From 7c82b0efae81a7ff6cc8ea5a384ece1e39c99f24 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 11:00:37 +0100
Subject: [PATCH 01/76] test(vntyper): fetch VNtyper test BAMs with curl and
 gzip, no Python

The Zenodo archive never changes, so the deflated bytes of each member sit
at a fixed offset. Pin them, fetch one range per member, and let gzip check
the CRC-32 and size the archive stores; the sha256 pin stays.

Bead: pgp-bs9u.39
---
 tests/e2e/vntyper-1.sh          |   4 +-
 tests/smoke/commands.tsv        |   2 +-
 tests/smoke/vntyper.sh          |   4 +-
 tests/smoke/vntyper_testdata.py | 103 --------------------------------
 tests/smoke/vntyper_testdata.sh |  65 ++++++++++++++++++++
 5 files changed, 70 insertions(+), 108 deletions(-)
 delete mode 100644 tests/smoke/vntyper_testdata.py
 create mode 100755 tests/smoke/vntyper_testdata.sh

diff --git a/tests/e2e/vntyper-1.sh b/tests/e2e/vntyper-1.sh
index 7cf376973..9e30e05dd 100755
--- a/tests/e2e/vntyper-1.sh
+++ b/tests/e2e/vntyper-1.sh
@@ -5,7 +5,7 @@
 #     over MUC1): VNtyper has nothing to read, and the step says "not
 #     assessed" with that reason, never "negative";
 #   - two BAMs of VNtyper's own public test data (tests/smoke/
-#     vntyper_testdata.py reads them out of its Zenodo archive, sha256
+#     vntyper_testdata.sh reads them out of its Zenodo archive, sha256
 #     pinned): their reads over MUC1 carried onto the fixture's header and
 #     added to case 20's BAM, as a whole-genome BAM would hold them. The
 #     sample with a frameshift reads positive, with the variant, and the one
@@ -38,7 +38,7 @@ check "the fixture: the message says the BAM has no read over MUC1" has 'no read
 
 # --- VNtyper's positive and negative samples on the fixture's header -------------------
 check "VNtyper's two test BAMs download and match their sha256" \
-  retry python3 -I "${REPO}/tests/smoke/vntyper_testdata.py" "$T" positive.bam negative.bam
+  retry sh "${REPO}/tests/smoke/vntyper_testdata.sh" "$T" positive.bam negative.bam
 H="${SAMPLE}muc"
 for s in positive negative; do
   dk "$SAMTOOLS_IMAGE" samtools index "${T}/${s}.bam"
diff --git a/tests/smoke/commands.tsv b/tests/smoke/commands.tsv
index 11e807eb3..7ff8d98b9 100644
--- a/tests/smoke/commands.tsv
+++ b/tests/smoke/commands.tsv
@@ -52,7 +52,7 @@ PARASCOPY_IMAGE	net,also=PARASCOPY_DATA_VERSION	fullref,slice	sh /smoke/parascop
 PARAPHASE_IMAGE	net	fullref	v=${PARAPHASE_IMAGE##*:} && u=https://raw.githubusercontent.com/PacificBiosciences/paraphase/v${v%%--*}/tests/data/bams/HG01175_smn1_extracted.bam && wget -q -O hg.bam "$u" && wget -q -O hg.bam.bai "${u}.bai" && { printf '%s  hg.bam\n%s  hg.bam.bai\n' c9659364ad9e60e41ee4771cf92dc017313b6b75a1e08df3e8c0e95ef38eadca 8b5dd238fdf1cc508e85105ff2a157a2c3d73aa3f441d08afdba9458beecca51 | sha256sum -c || { echo 'the demo BAM or its index is not the file Paraphase v4.1.0 ships'; exit 1; }; } && paraphase -b hg.bam -r /in/ref.fa -o pp -p HG01175 -g smn1 -t 4 && cp pp/HG01175.paraphase.json smn1.json && rm -rf pp hg.bam hg.bam.bai	py "SMN1, SMN2 and SMN exon 7-8 deletion copy numbers of HG01175 as Paraphase's demo publishes them (2, 1, 1)" "import json; s = json.load(open('smn1.json'))['smn1']; print(json.dumps(s)[:3000]); r = s['region_specific_info']; c = (r['smn1_cn'], r['smn2_cn'], r['smn_del78_cn']); print(c); assert c == (2, 1, 1)"
 # MEGAnE's call needs a whole chromosome: on mini.fa's 500 kb it stops in its own code (IndexError). The e2e case mei-1 runs it on chr20.
 MEGANE_IMAGE	-	ref	build_kmerset -fa /in/mini.fa -prefix mini -outdir /out/mk && { call_genotype_38 -h > help.txt 2>&1 || true; }	at_least "repeated 32-mers in the k-mer set of mini.fa" "$(cat mk/mini.mi)" 1000; same "the .mk holds the 8-byte k-mers the .mi counts" "$(( $(wc -c < mk/mini.mk) / 8 ))" "$(cat mk/mini.mi)"; contains "call_genotype_38 takes the -mainchr step 50 passes" help.txt "-mainchr"; contains "and -no_sex_chr" help.txt "-no_sex_chr"; contains "and -only_ins" help.txt "-only_ins"
-# Step 52 on VNtyper's own test data, two BAMs read out of its Zenodo archive by range requests (tests/smoke/vntyper_testdata.py,
+# Step 52 on VNtyper's own test data, two BAMs read out of its Zenodo archive by range requests (tests/smoke/vntyper_testdata.sh,
 # sha256 pinned): a sample with a MUC1 VNTR frameshift must be called, and one without must be negative (the red control);
 # a BAM with no read over MUC1 must stop VNtyper with the message step 52 turns into "no read over MUC1".
 VNTYPER_IMAGE	net	-	sh /smoke/vntyper.sh	has "the positive sample: Kestrel calls a frameshift with high precision" "$(awk -F'\t' '$1 == "positive" {print $2}' calls.tsv)" "^High_Precision"; same "the negative sample: no call" "$(awk -F'\t' '$1 == "negative" {print $2}' calls.tsv)" Negative; at_least "the positive sample: mean depth over the VNTR" "$(awk -F'\t' '$1 == "positive" {print int($4)}' calls.tsv)" 100; at_least "the negative sample: mean depth over the VNTR" "$(awk -F'\t' '$1 == "negative" {print int($4)}' calls.tsv)" 100; same "a BAM with no read over MUC1: VNtyper stops with exit 1" "$(cat empty_rc.txt)" 1; contains "and its log names the empty read layout step 52 reads" empty.log "FASTQ layout .empty."; has "vntyper --version is the release of the image tag" "$(cat version.txt)" "${VNTYPER_IMAGE##*:}"
diff --git a/tests/smoke/vntyper.sh b/tests/smoke/vntyper.sh
index 0c3d7c7bb..cd4d6cec1 100644
--- a/tests/smoke/vntyper.sh
+++ b/tests/smoke/vntyper.sh
@@ -1,12 +1,12 @@
 # shellcheck shell=sh
 # VNTYPER_IMAGE row: what step 52 runs, on VNtyper's own public test data
-# (tests/smoke/vntyper_testdata.py fetches two BAMs out of its Zenodo archive):
+# (tests/smoke/vntyper_testdata.sh fetches two BAMs out of its Zenodo archive):
 # a sample with a MUC1 VNTR frameshift and one without. The image's samtools
 # indexes them, then VNtyper runs with the step's flags (and no IGV view in its HTML)
 # from /opt/vntyper,
 # the folder its config.json paths are relative to.
 set -e
-python3 /smoke/vntyper_testdata.py /out/data positive.bam negative.bam
+sh /smoke/vntyper_testdata.sh /out/data positive.bam negative.bam
 for s in positive negative; do
   samtools index "/out/data/${s}.bam"
   (cd /opt/vntyper && vntyper pipeline --bam "/out/data/${s}.bam" -o "/out/${s}" --sample-name "$s" \
diff --git a/tests/smoke/vntyper_testdata.py b/tests/smoke/vntyper_testdata.py
deleted file mode 100644
index b33731d94..000000000
--- a/tests/smoke/vntyper_testdata.py
+++ /dev/null
@@ -1,103 +0,0 @@
-#!/usr/bin/env python3
-"""Fetch members of VNtyper's public test data without the whole archive.
-
-VNtyper publishes its test BAMs as one 1.2 GB zip on Zenodo (record 19181821,
-"VNtyper 2.0 test data", the archive_file of tests/test_data_config.json in
-VNtyper v2.0.47). A zip keeps its file list at the end, so this script reads
-that list with an HTTP range request, then fetches and inflates only the
-members it is asked for, about 10 MB instead of 1.2 GB (the .bai files are
-not fetched: samtools index writes them). Each member is checked
-against the CRC-32 the archive stores and against the sha256 pinned below.
-
-Usage: vntyper_testdata.py OUTDIR NAME...   (NAME: a key of MEMBERS)
-Standard library only: it runs in VNTYPER_IMAGE's Python and on the host.
-"""
-import hashlib
-import os
-import struct
-import sys
-import time
-import urllib.request
-import zlib
-
-URL = "https://zenodo.org/records/19181821/files/data.zip?download=1"
-SIZE = 1174975271  # bytes; Zenodo lists md5 fdd5958d58c733cdca452f3287898964 for the whole file
-
-# name -> (path in the archive, sha256 of the inflated file)
-MEMBERS = {
-    # Positive: a MUC1 VNTR frameshift VNtyper calls High_Precision* (its
-    # integration test example_dfc3_GRCh38_fast runs the same reads on NCBI
-    # contig names). Reads realigned by VNtyper to GRCh38 chr1, UCSC names.
-    "positive.bam": ("data/remapped/bwa/hg38/example_dfc3_hg38_bwa.bam",
-                     "5934330a8ac2144ac0cc6ae8c84d7d9262e90b28127417e4068f7d662b7c64bb"),
-    # Negative: no variant called (its integration test
-    # example_40cf_hg38_subset_fast_gdp_guard), mean VNTR depth about 148x.
-    "negative.bam": ("data/example_40cf_hg38_subset.bam",
-                     "44aff8e3b2096b7ea3529989660052c61b29c8a26afd7f48de4988f7047d0652"),
-}
-
-
-def get(start, end):
-    """Bytes start..end (inclusive) of the archive, with retries."""
-    for attempt in range(4):
-        try:
-            req = urllib.request.Request(URL, headers={"Range": f"bytes={start}-{end}"})
-            with urllib.request.urlopen(req, timeout=120) as r:
-                if r.status != 206:
-                    raise OSError(f"HTTP {r.status}, want 206 (a range)")
-                data = r.read()
-            if len(data) != end - start + 1:
-                raise OSError(f"got {len(data)} bytes, want {end - start + 1}")
-            return data
-        except OSError as e:
-            if attempt == 3:
-                raise
-            print(f"range {start}-{end}: {e}; again in {15 * (attempt + 1)} s", file=sys.stderr)
-            time.sleep(15 * (attempt + 1))
-    raise AssertionError("unreachable")
-
-
-def directory():
-    """{path: (method, crc, compressed size, size, local header offset)}"""
-    tail = get(SIZE - 65536, SIZE - 1)
-    i = tail.rfind(b"PK\x05\x06")
-    if i < 0:
-        raise SystemExit("no end-of-central-directory record in the last 64 kB")
-    _, _, _, _, n, cd_size, cd_off, _ = struct.unpack("<IHHHHIIH", tail[i:i + 22])
-    cd = get(cd_off, cd_off + cd_size - 1)
-    out, p = {}, 0
-    for _ in range(n):
-        f = struct.unpack("<IHHHHHHIIIHHHHHII", cd[p:p + 46])
-        if f[0] != 0x02014B50:
-            raise SystemExit(f"bad central directory entry at {p}")
-        nl, el, cl = f[10], f[11], f[12]
-        out[cd[p + 46:p + 46 + nl].decode()] = (f[4], f[7], f[8], f[9], f[16])
-        p += 46 + nl + el + cl
-    return out
-
-
-def main(argv):
-    if len(argv) < 2 or any(n not in MEMBERS for n in argv[1:]):
-        raise SystemExit(f"usage: {os.path.basename(__file__)} OUTDIR NAME... (NAME of {', '.join(MEMBERS)})")
-    outdir = argv[0]
-    os.makedirs(outdir, exist_ok=True)
-    cd = directory()
-    for name in argv[1:]:
-        path, want = MEMBERS[name]
-        method, crc, csize, size, off = cd[path]
-        head = get(off, off + 29)
-        nl, el = struct.unpack("<HH", head[26:30])
-        raw = get(off + 30 + nl + el, off + 30 + nl + el + csize - 1)
-        data = zlib.decompressobj(-15).decompress(raw) if method == 8 else raw
-        if len(data) != size or zlib.crc32(data) != crc:
-            raise SystemExit(f"{path}: size or CRC-32 differs from the archive's directory")
-        got = hashlib.sha256(data).hexdigest()
-        if got != want:
-            raise SystemExit(f"{path}: sha256 {got}, pinned {want}")
-        with open(os.path.join(outdir, name), "wb") as f:
-            f.write(data)
-        print(f"{name}\t{path}\t{size}\t{got}")
-
-
-if __name__ == "__main__":
-    main(sys.argv[1:])
diff --git a/tests/smoke/vntyper_testdata.sh b/tests/smoke/vntyper_testdata.sh
new file mode 100755
index 000000000..608c81e7e
--- /dev/null
+++ b/tests/smoke/vntyper_testdata.sh
@@ -0,0 +1,65 @@
+#!/bin/sh
+# Fetch members of VNtyper's public test data without the whole archive.
+#
+# VNtyper publishes its test BAMs as one 1.2 GB zip on Zenodo (record 19181821,
+# "VNtyper 2.0 test data", the archive_file of tests/test_data_config.json in
+# VNtyper v2.0.47). A Zenodo record never changes, so where each member's
+# deflated bytes sit in the archive is fixed: MEMBERS below pins it, read once
+# from the archive's central directory and the member's local header. This
+# script fetches only those bytes with one HTTP range request per member,
+# about 10 MB instead of 1.2 GB (the .bai files are not fetched: samtools
+# index writes them). It wraps them in a gzip header and a trailer holding the
+# CRC-32 and size the archive stores, so gzip inflates them and checks both,
+# and then checks the result against the pinned sha256. A wrong offset, a
+# changed archive or a cut transfer fails one of those checks.
+#
+# Usage: vntyper_testdata.sh OUTDIR NAME...   (NAME: positive.bam or negative.bam)
+# POSIX sh with curl, gzip and sha256sum: it runs in VNTYPER_IMAGE and on the host.
+set -eu
+
+URL="https://zenodo.org/records/19181821/files/data.zip?download=1"
+
+# member NAME: "path data_offset deflated_size size crc32 sha256" of NAME.
+member() {
+  case $1 in
+    # Positive: a MUC1 VNTR frameshift VNtyper calls High_Precision* (its
+    # integration test example_dfc3_GRCh38_fast runs the same reads on NCBI
+    # contig names). Reads realigned by VNtyper to GRCh38 chr1, UCSC names.
+    positive.bam) echo "data/remapped/bwa/hg38/example_dfc3_hg38_bwa.bam 1023038956 6194566 6194149 f8fa50d2 5934330a8ac2144ac0cc6ae8c84d7d9262e90b28127417e4068f7d662b7c64bb" ;;
+    # Negative: no variant called (its integration test
+    # example_40cf_hg38_subset_fast_gdp_guard), mean VNTR depth about 148x.
+    negative.bam) echo "data/example_40cf_hg38_subset.bam 154 3376349 3378669 286d97d5 44aff8e3b2096b7ea3529989660052c61b29c8a26afd7f48de4988f7047d0652" ;;
+    *) return 1 ;;
+  esac
+}
+
+# le32 N: N as four little-endian bytes.
+le32() {
+  printf '%b' "$(printf '\\0%03o\\0%03o\\0%03o\\0%03o' $(($1 & 255)) $(($1 >> 8 & 255)) $(($1 >> 16 & 255)) $(($1 >> 24 & 255)))"
+}
+
+[ $# -ge 2 ] || { echo "usage: vntyper_testdata.sh OUTDIR NAME... (NAME of positive.bam, negative.bam)" >&2; exit 2; }
+out=$1
+shift
+for name in "$@"; do
+  member "$name" > /dev/null || { echo "vntyper_testdata.sh: unknown member ${name} (positive.bam, negative.bam)" >&2; exit 2; }
+done
+mkdir -p "$out"
+for name in "$@"; do
+  read -r path off csize size crc want <<EOF
+$(member "$name")
+EOF
+  part="${out}/${name}.part"
+  curl -fsSL --retry 4 --retry-all-errors --retry-delay 15 -r "${off}-$((off + csize - 1))" -o "${part}.raw" "$URL"
+  got=$(wc -c < "${part}.raw" | tr -d ' ')
+  [ "$got" -eq "$csize" ] || { echo "${path}: got ${got} bytes, want ${csize} (the server ignored the range?)" >&2; exit 1; }
+  # gzip member: magic, deflate, no flags, no time, no extra flags, unknown OS;
+  # then the raw deflate stream; then CRC-32 and size, both little-endian.
+  { printf '\037\213\010\000\000\000\000\000\000\377'; cat "${part}.raw"; le32 "$((0x$crc))"; le32 "$size"; } > "${part}.gz"
+  gzip -dc "${part}.gz" > "$part" || { echo "${path}: size or CRC-32 differs from the archive's directory" >&2; exit 1; }
+  got=$(sha256sum "$part" | cut -d' ' -f1)
+  [ "$got" = "$want" ] || { echo "${path}: sha256 ${got}, pinned ${want}" >&2; exit 1; }
+  rm -f "${part}.raw" "${part}.gz"
+  mv "$part" "${out}/${name}"
+  printf '%s\t%s\t%s\t%s\n' "$name" "$path" "$size" "$got"
+done

From 463305a90714986c75c043b356e29e5e72bf6912 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 11:08:09 +0100
Subject: [PATCH 02/76] feat(dev): og dev fixture and og dev evidence verbs

og dev fixture comphet writes the compound-het fixture byte for byte
(CPython's Mersenne Twister for the seeded contig); og dev fixture
trim-pharmcat trims a PharmCAT report; og dev evidence clashes and
hg002-gvcf replace the public-evidence workflow's inline Python, streaming,
with the covered positions kept as merged spans. Parity cases against the
Python, and a golden for the site past a contig's end.

Bead: pgp-bs9u.39
---
 rust/crates/og-dev/src/evidence.rs            | 354 ++++++++++
 rust/crates/og-dev/src/fixture.rs             | 649 ++++++++++++++++++
 rust/crates/og-dev/src/lib.rs                 |  10 +-
 tests/parity/cases.tsv                        |  10 +
 .../past-the-end/stdout                       |   1 +
 .../inputs/dev-evidence-clashes/chrA.tsv.gz   | Bin 0 -> 58 bytes
 .../inputs/dev-evidence-clashes/chrB.tsv.gz   | Bin 0 -> 45 bytes
 .../inputs/dev-evidence-clashes/chrZ.tsv.gz   | Bin 0 -> 45 bytes
 .../inputs/dev-evidence-clashes/notes.tsv.gz  | Bin 0 -> 37 bytes
 .../inputs/dev-evidence-clashes/raw.vcf.gz    | Bin 0 -> 192 bytes
 .../inputs/dev-evidence-clashes/split.vcf.gz  | Bin 0 -> 192 bytes
 .../sites-past-end.tsv                        |   4 +
 .../inputs/dev-evidence-hg002-gvcf/sites.tsv  |  19 +
 .../truth-past-end.bed                        |   1 +
 .../inputs/dev-evidence-hg002-gvcf/truth.bed  |   4 +
 .../dev-evidence-hg002-gvcf/truth.vcf.gz      | Bin 0 -> 173 bytes
 tests/parity/oracle.ref                       |   4 +
 17 files changed, 1055 insertions(+), 1 deletion(-)
 create mode 100644 rust/crates/og-dev/src/evidence.rs
 create mode 100644 rust/crates/og-dev/src/fixture.rs
 create mode 100644 tests/parity/golden/dev-evidence-hg002-gvcf/past-the-end/stdout
 create mode 100644 tests/parity/inputs/dev-evidence-clashes/chrA.tsv.gz
 create mode 100644 tests/parity/inputs/dev-evidence-clashes/chrB.tsv.gz
 create mode 100644 tests/parity/inputs/dev-evidence-clashes/chrZ.tsv.gz
 create mode 100644 tests/parity/inputs/dev-evidence-clashes/notes.tsv.gz
 create mode 100644 tests/parity/inputs/dev-evidence-clashes/raw.vcf.gz
 create mode 100644 tests/parity/inputs/dev-evidence-clashes/split.vcf.gz
 create mode 100644 tests/parity/inputs/dev-evidence-hg002-gvcf/sites-past-end.tsv
 create mode 100644 tests/parity/inputs/dev-evidence-hg002-gvcf/sites.tsv
 create mode 100644 tests/parity/inputs/dev-evidence-hg002-gvcf/truth-past-end.bed
 create mode 100644 tests/parity/inputs/dev-evidence-hg002-gvcf/truth.bed
 create mode 100644 tests/parity/inputs/dev-evidence-hg002-gvcf/truth.vcf.gz

diff --git a/rust/crates/og-dev/src/evidence.rs b/rust/crates/og-dev/src/evidence.rs
new file mode 100644
index 000000000..c9b76d7fc
--- /dev/null
+++ b/rust/crates/og-dev/src/evidence.rs
@@ -0,0 +1,354 @@
+//! `og dev evidence`: the measurements of `.github/workflows/public-evidence.yml`
+//! on public data (GIAB's HG002), which were Python inside the workflow.
+//!
+//! - `og dev evidence clashes RAW.vcf.gz SPLIT.vcf.gz DATA_DIR OUT.tsv`: the
+//!   positions with two records or more, one of them an SNV, in the VCF as
+//!   GIAB writes it and split with `bcftools norm -m-`, on the chromosomes
+//!   of the archaic tables in DATA_DIR (`chr*.tsv.gz`), and how many rows of
+//!   those tables sit at such a position. OUT holds `raw_positions`,
+//!   `raw_on_table`, `split_positions` and `split_on_table`.
+//! - `og dev evidence hg002-gvcf TRUTH.vcf.gz TRUTH.bed REF.fasta SITES.tsv OUT.vcf`:
+//!   a gVCF of GIAB's genotypes plus a one-base reference block at every
+//!   panel site inside the benchmark regions that no GIAB record covers,
+//!   with the reference base from the FASTA (through its `.fai`). The
+//!   output is unsorted: the workflow sorts it with bcftools.
+//!
+//! Both stream their VCFs. hg002-gvcf keeps, per chromosome, the merged
+//! spans the GIAB records cover instead of every covered position, and
+//! reads one reference base per site with a positioned read.
+//!
+//! Exit 0 when written, 1 when an input cannot be read or parsed, 2 on a
+//! usage error.
+
+use std::collections::{BTreeMap, BTreeSet, HashMap};
+use std::fs::{self, File};
+use std::io::{BufRead, BufWriter, Write};
+use std::os::unix::fs::FileExt;
+use std::path::Path;
+
+const USAGE: &str = "usage: og dev evidence clashes RAW.vcf.gz SPLIT.vcf.gz DATA_DIR OUT.tsv\n       og dev evidence hg002-gvcf TRUTH.vcf.gz TRUTH.bed REF.fasta SITES.tsv OUT.vcf\n";
+
+/// Runs `og dev evidence ARGS`; returns the exit code.
+pub fn cli(args: &[String], out: &mut dyn Write, err: &mut dyn Write) -> u8 {
+    let usage = |err: &mut dyn Write, msg: &str| {
+        let _ = writeln!(err, "{USAGE}og dev evidence: error: {msg}");
+        2
+    };
+    let rest = args.get(1..).unwrap_or(&[]);
+    let result = match args.first().map(String::as_str) {
+        Some("clashes") if rest.len() == 4 => clashes(&rest[0], &rest[1], &rest[2], &rest[3]),
+        Some("hg002-gvcf") if rest.len() == 5 => {
+            hg002_gvcf(&rest[0], &rest[1], &rest[2], &rest[3], &rest[4]).map(|(records, blocks)| {
+                let _ = writeln!(
+                    out,
+                    "gVCF: {records} GIAB records, {blocks} reference blocks at panel sites"
+                );
+            })
+        }
+        Some("clashes" | "hg002-gvcf") => return usage(err, "wrong number of arguments"),
+        Some("-h" | "--help") => {
+            let _ = out.write_all(USAGE.as_bytes());
+            return 0;
+        }
+        Some(other) => return usage(err, &format!("unknown evidence '{other}'")),
+        None => return usage(err, "the following arguments are required: evidence"),
+    };
+    match result {
+        Ok(()) => 0,
+        Err(e) => {
+            let _ = writeln!(err, "og dev evidence: {e}");
+            1
+        }
+    }
+}
+
+fn open(path: &str) -> Result<Box<dyn BufRead>, String> {
+    og_io::open(path).map_err(|e| format!("{path}: {e}"))
+}
+
+/// Each line of `path` without its line end, to `f`.
+fn lines(path: &str, mut f: impl FnMut(&[u8]) -> Result<(), String>) -> Result<(), String> {
+    let mut r = open(path)?;
+    let mut buf = Vec::new();
+    loop {
+        buf.clear();
+        let n = r
+            .read_until(b'\n', &mut buf)
+            .map_err(|e| format!("{path}: {e}"))?;
+        if n == 0 {
+            return Ok(());
+        }
+        let line = buf.strip_suffix(b"\n").unwrap_or(&buf);
+        f(line.strip_suffix(b"\r").unwrap_or(line))?;
+    }
+}
+
+fn pos(field: &[u8], path: &str) -> Result<u64, String> {
+    std::str::from_utf8(field)
+        .ok()
+        .and_then(|s| s.trim().parse().ok())
+        .ok_or_else(|| {
+            format!(
+                "{path}: position '{}' is not a number",
+                String::from_utf8_lossy(field)
+            )
+        })
+}
+
+/// The positions of `path` on `chroms` with two records or more, one of
+/// them an SNV. The VCF is sorted, so a position's records are adjacent.
+fn clash_positions(
+    path: &str,
+    chroms: &BTreeSet<Vec<u8>>,
+) -> Result<BTreeSet<(Vec<u8>, u64)>, String> {
+    let mut hit = BTreeSet::new();
+    let (mut key, mut n, mut snvs): (Option<(Vec<u8>, u64)>, u32, u32) = (None, 0, 0);
+    lines(path, |line| {
+        if line.first() == Some(&b'#') {
+            return Ok(());
+        }
+        let c: Vec<&[u8]> = line.splitn(6, |&b| b == b'\t').collect();
+        if c.len() < 5 || !chroms.contains(c[0]) {
+            return Ok(());
+        }
+        let k = (c[0].to_vec(), pos(c[1], path)?);
+        if key.as_ref() != Some(&k) {
+            key = Some(k.clone());
+            (n, snvs) = (0, 0);
+        }
+        n += 1;
+        let one = |a: &[u8]| std::str::from_utf8(a).map_or(a.len(), |s| s.chars().count()) == 1;
+        snvs += u32::from(one(c[3]) && one(c[4]));
+        if n >= 2 && snvs >= 1 {
+            hit.insert(k);
+        }
+        Ok(())
+    })?;
+    Ok(hit)
+}
+
+fn clashes(raw: &str, split: &str, data: &str, out: &str) -> Result<(), String> {
+    let mut tables = BTreeMap::new();
+    for e in fs::read_dir(data).map_err(|e| format!("{data}: {e}"))? {
+        let name = e
+            .map_err(|e| format!("{data}: {e}"))?
+            .file_name()
+            .into_string()
+            .unwrap_or_default();
+        if let Some(chrom) = name
+            .strip_suffix(".tsv.gz")
+            .filter(|c| c.starts_with("chr"))
+        {
+            tables.insert(chrom.as_bytes().to_vec(), Path::new(data).join(&name));
+        }
+    }
+    let chroms: BTreeSet<Vec<u8>> = tables.keys().cloned().collect();
+    let sets = [
+        ("raw", clash_positions(raw, &chroms)?),
+        ("split", clash_positions(split, &chroms)?),
+    ];
+    let mut on_table = [0u64; 2];
+    for (chrom, table) in &tables {
+        let want: Vec<BTreeSet<u64>> = sets
+            .iter()
+            .map(|(_, s)| {
+                s.iter()
+                    .filter(|(c, _)| c == chrom)
+                    .map(|(_, p)| *p)
+                    .collect()
+            })
+            .collect();
+        if want.iter().all(BTreeSet::is_empty) {
+            continue;
+        }
+        let path = table.to_string_lossy().into_owned();
+        lines(&path, |line| {
+            let c: Vec<&[u8]> = line.splitn(3, |&b| b == b'\t').collect();
+            if c[0] != chrom.as_slice() || c.len() < 2 {
+                return Ok(());
+            }
+            let p = pos(c[1], &path)?;
+            for (k, w) in want.iter().enumerate() {
+                on_table[k] += u64::from(w.contains(&p));
+            }
+            Ok(())
+        })?;
+    }
+    let mut text = String::new();
+    for (k, (name, s)) in sets.iter().enumerate() {
+        text += &format!(
+            "{name}_positions\t{}\n{name}_on_table\t{}\n",
+            s.len(),
+            on_table[k]
+        );
+    }
+    fs::write(out, text).map_err(|e| format!("{out}: {e}"))
+}
+
+/// One `.fai` row: length, byte offset, bases per line, bytes per line.
+struct Fai {
+    len: u64,
+    offset: u64,
+    line_bases: u64,
+    line_bytes: u64,
+}
+
+fn read_fai(path: &str) -> Result<HashMap<Vec<u8>, Fai>, String> {
+    let mut fai = HashMap::new();
+    lines(path, |line| {
+        let f: Vec<&[u8]> = line.split(|&b| b == b'\t').collect();
+        let n = |i: usize| {
+            f.get(i)
+                .ok_or_else(|| format!("{path}: a row has fewer than 5 columns"))
+                .and_then(|x| pos(x, path))
+        };
+        let row = Fai {
+            len: n(1)?,
+            offset: n(2)?,
+            line_bases: n(3)?,
+            line_bytes: n(4)?,
+        };
+        if row.line_bases == 0 {
+            return Err(format!("{path}: a row has 0 bases per line"));
+        }
+        fai.insert(f[0].to_vec(), row);
+        Ok(())
+    })?;
+    Ok(fai)
+}
+
+/// Sorted, merged half-open spans `[start, end)` of 1-based positions.
+fn merge(mut spans: Vec<(u64, u64)>) -> Vec<(u64, u64)> {
+    spans.sort_unstable();
+    let mut out: Vec<(u64, u64)> = Vec::with_capacity(spans.len());
+    for (s, e) in spans {
+        match out.last_mut() {
+            Some(last) if s <= last.1 => last.1 = last.1.max(e),
+            _ => out.push((s, e)),
+        }
+    }
+    out
+}
+
+/// Is `p` inside one of the sorted, disjoint spans?
+fn inside(spans: &[(u64, u64)], p: u64) -> bool {
+    let i = spans.partition_point(|&(s, _)| s <= p);
+    i > 0 && p < spans[i - 1].1
+}
+
+fn hg002_gvcf(
+    truth: &str,
+    bed: &str,
+    reference: &str,
+    sites: &str,
+    out: &str,
+) -> Result<(u64, u64), String> {
+    let fai = read_fai(&format!("{reference}.fai"))?;
+    let fasta = File::open(reference).map_err(|e| format!("{reference}: {e}"))?;
+    // The benchmark regions, BED 0-based: (start, end) per chromosome,
+    // sorted. A site p (1-based) is confident when the region with the
+    // largest start below p ends at p or later, as the Python's bisect did.
+    let mut conf: HashMap<Vec<u8>, Vec<(u64, u64)>> = HashMap::new();
+    lines(bed, |line| {
+        let f: Vec<&[u8]> = line
+            .split(|b| b.is_ascii_whitespace())
+            .filter(|x| !x.is_empty())
+            .collect();
+        if f.is_empty() {
+            return Ok(());
+        }
+        if f.len() < 3 {
+            return Err(format!("{bed}: a row has fewer than 3 columns"));
+        }
+        conf.entry(f[0].to_vec())
+            .or_default()
+            .push((pos(f[1], bed)?, pos(f[2], bed)?));
+        Ok(())
+    })?;
+    for v in conf.values_mut() {
+        v.sort_unstable();
+    }
+    let confident = |c: &[u8], p: u64| {
+        conf.get(c).is_some_and(|v| {
+            let i = v.partition_point(|&(s, _)| s < p);
+            i > 0 && v[i - 1].1 >= p
+        })
+    };
+
+    let file = File::create(out).map_err(|e| format!("{out}: {e}"))?;
+    let mut w = BufWriter::with_capacity(1 << 20, file);
+    let werr = |e: std::io::Error| format!("{out}: {e}");
+    let mut covered: HashMap<Vec<u8>, Vec<(u64, u64)>> = HashMap::new();
+    let mut records = 0u64;
+    lines(truth, |line| {
+        if line.starts_with(b"##") {
+        } else if line.first() == Some(&b'#') {
+            w.write_all(b"##INFO=<ID=END,Number=1,Type=Integer,Description=\"End of the reference block\">\n##ALT=<ID=*,Description=\"Any other allele\">\n")
+                .map_err(werr)?;
+        } else {
+            let f: Vec<&[u8]> = line.splitn(6, |&b| b == b'\t').collect();
+            if f.len() < 5 {
+                return Err(format!("{truth}: a record has fewer than 5 columns"));
+            }
+            let p = pos(f[1], truth)?;
+            covered
+                .entry(f[0].to_vec())
+                .or_default()
+                .push((p, p + f[3].len() as u64));
+            records += 1;
+        }
+        w.write_all(line)
+            .and_then(|()| w.write_all(b"\n"))
+            .map_err(werr)
+    })?;
+    let covered: HashMap<Vec<u8>, Vec<(u64, u64)>> =
+        covered.into_iter().map(|(c, v)| (c, merge(v))).collect();
+
+    let mut blocks = 0u64;
+    let mut first = true;
+    let mut base = [0u8; 1];
+    lines(sites, |line| {
+        if std::mem::take(&mut first) {
+            return Ok(());
+        }
+        let f: Vec<&[u8]> = line.splitn(4, |&b| b == b'\t').collect();
+        if f.len() < 3 {
+            return Err(format!("{sites}: a row has fewer than 3 columns"));
+        }
+        let (c, p) = (f[1], pos(f[2], sites)?);
+        let Some(row) = fai.get(c) else { return Ok(()) };
+        if p == 0 || p > row.len || covered.get(c).is_some_and(|v| inside(v, p)) || !confident(c, p)
+        {
+            return Ok(());
+        }
+        let at =
+            row.offset + ((p - 1) / row.line_bases) * row.line_bytes + (p - 1) % row.line_bases;
+        fasta
+            .read_exact_at(&mut base, at)
+            .map_err(|e| format!("{reference}: {e}"))?;
+        let b = base[0].to_ascii_uppercase();
+        if !b"ACGT".contains(&b) {
+            return Ok(());
+        }
+        blocks += 1;
+        w.write_all(c)
+            .and_then(|()| writeln!(w, "\t{p}\t.\t{}\t<*>\t.\t.\tEND={p}\tGT\t0/0", b as char))
+            .map_err(werr)
+    })?;
+    w.flush().map_err(werr)?;
+    Ok((records, blocks))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn spans_merge_and_answer_inside() {
+        let m = merge(vec![(10, 12), (5, 6), (11, 15), (15, 16)]);
+        assert_eq!(m, [(5, 6), (10, 16)]);
+        assert!(
+            inside(&m, 5) && !inside(&m, 6) && inside(&m, 15) && !inside(&m, 16) && !inside(&m, 4)
+        );
+    }
+}
diff --git a/rust/crates/og-dev/src/fixture.rs b/rust/crates/og-dev/src/fixture.rs
new file mode 100644
index 000000000..bb163c9f9
--- /dev/null
+++ b/rust/crates/og-dev/src/fixture.rs
@@ -0,0 +1,649 @@
+//! `og dev fixture`: writers of committed or generated test fixtures.
+//!
+//! - `og dev fixture comphet OUT_DIR [--swap]`: the compound-het phasing
+//!   fixture of `tests/e2e/comphet-phasing-1-reads.sh` (made-up reads on a
+//!   made-up contig). It replaces `tests/fixtures/comphet/make_fixture.py`
+//!   and writes the same bytes: the contig is Python's `random.Random(31)`
+//!   choosing among `ACGT`, so [`Mt19937`] is CPython's generator.
+//! - `og dev fixture trim-pharmcat REPORT OUT [MAX_ANNOTATIONS]`: a PharmCAT
+//!   `report.json` cut down to the fields `og pgx` reads. It replaces
+//!   `tests/fixtures/pharmcat/trim_report.py` and writes the same bytes.
+//!
+//! Exit 0 when written, 1 when an input cannot be read or has the wrong
+//! shape, 2 on a usage error.
+
+use crate::py_os_error;
+use indexmap::IndexMap;
+use pycompat::json::{self, Dump, Value};
+use std::fmt::Write as _;
+use std::fs;
+use std::io::Write;
+use std::path::Path;
+
+const USAGE: &str = "usage: og dev fixture comphet OUT_DIR [--swap]\n       og dev fixture trim-pharmcat REPORT.json OUT.json [MAX_ANNOTATIONS]\n";
+
+/// Runs `og dev fixture ARGS`; returns the exit code.
+pub fn cli(args: &[String], out: &mut dyn Write, err: &mut dyn Write) -> u8 {
+    let usage = |err: &mut dyn Write, msg: &str| {
+        let _ = writeln!(err, "{USAGE}og dev fixture: error: {msg}");
+        2
+    };
+    let result = match args.first().map(String::as_str) {
+        Some("comphet") => {
+            let rest: Vec<&String> = args[1..].iter().filter(|a| *a != "--swap").collect();
+            if rest.len() != 1 {
+                return usage(err, "comphet takes one OUT_DIR and an optional --swap");
+            }
+            comphet::write(Path::new(rest[0]), args[1..].iter().any(|a| a == "--swap"))
+        }
+        Some("trim-pharmcat") => {
+            let rest = &args[1..];
+            if !(2..=3).contains(&rest.len()) {
+                return usage(
+                    err,
+                    "trim-pharmcat takes REPORT.json OUT.json [MAX_ANNOTATIONS]",
+                );
+            }
+            let max = match rest.get(2).map(|m| m.trim().parse::<i64>()) {
+                None => 4,
+                Some(Ok(n)) => n,
+                Some(Err(_)) => {
+                    return usage(
+                        err,
+                        &format!("MAX_ANNOTATIONS '{}' is not a whole number", rest[2]),
+                    );
+                }
+            };
+            trim_pharmcat(Path::new(&rest[0]), Path::new(&rest[1]), max)
+        }
+        Some("-h" | "--help") => {
+            let _ = out.write_all(USAGE.as_bytes());
+            return 0;
+        }
+        Some(other) => return usage(err, &format!("unknown fixture '{other}'")),
+        None => return usage(err, "the following arguments are required: fixture"),
+    };
+    match result {
+        Ok(()) => 0,
+        Err(e) => {
+            let _ = writeln!(err, "og dev fixture: {e}");
+            1
+        }
+    }
+}
+
+/// CPython's Mersenne Twister (`random.Random`), only as far as
+/// `Random(int).choice(seq)` needs it.
+pub struct Mt19937 {
+    state: [u32; 624],
+    index: usize,
+}
+
+impl Mt19937 {
+    /// `random.Random(seed)` for a seed below 2^32: `init_by_array([seed])`.
+    pub fn new(seed: u32) -> Self {
+        let mut mt = Mt19937 {
+            state: [0; 624],
+            index: 624,
+        };
+        mt.init_genrand(19_650_218);
+        let key = [seed];
+        let (mut i, mut j) = (1usize, 0usize);
+        for _ in 0..624.max(key.len()) {
+            let prev = mt.state[i - 1] ^ (mt.state[i - 1] >> 30);
+            mt.state[i] = (mt.state[i] ^ prev.wrapping_mul(1_664_525))
+                .wrapping_add(key[j])
+                .wrapping_add(j as u32);
+            i += 1;
+            j += 1;
+            if i >= 624 {
+                mt.state[0] = mt.state[623];
+                i = 1;
+            }
+            if j >= key.len() {
+                j = 0;
+            }
+        }
+        for _ in 0..623 {
+            let prev = mt.state[i - 1] ^ (mt.state[i - 1] >> 30);
+            mt.state[i] = (mt.state[i] ^ prev.wrapping_mul(1_566_083_941)).wrapping_sub(i as u32);
+            i += 1;
+            if i >= 624 {
+                mt.state[0] = mt.state[623];
+                i = 1;
+            }
+        }
+        mt.state[0] = 0x8000_0000;
+        mt
+    }
+
+    fn init_genrand(&mut self, s: u32) {
+        self.state[0] = s;
+        for i in 1..624 {
+            let prev = self.state[i - 1] ^ (self.state[i - 1] >> 30);
+            self.state[i] = 1_812_433_253u32.wrapping_mul(prev).wrapping_add(i as u32);
+        }
+        self.index = 624;
+    }
+
+    /// `genrand_uint32`.
+    pub fn next_u32(&mut self) -> u32 {
+        if self.index >= 624 {
+            for k in 0..624 {
+                let y = (self.state[k] & 0x8000_0000) | (self.state[(k + 1) % 624] & 0x7fff_ffff);
+                let mag = if y & 1 == 1 { 0x9908_b0df } else { 0 };
+                self.state[k] = self.state[(k + 397) % 624] ^ (y >> 1) ^ mag;
+            }
+            self.index = 0;
+        }
+        let mut y = self.state[self.index];
+        self.index += 1;
+        y ^= y >> 11;
+        y ^= (y << 7) & 0x9d2c_5680;
+        y ^= (y << 15) & 0xefc6_0000;
+        y ^ (y >> 18)
+    }
+
+    /// `_randbelow(n)` for `0 < n < 2^32`: rejection sampling on
+    /// `getrandbits(n.bit_length())`.
+    pub fn below(&mut self, n: u32) -> u32 {
+        let k = 32 - n.leading_zeros();
+        loop {
+            let r = self.next_u32() >> (32 - k);
+            if r < n {
+                return r;
+            }
+        }
+    }
+}
+
+pub mod comphet {
+    //! The compound-het phasing fixture: sample CHPH on contig chrP (80 kb
+    //! of seeded random sequence), read pairs of 100 bp from 500 bp
+    //! fragments, and three pairs of heterozygous variants:
+    //!
+    //! - GENEC: SNV at 1000 and a 2-base deletion at 1003, both on copy 1
+    //!   (cis); single reads cover both. `--swap` moves the deletion to
+    //!   copy 2 (trans).
+    //! - GENET: SNVs at 5000 and 5400, one on each copy (trans); only a read
+    //!   and its mate cover both.
+    //! - GENEF: SNVs at 20000 and 70000, one on each copy, 50 kb apart: no
+    //!   read pair covers both (unknown).
+    //!
+    //! Files: `reads.sam`, `vep.vcf` (with a VEP CSQ, for step 31) and
+    //! `comphet.vcf` (the pairs as slivar names them, for `og comphet
+    //! phase`).
+
+    use super::Mt19937;
+    use std::fmt::Write as _;
+    use std::fs;
+    use std::path::Path;
+
+    pub const SAMPLE: &str = "CHPH";
+    pub const CONTIG: &str = "chrP";
+    pub const LENGTH: usize = 80_000;
+    const READ: usize = 100;
+    const FRAG: usize = 500;
+    const FIELDS: &str = "Allele|Consequence|IMPACT|SYMBOL|Gene|Feature_type|Feature|BIOTYPE|CANONICAL|MANE_SELECT|Existing_variation|MAX_AF|gnomADe_AF|gnomADg_AF|CLIN_SIG";
+
+    /// One variant: 1-based position, alleles, consequence and the copy
+    /// (0 or 1) that carries it.
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    pub struct Variant {
+        pub gene: &'static str,
+        pub pos: usize,
+        pub alt_ref: String,
+        pub alt: String,
+        pub consequence: &'static str,
+        pub copy: u8,
+    }
+
+    /// The contig: `random.Random(31)` choosing among `ACGT` 80,000 times.
+    pub fn reference() -> Vec<u8> {
+        let mut rng = Mt19937::new(31);
+        (0..LENGTH)
+            .map(|_| b"ACGT"[rng.below(4) as usize])
+            .collect()
+    }
+
+    /// The base before `b` in `ACGT`, wrapping (`A` gives `T`).
+    fn other(b: u8) -> u8 {
+        let i = b"ACGT"
+            .iter()
+            .position(|&x| x == b)
+            .expect("a base of ACGT");
+        b"ACGT"[(i + 3) % 4]
+    }
+
+    pub fn variants(seq: &[u8], swap: bool) -> Vec<Variant> {
+        let s = |a: usize, b: usize| String::from_utf8_lossy(&seq[a..b]).into_owned();
+        let snv = |gene, pos: usize, consequence, copy| Variant {
+            gene,
+            pos,
+            alt_ref: s(pos - 1, pos),
+            alt: (other(seq[pos - 1]) as char).to_string(),
+            consequence,
+            copy,
+        };
+        vec![
+            snv("GENEC", 1000, "stop_gained", 0),
+            Variant {
+                gene: "GENEC",
+                pos: 1003,
+                alt_ref: s(1002, 1005),
+                alt: s(1002, 1003),
+                consequence: "frameshift_variant",
+                copy: u8::from(swap),
+            },
+            snv("GENET", 5000, "stop_gained", 0),
+            snv("GENET", 5400, "stop_gained", 1),
+            snv("GENEF", 20000, "stop_gained", 0),
+            snv("GENEF", 70000, "stop_gained", 1),
+        ]
+    }
+
+    /// The sequence and CIGAR of a read of `READ` bases from 0-based
+    /// `start` on one copy.
+    fn read_on(seq: &[u8], vs: &[Variant], copy: u8, start: usize) -> (String, String) {
+        let mine = || vs.iter().filter(|v| v.copy == copy);
+        let snv_at = |p: usize| {
+            mine()
+                .find(|v| v.alt_ref.len() == v.alt.len() && v.pos - 1 == p)
+                .map(|v| v.alt.as_bytes()[0])
+        };
+        // A deletion is keyed on the first deleted base.
+        let del_at = |p: usize| {
+            mine()
+                .find(|v| v.alt_ref.len() > v.alt.len() && v.pos + v.alt.len() - 1 == p)
+                .map(|v| v.alt_ref.len() - v.alt.len())
+        };
+        let (mut out, mut ops, mut p) =
+            (Vec::with_capacity(READ), Vec::<(u8, usize)>::new(), start);
+        while out.len() < READ {
+            if let Some(n) = del_at(p) {
+                ops.push((b'D', n));
+                p += n;
+                continue;
+            }
+            out.push(snv_at(p).unwrap_or(seq[p]));
+            ops.push((b'M', 1));
+            p += 1;
+        }
+        let mut cigar = String::new();
+        let mut i = 0;
+        while i < ops.len() {
+            let (op, mut n) = ops[i];
+            let mut j = i + 1;
+            while j < ops.len() && ops[j].0 == op {
+                n += ops[j].1;
+                j += 1;
+            }
+            let _ = write!(cigar, "{n}{}", op as char);
+            i = j;
+        }
+        (String::from_utf8_lossy(&out).into_owned(), cigar)
+    }
+
+    pub fn sam(seq: &[u8], vs: &[Variant]) -> String {
+        let mut s = format!(
+            "@HD\tVN:1.6\tSO:unsorted\n@SQ\tSN:{CONTIG}\tLN:{LENGTH}\n@RG\tID:{SAMPLE}\tSM:{SAMPLE}\n"
+        );
+        // Fragment starts (0-based) around each pair: read 1 covers the
+        // first position, its mate the second one when 400 bp apart.
+        let starts: [(&str, std::iter::StepBy<std::ops::Range<usize>>); 4] = [
+            ("c", (920..991).step_by(7)),
+            ("t", (4905..4996).step_by(10)),
+            ("f", (19905..19996).step_by(10)),
+            ("g", (69905..69996).step_by(10)),
+        ];
+        let q = "I".repeat(READ);
+        for (region, rs) in starts {
+            for copy in 0..2u8 {
+                for st in rs.clone() {
+                    let m = st + FRAG - READ;
+                    let (s1, c1) = read_on(seq, vs, copy, st);
+                    let (s2, c2) = read_on(seq, vs, copy, m);
+                    let name = format!("{region}{copy}_{st}");
+                    let _ = writeln!(
+                        s,
+                        "{name}\t99\t{CONTIG}\t{}\t60\t{c1}\t=\t{}\t{FRAG}\t{s1}\t{q}\tRG:Z:{SAMPLE}",
+                        st + 1,
+                        m + 1
+                    );
+                    let _ = writeln!(
+                        s,
+                        "{name}\t147\t{CONTIG}\t{}\t60\t{c2}\t=\t{}\t-{FRAG}\t{s2}\t{q}\tRG:Z:{SAMPLE}",
+                        m + 1,
+                        st + 1
+                    );
+                }
+            }
+        }
+        s
+    }
+
+    fn vcf_head(info: &str) -> String {
+        format!(
+            "##fileformat=VCFv4.2\n##contig=<ID={CONTIG},length={LENGTH}>\n##FILTER=<ID=PASS,Description=\"All filters passed\">\n{info}\
+             ##FORMAT=<ID=GT,Number=1,Type=String,Description=\"Genotype\">\n\
+             ##FORMAT=<ID=GQ,Number=1,Type=Integer,Description=\"Genotype quality\">\n\
+             ##FORMAT=<ID=DP,Number=1,Type=Integer,Description=\"Read depth\">\n\
+             ##FORMAT=<ID=AD,Number=R,Type=Integer,Description=\"Allele depths\">\n\
+             #CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\t{SAMPLE}\n"
+        )
+    }
+
+    pub fn vep_vcf(vs: &[Variant]) -> String {
+        let mut out = vcf_head(&format!(
+            "##INFO=<ID=CSQ,Number=.,Type=String,Description=\"Consequence annotations from Ensembl VEP. Format: {FIELDS}\">\n"
+        ));
+        for v in vs {
+            let (g, p) = (v.gene, v.pos);
+            let _ = writeln!(
+                out,
+                "{CONTIG}\t{p}\t.\t{}\t{}\t50\tPASS\tCSQ={}|{}|HIGH|{g}|ENSG{g}|Transcript|ENST{p}|protein_coding|YES|NM_{p}.1|rs{p}|0.0001|0.0001|0.0001|\tGT:GQ:DP:AD\t0/1:50:30:15,15",
+                v.alt_ref, v.alt, v.alt, v.consequence
+            );
+        }
+        out
+    }
+
+    pub fn comphet_vcf(vs: &[Variant]) -> String {
+        let mut out = vcf_head(
+            "##INFO=<ID=slivar_comphet,Number=.,Type=String,Description=\"compound hets called by slivar\">\n",
+        );
+        for (i, v) in vs.iter().enumerate() {
+            let mate = if i % 2 == 0 { &vs[i + 1] } else { &vs[i - 1] };
+            let pid = match v.gene {
+                "GENEC" => 1,
+                "GENET" => 2,
+                _ => 3,
+            };
+            let _ = writeln!(
+                out,
+                "{CONTIG}\t{}\t.\t{}\t{}\t50\tPASS\tslivar_comphet={SAMPLE}/{}/{pid}/{CONTIG}/{}/{}/{}\tGT:GQ:DP:AD\t0/1:50:30:15,15",
+                v.pos, v.alt_ref, v.alt, v.gene, mate.pos, mate.alt_ref, mate.alt
+            );
+        }
+        out
+    }
+
+    /// Writes the three files into `dir`, made if missing.
+    pub fn write(dir: &Path, swap: bool) -> Result<(), String> {
+        let seq = reference();
+        let vs = variants(&seq, swap);
+        fs::create_dir_all(dir).map_err(|e| format!("{}: {e}", dir.display()))?;
+        for (name, text) in [
+            ("reads.sam", sam(&seq, &vs)),
+            ("vep.vcf", vep_vcf(&vs)),
+            ("comphet.vcf", comphet_vcf(&vs)),
+        ] {
+            let path = dir.join(name);
+            fs::write(&path, text).map_err(|e| format!("{}: {e}", path.display()))?;
+        }
+        Ok(())
+    }
+}
+
+/// `x.get(k)`: the value, or JSON null.
+fn get(x: &IndexMap<String, Value>, k: &str) -> Value {
+    x.get(k).cloned().unwrap_or(Value::Null)
+}
+
+/// Python's truth of a JSON value.
+fn truthy(v: &Value) -> bool {
+    pycompat::value::truthy(v)
+}
+
+/// `v or []` as a list; a truthy value that is not a list is an error.
+fn list<'a>(v: Option<&'a Value>, what: &str) -> Result<&'a [Value], String> {
+    match v {
+        Some(Value::Array(a)) => Ok(a),
+        Some(x) if truthy(x) => Err(format!("{what} is not a list")),
+        _ => Ok(&[]),
+    }
+}
+
+fn object<'a>(v: &'a Value, what: &str) -> Result<&'a IndexMap<String, Value>, String> {
+    match v {
+        Value::Object(o) => Ok(o),
+        _ => Err(format!("{what} is not an object")),
+    }
+}
+
+/// The keys of `x` among `keys`, in that order.
+fn pick(x: &IndexMap<String, Value>, keys: &[&str]) -> IndexMap<String, Value> {
+    keys.iter()
+        .filter_map(|k| x.get(*k).map(|v| ((*k).to_owned(), v.clone())))
+        .collect()
+}
+
+/// One listed diplotype with the fields `og pgx` reads.
+fn diplotype(x: &Value) -> Result<Value, String> {
+    let Value::Object(x) = x else {
+        return Ok(x.clone());
+    };
+    let mut out = pick(
+        x,
+        &[
+            "gene",
+            "label",
+            "phenotypes",
+            "activityScore",
+            "outsidePhenotype",
+        ],
+    );
+    for a in ["allele1", "allele2"] {
+        let Some(v) = x.get(a) else { continue };
+        let kept = match v {
+            Value::Object(o) if !o.is_empty() => {
+                Value::Object(pick(o, &["gene", "name", "function"]))
+            }
+            v if !truthy(v) => v.clone(),
+            _ => return Err(format!("diplotype {a} is not an object")),
+        };
+        out.insert(a.to_owned(), kept);
+    }
+    Ok(Value::Object(out))
+}
+
+/// `items[:n]` with Python's slice rule for a negative `n`.
+fn head(items: &[Value], n: i64) -> &[Value] {
+    let len = items.len() as i64;
+    let end = if n < 0 { (len + n).max(0) } else { n.min(len) };
+    &items[..end as usize]
+}
+
+/// The trimmed report: every gene with its listed diplotypes and related
+/// drugs, and for each drug of each guidance source up to `max` of the
+/// annotations PharmCAT matched, with only the fields `og pgx` reads.
+pub fn trim(d: &Value, max: i64) -> Result<Value, String> {
+    let d = object(d, "the report")?;
+    let mut genes = IndexMap::new();
+    for (g, v) in object(d.get("genes").unwrap_or(&Value::Null), "genes")? {
+        let v = object(v, &format!("gene {g}"))?;
+        let mut gene = pick(v, &["geneSymbol", "chr", "phased", "callSource"]);
+        let mut related = Vec::new();
+        for r in list(v.get("relatedDrugs"), "relatedDrugs")? {
+            let r = object(r, "a related drug")?;
+            let name = r.get("name").ok_or("a related drug has no name")?.clone();
+            related.push(Value::Object(IndexMap::from([
+                ("name".to_owned(), name),
+                ("id".to_owned(), get(r, "id")),
+            ])));
+        }
+        gene.insert("relatedDrugs".to_owned(), Value::Array(related));
+        // sourceDiplotypes is what og pgx reads; recommendationDiplotypes
+        // only when sourceDiplotypes is absent, so it is kept only then.
+        let k = if v.get("sourceDiplotypes").is_some_and(truthy) {
+            "sourceDiplotypes"
+        } else {
+            "recommendationDiplotypes"
+        };
+        if v.contains_key(k) {
+            let dips = list(v.get(k), k)?
+                .iter()
+                .map(diplotype)
+                .collect::<Result<_, _>>()?;
+            gene.insert(k.to_owned(), Value::Array(dips));
+        }
+        genes.insert(g.clone(), Value::Object(gene));
+    }
+    let mut drugs: IndexMap<String, Value> = IndexMap::new();
+    for (source, by) in object(d.get("drugs").unwrap_or(&Value::Null), "drugs")? {
+        for (name, rep) in object(by, &format!("drugs of {source}"))? {
+            let rep = object(rep, &format!("drug {name}"))?;
+            let mut gls = Vec::new();
+            for gl in list(rep.get("guidelines"), "guidelines")? {
+                let gl = object(gl, "a guideline")?;
+                let mut anns = Vec::new();
+                for a in head(list(gl.get("annotations"), "annotations")?, max) {
+                    let a = object(a, "an annotation")?;
+                    let mut gts = Vec::new();
+                    for gt in list(a.get("genotypes"), "genotypes")? {
+                        let gt = object(gt, "a genotype")?;
+                        let dips = list(gt.get("diplotypes"), "diplotypes")?
+                            .iter()
+                            .filter_map(|x| match x {
+                                Value::Object(x) => Some(Value::Object(IndexMap::from([
+                                    ("gene".to_owned(), get(x, "gene")),
+                                    ("label".to_owned(), get(x, "label")),
+                                ]))),
+                                _ => None,
+                            })
+                            .collect();
+                        gts.push(Value::Object(IndexMap::from([(
+                            "diplotypes".to_owned(),
+                            Value::Array(dips),
+                        )])));
+                    }
+                    anns.push(Value::Object(IndexMap::from([
+                        ("phenotypes".to_owned(), get(a, "phenotypes")),
+                        ("classification".to_owned(), get(a, "classification")),
+                        (
+                            "drugRecommendation".to_owned(),
+                            get(a, "drugRecommendation"),
+                        ),
+                        ("genotypes".to_owned(), Value::Array(gts)),
+                    ])));
+                }
+                if !anns.is_empty() {
+                    gls.push(Value::Object(IndexMap::from([
+                        ("name".to_owned(), get(gl, "name")),
+                        ("source".to_owned(), get(gl, "source")),
+                        ("annotations".to_owned(), Value::Array(anns)),
+                    ])));
+                }
+            }
+            if !gls.is_empty() {
+                let entry = drugs
+                    .entry(source.clone())
+                    .or_insert_with(|| Value::Object(IndexMap::new()));
+                if let Value::Object(e) = entry {
+                    e.insert(
+                        name.clone(),
+                        Value::Object(IndexMap::from([
+                            ("name".to_owned(), get(rep, "name")),
+                            ("id".to_owned(), get(rep, "id")),
+                            ("guidelines".to_owned(), Value::Array(gls)),
+                        ])),
+                    );
+                }
+            }
+        }
+    }
+    let mut out = pick(d, &["title", "timestamp", "pharmcatVersion", "dataVersion"]);
+    out.insert("genes".to_owned(), Value::Object(genes));
+    out.insert("drugs".to_owned(), Value::Object(drugs));
+    let mut note = String::new();
+    let _ = write!(
+        note,
+        "Trimmed by og dev fixture trim-pharmcat: every gene, and up to {max} matched annotations per drug guideline, with only the fields og pgx reads."
+    );
+    out.insert("_fixture_note".to_owned(), Value::Str(note));
+    Ok(Value::Object(out))
+}
+
+fn trim_pharmcat(src: &Path, dst: &Path, max: i64) -> Result<(), String> {
+    let text = fs::read(src).map_err(|e| py_os_error(&e, &src.to_string_lossy()))?;
+    let text = String::from_utf8(text).map_err(|_| format!("{}: not UTF-8", src.display()))?;
+    let d = json::loads(&text).map_err(|e| format!("{}: {e}", src.display()))?;
+    let out = trim(&d, max)?;
+    let opts = Dump {
+        separators: Some((",", ":")),
+        ..Dump::default()
+    };
+    let text = json::dumps(&out, &opts).map_err(|e| e.to_string())?;
+    fs::write(dst, text).map_err(|e| py_os_error(&e, &dst.to_string_lossy()))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn mt19937_matches_cpython() {
+        // random.Random(31): [r.getrandbits(32) for _ in range(3)] and the
+        // first ten of "".join(r.choice("ACGT") ...) from a fresh seed.
+        let mut r = Mt19937::new(31);
+        let first: Vec<u32> = (0..3).map(|_| r.next_u32()).collect();
+        assert_eq!(first, [52_734_659, 2_016_822_975, 482_749_413]);
+        assert_eq!(&comphet::reference()[..10], b"ATATCACACC");
+    }
+
+    #[test]
+    fn swap_moves_only_the_deletion() {
+        let seq = comphet::reference();
+        let (a, b) = (
+            comphet::variants(&seq, false),
+            comphet::variants(&seq, true),
+        );
+        assert_eq!(a[1].copy, 0);
+        assert_eq!(b[1].copy, 1);
+        assert_eq!(a[0], b[0]);
+        assert_eq!(a[2..], b[2..]);
+    }
+
+    #[test]
+    fn a_read_over_the_deletion_has_a_d_in_its_cigar() {
+        let seq = comphet::reference();
+        let vs = comphet::variants(&seq, false);
+        let sam = comphet::sam(&seq, &vs);
+        let line = sam
+            .lines()
+            .find(|l| l.starts_with("c0_920\t99"))
+            .expect("read c0_920");
+        assert!(line.contains("\t83M2D17M\t"), "{line}");
+        let line = sam
+            .lines()
+            .find(|l| l.starts_with("c1_920\t99"))
+            .expect("read c1_920");
+        assert!(line.contains("\t100M\t"), "{line}");
+    }
+
+    #[test]
+    fn trim_keeps_the_fields_og_pgx_reads() {
+        let d = json::loads(
+            r#"{"title":"t","extra":1,"genes":{"G":{"geneSymbol":"G","x":1,"relatedDrugs":[{"name":"d"}],
+            "sourceDiplotypes":[],"recommendationDiplotypes":[{"label":"*1/*2","allele1":{"name":"*1","y":2},"allele2":null,"z":3},"str"]}},
+            "drugs":{"CPIC":{"d":{"name":"d","guidelines":[{"name":"g","annotations":[{"genotypes":[{"diplotypes":[{"gene":"G"},5]}]},{},{}]},{"annotations":[]}]}}}}"#,
+        )
+        .expect("json");
+        let out = trim(&d, 2).expect("trim");
+        let text = json::dumps(
+            &out,
+            &Dump {
+                separators: Some((",", ":")),
+                ..Dump::default()
+            },
+        )
+        .expect("dumps");
+        assert!(text.starts_with(r#"{"title":"t","genes":{"G":{"geneSymbol":"G","relatedDrugs":[{"name":"d","id":null}],"recommendationDiplotypes":[{"label":"*1/*2","allele1":{"name":"*1"},"allele2":null},"str"]}}"#), "{text}");
+        assert!(text.contains(r#""annotations":[{"phenotypes":null,"classification":null,"drugRecommendation":null,"genotypes":[{"diplotypes":[{"gene":"G","label":null}]}]},{"phenotypes":null"#), "{text}");
+        assert_eq!(text.matches("drugRecommendation").count(), 2, "{text}");
+        // A negative count is Python's slice: all but the last.
+        let out = trim(&d, -2).expect("trim");
+        let text = json::dumps(&out, &Dump::default()).expect("dumps");
+        assert_eq!(text.matches("drugRecommendation").count(), 1, "{text}");
+    }
+}
diff --git a/rust/crates/og-dev/src/lib.rs b/rust/crates/og-dev/src/lib.rs
index 55c93fdf0..918237714 100644
--- a/rust/crates/og-dev/src/lib.rs
+++ b/rust/crates/og-dev/src/lib.rs
@@ -12,8 +12,14 @@
 //!   the report carries the report-only error strategy.
 //! - `og dev remnants` ([`remnants`]): does each Python file kept only for
 //!   its importers (`tests/parity/remnants.tsv`) hold nothing else?
+//! - `og dev fixture` ([`fixture`]): writers of test fixtures (the
+//!   compound-het reads, a trimmed PharmCAT report).
+//! - `og dev evidence` ([`evidence`]): the measurements of the public
+//!   evidence workflow on GIAB's HG002.
 
 pub mod contract;
+pub mod evidence;
+pub mod fixture;
 pub mod parity;
 pub mod remnants;
 pub mod report_only;
@@ -22,7 +28,7 @@ mod zip;
 
 use std::io::Write;
 
-const USAGE: &str = "usage: og dev parity-compare KIND ORACLE NEW\n       og dev parity-compare --self-test\n       og dev contract --static [--repo DIR] [--contract FILE]\n       og dev contract --outputs DIR --leg bash|nextflow --sample S [--observe]\n       og dev schema SCHEMA.json DOC.json\n       og dev report-only [--repo DIR]\n       og dev remnants [--list FILE] [--root DIR]\n";
+const USAGE: &str = "usage: og dev parity-compare KIND ORACLE NEW\n       og dev parity-compare --self-test\n       og dev contract --static [--repo DIR] [--contract FILE]\n       og dev contract --outputs DIR --leg bash|nextflow --sample S [--observe]\n       og dev schema SCHEMA.json DOC.json\n       og dev report-only [--repo DIR]\n       og dev remnants [--list FILE] [--root DIR]\n       og dev fixture comphet|trim-pharmcat [args]\n       og dev evidence clashes|hg002-gvcf [args]\n";
 
 /// Python's `str(OSError)`: `[Errno 2] No such file or directory: 'path'`.
 pub(crate) fn py_os_error(e: &std::io::Error, path: &str) -> String {
@@ -57,6 +63,8 @@ pub fn main(args: &[String]) -> u8 {
         Some("contract") => run(contract::cli, &args[1..]),
         Some("schema") => run(schema::cli, &args[1..]),
         Some("report-only") => run(report_only::cli, &args[1..]),
+        Some("fixture") => run(fixture::cli, &args[1..]),
+        Some("evidence") => run(evidence::cli, &args[1..]),
         Some("-h" | "--help") => {
             print!("{USAGE}");
             0
diff --git a/tests/parity/cases.tsv b/tests/parity/cases.tsv
index 795bb7945..692b0f540 100644
--- a/tests/parity/cases.tsv
+++ b/tests/parity/cases.tsv
@@ -874,3 +874,13 @@ family-ibd	mapbp	gen:ibd-oracle.sh,gen:ibd-cases.sh	--pedigree mapbp/pedigree.ts
 family-ibd	nomap	gen:ibd-oracle.sh,gen:ibd-cases.sh	--pedigree nomap/pedigree.tsv --chroms nomap/chroms.txt --maps nomap/maps --phased nomap/phased --ibd nomap/ibd --out-dir out	-	content	PYTHON_IMAGE
 family-ibd	short	gen:ibd-oracle.sh,gen:ibd-cases.sh	--pedigree short/pedigree.tsv --chroms short/chroms.txt --maps short/maps --phased short/phased --ibd short/ibd --out-dir out	-	content	PYTHON_IMAGE
 family-ibd	twice	gen:ibd-oracle.sh,gen:ibd-cases.sh	--pedigree twice/pedigree.tsv --chroms twice/chroms.txt --maps twice/maps --phased twice/phased --ibd twice/ibd --out-dir out	-	content	PYTHON_IMAGE
+dev-fixture-comphet	plain	-	out	out/reads.sam,out/vep.vcf,out/comphet.vcf	bytes	PYTHON_IMAGE
+dev-fixture-comphet	swap	-	out --swap	out/reads.sam,out/vep.vcf,out/comphet.vcf	bytes	PYTHON_IMAGE
+dev-fixture-trim-pharmcat	report-3.2.0	gen:pgx-fixtures.sh	report-3.2.0.json out.json	out.json	json:mask=_fixture_note	PYTHON_IMAGE
+dev-fixture-trim-pharmcat	report-3.4.0	gen:pgx-fixtures.sh	report-3.4.0.json out.json	out.json	json:mask=_fixture_note	PYTHON_IMAGE
+dev-fixture-trim-pharmcat	pharmcat-docs-example	gen:pgx-fixtures.sh	pharmcat-docs-example.json out.json	out.json	json:mask=_fixture_note	PYTHON_IMAGE
+dev-fixture-trim-pharmcat	one-annotation	gen:pgx-fixtures.sh	report-3.4.0.json out.json 1	out.json	json:mask=_fixture_note	PYTHON_IMAGE
+dev-fixture-trim-pharmcat	all-but-last	gen:pgx-fixtures.sh	pharmcat-docs-example.json out.json -1	out.json	json:mask=_fixture_note	PYTHON_IMAGE
+dev-evidence-clashes	synthetic	dev-evidence-clashes/raw.vcf.gz,dev-evidence-clashes/split.vcf.gz,dev-evidence-clashes/chrA.tsv.gz,dev-evidence-clashes/chrB.tsv.gz,dev-evidence-clashes/chrZ.tsv.gz,dev-evidence-clashes/notes.tsv.gz	raw.vcf.gz split.vcf.gz . affected.tsv	affected.tsv	bytes	PYTHON_IMAGE
+dev-evidence-hg002-gvcf	synthetic	dev-evidence-hg002-gvcf/truth.vcf.gz,dev-evidence-hg002-gvcf/truth.bed,dev-evidence-hg002-gvcf/ref.fasta,dev-evidence-hg002-gvcf/ref.fasta.fai,dev-evidence-hg002-gvcf/sites.tsv	truth.vcf.gz truth.bed ref.fasta sites.tsv out.vcf	out.vcf	bytes	PYTHON_IMAGE
+dev-evidence-hg002-gvcf	past-the-end	dev-evidence-hg002-gvcf/truth.vcf.gz,dev-evidence-hg002-gvcf/truth-past-end.bed,dev-evidence-hg002-gvcf/ref.fasta,dev-evidence-hg002-gvcf/ref.fasta.fai,dev-evidence-hg002-gvcf/sites-past-end.tsv	truth.vcf.gz truth-past-end.bed ref.fasta sites-past-end.tsv out.vcf	out.vcf	bytes	PYTHON_IMAGE
diff --git a/tests/parity/golden/dev-evidence-hg002-gvcf/past-the-end/stdout b/tests/parity/golden/dev-evidence-hg002-gvcf/past-the-end/stdout
new file mode 100644
index 000000000..233285d28
--- /dev/null
+++ b/tests/parity/golden/dev-evidence-hg002-gvcf/past-the-end/stdout
@@ -0,0 +1 @@
+gVCF: 4 GIAB records, 1 reference blocks at panel sites
diff --git a/tests/parity/inputs/dev-evidence-clashes/chrA.tsv.gz b/tests/parity/inputs/dev-evidence-clashes/chrA.tsv.gz
new file mode 100644
index 0000000000000000000000000000000000000000..5dc766e8d450338fc6372800f67e9c3fc0ecd581
GIT binary patch
literal 58
zcmb2|=3oE;rvKjOG)|p=s&hjBS;-kq&ofWF&S?}qF?nXvV92A$Q#_-CwI?x!VG1)t
Lh}*wOc0e5fk|7n8

literal 0
HcmV?d00001

diff --git a/tests/parity/inputs/dev-evidence-clashes/chrB.tsv.gz b/tests/parity/inputs/dev-evidence-clashes/chrB.tsv.gz
new file mode 100644
index 0000000000000000000000000000000000000000..2ff2824f7570b5fb663c33b4e8d667bcf2f245de
GIT binary patch
literal 45
ycmb2|=3oE;rvKjOG)|p=s&hjBS;-kq&ofWF&S?}qGI?t9fQg}K^O3odKt%wPJ`z9x

literal 0
HcmV?d00001

diff --git a/tests/parity/inputs/dev-evidence-clashes/chrZ.tsv.gz b/tests/parity/inputs/dev-evidence-clashes/chrZ.tsv.gz
new file mode 100644
index 0000000000000000000000000000000000000000..987e91c2ce6814ccb80b83d2cf042cfeb10c57d8
GIT binary patch
literal 45
ycmb2|=3oE;rvKjOG)|p=s&hjBS;-kq&ofWF&S`W#GI?V1fQjMq66L>=Kt%wRY7%Gw

literal 0
HcmV?d00001

diff --git a/tests/parity/inputs/dev-evidence-clashes/notes.tsv.gz b/tests/parity/inputs/dev-evidence-clashes/notes.tsv.gz
new file mode 100644
index 0000000000000000000000000000000000000000..035133bbf944bc169e37959bc9f666d9342e05d7
GIT binary patch
literal 37
qcmb2|=3oE;rvKjOG)|p=s&hjBnb$duqGu*gm>9BVi~JA-N&*1&xD8MM

literal 0
HcmV?d00001

diff --git a/tests/parity/inputs/dev-evidence-clashes/raw.vcf.gz b/tests/parity/inputs/dev-evidence-clashes/raw.vcf.gz
new file mode 100644
index 0000000000000000000000000000000000000000..386cc04141ddaee0666a6957d26e90295f313b42
GIT binary patch
literal 192
zcmV;x06+g9iwFP!00002|9#Ct3xYrp1>p1RZ+Hz`E$NcMw7Dv1Te@`*Q4`8Qq~D(#
z1wm`aneV+B%c`1dS>3zax%W?8JQlV)v8>|W_D$`t;;mm?I+|X~w(c*!$JRf%`QTh5
zk20BJFLT6OWPt!B3Wp;l5OJb{4Dn7#2$`j%5QU7n6a4^l*a)HEG3+VN^`yXN&X>{<
uF!OSl34A(MciFJuqxCnFkvH)4b@iWhz{DKRi^IQa=sp1(Jr?Yk0RR9Ton2f2

literal 0
HcmV?d00001

diff --git a/tests/parity/inputs/dev-evidence-clashes/split.vcf.gz b/tests/parity/inputs/dev-evidence-clashes/split.vcf.gz
new file mode 100644
index 0000000000000000000000000000000000000000..4a4e80c1e428b4fbd7e40229992c3d58421c08b6
GIT binary patch
literal 192
zcmV;x06+g9iwFP!00002|9#EP3W7is1>p7ZHQa`cnzYGa932%jOQ-fB{(&io^!zzd
z5Tq{e{mwmCRm-L=%6@p<NBhS3bEg@Ks^)z+HkEw{T|2J_x@n898f)7k$3JwwXi8*3
zn#4FK8A2DS$3Y{3%aumpVI;g1;fW{UNg7juz$e5|<O7({;6uP7IMXbXlK|Q3KT4;-
uJnyHOg01ROwLzu@Tde*ton;4>>=x@R19Qxvzu8~ancEjXPPgc^0RRAO6I%5E

literal 0
HcmV?d00001

diff --git a/tests/parity/inputs/dev-evidence-hg002-gvcf/sites-past-end.tsv b/tests/parity/inputs/dev-evidence-hg002-gvcf/sites-past-end.tsv
new file mode 100644
index 000000000..bb13404a5
--- /dev/null
+++ b/tests/parity/inputs/dev-evidence-hg002-gvcf/sites-past-end.tsv
@@ -0,0 +1,4 @@
+id	chrom	pos
+s1	chrB	30
+s2	chrB	31
+s3	chrB	35
diff --git a/tests/parity/inputs/dev-evidence-hg002-gvcf/sites.tsv b/tests/parity/inputs/dev-evidence-hg002-gvcf/sites.tsv
new file mode 100644
index 000000000..b6a517815
--- /dev/null
+++ b/tests/parity/inputs/dev-evidence-hg002-gvcf/sites.tsv
@@ -0,0 +1,19 @@
+id	chrom	pos	ref
+s0	chrA	3	X
+s1	chrA	11	X
+s2	chrA	12	X
+s3	chrA	13	X
+s4	chrA	15	X
+s5	chrA	16	X
+s6	chrA	19	X
+s7	chrA	21	X
+s8	chrA	27	X
+s9	chrA	45	X
+s10	chrA	46	X
+s11	chrB	3	X
+s12	chrB	8	X
+s13	chrB	10	X
+s14	chrB	30	X
+s15	chrC	1	X
+s16	chrD	4	X
+s17	chrA	1	X
diff --git a/tests/parity/inputs/dev-evidence-hg002-gvcf/truth-past-end.bed b/tests/parity/inputs/dev-evidence-hg002-gvcf/truth-past-end.bed
new file mode 100644
index 000000000..d6806d6ff
--- /dev/null
+++ b/tests/parity/inputs/dev-evidence-hg002-gvcf/truth-past-end.bed
@@ -0,0 +1 @@
+chrB	0	40
diff --git a/tests/parity/inputs/dev-evidence-hg002-gvcf/truth.bed b/tests/parity/inputs/dev-evidence-hg002-gvcf/truth.bed
new file mode 100644
index 000000000..6a2ed2e11
--- /dev/null
+++ b/tests/parity/inputs/dev-evidence-hg002-gvcf/truth.bed
@@ -0,0 +1,4 @@
+chrA	18	45
+chrA	0	15
+chrB	0	30
+chrC	0	10
diff --git a/tests/parity/inputs/dev-evidence-hg002-gvcf/truth.vcf.gz b/tests/parity/inputs/dev-evidence-hg002-gvcf/truth.vcf.gz
new file mode 100644
index 0000000000000000000000000000000000000000..f13c00115d4f489b2140634ee513945ddb31d804
GIT binary patch
literal 173
zcmV;e08;-SiwFP!00002|8>pF3W7iw1>p7ZHD((&YC?-97)M71O&h27A>P0gM0);|
zXk{(W`Th$bb=Oz*I6WUTy9@a`n6^PkISzBzuv6@_vYq&@uZCuBnM=<b^uFk<C?b`m
z$g={m4;4u8MB{qn31pn;Kq0=!3^G$G*N8$&ZDV}^2PQ&jxD+`riZyA_z4cLxE`?Yc
b@pHh#arHmz0@jlGa(<(4KKo>K{r~^~M%hj3

literal 0
HcmV?d00001

diff --git a/tests/parity/oracle.ref b/tests/parity/oracle.ref
index 226fc54b2..ca861a0ed 100644
--- a/tests/parity/oracle.ref
+++ b/tests/parity/oracle.ref
@@ -58,3 +58,7 @@ mito-copies	954ab367004d63ea639521982299b4976927ccfd	file:bin/collect_summary.py
 lookup	0baddb45aa3871a57469cf20295bdd832f72f5c0	file:bin/genome_lookup.py	python3	lookup
 lookup-query	0baddb45aa3871a57469cf20295bdd832f72f5c0	file:bin/genome_lookup.py	bash ./oracle.sh	lookup query
 family-ibd	0baddb45aa3871a57469cf20295bdd832f72f5c0	file:bin/ibd_report.py	sh ./ibd_oracle.sh	family ibd
+dev-fixture-comphet	fe6b67e09cef81c396c2277472df10407c56d7ac	file:tests/fixtures/comphet/make_fixture.py	python3	dev fixture comphet
+dev-fixture-trim-pharmcat	fe6b67e09cef81c396c2277472df10407c56d7ac	file:tests/fixtures/pharmcat/trim_report.py	python3	dev fixture trim-pharmcat
+dev-evidence-clashes	fe6b67e09cef81c396c2277472df10407c56d7ac	file:.github/workflows/public-evidence.yml	sh -c 'd=$(mktemp -d) && awk -v n=1 "/<<.PY.\$/ {k++; if (k == n) {on = 1; next}} on && /^ *PY\$/ {exit} on {sub(/^          /, \"\"); print}" "$0" > "$d/p.py" && exec python3 -I "$d/p.py" "$@"'	dev evidence clashes
+dev-evidence-hg002-gvcf	fe6b67e09cef81c396c2277472df10407c56d7ac	file:.github/workflows/public-evidence.yml	sh -c 'd=$(mktemp -d) && awk -v n=2 "/<<.PY.\$/ {k++; if (k == n) {on = 1; next}} on && /^ *PY\$/ {exit} on {sub(/^          /, \"\"); print}" "$0" > "$d/p.py" && exec python3 -I "$d/p.py" "$@"'	dev evidence hg002-gvcf

From 1ec05547d9a382e213ebf9dfca50022418dac0a1 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 11:09:59 +0100
Subject: [PATCH 03/76] feat(og): og dev scan, versions and pgs verbs for the
 CI scanners

The personal-data scan, the image scan, the coupled-version check, the
run-versions check, the URL expander of check-links.sh and the PGS Catalog
answer readers, ported from the Python inside five scripts/ci scripts.

Bead: pgp-bs9u.37
---
 rust/crates/og-dev/Cargo.toml           |   2 +-
 rust/crates/og-dev/src/images.rs        | 406 ++++++++++++++++++
 rust/crates/og-dev/src/lib.rs           |  42 +-
 rust/crates/og-dev/src/lookaround.rs    | 103 +++++
 rust/crates/og-dev/src/personal_data.rs | 538 ++++++++++++++++++++++++
 rust/crates/og-dev/src/pgs.rs           | 320 ++++++++++++++
 rust/crates/og-dev/src/versions.rs      | 263 ++++++++++++
 rust/crates/og-dev/src/versions_env.rs  | 115 +++++
 rust/og/src/main.rs                     |   3 +
 9 files changed, 1785 insertions(+), 7 deletions(-)
 create mode 100644 rust/crates/og-dev/src/images.rs
 create mode 100644 rust/crates/og-dev/src/lookaround.rs
 create mode 100644 rust/crates/og-dev/src/personal_data.rs
 create mode 100644 rust/crates/og-dev/src/pgs.rs
 create mode 100644 rust/crates/og-dev/src/versions.rs
 create mode 100644 rust/crates/og-dev/src/versions_env.rs

diff --git a/rust/crates/og-dev/Cargo.toml b/rust/crates/og-dev/Cargo.toml
index 20bcd7e4c..108491221 100644
--- a/rust/crates/og-dev/Cargo.toml
+++ b/rust/crates/og-dev/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "og-dev"
-description = "og dev: the developer and CI verbs: parity-compare, contract, schema, report-only"
+description = "og dev: the developer and CI verbs: parity-compare, contract, schema, report-only, scans and version checks"
 version.workspace = true
 edition.workspace = true
 license.workspace = true
diff --git a/rust/crates/og-dev/src/images.rs b/rust/crates/og-dev/src/images.rs
new file mode 100644
index 000000000..91ded0e7f
--- /dev/null
+++ b/rust/crates/og-dev/src/images.rs
@@ -0,0 +1,406 @@
+//! `og dev scan images` and `og dev versions coupled`: the two checks of
+//! `scripts/ci/check-images.sh` that were Python. The script keeps the
+//! lists (which paths are scanned, which files and single literals are
+//! exempt, with the reason) and passes them in.
+//!
+//! ```text
+//! og dev scan images --root DIR --exempt-files TEXT --exempt-pairs TEXT < FILES
+//! og dev versions coupled --env versions.env
+//! ```
+//!
+//! `scan images` reads the files to scan (one path relative to DIR per
+//! line) on stdin and prints one `FAIL: <file>:<line> names the image
+//! <image>; ...` per literal image, then `scanned N files`. An image is
+//! `registry/name:tag`, `name@sha256:...`, or a Docker Hub official name
+//! (those `versions.env` uses and the usual base images) with a tag. A line
+//! of `--exempt-pairs` (`file image reason`) allows one occurrence of that
+//! image in that file; listing a pair twice allows two.
+//!
+//! `versions coupled` checks that `MINIMAP2_SAMTOOLS_IMAGE`, the one image
+//! of the Nextflow alignment task, names in its `versions.env` comment the
+//! minimap2 and samtools releases of `MINIMAP2_IMAGE` and `SAMTOOLS_IMAGE`.
+//!
+//! Exit 0 clean, 1 on a finding, 2 on a usage error or a `versions.env`
+//! the strict reader refuses.
+//!
+//! Where it differs from the Python on purpose: an exempt pair whose file
+//! no longer names its image as often as the list allows fails
+//! (`FAIL: <file> no longer names <image>; drop its line ...`), so an
+//! exemption cannot outlive its reason; and `versions.env` is read strictly
+//! ([`crate::versions_env`]).
+
+use std::collections::{BTreeMap, BTreeSet};
+use std::io::{Read, Write};
+use std::path::Path;
+use std::sync::LazyLock;
+
+use regex::Regex;
+
+use crate::lookaround::Rule;
+use crate::versions_env::{self, Pin};
+
+const USAGE: &str = "usage: og dev scan images --root DIR --exempt-files TEXT --exempt-pairs TEXT < FILES\n       og dev versions coupled --env versions.env\n";
+
+/// Docker Hub official images that `versions.env` may not use today.
+const BASES: [&str; 15] = [
+    "ubuntu",
+    "debian",
+    "alpine",
+    "busybox",
+    "centos",
+    "rockylinux",
+    "fedora",
+    "python",
+    "node",
+    "perl",
+    "r-base",
+    "openjdk",
+    "eclipse-temurin",
+    "golang",
+    "rust",
+];
+
+/// Any tag: a version, or a word such as latest or stable.
+const TAG: &str = r"(?::[A-Za-z0-9_][A-Za-z0-9._-]*|@sha256:[0-9a-f]{64})";
+/// What may not stand right before an image, nor right after it.
+const AHEAD: &str = r"(?:[^A-Za-z0-9_/-]|$)";
+
+fn lead(c: char) -> bool {
+    c.is_ascii_alphanumeric() || "_./:@$-".contains(c)
+}
+
+static URL: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"[a-z][a-z0-9+.-]*://[^\s\x1c-\x1f]+").expect("a valid pattern"));
+/// A path to a file, such as modules/local/vep/main.nf:23, is not an image.
+static FILE: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(r"\.(nf|sh|md|py|config|ya?ml|json|txt|tsv|csv|vcf|gz|html|css|js|R|r):[0-9]+(-[0-9]+)?$")
+        .expect("a valid pattern")
+});
+
+fn bare_names(pins: &[Pin]) -> BTreeSet<String> {
+    let mut bare: BTreeSet<String> = BASES.iter().map(|s| (*s).to_owned()).collect();
+    for p in pins.iter().filter(|p| p.name.ends_with("_IMAGE")) {
+        if let Some(i) = p.value.find([':', '@']) {
+            let name = &p.value[..i];
+            if !name.is_empty() && !name.contains('/') {
+                bare.insert(name.to_owned());
+            }
+        }
+    }
+    bare
+}
+
+/// The two patterns: `ns/name:tag`, and an official name with a tag.
+fn patterns(bare: &BTreeSet<String>) -> [Rule; 2] {
+    let names: Vec<String> = bare.iter().map(|b| regex::escape(b)).collect();
+    [
+        Rule::new(
+            &format!(r"([a-z][a-z0-9._-]*/[a-z][a-z0-9._/-]*{TAG}){AHEAD}"),
+            Some(lead),
+        )
+        .expect("a valid pattern"),
+        Rule::new(&format!(r"((?:{}){TAG}){AHEAD}", names.join("|")), Some(lead))
+            .expect("a valid pattern"),
+    ]
+}
+
+/// The text of a file as Python's text mode reads it: strict UTF-8, any
+/// newline turned into `\n`. None for a file that is not UTF-8 or not a
+/// readable file.
+fn read_text(path: &Path) -> Option<String> {
+    let bytes = std::fs::read(path).ok()?;
+    let text = String::from_utf8(bytes).ok()?;
+    Some(text.replace("\r\n", "\n").replace('\r', "\n"))
+}
+
+/// The literal images of one file, with their line numbers; exempt
+/// occurrences are taken off `left`.
+fn scan_file(
+    rel: &str,
+    text: &str,
+    rules: &[Rule; 2],
+    left: &mut BTreeMap<(String, String), usize>,
+    out: &mut dyn Write,
+) -> bool {
+    let mut bad = false;
+    for (i, raw) in text.split('\n').enumerate() {
+        // docker://image:tag (a step image in a workflow) is an image, not a URL.
+        let line = raw.replace("docker://", " ");
+        let line = URL.replace_all(&line, " ");
+        for r in rules {
+            for (s, e) in r.find_iter(&line) {
+                // A full stop ends the sentence, not the tag.
+                let image = line[s..e].trim_end_matches('.');
+                if FILE.is_match(image) || image.starts_with("example/") {
+                    continue; // example/ is the placeholder namespace of the self-tests
+                }
+                if let Some(n) = left.get_mut(&(rel.to_owned(), image.to_owned()))
+                    && *n > 0
+                {
+                    *n -= 1;
+                    continue;
+                }
+                let _ = writeln!(
+                    out,
+                    "FAIL: {rel}:{} names the image {image}; use its *_IMAGE variable from versions.env",
+                    i + 1
+                );
+                bad = true;
+            }
+        }
+    }
+    bad
+}
+
+struct ScanArgs {
+    root: String,
+    exempt_files: Vec<String>,
+    pairs: BTreeMap<(String, String), usize>,
+}
+
+fn parse_scan(args: &[String]) -> Result<ScanArgs, String> {
+    let (mut root, mut files, mut pairs) = (None, None, None);
+    let mut it = args.iter();
+    while let Some(a) = it.next() {
+        let v = it.next().ok_or_else(|| format!("{a} needs a value"));
+        match a.as_str() {
+            "--root" => root = Some(v?.clone()),
+            "--exempt-files" => files = Some(v?.clone()),
+            "--exempt-pairs" => pairs = Some(v?.clone()),
+            s => return Err(format!("unknown argument {s}")),
+        }
+    }
+    let exempt_files = files
+        .ok_or("--exempt-files is required")?
+        .lines()
+        .filter_map(|l| l.split_whitespace().next().map(str::to_owned))
+        .collect();
+    let mut counted = BTreeMap::new();
+    for l in pairs.ok_or("--exempt-pairs is required")?.lines() {
+        let w: Vec<&str> = l.split_whitespace().take(2).collect();
+        if let [f, image] = w[..] {
+            *counted.entry((f.to_owned(), image.to_owned())).or_insert(0) += 1;
+        } else if !w.is_empty() {
+            return Err(format!("an exempt pair needs a file and an image: {l}"));
+        }
+    }
+    Ok(ScanArgs {
+        root: root.ok_or("--root is required")?,
+        exempt_files,
+        pairs: counted,
+    })
+}
+
+fn scan(a: &ScanArgs, list: &str, out: &mut dyn Write) -> Result<bool, String> {
+    let files: Vec<&str> = list.lines().filter(|f| !f.is_empty()).collect();
+    if files.is_empty() {
+        let _ = writeln!(out, "FAIL: no file to scan");
+        return Ok(false);
+    }
+    let root = Path::new(&a.root);
+    let pins = versions_env::read(&root.join("versions.env"))?;
+    let rules = patterns(&bare_names(&pins));
+    let mut left = a.pairs.clone();
+    let mut bad = false;
+    for f in &files {
+        let skipped = a
+            .exempt_files
+            .iter()
+            .any(|s| *f == s || (s.ends_with('/') && f.starts_with(s.as_str())));
+        if skipped {
+            continue;
+        }
+        if let Some(text) = read_text(&root.join(f)) {
+            bad |= scan_file(f, &text, &rules, &mut left, out);
+        }
+    }
+    for ((f, image), n) in &left {
+        if *n > 0 {
+            let _ = writeln!(
+                out,
+                "FAIL: {f} no longer names {image}{}; drop its line from EXEMPT_PAIRS in scripts/ci/check-images.sh",
+                if *n > 1 { format!(" {n} more times") } else { String::new() }
+            );
+            bad = true;
+        }
+    }
+    let _ = writeln!(out, "scanned {} files", files.len());
+    Ok(!bad)
+}
+
+/// `og dev scan images ARGS`.
+pub fn cli_scan(args: &[String], out: &mut dyn Write, err: &mut dyn Write) -> u8 {
+    let a = match parse_scan(args) {
+        Ok(a) => a,
+        Err(e) => {
+            let _ = write!(err, "{USAGE}");
+            let _ = writeln!(err, "og dev scan images: error: {e}");
+            return 2;
+        }
+    };
+    let mut list = String::new();
+    if let Err(e) = std::io::stdin().read_to_string(&mut list) {
+        let _ = writeln!(err, "ERROR: cannot read the file list: {e}");
+        return 2;
+    }
+    match scan(&a, &list, out) {
+        Ok(true) => 0,
+        Ok(false) => 1,
+        Err(e) => {
+            let _ = writeln!(err, "ERROR: {e}");
+            2
+        }
+    }
+}
+
+/// The release in an image's tag: `quay.io/x/samtools:1.24--h0_0` is 1.24.
+fn release(value: &str) -> Option<&str> {
+    let tag = value.rsplit('/').next().unwrap_or(value);
+    let (_, t) = tag.split_once(':')?;
+    Some(t.split("--").next().unwrap_or(t))
+}
+
+static HELD: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(r"\b(minimap2|samtools)=([0-9][0-9A-Za-z.]*)").expect("a valid pattern")
+});
+
+/// The check on parsed pins; prints one line per tool.
+pub fn coupled(pins: &[Pin], out: &mut dyn Write) -> bool {
+    let Some(image) = versions_env::get(pins, "MINIMAP2_SAMTOOLS_IMAGE") else {
+        let _ = writeln!(out, "FAIL: MINIMAP2_SAMTOOLS_IMAGE is not set in versions.env");
+        return false;
+    };
+    let mut held: BTreeMap<&str, &str> = BTreeMap::new();
+    for c in HELD.captures_iter(&image.rest) {
+        let (tool, v) = (c.get(1).map_or("", |m| m.as_str()), c.get(2).map_or("", |m| m.as_str()));
+        held.insert(tool, v.trim_end_matches('.'));
+    }
+    let mut ok = true;
+    for (tool, var) in [("minimap2", "MINIMAP2_IMAGE"), ("samtools", "SAMTOOLS_IMAGE")] {
+        let want = versions_env::get(pins, var).and_then(|p| release(&p.value));
+        let got = held.get(tool).copied();
+        match (want, got) {
+            (Some(w), Some(g)) if !w.is_empty() && w == g => {
+                let _ = writeln!(
+                    out,
+                    "OK: MINIMAP2_SAMTOOLS_IMAGE holds {tool} {g}, the release of {var}"
+                );
+            }
+            _ => {
+                let want = want.filter(|w| !w.is_empty());
+                let _ = writeln!(
+                    out,
+                    "FAIL: MINIMAP2_SAMTOOLS_IMAGE says {tool}={} in its versions.env comment, but {var} is {}: pin a BioContainers mulled image with {tool} {} and name it in that comment (docs/updating.md, Held pins)",
+                    got.unwrap_or("(nothing)"),
+                    want.unwrap_or("(unset)"),
+                    want.unwrap_or("?")
+                );
+                ok = false;
+            }
+        }
+    }
+    ok
+}
+
+/// `og dev versions coupled --env FILE`.
+pub fn cli_coupled(args: &[String], out: &mut dyn Write, err: &mut dyn Write) -> u8 {
+    let [flag, path] = args else {
+        let _ = write!(err, "{USAGE}");
+        return 2;
+    };
+    if flag != "--env" {
+        let _ = write!(err, "{USAGE}");
+        return 2;
+    }
+    match versions_env::read(Path::new(path)) {
+        Ok(pins) => u8::from(!coupled(&pins, out)),
+        Err(e) => {
+            let _ = writeln!(err, "ERROR: {e}");
+            2
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn rules() -> [Rule; 2] {
+        let pins = versions_env::parse("PYTHON_IMAGE=\"python:3.15.2\"\n").unwrap();
+        patterns(&bare_names(&pins))
+    }
+
+    fn found(line: &str) -> Vec<String> {
+        let mut left = BTreeMap::new();
+        let mut out = Vec::new();
+        scan_file("f", line, &rules(), &mut left, &mut out);
+        String::from_utf8(out)
+            .unwrap()
+            .lines()
+            .map(|l| l.split(" names the image ").nth(1).unwrap().split(';').next().unwrap().to_owned())
+            .collect()
+    }
+
+    // Planted images are split by "~", which is dropped, so this file
+    // names none of them whole.
+    fn p(s: &str) -> String {
+        s.replace('~', "")
+    }
+
+    #[test]
+    fn literals_are_found_as_python_finds_them() {
+        assert_eq!(found(&p("docker run staphb/bcftools:~1.21 x")), [p("staphb/bcftools:~1.21")]);
+        assert_eq!(found(&p("runs staphb/samtools:~1.19.")), [p("staphb/samtools:~1.19")]);
+        assert_eq!(found(&p("// container python:~3.12")), [p("python:~3.12")]);
+        assert_eq!(found(&p("uses: docker://alpine:~3.8")), [p("alpine:~3.8")]);
+        // A tag followed by a slash backs off to the part before a dot.
+        assert_eq!(found(&p("x staphb/samtools:~1.2/x")), [p("staphb/samtools:~1")]);
+        for clean in [
+            "see https://quay.io/repository/biocontainers/samtools:1.0",
+            "modules/local/vep/main.nf:23",
+            "example/bcftools:1.0",
+            "$VAR/name:tag",
+            "python3 x.py",
+        ] {
+            assert!(found(clean).is_empty(), "{clean}: {:?}", found(clean));
+        }
+    }
+
+    #[test]
+    fn a_stale_exemption_fails() {
+        let dir = std::env::temp_dir().join(format!("og-dev-images-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        std::fs::write(dir.join("versions.env"), "A_IMAGE=\"x/y:1\"\n").unwrap();
+        std::fs::write(dir.join("a.md"), p("uses quay.io/x/y:~2\n")).unwrap();
+        let a = ScanArgs {
+            root: dir.to_string_lossy().into_owned(),
+            exempt_files: vec![],
+            pairs: BTreeMap::from([
+                (("a.md".into(), p("quay.io/x/y:~2")), 1),
+                (("a.md".into(), p("quay.io/x/y:~3")), 1),
+            ]),
+        };
+        let mut out = Vec::new();
+        let ok = scan(&a, "a.md\n", &mut out).unwrap();
+        let out = String::from_utf8(out).unwrap();
+        std::fs::remove_dir_all(&dir).unwrap();
+        assert!(!ok);
+        assert!(
+            out.contains(&p("FAIL: a.md no longer names quay.io/x/y:~3; drop its line")),
+            "{out}"
+        );
+        assert!(!out.contains(&p("y:~2;")), "{out}");
+    }
+
+    #[test]
+    fn coupled_releases() {
+        let env = "MINIMAP2_IMAGE=\"q/minimap2:2.31--h1_0\"\nSAMTOOLS_IMAGE=\"q/samtools:1.24--h2_0\"\nMINIMAP2_SAMTOOLS_IMAGE=\"q/mulled:abc\"  # minimap2=2.31,samtools=1.24.\n";
+        let mut out = Vec::new();
+        assert!(coupled(&versions_env::parse(env).unwrap(), &mut out));
+        let bumped = env.replace("samtools:1.24", "samtools:9.99");
+        let mut out = Vec::new();
+        assert!(!coupled(&versions_env::parse(&bumped).unwrap(), &mut out));
+        let out = String::from_utf8(out).unwrap();
+        assert!(out.contains("FAIL: MINIMAP2_SAMTOOLS_IMAGE says samtools=1.24 in its versions.env comment, but SAMTOOLS_IMAGE is 9.99:"), "{out}");
+    }
+}
diff --git a/rust/crates/og-dev/src/lib.rs b/rust/crates/og-dev/src/lib.rs
index 55c93fdf0..3ca2ae5c4 100644
--- a/rust/crates/og-dev/src/lib.rs
+++ b/rust/crates/og-dev/src/lib.rs
@@ -12,17 +12,33 @@
 //!   the report carries the report-only error strategy.
 //! - `og dev remnants` ([`remnants`]): does each Python file kept only for
 //!   its importers (`tests/parity/remnants.tsv`) hold nothing else?
+//! - `og dev scan personal-data` ([`personal_data`]): no tracked file holds
+//!   a home path, a private address or a genotype.
+//! - `og dev scan images`, `og dev versions coupled` ([`images`]): no file
+//!   names an image outside `versions.env`; the alignment task's image holds
+//!   the releases of step 02's two images.
+//! - `og dev versions check-run`, `og dev versions expand` ([`versions`]): a
+//!   run used the images `conf/containers.config` names; download URLs with
+//!   their `versions.env` variables filled.
+//! - `og dev pgs` ([`pgs`]): the PGS Catalog's answers against
+//!   `assets/pgs_scores.tsv`.
 
 pub mod contract;
+pub mod images;
+mod lookaround;
 pub mod parity;
+pub mod personal_data;
+pub mod pgs;
 pub mod remnants;
 pub mod report_only;
 pub mod schema;
+pub mod versions;
+pub mod versions_env;
 mod zip;
 
 use std::io::Write;
 
-const USAGE: &str = "usage: og dev parity-compare KIND ORACLE NEW\n       og dev parity-compare --self-test\n       og dev contract --static [--repo DIR] [--contract FILE]\n       og dev contract --outputs DIR --leg bash|nextflow --sample S [--observe]\n       og dev schema SCHEMA.json DOC.json\n       og dev report-only [--repo DIR]\n       og dev remnants [--list FILE] [--root DIR]\n";
+const USAGE: &str = "usage: og dev parity-compare KIND ORACLE NEW\n       og dev parity-compare --self-test\n       og dev contract --static [--repo DIR] [--contract FILE]\n       og dev contract --outputs DIR --leg bash|nextflow --sample S [--observe]\n       og dev schema SCHEMA.json DOC.json\n       og dev report-only [--repo DIR]\n       og dev remnants [--list FILE] [--root DIR]\n       og dev scan personal-data|images [args]\n       og dev versions check-run|expand|coupled [args]\n       og dev pgs trait|label-match|metric-match [args]\n";
 
 /// Python's `str(OSError)`: `[Errno 2] No such file or directory: 'path'`.
 pub(crate) fn py_os_error(e: &std::io::Error, path: &str) -> String {
@@ -49,6 +65,12 @@ fn run(f: fn(&[String], &mut dyn Write, &mut dyn Write) -> u8, args: &[String])
     code
 }
 
+fn unknown(verb: &str) -> u8 {
+    eprint!("{USAGE}");
+    eprintln!("og dev: error: unknown verb '{verb}'");
+    2
+}
+
 /// Runs `og dev ARGS`; returns the exit code.
 pub fn main(args: &[String]) -> u8 {
     match args.first().map(String::as_str) {
@@ -57,15 +79,23 @@ pub fn main(args: &[String]) -> u8 {
         Some("contract") => run(contract::cli, &args[1..]),
         Some("schema") => run(schema::cli, &args[1..]),
         Some("report-only") => run(report_only::cli, &args[1..]),
+        Some("scan") => match args.get(1).map(String::as_str) {
+            Some("personal-data") => run(personal_data::cli, &args[2..]),
+            Some("images") => run(images::cli_scan, &args[2..]),
+            _ => unknown(args.get(1).map_or("scan", String::as_str)),
+        },
+        Some("versions") => match args.get(1).map(String::as_str) {
+            Some("check-run") => run(versions::cli_check_run, &args[2..]),
+            Some("expand") => run(versions::cli_expand, &args[2..]),
+            Some("coupled") => run(images::cli_coupled, &args[2..]),
+            _ => unknown(args.get(1).map_or("versions", String::as_str)),
+        },
+        Some("pgs") => run(pgs::cli, &args[1..]),
         Some("-h" | "--help") => {
             print!("{USAGE}");
             0
         }
-        Some(other) => {
-            eprint!("{USAGE}");
-            eprintln!("og dev: error: unknown verb '{other}'");
-            2
-        }
+        Some(other) => unknown(other),
         None => {
             eprint!("{USAGE}");
             eprintln!("og dev: error: the following arguments are required: verb");
diff --git a/rust/crates/og-dev/src/lookaround.rs b/rust/crates/og-dev/src/lookaround.rs
new file mode 100644
index 000000000..d40d83b0d
--- /dev/null
+++ b/rust/crates/og-dev/src/lookaround.rs
@@ -0,0 +1,103 @@
+//! Python's one-character look-behind and look-ahead on the `regex` crate,
+//! which has neither.
+//!
+//! Every look-around of the scanners is a single character class: "not
+//! after one of these" before the match and "not followed by one of these"
+//! after it. A [`Rule`] keeps the matched text in capture group 1 and
+//! writes the look-ahead as a consumed `(?:[^...]|$)` after it, so the
+//! engine still finds, at each start, the match Python's backtracking would
+//! pick. The look-behind is the character before group 1, checked in code;
+//! when it fails, the search starts again one character later, as Python
+//! tries the next start. The next match is searched from the end of group
+//! 1, so the character the look-ahead read is not used up.
+
+use regex::Regex;
+
+/// A pattern with its look-behind.
+pub struct Rule {
+    re: Regex,
+    /// True for a character the match must not follow.
+    not_after: Option<fn(char) -> bool>,
+}
+
+impl Rule {
+    /// `pattern` holds the match in group 1, or is the match when it has no
+    /// group.
+    pub fn new(pattern: &str, not_after: Option<fn(char) -> bool>) -> Result<Rule, regex::Error> {
+        Ok(Rule {
+            re: Regex::new(pattern)?,
+            not_after,
+        })
+    }
+
+    /// The spans of `re.finditer` over `line`, in order.
+    pub fn find_iter<'a>(&'a self, line: &'a str) -> impl Iterator<Item = (usize, usize)> + 'a {
+        let mut pos = 0;
+        std::iter::from_fn(move || {
+            while pos <= line.len() {
+                let caps = self.re.captures_at(line, pos)?;
+                let m = caps.get(1).or_else(|| caps.get(0))?;
+                let (start, end) = (m.start(), m.end());
+                let refused = self.not_after.is_some_and(|bad| {
+                    line[..start].chars().next_back().is_some_and(bad)
+                });
+                if refused {
+                    pos = next_char(line, start);
+                    continue;
+                }
+                pos = if end > start {
+                    end
+                } else {
+                    next_char(line, end)
+                };
+                return Some((start, end));
+            }
+            None
+        })
+    }
+
+    /// `re.search(line) is not None`.
+    pub fn is_match(&self, line: &str) -> bool {
+        self.find_iter(line).next().is_some()
+    }
+}
+
+/// The byte offset of the character after `i`, or one past the end.
+fn next_char(s: &str, i: usize) -> usize {
+    s[i..].chars().next().map_or(s.len() + 1, |c| i + c.len_utf8())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn digit_or_dot(c: char) -> bool {
+        c.is_ascii_digit() || c == '.'
+    }
+
+    #[test]
+    fn behind_and_ahead_as_python() {
+        // Python: re.finditer(r'(?<![0-9.])[0-9]{1,4}/[0-9]{1,4}(?![0-9/])', s)
+        let r = Rule::new(r"([0-9]{1,4}/[0-9]{1,4})(?:[^0-9/]|$)", Some(digit_or_dot)).unwrap();
+        fn spans<'a>(r: &Rule, s: &'a str) -> Vec<&'a str> {
+            r.find_iter(s).map(|(a, b)| &s[a..b]).collect()
+        }
+        assert_eq!(spans(&r, "17/19"), ["17/19"]);
+        assert_eq!(spans(&r, "1.17/19 x"), Vec::<&str>::new());
+        assert_eq!(spans(&r, "17/19/3"), ["19/3"]);
+        assert_eq!(spans(&r, "a 17/19 and 2/3"), ["17/19", "2/3"]);
+        // The look-ahead character is not used up: two matches side by side.
+        let w = Rule::new(r"(ab)(?:[^b]|$)", None).unwrap();
+        assert_eq!(w.find_iter("abab").count(), 2);
+    }
+
+    #[test]
+    fn a_shorter_match_where_the_longest_fails_ahead() {
+        // Python finds "a/b:1" in "a/b:1.2/x": the tag backs off to "1",
+        // which a "." follows.
+        let r = Rule::new(r"([a-z]+/[a-z]+:[0-9][0-9.]*)(?:[^0-9a-z/]|$)", None).unwrap();
+        let s = "a/b:1.2/x";
+        let got: Vec<_> = r.find_iter(s).map(|(a, b)| &s[a..b]).collect();
+        assert_eq!(got, ["a/b:1"]);
+    }
+}
diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
new file mode 100644
index 000000000..a10289f56
--- /dev/null
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -0,0 +1,538 @@
+//! `og dev scan personal-data`: fail when a tracked text file holds
+//! something that looks like personal data. It replaces the Python inside
+//! `scripts/ci/check-personal-data.sh`, which keeps the lists of documented
+//! examples (`--allow`) and skipped files (`--skip`) and passes them in.
+//!
+//! ```text
+//! og dev scan personal-data --root DIR --allow TEXT --skip TEXT
+//!                           [--patterns FILE] [--cached] [--] [FILE...]
+//! ```
+//!
+//! With no FILE, every file `git ls-files` lists under DIR. `--cached`
+//! reads each file's staged blob (one `git cat-file --batch` process)
+//! instead of the working copy. `--patterns` adds one regular expression
+//! per line (kind `own`).
+//!
+//! Each line of a text file (no NUL byte in its first 8 KiB) is matched
+//! against the rules below; a match inside an allowed example of that file
+//! is skipped, the rest of the line still counts. Output: one
+//! `FAIL <kind> <file>:<line>: <text>` per rule and line, then
+//! `scanned N text files`. Exit 0 clean, 1 on a finding or when no text
+//! file was scanned, 2 on a usage error or a file or pattern that cannot be
+//! read.
+//!
+//! Where it differs from the Python on purpose: a scan that read no text
+//! file fails (`FAIL: no text file was scanned`) instead of passing, and a
+//! file is placed under DIR after resolving symbolic links in both, so
+//! DIR given as `/tmp/x` still finds `/private/tmp/x/CLAUDE.md`'s examples.
+
+use std::collections::HashMap;
+use std::ffi::OsStr;
+use std::io::{BufRead, BufReader, Read, Write};
+use std::os::unix::ffi::OsStrExt;
+use std::path::{Path, PathBuf};
+use std::process::{Command, Stdio};
+use std::sync::LazyLock;
+
+use pycompat::mtime::fnmatch;
+use pycompat::num::py_strip;
+
+use crate::lookaround::Rule;
+
+const USAGE: &str = "usage: og dev scan personal-data --root DIR --allow TEXT --skip TEXT [--patterns FILE] [--cached] [--] [FILE...]\n";
+
+/// This file's own path: it holds every allowed text, so all of them apply.
+const SELF: &str = "scripts/ci/check-personal-data.sh";
+
+/// How many leading bytes are searched for a NUL to call a file binary.
+const BINARY_PROBE: usize = 8192;
+
+fn not_word(c: char) -> bool {
+    c.is_ascii_alphanumeric() || c == '_'
+}
+
+fn digit_or_dot(c: char) -> bool {
+    c.is_ascii_digit() || c == '.'
+}
+
+fn digit_dot_slash(c: char) -> bool {
+    c.is_ascii_digit() || c == '.' || c == '/'
+}
+
+/// `[A-Za-z]` under Python's `(?i)`, which also folds to the long s and
+/// the Kelvin sign.
+fn letter_ci(c: char) -> bool {
+    c.is_ascii_alphabetic() || c == '\u{17F}' || c == '\u{212A}'
+}
+
+const STR_GENES: &str = "HTT|FMR1|C9orf72|C9ORF72|ATXN[0-9]+|DMPK|FXN|CNBP|RFC1|PABPN1|CACNA1A|TCF4|AR|PPP2R2B|TBP|JPH3|NOP56|ATN1|CSTB|AFF2|FMR2|NOTCH2NLC|DAB1|BEAN1|STARD7|YEATS2";
+const OCTET: &str = "(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])";
+/// Python's `\s` also holds the four separators U+001C to U+001F.
+const SPACE: &str = r"\s\x1c-\x1f";
+
+/// A rule: its kind, its pattern, and a pattern the line must also match.
+struct Check {
+    kind: &'static str,
+    rule: Rule,
+    cond: Option<&'static [Rule]>,
+}
+
+fn rule(pattern: &str, not_after: Option<fn(char) -> bool>) -> Rule {
+    Rule::new(pattern, not_after).expect("a valid built-in pattern")
+}
+
+/// A sample label, which may carry a number after a separator: sample7,
+/// sample_01, donor-3; or a public sample id such as NA12878 or HG002.
+static LABEL: LazyLock<[Rule; 2]> = LazyLock::new(|| {
+    [
+        rule(
+            r"(?i)((?:sample|patient|subject|proband|participant|individual|donor)s?(?:[_-]?[0-9]+)?)(?:[^A-Za-z]|$)",
+            Some(letter_ci),
+        ),
+        rule(r"\b(?:NA|HG)[0-9]{3,5}\b", None),
+    ]
+});
+
+static REPCN: LazyLock<[Rule; 1]> = LazyLock::new(|| [rule(r"\bREPCN\b", None)]);
+
+/// The built-in rules, in the order they are reported. Each pattern marks
+/// only the leaked value, so an allowed example covers just its span.
+fn builtin() -> Vec<Check> {
+    let gt = r"\(?[ACGTDI][/|;]?[ACGTDI]\)?";
+    vec![
+        Check {
+            kind: "home",
+            rule: rule(
+                r"/home/[A-Za-z]|/Users/[A-Za-z]|/mnt/use[r]\b|[A-Za-z]:\\\\?Users\\\\?[A-Za-z]",
+                Some(not_word),
+            ),
+            cond: None,
+        },
+        Check {
+            kind: "address",
+            rule: rule(
+                &format!(
+                    r"((?:10\.{OCTET}|172\.(?:1[6-9]|2[0-9]|3[01])|192\.168|100\.(?:6[4-9]|[7-9][0-9]|1[01][0-9]|12[0-7]))\.{OCTET}\.{OCTET})(?:$|\.$|\.[^0-9]|[^0-9.])"
+                ),
+                Some(digit_or_dot),
+            ),
+            cond: None,
+        },
+        Check {
+            kind: "address",
+            rule: rule(r"[A-Za-z0-9-]\.ts\.net\b", None),
+            cond: None,
+        },
+        Check {
+            kind: "diplotype",
+            rule: rule(r"\*[0-9]+[A-Za-z0-9.]*/\*[0-9]+", None),
+            cond: Some(&*LABEL),
+        },
+        Check {
+            kind: "rsid",
+            rule: rule(
+                &format!(r#"(\brs[0-9]+\b[{SPACE}:=,;|`'"\[\]-]{{1,6}}{gt})(?:[^A-Za-z0-9]|$)"#),
+                None,
+            ),
+            cond: None,
+        },
+        Check {
+            kind: "rsid",
+            rule: rule(r"\brs[0-9]+\t[0-9XYMT]{1,2}\t[0-9]+\t[ACGTDI-]{1,2}\b", None),
+            cond: None,
+        },
+        Check {
+            kind: "repeat",
+            rule: rule(r"([0-9]{1,4}/[0-9]{1,4})(?:[^0-9/]|$)", Some(digit_dot_slash)),
+            cond: Some(&*REPCN),
+        },
+        // Python: \b(?:GENES)\b[^/\n]{0,40}?(?<![0-9.])N/N(?![0-9/]). The
+        // gap after the gene is never empty (a digit right after a gene
+        // name is no word boundary), so its last character carries the
+        // look-behind.
+        Check {
+            kind: "repeat",
+            rule: rule(
+                &format!(
+                    r"(\b(?:{STR_GENES})\b[^/\n]{{0,39}}?[^/\n0-9.][0-9]{{1,4}}/[0-9]{{1,4}})(?:[^0-9/]|$)"
+                ),
+                None,
+            ),
+            cond: None,
+        },
+    ]
+}
+
+/// The arguments.
+struct Args {
+    root: PathBuf,
+    allow: Vec<(String, String)>,
+    skip: Vec<String>,
+    patterns: Option<String>,
+    cached: bool,
+    files: Vec<PathBuf>,
+}
+
+fn parse(args: &[String]) -> Result<Args, String> {
+    let (mut root, mut allow, mut skip, mut patterns, mut cached) = (None, None, None, None, false);
+    let mut files = Vec::new();
+    let mut it = args.iter();
+    while let Some(a) = it.next() {
+        let mut value = |name: &str| {
+            it.next()
+                .cloned()
+                .ok_or_else(|| format!("{name} needs a value"))
+        };
+        match a.as_str() {
+            "--root" => root = Some(value("--root")?),
+            "--allow" => allow = Some(value("--allow")?),
+            "--skip" => skip = Some(value("--skip")?),
+            "--patterns" => patterns = Some(value("--patterns")?),
+            "--cached" => cached = true,
+            "--" => {
+                files.extend(it.by_ref().map(PathBuf::from));
+                break;
+            }
+            s if s.starts_with('-') => return Err(format!("unknown option {s}")),
+            s => files.push(PathBuf::from(s)),
+        }
+    }
+    let root = root.ok_or("--root is required")?;
+    let allow = allow
+        .ok_or("--allow is required")?
+        .lines()
+        .filter(|l| !l.trim().is_empty())
+        .map(|l| {
+            let l = py_strip(l);
+            let (path, text) = l.split_once(' ').unwrap_or((l, ""));
+            (path.to_owned(), py_strip(text).to_owned())
+        })
+        .collect();
+    let skip = skip
+        .ok_or("--skip is required")?
+        .lines()
+        .filter_map(|l| l.split_whitespace().next().map(str::to_owned))
+        .collect();
+    Ok(Args {
+        root: PathBuf::from(root),
+        allow,
+        skip,
+        patterns: patterns.filter(|p| !p.is_empty()),
+        cached,
+        files,
+    })
+}
+
+/// The user's own patterns, one per line; `#` lines and blank lines skipped.
+fn own_rules(path: &str) -> Result<Vec<Check>, String> {
+    let text = std::fs::read_to_string(path).map_err(|e| format!("cannot read {path}: {e}"))?;
+    let mut out = Vec::new();
+    for l in text.lines() {
+        let p = py_strip(l);
+        if p.is_empty() || l.starts_with('#') {
+            continue;
+        }
+        let rule = Rule::new(p, None).map_err(|e| format!("{path}: bad pattern {p}: {e}"))?;
+        out.push(Check {
+            kind: "own",
+            rule,
+            cond: None,
+        });
+    }
+    Ok(out)
+}
+
+/// `path` relative to `root` when it lies below it (both with symbolic
+/// links resolved), else `path` as given.
+fn relative(path: &Path, root: &Path) -> String {
+    let abs = if path.is_absolute() {
+        path.to_path_buf()
+    } else {
+        std::env::current_dir().map_or_else(|_| path.to_path_buf(), |d| d.join(path))
+    };
+    // The folder is resolved, not the file: a tracked symbolic link keeps
+    // its own name.
+    let placed = match (abs.parent(), abs.file_name()) {
+        (Some(dir), Some(name)) => dir
+            .canonicalize()
+            .map_or_else(|_| abs.clone(), |d| d.join(name)),
+        _ => abs.clone(),
+    };
+    match placed.strip_prefix(root) {
+        Ok(rel) if !rel.as_os_str().is_empty() => rel.to_string_lossy().into_owned(),
+        _ => path.to_string_lossy().into_owned(),
+    }
+}
+
+fn git_files(root: &Path) -> Result<Vec<PathBuf>, String> {
+    let out = Command::new("git")
+        .arg("-C")
+        .arg(root)
+        .args(["ls-files", "-z"])
+        .stderr(Stdio::inherit())
+        .output()
+        .map_err(|e| format!("cannot run git: {e}"))?;
+    if !out.status.success() {
+        return Err(format!("git ls-files failed in {}", root.display()));
+    }
+    Ok(out
+        .stdout
+        .split(|&b| b == 0)
+        .filter(|f| !f.is_empty())
+        .map(|f| root.join(OsStr::from_bytes(f)))
+        .collect())
+}
+
+/// The staged blob of each path (relative to `root`), from one
+/// `git cat-file --batch`. A path with no blob in the index is absent.
+fn staged(root: &Path, rels: &[String]) -> Result<HashMap<String, Vec<u8>>, String> {
+    let wanted: Vec<&String> = rels.iter().filter(|r| !r.starts_with('/') && !r.contains('\n')).collect();
+    let mut blobs = HashMap::new();
+    if wanted.is_empty() {
+        return Ok(blobs);
+    }
+    let mut child = Command::new("git")
+        .arg("-C")
+        .arg(root)
+        .args(["cat-file", "--batch"])
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .spawn()
+        .map_err(|e| format!("cannot run git: {e}"))?;
+    let mut stdin = child.stdin.take().ok_or("no stdin for git")?;
+    let input: Vec<u8> = wanted
+        .iter()
+        .flat_map(|r| format!(":{r}\n").into_bytes())
+        .collect();
+    let writer = std::thread::spawn(move || stdin.write_all(&input));
+    let mut out = BufReader::new(child.stdout.take().ok_or("no stdout for git")?);
+    for rel in &wanted {
+        let mut head = String::new();
+        if out.read_line(&mut head).map_err(|e| e.to_string())? == 0 {
+            return Err("git cat-file stopped early".into());
+        }
+        let fields: Vec<&str> = head.trim_end().split(' ').collect();
+        let [_, kind, size] = fields[..] else {
+            continue; // "<name> missing" or "ambiguous"
+        };
+        let size: usize = size.parse().map_err(|_| format!("git cat-file: {head}"))?;
+        let mut data = vec![0; size + 1];
+        out.read_exact(&mut data).map_err(|e| e.to_string())?;
+        data.pop();
+        if kind == "blob" {
+            blobs.insert((*rel).clone(), data);
+        }
+    }
+    let _ = writer.join();
+    let _ = child.wait();
+    Ok(blobs)
+}
+
+/// One line of the report: kind padded as Python's `%-9s`, the stripped
+/// line cut at 160 characters.
+fn report(out: &mut dyn Write, kind: &str, rel: &str, n: usize, line: &str) {
+    let text: String = py_strip(line).chars().take(160).collect();
+    let _ = writeln!(out, "FAIL {kind:<9} {rel}:{n}: {text}");
+}
+
+/// Scans one file's text; true when something was reported.
+fn scan_text(out: &mut dyn Write, rules: &[Check], texts: &[&str], rel: &str, data: &[u8]) -> bool {
+    let mut bad = false;
+    let text = String::from_utf8_lossy(data);
+    for (i, line) in text.split('\n').enumerate() {
+        let spans: Vec<(usize, usize)> = texts
+            .iter()
+            .flat_map(|t| line.match_indices(*t).map(|(a, s)| (a, a + s.len())))
+            .collect();
+        for c in rules {
+            if c.cond.is_some_and(|cs| !cs.iter().any(|r| r.is_match(line))) {
+                continue;
+            }
+            let leaked = c
+                .rule
+                .find_iter(line)
+                .find(|&(s, e)| !spans.iter().any(|&(a, b)| a <= s && e <= b));
+            if leaked.is_some() {
+                report(out, c.kind, rel, i + 1, line);
+                bad = true;
+            }
+        }
+    }
+    bad
+}
+
+fn run(a: &Args, out: &mut dyn Write) -> Result<bool, String> {
+    let root = a
+        .root
+        .canonicalize()
+        .map_err(|e| format!("--root {}: {e}", a.root.display()))?;
+    let mut rules = builtin();
+    if let Some(p) = &a.patterns {
+        rules.extend(own_rules(p)?);
+    }
+    let files = if a.files.is_empty() {
+        git_files(&root)?
+    } else {
+        a.files.clone()
+    };
+    if files.is_empty() {
+        let _ = writeln!(out, "FAIL: no file to scan");
+        return Ok(false);
+    }
+    let todo: Vec<(&PathBuf, String)> = files
+        .iter()
+        .map(|f| (f, relative(f, &root)))
+        .filter(|(_, rel)| !a.skip.iter().any(|g| fnmatch(rel, g)))
+        .collect();
+    let blobs = if a.cached {
+        staged(&root, &todo.iter().map(|(_, r)| r.clone()).collect::<Vec<_>>())?
+    } else {
+        HashMap::new()
+    };
+    let (mut bad, mut scanned) = (false, 0usize);
+    for (path, rel) in &todo {
+        let data = if a.cached {
+            match blobs.get(rel) {
+                Some(d) => std::borrow::Cow::Borrowed(d.as_slice()),
+                None => continue,
+            }
+        } else {
+            match std::fs::read(path) {
+                Ok(d) => std::borrow::Cow::Owned(d),
+                Err(e)
+                    if matches!(
+                        e.kind(),
+                        std::io::ErrorKind::NotFound | std::io::ErrorKind::IsADirectory
+                    ) =>
+                {
+                    continue;
+                }
+                Err(e) => return Err(format!("cannot read {}: {e}", path.display())),
+            }
+        };
+        if data[..data.len().min(BINARY_PROBE)].contains(&0) {
+            continue;
+        }
+        scanned += 1;
+        let texts: Vec<&str> = a
+            .allow
+            .iter()
+            .filter(|(p, _)| rel == SELF || fnmatch(rel, p))
+            .map(|(_, t)| t.as_str())
+            .collect();
+        bad |= scan_text(out, &rules, &texts, rel, &data);
+    }
+    let _ = writeln!(out, "scanned {scanned} text files");
+    if scanned == 0 {
+        let _ = writeln!(out, "FAIL: no text file was scanned");
+        return Ok(false);
+    }
+    Ok(!bad)
+}
+
+/// `og dev scan personal-data ARGS`.
+pub fn cli(args: &[String], out: &mut dyn Write, err: &mut dyn Write) -> u8 {
+    let a = match parse(args) {
+        Ok(a) => a,
+        Err(e) => {
+            let _ = write!(err, "{USAGE}");
+            let _ = writeln!(err, "og dev scan personal-data: error: {e}");
+            return 2;
+        }
+    };
+    match run(&a, out) {
+        Ok(true) => 0,
+        Ok(false) => 1,
+        Err(e) => {
+            let _ = writeln!(err, "ERROR: {e}");
+            2
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn kinds(line: &str) -> Vec<&'static str> {
+        let rules = builtin();
+        let mut out = Vec::new();
+        for c in &rules {
+            if c.cond.is_some_and(|cs| !cs.iter().any(|r| r.is_match(line))) {
+                continue;
+            }
+            if c.rule.is_match(line) {
+                out.push(c.kind);
+            }
+        }
+        out
+    }
+
+    // Every planted value is split by "~", which is dropped, so this file
+    // holds none of them whole.
+    fn p(s: &str) -> String {
+        s.replace('~', "")
+    }
+
+    #[test]
+    fn each_kind_is_caught() {
+        for (line, kind) in [
+            ("cp results.html /home/~alice/genome/", "home"),
+            ("C:\\~Users\\bob", "home"),
+            ("scp out.vcf.gz root@192.~168.7.20:/data/", "address"),
+            ("ssh nas.tail1234.ts.~net", "address"),
+            ("| sample7 | CYP2D6 | *1/~*4 |", "diplotype"),
+            ("sample_01 CYP2D6 *1/~*4", "diplotype"),
+            ("HG0~02 *1/~*2", "diplotype"),
+            ("rs4244285~ AG", "rsid"),
+            ("rs123: (C;~T)", "rsid"),
+            ("rs4477212\t1\t82154\t~AA", "rsid"),
+            ("HTT CAG repeats: 17/~19", "repeat"),
+            ("GT:REPCN 0/1:17/~19", "repeat"),
+        ] {
+            let line = p(line);
+            assert!(kinds(&line).contains(&kind), "{line}: {:?}", kinds(&line));
+        }
+    }
+
+    #[test]
+    fn edges_as_python_reads_them() {
+        for line in [
+            "- `*1/*4` -- Intermediate metabolizer",
+            "samtools 1.21, GATK 4.6.2.0",
+            "https://example.org/home/page",
+            "CYP2C19*2 is rs4244285 (G>A)",
+            // An address with a fifth part, or a version that looks like one.
+            "v10.1.2.3.4",
+            "1.10.1.2.3",
+            "10.1.2.256",
+            // The word must stand alone: "samples" is a label, "sampler" is not.
+            "sampler *1/*4",
+            // A repeat count with another digit or slash on either side.
+            "REPCN 1.17/19",
+            "REPCN 17/19/3",
+            "/home/1x",
+            "my/home/user",
+        ] {
+            assert!(kinds(line).is_empty(), "{line}: {:?}", kinds(line));
+        }
+        // Python takes the label "sample" out of "sample7a" by backing off
+        // the number: the line still counts as labelled.
+        assert_eq!(kinds(&p("sample7a *1/~*4")), ["diplotype"]);
+        assert_eq!(kinds(&p("samples: *1/~*4")), ["diplotype"]);
+        assert_eq!(kinds(&p("10.1.2.3.")), ["address"]);
+        assert_eq!(kinds(&p("FMR1 has 29/~31")), ["repeat"]);
+    }
+
+    #[test]
+    fn an_allowed_example_covers_only_its_own_text() {
+        let rules = builtin();
+        let ex = "(`/mnt/user/`, `/home/username/`, etc.)";
+        let mut out = Vec::new();
+        assert!(!scan_text(&mut out, &rules, &[ex], "x.md", ex.as_bytes()));
+        let line = p(&format!("{ex} see /home/~bob/x"));
+        assert!(scan_text(&mut out, &rules, &[ex], "x.md", line.as_bytes()));
+        let got = String::from_utf8(out).unwrap();
+        assert!(got.starts_with("FAIL home      x.md:1: "), "{got}");
+    }
+}
diff --git a/rust/crates/og-dev/src/pgs.rs b/rust/crates/og-dev/src/pgs.rs
new file mode 100644
index 000000000..3bc7acd3c
--- /dev/null
+++ b/rust/crates/og-dev/src/pgs.rs
@@ -0,0 +1,320 @@
+//! `og dev pgs`: the readers of `scripts/ci/check-pgs-labels.sh` that were
+//! Python. The script still asks the PGS Catalog with curl; these verbs
+//! read its answer on stdin and never touch the network.
+//!
+//! ```text
+//! og dev pgs trait --id PGS000018 < score.json
+//! og dev pgs label-match LABEL TRAIT
+//! og dev pgs metric-match --id PGS --ppm PPM --ancestry GROUP --effect "OR 1.61" < performance.json
+//! ```
+//!
+//! - `trait` prints the score's `trait_reported`, or exits 1 when the
+//!   answer is not JSON, is for another id (the API answers `{}` with HTTP
+//!   200 for an unknown one) or has no trait.
+//! - `label-match` exits 0 when every word of LABEL is a word of TRAIT,
+//!   after lower-casing and dropping apostrophes and punctuation.
+//! - `metric-match` prints what the catalog says of the evaluation
+//!   (`score, ancestries, effects`) and exits 0 when it belongs to the
+//!   score, was measured only in samples of that ancestry group and reports
+//!   that odds or hazard ratio; 1 when it does not; 2 when the answer is not
+//!   an evaluation with that id.
+//!
+//! Where it differs from the Python on purpose: a JSON `true` is never the
+//! number 1, so `"estimate": true` no longer matches `OR 1`; and an answer
+//! whose samples or effects are not the objects and strings the catalog
+//! sends is exit 2 (not an evaluation) instead of a traceback read as a
+//! mismatch.
+
+use std::io::{Read, Write};
+use std::sync::LazyLock;
+
+use pycompat::json::{Value, loads};
+use pycompat::value::{py_str, truthy};
+use regex::Regex;
+
+const USAGE: &str = "usage: og dev pgs trait --id PGS_ID < ANSWER\n       og dev pgs label-match LABEL TRAIT\n       og dev pgs metric-match --id PGS_ID --ppm PPM_ID --ancestry GROUP --effect 'OR|HR N' < ANSWER\n";
+
+/// The PGS Catalog `ancestry_broad` terms of each 1000 Genomes group
+/// pgsc_calc reports (its ancestry_distribution uses the same codes).
+const GROUPS: [(&str, &[&str]); 5] = [
+    ("EUR", &["European"]),
+    (
+        "AFR",
+        &[
+            "African unspecified",
+            "African American or Afro-Caribbean",
+            "Sub-Saharan African",
+        ],
+    ),
+    ("AMR", &["Hispanic or Latin American"]),
+    ("EAS", &["East Asian"]),
+    ("SAS", &["South Asian"]),
+];
+
+fn group(term: &str) -> Option<&'static str> {
+    GROUPS
+        .iter()
+        .find(|(_, terms)| terms.contains(&term))
+        .map(|(g, _)| *g)
+}
+
+fn field<'a>(d: &'a Value, key: &str) -> Option<&'a Value> {
+    match d {
+        Value::Object(o) => o.get(key),
+        _ => None,
+    }
+}
+
+fn is_str(v: Option<&Value>, want: &str) -> bool {
+    matches!(v, Some(Value::Str(s)) if s == want)
+}
+
+/// The trait of score `id` in `body`, or None.
+pub fn trait_of(body: &str, id: &str) -> Option<String> {
+    let d = loads(body).ok()?;
+    if !matches!(d, Value::Object(_)) || !is_str(field(&d, "id"), id) {
+        return None;
+    }
+    match field(&d, "trait_reported") {
+        Some(Value::Str(t)) => {
+            let t = pycompat::num::py_strip(t);
+            (!t.is_empty()).then(|| t.to_owned())
+        }
+        _ => None,
+    }
+}
+
+static NOT_WORD: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new("[^a-z0-9]+").expect("a valid pattern"));
+
+fn words(s: &str) -> std::collections::BTreeSet<String> {
+    let s = pycompat::text::lower(s).replace(['\u{2019}', '\''], "");
+    NOT_WORD
+        .replace_all(&s, " ")
+        .split_whitespace()
+        .map(str::to_owned)
+        .collect()
+}
+
+/// True when every word of `label` appears in `trait_`.
+pub fn label_matches(label: &str, trait_: &str) -> bool {
+    let (l, t) = (words(label), words(trait_));
+    !l.is_empty() && l.is_subset(&t)
+}
+
+static EFFECT: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"^(OR|HR) ([0-9]+(?:\.[0-9]+)?)$").expect("a valid pattern"));
+
+/// What the catalog says of an evaluation, and whether it matches. Err is
+/// the reason the answer is not an evaluation with that id.
+pub fn metric(body: &str, id: &str, ppm: &str, anc: &str, eff: &str) -> Result<(String, bool), String> {
+    let d = loads(body).map_err(|_| "(not JSON)".to_owned())?;
+    if !matches!(d, Value::Object(_)) || !is_str(field(&d, "id"), ppm) {
+        return Err("(no such evaluation)".into());
+    }
+    let odd = || "(not an evaluation the check can read)".to_owned();
+    let empty = Value::Null;
+    let or_empty = |v: Option<&'_ Value>| -> Value {
+        v.filter(|v| truthy(v)).cloned().unwrap_or(Value::Null)
+    };
+    let samples = match or_empty(field(&or_empty(field(&d, "sampleset")), "samples")) {
+        Value::Null => Vec::new(),
+        Value::Array(a) => a,
+        _ => return Err(odd()),
+    };
+    let mut terms = Vec::new();
+    for s in &samples {
+        if !matches!(s, Value::Object(_)) {
+            return Err(odd());
+        }
+        match or_empty(field(s, "ancestry_broad")) {
+            Value::Null => terms.push(String::new()),
+            Value::Str(t) => terms.push(t),
+            _ => return Err(odd()),
+        }
+    }
+    let found: std::collections::BTreeSet<Option<&str>> = terms.iter().map(|t| group(t)).collect();
+    let sizes = match or_empty(field(&or_empty(field(&d, "performance_metrics")), "effect_sizes")) {
+        Value::Null => Vec::new(),
+        Value::Array(a) => a,
+        _ => return Err(odd()),
+    };
+    let mut effects = Vec::new();
+    for e in &sizes {
+        if !matches!(e, Value::Object(_)) {
+            return Err(odd());
+        }
+        let name = field(e, "name_short").unwrap_or(&empty).clone();
+        let est = field(e, "estimate").unwrap_or(&empty).clone();
+        effects.push((name, est));
+    }
+    let pgs = field(&d, "associated_pgs_id").unwrap_or(&empty);
+    let show = |v: &Value| py_str(v).map_err(|_| odd());
+    let effects_said = effects
+        .iter()
+        .map(|(n, v)| Ok(format!("{} {}", show(n)?, show(v)?)))
+        .collect::<Result<Vec<_>, String>>()?
+        .join("; ");
+    let terms_said = terms.join("; ");
+    let said = format!(
+        "{}, {}, {}",
+        show(pgs)?,
+        if terms_said.is_empty() { "no samples" } else { &terms_said },
+        if effects_said.is_empty() { "no effect size" } else { &effects_said },
+    );
+    let ok = is_str(Some(pgs), id)
+        && group_named(anc)
+        && found.len() == 1
+        && found.contains(&Some(anc))
+        && EFFECT.captures(eff).is_some_and(|m| {
+            let want: f64 = m[2].parse().unwrap_or(f64::NAN);
+            effects.iter().any(|(n, v)| {
+                is_str(Some(n), &m[1])
+                    && match v {
+                        Value::Int(i) => (*i as f64 - want).abs() < 1e-9,
+                        Value::Float(x) => (x - want).abs() < 1e-9,
+                        _ => false, // a bool is never a number
+                    }
+            })
+        });
+    Ok((said, ok))
+}
+
+fn group_named(anc: &str) -> bool {
+    GROUPS.iter().any(|(g, _)| *g == anc)
+}
+
+fn stdin() -> Result<String, String> {
+    let mut s = String::new();
+    std::io::stdin()
+        .read_to_string(&mut s)
+        .map_err(|e| e.to_string())?;
+    Ok(s)
+}
+
+/// `--name value` pairs.
+fn opts<'a>(args: &'a [String], names: &[&str]) -> Option<Vec<&'a str>> {
+    let mut got = vec![None; names.len()];
+    let mut it = args.iter();
+    while let Some(a) = it.next() {
+        let i = names.iter().position(|n| n == a)?;
+        got[i] = Some(it.next()?.as_str());
+    }
+    got.into_iter().collect()
+}
+
+/// `og dev pgs ARGS`.
+pub fn cli(args: &[String], out: &mut dyn Write, err: &mut dyn Write) -> u8 {
+    let usage = |err: &mut dyn Write| {
+        let _ = write!(err, "{USAGE}");
+        2
+    };
+    match args.first().map(String::as_str) {
+        Some("trait") => {
+            let Some(v) = opts(&args[1..], &["--id"]) else {
+                return usage(err);
+            };
+            match stdin().ok().and_then(|b| trait_of(&b, v[0])) {
+                Some(t) => {
+                    let _ = writeln!(out, "{t}");
+                    0
+                }
+                None => 1,
+            }
+        }
+        Some("label-match") => match &args[1..] {
+            [label, trait_] => u8::from(!label_matches(label, trait_)),
+            _ => usage(err),
+        },
+        Some("metric-match") => {
+            let Some(v) = opts(&args[1..], &["--id", "--ppm", "--ancestry", "--effect"]) else {
+                return usage(err);
+            };
+            let body = match stdin() {
+                Ok(b) => b,
+                Err(e) => {
+                    let _ = writeln!(err, "ERROR: {e}");
+                    return 2;
+                }
+            };
+            match metric(&body, v[0], v[1], v[2], v[3]) {
+                Ok((said, ok)) => {
+                    let _ = writeln!(out, "{said}");
+                    u8::from(!ok)
+                }
+                Err(why) => {
+                    let _ = writeln!(out, "{why}");
+                    2
+                }
+            }
+        }
+        _ => usage(err),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn trait_needs_the_same_id_and_a_trait() {
+        assert_eq!(
+            trait_of(r#"{"id": "PGS000018", "trait_reported": " Coronary artery disease "}"#, "PGS000018").as_deref(),
+            Some("Coronary artery disease")
+        );
+        assert_eq!(trait_of("{}", "PGS000018"), None);
+        assert_eq!(trait_of(r#"{"id": "PGS000020", "trait_reported": "x"}"#, "PGS000018"), None);
+        assert_eq!(trait_of(r#"{"id": "PGS000018", "trait_reported": ""}"#, "PGS000018"), None);
+        assert_eq!(trait_of("not json", "PGS000018"), None);
+    }
+
+    #[test]
+    fn labels_match_by_words() {
+        assert!(label_matches("Type 2 diabetes (T2D)", "Type 2 diabetes (T2D)"));
+        assert!(label_matches("type_2_diabetes", "Type 2 diabetes (T2D)"));
+        assert!(label_matches("Late-onset Alzheimer\u{2019}s disease", "Late-onset Alzheimer's disease"));
+        assert!(!label_matches("inflammatory_bowel_disease", "Type 2 diabetes (T2D)"));
+        assert!(!label_matches("", "anything"));
+    }
+
+    const ANSWER: &str = r#"{"id": "PPM000591", "associated_pgs_id": "PGS000018",
+        "sampleset": {"samples": [{"ancestry_broad": "European"}]},
+        "performance_metrics": {"effect_sizes": [{"name_short": "HR", "estimate": 1.53}]}}"#;
+
+    #[test]
+    fn an_evaluation_matches_its_score_ancestry_and_effect() {
+        let (said, ok) = metric(ANSWER, "PGS000018", "PPM000591", "EUR", "HR 1.53").unwrap();
+        assert!(ok);
+        assert_eq!(said, "PGS000018, European, HR 1.53");
+        for (id, anc, eff) in [
+            ("PGS000004", "EUR", "HR 1.53"),
+            ("PGS000018", "AFR", "HR 1.53"),
+            ("PGS000018", "EUR", "HR 1.54"),
+            ("PGS000018", "EUR", "OR 1.53"),
+            ("PGS000018", "XYZ", "HR 1.53"),
+            ("PGS000018", "EUR", "HR"),
+        ] {
+            assert!(!metric(ANSWER, id, "PPM000591", anc, eff).unwrap().1, "{id} {anc} {eff}");
+        }
+        assert_eq!(metric("{}", "PGS000018", "PPM000591", "EUR", "HR 1.53").unwrap_err(), "(no such evaluation)");
+        assert_eq!(metric("<html>", "PGS000018", "PPM000591", "EUR", "HR 1.53").unwrap_err(), "(not JSON)");
+    }
+
+    #[test]
+    fn a_bool_is_never_a_number() {
+        let body = ANSWER.replace("1.53", "true");
+        let (said, ok) = metric(&body, "PGS000018", "PPM000591", "EUR", "HR 1").unwrap();
+        assert!(!ok, "{said}");
+        assert_eq!(said, "PGS000018, European, HR True");
+        let body = ANSWER.replace("1.53", "2");
+        assert!(metric(&body, "PGS000018", "PPM000591", "EUR", "HR 2").unwrap().1);
+    }
+
+    #[test]
+    fn no_samples_no_effects() {
+        let body = r#"{"id": "PPM1", "associated_pgs_id": null, "sampleset": null}"#;
+        let (said, ok) = metric(body, "PGS1", "PPM1", "EUR", "OR 1").unwrap();
+        assert!(!ok);
+        assert_eq!(said, "None, no samples, no effect size");
+    }
+}
diff --git a/rust/crates/og-dev/src/versions.rs b/rust/crates/og-dev/src/versions.rs
new file mode 100644
index 000000000..d08528e2e
--- /dev/null
+++ b/rust/crates/og-dev/src/versions.rs
@@ -0,0 +1,263 @@
+//! `og dev versions check-run` and `og dev versions expand`: the version
+//! checks of `scripts/ci/gen-containers-config.sh --check-versions` and
+//! `scripts/ci/check-links.sh` that were Python.
+//!
+//! ```text
+//! og dev versions check-run --config conf/containers.config FILE [PROCESS...]
+//! og dev versions expand --env versions.env < URL<TAB>LOC lines
+//! ```
+//!
+//! `check-run` proves a run used the images `conf/containers.config` gives
+//! each process. Each module writes, as the first line of its block in
+//! `pipeline_info/software_versions.yml` (FILE), the tag of the image it ran
+//! in; a process that runs on the host (an `ext.pipeline_version` selector)
+//! writes the release of the pipeline it starts. One `OK   PROC key: value`
+//! or `FAIL PROC ...` line per process of PROCESS... (default: every
+//! selector) and of FILE. Exit 0 when all agree, 1 otherwise, 2 on a usage
+//! error or a file that cannot be read.
+//!
+//! `expand` fills `${NAME}` and `$NAME` in each URL from `versions.env` (a
+//! missing file fills nothing), drops trailing `.,;:]` and a `}` that closes
+//! nothing, and prints the lines back. Exit 2 on a line with no tab or a
+//! `versions.env` the strict reader refuses: on purpose, a line it cannot
+//! read is no longer skipped ([`crate::versions_env`]).
+
+use std::collections::{BTreeMap, BTreeSet};
+use std::io::{BufRead, Write};
+use std::path::Path;
+use std::sync::LazyLock;
+
+use regex::{Captures, Regex};
+
+use crate::versions_env;
+
+const USAGE: &str = "usage: og dev versions check-run --config FILE VERSIONS.yml [PROCESS...]\n       og dev versions expand --env versions.env < LINES\n       og dev versions coupled --env versions.env\n";
+
+fn re(s: &str) -> Regex {
+    Regex::new(s).expect("a valid built-in pattern")
+}
+
+static CONTAINER: LazyLock<Regex> =
+    LazyLock::new(|| re(r"withName: '(\w+)' \{ container = '([^']+)' \}"));
+static PIPELINE: LazyLock<Regex> =
+    LazyLock::new(|| re(r"withName: '(\w+)' \{ ext\.pipeline_version = '([^']+)';"));
+static BLOCK: LazyLock<Regex> = LazyLock::new(|| re(r#"^"([^"]+)":\s*$"#));
+static ENTRY: LazyLock<Regex> = LazyLock::new(|| re(r"^\s+([\w.-]+):\s*(.*?)\s*$"));
+static TAG_PREFIX: LazyLock<Regex> = LazyLock::new(|| re(r"^[^:@]+[:@]"));
+
+/// The image (or pipeline release) of every process in the config text.
+pub fn selectors(config: &str) -> BTreeMap<String, String> {
+    let mut images = BTreeMap::new();
+    for re in [&*CONTAINER, &*PIPELINE] {
+        for c in re.captures_iter(config) {
+            images.insert(c[1].to_owned(), c[2].to_owned());
+        }
+    }
+    images
+}
+
+/// The first `key: value` under each `"PATH:PROC":` block of a
+/// `software_versions.yml`.
+pub fn first_entries(yml: &str) -> BTreeMap<String, (String, String)> {
+    let mut first = BTreeMap::new();
+    let mut proc: Option<String> = None;
+    for line in yml.split_inclusive('\n') {
+        let line = line.strip_suffix('\n').unwrap_or(line);
+        if let Some(c) = BLOCK.captures(line) {
+            proc = c[1].rsplit(':').next().map(str::to_owned);
+            continue;
+        }
+        if let (Some(c), Some(p)) = (ENTRY.captures(line), &proc)
+            && !p.is_empty()
+            && !first.contains_key(p)
+        {
+            first.insert(p.clone(), (c[1].to_owned(), c[2].to_owned()));
+        }
+    }
+    first
+}
+
+/// The check on parsed inputs. `expect` empty means every selector.
+pub fn check_run(
+    images: &BTreeMap<String, String>,
+    first: &BTreeMap<String, (String, String)>,
+    yml_name: &str,
+    expect: &[String],
+    out: &mut dyn Write,
+) -> bool {
+    let mut ok = true;
+    if first.is_empty() {
+        let _ = writeln!(out, "FAIL: {yml_name} has no process block");
+        ok = false;
+    }
+    let wanted: BTreeSet<&str> = if expect.is_empty() {
+        images.keys().map(String::as_str).collect()
+    } else {
+        expect.iter().map(String::as_str).collect()
+    };
+    let all: BTreeSet<&str> = wanted
+        .iter()
+        .copied()
+        .chain(first.keys().map(String::as_str))
+        .collect();
+    for p in all {
+        match (images.get(p), first.get(p)) {
+            (None, _) => {
+                let _ = writeln!(out, "FAIL {p:<20} has no selector in conf/containers.config");
+                ok = false;
+            }
+            (Some(_), None) => {
+                if wanted.contains(p) {
+                    let _ = writeln!(out, "FAIL {p:<20} missing from {yml_name}");
+                    ok = false;
+                }
+            }
+            (Some(image), Some((key, value))) => {
+                let tag = TAG_PREFIX.replace(image, "");
+                if *value == tag {
+                    let _ = writeln!(out, "OK   {p:<20} {key}: {value}");
+                } else {
+                    let _ = writeln!(out, "FAIL {p:<20} {key}: {value}, want {tag} ({image})");
+                    ok = false;
+                }
+            }
+        }
+    }
+    ok
+}
+
+fn read(path: &str) -> Result<String, String> {
+    std::fs::read_to_string(path).map_err(|e| format!("cannot read {path}: {e}"))
+}
+
+/// `og dev versions check-run ARGS`.
+pub fn cli_check_run(args: &[String], out: &mut dyn Write, err: &mut dyn Write) -> u8 {
+    let [flag, config, yml, expect @ ..] = args else {
+        let _ = write!(err, "{USAGE}");
+        return 2;
+    };
+    if flag != "--config" {
+        let _ = write!(err, "{USAGE}");
+        return 2;
+    }
+    let texts = read(config).and_then(|c| Ok((c, read(yml)?)));
+    match texts {
+        Ok((c, y)) => u8::from(!check_run(&selectors(&c), &first_entries(&y), yml, expect, out)),
+        Err(e) => {
+            let _ = writeln!(err, "ERROR: {e}");
+            2
+        }
+    }
+}
+
+static VAR: LazyLock<Regex> =
+    LazyLock::new(|| re(r"\$\{([A-Z][A-Z0-9_]*)\}|\$([A-Z][A-Z0-9_]*)"));
+
+/// One URL with its variables filled and its trailing punctuation dropped.
+pub fn expand(url: &str, vals: &BTreeMap<String, String>) -> String {
+    let filled = VAR.replace_all(url, |c: &Captures| {
+        let name = c.get(1).or_else(|| c.get(2)).map_or("", |m| m.as_str());
+        vals.get(name).cloned().unwrap_or_else(|| c[0].to_owned())
+    });
+    let mut u = filled.into_owned();
+    // Trailing punctuation, and the brace that closes ${VAR:-https://...}.
+    while let Some(last) = u.chars().next_back() {
+        let unbalanced = last == '}' && u.matches('}').count() > u.matches('{').count();
+        if ".,;:]".contains(last) || unbalanced {
+            u.pop();
+        } else {
+            break;
+        }
+    }
+    u
+}
+
+/// `og dev versions expand --env FILE`.
+pub fn cli_expand(args: &[String], out: &mut dyn Write, err: &mut dyn Write) -> u8 {
+    let [flag, env] = args else {
+        let _ = write!(err, "{USAGE}");
+        return 2;
+    };
+    if flag != "--env" {
+        let _ = write!(err, "{USAGE}");
+        return 2;
+    }
+    let pins = match std::fs::read_to_string(Path::new(env)) {
+        Ok(text) => versions_env::parse(&text),
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(Vec::new()),
+        Err(e) => Err(format!("cannot read {env}: {e}")),
+    };
+    let vals: BTreeMap<String, String> = match pins {
+        Ok(p) => p.into_iter().map(|p| (p.name, p.value)).collect(),
+        Err(e) => {
+            let _ = writeln!(err, "ERROR: {e}");
+            return 2;
+        }
+    };
+    for (i, line) in std::io::stdin().lock().lines().enumerate() {
+        let line = match line {
+            Ok(l) => l,
+            Err(e) => {
+                let _ = writeln!(err, "ERROR: cannot read line {}: {e}", i + 1);
+                return 2;
+            }
+        };
+        let Some((url, loc)) = line.split_once('\t') else {
+            let _ = writeln!(err, "ERROR: line {} has no tab: {line}", i + 1);
+            return 2;
+        };
+        let _ = writeln!(out, "{}\t{loc}", expand(url, &vals));
+    }
+    0
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const CONFIG: &str = "process {\n    withName: 'ROH' { container = 'quay.io/x/bcftools:1.22--h0_0' }\n    withName: 'VEP' { container = 'ensemblorg/ensembl-vep@sha256:abc' }\n    withName: 'PRS' { ext.pipeline_version = 'v2.1.0'; ext.x = 'y' }\n}\n";
+
+    fn run(yml: &str, expect: &[&str]) -> (bool, String) {
+        let expect: Vec<String> = expect.iter().map(|s| (*s).to_owned()).collect();
+        let mut out = Vec::new();
+        let ok = check_run(&selectors(CONFIG), &first_entries(yml), "v.yml", &expect, &mut out);
+        (ok, String::from_utf8(out).unwrap())
+    }
+
+    #[test]
+    fn right_tags_pass() {
+        let (ok, out) = run(
+            "\"PGX:ROH\":\n    bcftools: 1.22--h0_0\n    other: 9\n\"VEP\":\n    ensemblvep: sha256:abc\n\"CLINICAL:PRS\":\n    pgsc_calc: v2.1.0\n",
+            &[],
+        );
+        assert!(ok, "{out}");
+        assert!(out.contains("OK   ROH                  bcftools: 1.22--h0_0\n"), "{out}");
+    }
+
+    #[test]
+    fn a_wrong_missing_or_unknown_process_fails() {
+        let (ok, out) = run(
+            "\"PGX:ROH\":\n    bcftools: 0.0.0-planted\n\"NEW_TOOL\":\n    tool: 1.0\n",
+            &["ROH", "VEP"],
+        );
+        assert!(!ok);
+        assert!(out.contains("FAIL ROH                  bcftools: 0.0.0-planted, want 1.22--h0_0 (quay.io/x/bcftools:1.22--h0_0)"), "{out}");
+        assert!(out.contains("FAIL NEW_TOOL             has no selector"), "{out}");
+        assert!(out.contains("FAIL VEP                  missing from v.yml"), "{out}");
+        assert!(!out.contains("PRS"), "{out}");
+        let (ok, out) = run("nothing: here\n", &["ROH"]);
+        assert!(!ok);
+        assert!(out.contains("FAIL: v.yml has no process block"), "{out}");
+    }
+
+    #[test]
+    fn urls_expand_and_lose_trailing_punctuation() {
+        let vals = BTreeMap::from([("REL".to_owned(), "1.2".to_owned())]);
+        assert_eq!(expand("https://x.org/${REL}/a.gz", &vals), "https://x.org/1.2/a.gz");
+        assert_eq!(expand("https://x.org/$REL/a.gz).", &vals), "https://x.org/1.2/a.gz)");
+        assert_eq!(expand("https://x.org/${NOPE}/a.", &vals), "https://x.org/${NOPE}/a");
+        assert_eq!(expand("${U:-https://x.org/a}", &vals), "${U:-https://x.org/a}");
+        assert_eq!(expand("https://x.org/a}", &vals), "https://x.org/a");
+        assert_eq!(expand("https://x.org/a];:", &vals), "https://x.org/a");
+    }
+}
diff --git a/rust/crates/og-dev/src/versions_env.rs b/rust/crates/og-dev/src/versions_env.rs
new file mode 100644
index 000000000..f6245ecbc
--- /dev/null
+++ b/rust/crates/og-dev/src/versions_env.rs
@@ -0,0 +1,115 @@
+//! A strict reader of `versions.env`, the one list of images and coupled
+//! data versions.
+//!
+//! The bash steps source the file, so a line could hold anything bash
+//! accepts. The dev verbs never run it: they read it, and only in one shape,
+//! `NAME="value"` with an optional trailing `# comment`, where the value
+//! holds no `"`, `$` or backquote (nothing for bash to expand). A blank line
+//! or a comment line is skipped. Any other line, and a name set twice, is an
+//! error naming the line, so a check never reads a file it does not
+//! understand as one with fewer pins.
+
+use std::path::Path;
+use std::sync::LazyLock;
+
+use regex::Regex;
+
+/// One `NAME="value"` line.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Pin {
+    pub name: String,
+    pub value: String,
+    /// What follows the closing quote, as written (the comment, if any).
+    pub rest: String,
+    /// The 1-based line number.
+    pub line: usize,
+}
+
+static LINE: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(r#"^([A-Z][A-Z0-9_]*)="([^"$`]*)"(\s*(?:#.*)?)$"#).expect("a valid pattern")
+});
+
+/// Reads `versions.env` text. Lines may end in `\n` or `\r\n`.
+pub fn parse(text: &str) -> Result<Vec<Pin>, String> {
+    let mut pins: Vec<Pin> = Vec::new();
+    for (i, raw) in text.split('\n').enumerate() {
+        let line = raw.strip_suffix('\r').unwrap_or(raw);
+        let trimmed = line.trim();
+        if trimmed.is_empty() || trimmed.starts_with('#') {
+            continue;
+        }
+        let Some(c) = LINE.captures(line) else {
+            return Err(format!(
+                "versions.env:{}: not a NAME=\"value\" line (a value holds no \", $ or backquote): {line}",
+                i + 1
+            ));
+        };
+        let name = c[1].to_owned();
+        if let Some(first) = pins.iter().find(|p| p.name == name) {
+            return Err(format!(
+                "versions.env:{}: {name} is set again (first on line {})",
+                i + 1,
+                first.line
+            ));
+        }
+        pins.push(Pin {
+            name,
+            value: c[2].to_owned(),
+            rest: c[3].to_owned(),
+            line: i + 1,
+        });
+    }
+    Ok(pins)
+}
+
+/// Reads the `versions.env` at `path`.
+pub fn read(path: &Path) -> Result<Vec<Pin>, String> {
+    let text = std::fs::read_to_string(path)
+        .map_err(|e| format!("cannot read {}: {e}", path.display()))?;
+    parse(&text)
+}
+
+/// The value of `name`, if it is set.
+pub fn get<'a>(pins: &'a [Pin], name: &str) -> Option<&'a Pin> {
+    pins.iter().find(|p| p.name == name)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn reads_values_and_comments() {
+        let p = parse("# head\n\nA_IMAGE=\"x/y:1\"  # minimap2=2.31\r\nB=\"\"\n").unwrap();
+        assert_eq!(p.len(), 2);
+        assert_eq!(p[0].name, "A_IMAGE");
+        assert_eq!(p[0].value, "x/y:1");
+        assert_eq!(p[0].rest, "  # minimap2=2.31");
+        assert_eq!(p[0].line, 3);
+        assert_eq!(p[1].value, "");
+    }
+
+    #[test]
+    fn refuses_what_bash_would_expand_or_a_second_value() {
+        for bad in [
+            "A=\"${B}\"",
+            "A=\"$(date)\"",
+            "A=\"`x`\"",
+            "A=x",
+            "export A=\"x\"",
+            "A=\"x\" B",
+            "a=\"x\"",
+        ] {
+            assert!(parse(bad).is_err(), "{bad} was read");
+        }
+        let e = parse("A=\"1\"\nA=\"2\"\n").unwrap_err();
+        assert!(e.contains("A is set again (first on line 1)"), "{e}");
+    }
+
+    #[test]
+    fn the_repository_file_reads() {
+        let path = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../../versions.env");
+        let pins = read(&path).unwrap();
+        assert!(get(&pins, "SAMTOOLS_IMAGE").is_some());
+    }
+}
diff --git a/rust/og/src/main.rs b/rust/og/src/main.rs
index 7b8f792ab..0006ba019 100644
--- a/rust/og/src/main.rs
+++ b/rust/og/src/main.rs
@@ -69,6 +69,9 @@ const USAGE: &str = "usage: og <tool> [args]
        og exomiser report [args]
        og lookup query|resolve|report [args]
        og dev parity-compare|contract|schema|report-only|remnants [args]
+       og dev scan personal-data|images [args]
+       og dev versions check-run|expand|coupled [args]
+       og dev pgs trait|label-match|metric-match [args]
        og dev freshness [--out FILE] [--sections a,b] | --update-issue BODY --repo O/N | --self-test
        og version
        og --tree-hash

From 2d60f679993627e65726faaf627a7c8d7d120bc1 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 11:11:50 +0100
Subject: [PATCH 04/76] refactor(ci): check the Renovate dry run with og dev
 renovate-check

The 210-line checker the workflow wrote into a file is now an og dev verb;
its pins table is data in scripts/ci/renovate-pins.tsv, where a missing file
or a glob that matches nothing is an error. On the last saved log of main
it prints the same lines as the Python, clean and with planted pins.

Bead: pgp-bs9u.39
---
 .github/workflows/renovate-dry-run.yml | 237 +------
 rust/crates/og-dev/src/lib.rs          |   6 +-
 rust/crates/og-dev/src/renovate.rs     | 847 +++++++++++++++++++++++++
 scripts/ci/renovate-pins.tsv           |  25 +
 4 files changed, 894 insertions(+), 221 deletions(-)
 create mode 100644 rust/crates/og-dev/src/renovate.rs
 create mode 100644 scripts/ci/renovate-pins.tsv

diff --git a/.github/workflows/renovate-dry-run.yml b/.github/workflows/renovate-dry-run.yml
index 5722cb025..155568c19 100644
--- a/.github/workflows/renovate-dry-run.yml
+++ b/.github/workflows/renovate-dry-run.yml
@@ -6,7 +6,8 @@ name: Renovate dry run
 # matcher that misses an image, or a versioning that cannot read a tag, shows
 # up here first. The full debug log is kept as an artifact for 14 days.
 #
-# The checks (each one has a planted fault in the self-test step):
+# The checks (og dev renovate-check; each one has a planted fault in its
+# self-test, which runs after the checks):
 #   count    every *_IMAGE line of versions.env is a detected docker dependency
 #   names    no package name carries a ':' or '@' (a digest line once became
 #            a package named '...@sha256')
@@ -16,9 +17,10 @@ name: Renovate dry run
 #   one-pr   a tool gets the same proposal in every file it is in
 #   pins     every non-image pin (Nextflow, actionlint, gitleaks, ShellCheck,
 #            the Renovate CLI, the HLA database, pgsc_calc, the demo's Python
-#            packages, Aldy, the docs workflow's Python) is detected in every
-#            place it is pinned, as often as the text has them. A setup-nextflow
-#            step counts as a pin only when its version: line is a literal
+#            packages, Aldy, the docs workflow's Python; one row each in
+#            scripts/ci/renovate-pins.tsv) is detected in every place it is
+#            pinned, as often as the text has them. A setup-nextflow step
+#            counts as a pin only when its version: line is a literal
 #            version, quoted or not; a computed one (an expression) is not a pin
 #   lookups  no lookup failed and no tag was unreadable; the only skipped
 #            dependencies are the ones a rule in renovate.json disables
@@ -31,7 +33,8 @@ on:
   # Every file a manager in renovate.json reads (the workflows hold the
   # Nextflow, actionlint, gitleaks, ShellCheck, Renovate and docs Python pins,
   # the docs the NXF_VER lines and the Aldy pin, scripts/lib/common.sh the HLA
-  # database, the demo script its Python packages), plus the doc generator.
+  # database, the demo script its Python packages), plus the doc generator,
+  # the pins table and the checker.
   # The lookups take about a minute.
   pull_request:
     branches: [main]
@@ -42,6 +45,8 @@ on:
       - 'docs/*.md'
       - '.github/workflows/**'
       - 'scripts/ci/gen-versions-doc.sh'
+      - 'scripts/ci/renovate-pins.tsv'
+      - 'rust/crates/og-dev/src/renovate.rs'
       - 'scripts/lib/common.sh'
       - 'tests/demo/retake-screenshots.sh'
   push:
@@ -91,7 +96,7 @@ jobs:
   lookup:
     # Public repo: GitHub-hosted runners only.
     runs-on: ubuntu-latest
-    timeout-minutes: 20
+    timeout-minutes: 40
     env:
       RENOVATE_VERSION: 44.199.2
     steps:
@@ -129,222 +134,14 @@ jobs:
           path: ${{ runner.temp }}/renovate.log
           retention-days: 14
 
-      - name: Write the checker
+      # The checks are og dev renovate-check (rust/crates/og-dev/src/renovate.rs),
+      # with the non-image pins in scripts/ci/renovate-pins.tsv.
+      - name: Build og as scripts/setup.sh --og does
         if: ${{ !cancelled() && steps.lookup.outcome == 'success' }}
         run: |
-          cat > "${RUNNER_TEMP}/check.py" <<'PY'
-          import collections, copy, glob, json, os, re, sys
-
-          ENV = "versions.env"
-          TWINS = ("docs/versions.md", "conf/containers.config")
-          RULE_SKIPS = {"disabled", "package-rules"}
-          # The non-image pins: (dependency, files, how a pin of it looks in that text).
-          # A setup-nextflow step is a pin when a version: line with a literal
-          # version follows its uses: line inside the same step (the lines in
-          # between are blank or start with anything but '-', which opens the
-          # next step).
-          SETUP_NEXTFLOW = r'uses: ["\x27]?nf-core/setup-nextflow@[^\n]*\n(?:[ \t]*(?:[^\s-][^\n]*)?\n)*?[ \t]+version: ["\x27]?\d'
-          DEMO = "tests/demo/retake-screenshots.sh"
-          PINS = (
-              ("nextflow-io/nextflow", [ENV], r'^NEXTFLOW_VERSION="'),
-              ("nextflow-io/nextflow", sorted(glob.glob(".github/workflows/*.yml")), SETUP_NEXTFLOW),
-              ("nextflow-io/nextflow", sorted(glob.glob("docs/*.md")), r"NXF_VER=\d"),
-              ("rhysd/actionlint", sorted(glob.glob(".github/workflows/*.yml")), r"ACTIONLINT_VERSION=\d"),
-              ("gitleaks/gitleaks", sorted(glob.glob(".github/workflows/*.yml")), r"GITLEAKS_VERSION=\d"),
-              ("koalaman/shellcheck", [".github/workflows/lint.yml"], r"^[ \t]+version: v\d"),
-              ("renovate", [".github/workflows/renovate-dry-run.yml"], r"RENOVATE_VERSION: \d"),
-              ("renovate", ["docs/updating.md"], r"renovate@\d"),
-              ("python", [".github/workflows/docs.yml"], r"python-version: ['\"]?\d"),
-              ("ANHIG/IMGTHLA", ["scripts/lib/common.sh"], r"^HLA_DB_RELEASE=\$\{HLA_DB_RELEASE:-\d"),
-              ("PGScatalog/pgsc_calc", [ENV], r'^PGSC_CALC_VERSION="'),
-              ("PGScatalog/pgsc_calc", ["conf/containers.config"], r"ext\.pipeline_version = '"),
-              ("playwright", [DEMO], r"playwright==\d"),
-              ("pillow", [DEMO], r"pillow==\d"),
-              ("pyobjc-framework-Vision", [DEMO], r"pyobjc-framework-Vision==\d"),
-              ("aldy", ["docs/21-cyrius.md"], r"aldy==\d|\[Aldy\]\([^)]*\) v\d"),
-          )
-          # Only the files a pin is listed for are counted: python is also the
-          # docker image of versions.env, which the image checks cover.
-          PIN_FILES = collections.defaultdict(set)
-          for _name, _files, _ in PINS:
-              PIN_FILES[_name].update(_files)
-
-          def pin_counts():
-              want = collections.Counter()
-              for name, files, pattern in PINS:
-                  for f in files:
-                      n = len(re.findall(pattern, open(f).read(), re.M))
-                      if n:
-                          want[(name, f)] += n
-              return want
-
-          def load(log):
-              files = None
-              for line in open(log):
-                  try:
-                      rec = json.loads(line)
-                  except ValueError:
-                      continue
-                  if rec.get("msg") == "packageFiles with updates":
-                      files = rec["config"]
-              if files is None:
-                  sys.exit("FAIL: no 'packageFiles with updates' record in %s" % log)
-              return [(pf["packageFile"], dep) for entries in files.values() for pf in entries for dep in pf.get("deps", [])]
-
-          def env_images(text):
-              out = []
-              for m in re.finditer(r'^[A-Z0-9_]+_IMAGE="([^"]*)"', text, re.M):
-                  # name:tag@sha256:..., name@sha256:... or name:tag -> name
-                  out.append(re.sub(r":[^:/]*$", "", m.group(1).split("@", 1)[0]))
-              return out
-
-          def key(dep):
-              return (dep.get("depName"), dep.get("currentValue"), dep.get("currentDigest"))
-
-          def proposals(dep):
-              return sorted((u.get("newValue") or "", u.get("newDigest") or "") for u in dep.get("updates", []))
-
-          def check(deps, env_text):
-              fails = []
-              docker = [(f, d) for f, d in deps if d.get("datasource") == "docker"]
-              by_file = collections.defaultdict(list)
-              for f, d in docker:
-                  by_file[f].append(d)
-              want = env_images(env_text)
-              got = [d.get("depName") for d in by_file[ENV]]
-              if len(got) != len(want):
-                  fails.append("count: versions.env has %d *_IMAGE lines, Renovate found %d docker dependencies there" % (len(want), len(got)))
-              for name in sorted(set(want) - set(got)):
-                  fails.append("count: %s (versions.env) is not a detected dependency" % name)
-              for f, d in docker:
-                  if re.search(r"[:@]", d.get("depName") or ":"):
-                      fails.append("names: %s: package name %r" % (f, d.get("depName")))
-              env_keys = collections.Counter(key(d) for d in by_file[ENV])
-              for f in TWINS:
-                  keys = collections.Counter(key(d) for d in by_file[f])
-                  if f == "docs/versions.md" and keys != env_keys:
-                      for k in sorted((keys - env_keys) | (env_keys - keys), key=str):
-                          fails.append("twins: docs/versions.md and versions.env differ on %s" % (k,))
-                  else:
-                      for k in sorted(set(keys) - set(env_keys), key=str):
-                          fails.append("twins: %s has %s, which versions.env does not" % (f, k))
-              seen = {}
-              for f, d in deps:
-                  name = (d.get("datasource"), d.get("depName"), d.get("currentValue"), d.get("currentDigest"))
-                  p = proposals(d)
-                  if name in seen and seen[name][1] != p:
-                      fails.append("one-pr: %s gets %s in %s but %s in %s" % (d.get("depName"), seen[name][1], seen[name][0], p, f))
-                  seen.setdefault(name, (f, p))
-              for f, d in deps:
-                  if d.get("warnings"):
-                      fails.append("lookups: %s (%s): %s" % (d.get("depName"), f, "; ".join(w.get("message", str(w)) for w in d["warnings"])))
-                  if d.get("skipReason") and d["skipReason"] not in RULE_SKIPS:
-                      fails.append("lookups: %s (%s) skipped: %s" % (d.get("depName"), f, d["skipReason"]))
-              got = collections.Counter((d.get("depName"), f) for f, d in deps
-                                        if f in PIN_FILES.get(d.get("depName"), ()))
-              for k in sorted(set(want_pins) | set(got)):
-                  if want_pins[k] != got[k]:
-                      fails.append("pins: %s in %s: the text pins it %d times, Renovate found %d" % (k[0], k[1], want_pins[k], got[k]))
-              return fails
-
-          def self_test(deps, env_text):
-              ok = True
-              base = set(check(deps, env_text))
-              def plant(label, fn, pattern):
-                  nonlocal ok
-                  d = copy.deepcopy(deps)
-                  try:
-                      fn(d)
-                  except StopIteration:
-                      print("self-test %-8s NOT PLANTED: no dependency to plant it on" % label)
-                      ok = False
-                      return
-                  # Only a failure the plant added counts as caught.
-                  hits = [x for x in check(d, env_text) if x.startswith(pattern) and x not in base]
-                  print("self-test %-8s %s" % (label, "caught: " + hits[0] if hits else "NOT CAUGHT"))
-                  ok = ok and bool(hits)
-              def first(d, f):
-                  return next(x for g, x in d if g == f and x.get("datasource") == "docker")
-              def drop(d):
-                  d.remove(next((g, x) for g, x in d if g == ENV and x.get("datasource") == "docker"))
-              def digest_name(d):
-                  first(d, ENV)["depName"] += "@sha256"
-              def stale_twin(d):
-                  first(d, "docs/versions.md")["currentValue"] = "0.0.0-planted"
-              def split_pr(d):
-                  first(d, "conf/containers.config")["updates"] = [{"newValue": "9.9.9-planted"}]
-              def drop_pin(d):
-                  d.remove(next((g, x) for g, x in d if g == ENV and x.get("depName") == "nextflow-io/nextflow"))
-              def broken_lookup(d):
-                  first(d, ENV)["skipReason"] = "invalid-value"
-              plant("count", drop, "count:")
-              plant("names", digest_name, "names:")
-              plant("twins", stale_twin, "twins:")
-              plant("one-pr", split_pr, "one-pr:")
-              plant("pins", drop_pin, "pins:")
-              plant("lookups", broken_lookup, "lookups:")
-              # The setup-nextflow pattern itself, on planted workflow text.
-              step = ('      - uses: %snf-core/setup-nextflow@%s%s # v3.0.1\n'
-                      '%s'
-                      '        if: steps.scope.outputs.run == \'true\'\n'
-                      '        with:\n'
-                      '          version: %s\n'
-                      '\n'
-                      '      - uses: actions/setup-java@%s # v6\n'
-                      '        with:\n'
-                      '          java-version: "17"\n')
-              for label, quote, gap, version, want in (
-                      ("computed", "", "", "$" + "{{ steps.nf.outputs.version }}", 0),
-                      ("computed, uses quoted", '"', "", "$" + "{{ steps.nf.outputs.version }}", 0),
-                      ("computed after a blank line", "", "\n", "$" + "{{ steps.nf.outputs.version }}", 0),
-                      ("literal", "", "", '"25.10.8"', 1),
-                      ("literal after a blank line", "", "\n", '"25.10.8"', 1),
-                      ("single-quoted literal", "'", "", "'25.10.8'", 1),
-                      ("bare literal, uses quoted", '"', "", "25.10.8", 1)):
-                  text = step % (quote, "a" * 40, quote, gap, version, "b" * 40)
-                  n = len(re.findall(SETUP_NEXTFLOW, text, re.M))
-                  print("self-test pin-text %-27s counted %d, want %d" % (label, n, want))
-                  ok = ok and n == want
-              clean = check(deps, env_text)
-              print("self-test clean    %s" % ("passes" if not clean else "fails: %s" % clean[0]))
-              return ok
-
-          def summary(deps):
-              rows, seen = [], set()
-              files = collections.defaultdict(set)
-              for f, d in deps:
-                  files[(d.get("datasource"), d.get("depName"))].add(f)
-              for f, d in deps:
-                  k = (d.get("datasource"), d.get("depName"))
-                  if k in seen:
-                      continue
-                  seen.add(k)
-                  cur = d.get("currentValue") or d.get("currentDigest") or ""
-                  ups = ", ".join("%s (%s)" % (u.get("newValue") or u.get("newDigest"), u.get("updateType"))
-                                  for u in d.get("updates", [])) or "none"
-                  note = d.get("skipReason") or ""
-                  rows.append("| `%s` | `%s` | %s | %s | %d |" % (d.get("depName"), cur, ups, note, len(files[k])))
-              return "\n".join(["| Dependency | Current | Proposed update | Skipped | Files |", "|---|---|---|---|---|"] + rows)
-
-          deps = load(sys.argv[1])
-          env_text = open(ENV).read()
-          want_pins = pin_counts()
-          table = summary(deps)
-          print(table)
-          if os.environ.get("GITHUB_STEP_SUMMARY"):
-              with open(os.environ["GITHUB_STEP_SUMMARY"], "a") as out:
-                  out.write("## Renovate dry run\n\n" + table + "\n")
-          fails = check(deps, env_text)
-          for x in fails:
-              print("FAIL " + x)
-          if not self_test(deps, env_text):
-              fails.append("the self-test did not catch a planted fault")
-              print("FAIL the self-test did not catch a planted fault")
-          if fails:
-              sys.exit(1)
-          print("OK: %d dependencies; every check passed" % len(deps))
-          PY
+          scripts/setup.sh --og
+          rust/og.sh check --required
 
       - name: Check what Renovate found
         if: ${{ !cancelled() && steps.lookup.outcome == 'success' }}
-        run: python3 "${RUNNER_TEMP}/check.py" "${RUNNER_TEMP}/renovate.log"
+        run: bin/og dev renovate-check "${RUNNER_TEMP}/renovate.log"
diff --git a/rust/crates/og-dev/src/lib.rs b/rust/crates/og-dev/src/lib.rs
index 918237714..ae345abbc 100644
--- a/rust/crates/og-dev/src/lib.rs
+++ b/rust/crates/og-dev/src/lib.rs
@@ -16,19 +16,22 @@
 //!   compound-het reads, a trimmed PharmCAT report).
 //! - `og dev evidence` ([`evidence`]): the measurements of the public
 //!   evidence workflow on GIAB's HG002.
+//! - `og dev renovate-check LOG` ([`renovate`]): what a Renovate dry run
+//!   found, against every pin in the repository.
 
 pub mod contract;
 pub mod evidence;
 pub mod fixture;
 pub mod parity;
 pub mod remnants;
+pub mod renovate;
 pub mod report_only;
 pub mod schema;
 mod zip;
 
 use std::io::Write;
 
-const USAGE: &str = "usage: og dev parity-compare KIND ORACLE NEW\n       og dev parity-compare --self-test\n       og dev contract --static [--repo DIR] [--contract FILE]\n       og dev contract --outputs DIR --leg bash|nextflow --sample S [--observe]\n       og dev schema SCHEMA.json DOC.json\n       og dev report-only [--repo DIR]\n       og dev remnants [--list FILE] [--root DIR]\n       og dev fixture comphet|trim-pharmcat [args]\n       og dev evidence clashes|hg002-gvcf [args]\n";
+const USAGE: &str = "usage: og dev parity-compare KIND ORACLE NEW\n       og dev parity-compare --self-test\n       og dev contract --static [--repo DIR] [--contract FILE]\n       og dev contract --outputs DIR --leg bash|nextflow --sample S [--observe]\n       og dev schema SCHEMA.json DOC.json\n       og dev report-only [--repo DIR]\n       og dev remnants [--list FILE] [--root DIR]\n       og dev fixture comphet|trim-pharmcat [args]\n       og dev evidence clashes|hg002-gvcf [args]\n       og dev renovate-check LOG [--pins FILE] [--repo DIR]\n";
 
 /// Python's `str(OSError)`: `[Errno 2] No such file or directory: 'path'`.
 pub(crate) fn py_os_error(e: &std::io::Error, path: &str) -> String {
@@ -65,6 +68,7 @@ pub fn main(args: &[String]) -> u8 {
         Some("report-only") => run(report_only::cli, &args[1..]),
         Some("fixture") => run(fixture::cli, &args[1..]),
         Some("evidence") => run(evidence::cli, &args[1..]),
+        Some("renovate-check") => run(renovate::cli, &args[1..]),
         Some("-h" | "--help") => {
             print!("{USAGE}");
             0
diff --git a/rust/crates/og-dev/src/renovate.rs b/rust/crates/og-dev/src/renovate.rs
new file mode 100644
index 000000000..f3355c766
--- /dev/null
+++ b/rust/crates/og-dev/src/renovate.rs
@@ -0,0 +1,847 @@
+//! `og dev renovate-check LOG [--pins FILE] [--repo DIR]`: checks what a
+//! Renovate dry run (`renovate --platform=local --dry-run=lookup`, JSON
+//! debug log) found against every pin in the repository. It replaces the
+//! Python the `renovate-dry-run.yml` workflow wrote into a file and ran.
+//!
+//! The checks, each with a planted fault in the self-test that runs after
+//! them:
+//!
+//! - `count`: every `*_IMAGE` line of `versions.env` is a detected docker
+//!   dependency;
+//! - `names`: no docker package name carries a `:` or `@`;
+//! - `twins`: `docs/versions.md` holds exactly the images of `versions.env`,
+//!   and `conf/containers.config` holds only those;
+//! - `one-pr`: a dependency gets the same proposals in every file it is in;
+//! - `pins`: every non-image pin of the pins table
+//!   (`scripts/ci/renovate-pins.tsv`) is detected as often as its file pins
+//!   it;
+//! - `lookups`: no lookup failed, no tag was unreadable, and the only
+//!   skipped dependencies are the ones a rule in `renovate.json` disables.
+//!
+//! The pins table has three tab-separated columns: the dependency, a file
+//! or a glob of files (relative to the repository; `*` and `?` in the last
+//! part), and a regular expression for one pin of it in that text, read
+//! with `^` and `$` at line ends. A file that is missing, or a glob that
+//! matches nothing, is an error (exit 2): a pin counted in no file could
+//! never fail.
+//!
+//! Output: the Markdown table of every dependency and its proposed update
+//! (also appended to `$GITHUB_STEP_SUMMARY`), one `FAIL <check>: ...` line
+//! per problem, the self-test lines, then `OK: N dependencies; every check
+//! passed`. Exit 0 when clean, 1 on a finding, a self-test miss, or a log
+//! without its `packageFiles with updates` record, 2 on a usage error or a
+//! pins table it cannot use.
+
+use indexmap::IndexMap;
+use pycompat::json::{self, Value};
+use pycompat::value::{py_repr, py_str, truthy};
+use regex::Regex;
+use std::collections::{BTreeMap, BTreeSet, HashMap};
+use std::fs;
+use std::io::{BufRead, BufReader, Write};
+use std::path::Path;
+
+const USAGE: &str = "usage: og dev renovate-check LOG [--pins FILE] [--repo DIR]\n";
+const ENV: &str = "versions.env";
+const DOCS: &str = "docs/versions.md";
+const CONFIG: &str = "conf/containers.config";
+const TWINS: [&str; 2] = [DOCS, CONFIG];
+const RULE_SKIPS: [&str; 2] = ["disabled", "package-rules"];
+const PINS: &str = "scripts/ci/renovate-pins.tsv";
+
+/// One dependency Renovate found: the file it is in and its record.
+type Dep = (String, IndexMap<String, Value>);
+
+/// The pins table, expanded: per (dependency, file) how many pins the text
+/// holds, and per dependency the files listed for it.
+struct Pins {
+    want: BTreeMap<(String, String), usize>,
+    files: HashMap<String, BTreeSet<String>>,
+    setup_nextflow: Option<Regex>,
+}
+
+/// Runs `og dev renovate-check ARGS`; returns the exit code.
+pub fn cli(args: &[String], out: &mut dyn Write, err: &mut dyn Write) -> u8 {
+    let (mut log, mut pins, mut repo) = (None, PINS.to_owned(), ".".to_owned());
+    let mut it = args.iter();
+    while let Some(a) = it.next() {
+        match a.as_str() {
+            "-h" | "--help" => {
+                let _ = out.write_all(USAGE.as_bytes());
+                return 0;
+            }
+            "--pins" | "--repo" => {
+                let Some(v) = it.next() else {
+                    let _ = writeln!(
+                        err,
+                        "{USAGE}og dev renovate-check: error: {a} needs a value"
+                    );
+                    return 2;
+                };
+                if a == "--pins" {
+                    pins = v.clone();
+                } else {
+                    repo = v.clone();
+                }
+            }
+            _ if log.is_none() => log = Some(a.clone()),
+            _ => {
+                let _ = writeln!(
+                    err,
+                    "{USAGE}og dev renovate-check: error: unexpected argument '{a}'"
+                );
+                return 2;
+            }
+        }
+    }
+    let Some(log) = log else {
+        let _ = writeln!(
+            err,
+            "{USAGE}og dev renovate-check: error: the following arguments are required: LOG"
+        );
+        return 2;
+    };
+    let repo = Path::new(&repo);
+    let pins = match read_pins(repo, &repo.join(&pins)) {
+        Ok(p) => p,
+        Err(e) => {
+            let _ = writeln!(err, "og dev renovate-check: {e}");
+            return 2;
+        }
+    };
+    let env_text = match fs::read_to_string(repo.join(ENV)) {
+        Ok(t) => t,
+        Err(e) => {
+            let _ = writeln!(err, "og dev renovate-check: {ENV}: {e}");
+            return 2;
+        }
+    };
+    let deps = match load(&log) {
+        Ok(d) => d,
+        Err(e) => {
+            let _ = writeln!(err, "{e}");
+            return 1;
+        }
+    };
+    let table = summary(&deps);
+    let _ = writeln!(out, "{table}");
+    if let Some(path) = std::env::var_os("GITHUB_STEP_SUMMARY").filter(|p| !p.is_empty()) {
+        let appended = fs::OpenOptions::new()
+            .append(true)
+            .create(true)
+            .open(&path)
+            .and_then(|mut f| write!(f, "## Renovate dry run\n\n{table}\n"));
+        if let Err(e) = appended {
+            let _ = writeln!(err, "og dev renovate-check: GITHUB_STEP_SUMMARY: {e}");
+        }
+    }
+    let mut fails = check(&deps, &env_text, &pins);
+    for x in &fails {
+        let _ = writeln!(out, "FAIL {x}");
+    }
+    if !self_test(&deps, &env_text, &pins, out) {
+        fails.push("the self-test did not catch a planted fault".to_owned());
+        let _ = writeln!(out, "FAIL the self-test did not catch a planted fault");
+    }
+    if !fails.is_empty() {
+        return 1;
+    }
+    let _ = writeln!(out, "OK: {} dependencies; every check passed", deps.len());
+    0
+}
+
+/// `fnmatch` for `*` and `?`, case-sensitive.
+fn fnmatch(pat: &[u8], name: &[u8]) -> bool {
+    match pat.split_first() {
+        None => name.is_empty(),
+        Some((b'*', rest)) => (0..=name.len()).any(|i| fnmatch(rest, &name[i..])),
+        Some((b'?', rest)) => !name.is_empty() && fnmatch(rest, &name[1..]),
+        Some((c, rest)) => name.first() == Some(c) && fnmatch(rest, &name[1..]),
+    }
+}
+
+/// The files of `pattern` under `repo`, relative and sorted, as Python's
+/// `sorted(glob.glob(pattern))` lists them: a wildcard never matches a name
+/// that starts with a dot unless the pattern does.
+fn glob(repo: &Path, pattern: &str) -> Result<Vec<String>, String> {
+    let (dir, last) = pattern.rsplit_once('/').unwrap_or(("", pattern));
+    if dir.contains(['*', '?']) {
+        return Err(format!(
+            "{pattern}: a wildcard is allowed only in the last part"
+        ));
+    }
+    if !last.contains(['*', '?']) {
+        return if repo.join(pattern).is_file() {
+            Ok(vec![pattern.to_owned()])
+        } else {
+            Err(format!("{pattern} is not a file"))
+        };
+    }
+    let mut out = Vec::new();
+    let entries = fs::read_dir(repo.join(if dir.is_empty() { "." } else { dir }))
+        .map_err(|e| format!("{pattern}: {e}"))?;
+    for e in entries {
+        let name = e.map_err(|e| format!("{pattern}: {e}"))?.file_name();
+        let name = name.to_string_lossy();
+        if (name.starts_with('.') && !last.starts_with('.'))
+            || !fnmatch(last.as_bytes(), name.as_bytes())
+        {
+            continue;
+        }
+        out.push(if dir.is_empty() {
+            name.into_owned()
+        } else {
+            format!("{dir}/{name}")
+        });
+    }
+    out.sort();
+    if out.is_empty() {
+        return Err(format!("{pattern} matches no file"));
+    }
+    Ok(out)
+}
+
+fn read_pins(repo: &Path, path: &Path) -> Result<Pins, String> {
+    let text = fs::read_to_string(path).map_err(|e| format!("{}: {e}", path.display()))?;
+    let mut pins = Pins {
+        want: BTreeMap::new(),
+        files: HashMap::new(),
+        setup_nextflow: None,
+    };
+    let mut texts: HashMap<String, String> = HashMap::new();
+    for (i, line) in text.lines().enumerate() {
+        if line.is_empty() || line.starts_with('#') {
+            continue;
+        }
+        let at = |msg: &str| format!("{}:{}: {msg}", path.display(), i + 1);
+        let cols: Vec<&str> = line.split('\t').collect();
+        let [dep, files, pattern] = cols[..] else {
+            return Err(at(
+                "want three tab-separated columns: dependency, file or glob, pattern",
+            ));
+        };
+        let re = Regex::new(&format!("(?m){pattern}")).map_err(|e| at(&e.to_string()))?;
+        if pattern.contains("setup-nextflow") {
+            pins.setup_nextflow = Some(re.clone());
+        }
+        for f in glob(repo, files).map_err(|e| at(&e))? {
+            if !texts.contains_key(&f) {
+                let t = fs::read_to_string(repo.join(&f)).map_err(|e| at(&format!("{f}: {e}")))?;
+                texts.insert(f.clone(), t);
+            }
+            let n = re.find_iter(&texts[&f]).count();
+            if n > 0 {
+                *pins.want.entry((dep.to_owned(), f.clone())).or_default() += n;
+            }
+            pins.files.entry(dep.to_owned()).or_default().insert(f);
+        }
+    }
+    Ok(pins)
+}
+
+/// Every dependency of the log's last `packageFiles with updates` record.
+fn load(log: &str) -> Result<Vec<Dep>, String> {
+    let f = fs::File::open(log).map_err(|e| format!("FAIL: cannot read {log}: {e}"))?;
+    let mut files = None;
+    let mut r = BufReader::new(f);
+    let mut buf = Vec::new();
+    loop {
+        buf.clear();
+        if r.read_until(b'\n', &mut buf)
+            .map_err(|e| format!("FAIL: cannot read {log}: {e}"))?
+            == 0
+        {
+            break;
+        }
+        let Ok(Value::Object(mut rec)) = json::loads(&String::from_utf8_lossy(&buf)) else {
+            continue;
+        };
+        if rec.get("msg") == Some(&Value::Str("packageFiles with updates".to_owned())) {
+            files = Some(rec.swap_remove("config").unwrap_or(Value::Null));
+        }
+    }
+    let Some(files) = files else {
+        return Err(format!(
+            "FAIL: no 'packageFiles with updates' record in {log}"
+        ));
+    };
+    let shape = || {
+        format!(
+            "FAIL: the 'packageFiles with updates' record of {log} is not a map of package file lists"
+        )
+    };
+    let Value::Object(files) = files else {
+        return Err(shape());
+    };
+    let mut deps = Vec::new();
+    for entries in files.into_values() {
+        let Value::Array(entries) = entries else {
+            return Err(shape());
+        };
+        for pf in entries {
+            let Value::Object(mut pf) = pf else {
+                return Err(shape());
+            };
+            let name = pf
+                .get("packageFile")
+                .map(py_str)
+                .ok_or_else(shape)?
+                .map_err(|_| shape())?;
+            if let Some(Value::Array(ds)) = pf.swap_remove("deps") {
+                for d in ds {
+                    let Value::Object(d) = d else {
+                        return Err(shape());
+                    };
+                    deps.push((name.clone(), d));
+                }
+            }
+        }
+    }
+    Ok(deps)
+}
+
+fn get<'a>(d: &'a IndexMap<String, Value>, k: &str) -> &'a Value {
+    d.get(k).unwrap_or(&Value::Null)
+}
+
+/// Python's `"%s" % v`.
+fn s(v: &Value) -> String {
+    py_str(v).unwrap_or_else(|_| format!("{v:?}"))
+}
+
+/// Python's `repr(v)`.
+fn r(v: &Value) -> String {
+    py_repr(v).unwrap_or_else(|_| format!("{v:?}"))
+}
+
+/// `repr` of a tuple of values.
+fn tuple(vs: &[&Value]) -> String {
+    let items: Vec<String> = vs.iter().map(|v| r(v)).collect();
+    format!("({})", items.join(", "))
+}
+
+fn is_docker(d: &IndexMap<String, Value>) -> bool {
+    get(d, "datasource") == &Value::Str("docker".to_owned())
+}
+
+/// The image names of `versions.env`: `name:tag@sha256:...`,
+/// `name@sha256:...` and `name:tag` all give `name`.
+fn env_images(text: &str) -> Vec<String> {
+    let line = Regex::new(r#"(?m)^[A-Z0-9_]+_IMAGE="([^"]*)""#).expect("a valid pattern");
+    let tag = Regex::new(r":[^:/]*$").expect("a valid pattern");
+    line.captures_iter(text)
+        .map(|c| {
+            let v = c[1].split('@').next().unwrap_or("");
+            tag.replace(v, "").into_owned()
+        })
+        .collect()
+}
+
+/// `(depName, currentValue, currentDigest)` as Python prints the tuple.
+fn key(d: &IndexMap<String, Value>) -> String {
+    tuple(&[
+        get(d, "depName"),
+        get(d, "currentValue"),
+        get(d, "currentDigest"),
+    ])
+}
+
+/// `v or ""`.
+fn or_empty(v: &Value) -> Value {
+    if truthy(v) {
+        v.clone()
+    } else {
+        Value::Str(String::new())
+    }
+}
+
+/// The updates as sorted `(newValue or "", newDigest or "")` pairs, printed
+/// as Python prints the list.
+fn proposals(d: &IndexMap<String, Value>) -> String {
+    let mut ps: Vec<(Value, Value)> = updates(d)
+        .iter()
+        .map(|u| match u {
+            Value::Object(u) => (or_empty(get(u, "newValue")), or_empty(get(u, "newDigest"))),
+            _ => (Value::Null, Value::Null),
+        })
+        .collect();
+    ps.sort_by(|a, b| (s(&a.0), s(&a.1)).cmp(&(s(&b.0), s(&b.1))));
+    let items: Vec<String> = ps.iter().map(|(a, b)| tuple(&[a, b])).collect();
+    format!("[{}]", items.join(", "))
+}
+
+fn updates(d: &IndexMap<String, Value>) -> &[Value] {
+    match d.get("updates") {
+        Some(Value::Array(u)) => u,
+        _ => &[],
+    }
+}
+
+fn counter<'a>(it: impl Iterator<Item = &'a IndexMap<String, Value>>) -> BTreeMap<String, usize> {
+    let mut c = BTreeMap::new();
+    for d in it {
+        *c.entry(key(d)).or_default() += 1;
+    }
+    c
+}
+
+/// The docker dependencies of one file.
+fn in_file<'a>(
+    docker: &'a [&'a Dep],
+    f: &'a str,
+) -> impl Iterator<Item = &'a IndexMap<String, Value>> {
+    docker.iter().filter(move |(g, _)| g == f).map(|(_, d)| d)
+}
+
+/// Every problem, as `check: ...` lines.
+fn check(deps: &[Dep], env_text: &str, pins: &Pins) -> Vec<String> {
+    let mut fails = Vec::new();
+    let docker: Vec<&Dep> = deps.iter().filter(|(_, d)| is_docker(d)).collect();
+    let want = env_images(env_text);
+    let got: Vec<&Value> = in_file(&docker, ENV).map(|d| get(d, "depName")).collect();
+    if got.len() != want.len() {
+        fails.push(format!(
+            "count: versions.env has {} *_IMAGE lines, Renovate found {} docker dependencies there",
+            want.len(),
+            got.len()
+        ));
+    }
+    let want_set: BTreeSet<&String> = want.iter().collect();
+    for name in want_set {
+        if !got.contains(&&Value::Str(name.clone())) {
+            fails.push(format!(
+                "count: {name} (versions.env) is not a detected dependency"
+            ));
+        }
+    }
+    for (f, d) in &docker {
+        let name = get(d, "depName");
+        let text = if truthy(name) {
+            s(name)
+        } else {
+            ":".to_owned()
+        };
+        if text.contains([':', '@']) {
+            fails.push(format!("names: {f}: package name {}", r(name)));
+        }
+    }
+    let env_keys = counter(in_file(&docker, ENV));
+    for f in TWINS {
+        let keys = counter(in_file(&docker, f));
+        if f == DOCS && keys != env_keys {
+            let all: BTreeSet<&String> = keys.keys().chain(env_keys.keys()).collect();
+            for k in all {
+                if keys.get(k) != env_keys.get(k) {
+                    fails.push(format!(
+                        "twins: docs/versions.md and versions.env differ on {k}"
+                    ));
+                }
+            }
+        } else {
+            for k in keys.keys().filter(|k| !env_keys.contains_key(*k)) {
+                fails.push(format!("twins: {f} has {k}, which versions.env does not"));
+            }
+        }
+    }
+    let mut seen: HashMap<String, (&str, String)> = HashMap::new();
+    for (f, d) in deps {
+        let name = tuple(&[
+            get(d, "datasource"),
+            get(d, "depName"),
+            get(d, "currentValue"),
+            get(d, "currentDigest"),
+        ]);
+        let p = proposals(d);
+        match seen.get(&name) {
+            Some((first, q)) if *q != p => fails.push(format!(
+                "one-pr: {} gets {q} in {first} but {p} in {f}",
+                s(get(d, "depName"))
+            )),
+            Some(_) => {}
+            None => {
+                seen.insert(name, (f, p));
+            }
+        }
+    }
+    for (f, d) in deps {
+        let warnings = get(d, "warnings");
+        if truthy(warnings) {
+            let msgs: Vec<String> = match warnings {
+                Value::Array(ws) => ws
+                    .iter()
+                    .map(|w| match w {
+                        Value::Object(o) if o.contains_key("message") => s(get(o, "message")),
+                        w => s(w),
+                    })
+                    .collect(),
+                w => vec![s(w)],
+            };
+            fails.push(format!(
+                "lookups: {} ({f}): {}",
+                s(get(d, "depName")),
+                msgs.join("; ")
+            ));
+        }
+        let skip = get(d, "skipReason");
+        if truthy(skip) && !RULE_SKIPS.contains(&s(skip).as_str()) {
+            fails.push(format!(
+                "lookups: {} ({f}) skipped: {}",
+                s(get(d, "depName")),
+                s(skip)
+            ));
+        }
+    }
+    let mut got: BTreeMap<(String, String), usize> = BTreeMap::new();
+    for (f, d) in deps {
+        if let Value::Str(name) = get(d, "depName")
+            && pins.files.get(name).is_some_and(|fs| fs.contains(f))
+        {
+            *got.entry((name.clone(), f.clone())).or_default() += 1;
+        }
+    }
+    let all: BTreeSet<&(String, String)> = pins.want.keys().chain(got.keys()).collect();
+    for k in all {
+        let (w, g) = (
+            pins.want.get(k).copied().unwrap_or(0),
+            got.get(k).copied().unwrap_or(0),
+        );
+        if w != g {
+            fails.push(format!(
+                "pins: {} in {}: the text pins it {w} times, Renovate found {g}",
+                k.0, k.1
+            ));
+        }
+    }
+    fails
+}
+
+/// Plants one fault of each kind in a copy of the dependencies and shows
+/// that the check it belongs to catches it; true when every one is caught.
+fn self_test(deps: &[Dep], env_text: &str, pins: &Pins, out: &mut dyn Write) -> bool {
+    let mut ok = true;
+    let base: BTreeSet<String> = check(deps, env_text, pins).into_iter().collect();
+    let first = |d: &[Dep], f: &str| d.iter().position(|(g, x)| g == f && is_docker(x));
+    type Plant = fn(&mut Vec<Dep>, usize);
+    let plants: [(&str, &str, Option<&str>, Plant); 6] = [
+        ("count", "count:", Some(ENV), |d, i| {
+            d.remove(i);
+        }),
+        ("names", "names:", Some(ENV), |d, i| {
+            let name = format!("{}@sha256", s(get(&d[i].1, "depName")));
+            d[i].1.insert("depName".to_owned(), Value::Str(name));
+        }),
+        ("twins", "twins:", Some(DOCS), |d, i| {
+            d[i].1.insert(
+                "currentValue".to_owned(),
+                Value::Str("0.0.0-planted".to_owned()),
+            );
+        }),
+        ("one-pr", "one-pr:", Some(CONFIG), |d, i| {
+            let u = IndexMap::from([(
+                "newValue".to_owned(),
+                Value::Str("9.9.9-planted".to_owned()),
+            )]);
+            d[i].1
+                .insert("updates".to_owned(), Value::Array(vec![Value::Object(u)]));
+        }),
+        ("pins", "pins:", None, |d, i| {
+            d.remove(i);
+        }),
+        ("lookups", "lookups:", Some(ENV), |d, i| {
+            d[i].1.insert(
+                "skipReason".to_owned(),
+                Value::Str("invalid-value".to_owned()),
+            );
+        }),
+    ];
+    for (label, pattern, file, plant) in plants {
+        let at = match file {
+            Some(f) => first(deps, f),
+            None => deps.iter().position(|(g, x)| {
+                g == ENV && get(x, "depName") == &Value::Str("nextflow-io/nextflow".to_owned())
+            }),
+        };
+        let Some(i) = at else {
+            let _ = writeln!(
+                out,
+                "self-test {label:<8} NOT PLANTED: no dependency to plant it on"
+            );
+            ok = false;
+            continue;
+        };
+        let mut d = deps.to_vec();
+        plant(&mut d, i);
+        // Only a failure the plant added counts as caught.
+        let hit = check(&d, env_text, pins)
+            .into_iter()
+            .find(|x| x.starts_with(pattern) && !base.contains(x));
+        match hit {
+            Some(h) => {
+                let _ = writeln!(out, "self-test {label:<8} caught: {h}");
+            }
+            None => {
+                let _ = writeln!(out, "self-test {label:<8} NOT CAUGHT");
+                ok = false;
+            }
+        }
+    }
+    // The setup-nextflow pattern itself, on planted workflow text.
+    let Some(setup) = &pins.setup_nextflow else {
+        let _ = writeln!(
+            out,
+            "self-test pin-text  NOT PLANTED: the pins table has no setup-nextflow pattern"
+        );
+        return false;
+    };
+    let computed = "${{ steps.nf.outputs.version }}";
+    let cases: [(&str, &str, &str, &str, usize); 7] = [
+        ("computed", "", "", computed, 0),
+        ("computed, uses quoted", "\"", "", computed, 0),
+        ("computed after a blank line", "", "\n", computed, 0),
+        ("literal", "", "", "\"25.10.8\"", 1),
+        ("literal after a blank line", "", "\n", "\"25.10.8\"", 1),
+        ("single-quoted literal", "'", "", "'25.10.8'", 1),
+        ("bare literal, uses quoted", "\"", "", "25.10.8", 1),
+    ];
+    for (label, quote, gap, version, want) in cases {
+        let text = format!(
+            "      - uses: {quote}nf-core/setup-nextflow@{a}{quote} # v3.0.1\n{gap}        if: steps.scope.outputs.run == 'true'\n        with:\n          version: {version}\n\n      - uses: actions/setup-java@{b} # v6\n        with:\n          java-version: \"17\"\n",
+            a = "a".repeat(40),
+            b = "b".repeat(40),
+        );
+        let n = setup.find_iter(&text).count();
+        let _ = writeln!(
+            out,
+            "self-test pin-text {label:<27} counted {n}, want {want}"
+        );
+        ok = ok && n == want;
+    }
+    let clean = check(deps, env_text, pins);
+    let verdict = clean
+        .first()
+        .map_or_else(|| "passes".to_owned(), |c| format!("fails: {c}"));
+    let _ = writeln!(out, "self-test clean    {verdict}");
+    ok
+}
+
+/// The Markdown table of every dependency, once per datasource and name.
+fn summary(deps: &[Dep]) -> String {
+    let id = |d: &IndexMap<String, Value>| tuple(&[get(d, "datasource"), get(d, "depName")]);
+    let mut files: HashMap<String, BTreeSet<&str>> = HashMap::new();
+    for (f, d) in deps {
+        files.entry(id(d)).or_default().insert(f);
+    }
+    let mut rows = vec![
+        "| Dependency | Current | Proposed update | Skipped | Files |".to_owned(),
+        "|---|---|---|---|---|".to_owned(),
+    ];
+    let mut seen = BTreeSet::new();
+    for (_, d) in deps {
+        let k = id(d);
+        if !seen.insert(k.clone()) {
+            continue;
+        }
+        let cur = [get(d, "currentValue"), get(d, "currentDigest")]
+            .into_iter()
+            .find(|v| truthy(v))
+            .map_or_else(String::new, s);
+        let ups: Vec<String> = updates(d)
+            .iter()
+            .map(|u| {
+                let u = match u {
+                    Value::Object(u) => u,
+                    _ => return s(u),
+                };
+                let new = if truthy(get(u, "newValue")) {
+                    get(u, "newValue")
+                } else {
+                    get(u, "newDigest")
+                };
+                format!("{} ({})", s(new), s(get(u, "updateType")))
+            })
+            .collect();
+        let ups = if ups.is_empty() {
+            "none".to_owned()
+        } else {
+            ups.join(", ")
+        };
+        let skip = get(d, "skipReason");
+        let note = if truthy(skip) { s(skip) } else { String::new() };
+        rows.push(format!(
+            "| `{}` | `{cur}` | {ups} | {note} | {} |",
+            s(get(d, "depName")),
+            files[&k].len()
+        ));
+    }
+    rows.join("\n")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn fnmatch_and_env_images() {
+        assert!(
+            fnmatch(b"*.yml", b"e2e.yml")
+                && !fnmatch(b"*.yml", b"e2e.yaml")
+                && fnmatch(b"a?c", b"abc")
+        );
+        let env = "A_IMAGE=\"x/y:1.2@sha256:ab\"\nB_IMAGE=\"z@sha256:cd\"\nC_IMAGE=\"host:5000/w:3\"\nD=\"1\"\n";
+        assert_eq!(env_images(env), ["x/y", "z", "host:5000/w"]);
+    }
+
+    #[test]
+    fn keys_and_proposals_print_as_python() {
+        let d: IndexMap<String, Value> = match json::loads(
+            r#"{"depName":"it's","currentValue":"1","updates":[{"newValue":"3"},{"newValue":"2","newDigest":"d"}]}"#,
+        ) {
+            Ok(Value::Object(o)) => o,
+            other => panic!("{other:?}"),
+        };
+        assert_eq!(key(&d), r#"("it's", '1', None)"#);
+        assert_eq!(proposals(&d), "[('2', 'd'), ('3', '')]");
+    }
+
+    /// A repository of the files the check reads, and a log that matches it.
+    fn planted(name: &str) -> std::path::PathBuf {
+        let d = std::env::temp_dir().join(format!("og-renovate-{name}-{}", std::process::id()));
+        let _ = fs::remove_dir_all(&d);
+        for sub in ["docs", "conf", "scripts/ci", ".github/workflows"] {
+            fs::create_dir_all(d.join(sub)).expect("mkdir");
+        }
+        let w = |p: &str, t: &str| fs::write(d.join(p), t).expect("write");
+        w(
+            ENV,
+            "NEXTFLOW_VERSION=\"25.10.8\"\nA_IMAGE=\"x/a:1@sha256:aa\"\nB_IMAGE=\"x/b:2\"\n",
+        );
+        w(DOCS, "| a | x/a:1 |\n");
+        w(CONFIG, "container = 'x/a:1'\n");
+        w(
+            ".github/workflows/ci.yml",
+            "      - uses: nf-core/setup-nextflow@abc # v3\n        with:\n          version: \"25.10.8\"\n",
+        );
+        w(
+            ".github/workflows/.hidden.yml",
+            "      - uses: nf-core/setup-nextflow@abc # v3\n        with:\n          version: \"25.10.8\"\n",
+        );
+        w(
+            PINS,
+            "# comment\nnextflow-io/nextflow\tversions.env\t^NEXTFLOW_VERSION=\"\nnextflow-io/nextflow\t.github/workflows/*.yml\tuses: [\"\\x27]?nf-core/setup-nextflow@[^\\n]*\\n(?:[ \\t]*(?:[^\\s-][^\\n]*)?\\n)*?[ \\t]+version: [\"\\x27]?\\d\n",
+        );
+        let dep = |n: &str, v: &str, ds: &str| {
+            format!(r#"{{"depName":"{n}","currentValue":"{v}","datasource":"{ds}"}}"#)
+        };
+        let log = format!(
+            "not json\n{{\"msg\":\"other\"}}\n{{\"msg\":\"packageFiles with updates\",\"config\":{{\"regex\":[{{\"packageFile\":\"versions.env\",\"deps\":[{},{},{}]}},{{\"packageFile\":\"docs/versions.md\",\"deps\":[{},{}]}},{{\"packageFile\":\"conf/containers.config\",\"deps\":[{}]}},{{\"packageFile\":\".github/workflows/ci.yml\",\"deps\":[{}]}}]}}}}\n",
+            dep("x/a", "1", "docker"),
+            dep("x/b", "2", "docker"),
+            dep("nextflow-io/nextflow", "25.10.8", "github-releases"),
+            dep("x/a", "1", "docker"),
+            dep("x/b", "2", "docker"),
+            dep("x/a", "1", "docker"),
+            dep("nextflow-io/nextflow", "25.10.8", "github-releases"),
+        );
+        w("renovate.log", &log);
+        d
+    }
+
+    fn run(d: &Path) -> (u8, String) {
+        let args: Vec<String> = [
+            d.join("renovate.log").to_string_lossy().into_owned(),
+            "--repo".to_owned(),
+            d.to_string_lossy().into_owned(),
+        ]
+        .into();
+        let (mut out, mut err) = (Vec::new(), Vec::new());
+        let code = cli(&args, &mut out, &mut err);
+        (
+            code,
+            String::from_utf8_lossy(&out).into_owned() + &String::from_utf8_lossy(&err),
+        )
+    }
+
+    #[test]
+    fn a_clean_tree_passes_and_every_plant_is_caught() {
+        let d = planted("clean");
+        let (code, out) = run(&d);
+        assert_eq!(code, 0, "{out}");
+        assert!(
+            out.contains("OK: 7 dependencies; every check passed"),
+            "{out}"
+        );
+        assert!(out.contains("| `x/a` | `1` | none |  | 3 |"), "{out}");
+        assert_eq!(out.matches("caught: ").count(), 6, "{out}");
+        let _ = fs::remove_dir_all(&d);
+    }
+
+    #[test]
+    fn a_pin_renovate_misses_fails() {
+        let d = planted("pin");
+        fs::write(
+            d.join(".github/workflows/more.yml"),
+            "      - uses: 'nf-core/setup-nextflow@abc'\n\n        with:\n          version: '26.04.0'\n",
+        )
+        .expect("write");
+        let (code, out) = run(&d);
+        assert_eq!(code, 1, "{out}");
+        assert!(
+            out.contains("FAIL pins: nextflow-io/nextflow in .github/workflows/more.yml: the text pins it 1 times, Renovate found 0"),
+            "{out}"
+        );
+        let _ = fs::remove_dir_all(&d);
+    }
+
+    #[test]
+    fn an_image_renovate_misses_and_a_stale_twin_fail() {
+        let d = planted("image");
+        let log = fs::read_to_string(d.join("renovate.log")).expect("read");
+        let log = log.replacen(
+            r#"{"depName":"x/b","currentValue":"2","datasource":"docker"},"#,
+            "",
+            1,
+        );
+        let log = log.replacen(
+            r#""docs/versions.md","deps":[{"depName":"x/a","currentValue":"1""#,
+            r#""docs/versions.md","deps":[{"depName":"x/a","currentValue":"0""#,
+            1,
+        );
+        fs::write(d.join("renovate.log"), log).expect("write");
+        let (code, out) = run(&d);
+        assert_eq!(code, 1, "{out}");
+        assert!(
+            out.contains("FAIL count: x/b (versions.env) is not a detected dependency"),
+            "{out}"
+        );
+        assert!(
+            out.contains(
+                "FAIL twins: docs/versions.md and versions.env differ on ('x/a', '0', None)"
+            ),
+            "{out}"
+        );
+        let _ = fs::remove_dir_all(&d);
+    }
+
+    #[test]
+    fn a_glob_that_matches_nothing_is_refused() {
+        let d = planted("glob");
+        fs::write(d.join(PINS), "aldy\tdocs/*.txt\taldy==\\d\n").expect("write");
+        let (code, out) = run(&d);
+        assert_eq!(code, 2, "{out}");
+        assert!(out.contains("docs/*.txt matches no file"), "{out}");
+        let _ = fs::remove_dir_all(&d);
+    }
+
+    #[test]
+    fn a_log_without_the_record_fails() {
+        let d = planted("nolog");
+        fs::write(d.join("renovate.log"), "{\"msg\":\"other\"}\n").expect("write");
+        let (code, out) = run(&d);
+        assert_eq!(code, 1, "{out}");
+        assert!(
+            out.contains("FAIL: no 'packageFiles with updates' record in"),
+            "{out}"
+        );
+        let _ = fs::remove_dir_all(&d);
+    }
+}
diff --git a/scripts/ci/renovate-pins.tsv b/scripts/ci/renovate-pins.tsv
new file mode 100644
index 000000000..ba15cba87
--- /dev/null
+++ b/scripts/ci/renovate-pins.tsv
@@ -0,0 +1,25 @@
+# The non-image pins `og dev renovate-check` counts (.github/workflows/renovate-dry-run.yml):
+# each must be a dependency Renovate detects in every place it is pinned, as often as the text has it.
+# dependency<TAB>file or glob (wildcards in the last part only)<TAB>regular expression for one pin,
+# with ^ and $ at line ends. A missing file or a glob that matches nothing is an error.
+# Only the files listed for a dependency are counted: python is also the docker image of
+# versions.env, which the image checks cover.
+# A setup-nextflow step is a pin when a version: line with a literal version follows its uses:
+# line inside the same step (the lines in between are blank or start with anything but '-',
+# which opens the next step); a computed version (an expression) is not a pin.
+nextflow-io/nextflow	versions.env	^NEXTFLOW_VERSION="
+nextflow-io/nextflow	.github/workflows/*.yml	uses: ["\x27]?nf-core/setup-nextflow@[^\n]*\n(?:[ \t]*(?:[^\s-][^\n]*)?\n)*?[ \t]+version: ["\x27]?\d
+nextflow-io/nextflow	docs/*.md	NXF_VER=\d
+rhysd/actionlint	.github/workflows/*.yml	ACTIONLINT_VERSION=\d
+gitleaks/gitleaks	.github/workflows/*.yml	GITLEAKS_VERSION=\d
+koalaman/shellcheck	.github/workflows/lint.yml	^[ \t]+version: v\d
+renovate	.github/workflows/renovate-dry-run.yml	RENOVATE_VERSION: \d
+renovate	docs/updating.md	renovate@\d
+python	.github/workflows/docs.yml	python-version: ['\"]?\d
+ANHIG/IMGTHLA	scripts/lib/common.sh	^HLA_DB_RELEASE=\$\{HLA_DB_RELEASE:-\d
+PGScatalog/pgsc_calc	versions.env	^PGSC_CALC_VERSION="
+PGScatalog/pgsc_calc	conf/containers.config	ext\.pipeline_version = '
+playwright	tests/demo/retake-screenshots.sh	playwright==\d
+pillow	tests/demo/retake-screenshots.sh	pillow==\d
+pyobjc-framework-Vision	tests/demo/retake-screenshots.sh	pyobjc-framework-Vision==\d
+aldy	docs/21-cyrius.md	aldy==\d|\[Aldy\]\([^)]*\) v\d

From c6750ad148e209167fd066eba81c8aa115431308 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 11:19:14 +0100
Subject: [PATCH 05/76] refactor(ci): switch the evidence workflow and fixtures
 to og, delete their Python

public-evidence.yml runs og dev evidence clashes and hg002-gvcf; the
comphet e2e case builds its fixture with og dev fixture comphet. The
comphet generator and the PharmCAT trimmer are deleted.

Bead: pgp-bs9u.39
---
 .github/workflows/e2e.yml              |   1 -
 .github/workflows/public-evidence.yml  | 106 +++--------------
 scripts/ci/e2e-case-paths.tsv          |   2 +-
 scripts/ci/e2e-scope.sh                |   2 +-
 tests/e2e/comphet-phasing-1-reads.sh   |   4 +-
 tests/fixtures/comphet/README.md       |   3 +-
 tests/fixtures/comphet/make_fixture.py | 150 -------------------------
 tests/fixtures/pharmcat/README.md      |   4 +-
 tests/fixtures/pharmcat/trim_report.py |  57 ----------
 9 files changed, 22 insertions(+), 307 deletions(-)
 delete mode 100755 tests/fixtures/comphet/make_fixture.py
 delete mode 100755 tests/fixtures/pharmcat/trim_report.py

diff --git a/.github/workflows/e2e.yml b/.github/workflows/e2e.yml
index e7c02c998..39d4b272d 100644
--- a/.github/workflows/e2e.yml
+++ b/.github/workflows/e2e.yml
@@ -67,7 +67,6 @@ on:
       - '.github/workflows/e2e.yml'
       - '.github/actions/**'
       - 'tests/fixtures/annotsv/class45.sh'
-      - 'tests/fixtures/comphet/make_fixture.py'
       - 'tests/fixtures/consumer_export/sites.tsv.gz'
       - 'tests/fixtures/families/stub_families.tsv'
       - 'tests/fixtures/pharmcat/refblocks.g.vcf'
diff --git a/.github/workflows/public-evidence.yml b/.github/workflows/public-evidence.yml
index 11b39d5a4..aa6e7dcc7 100644
--- a/.github/workflows/public-evidence.yml
+++ b/.github/workflows/public-evidence.yml
@@ -166,6 +166,11 @@ jobs:
           name: archaic-1kg-sites
           path: sites
 
+      - name: Build og as scripts/setup.sh --og does (og dev evidence)
+        run: |
+          scripts/setup.sh --og
+          rust/og.sh check --required
+
       - name: setup.sh --archaic and step 43 on HG002 (chromosome ${{ matrix.part }})
         id: run
         continue-on-error: ${{ matrix.part == 'empty' }}
@@ -230,47 +235,7 @@ jobs:
           # same-position rule of archaic_report.py decides).
           docker run --rm -u "$(id -u):$(id -g)" -v "${G}:/g" "$BCFTOOLS_IMAGE" \
             bcftools norm -m- -Oz -o /g/HG002/split.vcf.gz /g/HG002/vcf/HG002.vcf.gz
-          python3 -I - "${G}/HG002/vcf/HG002.vcf.gz" "${G}/HG002/split.vcf.gz" "$DATA" "$OUT/affected.tsv" <<'PY'
-          import glob, gzip, os, sys
-          raw, split, data, out = sys.argv[1:]
-          tables = sorted(glob.glob(os.path.join(data, "chr*.tsv.gz")))
-          chroms = {os.path.basename(t)[:-7] for t in tables}  # this part's chromosomes only
-          def clashes(path):
-              """Positions of this part with two records or more, one an SNV (the VCF is sorted)."""
-              hit, key, n, snvs = set(), None, 0, 0
-              for line in gzip.open(path, "rt"):
-                  if line.startswith("#"):
-                      continue
-                  c = line.split("\t", 6)
-                  if c[0] not in chroms:
-                      continue
-                  k = (c[0], int(c[1]))
-                  if k != key:
-                      key, n, snvs = k, 0, 0
-                  n += 1
-                  snvs += len(c[3]) == 1 and len(c[4]) == 1
-                  if n >= 2 and snvs >= 1:
-                      hit.add(key)
-              return hit
-          sets = {"raw": clashes(raw), "split": clashes(split)}
-          on_table = {k: 0 for k in sets}
-          for t in tables:
-              chrom = os.path.basename(t)[:-7]
-              want = {k: {p for c, p in v if c == chrom} for k, v in sets.items()}
-              if not any(want.values()):
-                  continue
-              for line in gzip.open(t, "rt"):
-                  c = line.split("\t", 2)
-                  if c[0] != chrom:
-                      continue
-                  p = int(c[1])
-                  for k in want:
-                      if p in want[k]:
-                          on_table[k] += 1
-          with open(out, "w") as f:
-              for k in sets:
-                  f.write(f"{k}_positions\t{len(sets[k])}\n{k}_on_table\t{on_table[k]}\n")
-          PY
+          bin/og dev evidence clashes "${G}/HG002/vcf/HG002.vcf.gz" "${G}/HG002/split.vcf.gz" "$DATA" "$OUT/affected.tsv"
           cat "$OUT/affected.tsv"
 
       - name: The red control failed, as it must
@@ -597,6 +562,11 @@ jobs:
           gzip -dc "${R}/${f}.gz" > "${R}/GRCh38_no_alt_analysis_set.fasta"
           rm -f "${R}/${f}.gz"
 
+      - name: Build og as scripts/setup.sh --og does (og dev evidence)
+        run: |
+          scripts/setup.sh --og
+          rust/og.sh check --required
+
       - name: setup.sh --ancient-panel and step 44 on HG002, measured
         env:
           THREADS: '4'
@@ -672,57 +642,9 @@ jobs:
           mkdir -p "${G}/HG002/vcf"
           curl -fsSL --retry 5 -o "${EV}/truth.vcf.gz" "${GIAB_HG002}.vcf.gz"
           curl -fsSL --retry 5 -o "${EV}/truth.bed" "${GIAB_HG002}_noinconsistent.bed"
-          python3 -I - "${EV}/truth.vcf.gz" "${EV}/truth.bed" "${G}/reference/GRCh38_no_alt_analysis_set.fasta" \
-              "${PANEL}/sites_grch38.tsv" "${EV}/hg002.unsorted.vcf" <<'PY'
-          import bisect, gzip, sys
-          truth, bed, ref, sites, out = sys.argv[1:]
-          fai = {l.split("\t")[0]: [int(x) for x in l.split("\t")[1:5]] for l in open(ref + ".fai")}
-          fa = open(ref, "rb")
-          def base(c, p):
-              n, off, lb, lw = fai[c]
-              fa.seek(off + ((p - 1) // lb) * lw + (p - 1) % lb)
-              return fa.read(1).decode().upper()
-          conf = {}
-          for l in open(bed):
-              c, s, e = l.split()[:3]
-              conf.setdefault(c, []).append((int(s), int(e)))
-          starts = {c: [s for s, _ in sorted(v)] for c, v in conf.items()}
-          ends = {c: [e for _, e in sorted(v)] for c, v in conf.items()}
-          def confident(c, p):
-              i = bisect.bisect_right(starts.get(c, []), p - 1) - 1
-              return i >= 0 and ends[c][i] >= p
-          covered, head, body = {}, [], []
-          for l in gzip.open(truth, "rt"):
-              if l.startswith("##"):
-                  head.append(l)
-                  continue
-              if l.startswith("#"):
-                  head.append('##INFO=<ID=END,Number=1,Type=Integer,Description="End of the reference block">\n')
-                  head.append('##ALT=<ID=*,Description="Any other allele">\n')
-                  head.append(l)
-                  continue
-              f = l.split("\t", 5)
-              p = int(f[1])
-              covered.setdefault(f[0], set()).update(range(p, p + len(f[3])))
-              body.append(l)
-          blocks = 0
-          with open(sites) as s:
-              next(s)
-              for l in s:
-                  _, c, p = l.split("\t")[:3]
-                  p = int(p)
-                  if c not in fai or p in covered.get(c, ()) or not confident(c, p):
-                      continue
-                  b = base(c, p)
-                  if b not in "ACGT":
-                      continue
-                  body.append(f"{c}\t{p}\t.\t{b}\t<*>\t.\t.\tEND={p}\tGT\t0/0\n")
-                  blocks += 1
-          with open(out, "w") as o:
-              o.writelines(head)
-              o.writelines(body)
-          print(f"gVCF: {len(body) - blocks} GIAB records, {blocks} reference blocks at panel sites")
-          PY
+          /usr/bin/time -v -o "${M}/gvcf.time" bin/og dev evidence hg002-gvcf "${EV}/truth.vcf.gz" "${EV}/truth.bed" \
+            "${G}/reference/GRCh38_no_alt_analysis_set.fasta" "${PANEL}/sites_grch38.tsv" "${EV}/hg002.unsorted.vcf"
+          grep -E 'Maximum resident|Elapsed' "${M}/gvcf.time"
           docker run --rm -u "$(id -u):$(id -g)" -v "${EV}:/ev" -v "${G}:/g" "$BCFTOOLS_IMAGE" bash -euo pipefail -c '
             bcftools sort -m 2G -T /ev/sort -Oz -o /g/HG002/vcf/HG002.g.vcf.gz /ev/hg002.unsorted.vcf
             bcftools index -t /g/HG002/vcf/HG002.g.vcf.gz'
diff --git a/scripts/ci/e2e-case-paths.tsv b/scripts/ci/e2e-case-paths.tsv
index 02c026afa..93069dae9 100644
--- a/scripts/ci/e2e-case-paths.tsv
+++ b/scripts/ci/e2e-case-paths.tsv
@@ -78,7 +78,7 @@ cn-guard-1-mapq0	bin/cn_loci.tsv bin/copy_number.py bin/og bin/traits_report.py
 cn-intervals-1-catalog	bin/cn_loci.tsv bin/og scripts/ci/build-cn-intervals.py scripts/ci/fake-docker/lib.sh
 cn-intervals-2-hg002	assets/par_grch38.bed assets/paralog_loci.tsv bin/cn_loci.tsv bin/copy_number.py bin/og bin/traits_report.py modules/local/deepvariant/* modules/local/parascopy/* modules/local/vcf_precheck/* scripts/35-paralogs.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 cn-report-1-tables	assets/carrier_genes.tsv assets/par_grch38.bed bin/collect_summary.py bin/couple_report.py bin/family_report.py bin/og bin/paraphase_report.py bin/render_report.py bin/results_index.py bin/traits_report.py scripts/24-html-report.sh scripts/39-couple.sh scripts/ci/fake-docker/lib.sh scripts/generate-report.sh
-comphet-phasing-1-reads	assets/construct_variants.tsv assets/stub/sample.bam assets/stub/sample.bam.bai bin/clip_check.py bin/og modules/local/slivar/* modules/local/vcf_precheck/* modules/local/vep/* scripts/13-vep-annotation.sh scripts/31-slivar.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh tests/fixtures/comphet/make_fixture.py
+comphet-phasing-1-reads	assets/construct_variants.tsv assets/stub/sample.bam assets/stub/sample.bam.bai bin/clip_check.py bin/og modules/local/slivar/* modules/local/vcf_precheck/* modules/local/vep/* scripts/13-vep-annotation.sh scripts/31-slivar.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 construct-scan-1-both	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/mito_confirmed.tsv assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz bin/clip_check.py bin/collect_summary.py bin/og bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/clinvar_screen/* modules/local/html_report/* modules/local/vcf_precheck/* scripts/06-clinvar-screen.sh scripts/24-html-report.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 consumer-export-1	assets/chip_genes.tsv assets/par_grch38.bed bin/chip_report.py bin/og modules/local/chip/* modules/local/export_consumer/* modules/local/vcf_precheck/* scripts/40-export-consumer.sh scripts/49-chip.sh scripts/chip-to-vcf.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh tests/fixtures/consumer_export/sites.tsv.gz
 containers-software-versions	scripts/ci/fake-docker/lib.sh scripts/ci/gen-containers-config.sh
diff --git a/scripts/ci/e2e-scope.sh b/scripts/ci/e2e-scope.sh
index 4e254dc56..81ddd26d0 100755
--- a/scripts/ci/e2e-scope.sh
+++ b/scripts/ci/e2e-scope.sh
@@ -46,7 +46,7 @@ export LC_ALL=C
 SCOPE_DIRS=(scripts modules workflows bin conf assets tests/e2e .github/actions)
 SCOPE_FILES=(tests/fixtures/VERSION main.nf nextflow.config nextflow_schema.json versions.env .github/workflows/e2e.yml
   # The committed fixtures the cases read (their rows name them too).
-  tests/fixtures/annotsv/class45.sh tests/fixtures/comphet/make_fixture.py tests/fixtures/consumer_export/sites.tsv.gz
+  tests/fixtures/annotsv/class45.sh tests/fixtures/consumer_export/sites.tsv.gz
   tests/fixtures/families/stub_families.tsv tests/fixtures/pharmcat/refblocks.g.vcf tests/fixtures/sv/cnvpytor.vcf.in
   tests/fixtures/sv/delly.vcf.in tests/fixtures/sv/manta.vcf.in tests/fixtures/vcf/combined_allele_clinvar.vcf
   tests/fixtures/vcf/combined_allele_sample.vcf tests/fixtures/vcf/grch37_no_contigs.vcf)
diff --git a/tests/e2e/comphet-phasing-1-reads.sh b/tests/e2e/comphet-phasing-1-reads.sh
index 2dc4e2ccf..5107b6ca6 100755
--- a/tests/e2e/comphet-phasing-1-reads.sh
+++ b/tests/e2e/comphet-phasing-1-reads.sh
@@ -2,7 +2,7 @@
 # Step 31 phases each compound-het pair from the reads, and the Nextflow
 # COMPHET_PHASE process writes the same pairs table.
 #
-# The fixture is tests/fixtures/comphet/make_fixture.py: read pairs on a
+# The fixture is og dev fixture comphet (tests/fixtures/comphet): read pairs on a
 # made-up contig (chrP) and a VEP VCF with three pairs, all rare and HIGH:
 #   GENEC  SNV at 1000 and a deletion at 1003 on one copy   -> cis, 22 reads
 #   GENET  SNVs at 5000 and 5400, one on each copy; only a read and its mate
@@ -28,7 +28,7 @@ cell() {
 make_sample() {
   local s=$1 f="${CASE_TMP}/fixture-$1"
   rm -rf "$f" "${GENOME_DIR:?}/${s}"
-  python3 "${REPO}/tests/fixtures/comphet/make_fixture.py" "$f" "${@:2}"
+  "${REPO}/bin/og" dev fixture comphet "$f" "${@:2}"
   mkdir -p "${GENOME_DIR}/${s}/vep" "${GENOME_DIR}/${s}/aligned"
   sed "s/CHPH/${s}/g" "${f}/vep.vcf" > "${GENOME_DIR}/${s}/vep/${s}_vep.vcf"
   sed "s/CHPH/${s}/g" "${f}/reads.sam" > "${GENOME_DIR}/${s}/aligned/${s}.sam"
diff --git a/tests/fixtures/comphet/README.md b/tests/fixtures/comphet/README.md
index b0a5816c6..fc17a306e 100644
--- a/tests/fixtures/comphet/README.md
+++ b/tests/fixtures/comphet/README.md
@@ -1,6 +1,7 @@
 # Made-up reads for the compound-het phase (step 31)
 
-`make_fixture.py OUT_DIR [--swap]` writes the fixture: read pairs of 100 bp
+`bin/og dev fixture comphet OUT_DIR [--swap]` writes the fixture
+(`rust/crates/og-dev/src/fixture.rs`): read pairs of 100 bp
 from 500 bp fragments on a made-up 80 kb contig (`chrP`, seeded random
 sequence), a VEP VCF of six heterozygous variants for step 31, and the three
 pairs as slivar names them. The reads and variants are made up; they describe
diff --git a/tests/fixtures/comphet/make_fixture.py b/tests/fixtures/comphet/make_fixture.py
deleted file mode 100755
index 38d842fc6..000000000
--- a/tests/fixtures/comphet/make_fixture.py
+++ /dev/null
@@ -1,150 +0,0 @@
-#!/usr/bin/env python3
-"""Write the compound-het phasing fixture: made-up reads on a made-up contig.
-
-  make_fixture.py OUT_DIR [--swap]
-
-writes, for the sample CHPH on contig chrP (80 kb of seeded random sequence):
-
-  reads.sam    read pairs of 100 bp, 500 bp fragments (mates 400 bp apart)
-  vep.vcf      the six heterozygous variants with a VEP CSQ, as step 13 writes
-               them, for step 31 (all rare, HIGH impact, three genes)
-  comphet.vcf  the three pairs as slivar compound-hets names them
-               (INFO/slivar_comphet), for og comphet phase alone
-
-The three pairs and what the reads show:
-
-  GENEC  SNV at 1000, 2-base deletion at 1003: both on copy 1 (cis); single
-         reads cover both
-  GENET  SNVs at 5000 and 5400, one on each copy (trans); no single read
-         covers both, only a read and its mate do
-  GENEF  SNVs at 20000 and 70000, one on each copy; 50 kb apart, so no read
-         pair covers both and the phase cannot be read (unknown)
-
---swap moves GENEC's deletion to copy 2: the same positions, now in trans.
-The output is the same for the same arguments; nothing is random at run time.
-"""
-import os
-import random
-import sys
-
-SAMPLE = "CHPH"
-CONTIG = "chrP"
-LENGTH = 80000
-READ = 100
-FRAG = 500
-FIELDS = ("Allele|Consequence|IMPACT|SYMBOL|Gene|Feature_type|Feature|BIOTYPE|CANONICAL|MANE_SELECT|"
-          "Existing_variation|MAX_AF|gnomADe_AF|gnomADg_AF|CLIN_SIG")
-
-
-def reference():
-    rng = random.Random(31)
-    return "".join(rng.choice("ACGT") for _ in range(LENGTH))
-
-
-def other(base):
-    return "ACGT"["ACGT".index(base) - 1]
-
-
-def variants(seq, swap=False):
-    """[(gene, pos, ref, alt, consequence, copy)]: pos 1-based, copy 0 or 1."""
-    snv = lambda pos: (seq[pos - 1], other(seq[pos - 1]))  # noqa: E731
-    return [
-        ("GENEC", 1000, *snv(1000), "stop_gained", 0),
-        ("GENEC", 1003, seq[1002:1005], seq[1002], "frameshift_variant", 1 if swap else 0),
-        ("GENET", 5000, *snv(5000), "stop_gained", 0),
-        ("GENET", 5400, *snv(5400), "stop_gained", 1),
-        ("GENEF", 20000, *snv(20000), "stop_gained", 0),
-        ("GENEF", 70000, *snv(70000), "stop_gained", 1),
-    ]
-
-
-def read_on(seq, vs, copy, start):
-    """(sequence, cigar) of a READ-base read from 0-based start on one copy."""
-    snvs = {v[1] - 1: v[3] for v in vs if v[5] == copy and len(v[2]) == len(v[3])}
-    dels = {v[1] + len(v[3]) - 1: len(v[2]) - len(v[3]) for v in vs if v[5] == copy and len(v[2]) > len(v[3])}
-    out, ops, p = [], [], start
-    while len(out) < READ:
-        if p in dels:
-            ops.append(("D", dels[p]))
-            p += dels[p]
-            continue
-        out.append(snvs.get(p, seq[p]))
-        ops.append(("M", 1))
-        p += 1
-    cigar, last, n = "", None, 0
-    for op, k in ops + [(None, 0)]:
-        if op == last:
-            n += k
-            continue
-        if last:
-            cigar += f"{n}{last}"
-        last, n = op, k
-    return "".join(out), cigar
-
-
-def sam(seq, vs):
-    lines = ["@HD\tVN:1.6\tSO:unsorted", f"@SQ\tSN:{CONTIG}\tLN:{LENGTH}", f"@RG\tID:{SAMPLE}\tSM:{SAMPLE}"]
-    # Fragment starts (0-based) around each pair: read 1 covers the first
-    # position, its mate the second one when they are 400 bp apart.
-    starts = {"c": range(920, 991, 7), "t": range(4905, 4996, 10), "f": range(19905, 19996, 10),
-              "g": range(69905, 69996, 10)}
-    for region, rs in starts.items():
-        for copy in (0, 1):
-            for s in rs:
-                name = f"{region}{copy}_{s}"
-                m = s + FRAG - READ
-                s1, c1 = read_on(seq, vs, copy, s)
-                s2, c2 = read_on(seq, vs, copy, m)
-                q = "I" * READ
-                lines.append(f"{name}\t99\t{CONTIG}\t{s + 1}\t60\t{c1}\t=\t{m + 1}\t{FRAG}\t{s1}\t{q}\tRG:Z:{SAMPLE}")
-                lines.append(f"{name}\t147\t{CONTIG}\t{m + 1}\t60\t{c2}\t=\t{s + 1}\t-{FRAG}\t{s2}\t{q}\tRG:Z:{SAMPLE}")
-    return "\n".join(lines) + "\n"
-
-
-def vcf_head(info):
-    return ("##fileformat=VCFv4.2\n"
-            f"##contig=<ID={CONTIG},length={LENGTH}>\n"
-            '##FILTER=<ID=PASS,Description="All filters passed">\n'
-            + info
-            + '##FORMAT=<ID=GT,Number=1,Type=String,Description="Genotype">\n'
-            '##FORMAT=<ID=GQ,Number=1,Type=Integer,Description="Genotype quality">\n'
-            '##FORMAT=<ID=DP,Number=1,Type=Integer,Description="Read depth">\n'
-            '##FORMAT=<ID=AD,Number=R,Type=Integer,Description="Allele depths">\n'
-            f"#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\t{SAMPLE}\n")
-
-
-def vep_vcf(vs):
-    out = vcf_head('##INFO=<ID=CSQ,Number=.,Type=String,Description="Consequence annotations from Ensembl VEP. '
-                   f'Format: {FIELDS}">\n')
-    for gene, pos, ref, alt, cons, _ in vs:
-        csq = (f"{alt}|{cons}|HIGH|{gene}|ENSG{gene}|Transcript|ENST{pos}|protein_coding|YES|NM_{pos}.1|"
-               f"rs{pos}|0.0001|0.0001|0.0001|")
-        out += f"{CONTIG}\t{pos}\t.\t{ref}\t{alt}\t50\tPASS\tCSQ={csq}\tGT:GQ:DP:AD\t0/1:50:30:15,15\n"
-    return out
-
-
-def comphet_vcf(vs):
-    out = vcf_head('##INFO=<ID=slivar_comphet,Number=.,Type=String,Description="compound hets called by slivar">\n')
-    pid = {"GENEC": 1, "GENET": 2, "GENEF": 3}
-    for i, (gene, pos, ref, alt, _, _) in enumerate(vs):
-        mate = vs[i + 1] if i % 2 == 0 else vs[i - 1]
-        tag = f"{SAMPLE}/{gene}/{pid[gene]}/{CONTIG}/{mate[1]}/{mate[2]}/{mate[3]}"
-        out += f"{CONTIG}\t{pos}\t.\t{ref}\t{alt}\t50\tPASS\tslivar_comphet={tag}\tGT:GQ:DP:AD\t0/1:50:30:15,15\n"
-    return out
-
-
-def write(out_dir, swap=False):
-    seq = reference()
-    vs = variants(seq, swap)
-    os.makedirs(out_dir, exist_ok=True)
-    for name, text in (("reads.sam", sam(seq, vs)), ("vep.vcf", vep_vcf(vs)), ("comphet.vcf", comphet_vcf(vs))):
-        with open(os.path.join(out_dir, name), "w") as fh:
-            fh.write(text)
-    return vs
-
-
-if __name__ == "__main__":
-    args = [a for a in sys.argv[1:] if a != "--swap"]
-    if len(args) != 1:
-        sys.exit(__doc__.split("\n\n")[1])
-    write(args[0], swap="--swap" in sys.argv[1:])
diff --git a/tests/fixtures/pharmcat/README.md b/tests/fixtures/pharmcat/README.md
index a4451df8d..9e15c7b00 100644
--- a/tests/fixtures/pharmcat/README.md
+++ b/tests/fixtures/pharmcat/README.md
@@ -1,7 +1,7 @@
 # PharmCAT report fixtures
 
 Real PharmCAT output for `tests/test_cpic_parser.py` (one `report-<version>.json` per release in its `REAL_REPORTS`), trimmed with
-`trim_report.py` to the fields `og pgx` reads (every gene with all
+`og dev fixture trim-pharmcat` (formerly `trim_report.py`, which wrote the files below) to the fields `og pgx` reads (every gene with all
 its listed diplotypes and `relatedDrugs`; up to 4 matched annotations per drug
 guideline).
 
@@ -16,7 +16,7 @@ with `VERSION` replaced by the PharmCAT release (for example `3.4.0`), and add
 the release to `REAL_REPORTS` in `tests/test_cpic_parser.py`:
 
 ```bash
-python3 tests/fixtures/pharmcat/trim_report.py report.json tests/fixtures/pharmcat/report-VERSION.json
+bin/og dev fixture trim-pharmcat report.json tests/fixtures/pharmcat/report-VERSION.json
 ```
 
 ## Reference blocks over PharmCAT's positions longer than one base
diff --git a/tests/fixtures/pharmcat/trim_report.py b/tests/fixtures/pharmcat/trim_report.py
deleted file mode 100755
index 33adcc5a2..000000000
--- a/tests/fixtures/pharmcat/trim_report.py
+++ /dev/null
@@ -1,57 +0,0 @@
-#!/usr/bin/env python3
-"""trim_report.py: cut a PharmCAT report.json down to a test fixture.
-
-  python3 tests/fixtures/pharmcat/trim_report.py REPORT.json OUT.json [MAX_ANNOTATIONS]
-
-Keeps every gene with all its listed diplotypes (sourceDiplotypes, or
-recommendationDiplotypes when that is all there is) and relatedDrugs, and for
-each drug of each guidance source up to MAX_ANNOTATIONS (default 4) of the
-annotations PharmCAT matched, with only the fields og pgx reads.
-Writes compact JSON. See README.md for how each fixture was made.
-"""
-import json
-import sys
-
-src, dst = sys.argv[1], sys.argv[2]
-MAX_ANN = int(sys.argv[3]) if len(sys.argv) > 3 else 4
-d = json.load(open(src))
-
-
-def dip(x):
-    if not isinstance(x, dict): return x
-    out = {k: x[k] for k in ("gene", "label", "phenotypes", "activityScore", "outsidePhenotype") if k in x}
-    for a in ("allele1", "allele2"):
-        if a in x:
-            out[a] = {k: x[a][k] for k in ("gene", "name", "function") if x[a] and k in x[a]} if x[a] else x[a]
-    return out
-
-
-genes = {}
-for g, v in d["genes"].items():
-    genes[g] = {k: v[k] for k in ("geneSymbol", "chr", "phased", "callSource") if k in v}
-    genes[g]["relatedDrugs"] = [{"name": r["name"], "id": r.get("id")} for r in v.get("relatedDrugs") or []]
-    # sourceDiplotypes is what og pgx reads; recommendationDiplotypes only
-    # when sourceDiplotypes is absent, so it is kept only then.
-    k = "sourceDiplotypes" if v.get("sourceDiplotypes") else "recommendationDiplotypes"
-    if k in v: genes[g][k] = [dip(x) for x in v[k] or []]
-drugs = {}
-for srcname, by in d["drugs"].items():
-    for name, rep in by.items():
-        gls = []
-        for gl in rep.get("guidelines") or []:
-            anns = []
-            for a in (gl.get("annotations") or [])[:MAX_ANN]:
-                anns.append({"phenotypes": a.get("phenotypes"), "classification": a.get("classification"),
-                             "drugRecommendation": a.get("drugRecommendation"),
-                             "genotypes": [{"diplotypes": [{"gene": x.get("gene"), "label": x.get("label")}
-                                                           for x in (gt.get("diplotypes") or []) if isinstance(x, dict)]}
-                                           for gt in (a.get("genotypes") or [])]})
-            if anns: gls.append({"name": gl.get("name"), "source": gl.get("source"), "annotations": anns})
-        if gls:
-            drugs.setdefault(srcname, {})[name] = {"name": rep.get("name"), "id": rep.get("id"), "guidelines": gls}
-out = {k: d[k] for k in ("title", "timestamp", "pharmcatVersion", "dataVersion") if k in d}
-out["genes"] = genes
-out["drugs"] = drugs
-out["_fixture_note"] = (f"Trimmed by tests/fixtures/pharmcat/trim_report.py: every gene, and up to {MAX_ANN} matched "
-                        "annotations per drug guideline, with only the fields og pgx reads.")
-json.dump(out, open(dst, "w"), separators=(",", ":"))

From 7457f1621717f0472580beff12673862a4b23052 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 11:20:24 +0100
Subject: [PATCH 06/76] docs(changelog): og dev fixture, evidence and
 renovate-check

Bead: pgp-bs9u.39
---
 CHANGELOG.md        | 5 +++++
 rust/og/src/main.rs | 1 +
 2 files changed, 6 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index bd24284ac..506e771c0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,11 @@ Each release's notes. From 1.0.0 on, a major or minor release has hand-written n
 
 ## Unreleased
 
+- The Python that CI and the fixtures ran outside the pipeline now runs in the Rust `og` binary. The public evidence workflow runs `og dev evidence clashes` and `og dev evidence hg002-gvcf` instead of two inline Python programs; the Renovate dry run checks what Renovate found with `og dev renovate-check`, whose list of non-image pins is now data in `scripts/ci/renovate-pins.tsv`; `og dev fixture comphet` writes the compound-het fixture of the e2e case `comphet-phasing-1-reads`, byte for byte; and `og dev fixture trim-pharmcat` trims a PharmCAT report for `tests/fixtures/pharmcat`. `tests/fixtures/comphet/make_fixture.py`, `tests/fixtures/pharmcat/trim_report.py` and `tests/smoke/vntyper_testdata.py` are gone: VNtyper's two test BAMs now come from `tests/smoke/vntyper_testdata.sh`, one HTTP range request per BAM with curl, checked by gzip against the archive's CRC-32 and size and then against the pinned sha256. On GIAB's HG002 benchmark VCF (4,048,342 records) with the chr20-22 reference, `og dev evidence hg002-gvcf` writes the same gVCF in 3.5 s and 97 MB instead of 11.8 s and 3.8 GB, because it keeps the spans the records cover instead of every covered position. No pipeline output changes. What changes on purpose:
+  - `og dev evidence hg002-gvcf` skips a panel site past the end of its contig. The Python read the byte after the contig, and at the end of the file wrote a reference block with an empty REF.
+  - `og dev renovate-check` stops with exit 2 when a pin's file is missing or its glob matches no file. The Python counted such a pin in no file, so it could never fail.
+  - `og dev fixture trim-pharmcat` names itself in the trimmed report's `_fixture_note`.
+
 - The database re-check and the monthly freshness issue now run in the Rust `og` binary: `og recheck` replaces `bin/owngenome_recheck.py` and `og dev freshness` replaces `scripts/ci/freshness.py`, which is gone. `bin/owngenome_recheck.py` stays until 1.1.0 as a shim that runs `bin/og recheck` with the same arguments and says on stderr that it is deprecated, so a crontab line keeps working; [docs/recheck.md](docs/recheck.md) has the new lines. Each lookup now returns a typed answer (a date, a release, the release a held pin can move to, or "report only"), and the re-check reads that answer, not the text of the report. The lookups run on up to 8 threads with one request at a time per host, and ask the network through the host's `curl`. The freshness report is the same, byte for byte; it took 20 s and 12 MB instead of 109 s and 27 MB on one live run. On a synthetic sample with 5,000 PGS scores the re-check takes 0.05 s and 16 MB instead of 0.56 s and 33 MB, with the same `state.json` by content. What changes on purpose:
   - The action lines say `bin/og recheck --sample S --rerun` instead of `bin/owngenome_recheck.py --sample S --rerun`.
   - `--rerun` prints its own lines before the replayed command's output. The Python held its lines in a buffer, so they could come after the child's.
diff --git a/rust/og/src/main.rs b/rust/og/src/main.rs
index 7b8f792ab..37a109075 100644
--- a/rust/og/src/main.rs
+++ b/rust/og/src/main.rs
@@ -69,6 +69,7 @@ const USAGE: &str = "usage: og <tool> [args]
        og exomiser report [args]
        og lookup query|resolve|report [args]
        og dev parity-compare|contract|schema|report-only|remnants [args]
+       og dev fixture|evidence|renovate-check [args]
        og dev freshness [--out FILE] [--sections a,b] | --update-issue BODY --repo O/N | --self-test
        og version
        og --tree-hash

From 8a8cb25ad55e62ca0aa3ac3fe0c8fec65a212800 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 11:23:02 +0100
Subject: [PATCH 07/76] test(parity): edge cases for og dev fixture
 trim-pharmcat

Every field the trimmer keeps or drops, a non-object diplotype, a null
allele, the recommendationDiplotypes fallback, non-ASCII text, and counts
of 2, 0 and -1.

Bead: pgp-bs9u.39
---
 tests/parity/cases.tsv                        |  4 +++
 .../dev-fixture-trim-pharmcat/edge.json       | 25 +++++++++++++++++++
 2 files changed, 29 insertions(+)
 create mode 100644 tests/parity/inputs/dev-fixture-trim-pharmcat/edge.json

diff --git a/tests/parity/cases.tsv b/tests/parity/cases.tsv
index 692b0f540..8d2905251 100644
--- a/tests/parity/cases.tsv
+++ b/tests/parity/cases.tsv
@@ -884,3 +884,7 @@ dev-fixture-trim-pharmcat	all-but-last	gen:pgx-fixtures.sh	pharmcat-docs-example
 dev-evidence-clashes	synthetic	dev-evidence-clashes/raw.vcf.gz,dev-evidence-clashes/split.vcf.gz,dev-evidence-clashes/chrA.tsv.gz,dev-evidence-clashes/chrB.tsv.gz,dev-evidence-clashes/chrZ.tsv.gz,dev-evidence-clashes/notes.tsv.gz	raw.vcf.gz split.vcf.gz . affected.tsv	affected.tsv	bytes	PYTHON_IMAGE
 dev-evidence-hg002-gvcf	synthetic	dev-evidence-hg002-gvcf/truth.vcf.gz,dev-evidence-hg002-gvcf/truth.bed,dev-evidence-hg002-gvcf/ref.fasta,dev-evidence-hg002-gvcf/ref.fasta.fai,dev-evidence-hg002-gvcf/sites.tsv	truth.vcf.gz truth.bed ref.fasta sites.tsv out.vcf	out.vcf	bytes	PYTHON_IMAGE
 dev-evidence-hg002-gvcf	past-the-end	dev-evidence-hg002-gvcf/truth.vcf.gz,dev-evidence-hg002-gvcf/truth-past-end.bed,dev-evidence-hg002-gvcf/ref.fasta,dev-evidence-hg002-gvcf/ref.fasta.fai,dev-evidence-hg002-gvcf/sites-past-end.tsv	truth.vcf.gz truth-past-end.bed ref.fasta sites-past-end.tsv out.vcf	out.vcf	bytes	PYTHON_IMAGE
+dev-fixture-trim-pharmcat	edge	dev-fixture-trim-pharmcat/edge.json	edge.json out.json	out.json	json:mask=_fixture_note	PYTHON_IMAGE
+dev-fixture-trim-pharmcat	edge2	dev-fixture-trim-pharmcat/edge.json	edge.json out.json 2	out.json	json:mask=_fixture_note	PYTHON_IMAGE
+dev-fixture-trim-pharmcat	edge0	dev-fixture-trim-pharmcat/edge.json	edge.json out.json 0	out.json	json:mask=_fixture_note	PYTHON_IMAGE
+dev-fixture-trim-pharmcat	edge-all-but-last	dev-fixture-trim-pharmcat/edge.json	edge.json out.json -1	out.json	json:mask=_fixture_note	PYTHON_IMAGE
diff --git a/tests/parity/inputs/dev-fixture-trim-pharmcat/edge.json b/tests/parity/inputs/dev-fixture-trim-pharmcat/edge.json
new file mode 100644
index 000000000..dd46aeb6b
--- /dev/null
+++ b/tests/parity/inputs/dev-fixture-trim-pharmcat/edge.json
@@ -0,0 +1,25 @@
+{"title":"edge é","timestamp":"t","pharmcatVersion":"3.4.0","dataVersion":"d","other":{"x":1},
+ "genes":{
+  "CYP2D6":{"geneSymbol":"CYP2D6","chr":"chr22","phased":false,"callSource":"OUTSIDE","extra":1,
+   "relatedDrugs":[{"name":"codeine","id":"PA449088"},{"name":"tramadol"}],
+   "sourceDiplotypes":[{"gene":"CYP2D6","label":"*1/*4","phenotypes":["Intermediate Metabolizer"],"activityScore":1.0,"outsidePhenotype":true,"lookupKey":["x"],
+     "allele1":{"gene":"CYP2D6","name":"*1","function":"Normal function","activityValue":"1.0"},"allele2":{"name":"*4","function":"No function"}},
+    "not an object"],
+   "recommendationDiplotypes":[{"label":"ignored because sourceDiplotypes is set"}]},
+  "UGT1A1":{"geneSymbol":"UGT1A1","relatedDrugs":null,"sourceDiplotypes":[],
+   "recommendationDiplotypes":[{"label":"*1/*80","allele1":null,"allele2":{}}]},
+  "DPYD":{"geneSymbol":"DPYD","sourceDiplotypes":[]},
+  "NAT2":{"geneSymbol":"NAT2","sourceDiplotypes":null,"recommendationDiplotypes":null}},
+ "drugs":{
+  "CPIC Guideline Annotation":{
+   "codeine":{"name":"codeine","id":"PA449088","source":"x","guidelines":[
+     {"name":"g1","source":"CPIC","url":"u","annotations":[
+       {"phenotypes":{"CYP2D6":"Intermediate Metabolizer"},"classification":"Moderate","drugRecommendation":"Use label-recommended dosing — caution.","implications":["dropped"],
+        "genotypes":[{"diplotypes":[{"gene":"CYP2D6","label":"*1/*4","x":1},"skip me",{"label":"no gene"}]},{}]},
+       {"classification":"Strong"},
+       {"classification":"Optional"}]},
+     {"name":"g2","annotations":[]},
+     {"name":"g3"}]},
+   "tramadol":{"name":"tramadol","guidelines":[]}},
+  "DPWG Guideline Annotation":{
+   "empty":{"name":"empty","guidelines":null}}}}

From 63938de53b7bf542246af55ea8ad3a31200c84fb Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 11:23:02 +0100
Subject: [PATCH 08/76] test: plant one fault in each new og dev verb (red
 control, reverted next)

Comphet seeded with 32, the trimmer drops activityScore, clashes needs
three records, and renovate-check no longer flags an @ in a package name.
Guard rust and parity must go red on this commit.

Bead: pgp-bs9u.39
---
 rust/crates/og-dev/src/evidence.rs |  2 +-
 rust/crates/og-dev/src/fixture.rs  | 13 ++-----------
 rust/crates/og-dev/src/renovate.rs |  2 +-
 3 files changed, 4 insertions(+), 13 deletions(-)

diff --git a/rust/crates/og-dev/src/evidence.rs b/rust/crates/og-dev/src/evidence.rs
index c9b76d7fc..6971f2f1b 100644
--- a/rust/crates/og-dev/src/evidence.rs
+++ b/rust/crates/og-dev/src/evidence.rs
@@ -119,7 +119,7 @@ fn clash_positions(
         n += 1;
         let one = |a: &[u8]| std::str::from_utf8(a).map_or(a.len(), |s| s.chars().count()) == 1;
         snvs += u32::from(one(c[3]) && one(c[4]));
-        if n >= 2 && snvs >= 1 {
+        if n >= 3 && snvs >= 1 {
             hit.insert(k);
         }
         Ok(())
diff --git a/rust/crates/og-dev/src/fixture.rs b/rust/crates/og-dev/src/fixture.rs
index bb163c9f9..0d5d9f3bf 100644
--- a/rust/crates/og-dev/src/fixture.rs
+++ b/rust/crates/og-dev/src/fixture.rs
@@ -200,7 +200,7 @@ pub mod comphet {
 
     /// The contig: `random.Random(31)` choosing among `ACGT` 80,000 times.
     pub fn reference() -> Vec<u8> {
-        let mut rng = Mt19937::new(31);
+        let mut rng = Mt19937::new(32);
         (0..LENGTH)
             .map(|_| b"ACGT"[rng.below(4) as usize])
             .collect()
@@ -423,16 +423,7 @@ fn diplotype(x: &Value) -> Result<Value, String> {
     let Value::Object(x) = x else {
         return Ok(x.clone());
     };
-    let mut out = pick(
-        x,
-        &[
-            "gene",
-            "label",
-            "phenotypes",
-            "activityScore",
-            "outsidePhenotype",
-        ],
-    );
+    let mut out = pick(x, &["gene", "label", "phenotypes", "outsidePhenotype"]);
     for a in ["allele1", "allele2"] {
         let Some(v) = x.get(a) else { continue };
         let kept = match v {
diff --git a/rust/crates/og-dev/src/renovate.rs b/rust/crates/og-dev/src/renovate.rs
index f3355c766..4544ccb01 100644
--- a/rust/crates/og-dev/src/renovate.rs
+++ b/rust/crates/og-dev/src/renovate.rs
@@ -421,7 +421,7 @@ fn check(deps: &[Dep], env_text: &str, pins: &Pins) -> Vec<String> {
         } else {
             ":".to_owned()
         };
-        if text.contains([':', '@']) {
+        if text.contains(':') {
             fails.push(format!("names: {f}: package name {}", r(name)));
         }
     }

From d6750f5033bc909f012bccffa5963e9182231e61 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 11:26:18 +0100
Subject: [PATCH 09/76] fix(ci): run the scanners and version checks through og
 dev

check-personal-data.sh, check-images.sh, gen-containers-config.sh
--check-versions, check-links.sh and check-pgs-labels.sh call the og dev
verbs instead of their Python heredocs, and each workflow job that runs
them has og. New self-test controls: a scan of no text file, a stale image
exemption, a versions.env line that is not NAME="value", and a JSON true
read as an effect of 1.

Bead: pgp-bs9u.37
---
 .github/workflows/freshness.yml         |  42 +++++----
 .github/workflows/guard.yml             |  18 +++-
 .github/workflows/nextflow.yml          |   2 +
 .github/workflows/personal-data.yml     |  25 +++++-
 rust/crates/og-dev/src/personal_data.rs |  10 +--
 scripts/ci/check-images.sh              |  96 ++++----------------
 scripts/ci/check-links.sh               |  52 ++++++-----
 scripts/ci/check-personal-data.sh       | 113 +++++++-----------------
 scripts/ci/check-pgs-labels.sh          |  88 ++++++------------
 scripts/ci/gen-containers-config.sh     |  42 ++-------
 10 files changed, 174 insertions(+), 314 deletions(-)

diff --git a/.github/workflows/freshness.yml b/.github/workflows/freshness.yml
index 491342c72..2df8e31e8 100644
--- a/.github/workflows/freshness.yml
+++ b/.github/workflows/freshness.yml
@@ -129,10 +129,16 @@ jobs:
       - name: og dev freshness self-test (a bogus image, a missing tag and a bogus URL must exit non-zero)
         run: rust/target/release/og dev freshness --self-test
 
-      - name: check-links.sh self-test (a 404, no answer and an empty tree must fail; a github.com 5xx is asked again, and one that lasts fails naming the outage)
+      # check-links.sh and check-pgs-labels.sh read with og dev versions
+      # expand and og dev pgs (rust/crates/og-dev), the og built above.
+      - name: check-links.sh self-test (a 404, no answer, an unreadable versions.env line and an empty tree must fail; a github.com 5xx is asked again, and one that lasts fails naming the outage)
+        env:
+          OG: ${{ github.workspace }}/rust/target/release/og
         run: scripts/ci/check-links.sh --self-test
 
-      - name: check-pgs-labels.sh self-test (a wrong label, an empty answer and no answer must fail)
+      - name: check-pgs-labels.sh self-test (a wrong label, an empty answer, no answer and an effect of true must fail)
+        env:
+          OG: ${{ github.workspace }}/rust/target/release/og
         run: scripts/ci/check-pgs-labels.sh --self-test
 
   pull-request:
@@ -158,20 +164,11 @@ jobs:
             echo "report=$(has 'rust/crates/og-fresh/.*|versions\.env|\.github/workflows/freshness\.yml')"
           } >> "$GITHUB_OUTPUT"
 
-      - name: Every download URL this pull request adds answers
-        env:
-          BASE: ${{ github.event.pull_request.base.sha }}
-        run: scripts/ci/check-links.sh --since "$BASE" | tee -a "$GITHUB_STEP_SUMMARY"
-
-      - name: Every PGS ID's label matches the PGS Catalog
-        if: steps.changed.outputs.prs == 'true'
-        run: scripts/ci/check-pgs-labels.sh | tee -a "$GITHUB_STEP_SUMMARY"
-
-      # og dev freshness (rust/crates/og-fresh) writes the report: the
-      # toolchain rust/rust-toolchain.toml pins, og built without the BAM
-      # reader, which the report never needs.
+      # og dev freshness (rust/crates/og-fresh) writes the report, and the
+      # link and label checks read with og dev versions expand and og dev
+      # pgs: the toolchain rust/rust-toolchain.toml pins, og built without
+      # the BAM reader, which none of them needs.
       - name: Install the toolchain rust/rust-toolchain.toml pins
-        if: steps.changed.outputs.report == 'true'
         working-directory: rust
         run: |
           channel=$(sed -n 's/^channel = "\(.*\)"$/\1/p' rust-toolchain.toml)
@@ -179,16 +176,26 @@ jobs:
           rustc --version
 
       - uses: Swatinem/rust-cache@d1527c8f67ef9af357290475d4af4b0fab8f12e0 # v2.9.3
-        if: steps.changed.outputs.report == 'true'
         with:
           workspaces: rust
           key: freshness
 
       - name: Build og
-        if: steps.changed.outputs.report == 'true'
         working-directory: rust
         run: cargo build --release --locked -p og --no-default-features
 
+      - name: Every download URL this pull request adds answers
+        env:
+          BASE: ${{ github.event.pull_request.base.sha }}
+          OG: ${{ github.workspace }}/rust/target/release/og
+        run: scripts/ci/check-links.sh --since "$BASE" | tee -a "$GITHUB_STEP_SUMMARY"
+
+      - name: Every PGS ID's label matches the PGS Catalog
+        if: steps.changed.outputs.prs == 'true'
+        env:
+          OG: ${{ github.workspace }}/rust/target/release/og
+        run: scripts/ci/check-pgs-labels.sh | tee -a "$GITHUB_STEP_SUMMARY"
+
       - name: Report dry run (no issue is written)
         if: steps.changed.outputs.report == 'true'
         env:
@@ -236,6 +243,7 @@ jobs:
         id: checks
         env:
           GITHUB_TOKEN: ${{ github.token }}
+          OG: ${{ github.workspace }}/rust/target/release/og
           RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
         run: |
           out="${RUNNER_TEMP}"
diff --git a/.github/workflows/guard.yml b/.github/workflows/guard.yml
index 45a57bedd..03ad9d83b 100644
--- a/.github/workflows/guard.yml
+++ b/.github/workflows/guard.yml
@@ -33,12 +33,25 @@ jobs:
   # two files generated from it (conf/containers.config, docs/versions.md)
   # are up to date. Each script's self-test plants its faults first.
   images:
+    needs: og
     runs-on: ubuntu-latest
     timeout-minutes: 10
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
-      - name: Self-test (a literal image in a script, module, workflow or doc, a process with no selector and a stale generated file must be caught)
+      # The scans and the run-versions check are og dev verbs
+      # (rust/crates/og-dev): the og the og job built.
+      - uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
+        with:
+          name: og-unit-tests
+          path: ${{ runner.temp }}/og
+
+      - name: og for the checks (OG)
+        run: |
+          chmod 755 "$RUNNER_TEMP/og/og"
+          echo "OG=${RUNNER_TEMP}/og/og" >> "$GITHUB_ENV"
+
+      - name: Self-test (a literal image in a script, module, workflow or doc, a stale exemption, a process with no selector and a stale generated file must be caught)
         run: scripts/ci/check-images.sh --self-test
 
       - name: Self-test of the containers.config generator (a stale tag, a missing or stray selector, a module's own container and a wrong version must be caught)
@@ -125,7 +138,8 @@ jobs:
 
   # og for the unit tests (tests/og_binary.py): the tests of a ported tool
   # and the demo sample builder run og as a subprocess. Built once here, so
-  # the three shards do not each spend minutes of their 10 on it.
+  # the three shards do not each spend minutes of their 10 on it. The images
+  # job runs its og dev scans with it too.
   og:
     runs-on: ubuntu-latest
     timeout-minutes: 20
diff --git a/.github/workflows/nextflow.yml b/.github/workflows/nextflow.yml
index 8f5426c6c..64b90c84f 100644
--- a/.github/workflows/nextflow.yml
+++ b/.github/workflows/nextflow.yml
@@ -363,6 +363,8 @@ jobs:
       # the image versions.env gives it.
       - name: Every process ran and states the tag of its image from versions.env
         if: steps.scope.outputs.run == 'true'
+        env:
+          OG: ${{ github.workspace }}/rust/target/release/og   # og dev versions check-run, built above
         run: |
           cat "${RUNNER_TEMP}/all-tools/pipeline_info/software_versions.yml"
           scripts/ci/gen-containers-config.sh --check-versions "${RUNNER_TEMP}/all-tools/pipeline_info/software_versions.yml"
diff --git a/.github/workflows/personal-data.yml b/.github/workflows/personal-data.yml
index 1cc1f5315..81ace8050 100644
--- a/.github/workflows/personal-data.yml
+++ b/.github/workflows/personal-data.yml
@@ -19,11 +19,32 @@ concurrency:
 jobs:
   personal-data:
     runs-on: ubuntu-latest
-    timeout-minutes: 5
+    timeout-minutes: 20
+    env:
+      OG: ${{ github.workspace }}/rust/target/release/og
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
-      - name: Self-test (a planted home path, address, diplotype, rsID genotype and repeat count must be caught)
+      # The scan is og dev scan personal-data (rust/crates/og-dev): the
+      # toolchain rust/rust-toolchain.toml pins, og built without the BAM
+      # reader, which the scan never needs.
+      - name: Install the toolchain rust/rust-toolchain.toml pins
+        working-directory: rust
+        run: |
+          channel=$(sed -n 's/^channel = "\(.*\)"$/\1/p' rust-toolchain.toml)
+          rustup toolchain install "$channel" --profile minimal
+          rustc --version
+
+      - uses: Swatinem/rust-cache@d1527c8f67ef9af357290475d4af4b0fab8f12e0 # v2.9.3
+        with:
+          workspaces: rust
+          key: personal-data
+
+      - name: Build og
+        working-directory: rust
+        run: cargo build --release --locked -p og --no-default-features
+
+      - name: Self-test (a planted home path, address, diplotype, rsID genotype and repeat count, and a scan of no text file, must be caught)
         run: scripts/ci/check-personal-data.sh --self-test
 
       - name: No tracked file holds a home path, a private address or a genotype
diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
index a10289f56..520ffb921 100644
--- a/rust/crates/og-dev/src/personal_data.rs
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -488,7 +488,7 @@ mod tests {
             ("rs123: (C;~T)", "rsid"),
             ("rs4477212\t1\t82154\t~AA", "rsid"),
             ("HTT CAG repeats: 17/~19", "repeat"),
-            ("GT:REPCN 0/1:17/~19", "repeat"),
+            ("GT:REPCN 0~/1:17/~19", "repeat"),
         ] {
             let line = p(line);
             assert!(kinds(&line).contains(&kind), "{line}: {:?}", kinds(&line));
@@ -520,18 +520,18 @@ mod tests {
         // the number: the line still counts as labelled.
         assert_eq!(kinds(&p("sample7a *1/~*4")), ["diplotype"]);
         assert_eq!(kinds(&p("samples: *1/~*4")), ["diplotype"]);
-        assert_eq!(kinds(&p("10.1.2.3.")), ["address"]);
+        assert_eq!(kinds(&p("10.1.2.~3.")), ["address"]);
         assert_eq!(kinds(&p("FMR1 has 29/~31")), ["repeat"]);
     }
 
     #[test]
     fn an_allowed_example_covers_only_its_own_text() {
         let rules = builtin();
-        let ex = "(`/mnt/user/`, `/home/username/`, etc.)";
+        let ex = p("(`/mnt/u~ser/`, `/ho~me/username/`, etc.)");
         let mut out = Vec::new();
-        assert!(!scan_text(&mut out, &rules, &[ex], "x.md", ex.as_bytes()));
+        assert!(!scan_text(&mut out, &rules, &[ex.as_str()], "x.md", ex.as_bytes()));
         let line = p(&format!("{ex} see /home/~bob/x"));
-        assert!(scan_text(&mut out, &rules, &[ex], "x.md", line.as_bytes()));
+        assert!(scan_text(&mut out, &rules, &[ex.as_str()], "x.md", line.as_bytes()));
         let got = String::from_utf8(out).unwrap();
         assert!(got.starts_with("FAIL home      x.md:1: "), "{got}");
     }
diff --git a/scripts/ci/check-images.sh b/scripts/ci/check-images.sh
index 792504f0b..9620755d1 100755
--- a/scripts/ci/check-images.sh
+++ b/scripts/ci/check-images.sh
@@ -28,6 +28,9 @@ set -euo pipefail
 export LC_ALL=C
 
 ROOT=$(cd "$(dirname "$0")/../.." && pwd)
+# og runs the scan and rule 4 (rust/crates/og-dev; bin/og picks the build
+# for this machine); OG names another og binary.
+OG=${OG:-${ROOT}/bin/og}
 MODE=check
 while [ $# -gt 0 ]; do
   case "$1" in
@@ -55,7 +58,8 @@ tests/fixtures/                       provenance notes name the image that wrote
 
 # Single literals that stay on purpose: file, image, reason. Each line allows
 # one occurrence: a change to the image or one more copy of it in the same
-# file is reported again.
+# file is reported again, and a line whose file no longer names the image
+# fails until it is dropped.
 EXEMPT_PAIRS='
 docs/08-hla-typing.md             jiachenzdocker/hla-la@sha256:ecca23de6635aa85e60b4ee39dd4e15341b5febb514e5478f2b2a086f05a447c   HLA-LA is not a pipeline step
 docs/stylesheets/theme.css        quay.io/biocontainers/expansionhunter:5.0.0   example in a CSS comment
@@ -74,90 +78,12 @@ scan() {
     list=$(cd "$ROOT" && find $SCAN -type f 2>/dev/null || true)
   fi
   [ -n "$list" ] || { echo "FAIL: found no file to scan under ${ROOT}"; return 1; }
-  # The file list goes in as an argument: stdin carries the program.
-  python3 - "$ROOT" "$EXEMPT_FILES" "$EXEMPT_PAIRS" "$list" <<'PY'
-import collections, os, re, sys
-root, exempt_files, exempt_pairs = sys.argv[1], sys.argv[2], sys.argv[3]
-files = [f for f in sys.argv[4].split("\n") if f]
-if not files:
-    print("FAIL: no file to scan")
-    sys.exit(1)
-skip = [l.split()[0] for l in exempt_files.splitlines() if l.strip()]
-# Each line allows one occurrence; list a pair twice to allow two.
-pairs = collections.Counter(tuple(l.split()[:2]) for l in exempt_pairs.splitlines() if l.strip())
-
-# Docker Hub official images have no slash: those versions.env uses, plus
-# the usual base images.
-env = open(os.path.join(root, "versions.env")).read()
-bare = set(re.findall(r'^[A-Z0-9_]+_IMAGE="([^"/:@]+)[:@]', env, re.M))
-bare |= {"ubuntu", "debian", "alpine", "busybox", "centos", "rockylinux", "fedora",
-         "python", "node", "perl", "r-base", "openjdk", "eclipse-temurin", "golang", "rust"}
-
-# Any tag: a version, or a word such as latest or stable.
-TAG = r'(?::[A-Za-z0-9_][A-Za-z0-9._-]*|@sha256:[0-9a-f]{64})'
-LEAD = r'(?<![A-Za-z0-9_./:@$-])'
-SHAPE = re.compile(LEAD + r'([a-z][a-z0-9._-]*/[a-z][a-z0-9._/-]*' + TAG + r')(?![A-Za-z0-9_/-])')
-BARE = re.compile(LEAD + r'((?:' + "|".join(map(re.escape, sorted(bare))) + r')' + TAG + r')(?![A-Za-z0-9_/-])')
-URL = re.compile(r'[a-z][a-z0-9+.-]*://\S+')
-# A path to a file, such as modules/local/vep/main.nf:23, is not an image.
-FILE = re.compile(r'\.(nf|sh|md|py|config|ya?ml|json|txt|tsv|csv|vcf|gz|html|css|js|R|r):[0-9]+(-[0-9]+)?$')
-
-bad = 0
-for f in files:
-    if any(f == s or (s.endswith("/") and f.startswith(s)) for s in skip):
-        continue
-    try:
-        text = open(os.path.join(root, f), encoding="utf-8").read()
-    except (UnicodeDecodeError, IsADirectoryError, FileNotFoundError):
-        continue
-    left = collections.Counter({k: v for k, v in pairs.items() if k[0] == f})
-    for n, line in enumerate(text.split("\n"), 1):
-        # docker://image:tag (a step image in a workflow) is an image, not a URL.
-        line = URL.sub(" ", line.replace("docker://", " "))
-        for rx in (SHAPE, BARE):
-            for m in rx.finditer(line):
-                image = m.group(1).rstrip(".")  # a full stop ends the sentence, not the tag
-                if FILE.search(image) or image.startswith("example/"):
-                    continue  # example/ is the placeholder namespace of the self-tests
-                if left[(f, image)] > 0:
-                    left[(f, image)] -= 1
-                    continue
-                print("FAIL: %s:%d names the image %s; use its *_IMAGE variable from versions.env" % (f, n, image))
-                bad = 1
-print("scanned %d files" % len(files))
-sys.exit(bad)
-PY
+  "$OG" dev scan images --root "$ROOT" --exempt-files "$EXEMPT_FILES" --exempt-pairs "$EXEMPT_PAIRS" <<<"$list"
 }
 
 # coupled: rule 4. Prints one line per tool, exit 1 if one disagrees.
 coupled() {
-  python3 - "${ROOT}/versions.env" <<'PY'
-import re, sys
-env = open(sys.argv[1]).read()
-def line(var):
-    m = re.search(r'^%s="([^"]*)"(.*)$' % var, env, re.M)
-    return (m.group(1), m.group(2)) if m else (None, "")
-def release(var):
-    value = line(var)[0] or ""
-    tag = value.rsplit("/", 1)[-1]
-    return tag.split(":", 1)[1].split("--")[0] if ":" in tag else None
-image, comment = line("MINIMAP2_SAMTOOLS_IMAGE")
-if image is None:
-    print("FAIL: MINIMAP2_SAMTOOLS_IMAGE is not set in versions.env")
-    sys.exit(1)
-held = {k: v.rstrip(".") for k, v in re.findall(r"\b(minimap2|samtools)=([0-9][0-9A-Za-z.]*)", comment)}
-bad = 0
-for tool, var in (("minimap2", "MINIMAP2_IMAGE"), ("samtools", "SAMTOOLS_IMAGE")):
-    want, got = release(var), held.get(tool)
-    if want and got == want:
-        print("OK: MINIMAP2_SAMTOOLS_IMAGE holds %s %s, the release of %s" % (tool, got, var))
-    else:
-        print("FAIL: MINIMAP2_SAMTOOLS_IMAGE says %s=%s in its versions.env comment, but %s is %s: pin a"
-              " BioContainers mulled image with %s %s and name it in that comment (docs/updating.md, Held pins)"
-              % (tool, got or "(nothing)", var, want or "(unset)", tool, want or "?"))
-        bad = 1
-sys.exit(bad)
-PY
+  "$OG" dev versions coupled --env "${ROOT}/versions.env"
 }
 
 check() {
@@ -191,6 +117,9 @@ self_test() {
     fi
   }
 
+  # The copies have no bin/.og: they run this tree's og.
+  export OG
+
   copy clean
   rc=0; out=$("${tmp}/clean/scripts/ci/check-images.sh" 2>&1) || rc=$?
   [ "$rc" -eq 0 ] || { echo "self-test: the unchanged copy failed:"; printf '%s\n' "$out"; fail=1; }
@@ -230,6 +159,11 @@ self_test() {
   echo '/* Then quay.io/biocontainers/expansionhunter:5.0.0 again. */' >> "${tmp}/exempt-twice/docs/stylesheets/theme.css"
   expect exempt-twice '^FAIL: docs/stylesheets/theme\.css:[0-9]+ names the image quay\.io/biocontainers/expansionhunter:5\.0\.0;'
 
+  # An exempt literal that left its file: the exemption is stale.
+  copy exempt-stale
+  sed -i.bak 's|quay.io/biocontainers/expansionhunter:5.0.0|an example image|' "${tmp}/exempt-stale/docs/stylesheets/theme.css"
+  expect exempt-stale '^FAIL: docs/stylesheets/theme\.css no longer names quay\.io/biocontainers/expansionhunter:5\.0\.0; drop its line'
+
   # The bwa-mem2 tag scripts/ci/settle-doubts.sh once repeated: it reads
   # BWAMEM2_IMAGE from versions.env now, so that literal must fail again.
   copy settle-literal
diff --git a/scripts/ci/check-links.sh b/scripts/ci/check-links.sh
index 874403fb8..ea234bbe6 100755
--- a/scripts/ci/check-links.sh
+++ b/scripts/ci/check-links.sh
@@ -31,6 +31,10 @@
 set -euo pipefail
 
 REPO_ROOT=$(cd "$(dirname "$0")/../.." && pwd)
+# og fills the versions.env variables (og dev versions expand,
+# rust/crates/og-dev; bin/og picks the build for this machine); OG names
+# another og binary.
+OG=${OG:-${REPO_ROOT}/bin/og}
 JOBS=${LINKS_JOBS:-8}
 
 # Prints "URL<TAB>file:line" for every candidate URL under $1, before variable
@@ -58,31 +62,10 @@ raw_urls() {
 }
 
 # Fills ${NAME} and $NAME from the versions.env under $1, reading stdin, and
-# drops trailing punctuation.
+# drops trailing punctuation. A versions.env line that is not a plain
+# NAME="value" fails the check instead of being left out.
 expand_vars() {
-  local env=${1}/versions.env
-  # shellcheck disable=SC2016  # Python source, not shell
-  python3 -c '
-import re, sys
-vals = {}
-try:
-    for line in open(sys.argv[1]):
-        m = re.match(r"^([A-Z][A-Z0-9_]*)=\"([^\"]*)\"", line)
-        if m:
-            vals[m.group(1)] = m.group(2)
-except FileNotFoundError:
-    pass
-def sub(m):
-    name = m.group(1) or m.group(2)
-    return vals.get(name, m.group(0))
-for line in sys.stdin:
-    url, loc = line.rstrip("\n").split("\t", 1)
-    url = re.sub(r"\$\{([A-Z][A-Z0-9_]*)\}|\$([A-Z][A-Z0-9_]*)", sub, url)
-    # Trailing punctuation, and the brace that closes ${VAR:-https://...}.
-    while url and (url[-1] in ".,;:]" or (url[-1] == "}" and url.count("}") > url.count("{"))):
-        url = url[:-1]
-    print(url + "\t" + loc)
-' "$env"
+  "$OG" dev versions expand --env "${1}/versions.env"
 }
 
 # Prints "URL<TAB>locations" (locations joined by ", "), one line per URL.
@@ -132,7 +115,7 @@ probe() {
 # ROOT's repository), only the URLs that tree did not already have.
 check_tree() {
   local root=$1 since=${2:-} list tmp n=0 nskip=0 nbad=0 nold=0 url loc code
-  list=$(collect "$root")
+  list=$(collect "$root") || { echo "ERROR: could not read the URLs under ${root}" >&2; return 1; }
   tmp=$(mktemp -d)
   : > "${tmp}/check"; : > "${tmp}/skip"; : > "${tmp}/old"
   if [ -z "$list" ]; then
@@ -147,7 +130,11 @@ check_tree() {
       rm -rf "$tmp"
       return 1
     fi
-    collect "${tmp}/base" | cut -f1 > "${tmp}/old"
+    if ! collect "${tmp}/base" | cut -f1 > "${tmp}/old"; then
+      echo "ERROR: could not read the URLs of ${since}" >&2
+      rm -rf "$tmp"
+      return 1
+    fi
   fi
   while IFS=$'\t' read -r url loc; do
     [ -n "$url" ] || continue
@@ -299,13 +286,24 @@ EOF
     echo "SELF-TEST FAIL: --since did not request exactly the added URL"; fail=1
   fi
 
+  # A versions.env line that is not NAME="value" fails: the URLs built from
+  # it would otherwise go unfilled and be skipped.
+  mkdir -p "${d}/strict/scripts"
+  echo "wget ${good}/blob/main/README.md" > "${d}/strict/scripts/c.sh"
+  # shellcheck disable=SC2016  # the ${...} is the text planted in the file
+  echo 'TESTREPO="${OTHER}"' > "${d}/strict/versions.env"
+  rc=0; out=$(check_tree "${d}/strict" 2>&1) || rc=$?
+  if [ "$rc" -eq 0 ] || ! grep -qF 'versions.env:1: not a NAME="value" line' <<<"$out"; then
+    echo "$out"; echo "SELF-TEST FAIL: a versions.env line with an expansion was read"; fail=1
+  fi
+
   # An empty tree is a failure.
   mkdir -p "${d}/empty"
   rc=0; out=$(check_tree "${d}/empty" 2>&1) || rc=$?
   [ "$rc" -ne 0 ] || { echo "SELF-TEST FAIL: an empty tree passed"; fail=1; }
 
   if [ "$fail" -eq 0 ]; then
-    echo "SELF-TEST OK: a 404, no answer and an empty tree fail; comments, prose and scripts/ci are left out; \${VAR} is filled from versions.env; --since requests only added URLs."
+    echo "SELF-TEST OK: a 404, no answer, an unreadable versions.env line and an empty tree fail; comments, prose and scripts/ci are left out; \${VAR} is filled from versions.env; --since requests only added URLs."
   fi
   return "$fail"
 }
diff --git a/scripts/ci/check-personal-data.sh b/scripts/ci/check-personal-data.sh
index 534c22dc8..4127d3799 100755
--- a/scripts/ci/check-personal-data.sh
+++ b/scripts/ci/check-personal-data.sh
@@ -36,6 +36,10 @@
 # the repository and point PERSONAL_DATA_PATTERNS at it; each match is
 # reported as kind "own".
 #
+# The scan is og dev scan personal-data (rust/crates/og-dev); bin/og runs
+# the build scripts/setup.sh --og puts in bin/.og for this machine, and OG
+# names another og binary.
+#
 # As a pre-commit hook, checking the staged files:
 #   cat > .git/hooks/pre-commit <<'HOOK'
 #   #!/bin/sh
@@ -47,6 +51,8 @@
 set -euo pipefail
 
 ROOT=$(cd "$(dirname "$0")/../.." && pwd)
+# og runs the scan (bin/og picks the build for this machine); OG overrides it.
+OG=${OG:-${ROOT}/bin/og}
 
 # file (exact path or glob)   text on the line that makes it a documented example
 # shellcheck disable=SC2016  # the entries are text, nothing expands
@@ -80,89 +86,16 @@ tests/parity/inputs/pgx-refblock-fill/*  built from the public PharmCAT data of
 tests/parity/golden/pgx-refblock-fill/*  the output og writes on those inputs
 '
 
+# scan [FILE...]: og dev scan personal-data (rust/crates/og-dev) with the
+# lists above; with no FILE, every file git ls-files lists under ROOT. A
+# scan that read no text file fails: it checked nothing.
 scan() {
-  python3 - "$ROOT" "$ALLOW" "$SKIP" "${PERSONAL_DATA_PATTERNS:-}" "${CACHED:-}" "$@" <<'PY'
-import fnmatch, os, re, subprocess, sys
-root, allow_text, skip_text, own_file, cached, args = sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4], sys.argv[5], sys.argv[6:]
-skip = [l.split()[0] for l in skip_text.splitlines() if l.strip()]
-allow = []
-for l in allow_text.splitlines():
-    if l.strip():
-        path, _, text = l.strip().partition(" ")
-        allow.append((path, text.strip()))
-
-if args:
-    files = args
-else:
-    out = subprocess.run(["git", "-C", root, "ls-files", "-z"], check=True, capture_output=True).stdout
-    files = [os.path.join(root, f) for f in out.decode().split("\0") if f]
-if not files:
-    print("FAIL: no file to scan")
-    sys.exit(1)
-
-# A label may carry a number after a separator: sample7, sample_01, donor-3.
-LABEL = r'(?:(?i:(?<![A-Za-z])(?:sample|patient|subject|proband|participant|individual|donor)s?(?:[_-]?[0-9]+)?(?![A-Za-z]))|\b(?:NA|HG)[0-9]{3,5}\b)'
-GT = r'\(?[ACGTDI][/|;]?[ACGTDI]\)?(?![A-Za-z0-9])'
-STR_GENES = (r'HTT|FMR1|C9orf72|C9ORF72|ATXN[0-9]+|DMPK|FXN|CNBP|RFC1|PABPN1|CACNA1A|TCF4|AR|'
-             r'PPP2R2B|TBP|JPH3|NOP56|ATN1|CSTB|AFF2|FMR2|NOTCH2NLC|DAB1|BEAN1|STARD7|YEATS2')
-OCTET = r'(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])'
-# (kind, pattern, the line must also match this or None). The pattern
-# marks only the leaked value, so an allowed example covers just its span.
-RULES = [
-    ("home", re.compile(r'(?<![A-Za-z0-9_])(?:/home/[A-Za-z]|/Users/[A-Za-z]|/mnt/use[r]\b|[A-Za-z]:\\\\?Users\\\\?[A-Za-z])'), None),
-    ("address", re.compile(r'(?<![0-9.])(?:10\.' + OCTET + r'|172\.(?:1[6-9]|2[0-9]|3[01])|192\.168|100\.(?:6[4-9]|[7-9][0-9]|1[01][0-9]|12[0-7]))'
-                           r'\.' + OCTET + r'\.' + OCTET + r'(?![0-9]|\.[0-9])'), None),
-    ("address", re.compile(r'[A-Za-z0-9-]\.ts\.net\b'), None),
-    ("diplotype", re.compile(r'\*[0-9]+[A-Za-z0-9.]*/\*[0-9]+'), re.compile(LABEL)),
-    ("rsid", re.compile(r'\brs[0-9]+\b[\s:=,;|`\'"\[\]-]{1,6}' + GT), None),
-    ("rsid", re.compile(r'\brs[0-9]+\t[0-9XYMT]{1,2}\t[0-9]+\t[ACGTDI-]{1,2}\b'), None),
-    ("repeat", re.compile(r'(?<![0-9./])[0-9]{1,4}/[0-9]{1,4}(?![0-9/])'), re.compile(r'\bREPCN\b')),
-    ("repeat", re.compile(r'\b(?:' + STR_GENES + r')\b[^/\n]{0,40}?(?<![0-9.])[0-9]{1,4}/[0-9]{1,4}(?![0-9/])'), None),
-]
-if own_file:
-    for l in open(own_file):
-        if l.strip() and not l.startswith("#"):
-            RULES.append(("own", re.compile(l.strip()), None))
-
-bad = scanned = 0
-for path in files:
-    full = os.path.abspath(path)
-    rel = os.path.relpath(full, root) if full.startswith(root + os.sep) else path
-    if any(fnmatch.fnmatchcase(rel, g) for g in skip):
-        continue
-    if cached:
-        # The blob in the index: what the commit will hold.
-        r = subprocess.run(["git", "-C", root, "show", ":" + rel], capture_output=True)
-        if r.returncode != 0:
-            continue
-        data = r.stdout
-    else:
-        try:
-            data = open(path, "rb").read()
-        except (IsADirectoryError, FileNotFoundError):
-            continue
-    if b"\0" in data[:8192]:
-        continue  # binary
-    scanned += 1
-    if rel == "scripts/ci/check-personal-data.sh":
-        texts = [t for _, t in allow]
-    else:
-        texts = [t for p, t in allow if fnmatch.fnmatchcase(rel, p)]
-    for n, line in enumerate(data.decode("utf-8", "replace").split("\n"), 1):
-        # Spans of the line that are documented examples.
-        spans = [(i.start(), i.end()) for t in texts for i in re.finditer(re.escape(t), line)]
-        for kind, rx, cond in RULES:
-            if cond is not None and not cond.search(line):
-                continue
-            for m in rx.finditer(line):
-                if any(a <= m.start() and m.end() <= b for a, b in spans):
-                    continue  # inside an allowed example; the rest of the line is still checked
-                print("FAIL %-9s %s:%d: %s" % (kind, rel, n, line.strip()[:160]))
-                bad = 1
-                break
-print("scanned %d text files" % scanned)
-sys.exit(bad)
-PY
+  local cached=()
+  [ -z "${CACHED:-}" ] || cached=(--cached)
+  local patterns=()
+  [ -z "${PERSONAL_DATA_PATTERNS:-}" ] || patterns=(--patterns "$PERSONAL_DATA_PATTERNS")
+  "$OG" dev scan personal-data --root "$ROOT" --allow "$ALLOW" --skip "$SKIP" \
+    ${patterns[@]+"${patterns[@]}"} ${cached[@]+"${cached[@]}"} -- "$@"
 }
 
 self_test() {
@@ -224,6 +157,22 @@ self_test() {
   else
     echo "self-test: caught: $(grep '^FAIL' <<<"$out")"
   fi
+  # A scan that read no text file checked nothing: it fails. Here the only
+  # file is binary.
+  printf 'a\0b\n' > "${tmp}/binary.bin"
+  rc=0; out=$(scan "${tmp}/binary.bin" 2>&1) || rc=$?
+  if [ "$rc" -ne 1 ] || ! grep -q '^FAIL: no text file was scanned' <<<"$out"; then
+    echo "self-test: a scan of no text file passed (exit ${rc}):"; printf '%s\n' "$out"; fail=1
+  else
+    echo "self-test: caught: $(grep '^FAIL' <<<"$out")"
+  fi
+  # ROOT reached through a symbolic link still places the file below it, so
+  # the file's allowed example applies.
+  ln -s "${tmp}/tree" "${tmp}/link"
+  # shellcheck disable=SC2016  # the backticks are text
+  plant tree/CONTRIBUTING.md 'Personal file paths (`/mnt/user/`, `/home/username/`, etc.)'
+  rc=0; out=$(ROOT="${tmp}/link" scan "${tmp}/tree/CONTRIBUTING.md" 2>&1) || rc=$?
+  [ "$rc" -eq 0 ] || { echo "self-test: an allowed example was reported under a linked ROOT:"; printf '%s\n' "$out"; fail=1; }
   # A pattern of your own, from PERSONAL_DATA_PATTERNS.
   printf '%s\n' 'Report for Jane Example' > "${tmp}/own.md"
   printf '%s\n' '\bJane Example\b' > "${tmp}/patterns"
diff --git a/scripts/ci/check-pgs-labels.sh b/scripts/ci/check-pgs-labels.sh
index ba5f84032..6e719c3d3 100755
--- a/scripts/ci/check-pgs-labels.sh
+++ b/scripts/ci/check-pgs-labels.sh
@@ -40,6 +40,9 @@
 set -euo pipefail
 
 ROOT=$(cd "$(dirname "$0")/../.." && pwd)
+# og reads the API's answers (og dev pgs, rust/crates/og-dev; bin/og picks
+# the build for this machine); OG names another og binary. curl asks.
+OG=${OG:-${ROOT}/bin/og}
 
 # Prints "ID<TAB>label" for every entry of the map in $1.
 read_map() {
@@ -62,31 +65,12 @@ trait_of() {
   local id=$1 body api=${PGS_API:-https://www.pgscatalog.org/rest/score}
   body=$(curl -fsS --connect-timeout 10 --max-time 30 --retry "${PGS_RETRY:-3}" --retry-delay 5 --retry-all-errors \
     -H 'Accept: application/json' "${api}/${id}") || return 1
-  ID="$id" python3 -c '
-import json, os, sys
-try:
-    d = json.loads(sys.stdin.read())
-except ValueError:
-    sys.exit(1)
-if not isinstance(d, dict) or d.get("id") != os.environ["ID"]:
-    sys.exit(1)
-t = (d.get("trait_reported") or "").strip()
-if not t:
-    sys.exit(1)
-print(t)
-' <<<"$body"
+  "$OG" dev pgs trait --id "$id" <<<"$body"
 }
 
 # Exit 0 when every word of label $1 appears in trait $2.
 label_matches() {
-  python3 - "$1" "$2" <<'EOF'
-import re, sys
-def words(s):
-    s = s.lower().replace("’", "").replace("'", "")
-    return set(re.sub(r"[^a-z0-9]+", " ", s).split())
-label, trait = words(sys.argv[1]), words(sys.argv[2])
-sys.exit(0 if label and label <= trait else 1)
-EOF
+  "$OG" dev pgs label-match "$1" "$2"
 }
 
 # Prints "ID<TAB>ppm_id<TAB>ancestry<TAB>effect" for every row of a score
@@ -100,49 +84,15 @@ read_metrics() {
 }
 
 # Exit 0 when evaluation $2 of the PGS Catalog belongs to score $1, was
-# measured in samples of ancestry $3 and reports effect $4 ("OR 1.61").
-# Prints what the catalog says, or why it does not match, on stdout. An
-# API that fails or answers without that id is exit 2.
+# measured in samples of ancestry $3 and reports effect $4 ("OR 1.61"; a
+# JSON true is not the number 1). Prints what the catalog says, or why it
+# does not match, on stdout. An API that fails or answers without that id
+# is exit 2.
 metric_matches() {
   local id=$1 ppm=$2 anc=$3 eff=$4 body api=${PGS_PERF_API:-https://www.pgscatalog.org/rest/performance}
   body=$(curl -fsS --connect-timeout 10 --max-time 30 --retry "${PGS_RETRY:-3}" --retry-delay 5 --retry-all-errors \
     -H 'Accept: application/json' "${api}/${ppm}") || { echo "(no answer)"; return 2; }
-  ID="$id" PPM="$ppm" ANC="$anc" EFF="$eff" python3 -c '
-import json, os, re, sys
-# The PGS Catalog ancestry_broad terms of each 1000 Genomes group pgsc_calc
-# reports (its ancestry_distribution uses the same codes).
-GROUPS = {
-    "EUR": {"European"},
-    "AFR": {"African unspecified", "African American or Afro-Caribbean", "Sub-Saharan African"},
-    "AMR": {"Hispanic or Latin American"},
-    "EAS": {"East Asian"},
-    "SAS": {"South Asian"},
-}
-def group(term):
-    for g, terms in GROUPS.items():
-        if term in terms:
-            return g
-    return None
-try:
-    d = json.loads(sys.stdin.read())
-except ValueError:
-    print("(not JSON)"); sys.exit(2)
-if not isinstance(d, dict) or d.get("id") != os.environ["PPM"]:
-    print("(no such evaluation)"); sys.exit(2)
-samples = (d.get("sampleset") or {}).get("samples") or []
-terms = [s.get("ancestry_broad") or "" for s in samples]
-found = {group(t) for t in terms}
-effects = [(e.get("name_short"), e.get("estimate")) for e in (d.get("performance_metrics") or {}).get("effect_sizes") or []]
-said = "%s, %s, %s" % (d.get("associated_pgs_id"), "; ".join(terms) or "no samples",
-                       "; ".join("%s %s" % e for e in effects) or "no effect size")
-print(said)
-m = re.fullmatch(r"(OR|HR) ([0-9]+(?:\.[0-9]+)?)", os.environ["EFF"])
-ok = (d.get("associated_pgs_id") == os.environ["ID"]
-      and os.environ["ANC"] in GROUPS and found == {os.environ["ANC"]}
-      and m is not None
-      and any(n == m.group(1) and isinstance(v, (int, float)) and abs(v - float(m.group(2))) < 1e-9 for n, v in effects))
-sys.exit(0 if ok else 1)
-' <<<"$body"
+  "$OG" dev pgs metric-match --id "$id" --ppm "$ppm" --ancestry "$anc" --effect "$eff" <<<"$body"
 }
 
 # The evaluations table of file $1; exit 1 when one is wrong. A score's
@@ -308,8 +258,24 @@ self_test() {
     echo "SELF-TEST FAIL: an evaluation was judged wrongly:"; echo "$out"; fail=1
   fi
 
+  # Control 7: an evaluation whose effect is the JSON value true is not an
+  # effect of 1. The answers are files (curl reads file:// URLs), so this
+  # control needs no network.
+  mkdir -p "${d}/perf"
+  printf '%s' '{"id": "PPM000001", "associated_pgs_id": "PGS000018", "sampleset": {"samples": [{"ancestry_broad": "European"}]}, "performance_metrics": {"effect_sizes": [{"name_short": "OR", "estimate": true}]}}' > "${d}/perf/PPM000001"
+  rc=0; out=$(PGS_PERF_API="file://${d}/perf" metric_matches PGS000018 PPM000001 EUR 'OR 1') || rc=$?
+  if [ "$rc" -ne 1 ]; then
+    echo "SELF-TEST FAIL: an effect of true was read as OR 1 (exit ${rc}): ${out}"; fail=1
+  fi
+  sed 's/true/1.0/' "${d}/perf/PPM000001" > "${d}/perf/PPM000002"
+  sed -i.bak 's/PPM000001/PPM000002/' "${d}/perf/PPM000002"
+  rc=0; out=$(PGS_PERF_API="file://${d}/perf" metric_matches PGS000018 PPM000002 EUR 'OR 1') || rc=$?
+  if [ "$rc" -ne 0 ]; then
+    echo "SELF-TEST FAIL: an effect of 1.0 was not read as OR 1 (exit ${rc}): ${out}"; fail=1
+  fi
+
   if [ "$fail" -eq 0 ]; then
-    echo "SELF-TEST OK: wrong label (list and map formats), old format, empty answer, no answer, empty map, and a wrong PPM id, ancestry or effect or an empty entry are all caught."
+    echo "SELF-TEST OK: wrong label (list and map formats), old format, empty answer, no answer, empty map, a wrong PPM id, ancestry or effect, an empty entry and an effect of true are all caught."
   fi
   return "$fail"
 }
diff --git a/scripts/ci/gen-containers-config.sh b/scripts/ci/gen-containers-config.sh
index 572001f2a..743f763a7 100755
--- a/scripts/ci/gen-containers-config.sh
+++ b/scripts/ci/gen-containers-config.sh
@@ -172,6 +172,10 @@ PRS  PGSC_CALC_VERSION  sha256=PGSC_CALC_SHA256 pgscatalog_utils=PGSC_UTILS_IMAG
 '
 
 ROOT=$(cd "$(dirname "$0")/../.." && pwd)
+# og reads a run's versions (rust/crates/og-dev; bin/og picks the build for
+# this machine); OG names another og binary. Set before --root, so a check
+# of another tree still runs this tree's og.
+OG=${OG:-${ROOT}/bin/og}
 MODE="write"
 ARGS=()
 while [ $# -gt 0 ]; do
@@ -272,43 +276,7 @@ check() {
 # its versions.yml block, the tag of the image it ran in (task.container).
 # Compare that line with the image conf/containers.config gives the process.
 check_versions() {
-  python3 - "$CONFIG" "$@" <<'PY'
-import re, sys
-config, yml, expect = sys.argv[1], sys.argv[2], sys.argv[3:]
-text = open(config).read()
-images = dict(re.findall(r"withName: '(\w+)' \{ container = '([^']+)' \}", text))
-# A process that runs on the host states the release of the pipeline it starts.
-images.update(re.findall(r"withName: '(\w+)' \{ ext\.pipeline_version = '([^']+)';", text))
-def tag(image):
-    return re.sub(r"^[^:@]+[:@]", "", image, count=1)
-first, proc = {}, None
-for line in open(yml):
-    m = re.match(r'^"([^"]+)":\s*$', line)
-    if m:
-        proc = m.group(1).split(":")[-1]
-        continue
-    m = re.match(r"^\s+([\w.-]+):\s*(.*?)\s*$", line)
-    if m and proc and proc not in first:
-        first[proc] = (m.group(1), m.group(2))
-fail = 0
-if not first:
-    print("FAIL: %s has no process block" % yml)
-    fail = 1
-for p in sorted(set(expect or images) | set(first)):
-    if p not in images:
-        print("FAIL %-20s has no selector in conf/containers.config" % p)
-        fail = 1
-    elif p not in first:
-        if p in (expect or images):
-            print("FAIL %-20s missing from %s" % (p, yml))
-            fail = 1
-    elif first[p][1] != tag(images[p]):
-        print("FAIL %-20s %s: %s, want %s (%s)" % (p, first[p][0], first[p][1], tag(images[p]), images[p]))
-        fail = 1
-    else:
-        print("OK   %-20s %s: %s" % (p, first[p][0], first[p][1]))
-sys.exit(fail)
-PY
+  "$OG" dev versions check-run --config "$CONFIG" "$@"
 }
 
 # self_test: plant each kind of fault in a copy of this tree and require

From 1d6e3b3dbab629dd0567ab9fcc681415c5fba97c Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 11:29:25 +0100
Subject: [PATCH 10/76] style(og): rustfmt the og dev scanners

Bead: pgp-bs9u.37
---
 rust/crates/og-dev/src/images.rs        | 63 +++++++++++++++----
 rust/crates/og-dev/src/lookaround.rs    | 11 ++--
 rust/crates/og-dev/src/personal_data.rs | 44 ++++++++++---
 rust/crates/og-dev/src/pgs.rs           | 82 ++++++++++++++++++++-----
 rust/crates/og-dev/src/versions.rs      | 59 ++++++++++++++----
 5 files changed, 205 insertions(+), 54 deletions(-)

diff --git a/rust/crates/og-dev/src/images.rs b/rust/crates/og-dev/src/images.rs
index 91ded0e7f..34f2d540d 100644
--- a/rust/crates/og-dev/src/images.rs
+++ b/rust/crates/og-dev/src/images.rs
@@ -73,8 +73,10 @@ static URL: LazyLock<Regex> =
     LazyLock::new(|| Regex::new(r"[a-z][a-z0-9+.-]*://[^\s\x1c-\x1f]+").expect("a valid pattern"));
 /// A path to a file, such as modules/local/vep/main.nf:23, is not an image.
 static FILE: LazyLock<Regex> = LazyLock::new(|| {
-    Regex::new(r"\.(nf|sh|md|py|config|ya?ml|json|txt|tsv|csv|vcf|gz|html|css|js|R|r):[0-9]+(-[0-9]+)?$")
-        .expect("a valid pattern")
+    Regex::new(
+        r"\.(nf|sh|md|py|config|ya?ml|json|txt|tsv|csv|vcf|gz|html|css|js|R|r):[0-9]+(-[0-9]+)?$",
+    )
+    .expect("a valid pattern")
 });
 
 fn bare_names(pins: &[Pin]) -> BTreeSet<String> {
@@ -99,8 +101,11 @@ fn patterns(bare: &BTreeSet<String>) -> [Rule; 2] {
             Some(lead),
         )
         .expect("a valid pattern"),
-        Rule::new(&format!(r"((?:{}){TAG}){AHEAD}", names.join("|")), Some(lead))
-            .expect("a valid pattern"),
+        Rule::new(
+            &format!(r"((?:{}){TAG}){AHEAD}", names.join("|")),
+            Some(lead),
+        )
+        .expect("a valid pattern"),
     ]
 }
 
@@ -219,7 +224,11 @@ fn scan(a: &ScanArgs, list: &str, out: &mut dyn Write) -> Result<bool, String> {
             let _ = writeln!(
                 out,
                 "FAIL: {f} no longer names {image}{}; drop its line from EXEMPT_PAIRS in scripts/ci/check-images.sh",
-                if *n > 1 { format!(" {n} more times") } else { String::new() }
+                if *n > 1 {
+                    format!(" {n} more times")
+                } else {
+                    String::new()
+                }
             );
             bad = true;
         }
@@ -267,16 +276,25 @@ static HELD: LazyLock<Regex> = LazyLock::new(|| {
 /// The check on parsed pins; prints one line per tool.
 pub fn coupled(pins: &[Pin], out: &mut dyn Write) -> bool {
     let Some(image) = versions_env::get(pins, "MINIMAP2_SAMTOOLS_IMAGE") else {
-        let _ = writeln!(out, "FAIL: MINIMAP2_SAMTOOLS_IMAGE is not set in versions.env");
+        let _ = writeln!(
+            out,
+            "FAIL: MINIMAP2_SAMTOOLS_IMAGE is not set in versions.env"
+        );
         return false;
     };
     let mut held: BTreeMap<&str, &str> = BTreeMap::new();
     for c in HELD.captures_iter(&image.rest) {
-        let (tool, v) = (c.get(1).map_or("", |m| m.as_str()), c.get(2).map_or("", |m| m.as_str()));
+        let (tool, v) = (
+            c.get(1).map_or("", |m| m.as_str()),
+            c.get(2).map_or("", |m| m.as_str()),
+        );
         held.insert(tool, v.trim_end_matches('.'));
     }
     let mut ok = true;
-    for (tool, var) in [("minimap2", "MINIMAP2_IMAGE"), ("samtools", "SAMTOOLS_IMAGE")] {
+    for (tool, var) in [
+        ("minimap2", "MINIMAP2_IMAGE"),
+        ("samtools", "SAMTOOLS_IMAGE"),
+    ] {
         let want = versions_env::get(pins, var).and_then(|p| release(&p.value));
         let got = held.get(tool).copied();
         match (want, got) {
@@ -337,7 +355,15 @@ mod tests {
         String::from_utf8(out)
             .unwrap()
             .lines()
-            .map(|l| l.split(" names the image ").nth(1).unwrap().split(';').next().unwrap().to_owned())
+            .map(|l| {
+                l.split(" names the image ")
+                    .nth(1)
+                    .unwrap()
+                    .split(';')
+                    .next()
+                    .unwrap()
+                    .to_owned()
+            })
             .collect()
     }
 
@@ -349,12 +375,21 @@ mod tests {
 
     #[test]
     fn literals_are_found_as_python_finds_them() {
-        assert_eq!(found(&p("docker run staphb/bcftools:~1.21 x")), [p("staphb/bcftools:~1.21")]);
-        assert_eq!(found(&p("runs staphb/samtools:~1.19.")), [p("staphb/samtools:~1.19")]);
+        assert_eq!(
+            found(&p("docker run staphb/bcftools:~1.21 x")),
+            [p("staphb/bcftools:~1.21")]
+        );
+        assert_eq!(
+            found(&p("runs staphb/samtools:~1.19.")),
+            [p("staphb/samtools:~1.19")]
+        );
         assert_eq!(found(&p("// container python:~3.12")), [p("python:~3.12")]);
         assert_eq!(found(&p("uses: docker://alpine:~3.8")), [p("alpine:~3.8")]);
         // A tag followed by a slash backs off to the part before a dot.
-        assert_eq!(found(&p("x staphb/samtools:~1.2/x")), [p("staphb/samtools:~1")]);
+        assert_eq!(
+            found(&p("x staphb/samtools:~1.2/x")),
+            [p("staphb/samtools:~1")]
+        );
         for clean in [
             "see https://quay.io/repository/biocontainers/samtools:1.0",
             "modules/local/vep/main.nf:23",
@@ -386,7 +421,9 @@ mod tests {
         std::fs::remove_dir_all(&dir).unwrap();
         assert!(!ok);
         assert!(
-            out.contains(&p("FAIL: a.md no longer names quay.io/x/y:~3; drop its line")),
+            out.contains(&p(
+                "FAIL: a.md no longer names quay.io/x/y:~3; drop its line"
+            )),
             "{out}"
         );
         assert!(!out.contains(&p("y:~2;")), "{out}");
diff --git a/rust/crates/og-dev/src/lookaround.rs b/rust/crates/og-dev/src/lookaround.rs
index d40d83b0d..d8dc7cce9 100644
--- a/rust/crates/og-dev/src/lookaround.rs
+++ b/rust/crates/og-dev/src/lookaround.rs
@@ -38,9 +38,9 @@ impl Rule {
                 let caps = self.re.captures_at(line, pos)?;
                 let m = caps.get(1).or_else(|| caps.get(0))?;
                 let (start, end) = (m.start(), m.end());
-                let refused = self.not_after.is_some_and(|bad| {
-                    line[..start].chars().next_back().is_some_and(bad)
-                });
+                let refused = self
+                    .not_after
+                    .is_some_and(|bad| line[..start].chars().next_back().is_some_and(bad));
                 if refused {
                     pos = next_char(line, start);
                     continue;
@@ -64,7 +64,10 @@ impl Rule {
 
 /// The byte offset of the character after `i`, or one past the end.
 fn next_char(s: &str, i: usize) -> usize {
-    s[i..].chars().next().map_or(s.len() + 1, |c| i + c.len_utf8())
+    s[i..]
+        .chars()
+        .next()
+        .map_or(s.len() + 1, |c| i + c.len_utf8())
 }
 
 #[cfg(test)]
diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
index 520ffb921..33cf3ef5b 100644
--- a/rust/crates/og-dev/src/personal_data.rs
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -138,12 +138,18 @@ fn builtin() -> Vec<Check> {
         },
         Check {
             kind: "rsid",
-            rule: rule(r"\brs[0-9]+\t[0-9XYMT]{1,2}\t[0-9]+\t[ACGTDI-]{1,2}\b", None),
+            rule: rule(
+                r"\brs[0-9]+\t[0-9XYMT]{1,2}\t[0-9]+\t[ACGTDI-]{1,2}\b",
+                None,
+            ),
             cond: None,
         },
         Check {
             kind: "repeat",
-            rule: rule(r"([0-9]{1,4}/[0-9]{1,4})(?:[^0-9/]|$)", Some(digit_dot_slash)),
+            rule: rule(
+                r"([0-9]{1,4}/[0-9]{1,4})(?:[^0-9/]|$)",
+                Some(digit_dot_slash),
+            ),
             cond: Some(&*REPCN),
         },
         // Python: \b(?:GENES)\b[^/\n]{0,40}?(?<![0-9.])N/N(?![0-9/]). The
@@ -286,7 +292,10 @@ fn git_files(root: &Path) -> Result<Vec<PathBuf>, String> {
 /// The staged blob of each path (relative to `root`), from one
 /// `git cat-file --batch`. A path with no blob in the index is absent.
 fn staged(root: &Path, rels: &[String]) -> Result<HashMap<String, Vec<u8>>, String> {
-    let wanted: Vec<&String> = rels.iter().filter(|r| !r.starts_with('/') && !r.contains('\n')).collect();
+    let wanted: Vec<&String> = rels
+        .iter()
+        .filter(|r| !r.starts_with('/') && !r.contains('\n'))
+        .collect();
     let mut blobs = HashMap::new();
     if wanted.is_empty() {
         return Ok(blobs);
@@ -345,7 +354,9 @@ fn scan_text(out: &mut dyn Write, rules: &[Check], texts: &[&str], rel: &str, da
             .flat_map(|t| line.match_indices(*t).map(|(a, s)| (a, a + s.len())))
             .collect();
         for c in rules {
-            if c.cond.is_some_and(|cs| !cs.iter().any(|r| r.is_match(line))) {
+            if c.cond
+                .is_some_and(|cs| !cs.iter().any(|r| r.is_match(line)))
+            {
                 continue;
             }
             let leaked = c
@@ -385,7 +396,10 @@ fn run(a: &Args, out: &mut dyn Write) -> Result<bool, String> {
         .filter(|(_, rel)| !a.skip.iter().any(|g| fnmatch(rel, g)))
         .collect();
     let blobs = if a.cached {
-        staged(&root, &todo.iter().map(|(_, r)| r.clone()).collect::<Vec<_>>())?
+        staged(
+            &root,
+            &todo.iter().map(|(_, r)| r.clone()).collect::<Vec<_>>(),
+        )?
     } else {
         HashMap::new()
     };
@@ -458,7 +472,9 @@ mod tests {
         let rules = builtin();
         let mut out = Vec::new();
         for c in &rules {
-            if c.cond.is_some_and(|cs| !cs.iter().any(|r| r.is_match(line))) {
+            if c.cond
+                .is_some_and(|cs| !cs.iter().any(|r| r.is_match(line)))
+            {
                 continue;
             }
             if c.rule.is_match(line) {
@@ -529,9 +545,21 @@ mod tests {
         let rules = builtin();
         let ex = p("(`/mnt/u~ser/`, `/ho~me/username/`, etc.)");
         let mut out = Vec::new();
-        assert!(!scan_text(&mut out, &rules, &[ex.as_str()], "x.md", ex.as_bytes()));
+        assert!(!scan_text(
+            &mut out,
+            &rules,
+            &[ex.as_str()],
+            "x.md",
+            ex.as_bytes()
+        ));
         let line = p(&format!("{ex} see /home/~bob/x"));
-        assert!(scan_text(&mut out, &rules, &[ex.as_str()], "x.md", line.as_bytes()));
+        assert!(scan_text(
+            &mut out,
+            &rules,
+            &[ex.as_str()],
+            "x.md",
+            line.as_bytes()
+        ));
         let got = String::from_utf8(out).unwrap();
         assert!(got.starts_with("FAIL home      x.md:1: "), "{got}");
     }
diff --git a/rust/crates/og-dev/src/pgs.rs b/rust/crates/og-dev/src/pgs.rs
index 3bc7acd3c..14639f36f 100644
--- a/rust/crates/og-dev/src/pgs.rs
+++ b/rust/crates/og-dev/src/pgs.rs
@@ -107,16 +107,21 @@ static EFFECT: LazyLock<Regex> =
 
 /// What the catalog says of an evaluation, and whether it matches. Err is
 /// the reason the answer is not an evaluation with that id.
-pub fn metric(body: &str, id: &str, ppm: &str, anc: &str, eff: &str) -> Result<(String, bool), String> {
+pub fn metric(
+    body: &str,
+    id: &str,
+    ppm: &str,
+    anc: &str,
+    eff: &str,
+) -> Result<(String, bool), String> {
     let d = loads(body).map_err(|_| "(not JSON)".to_owned())?;
     if !matches!(d, Value::Object(_)) || !is_str(field(&d, "id"), ppm) {
         return Err("(no such evaluation)".into());
     }
     let odd = || "(not an evaluation the check can read)".to_owned();
     let empty = Value::Null;
-    let or_empty = |v: Option<&'_ Value>| -> Value {
-        v.filter(|v| truthy(v)).cloned().unwrap_or(Value::Null)
-    };
+    let or_empty =
+        |v: Option<&'_ Value>| -> Value { v.filter(|v| truthy(v)).cloned().unwrap_or(Value::Null) };
     let samples = match or_empty(field(&or_empty(field(&d, "sampleset")), "samples")) {
         Value::Null => Vec::new(),
         Value::Array(a) => a,
@@ -134,7 +139,10 @@ pub fn metric(body: &str, id: &str, ppm: &str, anc: &str, eff: &str) -> Result<(
         }
     }
     let found: std::collections::BTreeSet<Option<&str>> = terms.iter().map(|t| group(t)).collect();
-    let sizes = match or_empty(field(&or_empty(field(&d, "performance_metrics")), "effect_sizes")) {
+    let sizes = match or_empty(field(
+        &or_empty(field(&d, "performance_metrics")),
+        "effect_sizes",
+    )) {
         Value::Null => Vec::new(),
         Value::Array(a) => a,
         _ => return Err(odd()),
@@ -159,8 +167,16 @@ pub fn metric(body: &str, id: &str, ppm: &str, anc: &str, eff: &str) -> Result<(
     let said = format!(
         "{}, {}, {}",
         show(pgs)?,
-        if terms_said.is_empty() { "no samples" } else { &terms_said },
-        if effects_said.is_empty() { "no effect size" } else { &effects_said },
+        if terms_said.is_empty() {
+            "no samples"
+        } else {
+            &terms_said
+        },
+        if effects_said.is_empty() {
+            "no effect size"
+        } else {
+            &effects_said
+        },
     );
     let ok = is_str(Some(pgs), id)
         && group_named(anc)
@@ -259,21 +275,40 @@ mod tests {
     #[test]
     fn trait_needs_the_same_id_and_a_trait() {
         assert_eq!(
-            trait_of(r#"{"id": "PGS000018", "trait_reported": " Coronary artery disease "}"#, "PGS000018").as_deref(),
+            trait_of(
+                r#"{"id": "PGS000018", "trait_reported": " Coronary artery disease "}"#,
+                "PGS000018"
+            )
+            .as_deref(),
             Some("Coronary artery disease")
         );
         assert_eq!(trait_of("{}", "PGS000018"), None);
-        assert_eq!(trait_of(r#"{"id": "PGS000020", "trait_reported": "x"}"#, "PGS000018"), None);
-        assert_eq!(trait_of(r#"{"id": "PGS000018", "trait_reported": ""}"#, "PGS000018"), None);
+        assert_eq!(
+            trait_of(r#"{"id": "PGS000020", "trait_reported": "x"}"#, "PGS000018"),
+            None
+        );
+        assert_eq!(
+            trait_of(r#"{"id": "PGS000018", "trait_reported": ""}"#, "PGS000018"),
+            None
+        );
         assert_eq!(trait_of("not json", "PGS000018"), None);
     }
 
     #[test]
     fn labels_match_by_words() {
-        assert!(label_matches("Type 2 diabetes (T2D)", "Type 2 diabetes (T2D)"));
+        assert!(label_matches(
+            "Type 2 diabetes (T2D)",
+            "Type 2 diabetes (T2D)"
+        ));
         assert!(label_matches("type_2_diabetes", "Type 2 diabetes (T2D)"));
-        assert!(label_matches("Late-onset Alzheimer\u{2019}s disease", "Late-onset Alzheimer's disease"));
-        assert!(!label_matches("inflammatory_bowel_disease", "Type 2 diabetes (T2D)"));
+        assert!(label_matches(
+            "Late-onset Alzheimer\u{2019}s disease",
+            "Late-onset Alzheimer's disease"
+        ));
+        assert!(!label_matches(
+            "inflammatory_bowel_disease",
+            "Type 2 diabetes (T2D)"
+        ));
         assert!(!label_matches("", "anything"));
     }
 
@@ -294,10 +329,19 @@ mod tests {
             ("PGS000018", "XYZ", "HR 1.53"),
             ("PGS000018", "EUR", "HR"),
         ] {
-            assert!(!metric(ANSWER, id, "PPM000591", anc, eff).unwrap().1, "{id} {anc} {eff}");
+            assert!(
+                !metric(ANSWER, id, "PPM000591", anc, eff).unwrap().1,
+                "{id} {anc} {eff}"
+            );
         }
-        assert_eq!(metric("{}", "PGS000018", "PPM000591", "EUR", "HR 1.53").unwrap_err(), "(no such evaluation)");
-        assert_eq!(metric("<html>", "PGS000018", "PPM000591", "EUR", "HR 1.53").unwrap_err(), "(not JSON)");
+        assert_eq!(
+            metric("{}", "PGS000018", "PPM000591", "EUR", "HR 1.53").unwrap_err(),
+            "(no such evaluation)"
+        );
+        assert_eq!(
+            metric("<html>", "PGS000018", "PPM000591", "EUR", "HR 1.53").unwrap_err(),
+            "(not JSON)"
+        );
     }
 
     #[test]
@@ -307,7 +351,11 @@ mod tests {
         assert!(!ok, "{said}");
         assert_eq!(said, "PGS000018, European, HR True");
         let body = ANSWER.replace("1.53", "2");
-        assert!(metric(&body, "PGS000018", "PPM000591", "EUR", "HR 2").unwrap().1);
+        assert!(
+            metric(&body, "PGS000018", "PPM000591", "EUR", "HR 2")
+                .unwrap()
+                .1
+        );
     }
 
     #[test]
diff --git a/rust/crates/og-dev/src/versions.rs b/rust/crates/og-dev/src/versions.rs
index d08528e2e..6e4761c5f 100644
--- a/rust/crates/og-dev/src/versions.rs
+++ b/rust/crates/og-dev/src/versions.rs
@@ -103,7 +103,10 @@ pub fn check_run(
     for p in all {
         match (images.get(p), first.get(p)) {
             (None, _) => {
-                let _ = writeln!(out, "FAIL {p:<20} has no selector in conf/containers.config");
+                let _ = writeln!(
+                    out,
+                    "FAIL {p:<20} has no selector in conf/containers.config"
+                );
                 ok = false;
             }
             (Some(_), None) => {
@@ -142,7 +145,13 @@ pub fn cli_check_run(args: &[String], out: &mut dyn Write, err: &mut dyn Write)
     }
     let texts = read(config).and_then(|c| Ok((c, read(yml)?)));
     match texts {
-        Ok((c, y)) => u8::from(!check_run(&selectors(&c), &first_entries(&y), yml, expect, out)),
+        Ok((c, y)) => u8::from(!check_run(
+            &selectors(&c),
+            &first_entries(&y),
+            yml,
+            expect,
+            out,
+        )),
         Err(e) => {
             let _ = writeln!(err, "ERROR: {e}");
             2
@@ -150,8 +159,7 @@ pub fn cli_check_run(args: &[String], out: &mut dyn Write, err: &mut dyn Write)
     }
 }
 
-static VAR: LazyLock<Regex> =
-    LazyLock::new(|| re(r"\$\{([A-Z][A-Z0-9_]*)\}|\$([A-Z][A-Z0-9_]*)"));
+static VAR: LazyLock<Regex> = LazyLock::new(|| re(r"\$\{([A-Z][A-Z0-9_]*)\}|\$([A-Z][A-Z0-9_]*)"));
 
 /// One URL with its variables filled and its trailing punctuation dropped.
 pub fn expand(url: &str, vals: &BTreeMap<String, String>) -> String {
@@ -220,7 +228,13 @@ mod tests {
     fn run(yml: &str, expect: &[&str]) -> (bool, String) {
         let expect: Vec<String> = expect.iter().map(|s| (*s).to_owned()).collect();
         let mut out = Vec::new();
-        let ok = check_run(&selectors(CONFIG), &first_entries(yml), "v.yml", &expect, &mut out);
+        let ok = check_run(
+            &selectors(CONFIG),
+            &first_entries(yml),
+            "v.yml",
+            &expect,
+            &mut out,
+        );
         (ok, String::from_utf8(out).unwrap())
     }
 
@@ -231,7 +245,10 @@ mod tests {
             &[],
         );
         assert!(ok, "{out}");
-        assert!(out.contains("OK   ROH                  bcftools: 1.22--h0_0\n"), "{out}");
+        assert!(
+            out.contains("OK   ROH                  bcftools: 1.22--h0_0\n"),
+            "{out}"
+        );
     }
 
     #[test]
@@ -242,8 +259,14 @@ mod tests {
         );
         assert!(!ok);
         assert!(out.contains("FAIL ROH                  bcftools: 0.0.0-planted, want 1.22--h0_0 (quay.io/x/bcftools:1.22--h0_0)"), "{out}");
-        assert!(out.contains("FAIL NEW_TOOL             has no selector"), "{out}");
-        assert!(out.contains("FAIL VEP                  missing from v.yml"), "{out}");
+        assert!(
+            out.contains("FAIL NEW_TOOL             has no selector"),
+            "{out}"
+        );
+        assert!(
+            out.contains("FAIL VEP                  missing from v.yml"),
+            "{out}"
+        );
         assert!(!out.contains("PRS"), "{out}");
         let (ok, out) = run("nothing: here\n", &["ROH"]);
         assert!(!ok);
@@ -253,10 +276,22 @@ mod tests {
     #[test]
     fn urls_expand_and_lose_trailing_punctuation() {
         let vals = BTreeMap::from([("REL".to_owned(), "1.2".to_owned())]);
-        assert_eq!(expand("https://x.org/${REL}/a.gz", &vals), "https://x.org/1.2/a.gz");
-        assert_eq!(expand("https://x.org/$REL/a.gz).", &vals), "https://x.org/1.2/a.gz)");
-        assert_eq!(expand("https://x.org/${NOPE}/a.", &vals), "https://x.org/${NOPE}/a");
-        assert_eq!(expand("${U:-https://x.org/a}", &vals), "${U:-https://x.org/a}");
+        assert_eq!(
+            expand("https://x.org/${REL}/a.gz", &vals),
+            "https://x.org/1.2/a.gz"
+        );
+        assert_eq!(
+            expand("https://x.org/$REL/a.gz).", &vals),
+            "https://x.org/1.2/a.gz)"
+        );
+        assert_eq!(
+            expand("https://x.org/${NOPE}/a.", &vals),
+            "https://x.org/${NOPE}/a"
+        );
+        assert_eq!(
+            expand("${U:-https://x.org/a}", &vals),
+            "${U:-https://x.org/a}"
+        );
         assert_eq!(expand("https://x.org/a}", &vals), "https://x.org/a");
         assert_eq!(expand("https://x.org/a];:", &vals), "https://x.org/a");
     }

From 037a72381cf5d58e207483a1c117d73e9e3d5e8e Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 11:30:48 +0100
Subject: [PATCH 11/76] docs: changelog for the og dev scanners and version
 checks

Bead: pgp-bs9u.37
---
 CHANGELOG.md                      | 8 ++++++++
 scripts/ci/check-personal-data.sh | 6 +++---
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d8f5f4625..19f32e7da 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,14 @@ Each release's notes. From 1.0.0 on, a major or minor release has hand-written n
 
 ## Unreleased
 
+- The personal-data scan, the image scan and the version checks of CI now run in the Rust `og` binary: `og dev scan personal-data` (`scripts/ci/check-personal-data.sh`), `og dev scan images` and `og dev versions coupled` (`scripts/ci/check-images.sh`), `og dev versions check-run` (`scripts/ci/gen-containers-config.sh --check-versions`), `og dev versions expand` (`scripts/ci/check-links.sh`) and `og dev pgs` (`scripts/ci/check-pgs-labels.sh`). The scripts keep their options, lists and output lines; the Python inside them is gone. The personal-data scan of the repository takes 0.5 s instead of 3.6 s. Fixes:
+  - A personal-data scan that read no text file (every file skipped or binary) fails with `FAIL: no text file was scanned`. It printed `scanned 0 text files` and passed.
+  - A personal-data scan whose root is reached through a symbolic link places each file under that root, so the lists of skipped files and documented examples still apply to it.
+  - An image exemption in `check-images.sh` whose file no longer names that image fails with `FAIL: <file> no longer names <image>; drop its line from EXEMPT_PAIRS`. A stale exemption was never reported.
+  - `check-links.sh` and `check-images.sh` read `versions.env` strictly: a line that is not a plain `NAME="value"` (with no `"`, `$` or backquote in the value), or a name set twice, fails the check and names the line. Before, such a line was skipped, so the URLs built from it went unchecked.
+  - The PGS evaluation check never reads a JSON `true` as the number 1, so `"estimate": true` no longer matches an effect of `OR 1`.
+  - `PERSONAL_DATA_PATTERNS` holds patterns in the syntax of Rust's regex crate. It was Python's.
+
 - Step 37's own Y tools now run in the Rust `og` binary: `og y tree-positions` and `og y tree-place` (the placement on the current YFull YTree), `og y private-snps` (the private SNP list) and `og y yleaf-positions` (Yleaf's marker positions). They replace `bin/y_tree_place.py` and `bin/y_private_snps.py`, which are gone, and the `positions` command of `bin/yleaf_run.py`, which keeps only `predict`. og is static, so each part still runs in the Yleaf image. The three tables are the same, byte for byte, on the 43 parity cases, except where a line below says otherwise. On the pinned YTree 14.06.0 with a synthetic pileup of 362,055 positions, `og y tree-place` takes 0.8 s and 99 MB where the Python took 3.6 s and 389 MB; on a synthetic chrY VCF of 20,000 records, `og y private-snps` takes 0.3 s and 24 MB where the Python took 1.1 s and 330 MB. What changes on purpose:
   - `og y tree-place` reads the pileup by contig and position, and only its `chrY` (or `Y`) lines. The Python keyed it by position only, so a line on another contig could overwrite a chrY count. Lines on another contig are now counted at the end of the step line, and a pileup with both `chrY` and `Y` lines stops with exit 1. Step 37 makes a chrY-only pileup, so its results do not change.
   - `og y private-snps` refuses a callable mask with more than one FASTA record (exit 1). The Python joined the records into one sequence, which shifts every position after the first. The pinned mask has one record.
diff --git a/scripts/ci/check-personal-data.sh b/scripts/ci/check-personal-data.sh
index 4127d3799..82aed5c92 100755
--- a/scripts/ci/check-personal-data.sh
+++ b/scripts/ci/check-personal-data.sh
@@ -32,9 +32,9 @@
 #                                                 and require each to be caught
 #
 # Your own identifiers (names, sample ids, hostnames) do not belong in this
-# public file. Put one extended regular expression per line in a file outside
-# the repository and point PERSONAL_DATA_PATTERNS at it; each match is
-# reported as kind "own".
+# public file. Put one regular expression per line (the syntax of Rust's
+# regex crate, close to POSIX extended) in a file outside the repository and
+# point PERSONAL_DATA_PATTERNS at it; each match is reported as kind "own".
 #
 # The scan is og dev scan personal-data (rust/crates/og-dev); bin/og runs
 # the build scripts/setup.sh --og puts in bin/.og for this machine, and OG

From 253157eb02611bb6c62c4cfa07c6b50a30a1ddff Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 11:32:51 +0100
Subject: [PATCH 12/76] test(ci): the stale-exemption control fails only on the
 stale exemption

Bead: pgp-bs9u.37
---
 scripts/ci/check-images.sh | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/scripts/ci/check-images.sh b/scripts/ci/check-images.sh
index 9620755d1..61df53f30 100755
--- a/scripts/ci/check-images.sh
+++ b/scripts/ci/check-images.sh
@@ -162,6 +162,9 @@ self_test() {
   # An exempt literal that left its file: the exemption is stale.
   copy exempt-stale
   sed -i.bak 's|quay.io/biocontainers/expansionhunter:5.0.0|an example image|' "${tmp}/exempt-stale/docs/stylesheets/theme.css"
+  # sed's backup still names the image and is no exempt file: drop it, so
+  # only the stale exemption can fail this copy.
+  rm "${tmp}/exempt-stale/docs/stylesheets/theme.css.bak"
   expect exempt-stale '^FAIL: docs/stylesheets/theme\.css no longer names quay\.io/biocontainers/expansionhunter:5\.0\.0; drop its line'
 
   # The bwa-mem2 tag scripts/ci/settle-doubts.sh once repeated: it reads

From 8153ee5dad9064f75d43d4bbaf7985720e53cc7a Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 11:33:07 +0100
Subject: [PATCH 13/76] test(ci): red control, the five pre-fix readings
 planted back

Each self-test control and cargo test of the fixes must go red on this
commit; the next commit reverts it.

Bead: pgp-bs9u.37
---
 rust/crates/og-dev/src/images.rs        | 2 +-
 rust/crates/og-dev/src/personal_data.rs | 6 ++----
 rust/crates/og-dev/src/pgs.rs           | 1 +
 rust/crates/og-dev/src/versions_env.rs  | 2 ++
 4 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/rust/crates/og-dev/src/images.rs b/rust/crates/og-dev/src/images.rs
index 34f2d540d..ea265da40 100644
--- a/rust/crates/og-dev/src/images.rs
+++ b/rust/crates/og-dev/src/images.rs
@@ -220,7 +220,7 @@ fn scan(a: &ScanArgs, list: &str, out: &mut dyn Write) -> Result<bool, String> {
         }
     }
     for ((f, image), n) in &left {
-        if *n > 0 {
+        if *n > 0 && false {
             let _ = writeln!(
                 out,
                 "FAIL: {f} no longer names {image}{}; drop its line from EXEMPT_PAIRS in scripts/ci/check-images.sh",
diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
index 33cf3ef5b..c4999b11a 100644
--- a/rust/crates/og-dev/src/personal_data.rs
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -373,9 +373,7 @@ fn scan_text(out: &mut dyn Write, rules: &[Check], texts: &[&str], rel: &str, da
 }
 
 fn run(a: &Args, out: &mut dyn Write) -> Result<bool, String> {
-    let root = a
-        .root
-        .canonicalize()
+    let root = Ok::<_, std::io::Error>(a.root.clone()) // RED CONTROL: the pre-fix root
         .map_err(|e| format!("--root {}: {e}", a.root.display()))?;
     let mut rules = builtin();
     if let Some(p) = &a.patterns {
@@ -437,7 +435,7 @@ fn run(a: &Args, out: &mut dyn Write) -> Result<bool, String> {
         bad |= scan_text(out, &rules, &texts, rel, &data);
     }
     let _ = writeln!(out, "scanned {scanned} text files");
-    if scanned == 0 {
+    if scanned == 0 && false {
         let _ = writeln!(out, "FAIL: no text file was scanned");
         return Ok(false);
     }
diff --git a/rust/crates/og-dev/src/pgs.rs b/rust/crates/og-dev/src/pgs.rs
index 14639f36f..1c9945283 100644
--- a/rust/crates/og-dev/src/pgs.rs
+++ b/rust/crates/og-dev/src/pgs.rs
@@ -189,6 +189,7 @@ pub fn metric(
                     && match v {
                         Value::Int(i) => (*i as f64 - want).abs() < 1e-9,
                         Value::Float(x) => (x - want).abs() < 1e-9,
+                        Value::Bool(b) => (f64::from(u8::from(*b)) - want).abs() < 1e-9, // RED CONTROL: the pre-fix reading
                         _ => false, // a bool is never a number
                     }
             })
diff --git a/rust/crates/og-dev/src/versions_env.rs b/rust/crates/og-dev/src/versions_env.rs
index f6245ecbc..583c489ad 100644
--- a/rust/crates/og-dev/src/versions_env.rs
+++ b/rust/crates/og-dev/src/versions_env.rs
@@ -39,6 +39,8 @@ pub fn parse(text: &str) -> Result<Vec<Pin>, String> {
             continue;
         }
         let Some(c) = LINE.captures(line) else {
+            continue; // RED CONTROL: the pre-fix reading skipped the line
+            #[allow(unreachable_code)]
             return Err(format!(
                 "versions.env:{}: not a NAME=\"value\" line (a value holds no \", $ or backquote): {line}",
                 i + 1

From 22d98d52c02e3dffa5b00d2b12bea4b58d5ba7fc Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 11:35:24 +0100
Subject: [PATCH 14/76] test(ci): take the red control back out

Reverts 8153ee5d, which planted the five pre-fix readings to show each
control red.

Bead: pgp-bs9u.37
---
 rust/crates/og-dev/src/images.rs        | 2 +-
 rust/crates/og-dev/src/personal_data.rs | 6 ++++--
 rust/crates/og-dev/src/pgs.rs           | 1 -
 rust/crates/og-dev/src/versions_env.rs  | 2 --
 4 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/rust/crates/og-dev/src/images.rs b/rust/crates/og-dev/src/images.rs
index ea265da40..34f2d540d 100644
--- a/rust/crates/og-dev/src/images.rs
+++ b/rust/crates/og-dev/src/images.rs
@@ -220,7 +220,7 @@ fn scan(a: &ScanArgs, list: &str, out: &mut dyn Write) -> Result<bool, String> {
         }
     }
     for ((f, image), n) in &left {
-        if *n > 0 && false {
+        if *n > 0 {
             let _ = writeln!(
                 out,
                 "FAIL: {f} no longer names {image}{}; drop its line from EXEMPT_PAIRS in scripts/ci/check-images.sh",
diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
index c4999b11a..33cf3ef5b 100644
--- a/rust/crates/og-dev/src/personal_data.rs
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -373,7 +373,9 @@ fn scan_text(out: &mut dyn Write, rules: &[Check], texts: &[&str], rel: &str, da
 }
 
 fn run(a: &Args, out: &mut dyn Write) -> Result<bool, String> {
-    let root = Ok::<_, std::io::Error>(a.root.clone()) // RED CONTROL: the pre-fix root
+    let root = a
+        .root
+        .canonicalize()
         .map_err(|e| format!("--root {}: {e}", a.root.display()))?;
     let mut rules = builtin();
     if let Some(p) = &a.patterns {
@@ -435,7 +437,7 @@ fn run(a: &Args, out: &mut dyn Write) -> Result<bool, String> {
         bad |= scan_text(out, &rules, &texts, rel, &data);
     }
     let _ = writeln!(out, "scanned {scanned} text files");
-    if scanned == 0 && false {
+    if scanned == 0 {
         let _ = writeln!(out, "FAIL: no text file was scanned");
         return Ok(false);
     }
diff --git a/rust/crates/og-dev/src/pgs.rs b/rust/crates/og-dev/src/pgs.rs
index 1c9945283..14639f36f 100644
--- a/rust/crates/og-dev/src/pgs.rs
+++ b/rust/crates/og-dev/src/pgs.rs
@@ -189,7 +189,6 @@ pub fn metric(
                     && match v {
                         Value::Int(i) => (*i as f64 - want).abs() < 1e-9,
                         Value::Float(x) => (x - want).abs() < 1e-9,
-                        Value::Bool(b) => (f64::from(u8::from(*b)) - want).abs() < 1e-9, // RED CONTROL: the pre-fix reading
                         _ => false, // a bool is never a number
                     }
             })
diff --git a/rust/crates/og-dev/src/versions_env.rs b/rust/crates/og-dev/src/versions_env.rs
index 583c489ad..f6245ecbc 100644
--- a/rust/crates/og-dev/src/versions_env.rs
+++ b/rust/crates/og-dev/src/versions_env.rs
@@ -39,8 +39,6 @@ pub fn parse(text: &str) -> Result<Vec<Pin>, String> {
             continue;
         }
         let Some(c) = LINE.captures(line) else {
-            continue; // RED CONTROL: the pre-fix reading skipped the line
-            #[allow(unreachable_code)]
             return Err(format!(
                 "versions.env:{}: not a NAME=\"value\" line (a value holds no \", $ or backquote): {line}",
                 i + 1

From 103471c7dad096ab0d2801232ab9941b6e32e22d Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 11:34:43 +0100
Subject: [PATCH 15/76] test: take the planted faults out again (red control
 done)

This reverts commit 63938de53b7bf542246af55ea8ad3a31200c84fb.

Bead: pgp-bs9u.39
---
 rust/crates/og-dev/src/evidence.rs |  2 +-
 rust/crates/og-dev/src/fixture.rs  | 13 +++++++++++--
 rust/crates/og-dev/src/renovate.rs |  2 +-
 3 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/rust/crates/og-dev/src/evidence.rs b/rust/crates/og-dev/src/evidence.rs
index 6971f2f1b..c9b76d7fc 100644
--- a/rust/crates/og-dev/src/evidence.rs
+++ b/rust/crates/og-dev/src/evidence.rs
@@ -119,7 +119,7 @@ fn clash_positions(
         n += 1;
         let one = |a: &[u8]| std::str::from_utf8(a).map_or(a.len(), |s| s.chars().count()) == 1;
         snvs += u32::from(one(c[3]) && one(c[4]));
-        if n >= 3 && snvs >= 1 {
+        if n >= 2 && snvs >= 1 {
             hit.insert(k);
         }
         Ok(())
diff --git a/rust/crates/og-dev/src/fixture.rs b/rust/crates/og-dev/src/fixture.rs
index 0d5d9f3bf..bb163c9f9 100644
--- a/rust/crates/og-dev/src/fixture.rs
+++ b/rust/crates/og-dev/src/fixture.rs
@@ -200,7 +200,7 @@ pub mod comphet {
 
     /// The contig: `random.Random(31)` choosing among `ACGT` 80,000 times.
     pub fn reference() -> Vec<u8> {
-        let mut rng = Mt19937::new(32);
+        let mut rng = Mt19937::new(31);
         (0..LENGTH)
             .map(|_| b"ACGT"[rng.below(4) as usize])
             .collect()
@@ -423,7 +423,16 @@ fn diplotype(x: &Value) -> Result<Value, String> {
     let Value::Object(x) = x else {
         return Ok(x.clone());
     };
-    let mut out = pick(x, &["gene", "label", "phenotypes", "outsidePhenotype"]);
+    let mut out = pick(
+        x,
+        &[
+            "gene",
+            "label",
+            "phenotypes",
+            "activityScore",
+            "outsidePhenotype",
+        ],
+    );
     for a in ["allele1", "allele2"] {
         let Some(v) = x.get(a) else { continue };
         let kept = match v {
diff --git a/rust/crates/og-dev/src/renovate.rs b/rust/crates/og-dev/src/renovate.rs
index 4544ccb01..f3355c766 100644
--- a/rust/crates/og-dev/src/renovate.rs
+++ b/rust/crates/og-dev/src/renovate.rs
@@ -421,7 +421,7 @@ fn check(deps: &[Dep], env_text: &str, pins: &Pins) -> Vec<String> {
         } else {
             ":".to_owned()
         };
-        if text.contains(':') {
+        if text.contains([':', '@']) {
             fails.push(format!("names: {f}: package name {}", r(name)));
         }
     }

From 26f3daf2ea50e361fe3f3f2d62e8a5ea84bf8ca4 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 12:02:40 +0100
Subject: [PATCH 16/76] test(ci): red control again, clippy-clean, so cargo
 test shows each planted fault

The first red control stopped at clippy, so cargo test never ran and the
PGS self-test step never started. This one plants the same five readings
in a form clippy accepts; the next commit takes them back out.

Bead: pgp-bs9u.37
---
 rust/crates/og-dev/src/images.rs        | 2 +-
 rust/crates/og-dev/src/personal_data.rs | 6 ++----
 rust/crates/og-dev/src/pgs.rs           | 1 +
 rust/crates/og-dev/src/versions_env.rs  | 2 ++
 4 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/rust/crates/og-dev/src/images.rs b/rust/crates/og-dev/src/images.rs
index 34f2d540d..08b17432d 100644
--- a/rust/crates/og-dev/src/images.rs
+++ b/rust/crates/og-dev/src/images.rs
@@ -220,7 +220,7 @@ fn scan(a: &ScanArgs, list: &str, out: &mut dyn Write) -> Result<bool, String> {
         }
     }
     for ((f, image), n) in &left {
-        if *n > 0 {
+        if *n > 0 && std::hint::black_box(false) {
             let _ = writeln!(
                 out,
                 "FAIL: {f} no longer names {image}{}; drop its line from EXEMPT_PAIRS in scripts/ci/check-images.sh",
diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
index 33cf3ef5b..047d89952 100644
--- a/rust/crates/og-dev/src/personal_data.rs
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -373,9 +373,7 @@ fn scan_text(out: &mut dyn Write, rules: &[Check], texts: &[&str], rel: &str, da
 }
 
 fn run(a: &Args, out: &mut dyn Write) -> Result<bool, String> {
-    let root = a
-        .root
-        .canonicalize()
+    let root = Ok::<_, std::io::Error>(a.root.clone()) // RED CONTROL: the pre-fix root
         .map_err(|e| format!("--root {}: {e}", a.root.display()))?;
     let mut rules = builtin();
     if let Some(p) = &a.patterns {
@@ -437,7 +435,7 @@ fn run(a: &Args, out: &mut dyn Write) -> Result<bool, String> {
         bad |= scan_text(out, &rules, &texts, rel, &data);
     }
     let _ = writeln!(out, "scanned {scanned} text files");
-    if scanned == 0 {
+    if scanned == 0 && std::hint::black_box(false) {
         let _ = writeln!(out, "FAIL: no text file was scanned");
         return Ok(false);
     }
diff --git a/rust/crates/og-dev/src/pgs.rs b/rust/crates/og-dev/src/pgs.rs
index 14639f36f..1c9945283 100644
--- a/rust/crates/og-dev/src/pgs.rs
+++ b/rust/crates/og-dev/src/pgs.rs
@@ -189,6 +189,7 @@ pub fn metric(
                     && match v {
                         Value::Int(i) => (*i as f64 - want).abs() < 1e-9,
                         Value::Float(x) => (x - want).abs() < 1e-9,
+                        Value::Bool(b) => (f64::from(u8::from(*b)) - want).abs() < 1e-9, // RED CONTROL: the pre-fix reading
                         _ => false, // a bool is never a number
                     }
             })
diff --git a/rust/crates/og-dev/src/versions_env.rs b/rust/crates/og-dev/src/versions_env.rs
index f6245ecbc..583c489ad 100644
--- a/rust/crates/og-dev/src/versions_env.rs
+++ b/rust/crates/og-dev/src/versions_env.rs
@@ -39,6 +39,8 @@ pub fn parse(text: &str) -> Result<Vec<Pin>, String> {
             continue;
         }
         let Some(c) = LINE.captures(line) else {
+            continue; // RED CONTROL: the pre-fix reading skipped the line
+            #[allow(unreachable_code)]
             return Err(format!(
                 "versions.env:{}: not a NAME=\"value\" line (a value holds no \", $ or backquote): {line}",
                 i + 1

From d15dcf10ae6187b79d39df93fb1c120c6ab3df29 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 12:02:51 +0100
Subject: [PATCH 17/76] test(ci): take the second red control back out

Bead: pgp-bs9u.37
---
 rust/crates/og-dev/src/images.rs        | 2 +-
 rust/crates/og-dev/src/personal_data.rs | 6 ++++--
 rust/crates/og-dev/src/pgs.rs           | 1 -
 rust/crates/og-dev/src/versions_env.rs  | 2 --
 4 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/rust/crates/og-dev/src/images.rs b/rust/crates/og-dev/src/images.rs
index 08b17432d..34f2d540d 100644
--- a/rust/crates/og-dev/src/images.rs
+++ b/rust/crates/og-dev/src/images.rs
@@ -220,7 +220,7 @@ fn scan(a: &ScanArgs, list: &str, out: &mut dyn Write) -> Result<bool, String> {
         }
     }
     for ((f, image), n) in &left {
-        if *n > 0 && std::hint::black_box(false) {
+        if *n > 0 {
             let _ = writeln!(
                 out,
                 "FAIL: {f} no longer names {image}{}; drop its line from EXEMPT_PAIRS in scripts/ci/check-images.sh",
diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
index 047d89952..33cf3ef5b 100644
--- a/rust/crates/og-dev/src/personal_data.rs
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -373,7 +373,9 @@ fn scan_text(out: &mut dyn Write, rules: &[Check], texts: &[&str], rel: &str, da
 }
 
 fn run(a: &Args, out: &mut dyn Write) -> Result<bool, String> {
-    let root = Ok::<_, std::io::Error>(a.root.clone()) // RED CONTROL: the pre-fix root
+    let root = a
+        .root
+        .canonicalize()
         .map_err(|e| format!("--root {}: {e}", a.root.display()))?;
     let mut rules = builtin();
     if let Some(p) = &a.patterns {
@@ -435,7 +437,7 @@ fn run(a: &Args, out: &mut dyn Write) -> Result<bool, String> {
         bad |= scan_text(out, &rules, &texts, rel, &data);
     }
     let _ = writeln!(out, "scanned {scanned} text files");
-    if scanned == 0 && std::hint::black_box(false) {
+    if scanned == 0 {
         let _ = writeln!(out, "FAIL: no text file was scanned");
         return Ok(false);
     }
diff --git a/rust/crates/og-dev/src/pgs.rs b/rust/crates/og-dev/src/pgs.rs
index 1c9945283..14639f36f 100644
--- a/rust/crates/og-dev/src/pgs.rs
+++ b/rust/crates/og-dev/src/pgs.rs
@@ -189,7 +189,6 @@ pub fn metric(
                     && match v {
                         Value::Int(i) => (*i as f64 - want).abs() < 1e-9,
                         Value::Float(x) => (x - want).abs() < 1e-9,
-                        Value::Bool(b) => (f64::from(u8::from(*b)) - want).abs() < 1e-9, // RED CONTROL: the pre-fix reading
                         _ => false, // a bool is never a number
                     }
             })
diff --git a/rust/crates/og-dev/src/versions_env.rs b/rust/crates/og-dev/src/versions_env.rs
index 583c489ad..f6245ecbc 100644
--- a/rust/crates/og-dev/src/versions_env.rs
+++ b/rust/crates/og-dev/src/versions_env.rs
@@ -39,8 +39,6 @@ pub fn parse(text: &str) -> Result<Vec<Pin>, String> {
             continue;
         }
         let Some(c) = LINE.captures(line) else {
-            continue; // RED CONTROL: the pre-fix reading skipped the line
-            #[allow(unreachable_code)]
             return Err(format!(
                 "versions.env:{}: not a NAME=\"value\" line (a value holds no \", $ or backquote): {line}",
                 i + 1

From 36123685c1fb8b1ab224f4df15e174430b074ec2 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 12:03:19 +0100
Subject: [PATCH 18/76] test(parity): commit the hg002-gvcf reference inputs
 .gitignore hid

The dev-evidence-hg002-gvcf parity cases read ref.fasta and its .fai,
which the *.fasta ignore rule kept out of the tree, so CI parity stopped
with 'input not in tests/parity/inputs'.

Bead: pgp-bs9u.39
---
 tests/parity/inputs/dev-evidence-hg002-gvcf/ref.fasta     | 7 +++++++
 tests/parity/inputs/dev-evidence-hg002-gvcf/ref.fasta.fai | 2 ++
 2 files changed, 9 insertions(+)
 create mode 100644 tests/parity/inputs/dev-evidence-hg002-gvcf/ref.fasta
 create mode 100644 tests/parity/inputs/dev-evidence-hg002-gvcf/ref.fasta.fai

diff --git a/tests/parity/inputs/dev-evidence-hg002-gvcf/ref.fasta b/tests/parity/inputs/dev-evidence-hg002-gvcf/ref.fasta
new file mode 100644
index 000000000..b37a59afb
--- /dev/null
+++ b/tests/parity/inputs/dev-evidence-hg002-gvcf/ref.fasta
@@ -0,0 +1,7 @@
+>chrA test
+ACGTACGTACGTACGTACGT
+NNACGTacgtACGTACGTAC
+GTACGTACGT
+>chrB test
+ACNNNTGCAtgcaACGTACG
+TACGTACGTA
diff --git a/tests/parity/inputs/dev-evidence-hg002-gvcf/ref.fasta.fai b/tests/parity/inputs/dev-evidence-hg002-gvcf/ref.fasta.fai
new file mode 100644
index 000000000..9980f0dd1
--- /dev/null
+++ b/tests/parity/inputs/dev-evidence-hg002-gvcf/ref.fasta.fai
@@ -0,0 +1,2 @@
+chrA	50	11	20	21
+chrB	30	75	20	21

From 2244bed69d2219d116bd2bac8593236ba0d46f94 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 12:02:40 +0100
Subject: [PATCH 19/76] test(ci): red control on the merged head, clippy-clean

The first red control stopped at clippy, so cargo test never ran. This one
plants the same five pre-fix readings in a form clippy accepts, on top of
the main merge; the next commit takes them back out.

Bead: pgp-bs9u.37
---
 rust/crates/og-dev/src/images.rs        | 2 +-
 rust/crates/og-dev/src/personal_data.rs | 6 ++----
 rust/crates/og-dev/src/pgs.rs           | 1 +
 rust/crates/og-dev/src/versions_env.rs  | 2 ++
 4 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/rust/crates/og-dev/src/images.rs b/rust/crates/og-dev/src/images.rs
index 34f2d540d..08b17432d 100644
--- a/rust/crates/og-dev/src/images.rs
+++ b/rust/crates/og-dev/src/images.rs
@@ -220,7 +220,7 @@ fn scan(a: &ScanArgs, list: &str, out: &mut dyn Write) -> Result<bool, String> {
         }
     }
     for ((f, image), n) in &left {
-        if *n > 0 {
+        if *n > 0 && std::hint::black_box(false) {
             let _ = writeln!(
                 out,
                 "FAIL: {f} no longer names {image}{}; drop its line from EXEMPT_PAIRS in scripts/ci/check-images.sh",
diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
index 33cf3ef5b..047d89952 100644
--- a/rust/crates/og-dev/src/personal_data.rs
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -373,9 +373,7 @@ fn scan_text(out: &mut dyn Write, rules: &[Check], texts: &[&str], rel: &str, da
 }
 
 fn run(a: &Args, out: &mut dyn Write) -> Result<bool, String> {
-    let root = a
-        .root
-        .canonicalize()
+    let root = Ok::<_, std::io::Error>(a.root.clone()) // RED CONTROL: the pre-fix root
         .map_err(|e| format!("--root {}: {e}", a.root.display()))?;
     let mut rules = builtin();
     if let Some(p) = &a.patterns {
@@ -437,7 +435,7 @@ fn run(a: &Args, out: &mut dyn Write) -> Result<bool, String> {
         bad |= scan_text(out, &rules, &texts, rel, &data);
     }
     let _ = writeln!(out, "scanned {scanned} text files");
-    if scanned == 0 {
+    if scanned == 0 && std::hint::black_box(false) {
         let _ = writeln!(out, "FAIL: no text file was scanned");
         return Ok(false);
     }
diff --git a/rust/crates/og-dev/src/pgs.rs b/rust/crates/og-dev/src/pgs.rs
index 14639f36f..1c9945283 100644
--- a/rust/crates/og-dev/src/pgs.rs
+++ b/rust/crates/og-dev/src/pgs.rs
@@ -189,6 +189,7 @@ pub fn metric(
                     && match v {
                         Value::Int(i) => (*i as f64 - want).abs() < 1e-9,
                         Value::Float(x) => (x - want).abs() < 1e-9,
+                        Value::Bool(b) => (f64::from(u8::from(*b)) - want).abs() < 1e-9, // RED CONTROL: the pre-fix reading
                         _ => false, // a bool is never a number
                     }
             })
diff --git a/rust/crates/og-dev/src/versions_env.rs b/rust/crates/og-dev/src/versions_env.rs
index f6245ecbc..583c489ad 100644
--- a/rust/crates/og-dev/src/versions_env.rs
+++ b/rust/crates/og-dev/src/versions_env.rs
@@ -39,6 +39,8 @@ pub fn parse(text: &str) -> Result<Vec<Pin>, String> {
             continue;
         }
         let Some(c) = LINE.captures(line) else {
+            continue; // RED CONTROL: the pre-fix reading skipped the line
+            #[allow(unreachable_code)]
             return Err(format!(
                 "versions.env:{}: not a NAME=\"value\" line (a value holds no \", $ or backquote): {line}",
                 i + 1

From 3cec87db803672ef0e34fd8ae881b2dc77c9e8ae Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 12:21:07 +0100
Subject: [PATCH 20/76] test(ci): take the red control on the merged head back
 out

Bead: pgp-bs9u.37
---
 rust/crates/og-dev/src/images.rs        | 2 +-
 rust/crates/og-dev/src/personal_data.rs | 6 ++++--
 rust/crates/og-dev/src/pgs.rs           | 1 -
 rust/crates/og-dev/src/versions_env.rs  | 2 --
 4 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/rust/crates/og-dev/src/images.rs b/rust/crates/og-dev/src/images.rs
index 08b17432d..34f2d540d 100644
--- a/rust/crates/og-dev/src/images.rs
+++ b/rust/crates/og-dev/src/images.rs
@@ -220,7 +220,7 @@ fn scan(a: &ScanArgs, list: &str, out: &mut dyn Write) -> Result<bool, String> {
         }
     }
     for ((f, image), n) in &left {
-        if *n > 0 && std::hint::black_box(false) {
+        if *n > 0 {
             let _ = writeln!(
                 out,
                 "FAIL: {f} no longer names {image}{}; drop its line from EXEMPT_PAIRS in scripts/ci/check-images.sh",
diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
index 047d89952..33cf3ef5b 100644
--- a/rust/crates/og-dev/src/personal_data.rs
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -373,7 +373,9 @@ fn scan_text(out: &mut dyn Write, rules: &[Check], texts: &[&str], rel: &str, da
 }
 
 fn run(a: &Args, out: &mut dyn Write) -> Result<bool, String> {
-    let root = Ok::<_, std::io::Error>(a.root.clone()) // RED CONTROL: the pre-fix root
+    let root = a
+        .root
+        .canonicalize()
         .map_err(|e| format!("--root {}: {e}", a.root.display()))?;
     let mut rules = builtin();
     if let Some(p) = &a.patterns {
@@ -435,7 +437,7 @@ fn run(a: &Args, out: &mut dyn Write) -> Result<bool, String> {
         bad |= scan_text(out, &rules, &texts, rel, &data);
     }
     let _ = writeln!(out, "scanned {scanned} text files");
-    if scanned == 0 && std::hint::black_box(false) {
+    if scanned == 0 {
         let _ = writeln!(out, "FAIL: no text file was scanned");
         return Ok(false);
     }
diff --git a/rust/crates/og-dev/src/pgs.rs b/rust/crates/og-dev/src/pgs.rs
index 1c9945283..14639f36f 100644
--- a/rust/crates/og-dev/src/pgs.rs
+++ b/rust/crates/og-dev/src/pgs.rs
@@ -189,7 +189,6 @@ pub fn metric(
                     && match v {
                         Value::Int(i) => (*i as f64 - want).abs() < 1e-9,
                         Value::Float(x) => (x - want).abs() < 1e-9,
-                        Value::Bool(b) => (f64::from(u8::from(*b)) - want).abs() < 1e-9, // RED CONTROL: the pre-fix reading
                         _ => false, // a bool is never a number
                     }
             })
diff --git a/rust/crates/og-dev/src/versions_env.rs b/rust/crates/og-dev/src/versions_env.rs
index 583c489ad..f6245ecbc 100644
--- a/rust/crates/og-dev/src/versions_env.rs
+++ b/rust/crates/og-dev/src/versions_env.rs
@@ -39,8 +39,6 @@ pub fn parse(text: &str) -> Result<Vec<Pin>, String> {
             continue;
         }
         let Some(c) = LINE.captures(line) else {
-            continue; // RED CONTROL: the pre-fix reading skipped the line
-            #[allow(unreachable_code)]
             return Err(format!(
                 "versions.env:{}: not a NAME=\"value\" line (a value holds no \", $ or backquote): {line}",
                 i + 1

From 06213bd908cfe31e96fd03fd77b6eafc11e4cc70 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 12:27:54 +0100
Subject: [PATCH 21/76] test(parity): commit the past-the-end golden VCF
 .gitignore hid

The *.vcf ignore rule kept the golden out.vcf of
dev-evidence-hg002-gvcf/past-the-end out of the tree, so CI compared og
with the oracle and reported the deliberate fix as a difference.

Bead: pgp-bs9u.39
---
 .../dev-evidence-hg002-gvcf/past-the-end/out.vcf      | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 tests/parity/golden/dev-evidence-hg002-gvcf/past-the-end/out.vcf

diff --git a/tests/parity/golden/dev-evidence-hg002-gvcf/past-the-end/out.vcf b/tests/parity/golden/dev-evidence-hg002-gvcf/past-the-end/out.vcf
new file mode 100644
index 000000000..1e494f38c
--- /dev/null
+++ b/tests/parity/golden/dev-evidence-hg002-gvcf/past-the-end/out.vcf
@@ -0,0 +1,11 @@
+##fileformat=VCFv4.2
+##contig=<ID=chrA,length=50>
+##contig=<ID=chrB,length=30>
+##INFO=<ID=END,Number=1,Type=Integer,Description="End of the reference block">
+##ALT=<ID=*,Description="Any other allele">
+#CHROM	POS	ID	REF	ALT	QUAL	FILTER	INFO	FORMAT	HG002
+chrA	3	.	G	T	50	PASS	.	GT	0/1
+chrA	10	.	CGT	C	50	PASS	.	GT	0/1
+chrB	8	.	C	T	50	PASS	.	GT	0/1
+chrC	1	.	A	G	50	PASS	.	GT	0/1
+chrB	30	.	A	<*>	.	.	END=30	GT	0/0

From 3ff62369089236db926da5458bb15ef4fad0f78f Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 13:13:27 +0100
Subject: [PATCH 22/76] test(ci): cover HG002 reference blocks and scope the
 Rust fixture

Select comphet-phasing-1-reads when its Rust generator changes. Keep the push paths and scope list aligned. Check HG002 truth records and the last valid reference block directly against the committed golden.

Bead: pgp-bs9u.39
---
 .github/workflows/e2e.yml          |  1 +
 rust/crates/og-dev/src/evidence.rs | 47 ++++++++++++++++++++++++++++++
 scripts/ci/e2e-case-paths.tsv      |  2 +-
 scripts/ci/e2e-scope.sh            |  1 +
 4 files changed, 50 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/e2e.yml b/.github/workflows/e2e.yml
index 39d4b272d..b395a6ad0 100644
--- a/.github/workflows/e2e.yml
+++ b/.github/workflows/e2e.yml
@@ -65,6 +65,7 @@ on:
       - 'nextflow_schema.json'
       - 'versions.env'
       - '.github/workflows/e2e.yml'
+      - 'rust/crates/og-dev/src/fixture.rs'
       - '.github/actions/**'
       - 'tests/fixtures/annotsv/class45.sh'
       - 'tests/fixtures/consumer_export/sites.tsv.gz'
diff --git a/rust/crates/og-dev/src/evidence.rs b/rust/crates/og-dev/src/evidence.rs
index c9b76d7fc..84529a8ef 100644
--- a/rust/crates/og-dev/src/evidence.rs
+++ b/rust/crates/og-dev/src/evidence.rs
@@ -343,6 +343,53 @@ fn hg002_gvcf(
 mod tests {
     use super::*;
 
+    #[test]
+    fn hg002_gvcf_keeps_truth_and_adds_only_valid_reference_blocks() {
+        let repo = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../..");
+        let inputs = repo.join("tests/parity/inputs/dev-evidence-hg002-gvcf");
+        let temp = std::env::temp_dir().join(format!(
+            "og-evidence-gvcf-{}-{}",
+            std::process::id(),
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_nanos()
+        ));
+        fs::create_dir(&temp).unwrap();
+        let output = temp.join("out.vcf");
+        let args = [
+            "hg002-gvcf".to_owned(),
+            inputs.join("truth.vcf.gz").to_str().unwrap().to_owned(),
+            inputs
+                .join("truth-past-end.bed")
+                .to_str()
+                .unwrap()
+                .to_owned(),
+            inputs.join("ref.fasta").to_str().unwrap().to_owned(),
+            inputs
+                .join("sites-past-end.tsv")
+                .to_str()
+                .unwrap()
+                .to_owned(),
+            output.to_str().unwrap().to_owned(),
+        ];
+        let (mut out, mut err) = (Vec::new(), Vec::new());
+        assert_eq!(cli(&args, &mut out, &mut err), 0, "{err:?}");
+        assert_eq!(
+            out,
+            b"gVCF: 4 GIAB records, 1 reference blocks at panel sites\n"
+        );
+        assert!(err.is_empty());
+        let actual = fs::read(&output).unwrap();
+        fs::remove_dir_all(&temp).unwrap();
+        assert_eq!(
+            actual,
+            include_bytes!(
+                "../../../../tests/parity/golden/dev-evidence-hg002-gvcf/past-the-end/out.vcf"
+            )
+        );
+    }
+
     #[test]
     fn spans_merge_and_answer_inside() {
         let m = merge(vec![(10, 12), (5, 6), (11, 15), (15, 16)]);
diff --git a/scripts/ci/e2e-case-paths.tsv b/scripts/ci/e2e-case-paths.tsv
index 17e9c8f6d..d01f1b348 100644
--- a/scripts/ci/e2e-case-paths.tsv
+++ b/scripts/ci/e2e-case-paths.tsv
@@ -78,7 +78,7 @@ cn-guard-1-mapq0	bin/cn_loci.tsv bin/copy_number.py bin/og bin/traits_report.py
 cn-intervals-1-catalog	bin/cn_loci.tsv bin/og scripts/ci/build-cn-intervals.py scripts/ci/fake-docker/lib.sh
 cn-intervals-2-hg002	assets/par_grch38.bed assets/paralog_loci.tsv bin/cn_loci.tsv bin/copy_number.py bin/og bin/traits_report.py modules/local/deepvariant/* modules/local/parascopy/* modules/local/vcf_precheck/* scripts/35-paralogs.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 cn-report-1-tables	assets/carrier_genes.tsv assets/par_grch38.bed bin/collect_summary.py bin/couple_report.py bin/family_report.py bin/og bin/paraphase_report.py bin/render_report.py bin/results_index.py bin/traits_report.py scripts/24-html-report.sh scripts/39-couple.sh scripts/ci/fake-docker/lib.sh scripts/generate-report.sh
-comphet-phasing-1-reads	assets/construct_variants.tsv assets/stub/sample.bam assets/stub/sample.bam.bai bin/clip_check.py bin/og modules/local/slivar/* modules/local/vcf_precheck/* modules/local/vep/* scripts/13-vep-annotation.sh scripts/31-slivar.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
+comphet-phasing-1-reads	assets/construct_variants.tsv assets/stub/sample.bam assets/stub/sample.bam.bai bin/clip_check.py bin/og modules/local/slivar/* modules/local/vcf_precheck/* modules/local/vep/* scripts/13-vep-annotation.sh scripts/31-slivar.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh rust/crates/og-dev/src/fixture.rs
 construct-scan-1-both	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/mito_confirmed.tsv assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz bin/clip_check.py bin/collect_summary.py bin/og bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/clinvar_screen/* modules/local/html_report/* modules/local/vcf_precheck/* scripts/06-clinvar-screen.sh scripts/24-html-report.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 consumer-export-1	assets/chip_genes.tsv assets/par_grch38.bed bin/chip_report.py bin/og modules/local/chip/* modules/local/export_consumer/* modules/local/vcf_precheck/* scripts/40-export-consumer.sh scripts/49-chip.sh scripts/chip-to-vcf.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh tests/fixtures/consumer_export/sites.tsv.gz
 containers-software-versions	scripts/ci/fake-docker/lib.sh scripts/ci/gen-containers-config.sh
diff --git a/scripts/ci/e2e-scope.sh b/scripts/ci/e2e-scope.sh
index 81ddd26d0..b3305168d 100755
--- a/scripts/ci/e2e-scope.sh
+++ b/scripts/ci/e2e-scope.sh
@@ -45,6 +45,7 @@ export LC_ALL=C
 # runs no case. The push paths of e2e.yml are the same list (e2e-plan checks).
 SCOPE_DIRS=(scripts modules workflows bin conf assets tests/e2e .github/actions)
 SCOPE_FILES=(tests/fixtures/VERSION main.nf nextflow.config nextflow_schema.json versions.env .github/workflows/e2e.yml
+  rust/crates/og-dev/src/fixture.rs
   # The committed fixtures the cases read (their rows name them too).
   tests/fixtures/annotsv/class45.sh tests/fixtures/consumer_export/sites.tsv.gz
   tests/fixtures/families/stub_families.tsv tests/fixtures/pharmcat/refblocks.g.vcf tests/fixtures/sv/cnvpytor.vcf.in

From 63e44b68022e77d44ad14d6e3fc5392bdc2ada9b Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 13:13:41 +0100
Subject: [PATCH 23/76] test: plant a wrong HG002 reference genotype for the
 red control

Guard must reject 1/1 reference blocks in evidence::tests::hg002_gvcf_keeps_truth_and_adds_only_valid_reference_blocks. Revert this planted fault after recording its red CI job.

Bead: pgp-bs9u.39
---
 rust/crates/og-dev/src/evidence.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rust/crates/og-dev/src/evidence.rs b/rust/crates/og-dev/src/evidence.rs
index 84529a8ef..44651f17a 100644
--- a/rust/crates/og-dev/src/evidence.rs
+++ b/rust/crates/og-dev/src/evidence.rs
@@ -332,7 +332,7 @@ fn hg002_gvcf(
         }
         blocks += 1;
         w.write_all(c)
-            .and_then(|()| writeln!(w, "\t{p}\t.\t{}\t<*>\t.\t.\tEND={p}\tGT\t0/0", b as char))
+            .and_then(|()| writeln!(w, "\t{p}\t.\t{}\t<*>\t.\t.\tEND={p}\tGT\t1/1", b as char))
             .map_err(werr)
     })?;
     w.flush().map_err(werr)?;

From d3a7a9da7c02c76788c6098b2dab392cc79f4b07 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 13:13:56 +0100
Subject: [PATCH 24/76] test: restore the HG002 reference genotype after the
 red control

Remove the deliberately wrong 1/1 reference genotype. Keep the direct golden-file regression test.

Bead: pgp-bs9u.39
---
 rust/crates/og-dev/src/evidence.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rust/crates/og-dev/src/evidence.rs b/rust/crates/og-dev/src/evidence.rs
index 44651f17a..84529a8ef 100644
--- a/rust/crates/og-dev/src/evidence.rs
+++ b/rust/crates/og-dev/src/evidence.rs
@@ -332,7 +332,7 @@ fn hg002_gvcf(
         }
         blocks += 1;
         w.write_all(c)
-            .and_then(|()| writeln!(w, "\t{p}\t.\t{}\t<*>\t.\t.\tEND={p}\tGT\t1/1", b as char))
+            .and_then(|()| writeln!(w, "\t{p}\t.\t{}\t<*>\t.\t.\tEND={p}\tGT\t0/0", b as char))
             .map_err(werr)
     })?;
     w.flush().map_err(werr)?;

From 103d3b45d9e1d0a26fd5efcf1f729ccc97688298 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 13:26:20 +0100
Subject: [PATCH 25/76] fix(ci): check complete custom-pattern matches against
 examples

Keep custom regex captures from hiding the rest of a match inside an allowed example. Cover numbered and named captures, inline flags and extended-mode comments.

Bead: pgp-bs9u.37
---
 CHANGELOG.md                            |  2 +-
 rust/crates/og-dev/src/lookaround.rs    | 13 ++++++++++-
 rust/crates/og-dev/src/personal_data.rs | 30 ++++++++++++++++++++++++-
 3 files changed, 42 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 43489f003..329c0adc3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,7 +10,7 @@ Each release's notes. From 1.0.0 on, a major or minor release has hand-written n
   - An image exemption in `check-images.sh` whose file no longer names that image fails with `FAIL: <file> no longer names <image>; drop its line from EXEMPT_PAIRS`. A stale exemption was never reported.
   - `check-links.sh` and `check-images.sh` read `versions.env` strictly: a line that is not a plain `NAME="value"` (with no `"`, `$` or backquote in the value), or a name set twice, fails the check and names the line. Before, such a line was skipped, so the URLs built from it went unchecked.
   - The PGS evaluation check never reads a JSON `true` as the number 1, so `"estimate": true` no longer matches an effect of `OR 1`.
-  - `PERSONAL_DATA_PATTERNS` holds patterns in the syntax of Rust's regex crate. It was Python's.
+  - `PERSONAL_DATA_PATTERNS` holds patterns in the syntax of Rust's regex crate. It was Python's. Capture groups keep the full match when checking allowed examples.
 
 - The Rust `og` binary has a first part of the summary collector: `og summary collect --only a`. It reads seven sections of summary.json (coverage, callability, sex_check, sample_qc, mosaic_sex_loss, read_count and variants), the run status, the manifest and each section's state. Nothing calls it yet: the reports still read the summary that `bin/collect_summary.py` writes. The sections are the same as the Python's on 33 parity cases, compared as JSON with key order. It walks the sample folder once instead of running a `glob` for each candidate path, and it reads step 33's table once for its two sections. On a synthetic 1,000,000-record VCF the variant count takes 0.05 s and 7 MB, where the Python collector took 0.9 s and 38 MB. What differs from the Python:
   - A file named `.vcf.gz` that is plain text is read. The Python marked the variants section unreadable.
diff --git a/rust/crates/og-dev/src/lookaround.rs b/rust/crates/og-dev/src/lookaround.rs
index d8dc7cce9..f74d24383 100644
--- a/rust/crates/og-dev/src/lookaround.rs
+++ b/rust/crates/og-dev/src/lookaround.rs
@@ -16,6 +16,9 @@ use regex::Regex;
 /// A pattern with its look-behind.
 pub struct Rule {
     re: Regex,
+    /// Capture describing the match span: 1 for rewritten look-around,
+    /// 0 for a user's unmodified regular expression.
+    capture: usize,
     /// True for a character the match must not follow.
     not_after: Option<fn(char) -> bool>,
 }
@@ -26,17 +29,25 @@ impl Rule {
     pub fn new(pattern: &str, not_after: Option<fn(char) -> bool>) -> Result<Rule, regex::Error> {
         Ok(Rule {
             re: Regex::new(pattern)?,
+            capture: 1,
             not_after,
         })
     }
 
+    /// A user's regular expression, whose captures do not change its span.
+    pub fn whole_match(pattern: &str) -> Result<Rule, regex::Error> {
+        let mut rule = Self::new(pattern, None)?;
+        rule.capture = 0;
+        Ok(rule)
+    }
+
     /// The spans of `re.finditer` over `line`, in order.
     pub fn find_iter<'a>(&'a self, line: &'a str) -> impl Iterator<Item = (usize, usize)> + 'a {
         let mut pos = 0;
         std::iter::from_fn(move || {
             while pos <= line.len() {
                 let caps = self.re.captures_at(line, pos)?;
-                let m = caps.get(1).or_else(|| caps.get(0))?;
+                let m = caps.get(self.capture).or_else(|| caps.get(0))?;
                 let (start, end) = (m.start(), m.end());
                 let refused = self
                     .not_after
diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
index 33cf3ef5b..c56466e10 100644
--- a/rust/crates/og-dev/src/personal_data.rs
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -238,7 +238,9 @@ fn own_rules(path: &str) -> Result<Vec<Check>, String> {
         if p.is_empty() || l.starts_with('#') {
             continue;
         }
-        let rule = Rule::new(p, None).map_err(|e| format!("{path}: bad pattern {p}: {e}"))?;
+        // Rule reports capture 1 for the built-in look-around patterns.
+        // A user's captures must not narrow the span checked against ALLOW.
+        let rule = Rule::whole_match(p).map_err(|e| format!("{path}: bad pattern {p}: {e}"))?;
         out.push(Check {
             kind: "own",
             rule,
@@ -563,4 +565,30 @@ mod tests {
         let got = String::from_utf8(out).unwrap();
         assert!(got.starts_with("FAIL home      x.md:1: "), "{got}");
     }
+
+    #[test]
+    fn own_patterns_use_the_complete_match() {
+        let path =
+            std::env::temp_dir().join(format!("og-personal-patterns-{}", std::process::id()));
+        std::fs::write(
+            &path,
+            "PREFIX (PUBLIC) SUFFIX\nPREFIX (?P<label>PUBLIC) SUFFIX\n(?i)prefix (public) suffix\nPREFIX (?:PUBLIC) SUFFIX\n(?x)PREFIX\\s+(PUBLIC)\\s+SUFFIX # trailing comment\n",
+        )
+        .unwrap();
+        let rules = own_rules(path.to_str().unwrap()).unwrap();
+        std::fs::remove_file(path).unwrap();
+
+        let line = b"PREFIX PUBLIC SUFFIX";
+        let mut out = Vec::new();
+        assert!(scan_text(&mut out, &rules, &["PUBLIC"], "x.md", line));
+        let got = String::from_utf8(out).unwrap();
+        assert_eq!(got.lines().count(), 5, "{got}");
+        assert!(!scan_text(
+            &mut Vec::new(),
+            &rules,
+            &["PREFIX PUBLIC SUFFIX"],
+            "x.md",
+            line,
+        ));
+    }
 }

From ea5a440af6ff8b2fce808b337557ebbcdd67fbfb Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 13:31:52 +0100
Subject: [PATCH 26/76] docs(cli): list each new dev verb on its own usage line

Bead: pgp-bs9u.39
---
 rust/og/src/main.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/rust/og/src/main.rs b/rust/og/src/main.rs
index 529c1ac2d..841fcc8ef 100644
--- a/rust/og/src/main.rs
+++ b/rust/og/src/main.rs
@@ -74,7 +74,11 @@ const USAGE: &str = "usage: og <tool> [args]
        og exomiser report [args]
        og lookup query|resolve|report [args]
        og dev parity-compare|contract|schema|report-only|remnants [args]
-       og dev fixture|evidence|renovate-check [args]
+       og dev fixture comphet OUT [--swap]
+       og dev fixture trim-pharmcat REPORT OUT [MAX]
+       og dev evidence clashes RAW.vcf.gz SPLIT.vcf.gz DATA_DIR OUT.tsv
+       og dev evidence hg002-gvcf TRUTH.vcf.gz TRUTH.bed REF.fasta SITES.tsv OUT.vcf
+       og dev renovate-check LOG
        og dev freshness [--out FILE] [--sections a,b] | --update-issue BODY --repo O/N | --self-test
        og version
        og --tree-hash

From 80a675eadf73640c2a0f2d63fcfe30e6fdd0deef Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 14:37:24 +0100
Subject: [PATCH 27/76] test(ci): expose scanner privacy regressions against
 the Python oracle

---
 rust/crates/og-dev/src/personal_data.rs | 265 ++++++++++++++++++++++++
 1 file changed, 265 insertions(+)

diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
index c56466e10..f273ae8bf 100644
--- a/rust/crates/og-dev/src/personal_data.rs
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -591,4 +591,269 @@ mod tests {
             line,
         ));
     }
+    struct Fixture(PathBuf);
+    impl Fixture {
+        fn new(name: &str) -> Self {
+            let root = std::env::temp_dir().join(format!("og-scan-{name}-{}", std::process::id()));
+            std::fs::create_dir_all(&root).unwrap();
+            Self(root.canonicalize().unwrap())
+        }
+        fn args(&self, files: &[&str]) -> Vec<String> {
+            let mut args = vec![
+                "--root".into(),
+                self.0.display().to_string(),
+                "--allow".into(),
+                "".into(),
+                "--skip".into(),
+                "".into(),
+            ];
+            args.extend(files.iter().map(|f| self.0.join(f).display().to_string()));
+            args
+        }
+    }
+    impl Drop for Fixture {
+        fn drop(&mut self) {
+            let _ = std::fs::remove_dir_all(&self.0);
+        }
+    }
+
+    // Execute the removed scanner itself. Only its reporting is adapted to
+    // structured metadata, because printing findings is the bug being fixed.
+    fn oracle(f: &Fixture, files: &[&str], cached: bool) -> String {
+        const SHA: &str = "4104a93f2121b457413336574b8563fe85291fd7";
+        let repo = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../..");
+        let read = || {
+            Command::new("git")
+                .arg("-C")
+                .arg(&repo)
+                .args(["show", &format!("{SHA}:scripts/ci/check-personal-data.sh")])
+                .output()
+                .unwrap()
+        };
+        let mut source = read();
+        if !source.status.success() {
+            assert!(
+                Command::new("git")
+                    .arg("-C")
+                    .arg(&repo)
+                    .args(["fetch", "--quiet", "--depth=1", "origin", SHA])
+                    .status()
+                    .unwrap()
+                    .success()
+            );
+            source = read();
+        }
+        assert!(source.status.success());
+        let source = String::from_utf8(source.stdout).unwrap();
+        let python = source
+            .split("<<'PY'\n")
+            .nth(1)
+            .unwrap()
+            .split("\nPY\n")
+            .next()
+            .unwrap();
+        let python = python
+            .replace(
+                "import fnmatch, os, re, subprocess, sys",
+                "import fnmatch, os, re, subprocess, sys, json",
+            )
+            .replace(
+                "print(\"FAIL %-9s %s:%d: %s\" % (kind, rel, n, line.strip()[:160]))",
+                "print(json.dumps([kind, rel, n]))",
+            );
+        let mut cmd = Command::new("python3");
+        cmd.args(["-I", "-c", &python])
+            .arg(&f.0)
+            .args(["", "", "", if cached { "1" } else { "" }]);
+        for file in files {
+            cmd.arg(f.0.join(file));
+        }
+        let output = cmd.output().unwrap();
+        assert!(
+            output.status.code().is_some_and(|c| c == 0 || c == 1),
+            "oracle failed"
+        );
+        assert!(output.stderr.is_empty(), "oracle diagnostic");
+        String::from_utf8(output.stdout).unwrap()
+    }
+
+    fn assert_oracle_findings(f: &Fixture, files: &[&str], cached: bool) {
+        let expected = oracle(f, files, cached);
+        let mut args = f.args(files);
+        if cached {
+            args.insert(0, "--cached".into());
+        }
+        let (mut out, mut err) = (Vec::new(), Vec::new());
+        let code = cli(&args, &mut out, &mut err);
+        let out = String::from_utf8(out).unwrap();
+        assert!(err.is_empty(), "unexpected scanner diagnostic");
+        let reported: std::collections::HashSet<_> = out.lines().collect();
+        let mut count = 0;
+        for line in expected.lines().filter(|l| l.starts_with('[')) {
+            let pycompat::json::Value::Array(row) = pycompat::json::loads(line).unwrap() else {
+                panic!("metadata")
+            };
+            let [
+                pycompat::json::Value::Str(kind),
+                pycompat::json::Value::Str(rel),
+                pycompat::json::Value::Int(n),
+            ] = row.as_slice()
+            else {
+                panic!("metadata fields")
+            };
+            // Keep the required report spelling independent of report().
+            let finding = format!("FAIL {kind:<9} {}:{n}", rel.escape_debug());
+            assert!(
+                reported.iter().any(|l| *l == finding
+                    || l.strip_prefix(&finding)
+                        .is_some_and(|tail| tail.starts_with(": "))),
+                "missing oracle finding #{count}"
+            );
+            count += 1;
+        }
+        assert!(count > 0, "oracle control was clean");
+        assert_eq!(code, 1);
+        assert_eq!(
+            out.lines().filter(|l| l.starts_with("FAIL ")).count(),
+            count
+        );
+    }
+
+    #[test]
+    fn privacy_report_never_contains_values_or_patterns() {
+        let f = Fixture::new("redaction");
+        let secret = p("/home/~synthetic_private_marker/path");
+        std::fs::write(f.0.join("probe.md"), &secret).unwrap();
+        let expected = oracle(&f, &["probe.md"], false);
+        assert!(expected.contains("home"));
+        let (mut out, mut err) = (Vec::new(), Vec::new());
+        assert_eq!(cli(&f.args(&["probe.md"]), &mut out, &mut err), 1);
+        for stream in [&out, &err] {
+            assert!(
+                !String::from_utf8_lossy(stream).contains(&secret),
+                "reported private value"
+            );
+        }
+        assert_oracle_findings(&f, &["probe.md"], false);
+        let pattern = "CUSTOM_PRIVATE_PATTERN_MARKER[";
+        std::fs::write(f.0.join("patterns"), pattern).unwrap();
+        let mut args = f.args(&["probe.md"]);
+        args.extend([
+            "--patterns".into(),
+            f.0.join("patterns").display().to_string(),
+        ]);
+        out.clear();
+        err.clear();
+        assert_eq!(cli(&args, &mut out, &mut err), 2);
+        for stream in [&out, &err] {
+            assert!(
+                !String::from_utf8_lossy(stream).contains("CUSTOM_PRIVATE_PATTERN_MARKER"),
+                "reported custom pattern"
+            );
+        }
+    }
+
+    #[test]
+    fn privacy_python_boundaries_differential() {
+        let f = Fixture::new("boundaries");
+        let text = p(
+            "\u{301}rs123~ AG\nHG0~02\u{301} *1/~*4\nHTT\u{301} 17/~19\nREPCN\u{301} 17/~19\n/mnt/u~ser\u{301}\nx.ts.~net\u{301}\nrs123\t1\t9\t~AA\u{301}\n",
+        );
+        std::fs::write(f.0.join("probe.md"), text).unwrap();
+        assert_oracle_findings(&f, &["probe.md"], false);
+    }
+
+    #[test]
+    fn privacy_python_casefold_differential() {
+        let f = Fixture::new("casefold");
+        let text = p(
+            "patİent *1/~*4\npatıent *1/~*4\nſample *1/~*4\nİpatient *1/~*4\nıpatient *1/~*4\nKpatient *1/~*4\n",
+        );
+        std::fs::write(f.0.join("probe.md"), text).unwrap();
+        assert_oracle_findings(&f, &["probe.md"], false);
+    }
+
+    #[test]
+    fn privacy_staged_newline_differential() {
+        let f = Fixture::new("staged");
+        let git = |args: &[&str]| {
+            assert!(
+                Command::new("git")
+                    .arg("-C")
+                    .arg(&f.0)
+                    .args(args)
+                    .status()
+                    .unwrap()
+                    .success()
+            )
+        };
+        git(&["init", "-q"]);
+        std::fs::write(f.0.join("clean.md"), "clean\n").unwrap();
+        std::fs::write(
+            f.0.join("odd\nname.md"),
+            p("/home/~synthetic_private_marker/path\n"),
+        )
+        .unwrap();
+        git(&["add", "--", "clean.md", "odd\nname.md"]);
+        std::fs::write(f.0.join("odd\nname.md"), "clean\n").unwrap();
+        assert_oracle_findings(&f, &["clean.md", "odd\nname.md"], true);
+    }
+
+    #[test]
+    fn privacy_fixed_seed_differential_fuzz() {
+        let f = Fixture::new("fuzz");
+        let vocabulary = [
+            "rs123~ AG",
+            "HG0~02 *1/~*4",
+            "patient *1/~*4",
+            "patİent *1/~*4",
+            "patıent *1/~*4",
+            "ſample *1/~*4",
+            "HTT 17/~19",
+            "REPCN 17/~19",
+            "/home/~synthetic/path",
+            "/mnt/u~ser",
+            "node.ts.~net",
+            "10.2.~3.4",
+            "rs123\t1\t9\t~AA",
+            "clean",
+        ];
+        let noise = [
+            "", "\u{301}", "\u{345}", "\u{200d}", "\u{200b}", "İ", "ı", "ſ", "K", "é", "²", "_",
+            "\u{1c}", "\u{a0}", "\r", "\t",
+        ];
+        let mut seed = 0x5ca1ab1eu64;
+        let mut next = || {
+            seed ^= seed << 13;
+            seed ^= seed >> 7;
+            seed ^= seed << 17;
+            seed as usize
+        };
+        let mut data = Vec::new();
+        for _ in 0..6144 {
+            let value = p(vocabulary[next() % vocabulary.len()]);
+            let before = noise[next() % noise.len()];
+            let after = noise[next() % noise.len()];
+            // Noise at every internal boundary, not only outside the line.
+            let value = value.replace(' ', &format!("{after} {before}"));
+            data.extend_from_slice(format!("{before}{value}{after}\r\n").as_bytes());
+        }
+        data.extend_from_slice(&[0xff, 0xfe]);
+        data.extend_from_slice(p("rs123~ AG\n").as_bytes());
+        data.extend(std::iter::repeat_n(b'x', 100_000));
+        data.extend_from_slice(p(" HTT 17/~19\n\0REPCN 17/~19\n").as_bytes());
+        let names = [
+            "noise.md",
+            "odd\nname.md",
+            "tab\tname.md",
+            "-dash.md",
+            "unicode-\u{301}.md",
+            "binary.md",
+        ];
+        for name in &names[..5] {
+            std::fs::write(f.0.join(name), &data).unwrap();
+        }
+        std::fs::write(f.0.join(names[5]), b"\0binary").unwrap();
+        assert_oracle_findings(&f, &names, false);
+    }
 }

From 3786b369b8d49889c683d28984e1651f008c7040 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 14:38:50 +0100
Subject: [PATCH 28/76] fix(ci): preserve scanner findings without exposing
 private values

---
 CHANGELOG.md                                  |  5 +-
 rust/crates/og-dev/src/lookaround.rs          | 51 ++++++++++++++-
 rust/crates/og-dev/src/personal_data.rs       | 62 ++++++++++--------
 tests/parity/cases.tsv                        | 10 +++
 .../gen/dev-scanners-clean-dev-scan-images.sh |  3 +
 .../dev-scanners-matching-dev-pgs-metric.sh   |  3 +
 .../dev-scanners-matching-dev-pgs-trait.sh    |  3 +
 .../dev-scanners-urls-dev-versions-expand.sh  |  3 +
 tests/parity/gen/dev-scanners.sh              | 11 ++++
 .../dev-scan-personal/odd-filename/stdout     | 10 +++
 .../unicode-fixed-seed/stdout                 |  9 +++
 tests/parity/inputs/dev-scanners/clean.md     |  1 +
 .../inputs/dev-scanners/containers.config     |  1 +
 tests/parity/inputs/dev-scanners/image.md     |  1 +
 tests/parity/inputs/dev-scanners/metric.json  |  1 +
 tests/parity/inputs/dev-scanners/oracle.sh    | 64 +++++++++++++++++++
 .../inputs/dev-scanners/software_versions.yml |  2 +
 tests/parity/inputs/dev-scanners/trait.json   |  1 +
 tests/parity/inputs/dev-scanners/urls         |  2 +
 tests/parity/inputs/dev-scanners/versions.env |  4 ++
 tests/parity/oracle.ref                       |  8 +++
 21 files changed, 228 insertions(+), 27 deletions(-)
 create mode 100644 tests/parity/gen/dev-scanners-clean-dev-scan-images.sh
 create mode 100644 tests/parity/gen/dev-scanners-matching-dev-pgs-metric.sh
 create mode 100644 tests/parity/gen/dev-scanners-matching-dev-pgs-trait.sh
 create mode 100644 tests/parity/gen/dev-scanners-urls-dev-versions-expand.sh
 create mode 100644 tests/parity/gen/dev-scanners.sh
 create mode 100644 tests/parity/golden/dev-scan-personal/odd-filename/stdout
 create mode 100644 tests/parity/golden/dev-scan-personal/unicode-fixed-seed/stdout
 create mode 100644 tests/parity/inputs/dev-scanners/clean.md
 create mode 100644 tests/parity/inputs/dev-scanners/containers.config
 create mode 100644 tests/parity/inputs/dev-scanners/image.md
 create mode 100644 tests/parity/inputs/dev-scanners/metric.json
 create mode 100644 tests/parity/inputs/dev-scanners/oracle.sh
 create mode 100644 tests/parity/inputs/dev-scanners/software_versions.yml
 create mode 100644 tests/parity/inputs/dev-scanners/trait.json
 create mode 100644 tests/parity/inputs/dev-scanners/urls
 create mode 100644 tests/parity/inputs/dev-scanners/versions.env

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 329c0adc3..179c6722d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,12 +4,15 @@ Each release's notes. From 1.0.0 on, a major or minor release has hand-written n
 
 ## Unreleased
 
-- The personal-data scan, the image scan and the version checks of CI now run in the Rust `og` binary: `og dev scan personal-data` (`scripts/ci/check-personal-data.sh`), `og dev scan images` and `og dev versions coupled` (`scripts/ci/check-images.sh`), `og dev versions check-run` (`scripts/ci/gen-containers-config.sh --check-versions`), `og dev versions expand` (`scripts/ci/check-links.sh`) and `og dev pgs` (`scripts/ci/check-pgs-labels.sh`). The scripts keep their options, lists and output lines; the Python inside them is gone. The personal-data scan of the repository takes 0.5 s instead of 3.6 s. Fixes:
+- The personal-data scan, the image scan and the version checks of CI now run in the Rust `og` binary: `og dev scan personal-data` (`scripts/ci/check-personal-data.sh`), `og dev scan images` and `og dev versions coupled` (`scripts/ci/check-images.sh`), `og dev versions check-run` (`scripts/ci/gen-containers-config.sh --check-versions`), `og dev versions expand` (`scripts/ci/check-links.sh`) and `og dev pgs` (`scripts/ci/check-pgs-labels.sh`). The scripts keep their options and lists; the Python inside them is gone. The personal-data scan of the repository takes 0.5 s instead of 3.6 s. Fixes:
   - A personal-data scan that read no text file (every file skipped or binary) fails with `FAIL: no text file was scanned`. It printed `scanned 0 text files` and passed.
   - A personal-data scan whose root is reached through a symbolic link places each file under that root, so the lists of skipped files and documented examples still apply to it.
   - An image exemption in `check-images.sh` whose file no longer names that image fails with `FAIL: <file> no longer names <image>; drop its line from EXEMPT_PAIRS`. A stale exemption was never reported.
   - `check-links.sh` and `check-images.sh` read `versions.env` strictly: a line that is not a plain `NAME="value"` (with no `"`, `$` or backquote in the value), or a name set twice, fails the check and names the line. Before, such a line was skipped, so the URLs built from it went unchecked.
   - The PGS evaluation check never reads a JSON `true` as the number 1, so `"estimate": true` no longer matches an effect of `OR 1`.
+  - Personal-data findings print only the kind, escaped filename and line number. Matched values and custom-pattern contents never appear in diagnostics. The Python scanner printed the detected line.
+  - Built-in word boundaries and sample-label case folding follow Python, including combining marks, dotted and dotless I, long s and the Kelvin sign.
+  - The staged scan uses NUL-delimited Git requests and responses, so a filename containing a newline cannot hide a finding.
   - `PERSONAL_DATA_PATTERNS` holds patterns in the syntax of Rust's regex crate. It was Python's. Capture groups keep the full match when checking allowed examples.
 
 - The Rust `og` binary has a first part of the summary collector: `og summary collect --only a`. It reads seven sections of summary.json (coverage, callability, sex_check, sample_qc, mosaic_sex_loss, read_count and variants), the run status, the manifest and each section's state. Nothing calls it yet: the reports still read the summary that `bin/collect_summary.py` writes. The sections are the same as the Python's on 33 parity cases, compared as JSON with key order. It walks the sample folder once instead of running a `glob` for each candidate path, and it reads step 33's table once for its two sections. On a synthetic 1,000,000-record VCF the variant count takes 0.05 s and 7 MB, where the Python collector took 0.9 s and 38 MB. What differs from the Python:
diff --git a/rust/crates/og-dev/src/lookaround.rs b/rust/crates/og-dev/src/lookaround.rs
index f74d24383..cdd241fb7 100644
--- a/rust/crates/og-dev/src/lookaround.rs
+++ b/rust/crates/og-dev/src/lookaround.rs
@@ -16,6 +16,7 @@ use regex::Regex;
 /// A pattern with its look-behind.
 pub struct Rule {
     re: Regex,
+    boundaries: Vec<usize>,
     /// Capture describing the match span: 1 for rewritten look-around,
     /// 0 for a user's unmodified regular expression.
     capture: usize,
@@ -29,11 +30,45 @@ impl Rule {
     pub fn new(pattern: &str, not_after: Option<fn(char) -> bool>) -> Result<Rule, regex::Error> {
         Ok(Rule {
             re: Regex::new(pattern)?,
+            boundaries: Vec::new(),
             capture: 1,
             not_after,
         })
     }
 
+    /// A scanner pattern with Python's Unicode word boundaries. Python's
+    /// word characters are Unicode letters and numbers plus underscore;
+    /// Rust regex also includes marks and join controls. Capture each
+    /// boundary position and check it without consuming surrounding text.
+    pub fn python(
+        pattern: &str,
+        not_after: Option<fn(char) -> bool>,
+    ) -> Result<Rule, regex::Error> {
+        let mut translated = String::new();
+        for (i, part) in pattern.split(r"\b").enumerate() {
+            if i > 0 {
+                translated.push_str(&format!("(?P<og_boundary_{i}>)"));
+            }
+            translated.push_str(part);
+        }
+        let re = Regex::new(&translated)?;
+        let mut boundaries = Vec::new();
+        let mut capture = 0;
+        for (i, name) in re.capture_names().enumerate().skip(1) {
+            if name.is_some_and(|n| n.starts_with("og_boundary_")) {
+                boundaries.push(i);
+            } else if capture == 0 {
+                capture = i;
+            }
+        }
+        Ok(Self {
+            re,
+            boundaries,
+            capture,
+            not_after,
+        })
+    }
+
     /// A user's regular expression, whose captures do not change its span.
     pub fn whole_match(pattern: &str) -> Result<Rule, regex::Error> {
         let mut rule = Self::new(pattern, None)?;
@@ -52,7 +87,15 @@ impl Rule {
                 let refused = self
                     .not_after
                     .is_some_and(|bad| line[..start].chars().next_back().is_some_and(bad));
-                if refused {
+                let bad_boundary = self.boundaries.iter().any(|&i| {
+                    caps.get(i).is_some_and(|m| {
+                        let at = m.start();
+                        let left = line[..at].chars().next_back().is_some_and(python_word);
+                        let right = line[at..].chars().next().is_some_and(python_word);
+                        left == right
+                    })
+                });
+                if refused || bad_boundary {
                     pos = next_char(line, start);
                     continue;
                 }
@@ -73,6 +116,12 @@ impl Rule {
     }
 }
 
+fn python_word(c: char) -> bool {
+    static WORD: std::sync::LazyLock<Regex> =
+        std::sync::LazyLock::new(|| Regex::new(r"\A[\p{L}\p{N}_]\z").expect("word character"));
+    WORD.is_match(c.encode_utf8(&mut [0; 4]))
+}
+
 /// The byte offset of the character after `i`, or one past the end.
 fn next_char(s: &str, i: usize) -> usize {
     s[i..]
diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
index f273ae8bf..d12033fa6 100644
--- a/rust/crates/og-dev/src/personal_data.rs
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -16,7 +16,7 @@
 //! Each line of a text file (no NUL byte in its first 8 KiB) is matched
 //! against the rules below; a match inside an allowed example of that file
 //! is skipped, the rest of the line still counts. Output: one
-//! `FAIL <kind> <file>:<line>: <text>` per rule and line, then
+//! `FAIL <kind> <escaped-file>:<line>` per rule and line, then
 //! `scanned N text files`. Exit 0 clean, 1 on a finding or when no text
 //! file was scanned, 2 on a usage error or a file or pattern that cannot be
 //! read.
@@ -60,9 +60,9 @@ fn digit_dot_slash(c: char) -> bool {
 }
 
 /// `[A-Za-z]` under Python's `(?i)`, which also folds to the long s and
-/// the Kelvin sign.
+/// the Kelvin sign, plus dotted and dotless I.
 fn letter_ci(c: char) -> bool {
-    c.is_ascii_alphabetic() || c == '\u{17F}' || c == '\u{212A}'
+    c.is_ascii_alphabetic() || c == '\u{130}' || c == '\u{131}' || c == '\u{17F}' || c == '\u{212A}'
 }
 
 const STR_GENES: &str = "HTT|FMR1|C9orf72|C9ORF72|ATXN[0-9]+|DMPK|FXN|CNBP|RFC1|PABPN1|CACNA1A|TCF4|AR|PPP2R2B|TBP|JPH3|NOP56|ATN1|CSTB|AFF2|FMR2|NOTCH2NLC|DAB1|BEAN1|STARD7|YEATS2";
@@ -78,7 +78,7 @@ struct Check {
 }
 
 fn rule(pattern: &str, not_after: Option<fn(char) -> bool>) -> Rule {
-    Rule::new(pattern, not_after).expect("a valid built-in pattern")
+    Rule::python(pattern, not_after).expect("a valid built-in pattern")
 }
 
 /// A sample label, which may carry a number after a separator: sample7,
@@ -86,7 +86,7 @@ fn rule(pattern: &str, not_after: Option<fn(char) -> bool>) -> Rule {
 static LABEL: LazyLock<[Rule; 2]> = LazyLock::new(|| {
     [
         rule(
-            r"(?i)((?:sample|patient|subject|proband|participant|individual|donor)s?(?:[_-]?[0-9]+)?)(?:[^A-Za-z]|$)",
+            r"(?i)((?:sample|pat[iİı]ent|subject|proband|part[iİı]c[iİı]pant|[iİı]nd[iİı]v[iİı]dual|donor)s?(?:[_-]?[0-9]+)?)(?:[^A-Za-zİı]|$)",
             Some(letter_ci),
         ),
         rule(r"\b(?:NA|HG)[0-9]{3,5}\b", None),
@@ -233,14 +233,20 @@ fn parse(args: &[String]) -> Result<Args, String> {
 fn own_rules(path: &str) -> Result<Vec<Check>, String> {
     let text = std::fs::read_to_string(path).map_err(|e| format!("cannot read {path}: {e}"))?;
     let mut out = Vec::new();
-    for l in text.lines() {
+    for (line, l) in text.lines().enumerate() {
         let p = py_strip(l);
         if p.is_empty() || l.starts_with('#') {
             continue;
         }
         // Rule reports capture 1 for the built-in look-around patterns.
         // A user's captures must not narrow the span checked against ALLOW.
-        let rule = Rule::whole_match(p).map_err(|e| format!("{path}: bad pattern {p}: {e}"))?;
+        let rule = Rule::whole_match(p).map_err(|_| {
+            format!(
+                "{}:{}: invalid custom pattern",
+                path.escape_debug(),
+                line + 1
+            )
+        })?;
         out.push(Check {
             kind: "own",
             rule,
@@ -294,10 +300,7 @@ fn git_files(root: &Path) -> Result<Vec<PathBuf>, String> {
 /// The staged blob of each path (relative to `root`), from one
 /// `git cat-file --batch`. A path with no blob in the index is absent.
 fn staged(root: &Path, rels: &[String]) -> Result<HashMap<String, Vec<u8>>, String> {
-    let wanted: Vec<&String> = rels
-        .iter()
-        .filter(|r| !r.starts_with('/') && !r.contains('\n'))
-        .collect();
+    let wanted: Vec<&String> = rels.iter().collect();
     let mut blobs = HashMap::new();
     if wanted.is_empty() {
         return Ok(blobs);
@@ -305,7 +308,7 @@ fn staged(root: &Path, rels: &[String]) -> Result<HashMap<String, Vec<u8>>, Stri
     let mut child = Command::new("git")
         .arg("-C")
         .arg(root)
-        .args(["cat-file", "--batch"])
+        .args(["cat-file", "--batch", "-Z"])
         .stdin(Stdio::piped())
         .stdout(Stdio::piped())
         .spawn()
@@ -313,16 +316,20 @@ fn staged(root: &Path, rels: &[String]) -> Result<HashMap<String, Vec<u8>>, Stri
     let mut stdin = child.stdin.take().ok_or("no stdin for git")?;
     let input: Vec<u8> = wanted
         .iter()
-        .flat_map(|r| format!(":{r}\n").into_bytes())
+        .flat_map(|r| format!(":{r}\0").into_bytes())
         .collect();
     let writer = std::thread::spawn(move || stdin.write_all(&input));
     let mut out = BufReader::new(child.stdout.take().ok_or("no stdout for git")?);
     for rel in &wanted {
-        let mut head = String::new();
-        if out.read_line(&mut head).map_err(|e| e.to_string())? == 0 {
+        let mut header = Vec::new();
+        if out.read_until(0, &mut header).map_err(|e| e.to_string())? == 0 {
             return Err("git cat-file stopped early".into());
         }
-        let fields: Vec<&str> = head.trim_end().split(' ').collect();
+        if header.pop() != Some(0) {
+            return Err("git cat-file: incomplete header".into());
+        }
+        let head = String::from_utf8_lossy(&header);
+        let fields: Vec<&str> = head.split(' ').collect();
         let [_, kind, size] = fields[..] else {
             continue; // "<name> missing" or "ambiguous"
         };
@@ -334,16 +341,20 @@ fn staged(root: &Path, rels: &[String]) -> Result<HashMap<String, Vec<u8>>, Stri
             blobs.insert((*rel).clone(), data);
         }
     }
-    let _ = writer.join();
-    let _ = child.wait();
+    writer
+        .join()
+        .map_err(|_| "git input writer stopped")?
+        .map_err(|e| e.to_string())?;
+    if !child.wait().map_err(|e| e.to_string())?.success() {
+        return Err("git cat-file failed".into());
+    }
     Ok(blobs)
 }
 
-/// One line of the report: kind padded as Python's `%-9s`, the stripped
-/// line cut at 160 characters.
-fn report(out: &mut dyn Write, kind: &str, rel: &str, n: usize, line: &str) {
-    let text: String = py_strip(line).chars().take(160).collect();
-    let _ = writeln!(out, "FAIL {kind:<9} {rel}:{n}: {text}");
+/// Reports metadata only. Escape control characters in paths so each
+/// finding occupies one line, including filenames containing newlines.
+fn report(out: &mut dyn Write, kind: &str, rel: &str, n: usize) {
+    let _ = writeln!(out, "FAIL {kind:<9} {}:{n}", rel.escape_debug());
 }
 
 /// Scans one file's text; true when something was reported.
@@ -366,7 +377,7 @@ fn scan_text(out: &mut dyn Write, rules: &[Check], texts: &[&str], rel: &str, da
                 .find_iter(line)
                 .find(|&(s, e)| !spans.iter().any(|&(a, b)| a <= s && e <= b));
             if leaked.is_some() {
-                report(out, c.kind, rel, i + 1, line);
+                report(out, c.kind, rel, i + 1);
                 bad = true;
             }
         }
@@ -563,7 +574,7 @@ mod tests {
             line.as_bytes()
         ));
         let got = String::from_utf8(out).unwrap();
-        assert!(got.starts_with("FAIL home      x.md:1: "), "{got}");
+        assert!(got.starts_with("FAIL home      x.md:1"), "{got}");
     }
 
     #[test]
@@ -591,6 +602,7 @@ mod tests {
             line,
         ));
     }
+
     struct Fixture(PathBuf);
     impl Fixture {
         fn new(name: &str) -> Self {
diff --git a/tests/parity/cases.tsv b/tests/parity/cases.tsv
index 0a9afd6bf..d3d9ebf97 100644
--- a/tests/parity/cases.tsv
+++ b/tests/parity/cases.tsv
@@ -950,3 +950,13 @@ family-ibd	mapbp	gen:ibd-oracle.sh,gen:ibd-cases.sh	--pedigree mapbp/pedigree.ts
 family-ibd	nomap	gen:ibd-oracle.sh,gen:ibd-cases.sh	--pedigree nomap/pedigree.tsv --chroms nomap/chroms.txt --maps nomap/maps --phased nomap/phased --ibd nomap/ibd --out-dir out	-	content	PYTHON_IMAGE
 family-ibd	short	gen:ibd-oracle.sh,gen:ibd-cases.sh	--pedigree short/pedigree.tsv --chroms short/chroms.txt --maps short/maps --phased short/phased --ibd short/ibd --out-dir out	-	content	PYTHON_IMAGE
 family-ibd	twice	gen:ibd-oracle.sh,gen:ibd-cases.sh	--pedigree twice/pedigree.tsv --chroms twice/chroms.txt --maps twice/maps --phased twice/phased --ibd twice/ibd --out-dir out	-	content	PYTHON_IMAGE
+dev-scan-personal	clean	dev-scanners/oracle.sh,dev-scanners/clean.md	--root . --allow _ --skip _ clean.md	-	bytes	PYTHON_IMAGE
+dev-scan-personal	unicode-fixed-seed	dev-scanners/oracle.sh,gen:dev-scanners.sh	--root . --allow _ --skip _ probe.md	-	bytes	PYTHON_IMAGE
+dev-scan-personal	odd-filename	dev-scanners/oracle.sh,gen:dev-scanners.sh	--root . --allow _ --skip _	-	bytes	PYTHON_IMAGE
+dev-scan-images	clean	dev-scanners/oracle.sh,dev-scanners/versions.env,dev-scanners/image.md,gen:dev-scanners-clean-dev-scan-images.sh	--root . --exempt-files _ --exempt-pairs  	-	bytes	PYTHON_IMAGE
+dev-versions-coupled	coupled	dev-scanners/oracle.sh,dev-scanners/versions.env	--env versions.env	-	bytes	PYTHON_IMAGE
+dev-versions-check-run	matching	dev-scanners/oracle.sh,dev-scanners/containers.config,dev-scanners/software_versions.yml	--config containers.config software_versions.yml	-	bytes	PYTHON_IMAGE
+dev-versions-expand	urls	dev-scanners/oracle.sh,dev-scanners/versions.env,gen:dev-scanners-urls-dev-versions-expand.sh	--env versions.env	-	bytes	PYTHON_IMAGE
+dev-pgs-trait	matching	dev-scanners/oracle.sh,dev-scanners/trait.json,gen:dev-scanners-matching-dev-pgs-trait.sh	--id PGS000001	-	bytes	PYTHON_IMAGE
+dev-pgs-label	matching	dev-scanners/oracle.sh	synthetic synthetic-trait	-	bytes	PYTHON_IMAGE
+dev-pgs-metric	effect-format	dev-scanners/oracle.sh,dev-scanners/metric.json,gen:dev-scanners-matching-dev-pgs-metric.sh	--id PGS000001 --ppm PPM000001 --ancestry EUR --effect OR	-	bytes	PYTHON_IMAGE
diff --git a/tests/parity/gen/dev-scanners-clean-dev-scan-images.sh b/tests/parity/gen/dev-scanners-clean-dev-scan-images.sh
new file mode 100644
index 000000000..a478a3feb
--- /dev/null
+++ b/tests/parity/gen/dev-scanners-clean-dev-scan-images.sh
@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -euo pipefail
+printf "%s\n" image.md > stdin
diff --git a/tests/parity/gen/dev-scanners-matching-dev-pgs-metric.sh b/tests/parity/gen/dev-scanners-matching-dev-pgs-metric.sh
new file mode 100644
index 000000000..cfc9528e5
--- /dev/null
+++ b/tests/parity/gen/dev-scanners-matching-dev-pgs-metric.sh
@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -euo pipefail
+cp -f "$(dirname "$0")/../inputs/dev-scanners/metric.json" stdin
diff --git a/tests/parity/gen/dev-scanners-matching-dev-pgs-trait.sh b/tests/parity/gen/dev-scanners-matching-dev-pgs-trait.sh
new file mode 100644
index 000000000..c64dc8a89
--- /dev/null
+++ b/tests/parity/gen/dev-scanners-matching-dev-pgs-trait.sh
@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -euo pipefail
+cp -f "$(dirname "$0")/../inputs/dev-scanners/trait.json" stdin
diff --git a/tests/parity/gen/dev-scanners-urls-dev-versions-expand.sh b/tests/parity/gen/dev-scanners-urls-dev-versions-expand.sh
new file mode 100644
index 000000000..9d2b0a4c5
--- /dev/null
+++ b/tests/parity/gen/dev-scanners-urls-dev-versions-expand.sh
@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -euo pipefail
+cp -f "$(dirname "$0")/../inputs/dev-scanners/urls" stdin
diff --git a/tests/parity/gen/dev-scanners.sh b/tests/parity/gen/dev-scanners.sh
new file mode 100644
index 000000000..333acd07f
--- /dev/null
+++ b/tests/parity/gen/dev-scanners.sh
@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+# Fixed subset of the differential fuzz, plus binary and odd-name controls.
+set -euo pipefail
+plant() { printf '%b\n' "${2//\~/}" > "$1"; }
+plant probe.md '́rs123~ AG\nHG0~02́ *1/~*4\nHTT́ 17/~19\nREPCŃ 17/~19\npatİent *1/~*4\npatıent *1/~*4\n/mnt/u~seŕ\nx.ts.~net́'
+plant $'odd\nname.md' '/home/~synthetic/path'
+printf '\377\376' >> probe.md
+printf '%s\n' 'clean' > clean.md
+printf '\0binary' > binary.md
+git init -q
+git add -- probe.md clean.md binary.md $'odd\nname.md'
diff --git a/tests/parity/golden/dev-scan-personal/odd-filename/stdout b/tests/parity/golden/dev-scan-personal/odd-filename/stdout
new file mode 100644
index 000000000..27cc68533
--- /dev/null
+++ b/tests/parity/golden/dev-scan-personal/odd-filename/stdout
@@ -0,0 +1,10 @@
+FAIL home      odd\nname.md:1
+FAIL rsid      probe.md:1
+FAIL diplotype probe.md:2
+FAIL repeat    probe.md:3
+FAIL repeat    probe.md:4
+FAIL diplotype probe.md:5
+FAIL diplotype probe.md:6
+FAIL home      probe.md:7
+FAIL address   probe.md:8
+scanned 3 text files
diff --git a/tests/parity/golden/dev-scan-personal/unicode-fixed-seed/stdout b/tests/parity/golden/dev-scan-personal/unicode-fixed-seed/stdout
new file mode 100644
index 000000000..1dc121f4f
--- /dev/null
+++ b/tests/parity/golden/dev-scan-personal/unicode-fixed-seed/stdout
@@ -0,0 +1,9 @@
+FAIL rsid      probe.md:1
+FAIL diplotype probe.md:2
+FAIL repeat    probe.md:3
+FAIL repeat    probe.md:4
+FAIL diplotype probe.md:5
+FAIL diplotype probe.md:6
+FAIL home      probe.md:7
+FAIL address   probe.md:8
+scanned 1 text files
diff --git a/tests/parity/inputs/dev-scanners/clean.md b/tests/parity/inputs/dev-scanners/clean.md
new file mode 100644
index 000000000..691744b39
--- /dev/null
+++ b/tests/parity/inputs/dev-scanners/clean.md
@@ -0,0 +1 @@
+Documentation without sample results.
diff --git a/tests/parity/inputs/dev-scanners/containers.config b/tests/parity/inputs/dev-scanners/containers.config
new file mode 100644
index 000000000..46eca54a9
--- /dev/null
+++ b/tests/parity/inputs/dev-scanners/containers.config
@@ -0,0 +1 @@
+withName: 'SYNTHETIC' { container = 'example/tool:1.2' }
diff --git a/tests/parity/inputs/dev-scanners/image.md b/tests/parity/inputs/dev-scanners/image.md
new file mode 100644
index 000000000..c6a2c2b81
--- /dev/null
+++ b/tests/parity/inputs/dev-scanners/image.md
@@ -0,0 +1 @@
+Use the configured image variable.
diff --git a/tests/parity/inputs/dev-scanners/metric.json b/tests/parity/inputs/dev-scanners/metric.json
new file mode 100644
index 000000000..ceb4e71bb
--- /dev/null
+++ b/tests/parity/inputs/dev-scanners/metric.json
@@ -0,0 +1 @@
+{"id":"PPM000001","associated_pgs_id":"PGS000001","sampleset":{"samples":[{"ancestry_broad":"European"}]},"performance_metrics":{"effect_sizes":[{"name_short":"OR","estimate":1.5}]}}
diff --git a/tests/parity/inputs/dev-scanners/oracle.sh b/tests/parity/inputs/dev-scanners/oracle.sh
new file mode 100644
index 000000000..ad4039d45
--- /dev/null
+++ b/tests/parity/inputs/dev-scanners/oracle.sh
@@ -0,0 +1,64 @@
+#!/usr/bin/env bash
+# Adapt the deleted shell heredocs to the og argv. Run only by parity.
+set -euo pipefail
+verb=$1 source=$2
+shift 2
+heredoc() {
+  awk -v fn="$1() {" '
+    $0 == fn { scope=1 }
+    scope && /<<\047(PY|EOF)\047/ { body=1; next }
+    body && /^(PY|EOF)$/ { exit }
+    body { print }' "$source"
+}
+inline() {
+  awk -v fn="$1() {" '
+    $0 == fn { scope=1 }
+    scope && /python3 -c \047$/ { body=1; next }
+    body && /^\047/ { exit }
+    body { print }' "$source"
+}
+case "$verb" in
+  personal)
+    root= allow= skip= patterns= cached=
+    while [ "$#" -gt 0 ]; do
+      case "$1" in
+        --root) root=$(cd "$2" && pwd); shift 2 ;;
+        --allow) allow=$2; shift 2 ;;
+        --skip) skip=$2; shift 2 ;;
+        --patterns) patterns=$2; shift 2 ;;
+        --cached) cached=1; shift ;;
+        --) shift; break ;;
+        *) break ;;
+      esac
+    done
+    exec python3 -c "$(heredoc scan)" "$root" "$allow" "$skip" "$patterns" "$cached" "$@" ;;
+  images)
+    root= exempt= pairs=
+    while [ "$#" -gt 0 ]; do
+      case "$1" in
+        --root) root=$(cd "$2" && pwd); shift 2 ;;
+        --exempt-files) exempt=$2; shift 2 ;;
+        --exempt-pairs) pairs=$2; shift 2 ;;
+        *) exit 2 ;;
+      esac
+    done
+    exec python3 -c "$(heredoc scan)" "$root" "$exempt" "$pairs" "$(cat)" ;;
+  coupled) shift; exec python3 -c "$(heredoc coupled)" "$1" ;;
+  check-run) shift; exec python3 -c "$(heredoc check_versions)" "$@" ;;
+  expand) shift; exec python3 -c "$(inline expand_vars)" "$1" ;;
+  trait) shift; export ID=$1; exec python3 -c "$(inline trait_of)" ;;
+  label) exec python3 -c "$(heredoc label_matches)" "$@" ;;
+  metric)
+    while [ "$#" -gt 0 ]; do
+      case "$1" in
+        --id) export ID=$2 ;;
+        --ppm) export PPM=$2 ;;
+        --ancestry) export ANC=$2 ;;
+        --effect) export EFF=$2 ;;
+        *) exit 2 ;;
+      esac
+      shift 2
+    done
+    exec python3 -c "$(inline metric_matches)" ;;
+  *) exit 2 ;;
+esac
diff --git a/tests/parity/inputs/dev-scanners/software_versions.yml b/tests/parity/inputs/dev-scanners/software_versions.yml
new file mode 100644
index 000000000..3f224dbbe
--- /dev/null
+++ b/tests/parity/inputs/dev-scanners/software_versions.yml
@@ -0,0 +1,2 @@
+"SYNTHETIC":
+  tool: 1.2
diff --git a/tests/parity/inputs/dev-scanners/trait.json b/tests/parity/inputs/dev-scanners/trait.json
new file mode 100644
index 000000000..f044fb312
--- /dev/null
+++ b/tests/parity/inputs/dev-scanners/trait.json
@@ -0,0 +1 @@
+{"id":"PGS000001","trait_reported":"Synthetic trait"}
diff --git a/tests/parity/inputs/dev-scanners/urls b/tests/parity/inputs/dev-scanners/urls
new file mode 100644
index 000000000..5e04143f2
--- /dev/null
+++ b/tests/parity/inputs/dev-scanners/urls
@@ -0,0 +1,2 @@
+${TEST_URL}/data.,	fixture.md:1
+$TEST_URL/file}	fixture.md:2
diff --git a/tests/parity/inputs/dev-scanners/versions.env b/tests/parity/inputs/dev-scanners/versions.env
new file mode 100644
index 000000000..50c325fd9
--- /dev/null
+++ b/tests/parity/inputs/dev-scanners/versions.env
@@ -0,0 +1,4 @@
+MINIMAP2_IMAGE="example/minimap2:2.30"
+SAMTOOLS_IMAGE="example/samtools:1.22"
+MINIMAP2_SAMTOOLS_IMAGE="example/combined:abc" # minimap2=2.30,samtools=1.22
+TEST_URL="https://example.org/reference"
diff --git a/tests/parity/oracle.ref b/tests/parity/oracle.ref
index 57c27da2f..4fcffb002 100644
--- a/tests/parity/oracle.ref
+++ b/tests/parity/oracle.ref
@@ -63,3 +63,11 @@ y-yleaf-positions	0baddb45aa3871a57469cf20295bdd832f72f5c0	file:bin/yleaf_run.py
 lookup	0baddb45aa3871a57469cf20295bdd832f72f5c0	file:bin/genome_lookup.py	python3	lookup
 lookup-query	0baddb45aa3871a57469cf20295bdd832f72f5c0	file:bin/genome_lookup.py	bash ./oracle.sh	lookup query
 family-ibd	0baddb45aa3871a57469cf20295bdd832f72f5c0	file:bin/ibd_report.py	sh ./ibd_oracle.sh	family ibd
+dev-scan-personal	4104a93f2121b457413336574b8563fe85291fd7	file:scripts/ci/check-personal-data.sh	bash ./oracle.sh personal	dev scan personal-data
+dev-scan-images	4104a93f2121b457413336574b8563fe85291fd7	file:scripts/ci/check-images.sh	bash ./oracle.sh images	dev scan images
+dev-versions-coupled	4104a93f2121b457413336574b8563fe85291fd7	file:scripts/ci/check-images.sh	bash ./oracle.sh coupled	dev versions coupled
+dev-versions-check-run	4104a93f2121b457413336574b8563fe85291fd7	file:scripts/ci/gen-containers-config.sh	bash ./oracle.sh check-run	dev versions check-run
+dev-versions-expand	4104a93f2121b457413336574b8563fe85291fd7	file:scripts/ci/check-links.sh	bash ./oracle.sh expand	dev versions expand
+dev-pgs-trait	4104a93f2121b457413336574b8563fe85291fd7	file:scripts/ci/check-pgs-labels.sh	bash ./oracle.sh trait	dev pgs trait
+dev-pgs-label	4104a93f2121b457413336574b8563fe85291fd7	file:scripts/ci/check-pgs-labels.sh	bash ./oracle.sh label	dev pgs label-match
+dev-pgs-metric	4104a93f2121b457413336574b8563fe85291fd7	file:scripts/ci/check-pgs-labels.sh	bash ./oracle.sh metric	dev pgs metric-match

From 2d4847e52272405dbbad66e5528da6b7324cc3e8 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 14:44:08 +0100
Subject: [PATCH 29/76] test(ci): retain red scanner controls on the fixed head

---
 .github/workflows/guard.yml             | 21 +++++++
 rust/crates/og-dev/src/lib.rs           |  4 +-
 rust/crates/og-dev/src/personal_data.rs | 82 ++++++++++++-------------
 3 files changed, 64 insertions(+), 43 deletions(-)

diff --git a/.github/workflows/guard.yml b/.github/workflows/guard.yml
index 5c9a5b653..0ce135958 100644
--- a/.github/workflows/guard.yml
+++ b/.github/workflows/guard.yml
@@ -296,6 +296,27 @@ jobs:
       - name: cargo test
         run: cargo test --workspace --locked --no-fail-fast
 
+      # Keep the negative controls executable on the final head. The pinned
+      # test-only commit contains the old scanner and the five regressions.
+      - name: Scanner controls (all five pre-fix differential tests must fail)
+        run: |
+          before=80a675eadf73640c2a0f2d63fcfe30e6fdd0deef
+          git cat-file -e "$before^{commit}" 2>/dev/null || git fetch --quiet --depth=1 origin "$before"
+          source=crates/og-dev/src/personal_data.rs
+          saved="${RUNNER_TEMP}/personal-data-fixed.rs"
+          cp "$source" "$saved"
+          trap 'cp "$saved" "$source"' EXIT
+          git show "$before:rust/$source" > "$source"
+          log="${RUNNER_TEMP}/scanner-red-controls.log"
+          rc=0
+          cargo test -p og-dev --locked --no-fail-fast privacy_ > "$log" 2>&1 || rc=$?
+          cat "$log"
+          [ "$rc" -ne 0 ] || { echo "ERROR: the pre-fix scanner passed"; exit 1; }
+          for test in report_never_contains_values_or_patterns python_boundaries_differential python_casefold_differential staged_newline_differential fixed_seed_differential_fuzz; do
+            grep -E "privacy_${test} .*FAILED" "$log" || { echo "ERROR: missing red control $test"; exit 1; }
+          done
+          echo "Control: all five scanner regressions failed, as they must."
+
       - name: pycompat against CPython (python3 -I in PYTHON_IMAGE, 100000 cases per operation)
         if: ${{ !cancelled() }}   # runs even when a step above failed, so each result shows
         run: |
diff --git a/rust/crates/og-dev/src/lib.rs b/rust/crates/og-dev/src/lib.rs
index 513d81531..dc320e4b9 100644
--- a/rust/crates/og-dev/src/lib.rs
+++ b/rust/crates/og-dev/src/lib.rs
@@ -27,18 +27,18 @@
 //!   `assets/pgs_scores.tsv`.
 
 pub mod contract;
+pub mod helpers;
 pub mod images;
 mod lookaround;
-pub mod helpers;
 pub mod parity;
 pub mod personal_data;
 pub mod pgs;
 pub mod remnants;
 pub mod report_only;
 pub mod schema;
+pub mod shlex;
 pub mod versions;
 pub mod versions_env;
-pub mod shlex;
 mod zip;
 
 use std::io::Write;
diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
index d12033fa6..030cc5d7e 100644
--- a/rust/crates/og-dev/src/personal_data.rs
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -632,49 +632,51 @@ mod tests {
     // Execute the removed scanner itself. Only its reporting is adapted to
     // structured metadata, because printing findings is the bug being fixed.
     fn oracle(f: &Fixture, files: &[&str], cached: bool) -> String {
-        const SHA: &str = "4104a93f2121b457413336574b8563fe85291fd7";
-        let repo = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../..");
-        let read = || {
-            Command::new("git")
-                .arg("-C")
-                .arg(&repo)
-                .args(["show", &format!("{SHA}:scripts/ci/check-personal-data.sh")])
-                .output()
-                .unwrap()
-        };
-        let mut source = read();
-        if !source.status.success() {
-            assert!(
+        static PYTHON: LazyLock<String> = LazyLock::new(|| {
+            const SHA: &str = "4104a93f2121b457413336574b8563fe85291fd7";
+            let repo = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../..");
+            let read = || {
                 Command::new("git")
                     .arg("-C")
                     .arg(&repo)
-                    .args(["fetch", "--quiet", "--depth=1", "origin", SHA])
-                    .status()
+                    .args(["show", &format!("{SHA}:scripts/ci/check-personal-data.sh")])
+                    .output()
                     .unwrap()
-                    .success()
-            );
-            source = read();
-        }
-        assert!(source.status.success());
-        let source = String::from_utf8(source.stdout).unwrap();
-        let python = source
-            .split("<<'PY'\n")
-            .nth(1)
-            .unwrap()
-            .split("\nPY\n")
-            .next()
-            .unwrap();
-        let python = python
-            .replace(
-                "import fnmatch, os, re, subprocess, sys",
-                "import fnmatch, os, re, subprocess, sys, json",
-            )
-            .replace(
-                "print(\"FAIL %-9s %s:%d: %s\" % (kind, rel, n, line.strip()[:160]))",
-                "print(json.dumps([kind, rel, n]))",
-            );
+            };
+            let mut source = read();
+            if !source.status.success() {
+                assert!(
+                    Command::new("git")
+                        .arg("-C")
+                        .arg(&repo)
+                        .args(["fetch", "--quiet", "--depth=1", "origin", SHA])
+                        .status()
+                        .unwrap()
+                        .success()
+                );
+                source = read();
+            }
+            assert!(source.status.success());
+            let source = String::from_utf8(source.stdout).unwrap();
+            let python = source
+                .split("<<'PY'\n")
+                .nth(1)
+                .unwrap()
+                .split("\nPY\n")
+                .next()
+                .unwrap();
+            python
+                .replace(
+                    "import fnmatch, os, re, subprocess, sys",
+                    "import fnmatch, os, re, subprocess, sys, json",
+                )
+                .replace(
+                    "print(\"FAIL %-9s %s:%d: %s\" % (kind, rel, n, line.strip()[:160]))",
+                    "print(json.dumps([kind, rel, n]))",
+                )
+        });
         let mut cmd = Command::new("python3");
-        cmd.args(["-I", "-c", &python])
+        cmd.args(["-I", "-c", &PYTHON])
             .arg(&f.0)
             .args(["", "", "", if cached { "1" } else { "" }]);
         for file in files {
@@ -716,9 +718,7 @@ mod tests {
             // Keep the required report spelling independent of report().
             let finding = format!("FAIL {kind:<9} {}:{n}", rel.escape_debug());
             assert!(
-                reported.iter().any(|l| *l == finding
-                    || l.strip_prefix(&finding)
-                        .is_some_and(|tail| tail.starts_with(": "))),
+                reported.contains(finding.as_str()),
                 "missing oracle finding #{count}"
             );
             count += 1;

From 454720de11d709b3f7d3541a24c37c882e48f35d Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 14:47:04 +0100
Subject: [PATCH 30/76] fix(ci): move trace and smoke readers to Rust

Bead: pgp-bs9u.38
---
 .github/workflows/nextflow.yml                | 133 +-------
 CHANGELOG.md                                  |   2 +
 docs/rust.md                                  |   8 +
 rust/README.md                                |   2 +
 rust/crates/og-dev/src/lib.rs                 |   8 +-
 rust/crates/og-dev/src/nf_trace.rs            | 316 +++++++++++++++++
 rust/crates/og-dev/src/pharmcat.rs            | 126 +++++++
 rust/crates/og-dev/src/smoke.rs               | 322 ++++++++++++++++++
 rust/crates/og-dev/tests/ci_readers.rs        | 294 ++++++++++++++++
 rust/og/src/main.rs                           |   3 +
 scripts/ci/e2e-case-paths.tsv                 |   1 +
 scripts/ci/e2e-case-times.tsv                 |   1 +
 scripts/ci/image-smoke.sh                     | 112 ++----
 scripts/ci/nf-trace-requests.tsv              |  10 +
 scripts/ci/parity-diff.sh                     |  32 +-
 scripts/ci/settle-doubts.sh                   |   7 +-
 tests/e2e/31-pharmcat-07.sh                   |   4 +-
 tests/e2e/60-nextflow.sh                      |   2 +-
 tests/e2e/lib.sh                              |  41 +--
 tests/e2e/nextflow-from-fastq-2-nextflow.sh   |   2 +-
 tests/e2e/pgx-6-gvcf-column.sh                |   2 +-
 tests/e2e/rust-z2e-readers.sh                 |  18 +
 tests/e2e/vendor-vcf-intake-5-docs.sh         |   2 +-
 tests/parity/README.md                        |   2 +
 tests/parity/cases.tsv                        |  16 +
 tests/parity/gen/ci-smoke.sh                  |   4 +
 tests/parity/inputs/ci-readers/attempts.tsv   |   3 +
 tests/parity/inputs/ci-readers/cells.csv      |   4 +
 tests/parity/inputs/ci-readers/empty.json     |   1 +
 tests/parity/inputs/ci-readers/flat.json      |   1 +
 tests/parity/inputs/ci-readers/nested.json    |   1 +
 tests/parity/inputs/ci-readers/oracle.sh      |  34 ++
 tests/parity/inputs/ci-readers/requests.tsv   |  19 ++
 tests/parity/inputs/ci-readers/truncated.json |   1 +
 tests/parity/inputs/ci-readers/want.tsv       |  10 +
 tests/parity/oracle.ref                       |   9 +
 tests/smoke/commands.tsv                      |  20 +-
 37 files changed, 1289 insertions(+), 284 deletions(-)
 create mode 100644 rust/crates/og-dev/src/nf_trace.rs
 create mode 100644 rust/crates/og-dev/src/pharmcat.rs
 create mode 100644 rust/crates/og-dev/src/smoke.rs
 create mode 100644 rust/crates/og-dev/tests/ci_readers.rs
 create mode 100644 scripts/ci/nf-trace-requests.tsv
 create mode 100755 tests/e2e/rust-z2e-readers.sh
 create mode 100755 tests/parity/gen/ci-smoke.sh
 create mode 100644 tests/parity/inputs/ci-readers/attempts.tsv
 create mode 100644 tests/parity/inputs/ci-readers/cells.csv
 create mode 100644 tests/parity/inputs/ci-readers/empty.json
 create mode 100644 tests/parity/inputs/ci-readers/flat.json
 create mode 100644 tests/parity/inputs/ci-readers/nested.json
 create mode 100644 tests/parity/inputs/ci-readers/oracle.sh
 create mode 100644 tests/parity/inputs/ci-readers/requests.tsv
 create mode 100644 tests/parity/inputs/ci-readers/truncated.json
 create mode 100644 tests/parity/inputs/ci-readers/want.tsv

diff --git a/.github/workflows/nextflow.yml b/.github/workflows/nextflow.yml
index 8f5426c6c..d4aaf9022 100644
--- a/.github/workflows/nextflow.yml
+++ b/.github/workflows/nextflow.yml
@@ -119,8 +119,8 @@ jobs:
       - name: Validate nextflow_schema.json and the samplesheet schema
         if: steps.scope.outputs.run == 'true'
         run: |
-          python3 -m json.tool nextflow_schema.json > /dev/null
-          python3 -m json.tool assets/schema_input.json > /dev/null
+          jq empty nextflow_schema.json > /dev/null
+          jq empty assets/schema_input.json > /dev/null
 
       # The stub run below pulls every image of the default tools: the pinned
       # leg ran out of disk in it twice on 2026-11-05 (#300, job 127077180393;
@@ -430,83 +430,10 @@ jobs:
           nextflow run main.nf -profile test_all -stub -ansi-log false -c "${RUNNER_TEMP}/resources.config" \
             --tools vep,manta,cnvpytor,prs --max_cpus 16 --max_memory 64.GB --max_time 48.h \
             --outdir "${RUNNER_TEMP}/resources" -work-dir "${RUNNER_TEMP}/resources-work"
-          python3 - "${RUNNER_TEMP}"/resources/pipeline_info/trace_*.txt "$exec_cpus" "$exec_mem_gb" <<'PY'
-          import csv, sys
-          GB, H = 1024 ** 3, 3600 * 1000
-          exec_cpus, exec_mem = int(sys.argv[2]), int(sys.argv[3]) * GB
-          # process: (cpus, memory, time) of the first attempt
-          want = {
-              'DEEPVARIANT':   (8, 32 * GB, 48 * H),
-              'FASTP':         (8, 8 * GB, 8 * H),
-              'ALIGN_MINIMAP2': (8, 32 * GB, 24 * H),
-              'MANTA':         (8, 16 * GB, 24 * H),
-              'CNVPYTOR':      (4, 8 * GB, 24 * H),
-              'VEP':           (8, 16 * GB, 24 * H),
-              'PRS_PREPARE':   (1, 2 * GB, 2 * H),
-              'PRS_SCORE_SITES': (2, 4 * GB, 4 * H),
-              'PRS':           (4, 24 * GB, 8 * H),
-          }
-          seen, bad = {p: {} for p in want}, 0
-          attempts = all_cpus = all_mem = 0
-          rows = {}
-          with open(sys.argv[1]) as fh:
-              for row in csv.DictReader(fh, delimiter='\t'):
-                  first_row = rows.setdefault(row['task_id'], row)
-                  if first_row is not row:
-                      # The late copy can be built before the exit status was
-                      # set, so it may read '-' there; nothing else may differ.
-                      exits = {first_row['exit'], row['exit']} - {'-'}
-                      if len(exits) > 1 or any(first_row[k] != row[k] for k in row if k != 'exit'):
-                          print(f"FAIL: task {row['task_id']} has two different rows in the trace: {first_row} and {row}")
-                          bad += 1
-                      else:
-                          print(f"{row['name']}: attempt {row['attempt']} is written twice in the trace; counted once")
-                      continue
-                  attempts += 1
-                  all_cpus += int(row['cpus'])
-                  all_mem += int(row['memory'])
-                  proc = row['name'].split(' (')[0].split(':')[-1]
-                  if proc not in want:
-                      continue
-                  got = (int(row['cpus']), int(row['memory']), int(row['time']))
-                  print(f"{row['name']}: attempt {row['attempt']}, exit {row['exit']}, "
-                        f"cpus {got[0]}, memory {got[1] / GB:g} GB, time {got[2] / H:g} h")
-                  seen[proc].setdefault(int(row['attempt']), {}).setdefault(row['name'], []).append(got)
-          for proc, (cpus, mem, time) in want.items():
-              first, second = seen[proc].get(1, {}), seen[proc].get(2, {})
-              unexpected = sorted(set(seen[proc]) - {1, 2})
-              if unexpected:
-                  print(f"FAIL {proc}: attempt(s) {unexpected} in the trace, want only a first attempt and one retry")
-                  bad += 1
-              if not first:
-                  print(f"FAIL {proc}: no first attempt in the trace")
-                  bad += 1
-                  continue
-              for name in sorted(set(first) | set(second)):
-                  n1, n2 = len(first.get(name, [])), len(second.get(name, []))
-                  if n1 != 1 or n2 != 1:
-                      print(f"FAIL {name}: {n1} first and {n2} second attempts in the trace, want one of each")
-                      bad += 1
-              for got in (g for gs in first.values() for g in gs):
-                  if got != (cpus, mem, time):
-                      print(f"FAIL {proc}: first attempt asks for cpus {got[0]}, memory {got[1] / GB:g} GB, "
-                            f"time {got[2] / H:g} h; want {cpus}, {mem / GB:g} GB, {time / H:g} h")
-                      bad += 1
-              for got in (g for gs in second.values() for g in gs):
-                  if got[1] != 2 * mem:
-                      print(f"FAIL {proc}: the retry asks for {got[1] / GB:g} GB, want {2 * mem / GB:g} GB")
-                      bad += 1
-          # Every attempt takes its request once and gives it back once. If
-          # the executor has at least the sum, losing every release still
-          # leaves room for the next task.
-          print(f"{attempts} task attempts ask for {all_cpus} CPUs and {all_mem / GB:g} GB added together; "
-                f"the executor is told it has {exec_cpus} CPUs and {exec_mem / GB:g} GB")
-          if all_cpus > exec_cpus or all_mem > exec_mem:
-              print("FAIL: executor.cpus or executor.memory of this step is below that sum; raise exec_cpus / exec_mem_gb")
-              bad += 1
-          print(f"{bad} failure(s)")
-          sys.exit(1 if bad else 0)
-          PY
+          traces=("${RUNNER_TEMP}"/resources/pipeline_info/trace_*.txt)
+          [ "${#traces[@]}" -eq 1 ] && [ -f "${traces[0]}" ] || { echo "FAIL: expected exactly one resource trace"; exit 2; }
+          rust/target/release/og dev nf-trace requests "${traces[0]}" --want scripts/ci/nf-trace-requests.tsv \
+            --executor-cpus "$exec_cpus" --executor-mem-gb "$exec_mem_gb"
 
       # The step above fakes the kill with beforeScript, so it cannot see how
       # ALIGN_MINIMAP2's own pipe reports one. This runs the module's real
@@ -574,28 +501,8 @@ jobs:
             --max_cpus 16 --max_memory 64.GB --outdir "$t/out" -work-dir "$t/work" || rc=$?
           echo "nextflow exited ${rc}"
           cat "$t/trace.txt"
-          python3 - "$t/trace.txt" "$rc" <<'PY'
-          import csv, sys
-          GB = 1024 ** 3
-          # One row per task_id: the trace can list a finished task twice
-          # (the retry step above says why), and the first row is the one
-          # written when the task completed.
-          # A repeated row must match the first; only its exit may read '-'.
-          rows = {}
-          for r in csv.DictReader(open(sys.argv[1]), delimiter='\t'):
-              first = rows.setdefault(r['task_id'], r)
-              exits = {first['exit'], r['exit']} - {'-'}
-              if len(exits) > 1 or any(first[k] != r[k] for k in r if k != 'exit'):
-                  print(f"FAIL: task {r['task_id']} has two different rows in the trace: {first} and {r}")
-                  sys.exit(1)
-          rows = [r for r in rows.values() if 'ALIGN_MINIMAP2' in r['name']]
-          got = [(int(r['attempt']), r['exit'], int(r['memory']) // GB) for r in rows]
-          want = [(1, '137', 32), (2, '0', 64)]
-          print(f"ALIGN_MINIMAP2 attempts (attempt, exit, GB): {got}; want {want}")
-          ok = sorted(got) == want and sys.argv[2] == '0'
-          print('OK' if ok else 'FAIL: a kill inside the pipe did not reach Nextflow as exit 137 and a retry')
-          sys.exit(0 if ok else 1)
-          PY
+          rust/target/release/og dev nf-trace attempts "$t/trace.txt" --name-glob '*ALIGN_MINIMAP2*' \
+            --want '1:137:32,2:0:64' --nextflow-exit "$rc"
 
       # PRS runs pgsc_calc, a Nextflow pipeline of its own, and gives it the
       # task's memory as --max_memory, the most one pgsc_calc task may have. A
@@ -696,26 +603,10 @@ jobs:
             --max_cpus 16 --max_memory 64.GB --outdir "$t/out" -work-dir "$t/work" || rc=$?
           echo "nextflow exited ${rc}"
           cat "$t/trace.txt"
-          python3 - "$t/trace.txt" "$rc" <<'PY'
-          import csv, sys
-          GB = 1024 ** 3
-          # One row per task_id, as in the ALIGN_MINIMAP2 step above.
-          rows = {}
-          for r in csv.DictReader(open(sys.argv[1]), delimiter='\t'):
-              first = rows.setdefault(r['task_id'], r)
-              exits = {first['exit'], r['exit']} - {'-'}
-              if len(exits) > 1 or any(first[k] != r[k] for k in r if k != 'exit'):
-                  print(f"FAIL: task {r['task_id']} has two different rows in the trace: {first} and {r}")
-                  sys.exit(1)
-          rows = list(rows.values())
-          want, ok = [(1, '137', 24), (2, '0', 48)], sys.argv[2] == '0'
-          for sample in ('sigkill', 'pool'):
-              got = sorted((int(r['attempt']), r['exit'], int(r['memory']) // GB) for r in rows if r['name'] == f'PRS ({sample})')
-              print(f"PRS ({sample}) attempts (attempt, exit, GB): {got}; want {want}")
-              ok = ok and got == want
-          print('OK' if ok else 'FAIL: a memory kill inside pgsc_calc did not reach Nextflow as exit 137 and a retry that passes')
-          sys.exit(0 if ok else 1)
-          PY
+          for sample in sigkill pool; do
+            rust/target/release/og dev nf-trace attempts "$t/trace.txt" --name-glob "PRS ($sample)" \
+              --want '1:137:24,2:0:48' --nextflow-exit "$rc"
+          done
 
       # A Nextflow run that fails, or that its step's timeout cuts, leaves its
       # log in the checkout as .nextflow.log (older runs of the job as
diff --git a/CHANGELOG.md b/CHANGELOG.md
index cd74b71a6..5ba164c75 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,8 @@ Each release's notes. From 1.0.0 on, a major or minor release has hand-written n
 
 ## Unreleased
 
+- CI readers now use `og dev pharmcat diplotypes`, `nf-trace` and `smoke`. Unreadable PharmCAT reports fail with exit 2 and are marked not assessed. Resource checks refuse trace globs and malformed numeric cells. The smoke mini-reference uses a fixed Rust seed for the planted bases. Gzip smoke reads have deterministic headers. Smoke table checks report concise property results.
+
 - The container helpers check (`scripts/ci/check-container-helpers.sh`, Guard job `helper-binaries`) now derives its table with the Rust `og` binary, `og dev helpers`. It replaces the Python inside the script, which is gone; the script keeps the docker probe, the orad download and its self-test. On this tree the table and the rule 1 output are the same, byte for byte. The static run takes 0.01 s and 6 MB where the Python took 0.2 s and 15 MB. What changes:
   - A helper called in a process's `shell:` block is checked too. The Python read only `script:` blocks, so such a call went unchecked. No module has one today.
   - A helper called in a process's `exec:` block always fails the check: Nextflow runs that block on the host, where no image applies.
diff --git a/docs/rust.md b/docs/rust.md
index c2ed48f65..bea0896ec 100644
--- a/docs/rust.md
+++ b/docs/rust.md
@@ -111,3 +111,11 @@ To add a primitive: write it in `pycompat` with unit tests, add an operation to
 - **Release** (`release.yml`): a tag builds the four binaries, writes `SHA256SUMS`, attests them and attaches all five files to the release. A pull request that changes `rust/` or the workflow builds them as a dry run.
 
 [Testing](testing.md) has the rest of CI.
+
+## CI readers
+
+`og dev pharmcat diplotypes REPORT` prints sorted, unique `GENE\tA1/A2` rows from flat or source-nested reports. `--called` prints the called count and names on stderr. `--called-lines` prints one called gene per line for e2e checks. An unreadable report exits 2 without a count. A valid empty report succeeds with a zero count.
+
+`og dev nf-trace requests TRACE --want FILE --executor-cpus N --executor-mem-gb N` checks initial requests, doubled retry memory and the executor budget. The expectation table is [nf-trace-requests.tsv](../scripts/ci/nf-trace-requests.tsv). `og dev nf-trace attempts TRACE --name-glob PATTERN --want '1:137:32,2:0:64' --nextflow-exit RC` checks a retry sequence. Both accept one explicit path, refuse globs, parse quoted TSV records and reject conflicting duplicates. Identical duplicate task IDs count once. Exit 1 means the check found a mismatch. Exit 2 means input or arguments could not be assessed.
+
+`og dev smoke` supplies `mini-ref SRC ORIG MINI POS LEN`, `long-reads HAP1 HAP2 OUT.gz`, `eh-catalog REF OUT END`, `csv-cell FILE KEY=VALUE[,KEY=VALUE] COLUMN` and `check KIND FILE`. Check kinds are `hap-ibd`, `ibdmix`, `rfmix`, `eigen` and `parascopy`. Mini-reference bases use a fixed Rust seed. Long-read gzip headers are deterministic. These synthetic fixtures do not change pipeline output files. Smoke references are limited to 1,003,000 bases. CSV lookups and table checks read one record at a time.
diff --git a/rust/README.md b/rust/README.md
index 394e83e10..40089ce54 100644
--- a/rust/README.md
+++ b/rust/README.md
@@ -34,3 +34,5 @@ cargo build --release && ../tests/rust/pycompat-diff.sh target/release/og   # py
 ```
 
 A binary from a plain `cargo build` is stamped `unknown`, and `rust/og.sh check` refuses it: only `scripts/setup.sh --og` stamps the tree hash the pipeline checks.
+
+CI readers also run through `og dev pharmcat diplotypes`, `og dev nf-trace requests|attempts` and `og dev smoke`. See [the Rust command notes](../docs/rust.md#ci-readers).
diff --git a/rust/crates/og-dev/src/lib.rs b/rust/crates/og-dev/src/lib.rs
index 49938910c..1222b0f2e 100644
--- a/rust/crates/og-dev/src/lib.rs
+++ b/rust/crates/og-dev/src/lib.rs
@@ -18,16 +18,19 @@
 
 pub mod contract;
 pub mod helpers;
+pub mod nf_trace;
 pub mod parity;
+pub mod pharmcat;
 pub mod remnants;
 pub mod report_only;
 pub mod schema;
 pub mod shlex;
+pub mod smoke;
 mod zip;
 
 use std::io::Write;
 
-const USAGE: &str = "usage: og dev parity-compare KIND ORACLE NEW\n       og dev parity-compare --self-test\n       og dev contract --static [--repo DIR] [--contract FILE]\n       og dev contract --outputs DIR --leg bash|nextflow --sample S [--observe]\n       og dev schema SCHEMA.json DOC.json\n       og dev report-only [--repo DIR]\n       og dev remnants [--list FILE] [--root DIR]\n       og dev helpers --list|--static|--images|--orad-calls [--root DIR]\n       og dev helpers --orad --help-file FILE [--orad-version V] [--root DIR]\n";
+const USAGE: &str = "usage: og dev parity-compare KIND ORACLE NEW\n       og dev parity-compare --self-test\n       og dev contract --static [--repo DIR] [--contract FILE]\n       og dev contract --outputs DIR --leg bash|nextflow --sample S [--observe]\n       og dev schema SCHEMA.json DOC.json\n       og dev report-only [--repo DIR]\n       og dev remnants [--list FILE] [--root DIR]\n       og dev pharmcat diplotypes REPORT [--called|--called-lines]\n       og dev nf-trace requests|attempts TRACE [options]\n       og dev smoke mini-ref|long-reads|eh-catalog|csv-cell|check [args]\n       og dev helpers --list|--static|--images|--orad-calls [--root DIR]\n       og dev helpers --orad --help-file FILE [--orad-version V] [--root DIR]\n";
 
 /// Python's `str(OSError)`: `[Errno 2] No such file or directory: 'path'`.
 pub(crate) fn py_os_error(e: &std::io::Error, path: &str) -> String {
@@ -62,6 +65,9 @@ pub fn main(args: &[String]) -> u8 {
         Some("contract") => run(contract::cli, &args[1..]),
         Some("schema") => run(schema::cli, &args[1..]),
         Some("report-only") => run(report_only::cli, &args[1..]),
+        Some("pharmcat") => run(pharmcat::cli, &args[1..]),
+        Some("nf-trace") => run(nf_trace::cli, &args[1..]),
+        Some("smoke") => run(smoke::cli, &args[1..]),
         Some("helpers") => run(helpers::cli, &args[1..]),
         Some("-h" | "--help") => {
             print!("{USAGE}");
diff --git a/rust/crates/og-dev/src/nf_trace.rs b/rust/crates/og-dev/src/nf_trace.rs
new file mode 100644
index 000000000..ac9441b72
--- /dev/null
+++ b/rust/crates/og-dev/src/nf_trace.rs
@@ -0,0 +1,316 @@
+//! Strict checks over raw Nextflow traces. Only one explicit trace path is accepted.
+use pycompat::csv::{Quoting, Reader};
+use std::collections::{BTreeMap, BTreeSet};
+use std::io::Write;
+
+const GB: u64 = 1 << 30;
+const H: u64 = 3_600_000;
+type Record = BTreeMap<String, String>;
+
+fn records(path: &str, mut f: impl FnMut(Record) -> Result<(), String>) -> Result<(), String> {
+    if path.contains(['*', '?', '[', ']']) {
+        return Err("trace glob refused: pass exactly one explicit trace path".into());
+    }
+    let lines = super::smoke::csv_lines(path)?;
+    let mut csv = Reader::new(lines, '\t', Quoting::Minimal);
+    let header = csv
+        .next()
+        .ok_or("no trace header")?
+        .map_err(|e| e.to_string())?;
+    for row in csv {
+        let row = row.map_err(|e| e.to_string())?;
+        if row.is_empty() {
+            continue;
+        }
+        if row.len() != header.len() {
+            return Err(format!("{path}: row width does not match header"));
+        }
+        f(header.iter().cloned().zip(row).collect())?;
+    }
+    Ok(())
+}
+fn cell<'a>(r: &'a Record, k: &str) -> Result<&'a str, String> {
+    r.get(k)
+        .map(String::as_str)
+        .ok_or_else(|| format!("missing column {k}"))
+}
+fn num(r: &Record, k: &str) -> Result<u64, String> {
+    cell(r, k)?
+        .parse()
+        .map_err(|_| format!("column {k} is not an unsigned integer"))
+}
+fn traces(path: &str, out: &mut dyn Write) -> Result<Vec<Record>, String> {
+    let mut rows: Vec<Record> = Vec::new();
+    let mut ids = BTreeMap::new();
+    records(path, |r| {
+        let id = cell(&r, "task_id")?.to_owned();
+        if let Some(&i) = ids.get(&id) {
+            let first: &Record = &rows[i];
+            let a = cell(first, "exit")?;
+            let b = cell(&r, "exit")?;
+            if (a != "-" && b != "-" && a != b)
+                || r.iter()
+                    .any(|(k, v)| k != "exit" && first.get(k) != Some(v))
+            {
+                return Err(format!("task {id} has two different rows in the trace"));
+            }
+            writeln!(
+                out,
+                "{}: attempt {} is written twice in the trace; counted once",
+                cell(&r, "name")?,
+                cell(&r, "attempt")?
+            )
+            .map_err(|e| e.to_string())?;
+        } else {
+            ids.insert(id, rows.len());
+            rows.push(r);
+        }
+        Ok(())
+    })?;
+    if rows.is_empty() {
+        return Err("no trace rows".into());
+    }
+    Ok(rows)
+}
+fn options(args: &[String]) -> Result<BTreeMap<&str, &str>, String> {
+    if !args.len().is_multiple_of(2) {
+        return Err("expected named option and value; pass exactly one trace path".into());
+    }
+    let mut opts = BTreeMap::new();
+    for pair in args.as_chunks::<2>().0 {
+        if !pair[0].starts_with("--") || opts.insert(pair[0].as_str(), pair[1].as_str()).is_some() {
+            return Err("unexpected or repeated argument".into());
+        }
+    }
+    Ok(opts)
+}
+fn opt<'a>(opts: &BTreeMap<&str, &'a str>, key: &str) -> Result<&'a str, String> {
+    opts.get(key)
+        .copied()
+        .ok_or_else(|| format!("{key} is required"))
+}
+fn glob(pattern: &str, text: &str) -> bool {
+    // Escaping makes punctuation literal. Only '*' and '?' have glob meaning.
+    let re = regex::escape(pattern)
+        .replace("\\*", ".*")
+        .replace("\\?", ".");
+    regex::Regex::new(&format!("(?s)^{re}$")).is_ok_and(|r| r.is_match(text))
+}
+fn attempts(path: &str, opts: &BTreeMap<&str, &str>, out: &mut dyn Write) -> Result<bool, String> {
+    for k in opts.keys() {
+        if !["--name-glob", "--want", "--nextflow-exit"].contains(k) {
+            return Err(format!("unknown option {k}"));
+        }
+    }
+    let pattern = opt(opts, "--name-glob")?;
+    let want: Vec<(u64, String, u64)> = opt(opts, "--want")?
+        .split(',')
+        .map(|t| {
+            let parts: Vec<_> = t.split(':').collect();
+            if parts.len() != 3 {
+                return Err("--want must be attempt:exit:GB,...".into());
+            }
+            Ok((
+                parts[0].parse().map_err(|_| "bad attempt")?,
+                parts[1].to_owned(),
+                parts[2].parse().map_err(|_| "bad memory")?,
+            ))
+        })
+        .collect::<Result<_, String>>()?;
+    let mut got = Vec::new();
+    for r in traces(path, out)? {
+        if glob(pattern, cell(&r, "name")?) {
+            got.push((
+                num(&r, "attempt")?,
+                cell(&r, "exit")?.to_owned(),
+                num(&r, "memory")? / GB,
+            ));
+        }
+    }
+    got.sort();
+    let tuples = |xs: &[(u64, String, u64)]| {
+        format!(
+            "[{}]",
+            xs.iter()
+                .map(|(a, e, m)| format!("({a}, '{e}', {m})"))
+                .collect::<Vec<_>>()
+                .join(", ")
+        )
+    };
+    let label = if pattern.contains("ALIGN_MINIMAP2") {
+        "ALIGN_MINIMAP2"
+    } else {
+        pattern
+    };
+    writeln!(
+        out,
+        "{label} attempts (attempt, exit, GB): {}; want {}",
+        tuples(&got),
+        tuples(&want)
+    )
+    .map_err(|e| e.to_string())?;
+    let ok = got == want && opt(opts, "--nextflow-exit")? == "0";
+    writeln!(
+        out,
+        "{}",
+        if ok {
+            "OK"
+        } else {
+            "FAIL: a memory kill did not reach Nextflow as exit 137 and a retry that passes"
+        }
+    )
+    .map_err(|e| e.to_string())?;
+    Ok(ok)
+}
+fn requests(path: &str, opts: &BTreeMap<&str, &str>, out: &mut dyn Write) -> Result<bool, String> {
+    for k in opts.keys() {
+        if !["--want", "--executor-cpus", "--executor-mem-gb"].contains(k) {
+            return Err(format!("unknown option {k}"));
+        }
+    }
+    let mut want = BTreeMap::new();
+    records(opt(opts, "--want")?, |r| {
+        let name = cell(&r, "process")?.to_owned();
+        let v = (
+            num(&r, "cpus")?,
+            num(&r, "memory_gb")?
+                .checked_mul(GB)
+                .ok_or("memory overflow")?,
+            num(&r, "time_h")?.checked_mul(H).ok_or("time overflow")?,
+        );
+        if want.insert(name, v).is_some() {
+            return Err("duplicate process in --want".into());
+        }
+        Ok(())
+    })?;
+    if want.is_empty() {
+        return Err("empty request expectations".into());
+    }
+    let rows = traces(path, out)?;
+    type Seen<'a> = BTreeMap<&'a str, BTreeMap<u64, BTreeMap<&'a str, Vec<(u64, u64, u64)>>>>;
+    let mut seen: Seen<'_> = BTreeMap::new();
+    let mut all_cpus = 0u64;
+    let mut all_mem = 0u64;
+    let mut bad = 0;
+    for r in &rows {
+        let cpus = num(r, "cpus")?;
+        let mem = num(r, "memory")?;
+        all_cpus = all_cpus.checked_add(cpus).ok_or("CPU sum overflow")?;
+        all_mem = all_mem.checked_add(mem).ok_or("memory sum overflow")?;
+        let name = cell(r, "name")?;
+        let proc = name
+            .split(" (")
+            .next()
+            .unwrap_or(name)
+            .rsplit(':')
+            .next()
+            .unwrap_or(name);
+        if !want.contains_key(proc) {
+            continue;
+        }
+        let attempt = num(r, "attempt")?;
+        let time = num(r, "time")?;
+        writeln!(
+            out,
+            "{name}: attempt {attempt}, exit {}, cpus {cpus}, memory {} GB, time {} h",
+            cell(r, "exit")?,
+            mem / GB,
+            time / H
+        )
+        .map_err(|e| e.to_string())?;
+        seen.entry(proc)
+            .or_default()
+            .entry(attempt)
+            .or_default()
+            .entry(name)
+            .or_default()
+            .push((cpus, mem, time));
+    }
+    for (proc, &expected) in &want {
+        let attempts = seen.get(proc.as_str());
+        if attempts.is_some_and(|a| a.keys().any(|k| ![1, 2].contains(k))) {
+            writeln!(out, "FAIL {proc}: want only a first attempt and one retry")
+                .map_err(|e| e.to_string())?;
+            bad += 1;
+        }
+        let first = attempts.and_then(|a| a.get(&1));
+        let second = attempts.and_then(|a| a.get(&2));
+        if first.is_none_or(|a| a.is_empty()) {
+            writeln!(out, "FAIL {proc}: no first attempt in the trace")
+                .map_err(|e| e.to_string())?;
+            bad += 1;
+            continue;
+        }
+        let names: BTreeSet<_> = first
+            .into_iter()
+            .chain(second)
+            .flat_map(|a| a.keys())
+            .collect();
+        for name in names {
+            let a = first.and_then(|a| a.get(name)).map_or(0, Vec::len);
+            let b = second.and_then(|a| a.get(name)).map_or(0, Vec::len);
+            if a != 1 || b != 1 {
+                writeln!(
+                    out,
+                    "FAIL {name}: {a} first and {b} second attempts in the trace, want one of each"
+                )
+                .map_err(|e| e.to_string())?;
+                bad += 1;
+            }
+        }
+        for got in first.into_iter().flat_map(|a| a.values()).flatten() {
+            if *got != expected {
+                writeln!(out,"FAIL {proc}: first attempt asks for cpus {}, memory {} GB, time {} h; want {}, {} GB, {} h",got.0,got.1/GB,got.2/H,expected.0,expected.1/GB,expected.2/H).map_err(|e| e.to_string())?;
+                bad += 1;
+            }
+        }
+        for got in second.into_iter().flat_map(|a| a.values()).flatten() {
+            if Some(got.1) != expected.1.checked_mul(2) {
+                writeln!(
+                    out,
+                    "FAIL {proc}: the retry asks for {} GB, want {} GB",
+                    got.1 / GB,
+                    expected.1 / GB * 2
+                )
+                .map_err(|e| e.to_string())?;
+                bad += 1;
+            }
+        }
+    }
+    let cpus: u64 = opt(opts, "--executor-cpus")?
+        .parse()
+        .map_err(|_| "invalid executor CPUs")?;
+    let mem: u64 = opt(opts, "--executor-mem-gb")?
+        .parse()
+        .map_err(|_| "invalid executor memory")?;
+    writeln!(out,"{} task attempts ask for {all_cpus} CPUs and {} GB added together; the executor is told it has {cpus} CPUs and {mem} GB",rows.len(),all_mem/GB).map_err(|e| e.to_string())?;
+    if all_cpus > cpus || Some(all_mem) > mem.checked_mul(GB) {
+        writeln!(out,"FAIL: executor.cpus or executor.memory of this step is below that sum; raise exec_cpus / exec_mem_gb").map_err(|e| e.to_string())?;
+        bad += 1;
+    }
+    writeln!(out, "{bad} failure(s)").map_err(|e| e.to_string())?;
+    Ok(bad == 0)
+}
+
+/// Checks `requests TRACE ...` or `attempts TRACE ...`.
+pub fn cli(args: &[String], out: &mut dyn Write, err: &mut dyn Write) -> u8 {
+    let result = (|| {
+        if args.len() < 2 {
+            return Err("usage: og dev nf-trace requests|attempts TRACE [options]".into());
+        }
+        let opts = options(&args[2..])?;
+        match args[0].as_str() {
+            "requests" => requests(&args[1], &opts, out),
+            "attempts" => attempts(&args[1], &opts, out),
+            _ => Err("unknown nf-trace verb".into()),
+        }
+    })();
+    match result {
+        Ok(true) => 0,
+        Ok(false) => 1,
+        Err(e) => {
+            let _ = writeln!(err, "FAIL: {e}");
+            2
+        }
+    }
+}
diff --git a/rust/crates/og-dev/src/pharmcat.rs b/rust/crates/og-dev/src/pharmcat.rs
new file mode 100644
index 000000000..10301dc3d
--- /dev/null
+++ b/rust/crates/og-dev/src/pharmcat.rs
@@ -0,0 +1,126 @@
+//! The single reader of PharmCAT's flat and source-nested gene maps.
+use pycompat::json::{self, Value};
+use std::collections::BTreeSet;
+use std::io::Write;
+
+trait Get {
+    fn get(&self, key: &str) -> Option<&Value>;
+}
+impl Get for Value {
+    fn get(&self, key: &str) -> Option<&Value> {
+        if let Value::Object(o) = self {
+            o.get(key)
+        } else {
+            None
+        }
+    }
+}
+
+fn diplotypes(g: &Value) -> Result<&[Value], String> {
+    let empty = &[][..];
+    let pick = ["sourceDiplotypes", "recommendationDiplotypes"]
+        .into_iter()
+        .filter_map(|k| g.get(k))
+        .find(|v| pycompat::value::truthy(v));
+    match pick {
+        None => Ok(empty),
+        Some(Value::Array(a)) => Ok(a),
+        _ => Err("diplotypes must be an array".into()),
+    }
+}
+
+/// All diplotypes and the genes with a named allele. Invalid structure is
+/// unassessed, just like invalid JSON, and cannot produce an empty success.
+pub fn read(data: &Value) -> Result<(BTreeSet<String>, BTreeSet<String>), String> {
+    let Value::Object(root) = data else {
+        return Err("report must be an object".into());
+    };
+    let mut rows = BTreeSet::new();
+    let mut called = BTreeSet::new();
+    let mut gene = |name: &str, g: &Value| -> Result<(), String> {
+        for d in diplotypes(g)? {
+            if !matches!(d, Value::Object(_)) {
+                return Err("diplotype must be an object".into());
+            }
+            let mut names = Vec::with_capacity(2);
+            for a in ["allele1", "allele2"] {
+                let n = match d.get(a) {
+                    None | Some(Value::Null) => "",
+                    Some(Value::Object(o)) => match o.get("name") {
+                        None | Some(Value::Null) => "",
+                        Some(Value::Str(s)) => s,
+                        _ => return Err("allele name must be a string".into()),
+                    },
+                    _ => return Err("allele must be an object".into()),
+                };
+                names.push(n);
+            }
+            rows.insert(format!("{name}\t{}", names.join("/")));
+            if names.iter().any(|n| {
+                !n.is_empty() && !["unknown", "none", "?"].contains(&n.to_lowercase().as_str())
+            }) {
+                called.insert(name.to_owned());
+            }
+        }
+        Ok(())
+    };
+    match root.get("genes") {
+        None | Some(Value::Null) => {}
+        Some(Value::Object(genes)) => {
+            for (key, val) in genes {
+                let Value::Object(map) = val else { continue };
+                if map.contains_key("sourceDiplotypes")
+                    || map.contains_key("recommendationDiplotypes")
+                {
+                    gene(key, val)?;
+                } else {
+                    for (name, g) in map {
+                        if matches!(g, Value::Object(_)) {
+                            gene(name, g)?;
+                        }
+                    }
+                }
+            }
+        }
+        _ => return Err("genes must be an object".into()),
+    }
+    Ok((rows, called))
+}
+
+/// `og dev pharmcat diplotypes REPORT [--called|--called-lines]`.
+pub fn cli(args: &[String], out: &mut dyn Write, err: &mut dyn Write) -> u8 {
+    let valid = args.first().is_some_and(|s| s == "diplotypes")
+        && (args.len() == 2
+            || (args.len() == 3 && ["--called", "--called-lines"].contains(&args[2].as_str())));
+    if !valid {
+        let _ = writeln!(
+            err,
+            "usage: og dev pharmcat diplotypes REPORT [--called|--called-lines]"
+        );
+        return 2;
+    }
+    let result = std::fs::read_to_string(&args[1])
+        .map_err(|e| e.to_string())
+        .and_then(|s| json::loads(&s).map_err(|e| e.to_string()))
+        .and_then(|v| read(&v));
+    let (rows, called) = match result {
+        Ok(r) => r,
+        Err(e) => {
+            let _ = writeln!(err, "unreadable report: {e}");
+            return 2;
+        }
+    };
+    let result = match args.get(2).map(String::as_str) {
+        Some("--called") => writeln!(
+            err,
+            "{}",
+            called.iter().cloned().collect::<Vec<_>>().join(" ")
+        )
+        .and_then(|()| writeln!(out, "{}", called.len())),
+        Some("--called-lines") => {
+            writeln!(out, "{}", called.into_iter().collect::<Vec<_>>().join("\n"))
+        }
+        _ => writeln!(out, "{}", rows.into_iter().collect::<Vec<_>>().join("\n")),
+    };
+    if result.is_ok() { 0 } else { 2 }
+}
diff --git a/rust/crates/og-dev/src/smoke.rs b/rust/crates/og-dev/src/smoke.rs
new file mode 100644
index 000000000..41d2c80b8
--- /dev/null
+++ b/rust/crates/og-dev/src/smoke.rs
@@ -0,0 +1,322 @@
+//! Small, local smoke fixtures and table checks. No subprocess or network.
+use og_io::{AtomicFile, Lines, Utf8};
+use pycompat::csv::{DictReader, Quoting};
+use std::io::Write;
+
+fn lines(path: &str) -> Result<Lines<Box<dyn std::io::BufRead>>, String> {
+    Ok(Lines::new(
+        og_io::open(path).map_err(|e| format!("{path}: {e}"))?,
+        Utf8::Strict,
+    ))
+}
+pub(crate) fn csv_lines(
+    path: &str,
+) -> Result<impl Iterator<Item = std::io::Result<String>>, String> {
+    let mut input = lines(path)?;
+    Ok(std::iter::from_fn(move || {
+        let mut line = String::new();
+        match input.read_line(&mut line) {
+            Ok(true) => Some(Ok(line)),
+            Ok(false) => None,
+            Err(e) => Some(Err(e)),
+        }
+    }))
+}
+fn fasta(path: &str) -> Result<Vec<u8>, String> {
+    let mut seq = Vec::new();
+    for line in lines(path)? {
+        let line = line.map_err(|e| e.to_string())?;
+        if !line.starts_with('>') {
+            seq.extend(line.trim().bytes().map(|b| b.to_ascii_uppercase()));
+        }
+    }
+    if seq.len() > 1_003_000 {
+        return Err("smoke reference exceeds 1003000 bases".into());
+    }
+    if !seq.is_ascii() {
+        return Err("FASTA sequence is not ASCII".into());
+    }
+    Ok(seq)
+}
+fn write_fasta(path: &str, seq: &[u8]) -> Result<(), String> {
+    let mut out = AtomicFile::create(path).map_err(|e| e.to_string())?;
+    out.write_all(b">chr20\n").map_err(|e| e.to_string())?;
+    for chunk in seq.chunks(60) {
+        out.write_all(chunk)
+            .and_then(|()| out.write_all(b"\n"))
+            .map_err(|e| e.to_string())?;
+    }
+    out.commit().map_err(|e| e.to_string())
+}
+fn number(s: &str) -> Result<usize, String> {
+    s.parse().map_err(|_| format!("invalid integer: {s}"))
+}
+fn mini(args: &[String]) -> Result<(), String> {
+    if args.len() != 5 {
+        return Err("mini-ref SRC ORIG MINI POS LEN".into());
+    }
+    let mut seq = fasta(&args[0])?;
+    if seq.len() != 500_000 {
+        return Err(format!("mini-ref needs 500000 bases, got {}", seq.len()));
+    }
+    let pos = number(&args[3])?;
+    let n = number(&args[4])?;
+    if pos > seq.len() || n > 1_000_000 {
+        return Err("plant outside bounded mini reference".into());
+    }
+    write_fasta(&args[1], &seq)?;
+    // Stable, portable xorshift64 seed. These bases are deliberately independent
+    // of CPython's RNG. They only create a deletion in reads of the original.
+    let mut state = 20u64;
+    let insert = (0..n).map(|_| {
+        state ^= state << 13;
+        state ^= state >> 7;
+        state ^= state << 17;
+        b"ACGT"[(state & 3) as usize]
+    });
+    seq.splice(pos..pos, insert);
+    write_fasta(&args[2], &seq)
+}
+fn long_reads(args: &[String], stdout: &mut dyn Write) -> Result<(), String> {
+    if args.len() != 3 {
+        return Err("long-reads HAP1 HAP2 OUT.gz".into());
+    }
+    let mut out = AtomicFile::create(&args[2]).map_err(|e| e.to_string())?;
+    let mut gz = flate2::GzBuilder::new()
+        .mtime(0)
+        .write(&mut out, flate2::Compression::default());
+    let mut k = 0;
+    for (h, path) in args[..2].iter().enumerate() {
+        let seq = fasta(path)?;
+        if seq.len() < 10000 {
+            continue;
+        }
+        for start in (0..=seq.len() - 10000).step_by(1000) {
+            let mut r = seq[start..start + 10000].to_vec();
+            if k % 2 == 1 {
+                r.reverse();
+                for b in &mut r {
+                    *b = match b {
+                        b'A' => b'T',
+                        b'C' => b'G',
+                        b'G' => b'C',
+                        b'T' => b'A',
+                        _ => *b,
+                    };
+                }
+            }
+            writeln!(gz, "@hap{}_{start}", h + 1)
+                .and_then(|()| gz.write_all(&r))
+                .and_then(|()| gz.write_all(b"\n+\n"))
+                .and_then(|()| gz.write_all(&[b'?'; 10000]))
+                .and_then(|()| gz.write_all(b"\n"))
+                .map_err(|e| e.to_string())?;
+            k += 1;
+        }
+    }
+    gz.finish().map_err(|e| e.to_string())?;
+    out.commit().map_err(|e| e.to_string())?;
+    writeln!(stdout, "{k} reads").map_err(|e| e.to_string())
+}
+fn catalog(args: &[String], stdout: &mut dyn Write) -> Result<(), String> {
+    if args.len() != 3 {
+        return Err("eh-catalog REF OUT END".into());
+    }
+    let seq = fasta(&args[0])?;
+    let end = number(&args[2])?;
+    let re = regex::bytes::Regex::new("(?:CA){12,}").expect("constant regex");
+    let m = re
+        .find_iter(&seq)
+        .find(|m| m.start() > 20000 && m.end().checked_add(20000).is_some_and(|n| n < end))
+        .ok_or("no suitable CA repeat")?;
+    let data = format!(
+        "[\n {{\n  \"LocusId\": \"SMOKE1\",\n  \"LocusStructure\": \"(CA)*\",\n  \"ReferenceRegion\": \"chr20:{}-{}\",\n  \"VariantType\": \"Repeat\"\n }}\n]",
+        m.start(),
+        m.end()
+    );
+    let mut out = AtomicFile::create(&args[1]).map_err(|e| e.to_string())?;
+    out.write_all(data.as_bytes()).map_err(|e| e.to_string())?;
+    out.commit().map_err(|e| e.to_string())?;
+    writeln!(
+        stdout,
+        "repeat {} {} {} units",
+        m.start(),
+        m.end(),
+        m.len() / 2
+    )
+    .map_err(|e| e.to_string())
+}
+fn csv_cell(args: &[String], out: &mut dyn Write) -> Result<(), String> {
+    if args.len() != 3 {
+        return Err("csv-cell FILE KEY=VALUE[,KEY=VALUE] COLUMN".into());
+    }
+    let want = args[1]
+        .split(',')
+        .map(|kv| kv.split_once('=').ok_or("expected KEY=VALUE"))
+        .collect::<Result<Vec<_>, _>>()?;
+    for row in DictReader::new(csv_lines(&args[0])?, ',', Quoting::Minimal) {
+        let row = row.map_err(|e| e.to_string())?;
+        if want.iter().all(|(k, v)| row.get(k) == Some(Some(v))) {
+            let val = row.get(&args[2]).flatten().ok_or("missing CSV column")?;
+            writeln!(out, "{val}").map_err(|e| e.to_string())?;
+            break;
+        }
+    }
+    Ok(())
+}
+fn fields(line: &str) -> Vec<&str> {
+    line.split_whitespace().collect()
+}
+fn float(s: Option<&&str>) -> Result<f64, String> {
+    pycompat::num::parse_float(s.ok_or("short table row")?).map_err(|e| e.to_string())
+}
+fn check(kind: &str, path: &str, out: &mut dyn Write) -> Result<bool, String> {
+    // The windows keep only their first covering row, matching Python's next().
+    let mut n = 0;
+    let mut ab = 0;
+    let mut ab_len = 0.;
+    let mut coverage = 0.;
+    let mut outside = 0;
+    let mut groups = [Vec::new(), Vec::new(), Vec::new()];
+    let mut codes = std::collections::BTreeMap::new();
+    let mut at = [None, None];
+    let mut aggregate = false;
+    for (i, line) in lines(path)?.enumerate() {
+        let line = line.map_err(|e| e.to_string())?;
+        let r = fields(&line);
+        match kind {
+            "hap-ibd" => {
+                if r.len() < 8 {
+                    return Err("short hap-ibd row".into());
+                }
+                n += 1;
+                if (r[0] == "A" && r[2] == "B") || (r[0] == "B" && r[2] == "A") {
+                    ab += 1;
+                    ab_len = float(r.get(7))?;
+                }
+            }
+            "ibdmix" => {
+                if i == 0 {
+                    continue;
+                }
+                if r.first() == Some(&"S")
+                    && float(r.get(4))? >= 4.
+                    && float(r.get(3))? - float(r.get(2))? >= 50000.
+                {
+                    let a = float(r.get(2))?;
+                    let b = float(r.get(3))?;
+                    n += 1;
+                    coverage += (b.min(2600000.) - a.max(2000000.)).max(0.);
+                    if b <= 2000000. || a >= 2600000. {
+                        outside += 1;
+                    }
+                }
+            }
+            "eigen" => {
+                if line.trim_start().starts_with('#') || r.is_empty() {
+                    continue;
+                }
+                let g = match r.last() {
+                    Some(&"PopA") => 0,
+                    Some(&"PopB") => 1,
+                    Some(&"Proj") => 2,
+                    _ => continue,
+                };
+                groups[g].push(float(r.get(1))?);
+            }
+            "rfmix" => {
+                if i == 0 {
+                    for pair in line
+                        .split_once(':')
+                        .ok_or("missing population codes")?
+                        .1
+                        .split_whitespace()
+                    {
+                        let (k, v) = pair.split_once('=').ok_or("bad population code")?;
+                        codes.insert(k.to_owned(), v.to_owned());
+                    }
+                }
+                if line.starts_with('#') {
+                    continue;
+                }
+                let a = float(r.get(1))?;
+                let b = float(r.get(2))?;
+                n += 1;
+                for (j, p) in [5000000., 15000000.].iter().enumerate() {
+                    if at[j].is_none() && a <= *p && *p < b {
+                        at[j] = Some([
+                            r.get(6).ok_or("short RFMix row")?.to_string(),
+                            r.get(7).ok_or("short RFMix row")?.to_string(),
+                        ]);
+                    }
+                }
+            }
+            "parascopy" => {
+                if r.is_empty() || r[0].starts_with('#') {
+                    continue;
+                }
+                if r.len() < 8 {
+                    return Err("short Parascopy row".into());
+                }
+                aggregate |=
+                    r[0] == "chr5" && !["", "*"].contains(&r[6]) && !["", "*"].contains(&r[7]);
+                n += 1;
+            }
+            _ => return Err(format!("unknown smoke check {kind}")),
+        }
+    }
+    let ok = match kind {
+        "hap-ibd" => n == 1 && ab == 1 && (8. ..=11.).contains(&ab_len),
+        "ibdmix" => coverage >= 540000. && outside == 0,
+        "eigen" => {
+            if groups.iter().any(Vec::is_empty) {
+                return Err("missing PCA group".into());
+            }
+            let a = &groups[0];
+            let b = &groups[1];
+            let p = groups[2][0];
+            let ma = pycompat::num::sum(a.iter().copied()) / a.len() as f64;
+            let mb = pycompat::num::sum(b.iter().copied()) / b.len() as f64;
+            (a.iter().copied().fold(f64::NEG_INFINITY, f64::max)
+                < b.iter().copied().fold(f64::INFINITY, f64::min)
+                || a.iter().copied().fold(f64::INFINITY, f64::min)
+                    > b.iter().copied().fold(f64::NEG_INFINITY, f64::max))
+                && (p - ma).abs() < (p - mb).abs()
+        }
+        "rfmix" => ["POPA", "POPB"].iter().enumerate().all(|(i, p)| {
+            codes
+                .get(*p)
+                .is_some_and(|c| at[i].as_ref() == Some(&[c.clone(), c.clone()]))
+        }),
+        "parascopy" => aggregate,
+        _ => false,
+    };
+    writeln!(out, "{kind}: {n} rows; {}", if ok { "OK" } else { "FAIL" })
+        .map_err(|e| e.to_string())?;
+    Ok(ok)
+}
+
+/// Runs a smoke generator, CSV lookup or table assertion.
+pub fn cli(args: &[String], out: &mut dyn Write, err: &mut dyn Write) -> u8 {
+    let result = (|| {
+        let (verb, args) = args.split_first().ok_or("smoke verb required")?;
+        match verb.as_str() {
+            "mini-ref" => mini(args).map(|()| true),
+            "long-reads" => long_reads(args, out).map(|()| true),
+            "eh-catalog" => catalog(args, out).map(|()| true),
+            "csv-cell" => csv_cell(args, out).map(|()| true),
+            "check" if args.len() == 2 => check(&args[0], &args[1], out),
+            _ => {
+                Err("usage: og dev smoke mini-ref|long-reads|eh-catalog|csv-cell|check ...".into())
+            }
+        }
+    })();
+    match result {
+        Ok(true) => 0,
+        Ok(false) => 1,
+        Err(e) => {
+            let _ = writeln!(err, "ERROR: {e}");
+            2
+        }
+    }
+}
diff --git a/rust/crates/og-dev/tests/ci_readers.rs b/rust/crates/og-dev/tests/ci_readers.rs
new file mode 100644
index 000000000..72b8f8db8
--- /dev/null
+++ b/rust/crates/og-dev/tests/ci_readers.rs
@@ -0,0 +1,294 @@
+//! Black-box controls for the CI readers. Every clean fixture is paired with
+//! a changed or unreadable input that must fail.
+use og_dev::{nf_trace, pharmcat, smoke};
+use std::path::PathBuf;
+use std::sync::atomic::{AtomicUsize, Ordering};
+static NEXT: AtomicUsize = AtomicUsize::new(0);
+struct Temp(PathBuf);
+impl Temp {
+    fn new() -> Self {
+        let p = std::env::temp_dir().join(format!(
+            "og-ci-readers-{}-{}",
+            std::process::id(),
+            NEXT.fetch_add(1, Ordering::Relaxed)
+        ));
+        std::fs::create_dir_all(&p).unwrap();
+        Self(p)
+    }
+    fn file(&self, name: &str, text: &str) -> String {
+        let p = self.0.join(name);
+        std::fs::write(&p, text).unwrap();
+        p.to_str().unwrap().into()
+    }
+    fn path(&self, name: &str) -> String {
+        self.0.join(name).to_str().unwrap().into()
+    }
+}
+impl Drop for Temp {
+    fn drop(&mut self) {
+        let _ = std::fs::remove_dir_all(&self.0);
+    }
+}
+type Cli = fn(&[String], &mut dyn std::io::Write, &mut dyn std::io::Write) -> u8;
+fn run(cli: Cli, args: &[&str]) -> (u8, String, String) {
+    let mut out = Vec::new();
+    let mut err = Vec::new();
+    let code = cli(
+        &args.iter().map(|s| s.to_string()).collect::<Vec<_>>(),
+        &mut out,
+        &mut err,
+    );
+    (
+        code,
+        String::from_utf8(out).unwrap(),
+        String::from_utf8(err).unwrap(),
+    )
+}
+#[test]
+fn unreadable_pharmcat_is_unassessed() {
+    let t = Temp::new();
+    for p in [
+        t.path("missing"),
+        t.file("broken", "{\"genes\":"),
+        t.file("wrong", "[]"),
+        t.file("bad-shape", "{\"genes\": []}"),
+    ] {
+        for flag in ["--called", "--called-lines"] {
+            let (rc, out, err) = run(pharmcat::cli, &["diplotypes", &p, flag]);
+            assert_eq!(rc, 2, "{err}");
+            assert!(out.is_empty());
+            assert!(err.starts_with("unreadable report:"));
+        }
+    }
+    let p = t.file("empty", "{\"genes\": {}}");
+    assert_eq!(
+        run(pharmcat::cli, &["diplotypes", &p, "--called"]),
+        (0, "0\n".into(), "\n".into())
+    );
+}
+#[test]
+fn pharmcat_shapes_fallback_and_deduplication() {
+    let t = Temp::new();
+    let p=t.file("r",r#"{"genes":{"CPIC":{"B":{"sourceDiplotypes":[],"recommendationDiplotypes":[{"allele1":{"name":"*1"}}]},"A":{"sourceDiplotypes":[{"allele1":{"name":"Unknown"},"allele2":{"name":"?"}}]}},"DPWG":{"B":{"sourceDiplotypes":[{"allele1":{"name":"*1"}}]}},"C":{"sourceDiplotypes":[{"allele1":{"name":"NONE"}}]}}}"#);
+    assert_eq!(
+        run(pharmcat::cli, &["diplotypes", &p]),
+        (0, "A\tUnknown/?\nB\t*1/\nC\tNONE/\n".into(), "".into())
+    );
+    assert_eq!(
+        run(pharmcat::cli, &["diplotypes", &p, "--called"]),
+        (0, "1\n".into(), "B\n".into())
+    );
+    let flat = t.file(
+        "flat",
+        r#"{"genes":{"B":{"sourceDiplotypes":[{"allele1":{"name":"*1"}}]}}}"#,
+    );
+    assert_eq!(
+        run(pharmcat::cli, &["diplotypes", &flat, "--called-lines"]),
+        (0, "B\n".into(), "".into())
+    );
+}
+const TRACE: &str = "\"task_id\"\tname\tattempt\texit\tmemory\tcpus\ttime\n1\tX:ALIGN_MINIMAP2 (s)\t1\t137\t34359738368\t8\t86400000\n2\tX:ALIGN_MINIMAP2 (s)\t2\t0\t68719476736\t8\t86400000\n";
+#[test]
+fn trace_attempts_and_duplicate_controls() {
+    let t = Temp::new();
+    let p = t.file("trace", TRACE);
+    let args = |p: &str| {
+        run(
+            nf_trace::cli,
+            &[
+                "attempts",
+                p,
+                "--name-glob",
+                "*ALIGN_MINIMAP2*",
+                "--want",
+                "1:137:32,2:0:64",
+                "--nextflow-exit",
+                "0",
+            ],
+        )
+    };
+    assert_eq!(args(&p).0, 0);
+    let duplicate = t.file(
+        "dup",
+        &format!("{TRACE}1\tX:ALIGN_MINIMAP2 (s)\t1\t-\t34359738368\t8\t86400000\n"),
+    );
+    assert_eq!(args(&duplicate).0, 0);
+    for (name, text) in [
+        ("memory", TRACE.replace("68719476736", "34359738368")),
+        ("exit", TRACE.replace("\t137\t", "\t1\t")),
+        (
+            "missing",
+            TRACE.lines().take(2).collect::<Vec<_>>().join("\n"),
+        ),
+        ("empty", String::new()),
+        ("dash", TRACE.replace("68719476736", "-")),
+        (
+            "conflict",
+            format!("{TRACE}1\tX:ALIGN_MINIMAP2 (s)\t1\t0\t34359738368\t8\t86400000\n"),
+        ),
+    ] {
+        assert_ne!(args(&t.file(name, &text)).0, 0, "{name}");
+    }
+    assert_eq!(args("trace_*.txt").0, 2);
+    assert_eq!(run(nf_trace::cli, &["attempts", &p, &p]).0, 2);
+}
+#[test]
+fn trace_requests_and_budget_controls() {
+    let t = Temp::new();
+    let p = t.file("trace", TRACE);
+    let want = t.file(
+        "want",
+        "process\tcpus\tmemory_gb\ttime_h\nALIGN_MINIMAP2\t8\t32\t24\n",
+    );
+    let args = |p: &str, cpus: &str, mem: &str| {
+        run(
+            nf_trace::cli,
+            &[
+                "requests",
+                p,
+                "--want",
+                &want,
+                "--executor-cpus",
+                cpus,
+                "--executor-mem-gb",
+                mem,
+            ],
+        )
+    };
+    assert_eq!(args(&p, "16", "96").0, 0);
+    assert_eq!(args(&p, "15", "96").0, 1);
+    assert_eq!(args(&p, "16", "95").0, 1);
+    for (name, text) in [
+        ("cpus", TRACE.replace("\t8\t", "\t4\t")),
+        ("time", TRACE.replace("86400000", "3600000")),
+        ("third", TRACE.replace("\t2\t0\t", "\t3\t0\t")),
+        (
+            "duplicate-name",
+            format!("{TRACE}3\tX:ALIGN_MINIMAP2 (s)\t1\t137\t34359738368\t8\t86400000\n"),
+        ),
+    ] {
+        assert_eq!(args(&t.file(name, &text), "512", "2048").0, 1, "{name}");
+    }
+}
+#[test]
+fn quoted_csv_cell_and_missing_column() {
+    let t = Temp::new();
+    let p = t.file(
+        "csv",
+        "Type,Filter,Value\r\n\"S,N\",PASS,\"a,b\nnext\"\r\nSNP,PASS,0.9\r\n",
+    );
+    assert_eq!(
+        run(
+            smoke::cli,
+            &["csv-cell", &p, "Type=SNP,Filter=PASS", "Value"]
+        ),
+        (0, "0.9\n".into(), "".into())
+    );
+    assert_eq!(
+        run(smoke::cli, &["csv-cell", &p, "Filter=PASS", "Value"]).1,
+        "a,b\nnext\n"
+    );
+    assert_eq!(
+        run(smoke::cli, &["csv-cell", &p, "Filter=PASS", "missing"]).0,
+        2
+    );
+}
+#[test]
+fn smoke_tables_reject_removed_properties() {
+    let t = Temp::new();
+    for (kind, good, bad) in [
+        (
+            "hap-ibd",
+            "A 1 B 1 20 1 10000000 10\n",
+            "A 1 C 1 20 1 10000000 10\n",
+        ),
+        (
+            "ibdmix",
+            "h\nS 22 2000000 2600000 4\n",
+            "h\nS 22 2000000 2300000 4\n",
+        ),
+        (
+            "rfmix",
+            "#codes: POPA=0 POPB=1\n#h\n20 0 10000000 0 0 0 0 0\n20 10000000 20000000 0 0 0 1 1\n",
+            "#codes: POPA=0 POPB=1\n20 0 20000000 0 0 0 0 0\n",
+        ),
+        (
+            "eigen",
+            "#h\na -2 0 PopA\nb 2 0 PopB\np -1 0 Proj\n",
+            "#h\na -2 0 PopA\nb 2 0 PopB\np 1 0 Proj\n",
+        ),
+        (
+            "parascopy",
+            "chr5 1 2 a b c 4 99\n",
+            "chr5 1 2 a b c * 99\n",
+        ),
+    ] {
+        let p = t.file("table", good);
+        assert_eq!(run(smoke::cli, &["check", kind, &p]).0, 0, "{kind}");
+        let p = t.file("table", bad);
+        assert_eq!(run(smoke::cli, &["check", kind, &p]).0, 1, "{kind}");
+    }
+}
+#[test]
+fn smoke_generators_keep_coordinates_and_reverse_complements() {
+    let t = Temp::new();
+    let seq = format!(
+        "{}{}{}",
+        "A".repeat(21000),
+        "CA".repeat(12),
+        "G".repeat(478976)
+    );
+    let src = t.file("src", &format!(">slice\n{seq}\n"));
+    let orig = t.path("orig");
+    let mini = t.path("mini");
+    assert_eq!(
+        run(
+            smoke::cli,
+            &["mini-ref", &src, &orig, &mini, "450000", "3000"]
+        )
+        .0,
+        0
+    );
+    let fa = std::fs::read_to_string(&mini).unwrap();
+    let s = fa.lines().skip(1).collect::<String>();
+    assert_eq!(s.len(), 503000);
+    assert_eq!(&s[..450000], &seq[..450000]);
+    assert_eq!(&s[453000..], &seq[450000..]);
+    let cat = t.path("cat");
+    assert_eq!(
+        run(smoke::cli, &["eh-catalog", &mini, &cat, "449000"]).1,
+        "repeat 21000 21024 12 units\n"
+    );
+    assert!(
+        std::fs::read_to_string(&cat)
+            .unwrap()
+            .contains("chr20:21000-21024")
+    );
+    let small = t.file("small", &format!(">chr20\n{}\n", "A".repeat(11000)));
+    let fq = t.path("reads.gz");
+    assert_eq!(
+        run(smoke::cli, &["long-reads", &small, &small, &fq]).1,
+        "4 reads\n"
+    );
+    use std::io::Read;
+    let mut text = String::new();
+    og_io::open(&fq).unwrap().read_to_string(&mut text).unwrap();
+    let ls = text.lines().collect::<Vec<_>>();
+    assert_eq!(ls.len(), 16);
+    assert_eq!(ls[1], "A".repeat(10000));
+    assert_eq!(ls[5], "T".repeat(10000));
+    assert_eq!(ls[3], "?".repeat(10000));
+    let bad = t.file("bad", ">x\nA\n");
+    assert_eq!(
+        run(
+            smoke::cli,
+            &["mini-ref", &bad, &orig, &mini, "450000", "3000"]
+        )
+        .0,
+        2
+    );
+    assert_eq!(
+        run(smoke::cli, &["eh-catalog", &small, &cat, "449000"]).0,
+        2
+    );
+}
diff --git a/rust/og/src/main.rs b/rust/og/src/main.rs
index 29c44efa7..226389c76 100644
--- a/rust/og/src/main.rs
+++ b/rust/og/src/main.rs
@@ -74,6 +74,9 @@ const USAGE: &str = "usage: og <tool> [args]
        og exomiser report [args]
        og lookup query|resolve|report [args]
        og dev parity-compare|contract|schema|report-only|remnants [args]
+       og dev pharmcat diplotypes REPORT [--called|--called-lines]
+       og dev nf-trace requests|attempts TRACE [options]
+       og dev smoke mini-ref|long-reads|eh-catalog|csv-cell|check [args]
        og dev helpers [args]
        og dev freshness [--out FILE] [--sections a,b] | --update-issue BODY --repo O/N | --self-test
        og version
diff --git a/scripts/ci/e2e-case-paths.tsv b/scripts/ci/e2e-case-paths.tsv
index f76068dcf..0faa36c6f 100644
--- a/scripts/ci/e2e-case-paths.tsv
+++ b/scripts/ci/e2e-case-paths.tsv
@@ -178,3 +178,4 @@ vntyper-1	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.t
 y-private-report-1-private-and-tree	assets/live/index.html assets/viewer/index.html bin/collect_summary.py bin/og bin/render_report.py bin/results_index.py bin/run_delta.py bin/traits_report.py bin/yleaf_run.py modules/local/html_report/* modules/local/y_haplogroup/* scripts/16-indexcov.sh scripts/24-html-report.sh scripts/37-y-haplogroup.sh scripts/generate-report.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh
 y-str-1	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/live/index.html assets/mito_confirmed.tsv assets/stub/sample.vcf.gz assets/viewer/index.html assets/ystr_panel.tsv bin/collect_summary.py bin/og bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/html_report/* modules/local/indexcov/* modules/local/vcf_precheck/* modules/local/y_str/* scripts/16-indexcov.sh scripts/24-html-report.sh scripts/45-y-str.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 y-tree-current-1-placement	assets/live/index.html assets/viewer/index.html bin/og bin/yleaf_run.py scripts/16-indexcov.sh scripts/37-y-haplogroup.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh
+rust-z2e-readers	rust/crates/og-dev/src/pharmcat.rs rust/crates/og-dev/src/nf_trace.rs rust/crates/og-dev/src/smoke.rs tests/e2e/lib.sh scripts/ci/image-smoke.sh scripts/ci/nf-trace-requests.tsv
diff --git a/scripts/ci/e2e-case-times.tsv b/scripts/ci/e2e-case-times.tsv
index be90f627f..22a67824a 100644
--- a/scripts/ci/e2e-case-times.tsv
+++ b/scripts/ci/e2e-case-times.tsv
@@ -177,3 +177,4 @@ vntyper-1	shard	92	-
 y-private-report-1-private-and-tree	shard	150	nextflow-hardening-2-nf
 y-str-1	shard	42	-
 y-tree-current-1-placement	shard	21	nextflow-hardening-2-nf
+rust-z2e-readers	shard	1	-
diff --git a/scripts/ci/image-smoke.sh b/scripts/ci/image-smoke.sh
index d6dc1c9bb..89d55911e 100755
--- a/scripts/ci/image-smoke.sh
+++ b/scripts/ci/image-smoke.sh
@@ -14,8 +14,7 @@
 #                                              names) and check that every *_IMAGE of
 #                                              versions.env has a row (no docker)
 #   scripts/ci/image-smoke.sh --self-test      prove --check fails on a bad table, and that a
-#                                              host check never imports a module the image
-#                                              planted in its row directory
+#                                              host check fails on a false JSON filter
 #
 # --full also runs the rows marked `full`: they need data too big for every
 # pull request (the monthly run and a run started by hand pass it).
@@ -142,17 +141,11 @@ self_test() {
   t "an unknown input fails" "unknown input 'genome'" "$A" $'B_IMAGE\t-\tgenome\ttrue\ttrue'
   t "also= on an unset variable fails" "also=B_DATA is not set" "$A" $'B_IMAGE\talso=B_DATA\t-\ttrue\ttrue'
   t "a row with four columns fails" "3 tabs, want 4" "$A" $'B_IMAGE\t-\t-\ttrue'
-  # A row's checks run in its row directory, which the image wrote. A json.py
-  # or csv.py the image planted there must not be imported by a host-side
-  # check (python3 -I keeps the working directory off sys.path).
-  mkdir "${tmp}/row"
-  for m in json csv; do printf 'raise SystemExit("planted %s.py was imported")\n' "$m" > "${tmp}/row/${m}.py"; done
-  printf '{"genes": {"CYP2C19": {"sourceDiplotypes": [{"allele1": {"name": "*1"}, "allele2": {"name": "*2"}}]}}}\n' > "${tmp}/row/r.json"
-  printf 'a,b\n1,2\n' > "${tmp}/row/t.csv"
-  out=$(cd "${tmp}/row" && CHECK_FAILS=0 && py "json loads" "import json; print(json.dumps(1))" \
-          && pharmcat_called r.json 2>/dev/null && csv_cell t.csv a=1 b && echo "fails=${CHECK_FAILS}")
-  if [ "$out" = $'[PASS] json loads (1)\n1\n2\nfails=0' ]; then echo "[PASS] a module the image planted in the row directory is not imported"
-  else echo "[FAIL] a module the image planted in the row directory is not imported: ${out//$'\n'/ | }"; fails=$((fails + 1)); fi
+  printf '{"value": 1}\n' > "${tmp}/r.json"
+  out=$(CHECK_FAILS=0; jqcheck "true filter" "${tmp}/r.json" '.value == 1'; jqcheck "false filter" "${tmp}/r.json" '.value == 2'; echo "fails=$CHECK_FAILS")
+  if grep -q '^\[PASS\] true filter' <<< "$out" && grep -q '^\[FAIL\] false filter' <<< "$out" && grep -q '^fails=1$' <<< "$out"; then
+    echo "[PASS] jqcheck rejects a false filter"
+  else echo "[FAIL] jqcheck rejects a false filter: $out"; fails=$((fails + 1)); fi
   rm -rf "$tmp"
   if [ "$fails" -gt 0 ]; then echo "self-test: ${fails} case(s) failed" >&2; return 1; fi
   echo "self-test: all cases passed"
@@ -303,20 +296,7 @@ need() {
 need_ref() {
   fx_get fixture_ref.fa.gz fixture_ref.fa.gz.fai fixture_ref.fa.gz.gzi || return 1
   hsam faidx /fx/fixture_ref.fa.gz chr20:10000001-10500000 > "${IN}/slice.fa.tmp" || return 1
-  python3 -I - "${IN}/slice.fa.tmp" "${IN}/orig.fa" "${IN}/mini.fa" "$PLANT_POS" "$PLANT_LEN" <<'PY' || return 1
-import random, sys
-src, orig, mini, pos, n = sys.argv[1], sys.argv[2], sys.argv[3], int(sys.argv[4]), int(sys.argv[5])
-seq = "".join(l.strip() for l in open(src) if not l.startswith(">")).upper()
-assert len(seq) == 500000, len(seq)
-def write(path, s):
-    with open(path, "w") as f:
-        f.write(">chr20\n")
-        for i in range(0, len(s), 60):
-            f.write(s[i:i + 60] + "\n")
-write(orig, seq)
-random.seed(20)
-write(mini, seq[:pos] + "".join(random.choice("ACGT") for _ in range(n)) + seq[pos:])
-PY
+  "${OG:-${REPO}/bin/og}" dev smoke mini-ref "${IN}/slice.fa.tmp" "${IN}/orig.fa" "${IN}/mini.fa" "$PLANT_POS" "$PLANT_LEN" || return 1
   rm -f "${IN}/slice.fa.tmp"
   hsam faidx /in/orig.fa && hsam faidx /in/mini.fa && hsam dict -o /in/mini.dict /in/mini.fa || return 1
   [ "$(cut -f2 "${IN}/mini.fa.fai")" = "$MINI_LEN" ]
@@ -368,21 +348,7 @@ need_longreads() {
   need ref && need truth || return 1
   hbcf consensus -H 1 -f /in/orig.fa /in/truth.vcf.gz > "${IN}/hap1.fa" &&
     hbcf consensus -H 2 -f /in/orig.fa /in/truth.vcf.gz > "${IN}/hap2.fa" || return 1
-  python3 -I - "${IN}/hap1.fa" "${IN}/hap2.fa" "${IN}/long.fq.gz" <<'PY'
-import gzip, sys
-comp = str.maketrans("ACGTN", "TGCAN")
-with gzip.open(sys.argv[3], "wt") as out:
-    k = 0
-    for h, path in enumerate(sys.argv[1:3], 1):
-        seq = "".join(l.strip() for l in open(path) if not l.startswith(">")).upper()
-        for start in range(0, len(seq) - 10000 + 1, 1000):
-            r = seq[start:start + 10000]
-            if k % 2:
-                r = r.translate(comp)[::-1]
-            out.write(f"@hap{h}_{start}\n{r}\n+\n{'?' * len(r)}\n")
-            k += 1
-print(k, "reads")
-PY
+  "${OG:-${REPO}/bin/og}" dev smoke long-reads "${IN}/hap1.fa" "${IN}/hap2.fa" "${IN}/long.fq.gz"
 }
 need_longbam() {
   need longreads || return 1
@@ -463,16 +429,7 @@ need_qc() {
 # in the mini reference, away from the slice ends and the planted bases.
 need_ehcatalog() {
   need ref || return 1
-  python3 -I - "${IN}/mini.fa" "${IN}/eh_catalog.json" "$SMALL_END" <<'PY'
-import json, re, sys
-seq = "".join(l.strip() for l in open(sys.argv[1]) if not l.startswith(">"))
-end = int(sys.argv[3])
-m = next(m for m in re.finditer(r"(?:CA){12,}", seq) if 20000 < m.start() and m.end() < end - 20000)
-json.dump([{"LocusId": "SMOKE1", "LocusStructure": "(CA)*",
-            "ReferenceRegion": f"chr20:{m.start()}-{m.end()}", "VariantType": "Repeat"}],
-          open(sys.argv[2], "w"), indent=1)
-print("repeat", m.start(), m.end(), len(m.group()) // 2, "units")
-PY
+  "${OG:-${REPO}/bin/og}" dev smoke eh-catalog "${IN}/mini.fa" "${IN}/eh_catalog.json" "$SMALL_END"
 }
 # A chain that maps chr20 onto itself over the region of the small variants.
 need_chain() {
@@ -511,9 +468,21 @@ same() { if [ -n "$2" ] && [ "$2" = "$3" ]; then pass "$1 (${2})"; else fail "$1
 has() { if [ -n "$2" ] && grep -Eq -- "$3" <<< "$2"; then pass "$1 (${2})"; else fail "$1 (got '${2}', want /${3}/)"; fi; }
 contains() { if [ -f "$2" ] && grep -Eq -- "$3" "$2"; then pass "$1"; else fail "$1 (/${3}/ not in ${2})"; fi; }
 nonempty() { if [ -s "$2" ]; then pass "$1"; else fail "$1 (${2} is missing or empty)"; fi; }
-py() {
+jqcheck() {
   local out
-  if out=$(python3 -I -c "$2" 2>&1); then pass "$1${out:+ (${out//$'\n'/ })}"; else fail "$1: $(tail -n 3 <<< "$out" | tr '\n' ' ')"; fi
+  if out=$(jq -e "$3" "$2" 2>&1); then pass "$1${out:+ (${out//$'\n'/ })}"
+  else fail "$1: ${out//$'\n'/ }"; fi
+}
+smoke_check() {
+  local out
+  if out=$("${OG:-${REPO}/bin/og}" dev smoke check "$2" "$3" 2>&1); then pass "$1 ($out)"
+  else fail "$1: $out"; fi
+}
+check_pharmcat() {
+  local out rc=0
+  out=$(pharmcat_called "$2") || rc=$?
+  if [ "$rc" -ne 0 ]; then fail "$1 (not assessed: unreadable PharmCAT report)"
+  else at_least "$1" "$out" 1; fi
 }
 bcf() { hbcf "$@" 2>/dev/null; }
 # vcf_records FILE: data records (paths relative to the row directory or under /in).
@@ -559,42 +528,11 @@ tsv_count() {
 }
 # csv_cell FILE KEY=VALUE[,KEY=VALUE] COLUMN: COLUMN of the first row that matches.
 csv_cell() {
-  python3 -I - "$1" "$2" "$3" <<'PY'
-import csv, sys
-want = dict(kv.split("=", 1) for kv in sys.argv[2].split(","))
-for row in csv.DictReader(open(sys.argv[1])):
-    if all(row.get(k) == v for k, v in want.items()):
-        print(row[sys.argv[3]])
-        break
-PY
+  "${OG:-${REPO}/bin/og}" dev smoke csv-cell "$1" "$2" "$3"
 }
 # pharmcat_called report.json: genes with a named diplotype.
 pharmcat_called() {
-  python3 -I - "$1" <<'PY'
-import json, sys
-try:
-    data = json.load(open(sys.argv[1]))
-except Exception as e:
-    print(f"unreadable report: {e}", file=sys.stderr)
-    sys.exit(0)
-def called(g):
-    for d in (g.get("sourceDiplotypes") or g.get("recommendationDiplotypes") or []):
-        names = [(d.get(a) or {}).get("name", "") for a in ("allele1", "allele2")]
-        if any(n and n.lower() not in ("unknown", "none", "?") for n in names):
-            return True
-    return False
-out = set()
-for key, val in (data.get("genes") or {}).items():
-    if not isinstance(val, dict):
-        continue
-    if "sourceDiplotypes" in val or "recommendationDiplotypes" in val:
-        if called(val):
-            out.add(key)
-    else:
-        out.update(n for n, g in val.items() if isinstance(g, dict) and called(g))
-print(" ".join(sorted(out)), file=sys.stderr)
-print(len(out))
-PY
+  "${OG:-${REPO}/bin/og}" dev pharmcat diplotypes "$1" --called
 }
 
 # ------------------------------------------------------------- the runner
diff --git a/scripts/ci/nf-trace-requests.tsv b/scripts/ci/nf-trace-requests.tsv
new file mode 100644
index 000000000..89ed623b0
--- /dev/null
+++ b/scripts/ci/nf-trace-requests.tsv
@@ -0,0 +1,10 @@
+process	cpus	memory_gb	time_h
+DEEPVARIANT	8	32	48
+FASTP	8	8	8
+ALIGN_MINIMAP2	8	32	24
+MANTA	8	16	24
+CNVPYTOR	4	8	24
+VEP	8	16	24
+PRS_PREPARE	1	2	2
+PRS_SCORE_SITES	2	4	4
+PRS	4	24	8
diff --git a/scripts/ci/parity-diff.sh b/scripts/ci/parity-diff.sh
index 3d94ebfb1..d8c555946 100755
--- a/scripts/ci/parity-diff.sh
+++ b/scripts/ci/parity-diff.sh
@@ -37,7 +37,7 @@
 #       to compare equal, then plants one difference per item and requires
 #       each to be reported (and a known one to pass, a stale one to fail,
 #       a missing file to fail), on the items PARITY_ITEMS picks.
-# Needs docker (bcftools and samtools from versions.env) and python3. Writes
+# Needs docker (bcftools and samtools from versions.env) and og (plus jq for --self-test). Writes
 # a markdown table to stdout and to $GITHUB_STEP_SUMMARY when it is set.
 set -euo pipefail
 export LC_ALL=C
@@ -112,25 +112,7 @@ canon() {
         echo "summary:"
         cat "${dir}/$(path "$side" roh "$s" | awk '{print $2}')"; } ;;
     pharmcat)
-      python3 - "$f" <<'PY'
-import json, sys
-data = json.load(open(sys.argv[1]))
-rows = set()
-def dips(gene, g):
-    for d in (g.get("sourceDiplotypes") or g.get("recommendationDiplotypes") or []):
-        names = [(d.get(a) or {}).get("name", "") or "" for a in ("allele1", "allele2")]
-        rows.add(f"{gene}\t{'/'.join(names)}")
-for key, val in (data.get("genes") or {}).items():
-    if not isinstance(val, dict):
-        continue
-    if "sourceDiplotypes" in val or "recommendationDiplotypes" in val:
-        dips(key, val)
-    else:
-        for name, g in val.items():
-            if isinstance(g, dict):
-                dips(name, g)
-print("\n".join(sorted(rows)))
-PY
+      "${OG:-${ROOT}/bin/og}" dev pharmcat diplotypes "$f"
       ;;
     prs)
       awk -F'\t' 'NR == 1 {for (i = 1; i <= NF; i++) c[$i] = i; next}
@@ -296,13 +278,9 @@ self_test() {
       clinvar) printf 'chr1\t1\tA\tT\t0/1\t1\tGENE:1\tPathogenic\tplanted\n' >> "${t}/nf/$(path nf clinvar "$s")" ;;
       roh) printf 'RG\t%s\tchr1\t1\t6000000\t6000000\t1\t99.0\n' "$s" >> "${t}/nf/$(path nf roh "$s" | awk '{print $1}')" ;;
       pharmcat)
-        python3 - "${t}/nf/$(path nf pharmcat "$s")" <<'PY'
-import json, sys
-p = sys.argv[1]
-d = json.load(open(p))
-d["genes"] = {}
-json.dump(d, open(p, "w"))
-PY
+        local report
+        report="${t}/nf/$(path nf pharmcat "$s")"
+        jq '.genes = {}' "$report" > "${report}.tmp" && mv "${report}.tmp" "$report"
         ;;
       prs)
         awk -F'\t' -v OFS='\t' 'NR == 1 {for (i = 1; i <= NF; i++) c[$i] = i; print; next}
diff --git a/scripts/ci/settle-doubts.sh b/scripts/ci/settle-doubts.sh
index d94afc639..8b1fc6891 100755
--- a/scripts/ci/settle-doubts.sh
+++ b/scripts/ci/settle-doubts.sh
@@ -216,12 +216,7 @@ CHECKED=0
 while IFS='=' read -r var val; do
   img=$(sed -E 's/^"([^"]*)".*/\1/' <<< "$val")
   CHECKED=$((CHECKED + 1))
-  user=$(docker buildx imagetools inspect "$img" --format '{{json .Image}}' 2>/dev/null | python3 -c '
-import json, sys
-d = json.load(sys.stdin)
-if "config" not in d:
-    d = d.get("linux/amd64") or next(iter(d.values()))
-print((d.get("config") or {}).get("User") or "")' 2>/dev/null || echo "?")
+  user=$(docker buildx imagetools inspect "$img" --format '{{json .Image}}' 2>/dev/null | jq -r 'if has("config") then . else (."linux/amd64" // (to_entries[0].value)) end | .config.User // ""' 2>/dev/null || echo "?")
   case "$user" in
     ""|root|0|0:0) ;;
     *)
diff --git a/tests/e2e/31-pharmcat-07.sh b/tests/e2e/31-pharmcat-07.sh
index 5c9c883c7..754494105 100755
--- a/tests/e2e/31-pharmcat-07.sh
+++ b/tests/e2e/31-pharmcat-07.sh
@@ -8,9 +8,7 @@ check_step_exit 07-pharmacogenomics.sh
 
 JSON="${GENOME_DIR}/${SAMPLE}/vcf/${SAMPLE}.report.json"
 check "report.json exists" test -s "$JSON"
-CALLED=$(pharmcat_called "$JSON")
-echo "genes with a named diplotype: ${CALLED//$'\n'/ }"
-check_ge "genes called in report.json" "$(grep -c . <<< "$CALLED" || true)" 1
+check_pharmcat_called "genes called in report.json" "$JSON"
 check "HTML report exists" nonempty "${SAMPLE}/vcf/${SAMPLE}.report.html"
 
 finish
diff --git a/tests/e2e/60-nextflow.sh b/tests/e2e/60-nextflow.sh
index 369c0ec1f..a9378e9ac 100755
--- a/tests/e2e/60-nextflow.sh
+++ b/tests/e2e/60-nextflow.sh
@@ -60,7 +60,7 @@ check "VCFANNO output is indexed" nonempty "${R}/vep/${SAMPLE}_annotated.vcf.gz.
 check_ge "VCFANNO records carrying REVEL" "$(vcf_count -i 'INFO/REVEL!="."' "${R}/vep/${SAMPLE}_annotated.vcf.gz")" 1
 check_ge "ROH output lines" "$(cat "${GENOME_DIR}/${R}"/roh/*_roh.txt 2>/dev/null | grep -vc '^#' || true)" 1
 JSON=$(find "${GENOME_DIR}/${R}/pharmcat" -name '*.report.json' 2>/dev/null | awk 'NR == 1')
-check_ge "PHARMCAT genes called" "$( [ -n "$JSON" ] && pharmcat_called "$JSON" | grep -c . || echo 0)" 1
+check_pharmcat_called "PHARMCAT genes called" "$JSON"
 check_ge "CPIC_LOOKUP gene rows" \
   "$(awk -F'\t' 'NF >= 3' "${GENOME_DIR}/${R}/cpic/${SAMPLE}_phenotypes.tsv" 2>/dev/null | wc -l | tr -d ' ')" 1
 
diff --git a/tests/e2e/lib.sh b/tests/e2e/lib.sh
index e469c2875..e0a01ae41 100755
--- a/tests/e2e/lib.sh
+++ b/tests/e2e/lib.sh
@@ -87,31 +87,22 @@ sample_side_hits() {
 # pharmcat_called <report.json>: genes with a named diplotype (flat or nested
 # `genes` map, sourceDiplotypes or recommendationDiplotypes), one per line.
 pharmcat_called() {
-  python3 - "$1" <<'PY'
-import json, sys
-try:
-    data = json.load(open(sys.argv[1]))
-except Exception as e:
-    print(f"unreadable report: {e}", file=sys.stderr)
-    sys.exit(0)
-def called(g):
-    for d in (g.get("sourceDiplotypes") or g.get("recommendationDiplotypes") or []):
-        names = [(d.get(a) or {}).get("name", "") for a in ("allele1", "allele2")]
-        if any(n and n.lower() not in ("unknown", "none", "?") for n in names):
-            return True
-    return False
-genes = data.get("genes") or {}
-out = set()
-for key, val in genes.items():
-    if not isinstance(val, dict):
-        continue
-    if "sourceDiplotypes" in val or "recommendationDiplotypes" in val:
-        if called(val):
-            out.add(key)
-    else:
-        out.update(name for name, g in val.items() if isinstance(g, dict) and called(g))
-print("\n".join(sorted(out)))
-PY
+  local genes rc=0
+  genes=$("${OG:-${REPO}/bin/og}" dev pharmcat diplotypes "$1" --called-lines) || rc=$?
+  if [ "$rc" -ne 0 ]; then
+    echo "not assessed: PharmCAT report could not be read" >&2
+    return "$rc"
+  fi
+  printf '%s\n' "$genes"
+}
+
+# An unreadable report is a failed assessment, even when a surrounding pipe
+# would otherwise turn the missing output into a zero count.
+check_pharmcat_called() {
+  local genes rc=0
+  genes=$(pharmcat_called "$2") || rc=$?
+  if [ "$rc" -ne 0 ]; then fail "$1 (not assessed: unreadable PharmCAT report)"
+  else check_ge "$1" "$(grep -c . <<< "$genes" || true)" 1; fi
 }
 
 # --- The ancestry panel, from the Actions cache or the mirror when it is there ---
diff --git a/tests/e2e/nextflow-from-fastq-2-nextflow.sh b/tests/e2e/nextflow-from-fastq-2-nextflow.sh
index 155ed2997..be93a8ff8 100755
--- a/tests/e2e/nextflow-from-fastq-2-nextflow.sh
+++ b/tests/e2e/nextflow-from-fastq-2-nextflow.sh
@@ -151,7 +151,7 @@ check_ge "heterozygous calls on the PAR1 slice (diploid there)" "$(vcf_count -g
 GENE=$(planted gene)
 check_ge "CLINVAR_SCREEN names the planted hit's gene (${GENE})" "$(sample_side_hits "${G}/${R}/clinvar" "$GENE")" 1
 JSON="${G}/${R}/pharmcat/${P}.report.json"
-check_ge "PHARMCAT genes called" "$( [ -s "$JSON" ] && pharmcat_called "$JSON" | grep -c . || echo 0)" 1
+check_pharmcat_called "PHARMCAT genes called" "$JSON"
 check_eq "PRS scores in the summary (one per id of assets/pgs_scores.tsv)" "$(awk 'NR > 1' "${G}/${R}/prs/${P}_prs_summary.tsv" 2>/dev/null | wc -l | tr -d ' ')" \
   "$(awk -F'\t' '$1 ~ /^PGS[0-9]+$/' "${REPO}/assets/pgs_scores.tsv" | wc -l | tr -d ' ')"
 check_eq "PRS input (hom-ref sites from the gVCF)" "$(awk -F'\t' 'NR == 2 {print $NF}' "${G}/${R}/prs/${P}_prs_summary.tsv" 2>/dev/null)" gvcf
diff --git a/tests/e2e/pgx-6-gvcf-column.sh b/tests/e2e/pgx-6-gvcf-column.sh
index 7e4feecac..8c7216209 100755
--- a/tests/e2e/pgx-6-gvcf-column.sh
+++ b/tests/e2e/pgx-6-gvcf-column.sh
@@ -64,7 +64,7 @@ OUT=$(cat "${WORK}/${HASH:-none}"*/.command.out 2>/dev/null)
 echo "PHARMCAT_PREPROCESS (${HASH:-no task}): $(head -n 1 <<< "$OUT")"
 check "PharmCAT's input is the gVCF, its reference blocks expanded" has "^Input: ${P}\.g\.vcf\.gz \(reference blocks expanded" "$OUT"
 JSON="${NF_OUT}/${P}/pharmcat/${P}.report.json"
-check_ge "PHARMCAT genes called" "$( [ -s "$JSON" ] && pharmcat_called "$JSON" | grep -c . || echo 0)" 1
+check_pharmcat_called "PHARMCAT genes called" "$JSON"
 check_eq "PRS input (hom-ref sites from the gVCF)" \
   "$(awk -F'\t' 'NR == 2 {print $NF}' "${NF_OUT}/${P}/prs/${P}_prs_summary.tsv" 2>/dev/null)" gvcf
 
diff --git a/tests/e2e/rust-z2e-readers.sh b/tests/e2e/rust-z2e-readers.sh
new file mode 100755
index 000000000..7ece97ea9
--- /dev/null
+++ b/tests/e2e/rust-z2e-readers.sh
@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+# Public synthetic reports and traces. No containers or downloaded fixture needed.
+. "$(dirname "$0")/lib.sh"
+printf '{"genes":{"CYP2C19":{"sourceDiplotypes":[{"allele1":{"name":"*1"}}]}}}\n' > "$CASE_TMP/report.json"
+check_pharmcat_called "a readable report has a named gene" "$CASE_TMP/report.json"
+printf '{"genes":' > "$CASE_TMP/broken.json"
+rc=0
+pharmcat_called "$CASE_TMP/broken.json" > "$CASE_TMP/out" 2> "$CASE_TMP/err" || rc=$?
+check_eq "truncated report exits 2" "$rc" 2
+check "truncated report is unreadable, never a zero count" grep -q 'unreadable report:' "$CASE_TMP/err"
+check_eq "truncated report has no call output" "$(wc -c < "$CASE_TMP/out" | tr -d ' ')" 0
+printf 'task_id\tname\tattempt\texit\tmemory\n1\tPRS (s)\t1\t137\t25769803776\n2\tPRS (s)\t2\t0\t51539607552\n' > "$CASE_TMP/trace.txt"
+check "retry memory and exit match" "${OG:-${REPO}/bin/og}" dev nf-trace attempts "$CASE_TMP/trace.txt" --name-glob 'PRS (s)' --want '1:137:24,2:0:48' --nextflow-exit 0
+rc=0
+"${OG:-${REPO}/bin/og}" dev nf-trace attempts "$CASE_TMP/trace*.txt" --name-glob 'PRS (s)' --want '1:137:24,2:0:48' --nextflow-exit 0 > "$CASE_TMP/out" 2> "$CASE_TMP/err" || rc=$?
+check_eq "ambiguous trace glob exits 2" "$rc" 2
+check "trace glob refusal explains the required path" grep -q 'trace glob refused' "$CASE_TMP/err"
+finish
diff --git a/tests/e2e/vendor-vcf-intake-5-docs.sh b/tests/e2e/vendor-vcf-intake-5-docs.sh
index 10a9a03c8..3ef380fae 100755
--- a/tests/e2e/vendor-vcf-intake-5-docs.sh
+++ b/tests/e2e/vendor-vcf-intake-5-docs.sh
@@ -80,7 +80,7 @@ check "the page's Nextflow run wrote the report" test -s "${R}/sample1_report.ht
 check_eq "its ROH card is filled" "$(html_stat "${R}/sample1_report.html" 'Runs of Homozygosity' Status)" Complete
 check_eq "its haplogroup card is filled" "$(html_stat "${R}/sample1_report.html" 'Mitochondrial Haplogroup' Status)" Complete
 JSON="${R}/pharmcat/sample1.report.json"
-check_ge "its PharmCAT calls genes" "$( [ -s "$JSON" ] && pharmcat_called "$JSON" | grep -c . || echo 0)" 1
+check_pharmcat_called "its PharmCAT calls genes" "$JSON"
 
 # --- docs/nextflow.md "Before you share outputs", as pasted ------------------------------
 RECIPE=$(awk '/^## Before you share outputs/ {on = 1} on && /^```bash$/ {b = 1; next} b && /^```/ {exit} b' \
diff --git a/tests/parity/README.md b/tests/parity/README.md
index d83ff2087..2604ea891 100644
--- a/tests/parity/README.md
+++ b/tests/parity/README.md
@@ -42,3 +42,5 @@ A `known.tsv` row whose difference is gone fails. A golden that the oracle also
 3. Run `scripts/ci/oracle-diff.sh`. Turn each difference into a fix, a golden or a `known.tsv` row.
 4. Switch the callers to `og`, delete the Python, and add the tool to `OG_SHADOW` in `.github/workflows/e2e.yml`.
 5. Link a red run in the pull request: the cases with one planted change in the port must fail.
+
+The `dev-pharmcat*`, `dev-nf-*` and `dev-smoke-*` cases extract archived heredocs from their pre-port shell/workflow files. The wrapper keeps the original Python as the oracle. The mini-reference golden records the deliberate change to a fixed Rust random seed. Truncated PharmCAT JSON has goldens for exit 2 and the unreadable-report diagnostic. The standalone [CI reader tests](../../rust/crates/og-dev/tests/ci_readers.rs) pair clean inputs with changed requests, exits, CSV fields and smoke properties that must fail.
diff --git a/tests/parity/cases.tsv b/tests/parity/cases.tsv
index 0a9afd6bf..98a436f8d 100644
--- a/tests/parity/cases.tsv
+++ b/tests/parity/cases.tsv
@@ -950,3 +950,19 @@ family-ibd	mapbp	gen:ibd-oracle.sh,gen:ibd-cases.sh	--pedigree mapbp/pedigree.ts
 family-ibd	nomap	gen:ibd-oracle.sh,gen:ibd-cases.sh	--pedigree nomap/pedigree.tsv --chroms nomap/chroms.txt --maps nomap/maps --phased nomap/phased --ibd nomap/ibd --out-dir out	-	content	PYTHON_IMAGE
 family-ibd	short	gen:ibd-oracle.sh,gen:ibd-cases.sh	--pedigree short/pedigree.tsv --chroms short/chroms.txt --maps short/maps --phased short/phased --ibd short/ibd --out-dir out	-	content	PYTHON_IMAGE
 family-ibd	twice	gen:ibd-oracle.sh,gen:ibd-cases.sh	--pedigree twice/pedigree.tsv --chroms twice/chroms.txt --maps twice/maps --phased twice/phased --ibd twice/ibd --out-dir out	-	content	PYTHON_IMAGE
+dev-pharmcat	flat	ci-readers/oracle.sh,ci-readers/flat.json	flat.json	-	bytes	PYTHON_IMAGE
+dev-pharmcat-called	flat	ci-readers/oracle.sh,ci-readers/flat.json	flat.json --called	-	bytes	PYTHON_IMAGE
+dev-pharmcat-lines	flat	ci-readers/oracle.sh,ci-readers/flat.json	flat.json --called-lines	-	bytes	PYTHON_IMAGE
+dev-pharmcat	nested	ci-readers/oracle.sh,ci-readers/nested.json	nested.json	-	bytes	PYTHON_IMAGE
+dev-pharmcat-called	nested	ci-readers/oracle.sh,ci-readers/nested.json	nested.json --called	-	bytes	PYTHON_IMAGE
+dev-pharmcat-lines	nested	ci-readers/oracle.sh,ci-readers/nested.json	nested.json --called-lines	-	bytes	PYTHON_IMAGE
+dev-pharmcat	empty	ci-readers/oracle.sh,ci-readers/empty.json	empty.json	-	bytes	PYTHON_IMAGE
+dev-pharmcat-called	empty	ci-readers/oracle.sh,ci-readers/empty.json	empty.json --called	-	bytes	PYTHON_IMAGE
+dev-pharmcat-lines	empty	ci-readers/oracle.sh,ci-readers/empty.json	empty.json --called-lines	-	bytes	PYTHON_IMAGE
+dev-pharmcat-called	truncated	ci-readers/oracle.sh,ci-readers/truncated.json	truncated.json --called	-	bytes	PYTHON_IMAGE
+dev-smoke-csv	quoted	ci-readers/oracle.sh,ci-readers/cells.csv	cells.csv Filter=PASS Value	-	bytes	PYTHON_IMAGE
+dev-nf-requests	resources	ci-readers/oracle.sh,ci-readers/requests.tsv,ci-readers/want.tsv	requests.tsv --want want.tsv --executor-cpus 512 --executor-mem-gb 2048	-	bytes	PYTHON_IMAGE
+dev-nf-attempts	retry	ci-readers/oracle.sh,ci-readers/attempts.tsv	attempts.tsv --name-glob *ALIGN_MINIMAP2* --want 1:137:32,2:0:64 --nextflow-exit 0	-	bytes	PYTHON_IMAGE
+dev-smoke-mini	fixture	ci-readers/oracle.sh,gen:ci-smoke.sh	slice.fa orig.fa mini.fa 450000 3000	orig.fa,mini.fa	bytes	PYTHON_IMAGE
+dev-smoke-long	fixture	ci-readers/oracle.sh,gen:ci-smoke.sh	hap1.fa hap2.fa long.fq.gz	long.fq.gz	gz-content	PYTHON_IMAGE
+dev-smoke-catalog	fixture	ci-readers/oracle.sh,gen:ci-smoke.sh	slice.fa eh.json 449000	eh.json	json	PYTHON_IMAGE
diff --git a/tests/parity/gen/ci-smoke.sh b/tests/parity/gen/ci-smoke.sh
new file mode 100755
index 000000000..e7eae467f
--- /dev/null
+++ b/tests/parity/gen/ci-smoke.sh
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+awk 'BEGIN {print ">chr20"; for(i=0;i<500000;i++) {printf "%s",(i>=21000 && i<21024 ? (i%2==0 ? "C":"A") : "G"); if(i%60==59)printf "\n"} printf "\n"}' > slice.fa
+for h in 1 2; do awk 'BEGIN {print ">chr20";for(i=0;i<11000;i++){printf "A";if(i%60==59)printf "\n"}printf "\n"}' > "hap${h}.fa"; done
diff --git a/tests/parity/inputs/ci-readers/attempts.tsv b/tests/parity/inputs/ci-readers/attempts.tsv
new file mode 100644
index 000000000..4e9bb6c82
--- /dev/null
+++ b/tests/parity/inputs/ci-readers/attempts.tsv
@@ -0,0 +1,3 @@
+task_id	name	attempt	exit	memory
+1	ALIGN_MINIMAP2 (s)	1	137	34359738368
+2	ALIGN_MINIMAP2 (s)	2	0	68719476736
diff --git a/tests/parity/inputs/ci-readers/cells.csv b/tests/parity/inputs/ci-readers/cells.csv
new file mode 100644
index 000000000..c634a7429
--- /dev/null
+++ b/tests/parity/inputs/ci-readers/cells.csv
@@ -0,0 +1,4 @@
+Type,Filter,Value
+"S,N",PASS,"a,b
+next"
+SNP,PASS,0.9
diff --git a/tests/parity/inputs/ci-readers/empty.json b/tests/parity/inputs/ci-readers/empty.json
new file mode 100644
index 000000000..6deaa1ec2
--- /dev/null
+++ b/tests/parity/inputs/ci-readers/empty.json
@@ -0,0 +1 @@
+{"genes":{}}
diff --git a/tests/parity/inputs/ci-readers/flat.json b/tests/parity/inputs/ci-readers/flat.json
new file mode 100644
index 000000000..d644fc71d
--- /dev/null
+++ b/tests/parity/inputs/ci-readers/flat.json
@@ -0,0 +1 @@
+{"genes": {"B": {"sourceDiplotypes": [{"allele1": {"name": "*1"}, "allele2": {"name": "*2"}}]}, "A": {"sourceDiplotypes": [{"allele1": {"name": "Unknown"}}]}}}
diff --git a/tests/parity/inputs/ci-readers/nested.json b/tests/parity/inputs/ci-readers/nested.json
new file mode 100644
index 000000000..de864f52e
--- /dev/null
+++ b/tests/parity/inputs/ci-readers/nested.json
@@ -0,0 +1 @@
+{"genes": {"CPIC": {"B": {"sourceDiplotypes": [{"allele1": {"name": "*1"}, "allele2": {"name": "*2"}}]}, "A": {"sourceDiplotypes": [{"allele1": {"name": "Unknown"}}]}}, "DPWG": {"B": {"sourceDiplotypes": [{"allele1": {"name": "*1"}, "allele2": {"name": "*2"}}]}, "A": {"sourceDiplotypes": [{"allele1": {"name": "Unknown"}}]}}}}
diff --git a/tests/parity/inputs/ci-readers/oracle.sh b/tests/parity/inputs/ci-readers/oracle.sh
new file mode 100644
index 000000000..eeb13677e
--- /dev/null
+++ b/tests/parity/inputs/ci-readers/oracle.sh
@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+# Extract the archived heredoc, not a second maintained implementation.
+set -euo pipefail
+mode=$1 prog=$2; shift 2
+case "$mode" in
+  diplotypes) start='^import json, sys$' ;;
+  called-lines) start='^import json, sys$' ;;
+  called) start='^import json, sys$' ;;
+  csv-cell) start='^import csv, sys$' ;;
+  mini-ref) start='^import random, sys$' ;;
+  long-reads) start='^import gzip, sys$' ;;
+  eh-catalog) start='^import json, re, sys$' ;;
+  requests) start='^import csv, sys$' ;;
+  attempts) start='^import csv, sys$' ;;
+  *) exit 2 ;;
+esac
+# The workflow's first inline reader is requests, the second is attempts.
+occurrence=1
+[ "$mode" != attempts ] || occurrence=2
+awk -v re="$start" -v want="$occurrence" '
+  { sub(/^          /, "") }
+  $0 ~ re { n++; if (n == want) on=1 }
+  on && /^PY$/ { exit }
+  on { print }
+' "$prog" > oracle-body
+case "$mode" in
+  called|called-lines) set -- "$1" ;;
+  requests) set -- "$1" "$5" "$7" ;;
+  attempts) set -- "$1" "$7" ;;
+esac
+rc=0
+python3 -I oracle-body "$@" || rc=$?
+rm -f oracle-body
+exit "$rc"
diff --git a/tests/parity/inputs/ci-readers/requests.tsv b/tests/parity/inputs/ci-readers/requests.tsv
new file mode 100644
index 000000000..7c5ef3d03
--- /dev/null
+++ b/tests/parity/inputs/ci-readers/requests.tsv
@@ -0,0 +1,19 @@
+task_id	name	attempt	exit	cpus	memory	time
+1	X:DEEPVARIANT (s)	1	137	8	34359738368	172800000
+2	X:DEEPVARIANT (s)	2	0	8	68719476736	172800000
+3	X:FASTP (s)	1	137	8	8589934592	28800000
+4	X:FASTP (s)	2	0	8	17179869184	28800000
+5	X:ALIGN_MINIMAP2 (s)	1	137	8	34359738368	86400000
+6	X:ALIGN_MINIMAP2 (s)	2	0	8	68719476736	86400000
+7	X:MANTA (s)	1	137	8	17179869184	86400000
+8	X:MANTA (s)	2	0	8	34359738368	86400000
+9	X:CNVPYTOR (s)	1	137	4	8589934592	86400000
+10	X:CNVPYTOR (s)	2	0	4	17179869184	86400000
+11	X:VEP (s)	1	137	8	17179869184	86400000
+12	X:VEP (s)	2	0	8	34359738368	86400000
+13	X:PRS_PREPARE (s)	1	137	1	2147483648	7200000
+14	X:PRS_PREPARE (s)	2	0	1	4294967296	7200000
+15	X:PRS_SCORE_SITES (s)	1	137	2	4294967296	14400000
+16	X:PRS_SCORE_SITES (s)	2	0	2	8589934592	14400000
+17	X:PRS (s)	1	137	4	25769803776	28800000
+18	X:PRS (s)	2	0	4	51539607552	28800000
diff --git a/tests/parity/inputs/ci-readers/truncated.json b/tests/parity/inputs/ci-readers/truncated.json
new file mode 100644
index 000000000..a24f91415
--- /dev/null
+++ b/tests/parity/inputs/ci-readers/truncated.json
@@ -0,0 +1 @@
+{"genes":
\ No newline at end of file
diff --git a/tests/parity/inputs/ci-readers/want.tsv b/tests/parity/inputs/ci-readers/want.tsv
new file mode 100644
index 000000000..89ed623b0
--- /dev/null
+++ b/tests/parity/inputs/ci-readers/want.tsv
@@ -0,0 +1,10 @@
+process	cpus	memory_gb	time_h
+DEEPVARIANT	8	32	48
+FASTP	8	8	8
+ALIGN_MINIMAP2	8	32	24
+MANTA	8	16	24
+CNVPYTOR	4	8	24
+VEP	8	16	24
+PRS_PREPARE	1	2	2
+PRS_SCORE_SITES	2	4	4
+PRS	4	24	8
diff --git a/tests/parity/oracle.ref b/tests/parity/oracle.ref
index 57c27da2f..4932df874 100644
--- a/tests/parity/oracle.ref
+++ b/tests/parity/oracle.ref
@@ -63,3 +63,12 @@ y-yleaf-positions	0baddb45aa3871a57469cf20295bdd832f72f5c0	file:bin/yleaf_run.py
 lookup	0baddb45aa3871a57469cf20295bdd832f72f5c0	file:bin/genome_lookup.py	python3	lookup
 lookup-query	0baddb45aa3871a57469cf20295bdd832f72f5c0	file:bin/genome_lookup.py	bash ./oracle.sh	lookup query
 family-ibd	0baddb45aa3871a57469cf20295bdd832f72f5c0	file:bin/ibd_report.py	sh ./ibd_oracle.sh	family ibd
+dev-pharmcat	669a8196cf4c377200f9b4af9c235ef85fb774a1	file:scripts/ci/parity-diff.sh	sh -c 'exec bash ./oracle.sh diplotypes "$0" "$@"'	dev pharmcat diplotypes
+dev-pharmcat-called	669a8196cf4c377200f9b4af9c235ef85fb774a1	file:scripts/ci/image-smoke.sh	sh -c 'exec bash ./oracle.sh called "$0" "$@"'	dev pharmcat diplotypes
+dev-pharmcat-lines	669a8196cf4c377200f9b4af9c235ef85fb774a1	file:tests/e2e/lib.sh	sh -c 'exec bash ./oracle.sh called-lines "$0" "$@"'	dev pharmcat diplotypes
+dev-smoke-csv	669a8196cf4c377200f9b4af9c235ef85fb774a1	file:scripts/ci/image-smoke.sh	sh -c 'exec bash ./oracle.sh csv-cell "$0" "$@"'	dev smoke csv-cell
+dev-nf-requests	669a8196cf4c377200f9b4af9c235ef85fb774a1	file:.github/workflows/nextflow.yml	sh -c 'exec bash ./oracle.sh requests "$0" "$@"'	dev nf-trace requests
+dev-nf-attempts	669a8196cf4c377200f9b4af9c235ef85fb774a1	file:.github/workflows/nextflow.yml	sh -c 'exec bash ./oracle.sh attempts "$0" "$@"'	dev nf-trace attempts
+dev-smoke-mini	669a8196cf4c377200f9b4af9c235ef85fb774a1	file:scripts/ci/image-smoke.sh	sh -c 'exec bash ./oracle.sh mini-ref "$0" "$@"'	dev smoke mini-ref
+dev-smoke-long	669a8196cf4c377200f9b4af9c235ef85fb774a1	file:scripts/ci/image-smoke.sh	sh -c 'exec bash ./oracle.sh long-reads "$0" "$@"'	dev smoke long-reads
+dev-smoke-catalog	669a8196cf4c377200f9b4af9c235ef85fb774a1	file:scripts/ci/image-smoke.sh	sh -c 'exec bash ./oracle.sh eh-catalog "$0" "$@"'	dev smoke eh-catalog
diff --git a/tests/smoke/commands.tsv b/tests/smoke/commands.tsv
index 11e807eb3..ff757048e 100644
--- a/tests/smoke/commands.tsv
+++ b/tests/smoke/commands.tsv
@@ -7,7 +7,7 @@ MINIMAP2_SAMTOOLS_IMAGE	-	ref,reads,bam	minimap2 --version > minimap2_version.tx
 SAMTOOLS_HTTPS_IMAGE	net	-	samtools view -H https://ftp.sra.ebi.ac.uk/vol1/run/ERR323/ERR3239334/NA12878.final.cram > h.sam	same "@SQ lines of the docs/quick-test.md CRAM header, read over https" "$(grep -c '^@SQ' h.sam)" 3366; contains "chr22 among them" h.sam "^@SQ[[:space:]]SN:chr22[[:space:]]"
 BCFTOOLS_IMAGE	-	ref,truth,vcf	bcftools view -Ob -o a.bcf /in/sample.vcf.gz && bcftools index a.bcf && bcftools view -Oz -o b.vcf.gz a.bcf && bcftools index -t b.vcf.gz && bcftools view -H b.vcf.gz | wc -l > n.txt && bcftools +split-vep -l /in/sample.vcf.gz > csq.txt && bcftools norm -m-both -f /in/mini.fa -Oz -o norm.vcf.gz /in/truth.vcf.gz && bcftools isec -n=2 -w1 -Oz -o shared.vcf.gz /in/truth.vcf.gz /in/query90.vcf.gz && bcftools view -H shared.vcf.gz | wc -l > shared.txt	same "records after a VCF to BCF to VCF round trip" "$(tr -d " " < n.txt)" "$(grep -vc "^#" "$FX/HG002_vep.vcf")"; contains "split-vep lists the CSQ fields" csq.txt "Consequence"; same "records isec finds in truth and query" "$(tr -d " " < shared.txt)" "$(vcf_records /in/query90.vcf.gz)"; at_least "records after norm" "$(vcf_records norm.vcf.gz)" 300
 DEEPVARIANT_IMAGE	-	ref,bam,truth	/opt/deepvariant/bin/run_deepvariant --model_type=WGS --ref=/in/mini.fa --reads=/in/mini.bam --output_vcf=dv.vcf.gz --sample_name=HG002 --num_shards=4 --regions chr20:1-449000 --intermediate_results_dir tmp	at_least "SNV recall against the GIAB truth" "$(snv_recall dv.vcf.gz)" 0.95; same "sample column" "$(bcf query -l dv.vcf.gz)" HG002
-FASTP_IMAGE	-	reads	fastp -i /in/reads_R1.fq.gz -I /in/reads_R2.fq.gz -o t_R1.fq.gz -O t_R2.fq.gz --detect_adapter_for_pe --qualified_quality_phred 20 --cut_front --cut_tail --cut_mean_quality 20 --length_required 36 -g -R HG002 -j fastp.json -h fastp.html	py "trimmed reads kept (at least 80 %)" "import json; s = json.load(open('fastp.json'))['summary']; b = s['before_filtering']['total_reads']; a = s['after_filtering']['total_reads']; print(a, 'of', b); assert b > 0 and a >= 0.8 * b"
+FASTP_IMAGE	-	reads	fastp -i /in/reads_R1.fq.gz -I /in/reads_R2.fq.gz -o t_R1.fq.gz -O t_R2.fq.gz --detect_adapter_for_pe --qualified_quality_phred 20 --cut_front --cut_tail --cut_mean_quality 20 --length_required 36 -g -R HG002 -j fastp.json -h fastp.html	jqcheck "trimmed reads kept (at least 80 %)" fastp.json '.summary | .before_filtering.total_reads as $b | .after_filtering.total_reads as $a | $b > 0 and $a >= 0.8 * $b'
 BWAMEM2_IMAGE	-	ref,reads	bwa-mem2 index -p mini /in/mini.fa && bwa-mem2 mem -t 4 -o bwamem2.sam -R '@RG\tID:HG002\tSM:HG002\tPL:ILLUMINA\tLB:HG002' mini /in/reads_R1.fq.gz /in/reads_R2.fq.gz	at_least "reads mapped (%)" "$(mapped_pct bwamem2.sam)" 95
 BWA_IMAGE	-	ref,reads	bwa index -p mini /in/mini.fa && bwa mem -t 4 -R '@RG\tID:HG002\tSM:HG002' mini /in/reads_R1.fq.gz /in/reads_R2.fq.gz > bwa.sam	at_least "reads mapped (%)" "$(mapped_pct bwa.sam)" 95
 FREEBAYES_IMAGE	-	ref,bam,truth	freebayes -f /in/mini.fa --region chr20:1-449000 /in/mini.bam > freebayes.vcf	at_least "SNV recall against the GIAB truth" "$(snv_recall freebayes.vcf)" 0.9
@@ -31,7 +31,7 @@ SURVIVOR_IMAGE	-	-	sh /smoke/survivor.sh	same "records kept" "$(grep -vc '^#' me
 VEP_IMAGE	net	vcf50	vep --input_file /in/sample50.vcf --output_file vep.vcf --vcf --database --assembly GRCh38 --symbol --force_overwrite --no_stats && grep -v "^#" vep.vcf | awk -F'\t' '{n = split($8, kv, ";"); for (i = 1; i <= n; i++) if (kv[i] ~ /^CSQ=/) {k = split(substr(kv[i], 5), e, ","); for (j = 1; j <= k; j++) {split(e[j], f, "|"); m = split(f[2], q, "&"); for (x = 1; x <= m; x++) print $1 "\t" $2 "\t" $4 "\t" $5 "\t" q[x]}}}' | LC_ALL=C sort -u > csq.tsv && cat csq.tsv	same "records with a CSQ annotation" "$(grep -v "^#" vep.vcf | grep -c "CSQ=")" 50; contains "a gene symbol of the fixture in CSQ" vep.vcf "CYP2C19|CYP2C9|SNAP25|HLA-"; at_least "variant and consequence pairs" "$(wc -l < csq.tsv)" 50; same "pairs that differ from tests/smoke/vep50_consequences.tsv" "$( { [ -s "${SMOKE_DIR}/vep50_consequences.tsv" ] || echo "< the baseline file is missing"; diff csq.tsv "${SMOKE_DIR}/vep50_consequences.tsv"; } 2>/dev/null | grep -c "^[<>]")" 0
 VEP_IMAGE	net	vcf50	sh /smoke/vep-clinvar-custom.sh	contains "ClinVar_CLNSIG in the CSQ header" vep_cv.vcf "Format: .*\|ClinVar_CLNSIG"; same "records with ClinVar_CLNSIG Pathogenic" "$(grep -v '^#' vep_cv.vcf | grep -c 'Pathogenic|reviewed_by_expert_panel')" 1; same "and it is the first record" "$(grep -v '^#' vep_cv.vcf | grep 'Pathogenic|reviewed_by_expert_panel' | awk -F'\t' '{print $1 ":" $2}')" "$(cat first.txt)"
 PCGR_IMAGE	net	vcf50	sh /smoke/pcgr.sh	has "cpsr --version names the release line of the image tag (2.3.2 says cpsr 2.3.0)" "$(cat cpsr_version.txt)" "cpsr $(echo "${PCGR_IMAGE##*:}" | cut -d. -f1-2)"; same "records the bundled VEP annotates" "$(grep -v "^#" vep.vcf | grep -c "CSQ=")" 50; has "the pcgrr R package is the release of the image tag" "$(cat pcgrr_version.txt)" "^${PCGR_IMAGE##*:}"; same "flags of step 17 that cpsr --help does not list" "$(grep -c . cpsr_missing_flags.txt)" 0
-PHARMCAT_IMAGE	-	fullref,pgxvcf	python3 /pharmcat/pharmcat_vcf_preprocessor -vcf /in/pgx.vcf.gz -refFna /in/ref.fa -o /out/ -bf HG002 && java -jar /pharmcat/pharmcat.jar -vcf /out/HG002.preprocessed.vcf.bgz -o /out/ -bf HG002 -reporterJson -reporterHtml	at_least "genes with a named diplotype in report.json" "$(pharmcat_called HG002.report.json)" 1
+PHARMCAT_IMAGE	-	fullref,pgxvcf	python3 /pharmcat/pharmcat_vcf_preprocessor -vcf /in/pgx.vcf.gz -refFna /in/ref.fa -o /out/ -bf HG002 && java -jar /pharmcat/pharmcat.jar -vcf /out/HG002.preprocessed.vcf.bgz -o /out/ -bf HG002 -reporterJson -reporterHtml	check_pharmcat "genes with a named diplotype in report.json" HG002.report.json
 PYPGX_IMAGE	also=PYPGX_BUNDLE_VERSION	fullref,slice,bundle	sh /smoke/pypgx.sh	has "CYP2D6 genotype" "$(cat CYP2D6.genotype.txt)" "^\*[0-9]"
 TELOMEREHUNTER_IMAGE	-	slice	sh /smoke/telomerehunter.sh	same "intratelomeric reads (1,100 planted)" "$(tsv_cell th/HG002/HG002_summary.tsv intratel_reads)" 1100; between "tel_content of the planted reads (5347.26 with 1.1.0 on fixture-v7; 5594.23 before its chrY stretches)" "$(tsv_cell th/HG002/HG002_summary.tsv tel_content)" 5347 5348; between "TCAGGG per intratelomeric read (100 of 1,100)" "$(tsv_cell th/HG002/HG002_summary.tsv TCAGGG_arbitrary_context_norm_by_intratel_reads)" 0.09 0.092
 HAPLOGREP3_IMAGE	-	mito	sh /smoke/haplogrep3.sh	has "haplogroup" "$(tsv_cell haplogroup.txt Haplogroup)" "^[A-Z]"; at_least "haplogroup quality" "$(tsv_cell haplogroup.txt Quality)" 0.8
@@ -41,15 +41,15 @@ YLEAF_IMAGE	net,also=YLEAF_DATA_SHA256	-	sh /smoke/yleaf.sh	same "the release ar
 HIPSTR_IMAGE	-	fullref,slice	sh /smoke/hipstr.sh	at_least "Y-STR regions HipSTR genotypes in the chrY slices, with GB, DP, Q and DSTUTTER (of 11)" "$(grep -c . called.tsv)" 7; same "a haploid call on chrY (one allele in GT)" "$(awk -F'\t' '$2 ~ /[\/|]/' called.tsv | wc -l | tr -d ' ')" 0; has "the image's Python, which step 45 runs on" "$(cat python_version.txt)" "^Python 3\."; contains "HipSTR's log names the regions it read" hipstr.log "Processing region chrY 6993189 6993257"
 T1K_IMAGE	net	hlareads	sh /smoke/t1k.sh	has "HLA-A allele, one of HG002's (A*01:01, A*26:01)" "$(awk -F'\t' '$1 == "HLA-A" {print $3}' t1k/HG002_hla_genotype.tsv)" "^HLA-A\*(01:01|26:01)"; has "both HLA-A alleles of HG002 (A*01:01 and A*26:01)" "$(awk -F'\t' '$1 == "HLA-A" {print $3, $6}' t1k/HG002_hla_genotype.tsv)" "^HLA-A\*01:01[^ ]* HLA-A\*26:01|^HLA-A\*26:01[^ ]* HLA-A\*01:01"
 OPTITYPE_IMAGE	-	hlareads	sh /smoke/optitype.sh	has "both HLA-A alleles of HG002 (A*01:01 and A*26:01)" "$(awk -F'\t' 'NR == 2 {print $2, $3}' HG002_result.tsv)" "^A\*01:01 A\*26:01$|^A\*26:01 A\*01:01$"; has "two HLA-B alleles" "$(awk -F'\t' 'NR == 2 {print $4, $5}' HG002_result.tsv)" "^B\*[0-9]+:[0-9]+ B\*[0-9]+:[0-9]+$"; at_least "reads OptiType mapped to its HLA sequences" "$(awk -F'\t' 'NR == 1 {for (i = 1; i <= NF; i++) if ($i == "Reads") c = i} NR == 2 {print int($c)}' HG002_result.tsv)" 100
-EXPANSIONHUNTER_IMAGE	-	ref,bam,ehcatalog	sh /smoke/expansionhunter.sh	py "the bundled GRCh38 catalog has at least 20 loci" "import json; n = len(json.load(open('bundled_catalog.json'))); print(n); assert n >= 20"; py "a genotype for the repeat on the fixture" "import json; v = json.load(open('eh.json'))['LocusResults']['SMOKE1']['Variants']['SMOKE1']; print(v.get('Genotype')); assert v.get('Genotype')"
+EXPANSIONHUNTER_IMAGE	-	ref,bam,ehcatalog	sh /smoke/expansionhunter.sh	jqcheck "the bundled GRCh38 catalog has at least 20 loci" bundled_catalog.json 'length >= 20'; jqcheck "a genotype for the repeat on the fixture" eh.json '.LocusResults.SMOKE1.Variants.SMOKE1.Genotype | select(. != null and . != false and . != 0 and . != "" and . != [] and . != {})'
 GOLEFT_IMAGE	-	slice	goleft indexcov --directory indexcov /in/HG002_slice.bam	at_least "sample rows in the .ped" "$(awk '!/^#/ && NF >= 6' indexcov/indexcov-indexcov.ped | wc -l)" 1
 MOSDEPTH_IMAGE	-	ref,bam	mosdepth --by 500 --fast-mode --no-per-base --threads 4 --thresholds 1,5,10,15,20,30,50 md /in/mini.bam	at_least "mean depth on chr20" "$(awk '$1 == "chr20" {print $4}' md.mosdepth.summary.txt)" 15
 # Zenodo data (homology table and models, ~50 MB) is downloaded in the row, as setup.sh --parascopy-data does.
-PARASCOPY_IMAGE	net,also=PARASCOPY_DATA_VERSION	fullref,slice	sh /smoke/parascopy.sh	at_least "rows of the SMN1/SMN2 profile" "$(grep -vc '^#' smn.tsv)" 1; py "an aggregate copy number of the SMN1/SMN2 region, with its quality" "import csv; rows = [r for r in csv.reader(open('smn.tsv'), delimiter='\t') if r and not r[0].startswith('#')]; print(rows); assert any(r[0] == 'chr5' and r[6] not in ('', '*') and r[7] not in ('', '*') for r in rows)"
+PARASCOPY_IMAGE	net,also=PARASCOPY_DATA_VERSION	fullref,slice	sh /smoke/parascopy.sh	at_least "rows of the SMN1/SMN2 profile" "$(grep -vc '^#' smn.tsv)" 1; smoke_check "an aggregate copy number of the SMN1/SMN2 region, with its quality" parascopy smn.tsv
 # Paraphase reads PacBio HiFi only: the row runs its own demo, the HG01175 SMN1/SMN2 HiFi reads in the release's tests/data,
 # whose result docs/demo.md of that release publishes: two SMN1, one SMN2, one SMN with exons 7-8 deleted.
 # busybox wget does not validate TLS, so the two files are checked against their sha256 in Paraphase v4.1.0.
-PARAPHASE_IMAGE	net	fullref	v=${PARAPHASE_IMAGE##*:} && u=https://raw.githubusercontent.com/PacificBiosciences/paraphase/v${v%%--*}/tests/data/bams/HG01175_smn1_extracted.bam && wget -q -O hg.bam "$u" && wget -q -O hg.bam.bai "${u}.bai" && { printf '%s  hg.bam\n%s  hg.bam.bai\n' c9659364ad9e60e41ee4771cf92dc017313b6b75a1e08df3e8c0e95ef38eadca 8b5dd238fdf1cc508e85105ff2a157a2c3d73aa3f441d08afdba9458beecca51 | sha256sum -c || { echo 'the demo BAM or its index is not the file Paraphase v4.1.0 ships'; exit 1; }; } && paraphase -b hg.bam -r /in/ref.fa -o pp -p HG01175 -g smn1 -t 4 && cp pp/HG01175.paraphase.json smn1.json && rm -rf pp hg.bam hg.bam.bai	py "SMN1, SMN2 and SMN exon 7-8 deletion copy numbers of HG01175 as Paraphase's demo publishes them (2, 1, 1)" "import json; s = json.load(open('smn1.json'))['smn1']; print(json.dumps(s)[:3000]); r = s['region_specific_info']; c = (r['smn1_cn'], r['smn2_cn'], r['smn_del78_cn']); print(c); assert c == (2, 1, 1)"
+PARAPHASE_IMAGE	net	fullref	v=${PARAPHASE_IMAGE##*:} && u=https://raw.githubusercontent.com/PacificBiosciences/paraphase/v${v%%--*}/tests/data/bams/HG01175_smn1_extracted.bam && wget -q -O hg.bam "$u" && wget -q -O hg.bam.bai "${u}.bai" && { printf '%s  hg.bam\n%s  hg.bam.bai\n' c9659364ad9e60e41ee4771cf92dc017313b6b75a1e08df3e8c0e95ef38eadca 8b5dd238fdf1cc508e85105ff2a157a2c3d73aa3f441d08afdba9458beecca51 | sha256sum -c || { echo 'the demo BAM or its index is not the file Paraphase v4.1.0 ships'; exit 1; }; } && paraphase -b hg.bam -r /in/ref.fa -o pp -p HG01175 -g smn1 -t 4 && cp pp/HG01175.paraphase.json smn1.json && rm -rf pp hg.bam hg.bam.bai	jqcheck "SMN1, SMN2 and SMN exon 7-8 deletion copy numbers of HG01175 (2, 1, 1)" smn1.json '.smn1.region_specific_info | [.smn1_cn, .smn2_cn, .smn_del78_cn] == [2, 1, 1]'
 # MEGAnE's call needs a whole chromosome: on mini.fa's 500 kb it stops in its own code (IndexError). The e2e case mei-1 runs it on chr20.
 MEGANE_IMAGE	-	ref	build_kmerset -fa /in/mini.fa -prefix mini -outdir /out/mk && { call_genotype_38 -h > help.txt 2>&1 || true; }	at_least "repeated 32-mers in the k-mer set of mini.fa" "$(cat mk/mini.mi)" 1000; same "the .mk holds the 8-byte k-mers the .mi counts" "$(( $(wc -c < mk/mini.mk) / 8 ))" "$(cat mk/mini.mi)"; contains "call_genotype_38 takes the -mainchr step 50 passes" help.txt "-mainchr"; contains "and -no_sex_chr" help.txt "-no_sex_chr"; contains "and -only_ins" help.txt "-only_ins"
 # Step 52 on VNtyper's own test data, two BAMs read out of its Zenodo archive by range requests (tests/smoke/vntyper_testdata.py,
@@ -63,19 +63,19 @@ VERIFYBAMID2_IMAGE	-	fullref,slice	sh /smoke/verifybamid2.sh	contains "with the
 GLNEXUS_IMAGE	-	-	H='##fileformat=VCFv4.2\n##FILTER=<ID=PASS,Description="All filters passed">\n##FILTER=<ID=RefCall,Description="Reference call">\n##INFO=<ID=END,Number=1,Type=Integer,Description="End">\n##FORMAT=<ID=GT,Number=1,Type=String,Description="Genotype">\n##FORMAT=<ID=GQ,Number=1,Type=Integer,Description="GQ">\n##FORMAT=<ID=DP,Number=1,Type=Integer,Description="DP">\n##FORMAT=<ID=MIN_DP,Number=1,Type=Integer,Description="MIN_DP">\n##FORMAT=<ID=AD,Number=R,Type=Integer,Description="AD">\n##FORMAT=<ID=VAF,Number=A,Type=Float,Description="VAF">\n##FORMAT=<ID=PL,Number=G,Type=Integer,Description="PL">\n##contig=<ID=chr20,length=503000>\n#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\t'; R='0/0:50:30:0,90,990'; printf "${H}A\nchr20\t1\t.\tA\t<*>\t0\t.\tEND=999\tGT:GQ:MIN_DP:PL\t$R\nchr20\t1000\t.\tA\tG,<*>\t40\tPASS\t.\tGT:GQ:DP:AD:VAF:PL\t0/1:40:30:15,15,0:0.5,0:40,0,40,990,990,990\nchr20\t1001\t.\tC\t<*>\t0\t.\tEND=2000\tGT:GQ:MIN_DP:PL\t$R\n" > A.g.vcf && printf "${H}B\nchr20\t1\t.\tA\t<*>\t0\t.\tEND=1499\tGT:GQ:MIN_DP:PL\t$R\nchr20\t1500\t.\tT\tC,<*>\t45\tPASS\t.\tGT:GQ:DP:AD:VAF:PL\t1/1:45:30:0,30,0:1,0:990,90,0,990,990,990\nchr20\t1501\t.\tG\t<*>\t0\t.\tEND=2000\tGT:GQ:MIN_DP:PL\t$R\n" > B.g.vcf && glnexus_cli --config DeepVariantWGS --dir db --threads 2 A.g.vcf B.g.vcf > joint.bcf	same "records of the joint call of two DeepVariant-style gVCFs" "$(vcf_records joint.bcf)" 2; same "genotypes: A heterozygous at 1000, B homozygous ALT at 1500, each reference from the other's block" "$(bcf query -f '%POS[ %GT]\n' joint.bcf | tr '\n' ';')" "1000 0/1 0/0;1500 0/0 1/1;"
 # Step 38: a three-site trio phased by inheritance, no reads, as the module runs it.
 WHATSHAP_IMAGE	-	-	H='##fileformat=VCFv4.2\n##contig=<ID=chr20,length=503000>\n##FORMAT=<ID=GT,Number=1,Type=String,Description="Genotype">\n#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tkid\tdad\tmum\n'; printf "${H}chr20\t100\t.\tA\tG\t50\tPASS\t.\tGT\t0/1\t0/0\t1/1\nchr20\t200\t.\tC\tT\t50\tPASS\t.\tGT\t0/1\t1/1\t0/0\nchr20\t300\t.\tG\tA\t50\tPASS\t.\tGT\t0/1\t0/1\t0/1\n" > trio.vcf && printf 'f\tkid\tdad\tmum\t1\t0\n' > trio.ped && whatshap phase --ped trio.ped --use-ped-samples -o phased.vcf.gz trio.vcf && python -c "import pysam; pysam.tabix_index('phased.vcf.gz', preset='vcf', force=True)"	has "the kid by inheritance alone: 100 and 200 phased on opposite haplotypes, 300 (all three heterozygous) left unphased" "$(gzip -dc phased.vcf.gz | awk -F'\t' '!/^#/ {split($10, g, ":"); printf "%s ", g[1]}')" '^(0\|1 1\|0|1\|0 0\|1) 0/1 $'; nonempty "pysam indexed the phased VCF (the module and step 38 do the same)" phased.vcf.gz.tbi
-HAP_IBD_IMAGE	-	-	awk 'BEGIN { srand(7); printf "##fileformat=VCFv4.2\n##contig=<ID=chr20,length=64444167>\n##FORMAT=<ID=GT,Number=1,Type=String,Description=\"Genotype\">\n#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tA\tB\tC\tD\n" > "t.vcf"; for (j = 1; j <= 2000; j++) { pos = j * 10000; s = (rand() < 0.5); b1 = (j >= 500 && j <= 1500) ? s : (rand() < 0.5); printf "chr20\t%d\t.\tA\tG\t.\tPASS\t.\tGT\t%d|%d\t%d|%d\t%d|%d\t%d|%d\n", pos, s, (rand() < 0.5), b1, (rand() < 0.5), (rand() < 0.5), (rand() < 0.5), (rand() < 0.5), (rand() < 0.5) > "t.vcf"; printf "chr20\t.\t%.4f\t%d\n", pos / 1000000, pos > "g.map" } }' && hap-ibd gt=t.vcf map=g.map out=o > hapibd.log 2>&1	py "hap-ibd finds the planted 10 cM segment A and B share, and no other" "import gzip; rows = [l.split() for l in gzip.open('o.ibd.gz', 'rt')]; print(rows); ab = [r for r in rows if {r[0], r[2]} == {'A', 'B'}]; assert len(rows) == 1 and len(ab) == 1 and 8 <= float(ab[0][7]) <= 11, rows"
+HAP_IBD_IMAGE	-	-	awk 'BEGIN { srand(7); printf "##fileformat=VCFv4.2\n##contig=<ID=chr20,length=64444167>\n##FORMAT=<ID=GT,Number=1,Type=String,Description=\"Genotype\">\n#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tA\tB\tC\tD\n" > "t.vcf"; for (j = 1; j <= 2000; j++) { pos = j * 10000; s = (rand() < 0.5); b1 = (j >= 500 && j <= 1500) ? s : (rand() < 0.5); printf "chr20\t%d\t.\tA\tG\t.\tPASS\t.\tGT\t%d|%d\t%d|%d\t%d|%d\t%d|%d\n", pos, s, (rand() < 0.5), b1, (rand() < 0.5), (rand() < 0.5), (rand() < 0.5), (rand() < 0.5), (rand() < 0.5) > "t.vcf"; printf "chr20\t.\t%.4f\t%d\n", pos / 1000000, pos > "g.map" } }' && hap-ibd gt=t.vcf map=g.map out=o > hapibd.log 2>&1	smoke_check "hap-ibd finds the planted 10 cM segment A and B share, and no other" hap-ibd o.ibd.gz
 GATK_IMAGE	-	ref,bam,truth	gatk --java-options -Xmx4g HaplotypeCaller -R /in/mini.fa -I /in/mini.bam -O gatk.vcf.gz -L chr20:1-449000 --native-pair-hmm-threads 4 -ERC NONE	at_least "SNV recall against the GIAB truth" "$(snv_recall gatk.vcf.gz)" 0.9
 PICARD_IMAGE	-	ref,truth,chain	java -Xmx2g -jar /usr/picard/picard.jar LiftoverVcf I=/in/truth.vcf.gz O=lift.vcf.gz CHAIN=/in/identity.chain R=/in/mini.fa REJECT=rejected.vcf.gz WARN_ON_MISSING_CONTIG=true	same "records lifted over an identity chain" "$(vcf_records lift.vcf.gz)" "$(vcf_records /in/truth.vcf.gz)"
-PYTHON_IMAGE	net,also=CYRIUS_VERSION	cyrius	sh /smoke/cyrius.sh	same "Cyrius installed from the hash-locked file" "$(cat installed.txt)" "cyrius ${CYRIUS_VERSION}"; same "the TSV has a row for the sample" "$(tsv_cell HG002_cyp2d6.tsv Sample)" HG002_cyrius; py "Cyrius read depth from the BAM (median depth above 0)" "import json; d = json.load(open('HG002_cyp2d6.json'))['HG002_cyrius']; print('median depth', d['Median_depth'], 'MAD', d['Coverage_MAD'], 'genotype', d['Genotype']); assert float(d['Median_depth']) > 0"
+PYTHON_IMAGE	net,also=CYRIUS_VERSION	cyrius	sh /smoke/cyrius.sh	same "Cyrius installed from the hash-locked file" "$(cat installed.txt)" "cyrius ${CYRIUS_VERSION}"; same "the TSV has a row for the sample" "$(tsv_cell HG002_cyp2d6.tsv Sample)" HG002_cyrius; jqcheck "Cyrius read depth from the BAM (median depth above 0)" HG002_cyp2d6.json '.["HG002_cyrius"].Median_depth | tonumber > 0'
 PLINK2_IMAGE	-	vcf	sh /smoke/plink2.sh	between "score sum over five ALT alleles of weight 1" "$(tsv_cell score.sscore SCORE1_SUM)" 5 10
 # Step 26b: two planted groups for ADMIXTURE's supervised fit and the projection of a third person drawn from one of them.
 ADMIXTURE_IMAGE	-	-	awk 'BEGIN { srand(7); for (j = 1; j <= 500; j++) { pa[j] = 0.1 + 0.8 * rand(); pb[j] = 1 - pa[j]; print 1, "s" j, 0, j * 1000 > "d.map"; print 1, "s" j, 0, j * 1000 > "t.map" }; for (i = 1; i <= 40; i++) { g = (i <= 20) ? "A" : "B"; print g > "d.pop"; printf "f%d i%d 0 0 0 -9", i, i > "d.ped"; for (j = 1; j <= 500; j++) { q = (g == "A") ? pa[j] : pb[j]; printf " %d %d", (rand() < q) ? 1 : 2, (rand() < q) ? 1 : 2 > "d.ped" }; printf "\n" > "d.ped" }; printf "t t 0 0 0 -9" > "t.ped"; for (j = 1; j <= 500; j++) printf " %d %d", (rand() < pa[j]) ? 1 : 2, (rand() < pa[j]) ? 1 : 2 > "t.ped"; printf "\n" > "t.ped" }' && admixture --supervised d.ped 2 > sup.log 2>&1 && cp d.2.P t.2.P.in && admixture -P t.ped 2 > proj.log 2>&1	contains "the supervised run on two planted groups converged" sup.log "Converged"; between "the projected person's share of the group it was drawn from" "$(awk '{print ($1 > $2 ? $1 : $2)}' t.2.Q)" 0.9 1
 BEAGLE_IMAGE	-	-	awk 'BEGIN { srand(3); h = "##fileformat=VCFv4.2\n##contig=<ID=chr20,length=64444167>\n##FORMAT=<ID=GT,Number=1,Type=String,Description=\"Genotype\">\n#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT"; printf "%s", h > "r.vcf"; for (i = 1; i <= 50; i++) printf "\tR%d", i > "r.vcf"; printf "\n" > "r.vcf"; printf "%s\tT\n", h > "t.vcf"; for (j = 1; j <= 300; j++) { printf "chr20\t%d\t.\tA\tG\t.\tPASS\t.\tGT", j * 1000 > "r.vcf"; for (i = 1; i <= 50; i++) printf "\t%d|%d", (rand() < 0.5), (rand() < 0.5) > "r.vcf"; printf "\n" > "r.vcf"; a = rand() < 0.5; b = rand() < 0.5; printf "chr20\t%d\t.\tA\tG\t.\tPASS\t.\tGT\t%d/%d\n", j * 1000, (a < b ? a : b), (a < b ? b : a) > "t.vcf" } }' && beagle gt=t.vcf ref=r.vcf out=o impute=false seed=1 nthreads=2 > beagle.log 2>&1	at_least "target genotypes Beagle returns phased" "$(gzip -dc o.vcf.gz | grep -v '^#' | grep -c '[01]|[01]')" 300; contains "Beagle finished" beagle.log "finished"
 MOCHA_IMAGE	-	ref	{ bcftools +mocha > usage.txt 2>&1 || true; } && awk 'BEGIN { print "##fileformat=VCFv4.2"; print "##contig=<ID=chr20,length=503000>"; print "##FORMAT=<ID=GT,Number=1,Type=String,Description=\"Genotype\">"; print "##FORMAT=<ID=AD,Number=R,Type=Integer,Description=\"Allelic depths\">"; printf "#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tHG002\n"; for (i = 1; i <= 100; i++) printf "chr20\t%d\t.\tA\tG\t.\tPASS\t.\tGT:AD\t0|1\t15,15\n", i * 4000 }' > v.vcf && bcftools +mochatools --no-version -Ov -o gc.vcf v.vcf -- -t GC -f /in/mini.fa	contains "the plugin prints the version MOCHA_VERSION pins" usage.txt "version ${MOCHA_VERSION}"; same "records mochatools gave a GC content from the reference" "$(grep -v '^#' gc.vcf | grep -c 'GC=0[.][0-9]')" 100
 # A planted query whose first half is drawn from POPA's frequencies and second half from POPB's.
-RFMIX_IMAGE	-	-	awk 'BEGIN { srand(5); h = "##fileformat=VCFv4.2\n##contig=<ID=chr20,length=64444167>\n##FORMAT=<ID=GT,Number=1,Type=String,Description=\"Genotype\">\n#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT"; printf "%s", h > "r.vcf"; for (i = 1; i <= 60; i++) { printf "\tR%d", i > "r.vcf"; print "R" i "\t" (i <= 30 ? "POPA" : "POPB") > "map.tsv" }; printf "\n" > "r.vcf"; printf "%s\tQ\n", h > "q.vcf"; for (j = 1; j <= 2000; j++) { pos = j * 10000; pa = 0.05 + 0.9 * rand(); pb = 1 - pa; printf "chr20\t%d\t.\tA\tG\t.\tPASS\t.\tGT", pos > "r.vcf"; for (i = 1; i <= 60; i++) { p = (i <= 30) ? pa : pb; printf "\t%d|%d", (rand() < p), (rand() < p) > "r.vcf" }; printf "\n" > "r.vcf"; p = (j <= 1000) ? pa : pb; printf "chr20\t%d\t.\tA\tG\t.\tPASS\t.\tGT\t%d|%d\n", pos, (rand() < p), (rand() < p) > "q.vcf"; printf "chr20\t%d\t%.4f\n", pos, pos / 1000000 > "g.map" } }' && rfmix -f q.vcf -r r.vcf -m map.tsv -g g.map -o o --chromosome=chr20 --n-threads=2 --random-seed=1 > rfmix.log 2>&1	py "RFMix paints the planted halves POPA then POPB" "import sys; rows = [l.split() for l in open('o.msp.tsv') if not l.startswith('#')]; codes = dict(x.split('=') for x in open('o.msp.tsv').readline().split(':', 1)[1].split()); at = lambda p: next((r[6:8] for r in rows if int(r[1]) <= p < int(r[2])), None); print(len(rows), 'windows', at(5000000), 'at 5 Mb and', at(15000000), 'at 15 Mb'); assert at(5000000) == [codes['POPA']] * 2 and at(15000000) == [codes['POPB']] * 2"
+RFMIX_IMAGE	-	-	awk 'BEGIN { srand(5); h = "##fileformat=VCFv4.2\n##contig=<ID=chr20,length=64444167>\n##FORMAT=<ID=GT,Number=1,Type=String,Description=\"Genotype\">\n#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT"; printf "%s", h > "r.vcf"; for (i = 1; i <= 60; i++) { printf "\tR%d", i > "r.vcf"; print "R" i "\t" (i <= 30 ? "POPA" : "POPB") > "map.tsv" }; printf "\n" > "r.vcf"; printf "%s\tQ\n", h > "q.vcf"; for (j = 1; j <= 2000; j++) { pos = j * 10000; pa = 0.05 + 0.9 * rand(); pb = 1 - pa; printf "chr20\t%d\t.\tA\tG\t.\tPASS\t.\tGT", pos > "r.vcf"; for (i = 1; i <= 60; i++) { p = (i <= 30) ? pa : pb; printf "\t%d|%d", (rand() < p), (rand() < p) > "r.vcf" }; printf "\n" > "r.vcf"; p = (j <= 1000) ? pa : pb; printf "chr20\t%d\t.\tA\tG\t.\tPASS\t.\tGT\t%d|%d\n", pos, (rand() < p), (rand() < p) > "q.vcf"; printf "chr20\t%d\t%.4f\n", pos, pos / 1000000 > "g.map" } }' && rfmix -f q.vcf -r r.vcf -m map.tsv -g g.map -o o --chromosome=chr20 --n-threads=2 --random-seed=1 > rfmix.log 2>&1	smoke_check "RFMix paints the planted halves POPA then POPB" rfmix o.msp.tsv
 # Step 43: one person with a planted 600 kb stretch carrying the Altai allele, against 100 stand-ins at the 1000 Genomes count.
-IBDMIX_IMAGE	-	-	awk 'BEGIN { srand(9); h = "chrom\tpos\tref\talt\tAltai\tS"; for (i = 1; i <= 100; i++) h = h sprintf("\tP%03d", i); print h > "g.txt"; print "S" > "s.txt"; for (i = 1; i <= 100; i++) printf "P%03d\n", i > "s.txt"; for (j = 0; j < 4000; j++) { pos = 1000000 + j * 1000; if (j % 2 == 0) { f = 0.02; a = 2; ac = 4 } else { f = 0.1 + 0.8 * rand(); a = (rand() < f) + (rand() < f); ac = int(f * 200 + 0.5) }; g = (rand() < f) + (rand() < f); if (j % 2 == 0 && pos >= 2000000 && pos < 2600000) g = 1; line = "22\t" pos "\tA\tG\t" a "\t" g; for (i = 1; i <= 100; i++) line = line "\t" (i <= int(ac / 2) ? 2 : (i == int(ac / 2) + 1 && ac % 2 ? 1 : 0)); print line > "g.txt" } }' && ibdmix -g g.txt -s s.txt -n Altai -o o.txt -d 4 -m 1 -a 0.01 -e 0.002 -c 2 > ibdmix.log 2>&1	py "IBDmix finds the planted 600 kb Altai stretch and nothing else" "rows = [l.split() for l in open('o.txt')][1:]; s = [r for r in rows if r[0] == 'S' and float(r[4]) >= 4 and int(r[3]) - int(r[2]) >= 50000]; cov = sum(max(0, min(int(r[3]), 2600000) - max(int(r[2]), 2000000)) for r in s); out = [r for r in s if int(r[3]) <= 2000000 or int(r[2]) >= 2600000]; print(len(s), 'segments,', cov, 'bp of the planted stretch,', len(out), 'outside'); assert cov >= 540000 and not out"
+IBDMIX_IMAGE	-	-	awk 'BEGIN { srand(9); h = "chrom\tpos\tref\talt\tAltai\tS"; for (i = 1; i <= 100; i++) h = h sprintf("\tP%03d", i); print h > "g.txt"; print "S" > "s.txt"; for (i = 1; i <= 100; i++) printf "P%03d\n", i > "s.txt"; for (j = 0; j < 4000; j++) { pos = 1000000 + j * 1000; if (j % 2 == 0) { f = 0.02; a = 2; ac = 4 } else { f = 0.1 + 0.8 * rand(); a = (rand() < f) + (rand() < f); ac = int(f * 200 + 0.5) }; g = (rand() < f) + (rand() < f); if (j % 2 == 0 && pos >= 2000000 && pos < 2600000) g = 1; line = "22\t" pos "\tA\tG\t" a "\t" g; for (i = 1; i <= 100; i++) line = line "\t" (i <= int(ac / 2) ? 2 : (i == int(ac / 2) + 1 && ac % 2 ? 1 : 0)); print line > "g.txt" } }' && ibdmix -g g.txt -s s.txt -n Altai -o o.txt -d 4 -m 1 -a 0.01 -e 0.002 -c 2 > ibdmix.log 2>&1	smoke_check "IBDmix finds the planted 600 kb Altai stretch and nothing else" ibdmix o.txt
 # setup.sh --ancestry-fine-panel reads gnomAD's bucket with it; the row depends on storage.googleapis.com being up.
 BCFTOOLS_HTTPS_IMAGE	net	-	bcftools query -l https://storage.googleapis.com/gcp-public-data--gnomad/resources/hgdp_1kg/phased_haplotypes_v2/hgdp1kgp_chr22.filtered.SNV_INDEL.phased.shapeit5.bcf 2>/dev/null > samples.txt && bcftools view -H -r chr22:20000000-20010000 https://storage.googleapis.com/gcp-public-data--gnomad/resources/hgdp_1kg/phased_haplotypes_v2/hgdp1kgp_chr22.filtered.SNV_INDEL.phased.shapeit5.bcf 2>/dev/null | wc -l > n.txt && bcftools plugin -l > plugins.txt	same "people in the panel's chr22 file, read over https" "$(wc -l < samples.txt | tr -d ' ')" 4091; at_least "records of a 10 kb region read through the remote index" "$(tr -d ' ' < n.txt)" 100; contains "the prune plugin setup.sh thins and LD-prunes with" plugins.txt "^prune$"
 # pgsc_calc's images (steps 25 and 26). pgscatalog-format writes the custom GRCh38 file step 25's og prs format makes as pgsc_calc's first step does; the other commands pgsc_calc calls must exist.
@@ -90,5 +90,5 @@ VCFANNO_IMAGE	-	vcf,revel	vcfanno -p 2 /smoke/vcfanno.toml /in/sample.vcf.gz > v
 SLIVAR_IMAGE	-	vcf	sh /smoke/slivar.sh	contains "compound-hets as step 31 calls it writes a VCF" step31.vcf "^#CHROM"; at_least "records in a compound-het pair" "$(grep -v "^#" comphet.vcf | grep -c "slivar_comphet=")" 2
 # EIGENSOFT (step 44): smartpca builds PC1 from two made-up groups and projects a third sample (lsqproject).
 # The sites sit on two chromosomes with genetic positions (Morgans): smartpca's jackknife needs more than one block.
-EIGENSOFT_IMAGE	-	-	awk 'BEGIN { srand(1); for (s = 1; s <= 300; s++) { printf "rs%d %d %.3f %d A G\n", s, (s <= 150 ? 1 : 2), s * 0.002, s * 1000 > "t.snp"; l = ""; for (i = 1; i <= 20; i++) { p = (i <= 10) ? 0.15 : 0.85; l = l ((rand() < p) + (rand() < p)) } print l ((rand() < 0.15) + (rand() < 0.15)) > "t.geno" } for (i = 1; i <= 20; i++) printf "I%d U %s\n", i, (i <= 10 ? "PopA" : "PopB") > "t.ind"; print "X1 U Proj" > "t.ind"; print "PopA" > "pop.txt"; print "PopB" > "pop.txt" }' && printf 'genotypename: t.geno\nsnpname: t.snp\nindivname: t.ind\npoplistname: pop.txt\nevecoutname: t.evec\nevaloutname: t.eval\nlsqproject: YES\nnumoutevec: 2\nnumoutlieriter: 0\n' > t.par && smartpca -p t.par > smartpca.log	same "rows in the .evec, 20 that build the axes and 1 projected" "$(grep -vc '^ *#' t.evec)" 21; py "PC1 separates the two groups and puts the projected sample (drawn like PopA) with PopA" "r = [l.split() for l in open('t.evec') if not l.lstrip().startswith('#')]; a = [float(x[1]) for x in r if x[-1] == 'PopA']; b = [float(x[1]) for x in r if x[-1] == 'PopB']; p = [float(x[1]) for x in r if x[-1] == 'Proj'][0]; ma, mb = sum(a) / len(a), sum(b) / len(b); print(ma, mb, p); assert max(a) < min(b) or min(a) > max(b); assert abs(p - ma) < abs(p - mb)"
+EIGENSOFT_IMAGE	-	-	awk 'BEGIN { srand(1); for (s = 1; s <= 300; s++) { printf "rs%d %d %.3f %d A G\n", s, (s <= 150 ? 1 : 2), s * 0.002, s * 1000 > "t.snp"; l = ""; for (i = 1; i <= 20; i++) { p = (i <= 10) ? 0.15 : 0.85; l = l ((rand() < p) + (rand() < p)) } print l ((rand() < 0.15) + (rand() < 0.15)) > "t.geno" } for (i = 1; i <= 20; i++) printf "I%d U %s\n", i, (i <= 10 ? "PopA" : "PopB") > "t.ind"; print "X1 U Proj" > "t.ind"; print "PopA" > "pop.txt"; print "PopB" > "pop.txt" }' && printf 'genotypename: t.geno\nsnpname: t.snp\nindivname: t.ind\npoplistname: pop.txt\nevecoutname: t.evec\nevaloutname: t.eval\nlsqproject: YES\nnumoutevec: 2\nnumoutlieriter: 0\n' > t.par && smartpca -p t.par > smartpca.log	same "rows in the .evec, 20 that build the axes and 1 projected" "$(grep -vc '^ *#' t.evec)" 21; smoke_check "PC1 separates the groups and puts the projected sample with PopA" eigen t.evec
 EXOMISER_IMAGE	-	-	exomiser analyse --help > analyse.txt 2>&1; java -version > java.txt 2>&1; true	contains "exomiser analyse starts and lists --analysis, the option step 48 passes" analyse.txt "--analysis"; at_least "the image's Java runs (major version)" "$(grep -oE 'version "[0-9]+' java.txt | grep -oE '[0-9]+$' | head -n 1)" 17

From 4c2ac36a570fa58cb2fc4c757bc5f6dd086977c3 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 14:53:53 +0100
Subject: [PATCH 31/76] test(ci): prove the migrated readers against archived
 controls

Bead: pgp-bs9u.38
---
 .github/workflows/nextflow.yml                |   4 +-
 rust/crates/og-dev/src/smoke.rs               | 113 ++++++++++++++----
 rust/crates/og-dev/tests/ci_readers.rs        |   4 +-
 scripts/ci/e2e-case-paths.tsv                 |   2 +-
 tests/parity/cases.tsv                        |  14 +++
 tests/parity/gen/ci-pharmcat.sh               |   4 +
 .../golden/dev-pharmcat-called/truncated/exit |   1 +
 .../dev-pharmcat-called/truncated/stderr      |   1 +
 .../golden/dev-smoke-check/eigen/stdout       |   1 +
 .../golden/dev-smoke-check/hap-ibd/stdout     |   1 +
 .../golden/dev-smoke-check/ibdmix/stdout      |   1 +
 .../golden/dev-smoke-check/parascopy/stdout   |   1 +
 .../golden/dev-smoke-check/rfmix/stdout       |   1 +
 tests/parity/inputs/ci-readers/o.ibd          |   1 +
 tests/parity/inputs/ci-readers/o.msp.tsv      |   4 +
 tests/parity/inputs/ci-readers/o.txt          |   2 +
 tests/parity/inputs/ci-readers/oracle.sh      |  27 ++++-
 tests/parity/inputs/ci-readers/smn.tsv        |   1 +
 tests/parity/inputs/ci-readers/t.evec         |   4 +
 tests/parity/oracle.ref                       |   1 +
 tests/test_ci_readers.sh                      |  14 +++
 21 files changed, 169 insertions(+), 33 deletions(-)
 create mode 100755 tests/parity/gen/ci-pharmcat.sh
 create mode 100644 tests/parity/golden/dev-pharmcat-called/truncated/exit
 create mode 100644 tests/parity/golden/dev-pharmcat-called/truncated/stderr
 create mode 100644 tests/parity/golden/dev-smoke-check/eigen/stdout
 create mode 100644 tests/parity/golden/dev-smoke-check/hap-ibd/stdout
 create mode 100644 tests/parity/golden/dev-smoke-check/ibdmix/stdout
 create mode 100644 tests/parity/golden/dev-smoke-check/parascopy/stdout
 create mode 100644 tests/parity/golden/dev-smoke-check/rfmix/stdout
 create mode 100644 tests/parity/inputs/ci-readers/o.ibd
 create mode 100644 tests/parity/inputs/ci-readers/o.msp.tsv
 create mode 100644 tests/parity/inputs/ci-readers/o.txt
 create mode 100644 tests/parity/inputs/ci-readers/smn.tsv
 create mode 100644 tests/parity/inputs/ci-readers/t.evec
 create mode 100755 tests/test_ci_readers.sh

diff --git a/.github/workflows/nextflow.yml b/.github/workflows/nextflow.yml
index d4aaf9022..4e80b740c 100644
--- a/.github/workflows/nextflow.yml
+++ b/.github/workflows/nextflow.yml
@@ -119,8 +119,8 @@ jobs:
       - name: Validate nextflow_schema.json and the samplesheet schema
         if: steps.scope.outputs.run == 'true'
         run: |
-          jq empty nextflow_schema.json > /dev/null
-          jq empty assets/schema_input.json > /dev/null
+          jq -s -e 'length == 1' nextflow_schema.json > /dev/null
+          jq -s -e 'length == 1' assets/schema_input.json > /dev/null
 
       # The stub run below pulls every image of the default tools: the pinned
       # leg ran out of disk in it twice on 2026-11-05 (#300, job 127077180393;
diff --git a/rust/crates/og-dev/src/smoke.rs b/rust/crates/og-dev/src/smoke.rs
index 41d2c80b8..379b1d7be 100644
--- a/rust/crates/og-dev/src/smoke.rs
+++ b/rust/crates/og-dev/src/smoke.rs
@@ -1,6 +1,6 @@
 //! Small, local smoke fixtures and table checks. No subprocess or network.
 use og_io::{AtomicFile, Lines, Utf8};
-use pycompat::csv::{DictReader, Quoting};
+use pycompat::csv::{DictReader, Quoting, Reader};
 use std::io::Write;
 
 fn lines(path: &str) -> Result<Lines<Box<dyn std::io::BufRead>>, String> {
@@ -27,6 +27,9 @@ fn fasta(path: &str) -> Result<Vec<u8>, String> {
     for line in lines(path)? {
         let line = line.map_err(|e| e.to_string())?;
         if !line.starts_with('>') {
+            if seq.len().saturating_add(line.trim().len()) > 1_003_000 {
+                return Err("smoke reference exceeds 1003000 bases".into());
+            }
             seq.extend(line.trim().bytes().map(|b| b.to_ascii_uppercase()));
         }
     }
@@ -157,7 +160,10 @@ fn csv_cell(args: &[String], out: &mut dyn Write) -> Result<(), String> {
     for row in DictReader::new(csv_lines(&args[0])?, ',', Quoting::Minimal) {
         let row = row.map_err(|e| e.to_string())?;
         if want.iter().all(|(k, v)| row.get(k) == Some(Some(v))) {
-            let val = row.get(&args[2]).flatten().ok_or("missing CSV column")?;
+            let val = row
+                .get(&args[2])
+                .ok_or("missing CSV column")?
+                .unwrap_or("None");
             writeln!(out, "{val}").map_err(|e| e.to_string())?;
             break;
         }
@@ -170,17 +176,90 @@ fn fields(line: &str) -> Vec<&str> {
 fn float(s: Option<&&str>) -> Result<f64, String> {
     pycompat::num::parse_float(s.ok_or("short table row")?).map_err(|e| e.to_string())
 }
+#[derive(Default)]
+struct PcaGroup {
+    n: usize,
+    first: f64,
+    min: f64,
+    max: f64,
+    sum: f64,
+    correction: f64,
+}
+impl PcaGroup {
+    fn add(&mut self, x: f64) {
+        if self.n == 0 {
+            self.first = x;
+            self.min = x;
+            self.max = x;
+        }
+        // Python's min/max keep the first element when a comparison is
+        // unordered (NaN), unlike f64::min/max, which skip NaN.
+        if x < self.min {
+            self.min = x;
+        }
+        if x > self.max {
+            self.max = x;
+        }
+        let t = self.sum + x;
+        self.correction += if self.sum.abs() >= x.abs() {
+            (self.sum - t) + x
+        } else {
+            (x - t) + self.sum
+        };
+        self.sum = t;
+        self.n += 1;
+    }
+    fn mean(&self) -> f64 {
+        (self.sum
+            + if self.correction != 0. && self.correction.is_finite() {
+                self.correction
+            } else {
+                0.
+            })
+            / self.n as f64
+    }
+}
+fn parascopy(path: &str, out: &mut dyn Write) -> Result<bool, String> {
+    let mut found = false;
+    let mut n = 0;
+    for row in Reader::new(csv_lines(path)?, '\t', Quoting::Minimal) {
+        let row = row.map_err(|e| e.to_string())?;
+        if row.is_empty() || row[0].starts_with('#') {
+            continue;
+        }
+        if row.len() < 8 {
+            return Err("short Parascopy row".into());
+        }
+        found |= row[0] == "chr5"
+            && !["", "*"].contains(&row[6].as_str())
+            && !["", "*"].contains(&row[7].as_str());
+        n += 1;
+    }
+    writeln!(
+        out,
+        "parascopy: {n} rows; {}",
+        if found { "OK" } else { "FAIL" }
+    )
+    .map_err(|e| e.to_string())?;
+    Ok(found)
+}
 fn check(kind: &str, path: &str, out: &mut dyn Write) -> Result<bool, String> {
+    if kind == "parascopy" {
+        return parascopy(path, out);
+    }
     // The windows keep only their first covering row, matching Python's next().
     let mut n = 0;
     let mut ab = 0;
     let mut ab_len = 0.;
     let mut coverage = 0.;
     let mut outside = 0;
-    let mut groups = [Vec::new(), Vec::new(), Vec::new()];
+    let mut groups = [
+        PcaGroup::default(),
+        PcaGroup::default(),
+        PcaGroup::default(),
+    ];
     let mut codes = std::collections::BTreeMap::new();
     let mut at = [None, None];
-    let mut aggregate = false;
     for (i, line) in lines(path)?.enumerate() {
         let line = line.map_err(|e| e.to_string())?;
         let r = fields(&line);
@@ -222,7 +301,7 @@ fn check(kind: &str, path: &str, out: &mut dyn Write) -> Result<bool, String> {
                     Some(&"Proj") => 2,
                     _ => continue,
                 };
-                groups[g].push(float(r.get(1))?);
+                groups[g].add(float(r.get(1))?);
             }
             "rfmix" => {
                 if i == 0 {
@@ -251,17 +330,6 @@ fn check(kind: &str, path: &str, out: &mut dyn Write) -> Result<bool, String> {
                     }
                 }
             }
-            "parascopy" => {
-                if r.is_empty() || r[0].starts_with('#') {
-                    continue;
-                }
-                if r.len() < 8 {
-                    return Err("short Parascopy row".into());
-                }
-                aggregate |=
-                    r[0] == "chr5" && !["", "*"].contains(&r[6]) && !["", "*"].contains(&r[7]);
-                n += 1;
-            }
             _ => return Err(format!("unknown smoke check {kind}")),
         }
     }
@@ -269,26 +337,19 @@ fn check(kind: &str, path: &str, out: &mut dyn Write) -> Result<bool, String> {
         "hap-ibd" => n == 1 && ab == 1 && (8. ..=11.).contains(&ab_len),
         "ibdmix" => coverage >= 540000. && outside == 0,
         "eigen" => {
-            if groups.iter().any(Vec::is_empty) {
+            if groups.iter().any(|g| g.n == 0) {
                 return Err("missing PCA group".into());
             }
             let a = &groups[0];
             let b = &groups[1];
-            let p = groups[2][0];
-            let ma = pycompat::num::sum(a.iter().copied()) / a.len() as f64;
-            let mb = pycompat::num::sum(b.iter().copied()) / b.len() as f64;
-            (a.iter().copied().fold(f64::NEG_INFINITY, f64::max)
-                < b.iter().copied().fold(f64::INFINITY, f64::min)
-                || a.iter().copied().fold(f64::INFINITY, f64::min)
-                    > b.iter().copied().fold(f64::NEG_INFINITY, f64::max))
-                && (p - ma).abs() < (p - mb).abs()
+            let p = groups[2].first;
+            (a.max < b.min || a.min > b.max) && (p - a.mean()).abs() < (p - b.mean()).abs()
         }
         "rfmix" => ["POPA", "POPB"].iter().enumerate().all(|(i, p)| {
             codes
                 .get(*p)
                 .is_some_and(|c| at[i].as_ref() == Some(&[c.clone(), c.clone()]))
         }),
-        "parascopy" => aggregate,
         _ => false,
     };
     writeln!(out, "{kind}: {n} rows; {}", if ok { "OK" } else { "FAIL" })
diff --git a/rust/crates/og-dev/tests/ci_readers.rs b/rust/crates/og-dev/tests/ci_readers.rs
index 72b8f8db8..25e452502 100644
--- a/rust/crates/og-dev/tests/ci_readers.rs
+++ b/rust/crates/og-dev/tests/ci_readers.rs
@@ -219,8 +219,8 @@ fn smoke_tables_reject_removed_properties() {
         ),
         (
             "parascopy",
-            "chr5 1 2 a b c 4 99\n",
-            "chr5 1 2 a b c * 99\n",
+            "chr5\t1\t2\ta\tb\tc\t4\t99\n",
+            "chr5\t1\t2\ta\tb\tc\t*\t99\n",
         ),
     ] {
         let p = t.file("table", good);
diff --git a/scripts/ci/e2e-case-paths.tsv b/scripts/ci/e2e-case-paths.tsv
index 0faa36c6f..145392ffb 100644
--- a/scripts/ci/e2e-case-paths.tsv
+++ b/scripts/ci/e2e-case-paths.tsv
@@ -178,4 +178,4 @@ vntyper-1	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.t
 y-private-report-1-private-and-tree	assets/live/index.html assets/viewer/index.html bin/collect_summary.py bin/og bin/render_report.py bin/results_index.py bin/run_delta.py bin/traits_report.py bin/yleaf_run.py modules/local/html_report/* modules/local/y_haplogroup/* scripts/16-indexcov.sh scripts/24-html-report.sh scripts/37-y-haplogroup.sh scripts/generate-report.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh
 y-str-1	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/live/index.html assets/mito_confirmed.tsv assets/stub/sample.vcf.gz assets/viewer/index.html assets/ystr_panel.tsv bin/collect_summary.py bin/og bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/html_report/* modules/local/indexcov/* modules/local/vcf_precheck/* modules/local/y_str/* scripts/16-indexcov.sh scripts/24-html-report.sh scripts/45-y-str.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 y-tree-current-1-placement	assets/live/index.html assets/viewer/index.html bin/og bin/yleaf_run.py scripts/16-indexcov.sh scripts/37-y-haplogroup.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh
-rust-z2e-readers	rust/crates/og-dev/src/pharmcat.rs rust/crates/og-dev/src/nf_trace.rs rust/crates/og-dev/src/smoke.rs tests/e2e/lib.sh scripts/ci/image-smoke.sh scripts/ci/nf-trace-requests.tsv
+rust-z2e-readers	bin/og tests/e2e/lib.sh scripts/ci/image-smoke.sh scripts/ci/nf-trace-requests.tsv
diff --git a/tests/parity/cases.tsv b/tests/parity/cases.tsv
index 98a436f8d..04f0538e9 100644
--- a/tests/parity/cases.tsv
+++ b/tests/parity/cases.tsv
@@ -966,3 +966,17 @@ dev-nf-attempts	retry	ci-readers/oracle.sh,ci-readers/attempts.tsv	attempts.tsv
 dev-smoke-mini	fixture	ci-readers/oracle.sh,gen:ci-smoke.sh	slice.fa orig.fa mini.fa 450000 3000	orig.fa,mini.fa	bytes	PYTHON_IMAGE
 dev-smoke-long	fixture	ci-readers/oracle.sh,gen:ci-smoke.sh	hap1.fa hap2.fa long.fq.gz	long.fq.gz	gz-content	PYTHON_IMAGE
 dev-smoke-catalog	fixture	ci-readers/oracle.sh,gen:ci-smoke.sh	slice.fa eh.json 449000	eh.json	json	PYTHON_IMAGE
+dev-smoke-check	hap-ibd	ci-readers/oracle.sh,ci-readers/o.ibd	hap-ibd o.ibd	-	bytes	PYTHON_IMAGE
+dev-smoke-check	ibdmix	ci-readers/oracle.sh,ci-readers/o.txt	ibdmix o.txt	-	bytes	PYTHON_IMAGE
+dev-smoke-check	rfmix	ci-readers/oracle.sh,ci-readers/o.msp.tsv	rfmix o.msp.tsv	-	bytes	PYTHON_IMAGE
+dev-smoke-check	eigen	ci-readers/oracle.sh,ci-readers/t.evec	eigen t.evec	-	bytes	PYTHON_IMAGE
+dev-smoke-check	parascopy	ci-readers/oracle.sh,ci-readers/smn.tsv	parascopy smn.tsv	-	bytes	PYTHON_IMAGE
+dev-pharmcat	report-3.2.0	ci-readers/oracle.sh,gen:ci-pharmcat.sh	report-3.2.0.json	-	bytes	PYTHON_IMAGE
+dev-pharmcat	report-3.4.0	ci-readers/oracle.sh,gen:ci-pharmcat.sh	report-3.4.0.json	-	bytes	PYTHON_IMAGE
+dev-pharmcat	pharmcat-docs-example	ci-readers/oracle.sh,gen:ci-pharmcat.sh	pharmcat-docs-example.json	-	bytes	PYTHON_IMAGE
+dev-pharmcat-called	report-3.2.0	ci-readers/oracle.sh,gen:ci-pharmcat.sh	report-3.2.0.json --called	-	bytes	PYTHON_IMAGE
+dev-pharmcat-called	report-3.4.0	ci-readers/oracle.sh,gen:ci-pharmcat.sh	report-3.4.0.json --called	-	bytes	PYTHON_IMAGE
+dev-pharmcat-called	pharmcat-docs-example	ci-readers/oracle.sh,gen:ci-pharmcat.sh	pharmcat-docs-example.json --called	-	bytes	PYTHON_IMAGE
+dev-pharmcat-lines	report-3.2.0	ci-readers/oracle.sh,gen:ci-pharmcat.sh	report-3.2.0.json --called-lines	-	bytes	PYTHON_IMAGE
+dev-pharmcat-lines	report-3.4.0	ci-readers/oracle.sh,gen:ci-pharmcat.sh	report-3.4.0.json --called-lines	-	bytes	PYTHON_IMAGE
+dev-pharmcat-lines	pharmcat-docs-example	ci-readers/oracle.sh,gen:ci-pharmcat.sh	pharmcat-docs-example.json --called-lines	-	bytes	PYTHON_IMAGE
diff --git a/tests/parity/gen/ci-pharmcat.sh b/tests/parity/gen/ci-pharmcat.sh
new file mode 100755
index 000000000..96abbd1b4
--- /dev/null
+++ b/tests/parity/gen/ci-pharmcat.sh
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+ROOT=$(cd "$(dirname "${BASH_SOURCE[0]}")/../../.." && pwd)
+cp "$ROOT"/tests/fixtures/pharmcat/report-3.2.0.json "$ROOT"/tests/fixtures/pharmcat/report-3.4.0.json "$ROOT"/tests/fixtures/pharmcat/pharmcat-docs-example.json .
diff --git a/tests/parity/golden/dev-pharmcat-called/truncated/exit b/tests/parity/golden/dev-pharmcat-called/truncated/exit
new file mode 100644
index 000000000..0cfbf0888
--- /dev/null
+++ b/tests/parity/golden/dev-pharmcat-called/truncated/exit
@@ -0,0 +1 @@
+2
diff --git a/tests/parity/golden/dev-pharmcat-called/truncated/stderr b/tests/parity/golden/dev-pharmcat-called/truncated/stderr
new file mode 100644
index 000000000..419989349
--- /dev/null
+++ b/tests/parity/golden/dev-pharmcat-called/truncated/stderr
@@ -0,0 +1 @@
+unreadable report: Expecting value: byte 9
diff --git a/tests/parity/golden/dev-smoke-check/eigen/stdout b/tests/parity/golden/dev-smoke-check/eigen/stdout
new file mode 100644
index 000000000..112b6bd29
--- /dev/null
+++ b/tests/parity/golden/dev-smoke-check/eigen/stdout
@@ -0,0 +1 @@
+eigen: 0 rows; OK
diff --git a/tests/parity/golden/dev-smoke-check/hap-ibd/stdout b/tests/parity/golden/dev-smoke-check/hap-ibd/stdout
new file mode 100644
index 000000000..efcc52c8d
--- /dev/null
+++ b/tests/parity/golden/dev-smoke-check/hap-ibd/stdout
@@ -0,0 +1 @@
+hap-ibd: 1 rows; OK
diff --git a/tests/parity/golden/dev-smoke-check/ibdmix/stdout b/tests/parity/golden/dev-smoke-check/ibdmix/stdout
new file mode 100644
index 000000000..062ef2efc
--- /dev/null
+++ b/tests/parity/golden/dev-smoke-check/ibdmix/stdout
@@ -0,0 +1 @@
+ibdmix: 1 rows; OK
diff --git a/tests/parity/golden/dev-smoke-check/parascopy/stdout b/tests/parity/golden/dev-smoke-check/parascopy/stdout
new file mode 100644
index 000000000..dcdac7a2a
--- /dev/null
+++ b/tests/parity/golden/dev-smoke-check/parascopy/stdout
@@ -0,0 +1 @@
+parascopy: 1 rows; OK
diff --git a/tests/parity/golden/dev-smoke-check/rfmix/stdout b/tests/parity/golden/dev-smoke-check/rfmix/stdout
new file mode 100644
index 000000000..550866716
--- /dev/null
+++ b/tests/parity/golden/dev-smoke-check/rfmix/stdout
@@ -0,0 +1 @@
+rfmix: 2 rows; OK
diff --git a/tests/parity/inputs/ci-readers/o.ibd b/tests/parity/inputs/ci-readers/o.ibd
new file mode 100644
index 000000000..2d1547c47
--- /dev/null
+++ b/tests/parity/inputs/ci-readers/o.ibd
@@ -0,0 +1 @@
+A 1 B 1 20 1 10000000 10
diff --git a/tests/parity/inputs/ci-readers/o.msp.tsv b/tests/parity/inputs/ci-readers/o.msp.tsv
new file mode 100644
index 000000000..91c77f4bc
--- /dev/null
+++ b/tests/parity/inputs/ci-readers/o.msp.tsv
@@ -0,0 +1,4 @@
+#codes: POPA=0 POPB=1
+#h
+20 0 10000000 0 0 0 0 0
+20 10000000 20000000 0 0 0 1 1
diff --git a/tests/parity/inputs/ci-readers/o.txt b/tests/parity/inputs/ci-readers/o.txt
new file mode 100644
index 000000000..a153febf0
--- /dev/null
+++ b/tests/parity/inputs/ci-readers/o.txt
@@ -0,0 +1,2 @@
+h
+S 22 2000000 2600000 4
diff --git a/tests/parity/inputs/ci-readers/oracle.sh b/tests/parity/inputs/ci-readers/oracle.sh
index eeb13677e..a5c238164 100644
--- a/tests/parity/inputs/ci-readers/oracle.sh
+++ b/tests/parity/inputs/ci-readers/oracle.sh
@@ -2,6 +2,27 @@
 # Extract the archived heredoc, not a second maintained implementation.
 set -euo pipefail
 mode=$1 prog=$2; shift 2
+if [ "$mode" = check ]; then
+  kind=$1
+  case "$kind" in
+    hap-ibd) var=HAP_IBD_IMAGE; gzip -c o.ibd > o.ibd.gz ;;
+    ibdmix) var=IBDMIX_IMAGE ;;
+    rfmix) var=RFMIX_IMAGE ;;
+    eigen) var=EIGENSOFT_IMAGE ;;
+    parascopy) var=PARASCOPY_IMAGE ;;
+    *) exit 2 ;;
+  esac
+  expect=$(awk -F '\t' -v v="$var" '$1 == v { print $5 }' "$prog")
+  [ -n "$expect" ] || exit 2
+  # Compare the assertions, not their debug dumps. The Rust diagnostics
+  # have explicit goldens; a failed Python assertion still fails the case.
+  py() { python3 -I -c "$2" > /dev/null; }
+  same() { :; }
+  at_least() { :; }
+  eval "$expect"
+  [ "$kind" != hap-ibd ] || rm -f o.ibd.gz
+  exit 0
+fi
 case "$mode" in
   diplotypes) start='^import json, sys$' ;;
   called-lines) start='^import json, sys$' ;;
@@ -17,8 +38,10 @@ esac
 # The workflow's first inline reader is requests, the second is attempts.
 occurrence=1
 [ "$mode" != attempts ] || occurrence=2
-awk -v re="$start" -v want="$occurrence" '
-  { sub(/^          /, "") }
+indent=0
+case "$mode" in requests|attempts) indent=1 ;; esac
+awk -v re="$start" -v want="$occurrence" -v indent="$indent" '
+  { if (indent) sub(/^          /, "") }
   $0 ~ re { n++; if (n == want) on=1 }
   on && /^PY$/ { exit }
   on { print }
diff --git a/tests/parity/inputs/ci-readers/smn.tsv b/tests/parity/inputs/ci-readers/smn.tsv
new file mode 100644
index 000000000..cc8e41ff4
--- /dev/null
+++ b/tests/parity/inputs/ci-readers/smn.tsv
@@ -0,0 +1 @@
+chr5	1	2	a	b	c	4	99
diff --git a/tests/parity/inputs/ci-readers/t.evec b/tests/parity/inputs/ci-readers/t.evec
new file mode 100644
index 000000000..b0b52a5e7
--- /dev/null
+++ b/tests/parity/inputs/ci-readers/t.evec
@@ -0,0 +1,4 @@
+#h
+a -2 0 PopA
+b 2 0 PopB
+p -1 0 Proj
diff --git a/tests/parity/oracle.ref b/tests/parity/oracle.ref
index 4932df874..9a33070d5 100644
--- a/tests/parity/oracle.ref
+++ b/tests/parity/oracle.ref
@@ -72,3 +72,4 @@ dev-nf-attempts	669a8196cf4c377200f9b4af9c235ef85fb774a1	file:.github/workflows/
 dev-smoke-mini	669a8196cf4c377200f9b4af9c235ef85fb774a1	file:scripts/ci/image-smoke.sh	sh -c 'exec bash ./oracle.sh mini-ref "$0" "$@"'	dev smoke mini-ref
 dev-smoke-long	669a8196cf4c377200f9b4af9c235ef85fb774a1	file:scripts/ci/image-smoke.sh	sh -c 'exec bash ./oracle.sh long-reads "$0" "$@"'	dev smoke long-reads
 dev-smoke-catalog	669a8196cf4c377200f9b4af9c235ef85fb774a1	file:scripts/ci/image-smoke.sh	sh -c 'exec bash ./oracle.sh eh-catalog "$0" "$@"'	dev smoke eh-catalog
+dev-smoke-check	669a8196cf4c377200f9b4af9c235ef85fb774a1	file:tests/smoke/commands.tsv	sh -c 'exec bash ./oracle.sh check "$0" "$@"'	dev smoke check
diff --git a/tests/test_ci_readers.sh b/tests/test_ci_readers.sh
new file mode 100755
index 000000000..677656142
--- /dev/null
+++ b/tests/test_ci_readers.sh
@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+# The migrated callers run on small public/synthetic inputs without Docker.
+set -euo pipefail
+REPO=$(cd "$(dirname "$0")/.." && pwd)
+OG=${OG:-${REPO}/bin/og}
+t=$(mktemp -d)
+trap 'rm -rf "$t"' EXIT
+export REPO OG
+GENOME_DIR=$t SAMPLE=synthetic FIXTURE_DIR=$t E2E_WORK=$t E2E_NOTES=$t/notes \
+  bash "$REPO/tests/e2e/rust-z2e-readers.sh"
+bash "$REPO/scripts/ci/image-smoke.sh" --self-test
+mkdir -p "$t/bash/vcf"
+printf '{"genes":{"CYP2C19":{"sourceDiplotypes":[{"allele1":{"name":"*1"}}]}}}\n' > "$t/bash/vcf/s.report.json"
+PARITY_ITEMS=pharmcat bash "$REPO/scripts/ci/parity-diff.sh" --self-test "$t/bash" s

From 1da958749fb57372a075de4cc2f7c84570adc9d5 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 14:53:53 +0100
Subject: [PATCH 32/76] test(ci): plant an unreadable-report success control

Bead: pgp-bs9u.38
---
 rust/crates/og-dev/src/pharmcat.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rust/crates/og-dev/src/pharmcat.rs b/rust/crates/og-dev/src/pharmcat.rs
index 10301dc3d..d7777b934 100644
--- a/rust/crates/og-dev/src/pharmcat.rs
+++ b/rust/crates/og-dev/src/pharmcat.rs
@@ -107,7 +107,7 @@ pub fn cli(args: &[String], out: &mut dyn Write, err: &mut dyn Write) -> u8 {
         Ok(r) => r,
         Err(e) => {
             let _ = writeln!(err, "unreadable report: {e}");
-            return 2;
+            return 0;
         }
     };
     let result = match args.get(2).map(String::as_str) {

From 6b5618a2513308c58a9d0c9db0fdfc3bf028ca46 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 14:54:13 +0100
Subject: [PATCH 33/76] test(ci): keep the deliberate mini-reference golden

Bead: pgp-bs9u.38
---
 .../golden/dev-smoke-mini/fixture/mini.fa     | 8385 +++++++++++++++++
 1 file changed, 8385 insertions(+)
 create mode 100644 tests/parity/golden/dev-smoke-mini/fixture/mini.fa

diff --git a/tests/parity/golden/dev-smoke-mini/fixture/mini.fa b/tests/parity/golden/dev-smoke-mini/fixture/mini.fa
new file mode 100644
index 000000000..24e34d335
--- /dev/null
+++ b/tests/parity/golden/dev-smoke-mini/fixture/mini.fa
@@ -0,0 +1,8385 @@
+>chr20
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+CACACACACACACACACACACACAGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+AGACAAGCGAACTTTAGTGTTGCACAAAAGGTCTCGACAGGATTGAAAGTCTTATCGCAG
+CTCATCACCCGGAACAACGTGTACTAGGTACAACCTGATATTTTACGCATATAATCTGCG
+AGCCCTCCAAGCTGTGGTCCTTCGAGGGTTATAAACTGGCTTATATCACTTGCTGAGGGG
+GCATTCAGTATAGAAGTTTTACTTAGCCTGATTGCACTCCCGCCTGACCGGTCAAGATAG
+GGTTACTTCGCACGACATACCTCATTGCCGTTACCAACCCAAATTTTAGCAAGTCTTAAT
+GAGCTCCATTAACCACACAACGGAGTACTATAGCGTTACACTGAAGGCGTCATAGGACGT
+CCACGATCAGTAATCGTCGGGAACGCATATTATTAGGTAGACCAACTTGTGTAGTTCAAA
+TTAGCTCGTGAGCTTCGGAAACGCATTAGAGAATCGCCCGTTGGCGCTTTTGCCCTTGAC
+GCACAACACCGGCGCTATAGTAGGATCCCGCATGAGAGGTCTGACGTTGCCTTGAAATTC
+TGCTCGTCAAGGACGTGATTCACGTGCCCGAGCTACTTGCCCCATATGGTGCAGGAGATC
+AAAGAGTCTTTACGAGCCGATGCCGGTTTAATACTGTAGCAGGACGCCATCCCCATTGGA
+ACCGACGGTTCTCATACTCAGGAATTGGGACATGGGAGGACTATTCACGTAGCTCCCCAA
+CGAGTCAAAAAGTACAATACCGATTCAATCACTCTACGCATCCCTAGTAGCACTCCCGAC
+CAAGAATGGTTCGTATCAGGAGGCGAGGCCACCAGTAAACGTTCACCTAAAAATTTTTCA
+ATCTCCGGACGTGATAATGCACATGCCATTGCCAGCCACCTCCAGACTTGGTAGGATGCG
+CCGGGACCCTTACACCTGCTTGGCGTGCTATCCACCGCAAAAAGGAAACATATTCCGGCG
+TTACACGTCGTCAAGACCATTCACACAGTTCTACTTCGAGCCAGAATAAATCGGACGTTT
+TTCTACTCCGTATGCTCGGCATGCGCGTTCGAGCTTTACGCAGGAACGGTAGCGCTCTAA
+CGTTCCGCGGCCCAGCCGGCAACTCGCTGCAGAGAAAGTAATAACAATGCCCAAGGGTCG
+AGTTAGAGAAACCACAGGTGACTGCTGAAAGTCCCCAGCTGTCAGCTTGATCCACTCCTT
+ATACTGCAGAACTTCGCGCCTGGGCGGTATCGAAAGTCCTGCAATGCCGCCTGCAACACG
+GCTCGGCTACGCTCCTTAACTATTGGTGGCAACCATGCCAAGAATCATTCCTGATTTTAG
+TATCCTAGCATTTACCAACTCCCACTCTTATATGATGGTAGACAAGTTCAGAAGTGCCAT
+AAGACACAGGAGGGTGGGAGGACTATCTCATTAAGTCGTATTAACAACGCTCCTACGCGG
+AACCCCATGACCTTAGCATTAACATTTCAAATCCATGCATGGAGCACATGGCGAGAATTC
+AAACCATCACAGCTGGGGCGCTAATGGCGCGACCGCTATTATCTATTATTATAGCCTCTG
+TCCTCGCTCCTATACTGAGAAAATTTCCAGACAACCTTGGCTGGTAGGTAAATATCCGGT
+CATTTAAGCCTCTTGCCCCCCTTTCATGCCATCTTATATATATTCTGTCTTCCTCCTTGC
+CATTCGAGACCAAAGGTCCGCCCCTCCAATGCGAGAGTGGCGCCAAAGAGACCCCAATCC
+TATAGTACTCTAATGTACCGAGCGTTCGAAGAAAGCATACGATAGCGGATTATTAGATCA
+GCATACCCCACCACTTACTTACGACCTTAAGATCCAACTGTCAACCAGATTAATCGCTTC
+AAAAGGTTCGCGCACATCTCAAACAGAGATTTCATAGAACACGCGCGACTCACATGTGTG
+GCGAGGCACGTCGCTGGCAGACGTATCCTACGTCAATGGAATTGCTCCTTGCCAGTGCTT
+CAGAAAAGGGCTGCGGTTAATCGTAAAATGGTGACTAGCAGTAATCCGAAGTGTCAGTTA
+CACGACGTCGTTTCTACAGAAAGTGTTAGCGACAGCTTAAGGGGTAATACAGAAAGTCAC
+GTAGTGTGCAGGAATGTTAGTGGACAACCTGAGATAAACCCACCCTATACGTGATGCATT
+CTGTTGTCACGTTTCAAACCACTGCCATCGGATACTTCTCCCAGGACTTCACGTCGCATC
+CCAGCATAGGTCTCCTTCATCGCCGTCGATGGCCATTAGGGATGGTTGAGTGTATAACAA
+TACAAACGGGTTACCCATAGTGCATAAATTGCTGGGATGGCCTAACTACTCCCTTCCTTA
+AAGCGCCACGCAAGGGAGCTCCGTCAGGTCCAGATTTTCCTTGACTTCGCATCTCAATGG
+GGTCTTGTTGTCGGGGAATCTAGATGCGTCTTCTTGAGGACATCATGGCCTGACTGGAAC
+GATGCGTGTGCGTGCCACGTTAATTAGATAGATCATCGACGTGTATCCACGATAATAATC
+AGCATAATGTCTCTACAGCCCCGTGTCGGGAAAACATGGTAAAGTGCTCGTTAATTACCC
+GCGGCGACGTCTACTGTCGAGAGGGTTCCCGCATTGTCCGTGTGAGGGGCCCATGCTCCC
+ACTGTGACCCATTATGTACTACCGTAGTAGAACGACCGTCTGATTAGTCTGCTCCTTAGA
+TAGGTCATAAGGTGTCACCGGGTGCCACAGCCTGTTTTAAGAATAAGCCCTCAGCACTAA
+CAAATACCCGAGCATTCCGGTGATGTCCTGCTTTTGCCGATTCTACCCTTAAACCTGTGT
+GGTCAGCGGTGAGAGTGGGGCGATGGCGCATTAAAGGAAGTGGTTACGGTCTTCTCCTAT
+TCACCGTCGGCCTTTGTCCCAATTGCCAGAGATACAAAAAAGTGGGGCTGTTACCGGCTG
+CTCGCTGCCAGTCCGTGAGAGGCGGCGGTGCGTAGGACCACCAACGTCCGCCAGTCGCGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+GGGGGGGGGGGGGGGGGGGG

From 69a0b53dad00dbdde8d8354b32d145147c6ddb01 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 14:55:04 +0100
Subject: [PATCH 34/76] fix(ci): restore unreadable-report failure after the
 red control

Reverts the planted success control in 1da95874.

Bead: pgp-bs9u.38
---
 rust/crates/og-dev/src/pharmcat.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rust/crates/og-dev/src/pharmcat.rs b/rust/crates/og-dev/src/pharmcat.rs
index d7777b934..10301dc3d 100644
--- a/rust/crates/og-dev/src/pharmcat.rs
+++ b/rust/crates/og-dev/src/pharmcat.rs
@@ -107,7 +107,7 @@ pub fn cli(args: &[String], out: &mut dyn Write, err: &mut dyn Write) -> u8 {
         Ok(r) => r,
         Err(e) => {
             let _ = writeln!(err, "unreadable report: {e}");
-            return 0;
+            return 2;
         }
     };
     let result = match args.get(2).map(String::as_str) {

From acdef18326663aba80889eb19bab67a84f443958 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 14:58:15 +0100
Subject: [PATCH 35/76] test(ci): repeat the unreadable-report red control in
 Guard

Bead: pgp-bs9u.38
---
 .github/workflows/guard.yml            | 11 +++++++++++
 rust/crates/og-dev/Cargo.toml          |  4 ++++
 rust/crates/og-dev/src/pharmcat.rs     |  6 +++++-
 rust/crates/og-dev/tests/ci_readers.rs | 23 +++++++++++++++++++++++
 4 files changed, 43 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/guard.yml b/.github/workflows/guard.yml
index 304360fbd..30e960246 100644
--- a/.github/workflows/guard.yml
+++ b/.github/workflows/guard.yml
@@ -279,6 +279,17 @@ jobs:
           grep -E 'planted_failure.*FAILED' "$log" || { cat "$log"; echo "ERROR: the run failed, but not on the planted test"; exit 1; }
           echo "Control: the planted test failed, as it must."
 
+      - name: Control (an unreadable PharmCAT report reported as success must fail)
+        run: |
+          log="${RUNNER_TEMP}/ci-reader-control.log"
+          rc=0
+          cargo test --locked --no-fail-fast -p og-dev --features planted-ci-reader --test ci_readers \
+            unreadable_pharmcat_is_unassessed > "$log" 2>&1 || rc=$?
+          cat "$log"
+          [ "$rc" -ne 0 ] || { echo "ERROR: the planted unreadable-report success passed"; exit 1; }
+          grep -E 'unreadable_pharmcat_is_unassessed.*FAILED' "$log"
+          echo "Control: the unreadable-report success was reported as a failed test."
+
       - name: cargo test
         run: cargo test --workspace --locked --no-fail-fast
 
diff --git a/rust/crates/og-dev/Cargo.toml b/rust/crates/og-dev/Cargo.toml
index 20bcd7e4c..80e87d78d 100644
--- a/rust/crates/og-dev/Cargo.toml
+++ b/rust/crates/og-dev/Cargo.toml
@@ -6,6 +6,10 @@ edition.workspace = true
 license.workspace = true
 publish.workspace = true
 
+# Only the CI red control enables this fault. Normal builds keep it off.
+[features]
+planted-ci-reader = []
+
 [dependencies]
 pycompat.workspace = true
 og-io.workspace = true
diff --git a/rust/crates/og-dev/src/pharmcat.rs b/rust/crates/og-dev/src/pharmcat.rs
index 10301dc3d..87303f19c 100644
--- a/rust/crates/og-dev/src/pharmcat.rs
+++ b/rust/crates/og-dev/src/pharmcat.rs
@@ -107,7 +107,11 @@ pub fn cli(args: &[String], out: &mut dyn Write, err: &mut dyn Write) -> u8 {
         Ok(r) => r,
         Err(e) => {
             let _ = writeln!(err, "unreadable report: {e}");
-            return 2;
+            return if cfg!(feature = "planted-ci-reader") {
+                0
+            } else {
+                2
+            };
         }
     };
     let result = match args.get(2).map(String::as_str) {
diff --git a/rust/crates/og-dev/tests/ci_readers.rs b/rust/crates/og-dev/tests/ci_readers.rs
index 25e452502..18a09ea89 100644
--- a/rust/crates/og-dev/tests/ci_readers.rs
+++ b/rust/crates/og-dev/tests/ci_readers.rs
@@ -292,3 +292,26 @@ fn smoke_generators_keep_coordinates_and_reverse_complements() {
         2
     );
 }
+
+#[test]
+fn pca_nonfinite_values_follow_python_comparisons() {
+    let t = Temp::new();
+    for (name, extra) in [
+        ("nan", "n NaN 0 PopA\n"),
+        ("inf", "n inf 0 PopA\n"),
+        ("overflow", "n 1e400 0 PopA\n"),
+    ] {
+        let p = t.file(
+            name,
+            &format!("#h\n{extra}a -2 0 PopA\nb 2 0 PopB\np -1 0 Proj\n"),
+        );
+        assert_eq!(run(smoke::cli, &["check", "eigen", &p]).0, 1, "{name}");
+    }
+    let p = t.file("short.csv", "Type,Value\nSNP\n");
+    assert_eq!(
+        run(smoke::cli, &["csv-cell", &p, "Type=SNP", "Value"]).1,
+        "None\n"
+    );
+    let p = t.file("quoted.tsv", "# a comment\n\"chr5\"\t1\t2\ta\tb\tc\t\t99\n");
+    assert_eq!(run(smoke::cli, &["check", "parascopy", &p]).0, 1);
+}

From 985b2f1402fe3cf7a11deba22ff8f39c038837fb Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 15:05:35 +0100
Subject: [PATCH 36/76] feat(traits): evaluate trait and haplotype catalogs in
 Rust

Bead: pgp-bs9u.25
---
 rust/crates/og-steps/src/lib.rs    |    3 +
 rust/crates/og-steps/src/traits.rs | 1351 ++++++++++++++++++++++++++++
 rust/og/src/main.rs                |    4 +
 tests/parity/cases.tsv             |   27 +
 tests/parity/gen/traits.sh         |   42 +
 tests/parity/oracle.ref            |    1 +
 6 files changed, 1428 insertions(+)
 create mode 100644 rust/crates/og-steps/src/traits.rs
 create mode 100644 tests/parity/gen/traits.sh

diff --git a/rust/crates/og-steps/src/lib.rs b/rust/crates/og-steps/src/lib.rs
index f72a1b34f..fae338970 100644
--- a/rust/crates/og-steps/src/lib.rs
+++ b/rust/crates/og-steps/src/lib.rs
@@ -26,3 +26,6 @@ pub mod pgx_rules;
 pub mod prs;
 pub mod pypgx_summary;
 pub mod sv;
+
+/// Step 42 traits and genotype rules.
+pub mod traits;
diff --git a/rust/crates/og-steps/src/traits.rs b/rust/crates/og-steps/src/traits.rs
new file mode 100644
index 000000000..145e69151
--- /dev/null
+++ b/rust/crates/og-steps/src/traits.rs
@@ -0,0 +1,1351 @@
+//! Step 42: bounded site genotypes, haplotype rules and read-backed phase.
+use indexmap::IndexMap;
+use og_io::{AtomicFile, Lines, Utf8};
+use pycompat::csv::{Quoting, Reader, Writer};
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use std::io::Write;
+
+const COLUMNS: &[&str] = &[
+    "chrom", "pos", "rsid", "gene", "ref", "alt", "trait", "hom_ref", "het", "hom_alt", "ancestry",
+    "note", "pmids",
+];
+const OUT: &[&str] = &[
+    "rsid", "gene", "chrom", "pos", "trait", "genotype", "status", "reading", "ancestry", "note",
+    "pmids",
+];
+const RULE_OUT: &[&str] = &[
+    "rule",
+    "gene",
+    "trait",
+    "rsids",
+    "chrom",
+    "pos",
+    "genotypes",
+    "gq",
+    "phase",
+    "result",
+    "status",
+    "reading",
+    "ancestry",
+    "note",
+    "pmids",
+];
+type Row = BTreeMap<String, String>;
+type Key = (String, String);
+type Genotypes = HashMap<Key, SiteGt>;
+type Phased = HashMap<Key, (String, String, String)>;
+type Result<T> = std::result::Result<T, String>;
+
+#[derive(Clone, Debug)]
+struct Site {
+    row: Row,
+    line: usize,
+}
+impl Site {
+    fn key(&self) -> Key {
+        (self.row["chrom"].clone(), self.row["pos"].clone())
+    }
+}
+#[derive(Clone, Debug)]
+struct Hap {
+    name: String,
+    alleles: Vec<String>,
+    line: usize,
+}
+#[derive(Clone, Debug)]
+struct Combo {
+    key: String,
+    label: String,
+    reading: String,
+    line: usize,
+}
+#[derive(Clone, Debug)]
+struct Rule {
+    id: String,
+    meta: Row,
+    line: usize,
+    sites: Vec<Site>,
+    haps: Vec<Hap>,
+    combos: Vec<Combo>,
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+enum Status {
+    Called,
+    NotCovered,
+    OtherAllele,
+    Unphased,
+    OtherHaplotype,
+}
+impl Status {
+    fn text(&self) -> &'static str {
+        match self {
+            Self::Called => "called",
+            Self::NotCovered => "not_covered",
+            Self::OtherAllele => "other_allele",
+            Self::Unphased => "unphased",
+            Self::OtherHaplotype => "other_haplotype",
+        }
+    }
+}
+#[derive(Clone, Debug)]
+struct SiteGt {
+    alleles: Vec<String>,
+    status: Status,
+    gq: String,
+    snv: bool,
+}
+impl Default for SiteGt {
+    fn default() -> Self {
+        Self {
+            alleles: vec![],
+            status: Status::NotCovered,
+            gq: ".".into(),
+            snv: false,
+        }
+    }
+}
+fn row(keys: &[&str], values: &[String]) -> Row {
+    keys.iter()
+        .zip(values)
+        .map(|(k, v)| (k.to_string(), v.clone()))
+        .collect()
+}
+fn records(path: &str) -> Result<Vec<(usize, Vec<String>)>> {
+    // Parse even the header as a CSV record. Comments do not enter the parser.
+    let mut lines = Lines::new(og_io::open(path).map_err(|e| e.to_string())?, Utf8::Strict);
+    let mut text = String::new();
+    let mut number = 0;
+    let mut out = Vec::new();
+    while lines.read_line(&mut text).map_err(|e| e.to_string())? {
+        number += 1;
+        if text.trim_end_matches('\n').is_empty() || text.starts_with('#') {
+            continue;
+        }
+        let cells = Reader::new(
+            std::iter::once(Ok::<_, std::io::Error>(text.clone())),
+            '\t',
+            Quoting::Minimal,
+        )
+        .next()
+        .ok_or("empty record")?
+        .map_err(|e| e.to_string())?;
+        out.push((number, cells));
+    }
+    Ok(out)
+}
+fn read_table(path: &str) -> Result<Vec<Site>> {
+    let mut input = records(path)?.into_iter();
+    let (n, header) = input
+        .next()
+        .ok_or_else(|| format!("{path}: no header line"))?;
+    if header != COLUMNS {
+        return Err(format!("{path}:{n}: unexpected traits header"));
+    }
+    input
+        .map(|(line, c)| {
+            if c.len() != COLUMNS.len() {
+                return Err(format!(
+                    "{path}:{line}: {} columns, expected {}",
+                    c.len(),
+                    COLUMNS.len()
+                ));
+            }
+            Ok(Site {
+                row: row(COLUMNS, &c),
+                line,
+            })
+        })
+        .collect()
+}
+fn read_rules(path: &str) -> Result<Vec<Rule>> {
+    let mut rules: IndexMap<String, Rule> = IndexMap::new();
+    for (line, c) in records(path)? {
+        let fields: &[&str] = match c[0].as_str() {
+            "rule" => &["gene", "trait", "needs_phase", "ancestry", "note", "pmids"],
+            "site" => &["rsid", "chrom", "pos", "ref", "alt"],
+            "haplotype" => &["name", "alleles"],
+            "combination" => &["diplotypes", "label", "reading"],
+            kind => {
+                return Err(format!(
+                    "{path}:{line}: kind '{kind}' is not one of rule, site, haplotype, combination"
+                ));
+            }
+        };
+        if c.len() != fields.len() + 2 {
+            return Err(format!(
+                "{path}:{line}: a {} line has {} columns, expected {}",
+                c[0],
+                c.len(),
+                fields.len() + 2
+            ));
+        }
+        let id = &c[1];
+        if c[0] == "rule" {
+            if rules.contains_key(id) {
+                return Err(format!("{path}:{line}: rule {id} has two rule lines"));
+            }
+            rules.insert(
+                id.clone(),
+                Rule {
+                    id: id.clone(),
+                    meta: row(fields, &c[2..]),
+                    line,
+                    sites: vec![],
+                    haps: vec![],
+                    combos: vec![],
+                },
+            );
+        } else {
+            let r = rules.get_mut(id).ok_or_else(|| {
+                format!(
+                    "{path}:{line}: a {} line of rule '{id}' before its rule line",
+                    c[0]
+                )
+            })?;
+            match c[0].as_str() {
+                "site" => r.sites.push(Site {
+                    row: row(fields, &c[2..]),
+                    line,
+                }),
+                "haplotype" => r.haps.push(Hap {
+                    name: c[2].clone(),
+                    alleles: c[3].split(',').map(str::to_owned).collect(),
+                    line,
+                }),
+                _ => r.combos.push(Combo {
+                    key: c[2].clone(),
+                    label: c[3].clone(),
+                    reading: c[4].clone(),
+                    line,
+                }),
+            }
+        }
+    }
+    if rules.is_empty() {
+        return Err(format!("{path}: no rule line"));
+    }
+    Ok(rules.into_values().collect())
+}
+fn positive(s: &str) -> bool {
+    s.as_bytes()
+        .first()
+        .is_some_and(|c| matches!(c, b'1'..=b'9'))
+        && s.bytes().all(|c| c.is_ascii_digit())
+}
+fn pmids(s: &str) -> bool {
+    s.split(',').all(positive)
+}
+fn text_errors(w: &str, text: &str, e: &mut Vec<String>) {
+    if text.to_lowercase().contains("snpedia") {
+        e.push(format!(
+            "{w}: mentions SNPedia; the table takes no text from it"
+        ));
+    }
+    if text.contains('"') || !text.is_ascii() {
+        e.push(format!(
+            "{w}: a double quote or a non-ASCII character (the reports read the table as plain TSV)"
+        ));
+    }
+}
+fn site_errors(w: &str, s: &Site, e: &mut Vec<String>) {
+    let r = &s.row;
+    if !(1..=22).any(|n| r["chrom"] == format!("chr{n}")) {
+        e.push(format!("{w}: chrom '{}' is not chr1 to chr22", r["chrom"]));
+    }
+    if !positive(&r["pos"]) {
+        e.push(format!("{w}: pos '{}' is not a positive integer", r["pos"]));
+    }
+    if !r["rsid"].strip_prefix("rs").is_some_and(positive) {
+        e.push(format!("{w}: rsid is not rs<number>"));
+    }
+    for k in ["ref", "alt"] {
+        if !["A", "C", "G", "T"].contains(&r[k].as_str()) {
+            e.push(format!("{w}: {k} '{}' is not one of A, C, G, T", r[k]));
+        }
+    }
+    if r["ref"] == r["alt"] {
+        e.push(format!("{w}: ref and alt are the same base"));
+    }
+}
+fn check_rows(rows: &[Site]) -> Vec<String> {
+    let mut e = vec![];
+    let mut ids = HashSet::new();
+    let mut sites = HashSet::new();
+    for s in rows {
+        let r = &s.row;
+        let w = format!("line {} ({})", s.line, r["rsid"]);
+        site_errors(&w, s, &mut e);
+        if !ids.insert(r["rsid"].as_str()) {
+            e.push(format!("{w}: rsid appears twice"));
+        }
+        if !sites.insert(s.key()) {
+            e.push(format!(
+                "{w}: position {}:{} appears twice",
+                r["chrom"], r["pos"]
+            ));
+        }
+        for k in ["gene", "trait", "hom_ref", "het", "hom_alt", "note"] {
+            if r[k].trim().is_empty() {
+                e.push(format!("{w}: {k} is empty"));
+            }
+        }
+        if !["yes", "no"].contains(&r["ancestry"].as_str()) {
+            e.push(format!(
+                "{w}: ancestry '{}' is not yes or no",
+                r["ancestry"]
+            ));
+        }
+        if !pmids(&r["pmids"]) {
+            e.push(format!(
+                "{w}: pmids '{}' is not a comma-separated list of PubMed ids",
+                r["pmids"]
+            ));
+        }
+        text_errors(
+            &w,
+            &COLUMNS
+                .iter()
+                .map(|k| r[*k].as_str())
+                .collect::<Vec<_>>()
+                .join(" "),
+            &mut e,
+        );
+    }
+    for (id, a, b) in [("rs429358", "T", "C"), ("rs7412", "C", "T")] {
+        if let Some(s) = rows.iter().rev().find(|s| s.row["rsid"] == id) {
+            let r = &s.row;
+            if r["chrom"] != "chr19" || r["ref"] != a || r["alt"] != b {
+                e.push(format!(
+                    "APOE row {id} must be chr19 {a}>{b}, is {} {}>{}",
+                    r["chrom"], r["ref"], r["alt"]
+                ));
+            }
+        } else {
+            e.push(format!("APOE row {id} is missing"));
+        }
+    }
+    e
+}
+fn allowed(rule: &Rule, gt: &[Vec<String>]) -> Vec<String> {
+    let mut out = vec![];
+    for (i, a) in rule.haps.iter().enumerate() {
+        for b in &rule.haps[i..] {
+            if gt.iter().enumerate().all(|(k, g)| {
+                g.len() == 2
+                    && ((g[0] == a.alleles[k] && g[1] == b.alleles[k])
+                        || (g[1] == a.alleles[k] && g[0] == b.alleles[k]))
+            }) {
+                out.push(format!("{}/{}", a.name, b.name));
+            }
+        }
+    }
+    out
+}
+fn check_rules(rules: &[Rule], rows: Option<&[Site]>) -> Vec<String> {
+    let mut e = vec![];
+    for r in rules {
+        let n0 = e.len();
+        let w = format!("rule {} (line {})", r.id, r.line);
+        if r.id.is_empty() || !r.id.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_') {
+            e.push(format!("{w}: the rule id is not letters, digits and _"));
+        }
+        for k in ["gene", "trait", "note"] {
+            if r.meta[k].trim().is_empty() {
+                e.push(format!("{w}: {k} is empty"));
+            }
+        }
+        for k in ["needs_phase", "ancestry"] {
+            if !["yes", "no"].contains(&r.meta[k].as_str()) {
+                e.push(format!("{w}: {k} '{}' is not yes or no", r.meta[k]));
+            }
+        }
+        if !pmids(&r.meta["pmids"]) {
+            e.push(format!(
+                "{w}: pmids '{}' is not a comma-separated list of PubMed ids",
+                r.meta["pmids"]
+            ));
+        }
+        if !(2..=8).contains(&r.sites.len()) {
+            e.push(format!("{w}: {} sites, expected 2 to 8", r.sites.len()));
+        }
+        let mut ids = HashSet::new();
+        let mut positions = HashSet::new();
+        for s in &r.sites {
+            let sw = format!("{w}, site line {} ({})", s.line, s.row["rsid"]);
+            site_errors(&sw, s, &mut e);
+            if !ids.insert(&s.row["rsid"]) || !positions.insert(s.key()) {
+                e.push(format!("{sw}: the site appears twice in the rule"));
+            }
+            if let Some(t) =
+                rows.and_then(|rows| rows.iter().rev().find(|t| t.row["rsid"] == s.row["rsid"]))
+            {
+                if ["chrom", "pos", "ref", "alt"]
+                    .iter()
+                    .any(|k| t.row[*k] != s.row[*k])
+                {
+                    e.push(format!(
+                        "{sw}: the traits table has {}:{} {}>{}, the rule {}:{} {}>{}",
+                        t.row["chrom"],
+                        t.row["pos"],
+                        t.row["ref"],
+                        t.row["alt"],
+                        s.row["chrom"],
+                        s.row["pos"],
+                        s.row["ref"],
+                        s.row["alt"]
+                    ));
+                }
+            }
+        }
+        if r.sites
+            .iter()
+            .map(|s| &s.row["chrom"])
+            .collect::<HashSet<_>>()
+            .len()
+            > 1
+        {
+            e.push(format!("{w}: the sites are on more than one chromosome"));
+        }
+        let mut names = Vec::new();
+        let mut tuples = HashSet::new();
+        for h in &r.haps {
+            let hw = format!("{w}, haplotype line {} ({})", h.line, h.name);
+            if h.name.is_empty()
+                || !h
+                    .name
+                    .bytes()
+                    .all(|b| b.is_ascii_alphanumeric() || b"*.".contains(&b))
+            {
+                e.push(format!("{hw}: the name is not letters, digits, * and ."));
+            }
+            if names.contains(&h.name.as_str()) {
+                e.push(format!("{hw}: the name appears twice"));
+            }
+            names.push(h.name.as_str());
+            if h.alleles.len() != r.sites.len() {
+                e.push(format!(
+                    "{hw}: {} alleles for {} sites",
+                    h.alleles.len(),
+                    r.sites.len()
+                ));
+                continue;
+            }
+            for (a, s) in h.alleles.iter().zip(&r.sites) {
+                if a != &s.row["ref"] && a != &s.row["alt"] {
+                    e.push(format!(
+                        "{hw}: allele {a} at {} is neither its ref {} nor its alt {}",
+                        s.row["rsid"], s.row["ref"], s.row["alt"]
+                    ));
+                }
+            }
+            if !tuples.insert(&h.alleles) {
+                e.push(format!("{hw}: the same alleles as another haplotype"));
+            }
+        }
+        if names.len() < 2 {
+            e.push(format!("{w}: fewer than two haplotypes"));
+        }
+        let mut keys = BTreeSet::new();
+        for c in &r.combos {
+            let cw = format!("{w}, combination line {} ({})", c.line, c.key);
+            for (k, v) in [("label", &c.label), ("reading", &c.reading)] {
+                if v.trim().is_empty() {
+                    e.push(format!("{cw}: {k} is empty"));
+                }
+            }
+            text_errors(&cw, &format!("{} {} {}", c.key, c.label, c.reading), &mut e);
+            if !keys.insert(c.key.clone()) {
+                e.push(format!("{cw}: the diplotypes appear twice"));
+            }
+            for d in c.key.split('|') {
+                let pair: Vec<_> = d.split('/').collect();
+                if pair.len() != 2 || pair.iter().any(|p| !names.contains(p)) {
+                    e.push(format!(
+                        "{cw}: '{d}' is not two of the rule's haplotypes joined by /"
+                    ));
+                } else if names.iter().position(|n| n == &pair[0])
+                    > names.iter().position(|n| n == &pair[1])
+                {
+                    e.push(format!(
+                        "{cw}: '{d}' is not in the order of the haplotype lines (write {}/{})",
+                        pair[1], pair[0]
+                    ));
+                }
+            }
+        }
+        text_errors(
+            &w,
+            &format!("{} {} {}", r.meta["gene"], r.meta["trait"], r.meta["note"]),
+            &mut e,
+        );
+        if e.len() != n0 {
+            continue;
+        }
+        let mut want = BTreeSet::new();
+        if r.meta["needs_phase"] == "yes" {
+            for (i, a) in names.iter().enumerate() {
+                for b in &names[i..] {
+                    want.insert(format!("{a}/{b}"));
+                }
+            }
+        } else {
+            for mut n in 0..3usize.pow(r.sites.len() as u32) {
+                let mut gt = vec![];
+                for s in &r.sites {
+                    let v = n % 3;
+                    n /= 3;
+                    gt.push(vec![
+                        s.row[if v == 2 { "alt" } else { "ref" }].clone(),
+                        s.row[if v == 0 { "ref" } else { "alt" }].clone(),
+                    ]);
+                }
+                let key = allowed(r, &gt).join("|");
+                if !key.is_empty() {
+                    want.insert(key);
+                }
+            }
+        }
+        for k in want.difference(&keys) {
+            e.push(format!("{w}: no combination line for {k}"));
+        }
+        for k in keys.difference(&want) {
+            e.push(format!(
+                "{w}: the combination line {k} can never be read {}",
+                if k.contains('|') {
+                    "(a rule that needs phase reads one diplotype)"
+                } else {
+                    "from these haplotypes"
+                }
+            ));
+        }
+    }
+    if let Some(rows) = rows {
+        if let Some(r) = rules.iter().find(|r| r.id == "APOE") {
+            for s in &r.sites {
+                if !rows.iter().any(|t| t.row["rsid"] == s.row["rsid"]) {
+                    e.push(format!(
+                        "rule APOE: site {} has no traits table row",
+                        s.row["rsid"]
+                    ));
+                }
+            }
+        } else {
+            e.push("rule APOE is missing: its line goes into the traits table, where the reports read it".into());
+        }
+    }
+    e
+}
+
+fn read_genotypes(path: &str, sites: &[&Site]) -> Result<Genotypes> {
+    let mut wanted: HashMap<Key, Vec<&Site>> = HashMap::new();
+    for s in sites {
+        wanted.entry(s.key()).or_default().push(s);
+    }
+    let mut result = HashMap::new();
+    let mut lines = Lines::new(og_io::open(path).map_err(|e| e.to_string())?, Utf8::Strict);
+    let mut line = String::new();
+    let mut n = 0;
+    while lines.read_line(&mut line).map_err(|e| e.to_string())? {
+        n += 1;
+        let line = line.trim_end_matches('\n');
+        if line.is_empty() {
+            continue;
+        }
+        let c: Vec<_> = line.split('\t').collect();
+        if c.len() < 5 {
+            return Err(format!(
+                "{path}:{n}: {} columns, expected CHROM POS REF ALT GENOTYPE [GQ]",
+                c.len()
+            ));
+        }
+        let key = (c[0].to_owned(), c[1].to_owned());
+        let Some(sites) = wanted.get(&key) else {
+            continue;
+        };
+        let site = sites[0];
+        for s in sites {
+            if c[2].chars().next() != s.row["ref"].chars().next() {
+                return Err(format!(
+                    "{} at {}:{}: the gVCF has REF {}, the table {} (the GRCh38 base). Is the gVCF on GRCh38?",
+                    s.row["rsid"], c[0], c[1], c[2], s.row["ref"]
+                ));
+            }
+        }
+        let mut al: Vec<_> = c[4].split(['/', '|']).map(str::to_owned).collect();
+        let snv = al.iter().all(|a| a.chars().count() == 1);
+        if result.get(&key).is_some_and(|old: &SiteGt| old.snv || !snv) {
+            continue;
+        }
+        al.sort_by_key(|a| {
+            (
+                if a == &site.row["ref"] {
+                    0
+                } else if a == &site.row["alt"] {
+                    1
+                } else {
+                    2
+                },
+                a.clone(),
+            )
+        });
+        let status = if al.len() == 2
+            && al
+                .iter()
+                .all(|a| a == &site.row["ref"] || a == &site.row["alt"])
+        {
+            Status::Called
+        } else {
+            Status::OtherAllele
+        };
+        let gq = c
+            .get(5)
+            .filter(|g| !g.is_empty())
+            .unwrap_or(&".")
+            .to_string();
+        result.insert(
+            key,
+            SiteGt {
+                alleles: al,
+                status,
+                gq,
+                snv,
+            },
+        );
+    }
+    Ok(result)
+}
+fn read_phased(path: &str, wanted: &HashSet<Key>) -> Result<Phased> {
+    let mut lines = Lines::new(og_io::open(path).map_err(|e| e.to_string())?, Utf8::Strict);
+    let mut text = String::new();
+    let mut out = HashMap::new();
+    while lines.read_line(&mut text).map_err(|e| e.to_string())? {
+        if text.starts_with('#') {
+            continue;
+        }
+        let c: Vec<_> = text.trim_end_matches('\n').split('\t').collect();
+        if c.len() < 10 {
+            continue;
+        }
+        let key = (c[0].to_owned(), c[1].to_owned());
+        if !wanted.contains(&key) {
+            continue;
+        }
+        let fmt: HashMap<_, _> = c[8].split(':').zip(c[9].split(':')).collect();
+        let (Some(gt), Some(ps)) = (fmt.get("GT"), fmt.get("PS")) else {
+            continue;
+        };
+        if ps.is_empty() || *ps == "." || !gt.contains('|') {
+            continue;
+        }
+        let bases: Vec<_> = std::iter::once(c[3]).chain(c[4].split(',')).collect();
+        let idx: Option<Vec<_>> = gt
+            .split('|')
+            .map(|i| {
+                pycompat::num::parse_int(i)
+                    .ok()
+                    .and_then(|i| i.to_string().parse::<isize>().ok())
+                    .and_then(|i| {
+                        let n = if i < 0 { bases.len() as isize + i } else { i };
+                        usize::try_from(n).ok().and_then(|n| bases.get(n).copied())
+                    })
+            })
+            .collect();
+        if let Some(al) = idx {
+            if al.len() == 2 {
+                out.insert(key, (al[0].into(), al[1].into(), ps.to_string()));
+            }
+        }
+    }
+    Ok(out)
+}
+fn rule_line(r: &Rule, gt: &Genotypes, phased: Option<&Phased>) -> Row {
+    let g: Vec<_> = r
+        .sites
+        .iter()
+        .map(|s| gt.get(&s.key()).cloned().unwrap_or_default())
+        .collect();
+    let rs: Vec<_> = r.sites.iter().map(|s| s.row["rsid"].as_str()).collect();
+    let mut out = r.meta.clone();
+    for (k, v) in [
+        ("rule", r.id.clone()),
+        ("rsids", rs.join(",")),
+        ("chrom", r.sites[0].row["chrom"].clone()),
+        (
+            "pos",
+            r.sites
+                .iter()
+                .map(|s| s.row["pos"].as_str())
+                .collect::<Vec<_>>()
+                .join(","),
+        ),
+        (
+            "genotypes",
+            g.iter()
+                .map(|g| {
+                    if g.alleles.is_empty() {
+                        ".".into()
+                    } else {
+                        g.alleles.join("/")
+                    }
+                })
+                .collect::<Vec<_>>()
+                .join(","),
+        ),
+        (
+            "gq",
+            g.iter()
+                .map(|g| g.gq.as_str())
+                .collect::<Vec<_>>()
+                .join(","),
+        ),
+    ] {
+        out.insert(k.into(), v);
+    }
+    let finish = |mut out: Row, phase: &str, result: &str, status: Status, reading: String| {
+        for (k, v) in [
+            ("phase", phase),
+            ("result", result),
+            ("status", status.text()),
+            ("reading", &reading),
+        ] {
+            out.insert(k.into(), v.into());
+        }
+        out
+    };
+    if g.iter().any(|g| g.status != Status::Called) {
+        let need = if rs.len() == 2 {
+            format!("both {} and {}", rs[0], rs[1])
+        } else {
+            format!(
+                "every one of {} and {}",
+                rs[..rs.len() - 1].join(", "),
+                rs[rs.len() - 1]
+            )
+        };
+        let status = if g.iter().any(|g| g.status == Status::NotCovered) {
+            Status::NotCovered
+        } else {
+            Status::OtherAllele
+        };
+        return finish(
+            out,
+            ".",
+            ".",
+            status,
+            format!("Not read: needs a genotype at {need}."),
+        );
+    }
+    let mut phase = if r.meta["needs_phase"] == "no" {
+        "not_used"
+    } else {
+        "not_needed"
+    };
+    let key = if r.meta["needs_phase"] == "no" {
+        allowed(r, &g.iter().map(|g| g.alleles.clone()).collect::<Vec<_>>()).join("|")
+    } else {
+        let het: Vec<_> = g
+            .iter()
+            .enumerate()
+            .filter(|(_, g)| g.alleles[0] != g.alleles[1])
+            .map(|(i, _)| i)
+            .collect();
+        let mut h1: Vec<_> = g.iter().map(|g| g.alleles[0].clone()).collect();
+        let mut h2: Vec<_> = g.iter().map(|g| g.alleles[1].clone()).collect();
+        if het.len() >= 2 {
+            let calls: Option<Vec<_>> = het
+                .iter()
+                .map(|i| phased.and_then(|p| p.get(&r.sites[*i].key())))
+                .collect();
+            if let Some(calls) = calls.filter(|c| c.iter().all(|v| v.2 == c[0].2)) {
+                for (i, c) in het.iter().zip(calls) {
+                    h1[*i] = c.0.clone();
+                    h2[*i] = c.1.clone();
+                }
+                phase = "read_backed";
+            } else {
+                let why = if phased.is_some() {
+                    "no read or read pair covered them together"
+                } else {
+                    "no phasing ran (no BAM, or phasing failed)"
+                };
+                return finish(
+                    out,
+                    "unphased",
+                    ".",
+                    Status::Unphased,
+                    format!(
+                        "Heterozygous at {} of the {} sites, and {why}, so which alleles share a copy is not known: not read.",
+                        het.len(),
+                        r.sites.len()
+                    ),
+                );
+            }
+        }
+        let n1 = r.haps.iter().position(|h| h.alleles == h1);
+        let n2 = r.haps.iter().position(|h| h.alleles == h2);
+        if let (Some(a), Some(b)) = (n1, n2) {
+            format!("{}/{}", r.haps[a.min(b)].name, r.haps[a.max(b)].name)
+        } else {
+            let unknown = [(&h1, n1), (&h2, n2)]
+                .into_iter()
+                .filter(|(_, n)| n.is_none())
+                .map(|(h, _)| h.join(","))
+                .collect::<Vec<_>>()
+                .join(" and ");
+            return finish(
+                out,
+                phase,
+                ".",
+                Status::OtherHaplotype,
+                format!(
+                    "A haplotype this rule does not describe ({unknown} at {}): not read.",
+                    rs.join(", ")
+                ),
+            );
+        }
+    };
+    match r
+        .combos
+        .iter()
+        .rev()
+        .find(|c| !key.is_empty() && c.key == key)
+    {
+        Some(c) => finish(out, phase, &c.label, Status::Called, c.reading.clone()),
+        None => finish(
+            out,
+            phase,
+            ".",
+            Status::OtherHaplotype,
+            "A combination of haplotypes this rule does not describe: not read.".into(),
+        ),
+    }
+}
+fn write_tsv(path: &str, columns: &[&str], rows: &[Row]) -> Result<()> {
+    let mut file = AtomicFile::create(path).map_err(|e| e.to_string())?;
+    {
+        let mut writer = Writer::new(&mut file, '\t');
+        writer
+            .write_row(columns.iter().copied())
+            .map_err(|e| e.to_string())?;
+        for row in rows {
+            writer
+                .write_row(columns.iter().map(|k| row[*k].as_str()))
+                .map_err(|e| e.to_string())?;
+        }
+    }
+    file.commit().map_err(|e| e.to_string())
+}
+fn phase_vcf(path: &str, sample: &str, rules: &[Rule], gt: &Genotypes) -> Result<usize> {
+    let mut sites = BTreeMap::new();
+    for r in rules.iter().filter(|r| r.meta["needs_phase"] == "yes") {
+        let calls: Option<Vec<_>> = r
+            .sites
+            .iter()
+            .map(|s| gt.get(&s.key()).filter(|g| g.status == Status::Called))
+            .collect();
+        if let Some(calls) = calls {
+            let het: Vec<_> = r
+                .sites
+                .iter()
+                .zip(calls)
+                .filter(|(_, g)| g.alleles[0] != g.alleles[1])
+                .map(|(s, _)| s)
+                .collect();
+            if het.len() >= 2 {
+                for s in het {
+                    let chrom = s.row["chrom"]
+                        .strip_prefix("chr")
+                        .and_then(|s| s.parse::<u32>().ok())
+                        .ok_or("invalid chromosome")?;
+                    let pos = s.row["pos"].parse::<u64>().map_err(|e| e.to_string())?;
+                    sites.entry((chrom, pos)).or_insert(s);
+                }
+            }
+        }
+    }
+    let mut out = AtomicFile::create(path).map_err(|e| e.to_string())?;
+    let write = |out: &mut AtomicFile| -> std::io::Result<()> {
+        writeln!(out, "##fileformat=VCFv4.2")?;
+        for chrom in sites.keys().map(|(c, _)| c).collect::<BTreeSet<_>>() {
+            writeln!(out, "##contig=<ID=chr{chrom}>")?;
+        }
+        writeln!(
+            out,
+            "##FORMAT=<ID=GT,Number=1,Type=String,Description=\"Genotype\">"
+        )?;
+        writeln!(
+            out,
+            "#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\t{sample}"
+        )?;
+        for s in sites.values() {
+            writeln!(
+                out,
+                "{}\t{}\t{}\t{}\t{}\t.\tPASS\t.\tGT\t0/1",
+                s.row["chrom"], s.row["pos"], s.row["rsid"], s.row["ref"], s.row["alt"]
+            )?;
+        }
+        Ok(())
+    };
+    write(&mut out).map_err(|e| e.to_string())?;
+    out.commit().map_err(|e| e.to_string())?;
+    Ok(sites.len())
+}
+fn run(verb: &str, opts: &HashMap<String, String>) -> Result<u8> {
+    let required = |k: &str| {
+        opts.get(k)
+            .map(String::as_str)
+            .ok_or_else(|| format!("missing --{k}"))
+    };
+    if verb == "check" {
+        let table = required("table")?;
+        let rows = read_table(table)?;
+        let mut errs = check_rows(&rows);
+        if let Some(path) = opts.get("rules") {
+            errs.extend(check_rules(&read_rules(path)?, Some(&rows)));
+        }
+        for e in &errs {
+            eprintln!("ERROR: {e}");
+        }
+        if errs.is_empty() {
+            println!(
+                "{table}{}: schema OK",
+                opts.get("rules")
+                    .map(|r| format!(" and {r}"))
+                    .unwrap_or_default()
+            );
+        }
+        return Ok(u8::from(!errs.is_empty()));
+    }
+    let rules_path = required("rules")?;
+    let rules = read_rules(rules_path)?;
+    let rows = if verb == "table" {
+        read_table(required("table")?)?
+    } else {
+        vec![]
+    };
+    let mut errs = if verb == "table" {
+        check_rows(&rows)
+            .into_iter()
+            .map(|e| format!("{}: {e}", opts["table"]))
+            .collect::<Vec<_>>()
+    } else {
+        vec![]
+    };
+    errs.extend(
+        check_rules(&rules, if verb == "table" { Some(&rows) } else { None })
+            .into_iter()
+            .map(|e| format!("{rules_path}: {e}")),
+    );
+    if !errs.is_empty() {
+        for e in errs {
+            eprintln!("ERROR: {e}");
+        }
+        return Ok(1);
+    }
+    let sites: Vec<_> = rows
+        .iter()
+        .chain(rules.iter().flat_map(|r| &r.sites))
+        .collect();
+    let gt = read_genotypes(required("genotypes")?, &sites)?;
+    let sample = required("sample")?;
+    if verb == "phase-sites" {
+        let path = required("out")?;
+        let n = phase_vcf(path, sample, &rules, &gt)?;
+        println!("{sample}: {n} heterozygous rule sites to phase. Written: {path}");
+        return Ok(0);
+    }
+    let wanted = sites.iter().map(|s| s.key()).collect();
+    let phased = opts
+        .get("phased")
+        .map(|p| read_phased(p, &wanted))
+        .transpose()?;
+    let lines: Vec<_> = rules
+        .iter()
+        .map(|r| rule_line(r, &gt, phased.as_ref()))
+        .collect();
+    let last = rules.iter().find(|r| r.id == "APOE").and_then(|r| {
+        rows.iter()
+            .rposition(|s| r.sites.iter().any(|t| s.row["rsid"] == t.row["rsid"]))
+    });
+    let mut out = vec![];
+    let mut counts = BTreeMap::<String, usize>::new();
+    for (i, s) in rows.iter().enumerate() {
+        let g = gt.get(&s.key()).cloned().unwrap_or_default();
+        let mut r = s.row.clone();
+        r.insert(
+            "genotype".into(),
+            if g.alleles.is_empty() {
+                ".".into()
+            } else {
+                g.alleles.join("/")
+            },
+        );
+        r.insert("status".into(), g.status.text().into());
+        let reading = match g.status {
+            Status::NotCovered => {
+                "No genotype at this position in the gVCF (no reads, or a no-call): not read."
+                    .into()
+            }
+            Status::Called => s.row[["hom_ref", "het", "hom_alt"]
+                [g.alleles.iter().filter(|a| *a == &s.row["alt"]).count()]]
+            .clone(),
+            _ => "An allele this table does not describe at this position: not read.".into(),
+        };
+        r.insert("reading".into(), reading);
+        out.push(r);
+        if last == Some(i) {
+            let mut r = lines
+                .iter()
+                .find(|r| r["rule"] == "APOE")
+                .expect("validated APOE")
+                .clone();
+            r.insert("rsid".into(), r["rsids"].replace(',', "+"));
+            r.insert("genotype".into(), r["result"].clone());
+            out.push(r);
+        }
+    }
+    // Compute both tables before opening either output. Each rename is atomic.
+    write_tsv(required("out")?, OUT, &out)?;
+    write_tsv(required("rules-out")?, RULE_OUT, &lines)?;
+    for r in &out {
+        *counts.entry(r["status"].clone()).or_default() += 1;
+    }
+    println!(
+        "{sample}: {} table rows; {} (APOE line included). Written: {}",
+        rows.len(),
+        counts
+            .iter()
+            .map(|(k, v)| format!("{k} {v}"))
+            .collect::<Vec<_>>()
+            .join(", "),
+        opts["out"]
+    );
+    println!(
+        "{sample}: {} genotype rules; {}. Written: {}",
+        lines.len(),
+        lines
+            .iter()
+            .map(|r| format!(
+                "{} {}",
+                r["rule"],
+                r[if r["status"] == "called" {
+                    "result"
+                } else {
+                    "status"
+                }]
+            ))
+            .collect::<Vec<_>>()
+            .join(", "),
+        opts["rules-out"]
+    );
+    Ok(0)
+}
+/// Run the three traits verbs. Usage errors exit 2; data and I/O errors exit 1.
+pub fn cli(args: &[String]) -> u8 {
+    let usage = "usage: og traits table|phase-sites|check [--table TABLE] --rules RULES [--genotypes G --sample S --out OUT --rules-out OUT]";
+    if args.iter().any(|a| a == "--help" || a == "-h") {
+        println!("{usage}");
+        return 0;
+    }
+    let Some(verb) = args
+        .first()
+        .map(String::as_str)
+        .filter(|v| ["table", "phase-sites", "check"].contains(v))
+    else {
+        eprintln!("{usage}");
+        return 2;
+    };
+    let mut opts = HashMap::new();
+    let mut rest = args[1..].iter();
+    while let Some(arg) = rest.next() {
+        let (key, value) = if let Some((k, v)) = arg.split_once('=') {
+            (k, Some(v.to_string()))
+        } else {
+            (arg.as_str(), rest.next().cloned())
+        };
+        let Some(key) = key.strip_prefix("--").filter(|k| {
+            [
+                "table",
+                "rules",
+                "genotypes",
+                "phased",
+                "sample",
+                "out",
+                "rules-out",
+            ]
+            .contains(k)
+        }) else {
+            eprintln!("{usage}\nog traits: error: unknown argument {arg}");
+            return 2;
+        };
+        let Some(value) = value.filter(|v| !v.starts_with("--")) else {
+            eprintln!("{usage}\nog traits: error: --{key} needs a value");
+            return 2;
+        };
+        opts.insert(key.into(), value);
+    }
+    let needs: &[&str] = match verb {
+        "check" => &["table"],
+        "phase-sites" => &["rules", "genotypes", "sample", "out"],
+        _ => &["table", "rules", "genotypes", "sample", "out", "rules-out"],
+    };
+    if let Some(k) = needs.iter().find(|k| !opts.contains_key(**k)) {
+        eprintln!("{usage}\nog traits: error: missing --{k}");
+        return 2;
+    }
+    match run(verb, &opts) {
+        Ok(code) => code,
+        Err(e) => {
+            eprintln!("ERROR: {e}");
+            1
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::PathBuf;
+    use std::sync::atomic::{AtomicU64, Ordering};
+    static SEQ: AtomicU64 = AtomicU64::new(0);
+    struct Scratch(PathBuf);
+    impl Scratch {
+        fn new() -> Self {
+            let p = std::env::temp_dir().join(format!(
+                "og-traits-{}-{}",
+                std::process::id(),
+                SEQ.fetch_add(1, Ordering::Relaxed)
+            ));
+            std::fs::create_dir_all(&p).unwrap();
+            Self(p)
+        }
+        fn put(&self, name: &str, text: &str) -> String {
+            let p = self.0.join(name);
+            std::fs::write(&p, text).unwrap();
+            p.to_string_lossy().into_owned()
+        }
+    }
+    impl Drop for Scratch {
+        fn drop(&mut self) {
+            let _ = std::fs::remove_dir_all(&self.0);
+        }
+    }
+    fn assets() -> (Vec<Site>, Vec<Rule>) {
+        let root = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../../assets");
+        (
+            read_table(root.join("traits.tsv").to_str().unwrap()).unwrap(),
+            read_rules(root.join("genotype_rules.tsv").to_str().unwrap()).unwrap(),
+        )
+    }
+    fn genotypes(r: &Rule, choices: &[u8]) -> Genotypes {
+        r.sites
+            .iter()
+            .zip(choices)
+            .map(|(s, v)| {
+                let al = vec![
+                    s.row[if *v == 2 { "alt" } else { "ref" }].clone(),
+                    s.row[if *v == 0 { "ref" } else { "alt" }].clone(),
+                ];
+                (
+                    s.key(),
+                    SiteGt {
+                        alleles: al,
+                        status: Status::Called,
+                        gq: "40".into(),
+                        snv: true,
+                    },
+                )
+            })
+            .collect()
+    }
+    #[test]
+    fn committed_catalogs_and_every_rule_genotype() {
+        let (rows, rules) = assets();
+        assert!(check_rows(&rows).is_empty());
+        assert_eq!(check_rules(&rules, Some(&rows)), Vec::<String>::new());
+        for r in &rules {
+            for mut n in 0..3usize.pow(r.sites.len() as u32) {
+                let mut choices = vec![];
+                for _ in &r.sites {
+                    choices.push((n % 3) as u8);
+                    n /= 3;
+                }
+                let gt = genotypes(r, &choices);
+                let line = rule_line(r, &gt, None);
+                assert!(RULE_OUT.iter().all(|k| line.contains_key(*k)));
+            }
+        }
+    }
+    #[test]
+    fn apoe_grid_keeps_haplotype_order_and_missing_calls() {
+        let (_, rules) = assets();
+        let r = rules.iter().find(|r| r.id == "APOE").unwrap();
+        let expected = [
+            ["e3/e3", "e2/e3", "e2/e2"],
+            ["e3/e4", "e2/e4", "e1/e2"],
+            ["e4/e4", "e1/e4", "e1/e1"],
+        ];
+        for (a, labels) in expected.iter().enumerate() {
+            for (b, label) in labels.iter().enumerate() {
+                let line = rule_line(r, &genotypes(r, &[a as u8, b as u8]), None);
+                assert_eq!(line["status"], "called");
+                assert_eq!(line["result"], *label);
+            }
+        }
+        let mut gt = genotypes(r, &[1, 0]);
+        gt.remove(&r.sites[1].key());
+        let line = rule_line(r, &gt, None);
+        assert_eq!(line["status"], "not_covered");
+        assert_eq!(line["phase"], ".");
+    }
+    #[test]
+    fn schema_faults_are_refused_before_enumeration() {
+        let (rows, rules) = assets();
+        for (k, v, needle) in [
+            ("ref", "N", "not one of"),
+            ("alt", rows[0].row["ref"].as_str(), "same base"),
+            ("pmids", "PMC123", "PubMed"),
+            ("chrom", "chrX", "chr1 to chr22"),
+            ("het", " ", "empty"),
+            ("note", "From SNPedia.", "SNPedia"),
+        ] {
+            let mut bad = rows.clone();
+            bad[0].row.insert(k.into(), v.into());
+            assert!(check_rows(&bad).iter().any(|e| e.contains(needle)), "{k}");
+        }
+        let mut bad = rows.clone();
+        bad.remove(bad.iter().position(|s| s.row["rsid"] == "rs7412").unwrap());
+        assert!(check_rows(&bad).iter().any(|e| e.contains("missing")));
+        let mut bad = rules.clone();
+        bad[0].combos.pop();
+        assert!(
+            check_rules(&bad, Some(&rows))
+                .iter()
+                .any(|e| e.contains("no combination"))
+        );
+        let mut bad = rules.clone();
+        bad[0].haps[0].alleles[0] = "N".into();
+        assert!(
+            check_rules(&bad, None)
+                .iter()
+                .any(|e| e.contains("neither"))
+        );
+        let mut bad = rules.clone();
+        bad[0].sites.clear();
+        assert!(!check_rules(&bad, None).is_empty());
+        let mut bad = rules.clone();
+        bad[0].sites[0].row.insert("pos".into(), "9".into());
+        assert!(
+            check_rules(&bad, Some(&rows))
+                .iter()
+                .any(|e| e.contains("traits table has"))
+        );
+        let mut bad = rules.clone();
+        bad[0].combos[0].key = "absent/absent".into();
+        assert!(
+            check_rules(&bad, None)
+                .iter()
+                .any(|e| e.contains("not two"))
+        );
+        let mut bad = rules.clone();
+        bad[0].combos[1].key = "e3/e2".into();
+        assert!(check_rules(&bad, None).iter().any(|e| e.contains("order")));
+        assert!(
+            check_rules(&rules[1..], Some(&rows))
+                .iter()
+                .any(|e| e.contains("rule APOE is missing"))
+        );
+    }
+    #[test]
+    fn stream_prefers_first_snv_but_checks_every_ref_and_bounds_memory() {
+        let (rows, _) = assets();
+        let s = &rows[0];
+        let scratch = Scratch::new();
+        let prefix = format!("{}\t{}\t", s.row["chrom"], s.row["pos"]);
+        let a = &s.row["ref"];
+        let b = &s.row["alt"];
+        for (gt, status) in [
+            (format!("{a}|{b}"), Status::Called),
+            (format!("./{b}"), Status::OtherAllele),
+            (a.clone(), Status::OtherAllele),
+            ("é/é".into(), Status::OtherAllele),
+        ] {
+            let path = scratch.put("g", &format!("{prefix}{a}\t{b}\t{gt}\t99\n"));
+            let result = read_genotypes(&path, &[s]).unwrap();
+            assert_eq!(result[&s.key()].status, status);
+        }
+        let text = format!(
+            "{prefix}{a}T\t{a}\t{a}T/{a}\n{prefix}{a}\t{b}\t{b}/{a}\t42\n{prefix}{a}\t{b}\t{b}/{b}\t1\n"
+        );
+        let path = scratch.put("g", &text);
+        let result = read_genotypes(&path, &[s]).unwrap();
+        assert_eq!(result[&s.key()].alleles, vec![a.clone(), b.clone()]);
+        assert_eq!(result[&s.key()].gq, "42");
+        let path = scratch.put("bad", &(text + &format!("{prefix}N\t{b}\tN/N\n")));
+        assert!(read_genotypes(&path, &[s]).unwrap_err().contains("GRCh38"));
+        let path = scratch.put("many", &"chr99\t1\tN\t.\tN/N\n".repeat(10000));
+        assert!(read_genotypes(&path, &[s]).unwrap().is_empty());
+    }
+    #[test]
+    fn phase_requires_one_block_and_only_multiple_hets_are_exported() {
+        let (_, rules) = assets();
+        let r = rules.iter().find(|r| r.id == "TAS2R38").unwrap();
+        let gt = genotypes(r, &[1, 1, 1]);
+        assert_eq!(rule_line(r, &gt, None)["phase"], "unphased");
+        assert!(
+            rule_line(r, &gt, Some(&HashMap::new()))["reading"].contains("no read or read pair")
+        );
+        let scratch = Scratch::new();
+        let mut vcf = String::new();
+        let hap1 = &r.haps[0];
+        let hap2 = &r.haps[1];
+        for (i, s) in r.sites.iter().enumerate() {
+            let a = usize::from(hap1.alleles[i] == s.row["alt"]);
+            let b = usize::from(hap2.alleles[i] == s.row["alt"]);
+            vcf += &format!(
+                "{}\t{}\t.\t{}\t{}\t.\tPASS\t.\tGT:PS\t{a}|{b}:7\n",
+                s.row["chrom"], s.row["pos"], s.row["ref"], s.row["alt"]
+            );
+        }
+        let p = scratch.put("phased", &vcf);
+        let mut phased = read_phased(&p, &r.sites.iter().map(Site::key).collect()).unwrap();
+        assert_eq!(rule_line(r, &gt, Some(&phased))["phase"], "read_backed");
+        phased.get_mut(&r.sites[0].key()).unwrap().2 = "8".into();
+        assert_eq!(rule_line(r, &gt, Some(&phased))["status"], "unphased");
+        let path = scratch.put("phase", "");
+        assert_eq!(phase_vcf(&path, "S", &rules, &gt).unwrap(), 3);
+        let text = std::fs::read_to_string(&path).unwrap();
+        assert!(text.contains("141972804\t"));
+        assert!(!text.contains("rs429358"));
+        assert_eq!(
+            phase_vcf(&path, "S", &rules, &genotypes(r, &[1, 0, 0])).unwrap(),
+            0
+        );
+        let gt = genotypes(r, &[0, 0, 0]);
+        assert_eq!(rule_line(r, &gt, None)["phase"], "not_needed");
+    }
+    #[test]
+    fn csv_header_unicode_rules_and_atomic_write_errors() {
+        let scratch = Scratch::new();
+        let mut text = COLUMNS
+            .iter()
+            .map(|k| format!("\"{k}\""))
+            .collect::<Vec<_>>()
+            .join("\t");
+        text.push_str("\r\n");
+        let path = scratch.put("quoted", &text);
+        assert!(read_table(&path).unwrap().is_empty());
+        let path = scratch.put("r", "rule\té\tG\tT\tno\tyes\tN\t1\n");
+        assert!(!check_rules(&read_rules(&path).unwrap(), None).is_empty());
+        assert!(write_tsv(scratch.0.join("absent/x").to_str().unwrap(), OUT, &[]).is_err());
+        assert_eq!(cli(&["table".into()]), 2);
+        assert_eq!(
+            cli(&[
+                "check".into(),
+                "--table".into(),
+                scratch.0.join("absent").to_string_lossy().into_owned()
+            ]),
+            1
+        );
+    }
+}
diff --git a/rust/og/src/main.rs b/rust/og/src/main.rs
index 29c44efa7..7df626a0a 100644
--- a/rust/og/src/main.rs
+++ b/rust/og/src/main.rs
@@ -53,6 +53,9 @@ const USAGE: &str = "usage: og <tool> [args]
        og summary collect --only a [args]
        og chip prepare|report|check-table [args]
        og cn bed|call|intervals|check-bam|marker-regions|marker-read [args]
+       og traits table [args]
+       og traits phase-sites [args]
+       og traits check [args]
        og bloodtype report|check-markers|systems [args]
        og family plan|prepare|check|report|segments [args]
        og family ibd [args]
@@ -216,6 +219,7 @@ fn main() -> ExitCode {
             )),
             None => usage_error("the following arguments are required: chip tool"),
         },
+        "traits" => ExitCode::from(og_steps::traits::cli(rest)),
         "bloodtype" => match rest.first() {
             Some(verb) => ExitCode::from(og_bloodtype::cli(
                 verb,
diff --git a/tests/parity/cases.tsv b/tests/parity/cases.tsv
index 0a9afd6bf..2a2fe1e34 100644
--- a/tests/parity/cases.tsv
+++ b/tests/parity/cases.tsv
@@ -950,3 +950,30 @@ family-ibd	mapbp	gen:ibd-oracle.sh,gen:ibd-cases.sh	--pedigree mapbp/pedigree.ts
 family-ibd	nomap	gen:ibd-oracle.sh,gen:ibd-cases.sh	--pedigree nomap/pedigree.tsv --chroms nomap/chroms.txt --maps nomap/maps --phased nomap/phased --ibd nomap/ibd --out-dir out	-	content	PYTHON_IMAGE
 family-ibd	short	gen:ibd-oracle.sh,gen:ibd-cases.sh	--pedigree short/pedigree.tsv --chroms short/chroms.txt --maps short/maps --phased short/phased --ibd short/ibd --out-dir out	-	content	PYTHON_IMAGE
 family-ibd	twice	gen:ibd-oracle.sh,gen:ibd-cases.sh	--pedigree twice/pedigree.tsv --chroms twice/chroms.txt --maps twice/maps --phased twice/phased --ibd twice/ibd --out-dir out	-	content	PYTHON_IMAGE
+traits	empty	gen:traits.sh	table --table traits.tsv --rules rules.tsv --genotypes empty.tsv --sample S --out traits-out.tsv --rules-out rules-out.tsv	traits-out.tsv,rules-out.tsv	tsv	PYTHON_IMAGE
+traits	reference	gen:traits.sh	table --table traits.tsv --rules rules.tsv --genotypes reference.tsv --sample S --out traits-out.tsv --rules-out rules-out.tsv	traits-out.tsv,rules-out.tsv	tsv	PYTHON_IMAGE
+traits	apoe-00	gen:traits.sh	table --table traits.tsv --rules rules.tsv --genotypes apoe-00.tsv --sample S --out traits-out.tsv --rules-out rules-out.tsv	traits-out.tsv,rules-out.tsv	tsv	PYTHON_IMAGE
+traits	apoe-01	gen:traits.sh	table --table traits.tsv --rules rules.tsv --genotypes apoe-01.tsv --sample S --out traits-out.tsv --rules-out rules-out.tsv	traits-out.tsv,rules-out.tsv	tsv	PYTHON_IMAGE
+traits	apoe-02	gen:traits.sh	table --table traits.tsv --rules rules.tsv --genotypes apoe-02.tsv --sample S --out traits-out.tsv --rules-out rules-out.tsv	traits-out.tsv,rules-out.tsv	tsv	PYTHON_IMAGE
+traits	apoe-10	gen:traits.sh	table --table traits.tsv --rules rules.tsv --genotypes apoe-10.tsv --sample S --out traits-out.tsv --rules-out rules-out.tsv	traits-out.tsv,rules-out.tsv	tsv	PYTHON_IMAGE
+traits	apoe-11	gen:traits.sh	table --table traits.tsv --rules rules.tsv --genotypes apoe-11.tsv --sample S --out traits-out.tsv --rules-out rules-out.tsv	traits-out.tsv,rules-out.tsv	tsv	PYTHON_IMAGE
+traits	apoe-12	gen:traits.sh	table --table traits.tsv --rules rules.tsv --genotypes apoe-12.tsv --sample S --out traits-out.tsv --rules-out rules-out.tsv	traits-out.tsv,rules-out.tsv	tsv	PYTHON_IMAGE
+traits	apoe-20	gen:traits.sh	table --table traits.tsv --rules rules.tsv --genotypes apoe-20.tsv --sample S --out traits-out.tsv --rules-out rules-out.tsv	traits-out.tsv,rules-out.tsv	tsv	PYTHON_IMAGE
+traits	apoe-21	gen:traits.sh	table --table traits.tsv --rules rules.tsv --genotypes apoe-21.tsv --sample S --out traits-out.tsv --rules-out rules-out.tsv	traits-out.tsv,rules-out.tsv	tsv	PYTHON_IMAGE
+traits	apoe-22	gen:traits.sh	table --table traits.tsv --rules rules.tsv --genotypes apoe-22.tsv --sample S --out traits-out.tsv --rules-out rules-out.tsv	traits-out.tsv,rules-out.tsv	tsv	PYTHON_IMAGE
+traits	other	gen:traits.sh	table --table traits.tsv --rules rules.tsv --genotypes other.tsv --sample S --out traits-out.tsv --rules-out rules-out.tsv	traits-out.tsv,rules-out.tsv	tsv	PYTHON_IMAGE
+traits	missing	gen:traits.sh	table --table traits.tsv --rules rules.tsv --genotypes missing.tsv --sample S --out traits-out.tsv --rules-out rules-out.tsv	traits-out.tsv,rules-out.tsv	tsv	PYTHON_IMAGE
+traits	duplicate	gen:traits.sh	table --table traits.tsv --rules rules.tsv --genotypes duplicate.tsv --sample S --out traits-out.tsv --rules-out rules-out.tsv	traits-out.tsv,rules-out.tsv	tsv	PYTHON_IMAGE
+traits	half	gen:traits.sh	table --table traits.tsv --rules rules.tsv --genotypes half.tsv --sample S --out traits-out.tsv --rules-out rules-out.tsv	traits-out.tsv,rules-out.tsv	tsv	PYTHON_IMAGE
+traits	wrong-ref	gen:traits.sh	table --table traits.tsv --rules rules.tsv --genotypes wrong-ref.tsv --sample S --out traits-out.tsv --rules-out rules-out.tsv	-	tsv	PYTHON_IMAGE
+traits	triple	gen:traits.sh	table --table traits.tsv --rules rules.tsv --genotypes triple.tsv --sample S --out traits-out.tsv --rules-out rules-out.tsv	traits-out.tsv,rules-out.tsv	tsv	PYTHON_IMAGE
+traits	single	gen:traits.sh	table --table traits.tsv --rules rules.tsv --genotypes single.tsv --sample S --out traits-out.tsv --rules-out rules-out.tsv	traits-out.tsv,rules-out.tsv	tsv	PYTHON_IMAGE
+traits	phase-empty	gen:traits.sh	table --table traits.tsv --rules rules.tsv --genotypes triple.tsv --phased empty.vcf --sample S --out traits-out.tsv --rules-out rules-out.tsv	traits-out.tsv,rules-out.tsv	tsv	PYTHON_IMAGE
+traits	phase-phased	gen:traits.sh	table --table traits.tsv --rules rules.tsv --genotypes triple.tsv --phased phased.vcf --sample S --out traits-out.tsv --rules-out rules-out.tsv	traits-out.tsv,rules-out.tsv	tsv	PYTHON_IMAGE
+traits	phase-split	gen:traits.sh	table --table traits.tsv --rules rules.tsv --genotypes triple.tsv --phased split.vcf --sample S --out traits-out.tsv --rules-out rules-out.tsv	traits-out.tsv,rules-out.tsv	tsv	PYTHON_IMAGE
+traits	sites-empty	gen:traits.sh	phase-sites --rules rules.tsv --genotypes empty.tsv --sample S --out phase.vcf	phase.vcf	vcf	PYTHON_IMAGE
+traits	sites-triple	gen:traits.sh	phase-sites --rules rules.tsv --genotypes triple.tsv --sample S --out phase.vcf	phase.vcf	vcf	PYTHON_IMAGE
+traits	sites-single	gen:traits.sh	phase-sites --rules rules.tsv --genotypes single.tsv --sample S --out phase.vcf	phase.vcf	vcf	PYTHON_IMAGE
+traits	check	gen:traits.sh	check --table traits.tsv --rules rules.tsv	-	bytes	PYTHON_IMAGE
+traits	bad-table	gen:traits.sh	check --table bad-table.tsv --rules rules.tsv	-	bytes	PYTHON_IMAGE
+traits	bad-rules	gen:traits.sh	check --table traits.tsv --rules bad-rules.tsv	-	bytes	PYTHON_IMAGE
diff --git a/tests/parity/gen/traits.sh b/tests/parity/gen/traits.sh
new file mode 100644
index 000000000..10d0fa26f
--- /dev/null
+++ b/tests/parity/gen/traits.sh
@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+# Public catalogs and synthetic genotype grids for all three traits verbs.
+set -euo pipefail
+root=$(cd "$(dirname "$0")/../../.." && pwd)
+cp "$root/assets/traits.tsv" traits.tsv
+cp "$root/assets/genotype_rules.tsv" rules.tsv
+cat > oracle.sh <<'EOF'
+prog=$1; shift
+mode=$1; shift
+case "$mode" in
+ table) exec python3 "$prog" "$@" ;;
+ check) exec python3 "$prog" "${@/--table/--check-table}" ;;
+ phase-sites)
+   args=()
+   while [ "$#" -gt 0 ]; do
+     if [ "$1" = --out ]; then args+=(--phase-sites "$2"); shift 2
+     else args+=("$1"); shift; fi
+   done
+   exec python3 "$prog" "${args[@]}" ;;
+esac
+EOF
+: > empty.tsv
+awk -F'\t' '$1 !~ /^#/ && $1 != "chrom" {print $1 "\t" $2 "\t" $5 "\t" $6 "\t" $5 "/" $5 "\t40"}' traits.tsv > reference.tsv
+for a in 0 1 2; do
+ for b in 0 1 2; do
+   case $a in 0) ga=T/T;; 1) ga=T/C;; 2) ga=C/C;; esac
+   case $b in 0) gb=C/C;; 1) gb=C/T;; 2) gb=T/T;; esac
+   printf 'chr19\t44908684\tT\tC\t%s\t40\nchr19\t44908822\tC\tT\t%s\t39\n' "$ga" "$gb" > "apoe-$a$b.tsv"
+ done
+done
+printf 'chr19\t44908684\tT\tC\tT/G\t30\nchr19\t44908822\tC\tT\tC/C\t40\n' > other.tsv
+printf 'chr19\t44908684\tT\tC\tT/C\t30\n' > missing.tsv
+printf 'chr19\t44908684\tTT\tT\tTT/T\t10\nchr19\t44908684\tT\tC\tC/T\t40\n' > duplicate.tsv
+printf 'chr19\t44908684\tG\tC\tG/C\t30\n' > wrong-ref.tsv
+printf 'chr19\t44908684\tT\tC\t./C\t30\n' > half.tsv
+printf 'chr7\t141973545\tC\tG\tC/G\t30\nchr7\t141972905\tG\tC\tG/C\t31\nchr7\t141972804\tT\tC\tT/C\t32\n' > triple.tsv
+head -1 triple.tsv > single.tsv
+: > empty.vcf
+printf 'chr7\t141973545\t.\tC\tG\t.\tPASS\t.\tGT:PS\t1|0:7\nchr7\t141972905\t.\tG\tC\t.\tPASS\t.\tGT:PS\t0|1:7\nchr7\t141972804\t.\tT\tC\t.\tPASS\t.\tGT:PS\t1|0:7\n' > phased.vcf
+sed '1s/:7$/:8/' phased.vcf > split.vcf
+awk -F'\t' -v OFS='\t' '$1 == "combination" && $2 == "APOE" && $3 == "e3/e3" {next} {print}' rules.tsv > bad-rules.tsv
+awk -F'\t' -v OFS='\t' '$3 == "rs671" {$6=$5} {print}' traits.tsv > bad-table.tsv
diff --git a/tests/parity/oracle.ref b/tests/parity/oracle.ref
index 57c27da2f..526797497 100644
--- a/tests/parity/oracle.ref
+++ b/tests/parity/oracle.ref
@@ -63,3 +63,4 @@ y-yleaf-positions	0baddb45aa3871a57469cf20295bdd832f72f5c0	file:bin/yleaf_run.py
 lookup	0baddb45aa3871a57469cf20295bdd832f72f5c0	file:bin/genome_lookup.py	python3	lookup
 lookup-query	0baddb45aa3871a57469cf20295bdd832f72f5c0	file:bin/genome_lookup.py	bash ./oracle.sh	lookup query
 family-ibd	0baddb45aa3871a57469cf20295bdd832f72f5c0	file:bin/ibd_report.py	sh ./ibd_oracle.sh	family ibd
+traits	669a8196	file:bin/traits_report.py	bash ./oracle.sh	traits

From fcb7ac4ec4dc547074f5b4e12699ae9ecb1c24ef Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 15:08:29 +0100
Subject: [PATCH 37/76] test(ci): expose five more Python scanner mismatches

---
 rust/crates/og-dev/src/personal_data.rs | 66 +++++++++++++++++++++++--
 1 file changed, 62 insertions(+), 4 deletions(-)

diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
index 030cc5d7e..d97cb54e6 100644
--- a/rust/crates/og-dev/src/personal_data.rs
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -632,6 +632,10 @@ mod tests {
     // Execute the removed scanner itself. Only its reporting is adapted to
     // structured metadata, because printing findings is the bug being fixed.
     fn oracle(f: &Fixture, files: &[&str], cached: bool) -> String {
+        oracle_options(f, files, cached, "", "", "")
+    }
+
+    fn oracle_options(f: &Fixture, files: &[&str], cached: bool, allow: &str, skip: &str, patterns: &str) -> String {
         static PYTHON: LazyLock<String> = LazyLock::new(|| {
             const SHA: &str = "4104a93f2121b457413336574b8563fe85291fd7";
             let repo = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../..");
@@ -678,7 +682,7 @@ mod tests {
         let mut cmd = Command::new("python3");
         cmd.args(["-I", "-c", &PYTHON])
             .arg(&f.0)
-            .args(["", "", "", if cached { "1" } else { "" }]);
+            .args([allow, skip, patterns, if cached { "1" } else { "" }]);
         for file in files {
             cmd.arg(f.0.join(file));
         }
@@ -692,8 +696,15 @@ mod tests {
     }
 
     fn assert_oracle_findings(f: &Fixture, files: &[&str], cached: bool) {
-        let expected = oracle(f, files, cached);
+        assert_options(f, files, cached, "", "", "", true);
+    }
+
+    fn assert_options(f: &Fixture, files: &[&str], cached: bool, allow: &str, skip: &str, patterns: &str, require_finding: bool) {
+        let expected = oracle_options(f, files, cached, allow, skip, patterns);
         let mut args = f.args(files);
+        args[3] = allow.into();
+        args[5] = skip.into();
+        if !patterns.is_empty() { args.extend(["--patterns".into(), patterns.into()]); }
         if cached {
             args.insert(0, "--cached".into());
         }
@@ -723,8 +734,8 @@ mod tests {
             );
             count += 1;
         }
-        assert!(count > 0, "oracle control was clean");
-        assert_eq!(code, 1);
+        if require_finding { assert!(count > 0, "oracle control was clean"); }
+        assert_eq!(code, u8::from(count > 0));
         assert_eq!(
             out.lines().filter(|l| l.starts_with("FAIL ")).count(),
             count
@@ -868,4 +879,51 @@ mod tests {
         std::fs::write(f.0.join(names[5]), b"\0binary").unwrap();
         assert_oracle_findings(&f, &names, false);
     }
+
+    #[test]
+    fn round2_boundary_backtracking() {
+        let f = Fixture::new("r2-boundary");
+        std::fs::write(f.0.join("chip.md"), "rs987654\t1\t9\tA-\n").unwrap();
+        assert_oracle_findings(&f, &["chip.md"], false);
+        assert!(Command::new("git").arg("-C").arg(&f.0).args(["init", "-q"]).status().unwrap().success());
+        assert!(Command::new("git").arg("-C").arg(&f.0).args(["add", "chip.md"]).status().unwrap().success());
+        assert_oracle_findings(&f, &["chip.md"], true);
+    }
+
+    #[test]
+    fn round2_custom_unicode() {
+        let f = Fixture::new("r2-custom");
+        for (pattern, text) in [(r"\bZetaSecret\b", "\u{301}ZetaSecret"), (r"(?i)patient", "patİent"), (r"(?i)[A-Z]+", "İı"), (r"\s+", "\u{1c}"), (r"\W+", "\u{301}"), (r"[^\w]+", "\u{301}")] {
+            std::fs::write(f.0.join("patterns"), pattern).unwrap();
+            std::fs::write(f.0.join("own.md"), text).unwrap();
+            assert_options(&f, &["own.md"], false, "", "", f.0.join("patterns").to_str().unwrap(), true);
+        }
+    }
+
+    #[test]
+    fn round2_cr_patterns() {
+        let f = Fixture::new("r2-pattern-lines");
+        for prefix in ["# a comment", "Unrelated"] {
+            std::fs::write(f.0.join("patterns"), format!("{prefix}\rZETA_PRIVATE_MARKER\r")).unwrap();
+            std::fs::write(f.0.join("own.md"), "ZETA_PRIVATE_MARKER\n").unwrap();
+            assert_options(&f, &["own.md"], false, "", "", f.0.join("patterns").to_str().unwrap(), true);
+        }
+    }
+
+    #[test]
+    fn round2_empty_alternative() {
+        let f = Fixture::new("r2-empty");
+        std::fs::write(f.0.join("patterns"), "^|PUBLIC_PRIVATE\n").unwrap();
+        std::fs::write(f.0.join("own.md"), "PUBLIC_PRIVATE").unwrap();
+        assert_options(&f, &["own.md"], false, "own.md PUBLIC", "", f.0.join("patterns").to_str().unwrap(), true);
+    }
+
+    #[test]
+    fn round2_exception_lines() {
+        let f = Fixture::new("r2-allow");
+        let text = p("safe\rOTHER.md /home/~synthetic_private_marker/path\n");
+        std::fs::write(f.0.join("builtin-allow.md"), &text).unwrap();
+        assert_options(&f, &["builtin-allow.md"], false, &format!("builtin-allow.md {text}"), "", "", true);
+    }
+
 }

From 17842fb53220882b008ef11b5b4a4e8663a1ced1 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 15:09:21 +0100
Subject: [PATCH 38/76] fix(ci): preserve fractional trace diagnostics and
 count PCA rows

Bead: pgp-bs9u.38
---
 rust/crates/og-dev/src/nf_trace.rs            | 15 +++++++++------
 rust/crates/og-dev/src/smoke.rs               |  1 +
 rust/crates/og-dev/tests/ci_readers.rs        |  6 +++++-
 tests/parity/cases.tsv                        |  2 ++
 .../golden/dev-smoke-check/eigen/stdout       |  2 +-
 .../inputs/ci-readers/requests-frac.tsv       | 19 +++++++++++++++++++
 6 files changed, 37 insertions(+), 8 deletions(-)
 create mode 100644 tests/parity/inputs/ci-readers/requests-frac.tsv

diff --git a/rust/crates/og-dev/src/nf_trace.rs b/rust/crates/og-dev/src/nf_trace.rs
index ac9441b72..2a0aef041 100644
--- a/rust/crates/og-dev/src/nf_trace.rs
+++ b/rust/crates/og-dev/src/nf_trace.rs
@@ -7,6 +7,9 @@ const GB: u64 = 1 << 30;
 const H: u64 = 3_600_000;
 type Record = BTreeMap<String, String>;
 
+fn g(value: u64, unit: u64) -> String {
+    pycompat::fmt::general(value as f64 / unit as f64, 6)
+}
 fn records(path: &str, mut f: impl FnMut(Record) -> Result<(), String>) -> Result<(), String> {
     if path.contains(['*', '?', '[', ']']) {
         return Err("trace glob refused: pass exactly one explicit trace path".into());
@@ -214,8 +217,8 @@ fn requests(path: &str, opts: &BTreeMap<&str, &str>, out: &mut dyn Write) -> Res
             out,
             "{name}: attempt {attempt}, exit {}, cpus {cpus}, memory {} GB, time {} h",
             cell(r, "exit")?,
-            mem / GB,
-            time / H
+            g(mem, GB),
+            g(time, H)
         )
         .map_err(|e| e.to_string())?;
         seen.entry(proc)
@@ -260,7 +263,7 @@ fn requests(path: &str, opts: &BTreeMap<&str, &str>, out: &mut dyn Write) -> Res
         }
         for got in first.into_iter().flat_map(|a| a.values()).flatten() {
             if *got != expected {
-                writeln!(out,"FAIL {proc}: first attempt asks for cpus {}, memory {} GB, time {} h; want {}, {} GB, {} h",got.0,got.1/GB,got.2/H,expected.0,expected.1/GB,expected.2/H).map_err(|e| e.to_string())?;
+                writeln!(out,"FAIL {proc}: first attempt asks for cpus {}, memory {} GB, time {} h; want {}, {} GB, {} h",got.0,g(got.1,GB),g(got.2,H),expected.0,g(expected.1,GB),g(expected.2,H)).map_err(|e| e.to_string())?;
                 bad += 1;
             }
         }
@@ -269,8 +272,8 @@ fn requests(path: &str, opts: &BTreeMap<&str, &str>, out: &mut dyn Write) -> Res
                 writeln!(
                     out,
                     "FAIL {proc}: the retry asks for {} GB, want {} GB",
-                    got.1 / GB,
-                    expected.1 / GB * 2
+                    g(got.1, GB),
+                    pycompat::fmt::general(expected.1 as f64 * 2. / GB as f64, 6)
                 )
                 .map_err(|e| e.to_string())?;
                 bad += 1;
@@ -283,7 +286,7 @@ fn requests(path: &str, opts: &BTreeMap<&str, &str>, out: &mut dyn Write) -> Res
     let mem: u64 = opt(opts, "--executor-mem-gb")?
         .parse()
         .map_err(|_| "invalid executor memory")?;
-    writeln!(out,"{} task attempts ask for {all_cpus} CPUs and {} GB added together; the executor is told it has {cpus} CPUs and {mem} GB",rows.len(),all_mem/GB).map_err(|e| e.to_string())?;
+    writeln!(out,"{} task attempts ask for {all_cpus} CPUs and {} GB added together; the executor is told it has {cpus} CPUs and {} GB",rows.len(),g(all_mem,GB),pycompat::fmt::general(mem as f64,6)).map_err(|e| e.to_string())?;
     if all_cpus > cpus || Some(all_mem) > mem.checked_mul(GB) {
         writeln!(out,"FAIL: executor.cpus or executor.memory of this step is below that sum; raise exec_cpus / exec_mem_gb").map_err(|e| e.to_string())?;
         bad += 1;
diff --git a/rust/crates/og-dev/src/smoke.rs b/rust/crates/og-dev/src/smoke.rs
index 379b1d7be..950d023cf 100644
--- a/rust/crates/og-dev/src/smoke.rs
+++ b/rust/crates/og-dev/src/smoke.rs
@@ -295,6 +295,7 @@ fn check(kind: &str, path: &str, out: &mut dyn Write) -> Result<bool, String> {
                 if line.trim_start().starts_with('#') || r.is_empty() {
                     continue;
                 }
+                n += 1;
                 let g = match r.last() {
                     Some(&"PopA") => 0,
                     Some(&"PopB") => 1,
diff --git a/rust/crates/og-dev/tests/ci_readers.rs b/rust/crates/og-dev/tests/ci_readers.rs
index 18a09ea89..a497e9307 100644
--- a/rust/crates/og-dev/tests/ci_readers.rs
+++ b/rust/crates/og-dev/tests/ci_readers.rs
@@ -224,7 +224,11 @@ fn smoke_tables_reject_removed_properties() {
         ),
     ] {
         let p = t.file("table", good);
-        assert_eq!(run(smoke::cli, &["check", kind, &p]).0, 0, "{kind}");
+        let clean = run(smoke::cli, &["check", kind, &p]);
+        assert_eq!(clean.0, 0, "{kind}");
+        if kind == "eigen" {
+            assert_eq!(clean.1, "eigen: 3 rows; OK\n");
+        }
         let p = t.file("table", bad);
         assert_eq!(run(smoke::cli, &["check", kind, &p]).0, 1, "{kind}");
     }
diff --git a/tests/parity/cases.tsv b/tests/parity/cases.tsv
index 04f0538e9..bbb1750da 100644
--- a/tests/parity/cases.tsv
+++ b/tests/parity/cases.tsv
@@ -980,3 +980,5 @@ dev-pharmcat-called	pharmcat-docs-example	ci-readers/oracle.sh,gen:ci-pharmcat.s
 dev-pharmcat-lines	report-3.2.0	ci-readers/oracle.sh,gen:ci-pharmcat.sh	report-3.2.0.json --called-lines	-	bytes	PYTHON_IMAGE
 dev-pharmcat-lines	report-3.4.0	ci-readers/oracle.sh,gen:ci-pharmcat.sh	report-3.4.0.json --called-lines	-	bytes	PYTHON_IMAGE
 dev-pharmcat-lines	pharmcat-docs-example	ci-readers/oracle.sh,gen:ci-pharmcat.sh	pharmcat-docs-example.json --called-lines	-	bytes	PYTHON_IMAGE
+dev-nf-requests	large-budget	ci-readers/oracle.sh,ci-readers/requests.tsv,ci-readers/want.tsv	requests.tsv --want want.tsv --executor-cpus 1000000 --executor-mem-gb 1000000	-	bytes	PYTHON_IMAGE
+dev-nf-requests	fractional-memory	ci-readers/oracle.sh,ci-readers/requests-frac.tsv,ci-readers/want.tsv	requests-frac.tsv --want want.tsv --executor-cpus 512 --executor-mem-gb 2048	-	bytes	PYTHON_IMAGE
diff --git a/tests/parity/golden/dev-smoke-check/eigen/stdout b/tests/parity/golden/dev-smoke-check/eigen/stdout
index 112b6bd29..f1e05c34a 100644
--- a/tests/parity/golden/dev-smoke-check/eigen/stdout
+++ b/tests/parity/golden/dev-smoke-check/eigen/stdout
@@ -1 +1 @@
-eigen: 0 rows; OK
+eigen: 3 rows; OK
diff --git a/tests/parity/inputs/ci-readers/requests-frac.tsv b/tests/parity/inputs/ci-readers/requests-frac.tsv
new file mode 100644
index 000000000..0d7e904e9
--- /dev/null
+++ b/tests/parity/inputs/ci-readers/requests-frac.tsv
@@ -0,0 +1,19 @@
+task_id	name	attempt	exit	cpus	memory	time
+1	X:DEEPVARIANT (s)	1	137	8	17716740096	172800000
+2	X:DEEPVARIANT (s)	2	0	8	68719476736	172800000
+3	X:FASTP (s)	1	137	8	8589934592	28800000
+4	X:FASTP (s)	2	0	8	17179869184	28800000
+5	X:ALIGN_MINIMAP2 (s)	1	137	8	34359738368	86400000
+6	X:ALIGN_MINIMAP2 (s)	2	0	8	68719476736	86400000
+7	X:MANTA (s)	1	137	8	17179869184	86400000
+8	X:MANTA (s)	2	0	8	34359738368	86400000
+9	X:CNVPYTOR (s)	1	137	4	8589934592	86400000
+10	X:CNVPYTOR (s)	2	0	4	17179869184	86400000
+11	X:VEP (s)	1	137	8	17179869184	86400000
+12	X:VEP (s)	2	0	8	34359738368	86400000
+13	X:PRS_PREPARE (s)	1	137	1	2147483648	7200000
+14	X:PRS_PREPARE (s)	2	0	1	4294967296	7200000
+15	X:PRS_SCORE_SITES (s)	1	137	2	4294967296	14400000
+16	X:PRS_SCORE_SITES (s)	2	0	2	8589934592	14400000
+17	X:PRS (s)	1	137	4	25769803776	28800000
+18	X:PRS (s)	2	0	4	51539607552	28800000

From c4e77149c378507c8246b74db17c37b200f65483 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 15:10:38 +0100
Subject: [PATCH 39/76] refactor(traits): switch step 42 and remove the
 replaced Python

Bead: pgp-bs9u.25
---
 .github/workflows/guard.yml              |   2 +-
 CHANGELOG.md                             |   4 +
 bin/copy_number.py                       | 344 -------------
 bin/traits_report.py                     | 605 +----------------------
 docs/42-traits.md                        |   6 +-
 docs/rust.md                             |   5 +
 modules/local/traits/main.nf             |   6 +-
 rust/README.md                           |   4 +
 rust/crates/og-steps/src/traits.rs       |  36 +-
 scripts/42-traits.sh                     |   4 +-
 scripts/ci/e2e-case-paths.tsv            |  71 +--
 scripts/ci/e2e-case-times.tsv            |   1 +
 tests/demo/make_demo_sample.py           |  20 +-
 tests/e2e/genotype-rules-2-g2.sh         |  14 +-
 tests/e2e/report-followups-1-sections.sh |  16 +-
 tests/e2e/rust-c2b-traits.sh             |  28 ++
 tests/parity/README.md                   |   5 +
 tests/parity/gen/traits.sh               |   4 +-
 tests/parity/oracle.ref                  |   2 +-
 tests/parity/remnants.tsv                |   1 +
 tests/test_collect_summary.py            |  16 +-
 tests/test_copy_number.py                |  25 +-
 tests/test_genotype_rules_indels.py      |   5 +-
 tests/test_hba_copy_number.py            |   2 +-
 tests/test_lpa_kiv2.py                   |   2 +-
 tests/test_render_report.py              |   5 +-
 tests/test_traits_report.py              | 481 +++---------------
 tests/test_traits_table.py               |  43 +-
 28 files changed, 267 insertions(+), 1490 deletions(-)
 delete mode 100755 bin/copy_number.py
 create mode 100755 tests/e2e/rust-c2b-traits.sh

diff --git a/.github/workflows/guard.yml b/.github/workflows/guard.yml
index 304360fbd..7ee58a0dc 100644
--- a/.github/workflows/guard.yml
+++ b/.github/workflows/guard.yml
@@ -351,7 +351,7 @@ jobs:
                    tests/test_results_index.py \
                    tests/test_pgx_outside_calls.py tests/test_hla_second_caller.py tests/test_paraphase_report.py \
                    tests/test_copy_number.py tests/test_hba_copy_number.py \
-                   tests/test_lpa_kiv2.py tests/test_traits_report.py tests/test_callability.py; do
+                   tests/test_lpa_kiv2.py tests/test_traits_report.py tests/test_traits_table.py tests/test_genotype_rules_indels.py tests/test_callability.py; do
             rc=0
             echo "::group::${t}"
             case "$t" in
diff --git a/CHANGELOG.md b/CHANGELOG.md
index cd74b71a6..8400d72da 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,10 @@ Each release's notes. From 1.0.0 on, a major or minor release has hand-written n
 
 ## Unreleased
 
+- Step 42 reads traits and genotype rules with `og traits table`, exports WhatsHap sites with `og traits phase-sites`, and checks the catalogs with `og traits check`. The replaced Python evaluator is removed. Report columns and readings stay the same. Genotypes outside the catalog are streamed past, and write errors now report a controlled error instead of a traceback.
+- The unused Python copy-number engine is removed. Its historical catalog tests materialise a pinned test oracle and keep testing the Rust commands.
+
+
 - The container helpers check (`scripts/ci/check-container-helpers.sh`, Guard job `helper-binaries`) now derives its table with the Rust `og` binary, `og dev helpers`. It replaces the Python inside the script, which is gone; the script keeps the docker probe, the orad download and its self-test. On this tree the table and the rule 1 output are the same, byte for byte. The static run takes 0.01 s and 6 MB where the Python took 0.2 s and 15 MB. What changes:
   - A helper called in a process's `shell:` block is checked too. The Python read only `script:` blocks, so such a call went unchecked. No module has one today.
   - A helper called in a process's `exec:` block always fails the check: Nextflow runs that block on the host, where no image applies.
diff --git a/bin/copy_number.py b/bin/copy_number.py
deleted file mode 100755
index 2e1b95485..000000000
--- a/bin/copy_number.py
+++ /dev/null
@@ -1,344 +0,0 @@
-#!/usr/bin/env python3
-"""copy_number.py: the catalog reader and the depth-ratio engine of
-bin/cn_loci.tsv, as the catalog tests (tests/test_copy_number.py,
-test_hba_copy_number.py, test_lpa_kiv2.py) import them. No step runs it.
-
-The commands are og cn's (rust/crates/og-cn, docs/cn-loci.md): `og cn bed`
-prints a locus's segments, `og cn call` turns `samtools bedcov` over them
-into the step's table, `og cn intervals` reads the interval rows and `og cn
-check-bam` refuses a BAM aligned with ALT contigs, and `og bloodtype
-report` reads step 41's RHD row with og cn's engine. This file keeps
-load_catalog, assess, cut_copies, BrokenControl and CatalogError for those
-tests until they move to og too.
-
-One method, one catalog row per locus: the depth over the locus's target
-segments against the depth over single-copy control segments, as
-`samtools bedcov` sums it. With T the target depth and C the control depth
-(each combined as the row's target_depth and control_depth say),
-    estimate = scale x T / C - offset
-then guarded by a minimum control depth, flank agreement and the share of the
-target depth from reads of mapping quality 0, and called as the row's `call`
-column says. docs/cn-loci.md describes the columns and how to add a locus.
-Standard library only.
-"""
-import csv
-import math
-import os
-
-CATALOG = os.path.join(os.path.dirname(os.path.abspath(__file__)), "cn_loci.tsv")
-COLUMNS = ["locus", "kind", "chrom", "targets", "controls", "details", "target_depth", "control_depth",
-           "scale", "offset", "bedcov", "mapq0_min", "mapq0_max", "min_control_depth", "max_control_ratio",
-           "call", "interval", "readings", "input", "owner", "cross_check", "pmids"]
-KINDS = ("gene", "interval", "organelle")
-# GRCh38 names of the primary chromosomes (the ClinGen BED spells chrX 'chrx':
-# scripts/ci/build-cn-intervals.py normalises it, and a row with any other
-# spelling is refused here).
-CHROMS = {f"chr{c}" for c in list(range(1, 23)) + ["X", "Y", "M"]}
-INPUTS = ("bedcov", "cnvpytor-level")
-Z95 = 1.96
-# The findings a psv row needs a reading for.
-PSV_FINDINGS = ("none", "deletion", "conversion", "pseudogene_deletion")
-BASES = "ACGT"
-
-
-class CatalogError(ValueError):
-    pass
-
-
-class BrokenControl(ValueError):
-    """A control segment with no read while the other controls are covered."""
-
-
-def _num(row, col, default=None):
-    v = row[col]
-    if v == ".":
-        return default
-    try:
-        x = float(v)
-    except ValueError:
-        x = math.nan
-    if not math.isfinite(x):
-        raise CatalogError(f"{row['locus']}: {col} is {v!r}, not a number or '.'")
-    return x
-
-
-def _segments(row, col):
-    """[(name, start, end, label)] of a targets, controls or details cell."""
-    if row[col] == ".":
-        return []
-    out = []
-    for part in row[col].split(";"):
-        bits = part.split(":", 2)
-        try:
-            name, (s, e) = bits[0], bits[1].split("-")
-            start, end = int(s), int(e)
-        except (IndexError, ValueError):
-            raise CatalogError(f"{row['locus']}: {col} segment {part!r} is not NAME:start-end[:label]")
-        if not name or end <= start or start < 0:
-            raise CatalogError(f"{row['locus']}: {col} segment {part!r} has no name or an empty span")
-        out.append((name, start, end, bits[2] if len(bits) > 2 else ""))
-    return out
-
-
-def _readings(row):
-    out = {}
-    if row["readings"] == ".":
-        return out
-    for part in row["readings"].split("|"):
-        k, sep, text = part.partition("=")
-        if not sep or not k or not text:
-            raise CatalogError(f"{row['locus']}: reading {part!r} is not KEY=text")
-        out[k] = text
-    return out
-
-
-def _call(row):
-    mode, sep, args = row["call"].partition(":")
-    try:
-        vals = [float(x) for x in args.split(",")]
-    except ValueError:
-        vals = []
-    if not all(math.isfinite(v) for v in vals):
-        vals = []
-    if not sep or mode not in ("round", "cut", "class", "psv") or not vals \
-            or (mode in ("round", "psv") and len(vals) != 1) or (mode == "class" and len(vals) != 2) \
-            or vals != sorted(vals):
-        raise CatalogError(f"{row['locus']}: call {row['call']!r} is not round:D, cut:A,B..., class:LOW,HIGH or psv:D")
-    return mode, vals
-
-
-def _psv_sites(row, details):
-    """[(name, gene 0-based position, pseudogene 0-based position, gene
-    bases, pseudogene bases, text)] of a psv row: every details segment is one
-    base, labelled 'PSEUDO_POS GENE>PSEUDO text' (bases among ACGT; In2G's
-    gene base is A or C)."""
-    out = []
-    for name, s, e, label in details:
-        bits = label.split(" ", 2)
-        try:
-            pos = int(bits[0])
-            gene, _, pseudo = bits[1].partition(">")
-        except (IndexError, ValueError):
-            raise CatalogError(f"{row['locus']}: PSV {name} label {label!r} is not 'PSEUDO_POS GENE>PSEUDO text'")
-        if e - s != 1 or pos < 0 or not gene or not pseudo or set(gene + pseudo) - set(BASES) \
-                or set(gene) & set(pseudo) or len(bits) < 3:
-            raise CatalogError(f"{row['locus']}: PSV {name} must be one base with distinct gene and pseudogene "
-                               f"bases and a text (got {s}-{e}, {label!r})")
-        out.append((name, s, pos, set(gene), set(pseudo), bits[2]))
-    return out
-
-
-def parse_row(row):
-    """The catalog row checked, with its parsed fields under '_' keys."""
-    loc = row["locus"]
-    if row["kind"] not in KINDS:
-        raise CatalogError(f"{loc}: kind {row['kind']!r} (one of {', '.join(KINDS)})")
-    if row["input"] not in INPUTS:
-        raise CatalogError(f"{loc}: input {row['input']!r} (one of {', '.join(INPUTS)})")
-    if row["chrom"] not in CHROMS:
-        raise CatalogError(f"{loc}: chrom {row['chrom']!r} (GRCh38 names, chr1 to chrM)")
-    p = dict(row)
-    p["_targets"], p["_controls"], p["_details"] = (_segments(row, c) for c in ("targets", "controls", "details"))
-    p["_call"] = _call(row)
-    p["_readings"] = _readings(row)
-    p["_psv"] = _psv_sites(row, p["_details"]) if p["_call"][0] == "psv" else []
-    if p["_call"][0] == "psv" and (not p["_psv"] or row["target_depth"] != "sum"
-                                   or not set(PSV_FINDINGS) <= set(p["_readings"])):
-        raise CatalogError(f"{loc}: call psv needs PSV sites in details, target_depth sum (gene and pseudogene) "
-                           f"and a reading for each of {', '.join(PSV_FINDINGS)}")
-    if not p["_targets"]:
-        raise CatalogError(f"{loc}: no target segment")
-    if row["input"] == "bedcov":
-        if not p["_controls"]:
-            raise CatalogError(f"{loc}: a bedcov row needs control segments")
-        if row["target_depth"] not in ("sum", "pooled") or row["control_depth"] not in ("flanks", "pooled"):
-            raise CatalogError(f"{loc}: target_depth sum|pooled and control_depth flanks|pooled")
-        p["_scale"], p["_offset"] = _num(row, "scale"), _num(row, "offset", 0.0)
-        if not p["_scale"] or p["_scale"] <= 0:
-            raise CatalogError(f"{loc}: scale must be a positive number")
-        p["_min_control"] = _num(row, "min_control_depth", 0.0)
-        p["_max_ratio"] = _num(row, "max_control_ratio")
-        p["_mapq0_min"], p["_mapq0_max"] = _num(row, "mapq0_min"), _num(row, "mapq0_max")
-        p["_passes"] = row["bedcov"].split(",")
-        if (p["_mapq0_min"] is not None or p["_mapq0_max"] is not None) and len(p["_passes"]) != 2:
-            raise CatalogError(f"{loc}: a MAPQ 0 guard needs two bedcov passes (all reads, MAPQ >= 1)")
-        if p["_call"][0] == "class" and row["interval"] != "cv":
-            raise CatalogError(f"{loc}: call class needs interval cv")
-        if row["interval"] not in ("cv", "."):
-            raise CatalogError(f"{loc}: interval {row['interval']!r} (cv or '.')")
-    names = [n for n, *_ in p["_targets"] + p["_controls"] + p["_details"]]
-    if len(names) != len(set(names)):
-        raise CatalogError(f"{loc}: a segment name is used twice")
-    return p
-
-
-def load_catalog(path=None):
-    """{locus: parsed row} of the catalog, in file order."""
-    path = path or CATALOG
-    with open(path) as f:
-        lines = [ln for ln in f if ln.strip() and not ln.startswith("#")]
-    rows = list(csv.DictReader(lines, delimiter="\t", quoting=csv.QUOTE_NONE))
-    if not rows or list(rows[0].keys()) != COLUMNS:
-        raise CatalogError(f"{path}: the header must be {' '.join(COLUMNS)}")
-    out, seen = {}, set()
-    for r in rows:
-        if None in r or None in r.values():
-            raise CatalogError(f"{path}: row {r.get('locus')!r} has the wrong number of columns")
-        if r["locus"] in out:
-            raise CatalogError(f"{path}: locus {r['locus']} is listed twice")
-        p = parse_row(r)
-        for n, *_ in p["_targets"] + p["_controls"] + p["_details"]:
-            if n in seen:
-                raise CatalogError(f"{path}: segment name {n} is used by two loci")
-            seen.add(n)
-        out[r["locus"]] = p
-    return out
-
-
-def regions(row):
-    """[(chrom, start, end, name)] of a row's segments, sorted by position."""
-    segs = row["_controls"] + row["_targets"] + row["_details"]
-    return sorted(((row["chrom"], s, e, n) for n, s, e, _ in segs), key=lambda r: (r[1], r[2]))
-
-
-def _combine(mode, segs, m):
-    if mode == "sum":
-        return sum(m[n] for n, *_ in segs)
-    if mode == "flanks":
-        return sum(m[n] for n, *_ in segs) / len(segs)
-    return sum(m[n] * (e - s) for n, s, e, _ in segs) / sum(e - s for _, s, e, _ in segs)
-
-
-def _cv(values):
-    """Coefficient of variation (sample standard deviation over the mean)."""
-    mu = sum(values) / len(values)
-    if mu <= 0 or len(values) < 2:
-        return 0.0
-    return math.sqrt(sum((v - mu) ** 2 for v in values) / (len(values) - 1)) / mu
-
-
-def cut_copies(value, cuts):
-    """The number of cut points a value reaches (cut:0.5,1.5 gives 0, 1 or 2)."""
-    return sum(value >= c for c in cuts)
-
-
-def reading(row, key):
-    r = row["_readings"]
-    if str(key) in r:
-        return r[str(key)]
-    if isinstance(key, int) and "more" in r and key > max(int(k) for k in r if k.isdigit()):
-        return r["more"].format(n=key)
-    return ""
-
-
-def ploidy(row, sex):
-    """The copies of the row's chromosome a sample has: 2, or 1 on a male's
-    chrX or chrY; None where it cannot be said (a chrY row on a female or on
-    a sample of no known sex, a chrX row without a sex)."""
-    if row["chrom"] not in ("chrX", "chrY"):
-        return 2
-    if sex == "male":
-        return 1
-    if sex == "female" and row["chrom"] == "chrX":
-        return 2
-    return None
-
-
-def assess(row, m, q1=None, sex=None):
-    """The locus's block for mean depths m (every read) and q1 (reads of
-    MAPQ >= 1, or None for a row without a MAPQ 0 guard; mapq0_share is then
-    None).
-
-    status is 'called' or 'not assessed'; reason names the guard that
-    stopped it: no_data, low_control_depth, controls_disagree,
-    low_mapq0_share, high_mapq0_share, below_floor, between_counts,
-    sex_unknown; status 'not applicable' (reason no_y) for a chrY row on a
-    female. sex matters only for a row on chrX or chrY: there the controls
-    sit on the same chromosome, so the scale follows the sample's count
-    there (ploidy). expected is the count with no change."""
-    guarded = q1 is not None
-    if not guarded and (row["_mapq0_min"] is not None or row["_mapq0_max"] is not None):
-        raise ValueError(f"{row['locus']} has a MAPQ 0 guard: the MAPQ >= 1 depths are needed")
-    q1 = q1 if guarded else {}
-    tg, ct = row["_targets"], row["_controls"]
-    b = {"locus": row["locus"], "status": "not assessed", "reason": None, "estimate": None, "total": None,
-         "copies": None, "ci95": None, "class": None, "target_depth": None, "control_depth": None,
-         "depths": dict(m), "mapq0_share": None, "details": {}, "reading": "", "expected": None}
-    # expected: the copies with no change, the ploidy times the reference
-    # units (each target segment is one with target_depth sum: AZFc's 4 DAZ)
-    units = len(row["_targets"]) if row.get("target_depth") == "sum" else 1
-    pl = ploidy(row, sex)
-    b["expected"] = None if pl is None else pl * units
-    if row["chrom"] == "chrY" and sex == "female":
-        b.update(status="not applicable", reason="no_y")
-        return b
-    if pl is None:
-        b["reason"] = "sex_unknown"
-        return b
-    if not m or any(n not in m for n, *_ in tg + ct):
-        b["reason"] = "no_data"
-        return b
-    for n, *_ in ct:
-        rest = [c for c in ct if c[0] != n]
-        if m[n] == 0 and rest and _combine(row["control_depth"], rest, m) >= row["_min_control"] > 0:
-            raise BrokenControl(f"BROKEN_CONTROL: control segment {n} of {row['locus']} has no read while the "
-                                f"other controls have {_combine(row['control_depth'], rest, m):.1f}x; check its "
-                                "coordinates in bin/cn_loci.tsv (or the sample lacks that stretch)")
-    T, C = _combine(row["target_depth"], tg, m), _combine(row["control_depth"], ct, m)
-    tq = _combine(row["target_depth"], tg, {n: q1.get(n, 0.0) for n, *_ in tg})
-    # The MAPQ 0 share is known only when the MAPQ >= 1 pass was given.
-    share = (1 - tq / T if T > 0 else 0.0) if guarded else None
-    b.update(target_depth=T, control_depth=C, mapq0_share=share)
-    low = min(m[n] for n, *_ in ct) if row["control_depth"] == "flanks" else C
-    if low < row["_min_control"] or C <= 0:
-        b["reason"] = "low_control_depth"
-        return b
-    if row["control_depth"] == "flanks" and row["_max_ratio"] is not None and len(ct) > 1:
-        vals = [m[n] for n, *_ in ct]
-        if min(vals) <= 0 or max(vals) / min(vals) > row["_max_ratio"]:
-            b["reason"] = "controls_disagree"
-            return b
-    total = row["_scale"] * pl / 2 * T / C
-    est = total - row["_offset"]
-    b.update(total=total, estimate=est,
-             details={n: row["_scale"] * pl / 2 * m[n] / C for n, *_ in row["_details"] if n in m})
-    # With no copy left there is no read to judge the aligner by (a row with
-    # an offset has a floor of its own below, after this guard).
-    no_copy = row["_offset"] == 0 and round(est) == 0
-    if row["_mapq0_min"] is not None and not no_copy and share < row["_mapq0_min"]:
-        b["reason"] = "low_mapq0_share"
-        return b
-    if row["_mapq0_max"] is not None and share > row["_mapq0_max"]:
-        b["reason"] = "high_mapq0_share"
-        return b
-    if row["_offset"] > 0 and est <= 0:
-        b["reason"] = "below_floor"
-        return b
-    mode, vals = row["_call"]
-    if row["interval"] == "cv":
-        rel = math.sqrt(_cv([m[n] for n, *_ in tg]) ** 2 / len(tg) + _cv([m[n] for n, *_ in ct]) ** 2 / len(ct))
-        b["ci95"] = (max(0.0, total * math.exp(-Z95 * rel) - row["_offset"]),
-                     total * math.exp(Z95 * rel) - row["_offset"])
-    if mode == "psv":
-        # the module total (gene plus pseudogene copies); og cn reads the sites
-        n = round(est)
-        if abs(est - n) > vals[0]:
-            b["reason"] = "between_counts"
-            return b
-        b["module_total"] = n
-    elif mode == "round":
-        n = round(est)
-        if abs(est - n) > vals[0]:
-            b["reason"] = "between_counts"
-            return b
-        b["copies"] = n
-        b["reading"] = reading(row, n)
-    elif mode == "cut":
-        b["copies"] = cut_copies(est, vals)
-        b["reading"] = reading(row, b["copies"])
-    else:
-        lo, hi = b["ci95"]
-        b["class"] = "low" if hi < vals[0] else "high" if lo > vals[1] else "typical"
-        b["reading"] = reading(row, b["class"])
-    b["status"] = "called"
-    return b
diff --git a/bin/traits_report.py b/bin/traits_report.py
index 6b984f1cb..0d8e67310 100755
--- a/bin/traits_report.py
+++ b/bin/traits_report.py
@@ -1,90 +1,17 @@
-#!/usr/bin/env python3
-"""traits_report.py: the traits table and the genotype rules of step 42, read from the gVCF genotypes.
+# remnant: kept for collect_summary, demo and catalog tests; deleted in lane R3.
+"""Step 42 metadata still read by the Python report collectors.
 
-  traits_report.py --table assets/traits.tsv --rules assets/genotype_rules.tsv --genotypes G.tsv \\
-      [--phased P.vcf] --sample S --out S_traits.tsv --rules-out S_genotype_rules.tsv
-  traits_report.py --rules assets/genotype_rules.tsv --genotypes G.tsv --sample S --phase-sites IN.vcf
-  traits_report.py --check-table assets/traits.tsv [--rules assets/genotype_rules.tsv]
-
-G.tsv is what bcftools writes in step 42 (scripts/42-traits.sh and the
-Nextflow TRAITS_SITES process run the same commands): one line per gVCF record
-at a position of the traits table or of a rule site, after the reference
-blocks are expanded to one record per base, as CHROM POS REF ALT GENOTYPE GQ,
-the genotype as bases (C/T, or C|T when phased). A position with no line has
-no genotype: it is "not_covered", never read as the reference. bcftools drops a
-record with a missing allele (a no-call or a half call such as ./T) before
-this script, so such a position has no line and reads as not_covered too; a
-half call that still reaches here is other_allele.
-
-Each traits table row becomes one output row with the genotype (the reference
-allele first), a status (called, not_covered, other_allele) and the reading
-for that genotype. A gVCF whose REF differs from the table's reference base at
-a position is not GRCh38 (or the table is wrong): the run stops.
-
-Each rule of the rules table (assets/genotype_rules.tsv) reads its sites
-together and becomes one line of --rules-out: the two haplotypes the genotypes
-make, named by the rule's haplotype lines, and the combination line of that
-diplotype. A rule with needs_phase no takes the combination line of every
-diplotype the unphased genotypes allow (APOE's double heterozygote is e2/e4
-or e1/e3). A rule with needs_phase yes and two or more heterozygous sites
-needs their phase: --phase-sites writes those sites as a VCF for WhatsHap,
-and --phased reads WhatsHap's answer; sites not phased in one block leave the
-rule "unphased", not read. The APOE rule's line also goes into the traits
-table, right after its last site row, where the reports read it.
-
---check-table checks the schema of the table (and of the rules, with --rules)
-and exits 1 on the first list of problems; tests/test_traits_table.py and
-tests/test_traits_report.py run the same checks. Standard library only (it
-runs in the plain python image and in the WhatsHap image).
-
-Copy-aware markers (MARKERS): two well-sourced markers of the rule catalog's
-list sit in sequence the genome holds more than once, so a gVCF genotype at
-one position cannot read them and they are not rule lines. Each is read from
-the BAM instead, by the step that counts its copies (og cn marker-regions,
-marker-read and call --marker, in rust/crates/og-cn): the reads at every
-GRCh38 copy of the site are added up, and the share that carries the marker's
-base is a fraction of copies, not a diploid genotype. MARKERS stays here for
-the reports (bin/collect_summary.py reads the marker tables with it).
-  LPA_KIV2_4925  the LPA KIV-2 4925G>A splice variant (Coassin et al. 2017,
-                 PMID 28444229), read by step 46 beside the KIV-2 count
-  SMN1_27134     SMN1 g.27134T>G (rs143838139; Luo et al. 2014, PMID
-                 23788250), read by step 35 beside the SMN1 psCN
+The executable implementation is og traits table, phase-sites and check.
+Copy-aware marker readers are og cn marker-read.
 """
-import argparse
-import itertools
-import os
-import re
-import sys
-
 COLUMNS = ["chrom", "pos", "rsid", "gene", "ref", "alt", "trait", "hom_ref", "het", "hom_alt",
            "ancestry", "note", "pmids"]
 OUT_COLUMNS = ["rsid", "gene", "chrom", "pos", "trait", "genotype", "status", "reading", "ancestry",
                "note", "pmids"]
 RULE_OUT_COLUMNS = ["rule", "gene", "trait", "rsids", "chrom", "pos", "genotypes", "gq", "phase", "result",
                     "status", "reading", "ancestry", "note", "pmids"]
-# The columns of each kind of line of the rules table, after the kind and the rule id.
-RULE_KINDS = {"rule": ["gene", "trait", "needs_phase", "ancestry", "note", "pmids"],
-              "site": ["rsid", "chrom", "pos", "ref", "alt"],
-              "haplotype": ["name", "alleles"],
-              "combination": ["diplotypes", "label", "reading"]}
-CHROMS = {f"chr{n}" for n in range(1, 23)}
-BASES = set("ACGT")
 
-# APOE: rs429358 C (Arg112) and rs7412 C (Arg158) make e4; T and T make e2.
-# The traits table must keep these two rows: the reports show them, and the
-# APOE rule's line goes after them.
-APOE_E4_SITE, APOE_E2_SITE = "rs429358", "rs7412"
-APOE_ALLELES = {APOE_E4_SITE: ("T", "C"), APOE_E2_SITE: ("C", "T")}
-# Rules whose line also goes into the traits table, where the reports read it
-# (they fold the APOE lines away). Every other rule's line is in --rules-out.
 TRAITS_TABLE_RULES = ("APOE",)
-# The rules table beside the traits table in the repository, for report()'s callers
-# that give none; the command line always takes --rules.
-DEFAULT_RULES = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "assets", "genotype_rules.tsv")
-MAX_RULE_SITES = 8   # the completeness check walks 3^sites genotypes
-NOT_COVERED = "No genotype at this position in the gVCF (no reads, or a no-call): not read."
-OTHER_ALLELE = "An allele this table does not describe at this position: not read."
-
 
 class TableError(Exception):
     pass
@@ -115,425 +42,6 @@ def read_table(path):
     return rows
 
 
-def text_errors(where, text):
-    errs = []
-    if "snpedia" in text.lower():
-        errs.append(f"{where}: mentions SNPedia; the table takes no text from it")
-    if '"' in text or not text.isascii():
-        errs.append(f"{where}: a double quote or a non-ASCII character (the reports read the table as plain TSV)")
-    return errs
-
-
-def site_errors(where, r):
-    """Schema problems of one site: chrom, pos, rsid, ref and alt."""
-    errs = []
-    if r["chrom"] not in CHROMS:
-        errs.append(f"{where}: chrom '{r['chrom']}' is not chr1 to chr22")
-    if not re.fullmatch(r"[1-9][0-9]*", r["pos"]):
-        errs.append(f"{where}: pos '{r['pos']}' is not a positive integer")
-    if not re.fullmatch(r"rs[1-9][0-9]*", r["rsid"]):
-        errs.append(f"{where}: rsid is not rs<number>")
-    for k in ("ref", "alt"):
-        if r[k] not in BASES:
-            errs.append(f"{where}: {k} '{r[k]}' is not one of A, C, G, T")
-    if r["ref"] == r["alt"]:
-        errs.append(f"{where}: ref and alt are the same base")
-    return errs
-
-
-def check_rows(rows):
-    """Every schema problem of the table rows, as messages (empty when it is valid)."""
-    errs, ids, sites = [], set(), set()
-    for r in rows:
-        where = f"line {r['line']} ({r['rsid']})"
-        errs += site_errors(where, r)
-        if r["rsid"] in ids:
-            errs.append(f"{where}: rsid appears twice")
-        ids.add(r["rsid"])
-        if (r["chrom"], r["pos"]) in sites:
-            errs.append(f"{where}: position {r['chrom']}:{r['pos']} appears twice")
-        sites.add((r["chrom"], r["pos"]))
-        for k in ("gene", "trait", "hom_ref", "het", "hom_alt", "note"):
-            if not r[k].strip():
-                errs.append(f"{where}: {k} is empty")
-        if r["ancestry"] not in ("yes", "no"):
-            errs.append(f"{where}: ancestry '{r['ancestry']}' is not yes or no")
-        if not re.fullmatch(r"[1-9][0-9]*(,[1-9][0-9]*)*", r["pmids"]):
-            errs.append(f"{where}: pmids '{r['pmids']}' is not a comma-separated list of PubMed ids")
-        errs += text_errors(where, " ".join(r[k] for k in COLUMNS))
-    by_id = {r["rsid"]: r for r in rows}
-    for rs, (ref, alt) in APOE_ALLELES.items():
-        r = by_id.get(rs)
-        if r is None:
-            errs.append(f"APOE row {rs} is missing")
-        elif (r["ref"], r["alt"]) != (ref, alt) or r["chrom"] != "chr19":
-            errs.append(f"APOE row {rs} must be chr19 {ref}>{alt}, is {r['chrom']} {r['ref']}>{r['alt']}")
-    return errs
-
-
-# --- The rules table ---------------------------------------------------------------
-
-def read_rules(path):
-    """{rule id: {gene, trait, needs_phase, ancestry, note, pmids, line, sites, haplotypes,
-    combinations}} in file order. Raises TableError on a line of an unknown kind or with
-    the wrong column count, and on a site, haplotype or combination line before its rule line."""
-    rules = {}
-    with open(path, encoding="utf-8") as f:
-        for n, line in enumerate(f, 1):
-            line = line.rstrip("\n")
-            if not line or line.startswith("#"):
-                continue
-            cells = line.split("\t")
-            kind = cells[0]
-            if kind not in RULE_KINDS:
-                raise TableError(f"{path}:{n}: kind '{kind}' is not one of {', '.join(RULE_KINDS)}")
-            want = 2 + len(RULE_KINDS[kind])
-            if len(cells) != want:
-                raise TableError(f"{path}:{n}: a {kind} line has {len(cells)} columns, expected {want}")
-            rid = cells[1]
-            d = dict(zip(RULE_KINDS[kind], cells[2:]), line=n)
-            if kind == "rule":
-                if rid in rules:
-                    raise TableError(f"{path}:{n}: rule {rid} has two rule lines")
-                rules[rid] = dict(d, id=rid, sites=[], haplotypes=[], combinations=[])
-                continue
-            if rid not in rules:
-                raise TableError(f"{path}:{n}: a {kind} line of rule '{rid}' before its rule line")
-            rules[rid]["sites" if kind == "site" else kind + "s"].append(d)
-    if not rules:
-        raise TableError(f"{path}: no rule line")
-    return rules
-
-
-def diplotype_key(rule, a, b):
-    """'a/b' with the two names in the order of the rule's haplotype lines."""
-    order = [h["name"] for h in rule["haplotypes"]]
-    return "/".join(sorted((a, b), key=order.index))
-
-
-def allowed_diplotypes(rule, genotypes):
-    """The diplotype keys, in haplotype order, whose two haplotypes give these unphased
-    genotypes (one [allele, allele] per site)."""
-    haps = rule["haplotypes"]
-    out = []
-    for i, j in itertools.combinations_with_replacement(range(len(haps)), 2):
-        a, b = haps[i]["alleles"].split(","), haps[j]["alleles"].split(",")
-        if all(sorted((a[k], b[k])) == sorted(g) for k, g in enumerate(genotypes)):
-            out.append(f"{haps[i]['name']}/{haps[j]['name']}")
-    return out
-
-
-def check_rules(rules, table_rows=None):
-    """Every schema problem of the rules, as messages (empty when they are valid). With
-    table_rows, also: a rule site that is a traits table row has the row's chrom, pos, ref
-    and alt, and the rules of TRAITS_TABLE_RULES exist with every site in the table."""
-    errs = []
-    by_rs = {r["rsid"]: r for r in table_rows or []}
-    for rid, rule in rules.items():
-        n0 = len(errs)
-        where = f"rule {rid} (line {rule['line']})"
-        if not re.fullmatch(r"[A-Za-z0-9_]+", rid):
-            errs.append(f"{where}: the rule id is not letters, digits and _")
-        for k in ("gene", "trait", "note"):
-            if not rule[k].strip():
-                errs.append(f"{where}: {k} is empty")
-        for k in ("needs_phase", "ancestry"):
-            if rule[k] not in ("yes", "no"):
-                errs.append(f"{where}: {k} '{rule[k]}' is not yes or no")
-        if not re.fullmatch(r"[1-9][0-9]*(,[1-9][0-9]*)*", rule["pmids"]):
-            errs.append(f"{where}: pmids '{rule['pmids']}' is not a comma-separated list of PubMed ids")
-        sites = rule["sites"]
-        if not 2 <= len(sites) <= MAX_RULE_SITES:
-            errs.append(f"{where}: {len(sites)} sites, expected 2 to {MAX_RULE_SITES}")
-        seen = set()
-        for s in sites:
-            w = f"{where}, site line {s['line']} ({s['rsid']})"
-            errs += site_errors(w, s)
-            if s["rsid"] in seen or (s["chrom"], s["pos"]) in seen:
-                errs.append(f"{w}: the site appears twice in the rule")
-            seen |= {s["rsid"], (s["chrom"], s["pos"])}
-            t = by_rs.get(s["rsid"])
-            if t and (t["chrom"], t["pos"], t["ref"], t["alt"]) != (s["chrom"], s["pos"], s["ref"], s["alt"]):
-                errs.append(f"{w}: the traits table has {t['chrom']}:{t['pos']} {t['ref']}>{t['alt']}, "
-                            f"the rule {s['chrom']}:{s['pos']} {s['ref']}>{s['alt']}")
-        if len({s["chrom"] for s in sites}) > 1:
-            errs.append(f"{where}: the sites are on more than one chromosome")
-        names, tuples = [], set()
-        for h in rule["haplotypes"]:
-            w = f"{where}, haplotype line {h['line']} ({h['name']})"
-            if not re.fullmatch(r"[A-Za-z0-9*.]+", h["name"]):
-                errs.append(f"{w}: the name is not letters, digits, * and .")
-            if h["name"] in names:
-                errs.append(f"{w}: the name appears twice")
-            names.append(h["name"])
-            al = h["alleles"].split(",")
-            if len(al) != len(sites):
-                errs.append(f"{w}: {len(al)} alleles for {len(sites)} sites")
-                continue
-            for a, s in zip(al, sites):
-                if a not in (s["ref"], s["alt"]):
-                    errs.append(f"{w}: allele {a} at {s['rsid']} is neither its ref {s['ref']} nor its alt {s['alt']}")
-            if tuple(al) in tuples:
-                errs.append(f"{w}: the same alleles as another haplotype")
-            tuples.add(tuple(al))
-        if len(names) < 2:
-            errs.append(f"{where}: fewer than two haplotypes")
-        keys = {}
-        for c in rule["combinations"]:
-            w = f"{where}, combination line {c['line']} ({c['diplotypes']})"
-            for k in ("label", "reading"):
-                if not c[k].strip():
-                    errs.append(f"{w}: {k} is empty")
-            errs += text_errors(w, " ".join((c["diplotypes"], c["label"], c["reading"])))
-            if c["diplotypes"] in keys:
-                errs.append(f"{w}: the diplotypes appear twice")
-            keys[c["diplotypes"]] = c
-            for d in c["diplotypes"].split("|"):
-                pair = d.split("/")
-                if len(pair) != 2 or any(p not in names for p in pair):
-                    errs.append(f"{w}: '{d}' is not two of the rule's haplotypes joined by /")
-                elif diplotype_key(rule, *pair) != d:
-                    errs.append(f"{w}: '{d}' is not in the order of the haplotype lines "
-                                f"(write {diplotype_key(rule, *pair)})")
-        errs += text_errors(where, " ".join(str(rule[k]) for k in ("gene", "trait", "note")))
-        if len(errs) > n0:
-            continue
-        # Completeness: the combination lines are exactly what the genotypes can give.
-        if rule["needs_phase"] == "yes":
-            want = {f"{a}/{b}" for a, b in itertools.combinations_with_replacement(names, 2)}
-        else:
-            want = set()
-            choices = [[[s["ref"]] * 2, [s["ref"], s["alt"]], [s["alt"]] * 2] for s in sites]
-            for g in itertools.product(*choices):
-                key = "|".join(allowed_diplotypes(rule, g))
-                if key:
-                    want.add(key)
-        for k in sorted(want - set(keys)):
-            errs.append(f"{where}: no combination line for {k}")
-        for k in sorted(set(keys) - want):
-            errs.append(f"{where}: the combination line {k} can never be read "
-                        + ("(a rule that needs phase reads one diplotype)" if "|" in k else "from these haplotypes"))
-    if table_rows is not None:
-        for rid in TRAITS_TABLE_RULES:
-            if rid not in rules:
-                errs.append(f"rule {rid} is missing: its line goes into the traits table, where the reports read it")
-            else:
-                for s in rules[rid]["sites"]:
-                    if s["rsid"] not in by_rs:
-                        errs.append(f"rule {rid}: site {s['rsid']} has no traits table row")
-    return errs
-
-
-# --- Genotypes ----------------------------------------------------------------------
-
-def read_genotypes(path):
-    """{(chrom, pos): [(REF, [allele, allele], GQ), ...]} from bcftools' CHROM POS REF ALT GT [GQ] lines."""
-    recs = {}
-    with open(path, encoding="utf-8") as f:
-        for n, line in enumerate(f, 1):
-            line = line.rstrip("\n")
-            if not line:
-                continue
-            c = line.split("\t")
-            if len(c) < 5:
-                raise TableError(f"{path}:{n}: {len(c)} columns, expected CHROM POS REF ALT GENOTYPE [GQ]")
-            gq = c[5] if len(c) > 5 and c[5] else "."
-            recs.setdefault((c[0], c[1]), []).append((c[2], re.split(r"[/|]", c[4]), gq))
-    return recs
-
-
-def site_genotype(site, recs):
-    """(alleles sorted with the reference first, status, GQ) of one site from its gVCF records."""
-    if not recs:
-        return None, "not_covered", "."
-    for r in recs:
-        if r[0][:1] != site["ref"]:
-            raise TableError(f"{site['rsid']} at {site['chrom']}:{site['pos']}: the gVCF has REF {r[0]}, the table "
-                             f"{site['ref']} (the GRCh38 base). Is the gVCF on GRCh38?")
-    snv = [r for r in recs if all(len(a) == 1 for a in r[1])]
-    _, alleles, gq = (snv or recs)[0]
-    order = {site["ref"]: 0, site["alt"]: 1}
-    alleles = sorted(alleles, key=lambda a: (order.get(a, 2), a))
-    if len(alleles) != 2 or any(a not in order for a in alleles):
-        return alleles, "other_allele", gq
-    return alleles, "called", gq
-
-
-def call(row, recs):
-    """(genotype, status, reading) of one traits table row from its gVCF records."""
-    alleles, status, _ = site_genotype(row, recs)
-    if status == "not_covered":
-        return ".", "not_covered", NOT_COVERED
-    gt = "/".join(alleles)
-    if status == "other_allele":
-        return gt, "other_allele", OTHER_ALLELE
-    return gt, "called", row[("hom_ref", "het", "hom_alt")[alleles.count(row["alt"])]]
-
-
-def read_phased(path):
-    """{(chrom, pos): (allele of haplotype 1, allele of haplotype 2, phase block)} of the
-    phased records of WhatsHap's VCF; unphased records are left out."""
-    out = {}
-    with open(path, encoding="utf-8") as f:
-        for line in f:
-            if line.startswith("#") or not line.strip():
-                continue
-            c = line.rstrip("\n").split("\t")
-            if len(c) < 10:
-                continue
-            fmt = dict(zip(c[8].split(":"), c[9].split(":")))
-            gt, ps = fmt.get("GT", ""), fmt.get("PS", ".")
-            if "|" not in gt or ps in (".", ""):
-                continue
-            bases = [c[3]] + c[4].split(",")
-            try:
-                a, b = (bases[int(i)] for i in gt.split("|"))
-            except (ValueError, IndexError):
-                continue
-            out[(c[0], c[1])] = (a, b, ps)
-    return out
-
-
-def phase_sites(rules, recs):
-    """The (chrom, pos, rsid, ref, alt) of the heterozygous sites of every rule that needs
-    phase and has two or more of them, each site once, in rule order."""
-    out, seen = [], set()
-    for rule in rules.values():
-        if rule["needs_phase"] != "yes":
-            continue
-        g = [(s, site_genotype(s, recs.get((s["chrom"], s["pos"]), []))) for s in rule["sites"]]
-        if any(st != "called" for _, (_, st, _) in g):
-            continue
-        het = [s for s, (al, _, _) in g if al[0] != al[1]]
-        if len(het) < 2:
-            continue
-        for s in het:
-            k = (s["chrom"], s["pos"])
-            if k not in seen:
-                seen.add(k)
-                out.append((s["chrom"], s["pos"], s["rsid"], s["ref"], s["alt"]))
-    return out
-
-
-def write_phase_vcf(path, sample, sites):
-    """The sites as a one-sample VCF of 0/1 genotypes, sorted, for whatshap phase."""
-    contigs = sorted({c for c, *_ in sites}, key=lambda c: int(c[3:]))
-    tmp = path + ".tmp"
-    with open(tmp, "w", encoding="utf-8") as f:
-        f.write("##fileformat=VCFv4.2\n")
-        for c in contigs:
-            f.write(f"##contig=<ID={c}>\n")
-        f.write('##FORMAT=<ID=GT,Number=1,Type=String,Description="Genotype">\n')
-        f.write("#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\t" + sample + "\n")
-        for c, p, rs, ref, alt in sorted(sites, key=lambda s: (int(s[0][3:]), int(s[1]))):
-            f.write(f"{c}\t{p}\t{rs}\t{ref}\t{alt}\t.\tPASS\t.\tGT\t0/1\n")
-    os.replace(tmp, path)
-
-
-def rule_line(rule, recs, phased):
-    """One output line of a rule. phased: read_phased's dict, or None when no phasing ran."""
-    sites = rule["sites"]
-    g = [site_genotype(s, recs.get((s["chrom"], s["pos"]), [])) for s in sites]
-    rsids = [s["rsid"] for s in sites]
-    line = {"rule": rule["id"], "gene": rule["gene"], "trait": rule["trait"], "rsids": ",".join(rsids),
-            "chrom": sites[0]["chrom"], "pos": ",".join(s["pos"] for s in sites),
-            "genotypes": ",".join("/".join(al) if al else "." for al, _, _ in g),
-            "gq": ",".join(gq for _, _, gq in g), "ancestry": rule["ancestry"], "note": rule["note"],
-            "pmids": rule["pmids"]}
-    phase = "not_used" if rule["needs_phase"] == "no" else "not_needed"
-    statuses = [st for _, st, _ in g]
-    if any(st != "called" for st in statuses):
-        need = (f"both {rsids[0]} and {rsids[1]}" if len(rsids) == 2
-                else "every one of " + ", ".join(rsids[:-1]) + " and " + rsids[-1])
-        return dict(line, phase=".", result=".",
-                    status="not_covered" if "not_covered" in statuses else "other_allele",
-                    reading=f"Not read: needs a genotype at {need}.")
-    alleles = [al for al, _, _ in g]
-    combos = {c["diplotypes"]: c for c in rule["combinations"]}
-    if rule["needs_phase"] == "no":
-        key = "|".join(allowed_diplotypes(rule, alleles))
-    else:
-        het = [i for i, al in enumerate(alleles) if al[0] != al[1]]
-        h1, h2 = [al[0] for al in alleles], [al[1] for al in alleles]
-        if len(het) >= 2:
-            blocks = {(phased or {}).get((sites[i]["chrom"], sites[i]["pos"]), (None, None, None))[2] for i in het}
-            if None in blocks or len(blocks) != 1:
-                why = ("no read or read pair covered them together"
-                       if phased is not None else "no phasing ran (no BAM, or phasing failed)")
-                return dict(line, phase="unphased", result=".", status="unphased",
-                            reading=f"Heterozygous at {len(het)} of the {len(sites)} sites, and {why}, so which "
-                                    "alleles share a copy is not known: not read.")
-            for i in het:
-                h1[i], h2[i] = phased[(sites[i]["chrom"], sites[i]["pos"])][:2]
-            phase = "read_backed"
-        by_alleles = {tuple(h["alleles"].split(",")): h["name"] for h in rule["haplotypes"]}
-        n1, n2 = by_alleles.get(tuple(h1)), by_alleles.get(tuple(h2))
-        unknown = [",".join(h) for h, n in ((h1, n1), (h2, n2)) if n is None]
-        if unknown:
-            return dict(line, phase=phase, result=".", status="other_haplotype",
-                        reading=f"A haplotype this rule does not describe ({' and '.join(unknown)} at "
-                                f"{', '.join(rsids)}): not read.")
-        key = diplotype_key(rule, n1, n2)
-    if not key or key not in combos:
-        return dict(line, phase=phase, result=".", status="other_haplotype",
-                    reading="A combination of haplotypes this rule does not describe: not read.")
-    c = combos[key]
-    return dict(line, phase=phase, result=c["label"], status="called", reading=c["reading"])
-
-
-def rule_lines(rules, recs, phased=None):
-    """One output line per rule, in the order of the rules table."""
-    return [rule_line(r, recs, phased) for r in rules.values()]
-
-
-def report(rows, recs, rules=None, phased=None, lines=None):
-    """The traits output rows: one per table row, with the line of each rule of
-    TRAITS_TABLE_RULES right after its last site row. rules defaults to
-    DEFAULT_RULES; lines, rule_lines' output, is computed when not given."""
-    if rules is None:
-        rules = read_rules(DEFAULT_RULES)
-    if lines is None:
-        lines = rule_lines(rules, recs, phased)
-    after = {}
-    for rid in TRAITS_TABLE_RULES:
-        rule = rules.get(rid)
-        if rule:
-            members = {s["rsid"] for s in rule["sites"]}
-            last = max((i for i, r in enumerate(rows) if r["rsid"] in members), default=None)
-            if last is not None:
-                after[last] = next(ln for ln in lines if ln["rule"] == rid)
-    out = []
-    for i, r in enumerate(rows):
-        gt, status, reading = call(r, recs.get((r["chrom"], r["pos"]), []))
-        out.append({"rsid": r["rsid"], "gene": r["gene"], "chrom": r["chrom"], "pos": r["pos"],
-                    "trait": r["trait"], "genotype": gt, "status": status, "reading": reading,
-                    "ancestry": r["ancestry"], "note": r["note"], "pmids": r["pmids"]})
-        if i in after:
-            ln = after[i]
-            out.append({"rsid": ln["rsids"].replace(",", "+"), "gene": ln["gene"], "chrom": ln["chrom"],
-                        "pos": ln["pos"], "trait": ln["trait"], "genotype": ln["result"], "status": ln["status"],
-                        "reading": ln["reading"], "ancestry": ln["ancestry"], "note": ln["note"],
-                        "pmids": ln["pmids"]})
-    return out
-
-
-# --- Copy-aware markers --------------------------------------------------------------
-
-# Each marker: the dbSNP record of one copy (rsID, chrom, POS, REF, ALT of
-# dbSNP b157's GRCh38 VCF, read from NCBI's Variation API on 2026-11-07), every
-# GRCh38 copy of the site (1-based), the plus-strand base pair read there, and
-# the GRCh38 sequence of 10 bases on each side of every copy (UCSC hg38 and
-# Ensembl GRCh38 agree, 2026-11-07): the same 21 bases at each copy, which is
-# why the reads cannot be placed on one copy. tests/test_traits_report.py
-# checks every copy against the context and the record against the marker, and
-# that og cn reads the same copies; tests/e2e/genotype-rules-2-smn1-marker.sh
-# compares the records with dbSNP.
-#   min_depth     fewer reads over all copies together: too little depth
-#   min_alt       reads with the marker's base for 'present' ...
-#   min_fraction  ... and a share of the reads at least this
-#   max_absent    this many reads with the marker's base or fewer: 'not seen'
-#                 (one or two reads can be sequencing errors); between the two
-#                 the marker is 'uncertain'
 MARKERS = {
     # KIV-2 4925G>A: the last base of the second KIV-2 exon (its donor splice
     # site), G>A on LPA's minus strand, so C>T on the plus strand. GRCh38 holds
@@ -560,108 +68,3 @@ def report(rows, recs, rules=None, phased=None, lines=None):
     },
 }
 MARKER_STATUSES = ("present", "not seen", "uncertain", "too little depth", "not assessed")
-
-
-def marker_errors(name, m=None, dbsnp=None):
-    """Problems of one marker (empty when it is consistent): the dbSNP record
-    is one of its copies with its ref and alt, on the plus strand and not
-    swapped; every copy sits in the middle of the same context, whose middle
-    base is the ref."""
-    m = MARKERS[name] if m is None else m
-    rs, chrom, pos, ref, alt = m["dbsnp"] if dbsnp is None else dbsnp
-    comp = {"A": "T", "C": "G", "G": "C", "T": "A"}
-    errs = []
-    if chrom != m["chrom"] or pos not in m["copies"]:
-        errs.append(f"{name}: dbSNP places {rs} at {chrom}:{pos}, not at one of the marker's copies")
-    if (m["ref"], m["alt"]) == (alt, ref):
-        errs.append(f"{name}: ref and alt are swapped (marker {m['ref']}>{m['alt']}, dbSNP {ref}>{alt})")
-    elif (m["ref"], m["alt"]) == (comp.get(ref), comp.get(alt)):
-        errs.append(f"{name}: the alleles are the minus-strand bases (marker {m['ref']}>{m['alt']}, "
-                    f"dbSNP {ref}>{alt}): write the plus-strand bases")
-    elif (m["ref"], m["alt"]) != (ref, alt):
-        errs.append(f"{name}: marker {m['ref']}>{m['alt']}, dbSNP {ref}>{alt}")
-    ctx = m["context"]
-    if len(ctx) % 2 != 1 or ctx[len(ctx) // 2] != m["ref"]:
-        errs.append(f"{name}: the middle base of the context is not the ref {m['ref']}")
-    if len(set(m["copies"])) != len(m["copies"]):
-        errs.append(f"{name}: a copy is listed twice")
-    return errs
-
-
-def write_tsv(path, out, columns=OUT_COLUMNS):
-    tmp = path + ".tmp"
-    with open(tmp, "w", encoding="utf-8") as f:
-        f.write("\t".join(columns) + "\n")
-        for o in out:
-            f.write("\t".join(str(o[k]) for k in columns) + "\n")
-    os.replace(tmp, path)
-
-
-def main(argv=None):
-    ap = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
-    ap.add_argument("--table", help="assets/traits.tsv")
-    ap.add_argument("--rules", help="assets/genotype_rules.tsv")
-    ap.add_argument("--genotypes", help="bcftools' CHROM POS REF ALT GENOTYPE GQ lines at the table and rule positions")
-    ap.add_argument("--phased", help="WhatsHap's VCF of the --phase-sites sites (absent: no phasing ran)")
-    ap.add_argument("--sample")
-    ap.add_argument("--out", help="the sample's traits table (TSV)")
-    ap.add_argument("--rules-out", help="the sample's genotype rules (TSV)")
-    ap.add_argument("--phase-sites", metavar="VCF", help="write the sites WhatsHap must phase and exit")
-    ap.add_argument("--check-table", metavar="TABLE", help="check the table's schema (and --rules') and exit")
-    a = ap.parse_args(argv)
-    try:
-        if a.check_table:
-            rows = read_table(a.check_table)
-            errs = check_rows(rows)
-            if a.rules:
-                errs += check_rules(read_rules(a.rules), rows)
-            for e in errs:
-                print(f"ERROR: {e}", file=sys.stderr)
-            if not errs:
-                print(f"{a.check_table}{' and ' + a.rules if a.rules else ''}: schema OK")
-            return 1 if errs else 0
-        if a.phase_sites:
-            if not (a.rules and a.genotypes and a.sample):
-                ap.error("--phase-sites needs --rules, --genotypes and --sample")
-            rules = read_rules(a.rules)
-            errs = check_rules(rules)
-            if errs:
-                for e in errs:
-                    print(f"ERROR: {a.rules}: {e}", file=sys.stderr)
-                return 1
-            sites = phase_sites(rules, read_genotypes(a.genotypes))
-            write_phase_vcf(a.phase_sites, a.sample, sites)
-            print(f"{a.sample}: {len(sites)} heterozygous rule sites to phase. Written: {a.phase_sites}")
-            return 0
-        if not (a.table and a.rules and a.genotypes and a.sample and a.out and a.rules_out):
-            ap.error("give --table, --rules, --genotypes, --sample, --out and --rules-out "
-                     "(or --phase-sites, or --check-table)")
-        rows = read_table(a.table)
-        rules = read_rules(a.rules)
-        errs = [f"{a.table}: {e}" for e in check_rows(rows)] + [f"{a.rules}: {e}" for e in check_rules(rules, rows)]
-        if errs:
-            for e in errs:
-                print(f"ERROR: {e}", file=sys.stderr)
-            return 1
-        phased = read_phased(a.phased) if a.phased else None
-        recs = read_genotypes(a.genotypes)
-        lines = rule_lines(rules, recs, phased)
-        out = report(rows, recs, rules, phased, lines)
-    except (TableError, OSError) as e:
-        print(f"ERROR: {e}", file=sys.stderr)
-        return 1
-    write_tsv(a.out, out)
-    write_tsv(a.rules_out, lines, RULE_OUT_COLUMNS)
-    counts = {}
-    for o in out:
-        counts[o["status"]] = counts.get(o["status"], 0) + 1
-    print(f"{a.sample}: {len(rows)} table rows; " + ", ".join(f"{k} {v}" for k, v in sorted(counts.items()))
-          + f" (APOE line included). Written: {a.out}")
-    print(f"{a.sample}: {len(lines)} genotype rules; "
-          + ", ".join(f"{ln['rule']} {ln['result'] if ln['status'] == 'called' else ln['status']}" for ln in lines)
-          + f". Written: {a.rules_out}")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())
diff --git a/docs/42-traits.md b/docs/42-traits.md
index 7c6affb70..ad3aa25cf 100644
--- a/docs/42-traits.md
+++ b/docs/42-traits.md
@@ -12,7 +12,7 @@ These are the results most people find easiest to read, and the pipeline had no
 
 - **bcftools** (`bcftools convert --gvcf2vcf`, `view`, `query`) reads the genotypes at the table's positions from the gVCF.
 - **WhatsHap** (`whatshap phase`) phases the heterozygous sites of a rule that needs phase from the BAM's reads.
-- **`bin/traits_report.py`** (Python standard library) reads each genotype against the table, and each rule against the rule table.
+- **`og traits table`** (Rust) reads each genotype against the table, and each rule against the rule table.
 
 ## Docker Image
 
@@ -122,12 +122,12 @@ Kim et al. (2003) found five TAS2R38 haplotypes worldwide. The rule reads the tw
 
 ### Checks on the rule table
 
-- `bin/traits_report.py --check-table assets/traits.tsv --rules assets/genotype_rules.tsv` (also run by every step-42 run and by `tests/test_traits_report.py`): every haplotype allele is its site's ref or alt, the combination lines are exactly the pairs the genotypes can give (none missing, none that can never be read), and a site that is also a traits table row has the row's position and bases.
+- `bin/og traits check --table assets/traits.tsv --rules assets/genotype_rules.tsv` (also run by every step-42 run and by `tests/test_traits_report.py`): every haplotype allele is its site's ref or alt, the combination lines are exactly the pairs the genotypes can give (none missing, none that can never be read), and a site that is also a traits table row has the row's position and bases.
 - `scripts/ci/check-rule-alleles.sh` checks every site against dbSNP: the rsID at that GRCh38 position, ref as dbSNP's REF and alt among its ALT alleles. A pair written the wrong way round, or as the minus-strand bases (TAS2R38 lies on the minus strand, where the papers name the codon bases), fails with the reason. The dbSNP records it compares with sit in the script, taken from dbSNP's GRCh38 VCF of the build `CONSUMER_DBSNP_BUILD` pins in `versions.env` (b157); `--online` reads them again over HTTPS and fails when they differ, and the e2e case `genotype-rules-1-phase` runs it. A C/G or A/T site is its own complement, so there a strand mistake keeps valid alleles: the check prints a note for each such site (rs713598 is one), and its haplotype alleles rest on the codon: Pro49 has C at the first base of codon 49 on the coding strand (NM_176817.5 c.145C, where Ala49 has G), so the PAV base on GRCh38 is its complement, G. The other such sites: rs17580 (SERPINA1 S, minus strand: Glu264 GAA, Val264 GTA, so the S base on GRCh38 is the complement of T, A), rs1799945 (HFE H63D, plus strand: His63 CAT, Asp63 GAT, so D is G) and rs1333049 (no gene; the risk allele C is the plus-strand base of the WTCCC 2007 record).
 
 ### Adding a rule
 
-Write the rule, site, haplotype and combination lines from the primary papers. Take each site's position and bases from dbSNP's GRCh38 record (plus strand), and turn each haplotype's codon bases into plus-strand bases for a gene on the minus strand. A new site needs its dbSNP record in `scripts/ci/check-rule-alleles.sh`: run it with `--print-table` and add each printed line at the end of the script after `#: `. Then run `python3 tests/test_traits_report.py`.
+Write the rule, site, haplotype and combination lines from the primary papers. Take each site's position and bases from dbSNP's GRCh38 record (plus strand), and turn each haplotype's codon bases into plus-strand bases for a gene on the minus strand. A new site needs its dbSNP record in `scripts/ci/check-rule-alleles.sh`: run it with `--print-table` and add each printed line at the end of the script after `#: `. Then run `OG=bin/og python3 tests/test_traits_report.py`.
 
 ## APOE
 
diff --git a/docs/rust.md b/docs/rust.md
index c2ed48f65..99637ea75 100644
--- a/docs/rust.md
+++ b/docs/rust.md
@@ -111,3 +111,8 @@ To add a primitive: write it in `pycompat` with unit tests, add an operation to
 - **Release** (`release.yml`): a tag builds the four binaries, writes `SHA256SUMS`, attests them and attaches all five files to the release. A pull request that changes `rust/` or the workflow builds them as a dry run.
 
 [Testing](testing.md) has the rest of CI.
+
+Step 42 uses `og traits table`, `og traits phase-sites` and `og traits check`.
+The readers retain only catalog sites. The trait and genotype-rule output
+columns and readings stay the same. `bin/traits_report.py` keeps report
+metadata until the Python summary and report collectors move.
diff --git a/modules/local/traits/main.nf b/modules/local/traits/main.nf
index b7be4b1c8..b6087ab75 100644
--- a/modules/local/traits/main.nf
+++ b/modules/local/traits/main.nf
@@ -13,7 +13,7 @@
                   an empty file when no rule has two such sites
     TRAITS        <id>_traits.tsv: the reading of each genotype from the
                   table, and the APOE line; <id>_genotype_rules.tsv: one
-                  line per rule (bin/traits_report.py)
+                  line per rule (og traits table)
 
     Runs for the samples with a gVCF only (DEEPVARIANT's, or one the
     samplesheet gives); main.nf logs the samples it skips. A sample without
@@ -89,7 +89,7 @@ process TRAITS_PHASE {
     script:
     // The same commands as scripts/42-traits.sh
     """
-    traits_report.py --rules ${rules} --genotypes ${genotypes} --sample ${meta.id} --phase-sites phase_sites.vcf
+    og traits phase-sites --rules ${rules} --genotypes ${genotypes} --sample ${meta.id} --out phase_sites.vcf
     if grep -qv '^#' phase_sites.vcf; then
         whatshap phase --reference ${reference} --ignore-read-groups -o ${meta.id}_traits_phased.vcf phase_sites.vcf ${bam}
     else
@@ -129,7 +129,7 @@ process TRAITS {
     script:
     def phased_arg = phased ? "--phased ${phased}" : ''
     """
-    traits_report.py --table ${table} --rules ${rules} --genotypes ${genotypes} ${phased_arg} --sample ${meta.id} \\
+    og traits table --table ${table} --rules ${rules} --genotypes ${genotypes} ${phased_arg} --sample ${meta.id} \\
         --out ${meta.id}_traits.tsv --rules-out ${meta.id}_genotype_rules.tsv
 
     printf '"%s":\\n    python: %s\\n' "${task.process}" "${task.container.replaceFirst(/^[^:@]+[:@]/, '')}" > versions.yml
diff --git a/rust/README.md b/rust/README.md
index 394e83e10..505ff4fa4 100644
--- a/rust/README.md
+++ b/rust/README.md
@@ -34,3 +34,7 @@ cargo build --release && ../tests/rust/pycompat-diff.sh target/release/og   # py
 ```
 
 A binary from a plain `cargo build` is stamped `unknown`, and `rust/og.sh check` refuses it: only `scripts/setup.sh --og` stamps the tree hash the pipeline checks.
+
+`og traits table`, `og traits phase-sites` and `og traits check` read step 42's
+curated catalogs and synthetic or bcftools genotype input. Their tests live
+in `og-steps::traits` and the `traits` parity cases.
diff --git a/rust/crates/og-steps/src/traits.rs b/rust/crates/og-steps/src/traits.rs
index 145e69151..40c3db950 100644
--- a/rust/crates/og-steps/src/traits.rs
+++ b/rust/crates/og-steps/src/traits.rs
@@ -378,23 +378,21 @@ fn check_rules(rules: &[Rule], rows: Option<&[Site]>) -> Vec<String> {
             }
             if let Some(t) =
                 rows.and_then(|rows| rows.iter().rev().find(|t| t.row["rsid"] == s.row["rsid"]))
-            {
-                if ["chrom", "pos", "ref", "alt"]
+                && ["chrom", "pos", "ref", "alt"]
                     .iter()
                     .any(|k| t.row[*k] != s.row[*k])
-                {
-                    e.push(format!(
-                        "{sw}: the traits table has {}:{} {}>{}, the rule {}:{} {}>{}",
-                        t.row["chrom"],
-                        t.row["pos"],
-                        t.row["ref"],
-                        t.row["alt"],
-                        s.row["chrom"],
-                        s.row["pos"],
-                        s.row["ref"],
-                        s.row["alt"]
-                    ));
-                }
+            {
+                e.push(format!(
+                    "{sw}: the traits table has {}:{} {}>{}, the rule {}:{} {}>{}",
+                    t.row["chrom"],
+                    t.row["pos"],
+                    t.row["ref"],
+                    t.row["alt"],
+                    s.row["chrom"],
+                    s.row["pos"],
+                    s.row["ref"],
+                    s.row["alt"]
+                ));
             }
         }
         if r.sites
@@ -650,10 +648,10 @@ fn read_phased(path: &str, wanted: &HashSet<Key>) -> Result<Phased> {
                     })
             })
             .collect();
-        if let Some(al) = idx {
-            if al.len() == 2 {
-                out.insert(key, (al[0].into(), al[1].into(), ps.to_string()));
-            }
+        if let Some(al) = idx
+            && al.len() == 2
+        {
+            out.insert(key, (al[0].into(), al[1].into(), ps.to_string()));
         }
     }
     Ok(out)
diff --git a/scripts/42-traits.sh b/scripts/42-traits.sh
index 8994e0273..ea3023328 100755
--- a/scripts/42-traits.sh
+++ b/scripts/42-traits.sh
@@ -93,7 +93,7 @@ if [ -f "$BAM" ] && [ -f "${BAM}.bai" ]; then
   # shellcheck disable=SC2016  # $1 to $6 belong to the inner bash
   run_in -v "${PGP_ROOT}/bin:/pgp-bin:ro" -v "${PGP_ROOT}/assets:/pgp-assets:ro" --cpus 1 --memory 2g "$WHATSHAP_IMAGE" \
     bash -euo pipefail -c '
-      python3 /pgp-bin/traits_report.py --rules /pgp-assets/genotype_rules.tsv --genotypes "$1" --sample "$2" --phase-sites "$3"
+      /pgp-bin/og traits phase-sites --rules /pgp-assets/genotype_rules.tsv --genotypes "$1" --sample "$2" --out "$3"
       if grep -qv "^#" "$3"; then
         whatshap phase --reference "$4" --ignore-read-groups -o "$5" "$3" "$6"
       else
@@ -118,7 +118,7 @@ fi
 
 echo "[3/3] Reading each genotype and each rule against the tables..."
 run_in -v "${PGP_ROOT}/bin:/pgp-bin:ro" -v "${PGP_ROOT}/assets:/pgp-assets:ro" --cpus 1 --memory 1g "$PYTHON_IMAGE" \
-  python3 /pgp-bin/traits_report.py --table /pgp-assets/traits.tsv --rules /pgp-assets/genotype_rules.tsv \
+  /pgp-bin/og traits table --table /pgp-assets/traits.tsv --rules /pgp-assets/genotype_rules.tsv \
     --genotypes "$(cpath "$GENOTYPES")" ${PHASE_ARGS[@]+"${PHASE_ARGS[@]}"} --sample "$SAMPLE" \
     --out "$(cpath "$OUT")" --rules-out "$(cpath "$RULES_OUT")"
 rm -f "$PHASED"
diff --git a/scripts/ci/e2e-case-paths.tsv b/scripts/ci/e2e-case-paths.tsv
index f76068dcf..fc0a5239c 100644
--- a/scripts/ci/e2e-case-paths.tsv
+++ b/scripts/ci/e2e-case-paths.tsv
@@ -73,22 +73,22 @@ clinical-filter-mane-and-quality-3-modules	assets/construct_variants.tsv assets/
 clinvar-clip-check-1	assets/construct_variants.tsv assets/deep_intronic_sites.tsv bin/clip_check.py bin/og bin/render_report.py scripts/06-clinvar-screen.sh scripts/ci/fake-docker/lib.sh
 clinvar-combined-allele-1	assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/stub/sample.bam assets/stub/sample.bam.bai bin/clip_check.py bin/og modules/local/clinvar_screen/* modules/local/vcf_precheck/* scripts/06-clinvar-screen.sh scripts/24-html-report.sh scripts/ci/fake-docker/lib.sh scripts/generate-report.sh scripts/validate-setup.sh tests/fixtures/vcf/combined_allele_clinvar.vcf tests/fixtures/vcf/combined_allele_sample.vcf
 clinvar-cpsr-quality-1	assets/construct_variants.tsv assets/deep_intronic_sites.tsv bin/clip_check.py bin/og bin/render_report.py scripts/06-clinvar-screen.sh scripts/ci/fake-docker/lib.sh
-cn-engine-1-parity	assets/bloodtype_markers.tsv bin/cn_loci.tsv bin/copy_number.py bin/og bin/traits_report.py scripts/41-bloodtype.sh scripts/46-lpa.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
-cn-guard-1-mapq0	bin/cn_loci.tsv bin/copy_number.py bin/og bin/traits_report.py modules/local/parascopy/* scripts/35-paralogs.sh
+cn-engine-1-parity	assets/bloodtype_markers.tsv bin/cn_loci.tsv bin/og bin/traits_report.py scripts/41-bloodtype.sh scripts/46-lpa.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
+cn-guard-1-mapq0	bin/cn_loci.tsv bin/og bin/traits_report.py modules/local/parascopy/* scripts/35-paralogs.sh
 cn-intervals-1-catalog	bin/cn_loci.tsv bin/og scripts/ci/build-cn-intervals.py scripts/ci/fake-docker/lib.sh
-cn-intervals-2-hg002	assets/par_grch38.bed assets/paralog_loci.tsv bin/cn_loci.tsv bin/copy_number.py bin/og bin/traits_report.py modules/local/deepvariant/* modules/local/parascopy/* modules/local/vcf_precheck/* scripts/35-paralogs.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
+cn-intervals-2-hg002	assets/par_grch38.bed assets/paralog_loci.tsv bin/cn_loci.tsv bin/og bin/traits_report.py modules/local/deepvariant/* modules/local/parascopy/* modules/local/vcf_precheck/* scripts/35-paralogs.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 cn-report-1-tables	assets/carrier_genes.tsv assets/par_grch38.bed bin/collect_summary.py bin/couple_report.py bin/family_report.py bin/og bin/paraphase_report.py bin/render_report.py bin/results_index.py bin/traits_report.py scripts/24-html-report.sh scripts/39-couple.sh scripts/ci/fake-docker/lib.sh scripts/generate-report.sh
 comphet-phasing-1-reads	assets/construct_variants.tsv assets/stub/sample.bam assets/stub/sample.bam.bai bin/clip_check.py bin/og modules/local/slivar/* modules/local/vcf_precheck/* modules/local/vep/* scripts/13-vep-annotation.sh scripts/31-slivar.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh tests/fixtures/comphet/make_fixture.py
 construct-scan-1-both	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/mito_confirmed.tsv assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz bin/clip_check.py bin/collect_summary.py bin/og bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/clinvar_screen/* modules/local/html_report/* modules/local/vcf_precheck/* scripts/06-clinvar-screen.sh scripts/24-html-report.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 consumer-export-1	assets/chip_genes.tsv assets/par_grch38.bed bin/chip_report.py bin/og modules/local/chip/* modules/local/export_consumer/* modules/local/vcf_precheck/* scripts/40-export-consumer.sh scripts/49-chip.sh scripts/chip-to-vcf.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh tests/fixtures/consumer_export/sites.tsv.gz
 containers-software-versions	scripts/ci/fake-docker/lib.sh scripts/ci/gen-containers-config.sh
-couple-carrier-1	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/families.example.tsv assets/mito_confirmed.tsv assets/par_grch38.bed assets/paralog_loci.tsv assets/pedigree.example.tsv assets/pgx_genes.tsv assets/str_extra_loci.json assets/stub/db/catalog.json assets/stub/db/hla.dat assets/stub/db/kir.dat assets/stub/pedigree.tsv assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz bin/clip_check.py bin/cn_loci.tsv bin/collect_summary.py bin/copy_number.py bin/couple_report.py bin/family_report.py bin/og bin/pgx_outside_calls.py bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/clinvar_screen/* modules/local/couple/* modules/local/delly/* modules/local/expansion_hunter/* modules/local/hla_typing/* modules/local/html_report/* modules/local/parascopy/* modules/local/somalier/* modules/local/t1k_build/* modules/local/vcf_precheck/* scripts/06-clinvar-screen.sh scripts/08-hla-typing.sh scripts/09-expansion-hunter.sh scripts/19-delly.sh scripts/24-html-report.sh scripts/32-pypgx.sh scripts/33-sample-qc.sh scripts/35-paralogs.sh scripts/36-pgx-consensus.sh scripts/38-family.sh scripts/39-couple.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
-couple-common-sv-1	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/families.example.tsv assets/mito_confirmed.tsv assets/par_grch38.bed assets/pedigree.example.tsv assets/stub/pedigree.tsv assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz bin/clip_check.py bin/cn_loci.tsv bin/collect_summary.py bin/copy_number.py bin/couple_report.py bin/family_report.py bin/og bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/clinvar_screen/* modules/local/couple/* modules/local/delly/* modules/local/html_report/* modules/local/vcf_precheck/* scripts/06-clinvar-screen.sh scripts/19-delly.sh scripts/24-html-report.sh scripts/38-family.sh scripts/39-couple.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh scripts/validate-setup.sh
-cpic-phenoconversion-1-medications	assets/pgx_contraindications.tsv assets/pgx_genes.tsv assets/pgx_inhibitors.tsv bin/cn_loci.tsv bin/collect_summary.py bin/copy_number.py bin/og bin/pgx_outside_calls.py bin/traits_report.py modules/local/cpic_lookup/* modules/local/pharmcat/* modules/local/vcf_precheck/* scripts/07-pharmacogenomics.sh scripts/27-cpic-lookup.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
-cyp21a2-short-reads-1-hg002	bin/cn_loci.tsv bin/copy_number.py bin/og bin/traits_report.py modules/local/parascopy/* scripts/35-paralogs.sh
-exomiser-1	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/families.example.tsv assets/mito_confirmed.tsv assets/par_grch38.bed assets/pedigree.example.tsv assets/pgx_genes.tsv assets/stub/db/hla.dat assets/stub/db/kir.dat assets/stub/pedigree.tsv assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz assets/stub/sample.vcf.gz.tbi bin/cn_loci.tsv bin/collect_summary.py bin/copy_number.py bin/family_report.py bin/og bin/pgx_outside_calls.py bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/exomiser/* modules/local/hla_typing/* modules/local/html_report/* modules/local/t1k_build/* modules/local/vcf_precheck/* scripts/08-hla-typing.sh scripts/24-html-report.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/38-family.sh scripts/48-exomiser.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh scripts/validate-setup.sh
+couple-carrier-1	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/families.example.tsv assets/mito_confirmed.tsv assets/par_grch38.bed assets/paralog_loci.tsv assets/pedigree.example.tsv assets/pgx_genes.tsv assets/str_extra_loci.json assets/stub/db/catalog.json assets/stub/db/hla.dat assets/stub/db/kir.dat assets/stub/pedigree.tsv assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz bin/clip_check.py bin/cn_loci.tsv bin/collect_summary.py bin/couple_report.py bin/family_report.py bin/og bin/pgx_outside_calls.py bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/clinvar_screen/* modules/local/couple/* modules/local/delly/* modules/local/expansion_hunter/* modules/local/hla_typing/* modules/local/html_report/* modules/local/parascopy/* modules/local/somalier/* modules/local/t1k_build/* modules/local/vcf_precheck/* scripts/06-clinvar-screen.sh scripts/08-hla-typing.sh scripts/09-expansion-hunter.sh scripts/19-delly.sh scripts/24-html-report.sh scripts/32-pypgx.sh scripts/33-sample-qc.sh scripts/35-paralogs.sh scripts/36-pgx-consensus.sh scripts/38-family.sh scripts/39-couple.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
+couple-common-sv-1	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/families.example.tsv assets/mito_confirmed.tsv assets/par_grch38.bed assets/pedigree.example.tsv assets/stub/pedigree.tsv assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz bin/clip_check.py bin/cn_loci.tsv bin/collect_summary.py bin/couple_report.py bin/family_report.py bin/og bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/clinvar_screen/* modules/local/couple/* modules/local/delly/* modules/local/html_report/* modules/local/vcf_precheck/* scripts/06-clinvar-screen.sh scripts/19-delly.sh scripts/24-html-report.sh scripts/38-family.sh scripts/39-couple.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh scripts/validate-setup.sh
+cpic-phenoconversion-1-medications	assets/pgx_contraindications.tsv assets/pgx_genes.tsv assets/pgx_inhibitors.tsv bin/cn_loci.tsv bin/collect_summary.py bin/og bin/pgx_outside_calls.py bin/traits_report.py modules/local/cpic_lookup/* modules/local/pharmcat/* modules/local/vcf_precheck/* scripts/07-pharmacogenomics.sh scripts/27-cpic-lookup.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
+cyp21a2-short-reads-1-hg002	bin/cn_loci.tsv bin/og bin/traits_report.py modules/local/parascopy/* scripts/35-paralogs.sh
+exomiser-1	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/families.example.tsv assets/mito_confirmed.tsv assets/par_grch38.bed assets/pedigree.example.tsv assets/pgx_genes.tsv assets/stub/db/hla.dat assets/stub/db/kir.dat assets/stub/pedigree.tsv assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz assets/stub/sample.vcf.gz.tbi bin/cn_loci.tsv bin/collect_summary.py bin/family_report.py bin/og bin/pgx_outside_calls.py bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/exomiser/* modules/local/hla_typing/* modules/local/html_report/* modules/local/t1k_build/* modules/local/vcf_precheck/* scripts/08-hla-typing.sh scripts/24-html-report.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/38-family.sh scripts/48-exomiser.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh scripts/validate-setup.sh
 expansions-and-rfc1-1-motif	assets/str_extra_loci.json assets/stub/db/catalog.json bin/og scripts/09-expansion-hunter.sh scripts/09b-stranger.sh scripts/ci/fake-docker/lib.sh scripts/generate-report.sh
-families-file-1	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/families.example.tsv assets/mito_confirmed.tsv assets/par_grch38.bed assets/pedigree.example.tsv assets/pgx_genes.tsv assets/stub/db/hla.dat assets/stub/db/kir.dat assets/stub/pedigree.tsv assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz bin/clip_check.py bin/cn_loci.tsv bin/collect_summary.py bin/copy_number.py bin/couple_report.py bin/family_report.py bin/og bin/pgx_outside_calls.py bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/align_minimap2/* modules/local/clinvar_screen/* modules/local/couple/* modules/local/deepvariant/* modules/local/fastp/* modules/local/hla_typing/* modules/local/html_report/* modules/local/t1k_build/* modules/local/vcf_precheck/* scripts/01b-fastp-qc.sh scripts/06-clinvar-screen.sh scripts/08-hla-typing.sh scripts/24-html-report.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/38-family.sh scripts/39-couple.sh scripts/ci/check-images.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh tests/fixtures/families/stub_families.tsv
+families-file-1	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/families.example.tsv assets/mito_confirmed.tsv assets/par_grch38.bed assets/pedigree.example.tsv assets/pgx_genes.tsv assets/stub/db/hla.dat assets/stub/db/kir.dat assets/stub/pedigree.tsv assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz bin/clip_check.py bin/cn_loci.tsv bin/collect_summary.py bin/couple_report.py bin/family_report.py bin/og bin/pgx_outside_calls.py bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/align_minimap2/* modules/local/clinvar_screen/* modules/local/couple/* modules/local/deepvariant/* modules/local/fastp/* modules/local/hla_typing/* modules/local/html_report/* modules/local/t1k_build/* modules/local/vcf_precheck/* scripts/01b-fastp-qc.sh scripts/06-clinvar-screen.sh scripts/08-hla-typing.sh scripts/24-html-report.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/38-family.sh scripts/39-couple.sh scripts/ci/check-images.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh tests/fixtures/families/stub_families.tsv
 family-joint-1	assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/families.example.tsv assets/par_grch38.bed assets/pedigree.example.tsv assets/stub/pedigree.tsv assets/stub/sample.bam assets/stub/sample.bam.bai bin/clip_check.py bin/collect_summary.py bin/family_report.py bin/og bin/traits_report.py modules/local/align_minimap2/* modules/local/clinvar_screen/* modules/local/deepvariant/* modules/local/fastp/* modules/local/roh/* modules/local/somalier/* modules/local/vcf_precheck/* scripts/01b-fastp-qc.sh scripts/06-clinvar-screen.sh scripts/11-roh-analysis.sh scripts/33-sample-qc.sh scripts/38-family.sh scripts/ci/check-images.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 fixitfelix-chr21-1	assets/callability_genes.tsv scripts/16b-mosdepth.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh
 followups-ci-3-sv-rule-regions	assets/sv_rule_regions.tsv scripts/ci/build-sv-rule-regions.sh scripts/ci/fake-docker/lib.sh
@@ -99,40 +99,40 @@ genome-lookup-1	bin/og scripts/ci/fake-docker/lib.sh scripts/owngenome-lookup.sh
 genotype-rule-rows-1-str-extra	assets/str_extra_loci.json assets/stub/db/catalog.json scripts/09-expansion-hunter.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh
 genotype-rules-1-phase	assets/genotype_rules.tsv assets/traits.tsv bin/traits_report.py modules/local/traits/* modules/local/vcf_precheck/* scripts/42-traits.sh scripts/ci/check-rule-alleles.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 genotype-rules-2-g2	assets/genotype_rules.tsv bin/collect_summary.py bin/genotype_rules_indels.py bin/traits_report.py
-genotype-rules-2-lpa-null	bin/cn_loci.tsv bin/collect_summary.py bin/copy_number.py bin/og bin/render_report.py bin/traits_report.py modules/local/lpa/* scripts/24-html-report.sh scripts/46-lpa.sh scripts/generate-report.sh
-genotype-rules-2-smn1-marker	bin/collect_summary.py bin/copy_number.py bin/og bin/render_report.py bin/traits_report.py modules/local/parascopy/* scripts/24-html-report.sh scripts/35-paralogs.sh scripts/generate-report.sh
+genotype-rules-2-lpa-null	bin/cn_loci.tsv bin/collect_summary.py bin/og bin/render_report.py bin/traits_report.py modules/local/lpa/* scripts/24-html-report.sh scripts/46-lpa.sh scripts/generate-report.sh
+genotype-rules-2-smn1-marker	bin/collect_summary.py bin/og bin/render_report.py bin/traits_report.py modules/local/parascopy/* scripts/24-html-report.sh scripts/35-paralogs.sh scripts/generate-report.sh
 haplogroup-explore-1-files	assets/callability_genes.tsv assets/live/index.html assets/mito_confirmed.tsv assets/viewer/index.html bin/collect_summary.py bin/og bin/traits_report.py bin/yleaf_run.py modules/local/indexcov/* modules/local/mito_haplogroup/* modules/local/mito_variants/* modules/local/vcf_precheck/* modules/local/y_haplogroup/* scripts/12-mito-haplogroup.sh scripts/16-indexcov.sh scripts/16b-mosdepth.sh scripts/20-mtoolbox.sh scripts/37-y-haplogroup.sh scripts/ci/fake-docker/lib.sh scripts/generate-report.sh scripts/setup.sh scripts/validate-setup.sh
-hba-short-read-accuracy-1-nf-report	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/mito_confirmed.tsv assets/par_grch38.bed assets/stub/sample.vcf.gz bin/cn_loci.tsv bin/collect_summary.py bin/copy_number.py bin/og bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/export_consumer/* modules/local/html_report/* modules/local/vcf_precheck/* scripts/24-html-report.sh scripts/40-export-consumer.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh tests/fixtures/consumer_export/sites.tsv.gz
-hla-second-caller-1-bash	assets/pgx_genes.tsv assets/stub/db/hla.dat assets/stub/db/kir.dat bin/cn_loci.tsv bin/copy_number.py bin/og bin/pgx_outside_calls.py bin/render_report.py scripts/08-hla-typing.sh scripts/24-html-report.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
-hla-second-caller-2-nextflow	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/mito_confirmed.tsv assets/pgx_genes.tsv assets/stub/db/hla.dat assets/stub/db/kir.dat assets/stub/sample.vcf.gz bin/cn_loci.tsv bin/collect_summary.py bin/copy_number.py bin/og bin/pgx_outside_calls.py bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/hla_typing/* modules/local/html_report/* modules/local/pgx_consensus/* modules/local/pharmcat/* modules/local/t1k_build/* modules/local/vcf_precheck/* scripts/07-pharmacogenomics.sh scripts/08-hla-typing.sh scripts/21-cyrius.sh scripts/24-html-report.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/fake-docker/lib.sh scripts/cyrius-constraints.txt scripts/setup.sh scripts/validate-setup.sh
+hba-short-read-accuracy-1-nf-report	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/mito_confirmed.tsv assets/par_grch38.bed assets/stub/sample.vcf.gz bin/cn_loci.tsv bin/collect_summary.py bin/og bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/export_consumer/* modules/local/html_report/* modules/local/vcf_precheck/* scripts/24-html-report.sh scripts/40-export-consumer.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh tests/fixtures/consumer_export/sites.tsv.gz
+hla-second-caller-1-bash	assets/pgx_genes.tsv assets/stub/db/hla.dat assets/stub/db/kir.dat bin/cn_loci.tsv bin/og bin/pgx_outside_calls.py bin/render_report.py scripts/08-hla-typing.sh scripts/24-html-report.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
+hla-second-caller-2-nextflow	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/mito_confirmed.tsv assets/pgx_genes.tsv assets/stub/db/hla.dat assets/stub/db/kir.dat assets/stub/sample.vcf.gz bin/cn_loci.tsv bin/collect_summary.py bin/og bin/pgx_outside_calls.py bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/hla_typing/* modules/local/html_report/* modules/local/pgx_consensus/* modules/local/pharmcat/* modules/local/t1k_build/* modules/local/vcf_precheck/* scripts/07-pharmacogenomics.sh scripts/08-hla-typing.sh scripts/21-cyrius.sh scripts/24-html-report.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/fake-docker/lib.sh scripts/cyrius-constraints.txt scripts/setup.sh scripts/validate-setup.sh
 ibd-segments-1	assets/families.example.tsv assets/par_grch38.bed assets/pedigree.example.tsv assets/stub/pedigree.tsv bin/family_report.py bin/og scripts/38-family.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh
 live-server-1-weblog	assets/live/* assets/viewer/index.html bin/live_results.py bin/owngenome_live.py bin/owngenome_live_results.py bin/render_report.py bin/run_state.py modules/local/roh/* modules/local/vcf_precheck/* scripts/11-roh-analysis.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
-lpa-1	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/mito_confirmed.tsv assets/par_grch38.bed assets/stub/sample.vcf.gz bin/cn_loci.tsv bin/collect_summary.py bin/copy_number.py bin/og bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/deepvariant/* modules/local/html_report/* modules/local/lpa/* modules/local/vcf_precheck/* scripts/24-html-report.sh scripts/46-lpa.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
+lpa-1	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/mito_confirmed.tsv assets/par_grch38.bed assets/stub/sample.vcf.gz bin/cn_loci.tsv bin/collect_summary.py bin/og bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/deepvariant/* modules/local/html_report/* modules/local/lpa/* modules/local/vcf_precheck/* scripts/24-html-report.sh scripts/46-lpa.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 mei-1	assets/mei_sites.tsv assets/par_grch38.bed assets/sv_rule_regions.tsv bin/annotsv_postfilter.py bin/cnvpytor_to_vcf.py bin/collect_summary.py bin/family_report.py bin/og bin/traits_report.py modules/local/align_minimap2/* modules/local/annotsv/* modules/local/deepvariant/* modules/local/fastp/* modules/local/mei/* modules/local/vcf_precheck/* scripts/01b-fastp-qc.sh scripts/05-annotsv.sh scripts/15-duphold.sh scripts/18-cnvpytor.sh scripts/19-delly.sh scripts/50-mei.sh scripts/ci/check-images.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh scripts/validate-setup.sh tests/fixtures/annotsv/class45.sh
 mito-extended-1-deletions	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/mito_confirmed.tsv assets/stub/db/clinvar.vcf.gz assets/stub/db/clinvar.vcf.gz.tbi assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz bin/clip_check.py bin/collect_summary.py bin/og bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/clinvar_screen/* modules/local/html_report/* modules/local/mito_variants/* modules/local/vcf_precheck/* scripts/06-clinvar-screen.sh scripts/16b-mosdepth.sh scripts/20-mtoolbox.sh scripts/24-html-report.sh scripts/ci/build-mito-confirmed.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 mocha-1	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/mito_confirmed.tsv assets/stub/sample.vcf.gz bin/collect_summary.py bin/og bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/html_report/* modules/local/mocha/* modules/local/vcf_precheck/* scripts/24-html-report.sh scripts/51-mocha.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh scripts/validate-setup.sh
 mosaic-loy-lox-1	assets/callability_genes.tsv bin/collect_summary.py bin/og bin/traits_report.py scripts/16b-mosdepth.sh scripts/33-sample-qc.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh
-nextflow-from-fastq-1-bash	assets/callability_genes.tsv assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/pgs_scores.tsv assets/pgx_genes.tsv assets/stub/db/hla.dat assets/stub/db/kir.dat bin/clip_check.py bin/cn_loci.tsv bin/collect_summary.py bin/copy_number.py bin/og bin/pgx_outside_calls.py bin/traits_report.py scripts/01b-fastp-qc.sh scripts/06-clinvar-screen.sh scripts/07-pharmacogenomics.sh scripts/08-hla-typing.sh scripts/11-roh-analysis.sh scripts/16b-mosdepth.sh scripts/20-mtoolbox.sh scripts/25-prs.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/fake-docker/lib.sh scripts/ci/parity-diff.sh scripts/validate-setup.sh
-nextflow-from-fastq-2-nextflow	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/live/index.html assets/mito_confirmed.tsv assets/par_grch38.bed assets/pgs_scores.tsv assets/pgx_contraindications.tsv assets/pgx_genes.tsv assets/pgx_inhibitors.tsv assets/stub/db/hla.dat assets/stub/db/kir.dat assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz assets/viewer/index.html bin/clip_check.py bin/cn_loci.tsv bin/collect_summary.py bin/copy_number.py bin/og bin/pgx_outside_calls.py bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/align_minimap2/* modules/local/clinvar_screen/* modules/local/cpic_lookup/* modules/local/cyrius/* modules/local/deepvariant/* modules/local/fastp/* modules/local/hla_typing/* modules/local/html_report/* modules/local/indexcov/* modules/local/mito_haplogroup/* modules/local/mito_variants/* modules/local/mosdepth/* modules/local/multiqc/* modules/local/pharmcat/* modules/local/prs/* modules/local/roh/* modules/local/t1k_build/* modules/local/telomere_hunter/* modules/local/vcf_precheck/* modules/local/vcfanno/* scripts/01b-fastp-qc.sh scripts/06-clinvar-screen.sh scripts/07-pharmacogenomics.sh scripts/08-hla-typing.sh scripts/10-telomere-hunter.sh scripts/11-roh-analysis.sh scripts/12-mito-haplogroup.sh scripts/16-indexcov.sh scripts/16b-mosdepth.sh scripts/20-mtoolbox.sh scripts/21-cyrius.sh scripts/24-html-report.sh scripts/25-prs.sh scripts/26-ancestry.sh scripts/27-cpic-lookup.sh scripts/28-multiqc.sh scripts/30-vcfanno.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/check-images.sh scripts/ci/fake-docker/lib.sh scripts/cyrius-constraints.txt scripts/validate-setup.sh
+nextflow-from-fastq-1-bash	assets/callability_genes.tsv assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/pgs_scores.tsv assets/pgx_genes.tsv assets/stub/db/hla.dat assets/stub/db/kir.dat bin/clip_check.py bin/cn_loci.tsv bin/collect_summary.py bin/og bin/pgx_outside_calls.py bin/traits_report.py scripts/01b-fastp-qc.sh scripts/06-clinvar-screen.sh scripts/07-pharmacogenomics.sh scripts/08-hla-typing.sh scripts/11-roh-analysis.sh scripts/16b-mosdepth.sh scripts/20-mtoolbox.sh scripts/25-prs.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/fake-docker/lib.sh scripts/ci/parity-diff.sh scripts/validate-setup.sh
+nextflow-from-fastq-2-nextflow	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/live/index.html assets/mito_confirmed.tsv assets/par_grch38.bed assets/pgs_scores.tsv assets/pgx_contraindications.tsv assets/pgx_genes.tsv assets/pgx_inhibitors.tsv assets/stub/db/hla.dat assets/stub/db/kir.dat assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz assets/viewer/index.html bin/clip_check.py bin/cn_loci.tsv bin/collect_summary.py bin/og bin/pgx_outside_calls.py bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/align_minimap2/* modules/local/clinvar_screen/* modules/local/cpic_lookup/* modules/local/cyrius/* modules/local/deepvariant/* modules/local/fastp/* modules/local/hla_typing/* modules/local/html_report/* modules/local/indexcov/* modules/local/mito_haplogroup/* modules/local/mito_variants/* modules/local/mosdepth/* modules/local/multiqc/* modules/local/pharmcat/* modules/local/prs/* modules/local/roh/* modules/local/t1k_build/* modules/local/telomere_hunter/* modules/local/vcf_precheck/* modules/local/vcfanno/* scripts/01b-fastp-qc.sh scripts/06-clinvar-screen.sh scripts/07-pharmacogenomics.sh scripts/08-hla-typing.sh scripts/10-telomere-hunter.sh scripts/11-roh-analysis.sh scripts/12-mito-haplogroup.sh scripts/16-indexcov.sh scripts/16b-mosdepth.sh scripts/20-mtoolbox.sh scripts/21-cyrius.sh scripts/24-html-report.sh scripts/25-prs.sh scripts/26-ancestry.sh scripts/27-cpic-lookup.sh scripts/28-multiqc.sh scripts/30-vcfanno.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/check-images.sh scripts/ci/fake-docker/lib.sh scripts/cyrius-constraints.txt scripts/validate-setup.sh
 nextflow-from-fastq-3-sexcheck	assets/callability_genes.tsv assets/live/index.html assets/viewer/index.html bin/collect_summary.py bin/traits_report.py modules/local/indexcov/* modules/local/mosdepth/* modules/local/vcf_precheck/* scripts/16-indexcov.sh scripts/16b-mosdepth.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 nextflow-hardening-1-manta	assets/par_grch38.bed assets/sv_rule_regions.tsv bin/annotsv_postfilter.py bin/cnvpytor_to_vcf.py bin/collect_summary.py bin/family_report.py bin/og bin/traits_report.py scripts/04-manta.sh scripts/05-annotsv.sh scripts/15-duphold.sh scripts/18-cnvpytor.sh scripts/19-delly.sh scripts/ci/fake-docker/lib.sh
-nextflow-hardening-2-nf	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/live/index.html assets/mito_confirmed.tsv assets/par_grch38.bed assets/pgx_genes.tsv assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz assets/sv_rule_regions.tsv assets/viewer/index.html bin/annotsv_postfilter.py bin/clip_check.py bin/cn_loci.tsv bin/cnvpytor_to_vcf.py bin/collect_summary.py bin/copy_number.py bin/family_report.py bin/og bin/pgx_outside_calls.py bin/render_report.py bin/results_index.py bin/traits_report.py bin/yleaf_run.py modules/local/clinvar_screen/* modules/local/delly/* modules/local/html_report/* modules/local/indexcov/* modules/local/manta/* modules/local/mito_haplogroup/* modules/local/mosdepth/* modules/local/pgx_consensus/* modules/local/pharmcat/* modules/local/pypgx/* modules/local/survivor_merge/* modules/local/telomere_hunter/* modules/local/vcf_precheck/* modules/local/vcfanno/* modules/local/y_haplogroup/* scripts/04-manta.sh scripts/05-annotsv.sh scripts/06-clinvar-screen.sh scripts/07-pharmacogenomics.sh scripts/10-telomere-hunter.sh scripts/12-mito-haplogroup.sh scripts/15-duphold.sh scripts/16-indexcov.sh scripts/16b-mosdepth.sh scripts/18-cnvpytor.sh scripts/19-delly.sh scripts/20-mtoolbox.sh scripts/21-cyrius.sh scripts/22-survivor-merge.sh scripts/24-html-report.sh scripts/30-vcfanno.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/37-y-haplogroup.sh scripts/ci/fake-docker/lib.sh scripts/ci/parity-diff.sh scripts/cyrius-constraints.txt scripts/setup.sh scripts/validate-setup.sh
-nextflow-report-parity-1-sections	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/mito_confirmed.tsv assets/par_grch38.bed assets/pgx_genes.tsv assets/str_extra_loci.json assets/stub/db/catalog.json assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz assets/sv_rule_regions.tsv bin/annotsv_postfilter.py bin/clip_check.py bin/cn_loci.tsv bin/cnvpytor_to_vcf.py bin/collect_summary.py bin/copy_number.py bin/family_report.py bin/og bin/pgx_outside_calls.py bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/annotsv/* modules/local/clinvar_screen/* modules/local/expansion_hunter/* modules/local/export_consumer/* modules/local/html_report/* modules/local/mito_variants/* modules/local/pypgx/* modules/local/slivar/* modules/local/stranger/* modules/local/vcf_precheck/* modules/local/vep/* scripts/05-annotsv.sh scripts/06-clinvar-screen.sh scripts/09-expansion-hunter.sh scripts/09b-stranger.sh scripts/13-vep-annotation.sh scripts/15-duphold.sh scripts/16b-mosdepth.sh scripts/18-cnvpytor.sh scripts/19-delly.sh scripts/20-mtoolbox.sh scripts/24-html-report.sh scripts/31-slivar.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/40-export-consumer.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh tests/fixtures/consumer_export/sites.tsv.gz
+nextflow-hardening-2-nf	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/live/index.html assets/mito_confirmed.tsv assets/par_grch38.bed assets/pgx_genes.tsv assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz assets/sv_rule_regions.tsv assets/viewer/index.html bin/annotsv_postfilter.py bin/clip_check.py bin/cn_loci.tsv bin/cnvpytor_to_vcf.py bin/collect_summary.py bin/family_report.py bin/og bin/pgx_outside_calls.py bin/render_report.py bin/results_index.py bin/traits_report.py bin/yleaf_run.py modules/local/clinvar_screen/* modules/local/delly/* modules/local/html_report/* modules/local/indexcov/* modules/local/manta/* modules/local/mito_haplogroup/* modules/local/mosdepth/* modules/local/pgx_consensus/* modules/local/pharmcat/* modules/local/pypgx/* modules/local/survivor_merge/* modules/local/telomere_hunter/* modules/local/vcf_precheck/* modules/local/vcfanno/* modules/local/y_haplogroup/* scripts/04-manta.sh scripts/05-annotsv.sh scripts/06-clinvar-screen.sh scripts/07-pharmacogenomics.sh scripts/10-telomere-hunter.sh scripts/12-mito-haplogroup.sh scripts/15-duphold.sh scripts/16-indexcov.sh scripts/16b-mosdepth.sh scripts/18-cnvpytor.sh scripts/19-delly.sh scripts/20-mtoolbox.sh scripts/21-cyrius.sh scripts/22-survivor-merge.sh scripts/24-html-report.sh scripts/30-vcfanno.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/37-y-haplogroup.sh scripts/ci/fake-docker/lib.sh scripts/ci/parity-diff.sh scripts/cyrius-constraints.txt scripts/setup.sh scripts/validate-setup.sh
+nextflow-report-parity-1-sections	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/mito_confirmed.tsv assets/par_grch38.bed assets/pgx_genes.tsv assets/str_extra_loci.json assets/stub/db/catalog.json assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz assets/sv_rule_regions.tsv bin/annotsv_postfilter.py bin/clip_check.py bin/cn_loci.tsv bin/cnvpytor_to_vcf.py bin/collect_summary.py bin/family_report.py bin/og bin/pgx_outside_calls.py bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/annotsv/* modules/local/clinvar_screen/* modules/local/expansion_hunter/* modules/local/export_consumer/* modules/local/html_report/* modules/local/mito_variants/* modules/local/pypgx/* modules/local/slivar/* modules/local/stranger/* modules/local/vcf_precheck/* modules/local/vep/* scripts/05-annotsv.sh scripts/06-clinvar-screen.sh scripts/09-expansion-hunter.sh scripts/09b-stranger.sh scripts/13-vep-annotation.sh scripts/15-duphold.sh scripts/16b-mosdepth.sh scripts/18-cnvpytor.sh scripts/19-delly.sh scripts/20-mtoolbox.sh scripts/24-html-report.sh scripts/31-slivar.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/40-export-consumer.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh tests/fixtures/consumer_export/sites.tsv.gz
 nf-wiring-1-report-tables	assets/acmg_sf.tsv assets/test_samplesheet.csv assets/stub/* bin/clip_check.py bin/collect_summary.py bin/cpsr_sample_id bin/og bin/render_report.py bin/results_index.py bin/traits_report.py conf/test_all.config conf/test.config modules/local/align_minimap2/* modules/local/clinical_filter/* modules/local/clinvar_screen/* modules/local/cpsr/* modules/local/html_report/* modules/local/slivar/* modules/local/vep/* scripts/24-html-report.sh tests/fixtures/consumer_export/sites.tsv.gz
 nf-wiring-2-sv-str-tools	bin/cnvpytor_to_vcf.py bin/family_report.py bin/og modules/local/cnvpytor/* modules/local/duphold/* modules/local/expansion_hunter/* modules/local/indexcov/* modules/local/manta/* modules/local/vcf_precheck/*
 output-contract-1-hg002	assets/* bin/* modules/* scripts/*
-paralog-catalog-1-gba	assets/paralog_loci.tsv assets/parascopy_models_v1.7.txt bin/cn_loci.tsv bin/copy_number.py bin/og bin/traits_report.py modules/local/parascopy/* modules/local/vcf_precheck/* scripts/35-paralogs.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh scripts/validate-setup.sh
-paralog-checks-and-doc-fixes-1-hba	assets/par_grch38.bed assets/paralog_loci.tsv bin/cn_loci.tsv bin/collect_summary.py bin/copy_number.py bin/og bin/paraphase_report.py bin/traits_report.py modules/local/align_minimap2/* modules/local/deepvariant/* modules/local/fastp/* modules/local/paraphase/* modules/local/parascopy/* modules/local/vcf_precheck/* scripts/01b-fastp-qc.sh scripts/35-paralogs.sh scripts/35b-paraphase.sh scripts/ci/check-images.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh scripts/validate-setup.sh
-paralog-rows-1	assets/paralog_loci.tsv assets/parascopy_models_v1.7.txt bin/cn_loci.tsv bin/collect_summary.py bin/copy_number.py bin/og bin/paraphase_report.py bin/render_report.py bin/traits_report.py scripts/35-paralogs.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh scripts/validate-setup.sh
+paralog-catalog-1-gba	assets/paralog_loci.tsv assets/parascopy_models_v1.7.txt bin/cn_loci.tsv bin/og bin/traits_report.py modules/local/parascopy/* modules/local/vcf_precheck/* scripts/35-paralogs.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh scripts/validate-setup.sh
+paralog-checks-and-doc-fixes-1-hba	assets/par_grch38.bed assets/paralog_loci.tsv bin/cn_loci.tsv bin/collect_summary.py bin/og bin/paraphase_report.py bin/traits_report.py modules/local/align_minimap2/* modules/local/deepvariant/* modules/local/fastp/* modules/local/paraphase/* modules/local/parascopy/* modules/local/vcf_precheck/* scripts/01b-fastp-qc.sh scripts/35-paralogs.sh scripts/35b-paraphase.sh scripts/ci/check-images.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh scripts/validate-setup.sh
+paralog-rows-1	assets/paralog_loci.tsv assets/parascopy_models_v1.7.txt bin/cn_loci.tsv bin/collect_summary.py bin/og bin/paraphase_report.py bin/render_report.py bin/traits_report.py scripts/35-paralogs.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh scripts/validate-setup.sh
 paralogs-paraphase-1	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/mito_confirmed.tsv assets/par_grch38.bed assets/stub/sample.vcf.gz bin/collect_summary.py bin/og bin/paraphase_report.py bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/align_minimap2/* modules/local/deepvariant/* modules/local/fastp/* modules/local/html_report/* modules/local/paraphase/* modules/local/vcf_precheck/* scripts/01b-fastp-qc.sh scripts/24-html-report.sh scripts/35b-paraphase.sh scripts/ci/check-images.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
-paralogs-report-section-1-nf-report-tables	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/mito_confirmed.tsv assets/par_grch38.bed assets/pgx_genes.tsv assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz bin/clip_check.py bin/cn_loci.tsv bin/collect_summary.py bin/copy_number.py bin/og bin/pgx_outside_calls.py bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/clinvar_screen/* modules/local/export_consumer/* modules/local/html_report/* modules/local/pypgx/* modules/local/slivar/* modules/local/vcf_precheck/* scripts/06-clinvar-screen.sh scripts/24-html-report.sh scripts/31-slivar.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/40-export-consumer.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh tests/fixtures/consumer_export/sites.tsv.gz
+paralogs-report-section-1-nf-report-tables	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/mito_confirmed.tsv assets/par_grch38.bed assets/pgx_genes.tsv assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz bin/clip_check.py bin/cn_loci.tsv bin/collect_summary.py bin/og bin/pgx_outside_calls.py bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/clinvar_screen/* modules/local/export_consumer/* modules/local/html_report/* modules/local/pypgx/* modules/local/slivar/* modules/local/vcf_precheck/* scripts/06-clinvar-screen.sh scripts/24-html-report.sh scripts/31-slivar.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/40-export-consumer.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh tests/fixtures/consumer_export/sites.tsv.gz
 pgx-1-depth-check	bin/og scripts/21-cyrius.sh scripts/32-pypgx.sh scripts/ci/alt-depth-ab.sh scripts/ci/fake-docker/lib.sh
-pgx-2-outside-calls	assets/pgx_contraindications.tsv assets/pgx_genes.tsv assets/pgx_inhibitors.tsv bin/cn_loci.tsv bin/collect_summary.py bin/copy_number.py bin/og bin/pgx_outside_calls.py bin/traits_report.py scripts/07-pharmacogenomics.sh scripts/27-cpic-lookup.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
-pgx-4-parascopy	assets/paralog_loci.tsv bin/cn_loci.tsv bin/copy_number.py bin/og bin/traits_report.py scripts/35-paralogs.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh scripts/validate-setup.sh
-pgx-5-kir	assets/pgx_genes.tsv assets/stub/db/hla.dat assets/stub/db/kir.dat bin/cn_loci.tsv bin/copy_number.py bin/og bin/pgx_outside_calls.py bin/render_report.py scripts/08-hla-typing.sh scripts/24-html-report.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh scripts/validate-setup.sh
+pgx-2-outside-calls	assets/pgx_contraindications.tsv assets/pgx_genes.tsv assets/pgx_inhibitors.tsv bin/cn_loci.tsv bin/collect_summary.py bin/og bin/pgx_outside_calls.py bin/traits_report.py scripts/07-pharmacogenomics.sh scripts/27-cpic-lookup.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
+pgx-4-parascopy	assets/paralog_loci.tsv bin/cn_loci.tsv bin/og bin/traits_report.py scripts/35-paralogs.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh scripts/validate-setup.sh
+pgx-5-kir	assets/pgx_genes.tsv assets/stub/db/hla.dat assets/stub/db/kir.dat bin/cn_loci.tsv bin/og bin/pgx_outside_calls.py bin/render_report.py scripts/08-hla-typing.sh scripts/24-html-report.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh scripts/validate-setup.sh
 pgx-6-gvcf-column	assets/live/index.html assets/par_grch38.bed assets/pgs_scores.tsv assets/viewer/index.html bin/collect_summary.py bin/og bin/traits_report.py modules/local/align_minimap2/* modules/local/deepvariant/* modules/local/fastp/* modules/local/indexcov/* modules/local/pharmcat/* modules/local/prs/* modules/local/vcf_precheck/* scripts/01b-fastp-qc.sh scripts/07-pharmacogenomics.sh scripts/16-indexcov.sh scripts/25-prs.sh scripts/26-ancestry.sh scripts/ci/check-images.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
-pgx-inhibitor-rows-1-contraindication	assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/pgx_contraindications.tsv assets/pgx_genes.tsv assets/pgx_inhibitors.tsv assets/stub/sample.bam assets/stub/sample.bam.bai bin/clip_check.py bin/cn_loci.tsv bin/collect_summary.py bin/copy_number.py bin/og bin/pgx_outside_calls.py bin/traits_report.py modules/local/clinvar_screen/* modules/local/cpic_lookup/* modules/local/pharmcat/* modules/local/vcf_precheck/* scripts/06-clinvar-screen.sh scripts/07-pharmacogenomics.sh scripts/27-cpic-lookup.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
-pgx-parse-fixes-1-labels	assets/pgx_contraindications.tsv assets/pgx_genes.tsv assets/pgx_inhibitors.tsv bin/cn_loci.tsv bin/collect_summary.py bin/copy_number.py bin/og bin/pgx_outside_calls.py bin/traits_report.py scripts/27-cpic-lookup.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
+pgx-inhibitor-rows-1-contraindication	assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/pgx_contraindications.tsv assets/pgx_genes.tsv assets/pgx_inhibitors.tsv assets/stub/sample.bam assets/stub/sample.bam.bai bin/clip_check.py bin/cn_loci.tsv bin/collect_summary.py bin/og bin/pgx_outside_calls.py bin/traits_report.py modules/local/clinvar_screen/* modules/local/cpic_lookup/* modules/local/pharmcat/* modules/local/vcf_precheck/* scripts/06-clinvar-screen.sh scripts/07-pharmacogenomics.sh scripts/27-cpic-lookup.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
+pgx-parse-fixes-1-labels	assets/pgx_contraindications.tsv assets/pgx_genes.tsv assets/pgx_inhibitors.tsv bin/cn_loci.tsv bin/collect_summary.py bin/og bin/pgx_outside_calls.py bin/traits_report.py scripts/27-cpic-lookup.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 pharmcat-indel-refblocks-1	bin/og scripts/07-pharmacogenomics.sh scripts/ci/fake-docker/lib.sh tests/fixtures/pharmcat/refblocks.g.vcf
 pharmcat-mito-input-and-log-1-mtrnr1	bin/og scripts/07-pharmacogenomics.sh scripts/ci/fake-docker/lib.sh
 platelet-antigens-1	assets/bloodtype_markers.tsv bin/cn_loci.tsv bin/og scripts/41-bloodtype.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
@@ -142,21 +142,21 @@ prs-3-panel-measure	assets/pgs_scores.tsv bin/collect_summary.py bin/traits_repo
 prs-runopts-and-trace-1	assets/par_grch38.bed assets/pgs_scores.tsv bin/collect_summary.py bin/traits_report.py modules/local/align_minimap2/* modules/local/deepvariant/* modules/local/fastp/* modules/local/prs/* modules/local/vcf_precheck/* scripts/01b-fastp-qc.sh scripts/25-prs.sh scripts/26-ancestry.sh scripts/ci/check-images.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 prs-scores-and-run-options-1-strand-sex	assets/pgs_scores.tsv bin/collect_summary.py bin/traits_report.py modules/local/prs/* modules/local/vcf_precheck/* scripts/25-prs.sh scripts/26-ancestry.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 prs-scores-and-run-options-2-panel-chrx	assets/pgs_scores.tsv bin/collect_summary.py bin/traits_report.py scripts/25-prs.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh
-pypgx-cyp2d6-section-1-summary	assets/pgx_genes.tsv bin/cn_loci.tsv bin/copy_number.py bin/og bin/pgx_outside_calls.py scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
+pypgx-cyp2d6-section-1-summary	assets/pgx_genes.tsv bin/cn_loci.tsv bin/og bin/pgx_outside_calls.py scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 qc-1-sample-qc	bin/collect_summary.py bin/og bin/traits_report.py scripts/28-multiqc.sh scripts/33-sample-qc.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh
-qc-2-nextflow-sample-qc	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/families.example.tsv assets/live/index.html assets/mito_confirmed.tsv assets/par_grch38.bed assets/pedigree.example.tsv assets/pgx_contraindications.tsv assets/pgx_genes.tsv assets/pgx_inhibitors.tsv assets/stub/db/hla.dat assets/stub/db/kir.dat assets/stub/pedigree.tsv assets/stub/sample.vcf.gz assets/viewer/index.html bin/cn_loci.tsv bin/collect_summary.py bin/copy_number.py bin/family_report.py bin/og bin/pgx_outside_calls.py bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/align_minimap2/* modules/local/cpic_lookup/* modules/local/deepvariant/* modules/local/fastp/* modules/local/hla_typing/* modules/local/html_report/* modules/local/indexcov/* modules/local/mito_haplogroup/* modules/local/mito_variants/* modules/local/mosdepth/* modules/local/pharmcat/* modules/local/pypgx/* modules/local/roh/* modules/local/somalier/* modules/local/t1k_build/* modules/local/telomere_hunter/* modules/local/vcf_precheck/* modules/local/verifybamid2/* scripts/01b-fastp-qc.sh scripts/07-pharmacogenomics.sh scripts/08-hla-typing.sh scripts/10-telomere-hunter.sh scripts/11-roh-analysis.sh scripts/12-mito-haplogroup.sh scripts/16-indexcov.sh scripts/16b-mosdepth.sh scripts/20-mtoolbox.sh scripts/24-html-report.sh scripts/27-cpic-lookup.sh scripts/32-pypgx.sh scripts/33-sample-qc.sh scripts/36-pgx-consensus.sh scripts/38-family.sh scripts/ci/check-images.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
+qc-2-nextflow-sample-qc	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/families.example.tsv assets/live/index.html assets/mito_confirmed.tsv assets/par_grch38.bed assets/pedigree.example.tsv assets/pgx_contraindications.tsv assets/pgx_genes.tsv assets/pgx_inhibitors.tsv assets/stub/db/hla.dat assets/stub/db/kir.dat assets/stub/pedigree.tsv assets/stub/sample.vcf.gz assets/viewer/index.html bin/cn_loci.tsv bin/collect_summary.py bin/family_report.py bin/og bin/pgx_outside_calls.py bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/align_minimap2/* modules/local/cpic_lookup/* modules/local/deepvariant/* modules/local/fastp/* modules/local/hla_typing/* modules/local/html_report/* modules/local/indexcov/* modules/local/mito_haplogroup/* modules/local/mito_variants/* modules/local/mosdepth/* modules/local/pharmcat/* modules/local/pypgx/* modules/local/roh/* modules/local/somalier/* modules/local/t1k_build/* modules/local/telomere_hunter/* modules/local/vcf_precheck/* modules/local/verifybamid2/* scripts/01b-fastp-qc.sh scripts/07-pharmacogenomics.sh scripts/08-hla-typing.sh scripts/10-telomere-hunter.sh scripts/11-roh-analysis.sh scripts/12-mito-haplogroup.sh scripts/16-indexcov.sh scripts/16b-mosdepth.sh scripts/20-mtoolbox.sh scripts/24-html-report.sh scripts/27-cpic-lookup.sh scripts/32-pypgx.sh scripts/33-sample-qc.sh scripts/36-pgx-consensus.sh scripts/38-family.sh scripts/ci/check-images.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 qc-3-cram	assets/callability_genes.tsv bin/collect_summary.py bin/traits_report.py modules/local/cram_archive/* modules/local/mosdepth/* modules/local/vcf_precheck/* scripts/16b-mosdepth.sh scripts/34-cram-archive.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 reference-noalt	scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 report-followups-1-sections	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/genotype_rules.tsv assets/mito_confirmed.tsv assets/par_grch38.bed assets/str_extra_loci.json assets/stub/db/catalog.json assets/stub/sample.vcf.gz assets/sv_rule_regions.tsv assets/traits.tsv bin/annotsv_postfilter.py bin/cnvpytor_to_vcf.py bin/collect_summary.py bin/family_report.py bin/og bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/annotsv/* modules/local/expansion_hunter/* modules/local/export_consumer/* modules/local/html_report/* modules/local/manta/* modules/local/traits/* modules/local/vcf_precheck/* scripts/04-manta.sh scripts/05-annotsv.sh scripts/09-expansion-hunter.sh scripts/15-duphold.sh scripts/18-cnvpytor.sh scripts/19-delly.sh scripts/24-html-report.sh scripts/40-export-consumer.sh scripts/42-traits.sh scripts/ci/fake-docker/lib.sh scripts/generate-report.sh scripts/validate-setup.sh tests/fixtures/consumer_export/sites.tsv.gz
 report-sections-mito-roh-telomere-cnv-1-mito	assets/callability_genes.tsv bin/collect_summary.py bin/traits_report.py scripts/10-telomere-hunter.sh scripts/16b-mosdepth.sh scripts/20-mtoolbox.sh scripts/ci/fake-docker/lib.sh scripts/generate-report.sh scripts/validate-setup.sh
 reports-and-pgx-correctness-clinical	assets/construct_variants.tsv bin/clip_check.py bin/og scripts/23-clinical-filter.sh scripts/31-slivar.sh scripts/ci/fake-docker/lib.sh
-reports-and-pgx-correctness-pgx	assets/pgx_contraindications.tsv assets/pgx_genes.tsv assets/pgx_inhibitors.tsv bin/cn_loci.tsv bin/collect_summary.py bin/copy_number.py bin/og bin/pgx_outside_calls.py bin/traits_report.py scripts/27-cpic-lookup.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
+reports-and-pgx-correctness-pgx	assets/pgx_contraindications.tsv assets/pgx_genes.tsv assets/pgx_inhibitors.tsv bin/cn_loci.tsv bin/collect_summary.py bin/og bin/pgx_outside_calls.py bin/traits_report.py scripts/27-cpic-lookup.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 reports-and-pgx-correctness-reports	assets/stub/db/clinvar.vcf.gz assets/stub/db/hla.dat bin/collect_summary.py bin/render_report.py bin/traits_report.py bin/write_manifest.sh scripts/24-html-report.sh scripts/ci/fake-docker/lib.sh scripts/generate-report.sh
 reports-and-pgx-correctness-revel	scripts/30-vcfanno.sh scripts/ci/fake-docker/lib.sh
-run-all-launcher	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/mito_confirmed.tsv assets/par_grch38.bed assets/pgs_scores.tsv assets/pgx_contraindications.tsv assets/pgx_genes.tsv assets/pgx_inhibitors.tsv assets/stub/db/hla.dat assets/stub/db/kir.dat assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz bin/clip_check.py bin/cn_loci.tsv bin/collect_summary.py bin/copy_number.py bin/og bin/pgx_outside_calls.py bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/align_minimap2/* modules/local/clinvar_screen/* modules/local/cpic_lookup/* modules/local/deepvariant/* modules/local/fastp/* modules/local/hla_typing/* modules/local/html_report/* modules/local/mito_haplogroup/* modules/local/mito_variants/* modules/local/mosdepth/* modules/local/multiqc/* modules/local/pharmcat/* modules/local/prs/* modules/local/roh/* modules/local/t1k_build/* modules/local/telomere_hunter/* modules/local/vcf_precheck/* modules/local/vcfanno/* modules/local/vep/* scripts/01b-fastp-qc.sh scripts/06-clinvar-screen.sh scripts/07-pharmacogenomics.sh scripts/08-hla-typing.sh scripts/10-telomere-hunter.sh scripts/11-roh-analysis.sh scripts/12-mito-haplogroup.sh scripts/13-vep-annotation.sh scripts/16b-mosdepth.sh scripts/20-mtoolbox.sh scripts/24-html-report.sh scripts/25-prs.sh scripts/26-ancestry.sh scripts/27-cpic-lookup.sh scripts/28-multiqc.sh scripts/30-vcfanno.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/check-images.sh scripts/ci/fake-docker/lib.sh scripts/ci/parity-diff.sh scripts/validate-setup.sh
+run-all-launcher	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/mito_confirmed.tsv assets/par_grch38.bed assets/pgs_scores.tsv assets/pgx_contraindications.tsv assets/pgx_genes.tsv assets/pgx_inhibitors.tsv assets/stub/db/hla.dat assets/stub/db/kir.dat assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz bin/clip_check.py bin/cn_loci.tsv bin/collect_summary.py bin/og bin/pgx_outside_calls.py bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/align_minimap2/* modules/local/clinvar_screen/* modules/local/cpic_lookup/* modules/local/deepvariant/* modules/local/fastp/* modules/local/hla_typing/* modules/local/html_report/* modules/local/mito_haplogroup/* modules/local/mito_variants/* modules/local/mosdepth/* modules/local/multiqc/* modules/local/pharmcat/* modules/local/prs/* modules/local/roh/* modules/local/t1k_build/* modules/local/telomere_hunter/* modules/local/vcf_precheck/* modules/local/vcfanno/* modules/local/vep/* scripts/01b-fastp-qc.sh scripts/06-clinvar-screen.sh scripts/07-pharmacogenomics.sh scripts/08-hla-typing.sh scripts/10-telomere-hunter.sh scripts/11-roh-analysis.sh scripts/12-mito-haplogroup.sh scripts/13-vep-annotation.sh scripts/16b-mosdepth.sh scripts/20-mtoolbox.sh scripts/24-html-report.sh scripts/25-prs.sh scripts/26-ancestry.sh scripts/27-cpic-lookup.sh scripts/28-multiqc.sh scripts/30-vcfanno.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/check-images.sh scripts/ci/fake-docker/lib.sh scripts/ci/parity-diff.sh scripts/validate-setup.sh
 run-all-sample-qc-and-stale-index-1-index-times	assets/par_grch38.bed modules/local/align_minimap2/* modules/local/deepvariant/* modules/local/fastp/* modules/local/roh/* modules/local/vcf_precheck/* scripts/01b-fastp-qc.sh scripts/11-roh-analysis.sh scripts/ci/check-images.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 setup-gencode-exons-and-nextflow-clip-check-1	assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/stub/sample.bam assets/stub/sample.bam.bai bin/clip_check.py bin/og modules/local/clinvar_screen/* modules/local/vcf_precheck/* scripts/06-clinvar-screen.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
-short-sample-id-stub	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/construct_variants.tsv assets/mito_confirmed.tsv assets/pgx_contraindications.tsv assets/pgx_genes.tsv assets/pgx_inhibitors.tsv assets/stub/db/hla.dat assets/stub/db/kir.dat assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz assets/stub/sample.vcf.gz.tbi bin/clip_check.py bin/cn_loci.tsv bin/collect_summary.py bin/copy_number.py bin/cpsr_sample_id bin/og bin/pgx_outside_calls.py bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/cpic_lookup/* modules/local/cpsr/* modules/local/hla_typing/* modules/local/html_report/* modules/local/pharmcat/* modules/local/t1k_build/* modules/local/telomere_hunter/* modules/local/vcf_precheck/* scripts/07-pharmacogenomics.sh scripts/08-hla-typing.sh scripts/10-telomere-hunter.sh scripts/17-cpsr.sh scripts/24-html-report.sh scripts/27-cpic-lookup.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
+short-sample-id-stub	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/construct_variants.tsv assets/mito_confirmed.tsv assets/pgx_contraindications.tsv assets/pgx_genes.tsv assets/pgx_inhibitors.tsv assets/stub/db/hla.dat assets/stub/db/kir.dat assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz assets/stub/sample.vcf.gz.tbi bin/clip_check.py bin/cn_loci.tsv bin/collect_summary.py bin/cpsr_sample_id bin/og bin/pgx_outside_calls.py bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/cpic_lookup/* modules/local/cpsr/* modules/local/hla_typing/* modules/local/html_report/* modules/local/pharmcat/* modules/local/t1k_build/* modules/local/telomere_hunter/* modules/local/vcf_precheck/* scripts/07-pharmacogenomics.sh scripts/08-hla-typing.sh scripts/10-telomere-hunter.sh scripts/17-cpsr.sh scripts/24-html-report.sh scripts/27-cpic-lookup.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 single-source-lib-ownership	scripts/11-roh-analysis.sh scripts/ci/fake-docker/lib.sh
 str-catalog-1-strchive	assets/str_extra_loci.json assets/stub/db/catalog.json assets/stub/sample.bam assets/stub/sample.bam.bai bin/og modules/local/expansion_hunter/* modules/local/stranger/* modules/local/vcf_precheck/* scripts/09-expansion-hunter.sh scripts/09b-stranger.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh scripts/validate-setup.sh
 str-extra-repeats-1-readings	assets/str_extra_loci.json bin/collect_summary.py bin/og bin/render_report.py bin/results_index.py bin/run_delta.py bin/traits_report.py modules/local/expansion_hunter/* modules/local/html_report/* scripts/09-expansion-hunter.sh scripts/24-html-report.sh scripts/ci/fake-docker/lib.sh scripts/generate-report.sh scripts/validate-setup.sh
@@ -169,12 +169,13 @@ sv-mito-telomere-steps-6-scatter	scripts/03a-gatk-haplotypecaller.sh scripts/03b
 traits-panel-1	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/genotype_rules.tsv assets/mito_confirmed.tsv assets/stub/sample.vcf.gz assets/traits.tsv bin/collect_summary.py bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/html_report/* modules/local/traits/* modules/local/vcf_precheck/* scripts/24-html-report.sh scripts/42-traits.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 vcf-precheck-ref-spotcheck-1	assets/par_grch38.bed modules/local/align_minimap2/* modules/local/deepvariant/* modules/local/fastp/* modules/local/roh/* modules/local/vcf_precheck/* scripts/01b-fastp-qc.sh scripts/11-roh-analysis.sh scripts/ci/check-images.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh tests/fixtures/vcf/grch37_no_contigs.vcf
 vendor-vcf-intake-1-bash	bin/og scripts/07-pharmacogenomics.sh scripts/ci/fake-docker/lib.sh
-vendor-vcf-intake-2-nf-report	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/mito_confirmed.tsv assets/pgx_contraindications.tsv assets/pgx_genes.tsv assets/pgx_inhibitors.tsv assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz bin/clip_check.py bin/cn_loci.tsv bin/collect_summary.py bin/copy_number.py bin/og bin/pgx_outside_calls.py bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/clinvar_screen/* modules/local/cpic_lookup/* modules/local/html_report/* modules/local/mito_haplogroup/* modules/local/mosdepth/* modules/local/multiqc/* modules/local/pharmcat/* modules/local/roh/* modules/local/vcf_precheck/* scripts/06-clinvar-screen.sh scripts/07-pharmacogenomics.sh scripts/11-roh-analysis.sh scripts/12-mito-haplogroup.sh scripts/16b-mosdepth.sh scripts/20-mtoolbox.sh scripts/24-html-report.sh scripts/27-cpic-lookup.sh scripts/28-multiqc.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
+vendor-vcf-intake-2-nf-report	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/mito_confirmed.tsv assets/pgx_contraindications.tsv assets/pgx_genes.tsv assets/pgx_inhibitors.tsv assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz bin/clip_check.py bin/cn_loci.tsv bin/collect_summary.py bin/og bin/pgx_outside_calls.py bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/clinvar_screen/* modules/local/cpic_lookup/* modules/local/html_report/* modules/local/mito_haplogroup/* modules/local/mosdepth/* modules/local/multiqc/* modules/local/pharmcat/* modules/local/roh/* modules/local/vcf_precheck/* scripts/06-clinvar-screen.sh scripts/07-pharmacogenomics.sh scripts/11-roh-analysis.sh scripts/12-mito-haplogroup.sh scripts/16b-mosdepth.sh scripts/20-mtoolbox.sh scripts/24-html-report.sh scripts/27-cpic-lookup.sh scripts/28-multiqc.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 vendor-vcf-intake-3-nf-stops	assets/callability_genes.tsv assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/stub/sample.bam assets/stub/sample.bam.bai bin/clip_check.py bin/collect_summary.py bin/og bin/traits_report.py modules/local/clinvar_screen/* modules/local/mito_haplogroup/* modules/local/pharmcat/* modules/local/roh/* modules/local/vcf_precheck/* scripts/06-clinvar-screen.sh scripts/07-pharmacogenomics.sh scripts/11-roh-analysis.sh scripts/12-mito-haplogroup.sh scripts/16b-mosdepth.sh scripts/20-mtoolbox.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
-vendor-vcf-intake-4-nf-header-clinvar	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/mito_confirmed.tsv assets/pgx_contraindications.tsv assets/pgx_genes.tsv assets/pgx_inhibitors.tsv assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz bin/clip_check.py bin/cn_loci.tsv bin/collect_summary.py bin/copy_number.py bin/og bin/pgx_outside_calls.py bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/clinvar_screen/* modules/local/cpic_lookup/* modules/local/html_report/* modules/local/mito_haplogroup/* modules/local/pharmcat/* modules/local/roh/* modules/local/vcf_precheck/* scripts/06-clinvar-screen.sh scripts/07-pharmacogenomics.sh scripts/11-roh-analysis.sh scripts/12-mito-haplogroup.sh scripts/16b-mosdepth.sh scripts/20-mtoolbox.sh scripts/24-html-report.sh scripts/27-cpic-lookup.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
+vendor-vcf-intake-4-nf-header-clinvar	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/construct_variants.tsv assets/deep_intronic_sites.tsv assets/mito_confirmed.tsv assets/pgx_contraindications.tsv assets/pgx_genes.tsv assets/pgx_inhibitors.tsv assets/stub/sample.bam assets/stub/sample.bam.bai assets/stub/sample.vcf.gz bin/clip_check.py bin/cn_loci.tsv bin/collect_summary.py bin/og bin/pgx_outside_calls.py bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/clinvar_screen/* modules/local/cpic_lookup/* modules/local/html_report/* modules/local/mito_haplogroup/* modules/local/pharmcat/* modules/local/roh/* modules/local/vcf_precheck/* scripts/06-clinvar-screen.sh scripts/07-pharmacogenomics.sh scripts/11-roh-analysis.sh scripts/12-mito-haplogroup.sh scripts/16b-mosdepth.sh scripts/20-mtoolbox.sh scripts/24-html-report.sh scripts/27-cpic-lookup.sh scripts/32-pypgx.sh scripts/36-pgx-consensus.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 vendor-vcf-intake-5-docs	scripts/ci/fake-docker/lib.sh
 viral-reads-1	bin/og modules/local/vcf_precheck/* modules/local/viral/* scripts/47-viral.sh scripts/ci/fake-docker/lib.sh scripts/generate-report.sh scripts/setup.sh scripts/validate-setup.sh
 vntyper-1	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/mito_confirmed.tsv assets/stub/sample.vcf.gz bin/collect_summary.py bin/og bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/html_report/* modules/local/vcf_precheck/* modules/local/vntyper/* scripts/24-html-report.sh scripts/52-vntyper.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 y-private-report-1-private-and-tree	assets/live/index.html assets/viewer/index.html bin/collect_summary.py bin/og bin/render_report.py bin/results_index.py bin/run_delta.py bin/traits_report.py bin/yleaf_run.py modules/local/html_report/* modules/local/y_haplogroup/* scripts/16-indexcov.sh scripts/24-html-report.sh scripts/37-y-haplogroup.sh scripts/generate-report.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh
 y-str-1	assets/acmg_sf.tsv assets/callability_genes.tsv assets/carrier_genes.tsv assets/live/index.html assets/mito_confirmed.tsv assets/stub/sample.vcf.gz assets/viewer/index.html assets/ystr_panel.tsv bin/collect_summary.py bin/og bin/render_report.py bin/results_index.py bin/traits_report.py modules/local/html_report/* modules/local/indexcov/* modules/local/vcf_precheck/* modules/local/y_str/* scripts/16-indexcov.sh scripts/24-html-report.sh scripts/45-y-str.sh scripts/ci/fake-docker/lib.sh scripts/validate-setup.sh
 y-tree-current-1-placement	assets/live/index.html assets/viewer/index.html bin/og bin/yleaf_run.py scripts/16-indexcov.sh scripts/37-y-haplogroup.sh scripts/ci/fake-docker/lib.sh scripts/setup.sh
+rust-c2b-traits	assets/traits.tsv assets/genotype_rules.tsv bin/og modules/local/traits/* scripts/42-traits.sh
diff --git a/scripts/ci/e2e-case-times.tsv b/scripts/ci/e2e-case-times.tsv
index be90f627f..5fd3717ec 100644
--- a/scripts/ci/e2e-case-times.tsv
+++ b/scripts/ci/e2e-case-times.tsv
@@ -177,3 +177,4 @@ vntyper-1	shard	92	-
 y-private-report-1-private-and-tree	shard	150	nextflow-hardening-2-nf
 y-str-1	shard	42	-
 y-tree-current-1-placement	shard	21	nextflow-hardening-2-nf
+rust-c2b-traits	shard	2	-
diff --git a/tests/demo/make_demo_sample.py b/tests/demo/make_demo_sample.py
index 49bf9e2a5..ec57b5814 100755
--- a/tests/demo/make_demo_sample.py
+++ b/tests/demo/make_demo_sample.py
@@ -1282,13 +1282,21 @@ def traits(d):
     unknown = sorted(r["rsid"] for r in rows if r["rsid"] not in TRAIT_ALT_COPIES | {"rs4410790": 0, "rs4481887": 0})
     if unknown:
         raise SystemExit(f"assets/traits.tsv has rows TRAIT_ALT_COPIES does not give: {', '.join(unknown)}")
-    recs = {}
-    for r in rows:
-        if r["rsid"] in TRAIT_ALT_COPIES:
-            n = TRAIT_ALT_COPIES[r["rsid"]]
-            recs[(r["chrom"], r["pos"])] = [(r["ref"], [r["ref"]] * (2 - n) + [r["alt"]] * n, "60")]
     os.makedirs(os.path.join(d, "traits"), exist_ok=True)
-    traits_report.write_tsv(os.path.join(d, "traits", f"{SAMPLE}_traits.tsv"), traits_report.report(rows, recs))
+    with tempfile.TemporaryDirectory() as work:
+        genotypes = os.path.join(work, "g.tsv")
+        with open(genotypes, "w") as f:
+            for r in rows:
+                if r["rsid"] in TRAIT_ALT_COPIES:
+                    n = TRAIT_ALT_COPIES[r["rsid"]]
+                    gt = "/".join([r["ref"]] * (2 - n) + [r["alt"]] * n)
+                    f.write(f"{r['chrom']}\t{r['pos']}\t{r['ref']}\t{r['alt']}\t{gt}\t60\n")
+        subprocess.run([os.environ.get("OG", os.path.join(REPO, "bin", "og")), "traits", "table",
+                        "--table", os.path.join(REPO, "assets", "traits.tsv"),
+                        "--rules", os.path.join(REPO, "assets", "genotype_rules.tsv"),
+                        "--genotypes", genotypes, "--sample", SAMPLE,
+                        "--out", os.path.join(d, "traits", f"{SAMPLE}_traits.tsv"),
+                        "--rules-out", os.path.join(work, "rules.tsv")], check=True)
 
 
 def mocha(d):
diff --git a/tests/e2e/genotype-rules-2-g2.sh b/tests/e2e/genotype-rules-2-g2.sh
index 7216eb962..5932e63c3 100644
--- a/tests/e2e/genotype-rules-2-g2.sh
+++ b/tests/e2e/genotype-rules-2-g2.sh
@@ -40,16 +40,18 @@ mkdir -p "$D"
 for s in G2HET G2REF; do
   mkdir -p "${D}/${s}/vcf" "${D}/${s}/traits"
   python3 - "$REPO" "${D}/${s}" "$s" <<'PY'
-import os, sys
+import os, subprocess, sys
 repo, d, s = sys.argv[1:]
 sys.path.insert(0, os.path.join(repo, "bin"))
-import traits_report as tr
-rules = tr.read_rules(os.path.join(repo, "assets", "genotype_rules.tsv"))
 g = os.path.join(d, "g.tsv")
 with open(g, "w") as f:   # G0/G1 at the two G1 sites
     f.write("chr22\t36265860\tA\tG\tA/G\t40\nchr22\t36265988\tT\tG\tT/G\t40\n")
-tr.write_tsv(os.path.join(d, "traits", f"{s}_genotype_rules.tsv"), tr.rule_lines(rules, tr.read_genotypes(g)),
-             tr.RULE_OUT_COLUMNS)
+subprocess.run([os.environ.get("OG", os.path.join(repo, "bin", "og")), "traits", "table",
+                "--table", os.path.join(repo, "assets", "traits.tsv"),
+                "--rules", os.path.join(repo, "assets", "genotype_rules.tsv"),
+                "--genotypes", g, "--sample", s,
+                "--out", os.path.join(d, "traits", f"{s}_traits.tsv"),
+                "--rules-out", os.path.join(d, "traits", f"{s}_genotype_rules.tsv")], check=True)
 os.remove(g)
 body = ["chr22\t36200000\t.\tA\t<*>\t0\t.\tEND=36265994\tGT:GQ\t0/0:50"]
 if s == "G2HET":
@@ -72,7 +74,7 @@ done
 
 read_result() {
   python3 - "$REPO" "${D}/$1" "$1" <<'PY'
-import os, sys
+import os, subprocess, sys
 repo, d, s = sys.argv[1:]
 sys.path.insert(0, os.path.join(repo, "bin"))
 import collect_summary as cs
diff --git a/tests/e2e/report-followups-1-sections.sh b/tests/e2e/report-followups-1-sections.sh
index 4cfcf7451..b89ec541b 100644
--- a/tests/e2e/report-followups-1-sections.sh
+++ b/tests/e2e/report-followups-1-sections.sh
@@ -41,7 +41,6 @@ python3 - "$REPO" "$G" "$T" <<'PY'
 import json, os, shutil, subprocess, sys
 repo, g, s = sys.argv[1:4]
 sys.path.insert(0, os.path.join(repo, "bin"))
-import traits_report  # noqa: E402
 
 
 def put(path, text):
@@ -56,14 +55,15 @@ for kind in ("full", "bare"):
     # Step 42: TAS2R38 homozygous for PAV (G, G, C on the plus strand).
     geno = os.path.join(g, kind, "genotypes.tsv")
     put(geno, "chr7\t141972804\tT\tC\tC/C\t40\nchr7\t141972905\tG\t.\tG/G\t40\nchr7\t141973545\tC\tG\tG/G\t40\n")
-    rows = traits_report.read_table(os.path.join(repo, "assets", "traits.tsv"))
-    rules = traits_report.read_rules(os.path.join(repo, "assets", "genotype_rules.tsv"))
-    recs = traits_report.read_genotypes(geno)
-    lines = traits_report.rule_lines(rules, recs)
     os.makedirs(f"{d}/traits", exist_ok=True)
-    traits_report.write_tsv(f"{d}/traits/{s}_traits.tsv", traits_report.report(rows, recs, rules, None, lines))
-    if kind == "full":
-        traits_report.write_tsv(f"{d}/traits/{s}_genotype_rules.tsv", lines, traits_report.RULE_OUT_COLUMNS)
+    subprocess.run([os.environ.get("OG", os.path.join(repo, "bin", "og")), "traits", "table",
+                    "--table", os.path.join(repo, "assets", "traits.tsv"),
+                    "--rules", os.path.join(repo, "assets", "genotype_rules.tsv"),
+                    "--genotypes", geno, "--sample", s,
+                    "--out", f"{d}/traits/{s}_traits.tsv",
+                    "--rules-out", f"{d}/traits/{s}_genotype_rules.tsv"], check=True)
+    if kind == "bare":
+        os.remove(f"{d}/traits/{s}_genotype_rules.tsv")
     # Step 05: two class 4 deletions; the rule table puts the second over half inside an IG locus.
     head = ("AnnotSV_ID\tSV_chrom\tSV_start\tSV_end\tSV_length\tSV_type\tID\tINFO\tAnnotation_mode\tGene_name\t"
             "B_loss_source\tB_loss_AFmax\tACMG_class\tAnnotSV_ranking_score\n")
diff --git a/tests/e2e/rust-c2b-traits.sh b/tests/e2e/rust-c2b-traits.sh
new file mode 100755
index 000000000..71613e72f
--- /dev/null
+++ b/tests/e2e/rust-c2b-traits.sh
@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+# Traits, APOE ordering, phase sites and refusal controls on synthetic input.
+. "$(dirname "$0")/lib.sh"
+OG=${OG:-${REPO}/bin/og}
+TABLE="${REPO}/assets/traits.tsv"
+RULES="${REPO}/assets/genotype_rules.tsv"
+G="${CASE_TMP}/g.tsv"
+printf 'chr19\t44908684\tT\tC\tT/C\t40\nchr19\t44908822\tC\tT\tC/T\t40\nchr7\t141973545\tC\tG\tC/G\t30\nchr7\t141972905\tG\tA\tG/A\t31\nchr7\t141972804\tT\tC\tT/C\t32\n' > "$G"
+"$OG" traits table --table "$TABLE" --rules "$RULES" --genotypes "$G" --sample S \
+  --out "${CASE_TMP}/traits.tsv" --rules-out "${CASE_TMP}/rules.tsv"
+check_eq 'traits table exits 0' "$?" 0
+check_eq 'APOE double heterozygote is e2/e4' "$(awk -F'\t' '$1 == "APOE" {print $10}' "${CASE_TMP}/rules.tsv")" e2/e4
+check_eq 'the taster rule needs phase' "$(awk -F'\t' '$1 == "TAS2R38" {print $11}' "${CASE_TMP}/rules.tsv")" unphased
+check_eq 'APOE line occurs exactly once' "$(grep -c '^rs429358+rs7412' "${CASE_TMP}/traits.tsv")" 1
+check 'absent LCT has no inferred genotype' awk -F'\t' '$1 == "rs4988235" {ok = ($6 == "." && $7 == "not_covered")} END {exit !ok}' "${CASE_TMP}/traits.tsv"
+"$OG" traits phase-sites --rules "$RULES" --genotypes "$G" --sample S --out "${CASE_TMP}/phase.vcf"
+check_eq 'phase-sites exits 0' "$?" 0
+check_eq 'only the three taster sites need phase' "$(grep -cv '^#' "${CASE_TMP}/phase.vcf")" 3
+check_eq 'phase sites are in genome order' "$(grep -v '^#' "${CASE_TMP}/phase.vcf" | cut -f2 | paste -sd, -)" 141972804,141972905,141973545
+sed 's/44908684\tT\t/44908684\tG\t/' "$G" > "${CASE_TMP}/bad.tsv"
+"$OG" traits table --table "$TABLE" --rules "$RULES" --genotypes "${CASE_TMP}/bad.tsv" --sample S \
+  --out "${CASE_TMP}/bad-out.tsv" --rules-out "${CASE_TMP}/bad-rules.tsv" > "${CASE_TMP}/bad.log" 2>&1
+check_eq 'control: wrong reference is refused' "$?" 1
+check 'control: refusal names the site and GRCh38' has 'rs429358.*GRCh38' "$(cat "${CASE_TMP}/bad.log")"
+check 'control: no table is written' test ! -e "${CASE_TMP}/bad-out.tsv"
+"$OG" traits check --table "$TABLE" --rules "$RULES"
+check_eq 'committed catalogs pass' "$?" 0
+finish
diff --git a/tests/parity/README.md b/tests/parity/README.md
index d83ff2087..3d32b9972 100644
--- a/tests/parity/README.md
+++ b/tests/parity/README.md
@@ -42,3 +42,8 @@ A `known.tsv` row whose difference is gone fails. A golden that the oracle also
 3. Run `scripts/ci/oracle-diff.sh`. Turn each difference into a fix, a golden or a `known.tsv` row.
 4. Switch the callers to `og`, delete the Python, and add the tool to `OG_SHADOW` in `.github/workflows/e2e.yml`.
 5. Link a red run in the pull request: the cases with one planted change in the port must fail.
+
+The `traits` cases cover all APOE genotype pairs, missing and other alleles,
+duplicate records, TAS2R38 phase blocks, phase-site VCFs and catalog refusals.
+The oracle adapter maps the three Rust verbs to the old flags. The Python
+report keeps only the metadata and table reader listed in `remnants.tsv`.
diff --git a/tests/parity/gen/traits.sh b/tests/parity/gen/traits.sh
index 10d0fa26f..a57771388 100644
--- a/tests/parity/gen/traits.sh
+++ b/tests/parity/gen/traits.sh
@@ -33,10 +33,10 @@ printf 'chr19\t44908684\tT\tC\tT/C\t30\n' > missing.tsv
 printf 'chr19\t44908684\tTT\tT\tTT/T\t10\nchr19\t44908684\tT\tC\tC/T\t40\n' > duplicate.tsv
 printf 'chr19\t44908684\tG\tC\tG/C\t30\n' > wrong-ref.tsv
 printf 'chr19\t44908684\tT\tC\t./C\t30\n' > half.tsv
-printf 'chr7\t141973545\tC\tG\tC/G\t30\nchr7\t141972905\tG\tC\tG/C\t31\nchr7\t141972804\tT\tC\tT/C\t32\n' > triple.tsv
+printf 'chr7\t141973545\tC\tG\tC/G\t30\nchr7\t141972905\tG\tA\tG/A\t31\nchr7\t141972804\tT\tC\tT/C\t32\n' > triple.tsv
 head -1 triple.tsv > single.tsv
 : > empty.vcf
-printf 'chr7\t141973545\t.\tC\tG\t.\tPASS\t.\tGT:PS\t1|0:7\nchr7\t141972905\t.\tG\tC\t.\tPASS\t.\tGT:PS\t0|1:7\nchr7\t141972804\t.\tT\tC\t.\tPASS\t.\tGT:PS\t1|0:7\n' > phased.vcf
+printf 'chr7\t141973545\t.\tC\tG\t.\tPASS\t.\tGT:PS\t1|0:7\nchr7\t141972905\t.\tG\tA\t.\tPASS\t.\tGT:PS\t0|1:7\nchr7\t141972804\t.\tT\tC\t.\tPASS\t.\tGT:PS\t1|0:7\n' > phased.vcf
 sed '1s/:7$/:8/' phased.vcf > split.vcf
 awk -F'\t' -v OFS='\t' '$1 == "combination" && $2 == "APOE" && $3 == "e3/e3" {next} {print}' rules.tsv > bad-rules.tsv
 awk -F'\t' -v OFS='\t' '$3 == "rs671" {$6=$5} {print}' traits.tsv > bad-table.tsv
diff --git a/tests/parity/oracle.ref b/tests/parity/oracle.ref
index 526797497..7d9e929b1 100644
--- a/tests/parity/oracle.ref
+++ b/tests/parity/oracle.ref
@@ -63,4 +63,4 @@ y-yleaf-positions	0baddb45aa3871a57469cf20295bdd832f72f5c0	file:bin/yleaf_run.py
 lookup	0baddb45aa3871a57469cf20295bdd832f72f5c0	file:bin/genome_lookup.py	python3	lookup
 lookup-query	0baddb45aa3871a57469cf20295bdd832f72f5c0	file:bin/genome_lookup.py	bash ./oracle.sh	lookup query
 family-ibd	0baddb45aa3871a57469cf20295bdd832f72f5c0	file:bin/ibd_report.py	sh ./ibd_oracle.sh	family ibd
-traits	669a8196	file:bin/traits_report.py	bash ./oracle.sh	traits
+traits	669a8196cf4c377200f9b4af9c235ef85fb774a1	file:bin/traits_report.py	bash ./oracle.sh	traits
diff --git a/tests/parity/remnants.tsv b/tests/parity/remnants.tsv
index 479efa8b8..084de768c 100644
--- a/tests/parity/remnants.tsv
+++ b/tests/parity/remnants.tsv
@@ -9,3 +9,4 @@ bin/pgx_outside_calls.py	HLA_GENES,NO_CALL,PROBABLE,NOT_CALLABLE,LOW_GQ,is_call,
 bin/paraphase_report.py	SMN1_EXON7,parascopy_smn1,compare_smn1	bin/collect_summary.py,bin/couple_report.py,tests/test_paralog_loci.py,tests/test_paraphase_report.py	R4
 bin/cnvpytor_to_vcf.py	DEPTH_MIN_SIZE,delly_depth_contradicts	bin/couple_report.py	R4
 bin/annotsv_postfilter.py	CONSENSUS_BP,KEEP,ADDED,open_text,chrom_key,sv_type,info_value,sample_format,sample_columns,read_consensus,consensus_support	bin/collect_summary.py,tests/demo/make_demo_sample.py	R3
+bin/traits_report.py	COLUMNS,OUT_COLUMNS,RULE_OUT_COLUMNS,TRAITS_TABLE_RULES,TableError,read_table,MARKERS,MARKER_STATUSES	bin/collect_summary.py,tests/demo/make_demo_sample.py,tests/test_traits_report.py,tests/test_traits_table.py,tests/test_collect_summary.py,tests/test_lpa_kiv2.py,tests/test_render_report.py	R3
diff --git a/tests/test_collect_summary.py b/tests/test_collect_summary.py
index 62d7d1b93..ee2580d72 100644
--- a/tests/test_collect_summary.py
+++ b/tests/test_collect_summary.py
@@ -1206,19 +1206,18 @@ def report_followups_sections(work, schema):
     # (G, G, C on the plus strand; rs1726866's G is the reference base).
     t = os.path.join(work, "rules", "S")
     rows = traits_report.read_table(os.path.join(REPO, "assets", "traits.tsv"))
-    rules = traits_report.read_rules(os.path.join(REPO, "assets", "genotype_rules.tsv"))
     g = os.path.join(work, "rules_g.tsv")
     put(g, "chr7\t141972804\tT\tC\tC/C\t40\nchr7\t141972905\tG\t.\tG/G\t40\nchr7\t141973545\tC\tG\tG/G\t40\n"
            "chr19\t44908684\tT\t.\tT/T\t40\nchr19\t44908822\tC\t.\tC/C\t40\n")
-    recs = traits_report.read_genotypes(g)
-    lines = traits_report.rule_lines(rules, recs)
+    from test_traits_report import traits_tables
     os.makedirs(f"{t}/traits", exist_ok=True)
-    traits_report.write_tsv(f"{t}/traits/S_traits.tsv", traits_report.report(rows, recs, rules, None, lines))
+    saved_rules = os.path.join(work, "rules_saved.tsv")
+    traits_tables(g, f"{t}/traits/S_traits.tsv", saved_rules)
     summ, txt, html_ = render(t)
     check("rules: without the rules table the section has no rule lines and the reports none",
           summ["sections"]["traits"]["data"].get("rules") is None and "Genotype rules (several sites" not in txt + html_,
           summ["sections"]["traits"]["data"].get("rules"))
-    traits_report.write_tsv(f"{t}/traits/S_genotype_rules.tsv", lines, traits_report.RULE_OUT_COLUMNS)
+    shutil.copyfile(saved_rules, f"{t}/traits/S_genotype_rules.tsv")
     summ, txt, html_ = render(t)
     html_ = htmlmod.unescape(html_)
     rl = summ["sections"]["traits"]["data"].get("rules") or []
@@ -1226,7 +1225,9 @@ def report_followups_sections(work, schema):
           [(r["rule"], r["result"], r["status"], r["phase"]) for r in rl if r["rule"] in ("TAS2R38", "APOE")]
           == [("TAS2R38", "PAV/PAV", "called", "not_needed")],
           rl)
-    trait = rules["TAS2R38"]["trait"]
+    import csv
+    with open(saved_rules) as f:
+        trait = next(r["trait"] for r in csv.DictReader(f, delimiter="\t") if r["rule"] == "TAS2R38")
     check("rules: the text report prints the rule line with its result and sites",
           f"{trait} (TAS2R38 rs713598, rs1726866, rs10246939): PAV/PAV (no phase needed). " in txt
           and "traits/S_genotype_rules.tsv" in txt, txt)
@@ -2861,7 +2862,8 @@ def strec(rep, cn, so, ci, adsp, st, nmax="20", pmin="40"):
                f"{ear['chrom']}\t{ear['pos']}\t{ear['ref']}\t.\t{ear['ref']}/{ear['ref']}\n"
                "chr19\t44908684\tT\t.\tT/T\nchr19\t44908822\tC\t.\tC/C\n")
         os.makedirs(f"{t}/traits", exist_ok=True)
-        traits_report.write_tsv(f"{t}/traits/S_traits.tsv", traits_report.report(rows, traits_report.read_genotypes(g)))
+        from test_traits_report import traits_tables
+        traits_tables(g, f"{t}/traits/S_traits.tsv", os.path.join(work, "traits_rules.tsv"))
         summ_t, txt_t, html_t = render(t)
         td = summ_t["sections"]["traits"]
         check("traits: section ok, counts without the APOE rows",
diff --git a/tests/test_copy_number.py b/tests/test_copy_number.py
index b00a00302..03a4bf349 100644
--- a/tests/test_copy_number.py
+++ b/tests/test_copy_number.py
@@ -86,7 +86,30 @@
 CATALOG = os.path.join(REPO, "bin", "cn_loci.tsv")
 MODELS = os.path.join(REPO, "assets", "parascopy_models_v1.7.txt")
 sys.path.insert(0, os.path.join(REPO, "bin"))
-import copy_number as cn  # noqa: E402
+# The old engine is a test oracle pinned to the traits port's parent. It is
+# materialised only for these historical differential assertions. No pipeline
+# step imports or ships a second engine.
+import importlib.util  # noqa: E402
+
+
+def catalog_oracle():
+    ref = "669a8196cf4c377200f9b4af9c235ef85fb774a1"
+    if subprocess.run(["git", "-C", REPO, "cat-file", "-e", ref + "^{commit}"],
+                      stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL).returncode:
+        subprocess.run(["git", "-C", REPO, "fetch", "--depth=1", "origin", ref], check=True)
+    source = subprocess.check_output(["git", "-C", REPO, "show", ref + ":bin/copy_number.py"])
+    with tempfile.TemporaryDirectory(prefix="cn-oracle-") as work:
+        path = os.path.join(work, "copy_number.py")
+        with open(path, "wb") as f:
+            f.write(source)
+        spec = importlib.util.spec_from_file_location("cn_catalog_oracle", path)
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+    module.CATALOG = os.path.join(REPO, "bin", "cn_loci.tsv")
+    return module
+
+
+cn = catalog_oracle()
 
 FAILS = 0
 # Frozen from bin/hba_copy_number.py and bin/lpa_kiv2.py as they were before the
diff --git a/tests/test_genotype_rules_indels.py b/tests/test_genotype_rules_indels.py
index 777aaf4b9..35fccfd72 100644
--- a/tests/test_genotype_rules_indels.py
+++ b/tests/test_genotype_rules_indels.py
@@ -155,8 +155,7 @@ def bgzip_with_tbi(path, lines):
 def report_checks():
     import collect_summary as cs
     import render_report as rr
-    import traits_report as tr
-    rules = tr.read_rules(os.path.join(REPO, "assets", "genotype_rules.tsv"))
+    from test_traits_report import traits_tables
     head = "##fileformat=VCFv4.2\n##contig=<ID=chr22>\n#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tS\n"
     g1 = [("chr22", "36265860", "A", "G", "A/G", "40"), ("chr22", "36265988", "T", "G", "T/G", "40")]
     work = tempfile.mkdtemp()
@@ -169,7 +168,7 @@ def folder(name, gvcf_lines, kind):
             g = os.path.join(work, name + "_g.tsv")
             with open(g, "w") as f:
                 f.writelines("\t".join(x) + "\n" for x in g1)
-            tr.write_tsv(p, tr.rule_lines(rules, tr.read_genotypes(g)), tr.RULE_OUT_COLUMNS)
+            traits_tables(g, os.path.join(d, "traits", "S_traits.tsv"), p)
             v = os.path.join(d, "vcf", "S.g.vcf.gz" if kind == "gvcf" else "S.vcf.gz")
             with gzip.open(v, "wt") as f:
                 f.write(head + "".join("\t".join(r) + "\n" for r in gvcf_lines))
diff --git a/tests/test_hba_copy_number.py b/tests/test_hba_copy_number.py
index a31afb5cd..4dc92a38c 100755
--- a/tests/test_hba_copy_number.py
+++ b/tests/test_hba_copy_number.py
@@ -35,7 +35,7 @@
 CATALOG = os.path.join(REPO, "bin", "cn_loci.tsv")
 OG = os.environ.get("OG", "")
 sys.path.insert(0, os.path.join(REPO, "bin"))
-import copy_number as cn  # noqa: E402
+from test_copy_number import cn  # noqa: E402  pinned differential oracle
 
 REGIONS = cn.regions(cn.load_catalog(CATALOG)["HBA"])
 # Step 35's HBA table, in its order (what bin/hba_copy_number.py wrote).
diff --git a/tests/test_lpa_kiv2.py b/tests/test_lpa_kiv2.py
index c1aeccf10..03ab6f15f 100644
--- a/tests/test_lpa_kiv2.py
+++ b/tests/test_lpa_kiv2.py
@@ -72,7 +72,7 @@
     shutil.copy2(os.path.join(REPO, "bin", "cn_loci.tsv"), os.path.join(_og_dir, "cn_loci.tsv"))
     OG = os.environ["OG"] = os.path.join(_og_dir, "og")
 sys.path.insert(0, os.path.join(REPO, "bin"))
-import copy_number as cn  # noqa: E402
+from test_copy_number import cn  # noqa: E402  pinned differential oracle
 
 FAILS = 0
 # The two LPA rows; named once here so no line of this file reads as an rsID with a genotype.
diff --git a/tests/test_render_report.py b/tests/test_render_report.py
index c5406109a..a8377a4d6 100644
--- a/tests/test_render_report.py
+++ b/tests/test_render_report.py
@@ -958,7 +958,10 @@ def mosaic_table(rows):
         d = f"{work}/traits/S"
         rows = traits_report.read_table(os.path.join(REPO, "assets", "traits.tsv"))
         put(f"{d}/traits/S_traits.tsv", "")
-        traits_report.write_tsv(f"{d}/traits/S_traits.tsv", traits_report.report(rows, {}))
+        from test_traits_report import traits_tables
+        g = os.path.join(work, "traits_empty.tsv")
+        put(g, "")
+        traits_tables(g, f"{d}/traits/S_traits.tsv", os.path.join(work, "traits_rules.tsv"))
         summ = collect_summary.collect("S", d)
         txt, html = render_report.text_report(summ), render_report.html_report(summ)
         check("traits: both reports say a reading is not a diagnosis",
diff --git a/tests/test_traits_report.py b/tests/test_traits_report.py
index cd9b75470..a10e13f47 100644
--- a/tests/test_traits_report.py
+++ b/tests/test_traits_report.py
@@ -1,92 +1,26 @@
 #!/usr/bin/env python3
-"""bin/traits_report.py (step 42) on synthetic bcftools output, on assets/traits.tsv and on
-assets/genotype_rules.tsv; and scripts/ci/check-rule-alleles.sh on the rules.
+"""Step 42 CLI goldens, rule-allele controls and og cn marker outputs.
 
-Checks:
-  1. a reference block expanded at a position (ALT '.', genotype G/G) reads as
-     ref/ref with the table's hom_ref text; ref/alt and alt/alt read het and
-     hom_alt, phased (C|T) as unphased, the reference allele printed first;
-  2. a planted alternate allele changes the reading: the same position read
-     as ref/ref and then as ref/alt gives two different readings, each the
-     table's own;
-  3. a position with no line is not_covered (never read as the reference); an
-     allele the table does not describe and a deletion starting at the
-     position are other_allele, not read; a half call that reaches the script
-     (the bcftools genotype filter of step 42 drops it first, so in a run its
-     position is not_covered) is other_allele too;
-  4. a gVCF REF that is not the table's reference base stops the run (exit 1,
-     the row named), so a gVCF on another build is not read;
-  5. the APOE line, now read from the APOE rule: for every pair of rs429358 and
-     rs7412 genotypes, one site not covered and an allele the rule does not
-     describe, the line is byte for byte the line the hand code of main
-     (6056452) wrote, by its sha256; it comes right after the second APOE row,
-     once; control: one changed character in a reading changes the hash;
-     report() without rules reads the repository's rules table;
-  6. the rules table passes the schema check, and planted problems are each
-     caught: a missing and an extra combination line, a haplotype allele that
-     is neither ref nor alt, diplotypes out of haplotype order, a site that
-     disagrees with its traits table row, no APOE rule, a line of an unknown
-     kind;
-  7. the rules on synthetic gVCF records, for each rule: reference blocks only
-     (homozygous reference, with the block's GQ; TAS2R38's reference haplotype
-     is AAI, which the rule does not read); APOE's double heterozygote
-     (e2/e4, maybe e1/e3) without phase; TAS2R38 homozygous PAV/PAV and a
-     single heterozygous site, which need no phase; the triple heterozygote
-     unphased (WhatsHap ran and no read pair spans the sites, or no phasing
-     ran), phased in one block (PAV/AVI, read-backed), phased in two blocks
-     (unphased), phased into a haplotype the rule does not describe; a site
-     not covered;
-  8. --phase-sites writes only the heterozygous sites of a rule that needs
-     phase and has two or more of them, as a sorted VCF; WhatsHap's phased VCF
-     is read back (GT with |, PS), its unphased records left out;
-  9. the command line writes the traits table (one row per table row plus the
-     APOE line, the columns in order) and the rules table (one line per rule),
-     and exits 1 on a traits table or a rules table that fails the schema check;
- 10. scripts/ci/check-rule-alleles.sh passes on the rules and fails, naming the
-     site and the mistake, on planted copies: ref and alt swapped, the
-     minus-strand bases, an rsID the dbSNP table lacks, a wrong position; and
-     on a rules file with no site, and on a dbSNP table of another build than
-     versions.env pins;
- 11. the copy-aware markers (MARKERS: LPA KIV-2 4925G>A, SMN1 g.27134T>G):
-     each pinned dbSNP record is one of the marker's copies with its ref and
-     alt, and a planted swap, a minus-strand pair and a position off the
-     copies are each caught; the context's middle base is the ref. With OG
-     naming the og binary (skipped without it, a failure with OG_REQUIRED
-     set too): og cn marker-regions prints one region per copy of MARKERS;
-     og cn marker-read SMN1_27134 on mpileup lines made up
-     for each case at the SMN1 and SMN2 copies: a quarter of the reads with G
-     is 'present' (copies = fraction x agCN), T only (the reference) 'not
-     seen', 2 reads with G 'uncertain', under 10 reads 'too little depth', an
-     unreadable pileup 'not assessed' (exit 0); the SMN1 psCN and the agCN
-     come from step 35's table (homologous region included, quality under 20
-     not resolved); every message, for every status and every psCN, says the
-     marker does not prove 2+0 (control: a message without the sentence fails
-     the same test).
-
-Run: python3 tests/test_traits_report.py
+Internal validation, phase and bounded-reader assertions live in
+og-steps::traits::tests. The parity harness checks the old Python at oracle.ref.
 """
+import csv
 import hashlib
 import os
 import shutil
 import subprocess
 import sys
 import tempfile
-
 REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 sys.path.insert(0, os.path.join(REPO, "bin"))
 import traits_report as tr  # noqa: E402
-
 TABLE = os.path.join(REPO, "assets", "traits.tsv")
 RULES = os.path.join(REPO, "assets", "genotype_rules.tsv")
-SCRIPT = os.path.join(REPO, "bin", "traits_report.py")
 CHECK = os.path.join(REPO, "scripts", "ci", "check-rule-alleles.sh")
 OG = os.environ.get("OG", "")
-# The sentence every SMN1 marker message ends with.
+SMN_HEADER = "chrom\tstart\tend\tlocus\tagCN_filter\tagCN\tagCN_qual\tpsCN_filter\tpsCN\tpsCN_qual\thomologous_regions\n"
 SMN1_NOT_PROOF = "This marker does not prove 2+0, and its absence does not rule 2+0 out."
 FAILS = 0
-
-# The sha256 of the APOE line (its OUT_COLUMNS joined by tabs) the hand code of
-# main 6056452 wrote, per rs429358 and rs7412 genotype ("." = no line).
 APOE_GOLDEN = {
     ("T/T", "C/C"): "e3d7512b649f1d23f5acbcaa08da19bd6a009d5b39ac57cb6856591c50e7cfda",
     ("T/T", "C/T"): "62e910d8ec7ac45ab15e9c9ed85c93b128ac41703d1149a332082dc0d7b5f389",
@@ -100,10 +34,6 @@
     ("T/C", "."): "34624db16a92981c0882edb3d8ce8d291162aa78b7c5208eba2360141e6ccbd8",
     ("T/G", "C/C"): "1d0aee0b8d241561ebd7477d6f4a8be274a48157a297abecd444c6c6a0a6abac",
 }
-# TAS2R38's three sites in the rule's order (codons 49, 262, 296).
-T1, T2, T3 = ("chr7", "141973545"), ("chr7", "141972905"), ("chr7", "141972804")
-
-
 def check(desc, ok, detail=""):
     global FAILS
     print(f"[{'PASS' if ok else 'FAIL'}] {desc}{'' if ok else ' -- ' + str(detail)[:600]}")
@@ -116,46 +46,6 @@ def write(path, text):
         f.write(text)
 
 
-def recs(*lines):
-    """bcftools' CHROM POS REF ALT GENOTYPE [GQ] lines -> read_genotypes' records."""
-    d = tempfile.mkdtemp()
-    try:
-        p = os.path.join(d, "g.tsv")
-        write(p, "".join("\t".join(map(str, l)) + "\n" for l in lines))
-        return tr.read_genotypes(p)
-    finally:
-        shutil.rmtree(d)
-
-
-def phased_vcf(*records):
-    """WhatsHap-style VCF records (chrom, pos, ref, alt, GT[:PS], GT as allele indexes) -> read_phased's dict."""
-    d = tempfile.mkdtemp()
-    try:
-        p = os.path.join(d, "p.vcf")
-        body = "".join(f"{c}\t{pos}\t.\t{ref}\t{alt}\t.\tPASS\t.\t{'GT:PS' if ':' in g else 'GT'}\t{g}\n"
-                       for c, pos, ref, alt, g in records)
-        write(p, "##fileformat=VCFv4.2\n#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tS\n" + body)
-        return tr.read_phased(p)
-    finally:
-        shutil.rmtree(d)
-
-
-def apoe_line(out):
-    return next(o for o in out if o["rsid"] == "rs429358+rs7412")
-
-
-def line_hash(o):
-    return hashlib.sha256("\t".join(str(o[c]) for c in tr.OUT_COLUMNS).encode()).hexdigest()
-
-
-def run(*args):
-    return subprocess.run([sys.executable, SCRIPT, *args], capture_output=True, text=True)
-
-
-def og_cn(*args):
-    return subprocess.run([OG, "cn", *args], capture_output=True, text=True)
-
-
 def dbsnp_checks(rules):
     """10. scripts/ci/check-rule-alleles.sh on the rules and on planted copies. Runs first,
     so a rules table that breaks the other checks still shows what dbSNP says."""
@@ -206,9 +96,6 @@ def planted(desc, new, want):
         shutil.rmtree(work)
 
 
-# 11. The multi-SNP rules (APOL1, SERPINA1, HFE, GC, CAD9p21, MAPT): per rule, the
-# genotypes (ALT allele per site, "." for a reference block) of one positive case and
-# its label, and of one negative case, a copy of the positive with one allele flipped.
 MULTI_SNP = {
     "APOL1": [(("G/G", "G/G"), "G1/G1"), (("A/G", "T/G"), "G0/G1")],
     "SERPINA1": [(("T/T", "T/T"), "PiZZ"), (("T/A", "C/T"), "PiSZ"), (("A/A", "C/C"), "PiSS")],
@@ -222,64 +109,6 @@ def planted(desc, new, want):
                  "CAD9p21": "no risk copy", "MAPT": "H1/H1"}
 
 
-def multi_snp_checks(rules):
-    """11. Each multi-SNP rule on synthetic records: every positive genotype gives its label,
-    reference blocks alone give the reference label, and the control: the first positive
-    case with one allele flipped at one site gives another result. Then the lines reach the
-    HTML report: collect_summary reads them from the rules table and render_report writes
-    one row per rule."""
-    import collect_summary as cs
-    import render_report as rr
-
-    def line(rid, gts):
-        sites = rules[rid]["sites"]
-        rows = []
-        for s, gt in zip(sites, gts):
-            a = [x for x in gt.split("/") if x != s["ref"]]
-            rows.append((s["chrom"], s["pos"], s["ref"], a[0] if a else ".", gt, "40"))
-        return next(x for x in tr.rule_lines(rules, recs(*rows)) if x["rule"] == rid)
-
-    check("11. every multi-SNP rule is in the rules table", set(MULTI_SNP) <= set(rules), sorted(rules))
-    for rid, cases in MULTI_SNP.items():
-        if rid not in rules:
-            continue
-        sites = rules[rid]["sites"]
-        for gts, want in cases:
-            ln = line(rid, gts)
-            check(f"{rid} {','.join(gts)}: {want}", (ln["status"], ln["result"]) == ("called", want), ln)
-        ref = tuple(f"{s['ref']}/{s['ref']}" for s in sites)
-        ln = line(rid, ref)
-        check(f"{rid}, reference blocks only: {MULTI_SNP_REF[rid]}",
-              (ln["status"], ln["result"]) == ("called", MULTI_SNP_REF[rid]), ln)
-        gts, want = cases[0]
-        a, b = gts[0].split("/")
-        s0 = sites[0]
-        flip = s0["ref"] if b == s0["alt"] else s0["alt"]
-        flipped = (f"{a}/{flip}",) + tuple(gts[1:])
-        ln = line(rid, flipped)
-        check(f"control: {rid} with one allele flipped at {s0['rsid']} ({','.join(flipped)}) is not {want}",
-              ln["result"] != want, ln)
-    apol1 = line("APOL1", ("A/G", "T/G"))["reading"]
-    check("APOL1 G0/G1 says G2 is not read and the other copy could carry it",
-          "G2 is not read" in apol1 and "G1/G2" in apol1, apol1)
-    work = tempfile.mkdtemp()
-    try:
-        os.makedirs(os.path.join(work, "traits"))
-        lines = [line(rid, cases[0][0]) for rid, cases in MULTI_SNP.items() if rid in rules]
-        tr.write_tsv(os.path.join(work, "traits", "S_genotype_rules.tsv"), lines, tr.RULE_OUT_COLUMNS)
-        read = cs.genotype_rules(work, "S") or []
-        page = "\n".join(rr.rules_html({"rules": read}, "S"))
-        for rid, cases in MULTI_SNP.items():
-            if rid in rules:
-                check(f"HTML report: the {rid} rule row with its result {cases[0][1]}",
-                      rr.E(rules[rid]["trait"]) in page and rr.E(cases[0][1]) in page, page[:300])
-    finally:
-        shutil.rmtree(work)
-
-
-SMN_HEADER = "chrom\tstart\tend\tlocus\tagCN_filter\tagCN\tagCN_qual\tpsCN_filter\tpsCN\tpsCN_qual\thomologous_regions\n"
-
-
 def says_not_proof(message):
     """The SMN1 marker's message must say the marker does not prove 2+0."""
     return "does not prove 2+0" in message
@@ -287,22 +116,6 @@ def says_not_proof(message):
 
 def marker_checks():
     """11. The copy-aware markers."""
-    for name, m in tr.MARKERS.items():
-        check(f"marker {name}: the pinned dbSNP record agrees with the marker", tr.marker_errors(name) == [],
-              tr.marker_errors(name))
-        rs, chrom, pos, ref, alt = m["dbsnp"]
-        comp = {"A": "T", "C": "G", "G": "C", "T": "A"}
-        e = tr.marker_errors(name, dict(m, ref=alt, alt=ref))
-        check(f"marker {name} control: ref and alt swapped is caught", any("swapped" in x for x in e), e)
-        e = tr.marker_errors(name, dict(m, ref=comp[ref], alt=comp[alt],
-                                        context=m["context"][:10] + comp[ref] + m["context"][11:]))
-        check(f"marker {name} control: the minus-strand bases are caught", any("minus-strand" in x for x in e), e)
-        e = tr.marker_errors(name, dbsnp=(rs, chrom, pos + 1, ref, alt))
-        check(f"marker {name} control: a dbSNP position off the copies is caught",
-              any("not at one of the marker's copies" in x for x in e), e)
-        e = tr.marker_errors(name, dict(m, context=m["context"][:10] + alt + m["context"][11:]))
-        check(f"marker {name} control: a context whose middle base is not the ref is caught",
-              any("middle base" in x for x in e), e)
     check("LPA_KIV2_4925: seven copies (six KIV-2 units and KIV-1)", len(tr.MARKERS["LPA_KIV2_4925"]["copies"]) == 7)
     if not OG:
         print("skip: OG is not set (OG=rust/target/release/og): og cn marker-regions and marker-read did not run")
@@ -395,235 +208,73 @@ def table(p, smn_path):
         shutil.rmtree(work)
 
 
-def main():
-    rules = tr.read_rules(RULES)
-    dbsnp_checks(rules)
-    rows = tr.read_table(TABLE)
-    by_id = {r["rsid"]: r for r in rows}
-    lct = by_id["rs4988235"]   # chr2:135851076 G>A
-    c, p, ref, alt = lct["chrom"], lct["pos"], lct["ref"], lct["alt"]
-    at = lambda *ls: recs(*ls).get((c, p), [])  # noqa: E731
 
-    # 1. genotypes and their readings
-    g = tr.call(lct, at((c, p, ref, ".", f"{ref}/{ref}")))
-    check("expanded reference block: ref/ref, hom_ref reading", g == (f"{ref}/{ref}", "called", lct["hom_ref"]), g)
-    g = tr.call(lct, at((c, p, ref, alt, f"{alt}/{ref}")))
-    check("ref/alt: het reading, reference allele first", g == (f"{ref}/{alt}", "called", lct["het"]), g)
-    g = tr.call(lct, at((c, p, ref, alt, f"{ref}|{alt}")))
-    check("phased ref|alt reads as ref/alt", g == (f"{ref}/{alt}", "called", lct["het"]), g)
-    g = tr.call(lct, at((c, p, ref, alt, f"{alt}/{alt}")))
-    check("alt/alt: hom_alt reading", g == (f"{alt}/{alt}", "called", lct["hom_alt"]), g)
+def traits_tables(genotypes, out, rules_out, sample="S"):
+    """Use og in the Rust job. Unit shards without og use the pinned oracle."""
+    args = ["--table", TABLE, "--rules", RULES, "--genotypes", genotypes,
+            "--sample", sample, "--out", out, "--rules-out", rules_out]
+    if OG:
+        subprocess.run([OG, "traits", "table", *args], check=True, capture_output=True, text=True)
+    else:
+        with tempfile.TemporaryDirectory(prefix="traits-oracle-") as work:
+            ref = "669a8196cf4c377200f9b4af9c235ef85fb774a1"
+            if subprocess.run(["git", "-C", REPO, "cat-file", "-e", ref + "^{commit}"],
+                              stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL).returncode:
+                subprocess.run(["git", "-C", REPO, "fetch", "--depth=1", "origin", ref], check=True)
+            source = subprocess.check_output(["git", "-C", REPO, "show", ref + ":bin/traits_report.py"])
+            path = os.path.join(work, "traits_report.py")
+            with open(path, "wb") as f:
+                f.write(source)
+            subprocess.run([sys.executable, path, *args], check=True, capture_output=True, text=True)
 
-    # 2. a planted alternate allele changes the reading
-    before = tr.call(lct, at((c, p, ref, ".", f"{ref}/{ref}")))[2]
-    after = tr.call(lct, at((c, p, ref, alt, f"{ref}/{alt}")))[2]
-    check("planted alt: the reading changes from hom_ref to het", before == lct["hom_ref"] and after == lct["het"]
-          and before != after, (before, after))
 
-    # 3. not covered and other alleles
-    check("no line: not_covered", tr.call(lct, [])[1] == "not_covered")
-    other = next(b for b in "ACGT" if b not in (ref, alt))
-    g = tr.call(lct, at((c, p, ref, other, f"{ref}/{other}")))
-    check("an allele the table does not describe: other_allele, not read", g[1] == "other_allele"
-          and g[2] == tr.OTHER_ALLELE, g)
-    g = tr.call(lct, at((c, p, ref, alt, f"./{alt}")))
-    check("a half call: other_allele", g[1] == "other_allele", g)
-    g = tr.call(lct, at((c, p, ref + "T", ref, f"{ref}T/{ref}")))
-    check("a deletion starting at the position: other_allele", g[1] == "other_allele", g)
-    g = tr.call(lct, at((c, p, ref + "T", ref, f"{ref}T/{ref}"), (c, p, ref, alt, f"{ref}/{alt}")))
-    check("a SNV record beside an indel at the position is the one read", g == (f"{ref}/{alt}", "called", lct["het"]), g)
-
-    # 4. a REF that is not the GRCh38 base stops
-    try:
-        tr.call(lct, at((c, p, other, alt, f"{other}/{alt}")))
-        check("a gVCF REF that differs from the table stops the run", False, "no error")
-    except tr.TableError as e:
-        check("a gVCF REF that differs from the table stops the run, naming the row", "rs4988235" in str(e), e)
-
-    # 5. APOE, byte for byte the hand code's line
-    r4, r2 = by_id["rs429358"], by_id["rs7412"]
-    for (g4, g2), want in APOE_GOLDEN.items():
-        lines = [(r4["chrom"], r4["pos"], "T", g4.split("/")[1], g4)]
-        if g2 != ".":
-            lines.append((r2["chrom"], r2["pos"], "C", "T", g2))
-        out = tr.report(rows, recs(*lines), rules)
-        line = apoe_line(out)
-        check(f"APOE line byte for byte as before: rs429358 {g4}, rs7412 {g2} -> {line['genotype']} {line['status']}",
-              line_hash(line) == want, line)
-    out = tr.report(rows, recs((r4["chrom"], r4["pos"], "T", "C", "T/C"), (r2["chrom"], r2["pos"], "C", "T", "C/T")),
-                       rules)
-    check("APOE e2/e4: says it could also be the rare e1/e3", "e1/e3" in apoe_line(out)["reading"], apoe_line(out))
-    ids = [o["rsid"] for o in out]
-    check("APOE: the line comes right after the second APOE row",
-          ids.index("rs429358+rs7412") == max(ids.index("rs429358"), ids.index("rs7412")) + 1, ids)
-    check("APOE: one line only", ids.count("rs429358+rs7412") == 1, ids)
-    changed = dict(rules["APOE"], combinations=[dict(x, reading=x["reading"].replace("e3/e3.", "e3/e3!"))
-                                                for x in rules["APOE"]["combinations"]])
-    out = tr.report(rows, recs((r4["chrom"], r4["pos"], "T", "C", "T/C"), (r2["chrom"], r2["pos"], "C", "T", "C/C")),
-                       dict(rules, APOE=changed))
-    check("control: one changed character in an APOE reading changes the hash",
-          line_hash(apoe_line(out)) != APOE_GOLDEN[("T/C", "C/C")], apoe_line(out))
-    e4 = apoe_line(tr.report(rows, recs((r4["chrom"], r4["pos"], "T", "C", "C/C"),
-                                        (r2["chrom"], r2["pos"], "C", "T", "C/C")), rules))
-    check("APOE e4/e4: a risk factor, not a diagnosis", "not a diagnosis" in e4["reading"], e4)
-    check("report() without rules reads assets/genotype_rules.tsv (other tests call it so)",
-          line_hash(apoe_line(tr.report(rows, {}))) == line_hash(apoe_line(tr.report(rows, {}, rules))), rows[:0])
-
-    # 6. the rules table's schema
-    errs = tr.check_rules(rules, rows)
-    check(f"assets/genotype_rules.tsv passes the schema check ({len(rules)} rules)", not errs, errs)
-    check("the APOE and TAS2R38 rules are there", {"APOE", "TAS2R38"} <= set(rules), list(rules))
-
-    def broken(desc, mutate, want, table=rows):
-        rs = {k: dict(v, sites=[dict(s) for s in v["sites"]], haplotypes=[dict(h) for h in v["haplotypes"]],
-                      combinations=[dict(x) for x in v["combinations"]]) for k, v in rules.items()}
-        mutate(rs)
-        e = tr.check_rules(rs, table)
-        check(f"control: {desc} is caught", any(want in x for x in e), e)
-
-    broken("a missing combination line", lambda rs: rs["TAS2R38"]["combinations"].pop(), "no combination line for AVI/AVI")
-    broken("an extra combination line", lambda rs: rs["TAS2R38"]["combinations"].append(
-        dict(rs["TAS2R38"]["combinations"][0], diplotypes="PAV/PAV|AVI/AVI")), "can never be read")
-    broken("a haplotype allele that is neither ref nor alt",
-           lambda rs: rs["TAS2R38"]["haplotypes"][0].update(alleles="C,C,C"), "neither its ref")
-    broken("diplotypes out of haplotype order",
-           lambda rs: rs["TAS2R38"]["combinations"][1].update(diplotypes="AVI/PAV"), "write PAV/AVI")
-    broken("a rule site that disagrees with its traits table row",
-           lambda rs: rs["TAS2R38"]["sites"][1].update(ref="A", alt="G"), "the traits table has chr7:141972905 G>A")
-    broken("no APOE rule", lambda rs: rs.pop("APOE"), "rule APOE is missing")
-    broken("a needs_phase that is not yes or no", lambda rs: rs["APOE"].update(needs_phase="maybe"), "needs_phase")
-    work = tempfile.mkdtemp()
-    try:
-        bad = os.path.join(work, "r.tsv")
-        write(bad, open(RULES).read() + "allele\tAPOE\tx\n")
-        try:
-            tr.read_rules(bad)
-            check("control: a line of an unknown kind is caught", False, "read without error")
-        except tr.TableError as e:
-            check("control: a line of an unknown kind is caught", "kind 'allele'" in str(e), e)
-    finally:
-        shutil.rmtree(work)
-
-    # 7. the rules on synthetic gVCF records
-    def rule(rid, *lines, phased=None):
-        return next(x for x in tr.rule_lines(rules, recs(*lines), phased) if x["rule"] == rid)
-
-    a4, a2 = (r4["chrom"], r4["pos"]), (r2["chrom"], r2["pos"])
-    l = rule("APOE", (*a4, "T", ".", "T/T", "37"), (*a2, "C", ".", "C/C", "41"))
-    check("APOE, reference blocks only: e3/e3 called, with each block's GQ",
-          (l["result"], l["status"], l["genotypes"], l["gq"], l["phase"]) == ("e3/e3", "called", "T/T,C/C", "37,41",
-                                                                             "not_used"), l)
-    l = rule("APOE", (*a4, "T", "C", "T/C", "30"), (*a2, "C", "T", "C/T", "30"))
-    check("APOE, double heterozygote without phase: e2/e4 (the rule needs no phase)",
-          (l["result"], l["status"]) == ("e2/e4", "called"), l)
-    ref_blocks = [(*T1, "C", ".", "C/C", "50"), (*T2, "G", ".", "G/G", "50"), (*T3, "T", ".", "T/T", "48")]
-    l = rule("TAS2R38", *ref_blocks)
-    check("TAS2R38, reference blocks only: homozygous reference with the GQ, AAI (C,G,T) not read",
-          (l["status"], l["genotypes"], l["gq"], l["result"]) == ("other_haplotype", "C/C,G/G,T/T", "50,50,48", ".")
-          and "C,G,T" in l["reading"], l)
-    pav = [(*T1, "C", "G", "G/G", "40"), (*T2, "G", ".", "G/G", "40"), (*T3, "T", "C", "C/C", "40")]
-    l = rule("TAS2R38", *pav)
-    check("TAS2R38 PAV/PAV: called, no phase needed",
-          (l["result"], l["status"], l["phase"]) == ("PAV/PAV", "called", "not_needed"), l)
-    one_het = [(*T1, "C", "G", "C/G", "40"), (*T2, "G", "A", "A/A", "40"), (*T3, "T", ".", "T/T", "40")]
-    l = rule("TAS2R38", *one_het)
-    check("TAS2R38, one heterozygous site: AVI with a G,A,T copy, which the rule does not read (no phase needed)",
-          l["status"] == "other_haplotype" and l["phase"] == "not_needed" and "G,A,T" in l["reading"], l)
-    tri = [(*T1, "C", "G", "C/G", "35"), (*T2, "G", "A", "G/A", "35"), (*T3, "T", "C", "T/C", "35")]
-    l = rule("TAS2R38", *tri, phased={})
-    check("TAS2R38 triple heterozygote, no read pair spans the sites: unphased, not read",
-          (l["status"], l["phase"], l["result"]) == ("unphased", "unphased", ".")
-          and "no read or read pair" in l["reading"], l)
-    l = rule("TAS2R38", *tri)
-    check("TAS2R38 triple heterozygote, no phasing ran: unphased, says why",
-          l["status"] == "unphased" and "no phasing ran" in l["reading"], l)
-    one_block = phased_vcf(("chr7", T3[1], "T", "C", "1|0:141972804"), ("chr7", T2[1], "G", "A", "0|1:141972804"),
-                           ("chr7", T1[1], "C", "G", "1|0:141972804"))
-    l = rule("TAS2R38", *tri, phased=one_block)
-    check("TAS2R38 triple heterozygote phased in one block: PAV/AVI, read-backed",
-          (l["result"], l["status"], l["phase"]) == ("PAV/AVI", "called", "read_backed"), l)
-    two_blocks = phased_vcf(("chr7", T3[1], "T", "C", "1|0:141972804"), ("chr7", T2[1], "G", "A", "0|1:141972804"),
-                            ("chr7", T1[1], "C", "G", "1|0:141973545"))
-    l = rule("TAS2R38", *tri, phased=two_blocks)
-    check("TAS2R38 triple heterozygote phased in two blocks: unphased", l["status"] == "unphased", l)
-    odd = phased_vcf(("chr7", T3[1], "T", "C", "0|1:141972804"), ("chr7", T2[1], "G", "A", "0|1:141972804"),
-                     ("chr7", T1[1], "C", "G", "1|0:141972804"))
-    l = rule("TAS2R38", *tri, phased=odd)
-    check("TAS2R38 phased into G,G,T and C,A,C: a haplotype the rule does not describe",
-          l["status"] == "other_haplotype" and "G,G,T and C,A,C" in l["reading"], l)
-    l = rule("TAS2R38", *tri[:2])
-    check("TAS2R38, a site not covered: not_covered, names the three sites",
-          l["status"] == "not_covered" and "every one of rs713598, rs1726866 and rs10246939" in l["reading"], l)
-
-    # 8. the sites to phase, and WhatsHap's VCF read back
-    s = tr.phase_sites(rules, recs(*tri, (*a4, "T", "C", "T/C"), (*a2, "C", "T", "C/T")))
-    check("--phase-sites: the three TAS2R38 sites, not APOE's (needs_phase no)",
-          sorted(x[2] for x in s) == ["rs10246939", "rs1726866", "rs713598"], s)
-    check("--phase-sites: nothing for one heterozygous site", tr.phase_sites(rules, recs(*one_het)) == [])
-    check("--phase-sites: nothing when a site is not covered", tr.phase_sites(rules, recs(*tri[:2])) == [])
-    check("WhatsHap's VCF: unphased records are left out",
-          phased_vcf(("chr7", "1", "C", "G", "0/1"), ("chr7", "2", "G", "A", "0|1:2")) == {("chr7", "2"): ("G", "A", "2")})
-    work = tempfile.mkdtemp()
-    try:
-        g = os.path.join(work, "g.tsv")
-        write(g, "".join("\t".join(x) + "\n" for x in tri))
-        vcf = os.path.join(work, "in.vcf")
-        res = run("--rules", RULES, "--genotypes", g, "--sample", "S", "--phase-sites", vcf)
-        body = [x.split("\t") for x in open(vcf).read().splitlines() if not x.startswith("#")] if res.returncode == 0 else []
-        check("--phase-sites CLI: a sorted one-sample VCF of the three 0/1 sites",
-              [(x[1], x[2], x[9]) for x in body] == [(T3[1], "rs10246939", "0/1"), (T2[1], "rs1726866", "0/1"),
-                                                      (T1[1], "rs713598", "0/1")]
-              and "#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tS" in open(vcf).read(), (res.stderr, body))
-
-        # 9. the command line
-        write(g, f"{c}\t{p}\t{ref}\t{alt}\t{ref}/{alt}\t30\n" + "".join("\t".join(x) + "\n" for x in tri))
-        out, rout = os.path.join(work, "S_traits.tsv"), os.path.join(work, "S_genotype_rules.tsv")
-        ph = os.path.join(work, "phased.vcf")
-        write(ph, "##fileformat=VCFv4.2\n#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tS\n"
-              f"chr7\t{T3[1]}\t.\tT\tC\t.\tPASS\t.\tGT:PS\t1|0:9\nchr7\t{T2[1]}\t.\tG\tA\t.\tPASS\t.\tGT:PS\t0|1:9\n"
-              f"chr7\t{T1[1]}\t.\tC\tG\t.\tPASS\t.\tGT:PS\t1|0:9\n")
-        res = run("--table", TABLE, "--rules", RULES, "--genotypes", g, "--phased", ph, "--sample", "S",
-                  "--out", out, "--rules-out", rout)
-        check("CLI: exits 0", res.returncode == 0, res.stderr)
-        lines = open(out).read().splitlines() if res.returncode == 0 else [""]
-        check("CLI: the header is the output columns", lines[0].split("\t") == tr.OUT_COLUMNS, lines[0])
-        check("CLI: one row per table row plus the APOE line", len(lines) - 1 == len(rows) + 1, len(lines))
-        row = next((l.split("\t") for l in lines[1:] if l.startswith("rs4988235\t")), [])
-        check("CLI: the planted het reads het", row[5:8] == [f"{ref}/{alt}", "called", lct["het"]], row)
-        check("CLI: a row with no line is not_covered",
-              next((l for l in lines if l.startswith("rs671\t")), "").split("\t")[6:7] == ["not_covered"])
-        rl = open(rout).read().splitlines() if res.returncode == 0 else [""]
-        check("CLI: the rules table has its header and one line per rule",
-              rl[0].split("\t") == tr.RULE_OUT_COLUMNS and len(rl) - 1 == len(rules), rl[:1])
-        t = next((x.split("\t") for x in rl if x.startswith("TAS2R38\t")), [])
-        check("CLI: TAS2R38 read from the phased VCF: PAV/AVI, read-backed, with the GQ",
-              t[6:11] == ["C/G,G/A,T/C", "35,35,35", "read_backed", "PAV/AVI", "called"], t)
-        bad = os.path.join(work, "bad.tsv")
-        write(bad, open(TABLE).read().replace("\trs671\tALDH2\tG\tA\t", "\trs671\tALDH2\tG\tG\t"))
-        res = run("--table", bad, "--rules", RULES, "--genotypes", g, "--sample", "S",
-                  "--out", os.path.join(work, "x.tsv"), "--rules-out", os.path.join(work, "y.tsv"))
-        check("CLI: a traits table that fails the schema check exits 1, naming the row",
-              res.returncode == 1 and "rs671" in res.stderr and not os.path.exists(os.path.join(work, "x.tsv")),
-              (res.returncode, res.stderr))
-        badr = os.path.join(work, "badr.tsv")
-        write(badr, open(RULES).read().replace("haplotype\tTAS2R38\tAVI\tC,A,T", "haplotype\tTAS2R38\tAVI\tC,A,A"))
-        res = run("--table", TABLE, "--rules", badr, "--genotypes", g, "--sample", "S",
-                  "--out", os.path.join(work, "x.tsv"), "--rules-out", os.path.join(work, "y.tsv"))
-        check("CLI: a rules table that fails the schema check exits 1, naming the haplotype",
-              res.returncode == 1 and "AVI" in res.stderr and not os.path.exists(os.path.join(work, "y.tsv")),
-              (res.returncode, res.stderr))
-        res = run("--check-table", TABLE, "--rules", RULES)
-        check("CLI --check-table with --rules: schema OK", res.returncode == 0 and "schema OK" in res.stdout,
-              (res.returncode, res.stderr))
+def og_cn(*args):
+    return subprocess.run([OG, "cn", *args], capture_output=True, text=True)
 
-    finally:
-        shutil.rmtree(work)
 
-    multi_snp_checks(rules)
+def main():
+    rules = {}
+    with open(RULES) as f:
+        for cells in csv.reader((line for line in f if not line.startswith("#")), delimiter="\t"):
+            if cells and cells[0] == "site":
+                rules.setdefault(cells[1], {"sites": []})["sites"].append(cells[2:])
+    dbsnp_checks(rules)
+    if not OG:
+        check("OG_REQUIRED needs the og binary", not os.environ.get("OG_REQUIRED"))
+        print("skip: OG is not set: traits CLI and cn marker checks did not run")
+        return int(bool(FAILS))
+    with tempfile.TemporaryDirectory() as work:
+        def table(records):
+            g = os.path.join(work, "g.tsv")
+            write(g, "".join("\t".join(rec) + "\n" for rec in records))
+            out, rout = os.path.join(work, "traits.tsv"), os.path.join(work, "rules.tsv")
+            res = subprocess.run([OG, "traits", "table", "--table", TABLE, "--rules", RULES,
+                                  "--genotypes", g, "--sample", "S", "--out", out,
+                                  "--rules-out", rout], capture_output=True, text=True)
+            check("traits table exits 0", res.returncode == 0, res.stderr)
+            if res.returncode:
+                return [], []
+            with open(out) as f:
+                traits = list(csv.DictReader(f, delimiter="\t"))
+            with open(rout) as f:
+                lines = list(csv.DictReader(f, delimiter="\t"))
+            return traits, lines
+        for (a, b), want in APOE_GOLDEN.items():
+            records = [("chr19", pos, ref, alt, gt) for pos, ref, alt, gt in
+                       [("44908684", "T", "C", a), ("44908822", "C", "T", b)] if gt != "."]
+            traits, lines = table(records)
+            apoe = next(r for r in traits if "+" in r["rsid"])
+            got = hashlib.sha256("\t".join(apoe[k] for k in tr.OUT_COLUMNS).encode()).hexdigest()
+            check(f"APOE golden {a}, {b}", got == want, got)
+        for rid, cases in MULTI_SNP.items():
+            for gts, label in cases:
+                records = [(s[1], s[2], s[3], s[4], gt) for s, gt in zip(rules[rid]["sites"], gts)]
+                _, lines = table(records)
+                got = next(r for r in lines if r["rule"] == rid)
+                check(f"{rid} {gts}: {label}", got["status"] == "called" and got["result"] == label, got)
     marker_checks()
-
-    print("\nRESULT:", "ALL PASS" if FAILS == 0 else f"{FAILS} FAILED")
-    return 1 if FAILS or (not OG and os.environ.get("OG_REQUIRED")) else 0
+    print("RESULT:", "ALL PASS" if not FAILS else f"{FAILS} FAILED")
+    return int(bool(FAILS))
 
 
 if __name__ == "__main__":
diff --git a/tests/test_traits_table.py b/tests/test_traits_table.py
index 0996c911a..84cf60203 100644
--- a/tests/test_traits_table.py
+++ b/tests/test_traits_table.py
@@ -145,39 +145,19 @@ def online_errors(rows):
     return errs
 
 
+def schema(path):
+    return subprocess.run([os.environ.get("OG", os.path.join(REPO, "bin", "og")),
+                           "traits", "check", "--table", path], capture_output=True, text=True)
+
+
 def schema_controls():
     good = tr.read_table(TABLE)
-    errs = tr.check_rows(good)
-    check(f"assets/traits.tsv passes the schema check ({len(good)} rows)", not errs, errs)
     check("the table has at least 30 rows", len(good) >= 30, len(good))
-
-    def broken(desc, mutate, want):
-        rows = [dict(r) for r in good]
-        mutate(rows)
-        e = tr.check_rows(rows)
-        check(f"control: {desc} is caught", any(want in x for x in e), e)
-
-    broken("ref = alt", lambda rs: rs[0].update(alt=rs[0]["ref"]), "same base")
-    broken("a ref that is not a base", lambda rs: rs[0].update(ref="N"), "is not one of A, C, G, T")
-    broken("a duplicate rsID", lambda rs: rs[1].update(rsid=rs[0]["rsid"]), "appears twice")
-    broken("a PMID that is not a number", lambda rs: rs[0].update(pmids="PMC123"), "PubMed ids")
-    broken("a contig outside chr1 to chr22", lambda rs: rs[0].update(chrom="chrX"), "is not chr1 to chr22")
-    broken("a missing APOE row", lambda rs: rs.remove(next(r for r in rs if r["rsid"] == "rs7412")), "rs7412 is missing")
-    broken("an empty reading", lambda rs: rs[0].update(het=" "), "het is empty")
-    broken("SNPedia text", lambda rs: rs[0].update(note="From SNPedia."), "SNPedia")
     work = tempfile.mkdtemp()
     try:
-        bad = os.path.join(work, "t.tsv")
-        with open(TABLE) as f:
-            text = f.read()
-        with open(bad, "w") as f:
-            f.write(text.replace("\trs671\t", "\trs671\textra\t", 1))
-        try:
-            tr.read_table(bad)
-            check("control: a row with an extra column is caught", False, "read without error")
-        except tr.TableError as e:
-            check("control: a row with an extra column is caught", "columns" in str(e), e)
-
+        # Schema controls are Rust unit tests and traits parity cases.
+        res = schema(TABLE)
+        check("assets/traits.tsv passes og traits check", res.returncode == 0, res.stderr)
         # FASTA check on a synthetic FASTA: chr2 holds the lactase row's base.
         lct = next(r for r in good if r["rsid"] == "rs4988235")
         pos = int(lct["pos"])
@@ -212,6 +192,9 @@ def main(argv=None):
     ap.add_argument("--online", action="store_true", help="look the PMIDs up in PubMed and the rsIDs in dbSNP")
     a = ap.parse_args(argv)
     if a.table == TABLE and not a.fasta and not a.online:
+        if not os.environ.get("OG") and not os.environ.get("OG_REQUIRED"):
+            print("skip: OG is not set: traits schema controls run in the Rust job")
+            return 0
         schema_controls()
     else:
         try:
@@ -219,8 +202,8 @@ def main(argv=None):
         except tr.TableError as e:
             check("the table can be read", False, e)
             rows = []
-        errs = tr.check_rows(rows)
-        check(f"{a.table} passes the schema check", not errs, errs)
+        res = schema(a.table)
+        check(f"{a.table} passes the schema check", res.returncode == 0, res.stderr)
         if a.fasta and rows:
             e, n = fasta_errors(a.fasta, rows)
             print(f"  ref checked against {a.fasta}: {n} rows (the others are on contigs it lacks)")

From 339b64733676314d8b5d75bc98553d9e9aea5254 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 15:11:07 +0100
Subject: [PATCH 40/76] test(traits): plant diplotype, reference and phase
 controls

Bead: pgp-bs9u.25
---
 rust/crates/og-steps/src/traits.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/rust/crates/og-steps/src/traits.rs b/rust/crates/og-steps/src/traits.rs
index 40c3db950..1c4d6169f 100644
--- a/rust/crates/og-steps/src/traits.rs
+++ b/rust/crates/og-steps/src/traits.rs
@@ -339,6 +339,7 @@ fn allowed(rule: &Rule, gt: &[Vec<String>]) -> Vec<String> {
             }
         }
     }
+    out.reverse(); // planted control: diplotype key order
     out
 }
 fn check_rules(rules: &[Rule], rows: Option<&[Site]>) -> Vec<String> {
@@ -562,7 +563,7 @@ fn read_genotypes(path: &str, sites: &[&Site]) -> Result<Genotypes> {
         };
         let site = sites[0];
         for s in sites {
-            if c[2].chars().next() != s.row["ref"].chars().next() {
+            if c[2].is_empty() { // planted control: REF check removed
                 return Err(format!(
                     "{} at {}:{}: the gVCF has REF {}, the table {} (the GRCh38 base). Is the gVCF on GRCh38?",
                     s.row["rsid"], c[0], c[1], c[2], s.row["ref"]
@@ -861,6 +862,7 @@ fn phase_vcf(path: &str, sample: &str, rules: &[Rule], gt: &Genotypes) -> Result
             }
         }
     }
+    sites.clear(); // planted control: missing phase sites
     let mut out = AtomicFile::create(path).map_err(|e| e.to_string())?;
     let write = |out: &mut AtomicFile| -> std::io::Result<()> {
         writeln!(out, "##fileformat=VCFv4.2")?;

From ab5088dc7e0ec80665fba0b074a4d756c7b37b65 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 15:14:48 +0100
Subject: [PATCH 41/76] test(traits): restore evaluation after planted controls

Reverts 339b64733676314d8b5d75bc98553d9e9aea5254.

Bead: pgp-bs9u.25
---
 rust/crates/og-steps/src/traits.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/rust/crates/og-steps/src/traits.rs b/rust/crates/og-steps/src/traits.rs
index 1c4d6169f..40c3db950 100644
--- a/rust/crates/og-steps/src/traits.rs
+++ b/rust/crates/og-steps/src/traits.rs
@@ -339,7 +339,6 @@ fn allowed(rule: &Rule, gt: &[Vec<String>]) -> Vec<String> {
             }
         }
     }
-    out.reverse(); // planted control: diplotype key order
     out
 }
 fn check_rules(rules: &[Rule], rows: Option<&[Site]>) -> Vec<String> {
@@ -563,7 +562,7 @@ fn read_genotypes(path: &str, sites: &[&Site]) -> Result<Genotypes> {
         };
         let site = sites[0];
         for s in sites {
-            if c[2].is_empty() { // planted control: REF check removed
+            if c[2].chars().next() != s.row["ref"].chars().next() {
                 return Err(format!(
                     "{} at {}:{}: the gVCF has REF {}, the table {} (the GRCh38 base). Is the gVCF on GRCh38?",
                     s.row["rsid"], c[0], c[1], c[2], s.row["ref"]
@@ -862,7 +861,6 @@ fn phase_vcf(path: &str, sample: &str, rules: &[Rule], gt: &Genotypes) -> Result
             }
         }
     }
-    sites.clear(); // planted control: missing phase sites
     let mut out = AtomicFile::create(path).map_err(|e| e.to_string())?;
     let write = |out: &mut AtomicFile| -> std::io::Result<()> {
         writeln!(out, "##fileformat=VCFv4.2")?;

From f7a5f2144edb2ca689f60822bcb99ff2f7601ee2 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 15:30:41 +0100
Subject: [PATCH 42/76] fix(ci): match personal-data patterns with Python
 semantics

---
 .github/workflows/guard.yml             |  62 ++-
 CHANGELOG.md                            |   7 +-
 rust/Cargo.lock                         |  28 ++
 rust/crates/og-dev/Cargo.toml           |   2 +
 rust/crates/og-dev/src/lookaround.rs    | 562 +++++++++++++++++++---
 rust/crates/og-dev/src/personal_data.rs | 588 +++++++++++++++++-------
 scripts/ci/check-personal-data.sh       |  22 +-
 7 files changed, 1013 insertions(+), 258 deletions(-)

diff --git a/.github/workflows/guard.yml b/.github/workflows/guard.yml
index 0ce135958..c1b036c90 100644
--- a/.github/workflows/guard.yml
+++ b/.github/workflows/guard.yml
@@ -296,26 +296,60 @@ jobs:
       - name: cargo test
         run: cargo test --workspace --locked --no-fail-fast
 
-      # Keep the negative controls executable on the final head. The pinned
-      # test-only commit contains the old scanner and the five regressions.
-      - name: Scanner controls (all five pre-fix differential tests must fail)
+      # Each pinned test-only commit still contains the scanner it attacks.
+      - name: Scanner controls (both rounds must fail against their pre-fix code)
         run: |
-          before=80a675eadf73640c2a0f2d63fcfe30e6fdd0deef
-          git cat-file -e "$before^{commit}" 2>/dev/null || git fetch --quiet --depth=1 origin "$before"
           source=crates/og-dev/src/personal_data.rs
-          saved="${RUNNER_TEMP}/personal-data-fixed.rs"
+          matcher=crates/og-dev/src/lookaround.rs
+          cp "$source" "${RUNNER_TEMP}/personal-data-fixed.rs"
+          cp "$matcher" "${RUNNER_TEMP}/matcher-fixed.rs"
+          trap 'cp "${RUNNER_TEMP}/personal-data-fixed.rs" "$source"; cp "${RUNNER_TEMP}/matcher-fixed.rs" "$matcher"' EXIT
+          for round in 1 2; do
+            if [ "$round" = 1 ]; then
+              before=80a675eadf73640c2a0f2d63fcfe30e6fdd0deef
+              filter=privacy_
+              tests="report_never_contains_values_or_patterns python_boundaries_differential python_casefold_differential staged_newline_differential fixed_seed_differential_fuzz"
+            else
+              before=fcb7ac4ec4dc547074f5b4e12699ae9ecb1c24ef
+              filter=round2_
+              tests="boundary_backtracking custom_unicode cr_patterns empty_alternative exception_lines"
+            fi
+            git cat-file -e "$before^{commit}" 2>/dev/null || git fetch --quiet --depth=1 origin "$before"
+            git show "$before:rust/$source" > "$source"
+            git show "$before:rust/$matcher" > "$matcher"
+            log="${RUNNER_TEMP}/scanner-red-controls-${round}.log"
+            rc=0
+            cargo test -p og-dev --locked --no-fail-fast "$filter" > "$log" 2>&1 || rc=$?
+            cat "$log"
+            [ "$rc" -ne 0 ] || { echo "ERROR: the pre-fix scanner passed"; exit 1; }
+            for test in $tests; do
+              grep -E "${filter}${test} .*FAILED" "$log" || { echo "ERROR: missing red control $test"; exit 1; }
+            done
+            echo "Control: all five scanner regressions in round ${round} failed, as they must."
+          done
+
+      - name: Scanner matcher controls (word classes and swallowed errors must be caught)
+        run: |
+          source=crates/og-dev/src/lookaround.rs
+          saved="${RUNNER_TEMP}/matcher-controls-fixed.rs"
           cp "$source" "$saved"
           trap 'cp "$saved" "$source"' EXIT
-          git show "$before:rust/$source" > "$source"
-          log="${RUNNER_TEMP}/scanner-red-controls.log"
+          sed 's/^const WORD: .*$/const WORD: \&str = r"[\\w]";/' "$saved" > "$source"
+          log="${RUNNER_TEMP}/matcher-word-control.log"
           rc=0
-          cargo test -p og-dev --locked --no-fail-fast privacy_ > "$log" 2>&1 || rc=$?
+          cargo test -p og-dev --locked --no-fail-fast --lib > "$log" 2>&1 || rc=$?
           cat "$log"
-          [ "$rc" -ne 0 ] || { echo "ERROR: the pre-fix scanner passed"; exit 1; }
-          for test in report_never_contains_values_or_patterns python_boundaries_differential python_casefold_differential staged_newline_differential fixed_seed_differential_fuzz; do
-            grep -E "privacy_${test} .*FAILED" "$log" || { echo "ERROR: missing red control $test"; exit 1; }
-          done
-          echo "Control: all five scanner regressions failed, as they must."
+          [ "$rc" -ne 0 ]
+          grep -E 'round2_generated_patterns_and_tables .*FAILED' "$log"
+          grep -E 'finditer_spans_match_real_python .*FAILED' "$log"
+          sed 's/Some(Err(()))/None/' "$saved" > "$source"
+          log="${RUNNER_TEMP}/matcher-error-control.log"
+          rc=0
+          cargo test -p og-dev --locked --no-fail-fast round2_unsupported > "$log" 2>&1 || rc=$?
+          cat "$log"
+          [ "$rc" -ne 0 ]
+          grep -E 'round2_unsupported_and_exhausted_patterns_fail_closed .*FAILED' "$log"
+          echo "Control: incorrect word classes and a swallowed matcher error both failed."
 
       - name: pycompat against CPython (python3 -I in PYTHON_IMAGE, 100000 cases per operation)
         if: ${{ !cancelled() }}   # runs even when a step above failed, so each result shows
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3c9d15394..26a72b608 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,7 +4,7 @@ Each release's notes. From 1.0.0 on, a major or minor release has hand-written n
 
 ## Unreleased
 
-- The personal-data scan, the image scan and the version checks of CI now run in the Rust `og` binary: `og dev scan personal-data` (`scripts/ci/check-personal-data.sh`), `og dev scan images` and `og dev versions coupled` (`scripts/ci/check-images.sh`), `og dev versions check-run` (`scripts/ci/gen-containers-config.sh --check-versions`), `og dev versions expand` (`scripts/ci/check-links.sh`) and `og dev pgs` (`scripts/ci/check-pgs-labels.sh`). The scripts keep their options and lists; the Python inside them is gone. The personal-data scan of the repository takes 0.5 s instead of 3.6 s. Fixes:
+- The personal-data scan, the image scan and the version checks of CI now run in the Rust `og` binary: `og dev scan personal-data` (`scripts/ci/check-personal-data.sh`), `og dev scan images` and `og dev versions coupled` (`scripts/ci/check-images.sh`), `og dev versions check-run` (`scripts/ci/gen-containers-config.sh --check-versions`), `og dev versions expand` (`scripts/ci/check-links.sh`) and `og dev pgs` (`scripts/ci/check-pgs-labels.sh`). The scripts keep their options and lists; the Python inside them is gone. Fixes:
   - A personal-data scan that read no text file (every file skipped or binary) fails with `FAIL: no text file was scanned`. It printed `scanned 0 text files` and passed.
   - A personal-data scan whose root is reached through a symbolic link places each file under that root, so the lists of skipped files and documented examples still apply to it.
   - An image exemption in `check-images.sh` whose file no longer names that image fails with `FAIL: <file> no longer names <image>; drop its line from EXEMPT_PAIRS`. A stale exemption was never reported.
@@ -13,7 +13,10 @@ Each release's notes. From 1.0.0 on, a major or minor release has hand-written n
   - Personal-data findings print only the kind, escaped filename and line number. Matched values and custom-pattern contents never appear in diagnostics. The Python scanner printed the detected line.
   - Built-in word boundaries and sample-label case folding follow Python, including combining marks, dotted and dotless I, long s and the Kelvin sign.
   - The staged scan uses NUL-delimited Git requests and responses, so a filename containing a newline cannot hide a finding.
-  - `PERSONAL_DATA_PATTERNS` holds patterns in the syntax of Rust's regex crate. It was Python's. Capture groups keep the full match when checking allowed examples.
+  - Built-in and custom personal-data patterns share a Python-subset compiler and a backtracking matcher. Word boundaries stay inside the search, so a chip row ending in `A-` can backtrack to its shorter match. Unicode word, space and case rules also apply to custom patterns.
+  - Empty custom matches keep Python's iteration order, including a nonempty alternative at the same position. Capture groups keep the full match when checking allowed examples.
+  - Pattern files use universal newlines. ALLOW and SKIP rows use Python's line separators, so a CR or Unicode separator cannot extend an exemption into another file.
+  - Unsupported custom constructs or matcher resource limits stop the scan with a redacted error and exit 2. The supported subset is documented in `scripts/ci/check-personal-data.sh`.
 
 - The container helpers check (`scripts/ci/check-container-helpers.sh`, Guard job `helper-binaries`) now derives its table with the Rust `og` binary, `og dev helpers`. It replaces the Python inside the script, which is gone; the script keeps the docker probe, the orad download and its self-test. On this tree the table and the rule 1 output are the same, byte for byte. The static run takes 0.01 s and 6 MB where the Python took 0.2 s and 15 MB. What changes:
   - A helper called in a process's `shell:` block is checked too. The Python read only `script:` blocks, so such a call went unchecked. No module has one today.
diff --git a/rust/Cargo.lock b/rust/Cargo.lock
index 4d91a18ca..24cddb0df 100644
--- a/rust/Cargo.lock
+++ b/rust/Cargo.lock
@@ -48,6 +48,21 @@ dependencies = [
  "thiserror 1.0.69",
 ]
 
+[[package]]
+name = "bit-set"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
+dependencies = [
+ "bit-vec",
+]
+
+[[package]]
+name = "bit-vec"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
+
 [[package]]
 name = "bitflags"
 version = "2.13.2"
@@ -177,6 +192,17 @@ dependencies = [
  "windows-sys",
 ]
 
+[[package]]
+name = "fancy-regex"
+version = "0.16.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "998b056554fbe42e03ae0e152895cd1a7e1002aec800fdc6635d20270260c46f"
+dependencies = [
+ "bit-set",
+ "regex-automata",
+ "regex-syntax",
+]
+
 [[package]]
 name = "fdeflate"
 version = "0.3.7"
@@ -664,6 +690,7 @@ dependencies = [
 name = "og-dev"
 version = "0.1.0"
 dependencies = [
+ "fancy-regex",
  "flate2",
  "indexmap",
  "og-io",
@@ -671,6 +698,7 @@ dependencies = [
  "png",
  "pycompat",
  "regex",
+ "regex-syntax",
 ]
 
 [[package]]
diff --git a/rust/crates/og-dev/Cargo.toml b/rust/crates/og-dev/Cargo.toml
index 108491221..1407e7633 100644
--- a/rust/crates/og-dev/Cargo.toml
+++ b/rust/crates/og-dev/Cargo.toml
@@ -13,6 +13,8 @@ og-nf.workspace = true
 flate2.workspace = true
 indexmap.workspace = true
 png = "0.18"
+fancy-regex = "=0.16.2"
+regex-syntax = "=0.8.11"
 regex = { version = "1", default-features = false, features = ["std", "perf", "unicode"] }
 
 [lints]
diff --git a/rust/crates/og-dev/src/lookaround.rs b/rust/crates/og-dev/src/lookaround.rs
index cdd241fb7..f95bd3935 100644
--- a/rust/crates/og-dev/src/lookaround.rs
+++ b/rust/crates/og-dev/src/lookaround.rs
@@ -1,7 +1,7 @@
-//! Python's one-character look-behind and look-ahead on the `regex` crate,
-//! which has neither.
+//! Image rules keep their original linear matcher. Personal-data rules use
+//! a Python-subset compiler and a backtracking matcher with assertions.
 //!
-//! Every look-around of the scanners is a single character class: "not
+//! Every look-around of the image scanner is a single character class: "not
 //! after one of these" before the match and "not followed by one of these"
 //! after it. A [`Rule`] keeps the matched text in capture group 1 and
 //! writes the look-ahead as a consumed `(?:[^...]|$)` after it, so the
@@ -16,10 +16,6 @@ use regex::Regex;
 /// A pattern with its look-behind.
 pub struct Rule {
     re: Regex,
-    boundaries: Vec<usize>,
-    /// Capture describing the match span: 1 for rewritten look-around,
-    /// 0 for a user's unmodified regular expression.
-    capture: usize,
     /// True for a character the match must not follow.
     not_after: Option<fn(char) -> bool>,
 }
@@ -30,72 +26,22 @@ impl Rule {
     pub fn new(pattern: &str, not_after: Option<fn(char) -> bool>) -> Result<Rule, regex::Error> {
         Ok(Rule {
             re: Regex::new(pattern)?,
-            boundaries: Vec::new(),
-            capture: 1,
             not_after,
         })
     }
 
-    /// A scanner pattern with Python's Unicode word boundaries. Python's
-    /// word characters are Unicode letters and numbers plus underscore;
-    /// Rust regex also includes marks and join controls. Capture each
-    /// boundary position and check it without consuming surrounding text.
-    pub fn python(
-        pattern: &str,
-        not_after: Option<fn(char) -> bool>,
-    ) -> Result<Rule, regex::Error> {
-        let mut translated = String::new();
-        for (i, part) in pattern.split(r"\b").enumerate() {
-            if i > 0 {
-                translated.push_str(&format!("(?P<og_boundary_{i}>)"));
-            }
-            translated.push_str(part);
-        }
-        let re = Regex::new(&translated)?;
-        let mut boundaries = Vec::new();
-        let mut capture = 0;
-        for (i, name) in re.capture_names().enumerate().skip(1) {
-            if name.is_some_and(|n| n.starts_with("og_boundary_")) {
-                boundaries.push(i);
-            } else if capture == 0 {
-                capture = i;
-            }
-        }
-        Ok(Self {
-            re,
-            boundaries,
-            capture,
-            not_after,
-        })
-    }
-
-    /// A user's regular expression, whose captures do not change its span.
-    pub fn whole_match(pattern: &str) -> Result<Rule, regex::Error> {
-        let mut rule = Self::new(pattern, None)?;
-        rule.capture = 0;
-        Ok(rule)
-    }
-
-    /// The spans of `re.finditer` over `line`, in order.
+    /// The spans of the image rule over `line`, in order.
     pub fn find_iter<'a>(&'a self, line: &'a str) -> impl Iterator<Item = (usize, usize)> + 'a {
         let mut pos = 0;
         std::iter::from_fn(move || {
             while pos <= line.len() {
                 let caps = self.re.captures_at(line, pos)?;
-                let m = caps.get(self.capture).or_else(|| caps.get(0))?;
+                let m = caps.get(1).or_else(|| caps.get(0))?;
                 let (start, end) = (m.start(), m.end());
                 let refused = self
                     .not_after
                     .is_some_and(|bad| line[..start].chars().next_back().is_some_and(bad));
-                let bad_boundary = self.boundaries.iter().any(|&i| {
-                    caps.get(i).is_some_and(|m| {
-                        let at = m.start();
-                        let left = line[..at].chars().next_back().is_some_and(python_word);
-                        let right = line[at..].chars().next().is_some_and(python_word);
-                        left == right
-                    })
-                });
-                if refused || bad_boundary {
+                if refused {
                     pos = next_char(line, start);
                     continue;
                 }
@@ -109,17 +55,6 @@ impl Rule {
             None
         })
     }
-
-    /// `re.search(line) is not None`.
-    pub fn is_match(&self, line: &str) -> bool {
-        self.find_iter(line).next().is_some()
-    }
-}
-
-fn python_word(c: char) -> bool {
-    static WORD: std::sync::LazyLock<Regex> =
-        std::sync::LazyLock::new(|| Regex::new(r"\A[\p{L}\p{N}_]\z").expect("word character"));
-    WORD.is_match(c.encode_utf8(&mut [0; 4]))
 }
 
 /// The byte offset of the character after `i`, or one past the end.
@@ -164,3 +99,488 @@ mod tests {
         assert_eq!(got, ["a/b:1"]);
     }
 }
+
+// Personal-data patterns have one translation and one search path. Assertions
+// stay in the engine so a failed assertion can backtrack at the same start.
+const WORD: &str = r"[\p{L}\p{N}_]";
+const SPACE: &str = r"[\x09-\x0d\x1c-\x20\x85\x{a0}\x{1680}\x{2000}-\x{200a}\x{2028}\x{2029}\x{202f}\x{205f}\x{3000}]";
+
+#[derive(Clone)]
+pub struct PythonRule {
+    re: fancy_regex::Regex,
+    after_empty: fancy_regex::Regex,
+}
+
+impl PythonRule {
+    pub fn compile(pattern: &str, builtin: bool) -> Result<Self, ()> {
+        if pattern.len() > 16_384 {
+            return Err(());
+        }
+        let mut parser = PythonPattern {
+            chars: pattern.chars().collect(),
+            at: 0,
+            builtin,
+            depth: 0,
+            names: std::collections::HashSet::new(),
+        };
+        let translated = parser.group(Flags::default(), false)?;
+        // \G is the search offset. After yielding an empty match, forbid only
+        // a match ending at that offset; the engine then tries nonempty
+        // alternatives at the same start, exactly as Python finditer does.
+        let after_empty = format!(r"(?:{translated})(?!\G)");
+        let build = |p: &str| {
+            fancy_regex::RegexBuilder::new(p)
+                .backtrack_limit(1_000_000)
+                .build()
+                .map_err(|_| ())
+        };
+        Ok(Self {
+            re: build(&translated)?,
+            after_empty: build(&after_empty)?,
+        })
+    }
+
+    pub fn find_iter<'a>(
+        &'a self,
+        text: &'a str,
+    ) -> impl Iterator<Item = Result<(usize, usize), ()>> + 'a {
+        let (mut pos, mut empty, mut done) = (0, false, false);
+        std::iter::from_fn(move || {
+            if done {
+                return None;
+            }
+            let re = if empty { &self.after_empty } else { &self.re };
+            match re.find_from_pos(text, pos) {
+                Ok(Some(m)) => {
+                    pos = m.end();
+                    empty = m.start() == m.end();
+                    Some(Ok((m.start(), m.end())))
+                }
+                Ok(None) => {
+                    done = true;
+                    None
+                }
+                Err(_) => {
+                    done = true;
+                    Some(Err(()))
+                }
+            }
+        })
+    }
+
+    pub fn is_match(&self, text: &str) -> Result<bool, ()> {
+        self.find_iter(text).next().transpose().map(|m| m.is_some())
+    }
+}
+
+#[derive(Clone, Copy, Default)]
+struct Flags {
+    i: bool,
+    m: bool,
+    s: bool,
+    x: bool,
+}
+
+struct PythonPattern {
+    chars: Vec<char>,
+    at: usize,
+    builtin: bool,
+    depth: usize,
+    names: std::collections::HashSet<String>,
+}
+
+impl PythonPattern {
+    fn take(&mut self) -> Result<char, ()> {
+        let c = self.chars.get(self.at).copied().ok_or(())?;
+        self.at += 1;
+        Ok(c)
+    }
+
+    fn peek(&self) -> Option<char> {
+        self.chars.get(self.at).copied()
+    }
+
+    fn group(&mut self, mut flags: Flags, nested: bool) -> Result<String, ()> {
+        let mut out = String::new();
+        let (mut repeatable, mut lazy) = (false, false);
+        while let Some(c) = self.peek() {
+            self.at += 1;
+            if flags.x && matches!(c, ' ' | '\t' | '\n' | '\r' | '\u{b}' | '\u{c}') {
+                continue;
+            }
+            if flags.x && c == '#' {
+                while self.peek().is_some_and(|c| c != '\n') {
+                    self.at += 1;
+                }
+                continue;
+            }
+            match c {
+                ')' if nested => return Ok(out),
+                ')' => return Err(()),
+                '(' => {
+                    repeatable = true;
+                    lazy = false;
+                    if self.depth >= 64 {
+                        return Err(());
+                    }
+                    let mut prefix = "?:".to_owned();
+                    let mut inner = flags;
+                    if self.peek() == Some('?') {
+                        self.at += 1;
+                        match self.take()? {
+                            ':' => (),
+                            '=' if self.builtin => prefix = "?=".into(),
+                            '!' if self.builtin => prefix = "?!".into(),
+                            '<' if self.builtin => {
+                                let c = self.take()?;
+                                if !matches!(c, '=' | '!') {
+                                    return Err(());
+                                }
+                                prefix = format!("?<{c}");
+                            }
+                            'P' => {
+                                if self.take()? != '<' {
+                                    return Err(());
+                                }
+                                let mut name = String::new();
+                                loop {
+                                    let c = self.take()?;
+                                    if c == '>' {
+                                        break;
+                                    }
+                                    name.push(c);
+                                }
+                                if name.is_empty()
+                                    || !name.chars().all(|c| c.is_ascii_alphanumeric() || c == '_')
+                                    || name.starts_with(|c: char| c.is_ascii_digit())
+                                    || !self.names.insert(name.clone())
+                                {
+                                    return Err(());
+                                }
+                            }
+                            c if "imsx-".contains(c) => {
+                                self.at -= 1;
+                                let mut on = true;
+                                let mut seen = std::collections::HashSet::new();
+                                let mut disabled = false;
+                                loop {
+                                    let flag = self.take()?;
+                                    if matches!(flag, 'i' | 'm' | 's' | 'x') {
+                                        if !seen.insert(flag) {
+                                            return Err(());
+                                        }
+                                        disabled |= !on;
+                                    }
+                                    match flag {
+                                        '-' if on => on = false,
+                                        'i' => inner.i = on,
+                                        'm' => inner.m = on,
+                                        's' => inner.s = on,
+                                        'x' => inner.x = on,
+                                        ':' if !seen.is_empty() && (on || disabled) => break,
+                                        ')' if on
+                                            && !seen.is_empty()
+                                            && out.is_empty()
+                                            && !nested =>
+                                        {
+                                            flags = inner;
+                                            break;
+                                        }
+                                        _ => return Err(()),
+                                    }
+                                    if self.chars[self.at - 1] == ')' {
+                                        break;
+                                    }
+                                }
+                                if self.chars[self.at - 1] == ')' {
+                                    repeatable = false;
+                                    continue;
+                                }
+                            }
+                            _ => return Err(()),
+                        }
+                    }
+                    out.push('(');
+                    out.push_str(&prefix);
+                    self.depth += 1;
+                    out.push_str(&self.group(inner, true)?);
+                    self.depth -= 1;
+                    out.push(')');
+                }
+                '[' => {
+                    out.push_str(&self.class(flags.i)?);
+                    repeatable = true;
+                    lazy = false;
+                }
+                '\\' => {
+                    repeatable = !matches!(self.peek(), Some('b' | 'B' | 'A' | 'Z'));
+                    lazy = false;
+                    out.push_str(&self.escape(flags.i, false)?);
+                }
+                '.' => {
+                    out.push_str(if flags.s { r"[\s\S]" } else { r"[^\n]" });
+                    repeatable = true;
+                    lazy = false;
+                }
+                '^' => {
+                    out.push_str(if flags.m { r"(?:\A|(?<=\n))" } else { r"\A" });
+                    repeatable = false;
+                    lazy = false;
+                }
+                '$' => {
+                    out.push_str(if flags.m { r"(?=\n|\z)" } else { r"(?=\n?\z)" });
+                    repeatable = false;
+                    lazy = false;
+                }
+                '|' => {
+                    out.push('|');
+                    repeatable = false;
+                    lazy = false;
+                }
+                '*' | '+' | '?' => {
+                    if c == '?' && lazy {
+                        out.push(c);
+                        lazy = false;
+                        continue;
+                    }
+                    if !repeatable {
+                        return Err(());
+                    }
+                    repeatable = false;
+                    lazy = true;
+                    // Possessive quantifiers are outside the supported subset.
+                    if matches!(c, '*' | '+' | '?') && self.peek() == Some('+') {
+                        return Err(());
+                    }
+                    out.push(c);
+                }
+                '{' => {
+                    if !repeatable {
+                        return Err(());
+                    }
+                    repeatable = false;
+                    lazy = true;
+                    out.push(c);
+                    loop {
+                        let c = self.take()?;
+                        out.push(c);
+                        if c == '}' {
+                            break;
+                        }
+                        if !c.is_ascii_digit() && c != ',' {
+                            return Err(());
+                        }
+                    }
+                    if self.peek() == Some('+') {
+                        return Err(());
+                    }
+                }
+                '}' => return Err(()),
+                c => {
+                    out.push_str(&literal(c, flags.i)?);
+                    repeatable = true;
+                    lazy = false;
+                }
+            }
+        }
+        if nested { Err(()) } else { Ok(out) }
+    }
+
+    fn escape(&mut self, ci: bool, class: bool) -> Result<String, ()> {
+        let c = self.take()?;
+        Ok(match c {
+            'w' => WORD.into(),
+            'W' => r"[^\p{L}\p{N}_]".into(),
+            's' => SPACE.into(),
+            'S' => format!("[^{SPACE}]"),
+            'd' => r"[\p{Nd}]".into(),
+            'D' => r"[^\p{Nd}]".into(),
+            'b' if class => r"\x08".into(),
+            'b' => format!(r"(?:(?<!{WORD})(?={WORD})|(?<={WORD})(?!{WORD}))"),
+            'B' if !class => format!(r"(?:(?<={WORD})(?={WORD})|(?<!{WORD})(?!{WORD}))"),
+            'A' if !class => r"\A".into(),
+            'Z' if !class => r"\z".into(),
+            'a' => r"\x07".into(),
+            'f' => r"\x0c".into(),
+            'n' => r"\x0a".into(),
+            'r' => r"\x0d".into(),
+            't' => r"\x09".into(),
+            'v' => r"\x0b".into(),
+            'x' | 'u' | 'U' => {
+                let n = match c {
+                    'x' => 2,
+                    'u' => 4,
+                    _ => 8,
+                };
+                let mut hex = String::new();
+                for _ in 0..n {
+                    let c = self.take()?;
+                    if !c.is_ascii_hexdigit() {
+                        return Err(());
+                    }
+                    hex.push(c);
+                }
+                let c = char::from_u32(u32::from_str_radix(&hex, 16).map_err(|_| ())?).ok_or(())?;
+                literal(c, ci)?
+            }
+            c if c.is_ascii_alphanumeric() => return Err(()),
+            c => literal(c, ci)?,
+        })
+    }
+
+    fn class(&mut self, ci: bool) -> Result<String, ()> {
+        let negative = self.peek() == Some('^');
+        if negative {
+            self.at += 1;
+        }
+        let mut atoms = Vec::new();
+        let mut first = true;
+        loop {
+            let c = self.take()?;
+            if c == ']' && !first {
+                break;
+            }
+            first = false;
+            match c {
+                '\\' => atoms.push((self.escape(false, true)?, false)),
+                '[' => return Err(()),
+                '-' => atoms.push((literal('-', false)?, true)),
+                c => atoms.push((literal(c, false)?, false)),
+            }
+        }
+        let mut body = String::new();
+        let mut i = 0;
+        while i < atoms.len() {
+            let atom = &atoms[i].0;
+            if i + 2 < atoms.len() && atoms[i + 1].1 {
+                // Categories are not case folded in Python, even inside
+                // classes. Only literal range endpoints can form a range.
+                if class_literal(atom).is_none() || class_literal(&atoms[i + 2].0).is_none() {
+                    return Err(());
+                }
+                let range = format!("[{atom}-{}]", atoms[i + 2].0);
+                body.push_str(&if ci { fold_class(&range)? } else { range });
+                i += 3;
+            } else {
+                if atoms[i].1 && i != 0 && i + 1 != atoms.len() {
+                    return Err(());
+                }
+                if ci && class_literal(atom).is_some() {
+                    body.push_str(&fold_class(&format!("[{atom}]"))?);
+                } else {
+                    body.push_str(atom);
+                }
+                i += 1;
+            }
+        }
+        Ok(format!("[{}{body}]", if negative { "^" } else { "" }))
+    }
+}
+
+fn class_literal(atom: &str) -> Option<char> {
+    let hir = regex_syntax::Parser::new().parse(atom).ok()?;
+    let regex_syntax::hir::HirKind::Literal(value) = hir.kind() else {
+        return None;
+    };
+    let text = std::str::from_utf8(&value.0).ok()?;
+    (text.chars().count() == 1)
+        .then(|| text.chars().next())
+        .flatten()
+}
+
+fn literal(c: char, ci: bool) -> Result<String, ()> {
+    let escaped = format!(r"\x{{{:x}}}", u32::from(c));
+    if ci {
+        fold_class(&format!("[{escaped}]"))
+    } else {
+        Ok(escaped)
+    }
+}
+
+fn fold_class(class: &str) -> Result<String, ()> {
+    use regex_syntax::hir::{Class, HirKind};
+    // Rust's simple fold follows Python except the extra dotted/dotless I.
+    let hir = regex_syntax::ParserBuilder::new()
+        .case_insensitive(true)
+        .build()
+        .parse(class)
+        .map_err(|_| ())?;
+    let set = match hir.kind() {
+        HirKind::Class(Class::Unicode(set)) => set.clone(),
+        HirKind::Literal(value) => {
+            let text = std::str::from_utf8(&value.0).map_err(|_| ())?;
+            let c = text.chars().next().ok_or(())?;
+            if text.chars().count() != 1 {
+                return Err(());
+            }
+            regex_syntax::hir::ClassUnicode::new([regex_syntax::hir::ClassUnicodeRange::new(c, c)])
+        }
+        _ => return Err(()),
+    };
+    let mut out = String::from("[");
+    let mut i = false;
+    for range in set.iter() {
+        out.push_str(&format!(
+            r"\x{{{:x}}}-\x{{{:x}}}",
+            u32::from(range.start()),
+            u32::from(range.end())
+        ));
+        i |= range.start() <= 'I' && 'I' <= range.end()
+            || range.start() <= 'i' && 'i' <= range.end()
+            || range.start() <= 'İ' && 'İ' <= range.end()
+            || range.start() <= 'ı' && 'ı' <= range.end();
+    }
+    if i {
+        out.push_str(r"Ii\x{130}\x{131}");
+    }
+    out.push(']');
+    Ok(out)
+}
+
+#[cfg(test)]
+mod python_tests {
+    use super::*;
+
+    #[test]
+    fn finditer_spans_match_real_python() {
+        for pattern in [
+            r"^|a",
+            r"a*?",
+            r"(?:|a)+",
+            r"a|",
+            r"\w*",
+            r"\b|\W+",
+            r"a$",
+            r"(?m)^|$",
+            r"(?s:.)*?",
+            r"(?i)[^I]+",
+            r"(?i:İ|ı|S|k)+",
+            r"[\s\S]",
+            r"(?i)[^\W]+",
+            r"(?i)[\w]+",
+            r"\D*\d?",
+            r"\Bz",
+            r"(?x) a + # comment",
+        ] {
+            for text in ["", "aa", "a\n", "a\n\n", "\u{301}aİıſK9\u{1c}\u{345}Ιι"] {
+                let output = std::process::Command::new("python3").args(["-I", "-c",
+                    "import re,sys; print(','.join(str(m.start())+':'+str(m.end()) for m in re.finditer(sys.argv[1],sys.argv[2])))", pattern, text]).output().unwrap();
+                assert!(output.status.success(), "span oracle failed");
+                let rule = PythonRule::compile(pattern, false).expect("supported span pattern");
+                let actual = rule
+                    .find_iter(text)
+                    .map(|m| {
+                        let (a, b) = m.unwrap();
+                        format!(
+                            "{}:{}",
+                            text[..a].chars().count(),
+                            text[..b].chars().count()
+                        )
+                    })
+                    .collect::<Vec<_>>()
+                    .join(",");
+                assert_eq!(actual, String::from_utf8(output.stdout).unwrap().trim());
+            }
+        }
+    }
+}
diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
index d97cb54e6..f63fb9f0f 100644
--- a/rust/crates/og-dev/src/personal_data.rs
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -37,7 +37,7 @@ use std::sync::LazyLock;
 use pycompat::mtime::fnmatch;
 use pycompat::num::py_strip;
 
-use crate::lookaround::Rule;
+use crate::lookaround::PythonRule as Rule;
 
 const USAGE: &str = "usage: og dev scan personal-data --root DIR --allow TEXT --skip TEXT [--patterns FILE] [--cached] [--] [FILE...]\n";
 
@@ -47,126 +47,133 @@ const SELF: &str = "scripts/ci/check-personal-data.sh";
 /// How many leading bytes are searched for a NUL to call a file binary.
 const BINARY_PROBE: usize = 8192;
 
-fn not_word(c: char) -> bool {
-    c.is_ascii_alphanumeric() || c == '_'
-}
-
-fn digit_or_dot(c: char) -> bool {
-    c.is_ascii_digit() || c == '.'
-}
+const STR_GENES: &str = "HTT|FMR1|C9orf72|C9ORF72|ATXN[0-9]+|DMPK|FXN|CNBP|RFC1|PABPN1|CACNA1A|TCF4|AR|PPP2R2B|TBP|JPH3|NOP56|ATN1|CSTB|AFF2|FMR2|NOTCH2NLC|DAB1|BEAN1|STARD7|YEATS2";
+const OCTET: &str = "(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])";
 
-fn digit_dot_slash(c: char) -> bool {
-    c.is_ascii_digit() || c == '.' || c == '/'
+/// Python has three distinct line operations here. Pattern files use text
+/// mode universal newlines; exception tables use str.splitlines(); scanned
+/// blobs are decoded from bytes and split on LF, preserving the last empty
+/// line. Keep the distinction in this one helper, including CRLF as one row.
+#[derive(Clone, Copy)]
+enum Lines {
+    Blob,
+    TextFile,
+    ExceptionTable,
 }
 
-/// `[A-Za-z]` under Python's `(?i)`, which also folds to the long s and
-/// the Kelvin sign, plus dotted and dotless I.
-fn letter_ci(c: char) -> bool {
-    c.is_ascii_alphabetic() || c == '\u{130}' || c == '\u{131}' || c == '\u{17F}' || c == '\u{212A}'
+fn lines(text: &str, mode: Lines) -> impl Iterator<Item = &str> {
+    let (mut rest, mut finished) = (text, false);
+    std::iter::from_fn(move || {
+        if finished || (rest.is_empty() && !matches!(mode, Lines::Blob)) {
+            return None;
+        }
+        let at = rest.char_indices().find(|&(_, c)| match mode {
+            Lines::Blob => c == '\n',
+            Lines::TextFile => matches!(c, '\n' | '\r'),
+            Lines::ExceptionTable => matches!(
+                c,
+                '\n' | '\r'
+                    | '\u{b}'
+                    | '\u{c}'
+                    | '\u{1c}'
+                    | '\u{1d}'
+                    | '\u{1e}'
+                    | '\u{85}'
+                    | '\u{2028}'
+                    | '\u{2029}'
+            ),
+        });
+        match at {
+            Some((i, c)) => {
+                let line = &rest[..i];
+                let mut end = i + c.len_utf8();
+                if c == '\r' && rest[end..].starts_with('\n') {
+                    end += 1;
+                }
+                rest = &rest[end..];
+                Some(line)
+            }
+            None => {
+                finished = true;
+                Some(rest)
+            }
+        }
+    })
 }
 
-const STR_GENES: &str = "HTT|FMR1|C9orf72|C9ORF72|ATXN[0-9]+|DMPK|FXN|CNBP|RFC1|PABPN1|CACNA1A|TCF4|AR|PPP2R2B|TBP|JPH3|NOP56|ATN1|CSTB|AFF2|FMR2|NOTCH2NLC|DAB1|BEAN1|STARD7|YEATS2";
-const OCTET: &str = "(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])";
-/// Python's `\s` also holds the four separators U+001C to U+001F.
-const SPACE: &str = r"\s\x1c-\x1f";
-
 /// A rule: its kind, its pattern, and a pattern the line must also match.
+#[derive(Clone)]
 struct Check {
     kind: &'static str,
     rule: Rule,
     cond: Option<&'static [Rule]>,
 }
 
-fn rule(pattern: &str, not_after: Option<fn(char) -> bool>) -> Rule {
-    Rule::python(pattern, not_after).expect("a valid built-in pattern")
+fn rule(pattern: &str) -> Rule {
+    Rule::compile(pattern, true).expect("a valid built-in pattern")
 }
 
-/// A sample label, which may carry a number after a separator: sample7,
-/// sample_01, donor-3; or a public sample id such as NA12878 or HG002.
-static LABEL: LazyLock<[Rule; 2]> = LazyLock::new(|| {
-    [
-        rule(
-            r"(?i)((?:sample|pat[iİı]ent|subject|proband|part[iİı]c[iİı]pant|[iİı]nd[iİı]v[iİı]dual|donor)s?(?:[_-]?[0-9]+)?)(?:[^A-Za-zİı]|$)",
-            Some(letter_ci),
-        ),
-        rule(r"\b(?:NA|HG)[0-9]{3,5}\b", None),
-    ]
+static LABEL: LazyLock<[Rule; 1]> = LazyLock::new(|| {
+    [rule(
+        r"(?:(?i:(?<![A-Za-z])(?:sample|patient|subject|proband|participant|individual|donor)s?(?:[_-]?[0-9]+)?(?![A-Za-z]))|\b(?:NA|HG)[0-9]{3,5}\b)",
+    )]
 });
+static REPCN: LazyLock<[Rule; 1]> = LazyLock::new(|| [rule(r"\bREPCN\b")]);
 
-static REPCN: LazyLock<[Rule; 1]> = LazyLock::new(|| [rule(r"\bREPCN\b", None)]);
-
-/// The built-in rules, in the order they are reported. Each pattern marks
-/// only the leaked value, so an allowed example covers just its span.
+/// Built-ins use the same compiler and iterator as custom patterns.
 fn builtin() -> Vec<Check> {
-    let gt = r"\(?[ACGTDI][/|;]?[ACGTDI]\)?";
-    vec![
-        Check {
-            kind: "home",
-            rule: rule(
-                r"/home/[A-Za-z]|/Users/[A-Za-z]|/mnt/use[r]\b|[A-Za-z]:\\\\?Users\\\\?[A-Za-z]",
-                Some(not_word),
-            ),
-            cond: None,
-        },
-        Check {
-            kind: "address",
-            rule: rule(
-                &format!(
-                    r"((?:10\.{OCTET}|172\.(?:1[6-9]|2[0-9]|3[01])|192\.168|100\.(?:6[4-9]|[7-9][0-9]|1[01][0-9]|12[0-7]))\.{OCTET}\.{OCTET})(?:$|\.$|\.[^0-9]|[^0-9.])"
-                ),
-                Some(digit_or_dot),
-            ),
-            cond: None,
-        },
-        Check {
-            kind: "address",
-            rule: rule(r"[A-Za-z0-9-]\.ts\.net\b", None),
-            cond: None,
-        },
-        Check {
-            kind: "diplotype",
-            rule: rule(r"\*[0-9]+[A-Za-z0-9.]*/\*[0-9]+", None),
-            cond: Some(&*LABEL),
-        },
-        Check {
-            kind: "rsid",
-            rule: rule(
-                &format!(r#"(\brs[0-9]+\b[{SPACE}:=,;|`'"\[\]-]{{1,6}}{gt})(?:[^A-Za-z0-9]|$)"#),
-                None,
-            ),
-            cond: None,
-        },
-        Check {
-            kind: "rsid",
-            rule: rule(
-                r"\brs[0-9]+\t[0-9XYMT]{1,2}\t[0-9]+\t[ACGTDI-]{1,2}\b",
-                None,
-            ),
-            cond: None,
-        },
-        Check {
-            kind: "repeat",
-            rule: rule(
-                r"([0-9]{1,4}/[0-9]{1,4})(?:[^0-9/]|$)",
-                Some(digit_dot_slash),
-            ),
-            cond: Some(&*REPCN),
-        },
-        // Python: \b(?:GENES)\b[^/\n]{0,40}?(?<![0-9.])N/N(?![0-9/]). The
-        // gap after the gene is never empty (a digit right after a gene
-        // name is no word boundary), so its last character carries the
-        // look-behind.
-        Check {
-            kind: "repeat",
-            rule: rule(
-                &format!(
-                    r"(\b(?:{STR_GENES})\b[^/\n]{{0,39}}?[^/\n0-9.][0-9]{{1,4}}/[0-9]{{1,4}})(?:[^0-9/]|$)"
+    static RULES: LazyLock<Vec<Check>> = LazyLock::new(|| {
+        let gt = r"\(?[ACGTDI][/|;]?[ACGTDI]\)?(?![A-Za-z0-9])";
+        vec![
+            Check {
+                kind: "home",
+                rule: rule(
+                    r"(?<![A-Za-z0-9_])(?:/home/[A-Za-z]|/Users/[A-Za-z]|/mnt/use[r]\b|[A-Za-z]:\\\\?Users\\\\?[A-Za-z])",
                 ),
-                None,
-            ),
-            cond: None,
-        },
-    ]
+                cond: None,
+            },
+            Check {
+                kind: "address",
+                rule: rule(&format!(
+                    r"(?<![0-9.])(?:10\.{OCTET}|172\.(?:1[6-9]|2[0-9]|3[01])|192\.168|100\.(?:6[4-9]|[7-9][0-9]|1[01][0-9]|12[0-7]))\.{OCTET}\.{OCTET}(?![0-9]|\.[0-9])"
+                )),
+                cond: None,
+            },
+            Check {
+                kind: "address",
+                rule: rule(r"[A-Za-z0-9-]\.ts\.net\b"),
+                cond: None,
+            },
+            Check {
+                kind: "diplotype",
+                rule: rule(r"\*[0-9]+[A-Za-z0-9.]*/\*[0-9]+"),
+                cond: Some(&*LABEL),
+            },
+            Check {
+                kind: "rsid",
+                rule: rule(&format!(r#"\brs[0-9]+\b[\s:=,;|`'"\[\]-]{{1,6}}{gt}"#)),
+                cond: None,
+            },
+            Check {
+                kind: "rsid",
+                rule: rule(r"\brs[0-9]+\t[0-9XYMT]{1,2}\t[0-9]+\t[ACGTDI-]{1,2}\b"),
+                cond: None,
+            },
+            Check {
+                kind: "repeat",
+                rule: rule(r"(?<![0-9./])[0-9]{1,4}/[0-9]{1,4}(?![0-9/])"),
+                cond: Some(&*REPCN),
+            },
+            Check {
+                kind: "repeat",
+                rule: rule(&format!(
+                    r"\b(?:{STR_GENES})\b[^/\n]{{0,40}}?(?<![0-9.])[0-9]{{1,4}}/[0-9]{{1,4}}(?![0-9/])"
+                )),
+                cond: None,
+            },
+        ]
+    });
+    RULES.clone()
 }
 
 /// The arguments.
@@ -204,20 +211,22 @@ fn parse(args: &[String]) -> Result<Args, String> {
         }
     }
     let root = root.ok_or("--root is required")?;
-    let allow = allow
-        .ok_or("--allow is required")?
-        .lines()
-        .filter(|l| !l.trim().is_empty())
+    let allow_text = allow.ok_or("--allow is required")?;
+    let allow = lines(&allow_text, Lines::ExceptionTable)
+        .filter(|l| !py_strip(l).is_empty())
         .map(|l| {
             let l = py_strip(l);
             let (path, text) = l.split_once(' ').unwrap_or((l, ""));
             (path.to_owned(), py_strip(text).to_owned())
         })
         .collect();
-    let skip = skip
-        .ok_or("--skip is required")?
-        .lines()
-        .filter_map(|l| l.split_whitespace().next().map(str::to_owned))
+    let skip_text = skip.ok_or("--skip is required")?;
+    let skip = lines(&skip_text, Lines::ExceptionTable)
+        .filter_map(|l| {
+            pycompat::text::split(l, None, None)
+                .first()
+                .map(|s| (*s).to_owned())
+        })
         .collect();
     Ok(Args {
         root: PathBuf::from(root),
@@ -233,16 +242,16 @@ fn parse(args: &[String]) -> Result<Args, String> {
 fn own_rules(path: &str) -> Result<Vec<Check>, String> {
     let text = std::fs::read_to_string(path).map_err(|e| format!("cannot read {path}: {e}"))?;
     let mut out = Vec::new();
-    for (line, l) in text.lines().enumerate() {
+    for (line, l) in lines(&text, Lines::TextFile).enumerate() {
         let p = py_strip(l);
         if p.is_empty() || l.starts_with('#') {
             continue;
         }
         // Rule reports capture 1 for the built-in look-around patterns.
         // A user's captures must not narrow the span checked against ALLOW.
-        let rule = Rule::whole_match(p).map_err(|_| {
+        let rule = Rule::compile(p, false).map_err(|_| {
             format!(
-                "{}:{}: invalid custom pattern",
+                "{}:{}: invalid or unsupported custom pattern",
                 path.escape_debug(),
                 line + 1
             )
@@ -358,31 +367,41 @@ fn report(out: &mut dyn Write, kind: &str, rel: &str, n: usize) {
 }
 
 /// Scans one file's text; true when something was reported.
-fn scan_text(out: &mut dyn Write, rules: &[Check], texts: &[&str], rel: &str, data: &[u8]) -> bool {
+fn scan_text(
+    out: &mut dyn Write,
+    rules: &[Check],
+    texts: &[&str],
+    rel: &str,
+    data: &[u8],
+) -> Result<bool, ()> {
     let mut bad = false;
     let text = String::from_utf8_lossy(data);
-    for (i, line) in text.split('\n').enumerate() {
+    for (i, line) in lines(&text, Lines::Blob).enumerate() {
         let spans: Vec<(usize, usize)> = texts
             .iter()
             .flat_map(|t| line.match_indices(*t).map(|(a, s)| (a, a + s.len())))
             .collect();
         for c in rules {
-            if c.cond
-                .is_some_and(|cs| !cs.iter().any(|r| r.is_match(line)))
-            {
-                continue;
+            if let Some(conditions) = c.cond {
+                let mut matched = false;
+                for condition in conditions {
+                    matched |= condition.is_match(line)?;
+                }
+                if !matched {
+                    continue;
+                }
             }
-            let leaked = c
-                .rule
-                .find_iter(line)
-                .find(|&(s, e)| !spans.iter().any(|&(a, b)| a <= s && e <= b));
-            if leaked.is_some() {
-                report(out, c.kind, rel, i + 1);
-                bad = true;
+            for found in c.rule.find_iter(line) {
+                let (s, e) = found?;
+                if !spans.iter().any(|&(a, b)| a <= s && e <= b) {
+                    report(out, c.kind, rel, i + 1);
+                    bad = true;
+                    break;
+                }
             }
         }
     }
-    bad
+    Ok(bad)
 }
 
 fn run(a: &Args, out: &mut dyn Write) -> Result<bool, String> {
@@ -447,7 +466,12 @@ fn run(a: &Args, out: &mut dyn Write) -> Result<bool, String> {
             .filter(|(p, _)| rel == SELF || fnmatch(rel, p))
             .map(|(_, t)| t.as_str())
             .collect();
-        bad |= scan_text(out, &rules, &texts, rel, &data);
+        bad |= scan_text(out, &rules, &texts, rel, &data).map_err(|()| {
+            format!(
+                "{}: pattern matching could not complete",
+                rel.escape_debug()
+            )
+        })?;
     }
     let _ = writeln!(out, "scanned {scanned} text files");
     if scanned == 0 {
@@ -486,11 +510,11 @@ mod tests {
         let mut out = Vec::new();
         for c in &rules {
             if c.cond
-                .is_some_and(|cs| !cs.iter().any(|r| r.is_match(line)))
+                .is_some_and(|cs| !cs.iter().any(|r| r.is_match(line).unwrap()))
             {
                 continue;
             }
-            if c.rule.is_match(line) {
+            if c.rule.is_match(line).unwrap() {
                 out.push(c.kind);
             }
         }
@@ -558,21 +582,9 @@ mod tests {
         let rules = builtin();
         let ex = p("(`/mnt/u~ser/`, `/ho~me/username/`, etc.)");
         let mut out = Vec::new();
-        assert!(!scan_text(
-            &mut out,
-            &rules,
-            &[ex.as_str()],
-            "x.md",
-            ex.as_bytes()
-        ));
+        assert!(!scan_text(&mut out, &rules, &[ex.as_str()], "x.md", ex.as_bytes()).unwrap());
         let line = p(&format!("{ex} see /home/~bob/x"));
-        assert!(scan_text(
-            &mut out,
-            &rules,
-            &[ex.as_str()],
-            "x.md",
-            line.as_bytes()
-        ));
+        assert!(scan_text(&mut out, &rules, &[ex.as_str()], "x.md", line.as_bytes()).unwrap());
         let got = String::from_utf8(out).unwrap();
         assert!(got.starts_with("FAIL home      x.md:1"), "{got}");
     }
@@ -591,16 +603,19 @@ mod tests {
 
         let line = b"PREFIX PUBLIC SUFFIX";
         let mut out = Vec::new();
-        assert!(scan_text(&mut out, &rules, &["PUBLIC"], "x.md", line));
+        assert!(scan_text(&mut out, &rules, &["PUBLIC"], "x.md", line).unwrap());
         let got = String::from_utf8(out).unwrap();
         assert_eq!(got.lines().count(), 5, "{got}");
-        assert!(!scan_text(
-            &mut Vec::new(),
-            &rules,
-            &["PREFIX PUBLIC SUFFIX"],
-            "x.md",
-            line,
-        ));
+        assert!(
+            !scan_text(
+                &mut Vec::new(),
+                &rules,
+                &["PREFIX PUBLIC SUFFIX"],
+                "x.md",
+                line,
+            )
+            .unwrap()
+        );
     }
 
     struct Fixture(PathBuf);
@@ -635,7 +650,14 @@ mod tests {
         oracle_options(f, files, cached, "", "", "")
     }
 
-    fn oracle_options(f: &Fixture, files: &[&str], cached: bool, allow: &str, skip: &str, patterns: &str) -> String {
+    fn oracle_options(
+        f: &Fixture,
+        files: &[&str],
+        cached: bool,
+        allow: &str,
+        skip: &str,
+        patterns: &str,
+    ) -> String {
         static PYTHON: LazyLock<String> = LazyLock::new(|| {
             const SHA: &str = "4104a93f2121b457413336574b8563fe85291fd7";
             let repo = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../..");
@@ -680,9 +702,12 @@ mod tests {
                 )
         });
         let mut cmd = Command::new("python3");
-        cmd.args(["-I", "-c", &PYTHON])
-            .arg(&f.0)
-            .args([allow, skip, patterns, if cached { "1" } else { "" }]);
+        cmd.args(["-I", "-c", &PYTHON]).arg(&f.0).args([
+            allow,
+            skip,
+            patterns,
+            if cached { "1" } else { "" },
+        ]);
         for file in files {
             cmd.arg(f.0.join(file));
         }
@@ -699,12 +724,22 @@ mod tests {
         assert_options(f, files, cached, "", "", "", true);
     }
 
-    fn assert_options(f: &Fixture, files: &[&str], cached: bool, allow: &str, skip: &str, patterns: &str, require_finding: bool) {
+    fn assert_options(
+        f: &Fixture,
+        files: &[&str],
+        cached: bool,
+        allow: &str,
+        skip: &str,
+        patterns: &str,
+        require_finding: bool,
+    ) {
         let expected = oracle_options(f, files, cached, allow, skip, patterns);
         let mut args = f.args(files);
         args[3] = allow.into();
         args[5] = skip.into();
-        if !patterns.is_empty() { args.extend(["--patterns".into(), patterns.into()]); }
+        if !patterns.is_empty() {
+            args.extend(["--patterns".into(), patterns.into()]);
+        }
         if cached {
             args.insert(0, "--cached".into());
         }
@@ -714,6 +749,7 @@ mod tests {
         assert!(err.is_empty(), "unexpected scanner diagnostic");
         let reported: std::collections::HashSet<_> = out.lines().collect();
         let mut count = 0;
+        let mut required_reports = Vec::new();
         for line in expected.lines().filter(|l| l.starts_with('[')) {
             let pycompat::json::Value::Array(row) = pycompat::json::loads(line).unwrap() else {
                 panic!("metadata")
@@ -732,9 +768,23 @@ mod tests {
                 reported.contains(finding.as_str()),
                 "missing oracle finding #{count}"
             );
+            required_reports.push(finding);
             count += 1;
         }
-        if require_finding { assert!(count > 0, "oracle control was clean"); }
+        let mut actual_reports: Vec<_> = out
+            .lines()
+            .filter(|l| l.starts_with("FAIL "))
+            .map(str::to_owned)
+            .collect();
+        actual_reports.sort();
+        required_reports.sort();
+        assert_eq!(
+            actual_reports, required_reports,
+            "scanner metadata multiset differs"
+        );
+        if require_finding {
+            assert!(count > 0, "oracle control was clean");
+        }
         assert_eq!(code, u8::from(count > 0));
         assert_eq!(
             out.lines().filter(|l| l.starts_with("FAIL ")).count(),
@@ -885,18 +935,51 @@ mod tests {
         let f = Fixture::new("r2-boundary");
         std::fs::write(f.0.join("chip.md"), "rs987654\t1\t9\tA-\n").unwrap();
         assert_oracle_findings(&f, &["chip.md"], false);
-        assert!(Command::new("git").arg("-C").arg(&f.0).args(["init", "-q"]).status().unwrap().success());
-        assert!(Command::new("git").arg("-C").arg(&f.0).args(["add", "chip.md"]).status().unwrap().success());
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(&f.0)
+                .args(["init", "-q"])
+                .status()
+                .unwrap()
+                .success()
+        );
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(&f.0)
+                .args(["add", "chip.md"])
+                .status()
+                .unwrap()
+                .success()
+        );
         assert_oracle_findings(&f, &["chip.md"], true);
+        assert_oracle_findings(&f, &[], false);
+        assert_oracle_findings(&f, &[], true);
     }
 
     #[test]
     fn round2_custom_unicode() {
         let f = Fixture::new("r2-custom");
-        for (pattern, text) in [(r"\bZetaSecret\b", "\u{301}ZetaSecret"), (r"(?i)patient", "patİent"), (r"(?i)[A-Z]+", "İı"), (r"\s+", "\u{1c}"), (r"\W+", "\u{301}"), (r"[^\w]+", "\u{301}")] {
+        for (pattern, text) in [
+            (r"\bZetaSecret\b", "\u{301}ZetaSecret"),
+            (r"(?i)patient", "patİent"),
+            (r"(?i)[A-Z]+", "İı"),
+            (r"\s+", "\u{1c}"),
+            (r"\W+", "\u{301}"),
+            (r"[^\w]+", "\u{301}"),
+        ] {
             std::fs::write(f.0.join("patterns"), pattern).unwrap();
             std::fs::write(f.0.join("own.md"), text).unwrap();
-            assert_options(&f, &["own.md"], false, "", "", f.0.join("patterns").to_str().unwrap(), true);
+            assert_options(
+                &f,
+                &["own.md"],
+                false,
+                "",
+                "",
+                f.0.join("patterns").to_str().unwrap(),
+                true,
+            );
         }
     }
 
@@ -904,9 +987,21 @@ mod tests {
     fn round2_cr_patterns() {
         let f = Fixture::new("r2-pattern-lines");
         for prefix in ["# a comment", "Unrelated"] {
-            std::fs::write(f.0.join("patterns"), format!("{prefix}\rZETA_PRIVATE_MARKER\r")).unwrap();
+            std::fs::write(
+                f.0.join("patterns"),
+                format!("{prefix}\rZETA_PRIVATE_MARKER\r"),
+            )
+            .unwrap();
             std::fs::write(f.0.join("own.md"), "ZETA_PRIVATE_MARKER\n").unwrap();
-            assert_options(&f, &["own.md"], false, "", "", f.0.join("patterns").to_str().unwrap(), true);
+            assert_options(
+                &f,
+                &["own.md"],
+                false,
+                "",
+                "",
+                f.0.join("patterns").to_str().unwrap(),
+                true,
+            );
         }
     }
 
@@ -915,7 +1010,15 @@ mod tests {
         let f = Fixture::new("r2-empty");
         std::fs::write(f.0.join("patterns"), "^|PUBLIC_PRIVATE\n").unwrap();
         std::fs::write(f.0.join("own.md"), "PUBLIC_PRIVATE").unwrap();
-        assert_options(&f, &["own.md"], false, "own.md PUBLIC", "", f.0.join("patterns").to_str().unwrap(), true);
+        assert_options(
+            &f,
+            &["own.md"],
+            false,
+            "own.md PUBLIC",
+            "",
+            f.0.join("patterns").to_str().unwrap(),
+            true,
+        );
     }
 
     #[test]
@@ -923,7 +1026,156 @@ mod tests {
         let f = Fixture::new("r2-allow");
         let text = p("safe\rOTHER.md /home/~synthetic_private_marker/path\n");
         std::fs::write(f.0.join("builtin-allow.md"), &text).unwrap();
-        assert_options(&f, &["builtin-allow.md"], false, &format!("builtin-allow.md {text}"), "", "", true);
+        assert_options(
+            &f,
+            &["builtin-allow.md"],
+            false,
+            &format!("builtin-allow.md {text}"),
+            "",
+            "",
+            true,
+        );
+    }
+
+    #[test]
+    fn round2_generated_patterns_and_tables() {
+        let f = Fixture::new("r2-grammar");
+        std::fs::write(f.0.join("clean.md"), "clean").unwrap();
+        let atoms = [
+            "PUBLIC",
+            "patient",
+            r"\w",
+            r"\W",
+            r"\s",
+            r"\S",
+            r"\d",
+            r"\D",
+            "[A-Z]",
+            r"[^\w]",
+            r"\bZetaSecret\b",
+            r"\BZetaSecret",
+        ];
+        let quantifiers = ["", "?", "+", "*", "{1,2}", "{0,2}?"];
+        let noise = [
+            "", "\u{301}", "\u{200c}", "\u{200d}", "\u{1c}", "\u{85}", "\u{2028}", "\u{2029}",
+            "İı", "ſK", "²", "_", "\t",
+        ];
+        let separators = [
+            "\n", "\r\n", "\r", "\u{85}", "\u{2028}", "\u{2029}", "\u{b}", "\u{1c}",
+        ];
+        let mut seed = 0x2d5ca1ab1eu64;
+        let mut next = || {
+            seed ^= seed << 13;
+            seed ^= seed >> 7;
+            seed ^= seed << 17;
+            seed as usize
+        };
+        for case in 0..96 {
+            let atom = if case < atoms.len() {
+                atoms[case]
+            } else {
+                atoms[next() % atoms.len()]
+            };
+            let quantified = format!("(?:{atom}){}", quantifiers[next() % quantifiers.len()]);
+            let expression = if case < atoms.len() {
+                atom.to_owned()
+            } else {
+                match next() % 4 {
+                    0 => quantified,
+                    1 => format!("^(?:{quantified})"),
+                    2 => format!("(?:{quantified})$"),
+                    _ => format!("^|{quantified}|PUBLIC_PRIVATE"),
+                }
+            };
+            let pattern = format!("{}{expression}", if next() % 2 == 0 { "(?i)" } else { "" });
+            // Unicode separators are pattern characters, not text-mode
+            // newlines. Only CR, CRLF and LF separate pattern-file rows.
+            let sep = if case < atoms.len() {
+                "\n"
+            } else {
+                separators[case % separators.len()]
+            };
+            std::fs::write(
+                f.0.join("patterns"),
+                format!("# comment{sep}{pattern}{sep}Unrelated{sep}"),
+            )
+            .unwrap();
+            let mut text = String::from("PUBLIC_PRIVATE\n");
+            for value in noise {
+                text.push_str(value);
+                text.push('\n');
+            }
+            for _ in 0..24 {
+                text.push_str(noise[next() % noise.len()]);
+                text.push_str(
+                    [
+                        "ZetaSecret",
+                        "PUBLIC_PRIVATE",
+                        "patİent",
+                        "İı",
+                        "a9",
+                        "\u{1c}",
+                    ][next() % 6],
+                );
+                text.push_str(noise[next() % noise.len()]);
+                text.push_str(separators[next() % separators.len()]);
+            }
+            for ending in ["A-", "-A", "--", "AA", "A"] {
+                text.push_str(&format!("rs987654\t1\t9\t{ending}\n"));
+            }
+            std::fs::write(f.0.join("own.md"), text).unwrap();
+            let allow = format!("own.md PUBLIC{sep}OTHER.md PRIVATE{sep}own.md Zeta");
+            let skip = format!("missing.md reason{sep}OTHER.md reason");
+            assert_options(
+                &f,
+                &["own.md", "clean.md"],
+                false,
+                &allow,
+                &skip,
+                f.0.join("patterns").to_str().unwrap(),
+                false,
+            );
+        }
+        // Cross-file scope and SKIP parsing, with a scanned clean companion.
+        for sep in separators {
+            let secret = p("safe /home/~synthetic/path");
+            std::fs::write(f.0.join("own.md"), &secret).unwrap();
+            let allow = format!("own.md safe{sep}OTHER.md {}", p("/home/~synthetic/path"));
+            assert_options(&f, &["own.md", "clean.md"], false, &allow, "", "", true);
+            let skip = format!("missing.md reason{sep}own.md reason");
+            assert_options(&f, &["own.md", "clean.md"], false, "", &skip, "", false);
+        }
     }
 
+    #[test]
+    fn round2_unsupported_and_exhausted_patterns_fail_closed() {
+        let f = Fixture::new("r2-unsupported");
+        std::fs::write(f.0.join("own.md"), format!("{}!", "a".repeat(64))).unwrap();
+        for (index, pattern) in [
+            r"\b*",
+            r"(?i)*",
+            r"(?P<a>x)(?P<a>y)",
+            r"(?=PRIVATE)",
+            r"(PRIVATE)\1",
+            r"\p{L}",
+            r"[[:alpha:]]",
+            r"(?a)PRIVATE",
+            r"\N{LATIN CAPITAL LETTER A}",
+            r"(a|\Ba)+$",
+        ]
+        .into_iter()
+        .enumerate()
+        {
+            std::fs::write(f.0.join("patterns"), pattern).unwrap();
+            let mut args = f.args(&["own.md"]);
+            args.extend([
+                "--patterns".into(),
+                f.0.join("patterns").display().to_string(),
+            ]);
+            let (mut out, mut err) = (Vec::new(), Vec::new());
+            assert_eq!(cli(&args, &mut out, &mut err), 2, "control {index}");
+            assert!(!String::from_utf8_lossy(&err).contains("PRIVATE"));
+            assert!(!String::from_utf8_lossy(&out).contains("PRIVATE"));
+        }
+    }
 }
diff --git a/scripts/ci/check-personal-data.sh b/scripts/ci/check-personal-data.sh
index 82aed5c92..3d7781bce 100755
--- a/scripts/ci/check-personal-data.sh
+++ b/scripts/ci/check-personal-data.sh
@@ -32,9 +32,25 @@
 #                                                 and require each to be caught
 #
 # Your own identifiers (names, sample ids, hostnames) do not belong in this
-# public file. Put one regular expression per line (the syntax of Rust's
-# regex crate, close to POSIX extended) in a file outside the repository and
-# point PERSONAL_DATA_PATTERNS at it; each match is reported as kind "own".
+# public file. Put one Python-subset regular expression per text-file line
+# outside the repository and point PERSONAL_DATA_PATTERNS at it. Each match
+# is reported as kind "own". CRLF, CR and LF separate pattern-file lines.
+#
+# Supported: literals, dot, character classes and ranges (including negated
+# classes), \b \B \w \W \s \S \d \D, ^ $ \A \Z, alternation, capturing,
+# named (?P<name>...) and noncapturing groups, greedy and lazy ? * + {m,n},
+# and global or scoped i/m/s/x flags. Hex \xHH, \uHHHH and \UHHHHHHHH and
+# standard control escapes are supported. Unicode word characters, spaces
+# and simple case folding follow Python, including dotted and dotless I.
+# Empty matches follow Python 3.14+ finditer, including a nonempty match at
+# the same position. Captures never narrow the span checked against ALLOW.
+#
+# Backreferences, look-around in custom patterns, conditionals, atomic or
+# possessive groups, ASCII/locale flags, named Unicode and octal escapes,
+# nested/POSIX classes and other engine extensions are unsupported. Patterns
+# over 16 KiB or with more than 64 nested groups are rejected. Unsupported
+# syntax, invalid patterns and a matcher resource-limit error stop the scan
+# with exit 2 and a diagnostic that omits the pattern and scanned values.
 #
 # The scan is og dev scan personal-data (rust/crates/og-dev); bin/og runs
 # the build scripts/setup.sh --og puts in bin/.og for this machine, and OG

From 0e0ba11bd114bb1c417feb8a099ab8d2ff9682d3 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 15:33:10 +0100
Subject: [PATCH 43/76] fix(traits): keep shared sites independent and stage
 both outputs

Exercise the three named fault controls in Guard before testing the restored source. Retain the local red log as reviewable evidence.

Bead: pgp-bs9u.25
---
 .github/workflows/guard.yml                 |  23 +++
 CHANGELOG.md                                |   2 +-
 rust/crates/og-steps/src/traits.rs          | 155 +++++++++++++++++---
 tests/e2e/rust-c2b-traits.sh                |   1 +
 tests/parity/cases.tsv                      |   1 +
 tests/parity/evidence/rust-c2b-controls.txt |  69 +++++++++
 tests/parity/gen/traits.sh                  |  16 +-
 tests/parity/remnants.tsv                   |   2 +-
 tests/test_copy_number.py                   |   3 +-
 tests/test_render_report.py                 |   2 -
 tests/test_traits_report.py                 |   3 +-
 tests/test_traits_table.py                  |  35 +----
 12 files changed, 252 insertions(+), 60 deletions(-)
 create mode 100644 tests/parity/evidence/rust-c2b-controls.txt

diff --git a/.github/workflows/guard.yml b/.github/workflows/guard.yml
index 7ee58a0dc..66800c3a5 100644
--- a/.github/workflows/guard.yml
+++ b/.github/workflows/guard.yml
@@ -279,6 +279,29 @@ jobs:
           grep -E 'planted_failure.*FAILED' "$log" || { cat "$log"; echo "ERROR: the run failed, but not on the planted test"; exit 1; }
           echo "Control: the planted test failed, as it must."
 
+      - name: Traits controls (diplotype order, REF check and missing phase rows)
+        env:
+          CARGO_BUILD_JOBS: 3
+        run: |
+          src=crates/og-steps/src/traits.rs
+          saved="${RUNNER_TEMP}/traits.rs"
+          log="${RUNNER_TEMP}/traits-controls.log"
+          cp -f "$src" "$saved"
+          trap 'cp -f "$saved" "$src"' EXIT
+          perl -0pi -e 's/(fn allowed\b.*?)(\n    out\n)/$1\n    out.reverse();$2/s; s/if c\[2\]\.chars\(\)\.next\(\) != s\.row\["ref"\]\.chars\(\)\.next\(\)/if c[2].is_empty()/; s/(fn phase_vcf\b.*?)(    let mut out = AtomicFile::create\(path\))/$1    sites.clear();\n$2/s' "$src"
+          cmp -s "$saved" "$src" && { echo "ERROR: no traits control was planted"; exit 1; }
+          if cargo test --locked -p og-steps traits::tests --no-fail-fast > "$log" 2>&1; then
+            cat "$log"
+            echo "ERROR: traits accepted the planted faults"
+            exit 1
+          fi
+          cat "$log"
+          for test in apoe_grid_keeps_haplotype_order_and_missing_calls stream_prefers_first_snv_but_checks_every_ref_and_bounds_memory phase_requires_one_block_and_only_multiple_hets_are_exported; do
+            grep -E "traits::tests::${test} .*FAILED" "$log" || { echo "ERROR: $test did not catch its fault"; exit 1; }
+          done
+          cp -f "$saved" "$src"
+          trap - EXIT
+
       - name: cargo test
         run: cargo test --workspace --locked --no-fail-fast
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8400d72da..b6245e959 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,7 +4,7 @@ Each release's notes. From 1.0.0 on, a major or minor release has hand-written n
 
 ## Unreleased
 
-- Step 42 reads traits and genotype rules with `og traits table`, exports WhatsHap sites with `og traits phase-sites`, and checks the catalogs with `og traits check`. The replaced Python evaluator is removed. Report columns and readings stay the same. Genotypes outside the catalog are streamed past, and write errors now report a controlled error instead of a traceback.
+- Step 42 reads traits and genotype rules with `og traits table`, exports WhatsHap sites with `og traits phase-sites`, and checks the catalogs with `og traits check`. The replaced Python evaluator is removed. Report columns and readings stay the same. Genotypes outside the catalog are streamed past, and write errors now report a controlled error with the path instead of a traceback. Both tables are staged before either is published, so an unwritable second output leaves the previous traits table intact.
 - The unused Python copy-number engine is removed. Its historical catalog tests materialise a pinned test oracle and keep testing the Rust commands.
 
 
diff --git a/rust/crates/og-steps/src/traits.rs b/rust/crates/og-steps/src/traits.rs
index 40c3db950..d537e672a 100644
--- a/rust/crates/og-steps/src/traits.rs
+++ b/rust/crates/og-steps/src/traits.rs
@@ -112,7 +112,10 @@ fn row(keys: &[&str], values: &[String]) -> Row {
 }
 fn records(path: &str) -> Result<Vec<(usize, Vec<String>)>> {
     // Parse even the header as a CSV record. Comments do not enter the parser.
-    let mut lines = Lines::new(og_io::open(path).map_err(|e| e.to_string())?, Utf8::Strict);
+    let mut lines = Lines::new(
+        og_io::open(path).map_err(|e| og_filters::os_error(&e, path))?,
+        Utf8::Strict,
+    );
     let mut text = String::new();
     let mut number = 0;
     let mut out = Vec::new();
@@ -534,13 +537,48 @@ fn check_rules(rules: &[Rule], rows: Option<&[Site]>) -> Vec<String> {
     e
 }
 
+// A locus may be reused by rules with different alternate alleles. The
+// selected record is shared, but each site's allele vocabulary is its own.
+fn genotype(site: &Site, records: &Genotypes) -> SiteGt {
+    let mut gt = records.get(&site.key()).cloned().unwrap_or_default();
+    if gt.status == Status::NotCovered {
+        return gt;
+    }
+    gt.alleles.sort_by_key(|a| {
+        (
+            if a == &site.row["ref"] {
+                0
+            } else if a == &site.row["alt"] {
+                1
+            } else {
+                2
+            },
+            a.clone(),
+        )
+    });
+    gt.status = if gt.alleles.len() == 2
+        && gt
+            .alleles
+            .iter()
+            .all(|a| a == &site.row["ref"] || a == &site.row["alt"])
+    {
+        Status::Called
+    } else {
+        Status::OtherAllele
+    };
+    gt
+}
+
 fn read_genotypes(path: &str, sites: &[&Site]) -> Result<Genotypes> {
     let mut wanted: HashMap<Key, Vec<&Site>> = HashMap::new();
     for s in sites {
         wanted.entry(s.key()).or_default().push(s);
     }
     let mut result = HashMap::new();
-    let mut lines = Lines::new(og_io::open(path).map_err(|e| e.to_string())?, Utf8::Strict);
+    let mut lines = Lines::new(
+        og_io::open(path).map_err(|e| og_filters::os_error(&e, path))?,
+        Utf8::Strict,
+    );
     let mut line = String::new();
     let mut n = 0;
     while lines.read_line(&mut line).map_err(|e| e.to_string())? {
@@ -613,7 +651,10 @@ fn read_genotypes(path: &str, sites: &[&Site]) -> Result<Genotypes> {
     Ok(result)
 }
 fn read_phased(path: &str, wanted: &HashSet<Key>) -> Result<Phased> {
-    let mut lines = Lines::new(og_io::open(path).map_err(|e| e.to_string())?, Utf8::Strict);
+    let mut lines = Lines::new(
+        og_io::open(path).map_err(|e| og_filters::os_error(&e, path))?,
+        Utf8::Strict,
+    );
     let mut text = String::new();
     let mut out = HashMap::new();
     while lines.read_line(&mut text).map_err(|e| e.to_string())? {
@@ -657,11 +698,7 @@ fn read_phased(path: &str, wanted: &HashSet<Key>) -> Result<Phased> {
     Ok(out)
 }
 fn rule_line(r: &Rule, gt: &Genotypes, phased: Option<&Phased>) -> Row {
-    let g: Vec<_> = r
-        .sites
-        .iter()
-        .map(|s| gt.get(&s.key()).cloned().unwrap_or_default())
-        .collect();
+    let g: Vec<_> = r.sites.iter().map(|s| genotype(s, gt)).collect();
     let rs: Vec<_> = r.sites.iter().map(|s| s.row["rsid"].as_str()).collect();
     let mut out = r.meta.clone();
     for (k, v) in [
@@ -818,20 +855,22 @@ fn rule_line(r: &Rule, gt: &Genotypes, phased: Option<&Phased>) -> Row {
         ),
     }
 }
-fn write_tsv(path: &str, columns: &[&str], rows: &[Row]) -> Result<()> {
-    let mut file = AtomicFile::create(path).map_err(|e| e.to_string())?;
+fn stage_tsv(path: &str, columns: &[&str], rows: &[Row]) -> Result<AtomicFile> {
+    let mut file = AtomicFile::create(path).map_err(|e| format!("cannot write {path}: {e}"))?;
     {
         let mut writer = Writer::new(&mut file, '\t');
         writer
             .write_row(columns.iter().copied())
-            .map_err(|e| e.to_string())?;
+            .map_err(|e| format!("cannot write {path}: {e}"))?;
         for row in rows {
             writer
                 .write_row(columns.iter().map(|k| row[*k].as_str()))
-                .map_err(|e| e.to_string())?;
+                .map_err(|e| format!("cannot write {path}: {e}"))?;
         }
     }
-    file.commit().map_err(|e| e.to_string())
+    file.flush()
+        .map_err(|e| format!("cannot write {path}: {e}"))?;
+    Ok(file)
 }
 fn phase_vcf(path: &str, sample: &str, rules: &[Rule], gt: &Genotypes) -> Result<usize> {
     let mut sites = BTreeMap::new();
@@ -839,7 +878,10 @@ fn phase_vcf(path: &str, sample: &str, rules: &[Rule], gt: &Genotypes) -> Result
         let calls: Option<Vec<_>> = r
             .sites
             .iter()
-            .map(|s| gt.get(&s.key()).filter(|g| g.status == Status::Called))
+            .map(|s| {
+                let g = genotype(s, gt);
+                (g.status == Status::Called).then_some(g)
+            })
             .collect();
         if let Some(calls) = calls {
             let het: Vec<_> = r
@@ -861,7 +903,7 @@ fn phase_vcf(path: &str, sample: &str, rules: &[Rule], gt: &Genotypes) -> Result
             }
         }
     }
-    let mut out = AtomicFile::create(path).map_err(|e| e.to_string())?;
+    let mut out = AtomicFile::create(path).map_err(|e| format!("cannot write {path}: {e}"))?;
     let write = |out: &mut AtomicFile| -> std::io::Result<()> {
         writeln!(out, "##fileformat=VCFv4.2")?;
         for chrom in sites.keys().map(|(c, _)| c).collect::<BTreeSet<_>>() {
@@ -884,8 +926,9 @@ fn phase_vcf(path: &str, sample: &str, rules: &[Rule], gt: &Genotypes) -> Result
         }
         Ok(())
     };
-    write(&mut out).map_err(|e| e.to_string())?;
-    out.commit().map_err(|e| e.to_string())?;
+    write(&mut out).map_err(|e| format!("cannot write {path}: {e}"))?;
+    out.commit()
+        .map_err(|e| format!("cannot write {path}: {e}"))?;
     Ok(sites.len())
 }
 fn run(verb: &str, opts: &HashMap<String, String>) -> Result<u8> {
@@ -968,7 +1011,7 @@ fn run(verb: &str, opts: &HashMap<String, String>) -> Result<u8> {
     let mut out = vec![];
     let mut counts = BTreeMap::<String, usize>::new();
     for (i, s) in rows.iter().enumerate() {
-        let g = gt.get(&s.key()).cloned().unwrap_or_default();
+        let g = genotype(s, &gt);
         let mut r = s.row.clone();
         r.insert(
             "genotype".into(),
@@ -1003,8 +1046,16 @@ fn run(verb: &str, opts: &HashMap<String, String>) -> Result<u8> {
         }
     }
     // Compute both tables before opening either output. Each rename is atomic.
-    write_tsv(required("out")?, OUT, &out)?;
-    write_tsv(required("rules-out")?, RULE_OUT, &lines)?;
+    let out_path = required("out")?;
+    let rules_path = required("rules-out")?;
+    let traits_file = stage_tsv(out_path, OUT, &out)?;
+    let rules_file = stage_tsv(rules_path, RULE_OUT, &lines)?;
+    traits_file
+        .commit()
+        .map_err(|e| format!("cannot write {out_path}: {e}"))?;
+    rules_file
+        .commit()
+        .map_err(|e| format!("cannot write {rules_path}: {e}"))?;
     for r in &out {
         *counts.entry(r["status"].clone()).or_default() += 1;
     }
@@ -1284,6 +1335,29 @@ mod tests {
         let path = scratch.put("many", &"chr99\t1\tN\t.\tN/N\n".repeat(10000));
         assert!(read_genotypes(&path, &[s]).unwrap().is_empty());
     }
+    #[test]
+    fn shared_position_keeps_each_rules_allele_vocabulary() {
+        let (rows, _) = assets();
+        let first = &rows[0];
+        let mut second = first.clone();
+        let alt = ["A", "C", "G", "T"]
+            .into_iter()
+            .find(|a| *a != first.row["ref"] && *a != first.row["alt"])
+            .unwrap();
+        second.row.insert("alt".into(), alt.into());
+        let scratch = Scratch::new();
+        let path = scratch.put(
+            "g",
+            &format!(
+                "{}\t{}\t{}\t{}\t{}/{}\n",
+                first.row["chrom"], first.row["pos"], first.row["ref"], alt, first.row["ref"], alt
+            ),
+        );
+        let gt = read_genotypes(&path, &[first, &second]).unwrap();
+        assert_eq!(genotype(first, &gt).status, Status::OtherAllele);
+        assert_eq!(genotype(&second, &gt).status, Status::Called);
+    }
+
     #[test]
     fn phase_requires_one_block_and_only_multiple_hets_are_exported() {
         let (_, rules) = assets();
@@ -1322,6 +1396,45 @@ mod tests {
         let gt = genotypes(r, &[0, 0, 0]);
         assert_eq!(rule_line(r, &gt, None)["phase"], "not_needed");
     }
+    #[test]
+    fn unwritable_rules_output_keeps_existing_traits_table() {
+        let scratch = Scratch::new();
+        let root = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../../assets");
+        let target = scratch.put("out", "previous complete table\n");
+        let gt = scratch.put("g", "");
+        let opts = [
+            (
+                "table",
+                root.join("traits.tsv").to_string_lossy().into_owned(),
+            ),
+            (
+                "rules",
+                root.join("genotype_rules.tsv")
+                    .to_string_lossy()
+                    .into_owned(),
+            ),
+            ("genotypes", gt),
+            ("sample", "S".into()),
+            ("out", target.clone()),
+            (
+                "rules-out",
+                scratch
+                    .0
+                    .join("missing/rules.tsv")
+                    .to_string_lossy()
+                    .into_owned(),
+            ),
+        ]
+        .into_iter()
+        .map(|(k, v)| (k.into(), v))
+        .collect();
+        assert!(run("table", &opts).unwrap_err().contains("cannot write"));
+        assert_eq!(
+            std::fs::read_to_string(target).unwrap(),
+            "previous complete table\n"
+        );
+    }
+
     #[test]
     fn csv_header_unicode_rules_and_atomic_write_errors() {
         let scratch = Scratch::new();
@@ -1335,7 +1448,7 @@ mod tests {
         assert!(read_table(&path).unwrap().is_empty());
         let path = scratch.put("r", "rule\té\tG\tT\tno\tyes\tN\t1\n");
         assert!(!check_rules(&read_rules(&path).unwrap(), None).is_empty());
-        assert!(write_tsv(scratch.0.join("absent/x").to_str().unwrap(), OUT, &[]).is_err());
+        assert!(stage_tsv(scratch.0.join("absent/x").to_str().unwrap(), OUT, &[]).is_err());
         assert_eq!(cli(&["table".into()]), 2);
         assert_eq!(
             cli(&[
diff --git a/tests/e2e/rust-c2b-traits.sh b/tests/e2e/rust-c2b-traits.sh
index 71613e72f..e5e2e3852 100755
--- a/tests/e2e/rust-c2b-traits.sh
+++ b/tests/e2e/rust-c2b-traits.sh
@@ -12,6 +12,7 @@ check_eq 'traits table exits 0' "$?" 0
 check_eq 'APOE double heterozygote is e2/e4' "$(awk -F'\t' '$1 == "APOE" {print $10}' "${CASE_TMP}/rules.tsv")" e2/e4
 check_eq 'the taster rule needs phase' "$(awk -F'\t' '$1 == "TAS2R38" {print $11}' "${CASE_TMP}/rules.tsv")" unphased
 check_eq 'APOE line occurs exactly once' "$(grep -c '^rs429358+rs7412' "${CASE_TMP}/traits.tsv")" 1
+# shellcheck disable=SC2016  # awk field references
 check 'absent LCT has no inferred genotype' awk -F'\t' '$1 == "rs4988235" {ok = ($6 == "." && $7 == "not_covered")} END {exit !ok}' "${CASE_TMP}/traits.tsv"
 "$OG" traits phase-sites --rules "$RULES" --genotypes "$G" --sample S --out "${CASE_TMP}/phase.vcf"
 check_eq 'phase-sites exits 0' "$?" 0
diff --git a/tests/parity/cases.tsv b/tests/parity/cases.tsv
index 2a2fe1e34..70faade6e 100644
--- a/tests/parity/cases.tsv
+++ b/tests/parity/cases.tsv
@@ -977,3 +977,4 @@ traits	sites-single	gen:traits.sh	phase-sites --rules rules.tsv --genotypes sing
 traits	check	gen:traits.sh	check --table traits.tsv --rules rules.tsv	-	bytes	PYTHON_IMAGE
 traits	bad-table	gen:traits.sh	check --table bad-table.tsv --rules rules.tsv	-	bytes	PYTHON_IMAGE
 traits	bad-rules	gen:traits.sh	check --table traits.tsv --rules bad-rules.tsv	-	bytes	PYTHON_IMAGE
+traits	shared-vocabulary	gen:traits.sh	table --table traits.tsv --rules shared-rules.tsv --genotypes shared.tsv --sample S --out traits-out.tsv --rules-out rules-out.tsv	traits-out.tsv,rules-out.tsv	tsv	PYTHON_IMAGE
diff --git a/tests/parity/evidence/rust-c2b-controls.txt b/tests/parity/evidence/rust-c2b-controls.txt
new file mode 100644
index 000000000..bed580b72
--- /dev/null
+++ b/tests/parity/evidence/rust-c2b-controls.txt
@@ -0,0 +1,69 @@
+Local execution of the Guard step "Traits controls", Rust 1.93.0.
+Command: cargo test --locked -p og-steps traits::tests --no-fail-fast
+Faults: reverse the diplotype key list; remove the genotype REF guard;
+clear the phase-site list before writing the VCF.
+The step requires each of the three named regression tests to fail, then
+restores the source. A compiler failure alone does not satisfy the control.
+
+running 8 tests
+test traits::tests::csv_header_unicode_rules_and_atomic_write_errors ... ok
+test traits::tests::apoe_grid_keeps_haplotype_order_and_missing_calls ... FAILED
+test traits::tests::stream_prefers_first_snv_but_checks_every_ref_and_bounds_memory ... FAILED
+test traits::tests::shared_position_keeps_each_rules_allele_vocabulary ... ok
+test traits::tests::phase_requires_one_block_and_only_multiple_hets_are_exported ... FAILED
+test traits::tests::unwritable_rules_output_keeps_existing_traits_table ... FAILED
+test traits::tests::committed_catalogs_and_every_rule_genotype ... FAILED
+test traits::tests::schema_faults_are_refused_before_enumeration ... ok
+
+failures:
+
+---- traits::tests::apoe_grid_keeps_haplotype_order_and_missing_calls stdout ----
+
+thread 'traits::tests::apoe_grid_keeps_haplotype_order_and_missing_calls' (4288523) panicked at crates/og-steps/src/traits.rs:1242:17:
+assertion `left == right` failed
+  left: "other_haplotype"
+ right: "called"
+note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
+
+---- traits::tests::stream_prefers_first_snv_but_checks_every_ref_and_bounds_memory stdout ----
+
+thread 'traits::tests::stream_prefers_first_snv_but_checks_every_ref_and_bounds_memory' (4288529) panicked at crates/og-steps/src/traits.rs:1336:45:
+called `Result::unwrap_err()` on an `Ok` value: {("chr2", "135851076"): SiteGt { alleles: ["G", "A"], status: Called, gq: "42", snv: true }}
+
+---- traits::tests::phase_requires_one_block_and_only_multiple_hets_are_exported stdout ----
+
+thread 'traits::tests::phase_requires_one_block_and_only_multiple_hets_are_exported' (4288526) panicked at crates/og-steps/src/traits.rs:1390:9:
+assertion `left == right` failed
+  left: 0
+ right: 3
+
+---- traits::tests::unwritable_rules_output_keeps_existing_traits_table stdout ----
+ERROR: /Volumes/Data/repos/personal/.worktrees/pgp-rust-c2b/rust/crates/og-steps/../../../assets/genotype_rules.tsv: rule APOE (line 19): no combination line for e2/e4|e1/e3
+ERROR: /Volumes/Data/repos/personal/.worktrees/pgp-rust-c2b/rust/crates/og-steps/../../../assets/genotype_rules.tsv: rule APOE (line 19): the combination line e1/e3|e2/e4 can never be read (a rule that needs phase reads one diplotype)
+
+thread 'traits::tests::unwritable_rules_output_keeps_existing_traits_table' (4288530) panicked at crates/og-steps/src/traits.rs:1433:37:
+called `Result::unwrap_err()` on an `Ok` value: 1
+
+---- traits::tests::committed_catalogs_and_every_rule_genotype stdout ----
+
+thread 'traits::tests::committed_catalogs_and_every_rule_genotype' (4288524) panicked at crates/og-steps/src/traits.rs:1216:9:
+assertion `left == right` failed
+  left: ["rule APOE (line 19): no combination line for e2/e4|e1/e3", "rule APOE (line 19): the combination line e1/e3|e2/e4 can never be read (a rule that needs phase reads one diplotype)"]
+ right: []
+
+
+failures:
+    traits::tests::apoe_grid_keeps_haplotype_order_and_missing_calls
+    traits::tests::committed_catalogs_and_every_rule_genotype
+    traits::tests::phase_requires_one_block_and_only_multiple_hets_are_exported
+    traits::tests::stream_prefers_first_snv_but_checks_every_ref_and_bounds_memory
+    traits::tests::unwritable_rules_output_keeps_existing_traits_table
+
+test result: FAILED. 3 passed; 5 failed; 0 ignored; 0 measured; 91 filtered out; finished in 0.01s
+
+error: test failed, to rerun pass `-p og-steps --lib`
+error: 1 target failed:
+    `-p og-steps --lib`
+test traits::tests::apoe_grid_keeps_haplotype_order_and_missing_calls ... FAILED
+test traits::tests::stream_prefers_first_snv_but_checks_every_ref_and_bounds_memory ... FAILED
+test traits::tests::phase_requires_one_block_and_only_multiple_hets_are_exported ... FAILED
diff --git a/tests/parity/gen/traits.sh b/tests/parity/gen/traits.sh
index a57771388..227660390 100644
--- a/tests/parity/gen/traits.sh
+++ b/tests/parity/gen/traits.sh
@@ -2,8 +2,8 @@
 # Public catalogs and synthetic genotype grids for all three traits verbs.
 set -euo pipefail
 root=$(cd "$(dirname "$0")/../../.." && pwd)
-cp "$root/assets/traits.tsv" traits.tsv
-cp "$root/assets/genotype_rules.tsv" rules.tsv
+cp -f "$root/assets/traits.tsv" traits.tsv
+cp -f "$root/assets/genotype_rules.tsv" rules.tsv
 cat > oracle.sh <<'EOF'
 prog=$1; shift
 mode=$1; shift
@@ -40,3 +40,15 @@ printf 'chr7\t141973545\t.\tC\tG\t.\tPASS\t.\tGT:PS\t1|0:7\nchr7\t141972905\t.\t
 sed '1s/:7$/:8/' phased.vcf > split.vcf
 awk -F'\t' -v OFS='\t' '$1 == "combination" && $2 == "APOE" && $3 == "e3/e3" {next} {print}' rules.tsv > bad-rules.tsv
 awk -F'\t' -v OFS='\t' '$3 == "rs671" {$6=$5} {print}' traits.tsv > bad-table.tsv
+cp -f rules.tsv shared-rules.tsv
+cat >> shared-rules.tsv <<'TSV'
+rule	SHARE	SHARE	Shared position test	no	no	Synthetic alternate allele vocabulary.	1
+site	SHARE	rs999999991	chr19	44908684	T	G
+site	SHARE	rs999999992	chr19	44908822	C	T
+haplotype	SHARE	h0	T,C
+haplotype	SHARE	h1	G,T
+combination	SHARE	h0/h0	normal	Reference pair.
+combination	SHARE	h0/h1	carrier	One alternate copy.
+combination	SHARE	h1/h1	alternate	Two alternate copies.
+TSV
+printf 'chr19\t44908684\tT\tG\tT/G\t40\nchr19\t44908822\tC\tT\tC/T\t40\n' > shared.tsv
diff --git a/tests/parity/remnants.tsv b/tests/parity/remnants.tsv
index 084de768c..268a9ce99 100644
--- a/tests/parity/remnants.tsv
+++ b/tests/parity/remnants.tsv
@@ -9,4 +9,4 @@ bin/pgx_outside_calls.py	HLA_GENES,NO_CALL,PROBABLE,NOT_CALLABLE,LOW_GQ,is_call,
 bin/paraphase_report.py	SMN1_EXON7,parascopy_smn1,compare_smn1	bin/collect_summary.py,bin/couple_report.py,tests/test_paralog_loci.py,tests/test_paraphase_report.py	R4
 bin/cnvpytor_to_vcf.py	DEPTH_MIN_SIZE,delly_depth_contradicts	bin/couple_report.py	R4
 bin/annotsv_postfilter.py	CONSENSUS_BP,KEEP,ADDED,open_text,chrom_key,sv_type,info_value,sample_format,sample_columns,read_consensus,consensus_support	bin/collect_summary.py,tests/demo/make_demo_sample.py	R3
-bin/traits_report.py	COLUMNS,OUT_COLUMNS,RULE_OUT_COLUMNS,TRAITS_TABLE_RULES,TableError,read_table,MARKERS,MARKER_STATUSES	bin/collect_summary.py,tests/demo/make_demo_sample.py,tests/test_traits_report.py,tests/test_traits_table.py,tests/test_collect_summary.py,tests/test_lpa_kiv2.py,tests/test_render_report.py	R3
+bin/traits_report.py	COLUMNS,OUT_COLUMNS,RULE_OUT_COLUMNS,TRAITS_TABLE_RULES,TableError,read_table,MARKERS,MARKER_STATUSES	bin/collect_summary.py,tests/demo/make_demo_sample.py,tests/test_traits_report.py,tests/test_traits_table.py,tests/test_collect_summary.py,tests/test_lpa_kiv2.py	R3
diff --git a/tests/test_copy_number.py b/tests/test_copy_number.py
index 03a4bf349..3cb0eb2da 100644
--- a/tests/test_copy_number.py
+++ b/tests/test_copy_number.py
@@ -1,7 +1,6 @@
 #!/usr/bin/env python3
 """og cn and bin/cn_loci.tsv: one depth-ratio engine for every copy-number
-locus, and what bin/copy_number.py keeps (the catalog reader and assess(),
-which step 41's report imports).
+locus, compared with the pinned historical catalog reader and assess() oracle.
 
 Without og (OG unset) the checks of the catalog and of assess() run, and the
 wiring; with OG naming the og binary (OG=rust/target/release/og, or bin/og)
diff --git a/tests/test_render_report.py b/tests/test_render_report.py
index a8377a4d6..beb0497c0 100644
--- a/tests/test_render_report.py
+++ b/tests/test_render_report.py
@@ -954,9 +954,7 @@ def mosaic_table(rows):
 
         # 11. traits card
         import time
-        import traits_report
         d = f"{work}/traits/S"
-        rows = traits_report.read_table(os.path.join(REPO, "assets", "traits.tsv"))
         put(f"{d}/traits/S_traits.tsv", "")
         from test_traits_report import traits_tables
         g = os.path.join(work, "traits_empty.tsv")
diff --git a/tests/test_traits_report.py b/tests/test_traits_report.py
index a10e13f47..2414935bc 100644
--- a/tests/test_traits_report.py
+++ b/tests/test_traits_report.py
@@ -105,8 +105,7 @@ def planted(desc, new, want):
     "MAPT": [(("G/G", "G/G"), "H2/H2"), (("A/G", "A/G"), "H1/H2")],
 }
 # The label of the reference blocks alone (every site homozygous for the GRCh38 base).
-MULTI_SNP_REF = {"APOL1": "G0/G0", "SERPINA1": "PiMM", "HFE": "wt/wt", "GC": "Gc1F/Gc1F",
-                 "CAD9p21": "no risk copy", "MAPT": "H1/H1"}
+
 
 
 def says_not_proof(message):
diff --git a/tests/test_traits_table.py b/tests/test_traits_table.py
index 84cf60203..3d2566b27 100644
--- a/tests/test_traits_table.py
+++ b/tests/test_traits_table.py
@@ -1,33 +1,10 @@
 #!/usr/bin/env python3
-"""assets/traits.tsv, the curated table of step 42: its schema, its reference
-bases and its sources.
-
-  python3 tests/test_traits_table.py                    schema (the unit-tests job)
-  python3 tests/test_traits_table.py --fasta REF.fasta  also: each row's ref is the
-                                                        FASTA's base, on every contig
-                                                        the FASTA has (needs REF.fasta.fai)
-  python3 tests/test_traits_table.py --online           also: every PMID resolves in
-                                                        PubMed, and every rsID's GRCh38
-                                                        position, reference base and
-                                                        alt allele are dbSNP's (curl)
-  --table FILE checks another table (the e2e case plants a broken copy).
-
-The e2e case traits-panel-1 runs it with --fasta (the fixture's GRCh38
-reference) and --online, and on a planted copy with one wrong reference base
-and one PubMed id that does not exist, which must fail.
-
-Checks without options:
-  1. the table passes bin/traits_report.py's schema check (columns, chr1 to
-     chr22, positions, one base each for ref and alt, readings, ancestry
-     yes/no, PubMed ids, the two APOE rows, no SNPedia text);
-  2. planted problems are each caught: a wrong column count, ref = alt, a
-     non-base allele, a duplicate rsID, a PMID that is not a number, a
-     missing APOE row;
-  3. the FASTA check on a three-base synthetic FASTA: the right base passes,
-     a planted wrong base fails, a contig the FASTA lacks is counted as not
-     checked.
-
-Run: python3 tests/test_traits_table.py
+"""Validate the curated traits catalog and its GRCh38 reference bases.
+
+Schema checks use og traits check. Rust unit tests plant invalid catalog
+rows and rules. The optional --fasta and --online checks also verify the
+FASTA bases, PubMed sources and dbSNP records. A synthetic FASTA provides
+positive, wrong-base and missing-contig controls without network access.
 """
 import argparse
 import json

From 31d8c3547ad8b66ac1ae4d4c07c9848858178b3c Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 15:38:29 +0100
Subject: [PATCH 44/76] perf(ci): skip scanner rules whose required literals
 are absent

---
 rust/crates/og-dev/src/personal_data.rs | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
index f63fb9f0f..1fcddb6aa 100644
--- a/rust/crates/og-dev/src/personal_data.rs
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -109,6 +109,23 @@ struct Check {
     cond: Option<&'static [Rule]>,
 }
 
+impl Check {
+    /// Necessary literal bytes only. This can admit extra lines, but cannot
+    /// decide a match or discard a candidate span. Custom rules always run.
+    fn candidate(&self, line: &str) -> bool {
+        match self.kind {
+            "home" => {
+                line.contains("/home/") || line.contains("/mnt/user") || line.contains("Users")
+            }
+            "address" => line.contains('.'),
+            "diplotype" => line.contains('*') && line.contains('/'),
+            "rsid" => line.contains("rs"),
+            "repeat" => line.contains('/'),
+            _ => true,
+        }
+    }
+}
+
 fn rule(pattern: &str) -> Rule {
     Rule::compile(pattern, true).expect("a valid built-in pattern")
 }
@@ -382,6 +399,9 @@ fn scan_text(
             .flat_map(|t| line.match_indices(*t).map(|(a, s)| (a, a + s.len())))
             .collect();
         for c in rules {
+            if !c.candidate(line) {
+                continue;
+            }
             if let Some(conditions) = c.cond {
                 let mut matched = false;
                 for condition in conditions {

From 853dda63ca5dbd14eb8ab2e86ee5b63cdfd8146f Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 15:39:11 +0100
Subject: [PATCH 45/76] docs(traits): describe the removed copy-number test
 oracle

Bead: pgp-bs9u.25
---
 docs/cn-loci.md | 2 +-
 docs/rust.md    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/cn-loci.md b/docs/cn-loci.md
index eb6f0a44e..247ffc02c 100644
--- a/docs/cn-loci.md
+++ b/docs/cn-loci.md
@@ -1,6 +1,6 @@
 # Copy Number from Depth (the locus catalog)
 
-Several steps count copies of a gene from short-read depth: HBA1 and HBA2 in step 35, the RHD deletion in step 41 and the LPA KIV-2 repeat in step 46. Step 35 also counts three gene-dosage loci that no pinned caller models (HP, LCE3B/LCE3C and CCL3L1), CYP21A2 from depth and its pseudogene variant sites, and the interval rows: the recurrent CNV regions ClinGen curates (22q11.2, 1q21.1, 15q11.2, 16p11.2, 17p12 and the rest), five carrier deletion alleles and the Y chromosome AZF regions. They all use one table, `bin/cn_loci.tsv`, with one row per locus, and one engine, `og cn` (the Rust crate `rust/crates/og-cn`, run through `bin/og`; [docs/rust.md](rust.md)). Step 41 uses the same engine: `og cn bed` gives it the RHD regions, and `og bloodtype report` makes the RhD call with og cn's rules on the RHD row. `bin/copy_number.py` stays only for the catalog tests. A new locus is a new row, not a new script.
+Several steps count copies of a gene from short-read depth: HBA1 and HBA2 in step 35, the RHD deletion in step 41 and the LPA KIV-2 repeat in step 46. Step 35 also counts three gene-dosage loci that no pinned caller models (HP, LCE3B/LCE3C and CCL3L1), CYP21A2 from depth and its pseudogene variant sites, and the interval rows: the recurrent CNV regions ClinGen curates (22q11.2, 1q21.1, 15q11.2, 16p11.2, 17p12 and the rest), five carrier deletion alleles and the Y chromosome AZF regions. They all use one table, `bin/cn_loci.tsv`, with one row per locus, and one engine, `og cn` (the Rust crate `rust/crates/og-cn`, run through `bin/og`; [docs/rust.md](rust.md)). Step 41 uses the same engine: `og cn bed` gives it the RHD regions, and `og bloodtype report` makes the RhD call with og cn's rules on the RHD row. The catalog tests materialise the historical Python engine from its pinned Git commit as a differential oracle. A new locus is a new row, not a new script.
 
 The table sits in `bin/` because `bin/` is the one repository folder that every container mounts: the bash steps mount it as `/pgp-bin`, and Nextflow puts it on every task's PATH.
 
diff --git a/docs/rust.md b/docs/rust.md
index 99637ea75..728a2abd2 100644
--- a/docs/rust.md
+++ b/docs/rust.md
@@ -37,7 +37,7 @@ bin/og                  the shim tasks call; runs bin/.og/og-linux-<arch> (og-da
 tests/rust/             the differential test against CPython, the image test
 ```
 
-Each ported tool becomes a subcommand named after its file in `bin/` without `.py`, in kebab-case. Today `og` has `og qc sex-loss` (step 33), `og version`, `og --tree-hash`, `og map`, `og setup mask-fasta`, `og run state|tasks|eta|headroom|delta`, `og dev parity-compare`, `og pgx cyp2d6-bed|cyp2d6-measure|cyp2d6-check`, `og str motif|catalog`, `og cdna check|scan` (were `clip_check.py` and `cdna_scan.py`; `clip_check.py` keeps only the names `collect_summary.py` imports), `og comphet phase` (was `comphet_phase.py`), `og bam contigs`, `og setup unzip|genetic-map` and two hidden ones the tests drive: `og pycompat-probe` and `og bam-fetch-probe`. The filters of steps 04, 05 and 07 are grouped by step: `og sv svlen-fix` and `og sv inv-filter` (were `sv_svlen_fix.py` and `manta_inv_filter.py`), `og pgx refblock-fill` and `og pgx mito-merge` (were `pgx_refblock_fill.py` and `pgx_mito_merge.py`). Step 05 builds AnnotSV's input with `og sv add-callers` and checks its class 4 and 5 calls with `og sv postfilter` (were `cnvpytor_to_vcf.py` and `annotsv_postfilter.py`); both apply one read-depth rule for long Delly calls (`og-steps::sv`). `cnvpytor_to_vcf.py` keeps only the Python copy of that rule, which step 39's couple screen still imports, and `annotsv_postfilter.py` only the column names and the consensus join the reports import. `og str catalog` (was `strchive_convert.py`) builds the STRchive catalog of steps 09 and 9b; `og setup unzip` and `og setup genetic-map` replace two small Python programs inside `setup.sh`. Step 25 has `og prs format` (a port of `collect_summary.py prs-format`, named by what it works on) and `og prs table` (was `prs-table`). Step 33 has `og qc sample` (was `sample-qc`), and step 20 has `og mito annotate|deletions|copies` (were `mito-annotate`, `mito-deletions` and `mito-copies`). Steps 23 and 31 use `og vcf csq-rank` and `og table constraint-join` (ports of the awk programs `bin/csq_rank.awk` and `bin/constraint_join.awk`, named by what they work on). Step 27 uses `og pgx cpic-report` and `og pgx step36-outside` (were the two commands of `pgx_parse.py`). Step 49 runs `og chip prepare`, `og chip report` and `og chip check-table` (the commands of `chip_report.py`, which keeps only the detection limit and the column names the reports import). Steps 32, 35, 41 and 46 run `og cn bed`, `og cn call`, `og cn intervals`, `og cn check-bam`, `og cn marker-regions` and `og cn marker-read` ([Copy number from depth](cn-loci.md)); they replace `hba_copy_number.py`, `lpa_kiv2.py`, the commands of `copy_number.py` (which keeps the catalog reader the catalog tests import) and the marker reader of `traits_report.py` (which keeps `MARKERS` for the summary). Step 41 runs `og bloodtype report` (was `bloodtype_report.py`), which reads the marker sites through the VCF's index. Step 26b's six commands are `og ancestry-fine panel-map|check-map|order|sample-bed|chroms|report`; `bin/ancestry_fine_report.py` keeps only the names `collect_summary.py` and the docs demo import. Step 40 runs `og consumer build-sites`, `og consumer export` and `og consumer check` (were the three commands of `export_consumer.py`). Step 38 and the Nextflow family workflow run `og family plan`, `prepare`, `check`, `report`, `segments` and `ibd` (were `family_report.py`, `family_segments.py` and `ibd_report.py`). `og family report` reads the joint VCF once, compresses each child's inheritance table on its own thread, and stops with exit 2 on a joint VCF that is not sorted. The opt-in steps read their tool's output with `og y str-bed|str-report` (45), `og viral report` (47), `og exomiser prepare|report` (48), `og mei report|annotsv-input` (50), `og mocha report` (51), `og vntyper report` (52) and `og locityper report` (53); they replaced `ystr_report.py`, `viral_report.py`, `exomiser_report.py`, `mei_report.py`, `mocha_report.py`, `vntyper_report.py` and `locityper_report.py`. Step 37 places the sample on the current YFull YTree with `og y tree-positions` and `og y tree-place` (were the two commands of `y_tree_place.py`), lists its private SNPs with `og y private-snps` (was `y_private_snps.py`) and writes Yleaf's marker positions with `og y yleaf-positions` (was `yleaf_run.py positions`; `yleaf_run.py predict` stays Python, as glue inside Yleaf's own code). Steps 08, 32 and 36 run `og pgx hla-concordance`, `og pgx pypgx-summary` and `og pgx outside-calls` (were the three commands of `pgx_outside_calls.py`, which keeps the CYP2D6 and HLA rules the reports import), and step 35b runs `og paraphase check-bam|table` (were `paraphase_report.py`, which keeps the SMN1 rule beside Parascopy). Both write their two output files together or not at all. `scripts/owngenome-lookup.sh` runs `og lookup query` ([genotype lookup](lookup.md)), which answers every query of the command line in one process; `og lookup resolve` and `og lookup report` are its two halves, with the command lines of `genome_lookup.py`, which keeps only the query reading and the names rule that `results_index.py` imports. `og recheck` replaced `owngenome_recheck.py` ([Newer databases since a run](recheck.md)); the file stays one release as a shim that runs it, for crontabs. `og dev freshness` replaced `scripts/ci/freshness.py`, the monthly freshness issue of `freshness.yml`. Both ask the network through the host's `curl` (the config on stdin, so no token reaches the process list), which keeps a TLS stack out of the static binary and its cross-builds.
+Each ported tool becomes a subcommand named after its file in `bin/` without `.py`, in kebab-case. Today `og` has `og qc sex-loss` (step 33), `og version`, `og --tree-hash`, `og map`, `og setup mask-fasta`, `og run state|tasks|eta|headroom|delta`, `og dev parity-compare`, `og pgx cyp2d6-bed|cyp2d6-measure|cyp2d6-check`, `og str motif|catalog`, `og cdna check|scan` (were `clip_check.py` and `cdna_scan.py`; `clip_check.py` keeps only the names `collect_summary.py` imports), `og comphet phase` (was `comphet_phase.py`), `og bam contigs`, `og setup unzip|genetic-map` and two hidden ones the tests drive: `og pycompat-probe` and `og bam-fetch-probe`. The filters of steps 04, 05 and 07 are grouped by step: `og sv svlen-fix` and `og sv inv-filter` (were `sv_svlen_fix.py` and `manta_inv_filter.py`), `og pgx refblock-fill` and `og pgx mito-merge` (were `pgx_refblock_fill.py` and `pgx_mito_merge.py`). Step 05 builds AnnotSV's input with `og sv add-callers` and checks its class 4 and 5 calls with `og sv postfilter` (were `cnvpytor_to_vcf.py` and `annotsv_postfilter.py`); both apply one read-depth rule for long Delly calls (`og-steps::sv`). `cnvpytor_to_vcf.py` keeps only the Python copy of that rule, which step 39's couple screen still imports, and `annotsv_postfilter.py` only the column names and the consensus join the reports import. `og str catalog` (was `strchive_convert.py`) builds the STRchive catalog of steps 09 and 9b; `og setup unzip` and `og setup genetic-map` replace two small Python programs inside `setup.sh`. Step 25 has `og prs format` (a port of `collect_summary.py prs-format`, named by what it works on) and `og prs table` (was `prs-table`). Step 33 has `og qc sample` (was `sample-qc`), and step 20 has `og mito annotate|deletions|copies` (were `mito-annotate`, `mito-deletions` and `mito-copies`). Steps 23 and 31 use `og vcf csq-rank` and `og table constraint-join` (ports of the awk programs `bin/csq_rank.awk` and `bin/constraint_join.awk`, named by what they work on). Step 27 uses `og pgx cpic-report` and `og pgx step36-outside` (were the two commands of `pgx_parse.py`). Step 49 runs `og chip prepare`, `og chip report` and `og chip check-table` (the commands of `chip_report.py`, which keeps only the detection limit and the column names the reports import). Steps 32, 35, 41 and 46 run `og cn bed`, `og cn call`, `og cn intervals`, `og cn check-bam`, `og cn marker-regions` and `og cn marker-read` ([Copy number from depth](cn-loci.md)); they replace `hba_copy_number.py`, `lpa_kiv2.py`, `copy_number.py` (the catalog tests materialise its pinned historical version as a differential oracle) and the marker reader of `traits_report.py` (which keeps `MARKERS` for the summary). Step 41 runs `og bloodtype report` (was `bloodtype_report.py`), which reads the marker sites through the VCF's index. Step 26b's six commands are `og ancestry-fine panel-map|check-map|order|sample-bed|chroms|report`; `bin/ancestry_fine_report.py` keeps only the names `collect_summary.py` and the docs demo import. Step 40 runs `og consumer build-sites`, `og consumer export` and `og consumer check` (were the three commands of `export_consumer.py`). Step 38 and the Nextflow family workflow run `og family plan`, `prepare`, `check`, `report`, `segments` and `ibd` (were `family_report.py`, `family_segments.py` and `ibd_report.py`). `og family report` reads the joint VCF once, compresses each child's inheritance table on its own thread, and stops with exit 2 on a joint VCF that is not sorted. The opt-in steps read their tool's output with `og y str-bed|str-report` (45), `og viral report` (47), `og exomiser prepare|report` (48), `og mei report|annotsv-input` (50), `og mocha report` (51), `og vntyper report` (52) and `og locityper report` (53); they replaced `ystr_report.py`, `viral_report.py`, `exomiser_report.py`, `mei_report.py`, `mocha_report.py`, `vntyper_report.py` and `locityper_report.py`. Step 37 places the sample on the current YFull YTree with `og y tree-positions` and `og y tree-place` (were the two commands of `y_tree_place.py`), lists its private SNPs with `og y private-snps` (was `y_private_snps.py`) and writes Yleaf's marker positions with `og y yleaf-positions` (was `yleaf_run.py positions`; `yleaf_run.py predict` stays Python, as glue inside Yleaf's own code). Steps 08, 32 and 36 run `og pgx hla-concordance`, `og pgx pypgx-summary` and `og pgx outside-calls` (were the three commands of `pgx_outside_calls.py`, which keeps the CYP2D6 and HLA rules the reports import), and step 35b runs `og paraphase check-bam|table` (were `paraphase_report.py`, which keeps the SMN1 rule beside Parascopy). Both write their two output files together or not at all. `scripts/owngenome-lookup.sh` runs `og lookup query` ([genotype lookup](lookup.md)), which answers every query of the command line in one process; `og lookup resolve` and `og lookup report` are its two halves, with the command lines of `genome_lookup.py`, which keeps only the query reading and the names rule that `results_index.py` imports. `og recheck` replaced `owngenome_recheck.py` ([Newer databases since a run](recheck.md)); the file stays one release as a shim that runs it, for crontabs. `og dev freshness` replaced `scripts/ci/freshness.py`, the monthly freshness issue of `freshness.yml`. Both ask the network through the host's `curl` (the config on stdin, so no token reaches the process list), which keeps a TLS stack out of the static binary and its cross-builds.
 
 A Python file whose tool moved to `og` but whose names other Python still imports stays as a *remnant*: a `# remnant:` header names its importers and the lane that deletes it, and `tests/parity/remnants.tsv` lists the names it may hold and the files that import it. `og dev remnants` (Guard, job `rust`) fails when the file defines a name the list does not allow, when an allowed name has no user left, when a listed importer no longer imports it, or when an unlisted file starts to. So a remnant only shrinks. `bin/family_report.py` is the first one: the pedigree, kinship and PAR rules that `couple_report.py` and `pedigree_svg.py` import. `bin/genome_lookup.py` keeps the query reading and the summary names rule that `results_index.py` imports.
 

From 051c92e7081f014e727e82ac9253c696e804e8af Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 15:41:46 +0100
Subject: [PATCH 46/76] fix(ci): keep scanner hints free of reportable examples

---
 rust/crates/og-dev/src/personal_data.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
index 1fcddb6aa..04d9f9d18 100644
--- a/rust/crates/og-dev/src/personal_data.rs
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -115,7 +115,7 @@ impl Check {
     fn candidate(&self, line: &str) -> bool {
         match self.kind {
             "home" => {
-                line.contains("/home/") || line.contains("/mnt/user") || line.contains("Users")
+                line.contains("/home/") || line.contains("/mnt/use") || line.contains("Users")
             }
             "address" => line.contains('.'),
             "diplotype" => line.contains('*') && line.contains('/'),

From b9379927cfd63f83593368caea570bb14d8b6329 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 15:43:45 +0100
Subject: [PATCH 47/76] fix(ci): reject malformed smoke inputs and bound
 CR-only reads

---
 CHANGELOG.md                           |   1 +
 docs/rust.md                           |   6 +-
 rust/crates/og-dev/src/nf_trace.rs     |  12 +-
 rust/crates/og-dev/src/smoke.rs        |  42 +++-
 rust/crates/og-dev/tests/ci_readers.rs | 314 +++++++++++++++++++++++++
 rust/crates/og-io/src/lib.rs           | 102 ++++++--
 scripts/ci/image-smoke.sh              |  91 ++++++-
 tests/smoke/commands.tsv               |   8 +-
 8 files changed, 534 insertions(+), 42 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5ba164c75..79e7ba9e4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,7 @@ Each release's notes. From 1.0.0 on, a major or minor release has hand-written n
 
 ## Unreleased
 
+- The shared `og-io` line reader bounds memory by the longest record for CR-only files as well as LF and CRLF files. Smoke coordinates require signed integers, so decimal and nonfinite coordinates fail. Trace integer cells accept whitespace, signs and underscores but deliberately refuse Unicode digits and negative resources. Integers outside the target range fail. Duplicate task rows retain concrete exits. Smoke JSON checks require one document, numeric counts and copy numbers, array catalogs and string genotypes. Numeric depth strings stay supported; booleans are refused. The array and genotype rules deliberately reject malformed values Python accepted. Smoke fixtures build a missing default `og` on first use.
 - CI readers now use `og dev pharmcat diplotypes`, `nf-trace` and `smoke`. Unreadable PharmCAT reports fail with exit 2 and are marked not assessed. Resource checks refuse trace globs and malformed numeric cells. The smoke mini-reference uses a fixed Rust seed for the planted bases. Gzip smoke reads have deterministic headers. Smoke table checks report concise property results.
 
 - The container helpers check (`scripts/ci/check-container-helpers.sh`, Guard job `helper-binaries`) now derives its table with the Rust `og` binary, `og dev helpers`. It replaces the Python inside the script, which is gone; the script keeps the docker probe, the orad download and its self-test. On this tree the table and the rule 1 output are the same, byte for byte. The static run takes 0.01 s and 6 MB where the Python took 0.2 s and 15 MB. What changes:
diff --git a/docs/rust.md b/docs/rust.md
index bea0896ec..759731446 100644
--- a/docs/rust.md
+++ b/docs/rust.md
@@ -116,6 +116,10 @@ To add a primitive: write it in `pycompat` with unit tests, add an operation to
 
 `og dev pharmcat diplotypes REPORT` prints sorted, unique `GENE\tA1/A2` rows from flat or source-nested reports. `--called` prints the called count and names on stderr. `--called-lines` prints one called gene per line for e2e checks. An unreadable report exits 2 without a count. A valid empty report succeeds with a zero count.
 
-`og dev nf-trace requests TRACE --want FILE --executor-cpus N --executor-mem-gb N` checks initial requests, doubled retry memory and the executor budget. The expectation table is [nf-trace-requests.tsv](../scripts/ci/nf-trace-requests.tsv). `og dev nf-trace attempts TRACE --name-glob PATTERN --want '1:137:32,2:0:64' --nextflow-exit RC` checks a retry sequence. Both accept one explicit path, refuse globs, parse quoted TSV records and reject conflicting duplicates. Identical duplicate task IDs count once. Exit 1 means the check found a mismatch. Exit 2 means input or arguments could not be assessed.
+`og dev nf-trace requests TRACE --want FILE --executor-cpus N --executor-mem-gb N` checks initial requests, doubled retry memory and the executor budget. The expectation table is [nf-trace-requests.tsv](https://github.com/GeiserX/OwnGenome/blob/main/scripts/ci/nf-trace-requests.tsv). `og dev nf-trace attempts TRACE --name-glob PATTERN --want '1:137:32,2:0:64' --nextflow-exit RC` checks a retry sequence. Both accept one explicit path, refuse globs, parse quoted TSV records and reject conflicting duplicates. Identical duplicate task IDs count once. Exit 1 means the check found a mismatch. Exit 2 means input or arguments could not be assessed.
 
 `og dev smoke` supplies `mini-ref SRC ORIG MINI POS LEN`, `long-reads HAP1 HAP2 OUT.gz`, `eh-catalog REF OUT END`, `csv-cell FILE KEY=VALUE[,KEY=VALUE] COLUMN` and `check KIND FILE`. Check kinds are `hap-ibd`, `ibdmix`, `rfmix`, `eigen` and `parascopy`. Mini-reference bases use a fixed Rust seed. Long-read gzip headers are deterministic. These synthetic fixtures do not change pipeline output files. Smoke references are limited to 1,003,000 bases. CSV lookups and table checks read one record at a time.
+
+CI integer cells accept surrounding whitespace, signs and digit separators. Trace cells deliberately refuse Unicode digits and negative resource values. Smoke coordinates accept Unicode decimal digits and use signed 128-bit integers. Integers beyond the target range fail. Decimal and nonfinite coordinates fail. Duplicate trace rows retain the first concrete exit status and reject later conflicts.
+
+The shared `og-io` reader consumes LF, CRLF and lone CR records with storage bounded by the longest line. Smoke JSON checks require one document and typed fields. Catalogs must be arrays and genotypes must be nonempty strings. This deliberately rejects malformed values that Python truthiness or `len()` accepted. Numeric depth strings remain supported; booleans are refused. Smoke fixtures and assertions build `og` on first use if the default binary is missing. An explicit `OG` is used as supplied.
diff --git a/rust/crates/og-dev/src/nf_trace.rs b/rust/crates/og-dev/src/nf_trace.rs
index 2a0aef041..2015c9e0d 100644
--- a/rust/crates/og-dev/src/nf_trace.rs
+++ b/rust/crates/og-dev/src/nf_trace.rs
@@ -38,9 +38,10 @@ fn cell<'a>(r: &'a Record, k: &str) -> Result<&'a str, String> {
         .ok_or_else(|| format!("missing column {k}"))
 }
 fn num(r: &Record, k: &str) -> Result<u64, String> {
-    cell(r, k)?
-        .parse()
-        .map_err(|_| format!("column {k} is not an unsigned integer"))
+    pycompat::num::parse_int(cell(r, k)?)
+        .ok()
+        .and_then(|v| u64::try_from(v).ok())
+        .ok_or_else(|| format!("column {k} is not an unsigned ASCII integer"))
 }
 fn traces(path: &str, out: &mut dyn Write) -> Result<Vec<Record>, String> {
     let mut rows: Vec<Record> = Vec::new();
@@ -48,7 +49,7 @@ fn traces(path: &str, out: &mut dyn Write) -> Result<Vec<Record>, String> {
     records(path, |r| {
         let id = cell(&r, "task_id")?.to_owned();
         if let Some(&i) = ids.get(&id) {
-            let first: &Record = &rows[i];
+            let first: &mut Record = &mut rows[i];
             let a = cell(first, "exit")?;
             let b = cell(&r, "exit")?;
             if (a != "-" && b != "-" && a != b)
@@ -57,6 +58,9 @@ fn traces(path: &str, out: &mut dyn Write) -> Result<Vec<Record>, String> {
             {
                 return Err(format!("task {id} has two different rows in the trace"));
             }
+            if a == "-" && b != "-" {
+                first.insert("exit".into(), b.into());
+            }
             writeln!(
                 out,
                 "{}: attempt {} is written twice in the trace; counted once",
diff --git a/rust/crates/og-dev/src/smoke.rs b/rust/crates/og-dev/src/smoke.rs
index 950d023cf..b95bb6470 100644
--- a/rust/crates/og-dev/src/smoke.rs
+++ b/rust/crates/og-dev/src/smoke.rs
@@ -51,6 +51,31 @@ fn write_fasta(path: &str, seq: &[u8]) -> Result<(), String> {
     }
     out.commit().map_err(|e| e.to_string())
 }
+fn integer(s: Option<&&str>) -> Result<i128, String> {
+    let s = *s.ok_or("missing integer field")?;
+    // Python int accepts every Unicode decimal digit. Nd runs contain one
+    // or more adjacent 0..9 alphabets (the mathematical digits have five).
+    let normalized;
+    let s = if s.is_ascii() {
+        s
+    } else {
+        normalized = s
+            .chars()
+            .map(|c| {
+                if c.is_ascii() || !pycompat::text::is_decimal(c) {
+                    return c;
+                }
+                let mut start = c as u32;
+                while char::from_u32(start - 1).is_some_and(pycompat::text::is_decimal) {
+                    start -= 1;
+                }
+                char::from(b'0' + ((c as u32 - start) % 10) as u8)
+            })
+            .collect::<String>();
+        &normalized
+    };
+    pycompat::num::parse_int(s).map_err(|e| format!("invalid integer: {e}"))
+}
 fn number(s: &str) -> Result<usize, String> {
     s.parse().map_err(|_| format!("invalid integer: {s}"))
 }
@@ -280,13 +305,14 @@ fn check(kind: &str, path: &str, out: &mut dyn Write) -> Result<bool, String> {
                 }
                 if r.first() == Some(&"S")
                     && float(r.get(4))? >= 4.
-                    && float(r.get(3))? - float(r.get(2))? >= 50000.
+                    && integer(r.get(3))?.saturating_sub(integer(r.get(2))?) >= 50000
                 {
-                    let a = float(r.get(2))?;
-                    let b = float(r.get(3))?;
+                    let a = integer(r.get(2))?;
+                    let b = integer(r.get(3))?;
                     n += 1;
-                    coverage += (b.min(2600000.) - a.max(2000000.)).max(0.);
-                    if b <= 2000000. || a >= 2600000. {
+                    coverage +=
+                        (b.clamp(2000000, 2600000) - a.clamp(2000000, 2600000)).max(0) as f64;
+                    if b <= 2000000 || a >= 2600000 {
                         outside += 1;
                     }
                 }
@@ -319,10 +345,10 @@ fn check(kind: &str, path: &str, out: &mut dyn Write) -> Result<bool, String> {
                 if line.starts_with('#') {
                     continue;
                 }
-                let a = float(r.get(1))?;
-                let b = float(r.get(2))?;
+                let a = integer(r.get(1))?;
+                let b = integer(r.get(2))?;
                 n += 1;
-                for (j, p) in [5000000., 15000000.].iter().enumerate() {
+                for (j, p) in [5000000, 15000000].iter().enumerate() {
                     if at[j].is_none() && a <= *p && *p < b {
                         at[j] = Some([
                             r.get(6).ok_or("short RFMix row")?.to_string(),
diff --git a/rust/crates/og-dev/tests/ci_readers.rs b/rust/crates/og-dev/tests/ci_readers.rs
index a497e9307..9622b44b3 100644
--- a/rust/crates/og-dev/tests/ci_readers.rs
+++ b/rust/crates/og-dev/tests/ci_readers.rs
@@ -319,3 +319,317 @@ fn pca_nonfinite_values_follow_python_comparisons() {
     let p = t.file("quoted.tsv", "# a comment\n\"chr5\"\t1\t2\ta\tb\tc\t\t99\n");
     assert_eq!(run(smoke::cli, &["check", "parascopy", &p]).0, 1);
 }
+
+#[test]
+fn smoke_coordinates_require_integers() {
+    let t = Temp::new();
+    for bad in ["-inf", "inf", "nan", "2000000.0"] {
+        for text in [
+            format!("h\nS 22 {bad} 2600000 4\n"),
+            format!("h\nS 22 2000000 {bad} 4\n"),
+        ] {
+            let p = t.file("ibdmix", &text);
+            assert_ne!(run(smoke::cli, &["check", "ibdmix", &p]).0, 0, "{text}");
+        }
+        for text in [
+            format!(
+                "#codes: POPA=0 POPB=1\n20 {bad} 10000000 0 0 0 0 0\n20 10000000 20000000 0 0 0 1 1\n"
+            ),
+            format!(
+                "#codes: POPA=0 POPB=1\n20 0 {bad} 0 0 0 0 0\n20 10000000 20000000 0 0 0 1 1\n"
+            ),
+        ] {
+            let p = t.file("rfmix", &text);
+            assert_ne!(run(smoke::cli, &["check", "rfmix", &p]).0, 0, "{text}");
+        }
+    }
+    let p = t.file("ints", "h\nS 22 +2_000_000 2_600_000 4.0\n");
+    assert_eq!(run(smoke::cli, &["check", "ibdmix", &p]).0, 0);
+}
+
+#[test]
+fn trace_retains_concrete_duplicate_exit() {
+    let t = Temp::new();
+    let first = "task_id\tname\tattempt\texit\tmemory\n1\tPRS (s)\t1\t-\t25769803776\n";
+    let p = t.file(
+        "trace",
+        &format!("{first}1\tPRS (s)\t1\t137\t25769803776\n"),
+    );
+    let args = [
+        "attempts",
+        &p,
+        "--name-glob",
+        "PRS (s)",
+        "--want",
+        "1:137:24",
+        "--nextflow-exit",
+        "0",
+    ];
+    assert_eq!(run(nf_trace::cli, &args).0, 0);
+    t.file(
+        "trace",
+        &format!("{first}1\tPRS (s)\t1\t137\t25769803776\n1\tPRS (s)\t1\t0\t25769803776\n"),
+    );
+    assert_eq!(run(nf_trace::cli, &args).0, 2);
+}
+
+#[test]
+fn trace_integer_policy() {
+    let t = Temp::new();
+    let p = t.file("spaces", &TRACE.replace("\t8\t", "\t +8 \t"));
+    let want = t.file(
+        "want",
+        "process\tcpus\tmemory_gb\ttime_h\nALIGN_MINIMAP2\t8\t32\t24\n",
+    );
+    let args = [
+        "requests",
+        &p,
+        "--want",
+        &want,
+        "--executor-cpus",
+        "16",
+        "--executor-mem-gb",
+        "96",
+    ];
+    assert_eq!(run(nf_trace::cli, &args).0, 0);
+    t.file("spaces", &TRACE.replace("\t8\t", "\t٨\t"));
+    assert_eq!(run(nf_trace::cli, &args).0, 2);
+}
+
+/// Run explicitly with a full git history and Python available. The oracle
+/// is the actual replaced assertion, not a second maintained implementation.
+#[test]
+#[ignore = "requires archived source and a local Python interpreter"]
+fn differential_coordinate_controls() {
+    use std::process::Command;
+    let t = Temp::new();
+    let repo = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../..");
+    let archived = Command::new("git")
+        .arg("-C")
+        .arg(&repo)
+        .args([
+            "show",
+            "669a8196cf4c377200f9b4af9c235ef85fb774a1:tests/smoke/commands.tsv",
+        ])
+        .output()
+        .unwrap();
+    assert!(archived.status.success());
+    let table = String::from_utf8(archived.stdout).unwrap();
+    for (kind, var, name) in [
+        ("ibdmix", "IBDMIX_IMAGE", "o.txt"),
+        ("rfmix", "RFMIX_IMAGE", "o.msp.tsv"),
+    ] {
+        let row = table
+            .lines()
+            .find(|l| l.starts_with(&format!("{var}\t")))
+            .unwrap();
+        let expect = row.split('\t').nth(4).unwrap();
+        let code = expect
+            .split("\" \"")
+            .nth(1)
+            .unwrap()
+            .strip_suffix('"')
+            .unwrap();
+        for value in [
+            "2000000",
+            "+2_000_000",
+            "٢٠٠٠٠٠٠",
+            "𝟚𝟘𝟘𝟘𝟘𝟘𝟘",
+            "-inf",
+            "inf",
+            "nan",
+            "2000000.0",
+        ] {
+            for column in [0, 1] {
+                let mut bounds = ["2000000", "2600000"];
+                bounds[column] = value;
+                let text = if kind == "ibdmix" {
+                    format!("h\nS 22 {} {} 4\n", bounds[0], bounds[1])
+                } else {
+                    let a = if column == 0 { value } else { "0" };
+                    let b = if column == 1 { value } else { "10000000" };
+                    format!(
+                        "#codes: POPA=0 POPB=1\n20 {a} {b} 0 0 0 0 0\n20 10000000 20000000 0 0 0 1 1\n"
+                    )
+                };
+                let p = t.file(name, &text);
+                let old = Command::new("python3")
+                    .args(["-I", "-c", code])
+                    .current_dir(&t.0)
+                    .output()
+                    .unwrap();
+                let new = run(smoke::cli, &["check", kind, &p]);
+                assert_eq!(
+                    old.status.success(),
+                    new.0 == 0,
+                    "{kind} col={column} value={value}: {}",
+                    new.2
+                );
+                println!(
+                    "{kind} col={column} value={value}: Python={} Rust={}",
+                    old.status.success(),
+                    new.0
+                );
+            }
+        }
+    }
+}
+
+#[test]
+#[ignore = "requires archived source, jq and a local Python interpreter"]
+fn differential_json_controls() {
+    use std::process::Command;
+    let t = Temp::new();
+    let repo = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../..");
+    let archived = Command::new("git")
+        .arg("-C")
+        .arg(&repo)
+        .args([
+            "show",
+            "669a8196cf4c377200f9b4af9c235ef85fb774a1:tests/smoke/commands.tsv",
+        ])
+        .output()
+        .unwrap();
+    assert!(archived.status.success());
+    let old_table = String::from_utf8(archived.stdout).unwrap();
+    let new_table = std::fs::read_to_string(repo.join("tests/smoke/commands.tsv")).unwrap();
+    let script = std::fs::read_to_string(repo.join("scripts/ci/image-smoke.sh")).unwrap();
+    let helper = script
+        .split("jqcheck() {")
+        .nth(1)
+        .unwrap()
+        .split("\n}\n")
+        .next()
+        .unwrap();
+    let helper = format!(
+        "CHECK_FAILS=0; pass() {{ :; }}; fail() {{ CHECK_FAILS=1; }}; jqcheck() {{{helper}\n}}\njqcheck control \"$1\" \"$2\"; exit \"$CHECK_FAILS\""
+    );
+    for (var, index, file, template, good) in [
+        (
+            "FASTP_IMAGE",
+            0,
+            "fastp.json",
+            "{\"summary\":{\"before_filtering\":{\"total_reads\":100},\"after_filtering\":{\"total_reads\":VALUE}}}",
+            "90",
+        ),
+        (
+            "EXPANSIONHUNTER_IMAGE",
+            0,
+            "bundled_catalog.json",
+            "VALUE",
+            "[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]",
+        ),
+        (
+            "EXPANSIONHUNTER_IMAGE",
+            1,
+            "eh.json",
+            "{\"LocusResults\":{\"SMOKE1\":{\"Variants\":{\"SMOKE1\":{\"Genotype\":VALUE}}}}}",
+            "\"12/12\"",
+        ),
+        (
+            "PARAPHASE_IMAGE",
+            0,
+            "smn1.json",
+            "{\"smn1\":{\"region_specific_info\":{\"smn1_cn\":2,\"smn2_cn\":VALUE,\"smn_del78_cn\":1}}}",
+            "1",
+        ),
+        (
+            "PYTHON_IMAGE",
+            0,
+            "HG002_cyp2d6.json",
+            "{\"HG002_cyrius\":{\"Median_depth\":VALUE,\"Coverage_MAD\":0,\"Genotype\":\"test\"}}",
+            "20",
+        ),
+    ] {
+        let row = |table: &str| {
+            table
+                .lines()
+                .find(|l| l.starts_with(&format!("{var}\t")))
+                .unwrap()
+                .split('\t')
+                .nth(4)
+                .unwrap()
+                .to_owned()
+        };
+        let old = row(&old_table);
+        let code = old
+            .split("py \"")
+            .nth(index + 1)
+            .unwrap()
+            .split("\" \"")
+            .nth(1)
+            .unwrap()
+            .split('"')
+            .next()
+            .unwrap();
+        let new = row(&new_table);
+        let filter = new
+            .split("jqcheck \"")
+            .nth(index + 1)
+            .unwrap()
+            .split('\'')
+            .nth(1)
+            .unwrap();
+        for value in [
+            good,
+            "\"broken\"",
+            "null",
+            "[]",
+            "{}",
+            "true",
+            "false",
+            "20",
+            "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaa\"",
+        ] {
+            let json = template.replace("VALUE", value);
+            let p = t.file(file, &json);
+            let python = Command::new("python3")
+                .args(["-I", "-c", code])
+                .current_dir(&t.0)
+                .output()
+                .unwrap();
+            let rust = Command::new("bash")
+                .args(["-c", &helper, "_", &p, filter])
+                .output()
+                .unwrap();
+            let deliberate = (var == "EXPANSIONHUNTER_IMAGE"
+                && ((index == 0 && value.starts_with('"'))
+                    || (index == 1 && ["true", "20"].contains(&value))))
+                || (["PARAPHASE_IMAGE", "PYTHON_IMAGE"].contains(&var) && value == "true");
+            if deliberate {
+                assert!(!rust.status.success(), "typed policy: {var} {value}");
+            } else {
+                assert_eq!(
+                    python.status.success(),
+                    rust.status.success(),
+                    "{var} {index} {value}: {}",
+                    String::from_utf8_lossy(&python.stderr)
+                );
+            }
+            println!(
+                "{var}/{index} {value}: Python={} jq={} deliberate={deliberate}",
+                python.status.success(),
+                rust.status.success()
+            );
+        }
+        let valid = template.replace("VALUE", good);
+        let p = t.file(file, &format!("{valid}\n{valid}\n"));
+        assert!(
+            !Command::new("python3")
+                .args(["-I", "-c", code])
+                .current_dir(&t.0)
+                .output()
+                .unwrap()
+                .status
+                .success()
+        );
+        assert!(
+            !Command::new("bash")
+                .args(["-c", &helper, "_", &p, filter])
+                .output()
+                .unwrap()
+                .status
+                .success()
+        );
+    }
+}
diff --git a/rust/crates/og-io/src/lib.rs b/rust/crates/og-io/src/lib.rs
index 363b9ceeb..1943c18be 100644
--- a/rust/crates/og-io/src/lib.rs
+++ b/rust/crates/og-io/src/lib.rs
@@ -110,7 +110,7 @@ pub enum Utf8 {
 pub struct Lines<R> {
     inner: R,
     raw: Vec<u8>,
-    pos: usize,
+    skip_lf: bool,
     utf8: Utf8,
 }
 
@@ -119,7 +119,7 @@ impl<R: BufRead> Lines<R> {
         Lines {
             inner,
             raw: Vec::new(),
-            pos: 0,
+            skip_lf: false,
             utf8,
         }
     }
@@ -128,25 +128,36 @@ impl<R: BufRead> Lines<R> {
     /// `\n` (none on a last line without one), or `false` at the end.
     pub fn read_line(&mut self, out: &mut String) -> io::Result<bool> {
         out.clear();
-        if self.pos == self.raw.len() {
-            self.raw.clear();
-            self.pos = 0;
-            if self.inner.read_until(b'\n', &mut self.raw)? == 0 {
-                return Ok(false);
+        self.raw.clear();
+        // A CR ends this record immediately. Consume a following LF on the
+        // next call, including when CR is the last byte of a buffer.
+        if self.skip_lf {
+            if self.inner.fill_buf()?.first() == Some(&b'\n') {
+                self.inner.consume(1);
             }
+            self.skip_lf = false;
         }
-        let rest = &self.raw[self.pos..];
-        // read_until stops after a \n or at the end, so a \r\n is never split.
-        let (body, used) = match rest.iter().position(|&c| c == b'\n' || c == b'\r') {
-            None => (rest, rest.len()),
-            Some(k) if rest[k] == b'\r' && rest.get(k + 1) == Some(&b'\n') => (&rest[..k], k + 2),
-            Some(k) => (&rest[..k], k + 1),
+        let ended = loop {
+            let bytes = self.inner.fill_buf()?;
+            if bytes.is_empty() {
+                if self.raw.is_empty() {
+                    return Ok(false);
+                }
+                break false;
+            }
+            if let Some(k) = bytes.iter().position(|&b| b == b'\r' || b == b'\n') {
+                self.raw.extend_from_slice(&bytes[..k]);
+                self.skip_lf = bytes[k] == b'\r';
+                self.inner.consume(k + 1);
+                break true;
+            }
+            let n = bytes.len();
+            self.raw.extend_from_slice(bytes);
+            self.inner.consume(n);
         };
-        let ended = used > body.len();
-        // Past the line before decoding it, so a strict error is not raised
-        // again for the same line by a caller that goes on reading. (Python
-        // raises once too; a caller is expected to stop at the error.)
-        self.pos += used;
+        // Consume the record before decoding so a strict UTF-8 error is
+        // raised only once when a caller continues with the next record.
+        let body = &self.raw;
         match self.utf8 {
             Utf8::Strict => out.push_str(
                 std::str::from_utf8(body)
@@ -349,3 +360,58 @@ mod tests {
         fs::remove_dir_all(&dir).unwrap();
     }
 }
+
+#[cfg(test)]
+mod bounded_line_tests {
+    use super::*;
+
+    #[test]
+    fn all_endings_and_buffer_edges() {
+        for bytes in [
+            b"a\nb\n".as_slice(),
+            b"a\r\nb\r\n",
+            b"a\rb\r",
+            b"a\r\nb\rc\nd",
+            b"tail",
+            b"",
+        ] {
+            for capacity in 1..=8 {
+                let mut input = Lines::new(
+                    BufReader::with_capacity(capacity, io::Cursor::new(bytes)),
+                    Utf8::Strict,
+                );
+                let mut got = Vec::new();
+                let mut line = String::new();
+                while input.read_line(&mut line).unwrap() {
+                    got.push(line.clone());
+                }
+                let normalized = String::from_utf8(bytes.to_vec())
+                    .unwrap()
+                    .replace("\r\n", "\n")
+                    .replace('\r', "\n");
+                let want: Vec<_> = normalized.split_inclusive('\n').collect();
+                assert_eq!(got, want, "capacity {capacity}: {bytes:?}");
+            }
+        }
+    }
+
+    #[test]
+    fn cr_only_storage_is_bounded_by_one_line() {
+        let input = b"a,b\r".repeat(1 << 18);
+        let mut input = Lines::new(
+            BufReader::with_capacity(64, io::Cursor::new(input)),
+            Utf8::Strict,
+        );
+        let mut line = String::new();
+        for _ in 0..1 << 18 {
+            assert!(input.read_line(&mut line).unwrap());
+            assert_eq!(line, "a,b\n");
+            assert!(
+                input.raw.capacity() <= 64,
+                "buffer grew to {} bytes",
+                input.raw.capacity()
+            );
+        }
+        assert!(!input.read_line(&mut line).unwrap());
+    }
+}
diff --git a/scripts/ci/image-smoke.sh b/scripts/ci/image-smoke.sh
index 89d55911e..ef21b6a67 100755
--- a/scripts/ci/image-smoke.sh
+++ b/scripts/ci/image-smoke.sh
@@ -146,6 +146,71 @@ self_test() {
   if grep -q '^\[PASS\] true filter' <<< "$out" && grep -q '^\[FAIL\] false filter' <<< "$out" && grep -q '^fails=1$' <<< "$out"; then
     echo "[PASS] jqcheck rejects a false filter"
   else echo "[FAIL] jqcheck rejects a false filter: $out"; fails=$((fails + 1)); fi
+  # Read the production filters, so a weakened assertion makes this test red.
+  local counts catalog genotype copies depth
+  counts=$(awk -F '\t' '$1 == "FASTP_IMAGE" {print $5}' "$TABLE" | cut -d "'" -f 2)
+  catalog=$(awk -F '\t' '$1 == "EXPANSIONHUNTER_IMAGE" {print $5}' "$TABLE" | cut -d "'" -f 2)
+  genotype=$(awk -F '\t' '$1 == "EXPANSIONHUNTER_IMAGE" {print $5}' "$TABLE" | cut -d "'" -f 4)
+  copies=$(awk -F '\t' '$1 == "PARAPHASE_IMAGE" {print $5}' "$TABLE" | cut -d "'" -f 2)
+  depth=$(awk -F '\t' '$1 == "PYTHON_IMAGE" {print $5}' "$TABLE" | cut -d "'" -f 2)
+  json_case() {
+    local label=$1 filter=$2 json=$3 want=$4
+    printf '%s\n' "$json" > "${tmp}/control.json"
+    out=$(CHECK_FAILS=0; jqcheck "$label" "${tmp}/control.json" "$filter"; echo "fails=$CHECK_FAILS")
+    if grep -qx "fails=$want" <<< "$out"; then echo "[PASS] $label"
+    else echo "[FAIL] $label: $out"; fails=$((fails + 1)); fi
+  }
+  json_case "numeric counts" "$counts" '{"summary":{"before_filtering":{"total_reads":100},"after_filtering":{"total_reads":90}}}' 0
+  json_case "one JSON document" "$counts" $'{"summary":{"before_filtering":{"total_reads":100},"after_filtering":{"total_reads":0}}}\n{"summary":{"before_filtering":{"total_reads":100},"after_filtering":{"total_reads":90}}}' 1
+  json_case "array catalog" "$catalog" "[$(printf '0,%.0s' {1..19})0]" 0
+  json_case "string genotype" "$genotype" '{"LocusResults":{"SMOKE1":{"Variants":{"SMOKE1":{"Genotype":"12/12"}}}}}' 0
+  json_case "numeric copy numbers" "$copies" '{"smn1":{"region_specific_info":{"smn1_cn":2,"smn2_cn":1,"smn_del78_cn":1}}}' 0
+  json_case "numeric depth" "$depth" '{"HG002_cyrius":{"Median_depth":20}}' 0
+  json_case "numeric string depth" "$depth" '{"HG002_cyrius":{"Median_depth":"20"}}' 0
+  local bad
+  for bad in '"broken"' null '[]' '{}' true false; do
+    json_case "output count rejects $bad" "$counts" "{\"summary\":{\"before_filtering\":{\"total_reads\":100},\"after_filtering\":{\"total_reads\":$bad}}}" 1
+    json_case "input count rejects $bad" "$counts" "{\"summary\":{\"before_filtering\":{\"total_reads\":$bad},\"after_filtering\":{\"total_reads\":90}}}" 1
+    json_case "catalog rejects $bad" "$catalog" "$bad" 1
+    json_case "copy numbers reject $bad" "$copies" "{\"smn1\":{\"region_specific_info\":{\"smn1_cn\":2,\"smn2_cn\":$bad,\"smn_del78_cn\":1}}}" 1
+    json_case "depth rejects $bad" "$depth" "{\"HG002_cyrius\":{\"Median_depth\":$bad}}" 1
+  done
+  for bad in 1 null '[]' '{}' true false '""'; do
+    json_case "genotype rejects $bad" "$genotype" "{\"LocusResults\":{\"SMOKE1\":{\"Variants\":{\"SMOKE1\":{\"Genotype\":$bad}}}}}" 1
+  done
+  for filter in "$counts" "$catalog" "$genotype" "$copies" "$depth"; do
+    json_case "missing keys fail" "$filter" '{}' 1
+  done
+  json_case "numeric catalog fails" "$catalog" '20' 1
+  json_case "long string catalog fails" "$catalog" '"aaaaaaaaaaaaaaaaaaaaaaaaaaaa"' 1
+  json_case "no JSON document fails" "$counts" '' 1
+  mkdir -p "${tmp}/repo/bin" "${tmp}/repo/scripts"
+  cat > "${tmp}/repo/bin/og" <<'SH'
+#!/usr/bin/env bash
+[ -f "$(dirname "$0")/../ready" ] || exit 127
+printf '%s\n' "$*"
+SH
+  cat > "${tmp}/repo/scripts/setup.sh" <<'SH'
+#!/usr/bin/env bash
+[ "$1" = --og ] || exit 2
+printf 'built\n' >> "$(dirname "$0")/../ready"
+SH
+  chmod +x "${tmp}/repo/bin/og"
+  # shellcheck disable=SC2016  # variables belong to the isolated test shell
+  out=$(env -u OG REPO="${tmp}/repo" bash -c "$(declare -f smoke_og)"'
+    rc=0
+    "$REPO/bin/og" dev smoke mini-ref >/dev/null 2>&1 || rc=$?
+    [ "$rc" -eq 127 ] || exit 1
+    smoke_og dev smoke mini-ref || exit 1
+    smoke_og dev smoke csv-cell || exit 1
+    [ "$(wc -l < "$REPO/ready")" -eq 1 ] || exit 1
+    OG="$REPO/bin/absent"
+    rc=0
+    smoke_og version >/dev/null 2>&1 || rc=$?
+    [ "$rc" -eq 127 ] || exit 1
+  '); rc=$?
+  if [ "$rc" -eq 0 ]; then echo "[PASS] missing default og is built once; explicit OG failure is retained"
+  else echo "[FAIL] og fixture preparation: $out"; fails=$((fails + 1)); fi
   rm -rf "$tmp"
   if [ "$fails" -gt 0 ]; then echo "self-test: ${fails} case(s) failed" >&2; return 1; fi
   echo "self-test: all cases passed"
@@ -296,7 +361,7 @@ need() {
 need_ref() {
   fx_get fixture_ref.fa.gz fixture_ref.fa.gz.fai fixture_ref.fa.gz.gzi || return 1
   hsam faidx /fx/fixture_ref.fa.gz chr20:10000001-10500000 > "${IN}/slice.fa.tmp" || return 1
-  "${OG:-${REPO}/bin/og}" dev smoke mini-ref "${IN}/slice.fa.tmp" "${IN}/orig.fa" "${IN}/mini.fa" "$PLANT_POS" "$PLANT_LEN" || return 1
+  smoke_og dev smoke mini-ref "${IN}/slice.fa.tmp" "${IN}/orig.fa" "${IN}/mini.fa" "$PLANT_POS" "$PLANT_LEN" || return 1
   rm -f "${IN}/slice.fa.tmp"
   hsam faidx /in/orig.fa && hsam faidx /in/mini.fa && hsam dict -o /in/mini.dict /in/mini.fa || return 1
   [ "$(cut -f2 "${IN}/mini.fa.fai")" = "$MINI_LEN" ]
@@ -348,7 +413,7 @@ need_longreads() {
   need ref && need truth || return 1
   hbcf consensus -H 1 -f /in/orig.fa /in/truth.vcf.gz > "${IN}/hap1.fa" &&
     hbcf consensus -H 2 -f /in/orig.fa /in/truth.vcf.gz > "${IN}/hap2.fa" || return 1
-  "${OG:-${REPO}/bin/og}" dev smoke long-reads "${IN}/hap1.fa" "${IN}/hap2.fa" "${IN}/long.fq.gz"
+  smoke_og dev smoke long-reads "${IN}/hap1.fa" "${IN}/hap2.fa" "${IN}/long.fq.gz"
 }
 need_longbam() {
   need longreads || return 1
@@ -429,7 +494,7 @@ need_qc() {
 # in the mini reference, away from the slice ends and the planted bases.
 need_ehcatalog() {
   need ref || return 1
-  "${OG:-${REPO}/bin/og}" dev smoke eh-catalog "${IN}/mini.fa" "${IN}/eh_catalog.json" "$SMALL_END"
+  smoke_og dev smoke eh-catalog "${IN}/mini.fa" "${IN}/eh_catalog.json" "$SMALL_END"
 }
 # A chain that maps chr20 onto itself over the region of the small variants.
 need_chain() {
@@ -470,12 +535,24 @@ contains() { if [ -f "$2" ] && grep -Eq -- "$3" "$2"; then pass "$1"; else fail
 nonempty() { if [ -s "$2" ]; then pass "$1"; else fail "$1 (${2} is missing or empty)"; fi; }
 jqcheck() {
   local out
-  if out=$(jq -e "$3" "$2" 2>&1); then pass "$1${out:+ (${out//$'\n'/ })}"
+  if out=$(jq -se "if length == 1 then .[0] | ($3) else error(\"expected exactly one JSON document\") end" "$2" 2>&1); then pass "$1${out:+ (${out//$'\n'/ })}"
   else fail "$1: ${out//$'\n'/ }"; fi
 }
+# Build only when a fixture or assertion first needs og. A caller-supplied
+# OG is authoritative; its failure must not silently select another binary.
+smoke_og() {
+  local rc=0
+  "${OG:-${REPO}/bin/og}" --version >/dev/null 2>&1 || rc=$?
+  if [ "$rc" -eq 127 ] && [ -z "${OG:-}" ]; then
+    bash "${REPO}/scripts/setup.sh" --og || return 1
+  elif [ "$rc" -ne 0 ]; then
+    return "$rc"
+  fi
+  "${OG:-${REPO}/bin/og}" "$@"
+}
 smoke_check() {
   local out
-  if out=$("${OG:-${REPO}/bin/og}" dev smoke check "$2" "$3" 2>&1); then pass "$1 ($out)"
+  if out=$(smoke_og dev smoke check "$2" "$3" 2>&1); then pass "$1 ($out)"
   else fail "$1: $out"; fi
 }
 check_pharmcat() {
@@ -528,11 +605,11 @@ tsv_count() {
 }
 # csv_cell FILE KEY=VALUE[,KEY=VALUE] COLUMN: COLUMN of the first row that matches.
 csv_cell() {
-  "${OG:-${REPO}/bin/og}" dev smoke csv-cell "$1" "$2" "$3"
+  smoke_og dev smoke csv-cell "$1" "$2" "$3"
 }
 # pharmcat_called report.json: genes with a named diplotype.
 pharmcat_called() {
-  "${OG:-${REPO}/bin/og}" dev pharmcat diplotypes "$1" --called
+  smoke_og dev pharmcat diplotypes "$1" --called
 }
 
 # ------------------------------------------------------------- the runner
diff --git a/tests/smoke/commands.tsv b/tests/smoke/commands.tsv
index ff757048e..e7387040c 100644
--- a/tests/smoke/commands.tsv
+++ b/tests/smoke/commands.tsv
@@ -7,7 +7,7 @@ MINIMAP2_SAMTOOLS_IMAGE	-	ref,reads,bam	minimap2 --version > minimap2_version.tx
 SAMTOOLS_HTTPS_IMAGE	net	-	samtools view -H https://ftp.sra.ebi.ac.uk/vol1/run/ERR323/ERR3239334/NA12878.final.cram > h.sam	same "@SQ lines of the docs/quick-test.md CRAM header, read over https" "$(grep -c '^@SQ' h.sam)" 3366; contains "chr22 among them" h.sam "^@SQ[[:space:]]SN:chr22[[:space:]]"
 BCFTOOLS_IMAGE	-	ref,truth,vcf	bcftools view -Ob -o a.bcf /in/sample.vcf.gz && bcftools index a.bcf && bcftools view -Oz -o b.vcf.gz a.bcf && bcftools index -t b.vcf.gz && bcftools view -H b.vcf.gz | wc -l > n.txt && bcftools +split-vep -l /in/sample.vcf.gz > csq.txt && bcftools norm -m-both -f /in/mini.fa -Oz -o norm.vcf.gz /in/truth.vcf.gz && bcftools isec -n=2 -w1 -Oz -o shared.vcf.gz /in/truth.vcf.gz /in/query90.vcf.gz && bcftools view -H shared.vcf.gz | wc -l > shared.txt	same "records after a VCF to BCF to VCF round trip" "$(tr -d " " < n.txt)" "$(grep -vc "^#" "$FX/HG002_vep.vcf")"; contains "split-vep lists the CSQ fields" csq.txt "Consequence"; same "records isec finds in truth and query" "$(tr -d " " < shared.txt)" "$(vcf_records /in/query90.vcf.gz)"; at_least "records after norm" "$(vcf_records norm.vcf.gz)" 300
 DEEPVARIANT_IMAGE	-	ref,bam,truth	/opt/deepvariant/bin/run_deepvariant --model_type=WGS --ref=/in/mini.fa --reads=/in/mini.bam --output_vcf=dv.vcf.gz --sample_name=HG002 --num_shards=4 --regions chr20:1-449000 --intermediate_results_dir tmp	at_least "SNV recall against the GIAB truth" "$(snv_recall dv.vcf.gz)" 0.95; same "sample column" "$(bcf query -l dv.vcf.gz)" HG002
-FASTP_IMAGE	-	reads	fastp -i /in/reads_R1.fq.gz -I /in/reads_R2.fq.gz -o t_R1.fq.gz -O t_R2.fq.gz --detect_adapter_for_pe --qualified_quality_phred 20 --cut_front --cut_tail --cut_mean_quality 20 --length_required 36 -g -R HG002 -j fastp.json -h fastp.html	jqcheck "trimmed reads kept (at least 80 %)" fastp.json '.summary | .before_filtering.total_reads as $b | .after_filtering.total_reads as $a | $b > 0 and $a >= 0.8 * $b'
+FASTP_IMAGE	-	reads	fastp -i /in/reads_R1.fq.gz -I /in/reads_R2.fq.gz -o t_R1.fq.gz -O t_R2.fq.gz --detect_adapter_for_pe --qualified_quality_phred 20 --cut_front --cut_tail --cut_mean_quality 20 --length_required 36 -g -R HG002 -j fastp.json -h fastp.html	jqcheck "trimmed reads kept (at least 80 %)" fastp.json '.summary | .before_filtering.total_reads as $b | .after_filtering.total_reads as $a | ($b | type == "number") and ($a | type == "number") and $b > 0 and $a >= 0.8 * $b'
 BWAMEM2_IMAGE	-	ref,reads	bwa-mem2 index -p mini /in/mini.fa && bwa-mem2 mem -t 4 -o bwamem2.sam -R '@RG\tID:HG002\tSM:HG002\tPL:ILLUMINA\tLB:HG002' mini /in/reads_R1.fq.gz /in/reads_R2.fq.gz	at_least "reads mapped (%)" "$(mapped_pct bwamem2.sam)" 95
 BWA_IMAGE	-	ref,reads	bwa index -p mini /in/mini.fa && bwa mem -t 4 -R '@RG\tID:HG002\tSM:HG002' mini /in/reads_R1.fq.gz /in/reads_R2.fq.gz > bwa.sam	at_least "reads mapped (%)" "$(mapped_pct bwa.sam)" 95
 FREEBAYES_IMAGE	-	ref,bam,truth	freebayes -f /in/mini.fa --region chr20:1-449000 /in/mini.bam > freebayes.vcf	at_least "SNV recall against the GIAB truth" "$(snv_recall freebayes.vcf)" 0.9
@@ -41,7 +41,7 @@ YLEAF_IMAGE	net,also=YLEAF_DATA_SHA256	-	sh /smoke/yleaf.sh	same "the release ar
 HIPSTR_IMAGE	-	fullref,slice	sh /smoke/hipstr.sh	at_least "Y-STR regions HipSTR genotypes in the chrY slices, with GB, DP, Q and DSTUTTER (of 11)" "$(grep -c . called.tsv)" 7; same "a haploid call on chrY (one allele in GT)" "$(awk -F'\t' '$2 ~ /[\/|]/' called.tsv | wc -l | tr -d ' ')" 0; has "the image's Python, which step 45 runs on" "$(cat python_version.txt)" "^Python 3\."; contains "HipSTR's log names the regions it read" hipstr.log "Processing region chrY 6993189 6993257"
 T1K_IMAGE	net	hlareads	sh /smoke/t1k.sh	has "HLA-A allele, one of HG002's (A*01:01, A*26:01)" "$(awk -F'\t' '$1 == "HLA-A" {print $3}' t1k/HG002_hla_genotype.tsv)" "^HLA-A\*(01:01|26:01)"; has "both HLA-A alleles of HG002 (A*01:01 and A*26:01)" "$(awk -F'\t' '$1 == "HLA-A" {print $3, $6}' t1k/HG002_hla_genotype.tsv)" "^HLA-A\*01:01[^ ]* HLA-A\*26:01|^HLA-A\*26:01[^ ]* HLA-A\*01:01"
 OPTITYPE_IMAGE	-	hlareads	sh /smoke/optitype.sh	has "both HLA-A alleles of HG002 (A*01:01 and A*26:01)" "$(awk -F'\t' 'NR == 2 {print $2, $3}' HG002_result.tsv)" "^A\*01:01 A\*26:01$|^A\*26:01 A\*01:01$"; has "two HLA-B alleles" "$(awk -F'\t' 'NR == 2 {print $4, $5}' HG002_result.tsv)" "^B\*[0-9]+:[0-9]+ B\*[0-9]+:[0-9]+$"; at_least "reads OptiType mapped to its HLA sequences" "$(awk -F'\t' 'NR == 1 {for (i = 1; i <= NF; i++) if ($i == "Reads") c = i} NR == 2 {print int($c)}' HG002_result.tsv)" 100
-EXPANSIONHUNTER_IMAGE	-	ref,bam,ehcatalog	sh /smoke/expansionhunter.sh	jqcheck "the bundled GRCh38 catalog has at least 20 loci" bundled_catalog.json 'length >= 20'; jqcheck "a genotype for the repeat on the fixture" eh.json '.LocusResults.SMOKE1.Variants.SMOKE1.Genotype | select(. != null and . != false and . != 0 and . != "" and . != [] and . != {})'
+EXPANSIONHUNTER_IMAGE	-	ref,bam,ehcatalog	sh /smoke/expansionhunter.sh	jqcheck "the bundled GRCh38 catalog has at least 20 loci" bundled_catalog.json 'type == "array" and length >= 20'; jqcheck "a genotype for the repeat on the fixture" eh.json '.LocusResults.SMOKE1.Variants.SMOKE1.Genotype | type == "string" and length > 0'
 GOLEFT_IMAGE	-	slice	goleft indexcov --directory indexcov /in/HG002_slice.bam	at_least "sample rows in the .ped" "$(awk '!/^#/ && NF >= 6' indexcov/indexcov-indexcov.ped | wc -l)" 1
 MOSDEPTH_IMAGE	-	ref,bam	mosdepth --by 500 --fast-mode --no-per-base --threads 4 --thresholds 1,5,10,15,20,30,50 md /in/mini.bam	at_least "mean depth on chr20" "$(awk '$1 == "chr20" {print $4}' md.mosdepth.summary.txt)" 15
 # Zenodo data (homology table and models, ~50 MB) is downloaded in the row, as setup.sh --parascopy-data does.
@@ -49,7 +49,7 @@ PARASCOPY_IMAGE	net,also=PARASCOPY_DATA_VERSION	fullref,slice	sh /smoke/parascop
 # Paraphase reads PacBio HiFi only: the row runs its own demo, the HG01175 SMN1/SMN2 HiFi reads in the release's tests/data,
 # whose result docs/demo.md of that release publishes: two SMN1, one SMN2, one SMN with exons 7-8 deleted.
 # busybox wget does not validate TLS, so the two files are checked against their sha256 in Paraphase v4.1.0.
-PARAPHASE_IMAGE	net	fullref	v=${PARAPHASE_IMAGE##*:} && u=https://raw.githubusercontent.com/PacificBiosciences/paraphase/v${v%%--*}/tests/data/bams/HG01175_smn1_extracted.bam && wget -q -O hg.bam "$u" && wget -q -O hg.bam.bai "${u}.bai" && { printf '%s  hg.bam\n%s  hg.bam.bai\n' c9659364ad9e60e41ee4771cf92dc017313b6b75a1e08df3e8c0e95ef38eadca 8b5dd238fdf1cc508e85105ff2a157a2c3d73aa3f441d08afdba9458beecca51 | sha256sum -c || { echo 'the demo BAM or its index is not the file Paraphase v4.1.0 ships'; exit 1; }; } && paraphase -b hg.bam -r /in/ref.fa -o pp -p HG01175 -g smn1 -t 4 && cp pp/HG01175.paraphase.json smn1.json && rm -rf pp hg.bam hg.bam.bai	jqcheck "SMN1, SMN2 and SMN exon 7-8 deletion copy numbers of HG01175 (2, 1, 1)" smn1.json '.smn1.region_specific_info | [.smn1_cn, .smn2_cn, .smn_del78_cn] == [2, 1, 1]'
+PARAPHASE_IMAGE	net	fullref	v=${PARAPHASE_IMAGE##*:} && u=https://raw.githubusercontent.com/PacificBiosciences/paraphase/v${v%%--*}/tests/data/bams/HG01175_smn1_extracted.bam && wget -q -O hg.bam "$u" && wget -q -O hg.bam.bai "${u}.bai" && { printf '%s  hg.bam\n%s  hg.bam.bai\n' c9659364ad9e60e41ee4771cf92dc017313b6b75a1e08df3e8c0e95ef38eadca 8b5dd238fdf1cc508e85105ff2a157a2c3d73aa3f441d08afdba9458beecca51 | sha256sum -c || { echo 'the demo BAM or its index is not the file Paraphase v4.1.0 ships'; exit 1; }; } && paraphase -b hg.bam -r /in/ref.fa -o pp -p HG01175 -g smn1 -t 4 && cp pp/HG01175.paraphase.json smn1.json && rm -rf pp hg.bam hg.bam.bai	jqcheck "SMN1, SMN2 and SMN exon 7-8 deletion copy numbers of HG01175 (2, 1, 1)" smn1.json '.smn1.region_specific_info | [.smn1_cn, .smn2_cn, .smn_del78_cn] | all(.[]; type == "number") and . == [2, 1, 1]'
 # MEGAnE's call needs a whole chromosome: on mini.fa's 500 kb it stops in its own code (IndexError). The e2e case mei-1 runs it on chr20.
 MEGANE_IMAGE	-	ref	build_kmerset -fa /in/mini.fa -prefix mini -outdir /out/mk && { call_genotype_38 -h > help.txt 2>&1 || true; }	at_least "repeated 32-mers in the k-mer set of mini.fa" "$(cat mk/mini.mi)" 1000; same "the .mk holds the 8-byte k-mers the .mi counts" "$(( $(wc -c < mk/mini.mk) / 8 ))" "$(cat mk/mini.mi)"; contains "call_genotype_38 takes the -mainchr step 50 passes" help.txt "-mainchr"; contains "and -no_sex_chr" help.txt "-no_sex_chr"; contains "and -only_ins" help.txt "-only_ins"
 # Step 52 on VNtyper's own test data, two BAMs read out of its Zenodo archive by range requests (tests/smoke/vntyper_testdata.py,
@@ -66,7 +66,7 @@ WHATSHAP_IMAGE	-	-	H='##fileformat=VCFv4.2\n##contig=<ID=chr20,length=503000>\n#
 HAP_IBD_IMAGE	-	-	awk 'BEGIN { srand(7); printf "##fileformat=VCFv4.2\n##contig=<ID=chr20,length=64444167>\n##FORMAT=<ID=GT,Number=1,Type=String,Description=\"Genotype\">\n#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tA\tB\tC\tD\n" > "t.vcf"; for (j = 1; j <= 2000; j++) { pos = j * 10000; s = (rand() < 0.5); b1 = (j >= 500 && j <= 1500) ? s : (rand() < 0.5); printf "chr20\t%d\t.\tA\tG\t.\tPASS\t.\tGT\t%d|%d\t%d|%d\t%d|%d\t%d|%d\n", pos, s, (rand() < 0.5), b1, (rand() < 0.5), (rand() < 0.5), (rand() < 0.5), (rand() < 0.5), (rand() < 0.5) > "t.vcf"; printf "chr20\t.\t%.4f\t%d\n", pos / 1000000, pos > "g.map" } }' && hap-ibd gt=t.vcf map=g.map out=o > hapibd.log 2>&1	smoke_check "hap-ibd finds the planted 10 cM segment A and B share, and no other" hap-ibd o.ibd.gz
 GATK_IMAGE	-	ref,bam,truth	gatk --java-options -Xmx4g HaplotypeCaller -R /in/mini.fa -I /in/mini.bam -O gatk.vcf.gz -L chr20:1-449000 --native-pair-hmm-threads 4 -ERC NONE	at_least "SNV recall against the GIAB truth" "$(snv_recall gatk.vcf.gz)" 0.9
 PICARD_IMAGE	-	ref,truth,chain	java -Xmx2g -jar /usr/picard/picard.jar LiftoverVcf I=/in/truth.vcf.gz O=lift.vcf.gz CHAIN=/in/identity.chain R=/in/mini.fa REJECT=rejected.vcf.gz WARN_ON_MISSING_CONTIG=true	same "records lifted over an identity chain" "$(vcf_records lift.vcf.gz)" "$(vcf_records /in/truth.vcf.gz)"
-PYTHON_IMAGE	net,also=CYRIUS_VERSION	cyrius	sh /smoke/cyrius.sh	same "Cyrius installed from the hash-locked file" "$(cat installed.txt)" "cyrius ${CYRIUS_VERSION}"; same "the TSV has a row for the sample" "$(tsv_cell HG002_cyp2d6.tsv Sample)" HG002_cyrius; jqcheck "Cyrius read depth from the BAM (median depth above 0)" HG002_cyp2d6.json '.["HG002_cyrius"].Median_depth | tonumber > 0'
+PYTHON_IMAGE	net,also=CYRIUS_VERSION	cyrius	sh /smoke/cyrius.sh	same "Cyrius installed from the hash-locked file" "$(cat installed.txt)" "cyrius ${CYRIUS_VERSION}"; same "the TSV has a row for the sample" "$(tsv_cell HG002_cyp2d6.tsv Sample)" HG002_cyrius; jqcheck "Cyrius read depth from the BAM (median depth above 0)" HG002_cyp2d6.json '.["HG002_cyrius"].Median_depth | (type == "number" or type == "string") and (tonumber > 0)'
 PLINK2_IMAGE	-	vcf	sh /smoke/plink2.sh	between "score sum over five ALT alleles of weight 1" "$(tsv_cell score.sscore SCORE1_SUM)" 5 10
 # Step 26b: two planted groups for ADMIXTURE's supervised fit and the projection of a third person drawn from one of them.
 ADMIXTURE_IMAGE	-	-	awk 'BEGIN { srand(7); for (j = 1; j <= 500; j++) { pa[j] = 0.1 + 0.8 * rand(); pb[j] = 1 - pa[j]; print 1, "s" j, 0, j * 1000 > "d.map"; print 1, "s" j, 0, j * 1000 > "t.map" }; for (i = 1; i <= 40; i++) { g = (i <= 20) ? "A" : "B"; print g > "d.pop"; printf "f%d i%d 0 0 0 -9", i, i > "d.ped"; for (j = 1; j <= 500; j++) { q = (g == "A") ? pa[j] : pb[j]; printf " %d %d", (rand() < q) ? 1 : 2, (rand() < q) ? 1 : 2 > "d.ped" }; printf "\n" > "d.ped" }; printf "t t 0 0 0 -9" > "t.ped"; for (j = 1; j <= 500; j++) printf " %d %d", (rand() < pa[j]) ? 1 : 2, (rand() < pa[j]) ? 1 : 2 > "t.ped"; printf "\n" > "t.ped" }' && admixture --supervised d.ped 2 > sup.log 2>&1 && cp d.2.P t.2.P.in && admixture -P t.ped 2 > proj.log 2>&1	contains "the supervised run on two planted groups converged" sup.log "Converged"; between "the projected person's share of the group it was drawn from" "$(awk '{print ($1 > $2 ? $1 : $2)}' t.2.Q)" 0.9 1

From 3c2c2f288c5ac516c22ed85b6aa8b04e43e734c6 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 16:11:04 +0100
Subject: [PATCH 48/76] test(ci): expose nullable-pattern and raw-path scan
 gaps

---
 rust/crates/og-dev/src/lookaround.rs    |  21 ++++
 rust/crates/og-dev/src/personal_data.rs | 124 ++++++++++++++++++++++++
 2 files changed, 145 insertions(+)

diff --git a/rust/crates/og-dev/src/lookaround.rs b/rust/crates/og-dev/src/lookaround.rs
index f95bd3935..73c2c332d 100644
--- a/rust/crates/og-dev/src/lookaround.rs
+++ b/rust/crates/og-dev/src/lookaround.rs
@@ -583,4 +583,25 @@ mod python_tests {
             }
         }
     }
+
+    #[test]
+    fn round3_nullable_atoms_are_refused() {
+        for pattern in [
+            "(a*|b*?){1,3}",
+            "(?:a*|[ab]{0,2}){0,3}",
+            "(?:a?)+",
+            "(?:a*)?",
+            "(?:|a)*?",
+            "()*",
+            "(?:a{0}){2}",
+            "(?i:(?:a?|b)){1,2}",
+            "(?:^|a)+",
+            "(?:a|$)?",
+        ] {
+            assert!(
+                PythonRule::compile(pattern, false).is_err(),
+                "nullable operand accepted"
+            );
+        }
+    }
 }
diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
index 04d9f9d18..477f11a1e 100644
--- a/rust/crates/og-dev/src/personal_data.rs
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -1198,4 +1198,128 @@ mod tests {
             assert!(!String::from_utf8_lossy(&out).contains("PRIVATE"));
         }
     }
+
+    #[test]
+    fn round3_nullable_repetitions_fail_closed() {
+        let f = Fixture::new("r3-nullable");
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(&f.0)
+                .args(["init", "-q"])
+                .status()
+                .unwrap()
+                .success()
+        );
+        for (pattern, text, allow) in [
+            ("(a*|b*?){1,3}", "ba", "own.md b\nown.md a"),
+            (
+                "(?:a*|[ab]{0,2}){0,3}",
+                "baa",
+                "own.md\nown.md a\nown.md ba",
+            ),
+        ] {
+            // Reconfirm that a partial ALLOW does not cover Python's match.
+            std::fs::write(f.0.join("patterns"), pattern).unwrap();
+            std::fs::write(f.0.join("own.md"), text).unwrap();
+            assert!(
+                Command::new("git")
+                    .arg("-C")
+                    .arg(&f.0)
+                    .args(["add", "own.md"])
+                    .status()
+                    .unwrap()
+                    .success()
+            );
+            for cached in [false, true] {
+                for files in [&["own.md"][..], &[][..]] {
+                    let expected = oracle_options(
+                        &f,
+                        files,
+                        cached,
+                        allow,
+                        "",
+                        f.0.join("patterns").to_str().unwrap(),
+                    );
+                    assert!(
+                        expected.contains("[\"own\""),
+                        "partial ALLOW must leave a Python finding"
+                    );
+                    let mut args = f.args(files);
+                    args[3] = allow.into();
+                    args.extend([
+                        "--patterns".into(),
+                        f.0.join("patterns").to_str().unwrap().into(),
+                    ]);
+                    if cached {
+                        args.push("--cached".into());
+                    }
+                    let (mut out, mut err) = (Vec::new(), Vec::new());
+                    assert_eq!(
+                        cli(&args, &mut out, &mut err),
+                        2,
+                        "nullable repetition must be refused"
+                    );
+                    assert!(!String::from_utf8(err).unwrap().contains(pattern));
+                    assert!(out.is_empty());
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn round3_raw_byte_paths_fail_closed() {
+        let f = Fixture::new("r3-raw-path");
+        let git = |args: &[&str], input: &[u8]| {
+            let mut child = Command::new("git")
+                .arg("-C")
+                .arg(&f.0)
+                .args(args)
+                .stdin(Stdio::piped())
+                .stdout(Stdio::piped())
+                .spawn()
+                .unwrap();
+            child.stdin.take().unwrap().write_all(input).unwrap();
+            let output = child.wait_with_output().unwrap();
+            assert!(output.status.success());
+            output.stdout
+        };
+        git(&["init", "-q"], b"");
+        std::fs::write(f.0.join("clean.md"), "clean").unwrap();
+        git(&["add", "clean.md"], b"");
+        let hash = git(
+            &["hash-object", "-w", "--stdin"],
+            p("/home/~reviewer_three_synthetic/path").as_bytes(),
+        );
+        let mut entry = b"100644 ".to_vec();
+        entry.extend_from_slice(hash.trim_ascii());
+        entry.extend_from_slice(b"\tbad\xff.md\0");
+        git(&["update-index", "-z", "--index-info"], &entry);
+        for cached in [false, true] {
+            let mut args = f.args(&[]);
+            if cached {
+                args.push("--cached".into());
+            }
+            let (mut out, mut err) = (Vec::new(), Vec::new());
+            assert_eq!(
+                cli(&args, &mut out, &mut err),
+                2,
+                "invalid tracked path must stop the whole scan"
+            );
+            assert!(out.is_empty());
+            assert_eq!(
+                String::from_utf8(err).unwrap(),
+                "ERROR: path is not valid UTF-8\n"
+            );
+            // Explicit paths reach the same validation before SKIP or I/O.
+            let mut a = parse(&f.args(&["clean.md"])).unwrap();
+            a.cached = cached;
+            a.files.push(f.0.join(OsStr::from_bytes(b"bad\xff.md")));
+            a.skip.push("*".into());
+            assert_eq!(
+                run(&a, &mut Vec::new()).unwrap_err(),
+                "path is not valid UTF-8"
+            );
+        }
+    }
 }

From 0d6272de4ad4e34c94ed4886c6e3a29878e28110 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 16:16:43 +0100
Subject: [PATCH 49/76] fix(ci): use curl options the pinned VNtyper image
 supports

The real smoke job rejected --retry-all-errors. Keep portable retry flags, the byte-range length check, gzip CRC and size verification, and the pinned SHA-256 checks. Both BAMs still download with their expected hashes.

Bead: pgp-bs9u.39
---
 tests/smoke/vntyper_testdata.sh | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/smoke/vntyper_testdata.sh b/tests/smoke/vntyper_testdata.sh
index 608c81e7e..705f4ea53 100755
--- a/tests/smoke/vntyper_testdata.sh
+++ b/tests/smoke/vntyper_testdata.sh
@@ -50,7 +50,8 @@ for name in "$@"; do
 $(member "$name")
 EOF
   part="${out}/${name}.part"
-  curl -fsSL --retry 4 --retry-all-errors --retry-delay 15 -r "${off}-$((off + csize - 1))" -o "${part}.raw" "$URL"
+  # The pinned VNtyper image's curl does not support --retry-all-errors.
+  curl -fsSL --retry 4 --retry-delay 15 -r "${off}-$((off + csize - 1))" -o "${part}.raw" "$URL"
   got=$(wc -c < "${part}.raw" | tr -d ' ')
   [ "$got" -eq "$csize" ] || { echo "${path}: got ${got} bytes, want ${csize} (the server ignored the range?)" >&2; exit 1; }
   # gzip member: magic, deflate, no flags, no time, no extra flags, unknown OS;

From b7be2494e541e8215a1bfddc5c6f8fe1f55c2529 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 16:17:20 +0100
Subject: [PATCH 50/76] test(traits): restore independent expectations and
 output refusal controls

---
 rust/crates/og-steps/src/traits.rs |  39 +++++++++-
 tests/test_traits_report.py        | 121 ++++++++++++++++++++++++++++-
 2 files changed, 155 insertions(+), 5 deletions(-)

diff --git a/rust/crates/og-steps/src/traits.rs b/rust/crates/og-steps/src/traits.rs
index d537e672a..a0f323c3c 100644
--- a/rust/crates/og-steps/src/traits.rs
+++ b/rust/crates/og-steps/src/traits.rs
@@ -1435,8 +1435,43 @@ mod tests {
         );
     }
 
+
+    #[test]
+    fn catalog_quotes_are_literal_and_embedded_tabs_are_columns() {
+        let root = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../../assets");
+        let text = std::fs::read_to_string(root.join("traits.tsv")).unwrap();
+        let rules = std::fs::read_to_string(root.join("genotype_rules.tsv")).unwrap();
+        let scratch = Scratch::new();
+        let path = scratch.put("quoted-field", &text.replacen("\tMCM6\t", "\t\"MCM6\"\t", 1));
+        assert!(check_rows(&read_table(&path).unwrap()).iter().any(|e| e.contains("quote")));
+        let path = scratch.put("quoted-rule", &rules.replacen("\tAPOE\t", "\t\"APOE\"\t", 1));
+        assert!(!check_rules(&read_rules(&path).unwrap(), None).is_empty());
+        let path = scratch.put("embedded-tab", &text.replacen("\tMCM6\t", "\t\"MCM6\textra\"\t", 1));
+        assert!(read_table(&path).unwrap_err().contains("14 columns, expected 13"));
+    }
+
+    #[test]
+    fn directory_destinations_keep_both_previous_tables() {
+        let scratch = Scratch::new();
+        let root = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../../assets");
+        let gt = scratch.put("g", "");
+        for directory_key in ["out", "rules-out"] {
+            let previous = scratch.put("previous.tsv", "previous complete table\n");
+            let mut opts: HashMap<String, String> = [
+                ("table", root.join("traits.tsv").to_string_lossy().into_owned()),
+                ("rules", root.join("genotype_rules.tsv").to_string_lossy().into_owned()),
+                ("genotypes", gt.clone()), ("sample", "S".into()),
+                ("out", previous.clone()), ("rules-out", previous.clone()),
+            ].into_iter().map(|(k,v)| (k.into(),v)).collect();
+            opts.insert(directory_key.into(), scratch.0.to_string_lossy().into_owned());
+            assert!(run("table", &opts).unwrap_err().contains("cannot write"));
+            assert_eq!(std::fs::read_to_string(&previous).unwrap(), "previous complete table\n", "{directory_key}");
+            assert_eq!(std::fs::read_dir(&scratch.0).unwrap().count(), 2);
+        }
+    }
+
     #[test]
-    fn csv_header_unicode_rules_and_atomic_write_errors() {
+    fn plain_header_unicode_rules_and_atomic_write_errors() {
         let scratch = Scratch::new();
         let mut text = COLUMNS
             .iter()
@@ -1445,7 +1480,7 @@ mod tests {
             .join("\t");
         text.push_str("\r\n");
         let path = scratch.put("quoted", &text);
-        assert!(read_table(&path).unwrap().is_empty());
+        assert!(read_table(&path).unwrap_err().contains("unexpected traits header"));
         let path = scratch.put("r", "rule\té\tG\tT\tno\tyes\tN\t1\n");
         assert!(!check_rules(&read_rules(&path).unwrap(), None).is_empty());
         assert!(stage_tsv(scratch.0.join("absent/x").to_str().unwrap(), OUT, &[]).is_err());
diff --git a/tests/test_traits_report.py b/tests/test_traits_report.py
index 2414935bc..b93c21555 100644
--- a/tests/test_traits_report.py
+++ b/tests/test_traits_report.py
@@ -104,7 +104,9 @@ def planted(desc, new, want):
     "CAD9p21": [(("G/G", "C/C"), "two risk copies"), (("A/G", "G/C"), "one risk copy")],
     "MAPT": [(("G/G", "G/G"), "H2/H2"), (("A/G", "A/G"), "H1/H2")],
 }
-# The label of the reference blocks alone (every site homozygous for the GRCh38 base).
+# Independent labels for homozygous GRCh38 reference blocks.
+MULTI_SNP_REF = {"APOL1": "G0/G0", "SERPINA1": "PiMM", "HFE": "wt/wt", "GC": "Gc1F/Gc1F",
+                 "CAD9p21": "no risk copy", "MAPT": "H1/H1"}
 
 
 
@@ -113,8 +115,50 @@ def says_not_proof(message):
     return "does not prove 2+0" in message
 
 
+def marker_errors(name, m=None, dbsnp=None):
+    """Problems of one marker (empty when it is consistent): the dbSNP record
+    is one of its copies with its ref and alt, on the plus strand and not
+    swapped; every copy sits in the middle of the same context, whose middle
+    base is the ref."""
+    m = tr.MARKERS[name] if m is None else m
+    rs, chrom, pos, ref, alt = m["dbsnp"] if dbsnp is None else dbsnp
+    comp = {"A": "T", "C": "G", "G": "C", "T": "A"}
+    errs = []
+    if chrom != m["chrom"] or pos not in m["copies"]:
+        errs.append(f"{name}: dbSNP places {rs} at {chrom}:{pos}, not at one of the marker's copies")
+    if (m["ref"], m["alt"]) == (alt, ref):
+        errs.append(f"{name}: ref and alt are swapped (marker {m['ref']}>{m['alt']}, dbSNP {ref}>{alt})")
+    elif (m["ref"], m["alt"]) == (comp.get(ref), comp.get(alt)):
+        errs.append(f"{name}: the alleles are the minus-strand bases (marker {m['ref']}>{m['alt']}, "
+                    f"dbSNP {ref}>{alt}): write the plus-strand bases")
+    elif (m["ref"], m["alt"]) != (ref, alt):
+        errs.append(f"{name}: marker {m['ref']}>{m['alt']}, dbSNP {ref}>{alt}")
+    ctx = m["context"]
+    if len(ctx) % 2 != 1 or ctx[len(ctx) // 2] != m["ref"]:
+        errs.append(f"{name}: the middle base of the context is not the ref {m['ref']}")
+    if len(set(m["copies"])) != len(m["copies"]):
+        errs.append(f"{name}: a copy is listed twice")
+    return errs
+
+
 def marker_checks():
     """11. The copy-aware markers."""
+    for name, m in tr.MARKERS.items():
+        check(f"marker {name}: the pinned dbSNP record agrees with the marker", marker_errors(name) == [],
+              marker_errors(name))
+        rs, chrom, pos, ref, alt = m["dbsnp"]
+        comp = {"A": "T", "C": "G", "G": "C", "T": "A"}
+        e = marker_errors(name, dict(m, ref=alt, alt=ref))
+        check(f"marker {name} control: ref and alt swapped is caught", any("swapped" in x for x in e), e)
+        e = marker_errors(name, dict(m, ref=comp[ref], alt=comp[alt],
+                                        context=m["context"][:10] + comp[ref] + m["context"][11:]))
+        check(f"marker {name} control: the minus-strand bases are caught", any("minus-strand" in x for x in e), e)
+        e = marker_errors(name, dbsnp=(rs, chrom, pos + 1, ref, alt))
+        check(f"marker {name} control: a dbSNP position off the copies is caught",
+              any("not at one of the marker's copies" in x for x in e), e)
+        e = marker_errors(name, dict(m, context=m["context"][:10] + alt + m["context"][11:]))
+        check(f"marker {name} control: a context whose middle base is not the ref is caught",
+              any("middle base" in x for x in e), e)
     check("LPA_KIV2_4925: seven copies (six KIV-2 units and KIV-1)", len(tr.MARKERS["LPA_KIV2_4925"]["copies"]) == 7)
     if not OG:
         print("skip: OG is not set (OG=rust/target/release/og): og cn marker-regions and marker-read did not run")
@@ -231,6 +275,44 @@ def og_cn(*args):
     return subprocess.run([OG, "cn", *args], capture_output=True, text=True)
 
 
+
+def plain_tsv_checks():
+    """Reject CSV quoting before it can produce a table the collector cannot read."""
+    import collect_summary as cs
+    with tempfile.TemporaryDirectory() as work:
+        folder = os.path.join(work, "traits")
+        os.makedirs(folder)
+        g = os.path.join(work, "g.tsv")
+        write(g, "")
+        out, rout = os.path.join(folder, "S_traits.tsv"), os.path.join(folder, "S_genotype_rules.tsv")
+        source = open(TABLE).read()
+        rules_source = open(RULES).read()
+        for name, text, rules_text in [
+            ("quoted header", source.replace("chrom\t", '\"chrom\"\t', 1), rules_source),
+            ("quoted catalog field", source.replace("\tMCM6\t", '\t\"MCM6\"\t', 1), rules_source),
+            ("quoted rule text", source, rules_source.replace("\tAPOE\t", '\t\"APOE\"\t', 1)),
+            ("embedded tab", source.replace("\tMCM6\t", '\t\"MCM6\textra\"\t', 1), rules_source),
+        ]:
+            # Keep complete, collector-readable outputs from the previous run.
+            traits_tables(g, out, rout)
+            previous = open(out, "rb").read(), open(rout, "rb").read()
+            bad, badrules = os.path.join(work, "bad.tsv"), os.path.join(work, "badrules.tsv")
+            write(bad, text)
+            write(badrules, rules_text)
+            res = subprocess.run([OG, "traits", "table", "--table", bad, "--rules", badrules,
+                                  "--genotypes", g, "--sample", "S", "--out", out,
+                                  "--rules-out", rout], capture_output=True, text=True)
+            check(f"plain TSV control: {name} is refused", res.returncode == 1, res.stderr)
+            check(f"plain TSV control: {name} preserves both outputs",
+                  previous == (open(out, "rb").read(), open(rout, "rb").read()))
+            try:
+                _, collected = cs.sec_traits(work, "S")
+                readable = bool(collected["rows"])
+            except cs.Unreadable:
+                readable = False
+            check(f"plain TSV control: {name} leaves collector-readable output", readable)
+
+
 def main():
     rules = {}
     with open(RULES) as f:
@@ -238,15 +320,18 @@ def main():
             if cells and cells[0] == "site":
                 rules.setdefault(cells[1], {"sites": []})["sites"].append(cells[2:])
     dbsnp_checks(rules)
+    marker_checks()
     if not OG:
         check("OG_REQUIRED needs the og binary", not os.environ.get("OG_REQUIRED"))
         print("skip: OG is not set: traits CLI and cn marker checks did not run")
         return int(bool(FAILS))
+    plain_tsv_checks()
     with tempfile.TemporaryDirectory() as work:
         def table(records):
             g = os.path.join(work, "g.tsv")
             write(g, "".join("\t".join(rec) + "\n" for rec in records))
-            out, rout = os.path.join(work, "traits.tsv"), os.path.join(work, "rules.tsv")
+            os.makedirs(os.path.join(work, "traits"), exist_ok=True)
+            out, rout = os.path.join(work, "traits", "S_traits.tsv"), os.path.join(work, "traits", "S_genotype_rules.tsv")
             res = subprocess.run([OG, "traits", "table", "--table", TABLE, "--rules", RULES,
                                   "--genotypes", g, "--sample", "S", "--out", out,
                                   "--rules-out", rout], capture_output=True, text=True)
@@ -271,7 +356,37 @@ def table(records):
                 _, lines = table(records)
                 got = next(r for r in lines if r["rule"] == rid)
                 check(f"{rid} {gts}: {label}", got["status"] == "called" and got["result"] == label, got)
-    marker_checks()
+        import collect_summary as cs
+        import render_report as rr
+        check("every multi-SNP rule is in the catalog", set(MULTI_SNP) <= set(rules))
+        for rid, cases in MULTI_SNP.items():
+            sites = rules[rid]["sites"]
+            records = [(s[1], s[2], s[3], ".", f"{s[3]}/{s[3]}", "40") for s in sites]
+            _, lines = table(records)
+            got = next(r for r in lines if r["rule"] == rid)
+            check(f"{rid}, reference blocks only: {MULTI_SNP_REF[rid]}",
+                  (got["status"], got["result"]) == ("called", MULTI_SNP_REF[rid]), got)
+            gts, want = cases[0]
+            a, b = gts[0].split("/")
+            s0 = sites[0]
+            flip = s0[3] if b == s0[4] else s0[4]
+            flipped = (f"{a}/{flip}",) + tuple(gts[1:])
+            records = [(s[1], s[2], s[3], s[4], gt) for s, gt in zip(sites, flipped)]
+            _, lines = table(records)
+            got = next(r for r in lines if r["rule"] == rid)
+            check(f"control: {rid} with one allele flipped is not {want}", got["result"] != want, got)
+            # Collect and render the actual CLI output, independently for each rule.
+            records = [(s[1], s[2], s[3], s[4], gt) for s, gt in zip(sites, gts)]
+            _, lines = table(records)
+            read = cs.genotype_rules(work, "S") or []
+            page = "\n".join(rr.rules_html({"rules": read}, "S"))
+            got = next(r for r in lines if r["rule"] == rid)
+            check(f"HTML report: {rid} with result {want}", rr.E(got["trait"]) in page and rr.E(want) in page, page[:300])
+        records = [(s[1], s[2], s[3], s[4], gt) for s, gt in zip(rules["APOL1"]["sites"], ("A/G", "T/G"))]
+        _, lines = table(records)
+        reading = next(r for r in lines if r["rule"] == "APOL1")["reading"]
+        check("APOL1 G0/G1 says G2 is not read and the other copy could carry it",
+              "G2 is not read" in reading and "G1/G2" in reading, reading)
     print("RESULT:", "ALL PASS" if not FAILS else f"{FAILS} FAILED")
     return int(bool(FAILS))
 

From d0c12a52666fe22a01112b095ab9df2d2f129c77 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 16:22:13 +0100
Subject: [PATCH 51/76] fix(traits): preserve plain TSV and reject directory
 outputs before publication

---
 .github/workflows/guard.yml                 |  37 +++++++
 CHANGELOG.md                                |   2 +-
 rust/crates/og-steps/src/traits.rs          | 104 +++++++++++++-------
 tests/parity/evidence/rust-c2b-controls.txt |  40 +++++++-
 tests/test_traits_report.py                 |   2 +-
 5 files changed, 144 insertions(+), 41 deletions(-)

diff --git a/.github/workflows/guard.yml b/.github/workflows/guard.yml
index 66800c3a5..d2a8d74a2 100644
--- a/.github/workflows/guard.yml
+++ b/.github/workflows/guard.yml
@@ -386,6 +386,43 @@ jobs:
           done
           exit "$fail"
 
+      - name: Traits independent expectations reject changed reference labels and marker metadata
+        working-directory: .
+        env:
+          OG: ${{ github.workspace }}/bin/og
+          OG_REQUIRED: 1
+        run: |
+          python3 - <<'PY'
+          import contextlib, io, pathlib, runpy, tempfile
+          test = runpy.run_path("tests/test_traits_report.py")["main"].__globals__
+          original = pathlib.Path(test["RULES"]).read_text()
+          with tempfile.TemporaryDirectory() as work:
+              for rid, key, label in [("APOL1", "G0/G0", "G0/G0"), ("CAD9p21", "nonrisk/nonrisk", "no risk copy")]:
+                  path = pathlib.Path(work) / "rules.tsv"
+                  old = f"combination\t{rid}\t{key}\t{label}\t"
+                  assert old in original
+                  path.write_text(original.replace(old, f"combination\t{rid}\t{key}\tWRONG_REFERENCE\t"))
+                  test["RULES"], test["FAILS"] = str(path), 0
+                  log = io.StringIO()
+                  with contextlib.redirect_stdout(log):
+                      rc = test["main"]()
+                  print(log.getvalue())
+                  assert rc == 1 and test["FAILS"] == 1
+                  assert f"[FAIL] {rid}, reference blocks only: {label}" in log.getvalue()
+                  print(f"Control: {rid} WRONG_REFERENCE failed its independent expectation")
+          marker = test["tr"].MARKERS["SMN1_27134"]
+          rs, chrom, pos, ref, alt = marker["dbsnp"]
+          marker["dbsnp"] = rs, chrom, pos + 1, ref, alt
+          test["FAILS"] = 0
+          log = io.StringIO()
+          with contextlib.redirect_stdout(log):
+              test["marker_checks"]()
+          print(log.getvalue())
+          assert test["FAILS"] == 1
+          assert "[FAIL] marker SMN1_27134: the pinned dbSNP record agrees" in log.getvalue()
+          print("Control: retained SMN1 off-copy metadata failed its independent expectation")
+          PY
+
       # The fake-docker job builds no og, so its cn-engine-calls case says it
       # is skipped there; here bin/og is built and the case must run.
       - name: The fake-docker case cn-engine-calls (steps 35, 41 and 46 through og cn) with og
diff --git a/CHANGELOG.md b/CHANGELOG.md
index b6245e959..3e56f60b5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,7 +4,7 @@ Each release's notes. From 1.0.0 on, a major or minor release has hand-written n
 
 ## Unreleased
 
-- Step 42 reads traits and genotype rules with `og traits table`, exports WhatsHap sites with `og traits phase-sites`, and checks the catalogs with `og traits check`. The replaced Python evaluator is removed. Report columns and readings stay the same. Genotypes outside the catalog are streamed past, and write errors now report a controlled error with the path instead of a traceback. Both tables are staged before either is published, so an unwritable second output leaves the previous traits table intact.
+- Step 42 reads traits and genotype rules with `og traits table`, exports WhatsHap sites with `og traits phase-sites`, and checks the catalogs with `og traits check`. The replaced Python evaluator is removed. Report columns and readings stay the same. Genotypes outside the catalog are streamed past, and write errors now report a controlled error with the path instead of a traceback. Both tables are staged before either is published. A staging failure or a directory destination leaves both previous tables intact. Each file is then replaced by a separate atomic rename. The pair is not a transaction: a failure of the second rename can leave the first table updated. Catalogs and output remain plain TSV; quotes never hide a tab or bypass validation.
 - The unused Python copy-number engine is removed. Its historical catalog tests materialise a pinned test oracle and keep testing the Rust commands.
 
 
diff --git a/rust/crates/og-steps/src/traits.rs b/rust/crates/og-steps/src/traits.rs
index a0f323c3c..fa6fef4b1 100644
--- a/rust/crates/og-steps/src/traits.rs
+++ b/rust/crates/og-steps/src/traits.rs
@@ -1,7 +1,6 @@
 //! Step 42: bounded site genotypes, haplotype rules and read-backed phase.
 use indexmap::IndexMap;
 use og_io::{AtomicFile, Lines, Utf8};
-use pycompat::csv::{Quoting, Reader, Writer};
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::io::Write;
 
@@ -111,7 +110,7 @@ fn row(keys: &[&str], values: &[String]) -> Row {
         .collect()
 }
 fn records(path: &str) -> Result<Vec<(usize, Vec<String>)>> {
-    // Parse even the header as a CSV record. Comments do not enter the parser.
+    // Catalogs are plain TSV: quotes are literal and never hide a tab.
     let mut lines = Lines::new(
         og_io::open(path).map_err(|e| og_filters::os_error(&e, path))?,
         Utf8::Strict,
@@ -124,14 +123,11 @@ fn records(path: &str) -> Result<Vec<(usize, Vec<String>)>> {
         if text.trim_end_matches('\n').is_empty() || text.starts_with('#') {
             continue;
         }
-        let cells = Reader::new(
-            std::iter::once(Ok::<_, std::io::Error>(text.clone())),
-            '\t',
-            Quoting::Minimal,
-        )
-        .next()
-        .ok_or("empty record")?
-        .map_err(|e| e.to_string())?;
+        let cells = text
+            .trim_end_matches('\n')
+            .split('\t')
+            .map(str::to_owned)
+            .collect();
         out.push((number, cells));
     }
     Ok(out)
@@ -857,16 +853,10 @@ fn rule_line(r: &Rule, gt: &Genotypes, phased: Option<&Phased>) -> Row {
 }
 fn stage_tsv(path: &str, columns: &[&str], rows: &[Row]) -> Result<AtomicFile> {
     let mut file = AtomicFile::create(path).map_err(|e| format!("cannot write {path}: {e}"))?;
-    {
-        let mut writer = Writer::new(&mut file, '\t');
-        writer
-            .write_row(columns.iter().copied())
-            .map_err(|e| format!("cannot write {path}: {e}"))?;
-        for row in rows {
-            writer
-                .write_row(columns.iter().map(|k| row[*k].as_str()))
-                .map_err(|e| format!("cannot write {path}: {e}"))?;
-        }
+    writeln!(file, "{}", columns.join("\t")).map_err(|e| format!("cannot write {path}: {e}"))?;
+    for row in rows {
+        let fields: Vec<_> = columns.iter().map(|k| row[*k].as_str()).collect();
+        writeln!(file, "{}", fields.join("\t")).map_err(|e| format!("cannot write {path}: {e}"))?;
     }
     file.flush()
         .map_err(|e| format!("cannot write {path}: {e}"))?;
@@ -1048,6 +1038,13 @@ fn run(verb: &str, opts: &HashMap<String, String>) -> Result<u8> {
     // Compute both tables before opening either output. Each rename is atomic.
     let out_path = required("out")?;
     let rules_path = required("rules-out")?;
+    // Refuse known rename failures before either previous output is replaced.
+    // Publication still uses two renames, not one transaction.
+    for path in [out_path, rules_path] {
+        if std::path::Path::new(path).is_dir() {
+            return Err(format!("cannot write {path}: destination is a directory"));
+        }
+    }
     let traits_file = stage_tsv(out_path, OUT, &out)?;
     let rules_file = stage_tsv(rules_path, RULE_OUT, &lines)?;
     traits_file
@@ -1435,19 +1432,35 @@ mod tests {
         );
     }
 
-
     #[test]
     fn catalog_quotes_are_literal_and_embedded_tabs_are_columns() {
         let root = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../../assets");
         let text = std::fs::read_to_string(root.join("traits.tsv")).unwrap();
         let rules = std::fs::read_to_string(root.join("genotype_rules.tsv")).unwrap();
         let scratch = Scratch::new();
-        let path = scratch.put("quoted-field", &text.replacen("\tMCM6\t", "\t\"MCM6\"\t", 1));
-        assert!(check_rows(&read_table(&path).unwrap()).iter().any(|e| e.contains("quote")));
-        let path = scratch.put("quoted-rule", &rules.replacen("\tAPOE\t", "\t\"APOE\"\t", 1));
+        let path = scratch.put(
+            "quoted-field",
+            &text.replacen("\tMCM6\t", "\t\"MCM6\"\t", 1),
+        );
+        assert!(
+            check_rows(&read_table(&path).unwrap())
+                .iter()
+                .any(|e| e.contains("quote"))
+        );
+        let path = scratch.put(
+            "quoted-rule",
+            &rules.replacen("\tAPOE\tAPOE\t", "\tAPOE\t\"APOE\"\t", 1),
+        );
         assert!(!check_rules(&read_rules(&path).unwrap(), None).is_empty());
-        let path = scratch.put("embedded-tab", &text.replacen("\tMCM6\t", "\t\"MCM6\textra\"\t", 1));
-        assert!(read_table(&path).unwrap_err().contains("14 columns, expected 13"));
+        let path = scratch.put(
+            "embedded-tab",
+            &text.replacen("\tMCM6\t", "\t\"MCM6\textra\"\t", 1),
+        );
+        assert!(
+            read_table(&path)
+                .unwrap_err()
+                .contains("14 columns, expected 13")
+        );
     }
 
     #[test]
@@ -1458,14 +1471,33 @@ mod tests {
         for directory_key in ["out", "rules-out"] {
             let previous = scratch.put("previous.tsv", "previous complete table\n");
             let mut opts: HashMap<String, String> = [
-                ("table", root.join("traits.tsv").to_string_lossy().into_owned()),
-                ("rules", root.join("genotype_rules.tsv").to_string_lossy().into_owned()),
-                ("genotypes", gt.clone()), ("sample", "S".into()),
-                ("out", previous.clone()), ("rules-out", previous.clone()),
-            ].into_iter().map(|(k,v)| (k.into(),v)).collect();
-            opts.insert(directory_key.into(), scratch.0.to_string_lossy().into_owned());
+                (
+                    "table",
+                    root.join("traits.tsv").to_string_lossy().into_owned(),
+                ),
+                (
+                    "rules",
+                    root.join("genotype_rules.tsv")
+                        .to_string_lossy()
+                        .into_owned(),
+                ),
+                ("genotypes", gt.clone()),
+                ("sample", "S".into()),
+                ("out", previous.clone()),
+                ("rules-out", previous.clone()),
+            ]
+            .into_iter()
+            .map(|(k, v)| (k.into(), v))
+            .collect();
+            opts.insert(
+                directory_key.into(),
+                scratch.0.to_string_lossy().into_owned(),
+            );
             assert!(run("table", &opts).unwrap_err().contains("cannot write"));
-            assert_eq!(std::fs::read_to_string(&previous).unwrap(), "previous complete table\n", "{directory_key}");
+            assert!(
+                std::fs::read_to_string(&previous).unwrap() == "previous complete table\n",
+                "{directory_key}: previous output changed"
+            );
             assert_eq!(std::fs::read_dir(&scratch.0).unwrap().count(), 2);
         }
     }
@@ -1480,7 +1512,11 @@ mod tests {
             .join("\t");
         text.push_str("\r\n");
         let path = scratch.put("quoted", &text);
-        assert!(read_table(&path).unwrap_err().contains("unexpected traits header"));
+        assert!(
+            read_table(&path)
+                .unwrap_err()
+                .contains("unexpected traits header")
+        );
         let path = scratch.put("r", "rule\té\tG\tT\tno\tyes\tN\t1\n");
         assert!(!check_rules(&read_rules(&path).unwrap(), None).is_empty());
         assert!(stage_tsv(scratch.0.join("absent/x").to_str().unwrap(), OUT, &[]).is_err());
diff --git a/tests/parity/evidence/rust-c2b-controls.txt b/tests/parity/evidence/rust-c2b-controls.txt
index bed580b72..9637cfe02 100644
--- a/tests/parity/evidence/rust-c2b-controls.txt
+++ b/tests/parity/evidence/rust-c2b-controls.txt
@@ -19,7 +19,7 @@ failures:
 
 ---- traits::tests::apoe_grid_keeps_haplotype_order_and_missing_calls stdout ----
 
-thread 'traits::tests::apoe_grid_keeps_haplotype_order_and_missing_calls' (4288523) panicked at crates/og-steps/src/traits.rs:1242:17:
+thread 'traits::tests::apoe_grid_keeps_haplotype_order_and_missing_calls' (4288523) panicked at traits.rs (line 1242, column 17):
 assertion `left == right` failed
   left: "other_haplotype"
  right: "called"
@@ -27,12 +27,12 @@ note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 
 ---- traits::tests::stream_prefers_first_snv_but_checks_every_ref_and_bounds_memory stdout ----
 
-thread 'traits::tests::stream_prefers_first_snv_but_checks_every_ref_and_bounds_memory' (4288529) panicked at crates/og-steps/src/traits.rs:1336:45:
+thread 'traits::tests::stream_prefers_first_snv_but_checks_every_ref_and_bounds_memory' (4288529) panicked at traits.rs (line 1336, column 45):
 called `Result::unwrap_err()` on an `Ok` value: {("chr2", "135851076"): SiteGt { alleles: ["G", "A"], status: Called, gq: "42", snv: true }}
 
 ---- traits::tests::phase_requires_one_block_and_only_multiple_hets_are_exported stdout ----
 
-thread 'traits::tests::phase_requires_one_block_and_only_multiple_hets_are_exported' (4288526) panicked at crates/og-steps/src/traits.rs:1390:9:
+thread 'traits::tests::phase_requires_one_block_and_only_multiple_hets_are_exported' (4288526) panicked at traits.rs (line 1390, column 9):
 assertion `left == right` failed
   left: 0
  right: 3
@@ -41,12 +41,12 @@ assertion `left == right` failed
 ERROR: /Volumes/Data/repos/personal/.worktrees/pgp-rust-c2b/rust/crates/og-steps/../../../assets/genotype_rules.tsv: rule APOE (line 19): no combination line for e2/e4|e1/e3
 ERROR: /Volumes/Data/repos/personal/.worktrees/pgp-rust-c2b/rust/crates/og-steps/../../../assets/genotype_rules.tsv: rule APOE (line 19): the combination line e1/e3|e2/e4 can never be read (a rule that needs phase reads one diplotype)
 
-thread 'traits::tests::unwritable_rules_output_keeps_existing_traits_table' (4288530) panicked at crates/og-steps/src/traits.rs:1433:37:
+thread 'traits::tests::unwritable_rules_output_keeps_existing_traits_table' (4288530) panicked at traits.rs (line 1433, column 37):
 called `Result::unwrap_err()` on an `Ok` value: 1
 
 ---- traits::tests::committed_catalogs_and_every_rule_genotype stdout ----
 
-thread 'traits::tests::committed_catalogs_and_every_rule_genotype' (4288524) panicked at crates/og-steps/src/traits.rs:1216:9:
+thread 'traits::tests::committed_catalogs_and_every_rule_genotype' (4288524) panicked at traits.rs (line 1216, column 9):
 assertion `left == right` failed
   left: ["rule APOE (line 19): no combination line for e2/e4|e1/e3", "rule APOE (line 19): the combination line e1/e3|e2/e4 can never be read (a rule that needs phase reads one diplotype)"]
  right: []
@@ -67,3 +67,33 @@ error: 1 target failed:
 test traits::tests::apoe_grid_keeps_haplotype_order_and_missing_calls ... FAILED
 test traits::tests::stream_prefers_first_snv_but_checks_every_ref_and_bounds_memory ... FAILED
 test traits::tests::phase_requires_one_block_and_only_multiple_hets_are_exported ... FAILED
+
+Fix round 1: local red-first controls, Rust 1.93.0, synthetic inputs only.
+The tests-only commit b7be2494 leaves production code unchanged.
+Command: cargo test --locked -p og-steps traits::tests --no-fail-fast
+test traits::tests::catalog_quotes_are_literal_and_embedded_tabs_are_columns ... FAILED
+test traits::tests::plain_header_unicode_rules_and_atomic_write_errors ... FAILED
+test traits::tests::directory_destinations_keep_both_previous_tables ... FAILED
+
+Command: OG_REQUIRED=1 python3 tests/test_traits_report.py (unfixed binary)
+[FAIL] plain TSV control: quoted header is refused --
+[FAIL] plain TSV control: quoted catalog field is refused --
+[FAIL] plain TSV control: quoted rule text is refused --
+[FAIL] plain TSV control: embedded tab is refused --
+[FAIL] plain TSV control: embedded tab preserves both outputs --
+[FAIL] plain TSV control: embedded tab leaves collector-readable output --
+
+Independent reference controls: a scratch copy of genotype_rules.tsv changes
+only the reference label to WRONG_REFERENCE. The actual og tables must still
+match the six fixed labels in tests/test_traits_report.py.
+APOL1 G0/G0 changed: the APOL1 reference assertion fails.
+CAD9p21 no risk copy changed: the CAD9p21 reference assertion fails.
+SMN1 retained metadata: dbSNP position moved one base off its copies.
+The pinned dbSNP agreement assertion fails.
+Guard now repeats these three controls, requires the exact failed assertion
+and exactly one failure per mutation, and keeps the catalogs unchanged.
+
+After fixes: all 10 traits Rust tests pass. The CLI controls refuse quoted
+headers, quoted fields, quoted rule text and embedded tabs. The previous
+outputs survive; collect_summary reads the unchanged table with QUOTE_NONE.
+Both directory-destination controls preserve the other previous output.
diff --git a/tests/test_traits_report.py b/tests/test_traits_report.py
index b93c21555..cf55a9599 100644
--- a/tests/test_traits_report.py
+++ b/tests/test_traits_report.py
@@ -290,7 +290,7 @@ def plain_tsv_checks():
         for name, text, rules_text in [
             ("quoted header", source.replace("chrom\t", '\"chrom\"\t', 1), rules_source),
             ("quoted catalog field", source.replace("\tMCM6\t", '\t\"MCM6\"\t', 1), rules_source),
-            ("quoted rule text", source, rules_source.replace("\tAPOE\t", '\t\"APOE\"\t', 1)),
+            ("quoted rule text", source, rules_source.replace("\tAPOE\tAPOE\t", '\tAPOE\t\"APOE\"\t', 1)),
             ("embedded tab", source.replace("\tMCM6\t", '\t\"MCM6\textra\"\t', 1), rules_source),
         ]:
             # Keep complete, collector-readable outputs from the previous run.

From 7f4ab7e49bc7a78db10236cdf68accca8176e824 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 16:23:07 +0100
Subject: [PATCH 52/76] fix(ci): refuse nullable pattern repetitions and
 invalid paths

---
 .github/workflows/guard.yml                   |  28 ++
 CHANGELOG.md                                  |   2 +
 rust/crates/og-dev/src/lookaround.rs          | 268 +++++++++++++++++-
 rust/crates/og-dev/src/personal_data.rs       |  44 ++-
 rust/og/src/main.rs                           |  12 +
 scripts/ci/check-personal-data.sh             |  10 +-
 .../inputs/dev-scanners/containers.config     |   4 +-
 7 files changed, 344 insertions(+), 24 deletions(-)

diff --git a/.github/workflows/guard.yml b/.github/workflows/guard.yml
index c1b036c90..4e44087c5 100644
--- a/.github/workflows/guard.yml
+++ b/.github/workflows/guard.yml
@@ -265,6 +265,12 @@ jobs:
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
+      # Scanner patterns target Python 3.14+ finditer, including \B on empty
+      # text. Use the oracle image's minor version for differential tests.
+      - uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0
+        with:
+          python-version: '3.15'
+
       - name: Install the toolchain rust/rust-toolchain.toml pins, with rustfmt and clippy
         run: |
           channel=$(sed -n 's/^channel = "\(.*\)"$/\1/p' rust-toolchain.toml)
@@ -328,6 +334,27 @@ jobs:
             echo "Control: all five scanner regressions in round ${round} failed, as they must."
           done
 
+      - name: Scanner round-three controls (nullable operands and raw-byte paths must fail before the fix)
+        run: |
+          source=crates/og-dev/src/personal_data.rs
+          matcher=crates/og-dev/src/lookaround.rs
+          cp "$source" "${RUNNER_TEMP}/round3-personal-fixed.rs"
+          cp "$matcher" "${RUNNER_TEMP}/round3-matcher-fixed.rs"
+          trap 'cp "${RUNNER_TEMP}/round3-personal-fixed.rs" "$source"; cp "${RUNNER_TEMP}/round3-matcher-fixed.rs" "$matcher"' EXIT
+          before=3c2c2f288c5ac516c22ed85b6aa8b04e43e734c6
+          git cat-file -e "$before^{commit}" 2>/dev/null || git fetch --quiet --depth=1 origin "$before"
+          git show "$before:rust/$source" > "$source"
+          git show "$before:rust/$matcher" > "$matcher"
+          log="${RUNNER_TEMP}/scanner-round3-red.log"
+          rc=0
+          cargo test -p og-dev --locked --no-fail-fast round3_ > "$log" 2>&1 || rc=$?
+          cat "$log"
+          [ "$rc" -ne 0 ]
+          for test in nullable_atoms_are_refused nullable_repetitions_fail_closed raw_byte_paths_fail_closed; do
+            grep -E "round3_${test} .*FAILED" "$log" || { echo "ERROR: missing round-three red control"; exit 1; }
+          done
+          echo "Control: nullable operands and raw-byte paths failed before the fix."
+
       - name: Scanner matcher controls (word classes and swallowed errors must be caught)
         run: |
           source=crates/og-dev/src/lookaround.rs
@@ -342,6 +369,7 @@ jobs:
           [ "$rc" -ne 0 ]
           grep -E 'round2_generated_patterns_and_tables .*FAILED' "$log"
           grep -E 'finditer_spans_match_real_python .*FAILED' "$log"
+          grep -E 'exhaustive_small_model_spans .*FAILED' "$log"
           sed 's/Some(Err(()))/None/' "$saved" > "$source"
           log="${RUNNER_TEMP}/matcher-error-control.log"
           rc=0
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 26a72b608..9f218297a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,6 +16,8 @@ Each release's notes. From 1.0.0 on, a major or minor release has hand-written n
   - Built-in and custom personal-data patterns share a Python-subset compiler and a backtracking matcher. Word boundaries stay inside the search, so a chip row ending in `A-` can backtrack to its shorter match. Unicode word, space and case rules also apply to custom patterns.
   - Empty custom matches keep Python's iteration order, including a nonempty alternative at the same position. Capture groups keep the full match when checking allowed examples.
   - Pattern files use universal newlines. ALLOW and SKIP rows use Python's line separators, so a CR or Unicode separator cannot extend an exemption into another file.
+  - Custom patterns cannot quantify an operand that can match empty text. Such patterns stop with redacted exit 2 because their match spans can differ from Python and hide a finding under a partial exemption.
+  - A filename with invalid UTF-8 stops the personal-data scan with redacted exit 2 in working-copy and index modes. It cannot be changed into another name or skipped.
   - Unsupported custom constructs or matcher resource limits stop the scan with a redacted error and exit 2. The supported subset is documented in `scripts/ci/check-personal-data.sh`.
 
 - The container helpers check (`scripts/ci/check-container-helpers.sh`, Guard job `helper-binaries`) now derives its table with the Rust `og` binary, `og dev helpers`. It replaces the Python inside the script, which is gone; the script keeps the docker probe, the orad download and its self-test. On this tree the table and the rule 1 output are the same, byte for byte. The static run takes 0.01 s and 6 MB where the Python took 0.2 s and 15 MB. What changes:
diff --git a/rust/crates/og-dev/src/lookaround.rs b/rust/crates/og-dev/src/lookaround.rs
index 73c2c332d..2b1dc9dd2 100644
--- a/rust/crates/og-dev/src/lookaround.rs
+++ b/rust/crates/og-dev/src/lookaround.rs
@@ -123,7 +123,7 @@ impl PythonRule {
             depth: 0,
             names: std::collections::HashSet::new(),
         };
-        let translated = parser.group(Flags::default(), false)?;
+        let (translated, _) = parser.group(Flags::default(), false)?;
         // \G is the search offset. After yielding an empty match, forbid only
         // a match ending at that offset; the engine then tries nonempty
         // alternatives at the same start, exactly as Python finditer does.
@@ -200,8 +200,11 @@ impl PythonPattern {
         self.chars.get(self.at).copied()
     }
 
-    fn group(&mut self, mut flags: Flags, nested: bool) -> Result<String, ()> {
+    fn group(&mut self, mut flags: Flags, nested: bool) -> Result<(String, bool), ()> {
         let mut out = String::new();
+        // Nullability is structural: concatenate with AND, alternate with OR.
+        // Keep the last atom separate until its quantifier is known.
+        let (mut prefix_nullable, mut atom_nullable, mut alt_nullable) = (true, true, false);
         let (mut repeatable, mut lazy) = (false, false);
         while let Some(c) = self.peek() {
             self.at += 1;
@@ -214,8 +217,14 @@ impl PythonPattern {
                 }
                 continue;
             }
+            if !matches!(c, ')' | '|' | '*' | '+' | '?' | '{') {
+                prefix_nullable &= atom_nullable;
+                atom_nullable = true;
+            }
             match c {
-                ')' if nested => return Ok(out),
+                ')' if nested => {
+                    return Ok((out, alt_nullable || (prefix_nullable && atom_nullable)));
+                }
                 ')' => return Err(()),
                 '(' => {
                     repeatable = true;
@@ -303,22 +312,27 @@ impl PythonPattern {
                     out.push('(');
                     out.push_str(&prefix);
                     self.depth += 1;
-                    out.push_str(&self.group(inner, true)?);
+                    let (body, nullable) = self.group(inner, true)?;
+                    atom_nullable = prefix != "?:" || nullable;
+                    out.push_str(&body);
                     self.depth -= 1;
                     out.push(')');
                 }
                 '[' => {
                     out.push_str(&self.class(flags.i)?);
+                    atom_nullable = false;
                     repeatable = true;
                     lazy = false;
                 }
                 '\\' => {
                     repeatable = !matches!(self.peek(), Some('b' | 'B' | 'A' | 'Z'));
+                    atom_nullable = !repeatable;
                     lazy = false;
                     out.push_str(&self.escape(flags.i, false)?);
                 }
                 '.' => {
                     out.push_str(if flags.s { r"[\s\S]" } else { r"[^\n]" });
+                    atom_nullable = false;
                     repeatable = true;
                     lazy = false;
                 }
@@ -333,6 +347,9 @@ impl PythonPattern {
                     lazy = false;
                 }
                 '|' => {
+                    alt_nullable |= prefix_nullable && atom_nullable;
+                    prefix_nullable = true;
+                    atom_nullable = true;
                     out.push('|');
                     repeatable = false;
                     lazy = false;
@@ -343,7 +360,7 @@ impl PythonPattern {
                         lazy = false;
                         continue;
                     }
-                    if !repeatable {
+                    if !repeatable || atom_nullable {
                         return Err(());
                     }
                     repeatable = false;
@@ -352,15 +369,17 @@ impl PythonPattern {
                     if matches!(c, '*' | '+' | '?') && self.peek() == Some('+') {
                         return Err(());
                     }
+                    atom_nullable = c != '+';
                     out.push(c);
                 }
                 '{' => {
-                    if !repeatable {
+                    if !repeatable || atom_nullable {
                         return Err(());
                     }
                     repeatable = false;
                     lazy = true;
                     out.push(c);
+                    let minimum_at = self.at;
                     loop {
                         let c = self.take()?;
                         out.push(c);
@@ -371,6 +390,11 @@ impl PythonPattern {
                             return Err(());
                         }
                     }
+                    // Python permits {,n}; a missing minimum means zero.
+                    atom_nullable = self.chars[minimum_at..self.at - 1]
+                        .iter()
+                        .take_while(|&&c| c != ',')
+                        .all(|&c| c == '0');
                     if self.peek() == Some('+') {
                         return Err(());
                     }
@@ -378,12 +402,17 @@ impl PythonPattern {
                 '}' => return Err(()),
                 c => {
                     out.push_str(&literal(c, flags.i)?);
+                    atom_nullable = false;
                     repeatable = true;
                     lazy = false;
                 }
             }
         }
-        if nested { Err(()) } else { Ok(out) }
+        if nested {
+            Err(())
+        } else {
+            Ok((out, alt_nullable || (prefix_nullable && atom_nullable)))
+        }
     }
 
     fn escape(&mut self, ci: bool, class: bool) -> Result<String, ()> {
@@ -546,7 +575,6 @@ mod python_tests {
         for pattern in [
             r"^|a",
             r"a*?",
-            r"(?:|a)+",
             r"a|",
             r"\w*",
             r"\b|\W+",
@@ -586,6 +614,19 @@ mod python_tests {
 
     #[test]
     fn round3_nullable_atoms_are_refused() {
+        for (pattern, text, spans) in [
+            ("(a*|b*?){1,3}", "ba", "0:0,0:2,2:2"),
+            ("(?:a*|[ab]{0,2}){0,3}", "baa", "0:0,0:3,3:3"),
+        ] {
+            let output = std::process::Command::new("python3").args(["-I", "-c",
+                "import re,sys; print(','.join(str(m.start())+':'+str(m.end()) for m in re.finditer(sys.argv[1],sys.argv[2])))", pattern, text]).output().unwrap();
+            assert!(output.status.success());
+            assert_eq!(String::from_utf8(output.stdout).unwrap().trim(), spans);
+            assert!(
+                PythonRule::compile(pattern, false).is_err(),
+                "unsupported span case accepted"
+            );
+        }
         for pattern in [
             "(a*|b*?){1,3}",
             "(?:a*|[ab]{0,2}){0,3}",
@@ -604,4 +645,215 @@ mod python_tests {
             );
         }
     }
+
+    // A finite grammar, exhaustively enumerated by AST node count. Every
+    // terminal costs one node; each unary/binary operator costs one more.
+    // No random selection or accepted-pattern sampling occurs in this model.
+    const MODEL_ATOMS: &[&str] = &[
+        "", "a", "b", "0", " ", "\u{301}", ".", "[ab]", "[^ab]", "[a-b]", r"\w", r"\W", r"\d",
+        r"\D", r"\s", r"\S", r"\b", r"\B", "^", "$", r"\A", r"\Z", r"\x61", r"\u0301", r"[\s\S]",
+        r"[\w0]",
+    ];
+    const MODEL_GROUPS: &[&str] = &["", "?:", "?P<n>", "?i:", "?m:", "?s:", "?x:", "?-i:"];
+    const MODEL_QUANTIFIERS: &[&str] = &[
+        "?", "*", "+", "??", "*?", "+?", "{0}", "{1}", "{0,2}", "{1,3}", "{2,}", "{,2}", "{0,2}?",
+        "{1,3}?",
+    ];
+
+    fn unary_patterns(p: &str) -> impl Iterator<Item = String> + '_ {
+        MODEL_GROUPS
+            .iter()
+            .map(move |g| format!("({g}{p})"))
+            .chain(MODEL_QUANTIFIERS.iter().map(move |q| format!("(?:{p}){q}")))
+    }
+
+    fn model_patterns(size: usize) -> Vec<String> {
+        use std::collections::BTreeSet;
+        let mut levels = vec![
+            BTreeSet::new(),
+            MODEL_ATOMS
+                .iter()
+                .map(|s| s.to_string())
+                .collect::<BTreeSet<_>>(),
+        ];
+        for n in 2..=size {
+            let mut level = BTreeSet::new();
+            for p in &levels[n - 1] {
+                level.extend(unary_patterns(p));
+            }
+            for left in 1..n - 1 {
+                for a in &levels[left] {
+                    for b in &levels[n - 1 - left] {
+                        level.insert(format!("(?:{a})(?:{b})"));
+                        level.insert(format!("(?:{a}|{b})"));
+                    }
+                }
+            }
+            levels.push(level);
+        }
+        levels
+            .into_iter()
+            .flatten()
+            .collect::<BTreeSet<_>>()
+            .into_iter()
+            .collect()
+    }
+
+    fn model_texts(length: usize) -> Vec<String> {
+        let mut all = vec![String::new()];
+        let mut level = vec![String::new()];
+        for _ in 0..length {
+            level = level
+                .iter()
+                .flat_map(|p| ['a', 'b', '0', ' ', '\u{301}'].map(|c| format!("{p}{c}")))
+                .collect();
+            all.extend(level.iter().cloned());
+        }
+        all
+    }
+
+    fn span_list(rule: &PythonRule, text: &str) -> String {
+        rule.find_iter(text)
+            .map(|m| {
+                let (a, b) = m.expect("model matcher exhausted");
+                format!(
+                    "{}:{}",
+                    text[..a].chars().count(),
+                    text[..b].chars().count()
+                )
+            })
+            .collect::<Vec<_>>()
+            .join(",")
+    }
+
+    fn compare_model(label: &str, patterns: &[String], texts: &[String]) -> usize {
+        use std::io::Write;
+        use std::process::{Command, Stdio};
+        let (mut accepted, mut refused) = (0, 0);
+        for (batch, chunk) in patterns.chunks(128).enumerate() {
+            let rules: Vec<_> = chunk
+                .iter()
+                .filter_map(|p| match PythonRule::compile(p, false) {
+                    Ok(r) => Some((p, r)),
+                    Err(()) => {
+                        refused += 1;
+                        None
+                    }
+                })
+                .collect();
+            if rules.is_empty() {
+                continue;
+            }
+            accepted += rules.len();
+            let array = |items: Vec<&str>| {
+                let mut out = String::from("[");
+                for (i, item) in items.iter().enumerate() {
+                    if i != 0 {
+                        out.push(',');
+                    }
+                    pycompat::json::quote(&mut out, item, true);
+                }
+                out.push(']');
+                out
+            };
+            let input = format!(
+                "[{},{}]",
+                array(rules.iter().map(|(p, _)| p.as_str()).collect()),
+                array(texts.iter().map(String::as_str).collect())
+            );
+            let mut child = Command::new("python3")
+                .args([
+                    "-I",
+                    "-c",
+                    r#"
+import json,re,sys
+patterns,texts=json.load(sys.stdin)
+for p in patterns:
+    r=re.compile(p)
+    for text in texts:
+        print(','.join(str(m.start())+':'+str(m.end()) for m in r.finditer(text)))
+"#,
+                ])
+                .stdin(Stdio::piped())
+                .stdout(Stdio::piped())
+                .stderr(Stdio::piped())
+                .spawn()
+                .unwrap();
+            let mut stdin = child.stdin.take().unwrap();
+            let writer = std::thread::spawn(move || stdin.write_all(input.as_bytes()));
+            let output = child.wait_with_output().unwrap();
+            writer.join().unwrap().unwrap();
+            assert!(output.status.success(), "model oracle failed");
+            assert!(output.stderr.is_empty(), "model oracle diagnostic");
+            let oracle = String::from_utf8(output.stdout).unwrap();
+            let mut spans = oracle.lines();
+            for (index, (_, rule)) in rules.iter().enumerate() {
+                for (t, text) in texts.iter().enumerate() {
+                    assert_eq!(
+                        Some(span_list(rule, text).as_str()),
+                        spans.next(),
+                        "{label}: batch {batch}, accepted pattern {index}, text {t}"
+                    );
+                }
+            }
+            assert!(spans.next().is_none(), "extra oracle rows");
+        }
+        let pairs = accepted * texts.len();
+        println!(
+            "{label}: {} patterns, {accepted} accepted, {refused} refused, {} texts, {pairs} pairs, zero span differences",
+            patterns.len(),
+            texts.len()
+        );
+        pairs
+    }
+
+    #[test]
+    fn exhaustive_small_model_spans() {
+        // CI: every <=2-node pattern against all <=2-character texts.
+        assert!(compare_model("exhaustive-ci", &model_patterns(2), &model_texts(2)) > 10_000);
+    }
+
+    #[test]
+    #[ignore = "large local model; run explicitly with --ignored --nocapture"]
+    fn exhaustive_large_model_spans() {
+        // Local: every <=3-node pattern against all <=3-character texts.
+        assert!(compare_model("exhaustive-local", &model_patterns(3), &model_texts(3)) > 1_000_000);
+    }
+
+    fn fuzz_pattern(state: &mut u64, depth: usize) -> String {
+        fn next(state: &mut u64) -> usize {
+            *state ^= *state << 13;
+            *state ^= *state >> 7;
+            *state ^= *state << 17;
+            *state as usize
+        }
+        if depth == 0 || next(state).is_multiple_of(4) {
+            return MODEL_ATOMS[next(state) % MODEL_ATOMS.len()].into();
+        }
+        let p = fuzz_pattern(state, depth - 1);
+        match next(state) % 4 {
+            0 => format!("({}{p})", MODEL_GROUPS[next(state) % MODEL_GROUPS.len()]),
+            1 => format!(
+                "(?:{p}){}",
+                MODEL_QUANTIFIERS[next(state) % MODEL_QUANTIFIERS.len()]
+            ),
+            2 => format!("(?:{p}|{})", fuzz_pattern(state, depth - 1)),
+            _ => format!("(?:{p})(?:{})", fuzz_pattern(state, depth - 1)),
+        }
+    }
+
+    #[test]
+    fn round3_two_seed_span_fuzz() {
+        for mut seed in [0x401ad33, 0x3ad401] {
+            let label = format!("fuzz-{seed:x}");
+            let mut patterns = Vec::new();
+            // Focus the same seeds on nullable alternatives and nested repeats.
+            for _ in 0..1500 {
+                let p = fuzz_pattern(&mut seed, 4);
+                patterns.push(p.clone());
+                patterns.push(format!("(?:{p}|a*?){{1,3}}"));
+            }
+            assert!(compare_model(&label, &patterns, &model_texts(3)) > 50_000);
+        }
+    }
 }
diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
index 477f11a1e..2bf5a6ca4 100644
--- a/rust/crates/og-dev/src/personal_data.rs
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -27,9 +27,7 @@
 //! DIR given as `/tmp/x` still finds `/private/tmp/x/CLAUDE.md`'s examples.
 
 use std::collections::HashMap;
-use std::ffi::OsStr;
 use std::io::{BufRead, BufReader, Read, Write};
-use std::os::unix::ffi::OsStrExt;
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
 use std::sync::LazyLock;
@@ -284,7 +282,8 @@ fn own_rules(path: &str) -> Result<Vec<Check>, String> {
 
 /// `path` relative to `root` when it lies below it (both with symbolic
 /// links resolved), else `path` as given.
-fn relative(path: &Path, root: &Path) -> String {
+fn relative(path: &Path, root: &Path) -> Result<String, String> {
+    utf8_path(path)?;
     let abs = if path.is_absolute() {
         path.to_path_buf()
     } else {
@@ -299,28 +298,36 @@ fn relative(path: &Path, root: &Path) -> String {
         _ => abs.clone(),
     };
     match placed.strip_prefix(root) {
-        Ok(rel) if !rel.as_os_str().is_empty() => rel.to_string_lossy().into_owned(),
-        _ => path.to_string_lossy().into_owned(),
+        Ok(rel) if !rel.as_os_str().is_empty() => utf8_path(rel).map(str::to_owned),
+        _ => utf8_path(path).map(str::to_owned),
     }
 }
 
+fn utf8_path(path: &Path) -> Result<&str, String> {
+    path.to_str()
+        .ok_or_else(|| "path is not valid UTF-8".into())
+}
+
 fn git_files(root: &Path) -> Result<Vec<PathBuf>, String> {
     let out = Command::new("git")
         .arg("-C")
         .arg(root)
         .args(["ls-files", "-z"])
-        .stderr(Stdio::inherit())
+        .stderr(Stdio::piped())
         .output()
         .map_err(|e| format!("cannot run git: {e}"))?;
     if !out.status.success() {
         return Err(format!("git ls-files failed in {}", root.display()));
     }
-    Ok(out
-        .stdout
+    out.stdout
         .split(|&b| b == 0)
         .filter(|f| !f.is_empty())
-        .map(|f| root.join(OsStr::from_bytes(f)))
-        .collect())
+        .map(|f| {
+            std::str::from_utf8(f)
+                .map(|s| root.join(s))
+                .map_err(|_| "path is not valid UTF-8".into())
+        })
+        .collect::<Result<Vec<_>, String>>()
 }
 
 /// The staged blob of each path (relative to `root`), from one
@@ -354,12 +361,15 @@ fn staged(root: &Path, rels: &[String]) -> Result<HashMap<String, Vec<u8>>, Stri
         if header.pop() != Some(0) {
             return Err("git cat-file: incomplete header".into());
         }
-        let head = String::from_utf8_lossy(&header);
+        let head =
+            std::str::from_utf8(&header).map_err(|_| "git cat-file: invalid header encoding")?;
         let fields: Vec<&str> = head.split(' ').collect();
         let [_, kind, size] = fields[..] else {
             continue; // "<name> missing" or "ambiguous"
         };
-        let size: usize = size.parse().map_err(|_| format!("git cat-file: {head}"))?;
+        let size: usize = size
+            .parse()
+            .map_err(|_| "git cat-file: invalid object size".to_owned())?;
         let mut data = vec![0; size + 1];
         out.read_exact(&mut data).map_err(|e| e.to_string())?;
         data.pop();
@@ -392,6 +402,8 @@ fn scan_text(
     data: &[u8],
 ) -> Result<bool, ()> {
     let mut bad = false;
+    // Intentional content decoding, matching Python errors="replace". Paths
+    // and Git protocol headers are validated strictly before any conversion.
     let text = String::from_utf8_lossy(data);
     for (i, line) in lines(&text, Lines::Blob).enumerate() {
         let spans: Vec<(usize, usize)> = texts
@@ -425,10 +437,12 @@ fn scan_text(
 }
 
 fn run(a: &Args, out: &mut dyn Write) -> Result<bool, String> {
+    utf8_path(&a.root)?;
     let root = a
         .root
         .canonicalize()
         .map_err(|e| format!("--root {}: {e}", a.root.display()))?;
+    utf8_path(&root)?;
     let mut rules = builtin();
     if let Some(p) = &a.patterns {
         rules.extend(own_rules(p)?);
@@ -444,7 +458,9 @@ fn run(a: &Args, out: &mut dyn Write) -> Result<bool, String> {
     }
     let todo: Vec<(&PathBuf, String)> = files
         .iter()
-        .map(|f| (f, relative(f, &root)))
+        .map(|f| relative(f, &root).map(|rel| (f, rel)))
+        .collect::<Result<Vec<_>, _>>()?
+        .into_iter()
         .filter(|(_, rel)| !a.skip.iter().any(|g| fnmatch(rel, g)))
         .collect();
     let blobs = if a.cached {
@@ -524,6 +540,8 @@ pub fn cli(args: &[String], out: &mut dyn Write, err: &mut dyn Write) -> u8 {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::ffi::OsStr;
+    use std::os::unix::ffi::OsStrExt;
 
     fn kinds(line: &str) -> Vec<&'static str> {
         let rules = builtin();
diff --git a/rust/og/src/main.rs b/rust/og/src/main.rs
index 6e8776e50..1ce65f1f6 100644
--- a/rust/og/src/main.rs
+++ b/rust/og/src/main.rs
@@ -102,6 +102,18 @@ fn no_bam(tool: &str) -> ExitCode {
 }
 
 fn main() -> ExitCode {
+    // Refuse raw-byte scanner arguments before std::env::args can panic or
+    // any path can be replaced with a different name. Other verbs retain
+    // their existing argument handling.
+    let raw: Vec<_> = std::env::args_os().skip(1).collect();
+    if raw
+        .get(..3)
+        .is_some_and(|prefix| prefix == ["dev", "scan", "personal-data"])
+        && raw.iter().any(|s| s.to_str().is_none())
+    {
+        eprintln!("ERROR: path is not valid UTF-8");
+        return ExitCode::from(2);
+    }
     let args: Vec<String> = std::env::args().skip(1).collect();
     let Some(tool) = args.first() else {
         return usage_error("the following arguments are required: tool");
diff --git a/scripts/ci/check-personal-data.sh b/scripts/ci/check-personal-data.sh
index 3d7781bce..09208035c 100755
--- a/scripts/ci/check-personal-data.sh
+++ b/scripts/ci/check-personal-data.sh
@@ -42,8 +42,12 @@
 # and global or scoped i/m/s/x flags. Hex \xHH, \uHHHH and \UHHHHHHHH and
 # standard control escapes are supported. Unicode word characters, spaces
 # and simple case folding follow Python, including dotted and dotless I.
-# Empty matches follow Python 3.14+ finditer, including a nonempty match at
-# the same position. Captures never narrow the span checked against ALLOW.
+# Every quantified operand must be nonnullable: it must consume a character
+# on every successful match. This includes groups and alternatives under
+# greedy or lazy ?, *, + and braces. For example, (a?)+ and (a*|b){1,3}
+# are refused. Nullability propagates through flags, groups and alternatives.
+# Empty matches outside such operands follow Python 3.14+ finditer. A
+# nonempty match can follow an empty match at the same position. Captures never narrow the span checked against ALLOW.
 #
 # Backreferences, look-around in custom patterns, conditionals, atomic or
 # possessive groups, ASCII/locale flags, named Unicode and octal escapes,
@@ -51,6 +55,8 @@
 # over 16 KiB or with more than 64 nested groups are rejected. Unsupported
 # syntax, invalid patterns and a matcher resource-limit error stop the scan
 # with exit 2 and a diagnostic that omits the pattern and scanned values.
+# A path with invalid UTF-8 also stops the scan before SKIP, path conversion
+# or staged-blob requests. File contents still use replacement decoding.
 #
 # The scan is og dev scan personal-data (rust/crates/og-dev); bin/og runs
 # the build scripts/setup.sh --og puts in bin/.og for this machine, and OG
diff --git a/tests/parity/inputs/dev-scanners/containers.config b/tests/parity/inputs/dev-scanners/containers.config
index 46eca54a9..cf204b9ef 100644
--- a/tests/parity/inputs/dev-scanners/containers.config
+++ b/tests/parity/inputs/dev-scanners/containers.config
@@ -1 +1,3 @@
-withName: 'SYNTHETIC' { container = 'example/tool:1.2' }
+process {
+    withName: 'SYNTHETIC' { container = 'example/tool:1.2' }
+}

From ac030e631afa5550f2c128a0998d2cb95dee14db Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 17:29:49 +0100
Subject: [PATCH 53/76] test(ci): expose Unicode version and symlink target
 gaps

---
 rust/crates/og-dev/src/personal_data.rs | 115 ++++++++++++++++++++++++
 1 file changed, 115 insertions(+)

diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
index 2bf5a6ca4..46a152720 100644
--- a/rust/crates/og-dev/src/personal_data.rs
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -1340,4 +1340,119 @@ mod tests {
             );
         }
     }
+    #[test]
+    fn round4_unicode_versions_fail_closed() {
+        let f = Fixture::new("r4-unicode");
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(&f.0)
+                .args(["init", "-q"])
+                .status()
+                .unwrap()
+                .success()
+        );
+        let cases = [
+            (p("\u{105c0}rs555~ AG"), None),
+            (p("HG004\u{105c0} *2/~*8"), None),
+            (p("HTT\u{105c0} 18/~32"), None),
+            ("\u{105c0}".into(), Some(r"\W+")),
+            ("\u{1e6c0}".into(), Some(r"\w+")),
+            ("\u{16ebb}".into(), Some(r"(?i)\U00016ea0")),
+        ];
+        let mut failures = Vec::new();
+        for (case, (text, pattern)) in cases.iter().enumerate() {
+            std::fs::write(f.0.join("own.md"), text).unwrap();
+            std::fs::write(f.0.join("patterns"), pattern.unwrap_or("# none")).unwrap();
+            assert!(
+                Command::new("git")
+                    .arg("-C")
+                    .arg(&f.0)
+                    .args(["add", "own.md"])
+                    .status()
+                    .unwrap()
+                    .success()
+            );
+            for cached in [false, true] {
+                for explicit in [false, true] {
+                    let mut args = f.args(if explicit { &["own.md"] } else { &[] });
+                    if cached {
+                        args.push("--cached".into());
+                    }
+                    if pattern.is_some() {
+                        args.extend([
+                            "--patterns".into(),
+                            f.0.join("patterns").display().to_string(),
+                        ]);
+                    }
+                    let (mut out, mut err) = (Vec::new(), Vec::new());
+                    let code = cli(&args, &mut out, &mut err);
+                    if code != 2 {
+                        failures.push((case, cached, explicit, code));
+                    }
+                    assert!(!String::from_utf8_lossy(&out).contains(text));
+                    assert!(!String::from_utf8_lossy(&err).contains(text));
+                }
+            }
+        }
+        assert!(
+            failures.is_empty(),
+            "version-dependent text must fail closed: {failures:?}"
+        );
+    }
+
+    #[test]
+    fn round4_symlink_targets_fail_closed() {
+        let f = Fixture::new("r4-symlinks");
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(&f.0)
+                .args(["init", "-q"])
+                .status()
+                .unwrap()
+                .success()
+        );
+        std::fs::write(f.0.join("clean.md"), "clean").unwrap();
+        std::os::unix::fs::symlink(
+            OsStr::from_bytes(b"private_target_\xff.md"),
+            f.0.join("alias.md"),
+        )
+        .unwrap();
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(&f.0)
+                .args(["add", "alias.md", "clean.md"])
+                .status()
+                .unwrap()
+                .success()
+        );
+        let mut failures = Vec::new();
+        for cached in [false, true] {
+            for explicit in [false, true] {
+                let mut args = f.args(if explicit {
+                    &["alias.md", "clean.md"]
+                } else {
+                    &[]
+                });
+                if cached {
+                    args.push("--cached".into());
+                }
+                let (mut out, mut err) = (Vec::new(), Vec::new());
+                let code = cli(&args, &mut out, &mut err);
+                if code != 2 {
+                    failures.push((cached, explicit, code));
+                }
+                if code == 2 {
+                    assert!(out.is_empty());
+                    assert_eq!(err, b"ERROR: path is not valid UTF-8\n");
+                }
+            }
+        }
+        assert!(
+            failures.is_empty(),
+            "raw symlink target must stop scan: {failures:?}"
+        );
+    }
 }

From 80da08835fb7b223c681a7cf60d3a7a7fa2eb6ef Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 17:33:35 +0100
Subject: [PATCH 54/76] fix(ci): keep og setup logs out of captured smoke
 values

---
 CHANGELOG.md              |  2 +-
 scripts/ci/image-smoke.sh | 37 +++++++++++++++++++++++++++++++++++--
 2 files changed, 36 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 79e7ba9e4..60875d363 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,7 +4,7 @@ Each release's notes. From 1.0.0 on, a major or minor release has hand-written n
 
 ## Unreleased
 
-- The shared `og-io` line reader bounds memory by the longest record for CR-only files as well as LF and CRLF files. Smoke coordinates require signed integers, so decimal and nonfinite coordinates fail. Trace integer cells accept whitespace, signs and underscores but deliberately refuse Unicode digits and negative resources. Integers outside the target range fail. Duplicate task rows retain concrete exits. Smoke JSON checks require one document, numeric counts and copy numbers, array catalogs and string genotypes. Numeric depth strings stay supported; booleans are refused. The array and genotype rules deliberately reject malformed values Python accepted. Smoke fixtures build a missing default `og` on first use.
+- The shared `og-io` line reader bounds memory by the longest record for CR-only files as well as LF and CRLF files. Smoke coordinates require signed integers, so decimal and nonfinite coordinates fail. Trace integer cells accept whitespace, signs and underscores but deliberately refuse Unicode digits and negative resources. Integers outside the target range fail. Duplicate task rows retain concrete exits. Smoke JSON checks require one document, numeric counts and copy numbers, array catalogs and string genotypes. Numeric depth strings stay supported; booleans are refused. The array and genotype rules deliberately reject malformed values Python accepted. Smoke fixtures build a missing default `og` on first use. Setup output goes to stderr so captured PharmCAT counts and CSV values stay clean.
 - CI readers now use `og dev pharmcat diplotypes`, `nf-trace` and `smoke`. Unreadable PharmCAT reports fail with exit 2 and are marked not assessed. Resource checks refuse trace globs and malformed numeric cells. The smoke mini-reference uses a fixed Rust seed for the planted bases. Gzip smoke reads have deterministic headers. Smoke table checks report concise property results.
 
 - The container helpers check (`scripts/ci/check-container-helpers.sh`, Guard job `helper-binaries`) now derives its table with the Rust `og` binary, `og dev helpers`. It replaces the Python inside the script, which is gone; the script keeps the docker probe, the orad download and its self-test. On this tree the table and the rule 1 output are the same, byte for byte. The static run takes 0.01 s and 6 MB where the Python took 0.2 s and 15 MB. What changes:
diff --git a/scripts/ci/image-smoke.sh b/scripts/ci/image-smoke.sh
index ef21b6a67..3457a5398 100755
--- a/scripts/ci/image-smoke.sh
+++ b/scripts/ci/image-smoke.sh
@@ -188,11 +188,17 @@ self_test() {
   cat > "${tmp}/repo/bin/og" <<'SH'
 #!/usr/bin/env bash
 [ -f "$(dirname "$0")/../ready" ] || exit 127
-printf '%s\n' "$*"
+case "$1 $2 ${3:-}" in
+  'dev pharmcat diplotypes') printf '1\n' ;;
+  'dev smoke csv-cell') printf '0.9\n' ;;
+  *) printf '%s\n' "$*" ;;
+esac
 SH
   cat > "${tmp}/repo/scripts/setup.sh" <<'SH'
 #!/usr/bin/env bash
 [ "$1" = --og ] || exit 2
+printf 'Building og ...\n'
+printf 'builder diagnostic\n' >&2
 printf 'built\n' >> "$(dirname "$0")/../ready"
 SH
   chmod +x "${tmp}/repo/bin/og"
@@ -211,6 +217,32 @@ SH
   '); rc=$?
   if [ "$rc" -eq 0 ]; then echo "[PASS] missing default og is built once; explicit OG failure is retained"
   else echo "[FAIL] og fixture preparation: $out"; fails=$((fails + 1)); fi
+  # A value helper can trigger setup inside command substitution. Use the
+  # real assertions with a noisy builder and no default binary built yet.
+  rm -f "${tmp}/repo/ready"
+  # shellcheck disable=SC2016  # variables belong to the isolated test shell
+  out=$(env -u OG REPO="${tmp}/repo" bash -c "$(declare -f smoke_og pharmcat_called check_pharmcat csv_cell num at_least between pass fail)"'
+    rc=0
+    "$REPO/bin/og" --version >/dev/null 2>&1 || rc=$?
+    [ "$rc" -eq 127 ] || exit 1
+    count=$(pharmcat_called report.json 2> "$REPO/build.log") || exit 1
+    [ "$count" = 1 ] || { printf "unexpected count: %s\n" "$count"; exit 1; }
+    grep -qx "Building og ..." "$REPO/build.log" || exit 1
+    grep -qx "builder diagnostic" "$REPO/build.log" || exit 1
+    rm -f "$REPO/ready"
+    CHECK_FAILS=0
+    check_pharmcat "first-use PharmCAT count" report.json 2> "$REPO/build.log"
+    [ "$CHECK_FAILS" -eq 0 ] || exit 1
+    [ "$(wc -l < "$REPO/ready")" -eq 1 ] || exit 1
+    rm -f "$REPO/ready"
+    value=$(csv_cell summary.csv Type=SNP,Filter=PASS METRIC.Recall 2> "$REPO/build.log") || exit 1
+    [ "$value" = 0.9 ] || { printf "unexpected CSV value: %s\n" "$value"; exit 1; }
+    between "first-use CSV recall" "$value" 0.85 0.95
+    [ "$CHECK_FAILS" -eq 0 ] || exit 1
+    [ "$(wc -l < "$REPO/ready")" -eq 1 ] || exit 1
+  '); rc=$?
+  if [ "$rc" -eq 0 ]; then echo "[PASS] first-use PharmCAT and CSV values exclude setup output"
+  else echo "[FAIL] first-use value capture: $out"; fails=$((fails + 1)); fi
   rm -rf "$tmp"
   if [ "$fails" -gt 0 ]; then echo "self-test: ${fails} case(s) failed" >&2; return 1; fi
   echo "self-test: all cases passed"
@@ -544,7 +576,8 @@ smoke_og() {
   local rc=0
   "${OG:-${REPO}/bin/og}" --version >/dev/null 2>&1 || rc=$?
   if [ "$rc" -eq 127 ] && [ -z "${OG:-}" ]; then
-    bash "${REPO}/scripts/setup.sh" --og || return 1
+    # This can run inside a captured value helper: only og's result is stdout.
+    bash "${REPO}/scripts/setup.sh" --og >&2 || return 1
   elif [ "$rc" -ne 0 ]; then
     return "$rc"
   fi

From 7e5623c40fb7a3b2164dc99ee07c84b00cf45631 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 17:39:41 +0100
Subject: [PATCH 55/76] fix(ci): fail closed on Unicode drift and invalid
 symlink targets

---
 .github/workflows/guard.yml                   |  33 +-
 CHANGELOG.md                                  |   2 +
 rust/crates/og-dev/src/lookaround.rs          |   8 +-
 rust/crates/og-dev/src/personal_data.rs       | 942 +++++++++++++++++-
 scripts/ci/check-personal-data.sh             |  22 +-
 tests/parity/gen/personal-unicode-generate.sh |  19 +
 .../parity/gen/personal-unicode-generator.rs  | 137 +++
 tests/parity/gen/personal-unicode-sources.tsv |   8 +
 8 files changed, 1161 insertions(+), 10 deletions(-)
 create mode 100755 tests/parity/gen/personal-unicode-generate.sh
 create mode 100644 tests/parity/gen/personal-unicode-generator.rs
 create mode 100644 tests/parity/gen/personal-unicode-sources.tsv

diff --git a/.github/workflows/guard.yml b/.github/workflows/guard.yml
index 4e44087c5..0383d5894 100644
--- a/.github/workflows/guard.yml
+++ b/.github/workflows/guard.yml
@@ -265,8 +265,13 @@ jobs:
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
-      # Scanner patterns target Python 3.14+ finditer, including \B on empty
-      # text. Use the oracle image's minor version for differential tests.
+      # Keep both ends of the Unicode-version differential available. The
+      # scanner fails closed on version-dependent scalars; span iteration
+      # intentionally uses Python 3.14+ semantics for empty-text \B.
+      - uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0
+        with:
+          python-version: '3.12'
+
       - uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0
         with:
           python-version: '3.15'
@@ -355,6 +360,30 @@ jobs:
           done
           echo "Control: nullable operands and raw-byte paths failed before the fix."
 
+      - name: Unicode guard regenerates from pinned official data
+        run: bash ../tests/parity/gen/personal-unicode-generate.sh "$RUNNER_TEMP/personal-unicode"
+
+      - name: Scanner round-four controls (Unicode versions and symlink targets fail before the fix)
+        run: |
+          source=crates/og-dev/src/personal_data.rs
+          matcher=crates/og-dev/src/lookaround.rs
+          cp "$source" "${RUNNER_TEMP}/round4-personal-fixed.rs"
+          cp "$matcher" "${RUNNER_TEMP}/round4-matcher-fixed.rs"
+          trap 'cp "${RUNNER_TEMP}/round4-personal-fixed.rs" "$source"; cp "${RUNNER_TEMP}/round4-matcher-fixed.rs" "$matcher"' EXIT
+          before=ac030e631afa5550f2c128a0998d2cb95dee14db
+          git cat-file -e "$before^{commit}" 2>/dev/null || git fetch --quiet --depth=1 origin "$before"
+          git show "$before:rust/$source" > "$source"
+          git show "$before:rust/$matcher" > "$matcher"
+          log="${RUNNER_TEMP}/scanner-round4-red.log"
+          rc=0
+          cargo test -p og-dev --locked --no-fail-fast round4_ > "$log" 2>&1 || rc=$?
+          cat "$log"
+          [ "$rc" -ne 0 ]
+          for test in unicode_versions_fail_closed symlink_targets_fail_closed; do
+            grep -E "round4_${test} .*FAILED" "$log" || { echo "ERROR: missing round-four red control"; exit 1; }
+          done
+          echo "Control: all 24 Unicode and four symlink scenarios failed before the fix."
+
       - name: Scanner matcher controls (word classes and swallowed errors must be caught)
         run: |
           source=crates/og-dev/src/lookaround.rs
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9f218297a..200b30491 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,8 @@ Each release's notes. From 1.0.0 on, a major or minor release has hand-written n
 
 ## Unreleased
 
+- The personal-data scan fails closed with redacted exit 2 on Unicode-version-dependent text, patterns and ALLOW/SKIP entries. Its generated guard covers UCD 13/15/16/17 and unassigned scalars. Newer emoji and plain symbols still scan. Files with newer script letters need an ASCII SKIP glob. Invalid UTF-8 symlink targets now fail before exclusions in working-copy and index scans.
+
 - The personal-data scan, the image scan and the version checks of CI now run in the Rust `og` binary: `og dev scan personal-data` (`scripts/ci/check-personal-data.sh`), `og dev scan images` and `og dev versions coupled` (`scripts/ci/check-images.sh`), `og dev versions check-run` (`scripts/ci/gen-containers-config.sh --check-versions`), `og dev versions expand` (`scripts/ci/check-links.sh`) and `og dev pgs` (`scripts/ci/check-pgs-labels.sh`). The scripts keep their options and lists; the Python inside them is gone. Fixes:
   - A personal-data scan that read no text file (every file skipped or binary) fails with `FAIL: no text file was scanned`. It printed `scanned 0 text files` and passed.
   - A personal-data scan whose root is reached through a symbolic link places each file under that root, so the lists of skipped files and documented examples still apply to it.
diff --git a/rust/crates/og-dev/src/lookaround.rs b/rust/crates/og-dev/src/lookaround.rs
index 2b1dc9dd2..58240c74c 100644
--- a/rust/crates/og-dev/src/lookaround.rs
+++ b/rust/crates/og-dev/src/lookaround.rs
@@ -113,6 +113,9 @@ pub struct PythonRule {
 
 impl PythonRule {
     pub fn compile(pattern: &str, builtin: bool) -> Result<Self, ()> {
+        if pattern.chars().any(crate::personal_data::version_dependent) {
+            return Err(());
+        }
         if pattern.len() > 16_384 {
             return Err(());
         }
@@ -518,6 +521,9 @@ fn class_literal(atom: &str) -> Option<char> {
 }
 
 fn literal(c: char, ci: bool) -> Result<String, ()> {
+    if crate::personal_data::version_dependent(c) {
+        return Err(());
+    }
     let escaped = format!(r"\x{{{:x}}}", u32::from(c));
     if ci {
         fold_class(&format!("[{escaped}]"))
@@ -705,7 +711,7 @@ mod python_tests {
         for _ in 0..length {
             level = level
                 .iter()
-                .flat_map(|p| ['a', 'b', '0', ' ', '\u{301}'].map(|c| format!("{p}{c}")))
+                .flat_map(|p| ['a', 'b', '0', ' ', '\u{301}', 'é'].map(|c| format!("{p}{c}")))
                 .collect();
             all.extend(level.iter().cloned());
         }
diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
index 46a152720..75a84e026 100644
--- a/rust/crates/og-dev/src/personal_data.rs
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -26,7 +26,7 @@
 //! file is placed under DIR after resolving symbolic links in both, so
 //! DIR given as `/tmp/x` still finds `/private/tmp/x/CLAUDE.md`'s examples.
 
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::io::{BufRead, BufReader, Read, Write};
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
@@ -37,6 +37,732 @@ use pycompat::num::py_strip;
 
 use crate::lookaround::PythonRule as Rule;
 
+// One generated guard, shared by text, patterns and exception tables. It is
+// deliberately conservative; matching itself still uses one Unicode table.
+// BEGIN GENERATED UNICODE GUARD
+// Generated by personal-unicode-generator.rs; do not edit.
+// UCD 13.0.0, 15.0.0, 16.0.0, 17.0.0; sources pinned in personal-unicode-sources.tsv.
+const VERSION_DEPENDENT: &[(u32, u32)] = &[
+    (0x19b, 0x19b),
+    (0x264, 0x264),
+    (0x378, 0x379),
+    (0x380, 0x383),
+    (0x38b, 0x38b),
+    (0x38d, 0x38d),
+    (0x390, 0x390),
+    (0x3a2, 0x3a2),
+    (0x3b0, 0x3b0),
+    (0x530, 0x530),
+    (0x557, 0x558),
+    (0x58b, 0x58c),
+    (0x590, 0x590),
+    (0x5c8, 0x5cf),
+    (0x5eb, 0x5ee),
+    (0x5f5, 0x5ff),
+    (0x70e, 0x70e),
+    (0x74b, 0x74c),
+    (0x7b2, 0x7bf),
+    (0x7fb, 0x7fc),
+    (0x82e, 0x82f),
+    (0x83f, 0x83f),
+    (0x85c, 0x85d),
+    (0x85f, 0x85f),
+    (0x86b, 0x887),
+    (0x889, 0x88f),
+    (0x892, 0x89f),
+    (0x8b5, 0x8b5),
+    (0x8c8, 0x8d2),
+    (0x984, 0x984),
+    (0x98d, 0x98e),
+    (0x991, 0x992),
+    (0x9a9, 0x9a9),
+    (0x9b1, 0x9b1),
+    (0x9b3, 0x9b5),
+    (0x9ba, 0x9bb),
+    (0x9c5, 0x9c6),
+    (0x9c9, 0x9ca),
+    (0x9cf, 0x9d6),
+    (0x9d8, 0x9db),
+    (0x9de, 0x9de),
+    (0x9e4, 0x9e5),
+    (0x9ff, 0xa00),
+    (0xa04, 0xa04),
+    (0xa0b, 0xa0e),
+    (0xa11, 0xa12),
+    (0xa29, 0xa29),
+    (0xa31, 0xa31),
+    (0xa34, 0xa34),
+    (0xa37, 0xa37),
+    (0xa3a, 0xa3b),
+    (0xa3d, 0xa3d),
+    (0xa43, 0xa46),
+    (0xa49, 0xa4a),
+    (0xa4e, 0xa50),
+    (0xa52, 0xa58),
+    (0xa5d, 0xa5d),
+    (0xa5f, 0xa65),
+    (0xa77, 0xa80),
+    (0xa84, 0xa84),
+    (0xa8e, 0xa8e),
+    (0xa92, 0xa92),
+    (0xaa9, 0xaa9),
+    (0xab1, 0xab1),
+    (0xab4, 0xab4),
+    (0xaba, 0xabb),
+    (0xac6, 0xac6),
+    (0xaca, 0xaca),
+    (0xace, 0xacf),
+    (0xad1, 0xadf),
+    (0xae4, 0xae5),
+    (0xaf2, 0xaf8),
+    (0xb00, 0xb00),
+    (0xb04, 0xb04),
+    (0xb0d, 0xb0e),
+    (0xb11, 0xb12),
+    (0xb29, 0xb29),
+    (0xb31, 0xb31),
+    (0xb34, 0xb34),
+    (0xb3a, 0xb3b),
+    (0xb45, 0xb46),
+    (0xb49, 0xb4a),
+    (0xb4e, 0xb54),
+    (0xb58, 0xb5b),
+    (0xb5e, 0xb5e),
+    (0xb64, 0xb65),
+    (0xb78, 0xb81),
+    (0xb84, 0xb84),
+    (0xb8b, 0xb8d),
+    (0xb91, 0xb91),
+    (0xb96, 0xb98),
+    (0xb9b, 0xb9b),
+    (0xb9d, 0xb9d),
+    (0xba0, 0xba2),
+    (0xba5, 0xba7),
+    (0xbab, 0xbad),
+    (0xbba, 0xbbd),
+    (0xbc3, 0xbc5),
+    (0xbc9, 0xbc9),
+    (0xbce, 0xbcf),
+    (0xbd1, 0xbd6),
+    (0xbd8, 0xbe5),
+    (0xbfb, 0xbff),
+    (0xc0d, 0xc0d),
+    (0xc11, 0xc11),
+    (0xc29, 0xc29),
+    (0xc3a, 0xc3c),
+    (0xc45, 0xc45),
+    (0xc49, 0xc49),
+    (0xc4e, 0xc54),
+    (0xc57, 0xc57),
+    (0xc5b, 0xc5f),
+    (0xc64, 0xc65),
+    (0xc70, 0xc76),
+    (0xc8d, 0xc8d),
+    (0xc91, 0xc91),
+    (0xca9, 0xca9),
+    (0xcb4, 0xcb4),
+    (0xcba, 0xcbb),
+    (0xcc5, 0xcc5),
+    (0xcc9, 0xcc9),
+    (0xcce, 0xcd4),
+    (0xcd7, 0xcdd),
+    (0xcdf, 0xcdf),
+    (0xce4, 0xce5),
+    (0xcf0, 0xcf0),
+    (0xcf3, 0xcff),
+    (0xd0d, 0xd0d),
+    (0xd11, 0xd11),
+    (0xd45, 0xd45),
+    (0xd49, 0xd49),
+    (0xd50, 0xd53),
+    (0xd64, 0xd65),
+    (0xd80, 0xd80),
+    (0xd84, 0xd84),
+    (0xd97, 0xd99),
+    (0xdb2, 0xdb2),
+    (0xdbc, 0xdbc),
+    (0xdbe, 0xdbf),
+    (0xdc7, 0xdc9),
+    (0xdcb, 0xdce),
+    (0xdd5, 0xdd5),
+    (0xdd7, 0xdd7),
+    (0xde0, 0xde5),
+    (0xdf0, 0xdf1),
+    (0xdf5, 0xe00),
+    (0xe3b, 0xe3e),
+    (0xe5c, 0xe80),
+    (0xe83, 0xe83),
+    (0xe85, 0xe85),
+    (0xe8b, 0xe8b),
+    (0xea4, 0xea4),
+    (0xea6, 0xea6),
+    (0xebe, 0xebf),
+    (0xec5, 0xec5),
+    (0xec7, 0xec7),
+    (0xece, 0xecf),
+    (0xeda, 0xedb),
+    (0xee0, 0xeff),
+    (0xf48, 0xf48),
+    (0xf6d, 0xf70),
+    (0xf98, 0xf98),
+    (0xfbd, 0xfbd),
+    (0xfcd, 0xfcd),
+    (0xfdb, 0xfff),
+    (0x10c6, 0x10c6),
+    (0x10c8, 0x10cc),
+    (0x10ce, 0x10cf),
+    (0x1249, 0x1249),
+    (0x124e, 0x124f),
+    (0x1257, 0x1257),
+    (0x1259, 0x1259),
+    (0x125e, 0x125f),
+    (0x1289, 0x1289),
+    (0x128e, 0x128f),
+    (0x12b1, 0x12b1),
+    (0x12b6, 0x12b7),
+    (0x12bf, 0x12bf),
+    (0x12c1, 0x12c1),
+    (0x12c6, 0x12c7),
+    (0x12d7, 0x12d7),
+    (0x1311, 0x1311),
+    (0x1316, 0x1317),
+    (0x135b, 0x135c),
+    (0x137d, 0x137f),
+    (0x139a, 0x139f),
+    (0x13f6, 0x13f7),
+    (0x13fe, 0x13ff),
+    (0x169d, 0x169f),
+    (0x16f9, 0x16ff),
+    (0x170d, 0x170d),
+    (0x1715, 0x171f),
+    (0x1737, 0x173f),
+    (0x1754, 0x175f),
+    (0x176d, 0x176d),
+    (0x1771, 0x1771),
+    (0x1774, 0x177f),
+    (0x17de, 0x17df),
+    (0x17ea, 0x17ef),
+    (0x17fa, 0x17ff),
+    (0x180f, 0x180f),
+    (0x181a, 0x181f),
+    (0x1879, 0x187f),
+    (0x18ab, 0x18af),
+    (0x18f6, 0x18ff),
+    (0x191f, 0x191f),
+    (0x192c, 0x192f),
+    (0x193c, 0x193f),
+    (0x1941, 0x1943),
+    (0x196e, 0x196f),
+    (0x1975, 0x197f),
+    (0x19ac, 0x19af),
+    (0x19ca, 0x19cf),
+    (0x19db, 0x19dd),
+    (0x1a1c, 0x1a1d),
+    (0x1a5f, 0x1a5f),
+    (0x1a7d, 0x1a7e),
+    (0x1a8a, 0x1a8f),
+    (0x1a9a, 0x1a9f),
+    (0x1aae, 0x1aaf),
+    (0x1ac1, 0x1aff),
+    (0x1b4c, 0x1b4d),
+    (0x1bf4, 0x1bfb),
+    (0x1c38, 0x1c3a),
+    (0x1c4a, 0x1c4c),
+    (0x1c89, 0x1c8f),
+    (0x1cbb, 0x1cbc),
+    (0x1cc8, 0x1ccf),
+    (0x1cfb, 0x1cff),
+    (0x1dfa, 0x1dfa),
+    (0x1f16, 0x1f17),
+    (0x1f1e, 0x1f1f),
+    (0x1f46, 0x1f47),
+    (0x1f4e, 0x1f4f),
+    (0x1f58, 0x1f58),
+    (0x1f5a, 0x1f5a),
+    (0x1f5c, 0x1f5c),
+    (0x1f5e, 0x1f5e),
+    (0x1f7e, 0x1f7f),
+    (0x1fb5, 0x1fb5),
+    (0x1fc5, 0x1fc5),
+    (0x1fd3, 0x1fd5),
+    (0x1fdc, 0x1fdc),
+    (0x1fe3, 0x1fe3),
+    (0x1ff0, 0x1ff1),
+    (0x1ff5, 0x1ff5),
+    (0x1fff, 0x1fff),
+    (0x2065, 0x2065),
+    (0x2072, 0x2073),
+    (0x208f, 0x208f),
+    (0x209d, 0x209f),
+    (0x20c2, 0x20cf),
+    (0x20f1, 0x20ff),
+    (0x218c, 0x218f),
+    (0x242a, 0x243f),
+    (0x244b, 0x245f),
+    (0x2b74, 0x2b75),
+    (0x2c2f, 0x2c2f),
+    (0x2c5f, 0x2c5f),
+    (0x2cf4, 0x2cf8),
+    (0x2d26, 0x2d26),
+    (0x2d28, 0x2d2c),
+    (0x2d2e, 0x2d2f),
+    (0x2d68, 0x2d6e),
+    (0x2d71, 0x2d7e),
+    (0x2d97, 0x2d9f),
+    (0x2da7, 0x2da7),
+    (0x2daf, 0x2daf),
+    (0x2db7, 0x2db7),
+    (0x2dbf, 0x2dbf),
+    (0x2dc7, 0x2dc7),
+    (0x2dcf, 0x2dcf),
+    (0x2dd7, 0x2dd7),
+    (0x2ddf, 0x2ddf),
+    (0x2e5e, 0x2e7f),
+    (0x2e9a, 0x2e9a),
+    (0x2ef4, 0x2eff),
+    (0x2fd6, 0x2fef),
+    (0x3040, 0x3040),
+    (0x3097, 0x3098),
+    (0x3100, 0x3104),
+    (0x3130, 0x3130),
+    (0x318f, 0x318f),
+    (0x31e6, 0x31ee),
+    (0x321f, 0x321f),
+    (0x9ffd, 0x9fff),
+    (0xa48d, 0xa48f),
+    (0xa4c7, 0xa4cf),
+    (0xa62c, 0xa63f),
+    (0xa6f8, 0xa6ff),
+    (0xa7c0, 0xa7c1),
+    (0xa7cb, 0xa7f4),
+    (0xa82d, 0xa82f),
+    (0xa83a, 0xa83f),
+    (0xa878, 0xa87f),
+    (0xa8c6, 0xa8cd),
+    (0xa8da, 0xa8df),
+    (0xa954, 0xa95e),
+    (0xa97d, 0xa97f),
+    (0xa9ce, 0xa9ce),
+    (0xa9da, 0xa9dd),
+    (0xa9ff, 0xa9ff),
+    (0xaa37, 0xaa3f),
+    (0xaa4e, 0xaa4f),
+    (0xaa5a, 0xaa5b),
+    (0xaac3, 0xaada),
+    (0xaaf7, 0xab00),
+    (0xab07, 0xab08),
+    (0xab0f, 0xab10),
+    (0xab17, 0xab1f),
+    (0xab27, 0xab27),
+    (0xab2f, 0xab2f),
+    (0xab6c, 0xab6f),
+    (0xabee, 0xabef),
+    (0xabfa, 0xabff),
+    (0xd7a4, 0xd7af),
+    (0xd7c7, 0xd7ca),
+    (0xd7fc, 0xd7ff),
+    (0xfa6e, 0xfa6f),
+    (0xfada, 0xfaff),
+    (0xfb05, 0xfb12),
+    (0xfb18, 0xfb1c),
+    (0xfb37, 0xfb37),
+    (0xfb3d, 0xfb3d),
+    (0xfb3f, 0xfb3f),
+    (0xfb42, 0xfb42),
+    (0xfb45, 0xfb45),
+    (0xfdd0, 0xfdef),
+    (0xfe1a, 0xfe1f),
+    (0xfe53, 0xfe53),
+    (0xfe67, 0xfe67),
+    (0xfe6c, 0xfe6f),
+    (0xfe75, 0xfe75),
+    (0xfefd, 0xfefe),
+    (0xff00, 0xff00),
+    (0xffbf, 0xffc1),
+    (0xffc8, 0xffc9),
+    (0xffd0, 0xffd1),
+    (0xffd8, 0xffd9),
+    (0xffdd, 0xffdf),
+    (0xffe7, 0xffe7),
+    (0xffef, 0xfff8),
+    (0xfffe, 0xffff),
+    (0x1000c, 0x1000c),
+    (0x10027, 0x10027),
+    (0x1003b, 0x1003b),
+    (0x1003e, 0x1003e),
+    (0x1004e, 0x1004f),
+    (0x1005e, 0x1007f),
+    (0x100fb, 0x100ff),
+    (0x10103, 0x10106),
+    (0x10134, 0x10136),
+    (0x1018f, 0x1018f),
+    (0x1019d, 0x1019f),
+    (0x101a1, 0x101cf),
+    (0x101fe, 0x1027f),
+    (0x1029d, 0x1029f),
+    (0x102d1, 0x102df),
+    (0x102fc, 0x102ff),
+    (0x10324, 0x1032c),
+    (0x1034b, 0x1034f),
+    (0x1037b, 0x1037f),
+    (0x1039e, 0x1039e),
+    (0x103c4, 0x103c7),
+    (0x103d6, 0x103ff),
+    (0x1049e, 0x1049f),
+    (0x104aa, 0x104af),
+    (0x104d4, 0x104d7),
+    (0x104fc, 0x104ff),
+    (0x10528, 0x1052f),
+    (0x10564, 0x1056e),
+    (0x10570, 0x105ff),
+    (0x10737, 0x1073f),
+    (0x10756, 0x1075f),
+    (0x10768, 0x107ff),
+    (0x10806, 0x10807),
+    (0x10809, 0x10809),
+    (0x10836, 0x10836),
+    (0x10839, 0x1083b),
+    (0x1083d, 0x1083e),
+    (0x10856, 0x10856),
+    (0x1089f, 0x108a6),
+    (0x108b0, 0x108df),
+    (0x108f3, 0x108f3),
+    (0x108f6, 0x108fa),
+    (0x1091c, 0x1091e),
+    (0x1093a, 0x1093e),
+    (0x10940, 0x1097f),
+    (0x109b8, 0x109bb),
+    (0x109d0, 0x109d1),
+    (0x10a04, 0x10a04),
+    (0x10a07, 0x10a0b),
+    (0x10a14, 0x10a14),
+    (0x10a18, 0x10a18),
+    (0x10a36, 0x10a37),
+    (0x10a3b, 0x10a3e),
+    (0x10a49, 0x10a4f),
+    (0x10a59, 0x10a5f),
+    (0x10aa0, 0x10abf),
+    (0x10ae7, 0x10aea),
+    (0x10af7, 0x10aff),
+    (0x10b36, 0x10b38),
+    (0x10b56, 0x10b57),
+    (0x10b73, 0x10b77),
+    (0x10b92, 0x10b98),
+    (0x10b9d, 0x10ba8),
+    (0x10bb0, 0x10bff),
+    (0x10c49, 0x10c7f),
+    (0x10cb3, 0x10cbf),
+    (0x10cf3, 0x10cf9),
+    (0x10d28, 0x10d2f),
+    (0x10d3a, 0x10d6d),
+    (0x10d6f, 0x10d8d),
+    (0x10d90, 0x10e5f),
+    (0x10e7f, 0x10e7f),
+    (0x10eaa, 0x10eaa),
+    (0x10eae, 0x10eaf),
+    (0x10eb2, 0x10ecf),
+    (0x10ed9, 0x10eff),
+    (0x10f28, 0x10f2f),
+    (0x10f5a, 0x10f85),
+    (0x10f8a, 0x10faf),
+    (0x10fcc, 0x10fdf),
+    (0x10ff7, 0x10fff),
+    (0x1104e, 0x11051),
+    (0x11070, 0x1107e),
+    (0x110c2, 0x110cc),
+    (0x110ce, 0x110cf),
+    (0x110e9, 0x110ef),
+    (0x110fa, 0x110ff),
+    (0x11135, 0x11135),
+    (0x11148, 0x1114f),
+    (0x11177, 0x1117f),
+    (0x111e0, 0x111e0),
+    (0x111f5, 0x111ff),
+    (0x11212, 0x11212),
+    (0x1123f, 0x1127f),
+    (0x11287, 0x11287),
+    (0x11289, 0x11289),
+    (0x1128e, 0x1128e),
+    (0x1129e, 0x1129e),
+    (0x112aa, 0x112af),
+    (0x112eb, 0x112ef),
+    (0x112fa, 0x112ff),
+    (0x11304, 0x11304),
+    (0x1130d, 0x1130e),
+    (0x11311, 0x11312),
+    (0x11329, 0x11329),
+    (0x11331, 0x11331),
+    (0x11334, 0x11334),
+    (0x1133a, 0x1133a),
+    (0x11345, 0x11346),
+    (0x11349, 0x1134a),
+    (0x1134e, 0x1134f),
+    (0x11351, 0x11356),
+    (0x11358, 0x1135c),
+    (0x11364, 0x11365),
+    (0x1136d, 0x1136f),
+    (0x11375, 0x113d3),
+    (0x113d6, 0x113d6),
+    (0x113d9, 0x113ff),
+    (0x1145c, 0x1145c),
+    (0x11462, 0x1147f),
+    (0x114c8, 0x114cf),
+    (0x114da, 0x1157f),
+    (0x115b6, 0x115b7),
+    (0x115de, 0x115ff),
+    (0x11645, 0x1164f),
+    (0x1165a, 0x1165f),
+    (0x1166d, 0x1167f),
+    (0x116ba, 0x116bf),
+    (0x116ca, 0x116ff),
+    (0x1171b, 0x1171c),
+    (0x1172c, 0x1172f),
+    (0x11740, 0x117ff),
+    (0x1183c, 0x1189f),
+    (0x118f3, 0x118fe),
+    (0x11907, 0x11908),
+    (0x1190a, 0x1190b),
+    (0x11914, 0x11914),
+    (0x11917, 0x11917),
+    (0x11936, 0x11936),
+    (0x11939, 0x1193a),
+    (0x11947, 0x1194f),
+    (0x1195a, 0x1199f),
+    (0x119a8, 0x119a9),
+    (0x119d8, 0x119d9),
+    (0x119e5, 0x119ff),
+    (0x11a48, 0x11a4f),
+    (0x11aa3, 0x11abf),
+    (0x11af9, 0x11aff),
+    (0x11b0a, 0x11be0),
+    (0x11be2, 0x11bff),
+    (0x11c09, 0x11c09),
+    (0x11c37, 0x11c37),
+    (0x11c46, 0x11c4f),
+    (0x11c6d, 0x11c6f),
+    (0x11c90, 0x11c91),
+    (0x11ca8, 0x11ca8),
+    (0x11cb7, 0x11cff),
+    (0x11d07, 0x11d07),
+    (0x11d0a, 0x11d0a),
+    (0x11d37, 0x11d39),
+    (0x11d3b, 0x11d3b),
+    (0x11d3e, 0x11d3e),
+    (0x11d48, 0x11d4f),
+    (0x11d5a, 0x11d5f),
+    (0x11d66, 0x11d66),
+    (0x11d69, 0x11d69),
+    (0x11d8f, 0x11d8f),
+    (0x11d92, 0x11d92),
+    (0x11d99, 0x11d9f),
+    (0x11daa, 0x11edf),
+    (0x11ef9, 0x11f42),
+    (0x11f50, 0x11faf),
+    (0x11fb1, 0x11fbf),
+    (0x11ff2, 0x11ffe),
+    (0x1239a, 0x123ff),
+    (0x1246f, 0x1246f),
+    (0x12475, 0x1247f),
+    (0x12544, 0x12ff0),
+    (0x12ff3, 0x12fff),
+    (0x1342f, 0x1342f),
+    (0x13440, 0x143ff),
+    (0x14647, 0x167ff),
+    (0x16a39, 0x16a3f),
+    (0x16a5f, 0x16a5f),
+    (0x16a6a, 0x16a6d),
+    (0x16a70, 0x16acf),
+    (0x16aee, 0x16aef),
+    (0x16af6, 0x16aff),
+    (0x16b46, 0x16b4f),
+    (0x16b5a, 0x16b5a),
+    (0x16b62, 0x16b62),
+    (0x16b78, 0x16b7c),
+    (0x16b90, 0x16d6c),
+    (0x16d70, 0x16e3f),
+    (0x16e9b, 0x16eff),
+    (0x16f4b, 0x16f4e),
+    (0x16f88, 0x16f8e),
+    (0x16fa0, 0x16fdf),
+    (0x16fe5, 0x16fef),
+    (0x16ff2, 0x16fff),
+    (0x187f8, 0x187ff),
+    (0x18cd6, 0x18cff),
+    (0x18d09, 0x1afff),
+    (0x1b11f, 0x1b14f),
+    (0x1b153, 0x1b163),
+    (0x1b168, 0x1b16f),
+    (0x1b2fc, 0x1bbff),
+    (0x1bc6b, 0x1bc6f),
+    (0x1bc7d, 0x1bc7f),
+    (0x1bc89, 0x1bc8f),
+    (0x1bc9a, 0x1bc9b),
+    (0x1bca4, 0x1cbff),
+    (0x1ccf0, 0x1ccf9),
+    (0x1ccfd, 0x1ccff),
+    (0x1ceb4, 0x1ceb9),
+    (0x1ced1, 0x1cedf),
+    (0x1cef1, 0x1cf4f),
+    (0x1cfc4, 0x1cfff),
+    (0x1d0f6, 0x1d0ff),
+    (0x1d127, 0x1d128),
+    (0x1d1eb, 0x1d1ff),
+    (0x1d246, 0x1d2df),
+    (0x1d2f4, 0x1d2ff),
+    (0x1d357, 0x1d35f),
+    (0x1d379, 0x1d3ff),
+    (0x1d455, 0x1d455),
+    (0x1d49d, 0x1d49d),
+    (0x1d4a0, 0x1d4a1),
+    (0x1d4a3, 0x1d4a4),
+    (0x1d4a7, 0x1d4a8),
+    (0x1d4ad, 0x1d4ad),
+    (0x1d4ba, 0x1d4ba),
+    (0x1d4bc, 0x1d4bc),
+    (0x1d4c4, 0x1d4c4),
+    (0x1d506, 0x1d506),
+    (0x1d50b, 0x1d50c),
+    (0x1d515, 0x1d515),
+    (0x1d51d, 0x1d51d),
+    (0x1d53a, 0x1d53a),
+    (0x1d53f, 0x1d53f),
+    (0x1d545, 0x1d545),
+    (0x1d547, 0x1d549),
+    (0x1d551, 0x1d551),
+    (0x1d6a6, 0x1d6a7),
+    (0x1d7cc, 0x1d7cd),
+    (0x1da8c, 0x1da9a),
+    (0x1daa0, 0x1daa0),
+    (0x1dab0, 0x1dfff),
+    (0x1e007, 0x1e007),
+    (0x1e019, 0x1e01a),
+    (0x1e022, 0x1e022),
+    (0x1e025, 0x1e025),
+    (0x1e02b, 0x1e0ff),
+    (0x1e12d, 0x1e12f),
+    (0x1e13e, 0x1e13f),
+    (0x1e14a, 0x1e14d),
+    (0x1e150, 0x1e2bf),
+    (0x1e2fa, 0x1e2fe),
+    (0x1e300, 0x1e5fe),
+    (0x1e600, 0x1e7ff),
+    (0x1e8c5, 0x1e8c6),
+    (0x1e8d7, 0x1e8ff),
+    (0x1e94c, 0x1e94f),
+    (0x1e95a, 0x1e95d),
+    (0x1e960, 0x1ec70),
+    (0x1ecb5, 0x1ed00),
+    (0x1ed3e, 0x1edff),
+    (0x1ee04, 0x1ee04),
+    (0x1ee20, 0x1ee20),
+    (0x1ee23, 0x1ee23),
+    (0x1ee25, 0x1ee26),
+    (0x1ee28, 0x1ee28),
+    (0x1ee33, 0x1ee33),
+    (0x1ee38, 0x1ee38),
+    (0x1ee3a, 0x1ee3a),
+    (0x1ee3c, 0x1ee41),
+    (0x1ee43, 0x1ee46),
+    (0x1ee48, 0x1ee48),
+    (0x1ee4a, 0x1ee4a),
+    (0x1ee4c, 0x1ee4c),
+    (0x1ee50, 0x1ee50),
+    (0x1ee53, 0x1ee53),
+    (0x1ee55, 0x1ee56),
+    (0x1ee58, 0x1ee58),
+    (0x1ee5a, 0x1ee5a),
+    (0x1ee5c, 0x1ee5c),
+    (0x1ee5e, 0x1ee5e),
+    (0x1ee60, 0x1ee60),
+    (0x1ee63, 0x1ee63),
+    (0x1ee65, 0x1ee66),
+    (0x1ee6b, 0x1ee6b),
+    (0x1ee73, 0x1ee73),
+    (0x1ee78, 0x1ee78),
+    (0x1ee7d, 0x1ee7d),
+    (0x1ee7f, 0x1ee7f),
+    (0x1ee8a, 0x1ee8a),
+    (0x1ee9c, 0x1eea0),
+    (0x1eea4, 0x1eea4),
+    (0x1eeaa, 0x1eeaa),
+    (0x1eebc, 0x1eeef),
+    (0x1eef2, 0x1efff),
+    (0x1f02c, 0x1f02f),
+    (0x1f094, 0x1f09f),
+    (0x1f0af, 0x1f0b0),
+    (0x1f0c0, 0x1f0c0),
+    (0x1f0d0, 0x1f0d0),
+    (0x1f0f6, 0x1f0ff),
+    (0x1f1ae, 0x1f1e5),
+    (0x1f203, 0x1f20f),
+    (0x1f23c, 0x1f23f),
+    (0x1f249, 0x1f24f),
+    (0x1f252, 0x1f25f),
+    (0x1f266, 0x1f2ff),
+    (0x1f6d9, 0x1f6db),
+    (0x1f6ed, 0x1f6ef),
+    (0x1f6fd, 0x1f6ff),
+    (0x1f7da, 0x1f7df),
+    (0x1f7ec, 0x1f7ef),
+    (0x1f7f1, 0x1f7ff),
+    (0x1f80c, 0x1f80f),
+    (0x1f848, 0x1f84f),
+    (0x1f85a, 0x1f85f),
+    (0x1f888, 0x1f88f),
+    (0x1f8ae, 0x1f8af),
+    (0x1f8bc, 0x1f8bf),
+    (0x1f8c2, 0x1f8cf),
+    (0x1f8d9, 0x1f8ff),
+    (0x1fa58, 0x1fa5f),
+    (0x1fa6e, 0x1fa6f),
+    (0x1fa7d, 0x1fa7f),
+    (0x1fa8b, 0x1fa8d),
+    (0x1fac7, 0x1fac7),
+    (0x1fac9, 0x1facc),
+    (0x1fadd, 0x1fade),
+    (0x1faeb, 0x1faee),
+    (0x1faf9, 0x1faff),
+    (0x1fb93, 0x1fb93),
+    (0x1fbfb, 0x1ffff),
+    (0x2a6de, 0x2a6ff),
+    (0x2b735, 0x2b73f),
+    (0x2b81e, 0x2b81f),
+    (0x2cea2, 0x2ceaf),
+    (0x2ebe1, 0x2f7ff),
+    (0x2fa1e, 0x2ffff),
+    (0x3134b, 0xe0000),
+    (0xe0002, 0xe001f),
+    (0xe0080, 0xe00ff),
+    (0xe01f0, 0xeffff),
+    (0xffffe, 0xfffff),
+    (0x10fffe, 0x10ffff),
+];
+// END GENERATED UNICODE GUARD
+
+pub(super) fn version_dependent(c: char) -> bool {
+    if c.is_ascii() {
+        return false;
+    }
+    let c = u32::from(c);
+    let at = VERSION_DEPENDENT.partition_point(|&(_, end)| end < c);
+    VERSION_DEPENDENT
+        .get(at)
+        .is_some_and(|&(start, _)| start <= c)
+}
+
+fn validate_unicode(text: &str, file: &str, mode: Lines) -> Result<(), String> {
+    for (line, text) in lines(text, mode).enumerate() {
+        if text.chars().any(version_dependent) {
+            return Err(format!(
+                "{}:{}: Unicode version-dependent text",
+                file.escape_debug(),
+                line + 1
+            ));
+        }
+    }
+    Ok(())
+}
+
 const USAGE: &str = "usage: og dev scan personal-data --root DIR --allow TEXT --skip TEXT [--patterns FILE] [--cached] [--] [FILE...]\n";
 
 /// This file's own path: it holds every allowed text, so all of them apply.
@@ -227,6 +953,7 @@ fn parse(args: &[String]) -> Result<Args, String> {
     }
     let root = root.ok_or("--root is required")?;
     let allow_text = allow.ok_or("--allow is required")?;
+    validate_unicode(&allow_text, "ALLOW", Lines::ExceptionTable)?;
     let allow = lines(&allow_text, Lines::ExceptionTable)
         .filter(|l| !py_strip(l).is_empty())
         .map(|l| {
@@ -236,6 +963,7 @@ fn parse(args: &[String]) -> Result<Args, String> {
         })
         .collect();
     let skip_text = skip.ok_or("--skip is required")?;
+    validate_unicode(&skip_text, "SKIP", Lines::ExceptionTable)?;
     let skip = lines(&skip_text, Lines::ExceptionTable)
         .filter_map(|l| {
             pycompat::text::split(l, None, None)
@@ -256,6 +984,7 @@ fn parse(args: &[String]) -> Result<Args, String> {
 /// The user's own patterns, one per line; `#` lines and blank lines skipped.
 fn own_rules(path: &str) -> Result<Vec<Check>, String> {
     let text = std::fs::read_to_string(path).map_err(|e| format!("cannot read {path}: {e}"))?;
+    validate_unicode(&text, path, Lines::TextFile)?;
     let mut out = Vec::new();
     for (line, l) in lines(&text, Lines::TextFile).enumerate() {
         let p = py_strip(l);
@@ -330,6 +1059,32 @@ fn git_files(root: &Path) -> Result<Vec<PathBuf>, String> {
         .collect::<Result<Vec<_>, String>>()
 }
 
+/// The index owns symlink identity in cached mode, even if the working copy
+/// is absent, replaced by a regular file, or has a different target.
+fn index_symlinks(root: &Path) -> Result<HashSet<String>, String> {
+    let output = Command::new("git")
+        .arg("-C")
+        .arg(root)
+        .args(["ls-files", "--stage", "-z"])
+        .output()
+        .map_err(|_| "cannot read Git index")?;
+    if !output.status.success() {
+        return Err("cannot read Git index".into());
+    }
+    let mut links = HashSet::new();
+    for entry in output.stdout.split(|&b| b == 0).filter(|e| !e.is_empty()) {
+        let tab = entry
+            .iter()
+            .position(|&b| b == b'\t')
+            .ok_or("invalid Git index entry")?;
+        let name = std::str::from_utf8(&entry[tab + 1..]).map_err(|_| "path is not valid UTF-8")?;
+        if entry.starts_with(b"120000 ") {
+            links.insert(name.to_owned());
+        }
+    }
+    Ok(links)
+}
+
 /// The staged blob of each path (relative to `root`), from one
 /// `git cat-file --batch`. A path with no blob in the index is absent.
 fn staged(root: &Path, rels: &[String]) -> Result<HashMap<String, Vec<u8>>, String> {
@@ -456,13 +1211,36 @@ fn run(a: &Args, out: &mut dyn Write) -> Result<bool, String> {
         let _ = writeln!(out, "FAIL: no file to scan");
         return Ok(false);
     }
-    let todo: Vec<(&PathBuf, String)> = files
+    let mut todo: Vec<(&PathBuf, String)> = files
         .iter()
         .map(|f| relative(f, &root).map(|rel| (f, rel)))
-        .collect::<Result<Vec<_>, _>>()?
-        .into_iter()
-        .filter(|(_, rel)| !a.skip.iter().any(|g| fnmatch(rel, g)))
-        .collect();
+        .collect::<Result<Vec<_>, _>>()?;
+    // Validate every selected target before SKIP, and before following any
+    // symlink for a read. Cached scans validate the target stored in Git.
+    if a.cached {
+        let links = index_symlinks(&root)?;
+        let rels: Vec<_> = todo
+            .iter()
+            .filter(|(_, r)| links.contains(r))
+            .map(|(_, r)| r.clone())
+            .collect();
+        for target in staged(&root, &rels)?.values() {
+            std::str::from_utf8(target).map_err(|_| "path is not valid UTF-8")?;
+        }
+    } else {
+        for (path, _) in &todo {
+            match std::fs::read_link(path) {
+                Ok(target) => {
+                    utf8_path(&target)?;
+                }
+                Err(e)
+                    if e.kind() == std::io::ErrorKind::InvalidInput
+                        || e.kind() == std::io::ErrorKind::NotFound => {}
+                Err(_) => return Err("cannot validate symlink target".into()),
+            }
+        }
+    }
+    todo.retain(|(_, rel)| !a.skip.iter().any(|g| fnmatch(rel, g)));
     let blobs = if a.cached {
         staged(
             &root,
@@ -495,6 +1273,7 @@ fn run(a: &Args, out: &mut dyn Write) -> Result<bool, String> {
         if data[..data.len().min(BINARY_PROBE)].contains(&0) {
             continue;
         }
+        validate_unicode(&String::from_utf8_lossy(&data), rel, Lines::Blob)?;
         scanned += 1;
         let texts: Vec<&str> = a
             .allow
@@ -1454,5 +2233,156 @@ mod tests {
             failures.is_empty(),
             "raw symlink target must stop scan: {failures:?}"
         );
+        let mut args = f.args(&["alias.md", "clean.md"]);
+        let skip = args.iter().position(|a| a == "--skip").unwrap() + 1;
+        args[skip] = "alias.md".into();
+        assert_eq!(cli(&args, &mut Vec::new(), &mut Vec::new()), 2);
+        // The cached mode must use the index mode and target, even when the
+        // working copy is now a regular file and SKIP excludes the alias.
+        std::fs::remove_file(f.0.join("alias.md")).unwrap();
+        std::fs::write(f.0.join("alias.md"), "clean").unwrap();
+        args.push("--cached".into());
+        let (mut out, mut err) = (Vec::new(), Vec::new());
+        assert_eq!(cli(&args, &mut out, &mut err), 2);
+        assert!(out.is_empty());
+        assert_eq!(err, b"ERROR: path is not valid UTF-8\n");
+    }
+    #[test]
+    fn round4_unicode_guard_inputs_and_emoji() {
+        let f = Fixture::new("r4-inputs");
+        let text = "safe\n\u{1e6c0}PRIVATE_MARKER";
+        std::fs::write(f.0.join("own.md"), text).unwrap();
+        // Contents fail before matching or applying allowed spans.
+        let mut args = f.args(&["own.md"]);
+        let (mut out, mut err) = (Vec::new(), Vec::new());
+        assert_eq!(cli(&args, &mut out, &mut err), 2);
+        assert_eq!(err, b"ERROR: own.md:2: Unicode version-dependent text\n");
+        assert!(out.is_empty());
+        for (option, diagnostic) in [("--allow", "ALLOW:2"), ("--skip", "SKIP:2")] {
+            let index = args.iter().position(|a| a == option).unwrap() + 1;
+            args[index] = "\n\u{105c0}PRIVATE_MARKER".into();
+            let (mut out, mut err) = (Vec::new(), Vec::new());
+            assert_eq!(cli(&args, &mut out, &mut err), 2);
+            assert!(out.is_empty());
+            let err = String::from_utf8(err).unwrap();
+            assert!(err.contains(diagnostic));
+            assert!(!err.contains("PRIVATE_MARKER"));
+            args[index].clear();
+        }
+        for pattern in [
+            "\n\u{1e6c0}PRIVATE_MARKER",
+            r"\U0001e6c0",
+            r"[\U0001e6c0]",
+            r"(?i)\U00016ea0",
+        ] {
+            std::fs::write(f.0.join("patterns"), pattern).unwrap();
+            let mut a = args.clone();
+            a.extend([
+                "--patterns".into(),
+                f.0.join("patterns").display().to_string(),
+            ]);
+            let (mut out, mut err) = (Vec::new(), Vec::new());
+            assert_eq!(cli(&a, &mut out, &mut err), 2);
+            assert!(out.is_empty());
+            assert!(!String::from_utf8_lossy(&err).contains("PRIVATE_MARKER"));
+        }
+        // All future unassigned scalars fail, including a currently reserved
+        // point in an old block. Stable letters and newer plain symbols pass.
+        assert!(version_dependent('\u{378}'));
+        assert!(!version_dependent('é'));
+        assert!(!version_dependent('\u{1fae8}')); // shaking face, Unicode 15
+        std::fs::write(f.0.join("own.md"), p("\u{1fae8}rs555~ AG")).unwrap();
+        let (mut out, mut err) = (Vec::new(), Vec::new());
+        assert_eq!(cli(&args, &mut out, &mut err), 1);
+        assert_eq!(out, b"FAIL rsid      own.md:1\nscanned 1 text files\n");
+        assert!(err.is_empty());
+        // ASCII SKIP globs can exempt files containing a newer script.
+        let index = args.iter().position(|a| a == "--skip").unwrap() + 1;
+        args[index] = "own.md".into();
+        std::fs::write(f.0.join("own.md"), text).unwrap();
+        std::fs::write(f.0.join("clean.md"), "clean").unwrap();
+        args.push(f.0.join("clean.md").display().to_string());
+        assert_eq!(cli(&args, &mut Vec::new(), &mut Vec::new()), 0);
+    }
+
+    #[test]
+    fn round4_guard_agrees_with_available_pythons() {
+        // Every available interpreter is checked, not just whichever python3
+        // happens to be first on PATH. Guard installs 3.12 and 3.15 explicitly.
+        let mut commands: Vec<String> = [
+            "python3",
+            "python3.9",
+            "python3.12",
+            "python3.14",
+            "python3.15",
+            "/usr/bin/python3",
+        ]
+        .iter()
+        .map(|s| (*s).into())
+        .collect();
+        if let Ok(extra) = std::env::var("PERSONAL_DATA_PYTHONS") {
+            commands.extend(extra.split(':').map(str::to_owned));
+        }
+        let ranges = VERSION_DEPENDENT
+            .iter()
+            .map(|(a, b)| format!("{a} {b}\n"))
+            .collect::<String>();
+        let mut baseline = None;
+        let mut versions = HashSet::new();
+        for command in commands {
+            let Ok(probe) = Command::new(&command).args(["-I", "-c", "import sys,unicodedata; print(sys.version.split()[0],unicodedata.unidata_version)"]).output() else { continue; };
+            if !probe.status.success() || !versions.insert(probe.stdout.clone()) {
+                continue;
+            }
+            let mut child = Command::new(command)
+                .args([
+                    "-I",
+                    "-c",
+                    r#"
+import sys,unicodedata
+ranges=[tuple(map(int,row.split())) for row in sys.stdin]
+i=0
+for c in range(0x110000):
+    if 0xd800 <= c <= 0xdfff: continue
+    while i < len(ranges) and ranges[i][1] < c: i+=1
+    if i < len(ranges) and ranges[i][0] <= c: continue
+    s=chr(c)
+    # Unicode 17 is the newest shipped table. No unassigned scalar may pass.
+    if unicodedata.unidata_version == '17.0.0': assert unicodedata.category(s) != 'Cn'
+    values=(int(s.isalnum() or s=='_'), int(s.isdecimal()), int(s.isspace()))
+    maps=','.join('.'.join(str(ord(x)) for x in m) for m in (s.lower(),s.upper(),s.casefold()))
+    print(str(c)+':'+''.join(map(str,values))+':'+maps)
+"#,
+                ])
+                .stdin(Stdio::piped())
+                .stdout(Stdio::piped())
+                .stderr(Stdio::piped())
+                .spawn()
+                .unwrap();
+            child
+                .stdin
+                .take()
+                .unwrap()
+                .write_all(ranges.as_bytes())
+                .unwrap();
+            let output = child.wait_with_output().unwrap();
+            assert!(output.status.success(), "Unicode oracle failed");
+            assert!(output.stderr.is_empty());
+            if let Some(ref first) = baseline {
+                assert!(
+                    first == &output.stdout,
+                    "stable Unicode signatures differ across available Pythons"
+                );
+            } else {
+                baseline = Some(output.stdout);
+            }
+        }
+        assert!(!versions.is_empty(), "no Python oracle available");
+        for version in versions {
+            println!(
+                "Unicode guard checked Python {}",
+                String::from_utf8(version).unwrap().trim()
+            );
+        }
     }
 }
diff --git a/scripts/ci/check-personal-data.sh b/scripts/ci/check-personal-data.sh
index 09208035c..136c16fdf 100755
--- a/scripts/ci/check-personal-data.sh
+++ b/scripts/ci/check-personal-data.sh
@@ -56,7 +56,27 @@
 # syntax, invalid patterns and a matcher resource-limit error stop the scan
 # with exit 2 and a diagnostic that omits the pattern and scanned values.
 # A path with invalid UTF-8 also stops the scan before SKIP, path conversion
-# or staged-blob requests. File contents still use replacement decoding.
+# or staged-blob requests. Symlink targets are also checked before SKIP:
+# working-copy targets from readlink, staged targets from index mode 120000.
+# File contents still use replacement decoding.
+#
+# Unicode guard: UCD 13, 15, 16 and 17 disagree on newer script letters.
+# The scan stops with redacted exit 2 at file:line for version-dependent
+# text, custom patterns (including escaped literals), or ALLOW/SKIP rows.
+# ALLOW cannot exempt such text. Use an ASCII SKIP glob to exempt its file.
+# A letter from a script newer than Unicode 13 therefore stops the scan
+# until its file is skipped. Newer plain symbols and emoji still scan.
+#
+# The generated conservative set includes every scalar unassigned in UCD
+# 17; post-13 letters, marks, numbers, connectors, spaces and case mappings;
+# and older scalars whose word/digit/space membership or case maps change
+# in UCD 13/15/16/17, including both ends of changed case relations.
+# This adds one binary-search lookup per non-ASCII character (ASCII is
+# stable), with a fixed table and no per-file Unicode index or extra process.
+# Regenerate from SHA-256-pinned official data with the Rust generator:
+# tests/parity/gen/personal-unicode-generate.sh SCRATCH_DIR
+# Guard regenerates byte for byte and compares all available Python oracles,
+# explicitly installing 3.12 and 3.15. Match iteration still follows 3.14+.
 #
 # The scan is og dev scan personal-data (rust/crates/og-dev); bin/og runs
 # the build scripts/setup.sh --og puts in bin/.og for this machine, and OG
diff --git a/tests/parity/gen/personal-unicode-generate.sh b/tests/parity/gen/personal-unicode-generate.sh
new file mode 100755
index 000000000..140eb0ba8
--- /dev/null
+++ b/tests/parity/gen/personal-unicode-generate.sh
@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+# Rebuild the guard from SHA-256-pinned official UCD files. Network is only
+# used here, never in the generator binary or the personal-data scanner.
+set -euo pipefail
+root=$(cd "$(dirname "$0")/../../.." && pwd)
+work=${1:?usage: personal-unicode-generate.sh SCRATCH_DIR}
+mkdir -p "$work/ucd"
+while IFS=$'\t' read -r hash file; do
+  mkdir -p "$work/ucd/${file%/*}"
+  curl --fail --silent --show-error --retry 2 "https://www.unicode.org/Public/${file%/*}/ucd/${file##*/}" -o "$work/ucd/$file"
+  printf '%s  %s\n' "$hash" "$work/ucd/$file" | shasum -a 256 --check
+ done < "$root/tests/parity/gen/personal-unicode-sources.tsv"
+rustc --edition=2024 -D warnings "$root/tests/parity/gen/personal-unicode-generator.rs" -o "$work/generator"
+"$work/generator" "$work/ucd" "$work/table.rs"
+awk '/^\/\/ BEGIN GENERATED UNICODE GUARD$/ { copy=1; next }
+     /^\/\/ END GENERATED UNICODE GUARD$/ { copy=0 }
+     copy { print }' "$root/rust/crates/og-dev/src/personal_data.rs" > "$work/checked-in.rs"
+cmp "$work/table.rs" "$work/checked-in.rs"
+echo 'Unicode guard regenerates byte for byte.'
diff --git a/tests/parity/gen/personal-unicode-generator.rs b/tests/parity/gen/personal-unicode-generator.rs
new file mode 100644
index 000000000..c29dcce3b
--- /dev/null
+++ b/tests/parity/gen/personal-unicode-generator.rs
@@ -0,0 +1,137 @@
+//! Generate the scanner's conservative Unicode-version guard from official UCD
+//! files. Run personal-unicode-generate.sh, which checks each source's SHA-256.
+//! No network or Python is used by this generator or by the scanner.
+use std::{env, fs, path::Path};
+
+#[derive(Clone, Default, PartialEq, Eq)]
+struct Properties {
+    category: String,
+    space: bool,
+    case: [String; 4], // simple upper/lower/title mappings and simple case fold
+}
+impl Properties {
+    fn assigned(&self) -> bool {
+        !self.category.is_empty()
+    }
+    fn word(&self) -> bool {
+        self.category.starts_with(['L', 'N'])
+    }
+    fn digit(&self) -> bool {
+        self.category == "Nd"
+    }
+    fn sensitive(&self) -> bool {
+        self.category.starts_with(['L', 'M', 'N'])
+            || self.category == "Pc"
+            || self.space
+            || self.case.iter().any(|s| !s.is_empty())
+    }
+    fn signature(&self) -> (bool, bool, bool, &[String; 4]) {
+        (self.word(), self.digit(), self.space, &self.case)
+    }
+}
+fn read(dir: &Path, version: &str) -> Vec<Properties> {
+    let mut table = vec![Properties::default(); 0x110000];
+    let data = fs::read_to_string(dir.join(version).join("UnicodeData.txt")).unwrap();
+    let mut start = None;
+    for line in data.lines() {
+        let f: Vec<_> = line.split(';').collect();
+        assert_eq!(f.len(), 15);
+        let c = usize::from_str_radix(f[0], 16).unwrap();
+        if f[1].ends_with(", First>") {
+            assert!(start.replace(c).is_none());
+            continue;
+        }
+        let a = if f[1].ends_with(", Last>") {
+            start.take().unwrap()
+        } else {
+            c
+        };
+        for p in &mut table[a..=c] {
+            assert!(!p.assigned());
+            *p = Properties {
+                category: f[2].into(),
+                space: f[2] == "Zs" || matches!(f[4], "WS" | "B" | "S"),
+                case: [f[12].into(), f[13].into(), f[14].into(), String::new()],
+            };
+        }
+    }
+    assert!(start.is_none());
+    let folding = fs::read_to_string(dir.join(version).join("CaseFolding.txt")).unwrap();
+    assert!(folding.contains(&format!("CaseFolding-{version}.txt")));
+    for line in folding.lines() {
+        let line = line.split('#').next().unwrap().trim();
+        if line.is_empty() {
+            continue;
+        }
+        let f: Vec<_> = line.split(';').map(str::trim).collect();
+        if matches!(f[1], "C" | "S") {
+            let c = usize::from_str_radix(f[0], 16).unwrap();
+            assert!(table[c].assigned());
+            table[c].case[3] = f[2].into();
+        }
+    }
+    table
+}
+fn main() {
+    let args: Vec<_> = env::args().collect();
+    assert_eq!(args.len(), 3, "usage: generator UCD_DIR OUTPUT");
+    let versions = ["13.0.0", "15.0.0", "16.0.0", "17.0.0"];
+    let tables: Vec<_> = versions
+        .iter()
+        .map(|v| read(Path::new(&args[1]), v))
+        .collect();
+    let mut refused = vec![false; 0x110000];
+    for (c, bad) in refused.iter_mut().enumerate() {
+        if char::from_u32(c as u32).is_none() {
+            continue;
+        }
+        let old = &tables[0][c];
+        *bad = !tables[3][c].assigned()
+            || (!old.assigned() && tables.iter().any(|t| t[c].sensitive()))
+            || (old.assigned() && tables.iter().any(|t| t[c].signature() != old.signature()));
+    }
+    // Include both ends of a changed case relation. This also guards a stable
+    // letter which acquires a newly assigned case partner in a later version.
+    loop {
+        let before = refused.clone();
+        for table in &tables {
+            for (c, p) in table.iter().enumerate() {
+                for mapping in &p.case {
+                    if mapping.is_empty() {
+                        continue;
+                    }
+                    let target = usize::from_str_radix(mapping, 16).unwrap();
+                    if refused[c] || refused[target] {
+                        refused[c] = true;
+                        refused[target] = true;
+                    }
+                }
+            }
+        }
+        if refused == before {
+            break;
+        }
+    }
+    let mut out = String::from(
+        "// Generated by personal-unicode-generator.rs; do not edit.\n// UCD 13.0.0, 15.0.0, 16.0.0, 17.0.0; sources pinned in personal-unicode-sources.tsv.\nconst VERSION_DEPENDENT: &[(u32, u32)] = &[\n",
+    );
+    let mut c = 0;
+    while c < refused.len() {
+        if !refused[c] {
+            c += 1;
+            continue;
+        }
+        let start = c;
+        while c + 1 < refused.len() && refused[c + 1] {
+            c += 1;
+        }
+        out.push_str(&format!("    (0x{start:x}, 0x{c:x}),\n"));
+        c += 1;
+    }
+    out.push_str("];\n");
+    fs::write(&args[2], out).unwrap();
+    println!(
+        "generated guard for {} Unicode scalars",
+        refused.iter().filter(|&&x| x).count()
+    );
+}
diff --git a/tests/parity/gen/personal-unicode-sources.tsv b/tests/parity/gen/personal-unicode-sources.tsv
new file mode 100644
index 000000000..1656898ad
--- /dev/null
+++ b/tests/parity/gen/personal-unicode-sources.tsv
@@ -0,0 +1,8 @@
+bdbffbbfc8ad4d3a6d01b5891510458f3d36f7170422af4ea2bed3211a73e8bb	13.0.0/UnicodeData.txt
+99d231d7c91688bbe8ca8ccebcc2f46b5b222f844babe4827295bae11e2abe5f	13.0.0/CaseFolding.txt
+806e9aed65037197f1ec85e12be6e8cd870fc5608b4de0fffd990f689f376a73	15.0.0/UnicodeData.txt
+cdd49e55eae3bbf1f0a3f6580c974a0263cb86a6a08daa10fbf705b4808a56f7	15.0.0/CaseFolding.txt
+ff58e5823bd095166564a006e47d111130813dcf8bf234ef79fa51a870edb48f	16.0.0/UnicodeData.txt
+6f1f9c588eb4a5c718d9e8f93b782685e5c7fec872cf05e8e6878053599e09bb	16.0.0/CaseFolding.txt
+2e1efc1dcb59c575eedf5ccae60f95229f706ee6d031835247d843c11d96470c	17.0.0/UnicodeData.txt
+ff8d8fefbf123574205085d6714c36149eb946d717a0c585c27f0f4ef58c4183	17.0.0/CaseFolding.txt

From 12ba3afb5f3432af2cb66db9945ed91ebe8f6fb0 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 17:52:23 +0100
Subject: [PATCH 56/76] test(dev): reproduce evidence and Renovate false
 successes

---
 rust/crates/og-dev/src/evidence.rs | 133 +++++++++++++++++++++++++++++
 rust/crates/og-dev/src/renovate.rs |  46 +++++++++-
 2 files changed, 178 insertions(+), 1 deletion(-)

diff --git a/rust/crates/og-dev/src/evidence.rs b/rust/crates/og-dev/src/evidence.rs
index 84529a8ef..0135488fd 100644
--- a/rust/crates/og-dev/src/evidence.rs
+++ b/rust/crates/og-dev/src/evidence.rs
@@ -390,6 +390,139 @@ mod tests {
         );
     }
 
+
+    struct Case {
+        dir: std::path::PathBuf,
+        kind: &'static str,
+    }
+
+    impl Case {
+        fn new(kind: &'static str, label: &str) -> Self {
+            let dir = std::env::temp_dir().join(format!(
+                "og-evidence-{kind}-{label}-{}-{:?}", std::process::id(), std::thread::current().id()
+            ));
+            let _ = fs::remove_dir_all(&dir);
+            fs::create_dir_all(&dir).unwrap();
+            let src = Path::new(env!("CARGO_MANIFEST_DIR"))
+                .join("../../../tests/parity/inputs").join(format!("dev-evidence-{kind}"));
+            for e in fs::read_dir(src).unwrap() {
+                let e = e.unwrap();
+                fs::copy(e.path(), dir.join(e.file_name())).unwrap();
+            }
+            Self { dir, kind }
+        }
+        fn text(&self, name: &str) -> Vec<u8> {
+            use std::io::Read;
+            let mut bytes = Vec::new();
+            open(self.dir.join(name).to_str().unwrap()).unwrap().read_to_end(&mut bytes).unwrap();
+            bytes
+        }
+        fn put(&self, name: &str, bytes: &[u8]) {
+            if name.ends_with(".gz") {
+                let mut gz = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+                gz.write_all(bytes).unwrap();
+                fs::write(self.dir.join(name), gz.finish().unwrap()).unwrap();
+            } else {
+                fs::write(self.dir.join(name), bytes).unwrap();
+            }
+        }
+        fn run(&self) -> Result<(), String> {
+            let p = |n: &str| self.dir.join(n).to_str().unwrap().to_owned();
+            if self.kind == "clashes" {
+                clashes(&p("raw.vcf.gz"), &p("split.vcf.gz"), self.dir.to_str().unwrap(), &p("out"))
+            } else {
+                hg002_gvcf(&p("truth.vcf.gz"), &p("truth.bed"), &p("ref.fasta"), &p("sites.tsv"), &p("out")).map(|_| ())
+            }
+        }
+        fn fails_without_publication(&self) {
+            fs::write(self.dir.join("out"), b"PREVIOUS OUTPUT\n").unwrap();
+            assert!(self.run().is_err(), "{} must fail", self.dir.display());
+            assert_eq!(fs::read(self.dir.join("out")).unwrap(), b"PREVIOUS OUTPUT\n");
+            let leftovers: Vec<_> = fs::read_dir(&self.dir).unwrap().filter_map(|e| {
+                let name = e.unwrap().file_name();
+                name.to_str().filter(|n| n.starts_with(".out.")).map(str::to_owned)
+            }).collect();
+            assert!(leftovers.is_empty(), "{leftovers:?}");
+        }
+    }
+    impl Drop for Case {
+        fn drop(&mut self) { fs::remove_dir_all(&self.dir).unwrap(); }
+    }
+
+    #[test]
+    fn selected_truncated_clash_records_fail() {
+        for name in ["raw.vcf.gz", "split.vcf.gz", "chrA.tsv.gz"] {
+            let c = Case::new("clashes", name);
+            c.put(name, if name == "chrA.tsv.gz" { b"chrA" } else { b"chrA\t3\n" });
+            c.fails_without_publication();
+        }
+    }
+
+    #[test]
+    fn missing_panel_header_and_blank_bed_fail() {
+        for name in ["sites.tsv", "truth.bed"] {
+            let c = Case::new("hg002-gvcf", name);
+            let bytes = if name == "sites.tsv" { vec![] } else { [c.text(name), b"\n".to_vec()].concat() };
+            c.put(name, &bytes);
+            c.fails_without_publication();
+        }
+    }
+
+    #[test]
+    fn every_evidence_text_input_rejects_invalid_utf8() {
+        for (kind, names) in [
+            ("clashes", vec!["raw.vcf.gz", "split.vcf.gz", "chrA.tsv.gz"]),
+            ("hg002-gvcf", vec!["truth.vcf.gz", "truth.bed", "ref.fasta.fai", "sites.tsv"]),
+        ] {
+            for name in names {
+                let c = Case::new(kind, name);
+                // Invalid bytes in a header or filtered-out record must still fail.
+                let mut bytes = c.text(name);
+                bytes.extend_from_slice(b"#ignored\xff\n");
+                c.put(name, &bytes);
+                c.fails_without_publication();
+            }
+        }
+    }
+
+    #[test]
+    fn every_evidence_text_input_has_universal_newlines() {
+        for (kind, names) in [
+            ("clashes", vec!["raw.vcf.gz", "split.vcf.gz", "chrA.tsv.gz", "chrB.tsv.gz"]),
+            ("hg002-gvcf", vec!["truth.vcf.gz", "truth.bed", "ref.fasta.fai", "sites.tsv"]),
+        ] {
+            for name in names {
+                for ending in [b"\r".as_slice(), b"\r\n".as_slice()] {
+                    let c = Case::new(kind, &format!("{name}-{}", ending.len()));
+                    c.run().unwrap();
+                    let expected = fs::read(c.dir.join("out")).unwrap();
+                    let bytes = c.text(name).split(|b| *b == b'\n').collect::<Vec<_>>().join(ending);
+                    c.put(name, &bytes);
+                    c.run().unwrap();
+                    assert_eq!(fs::read(c.dir.join("out")).unwrap(), expected, "{kind}/{name}/{ending:?}");
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn failed_gvcf_inputs_preserve_existing_output() {
+        for name in ["truth.vcf.gz", "sites.tsv"] {
+            for fault in ["missing", "directory", "malformed", "truncated"] {
+                let c = Case::new("hg002-gvcf", &format!("{name}-{fault}"));
+                let path = c.dir.join(name);
+                match fault {
+                    "missing" => fs::remove_file(path).unwrap(),
+                    "directory" => { fs::remove_file(&path).unwrap(); fs::create_dir(path).unwrap(); }
+                    "malformed" => { let mut bytes = c.text(name); bytes.extend_from_slice(b"bad\n"); c.put(name, &bytes); }
+                    _ if name.ends_with(".gz") => { let mut bytes = fs::read(&path).unwrap(); bytes.truncate(bytes.len()-5); fs::write(path, bytes).unwrap(); }
+                    _ => c.put(name, b"header\nbad\n"),
+                }
+                c.fails_without_publication();
+            }
+        }
+    }
+
     #[test]
     fn spans_merge_and_answer_inside() {
         let m = merge(vec![(10, 12), (5, 6), (11, 15), (15, 16)]);
diff --git a/rust/crates/og-dev/src/renovate.rs b/rust/crates/og-dev/src/renovate.rs
index f3355c766..e282db2a3 100644
--- a/rust/crates/og-dev/src/renovate.rs
+++ b/rust/crates/og-dev/src/renovate.rs
@@ -62,6 +62,11 @@ struct Pins {
 
 /// Runs `og dev renovate-check ARGS`; returns the exit code.
 pub fn cli(args: &[String], out: &mut dyn Write, err: &mut dyn Write) -> u8 {
+    let summary = std::env::var_os("GITHUB_STEP_SUMMARY").filter(|p| !p.is_empty());
+    cli_with_summary(args, out, err, summary.as_deref().map(Path::new))
+}
+
+fn cli_with_summary(args: &[String], out: &mut dyn Write, err: &mut dyn Write, summary_path: Option<&Path>) -> u8 {
     let (mut log, mut pins, mut repo) = (None, PINS.to_owned(), ".".to_owned());
     let mut it = args.iter();
     while let Some(a) = it.next() {
@@ -125,7 +130,7 @@ pub fn cli(args: &[String], out: &mut dyn Write, err: &mut dyn Write) -> u8 {
     };
     let table = summary(&deps);
     let _ = writeln!(out, "{table}");
-    if let Some(path) = std::env::var_os("GITHUB_STEP_SUMMARY").filter(|p| !p.is_empty()) {
+    if let Some(path) = summary_path {
         let appended = fs::OpenOptions::new()
             .append(true)
             .create(true)
@@ -832,6 +837,45 @@ mod tests {
         let _ = fs::remove_dir_all(&d);
     }
 
+
+
+    #[test]
+    fn configured_summary_write_failure_fails_the_check() {
+        let d = planted("summary");
+        let args = vec![d.join("renovate.log").to_str().unwrap().to_owned(), "--repo".to_owned(), d.to_str().unwrap().to_owned()];
+        let (mut out, mut err) = (Vec::new(), Vec::new());
+        assert_eq!(cli_with_summary(&args, &mut out, &mut err, Some(&d)), 1);
+        assert!(!String::from_utf8_lossy(&out).contains("every check passed"));
+        fs::remove_dir_all(d).unwrap();
+    }
+
+    #[test]
+    fn malformed_log_shapes_and_text_fail() {
+        for (label, bad) in [
+            ("null-deps", r#"{"packageFile":"unused","deps":null}"#),
+            ("null-updates", r#"{"packageFile":"unused","deps":[{"updates":null}]}"#),
+            ("scalar-update", r#"{"packageFile":"unused","deps":[{"updates":[42]}]}"#),
+            ("scalar-dep", r#"{"packageFile":"unused","deps":[42]}"#),
+            ("scalar-file", r#"{"packageFile":[],"deps":[]}"#),
+        ] {
+            let d = planted(label);
+            let log = fs::read_to_string(d.join("renovate.log")).unwrap();
+            let log = log.replacen(r#""regex":["#, &format!(r#""regex":[{bad},"#), 1);
+            fs::write(d.join("renovate.log"), log).unwrap();
+            let (code, out) = run(&d);
+            assert_eq!(code, 1, "{label}: {out}");
+            fs::remove_dir_all(d).unwrap();
+        }
+        for (label, prefix) in [("utf8", b"\xff\n".as_slice()), ("array", b"[]\n".as_slice()), ("null", b"null\n".as_slice())] {
+            let d = planted(label);
+            let log = [prefix, &fs::read(d.join("renovate.log")).unwrap()].concat();
+            fs::write(d.join("renovate.log"), log).unwrap();
+            let (code, out) = run(&d);
+            assert_eq!(code, 1, "{label}: {out}");
+            fs::remove_dir_all(d).unwrap();
+        }
+    }
+
     #[test]
     fn a_log_without_the_record_fails() {
         let d = planted("nolog");

From a6d0b25db3cf8805dfbe597568dde7425d150fc5 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 18:00:42 +0100
Subject: [PATCH 57/76] fix(dev): reject malformed evidence and publish
 validated outputs atomically

---
 CHANGELOG.md                       |   3 +
 rust/crates/og-dev/src/evidence.rs | 257 ++++++++++++++++++++++++-----
 rust/crates/og-dev/src/fixture.rs  |  42 +++--
 rust/crates/og-dev/src/renovate.rs | 139 +++++++++++-----
 tests/smoke/vntyper.sh             |   6 +
 tests/smoke/vntyper_testdata.sh    |   2 +-
 6 files changed, 353 insertions(+), 96 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c35c774a7..9e22902bf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,9 @@ Each release's notes. From 1.0.0 on, a major or minor release has hand-written n
 
 ## Unreleased
 
+- `og dev evidence` now rejects invalid UTF-8, truncated selected records, blank BED rows and missing panel headers. It reads LF, CRLF and CR line endings alike, with a 16 MiB limit per record. Evidence and fixture files are published by rename after validation, so a failed run preserves existing outputs. `og dev renovate-check` rejects malformed log records and present fields of the wrong type, and fails if its configured step summary cannot be written. The PharmCAT trimmer consumes source genes as it trims them. The VNtyper downloader also accepts output paths that contain a newline.
+
+
 - The Python that CI and the fixtures ran outside the pipeline now runs in the Rust `og` binary. The public evidence workflow runs `og dev evidence clashes` and `og dev evidence hg002-gvcf` instead of two inline Python programs; the Renovate dry run checks what Renovate found with `og dev renovate-check`, whose list of non-image pins is now data in `scripts/ci/renovate-pins.tsv`; `og dev fixture comphet` writes the compound-het fixture of the e2e case `comphet-phasing-1-reads`, byte for byte; and `og dev fixture trim-pharmcat` trims a PharmCAT report for `tests/fixtures/pharmcat`. `tests/fixtures/comphet/make_fixture.py`, `tests/fixtures/pharmcat/trim_report.py` and `tests/smoke/vntyper_testdata.py` are gone: VNtyper's two test BAMs now come from `tests/smoke/vntyper_testdata.sh`, one HTTP range request per BAM with curl, checked by gzip against the archive's CRC-32 and size and then against the pinned sha256. On GIAB's HG002 benchmark VCF (4,048,342 records) with the chr20-22 reference, `og dev evidence hg002-gvcf` writes the same gVCF in 3.5 s and 97 MB instead of 11.8 s and 3.8 GB, because it keeps the spans the records cover instead of every covered position. No pipeline output changes. What changes on purpose:
   - `og dev evidence hg002-gvcf` skips a panel site past the end of its contig. The Python read the byte after the contig, and at the end of the file wrote a reference block with an empty REF.
   - `og dev renovate-check` stops with exit 2 when a pin's file is missing or its glob matches no file. The Python counted such a pin in no file, so it could never fail.
diff --git a/rust/crates/og-dev/src/evidence.rs b/rust/crates/og-dev/src/evidence.rs
index 0135488fd..3e95b2880 100644
--- a/rust/crates/og-dev/src/evidence.rs
+++ b/rust/crates/og-dev/src/evidence.rs
@@ -25,6 +25,8 @@ use std::fs::{self, File};
 use std::io::{BufRead, BufWriter, Write};
 use std::os::unix::fs::FileExt;
 use std::path::Path;
+use std::path::PathBuf;
+use std::sync::atomic::{AtomicU64, Ordering};
 
 const USAGE: &str = "usage: og dev evidence clashes RAW.vcf.gz SPLIT.vcf.gz DATA_DIR OUT.tsv\n       og dev evidence hg002-gvcf TRUTH.vcf.gz TRUTH.bed REF.fasta SITES.tsv OUT.vcf\n";
 
@@ -66,23 +68,107 @@ fn open(path: &str) -> Result<Box<dyn BufRead>, String> {
     og_io::open(path).map_err(|e| format!("{path}: {e}"))
 }
 
-/// Each line of `path` without its line end, to `f`.
-fn lines(path: &str, mut f: impl FnMut(&[u8]) -> Result<(), String>) -> Result<(), String> {
+/// Strict UTF-8 and universal newlines, with a 16 MiB record limit. This
+/// local reader can use og-io's bounded reader once that API is available.
+pub(crate) fn lines(
+    path: &str,
+    mut f: impl FnMut(&[u8]) -> Result<(), String>,
+) -> Result<(), String> {
+    const MAX_LINE: usize = 16 << 20;
     let mut r = open(path)?;
-    let mut buf = Vec::new();
+    let mut line = Vec::new();
+    let mut after_cr = false;
     loop {
-        buf.clear();
-        let n = r
-            .read_until(b'\n', &mut buf)
-            .map_err(|e| format!("{path}: {e}"))?;
-        if n == 0 {
+        let chunk = r.fill_buf().map_err(|e| format!("{path}: {e}"))?;
+        if chunk.is_empty() {
+            if !line.is_empty() {
+                std::str::from_utf8(&line).map_err(|e| format!("{path}: invalid UTF-8: {e}"))?;
+                f(&line)?;
+            }
             return Ok(());
         }
-        let line = buf.strip_suffix(b"\n").unwrap_or(&buf);
-        f(line.strip_suffix(b"\r").unwrap_or(line))?;
+        if after_cr {
+            after_cr = false;
+            if chunk[0] == b'\n' {
+                r.consume(1);
+                continue;
+            }
+        }
+        let end = chunk.iter().position(|b| matches!(b, b'\r' | b'\n'));
+        let n = end.unwrap_or(chunk.len());
+        if line.len() + n > MAX_LINE {
+            return Err(format!("{path}: record exceeds {MAX_LINE} bytes"));
+        }
+        line.extend_from_slice(&chunk[..n]);
+        if end.is_some() {
+            after_cr = chunk[n] == b'\r';
+            r.consume(n + 1);
+            std::str::from_utf8(&line).map_err(|e| format!("{path}: invalid UTF-8: {e}"))?;
+            f(&line)?;
+            line.clear();
+        } else {
+            r.consume(n);
+        }
+    }
+}
+
+/// A unique, exclusively created sibling. Dropping it on any read, write
+/// or rename error removes the temporary file and preserves the destination.
+pub(crate) struct PendingOutput {
+    path: PathBuf,
+    destination: PathBuf,
+}
+
+impl PendingOutput {
+    pub(crate) fn new(destination: &Path) -> Result<(Self, File), String> {
+        static NEXT: AtomicU64 = AtomicU64::new(0);
+        let name = destination.file_name().ok_or("output has no file name")?;
+        loop {
+            let mut tmp = std::ffi::OsString::from(".");
+            tmp.push(name);
+            tmp.push(format!(
+                ".tmp-{}-{}",
+                std::process::id(),
+                NEXT.fetch_add(1, Ordering::Relaxed)
+            ));
+            let path = destination.with_file_name(tmp);
+            match File::options().write(true).create_new(true).open(&path) {
+                Ok(file) => {
+                    return Ok((
+                        Self {
+                            path,
+                            destination: destination.to_owned(),
+                        },
+                        file,
+                    ));
+                }
+                Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => continue,
+                Err(e) => return Err(format!("{}: {e}", destination.display())),
+            }
+        }
+    }
+
+    pub(crate) fn commit(self) -> Result<(), String> {
+        fs::rename(&self.path, &self.destination)
+            .map_err(|e| format!("{}: {e}", self.destination.display()))
     }
 }
 
+impl Drop for PendingOutput {
+    fn drop(&mut self) {
+        let _ = fs::remove_file(&self.path);
+    }
+}
+
+pub(crate) fn publish(path: &Path, bytes: &[u8]) -> Result<(), String> {
+    let (pending, mut file) = PendingOutput::new(path)?;
+    file.write_all(bytes)
+        .and_then(|()| file.flush())
+        .map_err(|e| format!("{}: {e}", path.display()))?;
+    drop(file);
+    pending.commit()
+}
+
 fn pos(field: &[u8], path: &str) -> Result<u64, String> {
     std::str::from_utf8(field)
         .ok()
@@ -108,9 +194,14 @@ fn clash_positions(
             return Ok(());
         }
         let c: Vec<&[u8]> = line.splitn(6, |&b| b == b'\t').collect();
-        if c.len() < 5 || !chroms.contains(c[0]) {
+        if !chroms.contains(c[0]) {
             return Ok(());
         }
+        if c.len() < 5 {
+            return Err(format!(
+                "{path}: a selected record has fewer than 5 columns"
+            ));
+        }
         let k = (c[0].to_vec(), pos(c[1], path)?);
         if key.as_ref() != Some(&k) {
             key = Some(k.clone());
@@ -164,9 +255,12 @@ fn clashes(raw: &str, split: &str, data: &str, out: &str) -> Result<(), String>
         let path = table.to_string_lossy().into_owned();
         lines(&path, |line| {
             let c: Vec<&[u8]> = line.splitn(3, |&b| b == b'\t').collect();
-            if c[0] != chrom.as_slice() || c.len() < 2 {
+            if c[0] != chrom.as_slice() {
                 return Ok(());
             }
+            if c.len() < 2 {
+                return Err(format!("{path}: a selected row has fewer than 2 columns"));
+            }
             let p = pos(c[1], &path)?;
             for (k, w) in want.iter().enumerate() {
                 on_table[k] += u64::from(w.contains(&p));
@@ -182,7 +276,7 @@ fn clashes(raw: &str, split: &str, data: &str, out: &str) -> Result<(), String>
             on_table[k]
         );
     }
-    fs::write(out, text).map_err(|e| format!("{out}: {e}"))
+    publish(Path::new(out), text.as_bytes())
 }
 
 /// One `.fai` row: length, byte offset, bases per line, bytes per line.
@@ -254,9 +348,6 @@ fn hg002_gvcf(
             .split(|b| b.is_ascii_whitespace())
             .filter(|x| !x.is_empty())
             .collect();
-        if f.is_empty() {
-            return Ok(());
-        }
         if f.len() < 3 {
             return Err(format!("{bed}: a row has fewer than 3 columns"));
         }
@@ -275,7 +366,7 @@ fn hg002_gvcf(
         })
     };
 
-    let file = File::create(out).map_err(|e| format!("{out}: {e}"))?;
+    let (pending, file) = PendingOutput::new(Path::new(out))?;
     let mut w = BufWriter::with_capacity(1 << 20, file);
     let werr = |e: std::io::Error| format!("{out}: {e}");
     let mut covered: HashMap<Vec<u8>, Vec<(u64, u64)>> = HashMap::new();
@@ -291,10 +382,13 @@ fn hg002_gvcf(
                 return Err(format!("{truth}: a record has fewer than 5 columns"));
             }
             let p = pos(f[1], truth)?;
-            covered
-                .entry(f[0].to_vec())
-                .or_default()
-                .push((p, p + f[3].len() as u64));
+            covered.entry(f[0].to_vec()).or_default().push((
+                p,
+                p + std::str::from_utf8(f[3])
+                    .expect("strict reader")
+                    .chars()
+                    .count() as u64,
+            ));
             records += 1;
         }
         w.write_all(line)
@@ -326,6 +420,7 @@ fn hg002_gvcf(
         fasta
             .read_exact_at(&mut base, at)
             .map_err(|e| format!("{reference}: {e}"))?;
+        std::str::from_utf8(&base).map_err(|e| format!("{reference}: invalid UTF-8: {e}"))?;
         let b = base[0].to_ascii_uppercase();
         if !b"ACGT".contains(&b) {
             return Ok(());
@@ -335,7 +430,12 @@ fn hg002_gvcf(
             .and_then(|()| writeln!(w, "\t{p}\t.\t{}\t<*>\t.\t.\tEND={p}\tGT\t0/0", b as char))
             .map_err(werr)
     })?;
-    w.flush().map_err(werr)?;
+    if first {
+        return Err(format!("{sites}: missing header"));
+    }
+    let file = w.into_inner().map_err(|e| werr(e.into_error()))?;
+    drop(file);
+    pending.commit()?;
     Ok((records, blocks))
 }
 
@@ -390,7 +490,6 @@ mod tests {
         );
     }
 
-
     struct Case {
         dir: std::path::PathBuf,
         kind: &'static str,
@@ -399,12 +498,15 @@ mod tests {
     impl Case {
         fn new(kind: &'static str, label: &str) -> Self {
             let dir = std::env::temp_dir().join(format!(
-                "og-evidence-{kind}-{label}-{}-{:?}", std::process::id(), std::thread::current().id()
+                "og-evidence-{kind}-{label}-{}-{:?}",
+                std::process::id(),
+                std::thread::current().id()
             ));
             let _ = fs::remove_dir_all(&dir);
             fs::create_dir_all(&dir).unwrap();
             let src = Path::new(env!("CARGO_MANIFEST_DIR"))
-                .join("../../../tests/parity/inputs").join(format!("dev-evidence-{kind}"));
+                .join("../../../tests/parity/inputs")
+                .join(format!("dev-evidence-{kind}"));
             for e in fs::read_dir(src).unwrap() {
                 let e = e.unwrap();
                 fs::copy(e.path(), dir.join(e.file_name())).unwrap();
@@ -414,12 +516,16 @@ mod tests {
         fn text(&self, name: &str) -> Vec<u8> {
             use std::io::Read;
             let mut bytes = Vec::new();
-            open(self.dir.join(name).to_str().unwrap()).unwrap().read_to_end(&mut bytes).unwrap();
+            open(self.dir.join(name).to_str().unwrap())
+                .unwrap()
+                .read_to_end(&mut bytes)
+                .unwrap();
             bytes
         }
         fn put(&self, name: &str, bytes: &[u8]) {
             if name.ends_with(".gz") {
-                let mut gz = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+                let mut gz =
+                    flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
                 gz.write_all(bytes).unwrap();
                 fs::write(self.dir.join(name), gz.finish().unwrap()).unwrap();
             } else {
@@ -429,31 +535,60 @@ mod tests {
         fn run(&self) -> Result<(), String> {
             let p = |n: &str| self.dir.join(n).to_str().unwrap().to_owned();
             if self.kind == "clashes" {
-                clashes(&p("raw.vcf.gz"), &p("split.vcf.gz"), self.dir.to_str().unwrap(), &p("out"))
+                clashes(
+                    &p("raw.vcf.gz"),
+                    &p("split.vcf.gz"),
+                    self.dir.to_str().unwrap(),
+                    &p("out"),
+                )
             } else {
-                hg002_gvcf(&p("truth.vcf.gz"), &p("truth.bed"), &p("ref.fasta"), &p("sites.tsv"), &p("out")).map(|_| ())
+                hg002_gvcf(
+                    &p("truth.vcf.gz"),
+                    &p("truth.bed"),
+                    &p("ref.fasta"),
+                    &p("sites.tsv"),
+                    &p("out"),
+                )
+                .map(|_| ())
             }
         }
         fn fails_without_publication(&self) {
             fs::write(self.dir.join("out"), b"PREVIOUS OUTPUT\n").unwrap();
             assert!(self.run().is_err(), "{} must fail", self.dir.display());
-            assert_eq!(fs::read(self.dir.join("out")).unwrap(), b"PREVIOUS OUTPUT\n");
-            let leftovers: Vec<_> = fs::read_dir(&self.dir).unwrap().filter_map(|e| {
-                let name = e.unwrap().file_name();
-                name.to_str().filter(|n| n.starts_with(".out.")).map(str::to_owned)
-            }).collect();
+            assert_eq!(
+                fs::read(self.dir.join("out")).unwrap(),
+                b"PREVIOUS OUTPUT\n"
+            );
+            let leftovers: Vec<_> = fs::read_dir(&self.dir)
+                .unwrap()
+                .filter_map(|e| {
+                    let name = e.unwrap().file_name();
+                    name.to_str()
+                        .filter(|n| n.starts_with(".out."))
+                        .map(str::to_owned)
+                })
+                .collect();
             assert!(leftovers.is_empty(), "{leftovers:?}");
         }
     }
     impl Drop for Case {
-        fn drop(&mut self) { fs::remove_dir_all(&self.dir).unwrap(); }
+        fn drop(&mut self) {
+            fs::remove_dir_all(&self.dir).unwrap();
+        }
     }
 
     #[test]
     fn selected_truncated_clash_records_fail() {
         for name in ["raw.vcf.gz", "split.vcf.gz", "chrA.tsv.gz"] {
             let c = Case::new("clashes", name);
-            c.put(name, if name == "chrA.tsv.gz" { b"chrA" } else { b"chrA\t3\n" });
+            c.put(
+                name,
+                if name == "chrA.tsv.gz" {
+                    b"chrA"
+                } else {
+                    b"chrA\t3\n"
+                },
+            );
             c.fails_without_publication();
         }
     }
@@ -462,7 +597,11 @@ mod tests {
     fn missing_panel_header_and_blank_bed_fail() {
         for name in ["sites.tsv", "truth.bed"] {
             let c = Case::new("hg002-gvcf", name);
-            let bytes = if name == "sites.tsv" { vec![] } else { [c.text(name), b"\n".to_vec()].concat() };
+            let bytes = if name == "sites.tsv" {
+                vec![]
+            } else {
+                [c.text(name), b"\n".to_vec()].concat()
+            };
             c.put(name, &bytes);
             c.fails_without_publication();
         }
@@ -472,7 +611,10 @@ mod tests {
     fn every_evidence_text_input_rejects_invalid_utf8() {
         for (kind, names) in [
             ("clashes", vec!["raw.vcf.gz", "split.vcf.gz", "chrA.tsv.gz"]),
-            ("hg002-gvcf", vec!["truth.vcf.gz", "truth.bed", "ref.fasta.fai", "sites.tsv"]),
+            (
+                "hg002-gvcf",
+                vec!["truth.vcf.gz", "truth.bed", "ref.fasta.fai", "sites.tsv"],
+            ),
         ] {
             for name in names {
                 let c = Case::new(kind, name);
@@ -488,18 +630,32 @@ mod tests {
     #[test]
     fn every_evidence_text_input_has_universal_newlines() {
         for (kind, names) in [
-            ("clashes", vec!["raw.vcf.gz", "split.vcf.gz", "chrA.tsv.gz", "chrB.tsv.gz"]),
-            ("hg002-gvcf", vec!["truth.vcf.gz", "truth.bed", "ref.fasta.fai", "sites.tsv"]),
+            (
+                "clashes",
+                vec!["raw.vcf.gz", "split.vcf.gz", "chrA.tsv.gz", "chrB.tsv.gz"],
+            ),
+            (
+                "hg002-gvcf",
+                vec!["truth.vcf.gz", "truth.bed", "ref.fasta.fai", "sites.tsv"],
+            ),
         ] {
             for name in names {
                 for ending in [b"\r".as_slice(), b"\r\n".as_slice()] {
                     let c = Case::new(kind, &format!("{name}-{}", ending.len()));
                     c.run().unwrap();
                     let expected = fs::read(c.dir.join("out")).unwrap();
-                    let bytes = c.text(name).split(|b| *b == b'\n').collect::<Vec<_>>().join(ending);
+                    let bytes = c
+                        .text(name)
+                        .split(|b| *b == b'\n')
+                        .collect::<Vec<_>>()
+                        .join(ending);
                     c.put(name, &bytes);
                     c.run().unwrap();
-                    assert_eq!(fs::read(c.dir.join("out")).unwrap(), expected, "{kind}/{name}/{ending:?}");
+                    assert_eq!(
+                        fs::read(c.dir.join("out")).unwrap(),
+                        expected,
+                        "{kind}/{name}/{ending:?}"
+                    );
                 }
             }
         }
@@ -513,9 +669,20 @@ mod tests {
                 let path = c.dir.join(name);
                 match fault {
                     "missing" => fs::remove_file(path).unwrap(),
-                    "directory" => { fs::remove_file(&path).unwrap(); fs::create_dir(path).unwrap(); }
-                    "malformed" => { let mut bytes = c.text(name); bytes.extend_from_slice(b"bad\n"); c.put(name, &bytes); }
-                    _ if name.ends_with(".gz") => { let mut bytes = fs::read(&path).unwrap(); bytes.truncate(bytes.len()-5); fs::write(path, bytes).unwrap(); }
+                    "directory" => {
+                        fs::remove_file(&path).unwrap();
+                        fs::create_dir(path).unwrap();
+                    }
+                    "malformed" => {
+                        let mut bytes = c.text(name);
+                        bytes.extend_from_slice(b"bad\n");
+                        c.put(name, &bytes);
+                    }
+                    _ if name.ends_with(".gz") => {
+                        let mut bytes = fs::read(&path).unwrap();
+                        bytes.truncate(bytes.len() - 5);
+                        fs::write(path, bytes).unwrap();
+                    }
                     _ => c.put(name, b"header\nbad\n"),
                 }
                 c.fails_without_publication();
diff --git a/rust/crates/og-dev/src/fixture.rs b/rust/crates/og-dev/src/fixture.rs
index bb163c9f9..3220fc707 100644
--- a/rust/crates/og-dev/src/fixture.rs
+++ b/rust/crates/og-dev/src/fixture.rs
@@ -379,7 +379,7 @@ pub mod comphet {
             ("comphet.vcf", comphet_vcf(&vs)),
         ] {
             let path = dir.join(name);
-            fs::write(&path, text).map_err(|e| format!("{}: {e}", path.display()))?;
+            crate::evidence::publish(&path, text.as_bytes())?;
         }
         Ok(())
     }
@@ -395,6 +395,7 @@ fn truthy(v: &Value) -> bool {
     pycompat::value::truthy(v)
 }
 
+/// The old trimmer used `v or []`: null and every false value are empty.
 /// `v or []` as a list; a truthy value that is not a list is an error.
 fn list<'a>(v: Option<&'a Value>, what: &str) -> Result<&'a [Value], String> {
     match v {
@@ -421,6 +422,7 @@ fn pick(x: &IndexMap<String, Value>, keys: &[&str]) -> IndexMap<String, Value> {
 /// One listed diplotype with the fields `og pgx` reads.
 fn diplotype(x: &Value) -> Result<Value, String> {
     let Value::Object(x) = x else {
+        // The Python dip() explicitly passes non-object listed diplotypes through.
         return Ok(x.clone());
     };
     let mut out = pick(
@@ -457,11 +459,17 @@ fn head(items: &[Value], n: i64) -> &[Value] {
 /// The trimmed report: every gene with its listed diplotypes and related
 /// drugs, and for each drug of each guidance source up to `max` of the
 /// annotations PharmCAT matched, with only the fields `og pgx` reads.
-pub fn trim(d: &Value, max: i64) -> Result<Value, String> {
-    let d = object(d, "the report")?;
+pub fn trim(d: Value, max: i64) -> Result<Value, String> {
+    let Value::Object(mut d) = d else {
+        return Err("the report is not an object".to_owned());
+    };
     let mut genes = IndexMap::new();
-    for (g, v) in object(d.get("genes").unwrap_or(&Value::Null), "genes")? {
-        let v = object(v, &format!("gene {g}"))?;
+    let Some(Value::Object(input_genes)) = d.swap_remove("genes") else {
+        return Err("genes is not an object".to_owned());
+    };
+    // Consume one source gene at a time: do not retain a second full report.
+    for (g, v) in input_genes {
+        let v = object(&v, &format!("gene {g}"))?;
         let mut gene = pick(v, &["geneSymbol", "chr", "phased", "callSource"]);
         let mut related = Vec::new();
         for r in list(v.get("relatedDrugs"), "relatedDrugs")? {
@@ -487,11 +495,14 @@ pub fn trim(d: &Value, max: i64) -> Result<Value, String> {
                 .collect::<Result<_, _>>()?;
             gene.insert(k.to_owned(), Value::Array(dips));
         }
-        genes.insert(g.clone(), Value::Object(gene));
+        genes.insert(g, Value::Object(gene));
     }
     let mut drugs: IndexMap<String, Value> = IndexMap::new();
-    for (source, by) in object(d.get("drugs").unwrap_or(&Value::Null), "drugs")? {
-        for (name, rep) in object(by, &format!("drugs of {source}"))? {
+    let Some(Value::Object(input_drugs)) = d.swap_remove("drugs") else {
+        return Err("drugs is not an object".to_owned());
+    };
+    for (source, by) in input_drugs {
+        for (name, rep) in object(&by, &format!("drugs of {source}"))? {
             let rep = object(rep, &format!("drug {name}"))?;
             let mut gls = Vec::new();
             for gl in list(rep.get("guidelines"), "guidelines")? {
@@ -509,6 +520,7 @@ pub fn trim(d: &Value, max: i64) -> Result<Value, String> {
                                     ("gene".to_owned(), get(x, "gene")),
                                     ("label".to_owned(), get(x, "label")),
                                 ]))),
+                                // The Python comprehension has `if isinstance(x, dict)`.
                                 _ => None,
                             })
                             .collect();
@@ -552,7 +564,10 @@ pub fn trim(d: &Value, max: i64) -> Result<Value, String> {
             }
         }
     }
-    let mut out = pick(d, &["title", "timestamp", "pharmcatVersion", "dataVersion"]);
+    let mut out = pick(
+        &d,
+        &["title", "timestamp", "pharmcatVersion", "dataVersion"],
+    );
     out.insert("genes".to_owned(), Value::Object(genes));
     out.insert("drugs".to_owned(), Value::Object(drugs));
     let mut note = String::new();
@@ -568,13 +583,14 @@ fn trim_pharmcat(src: &Path, dst: &Path, max: i64) -> Result<(), String> {
     let text = fs::read(src).map_err(|e| py_os_error(&e, &src.to_string_lossy()))?;
     let text = String::from_utf8(text).map_err(|_| format!("{}: not UTF-8", src.display()))?;
     let d = json::loads(&text).map_err(|e| format!("{}: {e}", src.display()))?;
-    let out = trim(&d, max)?;
+    drop(text);
+    let out = trim(d, max)?;
     let opts = Dump {
         separators: Some((",", ":")),
         ..Dump::default()
     };
     let text = json::dumps(&out, &opts).map_err(|e| e.to_string())?;
-    fs::write(dst, text).map_err(|e| py_os_error(&e, &dst.to_string_lossy()))
+    crate::evidence::publish(dst, text.as_bytes())
 }
 
 #[cfg(test)]
@@ -629,7 +645,7 @@ mod tests {
             "drugs":{"CPIC":{"d":{"name":"d","guidelines":[{"name":"g","annotations":[{"genotypes":[{"diplotypes":[{"gene":"G"},5]}]},{},{}]},{"annotations":[]}]}}}}"#,
         )
         .expect("json");
-        let out = trim(&d, 2).expect("trim");
+        let out = trim(d.clone(), 2).expect("trim");
         let text = json::dumps(
             &out,
             &Dump {
@@ -642,7 +658,7 @@ mod tests {
         assert!(text.contains(r#""annotations":[{"phenotypes":null,"classification":null,"drugRecommendation":null,"genotypes":[{"diplotypes":[{"gene":"G","label":null}]}]},{"phenotypes":null"#), "{text}");
         assert_eq!(text.matches("drugRecommendation").count(), 2, "{text}");
         // A negative count is Python's slice: all but the last.
-        let out = trim(&d, -2).expect("trim");
+        let out = trim(d, -2).expect("trim");
         let text = json::dumps(&out, &Dump::default()).expect("dumps");
         assert_eq!(text.matches("drugRecommendation").count(), 1, "{text}");
     }
diff --git a/rust/crates/og-dev/src/renovate.rs b/rust/crates/og-dev/src/renovate.rs
index e282db2a3..2513655c7 100644
--- a/rust/crates/og-dev/src/renovate.rs
+++ b/rust/crates/og-dev/src/renovate.rs
@@ -38,7 +38,7 @@ use pycompat::value::{py_repr, py_str, truthy};
 use regex::Regex;
 use std::collections::{BTreeMap, BTreeSet, HashMap};
 use std::fs;
-use std::io::{BufRead, BufReader, Write};
+use std::io::Write;
 use std::path::Path;
 
 const USAGE: &str = "usage: og dev renovate-check LOG [--pins FILE] [--repo DIR]\n";
@@ -66,7 +66,12 @@ pub fn cli(args: &[String], out: &mut dyn Write, err: &mut dyn Write) -> u8 {
     cli_with_summary(args, out, err, summary.as_deref().map(Path::new))
 }
 
-fn cli_with_summary(args: &[String], out: &mut dyn Write, err: &mut dyn Write, summary_path: Option<&Path>) -> u8 {
+fn cli_with_summary(
+    args: &[String],
+    out: &mut dyn Write,
+    err: &mut dyn Write,
+    summary_path: Option<&Path>,
+) -> u8 {
     let (mut log, mut pins, mut repo) = (None, PINS.to_owned(), ".".to_owned());
     let mut it = args.iter();
     while let Some(a) = it.next() {
@@ -131,13 +136,23 @@ fn cli_with_summary(args: &[String], out: &mut dyn Write, err: &mut dyn Write, s
     let table = summary(&deps);
     let _ = writeln!(out, "{table}");
     if let Some(path) = summary_path {
-        let appended = fs::OpenOptions::new()
-            .append(true)
-            .create(true)
-            .open(&path)
-            .and_then(|mut f| write!(f, "## Renovate dry run\n\n{table}\n"));
+        let appended = (|| -> Result<(), String> {
+            let (pending, mut file) = crate::evidence::PendingOutput::new(path)?;
+            match fs::File::open(path) {
+                Ok(mut old) => {
+                    std::io::copy(&mut old, &mut file).map_err(|e| e.to_string())?;
+                }
+                Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
+                Err(e) => return Err(e.to_string()),
+            }
+            writeln!(file, "## Renovate dry run\n\n{table}").map_err(|e| e.to_string())?;
+            file.flush().map_err(|e| e.to_string())?;
+            drop(file);
+            pending.commit()
+        })();
         if let Err(e) = appended {
             let _ = writeln!(err, "og dev renovate-check: GITHUB_STEP_SUMMARY: {e}");
+            return 1;
         }
     }
     let mut fails = check(&deps, &env_text, &pins);
@@ -246,25 +261,23 @@ fn read_pins(repo: &Path, path: &Path) -> Result<Pins, String> {
 
 /// Every dependency of the log's last `packageFiles with updates` record.
 fn load(log: &str) -> Result<Vec<Dep>, String> {
-    let f = fs::File::open(log).map_err(|e| format!("FAIL: cannot read {log}: {e}"))?;
     let mut files = None;
-    let mut r = BufReader::new(f);
-    let mut buf = Vec::new();
-    loop {
-        buf.clear();
-        if r.read_until(b'\n', &mut buf)
-            .map_err(|e| format!("FAIL: cannot read {log}: {e}"))?
-            == 0
-        {
-            break;
-        }
-        let Ok(Value::Object(mut rec)) = json::loads(&String::from_utf8_lossy(&buf)) else {
-            continue;
+    crate::evidence::lines(log, |line| {
+        // The old load() skipped only JSON parse errors, not parsed scalars.
+        let Ok(value) = json::loads(std::str::from_utf8(line).expect("strict reader")) else {
+            return Ok(());
+        };
+        let Value::Object(mut rec) = value else {
+            return Err(format!("FAIL: {log}: a log record is not an object"));
         };
         if rec.get("msg") == Some(&Value::Str("packageFiles with updates".to_owned())) {
-            files = Some(rec.swap_remove("config").unwrap_or(Value::Null));
+            files = Some(
+                rec.swap_remove("config")
+                    .ok_or_else(|| format!("FAIL: {log}: missing config"))?,
+            );
         }
-    }
+        Ok(())
+    })?;
     let Some(files) = files else {
         return Err(format!(
             "FAIL: no 'packageFiles with updates' record in {log}"
@@ -287,18 +300,58 @@ fn load(log: &str) -> Result<Vec<Dep>, String> {
             let Value::Object(mut pf) = pf else {
                 return Err(shape());
             };
-            let name = pf
-                .get("packageFile")
-                .map(py_str)
-                .ok_or_else(shape)?
-                .map_err(|_| shape())?;
-            if let Some(Value::Array(ds)) = pf.swap_remove("deps") {
-                for d in ds {
-                    let Value::Object(d) = d else {
+            let Some(Value::Str(name)) = pf.swap_remove("packageFile") else {
+                return Err(shape());
+            };
+            let ds = match pf.swap_remove("deps") {
+                None => Vec::new(),
+                Some(Value::Array(ds)) => ds,
+                _ => return Err(shape()),
+            };
+            for d in ds {
+                let Value::Object(d) = d else {
+                    return Err(shape());
+                };
+                // Optional means absent. Null or a scalar is not an empty list.
+                if let Some(u) = d.get("updates") {
+                    let Value::Array(us) = u else {
                         return Err(shape());
                     };
-                    deps.push((name.clone(), d));
+                    for u in us {
+                        let Value::Object(u) = u else {
+                            return Err(shape());
+                        };
+                        for k in ["newValue", "newDigest", "updateType"] {
+                            if u.get(k)
+                                .is_some_and(|v| !matches!(v, Value::Null | Value::Str(_)))
+                            {
+                                return Err(shape());
+                            }
+                        }
+                    }
                 }
+                for k in [
+                    "datasource",
+                    "depName",
+                    "currentValue",
+                    "currentDigest",
+                    "skipReason",
+                ] {
+                    if d.get(k)
+                        .is_some_and(|v| !matches!(v, Value::Null | Value::Str(_)))
+                    {
+                        return Err(shape());
+                    }
+                }
+                if let Some(ws) = d.get("warnings") {
+                    let Value::Array(ws) = ws else {
+                        return Err(shape());
+                    };
+                    if ws.iter().any(|v| !matches!(v, Value::Object(_))) {
+                        return Err(shape());
+                    }
+                }
+                deps.push((name.clone(), d));
             }
         }
     }
@@ -837,12 +890,14 @@ mod tests {
         let _ = fs::remove_dir_all(&d);
     }
 
-
-
     #[test]
     fn configured_summary_write_failure_fails_the_check() {
         let d = planted("summary");
-        let args = vec![d.join("renovate.log").to_str().unwrap().to_owned(), "--repo".to_owned(), d.to_str().unwrap().to_owned()];
+        let args = vec![
+            d.join("renovate.log").to_str().unwrap().to_owned(),
+            "--repo".to_owned(),
+            d.to_str().unwrap().to_owned(),
+        ];
         let (mut out, mut err) = (Vec::new(), Vec::new());
         assert_eq!(cli_with_summary(&args, &mut out, &mut err, Some(&d)), 1);
         assert!(!String::from_utf8_lossy(&out).contains("every check passed"));
@@ -853,8 +908,14 @@ mod tests {
     fn malformed_log_shapes_and_text_fail() {
         for (label, bad) in [
             ("null-deps", r#"{"packageFile":"unused","deps":null}"#),
-            ("null-updates", r#"{"packageFile":"unused","deps":[{"updates":null}]}"#),
-            ("scalar-update", r#"{"packageFile":"unused","deps":[{"updates":[42]}]}"#),
+            (
+                "null-updates",
+                r#"{"packageFile":"unused","deps":[{"updates":null}]}"#,
+            ),
+            (
+                "scalar-update",
+                r#"{"packageFile":"unused","deps":[{"updates":[42]}]}"#,
+            ),
             ("scalar-dep", r#"{"packageFile":"unused","deps":[42]}"#),
             ("scalar-file", r#"{"packageFile":[],"deps":[]}"#),
         ] {
@@ -866,7 +927,11 @@ mod tests {
             assert_eq!(code, 1, "{label}: {out}");
             fs::remove_dir_all(d).unwrap();
         }
-        for (label, prefix) in [("utf8", b"\xff\n".as_slice()), ("array", b"[]\n".as_slice()), ("null", b"null\n".as_slice())] {
+        for (label, prefix) in [
+            ("utf8", b"\xff\n".as_slice()),
+            ("array", b"[]\n".as_slice()),
+            ("null", b"null\n".as_slice()),
+        ] {
             let d = planted(label);
             let log = [prefix, &fs::read(d.join("renovate.log")).unwrap()].concat();
             fs::write(d.join("renovate.log"), log).unwrap();
diff --git a/tests/smoke/vntyper.sh b/tests/smoke/vntyper.sh
index cd4d6cec1..e726c3182 100644
--- a/tests/smoke/vntyper.sh
+++ b/tests/smoke/vntyper.sh
@@ -7,6 +7,12 @@
 # the folder its config.json paths are relative to.
 set -e
 sh /smoke/vntyper_testdata.sh /out/data positive.bam negative.bam
+# Hashing stdin must also work when the destination contains a newline.
+newline_out='/out/new
+line'
+sh /smoke/vntyper_testdata.sh "$newline_out" negative.bam
+cmp /out/data/negative.bam "$newline_out/negative.bam"
+rm -rf "$newline_out"
 for s in positive negative; do
   samtools index "/out/data/${s}.bam"
   (cd /opt/vntyper && vntyper pipeline --bam "/out/data/${s}.bam" -o "/out/${s}" --sample-name "$s" \
diff --git a/tests/smoke/vntyper_testdata.sh b/tests/smoke/vntyper_testdata.sh
index 705f4ea53..e6d7da2a8 100755
--- a/tests/smoke/vntyper_testdata.sh
+++ b/tests/smoke/vntyper_testdata.sh
@@ -58,7 +58,7 @@ EOF
   # then the raw deflate stream; then CRC-32 and size, both little-endian.
   { printf '\037\213\010\000\000\000\000\000\000\377'; cat "${part}.raw"; le32 "$((0x$crc))"; le32 "$size"; } > "${part}.gz"
   gzip -dc "${part}.gz" > "$part" || { echo "${path}: size or CRC-32 differs from the archive's directory" >&2; exit 1; }
-  got=$(sha256sum "$part" | cut -d' ' -f1)
+  got=$(sha256sum < "$part" | cut -d' ' -f1)
   [ "$got" = "$want" ] || { echo "${path}: sha256 ${got}, pinned ${want}" >&2; exit 1; }
   rm -f "${part}.raw" "${part}.gz"
   mv "$part" "${out}/${name}"

From dac11393c543a93f7c4ab79763a26e850b824682 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 18:30:39 +0100
Subject: [PATCH 58/76] test(dev): pin round two input and publication
 regressions

---
 rust/crates/og-dev/src/evidence.rs | 99 ++++++++++++++++++++++++++++++
 rust/crates/og-dev/src/fixture.rs  | 35 +++++++++++
 rust/crates/og-dev/src/renovate.rs | 46 ++++++++++++++
 3 files changed, 180 insertions(+)

diff --git a/rust/crates/og-dev/src/evidence.rs b/rust/crates/og-dev/src/evidence.rs
index 3e95b2880..09df60bab 100644
--- a/rust/crates/og-dev/src/evidence.rs
+++ b/rust/crates/og-dev/src/evidence.rs
@@ -690,6 +690,105 @@ mod tests {
         }
     }
 
+
+    #[test]
+    fn explicit_compression_is_required_at_every_input() {
+        for (kind, names) in [
+            ("clashes", vec!["raw.vcf.gz", "split.vcf.gz", "chrA.tsv.gz"]),
+            ("hg002-gvcf", vec!["truth.vcf.gz", "truth.bed", "ref.fasta.fai", "sites.tsv"]),
+        ] {
+            for name in names {
+                let c = Case::new(kind, &format!("compression-{name}"));
+                let bytes = c.text(name);
+                let wrong = if name.ends_with(".gz") { bytes } else {
+                    let mut gz = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+                    gz.write_all(&bytes).unwrap(); gz.finish().unwrap()
+                };
+                fs::write(c.dir.join(name), wrong).unwrap();
+                c.fails_without_publication();
+                assert!(c.run().unwrap_err().contains("compression"), "{name}");
+            }
+        }
+    }
+
+    #[test]
+    fn bed_rejects_python_whitespace_inside_fields_and_as_separators() {
+        for ch in ['\u{2028}', '\u{85}', '\u{b}', '\u{a0}', '\u{1c}', '\u{1d}', '\u{1e}', '\u{1f}'] {
+            for embedded in [true, false] {
+                let c = Case::new("hg002-gvcf", &format!("space-{}-{embedded}", ch as u32));
+                let text = String::from_utf8(c.text("truth.bed")).unwrap();
+                let text = if embedded { text.replacen("chrA", &format!("chr{ch}A"), 1) }
+                           else { text.replace('\t', &ch.to_string()) };
+                c.put("truth.bed", text.as_bytes());
+                c.fails_without_publication();
+                assert!(c.run().unwrap_err().contains("unsupported whitespace"));
+            }
+        }
+    }
+
+    #[test]
+    fn publication_preserves_permissions_and_follows_symlinks() {
+        use std::os::unix::fs::{PermissionsExt, symlink};
+        let c = Case::new("clashes", "publication");
+        let target = c.dir.join("target");
+        let link = c.dir.join("link");
+        fs::write(&target, b"old").unwrap();
+        fs::set_permissions(&target, fs::Permissions::from_mode(0o600)).unwrap();
+        symlink("target", &link).unwrap();
+        publish(&link, b"new").unwrap();
+        assert!(fs::symlink_metadata(&link).unwrap().file_type().is_symlink());
+        assert_eq!(fs::read(&target).unwrap(), b"new");
+        assert_eq!(fs::metadata(&target).unwrap().permissions().mode() & 0o777, 0o600);
+        fs::set_permissions(&target, fs::Permissions::from_mode(0o444)).unwrap();
+        assert!(publish(&link, b"bad").unwrap_err().contains("read-only"));
+        assert_eq!(fs::read(&target).unwrap(), b"new");
+        let dir_link = c.dir.join("dir-link");
+        symlink(&c.dir, &dir_link).unwrap();
+        for path in [&c.dir, &dir_link] {
+            assert!(publish(path, b"bad").unwrap_err().contains("not a regular file"));
+        }
+    }
+
+    #[test]
+    fn approved_strict_evidence_shapes_fail_with_stable_errors() {
+        for value in ["3_0", "٣", "-3", "18446744073709551616"] {
+            let c = Case::new("hg002-gvcf", value);
+            c.put("truth.vcf.gz", format!("chrA\t{value}\t.\tA\tC\n").as_bytes());
+            c.fails_without_publication();
+            assert!(c.run().unwrap_err().contains("not a number"));
+        }
+        let c = Case::new("hg002-gvcf", "short-vcf");
+        c.put("truth.vcf.gz", b"chrA\t3\t.\tA\n");
+        c.fails_without_publication();
+        assert!(c.run().unwrap_err().contains("fewer than 5 columns"));
+        let c = Case::new("hg002-gvcf", "blank-fai");
+        c.put("ref.fasta.fai", b"\n");
+        c.fails_without_publication();
+        assert!(c.run().unwrap_err().contains("fewer than 5 columns"));
+        let c = Case::new("clashes", "newline-alt");
+        c.put("raw.vcf.gz", b"chrA\t3\t.\tA\tC\nchrA\t3\t.\tAA\tA\n");
+        c.fails_without_publication();
+        assert!(c.run().unwrap_err().contains("VCF columns"));
+    }
+
+    #[test]
+    fn approved_record_limit_and_final_lf_are_pinned() {
+        let c = Case::new("clashes", "record-limit");
+        c.put("raw.vcf.gz", &vec![b'#'; (16 << 20) + 1]);
+        c.fails_without_publication();
+        assert!(c.run().unwrap_err().contains("record exceeds 16777216 bytes"));
+        let c = Case::new("hg002-gvcf", "final-lf");
+        c.run().unwrap();
+        let expected = fs::read(c.dir.join("out")).unwrap();
+        let mut truth = c.text("truth.vcf.gz");
+        assert_eq!(truth.pop(), Some(b'\n'));
+        c.put("truth.vcf.gz", &truth);
+        c.run().unwrap();
+        let result = fs::read(c.dir.join("out")).unwrap();
+        assert_eq!(result, expected);
+        assert_eq!(result.last(), Some(&b'\n'));
+    }
+
     #[test]
     fn spans_merge_and_answer_inside() {
         let m = merge(vec![(10, 12), (5, 6), (11, 15), (15, 16)]);
diff --git a/rust/crates/og-dev/src/fixture.rs b/rust/crates/og-dev/src/fixture.rs
index 3220fc707..b141a910a 100644
--- a/rust/crates/og-dev/src/fixture.rs
+++ b/rust/crates/og-dev/src/fixture.rs
@@ -597,6 +597,41 @@ fn trim_pharmcat(src: &Path, dst: &Path, max: i64) -> Result<(), String> {
 mod tests {
     use super::*;
 
+
+    #[test]
+    fn comphet_validates_later_destinations_before_publishing() {
+        let d = std::env::temp_dir().join(format!("og-comphet-preflight-{}", std::process::id()));
+        let _ = fs::remove_dir_all(&d);
+        fs::create_dir_all(d.join("comphet.vcf")).unwrap();
+        for name in ["reads.sam", "vep.vcf"] { fs::write(d.join(name), b"PREVIOUS OUTPUT").unwrap(); }
+        assert!(comphet::write(&d, false).is_err());
+        for name in ["reads.sam", "vep.vcf"] { assert_eq!(fs::read(d.join(name)).unwrap(), b"PREVIOUS OUTPUT"); }
+        assert_eq!(fs::read_dir(&d).unwrap().count(), 3);
+        fs::remove_dir_all(d).unwrap();
+    }
+
+    #[test]
+    fn approved_strict_pharmcat_containers_fail_at_the_cli() {
+        let d = std::env::temp_dir().join(format!("og-pharmcat-shapes-{}", std::process::id()));
+        fs::create_dir_all(&d).unwrap();
+        for (input, class) in [
+            (r#"{"genes":{"G":{"sourceDiplotypes":"x"}},"drugs":{}}"#, "sourceDiplotypes is not a list"),
+            (r#"{"genes":{"G":{"recommendationDiplotypes":"x"}},"drugs":{}}"#, "recommendationDiplotypes is not a list"),
+            (r#"{"genes":{"G":{"sourceDiplotypes":[{"allele1":"x"}]}},"drugs":{}}"#, "allele1 is not an object"),
+            (r#"{"genes":{"G":{"sourceDiplotypes":[{"allele2":["x"]}]}},"drugs":{}}"#, "allele2 is not an object"),
+            (r#"{"genes":{},"drugs":{"S":{"D":{"guidelines":[{"annotations":[{"genotypes":[{"diplotypes":{"x":1}}]}]}]}}}}"#, "diplotypes is not a list"),
+        ] {
+            fs::write(d.join("in"), input).unwrap();
+            fs::write(d.join("out"), b"old").unwrap();
+            let args = vec!["trim-pharmcat".into(), d.join("in").to_str().unwrap().into(), d.join("out").to_str().unwrap().into()];
+            let (mut out, mut err) = (Vec::new(), Vec::new());
+            assert_eq!(cli(&args, &mut out, &mut err), 1);
+            assert!(String::from_utf8_lossy(&err).contains(class), "{err:?}");
+            assert_eq!(fs::read(d.join("out")).unwrap(), b"old");
+        }
+        fs::remove_dir_all(d).unwrap();
+    }
+
     #[test]
     fn mt19937_matches_cpython() {
         // random.Random(31): [r.getrandbits(32) for _ in range(3)] and the
diff --git a/rust/crates/og-dev/src/renovate.rs b/rust/crates/og-dev/src/renovate.rs
index 2513655c7..87a368999 100644
--- a/rust/crates/og-dev/src/renovate.rs
+++ b/rust/crates/og-dev/src/renovate.rs
@@ -941,6 +941,52 @@ mod tests {
         }
     }
 
+
+    #[test]
+    fn repository_sources_use_universal_newlines() {
+        for name in [ENV, PINS, ".github/workflows/ci.yml"] {
+            for ending in ["\r", "\r\n"] {
+                let d = planted(&format!("newlines-{}-{}", name.replace('/', "-"), ending.len()));
+                let baseline = run(&d);
+                let text = fs::read_to_string(d.join(name)).unwrap().replace('\n', ending);
+                fs::write(d.join(name), text).unwrap();
+                assert_eq!(run(&d), baseline, "{name}/{ending:?}");
+                fs::remove_dir_all(d).unwrap();
+            }
+        }
+    }
+
+    #[test]
+    fn real_log_falsy_warnings_and_absent_empty_packages_are_accepted() {
+        for entry in [r#"{}"#, r#"{"deps":[]}"#, r#"{"deps":[],"packageFile":[]}"#,
+            r#"{"packageFile":"unused","deps":[{"warnings":null}]}"#,
+            r#"{"packageFile":"unused","deps":[{"warnings":false}]}"#,
+            r#"{"packageFile":"unused","deps":[{"warnings":""}]}"#,
+            r#"{"packageFile":"unused","deps":[{"warnings":{}}]}"#] {
+            let d = planted("falsy");
+            let log = fs::read_to_string(d.join("renovate.log")).unwrap();
+            fs::write(d.join("renovate.log"), log.replacen(r#""regex":["#, &format!(r#""regex":[{entry},"#), 1)).unwrap();
+            let (code, out) = run(&d);
+            assert_eq!(code, 0, "{entry}: {out}");
+            fs::remove_dir_all(d).unwrap();
+        }
+    }
+
+    #[test]
+    fn renovate_requires_plain_compression_and_pins_record_limit() {
+        let d = planted("compression-limit");
+        let text = fs::read(d.join("renovate.log")).unwrap();
+        let mut gz = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+        gz.write_all(&text).unwrap();
+        fs::write(d.join("renovate.log"), gz.finish().unwrap()).unwrap();
+        let (code, out) = run(&d);
+        assert_eq!(code, 1); assert!(out.contains("compression"), "{out}");
+        fs::write(d.join("renovate.log"), vec![b'x'; (16 << 20) + 1]).unwrap();
+        let (code, out) = run(&d);
+        assert_eq!(code, 1); assert!(out.contains("record exceeds 16777216 bytes"), "{out}");
+        fs::remove_dir_all(d).unwrap();
+    }
+
     #[test]
     fn a_log_without_the_record_fails() {
         let d = planted("nolog");

From ba23556d371a958fc6e333576172867f7165aa8d Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 18:31:32 +0100
Subject: [PATCH 59/76] test(smoke): reproduce unsafe downloader destinations
 and leftovers

---
 rust/crates/og-dev/src/fixture.rs | 50 +++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/rust/crates/og-dev/src/fixture.rs b/rust/crates/og-dev/src/fixture.rs
index b141a910a..eccfdc4fb 100644
--- a/rust/crates/og-dev/src/fixture.rs
+++ b/rust/crates/og-dev/src/fixture.rs
@@ -610,6 +610,56 @@ mod tests {
         fs::remove_dir_all(d).unwrap();
     }
 
+
+    #[test]
+    fn downloader_preflights_destinations_and_cleans_handled_failures() {
+        use std::os::unix::fs::{PermissionsExt, symlink};
+        use std::process::Command;
+        let d = std::env::temp_dir().join(format!("og-download-safety-{}", std::process::id()));
+        let _ = fs::remove_dir_all(&d);
+        fs::create_dir_all(d.join("bin")).unwrap();
+        let stub = d.join("bin/curl");
+        fs::write(&stub, "#!/bin/sh\nprintf called >> \"$CALLED\"\nwhile [ \"$1\" != -o ]; do shift; done\nprintf partial > \"$2\"\nexit 22\n").unwrap();
+        fs::set_permissions(&stub, fs::Permissions::from_mode(0o755)).unwrap();
+        let script = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../../tests/smoke/vntyper_testdata.sh");
+        for fault in ["directory", "directory-link", "curl", "crc", "sha", "signal"] {
+            let out = d.join(fault);
+            fs::create_dir(&out).unwrap();
+            let dst = out.join("negative.bam");
+            match fault {
+                "directory" => fs::create_dir(&dst).unwrap(),
+                "directory-link" => symlink(&d, &dst).unwrap(),
+                _ => {
+                    fs::write(&dst, b"PREVIOUS OUTPUT").unwrap();
+                    symlink("negative.bam", out.join("negative.bam.part")).unwrap();
+                }
+            }
+            if fault == "crc" {
+                fs::write(&stub, "#!/bin/sh\nprintf called >> \"$CALLED\"\nwhile [ \"$1\" != -o ]; do shift; done\ndd if=/dev/zero of=\"$2\" bs=3376349 count=1 2>/dev/null\n").unwrap();
+            } else if fault == "sha" {
+                // Supply an inflater with correct size but the wrong SHA.
+                fs::write(d.join("bin/gzip"), "#!/bin/sh\nprintf wrong-sha\n").unwrap();
+                fs::set_permissions(d.join("bin/gzip"), fs::Permissions::from_mode(0o755)).unwrap();
+            } else if fault == "signal" {
+                fs::remove_file(d.join("bin/gzip")).unwrap();
+                fs::write(&stub, "#!/bin/sh\nkill -TERM \"$PPID\"\nexit 22\n").unwrap();
+            }
+            let called = d.join("called");
+            let _ = fs::remove_file(&called);
+            let result = Command::new("sh").arg(&script).arg(&out).arg("negative.bam")
+                .env("PATH", format!("{}:{}", d.join("bin").display(), std::env::var("PATH").unwrap()))
+                .env("CALLED", &called).output().unwrap();
+            assert!(!result.status.success(), "{fault}");
+            if fault.starts_with("directory") { assert!(!called.exists(), "must reject before curl: {fault}"); }
+            else {
+                assert_eq!(fs::read(&dst).unwrap(), b"PREVIOUS OUTPUT", "{fault}");
+                let entries: Vec<_> = fs::read_dir(&out).unwrap().map(|e| e.unwrap().file_name()).collect();
+                assert_eq!(entries.len(), 2, "{fault}: {entries:?}");
+            }
+        }
+        fs::remove_dir_all(d).unwrap();
+    }
+
     #[test]
     fn approved_strict_pharmcat_containers_fail_at_the_cli() {
         let d = std::env::temp_dir().join(format!("og-pharmcat-shapes-{}", std::process::id()));

From f155efd343e82ebf8b53a563ee4b2c5b6f4dbf85 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 18:39:43 +0100
Subject: [PATCH 60/76] test(ci): expose regex case, gitlink and path
 validation gaps

---
 rust/crates/og-dev/src/personal_data.rs | 199 ++++++++++++++++++++++++
 1 file changed, 199 insertions(+)

diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
index 75a84e026..2b51ca0ba 100644
--- a/rust/crates/og-dev/src/personal_data.rs
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -2305,6 +2305,205 @@ mod tests {
         assert_eq!(cli(&args, &mut Vec::new(), &mut Vec::new()), 0);
     }
 
+    fn r5_git(f: &Fixture, args: &[&str], input: &[u8]) -> String {
+        let mut child = Command::new("git")
+            .arg("-C")
+            .arg(&f.0)
+            .args(args)
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .spawn()
+            .unwrap();
+        child.stdin.take().unwrap().write_all(input).unwrap();
+        let output = child.wait_with_output().unwrap();
+        assert!(output.status.success());
+        String::from_utf8(output.stdout).unwrap().trim().to_owned()
+    }
+
+    fn r5_modes(f: &Fixture, files: &[&str], expected: u8, skip: &str) {
+        let mut failures = Vec::new();
+        for cached in [false, true] {
+            for explicit in [false, true] {
+                let mut args = f.args(if explicit { files } else { &[] });
+                args[5] = skip.into();
+                if cached {
+                    args.push("--cached".into());
+                }
+                let (mut out, mut err) = (Vec::new(), Vec::new());
+                let code = cli(&args, &mut out, &mut err);
+                if code != expected {
+                    failures.push((cached, explicit, code));
+                }
+                if expected == 2 && code == 2 {
+                    assert!(out.is_empty());
+                    assert!(!String::from_utf8_lossy(&err).contains("PRIVATE_FIVE"));
+                }
+            }
+        }
+        assert!(
+            failures.is_empty(),
+            "round-five scenarios differ: {failures:?}"
+        );
+    }
+
+    #[test]
+    fn round5_regex_case_relations() {
+        let f = Fixture::new("r5-case");
+        r5_git(&f, &["init", "-q"], b"");
+        // These literal spellings are stable partners. Escape the pattern so
+        // it reaches the compiler's decoded-scalar validation as well.
+        for (text, pattern) in [
+            ("\u{1c80}", r"(?i)[^\u0412]"),
+            ("\u{1c82}", r"(?i)[^\u041e]"),
+            ("\u{1c88}", r"(?i)[^\ua64a]"),
+        ] {
+            std::fs::write(f.0.join("own.md"), text).unwrap();
+            std::fs::write(f.0.join("patterns"), pattern).unwrap();
+            r5_git(&f, &["add", "own.md"], b"");
+            for cached in [false, true] {
+                for explicit in [false, true] {
+                    let mut args = f.args(if explicit { &["own.md"] } else { &[] });
+                    args.extend([
+                        "--patterns".into(),
+                        f.0.join("patterns").display().to_string(),
+                    ]);
+                    if cached {
+                        args.push("--cached".into());
+                    }
+                    let (mut out, mut err) = (Vec::new(), Vec::new());
+                    assert_eq!(cli(&args, &mut out, &mut err), 2);
+                    assert!(out.is_empty());
+                    assert!(!String::from_utf8_lossy(&err).contains(text));
+                }
+            }
+        }
+        for c in [
+            0x412, 0x414, 0x41e, 0x421, 0x422, 0x42a, 0x432, 0x434, 0x43e, 0x441, 0x442, 0x44a,
+            0x462, 0x463, 0x1c80, 0x1c81, 0x1c82, 0x1c83, 0x1c84, 0x1c85, 0x1c86, 0x1c87, 0x1c88,
+            0xa64a, 0xa64b,
+        ] {
+            assert!(version_dependent(char::from_u32(c).unwrap()));
+        }
+    }
+
+    #[test]
+    fn round5_stable_case_scalars_pass() {
+        let f = Fixture::new("r5-stable");
+        r5_git(&f, &["init", "-q"], b"");
+        for c in [
+            '\u{390}', '\u{3b0}', '\u{1fd3}', '\u{1fe3}', '\u{fb05}', '\u{fb06}',
+        ] {
+            std::fs::write(f.0.join("own.md"), c.to_string()).unwrap();
+            r5_git(&f, &["add", "own.md"], b"");
+            r5_modes(&f, &["own.md"], 0, "");
+        }
+    }
+
+    #[test]
+    fn round5_gitlinks_fail_closed() {
+        let f = Fixture::new("r5-gitlink");
+        r5_git(&f, &["init", "-q"], b"");
+        std::fs::write(f.0.join("clean.md"), "clean").unwrap();
+        r5_git(&f, &["add", "clean.md"], b"");
+        let tree = r5_git(&f, &["hash-object", "-t", "tree", "-w", "--stdin"], b"");
+        let commit = r5_git(&f, &["hash-object", "-t", "commit", "-w", "--stdin"],
+            format!("tree {tree}\nauthor Synthetic <test@example.org> 0 +0000\ncommitter Synthetic <test@example.org> 0 +0000\n\nPRIVATE_FIVE\n").as_bytes());
+        r5_git(
+            &f,
+            &[
+                "update-index",
+                "--add",
+                "--cacheinfo",
+                &format!("160000,{commit},alias.md"),
+            ],
+            b"",
+        );
+        for explicit in [false, true] {
+            for skip in ["", "alias.md"] {
+                let mut args = f.args(if explicit {
+                    &["alias.md", "clean.md"]
+                } else {
+                    &[]
+                });
+                args[5] = skip.into();
+                args.push("--cached".into());
+                let (mut out, mut err) = (Vec::new(), Vec::new());
+                assert_eq!(
+                    cli(&args, &mut out, &mut err),
+                    if skip.is_empty() { 2 } else { 0 }
+                );
+                if skip.is_empty() {
+                    assert!(out.is_empty());
+                    assert_eq!(
+                        err,
+                        b"ERROR: alias.md: indexed entry is not a readable blob\n"
+                    );
+                } else {
+                    assert!(err.is_empty());
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn round5_guard_filenames() {
+        let f = Fixture::new("r5-path");
+        r5_git(&f, &["init", "-q"], b"");
+        std::fs::write(f.0.join("clean.md"), "clean").unwrap();
+        let name = "x\u{1e6c0}PRIVATE_FIVE.md";
+        std::fs::write(f.0.join(name), "clean").unwrap();
+        r5_git(&f, &["add", name, "clean.md"], b"");
+        for skip in ["", "x*"] {
+            r5_modes(&f, &[name, "clean.md"], 2, skip);
+            for cached in [false, true] {
+                let mut args = f.args(&[name, "clean.md"]);
+                args[5] = skip.into();
+                args[3] = "* clean".into();
+                if cached {
+                    args.push("--cached".into());
+                }
+                let (mut out, mut err) = (Vec::new(), Vec::new());
+                assert_eq!(cli(&args, &mut out, &mut err), 2);
+                assert!(out.is_empty());
+                assert_eq!(
+                    err,
+                    b"ERROR: selected filename has Unicode version-dependent text\n"
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn round5_every_symlink_hop() {
+        let f = Fixture::new("r5-hops");
+        r5_git(&f, &["init", "-q"], b"");
+        std::fs::write(f.0.join("clean.md"), "clean").unwrap();
+        std::os::unix::fs::symlink(
+            OsStr::from_bytes(b"PRIVATE_FIVE_\xff.md"),
+            f.0.join("inner.md"),
+        )
+        .unwrap();
+        std::os::unix::fs::symlink("inner.md", f.0.join("alias.md")).unwrap();
+        r5_git(&f, &["add", "alias.md", "clean.md"], b"");
+        for explicit in [false, true] {
+            for skip in ["", "alias.md"] {
+                let mut args = f.args(if explicit {
+                    &["alias.md", "clean.md"]
+                } else {
+                    &[]
+                });
+                args[5] = skip.into();
+                let (mut out, mut err) = (Vec::new(), Vec::new());
+                assert_eq!(cli(&args, &mut out, &mut err), 2);
+                assert!(out.is_empty());
+                assert_eq!(err, b"ERROR: path is not valid UTF-8\n");
+                // The index contains only the valid first-hop target.
+                args.push("--cached".into());
+                assert_eq!(cli(&args, &mut Vec::new(), &mut Vec::new()), 0);
+            }
+        }
+    }
+
     #[test]
     fn round4_guard_agrees_with_available_pythons() {
         // Every available interpreter is checked, not just whichever python3

From 96c3c7c93cc1b68449ac844f0b5f084b2c7bd6a8 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 18:39:45 +0100
Subject: [PATCH 61/76] fix(dev): enforce input formats and preserve
 publication destinations

---
 CHANGELOG.md                       |   4 +-
 docs/rust.md                       |  43 +++++
 rust/crates/og-dev/src/evidence.rs | 256 +++++++++++++++++++++++------
 rust/crates/og-dev/src/fixture.rs  | 113 +++++++++++--
 rust/crates/og-dev/src/renovate.rs |  84 ++++++++--
 tests/smoke/vntyper_testdata.sh    |  48 +++++-
 6 files changed, 458 insertions(+), 90 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index cc8b84ab4..90f203d7d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,7 +4,9 @@ Each release's notes. From 1.0.0 on, a major or minor release has hand-written n
 
 ## Unreleased
 
-- `og dev evidence` now rejects invalid UTF-8, truncated selected records, blank BED rows and missing panel headers. It reads LF, CRLF and CR line endings alike, with a 16 MiB limit per record. Evidence and fixture files are published by rename after validation, so a failed run preserves existing outputs. `og dev renovate-check` rejects malformed log records and present fields of the wrong type, and fails if its configured step summary cannot be written. The PharmCAT trimmer consumes source genes as it trims them. The VNtyper downloader also accepts output paths that contain a newline.
+- CI evidence and Renovate inputs now enforce their original explicit gzip or plain format above strict UTF-8 and universal-newline handling. Renovate normalizes repository sources too and accepts falsy warnings and packages with no dependencies. Output publication follows destination symlinks, preserves existing permissions, rejects read-only files and directories, and uses the umask for new files. VNtyper uses private temporary directories with failure and signal cleanup, and GNU `mv -T` prevents publication inside a directory. Comphet stages and validates all destinations before publishing. Three renames are still not one transaction. Stricter parsing is deliberate and tested: BED refuses unsupported Unicode/control whitespace, Renovate refuses wrong-typed present values, PharmCAT refuses truthy non-list containers and non-object alleles, evidence positions must be ASCII u64 values, truth VCF rows need five columns, blank FAI rows fail, text records have a 16 MiB limit, and clash rows need a trailing VCF column after ALT. Truth VCF records get a final LF. `docs/rust.md` lists the error classes.
+
+- `og dev evidence` now rejects invalid UTF-8, truncated selected records, blank BED rows and missing panel headers. It reads LF, CRLF and CR line endings alike, with a 16 MiB limit per record. Single-file evidence and fixture outputs are published by rename after validation. Comphet stages and validates all three outputs before its first rename. Three renames are still not one transaction. A crash or a filesystem failure between renames can publish only part of the new set. `og dev renovate-check` rejects malformed log records and present fields of the wrong type, and fails if its configured step summary cannot be written. The PharmCAT trimmer consumes source genes as it trims them. The VNtyper downloader also accepts output paths that contain a newline.
 
 
 - The Python that CI and the fixtures ran outside the pipeline now runs in the Rust `og` binary. The public evidence workflow runs `og dev evidence clashes` and `og dev evidence hg002-gvcf` instead of two inline Python programs; the Renovate dry run checks what Renovate found with `og dev renovate-check`, whose list of non-image pins is now data in `scripts/ci/renovate-pins.tsv`; `og dev fixture comphet` writes the compound-het fixture of the e2e case `comphet-phasing-1-reads`, byte for byte; and `og dev fixture trim-pharmcat` trims a PharmCAT report for `tests/fixtures/pharmcat`. `tests/fixtures/comphet/make_fixture.py`, `tests/fixtures/pharmcat/trim_report.py` and `tests/smoke/vntyper_testdata.py` are gone: VNtyper's two test BAMs now come from `tests/smoke/vntyper_testdata.sh`, one HTTP range request per BAM with curl, checked by gzip against the archive's CRC-32 and size and then against the pinned sha256. On GIAB's HG002 benchmark VCF (4,048,342 records) with the chr20-22 reference, `og dev evidence hg002-gvcf` writes the same gVCF in 3.5 s and 97 MB instead of 11.8 s and 3.8 GB, because it keeps the spans the records cover instead of every covered position. No pipeline output changes. What changes on purpose:
diff --git a/docs/rust.md b/docs/rust.md
index c624d8f9f..91928df39 100644
--- a/docs/rust.md
+++ b/docs/rust.md
@@ -111,3 +111,46 @@ To add a primitive: write it in `pycompat` with unit tests, add an operation to
 - **Release** (`release.yml`): a tag builds the four binaries, writes `SHA256SUMS`, attests them and attaches all five files to the release. A pull request that changes `rust/` or the workflow builds them as a dry run.
 
 [Testing](testing.md) has the rest of CI.
+
+## CI evidence and fixture verbs
+
+`og dev evidence clashes` reads two gzip VCFs and gzip archaic tables.
+`og dev evidence hg002-gvcf` reads a gzip truth VCF, plain BED, plain FASTA
+and FAI, and a plain sites table. `og dev renovate-check` reads a plain log
+and plain repository sources. Text uses strict UTF-8 and universal newlines
+(LF, CRLF and CR). Compression is explicit, even when a filename is misleading.
+
+Evidence, `og dev fixture comphet`, `og dev fixture trim-pharmcat` and the
+Renovate summary stage output beside its resolved destination. A file symlink
+stays a symlink, existing permission bits are preserved, and read-only files
+and directory destinations fail. New files use the caller's umask.
+The VNtyper downloader follows the same destination policy, uses a private
+`mktemp -d` directory, and removes it on handled failures and signals. It needs
+GNU `mv -T` (`gmv` on macOS) so a directory can never receive a temporary BAM.
+
+Comphet stages all three files and checks all three destinations before the
+first rename. A bad later destination leaves previous outputs intact.
+Three renames are still not one transaction. A crash or a filesystem failure
+between renames can publish only part of the new set. Unhandled SIGKILL can
+leave temporary files. Single-file outputs are replaced by one rename.
+
+### Stricter than the replaced Python, on purpose
+
+Each refusal below has a pinned negative CLI test with exit 1 and a stable
+error class in `og-dev`. The final-LF normalization has a positive byte test.
+
+- BED fields use spaces and tabs as separators. Other Python whitespace
+  (Unicode White_Space and U+001C through U+001F) fails with `unsupported whitespace`.
+- Renovate present fields of the wrong type fail with `not a map of package file lists`.
+  This includes map-valued updates and numeric dependency names, current values,
+  or update values. Falsy warnings and packages with no dependencies remain valid.
+- PharmCAT truthy strings or objects where lists belong fail with `is not a list`.
+- PharmCAT truthy non-object alleles fail with `is not an object`.
+- Evidence positions with underscores, non-ASCII digits, negative values or
+  values outside u64 fail with `not a number`.
+- Four-field truth VCF rows and blank FAI rows fail with `fewer than 5 columns`.
+- Text records over 16 MiB, including ignored headers or log lines, fail with
+  `record exceeds 16777216 bytes`.
+- Clash VCF rows need a tab after ALT. A newline in the ALT field of a short
+  row fails with `missing trailing VCF columns`.
+- A truth VCF record without its final LF gets one in the output. Valid VCF ends with LF.
diff --git a/rust/crates/og-dev/src/evidence.rs b/rust/crates/og-dev/src/evidence.rs
index 09df60bab..64251aa40 100644
--- a/rust/crates/og-dev/src/evidence.rs
+++ b/rust/crates/og-dev/src/evidence.rs
@@ -22,8 +22,8 @@
 
 use std::collections::{BTreeMap, BTreeSet, HashMap};
 use std::fs::{self, File};
-use std::io::{BufRead, BufWriter, Write};
-use std::os::unix::fs::FileExt;
+use std::io::{BufRead, BufReader, BufWriter, Write};
+use std::os::unix::fs::{FileExt, PermissionsExt};
 use std::path::Path;
 use std::path::PathBuf;
 use std::sync::atomic::{AtomicU64, Ordering};
@@ -64,18 +64,45 @@ pub fn cli(args: &[String], out: &mut dyn Write, err: &mut dyn Write) -> u8 {
     }
 }
 
-fn open(path: &str) -> Result<Box<dyn BufRead>, String> {
-    og_io::open(path).map_err(|e| format!("{path}: {e}"))
+fn open(path: &str, gzip: bool) -> Result<Box<dyn BufRead>, String> {
+    let mut file = BufReader::new(File::open(path).map_err(|e| format!("{path}: {e}"))?);
+    let head = file.fill_buf().map_err(|e| format!("{path}: {e}"))?;
+    if head.starts_with(&[0x1f, 0x8b]) != gzip {
+        return Err(format!(
+            "{path}: wrong compression (expected {})",
+            if gzip { "gzip" } else { "plain" }
+        ));
+    }
+    if gzip {
+        og_io::reader(file).map_err(|e| format!("{path}: {e}"))
+    } else {
+        Ok(Box::new(file))
+    }
+}
+
+/// Plain repository text with Python's universal-newline normalization.
+pub(crate) fn read_text(path: &Path) -> Result<String, String> {
+    use std::io::Read;
+    let mut text = String::new();
+    open(&path.to_string_lossy(), false)?
+        .read_to_string(&mut text)
+        .map_err(|e| format!("{}: invalid text: {e}", path.display()))?;
+    Ok(text.replace("\r\n", "\n").replace('\r', "\n"))
 }
 
 /// Strict UTF-8 and universal newlines, with a 16 MiB record limit. This
 /// local reader can use og-io's bounded reader once that API is available.
-pub(crate) fn lines(
+pub(crate) fn lines(path: &str, f: impl FnMut(&[u8]) -> Result<(), String>) -> Result<(), String> {
+    input_lines(path, false, f)
+}
+
+fn input_lines(
     path: &str,
+    gzip: bool,
     mut f: impl FnMut(&[u8]) -> Result<(), String>,
 ) -> Result<(), String> {
     const MAX_LINE: usize = 16 << 20;
-    let mut r = open(path)?;
+    let mut r = open(path, gzip)?;
     let mut line = Vec::new();
     let mut after_cr = false;
     loop {
@@ -112,8 +139,63 @@ pub(crate) fn lines(
     }
 }
 
+/// Follow the final symlink, including relative and dangling link targets.
+fn resolve_destination(destination: &Path) -> Result<PathBuf, String> {
+    let mut path = destination.to_owned();
+    for _ in 0..40 {
+        match fs::read_link(&path) {
+            Ok(target) => {
+                path = if target.is_absolute() {
+                    target
+                } else {
+                    path.parent().unwrap_or(Path::new(".")).join(target)
+                }
+            }
+            Err(e)
+                if matches!(
+                    e.kind(),
+                    std::io::ErrorKind::InvalidInput | std::io::ErrorKind::NotFound
+                ) =>
+            {
+                return Ok(path);
+            }
+            Err(e) => return Err(format!("{}: {e}", path.display())),
+        }
+    }
+    Err(format!(
+        "{}: too many destination symlinks",
+        destination.display()
+    ))
+}
+
+fn validate_destination(path: &Path) -> Result<Option<fs::Permissions>, String> {
+    match fs::metadata(path) {
+        Ok(meta) => {
+            if !meta.is_file() {
+                return Err(format!(
+                    "{}: destination is not a regular file",
+                    path.display()
+                ));
+            }
+            let permissions = meta.permissions();
+            if permissions.mode() & 0o222 == 0 {
+                return Err(format!("{}: read-only destination", path.display()));
+            }
+            // Check ACLs and effective-user access without truncating the old file.
+            File::options()
+                .write(true)
+                .open(path)
+                .map_err(|e| format!("{}: {e}", path.display()))?;
+            Ok(Some(permissions))
+        }
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(None),
+        Err(e) => Err(format!("{}: {e}", path.display())),
+    }
+}
+
 /// A unique, exclusively created sibling. Dropping it on any read, write
-/// or rename error removes the temporary file and preserves the destination.
+/// or rename error removes this temporary file. A multi-file set is staged
+/// together, but its renames are separate transactions.
 pub(crate) struct PendingOutput {
     path: PathBuf,
     destination: PathBuf,
@@ -122,6 +204,8 @@ pub(crate) struct PendingOutput {
 impl PendingOutput {
     pub(crate) fn new(destination: &Path) -> Result<(Self, File), String> {
         static NEXT: AtomicU64 = AtomicU64::new(0);
+        let destination = resolve_destination(destination)?;
+        let permissions = validate_destination(&destination)?;
         let name = destination.file_name().ok_or("output has no file name")?;
         loop {
             let mut tmp = std::ffi::OsString::from(".");
@@ -134,13 +218,15 @@ impl PendingOutput {
             let path = destination.with_file_name(tmp);
             match File::options().write(true).create_new(true).open(&path) {
                 Ok(file) => {
-                    return Ok((
-                        Self {
-                            path,
-                            destination: destination.to_owned(),
-                        },
-                        file,
-                    ));
+                    let pending = Self {
+                        path,
+                        destination: destination.to_owned(),
+                    };
+                    if let Some(permissions) = permissions {
+                        file.set_permissions(permissions)
+                            .map_err(|e| format!("{}: {e}", destination.display()))?;
+                    }
+                    return Ok((pending, file));
                 }
                 Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => continue,
                 Err(e) => return Err(format!("{}: {e}", destination.display())),
@@ -149,6 +235,7 @@ impl PendingOutput {
     }
 
     pub(crate) fn commit(self) -> Result<(), String> {
+        validate_destination(&self.destination)?;
         fs::rename(&self.path, &self.destination)
             .map_err(|e| format!("{}: {e}", self.destination.display()))
     }
@@ -189,7 +276,7 @@ fn clash_positions(
 ) -> Result<BTreeSet<(Vec<u8>, u64)>, String> {
     let mut hit = BTreeSet::new();
     let (mut key, mut n, mut snvs): (Option<(Vec<u8>, u64)>, u32, u32) = (None, 0, 0);
-    lines(path, |line| {
+    input_lines(path, true, |line| {
         if line.first() == Some(&b'#') {
             return Ok(());
         }
@@ -197,9 +284,9 @@ fn clash_positions(
         if !chroms.contains(c[0]) {
             return Ok(());
         }
-        if c.len() < 5 {
+        if c.len() < 6 {
             return Err(format!(
-                "{path}: a selected record has fewer than 5 columns"
+                "{path}: a selected record has fewer than 5 columns or missing trailing VCF columns"
             ));
         }
         let k = (c[0].to_vec(), pos(c[1], path)?);
@@ -253,7 +340,7 @@ fn clashes(raw: &str, split: &str, data: &str, out: &str) -> Result<(), String>
             continue;
         }
         let path = table.to_string_lossy().into_owned();
-        lines(&path, |line| {
+        input_lines(&path, true, |line| {
             let c: Vec<&[u8]> = line.splitn(3, |&b| b == b'\t').collect();
             if c[0] != chrom.as_slice() {
                 return Ok(());
@@ -339,15 +426,32 @@ fn hg002_gvcf(
 ) -> Result<(u64, u64), String> {
     let fai = read_fai(&format!("{reference}.fai"))?;
     let fasta = File::open(reference).map_err(|e| format!("{reference}: {e}"))?;
+    let mut magic = [0; 2];
+    if fasta
+        .read_at(&mut magic, 0)
+        .map_err(|e| format!("{reference}: {e}"))?
+        == 2
+        && magic == [0x1f, 0x8b]
+    {
+        return Err(format!("{reference}: wrong compression (expected plain)"));
+    }
     // The benchmark regions, BED 0-based: (start, end) per chromosome,
     // sorted. A site p (1-based) is confident when the region with the
     // largest start below p ends at p or later, as the Python's bisect did.
     let mut conf: HashMap<Vec<u8>, Vec<(u64, u64)>> = HashMap::new();
     lines(bed, |line| {
         let f: Vec<&[u8]> = line
-            .split(|b| b.is_ascii_whitespace())
+            .split(|b| matches!(b, b' ' | b'\t'))
             .filter(|x| !x.is_empty())
             .collect();
+        if f.iter().any(|field| {
+            std::str::from_utf8(field)
+                .expect("strict reader")
+                .chars()
+                .any(|ch| ch.is_whitespace() || matches!(ch, '\u{1c}'..='\u{1f}'))
+        }) {
+            return Err(format!("{bed}: unsupported whitespace in a field"));
+        }
         if f.len() < 3 {
             return Err(format!("{bed}: a row has fewer than 3 columns"));
         }
@@ -371,7 +475,7 @@ fn hg002_gvcf(
     let werr = |e: std::io::Error| format!("{out}: {e}");
     let mut covered: HashMap<Vec<u8>, Vec<(u64, u64)>> = HashMap::new();
     let mut records = 0u64;
-    lines(truth, |line| {
+    input_lines(truth, true, |line| {
         if line.starts_with(b"##") {
         } else if line.first() == Some(&b'#') {
             w.write_all(b"##INFO=<ID=END,Number=1,Type=Integer,Description=\"End of the reference block\">\n##ALT=<ID=*,Description=\"Any other allele\">\n")
@@ -384,10 +488,13 @@ fn hg002_gvcf(
             let p = pos(f[1], truth)?;
             covered.entry(f[0].to_vec()).or_default().push((
                 p,
-                p + std::str::from_utf8(f[3])
-                    .expect("strict reader")
-                    .chars()
-                    .count() as u64,
+                p.checked_add(
+                    std::str::from_utf8(f[3])
+                        .expect("strict reader")
+                        .chars()
+                        .count() as u64,
+                )
+                .ok_or_else(|| format!("{truth}: position span overflows"))?,
             ));
             records += 1;
         }
@@ -516,7 +623,7 @@ mod tests {
         fn text(&self, name: &str) -> Vec<u8> {
             use std::io::Read;
             let mut bytes = Vec::new();
-            open(self.dir.join(name).to_str().unwrap())
+            open(self.dir.join(name).to_str().unwrap(), name.ends_with(".gz"))
                 .unwrap()
                 .read_to_end(&mut bytes)
                 .unwrap();
@@ -534,22 +641,29 @@ mod tests {
         }
         fn run(&self) -> Result<(), String> {
             let p = |n: &str| self.dir.join(n).to_str().unwrap().to_owned();
-            if self.kind == "clashes" {
-                clashes(
-                    &p("raw.vcf.gz"),
-                    &p("split.vcf.gz"),
-                    self.dir.to_str().unwrap(),
-                    &p("out"),
-                )
+            let args = if self.kind == "clashes" {
+                vec![
+                    "clashes".to_owned(),
+                    p("raw.vcf.gz"),
+                    p("split.vcf.gz"),
+                    self.dir.to_str().unwrap().to_owned(),
+                    p("out"),
+                ]
             } else {
-                hg002_gvcf(
-                    &p("truth.vcf.gz"),
-                    &p("truth.bed"),
-                    &p("ref.fasta"),
-                    &p("sites.tsv"),
-                    &p("out"),
-                )
-                .map(|_| ())
+                vec![
+                    "hg002-gvcf".to_owned(),
+                    p("truth.vcf.gz"),
+                    p("truth.bed"),
+                    p("ref.fasta"),
+                    p("sites.tsv"),
+                    p("out"),
+                ]
+            };
+            let (mut out, mut err) = (Vec::new(), Vec::new());
+            match cli(&args, &mut out, &mut err) {
+                0 => Ok(()),
+                1 => Err(String::from_utf8(err).unwrap()),
+                code => panic!("unexpected CLI exit {code}: {err:?}"),
             }
         }
         fn fails_without_publication(&self) {
@@ -690,19 +804,31 @@ mod tests {
         }
     }
 
-
     #[test]
     fn explicit_compression_is_required_at_every_input() {
         for (kind, names) in [
             ("clashes", vec!["raw.vcf.gz", "split.vcf.gz", "chrA.tsv.gz"]),
-            ("hg002-gvcf", vec!["truth.vcf.gz", "truth.bed", "ref.fasta.fai", "sites.tsv"]),
+            (
+                "hg002-gvcf",
+                vec![
+                    "truth.vcf.gz",
+                    "truth.bed",
+                    "ref.fasta.fai",
+                    "ref.fasta",
+                    "sites.tsv",
+                ],
+            ),
         ] {
             for name in names {
                 let c = Case::new(kind, &format!("compression-{name}"));
                 let bytes = c.text(name);
-                let wrong = if name.ends_with(".gz") { bytes } else {
-                    let mut gz = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
-                    gz.write_all(&bytes).unwrap(); gz.finish().unwrap()
+                let wrong = if name.ends_with(".gz") {
+                    bytes
+                } else {
+                    let mut gz =
+                        flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+                    gz.write_all(&bytes).unwrap();
+                    gz.finish().unwrap()
                 };
                 fs::write(c.dir.join(name), wrong).unwrap();
                 c.fails_without_publication();
@@ -713,12 +839,17 @@ mod tests {
 
     #[test]
     fn bed_rejects_python_whitespace_inside_fields_and_as_separators() {
-        for ch in ['\u{2028}', '\u{85}', '\u{b}', '\u{a0}', '\u{1c}', '\u{1d}', '\u{1e}', '\u{1f}'] {
+        for ch in [
+            '\u{2028}', '\u{85}', '\u{b}', '\u{a0}', '\u{1c}', '\u{1d}', '\u{1e}', '\u{1f}',
+        ] {
             for embedded in [true, false] {
                 let c = Case::new("hg002-gvcf", &format!("space-{}-{embedded}", ch as u32));
                 let text = String::from_utf8(c.text("truth.bed")).unwrap();
-                let text = if embedded { text.replacen("chrA", &format!("chr{ch}A"), 1) }
-                           else { text.replace('\t', &ch.to_string()) };
+                let text = if embedded {
+                    text.replacen("chrA", &format!("chr{ch}A"), 1)
+                } else {
+                    text.replace('\t', &ch.to_string())
+                };
                 c.put("truth.bed", text.as_bytes());
                 c.fails_without_publication();
                 assert!(c.run().unwrap_err().contains("unsupported whitespace"));
@@ -736,16 +867,28 @@ mod tests {
         fs::set_permissions(&target, fs::Permissions::from_mode(0o600)).unwrap();
         symlink("target", &link).unwrap();
         publish(&link, b"new").unwrap();
-        assert!(fs::symlink_metadata(&link).unwrap().file_type().is_symlink());
+        assert!(
+            fs::symlink_metadata(&link)
+                .unwrap()
+                .file_type()
+                .is_symlink()
+        );
         assert_eq!(fs::read(&target).unwrap(), b"new");
-        assert_eq!(fs::metadata(&target).unwrap().permissions().mode() & 0o777, 0o600);
+        assert_eq!(
+            fs::metadata(&target).unwrap().permissions().mode() & 0o777,
+            0o600
+        );
         fs::set_permissions(&target, fs::Permissions::from_mode(0o444)).unwrap();
         assert!(publish(&link, b"bad").unwrap_err().contains("read-only"));
         assert_eq!(fs::read(&target).unwrap(), b"new");
         let dir_link = c.dir.join("dir-link");
         symlink(&c.dir, &dir_link).unwrap();
         for path in [&c.dir, &dir_link] {
-            assert!(publish(path, b"bad").unwrap_err().contains("not a regular file"));
+            assert!(
+                publish(path, b"bad")
+                    .unwrap_err()
+                    .contains("not a regular file")
+            );
         }
     }
 
@@ -753,7 +896,10 @@ mod tests {
     fn approved_strict_evidence_shapes_fail_with_stable_errors() {
         for value in ["3_0", "٣", "-3", "18446744073709551616"] {
             let c = Case::new("hg002-gvcf", value);
-            c.put("truth.vcf.gz", format!("chrA\t{value}\t.\tA\tC\n").as_bytes());
+            c.put(
+                "truth.vcf.gz",
+                format!("chrA\t{value}\t.\tA\tC\n").as_bytes(),
+            );
             c.fails_without_publication();
             assert!(c.run().unwrap_err().contains("not a number"));
         }
@@ -776,7 +922,11 @@ mod tests {
         let c = Case::new("clashes", "record-limit");
         c.put("raw.vcf.gz", &vec![b'#'; (16 << 20) + 1]);
         c.fails_without_publication();
-        assert!(c.run().unwrap_err().contains("record exceeds 16777216 bytes"));
+        assert!(
+            c.run()
+                .unwrap_err()
+                .contains("record exceeds 16777216 bytes")
+        );
         let c = Case::new("hg002-gvcf", "final-lf");
         c.run().unwrap();
         let expected = fs::read(c.dir.join("out")).unwrap();
diff --git a/rust/crates/og-dev/src/fixture.rs b/rust/crates/og-dev/src/fixture.rs
index eccfdc4fb..1ea2d5061 100644
--- a/rust/crates/og-dev/src/fixture.rs
+++ b/rust/crates/og-dev/src/fixture.rs
@@ -373,13 +373,24 @@ pub mod comphet {
         let seq = reference();
         let vs = variants(&seq, swap);
         fs::create_dir_all(dir).map_err(|e| format!("{}: {e}", dir.display()))?;
+        let mut staged = Vec::new();
         for (name, text) in [
             ("reads.sam", sam(&seq, &vs)),
             ("vep.vcf", vep_vcf(&vs)),
             ("comphet.vcf", comphet_vcf(&vs)),
         ] {
             let path = dir.join(name);
-            crate::evidence::publish(&path, text.as_bytes())?;
+            let (pending, mut file) = crate::evidence::PendingOutput::new(&path)?;
+            std::io::Write::write_all(&mut file, text.as_bytes())
+                .map_err(|e| format!("{}: {e}", path.display()))?;
+            std::io::Write::flush(&mut file).map_err(|e| format!("{}: {e}", path.display()))?;
+            drop(file);
+            staged.push(pending);
+        }
+        // Every file is staged and every destination checked before publication.
+        // Three renames are still not one transaction.
+        for pending in staged {
+            pending.commit()?;
         }
         Ok(())
     }
@@ -597,20 +608,43 @@ fn trim_pharmcat(src: &Path, dst: &Path, max: i64) -> Result<(), String> {
 mod tests {
     use super::*;
 
+    #[test]
+    fn pharmcat_input_is_plain_json() {
+        let d =
+            std::env::temp_dir().join(format!("og-pharmcat-compression-{}", std::process::id()));
+        fs::create_dir_all(&d).unwrap();
+        let mut gz = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+        gz.write_all(br#"{"genes":{},"drugs":{}}"#).unwrap();
+        fs::write(d.join("in"), gz.finish().unwrap()).unwrap();
+        fs::write(d.join("out"), b"old").unwrap();
+        let args = vec![
+            "trim-pharmcat".into(),
+            d.join("in").to_str().unwrap().into(),
+            d.join("out").to_str().unwrap().into(),
+        ];
+        let (mut out, mut err) = (Vec::new(), Vec::new());
+        assert_eq!(cli(&args, &mut out, &mut err), 1);
+        assert!(String::from_utf8_lossy(&err).contains("not UTF-8"));
+        assert_eq!(fs::read(d.join("out")).unwrap(), b"old");
+        fs::remove_dir_all(d).unwrap();
+    }
 
     #[test]
     fn comphet_validates_later_destinations_before_publishing() {
         let d = std::env::temp_dir().join(format!("og-comphet-preflight-{}", std::process::id()));
         let _ = fs::remove_dir_all(&d);
         fs::create_dir_all(d.join("comphet.vcf")).unwrap();
-        for name in ["reads.sam", "vep.vcf"] { fs::write(d.join(name), b"PREVIOUS OUTPUT").unwrap(); }
+        for name in ["reads.sam", "vep.vcf"] {
+            fs::write(d.join(name), b"PREVIOUS OUTPUT").unwrap();
+        }
         assert!(comphet::write(&d, false).is_err());
-        for name in ["reads.sam", "vep.vcf"] { assert_eq!(fs::read(d.join(name)).unwrap(), b"PREVIOUS OUTPUT"); }
+        for name in ["reads.sam", "vep.vcf"] {
+            assert_eq!(fs::read(d.join(name)).unwrap(), b"PREVIOUS OUTPUT");
+        }
         assert_eq!(fs::read_dir(&d).unwrap().count(), 3);
         fs::remove_dir_all(d).unwrap();
     }
 
-
     #[test]
     fn downloader_preflights_destinations_and_cleans_handled_failures() {
         use std::os::unix::fs::{PermissionsExt, symlink};
@@ -621,8 +655,16 @@ mod tests {
         let stub = d.join("bin/curl");
         fs::write(&stub, "#!/bin/sh\nprintf called >> \"$CALLED\"\nwhile [ \"$1\" != -o ]; do shift; done\nprintf partial > \"$2\"\nexit 22\n").unwrap();
         fs::set_permissions(&stub, fs::Permissions::from_mode(0o755)).unwrap();
-        let script = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../../tests/smoke/vntyper_testdata.sh");
-        for fault in ["directory", "directory-link", "curl", "crc", "sha", "signal"] {
+        let script =
+            Path::new(env!("CARGO_MANIFEST_DIR")).join("../../../tests/smoke/vntyper_testdata.sh");
+        for fault in [
+            "directory",
+            "directory-link",
+            "curl",
+            "crc",
+            "sha",
+            "signal",
+        ] {
             let out = d.join(fault);
             fs::create_dir(&out).unwrap();
             let dst = out.join("negative.bam");
@@ -646,14 +688,30 @@ mod tests {
             }
             let called = d.join("called");
             let _ = fs::remove_file(&called);
-            let result = Command::new("sh").arg(&script).arg(&out).arg("negative.bam")
-                .env("PATH", format!("{}:{}", d.join("bin").display(), std::env::var("PATH").unwrap()))
-                .env("CALLED", &called).output().unwrap();
+            let result = Command::new("sh")
+                .arg(&script)
+                .arg(&out)
+                .arg("negative.bam")
+                .env(
+                    "PATH",
+                    format!(
+                        "{}:{}",
+                        d.join("bin").display(),
+                        std::env::var("PATH").unwrap()
+                    ),
+                )
+                .env("CALLED", &called)
+                .output()
+                .unwrap();
             assert!(!result.status.success(), "{fault}");
-            if fault.starts_with("directory") { assert!(!called.exists(), "must reject before curl: {fault}"); }
-            else {
+            if fault.starts_with("directory") {
+                assert!(!called.exists(), "must reject before curl: {fault}");
+            } else {
                 assert_eq!(fs::read(&dst).unwrap(), b"PREVIOUS OUTPUT", "{fault}");
-                let entries: Vec<_> = fs::read_dir(&out).unwrap().map(|e| e.unwrap().file_name()).collect();
+                let entries: Vec<_> = fs::read_dir(&out)
+                    .unwrap()
+                    .map(|e| e.unwrap().file_name())
+                    .collect();
                 assert_eq!(entries.len(), 2, "{fault}: {entries:?}");
             }
         }
@@ -665,15 +723,34 @@ mod tests {
         let d = std::env::temp_dir().join(format!("og-pharmcat-shapes-{}", std::process::id()));
         fs::create_dir_all(&d).unwrap();
         for (input, class) in [
-            (r#"{"genes":{"G":{"sourceDiplotypes":"x"}},"drugs":{}}"#, "sourceDiplotypes is not a list"),
-            (r#"{"genes":{"G":{"recommendationDiplotypes":"x"}},"drugs":{}}"#, "recommendationDiplotypes is not a list"),
-            (r#"{"genes":{"G":{"sourceDiplotypes":[{"allele1":"x"}]}},"drugs":{}}"#, "allele1 is not an object"),
-            (r#"{"genes":{"G":{"sourceDiplotypes":[{"allele2":["x"]}]}},"drugs":{}}"#, "allele2 is not an object"),
-            (r#"{"genes":{},"drugs":{"S":{"D":{"guidelines":[{"annotations":[{"genotypes":[{"diplotypes":{"x":1}}]}]}]}}}}"#, "diplotypes is not a list"),
+            (
+                r#"{"genes":{"G":{"sourceDiplotypes":"x"}},"drugs":{}}"#,
+                "sourceDiplotypes is not a list",
+            ),
+            (
+                r#"{"genes":{"G":{"recommendationDiplotypes":"x"}},"drugs":{}}"#,
+                "recommendationDiplotypes is not a list",
+            ),
+            (
+                r#"{"genes":{"G":{"sourceDiplotypes":[{"allele1":"x"}]}},"drugs":{}}"#,
+                "allele1 is not an object",
+            ),
+            (
+                r#"{"genes":{"G":{"sourceDiplotypes":[{"allele2":["x"]}]}},"drugs":{}}"#,
+                "allele2 is not an object",
+            ),
+            (
+                r#"{"genes":{},"drugs":{"S":{"D":{"guidelines":[{"annotations":[{"genotypes":[{"diplotypes":{"x":1}}]}]}]}}}}"#,
+                "diplotypes is not a list",
+            ),
         ] {
             fs::write(d.join("in"), input).unwrap();
             fs::write(d.join("out"), b"old").unwrap();
-            let args = vec!["trim-pharmcat".into(), d.join("in").to_str().unwrap().into(), d.join("out").to_str().unwrap().into()];
+            let args = vec![
+                "trim-pharmcat".into(),
+                d.join("in").to_str().unwrap().into(),
+                d.join("out").to_str().unwrap().into(),
+            ];
             let (mut out, mut err) = (Vec::new(), Vec::new());
             assert_eq!(cli(&args, &mut out, &mut err), 1);
             assert!(String::from_utf8_lossy(&err).contains(class), "{err:?}");
diff --git a/rust/crates/og-dev/src/renovate.rs b/rust/crates/og-dev/src/renovate.rs
index 87a368999..e79644344 100644
--- a/rust/crates/og-dev/src/renovate.rs
+++ b/rust/crates/og-dev/src/renovate.rs
@@ -119,7 +119,7 @@ fn cli_with_summary(
             return 2;
         }
     };
-    let env_text = match fs::read_to_string(repo.join(ENV)) {
+    let env_text = match crate::evidence::read_text(&repo.join(ENV)) {
         Ok(t) => t,
         Err(e) => {
             let _ = writeln!(err, "og dev renovate-check: {ENV}: {e}");
@@ -222,7 +222,7 @@ fn glob(repo: &Path, pattern: &str) -> Result<Vec<String>, String> {
 }
 
 fn read_pins(repo: &Path, path: &Path) -> Result<Pins, String> {
-    let text = fs::read_to_string(path).map_err(|e| format!("{}: {e}", path.display()))?;
+    let text = crate::evidence::read_text(path)?;
     let mut pins = Pins {
         want: BTreeMap::new(),
         files: HashMap::new(),
@@ -246,7 +246,7 @@ fn read_pins(repo: &Path, path: &Path) -> Result<Pins, String> {
         }
         for f in glob(repo, files).map_err(|e| at(&e))? {
             if !texts.contains_key(&f) {
-                let t = fs::read_to_string(repo.join(&f)).map_err(|e| at(&format!("{f}: {e}")))?;
+                let t = crate::evidence::read_text(&repo.join(&f)).map_err(|e| at(&e))?;
                 texts.insert(f.clone(), t);
             }
             let n = re.find_iter(&texts[&f]).count();
@@ -300,14 +300,17 @@ fn load(log: &str) -> Result<Vec<Dep>, String> {
             let Value::Object(mut pf) = pf else {
                 return Err(shape());
             };
-            let Some(Value::Str(name)) = pf.swap_remove("packageFile") else {
-                return Err(shape());
-            };
             let ds = match pf.swap_remove("deps") {
                 None => Vec::new(),
                 Some(Value::Array(ds)) => ds,
                 _ => return Err(shape()),
             };
+            if ds.is_empty() {
+                continue;
+            }
+            let Some(Value::Str(name)) = pf.swap_remove("packageFile") else {
+                return Err(shape());
+            };
             for d in ds {
                 let Value::Object(d) = d else {
                     return Err(shape());
@@ -343,7 +346,7 @@ fn load(log: &str) -> Result<Vec<Dep>, String> {
                         return Err(shape());
                     }
                 }
-                if let Some(ws) = d.get("warnings") {
+                if let Some(ws) = d.get("warnings").filter(|v| truthy(v)) {
                     let Value::Array(ws) = ws else {
                         return Err(shape());
                     };
@@ -917,7 +920,23 @@ mod tests {
                 r#"{"packageFile":"unused","deps":[{"updates":[42]}]}"#,
             ),
             ("scalar-dep", r#"{"packageFile":"unused","deps":[42]}"#),
-            ("scalar-file", r#"{"packageFile":[],"deps":[]}"#),
+            ("scalar-file", r#"{"packageFile":[],"deps":[{}]}"#),
+            (
+                "map-updates",
+                r#"{"packageFile":"unused","deps":[{"updates":{}}]}"#,
+            ),
+            (
+                "number-update",
+                r#"{"packageFile":"unused","deps":[{"updates":[{"newValue":0}]}]}"#,
+            ),
+            (
+                "number-name",
+                r#"{"packageFile":"unused","deps":[{"depName":0}]}"#,
+            ),
+            (
+                "number-current",
+                r#"{"packageFile":"unused","deps":[{"currentValue":0}]}"#,
+            ),
         ] {
             let d = planted(label);
             let log = fs::read_to_string(d.join("renovate.log")).unwrap();
@@ -925,6 +944,10 @@ mod tests {
             fs::write(d.join("renovate.log"), log).unwrap();
             let (code, out) = run(&d);
             assert_eq!(code, 1, "{label}: {out}");
+            assert!(
+                out.contains("not a map of package file lists"),
+                "{label}: {out}"
+            );
             fs::remove_dir_all(d).unwrap();
         }
         for (label, prefix) in [
@@ -941,14 +964,19 @@ mod tests {
         }
     }
 
-
     #[test]
     fn repository_sources_use_universal_newlines() {
         for name in [ENV, PINS, ".github/workflows/ci.yml"] {
             for ending in ["\r", "\r\n"] {
-                let d = planted(&format!("newlines-{}-{}", name.replace('/', "-"), ending.len()));
+                let d = planted(&format!(
+                    "newlines-{}-{}",
+                    name.replace('/', "-"),
+                    ending.len()
+                ));
                 let baseline = run(&d);
-                let text = fs::read_to_string(d.join(name)).unwrap().replace('\n', ending);
+                let text = fs::read_to_string(d.join(name))
+                    .unwrap()
+                    .replace('\n', ending);
                 fs::write(d.join(name), text).unwrap();
                 assert_eq!(run(&d), baseline, "{name}/{ending:?}");
                 fs::remove_dir_all(d).unwrap();
@@ -958,20 +986,42 @@ mod tests {
 
     #[test]
     fn real_log_falsy_warnings_and_absent_empty_packages_are_accepted() {
-        for entry in [r#"{}"#, r#"{"deps":[]}"#, r#"{"deps":[],"packageFile":[]}"#,
+        for entry in [
+            r#"{}"#,
+            r#"{"deps":[]}"#,
+            r#"{"deps":[],"packageFile":[]}"#,
             r#"{"packageFile":"unused","deps":[{"warnings":null}]}"#,
             r#"{"packageFile":"unused","deps":[{"warnings":false}]}"#,
             r#"{"packageFile":"unused","deps":[{"warnings":""}]}"#,
-            r#"{"packageFile":"unused","deps":[{"warnings":{}}]}"#] {
+            r#"{"packageFile":"unused","deps":[{"warnings":{}}]}"#,
+        ] {
             let d = planted("falsy");
             let log = fs::read_to_string(d.join("renovate.log")).unwrap();
-            fs::write(d.join("renovate.log"), log.replacen(r#""regex":["#, &format!(r#""regex":[{entry},"#), 1)).unwrap();
+            fs::write(
+                d.join("renovate.log"),
+                log.replacen(r#""regex":["#, &format!(r#""regex":[{entry},"#), 1),
+            )
+            .unwrap();
             let (code, out) = run(&d);
             assert_eq!(code, 0, "{entry}: {out}");
             fs::remove_dir_all(d).unwrap();
         }
     }
 
+    #[test]
+    fn repository_sources_reject_gzip_even_under_plain_names() {
+        for name in [ENV, PINS, ".github/workflows/ci.yml"] {
+            let d = planted(&format!("compressed-{}", name.replace('/', "-")));
+            let mut gz = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+            gz.write_all(&fs::read(d.join(name)).unwrap()).unwrap();
+            fs::write(d.join(name), gz.finish().unwrap()).unwrap();
+            let (code, out) = run(&d);
+            assert_eq!(code, 2, "{out}");
+            assert!(out.contains("wrong compression"), "{out}");
+            fs::remove_dir_all(d).unwrap();
+        }
+    }
+
     #[test]
     fn renovate_requires_plain_compression_and_pins_record_limit() {
         let d = planted("compression-limit");
@@ -980,10 +1030,12 @@ mod tests {
         gz.write_all(&text).unwrap();
         fs::write(d.join("renovate.log"), gz.finish().unwrap()).unwrap();
         let (code, out) = run(&d);
-        assert_eq!(code, 1); assert!(out.contains("compression"), "{out}");
+        assert_eq!(code, 1);
+        assert!(out.contains("compression"), "{out}");
         fs::write(d.join("renovate.log"), vec![b'x'; (16 << 20) + 1]).unwrap();
         let (code, out) = run(&d);
-        assert_eq!(code, 1); assert!(out.contains("record exceeds 16777216 bytes"), "{out}");
+        assert_eq!(code, 1);
+        assert!(out.contains("record exceeds 16777216 bytes"), "{out}");
         fs::remove_dir_all(d).unwrap();
     }
 
diff --git a/tests/smoke/vntyper_testdata.sh b/tests/smoke/vntyper_testdata.sh
index e6d7da2a8..73c41d89c 100755
--- a/tests/smoke/vntyper_testdata.sh
+++ b/tests/smoke/vntyper_testdata.sh
@@ -44,12 +44,46 @@ shift
 for name in "$@"; do
   member "$name" > /dev/null || { echo "vntyper_testdata.sh: unknown member ${name} (positive.bam, negative.bam)" >&2; exit 2; }
 done
+# GNU mv's -T rejects a directory even if it appears during publication.
+# Homebrew calls it gmv on macOS; the pinned Linux image calls it mv.
+if command -v gmv > /dev/null 2>&1; then move="gmv"; else move="mv"; fi
+
+# Resolve file symlinks, including relative/dangling targets, before staging.
+destination() {
+  dest="${out}/${1}"
+  links=0
+  while [ -L "$dest" ]; do
+    links=$((links + 1))
+    [ "$links" -le 40 ] || { echo "destination: too many symlinks: $dest" >&2; return 1; }
+    target=$(readlink "$dest"; printf x)
+    target=${target%x}
+    target=${target%'
+'}
+    case $target in
+      /*) dest=$target ;;
+      *) dest="${dest%/*}/$target" ;;
+    esac
+  done
+  [ ! -d "$dest" ] || { echo "destination is a directory: $dest" >&2; return 1; }
+  if [ -e "$dest" ]; then
+    [ -f "$dest" ] && [ -w "$dest" ] || { echo "destination is not a writable regular file: $dest" >&2; return 1; }
+  fi
+}
+
+work=
+cleanup() { [ -z "$work" ] || rm -rf "$work"; }
+trap cleanup EXIT
+trap 'exit 1' HUP INT TERM
 mkdir -p "$out"
+# A bad destination must fail before any network request.
+for name in "$@"; do destination "$name"; done
 for name in "$@"; do
   read -r path off csize size crc want <<EOF
 $(member "$name")
 EOF
-  part="${out}/${name}.part"
+  destination "$name"
+  work=$(mktemp -d "${dest%/*}/.vntyper.XXXXXXXX")
+  part="${work}/payload"
   # The pinned VNtyper image's curl does not support --retry-all-errors.
   curl -fsSL --retry 4 --retry-delay 15 -r "${off}-$((off + csize - 1))" -o "${part}.raw" "$URL"
   got=$(wc -c < "${part}.raw" | tr -d ' ')
@@ -61,6 +95,16 @@ EOF
   got=$(sha256sum < "$part" | cut -d' ' -f1)
   [ "$got" = "$want" ] || { echo "${path}: sha256 ${got}, pinned ${want}" >&2; exit 1; }
   rm -f "${part}.raw" "${part}.gz"
-  mv "$part" "${out}/${name}"
+  # Preserve the Python output mode. New files inherit the caller's umask.
+  if [ -e "$dest" ]; then
+    case $(uname -s) in
+      Darwin) mode=$(stat -f '%Lp' "$dest") ;;
+      *) mode=$(stat -c '%a' "$dest") ;;
+    esac
+    chmod "$mode" "$part"
+  fi
+  "$move" -fT "$part" "$dest"
+  cleanup
+  work=
   printf '%s\t%s\t%s\t%s\n' "$name" "$path" "$size" "$got"
 done

From da245a62c392b6c89d3593c5251641f95e7c2d80 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 18:47:05 +0100
Subject: [PATCH 62/76] fix(dev): preserve special mode bits after staged
 writes

---
 rust/crates/og-dev/src/evidence.rs | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/rust/crates/og-dev/src/evidence.rs b/rust/crates/og-dev/src/evidence.rs
index 64251aa40..2210e9e5b 100644
--- a/rust/crates/og-dev/src/evidence.rs
+++ b/rust/crates/og-dev/src/evidence.rs
@@ -235,7 +235,12 @@ impl PendingOutput {
     }
 
     pub(crate) fn commit(self) -> Result<(), String> {
-        validate_destination(&self.destination)?;
+        if let Some(permissions) = validate_destination(&self.destination)? {
+            // A write can clear set-user-ID or set-group-ID bits. Apply the
+            // final mode after every byte is staged, immediately before rename.
+            fs::set_permissions(&self.path, permissions)
+                .map_err(|e| format!("{}: {e}", self.destination.display()))?;
+        }
         fs::rename(&self.path, &self.destination)
             .map_err(|e| format!("{}: {e}", self.destination.display()))
     }
@@ -878,6 +883,12 @@ mod tests {
             fs::metadata(&target).unwrap().permissions().mode() & 0o777,
             0o600
         );
+        fs::set_permissions(&target, fs::Permissions::from_mode(0o4600)).unwrap();
+        publish(&link, b"new").unwrap();
+        assert_eq!(
+            fs::metadata(&target).unwrap().permissions().mode() & 0o7777,
+            0o4600
+        );
         fs::set_permissions(&target, fs::Permissions::from_mode(0o444)).unwrap();
         assert!(publish(&link, b"bad").unwrap_err().contains("read-only"));
         assert_eq!(fs::read(&target).unwrap(), b"new");

From 154fd3b8fcb3b5c978b4d50d50d7422af789a331 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 18:51:57 +0100
Subject: [PATCH 63/76] fix(dev): keep present Renovate package file values
 typed

---
 rust/crates/og-dev/src/renovate.rs | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/rust/crates/og-dev/src/renovate.rs b/rust/crates/og-dev/src/renovate.rs
index e79644344..c206ac819 100644
--- a/rust/crates/og-dev/src/renovate.rs
+++ b/rust/crates/og-dev/src/renovate.rs
@@ -305,12 +305,17 @@ fn load(log: &str) -> Result<Vec<Dep>, String> {
                 Some(Value::Array(ds)) => ds,
                 _ => return Err(shape()),
             };
+            let name = match pf.swap_remove("packageFile") {
+                None => None,
+                Some(Value::Str(name)) => Some(name),
+                // An unused field may be absent, but a present wrong type is
+                // still a deliberate input error.
+                _ => return Err(shape()),
+            };
             if ds.is_empty() {
                 continue;
             }
-            let Some(Value::Str(name)) = pf.swap_remove("packageFile") else {
-                return Err(shape());
-            };
+            let name = name.ok_or_else(shape)?;
             for d in ds {
                 let Value::Object(d) = d else {
                     return Err(shape());
@@ -920,7 +925,7 @@ mod tests {
                 r#"{"packageFile":"unused","deps":[{"updates":[42]}]}"#,
             ),
             ("scalar-dep", r#"{"packageFile":"unused","deps":[42]}"#),
-            ("scalar-file", r#"{"packageFile":[],"deps":[{}]}"#),
+            ("scalar-file", r#"{"packageFile":[],"deps":[]}"#),
             (
                 "map-updates",
                 r#"{"packageFile":"unused","deps":[{"updates":{}}]}"#,
@@ -989,7 +994,6 @@ mod tests {
         for entry in [
             r#"{}"#,
             r#"{"deps":[]}"#,
-            r#"{"deps":[],"packageFile":[]}"#,
             r#"{"packageFile":"unused","deps":[{"warnings":null}]}"#,
             r#"{"packageFile":"unused","deps":[{"warnings":false}]}"#,
             r#"{"packageFile":"unused","deps":[{"warnings":""}]}"#,

From 51af87848944d67c12f9d7745f1badd41660d156 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 18:52:22 +0100
Subject: [PATCH 64/76] fix(ci): guard effective regex cases and every selected
 path

---
 .github/workflows/guard.yml                   |  40 +-
 CHANGELOG.md                                  |   2 +
 rust/crates/og-dev/src/personal_data.rs       | 447 +++++++++++++++++-
 scripts/ci/check-personal-data.sh             |  23 +-
 .../parity/gen/personal-unicode-generator.rs  |   9 +-
 5 files changed, 487 insertions(+), 34 deletions(-)

diff --git a/.github/workflows/guard.yml b/.github/workflows/guard.yml
index 0383d5894..0193baec6 100644
--- a/.github/workflows/guard.yml
+++ b/.github/workflows/guard.yml
@@ -265,9 +265,13 @@ jobs:
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
-      # Keep both ends of the Unicode-version differential available. The
+      # Keep Python 3.9's regex cases and the newer Unicode tables available. The
       # scanner fails closed on version-dependent scalars; span iteration
       # intentionally uses Python 3.14+ semantics for empty-text \B.
+      - uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0
+        with:
+          python-version: '3.9'
+
       - uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0
         with:
           python-version: '3.12'
@@ -384,6 +388,40 @@ jobs:
           done
           echo "Control: all 24 Unicode and four symlink scenarios failed before the fix."
 
+      - name: Scanner round-five controls (all five findings must fail before the fix)
+        run: |
+          source=crates/og-dev/src/personal_data.rs
+          cp "$source" "${RUNNER_TEMP}/round5-personal-fixed.rs"
+          trap 'cp "${RUNNER_TEMP}/round5-personal-fixed.rs" "$source"' EXIT
+          before=f155efd343e82ebf8b53a563ee4b2c5b6f4dbf85
+          git cat-file -e "$before^{commit}" 2>/dev/null || git fetch --quiet --depth=1 origin "$before"
+          git show "$before:rust/$source" > "$source"
+          log="${RUNNER_TEMP}/scanner-round5-red.log"
+          rc=0
+          cargo test -p og-dev --locked --no-fail-fast round5_ > "$log" 2>&1 || rc=$?
+          cat "$log"
+          [ "$rc" -ne 0 ]
+          for test in regex_case_relations stable_case_scalars_pass gitlinks_fail_closed guard_filenames every_symlink_hop; do
+            grep -E "round5_${test} .*FAILED" "$log" || { echo "ERROR: missing round-five red control"; exit 1; }
+          done
+          echo "Control: all five round-five regressions failed before the fix."
+
+      - name: Regex relation verifier rejects a missing table
+        run: |
+          source=crates/og-dev/src/personal_data.rs
+          cp "$source" "${RUNNER_TEMP}/regex-case-fixed.rs"
+          trap 'cp "${RUNNER_TEMP}/regex-case-fixed.rs" "$source"' EXIT
+          awk '/^const REGEX_CASE_RELATIONS:/ { print "const REGEX_CASE_RELATIONS: &[(u32, u32)] = &[];"; drop=1 }
+               drop && /^];/ { drop=0; next }
+               !drop { print }' "${RUNNER_TEMP}/regex-case-fixed.rs" > "$source"
+          log="${RUNNER_TEMP}/regex-table-red.log"
+          rc=0
+          cargo test -p og-dev --locked --no-fail-fast round5_regex_case_table_matches_interpreters > "$log" 2>&1 || rc=$?
+          cat "$log"
+          [ "$rc" -ne 0 ]
+          grep 'checked-in regex table misses a differing pair' "$log"
+          echo "Control: real regex engines rejected the incomplete table."
+
       - name: Scanner matcher controls (word classes and swallowed errors must be caught)
         run: |
           source=crates/og-dev/src/lookaround.rs
diff --git a/CHANGELOG.md b/CHANGELOG.md
index f817f87f7..e51366d08 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,8 @@ Each release's notes. From 1.0.0 on, a major or minor release has hand-written n
 
 ## Unreleased
 
+- The personal-data guard now includes effective Python regex case relations, including Python 3.9 Cyrillic differences. Six stable older scalars pass again. Selected filenames get the same Unicode guard before exclusions, with a generic redacted error. Cached gitlinks and unreadable indexed objects fail with exit 2 unless skipped. Working-copy symlinks validate every hop, including directory components, with a 40-hop bound. The 248 newer stable scalars remain conservatively blocked.
+
 - The personal-data scan fails closed with redacted exit 2 on Unicode-version-dependent text, patterns and ALLOW/SKIP entries. Its generated guard covers UCD 13/15/16/17 and unassigned scalars. Newer emoji and plain symbols still scan. Files with newer script letters need an ASCII SKIP glob. Invalid UTF-8 symlink targets now fail before exclusions in working-copy and index scans.
 
 - The personal-data scan, the image scan and the version checks of CI now run in the Rust `og` binary: `og dev scan personal-data` (`scripts/ci/check-personal-data.sh`), `og dev scan images` and `og dev versions coupled` (`scripts/ci/check-images.sh`), `og dev versions check-run` (`scripts/ci/gen-containers-config.sh --check-versions`), `og dev versions expand` (`scripts/ci/check-links.sh`) and `og dev pgs` (`scripts/ci/check-pgs-labels.sh`). The scripts keep their options and lists; the Python inside them is gone. Fixes:
diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
index 2b51ca0ba..0b19ad1a1 100644
--- a/rust/crates/og-dev/src/personal_data.rs
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -26,7 +26,7 @@
 //! file is placed under DIR after resolving symbolic links in both, so
 //! DIR given as `/tmp/x` still finds `/private/tmp/x/CLAUDE.md`'s examples.
 
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 use std::io::{BufRead, BufReader, Read, Write};
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
@@ -49,9 +49,7 @@ const VERSION_DEPENDENT: &[(u32, u32)] = &[
     (0x380, 0x383),
     (0x38b, 0x38b),
     (0x38d, 0x38d),
-    (0x390, 0x390),
     (0x3a2, 0x3a2),
-    (0x3b0, 0x3b0),
     (0x530, 0x530),
     (0x557, 0x558),
     (0x58b, 0x58c),
@@ -284,9 +282,8 @@ const VERSION_DEPENDENT: &[(u32, u32)] = &[
     (0x1f7e, 0x1f7f),
     (0x1fb5, 0x1fb5),
     (0x1fc5, 0x1fc5),
-    (0x1fd3, 0x1fd5),
+    (0x1fd4, 0x1fd5),
     (0x1fdc, 0x1fdc),
-    (0x1fe3, 0x1fe3),
     (0x1ff0, 0x1ff1),
     (0x1ff5, 0x1ff5),
     (0x1fff, 0x1fff),
@@ -363,7 +360,7 @@ const VERSION_DEPENDENT: &[(u32, u32)] = &[
     (0xd7fc, 0xd7ff),
     (0xfa6e, 0xfa6f),
     (0xfada, 0xfaff),
-    (0xfb05, 0xfb12),
+    (0xfb07, 0xfb12),
     (0xfb18, 0xfb1c),
     (0xfb37, 0xfb37),
     (0xfb3d, 0xfb3d),
@@ -739,6 +736,145 @@ const VERSION_DEPENDENT: &[(u32, u32)] = &[
 ];
 // END GENERATED UNICODE GUARD
 
+// BEGIN GENERATED REGEX CASE RELATIONS
+// Generated by round5_regex_case_table_matches_interpreters; decimal Unicode scalar pairs.
+// Both endpoints of each differing real re.IGNORECASE relation are refused.
+// Python 3.11.16 14.0.0
+// Python 3.12.14 15.0.0
+// Python 3.13.15 15.1.0
+// Python 3.14.7 16.0.0
+// Python 3.15.0rc2 17.0.0
+// Python 3.9.6 13.0.0
+const REGEX_CASE_RELATIONS: &[(u32, u32)] = &[
+    (411, 42972),
+    (612, 42955),
+    (1042, 7296),
+    (1044, 7297),
+    (1054, 7298),
+    (1057, 7299),
+    (1058, 7300),
+    (1058, 7301),
+    (1066, 7302),
+    (1074, 7296),
+    (1076, 7297),
+    (1086, 7298),
+    (1089, 7299),
+    (1090, 7300),
+    (1090, 7301),
+    (1098, 7302),
+    (1122, 7303),
+    (1123, 7303),
+    (7300, 7301),
+    (7304, 42570),
+    (7304, 42571),
+    (7305, 7306),
+    (11311, 11359),
+    (42944, 42945),
+    (42956, 42957),
+    (42958, 42959),
+    (42960, 42961),
+    (42962, 42963),
+    (42964, 42965),
+    (42966, 42967),
+    (42968, 42969),
+    (42970, 42971),
+    (66928, 66967),
+    (66929, 66968),
+    (66930, 66969),
+    (66931, 66970),
+    (66932, 66971),
+    (66933, 66972),
+    (66934, 66973),
+    (66935, 66974),
+    (66936, 66975),
+    (66937, 66976),
+    (66938, 66977),
+    (66940, 66979),
+    (66941, 66980),
+    (66942, 66981),
+    (66943, 66982),
+    (66944, 66983),
+    (66945, 66984),
+    (66946, 66985),
+    (66947, 66986),
+    (66948, 66987),
+    (66949, 66988),
+    (66950, 66989),
+    (66951, 66990),
+    (66952, 66991),
+    (66953, 66992),
+    (66954, 66993),
+    (66956, 66995),
+    (66957, 66996),
+    (66958, 66997),
+    (66959, 66998),
+    (66960, 66999),
+    (66961, 67000),
+    (66962, 67001),
+    (66964, 67003),
+    (66965, 67004),
+    (68944, 68976),
+    (68945, 68977),
+    (68946, 68978),
+    (68947, 68979),
+    (68948, 68980),
+    (68949, 68981),
+    (68950, 68982),
+    (68951, 68983),
+    (68952, 68984),
+    (68953, 68985),
+    (68954, 68986),
+    (68955, 68987),
+    (68956, 68988),
+    (68957, 68989),
+    (68958, 68990),
+    (68959, 68991),
+    (68960, 68992),
+    (68961, 68993),
+    (68962, 68994),
+    (68963, 68995),
+    (68964, 68996),
+    (68965, 68997),
+    (93856, 93883),
+    (93857, 93884),
+    (93858, 93885),
+    (93859, 93886),
+    (93860, 93887),
+    (93861, 93888),
+    (93862, 93889),
+    (93863, 93890),
+    (93864, 93891),
+    (93865, 93892),
+    (93866, 93893),
+    (93867, 93894),
+    (93868, 93895),
+    (93869, 93896),
+    (93870, 93897),
+    (93871, 93898),
+    (93872, 93899),
+    (93873, 93900),
+    (93874, 93901),
+    (93875, 93902),
+    (93876, 93903),
+    (93877, 93904),
+    (93878, 93905),
+    (93879, 93906),
+    (93880, 93907),
+];
+// END GENERATED REGEX CASE RELATIONS
+
+// Generated separately from real Python regex engines. String case mappings
+// do not describe re.IGNORECASE, notably the Python 3.9 Cyrillic relations.
+static REGEX_CASE_ENDPOINTS: LazyLock<Vec<u32>> = LazyLock::new(|| {
+    let mut points: Vec<u32> = REGEX_CASE_RELATIONS
+        .iter()
+        .flat_map(|&(a, b)| [a, b])
+        .collect();
+    points.sort_unstable();
+    points.dedup();
+    points
+});
+
 pub(super) fn version_dependent(c: char) -> bool {
     if c.is_ascii() {
         return false;
@@ -748,6 +884,7 @@ pub(super) fn version_dependent(c: char) -> bool {
     VERSION_DEPENDENT
         .get(at)
         .is_some_and(|&(start, _)| start <= c)
+        || REGEX_CASE_ENDPOINTS.binary_search(&c).is_ok()
 }
 
 fn validate_unicode(text: &str, file: &str, mode: Lines) -> Result<(), String> {
@@ -1012,7 +1149,9 @@ fn own_rules(path: &str) -> Result<Vec<Check>, String> {
 /// `path` relative to `root` when it lies below it (both with symbolic
 /// links resolved), else `path` as given.
 fn relative(path: &Path, root: &Path) -> Result<String, String> {
-    utf8_path(path)?;
+    if utf8_path(path)?.chars().any(version_dependent) {
+        return Err("selected filename has Unicode version-dependent text".into());
+    }
     let abs = if path.is_absolute() {
         path.to_path_buf()
     } else {
@@ -1026,6 +1165,9 @@ fn relative(path: &Path, root: &Path) -> Result<String, String> {
             .map_or_else(|_| abs.clone(), |d| d.join(name)),
         _ => abs.clone(),
     };
+    if utf8_path(&placed)?.chars().any(version_dependent) {
+        return Err("selected filename has Unicode version-dependent text".into());
+    }
     match placed.strip_prefix(root) {
         Ok(rel) if !rel.as_os_str().is_empty() => utf8_path(rel).map(str::to_owned),
         _ => utf8_path(path).map(str::to_owned),
@@ -1061,7 +1203,7 @@ fn git_files(root: &Path) -> Result<Vec<PathBuf>, String> {
 
 /// The index owns symlink identity in cached mode, even if the working copy
 /// is absent, replaced by a regular file, or has a different target.
-fn index_symlinks(root: &Path) -> Result<HashSet<String>, String> {
+fn index_entries(root: &Path) -> Result<HashMap<String, String>, String> {
     let output = Command::new("git")
         .arg("-C")
         .arg(root)
@@ -1071,23 +1213,41 @@ fn index_symlinks(root: &Path) -> Result<HashSet<String>, String> {
     if !output.status.success() {
         return Err("cannot read Git index".into());
     }
-    let mut links = HashSet::new();
+    let mut entries = HashMap::new();
     for entry in output.stdout.split(|&b| b == 0).filter(|e| !e.is_empty()) {
         let tab = entry
             .iter()
             .position(|&b| b == b'\t')
             .ok_or("invalid Git index entry")?;
         let name = std::str::from_utf8(&entry[tab + 1..]).map_err(|_| "path is not valid UTF-8")?;
-        if entry.starts_with(b"120000 ") {
-            links.insert(name.to_owned());
-        }
+        let mode = std::str::from_utf8(&entry[..tab])
+            .map_err(|_| "invalid Git index entry")?
+            .split(' ')
+            .next()
+            .ok_or("invalid Git index entry")?;
+        entries.insert(name.to_owned(), mode.to_owned());
     }
-    Ok(links)
+    Ok(entries)
 }
 
 /// The staged blob of each path (relative to `root`), from one
 /// `git cat-file --batch`. A path with no blob in the index is absent.
 fn staged(root: &Path, rels: &[String]) -> Result<HashMap<String, Vec<u8>>, String> {
+    let entries = index_entries(root)?;
+    let unsupported = |rel: &str| {
+        format!(
+            "{}: indexed entry is not a readable blob",
+            rel.escape_debug()
+        )
+    };
+    for rel in rels {
+        if entries
+            .get(rel)
+            .is_some_and(|mode| !matches!(mode.as_str(), "100644" | "100755" | "120000"))
+        {
+            return Err(unsupported(rel));
+        }
+    }
     let wanted: Vec<&String> = rels.iter().collect();
     let mut blobs = HashMap::new();
     if wanted.is_empty() {
@@ -1108,6 +1268,7 @@ fn staged(root: &Path, rels: &[String]) -> Result<HashMap<String, Vec<u8>>, Stri
         .collect();
     let writer = std::thread::spawn(move || stdin.write_all(&input));
     let mut out = BufReader::new(child.stdout.take().ok_or("no stdout for git")?);
+    let mut unreadable = None;
     for rel in &wanted {
         let mut header = Vec::new();
         if out.read_until(0, &mut header).map_err(|e| e.to_string())? == 0 {
@@ -1120,7 +1281,10 @@ fn staged(root: &Path, rels: &[String]) -> Result<HashMap<String, Vec<u8>>, Stri
             std::str::from_utf8(&header).map_err(|_| "git cat-file: invalid header encoding")?;
         let fields: Vec<&str> = head.split(' ').collect();
         let [_, kind, size] = fields[..] else {
-            continue; // "<name> missing" or "ambiguous"
+            if entries.contains_key(*rel) {
+                unreadable.get_or_insert_with(|| unsupported(rel));
+            }
+            continue; // An explicit untracked path has no index object.
         };
         let size: usize = size
             .parse()
@@ -1130,6 +1294,8 @@ fn staged(root: &Path, rels: &[String]) -> Result<HashMap<String, Vec<u8>>, Stri
         data.pop();
         if kind == "blob" {
             blobs.insert((*rel).clone(), data);
+        } else {
+            unreadable.get_or_insert_with(|| unsupported(rel));
         }
     }
     writer
@@ -1139,9 +1305,47 @@ fn staged(root: &Path, rels: &[String]) -> Result<HashMap<String, Vec<u8>>, Stri
     if !child.wait().map_err(|e| e.to_string())?.success() {
         return Err("git cat-file failed".into());
     }
+    if let Some(error) = unreadable {
+        return Err(error);
+    }
     Ok(blobs)
 }
 
+/// Validate components as well as terminal links: the OS can follow a link
+/// in a directory component of any target. A bounded queue avoids recursion
+/// and catches cycles before the subsequent read follows them.
+fn validate_symlink_chain(path: &Path) -> Result<(), String> {
+    let mut pending: std::collections::VecDeque<_> = path
+        .components()
+        .map(|c| c.as_os_str().to_os_string())
+        .collect();
+    let mut prefix = PathBuf::new();
+    let mut hops = 0;
+    while let Some(component) = pending.pop_front() {
+        prefix.push(component);
+        match std::fs::read_link(&prefix) {
+            Ok(target) => {
+                utf8_path(&target)?;
+                hops += 1;
+                if hops > 40 {
+                    return Err("cannot validate symlink target".into());
+                }
+                prefix.pop();
+                if target.is_absolute() {
+                    prefix.clear();
+                }
+                for part in target.components().rev() {
+                    pending.push_front(part.as_os_str().to_os_string());
+                }
+            }
+            Err(e) if e.kind() == std::io::ErrorKind::InvalidInput => {}
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(()),
+            Err(_) => return Err("cannot validate symlink target".into()),
+        }
+    }
+    Ok(())
+}
+
 /// Reports metadata only. Escape control characters in paths so each
 /// finding occupies one line, including filenames containing newlines.
 fn report(out: &mut dyn Write, kind: &str, rel: &str, n: usize) {
@@ -1218,10 +1422,10 @@ fn run(a: &Args, out: &mut dyn Write) -> Result<bool, String> {
     // Validate every selected target before SKIP, and before following any
     // symlink for a read. Cached scans validate the target stored in Git.
     if a.cached {
-        let links = index_symlinks(&root)?;
+        let entries = index_entries(&root)?;
         let rels: Vec<_> = todo
             .iter()
-            .filter(|(_, r)| links.contains(r))
+            .filter(|(_, r)| entries.get(r).is_some_and(|mode| mode == "120000"))
             .map(|(_, r)| r.clone())
             .collect();
         for target in staged(&root, &rels)?.values() {
@@ -1229,15 +1433,7 @@ fn run(a: &Args, out: &mut dyn Write) -> Result<bool, String> {
         }
     } else {
         for (path, _) in &todo {
-            match std::fs::read_link(path) {
-                Ok(target) => {
-                    utf8_path(&target)?;
-                }
-                Err(e)
-                    if e.kind() == std::io::ErrorKind::InvalidInput
-                        || e.kind() == std::io::ErrorKind::NotFound => {}
-                Err(_) => return Err("cannot validate symlink target".into()),
-            }
+            validate_symlink_chain(path)?;
         }
     }
     todo.retain(|(_, rel)| !a.skip.iter().any(|g| fnmatch(rel, g)));
@@ -1319,6 +1515,7 @@ pub fn cli(args: &[String], out: &mut dyn Write, err: &mut dyn Write) -> u8 {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::collections::HashSet;
     use std::ffi::OsStr;
     use std::os::unix::ffi::OsStrExt;
 
@@ -2504,6 +2701,201 @@ mod tests {
         }
     }
 
+    #[test]
+    fn round5_symlink_chains_and_cycles() {
+        let f = Fixture::new("r5-chain-positive");
+        std::fs::write(f.0.join("clean.md"), "clean").unwrap();
+        std::os::unix::fs::symlink("clean.md", f.0.join("inner.md")).unwrap();
+        std::os::unix::fs::symlink("inner.md", f.0.join("alias.md")).unwrap();
+        let args = f.args(&["alias.md"]);
+        assert_eq!(cli(&args, &mut Vec::new(), &mut Vec::new()), 0);
+        std::fs::remove_file(f.0.join("inner.md")).unwrap();
+        std::os::unix::fs::symlink("alias.md", f.0.join("inner.md")).unwrap();
+        let (mut out, mut err) = (Vec::new(), Vec::new());
+        assert_eq!(cli(&args, &mut out, &mut err), 2);
+        assert!(out.is_empty());
+        assert_eq!(err, b"ERROR: cannot validate symlink target\n");
+        // A link in a directory component is another hop the read follows.
+        std::fs::remove_file(f.0.join("alias.md")).unwrap();
+        std::os::unix::fs::symlink("inner.md/file", f.0.join("alias.md")).unwrap();
+        std::fs::remove_file(f.0.join("inner.md")).unwrap();
+        std::os::unix::fs::symlink(
+            OsStr::from_bytes(b"PRIVATE_FIVE_\xff"),
+            f.0.join("inner.md"),
+        )
+        .unwrap();
+        let (mut out, mut err) = (Vec::new(), Vec::new());
+        assert_eq!(cli(&args, &mut out, &mut err), 2);
+        assert!(out.is_empty());
+        assert_eq!(err, b"ERROR: path is not valid UTF-8\n");
+    }
+
+    // Regenerate with PERSONAL_DATA_UPDATE_REGEX_CASES=1 and all supported
+    // interpreters on PATH (or in PERSONAL_DATA_PYTHONS). No Python file is
+    // added to the repository; these calls use each real interpreter's engine.
+    #[test]
+    fn round5_regex_case_table_matches_interpreters() {
+        let mut commands: Vec<String> = [
+            "python3",
+            "python3.9",
+            "python3.10",
+            "python3.11",
+            "python3.12",
+            "python3.13",
+            "python3.14",
+            "python3.15",
+            "/usr/bin/python3",
+        ]
+        .iter()
+        .map(|s| (*s).into())
+        .collect();
+        if let Ok(extra) = std::env::var("PERSONAL_DATA_PYTHONS") {
+            commands.extend(extra.split(':').map(str::to_owned));
+        }
+        let mut interpreters = Vec::new();
+        let mut versions = HashSet::new();
+        let mut pairs = std::collections::BTreeSet::new();
+        for command in commands {
+            let Ok(probe) = Command::new(&command).args(["-I", "-c", "import sys,unicodedata; print(sys.version.split()[0],unicodedata.unidata_version)"]).output() else { continue; };
+            if !probe.status.success() || !versions.insert(probe.stdout.clone()) {
+                continue;
+            }
+            println!(
+                "Regex relations checked Python {}",
+                String::from_utf8_lossy(&probe.stdout).trim()
+            );
+            // Lowercase buckets plus the compiler's extra cases enumerate
+            // candidate pairs, including relations absent in another version.
+            // They are candidates only: every result below is real fullmatch.
+            let output = Command::new(&command)
+                .args([
+                    "-I",
+                    "-c",
+                    r#"
+import _sre,itertools
+try:
+    from re._casefix import _EXTRA_CASES
+except ImportError:
+    import sre_compile
+    _EXTRA_CASES=sre_compile._ignorecase_fixes
+buckets={}
+for c in range(0x110000):
+    if 0xd800 <= c <= 0xdfff: continue
+    lower=_sre.unicode_tolower(c)
+    if lower != c or _sre.unicode_iscased(c): buckets.setdefault(lower,set()).add(c)
+for key,others in _EXTRA_CASES.items():
+    group=set(buckets.get(key,{key}))
+    for other in others: group.update(buckets.get(other,{other}))
+    for a,b in itertools.combinations(sorted(group),2): print(a,b)
+for group in buckets.values():
+    for a,b in itertools.combinations(sorted(group),2): print(a,b)
+"#,
+                ])
+                .output()
+                .unwrap();
+            assert!(output.status.success(), "regex candidate oracle failed");
+            assert!(output.stderr.is_empty());
+            for row in String::from_utf8(output.stdout).unwrap().lines() {
+                let (a, b) = row.split_once(' ').unwrap();
+                pairs.insert((a.parse::<u32>().unwrap(), b.parse::<u32>().unwrap()));
+            }
+            interpreters.push(command);
+        }
+        assert!(!interpreters.is_empty());
+        let input: String = pairs.iter().map(|(a, b)| format!("{a} {b}\n")).collect();
+        let mut baseline = None;
+        let mut differing = std::collections::BTreeSet::new();
+        for command in interpreters {
+            let mut child = Command::new(command).args(["-I", "-c", r#"
+import re,sys
+for row in sys.stdin:
+    a,b=map(int,row.split()); a,b=chr(a),chr(b)
+    # Both directions, literals, and positive/negative classes. This also
+    # catches compiler asymmetries instead of assuming an equivalence class.
+    print(''.join(str(int(re.fullmatch(p,t,re.IGNORECASE) is not None))
+        for s,t in ((a,b),(b,a)) for p in (re.escape(s),'['+re.escape(s)+']','[^'+re.escape(s)+']')))
+"#]).stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped()).spawn().unwrap();
+            let mut stdin = child.stdin.take().unwrap();
+            let bytes = input.clone();
+            let writer = std::thread::spawn(move || stdin.write_all(bytes.as_bytes()));
+            let output = child.wait_with_output().unwrap();
+            writer.join().unwrap().unwrap();
+            assert!(output.status.success(), "regex relation oracle failed");
+            assert!(output.stderr.is_empty());
+            let rows: Vec<String> = String::from_utf8(output.stdout)
+                .unwrap()
+                .lines()
+                .map(str::to_owned)
+                .collect();
+            assert_eq!(rows.len(), pairs.len());
+            if let Some(first) = &baseline {
+                for ((pair, row), old) in pairs.iter().zip(&rows).zip(first) {
+                    if row != old {
+                        differing.insert(*pair);
+                    }
+                }
+            } else {
+                baseline = Some(rows);
+            }
+        }
+        let file = Path::new(env!("CARGO_MANIFEST_DIR")).join("src/personal_data.rs");
+        if std::env::var_os("PERSONAL_DATA_UPDATE_REGEX_CASES").is_some() {
+            assert!(
+                versions.len() >= 2,
+                "generation requires multiple real interpreters"
+            );
+            let mut table = String::from(
+                "// Generated by round5_regex_case_table_matches_interpreters; decimal Unicode scalar pairs.\n// Both endpoints of each differing real re.IGNORECASE relation are refused.\n",
+            );
+            let mut versions: Vec<_> = versions
+                .iter()
+                .map(|v| String::from_utf8_lossy(v).trim().to_owned())
+                .collect();
+            versions.sort();
+            for version in versions {
+                table.push_str(&format!("// Python {version}\n"));
+            }
+            table.push_str("const REGEX_CASE_RELATIONS: &[(u32, u32)] = &[\n");
+            for (a, b) in &differing {
+                table.push_str(&format!("    ({a}, {b}),\n"));
+            }
+            table.push_str("];\n");
+            let source = std::fs::read_to_string(&file).unwrap();
+            let (prefix, rest) = source
+                .split_once("// BEGIN GENERATED REGEX CASE RELATIONS\n")
+                .unwrap();
+            let (_, suffix) = rest
+                .split_once("// END GENERATED REGEX CASE RELATIONS\n")
+                .unwrap();
+            std::fs::write(&file, format!("{prefix}// BEGIN GENERATED REGEX CASE RELATIONS\n{table}// END GENERATED REGEX CASE RELATIONS\n{suffix}")).unwrap();
+        }
+        let checked: std::collections::BTreeSet<_> = REGEX_CASE_RELATIONS.iter().copied().collect();
+        if std::env::var_os("PERSONAL_DATA_UPDATE_REGEX_CASES").is_none() {
+            assert!(
+                differing.is_subset(&checked),
+                "checked-in regex table misses a differing pair"
+            );
+        }
+        println!(
+            "{} candidate pairs, {} differing pairs on available interpreters, {} checked-in pairs",
+            pairs.len(),
+            differing.len(),
+            checked.len()
+        );
+        // Generation can run before the production table is updated. Every
+        // ordinary verification must also prove both endpoints fail closed.
+        if std::env::var_os("PERSONAL_DATA_UPDATE_REGEX_CASES").is_none() {
+            for (a, b) in &checked {
+                for c in [a, b] {
+                    assert!(
+                        version_dependent(char::from_u32(*c).unwrap()),
+                        "regex endpoint is unguarded"
+                    );
+                }
+            }
+        }
+    }
+
     #[test]
     fn round4_guard_agrees_with_available_pythons() {
         // Every available interpreter is checked, not just whichever python3
@@ -2522,7 +2914,10 @@ mod tests {
         if let Ok(extra) = std::env::var("PERSONAL_DATA_PYTHONS") {
             commands.extend(extra.split(':').map(str::to_owned));
         }
-        let ranges = VERSION_DEPENDENT
+        let mut guarded = VERSION_DEPENDENT.to_vec();
+        guarded.extend(REGEX_CASE_ENDPOINTS.iter().map(|&c| (c, c)));
+        guarded.sort_unstable();
+        let ranges = guarded
             .iter()
             .map(|(a, b)| format!("{a} {b}\n"))
             .collect::<String>();
diff --git a/scripts/ci/check-personal-data.sh b/scripts/ci/check-personal-data.sh
index 136c16fdf..b56a9c08c 100755
--- a/scripts/ci/check-personal-data.sh
+++ b/scripts/ci/check-personal-data.sh
@@ -57,12 +57,15 @@
 # with exit 2 and a diagnostic that omits the pattern and scanned values.
 # A path with invalid UTF-8 also stops the scan before SKIP, path conversion
 # or staged-blob requests. Symlink targets are also checked before SKIP:
-# working-copy targets from readlink, staged targets from index mode 120000.
+# every working-copy hop (at most 40), staged targets from index mode 120000.
+# Version-dependent filenames fail before ALLOW/SKIP with a generic error.
+# Cached entries must be regular blobs or symlinks. Gitlinks and unreadable
+# indexed objects fail with exit 2 naming only the path, unless SKIP excludes it.
 # File contents still use replacement decoding.
 #
 # Unicode guard: UCD 13, 15, 16 and 17 disagree on newer script letters.
 # The scan stops with redacted exit 2 at file:line for version-dependent
-# text, custom patterns (including escaped literals), or ALLOW/SKIP rows.
+# text, filenames, custom patterns (including escaped literals), or ALLOW/SKIP rows.
 # ALLOW cannot exempt such text. Use an ASCII SKIP glob to exempt its file.
 # A letter from a script newer than Unicode 13 therefore stops the scan
 # until its file is skipped. Newer plain symbols and emoji still scan.
@@ -70,13 +73,23 @@
 # The generated conservative set includes every scalar unassigned in UCD
 # 17; post-13 letters, marks, numbers, connectors, spaces and case mappings;
 # and older scalars whose word/digit/space membership or case maps change
-# in UCD 13/15/16/17, including both ends of changed case relations.
+# in UCD 13/15/16/17. Full case folds avoid rejecting six stable old scalars.
+# Another generated table guards both ends of regex case relations that differ
+# across supported Python engines. It comes from real re.fullmatch calls,
+# including literal, positive-class and negative-class patterns both ways.
+# The 248 newer scalars with stable effective behavior remain conservatively
+# blocked. The six stable scalars assigned by Unicode 13 pass.
 # This adds one binary-search lookup per non-ASCII character (ASCII is
-# stable), with a fixed table and no per-file Unicode index or extra process.
+# stable), plus a fixed regex-endpoint table. No per-file index or process.
 # Regenerate from SHA-256-pinned official data with the Rust generator:
 # tests/parity/gen/personal-unicode-generate.sh SCRATCH_DIR
 # Guard regenerates byte for byte and compares all available Python oracles,
-# explicitly installing 3.12 and 3.15. Match iteration still follows 3.14+.
+# explicitly installing 3.9, 3.12 and 3.15. Match iteration follows 3.14+.
+# Regenerate the regex table via the existing Rust differential test:
+# PERSONAL_DATA_UPDATE_REGEX_CASES=1 cargo test -p og-dev round5_regex_case_table_matches_interpreters
+# Supply all supported Python interpreters on PATH or PERSONAL_DATA_PYTHONS
+# (colon-separated paths). Ordinary tests verify every available interpreter
+# and reject any differing pair missing from the checked-in table.
 #
 # The scan is og dev scan personal-data (rust/crates/og-dev); bin/og runs
 # the build scripts/setup.sh --og puts in bin/.og for this machine, and OG
diff --git a/tests/parity/gen/personal-unicode-generator.rs b/tests/parity/gen/personal-unicode-generator.rs
index c29dcce3b..154a2dc09 100644
--- a/tests/parity/gen/personal-unicode-generator.rs
+++ b/tests/parity/gen/personal-unicode-generator.rs
@@ -7,7 +7,7 @@ use std::{env, fs, path::Path};
 struct Properties {
     category: String,
     space: bool,
-    case: [String; 4], // simple upper/lower/title mappings and simple case fold
+    case: [String; 4], // simple upper/lower/title mappings and full case fold
 }
 impl Properties {
     fn assigned(&self) -> bool {
@@ -64,7 +64,7 @@ fn read(dir: &Path, version: &str) -> Vec<Properties> {
             continue;
         }
         let f: Vec<_> = line.split(';').map(str::trim).collect();
-        if matches!(f[1], "C" | "S") {
+        if matches!(f[1], "C" | "F") {
             let c = usize::from_str_radix(f[0], 16).unwrap();
             assert!(table[c].assigned());
             table[c].case[3] = f[2].into();
@@ -100,6 +100,11 @@ fn main() {
                     if mapping.is_empty() {
                         continue;
                     }
+                    // Full folds can expand to several scalars. They affect
+                    // the signature above, but are not regex case relations.
+                    if mapping.contains(' ') {
+                        continue;
+                    }
                     let target = usize::from_str_radix(mapping, 16).unwrap();
                     if refused[c] || refused[target] {
                         refused[c] = true;

From 152bf7860e95951dc585259dcf9f4c66869e36db Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 19:20:42 +0100
Subject: [PATCH 65/76] test(ci): expose astral case, range and symlink name
 gaps

---
 rust/crates/og-dev/src/personal_data.rs | 156 ++++++++++++++++++++++++
 1 file changed, 156 insertions(+)

diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
index 0b19ad1a1..1cc15fe33 100644
--- a/rust/crates/og-dev/src/personal_data.rs
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -2730,6 +2730,162 @@ mod tests {
         assert_eq!(err, b"ERROR: path is not valid UTF-8\n");
     }
 
+    #[test]
+    fn round6_astral_composite_cases() {
+        let f = Fixture::new("r6-astral");
+        r5_git(&f, &["init", "-q"], b"");
+        let mut failures = Vec::new();
+        // One lowercase/uppercase pair per astral cased script reported by
+        // the composite oracle. Run each through all four public entry modes.
+        for (lower, upper) in [
+            (0x10428, 0x10400),
+            (0x104d8, 0x104b0),
+            (0x10cc0, 0x10c80),
+            (0x118c0, 0x118a0),
+            (0x16e60, 0x16e40),
+            (0x1e922, 0x1e900),
+        ] {
+            let text = char::from_u32(lower).unwrap().to_string();
+            std::fs::write(f.0.join("own.md"), &text).unwrap();
+            std::fs::write(f.0.join("patterns"), format!(r"(?i)[^\U{upper:08x}Z]")).unwrap();
+            r5_git(&f, &["add", "own.md"], b"");
+            for cached in [false, true] {
+                for explicit in [false, true] {
+                    let mut args = f.args(if explicit { &["own.md"] } else { &[] });
+                    args.extend([
+                        "--patterns".into(),
+                        f.0.join("patterns").display().to_string(),
+                    ]);
+                    if cached {
+                        args.push("--cached".into());
+                    }
+                    let (mut out, mut err) = (Vec::new(), Vec::new());
+                    let code = cli(&args, &mut out, &mut err);
+                    if code != 2 {
+                        failures.push((lower, cached, explicit, code));
+                    } else {
+                        assert!(out.is_empty());
+                        assert!(!String::from_utf8_lossy(&err).contains(&text));
+                    }
+                }
+            }
+        }
+        assert!(failures.is_empty(), "astral scenarios differ: {failures:?}");
+    }
+
+    #[test]
+    fn round6_guarded_range_interiors() {
+        // Endpoints are stable. A guarded Cyrillic case partner lies inside.
+        for pattern in [
+            r"[\u0410-\u044f]",
+            r"(?i)[^\u0410-\u044fZ]",
+            r"[\U000103ff-\U00010450]",
+            r"[\u0377-\u037a]",
+        ] {
+            assert!(
+                Rule::compile(pattern, false).is_err(),
+                "guarded range accepted"
+            );
+        }
+    }
+
+    #[test]
+    fn round6_stable_ranges_and_uncased_astral() {
+        for pattern in [r"[A-Z]", r"(?i)[A-Z]", r"[À-Ö]", r"(?i)[À-Ö]"] {
+            let rule = Rule::compile(pattern, false).unwrap();
+            for text in ["aZz", "ÀàÖö", "abc", "😀𠀀Z"] {
+                let oracle = Command::new("python3").args(["-I", "-c",
+                    "import re,sys; print(';'.join(f'{m.start()},{m.end()}' for m in re.finditer(sys.argv[1],sys.argv[2])))", pattern, text]).output().unwrap();
+                assert!(oracle.status.success());
+                let spans = rule
+                    .find_iter(text)
+                    .map(|m| {
+                        let m = m.unwrap();
+                        format!(
+                            "{},{}",
+                            text[..m.0].chars().count(),
+                            text[..m.1].chars().count()
+                        )
+                    })
+                    .collect::<Vec<_>>()
+                    .join(";");
+                assert_eq!(spans, String::from_utf8(oracle.stdout).unwrap().trim());
+            }
+        }
+        let f = Fixture::new("r6-uncased");
+        r5_git(&f, &["init", "-q"], b"");
+        std::fs::write(f.0.join("own.md"), p("😀𠀀 rs123~ AG")).unwrap();
+        r5_git(&f, &["add", "own.md"], b"");
+        r5_modes(&f, &["own.md"], 1, "");
+    }
+
+    #[test]
+    fn round6_symlink_unicode_names() {
+        let f = Fixture::new("r6-link-name");
+        r5_git(&f, &["init", "-q"], b"");
+        std::fs::write(f.0.join("clean.md"), "clean").unwrap();
+        let name = "x\u{1e6c0}PRIVATE_SIX";
+        let mut failures = Vec::new();
+        for shape in ["direct", "directory", "intermediate"] {
+            let target = match shape {
+                "direct" => {
+                    std::fs::write(f.0.join(name), "clean").unwrap();
+                    name.to_string()
+                }
+                "directory" => {
+                    let dir = format!("dir{name}");
+                    std::fs::create_dir(f.0.join(&dir)).unwrap();
+                    std::fs::write(f.0.join(&dir).join("clean.md"), "clean").unwrap();
+                    format!("{dir}/clean.md")
+                }
+                _ => {
+                    let link = format!("link{name}");
+                    std::os::unix::fs::symlink("clean.md", f.0.join(&link)).unwrap();
+                    std::os::unix::fs::symlink(link, f.0.join("inner.md")).unwrap();
+                    "inner.md".into()
+                }
+            };
+            std::os::unix::fs::symlink(&target, f.0.join("alias.md")).unwrap();
+            r5_git(&f, &["add", "alias.md", "clean.md"], b"");
+            for explicit in [false, true] {
+                for skip in ["", "alias.md"] {
+                    let mut args = f.args(if explicit {
+                        &["alias.md", "clean.md"]
+                    } else {
+                        &[]
+                    });
+                    args[5] = skip.into();
+                    let (mut out, mut err) = (Vec::new(), Vec::new());
+                    let code = cli(&args, &mut out, &mut err);
+                    if code != 2 {
+                        failures.push((shape, explicit, skip.to_string(), code));
+                    } else {
+                        assert!(out.is_empty());
+                        assert_eq!(
+                            err,
+                            b"ERROR: selected filename has Unicode version-dependent text\n"
+                        );
+                    }
+                    // Working target names never replace the indexed target.
+                    args.push("--cached".into());
+                    assert_eq!(
+                        cli(&args, &mut Vec::new(), &mut Vec::new()),
+                        if skip.is_empty() && shape != "intermediate" {
+                            2
+                        } else {
+                            0
+                        }
+                    );
+                }
+            }
+            std::fs::remove_file(f.0.join("alias.md")).unwrap();
+        }
+        assert!(
+            failures.is_empty(),
+            "symlink names bypass guard: {failures:?}"
+        );
+    }
+
     // Regenerate with PERSONAL_DATA_UPDATE_REGEX_CASES=1 and all supported
     // interpreters on PATH (or in PERSONAL_DATA_PYTHONS). No Python file is
     // added to the repository; these calls use each real interpreter's engine.

From 145cdd0b4994b0664624dc4d1737a212abdc5614 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 19:23:49 +0100
Subject: [PATCH 66/76] test(dev): reproduce offset, stream and late-header
 failures

---
 rust/crates/og-dev/src/evidence.rs | 71 +++++++++++++++++++++++++++++-
 rust/crates/og-dev/src/fixture.rs  | 44 ++++++++++++++++++
 rust/crates/og-dev/src/lib.rs      | 46 ++++++++++++++++++-
 rust/crates/og-dev/src/renovate.rs | 19 ++++++++
 4 files changed, 178 insertions(+), 2 deletions(-)

diff --git a/rust/crates/og-dev/src/evidence.rs b/rust/crates/og-dev/src/evidence.rs
index 2210e9e5b..547bf903b 100644
--- a/rust/crates/og-dev/src/evidence.rs
+++ b/rust/crates/og-dev/src/evidence.rs
@@ -696,6 +696,75 @@ mod tests {
         }
     }
 
+    #[test]
+    fn fai_offsets_reject_overflow_and_out_of_file_before_publication() {
+        for (offset, bases, bytes, position) in [
+            (18446744073709551598u64, 1, 2, 13),
+            (1, 1, u64::MAX, 3),
+            (u64::MAX, 1, 1, 1),
+            (1000, 50, 51, 1),
+        ] {
+            let c = Case::new("hg002-gvcf", &format!("offset-{offset}-{position}"));
+            c.put("ref.fasta.fai", format!("chrA\t50\t{offset}\t{bases}\t{bytes}\n").as_bytes());
+            c.put("sites.tsv", format!("id\tchr\tpos\nx\tchrA\t{position}\n").as_bytes());
+            c.put("truth.bed", b"chrA\t0\t50\n");
+            c.put("truth.vcf.gz", b"##fileformat=VCFv4.2\n#CHROM\tPOS\tID\tREF\tALT\n");
+            c.fails_without_publication();
+            assert!(c.run().unwrap_err().contains(": invalid FASTA offset:"));
+        }
+    }
+
+    #[test]
+    fn late_vcf_headers_fail_before_publication() {
+        for header in [b"##late=yes\n".as_slice(), b"#CHROM\tPOS\n"] {
+            let c = Case::new("hg002-gvcf", &format!("late-{}", header.len()));
+            c.put("truth.vcf.gz", &[c.text("truth.vcf.gz"), header.to_vec()].concat());
+            c.fails_without_publication();
+            assert!(c.run().unwrap_err().contains(": VCF header after first data record"));
+        }
+    }
+
+    #[test]
+    fn empty_gzip_inputs_and_unused_zero_width_fai_rows_fail() {
+        for (kind, name) in [
+            ("clashes", "raw.vcf.gz"), ("clashes", "split.vcf.gz"),
+            ("clashes", "chrA.tsv.gz"), ("hg002-gvcf", "truth.vcf.gz"),
+        ] {
+            let c = Case::new(kind, name);
+            fs::write(c.dir.join(name), b"").unwrap();
+            c.fails_without_publication();
+            assert!(c.run().unwrap_err().contains(": wrong compression (expected gzip)"));
+        }
+        let c = Case::new("hg002-gvcf", "unused-row");
+        c.put("ref.fasta.fai", &[c.text("ref.fasta.fai"), b"chrUnused\t0\t0\t0\t0\n".to_vec()].concat());
+        c.fails_without_publication();
+        assert!(c.run().unwrap_err().contains(": a row has 0 bases per line"));
+    }
+
+    #[test]
+    fn gzip_fasta_with_ascii_fname_is_refused_by_format_guard() {
+        let c = Case::new("hg002-gvcf", "fname");
+        let mut gz = flate2::GzBuilder::new().filename(vec![b'A'; 200])
+            .write(Vec::new(), flate2::Compression::default());
+        gz.write_all(&c.text("ref.fasta")).unwrap();
+        fs::write(c.dir.join("ref.fasta"), gz.finish().unwrap()).unwrap();
+        c.fails_without_publication();
+        assert!(c.run().unwrap_err().contains(": wrong compression (expected plain)"));
+    }
+
+    #[test]
+    fn non_writable_parents_preserve_evidence_destinations() {
+        for kind in ["clashes", "hg002-gvcf"] {
+            let c = Case::new(kind, "parent-mode");
+            fs::write(c.dir.join("out"), b"PREVIOUS OUTPUT\n").unwrap();
+            fs::set_permissions(&c.dir, fs::Permissions::from_mode(0o555)).unwrap();
+            let result = c.run();
+            fs::set_permissions(&c.dir, fs::Permissions::from_mode(0o755)).unwrap();
+            assert!(result.unwrap_err().contains(": parent directory is not writable"));
+            assert_eq!(fs::read(c.dir.join("out")).unwrap(), b"PREVIOUS OUTPUT\n");
+        }
+    }
+
     #[test]
     fn selected_truncated_clash_records_fail() {
         for name in ["raw.vcf.gz", "split.vcf.gz", "chrA.tsv.gz"] {
@@ -837,7 +906,7 @@ mod tests {
                 };
                 fs::write(c.dir.join(name), wrong).unwrap();
                 c.fails_without_publication();
-                assert!(c.run().unwrap_err().contains("compression"), "{name}");
+                assert!(c.run().unwrap_err().contains(": wrong compression (expected "), "{name}");
             }
         }
     }
diff --git a/rust/crates/og-dev/src/fixture.rs b/rust/crates/og-dev/src/fixture.rs
index 1ea2d5061..3371b7a91 100644
--- a/rust/crates/og-dev/src/fixture.rs
+++ b/rust/crates/og-dev/src/fixture.rs
@@ -608,6 +608,50 @@ fn trim_pharmcat(src: &Path, dst: &Path, max: i64) -> Result<(), String> {
 mod tests {
     use super::*;
 
+    #[test]
+    fn non_ascii_or_out_of_range_annotation_limits_fail_at_cli() {
+        let d = std::env::temp_dir().join(format!("og-limits-{}", std::process::id()));
+        fs::create_dir_all(&d).unwrap();
+        fs::write(d.join("in"), br#"{"genes":{},"drugs":{}}"#).unwrap();
+        for limit in ["1_0", "٤", "18446744073709551616"] {
+            fs::write(d.join("out"), b"old").unwrap();
+            let args = vec!["trim-pharmcat".into(), d.join("in").to_str().unwrap().into(),
+                d.join("out").to_str().unwrap().into(), limit.into()];
+            let (mut out, mut err) = (Vec::new(), Vec::new());
+            assert_eq!(cli(&args, &mut out, &mut err), 2);
+            let err = String::from_utf8(err).unwrap();
+            assert!(err.contains("error: MAX_ANNOTATIONS") && err.contains("is not a whole number"), "{err}");
+            assert_eq!(fs::read(d.join("out")).unwrap(), b"old");
+        }
+        fs::remove_dir_all(d).unwrap();
+    }
+
+    #[test]
+    fn non_writable_parents_preserve_fixture_destinations() {
+        use std::os::unix::fs::PermissionsExt;
+        let d = std::env::temp_dir().join(format!("og-parent-{}", std::process::id()));
+        fs::create_dir_all(&d).unwrap();
+        fs::write(d.join("in"), br#"{"genes":{},"drugs":{}}"#).unwrap();
+        for name in ["out", "reads.sam", "vep.vcf", "comphet.vcf"] {
+            fs::write(d.join(name), b"old").unwrap();
+        }
+        for args in [
+            vec!["trim-pharmcat".into(), d.join("in").to_str().unwrap().into(), d.join("out").to_str().unwrap().into()],
+            vec!["comphet".into(), d.to_str().unwrap().into()],
+        ] {
+            fs::set_permissions(&d, fs::Permissions::from_mode(0o555)).unwrap();
+            let (mut out, mut err) = (Vec::new(), Vec::new());
+            let code = cli(&args, &mut out, &mut err);
+            fs::set_permissions(&d, fs::Permissions::from_mode(0o755)).unwrap();
+            assert_eq!(code, 1);
+            assert!(String::from_utf8(err).unwrap().contains(": parent directory is not writable"));
+            for name in ["out", "reads.sam", "vep.vcf", "comphet.vcf"] {
+                assert_eq!(fs::read(d.join(name)).unwrap(), b"old");
+            }
+        }
+        fs::remove_dir_all(d).unwrap();
+    }
+
     #[test]
     fn pharmcat_input_is_plain_json() {
         let d =
diff --git a/rust/crates/og-dev/src/lib.rs b/rust/crates/og-dev/src/lib.rs
index d4a2aad52..14eb34dfb 100644
--- a/rust/crates/og-dev/src/lib.rs
+++ b/rust/crates/og-dev/src/lib.rs
@@ -61,7 +61,14 @@ pub(crate) fn py_os_error(e: &std::io::Error, path: &str) -> String {
 fn run(f: fn(&[String], &mut dyn Write, &mut dyn Write) -> u8, args: &[String]) -> u8 {
     let mut out = std::io::stdout().lock();
     let mut err = std::io::stderr().lock();
-    let code = f(args, &mut out, &mut err);
+    run_with_writers(f, args, &mut out, &mut err)
+}
+
+pub(crate) fn run_with_writers(
+    f: fn(&[String], &mut dyn Write, &mut dyn Write) -> u8,
+    args: &[String], out: &mut dyn Write, err: &mut dyn Write,
+) -> u8 {
+    let code = f(args, out, err);
     let _ = out.flush();
     code
 }
@@ -95,3 +102,40 @@ pub fn main(args: &[String]) -> u8 {
         }
     }
 }
+
+#[cfg(test)]
+mod stream_tests {
+    use super::*;
+    struct Fails { flush_only: bool }
+    impl Write for Fails {
+        fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
+            if self.flush_only { Ok(bytes.len()) } else { Err(std::io::Error::other("write control")) }
+        }
+        fn flush(&mut self) -> std::io::Result<()> {
+            if self.flush_only { Err(std::io::Error::other("flush control")) } else { Ok(()) }
+        }
+    }
+    #[test]
+    fn added_verbs_propagate_write_and_flush_errors() {
+        let verbs = [fixture::cli, evidence::cli, renovate::cli];
+        for verb in verbs {
+            for flush_only in [false, true] {
+                let mut bad = Fails { flush_only };
+                let mut err = Vec::new();
+                assert_eq!(run_with_writers(verb, &["--help".into()], &mut bad, &mut err), 1);
+                assert!(String::from_utf8(err).unwrap().contains("stdout:"));
+            }
+        }
+    }
+    #[test]
+    fn shared_runner_checks_stderr_and_an_empty_stdout() {
+        fn clean(_: &[String], _: &mut dyn Write, err: &mut dyn Write) -> u8 {
+            let _ = writeln!(err, "status");
+            0
+        }
+        for flush_only in [false, true] {
+            assert_eq!(run_with_writers(clean, &[], &mut Vec::new(), &mut Fails { flush_only }), 1);
+        }
+        assert_eq!(run_with_writers(clean, &[], &mut Fails { flush_only: true }, &mut Vec::new()), 1);
+    }
+}
diff --git a/rust/crates/og-dev/src/renovate.rs b/rust/crates/og-dev/src/renovate.rs
index c206ac819..74bbfb6a1 100644
--- a/rust/crates/og-dev/src/renovate.rs
+++ b/rust/crates/og-dev/src/renovate.rs
@@ -898,6 +898,25 @@ mod tests {
         let _ = fs::remove_dir_all(&d);
     }
 
+    #[test]
+    fn non_writable_summary_parent_preserves_previous_summary() {
+        use std::os::unix::fs::PermissionsExt;
+        let d = planted("summary-parent");
+        let parent = d.join("summary-dir");
+        fs::create_dir(&parent).unwrap();
+        let summary = parent.join("result");
+        fs::write(&summary, b"old").unwrap();
+        fs::set_permissions(&parent, fs::Permissions::from_mode(0o555)).unwrap();
+        let args = vec![d.join("renovate.log").to_str().unwrap().into(), "--repo".into(), d.to_str().unwrap().into()];
+        let (mut out, mut err) = (Vec::new(), Vec::new());
+        let code = cli_with_summary(&args, &mut out, &mut err, Some(&summary));
+        fs::set_permissions(&parent, fs::Permissions::from_mode(0o755)).unwrap();
+        assert_eq!(code, 1);
+        assert!(String::from_utf8(err).unwrap().contains(": parent directory is not writable"));
+        assert_eq!(fs::read(&summary).unwrap(), b"old");
+        fs::remove_dir_all(d).unwrap();
+    }
+
     #[test]
     fn configured_summary_write_failure_fails_the_check() {
         let d = planted("summary");

From e14fb3dcc76fcc03aabf065265eaa78b55574b38 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 19:29:51 +0100
Subject: [PATCH 67/76] fix(ci): guard astral cases, range interiors and
 symlink names

---
 .github/workflows/guard.yml                   |  27 ++-
 CHANGELOG.md                                  |   2 +
 rust/crates/og-dev/src/lookaround.rs          |   4 +-
 rust/crates/og-dev/src/personal_data.rs       | 191 ++++++++----------
 scripts/ci/check-personal-data.sh             |  17 +-
 .../parity/gen/personal-unicode-generator.rs  |  42 +++-
 tests/parity/gen/personal-unicode-sources.tsv |   4 +
 7 files changed, 174 insertions(+), 113 deletions(-)

diff --git a/.github/workflows/guard.yml b/.github/workflows/guard.yml
index 0193baec6..0ea2ea31e 100644
--- a/.github/workflows/guard.yml
+++ b/.github/workflows/guard.yml
@@ -391,11 +391,14 @@ jobs:
       - name: Scanner round-five controls (all five findings must fail before the fix)
         run: |
           source=crates/og-dev/src/personal_data.rs
+          matcher=crates/og-dev/src/lookaround.rs
           cp "$source" "${RUNNER_TEMP}/round5-personal-fixed.rs"
-          trap 'cp "${RUNNER_TEMP}/round5-personal-fixed.rs" "$source"' EXIT
+          cp "$matcher" "${RUNNER_TEMP}/round5-matcher-fixed.rs"
+          trap 'cp "${RUNNER_TEMP}/round5-personal-fixed.rs" "$source"; cp "${RUNNER_TEMP}/round5-matcher-fixed.rs" "$matcher"' EXIT
           before=f155efd343e82ebf8b53a563ee4b2c5b6f4dbf85
           git cat-file -e "$before^{commit}" 2>/dev/null || git fetch --quiet --depth=1 origin "$before"
           git show "$before:rust/$source" > "$source"
+          git show "$before:rust/$matcher" > "$matcher"
           log="${RUNNER_TEMP}/scanner-round5-red.log"
           rc=0
           cargo test -p og-dev --locked --no-fail-fast round5_ > "$log" 2>&1 || rc=$?
@@ -406,6 +409,28 @@ jobs:
           done
           echo "Control: all five round-five regressions failed before the fix."
 
+      - name: Scanner round-six controls (astral cases, range interiors and symlink names fail before the fix)
+        run: |
+          source=crates/og-dev/src/personal_data.rs
+          matcher=crates/og-dev/src/lookaround.rs
+          cp "$source" "${RUNNER_TEMP}/round6-personal-fixed.rs"
+          cp "$matcher" "${RUNNER_TEMP}/round6-matcher-fixed.rs"
+          trap 'cp "${RUNNER_TEMP}/round6-personal-fixed.rs" "$source"; cp "${RUNNER_TEMP}/round6-matcher-fixed.rs" "$matcher"' EXIT
+          before=152bf7860e95951dc585259dcf9f4c66869e36db
+          git cat-file -e "$before^{commit}" 2>/dev/null || git fetch --quiet --depth=1 origin "$before"
+          git show "$before:rust/$source" > "$source"
+          git show "$before:rust/$matcher" > "$matcher"
+          log="${RUNNER_TEMP}/scanner-round6-red.log"
+          rc=0
+          cargo test -p og-dev --locked --no-fail-fast round6_ > "$log" 2>&1 || rc=$?
+          cat "$log"
+          [ "$rc" -ne 0 ]
+          for test in astral_composite_cases guarded_range_interiors symlink_unicode_names; do
+            grep -E "round6_${test} .*FAILED" "$log" || { echo "ERROR: missing round-six red control"; exit 1; }
+          done
+          grep -E 'round6_stable_ranges_and_uncased_astral .*ok' "$log"
+          echo "Control: all three regressions failed; stable ranges and uncased astral text passed."
+
       - name: Regex relation verifier rejects a missing table
         run: |
           source=crates/og-dev/src/personal_data.rs
diff --git a/CHANGELOG.md b/CHANGELOG.md
index e51366d08..5bd1c2c89 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,8 @@ Each release's notes. From 1.0.0 on, a major or minor release has hand-written n
 
 ## Unreleased
 
+- The personal-data scan refuses every astral cased character from UCD 13/15/16/17, including case-mapping targets. Text in Deseret, Osage, Old Hungarian, Warang Citi, Medefaidrin, Adlam and other astral cased scripts needs an ASCII SKIP glob. Uncased astral text still scans. Custom class ranges with a guarded interior return redacted exit 2. BMP verification now covers composite classes, ranges and alternatives on every available Python. Every working-copy symlink target gets the same redacted Unicode filename guard before following it.
+
 - The personal-data guard now includes effective Python regex case relations, including Python 3.9 Cyrillic differences. Six stable older scalars pass again. Selected filenames get the same Unicode guard before exclusions, with a generic redacted error. Cached gitlinks and unreadable indexed objects fail with exit 2 unless skipped. Working-copy symlinks validate every hop, including directory components, with a 40-hop bound. The 248 newer stable scalars remain conservatively blocked.
 
 - The personal-data scan fails closed with redacted exit 2 on Unicode-version-dependent text, patterns and ALLOW/SKIP entries. Its generated guard covers UCD 13/15/16/17 and unassigned scalars. Newer emoji and plain symbols still scan. Files with newer script letters need an ASCII SKIP glob. Invalid UTF-8 symlink targets now fail before exclusions in working-copy and index scans.
diff --git a/rust/crates/og-dev/src/lookaround.rs b/rust/crates/og-dev/src/lookaround.rs
index 58240c74c..63eb3af6d 100644
--- a/rust/crates/og-dev/src/lookaround.rs
+++ b/rust/crates/og-dev/src/lookaround.rs
@@ -487,7 +487,9 @@ impl PythonPattern {
             if i + 2 < atoms.len() && atoms[i + 1].1 {
                 // Categories are not case folded in Python, even inside
                 // classes. Only literal range endpoints can form a range.
-                if class_literal(atom).is_none() || class_literal(&atoms[i + 2].0).is_none() {
+                let start = class_literal(atom).ok_or(())?;
+                let end = class_literal(&atoms[i + 2].0).ok_or(())?;
+                if start > end || crate::personal_data::range_version_dependent(start, end) {
                     return Err(());
                 }
                 let range = format!("[{atom}-{}]", atoms[i + 2].0);
diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
index 1cc15fe33..19e477de4 100644
--- a/rust/crates/og-dev/src/personal_data.rs
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -404,11 +404,9 @@ const VERSION_DEPENDENT: &[(u32, u32)] = &[
     (0x1037b, 0x1037f),
     (0x1039e, 0x1039e),
     (0x103c4, 0x103c7),
-    (0x103d6, 0x103ff),
+    (0x103d6, 0x1044f),
     (0x1049e, 0x1049f),
-    (0x104aa, 0x104af),
-    (0x104d4, 0x104d7),
-    (0x104fc, 0x104ff),
+    (0x104aa, 0x104ff),
     (0x10528, 0x1052f),
     (0x10564, 0x1056e),
     (0x10570, 0x105ff),
@@ -447,9 +445,7 @@ const VERSION_DEPENDENT: &[(u32, u32)] = &[
     (0x10b92, 0x10b98),
     (0x10b9d, 0x10ba8),
     (0x10bb0, 0x10bff),
-    (0x10c49, 0x10c7f),
-    (0x10cb3, 0x10cbf),
-    (0x10cf3, 0x10cf9),
+    (0x10c49, 0x10cf9),
     (0x10d28, 0x10d2f),
     (0x10d3a, 0x10d6d),
     (0x10d6f, 0x10d8d),
@@ -515,7 +511,7 @@ const VERSION_DEPENDENT: &[(u32, u32)] = &[
     (0x1171b, 0x1171c),
     (0x1172c, 0x1172f),
     (0x11740, 0x117ff),
-    (0x1183c, 0x1189f),
+    (0x1183c, 0x118df),
     (0x118f3, 0x118fe),
     (0x11907, 0x11908),
     (0x1190a, 0x1190b),
@@ -576,7 +572,7 @@ const VERSION_DEPENDENT: &[(u32, u32)] = &[
     (0x16b62, 0x16b62),
     (0x16b78, 0x16b7c),
     (0x16b90, 0x16d6c),
-    (0x16d70, 0x16e3f),
+    (0x16d70, 0x16e7f),
     (0x16e9b, 0x16eff),
     (0x16f4b, 0x16f4e),
     (0x16f88, 0x16f8e),
@@ -644,7 +640,7 @@ const VERSION_DEPENDENT: &[(u32, u32)] = &[
     (0x1e300, 0x1e5fe),
     (0x1e600, 0x1e7ff),
     (0x1e8c5, 0x1e8c6),
-    (0x1e8d7, 0x1e8ff),
+    (0x1e8d7, 0x1e943),
     (0x1e94c, 0x1e94f),
     (0x1e95a, 0x1e95d),
     (0x1e960, 0x1ec70),
@@ -778,88 +774,6 @@ const REGEX_CASE_RELATIONS: &[(u32, u32)] = &[
     (42966, 42967),
     (42968, 42969),
     (42970, 42971),
-    (66928, 66967),
-    (66929, 66968),
-    (66930, 66969),
-    (66931, 66970),
-    (66932, 66971),
-    (66933, 66972),
-    (66934, 66973),
-    (66935, 66974),
-    (66936, 66975),
-    (66937, 66976),
-    (66938, 66977),
-    (66940, 66979),
-    (66941, 66980),
-    (66942, 66981),
-    (66943, 66982),
-    (66944, 66983),
-    (66945, 66984),
-    (66946, 66985),
-    (66947, 66986),
-    (66948, 66987),
-    (66949, 66988),
-    (66950, 66989),
-    (66951, 66990),
-    (66952, 66991),
-    (66953, 66992),
-    (66954, 66993),
-    (66956, 66995),
-    (66957, 66996),
-    (66958, 66997),
-    (66959, 66998),
-    (66960, 66999),
-    (66961, 67000),
-    (66962, 67001),
-    (66964, 67003),
-    (66965, 67004),
-    (68944, 68976),
-    (68945, 68977),
-    (68946, 68978),
-    (68947, 68979),
-    (68948, 68980),
-    (68949, 68981),
-    (68950, 68982),
-    (68951, 68983),
-    (68952, 68984),
-    (68953, 68985),
-    (68954, 68986),
-    (68955, 68987),
-    (68956, 68988),
-    (68957, 68989),
-    (68958, 68990),
-    (68959, 68991),
-    (68960, 68992),
-    (68961, 68993),
-    (68962, 68994),
-    (68963, 68995),
-    (68964, 68996),
-    (68965, 68997),
-    (93856, 93883),
-    (93857, 93884),
-    (93858, 93885),
-    (93859, 93886),
-    (93860, 93887),
-    (93861, 93888),
-    (93862, 93889),
-    (93863, 93890),
-    (93864, 93891),
-    (93865, 93892),
-    (93866, 93893),
-    (93867, 93894),
-    (93868, 93895),
-    (93869, 93896),
-    (93870, 93897),
-    (93871, 93898),
-    (93872, 93899),
-    (93873, 93900),
-    (93874, 93901),
-    (93875, 93902),
-    (93876, 93903),
-    (93877, 93904),
-    (93878, 93905),
-    (93879, 93906),
-    (93880, 93907),
 ];
 // END GENERATED REGEX CASE RELATIONS
 
@@ -887,6 +801,19 @@ pub(super) fn version_dependent(c: char) -> bool {
         || REGEX_CASE_ENDPOINTS.binary_search(&c).is_ok()
 }
 
+/// Check the closed range without walking its code points. Endpoints alone
+/// cannot validate a custom class: its interior can name a guarded scalar.
+pub(super) fn range_version_dependent(start: char, end: char) -> bool {
+    let (start, end) = (u32::from(start), u32::from(end));
+    let at = VERSION_DEPENDENT.partition_point(|&(_, last)| last < start);
+    VERSION_DEPENDENT
+        .get(at)
+        .is_some_and(|&(first, _)| first <= end)
+        || REGEX_CASE_ENDPOINTS
+            .get(REGEX_CASE_ENDPOINTS.partition_point(|&c| c < start))
+            .is_some_and(|&c| c <= end)
+}
+
 fn validate_unicode(text: &str, file: &str, mode: Lines) -> Result<(), String> {
     for (line, text) in lines(text, mode).enumerate() {
         if text.chars().any(version_dependent) {
@@ -1149,9 +1076,7 @@ fn own_rules(path: &str) -> Result<Vec<Check>, String> {
 /// `path` relative to `root` when it lies below it (both with symbolic
 /// links resolved), else `path` as given.
 fn relative(path: &Path, root: &Path) -> Result<String, String> {
-    if utf8_path(path)?.chars().any(version_dependent) {
-        return Err("selected filename has Unicode version-dependent text".into());
-    }
+    validate_filename(path)?;
     let abs = if path.is_absolute() {
         path.to_path_buf()
     } else {
@@ -1165,15 +1090,20 @@ fn relative(path: &Path, root: &Path) -> Result<String, String> {
             .map_or_else(|_| abs.clone(), |d| d.join(name)),
         _ => abs.clone(),
     };
-    if utf8_path(&placed)?.chars().any(version_dependent) {
-        return Err("selected filename has Unicode version-dependent text".into());
-    }
+    validate_filename(&placed)?;
     match placed.strip_prefix(root) {
         Ok(rel) if !rel.as_os_str().is_empty() => utf8_path(rel).map(str::to_owned),
         _ => utf8_path(path).map(str::to_owned),
     }
 }
 
+fn validate_filename(path: &Path) -> Result<(), String> {
+    if utf8_path(path)?.chars().any(version_dependent) {
+        return Err("selected filename has Unicode version-dependent text".into());
+    }
+    Ok(())
+}
+
 fn utf8_path(path: &Path) -> Result<&str, String> {
     path.to_str()
         .ok_or_else(|| "path is not valid UTF-8".into())
@@ -1325,7 +1255,7 @@ fn validate_symlink_chain(path: &Path) -> Result<(), String> {
         prefix.push(component);
         match std::fs::read_link(&prefix) {
             Ok(target) => {
-                utf8_path(&target)?;
+                validate_filename(&target)?;
                 hops += 1;
                 if hops > 40 {
                     return Err("cannot validate symlink target".into());
@@ -2786,6 +2716,27 @@ mod tests {
                 Rule::compile(pattern, false).is_err(),
                 "guarded range accepted"
             );
+            let f = Fixture::new("r6-range");
+            r5_git(&f, &["init", "-q"], b"");
+            std::fs::write(f.0.join("own.md"), "clean").unwrap();
+            std::fs::write(f.0.join("patterns"), pattern).unwrap();
+            r5_git(&f, &["add", "own.md"], b"");
+            for cached in [false, true] {
+                for explicit in [false, true] {
+                    let mut args = f.args(if explicit { &["own.md"] } else { &[] });
+                    args.extend([
+                        "--patterns".into(),
+                        f.0.join("patterns").display().to_string(),
+                    ]);
+                    if cached {
+                        args.push("--cached".into());
+                    }
+                    let (mut out, mut err) = (Vec::new(), Vec::new());
+                    assert_eq!(cli(&args, &mut out, &mut err), 2);
+                    assert!(out.is_empty());
+                    assert!(!String::from_utf8_lossy(&err).contains(pattern));
+                }
+            }
         }
     }
 
@@ -2935,7 +2886,7 @@ except ImportError:
     import sre_compile
     _EXTRA_CASES=sre_compile._ignorecase_fixes
 buckets={}
-for c in range(0x110000):
+for c in range(0x10000):
     if 0xd800 <= c <= 0xdfff: continue
     lower=_sre.unicode_tolower(c)
     if lower != c or _sre.unicode_iscased(c): buckets.setdefault(lower,set()).add(c)
@@ -2953,7 +2904,9 @@ for group in buckets.values():
             assert!(output.stderr.is_empty());
             for row in String::from_utf8(output.stdout).unwrap().lines() {
                 let (a, b) = row.split_once(' ').unwrap();
-                pairs.insert((a.parse::<u32>().unwrap(), b.parse::<u32>().unwrap()));
+                let pair = (a.parse::<u32>().unwrap(), b.parse::<u32>().unwrap());
+                assert!(pair.0 <= 0xffff && pair.1 <= 0xffff);
+                pairs.insert(pair);
             }
             interpreters.push(command);
         }
@@ -2962,15 +2915,41 @@ for group in buckets.values():
         let mut baseline = None;
         let mut differing = std::collections::BTreeSet::new();
         for command in interpreters {
-            let mut child = Command::new(command).args(["-I", "-c", r#"
+            let mut child = Command::new(command)
+                .args([
+                    "-I",
+                    "-c",
+                    r#"
 import re,sys
 for row in sys.stdin:
     a,b=map(int,row.split()); a,b=chr(a),chr(b)
-    # Both directions, literals, and positive/negative classes. This also
-    # catches compiler asymmetries instead of assuming an equivalence class.
+    # Exercise compiler optimizations in both directions. Category unions,
+    # negation, ranges and grouping can select different engine instructions.
+    def shapes(s):
+        e=re.escape(s)
+        patterns=[e, '(?:'+e+')', '('+e+')', '['+e+']', '[^'+e+']',
+            '['+e+'Z]', '[^'+e+'Z]',
+            e+'|Z', 'Z|'+e, '(?:'+e+'|Z)', '('+e+'|Z)',
+            '(?:'+e+')|(?:Z)', '(?:(?:'+e+')|(?:Z))']
+        for category in (r'\d',r'\D',r'\w',r'\W',r'\s',r'\S'):
+            for extra in (category,'Z'+category):
+                patterns.extend(('['+e+extra+']','[^'+e+extra+']'))
+        c=ord(s)
+        for lo,hi in ((c,c+1),(c-1,c),(c-1,c+1)):
+            if 0 <= lo <= hi <= 0xffff and not (lo <= 0xdfff and hi >= 0xd800):
+                span=re.escape(chr(lo))+'-'+re.escape(chr(hi))
+                for extra in ('','Z',r'\d',r'\D',r'\w',r'\W',r'\s',r'\S'):
+                    patterns.extend(('['+span+extra+']','[^'+span+extra+']'))
+        return patterns
     print(''.join(str(int(re.fullmatch(p,t,re.IGNORECASE) is not None))
-        for s,t in ((a,b),(b,a)) for p in (re.escape(s),'['+re.escape(s)+']','[^'+re.escape(s)+']')))
-"#]).stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped()).spawn().unwrap();
+        for s,t in ((a,b),(b,a)) for p in shapes(s)))
+"#,
+                ])
+                .stdin(Stdio::piped())
+                .stdout(Stdio::piped())
+                .stderr(Stdio::piped())
+                .spawn()
+                .unwrap();
             let mut stdin = child.stdin.take().unwrap();
             let bytes = input.clone();
             let writer = std::thread::spawn(move || stdin.write_all(bytes.as_bytes()));
diff --git a/scripts/ci/check-personal-data.sh b/scripts/ci/check-personal-data.sh
index b56a9c08c..de0abadbe 100755
--- a/scripts/ci/check-personal-data.sh
+++ b/scripts/ci/check-personal-data.sh
@@ -68,15 +68,24 @@
 # text, filenames, custom patterns (including escaped literals), or ALLOW/SKIP rows.
 # ALLOW cannot exempt such text. Use an ASCII SKIP glob to exempt its file.
 # A letter from a script newer than Unicode 13 therefore stops the scan
-# until its file is skipped. Newer plain symbols and emoji still scan.
+# until its file is skipped. Every astral scalar with a case mapping or used
+# as a mapping target in UCD 13/15/16/17 is also refused, regardless of the
+# pattern shape. Text in Deseret, Osage, Old Hungarian, Warang Citi,
+# Medefaidrin, Adlam and any other astral cased script stops the scan until
+# its file is SKIPped. Newer plain symbols, emoji and uncased CJK still scan.
+# A custom class range containing a guarded scalar is refused, even when
+# its endpoints are stable. ASCII and stable Latin-1 ranges remain supported.
 #
 # The generated conservative set includes every scalar unassigned in UCD
 # 17; post-13 letters, marks, numbers, connectors, spaces and case mappings;
 # and older scalars whose word/digit/space membership or case maps change
 # in UCD 13/15/16/17. Full case folds avoid rejecting six stable old scalars.
-# Another generated table guards both ends of regex case relations that differ
-# across supported Python engines. It comes from real re.fullmatch calls,
-# including literal, positive-class and negative-class patterns both ways.
+# Another generated table guards both ends of BMP regex case relations that
+# differ across supported Python engines. Real re.fullmatch calls check both
+# directions with literals, singleton and composite positive/negative classes,
+# ASCII/category mixtures, range endpoints/interiors, optimized alternatives
+# and grouped forms. Astral mappings come from UnicodeData, SpecialCasing
+# and CaseFolding, all SHA-256-pinned, with no interpreter test needed.
 # The 248 newer scalars with stable effective behavior remain conservatively
 # blocked. The six stable scalars assigned by Unicode 13 pass.
 # This adds one binary-search lookup per non-ASCII character (ASCII is
diff --git a/tests/parity/gen/personal-unicode-generator.rs b/tests/parity/gen/personal-unicode-generator.rs
index 154a2dc09..7d49f4be7 100644
--- a/tests/parity/gen/personal-unicode-generator.rs
+++ b/tests/parity/gen/personal-unicode-generator.rs
@@ -6,6 +6,7 @@ use std::{env, fs, path::Path};
 #[derive(Clone, Default, PartialEq, Eq)]
 struct Properties {
     category: String,
+    astral_case: bool,
     space: bool,
     case: [String; 4], // simple upper/lower/title mappings and full case fold
 }
@@ -50,12 +51,35 @@ fn read(dir: &Path, version: &str) -> Vec<Properties> {
             assert!(!p.assigned());
             *p = Properties {
                 category: f[2].into(),
+                astral_case: false,
                 space: f[2] == "Zs" || matches!(f[4], "WS" | "B" | "S"),
                 case: [f[12].into(), f[13].into(), f[14].into(), String::new()],
             };
         }
     }
     assert!(start.is_none());
+    // The astral rule uses every mapping, including full mappings and their
+    // targets. It does not depend on any interpreter or regex pattern shape.
+    for line in data.lines() {
+        let f: Vec<_> = line.split(';').collect();
+        let c = usize::from_str_radix(f[0], 16).unwrap();
+        for mapping in &f[12..15] {
+            mark_astral_case(&mut table, c, mapping);
+        }
+    }
+    let special = fs::read_to_string(dir.join(version).join("SpecialCasing.txt")).unwrap();
+    assert!(special.contains(&format!("SpecialCasing-{version}.txt")));
+    for line in special.lines() {
+        let line = line.split('#').next().unwrap().trim();
+        if line.is_empty() {
+            continue;
+        }
+        let f: Vec<_> = line.split(';').map(str::trim).collect();
+        let c = usize::from_str_radix(f[0], 16).unwrap();
+        for mapping in &f[1..4] {
+            mark_astral_case(&mut table, c, mapping);
+        }
+    }
     let folding = fs::read_to_string(dir.join(version).join("CaseFolding.txt")).unwrap();
     assert!(folding.contains(&format!("CaseFolding-{version}.txt")));
     for line in folding.lines() {
@@ -64,6 +88,8 @@ fn read(dir: &Path, version: &str) -> Vec<Properties> {
             continue;
         }
         let f: Vec<_> = line.split(';').map(str::trim).collect();
+        let source = usize::from_str_radix(f[0], 16).unwrap();
+        mark_astral_case(&mut table, source, f[2]);
         if matches!(f[1], "C" | "F") {
             let c = usize::from_str_radix(f[0], 16).unwrap();
             assert!(table[c].assigned());
@@ -72,6 +98,19 @@ fn read(dir: &Path, version: &str) -> Vec<Properties> {
     }
     table
 }
+fn mark_astral_case(table: &mut [Properties], source: usize, mapping: &str) {
+    for target in mapping.split_whitespace() {
+        let target = usize::from_str_radix(target, 16).unwrap();
+        if target != source {
+            if source > 0xffff {
+                table[source].astral_case = true;
+            }
+            if target > 0xffff {
+                table[target].astral_case = true;
+            }
+        }
+    }
+}
 fn main() {
     let args: Vec<_> = env::args().collect();
     assert_eq!(args.len(), 3, "usage: generator UCD_DIR OUTPUT");
@@ -86,7 +125,8 @@ fn main() {
             continue;
         }
         let old = &tables[0][c];
-        *bad = !tables[3][c].assigned()
+        *bad = tables.iter().any(|t| t[c].astral_case)
+            || !tables[3][c].assigned()
             || (!old.assigned() && tables.iter().any(|t| t[c].sensitive()))
             || (old.assigned() && tables.iter().any(|t| t[c].signature() != old.signature()));
     }
diff --git a/tests/parity/gen/personal-unicode-sources.tsv b/tests/parity/gen/personal-unicode-sources.tsv
index 1656898ad..9972d1ac4 100644
--- a/tests/parity/gen/personal-unicode-sources.tsv
+++ b/tests/parity/gen/personal-unicode-sources.tsv
@@ -6,3 +6,7 @@ ff58e5823bd095166564a006e47d111130813dcf8bf234ef79fa51a870edb48f	16.0.0/UnicodeD
 6f1f9c588eb4a5c718d9e8f93b782685e5c7fec872cf05e8e6878053599e09bb	16.0.0/CaseFolding.txt
 2e1efc1dcb59c575eedf5ccae60f95229f706ee6d031835247d843c11d96470c	17.0.0/UnicodeData.txt
 ff8d8fefbf123574205085d6714c36149eb946d717a0c585c27f0f4ef58c4183	17.0.0/CaseFolding.txt
+6424312f1dc39b22e0ff9c0ffb13dfad424d9b03e6a6dc6bca941f6bf5ef1ffd	13.0.0/SpecialCasing.txt
+78b29c64b5840d25c11a9f31b665ee551b8a499eca6c70d770fcad7dd710f494	15.0.0/SpecialCasing.txt
+8d5de354eef79f2395a54c9c7dcebbaf3d30fc962d0f85611ea97aa973a0c451	16.0.0/SpecialCasing.txt
+efc25faf19de21b92c1194c111c932e03d2a5eaf18194e33f1156e96de4c9588	17.0.0/SpecialCasing.txt

From cc98f40409f4680f432803c6e508c4fc452dcb5a Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 19:33:20 +0100
Subject: [PATCH 68/76] fix(dev): check offsets and output streams before
 reporting success

---
 .github/workflows/guard.yml        |   3 +
 CHANGELOG.md                       |   2 +
 docs/rust.md                       |  27 ++++-
 rust/crates/og-dev/src/evidence.rs | 180 +++++++++++++++++++++++------
 rust/crates/og-dev/src/fixture.rs  |  75 ++++++++++--
 rust/crates/og-dev/src/lib.rs      |  97 ++++++++++++++--
 rust/crates/og-dev/src/renovate.rs |  71 ++++++++++--
 7 files changed, 390 insertions(+), 65 deletions(-)

diff --git a/.github/workflows/guard.yml b/.github/workflows/guard.yml
index 304360fbd..4cc06645e 100644
--- a/.github/workflows/guard.yml
+++ b/.github/workflows/guard.yml
@@ -282,6 +282,9 @@ jobs:
       - name: cargo test
         run: cargo test --workspace --locked --no-fail-fast
 
+      - name: Evidence offset regression in release mode
+        run: cargo test --release --locked -p og-dev --no-fail-fast fai_offsets_reject_overflow_and_out_of_file_before_publication
+
       - name: pycompat against CPython (python3 -I in PYTHON_IMAGE, 100000 cases per operation)
         if: ${{ !cancelled() }}   # runs even when a step above failed, so each result shows
         run: |
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 90f203d7d..a7f197e0e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,8 @@ Each release's notes. From 1.0.0 on, a major or minor release has hand-written n
 
 ## Unreleased
 
+- CI evidence rejects FASTA offset overflow and offsets outside the file before reading or publishing. Guard tests this in both debug and release builds. Every new dev verb fails on stdout or stderr write or flush errors. A truth VCF header after the first data record fails without replacing the destination. Additional deliberate refusals are documented and tested: zero-byte gzip inputs, zero-width unused FAI rows, non-ASCII or out-of-range annotation limits, non-writable staging parents, and gzip FASTA files with long FNAME headers. Publication replaces a file and leaves other hard links on the old inode.
+
 - CI evidence and Renovate inputs now enforce their original explicit gzip or plain format above strict UTF-8 and universal-newline handling. Renovate normalizes repository sources too and accepts falsy warnings and packages with no dependencies. Output publication follows destination symlinks, preserves existing permissions, rejects read-only files and directories, and uses the umask for new files. VNtyper uses private temporary directories with failure and signal cleanup, and GNU `mv -T` prevents publication inside a directory. Comphet stages and validates all destinations before publishing. Three renames are still not one transaction. Stricter parsing is deliberate and tested: BED refuses unsupported Unicode/control whitespace, Renovate refuses wrong-typed present values, PharmCAT refuses truthy non-list containers and non-object alleles, evidence positions must be ASCII u64 values, truth VCF rows need five columns, blank FAI rows fail, text records have a 16 MiB limit, and clash rows need a trailing VCF column after ALT. Truth VCF records get a final LF. `docs/rust.md` lists the error classes.
 
 - `og dev evidence` now rejects invalid UTF-8, truncated selected records, blank BED rows and missing panel headers. It reads LF, CRLF and CR line endings alike, with a 16 MiB limit per record. Single-file evidence and fixture outputs are published by rename after validation. Comphet stages and validates all three outputs before its first rename. Three renames are still not one transaction. A crash or a filesystem failure between renames can publish only part of the new set. `og dev renovate-check` rejects malformed log records and present fields of the wrong type, and fails if its configured step summary cannot be written. The PharmCAT trimmer consumes source genes as it trims them. The VNtyper downloader also accepts output paths that contain a newline.
diff --git a/docs/rust.md b/docs/rust.md
index 91928df39..4a276128f 100644
--- a/docs/rust.md
+++ b/docs/rust.md
@@ -132,11 +132,17 @@ Comphet stages all three files and checks all three destinations before the
 first rename. A bad later destination leaves previous outputs intact.
 Three renames are still not one transaction. A crash or a filesystem failure
 between renames can publish only part of the new set. Unhandled SIGKILL can
-leave temporary files. Single-file outputs are replaced by one rename.
+leave temporary files. Single-file outputs are replaced by one rename. Publication replaces the file
+and does not update other hard links. Those links still refer to the old inode.
+
+The shared runner fails the command if stdout or stderr cannot be written or
+flushed. This includes the evidence status and Renovate table. A configured
+Renovate summary must also be written and flushed successfully.
+Guard runs the FASTA offset regression in debug and release profiles.
 
 ### Stricter than the replaced Python, on purpose
 
-Each refusal below has a pinned negative CLI test with exit 1 and a stable
+Each refusal below has a pinned negative CLI test with exit 1 or 2 and a stable
 error class in `og-dev`. The final-LF normalization has a positive byte test.
 
 - BED fields use spaces and tabs as separators. Other Python whitespace
@@ -154,3 +160,20 @@ error class in `og-dev`. The final-LF normalization has a positive byte test.
 - Clash VCF rows need a tab after ALT. A newline in the ALT field of a short
   row fails with `missing trailing VCF columns`.
 - A truth VCF record without its final LF gets one in the output. Valid VCF ends with LF.
+
+- Zero-byte gzip VCFs or selected gzip tables fail with `wrong compression (expected gzip)`.
+- Every FAI row needs nonzero bases per line, including unused rows.
+  A zero width fails with `a row has 0 bases per line`.
+- `MAX_ANNOTATIONS` must parse as a signed 64-bit ASCII integer.
+  Underscores, non-ASCII digits and out-of-range values fail with
+  `MAX_ANNOTATIONS ... is not a whole number` (exit 2).
+- Staging needs a writable parent directory, even for an existing writable file.
+  A parent with no write bits fails with `parent directory is not writable`.
+  Other access failures report the operating system error.
+- The FASTA reader accepts plain files only. A gzip magic prefix fails with
+  `wrong compression (expected plain)`, including gzip with a long FNAME.
+- A VCF header after the first truth record fails with
+  `VCF header after first data record`. The previous destination stays intact.
+- FASTA offsets use checked subtraction, division, multiplication, addition
+  and remainder. Overflow, a position beyond the file, or an offset outside
+  the signed file-offset range fails with `invalid FASTA offset`.
diff --git a/rust/crates/og-dev/src/evidence.rs b/rust/crates/og-dev/src/evidence.rs
index 547bf903b..a3e2f12db 100644
--- a/rust/crates/og-dev/src/evidence.rs
+++ b/rust/crates/og-dev/src/evidence.rs
@@ -123,13 +123,16 @@ fn input_lines(
         }
         let end = chunk.iter().position(|b| matches!(b, b'\r' | b'\n'));
         let n = end.unwrap_or(chunk.len());
-        if line.len() + n > MAX_LINE {
+        if line.len().checked_add(n).is_none_or(|len| len > MAX_LINE) {
             return Err(format!("{path}: record exceeds {MAX_LINE} bytes"));
         }
         line.extend_from_slice(&chunk[..n]);
         if end.is_some() {
             after_cr = chunk[n] == b'\r';
-            r.consume(n + 1);
+            r.consume(
+                n.checked_add(1)
+                    .ok_or_else(|| format!("{path}: record size overflows"))?,
+            );
             std::str::from_utf8(&line).map_err(|e| format!("{path}: invalid UTF-8: {e}"))?;
             f(&line)?;
             line.clear();
@@ -206,6 +209,17 @@ impl PendingOutput {
         static NEXT: AtomicU64 = AtomicU64::new(0);
         let destination = resolve_destination(destination)?;
         let permissions = validate_destination(&destination)?;
+        let parent = destination
+            .parent()
+            .filter(|p| !p.as_os_str().is_empty())
+            .unwrap_or(Path::new("."));
+        let meta = fs::metadata(parent).map_err(|e| format!("{}: {e}", parent.display()))?;
+        if meta.permissions().mode() & 0o222 == 0 {
+            return Err(format!(
+                "{}: parent directory is not writable",
+                destination.display()
+            ));
+        }
         let name = destination.file_name().ok_or("output has no file name")?;
         loop {
             let mut tmp = std::ffi::OsString::from(".");
@@ -280,7 +294,8 @@ fn clash_positions(
     chroms: &BTreeSet<Vec<u8>>,
 ) -> Result<BTreeSet<(Vec<u8>, u64)>, String> {
     let mut hit = BTreeSet::new();
-    let (mut key, mut n, mut snvs): (Option<(Vec<u8>, u64)>, u32, u32) = (None, 0, 0);
+    let (mut key, mut seen, mut multiple, mut snv): (Option<(Vec<u8>, u64)>, bool, bool, bool) =
+        (None, false, false, false);
     input_lines(path, true, |line| {
         if line.first() == Some(&b'#') {
             return Ok(());
@@ -297,12 +312,13 @@ fn clash_positions(
         let k = (c[0].to_vec(), pos(c[1], path)?);
         if key.as_ref() != Some(&k) {
             key = Some(k.clone());
-            (n, snvs) = (0, 0);
+            (seen, multiple, snv) = (false, false, false);
         }
-        n += 1;
+        multiple |= seen;
+        seen = true;
         let one = |a: &[u8]| std::str::from_utf8(a).map_or(a.len(), |s| s.chars().count()) == 1;
-        snvs += u32::from(one(c[3]) && one(c[4]));
-        if n >= 2 && snvs >= 1 {
+        snv |= one(c[3]) && one(c[4]);
+        if multiple && snv {
             hit.insert(k);
         }
         Ok(())
@@ -355,7 +371,12 @@ fn clashes(raw: &str, split: &str, data: &str, out: &str) -> Result<(), String>
             }
             let p = pos(c[1], &path)?;
             for (k, w) in want.iter().enumerate() {
-                on_table[k] += u64::from(w.contains(&p));
+                let count = on_table
+                    .get_mut(k)
+                    .ok_or("table counter index out of range")?;
+                *count = count
+                    .checked_add(u64::from(w.contains(&p)))
+                    .ok_or_else(|| format!("{path}: table count overflows"))?;
             }
             Ok(())
         })?;
@@ -365,7 +386,7 @@ fn clashes(raw: &str, split: &str, data: &str, out: &str) -> Result<(), String>
         text += &format!(
             "{name}_positions\t{}\n{name}_on_table\t{}\n",
             s.len(),
-            on_table[k]
+            on_table.get(k).ok_or("table counter index out of range")?
         );
     }
     publish(Path::new(out), text.as_bytes())
@@ -419,7 +440,9 @@ fn merge(mut spans: Vec<(u64, u64)>) -> Vec<(u64, u64)> {
 /// Is `p` inside one of the sorted, disjoint spans?
 fn inside(spans: &[(u64, u64)], p: u64) -> bool {
     let i = spans.partition_point(|&(s, _)| s <= p);
-    i > 0 && p < spans[i - 1].1
+    i.checked_sub(1)
+        .and_then(|j| spans.get(j))
+        .is_some_and(|&(_, end)| p < end)
 }
 
 fn hg002_gvcf(
@@ -431,6 +454,10 @@ fn hg002_gvcf(
 ) -> Result<(u64, u64), String> {
     let fai = read_fai(&format!("{reference}.fai"))?;
     let fasta = File::open(reference).map_err(|e| format!("{reference}: {e}"))?;
+    let fasta_len = fasta
+        .metadata()
+        .map_err(|e| format!("{reference}: {e}"))?
+        .len();
     let mut magic = [0; 2];
     if fasta
         .read_at(&mut magic, 0)
@@ -471,7 +498,9 @@ fn hg002_gvcf(
     let confident = |c: &[u8], p: u64| {
         conf.get(c).is_some_and(|v| {
             let i = v.partition_point(|&(s, _)| s < p);
-            i > 0 && v[i - 1].1 >= p
+            i.checked_sub(1)
+                .and_then(|j| v.get(j))
+                .is_some_and(|&(_, end)| end >= p)
         })
     };
 
@@ -481,6 +510,9 @@ fn hg002_gvcf(
     let mut covered: HashMap<Vec<u8>, Vec<(u64, u64)>> = HashMap::new();
     let mut records = 0u64;
     input_lines(truth, true, |line| {
+        if line.first() == Some(&b'#') && records != 0 {
+            return Err(format!("{truth}: VCF header after first data record"));
+        }
         if line.starts_with(b"##") {
         } else if line.first() == Some(&b'#') {
             w.write_all(b"##INFO=<ID=END,Number=1,Type=Integer,Description=\"End of the reference block\">\n##ALT=<ID=*,Description=\"Any other allele\">\n")
@@ -497,11 +529,15 @@ fn hg002_gvcf(
                     std::str::from_utf8(f[3])
                         .expect("strict reader")
                         .chars()
-                        .count() as u64,
+                        .count()
+                        .try_into()
+                        .map_err(|_| format!("{truth}: allele length overflows"))?,
                 )
                 .ok_or_else(|| format!("{truth}: position span overflows"))?,
             ));
-            records += 1;
+            records = records
+                .checked_add(1)
+                .ok_or_else(|| format!("{truth}: record count overflows"))?;
         }
         w.write_all(line)
             .and_then(|()| w.write_all(b"\n"))
@@ -527,8 +563,20 @@ fn hg002_gvcf(
         {
             return Ok(());
         }
-        let at =
-            row.offset + ((p - 1) / row.line_bases) * row.line_bytes + (p - 1) % row.line_bases;
+        let invalid = || format!("{reference}: invalid FASTA offset: overflow or outside file");
+        let zero = p.checked_sub(1).ok_or_else(invalid)?;
+        let at = zero
+            .checked_div(row.line_bases)
+            .and_then(|line| line.checked_mul(row.line_bytes))
+            .and_then(|relative| row.offset.checked_add(relative))
+            .and_then(|start| {
+                zero.checked_rem(row.line_bases)
+                    .and_then(|col| start.checked_add(col))
+            })
+            .ok_or_else(invalid)?;
+        if at > i64::MAX as u64 || at.checked_add(1).is_none_or(|end| end > fasta_len) {
+            return Err(invalid());
+        }
         fasta
             .read_exact_at(&mut base, at)
             .map_err(|e| format!("{reference}: {e}"))?;
@@ -537,9 +585,17 @@ fn hg002_gvcf(
         if !b"ACGT".contains(&b) {
             return Ok(());
         }
-        blocks += 1;
+        blocks = blocks
+            .checked_add(1)
+            .ok_or_else(|| format!("{sites}: block count overflows"))?;
         w.write_all(c)
-            .and_then(|()| writeln!(w, "\t{p}\t.\t{}\t<*>\t.\t.\tEND={p}\tGT\t0/0", b as char))
+            .and_then(|()| {
+                writeln!(
+                    w,
+                    "\t{p}\t.\t{}\t<*>\t.\t.\tEND={p}\tGT\t0/0",
+                    char::from(b)
+                )
+            })
             .map_err(werr)
     })?;
     if first {
@@ -644,9 +700,9 @@ mod tests {
                 fs::write(self.dir.join(name), bytes).unwrap();
             }
         }
-        fn run(&self) -> Result<(), String> {
+        fn args(&self) -> Vec<String> {
             let p = |n: &str| self.dir.join(n).to_str().unwrap().to_owned();
-            let args = if self.kind == "clashes" {
+            if self.kind == "clashes" {
                 vec![
                     "clashes".to_owned(),
                     p("raw.vcf.gz"),
@@ -663,9 +719,11 @@ mod tests {
                     p("sites.tsv"),
                     p("out"),
                 ]
-            };
+            }
+        }
+        fn run(&self) -> Result<(), String> {
             let (mut out, mut err) = (Vec::new(), Vec::new());
-            match cli(&args, &mut out, &mut err) {
+            match cli(&self.args(), &mut out, &mut err) {
                 0 => Ok(()),
                 1 => Err(String::from_utf8(err).unwrap()),
                 code => panic!("unexpected CLI exit {code}: {err:?}"),
@@ -696,19 +754,37 @@ mod tests {
         }
     }
 
+    #[test]
+    fn evidence_status_uses_checked_runner() {
+        for kind in ["clashes", "hg002-gvcf"] {
+            let c = Case::new(kind, "streams");
+            crate::stream_tests::assert_status_errors(cli, &c.args(), kind == "hg002-gvcf");
+        }
+    }
+
     #[test]
     fn fai_offsets_reject_overflow_and_out_of_file_before_publication() {
         for (offset, bases, bytes, position) in [
             (18446744073709551598u64, 1, 2, 13),
             (1, 1, u64::MAX, 3),
             (u64::MAX, 1, 1, 1),
+            (u64::MAX - 1, 50, 51, 3),
             (1000, 50, 51, 1),
         ] {
             let c = Case::new("hg002-gvcf", &format!("offset-{offset}-{position}"));
-            c.put("ref.fasta.fai", format!("chrA\t50\t{offset}\t{bases}\t{bytes}\n").as_bytes());
-            c.put("sites.tsv", format!("id\tchr\tpos\nx\tchrA\t{position}\n").as_bytes());
+            c.put(
+                "ref.fasta.fai",
+                format!("chrA\t50\t{offset}\t{bases}\t{bytes}\n").as_bytes(),
+            );
+            c.put(
+                "sites.tsv",
+                format!("id\tchr\tpos\nx\tchrA\t{position}\n").as_bytes(),
+            );
             c.put("truth.bed", b"chrA\t0\t50\n");
-            c.put("truth.vcf.gz", b"##fileformat=VCFv4.2\n#CHROM\tPOS\tID\tREF\tALT\n");
+            c.put(
+                "truth.vcf.gz",
+                b"##fileformat=VCFv4.2\n#CHROM\tPOS\tID\tREF\tALT\n",
+            );
             c.fails_without_publication();
             assert!(c.run().unwrap_err().contains(": invalid FASTA offset:"));
         }
@@ -718,38 +794,63 @@ mod tests {
     fn late_vcf_headers_fail_before_publication() {
         for header in [b"##late=yes\n".as_slice(), b"#CHROM\tPOS\n"] {
             let c = Case::new("hg002-gvcf", &format!("late-{}", header.len()));
-            c.put("truth.vcf.gz", &[c.text("truth.vcf.gz"), header.to_vec()].concat());
+            c.put(
+                "truth.vcf.gz",
+                &[c.text("truth.vcf.gz"), header.to_vec()].concat(),
+            );
             c.fails_without_publication();
-            assert!(c.run().unwrap_err().contains(": VCF header after first data record"));
+            assert!(
+                c.run()
+                    .unwrap_err()
+                    .contains(": VCF header after first data record")
+            );
         }
     }
 
     #[test]
     fn empty_gzip_inputs_and_unused_zero_width_fai_rows_fail() {
         for (kind, name) in [
-            ("clashes", "raw.vcf.gz"), ("clashes", "split.vcf.gz"),
-            ("clashes", "chrA.tsv.gz"), ("hg002-gvcf", "truth.vcf.gz"),
+            ("clashes", "raw.vcf.gz"),
+            ("clashes", "split.vcf.gz"),
+            ("clashes", "chrA.tsv.gz"),
+            ("hg002-gvcf", "truth.vcf.gz"),
         ] {
             let c = Case::new(kind, name);
             fs::write(c.dir.join(name), b"").unwrap();
             c.fails_without_publication();
-            assert!(c.run().unwrap_err().contains(": wrong compression (expected gzip)"));
+            assert!(
+                c.run()
+                    .unwrap_err()
+                    .contains(": wrong compression (expected gzip)")
+            );
         }
         let c = Case::new("hg002-gvcf", "unused-row");
-        c.put("ref.fasta.fai", &[c.text("ref.fasta.fai"), b"chrUnused\t0\t0\t0\t0\n".to_vec()].concat());
+        c.put(
+            "ref.fasta.fai",
+            &[c.text("ref.fasta.fai"), b"chrUnused\t0\t0\t0\t0\n".to_vec()].concat(),
+        );
         c.fails_without_publication();
-        assert!(c.run().unwrap_err().contains(": a row has 0 bases per line"));
+        assert!(
+            c.run()
+                .unwrap_err()
+                .contains(": a row has 0 bases per line")
+        );
     }
 
     #[test]
     fn gzip_fasta_with_ascii_fname_is_refused_by_format_guard() {
         let c = Case::new("hg002-gvcf", "fname");
-        let mut gz = flate2::GzBuilder::new().filename(vec![b'A'; 200])
+        let mut gz = flate2::GzBuilder::new()
+            .filename(vec![b'A'; 200])
             .write(Vec::new(), flate2::Compression::default());
         gz.write_all(&c.text("ref.fasta")).unwrap();
         fs::write(c.dir.join("ref.fasta"), gz.finish().unwrap()).unwrap();
         c.fails_without_publication();
-        assert!(c.run().unwrap_err().contains(": wrong compression (expected plain)"));
+        assert!(
+            c.run()
+                .unwrap_err()
+                .contains(": wrong compression (expected plain)")
+        );
     }
 
     #[test]
@@ -760,7 +861,11 @@ mod tests {
             fs::set_permissions(&c.dir, fs::Permissions::from_mode(0o555)).unwrap();
             let result = c.run();
             fs::set_permissions(&c.dir, fs::Permissions::from_mode(0o755)).unwrap();
-            assert!(result.unwrap_err().contains(": parent directory is not writable"));
+            assert!(
+                result
+                    .unwrap_err()
+                    .contains(": parent directory is not writable")
+            );
             assert_eq!(fs::read(c.dir.join("out")).unwrap(), b"PREVIOUS OUTPUT\n");
         }
     }
@@ -906,7 +1011,12 @@ mod tests {
                 };
                 fs::write(c.dir.join(name), wrong).unwrap();
                 c.fails_without_publication();
-                assert!(c.run().unwrap_err().contains(": wrong compression (expected "), "{name}");
+                assert!(
+                    c.run()
+                        .unwrap_err()
+                        .contains(": wrong compression (expected "),
+                    "{name}"
+                );
             }
         }
     }
diff --git a/rust/crates/og-dev/src/fixture.rs b/rust/crates/og-dev/src/fixture.rs
index 3371b7a91..ec74f8dd3 100644
--- a/rust/crates/og-dev/src/fixture.rs
+++ b/rust/crates/og-dev/src/fixture.rs
@@ -461,10 +461,19 @@ fn diplotype(x: &Value) -> Result<Value, String> {
 }
 
 /// `items[:n]` with Python's slice rule for a negative `n`.
+#[allow(
+    clippy::manual_saturating_arithmetic,
+    reason = "Python slices clamp a checked negative end at zero"
+)]
 fn head(items: &[Value], n: i64) -> &[Value] {
-    let len = items.len() as i64;
-    let end = if n < 0 { (len + n).max(0) } else { n.min(len) };
-    &items[..end as usize]
+    // Clamp before slicing, including i64::MIN, without narrowing lengths.
+    let count = usize::try_from(n.unsigned_abs()).unwrap_or(usize::MAX);
+    let end = if n < 0 {
+        items.len().checked_sub(count).unwrap_or_default()
+    } else {
+        count.min(items.len())
+    };
+    &items[..end]
 }
 
 /// The trimmed report: every gene with its listed diplotypes and related
@@ -608,6 +617,41 @@ fn trim_pharmcat(src: &Path, dst: &Path, max: i64) -> Result<(), String> {
 mod tests {
     use super::*;
 
+    #[test]
+    fn fixture_verbs_use_checked_runner_even_with_empty_status() {
+        let d = std::env::temp_dir().join(format!("og-fixture-streams-{}", std::process::id()));
+        fs::create_dir_all(&d).unwrap();
+        fs::write(d.join("in"), br#"{"genes":{},"drugs":{}}"#).unwrap();
+        for args in [
+            vec![
+                "trim-pharmcat".into(),
+                d.join("in").to_str().unwrap().into(),
+                d.join("out").to_str().unwrap().into(),
+            ],
+            vec!["comphet".into(), d.to_str().unwrap().into()],
+        ] {
+            crate::stream_tests::assert_status_errors(cli, &args, false);
+        }
+        fs::remove_dir_all(d).unwrap();
+    }
+
+    #[test]
+    fn annotation_slices_clamp_extreme_counts_without_narrowing() {
+        let items = vec![Value::Null; 3];
+        for (n, expected) in [
+            (i64::MIN, 0),
+            (-4, 0),
+            (-3, 0),
+            (-2, 1),
+            (-1, 2),
+            (0, 0),
+            (1, 1),
+            (i64::MAX, 3),
+        ] {
+            assert_eq!(head(&items, n).len(), expected);
+        }
+    }
+
     #[test]
     fn non_ascii_or_out_of_range_annotation_limits_fail_at_cli() {
         let d = std::env::temp_dir().join(format!("og-limits-{}", std::process::id()));
@@ -615,12 +659,19 @@ mod tests {
         fs::write(d.join("in"), br#"{"genes":{},"drugs":{}}"#).unwrap();
         for limit in ["1_0", "٤", "18446744073709551616"] {
             fs::write(d.join("out"), b"old").unwrap();
-            let args = vec!["trim-pharmcat".into(), d.join("in").to_str().unwrap().into(),
-                d.join("out").to_str().unwrap().into(), limit.into()];
+            let args = vec![
+                "trim-pharmcat".into(),
+                d.join("in").to_str().unwrap().into(),
+                d.join("out").to_str().unwrap().into(),
+                limit.into(),
+            ];
             let (mut out, mut err) = (Vec::new(), Vec::new());
             assert_eq!(cli(&args, &mut out, &mut err), 2);
             let err = String::from_utf8(err).unwrap();
-            assert!(err.contains("error: MAX_ANNOTATIONS") && err.contains("is not a whole number"), "{err}");
+            assert!(
+                err.contains("error: MAX_ANNOTATIONS") && err.contains("is not a whole number"),
+                "{err}"
+            );
             assert_eq!(fs::read(d.join("out")).unwrap(), b"old");
         }
         fs::remove_dir_all(d).unwrap();
@@ -636,7 +687,11 @@ mod tests {
             fs::write(d.join(name), b"old").unwrap();
         }
         for args in [
-            vec!["trim-pharmcat".into(), d.join("in").to_str().unwrap().into(), d.join("out").to_str().unwrap().into()],
+            vec![
+                "trim-pharmcat".into(),
+                d.join("in").to_str().unwrap().into(),
+                d.join("out").to_str().unwrap().into(),
+            ],
             vec!["comphet".into(), d.to_str().unwrap().into()],
         ] {
             fs::set_permissions(&d, fs::Permissions::from_mode(0o555)).unwrap();
@@ -644,7 +699,11 @@ mod tests {
             let code = cli(&args, &mut out, &mut err);
             fs::set_permissions(&d, fs::Permissions::from_mode(0o755)).unwrap();
             assert_eq!(code, 1);
-            assert!(String::from_utf8(err).unwrap().contains(": parent directory is not writable"));
+            assert!(
+                String::from_utf8(err)
+                    .unwrap()
+                    .contains(": parent directory is not writable")
+            );
             for name in ["out", "reads.sam", "vep.vcf", "comphet.vcf"] {
                 assert_eq!(fs::read(d.join(name)).unwrap(), b"old");
             }
diff --git a/rust/crates/og-dev/src/lib.rs b/rust/crates/og-dev/src/lib.rs
index 14eb34dfb..1f8c44674 100644
--- a/rust/crates/og-dev/src/lib.rs
+++ b/rust/crates/og-dev/src/lib.rs
@@ -66,11 +66,54 @@ fn run(f: fn(&[String], &mut dyn Write, &mut dyn Write) -> u8, args: &[String])
 
 pub(crate) fn run_with_writers(
     f: fn(&[String], &mut dyn Write, &mut dyn Write) -> u8,
-    args: &[String], out: &mut dyn Write, err: &mut dyn Write,
+    args: &[String],
+    out: &mut dyn Write,
+    err: &mut dyn Write,
 ) -> u8 {
-    let code = f(args, out, err);
+    let mut out = CheckedWriter {
+        inner: out,
+        failure: None,
+    };
+    let mut err = CheckedWriter {
+        inner: err,
+        failure: None,
+    };
+    let code = f(args, &mut out, &mut err);
     let _ = out.flush();
-    code
+    if let Some(reason) = &out.failure {
+        let _ = writeln!(err, "og dev: stdout: {reason}");
+    }
+    let _ = err.flush();
+    if code == 0 && (out.failure.is_some() || err.failure.is_some()) {
+        1
+    } else {
+        code
+    }
+}
+
+/// Remember errors even when an older verb ignores its Write result.
+struct CheckedWriter<'a> {
+    inner: &'a mut dyn Write,
+    failure: Option<String>,
+}
+impl Write for CheckedWriter<'_> {
+    fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
+        let result = match self.inner.write(bytes) {
+            Ok(0) if !bytes.is_empty() => Err(std::io::Error::from(std::io::ErrorKind::WriteZero)),
+            result => result,
+        };
+        if let Err(e) = &result {
+            self.failure.get_or_insert_with(|| e.to_string());
+        }
+        result
+    }
+    fn flush(&mut self) -> std::io::Result<()> {
+        let result = self.inner.flush();
+        if let Err(e) = &result {
+            self.failure.get_or_insert_with(|| e.to_string());
+        }
+        result
+    }
 }
 
 /// Runs `og dev ARGS`; returns the exit code.
@@ -106,15 +149,42 @@ pub fn main(args: &[String]) -> u8 {
 #[cfg(test)]
 mod stream_tests {
     use super::*;
-    struct Fails { flush_only: bool }
+    struct Fails {
+        flush_only: bool,
+    }
     impl Write for Fails {
         fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
-            if self.flush_only { Ok(bytes.len()) } else { Err(std::io::Error::other("write control")) }
+            if self.flush_only {
+                Ok(bytes.len())
+            } else {
+                Err(std::io::Error::other("write control"))
+            }
         }
         fn flush(&mut self) -> std::io::Result<()> {
-            if self.flush_only { Err(std::io::Error::other("flush control")) } else { Ok(()) }
+            if self.flush_only {
+                Err(std::io::Error::other("flush control"))
+            } else {
+                Ok(())
+            }
         }
     }
+    pub(crate) fn assert_status_errors(
+        verb: fn(&[String], &mut dyn Write, &mut dyn Write) -> u8,
+        args: &[String],
+        writes: bool,
+    ) {
+        for flush_only in [false, true] {
+            let mut bad = Fails { flush_only };
+            let mut err = Vec::new();
+            assert_eq!(
+                run_with_writers(verb, args, &mut bad, &mut err),
+                u8::from(writes || flush_only),
+                "{}",
+                String::from_utf8_lossy(&err)
+            );
+        }
+    }
+
     #[test]
     fn added_verbs_propagate_write_and_flush_errors() {
         let verbs = [fixture::cli, evidence::cli, renovate::cli];
@@ -122,7 +192,10 @@ mod stream_tests {
             for flush_only in [false, true] {
                 let mut bad = Fails { flush_only };
                 let mut err = Vec::new();
-                assert_eq!(run_with_writers(verb, &["--help".into()], &mut bad, &mut err), 1);
+                assert_eq!(
+                    run_with_writers(verb, &["--help".into()], &mut bad, &mut err),
+                    1
+                );
                 assert!(String::from_utf8(err).unwrap().contains("stdout:"));
             }
         }
@@ -134,8 +207,14 @@ mod stream_tests {
             0
         }
         for flush_only in [false, true] {
-            assert_eq!(run_with_writers(clean, &[], &mut Vec::new(), &mut Fails { flush_only }), 1);
+            assert_eq!(
+                run_with_writers(clean, &[], &mut Vec::new(), &mut Fails { flush_only }),
+                1
+            );
         }
-        assert_eq!(run_with_writers(clean, &[], &mut Fails { flush_only: true }, &mut Vec::new()), 1);
+        assert_eq!(
+            run_with_writers(clean, &[], &mut Fails { flush_only: true }, &mut Vec::new()),
+            1
+        );
     }
 }
diff --git a/rust/crates/og-dev/src/renovate.rs b/rust/crates/og-dev/src/renovate.rs
index 74bbfb6a1..cafad1342 100644
--- a/rust/crates/og-dev/src/renovate.rs
+++ b/rust/crates/og-dev/src/renovate.rs
@@ -233,7 +233,8 @@ fn read_pins(repo: &Path, path: &Path) -> Result<Pins, String> {
         if line.is_empty() || line.starts_with('#') {
             continue;
         }
-        let at = |msg: &str| format!("{}:{}: {msg}", path.display(), i + 1);
+        let number = i.checked_add(1).ok_or("pin line number overflows")?;
+        let at = |msg: &str| format!("{}:{number}: {msg}", path.display());
         let cols: Vec<&str> = line.split('\t').collect();
         let [dep, files, pattern] = cols[..] else {
             return Err(at(
@@ -251,7 +252,7 @@ fn read_pins(repo: &Path, path: &Path) -> Result<Pins, String> {
             }
             let n = re.find_iter(&texts[&f]).count();
             if n > 0 {
-                *pins.want.entry((dep.to_owned(), f.clone())).or_default() += n;
+                add_count(pins.want.entry((dep.to_owned(), f.clone())).or_default(), n)?;
             }
             pins.files.entry(dep.to_owned()).or_default().insert(f);
         }
@@ -443,12 +444,21 @@ fn updates(d: &IndexMap<String, Value>) -> &[Value] {
     }
 }
 
-fn counter<'a>(it: impl Iterator<Item = &'a IndexMap<String, Value>>) -> BTreeMap<String, usize> {
+fn add_count(count: &mut usize, n: usize) -> Result<(), String> {
+    *count = count
+        .checked_add(n)
+        .ok_or("arithmetic: dependency count overflows")?;
+    Ok(())
+}
+
+fn counter<'a>(
+    it: impl Iterator<Item = &'a IndexMap<String, Value>>,
+) -> Result<BTreeMap<String, usize>, String> {
     let mut c = BTreeMap::new();
     for d in it {
-        *c.entry(key(d)).or_default() += 1;
+        add_count(c.entry(key(d)).or_default(), 1)?;
     }
-    c
+    Ok(c)
 }
 
 /// The docker dependencies of one file.
@@ -461,6 +471,10 @@ fn in_file<'a>(
 
 /// Every problem, as `check: ...` lines.
 fn check(deps: &[Dep], env_text: &str, pins: &Pins) -> Vec<String> {
+    check_counts(deps, env_text, pins).unwrap_or_else(|e| vec![e])
+}
+
+fn check_counts(deps: &[Dep], env_text: &str, pins: &Pins) -> Result<Vec<String>, String> {
     let mut fails = Vec::new();
     let docker: Vec<&Dep> = deps.iter().filter(|(_, d)| is_docker(d)).collect();
     let want = env_images(env_text);
@@ -491,9 +505,9 @@ fn check(deps: &[Dep], env_text: &str, pins: &Pins) -> Vec<String> {
             fails.push(format!("names: {f}: package name {}", r(name)));
         }
     }
-    let env_keys = counter(in_file(&docker, ENV));
+    let env_keys = counter(in_file(&docker, ENV))?;
     for f in TWINS {
-        let keys = counter(in_file(&docker, f));
+        let keys = counter(in_file(&docker, f))?;
         if f == DOCS && keys != env_keys {
             let all: BTreeSet<&String> = keys.keys().chain(env_keys.keys()).collect();
             for k in all {
@@ -562,7 +576,7 @@ fn check(deps: &[Dep], env_text: &str, pins: &Pins) -> Vec<String> {
         if let Value::Str(name) = get(d, "depName")
             && pins.files.get(name).is_some_and(|fs| fs.contains(f))
         {
-            *got.entry((name.clone(), f.clone())).or_default() += 1;
+            add_count(got.entry((name.clone(), f.clone())).or_default(), 1)?;
         }
     }
     let all: BTreeSet<&(String, String)> = pins.want.keys().chain(got.keys()).collect();
@@ -578,7 +592,7 @@ fn check(deps: &[Dep], env_text: &str, pins: &Pins) -> Vec<String> {
             ));
         }
     }
-    fails
+    Ok(fails)
 }
 
 /// Plants one fault of each kind in a copy of the dependencies and shows
@@ -898,6 +912,33 @@ mod tests {
         let _ = fs::remove_dir_all(&d);
     }
 
+    #[test]
+    fn renovate_table_uses_checked_runner() {
+        let d = planted("status");
+        let args = vec![
+            d.join("renovate.log").to_str().unwrap().into(),
+            "--repo".into(),
+            d.to_str().unwrap().into(),
+        ];
+        // No dependence on the process's GITHUB_STEP_SUMMARY environment.
+        fn verb(args: &[String], out: &mut dyn Write, err: &mut dyn Write) -> u8 {
+            cli_with_summary(args, out, err, None)
+        }
+        crate::stream_tests::assert_status_errors(verb, &args, true);
+        fs::remove_dir_all(d).unwrap();
+    }
+
+    #[test]
+    fn dependency_counts_refuse_overflow() {
+        let mut count = usize::MAX;
+        assert!(
+            add_count(&mut count, 1)
+                .unwrap_err()
+                .contains("dependency count overflows")
+        );
+        assert_eq!(count, usize::MAX);
+    }
+
     #[test]
     fn non_writable_summary_parent_preserves_previous_summary() {
         use std::os::unix::fs::PermissionsExt;
@@ -907,12 +948,20 @@ mod tests {
         let summary = parent.join("result");
         fs::write(&summary, b"old").unwrap();
         fs::set_permissions(&parent, fs::Permissions::from_mode(0o555)).unwrap();
-        let args = vec![d.join("renovate.log").to_str().unwrap().into(), "--repo".into(), d.to_str().unwrap().into()];
+        let args = vec![
+            d.join("renovate.log").to_str().unwrap().into(),
+            "--repo".into(),
+            d.to_str().unwrap().into(),
+        ];
         let (mut out, mut err) = (Vec::new(), Vec::new());
         let code = cli_with_summary(&args, &mut out, &mut err, Some(&summary));
         fs::set_permissions(&parent, fs::Permissions::from_mode(0o755)).unwrap();
         assert_eq!(code, 1);
-        assert!(String::from_utf8(err).unwrap().contains(": parent directory is not writable"));
+        assert!(
+            String::from_utf8(err)
+                .unwrap()
+                .contains(": parent directory is not writable")
+        );
         assert_eq!(fs::read(&summary).unwrap(), b"old");
         fs::remove_dir_all(d).unwrap();
     }

From 8dc168d42d030397c5dfca9efd289478bdbd886c Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 19:37:04 +0100
Subject: [PATCH 69/76] fix(dev): expose descriptor errors hidden by standard
 stdout

---
 rust/crates/og-dev/src/lib.rs | 50 +++++++++++++++++++++++++++++++++--
 1 file changed, 48 insertions(+), 2 deletions(-)

diff --git a/rust/crates/og-dev/src/lib.rs b/rust/crates/og-dev/src/lib.rs
index 1f8c44674..02b5d480e 100644
--- a/rust/crates/og-dev/src/lib.rs
+++ b/rust/crates/og-dev/src/lib.rs
@@ -59,8 +59,21 @@ pub(crate) fn py_os_error(e: &std::io::Error, path: &str) -> String {
 
 /// Runs a verb that writes to stdout and stderr, flushing both.
 fn run(f: fn(&[String], &mut dyn Write, &mut dyn Write) -> u8, args: &[String]) -> u8 {
-    let mut out = std::io::stdout().lock();
-    let mut err = std::io::stderr().lock();
+    use std::os::fd::AsFd;
+    // Stdout/StdoutLock suppress EBADF on Unix. Duplicating the descriptor
+    // preserves its access mode and exposes write errors without unsafe code.
+    let out = match std::io::stdout().as_fd().try_clone_to_owned() {
+        Ok(fd) => std::fs::File::from(fd),
+        Err(e) => {
+            let _ = writeln!(std::io::stderr().lock(), "og dev: stdout: {e}");
+            return 1;
+        }
+    };
+    let mut err = match std::io::stderr().as_fd().try_clone_to_owned() {
+        Ok(fd) => std::fs::File::from(fd),
+        Err(_) => return 1,
+    };
+    let mut out = std::io::BufWriter::new(out);
     run_with_writers(f, args, &mut out, &mut err)
 }
 
@@ -168,6 +181,39 @@ mod stream_tests {
             }
         }
     }
+    #[test]
+    fn stdio_process_control() {
+        if let Ok(verb) = std::env::var("OG_DEV_STREAM_CONTROL") {
+            std::process::exit(i32::from(main(&[verb, "--help".into()])));
+        }
+    }
+
+    #[test]
+    fn read_only_stdout_descriptor_makes_added_verbs_fail() {
+        let path = std::env::temp_dir().join(format!("og-stream-fd-{}", std::process::id()));
+        std::fs::write(&path, b"previous bytes").unwrap();
+        for verb in ["fixture", "evidence", "renovate-check"] {
+            let result = std::process::Command::new(std::env::current_exe().unwrap())
+                .args([
+                    "--exact",
+                    "stream_tests::stdio_process_control",
+                    "--nocapture",
+                ])
+                .env("OG_DEV_STREAM_CONTROL", verb)
+                .stdout(std::fs::File::open(&path).unwrap())
+                .output()
+                .unwrap();
+            assert!(!result.status.success(), "{verb} silently lost stdout");
+            assert!(
+                String::from_utf8_lossy(&result.stderr).contains("og dev: stdout:"),
+                "{verb}: {:?}",
+                result.stderr
+            );
+            assert_eq!(std::fs::read(&path).unwrap(), b"previous bytes");
+        }
+        std::fs::remove_file(path).unwrap();
+    }
+
     pub(crate) fn assert_status_errors(
         verb: fn(&[String], &mut dyn Write, &mut dyn Write) -> u8,
         args: &[String],

From daa6a688272e95b24c7411d88cd663853b3afe17 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 19:49:48 +0100
Subject: [PATCH 70/76] fix(ci): install Unicode oracle interpreters through
 pinned uv

---
 .github/workflows/guard.yml | 26 +++++++++++++++++---------
 CHANGELOG.md                |  2 ++
 2 files changed, 19 insertions(+), 9 deletions(-)

diff --git a/.github/workflows/guard.yml b/.github/workflows/guard.yml
index 0ea2ea31e..5d0e4d685 100644
--- a/.github/workflows/guard.yml
+++ b/.github/workflows/guard.yml
@@ -268,17 +268,25 @@ jobs:
       # Keep Python 3.9's regex cases and the newer Unicode tables available. The
       # scanner fails closed on version-dependent scalars; span iteration
       # intentionally uses Python 3.14+ semantics for empty-text \B.
-      - uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0
+      # Standalone builds also provide Python 3.9 on newer ubuntu-latest
+      # images where actions/setup-python has no matching distribution.
+      - uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3
         with:
-          python-version: '3.9'
+          version: '0.12.18'
+          enable-cache: false
 
-      - uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0
-        with:
-          python-version: '3.12'
-
-      - uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0
-        with:
-          python-version: '3.15'
+      - name: Install all three Unicode oracle interpreters
+        run: |
+          uv python install --no-bin 3.9 3.12 3.15
+          interpreters=""
+          for version in 3.9 3.12 3.15; do
+            python=$(uv python find --managed-python "$version")
+            "$python" -I -c 'import sys,unicodedata; print(sys.version.split()[0],unicodedata.unidata_version)'
+            interpreters="${interpreters:+$interpreters:}$python"
+          done
+          echo "PERSONAL_DATA_PYTHONS=$interpreters" >> "$GITHUB_ENV"
+          # Span iteration intentionally follows the newest interpreter.
+          dirname "$python" >> "$GITHUB_PATH"
 
       - name: Install the toolchain rust/rust-toolchain.toml pins, with rustfmt and clippy
         run: |
diff --git a/CHANGELOG.md b/CHANGELOG.md
index be878ca46..e1fb7aff2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,8 @@ Each release's notes. From 1.0.0 on, a major or minor release has hand-written n
 
 ## Unreleased
 
+- The scanner's Unicode checks install Python 3.9, 3.12 and 3.15 through pinned uv tooling, so the older oracle remains available on newer `ubuntu-latest` images.
+
 - The personal-data scan refuses every astral cased character from UCD 13/15/16/17, including case-mapping targets. Text in Deseret, Osage, Old Hungarian, Warang Citi, Medefaidrin, Adlam and other astral cased scripts needs an ASCII SKIP glob. Uncased astral text still scans. Custom class ranges with a guarded interior return redacted exit 2. BMP verification now covers composite classes, ranges and alternatives on every available Python. Every working-copy symlink target gets the same redacted Unicode filename guard before following it.
 
 - The personal-data guard now includes effective Python regex case relations, including Python 3.9 Cyrillic differences. Six stable older scalars pass again. Selected filenames get the same Unicode guard before exclusions, with a generic redacted error. Cached gitlinks and unreadable indexed objects fail with exit 2 unless skipped. Working-copy symlinks validate every hop, including directory components, with a 40-hop bound. The 248 newer stable scalars remain conservatively blocked.

From 0c881620fe1bee894d6a868ab5d7f06f055bbad3 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 20:22:40 +0100
Subject: [PATCH 71/76] test(ci): expose Cyrillic text and required-oracle
 regressions

---
 rust/crates/og-dev/src/personal_data.rs | 77 +++++++++++++++++++++++++
 1 file changed, 77 insertions(+)

diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
index 19e477de4..03fa7f1fd 100644
--- a/rust/crates/og-dev/src/personal_data.rs
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -2837,6 +2837,83 @@ mod tests {
         );
     }
 
+
+    #[test]
+    fn round7_ordinary_cyrillic() {
+        let f = Fixture::new("r7-cyrillic");
+        r5_git(&f, &["init", "-q"], b"");
+        for text in ["Привет, мир!", "Привіт, світе!", "Здраво, свете!", "о"] {
+            std::fs::write(f.0.join("own.md"), text).unwrap();
+            r5_git(&f, &["add", "own.md"], b"");
+            r5_modes(&f, &["own.md"], 0, "");
+        }
+        std::fs::write(f.0.join("own.md"), p("Привет, мир! rs123~ AG")).unwrap();
+        r5_git(&f, &["add", "own.md"], b"");
+        r5_modes(&f, &["own.md"], 1, "");
+        // The same letters also work in selected names and exception rows.
+        std::fs::write(f.0.join("Привет.md"), "Привет, мир!").unwrap();
+        r5_git(&f, &["add", "Привет.md"], b"");
+        for cached in [false, true] {
+            let mut args = f.args(&["Привет.md"]);
+            args[3] = "Привет.md Привет".into();
+            args[5] = "другое.md".into();
+            if cached { args.push("--cached".into()); }
+            assert_eq!(cli(&args, &mut Vec::new(), &mut Vec::new()), 0);
+        }
+    }
+
+    #[test]
+    fn round7_pattern_case_scope() {
+        for pattern in ["привет", "[а-я]", "[^В]", "(?i:a)(?-i:привет)", r"[\u0410-\u044f]"] {
+            assert!(Rule::compile(pattern, false).is_ok(), "stable pattern refused");
+        }
+        for pattern in ["(?i)привет", "(?i)[а-я]", "(?i)[^В]", "(?i:[^ОZ])", r"(?i)[\u0430-\u044f]", "(?i:т)"] {
+            for builtin in [false, true] {
+                assert!(Rule::compile(pattern, builtin).is_err(), "unstable pattern accepted");
+            }
+        }
+    }
+
+    #[test]
+    fn round7_cached_target_before_skip() {
+        let f = Fixture::new("r7-index-target");
+        r5_git(&f, &["init", "-q"], b"");
+        std::fs::write(f.0.join("clean.md"), "clean").unwrap();
+        for target in ["x\u{1e6c0}.md", "x\u{1e6c0}/clean.md"] {
+            std::os::unix::fs::symlink(target, f.0.join("alias.md")).unwrap();
+            r5_git(&f, &["add", "alias.md", "clean.md"], b"");
+            // Only the indexed target matters in cached mode.
+            std::fs::remove_file(f.0.join("alias.md")).unwrap();
+            std::fs::write(f.0.join("alias.md"), "clean").unwrap();
+            for explicit in [false, true] {
+                let mut args = f.args(if explicit { &["alias.md", "clean.md"] } else { &[] });
+                args[5] = "alias.md".into();
+                args.push("--cached".into());
+                let (mut out, mut err) = (Vec::new(), Vec::new());
+                assert_eq!(cli(&args, &mut out, &mut err), 2);
+                assert!(out.is_empty());
+                assert_eq!(err, b"ERROR: selected filename has Unicode version-dependent text\n");
+            }
+            std::fs::remove_file(f.0.join("alias.md")).unwrap();
+        }
+    }
+
+    #[test]
+    fn round7_required_interpreters_fail_closed() {
+        let f = Fixture::new("r7-required-python");
+        for interpreter in [f.0.join("missing-python"), PathBuf::from("/usr/bin/false")] {
+            for test in ["round4_guard_agrees_with_available_pythons", "round5_regex_case_table_matches_interpreters"] {
+                let output = Command::new(std::env::current_exe().unwrap())
+                    .args(["--exact", &format!("personal_data::tests::{test}"), "--nocapture"])
+                    .env("PERSONAL_DATA_PYTHONS", &interpreter)
+                    .output().unwrap();
+                assert!(!output.status.success(), "required interpreter silently skipped: {test}");
+                let log = String::from_utf8_lossy(&output.stdout);
+                assert!(log.contains("required Python oracle"), "wrong verifier failure");
+            }
+        }
+    }
+
     // Regenerate with PERSONAL_DATA_UPDATE_REGEX_CASES=1 and all supported
     // interpreters on PATH (or in PERSONAL_DATA_PYTHONS). No Python file is
     // added to the repository; these calls use each real interpreter's engine.

From ce558d084b7802e85d888627ac53070d0a0f5be5 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 20:25:17 +0100
Subject: [PATCH 72/76] test(dev): reproduce skipped JSON limits and pin
 refusal preservation

---
 rust/crates/og-dev/src/renovate.rs | 227 +++++++++++++++++++++++++++++
 1 file changed, 227 insertions(+)

diff --git a/rust/crates/og-dev/src/renovate.rs b/rust/crates/og-dev/src/renovate.rs
index cafad1342..e787e50ab 100644
--- a/rust/crates/og-dev/src/renovate.rs
+++ b/rust/crates/og-dev/src/renovate.rs
@@ -855,6 +855,233 @@ mod tests {
         let _ = fs::remove_dir_all(&d);
     }
 
+    #[test]
+    fn malformed_json_lines_are_skipped_before_and_after_the_config() {
+        let d = planted("syntax-errors");
+        let log = fs::read(d.join("renovate.log")).unwrap();
+        let bad = b"{broken}\n{\"x\":}\n\"\\uZZZZ\"\n";
+        fs::write(d.join("renovate.log"), [bad.as_slice(), &log, bad].concat()).unwrap();
+        let (code, out) = run(&d);
+        assert_eq!(code, 0, "{out}");
+        assert!(out.contains("OK: 7 dependencies; every check passed"));
+        fs::remove_dir_all(d).unwrap();
+    }
+
+    #[test]
+    fn json_reader_limits_never_fall_back_to_an_earlier_config() {
+        let huge = "340282366920938463463374607431768211456";
+        let deep = format!("{}{}", "[".repeat(json::MAX_DEPTH + 1), "]".repeat(json::MAX_DEPTH + 1));
+        let records = [
+            ("integer-prefix", format!("{huge}\n"), false, "Integer beyond 128 bits"),
+            ("surrogate-prefix", "\"\\ud800\"\n".into(), false, "Lone surrogate"),
+            ("final-config", format!("{{\"msg\":\"packageFiles with updates\",\"config\":{{\"regex\":[{{\"packageFile\":\"unused\",\"deps\":null}}]}},\"extra\":{huge}}}\n"), true, "Integer beyond 128 bits"),
+            ("nesting-prefix", format!("{deep}\n"), false, "nested deeper than 1000 levels"),
+        ];
+        std::thread::Builder::new().stack_size(8 << 20).spawn(move || {
+            let mut misses = Vec::new();
+            for (label, record, append, diagnostic) in records {
+                let d = planted(label);
+                let old = fs::read_to_string(d.join("renovate.log")).unwrap();
+                let log = if append { old + &record } else { record + &old };
+                fs::write(d.join("renovate.log"), log).unwrap();
+                let (code, out) = run(&d);
+                if code != 1 || !out.contains(diagnostic) || out.contains("every check passed") {
+                    misses.push(format!("{label}: exit {code}, {out}"));
+                }
+                fs::remove_dir_all(d).unwrap();
+            }
+            assert!(misses.is_empty(), "{}", misses.join("\n"));
+        }).unwrap().join().unwrap();
+    }
+
+    /// The refusal contract applies to every row, including unused input fields.
+    /// Run each CLI with both a regular output and a symlink to that output.
+    #[test]
+    fn refusals_preserve_bytes_modes_and_link_targets() {
+        // Match the main-thread stack used by og for the nesting-limit control.
+        std::thread::Builder::new().stack_size(8 << 20).spawn(refusal_table).unwrap().join().unwrap();
+    }
+
+    fn refusal_table() {
+        use std::os::unix::fs::{PermissionsExt, symlink};
+        #[derive(Clone, Copy, Debug)]
+        enum Verb { Gvcf, Clashes, Trim, Renovate, Comphet }
+        enum Fault {
+            Replace(&'static str, Vec<u8>),
+            Append(&'static str, Vec<u8>),
+            Prefix(Vec<u8>),
+            Limit(&'static str),
+            LongName,
+            ReadOnly,
+            ParentReadOnly,
+            Directory,
+        }
+        use Fault::*;
+        use Verb::*;
+        let bytes = |s: &str| s.as_bytes().to_vec();
+        let huge = "340282366920938463463374607431768211456";
+        let deep = format!("{}{}", "[".repeat(json::MAX_DEPTH + 1), "]".repeat(json::MAX_DEPTH + 1));
+        let final_record = format!(r#"{{"msg":"packageFiles with updates","config":{{"regex":[{{"packageFile":"unused","deps":null}}]}},"extra":{huge}}}"#);
+        // Add a refusal by adding one row: CLI, input fault, diagnostic.
+        let mut cases = vec![
+            (Renovate, Prefix(bytes(&format!("{huge}\n"))), "Integer beyond 128 bits"),
+            (Renovate, Prefix(bytes("\"\\ud800\"\n")), "Lone surrogate"),
+            (Renovate, Append("renovate.log", bytes(&format!("{final_record}\n"))), "Integer beyond 128 bits"),
+            (Renovate, Prefix(bytes(&format!("{deep}\n"))), "nested deeper than 1000 levels"),
+            (Renovate, Prefix(bytes("42\n")), "a log record is not an object"),
+            (Renovate, Prefix(vec![0xff, b'\n']), "not UTF-8"),
+            (Renovate, Prefix(vec![b'x'; (16 << 20) + 1]), "record exceeds 16777216 bytes"),
+            (Renovate, Replace(PINS, bytes("dep\tdocs/*.absent\tx\n")), "matches no file"),
+            (Renovate, Replace(PINS, bytes("dep\tabsent\tx\n")), "is not a file"),
+            (Gvcf, Append("ref.fasta.fai", bytes("chrUnused\t1\n")), "a row has fewer than 5 columns"),
+            (Gvcf, Replace("truth.vcf.gz", bytes("chrA\t18446744073709551615\t.\tA\tC\n")), "position span overflows"),
+            (Gvcf, Replace("ref.fasta.fai", bytes("\n")), "a row has fewer than 5 columns"),
+            (Gvcf, Append("ref.fasta.fai", bytes("chrUnused\t0\t0\t0\t0\n")), "a row has 0 bases per line"),
+            (Gvcf, Replace("truth.vcf.gz", bytes("chrA\t3\t.\tA\n")), "a record has fewer than 5 columns"),
+            (Gvcf, Replace("truth.bed", bytes("\n")), "a row has fewer than 3 columns"),
+            (Gvcf, Replace("truth.bed", bytes("chrA\u{85}0\u{85}50\n")), "unsupported whitespace"),
+            (Gvcf, Replace("sites.tsv", bytes("")), "missing header"),
+            (Gvcf, Append("truth.vcf.gz", bytes("##late=yes\n")), "VCF header after first data record"),
+            (Clashes, Replace("raw.vcf.gz", bytes("chrA\t3\t.\tA\tC\n")), "missing trailing VCF columns"),
+            (Trim, Replace("report.json", bytes(&format!(r#"{{"genes":{{}},"drugs":{{}},"title":{huge}}}"#))), "Integer beyond 128 bits"),
+            (Trim, Replace("report.json", bytes(r#"{"genes":{},"drugs":{},"title":"\ud800"}"#)), "Lone surrogate"),
+            (Trim, Replace("report.json", bytes(&deep)), "nested deeper than 1000 levels"),
+            (Trim, Replace("report.json", bytes("{broken}")), "Expecting property name"),
+            (Trim, Replace("report.json", vec![0xff]), "not UTF-8"),
+            (Trim, Replace("report.json", bytes("[]")), "the report is not an object"),
+            (Trim, Replace("report.json", bytes(r#"{"genes":[],"drugs":{}}"#)), "genes is not an object"),
+            (Trim, Replace("report.json", bytes(r#"{"genes":{},"drugs":[]}"#)), "drugs is not an object"),
+            (Trim, Replace("report.json", bytes(r#"{"genes":{"G":{"sourceDiplotypes":"x"}},"drugs":{}}"#)), "sourceDiplotypes is not a list"),
+            (Trim, Replace("report.json", bytes(r#"{"genes":{"G":{"recommendationDiplotypes":{ "x":1 }}},"drugs":{}}"#)), "recommendationDiplotypes is not a list"),
+            (Trim, Replace("report.json", bytes(r#"{"genes":{"G":{"sourceDiplotypes":[{"allele1":"x"}]}},"drugs":{}}"#)), "allele1 is not an object"),
+            (Trim, Replace("report.json", bytes(r#"{"genes":{"G":{"sourceDiplotypes":[{"allele2":["x"]}]}},"drugs":{}}"#)), "allele2 is not an object"),
+            (Trim, Replace("report.json", bytes(r#"{"genes":{},"drugs":{"S":{"D":{"guidelines":[{"annotations":[{"genotypes":[{"diplotypes":{"x":1}}]}]}]}}}}"#)), "diplotypes is not a list"),
+        ];
+        for limit in ["1_0", "٤", "18446744073709551616"] {
+            cases.push((Trim, Limit(limit), "is not a whole number"));
+        }
+        for value in ["3_0", "٣", "-3", "18446744073709551616"] {
+            cases.push((Gvcf, Replace("truth.vcf.gz", bytes(&format!("chrA\t{value}\t.\tA\tC\n"))), "is not a number"));
+        }
+        for row in ["chrA\t50\t18446744073709551598\t1\t2\n", "chrA\t50\t1\t1\t18446744073709551615\n", "chrA\t50\t1000\t50\t51\n"] {
+            cases.push((Gvcf, Replace("ref.fasta.fai", bytes(row)), "invalid FASTA offset"));
+        }
+        for bad in [r#"{"packageFile":"unused","deps":null}"#, r#"{"packageFile":[],"deps":[]}"#, r#"{"packageFile":"unused","deps":[{"updates":{}}]}"#, r#"{"packageFile":"unused","deps":[{"depName":0}]}"#, r#"{"packageFile":"unused","deps":[{"currentValue":0}]}"#, r#"{"packageFile":"unused","deps":[{"updates":[{"newValue":0}]}]}"#] {
+            cases.push((Renovate, Append("renovate.log", bytes(&format!("{{\"msg\":\"packageFiles with updates\",\"config\":{{\"regex\":[{bad}]}}}}\n"))), "not a map of package file lists"));
+        }
+        // A zero-byte gzip file is written directly, without the test compressor.
+        for (verb, file) in [(Gvcf, "truth.vcf.gz"), (Clashes, "raw.vcf.gz"), (Clashes, "split.vcf.gz"), (Clashes, "chrA.tsv.gz")] {
+            cases.push((verb, Replace(file, Vec::new()), "wrong compression (expected gzip)"));
+        }
+        // Plain inputs reject gzip, and compressed inputs reject plain text.
+        cases.push((Gvcf, Replace("ref.fasta", vec![0x1f, 0x8b, b'A', b'A']), "wrong compression (expected plain)"));
+        cases.push((Gvcf, Replace("truth.bed", vec![0x1f, 0x8b]), "wrong compression (expected plain)"));
+        for verb in [Gvcf, Clashes, Trim, Renovate] { cases.push((verb, LongName, "File name too long")); }
+        for verb in [Gvcf, Clashes, Trim, Renovate, Comphet] {
+            cases.push((verb, ReadOnly, "read-only destination"));
+            cases.push((verb, ParentReadOnly, "parent directory is not writable"));
+            cases.push((verb, Directory, "destination is not a regular file"));
+        }
+        for (index, (verb, fault, message)) in cases.into_iter().enumerate() {
+            for linked in [false, true] {
+                let d = planted(&format!("refusal-{index}-{linked}"));
+                let inputs = d.join("inputs");
+                fs::create_dir(&inputs).unwrap();
+                if matches!(verb, Gvcf | Clashes) {
+                    let kind = if matches!(verb, Gvcf) { "hg002-gvcf" } else { "clashes" };
+                    let src = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../../tests/parity/inputs").join(format!("dev-evidence-{kind}"));
+                    for entry in fs::read_dir(src).unwrap() {
+                        let entry = entry.unwrap();
+                        fs::copy(entry.path(), inputs.join(entry.file_name())).unwrap();
+                    }
+                    // Force the offset controls to read position 13.
+                    if matches!(&fault, Replace("ref.fasta.fai", text) if text.starts_with(b"chrA\t50")) {
+                        fs::write(inputs.join("sites.tsv"), b"id\tchr\tpos\nx\tchrA\t13\n").unwrap();
+                        fs::write(inputs.join("truth.bed"), b"chrA\t0\t50\n").unwrap();
+                    }
+                }
+                fs::write(inputs.join("report.json"), br#"{"genes":{},"drugs":{}}"#).unwrap();
+                let input_root = if matches!(verb, Renovate) { &d } else { &inputs };
+                match &fault {
+                    Replace(name, data) | Append(name, data) => {
+                        let path = input_root.join(name);
+                        let mut content = if matches!(fault, Append(..)) {
+                            if name.ends_with(".gz") {
+                                use std::io::Read;
+                                let mut old = Vec::new();
+                                flate2::read::MultiGzDecoder::new(fs::File::open(&path).unwrap()).read_to_end(&mut old).unwrap();
+                                old
+                            } else { fs::read(&path).unwrap() }
+                        } else { Vec::new() };
+                        content.extend_from_slice(data);
+                        if name.ends_with(".gz") && !content.is_empty() {
+                            let mut gz = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+                            gz.write_all(&content).unwrap();
+                            content = gz.finish().unwrap();
+                        }
+                        fs::write(path, content).unwrap();
+                    }
+                    Prefix(data) => {
+                        let old = fs::read(d.join("renovate.log")).unwrap();
+                        fs::write(d.join("renovate.log"), [data.as_slice(), &old].concat()).unwrap();
+                    }
+                    _ => {}
+                }
+                let outputs = d.join("outputs");
+                let targets = d.join("targets");
+                fs::create_dir(&outputs).unwrap();
+                fs::create_dir(&targets).unwrap();
+                let long = "x".repeat(255);
+                let names = if matches!(verb, Comphet) { vec!["reads.sam", "vep.vcf", "comphet.vcf"] } else { vec![if matches!(fault, LongName) { &long } else { "out" }] };
+                let mut previous = Vec::new();
+                for (n, name) in names.iter().enumerate() {
+                    let output = outputs.join(name);
+                    let target = if linked { targets.join(name) } else { output.clone() };
+                    let directory = matches!(fault, Directory) && n == 0;
+                    if directory {
+                        fs::create_dir(&target).unwrap();
+                        fs::write(target.join("sentinel"), b"PREVIOUS OUTPUT\n").unwrap();
+                    } else { fs::write(&target, b"PREVIOUS OUTPUT\n").unwrap(); }
+                    let mode = if matches!(fault, ReadOnly) && n == 0 { 0o444 } else if directory { 0o755 } else { 0o4600 };
+                    fs::set_permissions(&target, fs::Permissions::from_mode(mode)).unwrap();
+                    if linked { symlink(&target, &output).unwrap(); }
+                    previous.push((output, target, mode, directory));
+                }
+                let parent = if linked { &targets } else { &outputs };
+                if matches!(fault, ParentReadOnly) { fs::set_permissions(parent, fs::Permissions::from_mode(0o555)).unwrap(); }
+                let p = |n: &str| inputs.join(n).to_str().unwrap().to_owned();
+                let dest = previous[0].0.to_str().unwrap().to_owned();
+                let (mut stdout, mut stderr) = (Vec::new(), Vec::new());
+                let code = match verb {
+                    Gvcf => crate::evidence::cli(&["hg002-gvcf".into(), p("truth.vcf.gz"), p("truth.bed"), p("ref.fasta"), p("sites.tsv"), dest], &mut stdout, &mut stderr),
+                    Clashes => crate::evidence::cli(&["clashes".into(), p("raw.vcf.gz"), p("split.vcf.gz"), inputs.to_str().unwrap().into(), dest], &mut stdout, &mut stderr),
+                    Trim => {
+                        let mut args = vec!["trim-pharmcat".into(), p("report.json"), dest];
+                        if let Limit(limit) = &fault { args.push((*limit).into()); }
+                        crate::fixture::cli(&args, &mut stdout, &mut stderr)
+                    }
+                    Renovate => cli_with_summary(&[d.join("renovate.log").to_str().unwrap().into(), "--repo".into(), d.to_str().unwrap().into()], &mut stdout, &mut stderr, Some(Path::new(&dest))),
+                    Comphet => crate::fixture::cli(&["comphet".into(), outputs.to_str().unwrap().into()], &mut stdout, &mut stderr),
+                };
+                fs::set_permissions(parent, fs::Permissions::from_mode(0o755)).unwrap();
+                let diagnostic = String::from_utf8(stderr).unwrap();
+                assert_ne!(code, 0, "row {index} {verb:?}, linked={linked}: false success");
+                assert!(diagnostic.contains(message), "row {index} {verb:?}, linked={linked}: want {message:?}, got {diagnostic}");
+                for (output, target, mode, directory) in previous {
+                    let meta = fs::symlink_metadata(&output).unwrap();
+                    assert_eq!(meta.file_type().is_symlink(), linked, "row {index}");
+                    assert_eq!(fs::read_link(&output).ok(), linked.then_some(target.clone()), "row {index}: link target changed");
+                    assert_eq!(fs::metadata(&target).unwrap().permissions().mode() & 0o7777, mode, "row {index}: mode changed");
+                    assert_eq!(fs::read(if directory { target.join("sentinel") } else { target }).unwrap(), b"PREVIOUS OUTPUT\n", "row {index}: bytes changed");
+                }
+                for parent in [&outputs, &targets] {
+                    assert!(!fs::read_dir(parent).unwrap().any(|e| e.unwrap().file_name().to_string_lossy().contains(".tmp-")), "row {index}: temporary sibling leaked");
+                }
+                fs::remove_dir_all(d).unwrap();
+            }
+        }
+    }
+
     #[test]
     fn a_pin_renovate_misses_fails() {
         let d = planted("pin");

From ae9b69412645c82a12725a1e76b40b1d83847f6c Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 20:30:23 +0100
Subject: [PATCH 73/76] fix(dev): refuse JSON reader limits before selecting
 Renovate config

---
 CHANGELOG.md                       |   1 +
 docs/rust.md                       |  57 ++-
 rust/crates/og-dev/src/renovate.rs | 536 ++++++++++++++++++++++++-----
 3 files changed, 499 insertions(+), 95 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f66dcea84..cfb63afcc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,6 +15,7 @@ Each release's notes. From 1.0.0 on, a major or minor release has hand-written n
   - `og dev evidence hg002-gvcf` skips a panel site past the end of its contig. The Python read the byte after the contig, and at the end of the file wrote a reference block with an empty REF.
   - `og dev renovate-check` stops with exit 2 when a pin's file is missing or its glob matches no file. The Python counted such a pin in no file, so it could never fail.
   - `og dev fixture trim-pharmcat` names itself in the trimmed report's `_fixture_note`.
+  - Renovate skips only malformed JSON lines. JSON reader limits (signed 128-bit integers, Unicode scalar strings and 1000 nesting levels) now fail before an earlier config can pass the check. Evidence, fixture and Renovate refusals preserve existing output bytes, modes and symlink targets. [The refusal rule](docs/rust.md#input-and-destination-refusal-rule) states the numeric and size limits, with a shared table of negative CLI controls.
 - The Rust summary's CHIP reader marks a depth table with NaN unreadable instead of sorting it into a usable sensitivity estimate. Its unindexed APOL1 G2 reader keeps only records overlapping the deletion span and stops past that span on sorted input.
 
 - The Rust `og` binary now reads the rest of the summary's own sections: `og summary collect --only c`. It reads 32 sections of summary.json (couple, parascopy, paralogs, hla, prs, ancestry_fine, manta, delly, cnvpytor, sv_consensus, annotsv, expansions and their readings, telomere, roh, haplogroup, y_haplogroup, y_tree, y_str, consumer_export, bloodtype, lpa, vntyper, locityper, mito, traits with the APOL1 G2 call, archaic, ancient, viral, exomiser, chip, mei and mosaic). Nothing calls it yet: the reports still read the summary that `bin/collect_summary.py` writes. The sections are the same as the Python's on 15 new parity cases, compared as JSON with key order. The readers run on a thread pool, one per section. On a synthetic sample folder with every section and a 1,000,000-record VCF it takes 0.33 s and 34 MB, where the Python readers took 0.33 s and 41 to 59 MB. What differs from the Python:
diff --git a/docs/rust.md b/docs/rust.md
index 4cd9426c3..feda92600 100644
--- a/docs/rust.md
+++ b/docs/rust.md
@@ -139,10 +139,43 @@ flushed. This includes the evidence status and Renovate table. A configured
 Renovate summary must also be written and flushed successfully.
 Guard runs the FASTA offset regression in debug and release profiles.
 
-### Stricter than the replaced Python, on purpose
-
-Each refusal below has a pinned negative CLI test with exit 1 or 2 and a stable
-error class in `og-dev`. The final-LF normalization has a positive byte test.
+### Input and destination refusal rule
+
+These evidence, fixture and Renovate verbs may refuse any input that is
+malformed, outside the numeric ranges or size limits below, or not representable
+by the JSON reader. They may also refuse any destination beside which they
+cannot stage a sibling temporary file. A refusal always exits nonzero with a
+specific message. It leaves every existing output byte-identical, with its mode
+and link target unchanged. The crash and multi-file publication limits above
+still apply.
+
+- Evidence numeric fields use ASCII unsigned integers from 0 through
+  18446744073709551615. A reference lookup needs a position of at least 1.
+  Spans must fit that range. Calculated FASTA offsets must fit 0 through
+  9223372036854775807 and address a byte inside the file.
+- Every FAI row needs at least five columns and nonzero bases per line.
+- `MAX_ANNOTATIONS` is an ASCII signed integer from -9223372036854775808
+  through 9223372036854775807.
+- Evidence and Renovate text records have a 16 MiB (16777216-byte) limit.
+  The PharmCAT reader has no separate file-size limit and materializes JSON.
+- The JSON reader accepts signed 128-bit integers (-2^127 through 2^127-1),
+  Unicode scalar strings and at most 1000 nested arrays or objects.
+  It cannot represent lone surrogates, including in unused fields.
+- Destinations need a writable parent and a regular writable target when one
+  exists. Resolution follows at most 40 final symlinks. Temporary sibling names
+  must fit the filesystem's name limit. A 255-byte basename is refused cleanly
+  before any output write because its temporary sibling name is longer.
+
+Inputs produced by the real tools are never refused: bcftools/DeepVariant VCF,
+samtools faidx, UCSC BED, PharmCAT report JSON and Renovate debug log.
+
+`refusals_preserve_bytes_modes_and_link_targets` pins the rule through each CLI.
+Each table row runs with a regular output and with a symlink. It checks nonzero
+exit, the specific diagnostic, unchanged bytes, mode and link target, and no
+leftover temporary file. Adding a refusal case needs one row.
+
+Examples of refusals follow. This is not an exhaustive input grammar.
+The final-LF normalization has a positive byte test.
 
 - BED fields use spaces and tabs as separators. Other Python whitespace
   (Unicode White_Space and U+001C through U+001F) fails with `unsupported whitespace`.
@@ -176,3 +209,19 @@ error class in `og-dev`. The final-LF normalization has a positive byte test.
 - FASTA offsets use checked subtraction, division, multiplication, addition
   and remainder. Overflow, a position beyond the file, or an offset outside
   the signed file-offset range fails with `invalid FASTA offset`.
+
+- A nonblank unused FAI row with fewer than five columns fails with
+  `a row has fewer than 5 columns`.
+- A truth position that fits u64 but whose REF span does not fails with
+  `position span overflows`.
+- A destination whose temporary sibling name is too long fails with the
+  filesystem diagnostic `File name too long`.
+- JSON integers outside signed 128-bit range and escaped lone surrogates fail
+  with `Integer beyond 128 bits` and `Lone surrogate`, even in unused fields.
+  Excess nesting fails with `nested deeper than 1000 levels`.
+
+Renovate skips genuine JSON syntax errors only. Reader limitations fail the
+command before an earlier matching config or the summary can be used.
+`TooDeep` has its own error variant. The reader currently puts integer and
+surrogate limitations in `JsonError::Decode`, so the loader distinguishes those
+static reasons inside that variant. Other decode errors remain skippable.
diff --git a/rust/crates/og-dev/src/renovate.rs b/rust/crates/og-dev/src/renovate.rs
index e787e50ab..f279010b1 100644
--- a/rust/crates/og-dev/src/renovate.rs
+++ b/rust/crates/og-dev/src/renovate.rs
@@ -264,9 +264,21 @@ fn read_pins(repo: &Path, path: &Path) -> Result<Pins, String> {
 fn load(log: &str) -> Result<Vec<Dep>, String> {
     let mut files = None;
     crate::evidence::lines(log, |line| {
-        // The old load() skipped only JSON parse errors, not parsed scalars.
-        let Ok(value) = json::loads(std::str::from_utf8(line).expect("strict reader")) else {
-            return Ok(());
+        let value = match json::loads(std::str::from_utf8(line).expect("strict reader")) {
+            Ok(value) => value,
+            // TooDeep has a distinct kind. The reader still encodes its two
+            // other representation limits as static Decode reasons. They are
+            // valid JSON, so neither may hide a record or an earlier config.
+            Err(
+                e @ (json::JsonError::TooDeep
+                | json::JsonError::Decode(
+                    "Integer beyond 128 bits"
+                    | "Lone surrogate (Python keeps it; this port cannot)",
+                    _,
+                )),
+            ) => return Err(format!("FAIL: {log}: JSON reader limitation: {e}")),
+            Err(json::JsonError::Decode(..)) => return Ok(()),
+            Err(e) => return Err(format!("FAIL: {log}: {e}")),
         };
         let Value::Object(mut rec) = value else {
             return Err(format!("FAIL: {log}: a log record is not an object"));
@@ -870,28 +882,60 @@ mod tests {
     #[test]
     fn json_reader_limits_never_fall_back_to_an_earlier_config() {
         let huge = "340282366920938463463374607431768211456";
-        let deep = format!("{}{}", "[".repeat(json::MAX_DEPTH + 1), "]".repeat(json::MAX_DEPTH + 1));
+        let deep = format!(
+            "{}{}",
+            "[".repeat(json::MAX_DEPTH + 1),
+            "]".repeat(json::MAX_DEPTH + 1)
+        );
         let records = [
-            ("integer-prefix", format!("{huge}\n"), false, "Integer beyond 128 bits"),
-            ("surrogate-prefix", "\"\\ud800\"\n".into(), false, "Lone surrogate"),
-            ("final-config", format!("{{\"msg\":\"packageFiles with updates\",\"config\":{{\"regex\":[{{\"packageFile\":\"unused\",\"deps\":null}}]}},\"extra\":{huge}}}\n"), true, "Integer beyond 128 bits"),
-            ("nesting-prefix", format!("{deep}\n"), false, "nested deeper than 1000 levels"),
+            (
+                "integer-prefix",
+                format!("{huge}\n"),
+                false,
+                "Integer beyond 128 bits",
+            ),
+            (
+                "surrogate-prefix",
+                "\"\\ud800\"\n".into(),
+                false,
+                "Lone surrogate",
+            ),
+            (
+                "final-config",
+                format!(
+                    "{{\"msg\":\"packageFiles with updates\",\"config\":{{\"regex\":[{{\"packageFile\":\"unused\",\"deps\":null}}]}},\"extra\":{huge}}}\n"
+                ),
+                true,
+                "Integer beyond 128 bits",
+            ),
+            (
+                "nesting-prefix",
+                format!("{deep}\n"),
+                false,
+                "nested deeper than 1000 levels",
+            ),
         ];
-        std::thread::Builder::new().stack_size(8 << 20).spawn(move || {
-            let mut misses = Vec::new();
-            for (label, record, append, diagnostic) in records {
-                let d = planted(label);
-                let old = fs::read_to_string(d.join("renovate.log")).unwrap();
-                let log = if append { old + &record } else { record + &old };
-                fs::write(d.join("renovate.log"), log).unwrap();
-                let (code, out) = run(&d);
-                if code != 1 || !out.contains(diagnostic) || out.contains("every check passed") {
-                    misses.push(format!("{label}: exit {code}, {out}"));
+        std::thread::Builder::new()
+            .stack_size(8 << 20)
+            .spawn(move || {
+                let mut misses = Vec::new();
+                for (label, record, append, diagnostic) in records {
+                    let d = planted(label);
+                    let old = fs::read_to_string(d.join("renovate.log")).unwrap();
+                    let log = if append { old + &record } else { record + &old };
+                    fs::write(d.join("renovate.log"), log).unwrap();
+                    let (code, out) = run(&d);
+                    if code != 1 || !out.contains(diagnostic) || out.contains("every check passed")
+                    {
+                        misses.push(format!("{label}: exit {code}, {out}"));
+                    }
+                    fs::remove_dir_all(d).unwrap();
                 }
-                fs::remove_dir_all(d).unwrap();
-            }
-            assert!(misses.is_empty(), "{}", misses.join("\n"));
-        }).unwrap().join().unwrap();
+                assert!(misses.is_empty(), "{}", misses.join("\n"));
+            })
+            .unwrap()
+            .join()
+            .unwrap();
     }
 
     /// The refusal contract applies to every row, including unused input fields.
@@ -899,13 +943,24 @@ mod tests {
     #[test]
     fn refusals_preserve_bytes_modes_and_link_targets() {
         // Match the main-thread stack used by og for the nesting-limit control.
-        std::thread::Builder::new().stack_size(8 << 20).spawn(refusal_table).unwrap().join().unwrap();
+        std::thread::Builder::new()
+            .stack_size(8 << 20)
+            .spawn(refusal_table)
+            .unwrap()
+            .join()
+            .unwrap();
     }
 
     fn refusal_table() {
         use std::os::unix::fs::{PermissionsExt, symlink};
         #[derive(Clone, Copy, Debug)]
-        enum Verb { Gvcf, Clashes, Trim, Renovate, Comphet }
+        enum Verb {
+            Gvcf,
+            Clashes,
+            Trim,
+            Renovate,
+            Comphet,
+        }
         enum Fault {
             Replace(&'static str, Vec<u8>),
             Append(&'static str, Vec<u8>),
@@ -920,88 +975,287 @@ mod tests {
         use Verb::*;
         let bytes = |s: &str| s.as_bytes().to_vec();
         let huge = "340282366920938463463374607431768211456";
-        let deep = format!("{}{}", "[".repeat(json::MAX_DEPTH + 1), "]".repeat(json::MAX_DEPTH + 1));
-        let final_record = format!(r#"{{"msg":"packageFiles with updates","config":{{"regex":[{{"packageFile":"unused","deps":null}}]}},"extra":{huge}}}"#);
+        let deep = format!(
+            "{}{}",
+            "[".repeat(json::MAX_DEPTH + 1),
+            "]".repeat(json::MAX_DEPTH + 1)
+        );
+        let final_record = format!(
+            r#"{{"msg":"packageFiles with updates","config":{{"regex":[{{"packageFile":"unused","deps":null}}]}},"extra":{huge}}}"#
+        );
         // Add a refusal by adding one row: CLI, input fault, diagnostic.
         let mut cases = vec![
-            (Renovate, Prefix(bytes(&format!("{huge}\n"))), "Integer beyond 128 bits"),
+            (
+                Renovate,
+                Prefix(bytes(&format!("{huge}\n"))),
+                "Integer beyond 128 bits",
+            ),
             (Renovate, Prefix(bytes("\"\\ud800\"\n")), "Lone surrogate"),
-            (Renovate, Append("renovate.log", bytes(&format!("{final_record}\n"))), "Integer beyond 128 bits"),
-            (Renovate, Prefix(bytes(&format!("{deep}\n"))), "nested deeper than 1000 levels"),
-            (Renovate, Prefix(bytes("42\n")), "a log record is not an object"),
-            (Renovate, Prefix(vec![0xff, b'\n']), "not UTF-8"),
-            (Renovate, Prefix(vec![b'x'; (16 << 20) + 1]), "record exceeds 16777216 bytes"),
-            (Renovate, Replace(PINS, bytes("dep\tdocs/*.absent\tx\n")), "matches no file"),
-            (Renovate, Replace(PINS, bytes("dep\tabsent\tx\n")), "is not a file"),
-            (Gvcf, Append("ref.fasta.fai", bytes("chrUnused\t1\n")), "a row has fewer than 5 columns"),
-            (Gvcf, Replace("truth.vcf.gz", bytes("chrA\t18446744073709551615\t.\tA\tC\n")), "position span overflows"),
-            (Gvcf, Replace("ref.fasta.fai", bytes("\n")), "a row has fewer than 5 columns"),
-            (Gvcf, Append("ref.fasta.fai", bytes("chrUnused\t0\t0\t0\t0\n")), "a row has 0 bases per line"),
-            (Gvcf, Replace("truth.vcf.gz", bytes("chrA\t3\t.\tA\n")), "a record has fewer than 5 columns"),
-            (Gvcf, Replace("truth.bed", bytes("\n")), "a row has fewer than 3 columns"),
-            (Gvcf, Replace("truth.bed", bytes("chrA\u{85}0\u{85}50\n")), "unsupported whitespace"),
+            (
+                Renovate,
+                Append("renovate.log", bytes(&format!("{final_record}\n"))),
+                "Integer beyond 128 bits",
+            ),
+            (
+                Renovate,
+                Prefix(bytes(&format!("{deep}\n"))),
+                "nested deeper than 1000 levels",
+            ),
+            (
+                Renovate,
+                Prefix(bytes("42\n")),
+                "a log record is not an object",
+            ),
+            (Renovate, Prefix(vec![0xff, b'\n']), "invalid UTF-8"),
+            (
+                Renovate,
+                Prefix(vec![b'x'; (16 << 20) + 1]),
+                "record exceeds 16777216 bytes",
+            ),
+            (
+                Renovate,
+                Replace(PINS, bytes("dep\tdocs/*.absent\tx\n")),
+                "matches no file",
+            ),
+            (
+                Renovate,
+                Replace(PINS, bytes("dep\tabsent\tx\n")),
+                "is not a file",
+            ),
+            (
+                Gvcf,
+                Append("ref.fasta.fai", bytes("chrUnused\t1\n")),
+                "a row has fewer than 5 columns",
+            ),
+            (
+                Gvcf,
+                Replace(
+                    "truth.vcf.gz",
+                    bytes("chrA\t18446744073709551615\t.\tA\tC\n"),
+                ),
+                "position span overflows",
+            ),
+            (
+                Gvcf,
+                Replace("ref.fasta.fai", bytes("\n")),
+                "a row has fewer than 5 columns",
+            ),
+            (
+                Gvcf,
+                Append("ref.fasta.fai", bytes("chrUnused\t0\t0\t0\t0\n")),
+                "a row has 0 bases per line",
+            ),
+            (
+                Gvcf,
+                Replace("truth.vcf.gz", bytes("chrA\t3\t.\tA\n")),
+                "a record has fewer than 5 columns",
+            ),
+            (
+                Gvcf,
+                Replace("truth.bed", bytes("\n")),
+                "a row has fewer than 3 columns",
+            ),
+            (
+                Gvcf,
+                Replace("truth.bed", bytes("chrA\u{85}0\u{85}50\n")),
+                "unsupported whitespace",
+            ),
             (Gvcf, Replace("sites.tsv", bytes("")), "missing header"),
-            (Gvcf, Append("truth.vcf.gz", bytes("##late=yes\n")), "VCF header after first data record"),
-            (Clashes, Replace("raw.vcf.gz", bytes("chrA\t3\t.\tA\tC\n")), "missing trailing VCF columns"),
-            (Trim, Replace("report.json", bytes(&format!(r#"{{"genes":{{}},"drugs":{{}},"title":{huge}}}"#))), "Integer beyond 128 bits"),
-            (Trim, Replace("report.json", bytes(r#"{"genes":{},"drugs":{},"title":"\ud800"}"#)), "Lone surrogate"),
-            (Trim, Replace("report.json", bytes(&deep)), "nested deeper than 1000 levels"),
-            (Trim, Replace("report.json", bytes("{broken}")), "Expecting property name"),
+            (
+                Gvcf,
+                Append("truth.vcf.gz", bytes("##late=yes\n")),
+                "VCF header after first data record",
+            ),
+            (
+                Clashes,
+                Replace("raw.vcf.gz", bytes("chrA\t3\t.\tA\tC\n")),
+                "missing trailing VCF columns",
+            ),
+            (
+                Trim,
+                Replace(
+                    "report.json",
+                    bytes(&format!(r#"{{"genes":{{}},"drugs":{{}},"title":{huge}}}"#)),
+                ),
+                "Integer beyond 128 bits",
+            ),
+            (
+                Trim,
+                Replace(
+                    "report.json",
+                    bytes(r#"{"genes":{},"drugs":{},"title":"\ud800"}"#),
+                ),
+                "Lone surrogate",
+            ),
+            (
+                Trim,
+                Replace("report.json", bytes(&deep)),
+                "nested deeper than 1000 levels",
+            ),
+            (
+                Trim,
+                Replace("report.json", bytes("{broken}")),
+                "Expecting property name",
+            ),
             (Trim, Replace("report.json", vec![0xff]), "not UTF-8"),
-            (Trim, Replace("report.json", bytes("[]")), "the report is not an object"),
-            (Trim, Replace("report.json", bytes(r#"{"genes":[],"drugs":{}}"#)), "genes is not an object"),
-            (Trim, Replace("report.json", bytes(r#"{"genes":{},"drugs":[]}"#)), "drugs is not an object"),
-            (Trim, Replace("report.json", bytes(r#"{"genes":{"G":{"sourceDiplotypes":"x"}},"drugs":{}}"#)), "sourceDiplotypes is not a list"),
-            (Trim, Replace("report.json", bytes(r#"{"genes":{"G":{"recommendationDiplotypes":{ "x":1 }}},"drugs":{}}"#)), "recommendationDiplotypes is not a list"),
-            (Trim, Replace("report.json", bytes(r#"{"genes":{"G":{"sourceDiplotypes":[{"allele1":"x"}]}},"drugs":{}}"#)), "allele1 is not an object"),
-            (Trim, Replace("report.json", bytes(r#"{"genes":{"G":{"sourceDiplotypes":[{"allele2":["x"]}]}},"drugs":{}}"#)), "allele2 is not an object"),
-            (Trim, Replace("report.json", bytes(r#"{"genes":{},"drugs":{"S":{"D":{"guidelines":[{"annotations":[{"genotypes":[{"diplotypes":{"x":1}}]}]}]}}}}"#)), "diplotypes is not a list"),
+            (
+                Trim,
+                Replace("report.json", bytes("[]")),
+                "the report is not an object",
+            ),
+            (
+                Trim,
+                Replace("report.json", bytes(r#"{"genes":[],"drugs":{}}"#)),
+                "genes is not an object",
+            ),
+            (
+                Trim,
+                Replace("report.json", bytes(r#"{"genes":{},"drugs":[]}"#)),
+                "drugs is not an object",
+            ),
+            (
+                Trim,
+                Replace(
+                    "report.json",
+                    bytes(r#"{"genes":{"G":{"sourceDiplotypes":"x"}},"drugs":{}}"#),
+                ),
+                "sourceDiplotypes is not a list",
+            ),
+            (
+                Trim,
+                Replace(
+                    "report.json",
+                    bytes(r#"{"genes":{"G":{"recommendationDiplotypes":{ "x":1 }}},"drugs":{}}"#),
+                ),
+                "recommendationDiplotypes is not a list",
+            ),
+            (
+                Trim,
+                Replace(
+                    "report.json",
+                    bytes(r#"{"genes":{"G":{"sourceDiplotypes":[{"allele1":"x"}]}},"drugs":{}}"#),
+                ),
+                "allele1 is not an object",
+            ),
+            (
+                Trim,
+                Replace(
+                    "report.json",
+                    bytes(r#"{"genes":{"G":{"sourceDiplotypes":[{"allele2":["x"]}]}},"drugs":{}}"#),
+                ),
+                "allele2 is not an object",
+            ),
+            (
+                Trim,
+                Replace(
+                    "report.json",
+                    bytes(
+                        r#"{"genes":{},"drugs":{"S":{"D":{"guidelines":[{"annotations":[{"genotypes":[{"diplotypes":{"x":1}}]}]}]}}}}"#,
+                    ),
+                ),
+                "diplotypes is not a list",
+            ),
         ];
         for limit in ["1_0", "٤", "18446744073709551616"] {
             cases.push((Trim, Limit(limit), "is not a whole number"));
         }
         for value in ["3_0", "٣", "-3", "18446744073709551616"] {
-            cases.push((Gvcf, Replace("truth.vcf.gz", bytes(&format!("chrA\t{value}\t.\tA\tC\n"))), "is not a number"));
+            cases.push((
+                Gvcf,
+                Replace("truth.vcf.gz", bytes(&format!("chrA\t{value}\t.\tA\tC\n"))),
+                "is not a number",
+            ));
         }
-        for row in ["chrA\t50\t18446744073709551598\t1\t2\n", "chrA\t50\t1\t1\t18446744073709551615\n", "chrA\t50\t1000\t50\t51\n"] {
-            cases.push((Gvcf, Replace("ref.fasta.fai", bytes(row)), "invalid FASTA offset"));
+        for row in [
+            "chrA\t50\t18446744073709551598\t1\t2\n",
+            "chrA\t50\t1\t1\t18446744073709551615\n",
+            "chrA\t50\t1000\t50\t51\n",
+        ] {
+            cases.push((
+                Gvcf,
+                Replace("ref.fasta.fai", bytes(row)),
+                "invalid FASTA offset",
+            ));
         }
-        for bad in [r#"{"packageFile":"unused","deps":null}"#, r#"{"packageFile":[],"deps":[]}"#, r#"{"packageFile":"unused","deps":[{"updates":{}}]}"#, r#"{"packageFile":"unused","deps":[{"depName":0}]}"#, r#"{"packageFile":"unused","deps":[{"currentValue":0}]}"#, r#"{"packageFile":"unused","deps":[{"updates":[{"newValue":0}]}]}"#] {
+        for bad in [
+            r#"{"packageFile":"unused","deps":null}"#,
+            r#"{"packageFile":[],"deps":[]}"#,
+            r#"{"packageFile":"unused","deps":[{"updates":{}}]}"#,
+            r#"{"packageFile":"unused","deps":[{"depName":0}]}"#,
+            r#"{"packageFile":"unused","deps":[{"currentValue":0}]}"#,
+            r#"{"packageFile":"unused","deps":[{"updates":[{"newValue":0}]}]}"#,
+        ] {
             cases.push((Renovate, Append("renovate.log", bytes(&format!("{{\"msg\":\"packageFiles with updates\",\"config\":{{\"regex\":[{bad}]}}}}\n"))), "not a map of package file lists"));
         }
         // A zero-byte gzip file is written directly, without the test compressor.
-        for (verb, file) in [(Gvcf, "truth.vcf.gz"), (Clashes, "raw.vcf.gz"), (Clashes, "split.vcf.gz"), (Clashes, "chrA.tsv.gz")] {
-            cases.push((verb, Replace(file, Vec::new()), "wrong compression (expected gzip)"));
+        for (verb, file) in [
+            (Gvcf, "truth.vcf.gz"),
+            (Clashes, "raw.vcf.gz"),
+            (Clashes, "split.vcf.gz"),
+            (Clashes, "chrA.tsv.gz"),
+        ] {
+            cases.push((
+                verb,
+                Replace(file, Vec::new()),
+                "wrong compression (expected gzip)",
+            ));
         }
         // Plain inputs reject gzip, and compressed inputs reject plain text.
-        cases.push((Gvcf, Replace("ref.fasta", vec![0x1f, 0x8b, b'A', b'A']), "wrong compression (expected plain)"));
-        cases.push((Gvcf, Replace("truth.bed", vec![0x1f, 0x8b]), "wrong compression (expected plain)"));
-        for verb in [Gvcf, Clashes, Trim, Renovate] { cases.push((verb, LongName, "File name too long")); }
+        cases.push((
+            Gvcf,
+            Replace("ref.fasta", vec![0x1f, 0x8b, b'A', b'A']),
+            "wrong compression (expected plain)",
+        ));
+        cases.push((
+            Gvcf,
+            Replace("truth.bed", vec![0x1f, 0x8b]),
+            "wrong compression (expected plain)",
+        ));
+        for verb in [Gvcf, Clashes, Trim, Renovate] {
+            cases.push((verb, LongName, "File name too long"));
+        }
         for verb in [Gvcf, Clashes, Trim, Renovate, Comphet] {
             cases.push((verb, ReadOnly, "read-only destination"));
             cases.push((verb, ParentReadOnly, "parent directory is not writable"));
             cases.push((verb, Directory, "destination is not a regular file"));
         }
+        eprintln!(
+            "refusal contract: {} rows, {} CLI invocations",
+            cases.len(),
+            cases.len() * 2
+        );
         for (index, (verb, fault, message)) in cases.into_iter().enumerate() {
             for linked in [false, true] {
                 let d = planted(&format!("refusal-{index}-{linked}"));
                 let inputs = d.join("inputs");
                 fs::create_dir(&inputs).unwrap();
                 if matches!(verb, Gvcf | Clashes) {
-                    let kind = if matches!(verb, Gvcf) { "hg002-gvcf" } else { "clashes" };
-                    let src = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../../tests/parity/inputs").join(format!("dev-evidence-{kind}"));
+                    let kind = if matches!(verb, Gvcf) {
+                        "hg002-gvcf"
+                    } else {
+                        "clashes"
+                    };
+                    let src = Path::new(env!("CARGO_MANIFEST_DIR"))
+                        .join("../../../tests/parity/inputs")
+                        .join(format!("dev-evidence-{kind}"));
                     for entry in fs::read_dir(src).unwrap() {
                         let entry = entry.unwrap();
                         fs::copy(entry.path(), inputs.join(entry.file_name())).unwrap();
                     }
                     // Force the offset controls to read position 13.
-                    if matches!(&fault, Replace("ref.fasta.fai", text) if text.starts_with(b"chrA\t50")) {
-                        fs::write(inputs.join("sites.tsv"), b"id\tchr\tpos\nx\tchrA\t13\n").unwrap();
+                    if matches!(&fault, Replace("ref.fasta.fai", text) if text.starts_with(b"chrA\t50"))
+                    {
+                        fs::write(inputs.join("sites.tsv"), b"id\tchr\tpos\nx\tchrA\t13\n")
+                            .unwrap();
                         fs::write(inputs.join("truth.bed"), b"chrA\t0\t50\n").unwrap();
                     }
                 }
                 fs::write(inputs.join("report.json"), br#"{"genes":{},"drugs":{}}"#).unwrap();
-                let input_root = if matches!(verb, Renovate) { &d } else { &inputs };
+                let input_root = if matches!(verb, Renovate) {
+                    &d
+                } else {
+                    &inputs
+                };
                 match &fault {
                     Replace(name, data) | Append(name, data) => {
                         let path = input_root.join(name);
@@ -1009,13 +1263,22 @@ mod tests {
                             if name.ends_with(".gz") {
                                 use std::io::Read;
                                 let mut old = Vec::new();
-                                flate2::read::MultiGzDecoder::new(fs::File::open(&path).unwrap()).read_to_end(&mut old).unwrap();
+                                flate2::read::MultiGzDecoder::new(fs::File::open(&path).unwrap())
+                                    .read_to_end(&mut old)
+                                    .unwrap();
                                 old
-                            } else { fs::read(&path).unwrap() }
-                        } else { Vec::new() };
+                            } else {
+                                fs::read(&path).unwrap()
+                            }
+                        } else {
+                            Vec::new()
+                        };
                         content.extend_from_slice(data);
                         if name.ends_with(".gz") && !content.is_empty() {
-                            let mut gz = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+                            let mut gz = flate2::write::GzEncoder::new(
+                                Vec::new(),
+                                flate2::Compression::default(),
+                            );
                             gz.write_all(&content).unwrap();
                             content = gz.finish().unwrap();
                         }
@@ -1023,7 +1286,8 @@ mod tests {
                     }
                     Prefix(data) => {
                         let old = fs::read(d.join("renovate.log")).unwrap();
-                        fs::write(d.join("renovate.log"), [data.as_slice(), &old].concat()).unwrap();
+                        fs::write(d.join("renovate.log"), [data.as_slice(), &old].concat())
+                            .unwrap();
                     }
                     _ => {}
                 }
@@ -1032,50 +1296,140 @@ mod tests {
                 fs::create_dir(&outputs).unwrap();
                 fs::create_dir(&targets).unwrap();
                 let long = "x".repeat(255);
-                let names = if matches!(verb, Comphet) { vec!["reads.sam", "vep.vcf", "comphet.vcf"] } else { vec![if matches!(fault, LongName) { &long } else { "out" }] };
+                let names = if matches!(verb, Comphet) {
+                    vec!["reads.sam", "vep.vcf", "comphet.vcf"]
+                } else {
+                    vec![if matches!(fault, LongName) {
+                        &long
+                    } else {
+                        "out"
+                    }]
+                };
                 let mut previous = Vec::new();
                 for (n, name) in names.iter().enumerate() {
                     let output = outputs.join(name);
-                    let target = if linked { targets.join(name) } else { output.clone() };
+                    let target = if linked {
+                        targets.join(name)
+                    } else {
+                        output.clone()
+                    };
                     let directory = matches!(fault, Directory) && n == 0;
                     if directory {
                         fs::create_dir(&target).unwrap();
                         fs::write(target.join("sentinel"), b"PREVIOUS OUTPUT\n").unwrap();
-                    } else { fs::write(&target, b"PREVIOUS OUTPUT\n").unwrap(); }
-                    let mode = if matches!(fault, ReadOnly) && n == 0 { 0o444 } else if directory { 0o755 } else { 0o4600 };
+                    } else {
+                        fs::write(&target, b"PREVIOUS OUTPUT\n").unwrap();
+                    }
+                    let mode = if matches!(fault, ReadOnly) && n == 0 {
+                        0o444
+                    } else if directory {
+                        0o755
+                    } else {
+                        0o4600
+                    };
                     fs::set_permissions(&target, fs::Permissions::from_mode(mode)).unwrap();
-                    if linked { symlink(&target, &output).unwrap(); }
+                    if linked {
+                        symlink(&target, &output).unwrap();
+                    }
                     previous.push((output, target, mode, directory));
                 }
                 let parent = if linked { &targets } else { &outputs };
-                if matches!(fault, ParentReadOnly) { fs::set_permissions(parent, fs::Permissions::from_mode(0o555)).unwrap(); }
+                if matches!(fault, ParentReadOnly) {
+                    fs::set_permissions(parent, fs::Permissions::from_mode(0o555)).unwrap();
+                }
                 let p = |n: &str| inputs.join(n).to_str().unwrap().to_owned();
                 let dest = previous[0].0.to_str().unwrap().to_owned();
                 let (mut stdout, mut stderr) = (Vec::new(), Vec::new());
                 let code = match verb {
-                    Gvcf => crate::evidence::cli(&["hg002-gvcf".into(), p("truth.vcf.gz"), p("truth.bed"), p("ref.fasta"), p("sites.tsv"), dest], &mut stdout, &mut stderr),
-                    Clashes => crate::evidence::cli(&["clashes".into(), p("raw.vcf.gz"), p("split.vcf.gz"), inputs.to_str().unwrap().into(), dest], &mut stdout, &mut stderr),
+                    Gvcf => crate::evidence::cli(
+                        &[
+                            "hg002-gvcf".into(),
+                            p("truth.vcf.gz"),
+                            p("truth.bed"),
+                            p("ref.fasta"),
+                            p("sites.tsv"),
+                            dest,
+                        ],
+                        &mut stdout,
+                        &mut stderr,
+                    ),
+                    Clashes => crate::evidence::cli(
+                        &[
+                            "clashes".into(),
+                            p("raw.vcf.gz"),
+                            p("split.vcf.gz"),
+                            inputs.to_str().unwrap().into(),
+                            dest,
+                        ],
+                        &mut stdout,
+                        &mut stderr,
+                    ),
                     Trim => {
                         let mut args = vec!["trim-pharmcat".into(), p("report.json"), dest];
-                        if let Limit(limit) = &fault { args.push((*limit).into()); }
+                        if let Limit(limit) = &fault {
+                            args.push((*limit).into());
+                        }
                         crate::fixture::cli(&args, &mut stdout, &mut stderr)
                     }
-                    Renovate => cli_with_summary(&[d.join("renovate.log").to_str().unwrap().into(), "--repo".into(), d.to_str().unwrap().into()], &mut stdout, &mut stderr, Some(Path::new(&dest))),
-                    Comphet => crate::fixture::cli(&["comphet".into(), outputs.to_str().unwrap().into()], &mut stdout, &mut stderr),
+                    Renovate => cli_with_summary(
+                        &[
+                            d.join("renovate.log").to_str().unwrap().into(),
+                            "--repo".into(),
+                            d.to_str().unwrap().into(),
+                        ],
+                        &mut stdout,
+                        &mut stderr,
+                        Some(Path::new(&dest)),
+                    ),
+                    Comphet => crate::fixture::cli(
+                        &["comphet".into(), outputs.to_str().unwrap().into()],
+                        &mut stdout,
+                        &mut stderr,
+                    ),
                 };
                 fs::set_permissions(parent, fs::Permissions::from_mode(0o755)).unwrap();
                 let diagnostic = String::from_utf8(stderr).unwrap();
-                assert_ne!(code, 0, "row {index} {verb:?}, linked={linked}: false success");
-                assert!(diagnostic.contains(message), "row {index} {verb:?}, linked={linked}: want {message:?}, got {diagnostic}");
+                assert_ne!(
+                    code, 0,
+                    "row {index} {verb:?}, linked={linked}: false success"
+                );
+                assert!(
+                    diagnostic.contains(message),
+                    "row {index} {verb:?}, linked={linked}: want {message:?}, got {diagnostic}"
+                );
                 for (output, target, mode, directory) in previous {
                     let meta = fs::symlink_metadata(&output).unwrap();
                     assert_eq!(meta.file_type().is_symlink(), linked, "row {index}");
-                    assert_eq!(fs::read_link(&output).ok(), linked.then_some(target.clone()), "row {index}: link target changed");
-                    assert_eq!(fs::metadata(&target).unwrap().permissions().mode() & 0o7777, mode, "row {index}: mode changed");
-                    assert_eq!(fs::read(if directory { target.join("sentinel") } else { target }).unwrap(), b"PREVIOUS OUTPUT\n", "row {index}: bytes changed");
+                    assert_eq!(
+                        fs::read_link(&output).ok(),
+                        linked.then_some(target.clone()),
+                        "row {index}: link target changed"
+                    );
+                    assert_eq!(
+                        fs::metadata(&target).unwrap().permissions().mode() & 0o7777,
+                        mode,
+                        "row {index}: mode changed"
+                    );
+                    assert_eq!(
+                        fs::read(if directory {
+                            target.join("sentinel")
+                        } else {
+                            target
+                        })
+                        .unwrap(),
+                        b"PREVIOUS OUTPUT\n",
+                        "row {index}: bytes changed"
+                    );
                 }
                 for parent in [&outputs, &targets] {
-                    assert!(!fs::read_dir(parent).unwrap().any(|e| e.unwrap().file_name().to_string_lossy().contains(".tmp-")), "row {index}: temporary sibling leaked");
+                    assert!(
+                        !fs::read_dir(parent).unwrap().any(|e| e
+                            .unwrap()
+                            .file_name()
+                            .to_string_lossy()
+                            .contains(".tmp-")),
+                        "row {index}: temporary sibling leaked"
+                    );
                 }
                 fs::remove_dir_all(d).unwrap();
             }

From 65ba929fb967b785fc892628b799b60fbbd62a39 Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 20:43:01 +0100
Subject: [PATCH 74/76] fix(ci): guard Unicode regex cases in patterns and
 verify admitted text

---
 .github/workflows/guard.yml             |  22 ++
 CHANGELOG.md                            |   2 +
 rust/crates/og-dev/src/lookaround.rs    |  14 +-
 rust/crates/og-dev/src/personal_data.rs | 495 ++++++++++++++++++++----
 scripts/ci/check-personal-data.sh       |  35 +-
 5 files changed, 480 insertions(+), 88 deletions(-)

diff --git a/.github/workflows/guard.yml b/.github/workflows/guard.yml
index 5d0e4d685..ef1854182 100644
--- a/.github/workflows/guard.yml
+++ b/.github/workflows/guard.yml
@@ -285,6 +285,7 @@ jobs:
             interpreters="${interpreters:+$interpreters:}$python"
           done
           echo "PERSONAL_DATA_PYTHONS=$interpreters" >> "$GITHUB_ENV"
+          echo "PERSONAL_DATA_REQUIRE_PYTHONS=3.9:3.12:3.15" >> "$GITHUB_ENV"
           # Span iteration intentionally follows the newest interpreter.
           dirname "$python" >> "$GITHUB_PATH"
 
@@ -439,6 +440,27 @@ jobs:
           grep -E 'round6_stable_ranges_and_uncased_astral .*ok' "$log"
           echo "Control: all three regressions failed; stable ranges and uncased astral text passed."
 
+      - name: Scanner round-seven controls against the pre-fix scanner
+        run: |
+          source=crates/og-dev/src/personal_data.rs
+          matcher=crates/og-dev/src/lookaround.rs
+          cp "$source" "${RUNNER_TEMP}/round7-personal-fixed.rs"
+          cp "$matcher" "${RUNNER_TEMP}/round7-matcher-fixed.rs"
+          trap 'cp "${RUNNER_TEMP}/round7-personal-fixed.rs" "$source"; cp "${RUNNER_TEMP}/round7-matcher-fixed.rs" "$matcher"' EXIT
+          before=0c881620fe1bee894d6a868ab5d7f06f055bbad3
+          git cat-file -e "$before^{commit}" 2>/dev/null || git fetch origin "$before"
+          git show "$before:rust/$source" > "$source"
+          git show "$before:rust/$matcher" > "$matcher"
+          log="${RUNNER_TEMP}/scanner-round7-red.log"
+          rc=0
+          cargo test -p og-dev --locked --no-fail-fast round7_ > "$log" 2>&1 || rc=$?
+          cat "$log"
+          [ "$rc" -ne 0 ]
+          for test in ordinary_cyrillic pattern_case_scope cached_target_before_skip required_interpreters_fail_closed; do
+            grep -E "round7_${test} .*FAILED" "$log" || { echo "ERROR: missing round-seven red control"; exit 1; }
+          done
+          echo "Control: Cyrillic text, pattern scope, indexed targets and required oracles all failed before the fix."
+
       - name: Regex relation verifier rejects a missing table
         run: |
           source=crates/og-dev/src/personal_data.rs
diff --git a/CHANGELOG.md b/CHANGELOG.md
index e1fb7aff2..e1d601720 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,8 @@ Each release's notes. From 1.0.0 on, a major or minor release has hand-written n
 
 ## Unreleased
 
+- Ordinary Russian, Ukrainian and Serbian text scans again. BMP regex case differences now refuse patterns that name a differing fold class under active case-insensitive flags. This includes negated classes and range interiors. Stable case-sensitive Cyrillic names work. The Unicode property guard and the astral casing guard still apply to text, filenames and exception rows. Indexed symlink target names receive the full filename guard before SKIP, including directory components. Both Unicode verifiers fail when an explicitly requested Python cannot run. CI requires Python 3.9, 3.12 and 3.15.
+
 - The scanner's Unicode checks install Python 3.9, 3.12 and 3.15 through pinned uv tooling, so the older oracle remains available on newer `ubuntu-latest` images.
 
 - The personal-data scan refuses every astral cased character from UCD 13/15/16/17, including case-mapping targets. Text in Deseret, Osage, Old Hungarian, Warang Citi, Medefaidrin, Adlam and other astral cased scripts needs an ASCII SKIP glob. Uncased astral text still scans. Custom class ranges with a guarded interior return redacted exit 2. BMP verification now covers composite classes, ranges and alternatives on every available Python. Every working-copy symlink target gets the same redacted Unicode filename guard before following it.
diff --git a/rust/crates/og-dev/src/lookaround.rs b/rust/crates/og-dev/src/lookaround.rs
index 63eb3af6d..df44b00b2 100644
--- a/rust/crates/og-dev/src/lookaround.rs
+++ b/rust/crates/og-dev/src/lookaround.rs
@@ -489,7 +489,10 @@ impl PythonPattern {
                 // classes. Only literal range endpoints can form a range.
                 let start = class_literal(atom).ok_or(())?;
                 let end = class_literal(&atoms[i + 2].0).ok_or(())?;
-                if start > end || crate::personal_data::range_version_dependent(start, end) {
+                if start > end
+                    || crate::personal_data::range_version_dependent(start, end)
+                    || (ci && crate::personal_data::range_regex_case_dependent(start, end))
+                {
                     return Err(());
                 }
                 let range = format!("[{atom}-{}]", atoms[i + 2].0);
@@ -499,7 +502,10 @@ impl PythonPattern {
                 if atoms[i].1 && i != 0 && i + 1 != atoms.len() {
                     return Err(());
                 }
-                if ci && class_literal(atom).is_some() {
+                if ci && let Some(c) = class_literal(atom) {
+                    if crate::personal_data::range_regex_case_dependent(c, c) {
+                        return Err(());
+                    }
                     body.push_str(&fold_class(&format!("[{atom}]"))?);
                 } else {
                     body.push_str(atom);
@@ -523,7 +529,9 @@ fn class_literal(atom: &str) -> Option<char> {
 }
 
 fn literal(c: char, ci: bool) -> Result<String, ()> {
-    if crate::personal_data::version_dependent(c) {
+    if crate::personal_data::version_dependent(c)
+        || (ci && crate::personal_data::range_regex_case_dependent(c, c))
+    {
         return Err(());
     }
     let escaped = format!(r"\x{{{:x}}}", u32::from(c));
diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
index 03fa7f1fd..306abe4a3 100644
--- a/rust/crates/og-dev/src/personal_data.rs
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -37,8 +37,8 @@ use pycompat::num::py_strip;
 
 use crate::lookaround::PythonRule as Rule;
 
-// One generated guard, shared by text, patterns and exception tables. It is
-// deliberately conservative; matching itself still uses one Unicode table.
+// Property drift and astral casing guard text, patterns and exception rows.
+// BMP regex case drift is guarded separately, only where a pattern enables i.
 // BEGIN GENERATED UNICODE GUARD
 // Generated by personal-unicode-generator.rs; do not edit.
 // UCD 13.0.0, 15.0.0, 16.0.0, 17.0.0; sources pinned in personal-unicode-sources.tsv.
@@ -734,7 +734,7 @@ const VERSION_DEPENDENT: &[(u32, u32)] = &[
 
 // BEGIN GENERATED REGEX CASE RELATIONS
 // Generated by round5_regex_case_table_matches_interpreters; decimal Unicode scalar pairs.
-// Both endpoints of each differing real re.IGNORECASE relation are refused.
+// Differing BMP re.IGNORECASE relations seed the pattern-only fold-class guard.
 // Python 3.11.16 14.0.0
 // Python 3.12.14 15.0.0
 // Python 3.13.15 15.1.0
@@ -784,6 +784,25 @@ static REGEX_CASE_ENDPOINTS: LazyLock<Vec<u32>> = LazyLock::new(|| {
         .iter()
         .flat_map(|&(a, b)| [a, b])
         .collect();
+    // Close over the engine's fold classes too. Older Python-only relations
+    // already contribute both endpoints through the generated pair table.
+    let class = format!(
+        "[{}]",
+        points
+            .iter()
+            .map(|c| format!(r"\x{{{c:x}}}"))
+            .collect::<String>()
+    );
+    let hir = regex_syntax::ParserBuilder::new()
+        .case_insensitive(true)
+        .build()
+        .parse(&class)
+        .expect("fixed regex case table");
+    if let regex_syntax::hir::HirKind::Class(regex_syntax::hir::Class::Unicode(set)) = hir.kind() {
+        for range in set.iter() {
+            points.extend(u32::from(range.start())..=u32::from(range.end()));
+        }
+    }
     points.sort_unstable();
     points.dedup();
     points
@@ -798,7 +817,6 @@ pub(super) fn version_dependent(c: char) -> bool {
     VERSION_DEPENDENT
         .get(at)
         .is_some_and(|&(start, _)| start <= c)
-        || REGEX_CASE_ENDPOINTS.binary_search(&c).is_ok()
 }
 
 /// Check the closed range without walking its code points. Endpoints alone
@@ -809,9 +827,15 @@ pub(super) fn range_version_dependent(start: char, end: char) -> bool {
     VERSION_DEPENDENT
         .get(at)
         .is_some_and(|&(first, _)| first <= end)
-        || REGEX_CASE_ENDPOINTS
-            .get(REGEX_CASE_ENDPOINTS.partition_point(|&c| c < start))
-            .is_some_and(|&c| c <= end)
+}
+
+/// Only named literals and class ranges under active IGNORECASE use this
+/// relation guard. Categories and dot do not name a member of a fold class.
+pub(super) fn range_regex_case_dependent(start: char, end: char) -> bool {
+    let (start, end) = (u32::from(start), u32::from(end));
+    REGEX_CASE_ENDPOINTS
+        .get(REGEX_CASE_ENDPOINTS.partition_point(|&c| c < start))
+        .is_some_and(|&c| c <= end)
 }
 
 fn validate_unicode(text: &str, file: &str, mode: Lines) -> Result<(), String> {
@@ -1359,7 +1383,8 @@ fn run(a: &Args, out: &mut dyn Write) -> Result<bool, String> {
             .map(|(_, r)| r.clone())
             .collect();
         for target in staged(&root, &rels)?.values() {
-            std::str::from_utf8(target).map_err(|_| "path is not valid UTF-8")?;
+            let target = std::str::from_utf8(target).map_err(|_| "path is not valid UTF-8")?;
+            validate_filename(Path::new(target))?;
         }
     } else {
         for (path, _) in &todo {
@@ -2509,7 +2534,8 @@ mod tests {
             0x462, 0x463, 0x1c80, 0x1c81, 0x1c82, 0x1c83, 0x1c84, 0x1c85, 0x1c86, 0x1c87, 0x1c88,
             0xa64a, 0xa64b,
         ] {
-            assert!(version_dependent(char::from_u32(c).unwrap()));
+            let c = char::from_u32(c).unwrap();
+            assert!(range_regex_case_dependent(c, c));
         }
     }
 
@@ -2707,7 +2733,7 @@ mod tests {
     fn round6_guarded_range_interiors() {
         // Endpoints are stable. A guarded Cyrillic case partner lies inside.
         for pattern in [
-            r"[\u0410-\u044f]",
+            r"(?i)[\u0410-\u044f]",
             r"(?i)[^\u0410-\u044fZ]",
             r"[\U000103ff-\U00010450]",
             r"[\u0377-\u037a]",
@@ -2821,11 +2847,7 @@ mod tests {
                     args.push("--cached".into());
                     assert_eq!(
                         cli(&args, &mut Vec::new(), &mut Vec::new()),
-                        if skip.is_empty() && shape != "intermediate" {
-                            2
-                        } else {
-                            0
-                        }
+                        if shape != "intermediate" { 2 } else { 0 }
                     );
                 }
             }
@@ -2837,12 +2859,12 @@ mod tests {
         );
     }
 
-
     #[test]
     fn round7_ordinary_cyrillic() {
         let f = Fixture::new("r7-cyrillic");
         r5_git(&f, &["init", "-q"], b"");
-        for text in ["Привет, мир!", "Привіт, світе!", "Здраво, свете!", "о"] {
+        for text in ["Привет, мир!", "Привіт, світе!", "Здраво, свете!", "о"]
+        {
             std::fs::write(f.0.join("own.md"), text).unwrap();
             r5_git(&f, &["add", "own.md"], b"");
             r5_modes(&f, &["own.md"], 0, "");
@@ -2857,19 +2879,74 @@ mod tests {
             let mut args = f.args(&["Привет.md"]);
             args[3] = "Привет.md Привет".into();
             args[5] = "другое.md".into();
-            if cached { args.push("--cached".into()); }
+            if cached {
+                args.push("--cached".into());
+            }
             assert_eq!(cli(&args, &mut Vec::new(), &mut Vec::new()), 0);
         }
     }
 
     #[test]
     fn round7_pattern_case_scope() {
-        for pattern in ["привет", "[а-я]", "[^В]", "(?i:a)(?-i:привет)", r"[\u0410-\u044f]"] {
-            assert!(Rule::compile(pattern, false).is_ok(), "stable pattern refused");
+        for pattern in [
+            "привет",
+            "[а-я]",
+            "[^В]",
+            "(?i:a)(?-i:привет)",
+            r"[\u0410-\u044f]",
+        ] {
+            assert!(
+                Rule::compile(pattern, false).is_ok(),
+                "stable pattern refused"
+            );
         }
-        for pattern in ["(?i)привет", "(?i)[а-я]", "(?i)[^В]", "(?i:[^ОZ])", r"(?i)[\u0430-\u044f]", "(?i:т)"] {
+        for pattern in [
+            "(?i)привет",
+            "(?i)[а-я]",
+            "(?i)[^В]",
+            "(?i:[^ОZ])",
+            r"(?i)[\u0430-\u044f]",
+            "(?i:т)",
+        ] {
             for builtin in [false, true] {
-                assert!(Rule::compile(pattern, builtin).is_err(), "unstable pattern accepted");
+                assert!(
+                    Rule::compile(pattern, builtin).is_err(),
+                    "unstable pattern accepted"
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn round7_custom_cyrillic_cli() {
+        let f = Fixture::new("r7-custom");
+        r5_git(&f, &["init", "-q"], b"");
+        std::fs::write(f.0.join("own.md"), "привет, мир!").unwrap();
+        r5_git(&f, &["add", "own.md"], b"");
+        for (pattern, expected) in [
+            ("привет", 1),
+            ("[а-я]", 1),
+            ("(?i)привет", 2),
+            ("(?i)[а-я]", 2),
+        ] {
+            std::fs::write(f.0.join("patterns"), pattern).unwrap();
+            for cached in [false, true] {
+                for explicit in [false, true] {
+                    let mut args = f.args(if explicit { &["own.md"] } else { &[] });
+                    args.extend([
+                        "--patterns".into(),
+                        f.0.join("patterns").display().to_string(),
+                    ]);
+                    if cached {
+                        args.push("--cached".into());
+                    }
+                    let (mut out, mut err) = (Vec::new(), Vec::new());
+                    assert_eq!(cli(&args, &mut out, &mut err), expected);
+                    let output = [out, err].concat();
+                    let output = String::from_utf8_lossy(&output);
+                    assert!(!output.contains(pattern));
+                    assert!(!output.contains("привет"));
+                }
             }
         }
     }
@@ -2886,13 +2963,20 @@ mod tests {
             std::fs::remove_file(f.0.join("alias.md")).unwrap();
             std::fs::write(f.0.join("alias.md"), "clean").unwrap();
             for explicit in [false, true] {
-                let mut args = f.args(if explicit { &["alias.md", "clean.md"] } else { &[] });
+                let mut args = f.args(if explicit {
+                    &["alias.md", "clean.md"]
+                } else {
+                    &[]
+                });
                 args[5] = "alias.md".into();
                 args.push("--cached".into());
                 let (mut out, mut err) = (Vec::new(), Vec::new());
                 assert_eq!(cli(&args, &mut out, &mut err), 2);
                 assert!(out.is_empty());
-                assert_eq!(err, b"ERROR: selected filename has Unicode version-dependent text\n");
+                assert_eq!(
+                    err,
+                    b"ERROR: selected filename has Unicode version-dependent text\n"
+                );
             }
             std::fs::remove_file(f.0.join("alias.md")).unwrap();
         }
@@ -2902,24 +2986,62 @@ mod tests {
     fn round7_required_interpreters_fail_closed() {
         let f = Fixture::new("r7-required-python");
         for interpreter in [f.0.join("missing-python"), PathBuf::from("/usr/bin/false")] {
-            for test in ["round4_guard_agrees_with_available_pythons", "round5_regex_case_table_matches_interpreters"] {
+            for test in [
+                "round4_guard_agrees_with_available_pythons",
+                "round5_regex_case_table_matches_interpreters",
+            ] {
                 let output = Command::new(std::env::current_exe().unwrap())
-                    .args(["--exact", &format!("personal_data::tests::{test}"), "--nocapture"])
+                    .args([
+                        "--exact",
+                        &format!("personal_data::tests::{test}"),
+                        "--nocapture",
+                    ])
                     .env("PERSONAL_DATA_PYTHONS", &interpreter)
-                    .output().unwrap();
-                assert!(!output.status.success(), "required interpreter silently skipped: {test}");
-                let log = String::from_utf8_lossy(&output.stdout);
-                assert!(log.contains("required Python oracle"), "wrong verifier failure");
+                    .output()
+                    .unwrap();
+                assert!(
+                    !output.status.success(),
+                    "required interpreter silently skipped: {test}"
+                );
+                let bytes = [output.stdout, output.stderr].concat();
+                let log = String::from_utf8_lossy(&bytes);
+                assert!(
+                    log.contains("required Python oracle"),
+                    "wrong verifier failure"
+                );
             }
         }
     }
 
-    // Regenerate with PERSONAL_DATA_UPDATE_REGEX_CASES=1 and all supported
-    // interpreters on PATH (or in PERSONAL_DATA_PYTHONS). No Python file is
-    // added to the repository; these calls use each real interpreter's engine.
-    #[test]
-    fn round5_regex_case_table_matches_interpreters() {
-        let mut commands: Vec<String> = [
+    /// Explicit oracles are requirements, even when another path has the same
+    /// version. PATH discovery is optional. Probe requirements before dedup.
+    fn oracle_interpreters() -> Vec<(String, Vec<u8>)> {
+        let probe = |command: &str| {
+            Command::new(command).args(["-I", "-c",
+            "import sys,unicodedata; print(sys.version.split()[0],unicodedata.unidata_version)"]).output()
+        };
+        let mut found = Vec::new();
+        if let Some(extra) = std::env::var_os("PERSONAL_DATA_PYTHONS") {
+            for command in std::env::split_paths(&extra) {
+                let command = command
+                    .to_str()
+                    .expect("required Python oracle path encoding");
+                let output = probe(command).expect("required Python oracle could not run");
+                assert!(
+                    output.status.success() && output.stderr.is_empty(),
+                    "required Python oracle failed"
+                );
+                assert!(
+                    String::from_utf8_lossy(&output.stdout)
+                        .split_whitespace()
+                        .count()
+                        == 2,
+                    "required Python oracle returned an invalid version"
+                );
+                found.push((command.to_owned(), output.stdout));
+            }
+        }
+        for command in [
             "python3",
             "python3.9",
             "python3.10",
@@ -2929,24 +3051,262 @@ mod tests {
             "python3.14",
             "python3.15",
             "/usr/bin/python3",
-        ]
-        .iter()
-        .map(|s| (*s).into())
-        .collect();
-        if let Ok(extra) = std::env::var("PERSONAL_DATA_PYTHONS") {
-            commands.extend(extra.split(':').map(str::to_owned));
+        ] {
+            if let Ok(output) = probe(command)
+                && output.status.success()
+                && output.stderr.is_empty()
+            {
+                found.push((command.to_owned(), output.stdout));
+            }
+        }
+        if let Ok(required) = std::env::var("PERSONAL_DATA_REQUIRE_PYTHONS") {
+            for minor in required.split(':') {
+                assert!(
+                    found
+                        .iter()
+                        .any(|(_, version)| String::from_utf8_lossy(version)
+                            .starts_with(&format!("{minor}."))),
+                    "required Python oracle version unavailable"
+                );
+            }
+        }
+        let mut versions = HashSet::new();
+        found.retain(|(_, version)| versions.insert(version.clone()));
+        assert!(!found.is_empty(), "no Python oracle available");
+        found
+    }
+    /// Prove the converse on admitted text with real finditer spans. Endpoints
+    /// excluded by the property guard must stop before matching instead.
+    /// Discover third partners from actual singleton relations and probe them.
+    fn regex_case_converse(
+        interpreters: &[String],
+        pairs: &std::collections::BTreeSet<(u32, u32)>,
+    ) {
+        let input: String = pairs.iter().map(|(a, b)| format!("{a} {b}\n")).collect();
+        let run = |command: &str, script: &str, input: &str| {
+            let mut child = Command::new(command)
+                .args(["-I", "-c", script])
+                .stdin(Stdio::piped())
+                .stdout(Stdio::piped())
+                .stderr(Stdio::piped())
+                .spawn()
+                .unwrap();
+            let mut stdin = child.stdin.take().unwrap();
+            let bytes = input.to_owned();
+            let writer = std::thread::spawn(move || stdin.write_all(bytes.as_bytes()));
+            let output = child.wait_with_output().unwrap();
+            writer.join().unwrap().unwrap();
+            assert!(
+                output.status.success() && output.stderr.is_empty(),
+                "converse oracle failed"
+            );
+            String::from_utf8(output.stdout).unwrap()
+        };
+        let mut graph: HashMap<u32, HashSet<u32>> = HashMap::new();
+        for command in interpreters {
+            let output = run(
+                command,
+                r#"
+import re,sys
+for row in sys.stdin:
+    a,b=map(int,row.split())
+    if re.fullmatch(re.escape(chr(a)),chr(b),re.I) or re.fullmatch(re.escape(chr(b)),chr(a),re.I): print(a,b)
+"#,
+                &input,
+            );
+            for row in output.lines() {
+                let (a, b) = row.split_once(' ').unwrap();
+                let (a, b) = (a.parse::<u32>().unwrap(), b.parse::<u32>().unwrap());
+                graph.entry(a).or_default().insert(b);
+                graph.entry(b).or_default().insert(a);
+            }
+        }
+        let mut classes = Vec::new();
+        for &(a, b) in REGEX_CASE_RELATIONS {
+            let mut class = std::collections::BTreeSet::from([a, b]);
+            let mut pending = vec![a, b];
+            while let Some(c) = pending.pop() {
+                for &partner in graph.get(&c).into_iter().flatten() {
+                    if class.insert(partner) {
+                        pending.push(partner);
+                    }
+                }
+            }
+            classes.push((a, b, class));
+        }
+        let mut admitted = HashSet::new();
+        let mut stopped = HashSet::new();
+        for (a, b, class) in &classes {
+            for &c in class {
+                let c = char::from_u32(c).unwrap();
+                assert!(range_regex_case_dependent(c, c), "fold class is unguarded");
+            }
+            for &c in [a, b] {
+                let text = char::from_u32(c).unwrap().to_string();
+                if version_dependent(char::from_u32(c).unwrap()) {
+                    stopped.insert(c);
+                    // Exercise the production validation path, not just table
+                    // membership. This endpoint never reaches the matcher.
+                    assert_eq!(
+                        validate_unicode(&text, "own.md", Lines::Blob),
+                        Err("own.md:1: Unicode version-dependent text".into())
+                    );
+                    let f = Fixture::new("r7-property-endpoint");
+                    r5_git(&f, &["init", "-q"], b"");
+                    std::fs::write(f.0.join("own.md"), &text).unwrap();
+                    r5_git(&f, &["add", "own.md"], b"");
+                    r5_modes(&f, &["own.md"], 2, "");
+                } else {
+                    admitted.insert(c);
+                    assert!(validate_unicode(&text, "own.md", Lines::Blob).is_ok());
+                }
+            }
+        }
+        let input: String = classes
+            .iter()
+            .map(|(a, b, class)| {
+                format!(
+                    "{a} {b} {} {} {}\n",
+                    u8::from(admitted.contains(a)),
+                    u8::from(admitted.contains(b)),
+                    class
+                        .iter()
+                        .map(u32::to_string)
+                        .collect::<Vec<_>>()
+                        .join(" ")
+                )
+            })
+            .collect();
+        let script = r#"
+import re,sys,json
+for row in sys.stdin:
+    a,b,admit_a,admit_b,*group=map(int,row.split()); group=set(group)
+    # No named scalar is in the union of real case classes. Category escapes
+    # name categories, not individual scalars, even in negated classes.
+    atoms=['.',r'\w',r'\W',r'\d',r'\D',r'\s',r'\S',r'[^\w]',r'[^\W]',r'[^\d]',r'[^\D]',r'[^\s]',r'[^\S]',
+        '[^AZ]','[^éΩ]', '[A-Z]', '[é-ö]', '[^A-Zé-ö]',r'[A-Z\w]',r'[^AZ\d]',r'[^éΩ\W]']
+    assert not any(ord(c) in group for p in atoms for c in p)
+    assert not any(c in group for lo,hi in ((65,90),(233,246)) for c in range(lo,hi+1))
+    patterns=[]
+    for p in atoms:
+        patterns.extend(['(?i)'+p,'(?i:'+p+')','(?i:'+p+')+','(?i:'+p+'){1,3}?',
+            '(?i:'+p+'|Z)', '(?i:Z|'+p+')', '(?i:'+p+')(?-i:a)?', '(?i:(?:'+p+')+|Z)'])
+    # Stable case-sensitive names must still agree, including ordinary prose.
+    patterns.extend(['привет','[а-я]','[^В]','(?i:a)(?-i:привет)'])
+    texts=[]
+    for c,admit in ((a,admit_a),(b,admit_b)):
+        if not admit: continue
+        s=chr(c)
+        texts.extend([s,s*2,'A'+s+'éΩ9 ',s+'\u0301'+s,'! '+s+' Z', 'привет '+s])
+    for p in patterns:
+        for t in texts:
+            print(json.dumps([p,t,[(m.start(),m.end()) for m in re.finditer(p,t)],False,False],ensure_ascii=True))
+    # A third member can expose a different optimized compiler shape even if
+    # the pair table never used it as a pattern. Test every discovered member.
+    for c in sorted(group):
+        e=re.escape(chr(c))
+        for body in (e,'['+e+']','[^'+e+']','['+e+'Z]','[^'+e+'Z]',e+'|Z',r'[^'+e+r'\w]'):
+            p='(?i:'+body+')+'
+            for t in texts: print(json.dumps([p,t,[(m.start(),m.end()) for m in re.finditer(p,t)],True,c not in (a,b)],ensure_ascii=True))
+"#;
+        fn row_values(row: &str) -> (String, String, pycompat::json::Value, bool, bool) {
+            use pycompat::json::{Value, loads};
+            let Value::Array(row) = loads(row).unwrap() else {
+                panic!("invalid oracle row");
+            };
+            let [
+                Value::Str(pattern),
+                Value::Str(text),
+                spans,
+                Value::Bool(named),
+                Value::Bool(third),
+            ]: [Value; 5] = row.try_into().unwrap()
+            else {
+                panic!("invalid oracle columns");
+            };
+            (pattern, text, spans, named, third)
+        }
+        let mut baseline: Option<Vec<String>> = None;
+        let mut compared = 0;
+        let mut third_differences = HashSet::new();
+        let mut named_differences = HashSet::new();
+        let mut compiled: HashMap<String, Result<Rule, ()>> = HashMap::new();
+        for command in interpreters {
+            let output = run(command, script, &input);
+            let rows: Vec<_> = output.lines().map(str::to_owned).collect();
+            if let Some(first) = &baseline {
+                assert_eq!(first.len(), rows.len());
+                for (old, new) in first.iter().zip(&rows) {
+                    let (pattern, _, _, named, third) = row_values(new);
+                    if old != new {
+                        assert!(named, "converse violated by unnamed fold class");
+                        // A difference is permitted only for a pattern refused
+                        // by the production compiler. Otherwise stop shipping.
+                        assert!(
+                            Rule::compile(&pattern, false).is_err(),
+                            "converse violated by accepted pattern"
+                        );
+                        if third {
+                            third_differences.insert(pattern.to_owned());
+                        }
+                        named_differences.insert(pattern.to_owned());
+                    }
+                }
+            }
+            for row in &rows {
+                let (pattern, text, expected, named, _) = row_values(row);
+                assert!(
+                    validate_unicode(&text, "own.md", Lines::Blob).is_ok(),
+                    "converse text must be admitted"
+                );
+                let rule = compiled
+                    .entry(pattern.to_owned())
+                    .or_insert_with(|| Rule::compile(&pattern, false));
+                if !named {
+                    assert!(rule.is_ok(), "converse shape must be accepted");
+                }
+                if let Ok(rule) = rule {
+                    let spans: Vec<_> = rule
+                        .find_iter(&text)
+                        .map(|m| {
+                            let (a, b) = m.unwrap();
+                            pycompat::json::Value::Array(vec![
+                                pycompat::json::Value::Int(text[..a].chars().count() as i128),
+                                pycompat::json::Value::Int(text[..b].chars().count() as i128),
+                            ])
+                        })
+                        .collect();
+                    assert_eq!(
+                        pycompat::json::Value::Array(spans),
+                        expected,
+                        "accepted converse spans differ"
+                    );
+                }
+            }
+            compared += rows.len();
+            baseline.get_or_insert(rows);
         }
+        println!(
+            "Converse: {compared} admitted-text span rows; {} admitted endpoints, {} property-stopped endpoints; {} differing named-class shapes refused, including {} third-partner shapes",
+            admitted.len(),
+            stopped.len(),
+            named_differences.len(),
+            third_differences.len()
+        );
+    }
+    // Regenerate with PERSONAL_DATA_UPDATE_REGEX_CASES=1 and all supported
+    // interpreters on PATH (or in PERSONAL_DATA_PYTHONS). No Python file is
+    // added to the repository; these calls use each real interpreter's engine.
+    #[test]
+    fn round5_regex_case_table_matches_interpreters() {
         let mut interpreters = Vec::new();
         let mut versions = HashSet::new();
         let mut pairs = std::collections::BTreeSet::new();
-        for command in commands {
-            let Ok(probe) = Command::new(&command).args(["-I", "-c", "import sys,unicodedata; print(sys.version.split()[0],unicodedata.unidata_version)"]).output() else { continue; };
-            if !probe.status.success() || !versions.insert(probe.stdout.clone()) {
-                continue;
-            }
+        for (command, version) in oracle_interpreters() {
+            versions.insert(version.clone());
             println!(
                 "Regex relations checked Python {}",
-                String::from_utf8_lossy(&probe.stdout).trim()
+                String::from_utf8_lossy(&version).trim()
             );
             // Lowercase buckets plus the compiler's extra cases enumerate
             // candidate pairs, including relations absent in another version.
@@ -2991,7 +3351,7 @@ for group in buckets.values():
         let input: String = pairs.iter().map(|(a, b)| format!("{a} {b}\n")).collect();
         let mut baseline = None;
         let mut differing = std::collections::BTreeSet::new();
-        for command in interpreters {
+        for command in &interpreters {
             let mut child = Command::new(command)
                 .args([
                     "-I",
@@ -3057,7 +3417,7 @@ for row in sys.stdin:
                 "generation requires multiple real interpreters"
             );
             let mut table = String::from(
-                "// Generated by round5_regex_case_table_matches_interpreters; decimal Unicode scalar pairs.\n// Both endpoints of each differing real re.IGNORECASE relation are refused.\n",
+                "// Generated by round5_regex_case_table_matches_interpreters; decimal Unicode scalar pairs.\n// Differing BMP re.IGNORECASE relations seed the pattern-only fold-class guard.\n",
             );
             let mut versions: Vec<_> = versions
                 .iter()
@@ -3088,6 +3448,7 @@ for row in sys.stdin:
                 "checked-in regex table misses a differing pair"
             );
         }
+        regex_case_converse(&interpreters, &pairs);
         println!(
             "{} candidate pairs, {} differing pairs on available interpreters, {} checked-in pairs",
             pairs.len(),
@@ -3095,12 +3456,15 @@ for row in sys.stdin:
             checked.len()
         );
         // Generation can run before the production table is updated. Every
-        // ordinary verification must also prove both endpoints fail closed.
+        // ordinary verification must prove both endpoints are pattern-guarded.
         if std::env::var_os("PERSONAL_DATA_UPDATE_REGEX_CASES").is_none() {
             for (a, b) in &checked {
                 for c in [a, b] {
                     assert!(
-                        version_dependent(char::from_u32(*c).unwrap()),
+                        range_regex_case_dependent(
+                            char::from_u32(*c).unwrap(),
+                            char::from_u32(*c).unwrap()
+                        ),
                         "regex endpoint is unguarded"
                     );
                 }
@@ -3111,35 +3475,16 @@ for row in sys.stdin:
     #[test]
     fn round4_guard_agrees_with_available_pythons() {
         // Every available interpreter is checked, not just whichever python3
-        // happens to be first on PATH. Guard installs 3.12 and 3.15 explicitly.
-        let mut commands: Vec<String> = [
-            "python3",
-            "python3.9",
-            "python3.12",
-            "python3.14",
-            "python3.15",
-            "/usr/bin/python3",
-        ]
-        .iter()
-        .map(|s| (*s).into())
-        .collect();
-        if let Ok(extra) = std::env::var("PERSONAL_DATA_PYTHONS") {
-            commands.extend(extra.split(':').map(str::to_owned));
-        }
-        let mut guarded = VERSION_DEPENDENT.to_vec();
-        guarded.extend(REGEX_CASE_ENDPOINTS.iter().map(|&c| (c, c)));
-        guarded.sort_unstable();
+        // happens to be first on PATH. CI requires 3.9, 3.12 and 3.15 explicitly.
+        let guarded = VERSION_DEPENDENT.to_vec();
         let ranges = guarded
             .iter()
             .map(|(a, b)| format!("{a} {b}\n"))
             .collect::<String>();
         let mut baseline = None;
         let mut versions = HashSet::new();
-        for command in commands {
-            let Ok(probe) = Command::new(&command).args(["-I", "-c", "import sys,unicodedata; print(sys.version.split()[0],unicodedata.unidata_version)"]).output() else { continue; };
-            if !probe.status.success() || !versions.insert(probe.stdout.clone()) {
-                continue;
-            }
+        for (command, version) in oracle_interpreters() {
+            versions.insert(version);
             let mut child = Command::new(command)
                 .args([
                     "-I",
diff --git a/scripts/ci/check-personal-data.sh b/scripts/ci/check-personal-data.sh
index de0abadbe..4ed26da74 100755
--- a/scripts/ci/check-personal-data.sh
+++ b/scripts/ci/check-personal-data.sh
@@ -73,23 +73,35 @@
 # pattern shape. Text in Deseret, Osage, Old Hungarian, Warang Citi,
 # Medefaidrin, Adlam and any other astral cased script stops the scan until
 # its file is SKIPped. Newer plain symbols, emoji and uncased CJK still scan.
-# A custom class range containing a guarded scalar is refused, even when
-# its endpoints are stable. ASCII and stable Latin-1 ranges remain supported.
+# A custom class range containing a property-guarded scalar is refused, even
+# when its endpoints are stable. ASCII and stable Latin-1 ranges still work.
 #
 # The generated conservative set includes every scalar unassigned in UCD
 # 17; post-13 letters, marks, numbers, connectors, spaces and case mappings;
 # and older scalars whose word/digit/space membership or case maps change
 # in UCD 13/15/16/17. Full case folds avoid rejecting six stable old scalars.
-# Another generated table guards both ends of BMP regex case relations that
-# differ across supported Python engines. Real re.fullmatch calls check both
-# directions with literals, singleton and composite positive/negative classes,
-# ASCII/category mixtures, range endpoints/interiors, optimized alternatives
-# and grouped forms. Astral mappings come from UnicodeData, SpecialCasing
+# BMP regex case differences apply only to patterns. Under active global or
+# scoped i flags, a literal or a class range naming any member of a differing
+# fold class is refused. This includes escaped members, positive and negated
+# classes, and range interiors. Disabling i in that scope permits stable
+# case-sensitive names and ranges. Ordinary Russian, Ukrainian and Serbian
+# text, filenames and ALLOW/SKIP rows pass unless the property guard covers
+# them. Dot and category escapes do not name a member of a fold class.
+# Real fullmatch calls discover differing pairs. For each BMP pair, the
+# converse verifier proves that property-guarded endpoints stop the scan.
+# For admitted endpoints, it compares finditer spans using unrelated literals,
+# categories, negated classes, ranges, alternations, scopes and quantifiers.
+# It also discovers third case partners on every interpreter and checks their
+# shapes. Any differing accepted shape on admitted text fails verification.
+# Astral mappings come from UnicodeData, SpecialCasing
 # and CaseFolding, all SHA-256-pinned, with no interpreter test needed.
 # The 248 newer scalars with stable effective behavior remain conservatively
 # blocked. The six stable scalars assigned by Unicode 13 pass.
-# This adds one binary-search lookup per non-ASCII character (ASCII is
-# stable), plus a fixed regex-endpoint table. No per-file index or process.
+# Text validation uses one binary search per non-ASCII character. Pattern
+# compilation also checks a small fixed BMP fold-class set under i flags.
+# That set is initialized once from the embedded pairs and engine fold table.
+# This guard uses no per-file index or process. Cached symlink target names,
+# including directory components, receive the same check before SKIP.
 # Regenerate from SHA-256-pinned official data with the Rust generator:
 # tests/parity/gen/personal-unicode-generate.sh SCRATCH_DIR
 # Guard regenerates byte for byte and compares all available Python oracles,
@@ -98,7 +110,10 @@
 # PERSONAL_DATA_UPDATE_REGEX_CASES=1 cargo test -p og-dev round5_regex_case_table_matches_interpreters
 # Supply all supported Python interpreters on PATH or PERSONAL_DATA_PYTHONS
 # (colon-separated paths). Ordinary tests verify every available interpreter
-# and reject any differing pair missing from the checked-in table.
+# and reject any differing pair missing from the checked-in table. Every
+# explicitly supplied path must run successfully. CI requires
+# 3.9, 3.12 and 3.15 through PERSONAL_DATA_REQUIRE_PYTHONS. Missing explicit
+# paths and failing interpreters are negative controls for both verifiers.
 #
 # The scan is og dev scan personal-data (rust/crates/og-dev); bin/og runs
 # the build scripts/setup.sh --og puts in bin/.og for this machine, and OG

From b5ab8bf8d2456760ec77f460f91c653226d1781f Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 21:15:40 +0100
Subject: [PATCH 75/76] docs(dev): say which BED files the evidence commands
 read and why deep JSON is accepted

---
 docs/rust.md | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/docs/rust.md b/docs/rust.md
index feda92600..8bc38d80b 100644
--- a/docs/rust.md
+++ b/docs/rust.md
@@ -167,7 +167,14 @@ still apply.
   before any output write because its temporary sibling name is longer.
 
 Inputs produced by the real tools are never refused: bcftools/DeepVariant VCF,
-samtools faidx, UCSC BED, PharmCAT report JSON and Renovate debug log.
+samtools faidx, header-free BED intervals, PharmCAT report JSON and Renovate
+debug log. A BED file with a UCSC column header, a `track` line or a `browser`
+line is refused, as the Python refused it: remove those lines first.
+
+Valid JSON nested up to the reader's 1000 levels is accepted. The Python stopped
+with a RecursionError at a few hundred levels when it copied or wrote such a
+value. That was a limit of the interpreter, not a check on the input, so the
+Rust commands do not copy it.
 
 `refusals_preserve_bytes_modes_and_link_targets` pins the rule through each CLI.
 Each table row runs with a regular output and with a symlink. It checks nonzero

From c01ea3b23ec1399a9aa9144728da747be9eff4bf Mon Sep 17 00:00:00 2001
From: GeiserX <9169332+GeiserX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 21:55:16 +0100
Subject: [PATCH 76/76] fix(dev): say why a case-insensitive name pattern was
 refused and what to change

---
 CHANGELOG.md                            |  2 +-
 rust/crates/og-dev/src/lookaround.rs    | 56 +++++++++++++++++++++----
 rust/crates/og-dev/src/personal_data.rs | 24 +++++++++--
 3 files changed, 69 insertions(+), 13 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e1d601720..3ae4c0a4f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,7 +4,7 @@ Each release's notes. From 1.0.0 on, a major or minor release has hand-written n
 
 ## Unreleased
 
-- Ordinary Russian, Ukrainian and Serbian text scans again. BMP regex case differences now refuse patterns that name a differing fold class under active case-insensitive flags. This includes negated classes and range interiors. Stable case-sensitive Cyrillic names work. The Unicode property guard and the astral casing guard still apply to text, filenames and exception rows. Indexed symlink target names receive the full filename guard before SKIP, including directory components. Both Unicode verifiers fail when an explicitly requested Python cannot run. CI requires Python 3.9, 3.12 and 3.15.
+- Ordinary Russian, Ukrainian and Serbian text scans again. BMP regex case differences now refuse patterns that name a differing fold class under active case-insensitive flags. This includes negated classes and range interiors. Stable case-sensitive Cyrillic names work. The Unicode property guard and the astral casing guard still apply to text, filenames and exception rows. Indexed symlink target names receive the full filename guard before SKIP, including directory components. Both Unicode verifiers fail when an explicitly requested Python cannot run. CI requires Python 3.9, 3.12 and 3.15. A custom pattern refused by the case-difference rule now says so, with the file and line, and says what to change: turn the `i` flag off for that part and list the exact spellings.
 
 - The scanner's Unicode checks install Python 3.9, 3.12 and 3.15 through pinned uv tooling, so the older oracle remains available on newer `ubuntu-latest` images.
 
diff --git a/rust/crates/og-dev/src/lookaround.rs b/rust/crates/og-dev/src/lookaround.rs
index df44b00b2..75e27dcb1 100644
--- a/rust/crates/og-dev/src/lookaround.rs
+++ b/rust/crates/og-dev/src/lookaround.rs
@@ -105,6 +105,15 @@ mod tests {
 const WORD: &str = r"[\p{L}\p{N}_]";
 const SPACE: &str = r"[\x09-\x0d\x1c-\x20\x85\x{a0}\x{1680}\x{2000}-\x{200a}\x{2028}\x{2029}\x{202f}\x{205f}\x{3000}]";
 
+/// Why a pattern was refused.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Refusal {
+    /// It names, under an active `i` flag, a letter whose case pairing
+    /// differs between Unicode versions.
+    CaseDependent,
+    Other,
+}
+
 #[derive(Clone)]
 pub struct PythonRule {
     re: fancy_regex::Regex,
@@ -113,11 +122,28 @@ pub struct PythonRule {
 
 impl PythonRule {
     pub fn compile(pattern: &str, builtin: bool) -> Result<Self, ()> {
+        Self::compile_explained(pattern, builtin).map_err(|_| ())
+    }
+
+    /// As `compile`, and says when the refusal is the case-pairing guard, so
+    /// the caller can tell the user what to change.
+    pub fn compile_explained(pattern: &str, builtin: bool) -> Result<Self, Refusal> {
+        Self::compile_inner(pattern, builtin).map_err(|case| {
+            if case {
+                Refusal::CaseDependent
+            } else {
+                Refusal::Other
+            }
+        })
+    }
+
+    /// The error is true when the case-pairing guard refused the pattern.
+    fn compile_inner(pattern: &str, builtin: bool) -> Result<Self, bool> {
         if pattern.chars().any(crate::personal_data::version_dependent) {
-            return Err(());
+            return Err(false);
         }
         if pattern.len() > 16_384 {
-            return Err(());
+            return Err(false);
         }
         let mut parser = PythonPattern {
             chars: pattern.chars().collect(),
@@ -125,8 +151,11 @@ impl PythonRule {
             builtin,
             depth: 0,
             names: std::collections::HashSet::new(),
+            case_refused: false,
         };
-        let (translated, _) = parser.group(Flags::default(), false)?;
+        let (translated, _) = parser
+            .group(Flags::default(), false)
+            .map_err(|()| parser.case_refused)?;
         // \G is the search offset. After yielding an empty match, forbid only
         // a match ending at that offset; the engine then tries nonempty
         // alternatives at the same start, exactly as Python finditer does.
@@ -135,7 +164,7 @@ impl PythonRule {
             fancy_regex::RegexBuilder::new(p)
                 .backtrack_limit(1_000_000)
                 .build()
-                .map_err(|_| ())
+                .map_err(|_| false)
         };
         Ok(Self {
             re: build(&translated)?,
@@ -190,9 +219,17 @@ struct PythonPattern {
     builtin: bool,
     depth: usize,
     names: std::collections::HashSet<String>,
+    /// Set when a refusal comes from the case-pairing guard.
+    case_refused: bool,
 }
 
 impl PythonPattern {
+    /// `literal`, recording a refusal by the case-pairing guard.
+    fn lit(&mut self, c: char, ci: bool) -> Result<String, ()> {
+        self.case_refused |= ci && crate::personal_data::range_regex_case_dependent(c, c);
+        literal(c, ci)
+    }
+
     fn take(&mut self) -> Result<char, ()> {
         let c = self.chars.get(self.at).copied().ok_or(())?;
         self.at += 1;
@@ -404,7 +441,7 @@ impl PythonPattern {
                 }
                 '}' => return Err(()),
                 c => {
-                    out.push_str(&literal(c, flags.i)?);
+                    out.push_str(&self.lit(c, flags.i)?);
                     atom_nullable = false;
                     repeatable = true;
                     lazy = false;
@@ -453,10 +490,10 @@ impl PythonPattern {
                     hex.push(c);
                 }
                 let c = char::from_u32(u32::from_str_radix(&hex, 16).map_err(|_| ())?).ok_or(())?;
-                literal(c, ci)?
+                self.lit(c, ci)?
             }
             c if c.is_ascii_alphanumeric() => return Err(()),
-            c => literal(c, ci)?,
+            c => self.lit(c, ci)?,
         })
     }
 
@@ -489,9 +526,11 @@ impl PythonPattern {
                 // classes. Only literal range endpoints can form a range.
                 let start = class_literal(atom).ok_or(())?;
                 let end = class_literal(&atoms[i + 2].0).ok_or(())?;
+                self.case_refused |=
+                    ci && crate::personal_data::range_regex_case_dependent(start, end);
                 if start > end
                     || crate::personal_data::range_version_dependent(start, end)
-                    || (ci && crate::personal_data::range_regex_case_dependent(start, end))
+                    || self.case_refused
                 {
                     return Err(());
                 }
@@ -504,6 +543,7 @@ impl PythonPattern {
                 }
                 if ci && let Some(c) = class_literal(atom) {
                     if crate::personal_data::range_regex_case_dependent(c, c) {
+                        self.case_refused = true;
                         return Err(());
                     }
                     body.push_str(&fold_class(&format!("[{atom}]"))?);
diff --git a/rust/crates/og-dev/src/personal_data.rs b/rust/crates/og-dev/src/personal_data.rs
index 306abe4a3..40159c19d 100644
--- a/rust/crates/og-dev/src/personal_data.rs
+++ b/rust/crates/og-dev/src/personal_data.rs
@@ -35,7 +35,7 @@ use std::sync::LazyLock;
 use pycompat::mtime::fnmatch;
 use pycompat::num::py_strip;
 
-use crate::lookaround::PythonRule as Rule;
+use crate::lookaround::{PythonRule as Rule, Refusal};
 
 // Property drift and astral casing guard text, patterns and exception rows.
 // BMP regex case drift is guarded separately, only where a pattern enables i.
@@ -1069,6 +1069,9 @@ fn parse(args: &[String]) -> Result<Args, String> {
     })
 }
 
+/// Said when a pattern is refused by the case-pairing guard.
+const CASE_REFUSAL: &str = "unsupported custom pattern: it matches case-insensitively a letter whose upper/lower pairing differs between Unicode versions (some Cyrillic letters, for example). Turn the i flag off for that part and list the exact spellings instead, such as (?:Name|NAME|name)";
+
 /// The user's own patterns, one per line; `#` lines and blank lines skipped.
 fn own_rules(path: &str) -> Result<Vec<Check>, String> {
     let text = std::fs::read_to_string(path).map_err(|e| format!("cannot read {path}: {e}"))?;
@@ -1081,11 +1084,16 @@ fn own_rules(path: &str) -> Result<Vec<Check>, String> {
         }
         // Rule reports capture 1 for the built-in look-around patterns.
         // A user's captures must not narrow the span checked against ALLOW.
-        let rule = Rule::compile(p, false).map_err(|_| {
+        // The message never quotes the pattern: it is private.
+        let rule = Rule::compile_explained(p, false).map_err(|why| {
             format!(
-                "{}:{}: invalid or unsupported custom pattern",
+                "{}:{}: {}",
                 path.escape_debug(),
-                line + 1
+                line + 1,
+                match why {
+                    Refusal::CaseDependent => CASE_REFUSAL,
+                    Refusal::Other => "invalid or unsupported custom pattern",
+                }
             )
         })?;
         out.push(Check {
@@ -2144,6 +2152,8 @@ mod tests {
             let (mut out, mut err) = (Vec::new(), Vec::new());
             assert_eq!(cli(&args, &mut out, &mut err), 2, "control {index}");
             assert!(!String::from_utf8_lossy(&err).contains("PRIVATE"));
+            // Only the case-pairing guard gives the i-flag advice.
+            assert!(!String::from_utf8_lossy(&err).contains("i flag"));
             assert!(!String::from_utf8_lossy(&out).contains("PRIVATE"));
         }
     }
@@ -2942,6 +2952,12 @@ mod tests {
                     }
                     let (mut out, mut err) = (Vec::new(), Vec::new());
                     assert_eq!(cli(&args, &mut out, &mut err), expected);
+                    // The refusal names the line and says what to change.
+                    assert_eq!(
+                        String::from_utf8_lossy(&err).contains(":1: unsupported custom pattern")
+                            && String::from_utf8_lossy(&err).contains("Turn the i flag off"),
+                        expected == 2
+                    );
                     let output = [out, err].concat();
                     let output = String::from_utf8_lossy(&output);
                     assert!(!output.contains(pattern));