From 2cb3a49ab40c777add34b87b7526ce5df0524264 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Mon, 31 Aug 2026 10:58:19 +0800
Subject: [PATCH 01/51] tandardize test filenames and improve formatter
 diagnostics

---
 CONTRIBUTING.md                               |    9 +-
 docs/api/discrete_distributions.md            |    5 +-
 docs/mpmc-compatibility.md                    |    7 +-
 docs/tests.md                                 |   42 +
 makefile                                      |   15 +
 qmcpy/accumulate_data/__init__.py             |    1 -
 scripts/check_test_style.py                   |  131 ++
 scripts/flatten_qmcpy_imports.py              |   27 +-
 scripts/remove_trailing_whitespace.py         |   14 +-
 scripts/unwrap_markdown.py                    |   22 +-
 test/README.md                                |   42 +
 test/test_check_links.py                      |  178 ---
 test/test_check_removed_urls.py               |  134 --
 test/test_copulas.py                          | 1362 -----------------
 ...stribs.py => test_dd_discrete_distribs.py} |    0
 test/test_dd_dummy_sampler.py                 |  107 ++
 test/test_dummy_sampler.py                    |  111 --
 ...test_integrate.py => test_ee_integrate.py} |    0
 test/{test_keister.py => test_ee_keister.py}  |    0
 ...st_pi_problem.py => test_ee_pi_problem.py} |    0
 test/test_fast_transform_fallbacks.py         |   46 -
 test/test_financial_option_quick.py           |   94 --
 test/test_flatten_qmcpy_imports.py            |  330 ----
 test/test_ft_fast_transform_fallbacks.py      |   52 +
 test/test_ig_financial_option_quick.py        |  102 ++
 ...st_integrands.py => test_ig_integrands.py} |    0
 test/{test_option.py => test_ig_option.py}    |    0
 ...test_option_ml.py => test_ig_option_ml.py} |    0
 test/test_install_mpmc_pyg.py                 |   85 -
 test/{test_kernels.py => test_kn_kernels.py}  |    0
 test/test_mpmc_optional_imports.py            |  100 --
 test/test_plot_and_stop.py                    |  155 --
 test/test_product_measure.py                  |  277 ----
 ...ate_data.py => test_sc_accumulate_data.py} |    0
 ...ubbayes_vec.py => test_sc_cubbayes_vec.py} |    0
 ...iteria.py => test_sc_stopping_criteria.py} |    0
 test/test_scipy_wrapper_custom.py             |  302 ----
 test/test_sr_check_links.py                   |  198 +++
 test/test_sr_check_removed_urls.py            |  165 ++
 test/test_sr_flatten_qmcpy_imports.py         |  351 +++++
 test/test_sr_install_mpmc_pyg.py              |   92 ++
 test/test_sr_mpmc_optional_imports.py         |  114 ++
 test/test_sr_unwrap_markdown.py               |   99 ++
 test/test_tm_copulas.py                       | 1271 +++++++++++++++
 test/test_tm_product_measure.py               |  271 ++++
 test/test_tm_scipy_wrapper_custom.py          |  292 ++++
 ...e_measures.py => test_tm_true_measures.py} |    0
 test/test_unwrap_markdown.py                  |   89 --
 test/test_ut_plot_and_stop.py                 |  167 ++
 test/{test_util.py => test_ut_util.py}        |    0
 50 files changed, 3556 insertions(+), 3303 deletions(-)
 delete mode 100644 qmcpy/accumulate_data/__init__.py
 create mode 100755 scripts/check_test_style.py
 delete mode 100644 test/test_check_links.py
 delete mode 100644 test/test_check_removed_urls.py
 delete mode 100644 test/test_copulas.py
 rename test/{test_discrete_distribs.py => test_dd_discrete_distribs.py} (100%)
 create mode 100644 test/test_dd_dummy_sampler.py
 delete mode 100644 test/test_dummy_sampler.py
 rename test/{test_integrate.py => test_ee_integrate.py} (100%)
 rename test/{test_keister.py => test_ee_keister.py} (100%)
 rename test/{test_pi_problem.py => test_ee_pi_problem.py} (100%)
 delete mode 100644 test/test_fast_transform_fallbacks.py
 delete mode 100644 test/test_financial_option_quick.py
 delete mode 100644 test/test_flatten_qmcpy_imports.py
 create mode 100644 test/test_ft_fast_transform_fallbacks.py
 create mode 100644 test/test_ig_financial_option_quick.py
 rename test/{test_integrands.py => test_ig_integrands.py} (100%)
 rename test/{test_option.py => test_ig_option.py} (100%)
 rename test/{test_option_ml.py => test_ig_option_ml.py} (100%)
 delete mode 100644 test/test_install_mpmc_pyg.py
 rename test/{test_kernels.py => test_kn_kernels.py} (100%)
 delete mode 100644 test/test_mpmc_optional_imports.py
 delete mode 100644 test/test_plot_and_stop.py
 delete mode 100644 test/test_product_measure.py
 rename test/{test_accumulate_data.py => test_sc_accumulate_data.py} (100%)
 rename test/{test_cubbayes_vec.py => test_sc_cubbayes_vec.py} (100%)
 rename test/{test_stopping_criteria.py => test_sc_stopping_criteria.py} (100%)
 delete mode 100644 test/test_scipy_wrapper_custom.py
 create mode 100644 test/test_sr_check_links.py
 create mode 100644 test/test_sr_check_removed_urls.py
 create mode 100644 test/test_sr_flatten_qmcpy_imports.py
 create mode 100644 test/test_sr_install_mpmc_pyg.py
 create mode 100644 test/test_sr_mpmc_optional_imports.py
 create mode 100644 test/test_sr_unwrap_markdown.py
 create mode 100644 test/test_tm_copulas.py
 create mode 100644 test/test_tm_product_measure.py
 create mode 100644 test/test_tm_scipy_wrapper_custom.py
 rename test/{test_true_measures.py => test_tm_true_measures.py} (100%)
 delete mode 100644 test/test_unwrap_markdown.py
 create mode 100644 test/test_ut_plot_and_stop.py
 rename test/{test_util.py => test_ut_util.py} (100%)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index a4dc7a59a..63feb062a 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -60,10 +60,7 @@ While `dev` contains the most complete set of install dependencies, a number of
 pip install -e ".[dev]"
 ~~~
 
-The `dev` extra includes QMCPy's PyPI-hosted MPMC dependencies. MPMC additionally
-requires a platform-specific `pyg_lib` wheel that is not available from PyPI.
-After installing `dev`, let the QMCPy installer select the wheel page matching
-the installed PyTorch build:
+The `dev` extra includes QMCPy's PyPI-hosted MPMC dependencies. MPMC additionally requires a platform-specific `pyg_lib` wheel that is not available from PyPI. After installing `dev`, let the QMCPy installer select the wheel page matching the installed PyTorch build:
 
 ~~~bash
 qmcpy-install-mpmc
@@ -145,6 +142,10 @@ make tests
 
 Please see the targets in the makefile for more granular control over tests.
 
+### Test file layout
+
+Unit tests live flat in `test/`, named `test_<area>_<topic>.py` where `<area>` is a short code for the `qmcpy` subpackage under test (`tm` true_measure, `dd` discrete_distribution, `sc` stopping_criterion, `ig` integrand, ...) or a cross-cutting bucket (`ee`, `sr`). So `pytest test/ -k test_tm_` runs every true-measure test. New files should also be written as a `unittest.TestCase` subclass rather than bare `def test_*` functions. `make check_test_style` lists any file that breaks either convention (informational; also runs inside `make format`; `STRICT=--strict` makes it fail). The full area table is in [`test/README.md`](test/README.md#test-file-organization).
+
 ## Documentation
 
 ### Ensure `pyreverse` Is On Your PATH
diff --git a/docs/api/discrete_distributions.md b/docs/api/discrete_distributions.md
index daa782cb6..49b60fbb4 100644
--- a/docs/api/discrete_distributions.md
+++ b/docs/api/discrete_distributions.md
@@ -70,10 +70,7 @@ python -m pip install "qmcpy[mpmc]"
 qmcpy-install-mpmc
 ```
 
-The second command selects the `pyg_lib` wheel page matching the installed
-PyTorch and accelerator builds. For GPU support or platform-specific wheels,
-see the [PyTorch installation guide](https://pytorch.org/get-started/locally/)
-and the [PyTorch Geometric installation guide](https://pytorch-geometric.readthedocs.io/en/latest/install/installation.html).
+The second command selects the `pyg_lib` wheel page matching the installed PyTorch and accelerator builds. For GPU support or platform-specific wheels, see the [PyTorch installation guide](https://pytorch.org/get-started/locally/) and the [PyTorch Geometric installation guide](https://pytorch-geometric.readthedocs.io/en/latest/install/installation.html).
 
 ::: qmcpy.discrete_distribution.mpmc.mpmc.MPMC
 
diff --git a/docs/mpmc-compatibility.md b/docs/mpmc-compatibility.md
index 92d6f1526..4e9bbf424 100644
--- a/docs/mpmc-compatibility.md
+++ b/docs/mpmc-compatibility.md
@@ -36,17 +36,14 @@ This gives one place to enforce modern MPMC compatibility without forcing the en
 
 ## Local Developer Commands
 
-Install the usual test and MPMC extras first, then add the platform-specific
-PyG runtime with QMCPy's installed helper command:
+Install the usual test and MPMC extras first, then add the platform-specific PyG runtime with QMCPy's installed helper command:
 
 ```bash
 python -m pip install -e ".[test,test_torch,test_gpytorch,test_botorch,mpmc]"
 qmcpy-install-mpmc
 ```
 
-The `mpmc` extra contains dependencies available from PyPI. The helper handles
-`pyg_lib` separately because its wheel page depends on the installed PyTorch
-version and accelerator build, which standard project metadata cannot select.
+The `mpmc` extra contains dependencies available from PyPI. The helper handles `pyg_lib` separately because its wheel page depends on the installed PyTorch version and accelerator build, which standard project metadata cannot select.
 
 Then run the MPMC-specific checks:
 
diff --git a/docs/tests.md b/docs/tests.md
index 1120146dc..73fb226be 100644
--- a/docs/tests.md
+++ b/docs/tests.md
@@ -18,6 +18,48 @@ This document describes the available test targets in the Makefile for QMCSoftwa
 | `make delcoverage` | Reset coverage tracking | Instant | Start fresh coverage analysis |
 
 
+## Test File Organization
+
+Unit tests live flat in `test/` (no subpackage subfolders). Every file is named:
+
+```
+test_<area>_<topic>.py
+```
+
+`<area>` is a short code for the `qmcpy` subpackage under test, or a cross-cutting bucket:
+
+| area | scope |
+|------|-------|
+| `dd` | `qmcpy/discrete_distribution` |
+| `ft` | `qmcpy/fast_transform` |
+| `ig` | `qmcpy/integrand` |
+| `kn` | `qmcpy/kernel` |
+| `sc` | `qmcpy/stopping_criterion` |
+| `tm` | `qmcpy/true_measure` |
+| `ut` | `qmcpy/util` |
+| `ee` | end-to-end / cross-cutting pipeline (`integrate()`, worked problems such as Keister and pi) |
+| `sr` | `scripts/` tooling, packaging, and docs checks |
+
+This keeps related tests adjacent when the directory is sorted, and lets you run one area at a time:
+
+```bash
+python -m pytest test/ -k test_tm_      # every true_measure test
+make unittests PYTEST_EXTRA_ARGS="-k test_sc_"
+```
+
+Notebook tests are separate: they live in `test/booktests/` as `tb_*.py` and are generated from `demos/` (see `test/booktests/README.md`).
+
+### Conventions checked by `make check_test_style`
+
+1. **Area prefix** — the filename must start with a recognized `test_<area>_` prefix from the table above.
+2. **Object class** — write a test file as one or more `unittest.TestCase` subclasses rather than bare `def test_*` pytest functions. A class groups related assertions under a name (so `pytest -k TestCubMCG` selects them and a failure report names the group), shares construction through `setUp` / `setUpClass` / `self.addCleanup`, and runs identically under `pytest`, `python -m unittest`, and the coverage and booktest runners without depending on pytest fixtures. Most of the suite already follows this; a few legacy files still use bare functions and new files should not.
+
+`make check_test_style` lists any violation and is informational (exit 0). It also runs as part of `make format`. To make it fail instead — for a pre-commit hook or CI gate — pass `--strict`:
+
+```bash
+STRICT=--strict make check_test_style
+```
+
 ## Detailed Descriptions
 
 ## Scope
diff --git a/makefile b/makefile
index 57e4f66e6..924c0e9b5 100644
--- a/makefile
+++ b/makefile
@@ -40,6 +40,16 @@ clean_local_only_files:
 clean_coverage:
 	rm -fr artifacts/coverage/ .coverage* test/booktests/.coverage*
 
+TEST_STYLE_PATH ?= test
+# Check test/test_*.py against two suite conventions: (1) written as a
+# unittest.TestCase subclass ("object class"), not bare pytest functions;
+# (2) named test_<area>_*.py where <area> is the qmcpy subpackage under test
+# (dd ft ig kn sc tm ut) or a cross-cutting bucket (ee sr).
+# Informational by default; pass --strict to make it fail
+# (e.g. STRICT=--strict make check_test_style).
+check_test_style:
+	@$(PYTHON) scripts/check_test_style.py $(TEST_STYLE_PATH) $(STRICT)
+
 ##########################################################
 # Doctests
 ##########################################################
@@ -406,8 +416,13 @@ MARKDOWN_UNWRAP_PATH ?= $(FORMAT_PATH)
 
 format:
 	$(MAKE) flatten_qmcpy_imports
+	@echo ""
 	$(MAKE) markdown-unwrap MARKDOWN_UNWRAP_PATH="$(MARKDOWN_UNWRAP_PATH)"
+	@echo ""
 	$(MAKE) rm_trailing_whitespace FORMAT_PATH="$(FORMAT_PATH)"
+	@echo ""
+	$(MAKE) check_test_style
+	@echo ""
 
 flatten_qmcpy_imports:
 	$(PYTHON) scripts/flatten_qmcpy_imports.py
diff --git a/qmcpy/accumulate_data/__init__.py b/qmcpy/accumulate_data/__init__.py
deleted file mode 100644
index 6f913ef81..000000000
--- a/qmcpy/accumulate_data/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Accumulate data module."""
diff --git a/scripts/check_test_style.py b/scripts/check_test_style.py
new file mode 100755
index 000000000..9fdda9fa0
--- /dev/null
+++ b/scripts/check_test_style.py
@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+"""Check ``test/test_*.py`` files against two suite conventions.
+
+1. **Object class.** A test file should be written as a ``unittest.TestCase``
+   subclass, not as bare ``def test_*`` pytest functions.  The numeric-correctness
+   backbone (``test_tm_true_measures.py``, ``test_sc_stopping_criteria.py``,
+   ``test_dd_discrete_distribs.py``, ...) already follows this; newer per-measure
+   and tooling files do not.  The split is listed so it stays visible in review.
+
+2. **Area prefix.** A test file should be named ``test_<area>_<rest>.py`` where
+   ``<area>`` marks the ``qmcpy`` subpackage under test (or a cross-cutting
+   bucket).  Recognized areas:
+
+       dd    discrete_distribution    tm    true_measure
+       ft    fast_transform           ut    util
+       ig    integrand                ee    end-to-end / cross-cutting pipeline
+       kn    kernel                   sr    scripts/ tooling, packaging, docs checks
+       sc    stopping_criterion
+
+Usage:
+    python scripts/check_test_style.py [TEST_DIR] [--strict] [--quiet]
+
+TEST_DIR defaults to ``test``.  With ``--strict`` the exit code is non-zero when
+any file violates either convention (so it can gate CI); otherwise it is always
+0 and the output is informational.
+"""
+import ast
+import re
+import sys
+from pathlib import Path
+
+AREA_PREFIXES = {
+    "dd": "discrete_distribution",
+    "ft": "fast_transform",
+    "ig": "integrand",
+    "kn": "kernel",
+    "sc": "stopping_criterion",
+    "tm": "true_measure",
+    "ut": "util",
+    "ee": "end-to-end / cross-cutting pipeline",
+    "sr": "scripts/ tooling, packaging, docs checks",
+}
+AREA_RE = re.compile(r"^test_(?:" + "|".join(sorted(AREA_PREFIXES)) + r")_.+\.py$")
+
+
+def _area_ok(path):
+    """True if the filename starts with a recognized ``test_<area>_`` prefix."""
+    return bool(AREA_RE.match(path.name))
+
+
+def _subclasses_testcase(node):
+    """True if a ClassDef lists ``TestCase`` / ``unittest.TestCase`` as a base."""
+    for base in node.bases:
+        if isinstance(base, ast.Attribute) and base.attr == "TestCase":
+            return True
+        if isinstance(base, ast.Name) and base.id == "TestCase":
+            return True
+    return False
+
+
+def classify(path):
+    """Return (has_testcase_class, has_test_callables)."""
+    tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+    nodes = list(ast.walk(tree))
+    has_class = any(
+        isinstance(n, ast.ClassDef) and _subclasses_testcase(n) for n in nodes
+    )
+    has_tests = any(
+        isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))
+        and n.name.startswith("test_")
+        for n in nodes
+    )
+    return has_class, has_tests
+
+
+def main(argv):
+    strict = "--strict" in argv
+    quiet = "--quiet" in argv
+    positional = [a for a in argv if not a.startswith("-")]
+    test_dir = Path(positional[0]) if positional else Path("test")
+
+    files = sorted(test_dir.glob("test_*.py"))
+    if not files:
+        print(f"no test_*.py files under {test_dir}/", file=sys.stderr)
+        return 1
+
+    class_based, function_based, no_tests = [], [], []
+    for f in files:
+        has_class, has_tests = classify(f)
+        if has_class:
+            class_based.append(f)
+        elif has_tests:
+            function_based.append(f)
+        else:
+            no_tests.append(f)
+
+    misnamed = [f for f in files if not _area_ok(f)]
+
+    if not quiet:
+        print(f"{len(class_based)}/{len(files)} file(s) use a unittest.TestCase class")
+    if function_based:
+        print(
+            f"{len(function_based)} file(s) use bare pytest functions "
+            f"(no unittest.TestCase class):"
+        )
+        for f in function_based:
+            print(f"  {f.as_posix()}")
+    elif not quiet:
+        print("  no bare-function test files found")
+    if no_tests and not quiet:
+        print(f"{len(no_tests)} file(s) define no test_* callables:")
+        for f in no_tests:
+            print(f"  {f.as_posix()}")
+
+    if not quiet:
+        print(
+            f"{len(files) - len(misnamed)}/{len(files)} file(s) use a "
+            f"test_<area>_ prefix ({', '.join(sorted(AREA_PREFIXES))})"
+        )
+    if misnamed:
+        print(f"  {len(misnamed)} file(s) have no recognized test_<area>_ prefix:")
+        for f in misnamed:
+            print(f"  {f.as_posix()}")
+    elif not quiet:
+        print("  no misnamed test files found")
+
+    return 1 if (strict and (function_based or misnamed)) else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))
diff --git a/scripts/flatten_qmcpy_imports.py b/scripts/flatten_qmcpy_imports.py
index 033952768..f48a5cbd1 100644
--- a/scripts/flatten_qmcpy_imports.py
+++ b/scripts/flatten_qmcpy_imports.py
@@ -907,7 +907,7 @@ def main(argv: list[str] | None = None) -> int:
             file=sys.stderr,
         )
 
-    changed_files = 0
+    changed = []  # list of (display_path, import_count)
     changed_imports = 0
     for path in targets:
         original = path.read_bytes()
@@ -919,29 +919,26 @@ def main(argv: list[str] | None = None) -> int:
         if not count:
             continue
 
-        changed_files += 1
+        changed.append((_display_path(path, repository_root), count))
         changed_imports += count
         if not args.check:
             path.write_bytes(updated)
-        action = "Would update" if args.check else "Updated"
-        import_label = "import" if count == 1 else "imports"
-        print(
-            f"{action}: {_display_path(path, repository_root)} "
-            f"({count} {import_label})"
-        )
 
-    if changed_files:
-        action = "need updates" if args.check else "updated"
+    action = "would update" if args.check else "updated"
+    if changed:
+        file_label = "file" if len(changed) == 1 else "files"
         import_label = "import" if changed_imports == 1 else "imports"
-        file_label = "file" if changed_files == 1 else "files"
         print(
-            f"{changed_imports} {import_label} in "
-            f"{changed_files} {file_label} {action}."
+            f"qmcpy imports {action}: {len(changed)} {file_label}, "
+            f"{changed_imports} {import_label}:"
         )
+        for display_path, count in sorted(changed):
+            per = "import" if count == 1 else "imports"
+            print(f"  {display_path} ({count} {per})")
     else:
-        print("All eligible QMCPy imports already use the top-level package.")
+        print(f"  qmcpy imports {action}: 0 files")
 
-    return int(args.check and changed_files > 0)
+    return int(args.check and bool(changed))
 
 
 if __name__ == "__main__":
diff --git a/scripts/remove_trailing_whitespace.py b/scripts/remove_trailing_whitespace.py
index e8def8d17..bbdc65f58 100644
--- a/scripts/remove_trailing_whitespace.py
+++ b/scripts/remove_trailing_whitespace.py
@@ -125,11 +125,17 @@ def main() -> int:
     parser.add_argument("paths", nargs="+", help="tracked files or directories to process")
     args = parser.parse_args()
 
-    changed = [
-        path for path in iter_source_files(args.paths) if remove_trailing_whitespace(path, args.check)
-    ]
+    changed = sorted(
+        path for path in iter_source_files(args.paths)
+        if remove_trailing_whitespace(path, args.check)
+    )
     action = "would update" if args.check else "updated"
-    print(f"trailing whitespace {action}: {len(changed)} file(s)")
+    if changed:
+        print(f"trailing whitespace {action}: {len(changed)} file(s):")
+        for path in changed:
+            print(f"  {path}")
+    else:
+        print(f"  trailing whitespace {action}: 0 file(s)")
     return int(args.check and bool(changed))
 
 
diff --git a/scripts/unwrap_markdown.py b/scripts/unwrap_markdown.py
index 7841d8cc7..b02004c8f 100755
--- a/scripts/unwrap_markdown.py
+++ b/scripts/unwrap_markdown.py
@@ -280,23 +280,31 @@ def main() -> int:
         print("error: no .md or .ipynb files found", file=sys.stderr)
         return 2
 
-    changed_files = 0
+    changed_paths = []
     changed_cells = 0
     for path in targets:
         suffix = path.suffix.lower()
         if suffix == ".md":
-            changed = process_markdown_file(path, args.check)
-            changed_files += int(changed)
+            if process_markdown_file(path, args.check):
+                changed_paths.append(path)
         elif suffix == ".ipynb":
             changed, cell_count = process_notebook(path, args.check)
-            changed_files += int(changed)
+            if changed:
+                changed_paths.append(path)
             changed_cells += cell_count
 
     mode = "would update" if args.check else "updated"
-    print(
-        f"markdown unwrap {mode}: {changed_files} file(s), {changed_cells} markdown cell(s)",
+    summary = (
+        f"markdown unwrap {mode}: {len(changed_paths)} file(s), "
+        f"{changed_cells} markdown cell(s)"
     )
-    return 1 if args.check and changed_files else 0
+    if changed_paths:
+        print(summary + ":")
+        for path in sorted(changed_paths):
+            print(f"  {path}")
+    else:
+        print("  " + summary)
+    return 1 if args.check and changed_paths else 0
 
 
 if __name__ == "__main__":
diff --git a/test/README.md b/test/README.md
index 1120146dc..73fb226be 100644
--- a/test/README.md
+++ b/test/README.md
@@ -18,6 +18,48 @@ This document describes the available test targets in the Makefile for QMCSoftwa
 | `make delcoverage` | Reset coverage tracking | Instant | Start fresh coverage analysis |
 
 
+## Test File Organization
+
+Unit tests live flat in `test/` (no subpackage subfolders). Every file is named:
+
+```
+test_<area>_<topic>.py
+```
+
+`<area>` is a short code for the `qmcpy` subpackage under test, or a cross-cutting bucket:
+
+| area | scope |
+|------|-------|
+| `dd` | `qmcpy/discrete_distribution` |
+| `ft` | `qmcpy/fast_transform` |
+| `ig` | `qmcpy/integrand` |
+| `kn` | `qmcpy/kernel` |
+| `sc` | `qmcpy/stopping_criterion` |
+| `tm` | `qmcpy/true_measure` |
+| `ut` | `qmcpy/util` |
+| `ee` | end-to-end / cross-cutting pipeline (`integrate()`, worked problems such as Keister and pi) |
+| `sr` | `scripts/` tooling, packaging, and docs checks |
+
+This keeps related tests adjacent when the directory is sorted, and lets you run one area at a time:
+
+```bash
+python -m pytest test/ -k test_tm_      # every true_measure test
+make unittests PYTEST_EXTRA_ARGS="-k test_sc_"
+```
+
+Notebook tests are separate: they live in `test/booktests/` as `tb_*.py` and are generated from `demos/` (see `test/booktests/README.md`).
+
+### Conventions checked by `make check_test_style`
+
+1. **Area prefix** — the filename must start with a recognized `test_<area>_` prefix from the table above.
+2. **Object class** — write a test file as one or more `unittest.TestCase` subclasses rather than bare `def test_*` pytest functions. A class groups related assertions under a name (so `pytest -k TestCubMCG` selects them and a failure report names the group), shares construction through `setUp` / `setUpClass` / `self.addCleanup`, and runs identically under `pytest`, `python -m unittest`, and the coverage and booktest runners without depending on pytest fixtures. Most of the suite already follows this; a few legacy files still use bare functions and new files should not.
+
+`make check_test_style` lists any violation and is informational (exit 0). It also runs as part of `make format`. To make it fail instead — for a pre-commit hook or CI gate — pass `--strict`:
+
+```bash
+STRICT=--strict make check_test_style
+```
+
 ## Detailed Descriptions
 
 ## Scope
diff --git a/test/test_check_links.py b/test/test_check_links.py
deleted file mode 100644
index 6a2b3dc52..000000000
--- a/test/test_check_links.py
+++ /dev/null
@@ -1,178 +0,0 @@
-import ssl
-import sys
-import urllib.error
-from unittest.mock import patch
-
-from scripts import check_links
-
-
-def _http_error(url, code):
-    return urllib.error.HTTPError(url, code, "test response", {}, None)
-
-
-def test_head_success_is_reachable():
-    with patch.object(check_links.urllib.request, "urlopen", return_value=object()) as urlopen:
-        assert check_links._check_one("https://example.test", timeout=1) is None
-
-    assert urlopen.call_count == 1
-    assert urlopen.call_args.args[0].get_method() == "HEAD"
-
-
-def test_get_success_after_head_failure_is_reachable():
-    url = "https://example.test"
-    with patch.object(
-        check_links.urllib.request,
-        "urlopen",
-        side_effect=[_http_error(url, 405), object()],
-    ) as urlopen:
-        assert check_links._check_one(url, timeout=1) is None
-
-    assert urlopen.call_count == 2
-    assert urlopen.call_args_list[1].args[0].get_method() == "GET"
-
-
-def test_not_found_and_gone_gets_are_broken():
-    for code in (404, 410):
-        url = f"https://example.test/{code}"
-        with patch.object(
-            check_links.urllib.request,
-            "urlopen",
-            side_effect=[_http_error(url, code), _http_error(url, code)],
-        ):
-            assert check_links._check_one(url, timeout=1) == (
-                "broken",
-                f"{url} -- HTTP {code}",
-            )
-
-
-def test_bot_block_and_rate_limit_are_warnings():
-    for code in (403, 429):
-        url = f"https://example.test/{code}"
-        with patch.object(
-            check_links.urllib.request,
-            "urlopen",
-            side_effect=[_http_error(url, code), _http_error(url, code)],
-        ):
-            severity, message = check_links._check_one(url, timeout=1)
-
-        assert severity == "warning"
-        assert f"HTTP {code}" in message
-
-
-def test_tls_and_timeout_failures_are_warnings():
-    failures = (
-        ssl.SSLCertVerificationError("certificate verify failed"),
-        TimeoutError("timed out"),
-    )
-    for failure in failures:
-        with patch.object(
-            check_links.urllib.request,
-            "urlopen",
-            side_effect=[failure, failure],
-        ):
-            severity, message = check_links._check_one(
-                "https://example.test", timeout=1
-            )
-
-        assert severity == "warning"
-        assert str(failure) in message
-
-
-def test_external_results_are_separated_and_duplicate_urls_checked_once(tmp_path):
-    (tmp_path / "page.html").write_text(
-        '<a href="https://example.test/missing">missing</a>'
-        '<a href="https://example.test/missing">duplicate</a>'
-        '<a href="https://example.test/blocked">blocked</a>',
-        encoding="utf-8",
-    )
-
-    def result_for(url, _timeout):
-        if url.endswith("/missing"):
-            return "broken", f"{url} -- HTTP 404"
-        return "warning", f"{url} -- HTTP 403"
-
-    with patch.object(check_links, "_check_one", side_effect=result_for) as check_one:
-        broken, warnings = check_links.check_external(tmp_path, workers=1)
-
-    assert check_one.call_count == 2
-    assert broken == [
-        "https://example.test/missing -- HTTP 404 (seen on page.html)"
-    ]
-    assert warnings == [
-        "https://example.test/blocked -- HTTP 403 (seen on page.html)"
-    ]
-
-
-def test_internal_links_strip_site_url_deployment_path(tmp_path):
-    target = tmp_path / "target"
-    target.mkdir()
-    (target / "index.html").write_text(
-        '<h2 id="section">Target</h2>', encoding="utf-8"
-    )
-    (tmp_path / "index.html").write_text(
-        '<a href="/QMCSoftware/target/">root-relative</a>'
-        '<a href="https://qmcsoftware.github.io/QMCSoftware/target/#section">absolute</a>',
-        encoding="utf-8",
-    )
-
-    assert (
-        check_links.check_internal(
-            tmp_path, site_url="https://qmcsoftware.github.io/QMCSoftware/"
-        )
-        == []
-    )
-
-
-def test_external_check_skips_same_site_urls(tmp_path):
-    (tmp_path / "page.html").write_text(
-        '<a href="https://qmcsoftware.github.io/QMCSoftware/target/">same</a>'
-        '<a href="https://example.test/target/">external</a>',
-        encoding="utf-8",
-    )
-
-    with patch.object(check_links, "_check_one", return_value=None) as check_one:
-        broken, warnings = check_links.check_external(
-            tmp_path,
-            workers=1,
-            site_url="https://qmcsoftware.github.io/QMCSoftware/",
-        )
-
-    assert broken == []
-    assert warnings == []
-    assert check_one.call_count == 1
-    assert check_one.call_args.args[0] == "https://example.test/target/"
-
-
-def test_external_warnings_do_not_make_main_fail(tmp_path, monkeypatch, capsys):
-    monkeypatch.setattr(sys, "argv", ["check_links.py", str(tmp_path), "--external"])
-    monkeypatch.setattr(
-        check_links, "check_internal", lambda _site_dir, site_url=None: []
-    )
-    monkeypatch.setattr(
-        check_links,
-        "check_external",
-        lambda _site_dir, site_url=None: (
-            [],
-            ["https://example.test -- HTTP 403"],
-        ),
-    )
-
-    assert check_links.main() == 0
-    assert "0 broken link(s), 1 warning(s)" in capsys.readouterr().out
-
-
-def test_confirmed_external_breakage_makes_main_fail(tmp_path, monkeypatch):
-    monkeypatch.setattr(sys, "argv", ["check_links.py", str(tmp_path), "--external"])
-    monkeypatch.setattr(
-        check_links, "check_internal", lambda _site_dir, site_url=None: []
-    )
-    monkeypatch.setattr(
-        check_links,
-        "check_external",
-        lambda _site_dir, site_url=None: (
-            ["https://example.test -- HTTP 404"],
-            [],
-        ),
-    )
-
-    assert check_links.main() == 1
diff --git a/test/test_check_removed_urls.py b/test/test_check_removed_urls.py
deleted file mode 100644
index 9374e34ad..000000000
--- a/test/test_check_removed_urls.py
+++ /dev/null
@@ -1,134 +0,0 @@
-import sys
-import urllib.error
-from unittest.mock import patch
-
-from scripts import check_removed_urls as cru
-
-SITE = "https://qmcsoftware.github.io/QMCSoftware/"
-
-
-def _sitemap(*paths):
-    locs = "".join(f"<loc>{SITE}{path}</loc>" for path in paths)
-    return f'<?xml version="1.0" encoding="UTF-8"?><urlset>{locs}</urlset>'
-
-
-def _config(redirect_maps=None):
-    plugins = ["material/search", {"mkdocs-jupyter": {"execute": False}}]
-    if redirect_maps is not None:
-        plugins.append({"redirects": {"redirect_maps": redirect_maps}})
-    return {"site_url": SITE, "plugins": plugins}
-
-
-def _run(tmp_path, monkeypatch, sitemap_paths, redirect_maps=None, extra_argv=()):
-    """Run main() offline against a temp sitemap and a temp docs/ tree."""
-    docs = tmp_path / "docs"
-    docs.mkdir(parents=True)
-    (docs / "README.md").write_text("home", encoding="utf-8")
-    (docs / "good_practices.md").write_text("page", encoding="utf-8")
-    sitemap = tmp_path / "sitemap.xml"
-    sitemap.write_text(_sitemap(*sitemap_paths), encoding="utf-8")
-
-    monkeypatch.setattr(cru, "read_config", lambda *a, **k: _config(redirect_maps))
-    monkeypatch.setattr(sys, "argv", [
-        "check_removed_urls.py", "--sitemap", str(sitemap), "--docs-dir", str(docs),
-        *extra_argv,
-    ])
-    return cru.main()
-
-
-def test_url_path_and_source_round_trip(tmp_path):
-    for source, url_path in [("blogs/scipywrapper/index.md", "blogs/scipywrapper/"),
-                             ("good_practices.md", "good_practices/"),
-                             ("demos/quickstart.ipynb", "demos/quickstart/"),
-                             ("index.md", ""), ("README.md", "")]:
-        assert cru.url_path_for_source(source) == url_path
-
-    for source in ("README.md", "good_practices.md", "demos/quickstart.ipynb",
-                   "api/index.md"):
-        path = tmp_path / source
-        path.parent.mkdir(parents=True, exist_ok=True)
-        path.write_text("page", encoding="utf-8")
-        assert cru.source_exists(cru.url_path_for_source(source), tmp_path)
-    assert not cru.source_exists("blogs/scipywrapper/", tmp_path)
-
-
-def test_redirect_maps_reads_the_plugin_and_tolerates_its_absence():
-    entry = {"blogs/x/index.md": "https://qmcsoftware.org/blogs/x/"}
-    assert cru.redirect_maps(_config(entry)) == entry
-    assert cru.redirect_maps(_config()) == {}
-    assert cru.redirect_maps({}) == {}
-
-
-def test_published_paths_separates_foreign_urls():
-    sitemap = _sitemap("", "good_practices/").replace(
-        "</urlset>", "<loc>https://example.test/other/</loc></urlset>")
-
-    assert cru.published_paths(sitemap, SITE) == (
-        ["", "good_practices/"], ["https://example.test/other/"])
-
-
-def test_http_status_falls_back_to_get_when_head_is_unsupported():
-    url = "https://example.test"
-    error = urllib.error.HTTPError(url, 405, "test response", {}, None)
-    response = type("Response", (), {"status": 200, "__enter__": lambda s: s,
-                                     "__exit__": lambda s, *a: False})()
-    with patch.object(cru.urllib.request, "urlopen",
-                      side_effect=[error, response]) as urlopen:
-        assert cru.http_status(url, timeout=1) == "200"
-
-    assert urlopen.call_count == 2
-    assert urlopen.call_args_list[1].args[0].get_method() == "GET"
-
-
-def test_removed_page_without_redirect_is_flagged(tmp_path, monkeypatch, capsys):
-    code = _run(tmp_path, monkeypatch, ["", "good_practices/", "blogs/scipywrapper/"])
-    out = capsys.readouterr().out
-
-    assert code == 1
-    assert "1 removed with no redirect" in out
-    assert f"[ORPHAN]   {SITE}blogs/scipywrapper/" in out
-    assert "blogs/scipywrapper/index.md: <new URL or page>" in out
-
-
-def test_removed_page_covered_by_a_redirect_passes(tmp_path, monkeypatch, capsys):
-    code = _run(
-        tmp_path, monkeypatch, ["", "good_practices/", "blogs/scipywrapper/"],
-        redirect_maps={
-            "blogs/scipywrapper/index.md": "https://qmcsoftware.org/blogs/scipywrapper/"},
-    )
-    out = capsys.readouterr().out
-
-    assert code == 0
-    assert "0 removed with no redirect" in out
-    assert "[redirect]" in out and "[ORPHAN]" not in out
-
-
-def test_intact_site_passes(tmp_path, monkeypatch, capsys):
-    assert _run(tmp_path, monkeypatch, ["", "good_practices/"]) == 0
-    assert "2 still have a page source" in capsys.readouterr().out
-
-
-def test_verify_redirects_follows_the_target_status(tmp_path, monkeypatch, capsys):
-    redirects = {"blogs/x/index.md": "https://qmcsoftware.org/blogs/x/"}
-    for status, expected_code in [("200", 0), ("404", 1)]:
-        monkeypatch.setattr(cru, "http_status", lambda *a, **k: status)
-        code = _run(tmp_path / status, monkeypatch, ["", "blogs/x/"],
-                    redirect_maps=redirects, extra_argv=("--verify-redirects",))
-        out = capsys.readouterr().out
-
-        assert code == expected_code
-        assert status in out
-        # The URL itself is covered, so a failure is the target, not an orphan.
-        assert "[ORPHAN]" not in out
-
-
-def test_unreachable_sitemap_fails_unless_offline_is_allowed(tmp_path, monkeypatch, capsys):
-    monkeypatch.setattr(cru, "read_config", lambda *a, **k: _config())
-    argv = ["check_removed_urls.py", "--sitemap", str(tmp_path / "absent.xml")]
-
-    monkeypatch.setattr(sys, "argv", argv)
-    assert cru.main() == 1
-
-    monkeypatch.setattr(sys, "argv", argv + ["--allow-offline"])
-    assert cru.main() == 0
-    assert "skipping the check" in capsys.readouterr().out
diff --git a/test/test_copulas.py b/test/test_copulas.py
deleted file mode 100644
index 2f4bd06ba..000000000
--- a/test/test_copulas.py
+++ /dev/null
@@ -1,1362 +0,0 @@
-import warnings
-
-import numpy as np
-import pytest
-import scipy.stats as stats
-
-from qmcpy import (
-    AbstractCopula,
-    ClaytonCopula,
-    DigitalNetB2,
-    FrankCopula,
-    GaussianCopula,
-    GumbelCopula,
-    StudentTCopula,
-)
-
-from qmcpy.true_measure.copula import (
-    AbstractCopula as ModuleAbstractCopula,
-    _apply_marginal_ppfs,
-    _build_marginal_range,
-    _clip_unit_interval,
-    _marginal_cdfs_and_logpdf,
-    _validate_correlation_matrix,
-    _validate_dimension,
-    _validate_marginals,
-)
-
-from qmcpy.util import DimensionError, MethodImplementationError, ParameterError
-
-
-class PPFOnlyMarginal:
-    def ppf(self, u):
-        return np.asarray(u, dtype=float)
-
-
-class NonCallablePPFMarginal:
-    ppf = 1.0
-
-
-class UnitPDFMarginal:
-    def ppf(self, u):
-        return np.asarray(u, dtype=float)
-
-    def cdf(self, x):
-        return np.asarray(x, dtype=float)
-
-    def pdf(self, x):
-        return np.ones_like(np.asarray(x, dtype=float))
-
-
-class CDFOnlyMarginal(PPFOnlyMarginal):
-    def cdf(self, x):
-        return np.asarray(x, dtype=float)
-
-
-class BadIntervalMarginal(PPFOnlyMarginal):
-    def interval(self, confidence):
-        raise ValueError("interval unavailable")
-
-
-class BadRangeMarginal:
-    def ppf(self, u):
-        raise ValueError("ppf unavailable")
-
-
-def _equicorrelation(d, rho):
-    corr = np.full((d, d), rho, dtype=float)
-    np.fill_diagonal(corr, 1.0)
-    return corr
-
-
-def _make_copula(copula_cls, dimension=2, marginals=None, correlation=None, seed=7):
-    if marginals is None:
-        marginals = [stats.norm()] * dimension
-    if correlation is None:
-        correlation = np.eye(dimension)
-
-    kwargs = {}
-    if copula_cls is StudentTCopula:
-        kwargs["df"] = 4
-    if copula_cls is ClaytonCopula:
-        kwargs["theta"] = 2.0
-    if copula_cls is FrankCopula:
-        kwargs["theta"] = 5.0
-    if copula_cls is GumbelCopula:
-        kwargs["theta"] = 2.0
-
-    common = {
-        "sampler": DigitalNetB2(dimension, seed=seed),
-        "marginals": marginals,
-        **kwargs,
-    }
-    if copula_cls in [ClaytonCopula, FrankCopula, GumbelCopula]:
-        return copula_cls(**common)
-    return copula_cls(correlation=correlation, **common)
-
-
-# Base AbstractCopula and helper tests
-
-
-def test_abstract_copula_is_importable_from_public_module_path():
-    assert ModuleAbstractCopula is AbstractCopula
-
-
-def test_public_api_imports_and_normal_usage():
-    for copula_cls in [
-        GaussianCopula,
-        StudentTCopula,
-        ClaytonCopula,
-        FrankCopula,
-        GumbelCopula,
-    ]:
-        assert issubclass(copula_cls, AbstractCopula)
-
-        tm = _make_copula(copula_cls)
-        x = tm(8)
-        x_gen = tm.gen_samples(8)
-        v = tm.gen_copula_samples(8)
-
-        assert x.shape == (8, 2)
-        assert x_gen.shape == (8, 2)
-        assert v.shape == (8, 2)
-        assert np.all(np.isfinite(x))
-        assert np.all(np.isfinite(x_gen))
-        assert np.all((0 <= v) & (v <= 1))
-
-
-def test_abstract_copula_rejects_unimplemented_transform():
-    tm = AbstractCopula(
-        DigitalNetB2(2, seed=101),
-        marginals=[stats.uniform(), stats.uniform()],
-    )
-
-    with pytest.raises(MethodImplementationError):
-        tm.copula_transform(np.full((3, 2), 0.5))
-
-
-def test_abstract_copula_rejects_invalid_sampler():
-    with pytest.raises(ParameterError, match="sampler"):
-        AbstractCopula(object(), marginals=[stats.uniform()])
-
-
-def test_validate_marginals_error_branches():
-    with pytest.raises(ParameterError, match="marginals"):
-        _validate_marginals(None)
-
-    with pytest.raises(ParameterError, match="at least one"):
-        _validate_marginals([])
-
-    with pytest.raises(ParameterError, match="ppf"):
-        _validate_marginals([NonCallablePPFMarginal()])
-
-
-def test_validate_dimension_error_branches():
-    with pytest.raises(DimensionError, match="integer dimension"):
-        _validate_dimension(object(), [stats.uniform()])
-
-    with pytest.raises(DimensionError, match="marginals"):
-        _validate_dimension(3, [stats.uniform(), stats.uniform()])
-
-
-def test_apply_marginal_ppfs_clips_endpoints_and_checks_dimension():
-    transformed = _apply_marginal_ppfs(
-        np.array([[0.0, 1.0], [1.0, 0.0]]),
-        [stats.norm(), stats.norm()],
-    )
-
-    assert transformed.shape == (2, 2)
-    assert np.all(np.isfinite(transformed))
-
-    with pytest.raises(DimensionError, match="marginals"):
-        _apply_marginal_ppfs(np.full((2, 3), 0.5), [stats.uniform(), stats.uniform()])
-
-
-def test_marginal_range_falls_back_when_interval_or_ppf_fails():
-    ranges = _build_marginal_range([BadIntervalMarginal(), BadRangeMarginal()])
-
-    assert ranges.shape == (2, 2)
-    assert np.all(np.isfinite(ranges[0]))
-    np.testing.assert_allclose(ranges[1], [-np.inf, np.inf])
-
-
-def test_marginal_cdfs_and_logpdf_pdf_branch_and_errors():
-    x = np.array([[0.25, 0.75], [0.4, 0.6]])
-    u, log_density = _marginal_cdfs_and_logpdf(
-        x,
-        [UnitPDFMarginal(), UnitPDFMarginal()],
-    )
-
-    np.testing.assert_allclose(u, x)
-    np.testing.assert_allclose(log_density, np.zeros(2))
-
-    with pytest.raises(ParameterError, match="cdf"):
-        _marginal_cdfs_and_logpdf(x, [PPFOnlyMarginal(), UnitPDFMarginal()])
-
-    with pytest.raises(ParameterError, match="pdf"):
-        _marginal_cdfs_and_logpdf(x, [CDFOnlyMarginal(), UnitPDFMarginal()])
-
-
-def test_validate_correlation_matrix_rejects_nonfinite_values():
-    with pytest.raises(ValueError, match="finite"):
-        _validate_correlation_matrix([[1.0, np.nan], [np.nan, 1.0]], 2)
-
-
-def test_clip_unit_interval_uses_machine_epsilon():
-    clipped = _clip_unit_interval(np.array([0.0, 0.5, 1.0]))
-    eps = np.finfo(float).eps
-
-    np.testing.assert_allclose(clipped, [eps, 0.5, 1.0 - eps])
-
-
-@pytest.mark.parametrize(
-    "copula_cls",
-    [GaussianCopula, StudentTCopula, ClaytonCopula, GumbelCopula, FrankCopula],
-)
-def test_copula_transform_outputs_dependent_uniforms_in_unit_cube(copula_cls):
-    tm = _make_copula(copula_cls, dimension=3)
-    u = np.array(
-        [
-            [0.1, 0.3, 0.7],
-            [0.5, 0.5, 0.5],
-            [0.9, 0.8, 0.2],
-        ]
-    )
-
-    v = tm.copula_transform(u)
-
-    assert v.shape == u.shape
-    assert np.all(np.isfinite(v))
-    assert np.all((0.0 <= v) & (v <= 1.0))
-
-
-@pytest.mark.parametrize(
-    "copula_cls,dimension",
-    [
-        (GaussianCopula, 3),
-        (StudentTCopula, 3),
-        (ClaytonCopula, 3),
-        (FrankCopula, 3),
-        (GumbelCopula, 3),
-    ],
-)
-def test_copula_sample_shapes_are_preserved(copula_cls, dimension):
-    tm = _make_copula(copula_cls, dimension=dimension, seed=9)
-
-    one = tm(1)
-    many = tm(8)
-    batched_transform = tm._transform(np.full((2, 3, dimension), 0.5))
-
-    assert one.shape == (1, dimension)
-    assert many.shape == (8, dimension)
-    assert batched_transform.shape == (2, 3, dimension)
-    assert np.all(np.isfinite(one))
-    assert np.all(np.isfinite(many))
-    assert np.all(np.isfinite(batched_transform))
-
-
-# Elliptical copulas
-
-
-def test_output_shape_with_nonnormal_marginals():
-    tm = GaussianCopula(
-        sampler=DigitalNetB2(2, seed=7),
-        marginals=[stats.beta(a=2, b=5), stats.gamma(a=3, scale=2)],
-        correlation=[[1.0, 0.4], [0.4, 1.0]],
-    )
-
-    x = tm(16)
-
-    assert x.shape == (16, 2)
-
-
-def test_finite_output_for_normal_marginals():
-    tm = GaussianCopula(
-        sampler=DigitalNetB2(2, seed=11),
-        marginals=[stats.norm(), stats.norm(loc=1.0, scale=2.0)],
-        correlation=[[1.0, -0.3], [-0.3, 1.0]],
-    )
-
-    x = tm(128)
-
-    assert np.all(np.isfinite(x))
-
-
-def test_return_weights_shape_when_marginal_densities_available():
-    tm = GaussianCopula(
-        sampler=DigitalNetB2(2, seed=12),
-        marginals=[stats.norm(), stats.gamma(a=2.0)],
-        correlation=[[1.0, 0.25], [0.25, 1.0]],
-    )
-
-    x, weights = tm(32, return_weights=True)
-
-    assert x.shape == (32, 2)
-    assert weights.shape == (32,)
-    assert np.all(np.isfinite(weights))
-    assert np.all(weights > 0.0)
-
-
-def test_identity_correlation_matches_independent_marginal_transforms():
-    marginals = [stats.norm(loc=-1.0, scale=2.0), stats.gamma(a=2.0, scale=3.0)]
-    tm = GaussianCopula(
-        sampler=DigitalNetB2(2, seed=13),
-        marginals=marginals,
-        correlation=np.eye(2),
-    )
-    u = np.array([[0.2, 0.7], [0.4, 0.8], [0.9, 0.1]])
-
-    x = tm._transform(u)
-    expected = np.column_stack(
-        [marginals[j].ppf(u[:, j]) for j in range(len(marginals))]
-    )
-
-    np.testing.assert_allclose(x, expected, rtol=1e-12, atol=1e-12)
-
-
-def test_positive_correlation_produces_positive_dependence():
-    rho = 0.75
-    tm = GaussianCopula(
-        sampler=DigitalNetB2(2, seed=17),
-        marginals=[stats.norm(), stats.norm()],
-        correlation=[[1.0, rho], [rho, 1.0]],
-    )
-
-    x = tm(4096)
-    empirical_corr = np.corrcoef(x.T)[0, 1]
-
-    assert empirical_corr > 0.5
-    assert abs(empirical_corr - rho) < 0.2
-
-
-@pytest.mark.parametrize("copula_cls", [GaussianCopula, StudentTCopula])
-@pytest.mark.parametrize("dimension", [1, 3, 5])
-def test_elliptical_copulas_support_general_dimensions(copula_cls, dimension):
-    correlation = _equicorrelation(dimension, 0.25)
-    tm = _make_copula(
-        copula_cls,
-        dimension=dimension,
-        marginals=[stats.norm()] * dimension,
-        correlation=correlation,
-        seed=19,
-    )
-
-    x = tm(16)
-    one = tm(1)
-
-    assert x.shape == (16, dimension)
-    assert one.shape == (1, dimension)
-    assert np.all(np.isfinite(x))
-    assert np.all(np.isfinite(one))
-
-
-@pytest.mark.parametrize("copula_cls", [GaussianCopula, StudentTCopula])
-def test_elliptical_copulas_handle_valid_near_singular_correlation(copula_cls):
-    dimension = 5
-    tm = _make_copula(
-        copula_cls,
-        dimension=dimension,
-        marginals=[stats.norm()] * dimension,
-        correlation=_equicorrelation(dimension, 0.999),
-        seed=20,
-    )
-
-    x = tm(32)
-
-    assert x.shape == (32, dimension)
-    assert np.all(np.isfinite(x))
-
-
-@pytest.mark.parametrize("copula_cls", [GaussianCopula, StudentTCopula])
-def test_elliptical_copulas_reject_singular_correlation(copula_cls):
-    with pytest.raises(ValueError, match="positive definite"):
-        _make_copula(
-            copula_cls,
-            dimension=3,
-            marginals=[stats.norm(), stats.norm(), stats.norm()],
-            correlation=np.ones((3, 3)),
-            seed=22,
-        )
-
-
-@pytest.mark.parametrize(
-    "copula_cls",
-    [GaussianCopula, StudentTCopula, ClaytonCopula, FrankCopula, GumbelCopula],
-)
-def test_distribution_dimension_matches_number_of_marginals(copula_cls):
-    tm = _make_copula(
-        copula_cls,
-        dimension=5,
-        marginals=[
-            stats.norm(),
-            stats.beta(a=2, b=5),
-            stats.gamma(a=3),
-            stats.expon(),
-            stats.lognorm(s=0.5),
-        ],
-        correlation=np.eye(5),
-    )
-
-    x = tm(32)
-
-    assert x.shape == (32, 5)
-    assert np.all(np.isfinite(x))
-
-
-@pytest.mark.parametrize("copula_cls", [GaussianCopula, StudentTCopula])
-def test_invalid_dimension_mismatches_raise(copula_cls):
-    with pytest.raises(DimensionError, match="marginals"):
-        _make_copula(
-            copula_cls,
-            dimension=2,
-            marginals=[stats.norm(), stats.norm(), stats.norm()],
-            correlation=np.eye(2),
-        )
-
-    with pytest.raises(ValueError, match="shape"):
-        _make_copula(
-            copula_cls,
-            dimension=2,
-            marginals=[stats.norm(), stats.norm()],
-            correlation=np.eye(3),
-        )
-
-    with pytest.raises(ValueError, match="square"):
-        _make_copula(
-            copula_cls,
-            dimension=2,
-            marginals=[stats.norm(), stats.norm()],
-            correlation=[[1.0, 0.2, 0.3], [0.2, 1.0, 0.4]],
-        )
-
-
-@pytest.mark.parametrize("copula_cls", [ClaytonCopula, FrankCopula, GumbelCopula])
-def test_archimedean_dimension_mismatch_raises_dimension_error(copula_cls):
-    with pytest.raises(DimensionError, match="marginals"):
-        _make_copula(
-            copula_cls,
-            dimension=2,
-            marginals=[stats.norm(), stats.norm(), stats.norm()],
-        )
-
-
-@pytest.mark.parametrize(
-    "copula_cls",
-    [GaussianCopula, StudentTCopula],
-)
-@pytest.mark.parametrize(
-    "correlation",
-    [
-        [[1.0, 0.2], [0.3, 1.0]],
-        [[1.0, 0.2], [0.2, 0.9]],
-        [[1.0, 1.2], [1.2, 1.0]],
-    ],
-)
-def test_invalid_correlation_matrices_raise_value_error(copula_cls, correlation):
-    with pytest.raises(ValueError):
-        _make_copula(
-            copula_cls,
-            dimension=2,
-            marginals=[stats.norm(), stats.norm()],
-            correlation=correlation,
-        )
-
-
-def test_marginal_length_mismatch_raises_dimension_error():
-    with pytest.raises(DimensionError, match="marginals"):
-        GaussianCopula(
-            sampler=DigitalNetB2(2, seed=21),
-            marginals=[stats.norm()],
-            correlation=np.eye(2),
-        )
-
-
-def test_marginal_without_ppf_raises_clear_error():
-    class NoPPF:
-        pass
-
-    with pytest.raises(ParameterError, match="ppf"):
-        GaussianCopula(
-            sampler=DigitalNetB2(1, seed=23),
-            marginals=[NoPPF()],
-            correlation=[[1.0]],
-        )
-
-
-@pytest.mark.parametrize(
-    "copula_cls",
-    [GaussianCopula, StudentTCopula, ClaytonCopula, FrankCopula, GumbelCopula],
-)
-def test_common_scipy_frozen_marginals_work(copula_cls):
-    tm = _make_copula(
-        copula_cls,
-        dimension=5,
-        marginals=[
-            stats.norm(),
-            stats.beta(a=2, b=5),
-            stats.gamma(a=3),
-            stats.expon(),
-            stats.lognorm(s=0.5),
-        ],
-        correlation=np.eye(5),
-        seed=47,
-    )
-
-    x = tm(128)
-
-    assert x.shape == (128, 5)
-    assert np.all(np.isfinite(x))
-
-
-@pytest.mark.parametrize(
-    "copula_cls",
-    [GaussianCopula, StudentTCopula, ClaytonCopula, FrankCopula, GumbelCopula],
-)
-def test_endpoint_uniforms_are_clipped_to_finite_outputs(copula_cls):
-    tm = _make_copula(
-        copula_cls,
-        dimension=5,
-        marginals=[
-            stats.norm(),
-            stats.beta(a=2, b=5),
-            stats.gamma(a=3),
-            stats.expon(),
-            stats.lognorm(s=0.5),
-        ],
-        correlation=np.eye(5),
-        seed=53,
-    )
-    u = np.array(
-        [
-            [0.0, 1.0, 0.0, 1.0, 0.5],
-            [1.0, 0.0, 1.0, 0.0, 0.5],
-        ]
-    )
-
-    x = tm._transform(u)
-
-    assert x.shape == (2, 5)
-    assert np.all(np.isfinite(x))
-
-
-def test_student_t_copula_output_shape_and_finite_values():
-    tm = StudentTCopula(
-        sampler=DigitalNetB2(2, seed=29),
-        marginals=[stats.norm(), stats.gamma(a=3.0, scale=2.0)],
-        correlation=[[1.0, 0.5], [0.5, 1.0]],
-        df=4,
-    )
-
-    x = tm(128)
-
-    assert x.shape == (128, 2)
-    assert np.all(np.isfinite(x))
-
-
-def test_student_t_copula_positive_correlation_produces_positive_dependence():
-    tm = StudentTCopula(
-        sampler=DigitalNetB2(2, seed=31),
-        marginals=[stats.norm(), stats.norm()],
-        correlation=[[1.0, 0.7], [0.7, 1.0]],
-        df=5,
-    )
-
-    x = tm(4096)
-    empirical_corr = np.corrcoef(x.T)[0, 1]
-
-    assert empirical_corr > 0.45
-
-
-def test_student_t_copula_has_stronger_joint_tail_than_gaussian_copula():
-    rho = 0.7
-    df = 4
-    n = 2**12
-    marginals = [stats.norm(), stats.norm()]
-    correlation = [[1.0, rho], [rho, 1.0]]
-
-    gaussian = GaussianCopula(
-        sampler=DigitalNetB2(2, seed=101),
-        marginals=marginals,
-        correlation=correlation,
-    )
-    student_t = StudentTCopula(
-        sampler=DigitalNetB2(2, seed=101),
-        marginals=marginals,
-        correlation=correlation,
-        df=df,
-    )
-
-    x_gaussian = gaussian(n)
-    x_student_t = student_t(n)
-    threshold = stats.norm.ppf(0.99)
-
-    def joint_tail_rate(x):
-        tail_0 = x[:, 0] > threshold
-        return np.mean(x[tail_0, 1] > threshold)
-
-    gaussian_tail = joint_tail_rate(x_gaussian)
-    student_t_tail = joint_tail_rate(x_student_t)
-
-    assert student_t_tail > gaussian_tail + 0.08
-
-
-def test_student_t_copula_return_weights_shape_when_density_available():
-    tm = StudentTCopula(
-        sampler=DigitalNetB2(2, seed=37),
-        marginals=[stats.norm(), stats.gamma(a=2.0)],
-        correlation=[[1.0, 0.3], [0.3, 1.0]],
-        df=6,
-    )
-
-    x, weights = tm(32, return_weights=True)
-
-    assert x.shape == (32, 2)
-    assert weights.shape == (32,)
-    assert np.all(np.isfinite(weights))
-    assert np.all(weights > 0.0)
-
-
-@pytest.mark.parametrize("df", [1.0, 100.0])
-def test_student_t_copula_boundary_df_values_are_finite(df):
-    dimension = 3
-    tm = StudentTCopula(
-        sampler=DigitalNetB2(dimension, seed=39),
-        marginals=[stats.norm()] * dimension,
-        correlation=_equicorrelation(dimension, 0.4),
-        df=df,
-    )
-
-    x = tm(128)
-
-    assert x.shape == (128, dimension)
-    assert np.all(np.isfinite(x))
-
-
-def test_student_t_copula_large_df_is_close_to_gaussian_copula():
-    rho = 0.6
-    correlation = [[1.0, rho], [rho, 1.0]]
-    marginals = [stats.norm(), stats.norm()]
-    gaussian = GaussianCopula(
-        sampler=DigitalNetB2(2, seed=40),
-        marginals=marginals,
-        correlation=correlation,
-    )
-    student_t = StudentTCopula(
-        sampler=DigitalNetB2(2, seed=40),
-        marginals=marginals,
-        correlation=correlation,
-        df=100,
-    )
-
-    x_gaussian = gaussian(4096)
-    x_student_t = student_t(4096)
-    corr_gaussian = np.corrcoef(x_gaussian.T)[0, 1]
-    corr_student_t = np.corrcoef(x_student_t.T)[0, 1]
-
-    assert abs(corr_student_t - corr_gaussian) < 0.02
-
-
-@pytest.mark.parametrize("df", [0, -1, np.inf, "not-a-number"])
-def test_student_t_copula_invalid_df_raises_parameter_error(df):
-    with pytest.raises(ParameterError, match="df"):
-        StudentTCopula(
-            sampler=DigitalNetB2(2, seed=41),
-            marginals=[stats.norm(), stats.norm()],
-            correlation=np.eye(2),
-            df=df,
-        )
-
-
-def test_student_t_copula_marginal_without_ppf_raises_clear_error():
-    class NoPPF:
-        pass
-
-    with pytest.raises(ParameterError, match="ppf"):
-        StudentTCopula(
-            sampler=DigitalNetB2(1, seed=43),
-            marginals=[NoPPF()],
-            correlation=[[1.0]],
-            df=4,
-        )
-
-
-# Archimedean copulas
-
-
-def test_clayton_copula_output_shape_and_finite_values():
-    tm = ClaytonCopula(
-        sampler=DigitalNetB2(2, seed=57),
-        marginals=[stats.norm(), stats.gamma(a=3.0, scale=2.0)],
-        theta=2.0,
-    )
-
-    x = tm(128)
-
-    assert x.shape == (128, 2)
-    assert np.all(np.isfinite(x))
-
-
-def test_clayton_copula_return_weights_shape_when_density_available():
-    tm = ClaytonCopula(
-        sampler=DigitalNetB2(3, seed=59),
-        marginals=[stats.norm(), stats.gamma(a=2.0), stats.expon()],
-        theta=1.5,
-    )
-
-    x, weights = tm(32, return_weights=True)
-
-    assert x.shape == (32, 3)
-    assert weights.shape == (32,)
-    assert np.all(np.isfinite(weights))
-    assert np.all(weights > 0.0)
-
-
-@pytest.mark.parametrize("theta", [0, -1, np.inf, "not-a-number"])
-def test_clayton_copula_invalid_theta_raises_parameter_error(theta):
-    with pytest.raises(ParameterError, match="theta"):
-        ClaytonCopula(
-            sampler=DigitalNetB2(2, seed=61),
-            marginals=[stats.norm(), stats.norm()],
-            theta=theta,
-        )
-
-
-@pytest.mark.parametrize("dimension", [2, 3, 5])
-def test_clayton_copula_supports_general_dimension(dimension):
-    tm = ClaytonCopula(
-        sampler=DigitalNetB2(dimension, seed=63),
-        marginals=[stats.norm()] * dimension,
-        theta=2.0,
-    )
-
-    x = tm(128)
-
-    assert x.shape == (128, dimension)
-    assert np.all(np.isfinite(x))
-
-
-def test_clayton_copula_marginal_without_ppf_raises_clear_error():
-    class NoPPF:
-        pass
-
-    with pytest.raises(ParameterError, match="ppf"):
-        ClaytonCopula(
-            sampler=DigitalNetB2(2, seed=67),
-            marginals=[stats.norm(), NoPPF()],
-            theta=2.0,
-        )
-
-
-@pytest.mark.parametrize(
-    "marginals",
-    [
-        [stats.norm(), stats.beta(a=2, b=5)],
-        [stats.gamma(a=3), stats.expon()],
-        [stats.lognorm(s=0.5), stats.norm()],
-    ],
-)
-def test_clayton_copula_common_scipy_frozen_marginals_work(marginals):
-    tm = ClaytonCopula(
-        sampler=DigitalNetB2(2, seed=69),
-        marginals=marginals,
-        theta=2.0,
-    )
-
-    x = tm(128)
-
-    assert x.shape == (128, 2)
-    assert np.all(np.isfinite(x))
-
-
-def test_clayton_copula_endpoint_uniforms_are_clipped_to_finite_outputs():
-    tm = ClaytonCopula(
-        sampler=DigitalNetB2(2, seed=70),
-        marginals=[stats.norm(), stats.lognorm(s=0.5)],
-        theta=2.0,
-    )
-    u = np.array([[0.0, 1.0], [1.0, 0.0]])
-
-    x = tm._transform(u)
-
-    assert x.shape == (2, 2)
-    assert np.all(np.isfinite(x))
-
-
-@pytest.mark.parametrize("dimension", [2, 3, 5])
-def test_clayton_copula_tiny_theta_is_near_independent(dimension):
-    marginals = [stats.uniform()] * dimension
-    tm = ClaytonCopula(
-        sampler=DigitalNetB2(dimension, seed=70),
-        marginals=marginals,
-        theta=1e-8,
-    )
-    u = np.array(
-        [
-            [0.2, 0.7, 0.4, 0.6, 0.8],
-            [0.4, 0.8, 0.9, 0.3, 0.2],
-            [0.9, 0.1, 0.3, 0.7, 0.5],
-        ]
-    )[:, :dimension]
-
-    x = tm._transform(u)
-
-    assert x.shape == (3, dimension)
-    assert np.all(np.isfinite(x))
-    np.testing.assert_allclose(x, u, atol=5e-6)
-
-
-@pytest.mark.parametrize("dimension", [2, 3, 5])
-@pytest.mark.parametrize("theta", [20.0, 50.0])
-def test_clayton_copula_large_theta_is_finite(theta, dimension):
-    tm = ClaytonCopula(
-        sampler=DigitalNetB2(dimension, seed=70),
-        marginals=[stats.norm()] * dimension,
-        theta=theta,
-    )
-
-    x = tm(128)
-
-    assert x.shape == (128, dimension)
-    assert np.all(np.isfinite(x))
-
-
-def test_clayton_copula_positive_dependence_behavior():
-    tm = ClaytonCopula(
-        sampler=DigitalNetB2(2, seed=71),
-        marginals=[stats.uniform(), stats.uniform()],
-        theta=2.0,
-    )
-
-    x = tm(4096)
-    empirical_corr = np.corrcoef(x.T)[0, 1]
-
-    assert empirical_corr > 0.45
-
-
-def test_clayton_copula_has_stronger_lower_tail_than_gaussian_copula():
-    theta = 2.0
-    n = 2**12
-    marginals = [stats.uniform(), stats.uniform()]
-    # Clayton Kendall tau is theta/(theta+2); convert to Gaussian rho.
-    rho = np.sin(np.pi * (theta / (theta + 2.0)) / 2.0)
-
-    clayton = ClaytonCopula(
-        sampler=DigitalNetB2(2, seed=73),
-        marginals=marginals,
-        theta=theta,
-    )
-    gaussian = GaussianCopula(
-        sampler=DigitalNetB2(2, seed=73),
-        marginals=marginals,
-        correlation=[[1.0, rho], [rho, 1.0]],
-    )
-
-    x_clayton = clayton(n)
-    x_gaussian = gaussian(n)
-    threshold = 0.05
-
-    def lower_tail_rate(x):
-        tail_0 = x[:, 0] < threshold
-        return np.mean(x[tail_0, 1] < threshold)
-
-    clayton_tail = lower_tail_rate(x_clayton)
-    gaussian_tail = lower_tail_rate(x_gaussian)
-
-    assert clayton_tail > gaussian_tail + 0.2
-
-
-def test_frank_copula_output_shape_for_two_dimensions():
-    tm = FrankCopula(
-        sampler=DigitalNetB2(2, seed=75),
-        marginals=[stats.norm(), stats.gamma(a=3.0, scale=2.0)],
-        theta=5.0,
-    )
-
-    x = tm(128)
-
-    assert x.shape == (128, 2)
-    assert np.all(np.isfinite(x))
-
-
-@pytest.mark.parametrize("dimension", [3, 5])
-def test_frank_copula_positive_theta_supports_higher_dimensions(dimension):
-    tm = FrankCopula(
-        sampler=DigitalNetB2(dimension, seed=76),
-        marginals=[stats.norm()] * dimension,
-        theta=5.0,
-    )
-
-    x = tm(128)
-
-    assert x.shape == (128, dimension)
-    assert np.all(np.isfinite(x))
-
-
-def test_frank_copula_return_weights_shape_when_density_available():
-    tm = FrankCopula(
-        sampler=DigitalNetB2(3, seed=77),
-        marginals=[stats.norm(), stats.gamma(a=2.0), stats.expon()],
-        theta=4.0,
-    )
-
-    x, weights = tm(32, return_weights=True)
-
-    assert x.shape == (32, 3)
-    assert weights.shape == (32,)
-    assert np.all(np.isfinite(weights))
-    assert np.all(weights > 0.0)
-
-
-@pytest.mark.parametrize("theta", [0, np.inf, -np.inf, "not-a-number"])
-def test_frank_copula_invalid_theta_raises_parameter_error(theta):
-    with pytest.raises(ParameterError, match="theta"):
-        FrankCopula(
-            sampler=DigitalNetB2(2, seed=78),
-            marginals=[stats.norm(), stats.norm()],
-            theta=theta,
-        )
-
-
-def test_frank_copula_negative_theta_rejected_above_two_dimensions():
-    with pytest.raises(ParameterError, match="d=2"):
-        FrankCopula(
-            sampler=DigitalNetB2(3, seed=79),
-            marginals=[stats.norm(), stats.norm(), stats.norm()],
-            theta=-2.0,
-        )
-
-
-def test_frank_copula_dimension_mismatch_raises_dimension_error():
-    with pytest.raises(DimensionError, match="marginals"):
-        FrankCopula(
-            sampler=DigitalNetB2(2, seed=80),
-            marginals=[stats.norm(), stats.norm(), stats.norm()],
-            theta=5.0,
-        )
-
-
-def test_frank_copula_marginal_without_ppf_raises_clear_error():
-    class NoPPF:
-        pass
-
-    with pytest.raises(ParameterError, match="ppf"):
-        FrankCopula(
-            sampler=DigitalNetB2(2, seed=82),
-            marginals=[stats.norm(), NoPPF()],
-            theta=5.0,
-        )
-
-
-def test_frank_copula_positive_dependence_behavior():
-    tm = FrankCopula(
-        sampler=DigitalNetB2(2, seed=84),
-        marginals=[stats.uniform(), stats.uniform()],
-        theta=6.0,
-    )
-
-    x = tm(4096)
-    empirical_corr = np.corrcoef(x.T)[0, 1]
-
-    assert empirical_corr > 0.45
-
-
-@pytest.mark.parametrize(
-    "theta,dimension",
-    [
-        (1e-8, 3),
-        (-1e-8, 2),
-    ],
-)
-def test_frank_copula_tiny_theta_is_close_to_independence(theta, dimension):
-    marginals = [stats.uniform()] * dimension
-    tm = FrankCopula(
-        sampler=DigitalNetB2(dimension, seed=86),
-        marginals=marginals,
-        theta=theta,
-    )
-    u = np.array(
-        [
-            [0.2, 0.7, 0.4, 0.6, 0.8],
-            [0.4, 0.8, 0.9, 0.3, 0.2],
-            [0.9, 0.1, 0.3, 0.7, 0.5],
-        ]
-    )[:, :dimension]
-
-    x = tm._transform(u)
-
-    assert x.shape == (3, dimension)
-    assert np.all(np.isfinite(x))
-    np.testing.assert_allclose(x, u, atol=5e-6)
-
-
-@pytest.mark.parametrize(
-    "theta,dimension",
-    [
-        (50.0, 5),
-        (-50.0, 2),
-    ],
-)
-def test_frank_copula_large_theta_is_finite(theta, dimension):
-    tm = FrankCopula(
-        sampler=DigitalNetB2(dimension, seed=87),
-        marginals=[stats.norm()] * dimension,
-        theta=theta,
-    )
-
-    x = tm(128)
-
-    assert x.shape == (128, dimension)
-    assert np.all(np.isfinite(x))
-
-
-def test_frank_copula_negative_theta_produces_negative_dependence_in_2d():
-    tm = FrankCopula(
-        sampler=DigitalNetB2(2, seed=88),
-        marginals=[stats.uniform(), stats.uniform()],
-        theta=-6.0,
-    )
-
-    x = tm(4096)
-    empirical_corr = np.corrcoef(x.T)[0, 1]
-
-    assert empirical_corr < -0.35
-
-
-def test_gumbel_copula_output_shape_and_finite_values():
-    tm = GumbelCopula(
-        sampler=DigitalNetB2(2, seed=79),
-        marginals=[stats.norm(), stats.gamma(a=3.0, scale=2.0)],
-        theta=2.0,
-    )
-
-    x = tm(128)
-
-    assert x.shape == (128, 2)
-    assert np.all(np.isfinite(x))
-
-
-def test_gumbel_copula_return_weights_shape_when_density_available():
-    tm = GumbelCopula(
-        sampler=DigitalNetB2(3, seed=81),
-        marginals=[stats.norm(), stats.gamma(a=2.0), stats.expon()],
-        theta=1.5,
-    )
-
-    x, weights = tm(32, return_weights=True)
-
-    assert x.shape == (32, 3)
-    assert weights.shape == (32,)
-    assert np.all(np.isfinite(weights))
-    assert np.all(weights > 0.0)
-
-
-@pytest.mark.parametrize("theta", [0, 0.5, -1, np.inf, "not-a-number"])
-def test_gumbel_copula_invalid_theta_raises_parameter_error(theta):
-    with pytest.raises(ParameterError, match="theta"):
-        GumbelCopula(
-            sampler=DigitalNetB2(2, seed=83),
-            marginals=[stats.norm(), stats.norm()],
-            theta=theta,
-        )
-
-
-def test_gumbel_copula_theta_one_is_independent_marginal_transform():
-    marginals = [stats.norm(loc=-1.0, scale=2.0), stats.gamma(a=2.0, scale=3.0)]
-    tm = GumbelCopula(
-        sampler=DigitalNetB2(2, seed=85),
-        marginals=marginals,
-        theta=1.0,
-    )
-    u = np.array([[0.2, 0.7], [0.4, 0.8], [0.9, 0.1]])
-
-    x = tm._transform(u)
-    expected = np.column_stack(
-        [marginals[j].ppf(u[:, j]) for j in range(len(marginals))]
-    )
-
-    np.testing.assert_allclose(x, expected, rtol=1e-12, atol=1e-12)
-
-
-@pytest.mark.parametrize("dimension", [2, 3, 5])
-def test_gumbel_copula_theta_close_to_one_is_near_independent(dimension):
-    marginals = [stats.uniform()] * dimension
-    tm = GumbelCopula(
-        sampler=DigitalNetB2(dimension, seed=85),
-        marginals=marginals,
-        theta=1.000001,
-    )
-    u = np.array(
-        [
-            [0.2, 0.7, 0.4, 0.6, 0.8],
-            [0.4, 0.8, 0.9, 0.3, 0.2],
-            [0.9, 0.1, 0.3, 0.7, 0.5],
-        ]
-    )[:, :dimension]
-
-    x = tm._transform(u)
-
-    assert x.shape == (3, dimension)
-    assert np.all(np.isfinite(x))
-    np.testing.assert_allclose(x, u, atol=5e-5)
-
-
-@pytest.mark.parametrize("dimension", [2, 3, 5])
-@pytest.mark.parametrize("theta", [20.0, 50.0])
-def test_gumbel_copula_large_theta_is_finite(theta, dimension):
-    tm = GumbelCopula(
-        sampler=DigitalNetB2(dimension, seed=86),
-        marginals=[stats.norm()] * dimension,
-        theta=theta,
-    )
-
-    x = tm(128)
-
-    assert x.shape == (128, dimension)
-    assert np.all(np.isfinite(x))
-
-
-@pytest.mark.parametrize("dimension", [2, 3, 5])
-def test_gumbel_copula_supports_general_dimension(dimension):
-    tm = GumbelCopula(
-        sampler=DigitalNetB2(dimension, seed=87),
-        marginals=[stats.norm()] * dimension,
-        theta=2.0,
-    )
-
-    x = tm(128)
-
-    assert x.shape == (128, dimension)
-    assert np.all(np.isfinite(x))
-
-
-def test_gumbel_copula_marginal_without_ppf_raises_clear_error():
-    class NoPPF:
-        pass
-
-    with pytest.raises(ParameterError, match="ppf"):
-        GumbelCopula(
-            sampler=DigitalNetB2(2, seed=89),
-            marginals=[stats.norm(), NoPPF()],
-            theta=2.0,
-        )
-
-
-@pytest.mark.parametrize(
-    "marginals",
-    [
-        [stats.norm(), stats.beta(a=2, b=5)],
-        [stats.gamma(a=3), stats.expon()],
-        [stats.lognorm(s=0.5), stats.norm()],
-    ],
-)
-def test_gumbel_copula_common_scipy_frozen_marginals_work(marginals):
-    tm = GumbelCopula(
-        sampler=DigitalNetB2(2, seed=91),
-        marginals=marginals,
-        theta=2.0,
-    )
-
-    x = tm(128)
-
-    assert x.shape == (128, 2)
-    assert np.all(np.isfinite(x))
-
-
-def test_gumbel_copula_endpoint_uniforms_are_clipped_to_finite_outputs():
-    tm = GumbelCopula(
-        sampler=DigitalNetB2(2, seed=93),
-        marginals=[stats.norm(), stats.lognorm(s=0.5)],
-        theta=2.0,
-    )
-    u = np.array([[0.0, 1.0], [1.0, 0.0]])
-
-    x = tm._transform(u)
-
-    assert x.shape == (2, 2)
-    assert np.all(np.isfinite(x))
-
-
-def test_gumbel_copula_positive_dependence_behavior():
-    tm = GumbelCopula(
-        sampler=DigitalNetB2(2, seed=95),
-        marginals=[stats.uniform(), stats.uniform()],
-        theta=2.0,
-    )
-
-    x = tm(4096)
-    empirical_corr = np.corrcoef(x.T)[0, 1]
-
-    assert empirical_corr > 0.45
-
-
-def test_gumbel_copula_has_stronger_upper_tail_than_gaussian_copula():
-    theta = 2.0
-    n = 2**12
-    marginals = [stats.uniform(), stats.uniform()]
-    # Gumbel Kendall tau is 1 - 1/theta; convert to Gaussian rho.
-    rho = np.sin(np.pi * (1.0 - 1.0 / theta) / 2.0)
-
-    gumbel = GumbelCopula(
-        sampler=DigitalNetB2(2, seed=97),
-        marginals=marginals,
-        theta=theta,
-    )
-    gaussian = GaussianCopula(
-        sampler=DigitalNetB2(2, seed=97),
-        marginals=marginals,
-        correlation=[[1.0, rho], [rho, 1.0]],
-    )
-
-    x_gumbel = gumbel(n)
-    x_gaussian = gaussian(n)
-    threshold = 0.95
-
-    def upper_tail_rate(x):
-        tail_0 = x[:, 0] > threshold
-        return np.mean(x[tail_0, 1] > threshold)
-
-    gumbel_tail = upper_tail_rate(x_gumbel)
-    gaussian_tail = upper_tail_rate(x_gaussian)
-
-    assert gumbel_tail > gaussian_tail + 0.15
-
-
-# Weights, fallback behavior, spawn, and edge cases
-
-
-@pytest.mark.parametrize(
-    "copula_cls",
-    [GaussianCopula, StudentTCopula, ClaytonCopula, GumbelCopula, FrankCopula],
-)
-def test_copula_weight_fallback_warns_once_when_density_methods_are_missing(
-    copula_cls,
-):
-    tm = _make_copula(
-        copula_cls,
-        dimension=2,
-        marginals=[PPFOnlyMarginal(), PPFOnlyMarginal()],
-    )
-    x = np.full((4, 2), 0.5)
-    expected_message = getattr(
-        tm,
-        "_missing_weight_warning_message",
-        f"{copula_cls.__name__} marginals must implement 'cdf' and "
-        "'pdf' or 'logpdf' to compute density weights. "
-        "Weights will be treated as 1.",
-    )
-
-    assert "_unit_weight_with_warning" not in copula_cls.__dict__
-    assert (
-        tm._unit_weight_with_warning.__func__
-        is AbstractCopula._unit_weight_with_warning
-    )
-
-    with pytest.warns(UserWarning) as warning_info:
-        weights = tm._weight(x)
-
-    with warnings.catch_warnings(record=True) as caught:
-        warnings.simplefilter("always")
-        second_weights = tm._weight(x)
-
-    np.testing.assert_allclose(weights, np.ones(4))
-    np.testing.assert_allclose(second_weights, np.ones(4))
-    assert str(warning_info[0].message) == expected_message
-    assert caught == []
-
-
-def test_student_t_weight_falls_back_when_multivariate_t_is_unavailable():
-    tm = StudentTCopula(
-        DigitalNetB2(2, seed=115),
-        marginals=[stats.norm(), stats.norm()],
-        correlation=np.eye(2),
-        df=4,
-    )
-    tm._mvt_scipy = None
-
-    with pytest.warns(UserWarning, match="Weights will be treated as 1"):
-        weights = tm._weight(np.full((3, 2), 0.25))
-
-    np.testing.assert_allclose(weights, np.ones(3))
-
-
-def test_gaussian_weight_uses_pdf_branch_when_logpdf_is_unavailable():
-    tm = GaussianCopula(
-        DigitalNetB2(2, seed=117),
-        marginals=[UnitPDFMarginal(), UnitPDFMarginal()],
-        correlation=[[1.0, 0.4], [0.4, 1.0]],
-    )
-
-    weights = tm._weight(np.array([[0.25, 0.5], [0.75, 0.5]]))
-
-    assert weights.shape == (2,)
-    assert np.all(np.isfinite(weights))
-    assert np.all(weights > 0.0)
-
-
-def test_gumbel_theta_one_weight_is_independent_marginal_density():
-    tm = GumbelCopula(
-        DigitalNetB2(2, seed=119),
-        marginals=[stats.gamma(a=2.0), stats.expon()],
-        theta=1.0,
-    )
-    x = np.array([[1.0, 0.5], [2.0, 1.5]])
-    expected = stats.gamma(a=2.0).pdf(x[:, 0]) * stats.expon().pdf(x[:, 1])
-
-    weights = tm._weight(x)
-
-    np.testing.assert_allclose(weights, expected)
-
-
-def test_gen_copula_samples_composed_transform_branch():
-    inner = GaussianCopula(
-        DigitalNetB2(2, seed=121),
-        marginals=[stats.uniform(), stats.uniform()],
-        correlation=[[1.0, 0.3], [0.3, 1.0]],
-    )
-    outer = ClaytonCopula(inner, marginals=[stats.uniform(), stats.uniform()], theta=1.5)
-
-    v = outer.gen_copula_samples(n_min=4, n_max=8)
-
-    assert v.shape == (4, 2)
-    assert np.all(np.isfinite(v))
-    assert np.all((0.0 <= v) & (v <= 1.0))
-
-
-@pytest.mark.parametrize(
-    "copula_cls",
-    [GaussianCopula, StudentTCopula, ClaytonCopula, GumbelCopula, FrankCopula],
-)
-def test_copula_spawn_same_dimension_and_reject_different_dimension(copula_cls):
-    tm = _make_copula(copula_cls, dimension=2)
-
-    spawned = tm.spawn(s=1, dimensions=[2])
-    assert len(spawned) == 1
-    assert isinstance(spawned[0], copula_cls)
-    assert spawned[0](4).shape == (4, 2)
-
-    with pytest.raises(DimensionError):
-        tm._spawn(DigitalNetB2(3, seed=123), 3)
-
-
-def test_frank_one_dimensional_weight_covers_zero_order_eulerian_term():
-    tm = FrankCopula(
-        DigitalNetB2(1, seed=125),
-        marginals=[UnitPDFMarginal()],
-        theta=3.0,
-    )
-
-    weights = tm._weight(np.array([[0.25], [0.75]]))
-
-    assert weights.shape == (2,)
-    assert np.all(np.isfinite(weights))
-    assert np.all(weights > 0.0)
-
-
-def test_frank_rejects_large_negative_theta_when_exponential_overflows():
-    with np.errstate(over="ignore"):
-        with pytest.raises(ParameterError, match="too close to 0 or too large"):
-            FrankCopula(
-                DigitalNetB2(2, seed=127),
-                marginals=[stats.uniform(), stats.uniform()],
-                theta=-1000.0,
-            )
diff --git a/test/test_discrete_distribs.py b/test/test_dd_discrete_distribs.py
similarity index 100%
rename from test/test_discrete_distribs.py
rename to test/test_dd_discrete_distribs.py
diff --git a/test/test_dd_dummy_sampler.py b/test/test_dd_dummy_sampler.py
new file mode 100644
index 000000000..50d5005b8
--- /dev/null
+++ b/test/test_dd_dummy_sampler.py
@@ -0,0 +1,107 @@
+import unittest
+
+import numpy as np
+
+from qmcpy import DummySampler
+from qmcpy.util import ParameterError
+
+
+PLACEHOLDER_ERROR = "construction placeholder"
+
+
+class TestDummySampler(unittest.TestCase):
+
+    def test_dummy_sampler_constructs_dimension_one(self):
+        sampler = DummySampler(1)
+
+        self.assertEqual(sampler.d, 1)
+        self.assertEqual(sampler.replications, 1)
+        self.assertTrue(sampler.no_replications)
+        self.assertEqual(sampler.mimics, "StdUniform")
+        self.assertEqual(sampler.parameters, [])
+
+    def test_dummy_sampler_constructs_larger_dimensions(self):
+        sampler = DummySampler(3, seed=7)
+
+        self.assertEqual(sampler.d, 3)
+        self.assertEqual(sampler.replications, 1)
+        self.assertTrue(sampler.no_replications)
+        self.assertTrue(np.array_equal(sampler.dvec, np.arange(3)))
+
+    def test_dummy_sampler_constructs_larger_dimension_with_replications(self):
+        sampler = DummySampler(4, replications=3, seed=7)
+
+        self.assertEqual(sampler.d, 4)
+        self.assertEqual(sampler.replications, 3)
+        self.assertFalse(sampler.no_replications)
+        self.assertTrue(np.array_equal(sampler.dvec, np.arange(4)))
+
+    def test_dummy_sampler_direct_sampling_raises_placeholder_error(self):
+        sampler = DummySampler(2)
+
+        with self.assertRaisesRegex(ParameterError, PLACEHOLDER_ERROR):
+            sampler(8)
+
+    def test_dummy_sampler_replicated_direct_sampling_raises_placeholder_error(self):
+        sampler = DummySampler(2, replications=3)
+
+        with self.assertRaisesRegex(ParameterError, PLACEHOLDER_ERROR):
+            sampler(8)
+
+    def test_dummy_sampler_supported_calling_conventions_raise_placeholder_error(self):
+        sampler = DummySampler(2)
+
+        with self.assertRaisesRegex(ParameterError, PLACEHOLDER_ERROR):
+            sampler(n=4)
+        with self.assertRaisesRegex(ParameterError, PLACEHOLDER_ERROR):
+            sampler(n_min=2, n_max=6)
+        with self.assertRaisesRegex(ParameterError, PLACEHOLDER_ERROR):
+            sampler(n=2, n_min=6)
+
+    def test_dummy_sampler_nonzero_n_min_raises_placeholder_error(self):
+        sampler = DummySampler(2)
+
+        with self.assertRaisesRegex(ParameterError, PLACEHOLDER_ERROR):
+            sampler(n_min=5, n_max=9)
+
+    def test_dummy_sampler_rejects_return_binary(self):
+        sampler = DummySampler(2)
+
+        with self.assertRaisesRegex(ParameterError, PLACEHOLDER_ERROR):
+            sampler(4, return_binary=True)
+
+    def test_dummy_sampler_internal_gen_samples_raises_placeholder_error(self):
+        sampler = DummySampler(2)
+
+        with self.assertRaisesRegex(ParameterError, PLACEHOLDER_ERROR):
+            sampler._gen_samples(n_min=5, n_max=9, return_binary=False, warn=True)
+
+    def test_dummy_sampler_spawn_preserves_relevant_fields(self):
+        sampler = DummySampler(2, replications=3, seed=11)
+
+        spawned = sampler.spawn(s=2, dimensions=[1, 5])
+
+        self.assertEqual([spawn.d for spawn in spawned], [1, 5])
+        self.assertEqual([spawn.replications for spawn in spawned], [3, 3])
+        self.assertTrue(all(isinstance(spawn, DummySampler) for spawn in spawned))
+
+    def test_dummy_sampler_spawn_without_explicit_replications(self):
+        sampler = DummySampler(2, seed=11)
+
+        spawned = sampler.spawn(s=1, dimensions=4)[0]
+
+        self.assertEqual(spawned.d, 4)
+        self.assertEqual(spawned.replications, 1)
+        self.assertTrue(spawned.no_replications)
+
+    def test_dummy_sampler_limits_are_enforced(self):
+        with self.assertRaisesRegex(ParameterError, "dimension greater than dimension limit"):
+            DummySampler(10_002)
+
+        sampler = DummySampler(1)
+        with self.assertRaisesRegex(ParameterError, "n_limit"):
+            sampler(n_min=0, n_max=2**32 + 1)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/test/test_dummy_sampler.py b/test/test_dummy_sampler.py
deleted file mode 100644
index 24bec84eb..000000000
--- a/test/test_dummy_sampler.py
+++ /dev/null
@@ -1,111 +0,0 @@
-import numpy as np
-import pytest
-
-from qmcpy import DummySampler
-from qmcpy.util import ParameterError
-
-
-PLACEHOLDER_ERROR = "construction placeholder"
-
-
-def test_dummy_sampler_constructs_dimension_one():
-    sampler = DummySampler(1)
-
-    assert sampler.d == 1
-    assert sampler.replications == 1
-    assert sampler.no_replications
-    assert sampler.mimics == "StdUniform"
-    assert sampler.parameters == []
-
-
-def test_dummy_sampler_constructs_larger_dimensions():
-    sampler = DummySampler(3, seed=7)
-
-    assert sampler.d == 3
-    assert sampler.replications == 1
-    assert sampler.no_replications
-    assert np.array_equal(sampler.dvec, np.arange(3))
-
-
-def test_dummy_sampler_constructs_larger_dimension_with_replications():
-    sampler = DummySampler(4, replications=3, seed=7)
-
-    assert sampler.d == 4
-    assert sampler.replications == 3
-    assert not sampler.no_replications
-    assert np.array_equal(sampler.dvec, np.arange(4))
-
-
-def test_dummy_sampler_direct_sampling_raises_placeholder_error():
-    sampler = DummySampler(2)
-
-    with pytest.raises(ParameterError, match=PLACEHOLDER_ERROR):
-        sampler(8)
-
-
-def test_dummy_sampler_replicated_direct_sampling_raises_placeholder_error():
-    sampler = DummySampler(2, replications=3)
-
-    with pytest.raises(ParameterError, match=PLACEHOLDER_ERROR):
-        sampler(8)
-
-
-def test_dummy_sampler_supported_calling_conventions_raise_placeholder_error():
-    sampler = DummySampler(2)
-
-    with pytest.raises(ParameterError, match=PLACEHOLDER_ERROR):
-        sampler(n=4)
-    with pytest.raises(ParameterError, match=PLACEHOLDER_ERROR):
-        sampler(n_min=2, n_max=6)
-    with pytest.raises(ParameterError, match=PLACEHOLDER_ERROR):
-        sampler(n=2, n_min=6)
-
-
-def test_dummy_sampler_nonzero_n_min_raises_placeholder_error():
-    sampler = DummySampler(2)
-
-    with pytest.raises(ParameterError, match=PLACEHOLDER_ERROR):
-        sampler(n_min=5, n_max=9)
-
-
-def test_dummy_sampler_rejects_return_binary():
-    sampler = DummySampler(2)
-
-    with pytest.raises(ParameterError, match=PLACEHOLDER_ERROR):
-        sampler(4, return_binary=True)
-
-
-def test_dummy_sampler_internal_gen_samples_raises_placeholder_error():
-    sampler = DummySampler(2)
-
-    with pytest.raises(ParameterError, match=PLACEHOLDER_ERROR):
-        sampler._gen_samples(n_min=5, n_max=9, return_binary=False, warn=True)
-
-
-def test_dummy_sampler_spawn_preserves_relevant_fields():
-    sampler = DummySampler(2, replications=3, seed=11)
-
-    spawned = sampler.spawn(s=2, dimensions=[1, 5])
-
-    assert [spawn.d for spawn in spawned] == [1, 5]
-    assert [spawn.replications for spawn in spawned] == [3, 3]
-    assert all(isinstance(spawn, DummySampler) for spawn in spawned)
-
-
-def test_dummy_sampler_spawn_without_explicit_replications():
-    sampler = DummySampler(2, seed=11)
-
-    spawned = sampler.spawn(s=1, dimensions=4)[0]
-
-    assert spawned.d == 4
-    assert spawned.replications == 1
-    assert spawned.no_replications
-
-
-def test_dummy_sampler_limits_are_enforced():
-    with pytest.raises(ParameterError, match="dimension greater than dimension limit"):
-        DummySampler(10_002)
-
-    sampler = DummySampler(1)
-    with pytest.raises(ParameterError, match="n_limit"):
-        sampler(n_min=0, n_max=2**32 + 1)
diff --git a/test/test_integrate.py b/test/test_ee_integrate.py
similarity index 100%
rename from test/test_integrate.py
rename to test/test_ee_integrate.py
diff --git a/test/test_keister.py b/test/test_ee_keister.py
similarity index 100%
rename from test/test_keister.py
rename to test/test_ee_keister.py
diff --git a/test/test_pi_problem.py b/test/test_ee_pi_problem.py
similarity index 100%
rename from test/test_pi_problem.py
rename to test/test_ee_pi_problem.py
diff --git a/test/test_fast_transform_fallbacks.py b/test/test_fast_transform_fallbacks.py
deleted file mode 100644
index 2dcbd2b7a..000000000
--- a/test/test_fast_transform_fallbacks.py
+++ /dev/null
@@ -1,46 +0,0 @@
-import numpy as np
-import pytest
-
-from qmcpy import (
-    fftbr,
-    fftbr_torch,
-    fwht,
-    fwht_torch,
-    ifftbr,
-    ifftbr_torch,
-    omega_fftbr,
-    omega_fftbr_torch,
-    omega_fwht,
-    omega_fwht_torch,
-)
-
-
-def test_non_torch_transforms_basic():
-    rng = np.random.default_rng(11)
-    x = rng.random(8) + 1j * rng.random(8)
-    y = fftbr(x)
-    assert y.shape == x.shape
-    xr = ifftbr(y)
-    assert xr.shape == x.shape
-
-    a = rng.random(8)
-    b = fwht(a)
-    assert b.shape == a.shape
-
-    omega = omega_fftbr(3)
-    assert omega.shape[0] == 2**3
-    omega2 = omega_fwht(3)
-    assert omega2.shape[0] == 2**3
-
-
-def test_torch_fallbacks_raise():
-    with pytest.raises(Exception):
-        fftbr_torch()
-    with pytest.raises(Exception):
-        ifftbr_torch()
-    with pytest.raises(Exception):
-        fwht_torch()
-    with pytest.raises(Exception):
-        omega_fftbr_torch()
-    with pytest.raises(Exception):
-        omega_fwht_torch()
diff --git a/test/test_financial_option_quick.py b/test/test_financial_option_quick.py
deleted file mode 100644
index bd9f3022b..000000000
--- a/test/test_financial_option_quick.py
+++ /dev/null
@@ -1,94 +0,0 @@
-import numpy as np
-
-from qmcpy import FinancialOption
-import qmcpy
-
-
-class SmallSampler(qmcpy.AbstractDiscreteDistribution):
-    def __init__(self, d=3):
-        super().__init__(
-            dimension=d, replications=1, seed=123, d_limit=100, n_limit=1024
-        )
-
-    def _gen_samples(self, n_min, n_max, return_binary=False, warn=True):
-        n = n_max - n_min
-        # return shape (replications, n, d)
-        arr = np.tile(np.linspace(0.1, 1.0, n)[:, None], (1, self.d))
-        return arr.reshape(self.replications, n, self.d)
-
-
-def test_financial_option_payoffs_and_exact():
-    sampler = SmallSampler(d=3)
-    fo = FinancialOption(
-        sampler,
-        option="EUROPEAN",
-        call_put="CALL",
-        volatility=0.5,
-        start_price=30,
-        strike_price=25,
-        interest_rate=0.01,
-        t_final=1,
-    )
-    gbm = np.array([[30.0, 28.0, 35.0]])
-    c = fo.payoff_european_call(gbm)
-    p = fo.payoff_european_put(gbm)
-    assert c.shape == (1,)
-    assert p.shape == (1,)
-
-    # Asian arithmetic trapezoidal
-    fo_asian = FinancialOption(
-        sampler,
-        option="ASIAN",
-        asian_mean="ARITHMETIC",
-        asian_mean_quadrature_rule="TRAPEZOIDAL",
-    )
-    gbm2 = np.array([[30.0, 32.0, 34.0]])
-    a_call = fo_asian.payoff_asian_arithmetic_trap_call(gbm2)
-    assert a_call.shape == (1,)
-
-    # geometric right call
-    fo_geo = FinancialOption(
-        sampler,
-        option="ASIAN",
-        asian_mean="GEOMETRIC",
-        asian_mean_quadrature_rule="RIGHT",
-    )
-    g_call = fo_geo.payoff_asian_geometric_right_call(np.array([[30.0, 30.0, 30.0]]))
-    assert g_call.shape == (1,)
-
-    # barrier options: up and down behaviors
-    fo_barrier_up = FinancialOption(
-        sampler, option="BARRIER", barrier_in_out="IN", barrier_price=25, start_price=20
-    )
-    gbm_up = np.array([[20.0, 26.0, 27.0]])
-    v = fo_barrier_up.payoff_barrier_in_up_call(gbm_up)
-    assert v.shape == (1,)
-
-    fo_barrier_out = FinancialOption(
-        sampler,
-        option="BARRIER",
-        barrier_in_out="OUT",
-        barrier_price=40,
-        start_price=30,
-    )
-    gbm_out = np.array([[30.0, 32.0, 33.0]])
-    v2 = fo_barrier_out.payoff_barrier_out_up_call(gbm_out)
-    assert v2.shape == (1,)
-
-    # lookback
-    fo_lb = FinancialOption(sampler, option="LOOKBACK")
-    lb = fo_lb.payoff_lookback_call(np.array([[10.0, 9.0, 12.0]]))
-    assert lb.shape == (1,)
-
-    # digital
-    fo_dig = FinancialOption(sampler, option="DIGITAL", digital_payout=5)
-    dig = fo_dig.payoff_digital_call(np.array([[10.0, 11.0, 12.0]]))
-    assert dig.shape == (1,)
-
-    # exact value for European should return a float
-    val = fo.get_exact_value()
-    assert np.isscalar(val)
-
-    # exact value for Asian geometric right
-    val2 = fo_geo.get_exact_value()
-    assert np.isscalar(val2)
diff --git a/test/test_flatten_qmcpy_imports.py b/test/test_flatten_qmcpy_imports.py
deleted file mode 100644
index c7fc36fdb..000000000
--- a/test/test_flatten_qmcpy_imports.py
+++ /dev/null
@@ -1,330 +0,0 @@
-import json
-from pathlib import Path
-
-from scripts.flatten_qmcpy_imports import (
-    _load_qmcpy_public_names,
-    flatten_imports,
-    main,
-)
-
-
-def _nested_import(module, imported):
-    return f"from {'qmcpy.' + module} import {imported}"
-
-
-def test_flatten_imports_basic():
-    source = (
-        _nested_import("integrand", "Keister")
-        + "\n"
-        + _nested_import("discrete_distribution.lattice", "Lattice as LD")
-        + "\nfrom qmcpy import DigitalNetB2\nimport qmcpy.util\n"
-    ).encode()
-
-    updated, count = flatten_imports(
-        source, frozenset({"DigitalNetB2", "Keister", "Lattice"})
-    )
-
-    assert count == 3
-    assert updated == (
-        b"from qmcpy import DigitalNetB2, Keister, Lattice as LD\n"
-        b"import qmcpy.util\n"
-    )
-
-
-def test_flatten_preserves_private():
-    source = (
-        _nested_import("_internal._helpers", "PublicHelper")
-        + "\n"
-        + _nested_import(
-            "true_measure.uniform_triangle",
-            "UniformTriangle, _UniformTriangleAdapter",
-        )
-        + "\n"
-        + _nested_import(
-            "true_measure.copula",
-            "(\n    AbstractCopula,\n    _validate_dimension,\n)",
-        )
-        + "\n"
-        + _nested_import("integrand", "Keister")
-        + "\n"
-    ).encode()
-
-    updated, count = flatten_imports(source, frozenset({"Keister"}))
-
-    assert count == 1
-    assert updated == source.replace(
-        _nested_import("integrand", "Keister").encode(),
-        b"from qmcpy import Keister",
-    )
-
-
-def test_private_module_splits_groups():
-    source = (
-        b"from qmcpy import Zeta\n"
-        b"from qmcpy._internal._helpers import PublicHelper\n"
-        b"from qmcpy import Alpha\n"
-    )
-
-    updated, count = flatten_imports(source)
-
-    assert count == 0
-    assert updated == source
-
-
-def test_flatten_preserves_util_imports():
-    source = (
-        b"from qmcpy.util import ParameterError\n"
-        b"from qmcpy.util.transforms import tf_exp\n"
-    )
-
-    updated, count = flatten_imports(source, frozenset({"ParameterError", "tf_exp"}))
-
-    assert (updated, count) == (source, 0)
-
-
-def test_flatten_keeps_nonpublic_names():
-    source = b"from qmcpy.stopping_criterion.pf_gp_ci import PFGPCIData\n"
-
-    updated, count = flatten_imports(source, frozenset({"PFGPCI"}))
-
-    assert (updated, count) == (source, 0)
-
-
-def test_flatten_no_public_api_noop():
-    source = (_nested_import("integrand", "Keister") + "\n").encode()
-
-    updated, count = flatten_imports(source)
-
-    assert (updated, count) == (source, 0)
-
-
-def test_flatten_preserve_str_literals():
-    source = b'text = """\nfrom qmcpy.integrand import Keister\n"""\n'
-
-    updated, count = flatten_imports(source, frozenset({"Keister"}))
-
-    assert count == 0
-    assert updated == source
-
-
-def test_python_string_protection_applies_to_every_rewrite_stage():
-    string_body = (
-        b'text = """\n'
-        b"from qmcpy.integrand import Keister\n"
-        b"from qmcpy import Zeta,Beta\n"
-        b"from qmcpy import Alpha\n"
-        b"from qmcpy import *\n"
-        b"from qmcpy import *\n"
-        b'"""\n'
-    )
-    source = string_body + b"from qmcpy.integrand import Keister\n"
-
-    updated, count = flatten_imports(source, frozenset({"Keister"}))
-
-    assert count == 1
-    assert updated == string_body + b"from qmcpy import Keister\n"
-
-
-def test_python_tokenize_failure_is_fail_closed():
-    source = b'"""unterminated\nfrom qmcpy.integrand import Keister\n'
-
-    assert flatten_imports(source, frozenset({"Keister"})) == (source, 0)
-
-
-def test_flatten_skip_star_expansion():
-    source = (
-        b"from qmcpy import *\n\n"
-        b"def f(Lattice):\n"
-        b"    return Lattice\n\n"
-        b"y = Keister(dimension=2)\n"
-        b"x = Lattice(dimension=2)\n"
-    )
-
-    updated, count = flatten_imports(source, frozenset({"Keister", "Lattice"}))
-
-    assert count == 0
-    assert updated == source
-
-
-def test_notebook_star_dedup():
-    notebook = {
-        "cells": [
-            {
-                "cell_type": "code",
-                "source": [
-                    _nested_import("integrand", "*") + "\n",
-                    _nested_import("true_measure", "*"),
-                ],
-            }
-        ]
-    }
-    source = json.dumps(notebook, indent=1).encode()
-
-    updated, count = flatten_imports(source, frozenset({"Keister"}))
-
-    assert count == 3
-    assert json.loads(updated)["cells"][0]["source"] == ["from qmcpy import *"]
-
-
-def test_named_imports_merge_sort():
-    source = (
-        b"from qmcpy import Zeta,Beta\n"
-        b"from qmcpy import Alpha\n"
-        b"\n"
-        b"from qmcpy import Gamma\n"
-    )
-
-    updated, count = flatten_imports(source)
-
-    assert count == 1
-    assert updated == (
-        b"from qmcpy import Alpha, Beta, Zeta\n"
-        b"\n"
-        b"from qmcpy import Gamma\n"
-    )
-    assert flatten_imports(updated) == (updated, 0)
-
-
-def test_merge_paren_and_single_line():
-    source = b"""from qmcpy import (
-    KernelDigShiftInvar,
-    KernelDigShiftInvarAdaptiveAlpha,
-    KernelDigShiftInvarCombined,
-    KernelShiftInvar,
-    KernelShiftInvarCombined,
-)
-from qmcpy import tf_exp_eps, tf_exp_eps_inv
-"""
-
-    updated, count = flatten_imports(source)
-
-    assert count == 1
-    assert updated == b"""from qmcpy import (
-    KernelDigShiftInvar,
-    KernelDigShiftInvarAdaptiveAlpha,
-    KernelDigShiftInvarCombined,
-    KernelShiftInvar,
-    KernelShiftInvarCombined,
-    tf_exp_eps,
-    tf_exp_eps_inv,
-)
-"""
-    assert flatten_imports(updated) == (updated, 0)
-
-
-def test_merge_same_scope_only():
-    source = (
-        b"if enabled:\n"
-        b"    from qmcpy import Zeta\n"
-        b"    from qmcpy import Alpha as First\n"
-        b"else:\n"
-        b"    from qmcpy import Beta\n"
-        b"from qmcpy import _Private\n"
-        b"from qmcpy import Gamma  # keep this comment\n"
-    )
-
-    updated, count = flatten_imports(source)
-
-    assert count == 1
-    assert updated == (
-        b"if enabled:\n"
-        b"    from qmcpy import Alpha as First, Zeta\n"
-        b"else:\n"
-        b"    from qmcpy import Beta\n"
-        b"from qmcpy import _Private\n"
-        b"from qmcpy import Gamma  # keep this comment\n"
-    )
-
-
-def test_notebook_named_merge():
-    notebook = {
-        "cells": [
-            {
-                "cell_type": "code",
-                "source": [
-                    "from qmcpy import Zeta\n",
-                    "from qmcpy import Alpha,Beta\n",
-                    "print(Alpha)\n",
-                ],
-            }
-        ]
-    }
-    source = json.dumps(notebook, indent=1).encode()
-
-    updated, count = flatten_imports(source)
-
-    assert count == 1
-    assert json.loads(updated)["cells"][0]["source"] == [
-        "from qmcpy import Alpha, Beta, Zeta\n",
-        "print(Alpha)\n",
-    ]
-    assert flatten_imports(updated) == (updated, 0)
-
-
-def test_notebook_flattens_nested_imports_only_in_code_cells():
-    nested_import = _nested_import("integrand", "Keister") + "\n"
-    metadata_import = _nested_import("true_measure", "Gaussian") + "\n"
-    string_literal = f'text = "{nested_import.rstrip()}"\n'
-    multiline_string = ['text = """\n', nested_import, '"""\n']
-    notebook = {
-        "metadata": {"source": [metadata_import]},
-        "cells": [
-            {"cell_type": "markdown", "source": [nested_import]},
-            {"cell_type": "code", "source": [nested_import]},
-            {"cell_type": "code", "source": [string_literal]},
-            {"cell_type": "code", "source": multiline_string},
-        ]
-    }
-    source = json.dumps(notebook, indent=1).encode()
-
-    updated, count = flatten_imports(source, frozenset({"Keister"}))
-
-    cells = json.loads(updated)["cells"]
-    assert count == 1
-    assert json.loads(updated)["metadata"]["source"] == [metadata_import]
-    assert cells[0]["source"] == [nested_import]
-    assert cells[1]["source"] == ["from qmcpy import Keister\n"]
-    assert cells[2]["source"] == [string_literal]
-    assert cells[3]["source"] == multiline_string
-    assert flatten_imports(updated, frozenset({"Keister"})) == (updated, 0)
-
-
-def test_markdown_import_examples_are_flattened(tmp_path):
-    path = tmp_path / "example.md"
-    path.write_bytes(
-        b'Example with unmatched prose delimiter: """\n\n'
-        b"```python\n"
-        b"from qmcpy.integrand import Keister\n"
-        b"```\n"
-    )
-
-    assert main([str(path)]) == 0
-    assert b"from qmcpy import Keister" in path.read_bytes()
-
-
-def test_check_mode_no_write(tmp_path):
-    path = tmp_path / "example.py"
-    original = (_nested_import("true_measure", "Gaussian") + "\n").encode()
-    path.write_bytes(original)
-
-    assert main(["--check", str(path)]) == 1
-    assert path.read_bytes() == original
-
-    assert main([str(path)]) == 0
-    assert path.read_bytes() == b"from qmcpy import Gaussian\n"
-    assert main(["--check", str(path)]) == 0
-
-
-def test_public_names_optional_free_stable():
-    repository_root = Path(__file__).resolve().parent.parent
-    names = _load_qmcpy_public_names(repository_root)
-
-    assert names is not None
-    assert "Gaussian" in names
-    assert "Keister" in names
-    # Optional dependencies are blocked in the probe context, so fallback
-    # exports are part of the deterministic name set.
-    assert "PFGPCI" in names
-    # Helpers that are deliberately not part of the top-level API.
-    assert "PFGPCIData" not in names
-    assert "TriangularDistribution" not in names
\ No newline at end of file
diff --git a/test/test_ft_fast_transform_fallbacks.py b/test/test_ft_fast_transform_fallbacks.py
new file mode 100644
index 000000000..d60266030
--- /dev/null
+++ b/test/test_ft_fast_transform_fallbacks.py
@@ -0,0 +1,52 @@
+import unittest
+
+import numpy as np
+
+from qmcpy import (
+    fftbr,
+    fftbr_torch,
+    fwht,
+    fwht_torch,
+    ifftbr,
+    ifftbr_torch,
+    omega_fftbr,
+    omega_fftbr_torch,
+    omega_fwht,
+    omega_fwht_torch,
+)
+
+
+class TestFastTransformFallbacks(unittest.TestCase):
+
+    def test_non_torch_transforms_basic(self):
+        rng = np.random.default_rng(11)
+        x = rng.random(8) + 1j * rng.random(8)
+        y = fftbr(x)
+        self.assertEqual(y.shape, x.shape)
+        xr = ifftbr(y)
+        self.assertEqual(xr.shape, x.shape)
+
+        a = rng.random(8)
+        b = fwht(a)
+        self.assertEqual(b.shape, a.shape)
+
+        omega = omega_fftbr(3)
+        self.assertEqual(omega.shape[0], 2**3)
+        omega2 = omega_fwht(3)
+        self.assertEqual(omega2.shape[0], 2**3)
+
+    def test_torch_fallbacks_raise(self):
+        with self.assertRaises(Exception):
+            fftbr_torch()
+        with self.assertRaises(Exception):
+            ifftbr_torch()
+        with self.assertRaises(Exception):
+            fwht_torch()
+        with self.assertRaises(Exception):
+            omega_fftbr_torch()
+        with self.assertRaises(Exception):
+            omega_fwht_torch()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/test/test_ig_financial_option_quick.py b/test/test_ig_financial_option_quick.py
new file mode 100644
index 000000000..921701712
--- /dev/null
+++ b/test/test_ig_financial_option_quick.py
@@ -0,0 +1,102 @@
+import unittest
+
+import numpy as np
+
+from qmcpy import FinancialOption
+import qmcpy
+
+
+class SmallSampler(qmcpy.AbstractDiscreteDistribution):
+    def __init__(self, d=3):
+        super().__init__(
+            dimension=d, replications=1, seed=123, d_limit=100, n_limit=1024
+        )
+
+    def _gen_samples(self, n_min, n_max, return_binary=False, warn=True):
+        n = n_max - n_min
+        # return shape (replications, n, d)
+        arr = np.tile(np.linspace(0.1, 1.0, n)[:, None], (1, self.d))
+        return arr.reshape(self.replications, n, self.d)
+
+
+class TestFinancialOptionPayoffs(unittest.TestCase):
+
+    def test_financial_option_payoffs_and_exact(self):
+        sampler = SmallSampler(d=3)
+        fo = FinancialOption(
+            sampler,
+            option="EUROPEAN",
+            call_put="CALL",
+            volatility=0.5,
+            start_price=30,
+            strike_price=25,
+            interest_rate=0.01,
+            t_final=1,
+        )
+        gbm = np.array([[30.0, 28.0, 35.0]])
+        c = fo.payoff_european_call(gbm)
+        p = fo.payoff_european_put(gbm)
+        self.assertEqual(c.shape, (1,))
+        self.assertEqual(p.shape, (1,))
+
+        # Asian arithmetic trapezoidal
+        fo_asian = FinancialOption(
+            sampler,
+            option="ASIAN",
+            asian_mean="ARITHMETIC",
+            asian_mean_quadrature_rule="TRAPEZOIDAL",
+        )
+        gbm2 = np.array([[30.0, 32.0, 34.0]])
+        a_call = fo_asian.payoff_asian_arithmetic_trap_call(gbm2)
+        self.assertEqual(a_call.shape, (1,))
+
+        # geometric right call
+        fo_geo = FinancialOption(
+            sampler,
+            option="ASIAN",
+            asian_mean="GEOMETRIC",
+            asian_mean_quadrature_rule="RIGHT",
+        )
+        g_call = fo_geo.payoff_asian_geometric_right_call(np.array([[30.0, 30.0, 30.0]]))
+        self.assertEqual(g_call.shape, (1,))
+
+        # barrier options: up and down behaviors
+        fo_barrier_up = FinancialOption(
+            sampler, option="BARRIER", barrier_in_out="IN", barrier_price=25, start_price=20
+        )
+        gbm_up = np.array([[20.0, 26.0, 27.0]])
+        v = fo_barrier_up.payoff_barrier_in_up_call(gbm_up)
+        self.assertEqual(v.shape, (1,))
+
+        fo_barrier_out = FinancialOption(
+            sampler,
+            option="BARRIER",
+            barrier_in_out="OUT",
+            barrier_price=40,
+            start_price=30,
+        )
+        gbm_out = np.array([[30.0, 32.0, 33.0]])
+        v2 = fo_barrier_out.payoff_barrier_out_up_call(gbm_out)
+        self.assertEqual(v2.shape, (1,))
+
+        # lookback
+        fo_lb = FinancialOption(sampler, option="LOOKBACK")
+        lb = fo_lb.payoff_lookback_call(np.array([[10.0, 9.0, 12.0]]))
+        self.assertEqual(lb.shape, (1,))
+
+        # digital
+        fo_dig = FinancialOption(sampler, option="DIGITAL", digital_payout=5)
+        dig = fo_dig.payoff_digital_call(np.array([[10.0, 11.0, 12.0]]))
+        self.assertEqual(dig.shape, (1,))
+
+        # exact value for European should return a float
+        val = fo.get_exact_value()
+        self.assertTrue(np.isscalar(val))
+
+        # exact value for Asian geometric right
+        val2 = fo_geo.get_exact_value()
+        self.assertTrue(np.isscalar(val2))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/test/test_integrands.py b/test/test_ig_integrands.py
similarity index 100%
rename from test/test_integrands.py
rename to test/test_ig_integrands.py
diff --git a/test/test_option.py b/test/test_ig_option.py
similarity index 100%
rename from test/test_option.py
rename to test/test_ig_option.py
diff --git a/test/test_option_ml.py b/test/test_ig_option_ml.py
similarity index 100%
rename from test/test_option_ml.py
rename to test/test_ig_option_ml.py
diff --git a/test/test_install_mpmc_pyg.py b/test/test_install_mpmc_pyg.py
deleted file mode 100644
index 41b1b4e0b..000000000
--- a/test/test_install_mpmc_pyg.py
+++ /dev/null
@@ -1,85 +0,0 @@
-"""Tests for the platform-specific MPMC dependency installer."""
-
-import subprocess
-from types import SimpleNamespace
-
-import pytest
-
-from qmcpy.util import install_mpmc_pyg
-
-
-def _torch(version="2.12.1+cpu", cuda=None, hip=None):
-    return SimpleNamespace(
-        __version__=version,
-        version=SimpleNamespace(cuda=cuda, hip=hip),
-    )
-
-
-def test_torch_versions_include_baseline_fallback():
-    """Wheel lookup tries an exact patch release, then its minor baseline."""
-    assert install_mpmc_pyg.torch_versions("2.12.1+cpu") == ["2.12.1", "2.12.0"]
-    assert install_mpmc_pyg.torch_versions("2.12.0") == ["2.12.0"]
-
-    with pytest.raises(RuntimeError, match="Unable to parse torch version"):
-        install_mpmc_pyg.torch_versions("development")
-
-
-@pytest.mark.parametrize(
-    ("torch_module", "expected"),
-    [
-        (_torch(), "cpu"),
-        (_torch(cuda="12.6"), "cu126"),
-        (_torch(cuda="13.0.1"), "cu130"),
-    ],
-)
-def test_accelerator_tag(torch_module, expected):
-    """PyTorch build metadata maps to the expected PyG wheel tag."""
-    assert install_mpmc_pyg.accelerator_tag(torch_module) == expected
-
-
-def test_accelerator_tag_rejects_rocm():
-    """The installer directs unsupported ROCm users to upstream guidance."""
-    with pytest.raises(RuntimeError, match="does not currently support ROCm"):
-        install_mpmc_pyg.accelerator_tag(_torch(hip="6.3"))
-
-
-def test_main_retries_with_torch_minor_baseline(monkeypatch):
-    """A missing exact wheel page falls back to the minor baseline page."""
-    calls = []
-
-    def fake_run(*args):
-        calls.append(args)
-        if args[-1].endswith("torch-2.12.1+cpu.html"):
-            raise subprocess.CalledProcessError(1, args)
-
-    monkeypatch.setattr(install_mpmc_pyg, "run", fake_run)
-
-    install_mpmc_pyg.main(_torch())
-
-    assert calls[0][-1] == "torch-geometric>=2.6.1"
-    assert calls[1][-1] == "https://data.pyg.org/whl/torch-2.12.1+cpu.html"
-    assert calls[2][-1] == "https://data.pyg.org/whl/torch-2.12.0+cpu.html"
-    assert "--only-binary" in calls[1]
-
-
-def test_main_explains_that_torch_must_be_installed(monkeypatch):
-    """Running the helper before installing the extra gives a useful error."""
-    def missing_torch(_name):
-        raise ModuleNotFoundError("No module named 'torch'", name="torch")
-
-    monkeypatch.setattr(install_mpmc_pyg.importlib, "import_module", missing_torch)
-
-    with pytest.raises(RuntimeError, match=r"install 'qmcpy\[mpmc\]'"):
-        install_mpmc_pyg.main()
-
-
-def test_main_reports_missing_wheel(monkeypatch):
-    """Exhausting candidate wheel pages reports the build that failed."""
-    def fail_pyg_lib(*args):
-        if "pyg_lib>=0.6.0" in args:
-            raise subprocess.CalledProcessError(1, args)
-
-    monkeypatch.setattr(install_mpmc_pyg, "run", fail_pyg_lib)
-
-    with pytest.raises(RuntimeError, match=r"torch 2\.12\.1\+cpu \(cpu\)"):
-        install_mpmc_pyg.main(_torch())
diff --git a/test/test_kernels.py b/test/test_kn_kernels.py
similarity index 100%
rename from test/test_kernels.py
rename to test/test_kn_kernels.py
diff --git a/test/test_mpmc_optional_imports.py b/test/test_mpmc_optional_imports.py
deleted file mode 100644
index 33b71b841..000000000
--- a/test/test_mpmc_optional_imports.py
+++ /dev/null
@@ -1,100 +0,0 @@
-import ast
-import builtins
-from pathlib import Path
-
-import pytest
-
-
-def _execute_optional_import(blocked_import):
-    repository_root = Path(__file__).resolve().parent.parent
-    init_path = repository_root / "qmcpy" / "__init__.py"
-    init_tree = ast.parse(init_path.read_text())
-    optional_import = next(
-        node
-        for node in init_tree.body
-        if isinstance(node, ast.Try)
-        and any(
-            isinstance(statement, ast.ImportFrom)
-            and statement.module == "discrete_distribution.mpmc"
-            for statement in node.body
-        )
-    )
-
-    import qmcpy
-
-    real_import = builtins.__import__
-
-    def guarded_import(name, globals=None, locals=None, fromlist=(), level=0):
-        missing_module = blocked_import(name, fromlist, level)
-        if missing_module is not None:
-            raise ModuleNotFoundError(
-                "blocked optional dependency",
-                name=missing_module,
-            )
-        return real_import(name, globals, locals, fromlist, level)
-
-    test_builtins = vars(builtins).copy()
-    test_builtins["__import__"] = guarded_import
-    namespace = {"__builtins__": test_builtins, "__package__": "qmcpy"}
-    module = ast.Module(body=[optional_import], type_ignores=[])
-    exec(compile(module, str(init_path), "exec"), namespace)
-    return namespace
-
-
-def test_mpmc_utils_remain_available_without_pyg():
-    pytest.importorskip("torch")
-
-    def block_pyg_models(name, fromlist, level):
-        if level == 1 and name == "discrete_distribution.mpmc.models":
-            return "torch_geometric"
-        return None
-
-    namespace = _execute_optional_import(block_pyg_models)
-
-    import qmcpy
-
-    assert namespace["mpmc_utils"] is qmcpy.mpmc_utils
-    assert namespace["mpmc_utils"].__name__ == (
-        "qmcpy.discrete_distribution.mpmc.utils"
-    )
-    assert "utils" not in namespace
-
-    with pytest.raises(ModuleNotFoundError, match="MPMC_net.*torch_geometric") as error:
-        namespace["MPMC_net"]()
-    assert error.value.name == "torch_geometric"
-
-
-def test_mpmc_placeholders_report_missing_torch():
-    def block_torch_utils(name, fromlist, level):
-        if (
-            level == 1
-            and name == "discrete_distribution.mpmc"
-            and "utils" in fromlist
-        ):
-            return "torch"
-        return None
-
-    namespace = _execute_optional_import(block_torch_utils)
-
-    with pytest.raises(ModuleNotFoundError, match="mpmc_utils.*torch") as error:
-        namespace["mpmc_utils"].L2star
-    assert error.value.name == "torch"
-
-    with pytest.raises(ModuleNotFoundError, match="MPMC_net.*torch") as error:
-        namespace["MPMC_net"]()
-    assert error.value.name == "torch"
-
-
-def test_mpmc_placeholder_missing_torch_scatter():
-    pytest.importorskip("torch")
-
-    def block_torch_scatter(name, fromlist, level):
-        if level == 1 and name == "discrete_distribution.mpmc.models":
-            return "torch_scatter"
-        return None
-
-    namespace = _execute_optional_import(block_torch_scatter)
-
-    with pytest.raises(ModuleNotFoundError, match="MPMC_net.*torch_scatter") as error:
-        namespace["MPMC_net"]()
-    assert error.value.name == "torch_scatter"
diff --git a/test/test_plot_and_stop.py b/test/test_plot_and_stop.py
deleted file mode 100644
index dd564cd9d..000000000
--- a/test/test_plot_and_stop.py
+++ /dev/null
@@ -1,155 +0,0 @@
-import sys
-import types
-import numpy as np
-import builtins
-import pytest
-
-import qmcpy
-from qmcpy import plot_proj
-from qmcpy.util import stop_notebook
-
-
-class FakeAxes:
-    def __init__(self):
-        self.removed = False
-        self.calls = []
-
-    def remove(self):
-        self.removed = True
-
-    def set_xlim(self, *a, **k):
-        self.calls.append(("set_xlim", a))
-
-    def set_ylim(self, *a, **k):
-        self.calls.append(("set_ylim", a))
-
-    def set_xticks(self, *a, **k):
-        self.calls.append(("set_xticks", a))
-
-    def set_yticks(self, *a, **k):
-        self.calls.append(("set_yticks", a))
-
-    def set_aspect(self, *a, **k):
-        self.calls.append(("set_aspect", a))
-
-    def grid(self, *a, **k):
-        self.calls.append(("grid", a))
-
-    def tick_params(self, *a, **k):
-        self.calls.append(("tick_params", a))
-
-    def set_xlabel(self, *a, **k):
-        self.calls.append(("set_xlabel", a))
-
-    def set_ylabel(self, *a, **k):
-        self.calls.append(("set_ylabel", a))
-
-    def scatter(self, *a, **k):
-        self.calls.append(("scatter", a))
-
-
-class FakeFig:
-    def __init__(self):
-        self.tl = False
-
-    def tight_layout(self, *a, **k):
-        self.tl = True
-
-
-def make_fake_matplotlib(nrows, ncols):
-    plt = types.ModuleType("matplotlib.pyplot")
-    plt.style = types.SimpleNamespace()
-    plt.style.use = lambda *a, **k: None
-    plt.rcParams = {
-        "font.family": "sans-serif",
-        "axes.prop_cycle": types.SimpleNamespace(
-            by_key=lambda: {"color": ["k", "b", "r"]}
-        ),
-    }
-
-    def subplots(nrows=1, ncols=1, figsize=None, squeeze=False):
-        fig = FakeFig()
-        ax = np.empty((nrows, ncols), dtype=object)
-        for i in range(nrows):
-            for j in range(ncols):
-                ax[i, j] = FakeAxes()
-        return fig, ax
-
-    plt.subplots = subplots
-    plt.suptitle = lambda *a, **k: None
-    return plt
-
-
-class DummySampler(qmcpy.AbstractDiscreteDistribution):
-    def __init__(self, d=2):
-        super().__init__(dimension=d, replications=1, seed=1, d_limit=10, n_limit=100)
-
-    def _gen_samples(self, n_min, n_max, return_binary=False, warn=True):
-        n = n_max - n_min
-        return np.tile(np.arange(n)[:, None] / max(1, n - 1), (1, 1, self.d)).reshape(
-            self.replications, n, self.d
-        )
-
-    def __repr__(self):
-        return "DummySampler"
-
-
-def test_plot_proj_with_fake_matplotlib_and_sampler(monkeypatch):
-    # Inject fake matplotlib.pyplot
-    fake_plt = make_fake_matplotlib(1, 1)
-    # Create a proper matplotlib package module with colors submodule
-    fake_matplotlib = types.ModuleType("matplotlib")
-    fake_matplotlib.pyplot = fake_plt
-    fake_matplotlib.colors = types.SimpleNamespace()
-    monkeypatch.setitem(sys.modules, "matplotlib.pyplot", fake_plt)
-    monkeypatch.setitem(sys.modules, "matplotlib", fake_matplotlib)
-
-    sampler = DummySampler(d=3)
-    fig, ax = plot_proj(
-        sampler,
-        n=4,
-        d_horizontal=1,
-        d_vertical=2,
-        math_ind=True,
-        marker_size=1,
-        figfac=1,
-    )
-    assert isinstance(fig, FakeFig)
-    assert isinstance(ax, np.ndarray)
-    # At least one axes should have scatter calls or be removed
-    found = False
-    for a in ax.flatten():
-        if getattr(a, "removed", False) or any(c[0] == "scatter" for c in a.calls):
-            found = True
-            break
-    assert found
-
-
-def test_plot_proj_with_callable_sampler(monkeypatch):
-    # sampler not instance of AbstractDiscreteDistribution -> uses t_i labels
-    fake_plt = make_fake_matplotlib(1, 1)
-    fake_matplotlib = types.ModuleType("matplotlib")
-    fake_matplotlib.pyplot = fake_plt
-    fake_matplotlib.colors = types.SimpleNamespace()
-    monkeypatch.setitem(sys.modules, "matplotlib.pyplot", fake_plt)
-    monkeypatch.setitem(sys.modules, "matplotlib", fake_matplotlib)
-
-    def sampler_callable(n):
-        return np.zeros((n, 1))
-
-    fig, ax = plot_proj(
-        sampler_callable, n=3, d_horizontal=0, d_vertical=0, math_ind=False
-    )
-    assert isinstance(fig, FakeFig)
-
-
-def test_stop_notebook_yes_and_no(monkeypatch):
-    # When input is 'yes' nothing should happen
-    monkeypatch.setattr(builtins, "input", lambda prompt="": "yes")
-    # Should not raise
-    stop_notebook("prompt")
-
-    # When input is not 'yes' should exit
-    monkeypatch.setattr(builtins, "input", lambda prompt="": "no")
-    with pytest.raises(SystemExit):
-        stop_notebook("prompt")
diff --git a/test/test_product_measure.py b/test/test_product_measure.py
deleted file mode 100644
index c91b313bd..000000000
--- a/test/test_product_measure.py
+++ /dev/null
@@ -1,277 +0,0 @@
-import numpy as np
-import pytest
-import scipy.stats as stats
-
-from qmcpy import (
-    AcceptanceRejection,
-    DigitalNetB2,
-    DummySampler,
-    Gaussian,
-    GaussianCopula,
-    ProductMeasure,
-    SciPyWrapper,
-    Uniform,
-    ZeroInflatedExpUniform,
-)
-from qmcpy.util import DimensionError, ParameterError
-
-
-def test_product_measure_zero_inflated_with_scipy_uniform_shape():
-    n = 32
-    marginals = [
-        ZeroInflatedExpUniform(DummySampler(1), p_zero=0.4, lam=1.5),
-        SciPyWrapper(DummySampler(1), stats.uniform(loc=2.0, scale=3.0)),
-    ]
-    tm = ProductMeasure(sampler=DigitalNetB2(2, seed=23), marginals=marginals)
-
-    x = tm(n)
-
-    assert x.shape == (n, 2)
-    assert np.any(x[:, 0] == 0.0)
-    assert np.all((2.0 <= x[:, 1]) & (x[:, 1] <= 5.0))
-
-
-def test_product_measure_replication_shape():
-    n = 16
-    r = 3
-    marginals = [
-        ZeroInflatedExpUniform(DummySampler(1), p_zero=0.4, lam=1.5),
-        Uniform(DummySampler(1), lower_bound=2.0, upper_bound=5.0),
-    ]
-    tm = ProductMeasure(
-        sampler=DigitalNetB2(2, seed=23, replications=r),
-        marginals=marginals,
-    )
-
-    x = tm(n)
-
-    assert x.shape == (r, n, 2)
-
-
-def test_product_measure_marginals_with_different_dimensions():
-    n = 32
-    marginals = [
-        Gaussian(
-            DummySampler(2),
-            mean=[1.0, -1.0],
-            covariance=[[2.0, 0.25], [0.25, 1.0]],
-        ),
-        ZeroInflatedExpUniform(DummySampler(1), p_zero=0.4, lam=1.5),
-    ]
-    tm = ProductMeasure(sampler=DigitalNetB2(3, seed=31), marginals=marginals)
-
-    x = tm(n)
-
-    assert tm.d == 3
-    assert np.array_equal(tm.marginal_dimensions, np.array([2, 1]))
-    assert x.shape == (n, 3)
-    assert np.all(np.isfinite(x[:, :2]))
-    assert np.all(x[:, 2] >= 0.0)
-
-
-def test_product_measure_block_split_range_and_weight_product():
-    n = 16
-    marginals = [
-        Uniform(DummySampler(1), lower_bound=10.0, upper_bound=12.0),
-        Uniform(
-            DummySampler(2),
-            lower_bound=[20.0, 30.0],
-            upper_bound=[24.0, 36.0],
-        ),
-    ]
-    tm = ProductMeasure(sampler=DigitalNetB2(3, seed=41), marginals=marginals)
-
-    u = tm.discrete_distrib.gen_samples(n)
-    x = tm._transform(u)
-    x_call, jac = tm(n, return_weights=True)
-    expected = np.concatenate(
-        [
-            marginals[0]._jacobian_transform_r(u[..., :1], return_weights=False),
-            marginals[1]._jacobian_transform_r(u[..., 1:], return_weights=False),
-        ],
-        axis=-1,
-    )
-    expected_range = np.array([[10.0, 12.0], [20.0, 24.0], [30.0, 36.0]])
-
-    assert x.shape == (n, 3)
-    assert np.allclose(tm.range, expected_range)
-    assert np.allclose(x, expected)
-    assert np.all((10.0 <= x[:, 0]) & (x[:, 0] <= 12.0))
-    assert np.all((20.0 <= x[:, 1]) & (x[:, 1] <= 24.0))
-    assert np.all((30.0 <= x[:, 2]) & (x[:, 2] <= 36.0))
-    assert np.allclose(tm._weight(x), 1.0 / (2.0 * 4.0 * 6.0))
-    assert x_call.shape == (n, 3)
-    assert np.allclose(jac, 2.0 * 4.0 * 6.0)
-
-
-def test_product_measure_invalid_inputs():
-    with pytest.raises(ParameterError, match="nonempty list of marginals"):
-        ProductMeasure(sampler=DigitalNetB2(1, seed=7), marginals=[])
-
-    with pytest.raises(ParameterError, match="marginal"):
-        ProductMeasure(sampler=DigitalNetB2(1, seed=7), marginals=[object()])
-
-    with pytest.raises(ParameterError, match="AbstractDiscreteDistribution"):
-        ProductMeasure(sampler=object(), marginals=[Uniform(DummySampler(1))])
-
-    marginals = [Uniform(DummySampler(1))]
-    with pytest.raises(DimensionError, match="sum of marginal dimensions"):
-        ProductMeasure(sampler=DigitalNetB2(2, seed=7), marginals=marginals)
-
-
-def test_product_measure_rejects_non_dimension_preserving_marginal():
-    marginal = AcceptanceRejection(
-        DigitalNetB2(2, seed=7),
-        lambda x: np.ones(len(x)),
-        1.0,
-        1.0,
-    )
-
-    with pytest.raises(DimensionError, match="dimension-preserving"):
-        ProductMeasure(DigitalNetB2(2, seed=11), [marginal])
-
-
-def test_product_measure_spawn_preserves_marginal_blocks_and_replaces_outer_sampler():
-    marginals = [
-        Uniform(DummySampler(1), lower_bound=10.0, upper_bound=12.0),
-        Uniform(
-            DummySampler(2),
-            lower_bound=[20.0, 30.0],
-            upper_bound=[24.0, 36.0],
-        ),
-    ]
-    tm = ProductMeasure(sampler=DigitalNetB2(3, seed=41), marginals=marginals)
-
-    spawn = tm.spawn(s=1)[0]
-
-    assert isinstance(spawn, ProductMeasure)
-    assert spawn.d == 3
-    assert spawn.marginals == tm.marginals
-    assert spawn.discrete_distrib is not tm.discrete_distrib
-    assert np.array_equal(spawn.marginal_dimensions, np.array([1, 2]))
-
-    with pytest.raises(DimensionError):
-        tm.spawn(s=1, dimensions=4)
-
-
-def test_product_measure_does_not_use_marginal_dummy_sampler_values():
-    marginals = [
-        Uniform(DummySampler(1), lower_bound=0.0, upper_bound=2.0),
-        Uniform(DummySampler(1), lower_bound=10.0, upper_bound=12.0),
-    ]
-
-    with pytest.raises(ParameterError, match="construction placeholder"):
-        marginals[0].discrete_distrib(4)
-
-    tm = ProductMeasure(sampler=DigitalNetB2(2, seed=19), marginals=marginals)
-    x = tm(8)
-
-    assert x.shape == (8, 2)
-    assert np.all((0.0 <= x[:, 0]) & (x[:, 0] <= 2.0))
-    assert np.all((10.0 <= x[:, 1]) & (x[:, 1] <= 12.0))
-
-
-def test_product_measure_same_outer_seed_matches_different_outer_seed_changes():
-    marginals = [
-        Uniform(DummySampler(1), lower_bound=0.0, upper_bound=2.0),
-        Uniform(DummySampler(1), lower_bound=10.0, upper_bound=12.0),
-    ]
-
-    first = ProductMeasure(sampler=DigitalNetB2(2, seed=101), marginals=marginals)(16)
-    same_outer = ProductMeasure(sampler=DigitalNetB2(2, seed=101), marginals=marginals)(16)
-    different_outer = ProductMeasure(sampler=DigitalNetB2(2, seed=102), marginals=marginals)(16)
-
-    assert np.array_equal(first, same_outer)
-    assert not np.array_equal(first, different_outer)
-
-
-def test_product_measure_replication_means_close_to_uniform_targets():
-    n = 1024
-    r = 4
-    marginals = [
-        Uniform(DummySampler(1), lower_bound=0.0, upper_bound=2.0),
-        Uniform(DummySampler(1), lower_bound=10.0, upper_bound=12.0),
-    ]
-    tm = ProductMeasure(
-        sampler=DigitalNetB2(2, seed=101, replications=r),
-        marginals=marginals,
-    )
-
-    x = tm(n)
-    replication_means = x.mean(axis=1)
-
-    assert x.shape == (r, n, 2)
-    assert np.allclose(replication_means[:, 0], 1.0, atol=0.03)
-    assert np.allclose(replication_means[:, 1], 11.0, atol=0.03)
-
-
-def test_product_measure_with_scipywrapper_beta_marginal():
-    n = 64
-    marginals = [
-        Uniform(DummySampler(1), lower_bound=-1.0, upper_bound=1.0),
-        SciPyWrapper(DummySampler(1), stats.beta(a=2.0, b=5.0)),
-    ]
-    tm = ProductMeasure(sampler=DigitalNetB2(2, seed=71), marginals=marginals)
-
-    x = tm(n)
-
-    assert x.shape == (n, 2)
-    assert np.all((-1.0 <= x[:, 0]) & (x[:, 0] <= 1.0))
-    assert np.all((0.0 <= x[:, 1]) & (x[:, 1] <= 1.0))
-
-
-def test_product_measure_matches_equivalent_scipywrapper():
-    n = 128
-    seed = 55
-    scipy_marginals = [stats.norm(loc=0.0, scale=1.0), stats.gamma(a=2.0, scale=1.0)]
-    product_marginals = [
-        SciPyWrapper(DummySampler(1), scipy_marginals[0]),
-        SciPyWrapper(DummySampler(1), scipy_marginals[1]),
-    ]
-
-    product_samples = ProductMeasure(
-        sampler=DigitalNetB2(2, seed=seed),
-        marginals=product_marginals,
-    )(n)
-    scipy_samples = SciPyWrapper(DigitalNetB2(2, seed=seed), scipy_marginals)(n)
-
-    assert np.array_equal(product_samples, scipy_samples)
-
-
-def test_product_measure_with_gaussian_copula_marginal():
-    n = 64
-    copula = GaussianCopula(
-        DummySampler(2),
-        marginals=[stats.beta(a=2.0, b=5.0), stats.gamma(a=3.0, scale=1.0)],
-        correlation=[[1.0, 0.5], [0.5, 1.0]],
-    )
-    marginals = [copula, Uniform(DummySampler(1), lower_bound=10.0, upper_bound=12.0)]
-    tm = ProductMeasure(sampler=DigitalNetB2(3, seed=81), marginals=marginals)
-
-    x = tm(n)
-
-    assert x.shape == (n, 3)
-    assert np.all((0.0 <= x[:, 0]) & (x[:, 0] <= 1.0))
-    assert np.all(x[:, 1] >= 0.0)
-    assert np.all((10.0 <= x[:, 2]) & (x[:, 2] <= 12.0))
-
-
-def test_product_measure_recursive_transform_sampling_supported_but_weights_restricted():
-    recursive_marginal = Uniform(
-        Uniform(DummySampler(1), lower_bound=0.0, upper_bound=1.0),
-        lower_bound=2.0,
-        upper_bound=4.0,
-    )
-    direct_marginal = Uniform(DummySampler(1), lower_bound=10.0, upper_bound=12.0)
-    tm = ProductMeasure(
-        sampler=DigitalNetB2(2, seed=91),
-        marginals=[recursive_marginal, direct_marginal],
-    )
-
-    x = tm(16)
-
-    assert x.shape == (16, 2)
-    assert np.all((2.0 <= x[:, 0]) & (x[:, 0] <= 4.0))
-    assert np.all((10.0 <= x[:, 1]) & (x[:, 1] <= 12.0))
-    with pytest.raises(ParameterError, match="direct marginal"):
-        tm(16, return_weights=True)
diff --git a/test/test_accumulate_data.py b/test/test_sc_accumulate_data.py
similarity index 100%
rename from test/test_accumulate_data.py
rename to test/test_sc_accumulate_data.py
diff --git a/test/test_cubbayes_vec.py b/test/test_sc_cubbayes_vec.py
similarity index 100%
rename from test/test_cubbayes_vec.py
rename to test/test_sc_cubbayes_vec.py
diff --git a/test/test_stopping_criteria.py b/test/test_sc_stopping_criteria.py
similarity index 100%
rename from test/test_stopping_criteria.py
rename to test/test_sc_stopping_criteria.py
diff --git a/test/test_scipy_wrapper_custom.py b/test/test_scipy_wrapper_custom.py
deleted file mode 100644
index dd713e934..000000000
--- a/test/test_scipy_wrapper_custom.py
+++ /dev/null
@@ -1,302 +0,0 @@
-import warnings
-
-import pytest
-import numpy as np
-import scipy.stats as stats
-
-from qmcpy import DigitalNetB2, SciPyWrapper, StudentT, ZeroInflatedExpUniform
-
-from qmcpy.true_measure.triangular import TriangularDistribution
-from qmcpy.util import DimensionError, ParameterError
-
-
-MISSING_PDF_WARNING = "no 'pdf' or 'logpdf'"
-
-
-def _missing_pdf_warnings(caught):
-    return [
-        warning
-        for warning in caught
-        if issubclass(warning.category, UserWarning)
-        and MISSING_PDF_WARNING in str(warning.message)
-    ]
-
-
-def test_mvn_dependence_correlation_and_moment():
-    """
-    Check that passing a SciPy multivariate normal through SciPyWrapper
-    preserves correlation and the mixed moment E[X1 X2].
-    """
-    sampler = DigitalNetB2(2, seed=5)
-    rho_target = 0.7
-    cov = [[1.0, rho_target], [rho_target, 1.0]]
-    mvn = stats.multivariate_normal(mean=[0.0, 0.0], cov=cov)
-    tm_mvn = SciPyWrapper(sampler, scipy_distribs=mvn)
-
-    n = 4096
-    x = tm_mvn(n)
-
-    rho_hat = np.corrcoef(x.T)[0, 1]
-    est_moment = np.mean(x[:, 0] * x[:, 1])
-
-    assert np.isfinite(rho_hat)
-    assert np.isfinite(est_moment)
-
-    assert abs(rho_hat - rho_target) < 0.05
-    assert abs(est_moment - rho_target) < 0.05
-
-
-def test_triangular_custom_marginal_range_and_shape():
-    """
-    Make sure our custom triangular marginal behaves sensibly:
-    samples stay in the right interval and the empirical mean is close
-    to the analytic mean.
-    """
-    tri = TriangularDistribution(c=0.3, loc=-1.0, scale=2.0)
-    tm = SciPyWrapper(DigitalNetB2(1, seed=11), scipy_distribs=tri)
-
-    n = 4096
-    x = tm(n).ravel()
-
-    assert x.min() >= -1.1
-    assert x.max() <= 1.1
-
-    a = -1.0
-    b = 1.0
-    m = -1.0 + 0.3 * 2.0
-    true_mean = (a + b + m) / 3.0
-    emp_mean = x.mean()
-    assert abs(emp_mean - true_mean) < 0.05
-
-
-def test_zero_inflated_zero_rate():
-    """
-    Check that the zero-inflated exponential distribution preserves the
-    specified probability mass at X = 0.
-    """
-    p_zero = 0.4
-    sampler = DigitalNetB2(1, seed=17)
-    tm = ZeroInflatedExpUniform(sampler, p_zero=p_zero, lam=1.5)
-
-    n = 4096
-    samples = tm(n)
-    x = samples.ravel()
-    zero_rate = np.mean(x == 0.0)
-
-    assert samples.shape == (n, 1)
-    assert abs(zero_rate - p_zero) < 0.05
-
-
-def test_zero_inflated_replications_shape():
-    tm = ZeroInflatedExpUniform(
-        DigitalNetB2(1, seed=17, replications=2),
-        p_zero=0.4,
-        lam=1.5,
-    )
-
-    x = tm(8)
-
-    assert x.shape == (2, 8, 1)
-    assert np.all(x >= 0.0)
-
-
-@pytest.mark.parametrize("p_zero", [0.0, 1.0, -0.1, 1.1])
-def test_zero_inflated_rejects_invalid_p_zero(p_zero):
-    with pytest.raises(ParameterError, match="p_zero must be in"):
-        ZeroInflatedExpUniform(
-            DigitalNetB2(1, seed=17),
-            p_zero=p_zero,
-            lam=1.5,
-        )
-
-
-@pytest.mark.parametrize("lam", [0.0, -1.0])
-def test_zero_inflated_rejects_nonpositive_lam(lam):
-    with pytest.raises(ParameterError, match="lam must be positive"):
-        ZeroInflatedExpUniform(
-            DigitalNetB2(1, seed=17),
-            p_zero=0.4,
-            lam=lam,
-        )
-
-
-def test_zero_inflated_requires_one_dimensional_sampler():
-    with pytest.raises(
-        DimensionError,
-        match="requires a one-dimensional sampler",
-    ):
-        ZeroInflatedExpUniform(
-            DigitalNetB2(2, seed=17),
-            p_zero=0.4,
-            lam=1.5,
-        )
-
-
-def test_zero_inflated_inverse_transform_exact_values():
-    tm = ZeroInflatedExpUniform(
-        DigitalNetB2(1, seed=17),
-        p_zero=0.4,
-        lam=2.0,
-    )
-    u = np.array([[0.0], [0.2], [0.4], [0.7], [0.9]])
-
-    x = tm._transform(u)
-
-    assert x.shape == (5, 1)
-    assert np.array_equal(x[:3], np.zeros((3, 1)))
-    assert np.all(x[3:] > 0.0)
-
-    u_positive = u[3:, 0]
-    u_rescaled = (u_positive - 0.4) / 0.6
-    expected = -np.log1p(-u_rescaled) / 2.0
-    assert np.allclose(x[3:, 0], expected)
-
-
-def test_zero_inflated_inverse_transform_all_zero_branch():
-    tm = ZeroInflatedExpUniform(
-        DigitalNetB2(1, seed=17),
-        p_zero=0.4,
-        lam=2.0,
-    )
-    u = np.array([[0.0], [0.1], [0.4]])
-
-    x = tm._transform(u)
-
-    assert x.shape == (3, 1)
-    assert np.array_equal(x, np.zeros((3, 1)))
-
-
-def test_zero_inflated_inverse_transform_clips_one():
-    tm = ZeroInflatedExpUniform(
-        DigitalNetB2(1, seed=17),
-        p_zero=0.4,
-        lam=2.0,
-    )
-    u = np.array([[1.0]])
-
-    x = tm._transform(u)
-
-    assert x.shape == (1, 1)
-    assert np.isfinite(x).all()
-    assert x[0, 0] > 0.0
-
-
-def test_zero_inflated_construction_does_not_warn_about_missing_pdf():
-    with warnings.catch_warnings(record=True) as caught:
-        warnings.simplefilter("always")
-        tm = ZeroInflatedExpUniform(
-            DigitalNetB2(1, seed=17),
-            p_zero=0.4,
-            lam=1.5,
-        )
-
-    assert tm.d == 1
-    assert _missing_pdf_warnings(caught) == []
-
-
-def test_zero_inflated_sampling_does_not_warn_about_missing_pdf():
-    tm = ZeroInflatedExpUniform(DigitalNetB2(1, seed=17), p_zero=0.4, lam=1.5)
-
-    with warnings.catch_warnings(record=True) as caught:
-        warnings.simplefilter("always")
-        x = tm(8)
-
-    assert x.shape == (8, 1)
-    assert _missing_pdf_warnings(caught) == []
-
-
-def test_zero_inflated_return_weights_warns_once_for_missing_pdf():
-    tm = ZeroInflatedExpUniform(DigitalNetB2(1, seed=17), p_zero=0.4, lam=1.5)
-
-    with pytest.warns(UserWarning, match=MISSING_PDF_WARNING):
-        x, jac = tm(8, return_weights=True)
-
-    assert x.shape == (8, 1)
-    assert jac.shape == (8,)
-    assert np.allclose(jac, 1.0)
-
-    with warnings.catch_warnings(record=True) as caught:
-        warnings.simplefilter("always")
-        x_second, jac_second = tm(8, return_weights=True)
-
-    assert x_second.shape == (8, 1)
-    assert np.allclose(jac_second, 1.0)
-    assert _missing_pdf_warnings(caught) == []
-
-
-def test_zero_inflated_y_split_warns_and_uses_one_dimensional_interface():
-    with pytest.warns(DeprecationWarning, match="y_split"):
-        tm = ZeroInflatedExpUniform(
-            DigitalNetB2(1, seed=17),
-            p_zero=0.4,
-            lam=1.5,
-            y_split=0.5,
-        )
-
-    x = tm(4)
-
-    assert x.shape == (4, 1)
-    assert np.all(x >= 0.0)
-
-
-def test_zero_inflated_y_split_preserves_deprecated_two_dimensional_usage():
-    with pytest.warns(DeprecationWarning, match="2D zero-inflated"):
-        tm = ZeroInflatedExpUniform(
-            DigitalNetB2(2, seed=17),
-            p_zero=0.4,
-            lam=1.5,
-            y_split=0.5,
-        )
-
-    x = tm(16)
-
-    assert x.shape == (16, 2)
-    assert np.all(x[:, 0] >= 0.0)
-    assert np.all((0.0 <= x[:, 1]) & (x[:, 1] <= 1.0))
-    assert np.all(x[x[:, 0] == 0.0, 1] <= 0.5)
-    assert np.all(x[x[:, 0] > 0.0, 1] >= 0.5)
-
-
-def test_zero_inflated_y_split_preserves_replicated_two_dimensional_usage():
-    with pytest.warns(DeprecationWarning, match="2D zero-inflated"):
-        tm = ZeroInflatedExpUniform(
-            DigitalNetB2(2, seed=17, replications=2),
-            p_zero=0.4,
-            lam=1.5,
-            y_split=0.5,
-        )
-
-    x = tm(16)
-
-    assert x.shape == (2, 16, 2)
-    assert np.all(x[..., 0] >= 0.0)
-    assert np.all((0.0 <= x[..., 1]) & (x[..., 1] <= 1.0))
-    assert np.all(x[..., 1][x[..., 0] == 0.0] <= 0.5)
-    assert np.all(x[..., 1][x[..., 0] > 0.0] >= 0.5)
-
-
-def test_student_t_marginals_shape():
-    tm = SciPyWrapper(
-        sampler=DigitalNetB2(2, seed=5),
-        scipy_distribs=stats.t(df=5),
-    )
-    x = tm(8)
-    assert x.shape == (8, 2)
-
-
-def test_multivariate_student_t_joint_corr_and_cov():
-    if not hasattr(stats, "multivariate_t"):
-        pytest.skip("scipy.stats.multivariate_t not available in this SciPy version")
-
-    df = 5.0
-    rho = 0.8
-    loc = np.array([0.0, 0.0])
-    shape = np.array([[1.0, rho], [rho, 1.0]])
-
-    tm = StudentT(DigitalNetB2(2, seed=123), loc=loc, shape=shape, df=df)
-
-    n = 4096
-    x = tm(n)
-    emp_corr = np.corrcoef(x.T)[0, 1]
-
-    assert abs(emp_corr - rho) < 0.05
diff --git a/test/test_sr_check_links.py b/test/test_sr_check_links.py
new file mode 100644
index 000000000..49c148256
--- /dev/null
+++ b/test/test_sr_check_links.py
@@ -0,0 +1,198 @@
+import contextlib
+import io
+import shutil
+import ssl
+import sys
+import tempfile
+import unittest
+import urllib.error
+from pathlib import Path
+from unittest.mock import patch
+
+from scripts import check_links
+
+
+def _http_error(url, code):
+    return urllib.error.HTTPError(url, code, "test response", {}, None)
+
+
+class TestCheckLinks(unittest.TestCase):
+
+    def setUp(self):
+        self.tmp_path = Path(tempfile.mkdtemp())
+        self.addCleanup(shutil.rmtree, self.tmp_path, ignore_errors=True)
+
+    def _patch(self, target, name, value):
+        """monkeypatch.setattr equivalent: set now, auto-restore at test end."""
+        patcher = patch.object(target, name, value)
+        patcher.start()
+        self.addCleanup(patcher.stop)
+
+    def test_head_success_is_reachable(self):
+        with patch.object(check_links.urllib.request, "urlopen", return_value=object()) as urlopen:
+            self.assertIsNone(check_links._check_one("https://example.test", timeout=1))
+
+        self.assertEqual(urlopen.call_count, 1)
+        self.assertEqual(urlopen.call_args.args[0].get_method(), "HEAD")
+
+    def test_get_success_after_head_failure_is_reachable(self):
+        url = "https://example.test"
+        with patch.object(
+            check_links.urllib.request,
+            "urlopen",
+            side_effect=[_http_error(url, 405), object()],
+        ) as urlopen:
+            self.assertIsNone(check_links._check_one(url, timeout=1))
+
+        self.assertEqual(urlopen.call_count, 2)
+        self.assertEqual(urlopen.call_args_list[1].args[0].get_method(), "GET")
+
+    def test_not_found_and_gone_gets_are_broken(self):
+        for code in (404, 410):
+            with self.subTest(code=code):
+                url = f"https://example.test/{code}"
+                with patch.object(
+                    check_links.urllib.request,
+                    "urlopen",
+                    side_effect=[_http_error(url, code), _http_error(url, code)],
+                ):
+                    self.assertEqual(
+                        check_links._check_one(url, timeout=1),
+                        ("broken", f"{url} -- HTTP {code}"),
+                    )
+
+    def test_bot_block_and_rate_limit_are_warnings(self):
+        for code in (403, 429):
+            with self.subTest(code=code):
+                url = f"https://example.test/{code}"
+                with patch.object(
+                    check_links.urllib.request,
+                    "urlopen",
+                    side_effect=[_http_error(url, code), _http_error(url, code)],
+                ):
+                    severity, message = check_links._check_one(url, timeout=1)
+
+                self.assertEqual(severity, "warning")
+                self.assertIn(f"HTTP {code}", message)
+
+    def test_tls_and_timeout_failures_are_warnings(self):
+        failures = (
+            ssl.SSLCertVerificationError("certificate verify failed"),
+            TimeoutError("timed out"),
+        )
+        for failure in failures:
+            with self.subTest(failure=type(failure).__name__):
+                with patch.object(
+                    check_links.urllib.request,
+                    "urlopen",
+                    side_effect=[failure, failure],
+                ):
+                    severity, message = check_links._check_one(
+                        "https://example.test", timeout=1
+                    )
+
+                self.assertEqual(severity, "warning")
+                self.assertIn(str(failure), message)
+
+    def test_external_results_are_separated_and_duplicate_urls_checked_once(self):
+        (self.tmp_path / "page.html").write_text(
+            '<a href="https://example.test/missing">missing</a>'
+            '<a href="https://example.test/missing">duplicate</a>'
+            '<a href="https://example.test/blocked">blocked</a>',
+            encoding="utf-8",
+        )
+
+        def result_for(url, _timeout):
+            if url.endswith("/missing"):
+                return "broken", f"{url} -- HTTP 404"
+            return "warning", f"{url} -- HTTP 403"
+
+        with patch.object(check_links, "_check_one", side_effect=result_for) as check_one:
+            broken, warnings = check_links.check_external(self.tmp_path, workers=1)
+
+        self.assertEqual(check_one.call_count, 2)
+        self.assertEqual(
+            broken,
+            ["https://example.test/missing -- HTTP 404 (seen on page.html)"],
+        )
+        self.assertEqual(
+            warnings,
+            ["https://example.test/blocked -- HTTP 403 (seen on page.html)"],
+        )
+
+    def test_internal_links_strip_site_url_deployment_path(self):
+        target = self.tmp_path / "target"
+        target.mkdir()
+        (target / "index.html").write_text(
+            '<h2 id="section">Target</h2>', encoding="utf-8"
+        )
+        (self.tmp_path / "index.html").write_text(
+            '<a href="/QMCSoftware/target/">root-relative</a>'
+            '<a href="https://qmcsoftware.github.io/QMCSoftware/target/#section">absolute</a>',
+            encoding="utf-8",
+        )
+
+        self.assertEqual(
+            check_links.check_internal(
+                self.tmp_path, site_url="https://qmcsoftware.github.io/QMCSoftware/"
+            ),
+            [],
+        )
+
+    def test_external_check_skips_same_site_urls(self):
+        (self.tmp_path / "page.html").write_text(
+            '<a href="https://qmcsoftware.github.io/QMCSoftware/target/">same</a>'
+            '<a href="https://example.test/target/">external</a>',
+            encoding="utf-8",
+        )
+
+        with patch.object(check_links, "_check_one", return_value=None) as check_one:
+            broken, warnings = check_links.check_external(
+                self.tmp_path,
+                workers=1,
+                site_url="https://qmcsoftware.github.io/QMCSoftware/",
+            )
+
+        self.assertEqual(broken, [])
+        self.assertEqual(warnings, [])
+        self.assertEqual(check_one.call_count, 1)
+        self.assertEqual(check_one.call_args.args[0], "https://example.test/target/")
+
+    def test_external_warnings_do_not_make_main_fail(self):
+        self._patch(sys, "argv", ["check_links.py", str(self.tmp_path), "--external"])
+        self._patch(
+            check_links, "check_internal", lambda _site_dir, site_url=None: []
+        )
+        self._patch(
+            check_links,
+            "check_external",
+            lambda _site_dir, site_url=None: (
+                [],
+                ["https://example.test -- HTTP 403"],
+            ),
+        )
+
+        buf = io.StringIO()
+        with contextlib.redirect_stdout(buf):
+            self.assertEqual(check_links.main(), 0)
+        self.assertIn("0 broken link(s), 1 warning(s)", buf.getvalue())
+
+    def test_confirmed_external_breakage_makes_main_fail(self):
+        self._patch(sys, "argv", ["check_links.py", str(self.tmp_path), "--external"])
+        self._patch(
+            check_links, "check_internal", lambda _site_dir, site_url=None: []
+        )
+        self._patch(
+            check_links,
+            "check_external",
+            lambda _site_dir, site_url=None: (
+                ["https://example.test -- HTTP 404"],
+                [],
+            ),
+        )
+
+        self.assertEqual(check_links.main(), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/test/test_sr_check_removed_urls.py b/test/test_sr_check_removed_urls.py
new file mode 100644
index 000000000..57a30223d
--- /dev/null
+++ b/test/test_sr_check_removed_urls.py
@@ -0,0 +1,165 @@
+import contextlib
+import io
+import shutil
+import sys
+import tempfile
+import unittest
+import urllib.error
+from pathlib import Path
+from unittest.mock import patch
+
+from scripts import check_removed_urls as cru
+
+SITE = "https://qmcsoftware.github.io/QMCSoftware/"
+
+
+def _sitemap(*paths):
+    locs = "".join(f"<loc>{SITE}{path}</loc>" for path in paths)
+    return f'<?xml version="1.0" encoding="UTF-8"?><urlset>{locs}</urlset>'
+
+
+def _config(redirect_maps=None):
+    plugins = ["material/search", {"mkdocs-jupyter": {"execute": False}}]
+    if redirect_maps is not None:
+        plugins.append({"redirects": {"redirect_maps": redirect_maps}})
+    return {"site_url": SITE, "plugins": plugins}
+
+
+class TestCheckRemovedUrls(unittest.TestCase):
+
+    def setUp(self):
+        self.tmp_path = Path(tempfile.mkdtemp())
+        self.addCleanup(shutil.rmtree, self.tmp_path, ignore_errors=True)
+        self._last_out = ""
+
+    def _patch(self, target, name, value):
+        """monkeypatch.setattr equivalent: set now, auto-restore at test end."""
+        patcher = patch.object(target, name, value)
+        patcher.start()
+        self.addCleanup(patcher.stop)
+
+    def _run(self, sitemap_paths, redirect_maps=None, extra_argv=(), base=None):
+        """Run main() offline against a temp sitemap and a temp docs/ tree."""
+        base = self.tmp_path if base is None else base
+        docs = base / "docs"
+        docs.mkdir(parents=True)
+        (docs / "README.md").write_text("home", encoding="utf-8")
+        (docs / "good_practices.md").write_text("page", encoding="utf-8")
+        sitemap = base / "sitemap.xml"
+        sitemap.write_text(_sitemap(*sitemap_paths), encoding="utf-8")
+
+        self._patch(cru, "read_config", lambda *a, **k: _config(redirect_maps))
+        self._patch(sys, "argv", [
+            "check_removed_urls.py", "--sitemap", str(sitemap), "--docs-dir", str(docs),
+            *extra_argv,
+        ])
+        buf = io.StringIO()
+        with contextlib.redirect_stdout(buf):
+            code = cru.main()
+        self._last_out = buf.getvalue()
+        return code
+
+    def test_url_path_and_source_round_trip(self):
+        for source, url_path in [("blogs/scipywrapper/index.md", "blogs/scipywrapper/"),
+                                 ("good_practices.md", "good_practices/"),
+                                 ("demos/quickstart.ipynb", "demos/quickstart/"),
+                                 ("index.md", ""), ("README.md", "")]:
+            self.assertEqual(cru.url_path_for_source(source), url_path)
+
+        for source in ("README.md", "good_practices.md", "demos/quickstart.ipynb",
+                       "api/index.md"):
+            path = self.tmp_path / source
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text("page", encoding="utf-8")
+            self.assertTrue(
+                cru.source_exists(cru.url_path_for_source(source), self.tmp_path)
+            )
+        self.assertFalse(cru.source_exists("blogs/scipywrapper/", self.tmp_path))
+
+    def test_redirect_maps_reads_the_plugin_and_tolerates_its_absence(self):
+        entry = {"blogs/x/index.md": "https://qmcsoftware.org/blogs/x/"}
+        self.assertEqual(cru.redirect_maps(_config(entry)), entry)
+        self.assertEqual(cru.redirect_maps(_config()), {})
+        self.assertEqual(cru.redirect_maps({}), {})
+
+    def test_published_paths_separates_foreign_urls(self):
+        sitemap = _sitemap("", "good_practices/").replace(
+            "</urlset>", "<loc>https://example.test/other/</loc></urlset>")
+
+        self.assertEqual(
+            cru.published_paths(sitemap, SITE),
+            (["", "good_practices/"], ["https://example.test/other/"]),
+        )
+
+    def test_http_status_falls_back_to_get_when_head_is_unsupported(self):
+        url = "https://example.test"
+        error = urllib.error.HTTPError(url, 405, "test response", {}, None)
+        response = type("Response", (), {"status": 200, "__enter__": lambda s: s,
+                                         "__exit__": lambda s, *a: False})()
+        with patch.object(cru.urllib.request, "urlopen",
+                          side_effect=[error, response]) as urlopen:
+            self.assertEqual(cru.http_status(url, timeout=1), "200")
+
+        self.assertEqual(urlopen.call_count, 2)
+        self.assertEqual(urlopen.call_args_list[1].args[0].get_method(), "GET")
+
+    def test_removed_page_without_redirect_is_flagged(self):
+        code = self._run(["", "good_practices/", "blogs/scipywrapper/"])
+        out = self._last_out
+
+        self.assertEqual(code, 1)
+        self.assertIn("1 removed with no redirect", out)
+        self.assertIn(f"[ORPHAN]   {SITE}blogs/scipywrapper/", out)
+        self.assertIn("blogs/scipywrapper/index.md: <new URL or page>", out)
+
+    def test_removed_page_covered_by_a_redirect_passes(self):
+        code = self._run(
+            ["", "good_practices/", "blogs/scipywrapper/"],
+            redirect_maps={
+                "blogs/scipywrapper/index.md": "https://qmcsoftware.org/blogs/scipywrapper/"},
+        )
+        out = self._last_out
+
+        self.assertEqual(code, 0)
+        self.assertIn("0 removed with no redirect", out)
+        self.assertIn("[redirect]", out)
+        self.assertNotIn("[ORPHAN]", out)
+
+    def test_intact_site_passes(self):
+        self.assertEqual(self._run(["", "good_practices/"]), 0)
+        self.assertIn("2 still have a page source", self._last_out)
+
+    def test_verify_redirects_follows_the_target_status(self):
+        redirects = {"blogs/x/index.md": "https://qmcsoftware.org/blogs/x/"}
+        for status, expected_code in [("200", 0), ("404", 1)]:
+            with self.subTest(status=status):
+                self._patch(cru, "http_status", lambda *a, **k: status)
+                code = self._run(
+                    ["", "blogs/x/"],
+                    redirect_maps=redirects,
+                    extra_argv=("--verify-redirects",),
+                    base=self.tmp_path / status,
+                )
+                out = self._last_out
+
+                self.assertEqual(code, expected_code)
+                self.assertIn(status, out)
+                # The URL itself is covered, so a failure is the target, not an orphan.
+                self.assertNotIn("[ORPHAN]", out)
+
+    def test_unreachable_sitemap_fails_unless_offline_is_allowed(self):
+        self._patch(cru, "read_config", lambda *a, **k: _config())
+        argv = ["check_removed_urls.py", "--sitemap", str(self.tmp_path / "absent.xml")]
+
+        self._patch(sys, "argv", argv)
+        self.assertEqual(cru.main(), 1)
+
+        self._patch(sys, "argv", argv + ["--allow-offline"])
+        buf = io.StringIO()
+        with contextlib.redirect_stdout(buf):
+            self.assertEqual(cru.main(), 0)
+        self.assertIn("skipping the check", buf.getvalue())
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/test/test_sr_flatten_qmcpy_imports.py b/test/test_sr_flatten_qmcpy_imports.py
new file mode 100644
index 000000000..5a295121a
--- /dev/null
+++ b/test/test_sr_flatten_qmcpy_imports.py
@@ -0,0 +1,351 @@
+import json
+import shutil
+import tempfile
+import unittest
+from pathlib import Path
+
+from scripts.flatten_qmcpy_imports import (
+    _load_qmcpy_public_names,
+    flatten_imports,
+    main,
+)
+
+
+def _nested_import(module, imported):
+    return f"from {'qmcpy.' + module} import {imported}"
+
+
+class TestFlattenQmcpyImports(unittest.TestCase):
+
+    def setUp(self):
+        self.tmp_path = Path(tempfile.mkdtemp())
+        self.addCleanup(shutil.rmtree, self.tmp_path, ignore_errors=True)
+
+    def test_flatten_imports_basic(self):
+        source = (
+            _nested_import("integrand", "Keister")
+            + "\n"
+            + _nested_import("discrete_distribution.lattice", "Lattice as LD")
+            + "\nfrom qmcpy import DigitalNetB2\nimport qmcpy.util\n"
+        ).encode()
+
+        updated, count = flatten_imports(
+            source, frozenset({"DigitalNetB2", "Keister", "Lattice"})
+        )
+
+        self.assertEqual(count, 3)
+        self.assertEqual(
+            updated,
+            (
+                b"from qmcpy import DigitalNetB2, Keister, Lattice as LD\n"
+                b"import qmcpy.util\n"
+            ),
+        )
+
+    def test_flatten_preserves_private(self):
+        source = (
+            _nested_import("_internal._helpers", "PublicHelper")
+            + "\n"
+            + _nested_import(
+                "true_measure.uniform_triangle",
+                "UniformTriangle, _UniformTriangleAdapter",
+            )
+            + "\n"
+            + _nested_import(
+                "true_measure.copula",
+                "(\n    AbstractCopula,\n    _validate_dimension,\n)",
+            )
+            + "\n"
+            + _nested_import("integrand", "Keister")
+            + "\n"
+        ).encode()
+
+        updated, count = flatten_imports(source, frozenset({"Keister"}))
+
+        self.assertEqual(count, 1)
+        self.assertEqual(
+            updated,
+            source.replace(
+                _nested_import("integrand", "Keister").encode(),
+                b"from qmcpy import Keister",
+            ),
+        )
+
+    def test_private_module_splits_groups(self):
+        source = (
+            b"from qmcpy import Zeta\n"
+            b"from qmcpy._internal._helpers import PublicHelper\n"
+            b"from qmcpy import Alpha\n"
+        )
+
+        updated, count = flatten_imports(source)
+
+        self.assertEqual(count, 0)
+        self.assertEqual(updated, source)
+
+    def test_flatten_preserves_util_imports(self):
+        source = (
+            b"from qmcpy.util import ParameterError\n"
+            b"from qmcpy.util.transforms import tf_exp\n"
+        )
+
+        updated, count = flatten_imports(source, frozenset({"ParameterError", "tf_exp"}))
+
+        self.assertEqual((updated, count), (source, 0))
+
+    def test_flatten_keeps_nonpublic_names(self):
+        source = b"from qmcpy.stopping_criterion.pf_gp_ci import PFGPCIData\n"
+
+        updated, count = flatten_imports(source, frozenset({"PFGPCI"}))
+
+        self.assertEqual((updated, count), (source, 0))
+
+    def test_flatten_no_public_api_noop(self):
+        source = (_nested_import("integrand", "Keister") + "\n").encode()
+
+        updated, count = flatten_imports(source)
+
+        self.assertEqual((updated, count), (source, 0))
+
+    def test_flatten_preserve_str_literals(self):
+        source = b'text = """\nfrom qmcpy.integrand import Keister\n"""\n'
+
+        updated, count = flatten_imports(source, frozenset({"Keister"}))
+
+        self.assertEqual(count, 0)
+        self.assertEqual(updated, source)
+
+    def test_python_string_protection_applies_to_every_rewrite_stage(self):
+        string_body = (
+            b'text = """\n'
+            b"from qmcpy.integrand import Keister\n"
+            b"from qmcpy import Zeta,Beta\n"
+            b"from qmcpy import Alpha\n"
+            b"from qmcpy import *\n"
+            b"from qmcpy import *\n"
+            b'"""\n'
+        )
+        source = string_body + b"from qmcpy.integrand import Keister\n"
+
+        updated, count = flatten_imports(source, frozenset({"Keister"}))
+
+        self.assertEqual(count, 1)
+        self.assertEqual(updated, string_body + b"from qmcpy import Keister\n")
+
+    def test_python_tokenize_failure_is_fail_closed(self):
+        source = b'"""unterminated\nfrom qmcpy.integrand import Keister\n'
+
+        self.assertEqual(
+            flatten_imports(source, frozenset({"Keister"})), (source, 0)
+        )
+
+    def test_flatten_skip_star_expansion(self):
+        source = (
+            b"from qmcpy import *\n\n"
+            b"def f(Lattice):\n"
+            b"    return Lattice\n\n"
+            b"y = Keister(dimension=2)\n"
+            b"x = Lattice(dimension=2)\n"
+        )
+
+        updated, count = flatten_imports(source, frozenset({"Keister", "Lattice"}))
+
+        self.assertEqual(count, 0)
+        self.assertEqual(updated, source)
+
+    def test_notebook_star_dedup(self):
+        notebook = {
+            "cells": [
+                {
+                    "cell_type": "code",
+                    "source": [
+                        _nested_import("integrand", "*") + "\n",
+                        _nested_import("true_measure", "*"),
+                    ],
+                }
+            ]
+        }
+        source = json.dumps(notebook, indent=1).encode()
+
+        updated, count = flatten_imports(source, frozenset({"Keister"}))
+
+        self.assertEqual(count, 3)
+        self.assertEqual(
+            json.loads(updated)["cells"][0]["source"], ["from qmcpy import *"]
+        )
+
+    def test_named_imports_merge_sort(self):
+        source = (
+            b"from qmcpy import Zeta,Beta\n"
+            b"from qmcpy import Alpha\n"
+            b"\n"
+            b"from qmcpy import Gamma\n"
+        )
+
+        updated, count = flatten_imports(source)
+
+        self.assertEqual(count, 1)
+        self.assertEqual(
+            updated,
+            (
+                b"from qmcpy import Alpha, Beta, Zeta\n"
+                b"\n"
+                b"from qmcpy import Gamma\n"
+            ),
+        )
+        self.assertEqual(flatten_imports(updated), (updated, 0))
+
+    def test_merge_paren_and_single_line(self):
+        source = b"""from qmcpy import (
+    KernelDigShiftInvar,
+    KernelDigShiftInvarAdaptiveAlpha,
+    KernelDigShiftInvarCombined,
+    KernelShiftInvar,
+    KernelShiftInvarCombined,
+)
+from qmcpy import tf_exp_eps, tf_exp_eps_inv
+"""
+
+        updated, count = flatten_imports(source)
+
+        self.assertEqual(count, 1)
+        self.assertEqual(
+            updated,
+            b"""from qmcpy import (
+    KernelDigShiftInvar,
+    KernelDigShiftInvarAdaptiveAlpha,
+    KernelDigShiftInvarCombined,
+    KernelShiftInvar,
+    KernelShiftInvarCombined,
+    tf_exp_eps,
+    tf_exp_eps_inv,
+)
+""",
+        )
+        self.assertEqual(flatten_imports(updated), (updated, 0))
+
+    def test_merge_same_scope_only(self):
+        source = (
+            b"if enabled:\n"
+            b"    from qmcpy import Zeta\n"
+            b"    from qmcpy import Alpha as First\n"
+            b"else:\n"
+            b"    from qmcpy import Beta\n"
+            b"from qmcpy import _Private\n"
+            b"from qmcpy import Gamma  # keep this comment\n"
+        )
+
+        updated, count = flatten_imports(source)
+
+        self.assertEqual(count, 1)
+        self.assertEqual(
+            updated,
+            (
+                b"if enabled:\n"
+                b"    from qmcpy import Alpha as First, Zeta\n"
+                b"else:\n"
+                b"    from qmcpy import Beta\n"
+                b"from qmcpy import _Private\n"
+                b"from qmcpy import Gamma  # keep this comment\n"
+            ),
+        )
+
+    def test_notebook_named_merge(self):
+        notebook = {
+            "cells": [
+                {
+                    "cell_type": "code",
+                    "source": [
+                        "from qmcpy import Zeta\n",
+                        "from qmcpy import Alpha,Beta\n",
+                        "print(Alpha)\n",
+                    ],
+                }
+            ]
+        }
+        source = json.dumps(notebook, indent=1).encode()
+
+        updated, count = flatten_imports(source)
+
+        self.assertEqual(count, 1)
+        self.assertEqual(
+            json.loads(updated)["cells"][0]["source"],
+            [
+                "from qmcpy import Alpha, Beta, Zeta\n",
+                "print(Alpha)\n",
+            ],
+        )
+        self.assertEqual(flatten_imports(updated), (updated, 0))
+
+    def test_notebook_flattens_nested_imports_only_in_code_cells(self):
+        nested_import = _nested_import("integrand", "Keister") + "\n"
+        metadata_import = _nested_import("true_measure", "Gaussian") + "\n"
+        string_literal = f'text = "{nested_import.rstrip()}"\n'
+        multiline_string = ['text = """\n', nested_import, '"""\n']
+        notebook = {
+            "metadata": {"source": [metadata_import]},
+            "cells": [
+                {"cell_type": "markdown", "source": [nested_import]},
+                {"cell_type": "code", "source": [nested_import]},
+                {"cell_type": "code", "source": [string_literal]},
+                {"cell_type": "code", "source": multiline_string},
+            ]
+        }
+        source = json.dumps(notebook, indent=1).encode()
+
+        updated, count = flatten_imports(source, frozenset({"Keister"}))
+
+        cells = json.loads(updated)["cells"]
+        self.assertEqual(count, 1)
+        self.assertEqual(
+            json.loads(updated)["metadata"]["source"], [metadata_import]
+        )
+        self.assertEqual(cells[0]["source"], [nested_import])
+        self.assertEqual(cells[1]["source"], ["from qmcpy import Keister\n"])
+        self.assertEqual(cells[2]["source"], [string_literal])
+        self.assertEqual(cells[3]["source"], multiline_string)
+        self.assertEqual(
+            flatten_imports(updated, frozenset({"Keister"})), (updated, 0)
+        )
+
+    def test_markdown_import_examples_are_flattened(self):
+        path = self.tmp_path / "example.md"
+        path.write_bytes(
+            b'Example with unmatched prose delimiter: """\n\n'
+            b"```python\n"
+            b"from qmcpy.integrand import Keister\n"
+            b"```\n"
+        )
+
+        self.assertEqual(main([str(path)]), 0)
+        self.assertIn(b"from qmcpy import Keister", path.read_bytes())
+
+    def test_check_mode_no_write(self):
+        path = self.tmp_path / "example.py"
+        original = (_nested_import("true_measure", "Gaussian") + "\n").encode()
+        path.write_bytes(original)
+
+        self.assertEqual(main(["--check", str(path)]), 1)
+        self.assertEqual(path.read_bytes(), original)
+
+        self.assertEqual(main([str(path)]), 0)
+        self.assertEqual(path.read_bytes(), b"from qmcpy import Gaussian\n")
+        self.assertEqual(main(["--check", str(path)]), 0)
+
+    def test_public_names_optional_free_stable(self):
+        repository_root = Path(__file__).resolve().parent.parent
+        names = _load_qmcpy_public_names(repository_root)
+
+        self.assertIsNotNone(names)
+        self.assertIn("Gaussian", names)
+        self.assertIn("Keister", names)
+        # Optional dependencies are blocked in the probe context, so fallback
+        # exports are part of the deterministic name set.
+        self.assertIn("PFGPCI", names)
+        # Helpers that are deliberately not part of the top-level API.
+        self.assertNotIn("PFGPCIData", names)
+        self.assertNotIn("TriangularDistribution", names)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/test/test_sr_install_mpmc_pyg.py b/test/test_sr_install_mpmc_pyg.py
new file mode 100644
index 000000000..25e810ec1
--- /dev/null
+++ b/test/test_sr_install_mpmc_pyg.py
@@ -0,0 +1,92 @@
+"""Tests for the platform-specific MPMC dependency installer."""
+
+import subprocess
+import unittest
+from types import SimpleNamespace
+from unittest.mock import patch
+
+from qmcpy.util import install_mpmc_pyg
+
+
+def _torch(version="2.12.1+cpu", cuda=None, hip=None):
+    return SimpleNamespace(
+        __version__=version,
+        version=SimpleNamespace(cuda=cuda, hip=hip),
+    )
+
+
+class TestInstallMPMCPyG(unittest.TestCase):
+
+    def test_torch_versions_include_baseline_fallback(self):
+        """Wheel lookup tries an exact patch release, then its minor baseline."""
+        self.assertEqual(
+            install_mpmc_pyg.torch_versions("2.12.1+cpu"), ["2.12.1", "2.12.0"]
+        )
+        self.assertEqual(install_mpmc_pyg.torch_versions("2.12.0"), ["2.12.0"])
+
+        with self.assertRaisesRegex(RuntimeError, "Unable to parse torch version"):
+            install_mpmc_pyg.torch_versions("development")
+
+    def test_accelerator_tag(self):
+        """PyTorch build metadata maps to the expected PyG wheel tag."""
+        cases = [
+            (_torch(), "cpu"),
+            (_torch(cuda="12.6"), "cu126"),
+            (_torch(cuda="13.0.1"), "cu130"),
+        ]
+        for torch_module, expected in cases:
+            with self.subTest(expected=expected):
+                self.assertEqual(
+                    install_mpmc_pyg.accelerator_tag(torch_module), expected
+                )
+
+    def test_accelerator_tag_rejects_rocm(self):
+        """The installer directs unsupported ROCm users to upstream guidance."""
+        with self.assertRaisesRegex(RuntimeError, "does not currently support ROCm"):
+            install_mpmc_pyg.accelerator_tag(_torch(hip="6.3"))
+
+    def test_main_retries_with_torch_minor_baseline(self):
+        """A missing exact wheel page falls back to the minor baseline page."""
+        calls = []
+
+        def fake_run(*args):
+            calls.append(args)
+            if args[-1].endswith("torch-2.12.1+cpu.html"):
+                raise subprocess.CalledProcessError(1, args)
+
+        with patch.object(install_mpmc_pyg, "run", fake_run):
+            install_mpmc_pyg.main(_torch())
+
+        self.assertEqual(calls[0][-1], "torch-geometric>=2.6.1")
+        self.assertEqual(
+            calls[1][-1], "https://data.pyg.org/whl/torch-2.12.1+cpu.html"
+        )
+        self.assertEqual(
+            calls[2][-1], "https://data.pyg.org/whl/torch-2.12.0+cpu.html"
+        )
+        self.assertIn("--only-binary", calls[1])
+
+    def test_main_explains_that_torch_must_be_installed(self):
+        """Running the helper before installing the extra gives a useful error."""
+        def missing_torch(_name):
+            raise ModuleNotFoundError("No module named 'torch'", name="torch")
+
+        with patch.object(
+            install_mpmc_pyg.importlib, "import_module", missing_torch
+        ):
+            with self.assertRaisesRegex(RuntimeError, r"install 'qmcpy\[mpmc\]'"):
+                install_mpmc_pyg.main()
+
+    def test_main_reports_missing_wheel(self):
+        """Exhausting candidate wheel pages reports the build that failed."""
+        def fail_pyg_lib(*args):
+            if "pyg_lib>=0.6.0" in args:
+                raise subprocess.CalledProcessError(1, args)
+
+        with patch.object(install_mpmc_pyg, "run", fail_pyg_lib):
+            with self.assertRaisesRegex(RuntimeError, r"torch 2\.12\.1\+cpu \(cpu\)"):
+                install_mpmc_pyg.main(_torch())
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/test/test_sr_mpmc_optional_imports.py b/test/test_sr_mpmc_optional_imports.py
new file mode 100644
index 000000000..4628f2c93
--- /dev/null
+++ b/test/test_sr_mpmc_optional_imports.py
@@ -0,0 +1,114 @@
+import ast
+import builtins
+import unittest
+from pathlib import Path
+
+
+def _execute_optional_import(blocked_import):
+    repository_root = Path(__file__).resolve().parent.parent
+    init_path = repository_root / "qmcpy" / "__init__.py"
+    init_tree = ast.parse(init_path.read_text())
+    optional_import = next(
+        node
+        for node in init_tree.body
+        if isinstance(node, ast.Try)
+        and any(
+            isinstance(statement, ast.ImportFrom)
+            and statement.module == "discrete_distribution.mpmc"
+            for statement in node.body
+        )
+    )
+
+    import qmcpy
+
+    real_import = builtins.__import__
+
+    def guarded_import(name, globals=None, locals=None, fromlist=(), level=0):
+        missing_module = blocked_import(name, fromlist, level)
+        if missing_module is not None:
+            raise ModuleNotFoundError(
+                "blocked optional dependency",
+                name=missing_module,
+            )
+        return real_import(name, globals, locals, fromlist, level)
+
+    test_builtins = vars(builtins).copy()
+    test_builtins["__import__"] = guarded_import
+    namespace = {"__builtins__": test_builtins, "__package__": "qmcpy"}
+    module = ast.Module(body=[optional_import], type_ignores=[])
+    exec(compile(module, str(init_path), "exec"), namespace)
+    return namespace
+
+
+class TestMPMCOptionalImports(unittest.TestCase):
+
+    def test_mpmc_utils_remain_available_without_pyg(self):
+        try:
+            import torch  # noqa: F401
+        except ImportError:
+            self.skipTest("torch not available")
+
+        def block_pyg_models(name, fromlist, level):
+            if level == 1 and name == "discrete_distribution.mpmc.models":
+                return "torch_geometric"
+            return None
+
+        namespace = _execute_optional_import(block_pyg_models)
+
+        import qmcpy
+
+        self.assertIs(namespace["mpmc_utils"], qmcpy.mpmc_utils)
+        self.assertEqual(
+            namespace["mpmc_utils"].__name__,
+            "qmcpy.discrete_distribution.mpmc.utils",
+        )
+        self.assertNotIn("utils", namespace)
+
+        with self.assertRaisesRegex(
+            ModuleNotFoundError, "MPMC_net.*torch_geometric"
+        ) as cm:
+            namespace["MPMC_net"]()
+        self.assertEqual(cm.exception.name, "torch_geometric")
+
+    def test_mpmc_placeholders_report_missing_torch(self):
+        def block_torch_utils(name, fromlist, level):
+            if (
+                level == 1
+                and name == "discrete_distribution.mpmc"
+                and "utils" in fromlist
+            ):
+                return "torch"
+            return None
+
+        namespace = _execute_optional_import(block_torch_utils)
+
+        with self.assertRaisesRegex(ModuleNotFoundError, "mpmc_utils.*torch") as cm:
+            namespace["mpmc_utils"].L2star
+        self.assertEqual(cm.exception.name, "torch")
+
+        with self.assertRaisesRegex(ModuleNotFoundError, "MPMC_net.*torch") as cm:
+            namespace["MPMC_net"]()
+        self.assertEqual(cm.exception.name, "torch")
+
+    def test_mpmc_placeholder_missing_torch_scatter(self):
+        try:
+            import torch  # noqa: F401
+        except ImportError:
+            self.skipTest("torch not available")
+
+        def block_torch_scatter(name, fromlist, level):
+            if level == 1 and name == "discrete_distribution.mpmc.models":
+                return "torch_scatter"
+            return None
+
+        namespace = _execute_optional_import(block_torch_scatter)
+
+        with self.assertRaisesRegex(
+            ModuleNotFoundError, "MPMC_net.*torch_scatter"
+        ) as cm:
+            namespace["MPMC_net"]()
+        self.assertEqual(cm.exception.name, "torch_scatter")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/test/test_sr_unwrap_markdown.py b/test/test_sr_unwrap_markdown.py
new file mode 100644
index 000000000..4115d9ad2
--- /dev/null
+++ b/test/test_sr_unwrap_markdown.py
@@ -0,0 +1,99 @@
+import unittest
+
+from scripts.unwrap_markdown import unwrap_markdown_text
+
+
+class TestUnwrapMarkdown(unittest.TestCase):
+
+    def test_unwraps_list_item_continuations(self):
+        cases = [
+            (
+                "- unordered first\n  unordered second\n",
+                "- unordered first unordered second\n",
+            ),
+            (
+                "- [ ] task first\n  task second\n",
+                "- [ ] task first task second\n",
+            ),
+            (
+                "10. ordered first\n    ordered second\n",
+                "10. ordered first ordered second\n",
+            ),
+        ]
+        for source, expected in cases:
+            with self.subTest(source=source):
+                updated = unwrap_markdown_text(source)
+
+                self.assertEqual(updated, expected)
+                self.assertEqual(unwrap_markdown_text(updated), updated)
+
+    def test_unwraps_adjacent_and_nested_list_items_separately(self):
+        source = (
+            "- parent first\n"
+            "  parent second\n"
+            "  - child first\n"
+            "    child second\n"
+            "- sibling first\n"
+            "  sibling second\n"
+        )
+
+        self.assertEqual(
+            unwrap_markdown_text(source),
+            (
+                "- parent first parent second\n"
+                "  - child first child second\n"
+                "- sibling first sibling second\n"
+            ),
+        )
+
+    def test_preserves_list_item_blocks_and_explicit_hard_breaks(self):
+        source = (
+            "- first paragraph\n"
+            "  continuation\n"
+            "\n"
+            "  second paragraph\n"
+            "  continuation\n"
+            "\n"
+            "- item before code\n"
+            "      indented code\n"
+            "\n"
+            "- explicit hard break  \n"
+            "  remains separate\n"
+        )
+
+        self.assertEqual(
+            unwrap_markdown_text(source),
+            (
+                "- first paragraph continuation\n"
+                "\n"
+                "  second paragraph continuation\n"
+                "\n"
+                "- item before code\n"
+                "      indented code\n"
+                "\n"
+                "- explicit hard break  \n"
+                "  remains separate\n"
+            ),
+        )
+
+    def test_unwraps_ordinary_paragraphs(self):
+        self.assertEqual(
+            unwrap_markdown_text("first line\nsecond line\n"),
+            "first line second line\n",
+        )
+
+    def test_preserves_horizontal_rules(self):
+        for rule in ["- - -", "* * *", "_ _ _"]:
+            with self.subTest(rule=rule):
+                source = f"{rule}\nfollowing paragraph\n"
+
+                self.assertEqual(unwrap_markdown_text(source), source)
+
+    def test_preserves_indented_code_that_looks_like_a_list(self):
+        source = "    - code first\n      code second\n"
+
+        self.assertEqual(unwrap_markdown_text(source), source)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/test/test_tm_copulas.py b/test/test_tm_copulas.py
new file mode 100644
index 000000000..ed29969fb
--- /dev/null
+++ b/test/test_tm_copulas.py
@@ -0,0 +1,1271 @@
+import unittest
+import warnings
+
+import numpy as np
+import scipy.stats as stats
+
+from qmcpy import (
+    AbstractCopula,
+    ClaytonCopula,
+    DigitalNetB2,
+    FrankCopula,
+    GaussianCopula,
+    GumbelCopula,
+    StudentTCopula,
+)
+
+from qmcpy.true_measure.copula import (
+    AbstractCopula as ModuleAbstractCopula,
+    _apply_marginal_ppfs,
+    _build_marginal_range,
+    _clip_unit_interval,
+    _marginal_cdfs_and_logpdf,
+    _validate_correlation_matrix,
+    _validate_dimension,
+    _validate_marginals,
+)
+
+from qmcpy.util import DimensionError, MethodImplementationError, ParameterError
+
+
+class PPFOnlyMarginal:
+    def ppf(self, u):
+        return np.asarray(u, dtype=float)
+
+
+class NonCallablePPFMarginal:
+    ppf = 1.0
+
+
+class UnitPDFMarginal:
+    def ppf(self, u):
+        return np.asarray(u, dtype=float)
+
+    def cdf(self, x):
+        return np.asarray(x, dtype=float)
+
+    def pdf(self, x):
+        return np.ones_like(np.asarray(x, dtype=float))
+
+
+class CDFOnlyMarginal(PPFOnlyMarginal):
+    def cdf(self, x):
+        return np.asarray(x, dtype=float)
+
+
+class BadIntervalMarginal(PPFOnlyMarginal):
+    def interval(self, confidence):
+        raise ValueError("interval unavailable")
+
+
+class BadRangeMarginal:
+    def ppf(self, u):
+        raise ValueError("ppf unavailable")
+
+
+def _equicorrelation(d, rho):
+    corr = np.full((d, d), rho, dtype=float)
+    np.fill_diagonal(corr, 1.0)
+    return corr
+
+
+def _make_copula(copula_cls, dimension=2, marginals=None, correlation=None, seed=7):
+    if marginals is None:
+        marginals = [stats.norm()] * dimension
+    if correlation is None:
+        correlation = np.eye(dimension)
+
+    kwargs = {}
+    if copula_cls is StudentTCopula:
+        kwargs["df"] = 4
+    if copula_cls is ClaytonCopula:
+        kwargs["theta"] = 2.0
+    if copula_cls is FrankCopula:
+        kwargs["theta"] = 5.0
+    if copula_cls is GumbelCopula:
+        kwargs["theta"] = 2.0
+
+    common = {
+        "sampler": DigitalNetB2(dimension, seed=seed),
+        "marginals": marginals,
+        **kwargs,
+    }
+    if copula_cls in [ClaytonCopula, FrankCopula, GumbelCopula]:
+        return copula_cls(**common)
+    return copula_cls(correlation=correlation, **common)
+
+
+class TestAbstractCopulaAndHelpers(unittest.TestCase):
+
+    def test_abstract_copula_is_importable_from_public_module_path(self):
+        self.assertIs(ModuleAbstractCopula, AbstractCopula)
+
+    def test_public_api_imports_and_normal_usage(self):
+        for copula_cls in [
+            GaussianCopula,
+            StudentTCopula,
+            ClaytonCopula,
+            FrankCopula,
+            GumbelCopula,
+        ]:
+            with self.subTest(copula_cls=copula_cls.__name__):
+                self.assertTrue(issubclass(copula_cls, AbstractCopula))
+
+                tm = _make_copula(copula_cls)
+                x = tm(8)
+                x_gen = tm.gen_samples(8)
+                v = tm.gen_copula_samples(8)
+
+                self.assertEqual(x.shape, (8, 2))
+                self.assertEqual(x_gen.shape, (8, 2))
+                self.assertEqual(v.shape, (8, 2))
+                self.assertTrue(np.all(np.isfinite(x)))
+                self.assertTrue(np.all(np.isfinite(x_gen)))
+                self.assertTrue(np.all((0 <= v) & (v <= 1)))
+
+    def test_abstract_copula_rejects_unimplemented_transform(self):
+        tm = AbstractCopula(
+            DigitalNetB2(2, seed=101),
+            marginals=[stats.uniform(), stats.uniform()],
+        )
+
+        with self.assertRaises(MethodImplementationError):
+            tm.copula_transform(np.full((3, 2), 0.5))
+
+    def test_abstract_copula_rejects_invalid_sampler(self):
+        with self.assertRaisesRegex(ParameterError, "sampler"):
+            AbstractCopula(object(), marginals=[stats.uniform()])
+
+    def test_validate_marginals_error_branches(self):
+        with self.assertRaisesRegex(ParameterError, "marginals"):
+            _validate_marginals(None)
+
+        with self.assertRaisesRegex(ParameterError, "at least one"):
+            _validate_marginals([])
+
+        with self.assertRaisesRegex(ParameterError, "ppf"):
+            _validate_marginals([NonCallablePPFMarginal()])
+
+    def test_validate_dimension_error_branches(self):
+        with self.assertRaisesRegex(DimensionError, "integer dimension"):
+            _validate_dimension(object(), [stats.uniform()])
+
+        with self.assertRaisesRegex(DimensionError, "marginals"):
+            _validate_dimension(3, [stats.uniform(), stats.uniform()])
+
+    def test_apply_marginal_ppfs_clips_endpoints_and_checks_dimension(self):
+        transformed = _apply_marginal_ppfs(
+            np.array([[0.0, 1.0], [1.0, 0.0]]),
+            [stats.norm(), stats.norm()],
+        )
+
+        self.assertEqual(transformed.shape, (2, 2))
+        self.assertTrue(np.all(np.isfinite(transformed)))
+
+        with self.assertRaisesRegex(DimensionError, "marginals"):
+            _apply_marginal_ppfs(np.full((2, 3), 0.5), [stats.uniform(), stats.uniform()])
+
+    def test_marginal_range_falls_back_when_interval_or_ppf_fails(self):
+        ranges = _build_marginal_range([BadIntervalMarginal(), BadRangeMarginal()])
+
+        self.assertEqual(ranges.shape, (2, 2))
+        self.assertTrue(np.all(np.isfinite(ranges[0])))
+        np.testing.assert_allclose(ranges[1], [-np.inf, np.inf])
+
+    def test_marginal_cdfs_and_logpdf_pdf_branch_and_errors(self):
+        x = np.array([[0.25, 0.75], [0.4, 0.6]])
+        u, log_density = _marginal_cdfs_and_logpdf(
+            x,
+            [UnitPDFMarginal(), UnitPDFMarginal()],
+        )
+
+        np.testing.assert_allclose(u, x)
+        np.testing.assert_allclose(log_density, np.zeros(2))
+
+        with self.assertRaisesRegex(ParameterError, "cdf"):
+            _marginal_cdfs_and_logpdf(x, [PPFOnlyMarginal(), UnitPDFMarginal()])
+
+        with self.assertRaisesRegex(ParameterError, "pdf"):
+            _marginal_cdfs_and_logpdf(x, [CDFOnlyMarginal(), UnitPDFMarginal()])
+
+    def test_validate_correlation_matrix_rejects_nonfinite_values(self):
+        with self.assertRaisesRegex(ValueError, "finite"):
+            _validate_correlation_matrix([[1.0, np.nan], [np.nan, 1.0]], 2)
+
+    def test_clip_unit_interval_uses_machine_epsilon(self):
+        clipped = _clip_unit_interval(np.array([0.0, 0.5, 1.0]))
+        eps = np.finfo(float).eps
+
+        np.testing.assert_allclose(clipped, [eps, 0.5, 1.0 - eps])
+
+    def test_copula_transform_outputs_dependent_uniforms_in_unit_cube(self):
+        for copula_cls in [GaussianCopula, StudentTCopula, ClaytonCopula, GumbelCopula, FrankCopula]:
+            with self.subTest(copula_cls=copula_cls.__name__):
+                tm = _make_copula(copula_cls, dimension=3)
+                u = np.array(
+                    [
+                        [0.1, 0.3, 0.7],
+                        [0.5, 0.5, 0.5],
+                        [0.9, 0.8, 0.2],
+                    ]
+                )
+
+                v = tm.copula_transform(u)
+
+                self.assertEqual(v.shape, u.shape)
+                self.assertTrue(np.all(np.isfinite(v)))
+                self.assertTrue(np.all((0.0 <= v) & (v <= 1.0)))
+
+    def test_copula_sample_shapes_are_preserved(self):
+        for copula_cls, dimension in [
+            (GaussianCopula, 3),
+            (StudentTCopula, 3),
+            (ClaytonCopula, 3),
+            (FrankCopula, 3),
+            (GumbelCopula, 3),
+        ]:
+            with self.subTest(copula_cls=copula_cls.__name__, dimension=dimension):
+                tm = _make_copula(copula_cls, dimension=dimension, seed=9)
+
+                one = tm(1)
+                many = tm(8)
+                batched_transform = tm._transform(np.full((2, 3, dimension), 0.5))
+
+                self.assertEqual(one.shape, (1, dimension))
+                self.assertEqual(many.shape, (8, dimension))
+                self.assertEqual(batched_transform.shape, (2, 3, dimension))
+                self.assertTrue(np.all(np.isfinite(one)))
+                self.assertTrue(np.all(np.isfinite(many)))
+                self.assertTrue(np.all(np.isfinite(batched_transform)))
+
+
+class TestEllipticalCopulas(unittest.TestCase):
+
+    def test_output_shape_with_nonnormal_marginals(self):
+        tm = GaussianCopula(
+            sampler=DigitalNetB2(2, seed=7),
+            marginals=[stats.beta(a=2, b=5), stats.gamma(a=3, scale=2)],
+            correlation=[[1.0, 0.4], [0.4, 1.0]],
+        )
+
+        x = tm(16)
+
+        self.assertEqual(x.shape, (16, 2))
+
+    def test_finite_output_for_normal_marginals(self):
+        tm = GaussianCopula(
+            sampler=DigitalNetB2(2, seed=11),
+            marginals=[stats.norm(), stats.norm(loc=1.0, scale=2.0)],
+            correlation=[[1.0, -0.3], [-0.3, 1.0]],
+        )
+
+        x = tm(128)
+
+        self.assertTrue(np.all(np.isfinite(x)))
+
+    def test_return_weights_shape_when_marginal_densities_available(self):
+        tm = GaussianCopula(
+            sampler=DigitalNetB2(2, seed=12),
+            marginals=[stats.norm(), stats.gamma(a=2.0)],
+            correlation=[[1.0, 0.25], [0.25, 1.0]],
+        )
+
+        x, weights = tm(32, return_weights=True)
+
+        self.assertEqual(x.shape, (32, 2))
+        self.assertEqual(weights.shape, (32,))
+        self.assertTrue(np.all(np.isfinite(weights)))
+        self.assertTrue(np.all(weights > 0.0))
+
+    def test_identity_correlation_matches_independent_marginal_transforms(self):
+        marginals = [stats.norm(loc=-1.0, scale=2.0), stats.gamma(a=2.0, scale=3.0)]
+        tm = GaussianCopula(
+            sampler=DigitalNetB2(2, seed=13),
+            marginals=marginals,
+            correlation=np.eye(2),
+        )
+        u = np.array([[0.2, 0.7], [0.4, 0.8], [0.9, 0.1]])
+
+        x = tm._transform(u)
+        expected = np.column_stack(
+            [marginals[j].ppf(u[:, j]) for j in range(len(marginals))]
+        )
+
+        np.testing.assert_allclose(x, expected, rtol=1e-12, atol=1e-12)
+
+    def test_positive_correlation_produces_positive_dependence(self):
+        rho = 0.75
+        tm = GaussianCopula(
+            sampler=DigitalNetB2(2, seed=17),
+            marginals=[stats.norm(), stats.norm()],
+            correlation=[[1.0, rho], [rho, 1.0]],
+        )
+
+        x = tm(4096)
+        empirical_corr = np.corrcoef(x.T)[0, 1]
+
+        self.assertGreater(empirical_corr, 0.5)
+        self.assertLess(abs(empirical_corr - rho), 0.2)
+
+    def test_elliptical_copulas_support_general_dimensions(self):
+        for copula_cls in [GaussianCopula, StudentTCopula]:
+            for dimension in [1, 3, 5]:
+                with self.subTest(copula_cls=copula_cls.__name__, dimension=dimension):
+                    correlation = _equicorrelation(dimension, 0.25)
+                    tm = _make_copula(
+                        copula_cls,
+                        dimension=dimension,
+                        marginals=[stats.norm()] * dimension,
+                        correlation=correlation,
+                        seed=19,
+                    )
+
+                    x = tm(16)
+                    one = tm(1)
+
+                    self.assertEqual(x.shape, (16, dimension))
+                    self.assertEqual(one.shape, (1, dimension))
+                    self.assertTrue(np.all(np.isfinite(x)))
+                    self.assertTrue(np.all(np.isfinite(one)))
+
+    def test_elliptical_copulas_handle_valid_near_singular_correlation(self):
+        for copula_cls in [GaussianCopula, StudentTCopula]:
+            with self.subTest(copula_cls=copula_cls.__name__):
+                dimension = 5
+                tm = _make_copula(
+                    copula_cls,
+                    dimension=dimension,
+                    marginals=[stats.norm()] * dimension,
+                    correlation=_equicorrelation(dimension, 0.999),
+                    seed=20,
+                )
+
+                x = tm(32)
+
+                self.assertEqual(x.shape, (32, dimension))
+                self.assertTrue(np.all(np.isfinite(x)))
+
+    def test_elliptical_copulas_reject_singular_correlation(self):
+        for copula_cls in [GaussianCopula, StudentTCopula]:
+            with self.subTest(copula_cls=copula_cls.__name__):
+                with self.assertRaisesRegex(ValueError, "positive definite"):
+                    _make_copula(
+                        copula_cls,
+                        dimension=3,
+                        marginals=[stats.norm(), stats.norm(), stats.norm()],
+                        correlation=np.ones((3, 3)),
+                        seed=22,
+                    )
+
+    def test_distribution_dimension_matches_number_of_marginals(self):
+        for copula_cls in [GaussianCopula, StudentTCopula, ClaytonCopula, FrankCopula, GumbelCopula]:
+            with self.subTest(copula_cls=copula_cls.__name__):
+                tm = _make_copula(
+                    copula_cls,
+                    dimension=5,
+                    marginals=[
+                        stats.norm(),
+                        stats.beta(a=2, b=5),
+                        stats.gamma(a=3),
+                        stats.expon(),
+                        stats.lognorm(s=0.5),
+                    ],
+                    correlation=np.eye(5),
+                )
+
+                x = tm(32)
+
+                self.assertEqual(x.shape, (32, 5))
+                self.assertTrue(np.all(np.isfinite(x)))
+
+    def test_invalid_dimension_mismatches_raise(self):
+        for copula_cls in [GaussianCopula, StudentTCopula]:
+            with self.subTest(copula_cls=copula_cls.__name__):
+                with self.assertRaisesRegex(DimensionError, "marginals"):
+                    _make_copula(
+                        copula_cls,
+                        dimension=2,
+                        marginals=[stats.norm(), stats.norm(), stats.norm()],
+                        correlation=np.eye(2),
+                    )
+
+                with self.assertRaisesRegex(ValueError, "shape"):
+                    _make_copula(
+                        copula_cls,
+                        dimension=2,
+                        marginals=[stats.norm(), stats.norm()],
+                        correlation=np.eye(3),
+                    )
+
+                with self.assertRaisesRegex(ValueError, "square"):
+                    _make_copula(
+                        copula_cls,
+                        dimension=2,
+                        marginals=[stats.norm(), stats.norm()],
+                        correlation=[[1.0, 0.2, 0.3], [0.2, 1.0, 0.4]],
+                    )
+
+    def test_archimedean_dimension_mismatch_raises_dimension_error(self):
+        for copula_cls in [ClaytonCopula, FrankCopula, GumbelCopula]:
+            with self.subTest(copula_cls=copula_cls.__name__):
+                with self.assertRaisesRegex(DimensionError, "marginals"):
+                    _make_copula(
+                        copula_cls,
+                        dimension=2,
+                        marginals=[stats.norm(), stats.norm(), stats.norm()],
+                    )
+
+    def test_invalid_correlation_matrices_raise_value_error(self):
+        correlations = [
+            [[1.0, 0.2], [0.3, 1.0]],
+            [[1.0, 0.2], [0.2, 0.9]],
+            [[1.0, 1.2], [1.2, 1.0]],
+        ]
+        for copula_cls in [GaussianCopula, StudentTCopula]:
+            for correlation in correlations:
+                with self.subTest(copula_cls=copula_cls.__name__, correlation=correlation):
+                    with self.assertRaises(ValueError):
+                        _make_copula(
+                            copula_cls,
+                            dimension=2,
+                            marginals=[stats.norm(), stats.norm()],
+                            correlation=correlation,
+                        )
+
+    def test_marginal_length_mismatch_raises_dimension_error(self):
+        with self.assertRaisesRegex(DimensionError, "marginals"):
+            GaussianCopula(
+                sampler=DigitalNetB2(2, seed=21),
+                marginals=[stats.norm()],
+                correlation=np.eye(2),
+            )
+
+    def test_marginal_without_ppf_raises_clear_error(self):
+        class NoPPF:
+            pass
+
+        with self.assertRaisesRegex(ParameterError, "ppf"):
+            GaussianCopula(
+                sampler=DigitalNetB2(1, seed=23),
+                marginals=[NoPPF()],
+                correlation=[[1.0]],
+            )
+
+    def test_common_scipy_frozen_marginals_work(self):
+        for copula_cls in [GaussianCopula, StudentTCopula, ClaytonCopula, FrankCopula, GumbelCopula]:
+            with self.subTest(copula_cls=copula_cls.__name__):
+                tm = _make_copula(
+                    copula_cls,
+                    dimension=5,
+                    marginals=[
+                        stats.norm(),
+                        stats.beta(a=2, b=5),
+                        stats.gamma(a=3),
+                        stats.expon(),
+                        stats.lognorm(s=0.5),
+                    ],
+                    correlation=np.eye(5),
+                    seed=47,
+                )
+
+                x = tm(128)
+
+                self.assertEqual(x.shape, (128, 5))
+                self.assertTrue(np.all(np.isfinite(x)))
+
+    def test_endpoint_uniforms_are_clipped_to_finite_outputs(self):
+        for copula_cls in [GaussianCopula, StudentTCopula, ClaytonCopula, FrankCopula, GumbelCopula]:
+            with self.subTest(copula_cls=copula_cls.__name__):
+                tm = _make_copula(
+                    copula_cls,
+                    dimension=5,
+                    marginals=[
+                        stats.norm(),
+                        stats.beta(a=2, b=5),
+                        stats.gamma(a=3),
+                        stats.expon(),
+                        stats.lognorm(s=0.5),
+                    ],
+                    correlation=np.eye(5),
+                    seed=53,
+                )
+                u = np.array(
+                    [
+                        [0.0, 1.0, 0.0, 1.0, 0.5],
+                        [1.0, 0.0, 1.0, 0.0, 0.5],
+                    ]
+                )
+
+                x = tm._transform(u)
+
+                self.assertEqual(x.shape, (2, 5))
+                self.assertTrue(np.all(np.isfinite(x)))
+
+    def test_student_t_copula_output_shape_and_finite_values(self):
+        tm = StudentTCopula(
+            sampler=DigitalNetB2(2, seed=29),
+            marginals=[stats.norm(), stats.gamma(a=3.0, scale=2.0)],
+            correlation=[[1.0, 0.5], [0.5, 1.0]],
+            df=4,
+        )
+
+        x = tm(128)
+
+        self.assertEqual(x.shape, (128, 2))
+        self.assertTrue(np.all(np.isfinite(x)))
+
+    def test_student_t_copula_positive_correlation_produces_positive_dependence(self):
+        tm = StudentTCopula(
+            sampler=DigitalNetB2(2, seed=31),
+            marginals=[stats.norm(), stats.norm()],
+            correlation=[[1.0, 0.7], [0.7, 1.0]],
+            df=5,
+        )
+
+        x = tm(4096)
+        empirical_corr = np.corrcoef(x.T)[0, 1]
+
+        self.assertGreater(empirical_corr, 0.45)
+
+    def test_student_t_copula_has_stronger_joint_tail_than_gaussian_copula(self):
+        rho = 0.7
+        df = 4
+        n = 2**12
+        marginals = [stats.norm(), stats.norm()]
+        correlation = [[1.0, rho], [rho, 1.0]]
+
+        gaussian = GaussianCopula(
+            sampler=DigitalNetB2(2, seed=101),
+            marginals=marginals,
+            correlation=correlation,
+        )
+        student_t = StudentTCopula(
+            sampler=DigitalNetB2(2, seed=101),
+            marginals=marginals,
+            correlation=correlation,
+            df=df,
+        )
+
+        x_gaussian = gaussian(n)
+        x_student_t = student_t(n)
+        threshold = stats.norm.ppf(0.99)
+
+        def joint_tail_rate(x):
+            tail_0 = x[:, 0] > threshold
+            return np.mean(x[tail_0, 1] > threshold)
+
+        gaussian_tail = joint_tail_rate(x_gaussian)
+        student_t_tail = joint_tail_rate(x_student_t)
+
+        self.assertGreater(student_t_tail, gaussian_tail + 0.08)
+
+    def test_student_t_copula_return_weights_shape_when_density_available(self):
+        tm = StudentTCopula(
+            sampler=DigitalNetB2(2, seed=37),
+            marginals=[stats.norm(), stats.gamma(a=2.0)],
+            correlation=[[1.0, 0.3], [0.3, 1.0]],
+            df=6,
+        )
+
+        x, weights = tm(32, return_weights=True)
+
+        self.assertEqual(x.shape, (32, 2))
+        self.assertEqual(weights.shape, (32,))
+        self.assertTrue(np.all(np.isfinite(weights)))
+        self.assertTrue(np.all(weights > 0.0))
+
+    def test_student_t_copula_boundary_df_values_are_finite(self):
+        for df in [1.0, 100.0]:
+            with self.subTest(df=df):
+                dimension = 3
+                tm = StudentTCopula(
+                    sampler=DigitalNetB2(dimension, seed=39),
+                    marginals=[stats.norm()] * dimension,
+                    correlation=_equicorrelation(dimension, 0.4),
+                    df=df,
+                )
+
+                x = tm(128)
+
+                self.assertEqual(x.shape, (128, dimension))
+                self.assertTrue(np.all(np.isfinite(x)))
+
+    def test_student_t_copula_large_df_is_close_to_gaussian_copula(self):
+        rho = 0.6
+        correlation = [[1.0, rho], [rho, 1.0]]
+        marginals = [stats.norm(), stats.norm()]
+        gaussian = GaussianCopula(
+            sampler=DigitalNetB2(2, seed=40),
+            marginals=marginals,
+            correlation=correlation,
+        )
+        student_t = StudentTCopula(
+            sampler=DigitalNetB2(2, seed=40),
+            marginals=marginals,
+            correlation=correlation,
+            df=100,
+        )
+
+        x_gaussian = gaussian(4096)
+        x_student_t = student_t(4096)
+        corr_gaussian = np.corrcoef(x_gaussian.T)[0, 1]
+        corr_student_t = np.corrcoef(x_student_t.T)[0, 1]
+
+        self.assertLess(abs(corr_student_t - corr_gaussian), 0.02)
+
+    def test_student_t_copula_invalid_df_raises_parameter_error(self):
+        for df in [0, -1, np.inf, "not-a-number"]:
+            with self.subTest(df=df):
+                with self.assertRaisesRegex(ParameterError, "df"):
+                    StudentTCopula(
+                        sampler=DigitalNetB2(2, seed=41),
+                        marginals=[stats.norm(), stats.norm()],
+                        correlation=np.eye(2),
+                        df=df,
+                    )
+
+    def test_student_t_copula_marginal_without_ppf_raises_clear_error(self):
+        class NoPPF:
+            pass
+
+        with self.assertRaisesRegex(ParameterError, "ppf"):
+            StudentTCopula(
+                sampler=DigitalNetB2(1, seed=43),
+                marginals=[NoPPF()],
+                correlation=[[1.0]],
+                df=4,
+            )
+
+
+class TestArchimedeanCopulas(unittest.TestCase):
+
+    def test_clayton_copula_output_shape_and_finite_values(self):
+        tm = ClaytonCopula(
+            sampler=DigitalNetB2(2, seed=57),
+            marginals=[stats.norm(), stats.gamma(a=3.0, scale=2.0)],
+            theta=2.0,
+        )
+
+        x = tm(128)
+
+        self.assertEqual(x.shape, (128, 2))
+        self.assertTrue(np.all(np.isfinite(x)))
+
+    def test_clayton_copula_return_weights_shape_when_density_available(self):
+        tm = ClaytonCopula(
+            sampler=DigitalNetB2(3, seed=59),
+            marginals=[stats.norm(), stats.gamma(a=2.0), stats.expon()],
+            theta=1.5,
+        )
+
+        x, weights = tm(32, return_weights=True)
+
+        self.assertEqual(x.shape, (32, 3))
+        self.assertEqual(weights.shape, (32,))
+        self.assertTrue(np.all(np.isfinite(weights)))
+        self.assertTrue(np.all(weights > 0.0))
+
+    def test_clayton_copula_invalid_theta_raises_parameter_error(self):
+        for theta in [0, -1, np.inf, "not-a-number"]:
+            with self.subTest(theta=theta):
+                with self.assertRaisesRegex(ParameterError, "theta"):
+                    ClaytonCopula(
+                        sampler=DigitalNetB2(2, seed=61),
+                        marginals=[stats.norm(), stats.norm()],
+                        theta=theta,
+                    )
+
+    def test_clayton_copula_supports_general_dimension(self):
+        for dimension in [2, 3, 5]:
+            with self.subTest(dimension=dimension):
+                tm = ClaytonCopula(
+                    sampler=DigitalNetB2(dimension, seed=63),
+                    marginals=[stats.norm()] * dimension,
+                    theta=2.0,
+                )
+
+                x = tm(128)
+
+                self.assertEqual(x.shape, (128, dimension))
+                self.assertTrue(np.all(np.isfinite(x)))
+
+    def test_clayton_copula_marginal_without_ppf_raises_clear_error(self):
+        class NoPPF:
+            pass
+
+        with self.assertRaisesRegex(ParameterError, "ppf"):
+            ClaytonCopula(
+                sampler=DigitalNetB2(2, seed=67),
+                marginals=[stats.norm(), NoPPF()],
+                theta=2.0,
+            )
+
+    def test_clayton_copula_common_scipy_frozen_marginals_work(self):
+        for marginals in [
+            [stats.norm(), stats.beta(a=2, b=5)],
+            [stats.gamma(a=3), stats.expon()],
+            [stats.lognorm(s=0.5), stats.norm()],
+        ]:
+            with self.subTest(marginals=[type(m.dist).__name__ for m in marginals]):
+                tm = ClaytonCopula(
+                    sampler=DigitalNetB2(2, seed=69),
+                    marginals=marginals,
+                    theta=2.0,
+                )
+
+                x = tm(128)
+
+                self.assertEqual(x.shape, (128, 2))
+                self.assertTrue(np.all(np.isfinite(x)))
+
+    def test_clayton_copula_endpoint_uniforms_are_clipped_to_finite_outputs(self):
+        tm = ClaytonCopula(
+            sampler=DigitalNetB2(2, seed=70),
+            marginals=[stats.norm(), stats.lognorm(s=0.5)],
+            theta=2.0,
+        )
+        u = np.array([[0.0, 1.0], [1.0, 0.0]])
+
+        x = tm._transform(u)
+
+        self.assertEqual(x.shape, (2, 2))
+        self.assertTrue(np.all(np.isfinite(x)))
+
+    def test_clayton_copula_tiny_theta_is_near_independent(self):
+        for dimension in [2, 3, 5]:
+            with self.subTest(dimension=dimension):
+                marginals = [stats.uniform()] * dimension
+                tm = ClaytonCopula(
+                    sampler=DigitalNetB2(dimension, seed=70),
+                    marginals=marginals,
+                    theta=1e-8,
+                )
+                u = np.array(
+                    [
+                        [0.2, 0.7, 0.4, 0.6, 0.8],
+                        [0.4, 0.8, 0.9, 0.3, 0.2],
+                        [0.9, 0.1, 0.3, 0.7, 0.5],
+                    ]
+                )[:, :dimension]
+
+                x = tm._transform(u)
+
+                self.assertEqual(x.shape, (3, dimension))
+                self.assertTrue(np.all(np.isfinite(x)))
+                np.testing.assert_allclose(x, u, atol=5e-6)
+
+    def test_clayton_copula_large_theta_is_finite(self):
+        for dimension in [2, 3, 5]:
+            for theta in [20.0, 50.0]:
+                with self.subTest(dimension=dimension, theta=theta):
+                    tm = ClaytonCopula(
+                        sampler=DigitalNetB2(dimension, seed=70),
+                        marginals=[stats.norm()] * dimension,
+                        theta=theta,
+                    )
+
+                    x = tm(128)
+
+                    self.assertEqual(x.shape, (128, dimension))
+                    self.assertTrue(np.all(np.isfinite(x)))
+
+    def test_clayton_copula_positive_dependence_behavior(self):
+        tm = ClaytonCopula(
+            sampler=DigitalNetB2(2, seed=71),
+            marginals=[stats.uniform(), stats.uniform()],
+            theta=2.0,
+        )
+
+        x = tm(4096)
+        empirical_corr = np.corrcoef(x.T)[0, 1]
+
+        self.assertGreater(empirical_corr, 0.45)
+
+    def test_clayton_copula_has_stronger_lower_tail_than_gaussian_copula(self):
+        theta = 2.0
+        n = 2**12
+        marginals = [stats.uniform(), stats.uniform()]
+        # Clayton Kendall tau is theta/(theta+2); convert to Gaussian rho.
+        rho = np.sin(np.pi * (theta / (theta + 2.0)) / 2.0)
+
+        clayton = ClaytonCopula(
+            sampler=DigitalNetB2(2, seed=73),
+            marginals=marginals,
+            theta=theta,
+        )
+        gaussian = GaussianCopula(
+            sampler=DigitalNetB2(2, seed=73),
+            marginals=marginals,
+            correlation=[[1.0, rho], [rho, 1.0]],
+        )
+
+        x_clayton = clayton(n)
+        x_gaussian = gaussian(n)
+        threshold = 0.05
+
+        def lower_tail_rate(x):
+            tail_0 = x[:, 0] < threshold
+            return np.mean(x[tail_0, 1] < threshold)
+
+        clayton_tail = lower_tail_rate(x_clayton)
+        gaussian_tail = lower_tail_rate(x_gaussian)
+
+        self.assertGreater(clayton_tail, gaussian_tail + 0.2)
+
+    def test_frank_copula_output_shape_for_two_dimensions(self):
+        tm = FrankCopula(
+            sampler=DigitalNetB2(2, seed=75),
+            marginals=[stats.norm(), stats.gamma(a=3.0, scale=2.0)],
+            theta=5.0,
+        )
+
+        x = tm(128)
+
+        self.assertEqual(x.shape, (128, 2))
+        self.assertTrue(np.all(np.isfinite(x)))
+
+    def test_frank_copula_positive_theta_supports_higher_dimensions(self):
+        for dimension in [3, 5]:
+            with self.subTest(dimension=dimension):
+                tm = FrankCopula(
+                    sampler=DigitalNetB2(dimension, seed=76),
+                    marginals=[stats.norm()] * dimension,
+                    theta=5.0,
+                )
+
+                x = tm(128)
+
+                self.assertEqual(x.shape, (128, dimension))
+                self.assertTrue(np.all(np.isfinite(x)))
+
+    def test_frank_copula_return_weights_shape_when_density_available(self):
+        tm = FrankCopula(
+            sampler=DigitalNetB2(3, seed=77),
+            marginals=[stats.norm(), stats.gamma(a=2.0), stats.expon()],
+            theta=4.0,
+        )
+
+        x, weights = tm(32, return_weights=True)
+
+        self.assertEqual(x.shape, (32, 3))
+        self.assertEqual(weights.shape, (32,))
+        self.assertTrue(np.all(np.isfinite(weights)))
+        self.assertTrue(np.all(weights > 0.0))
+
+    def test_frank_copula_invalid_theta_raises_parameter_error(self):
+        for theta in [0, np.inf, -np.inf, "not-a-number"]:
+            with self.subTest(theta=theta):
+                with self.assertRaisesRegex(ParameterError, "theta"):
+                    FrankCopula(
+                        sampler=DigitalNetB2(2, seed=78),
+                        marginals=[stats.norm(), stats.norm()],
+                        theta=theta,
+                    )
+
+    def test_frank_copula_negative_theta_rejected_above_two_dimensions(self):
+        with self.assertRaisesRegex(ParameterError, "d=2"):
+            FrankCopula(
+                sampler=DigitalNetB2(3, seed=79),
+                marginals=[stats.norm(), stats.norm(), stats.norm()],
+                theta=-2.0,
+            )
+
+    def test_frank_copula_dimension_mismatch_raises_dimension_error(self):
+        with self.assertRaisesRegex(DimensionError, "marginals"):
+            FrankCopula(
+                sampler=DigitalNetB2(2, seed=80),
+                marginals=[stats.norm(), stats.norm(), stats.norm()],
+                theta=5.0,
+            )
+
+    def test_frank_copula_marginal_without_ppf_raises_clear_error(self):
+        class NoPPF:
+            pass
+
+        with self.assertRaisesRegex(ParameterError, "ppf"):
+            FrankCopula(
+                sampler=DigitalNetB2(2, seed=82),
+                marginals=[stats.norm(), NoPPF()],
+                theta=5.0,
+            )
+
+    def test_frank_copula_positive_dependence_behavior(self):
+        tm = FrankCopula(
+            sampler=DigitalNetB2(2, seed=84),
+            marginals=[stats.uniform(), stats.uniform()],
+            theta=6.0,
+        )
+
+        x = tm(4096)
+        empirical_corr = np.corrcoef(x.T)[0, 1]
+
+        self.assertGreater(empirical_corr, 0.45)
+
+    def test_frank_copula_tiny_theta_is_close_to_independence(self):
+        for theta, dimension in [(1e-8, 3), (-1e-8, 2)]:
+            with self.subTest(theta=theta, dimension=dimension):
+                marginals = [stats.uniform()] * dimension
+                tm = FrankCopula(
+                    sampler=DigitalNetB2(dimension, seed=86),
+                    marginals=marginals,
+                    theta=theta,
+                )
+                u = np.array(
+                    [
+                        [0.2, 0.7, 0.4, 0.6, 0.8],
+                        [0.4, 0.8, 0.9, 0.3, 0.2],
+                        [0.9, 0.1, 0.3, 0.7, 0.5],
+                    ]
+                )[:, :dimension]
+
+                x = tm._transform(u)
+
+                self.assertEqual(x.shape, (3, dimension))
+                self.assertTrue(np.all(np.isfinite(x)))
+                np.testing.assert_allclose(x, u, atol=5e-6)
+
+    def test_frank_copula_large_theta_is_finite(self):
+        for theta, dimension in [(50.0, 5), (-50.0, 2)]:
+            with self.subTest(theta=theta, dimension=dimension):
+                tm = FrankCopula(
+                    sampler=DigitalNetB2(dimension, seed=87),
+                    marginals=[stats.norm()] * dimension,
+                    theta=theta,
+                )
+
+                x = tm(128)
+
+                self.assertEqual(x.shape, (128, dimension))
+                self.assertTrue(np.all(np.isfinite(x)))
+
+    def test_frank_copula_negative_theta_produces_negative_dependence_in_2d(self):
+        tm = FrankCopula(
+            sampler=DigitalNetB2(2, seed=88),
+            marginals=[stats.uniform(), stats.uniform()],
+            theta=-6.0,
+        )
+
+        x = tm(4096)
+        empirical_corr = np.corrcoef(x.T)[0, 1]
+
+        self.assertLess(empirical_corr, -0.35)
+
+    def test_gumbel_copula_output_shape_and_finite_values(self):
+        tm = GumbelCopula(
+            sampler=DigitalNetB2(2, seed=79),
+            marginals=[stats.norm(), stats.gamma(a=3.0, scale=2.0)],
+            theta=2.0,
+        )
+
+        x = tm(128)
+
+        self.assertEqual(x.shape, (128, 2))
+        self.assertTrue(np.all(np.isfinite(x)))
+
+    def test_gumbel_copula_return_weights_shape_when_density_available(self):
+        tm = GumbelCopula(
+            sampler=DigitalNetB2(3, seed=81),
+            marginals=[stats.norm(), stats.gamma(a=2.0), stats.expon()],
+            theta=1.5,
+        )
+
+        x, weights = tm(32, return_weights=True)
+
+        self.assertEqual(x.shape, (32, 3))
+        self.assertEqual(weights.shape, (32,))
+        self.assertTrue(np.all(np.isfinite(weights)))
+        self.assertTrue(np.all(weights > 0.0))
+
+    def test_gumbel_copula_invalid_theta_raises_parameter_error(self):
+        for theta in [0, 0.5, -1, np.inf, "not-a-number"]:
+            with self.subTest(theta=theta):
+                with self.assertRaisesRegex(ParameterError, "theta"):
+                    GumbelCopula(
+                        sampler=DigitalNetB2(2, seed=83),
+                        marginals=[stats.norm(), stats.norm()],
+                        theta=theta,
+                    )
+
+    def test_gumbel_copula_theta_one_is_independent_marginal_transform(self):
+        marginals = [stats.norm(loc=-1.0, scale=2.0), stats.gamma(a=2.0, scale=3.0)]
+        tm = GumbelCopula(
+            sampler=DigitalNetB2(2, seed=85),
+            marginals=marginals,
+            theta=1.0,
+        )
+        u = np.array([[0.2, 0.7], [0.4, 0.8], [0.9, 0.1]])
+
+        x = tm._transform(u)
+        expected = np.column_stack(
+            [marginals[j].ppf(u[:, j]) for j in range(len(marginals))]
+        )
+
+        np.testing.assert_allclose(x, expected, rtol=1e-12, atol=1e-12)
+
+    def test_gumbel_copula_theta_close_to_one_is_near_independent(self):
+        for dimension in [2, 3, 5]:
+            with self.subTest(dimension=dimension):
+                marginals = [stats.uniform()] * dimension
+                tm = GumbelCopula(
+                    sampler=DigitalNetB2(dimension, seed=85),
+                    marginals=marginals,
+                    theta=1.000001,
+                )
+                u = np.array(
+                    [
+                        [0.2, 0.7, 0.4, 0.6, 0.8],
+                        [0.4, 0.8, 0.9, 0.3, 0.2],
+                        [0.9, 0.1, 0.3, 0.7, 0.5],
+                    ]
+                )[:, :dimension]
+
+                x = tm._transform(u)
+
+                self.assertEqual(x.shape, (3, dimension))
+                self.assertTrue(np.all(np.isfinite(x)))
+                np.testing.assert_allclose(x, u, atol=5e-5)
+
+    def test_gumbel_copula_large_theta_is_finite(self):
+        for dimension in [2, 3, 5]:
+            for theta in [20.0, 50.0]:
+                with self.subTest(dimension=dimension, theta=theta):
+                    tm = GumbelCopula(
+                        sampler=DigitalNetB2(dimension, seed=86),
+                        marginals=[stats.norm()] * dimension,
+                        theta=theta,
+                    )
+
+                    x = tm(128)
+
+                    self.assertEqual(x.shape, (128, dimension))
+                    self.assertTrue(np.all(np.isfinite(x)))
+
+    def test_gumbel_copula_supports_general_dimension(self):
+        for dimension in [2, 3, 5]:
+            with self.subTest(dimension=dimension):
+                tm = GumbelCopula(
+                    sampler=DigitalNetB2(dimension, seed=87),
+                    marginals=[stats.norm()] * dimension,
+                    theta=2.0,
+                )
+
+                x = tm(128)
+
+                self.assertEqual(x.shape, (128, dimension))
+                self.assertTrue(np.all(np.isfinite(x)))
+
+    def test_gumbel_copula_marginal_without_ppf_raises_clear_error(self):
+        class NoPPF:
+            pass
+
+        with self.assertRaisesRegex(ParameterError, "ppf"):
+            GumbelCopula(
+                sampler=DigitalNetB2(2, seed=89),
+                marginals=[stats.norm(), NoPPF()],
+                theta=2.0,
+            )
+
+    def test_gumbel_copula_common_scipy_frozen_marginals_work(self):
+        for marginals in [
+            [stats.norm(), stats.beta(a=2, b=5)],
+            [stats.gamma(a=3), stats.expon()],
+            [stats.lognorm(s=0.5), stats.norm()],
+        ]:
+            with self.subTest(marginals=[type(m.dist).__name__ for m in marginals]):
+                tm = GumbelCopula(
+                    sampler=DigitalNetB2(2, seed=91),
+                    marginals=marginals,
+                    theta=2.0,
+                )
+
+                x = tm(128)
+
+                self.assertEqual(x.shape, (128, 2))
+                self.assertTrue(np.all(np.isfinite(x)))
+
+    def test_gumbel_copula_endpoint_uniforms_are_clipped_to_finite_outputs(self):
+        tm = GumbelCopula(
+            sampler=DigitalNetB2(2, seed=93),
+            marginals=[stats.norm(), stats.lognorm(s=0.5)],
+            theta=2.0,
+        )
+        u = np.array([[0.0, 1.0], [1.0, 0.0]])
+
+        x = tm._transform(u)
+
+        self.assertEqual(x.shape, (2, 2))
+        self.assertTrue(np.all(np.isfinite(x)))
+
+    def test_gumbel_copula_positive_dependence_behavior(self):
+        tm = GumbelCopula(
+            sampler=DigitalNetB2(2, seed=95),
+            marginals=[stats.uniform(), stats.uniform()],
+            theta=2.0,
+        )
+
+        x = tm(4096)
+        empirical_corr = np.corrcoef(x.T)[0, 1]
+
+        self.assertGreater(empirical_corr, 0.45)
+
+    def test_gumbel_copula_has_stronger_upper_tail_than_gaussian_copula(self):
+        theta = 2.0
+        n = 2**12
+        marginals = [stats.uniform(), stats.uniform()]
+        # Gumbel Kendall tau is 1 - 1/theta; convert to Gaussian rho.
+        rho = np.sin(np.pi * (1.0 - 1.0 / theta) / 2.0)
+
+        gumbel = GumbelCopula(
+            sampler=DigitalNetB2(2, seed=97),
+            marginals=marginals,
+            theta=theta,
+        )
+        gaussian = GaussianCopula(
+            sampler=DigitalNetB2(2, seed=97),
+            marginals=marginals,
+            correlation=[[1.0, rho], [rho, 1.0]],
+        )
+
+        x_gumbel = gumbel(n)
+        x_gaussian = gaussian(n)
+        threshold = 0.95
+
+        def upper_tail_rate(x):
+            tail_0 = x[:, 0] > threshold
+            return np.mean(x[tail_0, 1] > threshold)
+
+        gumbel_tail = upper_tail_rate(x_gumbel)
+        gaussian_tail = upper_tail_rate(x_gaussian)
+
+        self.assertGreater(gumbel_tail, gaussian_tail + 0.15)
+
+
+class TestCopulaWeightsFallbackAndSpawn(unittest.TestCase):
+
+    def test_copula_weight_fallback_warns_once_when_density_methods_are_missing(self):
+        for copula_cls in [GaussianCopula, StudentTCopula, ClaytonCopula, GumbelCopula, FrankCopula]:
+            with self.subTest(copula_cls=copula_cls.__name__):
+                tm = _make_copula(
+                    copula_cls,
+                    dimension=2,
+                    marginals=[PPFOnlyMarginal(), PPFOnlyMarginal()],
+                )
+                x = np.full((4, 2), 0.5)
+                expected_message = getattr(
+                    tm,
+                    "_missing_weight_warning_message",
+                    f"{copula_cls.__name__} marginals must implement 'cdf' and "
+                    "'pdf' or 'logpdf' to compute density weights. "
+                    "Weights will be treated as 1.",
+                )
+
+                self.assertNotIn("_unit_weight_with_warning", copula_cls.__dict__)
+                self.assertIs(
+                    tm._unit_weight_with_warning.__func__,
+                    AbstractCopula._unit_weight_with_warning,
+                )
+
+                with self.assertWarns(UserWarning) as wcm:
+                    weights = tm._weight(x)
+
+                with warnings.catch_warnings(record=True) as caught:
+                    warnings.simplefilter("always")
+                    second_weights = tm._weight(x)
+
+                np.testing.assert_allclose(weights, np.ones(4))
+                np.testing.assert_allclose(second_weights, np.ones(4))
+                self.assertEqual(str(wcm.warning), expected_message)
+                self.assertEqual(caught, [])
+
+    def test_student_t_weight_falls_back_when_multivariate_t_is_unavailable(self):
+        tm = StudentTCopula(
+            DigitalNetB2(2, seed=115),
+            marginals=[stats.norm(), stats.norm()],
+            correlation=np.eye(2),
+            df=4,
+        )
+        tm._mvt_scipy = None
+
+        with self.assertWarnsRegex(UserWarning, "Weights will be treated as 1"):
+            weights = tm._weight(np.full((3, 2), 0.25))
+
+        np.testing.assert_allclose(weights, np.ones(3))
+
+    def test_gaussian_weight_uses_pdf_branch_when_logpdf_is_unavailable(self):
+        tm = GaussianCopula(
+            DigitalNetB2(2, seed=117),
+            marginals=[UnitPDFMarginal(), UnitPDFMarginal()],
+            correlation=[[1.0, 0.4], [0.4, 1.0]],
+        )
+
+        weights = tm._weight(np.array([[0.25, 0.5], [0.75, 0.5]]))
+
+        self.assertEqual(weights.shape, (2,))
+        self.assertTrue(np.all(np.isfinite(weights)))
+        self.assertTrue(np.all(weights > 0.0))
+
+    def test_gumbel_theta_one_weight_is_independent_marginal_density(self):
+        tm = GumbelCopula(
+            DigitalNetB2(2, seed=119),
+            marginals=[stats.gamma(a=2.0), stats.expon()],
+            theta=1.0,
+        )
+        x = np.array([[1.0, 0.5], [2.0, 1.5]])
+        expected = stats.gamma(a=2.0).pdf(x[:, 0]) * stats.expon().pdf(x[:, 1])
+
+        weights = tm._weight(x)
+
+        np.testing.assert_allclose(weights, expected)
+
+    def test_gen_copula_samples_composed_transform_branch(self):
+        inner = GaussianCopula(
+            DigitalNetB2(2, seed=121),
+            marginals=[stats.uniform(), stats.uniform()],
+            correlation=[[1.0, 0.3], [0.3, 1.0]],
+        )
+        outer = ClaytonCopula(inner, marginals=[stats.uniform(), stats.uniform()], theta=1.5)
+
+        v = outer.gen_copula_samples(n_min=4, n_max=8)
+
+        self.assertEqual(v.shape, (4, 2))
+        self.assertTrue(np.all(np.isfinite(v)))
+        self.assertTrue(np.all((0.0 <= v) & (v <= 1.0)))
+
+    def test_copula_spawn_same_dimension_and_reject_different_dimension(self):
+        for copula_cls in [GaussianCopula, StudentTCopula, ClaytonCopula, GumbelCopula, FrankCopula]:
+            with self.subTest(copula_cls=copula_cls.__name__):
+                tm = _make_copula(copula_cls, dimension=2)
+
+                spawned = tm.spawn(s=1, dimensions=[2])
+                self.assertEqual(len(spawned), 1)
+                self.assertIsInstance(spawned[0], copula_cls)
+                self.assertEqual(spawned[0](4).shape, (4, 2))
+
+                with self.assertRaises(DimensionError):
+                    tm._spawn(DigitalNetB2(3, seed=123), 3)
+
+    def test_frank_one_dimensional_weight_covers_zero_order_eulerian_term(self):
+        tm = FrankCopula(
+            DigitalNetB2(1, seed=125),
+            marginals=[UnitPDFMarginal()],
+            theta=3.0,
+        )
+
+        weights = tm._weight(np.array([[0.25], [0.75]]))
+
+        self.assertEqual(weights.shape, (2,))
+        self.assertTrue(np.all(np.isfinite(weights)))
+        self.assertTrue(np.all(weights > 0.0))
+
+    def test_frank_rejects_large_negative_theta_when_exponential_overflows(self):
+        with np.errstate(over="ignore"):
+            with self.assertRaisesRegex(ParameterError, "too close to 0 or too large"):
+                FrankCopula(
+                    DigitalNetB2(2, seed=127),
+                    marginals=[stats.uniform(), stats.uniform()],
+                    theta=-1000.0,
+                )
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/test/test_tm_product_measure.py b/test/test_tm_product_measure.py
new file mode 100644
index 000000000..470356860
--- /dev/null
+++ b/test/test_tm_product_measure.py
@@ -0,0 +1,271 @@
+import unittest
+
+import numpy as np
+import scipy.stats as stats
+
+from qmcpy import (
+    AcceptanceRejection,
+    DigitalNetB2,
+    DummySampler,
+    Gaussian,
+    GaussianCopula,
+    ProductMeasure,
+    SciPyWrapper,
+    Uniform,
+    ZeroInflatedExpUniform,
+)
+from qmcpy.util import DimensionError, ParameterError
+
+
+class TestProductMeasure(unittest.TestCase):
+
+    def test_product_measure_zero_inflated_with_scipy_uniform_shape(self):
+        n = 32
+        marginals = [
+            ZeroInflatedExpUniform(DummySampler(1), p_zero=0.4, lam=1.5),
+            SciPyWrapper(DummySampler(1), stats.uniform(loc=2.0, scale=3.0)),
+        ]
+        tm = ProductMeasure(sampler=DigitalNetB2(2, seed=23), marginals=marginals)
+
+        x = tm(n)
+
+        self.assertEqual(x.shape, (n, 2))
+        self.assertTrue(np.any(x[:, 0] == 0.0))
+        self.assertTrue(np.all((2.0 <= x[:, 1]) & (x[:, 1] <= 5.0)))
+
+    def test_product_measure_replication_shape(self):
+        n = 16
+        r = 3
+        marginals = [
+            ZeroInflatedExpUniform(DummySampler(1), p_zero=0.4, lam=1.5),
+            Uniform(DummySampler(1), lower_bound=2.0, upper_bound=5.0),
+        ]
+        tm = ProductMeasure(
+            sampler=DigitalNetB2(2, seed=23, replications=r),
+            marginals=marginals,
+        )
+
+        x = tm(n)
+
+        self.assertEqual(x.shape, (r, n, 2))
+
+    def test_product_measure_marginals_with_different_dimensions(self):
+        n = 32
+        marginals = [
+            Gaussian(
+                DummySampler(2),
+                mean=[1.0, -1.0],
+                covariance=[[2.0, 0.25], [0.25, 1.0]],
+            ),
+            ZeroInflatedExpUniform(DummySampler(1), p_zero=0.4, lam=1.5),
+        ]
+        tm = ProductMeasure(sampler=DigitalNetB2(3, seed=31), marginals=marginals)
+
+        x = tm(n)
+
+        self.assertEqual(tm.d, 3)
+        self.assertTrue(np.array_equal(tm.marginal_dimensions, np.array([2, 1])))
+        self.assertEqual(x.shape, (n, 3))
+        self.assertTrue(np.all(np.isfinite(x[:, :2])))
+        self.assertTrue(np.all(x[:, 2] >= 0.0))
+
+    def test_product_measure_block_split_range_and_weight_product(self):
+        n = 16
+        marginals = [
+            Uniform(DummySampler(1), lower_bound=10.0, upper_bound=12.0),
+            Uniform(
+                DummySampler(2),
+                lower_bound=[20.0, 30.0],
+                upper_bound=[24.0, 36.0],
+            ),
+        ]
+        tm = ProductMeasure(sampler=DigitalNetB2(3, seed=41), marginals=marginals)
+
+        u = tm.discrete_distrib.gen_samples(n)
+        x = tm._transform(u)
+        x_call, jac = tm(n, return_weights=True)
+        expected = np.concatenate(
+            [
+                marginals[0]._jacobian_transform_r(u[..., :1], return_weights=False),
+                marginals[1]._jacobian_transform_r(u[..., 1:], return_weights=False),
+            ],
+            axis=-1,
+        )
+        expected_range = np.array([[10.0, 12.0], [20.0, 24.0], [30.0, 36.0]])
+
+        self.assertEqual(x.shape, (n, 3))
+        self.assertTrue(np.allclose(tm.range, expected_range))
+        self.assertTrue(np.allclose(x, expected))
+        self.assertTrue(np.all((10.0 <= x[:, 0]) & (x[:, 0] <= 12.0)))
+        self.assertTrue(np.all((20.0 <= x[:, 1]) & (x[:, 1] <= 24.0)))
+        self.assertTrue(np.all((30.0 <= x[:, 2]) & (x[:, 2] <= 36.0)))
+        self.assertTrue(np.allclose(tm._weight(x), 1.0 / (2.0 * 4.0 * 6.0)))
+        self.assertEqual(x_call.shape, (n, 3))
+        self.assertTrue(np.allclose(jac, 2.0 * 4.0 * 6.0))
+
+    def test_product_measure_invalid_inputs(self):
+        with self.assertRaisesRegex(ParameterError, "nonempty list of marginals"):
+            ProductMeasure(sampler=DigitalNetB2(1, seed=7), marginals=[])
+
+        with self.assertRaisesRegex(ParameterError, "marginal"):
+            ProductMeasure(sampler=DigitalNetB2(1, seed=7), marginals=[object()])
+
+        with self.assertRaisesRegex(ParameterError, "AbstractDiscreteDistribution"):
+            ProductMeasure(sampler=object(), marginals=[Uniform(DummySampler(1))])
+
+        marginals = [Uniform(DummySampler(1))]
+        with self.assertRaisesRegex(DimensionError, "sum of marginal dimensions"):
+            ProductMeasure(sampler=DigitalNetB2(2, seed=7), marginals=marginals)
+
+    def test_product_measure_rejects_non_dimension_preserving_marginal(self):
+        marginal = AcceptanceRejection(
+            DigitalNetB2(2, seed=7),
+            lambda x: np.ones(len(x)),
+            1.0,
+            1.0,
+        )
+
+        with self.assertRaisesRegex(DimensionError, "dimension-preserving"):
+            ProductMeasure(DigitalNetB2(2, seed=11), [marginal])
+
+    def test_product_measure_spawn_preserves_marginal_blocks_and_replaces_outer_sampler(self):
+        marginals = [
+            Uniform(DummySampler(1), lower_bound=10.0, upper_bound=12.0),
+            Uniform(
+                DummySampler(2),
+                lower_bound=[20.0, 30.0],
+                upper_bound=[24.0, 36.0],
+            ),
+        ]
+        tm = ProductMeasure(sampler=DigitalNetB2(3, seed=41), marginals=marginals)
+
+        spawn = tm.spawn(s=1)[0]
+
+        self.assertIsInstance(spawn, ProductMeasure)
+        self.assertEqual(spawn.d, 3)
+        self.assertEqual(spawn.marginals, tm.marginals)
+        self.assertIsNot(spawn.discrete_distrib, tm.discrete_distrib)
+        self.assertTrue(np.array_equal(spawn.marginal_dimensions, np.array([1, 2])))
+
+        with self.assertRaises(DimensionError):
+            tm.spawn(s=1, dimensions=4)
+
+    def test_product_measure_does_not_use_marginal_dummy_sampler_values(self):
+        marginals = [
+            Uniform(DummySampler(1), lower_bound=0.0, upper_bound=2.0),
+            Uniform(DummySampler(1), lower_bound=10.0, upper_bound=12.0),
+        ]
+
+        with self.assertRaisesRegex(ParameterError, "construction placeholder"):
+            marginals[0].discrete_distrib(4)
+
+        tm = ProductMeasure(sampler=DigitalNetB2(2, seed=19), marginals=marginals)
+        x = tm(8)
+
+        self.assertEqual(x.shape, (8, 2))
+        self.assertTrue(np.all((0.0 <= x[:, 0]) & (x[:, 0] <= 2.0)))
+        self.assertTrue(np.all((10.0 <= x[:, 1]) & (x[:, 1] <= 12.0)))
+
+    def test_product_measure_same_outer_seed_matches_different_outer_seed_changes(self):
+        marginals = [
+            Uniform(DummySampler(1), lower_bound=0.0, upper_bound=2.0),
+            Uniform(DummySampler(1), lower_bound=10.0, upper_bound=12.0),
+        ]
+
+        first = ProductMeasure(sampler=DigitalNetB2(2, seed=101), marginals=marginals)(16)
+        same_outer = ProductMeasure(sampler=DigitalNetB2(2, seed=101), marginals=marginals)(16)
+        different_outer = ProductMeasure(sampler=DigitalNetB2(2, seed=102), marginals=marginals)(16)
+
+        self.assertTrue(np.array_equal(first, same_outer))
+        self.assertFalse(np.array_equal(first, different_outer))
+
+    def test_product_measure_replication_means_close_to_uniform_targets(self):
+        n = 1024
+        r = 4
+        marginals = [
+            Uniform(DummySampler(1), lower_bound=0.0, upper_bound=2.0),
+            Uniform(DummySampler(1), lower_bound=10.0, upper_bound=12.0),
+        ]
+        tm = ProductMeasure(
+            sampler=DigitalNetB2(2, seed=101, replications=r),
+            marginals=marginals,
+        )
+
+        x = tm(n)
+        replication_means = x.mean(axis=1)
+
+        self.assertEqual(x.shape, (r, n, 2))
+        self.assertTrue(np.allclose(replication_means[:, 0], 1.0, atol=0.03))
+        self.assertTrue(np.allclose(replication_means[:, 1], 11.0, atol=0.03))
+
+    def test_product_measure_with_scipywrapper_beta_marginal(self):
+        n = 64
+        marginals = [
+            Uniform(DummySampler(1), lower_bound=-1.0, upper_bound=1.0),
+            SciPyWrapper(DummySampler(1), stats.beta(a=2.0, b=5.0)),
+        ]
+        tm = ProductMeasure(sampler=DigitalNetB2(2, seed=71), marginals=marginals)
+
+        x = tm(n)
+
+        self.assertEqual(x.shape, (n, 2))
+        self.assertTrue(np.all((-1.0 <= x[:, 0]) & (x[:, 0] <= 1.0)))
+        self.assertTrue(np.all((0.0 <= x[:, 1]) & (x[:, 1] <= 1.0)))
+
+    def test_product_measure_matches_equivalent_scipywrapper(self):
+        n = 128
+        seed = 55
+        scipy_marginals = [stats.norm(loc=0.0, scale=1.0), stats.gamma(a=2.0, scale=1.0)]
+        product_marginals = [
+            SciPyWrapper(DummySampler(1), scipy_marginals[0]),
+            SciPyWrapper(DummySampler(1), scipy_marginals[1]),
+        ]
+
+        product_samples = ProductMeasure(
+            sampler=DigitalNetB2(2, seed=seed),
+            marginals=product_marginals,
+        )(n)
+        scipy_samples = SciPyWrapper(DigitalNetB2(2, seed=seed), scipy_marginals)(n)
+
+        self.assertTrue(np.array_equal(product_samples, scipy_samples))
+
+    def test_product_measure_with_gaussian_copula_marginal(self):
+        n = 64
+        copula = GaussianCopula(
+            DummySampler(2),
+            marginals=[stats.beta(a=2.0, b=5.0), stats.gamma(a=3.0, scale=1.0)],
+            correlation=[[1.0, 0.5], [0.5, 1.0]],
+        )
+        marginals = [copula, Uniform(DummySampler(1), lower_bound=10.0, upper_bound=12.0)]
+        tm = ProductMeasure(sampler=DigitalNetB2(3, seed=81), marginals=marginals)
+
+        x = tm(n)
+
+        self.assertEqual(x.shape, (n, 3))
+        self.assertTrue(np.all((0.0 <= x[:, 0]) & (x[:, 0] <= 1.0)))
+        self.assertTrue(np.all(x[:, 1] >= 0.0))
+        self.assertTrue(np.all((10.0 <= x[:, 2]) & (x[:, 2] <= 12.0)))
+
+    def test_product_measure_recursive_transform_sampling_supported_but_weights_restricted(self):
+        recursive_marginal = Uniform(
+            Uniform(DummySampler(1), lower_bound=0.0, upper_bound=1.0),
+            lower_bound=2.0,
+            upper_bound=4.0,
+        )
+        direct_marginal = Uniform(DummySampler(1), lower_bound=10.0, upper_bound=12.0)
+        tm = ProductMeasure(
+            sampler=DigitalNetB2(2, seed=91),
+            marginals=[recursive_marginal, direct_marginal],
+        )
+
+        x = tm(16)
+
+        self.assertEqual(x.shape, (16, 2))
+        self.assertTrue(np.all((2.0 <= x[:, 0]) & (x[:, 0] <= 4.0)))
+        self.assertTrue(np.all((10.0 <= x[:, 1]) & (x[:, 1] <= 12.0)))
+        with self.assertRaisesRegex(ParameterError, "direct marginal"):
+            tm(16, return_weights=True)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/test/test_tm_scipy_wrapper_custom.py b/test/test_tm_scipy_wrapper_custom.py
new file mode 100644
index 000000000..105b984e5
--- /dev/null
+++ b/test/test_tm_scipy_wrapper_custom.py
@@ -0,0 +1,292 @@
+import unittest
+import warnings
+
+import numpy as np
+import scipy.stats as stats
+
+from qmcpy import DigitalNetB2, SciPyWrapper, StudentT, ZeroInflatedExpUniform
+
+from qmcpy.true_measure.triangular import TriangularDistribution
+from qmcpy.util import DimensionError, ParameterError
+
+
+MISSING_PDF_WARNING = "no 'pdf' or 'logpdf'"
+
+
+def _missing_pdf_warnings(caught):
+    return [
+        warning
+        for warning in caught
+        if issubclass(warning.category, UserWarning)
+        and MISSING_PDF_WARNING in str(warning.message)
+    ]
+
+
+class TestSciPyWrapperCustom(unittest.TestCase):
+
+    def test_mvn_dependence_correlation_and_moment(self):
+        """
+        Check that passing a SciPy multivariate normal through SciPyWrapper
+        preserves correlation and the mixed moment E[X1 X2].
+        """
+        sampler = DigitalNetB2(2, seed=5)
+        rho_target = 0.7
+        cov = [[1.0, rho_target], [rho_target, 1.0]]
+        mvn = stats.multivariate_normal(mean=[0.0, 0.0], cov=cov)
+        tm_mvn = SciPyWrapper(sampler, scipy_distribs=mvn)
+
+        n = 4096
+        x = tm_mvn(n)
+
+        rho_hat = np.corrcoef(x.T)[0, 1]
+        est_moment = np.mean(x[:, 0] * x[:, 1])
+
+        self.assertTrue(np.isfinite(rho_hat))
+        self.assertTrue(np.isfinite(est_moment))
+
+        self.assertLess(abs(rho_hat - rho_target), 0.05)
+        self.assertLess(abs(est_moment - rho_target), 0.05)
+
+    def test_triangular_custom_marginal_range_and_shape(self):
+        """
+        Make sure our custom triangular marginal behaves sensibly:
+        samples stay in the right interval and the empirical mean is close
+        to the analytic mean.
+        """
+        tri = TriangularDistribution(c=0.3, loc=-1.0, scale=2.0)
+        tm = SciPyWrapper(DigitalNetB2(1, seed=11), scipy_distribs=tri)
+
+        n = 4096
+        x = tm(n).ravel()
+
+        self.assertGreaterEqual(x.min(), -1.1)
+        self.assertLessEqual(x.max(), 1.1)
+
+        a = -1.0
+        b = 1.0
+        m = -1.0 + 0.3 * 2.0
+        true_mean = (a + b + m) / 3.0
+        emp_mean = x.mean()
+        self.assertLess(abs(emp_mean - true_mean), 0.05)
+
+    def test_zero_inflated_zero_rate(self):
+        """
+        Check that the zero-inflated exponential distribution preserves the
+        specified probability mass at X = 0.
+        """
+        p_zero = 0.4
+        sampler = DigitalNetB2(1, seed=17)
+        tm = ZeroInflatedExpUniform(sampler, p_zero=p_zero, lam=1.5)
+
+        n = 4096
+        samples = tm(n)
+        x = samples.ravel()
+        zero_rate = np.mean(x == 0.0)
+
+        self.assertEqual(samples.shape, (n, 1))
+        self.assertLess(abs(zero_rate - p_zero), 0.05)
+
+    def test_zero_inflated_replications_shape(self):
+        tm = ZeroInflatedExpUniform(
+            DigitalNetB2(1, seed=17, replications=2),
+            p_zero=0.4,
+            lam=1.5,
+        )
+
+        x = tm(8)
+
+        self.assertEqual(x.shape, (2, 8, 1))
+        self.assertTrue(np.all(x >= 0.0))
+
+    def test_zero_inflated_rejects_invalid_p_zero(self):
+        for p_zero in [0.0, 1.0, -0.1, 1.1]:
+            with self.subTest(p_zero=p_zero):
+                with self.assertRaisesRegex(ParameterError, "p_zero must be in"):
+                    ZeroInflatedExpUniform(
+                        DigitalNetB2(1, seed=17),
+                        p_zero=p_zero,
+                        lam=1.5,
+                    )
+
+    def test_zero_inflated_rejects_nonpositive_lam(self):
+        for lam in [0.0, -1.0]:
+            with self.subTest(lam=lam):
+                with self.assertRaisesRegex(ParameterError, "lam must be positive"):
+                    ZeroInflatedExpUniform(
+                        DigitalNetB2(1, seed=17),
+                        p_zero=0.4,
+                        lam=lam,
+                    )
+
+    def test_zero_inflated_requires_one_dimensional_sampler(self):
+        with self.assertRaisesRegex(
+            DimensionError, "requires a one-dimensional sampler"
+        ):
+            ZeroInflatedExpUniform(
+                DigitalNetB2(2, seed=17),
+                p_zero=0.4,
+                lam=1.5,
+            )
+
+    def test_zero_inflated_inverse_transform_exact_values(self):
+        tm = ZeroInflatedExpUniform(
+            DigitalNetB2(1, seed=17),
+            p_zero=0.4,
+            lam=2.0,
+        )
+        u = np.array([[0.0], [0.2], [0.4], [0.7], [0.9]])
+
+        x = tm._transform(u)
+
+        self.assertEqual(x.shape, (5, 1))
+        self.assertTrue(np.array_equal(x[:3], np.zeros((3, 1))))
+        self.assertTrue(np.all(x[3:] > 0.0))
+
+        u_positive = u[3:, 0]
+        u_rescaled = (u_positive - 0.4) / 0.6
+        expected = -np.log1p(-u_rescaled) / 2.0
+        self.assertTrue(np.allclose(x[3:, 0], expected))
+
+    def test_zero_inflated_inverse_transform_all_zero_branch(self):
+        tm = ZeroInflatedExpUniform(
+            DigitalNetB2(1, seed=17),
+            p_zero=0.4,
+            lam=2.0,
+        )
+        u = np.array([[0.0], [0.1], [0.4]])
+
+        x = tm._transform(u)
+
+        self.assertEqual(x.shape, (3, 1))
+        self.assertTrue(np.array_equal(x, np.zeros((3, 1))))
+
+    def test_zero_inflated_inverse_transform_clips_one(self):
+        tm = ZeroInflatedExpUniform(
+            DigitalNetB2(1, seed=17),
+            p_zero=0.4,
+            lam=2.0,
+        )
+        u = np.array([[1.0]])
+
+        x = tm._transform(u)
+
+        self.assertEqual(x.shape, (1, 1))
+        self.assertTrue(np.isfinite(x).all())
+        self.assertGreater(x[0, 0], 0.0)
+
+    def test_zero_inflated_construction_does_not_warn_about_missing_pdf(self):
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always")
+            tm = ZeroInflatedExpUniform(
+                DigitalNetB2(1, seed=17),
+                p_zero=0.4,
+                lam=1.5,
+            )
+
+        self.assertEqual(tm.d, 1)
+        self.assertEqual(_missing_pdf_warnings(caught), [])
+
+    def test_zero_inflated_sampling_does_not_warn_about_missing_pdf(self):
+        tm = ZeroInflatedExpUniform(DigitalNetB2(1, seed=17), p_zero=0.4, lam=1.5)
+
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always")
+            x = tm(8)
+
+        self.assertEqual(x.shape, (8, 1))
+        self.assertEqual(_missing_pdf_warnings(caught), [])
+
+    def test_zero_inflated_return_weights_warns_once_for_missing_pdf(self):
+        tm = ZeroInflatedExpUniform(DigitalNetB2(1, seed=17), p_zero=0.4, lam=1.5)
+
+        with self.assertWarnsRegex(UserWarning, MISSING_PDF_WARNING):
+            x, jac = tm(8, return_weights=True)
+
+        self.assertEqual(x.shape, (8, 1))
+        self.assertEqual(jac.shape, (8,))
+        self.assertTrue(np.allclose(jac, 1.0))
+
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always")
+            x_second, jac_second = tm(8, return_weights=True)
+
+        self.assertEqual(x_second.shape, (8, 1))
+        self.assertTrue(np.allclose(jac_second, 1.0))
+        self.assertEqual(_missing_pdf_warnings(caught), [])
+
+    def test_zero_inflated_y_split_warns_and_uses_one_dimensional_interface(self):
+        with self.assertWarnsRegex(DeprecationWarning, "y_split"):
+            tm = ZeroInflatedExpUniform(
+                DigitalNetB2(1, seed=17),
+                p_zero=0.4,
+                lam=1.5,
+                y_split=0.5,
+            )
+
+        x = tm(4)
+
+        self.assertEqual(x.shape, (4, 1))
+        self.assertTrue(np.all(x >= 0.0))
+
+    def test_zero_inflated_y_split_preserves_deprecated_two_dimensional_usage(self):
+        with self.assertWarnsRegex(DeprecationWarning, "2D zero-inflated"):
+            tm = ZeroInflatedExpUniform(
+                DigitalNetB2(2, seed=17),
+                p_zero=0.4,
+                lam=1.5,
+                y_split=0.5,
+            )
+
+        x = tm(16)
+
+        self.assertEqual(x.shape, (16, 2))
+        self.assertTrue(np.all(x[:, 0] >= 0.0))
+        self.assertTrue(np.all((0.0 <= x[:, 1]) & (x[:, 1] <= 1.0)))
+        self.assertTrue(np.all(x[x[:, 0] == 0.0, 1] <= 0.5))
+        self.assertTrue(np.all(x[x[:, 0] > 0.0, 1] >= 0.5))
+
+    def test_zero_inflated_y_split_preserves_replicated_two_dimensional_usage(self):
+        with self.assertWarnsRegex(DeprecationWarning, "2D zero-inflated"):
+            tm = ZeroInflatedExpUniform(
+                DigitalNetB2(2, seed=17, replications=2),
+                p_zero=0.4,
+                lam=1.5,
+                y_split=0.5,
+            )
+
+        x = tm(16)
+
+        self.assertEqual(x.shape, (2, 16, 2))
+        self.assertTrue(np.all(x[..., 0] >= 0.0))
+        self.assertTrue(np.all((0.0 <= x[..., 1]) & (x[..., 1] <= 1.0)))
+        self.assertTrue(np.all(x[..., 1][x[..., 0] == 0.0] <= 0.5))
+        self.assertTrue(np.all(x[..., 1][x[..., 0] > 0.0] >= 0.5))
+
+    def test_student_t_marginals_shape(self):
+        tm = SciPyWrapper(
+            sampler=DigitalNetB2(2, seed=5),
+            scipy_distribs=stats.t(df=5),
+        )
+        x = tm(8)
+        self.assertEqual(x.shape, (8, 2))
+
+    def test_multivariate_student_t_joint_corr_and_cov(self):
+        if not hasattr(stats, "multivariate_t"):
+            self.skipTest("scipy.stats.multivariate_t not available in this SciPy version")
+
+        df = 5.0
+        rho = 0.8
+        loc = np.array([0.0, 0.0])
+        shape = np.array([[1.0, rho], [rho, 1.0]])
+
+        tm = StudentT(DigitalNetB2(2, seed=123), loc=loc, shape=shape, df=df)
+
+        n = 4096
+        x = tm(n)
+        emp_corr = np.corrcoef(x.T)[0, 1]
+
+        self.assertLess(abs(emp_corr - rho), 0.05)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/test/test_true_measures.py b/test/test_tm_true_measures.py
similarity index 100%
rename from test/test_true_measures.py
rename to test/test_tm_true_measures.py
diff --git a/test/test_unwrap_markdown.py b/test/test_unwrap_markdown.py
deleted file mode 100644
index e227b1807..000000000
--- a/test/test_unwrap_markdown.py
+++ /dev/null
@@ -1,89 +0,0 @@
-import pytest
-
-from scripts.unwrap_markdown import unwrap_markdown_text
-
-
-@pytest.mark.parametrize(
-    ("source", "expected"),
-    [
-        (
-            "- unordered first\n  unordered second\n",
-            "- unordered first unordered second\n",
-        ),
-        (
-            "- [ ] task first\n  task second\n",
-            "- [ ] task first task second\n",
-        ),
-        (
-            "10. ordered first\n    ordered second\n",
-            "10. ordered first ordered second\n",
-        ),
-    ],
-)
-def test_unwraps_list_item_continuations(source, expected):
-    updated = unwrap_markdown_text(source)
-
-    assert updated == expected
-    assert unwrap_markdown_text(updated) == updated
-
-
-def test_unwraps_adjacent_and_nested_list_items_separately():
-    source = (
-        "- parent first\n"
-        "  parent second\n"
-        "  - child first\n"
-        "    child second\n"
-        "- sibling first\n"
-        "  sibling second\n"
-    )
-
-    assert unwrap_markdown_text(source) == (
-        "- parent first parent second\n"
-        "  - child first child second\n"
-        "- sibling first sibling second\n"
-    )
-
-
-def test_preserves_list_item_blocks_and_explicit_hard_breaks():
-    source = (
-        "- first paragraph\n"
-        "  continuation\n"
-        "\n"
-        "  second paragraph\n"
-        "  continuation\n"
-        "\n"
-        "- item before code\n"
-        "      indented code\n"
-        "\n"
-        "- explicit hard break  \n"
-        "  remains separate\n"
-    )
-
-    assert unwrap_markdown_text(source) == (
-        "- first paragraph continuation\n"
-        "\n"
-        "  second paragraph continuation\n"
-        "\n"
-        "- item before code\n"
-        "      indented code\n"
-        "\n"
-        "- explicit hard break  \n"
-        "  remains separate\n"
-    )
-
-
-def test_unwraps_ordinary_paragraphs():
-    assert unwrap_markdown_text("first line\nsecond line\n") == "first line second line\n"
-
-
-@pytest.mark.parametrize("rule", ["- - -", "* * *", "_ _ _"])
-def test_preserves_horizontal_rules(rule):
-    source = f"{rule}\nfollowing paragraph\n"
-
-    assert unwrap_markdown_text(source) == source
-
-
-def test_preserves_indented_code_that_looks_like_a_list():
-    source = "    - code first\n      code second\n"
-
-    assert unwrap_markdown_text(source) == source
diff --git a/test/test_ut_plot_and_stop.py b/test/test_ut_plot_and_stop.py
new file mode 100644
index 000000000..97ee233b8
--- /dev/null
+++ b/test/test_ut_plot_and_stop.py
@@ -0,0 +1,167 @@
+import builtins
+import sys
+import types
+import unittest
+from unittest.mock import patch
+
+import numpy as np
+
+import qmcpy
+from qmcpy import plot_proj
+from qmcpy.util import stop_notebook
+
+
+class FakeAxes:
+    def __init__(self):
+        self.removed = False
+        self.calls = []
+
+    def remove(self):
+        self.removed = True
+
+    def set_xlim(self, *a, **k):
+        self.calls.append(("set_xlim", a))
+
+    def set_ylim(self, *a, **k):
+        self.calls.append(("set_ylim", a))
+
+    def set_xticks(self, *a, **k):
+        self.calls.append(("set_xticks", a))
+
+    def set_yticks(self, *a, **k):
+        self.calls.append(("set_yticks", a))
+
+    def set_aspect(self, *a, **k):
+        self.calls.append(("set_aspect", a))
+
+    def grid(self, *a, **k):
+        self.calls.append(("grid", a))
+
+    def tick_params(self, *a, **k):
+        self.calls.append(("tick_params", a))
+
+    def set_xlabel(self, *a, **k):
+        self.calls.append(("set_xlabel", a))
+
+    def set_ylabel(self, *a, **k):
+        self.calls.append(("set_ylabel", a))
+
+    def scatter(self, *a, **k):
+        self.calls.append(("scatter", a))
+
+
+class FakeFig:
+    def __init__(self):
+        self.tl = False
+
+    def tight_layout(self, *a, **k):
+        self.tl = True
+
+
+def make_fake_matplotlib(nrows, ncols):
+    plt = types.ModuleType("matplotlib.pyplot")
+    plt.style = types.SimpleNamespace()
+    plt.style.use = lambda *a, **k: None
+    plt.rcParams = {
+        "font.family": "sans-serif",
+        "axes.prop_cycle": types.SimpleNamespace(
+            by_key=lambda: {"color": ["k", "b", "r"]}
+        ),
+    }
+
+    def subplots(nrows=1, ncols=1, figsize=None, squeeze=False):
+        fig = FakeFig()
+        ax = np.empty((nrows, ncols), dtype=object)
+        for i in range(nrows):
+            for j in range(ncols):
+                ax[i, j] = FakeAxes()
+        return fig, ax
+
+    plt.subplots = subplots
+    plt.suptitle = lambda *a, **k: None
+    return plt
+
+
+class DummySampler(qmcpy.AbstractDiscreteDistribution):
+    def __init__(self, d=2):
+        super().__init__(dimension=d, replications=1, seed=1, d_limit=10, n_limit=100)
+
+    def _gen_samples(self, n_min, n_max, return_binary=False, warn=True):
+        n = n_max - n_min
+        return np.tile(np.arange(n)[:, None] / max(1, n - 1), (1, 1, self.d)).reshape(
+            self.replications, n, self.d
+        )
+
+    def __repr__(self):
+        return "DummySampler"
+
+
+class TestPlotProjAndStopNotebook(unittest.TestCase):
+
+    def test_plot_proj_with_fake_matplotlib_and_sampler(self):
+        # Inject fake matplotlib.pyplot
+        fake_plt = make_fake_matplotlib(1, 1)
+        # Create a proper matplotlib package module with colors submodule
+        fake_matplotlib = types.ModuleType("matplotlib")
+        fake_matplotlib.pyplot = fake_plt
+        fake_matplotlib.colors = types.SimpleNamespace()
+
+        with patch.dict(
+            sys.modules,
+            {"matplotlib.pyplot": fake_plt, "matplotlib": fake_matplotlib},
+        ):
+            sampler = DummySampler(d=3)
+            fig, ax = plot_proj(
+                sampler,
+                n=4,
+                d_horizontal=1,
+                d_vertical=2,
+                math_ind=True,
+                marker_size=1,
+                figfac=1,
+            )
+
+        self.assertIsInstance(fig, FakeFig)
+        self.assertIsInstance(ax, np.ndarray)
+        # At least one axes should have scatter calls or be removed
+        found = False
+        for a in ax.flatten():
+            if getattr(a, "removed", False) or any(c[0] == "scatter" for c in a.calls):
+                found = True
+                break
+        self.assertTrue(found)
+
+    def test_plot_proj_with_callable_sampler(self):
+        # sampler not instance of AbstractDiscreteDistribution -> uses t_i labels
+        fake_plt = make_fake_matplotlib(1, 1)
+        fake_matplotlib = types.ModuleType("matplotlib")
+        fake_matplotlib.pyplot = fake_plt
+        fake_matplotlib.colors = types.SimpleNamespace()
+
+        with patch.dict(
+            sys.modules,
+            {"matplotlib.pyplot": fake_plt, "matplotlib": fake_matplotlib},
+        ):
+            def sampler_callable(n):
+                return np.zeros((n, 1))
+
+            fig, ax = plot_proj(
+                sampler_callable, n=3, d_horizontal=0, d_vertical=0, math_ind=False
+            )
+
+        self.assertIsInstance(fig, FakeFig)
+
+    def test_stop_notebook_yes_and_no(self):
+        # When input is 'yes' nothing should happen
+        with patch.object(builtins, "input", lambda prompt="": "yes"):
+            # Should not raise
+            stop_notebook("prompt")
+
+        # When input is not 'yes' should exit
+        with patch.object(builtins, "input", lambda prompt="": "no"):
+            with self.assertRaises(SystemExit):
+                stop_notebook("prompt")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/test/test_util.py b/test/test_ut_util.py
similarity index 100%
rename from test/test_util.py
rename to test/test_ut_util.py

From b7647cf92ae9c2148d99ab39f10d07dab874c2ed Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Mon, 31 Aug 2026 11:08:01 +0800
Subject: [PATCH 02/51] Respond to comments from gitHub-code-quality

---
 test/test_ig_financial_option_quick.py | 5 ++---
 test/test_ut_plot_and_stop.py          | 5 ++---
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/test/test_ig_financial_option_quick.py b/test/test_ig_financial_option_quick.py
index 921701712..b05b8708b 100644
--- a/test/test_ig_financial_option_quick.py
+++ b/test/test_ig_financial_option_quick.py
@@ -2,11 +2,10 @@
 
 import numpy as np
 
-from qmcpy import FinancialOption
-import qmcpy
+from qmcpy import AbstractDiscreteDistribution, FinancialOption
 
 
-class SmallSampler(qmcpy.AbstractDiscreteDistribution):
+class SmallSampler(AbstractDiscreteDistribution):
     def __init__(self, d=3):
         super().__init__(
             dimension=d, replications=1, seed=123, d_limit=100, n_limit=1024
diff --git a/test/test_ut_plot_and_stop.py b/test/test_ut_plot_and_stop.py
index 97ee233b8..4ce81545b 100644
--- a/test/test_ut_plot_and_stop.py
+++ b/test/test_ut_plot_and_stop.py
@@ -6,8 +6,7 @@
 
 import numpy as np
 
-import qmcpy
-from qmcpy import plot_proj
+from qmcpy import AbstractDiscreteDistribution, plot_proj
 from qmcpy.util import stop_notebook
 
 
@@ -82,7 +81,7 @@ def subplots(nrows=1, ncols=1, figsize=None, squeeze=False):
     return plt
 
 
-class DummySampler(qmcpy.AbstractDiscreteDistribution):
+class DummySampler(AbstractDiscreteDistribution):
     def __init__(self, d=2):
         super().__init__(dimension=d, replications=1, seed=1, d_limit=10, n_limit=100)
 

From f46f7f334b053e539e23273fcf830187d0cf2867 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Mon, 31 Aug 2026 17:20:23 +0800
Subject: [PATCH 03/51] Fix Torch fallback test arguments

---
 test/test_ft_fast_transform_fallbacks.py | 38 +++++++++++++++++-------
 1 file changed, 27 insertions(+), 11 deletions(-)

diff --git a/test/test_ft_fast_transform_fallbacks.py b/test/test_ft_fast_transform_fallbacks.py
index d60266030..7bf9c3493 100644
--- a/test/test_ft_fast_transform_fallbacks.py
+++ b/test/test_ft_fast_transform_fallbacks.py
@@ -2,6 +2,11 @@
 
 import numpy as np
 
+try:
+    import torch
+except ImportError:
+    torch = None
+
 from qmcpy import (
     fftbr,
     fftbr_torch,
@@ -35,17 +40,28 @@ def test_non_torch_transforms_basic(self):
         omega2 = omega_fwht(3)
         self.assertEqual(omega2.shape[0], 2**3)
 
-    def test_torch_fallbacks_raise(self):
-        with self.assertRaises(Exception):
-            fftbr_torch()
-        with self.assertRaises(Exception):
-            ifftbr_torch()
-        with self.assertRaises(Exception):
-            fwht_torch()
-        with self.assertRaises(Exception):
-            omega_fftbr_torch()
-        with self.assertRaises(Exception):
-            omega_fwht_torch()
+    def test_torch_transforms_or_fallbacks(self):
+        if torch is None:
+            calls = (
+                (fftbr_torch, np.zeros(8, dtype=complex)),
+                (ifftbr_torch, np.zeros(8, dtype=complex)),
+                (fwht_torch, np.zeros(8)),
+                (omega_fftbr_torch, 3),
+                (omega_fwht_torch, 3),
+            )
+            for transform, argument in calls:
+                with self.subTest(transform=transform.__name__):
+                    with self.assertRaisesRegex(ModuleNotFoundError, "requires torch"):
+                        transform(argument)
+            return
+
+        complex_x = torch.zeros(8, dtype=torch.complex64)
+        real_x = torch.zeros(8)
+        self.assertEqual(fftbr_torch(complex_x).shape, complex_x.shape)
+        self.assertEqual(ifftbr_torch(complex_x).shape, complex_x.shape)
+        self.assertEqual(fwht_torch(real_x).shape, real_x.shape)
+        self.assertEqual(omega_fftbr_torch(3).shape[0], 2**3)
+        self.assertEqual(omega_fwht_torch(3).shape[0], 2**3)
 
 
 if __name__ == "__main__":

From 26f91c8b6b0904c3fd34a66679d170731d376943 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Fri, 4 Sep 2026 09:40:57 +0800
Subject: [PATCH 04/51] Guidelines when a test spans >1 areas

---
 CONTRIBUTING.md             | 2 +-
 scripts/check_test_style.py | 5 +++++
 test/README.md              | 7 +++++++
 3 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 63feb062a..885f9922a 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -144,7 +144,7 @@ Please see the targets in the makefile for more granular control over tests.
 
 ### Test file layout
 
-Unit tests live flat in `test/`, named `test_<area>_<topic>.py` where `<area>` is a short code for the `qmcpy` subpackage under test (`tm` true_measure, `dd` discrete_distribution, `sc` stopping_criterion, `ig` integrand, ...) or a cross-cutting bucket (`ee`, `sr`). So `pytest test/ -k test_tm_` runs every true-measure test. New files should also be written as a `unittest.TestCase` subclass rather than bare `def test_*` functions. `make check_test_style` lists any file that breaks either convention (informational; also runs inside `make format`; `STRICT=--strict` makes it fail). The full area table is in [`test/README.md`](test/README.md#test-file-organization).
+Unit tests live flat in `test/`, named `test_<area>_<topic>.py` where `<area>` is a short code for the `qmcpy` subpackage under test (`tm` true_measure, `dd` discrete_distribution, `sc` stopping_criterion, `ig` integrand, ...) or a cross-cutting bucket (`ee`, `sr`). So `pytest test/ -k test_tm_` runs every true-measure test. A test that spans two areas goes under the component actually under test, with the other named in `<topic>` (e.g. `test_sc_cubbayes_kernels.py`); use `ee` only when neither side is the clear subject, and never coin a new code — `STRICT=--strict` rejects anything outside the table. New files should also be written as a `unittest.TestCase` subclass rather than bare `def test_*` functions. `make check_test_style` lists any file that breaks either convention (informational; also runs inside `make format`; `STRICT=--strict` makes it fail). The full area table is in [`test/README.md`](test/README.md#test-file-organization).
 
 ## Documentation
 
diff --git a/scripts/check_test_style.py b/scripts/check_test_style.py
index 9fdda9fa0..e1151c0de 100755
--- a/scripts/check_test_style.py
+++ b/scripts/check_test_style.py
@@ -17,6 +17,11 @@
        kn    kernel                   sr    scripts/ tooling, packaging, docs checks
        sc    stopping_criterion
 
+   A test that spans two areas goes under the component actually under test,
+   with the other named in ``<rest>`` (e.g. ``test_sc_cubbayes_kernels.py``);
+   ``ee`` is only for tests where neither side is the clear subject.  Only the
+   codes above are accepted -- new two-letter codes are a ``--strict`` failure.
+
 Usage:
     python scripts/check_test_style.py [TEST_DIR] [--strict] [--quiet]
 
diff --git a/test/README.md b/test/README.md
index 73fb226be..d77d83930 100644
--- a/test/README.md
+++ b/test/README.md
@@ -47,6 +47,13 @@ python -m pytest test/ -k test_tm_      # every true_measure test
 make unittests PYTEST_EXTRA_ARGS="-k test_sc_"
 ```
 
+When a test spans two areas (say a stopping criterion exercised against a
+particular kernel), file it under the component actually under test and name the
+other in `<topic>` — e.g. `test_sc_cubbayes_kernels.py`. Reserve `ee` for cases
+where neither side is the clear subject. Do not invent new area codes: only the
+prefixes in the table are accepted, and `make check_test_style STRICT=--strict`
+fails on anything else.
+
 Notebook tests are separate: they live in `test/booktests/` as `tb_*.py` and are generated from `demos/` (see `test/booktests/README.md`).
 
 ### Conventions checked by `make check_test_style`

From 3ff2e4adf8f9e12b4f05a3fc5a37761ca56dd48f Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Fri, 4 Sep 2026 09:46:22 +0800
Subject: [PATCH 05/51] Merge branch 'develop' into develop_choi

---
 .github/workflows/alltests.yml                | 162 ++++-
 .github/workflows/unittests.yml               | 205 ++++++-
 .gitignore                                    |   1 +
 CONTRIBUTING.md                               |  31 +-
 README.md                                     |   4 +-
 demos/DAKOTA_Genz/dakota_genz.ipynb           |  49 +-
 demos/GBM/gbm_demo.ipynb                      | 294 +++++----
 demos/GBM/gbm_examples.ipynb                  |  42 +-
 demos/acceptance_rejection.ipynb              |  22 +-
 demos/asian-option-mlqmc.ipynb                |  30 +-
 demos/brownian_bridge.ipynb                   |  27 +-
 demos/control_variates.ipynb                  |  26 +-
 demos/copula_examples.ipynb                   |  25 +
 .../Iteration_Log_Tolerance_Demo.ipynb        |  27 +-
 .../accuracy_and_resume.ipynb                 |  34 ++
 demos/demo_resume_data/resume_examples.ipynb  |  36 +-
 demos/digital_net_b2.ipynb                    |  25 +-
 demos/elliptic-pde.ipynb                      |  39 +-
 .../gaussian_diagnostics_demo.ipynb           |  20 +-
 demos/iris.ipynb                              |  25 +-
 ...obov_hammersley_latinhypercube_demos.ipynb |  27 +-
 demos/lattice_random_generator.ipynb          |  25 +-
 demos/lebesgue_integration.ipynb              |  18 +-
 demos/linear-scrambled-halton.ipynb           |  25 +-
 demos/nei_demo.ipynb                          |  27 +-
 demos/plot_proj_function.ipynb                |  25 +-
 demos/pricing_options.ipynb                   |  23 +
 demos/product_measure.ipynb                   |  25 +
 demos/qei-demo-for-blog.ipynb                 |  23 +
 demos/qmcpy-logo.ipynb                        |  25 +
 demos/qmcpy_intro.ipynb                       |  20 +-
 demos/quickstart.ipynb                        |  32 +-
 demos/ray_tracing.ipynb                       |  23 +
 demos/sample_scatter_plots.ipynb              |  23 +
 .../scipywrapper_demo.ipynb                   |  25 +
 demos/some_true_measures.ipynb                |  23 +
 demos/statistics_for_TrueMeasure.ipynb        |  25 +
 .../talk_paper_demos/JOSS2026/joss2026.ipynb  |  33 +-
 .../MCQMC_2020_QMC_Software_Tutorial.ipynb    |  26 +-
 .../Parslfest_2025/01_sequential.ipynb        |  46 +-
 .../Parslfest_2025/02_parallel.ipynb          |  45 +-
 .../Parslfest_2025/03_visualize_speedup.ipynb |  34 ++
 .../output/01_sequential_output.ipynb         |  37 ++
 demos/talk_paper_demos/Parslfest_2025/util.py |   2 +-
 .../sorokin_thesis_2025.ipynb                 |  25 +-
 ..._LD_seq_QMC_fast_kernel_methods_2026.ipynb |  30 +-
 demos/talk_paper_demos/pydata_chi_2023.ipynb  |  27 +-
 .../why_add_q_to_mc_blog.ipynb                |  25 +
 demos/vectorized_qmc.ipynb                    |  36 +-
 demos/vectorized_qmc_bayes.ipynb              |  36 +-
 docs/ci-testing.md                            |  28 +-
 docs/mpmc-compatibility.md                    |  16 +-
 docs/tests.md                                 |  91 ++-
 makefile                                      | 102 +++-
 pyproject.toml                                |  24 +-
 .../digital_net_b2/digital_net_b2.py          |   4 +-
 qmcpy/true_measure/product_measure.py         | 137 ++++-
 scripts/__init__.py                           |   1 +
 scripts/check_colab_notebooks.py              | 567 ++++++++++++++++++
 scripts/colab_notebooks_manifest.json         |  57 ++
 scripts/harden_colab_notebook.py              | 503 ++++++++++++++++
 scripts/report_colab_notebook_patterns.py     | 164 +++++
 scripts/smoke_test_colab_notebooks.py         | 379 ++++++++++++
 test/README.md                                |  89 ++-
 test/booktests/__init__.py                    |  19 +-
 test/test_colab_notebooks.py                  | 314 ++++++++++
 test/test_sc_accumulate_data.py               |   7 +
 67 files changed, 4113 insertions(+), 329 deletions(-)
 create mode 100644 scripts/__init__.py
 create mode 100644 scripts/check_colab_notebooks.py
 create mode 100644 scripts/colab_notebooks_manifest.json
 create mode 100644 scripts/harden_colab_notebook.py
 create mode 100644 scripts/report_colab_notebook_patterns.py
 create mode 100644 scripts/smoke_test_colab_notebooks.py
 create mode 100644 test/test_colab_notebooks.py

diff --git a/.github/workflows/alltests.yml b/.github/workflows/alltests.yml
index a2b8f551c..97486f78f 100644
--- a/.github/workflows/alltests.yml
+++ b/.github/workflows/alltests.yml
@@ -8,6 +8,13 @@ on:
       - master
   workflow_dispatch:
 
+# CodeQL "Workflow does not contain permissions": restrict the GITHUB_TOKEN to
+# the minimum. These jobs only read the repo -- checkout, conda/python setup,
+# caching, and tests. Codecov uploads authenticate with CODECOV_TOKEN, not the
+# GITHUB_TOKEN, so no write scope is needed.
+permissions:
+  contents: read
+
 concurrency:
   # Keep push and pull_request runs separate so same-SHA PR updates do not inherit cancelled push checks.
   group: alltests-${{ github.event_name }}-${{ github.event.pull_request.head.repo.full_name || github.repository }}-${{ github.head_ref || github.ref_name }}
@@ -68,9 +75,36 @@ jobs:
       - uses: conda-incubator/setup-miniconda@v3
         with:
           miniconda-version: "latest"
-          auto-activate-base: true
+          python-version: ${{ matrix.python-version }}
+          channels: conda-forge
+          auto-activate-base: false
+          # Name the env explicitly: without this the active environment is
+          # ambiguous (base vs the auto-created `test`), which can leave pip
+          # and python pointing at different prefixes.
+          activate-environment: qmcpy-ci
           conda-remove-defaults: true
-          use-only-tar-bz2: true
+
+      # Without python-version above, matrix.python-version reached only the job
+      # name and every job ran the conda base interpreter. Steps touching Python
+      # must use a profile-loading shell (bash -el / pwsh) to see the env.
+      - name: Verify interpreter matches the matrix (Unix)
+        if: runner.os != 'Windows'
+        shell: bash -el {0}
+        run: |
+          echo "which python : $(which python)"
+          echo "which pip    : $(which pip)"
+          conda info --envs || true
+          python -c "import sys; print('prefix:',sys.prefix); print(sys.version)"
+          python -c "import sys; got='.'.join(map(str,sys.version_info[:2])); want='${{ matrix.python-version }}'; assert got==want, 'matrix says %s but interpreter is %s'%(want,got)"
+
+      - name: Verify interpreter matches the matrix (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: |
+          Get-Command python | Format-List
+          conda info --envs
+          python -c "import sys; print('prefix:',sys.prefix); print(sys.version)"
+          python -c "import sys; got='.'.join(map(str,sys.version_info[:2])); want='${{ matrix.python-version }}'; assert got==want, 'matrix says %s but interpreter is %s'%(want,got)"
 
       # -----------------------------------------------------------
       # Clean old coverage files
@@ -222,18 +256,22 @@ jobs:
 
       - name: Build and cache wheels (Linux)
         if: runner.os == 'Linux'
+        shell: bash -el {0}
         run: |
-          python -m pip wheel -w ./.wheels .[test,test_torch,test_gpytorch,test_botorch,test_umbridge] || true
+          python -m pip wheel -w ./.wheels ".[test,test_torch,test_gpytorch,test_botorch,test_umbridge]" || true
       - name: Install Python dependencies (Linux)
         if: runner.os == 'Linux'
+        shell: bash -el {0}
         run: |
           pip install --find-links ./.wheels -e ".[test,test_torch,test_gpytorch,test_botorch,test_umbridge]"
       - name: Build and cache wheels (macOS)
         if: runner.os == 'macOS'
+        shell: bash -el {0}
         run: |
-          python -m pip wheel -w ./.wheels .[test,test_torch,test_gpytorch,test_botorch] || true
+          python -m pip wheel -w ./.wheels ".[test,test_torch,test_gpytorch,test_botorch]" || true
       - name: Install Python dependencies (macOS)
         if: runner.os == 'macOS'
+        shell: bash -el {0}
         run: |
           pip install --find-links ./.wheels -e ".[test,test_torch,test_gpytorch,test_botorch]"
       - name: Build and cache wheels (Windows)
@@ -246,12 +284,34 @@ jobs:
         shell: pwsh
         run: |
           pip install --find-links ./.wheels -e '.[test,test_torch,test_gpytorch,test_botorch]'
-      - name: Install MPMC dependencies
-        run: |
-          qmcpy-install-mpmc
-      - name: Validate MPMC dependencies
+      - name: Install MPMC dependencies (Unix)
+        if: runner.os != 'Windows'
+        shell: bash -el {0}
+        run: qmcpy-install-mpmc
+
+      - name: Install MPMC dependencies (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: qmcpy-install-mpmc
+
+      - name: Validate MPMC dependencies (Unix)
+        if: runner.os != 'Windows'
+        shell: bash -el {0}
+        run: python -c "import torch, pyg_lib, torch_geometric; print(f'torch={torch.__version__}'); print('MPMC dependencies ready')"
+
+      - name: Validate MPMC dependencies (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: python -c "import torch, pyg_lib, torch_geometric; print(f'torch={torch.__version__}'); print('MPMC dependencies ready')"
+      # -----------------------------------------------------------
+      # Colab readiness tests (Linux only)
+      # -----------------------------------------------------------
+      - name: Run Colab readiness tests (Linux)
+        if: runner.os == 'Linux'
+        shell: bash -l {0}
         run: |
-          python -c "import torch, pyg_lib, torch_geometric; print(f'torch={torch.__version__}'); print('MPMC dependencies ready')"
+          make check_colab_notebooks
+          make check_colab_notebooks_smoke
       # -----------------------------------------------------------
       # Install minimal LaTeX required by Jupyter notebooks (OS-specific)
       # -----------------------------------------------------------
@@ -375,7 +435,7 @@ jobs:
             Invoke-WithRetry -Description "Refresh MiKTeX package database" -Script {
               mpm --admin --update-db
             }
-            $packages = @('latexmk','dvipng','cm-super','lmodern','type1cm','tex-gyre')
+            $packages = @('latexmk','dvipng','cm-super','lmodern','type1cm','tex-gyre','l3backend')
             foreach ($pkg in $packages) {
               Invoke-WithRetry -Description "Install MiKTeX package $pkg" -Script {
                 mpm --admin --install=$pkg
@@ -386,6 +446,10 @@ jobs:
           Invoke-WithRetry -Description "Refresh MiKTeX filename database" -Script {
             initexmf --admin --update-fndb
           }
+          $L3BackendPath = kpsewhich l3backend-dvips.def
+          if ([string]::IsNullOrWhiteSpace($L3BackendPath)) {
+            throw "MiKTeX install did not provide l3backend-dvips.def"
+          }
           latex --version
           latexmk -v
           dvipng --version
@@ -393,12 +457,60 @@ jobs:
       # -----------------------------------------------------------
       # Run doctests (OS-specific)
       # -----------------------------------------------------------
-      - run: pip freeze
-      - run: make doctests_minimal
-      - run: make doctests_torch
-      - run: make doctests_gpytorch
-      - run: make doctests_botorch
-      - run: make doctests_markdown
+      - name: pip freeze (Unix)
+        if: runner.os != 'Windows'
+        shell: bash -el {0}
+        run: pip freeze
+
+      - name: pip freeze (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: pip freeze
+      - name: doctests_minimal (Unix)
+        if: runner.os != 'Windows'
+        shell: bash -el {0}
+        run: make doctests_minimal
+
+      - name: doctests_minimal (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: make doctests_minimal
+      - name: doctests_torch (Unix)
+        if: runner.os != 'Windows'
+        shell: bash -el {0}
+        run: make doctests_torch
+
+      - name: doctests_torch (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: make doctests_torch
+      - name: doctests_gpytorch (Unix)
+        if: runner.os != 'Windows'
+        shell: bash -el {0}
+        run: make doctests_gpytorch
+
+      - name: doctests_gpytorch (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: make doctests_gpytorch
+      - name: doctests_botorch (Unix)
+        if: runner.os != 'Windows'
+        shell: bash -el {0}
+        run: make doctests_botorch
+
+      - name: doctests_botorch (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: make doctests_botorch
+      - name: doctests_markdown (Unix)
+        if: runner.os != 'Windows'
+        shell: bash -el {0}
+        run: make doctests_markdown
+
+      - name: doctests_markdown (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: make doctests_markdown
       - name: Run umbridge doctests on Linux full sweeps when Docker is available
         shell: bash -l {0}
         run: |
@@ -411,12 +523,26 @@ jobs:
           else
             echo "Skipping umbridge doctests because Docker is not available on this runner"
           fi
-      - name: Run MPMC doctests
+      - name: Run MPMC doctests (Unix)
+        if: runner.os != 'Windows'
+        shell: bash -el {0}
+        run: make doctests_mpmc
+
+      - name: Run MPMC doctests (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
         run: make doctests_mpmc
       # -----------------------------------------------------------
       # Run unittests for Python source files
       # -----------------------------------------------------------
-      - name: Run unittests (parallel)
+      - name: Run unittests (parallel, Unix)
+        if: runner.os != 'Windows'
+        shell: bash -el {0}
+        run: make unittests
+
+      - name: Run unittests (parallel, Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
         run: make unittests
 
       # -----------------------------------------------------------
diff --git a/.github/workflows/unittests.yml b/.github/workflows/unittests.yml
index 14342777c..1ef7bace0 100644
--- a/.github/workflows/unittests.yml
+++ b/.github/workflows/unittests.yml
@@ -11,6 +11,13 @@ on:
       - master
   workflow_dispatch:
 
+# CodeQL "Workflow does not contain permissions": restrict the GITHUB_TOKEN to
+# the minimum. These jobs only read the repo -- checkout, conda/python setup,
+# caching, and tests. Codecov uploads authenticate with CODECOV_TOKEN, not the
+# GITHUB_TOKEN, so no write scope is needed.
+permissions:
+  contents: read
+
 concurrency:
   group: unittests-${{ github.event.pull_request.number || github.ref }}
   cancel-in-progress: true
@@ -21,23 +28,19 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
         matrix:
+            # These versions are real: python-version is passed to
+            # setup-miniconda and asserted by the "Verify interpreter" step.
+            # Floor is 3.10 -- the `test` extra needs pytest >= 9.0.3 and
+            # parsl >= 2026.01.05, which both require 3.10+. Older interpreters
+            # run in the core-tests job below. Each version appears once; the
+            # full install set resolves on all three OSes for 3.10-3.14.
             include:
-              - os: macos-latest
-                python-version: '3.5'
-              - os: macos-latest
-                python-version: '3.8'
               - os: macos-latest
                 python-version: '3.11'
               - os: macos-latest
                 python-version: '3.14'
-              - os: ubuntu-latest
-                python-version: '3.6'
-              - os: ubuntu-latest
-                python-version: '3.9'
               - os: ubuntu-latest
                 python-version: '3.12'
-              - os: windows-latest
-                python-version: '3.7'
               - os: windows-latest
                 python-version: '3.10'
               - os: windows-latest
@@ -48,9 +51,37 @@ jobs:
       - uses: conda-incubator/setup-miniconda@v3
         with:
           miniconda-version: "latest"
-          auto-activate-base: true
+          python-version: ${{ matrix.python-version }}
+          channels: conda-forge
+          auto-activate-base: false
+          # Name the env explicitly: without this the active environment is
+          # ambiguous (base vs the auto-created `test`), which can leave pip
+          # and python pointing at different prefixes.
+          activate-environment: qmcpy-ci
           conda-remove-defaults: true
-          use-only-tar-bz2: true
+
+      # Guards the failure mode this matrix used to have: the job name claimed a
+      # Python version while every job actually ran the conda base interpreter.
+      # Steps that touch Python must use a profile-loading shell (bash -el / pwsh)
+      # or they will see base rather than the activated env.
+      - name: Verify interpreter matches the matrix (Unix)
+        if: runner.os != 'Windows'
+        shell: bash -el {0}
+        run: |
+          echo "which python : $(which python)"
+          echo "which pip    : $(which pip)"
+          conda info --envs || true
+          python -c "import sys; print('prefix:',sys.prefix); print(sys.version)"
+          python -c "import sys; got='.'.join(map(str,sys.version_info[:2])); want='${{ matrix.python-version }}'; assert got==want, 'matrix says %s but interpreter is %s'%(want,got)"
+
+      - name: Verify interpreter matches the matrix (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: |
+          Get-Command python | Format-List
+          conda info --envs
+          python -c "import sys; print('prefix:',sys.prefix); print(sys.version)"
+          python -c "import sys; got='.'.join(map(str,sys.version_info[:2])); want='${{ matrix.python-version }}'; assert got==want, 'matrix says %s but interpreter is %s'%(want,got)"
 
       # -----------------------------------------------------------
       # Clean old coverage files
@@ -194,21 +225,25 @@ jobs:
 
       - name: Build and cache wheels (Linux)
         if: runner.os == 'Linux'
+        shell: bash -el {0}
         run: |
-          python -m pip wheel -w ./.wheels .[test,test_torch,test_gpytorch,test_botorch,test_umbridge] || true
+          python -m pip wheel -w ./.wheels ".[test,test_torch,test_gpytorch,test_botorch,test_umbridge]" || true
 
       - name: Install Python dependencies (Linux)
         if: runner.os == 'Linux'
+        shell: bash -el {0}
         run: |
           pip install --find-links ./.wheels -e ".[test,test_torch,test_gpytorch,test_botorch,test_umbridge]"
 
       - name: Build and cache wheels (macOS)
         if: runner.os == 'macOS'
+        shell: bash -el {0}
         run: |
-          python -m pip wheel -w ./.wheels .[test,test_torch,test_gpytorch,test_botorch] || true
+          python -m pip wheel -w ./.wheels ".[test,test_torch,test_gpytorch,test_botorch]" || true
 
       - name: Install Python dependencies (macOS)
         if: runner.os == 'macOS'
+        shell: bash -el {0}
         run: |
           pip install --find-links ./.wheels -e ".[test,test_torch,test_gpytorch,test_botorch]"
 
@@ -227,5 +262,145 @@ jobs:
       # -----------------------------------------------------------
       # Run unittests for Python source files
       # -----------------------------------------------------------
-      - name: Run unittests (parallel)
+      - name: Run unittests (parallel, Unix)
+        if: runner.os != 'Windows'
+        shell: bash -el {0}
         run: make unittests
+
+      - name: Run unittests (parallel, Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: make unittests
+
+  # Exercise the supported 3.9 floor without the `test` extra's Python 3.10+
+  # dependencies. First verify the built wheel as a user would install it;
+  # then run test/test_*.py against the slim `test_core` extra. Modules needing
+  # an optional stack skip themselves via pytest.importorskip.
+  # The 3.9 support claim is OS-independent, so prove it on every OS we ship
+  # for. qmctoolscl publishes exactly one wheel (cp312, win_amd64), so all three
+  # legs build it from its sdist -- which is precisely the risk being covered.
+  core-tests:
+    name: Core Unit Tests on ${{ matrix.os }} (Python ${{ matrix.python-version }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+        fail-fast: false
+        matrix:
+            os: [ubuntu-latest, macos-latest, windows-latest]
+            python-version: ['3.9']
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: conda-incubator/setup-miniconda@v3
+        with:
+          miniconda-version: "latest"
+          python-version: ${{ matrix.python-version }}
+          channels: conda-forge
+          auto-activate-base: false
+          activate-environment: qmcpy-core
+          conda-remove-defaults: true
+
+      - name: Verify interpreter matches the matrix (Unix)
+        if: runner.os != 'Windows'
+        shell: bash -el {0}
+        run: |
+          echo "which python : $(which python)"
+          conda info --envs || true
+          python -c "import sys; print('prefix:',sys.prefix); print(sys.version)"
+          python -c "import sys; got='.'.join(map(str,sys.version_info[:2])); want='${{ matrix.python-version }}'; assert got==want, 'matrix says %s but interpreter is %s'%(want,got)"
+
+      - name: Verify interpreter matches the matrix (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: |
+          conda info --envs
+          python -c "import sys; print('prefix:',sys.prefix); print(sys.version)"
+          python -c "import sys; got='.'.join(map(str,sys.version_info[:2])); want='${{ matrix.python-version }}'; assert got==want, 'matrix says %s but interpreter is %s'%(want,got)"
+
+      - name: Build and test the user wheel (Unix)
+        if: runner.os != 'Windows'
+        shell: bash -el {0}
+        run: |
+          python -m pip install build
+          python -m build --wheel
+          python -m pip install dist/*.whl
+          python -m pip check
+          python -c "import os,tempfile; os.chdir(tempfile.gettempdir()); import qmcpy; print(qmcpy.__file__)"
+
+      - name: Build and test the user wheel (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: |
+          python -m pip install build
+          python -m build --wheel
+          $wheel = (Get-ChildItem dist/*.whl | Select-Object -First 1).FullName
+          python -m pip install $wheel
+          python -m pip check
+          python -c "import os,tempfile; os.chdir(tempfile.gettempdir()); import qmcpy; print(qmcpy.__file__)"
+
+      - name: Install qmcpy and minimal test dependencies (Unix)
+        if: runner.os != 'Windows'
+        shell: bash -el {0}
+        run: python -m pip install -e ".[test_core]"
+
+      - name: Install qmcpy and minimal test dependencies (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: python -m pip install -e ".[test_core]"
+
+      - name: Run core unit tests (Unix)
+        if: runner.os != 'Windows'
+        shell: bash -el {0}
+        run: make unittests_core
+
+      - name: Run core unit tests (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: make unittests_core
+
+  # Early-warning job for the next Python. 3.15.0-rc.1 is published in
+  # actions/python-versions but NOT in conda-forge, so this uses setup-python
+  # rather than setup-miniconda like the jobs above.
+  #
+  # Non-blocking by design: at time of writing scipy (a core dependency) and
+  # scikit-learn publish no cp315 wheels, so the install is expected to fail
+  # until the scientific stack catches up. The job exists to tell us the day
+  # that changes -- when it goes green, promote 3.15 into the `tests` matrix.
+  prerelease-tests:
+    name: Core Unit Tests (Python ${{ matrix.python-version }}, pre-release)
+    runs-on: ubuntu-latest
+    # Never gate a merge on an unreleased interpreter.
+    continue-on-error: true
+    strategy:
+        fail-fast: false
+        matrix:
+            python-version: ['3.15.0-rc.1']
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          allow-prereleases: true
+
+      - name: Report interpreter
+        run: python -VV
+
+      # Step-level continue-on-error is still needed: without it a failed
+      # install would skip the reporting step below.
+      - name: Install qmcpy and minimal test dependencies
+        id: install
+        continue-on-error: true
+        run: pip install -e ".[test_core]"
+
+      - name: Run core unit tests
+        if: steps.install.outcome == 'success'
+        run: make unittests_core
+
+      - name: Report pre-release ecosystem not ready
+        if: steps.install.outcome != 'success'
+        run: |
+          echo "::warning title=Python ${{ matrix.python-version }} not installable::\
+          qmcpy could not be installed on Python ${{ matrix.python-version }}. \
+          This is expected while the scientific stack lacks cp315 wheels (scipy \
+          and scikit-learn in particular). See the install log above; when this \
+          job passes, promote 3.15 into the tests matrix."
diff --git a/.gitignore b/.gitignore
index 5c4b0f3c8..9fae76cab 100644
--- a/.gitignore
+++ b/.gitignore
@@ -39,6 +39,7 @@ demos/prob_failure_gp_ci_plots/
 demos/fgpr_figs/
 demos/GBM/images/*.png
 demos/GBM/outputs/*.*
+*.tmp_colab*
 
 # Generated notebook/demo images
 figures/
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 885f9922a..6c0fe3ae5 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -73,6 +73,27 @@ pip install -e ".[mpmc]"
 qmcpy-install-mpmc
 ~~~
 
+### Minimum Python Version by Role
+
+`requires-python` covers a bare install; the optional dependency groups in `pyproject.toml` raise it. Each row shows the strictest floor among that role's pinned dependencies. Rows marked `+` add a capability to the Application-user install; unmarked rows are self-contained role profiles.
+
+| Role | Install command | Binding constraint | Minimum Python |
+|---|---|---|---|
+| Application user | `pip install qmcpy` | QMCPy support policy | 3.9 |
+| + torch / GP features | `pip install "qmcpy[torch,gpytorch]"` | inherits the QMCPy floor | 3.9 |
+| + MPMC | `pip install "qmcpy[mpmc]"`, then `qmcpy-install-mpmc` | `torch >= 2.10.0` | 3.10 |
+| + Bayesian optimization | `pip install "qmcpy[botorch]"` | `botorch >= 0.10.0` | 3.9 |
+| Course instructor (`class`) | `pip install -e ".[class]"` | `arviz >= 0.17`, `matplotlib >= 3.9.0`, `statsmodels >= 0.14.3` | 3.9 |
+| Test developer | `pip install -e ".[test]"` | `pytest >= 9.0.3`, `parsl >= 2026.01.05` | 3.10 |
+| Documentation developer | `pip install -e ".[docs]"` | inherits `test`; `pylint >= 4.0.5` | 3.10 |
+| Release / core developer | `pip install -e ".[dev]"` | inherits `docs` / `test` | 3.10 |
+
+Using `qmcpy` needs Python **3.9+**; contributing code, running tests, or building docs needs **3.10+**. We recommend 3.13 for development.
+
+Python 3.9 is a deliberate QMCPy **support-policy floor**, not a claim about source syntax or `qmctoolscl`'s declared floor. It is the oldest interpreter whose current runtime stack QMCPy commits to support and test; earlier versions are outside that policy even if a particular toolchain can install them.
+
+CI measures the lower tier rather than assuming it: `unittests.yml`'s `core-tests` job builds the QMCPy wheel on Python 3.9 on Linux, macOS, and Windows, installs it with no extras, checks its dependencies, and imports it from outside the source tree. The 3.9 claim is OS-independent, and `qmctoolscl` ships only one wheel (cp312, `win_amd64`), so every leg builds it from its source distribution. It then runs `make unittests_core` with the slim `test_core` extra and no notebook stack. Its main `tests` job runs the full suite on 3.10-3.14, each version on one operating system. Every conda matrix asserts the running interpreter before any test runs. Test modules self-skip via `pytest.importorskip` when an optional stack (torch, gpytorch, PyG) is absent, so each interpreter runs what applies to it.
+
 ## 📚 Using `qmcpy` In Courses (`class` Extra)
 
 `qmcpy` provides a `class` optional dependency group that installs a complete teaching environment (JupyterLab, plotting, statistics, and utilities) in addition to `qmcpy` itself.
@@ -209,12 +230,18 @@ In the built HTML documentation:
 
 ## Demos
 
-Demos are Jupyter notebooks which may be launched using the command
+Demos are Jupyter notebooks under `demos/`. To open one:
 
 ~~~bash
-jupyter-lab
+jupyter-lab                                              # or: make open_notebook NOTEBOOK=demos/quickstart.ipynb
+make open_colab_notebook NOTEBOOK=demos/quickstart.ipynb # in Colab, from your current (pushed) branch
+make open_colab_notebook_gist NOTEBOOK=demos/quickstart.ipynb  # in Colab, from your uncommitted working copy (needs the gh CLI)
 ~~~
 
+`open_colab_notebook` uses the branch version only when the notebook is new or differs from `develop`, otherwise the `develop` version. See [docs/tests.md](docs/tests.md) for details.
+
+Note: `make format` runs `make harden_colab_notebook`, so it will insert a Colab badge and bootstrap cell into any unclassified `demos/*.ipynb` and add it to `scripts/colab_notebooks_manifest.json` (and fail if a notebook cannot be hardened automatically).
+
 ## Other Developer Tools
 
 The [Developers Tools](https://qmcpy.org/references-for-python-and-mathematical-software-development/) page on [qmcpy.org](https://qmcpy.org) documents additional tools we have found helpful for mathematical software development and presentation.
diff --git a/README.md b/README.md
index b55375193..5d31f0817 100644
--- a/README.md
+++ b/README.md
@@ -28,6 +28,8 @@ The [QMCPy documentation](https://QMCSoftware.github.io/QMCSoftware/) contains a
 pip install qmcpy
 ```
 
+Requires Python >= 3.9. Contributing code, running tests, or building the documentation requires Python >= 3.10 — see the [Minimum Python Version by Role](https://qmcsoftware.github.io/QMCSoftware/CONTRIBUTING/#minimum-python-version-by-role) table in the contributing guidelines for the full breakdown.
+
 To install from source, please see the [contributing guidelines](https://qmcsoftware.github.io/QMCSoftware/CONTRIBUTING/).
 
 ## Citation
@@ -64,4 +66,4 @@ Want to contribute to QMCPy? Please see our [guidelines for contributors](https:
 
 This software would not be possible without the efforts of the [QMCPy community](https://qmcsoftware.github.io/QMCSoftware/community) including our steering council, collaborators, contributors, and sponsors.
 
-QMCPy is distributed under an [Apache 2.0 license from the Illinois Institute of Technology](https://github.com/QMCSoftware/QMCSoftware/blob/master/LICENSE).
\ No newline at end of file
+QMCPy is distributed under an [Apache 2.0 license from the Illinois Institute of Technology](https://github.com/QMCSoftware/QMCSoftware/blob/master/LICENSE).
diff --git a/demos/DAKOTA_Genz/dakota_genz.ipynb b/demos/DAKOTA_Genz/dakota_genz.ipynb
index ea83ae0fd..77830a313 100644
--- a/demos/DAKOTA_Genz/dakota_genz.ipynb
+++ b/demos/DAKOTA_Genz/dakota_genz.ipynb
@@ -14,12 +14,28 @@
     },
     {
       "cell_type": "markdown",
-      "id": "385fe7c1-64b4-46a2-a7de-8599511b83da",
-      "metadata": {
-        "id": "385fe7c1-64b4-46a2-a7de-8599511b83da"
-      },
+      "id": "6952b7c0",
+      "metadata": {},
+      "source": [
+        "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/DAKOTA_Genz/dakota_genz.ipynb)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "7fadab1b",
+      "metadata": {},
+      "outputs": [],
       "source": [
-        "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/dakota_genz.ipynb)"
+        "# @title Execute this cell to install dependencies\n",
+        "try:\n",
+        "  import google.colab\n",
+        "  IN_COLAB = True\n",
+        "except ImportError:\n",
+        "  IN_COLAB = False\n",
+        "if IN_COLAB:\n",
+        "  !pip install -q qmcpy\n",
+        "  !tmp=$(mktemp) && if { apt-get update -qq && DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends texlive-latex-base texlive-fonts-recommended texlive-latex-extra cm-super dvipng; } >\"$tmp\" 2>&1; then rm -f \"$tmp\"; else status=$?; cat \"$tmp\"; rm -f \"$tmp\"; exit $status; fi\n"
       ]
     },
     {
@@ -75,7 +91,7 @@
         "kinds_func = ['oscillatory','corner-peak']\n",
         "kinds_coeff = [1,2,3]\n",
         "ds = 2**arange(8)\n",
-        "ns = 2**arange(7,19)\n",
+        "ns = 2**arange(7, 13 if IN_COLAB else 19)  # smaller sweep on Colab\n",
         "ds"
       ]
     },
@@ -240,7 +256,7 @@
         "# takes about 5.5 min to run for me\n",
         "ref_sols = {}\n",
         "print('logging: ',end='',flush=True)\n",
-        "x_full = DigitalNetB2(ds.max(),seed=7).gen_samples(2**22)\n",
+        "x_full = DigitalNetB2(ds.max(),seed=7).gen_samples(2**16 if IN_COLAB else 2**22)  # 2**22 needs ~4 GB RAM\n",
         "for kind_func in kinds_func:\n",
         "    for kind_coeff in kinds_coeff:\n",
         "        tag = '%s.%d'%(kind_func,kind_coeff)\n",
@@ -275,10 +291,19 @@
         }
       ],
       "source": [
+        "if not os.path.isfile(\"x_full_dakota.txt\"):\n",
+        "    try:\n",
+        "        import gdown\n",
+        "        gdown.download(\"https://drive.google.com/uc?id=1ljmpq3w5L4OjjdinAMSLhXBeWGW6EJ3U\", \"x_full_dakota.txt\", quiet=True)\n",
+        "    except Exception as e:\n",
+        "        print(f\"Auto-download of x_full_dakota.txt failed ({e}); the Dakota comparison will be skipped.\")\n",
+        "\n",
         "if os.path.isfile(\"x_full_dakota.txt\"):\n",
         "    x_full_dakota = np.loadtxt(\"x_full_dakota.txt\")\n",
         "else:\n",
-        "    print(\"please download Dakota's Halton points from https://drive.google.com/uc?id=1ljmpq3w5L4OjjdinAMSLhXBeWGW6EJ3U\")\n",
+        "    x_full_dakota = None  # data file absent (e.g. Colab); Dakota comparison skipped\n",
+        "    print(\"x_full_dakota.txt not found; skipping the Dakota Halton comparison.\")\n",
+        "    print(\"To include it, download https://drive.google.com/uc?id=1ljmpq3w5L4OjjdinAMSLhXBeWGW6EJ3U into this folder.\")\n",
         "    # with tempfile.TemporaryDirectory() as tmp:\n",
         "    #     with open(os.path.join(tmp, \"dakota.in\"), \"w\") as io:\n",
         "    #         io.write(f\"environment\\\n",
@@ -311,7 +336,8 @@
         "    #                 x_full_dakota.append([float(lines[n + 1 + j].split()[0]) for j in range(ds.max())])\n",
         "    #         x_full_dakota = np.vstack(x_full_dakota)\n",
         "    #     np.savetxt(\"data/x_full_dakota.txt\",x_full_dakota)\n",
-        "print(x_full_dakota.shape)"
+        "if x_full_dakota is not None:\n",
+        "    print(x_full_dakota.shape)"
       ]
     },
     {
@@ -329,8 +355,9 @@
         "    'Lattice (random shift)': Lattice(d_max).gen_samples(n_max),\n",
         "    'Digital Net (random scramble + shift)': DigitalNetB2(d_max).gen_samples(n_max),\n",
         "    'Halton (QMCPy)': Halton(d_max).gen_samples(n_max,warn=False),\n",
-        "    'Halton (Dakota)': x_full_dakota[:n_max,:d_max]\n",
-        "}"
+        "}\n",
+        "if x_full_dakota is not None:\n",
+        "    pts['Halton (Dakota)'] = x_full_dakota[:n_max,:d_max]"
       ]
     },
     {
diff --git a/demos/GBM/gbm_demo.ipynb b/demos/GBM/gbm_demo.ipynb
index 5199aa087..7cbaf6415 100644
--- a/demos/GBM/gbm_demo.ipynb
+++ b/demos/GBM/gbm_demo.ipynb
@@ -7,13 +7,6 @@
     "# Geometric Brownian Motion Demo"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/gbm_demo.ipynb)"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -32,9 +25,45 @@
     "- Random seeds: 42 (QMCPy), 7 (QuantLib)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/GBM/gbm_demo.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  import sys\n",
+    "  import os\n",
+    "  repo_root = \"/content/QMCSoftware\"\n",
+    "  notebook_dir = f\"{repo_root}/demos/GBM\"\n",
+    "  if not os.path.isdir(repo_root):\n",
+    "    !git clone -q --depth 1 https://github.com/QMCSoftware/QMCSoftware {repo_root}\n",
+    "  !pip install -q qmcpy\n",
+    "  !pip install -q ipywidgets QuantLib\n",
+    "  os.chdir(notebook_dir)\n",
+    "  if notebook_dir not in sys.path:\n",
+    "    sys.path.insert(0, notebook_dir)\n",
+    "  extra_path = f\"{repo_root}/demos/GBM/gbm_code\"\n",
+    "  if extra_path not in sys.path:\n",
+    "    sys.path.insert(0, extra_path)\n"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -46,7 +75,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -69,7 +98,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -78,7 +107,7 @@
     "os.makedirs('images', exist_ok=True)\n",
     "\n",
     "# Toggle debug mode\n",
-    "cf.is_debug = False"
+    "cf.is_debug = IN_COLAB  # use the smaller parameter sweep on Colab's limited runtime"
    ]
   },
   {
@@ -121,7 +150,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
@@ -130,14 +159,24 @@
      "text": [
       "Help on function __init__ in module qmcpy.true_measure.geometric_brownian_motion:\n",
       "\n",
-      "__init__(self, sampler, t_final=1, initial_value=1, drift=0, diffusion=1, decomp_type='PCA', lazy_load=True, lazy_decomp=True)\n",
+      "__init__(\n",
+      "    self,\n",
+      "    sampler,\n",
+      "    t_final=1,\n",
+      "    initial_value=1,\n",
+      "    drift=0,\n",
+      "    diffusion=1,\n",
+      "    decomp_type='PCA',\n",
+      "    lazy_load=True,\n",
+      "    lazy_decomp=True\n",
+      ")\n",
       "    Args:\n",
       "        sampler (DiscreteDistribution/TrueMeasure): A discrete distribution or true measure.\n",
       "        t_final (float): End time for the geometric Brownian motion, non-negative.\n",
       "        initial_value (float): Positive initial value of the process, $S_0$.\n",
       "        drift (float): Drift coefficient $\\gamma$.\n",
       "        diffusion (float): Positive diffusion coefficient $\\sigma^2$, where $\\sigma$ is volatility.\n",
-      "        decomp_type (str): Method of decomposition, either \"PCA\" or \"Cholesky\".\n",
+      "        decomp_type (str): Method of decomposition, either \"PCA\", \"Cholesky\", or \"BrownianBridge\".\n",
       "        lazy_load (bool): If True, defer GBM-specific computations until needed.\n",
       "        lazy_decomp (bool): If True, defer expensive matrix decomposition until needed.\n",
       "\n"
@@ -150,7 +189,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
@@ -159,7 +198,14 @@
      "text": [
       "Help on function gen_samples in module qmcpy.true_measure.geometric_brownian_motion:\n",
       "\n",
-      "gen_samples(self, n=None, n_min=None, n_max=None, return_weights=False, warn=True) -> Union[numpy.ndarray, Tuple[numpy.ndarray, numpy.ndarray]]\n",
+      "gen_samples(\n",
+      "    self,\n",
+      "    n=None,\n",
+      "    n_min=None,\n",
+      "    n_max=None,\n",
+      "    return_weights=False,\n",
+      "    warn=True\n",
+      ") -> Union[numpy.ndarray, Tuple[numpy.ndarray, numpy.ndarray]]\n",
       "    Generate GBM samples using the parent's transform pipeline.\n",
       "\n",
       "    Args:\n",
@@ -188,7 +234,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
@@ -204,7 +250,7 @@
        "    decomp_type     PCA"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -216,7 +262,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
@@ -228,7 +274,7 @@
        "       [0.619371  , 0.31898397]])"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -255,7 +301,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
@@ -282,7 +328,7 @@
        "    decomp_type     PCA"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -329,7 +375,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -373,12 +419,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 700x400 with 1 Axes>"
       ]
@@ -388,7 +434,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 700x400 with 1 Axes>"
       ]
@@ -414,12 +460,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAArwAAAGQCAYAAABMPLOTAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQV0W8fWhbdFZmbHYWZOmkKapklTSJmZuX3l9pUZ/sIrMzMnhTQNtGFmZrQTM7Ms+teZuSOybMvsOOdbS5EsKYKrC/ue2bNPgMPhcIBhGIZhGIZhOii6tv4ADMMwDMMwDNOSsOBlGIZhGIZhOjQseBmGYRiGYZgODQtehmEYhmEYpkPDgpdhGIZhGIbp0LDgZRiGYRiGYTo0LHgZhmEYhmGYDg0LXoZhGIZhGKZDw4KXYRiGYRiG6dCw4GUYhmEYhmE6NCx4GYZhGIZhmA4NC16GYRiGYRimQ8OCl2EYhmEYhunQsOBlGIZhGIZhOjQseBmGYRiGYZgODQtehmEYhmEYpkPDgpdhGIZhGIbp0LDgZRiGYRiGYTo0LHgZhmEYhmGYDg0LXoZhGIZhGKZDw4KXYRiGYRiG6dCw4GUYhmEYhmE6NCx4GYZhGIZhmA4NC16GYRiGYRimQ8OCl2EYhmEYhunQsOBtJxw4cAABAQH44osvnPc99dRT4r7Wpq3et7nJzs7GBRdcgNjYWPF93njjjbb+SEc03bp1wzXXXNPWH6NdMmHCBHE5mliwYIHYruj6SKaj7O/a8ljV2tvW0b5vp2VP35t+C8Z/WPD6WInUxWAwoFOnTuIgf/jwYXQkKioqxI7+SD9Y1cU999yD2bNn4+GHH8bXX3+NU089tc7nm81mvP322zj++OMRHR0Nk8mElJQUnHXWWfj+++9hs9nQEdi2bZv47dtyZ0ni2X1bCwoKQu/evfHAAw+goKCgzT7XkSo66fLNN9/4fM5xxx0nHh80aFCj3uO9995rNXFztEHHlrCwMI/7SNx5/1bu24tOp0NUVBQGDx6Mm266CStXrvT52mVlZXjyySfFa4WGhgpxOGzYMNx1113IyMhwPm/mzJlif9Dc38Mdeqw5T5Ybum9nXLSH/X+b4WCcfP755w5aJM8884zj66+/dnz88ceO66+/3qHX6x09e/Z0VFZWttjS2r9/v3hv+gwKi8XSYu+Zm5sr3u/JJ5+s8VhLvm9rkpiY6Lj88sv9em5OTo5j5MiRYplMmTLF8eqrrzo+++wzxwsvvOCYOHGic73oCPz888/i+8yfP79B/6+qqspRXV3dLJ+ha9eujmHDhontTG1rt9xyi8NgMDhGjx7tONIwm83i0trQb0i/ZVBQkOO0006rdb9Cjw8cOLBR70H/78QTT6xxv81mE/sJuj6Sacv93dVXX+0IDQ31uI+Wtfdv5b29vPfee44777zTkZSUJH7fe+65x+P5tJ0OHz7cERwcLLarDz74QOzTrr32WkdcXJzHtn/77beL12jKscrX93CHHqPnNNe21ZB9e0fEarWKddZut7fa/r8jYGhrwd0eOe200zBq1Chx+4YbbkBcXBz+7//+D3/88QcuuuiiVvscVGGmS2vTVu/b3OTk5IhKiD9ceeWVWL9+PX799Vecd955Ho9RFWHNmjXYuXMnjjYcDgeqqqoQHByMwMDAZn1tGj254oornH/TtkaVoFdffRW7d+8WFd/aKC8vF1Wr9gKNBrQlp59+utg/5eXlif2V4rvvvkNiYqJYloWFhc36nlRppMr8kc6Rsr/z3l4IOi5ddtlleP3118VvfOutt4r7f/vtN7E/+/bbb8Xj7tD2XF1djSMFX9tWQ/bt/kDLhN6H1ukjAb1eLy5Mwzgyft025oQTThDXe/fu9bh/x44dwkcUExMjdvwkkumg4w4Nz95///1i+IkO5hEREUJQb9y4scHeMhoSch8Gdr+oISnakT3xxBMYOXIkIiMjhSigzz9//nzn69BQRnx8vLj99NNP13gNX542q9WKZ599Fj179hTCh4bYHnnkEWEDcIfunzp1KpYsWYIxY8aI5dKjRw989dVXHs+zWCzivWknTc+h4TayEsydO7fe5bJv3z5ceOGFYrmHhITgmGOOwV9//VXDmkJi7d1333V+v9pYvny5GB6j4UFvsaug3/byyy/3uI++Ow0Z9urVSyyTzp0748EHH6yxTBq67GiYmt6PRCatN8p2Mm3aNPE3LS/6femA5k196yQtG1p2xEknneRcNuo91Geg5aE+w4cffuh8zHtYsqioSAwv0mP03VJTU3HVVVcJ4dUYkpKSxLW7AFHDpbT9kbALDw93/hYkfO+77z6x7On9+/btKwQz/fYK+k1HjBjh8T5nnnmm+N7uy4aGhum+v//+27ms6O+lS5fi3nvvFdsMbU/nnnsucnNz6/QZ+rMduvsh6TN/9NFHznVk9OjRWL16td/L7eyzzxb/7+eff/a4nwQvnaT7Ojj6s17SfVu3bsXChQud64r6nrV5eOkz0PemdYfEN4k0b0uY+k3p/nPOOUfcpuVL+0p/rEPu+yt3vNdRf/YzvvZ39Pcdd9whhCNZAmj5DBw4ELNmzarxnmp7pdenZUnbS2v5gmkZ05A+be/PP/+8c71Xxyqys3hDn5OOQwQtK9pHEu7HE/ftm55D6zAJzKuvvlrc11Qau23Vt2+v79jgvt7+8MMPeOyxx8SJBD23pKTEuV6mpaWJ/SDdpsfVMtq8eTMmTpwoPmvXrl3F9lUf7ts4nZjQ/6Pf7cQTT8SWLVtqPH/evHliX0HvQcuctu3t27f7XH7utgR/jr1f1LP/p8LOlClTxHZLn7F79+647rrr0FFo/6e17QC1UpGvU0EHAdqZ0Mbw3//+V6ycP/30k9h5U5WQNly1AdJOk1YyWnnIbE87RFrZyUtDHlF/ufnmmzFp0iSP+2gHTGfxCQkJ4m/aaD/55BNceumluPHGG1FaWopPP/1UrMSrVq0SHi7aubz//vuiGkCfU4m8IUOG1PreVH378ssvhZgigUHi4MUXXxQb4vTp0z2eu2fPHvG866+/XuwgP/vsM7EjoYMgHTQIOiDQ/6fXpY2TPjdtbOvWrcPkyZNr/Ry0/I499ljhQf7Pf/4jDmD0uchn+8svv4jvM378eHEQoKotvRYJsLr4888/xbV39aQu7Ha7eE/auZBQ7t+/v9gZ0g5t165d4jdv7LKjigz91vR5aCdJ4uyDDz4QYuS2224Tz6P/T0KGqs6qKuHPOknLhpbbW2+9JV6PPjehrgl6TVp/6DPQOkQisjaPIO2Y6XvQTpFEJQldEpGHDh3yqDT6gsSIEsZUYSEB/7///U98RtpWvMUZrcMkVmiZ0AGKDnr0G5CIpHWN1m0S6uQDJiFFvwVBn/H3338X6xgd6On/0YGWltvixYvFaxB0m+7zFgl33nmn2Pbp5Ib2BTRBhsTQjz/+WOt382c7dIcOnPQcWuZ0AHr55ZfFdkn7D6PRiPqg5UEHRvKaqyofnVTTOkGfY9OmTTX+jz/rJX1X+v504H/00UfFfVQxrg06oF577bVCsNNr0fb65ptviuVNv697VY6ELS2PsWPHit/0n3/+wWuvvSZEo/oOTaWx+xmCtm06yaRtjk6yaJs5//zzhRii/Q5B34n8o8nJyUJY03d65plnnAWF1oB+G9q2af2iYwrtY0lUESR2SNTVJr5pfSM/L50A0D7THdpOaJ2i5XDLLbeIfQStF7RPby4aum3VtW/359jgDp3sUVWXTrLoJE9Vkuk3pKIUvRdth3R8pc9E+1PaBuhkm7ZN2ifT+48bN67G/soX9FvQNn777beL/R1tFySe6bihtinaBui9SajSultZWSnmldA+idZZErV1Ud+xd3wd+3+qmp9yyili3aXjB22r9JvQNtBhaGtPRXv08P7zzz/C45qenu745ZdfHPHx8Y7AwEDxt+Lkk092DB48WPgaFeSnOfbYYx29e/d23kePe3vcyANFr+fuCfXliyJ/bV0/0e7dux2RkZGOyZMnC08PQdfefqfCwkLhebruuuv88vB6v++GDRvE3zfccIPH8+6//35x/7x58zy8ZnTfokWLPPyx9H3vu+8+531Dhw51nHHGGY6Gcvfdd4vXX7x4sfO+0tJSR/fu3R3dunXzWNb0PPKn1ce5554rnltUVORxP3mkaDmpCy1HBfnodDqdx+cgyCtHr7V06dJGL7tly5Y575s9e7a4j7x4Bw8edN7/4Ycf1vBh+btO1uXhUp9h1qxZPh9z9+E98cQT4rnTpk2r8dz6vGXqfbwvxx13nCMvL8/jufSe9Nh///tfj/t/++03cf9zzz3ncf8FF1zgCAgIcOzZs0f8vXr1avG8mTNnir83bdok/r7wwgsdY8eOdf6/s846S/gevfcHkyZN8vg+5JckX7/7+kK+S3efq7/bodruY2NjHQUFBc77f//9d3H/n3/+6ZeHl37TGTNmiO+dlpYmHnvggQccPXr08OkLbch6WZuHV723Wo/IN5qQkOAYNGiQhyeWPhc9j9YX79/U2xdPy5+89PVR277Lex31Zz/jaz9Lf5tMJuc6RGzcuFHc//bbbzvvO/PMMx0hISGOw4cPe+yXyYvuz+G1IR7eur7H66+/Lt6P1huioqLC0bdvX3Ef/d9rrrnG8emnnzqys7Nr/N/aPLxq+3r55Zc91usTTjihyR7epmxbte3b/T02qPWWtg1aTu6o9ZLmbrhvt7T/pW3rhx9+cN6/Y8eOWtdDd9Q2Tq9x6NAh5/0rV66s4b8mnzZtQ/n5+R7rHR1rrrrqqhrLj167ocfen2vZ/0+fPl3cT/vLjgpbGnxAVVQ6y6FhUjpbojM7qlrRcK2yKdCwA1XY6IyNqlR0yc/PFxUL8h+qITwaClMVODpzpOfQGTlVzeiMrbHQUC6dsdLZMVV11JAlXaszVapC0mel6hgNuTX2/WgWL0FDT+5QVYjwHjIaMGCA0wZC0LKk70vVKgWdPVL1iZZVQz8LVWqo0qeg5UlVVjobpQpHQ6Gqj3odd+gMnj67uri/Jw3b0llxv379nL8/XeiMnVBD141ZdlQxUFD1i6DX7dKlS4371TJtyDpZH1StoP9TH1Q1Hjp0aI3KCeHPcC59B6os0WXGjBliSJbWCarIUGXDG++qHy1bWt+pYuG9bOmYqKwJw4cPF7/tokWLnJVcZb2gbYIqQvR8qmS5r7cKWrfcvw89h7blgwcP1vrdGrodXnzxxR4jSOpzuG8z9UHVGRrKpaFa+j50TRVmXzR0vfQHqpxSlYgqou7e3jPOOENsJ75ekyqH7tD3bsh3ro/G7mfUcYCqzQoaAaMRAvX5aB2gihyNoLiP1JHFiap0rYnad9G2T9BwNFXsabRDVd6p6keVaKqqetupaltHyFrkvt3Rek3/v7lozLbVXMcGqoDScvIFjQi4r0N0/CId4D6Hh+6jx/xdX2k9odE3BX1W2geqbTEzMxMbNmwQFVnajt3XO6pmq+fVhT/H3tpQoy+0L6bRt44IC14fkF+HDsI0DEKeQRIO7hN2aNiADiiPP/64hyCiCw3NELTjVwc7NaGAXoOGeel5NMRYXFzc6B+OhknJp0VDTGp4TUHDOLSRKM8avR8dbBr7frTzIdFOO3JvvyVtJN47J3dhpqCDufukGRr2Iy9Ynz59hC+Vdsy+hl19fRZfQ+xqaKYxO0oarlRD9O7Q8KUSZN52DzqA0oHU+/en7+P++zd12ZF3jqCTL1/3q2XakHWyPvwZniNo/Wts1BVB2wKJCrqQKKIhNhp+X7Zsmbh2hw686oRTQcuOhIb6/WpbF+ggTScRJHQJuqaDAh0Y6eC6YsUKcTAkUepL8Hr/JkqY1jcJrCHbYWPfwx2yPpB1iuwRJO7T09NrTFhSNHS99Af1f3xtnyR4vV+Tlov30L/3fqKpNHY/489+jLYnOjHzXoaEr/taErXvct8WaB9BQ/Ik9uhClgf6bd555x0xnF8f9HuRQPYuBNRmcaoPXyfBzbHeN/bYUNt+ztd6ScuS9j/e34Hu9/ez+pqES+ulskzWtf3QdyAdQoWuuvDn2FsbZLOkYx5Zc2jfTHaWzz//3K+ToyMF9vD6gM68VEoDnZXRgZEOHORtpI2fRCxB3p/aKmFqh/fCCy8IEUIeR9rJ0JkbHWjuvvtu5+s0FPL+UFWXcje9vYB0H50h0uemnTt5e+mATz4270l3DcXfSRi1zR51n0hEXiL6POStnDNnjhA4dGJAVVX3s+vWgA7GBE0gcPdvkshUQpN2Gu4Tsei3owMoeU594S1Qm7rs6lumDVkn66O2qkdrcPLJJ4trEmzulST3kZLGQNswVZDJO0eCl7x4JOxIsNPfykPnS/D6sz5709DtsDHv4QvaT9E2RP4/qr5Txacu2rLhQkvMMvee8NaU/Uxz/SatgZr8VNs2Tp5eOgbRaAz5Q8mX+txzzzXb+5NIJGFEy8Z7nVJJL74SPdpyGde2n2vsPrg90JTPGBAQIIp8VACgeS00H4LWGfLV03115SwfKbDgrQd1kKIZjXRmTGZu2mGoior3JDJvaAWi/0tn1+5Q1aG+ST2+oIMziRoSzN6pAer96POR0dx9x6OqfI050NHOkgQVVTXdJzfRJAH6HmqCREMh8U8TXOhCFQo6ONGBuq4DEb2Xr3gwSidQjzcUmtn60ksviYOAr1nNvqChTpoURAKtrmXZUsvOm4ask80lcmgZ+Jpl3BRo2N9Xtd0XtOxoSJmGcd0rW77WBRKylJxAJ4pk7VDCltY5JXip2lLXhKyG4O922NyQsKcqD826psiq5lgv/V1f1P+h7VNZexR0X3Ot6+oE1DstgH5fGhZujv2MP9BJDIk4Gl3xxtd9LQV9Jxrpo5Ns99+ytuXmvd3W9vvS7/Xvv/+K13cXO772v/Rc2nbp5MJbdNOyoBOR5vz9W+vY0Jz4stXQBGc1Ec19+/H1HUgvNEcUY0A92zMlW9CFCgQ0WkQ6g+xRrV2IagnY0uAHFIlCVV+aQUpnqrSjo/sobcHXDtY9VoUEs/fZFfk/G9O5jd6LPER0UHvllVfqPMNzf0/yclH0lvesbsKfiBmydRDe7RtVdZOGoxsKeUvdoR0q7SjrGz6hz0Kz3N2/Dw3zUKQT7Tjqq2j5gkQueaToNagS5Avv35B+B/oNP/744xrPpWFONfTUEsvOFw1ZJ9VOs6nxQjT8RaLfO2miKVUPlZhB1cn6oGVLB1I6EXWHKni0U3f3UZJXjk4GSASSAFJpISR8qXpBsVu+qruNxd/tsLmh700zsElY00z22mjIeknriz/rCo2K0XpI1VP37Zi81JT80FzrOkGiTXmyFbT9eld4G7uf8fc3ppNLSmRx71xGAk/5x1sa2tfQ70x2HBq1UGKGtktf0YA0bE72Hfdh89r2B7SOkIilRB8FLV9KDfBGbWve2yKhIr1a2tfcEseG5oTWE/fjPn1W2ieo5UL2ERqxJSuU+29BJyc0OqG22aYSWsvvTbYH7/22GkHuKLYGrvD6CQ1Lkj+OzP800YI2YhKeNKxNflqq5lB1hDY2imRSObtUPSQfGVUXKDKFIkiokqgqcg2BJueQcKGsVzrjcoe8gnSh96OqEg1d0QFm//794gBEG7t71YyGc+g+in+hyhaJABre9eXJJPFBBn/acdBGQl4f2lhpw6QhW6pgNxR6bxJoFJdC700TXqgqRvEvdUEVdqrS0U6Clgf9X/oc9D1pElVjh71pCJrihej70GvTgYyqIVlZWaKKSAdX9x02HWQo8ovWBZqgRqKZDgZ0Jk73qxzbllh2teHvOkk7MTpYk/gjPynZBagip6LtGrJN0G9G2wUNfdFvSQdemuBJ61x9opV2/qodLlXn6PORYKdKhj8TYyiujZYfHejJB0fvRwcGOmmhERD3CUd0gkefj8StyuAlqNpHB0W6NKfg9Xc7bAnIe0eXumjIeknLjUQPDYGTWKT1xLuCS6gTCtrX0evRhDkVS0aCg/KamwuqNtG2RydddLJK6w5tc96jZo3dz/gLVYppnaPtnyZ3qRMw2o/SBKTmxH17oXWIhCsVT2gfRZMNKWJMQfMO6KSHJoBStY6EPk1copgqEi/uGca0bAjan5IdivYNl1xyidhO6HvRPpe2L1qWtE778qDTPoV+E/qtqZKpIt/oc9BkK3rMn5PYptBSx4bmgrYd2j/TekK/AZ1skrefjucKKmTR56c5BzTJUMWSkVe4qe2fFbXt/6maS23EaZ9F+04aOaOCDk3UbC6x3ea0dUxEe0JFffiK5aBIE2ovTBcVAbZ3714RFULtHY1Go6NTp06OqVOniigzBUVEUSRIcnKyiCWh2KXly5fXiFrxJ5aMnu8rysk9GoUiXihShSJKKI6EYn4oFojiVug+dyj+iiKAKH7H/TV8xfRQ+82nn35aRLzQd+3cubPj4Ycf9ojAqis+x/v7UpTUmDFjHFFRUWK59OvXz/H888/71bqWljtFT9H/pZap9Dr0Hb3xN5ZMQVFKb7zxhmPcuHGOiIgIES1Evy39pt9++63zd1fQZ/2///s/ESFEyzo6OlosT1pOxcXFzbbsfH0Ptb688sorNZZNfeskQa18KZaHIoDcI2rqij/yjnwiKD7njjvuEO9D61Fqaqp4jne0mK/Xcl9/KXaH4nguvfRSjyio+iKPKHaIYn1SUlLE96X4NVomvmLRKKaL3ot+M3d69eol7qdl58/+wDuOy9f67e92WNvvSPgTeeQeS1YXvqKu/F0vs7KyxDoRHh4u3kt9T1/Lgfjxxx/F96XvHRMTI1rAuscx1fWb1hfF6L4/fuihh0SbXIoFo3bgtN54r6P+7GdqiyXzte/wtQ38+++/4vvS+k/Hh08++UTs82nf1JyxZGpboXgs2j/Rc2688UYRb+XNvn37RAzcMcccI7Yr2pdRvCb9ju6RcwTt16hNMT1Or+2+LGj7vvLKK8X7UQQm3V6/fn2NY5X6Td58800RBUffnS50+6233qoRzdmUbauu38efY0Nd20xt66Wv38SfuDjvbfy1114T2xltGxTvRpFj3lAsKukEWl9puVP03bZt2zyeU1ssmT/H3tr2/+vWrRP73y5duojPR+sNHTvWrFnj6CgE0D9tLboZhmEYpqNAVfLGxqExHQuqjlMiBFVvaf4N03awh5dhGIZhGol3ZjSJXBrGd281zTBM28MeXoZhGIZpJOSVpwg6uqZJYeR3pqYj7t5MhmHaHha8DMMwDNNIaLIrTZaiyWM0AYgmHFH+uq9GAwzDtB3s4WUYhmEYhmE6NOzhZRiGYRiGYTo0HVLwkoeKMmkpP44uNMTkHgROkwkoh9P9QpmO7qSlpYn8TMrvpNxJyhxVXaAYhmEYhmGYI4cO6eFNTU0VrWLJQ0WpaxQ+TUHs69evd3ZYomB+agjh3XmMoPBwErtJSUlYtmyZ6Fx11VVXiWB18mb5C7XupA481Pa0LXvWMwzDMAzT8SHNQ00jUlJS2rzZRrvDcZRATQEoEJygEOa77rqr1ufOnDlTBOFT4Lri/fffFyHQZrPZ7/dMT0+vtVEEX3gZ8DrA6wCvA7wO8DrA60BLrAOkPxhPOmSF1x2q1lL7RWodStYGBbX3pTaNVMWlFoqPP/64s8pLrVipPWtiYqLz+dRykVoCUpj48OHD/XpvquwS6enpwlrBMAzDMAzTUpSUlKBz585O/cG46LCCd/PmzULgVlVViT7i06dPF73Aicsuuwxdu3YVJf9NmzbhoYcews6dO0WfcILiZdzFLqH+psdqg/pj00VBwwqE8hIzDMMwDMO0NGyjPIoEb9++fbFhwwYUFxfjl19+wdVXX42FCxcK0XvTTTc5n0eV3OTkZJx88snYu3cvevbs2ej3fPHFF/H000830zdgGIZhGIZhmoMO62imTje9evXCyJEjhRAdOnQo3nzzTZ/PHTt2rLjes2ePuCabQ3Z2tsdz1N/0WG08/PDDQmCrC1kZGIZhGIZhmLalwwpeX4kJ7nYDd6gSTFCllyArBFkicnJynM+ZO3eusCUoW4QvqMuOsi+wjYFhGIZhGKZ90CEtDVRpPe2009ClSxfho/3uu++wYMECzJ49W9gW6O/TTz8dsbGxwsN7zz33YPz48SK7lzjllFOEsL3yyivx8ssvC9/uY489httvv12IWoZhGIZhGObIoUMKXqrMUm4u5edGRkYKIUtid/LkycJm8M8//+CNN94QyQ00m/H8888Xglah1+sxY8YMkcpA1d7Q0FDhAXbP7WUYhmEYhmGODAIom6ytP0RHjgchwU1+Xk5pYBiGYRiGdUfbcNR4eBmGYRiGYZijExa8DMMwDMMwTIeGBS/DMAzDMAzToWHByzAMwzAMw3RoWPAyDMMwDMM0A4W/70HmS6tgK6vm5dnOYMHLMAzDMAzTRGwlZpSvyIStyIzqAyW8PNsZLHgZhmEYhmGaSMX6HEALerUW+e7syrQdLHgZhmEYhmGaALU0KF+b4/zbVsyCt73BgpdhGIZhGKYJWA6XwZpT4fybbA1M+4IFL8MwDMMwTBMoX5stRVWIQVxzhbf9wYKXYRiGYRimCVRuyRPXYcd3Etfs4W1/sOBlGIZhGIZpJA6bA/ZSi7gdPDBWXNtLq+Gw2XmZtiNY8DIMwzAMwzQSe5XVedsQFwwYAkRag62Ys3jbEyx4GYZhGIZhGom9QlZ3AwL1CNDroI8MFH+zj7d9wYKXYRiGYRimkdgrrR4T1gxK8HJSQ7uCBS/DMAzDMEyTBa9RXOujpOC1chZvu4IFL8MwDMMwTCNxVGiCN9jgIXi5wtu+YMHLMAzDMAzTRA+vU/CypaFdwoKXYRiGYRimuTy8XOFtl7DgZRiGYRiGaargDWYPb3uGBS/DMAzDMEwjsVd4VniVpcFRaYXdbOPl2k5gwcswDMMwDNPkCq8UvLogAwKC9OI2Z/G2H1jwMgzDMAzDNNOkNYJ9vO0PFrwMwzAMwzDNNGmN4G5r7Q8WvAzDMAzDMM3UeELcDjeJa1tpNS/XdgILXoZhGIZhmEbgcDick9YC3CwNeha87Q4WvAzDMAzDMI3AUW0D7A4pqHwIXjtXeNsNLHgZhmEYhmH8wFpQBYfV7vxbVXdhCECA0SWpdOHS3mArlRPamLbHdTrCMAzDMAzD+MScVoLc9zbCEBeM2KsHwBgf4tF0IiAgoKaloYw9vO0FrvAyDMMwDMPUQ+WGXHFtzatEzrsbULWnyNV0ws3O4GFpKKkWPl+m7WHByzAMwzAMUwckWiu35TsjxxxVNhT+vNOVwesWSSb+DpOC12GxS58v0+Z0SMH7/vvvY8iQIYiIiBCXcePG4e+//3Y+XlVVhdtvvx2xsbEICwvD+eefj+zsbI/XSEtLwxlnnIGQkBAkJCTggQcegNWqeXUYhmEYhjlqsGRVwFZkBgw6JNw5DAigLmrVsGRX+Kzw6gL1CDBp3dbYx9su6JCCNzU1FS+99BLWrl2LNWvWYOLEiTj77LOxdetW8fg999yDP//8Ez///DMWLlyIjIwMnHfeec7/b7PZhNitrq7GsmXL8OWXX+KLL77AE0880YbfimEYhmGYtqBKq+4G9Y6CPswEQ0KI+Nu8u7BGBq9CH+GyNTBtT4DjKDGXxMTE4JVXXsEFF1yA+Ph4fPfdd+I2sWPHDvTv3x/Lly/HMcccI6rBU6dOFUI4MTFRPOeDDz7AQw89hNzcXJhMciWuj5KSEkRGRqK4uFhUmhmGYRiGOfLIfns9LIfLEH1+b4SOTkLBTztRsS5Hlg3tQNjxnRA1tYfH/8n5YCOqD5Qg5rJ+CBkS3yqfk3XHUVbhdYeqtT/88APKy8uFtYGqvhaLBZMmTXI+p1+/fujSpYsQvARdDx482Cl2iSlTpogVSVWJGYZhGIbp+FiLzULsko0hqF+MuM/UKUw+qCWUeVsaGtN8gt7Hml/ZbJ+bOUpiyTZv3iwELvl1yac7ffp0DBgwABs2bBAV2qioKI/nk7jNysoSt+naXeyqx9VjtWE2m8VFQQKZYRiGYZgjl6odBeLa1DncKWKNqeEez/GetObZfKL+LN7K7fko+G4HoAtA8sNjoAvqsPKszeiwFd6+ffsKcbty5UrceuutuPrqq7Ft27YWfc8XX3xRWBjUpXPnzi36fgzDMAzDtCzmPUXiOqhPtPM+Y3KoqPjWJXhdzSfqrvCWr85C/tfbZKKD2QZLRlnzfXim4wtequL26tULI0eOFEJ06NChePPNN5GUlCQmoxUVyRVYQSkN9BhB196pDepv9RxfPPzww8Kvqy7p6ekt8t0YhmEYhml5aJqTeV+xuB3YyzUyrDPpnRPXxN/BxkZZGijWrPC3PcIaoTq1VWeWN+t3YDq44PXGbrcLuwEJYKPRiH///df52M6dO0UMGVkgCLomS0ROTo7zOXPnzhUTz8gWURuBgYHOKDR1YRiGYRjmyMSaXQF7uUWIUZOXjcHp463Fw6tzWhpqF7w2SnCwOUSFOOyETuI+CwveFqFDmkSo0nraaaeJiWilpaUikWHBggWYPXu2sBpcf/31uPfee0VyA4nSO++8U4hcSmggTjnlFCFsr7zySrz88svCt/vYY4+J7F4StQzDMAzDdHyq9srRYFO3CAQYPGuERhK8lNRQm4c3rP72ws5ObSFGmFKkgGbB2zJ0SMFLldmrrroKmZmZQuBSEwoSu5MnTxaPv/7669DpdKLhBFV9KYHhvffec/5/vV6PGTNmCO8vCeHQ0FDhAX7mmWfa8FsxDMMwDNOamPdqdoaenhPd/anwOietlVngsDsQoHMz/WrYq6TgDQjSS18wCd7scjhsDgToaz6faTwdUvB++umndT4eFBSEd999V1xqo2vXrpg5c2YLfDqGYRiGYdo7JFLN+zXB2yOyxuPGlDDoQo2i8hvgI1WBHhMT2xwQtgglgN2xV2oV3mAD9NFBojsbtSK25lWILm4VG3MRc2EfTm1oBjqk4GUYhmEYhmkKZC1wVFoREKiHqZOnf1dNXEu8dyQCAuCzeksVWhK9VOGliWv1CV56DaryVh8sQfXBUhT9vV+8f+WAfISO9IxKZRrOUTNpjWEYhmEYxl/Mmn83sHtkrfYCfajRZ1thf5MaHJqlQVkilK2h5N80IXYJf5pRUJoEVaSZ2mHByzAMwzAM40XV7sJa/bv+Ul9Sg7PCG+QpeG3FriZW1vyqOt/DbrYh65U1yP9yqxC+jG/Y0sAwDMMwDOOGw2KDeb/slhrU19VwoqHow+puPqEEb4BXhdcda0HdgteSVQ5bQZW4ONIbL847OlzhZRiGYRiGcUM0m7DaoY8MhCE+uNHLRh8lo0xtha6KbW0eXsKY5OrgZuoifcO2eiwN7tXj8jWeTbMYFyx4GYZhGIZh3KjaVeis7gbQrLRGYogJqrNKq2LJlOCliXCmrhGAQYfIqT3kcyqsoiNbnc0rNCq35vHvWAtsaWAYhmEYhvEheAN7RzdNZCnBW+hb8DoqbR4eXiLumoFCCBuigqALkykPJJhNtUyO87BLWNnDWxtc4WUYhmEYhtEgcWnNrRQKKahX0zyxek3w2orMPlMUvC0N4naQQYhdwhAbXO/ENVXhVe/F+IYFL8MwDMMwjFc6g6lzhM8Oag1BHxEIUKSZzQFbibn2Tmu1vI8hVlkiavfxqgpv2LEponEF4xsWvAzDMAzDMO4T1si/26dpdgaCmkkYtIlr3lVaah/sMGuWhtoEr7JE5NVe4bVrFV5jfDCiz+vNv2MtsOBlGIZhGIbRUI0ejEkhzbJMnLYGLx+vqu4KMRbkuzJriAv2u8JLmb/B/WOa5TN3RFjwMgzDMAzDaJDfltBrPtqmYoj2ndSgOqmRDSFAr6tbLNfi4XXY7LCXywQHfUTN1sWMCxa8DMMwDMMwVHWttolUBMIQLa0IzVfhNdcSSVa771ZNWqOJadQMwxub9lmhC6izxTHDgpdhGIZhGMajuhsQqK91IllzZfH6SmjwRhdiEJ/F1/8Xr6ESGsKNwi/M1A5XeBmGYRiGYdx8tlTdbUrDiYYI3gC3DF5v6DM4fbw+bA0qkoz8u0zdsOBlGIZhGIYRDSI0/67mu20O1GtRC2B3W4J3l7XaUNFk1emltU5Y07PgrRcWvAzDMAzDMMLSIKuoei1KrDnwsCW4+XjVpLX6BG/wwFhxXb4mCw6r3bfg5Qlr9cKCl2EYhmEYxk2QqmSF5kDYEnzYGuw+2gr7IogEL7UYLrWgckuex2NUNSa4wls/LHgZhmEYhmHcPLz6Zkpo8LY1uGfx2itlwkJ9k+PeW7QPH5dJO0PZsgzfHl6u8NYLC16GYRiGYZgWqvCK11MV3lxXAwl7Vd1d1hQbDxXjD1hgCwCq00pRfajUh6WheQV6R4QFL8MwDMMwRz0Oi91lEWhmwWvqGu704Vq16DN/YsmIoopqFMKBfXEyiaHwl12wV1g8KrxsaagfFrwMwzAMwxz1WIu1DF6jTkw0a06CB8bB1DUCjmo7imfs9Zy0Vo+Ht0gTt/PjDdCFG2HJqkDel9tgN1thL2PB6y8seBmGYRiGOepx+XeDmi2DV0FNIaLO6SVUV+WWfFTuLPC7wluoCd6DVhvirhuMgCA9qg+WIPf9TYCDXhzQhXGXtfpgwcswDMMwzFGP1a3pREtgSg5F2LGdxO2SWQdcjSfqELwOhwPFlbKKW1RpEa8Rd81AIXotWeXifl2Yibus+QELXoZhGIZhjnpsLdB0wpuIiZ0Bgw6WzHLYyy31VnjLq22w2BxOLy8R2C0Sif8ZAWPncI/GFEzdNK9JhWEYhmEY5ghvK9xS6EKMCBkaj4q12a77gmVTCl8Ullf7vE2pDwk3D0HFxlyYukjhy9QNV3gZhmEYhjnqcbYVjmrZimnYuGQPFRZgql3wFmtZvURJlRVWm6vTWoBBh9CRiTDGh7Tch+1AsOBlGIZhGOaoxmFzwJJRJm4bk1pWQJpSw51VWUpoqGuCXKFmY3AXvXVRWS2zfZmasOBlGIZhGOaoxppbIXJ4qdpqaIWKaei4FHGtC5fZuvVFktUmgL0nuJ36xqJm+oQdD/bwMgzDMAxzVFOdLruXmVLDWiXxgHy81OSC3q8u1ES12v52Z09OGfLdfL6MJyx4GYZhGIY5qlHtelXyQUtDojp8fGq9z6tR4dWSHXyxYl9+s3y2jgpbGhiGYRiGOapxr/C2J1TTCdfftVdwV+wraIVPdOTSIQXviy++iNGjRyM8PBwJCQk455xzsHPnTo/nTJgwQRjF3S+33HKLx3PS0tJwxhlnICQkRLzOAw88AKu1bsM4wzAMwzBHDg6LTbTrJUytVOH1F28Lg3tqg7d/d+V+rvAedZaGhQsX4vbbbxeilwTqI488glNOOQXbtm1DaGio83k33ngjnnnmGeffJGwVNptNiN2kpCQsW7YMmZmZuOqqq2A0GvHCCy+0+ndiGIZhGKb5qc4oB+wO0Z5XH9lyGbyNgbqrESEmPSqqbbVWePfmliGvrBomQ4esYzYLHVLwzpo1y+PvL774QlRo165di/Hjx3sIXBK0vpgzZ44QyP/88w8SExMxbNgwPPvss3jooYfw1FNPwWSqe2YlwzAMwzBHjn+X4sLqighrC5TA7RYbim2ZJTUsDorlmp1hRJco7G3VT3jkcFScChQXF4vrmJgYj/u//fZbxMXFYdCgQXj44YdRUSGHNIjly5dj8ODBQuwqpkyZgpKSEmzdutXn+5jNZvG4+4VhGIZhmPaLRfl325mdgSjWBG73uNA6UxrUhLVRXT11DtPBK7zu2O123H333TjuuOOEsFVcdtll6Nq1K1JSUrBp0yZRuSWf77Rp08TjWVlZHmKXUH/TY7V5h59++ukW/T4MwzAMwzQf1YfL2q3gdVZ440J8pjY4/btahXdUt+hW/oRHDh1e8JKXd8uWLViyZInH/TfddJPzNlVyk5OTcfLJJ2Pv3r3o2bNno96LqsT33nuv82+q8Hbu3LkJn55hGIZhmJbCYbXDmlcpbhuTXHN82gN2u8M5Sa17nEyP8GVp2JtbjrwyMwINOgxOjWz1z3mk0KEtDXfccQdmzJiB+fPnIzW17ry7sWPHius9e/aIa/L2ZmdnezxH/V2b7zcwMBAREREeF4ZhGIZh2ifW/ErAAQQE6aELN6I9UVplpbl0gm6xqsJbjcLyatzz4was2l/gYWcY0SUagQZ9233gdk6HFLxU3iexO336dMybNw/du3ev9/9s2LBBXFOllxg3bhw2b96MnJwc53Pmzp0rROyAAQNa8NMzDMMwDNMaWHJkdZfaCbfXCWuU0JAQHuS875sVBzF9/WE8O2Obh+A9pkdsG37a9o+ho9oYvvvuO/z+++8ii1d5biMjIxEcHCxsC/T46aefjtjYWOHhveeee0SCw5AhQ8RzKcaMhO2VV16Jl19+WbzGY489Jl6bKrkMwzAMwxzZWPPkZHVjfDDaGyqSLDrEhKhQWX2ustixYFeuuL35cDEyiyuxUqv0HtODJ6wddRXe999/XyQzUHMJqtiqy48//igep0gxihsjUduvXz/cd999OP/88/Hnn386X0Ov1ws7BF1TtfeKK64QObzuub0MwzAMwxy5WN0qvO0NVeGNCjEiPNAAg05WoNelFTqf8+HCfcgtNYv83aGdo9rssx4JGDqqpaEuaCIZNaeoD0pxmDlzZjN+MoZhGIZh2guW3PZb4VWRZCR4yW5B19Rcwl3ikL1B5e8GGfWolvqdOVoqvAzDMAzDMPUVx6y5qsIb3I4rvLLRVWSwa1LdgGQ5Kd6qzWpj/279sOBlGIZhGOaow15qgcNsE0rIENseBa9W4dWELnl5FZeO6Ywe8a4YtbHdecJafbDgZRiGYRjmqLUzGKKDEGBof3KoWKvwKqGrKr2qojt5gGyGRf7d4V3Yv1sf7e8XZhiGYRiGaWFcdob2N2HNo8Iboiq88jo21IReCWE4d3gnIXZPGZAo/LvMUThpjWEYhmEYhrAVm6ELNdao4lpVhbcd+nfdY8lUZTc61OSs7tIktn5JEVjx8MkIDWSx6w9c4WUYhmEYxkmVxYYPFu51dvI6kqnaU4TMl1ah+O/9NR6zaBVeYzut8CpLg/LwnjOsE47vFYfrT3A104oJNXF3NT/hCi/DMAzDMIKMokrc9PUabDlcgh5xoZh3/4QjeslUbMgRrYMrdxQg6syezvsddgesOVqFN6F9VniLtQpvpGZlGJASgW9uGNvGn+rIhQUvwzAMwzDILqnCWe8sEVmvxP78clHtPVL9oRQ7VrVLNmmw5VfBXmmFLtgA84FiFP25D7Yis0xoaK8VXiV43eLImMbDlgaGYRiGYTBzc6YQu93jQhEWaBANDg7klx+xS8aaXQF7iRTvRHVGmfDz5n6yBZbDZQgI1CP6nN7Qa21725tYL6myitsseJsHFrwMwzAMw2BXdplYCqcPTkLvxDBxe2/OkSt4q3a6WvASlowyWfG12mFIDEHSA6MQOiYJ7ZEysxU2rakEC97mgQUvwzAMwzDYnV0qlkKfxHD0itcEb64UwQqrzY5ys6w8tneqdslJd/oImW5AVV2axEYED4qDPsyVa9te7QwUO3akWkraGyx4GYZhGOYoh4bQd2mCt3dCOHomSMG7J8dT8N741RoMe2YOHp62GekFctJXe8RutsF8oETcDhufKq6rD5fBrAneoF7tu1ED+3ebHxa8DMMwDHOUk1tqFp5RXQBEy9qePiq8JIqX78uHxebA96vSMPn1hdiRJUVlu6zu2hzQxwQhZGi8s9GEvdyCAJMepi7hOBIEb0QQZws0Fyx4GYZhGOYoR/l3u8aGiiH0nvGh4u99ueWwa17S/PJqVFnsCAgABqZEiNtfLD2A9gb5dAt/2S1uB/ePgT7cBF24y74Q2CMSAfr2LX9KOKGh2WnfvzjDMAzDMC2Oy84gK7tdYkJg1Aeg0mJDZkmVuO9QoWzUkBgehMenDhC3/9yYgYrq9uPprdxZgLwvtsJhtglhGzG5q7jf1El+LyKwndsZCLY0ND8seBmGYRjmKGd3jmvCGmHQ69AtVlZ592o+3sOa4E2NDsbY7jHoFhuC8mob/tqUifZC+fJMwO5A8KBYxF03CDrNEmBMkd+FCOrNgvdohAUvwzAMwxzlKEuDiiMjvH28hwrlJLVO0cEICAjAhaM6i79/XnMI7QHyGFenuyaqBRhcEseUKoU8WRsMCe2z0YQ7XOFtfljwMgzDMMxRDAlF90gyRc+EUC/B66rwEuePSBWT3FYdKMA+r/iytsBWaIa93AroA2BKdgl3IqhfDMInpCL6gt5CrLd3WPA2Pyx4GYZhGOYoJkdLaNDrAkRCQ40Kr9Z8QlV4U6NlhTQpMgjj+8gEhDnbstHWVKdL0W5MDkWA0VPeBOgCEHlqdwT3jcGRQHGl9EVHcFvhZoMFL8MwDMMcxagJa11jQxBo0NcQvLuVh7dIVng7RckKLzG6mxSQ2zJK2o3gVfaFIxmu8DY/LHgZhmEY5ihm8+Fij4QGBfl5qeqbV2YWYtfb0kAMSI4Q19sz24HgPaQJ3s4seJmasOBlGIZhmKMUahVMTSQIZU9QhJgMGJQiBe3crVmoqLaJ2yluFd7+muDdl1eOKot8vC1w2ByidXBHEbycw9v8sOBlGIZhmKOU2VuzkV5QiZhQE84bLlvwujOyq7Qs/LYhQ1zHhweKxhSKxIhARIUYYbM7arQhbk0s2eVwUFOMID0McS5BfsRbGkKMbf1ROgwseBmGYRjmKE1n+GjRXnH7imO6ItjkErKK0d2ixfWG9KIadgaCEg/6J8kq77Y2tDU47Qyp4WKC2pH+u7CHt/lhwcswDMMwRyGrDxRi46FimAw6XDVOdiTzZqQmeBXuE9a8bQ1t6eO1pHccOwM186CKORHJKQ3NBgtehmEYhjnKoCriG//sErfPH9EJcWGBPp+XEB4k0hsUKpLMnX7JUmTuyJRV1rbAfLC4wwheVd2l1s7BbvYRpmmw4GUYhmGYo4x/t+dg2d58Ud29bUKvOp87SvPx+rI0eCQ1ZJUIId3a2EqrYc2pBAKAwG7ysxzJFFdo/t1g4xHRJONIgQUvwzAMw7QgXy0/gJNfW+Bs3NDWWGx2vPD3dnH7uuO6o3NM3a12lY9XtRX2pleCjC8rqrAgq6QKrY15v6zuGhNDoesAk7xUhZebTjQvLHgZhmEYpgX5Ze0h7M0tx9I9ee1iOf+wKg37cstFMsNtJ/Ws9/mj3ARvZx+Cl1Ibemod2trC1qAEb2CPSHQESqpcFV6m+WDByzAMwzBeLN6di1dn7xQ5tU0ls1hWPXNLze1iOf+xUUaM3X5SL0QE1S+qqOPaqK7R6JcUji4xrtbD7vRrw6QG8z7Nv9u9YwheTmhoGQwt9LoMwzAMc0SSU1qFW75eK2bLD+oUgVMHJTf6taqtdtGprL0IXvLY7sySVdhxPWL9+j/kI/35lnF1+klVl7YDeeVoTWzlFlizpVUksHvj/LtZxVXiNxrUKbJdNZ3w52SEOcorvC+++CJGjx6N8PBwJCQk4JxzzsHOnTs9nlNVVYXbb78dsbGxCAsLw/nnn4/s7GyP56SlpeGMM85ASEiIeJ0HHngAVqu1lb8NwzAM05pQZZfELrFqf2GTXiu7pApqHleuJnzbkpxSM0qqrKCo2h6aDcEf6ps8lazFlalqdmtRrdkZDAkh0IeZGvUaV3+2Cme9swSZxbJ1clvDFd6WoUMK3oULFwoxu2LFCsydOxcWiwWnnHIKystdZ5733HMP/vzzT/z888/i+RkZGTjvvPOcj9tsNiF2q6ursWzZMnz55Zf44osv8MQTT7TRt2IYhmFams2HivHz2kPOv9ceLGjS67lP4moPFd7d2TKvtltsqEfHtKaSEhkkrjNaWTQqO0Nj/btlZit2ZpeCYm8P5rePSYUseFuGDmlpmDVrlsffJFSpQrt27VqMHz8excXF+PTTT/Hdd99h4sSJ4jmff/45+vfvL0TyMcccgzlz5mDbtm34559/kJiYiGHDhuHZZ5/FQw89hKeeegomU+POJBmGYZj2y4t/bxcV2bHdY7ByfwG2ZpSgstrmswtZbZBILq2yYkLfBI+KJ1VX25pd2dLO0DtRWhCaixRV4S2iiraj1eK0zPuKmiR497q1Q6aUifYAC96WoUNWeL0hgUvExMgsQRK+VPWdNGmS8zn9+vVDly5dsHz5cvE3XQ8ePFiIXcWUKVNQUlKCrVu3+nwfs9ksHne/MAzDMEcG1N1q1X5Z0X3hvMFIjAiE1e5wttX1BxJ7132xBtd/uQY5JVXIcqt4tosKb44UvH0Sm7dBQ5JW4a202JyCraWxFlTBklUh83d7RjXqNXZ7CN5qtAdY8LYMHV7w2u123H333TjuuOMwaNAgcV9WVpao0EZFeW4gJG7pMfUcd7GrHleP1eYdjoyMdF46d+7cQt+KYRiGaYnJaiRwDboAMeSvGi40xNZA3l8SLCSet2eVelR4K6ptKDe37TyQXZqloXczC16yR8SGypHPjKLW8fFWbssX16ZukdCHNm6C1x43wVvYziq8nMPbvHR4wUte3i1btuCHH35o8fd6+OGHRTVZXdLT01v8PRmGYZjmIaOo0lmtpEYKI7vK/Nk1B/2fuFZY7qoS7s4uFQkA7rRllZeqz8rS0KeZLQ1EclSQx3Jsaao0wRs80L+0CV/s0Sre7aXCW2WxOdcZzuFtXjq04L3jjjswY8YMzJ8/H6mpqc77k5KSxGS0oiLPYSpKaaDH1HO8UxvU3+o53gQGBiIiIsLjwjAMwxwZHCqs9PCjqoYL6w4Wwk6zmvzA3QdKE8S8UwvaMqkhu8QsvMUk5rvH+Z/Q4C/JkSqpobJV4sjMB6RdMXhAUwSve4W3bQVvRbUV132xWqwzISY9+iY1bxX+aKdDCl46iyWxO336dMybNw/du3f3eHzkyJEwGo34999/nfdRbBnFkI0bN078TdebN29GTk6O8zmU+EAidsCAAa34bRiGYZiWOE54o4biUzXB2z85AsFGvYjxcvd61kWBm2giv6yq1tHrtHWFV1V3u8WGINDQfAkNNZMamtfS4LA7UL46C+Y017yYqh0FgB0wJofCECPftzHV1LSCinZjabjju/VYtjcfoSY9Pr9mtOiExzQfuo5qY/jmm29ECgNl8ZLnli6VlfKsk/y1119/Pe69915R/aVJbNdee60QuZTQQFCMGQnbK6+8Ehs3bsTs2bPx2GOPidemSi7DMAxzZEJD7mNe+Bf/N2uHx/2Hiyo8KrxGvQ7DOsu5Hhv9nLjmPixOflnyBRPUwKK9CN7mnrBWM6mheSu85SsyUfjrbuR/tQ0OrfOd8u8GNaG6uz+vXMSRtQdLA4nveTtkge3L68ZgrJ9NQZijXPC+//77wkM7YcIEJCcnOy8//vij8zmvv/46pk6dKhpOUFQZ2RSmTZvmfFyv1ws7BF2TEL7iiitw1VVX4Zlnnmmjb8UwDMM0B/N35gjh+ffmTJ8VXiXciO5ac4b0wooGe3gp45UElVEf4Gy9qwRwW2bwNveENe/mE81Z4bXmV6L47/3itr3MAvOeItgrLDDvKmw2OwNZPNq6wpuvrTe0rijvONO8GI6WoSpvgoKC8O6774pLbXTt2hUzZ85s5k/HMAzDtCXbMuTQOHkl3TNj1WSrTtEuwdtJE3GHNX9vffgSTYkRQSLirM0rvDktN2HN3dLQXB5esjIU/LIbDotdlufsQMWGXFiyK8R9xqQQGFMa70VWNpVBKRHYeKi4TSu8BWXyvWNDA1stw/hoo0NWeBmGYRimNqiZBGG22j0EqhK1nbS0ASJVE7+H/Rym9yWakiODEB/etoLXYrM7hf6A5IgWrfCSb9nfSX51Ubk5V7QODjDpEHNhX3nf1nyULcsQt8OO7dQkcaiaTozqFuOccOhPwawlyCuX6wX7dlsOFrwMwzDMUQPl4+7Ick1+UlXdkioLSrWMXHdLg7PC66fgVQI6LNA1gJoUGewSvG2U0rAzq1QIfIq6aomEBiIxPBDkDrDYHE4B1xRKl0hhGz4+FcHD4qGPCoSj2gZbkRm6EIO4rzmacIzW0jgog1mtA21W4Q3jiWotBQtehmEY5qhhf14ZqmiIXEPFhqnqbnSIESEml1hV9gaqWpJYrg8VbaUizVSFNyE8qE0rvOvTpOd1aOeoFhsyN+h1wr7RHM0nKJHBkl4K6AMQOjZZfOYQN4EbMjoJuga0e/a1PPbllovbA1MiEWSUcqiovG18vAWah1c172CaHxa8DMMwzFFnZ1Co1r++/LsECVXqvEbVv+ySKr9zeEdrw+REUoTL0pBXVt0sw/00Oe6r5Qf8ngS3XkuZUKkTLQWJ+4YmNfyzLRs3fLkaafmuiYFlS2V1N2RoPPThUgSGDEuQDwYAYcckN/ozbjlcjKs+WyV+0/F94oVtJTrE1KZZvGrSWkwop0C1FCx4GYZhmKMG5WNVqEQBZVlI0ZonKGgGv+og5o+tQQkmmmmvTf4XIpC8mVRYpSqxe1ZvY3l3/h488ftWTH1rCdZp1du62KAJ3uFdWljwNjCpgSa43f3jBvyzPQe3f7cO1VY7bMVmVG7OE4+HHdfJ+VxjUiiiL+yD2Mv7wxDduOxdSs64+rNVogHHqK7ReP/yEaJ6HNXWglezurCloeVgwcswDMMcdRVe5WNVlUin4NUEW9WuXSj69VcxiakhSQ2qwktD+wNS5OSw3olhItM3RhNVzWFrWHWgQFznlJpxyYcrsHBXbq3PLa6wOIfvh6W2rOB1JjX4cXJAy/bR6VuECCU2Hy7Gy7N2oGJLHijPzdQtAqZOnokSoSMTETwortGfb/WBAlFNpZOQz68djVDNa01WFqK4sm0tDTxpreVgwcswDMMcFZDA2poh29FO6p/gUYl0dlmLDoa9qgrp19+AzEcfQ8Xq1egUFeJXhZeqk0q8kYD68MpR+OGmY9ArQebeNldSAzUpUJXqMd1iUG2z49MlMqvWFxsOFTk7rEW3sEdUnTD4Uw3/Y2OGaLZg0uvw39P6ifs+WbIfaQfk5zV1bv68YGoTTRzbMw7hQVLkEk5Lg1uOcltYGtjDe5QIXovFgvT0dNHmt6BAnr0yDMMwTHOQVVIlUhTIpnBiHyl4Vevfw1pjCRJsRT/+CGuurJhW793r9PUeqqfCW1QpRQtZGSKCjKIyfIxbx6zmErybDhUL/ym93kOnybiuXVkyccAXG9Jax79L9IwP8+jqVhcfLdonrm8/qRduObEnrjimi/h7z34pSvUtkFig7B8junouiyitwttWzSeck9Y4paHjCt7S0lLRGe3EE09EREQEunXrhv79+yM+Pl40frjxxhuxevXqtv6YDMMwzBHO1sOyKtorPgxdY0M8MmNVhbdTUADyPv7E+X+q0w8h1atqWVxLXquyM1D0l04ZeN1Q/uAZmzKaNHFNJS6M6BLlbBNMYp4+l8/npxe2muDtlxzubNtLlejaIC+z6nR27nDp0711Qi9xskAd1QhduKsC2xzQeyrxP6KLZzczVeEtamMPL09a66CC93//+58QuJ9//jkmTZqE3377DRs2bMCuXbuwfPlyPPnkk7BarTjllFNw6qmnYvfu3W35cRmGYZgjBF+CVPl3B6ZEICkySEwiIztAZkkVsrW0g6h//oQtT06YIizp6a5h+sIKzNqSiaHPzMFLs3bUeH01HK7EkzdXH9sNJoMO83fm4r0Fe5pepewSLYbllcfYPV/YfTlsVAkNXiKvJYgPCxQ+VNLzqpWxLygVg3KBaXmoCjp9j5P7JyKGYhiowqulMzRnFnF5tU1kJKsThbaq8C7bk4drP1+FL5cdECcG9LkI9vB2UMFLldtFixZh1apVePzxxzFlyhQMHjwYvXr1wpgxY3DdddcJMZyZmYlzzjkHixcvbsuPyzAMwxwBvD53F0Y//y/+3Z7tcf+2TOnfpclkNImMxBnx2/rDIH083JqPqs8+FveFT5kirqvT052CjCq87y/Y6xyO905HUGJpyp4lyHnjDTjsrrxf9b7PnT1I3H5t7i4s35vv93d6459dGP/yfCFq16kqZVcpYPslSfG204eNgGwY9LnIJ9tfq762JJR4oD7Pdh8CXLEnV4rhHnGhwmKiuPKYrk7BWx3UvBJF/V5U6XZ/T6K1YslI3F73xWpc9slKceLz1r+7nXYGoz4AEUGuDGimAwne77//HgMHDhS3jz32WJSU+N44goKCcMsttwgBzDAMwzB18duGw8grM+PGr9bgu5VpNSq8Kj1BZcbSc+Iqi/Do4o9gLy1F8MiRiLv9NmeFNylCCmNqWLHxkBTNJJAf/nWzaNmroOFwg92KqQu/R/4HH6Lkr5ken8tWUoJTC7fjoqFJ4v9/ukR6WP3h5zWHkFZQgRu+XCM8wJQNPLhTpHisjyYwd/jw8ZLfV1kNAg2Nb9TQEPolyeW7I7O03ra+yvOrOK57DKI1afLn7tqTJ5pWGa9p7YgONXrYUloKNVGPxK2arKb8zjK6rmWagjDtwMOrWLFiBaqqaub2kQh+6KGH2uQzMQzDMEcWldU2IQwJGlZ/ZPpm0diA/K1q0tnAZCkUkzVPbWZhOZ5a8RlCi/Nh6tEDnd99B6auXeVrlJfDWF7qnHBGULMCEidUUf1ksSsdgSqpCRWF0DmkCM596y04qmX1zpKdjQOXXIrD/7kL1+bKeSmLd+ehorr+VrblZqvTP+z8DikRCDLqPSu8PgWvrAYrcdwaKB/vzuzaK7x7tQpvz3ivNscVcnlY4cDT/+wSv11zJzQM1yrj7rRWDq+aXHjFMV2dPvLl+2Sln/27HVzwXnDBBXjppZfEWU1OTk6Nx8vLy/Hqq6+2yWdjGIZhjixISFH1lGLBLhqVKu77fWMGtmWWOGPHIjW/pmooMSx3N3oWZ0AXHo7OH30EfVQUdIGBMCQmOqu8yidL3DahJx7WYrS+Xn7A6RcmsZRU7koYov9X+NPPqNyyFQevvArV+2RFN3j5InSOCRYe1kW78vz6TgTZEhTD3fy4fTXBS2LK27usKrxDUltR8CpLQ2bNz6PYmyNzgXsmeFZ4bdqEtUqDDtV2B277dh1enLkdP61J9yvqrK5JYQe0Tm4jOtcUvK5Jay1b4VW/Za+EMKePeIVmbYnjhIaOLXi7dOmCGTNmiI1i6NChSEhIwOTJk3H//ffjm2++wXvvvYfk5Ma3EGQYhmGOHnbnyApa78RwXDiqs7i9eHcuNh+Wlc4ByXK43d3ScHLaWnEdeeZUmFJdnb1MnTvX8PFSRXJs9xicOTQFISa9yPFVNgeatJZUIcVLQKCsCGc/9xwOXHABLGlpMGjHssoNG3BGF1ndm+tWwTRbbbjko+X476+bPL6TSjOgLmk3je8h/KdnDHEdF3vEhQmLQ6nZ6tHhjJIgqI0uMaSFG0640zshXKQtkDc1V0sfqL3C6yV4S7WJf/EhOH1wkphU+OGifXjwl0046dUFeG3OTr+q4t4o4U+/nzrhcUc1nqAcZcpTbin2uH3vvprgpYYbBE9Y6+CCl5IalixZAoPBIGwNH3/8MY477jjs2bNHpDSQ6H355Zfb+mMyDMMwRwC7tGSAPolhGN45SkwCoqrdD6vTxf0DU2Sls2LdOnQKqEaIpQrHZm4W90WefbbHaxk1wUuV2hN6ye5ed0zsJUYkyU5wUj+Z5TtrS5bT0qAqvJHnnQtT9+7idkBwMMInT0K3779DYL9+wgA8qVROfpu3IxtWzQdM4nTFvgLxWcmD7C14qSr4yOn9se2ZKRjdLcb5OCUdKOG4022i2P78ciGCAw069PaqpLYkwSY9ummd7Hz5eOnEQDVaUB3vFHZN8BoiTHjzkuF46bzBIp93aOcoIUTfnrcHF7y/XESMNQQ1gW6A9vt7Q7nJah6bylNuiQlrypJCvyV14CPUV2HB27K0m+mAZF0wGuUZ1tleOx2GYRiG8QcVhUVVRoNehxN6x+OvzZnO1rrkfS1fsRJp11yDbnEJuCBmMIJsFui6dkPQkCEer2XsnOqs8F58c2dRVXXvznXaoCT8tSlTRJU9dGpfMWltTIUUvIHduyP+jjtQfTANQYMGQmeSQ+ZhE06EeccOJG5ZjajY04VIXnuwEGN7xDo/I7FiXz6mDkmR30kTvEq0+pp8RrYG8hTTxLWJ/aQVY7NW1aTvTMuiNemfFCG+D6VKkOfZnX15Zc42xKq1r8JWpjXvCDOJJI1LxshmFDQKPHtrNh78ZaOwp/yzPRtTBib5/XmUv1nZLbyh3GTKT6bfg06QEsJl9b85oeVBDg+KQKOOasqKouAuax28wqtQYpdhGKZDUFkEWBrvOWSaammQ4vDEvp5iixIain//XdzW5eXg0l3/itux555TY4a8sjRY0g+Jx9zFLnFS3wRRXSVvKAlN8vAmaoLXmJoKQ2wsQkYMd4pdIvykk8R1xdKlmNRTVmnnaLaGfXkuwbt33lLR1ljcVoLXKzvWHSWeNqVLkevp3209O4NCCUtfFd7a/LuEvdTiM4OXlv+pg5LEZC/ii6UHGvR51OeoK5qtpdsLu9sZ6PsoK4oiVovJYzqg4E1Lc8XF+MPhw4db7LMwDMM0G1UlwJtDgU8m80JtIhvSi3Dyaws8vK61LnaLK6GBKrzEBLfqIvk0E4N1KJ07V/ytj5M2BepAEXnWmTVej0QrUX1I2iG8oerk+N7xTlsDVQaTy/M9/q83QYMHQx8bC3tZGaZAfqc1B6RI3q9VeMlmMeHjZ5F23fWoyM3Dgfxy5zB4bajOYbO2ZuHhaZvEsmiLhAZFP80rrSYL+uPfdffw1tZljQQveZgp2WC7j9f2BVkh1Hv21SLTfNHSzSfUiQt1+iPoZMnd0sGWhg4seEePHo2bb765ztbBxcXFwtc7aNAg/Prrr636+RiGYRpF9lagqgjI3gyYa88iZernjw0Z2JtbjmnrDtX7XPK6qoQGNeM9ISJIDOkr/27FkiVCbFICQ/dff0Xo8ccj9sYbYUyR9gFfFV5rZpYzXswbsjUQny7ZD3NRMcK1qr6pk2vymzsBOh3CTjxR3O62e4O43p5VKvJ81VB//4IDMNkscFgsSFu4Qng8w4MMSHCLRvPmmB4xeGBKX9E97vtV6ej3+Cys0WK4hnZufcGrRDZlzHpPMqs1ksxN8NbWZY263p2qWRmoS5k/0PtZ7Q6xDMlGURtKcLZUNJmq8LqfuKgMZYItDR1Y8G7btg2hoaEilSEpKQlnnHEGbrzxRtx555244oorMGLECJHa8Nlnn4mJa//5z3/a8uMyDMP4R75b29iiho1kMb4tCu7+Vn8SGtztCacPTnaKwpKZf4vbEaedBmNiArp88jES7r3H5+tRJTYgJERMMrNkZPh8Dr02NTKg2f2J2oQ1XUwMdKE1xZwiZNQocW3cu1O0uaUKJAlDFZs1qsS1zhSuXO0USXU1JaDHbj+pF764dgzi3IbGu8WGoHtc601YU1DrZhLoJNZVww/vSXi+Krx2LZZMH1a7zfGa47qJ6+nrD4vlXh+q5TLZLOpahsrSoDqfNTfOZhsJrnWjjzYSQbCloQML3tjYWJHSQK2D33nnHfTu3Rt5eXnYvXu3ePzyyy/H2rVrsXz5cpx++ult+VEZhmH8J1/uwwQseJuEEkeUOEAxW/5NWPMUUrec2BPf3jAWN4xKRum8eeK+iDPqP6aQODJp1oS0m2/GnilTUL5sWY1Egp9vORYvnjcYve1SWJm0yW61ETRwgLg2b9+Ogcnys5Jlg4QvDXMfW+lWzd680ed3qo0T+8RjxcMTseaxSZh//wTMunt8jTa6rYXyDm9Ml9YK4kBeuRD29Jn6u0XE1bQ0+K7wEqO6RotIOcox3uYlpn2hOtCpDnC1ERPWch5eSpVQHu1e8S6R2zfJ9buypaGDpzRs3boVgYGBogEFXRiGYY548mXklKDwYFt+kiOa0ioLMrVcWRKDGcWVSI2W+bV1R5J5TkwicXVcrziUzJoFR2WliBsLGjTIr88Q2LcvzLt2wXJQVl0P3/8Aevz+Gwzx8R6vf+mYLpi8KRq5i8jOULfgDezRAwEmk7BWjAmsxEpqo7tRVpB7RhkRn+46YQpP24PAQdV1+ne9oUQGqvK6V3rbgmGdI0WagsopJigxgzi2ZyyiNQuBwl5tg8Nsq9PSoE5EyKZC68a2jGKM6e6KaKtrwprqAFcbMarC2wKWhkOFFWIdpog4lensLsKDjDoRocd04JSGe++9VzSXcOevv/4S1d177rkHBw40bCYmwzBMm8OWhmaBvLvu7HdLMfAF2QLqqoaW/iuru+GnTK5zaNudxP8+hOQXXkDqe+8K8WsrKEDGI4/CYa/ZnMCacdgjv7c2AoxG8VrEkIpsj+861pKDAIsFRYFhyAuKhN5uQ5+idOckvCMJVeFVk+fgJuynujXO8LYzwKBDQGDN6DV3VHWYurk1NZJMoQR4S1ga1EgFTVJzr7hTXvFjZ/TH/50/xO91kjlCBe/GjRtx/vnnO//evn07zj33XCxcuFA0nRgzZgwyavFOMQzDNJmqYuC7S4CNPzbPwrTbgALZQlZQ1L4rvKXz5uPwfffDVuQSJe2F3ZqA9Ufw5paaRUIDaYaBPlIJaAJY2cKF4nb4ySf7/RkoWizqvHMRPnEiOr36iuigVr54MYp++rnGc6sPSSuC0a1bW20EDZC2htQ8T4/34HxZ5AkaPhx53WX74lElBzGsc+tHizUV1c74YH6FyCjekyNzgo36AJ8Zuq4Ja8Z6xZ9T8Lo12vAF2ROySqp8Vv5rq/C2hKVhudY+2Fel/oYTeuDsYfWvM8wRLngphaGz29nwV199hR49euDgwYM4dOiQaDf80ksvtelnZBimA7P9T2DX38CMe4DyvKa/XnE6YKs+IgQvVSmznn0WJX/9hfwvv0R7Q1XFFHVNXFt7UE4Yo3at1EDAm4q162AvKYE+OhrBQ4c26vME9u6NeG3ydNEvv9R4nPJ63dMd/BG8wQd2I0gPnHJgJcZkbUPn9J3i/i4TjsWJ58tYu6vDi2sM/zcEa26uU4y3JlEhJjFpTmUC/7lR2hmoGQg95o3qslaXncFb8FL1VnWqq8u/mxodXCNHudYKbzNbGkjof7lcnsiwsD2KBW9qaqqYtKb4999/ceGFF0Kv1wtv78MPP4w5c+a06WdkGKYDkysFBizlwNI3m/56eVpCg0Hz6RW2fUoDRWqlXXedqOS6U7lhA6za/rd42nQ4rPXPeG9NVIcxFXHl3pjBm9UHZATXqG4yj9absvnSzhA2YQIC9HUPl9dF5Nlnidzeqi1bYMnO9jh5sGhZ8bVl8PoSvNXbtuGKgo24Z8PPeHrFZwjfuErcHzJyFEJGjhC3zRs2wGGT3taGQv/vwGWXY/9ZZ8OSnYO2sjUs3JWL3zfI5XPm0Jp2Bu8ua/XRNSYEISa9mLimcop98cfGw35nETtjycqbL4eXOsQ9/ttWWGwOnNwvAZP6y3bUzFEoeCdNmiSSGgiq6q5btw6nnHKK8/GePXsiPd136DfDMEyTydvlur3qY6Asp3n8u12PldfmYtl1rQ2pWLcO5cuWi0outclVlPw103nbmp2NssWL2+gTAiVz5iDrhRc8RLeKGZsyULbK3a/l1PpCNW8Y3S3Gp+hQ/t2wibLTWWMxxMUhWGtBXDZ/gfN+S3q6zOo1GGBMqr/lbWCf3uK5tuJiTF0xTdxnDZCHZF1EBIL690Ngnz7QhYXBXl6OsvnzG/V5qzZvFp/NXlGB0n9kw422sDVQTjGlM1AW7qT+8vf0xubsslZ/51VqBay6y22rxcdLiRA/rZGV7euP7+634KWoM7O1cScY3szYlCmaZNBktafOGsg+3aNZ8D722GOYP3++sDGMGzdO2BuOP/545+PZ2dkIC2v9DEGGYY6yCm9QJGCtBOY+CVjNTRe8yUOAkLh2YWsoX+qK0ipfvlxck7Ck1AIisH9/cV30c81h+lazVjz5FAq/+topuqlZwaFC2cThFM3vSX/7EiL03C1aPNUoH4K3es8eWA4dEskIYcdqJyJNIExrD+wuQsuWLBHXIcOHI8BQ/2x7XWAgAnv1ErcDK8uRGxyJ2899BknPPI3OH7wvXoMq0dGXXSaek/1/L8Nubvh6WbZokev2v7KNcmvi7j0m/+o314+t1VpgKzL7bWnwnLjm28f71r+7RRzYhL7xPtcLbyglQU0oa64qr5qkd+MJPdA5pvaEEeYoELydOnUSndZootppp52GadOmeZwBzZs3D3369GnTz8gwRxKikjNvXqOHQI8qLFUuMXray/J643fAO6OA3XObJnhjewHRXdtFNFn5UinGiIoVK+T16tWw5edDHxmJlJdeFPfRpK7yFStgK6u9ktoSmHfvga1QWhLMO3Y4/brUNY2qbpS6EB5oEH/TBChvNqQVCWFDXbQ6RbkinxQlWivhkHHH1NkQwl9UlZhOHmh7cxeWoeNP8Pt1lK2B+HXAKRg9rBeiL7oIISOklYGIu/km0RWOqrQFn33W4M9attAleMtXrRYV5daEWh5fc2w33DOpD2bceTyG1jH5zpIjl6UhMaTJgnfL4WJM1ywU9072T0OQ9mjO5hM0skCtsYkT+7pi7JijVPASXbt2xWuvvYZPP/0Uw4cPr9GNjfN5GcZ/qBJ06Lbbkf/RR7zY/BGnDrus7g65GDj3QyA8WTaL+OkqoLq88Rm8JHijurR58wlrQQGqtm13/l2+fIWoqBb/9Zf4O3zKFAT17YtgElk2G9KuuRa7xh6D4t9/b7XPWLGSkmglVTt2etgZVIexHlobWjVxraTKgllbMrEurdDNv+vDzkARX1qiQmQzNTCiyWvk0yULAzWioMprxUrpvQ0bL9sG+0PwYJkFbOzSBS99/AhevkBaJdwhgZ7wwAPidt6HH8HiNufFn8lqVVu3ituGlGTAanUmVbQWZD2gofy7JvVGkFFfpzi0ZkvBa0zwT/AO0HJ13QUvvc7Pa9Jx0YfLxQnSKQMSnT5if4gJNTZbe2HKCc4pNYuq8aCU1m/vzLRDwVsXlNpw1113Nej/LFq0CGeeeSZSUlLEjvK3337zePyaa64R97tfTj31VI/nFBQUiCzgiIgIREVF4frrr0dZK1c9GKah2KurUTJT+jILf/yp3U1CanfkaXaGuL5iIhKGXgLcuQ4ITwEsFcDhtfW/RoX0jgoslTKlwSl4u7a5pUFZGEwRFgTo7aKSWr5kCUpmSMEbccYZ4jrxkUdEdVIfFyeEb6GP2K2WomK1FIvuFV7VREJl6lJ+KTFzcyau/2I1Rj47F7d8sw7nvbcMHy7aW+uEtdJ//4U1K0u0CQ4/7bRm+bx0zFC2hpK/Z6Fi1Wo4qqpEJVZ4c/0k8txzEXvLzUh9+y0EhwTV2hGNusIFjxwp3iP37Xf8fv2yRdIeQk02Is8+W9wunfsP2iO2YjMc1TZAFwBDXM0qvS/6JkWIzTa7xIz8MmmH+HrFQTzwyyZUVNtEK+kXzhvcoM/RnBVeVd2l5BDqyMe0Le1e8DaG8vJyEWf27rvv1vocEriUDqEu33//vcfjJHapC9zcuXMxY8YMIaJvuummVvj0DNNwqIpFlC9ZCnuprIzRQV4d8JoDX0H7Rzy52oS1eLchT1OIa8LZQSkWa2XzL8DL3YHZj8q/szbTkpIV45DYdlHhVf7dsBQzQuLlQfzwAw8K8UQiKmTMaHFf8KCB6PLRR+j2ww/OBAdbSf1tW5tjvSLBqKhOSxOTtBbtyvWY9NQ9TgrfPzZm4N8dOWLWO0VekUgkcUOM6lqzwlvwzTfiOvrii6AzNT7ay5uI06V4pomAOa/Liddh409o0KQkXVAQEu6+W1TY64JeM/FBWeUt/u03VO1ym2jpRuXmzR55yspmETZ+PMInTZL3LVkCe5XMpW1PWLTqLondAL1/0iQs0IDusfJEaH2a/N4/u01S+/aGYxrcbc6Z1FDRfIJ3WJcjL0O5I9IhBS95gZ977jnhC64NijxLSkpyXqKjoz2aX8yaNQuffPIJxo4dKybRvf322/jhhx+4CQbT7jj84IPYffwJqNq+3VndDQiRQ4JFP/3ULO9B4mfH0GHI++BDdNgKrztdjpHXafUI3jWfy+vl78jbv90q/+52gqwYt7GHl4Z3acidCE0yiwth13yc1EXMW6CZUjvB1LOnqPKq/9uSmHfuFL5SXUiIqMLSOPT+1ZuwNaNEiNnJA+SEtdFa9ZZmu195TFfMvWc8FjxwEmbfPR5nDU3B5WO71OikVbVtGyrXrBVpCFEXX9Ksn5smp8Vce638DpplJPQE//27DYWyg8MpwchuR+7/Xq/xeMms2Thw4UU4dNfdztGe8qVL5ecbOwgZnYJgTEkRrZULvvwK7Q2nncFP/66CWkYTC3bliCrvlgy5bt88vketFXN/BG++FpHWLIL3CGwa0hHpkILXHxYsWICEhAT07dsXt956K/LzZRcUYvny5cLGMGrUKI/4NJ1Oh5VuXjOGaWvIQ1g6a7YQDIfvvQ9l82T0UtLjjzsrPA3x/NVGMQ1/WyzI++ADWLXJRR2rwusteMfJ60OrAZtViDBxcac0GzgoBYVgxt3SExyRCkx9Q97ntDSk1fz/rQClE1ClP0BPgRFmhCaaPfJkgwf7Hu4N04QbTXiiamvW8y8Ia0BLUK7tU4NHjUSQlhaxaeEacX1sz1inADm2V5yY9LT0vxPx7DmD0FvrmkUe37cuHY7nzx0s/KLuFP3yq7iOOOUUGBObP/804d57XE0sDAaENkMCRF3E3303oNejbMECFP78s8cIT44W70l+aPOePSidPQf2sjLoExJw7YHncOlflyL41uvEc/LeeUdUiemESE26azcVXj/9uwpKYCAW7MzFkj15YjOjE5+EiKBGfY7mqvBSM4zNh6T4Hs6Ct11wVApesjOQN5iaXPzf//2faGNMVWGbNqs9KytLiGF3DAYDYmJixGO1YTabUVJS4nFhmJakaudOmf1J4mb/fnHwoipO5DlnI2TMGFENKvyh4S1zKzdtQtazzznFbcU66WWlYfDCr79Gh4BaAKtEhTivWdwJ/YHASKC6DMjeDEy/GfjfAKBMDrMLtv8h7QvJw4Cux7uaTVzyLRCmzciO7AzoDLKpxT5XZmtrQVU/goQufYzAKCtMsUboo6IQf889tf6/sBPHi+uyJYuR9eKL4jfPfPQxp3WmOVF2htCxYxHUT554FGyUE63OGOzZoGBQp8gGDVHT9kGETZyIliDAaESn/72GwH79EHP5ZdC3cIRmYI/uiL5cxpRlPf4EMh56SJzsUtc3S1qah9Av/O47cbvktLHIqspBpbUSh47rKbzH9DseuuNO7J00GTtHjBTtpdsaa07jKrzjesbCZNCJyLovl8luZif01uIAG0FzeXjJg15psQnbRY94jlZtDxyVgveSSy7BWWedhcGDB+Occ84RHl2KRqOqb1N48cUXERkZ6by4t0xmmJagcsNGcW2kdU0bmg4/7VQZr3PF5eLvgq+/hjUvr0Fil2bqF377LQo+/0JEVJm1mfPi9b75FrayRqQXtDcKDwA2M2AIcnltFTo90HmMvP3PU8CmH4HSDGC/2wz3bVqKwaDzgQs/B8bcBFz2I5AyzPUcYxAwSlbV8OddjUt9aCRUvSN/KRHRRYoJWkW6n21Dz1l/19kcgby9ZIux5eahWKuSkje0bPGS5v2MNpuIRyN0w0eiOKWbuB2VdUAMR6v83cZSfUAKIFN3+botgbFTJ/T4bToSH34YrUHiQw8h/u67KP4Axb//gT0nTUTO6284u8gRhT/+iMr160XV+a9BLuF2sDQNSU8/BV1kpBDIqjMcVYzbElpXLY0UvCEmA47pEStur9N8vNS6uLE0V4VX2RnIg94YawXT/ByVgtcbanoRFxeHPXtktYc8vTk5nt2WrFarSG6gx2qD2iAXFxc7L9whjmlpKjdKwUsVXZplT7meMVpQffjkyQgaMgSOigrkvfe+X69n3r0b6Tfe5BzmLP3nHymq7XZROTZ17w57SQmKfmx41bjddliL7S0FrjfKx+temc2WlUfRjU3ZGQacDYQlAKe/AvTwEUl18hOy0ktJDfOeQ2tB/lUSfAEmA8I6VTntFbqKw9CH1T0LniZ3hY7TbB3UCCBGTgYr/vOP5v2M23eISZbUTeyGZSW4fokcAu5enIlje0Q7xUdjsJWWipxhwtS15QRva0PNKOJuuQVdv/oSgX37im2Vtkk66e30xusiKYJ8ukTIpIn4q8Tlwz5YchDGhASkvvUWIs8/D1EXXSTuN+/TovTaCFtxNRxmLaEh1r+EBncm9HEJXKr2julef5OJ2ojW1rmCJjSeIDvDnG1yNJj9u+0HFrxk0zt0SHh4k5Pl8Bl1fCsqKsLatWs9GmDY7XYxia2uiXAUY+Z+YZiWhKqxRPDQYYi58gp0n/arqDgRVOVNuO8+cbvwp59QuXVrvUPSGY8+JoZIg8jbaTSiet8+FGlewZDRoxB7ww3y9X78UVRljmiyt/j273r7eN3J2eayM1B+b8oI18S02ggMB87UPL0r3geytddoYdQExrBBqdAbHUC34wETDa06/EqNCD/5ZGfmbOo7MgqrbN58ISSbQsWaNSKJgbqjlWpNMEr6DMLaQ6U4FBaPap0BwbZqXJDUtKpY9QE5UVAfHwd9WNObTbQ3QkaNQvffpiP1g/dF5FinV18RqQ+R57kma++b1EdYGRRpJfJ3Dx07BinPP4+oi6Xgrd67D+3BzmCIC0KAoeGy5KR+LgvimG4xdeb91keM09JQs6tdUUU1rvpsFU5+bQGOe2keXpktI/TcoXzoa79YLTzFNKJyci1tlJnWp0MKXsrL3bBhg7gQ+/fvF7fT0tLEYw888ABWrFiBAwcOCB/v2WefjV69emHKlCni+f379xc+3xtvvBGrVq3C0qVLcccddwgrBGX7Mkx7gBoKKN9e8BDfk4/owCY6P1mtOHD+BdgxeAiyX5Rdtbwx792LKhLQBgM6v/cuQo+RFc7S2dIHGjxiJCJOnYKAoCDxviov9YglTZuAmipjuWrQaYS0OxBkVyCUWN2jTeAacJZ/79VrEtCfnusAlr6J1oj6Kpn5t7gd0cfkEvbR3eXtgv31vgaNGqS89iq6fPE5gocPE8kNDrMZpXPq70BXsW499l98McpXufJ1icrNW3Dwyquw/6qrMfmVefj3e/kZ/zbIk7Q7JveDrkdPcfvEALd840ZQfVAKXlPXek5IjmDopDZ8wgSk/N9Lzslz0RdeCF1EhBDEvwVLK9KgWNng4kCJtHgoArvL9YGymeubjGort8BW0vTkAl9YsqXVx5jYuBMTymjuGhvSZP8uEROmWRrKLTVO6n9cnS7i8vbmluNwUSU+WrQPVRbPjpb3/rgBi3fnIdiox/uXj8TIrjWzoZm2oUMK3jVr1oiObapr27333ituP/HEE9Dr9di0aZPw8FLLYmooMXLkSCxevFhUaBXffvst+vXrh5NPPhmnn366iCb7iDtXMe3QzmDq0QP6OkYTyPNn7NpFzO4maBKbrxxO8gMSYccfD0N8PMIny9xORciI4aLrk5rBXzJnju83XPQK8Mlkz4YM7XHCWvpKT+uCN8Zg4MIvZOLCBM2fWZwGVBYBB7Vh4m5ycpdfHK9NEtvyC1CkNadoIShGzpqZKX+v2FxX9FqMNrRfWL/gDdDpEHnGGTDExgphFXnmmeL+4j/qtzVQHF7Vxk3IeOBBjzbFxdOnibQKe1YWuu5chz7Z0ka2MKSzmIx2y4k9ED9Oeqcrtepvk/273TqOnUFRbatdeJL1qNe8eYj+4A0szpCe61uG3iKuD5UdgtXuakZDUXD0fPGae2u3NTjsDuS8uwHZb6yFvaLpExfp9Sy5Fajcmo/i2QdQtiyjUQkN7jxyen+cOjAJF41q2twZVeGtttlRruU7K2Zskok3t5/UU6yvlAW9+bCrVTOJ34VafvRX14/BqYOa5kFnmpcOKXgnTJggzsy8L1988QWCg4Mxe/Zs4dGtrq4WVV4SsomJnsMOlMjw3XffobS0VPhxP/vsM4S18AxchmmcnUGLRaqFwJ490Wv2bPTbvEm0F6UqXYVX5U20mp3xpzOuyjmkrU2Eo0kuIpuV7qcsUKr8zppd09ZAUV0L/g84tArYISdMtUvImmAukUP8ibL65ZO+pwGjrgVCYmTLYWLbb0BVEWAMBZJrtoKtFaoYdx8PkOBY8V69T7fk5ODAZZcj67nn0VAoTowIm3AidEV7fFR4Gz6EHXnmVLE+iNirvXvFb3/4/gew77zzakRbmffJ17dmZyNXi8sSXQD/kjYL4oatMxBiNaPUGIz9kSm46+ReYgISNW8Q32HxYr9tM5RUotJKOkqFt7S6FMVml5giaHk8vfxpjPl2DFZnuZp1eEMWjnlZi2GxW9AzsidOSD0BJp1JiN3Mcs+YQrVdm+uwNdiKzLAVVMFeYUXltoImi938r7Yh+7W1yP96G0rnp8NWaBb+3aDejc+rnTIwCR9cOdLpwW0s1BEtyCilUaFbUsOBvHIhbmkC2nXHdccorXK7RmtrrSaqkQhOCA90Ps60Hzqk4GWYo4EqrcIbPNQ/0UUVu7DjNTGhdWCjiU2U1UvtZ60ZmdCFhztbplJlL2TkSGfIPv1/IuykCSKOiWLQKOfVg/VfAXatAqSqoDR8PuthoLT2SL9WJ02rHlISg97g3/9JGCCvV32i/d/RgN7YsPc9TjYFwNov66yAU/btoVtuReW6dSj85hvheW0IzmYTw3p7JlHE1GFpKMmQHuNaPhd5w8NOnuhM/ihftAglM2aIpgtUUXYXZe7VwsLvvhfWhrKFC4U/vMIkJyUll8sJZWV9B+Pisd1w8WiZlBEyejQCAgNFfnCN9auWpIf9F16EvWdM9Ri5OJIrvCRMz/vjPJz929ke1dy317+NX3b9ApvDhh931j1x9O/90i5yavdToQvQoUtEF+fENXcCe/QQ19V1TFxTCQpE5Rb/E198Qf+/akeBELjG5FCEDE9A9IV9kPzf0QjsJrvqtTUuH69r2c/YlOHMho4NC3S2sV570LW9rDkgb4/uHtOgjntM68CCl2GOMEhQFP7wA8q1/NL6KrzuqOpZ+eLFIpLowKWXIf2mm0UyA0EeXZr4ooi55mohPtwnwlDWaOjxMne2ZPYcT5vAmi9cf6sUg7lPyIqmar/bHlAd1HxNTKsNyuYlKJeX6Hpcw9+350QgaYjM5Z3zWK0C7vB994uTEUXR9Ol+vwXFh1VtkRPyQgM2uHzKlEShKry+LA3zngdm/Rf48EQgU55MeRNz1VXiuvi335H9yise6R4KquqSYCcLjRotOHTb7Tj0ppz49leXsdiVIKuKxLAzJ+LF8waL2fUErX8hY6WtwZ/W2DTSQd3aLOnp4gTBKbqV4D0CK7yHyw4jqzwL+VX52F8sf6vpu6fj480fO5+z6NAijwlp7uRX5mNlprTsnN79dHHdNaKrT8Fr6tmj3gqvNdcleKt2F8JeZa39uXmVyHp9LcrXZdd4zGFzoGSufP+IiZ2ReNcIxFzcF6EjE6GPaFgL4JbEldTgLnhlZfzMIdICory5aw8WOkciVmnV3tFc3W2XsOBlmCOMrKefRtZTT4uJaBFnnCFC7/0lhCaiGQxiuDfjof8Ke4OwLdjt4vHIc87xeH74pEnot3GD6FTlcf8U+XfJ33+7hp13zQZKDgHB0VROljFceXuA3XNdVoBi2ee+TaHPe3B53f5dXyQO9Py7IWJZQcv69FfpBrDhW7nM6PLHf5zJCWRHoFxUOtGIueYacV/x9N+EEPaHcvK+OhwwdesM416ttfRJ2smGqvBSq2PtN3eSsd7lU/70FFcV3A2qvgb27y8akFTvcVUEq9wEr1m7n4Rm4uNPiMlT1PErYI+Mgds59Hj0v/5y12v6SL4JO0FrfLHYt+AlSwUJe/GcRYtc333lKuckLIo7o+Vt6uKVsXwEoEQusUezpHyxVZ5M3jTkJnQK6yTE7uJDiz1E7n0L7sOXW7/E7AOzRRV4YOxAZ2VXXaukBnfLU33RZNYcN2Ftc8gKbS1UbMgRbYJL/02rYUmpWJ8Da24ldCEGhB0vJyq2R1Qc3tI9eTBbbZi3Ixs7skph1AcI6wQxMCVStLkurLCISWw2uwPrDmqCtwmxaEzLwYKXYRrK4teA7y8DzE2LZ2oMJFSLqHOaToeEBx5AyquvNGjojKqzISNGOOOhiG7ff4fU995F6jtvOy0M9UH+3oDgYDF0XUEig4bBl0ivJkZcJauYxLxnAFWFIu/qqo/Q5hSnyyYS1Hqsk3/f18PSQOiMQKqr9XiD6DIWGHe7vP3D5cB3FwHrvgQWvCTuInsJEXnuOYi/527hn6bh/fJlmkivh/Kl0s4QlmSmkhrQ93SgqybOqe0xeY/J5kAVZiVIrGYgT2suQlFr1ipgrVu1XoPWNVXlJSj32bvCq4bGF1vCMD+tDJ0/+RgFw+SJRXp8V7z/+EXodeHZwmpA/z+wT59aRyIq1q6t0eSkfMVK7DvzLBy89jrhPS/X/Mri+dpEN1XdNSYne4xYHKmCt8JS4bzv0n6X4pRu8oSThK3if2v/hzkH5+DVNa+KC3Fa99Ocj3cNr6XCq1kayNIkKvM+oAlmhCE2qF5bgyVLvoY1v8oZN6a8uyXzpNgOP7EzdEF+WonaAGpXTXyyZD+GPDUH130h95UT+iYgMkTamGhEYmhqlNPWsD2zBGVmK8IDDeiXxJGk7REWvAzTEKgKR80Ddv4FrGv9FrsU60QEDR6E2Ouva5RPTIkJIuL00xE8bBjCJ04U1Vx/0YeHi9gqouC9l4F3RgGHVkuvKHUWU8P9qhtZohabRiLK7Jq13yaoymXyUMDUgBgkmvRFlWsiaTCw6afGf5eJjwGxvVx+ZzcLiJpQSK12dWQnmTpV/F00TXY8qwuqqJUvla8TatouP+/JT7qeQH7lU1+Qt1e8Ky0MJHqpCQedkARFAsf9Rz6e77viF3HG6TD16ikquElPydeu3r3HWc1TFd59wfH4Y2OGEJy/n3MnXhp1Ofbe9ggigowiHaDHjD/R7ddfnN5wd+i1RbKIxYKKla5KM1W5Raye3Q7z9u0yDcLN+lG5ZYsQyCqD19TtyLMz+BK8u4t2wwEH4oLjxGVKtylOWwOJ4U25m/DHXpmeYdQZxWS1AATg1G6nOl+nNkuDITra2VjEvN8ztkyhhGv4BJmAULWzEHavBAOFJcvN7+s2wc1aUCUmvsGgQ+g4z5bR7Y3/ntYPj08dgPjwQJitdoSa9LhoVCpeOs8z/nFkN9fEtdWaf3dE12jurNZOYcHLMA1h1cey4YC4/VHNYeEWpmqz9I8GD/Kdu+sPoeO1KC2jUVQQ6yRzE/DlWcAhWeFwJ+aKK8R12aqtqM4pkhXQq2cA0d1cFUXFGa8BMT2AqmJgfeufKHiw8fvGWRIopiymp8uv/Od/fFZB/X6ty38BTnoMuGWJFKaFB2BN2yb8qETIGOljjTr/PHFd9s+/sJWU1PmyloMHYcnIAPQ6hCRUA71PARK8LC8jrwHO1LKAV34ApK8Csra4TkzUd8zfU2sXth6//44ef81AUP/+Yj2ilAYrva/b0HhaeCI2HZK2g2255ViYOhzdB/d2vk6AwVDnCVvYcdIn7p4oUjRtmnP5ENnPS/FOjVKMqamAzYbKdWuP6Alr3oJ3b9Fe7MiXmdf9YuRvOSBmAFLDUlFlq8JLq17CcytkB79zep2Dr077Cr2je+OivhchMTSxhuDNKM+AxWbxe+KaraxapDOQCyd4aDz0UYFwWOww75W/rTskgq35LvtD1TY5MZGwapVfah2sMzW+MURrEGjQ4/rju2Pxgydh+m3HYtWjk/DyBUPFZDV3VBLDot25+G2DXP+b0uWNaVlY8DKMv1SXy6FnQgiU/cCe+kP4mxOqYBFBg+qI0qqHoD59kPLqq+j8wfswda4ns3LNp8D+hcDvt0uR5+X9Cx1CB8oA5OxIRZ7uahSvz6wpJinOiyZNjbvDNTmq0HclqcXZ/Q+wd560JIy+vuH/n9oI6wMBJRhUe+JG4IjuBsfx98pqsWYBqV78g7gO7N1LpGQQNOxPFVXqklf677z6/bsklrtFQWdwuCbaeUOid9D58vbu2a6uc0mD5IkJUVkAVBbW2t5WCFaj0dm8gHy8YrLYbimU08MTcSC/AvllZuzKlpXw/sn+D/UGD5OTMSs3yZM8qtzmvvmWuB17443C46w6B4aNH4+QY8Y6LQ9VO3ccsRPWaBnuK3ZNIDtUeggbcjd4CF46UZjaU1b+p++Zju0F2xFqDMVdI+7CoLhBmHbWNDx2jOekSKoMhxhCYHfYkV6W7nc0GXluCRK6JFSD+kqRV7Wr5rpB3l3qrRIQKAVtdXqps1mFxU3wHilQx7bhXaIRGujbfkET10x6HbJLzNiYLk8ARndjwdteYcHLMLVhqfQUeRt/kBVKmuk+9hZXhayVoOFcNXwbPLjxgpeInHoGwo7zI2UgVxN0uTuATTVjkGKGSj9b6R4Lct94ExkPPiRtF6FxstEB0f9M4TkWIqvzMUB1KTD91hoCusWxWV3JCGNvdgm7hnDy48DDh+XELuUHbiSFX32FHQMHIf3mW2AJ0SqfexaKq5DRsrqriDhNejFLZsmoqdqo3CDTFUJU3j3ZJmqj12TtPf9xCV6amBcY5soczq87r5dC9jOjk50+XltBgYgesyNAtAkmft+QgWqrHWGBBnSO9l/sBA+RJwG0zpOwLfnrL9jy8oTVIf7OOxB1wQXO54adOF5YQIjC775z+nqDtNc4kig0F6KkukRYEsKN4cLKMC9tnofgJW4afBP+74T/wxk9zhDV20fGPiJEbW2QSO4ZJYXt5lwtaUQjqL983Yq1a2qNJDPEy98uqI8UvGYfgteSKUWtqUs4TJ3Dxe3K7bLKayExTII3qeO0eY4KMeG7G8fixhNkLu8Zg5Mxokvjs4SZloUFL8P4gmaxv9YX+Plq+Tf5E9WEKxJLotVsgKwW5rkm7LQkIuy/kmY4h8CkVdVaHDWRiZj/gpzcpLBZEapbh8juFQjq10N6LkmUzdSaC9DErLg+rra8FIt17gey2UPaMmD5u2hVyEqRu12mSIy/v/GvU3oYqNa8u03omKYi3SifNuuLf8RtQ8Uun8kFSvDShDQSlLVRuUUKmaAwTYzEuiwEPiPSCIogO7RW3lZNOJStoaD2mfubDxXj+i9W488SmatLmbm0jhLZIdEwG0zOdqxE/+Rw6HT+e86NXbuKFrmUJFK1axfKl8iuYVHnnIMAkwmx110rOslRFZdGPELGyGVGCRJEwoMPivzoI9XOkBKWgj4xckJfhVWKxf4xroq9UW/E6T1Ox0snvIQZ587AWT3rb3N9TLKcPLjksFyWilAtn7ty3Xpn+oV3hdeodUEL7BklMnTFpLT8SlG5LZqxT7QedlVxQxE0INbD1nAkVnj9YVS3GDx6xgD8cuuxePfyETDoWVa1V/iXYRhfbP5JVnN3zJRpDBSxRVVOmtk/7DIZ79T9BM+82RamastW5xA3DSm3OOV5QIXmwQtLlNXMNZ+7Hj+8BgHmYqRMCED3aX8g4f77XVFl5G0eeTVwx2ogzk100XI79UV5e+HLgNZ8oMUhoU7vR4x/UIrexpKz3XWblklt3cCoOk7NHGoZtlbJBmETJqAyV4pDU3AF9IE2hIwZXcNjGdi3r4iiK/3nHyEAS+fN84h9EpO1tCHp4ODM+iu84YnSTkFQ1Z1sOsoCEdujTh9vZbUNd/24Hla7AwcikpyWBtVwgvy7ip3ZpQ22M6iKZPBg+fkq129w2jVCtZEJaoTRY+ZMdPvxBzHxzZiYILy8NJqQ9OwzQhAfiSjB2y2yG3pFuX4/siykhqc26bWp4xqxLGOZR4thU2onYaOhOQllS5bCXmlF9tvrUThtt1OoGuLliQ2lK5i6atXbbQWiW1rZksMomX3AJWqTQxE8QA7tV+0tFu2Ilbe3I1V4mSMLFrwM4wuVLkCxTjSp58BSV2QTzWQnEgbWKQqamypVvdNEQIuTq1V3qUPXCVpFdPPPrsdVvi5VCnV64aOkihtFaLl33qrBsCukZ5VElooya2nWfSWjyMJTZIpEU9sSKyi+qzy35nMoweG9sTLP1sfERlpGIifWYEDqW28i4ckXUVUsfYIRQ+LEzHlvIk6TM+5z3ngD+885VzRzKJ42zfl41batQnwbEmJhCLJLUR8qq2y10sstmYPEMU2mI5wT13xXeF+YuR37cqW4OagJXsrlLVssK4fp4QnC2+jOgAYKXvcugoXffy+WF0W0BQ105SGTyNVHuYaQu3z2KXrOmYPoCy/EkYoSvN0jujstCETf6L6iY1pTGBw3GOGmcGGZ2JKn2Vg06MSLoAxoai5hOVyG8lVZMO8p8qjwEkF9pJgtmXNAVHqJ8rXZqD5c5hS1hoQQ4fuF1Y6ylZmAHQgINkAX0bTWvwzTWFjwMow3BfuALDePG7XIPaANAXaTM8cFsXWLgpaKJKvh36XmDtS8oDZoghWlS9D3aoydgby4fbU8z4x1svJN7Na6rFESAO1MAgOd0WYlf2m2Bl/o3KKy6HO1UDMKqmBRZJOo7i7WhPUJ9wLGJuayuld4fdkaNnwHTLtJpnlQBVh1ZnNDVXcDu3cTw/NR558PXW8pOKJGJvh824hTpeC15eY5RXTOa/9zJjdUqfWje1L9dgZfglfZGcT/rd3SsDe3DF+vkNFW1xzbDVkhMag2GOGorkbZPOk13RjfC8f18hTbA1IaLnjVyZ2qHIeOG1fn6AbF5VG18kjGKXgju3tUePvH1jIBsQEYdAYcm3KsuL348GKfgld2YayZMa4qvO4+XkprIHShBtGQwmG2CVVB4pgq9EH9pDAuW5rhtDNwy12mrWDByxzZtEQs2DaZZylm8ivBe1AJXreJXmq4uBUqvCQmzDt2+E5o+Pka2bxAVaF9Vatn3g98foa0KfiLmrBG+bNRneUkLxJxtDxoqD5rk3y858keGa1EyaxZcFhrbz+KXicDXY+XDRB+v6NFThpumnsTJv0yCZWrPnRVd4df2fQXztYqvKrapiawEVt/A367jX4xwKhVxPYvrl3w9naJUtM42b45KNa3z5UitiLPP090OqNGITSzniaJ5b7zjqd/NyWofjuDInWM9FR7d5JzVnj31bBsfL5UCrJJ/RNw24SecATosDdCtls1JCVh+WV3Y01if/RJCkePeDl8TdbdPolyGLwhKEuDIvQ4KdY6Mkrw9ojsUaPC2xyc0OkEnz5ealFOFXTyiFftkpYYiiELMOlhSAyBPsxVmSXLgi5M7h8De0Yi+nxX8xBDXAgCjHLbUIkO9jKZpsF2hsZRWl2K+WnzYWvtib4dDBa8zJEHRSVRt7MPTgCejQW2uIZ1m4XtmuBVk63SV8qGEwF6oLPbZCIlKAr2ywSAFqRy82YxU50OSEb3KDGKSlMz7Lf/Wbc1gUQfVR79PUlwVni1g1l3Lb93/yJXli2lLmiz8VUFTk8Hzfx8VG7SBLEvKH910lNyme6bLxtXzHkczUWVtQprstagb3EuTP8+54oU+/EK4OvzgJ+uBtJXN/yFqVquosgoas29wpu2Ui5fErsjrwVOesS1vLww76opeKGJxtp8v0TK88+jx/RpolFI0qPy9Qu//Q5VO3a4KrzR2sTCOD8EL00sG3yh/B3cq72iBXEAYC72OEkqLK/GL2tlRf7643sgISIISRFB+N/wi1H5n4fQc+ZfWNlddq/rFBXs7ETVMz5MRDw1FENcHIwpKa4q5LEdW/CabWYcLjvsrPDGBMWINsKU2DA0Xsa0NZXjOsmT9m3525BX6fptKWYu7AQphi3Z0qYQNi4Zyf8djcQ7hnm8RoAuQDShIOEbdW5vUcklCwNB9ynEBDeD6wTOmNSxJqy1Fs+vfB7/mf8fvL729bb+KEc0LHiZI4/ZjwL/PiMrjFRxdA//p2H7pnTyIvFymGasBwDH3SUna5GPl0gZBgS6VakiOsnOYtQty73K1wIU/yHFbPiECZ5DgqLaqFXgdv3tewKVe+bt3n/99826V3iJ7ifK630LXF3mqI2wG5TLGqTlp5p31ZNR23k0cN1soPcU+Tsue8v1nk2EukmNqKzEu9m50FMVmSK46MSAcpNpGWz7Dfj8VGDFB7VPOvMFVaLp96aqaFdNfJFtofgw8P0lsmLd5zTZaEMtL5rU6BX0X7Vbfk9Htx6e6xNRok04q4fQY49F+CmniGYLh+66C5ZDUogGBef6X+ElTn8FeGCPXL8V5OWNTK1ha/huVRqqLHYMTInAMT3kcPWQ1EgcCk/A2kHjRYLI4aJKp+BVzxmldaRqDEGaj5eSSWiiWkfmw40fOjuqkdgl3jzpTbw36T30iGpEjJ4P6LVV2sPKzJUej1G8WwCt23aTq5IbYkSAj5OV8OM7IfGuETDGBQsBHDW1B/TRgQgd4bLkUG5vYA+Xx5orvA2n2FyMOQekfeyb7d9ge76XpYrxGxa8zJGHGiIefaO8TlsuK50HlwNvjwT+0BocNIYtv7oaJ9BMcyVqvP27yovqPbmH/K0NEVB+YK+qckZ9RZ57jueD7v5QEraqmutL8PbR2owue7uGAHNCJwsUs0bJFCWHfFd4adIWNd0IjAAGen0ekShQe4i9T9F7+U9S9BIbv0NzDQs/m1eAEArxj+8BXPSVjN8iJj0tq700S33WQ65sXn/IkUkZIs2AJvMRVP2nijc1aqBOZRd8KiPYyBNLE8cowixjg0eeMk3wIs76KwvL9+Z7VnipqkrL3w+ota8hPh6Wg2lO24O+bJ//Hl5CbwRCfITlq5zi/L3Yn1eODxfuxadL5HD7DSd0d554De0sBc1GrataRpGsDqZEBePCkZ3xwRUj8d9TG+8/DTvxRGcb7I4MZe1+vPljcfuBUQ84l2/fmL44vpPXvqeJDImXJxG7Cj1PMIOHD4cuQp7o6GMCoaul4YIvyNeb/NAYBPX1XJeCNVuD98Q3xj/+3v+3aBVN2Bw2PLP8GZ/WBhLCGWW1jw4xLHiZIw0a7qVqKvknJz0JRHYBbNXSv0qVXqoU7lvYONFJ/0cN1Q+5SF53dfPskufUG+fEtT3App+Bl7oAa92iuxozIeqHyz08rTQRiGaoG1KSne1mnaiWsAqq8npDkWoqjiskDqgqkj5cX/x0pbQXzNUmlYUmuMQQNZNwn9g0+ALAVDNiKLBnD4+JRn5BUW/Exh+bpSFFVs5mdLZaaWI43us1Gig5DJhLAEOw7Ph24ZfAFC0ebfk7wOZffL8Qidkc6Z32mLBGbZRp3RPPSQf2zpe3R13jWiZ0QqROkqhbnUZ1WprwZNNEr6zQGCzYmSMfoNEDOonwUeUtrbKIizeGmBikvPKKtIiQ6OjXSwpmGqEQtoQmoK3bOVsX4D+vf4VX/96CgvJqdIsNwRmDXTYDqvASmw4Vi7gyeo4SvJS7e+qgJESGaH74RhB+yhlIePwbRF1yDToqZC14dMmj4vYV/a8Q+bq14bDYUJ3RhFEsmmcaJU+G9hR5zj+gCrohWZ7g6kOaxy8aNDAWASYdjJ3CRLWYaRi/7flNXF876FqEGcOwJX8L3lz3pkck4c6Cnbj0r0tx5d9XopqOh4xPuMLLtC200VK8lb95rOSndXaECgd6TXT5bpWHlSptZZqIaAgZ62XWLrWOHXiup+Alj2MXz2YANSaurZbVGY+s2oZCndt2zACWuLxaRb/JHV7kWWeJvFEPlH+XvLSEd1pDdQVQlq191h6utAV6D2/I00qNNMR3+NTTzqBQw/Q+7AwKk6rw7mtAKgR9rqAo6TMmy0QTqU6Xma1pBgN2VWYBh9fJB5KHAHqDFIjjbgOotS/xx51Atla9VVirgU8mAx9NAEqz5H3qOSR4aSIfQdVutV6qZg7ey8vNx6smrB0IS5QTvnLdxIvW4ey5H/7Fl8tkZb7cbMXk/y0SFyUm3Qk9Zizizx8HBDgQodMmItFnUxFjjUUbvUjY8xP+NP4XP4f/D09N7Y9ptx0Hk8G1Hg7pJCu8aQUV2JYpEzzCAw2IDG4ecUMZr5WbK1A6X3pbOyLLM5ajzFImUhnuHaWtk7VQ9Nd+5Ly1HqULG9/0pFe03G/tKfQUvFRVNqYOELcdZh9xe43AEBWExHtHIf76pnWHPBrZXbgbW/O3whBgwDUDr8EDox8Q93++9XM8tOgh4fkmvtj6haj+5lTk4N+D/7bxp26/sOBl2haKcPr2AmD6zf49nzJxCTV5TCUErP8GsMhcUAF11Gooqrrb7wwgWPOdJQ4ATnkeOPtdV/6uL8FLsWVK9JC3mDydje3wRmivZcnORvkSmb4QedbZns+lyWdKgKnOYfT/KgpqVnfps9Pwer+p8u8df8mTjdJsVyzY0jfktdGtaqvsDIo+U1x5xMmeE1m8K7yUNUvNEPzCECgnT6l1orHQd/r1RphoAhnpf5MRh0rSYRO+bO1zuzPxMaDHBIDiyz6ZJE80SOgSJP7LsgBrpfx9aXmnSSGNTiNcHlf6vzTkGN2tZrtiZQOh/6dF3akJa6phg8qzdbc1FGYewP/N2iHE7pxtWcgqqRKXl/72sV7bLIiLWoJ+F2QiPKKBdoa6GHgOMsKHIM0eDyt0GGbZgGuSDyIm1DNHlaq33ePkOqMsD1TdbS6qD8kTAkuGn+uSG5Vb85Dz7gZYshv+f1sTmkBGjE0eC6NKh/EBVfWqtFa9xXMOOhs9NBQVd5ZRnoEy1TVQQxcmT7osmT7sUY3EEBXI1d1G8PsemQc/PnW88HSf1/s8PHPsM0IA/33gb9y74F5klmVi1v5Zzv/z8y63rHTGAxa8TNuiKol7/pHCi7ylM+4FlsmopRooUakqmj1OlNVXNXGrtqzU+iCRo4a1h13u+dixdwDDLvX9/5TgpcpwfdYCf6AhdCJvF+xFWTh8731CaJG3LrCH1xB10QHpD6WKdI+TpN1AWDoW1BTQUV3lNYk7ErQ0xL/mM+l5fnOoTEggEUxcM8NlXSBh5w4t76v+AC793jmM7g2lNOjj4sTt6v37Gm5roOpzpWd7U78pyYBt80+Is8nh2N0mEywOKzIzVvv+PuS1Pf8zWckn4frPU8B3F0rhvHW663kkeOk3ptEDihtLGS6tCyFuWbPe1V11wkDRX1SJ+fx04T9XFd6D4VLwHiyoQLXV7jFxLSmgABXVNvy1ORPT1rlOnn5acwirD7id0KiqflkWAsLjYB14ARwIQFmXk9BUtpaHY0LBIxhf/SbSe2q/zYIXXXYhtyHVS8fIavfMzbISnhLVxKxjN4FHDRAIS24FHGo5+fN/rXYU/rYX1emlKPlHbleWvErkfrwJlZpobC9sL9heo3WwL2yFZtiKtRMymwMFP+1s0DJRRAZGIiFYTi7bW+yyHtFr2a3yt6va7jmhjWldaN3/J022HD+z55nO+8/tfS4+mPwBAvWBWHRoEa6edTWsDqtYd0w6E7YVuDXGYTxgwcu0HVSdVJU3EqybfpSVWhLB/zxZM+rLUumaeNR5jKtyqeKhiEEX1OyG5Q+7Z0sxE5YE9GyAWPCeCa98nTsbIXipgkgz/jUtkfnf+1G5di104eFIfvaZms9X/t2EfnKYnrqXEe4NJtSENao+EtR0obcWP/XXvbLbGU3eooQE+g36ni5FIYnei74Ghlxc831J9GpirTaoFS5hboiPl0RkfH/ZvcxdbPrZZOKRxY/g/bWvI9OgR0+L9LsWahaQNDV0613hJagb2TV/Aed+KD2+dMKwdZrrBMCZxbzUte7RRC8isnPdgpdOCi7/WQpq8hB/dTbM66S94UCkrKTZ7A5hBxDfIzTRKXiJTxbvw9I9MjrqxD4y/u3R6ZvF/3GipZQ4hl2O2ypvRb+qz/FktlZZbiQ7skpw5aerUG2z46S+8eh29qMykYROOGc+ALzWD/jgeNnUA8B1x3V3enmJTtHNU+G1lVTDXq55l20OWHJlAoQ/UOcve6kUh5Vb82ErMaP4z70w7y1G2eL2Y4+wO+zCg+lPcwnzfmkZMSQEQxdiEFXvshX+pXr4Y2tYvWUpAhwBcFSXw7J3K35e9RmaBO3fW6t9eAeDkmYoos69WYiCRgKeO07GLWaWy9//tmG34dTu2sRkxicseJm2Q0VbKavA+m+BRa/I2yTC1HC8u8eW7idRqmbIEyo/lGwOyqPqPtHIHza4TVajqp+/0IQu8p4qKI5KeTYbGo9Wlg2HpRrFB4Owf3Y8Shasla1n33wDgb18REwp/y4lAxDRWhXXfbl5C15C2RqUAKTJW3qTnAh4/D3yfrI/DDjLJewaiMk5ca0BFV4Sh6rK20Bbw/qc9fhz3594L302FgYHo2e1FElWskqQ4NXZgcDImpYD9/ceeon09RK/3ylPBmiSn8okpqYS3pMXlY+XRhmUfcEbssdcMU2cjNmtNlTnSXGrj7AhLkx+PuXj3Vstt4UuhiLRrGFXdhlI247oEoU3LxkmvLF039aMYlcFn0ZHAHxvOwlztmXDDBMW7c71mNTSEPblluHyj1cKvzCJ2DcuGY6ACLeWzORVL82U65/mmzfodXj5giEw6gOa1dKgqrvOv/0cwnfYHChdqFl1yG9sd6Dw192o2lkoXydX/gbtgUOlh4R/l6pzlL1bg6oSmR4z416YZ/8k7gqu+hvhQ2VBQFkcGmtrcJ+4lrVd7jsqKuSJ98y/3kBuRa5ICbhm1jW48M8LZfdCf6CTxI8nAj/59vozdbM0Q55gj0wYiRDVxMYNEre3Dr3V2aSEbA+X9df2n4xPWPAybQNVhjb9IG9PfV1W1ijvk4baFd7dt5x2hjGew+nH3CIzc898S04mUpYGfw/4FKxPFV5CCS5/oc8Rp/klydPae7IUVTRTVk0A8xNbxk6kL45BxvIYmIso+zIAKc8/J/JWfaIqvEmDPG0L7rm7SvwqMaziyagySRXhy3+RIu+O1cAN/7gq500ksDET19QJB4nHQ6tkPNraL4FvLqi3SrQxd6Mrxic0BOQyrdIbERorPcgHjQaZM+s96c+bY/8jT2CUH5wq3Gqd8tVtT1X0aZTBl8dbQZX1Cz5F9eQvAUcAdCY7TonZhWN7xnr4eNcUSKHYK6gYE/q68kzPHZGKqBATBmtV1B1ZpdL+s+AlUZkvTj4Ojy2qcK6SuaVm7M5p3Ez+Z2ZsQ355NQZ1isDX1411TT477m7ZrY4uyjvvloHdLykCT5w5EF1jQ3DKAFmpbirV3oI30z/BW7ExB7aCKuhCjYg+W66LSuwS9lIL7BXypKj6UCmsBTJKrS1QQ9B9ovvU9O/SPuyL04FfrhMjX9WlsspvqlyAoI13idvmgyUiuaGxgnd3kbTYEEl7pRfbHCgn/XY/ZMWPO38UXtK12Wuxo2AHvt3+rcfr/Ln9B9z/1bHYkuvVaEaN0tB209g5De0E84FiHH58KcqW1v89yldnIe/rbU0+qVp6eKlHoxBfkOB9Z+I7IqdZF6DDwNiBGJvkY3I1I2DBy7QNNFxMHdPo4DngHKC/y6PkbHXq3bJXm4jk0e2MoLSGyc/IoX2yGOgMsjpHnmCahLTyQ9dzKfKK3vub84HXB8vXJO8uVY5JsFK+akNRk7copovUBtkCiA3fukQ3xaZl1t55zJKZiYP/eQrlmUFC78UNKkHvs/MReUYtQ1T0PZS9Q/ltlahVvt3aKrxBEcBdG4GbFsjhfPV4J9khqzloVDQZQVYJVbGnrmV//kc2i1D5yJQk8c5o2TGNIsyo+kWCN8cleFM1/25BZAq6dpWdo9KMxpr+3dqqsSe4zZIfdJ5nFjMN67svJ8ohDo0HjpGVlvowF8ldbmCkBScG7RYdyNwrvPMzZO5pnKMAF46Uk+Koajp1sLQ/jIkuw8X6+Qja8h3w2RRnbvF7lZNFJfi84Z1wfC9ZlVZWiIaw9mABFuzMhV4XgHcuHeEZJ0a51HdvAu7dBpz1lhwROLBYnphoXHlMVyx84CT0Smh4G+G6KrzU2tZXhbdsZSYqNtf8nmXL5TBv2PGdEDI8wdkGl7p+kRVAvFZOBaz5lch5byNyP9oEh7tNpBXZkb+jdjsD+cZpsqPeBNuwu2F1kMfbgcDeSTDY9kIfkA9YHTAfkNtBQ+gd3dvD0mDOKEVKWRwssMLUX/5+gw468PP2H/H+xved/+/zLZ+LZggEXVfMeRiv7tuKnOlaLjpB+71drolUYp9L8yS+mAp8eWbtOeDtFFqfHBY7ytfXnf5DoyrFsw6gams+ct7egIqNjUu6oPSF1Vly3oG3ncE7VePEzieKbnyKN07SJh8zNWDBy7QNyuOqLAQq4oqqo6OurSl4LVWuaCf3CpuvVqlqhjqlDtAkpL8fdInA328HfrhMmySXJofbVG5uQ6u7iomPSr/rMbe5XodEN+3wyZO84n1ZpfnwBODXG1ypCBrWvDwcvPoamNOyoQ+yoevNIxA/Jgh6Q5VL1HpD340aQ9DJQfJQzwqvmPxnlQcdp+D1GiqlZd4Q60YDMfWUVbXq9HSROdsg1O+QoUWJEVTxVcPp1NqXhtKn3wS81heOabdgY458bpDdjj7a+1ni+6BLF03wGgxy8pg/UEtpOqnqfYoUt+6Clyq5mk1CQBVx6lLmowGHLwq2yMlJgZFW9Kjahp6xRqeN4GB+OdYWygpvoDkfk/tE4ebxPfD8OYMRTckIOTtw+/Yr8X/Gj3HWgRekPzIoEgcnvosPs/oIYfzQaf1wbE8peJephhYN4LU5shEBie1uWvKCB2RxoZM6Sqig5UO4dzpsZlTebOhIWTG2ZLoqvjQZrWj6HhR8v11MRlPYSqthSS91/r8Ag04IX9UdzJgqxZw1pxLmfcXC7mArMqM6reGisTknrPWL6VfzQRUf2OMkmHvIhjrGlDDoLvsMAb0mIjBgvbjPvKfhkzxpGJzIr8pHQVUBslfIk9PVEVvRedKp4nfufwi46ud8FJRkIyk0SVSFSy2l+GyL9PZ+ufVLDCiXv8nEjB3IX/eFS6irCbjiS/4hR/ToBMm9NfkRAAndqu0FzhGGuiYJWvMqnZ5zB2VSf78DVY34baiaXmWrQnxwvKj8NwSPTpyMByx4mdaHhJhKEuilDY12P0FOHLp6hpy45NXSVOwoaZiZckpricNyQpVeYvUnngcOylLdqNkojr0TiO8nY6do50xDiWrCW0NRflclICkj+CQZIo+/7gNm/df13M0/A5+f5pzsU1VcgIM33gBLWhqMMcHoPjkPwUMGu6rYKgbLjYw9szF/xWv4PSwU68bfKSu2BC0b8uJSK2SyhpBVQ/jtNIHSihgSEqALDRVtb6sPenmx64N82LRMCSXmD2kpC6phBkWYUTXfUoG0bT+jsLoEJp0RNxSXoI/m3zWljEDXCFnZPmQKxI64bqJS9dKql/DciudEnI9PKL/2+jlyshkdPNybj3h322sAOaVVWEO+bBJlkXoY7GYMdMh1fG9uOf7YkIFChKMaUgQbKnLw8On9cdHozrKD3w+XwWirwF57MpYEjACGXwHcshSvZwwUz586JAWJEUFOm8SKffmw2vyfwb9sb54QySa9Dnee7Ees2UjtxHT913IkpaHJKPVAwtVeUi1WX6rS0jVZEWxl8oSmYoNWbbMDpf+41rGqnVKcUKMDfYSMUAsfn4qEO4cj4pRuMMYHOyu8ZAdQVG5p/clVVBFUrWIHxGrWGXe2a4K33xlSnNNBO7Qahx98GBXhkxGolx38qva47Br+Qr7Q1DC5X9ibvwe2zfL1d6YeRmivPqKhid2gw7HbHbjnNztuG3ob7hohbRRka/h408f4ZtvX6K5NECXCZj4orWiqoJEw0LXdLnzZ9eY0V0PF/7UBlRs3wrxPRujVR9XuQiFenRMn67DVVGuVdlOXcAQPlieelZtzfYroukYUlh1e5rQzsIBtPljwMq0PJSiU50jfrrs9gcREZCe37mVuglfNmCcxVN8ZrPJceh84hKfMISt9pzwnq7LKPkH5smp4vzkgT3G3E2Qclfr7poVy4lRRGpZt+xEPLHwA310/AdXbdwIxUehyURKMoTY5Ia/ruBoduojismyct+R+/CchFo/Fx+Kavd9ha56WxUv+VJUaQN5dVd2lqCv3qmQrQDtpVeVVMVx+Q5/14m/kZLoraaJYgPwuVNGkFAuqnp/5JnDHGuC62dgYKit2A3QhuLi4FP00wRvddTwSQxNFfA/1XLvwr4vx3ob3xMGafIkvrHzBf5uFOnD7SmLwA4odu/bz1YjPlZOBggfIiYapJethgBWDzOvw+ULycgagOjTJ1VVQnSBOv0WcANojUnFh9ZO4ovJ+5J/8P2Tr4jFjU6YzKYEY1CkSEUEGlFZZsSXD/6rlF0vl+nLJmM7o5M+kM/Kr06gCiXEaSXn/uGZpGuJd3TXEB0MfboIhJshpayCxULHJZWWgoWOVtVu1QwreoH6uFrcBugCYOoWJa6c9IqcC1WmuFs6V2/JlDFpepYcQbkmyK7JRaC6EPkDvtBg4oZGaTBK0ATCHTEDFWtlApmLpHyiZ+TcOPvwWjA7p/7UcLodNqyxW7dyJ0levQMUv2gRaP5IacjYdhLFSh0J9CfS95PYUOfUMxL/3Fmw6YPRuB041DcOJqScKEUZD7m+tfwsR5jKEORywB+iwIdCEQKsZjm/PB7ZMk28w+jo5qZZOwmnbpUmg1L1RteNuA6q2b8eBSy/DwSuvhN2P0afKLZ6WGRpZqA213gT2iJQnaeJkpKiGL/3wU8uE9aE2Fh9eLK4n604Qky2L/96PslWZjYqgY1yw4GVahuXvyfiiah9nw+qgSEPFvoSYivqiHSRFkVFcl/KD9T2j/vd28+FaxmoNLdKWy9xZ5bUl4vsAF34hRfeJD6JZoWovxVzR5J6THkPWuFux0RiAjZ0G4t6EONy8/hX8s+dvjNghD1K77jsbJp3WzYsEb2+twQO1SSZBoTF3weMop4Kt3YGuYalwwIFX1rzimpHv7uN12hncJqy1IsHDZHW2dEEjRBCd/NBkOkrBoEo8sfRNea0ycOnEp8sx2Jgkh/yG5h9ClMMhMngdehOCkoeJiRydw13RYSd1Pkl0LKL7Fxxa4DpZqI+LvwYu/7XRk/o+XLgX+w/mIFHLF44aK4WzMX0ZPgj5CN+aXsS3eBQnJlQiNFb7vGoCJ8Wh7Zwp8pZ1l3yLsBgpiHdmleLr5QdhtTswpluMc0Ib+W+P6RHbIB9vRbUVC3fJStQlo90SUOpbx6/9Gzj1JbkNkaiZ9UiztIYmQVulVVxNKfKkVJ8khWrBwWwRz0WRYwFBBilsHRBZuyQIqnbLZRzsJnjdMSZogpcmq+VoE4v0AWKSW+XmPOS8vR65H26EtbDlJ7LNT5ctqXtE9RAnZh7smCk/Z+KZyPsxQ1QFTT3CULHiD3F/gMGEysMlMATI6nblpsM4cPElyL1tCsLL/oRp7bPIev55ONwqsN6MSRoDg0OPxJVyVOGfqBXor0bYaFc6/mSEj5LrfOXCxeJEliZJPX3s09LioAmwgJgeeL5LPxwy6BFQsB/Ilk1WxH6s/1TPTPPj75a3F73qHOlqTfI//lgcU2z5+Sibp7UErwWHzY5Kzc5AIrY+weus8HaLlM/XAbb8Ko9JkRXkA7Y5fFZ+iV2Fu7CveJ+YwNhrVYyYBEeJI0XT9qB00SHfn9PhwMeL9mH2Vu0YwviEBS/T/JDfds5jwKqPgK/O8ez8Reyd72qC4AsK86dKKEE7T6pyUAwSVWPJ+lAf5LM0hsAe1xdTS1ZjZxBVqxzS+0kTbVTbYFWlouFrNXTenFC1+sppSB9xCc787SxcMfMKXOE4hLmhISDzwy26kxBoBQpDgbUJZc4MXiF4SYxT0wLq4EWtl4mSDPx9WPqYr02dhE9O/VwcJMnvNS9tnqePlyq89H29J6y1IhGnyoi4sn/nwW5uwoEtdZS83iYP9B6eWpobaJJWkmMrXLOiA6iDWqAUSjQMe26vc/HT1J/w1sS3cN+o+zC1hzwIv7vhXf8+A406qPziBrI7uxRvz9uDLlp7YrJ76AdpVp698zDJLtMf+uvS8bH5fgSUawfCHE2MqyYswy8XSRN9k2QFbvPhYvywWvokrz3O8zc+Tpu49vHifZi3Q2stXQcLd+bCbLWjS0wI+ieHN2wdpwl7l/4gUyroMzexckepCdQdjQ70RGCfaHFAX2ZdI/7evGIlcpbJ0Z/gQbGIPLWbGAQgsVrwyy44zDYxSY0sDXUJXnuFjPXSxwQhqK8Ux+S5pP9PNgklXlqK3/b8Juw1xMldtPXBnR1/wuEIQH7eVXBUWWHqGgFTwmFxQhHYpw9S33tPTHIN0klbQ/HMXajafRgxfeV2YAh0oOKPz5F23fVinoAvzu99Pi4vnoqkqlhR3f0xdjYGxmmjGRrhJ8uTs9J/5T6GcmGp49fM82bifwNlQSEgvh8mDrwMNycloITmUajJtBTbR5OSab9L+/XRN8h4O4qWpDkU7jaHVoDsVSWzXO3Xi3+XncxqgzKbHZVWsT6FndDJuX76gqw25OElAruEQxdkgKlzRA3LCVkknE1EVMa0G3/vl3aQk5ImwJ4tXy9ogDyBLV+ZKSL3vCEr0vMzt+PuHzagqhGJHUcLLHiZ5ocaH1C1R002opm5VKklyLelAvxra/BAlTunrWGPrG4pv68/Q/M0BH3nOmw99w1kVOVhdrBbK1TKSg1zxT21Bl9t/UpMQAg3hiPBGIFxlZX4sTIU5xbJ77i5WwB25G+VUWYU0UDJFe55uVrWac6cR7E6UM4wP/WY+0WF5eqBV4u/X1v7Giw089lZ4T3gikXzTrVoxQqvISkJ9vJylC3SJhxq2IqK6qw8eeCsqmo7ejdPLbVF3VOegUibDWOqzK5s4XF3Op8zofMEPHPcMx6z4G8ecrMYRqahw03ecUrNiNlqw/2/bBINHE4NkaMdJFaE7UbEmMnv9IF1KvYaesFkLgTyd7tGSXbN0br2BQDH3C7u7qcJXmrjm1dWjcSIQEzyigE7b0QnDO4UiaIKC677Yg3+++sm7M+T719ZbcOenFIs2JmDVfvlyegsrTJ06qCkxnkGqRI//gF5e95zvkd26sFutqLoz72yFfDhMlG9jTq3lxga/nrb1/ja/AvssGNgaQ/otkpRFzI0HsakUEScLKvSlRvkyQIJWLIv+EIXYnSlNmjiJHigZmdy0xJ1VfKayvy0+Xh86eOi6QSJzluG3OL5hNydItnFbB8Ca3kQAoL0iLt6AMqXye0o7MTxCB13DCqrkhCqn40AlMNhCUboxMehi3WlkYR0AipWr8b+8y9A5SbP9dxabEbAnkpcmDNZ/P1x4jTYTA7nZDZF2ElyP12xZg1sxa7RJqpAhhRpJ+lxfXB+n/Nx2BSE6xNiUJE6EpjwX9ecChoJuG6OTNQhj/zpmtAl73dtE3NbgPzPPhfVXbEN0v5j8WJY82v3bis/ePCAWJi6SPFqza2EvcrqQ0zLEyRDQoizjXJgryjnpEKavFv4w6+wpLtOPiwZZTLZYfYBlC49LG4rwXt22KnixEsXYULsZf2gCzWILntVO6T1Zn1aodiWiT83SvtTpcWGjWmN7FJ5FMCCl2l+1AGbKpV0Vk9Vnz3/uiYf0UQq8nIpX6QvlK2BqpTbtLNwFfflDxHJ2FQiJyX8E+IK7f41SIeF6QsbHcrvD1XWKjGhg4amaPYzVXJUXMy/U3/GR1m56Ju9C+VLlzgF7+6S/bCoipnegMrSamzKGS5fkCq8G3/A7LS5cAQEYGhkL3QKl5NNrh90veixnl6aLmNsVDWXmnSoLnZUxW4DAnQ6RJwqY9VK/5Y7cWtuLg4/8CB2HTMOWS/46aF166RXVWTE4Q9nCZ8isTlvM7qazfgxMxcGp9r7qN683S4RXZztOr/Z9g1aArvdgQd+3oSN6UUIDzLgzHCt+tO7t7QDaA0sqrpOwOGRD8J4wyxg6huukQ/qOEdtjpV3PU5uE6rCm1MqBf7Fo7vAqPf8vuFBRvxy6zhcc6xcH35YnY6Jry3AyGfnov8TszDpf4twzeercdGHy/H50v2Yt11OAJsysO4OevWmW9A2T6Mx1DWxgRT8tAtlSzOE6AweFo+k+0YibGwy1uWsEyd0O4MPYPmJ+1FgksKixFSOwJ5SUISf3AVhx2knisK/q016rAVV5SWockq2iACjTlgbQsclt7jg/Xjzx+KaxO6T456E3jsxZfajomhQHnqN+DNkWAICAnUoXyz3GaEnnIAAgwEhJ54Ga2EmEgPvAMp3IMAQjALLfbBAnvjGnz0aph49YM3OxsFrroUlO0fYRagSnvXiKuR/uQ16mw7bQvdhfsQq9I3pKyq47pi6dEFg715iAmrZIuktdZKrjSLF90VCSAImdpmIHYEm/G/QRM+oyS7HONdfwYCzZeWXCiO/3d7oCWz2qipUrFuP8hUr4bDWFKHuWHJyUDxNeouTnngcQYMHA1YrSv5y66joRWW6FPj2VBP0oUYxGlBbldfp3+0W4VoPe7sEb8F33yPrqcdg3jbNw89L61np/HQUz9iHzfvXi+5qIYYQDDJLT7epc7hIGgkdLbdN6qz3xbIDOPe9Zbjz+/VifoA6YSWW7ePOdrXBgpdpflQuZ5dxrs5nKmJqn5udoS5Roiq8Kz+QopcsDtQwoQFsyZONGcYOvhJrImKx32jAK+W7cMe8O/D2+rdbTPR+s/0bMaGDLAxPLn1SVHcpEHx00miZpBCWCJvZjqptcsLJgT4RsDps2GMyCksCHZDmfLoVixeFolKXgC0BFqz++z/4M0zGRJ3W9wKPmdYqaHwrVYmVpUFEujnksGJECtILKoRPs7WJOF3+/qXzFyD37Xew9/QzUPKnrFiX/PGnf5FlcX2BwAhUl+qRtigBJX/NQs6rckLOzv1z8U1mFjpZtOp4Zzqw+pEwQLq493nielnmMtiawXfqzWtzd+KPjRkw6ALwwRUjYUjb7xK8xCnPCn930CVf4Nlzh6JLUryM5KNhX4K+j2KcjKRyr/ASVMS8hFIcfBBo0OOpswbix5uOwcR+CWLuGzWUIMICDegWK0Xf039uQ6nZKirFwzu7dQ1sKDT6MvxKeVtFCPoJrfPmXXKoN/aK/oi9pJ+YqEbM2DdDVEJP63YaLjr1asTdNQwfJv6Mx1PeQb5ZHtypKh05tQfCJ3YW1drgfnVPQFUT1wiq3JGYib91KBJuH4bw47Sha6q+tcAkIfKN04kaVUjvHH5nzYo6neDumQtbQAwqS+W6QmKnassW2AoLoQsLQ8hweTIcceoUlGUGwhCQi04xDyJQtx4OBKHA+H9wOAzQ5W9B0osfI3TSgwgcfA0Kvv4TJXMOoGJNthg0oBbFdHJROMUg/q4t8zVsorRclM6dC2thocuiRB0ICbJf0clXX9mK/M+9f6JcNW+pjdNfBYJjpN933rMNWoa078584knsHDUaBy+7DGnXXIM9J01E7jvv1jpyVPjVV+Kx4BEjsKuLAdZT5EhR0fTfUG01i4l4NXzkh6WI/aNCziExpUqbTHV6We3+3a4uwSvEaqBe2GcqVspjoDV3B9XjxW0ayVCRZ3TXnhWyCn9Sl5PgOFzlfA0idEyy+I3Mu4vw/Sx5ovHP9my8MnuHGMlRLG9EHOHRQocUvIsWLcKZZ56JlJQUsTP57TetJajbxvLEE08gOTkZwcHBmDRpEnZ7zSQvKCjA5ZdfjoiICERFReH6669HWVnjOhcddaj8XBIeNLxMHNYE736tQlBbG1bvCq/yM46/XzYFaITgpZaLQ+/eidzr/sbU/pc6Kyw3zrkRr695HU8uexJZ5VkNGhY7fP8DYqjeG1q3aGdPVForxcQo4tpB18oDG11SRqA8J1Dkf1L1JbGbTJXYYTKJCtmm+YdwaAcd/APwjbEPLu2UhOuSE7E90CQmW03ppk1o01BxRtvyt9X06/aahL83Z+KEl+dj7PP/4tHpm5GW33ptVamKYuzUCY7KSuS9+y7spaUIGjgQ+qgosfwqNkj/YW0U/ToN+y+6GIfXJCNtfixsFfJAUb50KSzZ2Yjf8jsi7A4URXeRDRGud/nz6mNQ3CCEGcNEeL5Ydl597DPKtJSERkBWgXfnS5/pS+cPEVFhZq0q7RS8dFJ34gOuCDYFbRs0k52qX6ZwOfHHzbfcLTYUJmqXS9mn/RLqbeM7tkcsPrtmNBY/eBL++s/x2PjEKdj81CmYf/8EXDTKFVdH1V1dLTYAv6FkEuLAEv87HZIIKKgSk7KoDbDyKyrWZct9x2ndTxPbUEpsJ+zunYNdwQex5LDW/U6J3lO6IfbKAbJa60eFl55Hlgg1OY4u+tgg2ZyingiqxvLDThmNeEq3UxAbLL8rVSdz/vc6yhYuAGY/Iu4rslwC2OixAuR//Ko4YSSo82IANVKhE97Ro1GS2wkl6UFiqD7G+D/odOWwlIYhq/ojZOS8jMLv90IX1gvG5GGw5PVB6QI58Sn6gj5IuneUOLm4aPRlmHbWNNw42K15hBvhE6WtoXTOHOwedyx2jz8R1vQ9rv2zJnhpEly3iG6osFY494O1EhaP3eP/I28vewvY/Y9sSOFHV7aSmTNR9NNPokKrj40V+xMaPcp75x3kve9qkqGwlZSg8Hu53K2XnynaJN8a8B1gMsG8fTt+uWESJv04UbRRVuQfyoTRpkdlQBWWVa3xEJ+lC9NFsxLViIL8u6rqG9jd1XExQK9zTnar3CK3f0d5DmZUSVtDRVqJM1WEiNwrT3JP7366M0FEvafBzWt+skUvTqSJjxfLE+nTB8sK8PastsmTPhLokIK3vLwcQ4cOxbvv+p6Q8vLLL+Ott97CBx98gJUrVyI0NBRTpkxBVZVrJiWJ3a1bt2Lu3LmYMWOGENE33XRTK36LIxg1WYoaQKjuVjTETr4+Ncxe3+QzakChoKYJKm3BT0qqS3Cg5IBT2FA1ZUzyGDx2zGN4cLRMZFiZtRKfbf0M03ZPw087f/LvdWfNQs7LL6NkxgzkvP6GzzahNMOWJpNN7iqtBF3Cu2BSF7cJTynDUZElvcih48Y5A+e3m0yo0CVh+XQplMz6SnwWJ3eMCdAjNigGl/a+DP+8tg/TX1vnzHFUglcE2JN4IpGkYe4xCc/9JXM+qYr37co0nPf+MmQVt04rVRIh0ZdeIr/rwM7odUsKut3UH1ET+oqShhqi9QVVkWhZU2WrZGspLBU0CSRFCGY6uOf9+gOOzZati6v7XC292w2A1omxybI6vixDy/elZm4l6bjgjwtwwZ8XIK8yT5zEPLz4YUz6eRKyy7P9sjI8O0MK6EvHdMYFI1NhzcwUvmUYDAjsU08Fmry9p74ob1PVacrzHlF8Br3OWYm9apz/ExI7x4RgYEqk6J5Gvwtdnj93ME7ulyCSHehz1kd+ZT4qRLZzLdD2TnGDJITUfsAPrFoHNWNiiIf3lixBtD0RwxM0iw+A4ztJO4i74G0IwgqhDxDiOkDvKfLLLGVAitw+ScTQ70/fma7VpKTGUlRV5PRoXtJXbhdEyezZyP/oI5S8fqdYbnZjDMoL5URa89ZZKPrhR5QvWeL07yqUreHw0hgcWDcauoveQPT5cnTM5kiAA2EIMNoRmpqG4ACylcmKdcTgEmczD/E6AQEiFs1I6S7UgfLPu+XkY42gHikISnT5nu3FxSj/VxO0EanOCaL0Ohf2kTacOQfn1LksaFTllkMz8H24/L/2n64AXuwMvD4AWPpWrf/PXlGBnFdeFbfjbrsNvZcsRu9FC5H4yMPivvyPP4F5v2fGbuF334sTbDrZnJtSAJvDhmxjBZZcNUTYxIavyMOFfxTij71yYuyuFUvwy2tPosCciT1B6dhWuE38/kJwGnRwVNlELnLhr7uE2K0g77gdMHYOd8bnKSgD2qGjVAiXkM8ol+t0QHG1PKnSVsG+5d3QGckYEzoStmKzuN+kNUoh0lLkye2JMOKLa0YjXJvToWIJ+ySGNeQ886ijQwre0047Dc899xzOPddtNr4GrbRvvPEGHnvsMZx99tkYMmQIvvrqK2RkZDgrwdu3b8esWbPwySefYOzYsTj++OPx9ttv44cffhDPY+qAtrY8twov+XSpGUJVkWz6QKkDtIP07vzl09Kg7QWobXADc2RVxY5aLkYHeVbQLul3SY2e9eSBdRfLvoa4Kag885FHXTvRb79FxXrZ6UgxY+8MZ/zVqye+itdOfA3vT3rfw6PnSBoqhiGJ0GPHoX+EFPdUwV27IQw2qx1dB8Vi+6B/UWaqQLIhGX9ftgILLl6Ik3IvRP6hMmTsLkKaNhTWL1YKZvJ+FVHLz+iuKA0IwPSoOFy1/hdkVhxEcmQQvrh2NHonhCGvzIxbv10rJlS1BjHXX49e8/5F5xtGwFi0BgHL30JC0HR0Hl+A8mW+I8v+TfsXv3x4r5gkY0hORtx/7kTUpZegyxdfIu7s0QjQO2Bd9Bmi7XZYKnQoeX02HFpL4YaghnDdBe/r614XNpTS6lK8s/4dzD04VwyrU2YqnRzVx28bDosEBbIN3DuZhD1QuVUmLgT26gVdoB/r8qDzZYtlmsg48/4aD7916XD8fMs4jO8Tj6ZA3t9Prh6FDU9MxpDUukdQaBlM/mUyrvj7itrtQLSdqkmG1CzGTyxugted9dly++oZ2RNRQVE1BC/9blZqC95AqMKb/N8xiLnA8+SDRmUu/etSfFcsW1mb00rw8JKHMe67cdjz1XJkvbpGZKLWR+WOAldjDJq6UHoIb6x9Azf/c7MYOqeT3KHxrmQYdeIXkZAtrSfm+6AL7wSHvRoxV0xE3G23IvL88xB92WWImDrVc1d5/XUIHjkScfc9ioCB5yB4ZG9hzYgbsgqJptuQEnoDovNuQ2zg64jX34lY41MIT7tV5jzTm7m3+d06TaYnUPdJapBDHl1zGQK+vwjdJhxEn/MyEX283HdXrtOKF5Qo48bxqfK3ocmgyiZA1iXvdWZN9hrkVOTg1ZhobDcZoaOJzVbthIIsDrU0Msn/5BNYs7JgTElB7E03ypM3kwnRV14pvM1kW8h+9lnn+5HPt+Crr+SyuulGzHYT4m/Fb8B7ZxpgDwAmb3BgzaKfkLFrB/5661WUZ2ViQdaP2OXYIY4JmeWZYr1JeWyssL8YU0JFW+fyFZkyaoz25yNqTogO7BqOyPGU/OFaT69PLMdh7eSDIFFbECdPJC+2nwlHRqVze9AFuo4dHx/KgxkOpEKHsREhuPUkeXKTEhmEEV2icXyvpu0POjodUvDWxf79+5GVlSVsDIrIyEghbJcvXy7+pmuyMYwapcUhAeL5Op1OVIRrw2w2o6SkxONy1EGVHdFnPQCI6Slb/SYNkY8tf8eVsVrfTHCqcp32MkDxUu6THxpoZ6Dqrq/e9RYS3m7sK5Jn3DTx68QfT8SzK54V4kbN4KedZ8YDD4jqgmnkcOhPO1kcLDIfe9zpZ6PXnLlfJkrQhCiyH9CwJU2Qcqd0Vxks5QbojHaEDOqF/hnys+40mbAxYyCCw43ocrYBK0PkRL9zrNfDZAxCeZEZG/5xtevcukhWDCJMEc6sWaowz4uIxkldOuGJ6BBsK5+HwMS/8MCUvpjQN0GIG2pKsD6tCDd/vRZztmY5Z/q2FHRAooNTgBJAnUaKnNywFDNSuiyFZbfWRU2D0iYeX/I4DH/IlImoCy9E/G23IfnJJ2Hc8DrC972A7lPyEUcRTf/P3ltAR3mt+/+f8UzcXYEEd3fXtlgV2lKj7u7u7kq9hbZQtC3u7h4gJBB39/H5r733TIKdc9pz712//72n37WyiAzJzDvv++5nP89XRNfstC/2vAKpuBZFb9Fjj1P05JN/iqMtTPQFDpUfkgXugbIDssDVeDZb4hwQqWxeiA7QP/q9dqeLdcdLeX3lCfn1nSPbERGgilsvX9unc6c/e9DgorcVj1f4Vpep3+mFSFTrm3xhn9l/5/0RIrd/BPF6Pz34qexyi3M8szqzZXryL2kN5/4up5OaRYvPcwzwFrwNG36jcffu1ojVMlVU9YpqdR4Q6BrelSBTkHzPBB/234HgCGsMZ4vFhNhU0FmO+agpS+HJ0/xx+g8mVw3HfFxdJ8IL1XLqHyvhhdVU5Q/HqPo5Q4qSBF7Y8QJfHf2qZSMu3FW83F23y0XGkU0sH+ImN8lFvfMKrLbuuN0ufDtaCb36ciLuuYfYl1+WYqtzN0zGpCSS5/7YQjuQ30sIwKdHOwzaPDQWUYxpcAx/mezfXFBzCI24R/9yjYo7fzEcMla2+pV7IXQXH/eV8d3ic43JH53RjdmlNiHNJ063cuzPQEpgCmE+YbLYPVJ+BEdVFVljxpJ/663nbaAERrWZyNc9J/NwRBhXJCZRmzRAbfSW3KEi0s+AoDFVfqX81CMfeQStT2s3VRzP6KeelMVv4/YdNKxfL8/d7Dlf4KyqwhkcxEFTE7mVyuPWSw3b1NlNbge1mQo+Wsiit1/A5XSg0eiwu6zYszIIbNC3REALuzFTUiABw9U9t35LoeTiCkK9udsFCs6dn8ACRaXzwnzyGPVBre5BcytqWKxRtUXb3HbM/9VDsfJ4UAuIRsWarAr2oo5Jc3ols4e04ZEJ7eUGWNCRhqYqO8K/cWH8xxW8otgViIo628ZHfO39mfg3MvLsnZperyc0NLTlMRfCq6++Kotn70dCwoXFJP+n4R1jCrW2wXMz8tIahF3ZX4ln7X+Lsjr6N2ySvAWvWBjPhegsCIyIH0GPCBVTLMamsvu//z3ZMVqctVhye29YeYMsgh1l5VhEl06r5alxVdzYYatMR7OdOqV8Lqur2VG0Q45ghWvCwFhPUto5EH+j8jvFJQtJbUT3200k7/0RH5eLZq2GWp8qRl7TgQV5P+PGRUplN4JOKyHart9O47C5CPZ0wXKOVNLgMcf30hqEIOZNbS1WrZZQjeps6/2yGNVRjcWSwvzkzVEc0o0Z5dzywz4mvL+Z2uY/aRH276KxEkrVe8KMX9DctAaH3YQpyIH212vPCisQVJOgojo6FoBTA2u6en52clVLXLQp0IY51I7bBaVWdXyq586TPL3aJUuoXbgIW5Zn0vBPICYAgnMoRpyimH199+stgrYJyRNksIdIwhIbCqGcLmgokEXxuRAhEMPe2MBN3+2ltM4q/WzP9MaV54700/yTBa+A4GN7hZoivvf/AWxOG09sfYJPDn0ivw7w0GXO7IifB+/1fQ6PV5z7JS+9RPETT5B73fXYz5iWeVPVLEd3kDfrOkpefkXyWr383XMLXjExGRSjuvNbCv58J/lCEJsd8XeyqrP4Jv0b+b26MLWJDW0M4JbSy5hdqgSOmgiTFBdVz8+QfqqWk9VnhQoICD9gwf8VEF7C4n5ysFxx1R/q8xBLpy5lFB346fmZvPzH/Vz5w0DuuaKeb4caeCukI3X2a+RjrenzCb7034+ylqJhr+PClI/Rj7wL3wGDKNoVjFt4mgh6WYlnsyA6uqK4zPdsNq6cq1IFxSTM1iB9zZm1VDYfzKGeWPT8KtW0PKfDKwrPPtF9Wu61dStW4Cgro3HrthaRquiki42ld+L2yvjPaWw/geM6N9fqqnAKioQouM+Mhxfd3c+/wG21SuFZwPhx571kUfyHXKOOX8X8Bfz01EPk/ai6u6dNWvZ+9QNTtsQw3K8fT/R/Qt6rxTndcegU+Zhhx/2w1tTR6O9mbML1hBij0did9DoZzImqszed5i7h6IJMyrfZk+wnxI/n4eRKrLXqfTjuKQnEBji1Y6u4bYWllvWBa6XtXrLFn9HNas3bZ1PH2llfz9ZvF+J0OskOMbQkAwou/x0j2tHHs/ntlxKK4RyKzt/4Dy54/yfx+OOPU1tb2/KRn986Jv+Pc2jwiBgkvMI1L/5MeMR/Ed6CV7gj/KOCV9yUBadXwOF2yC6Mt6MrVOECNpeN2atn89bc2+XX9bFBHKWQWh8npx6ahjYggOZ9+8i9aga7Ditu3rikcedRJrwQN31R/Gh8TIR200mbNl1jGW09ZgWaXtVEdvJlVY4SX3UrHkFNaRPZh8o5sV1FyI6a1ZHY1GDJ4T22rfisgnfeiXkU2GrkTbyd+1WclijQONlQ4PHkFYV++0gW3zFYWlaF+RnJrWzig3V/Mf73r8Lb3RX+s/4RMkChJvweHFYNOmsxbm+ohBCdnljBtO3q+O9N1fB69hzS8zbBUo9TQa9ZOKLUgnrUasbvddEJ1dC4ZQvl77zT8nuEVdGfgXdzIkIAhNOFWW/mrp53cX/v+1vSr8R54uVke3l+XghboHt/PkBxrUUeT8Gl+/mWAfh4uoei0LOkq46NWfCP/wp6zVL/ijCH/6FUKvH8RJfxXAjeqhB2ik6c8CwW9lleUZPY3P1VHm/5Bx9Q4xEOCRFj6evKi9Vtd8qUM/W5oulU//ADpT9+11Jk9I7sfd6f8Y7O/10er7fYvXb5tVy38jou/e1SWZwKkeucqV9TZlLPZVrVKHToWB+4m81js9CH+Ug/1IqvjlLx9VFK3thD4bObqF6kutFnUhnE51nlmXSvTuXR4huZmXIVKQHJPP/jjbySfISfK9ZynCZ0bjcat5tYaw8Z0uCoyMAYY0cX2FoU/WUIv/GZ82HWMhVaIjUDg7DVGais7q38rAfd05roKApgUdyaApW7zrWL4dEcFe9962YVADP+VQxBRnQ+Qk2nwSLuLxeI2+4bpawE95bspX6Vh0LgcmErUII5YQ0pXBxi/WIlN1vcL98e8bakeWS7LaxO9rzfx1uvNXtxMTULFsjPI+65gLuFB4GTlH2lsH0szzhGeL2iCgSMGY3VDAHNBpJ+r8BWUMGSKUv4bepvRPRVk56IakUl6Bs6gRBdOP1iVbJnYqkvmfmeDbsHgvt9phXehegMMiW0+BDWWrUeaOJsVAVopNguCKUHcPsbmD7NjUtXwfqI77D5qe/bcPNFbgUOp0u60rT/6EXG5e4hsV+sHKCKrvK5aYB+Jj1PX/wXNtX/YfiPK3ijo5WwpbT0bPGJ+Nr7M/FvWVnrTUvA4XBI5wbvYy4Ek8kkXR3O/PiPdmjwwtvhFQhKaLXO+h+CUNoKvqWgFHgLQS8EN9fbNRIFb1pIWktx+mvmr+cVyUatURa/1uNq4T0Q0mq8viuqnuSf5slxvUjwCVmkrJiEOO5CENyy4289Lz9f10vPCx074RYm7KIpVq3Gglt8f5PqZtEBEZ3Hjn6KkrHyi6OyWZbWPwr/BC3WngXsi1vF9+nfUVha2vI6hchKYHq76ZwotuKoU3QSbwHtRY+EYGlZ9c6VqsP93fYcssr+iy4kOdvgwNwLF2ZemyrvuFvcnMdMoTpTKeQdCx6WBWrho49y0X2LGHpMdchqJvYjzG4jcP4N0FgGIvZ04pvsn/wS18RE8XDPDiR3HIDfMPV7BeUEnSo0G3ft/FNP21vIChqDsHj7ePTHhJvDifWP5ctxX8qvBdd3SrspLcdSeC03N9Rz+sAePvzgK3ILSwn1M7LyvmE8c0mns5wTxHRAxJiK6YCp/dnj338JweMVVnZNla0BLP/N2PTDl3xw3eVU5J1NUxCFvfDAFU4Wn4z5hMvSLmvhPO8u2a2CTv4Vj9cTCS5oCpWffiY/D77mfrTBCdSvWkXDVuG2IQoSDS5rA6HXXUnkY4/Kx1V8+y1up4MYvxhi/JU37pnwPhcxavae938Vnxz8RHbxxb1CXOc+Oh8e6/eY5P23mzkAVzc/fHuFUBh6lPeifmBx7hJCZ3aUKW7C2kzZm7lxW7U07GqgetFOZU+lAW2AQYqbKn/P5ImC2Yyo6cPvf/zCmoXvsDxJWbBdWtLIK+UVrM0rpJvVRp8GdR07So4QMO6/wT9bhPW0Gd7ypdAMCFRsrsB99RKljxCaCsGd3ewJgxDvnVdzIDqtIiDIez8PTkBz9c+Y23t4vB0fpSG9kPxbb2vhqQtIC0ZRR2cfkIEVXthycs6iM1zU5iJ57AXERvOO7nfIz39yeNwSRBHu8eit+OILeQ/17dMH3/7/OEzHp0MqBAegczhpX1aH3uVGHxFBzO0zWTwon8ogG85GCwteegpneZ10yjALT15xfKx2zE4tnbXqvhnZpg1BbRPRiuJ+//ncbWEXJ4IhZFrfhaKsq7PBWoetTnV4B/o04IxQr8e++0dCpqcSNTOFKVseYkteIdfXL6SN5k5Cr/fjTrONg/XNrDlWSs1WFdbUtSqbCf0SMHq8fkWX91xM7/Wvxaf/qfiPK3hTUlJk0bpunScIQYyv6uokN3fgQHUzEP/W1NSwb5+HlC849OvX43K5JNf3b/wZh4YzTMaFW4PXOeDP8Hf/m7q7IjFI+NSeiYzqDKnCFot4h5AOskuQFNhagIsF77buralHosMrf1eJKsBORakxuIDoBgsRUtRTqkvc6UAVGpf7LDW5F6IQy7rtZvwzCrDp4JdeFhZbCtgx/mmO+t5NTN6NBBJMQWMBb+1VCuRpqdOI9Rjru5xuQqJ96X95ElOWTOHl/CfZk7icTdELuXj5JBbvazVPF4XbxKRLKbEfxBCqul87i3dSbTkj3tJhkR/D0yKkSt/hcvPSH2dbc/0liGpccAKX3gEf94MTf1y4w3uGHZ1YZHQTHsfl0GDQlFP73BUYMufSpn8VcZPKSb1Ow43BzcwrKiWhoRKn8Oy87CtJlfn2+A8c8jHRJ36IfA9DZ85Uv1SrlTw+gaY9e/+UkE0szgsnL2TNZWv4cvyXLYu1QI/IHrLjJ9A7qrfsSInz58OvH+OT2TNZ/NrzsGspY8vX89LULi2c3TPhpTOY2rZFa/7nFmLnQaeHnmpEy341mv3vRG1ZKftX/IbDZuX41rMFhN4x/LWdrm0pLoWSX/AzxYbM+/MLwpsSuP5lKNhH/Wo1vg6cMhtnQ0f8RjyJPqYHJc8/T/M2RY9w1RUSdPFFhFx1FdqQEHQlFfTPcDPE2JGKOXNkcMCZEJsS70ZvW6EqCJr27aNm4cI/xd8W1BRBzdBr9CybuoxvJ3zLL5f80sKHD2wfRcKMntQtfoXArz9g3CGnLK6zzYVE3d2T6Pt7EzzeTP3KB7Dn7UCjEUWvtcWayn+A6v4lZYZg8MSi5Gef5vG67+TnF+eF8kxDJZc0NNGwOoT+gT3o2qQmY87yYwSMvkDc8H8RwqVAFxoqO+ySRy3uxWkeakDW2taQiH+GNiMwj1Fe4A2bNlP44IM0bNpE/i23tnRwU4JSJF2gx3GL6nJ6YMvJlQI+kXAoj4En4tsL0YQQ1KEDznocotMswldKjkj6S82vSkgYfvc/7u5SkwdzRhMSoSZfieXqnuc/Yjir89ZgMblomt6euA6dsDU3sei152iorlI2iRGKfxtvN7cU4ca4APpLD2I3saegquHsjZXWrCf6gd5E3dtLhkOch6ID0l3QUqeaKmEBdroEq46zCPHw7ajFULKAmHpV4DtEA8RhwXfLQ4zprzZ5X/++HwrVce1qKZMba5H8JmDJaL2ne+HyUCz+xn9IwSv8cg8ePCg/vEI18XleXp68UO677z7p4rBs2TKOHDnCrFmzpGfv1KlT5eM7duzIhAkTuPnmm9m9ezfbtm3jrrvu4qqrrpKP+4+HtQE2v6nia/8MpUEETCR6NgoXGH/9d+No5T8WrIkRm4AoSr3OCd4FTuDGLjeex9Gc0nYKKaVqAa1NCuWDUR+08H6Fetd/yGBcAX6ENMKIsnC5EJ8JV3MzeTfciGPbLqx6+PnaeIZ0nyx/9mtlDptOj8Lg9uW2Lqq7IcQeYoQ8ue1kYjxJPXqTjgm3dCWn+TTlzeWyMB8TM44oWyIOrY3llUsI0KtNxfCE4ZRVG/GJXoxWr0Z0gqMqeJhX/nYlV/x2BYN/Giy9KEVh8NTFnSTvS3B6jxX9m0LL+hJo9vhJivPi56uhyFMQ1RV7NkIaSG6NBRYInX0XjhQlSowdUENkt3oC4i0EBtrRWwsJzFhJtNPJaYOerwbMgKjOcpwuFkxRqNzcTY3Y/YYNI/Lhh4h98w0pctP6+UnrJMuJs3l3/wii0x/ldzav/1yIRbCXWRVYe4p2yyLf5heGEy1Jzfl01bZ6eJ6JFsHaX+HvnglvwXtqAzS1enb+d2Df8iUtdIacw2ef9156z5luAuIYeCkg/5TH2/cmSJsobdXcP8/AtlvFI2v8vUJgLT79bkXvF4XrkJo+aH0aOe5TxerijazvowQ9l29xMf313ZS//Q6FDzxwXiF7pj2Z4DmKTmPxk09Jess/g9Ph4JevXiOqyiQ792LTKzY058bqNu3aRbPHiWXyYcHfdbd0J8V1XfjgQ2BpRB9UiNvRIItegco2Fl6zfiQ5mQJ2jeqGJ1qjsekhpl7Hk9MekI1Ue6MOh187hrV5AB+3kUp9DWF3zEIf+t8jSjw3/dBvgCpohbBL4txAH8H9/Rcwd1fnRNPu3fI6ExBTjPybb5F6BsnjjerDgBPq/dIFKS9aMQn7/tj3spsuNlFtgs8+3kadUQlJNRrygz1d/fydVHz+BYjubr9++PU/Z4Im7i+758Da5+Dz4WhKDxMQp0b9giYi4DdiRMuUa3z7SUx56ClCYuKoryhnyRsv4HI5afRMZCMdGvwHKdqAn/YPum69kTvSdjIzIoNDq1RC3pkQIrYznRTOQtEBbA16NG6wGd24fJ3kpLpB68ZSoafpq8dwbntXPvSFiAjst21TIUuF+7jFsFJ67WpPtHbOI6qKJA/a6/UrUtq89pQC4voo++yfe5v/J+P/ZMG7d+9eevbsKT8EHnjgAfm5CJsQeOSRR7j77rulr27fvn1lgSxsyHzOUHzOnTuXDh06MHr0aCZNmiStyb744gv+E1BZuYXCol9wuf4BZ1CoTte/BPOuao2EFAvx9g+hJld9fW7a1UXvwNTPoEtrStj/FP6ZYG1jnhpzi8XNC2/HVvhi3trtVtbnKb7rgJgBPDfwOZ5ofyfhnjrw+qnPy+Io3j++5W8JVXBRP9UlHnvy/A5fycsv03zoEBY/Ay/M1BE7fnJLyte24q1yUWzTM5IZPS+nXbDqjIuuoiicU3tH0Wt8Epfc1Y3QWD/ZofaKeN4d9zYrr1/G5HoVP9rgaJAUDMGznHfiB7TGs5XkP5/4Wbo4iC6V6FwLvqr4SAn3Y0Ab1THYm1v1X4uTDkr00BZEbNCas9X6Md3OD1kQi9xlr+I2KGrDYb8AXgsN5uCYJxT/cNRT5PS+hmtjovmmcAOnak7xzj7F072yw5Ut3XmxwIbddBNBF12kvEk9DitNu1oV//9VNNXVYtmijn9VtJuJj7/M1zFXkh6gCtnN8769YGexRbD2V/m7Z4rXBJVDHNMLOB/8u2iur+PI+laLprLsU/I1CohpgNeq79yN458qeEUld+kcaUuoaSglsdcRYiZ2wtWoReOjx9w9Qqrg9R1uocml0vgKAzNlOuHDmx/mx44V2HUQXwm6SnUeN+/dR+N29Teb9u+XwrZRjy7h/sVOdhZso/Knebg84UC7vv2SHx+/n/rKC1MdVi//noiDjQw6GtayafLCmpUlqRbivaz47POW74eUNNK+QFnmiZ9Vff8Dtuxs9JGRxLzyHCFXqvPA6bYzO+9efitfwdLQDZw2FfBezFz5s861MXTOcfFyyj34F6pzs7k5nLCbZhNfqq7BPX7pVE/+F13WfwJB2/ryyJeszfV0bM+B70BPwbvTQ/kR16ves/YJete5mosLwNylS2tSpkZD/McfSftAcTxE0SuCHga72tA5T10P+isVHagpO4vFmYtlAXh9J3XfOhcjElS09jad6lTaj2ymxhMJHHF3a+JgS0f3syHKum/ru3LTXUkER7SRaI1qs+HW6yhoH0JefZ5sFAyPH445IJDpjz+PydeP0tNZZB/YS6lW/b2A5kaCJ7cl7ukeaI++x0GTEZPOQbuAKrod+vgsge1ZOPCjmmic4SzRnLevRbCWE67hmj7jWDxuNge7qedWvmATuoYKinQ6SlNHYhZ2nMJ3WzyP7a9zf289XWtbtUAahwPr6dMYYvyUH3Czg6Z9x+RmT8CWW4ehVlHz/sZ/SME7YsQIJcQ45+Pbb79tWRxfeOEF6bggwibWrl1LWtrZSlPhyDBv3jzq6+ulAO3rr7/G37/VIuT/IkSBm3HyeQ4eup4TJ55g565JVFZuOv+BmZ5Fsvw4bHtfJeS83x1WPyU8dtTi7H9OtywkCXrM+Odxwv8NEO+zKEK7nXbRue5sDrXonO4tVYuMjyPtvIK30lIp7ZbEh+D1vjviXS5NuxRXhnKXKAqB1RWqc9Q1QhXTwnZHYEtn9bpSDpS2xm6KjvBvv1MrRnEaDZ9c7kdmnIaBMQPlqDzAEECTpoHSgBx6jE2QGfYvD3lZ3vDv7XWv/P86g5aB09oSm6oKxZNVijLSPqQ9lfOOU/nFES5rM502FT0kF1HwToXQZ0+NuukNDbn1rA62gPaMy96rlO6dpH7//tzzR2R/Ct7OfmRHjrpU18ae5Tl3Tq0/j797FoLi0dy5i6KbVnF1ZAi/hISS1v9uSBsvXToSL/6Q0JA2kkowdelU+foEJUVsTi6EeosdbR9FS6hfu1Z24U5PmXqeGf1fxcbvvySk2LNQ+TaxrlqH3emmsfNI9CYTJVknydp9tphLCda8Be9/QUziFXr+BW/bs56H3U7Ro49R+uabLd87sPI3HFYrkcltiUhUjhJ5R1R3yGv1lWSOI4CzjfTF+StwvPJ4i53fBWEKgKvnYzN3xuXU0+yjYmcDhscRenk7AoJFzLhDRuEKlAUcldddr8hejO1xGX5XqE2h35AhBF+uNsrl738gA19yZ14thW3avCIGnnAzfl2N5PwKiHcovbac0tOZHF7nsds6B0e3qYjzoAYDIa7W+7r11CmZ7Jc/ezY5V11FkygK9Xr5HATGHVKe3RmFh6j6Rjk6RD70IPqQEJzdglnq/zNPJn1Mra5BunxET+nMnW1eoSRabSTM+lBe2ppEnwnXKaGYoE7c+gohV1yBPVM9Zq9/uqQg/bv4I/sP3t//Pg9uelA6zLQ4ZDSWSEeL4x380Bj9sZfrcNQ3gNEXUjw839ge6ut/Aa2vLz4dlP93yNVXS/pF4hefS2qACIrJvfpqOj30lWhkkhEHzzuXysfWZB3HbrMyfU8Kh178lKbampbn5/LQj4bGDZWThLUu1WWo+OOQ7O5qOnfClhB/9qTxpxnQVKEsMPvdinvSW3yf3YFtlSnUxKvf54i28EO2ErsNjR/aQnMLjoqm62hlTbbj158p8dh96UQX1eVCc3guXxtsXBsbzX2dRtLs1BOmradmjerInoWafFh2t+JBb1A2hsJlxHIgvUWnkB+hoW1wW8mF/3iIAXRumiuNNJaY+Do4kKGJo1snOm1GyOnInfbvuDZIFbNeWI6fkAluxjh/nDW55M26gsL77pc/q9t0nPej/me4/v8X8H+y4P0bfx3C8/HAwRsoKFA8Qb0+mObmHA4eupHq6jO6ZKKT601LE9j0Osy7QhLzpQL/kvfh5nX/4zzdfwSxGMWcquWpX1zo73gG+xk2cmtPb8GtseKyB1JeEXlewSuCG0T3RkAkcPkb/c8aSWdHa6QnpzCQb+HxVhyW3qSrAnMoDwRdk1WmsNU02WjctZuSZ59Vf+SGy9kZ0yCFGWJELIrbjm4lGKtsk0W0Z0QlOIkfjvpQ3hgvhJPVquDtZEyj+XAF9vx6ou1OhmZfjq89QBbrwkPYiRVnc4K8uX4w8gNZRNze/XZ+ufgX1l2xTtIBzix4hWm5wL68/1rB6wpty3ZPoJCmYI8SsGV6BHOigL2ASl68JndQPLutJS2iwTO512Lxe7Tfo7L7LY6fwH297jsvUMTrmHDxh1t5KFO9vub9+6n74w8Z6yu4hi6PLdKFIJLQTk+dRvHzSlh4JnIO7ef4lg34WQ1EmSLkSPanQ6rbevmQjvS5SNGhts3/8SzHAyHMEpZMGrMZn46iS/tvwrtZ8Ir/zsCFusqiuM8cOYqyt1U3vOqHH6ldupSqr76m6egRtv78PTt+/Un+rM8l00jq3ussWoOXzpC8K5/Sl18563dH+EbIYBWxwXp/73uSB/wPERRPSUYH8rLuxOmORksl/mmNaHK3EGR5m0j/pzAGVWLQZBCpyZQR3N9N/I7nBj1Hm6dfJGXRQhI+/4yIe++Vx9By+DCVn6uua+AllxDm8Xa9dLsbTVUN+uhoGrt3xq5XI+aM7VvOOz6N9bVwxiSjODOjhWdfeN99uIXwUVz3h9QxCJoyuaWzKIprv2Y3Wd98JM8XYYOlGTOU79K/Y9KiSXyWsJnD5gxuyknijWFvUNaseMftYtJwO5TXcNDUmWiahU2fxxIsZTj28iYc5c24NG4O+mWwq/jPOYycC3EvEp7J8vW4XTy86WEpgp2+bLoMDblj3R3cuv9RCiddi7n3zdT+5hGU9fZ0W7uqlLQ/g6innyLs9tuIfOD+Fn5w4rffSPqCNTMLd1Mz+h5dWX5dBzL9Vefdt6qJoYdCCKhw0Vhdxb7lqhDe8tN3fHDdZWTt2Smva3GPPGoyYmk0UOORhWy31DD3yQfUFEK8p4tvVVaHIob7umUw6Q3qkifjsgg7QzfpVw7FL8ZCcsca1mUpt4dzY9m7j50k1yqxOao3G3FqRYpaE9ZjR2Xc8Q6HL5dvdpJVU8pvjmi5mVp3+CPyq86xPBS2bh5nH9lpPv4bRc8/Scl6f5rK1dQvPVEj72HdwrsRGt+2pctbfDyAxf7+cqonuu5l77xD8bEUyo8G4kr/neZDB8/qzFs9NC1jYgCO4kPy74rJR9OhbL6sfJ/VAX9RJ/AfhNZcur/xH42a2n3U1OxCqzXTtcuHBAf34djxRygvX01e3hxCQjy8qdMbceKivG0KIbokTCc9QpfuM1WxK4Im/iREJ+6fGd6fi1prLVk1WS0F44UguruX7FY3Eld9PcXPPEPC55/Lrv5ij2LcUd+FI4WtXNW4gNaC10tnGJXYyjW2HFcFb1ObaJod5dJA3vv3RYc3ozKDJqeFnd19uGSLRXIId374E/3KjqN1uaSieP34RDioBFIGnQGbxUFIVltI3kJeaCtH659BLNzegje1QYRZqI6Q+2gFwfogLk6/k8aJx6ikgm2nirGUTKFrXAgRAdGyiDgT4sZ7ovqE3CBk12bTIzFe7lHyq5opr7deUHz1ZygN1bpwip1GmjFhdllw7fkKrXAYELy0c7iBc4/PlVZgAsKRwlvAnkk3OZOrKT7EMRCLuuD6XQjCD1fYrOVpQnGHhKKprsKnSxfsBQVYjx2n/J13ifK4AJx7bI+/+za6EyewZJwg8t57ZbfK+7NNPyqz+65jL+JowAlKreuocJzA35TCxd1i0XWaxoGVv1NZkEfm7u2kDRgii2tvwRl2442yK/ZvQ3rbaqD8BK7aYrRBMS0F9pF1qxh7y1207d0qqBXdTxFnXPbll+wtzsFnzz7E/xCl35M/P0g5TfQgiKSKOmIbrJi79WTvb4vIPXxAvt796WojlFrkpj5/PdHPP3eWUOjunnezMX8j6ws3ELAwk7sf+YiolPM3aSLO1VqowdxTOQ6EGD5Fe2oMVCn+v7F7X45EZjN6xXP42nV06XTdWXxTL+9ZHx5O6DXXUDlnjuy4xrz4IsHT1CYj+8QuAjepoiDg2plkZWdCprpmq4sLKc/NJjK5lSu6YeMCqbr3ojjzBG1796PkxZdkoaaLCCf+vfeo+ORTbHl5hN9+O4a4OOWwkZHBs/MgomEnFgN8d1006xaNk8l8Au3MiVz9ZTbty/K4pscMcpuV2GhAeTDO6gL0Ee3x6TaodeoR3VXGCFd9eUgdryQjjbpm6YIh9AEiVOZCdnFiGnXu5EZAFLfCK1oIxsSHuF8KH2UBoQsQ140QHB4NraR9lfA99nghd5gEjxeCUXUj/wx8e/aUH2dCdH0Tv/masrfewm/wEEKvv44P3Ha+OPQ5FvMcfJqddM02Uu+pyQ6u+oPELt3Zs2yhLGKXf/Q2V7/yjoxiF1qKU8cD5HvVFKyj2t8MDfWs++5zLukfAid+VymeV82TGyuB3Cx1L60JsHHj5W8QVDkMQ10V/SwWdgeGye7xmRBd3pQevSWlQUQM50ebSC5qJnv2NZg613DbviACLG4Cm2rZe+VwKrJW8GlEAGlLL2dh6GBl39ZuDM7dXyO2WMWWQGJ86nAvvo26NUoE507S88UliWwNyOPyoDbyOhK6kK/6n+bDA04slQbaBqURrQ/l5G0X4bZ4rcb8sVTpcVusaP39JV2racdOGnYeJLzOJgtep5dK5naz9oPnmTfsKPzX0q//T+PvDu/fkCgtVUKMqMhJhIePRK8PoF3bR+T3KirX09SkxsHurLWkdwwgPa6enXF5lHcdAGNfhKmf/KVi9/fDRXR9bjUPLTgkfQbPhCi4LhSEcO+Ge6XQasLCCXx26DPJIRQWZGciO30bfU6qjo7GYKBx8xZqFy2WRdKBym0tBe+hgpqWzo+3WysKaiF4Ey4HooPlhbfDe82Up3lz+Juy4BZ+neJxIpTgqW3KpSHrkm4EXq46JANK0mWxu69bMHOujWBNwbqzxsHHthYRU56Gxq0lz5Ijlcv/CkWNRXKsL4rt4PLWXbyr3k6naF9Cm2OYobuN29q/SlPurUQZk/AvaJDJT+eiU3jreF10eTcVriQ2UXTynez/d7q8ng5vQbMPbjTkocSd7o2qoCV1rOBntDx8adbSlmJXdJtFZ9orFrxQweuFWCz+UbErIN5X+Xc1WjLufY7Yt94i+ZefiXlF8eKqvv22hbvosNslh3Xb/LksefNFan5X14DgF5Ytbx0LioJJWHbpDAaW0IWtR5Q4UGfOZXKPWOl96ePnT8+JSoi4Y+HPsssrgjDs+fnSEknEv/6X4BsKUYpLu+6Zqyk4dpQT2zaxc+HPNNZU8/u7r1NwXHHXBaWm9g/1/LMjgjief5rDEUG4Y2M4kGJkbWoxh1Jr8bcX06WwgrqlS6VqXW8w0lBVyalPPya98VRLweusqMCWfbZAVbg1TEhU3bI9bStY/NKjrBvfl9Kcs50+6tbswqerctAI6FiNWbcTji5u8Vd1dJnOW7m/Y9VAgMtJQOM/thcLv/MOIh58gOQff2gpdgVSXnyVvHAoCYbL3J9xtEhtCk12NaLO2HE2DeTYDkUlcAaq86go47j0eK1dvFh2++Leehvf3r1J/OpL2q1ZjTFebAY1qpNpNJJcBn5NTnYPCOEP+z5Z7IoNpOD7L5i+RFKp9BY71qNH5T1FTCjSVmfgqlfFpavaCutekJ+7UydSNT9DJs1p/Q3EXdlD/i5RlIpr5EwIO8Xb197O0J+Hym7yuRxdYRP3+aHPW8S3gpIl/LiFl7T4etOVm7ip3Q3y5yd9lNbCWaeXo3d1wPz/WyZzYpOS+PXX8pzX6HT46H24p/e9BCQpXYev1c6Qq2YRFp8onRIWv/68LNh0ej12SzPL3nqZ9qfM3HaiB5pTiu6iT7NzpE2tnCpU7l6Ba6Uq4uXak9DqqnLsuOqMW8IMhPtGYGivPHmHNFmYlDLpPNcegR7jldeu+N0fTbZJ6ho1dqzbRLHreUy2m2OuPOaEqWv/pNZB5tGf4eeZNM25BJ21mnq7kV9yulLh2wFXQyPUKGqb66KebAlS0yuvRkMkcZaHaGnwAb1Tw0Q6Yzl+XBa72sBAGSEt0FCkXr85JRKTZ0JkO51F+ddH0PppcXrDnMTkolhNYm+uabXO/Btn4++C92/gcjkoK1OhCVFRrTYxvr4phIepTmd+wXfypnSqaTXl4ar753DWcTgki5x40z+8UW4/VcGnG0+dF1+75IC6+f+6r4A75u7H6nC2FLuj397I5Z9tP2sUKRLEMor3kGazSY/djw9+zK1rbmXMr2Nk/KsXQUu3ypM6vU0im4ZeKr9X+sor7N/7BzZ3Ay6HH86mZCoabBTWqK2wn8GPYJPq5gmIgtbrtCBsduy5Ks43sGsPycsTC4mwzhE3SIFTtao4KHFWs/6im3hy4M0cimjHF0PjeH1SPUsLV7ZwIlOdXfjj40NsX5iFj8OPjmaPz27OhbmGZyKjSo1e2wa1xZGnRoReP8Y4i50svZOntp7k9RXqcY/ofKn87hglb+2lYUcRbk/6k4AQ3nnx4YEPZReozncRPnE/sSfnwm4D/xB2ixKPiOdYqf5GkV75dOpkzLQgHSthkoCIV31muxKQzuo0iy1XbZFemAJiEyH4zf8uDnsKXoHdxihpcyUW3YBRowi+SnFIS195FZfDwapP32P15x+wc+FPFO7cTmhjq4l7+e+/tXwuCkuB6M49WZFVi7NZ8V1N/vncPUq9ToFekyZjNJtlcZy5ZQMVn6rRcsS99/zXurse2OPUlCWSQukhuupz5RbiHxqGw25jyRsvUpGfKyNVhXLeERvD6Rh1Hjt1WhquncEvo1s3CwdS1YLcsHkzmrp6Yj1d0FVrf6LJR4PJpaVDkkf8d0bcrxeXBU1A44KiCAu52lq01W72vvF4y8/F+dawx4pGbIQ1FQROEx1oDZSlKwpUYDwbNM0UNJdxyuQ5PkXnp9h5IWJkw2++GXOPs8+PyMhkit69n7fvSsDQCNpGEQsL7YuVR+mJLRta7iVNjfWQregM7aeoc7L41EnqPT6n5m7dzncB8MB/+HBSN21k45RkDiVr2DtM6RQEbWjR5EWS76/XGyjrqOhS48oi+S10KFsbI3Bv2YqrQRU99qN7oa5Q8k6bA6/Fki6UeRrCru2EIcSHGR1mtIhMvQE44tq/be1t0o3Ca5UoaBRnYs6ROXJTLO5dV7a/kuSgZJZPW866y9fJEBURxZyc4dECBKjrVeMXRcOOMyhq/0OQ7gEWRemID42g35TL6DtZ3Z+dNhvRdjfTug8kxC+AqqICts79jtSNGXLz6RdtoUubUu6aNIHGNg1cEi8mZzbsgufa/2wef/FptfEOjPe4KaUqy7XLNIE82e8JRck7J644pXtvwhOSaQp0khei4dlrdeR6GG97UjW4dFqiasCam4vjjIrpW30E4p14mNNcHhvNs0GxFAfZeSujOz9UjJGPMfg60EdEYXfY5MbD21yJ9I1kUNxgTkerdbNPTSiWI2qNEJstESEdcu21LX/L7JOPISZBRY3bG7GdLqDs/eXgsrc0ErrkuBlR3cwNteo4/43z8XfB+zcklcFur8RgCCUk5Oyxc0KC4nYVFf3K/l3TyI1WC0fH1BdJSFDdglOn3qK2To3kzsTx4jqu/2YPr688wfRPt5NXqbhxoqO787RajLQaWH2slBd+U52h1cdKqLM4OFnawImSVrL+Tyd+4u3SChYWlvB5u2sYlTBKKvTFgvDmnjdlpK+1qpIuuxRn7seEgbwe0Iv08DZyrOp+/DVMNjeO+s4E+KhF/1B+605YiL28GO0RD4jOR9EjavwtVP9CmOLlMN7S7ZbzXm92XTbvbl7F/qj2HHt6FmuHlOJGh6NBdTZC9YkcmFMtI4HF+tumRwSXd5/WYvJ/ZoEvxEBX/X4Vlyy+hGlLp7Hg5IIWOkOXwE7YPVGsIZelofUzoLM4qfZzcaTZwu6cKnqho2+N2kQIJW/N0lPU/tHaDRCitzMhFkOdRo8h8Ci/lT7PB/s/kAuq6FD9S8gugxu3KZDMIlVwxg5Ui5n8+4L+IQIUPBA8aPG+iWhnEbUquNJxfmohEIv1hca4fxaHC1qf75HCs5975H33oRX8wpMnOfric7KQFWPzbmMm0D+hnSjFcHt9co8ek11a8XFim+LN5gR3kO/boMROUnAoeNLVDlU4NB04QPE1sxgQpkarpz/7FFddHcbkZIKmqff4v4pynaCxQIJfLS6nQwrOErt044Z3PiW2fSesTY0se+dVyhcpv9JTndpJSZjOsxldkb2e7AiLLFIFdnfQYenTCZxOyfGN23dYbmqPpKgFtHN0DwL6KppE0x4lfqpbvZqip54i9/obaP5uEcklqlDNim/kRGwYMZszKcpV13LDVpEN7Y/b1ohvTy2awKizPV67XsbPGfPlp47oLv+w4K0rL2PfH0upq7jwRqympBjrl1sYvdzMtAwlpMqJbiImLlZOWeoqKyjJUpvAtet/RufS0ODnZOKEWZj8/ORxLNysqFm+nmCGfwRxDwi78QZenqFjvyavZYPspXtI+ku0uAbcTHUWkbxvLgGlewhMtODTWb1/jnqjckO47Csa9xcToJtPUD8rpqTAFm9acX4JVwFR4ArHDDHdEl1fEYzy9fiv5VRE+CB77wmCC//FYeUi9HCfh2VXVSDYJ1he2wIum5OkTGV1VqItp1ZXJm3U6tdduOD9M17GfxbHNq+nvFnds5JjErBZmkno3I1ErYnBJwvodew0TV9/y8ADGQzQ+THQFER8jXp8+JR+6HDTZ9MHPO13gjBTM40OA2+4Qzwth1bYitSEIDm1ayv3XWdCX1eEQYiq30rF/ss1PLPtmZbjJe4B0295iug2nkmfn4YnZul4cpaOty7VYuihflf3027cTiOhjYqqsCrEh6d82rHZ18wJk5E1US6WDyqhNPwEBfXKPabW18SKJelcviGObtYkmjZukuuRgLDDy/Zou8Nya5Uvstx0qb8X9fBDmLurAAz/oCLs6xegDVD/wVVXgD1PXWfaqM4Uh2rRu+DqozZqKs7wwP8bZ+HvgvdvtNAZIiMnoD0nEjckZBD+fu1xuZqpblI70JT6GGITZpKW+hTRUcJuxsWxY4/gdLa6EzTZHNw1b78UEXmL30s+2srp8gY5dm6wOggyG/jsGjW+XrS/UH5vdXqrAGZrprp51VhqOH5yGYM83KZBJVm8P+p9aRbfMbSjHPOLxKSDCz/HZIfcCC0Hg3vRJiqQl/tcQ5UpgKDCWl740clHPx3jy9WvcsXJdRzL9KirzqA1nMnfFck+QvQkPF1jXnv1rOMizPi9HDqZwtVW2e40B/xGfEQzu+u/kl8n6sajKb2FhqyHyTt2HYVOJ8FRvlz9/AAm3taVCW0myJ2/4NEKizAvvkn/Rn4tRv2Ch/fKrlda+MW9HF0kGVMXbMIQbkbfXXXxxmsMJNq13N4rkZd91Ogtx+rklEfA07i3VMa4ekfSZ/Ixb+16K/F+SbgFX06XIbtFIgBDiF3+aYysgIdHZgtMwu5wYDabSR12GXbUuVQf2hXMrR30TQWqYzq53eSWQsHrifzP6Ar/CuKcO1lafxaf13v+yb8RHEz47SpUxLlwCTqni+HX3MjYm+8iokx1/UJm34RDq8Vgs1GxdQuFJ45RX1mO0ezL/FIlYpw1IIXukcqHVHiKNhzYT/7sm6WYJGDDZoxuCMhQXf/gyy6VHeb/DuRUmRCWm6HGZqZM6EBa/8FcdM8j8rlNeehJ/MPCqS4qYGdeFiejQkivLeBoSi3rpzlZPKyI3+PVAtklx5+2xeDQutk+weNQ8vnnhGTn06XJSVacKjQSLWHS91Qe2z17ZLhA4T33UvvrIuleUJp+hHYF6phkxzZQb9aTERPBrveekiKs2jVqbG45Oh+/vmrhpoMaHwsUJA+UXFUx8k9sr64f4d0s7NLSN63j0JrlrP3yY7669xY2fj+HeU89SPk5aXCCzrHwlWfkv0Llb69Um5zsqEa+mGIiqlHdk/Z88Yn899haxU02t4/FqDcR005t/Ioy1LHxH6QCNv4ZxDg6xBSCzak6rR1CVZEtICY5m6KqiOhWT2S4Cj8QEAVv2E1XoqUOoyYd98AHcfh2xFzwLkGG7/HPf1oJsUTRbfBlaqqibAgBqrgGhb5A3G9E/K7QAYxMVJSrH5fPoSqvlMe3PC69tsXYflIbNcY/FyIBzt9uJt6hiqbTcao5YM2qOC9aun79BrJGjqLkhRf5r8La1MTGH76iyaTuB+7SUn56+mG+ufdmUo5nEWSxSUGisV1b4dFG6P7DhOzeLz10/YYOxfeeH5Wns8OC1mGhVJ/A3Owe5B/Kkdef2BCI4ryhpgp9k0tO3np29nB1pQOF5/Pdn4PLwbzS7SzOWiwnW14qma5Zy0l/dc120wVgN2iko0670DRCh6sGSLcsH6Js1/HkRBVsYzU5WB6tzoHrEyYwOlFt6vd2qqZDjdokF/tF4vb1wdeqp992OwV33EnuDTdKgeQIVypjC9UGpGHdHho2KwGhT1d1rQi7y6QffqDtc1Mwh9vRp3+CNlCtOVrfIpyVarOTE+fLzvbq3Ana6kf5xn/TS/0/AH8XvP9hEDe2opPH5cIhzLaFFVlZuRqnR0WenXojIAqSTp3eJD7uWtoX+TJgTzVt4lr5iGlpT2M0htPUlEV29vstHdzPlr/DJQlv8fKQ1/h+ypf0S3RJXu7HG06xNVN1dwe3C2NspyjahPvRbHcyf0++pEB4sTlTdXTEzeni2jP8YUWKl61RLpSP9FU8Y9EBPbziR/n5rsRIIgJ9+eOeIUwc3oVXB07BqYGUUoivrSGwqpQbjq1gzAu3tOyqvQWv4FglBibKmMyKj9UiGf3sM5LHdyZEYSY6La8OfZWPRn3EXT3vQuPWo/fNoTb8eblARftF8+tVz3HwmXFc1LELbqcfm3zspPWLkkWvgOhuegtsL2dP2Kd5+XnPDnxWGrELzrDwzxVoW6e60SYPneGjCtVVHYSeK5qNTC6yE2Bx0eRyk97s4miFBZdZj9vmbEnmEV0fEdkqkBiQKL1tcxtOodF4OvjBvWQHvaypjFvW3PIPKRcifbD4qLq5V2tV4b1fn8jAd5dSFaS6dhm0dhxEYZ9blyvtp7zpXQKVQrXu2dz8mc5SbZNd8r+/35HTwgE/WlgnC8LIAJPcTAnLsDMLYIGmnt1pMhnxcTgZaNVI3q31dLYKF9BoCL/schrjVHx44YL5HN2k3oeQkAR6Z+wiPtDE6I5RcmQszr/j234n68brWro2QuHft8lJaJNFimACJyte75lotDdKP+G/ivxTuRyuUc+tXe4cLhkUjG+Q2kj4BgZx8b2PotO4CUls4miqDwuHF7C3Yw3Zlnxq/e0yZUrv0DAr5SpmDLuLG8qm0O30YNz+anKh8fUl5Nk7KQ2zonWBYckxdh7Zg9tgkE4Txc+9gt/Yl/Gf8ikBUz4gJXUmyVWhBDaC1egmP7KJotAAXEerKPpqLzjc2EvTcdUek51uic7TlIAxeSjfV6mIb+GLGtxGFXDuwv38+Ph9rPzkXdZ++QmH1qyQ3WzRiRWq/l+ee5T8dHXNiiJ30avPUVNaTFBkFJc9+RJdRo4lZdBAKuJgg+s44UMU/SEr9xSHNq3EUNIk0xDHHFDnWWya4kVW4hQcrpZAhX8G4RTiLUi9gktx3oopkxCN1Qe5Ce2oNg0Vx9SGwC/Ghk+ojVDDG4Qa38d9ehPWjavw06rrSlORDrmtvsYz2s+Q9B5hJSZik4UATbi3eLu1gkYhsMq6katWz5DiU3G/eXKAKsYuBMtJde13NKkiPztBFUYaUzRFX33OmrVfUr7qD4qfe46CO+7AUVIiU+uE+FJ0h8u/OkLxa7up+OEYDTuL/3QHOPfIASz1dWhi1Lmbl58jxZ0Oh4PT4UFyApK6YT1tli0j9vXXJHVEfC/igQeIffUVNbK//FsY+iBc8gH2S3+i3uEjpwvv7XybYb8MY+KiiazcpazH6v2cdIo9w4PdG6yhM1JtDubzIE/qp2dtEXBUWDhqVveg25MubgkgEVOokjR1TnTOd/LRuCvod7COtnXq/i3262KCdzTvcmKttxCZo7QRIZ7udMKkiykboN4zQ7mi0AmnERGQkjfzGnwL1N+0V+XiqlPNHstJY0uYhCh6jZMfwa33xeDOwjdBiQob1y/CUaHcGla1K2F3Wmspp484373mbyj87dLwfxRLspbw+6nfJR9MFFSicBUjz+UfvsXp/Wo8afAx03tGAg5jHSZTtHRmuBACAjrT3lQDWe+CCAg4IzzCYAihQ/uXOHzkNvLyv8IUOIVXl+/j0sRWw3Z7cxF39pzHnryZLDtUSHKYumgHtwuXz+vS3vG8uSpDfogiJdBHL2kNu7OraLBa+PXYPL6v9/CSRAfQ3ggZK+RIVERRjk0ay5qc1ZLDJLDX92KuH5SMSa/jwbFpjDil4bUoLUn5waR2vYOBoTpyPvqUxPoyih57nJQliyWNYeHJhVzf+XpJZSh5+hk56g2YOIGgM4oWi93JnM2nqWiw8sRFHVuiMSPNUbhrh0LwBjRo6RPdmwf7PNgikrhveDtWHComz+CiNOzsjp/oDq/IXsGKnBU83PdhNuVvkl3rToY0prWdJt0JRJxwk0NRQkLKfXHRiDE5iJJaCz9mljIEPzqho4+PHv/iBnknPtjkxCU4Iy43eU0OkjXQdKQCc5fwFlpDcWMxb+59E4fbIe3AKqoDKHXtpLjSzMprfuGFnS+wPHs58498y4TsA8q2KLwdVquVgoIC6WE9oHibdABIL7XidGs4ap6Pxvc035hvo3ttEPsq4+jS3Cw7v+K1CYguleBOCwjahDfkoNHRKD8Xm45/BlHoCv63+PhxZy6vTu/Wwt/tnhAsu73bsiolraFLnFpw8o8dYdHbLxEcF0bf7BICM09T/NhjNHqibf0GDsAQFYnv4MHw8wKatm0jvSxXdt5SN22hd1M9OVFudNox0iv5g7j78X3ndUwWqE6LouPM2yl57jmCslQXsjo0SLoLiAK/zlpH5/DO0u7rwY0PyrQ8UcCIVLw/A5EMVnIqkwJbO9oPGY05fS6sfEyFBCT2x5JVg35VM9cm+xLmk0G0JpKfDT5y0yLOad9aN7/P+5jQeh8Gv3615MOW/bYHg1vP5unTMG79nvEPvM6n9Yq7PMDQFT9LHQfXrKCuSzs6HDiOxicFrZ8a54IPMUGdmeCXiOP4p3zTJ4eaQRGwqImo9leiq9FgcTayoWk94amJOLduJDQ2nsiUNmjvP0Kt08Kypaqre1WHqyC8PW69Dxp7I6a60wSEpRDVph1GHx9ZxEYktWHxGy/ITuyCF5+ix4SLpIWVSMoSIQKXPvGCTM5K6qYK3Oy9Pnyb/i3r+rnptMdJhVHHuk8+kj+LqWnAnH9adqxj0lR3tjgkgKrQIEp//o4Rs84OorgQRCy5F1cvv5rM6swWTn9Pm01StVzGUBpNQwloXofJ3ADL7sRHp9wktMU78C3eKzeYbq0PGuGltevTliTChMAE3h35rtwgChsrEf5xpuCqj7E70bZwSowVNOksRDpCea7ubhrfOo6rRwRBE1POi9+1ZqmCt0t0V9YUbuaETgiRB1ERGcQLVS+SbdTQ/4SLBxe7WkS/bqtVhuY0H/fDmqmuL2eNVfKO9aE++KT96+JKOH8IRA0aDPuPk+3f6gBTGB6E3wOtjihBU6bIj/Ng8IHRivcf53YTFBlNbVkJnauiOBRZIhsMiw79QG+CcUX6yg21FzWdLuHV/D+ICu9ISfFe6q0l+Gl0NLqdcp0Udo2lpScoNIgANDc9Ol3BK+4psokiNAb3zj3BbUY/gm2NGGZfTXFREY8lhXKzJ83cXn4RBYf3MzBzA9c5LawY4UNstSp42101g/1LFjKeEOqNBnRRUbhqalooQvJ46gzonB5hsX8klpMWmaDmpbgIwarF/1LMNT8Q3XYVuuSZVP+0AI3LhdWgZW1SrqSm+A6uIlhjgJfXQ/TfibAXwt8d3v/FkGEaR7+VyTVnorihmJd2vMSukl3ct/E+blh1A8fzDjHvyQdlsSvU5qLYdbkbaOQP+X9SUu6RyUdCuZ575KDsAp/nMyjQ9VLwOZtjGRExlrCw4bjdDhZvfoou/soAvlk7gNjkN6XVmaN5Nzf13CEL2swydTMY2k4tntN6xsmdsujyCszon0hUoAmrw8XHe+aTVnGaMMGnFGEWAz1JO0fUbt5udfJE/ye42W88IqLcojOQE9Geq/urginM30TXNtUcaqPl1y7diR8/hnbXXsmzo++l2uSP7fRpKj/7nDhrW56s+Yzoyr68evML0pnB5edP1BMeNbCwgMqqYPx7m3l7zUm+25HLwn2tlIis8gbqi8fiLLyZ1Zeuld1fUUB64chrpKfIFRYd2Z2tXUlvolukOVIWfkKoIjiuo2r78fbh+6j7PVt2brxBFCnGRNyFzS0d3kUHCmRX81iousHHG7VyocuzuSh3uOk3OYWgCDO5DUqoYTleKbs1AmmhSrgmurgCN3W9idv7KJeJKkcG647XyqJdCslOb4dNr+FYfDtz5szh1Vdf5YcffqC4uJgIjVoIKwmhQOdG65eFRuNiaf0+siPH43BryMjIkLxd0QETEJ6TXmwu2CyLBZGC5OUjXuhcP5NPvDVLTQJ0Wo3ke1/39W5+P6xGyN3jg1qKXC+PV3QDl77zmuRr+g4eQtQLymu3btlvMhJVKKBjXlW0laSZKso3uMlKkFtDp4Q0AptUpzh55QLZ9apdtoyYJz7DrfdnzYh+fDw9XNIXDGdMArL9jby/4XUZljFz+UzGLhgrr0XhzSpe76eHPv3TXTIhhHPYrJj8/PGZ/iF08XCkjyxQx2ZFNs6iIkJMqtvew11BmMPJE/2ekN3AiX0u45aJj3DNDY8TEBaOrtAui12BwXV9+WpqFLdYvmJ9vqLNPHrxS1xy/2Py8xy3HatehyFRFWOBY5MwTY+mzlaJrz6Ay8z3k2iN4Yj1JH3bjyXZv4t8r3eULaGOJk7bm1jx0dvMfeJ+/njvDfAJ4usT82SnW0xUxPlvs9vJtyjh4sj4Yma88IakaUy860HJ9fTx9+eyJ1+g84gxyjN8xW+y2A2JieWqF96Qxe6ZEOJSgQ2lW+k+VCV3eY90Yr3aOIq44ri0jkTpTHJ8bnW7JFe4usRj1XUGxITlTOTW557lje0tdgWGaFRXV5sygKQfvsd00X3qB8KXWhSeri643To02HG5/XBf9XPr5Kr8JJxYDiVH5SZ8dtfZ9Ivpd567QNPuUmZWTETj1jDSNoCPTz1B0skQnHU2GjYX0rCl9d4kIL5vL2mSmsEeaaqxcaz+BPuCjnNvu/ekx7jArg5aci7tT8KcL/AfLUb5GupWF2I5VinsVAi5PA2fTup9EkLYPwNvwZvUdyB+zz1DZYCvvKeER0bjcrvZ+9vZ69e/gpw6DlNTsSmWfmy9aqv0L4+sUnSo4MSz7drmZi1kecMpvsn5nRUer++36pySliLufcLt52i1cjVJdWrwD2tHe10s95V0J/eJ1xj93Wtkhqj1xF6kXnNQbhXta/3kefNBzhI+2PQ+Q4sO07f0JLPXqeK1JthAtq6Scn2t5JIL4ah+1tXEvf2WFLEGjB2LT//+ZCW2Cl/LUlX3vflwK1/dbXdRVTUduysOnaMcY9g+ioNUs+BAiltOksZbXSQlNGK8+DI05j9vLfefhr8L3v/F2Fu6l7f3vc2z2589K/Ho/QPvY3VZ8W/SY9QY2Fe6j+vX30S6NVPy/K56/g1u/vhronpVoDMKzmU7woMnsfLT9/jkphn8+tJT/PzMo1QWeCINGyvh2FLsLi0H9yZRuz3vvIW6XdtHcaOlc+h+2oeewu4y8PSGiUz8wsTcEyoxaUDEr8T6qaIkIdRMYpi6iccGmxncVnUdBcZ3jmZoqiiGnSzJ/p7L61SBrOlxNXS/qsUe7be5O/ni3k1smJPP1CpP8llYG64e2o5g31YuqEWnjo2vuy19U0JlkdSmbSyfdlNjybwflrD01e3kHK5g3+ebmLh7ifz+h6kTmP5zBhsyynjp92Nc/eUu6fFq1KvL5tvt2S3HYU+OoFxo6RHRj2h/bxesFVn7yxhg1eOn10ox3pdbW1O/BH91VudZ8nPRbd2Zt50by9Rza9xRjDW3TnbBnu3zNO+VP4Hb5kIXYkIXYZYdTnk8B8fJBUm+Xpebo81OtFoNHQfF0vfiFGqcbiwa5P+1nKg6z6kh1i9WWrGNaaNESlpTBS+t2I2vLlTGGI9sVEW2vnA3DYVqMySSB/v06EqMUXXfu468FEtKa1epXrePoOQEWQxsT98uDfFPelzkxRjbC+Hneiav+EIF7+eHP5d2TKJgbrQ6WqzTFt0+iAFtQiX/+2C+Kry7xQfTJVYVvOmFtfI9WvbhO1jra6kwhNI49BrCLr+cqMcfk8l//qNGSasrQ5TiNgalpWHo11eK2CZ16YepTL32Bl+10RM+y0LM2NTczOaxY6iKTiGiKJ78xqIW+zGnj4mfRzbxVcE8WSyJyGdR6IrPxXEWxb3gaO8ovjA/2ps65YV3Ayo4p5IT3F0p+YW9lz2vFnthA/76JWg1iueuxcWd9X6yWPIWCT3GTaLDYHXcLada3Sx06LixfKq05BMQgtA2wW2kl3B0uzRZlFTEp6ETEcc6DX4DYqhylrKm6HvKG09L3v9DZdcRbQkjyak6rLajv9Jtzyb6niqiU9dexHfqIrtQJ3dtI/3IDunBLCA2cqL4WfPFR6zNjcbp1pJgLCGg9PwIZYPJhwm338fF9z2GX3AIKT37MOOlt2Xn+FyIAkjEfwuhV/GkjgTbVMEa2GQh9bOPlHgxM5OSBx+iT/opxh3JJiZJFR45B5WIS3o+O+08ve1p+s/tz8Ey1Z090zFFWOg90PsBVl+6mn3X7GPF9BXcGOqJ5o31eNR2Vvc/9TvB2ulZqlwPYXfF0BT/BNq0kSpZSzgyfNwXfp4Bc0bCkQtHxAoeftPeUsbWDmRLn1W8O/MTYka0J3hqWwJGqWKvdnk2jXtKWkbjFk931xDrT6fYLlL0Jrx8n4r9kDp9A+0NbVtCGb4d2IzvkMGYugzGd8QTOOtVgevTthF79haCJip6iriPOKpbnU3OPHcFB1tsMoWgUASTaHV6eQ6crFab67Z9+zPy1nvk50fWr6K+6h/b0XnR3FCP06GKyc7DVcGbl36YqmOZPBVxOwnlyjmnV/9WgazA6pzVLVHzfnpfpjY0MaQij4vDlYDyhzUPsNumwnE61+kpfOBBsoYNp/iJJzAuX0rfsgySTOp6NPfpjbmXen8fqh1I70w3KTuz5H3Eb6hK44utULzxU5EuTv/4BfcvcRHUrL7X3CaZgDFjSNu1k/gPP2DthMkcatNK+dreXt0Dm49UtLx31tM1uG0GKrhXWj6GVmxl72B4f7KWr8drGVAFLxXlU2szMW912X+r2PD/Gv4ueP8XY2GmUmOLi1yIjLxBCKJDKDBifzgP1E2mS1gXmjRWVvctI+DKQUS3TSXv+GbCO6vCp+JgMj8/8xjpG9dit1rkOFx0UU7u9Cw6+7/D5bCxpLAv6zI2snzOO1R8exRnXatIzd+/PcdqWrt2K7NHUWdXxeXanH400hsNTkYkq4ViXGIY1QszsZc1yVXgst5q0RL8y8jgJtrG1WAI2U3vhmwpVnMLO5Ze10JEe5pCO6NxOehw5Bn0WCk7Vs3yPaHUBLYhO7ET94xuvYE02BrIqlGiqt9uvlpyOwVuGdaGLbHd2Rbfj4Odb8Pq8ozADOHSraC4TVdsMUNpzqnnhm/2tBSo1wxIZNPDI/Az6mRncfspxcHam6MWlD7JSoTg7T7v+SObpe8dIC+9CrNbw0MjUtHjZOHaHWzYqTiMAmJ0NrODmpFdXDmcMEeryKtmSRbOCgsjdnfCWOSiWQvvBDj5/WgJp8sbMRt0jO8Tj1+faGl7cVKvw+6G5Fw8+j4AAQAASURBVG7h+AYaSeoSJjs7+c3qpl2/MR9rTi3tg1sL3pkdZ0p/X8ERTAlU/LVKR6bkVU+NGkjXMxLKumpOcuutt/LQ9VO5uPR9NNY67HozZQn+nHIq+yohftNoHXxb8x3LE5bzqeNTPjv8WcvvsDjUQimEP0KJ7i20BERhcbSwlqUHC+XNWxQtQpwizvM39rzBhqwcOSmICzbTNS6Qdy5OoU1oa/xtt/ggusYF4eNsxn5yL0vff5OiowdwaHSsihzDhixV7IVedx1pu3eR8MnHUph4JqI9CV5H9uymsqFc9u9KH34B/xGqW6hv25a9V1xOg0mNZ4NtwazavQq/KVPIu+lGtl83itwYCzqnhif7PM72mdu5TTuFS0t78VqfF1s4mF8e+ZJzITqMH8y+gvkvPk5DtbpGi04qvp6XcyqjYH2CoKGUrGVfoqEeX53yti3VKNHLJXWV6GXZfj6snmMQMDJBrgID67szv/BdXql/gAfT1DRBoOeES+S/xjT13rjj9dTWlkpvYofbxgLdIqwaqwxCeSP3fnROLRptNfZTazGKlPGGZobfcTdXPvtaS1fu9x8+xGGzMbGgA3ULdvD7+29Ix4wahz+NXTyJXyseA8uFHULaDxzCrZ99z/THnsPs38rHPBOiwJ+Qorq8S/OXU94BQhuacXQKILJHf8JvUS4rDevWybG9T0wMbQcNa0nVE1j91Udc8c5IOfYWVmBfHVFC1DMLXjEOF+lwMf4xktcfHxCPvuTw2QVvWFsQmwXxvMxBBF45lqAHH8R60QZ8r1UiypbJlYB4X4UgbuFNsP3D815b4+4SXE0OKVoN7BSNzs9A0Lhk/AfEyu6730DFzRf319J39lG3Lo+mfYof6pMaLB0c2oW03iMvqRrO68fu4aGEu/HT+0nbwHlzPsGaFYUuOAmXvRH/QX6Uv34fxU89jbMqH1O7YNkyb9zVmmTpxdENayQHW4gJTx9QQqzYtA7SbSN987qW8yqhc1fp/+y029n4rVq/zoW4/o9t2cD85x/nk9kz+fHx+2XSmqA0dB01Tq4dv733Otu+Vu9NuzEjGdlbnbMCWdVZnK49LSkOn4/9nJ1X7+I5twpImbpTrZ87tVZ+D1XTjnZH66lbvlxGcRs6dGR1imoARJTk0nbNaikiC7nyCvW97Rlcs081bQ6MTSJxzhxMZ8SHn4h1E/TTGvpmuglqUmtlmUd0KegidQ4nH0SncDKxNRRldUIyecF62ZGv36A2WM3H1T0go8LKvkpFVTiQZmVbZy1p7lg+rclHtHfWl7alprJahq38jQvj74L3fynEeHdNjlIcCwie5d6SvTy7Q0XZti3wI7zORNXedF5MfJCUIl/cWviiZB71tnpKyhYihPH1hb5kbiyU/p2ia3L50y8z7ta75e8QiVFkrYMNr7CrIpG8Bo9Re1MWB3Ytp+StfdRvysclbcTq+fLgGOps/lRawlmZM5pnL+nE85PFWF/DvhI1qhnTtoweCcFcozHRuKcI69yX4fUkJtfN49EJHXhkciBTl03hk8y7CI1czFMVqpDUDLwTQttQZ7HzRN1U7G49qT67mBryBFp3MU69Pwe73033ESPxMWjPUk2LQkmI0uIDlWhCYET7SG4d3pb9HWZi8QlD42xAY6uRhXX+tU8T+fCb9G7WM8Xmg1GrJdTPyJez+vDS1K7EBJlbCvRvtqlCeK8nqrRPkuK0VZc08uvre9n9WzYFJ6rlbj02NZgUfQEzzYcYrMti08plZGWdalmgRXzuzKQruaJSeUcGXdwGjVmPvbiR0rf3ScGZW6fhQVcjC/KquOcnNSqc2DUaf5Oe4MltiX2qP52v7kBkUgB9L1aLrI+fgYiEAElzEP/fXtRI+WeH8V9hkYKbKN8opqW2Wmf1jFJdOp05jy2Z5Yy2qu6Yd6jbyyeLGMrgixFQfIhqrZa7w/y5a8tDNKGsmlIMittcYs/Aore0zpM9EON8AaHSF9xkQem4qI1S8As+5Iy5n3Hvzwf5ZlsOK7NXynNWoMZaw5dHPiHCWs6kqvXMufMGfrp/NtdW/U58gI4R7SMIMOk5tXUt1xXMY3TpWk7tUGP+vZFDqDKGSUs8wcWWr9FfjZ/Phd+gQWjbp7GrRw/Su3dlX8duDJ06kviPP6Ldpo3kP/gABQ4HBoMBc7yyMss9kMtPCxawo7GR3HozRqeRAemhdCgIoiTzFFWHGtHUxLL6+6+5rvN1coOxp2QP2wqVB6wX6zf/yndDMvlZs5EfHr2H7QvmkndUdb29nFMR8mITYR6C01i2l2C9sKqykmEw8FBUMC63Pz6uSlzzb4bPhsLyR0TrTT5eBJF4be38B8USOFpZKAXUmehZ0A79t2VyqiAgurz+QaHEmVTnafOueXz/yN0c36q68pkh5axJVEVNqDOIRm0zvtOTWzmaobCkVN2n+ky7VG6m9bl1XLI1hqjDzWTu2sZJTzCEcMwInPqq9KdFeNYuuqXlOZ+Lc/mpF4KX1rCtaBtzOxTy9cxmxj/xtnqu08eReo2b1Jl22s6OJPnJKaR0VwVqfvoRSnNO8VH5j2RFinG0+n2bCjYy/6vXKS7NkWlmF7L3w1LXEsJCTA/V0hX3UK1n4tT1CnUMgk34949B6+OR0Yj3ctZSmL0OHsmGAXeq7wsrrfzdLe9b1S8Z1PymJlb+A2PQCLLwOccl+OK2ciOjMelwVDRTtyYX6ym1eTC1U/cncf51i+jGJ6M/4cGIOzA5DLjnl3JVtfIm/kL3E/X6JkqrNjM74RHuOH5LyyVc9/sf+A9QRbXsIp/hhCKQ7emQi02RiLAWiG3fkSVvvCApRQmdukqainiuo264TdqCic5/1t7z45QPrFgm6TCCfy+OpaD2iAmk6PaOvul2+XtEWIXoJgtay0XXqbXLC290uhDIihCO5owqGkrVNZTmqODeyhra1DkkdzfQBQN63UToTTeS/OuvHH7mA97tdhnlAeFobIK3nC6fs6B6CDGZLTub2JwGbDr4pH0eKxe9jfWE2ggJnIzTsLGbjiUDNARfMVl2ZzfXNFDe0MjW+T9y195jlKOhNlJNFhx6A1kJScyNbOTXBAMf7Eyn4MhRmtIVvaGwKQtb6sXyGj9qVsl5TyeIbr2bEuKoD1WOR4UnzqEj/o0W/F3w/i+FGO2KroOwxBGiJsGZE/xAUSwEaP3odVJ1CG3NzWz74VuGHA4n3Bkgx1ifHPgIm07xySqOhWA06olr24arX31Xxjy26zNA3oTEDavm+xvJrfdje4VaFBOD1Q72SPVWimuzqF2RQ9FzO3B9fJgrbRF8c+J1ntn2CKH+wVzZN4FxnaIkP3dLrhoX653HWHzHIPyKiwkzvIB/7Ueyk6Pd/Caze/nwS86b0qVAjHzvr2gi2umkgAgq+z4g//8bK0+wpq4zS6qfw+LyJ8p0mln6+4ms3I9LZyR/L7zx1g8cWp9PY61VelUKXKkJhgU34HylE47nUrEdO8h9I9vR3tPZnRtkYEeA6vLpQ1M5vFl1LrR2N6tm9WDLwyMY0ymqtSM7SC3q646X8eSzm2Ukr7iYusUFyr+94NW9VBU1yg7r8JntueKJvgy+Jp6NGzeidTuxi92H8Bf+TY3b5N/SaLnDdg1+LjOGGD9ZjHjHhwKmtBAODo7isFCUnwFv8S0WP62vgaTOYVz+eF/C41u7X3HtQ2hwQW5yEH59RScYLIcq+KnvdyyduvQs79seEd6CN5dd2VWYTymh2dzAAGm0HtpcjPv7KWCr57hPFJfFRbNV2KC5DSp/xBHC00Nv8rosEWUdA2Wq+HDZ1Hm5One17JJtyNsgvxYiMNElE1QHl0isj/oRU/QiXl15iK+P/NjSATbatCTsOMhVRb/ik3tQJoMJVGVn8rDPfl4cHMTzd9zDwZ/mYHTZqDSEcDCwKxsTL+Gph2cTHegjueFCEPnPIBa2xilTcHksxU537YDOaZN0gkaTiW3bVJE6ZcoUJk6aiE1rQ9+kJztbbYAMLgP96/rQrsCPXauXM2/+Apz+QbiNJg4VldJwspDp7dSo+/6N98vNqhfLilfh0LulPVhVcyU7fv2J+vpq+bdj2qmuvKBGfG5XXbtA7Sr89GvEUeOd0GAOmnMo1Ckqg/bEQhAdR2HJ9Ns9wlZDjkhF9aKP8kUXYCRwdCIxT/VXwQfRvrga7JR/cRhLRhV6g4F+vaZh0vnS5Kin1JIjO3J15epvVwXaKO9mQx+pOl1fRP3KsZj6lrGvsHYSUdxirHzbnvs5GacK6eBGAz4BgQyZcR19LpnOyOtvodekKUqcdKmID/YBEQXuSST7dyAoO2JD53VW+Gjcpy3qe82Jpegdxehd5RgbDqLf8jQRG+4iLlyP1dbMnctuJie2Ca1Lw/OFdfRvtsiCb0nOMpYs/lj+jmhzpPS5xWGDtc9L2pc81uKRgfHgFw4Lrocfp4OwkBKvqZeiLl0QgtYQ3wfZiZjwioprFxDiRJHct+AkTQfK5LRG3Bv8h5zNW/ZCo9MQND6ZmCf6SZqDb89IDPH+mLuEYUpp9fqdO2kuQ+OHEnKpoKuYpBhtcuFQEuzRVOvrmDt6E291W0FxiJsj0VaOJqniuu6PPzC1D0EXaMTVaKdheyuXVzj/FIjiVGz6/W38NCCLPe2rJU1EUBuCoqK5+P7HWjYsIvJZvP8Ca+d8xJI3X5KhKuLxoiO89ecf5M96TZzM5U+/Il1JxLq0+NXnZCNl8gNPEJ6YjN5kYvzt92EwmihtLJVJnJkFGaw4ojQDQthsza6l6sfjWByqMBT3p4krdbz5cyqrE35i/ay9pN75OFEPP4y5S2eWHiySm5OG/qrzX7dqVcsmWThJeFE5vAsT97qIefpLKXQWVmr7bh7M8QT4dYiGlRMj6Drxcjb0S2Ze1HaGrf+Bl0vqWd3sRO+GO0uC0CcPI3v0WOwGIwtTwnmtkw8fDerC0FIrn0VqWRi8li8H7ab+klH8HKrof6PDu5NcojYX0Zc8Stu+ykN68WaP3uZvnIe/C97/hRBjnl9PKn7XZamXcWu31rQZIQK5xzYVP4serWexlrGoLg23Japx4YHcuWiNTTiadbgL9dyRspGrQpYT4OeJMQwIlLtwgYPlISwvUZ+n+HdjzMRb6DpacL3cHLRuQhOiCkZ/m4vrMDGjzITL6cNdo1KlS0JkoA+9EkPIq4vHjQG7vYqm3C2EVN2FWbcXt9uAyxQDTiuHfr+LE1Un5Fh9ZYcHuapRFSVvNM/m9vkneH9tJou353Fxo5EyW2dW5d2J06bBL8LKKMO7YN2JFh0BpxLYOj9TFp1HCtO5oq6eGw6vgPRF6GyF6ClDs+BGCncXSLNu/PQ8dm037r5WjYJP7S+juljxUk2aOmIXj8bv016Q09qJC2x2k2oXdugw16q6j+EODfOf3Cn/tqAzxKUFc8WTfekyLI6IxABOZp7EhJXOiaF0GnM5LrcGZ20pCzerolx0gR17VhJmeJagzoWygBXFafjsrkQ91IeIG7uwtUnxSW8d1oYnJnXg4fHtGdhGcez+GeLbq85Odm49IZemYu6o/o/jYE2LW4IXXo9ZvTkfp60B9ylVlC7z92OLJzFM01xNc3BbbowwUabXS/oCGsWv89EbqXNnt4TvFXEIR4DqOtiqB2GwqE6asDsT7hTeglegk+5urBUjJSXCGLIbY9Lb5NSfxKA18tyg55hc0FXaEYmuvX+3NDmREAp9EUuatXs7859+kKCaHElfyEoeyfyEK9kSNoR7b5hK94QQhqWpxWLTyX+dJncqqJWe4tZqWL16tbz21q9fj9PpJCkpic6dO9M1pitFYZ7YWJ2L9GDlpxxdH4c7Io4SczBWl1t2ifRWC26jDwsW/so9Xe9mcOxgSdm4Y90dkspRW1vJUV/VPZR7ookdSR01gtUT6vnj4lryrcWy2BW+zN805+Bwm6VAUKB4dzAdm/tIkWNxvyuwujrR5ByEJeZmGbXMgR9h1eMtdAYfMZb2QOdvxNw5jIjbeyhRktMtO4kiLS3aqnihDeH1zP7oS/pNVcJGlxaqA2x0iuhMxC1d+W3wPlYH75AixKhHHsanZw92DQ6TwqAHNz1IRnUG2Z3d6AP9pAPDNa+8Q/+pl8vOrihoWrq2cb1hsnJUYNt7sO39Fo/avwLx+27rfhspQSm8N/I9GRDRgixPLG+fG2HEE9J9RpO3g8mRW9g6MJ+MoHK0Tng+YgpTHTXMqFPX+MmEBla4lJVY+2aP5d3+72DrO7D4dshTsdXE9lAF+7ElKmSi/+1wxw6I8fgR/xmMeQ6M/lC4D9f61/A9/TCRxvsJvzpKTnM0un++fGtNeklzCL2yPVF39STsmk4X/D9as17+zJQaTPj4VF4QxbagguT9xtGAVlrJuglRkvojhFuWI4cIGKOEXLWrcxQ1TXR1c7KxNDag8TexbWA9Db4OHHoXZTmnpV/0tEeekRZ6Z2LgZTMIjoqRXdpTe3eSd+Qgi157nl9fflpS7OI6dGbErNkyZEVc7yLGuzgrg31/LJFixmtff59bPv6GuPYdW3QQIonz8nVXku3KR+/W0TevPRXfpuOoLMChcVFtH0nBllDqKyOJeOh5Ikd1kX7oXlQ2WFuEsWlXKteIhk2bcTWr+2/gRR6vY62W+KNlTN/uxuiEE2m+hL/zOqHTprekj/aL7seGpl3khm/GaD2Brvpzjqaqe8vs/Dq61rrQGnxJWrea6ArFce5c66BDrZNmnY4fI9fwZcwiKkyNPLT5YZZ49CkzGixQLNYOESs4kfiOSiRtLD6fV/03FP62JftfBrHYvb33bRlnK7oWwmRcjGru6XmP7N7e1eMuljz7lHxs97GTOLBS7XCFM8O0Ideyc8dxkhoUx7cqM4hugaXotIKMVQ575sCQ++XPUnt0k2PUfVWqexjsE0WvsDH4dAhlxPibOLV3F7XVpZRPq2RJXTxl+0p5GB+GuvTM0waQnNNEk7kc324RTOgczb7casosybRxHsfnp6vRaetwuCOotD2D0VhOCC+QmrURc0IsL3WaTdDSh+TfPdI4gcSGvuzNrGHtiVqus/jg59ag07qISt9CBd2ISj5EWFoD/Y3vYXeHE2yHaKcbq9Ofbnvc9HIrWkSJbTR6BhFieB8Dpwhb9xx6rqPbkDgGdo+TBefRwFM01ym+qslXTw/tMkzWQrCC+7uLcfW7Uy6S+77bxZfGT/A35TPD+hgn3QkkIrLgnfL/DZjalk5DYqVwzIusY4e4k+8JFLHANZ+Ra/DB11FN47pfqPB/nUCbiVDb02h0Ntw7b4Y2v6BpM/yswkSEdgj0TgphXOdWisa/Qky7IFlA11VYqKtoxrd3FM3plTQdLJNd5DMXQtEVE5sOQZsZ7rMJg8tGsU7HSYOBpf6+jG5qolKrZZafkQa9KnKNBGNDPTcrFZJiI6B1G8HUWlw66ztTXd+ZNl1LKGtWAkaj1iwXhfUnSnl79SmcrvHc0GsMq8repRK16Nhru/LrlkLMJ9Uofm3fMgoj8siuNnJp6qWMvfVuVn78rvzZSb92DJ0xi0fH9pJiQ8G//nBDlnRuGJYawfy9BWz+FwWvCEjZeTQT0SNPdcSTqS/g8OHDlJeXS2cKgXHjxrUUafFd4zl08BCl5lLqDfX01PXEVmmjMVxx7rTNjSQeO0y78lrWjR2DVW9i+RdzeP/e97l3/b1y7P7k1ieZ4jcSmyC/enA8uIzAjimUHq4GO1y/6nq5qRVC1A7WFJqdPfDX/U7poRDqCwK5ffJL3NdO8TPr/YdR+/tpyAY/cwghvAG7PsNiE7zECMXDPAdak47QK9MoeX2PHIfXLMvCWdwsBZHd75omC+OhM64joUs3+bztBre0zBLfT+veFTYo143Hpj9Gyk8/cfHJX9m343k5QRDexVd3vJrgWUFygyIg/GuF6FbY8H025jMMnphUul0OFSdh8xuw5hkoz4CL3wV9a1HyZyBoMl6qTAtsTa2b1/63SV3AqZQBOOZeRnubjWsdFbzoDGNKXmem+CrK0fCmZqIcDkpNerJN4OdycX1pjnJU2KJoEtIu8bgK8SG6G6zyeOIOuksVr38VIlVLeM+uex7t1tfx9V6iNeL+3cq//++AMc6fiJtUY6MPCfKa8mpErtjsZP4wHTtDq2ieMALTwtXULlmKuV8/tGYtrmZ/qhacJPK27lJEJjajB/paqDA0YLBr6JGpzrMhV11LWPz5doOiKzv1kac5vnUT/iGhlJzOlHoSwUUV58nYW+6SE0eB8IQkhs+aLWPBdyyYJ8NXgqNjZJNG2EnamxvZWaw2HU7PJKxnYwdcq8uxZa3FelQl+6k5gw/xH71CwBgP1/oMLD9SjNPlllqAtkP6cio2Vhb6+bffgb2wEENcHD7dumLNOImzrAxdbAyfDLewLqmOypyFUpjqRVFDES/lrJRseqc2BJ2rmsCK9wi0X83l6YlgCMFZk4vR4eCH338i7KMPOXFoIwv2/IgzxEqNJku9jvAeHKg4KNMT06w2emd7vNET+ks7s9jUQKnh8LP+9wTd/F/E3x3e/0UQQp+71t3Fj8fViFcUuaLYFbi528081u8xfDDKkY/owPaadAl+IWonmdS1B0YfM7e0n0onX3UjaCiMo3toa7KZe+sH2AtVIdAuTJDsVVdFbzAyKHyy/NfUJkju1AdeqlTiG3/+kbl7TrNCY+f1ABcNuIl2abAcKKdq3gkcVRbpuiCWt4zSeNrmNKGz1mFzJbPH/wOaDW2odsRTZwomyOXi21o7/Ve8gd5ZT4ktjQO626XY6+oGExOajbLYDY72ZVDVAoLqc3AMu4Zvw1Xh18dmZaC9kI4UEqIrItp4kl5uxac72DgNi/NeLK7+nAy7Q34vRLuEXn7HZRCEgCgIU7p6uqUaGHFpJN18VeHmih+Axu1Ct+tDdB/3ZLzjdpJMhwmjmo9jV5IY6sujt/Zi7I2duPqFAbKre2axW19fT3DRRgJRBRt1hSQ5ThFBFcmaIsKXXYth5Uw0GhsubSAaRzPMu/KsrvKZSWKCB/1XYPTRE5XsSV87Uklho0PMeeX42mtIfya1QtAaBjY386Zmnvzeej8zYYZkNviauce/BzNiYsjzuDMIvDToNWzZD0vKghtnC3futp6zWx4To4shzGHCbQ+jW/lNXBrzKPba7tQWXMzs7w5yx9z9cpGZ3jOOx0ZcwqIpCxkYNRydK4jGsmH8sWgZOpdDOi1U6hS1Rgg0b1x1I7/oNmGfdCfz4q7gdJdpXDVK0TJuGd5GcroP5dcw4NV1PLnkqFx4hDVeUY3q1pwLwe+9cc4WAtzq9fVzpDCy22B0Ol1Lsdu1SxfC6urkIiswJmUMWUFZmIPNfDHuC2ZOnNF67KvK8M09QfuCUqLMvqR4rI2yioopTj/Gm8PflBxmESX7abG6tvvTSb4PwrFCRDwLRNp85CZEFLtis/u07wPUOmaTl/MA1Sd8iHz4YUyeYlcgYEic7O4JZ4XG5mHSDkvAV7MJrb8BnxPPwntdYd93cmTe8v6b9AQMVxtdryjJt0ekLGpbkBjC6eBq2RUTjg4CA2MGSnGQ4Le+uvtVGU/dP6Y/v17yK2suW8M9ve4hzBzWUuyK8I0Zf8yQVmiCy31m0qDEyCdgwuviwoSDc2Hpnf9Wp/c85G6TEyWCEiA8TXbtXzz+DS+FqSnI9LpG7tgRzIw+k9AIv29Ry7r6cVtNrbShGtfQyJKCYvpYrPDrDVAvzgnPtV7meQ3ie1WnwC8Shig61r+FAXdIj2L1HDzFouc5/U/igT4PSBrAg70f5M4RT9BT30ZSjZb31XAyFnZvnU/hQw9Rt/gF0Lmw59dTvzmf/KOHyIxv4JA5T3JMZzeNw2zTUetnJ7TfGWEQ50AUwqIg7jH+Isbfdi+jbrhVakqEJ3JY3Nk2Y52Hj5bUO4fdxpo5H2HNy6P42efIHDacNdOGyGvET+vLM/m3MrppAHdH3oIta01LsevTqRO+AwcQ/eILaIeOoN7i8cD1wO50Se2AwJQesXJTGzBeOViIhEF7fr7813L4iBQ8mnv2pM3ChYy+5nHZ1RVC1LnHlAuJwOEKT1BK0KWE2m4gvM4HrauBUPtCggzqnDsd4sCdlkrH996h0VHMg9lPszU0vaXYbQqczrtjv+H5Qc/TPqgtD1dVt8pRPemFgtZRE3I2n/pvnI2/C97/RZh3Yp7sBInF7u3hb3NNJ+UXeibKck5JW5ik4bXsOzaSDpOtmMMsJA1xs2fvdIpO3CjWPxrLfCixu/DR2qmzm7CaotFYqmj87GVsRQ34l+8i2U8VQol+HQkwhNLgU4fWqHaPbYeORhscgbOpnl61B5nWI46V9Y3M0jdinh5DYNBv+OuWSVGbeelpVmkCubK6DaFVqnta5biPLeZtHO39JNlDn6AoQd10OtWUYm4upMkZxPf1D7IgTNOSShae4E//yW2YOiMCw8HNoNPxQ1w2bwcYeTi1B44pn+Ca8DpvJaRxY1Qk82wz2NcwnQ21t9Novhm9Rkut083y7CRyHCpusqPvCkKjWz0u2w+IQaNxkto7krbNCzBqm6mwJ7PK/ibLqx8l39odl1t43bppiFS7+HaVG/k9xUmvmEDS+kVjPrMw8ED40PZGcdsY/ijuWctwX/o1v8U9xDZ645LmTA5qXZ2wTd8K7caCKHp/mgGl6WcliQkeqqCKkL/nLy1+gscrsOWXk6z6Kp2cBnXMvQruFjgdPG0382lJOUFuB4dMRj4PDKegoJe8oW8KNhJkfBiNW3XbkgKSmNBuEN9cO4lhca2WQIIqMbvLbCYmKyHMld2upG+i4hAeKrSweZc/lqIZOGp7syWzAovdxfC0CF6/TAlaRLrUFxM+Ys+1m7i9X0961KvjZw2JYnR1O6LrH2Jq2+nyyInEpG9yyqg0hvHYxA7oPR3ryAAfnr64E0lhvtIxRKT9+Zl0/5TWIKYRmgb1s1CXP2aMdNOmcP/99zN8+HA6pqXRafkKsqdNJ3PkSMreeouhIX346aKfWDplKf3D+uK7po4Jth5cYu3N1W1mMiy6AxFR/fEbfi1Dhyr+n9MvgD8+fR+dxdWSkOXQqM3oDR2vl11v+XqdVlIL3bz5YQPDNGnScuvHcT8QdlpQkHRYTx2QvMGQa64+77UI/mbME/2JvLcXuhGKPxoYvZvomaA59APU5Clu76eD1Lm25A5IX4Jf31C0foaziucz4bUwG+cTg0F0OZ0O6RUrAkUEfjrxk3SOuWzZZVL1L5L0jlcK/qQat4qi5PqV17eIvwTE486C6J4PuA1mLhDEVOW9LQrfvwJh6F95Tqqdl87QbrT8G4JWIzYRx43+VLn6y9CIa2OcpNoPSaswi6snNfbZXFbfyL6cfN4ur2R3bipuQQXyvB7ZwRWhOJ64Yfd+tVF0j3rqPN/yvwTBaZ69ljK/n6mwefjMQsTmOT//KYTgb9ndyvHiL24UREf+nRHvcH2X6wm99hquGaxEdD/VruOp6/Ty48OLwvi9fTA7i36gwlJA3do8ThWdZldntW7ckXwDtt3q2O/tUM0nR/+c77S49oWLw22f/yAL4Av9fNgNd7AiagLvViSz6a77qfnlF5xVVRyJU9dPN2caAxu682zCY8SVpGM9qnzbw26/jeSFv5L0zTc4J05mzDubGPnWJgqqFSVDYP7efE5XNEqhstChyP934w0EXnQRYbNvIuHzz4i49x7p3R00dSqJ33yNPiREThLEtSn8pRdkLsCNus909OuALvRZmoKmMq0ykOdjHpEbwzyfCo6as6i3V3HE18mWhFAcZpO0wROT3K6aRIbvD0NjuofG4Gn8UV7D9NTp/Dp1Cb1tZ7gBhfdvEWjnB/0dK/zP8Del4X8J7C47846rm+jj/R5nXLJS8p+LkqyT6EwOglJL5c3a6bOX9pdBtTVbjuUFb7S0NJSajUFkhVeTbdBTVB5FonkcCXxJgHYhZd9fQqR2DZfEl5MniAo2VRyeKttPmms8x0samPXVboKNPZnEavrUHSKvWpnSP5uwlbD1t4IICTBA+Z4ErK6eiNIooLZOFdtmHdmdf6V3mLJawqWnJDQMU6ILQUc8depycmpGsdLfzOnKBp64oRPdY4KkAEyg7L335L/Ofl2ZW6JGiFeOfht9tDJUjwr047s9b5Abl8uLpx4l2ajFYFM731NWJz62aHbbp5IcvgU/7Q6a92Xh2y8N7BZiCz7l9rj3ociBplD9nz0NV3D6kBitDyDbOgA/fS1DL0uk7YjeuL65Em3uSnSHPqXWnUDoFe0v/L4cWkcfinFpdGj63Ejl4irshT6MmjaCS3/txDjbbtprM8jR9uO29vHQ/kes307BVLiT2jmTSZ8wn/QmVbB2TwiC5moQwjExRh32iOqGefEPFOxCzLZvRathfnajg9SgfFzH92PNDMPUNkKZ4696gqhCJaLaaornpHsG2vpcdE3d0fIbLkMJr0wewvM71skOpIhZFYtQ/8RQdMaJbF3/a4syWoyoXx76MpemXSo9Szv61rD8y10UuIKxNSrTrE+v6cVHG7II9TPxydW9MJzDM8zJPo1r+88E2OtxaXWYQwMwaJzUFZqwRk9nSFwlWwo3QdBmhsbfwqgOkWf9/6v7J8mP4tpmhr+5kQarWhRXpZdwRe842bk9EyLeOl6rFo5Yl1pYLJnVhExtx5COHcl/9z2sJ5WfsLO8gsovv8JRVU2XV16WinURwWrLrSPBJ1JyYd0lLmJ9JkMPEIFa4e0iCd27h6rwcOrcWrb9/IMc2w4LH8Tmiu1E1vrQv+cYynOtFOXkYNHamLmxHLMN7vmogLYrV2ArcFJlKcPVVIWzIoPoJ989y7lAFBZCQBcdHY2vn6+0riLoctxbn0RTeQzHb3eqbodwEhAFYflx9SFwcC5aUxDB3d6jakeE5HYaos/meadXpGN2uXg6YzeIaGkxwr/4PTllEvoCsQkRna0DZQd4ZrtKyPJ2gYU91PyM+dJxQ/BrRWH/S8YvLdHZ5yF1DIjCcd3zsPxh9ZyjVbf6X2Ltc7DjI7j0K5nMeHbBO0bGAb+99y355ZUVE3D4DsLdfD2+2nTch5TivsFxCbrEDlhLe2DiIPWujmTWh5OjSyTFvhqnKY6K0KFEigALT8GrcVtpdval+XQ/Qnq6z3NT+CtwWE3YKv1B4487qhua0sOQuZpmO+g3voh26kfo0s72npU48APsVy4JpI2Htq1j9r+KkYkjJZUmqyaLCEMo1FtoWxgk3+fcphJym+bSJqgXa3rl49S5GRIzmNCtFdTb7YSktSE/Mpf87OVyw/PSkJdaJpP/DlwuNy9sLiXLV7kbPJUyhffKKuj2+gukbxfddBsdD9bjclfTuHop9asVhS/8jjsIv/sueZ2I6+ORXw9TXKs2LHfNO8D8WwficLl4b62aCt49qh0BPmrTp4+IkIERXgjRWvjtt5/1vMRE5qE+D8mJk8OQgCXyPhz2ao5q2lFl0uHncDOlJhKffTCu7RD+MGxgfvgqZqRexML2Rdi0+axechUnrdkEGALouzsEV4kG29FClkX15ZdtezCmxPF9s5NHmmIY4VOMpUZPwT3PYJvzFQ/n5lCV1ofUjHM2jn+jBX8XvP9LsC5vHaVNpbLrJXi7/+hGsGrjbmJT69DqXBQ3RuLWhBDrm0FQYE+O1wzgzc1xTClYR3BjCZVt6vjaL5DUjDYkBEzCblyJQVtAcOMb6HSlaDV6zNa+0g0io3Y3J2p20u34MZ7f2kBlow3f+M4YffKw5Z1As3MxY2KiuahYiU1cbh9pgh+gW4BxxGQphGmao8QQZeFGmsJO4HSbadPmPuatPsaN2dMo6PEejZEHqXJaCKyKp3OSjtOHi9mRW05/wU+Swi4XNUsWyc8XplQyrmYgF+vGkPCrjrrO+XIUO63dNNblrOX6uotJ9HSkBQexKdRNVn4RJm0UVeYEap1JBOlycW75HpJmwC/XyjHkmUtTk19HTpeoHbSAwaSj0RqEzRgjhRo1+ROJYCW+ug3UHTiCfVSijNy05dVJXpzGoKO5uZnIAs9oNGUMmho/LMfUTbX6u2M8G5GAX0Mwv5sCsGls7Dl0iKV5Bv44dSMLjAW0dxTQ47eJlPpOIpTxdE9oDwd/UsWugOA5Fh2AyizFxb7+91YP0DMQ0y6Yi+7sJl+DCNmo3LyMCNMraHHg+vFV3H5BaJrUCNumMZNrv5pkyxSS0WBurqfDzQP5KnMDmwo2yThVIbYSY8uJ8Rexb2UOB9bk4XI7GRpgps2pBlIfVcdNdDPEaFtYtdVvL8Oo02BzqltPpxADEQVWHo2Kwm5zsnPl4zhdlVQcvQKDIZyYwVkcPvIHbqXl4Jh/e7rGJVNXdJo4XY3k44aGdYHITRiD9vP0xYky+UoU2l5FfsvrDzJzTf8kFmw/Tl99PuE5B3nxpRV06tSJKZMnY/J46opI4i5aRR1J8I2EBg3OSgs1i1ZS9vpzOGtr0UWEk/DJJ1gzMqQ3ad2KFTKVr+lgDbbsOmkJZYwvQh8SRtMhA26bG7etAY3RH1uui7b19bLgtQeFcmT9anpOvIRB6eFUNwQyLHiAdEcY7TuMHtnBchPo8FuFu10mztIqSt9aiDZAiZ/s+Tsx9+6FMbnVzUPg+PHjzJ8/n9DQUGbPno2Pjw97j2YRrmtHG9dxDNVZUsjmmDaH9Vt348raQI9O7YgxNuE+uhBNXSHm0g8Jm/UrRm/E6RkQ9IOLGxox2z0dTuFO8PU4Um5cLeOxBZwup4z3FZ1e4SIjPJdF0Mbvp39voWXd0u0WObGSBW/lP7FTGnwfZG+G0xvgi+EqgEaIzYIu7FSgnoADDqomATs/UQVvdY66TrR6GuP7cMfaOyhrLifWFsHltkmEPzAA1+FP0K64TU5cRCKaTdeRyBkdcBe/S9O852h0zCTUuJb6kpHU+CVisXal4atriQrwiNhkRPZYqh13wr4K3LYT0g1DY9ThPzRObT7+AqyZHspRuI5TDaEI0kr5omcIohqDzknxTw8S8cReec6cZY+2/qXWrze/9acLXhFjXZ5zmpLTWdInNyIxWV7DgppicVrk5Gb9D3M44F5KRaCVBl87ySX+nK7dT0qWG2v7AG7UXczmQ59J7cjU2x8lsGGYFFoK+srMP2by2djPpFXkv4M3VmXwx+FimbNjsjdQZg7j0SF38FFKZ47nuiUTr/PeDBorHlX/Qacj+plnWvxzBUQc+foT4l6kxWTQytCau3/aL6dM5fVWSVETm+S/CjHh6Nv2DlbaeuHSmNDoIvH6wYwz+xLaw5em/WVMzx3BirYb2eOfTqa2kEaTokaJYldgfG1XXMWF+Jl8uHzjepaNnsq+iBj2CasdNNw/4nHeP/YKq0P7cSCtK/szy3BrEyHpWnZFiuS6Vvefv9GKvwve/x9CdKJ2nKpkSo84OYYV8HKCrmh/xVlqUi/EjvWpJYcxFmQSNk2JhzYVjGBN7hC+v7EXaYnh3PjaeuqtNkKslZKdKxTWq80BDPcbhhYjlX63Ed38FGadIv1bXB3IqD3K8bpdRHVKRWiSlm7Yw+GcYC7L280Ddw4n4OhOjjbXYah0cK1BdVvrHZfQ4JxKtPEWfHSHMSSXQHAIQbp9CO+ksggTTlsAXft8Q6lLwwKf94kNiWJo/mhZ8AYn7yAi9SFcAWZWHMml49Zb2Le+jo6P/wonynGWlGP3cROvH8n4YpVuY6cBe0GDtFISAQzvND1JU2GpJPGHXd1Biu2+/f476upy6T8skWH9e7Hr7Y6McuVirl2A+5u5ktJh04exoeJ6GgK6M+2WeJqsMfCW6kRrdRq6j4pn74pc9q3MxexfiL6pLdaAXpjs+wkzvEj9ijjcmiCaj1ZKvnP4zV3Zu20jfdxq120ceAvVuxQPVPAoBYc2oUzwpY0kOBI4Zchm0e+rWGlNRavR8XbEyzxQ+wodHBlMa15ML+M2SiJXwVpPYEGbkaoIyGr1ZGbDq3C14qudBXszydotUvzkF2HDL/h1VexqzGhphqZm3AZ/LEmjyUsfh587SZ4n4gwc7A4kPjqQ7scHsolNstg1aX24MmwWq15tFfqJqcLN6x34WNz4fbsL91tXyI5KRUEDy94/QHO9ndhALTlCAi+0PVVF7FyibkMB8fuIG7RIDgJDex6mvrgzFttWUlM15JfGENunjIaSYAb1nMLKotMMCLOTUa2jqjIe34B4dOYC7th4rdwYigVaxDv3iOwhLcQEpeTSSy/ltuFtKNu7nHCNh0stYpnT0ykpLObixKH4nHJwTXUxR41WtG4Nbft1xJXVgC2njoovFstiV3AA4z74AGN8HD5dulAx50vsubnUrVhNc4byJ3UUrafuF3XNBoy7mIatO/Hp0gN97BU0H6ukQ5sO7HU24zL749QbpLeoUKn3M0Qy/SU1PnYdrZMKc/EG6Np7NrldVCCXs9aG296APWczoU94omvPwIEDyqO5qqpKFr6i4D1x4gSdSaENqrA85O7All9WUVkprN0S2LXXSteuPajUmLmJN9EV7ccc5gkWmHenogD0u1kWsicqj/O0JwFRCqsK96vzUAi4ZsxrSRAUcdU3drlRngOfHPxE+i8/s+0ZHG4HMX4xMt1L0B28nF5B37jQ/U2o4Zk+h/SFs0jJ2YGvcJwo2Au371A/89wDq346gfV0rbTs8o/JRNvsKTcK9ylqULqKsXXF9eG+7c/Iwj3Q4c/z+XcQdWUH6VhA/ytw7vkUXcV+SW8Kj/4RffAkCO5FfZc3cRwoY3SbWWitGploGWr4iGhToaQbWdpcgfVkKI3OiwgYmUj9hnyZmuVF8/FKKQ4Tll5/FpZMdT/PyN1FUW0t7VIgQtf6OyOcuax870Um3v9MCz9aukaIzW9wItQVQ+5WyN0OSYMu+DfK83JY/fkH1FdW0FxXh0tsFgQtKSSU2R98id5olO+nn9YPa1MT6evU/aYw2cKB+BoGZutIPe5DWn4AHQr17NiqeOdC6xEcHUvxhu7ckPQJy8qeJqcuh1nLZ8mi15uu+GeRXlTLZ5sUTeLVyR1I/+Apfo2bQr4+gGmf7EQfPpwov83EVzjkeeHTuTMR99yDvycFTRS2czafZsVRdQ9+dGIHWdze/P1eVqW3UruEJ7w3UfOv4GSjhQ3Owbg0LoYE+PHUynLWh2hJ7x7MY72TCR1iknx408Z8RgcOZ039RjnpSA1qR7v1zeQH1xMZlYDf5gJ57+11z630bteXbgcyOYwBrdPJJVvXsbtTF67oqSadXoTWVlPbYOSg+S84gfyH4e+C9/8HKKuzyGjUNhHKBF8ECuzJqZZK8s2ZFfgFFFITclAmgAmlsxd2i4WFrz6DX1AIGcYxVKQfwDk8jaFh+9BoTCTFT4XcCl5bkYVRf5o6i4PugXbcDjt6jROn2UaTGB9HRkq6w71VbbjZ2JMxOrVYHqyycKBqHYEdevOHsw2dOcDc0xruPLKQMfn7CPz5K/yjbAwMhy5BxQRobdJ5obh5KjtLV3FJ4gBCjNtgwxuUliQSK8Z82nD0laPQR11NTHhPvtr0NBP3uKgaVox/yRgMjVHY/UoJiNzGoICJfHr0DeI9N/yTfjehLwoRTAlOdE9lfJ26iQWMiEfrZ5QG66IwER9eSAuuzuFYLBby81VU8mNry/k+1Y5x4LW4tq5Fry0BC9hDuvDjyUdpdvrLr08WxJLWPwqfkBM01tjpOiSZHuOSOLShAGt5M3qb6qiUD3iVuH2zMDbl4J95GxW2l0VshFx4q/YUYN7xJmasWP3iMMQPo/l75YEcdnVHqYQXj5tTWcOcvBCm6wvw1ViZblIcyZ6JPQkftZl73/uAhx2fk6QtI37DNUoQI8aCV/4Imasgd4ca8/52n/q69BhEeVJ/HFbV4dnzJXgKACl500KutSf2S74jZOc2XBUV2LU9qM1zEOA2YDU4OKo301F08x1wZN4J7LujGRpxOT4OHyLsgWhtQTRbbARFmEkbdZCq9bvwsSgxWOMfK6gZMJDm9oNY9+kumt1KaBdv1ZBjFiW+g1hDEcndehISo8MSuMhTYJsx+FYT2lYlsNUXm4nrX4Lex8WQtjuwNWXg79+fhlqYe/1lvLshh6iYKziSPZ8mS5MQX0sK0H0b7uPj/h+zdu1aWQz99ttv9OvXTxa7DreWNbZUyf4YZcimqqaK+dXLGWvrxmmj6r53cSYS3CeeyqNicQ9CF9WZoEmd5ShTJCUJnNpfToauG23IpX79KbRB4biaq2ja+rMqxFwu6lerjaBfnzRcGn8ZAxyUNJCoHT9REhODJToRTX4mLpMPvjFtKM88RURSCk0H1AJsy96IqdNw3M1i62GXSVf2ol3Yc7ZLamvghAkynvn13a9zX+/7GBIxhKwsJXbR6rTk5CgBjqBuJI68Fff2Xbiaa9ns7kdVZaUshhOio8jMyeXIEcWTzqANnchSVmZNVXByBZxaD52mkOdspEtDDal2O26DL5pB99C45Qh+pzfgzliOpvwkRLS6CHipFiKRTHCtSxpLWtIFxcZEBJ+EmEKotlZLH3Hh+nAhbKg6yj0UMKrPZN4/shHKT6jn5RHtWE/V0HxYFYJ1K3PQ+X7FmUSM5t9ew6dYqeXf1zWws2QnPi4TL+TfQftePeR9Qv3nInSVHqtA0Qoo/0N57HaaQsDoRJoOlcli16zdQKjhHcnnd7n92FPZj1CfKzA7faTnrfDCNSYGYDlWhdZXT+OBMhylTZR9clD6bEu73tGJGBP+8XhfUGS8Hd6CmgycYe2xGXMx2qpwGwNw6nzQN5fjzFjNvCdrGXj5TNqmxqPZ8Yn6BUL0J+4H+75V94Br1XTsXOxa9Iukwxm1DkZG5ODv45Lx1Fa7mEJdT8ToW6GN4p4fWbcSW3MToXEJXNp2IAesP7MjpYwiH19GHonB5XDIMCIhNhMeu4I69PYaRQF6+6qP+DH3MUmNEL7xy6Yuk1NLkWxmLy2Tm8h/hi82q9CNS7rHMklTga2qmCs0C1mWOJAK2mOrGEOoPZjgGd2Jum80uqCAs7j5V3y+QwpjBab1jOOGQclSXPzS1C4ykKZthD8D2oQxsO2/tno8F41OJzen59DscjE0xJ+PT7uwNTi5OsSXyEHtW2gtPmkh8uP26nvY/McOEgIS+HL8V2wr+pqTmzZChthIatjZqZKjFXP5pPtg3A1fY9J0pvvxNfQ9lIlPdHvGDvuYRdkb2J63m5nrM9GXJfJ5+0vOzfj5G2fgb9Ha/2M4nC6mfbJdkue/2ppNemGtLHYFfjtcTFVjA5VmNf7zsfYmzCesRUm+948lFJ44JlNqjPv3EaErIiZViRmaAkZyy/DumPRajhXXyZ2tiMO93mP8HuHTSGiz4ice9cvkoKuZXRp40XEtVrfaB5Wb2ypRh7sdmxpDpN1TRG0dY/L3E5TSLItdl0NYpWkIMKgOX439VjLrj1FuK2JXhbJk0hWvI9atzLDrLL1oO+09Rk0aIUecEZ8t44a1LiZ9cZBjYU7MeWrsVnT6G9wfHiI1fBb4Ku6qaWE5uh0npWo7OU6ZsjckHSZwfCIBQ+OIurenFOn4tA+RFIrQq9rj11s5MGRkncLlclHnMlHrMvHt9hz6DhvLMY1K3bG52lJY+iQ+BEhbMXFhZP9+mi0/HCDfuIXqiD10GB6Jyaxn/Owu9EhVXpKVDhfHcwPQ3PA7Ll0oRm0O4abnMXdVQrjjy7+kj1OZgxumfkjToQrcdhf6SDPG5EDpsyuU9Lde35O3ruxNhz5DZO68d7wuOnWleaeYcfVN3O+8Bwc6dOUeJXiPGWDyhy6XwkVvQe/rodNk9bPtH7SeZMK4XtAeRLEblAjxfcEcSo3/AFbWPELW0TqCb70cV/QQXE0aAuoMOHBS2tGfguImijz8Z1FMCDF//+AehJrsWH1LqA/KIGZwADGTDlDvfouw8u3ysVaDWmhKnn6G2ivG0GfDk0QUreF7fwvtHToiHRp66YrQ6W10uySUqO6rcWvK8DHFMnjwBgzakTQ2BnP6VG/cDq0sdpsa/dAZk7A7qmjfQXXdty5fSEr+KmJP1tK/vD8jS0cyd+RcGTogOoef/tIqlBFF4Nz5quua3LEbpe5ASl2BJFt7Eu4KwKKx85tpn4zhNml9GT19PLbTx6j59XP1/sV1I/zOu1uKXZvFwZb5JymO7IfGP0bIv9VrP74MU8c02vzxO36DFbddwG/gAPz6qPPRUeVPt/Rj6BwOGUjRHN+O5qQOlJp9Wbh5M8cXrcJZbcPtsOGq3cXptHByekUR+/xg3E1rsGdtkBuZgLFj0QUESN6sEIA9tvkx5m2Yp7qdxipOJp5Eq9USEBDADTfcQP8hI9DMXof29q10HnwR4b4+GE4coGTFQnqlJJKamsro0aM5IFrJouAShdLhn9ULEM4Gu7+QlJGrqtTirel+FW6fIGp3G2h2DkAjltsd58fhCgjqwoN9HpSfBxmDGJXZg9pVqhjvGNbxPOFaQX0B7+x9R/JsBRZlqmJtfcUB8nt4xtPbFYVKvN66NXnU6OopaFeLNliHj1NtmGxxM/kuwJ9DFaskx3aHj4mvqSXQ4ctLJXczcMp4yc9uwaGfVBs9cRCaIZ7uudhI5mzFEOYjO3Q+2u2EGgVv2o01cAwlVjGifxBzrfIyD/Ck1wm/a7HpDpqYIm27dKE+MuDBcrwKy4kqyr47IovDfwThoCJihJsdDVRaCxl94+0YB90qKRmayR+g76EaIGlBNVKwvPTNF8n58g71XiUOlP6skg4idkan1kHGyvP/RkMDWXvVVG/mxW3pEVpMO99S2viW0zGonIjCP3DPuwIaKyjOzGDnol/kY/tcPI2JI2cTV65oY26NkynmixgbO4uu1jAG2XSy4zxniypSBV5YmsvL/T+jbVBbKVz0+smXvPgSp8aMofYPxbeV15Hj7IAdISz7/XBxiw+5iACOrm3Ez9nMxNJVmMJUbHFJk/Atn3RWsSvw/rpMWewObhfGinuH8u6VPVqcdK4ZkMRHM3tx/9i0f6vYFXgms5CMRguRRj0fREVh26s2rMEXpVyQwy2626suXcUPE3/gxR0v8pbzp5aflXcwkdvOKcWUV/1xFSVVW2nTtJBJ4yYS/fYbvDZ7HhdHx/L1wKuZP+omxj/xMV+nXSQ3c44Ylfz4N87H3wXv/2NsO1VJYU2zHIe9sOI4t/2iuqsC4uLUB2Wg8ynFRSDFZROksvxwXg03PfoHWxe2jq0dzZuxDqxgJEqQsYkxUsl/58h2LTviRTPakrdGLRoRAVYCGlSHdL9fBi9rHZidTURWFXCr/UEes8+m6dLX6P/ga+y3haLXG9gUNpy7Di/AFGwntI8yJC87Gkj+mjByMdPguEgKNSwFu2WhnF5bQlGzSIHzweU243BF43JdSva69fL/7vnxXfqcCGZ3n8c5GjKNY1vySD85EK3DF5t/EfWJ+9FHdcEw7nkau07APqwdTdcmoR1zJ7GueKz6BkpSvqCkZKn8ffowsywew2/oQvisTnJh8i6GP6xS8ZylInFN2FkdLuLA6VIWNMxilWscJ+1PoHcFMCxAz6Rkf8YFGejqdBF3rE70G3FrHRw9od6bpC5hJIjRpyjMbW7Jh3WGtMN97TJc+mCMmpOEOl7AGLSJzp5Cvyr5YkgaQcMOdcP26yfcIFpvgsG+Rqb2jOPGS4bzzNNP8fjjjzN0qBIL/v7773QKN/Dhw7fiGqk8liX6tlp+yfPF2UxNZ1VguQ//Qt3Jn3EfXQx7v1bEhCmfwL0HpeqbR7OxX/ErDrcP2Qcr2LkiB9O0djT6C/dKF7tDc9lzKFt6akYMVV2XYIMDW9xJsmv343DZlQZZA5tzVuFqeFvSVZwhbtwaN6e7X0OF4NaegY6Zywiqz2WTj53rms0M8lfH8ODBFeTkfCE/T019kiZHEIv2DmX/vkuoyO+Kf6xSUAes86Gz7Wb5ua9vLgZdE4aDhwiuqqKmRk0BxHPI2JXBB6M+oL29PeHN4Tg1TnKDlFhP49Cg0WuYOXmc9NgU25LR+DHB1hOHtjVmOGngcJzHNpB/yy24Kk6B2yZSJWg+VtFyTqX/mkmS1cHAiEj8xzyP1hSAq6EUnX8NSd99hyklhbh338GnWzc5WjV3745v9wjJJ3eUNRPfZRwDdno8QwOCcev0GJ1Ome625OAOqjQNOCvS0d31FIc3lXBofQGZB6uJf+899NHKiq9syBC+//578nJUpLOgChw+omyQ8vzzOMQhrrjpCu6++25CI6NVpHJoCo7AFPKWL8K6bys0Ky74qVVLGdm3lzzvygO7UYc/GrtHvR7lsZTaPQfXjrmMs6nFvLj9LJxVFknNqXdcqh5z6GflDCD8c4WDg9VDfRDcxKTxvDX8Ld4OfB7Xjmo58hdBGELdLnCmcE1Ym32T/o3sXAu/3q2FqoAVmB8QoAId8rZDwT6smTWUFxRxT8pr3Gx4nIfTXmODnxUrRvSFP3FNfQMDLFYsGg0vhIfS1m7nuwIdwy4aJzfJLSg+DLvUBoee18CIx9VrF5vFby+CTwYSUnETYaY30IiTrcfV6G/8EQIjsTibKGvOw2dUFEbRwT0H1Q0lZIQc5EDdevZUrKTBXg0NTkp/8bi3eJB9YK8sLAUa9qj7RW7jMdr1GyjtJYXLC4/lQ5fpqqAVzlQRFvpNniYnd9E1nuM08C4lYA1NgQEegZVwbWhspUMInNi2SabnRSUmEFrk4X4OuIP/j73/Do+rPLe/8c+e3ke992JVN9ly7x0b03snQAiBEEpISEInCRB6CIQeejPNGNx777JlS5bVe5dG0/vMe+29XSDh/L7nnPf7O+8fh3VdAlllNLNn72ev577XvVZoyTPsshUz7NcjhHysef1Bfvb3dfQENViSkimYNIWu7g6mHE9h4okY7lyjJG7RGOK0qRQlziGycxcH6ns53D4iaWVLUy2SS8pdH9exIOUm6c+I2m1vfy8jX8lSk/6/Pi2FO6w93kvZQ+u4+s29NA3I549YEBLviTMKEiTtv2PtWpIcbsJChBiPmkT1PhRCkL6glgOn7BtPo7pzROqYihLBJy4cQ0nq/wvnjB9Bly/ARz3yxuyV0my027ultUhMx9Tm/DBo4/sQbfo+q/+Mje0bpdTClnEK1JPzefSBD7l9nCxtarG3SLMS4nUjBqmIKXni5vE0xIjoD3aPEBIUlNtaUOSfdR36CT/ET5KG/4+x8kiX9P9RyWaOZ2porxqWdmmlqWZqe5yEXTlEIhocKb8kZM3iuY0NJPc5mDr5AwSHh9CxJEJDduJK2xiTImeRr+FcVrhyeSQU5s75hdw8Mxd8bj59+D5CoQhZRhtDpsVcMzKGp6z7qTY0MkKQCc4TJIRGGDXnVr7e3ELK6jYSrHqm+zdxyZFNFLr85EwYwpQiV3P7fEaq+1PJtDkJnLgIZe55BAdrKGluIpoeT1tCDJ+1qZmU8BjNQ/uwh4eoCGxBddhG1cpPMRytojH/BlymDOlDPBntgQDRkXJI2E9/1juobRno/OmwfIShDPlmGM7YgK6qhMi0PsIaFwMD60lNleMpfwwf7muTdWwCXL1wEq4DNrKPfsHOR14h3nQJtb5rqDK3MkkZpiCcCt1utIJManSCirnBMtaoq9i3bx9TpkxBE1BKU/ji49l0SgKOIJ11NrLLR8MNX8K7yxFatpLEVulnXFEzbtfN+F85QrjPIw2vBHLVdHZ2kpEh+53+K8Qkr8zMTGnKvre3l5UrV3LNNdcgzLwLwl7Qx0iG+d9HTe090rEYb1UTZw9i+ehWIoI4Rw2hqbeiGv9D2yrR5i2/IlFqyx/Z2MG+HUdwWGtQaZWEXFHQR4g3FFB83hwaTnawyr8fd9gvafkmDA4Tt3c365YsJoYQTmcS1ph+3AsiWGwLic8uYGXsKLIcA2yxmFlU+ylzuo7wp+Of8UbWLNy+YWZNn8G6hnYi4dcx7ArjIpGq2CL+9N0GZgfbpGOXlXQSpSaCb0hD1nonQ5ufxPi3HNyRVmb0b+WofjIjcXGStq0wN5f6jg5qamqIjY2lYrCCAAFmTJ8h2Yk9/dLThB1h7Cl2DAYDy8emcrzLgxaBVhSs8BQwSd2BLaTjmrdepO+IvMERfTaNMzJx7+pjZGWTdAMbXFFPYr2NRJ1c3RKHsiJ9NVI1NuutN6SqqwilxULOp5+c2dwIGlHakIJ7bw+KmDkkploYG2vhmL2DiooK5k+bxj+ffJJ+g4FvFAeZPiUfe4Oo95SJ5+4vGsl9dAq5Kz5juK6ON3fsIBAIUEEF8ZZ4orosdjjKKVP2os/QgxN29B/mq6NRqauRYtXx5W3TqPrkLYa7OyWNpuh7WrNtEyd3b+fbF//KlY89TXZuHkeOljKL/WBKhuu/gTfnw3Az55yUN5ivhZah7LVypVPuGgWiJVK6m5Za2PePU2fZiyBqchc+KpEu8TjMDk9mcOdZkidWeYvPLf5BhXfQO8iuLtmDem3rWpIMSRKZF2/0on78q44N3F5+Ibrqz4hsfYHhgTt5Nu1dBtRyd6za2cI9SQms7egmLXy2yesgnvt6LmZq+C309BI9eCOErwFzqqzx3fIX2Q4wYRSUXQAqDVzzOWx9Uq78Dpw4O9RadhEs/xtKpYq0P0zh4wfvo7v9BPOiVhK+FwzhGOxn09uv0nxI3nSLMMTq8Xp7mKm6gfAJF7b9bcROyubwmlVseUcm3BMWnU9eQ6GUHtkVaOSCax+Wf1k8lzSnSE3mFNDHSsmHUyoLUR1XoVeGcAsxhOJmc4ZqzXsQGjfJThxf3Cy/NnOa5FRxfKusx51ebkZo6ZePxcLHUIkhIO169m74G0vTT1IxsppG/RLq0nMpd9YQ/cO9hLwezF4Vy2uMTHvkcQzjx+E5vB9lfAFEtbz2bdUZ+cCV02K4+rWj1Pe5eOZrBeaEy+hL+Ixvv36a8qBskRjq66P77X/ymKOIUCQqDZCe88IOMmL1dJyyDrt1dh4jX35FxOGgLxbaU7zk9hgp7VSRWhrhQD28s6tVkiacxstbZInP+WPTyIr/v08IP+sdlqQEU2OM1Fa9R1ZVOQoU7B9Vz+JIMSrFj1Mt8Tx/7aj8fj827TEuLLzwzPfEkBYxwEe8Ju6ecLfkcvNjONHjYNVR2dv7d5lBdn7xPt/z7PkJ38NPhPf/Q9h8QdbWyHq2uQtyqDnUjhCOEjGqOJGuQRiyEw1YUQduRqEtI6qDkw1OJpdsoiTxkBiWRDhbrD5FUarlRf1o/3g2Jf0MfzTKVpuTKQEnez7/mMYDe6RdvEnlZ1GqjXZfJSrVW/z5ZAVrNbmkZBhoF2Zxwu/jpno3l2KShpsYDPCn4BT8tj2kVfRKZFesRjeYyrh/ZDkjs7r4+9ebiE2Sc7wHTZ0MZ2op7RiiIVWDJmhgz4Cc9ibeKfaqO5hg6yWx3YtHn0h/ouwmYLFtBkUOiQNVpOyoov8hCCeEqS99Cq1ejcLgFHtmRCMC7sRq1hY/jm9/EYWT9YzYxYjiCIJoUP8vaBty8/bqvcxSBBBUaqaXZNO44m2CXlnPG/YfpjJOjSvRzjq7kyplC4sjHrI5wrrgdCYwSbKmmq8ex15vHXv37qVSLRNNcXo93aLDtr2L5qp+qfJLxgQCF79DcMVNjIT1tEcziAlci7lTRRgPIU2U9jIXW996VZJYFBcXs2TJEmJizgZJiHrjFStW0NTURFFREYODg9LnBw4ckDSozDuV4PQ9uFwnJbIrHuT+actRVx3A1NuBIhplxKKiSvUlBZ1lZGbIXqzS2yEILL6lnLbjQ2z75jADgRPSeyTKGU7f1d2aLslw/oChBXfAjzViYJ6/nBhvH27HWrLcjbSZR9HYOJnSot3ktVyCJWYqFjtca/ExtHQfRv2lHC7/BbM/eBjzQC/3DMmdCf+ft1F8SQbp3zow7lQRg53D++9lTmEecaYkwhEfcbmyHMS7w4xgdhG1B1B82YFnkYXjibPxR4xoAgFm7NiBpv8b/FMX09pqYOdOucolbiimTpiBs9vHRZdfxO+++h29ml7JHunyiVnkrumQtJSR8nguMcbz2UENf+zZTPBIFQqTiaR77yHmsssgIuBvcEiV2d5nDxH1hQhHo9h0KjIXZPHlx/UYvAoWPfUUqrizHpmnj/P3EbM8X9p4+g/2kZBegbs1wvKlcxg9JwuPPcCEtPM4MnSQHuUI23rr0XptWBWlWBL96NI/ZNfWt5mx4Dl29PdLZFelUxHyhciyZ/PdQAkjUQO7Q7lcbYqnqjvCU1/oCYXktnLbkIefv7GNKXvXSu29c26/R6oapo0qoa+5gZHeHt6+61ZSps9lFxNJMKkpvfwRMMTJFcPv5BCFFaFZPBG6ikk1fVycfEr7KnYygvcQV3gIbZZets4Tdb8jbZKsxrHHiTs4l4gzIB1zUecqtuzFYdP8IXnYT9TwBsNBKVAkHA2f2UyIbg+nXR1WnFxBt7ub31sjtKelEPXsx6L5C4dMjWgVWl6acB/7Nt5Pq0ogLRzGJQ7MTbmau5MWE/zKzCivCrciFp32CSlOGPHj+yhYINuYaU5Vac0psPwF2RqtZRtoLWBJh6SSH1gAFlROobv+hBR521lzjFAoSDTio6P2BCF/UIp6z584mfK58+l0/RqPY5iG9aMYpZ/OyOcNHD+ymf2bz2psbXtaUSQUYw8Nsuj+u7Am/TBZcajLxf5VLYwVJpPGWpzv30GpUq5s7u9N4Pgf15NRkkHFoiyyR6fCRa/DG/Pk4ULxQ7yuii+jr7lbem5ZnlPHofImMZpT+lT0w3186yEmRvtIFka4RtjEP1nMMctodDY/UxwHpPSz8/7yvDTYJq2LWWYC7U56c6azqV98DwXyGrayqq4aIeMEqsHFkve2c7ACveEAK5ybJQGNeeECnBs28s+NdXQXZZNq1VGUYmbryQHJF1dEYqyLI45PsK9aQT7w5hIFg2anRHjzuo0cnyRe9/NZX9srSSAyYg0c77JLA2niW/XLueJv/d+FWBj5tFeu7i6LU6FfE5TI7h7TUR5reg13YkgaNv9XiOf184eexxPyMDphNOcXyBHGpyFWda8avJeqk8eZWiIHX3TWDUudntGz08kqkwn986f00eM0OiKpM1n09Yc/Ed7/AEL0P+ME/RP+W3A4HFitVux2OxbLD1so/f4gc/aeYNgbJKXVQ6QshpEtXSg8YYIlVhRJraQf3E6v+3yM0QDzwnXsGV9MyBzDY8Y7MQoe3G4DRqO863W79IxUm+muy+HoorvYkqnl+oFm0r/9SMojF5Fo8LM4qQaN6gYGw00U6mQ91xH3cnY5b5AULlkagfEGFWpFLUrVG8TQz2DwSfzeIOkxv0ZFlDcnXcHNS19j2XsP0B5dyUNrc5ia/VuiQR/x16birD7A8F/+SlChYE9hOi6dhgSHC5tJIKwwIiYZ56l0nLCOwRydQVBXx5aUV3j8/TDqU7KtngvCRBed1XAFPUoa6magMIQoLpYrP8eqFzAykkpKaj2XX/YAsbGlPxhQ2NEwIO18c0aqyFTamTRpMo59W+mqqyEsaFFGRXcEgZ/lHUaR4ONIWhqHemYScpioVJ3gqGoi8e4k5gbPtuZDQpBANIJfCBFN9+NIMnN0s7joeVl+ewbJo4r48MMPzwzIiSiKyaGiPwNX1Ms2RSNOhYeo8my6j0qlYsKECVKFb7ivi8ZN71JltxAR9bpKJXPnzpUGr8Sfu/XWW0lMTPy3c6229j56er8kMXEJY0a/LD/XgVpc1a/QrO/A5juOQqFl6pSN6HSytlqEWGXevn079ad8ZU9DJNais4F47k6cOJGDBw9KHPiiQBkxwTgEpYbWhHdxlu/h0MHzCIW0CKIdUDiTCeFs0LhR++MIqR0MzH2fitn/xF9dR+9DD+MxmGnsGKRoWG7D+7RaThYVYXK7KBbyiRYv4RPjQalVWZjSjjV+L8pPjGhvGibr7RIGbT1snj+PQMCISa1mqqqD+E+qiYSG6XhQyaHGCwmHtUwqLian5iSKOgFNTI6og6BTN0KVtZ3Z4xaQJaTj3NwhRXX+IUXgw1/PwFF1lG4xwCESIe2ll2gIFkha3Snn50nDZgP/EMMIJHtd9rlDTP7FGGmjs/rVahoPHCR/XCoLbpqF1vDvLe3vY+tHJ/Hs7WG0XgwxERgIRjjqDaMWBGaYFCgEgS2B/TSb3eIqzZgcI7HZHxGJOgiHlbiclVRXyxPukUkRdrXvItdzIRv7ZW9SEWqlQPBUdXNUko4pCR/xSd25BCIaKm0HuX16OnOuOyuLESu+6179G90na4moNbgLxkj63/vvvx+NSGaCXmzvXsGaVgUPhq8lHNVKJOK7hEQsA350JXGSNlWVbCDl7lPVqGiU6PoHEfa8JFl8DQYfxh+pkIa2Em8bi3Nrh/QeKOO1XJx2F86QU2rdvnr0VWmwSbQdXB9zlpCuv3g937V8x4uHX/zR4/rQ5D9y6bZXoOcoUWsGgr2T3sJ5JFy5QqqyOTa1S8Ot2nwrCReZEI5/AXWrIBQAawbkzoKpt4vTfvxXIUbhipuFH0NCbiLn3vGolCjW2/sNNbV3o9EkgicTy/oLiFdlYQ8MsrH7fcoWzCevohLXR23EqVJQTrGSesG/T96vfKFK6iwlq+u5IO5BVILceQtElLzWMIlARJwDEN//KPGZuVQuP59R5n7U9d8iDl9E69dJmuu9g5lY0nIpDYhhPlq4pxaM8ibG5g4w79mtXO3/jN+oVzAUMPDuyExetVxFEBU3RvZz+503/yAy2Lm9E/vqFv4QsrFdpWSsysnLIVkW1R84ye8L32HAcwnDA4Vo43agSf6OZLtAbFYhMz/v5bXku3Gr9Txz6VgurkinptvBt43ree/EWyi0fQiKEEIkyk3rI7y5WH6fLt5eiNkdkEIvhOSn2NdipyDJxLOXjpESHLtGfCwdncIrV/94lfT/DfaMuLiwqhGTUsF9qgMs+SZfXLlZMXMXbw9+SHl8OR+fe1afK2rS/7T3T1IEsjMgb1A+WPoBYxLGcODbFnweeb1prhpg07tyV1O8zsSo+tpdPUQjsq/zrCtGoSw0c86LO6S1+UaHlviIgrnTHZRdd+GP8o7/7fipwvs/ALES9E5dD09/cZzRObF8eEUFvznZwbA4AaRV0ltkRtnmQO0Jo1T5CCt0jK5ZxawaDx+lO3CoLYzYnVz5zVvETbdjLPfgtJto+jQDVUqYtXMu4phhLHe0vIg66KBk93r0iX6S6o9IRdrMFCOz0npJ8R4hHI3hgD+HSdrTLUcYZ1yF2VzLSHQZ2f4AJuVedEp5SlmERXiNgLFSIrs+RQFX5DxO80gz3cgDBoMl5VLHNeRvZ4vZT+aUAtRKJepwmHHt3XwxTcnHC8IEVQJzDwlkDhjoNMVhYIr0+z3lq2lWC7z86zgy9AG+CnjRawRuHtSSn1ZIuzue2kMCmmgaAU8AzUAqeYk9JCU2MDKSQm/PKN54+wsuv8QoyQBe2NTI3zbJk/Ymwc8s3RBjxq5Hr/qClr5klGoLesPF+NzbiER62FFYiSnrGFGFh/L4TVRVLWWbd4IoiMSv7sbCBtzKc3H7Mzmq7KBG2SFpW/WNIyj2tKK33IyAgW1ffIM3LelM/KyIqePnkGLKp6l+mM76YbTesWiFKHmTrYxdkM66DWtpa2uT5BLixwJ2sJyDFCmL+U59LXbvoER08/PzpSrvF198wU033SQR4TVr1tDV1YXRqMHnayMp2UJ21i1nL+7EUmLm/53x0SiHq65mZGQfTc3PkptzB3sP/woiWg7tz8XtkrWrarWaYDDImDFjWLp0qbRZ27Bhg0R2RSQmNTFs+QDd58vQF19ChuN8moU9TLOvo9m/kM44PcdVHTQb6iku3E9p/c3onFno6grZ7F2IilxcP48hPt5NfNCN59UIHe5ijpeXETpVHcr1T6VfsEtkV0RrXxYpjc3Ezvah0UHbjW4OHziXQEAgJmJkmbMCPbMIzZqFd93jJL8XZVb2SnSdOqxb6tCOvQpFztlFPzuSQLatALZEcCJvSvYJYXb3eth6rJOshx6QyK5h0VI2VsXQ23xq4CYK0y4uwLo0D/uuLvZ2unFqlGSUyAOVBmsrLt1eag7YqNv5MqOmzGDJbXeh1slDTCIa9u9moK2V4unnUruzW7pxjTk/j8jmdhJRsECtkNYKpSDQ7WlisG8butxifDoj3a5azGEntdVzsDnORq0WF5v50LeJPt0AXrtYvYqwJLGTnmgWRwflY6iO286i1EbGJx9Bq3TyxrHrORg7gdDkFL5p+oblecvlZLu0DK549CkOr17JlvfeRBkR9dzypigvLw/Ueh403823ITem2DpyDZM51mVn24CT5WiwLs2VKraiE0Gwz4062Sjdqb0pv4JwNQblNhIMTxE693NUo8cjKAXMszKk+OLwkJ85qgpWxW2TBu9E+YI6ouKWvosZUNmoMtVRkVRBqimVS0ddyv7ufUTavCwYjpKo2MSx+EwSp93FJd1NEtlFF4MQkKuCKZPvkIa8RJjnZqJOMaDNtSIY1DD7PvnjvwmPpwWdTowR1xCbms7yu+9nsKMdpTZIZ8/bhIIu1IYQMbkt6GJlQtrRKYdBpKdfTXbWTeyOLMO0/R6smgSWjLqFrHlT8OztRaNKkaZsEuf+e5iNaPMnkl2RCOUuW0K1p4I8YRO6zu/YcdxHICK+3rMFg6GOZta+8jzrFUrSS8oonj4bRUeEcu96piR0QODUBn3cVWfIrogXNtZj8wTZn3g+IddK4jUe7klax3Wa4yx2PMCXphls+rgJl+8kz1w2lrlFSRgnpbBzayvbPUqpw3SvL15iGtFImCRNEa/W/5YLs8VhtULUg6UISd/Sa1bR0ZzMwZyLiYb0ZHh7md2Yx0hHE8lWga86n0Gp9zCqM4I6oqAmS+DNJac2JUELh3UVzHbvZVSbkaSF/dT3mWjsd3HRP0RXBtm71uuzSxrg01af/78gSnxO7NxK8bRZlMycg1L1H3snf9wj2+otT7QSWt+DklG4UkJcN+8W3lvxqZRKKHYuTluwPbnvyTPR66IF382jb2Zs4liOburgwHfyEGfXSRuuYblQFZtiwNbroWaHLFsQk0dH+jxs++gke2Pka7wgoCA+Knc4j/f9e0HkJ8j4ifD+D2D5tkN0HAtgdno4cMzLxM5WnDkxqDvF/nGE4Lg4lE3yTk8Vt4lLD+hI6HNJKTbjHIfYHj+XQzETGSOcIL1IJlMDe8QWuIIuzaXk1Rfyxnn59C28hK1fvY3Rto9T6Y5Miu9gekwrCq9YbBFoD12LQfVPFEKE5uAMrEvPIXbDA+RHRG/Dv4leURLEqNsmRz755mYMmiMIyATS61+I+72TNCS0YozVUZRRyphWWZbwct5u1u3cL1VS3n34V6SNKGisMLKm5okzWfMnRvkkwut19KKzRtDFt7Ff3wIhBZpaLYnmJCxF9QyFlTwnuls1NZDksTMzKg9wHUg8gDFW9BLtIT3DhrOzisFQKR6njn/+858EVQa2e1O4pHAnybE5qB055MSux2weEmcIGHVRK+76Cjy+GozWFtRpXWj1PqkOohL0oPJSVr6Z2trZDEeTuOHc5Vi+/Yj61Co2dl6Mz392sMkXZ2TsvHZcdQcYaZ5NjycZb0+3RI5UQTPpqnE0ronQeOrYnfbyFRM/m/c6GGoKkjvKyEBnoxSXGzEYGS16pAoQdGaicZRi0ndLTg1XX301r776qqTn/e677yQXB1HicBaldHSUMjx0lAsuyJXIqqgPe+vYW1xZfCWFBfdz4OCF9PZ+TU/veoRTmtBx46pxu2bi8cyivr4Vs8nE2Dx5wnzcuDI2iH6bEZG3RMjKriakj9K2fCN5nTPQeFNIaricvoVRztm9gPbAAJtVVXgCeqpqZ6DJ+ZbyE7/E2DOFHkM1ba0ZhNGiVrkpKumlffJMHCOyhln0OxUrgLXKDoY0vdLfFI+juGEb8I/GeaiB0oIIx+rKcCNgiqo5JzAehWGIiDcBlT4TRUw22sY2tI0hBKMB3bybEJRqXKERasN1JHTZSBnpQ2XJwJ+QilGjJtTbglZMrlOXsv/Rp0lpbAJrHFui83E1DRDyrCYS9nJ4/aWk5FnJm5nO4U4Xg60uiisTUCoVkgRlX/1hAolpBGOTMDQfp37vThwDfVz4u4cxWGOkSfjVLz1LKOCn4WAf0chYqTKcPi+TYyPHCe91kKBKQ4nASKBfkgGpzWFyJ23haPW5DA5m4t+7GGdIvpmplH6ssb1orHtp7VcRcoyj2xbBoHKzrPwlButiMEcuw5XSSFP8Fg6HI5SJDhsph9nWOZ16WwH3rHufqHWzFCM7J3OO9LhiyMz2hCY+WdDBtJ5U4iLpkq2ZSHjFgbetJ2TLpOJsJ3OSkmXCS4gL4i2oEw3oCmMl9wH3/l5JuhHxBBlZ1UIkeBeaOB8q+z7UG66H7A0Qm4NCp5IrvZva+fnRSxhSjbDbclR6LlOdY7FaYrmt7zLe4AtumyBXT61aK89oHsTR3IbK5CE5spb5HfXg8sKOU2lYomPJrheIGhMJZY6RrAyldS0awJFwAMGtQBtMxGwejUIcfhPlYB1DqMQ2hb4PT9BzJiY5Egnh83Wh12edkaeIEqqGxifo6HibmJhJlGj+hjrJKG10CiYF2bd/GTGmTkymEtTqWGy23Rw7fgdJSUtxOKoQBDXp6VeiVBpIG3UevZ6XyDx0P8aAiaHXZUtCMZYy9qJCVNZ/9yU+ulHujuRXJDFhiRg6koOtJ53XfntQOsdOQ1AoUKhKCAfEDk6QSCRMR0219CHClZTN5Lg2nMZ8KL0Qy5JTYQ2iq0m/iw/2yX/n53NL+fRvoxkT00lJjIuEQBe3GnfyF/cyRjxyt+pXH1Xx5S+nUZBo4hVDWCqCLBc0UjfP52oiYXE2jo3DqPVx3NQbx7OEcCniefH1WH63+Fz8XrmTJqgcaLLXYT+Sgy6q4au4TXiSPcQ7BB7+KIIyEuG5CxTsL5YJnm9wPm0xowna9hHr0rDzm4+wRW5AGRU3bCLFkd+zLQ1e7vtkLc9eueTfZEan4XZ3sP2D16ndLGuP26qr2L3iI5becS8Zpf9ul9fk8bGqXx7gLhE6mNI/Tvo8dXYRVn08szJmSWEbXzd+LQWyiFXdNa1rpFS2l+e/LAXyiNZ8vc12SZ8vQgwGGu6WN2vJuRYuvLeC7Z/WU7e7h4lLc5h4Tg4H17Sy/9sWasVkPyWM1ek5/9axfPNCFe21p6MufsK/4ifC+z+AmXs2UKPIpRq5rWOz6dE5bDxqfodWVxZv7JgrRimhVnuJ0x3BOhiDgILORA9lgyepskzAqbbQWJlGhboax4CRzuhMvPNn0uY1UWLSEn3vBImRGBJi9AyOeMk1DjMtsQ2zTsu68AImRcZLQRKfWpq4P1BLKKqhJ+9e4t159Pvj0Ct2oVNWSZHrNd4JnHBXYI9mM0f1CmWGDehx40fgE0uEc2xhygZzeNhxFyVLpsCWdlnnGVMveWqKxv938xk3zriR5w89K73m87JmkOHdhCLBS19VDKISIxJo4nDmRgZF26mogvR+He6eIFf6x+BeXMRXA5skX9UpNrkS7Al0UXEEZsy8GsFWRzA4TMXUMQy4v2J4MJ2WjrFiqiRzNU3MyNqKUhnGrzei1brPEk5VFHPpIczI2lARYou4tXUckyfejs3xe/T6PiZMkKvXJ4dO0JZ2M43+/RLZ1Wg85OQcpqlhOuGIGr/fTFzpKkI+A4NB2V7IMlKG1h8vUUpRVpyQ4wTjegyJ9Uxf8Cy2tlTJzso+4GWkV4PKHSVGO0yGshurzo0nbGKP81rpsfTeFCZ3foDjgJKchDhq2z0cOXK2+p6kr8ecbsNmS8M2nCnFyX7wwQeSBdUzG5+hu6GbF4+/yG2zbkMTnUJA2CuR3RFHApGQhri4biLRE9TXiy3JKNGT+/j6wFbm3jEVR+QT0lNL6OoqJcHSSuonXkauAyHXR7/pYzKq7iamcy4xvYLkF2oOhNH1HEVTnoY7mMSxoUzyhBH20UnzqU2RyGSDISPHjy2U/iW2J/PzDmJQCVTXTaZe2SPlyIs3qQmKJA5F+/HHJYDfwcEteQSMCagVIZZ6pyEaZTRNfpzkE9di6Z2KbeqldLSvIdYIWWnzEFDjtNZzwHiIbo+OaouF9NZ0Ko58huE4nD4riqrhvrELmF0ru4dUZ1yMyw/R4NeEA/JQadhfzaZ3dRhjx0utxpD/GA273yd33J1s2n8A7ylhWFSlQiiahbbjIN3t7Xz82B+5/skXpMGg00RksHULWmsKE88Zzbp/vCBVk0ToVEYKMidS37OP3MoJpFb4cEQ+xGruxu5Mk8luNEqhNZuBY2vQF3TQItlghWBkkvQYi3O2YFB7SSsMMH7POrrdPpri4VhYwYPdei7KW0hF0nGJ8LpthRism/m47mOJ8Ip2Y/duvVcKBhA3vm2xfcQNpbPr8C5mzprNHR8dxuUTEJQOpubHMDcpBpFeHiJEq7uDxOA4TNPTzhBesZrqWN8mOTioEi0of/4ZvHcu9B2D1+fC7N/CxJtQJ8juKoaKJO5/6yaeEN5kn+k459nmEHN5AaMOm3msOgXNLiPRsqgUuiHKIKRrbdl4hBMLZT/e72TLM3JmEa1bI9GcQU0C1bumYNGMJylzER2t7+EPn+3AGI2FlJe/zns792MJ/Ym1TgVHRfNZ4N0l7zI2oZQjR25kaGQ/8QnnUVr8GNFBOycOPsCIeYf0cyMj+2mqfYW4gYUk3TGOgdBqPJ4m1Op4xo2VXVq27FyM291AS4ssxUhOWoZWI1dSRV19e/sbtEz7HUXDzxOqjUoBGPHXlKDNO6vtF918RHeZvTX9jD/qlTTY4xaclRIc2yKfY6KWNhQIoFCpJE/czNJRdDeNJuCU7eXGLV5GR80x7P29HPSU8q1tDNagHcWhfYSPfsaHrjjSdBoEs0aqiC4oSUZxYAO9XgPh6HzSDcmSJdv1wY2Yim8md0YWL25uYG/zMDe8vR+9RknToBstEW4S/xvykXTbDCxlBfSsfxUzcSz1z+UTWujSFvLy+AvxeYskqduMoJ/63GcZ0Pl5RfEJE+Iq+DgoS++u7J1PYJKD74y1GGLjwZlMMOLn6qzzuKwwlSff2cLYwUYmN/sYY/gMpddBly6duAQbuoowb1Rfw5fVkGD8mj+cfyGRiJ8jR28mFLIzKvNRwp4A3330OwaOyUWNomnT6aytxTk0wJdPPcplD/6ZlIKzw4gjwRA37a9h2bcfEBsN40xSEBO6EK8uQPpoWW8tDqGJhFdMF7y+7Hr+vFf0aEfy05+RLrskiZKpdW8cl5JSCyYkMf2SAta/WYNjyMeCG0pRqhTMvbqYWZeNQqmWSX7lslz0JVaefn0PKoXAH+6fQpxFR8HEZI7u+Cla+D/CT4T3fwjeU6XTJO2w5D063tvK1b6d0jvgCBr4lHkoYjdSWadDE1bQH+NjQoGW1Avq6Ks5yJc989jSMp+ZCYfZtmsqGwxToUkkBiKhgAIiXKh+hSuS9uGLV6FTFeII/QGbfzQ5AnijAq7RcUwZ+IdECqvdSwknZki2QEQz6WtLQOgvkbLP9xbJk6LKkJc97uUU6bdJ+rA96mT2hkKYnGFmmxSUBNIYersHUTpvC0W5rPphrnhkIj/bej3N9maeOvCU9DizM2YyT3kAdHKLLWDKJuDpwBU9yHaDvKtN92WSUzKOhNQ0Zl51A1qDgV9HHmTX7l1sbt2MEAyQ1NyLENXiWF9F/jnz6On5HHOSAnuXj9T0JhLjWzl+fL5kOxUOqyTCe5rshr0KBE1Ekub5HclEXAkY0jKprg7isCcQiWr4un0jevMkCkftQa93olL5UQX30uNppKtXJmjF6VVYU1rwuS20d42hubGS2MFxxBV/Bd2lKMIaDIISQT+MKfUYcSVr0BjFcrvcempq/gsTJnxMfLqWDx/eBEorutgbUOiU9HocHItE6FZMwB897SGpoMc1l7Idf6CT6yEkVqHlyzbJWEPRhMPS5ynJDei5hX3VKgYGBnj5lZfRuXTkkSdN6oskWBnJJjtnkIigoq29An9YSV/BNvK7x0qPobEPkD2xEe+gluHA21K7NCmjlq7heGa9cxCFX8lQrpX4OcO4E+voKXuTxKarUflki5xDgxsorJzMSXEaPT8Bt8PA+vARBrVhSd+bW7iXpMR2GhomMzSYLb03o3OPkRafRor9JtojuxhRSNsENFE7Op+fFE0yvYoRfGmntKnRKDOUqViieoYyNhBRexhJ2ykR3iRDFtsqJpLoM1EcHE1ECDFQ/hbpxj7SogJHqs6hO9PKhgIrU+ocxKlnUaGOQb1jJfOOynZ+fUkT6Esox+n5FF2gTxrmiYTDREOH8XvH8tUzhwl4Goh6t2HWlvDR518REsNbwiHi/R6G9FZcOIgUjsXj9eIJ+Nn79WfU7ZCHhASFmWjESdj3NZ88/Jk0SCoOW6YUFEpWVMfFoSixM3PeJfR5noFByE4UqD7lsjQ1dzyVseX8SrGT6lg3KrdAJGrB55FjlMvtAVRKK+jszPrZIpSRPPT+l9nu7MAWVvBx00YqrbIeNOzNJhIysbt7N3XDdRLZbXe2E6PMJqFnKTNsejyqDrzOKFe9voYD7QIKRQhj6mcs230n+v4asqMCbUKUrwc6aPvTAywWZRzpcrjG8Gf1+OvlVpNYqRSMVtnx4P2LoL9G9oc+tgJu2iBpZsXqsLUijQcP34pX4cdstkgG/aLFl7dmSIps9jfZce/vkbysRR9r/bhE0FwuE14RagO0bpfIbgQtTbniULASR6AKR5NctVP5YlD54gnG9kskdPvu5STh4e82DUPhs4OvLx5+gbvTtLzZWsUel575jjVM6dqMS/BSHVYwOaAidngsqpRDDI76DNPAeGpeOUjX9BfQKSA762ZUQSvtvS7+tPd2ZqXvID8+QGVODHl5d5/5OxpNPKmpl9LV9QFN+X8kZ+KvScxYjNos68DF4auXNjXyxeFOyblgnkeNAhU96ggDmiiis7M4iiPai4kQya4pLp7xS85jx0f/pK95M3rrDYT8JUQCJ+htauTyR56UnCNeqReoTSwlAS8JzjbqnKJEJ4rd6xfbeVJ87z3T0tnwkBwLP7pgDrplU4l8+wZa+lhYv4sDWS1Ekr/F2LOMbrnYiVIRRZP4FU1d6YydM0ciu50nbexzxDJPaUeri+OC3jpeToF6syzZOC83kQtMZnoarufJ3DfYELuXDdG90j0yzZ/A4vD5qDJU3BSMsiZez6qGPsqSzfysOYSiupkHc69ihfE1tG396MWwFFEi5W2FDoFLfvZb1IYjvLw3nzf2qJhVdIQ07Q6p8q51ZjKyqgt8BoY7RPlThIS5wxwb7eD6OQ+w5dVX6B1u4p3HH6Dlyp+hN1YjxnLUeAuZtPJbkgdPbaA6YY3qTcbPOg/hVEqbSGpF7/wh3xDzV8yXvib++47xd5x5/6vWt+Oy+bEk6Jh7bTEanYqL7psgEeDTPsHSMT1Fdk9jR7t8bU0rSJDIroiKRZkcWHPKzeMn/Bt+Irz/AxCrpl1h2SDm0sKvGBNfQ8U+OY1KxMOq92lS63AHqsnui5P0oQUmM6nlx0ER4ZzyldT6MqizjeLFg/cyaJBP7tzUEQpHUqny9jBP+yBGYUj6WyHFaAb8D1GNgjEImKMQUIlJRfXcNiI6GgjUhc6h4vCA1DYODRwifPAzHAl6vhntZ3xXKj59GpuKVtKVaGFUy9VMMH5N3+B9TArlIZoQDepUJPnDxLvlaki/+D+/gpbdI7ww9wUpL90VdPHLcb9koclHW9s69PpstnZPxOwTq1HvoPENMGUkC/xppI5YsfuGSC8q4ZMVKySx/aJFi9i1XZ621w50kVlcdiZoo3CubEPW27fyzKC0ShdmTMVGFAqZXEYiCulz8Zg0rcskodiFKc+Nw5FEWoKG3fut+HwaqYVf09hESKnC44mh9dg5+FQ6MjK2k5Z+Em0SRLpVDJviOWiew3yaSc+upbuvSKr6Jla+hzWpiUxVhFBIQ37+O9JAilabgtMpLrxRfHY1GmMIu+MAWz+8k6LGrVwb72Sl7XHs4XT8Ei+3sD1wduilstLGgQMWWv2VHHFdQGluMzaligRnP5pIEGNeB/aIRtL5KZRR/LzOrFk3sWmTDofTI3ZEEZyDRK0B1MpYgkE9ze2ym4YIjQIsHWMJBGMkwqbu66LHnkjJlU3SMfX06hBOqli05SR9eiPHixJR9IZIM56H3/0Orsz9jFr0IAdfWM1wXwcUm6meFqa1b5gcWy+h+DQGxdamOO0dysV62EhsjIFYdR+d+gHKtIswHZGDMsQOQakyk90K2X80OGTjnxkdPO74I7VCJ3XKbtwKH+MCheT7s4kogtiy5QSz4/52UrVDaPzxzKCUhKBsO9QU8tDbMIvk0ftB2UZK4gkaXTMIWpL55yI3eX2dOE5MoNxqItXuwq9S0Fg2m3rVYXJH+vApdFzx4J/Y+LcncA0PEWNtwT6sxKPZz+TEixglZGOONHMkchJdZyOTLriEIyegOXyIsDcsDa5ENVp2bN6MZrgPQalDY7qCkOdjQpI3bZTYtDTm3/hLUjOL+O71p2k+fIDMsjEk5WVzYrsc4rHggjuJrxokOOCh6KARDz1cbZjOSetR/KoAoSF5w5IVcTK25H4Uhr9jc36LNddFft58HDsfYLbJx0DCL3nq6HsccFaj0M0k4sskPTydHtU6bll/ixRxmqRPwdh7H1VDLkR6mBqIYQAloXZBOp/mDq1lsXscplM+1OcIGl7Fz25dLEl1G3j33tuYMeNqUkg5Q3ZFTaeomT3jeHDrdqh6H9Y/KEf+nvgGyuRNtnVZnhQPbnALUiiLOJyjtGqlx3Dv6cH2RT1hm1/qUsecl4/X24Yiexw60WLLMyhOtxJV6HAEzuPk+BO4TT2YhyahtifhTWrA2FNGbPtiFGEtIdMIVRNewKBp5f1BrUR245QR5pvUrHQqOdxfxQuuEIc8suRhvUPNXkVICq8RcXI4jpcbf0G37gl8Mc10jH0Jy9BodIoeQiET2qqp9Bw8gCIcQRdN46O6S6Xf+2LMNPR6Wft9GjnZtzIwsA6fr5O6nvtot7/GmNH/oNuVyOWv72XYLet/l1stFNk8RMK97DbEsPaf+3n1mgmkBfpwDsqhQ2JwjaglTs4roGbrBmkYMSFrD073TPYYrYzYzdTf/kv6lXHUJsvT/4PoGTTL1nDLTB7G6tLY2NtHRSRE+/PvEooEsGoTGf3rC1BZtNBzJRx4A9Rf8VC7Hb84MJfWgnpoJkp9ByrzcVD66R49nZnFkwgHI5Lm1K1PxGs7iDF1KjMNOcjjtZBg0vDYDeMRjgxgPz6Ojr4lvJ+yBk0wSmUDXFFrQVWmhGCUiFrB0w2yD/TjaYkoqmRfYf2gn+sUNzCY2kmbq5YcUzn10b209zZwZPUOfnPvHzje+zrbWjO47/NjPDz1Dcz2fDKr7kMR1NHpPSnpfQ0qK6/k3kNbII7tTQ7uTz6fY4rPSBzspOCdVzhcPgWP3sDk+q+IHxnErxHINhUzPNKKK2Rjx+Z3Odn9MXNvuoa0jPO4vPhyKVZbep8tOfxxyh8lGZEIkege2SDLRqZfXCiR3dP4Ptn9MYgJdiIWlcphNiK8zjaI/NCD+Cf8Lye8jzzyCI8++ugPvibaP4lZ8yJETd69997LJ598gt/vZ/HixbzyyiskJ589sf4r6I8Y8Sg0KAlTnlzLqBYnibjpicQzpDJQHungbcM/WG0toL9QTziUTf6MXUQVETT94yT92Y3lH/HIrgcYCMvVNKuhiQt9NpZ7U3BrniNNkIXzIlExcgSbciO/Cc/gc8GMJSqgCcE1fd9I7/hQqIIpunQ0vgjRiAPv3n8STUzmhevVHFf1sir6HaoI0pBZnC6MqfJpvtt8NYNDdkJKD15jJweNEZb4Ra9B+aLsC8kks2pDGzcumMGX530p2a1k6M3s3jNP+l5K7G9JW2nGrfSLYmWE0DDjj2ViNefQNXgQV8DH/i8+xpNdRNhgprOjA7/YmvN7GTe+giW3/Zr1r7/EsU3rOPTlEdLm6wiHz5raizhNdnt7CujomMS0LAe1e4/h7jOQWnkFBw+0Eg5raO70EAhoUKsDLLp4CWP7+vjmqy8ItncS7h0gsyKWEXsSKakNmM2DnFCa2TeYJ1XcssblU5jURLxKgVs3KJFd6fWlNOA6nk/buiIu+s0r9Ay9gdMp+42G3Cq87XHElfVS3vcJiWKZXQVXJtzFYDAXQRWgxzuava5rCEW15I5NYNJN8zjZ/RyOrjF0lfqw5lRz2iJfrO3bTwuuxb2GS4fW5MPhfIte/Q2stFUwxVlFpa2F4hlNqExR2ttH09UpJ1qpwj6CggGrSHaBtMQacmfVEPIqpSp4OCjQujmdkF2FgI2GrCSigkDYrqH+m41kzFBg0l/IW4/+keiQm6Aywtdx3bhPhkU5McZUPckH1QQCQRIFC+PCuSg0eaftZE+Je8Q3TEDQKol6QyR5lAjGIIgbj3MSODZ4iJ3Rw8y3T2ZsOAcfAQzIZKMvsZqw1o5nMB9lx60Mxewnpe8csqUKFQS0Cjr8EOgrYSjSTVxFG4lJ7Qz0KMl259IY00xrYjuOY19yNCuRYZuZIaMKte4QhUMD0vHdHj+dIo+JiedexNb33mC4czXu9AJUhhzy/fLgWEkojcb2r4lEAqhGZ3Iw/AF7XduxBGO5Pec26nedJBCfgto2gFJVht4cx/xfPcZQ+wl0aTU46/cTXdtG/7CLOfOvo3DSNHLGVmAbOUAk4kWjSUJrKOBL96v84ti5kq5fxBjPKJ5qu5eN9iOs0ZTiF2CUL45933RgSs8kYzoMDGyQEsPEa8RoyGbBmHswGgt4cNeDEiEJ+DJR9JaywGqXNtliYIjVfiXvdbvEdGbJiaJHNA4W1xvBS7Z1NxPa7VRaZeJWNbSJVJ0ChWkCHep4DOVT8Rzfw7at73Je/h3oI0YUZrWUMvYDKFUw8UYpwldKANz1Nyi9QFq8lEY18deWSql+phlnY2YtczJxH+iVya5Ioien4jacoGqfKP2JkDttHjmbvpSOTrdhGp2FdlyxPezxmKiKerimp4TKxkuk340sycJ7dBB9D6Ts/B1PFDxNi6KXAm8Bs7RhxlhqGIjGs9UBhzzyLTI2MpmQtgZH0IUiKqCIqulQD/NV6k6sTTeQOu5PENPMUIw85JjSsphQixyGIo5W3RvUcSQKnyi9PL2ujjlFSWw92c/YjBgunZhJQVIaU6dsoKv7E9ra3sDjaWTPvot54/gNDLsLKEkx87vKHE583ITPs1Gq1OYnLmKDK59LXt3DNa7NnKbQc6+/RbKZE1M8HXN+xuYN21H0hGmPV2APy9KiNkOWNFAm4vq8RKzNDtZF7GQP7mTMyBDZ4yYwuUMerDqV68iEc06RXekf10uEN0Y4jDGSxmjrRKbFT+G4+igH1fU4Qn4mmaYR/TyHT4UDJGVbpEErg0VD/OJyvDu9ZFjSGKUYoj6i5r7FRWjanAx+Ix+/iY1pjP8mRKIdtCEwTI1DYdUSsfulYW+R/l9YnoL1qHzfO+kLY9Q7sWh9fJm0F4UhzISOdEq8M2mnQbLlbHxpM08sWcQ5H+2jxxXH74/8kb/aYhFCWlyJLo4r9kA/9GWU0KaRrQWrYtVcNTMWdeA6LtzyJRltdUw8Jm9ERQS1MCf5UrKUuQSTQxzTf0NDVT39dQE2vPUsRYtf4tqx77AkZ4kk9zOIHYjvYd+qZkLBCKkFVnLHnR0W/D+h1+6T0lPF+/33Ce+JU52kn/Dj+F9JeEWUlZVJVk+nIU7Cn8bdd98tDQaJXqji8M8dd9zBRRddxK5dsh3WfxXdEatUhZtkOMaYpmFSe+VFe3NkGoGoQKGyE4snTElON4mFQyjDhzB4Qrg9yWw9cB03lguYT/Tzm4idx4mnFCVPeIqJ9+iJUb1IrqIRe9TAVYE/8iBHmaL9DKvqMx5ylmAxWPALom4yQKpWXsCILpOoUr3aRdo3jxEJhziYdQ1R+xbiTUGGdEMET3VP7s65n3GVBXg7Gxlod4IySkAzQrfHR4Oil6JIKgFVFLvaD2EtAW+Y1a8e47w7ZfH+t7seY3/beCqtCWzfYMY94ies9OKLj0Ft9zMYb6Zf7wNLGUq3A21/J4a+Dty5pQwNDooMFrN7hDnXPig93vTLrqFu13Z665vJnmjFb/ahCURxhmLR6OUFoLs1l4a2qUQFJdvWDaALmDGVFXGkSZxyFV95lEBAXniSk+s5Wn01fn8vo8f7MUwpo+odC6a0I6Sme3ANG/l2YBH73HL1Q8TXxy7kKnMfkdYZlC3965mva7Ve7P5xeIf2cWD/uSj00qSg1KI3pXmZ3NWNeh9og2FCCoH2iutILZ6PYeXNmJ0BkoxtGFOrOWZexqzLfsfJxudImvQm1uFcjMl1sgdxbzm6uFYUiiC6sI/AqcCdgeYygp4Rsic3s204l6igYI9lAvocBWOtdQTdSryHPZSM/Y7YPCchr4ITK0vxWDIxJnnILT2GQmxDmmQdct/ORIy9YWxGDfWpst+jIdmPZ0CDrdGMrVFsQ8qDL25diJMzVCQkZFBqSOK2sbdJAz/1OfWS3njemOmwb4Q+1RAbRjYzoTkNaySWYX8P2klxlC9fwtd/+RMD3U0YVCqW3PEbiidPQrVby3PR9/g4fg33T7yfaSlT+NuuF6nrq6XGdIK5fUlkH7mWkD2WWk2AJFMAIapgKHM9nTGbSEseIhoWaFiZjblYjdoQ5MobJ1JzTE1VUxXDumFO5gc5l4ks/tVvePt3v2YANUpjDJpYIyd1hZJm8vUrF7Pv689wCCrCRjNloVSUp0Iq9YKOkfJkVqfu491dP5ffDAEcGhtPdz3NuISxpA+lE4hLwqqZwAX3jMdqVGNpiWD/JoLVKw9jinBtaafgV5Xo4mLobtgqfc2oOocV337NrOpSzH4DbnOA19O/5Of151Pky6QrmsLHgleSjExPiSFWp6K7qYxoWI3P10FHp+xfWzTqYWlQR/T6zGmLZ6QjxPW4qfckM+yRq6uZKPgWeW26TuXBZ19HuzeOuJQMzMphyt2lFGXOQoWaPm8r9Y6DzFh6HbNGEiWvVGflxVy4eK40nLe9ew3qtCUsXDZO0qP+KCbdArtehO7Dshdu9jT5OsqxnkmnEgfGFAqVVOU1TUrFtbsbhRj9PVnN0erbiUaDGN0h4g6vQAiFsFlV1I05KpHnLU4VK0fEDXAzj2T+gzt7rqIiOouL1h7HisDrGLFpOySyawwaGds7FrEj36v1sSCxiT1OPf6oQNBRzlNLnyQjYuebLz9ksms0X1b0ssrxCp8kfMtrcz7lxdV/YWHKl6QYd4PPgqttHoPhMP5AlDF6FSUqJe2OEPNVar5sHpb0riLE/7+2vRmzTiX5ziZbxpBpfZoUXuW9miUMemUS5PAGOb6yFQIOnEINbmuA0v5daGdNYufxFmIG5M6I2B0Yu2ipRIh+9fFhOabeJG9yRdOGuKgXXUhFt1reyIxOtfCzLjGwXMtN51fyyfsrcdmGOb5lgyS1McXG4RweJCY2hTGXLj3z1nkMRfSo48kPDnGVPcKsvuswO7WcExlN1KjAfUMs+98cxilS0yj0t8rhJDMuLSR+XBytXzyBOmMufzbEM7A0m/6uVm5o0pOTr6ZUpyOyq5ySwptJqczENC4d7ahy+v4mD/MlhGGsSs0NHjXaiAcfYayXf8mIZzUD0SgruwySgOymy+4kYZuBUGAUqoF6Xuneytyv9SiKM+CIHduAiVsIMkrw0JPwNVdWDUvb6W/GyZKfX9b7eSdPjUelwCrouMpwAbbJ/2DIHo/BnIQ/3YBQpyDLn4vH2Itn3iaM/g3kpRhpXp3FcF0sXaldxMT+g9KSJ//t9G840EfdqeRN0QHmPxqk+1eIw6O/F8XIoh47M0ZKVD0tZanf+9/jKP9b8L+W8IoEV0yx+leI3nVvvfUWH330EfPmyZVJcfq/pKRECh0Qk7b+qxiK6pmmOM470WfR9Mot3v2MpUElptFAdaCCSuUh4tsVdFt0TDzZT6ItwHFjNtlxG3ivzUxA0DLe2Mh3gV6swRvFBiZK2jGpNkican2wkppoLr+MpLEzshazYpCFpla8kVxqbYNYDbspFpwE/SbctiQGHWuJqVlN1O9j7fRzacvTM6FZ4FDWEEOnDstUtQ77+ho+XmPC0S8ToTkXj2PXSi0jhhMc0jRhCmppopcBay8mRS56TwYdtcPU7+9Fn7adP64uxR6ewEdRKA04yTWBRleDSUgieNqgX7SNUSgIm6x4dQaMDdVoejvwpWQiBHwUjZ1DIBLhq48/loayzGnZ0FxH3WYNY2aH6G4t54ijEqPSydXGTzjQW8QKYQxeQQupFcTjZH64EYMQpsVdhDonk8vLwTXcRneolid3LebiwlVkmHvw+GuYcetVDDj2MeyJ4aUD99B+Ko74vPzVrGudR104iwNd+aRm7kZjapKO/9BQJgkJHRhyqzC6x6DQ1SMMKck/4sM+NspAgpbWDBPlDaLllsDuSbEENd/R0v4djDMTNxikuMVFT6YDS/wKth9ahRYfohuOKlnuPAy1pHNyeDa1h28mKailVHCTe85DqLRuSrP2UX10Njv3JmDzx6IUwoSjSjYPjye+pY3c/jqGYiuwH2uhLPkgFnOI4uW1BByNmNM90lvwpSORWzN+ycEPP2f8hmZGDAE8FUr8Ng36NC/vj+sjY0BP5ZEEFEElESFKf3KYq8fcQ5Y5G+v8HJSnK0CiI8aoUdKHhOJ0LF0uktbF4V8W5LPXH5J0h6yBvetXSDpZERl5+ZRPmSYt/n+a/idMahMf1X3EH08+wi/1v+Rdz6eoLCpJKpNtySa/dCwb3zyB3T2aTf43SZ7chTani9PBm4IqSu6iQZLTzmN45Au+PfoAMyd+xDzbPD73fE59ppOiCZfT1NGJM7sIm2BHGzGTkJeAqu04OxrG4IkoOefW37Lpu210RWyM1xRKJXZ1ipFgr5vZwel8pdwlGcXPzZzLuXEX8fyWl2mLreGg+SBHDUdJTEgkNfNr6mq28PN9y9C7NahJIKIMEhjVQqjfh2loDF0frMayNJPwLi3Gnie4zmtE7GGoMFGAi6B2J32RvShTI/yq60qOamVJUYYixDX3yh6jb/1mB67eUszpsttBeuzVxFllYu1vdxC/IUo8SkoFJbXRMP2SR4lY3JLfgyR9Ox9lvcLFIxMYvVf043YykpJMq2KAyYwiqohyzLMTvdnC2IVLubTZKRHezw+1Urn4GKoLsvnbgUrskQiPf3KAi0+mc8eiEikE4AcwJcG4K+HQO3KV9xThFREMOjhZ/zADA2spLn6C1JQLsCzIkrS7nhQP+44uQ6XyMKomQobNLvnJhhUCJ3MTJbn8jvYCVqrkOOkC4yga3fW8kPYBCs9O1OpiEtVz+UCroV+Qh1PnD8qR3CIaGyZTrnew2DEBR1BgtusCRu0dwHt8kPOjc9GPSeBPF5xP+5pdHB04ynv1f+Otnz3LF09l0DS8jGhIQ8gnEkq525SpiRCrFD3OFbj9UZJCAgkpBu5IiWOTz8fXzYM4fSGcPheePg8L0fA813DKaEdCl91Hlfkks6yH6W0NkmTXsTlhNMdODDHbU39KsyygWHiDZCO2/O87GXD6MWlVXDcli4YDm1DZ6xkxHqYn1cek5lsIpBfzWGoCyp5BgslK2i12Uktn07DrKwSFmvN/cz/5EyZLch6NwXDGmqu7YYT331+DOynKY4NwjT2ETXq9opNjFJU7gm6FF2dfAK1RxbxrS6ha30Z8hpmCiUkMdbazKXqcuaFJpLqMHPlmB4/PKCVgOk34okybHcPsI5MIdUAoOxXXuw0QjOCNRtELAi+F9CiaZcGwo2Qldu93UrEj1FFJistDt7mF50f+iXPeLRxOmM1VK+tJbj/GnbPPwaczkZfcTrjHz6AQRz1qrA1LUAc/xGUw052cQdHgMSr6fWzT7qUvsZxrO/x85ZvAPP/NXPizcdTHdLD680+4xn+O5M3eN+YlAn55wHXMjOtJNqSy5/OP6NyRSjS0heyMLozmsx2LY1s7JecF8dIrm5lGymnJj3Q7DDIyIjrwRImLk8/LPU1DvLK1kTSrnsYBl+Qzr1Mr+N2Ss4WY5sP78XvcmMQh35/wo/hfGTwhShqefvppqXqr0+mYOnUqTzzxBFlZWWzevJn58+djs9l+kH6VnZ3NXXfdJVV//yOI8gfx4/vBE6Iv7KX3PMw7plcwCH5GjBo2O6+ijxzywskcUjVjFfq4nfeIRAWaQ9dQoH7/zGNsYAa7kO1xRMw+to2ZZZ30B17AoFxPjPoduvzjcQd+w60qJS1ChEeVK7le/SmtkUw+CNxNua+b86zPSVZkm4YspG04a61Vn5nL7b99jMvXf8rNq77FdmWI78Yq6AspuDgmIOk8w0Et7p4xaIM3sfSWhdTt7WHju7XEj/XRMnyUuLg4SQYyMmIj2V1GxJmASudkpHQd/2he9qPHKlXhpFjZy6ycRHJq4knUwjfaw1IUrK6rmWBMolRNE6u+ak0OUZMH/6kADYPLhbajnpA4OmBJwJ6eg4IolyQ0srbXwEuh84ieqsCdRqLSR5ZXzSGN7N04KTeOB5eVcvlrOxFddfItIV6+qJ6u7ldxBoxsbp/FxtZ5eCJa1NEIM1I38bOMjXxhm8XXTcuIUXq5tvx94g3DbOg4nwbbKG4d/RzZ5k6aV/+Zypj3KA3uwR7Opko7DdUMedLYfHQUiTNH0+z44kePiy0kYFZGpWEREeLVORKw8F7tJVQPyFXzU9/hKqeWHP0gOQsfR6n2o/QLPLf/l1R7i5iXuZ0YrZ0vG5dLPz1Re4RyIUhCWQJF48zQ+VcUUfl4itjZmcjnUTePVPye8ptelGI7H558I+fdci6err/yT+9B/EqNlOU+ylKASWVEoVaT1RiLb1Wn9BiCTim1r40Tks8MbZyGqD8dePUoEXdICiZwTPWy6vl/r3pc/uhTZBSXnf29SJBrVl9zJnJWxC2jb+HOijvP/NvnDmIf8FC3cxNRhZsG4xp6vU109oQ5t3QEgzrKAY+OSoNPtFbmc08hj037K+d/dy3eaISycAxBZxLdhm5cGheWgIULO89lT+JeDvdfyDPnzGXcmha0ASVuZQBjWENUJ/DW5LVct30emqiakfkq8spL0adYJLJ+cG0L/9z9AUfSN+PQDaIP6clyZTHOXo4iLKbuRVBb+7hk+RQKCq9loHkr3rdCkrb0NN7GL338GwQ/cQnN5A8VcCAikxBDygpW3fAgGbYE2v5ZgyPajZC/AfPwRAwDxaiSDCT+rJzB92qlgTKRtCmX5bC/ZScdLX8mFFXSpb6OFQ0HUcbs4faKm7gh/2o2vf0Paqv24M0olxwolHofjgQXD1z8iGSn5PYforn1c276Zi6uU9rp01ALQYJR+flplQK3zyvk57Py0Km/F+ow2AB/nyh/ft03kDeboaEd1NX9AZ9f9h1VKPRMnvQtBoMYsx5i49q5KHXdFDS5ye6SZyGGQlNx6ebQOO0N6d+1Hg2vDymp6FzMlN5zWVO6hmb9WgSxFC5KeDQZ3Dn5Du7fcT/qqIobWq5iWHCji6rxCUE0qLjYNxmjJO44i1CinpQbytDF6zk5fJIrvr1C8gy+3XI/4XWpaA0qKRDg8Lp2gv4Qk5bnkRIM4fy2hcOaKA/4XDgUUa5KsvLL/qgk59EtysaWqMXeaqdjWwdPhj1i6DGxCi/TMr8ioImwoeEayXLugoynid+STL0xn3VJi6TnpA97ub7jPU4aizhZsISrp2Tz9LqT5MQbeOfGSWTGCuzeM5d65zAv9MuvJ21Yy4W11zM9sYD9yiY6lUOSrEUkzbpeMIdLueKhJSRmnh6e5YyjwPt/3MMXmS8xaK1hW3sv+miIXv9fOOYpoycYYbZZJXlJH/OEJSsy0VHgNNwjNj564F4cA/0Ux03BmjaXmyYZsGsEKuwjmGhgn6VSkujM6Q3yZLUP1SmG4olEOSKGvZiUKAUFkWgUd1Ij3WOfxGDKoqzsBfatENhQv5nVZV8yknQnIU0uymiUe1a9Dt0dbJ2ymKAxgYWbPpQes1+TwBepFxBSqClx1mGI6eXwRAPTdR08OPl3XL/6Oob7KgkMLoCoWjobHhbUmPRtjPEUSjp97ZJkVOPsOB3VqFRmaQBRtK378i8P03ZMdtRR61RYEtIkBw2vSyy2hBGUCeRXjGPxrYvpG/oMu70Ke98Aw70NKPV2NKYg48a/QXz8XClcoq73rDbXrFXx9o2VVObESZaHYrjUxjdflmYAyhYu45xbfvlT8MSP4H8l4RUN+10ul6TbFUMCRD2vaOB//PhxVq1aJVk6fZ+4nk6eEhOvnnpKdh74z2qDRdjvN2PRCgzGqunn19QE5tMRrcU5soawLgFlJJWb+JgMcZmLyjrcACo0kpIQ1oUnsjEwFaNehSoY5PxgE/5wBaONX6FV1DIU+AXeyLnUEeZW3Bhxs0t7J2bBiy+qRineXIUwwbKLeXvczfyjxU9WVy+Tj1cxGBdLUnsbF2zbRiA7wuB9IQaHsrAP5JFXslV6Lv19uXR1FzNqVA3Tpj5EQsJcAt4Qap2SYbcfszbMnt2P4HRtQIVCInzRsJbvjF5q1TAvzsIN543i+c+30O5WMBw1ED2lRZxZEM/vLDHEHB5gl9DECW2rXD08HbkmnqSRCHmNTXhnzWThnDl4b7sNu93G7oJ06WBp9bHM/tndfDig4pMDsl3RRap9/EbxId8wl7+Hz8MVPnuT1aoU+EMRyYBctN05jfPCAplj3+fNE5fiP0U8EqMRznfqiY0oQAgTP+ltnmw9lxH/2c3QaYxNOc6dY14nHNDj7h5N8OQEBuwV0veSxn1C3KhNRMUpcEX0zI33NAZDEK/8QVIpAVc8I2Edfzp8B+6gEQURis1tiPWsLmcOKSonN4WUKNVDpEx4n6Dewb3bHicUUXO9933yE9vYwFx2uKYjEGGhup4n7rqB+Ph4gkHRyuwQB9a+TsijxT59AU8ffoZL6uO47It+lGlpHHzicWqCq/mmaaX0fJ6Y+QTn5p175vmF3UH6nj1IxBNCYdEQcciDNQqjCt2oOCK+EFF/GGWsDn/TCOGRs9dUwk3lrPr0WdpP3RA0eoNULZx1tZj490OIjh+Xr7ocX9gnVXW/OO8LybD9/4Qh7xCfHbqfUYHNkh51JKIm/nsJdytH1GxxnjWUT/YkU2YrI6Dyc9fwxaJjMH+ybuEczxQmB89uEkXsTq/hccvL3NN9LQvtZwcBdUWxxF1dIhH+I980oQqH2NT5HTab44z+9vsI6PwUlGcyLs+LtX0c2q0aoooQI4kHuMGWz1BAhyHtc/6x/F4+OljDhmMeIoHTSm5ZH/ozQc3xjFeZkT2DC/ZPIRo4e+18HxGVgCIUlTYmKfdORGmWq3JHjt/DUP9KGnwKXh7QsSxvGU/MeOJMizUQ8vPqe39juN0NMd14s7cxPe8qCrV6vvu2HZ/PhD+1j83dM+h1J0rXdomyj6XZm/AEBb6un0OXXq5unVMWyz+unSZV95ua/srA4CayjlaT3uMlYozn2PRJDPpkf+mgO4mQz4g+vgWzaSyFJa+xef0TxMSuJHHAz5gTMgHo9f+WUHQW3eWv4kzbe+b1vtlnIXn3ExQGNUSIcsQ0hNZ0gpb4g4RVfongDeoGuST3EoJb5fNikXsyB/THsSncJGBh7pTlqLv9dB8bpDMQwS620xdkMuMSOUTgb4f/xhvH3kAfMHP50d9z7rWVFE2WW2TiaxSPYe+gg3v+vpI9vtgz656IFzAwERVtmm48hPk0aGbjqfCAWF2IQMZfUagd0pCxp+leIsEERvu3UDI4xJdp5xESNAjRiCRfMiesRKuJZbB7FnFGjTTk9sRFo7lyUhYd7e9S1/AYL/TpaD+tVRPXu5ZKzNF8ieCLCAkhVFEVPqWPnmgrV6U+IEWPS+dONMLdW+6mvqeJuPZcqtO2ohJUbDVUYD3+OfXemdSmPE7JtFSaPz7JaJ1CqvYm/boCQ5rpDNn98slH6G9pIjY1jcn3/5mrjnTQp1VQ4h7hPt0daBVejoUm8YzqN4QEJZkjYe5q8lPaG+C4qRpz6VrMehfKoBFlrJNAtEfaEFVO/JKtniTebu1noGGEjngxwVGDEHZgGXyRssZuph+LJ2wxgj+A0h8ky1LG4cuX07P7CFvdOWcWX3FtFjdlcQYtSdYIVW3yuiV2FEIhg9QWfxA988XpmlIT6deMk4Yr/xVel5ftK56mftdOAs6z8xb/CoVWgz8mRnJFUgyJ0g/5sdTGIGUXh4kb/TEXvrJf8hU+PyOCMbOAqyZnUZJqoa+5kY8f/A3hkMwVRFz08JPklY3+ifD+CP5XEt5/xcjIiFTBfe6559Dr9f9twvsfVXhFwttvTmY4r5iDfb/nsTFyJaS4tYdrv32PDakVzEyo4Xa+kr4eRuDN8FIsRLlSuVr6WiiqYHNkFruV41AFxPZHAX/QXC+RoPuzPiTOEYexw09fqJOOYJBp+mYuN76LRSFrp1aGp/FO6iUcKK4gdOrCVkZCzO3YwWWNK0jQD+AtieLT6Tm4/wKiYl5M0S7i4jo5eOBCyX1ApfYxduw6xo69E7/mEp7fWM/qY71MTKnnF6P/Lq0Xdp8FR+MVtHbr+IA8Qih468Ic2hqP0N7QgJoAvqiKI6FMTkRSpNeVo/HwcCCRdEJ8rNst1RlExCbEYu8bJKJUMn3HTjLiMtHrjXj3b5Lsh2qSTbTFm6WG7J6kJRwy5oonNAuGNlPsrCdF5+TKBYlsyHyWX609Lg06/HJ0JlMqU7nxnQMS2Y0NCxRFVOxVB9FGIKAQb4MCGfp+0uMO8fSFl7LlyzXENsdiD2aiMA0Snfw5m3umcqB3PM6gkeLYRslBQ6v089zsP6BTyTeQgCuB9s0PocwR2Bm/knPMzSRY5KGMaERB167bmHxhBl2Dv5cqj/vr47ha00FLrmxH5LVl8GHnHPb0TCLd1M35OND0lDE89498efS3uIImrLowLq+SlEgUvWGIRn8CGcYeLupqxKtNY2xJMS/32TnhNRCvDrH/0fN+NGlINNpfuGIBf3zNRm6/Et+Fd2GN5vGP5M9YG7uLX479JbeNu00+P50BibyKekpPVb+UXJV0x3hce7px7egifIr4/itUCXrUGSa8RwYkYujJD+L6uk08I8i4spKEyv845/675u9489ibPDLtESmV6PsQ7Xv2tw6zvqaPOKOayyozSTKfrcztPHA5fudBEpPOp89+jIC3WbKNChvGsn6gB4/Tj7q7gliXHIIhQkxxWxgcgymqk/S64lnxZuwqMoUpLIzL4lruwqZ2kBCM4fqB8ykK5ZLhSxL3RATTlLiMPmIaVRxWNlOlktOTUiIxFIRT0Mc1sTtxK8NtE9CGdRSO2k1KShONDjPrezNISE1hQtzF/OW7CCjdXDDvAOVJRfy96u+EImEskfHo3QuIhGJ4SJFCYY+85oQkm30lqmwLNSdtxCoFMqamYiiNp+/DWrSneHBnjI5xvxqHzqgmHAnzi7WXc4m2SuoqtBgv4vqJf0GtPLsRcDiOsXPnHezfP1cKIJk0+QvUah91dTMZHBBDD8BsFsjIGEVt7Uk0Oj1Bv1x51evt6PqaGC6M4d22y6WN15rbc0m1hDh46GLpZxThKJMOj2D0hhmMU3OsKBZD9wK6axbSpuxn1MxX0Rpkcqv3hEnv9ZHe7UMVidKWocfl+TXe/hJG5vwWQRGm2hnHGPMw9pCOh7Y+zByfQLEnTtpweAyduE9dgyLcKjcTRk2mrvY4qoCZ+OHxFFpDHDAexB8JUFY6mqFd8YT9EfRWNQ7PEEHzAIa0ALPnzKawuJBz3juPAWU3paGJvHf9q2iUGja1b5LkDsdbTGw9kixpqiUkjmDyD+JyFJCkUnL1hCbesL2Nt/N6wh75/K8ocNOoeI6o0k2lYzTDmhFOeFPw914srdnhU6lxal0zWdF+mvxTEFQjWPJfwt54D4SNaJVhvrnZRWH2ZezeOoftziF2deSR78wjJmygWztEvC8efVhPQPCyNW0H0WiI6b3TMUWsBBQBwm4N9999H7EpRlYd+Zw/HP1hMeeyUZfxYPZyeH02UYUG7jmBYEqg7fggzg9OIJYEdMVxxF9fKpHcr5/5E66hQXRmC5MfeIKbuhz0BcJkhAZ4UPEYvroUktO6CVt7qaKCv3M3PkG+V2aGulim/IIOstkoLCaBQR6J3o8BL2Wlz1OlnMVNx1vlO4e40fCEiQ2NkNzzPF5VL14hyuVbk9EG5cKHymTklodfwZAlzye8/vkmVjW4afZqcP/LhlF0J3ny4jEsH5PGrz8+wLoTQxIlfXRBEdctKDjzc4fahul3+FlSniJtdNa+doymI70UnPsAAZcLV/d0uutKUIW0FFbE4nY10FpdhSJ0dhMuXQ96AwQDkoeyLs7HwVHXsKUvkVGuehYPbJJS8hb94k7UGi1f/OUhWo8elsl6NErehEnM/8VdUvf6p2jhf8dPhPcUKisrWbBgAQsXLvxvSxr+FSLhFU+8Oe+/RVriAHMO5fN4ZS4B1Q9z2mMcLswtfeyw3YpOCPJq+qU8UnAHqcM2nju2kULWk4GYlAN7ohN433wuyvQAL518guPGAhZMfEv6njIc4YZvv+TK9V8xElPM0VEz+fiSHHIamtnTV4BolBRO0zMqp5WwRs1JXxFRo+hXG+F8PudiVtBYM4meIdkXMajykpHSQ3X7GBrDCaQqHCRph2g3qjjYP16SYJzGRbnbUERjWNlaJg07ZArDNEUSsAg+LtQc+0HlUkQcNmZFdnB74E66SJQ0eIvQMEa3jgHkNprB5SSjs5v64iLSOruYuVO2KJNe6+IriSmppGrb23ymz2ZT0lyp2rFwYDNF7rPJZtaUn+H3x+AQIghWNb/6wxgpyWdbk4ZXV9RQOQgFmdU8G4hn4NSAyERLB9cWfoopXraLyezyMqrJTcBgpPGcq+gf3kAgFORv9ZPo0HRx/+gynl0zkUFvLLeNeRtB10CRVsCkd1Ht0vC2TXy/BXKUKjLds6TXmj9oQNuxiPgyFX25t9DeN4fDvWOoTD3MrIw96FV+6fF+v/MhIlElD0x+hkS3leH6hWTNeY7d3RN56/h1P3reXVH0BeM9BoLuBGJydtF5ciHPu4vxo+TVaypYUp4q/ZwYbSt6morPzTg5hY/euY+KZzagnfwLNElyZUckes5lekpnVkoVK9fOLuyrWyTt2Wkk/nwM2jxZgxYNR6XggWCPC4VJg6BRSJP1EXcQ06x0oqGoVBUWf19yZ/Cfvbnoy+OJu7JEipz9z0CcQv/ycBd/29xAp+2szZ9GqeDqKVmSZEW09unu+ZwTJ36H2VRGZeVK7t5yFzs7N5Ggy+AyxQw6a31EImJwdoROUyejnAV4hQDqqJLzA5XERI3s0h3nTzmvEAkkMD2jgj0D66W/NSF5Ai32ZqyRQRbrLIwNJiGoPZj7KnG3T2KdRtbRziCbxJSTOC2N+JIjWCxGYjLvY9WuTxkT8ymKUxX/dzqTORJ14uu8jqCzFHXcTnTJsv2aiFnxs7g+5XomTZSDJsKuAPb1bTgOdKGKKqkzttKy1EPclgp6G52kF8Vgs7ejsIcZq4yVhmQPusV3VfQEFhDMQd4peJTzUuxMMXpRRsaSV3A1Hd0vkp52FRkZV7N//3l4fe1UH12O3R6DKqkRo9KPvUe81iMS+T09BCri5ptvxu128+WXH+D3i+d+hMzMGr4YmkbtcDFLc7dxU8UQI86tmExlUkiDweFiYtWIOBNLGCP1kRl8oRhFCNFTPMyEyZ+S2B9gTIPtjFjJZcpiZ2lY8t3u9caTYe7ipC2XN5yD3J/mQuuN40TdOfi9AgnWbBSdyQxaDkrVSnEy3692SXKU08gwlGPyZzHU5cKUE6DVv0865/XudLKs5WhKejh2rPrseabRsGzm5Xyxchtfl79IVIhImzExCW5753YiISPuxj9CVIFgVJAe56GjMBM/CnS7O0DUvQoRouL//GLnx4c+431URtn1Jbc3iUtqRzEn5QqO6Jr4ndeEV2GUiM28eDPxwhY0LgUr/GMIoEZQ2okz9TFkH4Uh5gAZWSu4MDGbTmcrnrpFWAP/3pVyqB1sS91GQBlgwclruLDiHNbVf4A6YCAoBEkLjSZOOcLb1rfojfORNqDDqw0TVsErU55n7PjZ8NosKc7Zr0vikHkhWefdT7I2gb4XD0tWH6pFcXzyzkP4xU1UWg5pRaX8I6uc5qiCzGgbD6tfxtl5BSdPtpMYsZCjDXLU2IHg1zJsNbE6czZDhlPzHt/DhVYnv4/pY09nMveFjAQEBZVDXQwf6acrlMTM4V2Ms1fTqUtjZcq5TLPtZLxdlkYNZ57PLXdfTk762dhx6XqKRGnpcvDqxgY+Pylbny0fm0p5mlWKqxfdNfQaBZ8fkvW6o5JNdAy5iNcp6PVEJZ/kqUWJLJmSifNvJ6RhUmvuDpInvM+J2jkMD2cQa9VzwUXFfPVVEyM2O9ZwE+qRQdTaXAbUZkI6g+Q7b2w9QTAc5e2s6wkqNNyiOoSh+ZA07yA6uVSedwkrHv+D5BV+4/OvYY6Pl3TWp3nHT4T33/ET4RUXTpdL0u+KkoTrr7+exMREPv74Yy6+WK5AnDx5kuLiYvbs2fNfGlo7feIlrtqBwni2JTpmqBafOwtDUEVdhgafVl7C7zvyNuMUdbymvZOSZj0JTtH+5tTvGFYx0/K29PkWcyVRlcA8235eMF3GM7HXkp42TJtOrrYUjDTwM99TrDRdxz7TLKa0NzNgd9PV/e+LhqgTckzNluyhlvTtJLd2gKhCQKFUEAlH6Amb2RgcRfhfNLEiKpKOkqAfYn3bPERVokhTglKT9SwmqVooVck+iUpCmPHgUJiZbtjHfNceeojj16p72O+SjfOT8DFPU0NM1M2ib9bi1hnZdM4iaeGYvWMLyd39OM8J41weRqk0EaOYyG2fz6ZHH8/y4S3Mm7Yeg7mE2i8TiYRayQ2lkhVOwjjlXIy6EUb2/wW6Bwjfcx+7V+ciCCEuS/8F+3SZ/MlxO5flBCj0PYM12kemTrzZqVD134wq2of1oslSZGk47GPI5WTOs4fwBML8+cJy2oc9vLatmZzkLrKLd6IN9nKxsUmqmn0zEkub43rqmxLxBGUyb4oMsXCoDaWmkDWpA7hPBQeI0CsDLEvex7AyyuaOWeREgzy4+F6pKhxwJaG19NKvGs1De8oI+9Kx0MPorgABQYc1ycvFs79GpThLJCNhFe9teYQdEQsFBjX/LFdy5EiE/KgOy6nigv7iAjpfeBirehyqlNH4BD/BLBXmNqVU4jCMSZQIsveo7PWptGoQtCoMYxKwLJCjiP+zGHy3Bt8JeUpdk21BnWqULKfEm6N5TgbWJWc1fyG7n2CPWwog+H7bcGfDII+sqpHiT0WIU+6LSlNoGXRxuF22g3pkeSk3TM8lEBhix07xuo0wfdoOfBj4xae/IL0zHfOp98Ni7WPcJDM9tdlUNhWxSnsAp+CXJDqlkVQ+H7eBDncHI5GzNnjKqJlHc2+nqfNrnBE1roCR8cnVJBvk8/3o8bk4xBtcTpjyrI/+7TgYTddhsUbo6foAUVkjvjynK5lHe/XYmn8tXTGG3OeIFwKkWFLIUeSQ0TuMRuNj+blPkZFxtiJd01LNJ+v+yVrtDnwKP+c4ryb7+CT08Y1kznkWhTJEKKKgxmnEt/0+rF550yPiZOJ+ZlwaR1z/s1Ly3fchpoUFg0MoFDoC/uvZs+eUr9wpTJo9HsH/Fvv3jZWioXNzR8jMWofVOp5AQEHVYQX9/fK53alSsdE1HrPaydOzH5YS805DEdajHhqhvClITFDWljdEs3gicj2pCg9TwsOco3pPWmeayMRbciWbNDP47EAncUoXN4x/l5iYPt5qmkO98ihz/KMx92dIz+k0RImYKBUrSIsjNjiLptouRuKOElHKHYkbr1+OkgCrX/QRFYbQl26juUuuAOp1arw+MSREQONJRDD48YnhKJF4ai3jqSkOo3P1E+PqxqFqxq3cQWzgXpoaYohY1FyrOILa5yGg0rCheAKd6ljUx2woXPIxiKoF4jM8FPa8QUNmHxaXmiX7EtFEVUwYdy5tTUeoDgRpN+VytSYXt8FBvUqe8K8KpnE0fHYgSnq+2f9AZZCH9sqHyymyFxFQhIgYixjnjyWi3sdJXQs7zCcYEALMTbmUv864H61BzcBAD39+4wlig/GECBIYqmHNxCaEiMAVey8nQdmBc6gTlUbLhb97CIWzEev6X2OOylX4Q/pZjL9vJc6N7VIinivi4PPIJkKms+TSpdGxr2QUv4l5ikzhAb7Zejb58t8gRInoNLgVOtzp2YyZNoPHW0SVM5TWH6Euf7TUBcxvPcGMzev4LO1iSeZhCAe5yebgE6uZAbUGU8jFxT1f067PYEvCHLRRuDE+nsnpMbiG/bhsPrptXr5ReGlTy13GH0OsQc30ggS+rT6b2PeviBhVTNdHmBNwEhebQMfQdhzfu7TUGg8jfiudgoVZZauYVTqasrJnpUKbKK0U4+TtHa20DivYlDiX2IiNpxY8Tqrxd2x+7TtCfj8qtYZQMMCY+UtY+POzQRaDgy0kJub9RHh/BP8rCe9vfvMbli9fLlVtu7u7efjhhyX7pNraWons3nbbbaxevZp33nlHCkD41a9+Jf3e7t1n/ff+K4T37vtXs3Gmnn59DAmBYdxKHV6lgYLOAfJ6oriMOnaXWrC4QyytslHYdXaRduoElKZmHEE7HmUfT6rfkPS4p3G5/0Ga3Km8tO8Z9pZM4qXLr8OjM6L29xJSxxNVqPnF6k9JZIih/Ajb+ypp9J6+UYqPoyQ2b5CewrGkDTtZXL2V9kA6rmAMYe0wdeEkRNOa3GAnHrOJPl8MaQo7E9VtFBecZI1mNn1H9PSfSgZLEavAgpPqcJpou89q9QNsUM1lMBpDTEBP2YQvUcQO0ueFmq4c1mf+hg5tMvc1reKrpkl0ijpVXxeLGvfyfsFCVIS41mhjWD0stUMLVEfR5PrYlzSBE8oc2vtTcR5RYAx6eX/t47judhPMi9Lz1RX09R8lxhtiQdq1KGPkCM6I30ngxEr6CxcypI5HxU6WmJ85U4EORVIYCv4WjaIeq+oDhoP34ovIQ4OqeBXaUYkYxiWhyTLz6rZmnlpbJ0U7Pry8jAdXHpcmZw8+sJDVx3rYXvV3lud+xYcnLmF7lzxtm2Low+ESfZl/qAlVC36W5h7lQN9Eut0/3FyUBgLcM/sBBLNMBMJ+I0WJ/2S36ghtG/eiPtgrVX3Eiepzr7uEo7sXMxKjllLf1M4M/DHNDDuT+f3uP0hylisdSq7Q64n/XnKPMxylyRdinFEtafmcl5spHzOB4U9PniG5EgSwLs2VPFL/szY6/wrRKWDgtWp0BTGS3lWhUeKpHmD4I9mNIv66UvSl8fhb7Qy9VytphHXzMjiYpmfA6WNvyzDfnbrZxBjU3DG3gGumZJ8ZhvrnrhYeXVWLRqXgH1dXSAlVh1vqWZz1HXOzC6k/mSpd9yJ8Ch+utFouyK2RjlfB7pdQ+LS8mPYeUYeVVL1XSptLju9DqfDTHxQ46VOyxq6B5luZmNTEd+0Lzry2FHOAv8z8TprM9vv17KirZGLZXmJUMqlqHU5FR5SUONk0PhwVAx2ivN8by5UJDtxhA4/vuRdbIA6rtotF6nqMIflcMRhsjK/4TrKPCwXvYfHi239wXMUBv3Wt6/jL3r/g9fm5cOgqxpe9g0H3Q5K63alifX8cC41Kxgcy8A7lk5BSgk/5IcYkuZP0YxAjuOtOnIfbHaVX4aVd30NffB9/nnA5A9VfYhtJJTe3CqXy7J1dvLkc6MzG2ToZVVjLisBovFEdlxZ+jVnjkjYHs0wzOVkt8Oekz5jQM4UFPhfnsgEdQY5E8jgZzWGZYi8mwUMdeTwbvoYdwXx8kkO5jIXqOiZa6qmPKDH44lGeIrrx8e2kpUU5fixLkipp8TN3ZA3W7PEcHLoOlUWgI3KAlDQjGZl/k2zOlIp4ggEXCpWfnp5CGhvkIodSGaCkdBe++mUMdZZiSxBbyRH6lWb2eLKIFbxMU7dIO5fw8uV8+lUvkWCEmQUR8jt/SOhEpxaHzsiO1EJUnQ66ywoJWXSk97Rz+crXpOJBXEo68274uTQ4ONLfhy+vjJBW/30eSJqmiBVur3QONYQTpbXaiJ9phsMkmgapMjRS2TsNBQo2BvLpjMhFjzRR+z3mAzKT99PsMdEyOIFYQyzTx97MzKJinv70fZpPdJMiiO7XcFzrJFOACcIsrrp9EatfepKWI4dQ6Az4i8cT8ruZq6thum+zVBz5LnUcCkuQzI6LGBxJY4emDkGhJBKrx+ER7fg8Uveo0KJncEQhJSyOCqXiCjnpUQyRkp5BY3IJ8YNt+Hpl4n4aYvFpVVBgU4bciRRR6RriDns7f2uPp8Zx9v6ZHlLQpYpg0ClY2rWGXkwIueOpd5rpi4alE3SCX0l6WEmvMsJhbYiQgHRmzfWrqVaG6FVFUSsFJiV4aXPr6XTJ/55rEpP6nFSFMvCgIWJQEiqTNzKCLwwxai4PHkAflqsK4npZUNjH8foU9gRyaIuIIVMCBpWHT24uJiik4wpHyIo3Ygl5eOild9nozcUvaJhtqiM/YmPs2BOUZ97HN888IVV6lSoVP3vxDSwJidLfcDiq2bP3FpYs3v8T4f0R/K8kvFdccQXbt29naGhIIrgzZszgz3/+M/n5+T8InhCrvN8PnvgxG7P/DOF95+fPMaF0kFUlFXR0Otgal0NBZxsPv/Ei+0aX8vm8y+hOSGXErGH2MQ8zTniIK1/FppwMVhsWogkGOL9qB7tGMknOcPKS63kKvB04MfJI4DaWrl1LmmeYoRho+EMsz5geYUiQB1tSB9q4sGoXEa0BpVLJ+eefj5+d/Oboa/TZxuDrvgJVNESgNJ7oSAB1r5vIqcGJ0yi3tfDnHa/Re+HFjL7zMla8+zdsnrPHQkwe2hAcRaJgZ4q6E40QwRm0oncWUBQdoDmuQzK1jxkcjzmml4RZT6OP6HD2LOCr5EI26qeTHurlyV0O7vKJI3c/xIXGXvJjdknDdKcRFhRsGzWO1nY9CluAC/y13LZzDQGri8E7hzC9l8x2pby4n5f5S7ThKFGfHaVVDgz4C15WIy9EVoWPPxjqOd+/DkfoKgLRU76V0tDgWee+Dncd3pCbfMtYtIlmTHMyeLK2C0utjTEoecgQot8T+N4wXBSTxosrYJDI+vL8tUwL76NhWy470hbSqYhDE/ZhDTmYMbyHTJMGv7+Eo6YSdpoFApEoYzKsUqXS2/U8Pp9cJew5uBxTmx6Hcw8DfpkMlVaOZ+GdD0pTwIHvfkVHxyEUPfejDBpor3wCv7WV949ezda+yVjDAguCam5QCtT4lFQalWgVgtS+fU3ws1IVQqtTEW/U8uzFYzDX2bFGo0RsHgzjU9AV/Xun4L+KSCCMoFb8gDSPrGrCtatbItXqNBPBPrcoXkccL7oHD0dP2WaJEKuh103N4e6Fo7DqzxIfEeLrEDXaolXWvyJN38vUcB8WZZDssmxWCau4cfyNjFEP4Pi6i5iu2QT0/Rye/Htq3DqmxXjOyA2+j5GggZ7+PF48cQPBiIZU5Qi2sFEiYeWqbm6d8goGg+N7zwmePHoldu9MYs1+rIGjUgiN+Njr22bS4czBqHZLOvBhXxwJuiF+N+lF4vUCRsN8tm61UFS8GrNZJspDgyVccsk3KBT/3nnZ172P3275ORfFeCnXh6Ux1kXTt2If2c3xGrFyDMMhgbjT4+//Ak//KPqqrqJ42af4QydQKg0kJS2lt/drSecpwpJ2Cy82H5d0qiIeycskNtREWuqlpKZdyrGOrzjcuZqNwy5aAkp0IR0LOxdSE8j5QTVSHKi9xnqcTQnfUmorI82TRpAIDQR4PfoeMcLZ1aAnksxvnU+wQyvrs0ViJ7q7tPq1xAheztMcl84LETq1GMrlZ8oU8Rj56O/PoaN9NHFCI/aDZ94VsifFM+PqKzhZ/wdCIbFCKR5PubrX3TOOE02zKczrwmN3kZV9GIOhn2g4hoaVj1GdZSPO3cx3gRJGorKkI13lYK6ygZXxE3B2iwOcSn6mOCxV4szDopZUQShWJCennmjQT3zvANk3PMAdoRGJXP7q6HYmGZRULF3OV089ir2/D21GDoPmBOl6OX3Lnqos5lV3DFWEWZq5iQRfgHpbCSkKJzGKsw4sIprDcWRWzGV0upXqLjsrDnYg4OOhKS+Qauxi2BfDnu5KfGEtx+3L6BoJIkTCzFc3kKr8YXLX+PHjOWfJEr59/glO9A5IjjpxsbGcd+WNeN9YSknwGK1CGg3Tgghil6rqGjROgX25pbRmxuMKW1jQsIeEETeGgJ+ASk1LQiYjunzOcdUR3PEVm+ddxOFRFQiRKOoBNwabhxifk9nOOvSRIAq3g5UT5hBMzeJPJTksT7SyobaPn79/SNro3j6nQJoxERFO1hMdG8dkRZCJb/wFgyBw3Quv8/jadr48/u9V2vEZFp6+bDyKbi+fvn6Ug5oQ6tFhtualE+O0Yz7cz4DPgFYRksI7vFG1JKvxTk9GbOmNr6nhRH+cdBolpqiIHRmhzafj8rFx/Or8yVz18lYahuR7j1YZxB9WS0UTf6yG4Jg4aRI1rz9I77FBqfMjdjXUhKV5mGz1IDfMN+JvU2Nb+z6FC87l/Jtuls/X7s85Wf8gTqeP889r/Ynw/gj+VxLe/ymc0dIc+AxL+SLQWfHV1dFyyaViuUS6C+oT/Hw+cz41MWNYM+msCb0iGibT08mwIh6n3oTZ42b2ur18u3QOBlWAWw99QLzbT6cigzFHjxLTNkDVBUmUmlppd1Xy/JhLGbEmcMHaD4lzDjF97nxGTQDnyFreaz3AJqeaOLWR5L3Xs99wlkiKyHT2kRnV4dPGYvUPs6R9BSUtDZJHrva7L6i9+6/YLPl4zP24TfK0vMnv4JbBD/Gkm3kncjV+8c4TFVAFzYQ0DpQhA7FDYxGiaiYss1Czqw7fSBpKvY0PZsXSaI3l2bdfQ5V0LvdrBOm2M18YYn00XrI3Ej1ZBwZSae6dhT4URB0OSAl2qwOl0s9+jokkcbhInFr2DhP1Odni28mQv5tJCePJNqzE5ypHb7mF/WEf94pRct+DyLuWG1u4zyWGMZ8lYeLlobSE6R/oY1PPB9LXrJpESq1TcYVGCEeC5FnGYVRZ+DNe1pwi0d+HTuHj52PfYWxiLVt3XsSccbP55T4Bfwju8XiI2I8Q9ovaslOVAIWKjAUX0pRUwRVT88gwK/nk8V+QPHMn/hEt9V/lS8dWrNDrlEEWpjQwyjIM8x6AmfcSGvbS9+JBogEBnWIPLlUR7ZVP0aMI8Oe99+E45TiQhJ/fpR8hjQ60Ji07PbE81zHjB8+93GzgnI4oWXGdLFPfhaJoEZz/dzD+3/d6jIYiDH1Uh69WTk8SoSmJ4/fdA2yyuxG3DTNLEkmy6rm8MpPyVLPk3/yDxwhHsa9upt/p54qGToa9QWYWJlAS7+P9g/14QwbSTfD5L6aTmhBD0OZkJHCI/uZ1OLqOEdD3EdH4MVizcblkvV+Py8jJriK0QwVYrP0UjDqMVu3glaM3cqhvPGXJcHNOkG8Pt7ApOErSaP+2op+ixKfOEMSv2sfzbZ3on/1/hkXl4s7Rb5OT0CxpZEVotWn4JZsusXoVJhRSM6rwG3JzR/3gXO3t/Yqm5melIJXTFeSJEz4nLka2tGtp+TvNLc9LnytVVuJiL6Tt+AFUhgEU0VyKx8/lxPpxNB0SSU6Ugil+pp0/HXOslWHbHmpq7sagz2H8+Pekx37m4DOST7L4mielTGRZ3vn0unt5tfpVSSurV+mZ4JtB/J7jxMSOpd8Qw8pAiWS2Jij9REMWLJouzlN0SAN3otVUY1DH7sgYyoQW7rR+Sosrm8GIlS/DsxgWTm3wIg7m+FUoA3G8afbhVcCsiJ3RoTAl+lUcUhdJg7cJia1kZx0lENDRo0pDtdWGu9uAUhci7JM3s0njBkmbPIDdnkTN8blcfnklB/rMPLbWz2mJebzgZl6Cg8Xj3kIQ+vEOLeJPcb9gZH8HPrtAvFEjyZu8QVHaJQ++iliQ7idjqJo4sxn//q2kL/ORlN5CU1UFvbYComoNk8eO4ZwLL+K3Jzt4r3uIBbEmXs6JZ8Wj9zPS3YU1OYWBrNEEXDaOh1K44eKlTMs20TkQ5rx/7peGqj45f4Ty0XNo7h/h261t7GzsIlM5QpLCjSeqJqnyXH5z7lhpwFP0cd1eP8DJXifT83R0D+zl5V2xuE8NdJ3G5JSDTE3bwYmWsUTdKVJlPlcxJG0qRAlgYoKVQ4flJMlsfR21kankaNZzi3OvJB95PukyDqYXUVjlkiraH01egFsrD+Rq/CECWhXKSFjqAkTEeEdxbVUpyOlp5WjiD+9Jp6H0BbmwejsJXifLZs9k4px50ibA7Q+x8PntdNm93D47n3sXFbHo+W00+AMEJiXKk2eie719kOVfvc7cc85l+uXX8lZVh9QxGuhxSUS5MNSKeqCeWbNmMmfOHI6sr+eLdet499yZhJWnjk8ogmbfwBk5isakxjk+jqheifrwEGW9Ick27ED43y0FoxoFQiCCVa/inRsq6XX6ue2Dw9JyHpiehGLQj6rFieCXr/uIRoEi8OPyCnFmJdmqZ82vZ+F3rqGm9h7p6zrdLGZMf+cnwvsj+Inw/v8R/5F43N/YKPbH6Lz9DqlUlf3UXYy0nuSyviRqc2W7mx/glFeZIhIlohDQ+v1cubGe0q7tNBelS7Zd213ZKAJOohVxtCblMHPfenqyhumIXcJQfBYptlYC/nfQBBql+oW4IP9l7F/QHA3ym1olYUUET5oFf4aJudUbqKjdhz+tmJDRgLa3DbVzEKs3giNhKhq1HAwQxoczbhdBjZqJ+w+Q39JMwhw/K3gBW0wLQe1Z6/Q4g0OapDa5/n0SP6QIEwruYumOTxFic2iffR9WlKQhcCceqYKREOfAabFg9Bl4qU/gsLKO18OJOKM6xgpuzlf1kR2KZVRUXij7BDu9tmpO2vaQY7RxcZac0hOIqJjhfYd+pYJZ9i4eshbzAj6+JSjdqG5R2Dk3O43cilyG/vE5weZ9BHuPs2dCJSMhUXcqLpw/3CMqFWqKrJMosEziF7gpGtpMjqsZp8rMkDaO1FAPE88bYf1ICV81LiHNqqPb7mNuUSLPLyvn4OpWGvZ3EvDWoo8ew+mVhyX0RgtL77qPxv27ObphDaZ4PSqNhZEe+fuCwsKMRTOZpN8JdfJgUzj/IgbaryLk1KFJgpjw7/DbshlUX0FH5ZM4NA62d05lXet87AELWqWPy4u+JlE/yCtHb8Ib0rMwewuTE2J4qmq86PXOFU4NmWEl5fo1zLK8jiAGBlzyFuTO+j9eA6FQ6Acphv8ZhB1+fA0jeP0hnuwc4PPDXVKd/TkMTM2PJ+GGMoSOnfDxlZBeAYv/LLl2RE+uw3Y4A88p3WUfEZwZRiZWprFh7wc4M77jueqfS5ZyE9NHuK/kWzzhY0TUZwfe/hUJCQsZHt5JOOxlYOBcTtbFolL5ENI6eaP+Sqlyf+OUXP5wbrGk9X9hr40NDXZpmOXhqS/h81RR7zHw171/kMjdtVOyKUuzSJ6axzuG6BywkRruJ18xgCuqZTBiIFthw6oSb6YBFi5MJhB8m1BIrhYX5P+W+oY3UChsBAPXs2TJQ9LXPZ4Wmpqfp79fDlIQK5V6Qx75uXeRnHzOD0hxc/NzBAKD5OXdg1abSNMndURqhjBnW9BnmdEVRRj4+ina2zUMBPMJJ05hwewMyXYuEgiiyTZjrEiV1gB/fSerm1fy/7R3FmB2lefavvfa7nvcPTKZuBsBAgT3Am2BllJK21Ohcupy2p5TF9oeSqEGLcXdPUiMuE1kJqMZtz3b3f7r+/ZMJhMCpS35kbNurrnITCZ7r21rPd/7Pe/z/njkrzI27mguqr2Qi0s+zQ/W9VIUG2Fe1E5faBP6RIythVvwpGwM9X2ENFpW61tZoGnmqUgDTdoaOYb9j/obyXWl+Frvt2gxZC/60wptXDvXSev9X6W1chYLe85hhzHGqyZFWqimxnVMSyiUa90o5jbWZSo5SA56l0KwxsHnHvkF2kyarRedht9r4YxXs58b24IYw4lFJJNG9is1bAtnF3QW4nK7epx6cxefXXYzHm0e3+z9EfqDPmkneOA/VhKOxrnur9uIpcWCPU2hFdYkdqJVMtjdeRhyNtJwajZybUtsBX+LfxxLOkVeLELdzAb64mkODI1wya5XscWzz6UmlWTAUEpRakguMB6MzcVqs/HE51dy/R3b2dfr54K5pdz04ezI4HH2dHu5f3s3z+zqIBjP4LJb+djKau7b1s1h92SLy5HHVqTFnNmFN+pkUfEuTq1qYfn8HxGLDTHg6ec7z5jwuw2camiTz/U4xSWHmDp1CxtTJ3Gr9ga+fPgOvnL4r0Q1Bq6d9UP26aYxd6SPa3wanj5pMbtJcTA0+b1SbzWhF9m9wYnPomnvEOlghirbCIrNRHdxOWGLUUZznrN/C5dMr+W0s87me6293NfrJjp2TEudNk7Ns8vH+cCwh5RRy1KnlUOhKJ5kCkfAyyUbHqfi2s/xk36vtIbcUeUidHA/O3ZMWE/KyspIt+3jpiXnM5JTQMVIPwX9XeyatQQiKUw73SQtOhKzc0CvsGJ3kF0DPilerzc6eb5aS2eLh1SJmYxFh67VL+8ro9WwbE01t6+q54/r27hxXTtKOCn/3fhmkvB0J6c4SOcZObPHx+fPnEvj/n3ct7mDgYyNUlc3g+EC3NE8Tq5NcGXt92gcrmVO7UqW1X8ClytHFbzHQRW8J5B/1C2ZEeOt0mk0Y4Jg+LHH2furX2MNhfDYbdx3xlnsnTabvgLhuMpijKc4rXkrC5paOe2lZ9i8YhndlZX40kaejM8gcEoFmLIrUUM6TlzExRyFffj3FI4e4hTtYgy92dX2OM3OfF6edxKmaJiPvPQw2vFGu0xGjvzVjw5m6xamGWjy8/HbYtLDZowmuODxR9Gm03RWnkl77UXk5viZumIDO/sdJOJa5m5vZlN+McboSeiSNiypERoGbmdbxcfRpPPEk0F151M8sqIc6lbxqdY4brsf3bCRTzD55ChcbM6MhgFNBpsmyrmGJixjWZIlkWEieitenQVL0ou2pRWNAvXVJzMY1bFOb+ZlpRIDCS7V72VGQMMS0zK+oAxyKJ1DribEBYYD5JOhdus2qg4fpjvHxoHyAvSKkdNLrqLJt5XR2AAuUyFRJcyQLxs7ZdE6MJlzGA0exuxwSkEQ9nkxW+x87Le38v3nO7l/e3ZIQ45Zz7NfXCVX6IKIP87og4dIN4/SH2lj9+jLBBKj6LRGUql4tmakaMmkX5+xevp1NzAvt4fUU//NSPS/SWRqUBhB2/YDRhvFa5TBX7yc5gXnkbP4Nqz5TfiTdm7Zcy3NnskLrKnGHr6y6pcoGS33rL2Bl6iiMpniiqCoryqcVPIEczO3gcjBvfI+qFst399ia91us4ksNlHykAu0F154gS1btnDmmWfKWL9jicfjclx3IBDAarXKJiwxmU08b6IZ7XN375TCUFTff3lGPcteHZQZs6apDvICH0fjbZ34LGU0eJOfJJQSgzZSGLU72ajJwa0JMS1Vwiv6/eSXNGMoHOBn2z9HPG1gek4L1zTcS6kuhm1oATZlFsXnriKWHMDr24HZVEFFxbVy6tHuPdeSTkfp7ZnJ5r5TeN43TUbqzUvHWeN3klMeYvZZEfKnrOL83+3DHYpzQe0zXDptHX9p/x4bDpmozbfy9BdWTR68IMVqWIrlzs5OmQsuEmMSiQTPP/88RqOR6z5xEb09P0OrszBr5v+yY8d/4w/cTTBQwuzZVzA49AThcDZqS6PRUVvzBXncWu2E3/ONiPcGGbp5twhaHftJgkLLNzCks6NqBcHkarzJ/5z8GZxbgNYC1h2XoVe6aTVP49GyaWwOBAhpw1zpns8FkQ4+OP8G9rgmzn0GUYHtbyeiN9JaWI6x2UOma/LnW69oWGnr4/bYV7jf/Qv6krX4alNctjLBTJMbTXiE4OY7+aHFy0uGYhKaJPHB6wkFJs6T1jToxXtCxD4cRV7cTXWyi01nniVFyJLd6zl5y/PyvBbOK2YkbwqPJURCiYbZ2n7m63oQrYv9rtmsHxQyT0OttZv5ORke6q+SjZYneV7jnGXTaOmMcfeCOcQyaWqDA8zsHSQ/MoA+loPTMxvFNoSt4UnuTy9ge/WpYqV83NekeqSP05p2YkglpYQbsufQkV9CX1ElHpG9u9ONM5aW09lE5u5jn11JRe4xU+zG6PdF+Nht22genLAlmPVaaW0odZnk50tk9oqF2H+cWkfX4f+lo/MmhiO53LT7yzz8+UvItxl58eAgt607QGOvG31Kw5r8rUyxdaPTWpg5I07ncCffc/wQv8aJK+Xj93t/yGn+rUQ1eq6Z9RNezV1MTixNrS/NjkKdtCpc80qAS86oomBxMTVmA/FUmk88tJcNzgzL2mK81jXK/HiI08NimIuBsEHDvats9Obr5TVp5kgv5tppbA8cX8CPM9Vi5KmF0+iPxvjQjkP0H6dgao2E+MCudVjiUQzuAZLivWB1sG7KHAZyCjDFY3zk2cdx9e0hZrCy5uNfZPHq5VJE3zcwSqFBx+qBND/f0MaLg14aShw88rmVtIWjRIUdTIxXHgzxpw3tbHdqSOSO5YinM9KSZ9iebXQtc5k5d1YRf97cSWRlsbyWX6OL850l84ikUvz1phsJRxLo9TH8WoUHfUvlRE2dkpD56xaDlr9cOZMVMypVwXscVMF7AvlX4kFCW7bSdc01k37WMXsBD65ZyUDSzpqtG5ky1E3R0BD2YJBnl59Mz7Ra7LEIh5L5rC9oYJazk70Vc0kpWlyBfs5bv44d02bQNGUOVW4/l2zdT9SSrRIKq4EwGykZHzG9iQcWrcZjdTC3u4UVrY04DXq8yazI0ofSaN3txEoq5VacQJewYvNNYUbTS5gjgxycdiUJg52GpjuoMg1Sdeff0RUU4HngAXpv/BUvLVhF1DwDbbKFGU27KOsZoLXucgZKsuH9/UU6rolDwRQfzsKXCW3bwu/iX2MzRsQ8tTbSNI55OQ2ZFBfipzIVQmPoY0SvOdJ8Nj7Aw3m4h3R4gC5bHY8VrDninVum66Rel/V46pJpglo9D8TmyYaL841N5GuyF4h8vZZ00y4S8TgLHKuYmrdC2vw0WkWOORUVs55wM7u9rxCOZ0ddKlodH/z+T9DuSNK84VXyTKXUXn8qXS49Z/1mHXlouCcvH1ssTc7l0zBWORi9/1B2K18B14V1xIYCPPHgjbhjvZi1NmLpsNwizjeWU2efi95mYc9II4Fgkyj1ym5p7fNRtJ4MGl0E3cDvGN0wEc+2a+7n8eTUM9vyJCc5/0LonG+TrLuMH/1hDxtHjXiVDEaNhv/UDpI3706M+Z0cbjmDH3ecJxthzq8+QEWvnYivjlm1r3GK508U6ON41vyGW9Z2kE4luMqygZrAVnk8Q7mLuWV05RG/oYj6W7Vq1SSxK8Z3C5En3/cZA/GMlulmH2FHBX8eqCaaSMut4t98aB6rphYQa/cycvt++bzrNJ24HA9imppPuvFpRpNfIZoSojpDbt69HAzt4QnE6z1BscHKxcZSnkz4+LmvjHhGh14D19YWsVJjomx2Hv25OpnhO73YLo9djPAUj2B6bg+trb/ksX1p/nbgw/L2piQUzpcjgicsMObcXvqKivhzf0KOd15QnmZbd9ZjfPf1S1lRN9kKkozHpe/6WNLptBxxLgbiiObaK664Qi4KBIFAO1u3TX5sGo2enJxl1NV+GYdjDm/VQjL0u10kB0aw1ETRz5oHL/8IW/I+0hkb0fRczMpr0lbRHvkJ4eoV5DqMshosLtRW7ZPk6G+duD3gnvz/4Mn8NXzA/Wf22Su5peLD2BMRlvVHaLRrGMjJmXwQqTSOdb0y0UEgsrBPj+iZmRD5GHHSGNBrwlyd/xks2uzna5x2vZkPlBSgTSn8pPpbFNSfxQMbmnh4zyCRMe+9WKatiOkZFFVFQ1wOMxhHVGZFcox4H9SF2jlr6EWeKzmbNlMVVcoopxnbWbBgwZGq30hEy3OZ2SQUPeY00kbh0se4ItyHecTNs8tmsKd+wmIiqBgdZEq4j0bHTEbsegq9UTltM27QogxFqRwYJdcRwJBKkFIUdlRNl9v7hniUsoF+BlxFRBzHiFmxpb59BFMoxT3XL2Vh1Zt76n2RBF+6bzc9nrBs7rxsYTkWw/F3XcR73j26ic8/EOC1zhQFlggfnn43nqiNu5oukztBg+EiubNxTcN9WAs+h6LL4VdDI6RLrdKTLc6hpnScZ3Z9jRnBXQQVCxctvYP9hmxjleD0PWFWNEVx5Oq44jvLZTrEzucP89rDbdnIPJHEYk6wWmMmEU5iyzGiM2gZHgnz2EILB2smcrZN8TQXbglhzDXw2evm8cKIj22jPhxGE/kGHR8ryydPgYceeoi9La2snzqXlqIKaQlY0nGQ5qJKvFY7BX4Pcw7twuYfpal6Bi3VM0grihwec/aB7cw5UAnR50lEWrE4XVz761sxHZW+JHAHY5z6y1fkYuTaldWymbllMMCz+waozLOwoDKH54d8/KhvkPDYacOSzPCfdhdFGjBsfpCO7ZtpVwrYXzeHfasmxm0Lzt/8HOXR8JEhGfuTRWxLVspUiOS8XPn/dDjE8AWrVMF7HFTBewL5V/Pwhn77W9x/+CMag4GMmKBy1BSVSbdvsXLN936FPRHn3H0b5Uni2fh0btL+moT1XBpdfQx31UsPrQiy3lbeQL23V4pjcVax+adiChej0T/EcH62yS2Sq+Nvs89HSaf55OP38JHBFG3TFrFF00LqqOYdJRYhJ+Qh1zoLj3sKGsVEJh0gHhSVXjh5305MyTim2fOwn3UZwzd+V14kM4qWjinTKOtswxjPdq6nDTrcC7/CPmOFPNktsr7AUvvvJx5n3E44PQeztoqudC6XZJbIfM5xpoaHOHn4abzmPPbmzsOtceFTbJg0cRpih1nWt1aOzLy77INoDVqmJno5xealZvlKXtu85cjW4X5/FVvNpZw82szFQ+vZN2sOma5WbDEfI4YC9hsXcppTyw0/uR6NTktyKEx49xDB1/pJRKI0+7dyOHiA2fmraDj/TBnLM47GoCXv6hms63RTu2UYU2jsNdUgJ17JYQ1aDbkfqkepMbH+nr/Sv+EAvvgw8XR2m6/MMpVlzlPRiUzKdPbitHbwCdyRgyiKnrNLP4ZZl8M2v5dpG/6bgL2KgeUfIRKN4E8VoZDkqoLP4Fh2MZz7iyMnzb4WLy/ctp+gJ+s5sxQ0U7n6l/LPDxy6kGc7J1IIxqk2+HlS80We1pzOAbIXeTFU5CM8QiV93MsFNDEFBwH8Y7nKNTU1coy3qF6Kym9XVxcGJY0j0c9vE+eTOOo1FayckscvPzAbpzaOxZEVStHN2xl9VJgVsp8njVkndwcy0TTDugCGkwoxT8vlrjv/LhsHq+ihizJZmRPNqtOrKxn8yV94xT+TP2qjtI81bi2K6vBo07SNxRGdMaMQfzTJ1o5sfNqfF9dS2OrjCs8IUTTMj2k5I67DW3GIgKWTmbGZ+NtE+knWwfmYLUqLbsKPf7J7I1+56gxmrZ4Qqq/8/S/sePIRSqZMZ9qylcxZc44c2nDkPDA0xB//+EdpC7HZbDJZZurUqbKavu6VD5BI75a+00z6JM4662vYbBOC4tChQ7z66qvSaym8iKJSnP2wpWHvfdC3k1hXmHRvMybtbjTCP663ivFm8tdG4t8iygry8v6COfAIw4laHnD/XPpibSYNK+1pqpWPo9N4uS1+OfOt+fx2ajnPFkz2gMvnbv93Oce7g76809hqLeMRay32uJ8Zng5+Mv0T4uXjP+Jmije4SXpeP7TkpJp1zLU+DUYbWPLBkgfWPFINH+DPt/yJ0Y5OFDH2tbSCUDjCI6svozfpxOiPklthxDIS4JLXokT999NkqWSg7lQ6/EkSR+WICyojXXSZKuTn4iJbO0r1ItmRvyg3SezAK5hb93JYV8STwiIyFvR/dcBAnv9pel0R7rz0U3Kxd+q2l+itnEpbQZkUTMejfNDNBw90YBqqIa2EiVj7ZBHCbXDw3Ky5+Mfe7/JzpYHz8p3MSoR5cDRIk2JEk0zzaZeL7y2eiDP8dxC7LOvXr2fhwoUUFRWxt8fLR//8PF+Y9zsqHb1EMfI//IqkoYyKXVvY1VuKViMSDXTEF+STyZuYfFhpMnBLQxULrDpivz8V0+gBehKz+ZX+RzRVaahP7+a/On7PE6PfJ5AupNLaROmyBWx9JUI6laFfn6LkKD/xtPI+Vt9wDkmtg9u/uw7CKZrLh3llVhEpjZHztw2QH0xh1RTwkR+s4JHHHqK1rZVly5ZTVVUp3/svv/wy3d3ZKZziE9/rKqDWrGf51Cm0xxL8jyGf6JiP+GimeAZZ2rybk6ZPp754CSV1dh756VcZ7eth/tkXcNq1n3rdvxEJMp+9e6f883lzSmQzXTw5uawszzo6DZcuq+JHZ9UTdw/x6C/+B3dP9pphMJvJLa/kr/PPoDF3IkLQHvDy6af+QioSJWnPIZZXwh5nNTvnzCY+tlOcDgVVwfsGqIL3BPLvBECPj6VMDAww8vtb8D/1FOmKSh6pnc6AySqTG7bOnEvabObkpnYGXRoqPMO40xZei8+gggTFusMU6SZXRQQJrYmpmWpCfYWQ2sJwSViUJZkRH+IKw11cN/PnPJ2/VP7uNV27+UJTmpTmEZ7TldCjlFIUM5Do3ksikc0k1St2MJ9OMrKeTDrbcFRYXMr89bvQhidySzUmF5loNiNVEHbmw8wL8RgSmLQ5RJK5NJOPoklzwZR7KHd0snO0jA17fXLIwAVnzeBnoVWs7dVSHB3AkQzQYq2TmYvaTJKU5vhVi/MGn6E23ElCa8CoSWOy2Tnjuv9g6pIV7Nmzh20bN+LftoGhpIF7yy6XjRQf7VpPr0Nhum8/EcXIfaWXE9BnhdtvF1q46PLVR24/HUkyem8T0easZzmaCqHTGNApemyrykj0Bom1T34dtHkmjNVOwjvGKu1OA3lXNzAc6ubxG38srRCChprFtHTuoUDjYl7rYUTrt2J3YV52DYp1JqlMirX99+GJdVNqmUKu/QJa4xoMMR9xY3YYxDgzzc9y6pXTYfF1r39PxFMMtvsY6QnS+EoPzoYfYy0+SDSYxwvbL6dJm0tLNB+LLkI8YZbbvDPiGlZrhmg3jRIQI6UzhRg0Ga6blqS9o0NWgT7D32mhhhc0J8uq+9EYtRnmJrbwlfj1hDFJ8RtPK7Ireamuk88tcbJt70G8ST2Xlo0wq7YENt1EOmnAZ/0mIc/cI3bqfnuApxJbJ93+1NpqPnz+qXiF7A4EZKVUDBV49ubteEfFsNkMO6wRXhaKYgyRey3zNY5JXCtMa6hHyzolSUlSw1VBI4sr7Tw/w8JfthyWW5G/PK+Swb2/Z7RpKkPDNdxjC6BLR+QwlIL4CBpF4aKvfFvGxx1Y9xLP3HzjpPsorpvKB771P5iENWQMYXEQlamRkeyWp8vlpMoSIzzYhEE0JCVz6MiUUlhYyIc//GGCfj8vPXQfnW7vkV0Yce6RYrnICo99Ftpeev2HRGeGZHZhlVlwLdGp38VQbqffN4DrT0uwaSK8Grqc5tAaNBkLc6yPsNT2EN5kEX8fvYk/rcljyKVDn05wydCLrM1dgdvgpOhwL8+7f0iur0l+lg1KknKLj5zqer5p/yGv6PV0FxgwJtJcur6fOTEDNatqiRUb5ejUrkSCZVU56I4SjsPDw6xdu5bR9hYie7ILVkFcb+CFVRfSU1xFvneYG1cuZDBo4pYnt1PVsYFpwYNi2gmGvOvwW3rxa7Q4o/kMZsw8bokfec1rQh1EtGYGTGNJNBm4wL2d6sA2scJil2M2G3IXMs+3m1Xe/cSVCPddeB0DheXMG9nKmU88gb96Pn6Ljc5ZFoaUKmq37qCyt53uwhqiVhNzDu7AbjibTGqURGRTdpmkMUAmQkajwdewgjbnyRgTUBiIc/LCCNt3biWhaHl69nL6XdmdgvMKnPxiegW5+n/OJ38sjzzyiDwXWiwWOThEvAW37biKaOQQijaH29OX8Txny991xkcxvjZILOzAUWahe7ZLLgBydFq+Ul3EFSV52MeHKx18kuR916Ijzu7QeUwt6EK34AaM2jYG97Xy8P4Pkj5qoXtIn5KvxXVByEmZabC/wmrrb8FWxOApP2fDY49yjrKWeMbEfdoz6KfoyL8ViTQmbYqQclSzWForQp4nPVa9Xi8X3aK34IYbbpCfj+ZQlAcHRtnuD+FNpFid6+CCQhd1JNm7d69MphjfYTm8dzcP/ug7csDS1T/9DYXVkxcdmx64i7/vcvNMeqJfZVFVjmxoPNjvJ89mpK7AKqvt588pZbSvl3v/66tEAn5sObmcd8PXKKtvkOeLeDpNi3uUA48/yLeLGvBbHXyzupBVTdvZdP9dNJZP48lTLpYNdXWxEBc27+YPXTl03HiVWuE9DqrgPYGciIkno4kk3zrUw6NDXpzxKJduXYtxLOdvfBt/S0I0bmVYqs+uaNuTOXgyVqq1oxxO5bA/VcTiZIrPxmK8rHuN0eJyCkJJPhJfgdn4Nx4rS/N0wSlscmUbIa4YeIbfNP9MVhW7Sr6NKXU6sS4fXaEmDvg3EYxPNKeJ7XchwkRV0qVxUNLTToE/jNM1DfOyz9I++BDNoQ5mTZvHtKVX88wjNzEUmaiEZveztPLLYNITj0zEEnU76ng070xZMftw70PkJtwMGfJZW3AaI4Y8OWGrzhGh7uBaeYGOlDVwKJMrfXvzul49auM5y5TFy4hHo0QDAXLLK2ja8AoPlVyMPh1nmWcrhfEReThtFUvRWEz0pgrYkyqgMObl5tPszDtlNbHdu4h3HiYVDNLnziMvNLEa98QG0Z2Tx/STTpKWhXhfUG5H6sts5F4xXVZ2w3uGiB8OYD+tgkgiyN+/9nnCfh92vZG5oyEc7Ydlk6He6aT4B9/Hc+99hDdvlrevLZ6FaeEnCGbCPNt7mxRwYsJaS9kVRGN96IzTmHt6HbXzCrC03oNz8zfQmBzwmc3gnBxUf6z43fLEHvraHifU3MhoMEauUUPJKeXoa57n0EgtP99xg1xo2FMZAsdMRhM+6DWGQ+SkBzGn/LKBKFcTod82i7aIg2ZNBfviRQSSovExe2EUSQp/vmYRnv5unvr7b+mW47MnEHnM13I/ZQwSV6oZOvd37OhyU1VUTlV+OX954k45QEZclIQnNicnh+uuu+7IRUrQsn2Ql/52kGQijc2WYbnuN9QZN/Jg4Zf4bu8CpjosXG510H3Qwy5jEm1Gw6y4lgdsMYJHFequChhZYdAzVwyMmZvPld0DcvBIFQpubZgzy1+m5DXRnXoYjUbLi3mnUh7tZkawWV4kKytz6e0ekoMgFub14SqvZVNLhkg4RoFDw2UL4lhErFT5Ilh8PXFXraxQ7dy5g1gsWwEd3/YViwq9Vks8lZFjtU3dLehCfjJaHaUnnc5QPIXfHSGtJFih38PpyZdQtGJIxllkMgb01SV0n/VhXs3ks6z1VXwdu5l23ufkglVUpS6/dROL++/mO/q7Jt4fGi2dpjIcqSB7hz7K7+rPYct0E5ZomqnbDjEvtp3H0ssJ2+ysLnVx29XzefpHX+LQwax9RRDXmWmyTKM4pfDS6YvpLq2UzbfLd76Cd9hEa84UUrNySNn02GIppvkyfKGhBFe4R3rDhRXE2r4fJRHD68jFGIsQ1xv505VfJqMoLGh8jdM3PsWzc86lecZcztzwGDN6DxA3TMNhPf917/mdhiRrLdnz6Id6H8CSChM02FB0emzJIswREb+WIuo8jwfOnE9t52ZWbH+Rtsp61p50Hn57jghCZt6BddxQfStNL88mHjYTSGkIpsxURnvocE6nZvly4pufwuAdPm4DrM5g5dwbvsjUxct5eUMTO+/tw5SEsClEyLmTKXXVdPe3srWqmi2F80lrFObYzTw0b4q8tXsHRuV1wBGPsKogh1JHdpEuItfS6TgGQ7ah82jEYvA3v/kNKZEcJCYnFpion/USD6UWYlJ0zK+5iq+2Z33WBelBhjWFzDwYptqb5rklNpI6DS5F4bFF05huzVoNwv44puHXGLntKxwIn8apTpHaoeG53I9imXcJRtOdeEKDPL/hWjLDNtky7FMy7DWFOM/2Ki5hGxmeybXO72DXBCe958dJafRst5xCylLEvmGFPrKLAE1aizFaSNQyOXJMnAvE4ChhUxGRoz09PSxatIjzzz9f5nKL52H69IlsX0HXfjeHtg1izzVRXOekfHoOWp3CE7/+KYc2b6CgsppLv/kDbLnZ53Xv2ud44Y83yWPdlLOUZmcDl5bG+NC8IgbaDtHX2oLN6SS3rIKaeQvJr6zmnu9+Be9AP4XVddKaNn5bx/LAwCifP9iFXavw8PwpdIai/MfBLhmeKXzfZ+zfgrO1kcPkcPNdt6mC9ziogvcEciJH/DUGwhTrFPoONTP6bDtFXis7XIdpi2RHHo5zIFnI1mR2EtZFkXU8uOB8dE3ZblHTVAVfTbGsKCiZNAt9hzhsLmDImP3AlUVGGDDlkNJo+Ujf4/ys3IZyypdl9FO8J4Bi1ZO2pHnxx5+jqWVY5hJesOhUAr1O1va9QDIztj2ZybC8Rk/uqk/x9J234NNahWsYl9NGxt2LQW8i15JhyCf6bCeLJ73RxMorr+WP6zp5MVku58iLcZGnJ2qoX2Ym7G1kzlkX0aEvlOMfjSaFn375c+QP95HW6ghNmU1Cq2fmjOkU+IapaJjNYEcb2598JLtCOApxohn2BjGnsxWCjFZPzey5ZKwODnoCRNMaHonOIqwxsjS6j0sOvcCc9l55xCM2M1vrSjFr7cyecwrJ/jgHhjfKznVRTZ6z5qxsE9v27WSSKazLshV0/3PPy5/lXPNRHrn1N/S2NGGPxFjR0os2k0GxWnFddhm5H/84+qJC0rEYwzfeKKee5V5zDZmMkcE/7mbXwDpa/Ttls1w0GJTNba7iSq74r//Gnpcvxq3BbWdBzzaYcgaDK35GYNQtq4ni9wfbW0hEIxTXTadM1499501s3e9h/fDE1LMcYxjX6hGcVSGebF3DI+0XHGmOnBL1UkwhWy0ZgiLYLSMqVm9tMMUp0wq49eqFmHs3wV2XE0sm+TuX0k8hy609DDjm09rvwUaYuv42fBErnTU1RywZJpNJZmeLTO3rr79ebvnLL7E9r+hJZ/Tse6mb9Y+1y6tmRUMuaz7egGHH7Whf/pq8jVA6l2jyaiLpNXiT0JLKoK+0M/PUcl4b8PGtV7OZnotMZr67aipTyix4/nZA3p7pimmse7GNJaMpWjNJ1idfxtKzU27/G22X0mgr4UVTlDOHX2JqaKLRrto6yiUV+2XM00jUwgNdswmnDNTZ3FxckY1Ek9ScAgs+SmLdr2kajjOqK+bWRZ9loy6P2sFuFrQ24oqEMIz0ow9MLD4FDpOdsLKUuK2azspeFsQPcU54KelUBZYFhYQvqGLN1iY8aVjRupc5ve3ynCWqfD97qZO/dQ7jTCZ5qPh5ehJefuM6lV32epKKTp4zlhrMvJbIfl5+UVJEYUpD50gIRaPBadCyqFjD2ttvwd/UKF+vpNmBNhJEI0L/x0hqdbx40vk0zlj0pu8TTSBBdXc3pw/vozQZItKyX0Yl/uHK/8Rs0NHgHWazK1uVFeJ55fa1bFh8urQZWMJBPvDI7ay3ncqUTCE5aQ3mjIZebRptqZ6lXRH2aPXEMlHCZW14nE6mte+juqdVNuMKvIYK7io5j8rCUR6Ofpuv5n2ep+rPzJ6nIjGUfT40owlqTYPEwynO63oaQ2asGKFo+dBPbya3IJdbbv4dqcZtaGMRNEqashVDLD3ze+jSNeRXVE+q8H/u+X1UPzGMOZGhZsYoqzXfYmdtgohZodG3hFvsn8OvszLfkGQQE33xCfubORHnt9PLmZtn5Hs77qYrnUdt7iymOwpYlVmP4r6b0tIraG7OZ/26TRTbFDQ2P/muRp7MO5lndOfJ29GmMszpjHFmawSDN01Cp+Fwvl42kImpnLUDCS7cHCDg1LHJkOB8xYKpK4Ld4EGfDjCarODU3J8x07BFTrrb7qrDkIpwyFfH7xMX05MpkCPoT7Xu4geGP5ITjuGz6emNVtCQbMeNS54LZnFIWtNSy29AP9IELc9Nen88Er+C/dRjiOeQMA6jJOzELEOYEgVc8ZELqZpaKrPoBYcPH+b222+X5+TVq1fLBaXYVb3qqqukbcg7GOa1R9to3zU5yzun2MKpV9djz0lyx9dvIDpWlV39sU9K3/2zN99IKpmkbtFSepsPyr9/M8S0umQ8hqOgiCt/+Es5spvenSB2QsWwpOoJi5CI7Dtr+6FJSRYCkUE8/cl7CUZjKPEoc2bN4pKrPqIK3uOgCt4TyP+vmdahHYN4HjhEijQPG7bgU8KYtDZ00WI2F5azvT8ku42/qHuIm2ZewWb3VHSdQTkZJr6yCH0mKUXhOBWZMGG0uDVGTKkoMcUgq3kfiB7gxjM/iHE8j1Aw3EzmlpPoDZpwXPADHKs+TubAk4zc8SNaA0a6I2m6Q9nHLqoRL+afSrNtYhVdFhvgmxfN4/yT55PY9wQju/ro+N+72TvnehI6IyFthsdc4oSXvUBWhQ/zQS2c/dHLqZmXDWI/lt9veI3AzT8lbjDywpkfoj+3iOLcXF5aXC87wAU9B/fRvms7rqIS6ccSXspxhAwWjRe6sQB6QdJsI1I5ldZMIRsStTIIfE18Oye3b6OusIztviHCpKkc8THHE8b2wat4YtDNgE2LLuhjRn4OSytqCfzoJ/L2XB/6IFqXC/etf5DfHywvpCPPjjaVZl6/Dy66lPlzZ2FbuRLtURfA4yFO1FFfgNu+8ilZrT76RCpEvDgZ1y1cgtbTQezmU3ilr4x9vjcfomLXRQkmjXIBEs8pkLPehYjVGlNUnTOIrdDP2q6T0SsJlpbsQAmlaX+ujsHofB7On0tIZ8GUilAe6SWqNRE0OKWvWojg/ESYc1IBPmK9lUJ7BNfccyGnmswLP+A172X4qWa68Xl0BNge+wRD8Vpi2hY8jkEyR21PVka66bOUksxo0WoVPrZkAc6eAImBEESHGY330JeYzkhyFgNja68ZCwtYcVYV8eZR/K/2Ykjtw6X/PQYlW32MphbiM3+ZvE+eji5/wk/7P08eYHO7m9s+tpgiR7aK5X26neC63iOFukgywJbhpxiMHpbibk/hOSyJ18u/9hXp0Q7FcKYGmKL9Az5jHn+xX0wqGeHLBdtZYzqIW1/L39d65TrsyusupGT0VWh+WnqUj2Ar5tGLHubTPQnp57v4+bspHu6beC9oNBSWmygIdXNg9OgGOT2hnPk8etoSLj3UhJk4ropifp9fTa8l+/m0R8NctXsTkVSc1pqZbDUVkBjr/tfEUmSME597k6IheiTZAT5amsfPp1fQ07SfA6+uJRoro2u/kUjieZRQNkFCsa3GoJ8vs4nTiQ5S8UNo9BCxmwg7tGwonslQUQ6enDw5KraheReLdm9iX/0C9jYsJDlm0cjxjHDhi/dS6B7gidMvp33aPO6aU8OnDhxmNJHCEQ5KO8E4umSCpE5PkXeEG8KjlJpMVNVVEXKWc+1ftxOMJSlNKlwSNfD4MjstZRNNhPZQjGtfvI/aSDPx+vn812C2uXbJAoV1BdndnLLDPZzdtYuWRD5b5e5alpmBg5w28or88/xzLuC0j2X9nh0dHdzx5z9hGB1k4VkKWsdLGA1FLF36DHqdA3p3wP5H5Gu/wz6Tr/N5LtkSktGRkTUPUXnYhqflNDIpI/25Ge5cbSeqyx5zWSqEyeNjyOokYM7ubujlgODXWx5mZXZzJXdQEnMTDtvI1w3jHl3EwcZPcsdpdnxWrSwKnLc9xIL2OJ0FOoad2ffA2rkWKXxnhIaY9VyG+kT2+pFNIJ58Ts6IeMCibXypfB0msag9CmGNas6tI89lJq9nr2xAOxYxlXIkbSeFjpzpK3Fd9BMwuWDbn6BzA4y2w+A+WUF+rPBb9A93MZNDFGZGIFnHVs9lmF0WllVtZmhIR1F9ORWXfYK77r6blpaJxl5BYV4RlcoKDu9zy8+0SPiZMStDypjP4YN+osHsAqawzIg5x8hgy7MkR14lktKTGhvYJHYOL/zyt0jEY7Tv2ErXvj2M9HRRVFNH2fSGbIGho5WOLS+zOqeRCFYqP/N3ciMt8PjnIXFU6sTp/yWz1SVRH7sCUb7RfJi2tJFwKsMVxbn8cnoFPs8of7j1VuKJhByW9dOf/lQVvMdBFbzvA8Eruq0Hb9pFyhPDcFoxmRk2CgonGljWb9vDS08/mp0YVQi/n3IRpvUDEM8wy9DPn+d1kFz+MZ453IPFmscVM2czkkjwsS0t7Ov0yq6JdKFJbhUu0/j469ypuPq3QTycPemIE/TUs7IxVeMCtOlp8HXD7MvZs3ELa2+/ledzTqbJXi8rWmadhrBIORg7OZ40JZ8vnzlNdrEGXnyRAw9u4DfGZWwxpUhrwJSBy/PsXDLHxPwzF6MZH6l0HGLpNN/fugeXw8HH6io5bVsz7kSS/5lSxvUVE8/L0Rxc/zKvPXSP3FYa6myTSQv2/AJZHbXn5kvx2N/TQ8xg5vaRCtqT2YtJQ7yNJQMbsadCOJwuTh2N4m9rZ8Oqk/DkTnRPGwe6sA/1sbRNbFGmCeu1RPU6hvUFPDFtBUGjBnsqwPlt2/jF9f/J4ZJyljmt3FhfSa3F+I/fA5kMX3/6edxbNvCh8y9kaU0VD/3ke4z2Zm0topvYZLcTdg8RTwjRmKGwooJ4OIQuGaBI0ytHVvdF7AxHbUdel4Qzj2hJNdqQH9NgF2aHkSvz15GuLaSjvpxAsJt0JigrVcmYQsezFQwP5eG1FLNs+ix8/XF8fc/L+xOLiKjWiCUVwWA9F7u5mEtzvoFTl/Uxt0aX85z3a2/8GEliNnViy/NQ8vyTFPsHiaxpYFv0CowaLVW6Ipk0EUxn6ImnCR5z7ZxqVJhhUsTbHreY4CaUpSXGdG6kUL/5iCUoqrHyWOxS0joLi87/EGX1s9Dpk7JyY7Y7Jqcc3LybRH8Ib3KEV4fvIxoNotXoWVxyLjMuOps9u4c50DThWxdYFDd/tKXpHx8vnYFFpU5+f+0idt55C/tfXUv13AV84Fv/Dd4u2PZn2HkHGVMOjycvZsehDgZzCqkb7JIeeTGpKmYwodVpGJ01hf01M3F2lXPynl4SyTbCNGMOZz3AKcXI1vkrqQx60bsHMMTCtFbPYO/0xbjzC7E3DqKv1DMqtugVDZqUSCIRqlGRTae1zQdp2L8TEblrKCugZ2otGE2cjpV9TZ00HHxMTujKctSWvXkZJtMK+d2IkqbHkOYzH5vDrh1P0919tKUpg2Z0CII+bOGJ6ljMYGRv/SK2zltF2GJDm0pS13GQQ3Wz+P3MavmZ/1JTN2VGPaWbDrJtTq3MRi0dHeLk/Vt4dOW5sinp8uIcfltfKSvQgh2HR7nm3p0kSsxoivR4DQYMmTTnRA6zQZuL2+ikIh3g6RWLKDCb+dULzdzYOUhqSvZ9MNUd5vnGi9ioLKP4/G/xoicPbzhBcaKPqdYoykA//W2HuPir38XimLDpCA+yaBJzuSwsWfockUgnxbpZzBRJLQPZYQ7jfGLGD8hrXEDlSJKoXoMpMXln6nCBjpdWRJkT2cOszg78/nyqlAHurT2dPWXZ4kJ9Zj8np9YRUKzsZw6NmjlHeh/O4zHmsRNdVMvajv9ke62dkEmRU8TSGg2GRIaKkRhtJRPJCILy0UF+YEvj1+9k3WtW6gdr0cVthJQkT5tT2NMaFolznWkYw8wROazlwsOPootm2JRu4AxXL9XBvZNuM2K3o73gFhJPfBJrIIzbpWfPnDxKIjlM2dWEPpkhaXXir19OQEwmjGcoau9G4x0bPywWzt4umcAwji9ZxP3uXxHPTNibppb0UHrOMh58Oju9cmp1A22Hm0lnUjg8MzHG8qg27WCZ9Q7y9F1gsBMrO4W9B5x0huZSbdrGVNMGnNoBNBpxLhGDexbhzVnE+V/8BkaLBcKjsOferGdeiPJZH4CVN4AxazNJPfgJtPseyB7QUQ2j5NZlbX3usTHfq78DrS9C92a5Y0U6QcZVSezCWzHVZkfWC0KhEDt37pRTZL/zne+ogvc4qIL3fSB4BSKqaTwu63V/l8lw7733yqxPwbDNyWjAyGuxKtko9MrXzpAXgPNvWi9P1iLIXGSFivGTybEqTirXSGJerryInDS6g/savyIjaCQGG4FPbGJUm49RpyXfZkB31HEMBaJ89a4tvNopxICGm6+az9mzSmRG5O9eapUB6YlU9n4WVuUwtzaHl/cN0jGcPQEsGW7jR1cvZerqrA3gn+XvfSN8tbkHh07hb7NrWe6ysT8YYbsvxIWFLnLeoOFjIJbApdNiOuY5DceTfOH2V3mhYzw/VKQBjPKts6Zy8rJ5/OWmmxgJh9HH41T4ArQX5MnueL13mKQrH4NOh755D5G0lr9XXDkpK3lRqYmVFzTwv13DRNJpcvVaecyLnZMzk4/llx0D/LIzO11rjs3Ms4umSTG77fGHZMUt6MmmDQic5jRnFzZSftToW0nd6TDvSuKVp9LZ0s4TDz1AwGBmwcJFcry28MjmRDpR7r0SggOkbdX4gzW87F+BbtkLWPLbyaQVChwfY+b8r6LTG4iGEtz/wwdxd28ip3Q6FfV6dj/3hIzR0lnPx5VTyqXLN2IY2srdTTcQilleZ23UpJNklInXSPy1LelFCY7gc015w+dEp4FyCxTodlCs2UgsfTo7Qg24pR47qlGNBPOqDzGvbC+m1vt5uHs+naGJCqFGscsEEqGGK2bMouGU02k4eTWKoiXpjuB5qYOnNtyEe6Cb/PJqlhddiGXUfGQbclfYS4IRGsxPsit0Md5UOR4TVJ5WRmWxjefuOkh5TCGhgdyiJMMHfyejAqet+AxnffJM9HoFzwNN7N27lh3tk7dxC2vqMK1ZydczFYTHcnfFFvQNT3qxRTN0zgPj4HqsowmMw71kUq8ftyx2XgIWGy/NOYvDyTKSUx1kHIZs/NVONxpfgkVzcnHsf5ZZh47M5Z1EQqOT1ieTsANphYUmAJkYGiUXneU0tPpKerUpHrbGEQPO5lYlucQWorPlEAaDQcbWidxh4SMV/mthSTGIITtkCOcXsdnjz45fjcLmghpCxblHmgzLFC39ySRJrYaLTRZefKKVWK6B8sIIq7sbufSsM/HWTOOaxnYRm8s1pXn8dFq53B0SjUpfbuomPmZvKjbouW12NQscVkaHWjmv2UdHUss8u4Uz8x285Paz3Z+twBUMxdh00QLsd6yBvl2w5n+ygubQc/DAxyAZg4tuhnnZGDvJrjth+22kxUCJYTek4ujyNTTOSMr314zmAMVuDYmGM2nJVYhHD2PwdfKadgWxtdehyWgQAQbzPzSVmooUL9z1GNHu2SJmhvyZj+Oo3Eo86CSvLY/++Ax2WmdJQVYRGCARs6CP5ZGOWwgVe3muoYz9BcfPai70JrliQ5AnF1vpLMpWb0VyT7XfTUFxMQWZFIVrn5RZwdWludS67iDmDBMaqiekCfFq7xJe8Cx9nUVtnM+eWs5Xz5pDaNfNxJselE3TWAuxr/4VOlspUX8rQ699hR5jL5H06JHmaHMoit8UnyisiOhId4yZzWF0osI61s/CtLOzmeCiAowYP72QV+NfId8Z5XCfXdqNBDGjm4zMks8nZOskYuvGpnfy8cSd5NIKovHXYJXNwm8Ft/N0vIkicuKN5Oq6ZFV2EiYnXPoXsVqGez4kLRoBQzHO+JjfeP5HYKQlK27fCCGGpSVIA8s/C6d9F/QTixGPx0Nubq4qeI+DKnjfJ4L3HxGJRGSepPi/iDkS0TM/fC3Ezm4/584uJhhLyXGTx7K4OgefSeHgcFCORIwvyZfVnnP7tvOX1FNotHpeLvoYn3lVkV2ogmKHia+fM53ltfk8uruX37/cKiOetIqGG6+Yy0XzJjdMdY+GuemlFh7a2SujpMYRoer/GdrLgkf/jKGqiprHHkUxTa4yvBVSmQwX7WyRFyrRX7XcaWODN9sIIUTwf1QUcnVpHgUGPd3ROPf1j/LUsFdOA5pmMfHgvDoKjROWj3F+e//z3LN7lIF0dsUuFgBrcj0UhdqxmU2c/sILmHr7WL9qFf1lE6H4Ak08yrpAGW3WWnLio9Rm3Oy1TJPC//SSFDdcsoBvDIXZFQjL7eMPFOXITmwhzl16LeFUmu5InEAqJS/iIvxcYNBo5MX7dzMquUhjJLLfTZfDw+MP30NlZQVrzjqbfHMc7W1nZC8IIuap9hRY+QUomZt9Pbq7eeyxx2QyQF5eHp/61KekKBkncWAjmns+gE6b9ZKlMjpe9H6a8IIWHBXZzFKjr4SUcRbxiIt5yz9D1G/DVeqhp+92OhvXEYt4iAUMhAfNaDTF2HPK8Y3UExnJRpyZdUmKIj4qXQW4dAppV4p1Hh1+/+TRzaK7fYpRK9Mh+kOjaPPs5E4vp7DaQf2yYpJa+NZ929nY5qYoqqUsrFCSVJiaryOXLmI+H72xmRNjpNlO2LteymDFMJ10vOl1jUWCqbkhzl1oRlc6i1cPptm+tQmz3c41v7gZizOH0NYeks/9EStPoc+0yX+zNucknqr5IlVr9ejGRocej0ToBVLxRjSKC0vlZVTWVjPadZiezjvQJ2Nsnn8ylzsKmFKTz6zT1qCNK7RGhnmweT/G/iQ5+w1EBxWsTgMVH53C1+5cR64SpjqmZebIMKnoRlktb6ttQCyjNk+bR2vVdBx+D0G9lbTZAGLAx55RMuEUyUorUzQ9XPhstnFt08LV0hKuDEYJJC3MCDTLpiz5emiLMNgvl93227V91GfKWRg3MmBIcp85QdSpIzEnj4xVJ8P8q0YHmFZVxdLKMk7XJPANDzF79uwjXsu7+tx8tbn7KHOR7AZF1xsmVWEl4zwqwziRxrh+EE0iTUOelrONhzj33HOZMiW7KHp40MNnDxyWr6YQsFMsRh4czHqexW6KOAecU+DEepRlqyUU5bydh/AfFSslmoY+aLLxlVnluCwG2PFXeOIL2f3vyhXQtWmyDWXVV7JezH0PZgXvcWipsdJVMbZIStnQKFE0mslxlJHuz7C3YykPzDJRUG3nqQXTpAh95KaNDDYfP7ryH3GwTM+OKSa8NoWQUaF8JEHCHObLe1oZHaglYoBXLivAaTfybaubaaON6Ib3g9bAdtsZPPvqFpmgIz4jU6duprhkwqPe4qnhwUMXkUjrcZkCFOfUYLPksnJqLZcsqDquHe1YxGfS59tBU/N3CIUm7Acm7NjIZZQemfxrNpQyU3sGjs4mNEs/nT2nCQ49D/ddDakY6YLpeM0x+g3V7Nu9hlgkTyYCaa05OOwx7JYB1ofcJFJJLuEZ5uZE4YwfwIHHYP/DY3fsEjO5weiA0Q78yXw2hD9NkbKPBdZH5eLCnyzM2i90xxfJ4v2X1BjRZ2JsZCEvchKzdZ0sqzBS0vUYGjGSWG/JDvAJDY39K7EarslWigXivD22a0NBPaz+NlStlLut/ld/j/OTj70rdMe7DVXw/h8RvMfjQJ9fVnXHNaZRp/DrD86TU3Ui8RTXrqxhSU2urFJ9cn8nTx8cROuOkZie3Zqb2hXhyqpCfv3CITklR/z7RCo9MbTpKMRkn59cOptZZZO77wWeRJI7+9z8qWUAt2iGc8fkXPLpcwt5bGYpvRddTCdauj/xKYynn8alhTlYx2Nv3iKhVIqvN/ccucCJU22pUU9vLCuglLHxlkLkZo4zqUd0QR9P9IpmqU2NLfzo2VbaQtmLb53Ow63XnUJlKkbfN79Fsrqa50tKSXpjRAYOEs0rpl1XyrpEndx6uzi5marSXHZ6DaxLZCNuZhpG+P6VK7kprvC8e3Il1piIU+UeoMIzJI+1ubiKXlc+n6osJF+v4xeHuqgLBrh1u5ZMKs4j5q3ExppnxBQvIQI0oeFsBcpZfqRaMjg4yGuvvcbu3bvl9yL79eqrr6a4eMLvG3z1VXq/9GW0ip/ykzwojlxSUy5kdFeUvfs1eNY4KJj3IIp24gKcTtqpqr6c3t67SGdeP1/+yO+lNLQ/80GmRvKps8xBO+bZlKsU0SiZzrAumCQ0piXsCsw0aSnSh4nsuJNkTzb7Mvfaa3FdfjnbbrmTH0SKabFNXmwIrHqFb5aHmdGykcHCGjpb+4j4OyCTXQjl2aeyMr8JXXqAZ0c/TUopY6H1HojvYYu7Uvr1Ssx+LNoEbUFRbdRwUfl+priCYC9F7vkHshX3jNbAE4Wf5NNTL5NbxMWeJMubokwbSGCIZ6idX8D0M8v57v2NuHqiePVheqcHGCgqkQkEUkiJYw4FuPSF58nPWcNUbxr9VCdzE2mUgTAa4a/VZCPy1gayz9HKy6bw3YNdNPb6OG16AQUOE7rBKEV7R+SY8lFXgL1TNWyYMrkz3RYK8O2RVuYW5bE3pfBa4z4qD2zHFI8SqZ9LXGNgMCcfxWhioC+FV8nljIFurKFBdOaTaCyx87wxjiaY4PqlJazJ11FanY/JmUNCyXBX1yB/G/QyeIzmF3aEb9SWcEGBSy5Sf94xwB96sovwq0vyZIVVfF7FVK4Go5Gnd/dx+/4+MkaFFdW5pPwJHtvcLX2kD356BXMrXK973e8WAvpQt1wkjvPZykK+XVtyxOZwvAbhv/e55WfNodNKv3KV+SibUSICD14HzeNjnYWivhrMLnhNVOuPQryWJ39NjsROJ+M8/dyLjPiCDGlyqZvVhdW2F70+azj3+QoI+GtIpmLEojaGhmooaZjNr4qn4U+luawoh/+dUUlnKMaNjzdhavJTPZQkrgN3boqaov0snjMLu30uw10BMtEAFW3/QzjcxcbUWazLO5Velw1bKsTUHoXyoTQd87V8Z/gqrPEEW4MfplDfwjQxuvx4aA3ytX8+sZBWTR1Lly1l3qIientfZnhELBrFlrwYLe5k7tw/4XIu5F9FJEwMDgk/e4ac3OWYjNlzkt/fSGPjZ2QqjcBma6C05AMUFp6D0TgWWbbnXjKPfmZSo2RnhZnucjszD4xijqalNUJYOPpMLvZHZ7GKrZg4KhNa7DBdfCvMuXziZ8Gh7DnUVUFgy+P0PvZ3KrVbjgxIEY2wJqcF7dTToWoFtK4ls++hI8fhxsm2Rf/LSG8HDf0PsID98uexqlMxXnpzVvQ+9Z/QvRUuvhlqT4Vtf4Fnvi5tDdnjylocjsYfy+D8aeBdqzveSVTB+39Y8Aq+//h+/rop27DzvQsapMg9HqKieMmuFvb4whhCSeJ2vRQh+l1uKYJFlfi3H5ovK7R/2dDBzS+3Eo6npEXh8oXlcrrP0TaHcZ4f8fHpA4fl7QuqzQa+XlPCt1t6ZANKndnIYDhCcOyiP35h/OHUMs4peP0FbRwh0gVHX8REteCegVF2+cN8vCxfRuiIeLc/dQ/LSuo4J+fYuKw4V/79xxs7jlxkb5tVwwybmUQ6QzyTnlQJSqXS/OD+jdy5xye3qaryLNxy1UIaSide922dbq56ZAvJ0TRpsX8tFgLaPhbqJ5I1WpQpbAxnQ+eNJDnLkWHGvEpCU4rwaTL4RkdxrH0KXXyycNQ7nEzNLSYxFOFgtBddOkXIYMaIDl08gN1sJxDJNrSJaB4xjECkG4wL3RdffHFSA8e8efOkjcFsNk9UWh55lP7vflc8WMzz5lH8gx9gmj4xWSq4cSPdm1rY5taiKziIRRtEX7EXU073xOvSmY9laCkucwlRaw8ecyOhTAStMYQ5L0bEbeTQw9XosVJsL2fRNVdSPmMW3kdaibV6YWERuwciPOP189IcC1XBDD85p545ugyjt/+Vkd9nB5a0Fdawq9yGMRVll3MhRZoGgroomnATaU0MR8pPSXRgwpYz/jpqFPY6Z7PBtZx5Siu3GX7JQGQJL/s/h5Y4Jzluw57ewuO9DcRFxucYFlMdH6l8ApvWTTCVi0kJoFPSMl1h15KvccnBYTlidGlfnILBJGsbTET0Gqp1Ou5ZPI1SjZZHf7uLTbEITy+yErAcNREsmZANg6JpKyeQ5Nq1Aayx7Pt7WJum2ZqUk/LEO+IDMQNENMQ1GZwfrOa/n22S40a/dna9/KwLFmb0nObTETZquOl8F3GdhtomL3MPv8yIy8qcg9uxiGlOx5CyuwiX1sJYJq4mrZOTFu3+erQpIxGLwgNLrBwu0stF4ouLpk1ucD0KYZV6zu2jLRwjlEpLa8H44tOmVbBoFYbGEgc+NyZI30pFUNinQrEUNflvbAHqj8V5yR1gozfIqbl22fjztjDSCnvvBXsxLLouu5DceQc0PgDBYRCNwWv+W47jHkdMGhQRWSIZ4KKLLqK9vZnnX7gZMlbWrPmE/Hl7ezvbtm2Tw0QE3QWlPDNjsVw81QY99FpdxITXlgzzertoKS7Fo9Wj12i4zqLhXCWBs7qGXIedAk2KrVue4j8COfSacsmNefnF7hsZdZ7Ewis+TX2uHUUIrL6d2Wri4U2yIUwiFnLFs6BoZtbC0Z5tyBOVxcyH70Njyu50jZNI+PF4NmG3z8ZsfuMYxH8XcT9d3X+hu/t2UqmJGEu9PgezuYqCgjNR/EN4D/6B/NEUpQPZ93ZCqyGl02Aa2205NvbMo83HXlyLTm+kf8qVbBu1ycW/ODceveN1hKhfvs7JDTcxsmMrL45+ltmXnsysU0sZGBiQsWgHt73CzI2fwUGItNaIUrWCTPcWNImwvP+XWMEGljBr9hzmzJkjh8+IJrSVK1dODI8RQlvsFKy/EeIB0q5KNPGwHLktHoHfUoPz67vf1brjnUIVvP/HBa8YO3nt7VupyrPyq8vnorxJM9hwPMEVu9tkFVQMqEqKX01nWODLkF/rZCSZJJLOyOqJEEjFOh1fn1LCQqf1uBerZ4d9XL+/k4SYi24zcX15ARcX5kjP7PrRAB/cIwYJZzEmE0zrbGOkuJR+W/a5PNc7zHfc3VScezb60lJZFWoJR/lrr1vaEsxaDecXuDg73yk9sEfC0I/DRk9A/hvRyDQST/KhklwuL86lMxLjA7ta5cXYrCiyyvSK2y+P+U+zajg9b/LrKkbR3nDPLnq9EewmHXd8fAk/FNnwAAA9BUlEQVQzS53SD/29Zw6SjKWOFC3nGDN80h4n44vgSlrIS9uwYmIzcX6Gn2HGxjeTYok2yPfOXMALjS9Kq0GOy4XOPoV97gTt/gBKJslM3QA2TbYqIcaUjscpxbQ6HllwKhe6R7C0Z6u3xlSG4kiUzJQaugaylUjRXT1jxgyWzJqJde1LBDdsOOKnjXd0kBYJEBoFx4XX47jwA2h0OhSjFsWsQ1doQZdjIrRriOH7moimhHDR0BmP01P9JM6qzXhaV8vuclFPt2hEc2FCZmkKTKltVF50O4olwfCefHo3i4QBzZGBDLOu/DhNzhJMRi07feEjlb9xzsxz8IMpZeS88CxP/uk2Bqypye5BjVF6So8loLUxYCzEbchjwFREv7GYpKiajFFmHOE/cx/B0LeGw74Z8mcl5nbm6n7Hfl8xHfEzUHRFaLSl2HVuLDYtQ74c7Noh1jh/zZaiCj4765tyzHfFcIyPvBxiyKnl2QUWegqy9yPE7MndSfbkKnht2feokhINQxmqu1pwdgzhidnpPXkWKYsOpydB7cEgc/wadsww05OjxTASI28whi3fQluxnlQ8RTAUh3iaeWVOmrq8xIMJ8hLg9cU4K6yneZGLpgqD9Gt+4gU/SjJIKtZIJhNHyOekdph0JoyizcPADBTdFDRajfTXpoXlVO6LZHEVWTjzs3P4lXdU+lxvbqj6h77zoxELXrHwvKNv5IjwFRO7fjKt/HWfsfcbwrc8buEQCK+8GI5wROAcNXDjmWeekQK4taCMtTMWHYn+K/UOc2rTLhyxMFGdnl2LT2WP8J6OeW/HJ76V+kfxmCxEDCassQjXDbahHeiVVrfa2lquvPJKOZBhEiF3VryLCY/jiIJCywswsBeW/UfW5/oOE4+PMjD4GEODT+Hz7zru70yb9n0qfHYyT9yAZsxfK5qiBwqNFAzH5JTQuF7LS+kVbEstkOe73FwrbveEkBbDOc477zxmzsxaoY7H/vW9vHJXMzqjQrKqlWF/1vIjKGSEj1vWYgofla5SuoCXtaeyrvs426NySqWL08+oxmqZQ3u7h/r6eixDO8nceTFKarKdRa3wvjGq4P0/Lnj/WbyJJFftbWfHWOPGW6HKZOBLVUWUmgzsDoRpDERoD8c4GIpIQXtxoYvfzaiSTSlHs8ET4HAkzjyHheqBXrouvoSoRuHv517CvWsukNFF+d5RCr2jBMvKGTCYjzSfHIs43VeaDdi0WspMej5emscik577PCEpkA+FxxvQsgixeLtTy5mL5koB/JkDnazzBF93m9+qLaEvlmBvIEyp0SAr1CusFv73kQPsPOxB0Smy6SgWyZ6UMjYdl66qZq8xLRtt5totrDaaOO/FITI9QQyVdmwrSkmatdy6aTcPtQUYTI6JQhJM1w5RoiQIJWpZf0x1UlR4TnbEqZ9eQWFJHjH/YQ63HGRHQR27irLbeyu7eljUeYBYZvLrV5MqpCFdxyuOEJ3Rdlbsa2Rhv4+Mp0M21sjHm1uF7bQvkhlLqDgWfbGVxGBICmTz3AKMdU4Sg4O8/FIf/RGTfL7ydRqZkDBgVzhYYaCj3Mg0q4mfLihFF3yF/R1fkbc1kp7Jvr3TcexoRUkmZPPLvunziZrMWMNBrOEARfE4vbZKnl11CmGLVS4Pzlr/JPX7sw0f++wzSNXVMmfP82gyCTlwoXbBQvLKq7Dl5fOHFg3PHE6iiOexxEy01M7s7lbCLgetecUYto+gSWZIW3RyDLYxmsSuMWJLaWT1zJJJ0RAzcorhZTrjM9inKSIvrSEnnRUXa2eb2DTDfMQyoklnKPInGHAZjnwvVPnr8oqjKQxbh6UXVSyyovHsIkmx6wkvzpeNo/8qDq3CR6x2Xh72c8CYkdaGT6wPsaTATv2yEmw5Rp754x7CIoxYxpyl0YzFLR0P4RMWgfynXDkds+04Va9/ErEzI84t/bEEZ+Q5ZKVXZQJRSGhsbJS7Mc0FZTySMTFj8DA1B3bJRfCsWbPYuHGjfB4PllSxqW62zDmWole8z8bea5XpBHfNn8rUXJccwPC3v/1NTh8TVcVLLrnkLVXT/x3EfYnc2mNF/duFGLQRifTgD+ylr/de+f/CgnOYNeum7GOLh8l4D+Ptf46kNYf8vmE0/bthyhpClTN5acuXaTk0E78/e97UaFIUFHQSCJQTiRjlgkQMrRCLA9HnIMami2v9xP2n+Nt3XyXqycayxRx9JDVR+Zjrl5RxyWXnZ9M4OtcTd1Tx4G4fh8QOW0aDktaT1mbPuaKSbDINUlu3Aa02zf59pxGN2nE40iyY6cXlfZTZzT7iBoWumkLMpdfg3rOfBZ+/+32lO94uVMF7Ank/Ct5xP+zP2ge4rWdYTnk5GrEdKawAotoqhO3koY6vR1zOhL3gPyoLKTO9+QVz9I6/433oIXQFBRyYWs93Zy+l2zw5o9YwZkm4VkmAzcrTcVjvCdIVPcqPNYYpFiVqzG7ri/rKUouBuqcfp9OZw/r5S7GGQ3z84C7aG2bjNBpIBoKstefiPs7M9dchJqrtdKP1jE3GEiv9GjuZCivp41TRv1hZyFfyctG5TK+7wD20qZkfPXUQT9rwuudujdMqRfb2SIwdvskitshh5AcXzuL0AjtPPdnMN6sUPOLQM2nqhvqxJqJE9AbcVgcanY2ITiEsog3GKImkOWkkyUmxOMs9WhRPMptNadJJMSuq+5l4inQoQWIwfKS3y7qsBNeFdUei46LxJPfu6qW538f+RJyDuToCx+gY0Ty4zGmjxPd3VifultmhIsZse2opwztdlO+cmNJ1LGIka39RDTElSU1fmzyMl/NOYW/NfBIL87CHg5zn8fL9i1bjctjojca5q9/NaDTB1pYRDurSZMw6GtoP8avf/EiO6fzd5R+lyVXJYLdYRrz5xX+VppGdmnpCab38zbNnFLFPm6KlLHsxNyfSLEjF2ThmIRHjd88ffpUvdtxNl+lDfKH+DEZNCtZ4mvKBGJ0HRyfdo0mn8IMz6llamcNtrf1sdYdoylWIGhTqe+LUd8dpKjfQk68jx5dkoC8gIyrSwnYkthIUDVqzjoISG73xCb+fuI9flBZz1dSiSTF/8UiS3S92sW9dL5FAAqNFx/JL6qiZW0AsnJCCQatXMNn06A3/nJde5e1HnCPE1rcQXkKACUH88MMPSzvSWZd+AHtpObmpBJ0eL2vDSUKKli/XlmI7aserra2NO++8U97WGWecwUknTQw8eLsQExD3798v04JEFrGoagtxLXaVTjTR2ABGQ4GcfPhW8Hq303n4VkZHY4yO6iksFOfxZuJxDzt3XEA4PLkXRQhg8VhElVx8PsSo5kP727H7pmGI50pfedDeRtTaJxPeZ8ysp6amWuqCZ599ltHRUTGdBId3Bvq4k6CjjZhZNKxNFHCE6M5kJo5fF7dTojNx+tVp2nteZs+eQny+YjWH901QBe8J5P0qeMcR2/23947IZq/ReJIcg45LCnMwj1VlRKzXj9r6eGbER3DMo3s0InJL+HTHWeiwyG3MWDojq34fK8un+DiNYuOEkim5fRrbspn03XdT0NVJgccto89EDJjAOHUqWqeTnqFhevUmIkYTW2bO5cmTTiduMFA4OsKHnn9c2iMc0Qix5mY0M2fyhas+zZ6co4P7J3BFI3yhtoRfDPgJj92PeCyCQDIt7Q6SVBptR1CKqXSJWQoPQWEizof62pnX0sSrBgt/O/lM2bz2u5efwHfFh3kiqWFNnlN2jYsmGUE4Guc3D2+iw6fQFUxTmmPm6+fPoL44+74SF6rH9/TxwoFspu2+Xh+d7qwAPrOhiP++aBbPB4N8Q3S8H129GT/WsZ9Vh9LM8qZ4uVBHSD/xexWhNJ9qi1FXZCe5soQch4kqs0E2yYkTfCoYJ3LALW0RlsVFRypEotIkbCtPDU+O5zEqGla4bKzJc8iEiT2BielBxZl+ruSvLGQiAsuTKme4p5SN/fX4Uw5CBiv5hhhzm/dg9AxMPBzgxfzVNDnrufaKmXTpMkfuW4xg/WJVkYyoE7nM44hki2sGOvlU1Ev+ksVEm5rxPfooKc8obYW17KlsYO28uexGQRNJySEM5kyIpemdFKa7yDV5ePHwKXTGqmWSScakJba8EAwKOYMDXKlZz7y81zik5NFPCTOjEeZ2xjAO7CSjg7SxkCdn/5i7XnMTSoihHxG+s2gb0d5Z7DlYTGFGjHDOPp+2XCPB0RhJBZZcMYUllrU8+1iG3pgFZ3GEFR+5hFs2dbOn20vrUJCKXAvLa/O4alkldYV2ftHRz01d2WbHG+sruLLk+GNMBclEip4mD0XVDsz2f796+14iFhuSvtDR0U0k4m4UrZn66f9Dbu4K3guIaCoheMd9+m+FrVu38vTTT8s/i3G78+fPn2S1GEd4SoUFwuU6fg+FSAES9ouDBw9K37H4XghC0SsgKpzHctppp7Fq1aq3vaos/NHiMYljEc+HaMItLCyU1WXxvXhsIr5LHJOwiQlBLn4mvLZChItqt5jeKI7L6/WyefOjZPgFoVAO+xrPQKNJU1vnpKc7Lp8TgfhdYfkZH9Msbq+ssIbASARPYvIU1KNRUkYpdheumoI9P8n2J/1EIlHixlFi5kHiBo9coSppHY6UA5/WT0ZJoknpKc2rYih0WD4ucQbURNN8/2c/fN/qjn8HVfCeQN7vgvef4ckhr4wFEkJDVH8/UpovQ+BF9fXXnQNs8YVel44gto3PLXBKD+4yl1XGchnHvGjHkvR4GPr5L/A9kp2YpthspENie33yrWoMBvSVFSQ/fDWDs+dQ/eB9hB59lEQqJbf+rEYDNQ89yA5HDp/c287wUe3cQpTawiG+cM/tlKSTLLniA/hOP4MaiwljwI/v4Yfx3Hc/Q6NeXlmwlJ3TZ7JjxmwKvKOs2r2N+c0HKBodonB0VOZXjvOzj3yKZ1ecKsehiuEe41i1ivSlCuH7j8gkEnJMcWDti8SaDxEeGuG+BRdxT+5sWSk1FlsIzs2RFXcR2p8S0TpHUWEy8OnyAnISGfYPBditS9EUjcmYNCHq3yj0SGT+/mhqGQucVvm6iulb4hK5JxBmqzfEY2PxbkJUiuYgYU+ZazfLSKjHhrz87vCgHBpg0moZiImYtbFmQ1FxN/SzKHY3izJb0GmyF5DhaB6PtZzD/MJGFhbtocNXwfO7TyU8bMGSCtOVW0lPVR2pUgsZu15aAkSe8bEIz/gZeU4sisL5hU7qLP9YGASTKRp3bGDvgf+ltLIZi2ZCpAfTVm7W/4RYJE5Ip9CjraIm08r3+LasVgtiKQM6jYjnSzMczsOqD2HRRznsL2fn4FyGI3lM03Vxeu0rpMYOJ9Azn5H9F5KOVsnGyHQy+/wsPidIQfon+JI9+Bx6kmOLk2SgkiU1nyKn4RLQHX+7WNhvIqk0S11vPsHvaETVNxFPoWg1mKz6E77l/U4RjfZxuOuP9PXdJ5MBjkartbJg/p04HHN4v/Lkk0+yfXt2oSnykEWld+7cubJyLESciLZ86aWXZDqNEI/CQlFaWiqtCULgiuqtqFaKBfjxKCkpkd5X0YwnbksIUoGIorvwwgulcBQCtby8XIpkMUo9smsX+qoqeiIRKTzFNr+4TyFWj0X4n4VFY8+ePfJ4/l3EgsFut8tjElgsXubN38KB/XPwerOT9t4q4jOzqP5kWjb4SJpH0dgjhOI+9HEHRcpM5p/rx5v6Ful0FE26DHdrPb7OlcS8FaS0EZK6IIZYnvTOx/V+gnkHSB2VJOE0FWLoqyUSTPDV2y9UdcdxUAXvCUQVvG8dUQ1e6/ZLu4RIVhACebNvolFgnAKDjg8X53JeoYuNniA7/SE+WV7AkrGLd0I0YCmKtD2kvF7CW7aSiceI1tZBWTmFLoc88fRE4zwy6JH3ucMfYnx4UR4ZymwW9o7NKxeX9cuKc3hxxI8nOdmg4QgGmNt7mIRORyKRZEp3B9V9PRyaMp19cxfSY7YSGROWjmhYNi6FDEYMqRT10SBlGvDZ7fi0elriSeJoMMTjnDncy8Gp9bKDXSAe7ym5dincyowGFjmtR7yN4sLivf8BRm65BZ/Xx6HKGqZ1dWCNRhi1O3l2wUk8uPRMPJX5oFVwHR7mxttuZPHDdzJkssic0e+39jFw1Fb38dCM5Y8Ky4qo5HsSKeldPvL3ckJWDGUgIqucAuF9FXmrYkrfzFwrM20WDgUjeJMpeX9yNO34eLPsg5HbrOKxbvaG5OLIIGK3Bv0sTWzm0qKHyDdPDNAYR4wU3eueT37FZVy68CJSGh23dA3x++5hWW0vlsebZCzYgEqjQQ4eODXP/oZRVMfD7V7HgYNfJx7PZmOGAnYadXMoMA8Qw8QfNZ9nmOwkP1EB/jFfpUQXxx2fzkB0Nrn5F6JPHcQa+R4GZUIsHw99SktCyQ4jENgSVlzF5xMIOIkFXyFqGJvCNP78p0XzkxFFHyOd1FPTm0fdmb9DI5qJmp7MZnrWnAwF0yeF9r8hUT/BsJ6W7cN07B1moM13ZO0oGtRWXz2d0qnZNBG5m7Ll1mxn/1k/BlvhcW8yGGrBoM/BYMjunGQFpYIyNlRENB0lkz7M5mr5GRXvbfFc6/UuFOXt9Xqm00n8gT2YjCWYTKUkEh7a2n9NX9/9ZMYi/JyO+VRUXIvZXElr289l4oBen8v8eX/Dbm/g/YgQtZs2bZLxhKLiKRDFGiFuRdKAEJRvBSFWxfZ+Q0OD/PfxeFwKVFExPRqRPiEa8USVVQhLcfvidXfYbCxLpsh77DFSHg+N8+ZxsH4iPk+8g5csXsyiJUsYaWqm89Ah2v0+hn0TO0niPTR/xgwq3G70+w+QqKokOnce5sICKebFYxXiXPxefn6+vH/xM1GJ3rt3L62trZMq0lVVVTItQYj1lpZXueeel+WAmMKidmbMyCcRX8zwcJxEop94PEHdlEoqyueyf38nPT19nH76GdRPr+ex3+yi99DY9EVNClfteioXbyGezmYYC9tFZiy6bOrU75DnuFLGyo10BxnuDjDS56M3voeocRh7qoxYIipFszlcLnfYcqv1XPnNk1XBexxUwXsCUQXvv4eIDxMDIF5w+zl0nHzccUT1UGzPiiixYxvshJ3i8SEv6z0BRHFsuctKvl7P0yPeSVmcxyJOqKK6/IWqIubYLRwMRvjQnjYG40lydVpSsRi+Y6qk/7/QZdIsjQT4uEVh9n13E3rlFYZcOXzuGz9i2JmDQoYKrcLhYx6gbiiMdrcHPRmuW1UnJ+qJGKcWb4Q7QwH6lDTT7WbqbSYZzC+sKi+NBvhr74gUqeNNT5lQEvFqJEz/gn/zaIF7NMLy8g8alHQjYRZbDjLVso+weR5B4ywc8YMUhZ6TjWej5HJQWUwjs8igMMsixuKmaYzo5Gt/dKVe/P58k4eVFj+dCSuNMTuhtCKr1AtNPr5bY6c6dz46nVUKsfb2G+ntu0f+e4uljpqiT5O+bSeDjz3B/Wefwx1nXyaFtikTYblpgC9MmcXCnCJ0OvvrqqGiiuj17cBqmYLBWMBI/5OMdj9CwmggpclQkH+6FFqRkR107P8ew+l2Msf6vjMZ8sNWcqdeg6N0DfaBPgY3PsBOSw+mguygC3ormTbYh0MzgjWURCc60JUcDmXOw6ufia5mMaaCIvLKbFLEJjM9DLT9CU/7HvwRLcMDywn2zcNWshdH1RaSUQfe9pOJukVWtIbqOfm4cjWkDr3MwJCZcNpFrs2Ha94KkikNyXha+n/NDj3GonsY8d8mD8tmmyF95KFwm5y453IuIJ1J4vVukwJCREk57LPxeLceWVwYDIXk5q6kqPA8cnNXHRHJx5JOJ/D5dzMw8CihYDNGYzF6Q54UtMmkH6OhEJ3ewdDQM8RiwgqjkJ93qvw3iUR2MZXjWkZ19WfJyVl+5LVLJoPs3HUVgcA+FMVAXd3X0OtcshlKiGbxu0IEH+0RFaKlqfm/8Pl2Ulp6BaUll6PTvfWqevY2MsRi/XJxIJ6X/1+VdSFQRQVWNMAdLXJFxVNYEESVVlRQRWKEEIjid+rq6mTFt6ysTIrct3qsws97//33S5uEQJ9Okxjb6bKLXdJwmJ6xLPDCwUESOj2evDeIkhM5vek0pXl5TDvYhOHVVyf/vfCf5+Wh0Wql1U1fUoKhtlbGLGaiEXyPPUbSPUruR67GdtFFDI+MyKqyqDgLQXw0breb4ZGH6ev7xRGBKt4bx+4MZO9WT0nJpdTU3EDEZ+aFv24iqV1P7rQX0FvHF/EKdbVfoqLi43LYRiaTJC9vbIDGMWzevFl6f8VFUVR9dUkLmoyWhD5A4RQL11//CVXwHgdV8J5AVMH79iGESCCZYpM3yB+7h2Un9xKnVdoeXvFk82XPznfI0PqRRJJXRgNs8AQn/LTHYaXLxvmFLtnkNu5FFekRwpssRG6txfi6LW2RGVpo0EmxvKmnn8a2TmwmExqHg306oxTmIqt3VY5NNu8JD7LwJA/GEug0GlmhFr5lUZkeTSSlTcOp06JXNDJ39LHte9ms0ROyZJMQ9Ik4ibEBDKZoFEMyjn8slk1giYTJ9XvpKyyZ7M0dY7bNzEnpGHN2bKHAnsMf4uWsb3G/4XNSnmvms6dO4cCAn5e7RunUpElbdWSc+uxUq2PuQ1R1dZ1BKViTdWIkrV5GV4nfc6Ih5o8Ti6fI6JWJqVjJNNquENrhqNjnx5jMyOl87TlaUrX27EWpK4iu1U9OqZ1pi4pZH3y95eWfoSJzmJk04iaPbZrl//D3nRkPF/IIlSYjlkQbupSbEQrZa/kILUyR1WnxXvAdVfVfNbSRLz11KzVVl5D/uc/if/IpNEYjjnPPQXec7de3SrxnI0Mbv0Q41kNSp8GQ1FBW+0nMK76dHcl6FH53iE3P/xhdwf1oRA7wOAkTqeY5eOIVOKauQ9FH8Xctxd+1hHigCFvpHooX3CUrxP+Q0TzaNn+JRHAs2P9N0Br9FM67D2dVduv6H6HR6OSF/s1wOhcyZ/YtcjExMPAYo55NeL27iccGyBw9LOAfHZvWRio1Ieas1mlMn/Z9cnKOP8I8kfCy/8BXcLtFZe/1CLEjFkNC/FZWXEt7x2/p73/wqL83Y7PVY7NOxWAsRK9zEIsPEY+PSBFfXHQh4XA7bW2/JCIn12mkKB8X4gZDAXm5J0vRZDKVMTj4OP0Dj2Cx1JCft5qcnBVvuBD4VxG+0AMHDkgBLKZzihza42bQ/psIUdl66BCGX/8Gzd69NM2op7mhgeRRFq9lox7qR93oS0ppaznEjupqAnY7tmCQ3HSaku4eilpbZaLKEUSaysKFWFetIrxlM6FNr73lYzLNnk3hf/4n1mVLSQVDhLduJR0MkA5HiOxrJLJrN4rFgubkKkZntONR9kgPrc06Hbt2OqPdrxKz+7L+rDd4f5eVfpjqms8R8O/DYqnGan3jUenHInzHwi4pXiPx+ghf8rp162Rl/qc//akqeI+DKnhPIKrgPXGIyocQqKIp6kft/dzcNT6CcTIzrCYuLHRxQaELk6JIG4PYKhdTimbZLbwbEVaM+MgIIfcoSkcHzw97+J/qBtxjQvfoXM2jET8RdoBNnqDME7YqGu6aWyer27/rGpLCW/7ecBTdIV+2wcqolU1WIkVCOxJDIwJ034CMVkPaqcdaZKGywIpVr8Ws10mvsd6qY0iTkUkb36srwanXyeZBMbHvqw/u4cm9/WQMCmmHngaziU8tr2Z+ZY4cipBnNcix07dt7OSH61oQ/VnGYJJVUwv46aWzKXSYaA1HeWbYJ60oYkEjpuQJe0dHJMbeQEQuJvL1CpW0Mz14F5lYL/u1S4hjZH56E2WafnJzlmMyVXLvwChPJ5fLjM1URghzLyUMoJDCj50mZuLR/GPf9DjC6nFDVRHXtB+g97Ofy27xi4XB+GJLp8M4barcbkSvQ5ebh66wUDZUmhoaMM+bi+YNvOmTSMYh0A8mB5jH7ARvQPuB9bS2/JRkxovWEEJnyi4K/xHh4ToUXyXOMgdYNhHLDGPImCgzLCSadDOYPkRaRJWlwDCQT9ws/pDBYC3DrLjI7Okl5i2FnBFSRcMk8r2gZMikFfq3XUNoYBauwl0UWj0Y804mqrMRCu8g7I/i755NMm5jwdktFDZkcLoW4XIulsMExFjZoeFn6O9/RIpUk6lCPp+RaNfrHkMqYUITWUll3ekM9XQT8g9hcxZSWFlMWO+mP9hPQc4CyjWnkc70Eog/gdFQhilzIRaHBUdedtjK8UgnEnTs/Dm9gYcxGgtxFS0nGu3B49kySTwfCbDOaMhpqiQyI0aUiebK4yHEciTSdcRSceSWNFr5NV45FMLZ6ZyHxzNZvFmtU5lS/lXyClbJXoUThRB/Yra09m3uSxn5058Y/tWNKA4HVX+/A011tRTbwhcsmsiEl3icdDxO4LnnSQX8OM48E11+1iYTbW7Gc++9RPfsxbpyJa4PXoGhvPzIv0sMDZHyeMkkE6RGPSR6e4k2N0nxSiqJ/eyzUYxGRm65NdsDIhpsp08n3tlJZqwx7Y1I5mbApsMYzSXlHpUDekQ6AzqIV0PwQ3pipVmbiJLUkz8yj5LomdhPXY2x9vgDn/5Z+vr6uOOOO/jmN7+pCt7joAreE4gqeP//ISwHQsyKLXhRrRXCT+R4TrW+9S7ldzOiGvyLAx2sDcXoionsWFjutGHVKWzzhYim09w5p5aVOXZp5fhYY8dxPdCi+Cqq4kIgCk/wuOuhxKjHkMrQu28ExROXwtSaY2Kl0YwhkpIjowVnzSrmAwvKpUD9ZxjwReVtGHQKhXbjG253HnaH6B6NML/ShdV4YiwjYvsxGu3FYChhgy/KLzsG2ObPPlfivTPbbpaNdE0BH7FklDh6EiLw7phjztFrOS3Xzrn5TtbkOzEoCqN33MHgj38i/968aCGZWJxoY6P8ftiVy4GaKYRMFsyxqGxkFBPxxAU1/9OfwlBXJy+2QgwrYxPu3o7x4Q+80oZVeY5puQ+SVgwUVn2CaTk19LXdije8n0QmggYtVcXXUFV+PTpH4ZFFpXiejMaCIx5aYcc40PhFPIEdb/kY7NoyagbsjOw0si14OYHU8SvDYpJdamzYyrzaFmafPQdbwxICgx78Xb2YLAoayzAH+79PPJnteE9GhM3iFMIjdXg0ZegUI0q/8Q2zg0dtCp2FeqqHEuQGs+9pEbGWTgr7S/YlnnFSKYvPrcFq1RA+eIiexn4GW9yE+0ZIDA1T3LMBWyg7NEBshzvOPZfkolNp2tPEoLsZW+2rmAuzfkz9A+XkrPOjTUfQzC9Fs6KCVLURCkykzRl0cRMpt49h7QbSSlZQ5eedRln5VdlM1hAYfcIGoSFaEqKz+xa83i1HqoXC+pKMexkaeJok2fewaY+e4q6l5Mw7Dcvy5fI9GNqwXopg1wc/hNZmJeX3E29vxzBlClrb620W4rUXzWIp4XE1muTgmfC2rUSFF7avL1s5XbIE28mr5C6DaJrNJOJy4WZbvRpTff2k2xMCNbx1G6H164h3HiYVDErBLJ47cTuxpoP0fP4GMvE4JT/+Ma5LL+GdJDk8LEWv54EHRJlb/kxfVYmhrByNXo9hSh2WRYvkMJ7wtu1E9+8n1tIin4dxrKecjOPsc6RNIrx5sxS/qXwQva7idZULYPE6mkyU/vSnOM4+a9IxyOdUvCnFAloUeHQ6ed//COG1Fs2BarP861EF7wlEFbwqJwKRIyuq1XkG3RG7RzydORIHNx7ZdnVjO695Q+TpdTJJQVS6j27SEtVxYa8QDf6iIjv+74YTSQpE5fZNJtO9nxAXleZwNDuUxDiRQCB+/qLbzz39o/L/YqiJiM0TkXmbvcFJUXsiC/lbtaWcn+8gsn07upwcWcEVDLe0clPPCH/FKBsTx5nuGeHrt/2Omtbm1x2TtiAfQ3kF+opyeWG1nHseA1odneEYllE30w7sJdbZSTwSYWtOIVsWLuWgYpC+azHhTKQwiMr3vQPuI/5l4V0WmcLi8YmItt5oQlbnv1+bI+PhhF/5rT1faemRFdVIs6VONpUlE6MEg824R9cTDnfIJAOxtV9UeC5Wa518Lts9IxAJEzrgIdq4hVhvC3pC5Os7ydd14qiuYrf7ZF7rWHbkvjSIY54sXrXGAAWzHiEeysfTehqteTbWzTLTk58VA0WeJOdvC1HiScmpcx1FOqqGk9QOJKSPeZy4TjwnokEw+71i1JAe72wUhflURIrglO6YxUcmTWWiGUvXHhIaI0MF8wk4qif9iimnQ954dLQWDRlc/nbyhvaQ4z2ELdhDRqMlpTWgT2YrfilbhvBJafS9GvLyVmOsqsL/9DNSeI2jWK3op9TiL+8hXOUj50AFllChFFvJTIjABSlCJ6flVo8YuGhdq2B9WYs2OPGeE828Ynvf/+yzZERTmhhJXF0tb1vYb6zLlsnKqPsPfyB4rP/12PeB+M8AGROkcjPEpmVIlmXQDWqwGaZDiYWowY22NYb+BQ+asQEqb4b15FVU/OEP75oUECHuxch086xZGOvr3/S4hEBNDg2R9HrlgtVYWztxO0NDRHbvJiqSI8R5Q+xOhkLytRMLC0HOlR+Wi4VEfz+eO+8iNjZK+gg6HfbVq3FdcTlaEacWCEiLRmjTJpIjI2QiEbkAU845m6prrlEF73FQBe8JRBW8Ku8kQvS8NOqXAx3GxbHKv4Y/mZJJD0LwiotePJ1mizckGyofGfIwHE8eyWNe6szmC4sFxtpRP99p6T3y9yIOrdhgkMkgohFQvCqfHOzk8ttuRRvwE0skOOzMpb2skrbyStrKKuktLGYoJ18OxBhnfvN++fXESacznPvm9gtRhf5IaR5FRr3MzX5gwPO637m0KEf+nrCkiMcppguKcb/CBiN2D8SXGM1daNDTFo5Kf7zwugvRb1Y0LHfZZdScmFgofPDi+RI+56kWo/TCi12I8ZHB48/DdflGTk4PkUjGsdnzKSjNDiDY+8Q6dr46SjhoRYTcpZQMHqsWUzyDLZYhZNQw7NTSUainsdqAz6rlwqGXOXdkHVtzluCPa1nasxNXLMXjyz/MHkctcyJhlh/Yz1Q3RNM5mG0pDpRqud2Ri19xktBqCJg1VIwkOWe7jyL/0cbLOMW6UZyFdiKmPLraJk9llL+STpHvb6K2LIm9qgi3T8toJofRmJWAe/JWuFx4aLK37wx0MkVziIJCLQZdhuAzTx6pKEpE4kxhIelIhPRRCQTHIhqwHOedi+GKFbSN3IQ/vm/80DHt02PT1aHsDaC8NiTdFtH5aRL1BpTeOPo+DVqPBiUMiZIMifJMVjRntBgKS8nEUhj0eThqlqGdUYzPfkg2+YVD7aS0r38ujnt8Q+Bal0th3lmYZ8+R1d3YoRZZ/RS2AjEaXjSOFX3zG1KUv5cQcX3B0ajMx9YZtRTXOOQgl5GeAJ6BMFUz8zCYj3/+zSSTDP7853ju+PvbdjzBVIolrS2q4D0OquA9gaiCV0Xl/Y+oit/SPcwt3UOykW0cYR0Zb5qsMxv53pRSKYSFYB6KJfj6oR6ZIiIQYlGkjbSEY2/YaCkaGIvdwwzkF8pO9XFyohFWbNvEzI4WKZRFNJ01EqY4FuXMaIDlujSOs86SzTuMZSR3hGNUm408Mezl92ODKE40JkVs4matNMdDVNddei1Noai02iipDLZomoBZwZRKsmr/Lubv2cm++gZenb8Up17LmrIiLrbqqbvvbwReXU+spf112duyjJs5fmUupdGwefYCXpuzgJ0Nc+nPyS4e9IkMrlAKbQYGnVqMOoX5DgtLxDTA/jianW70abAYdVROcTF9Xg4Wl1luOx+LbzhM5143XQdGGWjzEn8Tn7zVrsUZ7iY31UdFvULF1CD6UDuZkTairYdJ+JLo8vLRFNWQVIpJaQswnXYFxoY5R3zgopo+PPw8nYdvIRDI2mnGycTsiKklGusbi+d/HjE+3YXTuUBW9gMjjfjdO9EnbRgpwGduIknW31xUdCH10/9bNhyOH6uwMQgrzxuRSqRJJrPb+uMvrcGkRXkLY6fHE1H8/j2EQ22yGVA0lVVUfEw2P/6jSnImncHdF2TocAB3b1AeiziGsD9O0JMVuVExLeYoxHhui9PIUKdffm+06pi/ppIZK0qxOAx4h8K0bBsk6IkRDQcxWs3YgoMYW3aga9yASZfCdfllOM87j4xBSzDSRCjSRmB4D57urQQ1o5gGFawDRtI1NiIlcfRGFw7zFFK9w4wc2sfp32xUBe9xUAXvCUQVvCoq/3cQvl8xTnuDJ8CDgx5awzEpYkVD2+erCl83NEVc7MXwjW+19EyaOCjGLDdYzTLtY6bNTK1RT+GBfeT5PZinTGGopIyb+j2ywnpJUQ4fKMoh09SE/5lnZRNPcmiY0GuvyS3OIygKRd/5NrlXXvm6497mCXDXzn009w0yZDDiCAXJ9Xkxx2IYE3EMiYRMBwmarYw4c8gJ+Fh0sJGp3R3YwmFGnS521M9iOCePyv5eqgd6cAiPZjolBXh3dR0zTHpWGjU4y8oJVlbxeEEZd/qj0lZhUDSympw5JuPaGg3L2z9t+ybO3/AStkhYRCvIZqBx9JWVpNzuIw1GAl1REbqCfDJhH7GOHtk7prcmsVdE0WgypGIKGZFL7KzE2DAfy5qLMc1ZKMWqO55k//AoQ+kMSZ1OLkCeGPIedzT5kadW5HcbdLL6P8WSTWYRVW9tPEjK348v7KcrKR5jhgXRwyzsP8iMgRdwJKLsDZ9LU+Q0Gek2qZ1/DA0JHMYejMZhggYDMZ2CM+3FlXGjMw+TsIbx6OoJuc7ApinF6E8TGokQdkfJaDMYyw5hNjRjth/GUtiM1pC1UCRjNkI987DbetHaR0gbomh0CRJhF1FPFemkEY2SQqMkUbQJdGYvetsQmZSeYN9cQoNzKChqoLK+gUzaRCKakkJeCMLcUisldU7seSYpKJPJEF1df6bz8M3SP6/X51BQcBYu12KIBSA0hD4YQJfKEMxdwkBfkEhokEh0iEggQiwSweTqxpTbQTplIOYrI+6pwZCYjc02D8Vow2DRkV8bwJrfjaJLEIv2Mzj4LKFw0xu/bpkyzPq52KyzsTuFNaeQgDtMKOAjmRqUAjkU247e2kUinCfv13d4KeFBkcF8tFDOoDcp2HIshHxh0hk3ij6CJmPEaLERcCMbR101G3FW7icWsJII5WPKOSwfUypuI9CzQEYARty16KwGbHWHsZTuwmrehIa31nA6TiiU5qILO1XBexxUwXsCUQWvisr/TYSYFZXKHL3uTcdjC4bjCZ4f8ZNv0NFgM1N+lI/4X0VsgYsYpXh3D+EtWwi88IL8uWXxYjmFUHgMhShM+QMEN6wnNTwi/15jNmOeM0emR+jy81CsNnTFRTKvVHS3xzvaSfn8cpiLNidXRjaJZqjAi2uJHWqWDUzie11RoTCJ4334IZJ9/cc9Rn15OYrdTqK7m2AiKSvTQYuV6Yfb5XRC0dBU+PWvk+jrJbp3r2zuMy9YQOzAAXyPP4Hv8cdJj2XEir/L+/i1WJYtRy/ue/x5CIdJtu5E3/sUGjGAI+qDeED6cCdhdGQj3nJrYdZlMOtSsBcfeS3F4kVMgxTVcTEkR8QMDsYT0qpy/Hr1PyY3GWBaxkdNJkTY24dbk0uxN0W5O0k8UobJZ8F6lKf43yFo1NBRqsGV30hNrIdU8xIysaOTPjIo2jBm/ShKjo60NZd0LIUurWDM6MkvtFK3ooZ4DPY+385g9z+Or0sbIOoSqeBpdLE0NnsLFXNvx2B941jEf5Z00iDFo0ZJYLBP+J2PPKq0QtRbgdafh+K3EgkWkCoewlG1GUX75vF3b4Q2NRODUoui85PW9BJLdZPOxMhojMKjgEbOs/zXyIidCNE8qUy87smoTT6GaKCUhK+UZCgXo6sXo6tLPvaAtxa9NoLZ2SPHHQf8Oq77xs2q4D0OquA9gaiCV0VF5Z1GCDb3H//E8K9//Ya/I0RwztVXkXvNNbLh7m2772SS8I6dUijHu7qJdx0mcfgwsbb2bPf5GKL73Dx3rhS0Mq5tRj3GKW+eSSqquoGXXkbrdGA96aS3Fu0miIeh9UVoegq6t4Cn4/i/lz8dKpZAbg2IgRLtL0P/3uz3JfOkOE6ZcnAfeomB3kY6TKW0WioZ1TmJaI0kNTr0RitWk5VKbRqdwcxmbTHbMk5602/BU5/JUBaBUneC/FCGfBQsaRHFlkQJJSl0JzDGMiT1GSLWCCN2DV0uOyFLEp3BR0E8SGEojU7jI+5wsyF3Aa2WqiO3XTKaonYwQYE/Jf3QBysMxMdGVB9LbtzL8sA+TOkkW23T0YetnNTqId+nlaO0PUYzQaNBVulLPEmKPVk7yOvQpLAUNGOv2IFBVIzTIv88LRsRRVVUVJCF/UTEQZviKTmx0KzxY48lcWiKSdvyCVo1DOPBZxolo5sQrZm0lshoNemEmXTCRGiwgUx/Jf7o2GM+iiJLI/b8/UTyIig2D3rbCFpjUN63JqWQiVpJRO30ZyrY6prBlFQHDek9mBwDk/Otj0MSLSGsskXVxITH+VBqJs3ekwja0tiNgwxQSiNzKaGPpWyigX0UMSh/NxjLwzc6DX/XMuiqn0gd0YAjz4Q+34TbrqWv2MD+Qi2peJq8gRijvhiRYIAXv3CGKniPgyp4TyCq4FVRUXm3EGlslJ3fGZHjHArJBAAhEq0rVmBeuBDlBGa3HouIpYrs2SM720VOqr6i4k19nCeU8ChEPGKfHw5vhL33Qc/2bI7uP0NhA5TOz4rhkrlQPAvEaOc38H23RWJytHdHJI5dxPUZ9LKRUVhVRErK2QVOaZF4I2R0WCCB2SZ2BIRKGsqKd70ZbMVgzc9WrcXj6tslCu68ap3BOm+Qw5G4HJoyy26mwmTgNW9QjvO2kCQ3PIBZZAErOgY1JroUB6mjJsi9EWK8eBkRytJ+isMjlHlD5HiT6HRaklYrQZMDj9aBL2PAl9TiHE1T25XAFEzTnaelo0jPvqpsE6LAkEkxQxtjvsuOxZJLRDzeVFp6wEV84EKHkWoG0Hj3kgkOkApZ8Ps0eMI1RGIuXLVGHIVJeodjDLQm6cFIh05LuEBHuT3MvqSRw6l/rpnXlRnlVF5CR0KK2hEK6KGCEHamRdpwJsJstC8kqphpCLay2NeIoqRIaxQq0nHK8yvZaa9nCy6KTSYWuZxMS3so9hykOOHFoY2gjLZhbH4ZvIflfaYzCtG0nXjGjF07gtZgBGcZOMa+xJ/zp8n3XtRSwNreYc6fOkUVvMdBFbwnEFXwqqioqLwHESL48CYY2Aveboj5oWolVCzNisqBRvB2QXAwK3AXXQv52Ri69xsikWSPL8hrfYfln5eUVJJn0LO3t5WhkJ/q/DKm5pVQYzFNikb8ZxC2nvWeIK+OBmSiR1c0Nmkc+IlCxPKJ4UT+ZBpvMok3kZLxg6LB0qVTONmqYYU+SnNSx66Ygk2no9RoZJbDxpJcBw6tVg4yylUylPlbIThMTNETScRxBQ5nLTS5ddnFkHh/vFWrkuiMGzoIzU9nF1/+HvD1QmR8DPEb449lcP40oAre46AK3n/AzTffzC9+8QsZ5iwmvdx0000sWbKEt4IqeFVUVFRUVP45RLZ4dzTObn+YxmBEfm9WFCmohRgVTYTbfVk/tZhnJmTk+N+L/4tGSFEJFrF6RbKh0EiDzcRcu4VAKkVTMEqhUc9Z+Q6sR8X9iaq5MCyIKZHvShIR8PeBrwf8vdkvsSAb3A+D+4ThVxW8b4IqeN+E++67j49+9KPceuutLF26lN/85jc88MADctRhYeFEY8QboQpeFRUVFRUVlRNOOiXtK36/D2dBqVrhPQ7/2v7D/xFuvPFGrr/+eq699loaGhqk8LVYLNx2223v9KGpqKioqKioqGQRfm2D5Q194yqq4H1D4vE4O3bs4IwzzjjyM0VR5Pevvfaa+t5RUVFRUVFRUXmPoM4bfQNGRkZIpVIUFRVN+rn4vqnp+GHWsVhMfh1taVBRUVFRUVFRUXlnUS0NbyM/+clPcDqdR74qKirezptXUVFRUVFRUVH5F1AF7xuQn5+PVqtlcDAbBD2O+L64ODuB51i++c1vSqP4+Fd3d/e/8pqoqKioqKioqKi8jaiC9w0wGAwsXLiQtWvXHvlZOp2W3y9fvvy4/8ZoNOJwOCZ9qaioqKioqKiovLOoHt434ctf/jLXXHMNixYtktm7IpYsFArJ1AYVFRUVFRUVFZX3BqrgfRM++MEPMjw8zH/913/JwRPz5s3j2WeffV0jm4qKioqKioqKyrsXdfDECUQdPKGioqKioqLy/wtVd7wxqodXRUVFRUVFRUXlfY0qeFVUVFRUVFRUVN7XqB7eE0gmk5H/VwdQqKioqKioqJxoxvXGuP5QmUAVvCcQt9st/68OoFBRUVFRUVH5/6k/xAAslQlUwXsCyc3Nlf/v6upS33jvkZWxWJyIgSFqhvJ7A/U1e2+hvl7vPdTX7L2FGHpVWVl5RH+oTKAK3hOIomQt0mKVpQqo9w7q0JD3Hupr9t5Cfb3ee6iv2XtTf6hMoD4jKioqKioqKioq72tUwauioqKioqKiovK+RhW8JxCj0cj3vvc9+X+Vdz/q6/XeQ33N3luor9d7D/U1e2+hvl5vjDppTUVFRUVFRUVF5X2NWuFVUVFRUVFRUVF5X6MKXhUVFRUVFRUVlfc1quBVUVFRUVFRUVF5X6MKXhUVFRUVFRUVlfc1quA9Qdx8881UV1djMplYunQpW7duPVF3pfJvsm7dOi644AJKS0vRaDQ8+uij6nP6LuYnP/kJixcvxm63U1hYyMUXX0xzc/M7fVgqb8Itt9zCnDlzjgwvWL58Oc8884z6nL1H+OlPfyrPjV/84hff6UNReQO+//3vy9fo6K/6+nr1+ToKVfCeAO677z6+/OUvy0iynTt3MnfuXM466yyGhoZOxN2p/JuEQiH5GolFisq7n1dffZXPfvazbN68mRdeeIFEIsGZZ54pX0eVdyfl5eVSNO3YsYPt27dz2mmncdFFF7F///53+tBU/gHbtm3jD3/4g1ywqLy7mTlzJv39/Ue+NmzY8E4f0rsKNZbsBCAquqIC9bvf/U5+n06nqaio4POf/zzf+MY3TsRdqrxNiFXxI488IquGKu8NhoeHZaVXCOGTTz75nT4clbdIbm4uv/jFL7juuuvU5+xdSjAYZMGCBfz+97/nhz/8IfPmzeM3v/nNO31YKm9Q4RW7k7t371afnzdArfC+zcTjcVnFOOOMMyaeZEWR37/22mtv992pqPyfx+fzHRFQKu9+UqkU9957r6zIC2uDyrsXsZNy3nnnTbqeqbx7aWlpkda82tparrrqKrq6ut7pQ3pXoXunD+D9xsjIiDyhFxUVTfq5+L6pqekdOy4VlfcjYvdE+ApXrlzJrFmz3unDUXkTGhsbpcCNRqPYbDa5k9LQ0KA+Z+9SxKJEWPKEpUHlvbGz/Ne//pXp06dLO8MPfvADVq1axb59+2S/g4oqeFVUVN7jFShxQle9au9+xIVYbLeKivyDDz7INddcI20oquh999Hd3c0XvvAF6ZEXjdcq737OOeecI38WfmshgKuqqrj//vtV29AYaoX3bSY/Px+tVsvg4OCkn4vvi4uL3+67U1H5P8vnPvc5nnzySZmyIZqiVN7dGAwGpkyZIv+8cOFCWTn87W9/KxuiVN5dCFueaLIW/t1xxM6l+KyJ3pRYLCavcyrvXlwuF9OmTaO1tfWdPpR3DaqH9wSc1MXJfO3atZO2XcX3ql9NReXfJ5PJSLErtsRfeuklampq1Kf1PYg4LwrhpPLu4/TTT5cWFFGRH/9atGiR9IWKP6ti973RcNjW1kZJSck7fSjvGtQK7wlARJKJ7TpxgliyZInsahUNGtdee+2JuDuVt+HEcPQquKOjQ57URRNUZWWl+vy+C20Md999N4899pj0pg0MDMifO51OzGbzO314Ksfhm9/8ptxyFZ+nQCAgX79XXnmF5557Tn2+3oWIz9Wxnnir1UpeXp7qlX+X8pWvfEXmyQsbQ19fn4xFFQuTD3/4w+/0ob1rUAXvCeCDH/ygjEr6r//6L3kxFlEuzz777Osa2VTeHYhc0NWrV09asAjEokU0Aai8+4YYCE499dRJP7/99tv52Mc+9g4dlcqbIbbHP/rRj8pmGrEwER5DIXbXrFmjPnEqKm8DPT09Uty63W4KCgo46aSTZFa5+LNKFjWHV0VFRUVFRUVF5X2N6uFVUVFRUVFRUVF5X6MKXhUVFRUVFRUVlfc1quBVUVFRUVFRUVF5X6MKXhUVFRUVFRUVlfc1quBVUVFRUVFRUVF5X6MKXhUVFRUVFRUVlfc1quBVUVFRUVFRUVF5X6MKXhUVFRUVFRUVlfc1quBVUVFReZfxpS99iUsvvfSdPgwVFRWV9w2q4FVRUVF5l7F161YWLVr0Th+GioqKyvsGdbSwioqKyruEeDyO1WolmUwe+dnSpUvZvHnzO3pcKioqKu91dO/0AaioqKioZNHpdGzcuFGK3N27d1NUVITJZFKfHhUVFZV/E1XwqqioqLxLUBSFvr4+8vLymDt37jt9OCoqKirvG1QPr4qKisq7iF27dqliV0VFReVtRhW8KioqKu8ihJVBre6qqKiovL2ogldFRUXlXURjYyPz5s17pw9DRUVF5X2FKnhVVFRU3kWk02mam5ull9fn873Th6OioqLyvkAVvCoqKirvIn74wx/y17/+lbKyMvlnFRUVFZV/HzWHV0VFRUVFRUVF5X2NWuFVUVFRUVFRUVF5X6MKXhUVFRUVFRUVlfc1quBVUVFRUVFRUVHh/cz/AxI3gzkkkijGAAAAAElFTkSuQmCC",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAArwAAAGQCAYAAABMPLOTAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQV0W8fWhbdFZmbHYWZOmkKapklTSJmZuX3l9pUZ/sIrMzMnhTQNtGFmZrQTM7Ms+teZuSOybMvsOOdbS5EsKYKrC/ue2bNPgMPhcIBhGIZhGIZhOii6tv4ADMMwDMMwDNOSsOBlGIZhGIZhOjQseBmGYRiGYZgODQtehmEYhmEYpkPDgpdhGIZhGIbp0LDgZRiGYRiGYTo0LHgZhmEYhmGYDg0LXoZhGIZhGKZDw4KXYRiGYRiG6dCw4GUYhmEYhmE6NCx4GYZhGIZhmA4NC16GYRiGYRimQ8OCl2EYhmEYhunQsOBlGIZhGIZhOjQseBmGYRiGYZgODQtehmEYhmEYpkPDgpdhGIZhGIbp0LDgZRiGYRiGYTo0LHgZhmEYhmGYDg0LXoZhGIZhGKZDw4KXYRiGYRiG6dCw4GUYhmEYhmE6NCx4GYZhGIZhmA4NC16GYRiGYRimQ8OCl2EYhmEYhunQsOBtJxw4cAABAQH44osvnPc99dRT4r7Wpq3et7nJzs7GBRdcgNjYWPF93njjjbb+SEc03bp1wzXXXNPWH6NdMmHCBHE5mliwYIHYruj6SKaj7O/a8ljV2tvW0b5vp2VP35t+C8Z/WPD6WInUxWAwoFOnTuIgf/jwYXQkKioqxI7+SD9Y1cU999yD2bNn4+GHH8bXX3+NU089tc7nm81mvP322zj++OMRHR0Nk8mElJQUnHXWWfj+++9hs9nQEdi2bZv47dtyZ0ni2X1bCwoKQu/evfHAAw+goKCgzT7XkSo66fLNN9/4fM5xxx0nHh80aFCj3uO9995rNXFztEHHlrCwMI/7SNx5/1bu24tOp0NUVBQGDx6Mm266CStXrvT52mVlZXjyySfFa4WGhgpxOGzYMNx1113IyMhwPm/mzJlif9Dc38Mdeqw5T5Ybum9nXLSH/X+b4WCcfP755w5aJM8884zj66+/dnz88ceO66+/3qHX6x09e/Z0VFZWttjS2r9/v3hv+gwKi8XSYu+Zm5sr3u/JJ5+s8VhLvm9rkpiY6Lj88sv9em5OTo5j5MiRYplMmTLF8eqrrzo+++wzxwsvvOCYOHGic73oCPz888/i+8yfP79B/6+qqspRXV3dLJ+ha9eujmHDhontTG1rt9xyi8NgMDhGjx7tONIwm83i0trQb0i/ZVBQkOO0006rdb9Cjw8cOLBR70H/78QTT6xxv81mE/sJuj6Sacv93dVXX+0IDQ31uI+Wtfdv5b29vPfee44777zTkZSUJH7fe+65x+P5tJ0OHz7cERwcLLarDz74QOzTrr32WkdcXJzHtn/77beL12jKscrX93CHHqPnNNe21ZB9e0fEarWKddZut7fa/r8jYGhrwd0eOe200zBq1Chx+4YbbkBcXBz+7//+D3/88QcuuuiiVvscVGGmS2vTVu/b3OTk5IhKiD9ceeWVWL9+PX799Vecd955Ho9RFWHNmjXYuXMnjjYcDgeqqqoQHByMwMDAZn1tGj254oornH/TtkaVoFdffRW7d+8WFd/aKC8vF1Wr9gKNBrQlp59+utg/5eXlif2V4rvvvkNiYqJYloWFhc36nlRppMr8kc6Rsr/z3l4IOi5ddtlleP3118VvfOutt4r7f/vtN7E/+/bbb8Xj7tD2XF1djSMFX9tWQ/bt/kDLhN6H1ukjAb1eLy5Mwzgyft025oQTThDXe/fu9bh/x44dwkcUExMjdvwkkumg4w4Nz95///1i+IkO5hEREUJQb9y4scHeMhoSch8Gdr+oISnakT3xxBMYOXIkIiMjhSigzz9//nzn69BQRnx8vLj99NNP13gNX542q9WKZ599Fj179hTCh4bYHnnkEWEDcIfunzp1KpYsWYIxY8aI5dKjRw989dVXHs+zWCzivWknTc+h4TayEsydO7fe5bJv3z5ceOGFYrmHhITgmGOOwV9//VXDmkJi7d1333V+v9pYvny5GB6j4UFvsaug3/byyy/3uI++Ow0Z9urVSyyTzp0748EHH6yxTBq67GiYmt6PRCatN8p2Mm3aNPE3LS/6femA5k196yQtG1p2xEknneRcNuo91Geg5aE+w4cffuh8zHtYsqioSAwv0mP03VJTU3HVVVcJ4dUYkpKSxLW7AFHDpbT9kbALDw93/hYkfO+77z6x7On9+/btKwQz/fYK+k1HjBjh8T5nnnmm+N7uy4aGhum+v//+27ms6O+lS5fi3nvvFdsMbU/nnnsucnNz6/QZ+rMduvsh6TN/9NFHznVk9OjRWL16td/L7eyzzxb/7+eff/a4nwQvnaT7Ojj6s17SfVu3bsXChQud64r6nrV5eOkz0PemdYfEN4k0b0uY+k3p/nPOOUfcpuVL+0p/rEPu+yt3vNdRf/YzvvZ39Pcdd9whhCNZAmj5DBw4ELNmzarxnmp7pdenZUnbS2v5gmkZ05A+be/PP/+8c71Xxyqys3hDn5OOQwQtK9pHEu7HE/ftm55D6zAJzKuvvlrc11Qau23Vt2+v79jgvt7+8MMPeOyxx8SJBD23pKTEuV6mpaWJ/SDdpsfVMtq8eTMmTpwoPmvXrl3F9lUf7ts4nZjQ/6Pf7cQTT8SWLVtqPH/evHliX0HvQcuctu3t27f7XH7utgR/jr1f1LP/p8LOlClTxHZLn7F79+647rrr0FFo/6e17QC1UpGvU0EHAdqZ0Mbw3//+V6ycP/30k9h5U5WQNly1AdJOk1YyWnnIbE87RFrZyUtDHlF/ufnmmzFp0iSP+2gHTGfxCQkJ4m/aaD/55BNceumluPHGG1FaWopPP/1UrMSrVq0SHi7aubz//vuiGkCfU4m8IUOG1PreVH378ssvhZgigUHi4MUXXxQb4vTp0z2eu2fPHvG866+/XuwgP/vsM7EjoYMgHTQIOiDQ/6fXpY2TPjdtbOvWrcPkyZNr/Ry0/I499ljhQf7Pf/4jDmD0uchn+8svv4jvM378eHEQoKotvRYJsLr4888/xbV39aQu7Ha7eE/auZBQ7t+/v9gZ0g5t165d4jdv7LKjigz91vR5aCdJ4uyDDz4QYuS2224Tz6P/T0KGqs6qKuHPOknLhpbbW2+9JV6PPjehrgl6TVp/6DPQOkQisjaPIO2Y6XvQTpFEJQldEpGHDh3yqDT6gsSIEsZUYSEB/7///U98RtpWvMUZrcMkVmiZ0AGKDnr0G5CIpHWN1m0S6uQDJiFFvwVBn/H3338X6xgd6On/0YGWltvixYvFaxB0m+7zFgl33nmn2Pbp5Ib2BTRBhsTQjz/+WOt382c7dIcOnPQcWuZ0AHr55ZfFdkn7D6PRiPqg5UEHRvKaqyofnVTTOkGfY9OmTTX+jz/rJX1X+v504H/00UfFfVQxrg06oF577bVCsNNr0fb65ptviuVNv697VY6ELS2PsWPHit/0n3/+wWuvvSZEo/oOTaWx+xmCtm06yaRtjk6yaJs5//zzhRii/Q5B34n8o8nJyUJY03d65plnnAWF1oB+G9q2af2iYwrtY0lUESR2SNTVJr5pfSM/L50A0D7THdpOaJ2i5XDLLbeIfQStF7RPby4aum3VtW/359jgDp3sUVWXTrLoJE9Vkuk3pKIUvRdth3R8pc9E+1PaBuhkm7ZN2ifT+48bN67G/soX9FvQNn777beL/R1tFySe6bihtinaBui9SajSultZWSnmldA+idZZErV1Ud+xd3wd+3+qmp9yyili3aXjB22r9JvQNtBhaGtPRXv08P7zzz/C45qenu745ZdfHPHx8Y7AwEDxt+Lkk092DB48WPgaFeSnOfbYYx29e/d23kePe3vcyANFr+fuCfXliyJ/bV0/0e7dux2RkZGOyZMnC08PQdfefqfCwkLhebruuuv88vB6v++GDRvE3zfccIPH8+6//35x/7x58zy8ZnTfokWLPPyx9H3vu+8+531Dhw51nHHGGY6Gcvfdd4vXX7x4sfO+0tJSR/fu3R3dunXzWNb0PPKn1ce5554rnltUVORxP3mkaDmpCy1HBfnodDqdx+cgyCtHr7V06dJGL7tly5Y575s9e7a4j7x4Bw8edN7/4Ycf1vBh+btO1uXhUp9h1qxZPh9z9+E98cQT4rnTpk2r8dz6vGXqfbwvxx13nCMvL8/jufSe9Nh///tfj/t/++03cf9zzz3ncf8FF1zgCAgIcOzZs0f8vXr1avG8mTNnir83bdok/r7wwgsdY8eOdf6/s846S/gevfcHkyZN8vg+5JckX7/7+kK+S3efq7/bodruY2NjHQUFBc77f//9d3H/n3/+6ZeHl37TGTNmiO+dlpYmHnvggQccPXr08OkLbch6WZuHV723Wo/IN5qQkOAYNGiQhyeWPhc9j9YX79/U2xdPy5+89PVR277Lex31Zz/jaz9Lf5tMJuc6RGzcuFHc//bbbzvvO/PMMx0hISGOw4cPe+yXyYvuz+G1IR7eur7H66+/Lt6P1huioqLC0bdvX3Ef/d9rrrnG8emnnzqys7Nr/N/aPLxq+3r55Zc91usTTjihyR7epmxbte3b/T02qPWWtg1aTu6o9ZLmbrhvt7T/pW3rhx9+cN6/Y8eOWtdDd9Q2Tq9x6NAh5/0rV66s4b8mnzZtQ/n5+R7rHR1rrrrqqhrLj167ocfen2vZ/0+fPl3cT/vLjgpbGnxAVVQ6y6FhUjpbojM7qlrRcK2yKdCwA1XY6IyNqlR0yc/PFxUL8h+qITwaClMVODpzpOfQGTlVzeiMrbHQUC6dsdLZMVV11JAlXaszVapC0mel6hgNuTX2/WgWL0FDT+5QVYjwHjIaMGCA0wZC0LKk70vVKgWdPVL1iZZVQz8LVWqo0qeg5UlVVjobpQpHQ6Gqj3odd+gMnj67uri/Jw3b0llxv379nL8/XeiMnVBD141ZdlQxUFD1i6DX7dKlS4371TJtyDpZH1StoP9TH1Q1Hjp0aI3KCeHPcC59B6os0WXGjBliSJbWCarIUGXDG++qHy1bWt+pYuG9bOmYqKwJw4cPF7/tokWLnJVcZb2gbYIqQvR8qmS5r7cKWrfcvw89h7blgwcP1vrdGrodXnzxxR4jSOpzuG8z9UHVGRrKpaFa+j50TRVmXzR0vfQHqpxSlYgqou7e3jPOOENsJ75ekyqH7tD3bsh3ro/G7mfUcYCqzQoaAaMRAvX5aB2gihyNoLiP1JHFiap0rYnad9G2T9BwNFXsabRDVd6p6keVaKqqetupaltHyFrkvt3Rek3/v7lozLbVXMcGqoDScvIFjQi4r0N0/CId4D6Hh+6jx/xdX2k9odE3BX1W2geqbTEzMxMbNmwQFVnajt3XO6pmq+fVhT/H3tpQoy+0L6bRt44IC14fkF+HDsI0DEKeQRIO7hN2aNiADiiPP/64hyCiCw3NELTjVwc7NaGAXoOGeel5NMRYXFzc6B+OhknJp0VDTGp4TUHDOLSRKM8avR8dbBr7frTzIdFOO3JvvyVtJN47J3dhpqCDufukGRr2Iy9Ynz59hC+Vdsy+hl19fRZfQ+xqaKYxO0oarlRD9O7Q8KUSZN52DzqA0oHU+/en7+P++zd12ZF3jqCTL1/3q2XakHWyPvwZniNo/Wts1BVB2wKJCrqQKKIhNhp+X7Zsmbh2hw686oRTQcuOhIb6/WpbF+ggTScRJHQJuqaDAh0Y6eC6YsUKcTAkUepL8Hr/JkqY1jcJrCHbYWPfwx2yPpB1iuwRJO7T09NrTFhSNHS99Af1f3xtnyR4vV+Tlov30L/3fqKpNHY/489+jLYnOjHzXoaEr/taErXvct8WaB9BQ/Ik9uhClgf6bd555x0xnF8f9HuRQPYuBNRmcaoPXyfBzbHeN/bYUNt+ztd6ScuS9j/e34Hu9/ez+pqES+ulskzWtf3QdyAdQoWuuvDn2FsbZLOkYx5Zc2jfTHaWzz//3K+ToyMF9vD6gM68VEoDnZXRgZEOHORtpI2fRCxB3p/aKmFqh/fCCy8IEUIeR9rJ0JkbHWjuvvtu5+s0FPL+UFWXcje9vYB0H50h0uemnTt5e+mATz4270l3DcXfSRi1zR51n0hEXiL6POStnDNnjhA4dGJAVVX3s+vWgA7GBE0gcPdvkshUQpN2Gu4Tsei3owMoeU594S1Qm7rs6lumDVkn66O2qkdrcPLJJ4trEmzulST3kZLGQNswVZDJO0eCl7x4JOxIsNPfykPnS/D6sz5709DtsDHv4QvaT9E2RP4/qr5Txacu2rLhQkvMMvee8NaU/Uxz/SatgZr8VNs2Tp5eOgbRaAz5Q8mX+txzzzXb+5NIJGFEy8Z7nVJJL74SPdpyGde2n2vsPrg90JTPGBAQIIp8VACgeS00H4LWGfLV03115SwfKbDgrQd1kKIZjXRmTGZu2mGoior3JDJvaAWi/0tn1+5Q1aG+ST2+oIMziRoSzN6pAer96POR0dx9x6OqfI050NHOkgQVVTXdJzfRJAH6HmqCREMh8U8TXOhCFQo6ONGBuq4DEb2Xr3gwSidQjzcUmtn60ksviYOAr1nNvqChTpoURAKtrmXZUsvOm4ask80lcmgZ+Jpl3BRo2N9Xtd0XtOxoSJmGcd0rW77WBRKylJxAJ4pk7VDCltY5JXip2lLXhKyG4O922NyQsKcqD826psiq5lgv/V1f1P+h7VNZexR0X3Ot6+oE1DstgH5fGhZujv2MP9BJDIk4Gl3xxtd9LQV9Jxrpo5Ns99+ytuXmvd3W9vvS7/Xvv/+K13cXO772v/Rc2nbp5MJbdNOyoBOR5vz9W+vY0Jz4stXQBGc1Ec19+/H1HUgvNEcUY0A92zMlW9CFCgQ0WkQ6g+xRrV2IagnY0uAHFIlCVV+aQUpnqrSjo/sobcHXDtY9VoUEs/fZFfk/G9O5jd6LPER0UHvllVfqPMNzf0/yclH0lvesbsKfiBmydRDe7RtVdZOGoxsKeUvdoR0q7SjrGz6hz0Kz3N2/Dw3zUKQT7Tjqq2j5gkQueaToNagS5Avv35B+B/oNP/744xrPpWFONfTUEsvOFw1ZJ9VOs6nxQjT8RaLfO2miKVUPlZhB1cn6oGVLB1I6EXWHKni0U3f3UZJXjk4GSASSAFJpISR8qXpBsVu+qruNxd/tsLmh700zsElY00z22mjIeknriz/rCo2K0XpI1VP37Zi81JT80FzrOkGiTXmyFbT9eld4G7uf8fc3ppNLSmRx71xGAk/5x1sa2tfQ70x2HBq1UGKGtktf0YA0bE72Hfdh89r2B7SOkIilRB8FLV9KDfBGbWve2yKhIr1a2tfcEseG5oTWE/fjPn1W2ieo5UL2ERqxJSuU+29BJyc0OqG22aYSWsvvTbYH7/22GkHuKLYGrvD6CQ1Lkj+OzP800YI2YhKeNKxNflqq5lB1hDY2imRSObtUPSQfGVUXKDKFIkiokqgqcg2BJueQcKGsVzrjcoe8gnSh96OqEg1d0QFm//794gBEG7t71YyGc+g+in+hyhaJABre9eXJJPFBBn/acdBGQl4f2lhpw6QhW6pgNxR6bxJoFJdC700TXqgqRvEvdUEVdqrS0U6Clgf9X/oc9D1pElVjh71pCJrihej70GvTgYyqIVlZWaKKSAdX9x02HWQo8ovWBZqgRqKZDgZ0Jk73qxzbllh2teHvOkk7MTpYk/gjPynZBagip6LtGrJN0G9G2wUNfdFvSQdemuBJ61x9opV2/qodLlXn6PORYKdKhj8TYyiujZYfHejJB0fvRwcGOmmhERD3CUd0gkefj8StyuAlqNpHB0W6NKfg9Xc7bAnIe0eXumjIeknLjUQPDYGTWKT1xLuCS6gTCtrX0evRhDkVS0aCg/KamwuqNtG2RydddLJK6w5tc96jZo3dz/gLVYppnaPtnyZ3qRMw2o/SBKTmxH17oXWIhCsVT2gfRZMNKWJMQfMO6KSHJoBStY6EPk1copgqEi/uGca0bAjan5IdivYNl1xyidhO6HvRPpe2L1qWtE778qDTPoV+E/qtqZKpIt/oc9BkK3rMn5PYptBSx4bmgrYd2j/TekK/AZ1skrefjucKKmTR56c5BzTJUMWSkVe4qe2fFbXt/6maS23EaZ9F+04aOaOCDk3UbC6x3ea0dUxEe0JFffiK5aBIE2ovTBcVAbZ3714RFULtHY1Go6NTp06OqVOniigzBUVEUSRIcnKyiCWh2KXly5fXiFrxJ5aMnu8rysk9GoUiXihShSJKKI6EYn4oFojiVug+dyj+iiKAKH7H/TV8xfRQ+82nn35aRLzQd+3cubPj4Ycf9ojAqis+x/v7UpTUmDFjHFFRUWK59OvXz/H888/71bqWljtFT9H/pZap9Dr0Hb3xN5ZMQVFKb7zxhmPcuHGOiIgIES1Evy39pt9++63zd1fQZ/2///s/ESFEyzo6OlosT1pOxcXFzbbsfH0Ptb688sorNZZNfeskQa18KZaHIoDcI2rqij/yjnwiKD7njjvuEO9D61Fqaqp4jne0mK/Xcl9/KXaH4nguvfRSjyio+iKPKHaIYn1SUlLE96X4NVomvmLRKKaL3ot+M3d69eol7qdl58/+wDuOy9f67e92WNvvSPgTeeQeS1YXvqKu/F0vs7KyxDoRHh4u3kt9T1/Lgfjxxx/F96XvHRMTI1rAuscx1fWb1hfF6L4/fuihh0SbXIoFo3bgtN54r6P+7GdqiyXzte/wtQ38+++/4vvS+k/Hh08++UTs82nf1JyxZGpboXgs2j/Rc2688UYRb+XNvn37RAzcMcccI7Yr2pdRvCb9ju6RcwTt16hNMT1Or+2+LGj7vvLKK8X7UQQm3V6/fn2NY5X6Td58800RBUffnS50+6233qoRzdmUbauu38efY0Nd20xt66Wv38SfuDjvbfy1114T2xltGxTvRpFj3lAsKukEWl9puVP03bZt2zyeU1ssmT/H3tr2/+vWrRP73y5duojPR+sNHTvWrFnj6CgE0D9tLboZhmEYpqNAVfLGxqExHQuqjlMiBFVvaf4N03awh5dhGIZhGol3ZjSJXBrGd281zTBM28MeXoZhGIZpJOSVpwg6uqZJYeR3pqYj7t5MhmHaHha8DMMwDNNIaLIrTZaiyWM0AYgmHFH+uq9GAwzDtB3s4WUYhmEYhmE6NOzhZRiGYRiGYTo0HVLwkoeKMmkpP44uNMTkHgROkwkoh9P9QpmO7qSlpYn8TMrvpNxJyhxVXaAYhmEYhmGYI4cO6eFNTU0VrWLJQ0WpaxQ+TUHs69evd3ZYomB+agjh3XmMoPBwErtJSUlYtmyZ6Fx11VVXiWB18mb5C7XupA481Pa0LXvWMwzDMAzT8SHNQ00jUlJS2rzZRrvDcZRATQEoEJygEOa77rqr1ufOnDlTBOFT4Lri/fffFyHQZrPZ7/dMT0+vtVEEX3gZ8DrA6wCvA7wO8DrA60BLrAOkPxhPOmSF1x2q1lL7RWodStYGBbX3pTaNVMWlFoqPP/64s8pLrVipPWtiYqLz+dRykVoCUpj48OHD/XpvquwS6enpwlrBMAzDMAzTUpSUlKBz585O/cG46LCCd/PmzULgVlVViT7i06dPF73Aicsuuwxdu3YVJf9NmzbhoYcews6dO0WfcILiZdzFLqH+psdqg/pj00VBwwqE8hIzDMMwDMO0NGyjPIoEb9++fbFhwwYUFxfjl19+wdVXX42FCxcK0XvTTTc5n0eV3OTkZJx88snYu3cvevbs2ej3fPHFF/H000830zdgGIZhGIZhmoMO62imTje9evXCyJEjhRAdOnQo3nzzTZ/PHTt2rLjes2ePuCabQ3Z2tsdz1N/0WG08/PDDQmCrC1kZGIZhGIZhmLalwwpeX4kJ7nYDd6gSTFCllyArBFkicnJynM+ZO3eusCUoW4QvqMuOsi+wjYFhGIZhGKZ90CEtDVRpPe2009ClSxfho/3uu++wYMECzJ49W9gW6O/TTz8dsbGxwsN7zz33YPz48SK7lzjllFOEsL3yyivx8ssvC9/uY489httvv12IWoZhGIZhGObIoUMKXqrMUm4u5edGRkYKIUtid/LkycJm8M8//+CNN94QyQ00m/H8888Xglah1+sxY8YMkcpA1d7Q0FDhAXbP7WUYhmEYhmGODAIom6ytP0RHjgchwU1+Xk5pYBiGYRiGdUfbcNR4eBmGYRiGYZijExa8DMMwDMMwTIeGBS/DMAzDMAzToWHByzAMwzAMw3RoWPAyDMMwDMM0A4W/70HmS6tgK6vm5dnOYMHLMAzDMAzTRGwlZpSvyIStyIzqAyW8PNsZLHgZhmEYhmGaSMX6HEALerUW+e7syrQdLHgZhmEYhmGaALU0KF+b4/zbVsyCt73BgpdhGIZhGKYJWA6XwZpT4fybbA1M+4IFL8MwDMMwTBMoX5stRVWIQVxzhbf9wYKXYRiGYRimCVRuyRPXYcd3Etfs4W1/sOBlGIZhGIZpJA6bA/ZSi7gdPDBWXNtLq+Gw2XmZtiNY8DIMwzAMwzQSe5XVedsQFwwYAkRag62Ys3jbEyx4GYZhGIZhGom9QlZ3AwL1CNDroI8MFH+zj7d9wYKXYRiGYRimkdgrrR4T1gxK8HJSQ7uCBS/DMAzDMEyTBa9RXOujpOC1chZvu4IFL8MwDMMwTCNxVGiCN9jgIXi5wtu+YMHLMAzDMAzTRA+vU/CypaFdwoKXYRiGYRimuTy8XOFtl7DgZRiGYRiGaargDWYPb3uGBS/DMAzDMEwjsVd4VniVpcFRaYXdbOPl2k5gwcswDMMwDNPkCq8UvLogAwKC9OI2Z/G2H1jwMgzDMAzDNNOkNYJ9vO0PFrwMwzAMwzDNNGmN4G5r7Q8WvAzDMAzDMM3UeELcDjeJa1tpNS/XdgILXoZhGIZhmEbgcDick9YC3CwNeha87Q4WvAzDMAzDMI3AUW0D7A4pqHwIXjtXeNsNLHgZhmEYhmH8wFpQBYfV7vxbVXdhCECA0SWpdOHS3mArlRPamLbHdTrCMAzDMAzD+MScVoLc9zbCEBeM2KsHwBgf4tF0IiAgoKaloYw9vO0FrvAyDMMwDMPUQ+WGXHFtzatEzrsbULWnyNV0ws3O4GFpKKkWPl+m7WHByzAMwzAMUwckWiu35TsjxxxVNhT+vNOVwesWSSb+DpOC12GxS58v0+Z0SMH7/vvvY8iQIYiIiBCXcePG4e+//3Y+XlVVhdtvvx2xsbEICwvD+eefj+zsbI/XSEtLwxlnnIGQkBAkJCTggQcegNWqeXUYhmEYhjlqsGRVwFZkBgw6JNw5DAigLmrVsGRX+Kzw6gL1CDBp3dbYx9su6JCCNzU1FS+99BLWrl2LNWvWYOLEiTj77LOxdetW8fg999yDP//8Ez///DMWLlyIjIwMnHfeec7/b7PZhNitrq7GsmXL8OWXX+KLL77AE0880YbfimEYhmGYtqBKq+4G9Y6CPswEQ0KI+Nu8u7BGBq9CH+GyNTBtT4DjKDGXxMTE4JVXXsEFF1yA+Ph4fPfdd+I2sWPHDvTv3x/Lly/HMcccI6rBU6dOFUI4MTFRPOeDDz7AQw89hNzcXJhMciWuj5KSEkRGRqK4uFhUmhmGYRiGOfLIfns9LIfLEH1+b4SOTkLBTztRsS5Hlg3tQNjxnRA1tYfH/8n5YCOqD5Qg5rJ+CBkS3yqfk3XHUVbhdYeqtT/88APKy8uFtYGqvhaLBZMmTXI+p1+/fujSpYsQvARdDx482Cl2iSlTpogVSVWJGYZhGIbp+FiLzULsko0hqF+MuM/UKUw+qCWUeVsaGtN8gt7Hml/ZbJ+bOUpiyTZv3iwELvl1yac7ffp0DBgwABs2bBAV2qioKI/nk7jNysoSt+naXeyqx9VjtWE2m8VFQQKZYRiGYZgjl6odBeLa1DncKWKNqeEez/GetObZfKL+LN7K7fko+G4HoAtA8sNjoAvqsPKszeiwFd6+ffsKcbty5UrceuutuPrqq7Ft27YWfc8XX3xRWBjUpXPnzi36fgzDMAzDtCzmPUXiOqhPtPM+Y3KoqPjWJXhdzSfqrvCWr85C/tfbZKKD2QZLRlnzfXim4wtequL26tULI0eOFEJ06NChePPNN5GUlCQmoxUVyRVYQSkN9BhB196pDepv9RxfPPzww8Kvqy7p6ekt8t0YhmEYhml5aJqTeV+xuB3YyzUyrDPpnRPXxN/BxkZZGijWrPC3PcIaoTq1VWeWN+t3YDq44PXGbrcLuwEJYKPRiH///df52M6dO0UMGVkgCLomS0ROTo7zOXPnzhUTz8gWURuBgYHOKDR1YRiGYRjmyMSaXQF7uUWIUZOXjcHp463Fw6tzWhpqF7w2SnCwOUSFOOyETuI+CwveFqFDmkSo0nraaaeJiWilpaUikWHBggWYPXu2sBpcf/31uPfee0VyA4nSO++8U4hcSmggTjnlFCFsr7zySrz88svCt/vYY4+J7F4StQzDMAzDdHyq9srRYFO3CAQYPGuERhK8lNRQm4c3rP72ws5ObSFGmFKkgGbB2zJ0SMFLldmrrroKmZmZQuBSEwoSu5MnTxaPv/7669DpdKLhBFV9KYHhvffec/5/vV6PGTNmCO8vCeHQ0FDhAX7mmWfa8FsxDMMwDNOamPdqdoaenhPd/anwOietlVngsDsQoHMz/WrYq6TgDQjSS18wCd7scjhsDgToaz6faTwdUvB++umndT4eFBSEd999V1xqo2vXrpg5c2YLfDqGYRiGYdo7JFLN+zXB2yOyxuPGlDDoQo2i8hvgI1WBHhMT2xwQtgglgN2xV2oV3mAD9NFBojsbtSK25lWILm4VG3MRc2EfTm1oBjqk4GUYhmEYhmkKZC1wVFoREKiHqZOnf1dNXEu8dyQCAuCzeksVWhK9VOGliWv1CV56DaryVh8sQfXBUhT9vV+8f+WAfISO9IxKZRrOUTNpjWEYhmEYxl/Mmn83sHtkrfYCfajRZ1thf5MaHJqlQVkilK2h5N80IXYJf5pRUJoEVaSZ2mHByzAMwzAM40XV7sJa/bv+Ul9Sg7PCG+QpeG3FriZW1vyqOt/DbrYh65U1yP9yqxC+jG/Y0sAwDMMwDOOGw2KDeb/slhrU19VwoqHow+puPqEEb4BXhdcda0HdgteSVQ5bQZW4ONIbL847OlzhZRiGYRiGcUM0m7DaoY8MhCE+uNHLRh8lo0xtha6KbW0eXsKY5OrgZuoifcO2eiwN7tXj8jWeTbMYFyx4GYZhGIZh3KjaVeis7gbQrLRGYogJqrNKq2LJlOCliXCmrhGAQYfIqT3kcyqsoiNbnc0rNCq35vHvWAtsaWAYhmEYhvEheAN7RzdNZCnBW+hb8DoqbR4eXiLumoFCCBuigqALkykPJJhNtUyO87BLWNnDWxtc4WUYhmEYhtEgcWnNrRQKKahX0zyxek3w2orMPlMUvC0N4naQQYhdwhAbXO/ENVXhVe/F+IYFL8MwDMMwjFc6g6lzhM8Oag1BHxEIUKSZzQFbibn2Tmu1vI8hVlkiavfxqgpv2LEponEF4xsWvAzDMAzDMO4T1si/26dpdgaCmkkYtIlr3lVaah/sMGuWhtoEr7JE5NVe4bVrFV5jfDCiz+vNv2MtsOBlGIZhGIbRUI0ejEkhzbJMnLYGLx+vqu4KMRbkuzJriAv2u8JLmb/B/WOa5TN3RFjwMgzDMAzDaJDfltBrPtqmYoj2ndSgOqmRDSFAr6tbLNfi4XXY7LCXywQHfUTN1sWMCxa8DMMwDMMwVHWttolUBMIQLa0IzVfhNdcSSVa771ZNWqOJadQMwxub9lmhC6izxTHDgpdhGIZhGMajuhsQqK91IllzZfH6SmjwRhdiEJ/F1/8Xr6ESGsKNwi/M1A5XeBmGYRiGYdx8tlTdbUrDiYYI3gC3DF5v6DM4fbw+bA0qkoz8u0zdsOBlGIZhGIYRDSI0/67mu20O1GtRC2B3W4J3l7XaUNFk1emltU5Y07PgrRcWvAzDMAzDMMLSIKuoei1KrDnwsCW4+XjVpLX6BG/wwFhxXb4mCw6r3bfg5Qlr9cKCl2EYhmEYxk2QqmSF5kDYEnzYGuw+2gr7IogEL7UYLrWgckuex2NUNSa4wls/LHgZhmEYhmHcPLz6Zkpo8LY1uGfx2itlwkJ9k+PeW7QPH5dJO0PZsgzfHl6u8NYLC16GYRiGYZgWqvCK11MV3lxXAwl7Vd1d1hQbDxXjD1hgCwCq00pRfajUh6WheQV6R4QFL8MwDMMwRz0Oi91lEWhmwWvqGu704Vq16DN/YsmIoopqFMKBfXEyiaHwl12wV1g8KrxsaagfFrwMwzAMwxz1WIu1DF6jTkw0a06CB8bB1DUCjmo7imfs9Zy0Vo+Ht0gTt/PjDdCFG2HJqkDel9tgN1thL2PB6y8seBmGYRiGOepx+XeDmi2DV0FNIaLO6SVUV+WWfFTuLPC7wluoCd6DVhvirhuMgCA9qg+WIPf9TYCDXhzQhXGXtfpgwcswDMMwzFGP1a3pREtgSg5F2LGdxO2SWQdcjSfqELwOhwPFlbKKW1RpEa8Rd81AIXotWeXifl2Yibus+QELXoZhGIZhjnpsLdB0wpuIiZ0Bgw6WzHLYyy31VnjLq22w2BxOLy8R2C0Sif8ZAWPncI/GFEzdNK9JhWEYhmEY5ghvK9xS6EKMCBkaj4q12a77gmVTCl8Ullf7vE2pDwk3D0HFxlyYukjhy9QNV3gZhmEYhjnqcbYVjmrZimnYuGQPFRZgql3wFmtZvURJlRVWm6vTWoBBh9CRiTDGh7Tch+1AsOBlGIZhGOaoxmFzwJJRJm4bk1pWQJpSw51VWUpoqGuCXKFmY3AXvXVRWS2zfZmasOBlGIZhGOaoxppbIXJ4qdpqaIWKaei4FHGtC5fZuvVFktUmgL0nuJ36xqJm+oQdD/bwMgzDMAxzVFOdLruXmVLDWiXxgHy81OSC3q8u1ES12v52Z09OGfLdfL6MJyx4GYZhGIY5qlHtelXyQUtDojp8fGq9z6tR4dWSHXyxYl9+s3y2jgpbGhiGYRiGOapxr/C2J1TTCdfftVdwV+wraIVPdOTSIQXviy++iNGjRyM8PBwJCQk455xzsHPnTo/nTJgwQRjF3S+33HKLx3PS0tJwxhlnICQkRLzOAw88AKu1bsM4wzAMwzBHDg6LTbTrJUytVOH1F28Lg3tqg7d/d+V+rvAedZaGhQsX4vbbbxeilwTqI488glNOOQXbtm1DaGio83k33ngjnnnmGeffJGwVNptNiN2kpCQsW7YMmZmZuOqqq2A0GvHCCy+0+ndiGIZhGKb5qc4oB+wO0Z5XH9lyGbyNgbqrESEmPSqqbbVWePfmliGvrBomQ4esYzYLHVLwzpo1y+PvL774QlRo165di/Hjx3sIXBK0vpgzZ44QyP/88w8SExMxbNgwPPvss3jooYfw1FNPwWSqe2YlwzAMwzBHjn+X4sLqighrC5TA7RYbim2ZJTUsDorlmp1hRJco7G3VT3jkcFScChQXF4vrmJgYj/u//fZbxMXFYdCgQXj44YdRUSGHNIjly5dj8ODBQuwqpkyZgpKSEmzdutXn+5jNZvG4+4VhGIZhmPaLRfl325mdgSjWBG73uNA6UxrUhLVRXT11DtPBK7zu2O123H333TjuuOOEsFVcdtll6Nq1K1JSUrBp0yZRuSWf77Rp08TjWVlZHmKXUH/TY7V5h59++ukW/T4MwzAMwzQf1YfL2q3gdVZ440J8pjY4/btahXdUt+hW/oRHDh1e8JKXd8uWLViyZInH/TfddJPzNlVyk5OTcfLJJ2Pv3r3o2bNno96LqsT33nuv82+q8Hbu3LkJn55hGIZhmJbCYbXDmlcpbhuTXHN82gN2u8M5Sa17nEyP8GVp2JtbjrwyMwINOgxOjWz1z3mk0KEtDXfccQdmzJiB+fPnIzW17ry7sWPHius9e/aIa/L2ZmdnezxH/V2b7zcwMBAREREeF4ZhGIZh2ifW/ErAAQQE6aELN6I9UVplpbl0gm6xqsJbjcLyatzz4was2l/gYWcY0SUagQZ9233gdk6HFLxU3iexO336dMybNw/du3ev9/9s2LBBXFOllxg3bhw2b96MnJwc53Pmzp0rROyAAQNa8NMzDMMwDNMaWHJkdZfaCbfXCWuU0JAQHuS875sVBzF9/WE8O2Obh+A9pkdsG37a9o+ho9oYvvvuO/z+++8ii1d5biMjIxEcHCxsC/T46aefjtjYWOHhveeee0SCw5AhQ8RzKcaMhO2VV16Jl19+WbzGY489Jl6bKrkMwzAMwxzZWPPkZHVjfDDaGyqSLDrEhKhQWX2ustixYFeuuL35cDEyiyuxUqv0HtODJ6wddRXe999/XyQzUHMJqtiqy48//igep0gxihsjUduvXz/cd999OP/88/Hnn386X0Ov1ws7BF1TtfeKK64QObzuub0MwzAMwxy5WN0qvO0NVeGNCjEiPNAAg05WoNelFTqf8+HCfcgtNYv83aGdo9rssx4JGDqqpaEuaCIZNaeoD0pxmDlzZjN+MoZhGIZh2guW3PZb4VWRZCR4yW5B19Rcwl3ikL1B5e8GGfWolvqdOVoqvAzDMAzDMPUVx6y5qsIb3I4rvLLRVWSwa1LdgGQ5Kd6qzWpj/279sOBlGIZhGOaow15qgcNsE0rIENseBa9W4dWELnl5FZeO6Ywe8a4YtbHdecJafbDgZRiGYRjmqLUzGKKDEGBof3KoWKvwKqGrKr2qojt5gGyGRf7d4V3Yv1sf7e8XZhiGYRiGaWFcdob2N2HNo8Iboiq88jo21IReCWE4d3gnIXZPGZAo/LvMUThpjWEYhmEYhrAVm6ELNdao4lpVhbcd+nfdY8lUZTc61OSs7tIktn5JEVjx8MkIDWSx6w9c4WUYhmEYxkmVxYYPFu51dvI6kqnaU4TMl1ah+O/9NR6zaBVeYzut8CpLg/LwnjOsE47vFYfrT3A104oJNXF3NT/hCi/DMAzDMIKMokrc9PUabDlcgh5xoZh3/4QjeslUbMgRrYMrdxQg6syezvsddgesOVqFN6F9VniLtQpvpGZlGJASgW9uGNvGn+rIhQUvwzAMwzDILqnCWe8sEVmvxP78clHtPVL9oRQ7VrVLNmmw5VfBXmmFLtgA84FiFP25D7Yis0xoaK8VXiV43eLImMbDlgaGYRiGYTBzc6YQu93jQhEWaBANDg7klx+xS8aaXQF7iRTvRHVGmfDz5n6yBZbDZQgI1CP6nN7Qa21725tYL6myitsseJsHFrwMwzAMw2BXdplYCqcPTkLvxDBxe2/OkSt4q3a6WvASlowyWfG12mFIDEHSA6MQOiYJ7ZEysxU2rakEC97mgQUvwzAMwzDYnV0qlkKfxHD0itcEb64UwQqrzY5ys6w8tneqdslJd/oImW5AVV2axEYED4qDPsyVa9te7QwUO3akWkraGyx4GYZhGOYoh4bQd2mCt3dCOHomSMG7J8dT8N741RoMe2YOHp62GekFctJXe8RutsF8oETcDhufKq6rD5fBrAneoF7tu1ED+3ebHxa8DMMwDHOUk1tqFp5RXQBEy9qePiq8JIqX78uHxebA96vSMPn1hdiRJUVlu6zu2hzQxwQhZGi8s9GEvdyCAJMepi7hOBIEb0QQZws0Fyx4GYZhGOYoR/l3u8aGiiH0nvGh4u99ueWwa17S/PJqVFnsCAgABqZEiNtfLD2A9gb5dAt/2S1uB/ePgT7cBF24y74Q2CMSAfr2LX9KOKGh2WnfvzjDMAzDMC2Oy84gK7tdYkJg1Aeg0mJDZkmVuO9QoWzUkBgehMenDhC3/9yYgYrq9uPprdxZgLwvtsJhtglhGzG5q7jf1El+LyKwndsZCLY0ND8seBmGYRjmKGd3jmvCGmHQ69AtVlZ592o+3sOa4E2NDsbY7jHoFhuC8mob/tqUifZC+fJMwO5A8KBYxF03CDrNEmBMkd+FCOrNgvdohAUvwzAMwxzlKEuDiiMjvH28hwrlJLVO0cEICAjAhaM6i79/XnMI7QHyGFenuyaqBRhcEseUKoU8WRsMCe2z0YQ7XOFtfljwMgzDMMxRDAlF90gyRc+EUC/B66rwEuePSBWT3FYdKMA+r/iytsBWaIa93AroA2BKdgl3IqhfDMInpCL6gt5CrLd3WPA2Pyx4GYZhGOYoJkdLaNDrAkRCQ40Kr9Z8QlV4U6NlhTQpMgjj+8gEhDnbstHWVKdL0W5MDkWA0VPeBOgCEHlqdwT3jcGRQHGl9EVHcFvhZoMFL8MwDMMcxagJa11jQxBo0NcQvLuVh7dIVng7RckKLzG6mxSQ2zJK2o3gVfaFIxmu8DY/LHgZhmEY5ihm8+Fij4QGBfl5qeqbV2YWYtfb0kAMSI4Q19sz24HgPaQJ3s4seJmasOBlGIZhmKMUahVMTSQIZU9QhJgMGJQiBe3crVmoqLaJ2yluFd7+muDdl1eOKot8vC1w2ByidXBHEbycw9v8sOBlGIZhmKOU2VuzkV5QiZhQE84bLlvwujOyq7Qs/LYhQ1zHhweKxhSKxIhARIUYYbM7arQhbk0s2eVwUFOMID0McS5BfsRbGkKMbf1ROgwseBmGYRjmKE1n+GjRXnH7imO6ItjkErKK0d2ixfWG9KIadgaCEg/6J8kq77Y2tDU47Qyp4WKC2pH+u7CHt/lhwcswDMMwRyGrDxRi46FimAw6XDVOdiTzZqQmeBXuE9a8bQ1t6eO1pHccOwM186CKORHJKQ3NBgtehmEYhjnKoCriG//sErfPH9EJcWGBPp+XEB4k0hsUKpLMnX7JUmTuyJRV1rbAfLC4wwheVd2l1s7BbvYRpmmw4GUYhmGYo4x/t+dg2d58Ud29bUKvOp87SvPx+rI0eCQ1ZJUIId3a2EqrYc2pBAKAwG7ysxzJFFdo/t1g4xHRJONIgQUvwzAMw7QgXy0/gJNfW+Bs3NDWWGx2vPD3dnH7uuO6o3NM3a12lY9XtRX2pleCjC8rqrAgq6QKrY15v6zuGhNDoesAk7xUhZebTjQvLHgZhmEYpgX5Ze0h7M0tx9I9ee1iOf+wKg37cstFMsNtJ/Ws9/mj3ARvZx+Cl1Ibemod2trC1qAEb2CPSHQESqpcFV6m+WDByzAMwzBeLN6di1dn7xQ5tU0ls1hWPXNLze1iOf+xUUaM3X5SL0QE1S+qqOPaqK7R6JcUji4xrtbD7vRrw6QG8z7Nv9u9YwheTmhoGQwt9LoMwzAMc0SSU1qFW75eK2bLD+oUgVMHJTf6taqtdtGprL0IXvLY7sySVdhxPWL9+j/kI/35lnF1+klVl7YDeeVoTWzlFlizpVUksHvj/LtZxVXiNxrUKbJdNZ3w52SEOcorvC+++CJGjx6N8PBwJCQk4JxzzsHOnTs9nlNVVYXbb78dsbGxCAsLw/nnn4/s7GyP56SlpeGMM85ASEiIeJ0HHngAVqu1lb8NwzAM05pQZZfELrFqf2GTXiu7pApqHleuJnzbkpxSM0qqrKCo2h6aDcEf6ps8lazFlalqdmtRrdkZDAkh0IeZGvUaV3+2Cme9swSZxbJ1clvDFd6WoUMK3oULFwoxu2LFCsydOxcWiwWnnHIKystdZ5733HMP/vzzT/z888/i+RkZGTjvvPOcj9tsNiF2q6ursWzZMnz55Zf44osv8MQTT7TRt2IYhmFams2HivHz2kPOv9ceLGjS67lP4moPFd7d2TKvtltsqEfHtKaSEhkkrjNaWTQqO0Nj/btlZit2ZpeCYm8P5rePSYUseFuGDmlpmDVrlsffJFSpQrt27VqMHz8excXF+PTTT/Hdd99h4sSJ4jmff/45+vfvL0TyMcccgzlz5mDbtm34559/kJiYiGHDhuHZZ5/FQw89hKeeegomU+POJBmGYZj2y4t/bxcV2bHdY7ByfwG2ZpSgstrmswtZbZBILq2yYkLfBI+KJ1VX25pd2dLO0DtRWhCaixRV4S2iiraj1eK0zPuKmiR497q1Q6aUifYAC96WoUNWeL0hgUvExMgsQRK+VPWdNGmS8zn9+vVDly5dsHz5cvE3XQ8ePFiIXcWUKVNQUlKCrVu3+nwfs9ksHne/MAzDMEcG1N1q1X5Z0X3hvMFIjAiE1e5wttX1BxJ7132xBtd/uQY5JVXIcqt4tosKb44UvH0Sm7dBQ5JW4a202JyCraWxFlTBklUh83d7RjXqNXZ7CN5qtAdY8LYMHV7w2u123H333TjuuOMwaNAgcV9WVpao0EZFeW4gJG7pMfUcd7GrHleP1eYdjoyMdF46d+7cQt+KYRiGaYnJaiRwDboAMeSvGi40xNZA3l8SLCSet2eVelR4K6ptKDe37TyQXZqloXczC16yR8SGypHPjKLW8fFWbssX16ZukdCHNm6C1x43wVvYziq8nMPbvHR4wUte3i1btuCHH35o8fd6+OGHRTVZXdLT01v8PRmGYZjmIaOo0lmtpEYKI7vK/Nk1B/2fuFZY7qoS7s4uFQkA7rRllZeqz8rS0KeZLQ1EclSQx3Jsaao0wRs80L+0CV/s0Sre7aXCW2WxOdcZzuFtXjq04L3jjjswY8YMzJ8/H6mpqc77k5KSxGS0oiLPYSpKaaDH1HO8UxvU3+o53gQGBiIiIsLjwjAMwxwZHCqs9PCjqoYL6w4Wwk6zmvzA3QdKE8S8UwvaMqkhu8QsvMUk5rvH+Z/Q4C/JkSqpobJV4sjMB6RdMXhAUwSve4W3bQVvRbUV132xWqwzISY9+iY1bxX+aKdDCl46iyWxO336dMybNw/du3f3eHzkyJEwGo34999/nfdRbBnFkI0bN078TdebN29GTk6O8zmU+EAidsCAAa34bRiGYZiWOE54o4biUzXB2z85AsFGvYjxcvd61kWBm2giv6yq1tHrtHWFV1V3u8WGINDQfAkNNZMamtfS4LA7UL46C+Y017yYqh0FgB0wJofCECPftzHV1LSCinZjabjju/VYtjcfoSY9Pr9mtOiExzQfuo5qY/jmm29ECgNl8ZLnli6VlfKsk/y1119/Pe69915R/aVJbNdee60QuZTQQFCMGQnbK6+8Ehs3bsTs2bPx2GOPidemSi7DMAxzZEJD7mNe+Bf/N2uHx/2Hiyo8KrxGvQ7DOsu5Hhv9nLjmPixOflnyBRPUwKK9CN7mnrBWM6mheSu85SsyUfjrbuR/tQ0OrfOd8u8GNaG6uz+vXMSRtQdLA4nveTtkge3L68ZgrJ9NQZijXPC+//77wkM7YcIEJCcnOy8//vij8zmvv/46pk6dKhpOUFQZ2RSmTZvmfFyv1ws7BF2TEL7iiitw1VVX4Zlnnmmjb8UwDMM0B/N35gjh+ffmTJ8VXiXciO5ac4b0wooGe3gp45UElVEf4Gy9qwRwW2bwNveENe/mE81Z4bXmV6L47/3itr3MAvOeItgrLDDvKmw2OwNZPNq6wpuvrTe0rijvONO8GI6WoSpvgoKC8O6774pLbXTt2hUzZ85s5k/HMAzDtCXbMuTQOHkl3TNj1WSrTtEuwdtJE3GHNX9vffgSTYkRQSLirM0rvDktN2HN3dLQXB5esjIU/LIbDotdlufsQMWGXFiyK8R9xqQQGFMa70VWNpVBKRHYeKi4TSu8BWXyvWNDA1stw/hoo0NWeBmGYRimNqiZBGG22j0EqhK1nbS0ASJVE7+H/Rym9yWakiODEB/etoLXYrM7hf6A5IgWrfCSb9nfSX51Ubk5V7QODjDpEHNhX3nf1nyULcsQt8OO7dQkcaiaTozqFuOccOhPwawlyCuX6wX7dlsOFrwMwzDMUQPl4+7Ick1+UlXdkioLSrWMXHdLg7PC66fgVQI6LNA1gJoUGewSvG2U0rAzq1QIfIq6aomEBiIxPBDkDrDYHE4B1xRKl0hhGz4+FcHD4qGPCoSj2gZbkRm6EIO4rzmacIzW0jgog1mtA21W4Q3jiWotBQtehmEY5qhhf14ZqmiIXEPFhqnqbnSIESEml1hV9gaqWpJYrg8VbaUizVSFNyE8qE0rvOvTpOd1aOeoFhsyN+h1wr7RHM0nKJHBkl4K6AMQOjZZfOYQN4EbMjoJuga0e/a1PPbllovbA1MiEWSUcqiovG18vAWah1c172CaHxa8DMMwzFFnZ1Co1r++/LsECVXqvEbVv+ySKr9zeEdrw+REUoTL0pBXVt0sw/00Oe6r5Qf8ngS3XkuZUKkTLQWJ+4YmNfyzLRs3fLkaafmuiYFlS2V1N2RoPPThUgSGDEuQDwYAYcckN/ozbjlcjKs+WyV+0/F94oVtJTrE1KZZvGrSWkwop0C1FCx4GYZhmKMG5WNVqEQBZVlI0ZonKGgGv+og5o+tQQkmmmmvTf4XIpC8mVRYpSqxe1ZvY3l3/h488ftWTH1rCdZp1du62KAJ3uFdWljwNjCpgSa43f3jBvyzPQe3f7cO1VY7bMVmVG7OE4+HHdfJ+VxjUiiiL+yD2Mv7wxDduOxdSs64+rNVogHHqK7ReP/yEaJ6HNXWglezurCloeVgwcswDMMcdRVe5WNVlUin4NUEW9WuXSj69VcxiakhSQ2qwktD+wNS5OSw3olhItM3RhNVzWFrWHWgQFznlJpxyYcrsHBXbq3PLa6wOIfvh6W2rOB1JjX4cXJAy/bR6VuECCU2Hy7Gy7N2oGJLHijPzdQtAqZOnokSoSMTETwortGfb/WBAlFNpZOQz68djVDNa01WFqK4sm0tDTxpreVgwcswDMMcFZDA2poh29FO6p/gUYl0dlmLDoa9qgrp19+AzEcfQ8Xq1egUFeJXhZeqk0q8kYD68MpR+OGmY9ArQebeNldSAzUpUJXqMd1iUG2z49MlMqvWFxsOFTk7rEW3sEdUnTD4Uw3/Y2OGaLZg0uvw39P6ifs+WbIfaQfk5zV1bv68YGoTTRzbMw7hQVLkEk5Lg1uOcltYGtjDe5QIXovFgvT0dNHmt6BAnr0yDMMwTHOQVVIlUhTIpnBiHyl4Vevfw1pjCRJsRT/+CGuurJhW793r9PUeqqfCW1QpRQtZGSKCjKIyfIxbx6zmErybDhUL/ym93kOnybiuXVkyccAXG9Jax79L9IwP8+jqVhcfLdonrm8/qRduObEnrjimi/h7z34pSvUtkFig7B8junouiyitwttWzSeck9Y4paHjCt7S0lLRGe3EE09EREQEunXrhv79+yM+Pl40frjxxhuxevXqtv6YDMMwzBHO1sOyKtorPgxdY0M8MmNVhbdTUADyPv7E+X+q0w8h1atqWVxLXquyM1D0l04ZeN1Q/uAZmzKaNHFNJS6M6BLlbBNMYp4+l8/npxe2muDtlxzubNtLlejaIC+z6nR27nDp0711Qi9xskAd1QhduKsC2xzQeyrxP6KLZzczVeEtamMPL09a66CC93//+58QuJ9//jkmTZqE3377DRs2bMCuXbuwfPlyPPnkk7BarTjllFNw6qmnYvfu3W35cRmGYZgjBF+CVPl3B6ZEICkySEwiIztAZkkVsrW0g6h//oQtT06YIizp6a5h+sIKzNqSiaHPzMFLs3bUeH01HK7EkzdXH9sNJoMO83fm4r0Fe5pepewSLYbllcfYPV/YfTlsVAkNXiKvJYgPCxQ+VNLzqpWxLygVg3KBaXmoCjp9j5P7JyKGYhiowqulMzRnFnF5tU1kJKsThbaq8C7bk4drP1+FL5cdECcG9LkI9vB2UMFLldtFixZh1apVePzxxzFlyhQMHjwYvXr1wpgxY3DdddcJMZyZmYlzzjkHixcvbsuPyzAMwxwBvD53F0Y//y/+3Z7tcf+2TOnfpclkNImMxBnx2/rDIH083JqPqs8+FveFT5kirqvT052CjCq87y/Y6xyO905HUGJpyp4lyHnjDTjsrrxf9b7PnT1I3H5t7i4s35vv93d6459dGP/yfCFq16kqZVcpYPslSfG204eNgGwY9LnIJ9tfq762JJR4oD7Pdh8CXLEnV4rhHnGhwmKiuPKYrk7BWx3UvBJF/V5U6XZ/T6K1YslI3F73xWpc9slKceLz1r+7nXYGoz4AEUGuDGimAwne77//HgMHDhS3jz32WJSU+N44goKCcMsttwgBzDAMwzB18duGw8grM+PGr9bgu5VpNSq8Kj1BZcbSc+Iqi/Do4o9gLy1F8MiRiLv9NmeFNylCCmNqWLHxkBTNJJAf/nWzaNmroOFwg92KqQu/R/4HH6Lkr5ken8tWUoJTC7fjoqFJ4v9/ukR6WP3h5zWHkFZQgRu+XCM8wJQNPLhTpHisjyYwd/jw8ZLfV1kNAg2Nb9TQEPolyeW7I7O03ra+yvOrOK57DKI1afLn7tqTJ5pWGa9p7YgONXrYUloKNVGPxK2arKb8zjK6rmWagjDtwMOrWLFiBaqqaub2kQh+6KGH2uQzMQzDMEcWldU2IQwJGlZ/ZPpm0diA/K1q0tnAZCkUkzVPbWZhOZ5a8RlCi/Nh6tEDnd99B6auXeVrlJfDWF7qnHBGULMCEidUUf1ksSsdgSqpCRWF0DmkCM596y04qmX1zpKdjQOXXIrD/7kL1+bKeSmLd+ehorr+VrblZqvTP+z8DikRCDLqPSu8PgWvrAYrcdwaKB/vzuzaK7x7tQpvz3ivNscVcnlY4cDT/+wSv11zJzQM1yrj7rRWDq+aXHjFMV2dPvLl+2Sln/27HVzwXnDBBXjppZfEWU1OTk6Nx8vLy/Hqq6+2yWdjGIZhjixISFH1lGLBLhqVKu77fWMGtmWWOGPHIjW/pmooMSx3N3oWZ0AXHo7OH30EfVQUdIGBMCQmOqu8yidL3DahJx7WYrS+Xn7A6RcmsZRU7koYov9X+NPPqNyyFQevvArV+2RFN3j5InSOCRYe1kW78vz6TgTZEhTD3fy4fTXBS2LK27usKrxDUltR8CpLQ2bNz6PYmyNzgXsmeFZ4bdqEtUqDDtV2B277dh1enLkdP61J9yvqrK5JYQe0Tm4jOtcUvK5Jay1b4VW/Za+EMKePeIVmbYnjhIaOLXi7dOmCGTNmiI1i6NChSEhIwOTJk3H//ffjm2++wXvvvYfk5Ma3EGQYhmGOHnbnyApa78RwXDiqs7i9eHcuNh+Wlc4ByXK43d3ScHLaWnEdeeZUmFJdnb1MnTvX8PFSRXJs9xicOTQFISa9yPFVNgeatJZUIcVLQKCsCGc/9xwOXHABLGlpMGjHssoNG3BGF1ndm+tWwTRbbbjko+X476+bPL6TSjOgLmk3je8h/KdnDHEdF3vEhQmLQ6nZ6tHhjJIgqI0uMaSFG0640zshXKQtkDc1V0sfqL3C6yV4S7WJf/EhOH1wkphU+OGifXjwl0046dUFeG3OTr+q4t4o4U+/nzrhcUc1nqAcZcpTbin2uH3vvprgpYYbBE9Y6+CCl5IalixZAoPBIGwNH3/8MY477jjs2bNHpDSQ6H355Zfb+mMyDMMwRwC7tGSAPolhGN45SkwCoqrdD6vTxf0DU2Sls2LdOnQKqEaIpQrHZm4W90WefbbHaxk1wUuV2hN6ye5ed0zsJUYkyU5wUj+Z5TtrS5bT0qAqvJHnnQtT9+7idkBwMMInT0K3779DYL9+wgA8qVROfpu3IxtWzQdM4nTFvgLxWcmD7C14qSr4yOn9se2ZKRjdLcb5OCUdKOG4022i2P78ciGCAw069PaqpLYkwSY9ummd7Hz5eOnEQDVaUB3vFHZN8BoiTHjzkuF46bzBIp93aOcoIUTfnrcHF7y/XESMNQQ1gW6A9vt7Q7nJah6bylNuiQlrypJCvyV14CPUV2HB27K0m+mAZF0wGuUZ1tleOx2GYRiG8QcVhUVVRoNehxN6x+OvzZnO1rrkfS1fsRJp11yDbnEJuCBmMIJsFui6dkPQkCEer2XsnOqs8F58c2dRVXXvznXaoCT8tSlTRJU9dGpfMWltTIUUvIHduyP+jjtQfTANQYMGQmeSQ+ZhE06EeccOJG5ZjajY04VIXnuwEGN7xDo/I7FiXz6mDkmR30kTvEq0+pp8RrYG8hTTxLWJ/aQVY7NW1aTvTMuiNemfFCG+D6VKkOfZnX15Zc42xKq1r8JWpjXvCDOJJI1LxshmFDQKPHtrNh78ZaOwp/yzPRtTBib5/XmUv1nZLbyh3GTKT6bfg06QEsJl9b85oeVBDg+KQKOOasqKouAuax28wqtQYpdhGKZDUFkEWBrvOWSaammQ4vDEvp5iixIain//XdzW5eXg0l3/itux555TY4a8sjRY0g+Jx9zFLnFS3wRRXSVvKAlN8vAmaoLXmJoKQ2wsQkYMd4pdIvykk8R1xdKlmNRTVmnnaLaGfXkuwbt33lLR1ljcVoLXKzvWHSWeNqVLkevp3209O4NCCUtfFd7a/LuEvdTiM4OXlv+pg5LEZC/ii6UHGvR51OeoK5qtpdsLu9sZ6PsoK4oiVovJYzqg4E1Lc8XF+MPhw4db7LMwDMM0G1UlwJtDgU8m80JtIhvSi3Dyaws8vK61LnaLK6GBKrzEBLfqIvk0E4N1KJ07V/ytj5M2BepAEXnWmTVej0QrUX1I2iG8oerk+N7xTlsDVQaTy/M9/q83QYMHQx8bC3tZGaZAfqc1B6RI3q9VeMlmMeHjZ5F23fWoyM3Dgfxy5zB4bajOYbO2ZuHhaZvEsmiLhAZFP80rrSYL+uPfdffw1tZljQQveZgp2WC7j9f2BVkh1Hv21SLTfNHSzSfUiQt1+iPoZMnd0sGWhg4seEePHo2bb765ztbBxcXFwtc7aNAg/Prrr636+RiGYRpF9lagqgjI3gyYa88iZernjw0Z2JtbjmnrDtX7XPK6qoQGNeM9ISJIDOkr/27FkiVCbFICQ/dff0Xo8ccj9sYbYUyR9gFfFV5rZpYzXswbsjUQny7ZD3NRMcK1qr6pk2vymzsBOh3CTjxR3O62e4O43p5VKvJ81VB//4IDMNkscFgsSFu4Qng8w4MMSHCLRvPmmB4xeGBKX9E97vtV6ej3+Cys0WK4hnZufcGrRDZlzHpPMqs1ksxN8NbWZY263p2qWRmoS5k/0PtZ7Q6xDMlGURtKcLZUNJmq8LqfuKgMZYItDR1Y8G7btg2hoaEilSEpKQlnnHEGbrzxRtx555244oorMGLECJHa8Nlnn4mJa//5z3/a8uMyDMP4R75b29iiho1kMb4tCu7+Vn8SGtztCacPTnaKwpKZf4vbEaedBmNiArp88jES7r3H5+tRJTYgJERMMrNkZPh8Dr02NTKg2f2J2oQ1XUwMdKE1xZwiZNQocW3cu1O0uaUKJAlDFZs1qsS1zhSuXO0USXU1JaDHbj+pF764dgzi3IbGu8WGoHtc601YU1DrZhLoJNZVww/vSXi+Krx2LZZMH1a7zfGa47qJ6+nrD4vlXh+q5TLZLOpahsrSoDqfNTfOZhsJrnWjjzYSQbCloQML3tjYWJHSQK2D33nnHfTu3Rt5eXnYvXu3ePzyyy/H2rVrsXz5cpx++ult+VEZhmH8J1/uwwQseJuEEkeUOEAxW/5NWPMUUrec2BPf3jAWN4xKRum8eeK+iDPqP6aQODJp1oS0m2/GnilTUL5sWY1Egp9vORYvnjcYve1SWJm0yW61ETRwgLg2b9+Ogcnys5Jlg4QvDXMfW+lWzd680ed3qo0T+8RjxcMTseaxSZh//wTMunt8jTa6rYXyDm9Ml9YK4kBeuRD29Jn6u0XE1bQ0+K7wEqO6RotIOcox3uYlpn2hOtCpDnC1ERPWch5eSpVQHu1e8S6R2zfJ9buypaGDpzRs3boVgYGBogEFXRiGYY548mXklKDwYFt+kiOa0ioLMrVcWRKDGcWVSI2W+bV1R5J5TkwicXVcrziUzJoFR2WliBsLGjTIr88Q2LcvzLt2wXJQVl0P3/8Aevz+Gwzx8R6vf+mYLpi8KRq5i8jOULfgDezRAwEmk7BWjAmsxEpqo7tRVpB7RhkRn+46YQpP24PAQdV1+ne9oUQGqvK6V3rbgmGdI0WagsopJigxgzi2ZyyiNQuBwl5tg8Nsq9PSoE5EyKZC68a2jGKM6e6KaKtrwprqAFcbMarC2wKWhkOFFWIdpog4lensLsKDjDoRocd04JSGe++9VzSXcOevv/4S1d177rkHBw40bCYmwzBMm8OWhmaBvLvu7HdLMfAF2QLqqoaW/iuru+GnTK5zaNudxP8+hOQXXkDqe+8K8WsrKEDGI4/CYa/ZnMCacdgjv7c2AoxG8VrEkIpsj+861pKDAIsFRYFhyAuKhN5uQ5+idOckvCMJVeFVk+fgJuynujXO8LYzwKBDQGDN6DV3VHWYurk1NZJMoQR4S1ga1EgFTVJzr7hTXvFjZ/TH/50/xO91kjlCBe/GjRtx/vnnO//evn07zj33XCxcuFA0nRgzZgwyavFOMQzDNJmqYuC7S4CNPzbPwrTbgALZQlZQ1L4rvKXz5uPwfffDVuQSJe2F3ZqA9Ufw5paaRUIDaYaBPlIJaAJY2cKF4nb4ySf7/RkoWizqvHMRPnEiOr36iuigVr54MYp++rnGc6sPSSuC0a1bW20EDZC2htQ8T4/34HxZ5AkaPhx53WX74lElBzGsc+tHizUV1c74YH6FyCjekyNzgo36AJ8Zuq4Ja8Z6xZ9T8Lo12vAF2ROySqp8Vv5rq/C2hKVhudY+2Fel/oYTeuDsYfWvM8wRLngphaGz29nwV199hR49euDgwYM4dOiQaDf80ksvtelnZBimA7P9T2DX38CMe4DyvKa/XnE6YKs+IgQvVSmznn0WJX/9hfwvv0R7Q1XFFHVNXFt7UE4Yo3at1EDAm4q162AvKYE+OhrBQ4c26vME9u6NeG3ydNEvv9R4nPJ63dMd/BG8wQd2I0gPnHJgJcZkbUPn9J3i/i4TjsWJ58tYu6vDi2sM/zcEa26uU4y3JlEhJjFpTmUC/7lR2hmoGQg95o3qslaXncFb8FL1VnWqq8u/mxodXCNHudYKbzNbGkjof7lcnsiwsD2KBW9qaqqYtKb4999/ceGFF0Kv1wtv78MPP4w5c+a06WdkGKYDkysFBizlwNI3m/56eVpCg0Hz6RW2fUoDRWqlXXedqOS6U7lhA6za/rd42nQ4rPXPeG9NVIcxFXHl3pjBm9UHZATXqG4yj9absvnSzhA2YQIC9HUPl9dF5Nlnidzeqi1bYMnO9jh5sGhZ8bVl8PoSvNXbtuGKgo24Z8PPeHrFZwjfuErcHzJyFEJGjhC3zRs2wGGT3taGQv/vwGWXY/9ZZ8OSnYO2sjUs3JWL3zfI5XPm0Jp2Bu8ua/XRNSYEISa9mLimcop98cfGw35nETtjycqbL4eXOsQ9/ttWWGwOnNwvAZP6y3bUzFEoeCdNmiSSGgiq6q5btw6nnHKK8/GePXsiPd136DfDMEyTydvlur3qY6Asp3n8u12PldfmYtl1rQ2pWLcO5cuWi0outclVlPw103nbmp2NssWL2+gTAiVz5iDrhRc8RLeKGZsyULbK3a/l1PpCNW8Y3S3Gp+hQ/t2wibLTWWMxxMUhWGtBXDZ/gfN+S3q6zOo1GGBMqr/lbWCf3uK5tuJiTF0xTdxnDZCHZF1EBIL690Ngnz7QhYXBXl6OsvnzG/V5qzZvFp/NXlGB0n9kw422sDVQTjGlM1AW7qT+8vf0xubsslZ/51VqBay6y22rxcdLiRA/rZGV7euP7+634KWoM7O1cScY3szYlCmaZNBktafOGsg+3aNZ8D722GOYP3++sDGMGzdO2BuOP/545+PZ2dkIC2v9DEGGYY6yCm9QJGCtBOY+CVjNTRe8yUOAkLh2YWsoX+qK0ipfvlxck7Ck1AIisH9/cV30c81h+lazVjz5FAq/+topuqlZwaFC2cThFM3vSX/7EiL03C1aPNUoH4K3es8eWA4dEskIYcdqJyJNIExrD+wuQsuWLBHXIcOHI8BQ/2x7XWAgAnv1ErcDK8uRGxyJ2899BknPPI3OH7wvXoMq0dGXXSaek/1/L8Nubvh6WbZokev2v7KNcmvi7j0m/+o314+t1VpgKzL7bWnwnLjm28f71r+7RRzYhL7xPtcLbyglQU0oa64qr5qkd+MJPdA5pvaEEeYoELydOnUSndZootppp52GadOmeZwBzZs3D3369GnTz8gwRxKikjNvXqOHQI8qLFUuMXray/J643fAO6OA3XObJnhjewHRXdtFNFn5UinGiIoVK+T16tWw5edDHxmJlJdeFPfRpK7yFStgK6u9ktoSmHfvga1QWhLMO3Y4/brUNY2qbpS6EB5oEH/TBChvNqQVCWFDXbQ6RbkinxQlWivhkHHH1NkQwl9UlZhOHmh7cxeWoeNP8Pt1lK2B+HXAKRg9rBeiL7oIISOklYGIu/km0RWOqrQFn33W4M9attAleMtXrRYV5daEWh5fc2w33DOpD2bceTyG1jH5zpIjl6UhMaTJgnfL4WJM1ywU9072T0OQ9mjO5hM0skCtsYkT+7pi7JijVPASXbt2xWuvvYZPP/0Uw4cPr9GNjfN5GcZ/qBJ06Lbbkf/RR7zY/BGnDrus7g65GDj3QyA8WTaL+OkqoLq88Rm8JHijurR58wlrQQGqtm13/l2+fIWoqBb/9Zf4O3zKFAT17YtgElk2G9KuuRa7xh6D4t9/b7XPWLGSkmglVTt2etgZVIexHlobWjVxraTKgllbMrEurdDNv+vDzkARX1qiQmQzNTCiyWvk0yULAzWioMprxUrpvQ0bL9sG+0PwYJkFbOzSBS99/AhevkBaJdwhgZ7wwAPidt6HH8HiNufFn8lqVVu3ituGlGTAanUmVbQWZD2gofy7JvVGkFFfpzi0ZkvBa0zwT/AO0HJ13QUvvc7Pa9Jx0YfLxQnSKQMSnT5if4gJNTZbe2HKCc4pNYuq8aCU1m/vzLRDwVsXlNpw1113Nej/LFq0CGeeeSZSUlLEjvK3337zePyaa64R97tfTj31VI/nFBQUiCzgiIgIREVF4frrr0dZK1c9GKah2KurUTJT+jILf/yp3U1CanfkaXaGuL5iIhKGXgLcuQ4ITwEsFcDhtfW/RoX0jgoslTKlwSl4u7a5pUFZGEwRFgTo7aKSWr5kCUpmSMEbccYZ4jrxkUdEdVIfFyeEb6GP2K2WomK1FIvuFV7VREJl6lJ+KTFzcyau/2I1Rj47F7d8sw7nvbcMHy7aW+uEtdJ//4U1K0u0CQ4/7bRm+bx0zFC2hpK/Z6Fi1Wo4qqpEJVZ4c/0k8txzEXvLzUh9+y0EhwTV2hGNusIFjxwp3iP37Xf8fv2yRdIeQk02Is8+W9wunfsP2iO2YjMc1TZAFwBDXM0qvS/6JkWIzTa7xIz8MmmH+HrFQTzwyyZUVNtEK+kXzhvcoM/RnBVeVd2l5BDqyMe0Le1e8DaG8vJyEWf27rvv1vocEriUDqEu33//vcfjJHapC9zcuXMxY8YMIaJvuummVvj0DNNwqIpFlC9ZCnuprIzRQV4d8JoDX0H7Rzy52oS1eLchT1OIa8LZQSkWa2XzL8DL3YHZj8q/szbTkpIV45DYdlHhVf7dsBQzQuLlQfzwAw8K8UQiKmTMaHFf8KCB6PLRR+j2ww/OBAdbSf1tW5tjvSLBqKhOSxOTtBbtyvWY9NQ9TgrfPzZm4N8dOWLWO0VekUgkcUOM6lqzwlvwzTfiOvrii6AzNT7ay5uI06V4pomAOa/Liddh409o0KQkXVAQEu6+W1TY64JeM/FBWeUt/u03VO1ym2jpRuXmzR55yspmETZ+PMInTZL3LVkCe5XMpW1PWLTqLondAL1/0iQs0IDusfJEaH2a/N4/u01S+/aGYxrcbc6Z1FDRfIJ3WJcjL0O5I9IhBS95gZ977jnhC64NijxLSkpyXqKjoz2aX8yaNQuffPIJxo4dKybRvf322/jhhx+4CQbT7jj84IPYffwJqNq+3VndDQiRQ4JFP/3ULO9B4mfH0GHI++BDdNgKrztdjpHXafUI3jWfy+vl78jbv90q/+52gqwYt7GHl4Z3acidCE0yiwth13yc1EXMW6CZUjvB1LOnqPKq/9uSmHfuFL5SXUiIqMLSOPT+1ZuwNaNEiNnJA+SEtdFa9ZZmu195TFfMvWc8FjxwEmbfPR5nDU3B5WO71OikVbVtGyrXrBVpCFEXX9Ksn5smp8Vce638DpplJPQE//27DYWyg8MpwchuR+7/Xq/xeMms2Thw4UU4dNfdztGe8qVL5ecbOwgZnYJgTEkRrZULvvwK7Q2nncFP/66CWkYTC3bliCrvlgy5bt88vketFXN/BG++FpHWLIL3CGwa0hHpkILXHxYsWICEhAT07dsXt956K/LzZRcUYvny5cLGMGrUKI/4NJ1Oh5VuXjOGaWvIQ1g6a7YQDIfvvQ9l82T0UtLjjzsrPA3x/NVGMQ1/WyzI++ADWLXJRR2rwusteMfJ60OrAZtViDBxcac0GzgoBYVgxt3SExyRCkx9Q97ntDSk1fz/rQClE1ClP0BPgRFmhCaaPfJkgwf7Hu4N04QbTXiiamvW8y8Ia0BLUK7tU4NHjUSQlhaxaeEacX1sz1inADm2V5yY9LT0vxPx7DmD0FvrmkUe37cuHY7nzx0s/KLuFP3yq7iOOOUUGBObP/804d57XE0sDAaENkMCRF3E3303oNejbMECFP78s8cIT44W70l+aPOePSidPQf2sjLoExJw7YHncOlflyL41uvEc/LeeUdUiemESE26azcVXj/9uwpKYCAW7MzFkj15YjOjE5+EiKBGfY7mqvBSM4zNh6T4Hs6Ct11wVApesjOQN5iaXPzf//2faGNMVWGbNqs9KytLiGF3DAYDYmJixGO1YTabUVJS4nFhmJakaudOmf1J4mb/fnHwoipO5DlnI2TMGFENKvyh4S1zKzdtQtazzznFbcU66WWlYfDCr79Gh4BaAKtEhTivWdwJ/YHASKC6DMjeDEy/GfjfAKBMDrMLtv8h7QvJw4Cux7uaTVzyLRCmzciO7AzoDLKpxT5XZmtrQVU/goQufYzAKCtMsUboo6IQf889tf6/sBPHi+uyJYuR9eKL4jfPfPQxp3WmOVF2htCxYxHUT554FGyUE63OGOzZoGBQp8gGDVHT9kGETZyIliDAaESn/72GwH79EHP5ZdC3cIRmYI/uiL5cxpRlPf4EMh56SJzsUtc3S1qah9Av/O47cbvktLHIqspBpbUSh47rKbzH9DseuuNO7J00GTtHjBTtpdsaa07jKrzjesbCZNCJyLovl8luZif01uIAG0FzeXjJg15psQnbRY94jlZtDxyVgveSSy7BWWedhcGDB+Occ84RHl2KRqOqb1N48cUXERkZ6by4t0xmmJagcsNGcW2kdU0bmg4/7VQZr3PF5eLvgq+/hjUvr0Fil2bqF377LQo+/0JEVJm1mfPi9b75FrayRqQXtDcKDwA2M2AIcnltFTo90HmMvP3PU8CmH4HSDGC/2wz3bVqKwaDzgQs/B8bcBFz2I5AyzPUcYxAwSlbV8OddjUt9aCRUvSN/KRHRRYoJWkW6n21Dz1l/19kcgby9ZIux5eahWKuSkje0bPGS5v2MNpuIRyN0w0eiOKWbuB2VdUAMR6v83cZSfUAKIFN3+botgbFTJ/T4bToSH34YrUHiQw8h/u67KP4Axb//gT0nTUTO6284u8gRhT/+iMr160XV+a9BLuF2sDQNSU8/BV1kpBDIqjMcVYzbElpXLY0UvCEmA47pEStur9N8vNS6uLE0V4VX2RnIg94YawXT/ByVgtcbanoRFxeHPXtktYc8vTk5nt2WrFarSG6gx2qD2iAXFxc7L9whjmlpKjdKwUsVXZplT7meMVpQffjkyQgaMgSOigrkvfe+X69n3r0b6Tfe5BzmLP3nHymq7XZROTZ17w57SQmKfmx41bjddliL7S0FrjfKx+temc2WlUfRjU3ZGQacDYQlAKe/AvTwEUl18hOy0ktJDfOeQ2tB/lUSfAEmA8I6VTntFbqKw9CH1T0LniZ3hY7TbB3UCCBGTgYr/vOP5v2M23eISZbUTeyGZSW4fokcAu5enIlje0Q7xUdjsJWWipxhwtS15QRva0PNKOJuuQVdv/oSgX37im2Vtkk66e30xusiKYJ8ukTIpIn4q8Tlwz5YchDGhASkvvUWIs8/D1EXXSTuN+/TovTaCFtxNRxmLaEh1r+EBncm9HEJXKr2julef5OJ2ojW1rmCJjSeIDvDnG1yNJj9u+0HFrxk0zt0SHh4k5Pl8Bl1fCsqKsLatWs9GmDY7XYxia2uiXAUY+Z+YZiWhKqxRPDQYYi58gp0n/arqDgRVOVNuO8+cbvwp59QuXVrvUPSGY8+JoZIg8jbaTSiet8+FGlewZDRoxB7ww3y9X78UVRljmiyt/j273r7eN3J2eayM1B+b8oI18S02ggMB87UPL0r3geytddoYdQExrBBqdAbHUC34wETDa06/EqNCD/5ZGfmbOo7MgqrbN58ISSbQsWaNSKJgbqjlWpNMEr6DMLaQ6U4FBaPap0BwbZqXJDUtKpY9QE5UVAfHwd9WNObTbQ3QkaNQvffpiP1g/dF5FinV18RqQ+R57kma++b1EdYGRRpJfJ3Dx07BinPP4+oi6Xgrd67D+3BzmCIC0KAoeGy5KR+LgvimG4xdeb91keM09JQs6tdUUU1rvpsFU5+bQGOe2keXpktI/TcoXzoa79YLTzFNKJyci1tlJnWp0MKXsrL3bBhg7gQ+/fvF7fT0tLEYw888ABWrFiBAwcOCB/v2WefjV69emHKlCni+f379xc+3xtvvBGrVq3C0qVLcccddwgrBGX7Mkx7gBoKKN9e8BDfk4/owCY6P1mtOHD+BdgxeAiyX5Rdtbwx792LKhLQBgM6v/cuQo+RFc7S2dIHGjxiJCJOnYKAoCDxviov9YglTZuAmipjuWrQaYS0OxBkVyCUWN2jTeAacJZ/79VrEtCfnusAlr6J1oj6Kpn5t7gd0cfkEvbR3eXtgv31vgaNGqS89iq6fPE5gocPE8kNDrMZpXPq70BXsW499l98McpXufJ1icrNW3Dwyquw/6qrMfmVefj3e/kZ/zbIk7Q7JveDrkdPcfvEALd840ZQfVAKXlPXek5IjmDopDZ8wgSk/N9Lzslz0RdeCF1EhBDEvwVLK9KgWNng4kCJtHgoArvL9YGymeubjGort8BW0vTkAl9YsqXVx5jYuBMTymjuGhvSZP8uEROmWRrKLTVO6n9cnS7i8vbmluNwUSU+WrQPVRbPjpb3/rgBi3fnIdiox/uXj8TIrjWzoZm2oUMK3jVr1oiObapr27333ituP/HEE9Dr9di0aZPw8FLLYmooMXLkSCxevFhUaBXffvst+vXrh5NPPhmnn366iCb7iDtXMe3QzmDq0QP6OkYTyPNn7NpFzO4maBKbrxxO8gMSYccfD0N8PMIny9xORciI4aLrk5rBXzJnju83XPQK8Mlkz4YM7XHCWvpKT+uCN8Zg4MIvZOLCBM2fWZwGVBYBB7Vh4m5ycpdfHK9NEtvyC1CkNadoIShGzpqZKX+v2FxX9FqMNrRfWL/gDdDpEHnGGTDExgphFXnmmeL+4j/qtzVQHF7Vxk3IeOBBjzbFxdOnibQKe1YWuu5chz7Z0ka2MKSzmIx2y4k9ED9Oeqcrtepvk/273TqOnUFRbatdeJL1qNe8eYj+4A0szpCe61uG3iKuD5UdgtXuakZDUXD0fPGae2u3NTjsDuS8uwHZb6yFvaLpExfp9Sy5Fajcmo/i2QdQtiyjUQkN7jxyen+cOjAJF41q2twZVeGtttlRruU7K2Zskok3t5/UU6yvlAW9+bCrVTOJ34VafvRX14/BqYOa5kFnmpcOKXgnTJggzsy8L1988QWCg4Mxe/Zs4dGtrq4WVV4SsomJnsMOlMjw3XffobS0VPhxP/vsM4S18AxchmmcnUGLRaqFwJ490Wv2bPTbvEm0F6UqXYVX5U20mp3xpzOuyjmkrU2Eo0kuIpuV7qcsUKr8zppd09ZAUV0L/g84tArYISdMtUvImmAukUP8ibL65ZO+pwGjrgVCYmTLYWLbb0BVEWAMBZJrtoKtFaoYdx8PkOBY8V69T7fk5ODAZZcj67nn0VAoTowIm3AidEV7fFR4Gz6EHXnmVLE+iNirvXvFb3/4/gew77zzakRbmffJ17dmZyNXi8sSXQD/kjYL4oatMxBiNaPUGIz9kSm46+ReYgISNW8Q32HxYr9tM5RUotJKOkqFt7S6FMVml5giaHk8vfxpjPl2DFZnuZp1eEMWjnlZi2GxW9AzsidOSD0BJp1JiN3Mcs+YQrVdm+uwNdiKzLAVVMFeYUXltoImi938r7Yh+7W1yP96G0rnp8NWaBb+3aDejc+rnTIwCR9cOdLpwW0s1BEtyCilUaFbUsOBvHIhbmkC2nXHdccorXK7RmtrrSaqkQhOCA90Ps60Hzqk4GWYo4EqrcIbPNQ/0UUVu7DjNTGhdWCjiU2U1UvtZ60ZmdCFhztbplJlL2TkSGfIPv1/IuykCSKOiWLQKOfVg/VfAXatAqSqoDR8PuthoLT2SL9WJ02rHlISg97g3/9JGCCvV32i/d/RgN7YsPc9TjYFwNov66yAU/btoVtuReW6dSj85hvheW0IzmYTw3p7JlHE1GFpKMmQHuNaPhd5w8NOnuhM/ihftAglM2aIpgtUUXYXZe7VwsLvvhfWhrKFC4U/vMIkJyUll8sJZWV9B+Pisd1w8WiZlBEyejQCAgNFfnCN9auWpIf9F16EvWdM9Ri5OJIrvCRMz/vjPJz929ke1dy317+NX3b9ApvDhh931j1x9O/90i5yavdToQvQoUtEF+fENXcCe/QQ19V1TFxTCQpE5Rb/E198Qf+/akeBELjG5FCEDE9A9IV9kPzf0QjsJrvqtTUuH69r2c/YlOHMho4NC3S2sV570LW9rDkgb4/uHtOgjntM68CCl2GOMEhQFP7wA8q1/NL6KrzuqOpZ+eLFIpLowKWXIf2mm0UyA0EeXZr4ooi55mohPtwnwlDWaOjxMne2ZPYcT5vAmi9cf6sUg7lPyIqmar/bHlAd1HxNTKsNyuYlKJeX6Hpcw9+350QgaYjM5Z3zWK0C7vB994uTEUXR9Ol+vwXFh1VtkRPyQgM2uHzKlEShKry+LA3zngdm/Rf48EQgU55MeRNz1VXiuvi335H9yise6R4KquqSYCcLjRotOHTb7Tj0ppz49leXsdiVIKuKxLAzJ+LF8waL2fUErX8hY6WtwZ/W2DTSQd3aLOnp4gTBKbqV4D0CK7yHyw4jqzwL+VX52F8sf6vpu6fj480fO5+z6NAijwlp7uRX5mNlprTsnN79dHHdNaKrT8Fr6tmj3gqvNdcleKt2F8JeZa39uXmVyHp9LcrXZdd4zGFzoGSufP+IiZ2ReNcIxFzcF6EjE6GPaFgL4JbEldTgLnhlZfzMIdICory5aw8WOkciVmnV3tFc3W2XsOBlmCOMrKefRtZTT4uJaBFnnCFC7/0lhCaiGQxiuDfjof8Ke4OwLdjt4vHIc87xeH74pEnot3GD6FTlcf8U+XfJ33+7hp13zQZKDgHB0VROljFceXuA3XNdVoBi2ee+TaHPe3B53f5dXyQO9Py7IWJZQcv69FfpBrDhW7nM6PLHf5zJCWRHoFxUOtGIueYacV/x9N+EEPaHcvK+OhwwdesM416ttfRJ2smGqvBSq2PtN3eSsd7lU/70FFcV3A2qvgb27y8akFTvcVUEq9wEr1m7n4Rm4uNPiMlT1PErYI+Mgds59Hj0v/5y12v6SL4JO0FrfLHYt+AlSwUJe/GcRYtc333lKuckLIo7o+Vt6uKVsXwEoEQusUezpHyxVZ5M3jTkJnQK6yTE7uJDiz1E7n0L7sOXW7/E7AOzRRV4YOxAZ2VXXaukBnfLU33RZNYcN2Ftc8gKbS1UbMgRbYJL/02rYUmpWJ8Da24ldCEGhB0vJyq2R1Qc3tI9eTBbbZi3Ixs7skph1AcI6wQxMCVStLkurLCISWw2uwPrDmqCtwmxaEzLwYKXYRrK4teA7y8DzE2LZ2oMJFSLqHOaToeEBx5AyquvNGjojKqzISNGOOOhiG7ff4fU995F6jtvOy0M9UH+3oDgYDF0XUEig4bBl0ivJkZcJauYxLxnAFWFIu/qqo/Q5hSnyyYS1Hqsk3/f18PSQOiMQKqr9XiD6DIWGHe7vP3D5cB3FwHrvgQWvCTuInsJEXnuOYi/527hn6bh/fJlmkivh/Kl0s4QlmSmkhrQ93SgqybOqe0xeY/J5kAVZiVIrGYgT2suQlFr1ipgrVu1XoPWNVXlJSj32bvCq4bGF1vCMD+tDJ0/+RgFw+SJRXp8V7z/+EXodeHZwmpA/z+wT59aRyIq1q6t0eSkfMVK7DvzLBy89jrhPS/X/Mri+dpEN1XdNSYne4xYHKmCt8JS4bzv0n6X4pRu8oSThK3if2v/hzkH5+DVNa+KC3Fa99Ocj3cNr6XCq1kayNIkKvM+oAlmhCE2qF5bgyVLvoY1v8oZN6a8uyXzpNgOP7EzdEF+WonaAGpXTXyyZD+GPDUH130h95UT+iYgMkTamGhEYmhqlNPWsD2zBGVmK8IDDeiXxJGk7REWvAzTEKgKR80Ddv4FrGv9FrsU60QEDR6E2Ouva5RPTIkJIuL00xE8bBjCJ04U1Vx/0YeHi9gqouC9l4F3RgGHVkuvKHUWU8P9qhtZohabRiLK7Jq13yaoymXyUMDUgBgkmvRFlWsiaTCw6afGf5eJjwGxvVx+ZzcLiJpQSK12dWQnmTpV/F00TXY8qwuqqJUvla8TatouP+/JT7qeQH7lU1+Qt1e8Ky0MJHqpCQedkARFAsf9Rz6e77viF3HG6TD16ikquElPydeu3r3HWc1TFd59wfH4Y2OGEJy/n3MnXhp1Ofbe9ggigowiHaDHjD/R7ddfnN5wd+i1RbKIxYKKla5KM1W5Raye3Q7z9u0yDcLN+lG5ZYsQyCqD19TtyLMz+BK8u4t2wwEH4oLjxGVKtylOWwOJ4U25m/DHXpmeYdQZxWS1AATg1G6nOl+nNkuDITra2VjEvN8ztkyhhGv4BJmAULWzEHavBAOFJcvN7+s2wc1aUCUmvsGgQ+g4z5bR7Y3/ntYPj08dgPjwQJitdoSa9LhoVCpeOs8z/nFkN9fEtdWaf3dE12jurNZOYcHLMA1h1cey4YC4/VHNYeEWpmqz9I8GD/Kdu+sPoeO1KC2jUVQQ6yRzE/DlWcAhWeFwJ+aKK8R12aqtqM4pkhXQq2cA0d1cFUXFGa8BMT2AqmJgfeufKHiw8fvGWRIopiymp8uv/Od/fFZB/X6ty38BTnoMuGWJFKaFB2BN2yb8qETIGOljjTr/PHFd9s+/sJWU1PmyloMHYcnIAPQ6hCRUA71PARK8LC8jrwHO1LKAV34ApK8Csra4TkzUd8zfU2sXth6//44ef81AUP/+Yj2ilAYrva/b0HhaeCI2HZK2g2255ViYOhzdB/d2vk6AwVDnCVvYcdIn7p4oUjRtmnP5ENnPS/FOjVKMqamAzYbKdWuP6Alr3oJ3b9Fe7MiXmdf9YuRvOSBmAFLDUlFlq8JLq17CcytkB79zep2Dr077Cr2je+OivhchMTSxhuDNKM+AxWbxe+KaraxapDOQCyd4aDz0UYFwWOww75W/rTskgq35LvtD1TY5MZGwapVfah2sMzW+MURrEGjQ4/rju2Pxgydh+m3HYtWjk/DyBUPFZDV3VBLDot25+G2DXP+b0uWNaVlY8DKMv1SXy6FnQgiU/cCe+kP4mxOqYBFBg+qI0qqHoD59kPLqq+j8wfswda4ns3LNp8D+hcDvt0uR5+X9Cx1CB8oA5OxIRZ7uahSvz6wpJinOiyZNjbvDNTmq0HclqcXZ/Q+wd560JIy+vuH/n9oI6wMBJRhUe+JG4IjuBsfx98pqsWYBqV78g7gO7N1LpGQQNOxPFVXqklf677z6/bsklrtFQWdwuCbaeUOid9D58vbu2a6uc0mD5IkJUVkAVBbW2t5WCFaj0dm8gHy8YrLYbimU08MTcSC/AvllZuzKlpXw/sn+D/UGD5OTMSs3yZM8qtzmvvmWuB17443C46w6B4aNH4+QY8Y6LQ9VO3ccsRPWaBnuK3ZNIDtUeggbcjd4CF46UZjaU1b+p++Zju0F2xFqDMVdI+7CoLhBmHbWNDx2jOekSKoMhxhCYHfYkV6W7nc0GXluCRK6JFSD+kqRV7Wr5rpB3l3qrRIQKAVtdXqps1mFxU3wHilQx7bhXaIRGujbfkET10x6HbJLzNiYLk8ARndjwdteYcHLMLVhqfQUeRt/kBVKmuk+9hZXhayVoOFcNXwbPLjxgpeInHoGwo7zI2UgVxN0uTuATTVjkGKGSj9b6R4Lct94ExkPPiRtF6FxstEB0f9M4TkWIqvzMUB1KTD91hoCusWxWV3JCGNvdgm7hnDy48DDh+XELuUHbiSFX32FHQMHIf3mW2AJ0SqfexaKq5DRsrqriDhNejFLZsmoqdqo3CDTFUJU3j3ZJmqj12TtPf9xCV6amBcY5soczq87r5dC9jOjk50+XltBgYgesyNAtAkmft+QgWqrHWGBBnSO9l/sBA+RJwG0zpOwLfnrL9jy8oTVIf7OOxB1wQXO54adOF5YQIjC775z+nqDtNc4kig0F6KkukRYEsKN4cLKMC9tnofgJW4afBP+74T/wxk9zhDV20fGPiJEbW2QSO4ZJYXt5lwtaUQjqL983Yq1a2qNJDPEy98uqI8UvGYfgteSKUWtqUs4TJ3Dxe3K7bLKayExTII3qeO0eY4KMeG7G8fixhNkLu8Zg5Mxokvjs4SZloUFL8P4gmaxv9YX+Plq+Tf5E9WEKxJLotVsgKwW5rkm7LQkIuy/kmY4h8CkVdVaHDWRiZj/gpzcpLBZEapbh8juFQjq10N6LkmUzdSaC9DErLg+rra8FIt17gey2UPaMmD5u2hVyEqRu12mSIy/v/GvU3oYqNa8u03omKYi3SifNuuLf8RtQ8Uun8kFSvDShDQSlLVRuUUKmaAwTYzEuiwEPiPSCIogO7RW3lZNOJStoaD2mfubDxXj+i9W488SmatLmbm0jhLZIdEwG0zOdqxE/+Rw6HT+e86NXbuKFrmUJFK1axfKl8iuYVHnnIMAkwmx110rOslRFZdGPELGyGVGCRJEwoMPivzoI9XOkBKWgj4xckJfhVWKxf4xroq9UW/E6T1Ox0snvIQZ587AWT3rb3N9TLKcPLjksFyWilAtn7ty3Xpn+oV3hdeodUEL7BklMnTFpLT8SlG5LZqxT7QedlVxQxE0INbD1nAkVnj9YVS3GDx6xgD8cuuxePfyETDoWVa1V/iXYRhfbP5JVnN3zJRpDBSxRVVOmtk/7DIZ79T9BM+82RamastW5xA3DSm3OOV5QIXmwQtLlNXMNZ+7Hj+8BgHmYqRMCED3aX8g4f77XVFl5G0eeTVwx2ogzk100XI79UV5e+HLgNZ8oMUhoU7vR4x/UIrexpKz3XWblklt3cCoOk7NHGoZtlbJBmETJqAyV4pDU3AF9IE2hIwZXcNjGdi3r4iiK/3nHyEAS+fN84h9EpO1tCHp4ODM+iu84YnSTkFQ1Z1sOsoCEdujTh9vZbUNd/24Hla7AwcikpyWBtVwgvy7ip3ZpQ22M6iKZPBg+fkq129w2jVCtZEJaoTRY+ZMdPvxBzHxzZiYILy8NJqQ9OwzQhAfiSjB2y2yG3pFuX4/siykhqc26bWp4xqxLGOZR4thU2onYaOhOQllS5bCXmlF9tvrUThtt1OoGuLliQ2lK5i6atXbbQWiW1rZksMomX3AJWqTQxE8QA7tV+0tFu2Ilbe3I1V4mSMLFrwM4wuVLkCxTjSp58BSV2QTzWQnEgbWKQqamypVvdNEQIuTq1V3qUPXCVpFdPPPrsdVvi5VCnV64aOkihtFaLl33qrBsCukZ5VElooya2nWfSWjyMJTZIpEU9sSKyi+qzy35nMoweG9sTLP1sfERlpGIifWYEDqW28i4ckXUVUsfYIRQ+LEzHlvIk6TM+5z3ngD+885VzRzKJ42zfl41batQnwbEmJhCLJLUR8qq2y10sstmYPEMU2mI5wT13xXeF+YuR37cqW4OagJXsrlLVssK4fp4QnC2+jOgAYKXvcugoXffy+WF0W0BQ105SGTyNVHuYaQu3z2KXrOmYPoCy/EkYoSvN0jujstCETf6L6iY1pTGBw3GOGmcGGZ2JKn2Vg06MSLoAxoai5hOVyG8lVZMO8p8qjwEkF9pJgtmXNAVHqJ8rXZqD5c5hS1hoQQ4fuF1Y6ylZmAHQgINkAX0bTWvwzTWFjwMow3BfuALDePG7XIPaANAXaTM8cFsXWLgpaKJKvh36XmDtS8oDZoghWlS9D3aoydgby4fbU8z4x1svJN7Na6rFESAO1MAgOd0WYlf2m2Bl/o3KKy6HO1UDMKqmBRZJOo7i7WhPUJ9wLGJuayuld4fdkaNnwHTLtJpnlQBVh1ZnNDVXcDu3cTw/NR558PXW8pOKJGJvh824hTpeC15eY5RXTOa/9zJjdUqfWje1L9dgZfglfZGcT/rd3SsDe3DF+vkNFW1xzbDVkhMag2GOGorkbZPOk13RjfC8f18hTbA1IaLnjVyZ2qHIeOG1fn6AbF5VG18kjGKXgju3tUePvH1jIBsQEYdAYcm3KsuL348GKfgld2YayZMa4qvO4+XkprIHShBtGQwmG2CVVB4pgq9EH9pDAuW5rhtDNwy12mrWDByxzZtEQs2DaZZylm8ivBe1AJXreJXmq4uBUqvCQmzDt2+E5o+Pka2bxAVaF9Vatn3g98foa0KfiLmrBG+bNRneUkLxJxtDxoqD5rk3y858keGa1EyaxZcFhrbz+KXicDXY+XDRB+v6NFThpumnsTJv0yCZWrPnRVd4df2fQXztYqvKrapiawEVt/A367jX4xwKhVxPYvrl3w9naJUtM42b45KNa3z5UitiLPP090OqNGITSzniaJ5b7zjqd/NyWofjuDInWM9FR7d5JzVnj31bBsfL5UCrJJ/RNw24SecATosDdCtls1JCVh+WV3Y01if/RJCkePeDl8TdbdPolyGLwhKEuDIvQ4KdY6Mkrw9ojsUaPC2xyc0OkEnz5ealFOFXTyiFftkpYYiiELMOlhSAyBPsxVmSXLgi5M7h8De0Yi+nxX8xBDXAgCjHLbUIkO9jKZpsF2hsZRWl2K+WnzYWvtib4dDBa8zJEHRSVRt7MPTgCejQW2uIZ1m4XtmuBVk63SV8qGEwF6oLPbZCIlKAr2ywSAFqRy82YxU50OSEb3KDGKSlMz7Lf/Wbc1gUQfVR79PUlwVni1g1l3Lb93/yJXli2lLmiz8VUFTk8Hzfx8VG7SBLEvKH910lNyme6bLxtXzHkczUWVtQprstagb3EuTP8+54oU+/EK4OvzgJ+uBtJXN/yFqVquosgoas29wpu2Ui5fErsjrwVOesS1vLww76opeKGJxtp8v0TK88+jx/RpolFI0qPy9Qu//Q5VO3a4KrzR2sTCOD8EL00sG3yh/B3cq72iBXEAYC72OEkqLK/GL2tlRf7643sgISIISRFB+N/wi1H5n4fQc+ZfWNlddq/rFBXs7ETVMz5MRDw1FENcHIwpKa4q5LEdW/CabWYcLjvsrPDGBMWINsKU2DA0Xsa0NZXjOsmT9m3525BX6fptKWYu7AQphi3Z0qYQNi4Zyf8djcQ7hnm8RoAuQDShIOEbdW5vUcklCwNB9ynEBDeD6wTOmNSxJqy1Fs+vfB7/mf8fvL729bb+KEc0LHiZI4/ZjwL/PiMrjFRxdA//p2H7pnTyIvFymGasBwDH3SUna5GPl0gZBgS6VakiOsnOYtQty73K1wIU/yHFbPiECZ5DgqLaqFXgdv3tewKVe+bt3n/99826V3iJ7ifK630LXF3mqI2wG5TLGqTlp5p31ZNR23k0cN1soPcU+Tsue8v1nk2EukmNqKzEu9m50FMVmSK46MSAcpNpGWz7Dfj8VGDFB7VPOvMFVaLp96aqaFdNfJFtofgw8P0lsmLd5zTZaEMtL5rU6BX0X7Vbfk9Htx6e6xNRok04q4fQY49F+CmniGYLh+66C5ZDUogGBef6X+ElTn8FeGCPXL8V5OWNTK1ha/huVRqqLHYMTInAMT3kcPWQ1EgcCk/A2kHjRYLI4aJKp+BVzxmldaRqDEGaj5eSSWiiWkfmw40fOjuqkdgl3jzpTbw36T30iGpEjJ4P6LVV2sPKzJUej1G8WwCt23aTq5IbYkSAj5OV8OM7IfGuETDGBQsBHDW1B/TRgQgd4bLkUG5vYA+Xx5orvA2n2FyMOQekfeyb7d9ge76XpYrxGxa8zJGHGiIefaO8TlsuK50HlwNvjwT+0BocNIYtv7oaJ9BMcyVqvP27yovqPbmH/K0NEVB+YK+qckZ9RZ57jueD7v5QEraqmutL8PbR2owue7uGAHNCJwsUs0bJFCWHfFd4adIWNd0IjAAGen0ekShQe4i9T9F7+U9S9BIbv0NzDQs/m1eAEArxj+8BXPSVjN8iJj0tq700S33WQ65sXn/IkUkZIs2AJvMRVP2nijc1aqBOZRd8KiPYyBNLE8cowixjg0eeMk3wIs76KwvL9+Z7VnipqkrL3w+ota8hPh6Wg2lO24O+bJ//Hl5CbwRCfITlq5zi/L3Yn1eODxfuxadL5HD7DSd0d554De0sBc1GrataRpGsDqZEBePCkZ3xwRUj8d9TG+8/DTvxRGcb7I4MZe1+vPljcfuBUQ84l2/fmL44vpPXvqeJDImXJxG7Cj1PMIOHD4cuQp7o6GMCoaul4YIvyNeb/NAYBPX1XJeCNVuD98Q3xj/+3v+3aBVN2Bw2PLP8GZ/WBhLCGWW1jw4xLHiZIw0a7qVqKvknJz0JRHYBbNXSv0qVXqoU7lvYONFJ/0cN1Q+5SF53dfPskufUG+fEtT3App+Bl7oAa92iuxozIeqHyz08rTQRiGaoG1KSne1mnaiWsAqq8npDkWoqjiskDqgqkj5cX/x0pbQXzNUmlYUmuMQQNZNwn9g0+ALAVDNiKLBnD4+JRn5BUW/Exh+bpSFFVs5mdLZaaWI43us1Gig5DJhLAEOw7Ph24ZfAFC0ebfk7wOZffL8Qidkc6Z32mLBGbZRp3RPPSQf2zpe3R13jWiZ0QqROkqhbnUZ1WprwZNNEr6zQGCzYmSMfoNEDOonwUeUtrbKIizeGmBikvPKKtIiQ6OjXSwpmGqEQtoQmoK3bOVsX4D+vf4VX/96CgvJqdIsNwRmDXTYDqvASmw4Vi7gyeo4SvJS7e+qgJESGaH74RhB+yhlIePwbRF1yDToqZC14dMmj4vYV/a8Q+bq14bDYUJ3RhFEsmmcaJU+G9hR5zj+gCrohWZ7g6kOaxy8aNDAWASYdjJ3CRLWYaRi/7flNXF876FqEGcOwJX8L3lz3pkck4c6Cnbj0r0tx5d9XopqOh4xPuMLLtC200VK8lb95rOSndXaECgd6TXT5bpWHlSptZZqIaAgZ62XWLrWOHXiup+Alj2MXz2YANSaurZbVGY+s2oZCndt2zACWuLxaRb/JHV7kWWeJvFEPlH+XvLSEd1pDdQVQlq191h6utAV6D2/I00qNNMR3+NTTzqBQw/Q+7AwKk6rw7mtAKgR9rqAo6TMmy0QTqU6Xma1pBgN2VWYBh9fJB5KHAHqDFIjjbgOotS/xx51Atla9VVirgU8mAx9NAEqz5H3qOSR4aSIfQdVutV6qZg7ey8vNx6smrB0IS5QTvnLdxIvW4ey5H/7Fl8tkZb7cbMXk/y0SFyUm3Qk9Zizizx8HBDgQodMmItFnUxFjjUUbvUjY8xP+NP4XP4f/D09N7Y9ptx0Hk8G1Hg7pJCu8aQUV2JYpEzzCAw2IDG4ecUMZr5WbK1A6X3pbOyLLM5ajzFImUhnuHaWtk7VQ9Nd+5Ly1HqULG9/0pFe03G/tKfQUvFRVNqYOELcdZh9xe43AEBWExHtHIf76pnWHPBrZXbgbW/O3whBgwDUDr8EDox8Q93++9XM8tOgh4fkmvtj6haj+5lTk4N+D/7bxp26/sOBl2haKcPr2AmD6zf49nzJxCTV5TCUErP8GsMhcUAF11Gooqrrb7wwgWPOdJQ4ATnkeOPtdV/6uL8FLsWVK9JC3mDydje3wRmivZcnORvkSmb4QedbZns+lyWdKgKnOYfT/KgpqVnfps9Pwer+p8u8df8mTjdJsVyzY0jfktdGtaqvsDIo+U1x5xMmeE1m8K7yUNUvNEPzCECgnT6l1orHQd/r1RphoAhnpf5MRh0rSYRO+bO1zuzPxMaDHBIDiyz6ZJE80SOgSJP7LsgBrpfx9aXmnSSGNTiNcHlf6vzTkGN2tZrtiZQOh/6dF3akJa6phg8qzdbc1FGYewP/N2iHE7pxtWcgqqRKXl/72sV7bLIiLWoJ+F2QiPKKBdoa6GHgOMsKHIM0eDyt0GGbZgGuSDyIm1DNHlaq33ePkOqMsD1TdbS6qD8kTAkuGn+uSG5Vb85Dz7gZYshv+f1sTmkBGjE0eC6NKh/EBVfWqtFa9xXMOOhs9NBQVd5ZRnoEy1TVQQxcmT7osmT7sUY3EEBXI1d1G8PsemQc/PnW88HSf1/s8PHPsM0IA/33gb9y74F5klmVi1v5Zzv/z8y63rHTGAxa8TNuiKol7/pHCi7ylM+4FlsmopRooUakqmj1OlNVXNXGrtqzU+iCRo4a1h13u+dixdwDDLvX9/5TgpcpwfdYCf6AhdCJvF+xFWTh8731CaJG3LrCH1xB10QHpD6WKdI+TpN1AWDoW1BTQUV3lNYk7ErQ0xL/mM+l5fnOoTEggEUxcM8NlXSBh5w4t76v+AC793jmM7g2lNOjj4sTt6v37Gm5roOpzpWd7U78pyYBt80+Is8nh2N0mEywOKzIzVvv+PuS1Pf8zWckn4frPU8B3F0rhvHW663kkeOk3ptEDihtLGS6tCyFuWbPe1V11wkDRX1SJ+fx04T9XFd6D4VLwHiyoQLXV7jFxLSmgABXVNvy1ORPT1rlOnn5acwirD7id0KiqflkWAsLjYB14ARwIQFmXk9BUtpaHY0LBIxhf/SbSe2q/zYIXXXYhtyHVS8fIavfMzbISnhLVxKxjN4FHDRAIS24FHGo5+fN/rXYU/rYX1emlKPlHbleWvErkfrwJlZpobC9sL9heo3WwL2yFZtiKtRMymwMFP+1s0DJRRAZGIiFYTi7bW+yyHtFr2a3yt6va7jmhjWldaN3/J022HD+z55nO+8/tfS4+mPwBAvWBWHRoEa6edTWsDqtYd0w6E7YVuDXGYTxgwcu0HVSdVJU3EqybfpSVWhLB/zxZM+rLUumaeNR5jKtyqeKhiEEX1OyG5Q+7Z0sxE5YE9GyAWPCeCa98nTsbIXipgkgz/jUtkfnf+1G5di104eFIfvaZms9X/t2EfnKYnrqXEe4NJtSENao+EtR0obcWP/XXvbLbGU3eooQE+g36ni5FIYnei74Ghlxc831J9GpirTaoFS5hboiPl0RkfH/ZvcxdbPrZZOKRxY/g/bWvI9OgR0+L9LsWahaQNDV0613hJagb2TV/Aed+KD2+dMKwdZrrBMCZxbzUte7RRC8isnPdgpdOCi7/WQpq8hB/dTbM66S94UCkrKTZ7A5hBxDfIzTRKXiJTxbvw9I9MjrqxD4y/u3R6ZvF/3GipZQ4hl2O2ypvRb+qz/FktlZZbiQ7skpw5aerUG2z46S+8eh29qMykYROOGc+ALzWD/jgeNnUA8B1x3V3enmJTtHNU+G1lVTDXq55l20OWHJlAoQ/UOcve6kUh5Vb82ErMaP4z70w7y1G2eL2Y4+wO+zCg+lPcwnzfmkZMSQEQxdiEFXvshX+pXr4Y2tYvWUpAhwBcFSXw7J3K35e9RmaBO3fW6t9eAeDkmYoos69WYiCRgKeO07GLWaWy9//tmG34dTu2sRkxicseJm2Q0VbKavA+m+BRa/I2yTC1HC8u8eW7idRqmbIEyo/lGwOyqPqPtHIHza4TVajqp+/0IQu8p4qKI5KeTYbGo9Wlg2HpRrFB4Owf3Y8Shasla1n33wDgb18REwp/y4lAxDRWhXXfbl5C15C2RqUAKTJW3qTnAh4/D3yfrI/DDjLJewaiMk5ca0BFV4Sh6rK20Bbw/qc9fhz3594L302FgYHo2e1FElWskqQ4NXZgcDImpYD9/ceeon09RK/3ylPBmiSn8okpqYS3pMXlY+XRhmUfcEbssdcMU2cjNmtNlTnSXGrj7AhLkx+PuXj3Vstt4UuhiLRrGFXdhlI247oEoU3LxkmvLF039aMYlcFn0ZHAHxvOwlztmXDDBMW7c71mNTSEPblluHyj1cKvzCJ2DcuGY6ACLeWzORVL82U65/mmzfodXj5giEw6gOa1dKgqrvOv/0cwnfYHChdqFl1yG9sd6Dw192o2lkoXydX/gbtgUOlh4R/l6pzlL1bg6oSmR4z416YZ/8k7gqu+hvhQ2VBQFkcGmtrcJ+4lrVd7jsqKuSJ98y/3kBuRa5ICbhm1jW48M8LZfdCf6CTxI8nAj/59vozdbM0Q55gj0wYiRDVxMYNEre3Dr3V2aSEbA+X9df2n4xPWPAybQNVhjb9IG9PfV1W1ijvk4baFd7dt5x2hjGew+nH3CIzc898S04mUpYGfw/4FKxPFV5CCS5/oc8Rp/klydPae7IUVTRTVk0A8xNbxk6kL45BxvIYmIso+zIAKc8/J/JWfaIqvEmDPG0L7rm7SvwqMaziyagySRXhy3+RIu+O1cAN/7gq500ksDET19QJB4nHQ6tkPNraL4FvLqi3SrQxd6Mrxic0BOQyrdIbERorPcgHjQaZM+s96c+bY/8jT2CUH5wq3Gqd8tVtT1X0aZTBl8dbQZX1Cz5F9eQvAUcAdCY7TonZhWN7xnr4eNcUSKHYK6gYE/q68kzPHZGKqBATBmtV1B1ZpdL+s+AlUZkvTj4Ojy2qcK6SuaVm7M5p3Ez+Z2ZsQ355NQZ1isDX1411TT477m7ZrY4uyjvvloHdLykCT5w5EF1jQ3DKAFmpbirV3oI30z/BW7ExB7aCKuhCjYg+W66LSuwS9lIL7BXypKj6UCmsBTJKrS1QQ9B9ovvU9O/SPuyL04FfrhMjX9WlsspvqlyAoI13idvmgyUiuaGxgnd3kbTYEEl7pRfbHCgn/XY/ZMWPO38UXtK12Wuxo2AHvt3+rcfr/Ln9B9z/1bHYkuvVaEaN0tB209g5De0E84FiHH58KcqW1v89yldnIe/rbU0+qVp6eKlHoxBfkOB9Z+I7IqdZF6DDwNiBGJvkY3I1I2DBy7QNNFxMHdPo4DngHKC/y6PkbHXq3bJXm4jk0e2MoLSGyc/IoX2yGOgMsjpHnmCahLTyQ9dzKfKK3vub84HXB8vXJO8uVY5JsFK+akNRk7copovUBtkCiA3fukQ3xaZl1t55zJKZiYP/eQrlmUFC78UNKkHvs/MReUYtQ1T0PZS9Q/ltlahVvt3aKrxBEcBdG4GbFsjhfPV4J9khqzloVDQZQVYJVbGnrmV//kc2i1D5yJQk8c5o2TGNIsyo+kWCN8cleFM1/25BZAq6dpWdo9KMxpr+3dqqsSe4zZIfdJ5nFjMN67svJ8ohDo0HjpGVlvowF8ldbmCkBScG7RYdyNwrvPMzZO5pnKMAF46Uk+Koajp1sLQ/jIkuw8X6+Qja8h3w2RRnbvF7lZNFJfi84Z1wfC9ZlVZWiIaw9mABFuzMhV4XgHcuHeEZJ0a51HdvAu7dBpz1lhwROLBYnphoXHlMVyx84CT0Smh4G+G6KrzU2tZXhbdsZSYqNtf8nmXL5TBv2PGdEDI8wdkGl7p+kRVAvFZOBaz5lch5byNyP9oEh7tNpBXZkb+jdjsD+cZpsqPeBNuwu2F1kMfbgcDeSTDY9kIfkA9YHTAfkNtBQ+gd3dvD0mDOKEVKWRwssMLUX/5+gw468PP2H/H+xved/+/zLZ+LZggEXVfMeRiv7tuKnOlaLjpB+71drolUYp9L8yS+mAp8eWbtOeDtFFqfHBY7ytfXnf5DoyrFsw6gams+ct7egIqNjUu6oPSF1Vly3oG3ncE7VePEzieKbnyKN07SJh8zNWDBy7QNyuOqLAQq4oqqo6OurSl4LVWuaCf3CpuvVqlqhjqlDtAkpL8fdInA328HfrhMmySXJofbVG5uQ6u7iomPSr/rMbe5XodEN+3wyZO84n1ZpfnwBODXG1ypCBrWvDwcvPoamNOyoQ+yoevNIxA/Jgh6Q5VL1HpD340aQ9DJQfJQzwqvmPxnlQcdp+D1GiqlZd4Q60YDMfWUVbXq9HSROdsg1O+QoUWJEVTxVcPp1NqXhtKn3wS81heOabdgY458bpDdjj7a+1ni+6BLF03wGgxy8pg/UEtpOqnqfYoUt+6Clyq5mk1CQBVx6lLmowGHLwq2yMlJgZFW9Kjahp6xRqeN4GB+OdYWygpvoDkfk/tE4ebxPfD8OYMRTckIOTtw+/Yr8X/Gj3HWgRekPzIoEgcnvosPs/oIYfzQaf1wbE8peJephhYN4LU5shEBie1uWvKCB2RxoZM6Sqig5UO4dzpsZlTebOhIWTG2ZLoqvjQZrWj6HhR8v11MRlPYSqthSS91/r8Ag04IX9UdzJgqxZw1pxLmfcXC7mArMqM6reGisTknrPWL6VfzQRUf2OMkmHvIhjrGlDDoLvsMAb0mIjBgvbjPvKfhkzxpGJzIr8pHQVUBslfIk9PVEVvRedKp4nfufwi46ud8FJRkIyk0SVSFSy2l+GyL9PZ+ufVLDCiXv8nEjB3IX/eFS6irCbjiS/4hR/ToBMm9NfkRAAndqu0FzhGGuiYJWvMqnZ5zB2VSf78DVY34baiaXmWrQnxwvKj8NwSPTpyMByx4mdaHhJhKEuilDY12P0FOHLp6hpy45NXSVOwoaZiZckpricNyQpVeYvUnngcOylLdqNkojr0TiO8nY6do50xDiWrCW0NRflclICkj+CQZIo+/7gNm/df13M0/A5+f5pzsU1VcgIM33gBLWhqMMcHoPjkPwUMGu6rYKgbLjYw9szF/xWv4PSwU68bfKSu2BC0b8uJSK2SyhpBVQ/jtNIHSihgSEqALDRVtb6sPenmx64N82LRMCSXmD2kpC6phBkWYUTXfUoG0bT+jsLoEJp0RNxSXoI/m3zWljEDXCFnZPmQKxI64bqJS9dKql/DciudEnI9PKL/2+jlyshkdPNybj3h322sAOaVVWEO+bBJlkXoY7GYMdMh1fG9uOf7YkIFChKMaUgQbKnLw8On9cdHozrKD3w+XwWirwF57MpYEjACGXwHcshSvZwwUz586JAWJEUFOm8SKffmw2vyfwb9sb54QySa9Dnee7Ees2UjtxHT913IkpaHJKPVAwtVeUi1WX6rS0jVZEWxl8oSmYoNWbbMDpf+41rGqnVKcUKMDfYSMUAsfn4qEO4cj4pRuMMYHOyu8ZAdQVG5p/clVVBFUrWIHxGrWGXe2a4K33xlSnNNBO7Qahx98GBXhkxGolx38qva47Br+Qr7Q1DC5X9ibvwe2zfL1d6YeRmivPqKhid2gw7HbHbjnNztuG3ob7hohbRRka/h408f4ZtvX6K5NECXCZj4orWiqoJEw0LXdLnzZ9eY0V0PF/7UBlRs3wrxPRujVR9XuQiFenRMn67DVVGuVdlOXcAQPlieelZtzfYroukYUlh1e5rQzsIBtPljwMq0PJSiU50jfrrs9gcREZCe37mVuglfNmCcxVN8ZrPJceh84hKfMISt9pzwnq7LKPkH5smp4vzkgT3G3E2Qclfr7poVy4lRRGpZt+xEPLHwA310/AdXbdwIxUehyURKMoTY5Ia/ruBoduojismyct+R+/CchFo/Fx+Kavd9ha56WxUv+VJUaQN5dVd2lqCv3qmQrQDtpVeVVMVx+Q5/14m/kZLoraaJYgPwuVNGkFAuqnp/5JnDHGuC62dgYKit2A3QhuLi4FP00wRvddTwSQxNFfA/1XLvwr4vx3ob3xMGafIkvrHzBf5uFOnD7SmLwA4odu/bz1YjPlZOBggfIiYapJethgBWDzOvw+ULycgagOjTJ1VVQnSBOv0WcANojUnFh9ZO4ovJ+5J/8P2Tr4jFjU6YzKYEY1CkSEUEGlFZZsSXD/6rlF0vl+nLJmM7o5M+kM/Kr06gCiXEaSXn/uGZpGuJd3TXEB0MfboIhJshpayCxULHJZWWgoWOVtVu1QwreoH6uFrcBugCYOoWJa6c9IqcC1WmuFs6V2/JlDFpepYcQbkmyK7JRaC6EPkDvtBg4oZGaTBK0ATCHTEDFWtlApmLpHyiZ+TcOPvwWjA7p/7UcLodNqyxW7dyJ0levQMUv2gRaP5IacjYdhLFSh0J9CfS95PYUOfUMxL/3Fmw6YPRuB041DcOJqScKEUZD7m+tfwsR5jKEORywB+iwIdCEQKsZjm/PB7ZMk28w+jo5qZZOwmnbpUmg1L1RteNuA6q2b8eBSy/DwSuvhN2P0afKLZ6WGRpZqA213gT2iJQnaeJkpKiGL/3wU8uE9aE2Fh9eLK4n604Qky2L/96PslWZjYqgY1yw4GVahuXvyfiiah9nw+qgSEPFvoSYivqiHSRFkVFcl/KD9T2j/vd28+FaxmoNLdKWy9xZ5bUl4vsAF34hRfeJD6JZoWovxVzR5J6THkPWuFux0RiAjZ0G4t6EONy8/hX8s+dvjNghD1K77jsbJp3WzYsEb2+twQO1SSZBoTF3weMop4Kt3YGuYalwwIFX1rzimpHv7uN12hncJqy1IsHDZHW2dEEjRBCd/NBkOkrBoEo8sfRNea0ycOnEp8sx2Jgkh/yG5h9ClMMhMngdehOCkoeJiRydw13RYSd1Pkl0LKL7Fxxa4DpZqI+LvwYu/7XRk/o+XLgX+w/mIFHLF44aK4WzMX0ZPgj5CN+aXsS3eBQnJlQiNFb7vGoCJ8Wh7Zwp8pZ1l3yLsBgpiHdmleLr5QdhtTswpluMc0Ib+W+P6RHbIB9vRbUVC3fJStQlo90SUOpbx6/9Gzj1JbkNkaiZ9UiztIYmQVulVVxNKfKkVJ8khWrBwWwRz0WRYwFBBilsHRBZuyQIqnbLZRzsJnjdMSZogpcmq+VoE4v0AWKSW+XmPOS8vR65H26EtbDlJ7LNT5ctqXtE9RAnZh7smCk/Z+KZyPsxQ1QFTT3CULHiD3F/gMGEysMlMATI6nblpsM4cPElyL1tCsLL/oRp7bPIev55ONwqsN6MSRoDg0OPxJVyVOGfqBXor0bYaFc6/mSEj5LrfOXCxeJEliZJPX3s09LioAmwgJgeeL5LPxwy6BFQsB/Ilk1WxH6s/1TPTPPj75a3F73qHOlqTfI//lgcU2z5+Sibp7UErwWHzY5Kzc5AIrY+weus8HaLlM/XAbb8Ko9JkRXkA7Y5fFZ+iV2Fu7CveJ+YwNhrVYyYBEeJI0XT9qB00SHfn9PhwMeL9mH2Vu0YwviEBS/T/JDfds5jwKqPgK/O8ez8Reyd72qC4AsK86dKKEE7T6pyUAwSVWPJ+lAf5LM0hsAe1xdTS1ZjZxBVqxzS+0kTbVTbYFWlouFrNXTenFC1+sppSB9xCc787SxcMfMKXOE4hLmhISDzwy26kxBoBQpDgbUJZc4MXiF4SYxT0wLq4EWtl4mSDPx9WPqYr02dhE9O/VwcJMnvNS9tnqePlyq89H29J6y1IhGnyoi4sn/nwW5uwoEtdZS83iYP9B6eWpobaJJWkmMrXLOiA6iDWqAUSjQMe26vc/HT1J/w1sS3cN+o+zC1hzwIv7vhXf8+A406qPziBrI7uxRvz9uDLlp7YrJ76AdpVp698zDJLtMf+uvS8bH5fgSUawfCHE2MqyYswy8XSRN9k2QFbvPhYvywWvokrz3O8zc+Tpu49vHifZi3Q2stXQcLd+bCbLWjS0wI+ieHN2wdpwl7l/4gUyroMzexckepCdQdjQ70RGCfaHFAX2ZdI/7evGIlcpbJ0Z/gQbGIPLWbGAQgsVrwyy44zDYxSY0sDXUJXnuFjPXSxwQhqK8Ux+S5pP9PNgklXlqK3/b8Juw1xMldtPXBnR1/wuEIQH7eVXBUWWHqGgFTwmFxQhHYpw9S33tPTHIN0klbQ/HMXajafRgxfeV2YAh0oOKPz5F23fVinoAvzu99Pi4vnoqkqlhR3f0xdjYGxmmjGRrhJ8uTs9J/5T6GcmGp49fM82bifwNlQSEgvh8mDrwMNycloITmUajJtBTbR5OSab9L+/XRN8h4O4qWpDkU7jaHVoDsVSWzXO3Xi3+XncxqgzKbHZVWsT6FndDJuX76gqw25OElAruEQxdkgKlzRA3LCVkknE1EVMa0G3/vl3aQk5ImwJ4tXy9ogDyBLV+ZKSL3vCEr0vMzt+PuHzagqhGJHUcLLHiZ5ocaH1C1R002opm5VKklyLelAvxra/BAlTunrWGPrG4pv68/Q/M0BH3nOmw99w1kVOVhdrBbK1TKSg1zxT21Bl9t/UpMQAg3hiPBGIFxlZX4sTIU5xbJ77i5WwB25G+VUWYU0UDJFe55uVrWac6cR7E6UM4wP/WY+0WF5eqBV4u/X1v7Giw089lZ4T3gikXzTrVoxQqvISkJ9vJylC3SJhxq2IqK6qw8eeCsqmo7ejdPLbVF3VOegUibDWOqzK5s4XF3Op8zofMEPHPcMx6z4G8ecrMYRqahw03ecUrNiNlqw/2/bBINHE4NkaMdJFaE7UbEmMnv9IF1KvYaesFkLgTyd7tGSXbN0br2BQDH3C7u7qcJXmrjm1dWjcSIQEzyigE7b0QnDO4UiaIKC677Yg3+++sm7M+T719ZbcOenFIs2JmDVfvlyegsrTJ06qCkxnkGqRI//gF5e95zvkd26sFutqLoz72yFfDhMlG9jTq3lxga/nrb1/ja/AvssGNgaQ/otkpRFzI0HsakUEScLKvSlRvkyQIJWLIv+EIXYnSlNmjiJHigZmdy0xJ1VfKayvy0+Xh86eOi6QSJzluG3OL5hNydItnFbB8Ca3kQAoL0iLt6AMqXye0o7MTxCB13DCqrkhCqn40AlMNhCUboxMehi3WlkYR0AipWr8b+8y9A5SbP9dxabEbAnkpcmDNZ/P1x4jTYTA7nZDZF2ElyP12xZg1sxa7RJqpAhhRpJ+lxfXB+n/Nx2BSE6xNiUJE6EpjwX9ecChoJuG6OTNQhj/zpmtAl73dtE3NbgPzPPhfVXbEN0v5j8WJY82v3bis/ePCAWJi6SPFqza2EvcrqQ0zLEyRDQoizjXJgryjnpEKavFv4w6+wpLtOPiwZZTLZYfYBlC49LG4rwXt22KnixEsXYULsZf2gCzWILntVO6T1Zn1aodiWiT83SvtTpcWGjWmN7FJ5FMCCl2l+1AGbKpV0Vk9Vnz3/uiYf0UQq8nIpX6QvlK2BqpTbtLNwFfflDxHJ2FQiJyX8E+IK7f41SIeF6QsbHcrvD1XWKjGhg4amaPYzVXJUXMy/U3/GR1m56Ju9C+VLlzgF7+6S/bCoipnegMrSamzKGS5fkCq8G3/A7LS5cAQEYGhkL3QKl5NNrh90veixnl6aLmNsVDWXmnSoLnZUxW4DAnQ6RJwqY9VK/5Y7cWtuLg4/8CB2HTMOWS/46aF166RXVWTE4Q9nCZ8isTlvM7qazfgxMxcGp9r7qN683S4RXZztOr/Z9g1aArvdgQd+3oSN6UUIDzLgzHCt+tO7t7QDaA0sqrpOwOGRD8J4wyxg6huukQ/qOEdtjpV3PU5uE6rCm1MqBf7Fo7vAqPf8vuFBRvxy6zhcc6xcH35YnY6Jry3AyGfnov8TszDpf4twzeercdGHy/H50v2Yt11OAJsysO4OevWmW9A2T6Mx1DWxgRT8tAtlSzOE6AweFo+k+0YibGwy1uWsEyd0O4MPYPmJ+1FgksKixFSOwJ5SUISf3AVhx2knisK/q016rAVV5SWockq2iACjTlgbQsclt7jg/Xjzx+KaxO6T456E3jsxZfajomhQHnqN+DNkWAICAnUoXyz3GaEnnIAAgwEhJ54Ga2EmEgPvAMp3IMAQjALLfbBAnvjGnz0aph49YM3OxsFrroUlO0fYRagSnvXiKuR/uQ16mw7bQvdhfsQq9I3pKyq47pi6dEFg715iAmrZIuktdZKrjSLF90VCSAImdpmIHYEm/G/QRM+oyS7HONdfwYCzZeWXCiO/3d7oCWz2qipUrFuP8hUr4bDWFKHuWHJyUDxNeouTnngcQYMHA1YrSv5y66joRWW6FPj2VBP0oUYxGlBbldfp3+0W4VoPe7sEb8F33yPrqcdg3jbNw89L61np/HQUz9iHzfvXi+5qIYYQDDJLT7epc7hIGgkdLbdN6qz3xbIDOPe9Zbjz+/VifoA6YSWW7ePOdrXBgpdpflQuZ5dxrs5nKmJqn5udoS5Roiq8Kz+QopcsDtQwoQFsyZONGcYOvhJrImKx32jAK+W7cMe8O/D2+rdbTPR+s/0bMaGDLAxPLn1SVHcpEHx00miZpBCWCJvZjqptcsLJgT4RsDps2GMyCksCHZDmfLoVixeFolKXgC0BFqz++z/4M0zGRJ3W9wKPmdYqaHwrVYmVpUFEujnksGJECtILKoRPs7WJOF3+/qXzFyD37Xew9/QzUPKnrFiX/PGnf5FlcX2BwAhUl+qRtigBJX/NQs6rckLOzv1z8U1mFjpZtOp4Zzqw+pEwQLq493nielnmMtiawXfqzWtzd+KPjRkw6ALwwRUjYUjb7xK8xCnPCn930CVf4Nlzh6JLUryM5KNhX4K+j2KcjKRyr/ASVMS8hFIcfBBo0OOpswbix5uOwcR+CWLuGzWUIMICDegWK0Xf039uQ6nZKirFwzu7dQ1sKDT6MvxKeVtFCPoJrfPmXXKoN/aK/oi9pJ+YqEbM2DdDVEJP63YaLjr1asTdNQwfJv6Mx1PeQb5ZHtypKh05tQfCJ3YW1drgfnVPQFUT1wiq3JGYib91KBJuH4bw47Sha6q+tcAkIfKN04kaVUjvHH5nzYo6neDumQtbQAwqS+W6QmKnassW2AoLoQsLQ8hweTIcceoUlGUGwhCQi04xDyJQtx4OBKHA+H9wOAzQ5W9B0osfI3TSgwgcfA0Kvv4TJXMOoGJNthg0oBbFdHJROMUg/q4t8zVsorRclM6dC2thocuiRB0ICbJf0clXX9mK/M+9f6JcNW+pjdNfBYJjpN933rMNWoa078584knsHDUaBy+7DGnXXIM9J01E7jvv1jpyVPjVV+Kx4BEjsKuLAdZT5EhR0fTfUG01i4l4NXzkh6WI/aNCziExpUqbTHV6We3+3a4uwSvEaqBe2GcqVspjoDV3B9XjxW0ayVCRZ3TXnhWyCn9Sl5PgOFzlfA0idEyy+I3Mu4vw/Sx5ovHP9my8MnuHGMlRLG9EHOHRQocUvIsWLcKZZ56JlJQUsTP57TetJajbxvLEE08gOTkZwcHBmDRpEnZ7zSQvKCjA5ZdfjoiICERFReH6669HWVnjOhcddaj8XBIeNLxMHNYE736tQlBbG1bvCq/yM46/XzYFaITgpZaLQ+/eidzr/sbU/pc6Kyw3zrkRr695HU8uexJZ5VkNGhY7fP8DYqjeG1q3aGdPVForxcQo4tpB18oDG11SRqA8J1Dkf1L1JbGbTJXYYTKJCtmm+YdwaAcd/APwjbEPLu2UhOuSE7E90CQmW03ppk1o01BxRtvyt9X06/aahL83Z+KEl+dj7PP/4tHpm5GW33ptVamKYuzUCY7KSuS9+y7spaUIGjgQ+qgosfwqNkj/YW0U/ToN+y+6GIfXJCNtfixsFfJAUb50KSzZ2Yjf8jsi7A4URXeRDRGud/nz6mNQ3CCEGcNEeL5Ydl597DPKtJSERkBWgXfnS5/pS+cPEVFhZq0q7RS8dFJ34gOuCDYFbRs0k52qX6ZwOfHHzbfcLTYUJmqXS9mn/RLqbeM7tkcsPrtmNBY/eBL++s/x2PjEKdj81CmYf/8EXDTKFVdH1V1dLTYAv6FkEuLAEv87HZIIKKgSk7KoDbDyKyrWZct9x2ndTxPbUEpsJ+zunYNdwQex5LDW/U6J3lO6IfbKAbJa60eFl55Hlgg1OY4u+tgg2ZyingiqxvLDThmNeEq3UxAbLL8rVSdz/vc6yhYuAGY/Iu4rslwC2OixAuR//Ko4YSSo82IANVKhE97Ro1GS2wkl6UFiqD7G+D/odOWwlIYhq/ojZOS8jMLv90IX1gvG5GGw5PVB6QI58Sn6gj5IuneUOLm4aPRlmHbWNNw42K15hBvhE6WtoXTOHOwedyx2jz8R1vQ9rv2zJnhpEly3iG6osFY494O1EhaP3eP/I28vewvY/Y9sSOFHV7aSmTNR9NNPokKrj40V+xMaPcp75x3kve9qkqGwlZSg8Hu53K2XnynaJN8a8B1gMsG8fTt+uWESJv04UbRRVuQfyoTRpkdlQBWWVa3xEJ+lC9NFsxLViIL8u6rqG9jd1XExQK9zTnar3CK3f0d5DmZUSVtDRVqJM1WEiNwrT3JP7366M0FEvafBzWt+skUvTqSJjxfLE+nTB8sK8PastsmTPhLokIK3vLwcQ4cOxbvv+p6Q8vLLL+Ott97CBx98gJUrVyI0NBRTpkxBVZVrJiWJ3a1bt2Lu3LmYMWOGENE33XRTK36LIxg1WYoaQKjuVjTETr4+Ncxe3+QzakChoKYJKm3BT0qqS3Cg5IBT2FA1ZUzyGDx2zGN4cLRMZFiZtRKfbf0M03ZPw087f/LvdWfNQs7LL6NkxgzkvP6GzzahNMOWJpNN7iqtBF3Cu2BSF7cJTynDUZElvcih48Y5A+e3m0yo0CVh+XQplMz6SnwWJ3eMCdAjNigGl/a+DP+8tg/TX1vnzHFUglcE2JN4IpGkYe4xCc/9JXM+qYr37co0nPf+MmQVt04rVRIh0ZdeIr/rwM7odUsKut3UH1ET+oqShhqi9QVVkWhZU2WrZGspLBU0CSRFCGY6uOf9+gOOzZati6v7XC292w2A1omxybI6vixDy/elZm4l6bjgjwtwwZ8XIK8yT5zEPLz4YUz6eRKyy7P9sjI8O0MK6EvHdMYFI1NhzcwUvmUYDAjsU08Fmry9p74ob1PVacrzHlF8Br3OWYm9apz/ExI7x4RgYEqk6J5Gvwtdnj93ME7ulyCSHehz1kd+ZT4qRLZzLdD2TnGDJITUfsAPrFoHNWNiiIf3lixBtD0RwxM0iw+A4ztJO4i74G0IwgqhDxDiOkDvKfLLLGVAitw+ScTQ70/fma7VpKTGUlRV5PRoXtJXbhdEyezZyP/oI5S8fqdYbnZjDMoL5URa89ZZKPrhR5QvWeL07yqUreHw0hgcWDcauoveQPT5cnTM5kiAA2EIMNoRmpqG4ACylcmKdcTgEmczD/E6AQEiFs1I6S7UgfLPu+XkY42gHikISnT5nu3FxSj/VxO0EanOCaL0Ohf2kTacOQfn1LksaFTllkMz8H24/L/2n64AXuwMvD4AWPpWrf/PXlGBnFdeFbfjbrsNvZcsRu9FC5H4yMPivvyPP4F5v2fGbuF334sTbDrZnJtSAJvDhmxjBZZcNUTYxIavyMOFfxTij71yYuyuFUvwy2tPosCciT1B6dhWuE38/kJwGnRwVNlELnLhr7uE2K0g77gdMHYOd8bnKSgD2qGjVAiXkM8ol+t0QHG1PKnSVsG+5d3QGckYEzoStmKzuN+kNUoh0lLkye2JMOKLa0YjXJvToWIJ+ySGNeQ886ijQwre0047Dc899xzOPddtNr4GrbRvvPEGHnvsMZx99tkYMmQIvvrqK2RkZDgrwdu3b8esWbPwySefYOzYsTj++OPx9ttv44cffhDPY+qAtrY8twov+XSpGUJVkWz6QKkDtIP07vzl09Kg7QWobXADc2RVxY5aLkYHeVbQLul3SY2e9eSBdRfLvoa4Kag885FHXTvRb79FxXrZ6UgxY+8MZ/zVqye+itdOfA3vT3rfw6PnSBoqhiGJ0GPHoX+EFPdUwV27IQw2qx1dB8Vi+6B/UWaqQLIhGX9ftgILLl6Ik3IvRP6hMmTsLkKaNhTWL1YKZvJ+FVHLz+iuKA0IwPSoOFy1/hdkVhxEcmQQvrh2NHonhCGvzIxbv10rJlS1BjHXX49e8/5F5xtGwFi0BgHL30JC0HR0Hl+A8mW+I8v+TfsXv3x4r5gkY0hORtx/7kTUpZegyxdfIu7s0QjQO2Bd9Bmi7XZYKnQoeX02HFpL4YaghnDdBe/r614XNpTS6lK8s/4dzD04VwyrU2YqnRzVx28bDosEBbIN3DuZhD1QuVUmLgT26gVdoB/r8qDzZYtlmsg48/4aD7916XD8fMs4jO8Tj6ZA3t9Prh6FDU9MxpDUukdQaBlM/mUyrvj7itrtQLSdqkmG1CzGTyxugted9dly++oZ2RNRQVE1BC/9blZqC95AqMKb/N8xiLnA8+SDRmUu/etSfFcsW1mb00rw8JKHMe67cdjz1XJkvbpGZKLWR+WOAldjDJq6UHoIb6x9Azf/c7MYOqeT3KHxrmQYdeIXkZAtrSfm+6AL7wSHvRoxV0xE3G23IvL88xB92WWImDrVc1d5/XUIHjkScfc9ioCB5yB4ZG9hzYgbsgqJptuQEnoDovNuQ2zg64jX34lY41MIT7tV5jzTm7m3+d06TaYnUPdJapBDHl1zGQK+vwjdJhxEn/MyEX283HdXrtOKF5Qo48bxqfK3ocmgyiZA1iXvdWZN9hrkVOTg1ZhobDcZoaOJzVbthIIsDrU0Msn/5BNYs7JgTElB7E03ypM3kwnRV14pvM1kW8h+9lnn+5HPt+Crr+SyuulGzHYT4m/Fb8B7ZxpgDwAmb3BgzaKfkLFrB/5661WUZ2ViQdaP2OXYIY4JmeWZYr1JeWyssL8YU0JFW+fyFZkyaoz25yNqTogO7BqOyPGU/OFaT69PLMdh7eSDIFFbECdPJC+2nwlHRqVze9AFuo4dHx/KgxkOpEKHsREhuPUkeXKTEhmEEV2icXyvpu0POjodUvDWxf79+5GVlSVsDIrIyEghbJcvXy7+pmuyMYwapcUhAeL5Op1OVIRrw2w2o6SkxONy1EGVHdFnPQCI6Slb/SYNkY8tf8eVsVrfTHCqcp32MkDxUu6THxpoZ6Dqrq/e9RYS3m7sK5Jn3DTx68QfT8SzK54V4kbN4KedZ8YDD4jqgmnkcOhPO1kcLDIfe9zpZ6PXnLlfJkrQhCiyH9CwJU2Qcqd0Vxks5QbojHaEDOqF/hnys+40mbAxYyCCw43ocrYBK0PkRL9zrNfDZAxCeZEZG/5xtevcukhWDCJMEc6sWaowz4uIxkldOuGJ6BBsK5+HwMS/8MCUvpjQN0GIG2pKsD6tCDd/vRZztmY5Z/q2FHRAooNTgBJAnUaKnNywFDNSuiyFZbfWRU2D0iYeX/I4DH/IlImoCy9E/G23IfnJJ2Hc8DrC972A7lPyEUcRTf/P3ltAR3mt+/+f8UzcXYEEd3fXtlgV2lKj7u7u7kq9hbZQtC3u7h4gJBB39/H5r733TIKdc9pz712//72n37WyiAzJzDvv++5nP89XRNfstC/2vAKpuBZFb9Fjj1P05JN/iqMtTPQFDpUfkgXugbIDssDVeDZb4hwQqWxeiA7QP/q9dqeLdcdLeX3lCfn1nSPbERGgilsvX9unc6c/e9DgorcVj1f4Vpep3+mFSFTrm3xhn9l/5/0RIrd/BPF6Pz34qexyi3M8szqzZXryL2kN5/4up5OaRYvPcwzwFrwNG36jcffu1ojVMlVU9YpqdR4Q6BrelSBTkHzPBB/234HgCGsMZ4vFhNhU0FmO+agpS+HJ0/xx+g8mVw3HfFxdJ8IL1XLqHyvhhdVU5Q/HqPo5Q4qSBF7Y8QJfHf2qZSMu3FW83F23y0XGkU0sH+ImN8lFvfMKrLbuuN0ufDtaCb36ciLuuYfYl1+WYqtzN0zGpCSS5/7YQjuQ30sIwKdHOwzaPDQWUYxpcAx/mezfXFBzCI24R/9yjYo7fzEcMla2+pV7IXQXH/eV8d3ic43JH53RjdmlNiHNJ063cuzPQEpgCmE+YbLYPVJ+BEdVFVljxpJ/663nbaAERrWZyNc9J/NwRBhXJCZRmzRAbfSW3KEi0s+AoDFVfqX81CMfeQStT2s3VRzP6KeelMVv4/YdNKxfL8/d7Dlf4KyqwhkcxEFTE7mVyuPWSw3b1NlNbge1mQo+Wsiit1/A5XSg0eiwu6zYszIIbNC3REALuzFTUiABw9U9t35LoeTiCkK9udsFCs6dn8ACRaXzwnzyGPVBre5BcytqWKxRtUXb3HbM/9VDsfJ4UAuIRsWarAr2oo5Jc3ols4e04ZEJ7eUGWNCRhqYqO8K/cWH8xxW8otgViIo628ZHfO39mfg3MvLsnZperyc0NLTlMRfCq6++Kotn70dCwoXFJP+n4R1jCrW2wXMz8tIahF3ZX4ln7X+Lsjr6N2ySvAWvWBjPhegsCIyIH0GPCBVTLMamsvu//z3ZMVqctVhye29YeYMsgh1l5VhEl06r5alxVdzYYatMR7OdOqV8Lqur2VG0Q45ghWvCwFhPUto5EH+j8jvFJQtJbUT3200k7/0RH5eLZq2GWp8qRl7TgQV5P+PGRUplN4JOKyHart9O47C5CPZ0wXKOVNLgMcf30hqEIOZNbS1WrZZQjeps6/2yGNVRjcWSwvzkzVEc0o0Z5dzywz4mvL+Z2uY/aRH276KxEkrVe8KMX9DctAaH3YQpyIH212vPCisQVJOgojo6FoBTA2u6en52clVLXLQp0IY51I7bBaVWdXyq586TPL3aJUuoXbgIW5Zn0vBPICYAgnMoRpyimH199+stgrYJyRNksIdIwhIbCqGcLmgokEXxuRAhEMPe2MBN3+2ltM4q/WzP9MaV54700/yTBa+A4GN7hZoivvf/AWxOG09sfYJPDn0ivw7w0GXO7IifB+/1fQ6PV5z7JS+9RPETT5B73fXYz5iWeVPVLEd3kDfrOkpefkXyWr383XMLXjExGRSjuvNbCv58J/lCEJsd8XeyqrP4Jv0b+b26MLWJDW0M4JbSy5hdqgSOmgiTFBdVz8+QfqqWk9VnhQoICD9gwf8VEF7C4n5ysFxx1R/q8xBLpy5lFB346fmZvPzH/Vz5w0DuuaKeb4caeCukI3X2a+RjrenzCb7034+ylqJhr+PClI/Rj7wL3wGDKNoVjFt4mgh6WYlnsyA6uqK4zPdsNq6cq1IFxSTM1iB9zZm1VDYfzKGeWPT8KtW0PKfDKwrPPtF9Wu61dStW4Cgro3HrthaRquiki42ld+L2yvjPaWw/geM6N9fqqnAKioQouM+Mhxfd3c+/wG21SuFZwPhx571kUfyHXKOOX8X8Bfz01EPk/ai6u6dNWvZ+9QNTtsQw3K8fT/R/Qt6rxTndcegU+Zhhx/2w1tTR6O9mbML1hBij0did9DoZzImqszed5i7h6IJMyrfZk+wnxI/n4eRKrLXqfTjuKQnEBji1Y6u4bYWllvWBa6XtXrLFn9HNas3bZ1PH2llfz9ZvF+J0OskOMbQkAwou/x0j2tHHs/ntlxKK4RyKzt/4Dy54/yfx+OOPU1tb2/KRn986Jv+Pc2jwiBgkvMI1L/5MeMR/Ed6CV7gj/KOCV9yUBadXwOF2yC6Mt6MrVOECNpeN2atn89bc2+XX9bFBHKWQWh8npx6ahjYggOZ9+8i9aga7Ditu3rikcedRJrwQN31R/Gh8TIR200mbNl1jGW09ZgWaXtVEdvJlVY4SX3UrHkFNaRPZh8o5sV1FyI6a1ZHY1GDJ4T22rfisgnfeiXkU2GrkTbyd+1WclijQONlQ4PHkFYV++0gW3zFYWlaF+RnJrWzig3V/Mf73r8Lb3RX+s/4RMkChJvweHFYNOmsxbm+ohBCdnljBtO3q+O9N1fB69hzS8zbBUo9TQa9ZOKLUgnrUasbvddEJ1dC4ZQvl77zT8nuEVdGfgXdzIkIAhNOFWW/mrp53cX/v+1vSr8R54uVke3l+XghboHt/PkBxrUUeT8Gl+/mWAfh4uoei0LOkq46NWfCP/wp6zVL/ijCH/6FUKvH8RJfxXAjeqhB2ik6c8CwW9lleUZPY3P1VHm/5Bx9Q4xEOCRFj6evKi9Vtd8qUM/W5oulU//ADpT9+11Jk9I7sfd6f8Y7O/10er7fYvXb5tVy38jou/e1SWZwKkeucqV9TZlLPZVrVKHToWB+4m81js9CH+Ug/1IqvjlLx9VFK3thD4bObqF6kutFnUhnE51nlmXSvTuXR4huZmXIVKQHJPP/jjbySfISfK9ZynCZ0bjcat5tYaw8Z0uCoyMAYY0cX2FoU/WUIv/GZ82HWMhVaIjUDg7DVGais7q38rAfd05roKApgUdyaApW7zrWL4dEcFe9962YVADP+VQxBRnQ+Qk2nwSLuLxeI2+4bpawE95bspX6Vh0LgcmErUII5YQ0pXBxi/WIlN1vcL98e8bakeWS7LaxO9rzfx1uvNXtxMTULFsjPI+65gLuFB4GTlH2lsH0szzhGeL2iCgSMGY3VDAHNBpJ+r8BWUMGSKUv4bepvRPRVk56IakUl6Bs6gRBdOP1iVbJnYqkvmfmeDbsHgvt9phXehegMMiW0+BDWWrUeaOJsVAVopNguCKUHcPsbmD7NjUtXwfqI77D5qe/bcPNFbgUOp0u60rT/6EXG5e4hsV+sHKCKrvK5aYB+Jj1PX/wXNtX/YfiPK3ijo5WwpbT0bPGJ+Nr7M/FvWVnrTUvA4XBI5wbvYy4Ek8kkXR3O/PiPdmjwwtvhFQhKaLXO+h+CUNoKvqWgFHgLQS8EN9fbNRIFb1pIWktx+mvmr+cVyUatURa/1uNq4T0Q0mq8viuqnuSf5slxvUjwCVmkrJiEOO5CENyy4289Lz9f10vPCx074RYm7KIpVq3Gglt8f5PqZtEBEZ3Hjn6KkrHyi6OyWZbWPwr/BC3WngXsi1vF9+nfUVha2vI6hchKYHq76ZwotuKoU3QSbwHtRY+EYGlZ9c6VqsP93fYcssr+iy4kOdvgwNwLF2ZemyrvuFvcnMdMoTpTKeQdCx6WBWrho49y0X2LGHpMdchqJvYjzG4jcP4N0FgGIvZ04pvsn/wS18RE8XDPDiR3HIDfMPV7BeUEnSo0G3ft/FNP21vIChqDsHj7ePTHhJvDifWP5ctxX8qvBdd3SrspLcdSeC03N9Rz+sAePvzgK3ILSwn1M7LyvmE8c0mns5wTxHRAxJiK6YCp/dnj338JweMVVnZNla0BLP/N2PTDl3xw3eVU5J1NUxCFvfDAFU4Wn4z5hMvSLmvhPO8u2a2CTv4Vj9cTCS5oCpWffiY/D77mfrTBCdSvWkXDVuG2IQoSDS5rA6HXXUnkY4/Kx1V8+y1up4MYvxhi/JU37pnwPhcxavae938Vnxz8RHbxxb1CXOc+Oh8e6/eY5P23mzkAVzc/fHuFUBh6lPeifmBx7hJCZ3aUKW7C2kzZm7lxW7U07GqgetFOZU+lAW2AQYqbKn/P5ImC2Yyo6cPvf/zCmoXvsDxJWbBdWtLIK+UVrM0rpJvVRp8GdR07So4QMO6/wT9bhPW0Gd7ypdAMCFRsrsB99RKljxCaCsGd3ewJgxDvnVdzIDqtIiDIez8PTkBz9c+Y23t4vB0fpSG9kPxbb2vhqQtIC0ZRR2cfkIEVXthycs6iM1zU5iJ57AXERvOO7nfIz39yeNwSRBHu8eit+OILeQ/17dMH3/7/OEzHp0MqBAegczhpX1aH3uVGHxFBzO0zWTwon8ogG85GCwteegpneZ10yjALT15xfKx2zE4tnbXqvhnZpg1BbRPRiuJ+//ncbWEXJ4IhZFrfhaKsq7PBWoetTnV4B/o04IxQr8e++0dCpqcSNTOFKVseYkteIdfXL6SN5k5Cr/fjTrONg/XNrDlWSs1WFdbUtSqbCf0SMHq8fkWX91xM7/Wvxaf/qfiPK3hTUlJk0bpunScIQYyv6uokN3fgQHUzEP/W1NSwb5+HlC849OvX43K5JNf3b/wZh4YzTMaFW4PXOeDP8Hf/m7q7IjFI+NSeiYzqDKnCFot4h5AOskuQFNhagIsF77buralHosMrf1eJKsBORakxuIDoBgsRUtRTqkvc6UAVGpf7LDW5F6IQy7rtZvwzCrDp4JdeFhZbCtgx/mmO+t5NTN6NBBJMQWMBb+1VCuRpqdOI9Rjru5xuQqJ96X95ElOWTOHl/CfZk7icTdELuXj5JBbvazVPF4XbxKRLKbEfxBCqul87i3dSbTkj3tJhkR/D0yKkSt/hcvPSH2dbc/0liGpccAKX3gEf94MTf1y4w3uGHZ1YZHQTHsfl0GDQlFP73BUYMufSpn8VcZPKSb1Ow43BzcwrKiWhoRKn8Oy87CtJlfn2+A8c8jHRJ36IfA9DZ85Uv1SrlTw+gaY9e/+UkE0szgsnL2TNZWv4cvyXLYu1QI/IHrLjJ9A7qrfsSInz58OvH+OT2TNZ/NrzsGspY8vX89LULi2c3TPhpTOY2rZFa/7nFmLnQaeHnmpEy341mv3vRG1ZKftX/IbDZuX41rMFhN4x/LWdrm0pLoWSX/AzxYbM+/MLwpsSuP5lKNhH/Wo1vg6cMhtnQ0f8RjyJPqYHJc8/T/M2RY9w1RUSdPFFhFx1FdqQEHQlFfTPcDPE2JGKOXNkcMCZEJsS70ZvW6EqCJr27aNm4cI/xd8W1BRBzdBr9CybuoxvJ3zLL5f80sKHD2wfRcKMntQtfoXArz9g3CGnLK6zzYVE3d2T6Pt7EzzeTP3KB7Dn7UCjEUWvtcWayn+A6v4lZYZg8MSi5Gef5vG67+TnF+eF8kxDJZc0NNGwOoT+gT3o2qQmY87yYwSMvkDc8H8RwqVAFxoqO+ySRy3uxWkeakDW2taQiH+GNiMwj1Fe4A2bNlP44IM0bNpE/i23tnRwU4JSJF2gx3GL6nJ6YMvJlQI+kXAoj4En4tsL0YQQ1KEDznocotMswldKjkj6S82vSkgYfvc/7u5SkwdzRhMSoSZfieXqnuc/Yjir89ZgMblomt6euA6dsDU3sei152iorlI2iRGKfxtvN7cU4ca4APpLD2I3saegquHsjZXWrCf6gd5E3dtLhkOch6ID0l3QUqeaKmEBdroEq46zCPHw7ajFULKAmHpV4DtEA8RhwXfLQ4zprzZ5X/++HwrVce1qKZMba5H8JmDJaL2ne+HyUCz+xn9IwSv8cg8ePCg/vEI18XleXp68UO677z7p4rBs2TKOHDnCrFmzpGfv1KlT5eM7duzIhAkTuPnmm9m9ezfbtm3jrrvu4qqrrpKP+4+HtQE2v6nia/8MpUEETCR6NgoXGH/9d+No5T8WrIkRm4AoSr3OCd4FTuDGLjeex9Gc0nYKKaVqAa1NCuWDUR+08H6Fetd/yGBcAX6ENMKIsnC5EJ8JV3MzeTfciGPbLqx6+PnaeIZ0nyx/9mtlDptOj8Lg9uW2Lqq7IcQeYoQ8ue1kYjxJPXqTjgm3dCWn+TTlzeWyMB8TM44oWyIOrY3llUsI0KtNxfCE4ZRVG/GJXoxWr0Z0gqMqeJhX/nYlV/x2BYN/Giy9KEVh8NTFnSTvS3B6jxX9m0LL+hJo9vhJivPi56uhyFMQ1RV7NkIaSG6NBRYInX0XjhQlSowdUENkt3oC4i0EBtrRWwsJzFhJtNPJaYOerwbMgKjOcpwuFkxRqNzcTY3Y/YYNI/Lhh4h98w0pctP6+UnrJMuJs3l3/wii0x/ldzav/1yIRbCXWRVYe4p2yyLf5heGEy1Jzfl01bZ6eJ6JFsHaX+HvnglvwXtqAzS1enb+d2Df8iUtdIacw2ef9156z5luAuIYeCkg/5TH2/cmSJsobdXcP8/AtlvFI2v8vUJgLT79bkXvF4XrkJo+aH0aOe5TxerijazvowQ9l29xMf313ZS//Q6FDzxwXiF7pj2Z4DmKTmPxk09Jess/g9Ph4JevXiOqyiQ792LTKzY058bqNu3aRbPHiWXyYcHfdbd0J8V1XfjgQ2BpRB9UiNvRIItegco2Fl6zfiQ5mQJ2jeqGJ1qjsekhpl7Hk9MekI1Ue6MOh187hrV5AB+3kUp9DWF3zEIf+t8jSjw3/dBvgCpohbBL4txAH8H9/Rcwd1fnRNPu3fI6ExBTjPybb5F6BsnjjerDgBPq/dIFKS9aMQn7/tj3spsuNlFtgs8+3kadUQlJNRrygz1d/fydVHz+BYjubr9++PU/Z4Im7i+758Da5+Dz4WhKDxMQp0b9giYi4DdiRMuUa3z7SUx56ClCYuKoryhnyRsv4HI5afRMZCMdGvwHKdqAn/YPum69kTvSdjIzIoNDq1RC3pkQIrYznRTOQtEBbA16NG6wGd24fJ3kpLpB68ZSoafpq8dwbntXPvSFiAjst21TIUuF+7jFsFJ67WpPtHbOI6qKJA/a6/UrUtq89pQC4voo++yfe5v/J+P/ZMG7d+9eevbsKT8EHnjgAfm5CJsQeOSRR7j77rulr27fvn1lgSxsyHzOUHzOnTuXDh06MHr0aCZNmiStyb744gv+E1BZuYXCol9wuf4BZ1CoTte/BPOuao2EFAvx9g+hJld9fW7a1UXvwNTPoEtrStj/FP6ZYG1jnhpzi8XNC2/HVvhi3trtVtbnKb7rgJgBPDfwOZ5ofyfhnjrw+qnPy+Io3j++5W8JVXBRP9UlHnvy/A5fycsv03zoEBY/Ay/M1BE7fnJLyte24q1yUWzTM5IZPS+nXbDqjIuuoiicU3tH0Wt8Epfc1Y3QWD/ZofaKeN4d9zYrr1/G5HoVP9rgaJAUDMGznHfiB7TGs5XkP5/4Wbo4iC6V6FwLvqr4SAn3Y0Ab1THYm1v1X4uTDkr00BZEbNCas9X6Md3OD1kQi9xlr+I2KGrDYb8AXgsN5uCYJxT/cNRT5PS+hmtjovmmcAOnak7xzj7F072yw5Ut3XmxwIbddBNBF12kvEk9DitNu1oV//9VNNXVYtmijn9VtJuJj7/M1zFXkh6gCtnN8769YGexRbD2V/m7Z4rXBJVDHNMLOB/8u2iur+PI+laLprLsU/I1CohpgNeq79yN458qeEUld+kcaUuoaSglsdcRYiZ2wtWoReOjx9w9Qqrg9R1uocml0vgKAzNlOuHDmx/mx44V2HUQXwm6SnUeN+/dR+N29Teb9u+XwrZRjy7h/sVOdhZso/Knebg84UC7vv2SHx+/n/rKC1MdVi//noiDjQw6GtayafLCmpUlqRbivaz47POW74eUNNK+QFnmiZ9Vff8Dtuxs9JGRxLzyHCFXqvPA6bYzO+9efitfwdLQDZw2FfBezFz5s861MXTOcfFyyj34F6pzs7k5nLCbZhNfqq7BPX7pVE/+F13WfwJB2/ryyJeszfV0bM+B70BPwbvTQ/kR16ves/YJete5mosLwNylS2tSpkZD/McfSftAcTxE0SuCHga72tA5T10P+isVHagpO4vFmYtlAXh9J3XfOhcjElS09jad6lTaj2ymxhMJHHF3a+JgS0f3syHKum/ru3LTXUkER7SRaI1qs+HW6yhoH0JefZ5sFAyPH445IJDpjz+PydeP0tNZZB/YS6lW/b2A5kaCJ7cl7ukeaI++x0GTEZPOQbuAKrod+vgsge1ZOPCjmmic4SzRnLevRbCWE67hmj7jWDxuNge7qedWvmATuoYKinQ6SlNHYhZ2nMJ3WzyP7a9zf289XWtbtUAahwPr6dMYYvyUH3Czg6Z9x+RmT8CWW4ehVlHz/sZ/SME7YsQIJcQ45+Pbb79tWRxfeOEF6bggwibWrl1LWtrZSlPhyDBv3jzq6+ulAO3rr7/G37/VIuT/IkSBm3HyeQ4eup4TJ55g565JVFZuOv+BmZ5Fsvw4bHtfJeS83x1WPyU8dtTi7H9OtywkCXrM+Odxwv8NEO+zKEK7nXbRue5sDrXonO4tVYuMjyPtvIK30lIp7ZbEh+D1vjviXS5NuxRXhnKXKAqB1RWqc9Q1QhXTwnZHYEtn9bpSDpS2xm6KjvBvv1MrRnEaDZ9c7kdmnIaBMQPlqDzAEECTpoHSgBx6jE2QGfYvD3lZ3vDv7XWv/P86g5aB09oSm6oKxZNVijLSPqQ9lfOOU/nFES5rM502FT0kF1HwToXQZ0+NuukNDbn1rA62gPaMy96rlO6dpH7//tzzR2R/Ct7OfmRHjrpU18ae5Tl3Tq0/j797FoLi0dy5i6KbVnF1ZAi/hISS1v9uSBsvXToSL/6Q0JA2kkowdelU+foEJUVsTi6EeosdbR9FS6hfu1Z24U5PmXqeGf1fxcbvvySk2LNQ+TaxrlqH3emmsfNI9CYTJVknydp9tphLCda8Be9/QUziFXr+BW/bs56H3U7Ro49R+uabLd87sPI3HFYrkcltiUhUjhJ5R1R3yGv1lWSOI4CzjfTF+StwvPJ4i53fBWEKgKvnYzN3xuXU0+yjYmcDhscRenk7AoJFzLhDRuEKlAUcldddr8hejO1xGX5XqE2h35AhBF+uNsrl738gA19yZ14thW3avCIGnnAzfl2N5PwKiHcovbac0tOZHF7nsds6B0e3qYjzoAYDIa7W+7r11CmZ7Jc/ezY5V11FkygK9Xr5HATGHVKe3RmFh6j6Rjk6RD70IPqQEJzdglnq/zNPJn1Mra5BunxET+nMnW1eoSRabSTM+lBe2ppEnwnXKaGYoE7c+gohV1yBPVM9Zq9/uqQg/bv4I/sP3t//Pg9uelA6zLQ4ZDSWSEeL4x380Bj9sZfrcNQ3gNEXUjw839ge6ut/Aa2vLz4dlP93yNVXS/pF4hefS2qACIrJvfpqOj30lWhkkhEHzzuXysfWZB3HbrMyfU8Kh178lKbampbn5/LQj4bGDZWThLUu1WWo+OOQ7O5qOnfClhB/9qTxpxnQVKEsMPvdinvSW3yf3YFtlSnUxKvf54i28EO2ErsNjR/aQnMLjoqm62hlTbbj158p8dh96UQX1eVCc3guXxtsXBsbzX2dRtLs1BOmradmjerInoWafFh2t+JBb1A2hsJlxHIgvUWnkB+hoW1wW8mF/3iIAXRumiuNNJaY+Do4kKGJo1snOm1GyOnInfbvuDZIFbNeWI6fkAluxjh/nDW55M26gsL77pc/q9t0nPej/me4/v8X8H+y4P0bfx3C8/HAwRsoKFA8Qb0+mObmHA4eupHq6jO6ZKKT601LE9j0Osy7QhLzpQL/kvfh5nX/4zzdfwSxGMWcquWpX1zo73gG+xk2cmtPb8GtseKyB1JeEXlewSuCG0T3RkAkcPkb/c8aSWdHa6QnpzCQb+HxVhyW3qSrAnMoDwRdk1WmsNU02WjctZuSZ59Vf+SGy9kZ0yCFGWJELIrbjm4lGKtsk0W0Z0QlOIkfjvpQ3hgvhJPVquDtZEyj+XAF9vx6ou1OhmZfjq89QBbrwkPYiRVnc4K8uX4w8gNZRNze/XZ+ufgX1l2xTtIBzix4hWm5wL68/1rB6wpty3ZPoJCmYI8SsGV6BHOigL2ASl68JndQPLutJS2iwTO512Lxe7Tfo7L7LY6fwH297jsvUMTrmHDxh1t5KFO9vub9+6n74w8Z6yu4hi6PLdKFIJLQTk+dRvHzSlh4JnIO7ef4lg34WQ1EmSLkSPanQ6rbevmQjvS5SNGhts3/8SzHAyHMEpZMGrMZn46iS/tvwrtZ8Ir/zsCFusqiuM8cOYqyt1U3vOqHH6ldupSqr76m6egRtv78PTt+/Un+rM8l00jq3ussWoOXzpC8K5/Sl18563dH+EbIYBWxwXp/73uSB/wPERRPSUYH8rLuxOmORksl/mmNaHK3EGR5m0j/pzAGVWLQZBCpyZQR3N9N/I7nBj1Hm6dfJGXRQhI+/4yIe++Vx9By+DCVn6uua+AllxDm8Xa9dLsbTVUN+uhoGrt3xq5XI+aM7VvOOz6N9bVwxiSjODOjhWdfeN99uIXwUVz3h9QxCJoyuaWzKIprv2Y3Wd98JM8XYYOlGTOU79K/Y9KiSXyWsJnD5gxuyknijWFvUNaseMftYtJwO5TXcNDUmWiahU2fxxIsZTj28iYc5c24NG4O+mWwq/jPOYycC3EvEp7J8vW4XTy86WEpgp2+bLoMDblj3R3cuv9RCiddi7n3zdT+5hGU9fZ0W7uqlLQ/g6innyLs9tuIfOD+Fn5w4rffSPqCNTMLd1Mz+h5dWX5dBzL9Vefdt6qJoYdCCKhw0Vhdxb7lqhDe8tN3fHDdZWTt2Smva3GPPGoyYmk0UOORhWy31DD3yQfUFEK8p4tvVVaHIob7umUw6Q3qkifjsgg7QzfpVw7FL8ZCcsca1mUpt4dzY9m7j50k1yqxOao3G3FqRYpaE9ZjR2Xc8Q6HL5dvdpJVU8pvjmi5mVp3+CPyq86xPBS2bh5nH9lpPv4bRc8/Scl6f5rK1dQvPVEj72HdwrsRGt+2pctbfDyAxf7+cqonuu5l77xD8bEUyo8G4kr/neZDB8/qzFs9NC1jYgCO4kPy74rJR9OhbL6sfJ/VAX9RJ/AfhNZcur/xH42a2n3U1OxCqzXTtcuHBAf34djxRygvX01e3hxCQjy8qdMbceKivG0KIbokTCc9QpfuM1WxK4Im/iREJ+6fGd6fi1prLVk1WS0F44UguruX7FY3Eld9PcXPPEPC55/Lrv5ij2LcUd+FI4WtXNW4gNaC10tnGJXYyjW2HFcFb1ObaJod5dJA3vv3RYc3ozKDJqeFnd19uGSLRXIId374E/3KjqN1uaSieP34RDioBFIGnQGbxUFIVltI3kJeaCtH659BLNzegje1QYRZqI6Q+2gFwfogLk6/k8aJx6ikgm2nirGUTKFrXAgRAdGyiDgT4sZ7ovqE3CBk12bTIzFe7lHyq5opr7deUHz1ZygN1bpwip1GmjFhdllw7fkKrXAYELy0c7iBc4/PlVZgAsKRwlvAnkk3OZOrKT7EMRCLuuD6XQjCD1fYrOVpQnGHhKKprsKnSxfsBQVYjx2n/J13ifK4AJx7bI+/+za6EyewZJwg8t57ZbfK+7NNPyqz+65jL+JowAlKreuocJzA35TCxd1i0XWaxoGVv1NZkEfm7u2kDRgii2tvwRl2442yK/ZvQ3rbaqD8BK7aYrRBMS0F9pF1qxh7y1207d0qqBXdTxFnXPbll+wtzsFnzz7E/xCl35M/P0g5TfQgiKSKOmIbrJi79WTvb4vIPXxAvt796WojlFrkpj5/PdHPP3eWUOjunnezMX8j6ws3ELAwk7sf+YiolPM3aSLO1VqowdxTOQ6EGD5Fe2oMVCn+v7F7X45EZjN6xXP42nV06XTdWXxTL+9ZHx5O6DXXUDlnjuy4xrz4IsHT1CYj+8QuAjepoiDg2plkZWdCprpmq4sLKc/NJjK5lSu6YeMCqbr3ojjzBG1796PkxZdkoaaLCCf+vfeo+ORTbHl5hN9+O4a4OOWwkZHBs/MgomEnFgN8d1006xaNk8l8Au3MiVz9ZTbty/K4pscMcpuV2GhAeTDO6gL0Ee3x6TaodeoR3VXGCFd9eUgdryQjjbpm6YIh9AEiVOZCdnFiGnXu5EZAFLfCK1oIxsSHuF8KH2UBoQsQ140QHB4NraR9lfA99nghd5gEjxeCUXUj/wx8e/aUH2dCdH0Tv/masrfewm/wEEKvv44P3Ha+OPQ5FvMcfJqddM02Uu+pyQ6u+oPELt3Zs2yhLGKXf/Q2V7/yjoxiF1qKU8cD5HvVFKyj2t8MDfWs++5zLukfAid+VymeV82TGyuB3Cx1L60JsHHj5W8QVDkMQ10V/SwWdgeGye7xmRBd3pQevSWlQUQM50ebSC5qJnv2NZg613DbviACLG4Cm2rZe+VwKrJW8GlEAGlLL2dh6GBl39ZuDM7dXyO2WMWWQGJ86nAvvo26NUoE507S88UliWwNyOPyoDbyOhK6kK/6n+bDA04slQbaBqURrQ/l5G0X4bZ4rcb8sVTpcVusaP39JV2racdOGnYeJLzOJgtep5dK5naz9oPnmTfsKPzX0q//T+PvDu/fkCgtVUKMqMhJhIePRK8PoF3bR+T3KirX09SkxsHurLWkdwwgPa6enXF5lHcdAGNfhKmf/KVi9/fDRXR9bjUPLTgkfQbPhCi4LhSEcO+Ge6XQasLCCXx26DPJIRQWZGciO30bfU6qjo7GYKBx8xZqFy2WRdKBym0tBe+hgpqWzo+3WysKaiF4Ey4HooPlhbfDe82Up3lz+Juy4BZ+neJxIpTgqW3KpSHrkm4EXq46JANK0mWxu69bMHOujWBNwbqzxsHHthYRU56Gxq0lz5Ijlcv/CkWNRXKsL4rt4PLWXbyr3k6naF9Cm2OYobuN29q/SlPurUQZk/AvaJDJT+eiU3jreF10eTcVriQ2UXTynez/d7q8ng5vQbMPbjTkocSd7o2qoCV1rOBntDx8adbSlmJXdJtFZ9orFrxQweuFWCz+UbErIN5X+Xc1WjLufY7Yt94i+ZefiXlF8eKqvv22hbvosNslh3Xb/LksefNFan5X14DgF5Ytbx0LioJJWHbpDAaW0IWtR5Q4UGfOZXKPWOl96ePnT8+JSoi4Y+HPsssrgjDs+fnSEknEv/6X4BsKUYpLu+6Zqyk4dpQT2zaxc+HPNNZU8/u7r1NwXHHXBaWm9g/1/LMjgjief5rDEUG4Y2M4kGJkbWoxh1Jr8bcX06WwgrqlS6VqXW8w0lBVyalPPya98VRLweusqMCWfbZAVbg1TEhU3bI9bStY/NKjrBvfl9Kcs50+6tbswqerctAI6FiNWbcTji5u8Vd1dJnOW7m/Y9VAgMtJQOM/thcLv/MOIh58gOQff2gpdgVSXnyVvHAoCYbL3J9xtEhtCk12NaLO2HE2DeTYDkUlcAaq86go47j0eK1dvFh2++Leehvf3r1J/OpL2q1ZjTFebAY1qpNpNJJcBn5NTnYPCOEP+z5Z7IoNpOD7L5i+RFKp9BY71qNH5T1FTCjSVmfgqlfFpavaCutekJ+7UydSNT9DJs1p/Q3EXdlD/i5RlIpr5EwIO8Xb197O0J+Hym7yuRxdYRP3+aHPW8S3gpIl/LiFl7T4etOVm7ip3Q3y5yd9lNbCWaeXo3d1wPz/WyZzYpOS+PXX8pzX6HT46H24p/e9BCQpXYev1c6Qq2YRFp8onRIWv/68LNh0ej12SzPL3nqZ9qfM3HaiB5pTiu6iT7NzpE2tnCpU7l6Ba6Uq4uXak9DqqnLsuOqMW8IMhPtGYGivPHmHNFmYlDLpPNcegR7jldeu+N0fTbZJ6ho1dqzbRLHreUy2m2OuPOaEqWv/pNZB5tGf4eeZNM25BJ21mnq7kV9yulLh2wFXQyPUKGqb66KebAlS0yuvRkMkcZaHaGnwAb1Tw0Q6Yzl+XBa72sBAGSEt0FCkXr85JRKTZ0JkO51F+ddH0PppcXrDnMTkolhNYm+uabXO/Btn4++C92/gcjkoK1OhCVFRrTYxvr4phIepTmd+wXfypnSqaTXl4ar753DWcTgki5x40z+8UW4/VcGnG0+dF1+75IC6+f+6r4A75u7H6nC2FLuj397I5Z9tP2sUKRLEMor3kGazSY/djw9+zK1rbmXMr2Nk/KsXQUu3ypM6vU0im4ZeKr9X+sor7N/7BzZ3Ay6HH86mZCoabBTWqK2wn8GPYJPq5gmIgtbrtCBsduy5Ks43sGsPycsTC4mwzhE3SIFTtao4KHFWs/6im3hy4M0cimjHF0PjeH1SPUsLV7ZwIlOdXfjj40NsX5iFj8OPjmaPz27OhbmGZyKjSo1e2wa1xZGnRoReP8Y4i50svZOntp7k9RXqcY/ofKn87hglb+2lYUcRbk/6k4AQ3nnx4YEPZReozncRPnE/sSfnwm4D/xB2ixKPiOdYqf5GkV75dOpkzLQgHSthkoCIV31muxKQzuo0iy1XbZFemAJiEyH4zf8uDnsKXoHdxihpcyUW3YBRowi+SnFIS195FZfDwapP32P15x+wc+FPFO7cTmhjq4l7+e+/tXwuCkuB6M49WZFVi7NZ8V1N/vncPUq9ToFekyZjNJtlcZy5ZQMVn6rRcsS99/zXurse2OPUlCWSQukhuupz5RbiHxqGw25jyRsvUpGfKyNVhXLeERvD6Rh1Hjt1WhquncEvo1s3CwdS1YLcsHkzmrp6Yj1d0FVrf6LJR4PJpaVDkkf8d0bcrxeXBU1A44KiCAu52lq01W72vvF4y8/F+dawx4pGbIQ1FQROEx1oDZSlKwpUYDwbNM0UNJdxyuQ5PkXnp9h5IWJkw2++GXOPs8+PyMhkit69n7fvSsDQCNpGEQsL7YuVR+mJLRta7iVNjfWQregM7aeoc7L41EnqPT6n5m7dzncB8MB/+HBSN21k45RkDiVr2DtM6RQEbWjR5EWS76/XGyjrqOhS48oi+S10KFsbI3Bv2YqrQRU99qN7oa5Q8k6bA6/Fki6UeRrCru2EIcSHGR1mtIhMvQE44tq/be1t0o3Ca5UoaBRnYs6ROXJTLO5dV7a/kuSgZJZPW866y9fJEBURxZyc4dECBKjrVeMXRcOOMyhq/0OQ7gEWRemID42g35TL6DtZ3Z+dNhvRdjfTug8kxC+AqqICts79jtSNGXLz6RdtoUubUu6aNIHGNg1cEi8mZzbsgufa/2wef/FptfEOjPe4KaUqy7XLNIE82e8JRck7J644pXtvwhOSaQp0khei4dlrdeR6GG97UjW4dFqiasCam4vjjIrpW30E4p14mNNcHhvNs0GxFAfZeSujOz9UjJGPMfg60EdEYXfY5MbD21yJ9I1kUNxgTkerdbNPTSiWI2qNEJstESEdcu21LX/L7JOPISZBRY3bG7GdLqDs/eXgsrc0ErrkuBlR3cwNteo4/43z8XfB+zcklcFur8RgCCUk5Oyxc0KC4nYVFf3K/l3TyI1WC0fH1BdJSFDdglOn3qK2To3kzsTx4jqu/2YPr688wfRPt5NXqbhxoqO787RajLQaWH2slBd+U52h1cdKqLM4OFnawImSVrL+Tyd+4u3SChYWlvB5u2sYlTBKKvTFgvDmnjdlpK+1qpIuuxRn7seEgbwe0Iv08DZyrOp+/DVMNjeO+s4E+KhF/1B+605YiL28GO0RD4jOR9EjavwtVP9CmOLlMN7S7ZbzXm92XTbvbl7F/qj2HHt6FmuHlOJGh6NBdTZC9YkcmFMtI4HF+tumRwSXd5/WYvJ/ZoEvxEBX/X4Vlyy+hGlLp7Hg5IIWOkOXwE7YPVGsIZelofUzoLM4qfZzcaTZwu6cKnqho2+N2kQIJW/N0lPU/tHaDRCitzMhFkOdRo8h8Ci/lT7PB/s/kAuq6FD9S8gugxu3KZDMIlVwxg5Ui5n8+4L+IQIUPBA8aPG+iWhnEbUquNJxfmohEIv1hca4fxaHC1qf75HCs5975H33oRX8wpMnOfric7KQFWPzbmMm0D+hnSjFcHt9co8ek11a8XFim+LN5gR3kO/boMROUnAoeNLVDlU4NB04QPE1sxgQpkarpz/7FFddHcbkZIKmqff4v4pynaCxQIJfLS6nQwrOErt044Z3PiW2fSesTY0se+dVyhcpv9JTndpJSZjOsxldkb2e7AiLLFIFdnfQYenTCZxOyfGN23dYbmqPpKgFtHN0DwL6KppE0x4lfqpbvZqip54i9/obaP5uEcklqlDNim/kRGwYMZszKcpV13LDVpEN7Y/b1ohvTy2awKizPV67XsbPGfPlp47oLv+w4K0rL2PfH0upq7jwRqympBjrl1sYvdzMtAwlpMqJbiImLlZOWeoqKyjJUpvAtet/RufS0ODnZOKEWZj8/ORxLNysqFm+nmCGfwRxDwi78QZenqFjvyavZYPspXtI+ku0uAbcTHUWkbxvLgGlewhMtODTWb1/jnqjckO47Csa9xcToJtPUD8rpqTAFm9acX4JVwFR4ArHDDHdEl1fEYzy9fiv5VRE+CB77wmCC//FYeUi9HCfh2VXVSDYJ1he2wIum5OkTGV1VqItp1ZXJm3U6tdduOD9M17GfxbHNq+nvFnds5JjErBZmkno3I1ErYnBJwvodew0TV9/y8ADGQzQ+THQFER8jXp8+JR+6HDTZ9MHPO13gjBTM40OA2+4Qzwth1bYitSEIDm1ayv3XWdCX1eEQYiq30rF/ss1PLPtmZbjJe4B0295iug2nkmfn4YnZul4cpaOty7VYuihflf3027cTiOhjYqqsCrEh6d82rHZ18wJk5E1US6WDyqhNPwEBfXKPabW18SKJelcviGObtYkmjZukuuRgLDDy/Zou8Nya5Uvstx0qb8X9fBDmLurAAz/oCLs6xegDVD/wVVXgD1PXWfaqM4Uh2rRu+DqozZqKs7wwP8bZ+HvgvdvtNAZIiMnoD0nEjckZBD+fu1xuZqpblI70JT6GGITZpKW+hTRUcJuxsWxY4/gdLa6EzTZHNw1b78UEXmL30s+2srp8gY5dm6wOggyG/jsGjW+XrS/UH5vdXqrAGZrprp51VhqOH5yGYM83KZBJVm8P+p9aRbfMbSjHPOLxKSDCz/HZIfcCC0Hg3vRJiqQl/tcQ5UpgKDCWl740clHPx3jy9WvcsXJdRzL9KirzqA1nMnfFck+QvQkPF1jXnv1rOMizPi9HDqZwtVW2e40B/xGfEQzu+u/kl8n6sajKb2FhqyHyTt2HYVOJ8FRvlz9/AAm3taVCW0myJ2/4NEKizAvvkn/Rn4tRv2Ch/fKrlda+MW9HF0kGVMXbMIQbkbfXXXxxmsMJNq13N4rkZd91Ogtx+rklEfA07i3VMa4ekfSZ/Ixb+16K/F+SbgFX06XIbtFIgBDiF3+aYysgIdHZgtMwu5wYDabSR12GXbUuVQf2hXMrR30TQWqYzq53eSWQsHrifzP6Ar/CuKcO1lafxaf13v+yb8RHEz47SpUxLlwCTqni+HX3MjYm+8iokx1/UJm34RDq8Vgs1GxdQuFJ45RX1mO0ezL/FIlYpw1IIXukcqHVHiKNhzYT/7sm6WYJGDDZoxuCMhQXf/gyy6VHeb/DuRUmRCWm6HGZqZM6EBa/8FcdM8j8rlNeehJ/MPCqS4qYGdeFiejQkivLeBoSi3rpzlZPKyI3+PVAtklx5+2xeDQutk+weNQ8vnnhGTn06XJSVacKjQSLWHS91Qe2z17ZLhA4T33UvvrIuleUJp+hHYF6phkxzZQb9aTERPBrveekiKs2jVqbG45Oh+/vmrhpoMaHwsUJA+UXFUx8k9sr64f4d0s7NLSN63j0JrlrP3yY7669xY2fj+HeU89SPk5aXCCzrHwlWfkv0Llb69Um5zsqEa+mGIiqlHdk/Z88Yn899haxU02t4/FqDcR005t/Ioy1LHxH6QCNv4ZxDg6xBSCzak6rR1CVZEtICY5m6KqiOhWT2S4Cj8QEAVv2E1XoqUOoyYd98AHcfh2xFzwLkGG7/HPf1oJsUTRbfBlaqqibAgBqrgGhb5A3G9E/K7QAYxMVJSrH5fPoSqvlMe3PC69tsXYflIbNcY/FyIBzt9uJt6hiqbTcao5YM2qOC9aun79BrJGjqLkhRf5r8La1MTGH76iyaTuB+7SUn56+mG+ufdmUo5nEWSxSUGisV1b4dFG6P7DhOzeLz10/YYOxfeeH5Wns8OC1mGhVJ/A3Owe5B/Kkdef2BCI4ryhpgp9k0tO3np29nB1pQOF5/Pdn4PLwbzS7SzOWiwnW14qma5Zy0l/dc120wVgN2iko0670DRCh6sGSLcsH6Js1/HkRBVsYzU5WB6tzoHrEyYwOlFt6vd2qqZDjdokF/tF4vb1wdeqp992OwV33EnuDTdKgeQIVypjC9UGpGHdHho2KwGhT1d1rQi7y6QffqDtc1Mwh9vRp3+CNlCtOVrfIpyVarOTE+fLzvbq3Ana6kf5xn/TS/0/AH8XvP9hEDe2opPH5cIhzLaFFVlZuRqnR0WenXojIAqSTp3eJD7uWtoX+TJgTzVt4lr5iGlpT2M0htPUlEV29vstHdzPlr/DJQlv8fKQ1/h+ypf0S3RJXu7HG06xNVN1dwe3C2NspyjahPvRbHcyf0++pEB4sTlTdXTEzeni2jP8YUWKl61RLpSP9FU8Y9EBPbziR/n5rsRIIgJ9+eOeIUwc3oVXB07BqYGUUoivrSGwqpQbjq1gzAu3tOyqvQWv4FglBibKmMyKj9UiGf3sM5LHdyZEYSY6La8OfZWPRn3EXT3vQuPWo/fNoTb8eblARftF8+tVz3HwmXFc1LELbqcfm3zspPWLkkWvgOhuegtsL2dP2Kd5+XnPDnxWGrELzrDwzxVoW6e60SYPneGjCtVVHYSeK5qNTC6yE2Bx0eRyk97s4miFBZdZj9vmbEnmEV0fEdkqkBiQKL1tcxtOodF4OvjBvWQHvaypjFvW3PIPKRcifbD4qLq5V2tV4b1fn8jAd5dSFaS6dhm0dhxEYZ9blyvtp7zpXQKVQrXu2dz8mc5SbZNd8r+/35HTwgE/WlgnC8LIAJPcTAnLsDMLYIGmnt1pMhnxcTgZaNVI3q31dLYKF9BoCL/schrjVHx44YL5HN2k3oeQkAR6Z+wiPtDE6I5RcmQszr/j234n68brWro2QuHft8lJaJNFimACJyte75lotDdKP+G/ivxTuRyuUc+tXe4cLhkUjG+Q2kj4BgZx8b2PotO4CUls4miqDwuHF7C3Yw3Zlnxq/e0yZUrv0DAr5SpmDLuLG8qm0O30YNz+anKh8fUl5Nk7KQ2zonWBYckxdh7Zg9tgkE4Txc+9gt/Yl/Gf8ikBUz4gJXUmyVWhBDaC1egmP7KJotAAXEerKPpqLzjc2EvTcdUek51uic7TlIAxeSjfV6mIb+GLGtxGFXDuwv38+Ph9rPzkXdZ++QmH1qyQ3WzRiRWq/l+ee5T8dHXNiiJ30avPUVNaTFBkFJc9+RJdRo4lZdBAKuJgg+s44UMU/SEr9xSHNq3EUNIk0xDHHFDnWWya4kVW4hQcrpZAhX8G4RTiLUi9gktx3oopkxCN1Qe5Ce2oNg0Vx9SGwC/Ghk+ojVDDG4Qa38d9ehPWjavw06rrSlORDrmtvsYz2s+Q9B5hJSZik4UATbi3eLu1gkYhsMq6katWz5DiU3G/eXKAKsYuBMtJde13NKkiPztBFUYaUzRFX33OmrVfUr7qD4qfe46CO+7AUVIiU+uE+FJ0h8u/OkLxa7up+OEYDTuL/3QHOPfIASz1dWhi1Lmbl58jxZ0Oh4PT4UFyApK6YT1tli0j9vXXJHVEfC/igQeIffUVNbK//FsY+iBc8gH2S3+i3uEjpwvv7XybYb8MY+KiiazcpazH6v2cdIo9w4PdG6yhM1JtDubzIE/qp2dtEXBUWDhqVveg25MubgkgEVOokjR1TnTOd/LRuCvod7COtnXq/i3262KCdzTvcmKttxCZo7QRIZ7udMKkiykboN4zQ7mi0AmnERGQkjfzGnwL1N+0V+XiqlPNHstJY0uYhCh6jZMfwa33xeDOwjdBiQob1y/CUaHcGla1K2F3Wmspp484373mbyj87dLwfxRLspbw+6nfJR9MFFSicBUjz+UfvsXp/Wo8afAx03tGAg5jHSZTtHRmuBACAjrT3lQDWe+CCAg4IzzCYAihQ/uXOHzkNvLyv8IUOIVXl+/j0sRWw3Z7cxF39pzHnryZLDtUSHKYumgHtwuXz+vS3vG8uSpDfogiJdBHL2kNu7OraLBa+PXYPL6v9/CSRAfQ3ggZK+RIVERRjk0ay5qc1ZLDJLDX92KuH5SMSa/jwbFpjDil4bUoLUn5waR2vYOBoTpyPvqUxPoyih57nJQliyWNYeHJhVzf+XpJZSh5+hk56g2YOIGgM4oWi93JnM2nqWiw8sRFHVuiMSPNUbhrh0LwBjRo6RPdmwf7PNgikrhveDtWHComz+CiNOzsjp/oDq/IXsGKnBU83PdhNuVvkl3rToY0prWdJt0JRJxwk0NRQkLKfXHRiDE5iJJaCz9mljIEPzqho4+PHv/iBnknPtjkxCU4Iy43eU0OkjXQdKQCc5fwFlpDcWMxb+59E4fbIe3AKqoDKHXtpLjSzMprfuGFnS+wPHs58498y4TsA8q2KLwdVquVgoIC6WE9oHibdABIL7XidGs4ap6Pxvc035hvo3ttEPsq4+jS3Cw7v+K1CYguleBOCwjahDfkoNHRKD8Xm45/BlHoCv63+PhxZy6vTu/Wwt/tnhAsu73bsiolraFLnFpw8o8dYdHbLxEcF0bf7BICM09T/NhjNHqibf0GDsAQFYnv4MHw8wKatm0jvSxXdt5SN22hd1M9OVFudNox0iv5g7j78X3ndUwWqE6LouPM2yl57jmCslQXsjo0SLoLiAK/zlpH5/DO0u7rwY0PyrQ8UcCIVLw/A5EMVnIqkwJbO9oPGY05fS6sfEyFBCT2x5JVg35VM9cm+xLmk0G0JpKfDT5y0yLOad9aN7/P+5jQeh8Gv3615MOW/bYHg1vP5unTMG79nvEPvM6n9Yq7PMDQFT9LHQfXrKCuSzs6HDiOxicFrZ8a54IPMUGdmeCXiOP4p3zTJ4eaQRGwqImo9leiq9FgcTayoWk94amJOLduJDQ2nsiUNmjvP0Kt08Kypaqre1WHqyC8PW69Dxp7I6a60wSEpRDVph1GHx9ZxEYktWHxGy/ITuyCF5+ix4SLpIWVSMoSIQKXPvGCTM5K6qYK3Oy9Pnyb/i3r+rnptMdJhVHHuk8+kj+LqWnAnH9adqxj0lR3tjgkgKrQIEp//o4Rs84OorgQRCy5F1cvv5rM6swWTn9Pm01StVzGUBpNQwloXofJ3ADL7sRHp9wktMU78C3eKzeYbq0PGuGltevTliTChMAE3h35rtwgChsrEf5xpuCqj7E70bZwSowVNOksRDpCea7ubhrfOo6rRwRBE1POi9+1ZqmCt0t0V9YUbuaETgiRB1ERGcQLVS+SbdTQ/4SLBxe7WkS/bqtVhuY0H/fDmqmuL2eNVfKO9aE++KT96+JKOH8IRA0aDPuPk+3f6gBTGB6E3wOtjihBU6bIj/Ng8IHRivcf53YTFBlNbVkJnauiOBRZIhsMiw79QG+CcUX6yg21FzWdLuHV/D+ICu9ISfFe6q0l+Gl0NLqdcp0Udo2lpScoNIgANDc9Ol3BK+4psokiNAb3zj3BbUY/gm2NGGZfTXFREY8lhXKzJ83cXn4RBYf3MzBzA9c5LawY4UNstSp42101g/1LFjKeEOqNBnRRUbhqalooQvJ46gzonB5hsX8klpMWmaDmpbgIwarF/1LMNT8Q3XYVuuSZVP+0AI3LhdWgZW1SrqSm+A6uIlhjgJfXQ/TfibAXwt8d3v/FkGEaR7+VyTVnorihmJd2vMSukl3ct/E+blh1A8fzDjHvyQdlsSvU5qLYdbkbaOQP+X9SUu6RyUdCuZ575KDsAp/nMyjQ9VLwOZtjGRExlrCw4bjdDhZvfoou/soAvlk7gNjkN6XVmaN5Nzf13CEL2swydTMY2k4tntN6xsmdsujyCszon0hUoAmrw8XHe+aTVnGaMMGnFGEWAz1JO0fUbt5udfJE/ye42W88IqLcojOQE9Geq/urginM30TXNtUcaqPl1y7diR8/hnbXXsmzo++l2uSP7fRpKj/7nDhrW56s+Yzoyr68evML0pnB5edP1BMeNbCwgMqqYPx7m3l7zUm+25HLwn2tlIis8gbqi8fiLLyZ1Zeuld1fUUB64chrpKfIFRYd2Z2tXUlvolukOVIWfkKoIjiuo2r78fbh+6j7PVt2brxBFCnGRNyFzS0d3kUHCmRX81iousHHG7VyocuzuSh3uOk3OYWgCDO5DUqoYTleKbs1AmmhSrgmurgCN3W9idv7KJeJKkcG647XyqJdCslOb4dNr+FYfDtz5szh1Vdf5YcffqC4uJgIjVoIKwmhQOdG65eFRuNiaf0+siPH43BryMjIkLxd0QETEJ6TXmwu2CyLBZGC5OUjXuhcP5NPvDVLTQJ0Wo3ke1/39W5+P6xGyN3jg1qKXC+PV3QDl77zmuRr+g4eQtQLymu3btlvMhJVKKBjXlW0laSZKso3uMlKkFtDp4Q0AptUpzh55QLZ9apdtoyYJz7DrfdnzYh+fDw9XNIXDGdMArL9jby/4XUZljFz+UzGLhgrr0XhzSpe76eHPv3TXTIhhHPYrJj8/PGZ/iF08XCkjyxQx2ZFNs6iIkJMqtvew11BmMPJE/2ekN3AiX0u45aJj3DNDY8TEBaOrtAui12BwXV9+WpqFLdYvmJ9vqLNPHrxS1xy/2Py8xy3HatehyFRFWOBY5MwTY+mzlaJrz6Ay8z3k2iN4Yj1JH3bjyXZv4t8r3eULaGOJk7bm1jx0dvMfeJ+/njvDfAJ4usT82SnW0xUxPlvs9vJtyjh4sj4Yma88IakaUy860HJ9fTx9+eyJ1+g84gxyjN8xW+y2A2JieWqF96Qxe6ZEOJSgQ2lW+k+VCV3eY90Yr3aOIq44ri0jkTpTHJ8bnW7JFe4usRj1XUGxITlTOTW557lje0tdgWGaFRXV5sygKQfvsd00X3qB8KXWhSeri643To02HG5/XBf9XPr5Kr8JJxYDiVH5SZ8dtfZ9Ivpd567QNPuUmZWTETj1jDSNoCPTz1B0skQnHU2GjYX0rCl9d4kIL5vL2mSmsEeaaqxcaz+BPuCjnNvu/ekx7jArg5aci7tT8KcL/AfLUb5GupWF2I5VinsVAi5PA2fTup9EkLYPwNvwZvUdyB+zz1DZYCvvKeER0bjcrvZ+9vZ69e/gpw6DlNTsSmWfmy9aqv0L4+sUnSo4MSz7drmZi1kecMpvsn5nRUer++36pySliLufcLt52i1cjVJdWrwD2tHe10s95V0J/eJ1xj93Wtkhqj1xF6kXnNQbhXta/3kefNBzhI+2PQ+Q4sO07f0JLPXqeK1JthAtq6Scn2t5JIL4ah+1tXEvf2WFLEGjB2LT//+ZCW2Cl/LUlX3vflwK1/dbXdRVTUduysOnaMcY9g+ioNUs+BAiltOksZbXSQlNGK8+DI05j9vLfefhr8L3v/F2Fu6l7f3vc2z2589K/Ho/QPvY3VZ8W/SY9QY2Fe6j+vX30S6NVPy/K56/g1u/vhronpVoDMKzmU7woMnsfLT9/jkphn8+tJT/PzMo1QWeCINGyvh2FLsLi0H9yZRuz3vvIW6XdtHcaOlc+h+2oeewu4y8PSGiUz8wsTcEyoxaUDEr8T6qaIkIdRMYpi6iccGmxncVnUdBcZ3jmZoqiiGnSzJ/p7L61SBrOlxNXS/qsUe7be5O/ni3k1smJPP1CpP8llYG64e2o5g31YuqEWnjo2vuy19U0JlkdSmbSyfdlNjybwflrD01e3kHK5g3+ebmLh7ifz+h6kTmP5zBhsyynjp92Nc/eUu6fFq1KvL5tvt2S3HYU+OoFxo6RHRj2h/bxesFVn7yxhg1eOn10ox3pdbW1O/BH91VudZ8nPRbd2Zt50by9Rza9xRjDW3TnbBnu3zNO+VP4Hb5kIXYkIXYZYdTnk8B8fJBUm+Xpebo81OtFoNHQfF0vfiFGqcbiwa5P+1nKg6z6kh1i9WWrGNaaNESlpTBS+t2I2vLlTGGI9sVEW2vnA3DYVqMySSB/v06EqMUXXfu468FEtKa1epXrePoOQEWQxsT98uDfFPelzkxRjbC+Hneiav+EIF7+eHP5d2TKJgbrQ6WqzTFt0+iAFtQiX/+2C+Kry7xQfTJVYVvOmFtfI9WvbhO1jra6kwhNI49BrCLr+cqMcfk8l//qNGSasrQ5TiNgalpWHo11eK2CZ16YepTL32Bl+10RM+y0LM2NTczOaxY6iKTiGiKJ78xqIW+zGnj4mfRzbxVcE8WSyJyGdR6IrPxXEWxb3gaO8ovjA/2ps65YV3Ayo4p5IT3F0p+YW9lz2vFnthA/76JWg1iueuxcWd9X6yWPIWCT3GTaLDYHXcLada3Sx06LixfKq05BMQgtA2wW2kl3B0uzRZlFTEp6ETEcc6DX4DYqhylrKm6HvKG09L3v9DZdcRbQkjyak6rLajv9Jtzyb6niqiU9dexHfqIrtQJ3dtI/3IDunBLCA2cqL4WfPFR6zNjcbp1pJgLCGg9PwIZYPJhwm338fF9z2GX3AIKT37MOOlt2Xn+FyIAkjEfwuhV/GkjgTbVMEa2GQh9bOPlHgxM5OSBx+iT/opxh3JJiZJFR45B5WIS3o+O+08ve1p+s/tz8Ey1Z090zFFWOg90PsBVl+6mn3X7GPF9BXcGOqJ5o31eNR2Vvc/9TvB2ulZqlwPYXfF0BT/BNq0kSpZSzgyfNwXfp4Bc0bCkQtHxAoeftPeUsbWDmRLn1W8O/MTYka0J3hqWwJGqWKvdnk2jXtKWkbjFk931xDrT6fYLlL0Jrx8n4r9kDp9A+0NbVtCGb4d2IzvkMGYugzGd8QTOOtVgevTthF79haCJip6iriPOKpbnU3OPHcFB1tsMoWgUASTaHV6eQ6crFab67Z9+zPy1nvk50fWr6K+6h/b0XnR3FCP06GKyc7DVcGbl36YqmOZPBVxOwnlyjmnV/9WgazA6pzVLVHzfnpfpjY0MaQij4vDlYDyhzUPsNumwnE61+kpfOBBsoYNp/iJJzAuX0rfsgySTOp6NPfpjbmXen8fqh1I70w3KTuz5H3Eb6hK44utULzxU5EuTv/4BfcvcRHUrL7X3CaZgDFjSNu1k/gPP2DthMkcatNK+dreXt0Dm49UtLx31tM1uG0GKrhXWj6GVmxl72B4f7KWr8drGVAFLxXlU2szMW912X+r2PD/Gv4ueP8XY2GmUmOLi1yIjLxBCKJDKDBifzgP1E2mS1gXmjRWVvctI+DKQUS3TSXv+GbCO6vCp+JgMj8/8xjpG9dit1rkOFx0UU7u9Cw6+7/D5bCxpLAv6zI2snzOO1R8exRnXatIzd+/PcdqWrt2K7NHUWdXxeXanH400hsNTkYkq4ViXGIY1QszsZc1yVXgst5q0RL8y8jgJtrG1WAI2U3vhmwpVnMLO5Ze10JEe5pCO6NxOehw5Bn0WCk7Vs3yPaHUBLYhO7ET94xuvYE02BrIqlGiqt9uvlpyOwVuGdaGLbHd2Rbfj4Odb8Pq8ozADOHSraC4TVdsMUNpzqnnhm/2tBSo1wxIZNPDI/Az6mRncfspxcHam6MWlD7JSoTg7T7v+SObpe8dIC+9CrNbw0MjUtHjZOHaHWzYqTiMAmJ0NrODmpFdXDmcMEeryKtmSRbOCgsjdnfCWOSiWQvvBDj5/WgJp8sbMRt0jO8Tj1+faGl7cVKvw+6G5Fw8+j4AAQAASURBVG7h+AYaSeoSJjs7+c3qpl2/MR9rTi3tg1sL3pkdZ0p/X8ERTAlU/LVKR6bkVU+NGkjXMxLKumpOcuutt/LQ9VO5uPR9NNY67HozZQn+nHIq+yohftNoHXxb8x3LE5bzqeNTPjv8WcvvsDjUQimEP0KJ7i20BERhcbSwlqUHC+XNWxQtQpwizvM39rzBhqwcOSmICzbTNS6Qdy5OoU1oa/xtt/ggusYF4eNsxn5yL0vff5OiowdwaHSsihzDhixV7IVedx1pu3eR8MnHUph4JqI9CV5H9uymsqFc9u9KH34B/xGqW6hv25a9V1xOg0mNZ4NtwazavQq/KVPIu+lGtl83itwYCzqnhif7PM72mdu5TTuFS0t78VqfF1s4mF8e+ZJzITqMH8y+gvkvPk5DtbpGi04qvp6XcyqjYH2CoKGUrGVfoqEeX53yti3VKNHLJXWV6GXZfj6snmMQMDJBrgID67szv/BdXql/gAfT1DRBoOeES+S/xjT13rjj9dTWlkpvYofbxgLdIqwaqwxCeSP3fnROLRptNfZTazGKlPGGZobfcTdXPvtaS1fu9x8+xGGzMbGgA3ULdvD7+29Ix4wahz+NXTyJXyseA8uFHULaDxzCrZ99z/THnsPs38rHPBOiwJ+Qorq8S/OXU94BQhuacXQKILJHf8JvUS4rDevWybG9T0wMbQcNa0nVE1j91Udc8c5IOfYWVmBfHVFC1DMLXjEOF+lwMf4xktcfHxCPvuTw2QVvWFsQmwXxvMxBBF45lqAHH8R60QZ8r1UiypbJlYB4X4UgbuFNsP3D815b4+4SXE0OKVoN7BSNzs9A0Lhk/AfEyu6730DFzRf319J39lG3Lo+mfYof6pMaLB0c2oW03iMvqRrO68fu4aGEu/HT+0nbwHlzPsGaFYUuOAmXvRH/QX6Uv34fxU89jbMqH1O7YNkyb9zVmmTpxdENayQHW4gJTx9QQqzYtA7SbSN987qW8yqhc1fp/+y029n4rVq/zoW4/o9t2cD85x/nk9kz+fHx+2XSmqA0dB01Tq4dv733Otu+Vu9NuzEjGdlbnbMCWdVZnK49LSkOn4/9nJ1X7+I5twpImbpTrZ87tVZ+D1XTjnZH66lbvlxGcRs6dGR1imoARJTk0nbNaikiC7nyCvW97Rlcs081bQ6MTSJxzhxMZ8SHn4h1E/TTGvpmuglqUmtlmUd0KegidQ4nH0SncDKxNRRldUIyecF62ZGv36A2WM3H1T0go8LKvkpFVTiQZmVbZy1p7lg+rclHtHfWl7alprJahq38jQvj74L3fynEeHdNjlIcCwie5d6SvTy7Q0XZti3wI7zORNXedF5MfJCUIl/cWviiZB71tnpKyhYihPH1hb5kbiyU/p2ia3L50y8z7ta75e8QiVFkrYMNr7CrIpG8Bo9Re1MWB3Ytp+StfdRvysclbcTq+fLgGOps/lRawlmZM5pnL+nE85PFWF/DvhI1qhnTtoweCcFcozHRuKcI69yX4fUkJtfN49EJHXhkciBTl03hk8y7CI1czFMVqpDUDLwTQttQZ7HzRN1U7G49qT67mBryBFp3MU69Pwe73033ESPxMWjPUk2LQkmI0uIDlWhCYET7SG4d3pb9HWZi8QlD42xAY6uRhXX+tU8T+fCb9G7WM8Xmg1GrJdTPyJez+vDS1K7EBJlbCvRvtqlCeK8nqrRPkuK0VZc08uvre9n9WzYFJ6rlbj02NZgUfQEzzYcYrMti08plZGWdalmgRXzuzKQruaJSeUcGXdwGjVmPvbiR0rf3ScGZW6fhQVcjC/KquOcnNSqc2DUaf5Oe4MltiX2qP52v7kBkUgB9L1aLrI+fgYiEAElzEP/fXtRI+WeH8V9hkYKbKN8opqW2Wmf1jFJdOp05jy2Z5Yy2qu6Yd6jbyyeLGMrgixFQfIhqrZa7w/y5a8tDNKGsmlIMittcYs/Aore0zpM9EON8AaHSF9xkQem4qI1S8As+5Iy5n3Hvzwf5ZlsOK7NXynNWoMZaw5dHPiHCWs6kqvXMufMGfrp/NtdW/U58gI4R7SMIMOk5tXUt1xXMY3TpWk7tUGP+vZFDqDKGSUs8wcWWr9FfjZ/Phd+gQWjbp7GrRw/Su3dlX8duDJ06kviPP6Ldpo3kP/gABQ4HBoMBc7yyMss9kMtPCxawo7GR3HozRqeRAemhdCgIoiTzFFWHGtHUxLL6+6+5rvN1coOxp2QP2wqVB6wX6zf/yndDMvlZs5EfHr2H7QvmkndUdb29nFMR8mITYR6C01i2l2C9sKqykmEw8FBUMC63Pz6uSlzzb4bPhsLyR0TrTT5eBJF4be38B8USOFpZKAXUmehZ0A79t2VyqiAgurz+QaHEmVTnafOueXz/yN0c36q68pkh5axJVEVNqDOIRm0zvtOTWzmaobCkVN2n+ky7VG6m9bl1XLI1hqjDzWTu2sZJTzCEcMwInPqq9KdFeNYuuqXlOZ+Lc/mpF4KX1rCtaBtzOxTy9cxmxj/xtnqu08eReo2b1Jl22s6OJPnJKaR0VwVqfvoRSnNO8VH5j2RFinG0+n2bCjYy/6vXKS7NkWlmF7L3w1LXEsJCTA/V0hX3UK1n4tT1CnUMgk34949B6+OR0Yj3ctZSmL0OHsmGAXeq7wsrrfzdLe9b1S8Z1PymJlb+A2PQCLLwOccl+OK2ciOjMelwVDRTtyYX6ym1eTC1U/cncf51i+jGJ6M/4cGIOzA5DLjnl3JVtfIm/kL3E/X6JkqrNjM74RHuOH5LyyVc9/sf+A9QRbXsIp/hhCKQ7emQi02RiLAWiG3fkSVvvCApRQmdukqainiuo264TdqCic5/1t7z45QPrFgm6TCCfy+OpaD2iAmk6PaOvul2+XtEWIXoJgtay0XXqbXLC290uhDIihCO5owqGkrVNZTmqODeyhra1DkkdzfQBQN63UToTTeS/OuvHH7mA97tdhnlAeFobIK3nC6fs6B6CDGZLTub2JwGbDr4pH0eKxe9jfWE2ggJnIzTsLGbjiUDNARfMVl2ZzfXNFDe0MjW+T9y195jlKOhNlJNFhx6A1kJScyNbOTXBAMf7Eyn4MhRmtIVvaGwKQtb6sXyGj9qVsl5TyeIbr2bEuKoD1WOR4UnzqEj/o0W/F3w/i+FGO2KroOwxBGiJsGZE/xAUSwEaP3odVJ1CG3NzWz74VuGHA4n3Bkgx1ifHPgIm07xySqOhWA06olr24arX31Xxjy26zNA3oTEDavm+xvJrfdje4VaFBOD1Q72SPVWimuzqF2RQ9FzO3B9fJgrbRF8c+J1ntn2CKH+wVzZN4FxnaIkP3dLrhoX653HWHzHIPyKiwkzvIB/7Ueyk6Pd/Caze/nwS86b0qVAjHzvr2gi2umkgAgq+z4g//8bK0+wpq4zS6qfw+LyJ8p0mln6+4ms3I9LZyR/L7zx1g8cWp9PY61VelUKXKkJhgU34HylE47nUrEdO8h9I9vR3tPZnRtkYEeA6vLpQ1M5vFl1LrR2N6tm9WDLwyMY0ymqtSM7SC3q646X8eSzm2Ukr7iYusUFyr+94NW9VBU1yg7r8JntueKJvgy+Jp6NGzeidTuxi92H8Bf+TY3b5N/SaLnDdg1+LjOGGD9ZjHjHhwKmtBAODo7isFCUnwFv8S0WP62vgaTOYVz+eF/C41u7X3HtQ2hwQW5yEH59RScYLIcq+KnvdyyduvQs79seEd6CN5dd2VWYTymh2dzAAGm0HtpcjPv7KWCr57hPFJfFRbNV2KC5DSp/xBHC00Nv8rosEWUdA2Wq+HDZ1Hm5One17JJtyNsgvxYiMNElE1QHl0isj/oRU/QiXl15iK+P/NjSATbatCTsOMhVRb/ik3tQJoMJVGVn8rDPfl4cHMTzd9zDwZ/mYHTZqDSEcDCwKxsTL+Gph2cTHegjueFCEPnPIBa2xilTcHksxU537YDOaZN0gkaTiW3bVJE6ZcoUJk6aiE1rQ9+kJztbbYAMLgP96/rQrsCPXauXM2/+Apz+QbiNJg4VldJwspDp7dSo+/6N98vNqhfLilfh0LulPVhVcyU7fv2J+vpq+bdj2qmuvKBGfG5XXbtA7Sr89GvEUeOd0GAOmnMo1Ckqg/bEQhAdR2HJ9Ns9wlZDjkhF9aKP8kUXYCRwdCIxT/VXwQfRvrga7JR/cRhLRhV6g4F+vaZh0vnS5Kin1JIjO3J15epvVwXaKO9mQx+pOl1fRP3KsZj6lrGvsHYSUdxirHzbnvs5GacK6eBGAz4BgQyZcR19LpnOyOtvodekKUqcdKmID/YBEQXuSST7dyAoO2JD53VW+Gjcpy3qe82Jpegdxehd5RgbDqLf8jQRG+4iLlyP1dbMnctuJie2Ca1Lw/OFdfRvtsiCb0nOMpYs/lj+jmhzpPS5xWGDtc9L2pc81uKRgfHgFw4Lrocfp4OwkBKvqZeiLl0QgtYQ3wfZiZjwioprFxDiRJHct+AkTQfK5LRG3Bv8h5zNW/ZCo9MQND6ZmCf6SZqDb89IDPH+mLuEYUpp9fqdO2kuQ+OHEnKpoKuYpBhtcuFQEuzRVOvrmDt6E291W0FxiJsj0VaOJqniuu6PPzC1D0EXaMTVaKdheyuXVzj/FIjiVGz6/W38NCCLPe2rJU1EUBuCoqK5+P7HWjYsIvJZvP8Ca+d8xJI3X5KhKuLxoiO89ecf5M96TZzM5U+/Il1JxLq0+NXnZCNl8gNPEJ6YjN5kYvzt92EwmihtLJVJnJkFGaw4ojQDQthsza6l6sfjWByqMBT3p4krdbz5cyqrE35i/ay9pN75OFEPP4y5S2eWHiySm5OG/qrzX7dqVcsmWThJeFE5vAsT97qIefpLKXQWVmr7bh7M8QT4dYiGlRMj6Drxcjb0S2Ze1HaGrf+Bl0vqWd3sRO+GO0uC0CcPI3v0WOwGIwtTwnmtkw8fDerC0FIrn0VqWRi8li8H7ab+klH8HKrof6PDu5NcojYX0Zc8Stu+ykN68WaP3uZvnIe/C97/hRBjnl9PKn7XZamXcWu31rQZIQK5xzYVP4serWexlrGoLg23Japx4YHcuWiNTTiadbgL9dyRspGrQpYT4OeJMQwIlLtwgYPlISwvUZ+n+HdjzMRb6DpacL3cHLRuQhOiCkZ/m4vrMDGjzITL6cNdo1KlS0JkoA+9EkPIq4vHjQG7vYqm3C2EVN2FWbcXt9uAyxQDTiuHfr+LE1Un5Fh9ZYcHuapRFSVvNM/m9vkneH9tJou353Fxo5EyW2dW5d2J06bBL8LKKMO7YN2JFh0BpxLYOj9TFp1HCtO5oq6eGw6vgPRF6GyF6ClDs+BGCncXSLNu/PQ8dm037r5WjYJP7S+juljxUk2aOmIXj8bv016Q09qJC2x2k2oXdugw16q6j+EODfOf3Cn/tqAzxKUFc8WTfekyLI6IxABOZp7EhJXOiaF0GnM5LrcGZ20pCzerolx0gR17VhJmeJagzoWygBXFafjsrkQ91IeIG7uwtUnxSW8d1oYnJnXg4fHtGdhGcez+GeLbq85Odm49IZemYu6o/o/jYE2LW4IXXo9ZvTkfp60B9ylVlC7z92OLJzFM01xNc3BbbowwUabXS/oCGsWv89EbqXNnt4TvFXEIR4DqOtiqB2GwqE6asDsT7hTeglegk+5urBUjJSXCGLIbY9Lb5NSfxKA18tyg55hc0FXaEYmuvX+3NDmREAp9EUuatXs7859+kKCaHElfyEoeyfyEK9kSNoR7b5hK94QQhqWpxWLTyX+dJncqqJWe4tZqWL16tbz21q9fj9PpJCkpic6dO9M1pitFYZ7YWJ2L9GDlpxxdH4c7Io4SczBWl1t2ifRWC26jDwsW/so9Xe9mcOxgSdm4Y90dkspRW1vJUV/VPZR7ookdSR01gtUT6vnj4lryrcWy2BW+zN805+Bwm6VAUKB4dzAdm/tIkWNxvyuwujrR5ByEJeZmGbXMgR9h1eMtdAYfMZb2QOdvxNw5jIjbeyhRktMtO4kiLS3aqnihDeH1zP7oS/pNVcJGlxaqA2x0iuhMxC1d+W3wPlYH75AixKhHHsanZw92DQ6TwqAHNz1IRnUG2Z3d6AP9pAPDNa+8Q/+pl8vOrihoWrq2cb1hsnJUYNt7sO39Fo/avwLx+27rfhspQSm8N/I9GRDRgixPLG+fG2HEE9J9RpO3g8mRW9g6MJ+MoHK0Tng+YgpTHTXMqFPX+MmEBla4lJVY+2aP5d3+72DrO7D4dshTsdXE9lAF+7ElKmSi/+1wxw6I8fgR/xmMeQ6M/lC4D9f61/A9/TCRxvsJvzpKTnM0un++fGtNeklzCL2yPVF39STsmk4X/D9as17+zJQaTPj4VF4QxbagguT9xtGAVlrJuglRkvojhFuWI4cIGKOEXLWrcxQ1TXR1c7KxNDag8TexbWA9Db4OHHoXZTmnpV/0tEeekRZ6Z2LgZTMIjoqRXdpTe3eSd+Qgi157nl9fflpS7OI6dGbErNkyZEVc7yLGuzgrg31/LJFixmtff59bPv6GuPYdW3QQIonz8nVXku3KR+/W0TevPRXfpuOoLMChcVFtH0nBllDqKyOJeOh5Ikd1kX7oXlQ2WFuEsWlXKteIhk2bcTWr+2/gRR6vY62W+KNlTN/uxuiEE2m+hL/zOqHTprekj/aL7seGpl3khm/GaD2Brvpzjqaqe8vs/Dq61rrQGnxJWrea6ArFce5c66BDrZNmnY4fI9fwZcwiKkyNPLT5YZZ49CkzGixQLNYOESs4kfiOSiRtLD6fV/03FP62JftfBrHYvb33bRlnK7oWwmRcjGru6XmP7N7e1eMuljz7lHxs97GTOLBS7XCFM8O0Ideyc8dxkhoUx7cqM4hugaXotIKMVQ575sCQ++XPUnt0k2PUfVWqexjsE0WvsDH4dAhlxPibOLV3F7XVpZRPq2RJXTxl+0p5GB+GuvTM0waQnNNEk7kc324RTOgczb7casosybRxHsfnp6vRaetwuCOotD2D0VhOCC+QmrURc0IsL3WaTdDSh+TfPdI4gcSGvuzNrGHtiVqus/jg59ag07qISt9CBd2ISj5EWFoD/Y3vYXeHE2yHaKcbq9Ofbnvc9HIrWkSJbTR6BhFieB8Dpwhb9xx6rqPbkDgGdo+TBefRwFM01ym+qslXTw/tMkzWQrCC+7uLcfW7Uy6S+77bxZfGT/A35TPD+hgn3QkkIrLgnfL/DZjalk5DYqVwzIusY4e4k+8JFLHANZ+Ra/DB11FN47pfqPB/nUCbiVDb02h0Ntw7b4Y2v6BpM/yswkSEdgj0TgphXOdWisa/Qky7IFlA11VYqKtoxrd3FM3plTQdLJNd5DMXQtEVE5sOQZsZ7rMJg8tGsU7HSYOBpf6+jG5qolKrZZafkQa9KnKNBGNDPTcrFZJiI6B1G8HUWlw66ztTXd+ZNl1LKGtWAkaj1iwXhfUnSnl79SmcrvHc0GsMq8repRK16Nhru/LrlkLMJ9Uofm3fMgoj8siuNnJp6qWMvfVuVn78rvzZSb92DJ0xi0fH9pJiQ8G//nBDlnRuGJYawfy9BWz+FwWvCEjZeTQT0SNPdcSTqS/g8OHDlJeXS2cKgXHjxrUUafFd4zl08BCl5lLqDfX01PXEVmmjMVxx7rTNjSQeO0y78lrWjR2DVW9i+RdzeP/e97l3/b1y7P7k1ieZ4jcSmyC/enA8uIzAjimUHq4GO1y/6nq5qRVC1A7WFJqdPfDX/U7poRDqCwK5ffJL3NdO8TPr/YdR+/tpyAY/cwghvAG7PsNiE7zECMXDPAdak47QK9MoeX2PHIfXLMvCWdwsBZHd75omC+OhM64joUs3+bztBre0zBLfT+veFTYo143Hpj9Gyk8/cfHJX9m343k5QRDexVd3vJrgWUFygyIg/GuF6FbY8H025jMMnphUul0OFSdh8xuw5hkoz4CL3wV9a1HyZyBoMl6qTAtsTa2b1/63SV3AqZQBOOZeRnubjWsdFbzoDGNKXmem+CrK0fCmZqIcDkpNerJN4OdycX1pjnJU2KJoEtIu8bgK8SG6G6zyeOIOuksVr38VIlVLeM+uex7t1tfx9V6iNeL+3cq//++AMc6fiJtUY6MPCfKa8mpErtjsZP4wHTtDq2ieMALTwtXULlmKuV8/tGYtrmZ/qhacJPK27lJEJjajB/paqDA0YLBr6JGpzrMhV11LWPz5doOiKzv1kac5vnUT/iGhlJzOlHoSwUUV58nYW+6SE0eB8IQkhs+aLWPBdyyYJ8NXgqNjZJNG2EnamxvZWaw2HU7PJKxnYwdcq8uxZa3FelQl+6k5gw/xH71CwBgP1/oMLD9SjNPlllqAtkP6cio2Vhb6+bffgb2wEENcHD7dumLNOImzrAxdbAyfDLewLqmOypyFUpjqRVFDES/lrJRseqc2BJ2rmsCK9wi0X83l6YlgCMFZk4vR4eCH338i7KMPOXFoIwv2/IgzxEqNJku9jvAeHKg4KNMT06w2emd7vNET+ks7s9jUQKnh8LP+9wTd/F/E3x3e/0UQQp+71t3Fj8fViFcUuaLYFbi528081u8xfDDKkY/owPaadAl+IWonmdS1B0YfM7e0n0onX3UjaCiMo3toa7KZe+sH2AtVIdAuTJDsVVdFbzAyKHyy/NfUJkju1AdeqlTiG3/+kbl7TrNCY+f1ABcNuIl2abAcKKdq3gkcVRbpuiCWt4zSeNrmNKGz1mFzJbPH/wOaDW2odsRTZwomyOXi21o7/Ve8gd5ZT4ktjQO626XY6+oGExOajbLYDY72ZVDVAoLqc3AMu4Zvw1Xh18dmZaC9kI4UEqIrItp4kl5uxac72DgNi/NeLK7+nAy7Q34vRLuEXn7HZRCEgCgIU7p6uqUaGHFpJN18VeHmih+Axu1Ct+tDdB/3ZLzjdpJMhwmjmo9jV5IY6sujt/Zi7I2duPqFAbKre2axW19fT3DRRgJRBRt1hSQ5ThFBFcmaIsKXXYth5Uw0GhsubSAaRzPMu/KsrvKZSWKCB/1XYPTRE5XsSV87Uklho0PMeeX42mtIfya1QtAaBjY386Zmnvzeej8zYYZkNviauce/BzNiYsjzuDMIvDToNWzZD0vKghtnC3futp6zWx4To4shzGHCbQ+jW/lNXBrzKPba7tQWXMzs7w5yx9z9cpGZ3jOOx0ZcwqIpCxkYNRydK4jGsmH8sWgZOpdDOi1U6hS1Rgg0b1x1I7/oNmGfdCfz4q7gdJdpXDVK0TJuGd5GcroP5dcw4NV1PLnkqFx4hDVeUY3q1pwLwe+9cc4WAtzq9fVzpDCy22B0Ol1Lsdu1SxfC6urkIiswJmUMWUFZmIPNfDHuC2ZOnNF67KvK8M09QfuCUqLMvqR4rI2yioopTj/Gm8PflBxmESX7abG6tvvTSb4PwrFCRDwLRNp85CZEFLtis/u07wPUOmaTl/MA1Sd8iHz4YUyeYlcgYEic7O4JZ4XG5mHSDkvAV7MJrb8BnxPPwntdYd93cmTe8v6b9AQMVxtdryjJt0ekLGpbkBjC6eBq2RUTjg4CA2MGSnGQ4Le+uvtVGU/dP6Y/v17yK2suW8M9ve4hzBzWUuyK8I0Zf8yQVmiCy31m0qDEyCdgwuviwoSDc2Hpnf9Wp/c85G6TEyWCEiA8TXbtXzz+DS+FqSnI9LpG7tgRzIw+k9AIv29Ry7r6cVtNrbShGtfQyJKCYvpYrPDrDVAvzgnPtV7meQ3ie1WnwC8Shig61r+FAXdIj2L1HDzFouc5/U/igT4PSBrAg70f5M4RT9BT30ZSjZb31XAyFnZvnU/hQw9Rt/gF0Lmw59dTvzmf/KOHyIxv4JA5T3JMZzeNw2zTUetnJ7TfGWEQ50AUwqIg7jH+Isbfdi+jbrhVakqEJ3JY3Nk2Y52Hj5bUO4fdxpo5H2HNy6P42efIHDacNdOGyGvET+vLM/m3MrppAHdH3oIta01LsevTqRO+AwcQ/eILaIeOoN7i8cD1wO50Se2AwJQesXJTGzBeOViIhEF7fr7813L4iBQ8mnv2pM3ChYy+5nHZ1RVC1LnHlAuJwOEKT1BK0KWE2m4gvM4HrauBUPtCggzqnDsd4sCdlkrH996h0VHMg9lPszU0vaXYbQqczrtjv+H5Qc/TPqgtD1dVt8pRPemFgtZRE3I2n/pvnI2/C97/RZh3Yp7sBInF7u3hb3NNJ+UXeibKck5JW5ik4bXsOzaSDpOtmMMsJA1xs2fvdIpO3CjWPxrLfCixu/DR2qmzm7CaotFYqmj87GVsRQ34l+8i2U8VQol+HQkwhNLgU4fWqHaPbYeORhscgbOpnl61B5nWI46V9Y3M0jdinh5DYNBv+OuWSVGbeelpVmkCubK6DaFVqnta5biPLeZtHO39JNlDn6AoQd10OtWUYm4upMkZxPf1D7IgTNOSShae4E//yW2YOiMCw8HNoNPxQ1w2bwcYeTi1B44pn+Ca8DpvJaRxY1Qk82wz2NcwnQ21t9Novhm9Rkut083y7CRyHCpusqPvCkKjWz0u2w+IQaNxkto7krbNCzBqm6mwJ7PK/ibLqx8l39odl1t43bppiFS7+HaVG/k9xUmvmEDS+kVjPrMw8ED40PZGcdsY/ijuWctwX/o1v8U9xDZ645LmTA5qXZ2wTd8K7caCKHp/mgGl6WcliQkeqqCKkL/nLy1+gscrsOWXk6z6Kp2cBnXMvQruFjgdPG0382lJOUFuB4dMRj4PDKegoJe8oW8KNhJkfBiNW3XbkgKSmNBuEN9cO4lhca2WQIIqMbvLbCYmKyHMld2upG+i4hAeKrSweZc/lqIZOGp7syWzAovdxfC0CF6/TAlaRLrUFxM+Ys+1m7i9X0961KvjZw2JYnR1O6LrH2Jq2+nyyInEpG9yyqg0hvHYxA7oPR3ryAAfnr64E0lhvtIxRKT9+Zl0/5TWIKYRmgb1s1CXP2aMdNOmcP/99zN8+HA6pqXRafkKsqdNJ3PkSMreeouhIX346aKfWDplKf3D+uK7po4Jth5cYu3N1W1mMiy6AxFR/fEbfi1Dhyr+n9MvgD8+fR+dxdWSkOXQqM3oDR2vl11v+XqdVlIL3bz5YQPDNGnScuvHcT8QdlpQkHRYTx2QvMGQa64+77UI/mbME/2JvLcXuhGKPxoYvZvomaA59APU5Clu76eD1Lm25A5IX4Jf31C0foaziucz4bUwG+cTg0F0OZ0O6RUrAkUEfjrxk3SOuWzZZVL1L5L0jlcK/qQat4qi5PqV17eIvwTE486C6J4PuA1mLhDEVOW9LQrfvwJh6F95Tqqdl87QbrT8G4JWIzYRx43+VLn6y9CIa2OcpNoPSaswi6snNfbZXFbfyL6cfN4ur2R3bipuQQXyvB7ZwRWhOJ64Yfd+tVF0j3rqPN/yvwTBaZ69ljK/n6mwefjMQsTmOT//KYTgb9ndyvHiL24UREf+nRHvcH2X6wm99hquGaxEdD/VruOp6/Ty48OLwvi9fTA7i36gwlJA3do8ThWdZldntW7ckXwDtt3q2O/tUM0nR/+c77S49oWLw22f/yAL4Av9fNgNd7AiagLvViSz6a77qfnlF5xVVRyJU9dPN2caAxu682zCY8SVpGM9qnzbw26/jeSFv5L0zTc4J05mzDubGPnWJgqqFSVDYP7efE5XNEqhstChyP934w0EXnQRYbNvIuHzz4i49x7p3R00dSqJ33yNPiREThLEtSn8pRdkLsCNus909OuALvRZmoKmMq0ykOdjHpEbwzyfCo6as6i3V3HE18mWhFAcZpO0wROT3K6aRIbvD0NjuofG4Gn8UV7D9NTp/Dp1Cb1tZ7gBhfdvEWjnB/0dK/zP8Del4X8J7C47846rm+jj/R5nXLJS8p+LkqyT6EwOglJL5c3a6bOX9pdBtTVbjuUFb7S0NJSajUFkhVeTbdBTVB5FonkcCXxJgHYhZd9fQqR2DZfEl5MniAo2VRyeKttPmms8x0samPXVboKNPZnEavrUHSKvWpnSP5uwlbD1t4IICTBA+Z4ErK6eiNIooLZOFdtmHdmdf6V3mLJawqWnJDQMU6ILQUc8depycmpGsdLfzOnKBp64oRPdY4KkAEyg7L335L/Ofl2ZW6JGiFeOfht9tDJUjwr047s9b5Abl8uLpx4l2ajFYFM731NWJz62aHbbp5IcvgU/7Q6a92Xh2y8N7BZiCz7l9rj3ociBplD9nz0NV3D6kBitDyDbOgA/fS1DL0uk7YjeuL65Em3uSnSHPqXWnUDoFe0v/L4cWkcfinFpdGj63Ejl4irshT6MmjaCS3/txDjbbtprM8jR9uO29vHQ/kes307BVLiT2jmTSZ8wn/QmVbB2TwiC5moQwjExRh32iOqGefEPFOxCzLZvRathfnajg9SgfFzH92PNDMPUNkKZ4696gqhCJaLaaornpHsG2vpcdE3d0fIbLkMJr0wewvM71skOpIhZFYtQ/8RQdMaJbF3/a4syWoyoXx76MpemXSo9Szv61rD8y10UuIKxNSrTrE+v6cVHG7II9TPxydW9MJzDM8zJPo1r+88E2OtxaXWYQwMwaJzUFZqwRk9nSFwlWwo3QdBmhsbfwqgOkWf9/6v7J8mP4tpmhr+5kQarWhRXpZdwRe842bk9EyLeOl6rFo5Yl1pYLJnVhExtx5COHcl/9z2sJ5WfsLO8gsovv8JRVU2XV16WinURwWrLrSPBJ1JyYd0lLmJ9JkMPEIFa4e0iCd27h6rwcOrcWrb9/IMc2w4LH8Tmiu1E1vrQv+cYynOtFOXkYNHamLmxHLMN7vmogLYrV2ArcFJlKcPVVIWzIoPoJ989y7lAFBZCQBcdHY2vn6+0riLoctxbn0RTeQzHb3eqbodwEhAFYflx9SFwcC5aUxDB3d6jakeE5HYaos/meadXpGN2uXg6YzeIaGkxwr/4PTllEvoCsQkRna0DZQd4ZrtKyPJ2gYU91PyM+dJxQ/BrRWH/S8YvLdHZ5yF1DIjCcd3zsPxh9ZyjVbf6X2Ltc7DjI7j0K5nMeHbBO0bGAb+99y355ZUVE3D4DsLdfD2+2nTch5TivsFxCbrEDlhLe2DiIPWujmTWh5OjSyTFvhqnKY6K0KFEigALT8GrcVtpdval+XQ/Qnq6z3NT+CtwWE3YKv1B4487qhua0sOQuZpmO+g3voh26kfo0s72npU48APsVy4JpI2Htq1j9r+KkYkjJZUmqyaLCEMo1FtoWxgk3+fcphJym+bSJqgXa3rl49S5GRIzmNCtFdTb7YSktSE/Mpf87OVyw/PSkJdaJpP/DlwuNy9sLiXLV7kbPJUyhffKKuj2+gukbxfddBsdD9bjclfTuHop9asVhS/8jjsIv/sueZ2I6+ORXw9TXKs2LHfNO8D8WwficLl4b62aCt49qh0BPmrTp4+IkIERXgjRWvjtt5/1vMRE5qE+D8mJk8OQgCXyPhz2ao5q2lFl0uHncDOlJhKffTCu7RD+MGxgfvgqZqRexML2Rdi0+axechUnrdkEGALouzsEV4kG29FClkX15ZdtezCmxPF9s5NHmmIY4VOMpUZPwT3PYJvzFQ/n5lCV1ofUjHM2jn+jBX8XvP9LsC5vHaVNpbLrJXi7/+hGsGrjbmJT69DqXBQ3RuLWhBDrm0FQYE+O1wzgzc1xTClYR3BjCZVt6vjaL5DUjDYkBEzCblyJQVtAcOMb6HSlaDV6zNa+0g0io3Y3J2p20u34MZ7f2kBlow3f+M4YffKw5Z1As3MxY2KiuahYiU1cbh9pgh+gW4BxxGQphGmao8QQZeFGmsJO4HSbadPmPuatPsaN2dMo6PEejZEHqXJaCKyKp3OSjtOHi9mRW05/wU+Swi4XNUsWyc8XplQyrmYgF+vGkPCrjrrO+XIUO63dNNblrOX6uotJ9HSkBQexKdRNVn4RJm0UVeYEap1JBOlycW75HpJmwC/XyjHkmUtTk19HTpeoHbSAwaSj0RqEzRgjhRo1+ROJYCW+ug3UHTiCfVSijNy05dVJXpzGoKO5uZnIAs9oNGUMmho/LMfUTbX6u2M8G5GAX0Mwv5sCsGls7Dl0iKV5Bv44dSMLjAW0dxTQ47eJlPpOIpTxdE9oDwd/UsWugOA5Fh2AyizFxb7+91YP0DMQ0y6Yi+7sJl+DCNmo3LyMCNMraHHg+vFV3H5BaJrUCNumMZNrv5pkyxSS0WBurqfDzQP5KnMDmwo2yThVIbYSY8uJ8Rexb2UOB9bk4XI7GRpgps2pBlIfVcdNdDPEaFtYtdVvL8Oo02BzqltPpxADEQVWHo2Kwm5zsnPl4zhdlVQcvQKDIZyYwVkcPvIHbqXl4Jh/e7rGJVNXdJo4XY3k44aGdYHITRiD9vP0xYky+UoU2l5FfsvrDzJzTf8kFmw/Tl99PuE5B3nxpRV06tSJKZMnY/J46opI4i5aRR1J8I2EBg3OSgs1i1ZS9vpzOGtr0UWEk/DJJ1gzMqQ3ad2KFTKVr+lgDbbsOmkJZYwvQh8SRtMhA26bG7etAY3RH1uui7b19bLgtQeFcmT9anpOvIRB6eFUNwQyLHiAdEcY7TuMHtnBchPo8FuFu10mztIqSt9aiDZAiZ/s+Tsx9+6FMbnVzUPg+PHjzJ8/n9DQUGbPno2Pjw97j2YRrmtHG9dxDNVZUsjmmDaH9Vt348raQI9O7YgxNuE+uhBNXSHm0g8Jm/UrRm/E6RkQ9IOLGxox2z0dTuFO8PU4Um5cLeOxBZwup4z3FZ1e4SIjPJdF0Mbvp39voWXd0u0WObGSBW/lP7FTGnwfZG+G0xvgi+EqgEaIzYIu7FSgnoADDqomATs/UQVvdY66TrR6GuP7cMfaOyhrLifWFsHltkmEPzAA1+FP0K64TU5cRCKaTdeRyBkdcBe/S9O852h0zCTUuJb6kpHU+CVisXal4atriQrwiNhkRPZYqh13wr4K3LYT0g1DY9ThPzRObT7+AqyZHspRuI5TDaEI0kr5omcIohqDzknxTw8S8cReec6cZY+2/qXWrze/9acLXhFjXZ5zmpLTWdInNyIxWV7DgppicVrk5Gb9D3M44F5KRaCVBl87ySX+nK7dT0qWG2v7AG7UXczmQ59J7cjU2x8lsGGYFFoK+srMP2by2djPpFXkv4M3VmXwx+FimbNjsjdQZg7j0SF38FFKZ47nuiUTr/PeDBorHlX/Qacj+plnWvxzBUQc+foT4l6kxWTQytCau3/aL6dM5fVWSVETm+S/CjHh6Nv2DlbaeuHSmNDoIvH6wYwz+xLaw5em/WVMzx3BirYb2eOfTqa2kEaTokaJYldgfG1XXMWF+Jl8uHzjepaNnsq+iBj2CasdNNw/4nHeP/YKq0P7cSCtK/szy3BrEyHpWnZFiuS6Vvefv9GKvwve/x9CdKJ2nKpkSo84OYYV8HKCrmh/xVlqUi/EjvWpJYcxFmQSNk2JhzYVjGBN7hC+v7EXaYnh3PjaeuqtNkKslZKdKxTWq80BDPcbhhYjlX63Ed38FGadIv1bXB3IqD3K8bpdRHVKRWiSlm7Yw+GcYC7L280Ddw4n4OhOjjbXYah0cK1BdVvrHZfQ4JxKtPEWfHSHMSSXQHAIQbp9CO+ksggTTlsAXft8Q6lLwwKf94kNiWJo/mhZ8AYn7yAi9SFcAWZWHMml49Zb2Le+jo6P/wonynGWlGP3cROvH8n4YpVuY6cBe0GDtFISAQzvND1JU2GpJPGHXd1Biu2+/f476upy6T8skWH9e7Hr7Y6McuVirl2A+5u5ktJh04exoeJ6GgK6M+2WeJqsMfCW6kRrdRq6j4pn74pc9q3MxexfiL6pLdaAXpjs+wkzvEj9ijjcmiCaj1ZKvnP4zV3Zu20jfdxq120ceAvVuxQPVPAoBYc2oUzwpY0kOBI4Zchm0e+rWGlNRavR8XbEyzxQ+wodHBlMa15ML+M2SiJXwVpPYEGbkaoIyGr1ZGbDq3C14qudBXszydotUvzkF2HDL/h1VexqzGhphqZm3AZ/LEmjyUsfh587SZ4n4gwc7A4kPjqQ7scHsolNstg1aX24MmwWq15tFfqJqcLN6x34WNz4fbsL91tXyI5KRUEDy94/QHO9ndhALTlCAi+0PVVF7FyibkMB8fuIG7RIDgJDex6mvrgzFttWUlM15JfGENunjIaSYAb1nMLKotMMCLOTUa2jqjIe34B4dOYC7th4rdwYigVaxDv3iOwhLcQEpeTSSy/ltuFtKNu7nHCNh0stYpnT0ykpLObixKH4nHJwTXUxR41WtG4Nbft1xJXVgC2njoovFstiV3AA4z74AGN8HD5dulAx50vsubnUrVhNc4byJ3UUrafuF3XNBoy7mIatO/Hp0gN97BU0H6ukQ5sO7HU24zL749QbpLeoUKn3M0Qy/SU1PnYdrZMKc/EG6Np7NrldVCCXs9aG296APWczoU94omvPwIEDyqO5qqpKFr6i4D1x4gSdSaENqrA85O7All9WUVkprN0S2LXXSteuPajUmLmJN9EV7ccc5gkWmHenogD0u1kWsicqj/O0JwFRCqsK96vzUAi4ZsxrSRAUcdU3drlRngOfHPxE+i8/s+0ZHG4HMX4xMt1L0B28nF5B37jQ/U2o4Zk+h/SFs0jJ2YGvcJwo2Au371A/89wDq346gfV0rbTs8o/JRNvsKTcK9ylqULqKsXXF9eG+7c/Iwj3Q4c/z+XcQdWUH6VhA/ytw7vkUXcV+SW8Kj/4RffAkCO5FfZc3cRwoY3SbWWitGploGWr4iGhToaQbWdpcgfVkKI3OiwgYmUj9hnyZmuVF8/FKKQ4Tll5/FpZMdT/PyN1FUW0t7VIgQtf6OyOcuax870Um3v9MCz9aukaIzW9wItQVQ+5WyN0OSYMu+DfK83JY/fkH1FdW0FxXh0tsFgQtKSSU2R98id5olO+nn9YPa1MT6evU/aYw2cKB+BoGZutIPe5DWn4AHQr17NiqeOdC6xEcHUvxhu7ckPQJy8qeJqcuh1nLZ8mi15uu+GeRXlTLZ5sUTeLVyR1I/+Apfo2bQr4+gGmf7EQfPpwov83EVzjkeeHTuTMR99yDvycFTRS2czafZsVRdQ9+dGIHWdze/P1eVqW3UruEJ7w3UfOv4GSjhQ3Owbg0LoYE+PHUynLWh2hJ7x7MY72TCR1iknx408Z8RgcOZ039RjnpSA1qR7v1zeQH1xMZlYDf5gJ57+11z630bteXbgcyOYwBrdPJJVvXsbtTF67oqSadXoTWVlPbYOSg+S84gfyH4e+C9/8HKKuzyGjUNhHKBF8ECuzJqZZK8s2ZFfgFFFITclAmgAmlsxd2i4WFrz6DX1AIGcYxVKQfwDk8jaFh+9BoTCTFT4XcCl5bkYVRf5o6i4PugXbcDjt6jROn2UaTGB9HRkq6w71VbbjZ2JMxOrVYHqyycKBqHYEdevOHsw2dOcDc0xruPLKQMfn7CPz5K/yjbAwMhy5BxQRobdJ5obh5KjtLV3FJ4gBCjNtgwxuUliQSK8Z82nD0laPQR11NTHhPvtr0NBP3uKgaVox/yRgMjVHY/UoJiNzGoICJfHr0DeI9N/yTfjehLwoRTAlOdE9lfJ26iQWMiEfrZ5QG66IwER9eSAuuzuFYLBby81VU8mNry/k+1Y5x4LW4tq5Fry0BC9hDuvDjyUdpdvrLr08WxJLWPwqfkBM01tjpOiSZHuOSOLShAGt5M3qb6qiUD3iVuH2zMDbl4J95GxW2l0VshFx4q/YUYN7xJmasWP3iMMQPo/l75YEcdnVHqYQXj5tTWcOcvBCm6wvw1ViZblIcyZ6JPQkftZl73/uAhx2fk6QtI37DNUoQI8aCV/4Imasgd4ca8/52n/q69BhEeVJ/HFbV4dnzJXgKACl500KutSf2S74jZOc2XBUV2LU9qM1zEOA2YDU4OKo301F08x1wZN4J7LujGRpxOT4OHyLsgWhtQTRbbARFmEkbdZCq9bvwsSgxWOMfK6gZMJDm9oNY9+kumt1KaBdv1ZBjFiW+g1hDEcndehISo8MSuMhTYJsx+FYT2lYlsNUXm4nrX4Lex8WQtjuwNWXg79+fhlqYe/1lvLshh6iYKziSPZ8mS5MQX0sK0H0b7uPj/h+zdu1aWQz99ttv9OvXTxa7DreWNbZUyf4YZcimqqaK+dXLGWvrxmmj6r53cSYS3CeeyqNicQ9CF9WZoEmd5ShTJCUJnNpfToauG23IpX79KbRB4biaq2ja+rMqxFwu6lerjaBfnzRcGn8ZAxyUNJCoHT9REhODJToRTX4mLpMPvjFtKM88RURSCk0H1AJsy96IqdNw3M1i62GXSVf2ol3Yc7ZLamvghAkynvn13a9zX+/7GBIxhKwsJXbR6rTk5CgBjqBuJI68Fff2Xbiaa9ns7kdVZaUshhOio8jMyeXIEcWTzqANnchSVmZNVXByBZxaD52mkOdspEtDDal2O26DL5pB99C45Qh+pzfgzliOpvwkRLS6CHipFiKRTHCtSxpLWtIFxcZEBJ+EmEKotlZLH3Hh+nAhbKg6yj0UMKrPZN4/shHKT6jn5RHtWE/V0HxYFYJ1K3PQ+X7FmUSM5t9ew6dYqeXf1zWws2QnPi4TL+TfQftePeR9Qv3nInSVHqtA0Qoo/0N57HaaQsDoRJoOlcli16zdQKjhHcnnd7n92FPZj1CfKzA7faTnrfDCNSYGYDlWhdZXT+OBMhylTZR9clD6bEu73tGJGBP+8XhfUGS8Hd6CmgycYe2xGXMx2qpwGwNw6nzQN5fjzFjNvCdrGXj5TNqmxqPZ8Yn6BUL0J+4H+75V94Br1XTsXOxa9Iukwxm1DkZG5ODv45Lx1Fa7mEJdT8ToW6GN4p4fWbcSW3MToXEJXNp2IAesP7MjpYwiH19GHonB5XDIMCIhNhMeu4I69PYaRQF6+6qP+DH3MUmNEL7xy6Yuk1NLkWxmLy2Tm8h/hi82q9CNS7rHMklTga2qmCs0C1mWOJAK2mOrGEOoPZjgGd2Jum80uqCAs7j5V3y+QwpjBab1jOOGQclSXPzS1C4ykKZthD8D2oQxsO2/tno8F41OJzen59DscjE0xJ+PT7uwNTi5OsSXyEHtW2gtPmkh8uP26nvY/McOEgIS+HL8V2wr+pqTmzZChthIatjZqZKjFXP5pPtg3A1fY9J0pvvxNfQ9lIlPdHvGDvuYRdkb2J63m5nrM9GXJfJ5+0vOzfj5G2fgb9Ha/2M4nC6mfbJdkue/2ppNemGtLHYFfjtcTFVjA5VmNf7zsfYmzCesRUm+948lFJ44JlNqjPv3EaErIiZViRmaAkZyy/DumPRajhXXyZ2tiMO93mP8HuHTSGiz4ice9cvkoKuZXRp40XEtVrfaB5Wb2ypRh7sdmxpDpN1TRG0dY/L3E5TSLItdl0NYpWkIMKgOX439VjLrj1FuK2JXhbJk0hWvI9atzLDrLL1oO+09Rk0aIUecEZ8t44a1LiZ9cZBjYU7MeWrsVnT6G9wfHiI1fBb4Ku6qaWE5uh0npWo7OU6ZsjckHSZwfCIBQ+OIurenFOn4tA+RFIrQq9rj11s5MGRkncLlclHnMlHrMvHt9hz6DhvLMY1K3bG52lJY+iQ+BEhbMXFhZP9+mi0/HCDfuIXqiD10GB6Jyaxn/Owu9EhVXpKVDhfHcwPQ3PA7Ll0oRm0O4abnMXdVQrjjy7+kj1OZgxumfkjToQrcdhf6SDPG5EDpsyuU9Lde35O3ruxNhz5DZO68d7wuOnWleaeYcfVN3O+8Bwc6dOUeJXiPGWDyhy6XwkVvQe/rodNk9bPtH7SeZMK4XtAeRLEblAjxfcEcSo3/AFbWPELW0TqCb70cV/QQXE0aAuoMOHBS2tGfguImijz8Z1FMCDF//+AehJrsWH1LqA/KIGZwADGTDlDvfouw8u3ysVaDWmhKnn6G2ivG0GfDk0QUreF7fwvtHToiHRp66YrQ6W10uySUqO6rcWvK8DHFMnjwBgzakTQ2BnP6VG/cDq0sdpsa/dAZk7A7qmjfQXXdty5fSEr+KmJP1tK/vD8jS0cyd+RcGTogOoef/tIqlBFF4Nz5quua3LEbpe5ASl2BJFt7Eu4KwKKx85tpn4zhNml9GT19PLbTx6j59XP1/sV1I/zOu1uKXZvFwZb5JymO7IfGP0bIv9VrP74MU8c02vzxO36DFbddwG/gAPz6qPPRUeVPt/Rj6BwOGUjRHN+O5qQOlJp9Wbh5M8cXrcJZbcPtsOGq3cXptHByekUR+/xg3E1rsGdtkBuZgLFj0QUESN6sEIA9tvkx5m2Yp7qdxipOJp5Eq9USEBDADTfcQP8hI9DMXof29q10HnwR4b4+GE4coGTFQnqlJJKamsro0aM5IFrJouAShdLhn9ULEM4Gu7+QlJGrqtTirel+FW6fIGp3G2h2DkAjltsd58fhCgjqwoN9HpSfBxmDGJXZg9pVqhjvGNbxPOFaQX0B7+x9R/JsBRZlqmJtfcUB8nt4xtPbFYVKvN66NXnU6OopaFeLNliHj1NtmGxxM/kuwJ9DFaskx3aHj4mvqSXQ4ctLJXczcMp4yc9uwaGfVBs9cRCaIZ7uudhI5mzFEOYjO3Q+2u2EGgVv2o01cAwlVjGifxBzrfIyD/Ck1wm/a7HpDpqYIm27dKE+MuDBcrwKy4kqyr47IovDfwThoCJihJsdDVRaCxl94+0YB90qKRmayR+g76EaIGlBNVKwvPTNF8n58g71XiUOlP6skg4idkan1kHGyvP/RkMDWXvVVG/mxW3pEVpMO99S2viW0zGonIjCP3DPuwIaKyjOzGDnol/kY/tcPI2JI2cTV65oY26NkynmixgbO4uu1jAG2XSy4zxniypSBV5YmsvL/T+jbVBbKVz0+smXvPgSp8aMofYPxbeV15Hj7IAdISz7/XBxiw+5iACOrm3Ez9nMxNJVmMJUbHFJk/Atn3RWsSvw/rpMWewObhfGinuH8u6VPVqcdK4ZkMRHM3tx/9i0f6vYFXgms5CMRguRRj0fREVh26s2rMEXpVyQwy2626suXcUPE3/gxR0v8pbzp5aflXcwkdvOKcWUV/1xFSVVW2nTtJBJ4yYS/fYbvDZ7HhdHx/L1wKuZP+omxj/xMV+nXSQ3c44Ylfz4N87H3wXv/2NsO1VJYU2zHIe9sOI4t/2iuqsC4uLUB2Wg8ynFRSDFZROksvxwXg03PfoHWxe2jq0dzZuxDqxgJEqQsYkxUsl/58h2LTviRTPakrdGLRoRAVYCGlSHdL9fBi9rHZidTURWFXCr/UEes8+m6dLX6P/ga+y3haLXG9gUNpy7Di/AFGwntI8yJC87Gkj+mjByMdPguEgKNSwFu2WhnF5bQlGzSIHzweU243BF43JdSva69fL/7vnxXfqcCGZ3n8c5GjKNY1vySD85EK3DF5t/EfWJ+9FHdcEw7nkau07APqwdTdcmoR1zJ7GueKz6BkpSvqCkZKn8ffowsywew2/oQvisTnJh8i6GP6xS8ZylInFN2FkdLuLA6VIWNMxilWscJ+1PoHcFMCxAz6Rkf8YFGejqdBF3rE70G3FrHRw9od6bpC5hJIjRpyjMbW7Jh3WGtMN97TJc+mCMmpOEOl7AGLSJzp5Cvyr5YkgaQcMOdcP26yfcIFpvgsG+Rqb2jOPGS4bzzNNP8fjjjzN0qBIL/v7773QKN/Dhw7fiGqk8liX6tlp+yfPF2UxNZ1VguQ//Qt3Jn3EfXQx7v1bEhCmfwL0HpeqbR7OxX/ErDrcP2Qcr2LkiB9O0djT6C/dKF7tDc9lzKFt6akYMVV2XYIMDW9xJsmv343DZlQZZA5tzVuFqeFvSVZwhbtwaN6e7X0OF4NaegY6Zywiqz2WTj53rms0M8lfH8ODBFeTkfCE/T019kiZHEIv2DmX/vkuoyO+Kf6xSUAes86Gz7Wb5ua9vLgZdE4aDhwiuqqKmRk0BxHPI2JXBB6M+oL29PeHN4Tg1TnKDlFhP49Cg0WuYOXmc9NgU25LR+DHB1hOHtjVmOGngcJzHNpB/yy24Kk6B2yZSJWg+VtFyTqX/mkmS1cHAiEj8xzyP1hSAq6EUnX8NSd99hyklhbh338GnWzc5WjV3745v9wjJJ3eUNRPfZRwDdno8QwOCcev0GJ1Ome625OAOqjQNOCvS0d31FIc3lXBofQGZB6uJf+899NHKiq9syBC+//578nJUpLOgChw+omyQ8vzzOMQhrrjpCu6++25CI6NVpHJoCo7AFPKWL8K6bys0Ky74qVVLGdm3lzzvygO7UYc/GrtHvR7lsZTaPQfXjrmMs6nFvLj9LJxVFknNqXdcqh5z6GflDCD8c4WDg9VDfRDcxKTxvDX8Ld4OfB7Xjmo58hdBGELdLnCmcE1Ym32T/o3sXAu/3q2FqoAVmB8QoAId8rZDwT6smTWUFxRxT8pr3Gx4nIfTXmODnxUrRvSFP3FNfQMDLFYsGg0vhIfS1m7nuwIdwy4aJzfJLSg+DLvUBoee18CIx9VrF5vFby+CTwYSUnETYaY30IiTrcfV6G/8EQIjsTibKGvOw2dUFEbRwT0H1Q0lZIQc5EDdevZUrKTBXg0NTkp/8bi3eJB9YK8sLAUa9qj7RW7jMdr1GyjtJYXLC4/lQ5fpqqAVzlQRFvpNniYnd9E1nuM08C4lYA1NgQEegZVwbWhspUMInNi2SabnRSUmEFrk4X4OuIP/j73/Do+rPLe/8c+e3ke992JVN9ly7x0b03snQAiBEEpISEInCRB6CIQeejPNGNx777JlS5bVe5dG0/vMe+29XSDh/L7nnPf7O+8fh3VdAlllNLNn72ev577XvVZoyTPsshUz7NcjhHysef1Bfvb3dfQENViSkimYNIWu7g6mHE9h4okY7lyjJG7RGOK0qRQlziGycxcH6ns53D4iaWVLUy2SS8pdH9exIOUm6c+I2m1vfy8jX8lSk/6/Pi2FO6w93kvZQ+u4+s29NA3I549YEBLviTMKEiTtv2PtWpIcbsJChBiPmkT1PhRCkL6glgOn7BtPo7pzROqYihLBJy4cQ0nq/wvnjB9Bly/ARz3yxuyV0my027ultUhMx9Tm/DBo4/sQbfo+q/+Mje0bpdTClnEK1JPzefSBD7l9nCxtarG3SLMS4nUjBqmIKXni5vE0xIjoD3aPEBIUlNtaUOSfdR36CT/ET5KG/4+x8kiX9P9RyWaOZ2porxqWdmmlqWZqe5yEXTlEIhocKb8kZM3iuY0NJPc5mDr5AwSHh9CxJEJDduJK2xiTImeRr+FcVrhyeSQU5s75hdw8Mxd8bj59+D5CoQhZRhtDpsVcMzKGp6z7qTY0MkKQCc4TJIRGGDXnVr7e3ELK6jYSrHqm+zdxyZFNFLr85EwYwpQiV3P7fEaq+1PJtDkJnLgIZe55BAdrKGluIpoeT1tCDJ+1qZmU8BjNQ/uwh4eoCGxBddhG1cpPMRytojH/BlymDOlDPBntgQDRkXJI2E9/1juobRno/OmwfIShDPlmGM7YgK6qhMi0PsIaFwMD60lNleMpfwwf7muTdWwCXL1wEq4DNrKPfsHOR14h3nQJtb5rqDK3MkkZpiCcCt1utIJManSCirnBMtaoq9i3bx9TpkxBE1BKU/ji49l0SgKOIJ11NrLLR8MNX8K7yxFatpLEVulnXFEzbtfN+F85QrjPIw2vBHLVdHZ2kpEh+53+K8Qkr8zMTGnKvre3l5UrV3LNNdcgzLwLwl7Qx0iG+d9HTe090rEYb1UTZw9i+ehWIoI4Rw2hqbeiGv9D2yrR5i2/IlFqyx/Z2MG+HUdwWGtQaZWEXFHQR4g3FFB83hwaTnawyr8fd9gvafkmDA4Tt3c365YsJoYQTmcS1ph+3AsiWGwLic8uYGXsKLIcA2yxmFlU+ylzuo7wp+Of8UbWLNy+YWZNn8G6hnYi4dcx7ArjIpGq2CL+9N0GZgfbpGOXlXQSpSaCb0hD1nonQ5ufxPi3HNyRVmb0b+WofjIjcXGStq0wN5f6jg5qamqIjY2lYrCCAAFmTJ8h2Yk9/dLThB1h7Cl2DAYDy8emcrzLgxaBVhSs8BQwSd2BLaTjmrdepO+IvMERfTaNMzJx7+pjZGWTdAMbXFFPYr2NRJ1c3RKHsiJ9NVI1NuutN6SqqwilxULOp5+c2dwIGlHakIJ7bw+KmDkkploYG2vhmL2DiooK5k+bxj+ffJJ+g4FvFAeZPiUfe4Oo95SJ5+4vGsl9dAq5Kz5juK6ON3fsIBAIUEEF8ZZ4orosdjjKKVP2os/QgxN29B/mq6NRqauRYtXx5W3TqPrkLYa7OyWNpuh7WrNtEyd3b+fbF//KlY89TXZuHkeOljKL/WBKhuu/gTfnw3Az55yUN5ivhZah7LVypVPuGgWiJVK6m5Za2PePU2fZiyBqchc+KpEu8TjMDk9mcOdZkidWeYvPLf5BhXfQO8iuLtmDem3rWpIMSRKZF2/0on78q44N3F5+Ibrqz4hsfYHhgTt5Nu1dBtRyd6za2cI9SQms7egmLXy2yesgnvt6LmZq+C309BI9eCOErwFzqqzx3fIX2Q4wYRSUXQAqDVzzOWx9Uq78Dpw4O9RadhEs/xtKpYq0P0zh4wfvo7v9BPOiVhK+FwzhGOxn09uv0nxI3nSLMMTq8Xp7mKm6gfAJF7b9bcROyubwmlVseUcm3BMWnU9eQ6GUHtkVaOSCax+Wf1k8lzSnSE3mFNDHSsmHUyoLUR1XoVeGcAsxhOJmc4ZqzXsQGjfJThxf3Cy/NnOa5FRxfKusx51ebkZo6ZePxcLHUIkhIO169m74G0vTT1IxsppG/RLq0nMpd9YQ/cO9hLwezF4Vy2uMTHvkcQzjx+E5vB9lfAFEtbz2bdUZ+cCV02K4+rWj1Pe5eOZrBeaEy+hL+Ixvv36a8qBskRjq66P77X/ymKOIUCQqDZCe88IOMmL1dJyyDrt1dh4jX35FxOGgLxbaU7zk9hgp7VSRWhrhQD28s6tVkiacxstbZInP+WPTyIr/v08IP+sdlqQEU2OM1Fa9R1ZVOQoU7B9Vz+JIMSrFj1Mt8Tx/7aj8fj827TEuLLzwzPfEkBYxwEe8Ju6ecLfkcvNjONHjYNVR2dv7d5lBdn7xPt/z7PkJ38NPhPf/Q9h8QdbWyHq2uQtyqDnUjhCOEjGqOJGuQRiyEw1YUQduRqEtI6qDkw1OJpdsoiTxkBiWRDhbrD5FUarlRf1o/3g2Jf0MfzTKVpuTKQEnez7/mMYDe6RdvEnlZ1GqjXZfJSrVW/z5ZAVrNbmkZBhoF2Zxwu/jpno3l2KShpsYDPCn4BT8tj2kVfRKZFesRjeYyrh/ZDkjs7r4+9ebiE2Sc7wHTZ0MZ2op7RiiIVWDJmhgz4Cc9ibeKfaqO5hg6yWx3YtHn0h/ouwmYLFtBkUOiQNVpOyoov8hCCeEqS99Cq1ejcLgFHtmRCMC7sRq1hY/jm9/EYWT9YzYxYjiCIJoUP8vaBty8/bqvcxSBBBUaqaXZNO44m2CXlnPG/YfpjJOjSvRzjq7kyplC4sjHrI5wrrgdCYwSbKmmq8ex15vHXv37qVSLRNNcXo93aLDtr2L5qp+qfJLxgQCF79DcMVNjIT1tEcziAlci7lTRRgPIU2U9jIXW996VZJYFBcXs2TJEmJizgZJiHrjFStW0NTURFFREYODg9LnBw4ckDSozDuV4PQ9uFwnJbIrHuT+actRVx3A1NuBIhplxKKiSvUlBZ1lZGbIXqzS2yEILL6lnLbjQ2z75jADgRPSeyTKGU7f1d2aLslw/oChBXfAjzViYJ6/nBhvH27HWrLcjbSZR9HYOJnSot3ktVyCJWYqFjtca/ExtHQfRv2lHC7/BbM/eBjzQC/3DMmdCf+ft1F8SQbp3zow7lQRg53D++9lTmEecaYkwhEfcbmyHMS7w4xgdhG1B1B82YFnkYXjibPxR4xoAgFm7NiBpv8b/FMX09pqYOdOucolbiimTpiBs9vHRZdfxO+++h29ml7JHunyiVnkrumQtJSR8nguMcbz2UENf+zZTPBIFQqTiaR77yHmsssgIuBvcEiV2d5nDxH1hQhHo9h0KjIXZPHlx/UYvAoWPfUUqrizHpmnj/P3EbM8X9p4+g/2kZBegbs1wvKlcxg9JwuPPcCEtPM4MnSQHuUI23rr0XptWBWlWBL96NI/ZNfWt5mx4Dl29PdLZFelUxHyhciyZ/PdQAkjUQO7Q7lcbYqnqjvCU1/oCYXktnLbkIefv7GNKXvXSu29c26/R6oapo0qoa+5gZHeHt6+61ZSps9lFxNJMKkpvfwRMMTJFcPv5BCFFaFZPBG6ikk1fVycfEr7KnYygvcQV3gIbZZets4Tdb8jbZKsxrHHiTs4l4gzIB1zUecqtuzFYdP8IXnYT9TwBsNBKVAkHA2f2UyIbg+nXR1WnFxBt7ub31sjtKelEPXsx6L5C4dMjWgVWl6acB/7Nt5Pq0ogLRzGJQ7MTbmau5MWE/zKzCivCrciFp32CSlOGPHj+yhYINuYaU5Vac0psPwF2RqtZRtoLWBJh6SSH1gAFlROobv+hBR521lzjFAoSDTio6P2BCF/UIp6z584mfK58+l0/RqPY5iG9aMYpZ/OyOcNHD+ymf2bz2psbXtaUSQUYw8Nsuj+u7Am/TBZcajLxf5VLYwVJpPGWpzv30GpUq5s7u9N4Pgf15NRkkHFoiyyR6fCRa/DG/Pk4ULxQ7yuii+jr7lbem5ZnlPHofImMZpT+lT0w3186yEmRvtIFka4RtjEP1nMMctodDY/UxwHpPSz8/7yvDTYJq2LWWYC7U56c6azqV98DwXyGrayqq4aIeMEqsHFkve2c7ACveEAK5ybJQGNeeECnBs28s+NdXQXZZNq1VGUYmbryQHJF1dEYqyLI45PsK9aQT7w5hIFg2anRHjzuo0cnyRe9/NZX9srSSAyYg0c77JLA2niW/XLueJv/d+FWBj5tFeu7i6LU6FfE5TI7h7TUR5reg13YkgaNv9XiOf184eexxPyMDphNOcXyBHGpyFWda8avJeqk8eZWiIHX3TWDUudntGz08kqkwn986f00eM0OiKpM1n09Yc/Ed7/AEL0P+ME/RP+W3A4HFitVux2OxbLD1so/f4gc/aeYNgbJKXVQ6QshpEtXSg8YYIlVhRJraQf3E6v+3yM0QDzwnXsGV9MyBzDY8Y7MQoe3G4DRqO863W79IxUm+muy+HoorvYkqnl+oFm0r/9SMojF5Fo8LM4qQaN6gYGw00U6mQ91xH3cnY5b5AULlkagfEGFWpFLUrVG8TQz2DwSfzeIOkxv0ZFlDcnXcHNS19j2XsP0B5dyUNrc5ia/VuiQR/x16birD7A8F/+SlChYE9hOi6dhgSHC5tJIKwwIiYZ56l0nLCOwRydQVBXx5aUV3j8/TDqU7KtngvCRBed1XAFPUoa6magMIQoLpYrP8eqFzAykkpKaj2XX/YAsbGlPxhQ2NEwIO18c0aqyFTamTRpMo59W+mqqyEsaFFGRXcEgZ/lHUaR4ONIWhqHemYScpioVJ3gqGoi8e4k5gbPtuZDQpBANIJfCBFN9+NIMnN0s7joeVl+ewbJo4r48MMPzwzIiSiKyaGiPwNX1Ms2RSNOhYeo8my6j0qlYsKECVKFb7ivi8ZN71JltxAR9bpKJXPnzpUGr8Sfu/XWW0lMTPy3c6229j56er8kMXEJY0a/LD/XgVpc1a/QrO/A5juOQqFl6pSN6HSytlqEWGXevn079ad8ZU9DJNais4F47k6cOJGDBw9KHPiiQBkxwTgEpYbWhHdxlu/h0MHzCIW0CKIdUDiTCeFs0LhR++MIqR0MzH2fitn/xF9dR+9DD+MxmGnsGKRoWG7D+7RaThYVYXK7KBbyiRYv4RPjQalVWZjSjjV+L8pPjGhvGibr7RIGbT1snj+PQMCISa1mqqqD+E+qiYSG6XhQyaHGCwmHtUwqLian5iSKOgFNTI6og6BTN0KVtZ3Z4xaQJaTj3NwhRXX+IUXgw1/PwFF1lG4xwCESIe2ll2gIFkha3Snn50nDZgP/EMMIJHtd9rlDTP7FGGmjs/rVahoPHCR/XCoLbpqF1vDvLe3vY+tHJ/Hs7WG0XgwxERgIRjjqDaMWBGaYFCgEgS2B/TSb3eIqzZgcI7HZHxGJOgiHlbiclVRXyxPukUkRdrXvItdzIRv7ZW9SEWqlQPBUdXNUko4pCR/xSd25BCIaKm0HuX16OnOuOyuLESu+6179G90na4moNbgLxkj63/vvvx+NSGaCXmzvXsGaVgUPhq8lHNVKJOK7hEQsA350JXGSNlWVbCDl7lPVqGiU6PoHEfa8JFl8DQYfxh+pkIa2Em8bi3Nrh/QeKOO1XJx2F86QU2rdvnr0VWmwSbQdXB9zlpCuv3g937V8x4uHX/zR4/rQ5D9y6bZXoOcoUWsGgr2T3sJ5JFy5QqqyOTa1S8Ot2nwrCReZEI5/AXWrIBQAawbkzoKpt4vTfvxXIUbhipuFH0NCbiLn3vGolCjW2/sNNbV3o9EkgicTy/oLiFdlYQ8MsrH7fcoWzCevohLXR23EqVJQTrGSesG/T96vfKFK6iwlq+u5IO5BVILceQtElLzWMIlARJwDEN//KPGZuVQuP59R5n7U9d8iDl9E69dJmuu9g5lY0nIpDYhhPlq4pxaM8ibG5g4w79mtXO3/jN+oVzAUMPDuyExetVxFEBU3RvZz+503/yAy2Lm9E/vqFv4QsrFdpWSsysnLIVkW1R84ye8L32HAcwnDA4Vo43agSf6OZLtAbFYhMz/v5bXku3Gr9Txz6VgurkinptvBt43ree/EWyi0fQiKEEIkyk3rI7y5WH6fLt5eiNkdkEIvhOSn2NdipyDJxLOXjpESHLtGfCwdncIrV/94lfT/DfaMuLiwqhGTUsF9qgMs+SZfXLlZMXMXbw9+SHl8OR+fe1afK2rS/7T3T1IEsjMgb1A+WPoBYxLGcODbFnweeb1prhpg07tyV1O8zsSo+tpdPUQjsq/zrCtGoSw0c86LO6S1+UaHlviIgrnTHZRdd+GP8o7/7fipwvs/ALES9E5dD09/cZzRObF8eEUFvznZwbA4AaRV0ltkRtnmQO0Jo1T5CCt0jK5ZxawaDx+lO3CoLYzYnVz5zVvETbdjLPfgtJto+jQDVUqYtXMu4phhLHe0vIg66KBk93r0iX6S6o9IRdrMFCOz0npJ8R4hHI3hgD+HSdrTLUcYZ1yF2VzLSHQZ2f4AJuVedEp5SlmERXiNgLFSIrs+RQFX5DxO80gz3cgDBoMl5VLHNeRvZ4vZT+aUAtRKJepwmHHt3XwxTcnHC8IEVQJzDwlkDhjoNMVhYIr0+z3lq2lWC7z86zgy9AG+CnjRawRuHtSSn1ZIuzue2kMCmmgaAU8AzUAqeYk9JCU2MDKSQm/PKN54+wsuv8QoyQBe2NTI3zbJk/Ymwc8s3RBjxq5Hr/qClr5klGoLesPF+NzbiER62FFYiSnrGFGFh/L4TVRVLWWbd4IoiMSv7sbCBtzKc3H7Mzmq7KBG2SFpW/WNIyj2tKK33IyAgW1ffIM3LelM/KyIqePnkGLKp6l+mM76YbTesWiFKHmTrYxdkM66DWtpa2uT5BLixwJ2sJyDFCmL+U59LXbvoER08/PzpSrvF198wU033SQR4TVr1tDV1YXRqMHnayMp2UJ21i1nL+7EUmLm/53x0SiHq65mZGQfTc3PkptzB3sP/woiWg7tz8XtkrWrarWaYDDImDFjWLp0qbRZ27Bhg0R2RSQmNTFs+QDd58vQF19ChuN8moU9TLOvo9m/kM44PcdVHTQb6iku3E9p/c3onFno6grZ7F2IilxcP48hPt5NfNCN59UIHe5ijpeXETpVHcr1T6VfsEtkV0RrXxYpjc3Ezvah0UHbjW4OHziXQEAgJmJkmbMCPbMIzZqFd93jJL8XZVb2SnSdOqxb6tCOvQpFztlFPzuSQLatALZEcCJvSvYJYXb3eth6rJOshx6QyK5h0VI2VsXQ23xq4CYK0y4uwLo0D/uuLvZ2unFqlGSUyAOVBmsrLt1eag7YqNv5MqOmzGDJbXeh1slDTCIa9u9moK2V4unnUruzW7pxjTk/j8jmdhJRsECtkNYKpSDQ7WlisG8butxifDoj3a5azGEntdVzsDnORq0WF5v50LeJPt0AXrtYvYqwJLGTnmgWRwflY6iO286i1EbGJx9Bq3TyxrHrORg7gdDkFL5p+oblecvlZLu0DK549CkOr17JlvfeRBkR9dzypigvLw/Ueh403823ITem2DpyDZM51mVn24CT5WiwLs2VKraiE0Gwz4062Sjdqb0pv4JwNQblNhIMTxE693NUo8cjKAXMszKk+OLwkJ85qgpWxW2TBu9E+YI6ouKWvosZUNmoMtVRkVRBqimVS0ddyv7ufUTavCwYjpKo2MSx+EwSp93FJd1NEtlFF4MQkKuCKZPvkIa8RJjnZqJOMaDNtSIY1DD7PvnjvwmPpwWdTowR1xCbms7yu+9nsKMdpTZIZ8/bhIIu1IYQMbkt6GJlQtrRKYdBpKdfTXbWTeyOLMO0/R6smgSWjLqFrHlT8OztRaNKkaZsEuf+e5iNaPMnkl2RCOUuW0K1p4I8YRO6zu/YcdxHICK+3rMFg6GOZta+8jzrFUrSS8oonj4bRUeEcu96piR0QODUBn3cVWfIrogXNtZj8wTZn3g+IddK4jUe7klax3Wa4yx2PMCXphls+rgJl+8kz1w2lrlFSRgnpbBzayvbPUqpw3SvL15iGtFImCRNEa/W/5YLs8VhtULUg6UISd/Sa1bR0ZzMwZyLiYb0ZHh7md2Yx0hHE8lWga86n0Gp9zCqM4I6oqAmS+DNJac2JUELh3UVzHbvZVSbkaSF/dT3mWjsd3HRP0RXBtm71uuzSxrg01af/78gSnxO7NxK8bRZlMycg1L1H3snf9wj2+otT7QSWt+DklG4UkJcN+8W3lvxqZRKKHYuTluwPbnvyTPR66IF382jb2Zs4liOburgwHfyEGfXSRuuYblQFZtiwNbroWaHLFsQk0dH+jxs++gke2Pka7wgoCA+Knc4j/f9e0HkJ8j4ifD+D2D5tkN0HAtgdno4cMzLxM5WnDkxqDvF/nGE4Lg4lE3yTk8Vt4lLD+hI6HNJKTbjHIfYHj+XQzETGSOcIL1IJlMDe8QWuIIuzaXk1Rfyxnn59C28hK1fvY3Rto9T6Y5Miu9gekwrCq9YbBFoD12LQfVPFEKE5uAMrEvPIXbDA+RHRG/Dv4leURLEqNsmRz755mYMmiMIyATS61+I+72TNCS0YozVUZRRyphWWZbwct5u1u3cL1VS3n34V6SNKGisMLKm5okzWfMnRvkkwut19KKzRtDFt7Ff3wIhBZpaLYnmJCxF9QyFlTwnuls1NZDksTMzKg9wHUg8gDFW9BLtIT3DhrOzisFQKR6njn/+858EVQa2e1O4pHAnybE5qB055MSux2weEmcIGHVRK+76Cjy+GozWFtRpXWj1PqkOohL0oPJSVr6Z2trZDEeTuOHc5Vi+/Yj61Co2dl6Mz392sMkXZ2TsvHZcdQcYaZ5NjycZb0+3RI5UQTPpqnE0ronQeOrYnfbyFRM/m/c6GGoKkjvKyEBnoxSXGzEYGS16pAoQdGaicZRi0ndLTg1XX301r776qqTn/e677yQXB1HicBaldHSUMjx0lAsuyJXIqqgPe+vYW1xZfCWFBfdz4OCF9PZ+TU/veoRTmtBx46pxu2bi8cyivr4Vs8nE2Dx5wnzcuDI2iH6bEZG3RMjKriakj9K2fCN5nTPQeFNIaricvoVRztm9gPbAAJtVVXgCeqpqZ6DJ+ZbyE7/E2DOFHkM1ba0ZhNGiVrkpKumlffJMHCOyhln0OxUrgLXKDoY0vdLfFI+juGEb8I/GeaiB0oIIx+rKcCNgiqo5JzAehWGIiDcBlT4TRUw22sY2tI0hBKMB3bybEJRqXKERasN1JHTZSBnpQ2XJwJ+QilGjJtTbglZMrlOXsv/Rp0lpbAJrHFui83E1DRDyrCYS9nJ4/aWk5FnJm5nO4U4Xg60uiisTUCoVkgRlX/1hAolpBGOTMDQfp37vThwDfVz4u4cxWGOkSfjVLz1LKOCn4WAf0chYqTKcPi+TYyPHCe91kKBKQ4nASKBfkgGpzWFyJ23haPW5DA5m4t+7GGdIvpmplH6ssb1orHtp7VcRcoyj2xbBoHKzrPwlButiMEcuw5XSSFP8Fg6HI5SJDhsph9nWOZ16WwH3rHufqHWzFCM7J3OO9LhiyMz2hCY+WdDBtJ5U4iLpkq2ZSHjFgbetJ2TLpOJsJ3OSkmXCS4gL4i2oEw3oCmMl9wH3/l5JuhHxBBlZ1UIkeBeaOB8q+z7UG66H7A0Qm4NCp5IrvZva+fnRSxhSjbDbclR6LlOdY7FaYrmt7zLe4AtumyBXT61aK89oHsTR3IbK5CE5spb5HfXg8sKOU2lYomPJrheIGhMJZY6RrAyldS0awJFwAMGtQBtMxGwejUIcfhPlYB1DqMQ2hb4PT9BzJiY5Egnh83Wh12edkaeIEqqGxifo6HibmJhJlGj+hjrJKG10CiYF2bd/GTGmTkymEtTqWGy23Rw7fgdJSUtxOKoQBDXp6VeiVBpIG3UevZ6XyDx0P8aAiaHXZUtCMZYy9qJCVNZ/9yU+ulHujuRXJDFhiRg6koOtJ53XfntQOsdOQ1AoUKhKCAfEDk6QSCRMR0219CHClZTN5Lg2nMZ8KL0Qy5JTYQ2iq0m/iw/2yX/n53NL+fRvoxkT00lJjIuEQBe3GnfyF/cyRjxyt+pXH1Xx5S+nUZBo4hVDWCqCLBc0UjfP52oiYXE2jo3DqPVx3NQbx7OEcCniefH1WH63+Fz8XrmTJqgcaLLXYT+Sgy6q4au4TXiSPcQ7BB7+KIIyEuG5CxTsL5YJnm9wPm0xowna9hHr0rDzm4+wRW5AGRU3bCLFkd+zLQ1e7vtkLc9eueTfZEan4XZ3sP2D16ndLGuP26qr2L3iI5becS8Zpf9ul9fk8bGqXx7gLhE6mNI/Tvo8dXYRVn08szJmSWEbXzd+LQWyiFXdNa1rpFS2l+e/LAXyiNZ8vc12SZ8vQgwGGu6WN2vJuRYuvLeC7Z/WU7e7h4lLc5h4Tg4H17Sy/9sWasVkPyWM1ek5/9axfPNCFe21p6MufsK/4ifC+z+AmXs2UKPIpRq5rWOz6dE5bDxqfodWVxZv7JgrRimhVnuJ0x3BOhiDgILORA9lgyepskzAqbbQWJlGhboax4CRzuhMvPNn0uY1UWLSEn3vBImRGBJi9AyOeMk1DjMtsQ2zTsu68AImRcZLQRKfWpq4P1BLKKqhJ+9e4t159Pvj0Ct2oVNWSZHrNd4JnHBXYI9mM0f1CmWGDehx40fgE0uEc2xhygZzeNhxFyVLpsCWdlnnGVMveWqKxv938xk3zriR5w89K73m87JmkOHdhCLBS19VDKISIxJo4nDmRgZF26mogvR+He6eIFf6x+BeXMRXA5skX9UpNrkS7Al0UXEEZsy8GsFWRzA4TMXUMQy4v2J4MJ2WjrFiqiRzNU3MyNqKUhnGrzei1brPEk5VFHPpIczI2lARYou4tXUckyfejs3xe/T6PiZMkKvXJ4dO0JZ2M43+/RLZ1Wg85OQcpqlhOuGIGr/fTFzpKkI+A4NB2V7IMlKG1h8vUUpRVpyQ4wTjegyJ9Uxf8Cy2tlTJzso+4GWkV4PKHSVGO0yGshurzo0nbGKP81rpsfTeFCZ3foDjgJKchDhq2z0cOXK2+p6kr8ecbsNmS8M2nCnFyX7wwQeSBdUzG5+hu6GbF4+/yG2zbkMTnUJA2CuR3RFHApGQhri4biLRE9TXiy3JKNGT+/j6wFbm3jEVR+QT0lNL6OoqJcHSSuonXkauAyHXR7/pYzKq7iamcy4xvYLkF2oOhNH1HEVTnoY7mMSxoUzyhBH20UnzqU2RyGSDISPHjy2U/iW2J/PzDmJQCVTXTaZe2SPlyIs3qQmKJA5F+/HHJYDfwcEteQSMCagVIZZ6pyEaZTRNfpzkE9di6Z2KbeqldLSvIdYIWWnzEFDjtNZzwHiIbo+OaouF9NZ0Ko58huE4nD4riqrhvrELmF0ru4dUZ1yMyw/R4NeEA/JQadhfzaZ3dRhjx0utxpD/GA273yd33J1s2n8A7ylhWFSlQiiahbbjIN3t7Xz82B+5/skXpMGg00RksHULWmsKE88Zzbp/vCBVk0ToVEYKMidS37OP3MoJpFb4cEQ+xGruxu5Mk8luNEqhNZuBY2vQF3TQItlghWBkkvQYi3O2YFB7SSsMMH7POrrdPpri4VhYwYPdei7KW0hF0nGJ8LpthRism/m47mOJ8Ip2Y/duvVcKBhA3vm2xfcQNpbPr8C5mzprNHR8dxuUTEJQOpubHMDcpBpFeHiJEq7uDxOA4TNPTzhBesZrqWN8mOTioEi0of/4ZvHcu9B2D1+fC7N/CxJtQJ8juKoaKJO5/6yaeEN5kn+k459nmEHN5AaMOm3msOgXNLiPRsqgUuiHKIKRrbdl4hBMLZT/e72TLM3JmEa1bI9GcQU0C1bumYNGMJylzER2t7+EPn+3AGI2FlJe/zns792MJ/Ym1TgVHRfNZ4N0l7zI2oZQjR25kaGQ/8QnnUVr8GNFBOycOPsCIeYf0cyMj+2mqfYW4gYUk3TGOgdBqPJ4m1Op4xo2VXVq27FyM291AS4ssxUhOWoZWI1dSRV19e/sbtEz7HUXDzxOqjUoBGPHXlKDNO6vtF918RHeZvTX9jD/qlTTY4xaclRIc2yKfY6KWNhQIoFCpJE/czNJRdDeNJuCU7eXGLV5GR80x7P29HPSU8q1tDNagHcWhfYSPfsaHrjjSdBoEs0aqiC4oSUZxYAO9XgPh6HzSDcmSJdv1wY2Yim8md0YWL25uYG/zMDe8vR+9RknToBstEW4S/xvykXTbDCxlBfSsfxUzcSz1z+UTWujSFvLy+AvxeYskqduMoJ/63GcZ0Pl5RfEJE+Iq+DgoS++u7J1PYJKD74y1GGLjwZlMMOLn6qzzuKwwlSff2cLYwUYmN/sYY/gMpddBly6duAQbuoowb1Rfw5fVkGD8mj+cfyGRiJ8jR28mFLIzKvNRwp4A3330OwaOyUWNomnT6aytxTk0wJdPPcplD/6ZlIKzw4gjwRA37a9h2bcfEBsN40xSEBO6EK8uQPpoWW8tDqGJhFdMF7y+7Hr+vFf0aEfy05+RLrskiZKpdW8cl5JSCyYkMf2SAta/WYNjyMeCG0pRqhTMvbqYWZeNQqmWSX7lslz0JVaefn0PKoXAH+6fQpxFR8HEZI7u+Cla+D/CT4T3fwjeU6XTJO2w5D063tvK1b6d0jvgCBr4lHkoYjdSWadDE1bQH+NjQoGW1Avq6Ks5yJc989jSMp+ZCYfZtmsqGwxToUkkBiKhgAIiXKh+hSuS9uGLV6FTFeII/QGbfzQ5AnijAq7RcUwZ+IdECqvdSwknZki2QEQz6WtLQOgvkbLP9xbJk6LKkJc97uUU6bdJ+rA96mT2hkKYnGFmmxSUBNIYersHUTpvC0W5rPphrnhkIj/bej3N9maeOvCU9DizM2YyT3kAdHKLLWDKJuDpwBU9yHaDvKtN92WSUzKOhNQ0Zl51A1qDgV9HHmTX7l1sbt2MEAyQ1NyLENXiWF9F/jnz6On5HHOSAnuXj9T0JhLjWzl+fL5kOxUOqyTCe5rshr0KBE1Ekub5HclEXAkY0jKprg7isCcQiWr4un0jevMkCkftQa93olL5UQX30uNppKtXJmjF6VVYU1rwuS20d42hubGS2MFxxBV/Bd2lKMIaDIISQT+MKfUYcSVr0BjFcrvcempq/gsTJnxMfLqWDx/eBEorutgbUOiU9HocHItE6FZMwB897SGpoMc1l7Idf6CT6yEkVqHlyzbJWEPRhMPS5ynJDei5hX3VKgYGBnj5lZfRuXTkkSdN6oskWBnJJjtnkIigoq29An9YSV/BNvK7x0qPobEPkD2xEe+gluHA21K7NCmjlq7heGa9cxCFX8lQrpX4OcO4E+voKXuTxKarUflki5xDgxsorJzMSXEaPT8Bt8PA+vARBrVhSd+bW7iXpMR2GhomMzSYLb03o3OPkRafRor9JtojuxhRSNsENFE7Op+fFE0yvYoRfGmntKnRKDOUqViieoYyNhBRexhJ2ykR3iRDFtsqJpLoM1EcHE1ECDFQ/hbpxj7SogJHqs6hO9PKhgIrU+ocxKlnUaGOQb1jJfOOynZ+fUkT6Esox+n5FF2gTxrmiYTDREOH8XvH8tUzhwl4Goh6t2HWlvDR518REsNbwiHi/R6G9FZcOIgUjsXj9eIJ+Nn79WfU7ZCHhASFmWjESdj3NZ88/Jk0SCoOW6YUFEpWVMfFoSixM3PeJfR5noFByE4UqD7lsjQ1dzyVseX8SrGT6lg3KrdAJGrB55FjlMvtAVRKK+jszPrZIpSRPPT+l9nu7MAWVvBx00YqrbIeNOzNJhIysbt7N3XDdRLZbXe2E6PMJqFnKTNsejyqDrzOKFe9voYD7QIKRQhj6mcs230n+v4asqMCbUKUrwc6aPvTAywWZRzpcrjG8Gf1+OvlVpNYqRSMVtnx4P2LoL9G9oc+tgJu2iBpZsXqsLUijQcP34pX4cdstkgG/aLFl7dmSIps9jfZce/vkbysRR9r/bhE0FwuE14RagO0bpfIbgQtTbniULASR6AKR5NctVP5YlD54gnG9kskdPvu5STh4e82DUPhs4OvLx5+gbvTtLzZWsUel575jjVM6dqMS/BSHVYwOaAidngsqpRDDI76DNPAeGpeOUjX9BfQKSA762ZUQSvtvS7+tPd2ZqXvID8+QGVODHl5d5/5OxpNPKmpl9LV9QFN+X8kZ+KvScxYjNos68DF4auXNjXyxeFOyblgnkeNAhU96ggDmiiis7M4iiPai4kQya4pLp7xS85jx0f/pK95M3rrDYT8JUQCJ+htauTyR56UnCNeqReoTSwlAS8JzjbqnKJEJ4rd6xfbeVJ87z3T0tnwkBwLP7pgDrplU4l8+wZa+lhYv4sDWS1Ekr/F2LOMbrnYiVIRRZP4FU1d6YydM0ciu50nbexzxDJPaUeri+OC3jpeToF6syzZOC83kQtMZnoarufJ3DfYELuXDdG90j0yzZ/A4vD5qDJU3BSMsiZez6qGPsqSzfysOYSiupkHc69ihfE1tG396MWwFFEi5W2FDoFLfvZb1IYjvLw3nzf2qJhVdIQ07Q6p8q51ZjKyqgt8BoY7RPlThIS5wxwb7eD6OQ+w5dVX6B1u4p3HH6Dlyp+hN1YjxnLUeAuZtPJbkgdPbaA6YY3qTcbPOg/hVEqbSGpF7/wh3xDzV8yXvib++47xd5x5/6vWt+Oy+bEk6Jh7bTEanYqL7psgEeDTPsHSMT1Fdk9jR7t8bU0rSJDIroiKRZkcWHPKzeMn/Bt+Irz/AxCrpl1h2SDm0sKvGBNfQ8U+OY1KxMOq92lS63AHqsnui5P0oQUmM6nlx0ER4ZzyldT6MqizjeLFg/cyaJBP7tzUEQpHUqny9jBP+yBGYUj6WyHFaAb8D1GNgjEImKMQUIlJRfXcNiI6GgjUhc6h4vCA1DYODRwifPAzHAl6vhntZ3xXKj59GpuKVtKVaGFUy9VMMH5N3+B9TArlIZoQDepUJPnDxLvlaki/+D+/gpbdI7ww9wUpL90VdPHLcb9koclHW9s69PpstnZPxOwTq1HvoPENMGUkC/xppI5YsfuGSC8q4ZMVKySx/aJFi9i1XZ621w50kVlcdiZoo3CubEPW27fyzKC0ShdmTMVGFAqZXEYiCulz8Zg0rcskodiFKc+Nw5FEWoKG3fut+HwaqYVf09hESKnC44mh9dg5+FQ6MjK2k5Z+Em0SRLpVDJviOWiew3yaSc+upbuvSKr6Jla+hzWpiUxVhFBIQ37+O9JAilabgtMpLrxRfHY1GmMIu+MAWz+8k6LGrVwb72Sl7XHs4XT8Ei+3sD1wduilstLGgQMWWv2VHHFdQGluMzaligRnP5pIEGNeB/aIRtL5KZRR/LzOrFk3sWmTDofTI3ZEEZyDRK0B1MpYgkE9ze2ym4YIjQIsHWMJBGMkwqbu66LHnkjJlU3SMfX06hBOqli05SR9eiPHixJR9IZIM56H3/0Orsz9jFr0IAdfWM1wXwcUm6meFqa1b5gcWy+h+DQGxdamOO0dysV62EhsjIFYdR+d+gHKtIswHZGDMsQOQakyk90K2X80OGTjnxkdPO74I7VCJ3XKbtwKH+MCheT7s4kogtiy5QSz4/52UrVDaPzxzKCUhKBsO9QU8tDbMIvk0ftB2UZK4gkaXTMIWpL55yI3eX2dOE5MoNxqItXuwq9S0Fg2m3rVYXJH+vApdFzx4J/Y+LcncA0PEWNtwT6sxKPZz+TEixglZGOONHMkchJdZyOTLriEIyegOXyIsDcsDa5ENVp2bN6MZrgPQalDY7qCkOdjQpI3bZTYtDTm3/hLUjOL+O71p2k+fIDMsjEk5WVzYrsc4rHggjuJrxokOOCh6KARDz1cbZjOSetR/KoAoSF5w5IVcTK25H4Uhr9jc36LNddFft58HDsfYLbJx0DCL3nq6HsccFaj0M0k4sskPTydHtU6bll/ixRxmqRPwdh7H1VDLkR6mBqIYQAloXZBOp/mDq1lsXscplM+1OcIGl7Fz25dLEl1G3j33tuYMeNqUkg5Q3ZFTaeomT3jeHDrdqh6H9Y/KEf+nvgGyuRNtnVZnhQPbnALUiiLOJyjtGqlx3Dv6cH2RT1hm1/qUsecl4/X24Yiexw60WLLMyhOtxJV6HAEzuPk+BO4TT2YhyahtifhTWrA2FNGbPtiFGEtIdMIVRNewKBp5f1BrUR245QR5pvUrHQqOdxfxQuuEIc8suRhvUPNXkVICq8RcXI4jpcbf0G37gl8Mc10jH0Jy9BodIoeQiET2qqp9Bw8gCIcQRdN46O6S6Xf+2LMNPR6Wft9GjnZtzIwsA6fr5O6nvtot7/GmNH/oNuVyOWv72XYLet/l1stFNk8RMK97DbEsPaf+3n1mgmkBfpwDsqhQ2JwjaglTs4roGbrBmkYMSFrD073TPYYrYzYzdTf/kv6lXHUJsvT/4PoGTTL1nDLTB7G6tLY2NtHRSRE+/PvEooEsGoTGf3rC1BZtNBzJRx4A9Rf8VC7Hb84MJfWgnpoJkp9ByrzcVD66R49nZnFkwgHI5Lm1K1PxGs7iDF1KjMNOcjjtZBg0vDYDeMRjgxgPz6Ojr4lvJ+yBk0wSmUDXFFrQVWmhGCUiFrB0w2yD/TjaYkoqmRfYf2gn+sUNzCY2kmbq5YcUzn10b209zZwZPUOfnPvHzje+zrbWjO47/NjPDz1Dcz2fDKr7kMR1NHpPSnpfQ0qK6/k3kNbII7tTQ7uTz6fY4rPSBzspOCdVzhcPgWP3sDk+q+IHxnErxHINhUzPNKKK2Rjx+Z3Odn9MXNvuoa0jPO4vPhyKVZbep8tOfxxyh8lGZEIkege2SDLRqZfXCiR3dP4Ptn9MYgJdiIWlcphNiK8zjaI/NCD+Cf8Lye8jzzyCI8++ugPvibaP4lZ8yJETd69997LJ598gt/vZ/HixbzyyiskJ589sf4r6I8Y8Sg0KAlTnlzLqBYnibjpicQzpDJQHungbcM/WG0toL9QTziUTf6MXUQVETT94yT92Y3lH/HIrgcYCMvVNKuhiQt9NpZ7U3BrniNNkIXzIlExcgSbciO/Cc/gc8GMJSqgCcE1fd9I7/hQqIIpunQ0vgjRiAPv3n8STUzmhevVHFf1sir6HaoI0pBZnC6MqfJpvtt8NYNDdkJKD15jJweNEZb4Ra9B+aLsC8kks2pDGzcumMGX530p2a1k6M3s3jNP+l5K7G9JW2nGrfSLYmWE0DDjj2ViNefQNXgQV8DH/i8+xpNdRNhgprOjA7/YmvN7GTe+giW3/Zr1r7/EsU3rOPTlEdLm6wiHz5raizhNdnt7CujomMS0LAe1e4/h7jOQWnkFBw+0Eg5raO70EAhoUKsDLLp4CWP7+vjmqy8ItncS7h0gsyKWEXsSKakNmM2DnFCa2TeYJ1XcssblU5jURLxKgVs3KJFd6fWlNOA6nk/buiIu+s0r9Ay9gdMp+42G3Cq87XHElfVS3vcJiWKZXQVXJtzFYDAXQRWgxzuava5rCEW15I5NYNJN8zjZ/RyOrjF0lfqw5lRz2iJfrO3bTwuuxb2GS4fW5MPhfIte/Q2stFUwxVlFpa2F4hlNqExR2ttH09UpJ1qpwj6CggGrSHaBtMQacmfVEPIqpSp4OCjQujmdkF2FgI2GrCSigkDYrqH+m41kzFBg0l/IW4/+keiQm6Aywtdx3bhPhkU5McZUPckH1QQCQRIFC+PCuSg0eaftZE+Je8Q3TEDQKol6QyR5lAjGIIgbj3MSODZ4iJ3Rw8y3T2ZsOAcfAQzIZKMvsZqw1o5nMB9lx60Mxewnpe8csqUKFQS0Cjr8EOgrYSjSTVxFG4lJ7Qz0KMl259IY00xrYjuOY19yNCuRYZuZIaMKte4QhUMD0vHdHj+dIo+JiedexNb33mC4czXu9AJUhhzy/fLgWEkojcb2r4lEAqhGZ3Iw/AF7XduxBGO5Pec26nedJBCfgto2gFJVht4cx/xfPcZQ+wl0aTU46/cTXdtG/7CLOfOvo3DSNHLGVmAbOUAk4kWjSUJrKOBL96v84ti5kq5fxBjPKJ5qu5eN9iOs0ZTiF2CUL45933RgSs8kYzoMDGyQEsPEa8RoyGbBmHswGgt4cNeDEiEJ+DJR9JaywGqXNtliYIjVfiXvdbvEdGbJiaJHNA4W1xvBS7Z1NxPa7VRaZeJWNbSJVJ0ChWkCHep4DOVT8Rzfw7at73Je/h3oI0YUZrWUMvYDKFUw8UYpwldKANz1Nyi9QFq8lEY18deWSql+phlnY2YtczJxH+iVya5Ioien4jacoGqfKP2JkDttHjmbvpSOTrdhGp2FdlyxPezxmKiKerimp4TKxkuk340sycJ7dBB9D6Ts/B1PFDxNi6KXAm8Bs7RhxlhqGIjGs9UBhzzyLTI2MpmQtgZH0IUiKqCIqulQD/NV6k6sTTeQOu5PENPMUIw85JjSsphQixyGIo5W3RvUcSQKnyi9PL2ujjlFSWw92c/YjBgunZhJQVIaU6dsoKv7E9ra3sDjaWTPvot54/gNDLsLKEkx87vKHE583ITPs1Gq1OYnLmKDK59LXt3DNa7NnKbQc6+/RbKZE1M8HXN+xuYN21H0hGmPV2APy9KiNkOWNFAm4vq8RKzNDtZF7GQP7mTMyBDZ4yYwuUMerDqV68iEc06RXekf10uEN0Y4jDGSxmjrRKbFT+G4+igH1fU4Qn4mmaYR/TyHT4UDJGVbpEErg0VD/OJyvDu9ZFjSGKUYoj6i5r7FRWjanAx+Ix+/iY1pjP8mRKIdtCEwTI1DYdUSsfulYW+R/l9YnoL1qHzfO+kLY9Q7sWh9fJm0F4UhzISOdEq8M2mnQbLlbHxpM08sWcQ5H+2jxxXH74/8kb/aYhFCWlyJLo4r9kA/9GWU0KaRrQWrYtVcNTMWdeA6LtzyJRltdUw8Jm9ERQS1MCf5UrKUuQSTQxzTf0NDVT39dQE2vPUsRYtf4tqx77AkZ4kk9zOIHYjvYd+qZkLBCKkFVnLHnR0W/D+h1+6T0lPF+/33Ce+JU52kn/Dj+F9JeEWUlZVJVk+nIU7Cn8bdd98tDQaJXqji8M8dd9zBRRddxK5dsh3WfxXdEatUhZtkOMaYpmFSe+VFe3NkGoGoQKGyE4snTElON4mFQyjDhzB4Qrg9yWw9cB03lguYT/Tzm4idx4mnFCVPeIqJ9+iJUb1IrqIRe9TAVYE/8iBHmaL9DKvqMx5ylmAxWPALom4yQKpWXsCILpOoUr3aRdo3jxEJhziYdQ1R+xbiTUGGdEMET3VP7s65n3GVBXg7Gxlod4IySkAzQrfHR4Oil6JIKgFVFLvaD2EtAW+Y1a8e47w7ZfH+t7seY3/beCqtCWzfYMY94ies9OKLj0Ft9zMYb6Zf7wNLGUq3A21/J4a+Dty5pQwNDooMFrN7hDnXPig93vTLrqFu13Z665vJnmjFb/ahCURxhmLR6OUFoLs1l4a2qUQFJdvWDaALmDGVFXGkSZxyFV95lEBAXniSk+s5Wn01fn8vo8f7MUwpo+odC6a0I6Sme3ANG/l2YBH73HL1Q8TXxy7kKnMfkdYZlC3965mva7Ve7P5xeIf2cWD/uSj00qSg1KI3pXmZ3NWNeh9og2FCCoH2iutILZ6PYeXNmJ0BkoxtGFOrOWZexqzLfsfJxudImvQm1uFcjMl1sgdxbzm6uFYUiiC6sI/AqcCdgeYygp4Rsic3s204l6igYI9lAvocBWOtdQTdSryHPZSM/Y7YPCchr4ITK0vxWDIxJnnILT2GQmxDmmQdct/ORIy9YWxGDfWpst+jIdmPZ0CDrdGMrVFsQ8qDL25diJMzVCQkZFBqSOK2sbdJAz/1OfWS3njemOmwb4Q+1RAbRjYzoTkNaySWYX8P2klxlC9fwtd/+RMD3U0YVCqW3PEbiidPQrVby3PR9/g4fg33T7yfaSlT+NuuF6nrq6XGdIK5fUlkH7mWkD2WWk2AJFMAIapgKHM9nTGbSEseIhoWaFiZjblYjdoQ5MobJ1JzTE1VUxXDumFO5gc5l4ks/tVvePt3v2YANUpjDJpYIyd1hZJm8vUrF7Pv689wCCrCRjNloVSUp0Iq9YKOkfJkVqfu491dP5ffDAEcGhtPdz3NuISxpA+lE4hLwqqZwAX3jMdqVGNpiWD/JoLVKw9jinBtaafgV5Xo4mLobtgqfc2oOocV337NrOpSzH4DbnOA19O/5Of151Pky6QrmsLHgleSjExPiSFWp6K7qYxoWI3P10FHp+xfWzTqYWlQR/T6zGmLZ6QjxPW4qfckM+yRq6uZKPgWeW26TuXBZ19HuzeOuJQMzMphyt2lFGXOQoWaPm8r9Y6DzFh6HbNGEiWvVGflxVy4eK40nLe9ew3qtCUsXDZO0qP+KCbdArtehO7Dshdu9jT5OsqxnkmnEgfGFAqVVOU1TUrFtbsbhRj9PVnN0erbiUaDGN0h4g6vQAiFsFlV1I05KpHnLU4VK0fEDXAzj2T+gzt7rqIiOouL1h7HisDrGLFpOySyawwaGds7FrEj36v1sSCxiT1OPf6oQNBRzlNLnyQjYuebLz9ksms0X1b0ssrxCp8kfMtrcz7lxdV/YWHKl6QYd4PPgqttHoPhMP5AlDF6FSUqJe2OEPNVar5sHpb0riLE/7+2vRmzTiX5ziZbxpBpfZoUXuW9miUMemUS5PAGOb6yFQIOnEINbmuA0v5daGdNYufxFmIG5M6I2B0Yu2ipRIh+9fFhOabeJG9yRdOGuKgXXUhFt1reyIxOtfCzLjGwXMtN51fyyfsrcdmGOb5lgyS1McXG4RweJCY2hTGXLj3z1nkMRfSo48kPDnGVPcKsvuswO7WcExlN1KjAfUMs+98cxilS0yj0t8rhJDMuLSR+XBytXzyBOmMufzbEM7A0m/6uVm5o0pOTr6ZUpyOyq5ySwptJqczENC4d7ahy+v4mD/MlhGGsSs0NHjXaiAcfYayXf8mIZzUD0SgruwySgOymy+4kYZuBUGAUqoF6Xuneytyv9SiKM+CIHduAiVsIMkrw0JPwNVdWDUvb6W/GyZKfX9b7eSdPjUelwCrouMpwAbbJ/2DIHo/BnIQ/3YBQpyDLn4vH2Itn3iaM/g3kpRhpXp3FcF0sXaldxMT+g9KSJ//t9G840EfdqeRN0QHmPxqk+1eIw6O/F8XIoh47M0ZKVD0tZanf+9/jKP9b8L+W8IoEV0yx+leI3nVvvfUWH330EfPmyZVJcfq/pKRECh0Qk7b+qxiK6pmmOM470WfR9Mot3v2MpUElptFAdaCCSuUh4tsVdFt0TDzZT6ItwHFjNtlxG3ivzUxA0DLe2Mh3gV6swRvFBiZK2jGpNkican2wkppoLr+MpLEzshazYpCFpla8kVxqbYNYDbspFpwE/SbctiQGHWuJqVlN1O9j7fRzacvTM6FZ4FDWEEOnDstUtQ77+ho+XmPC0S8ToTkXj2PXSi0jhhMc0jRhCmppopcBay8mRS56TwYdtcPU7+9Fn7adP64uxR6ewEdRKA04yTWBRleDSUgieNqgX7SNUSgIm6x4dQaMDdVoejvwpWQiBHwUjZ1DIBLhq48/loayzGnZ0FxH3WYNY2aH6G4t54ijEqPSydXGTzjQW8QKYQxeQQupFcTjZH64EYMQpsVdhDonk8vLwTXcRneolid3LebiwlVkmHvw+GuYcetVDDj2MeyJ4aUD99B+Ko74vPzVrGudR104iwNd+aRm7kZjapKO/9BQJgkJHRhyqzC6x6DQ1SMMKck/4sM+NspAgpbWDBPlDaLllsDuSbEENd/R0v4djDMTNxikuMVFT6YDS/wKth9ahRYfohuOKlnuPAy1pHNyeDa1h28mKailVHCTe85DqLRuSrP2UX10Njv3JmDzx6IUwoSjSjYPjye+pY3c/jqGYiuwH2uhLPkgFnOI4uW1BByNmNM90lvwpSORWzN+ycEPP2f8hmZGDAE8FUr8Ng36NC/vj+sjY0BP5ZEEFEElESFKf3KYq8fcQ5Y5G+v8HJSnK0CiI8aoUdKHhOJ0LF0uktbF4V8W5LPXH5J0h6yBvetXSDpZERl5+ZRPmSYt/n+a/idMahMf1X3EH08+wi/1v+Rdz6eoLCpJKpNtySa/dCwb3zyB3T2aTf43SZ7chTani9PBm4IqSu6iQZLTzmN45Au+PfoAMyd+xDzbPD73fE59ppOiCZfT1NGJM7sIm2BHGzGTkJeAqu04OxrG4IkoOefW37Lpu210RWyM1xRKJXZ1ipFgr5vZwel8pdwlGcXPzZzLuXEX8fyWl2mLreGg+SBHDUdJTEgkNfNr6mq28PN9y9C7NahJIKIMEhjVQqjfh2loDF0frMayNJPwLi3Gnie4zmtE7GGoMFGAi6B2J32RvShTI/yq60qOamVJUYYixDX3yh6jb/1mB67eUszpsttBeuzVxFllYu1vdxC/IUo8SkoFJbXRMP2SR4lY3JLfgyR9Ox9lvcLFIxMYvVf043YykpJMq2KAyYwiqohyzLMTvdnC2IVLubTZKRHezw+1Urn4GKoLsvnbgUrskQiPf3KAi0+mc8eiEikE4AcwJcG4K+HQO3KV9xThFREMOjhZ/zADA2spLn6C1JQLsCzIkrS7nhQP+44uQ6XyMKomQobNLvnJhhUCJ3MTJbn8jvYCVqrkOOkC4yga3fW8kPYBCs9O1OpiEtVz+UCroV+Qh1PnD8qR3CIaGyZTrnew2DEBR1BgtusCRu0dwHt8kPOjc9GPSeBPF5xP+5pdHB04ynv1f+Otnz3LF09l0DS8jGhIQ8gnEkq525SpiRCrFD3OFbj9UZJCAgkpBu5IiWOTz8fXzYM4fSGcPheePg8L0fA813DKaEdCl91Hlfkks6yH6W0NkmTXsTlhNMdODDHbU39KsyygWHiDZCO2/O87GXD6MWlVXDcli4YDm1DZ6xkxHqYn1cek5lsIpBfzWGoCyp5BgslK2i12Uktn07DrKwSFmvN/cz/5EyZLch6NwXDGmqu7YYT331+DOynKY4NwjT2ETXq9opNjFJU7gm6FF2dfAK1RxbxrS6ha30Z8hpmCiUkMdbazKXqcuaFJpLqMHPlmB4/PKCVgOk34okybHcPsI5MIdUAoOxXXuw0QjOCNRtELAi+F9CiaZcGwo2Qldu93UrEj1FFJistDt7mF50f+iXPeLRxOmM1VK+tJbj/GnbPPwaczkZfcTrjHz6AQRz1qrA1LUAc/xGUw052cQdHgMSr6fWzT7qUvsZxrO/x85ZvAPP/NXPizcdTHdLD680+4xn+O5M3eN+YlAn55wHXMjOtJNqSy5/OP6NyRSjS0heyMLozmsx2LY1s7JecF8dIrm5lGymnJj3Q7DDIyIjrwRImLk8/LPU1DvLK1kTSrnsYBl+Qzr1Mr+N2Ss4WY5sP78XvcmMQh35/wo/hfGTwhShqefvppqXqr0+mYOnUqTzzxBFlZWWzevJn58+djs9l+kH6VnZ3NXXfdJVV//yOI8gfx4/vBE6Iv7KX3PMw7plcwCH5GjBo2O6+ijxzywskcUjVjFfq4nfeIRAWaQ9dQoH7/zGNsYAa7kO1xRMw+to2ZZZ30B17AoFxPjPoduvzjcQd+w60qJS1ChEeVK7le/SmtkUw+CNxNua+b86zPSVZkm4YspG04a61Vn5nL7b99jMvXf8rNq77FdmWI78Yq6AspuDgmIOk8w0Et7p4xaIM3sfSWhdTt7WHju7XEj/XRMnyUuLg4SQYyMmIj2V1GxJmASudkpHQd/2he9qPHKlXhpFjZy6ycRHJq4knUwjfaw1IUrK6rmWBMolRNE6u+ak0OUZMH/6kADYPLhbajnpA4OmBJwJ6eg4IolyQ0srbXwEuh84ieqsCdRqLSR5ZXzSGN7N04KTeOB5eVcvlrOxFddfItIV6+qJ6u7ldxBoxsbp/FxtZ5eCJa1NEIM1I38bOMjXxhm8XXTcuIUXq5tvx94g3DbOg4nwbbKG4d/RzZ5k6aV/+Zypj3KA3uwR7Opko7DdUMedLYfHQUiTNH0+z44kePiy0kYFZGpWEREeLVORKw8F7tJVQPyFXzU9/hKqeWHP0gOQsfR6n2o/QLPLf/l1R7i5iXuZ0YrZ0vG5dLPz1Re4RyIUhCWQJF48zQ+VcUUfl4itjZmcjnUTePVPye8ptelGI7H558I+fdci6err/yT+9B/EqNlOU+ylKASWVEoVaT1RiLb1Wn9BiCTim1r40Tks8MbZyGqD8dePUoEXdICiZwTPWy6vl/r3pc/uhTZBSXnf29SJBrVl9zJnJWxC2jb+HOijvP/NvnDmIf8FC3cxNRhZsG4xp6vU109oQ5t3QEgzrKAY+OSoNPtFbmc08hj037K+d/dy3eaISycAxBZxLdhm5cGheWgIULO89lT+JeDvdfyDPnzGXcmha0ASVuZQBjWENUJ/DW5LVct30emqiakfkq8spL0adYJLJ+cG0L/9z9AUfSN+PQDaIP6clyZTHOXo4iLKbuRVBb+7hk+RQKCq9loHkr3rdCkrb0NN7GL338GwQ/cQnN5A8VcCAikxBDygpW3fAgGbYE2v5ZgyPajZC/AfPwRAwDxaiSDCT+rJzB92qlgTKRtCmX5bC/ZScdLX8mFFXSpb6OFQ0HUcbs4faKm7gh/2o2vf0Paqv24M0olxwolHofjgQXD1z8iGSn5PYforn1c276Zi6uU9rp01ALQYJR+flplQK3zyvk57Py0Km/F+ow2AB/nyh/ft03kDeboaEd1NX9AZ9f9h1VKPRMnvQtBoMYsx5i49q5KHXdFDS5ye6SZyGGQlNx6ebQOO0N6d+1Hg2vDymp6FzMlN5zWVO6hmb9WgSxFC5KeDQZ3Dn5Du7fcT/qqIobWq5iWHCji6rxCUE0qLjYNxmjJO44i1CinpQbytDF6zk5fJIrvr1C8gy+3XI/4XWpaA0qKRDg8Lp2gv4Qk5bnkRIM4fy2hcOaKA/4XDgUUa5KsvLL/qgk59EtysaWqMXeaqdjWwdPhj1i6DGxCi/TMr8ioImwoeEayXLugoynid+STL0xn3VJi6TnpA97ub7jPU4aizhZsISrp2Tz9LqT5MQbeOfGSWTGCuzeM5d65zAv9MuvJ21Yy4W11zM9sYD9yiY6lUOSrEUkzbpeMIdLueKhJSRmnh6e5YyjwPt/3MMXmS8xaK1hW3sv+miIXv9fOOYpoycYYbZZJXlJH/OEJSsy0VHgNNwjNj564F4cA/0Ux03BmjaXmyYZsGsEKuwjmGhgn6VSkujM6Q3yZLUP1SmG4olEOSKGvZiUKAUFkWgUd1Ij3WOfxGDKoqzsBfatENhQv5nVZV8yknQnIU0uymiUe1a9Dt0dbJ2ymKAxgYWbPpQes1+TwBepFxBSqClx1mGI6eXwRAPTdR08OPl3XL/6Oob7KgkMLoCoWjobHhbUmPRtjPEUSjp97ZJkVOPsOB3VqFRmaQBRtK378i8P03ZMdtRR61RYEtIkBw2vSyy2hBGUCeRXjGPxrYvpG/oMu70Ke98Aw70NKPV2NKYg48a/QXz8XClcoq73rDbXrFXx9o2VVObESZaHYrjUxjdflmYAyhYu45xbfvlT8MSP4H8l4RUN+10ul6TbFUMCRD2vaOB//PhxVq1aJVk6fZ+4nk6eEhOvnnpKdh74z2qDRdjvN2PRCgzGqunn19QE5tMRrcU5soawLgFlJJWb+JgMcZmLyjrcACo0kpIQ1oUnsjEwFaNehSoY5PxgE/5wBaONX6FV1DIU+AXeyLnUEeZW3Bhxs0t7J2bBiy+qRineXIUwwbKLeXvczfyjxU9WVy+Tj1cxGBdLUnsbF2zbRiA7wuB9IQaHsrAP5JFXslV6Lv19uXR1FzNqVA3Tpj5EQsJcAt4Qap2SYbcfszbMnt2P4HRtQIVCInzRsJbvjF5q1TAvzsIN543i+c+30O5WMBw1ED2lRZxZEM/vLDHEHB5gl9DECW2rXD08HbkmnqSRCHmNTXhnzWThnDl4b7sNu93G7oJ06WBp9bHM/tndfDig4pMDsl3RRap9/EbxId8wl7+Hz8MVPnuT1aoU+EMRyYBctN05jfPCAplj3+fNE5fiP0U8EqMRznfqiY0oQAgTP+ltnmw9lxH/2c3QaYxNOc6dY14nHNDj7h5N8OQEBuwV0veSxn1C3KhNRMUpcEX0zI33NAZDEK/8QVIpAVc8I2Edfzp8B+6gEQURis1tiPWsLmcOKSonN4WUKNVDpEx4n6Dewb3bHicUUXO9933yE9vYwFx2uKYjEGGhup4n7rqB+Ph4gkHRyuwQB9a+TsijxT59AU8ffoZL6uO47It+lGlpHHzicWqCq/mmaaX0fJ6Y+QTn5p175vmF3UH6nj1IxBNCYdEQcciDNQqjCt2oOCK+EFF/GGWsDn/TCOGRs9dUwk3lrPr0WdpP3RA0eoNULZx1tZj490OIjh+Xr7ocX9gnVXW/OO8LybD9/4Qh7xCfHbqfUYHNkh51JKIm/nsJdytH1GxxnjWUT/YkU2YrI6Dyc9fwxaJjMH+ybuEczxQmB89uEkXsTq/hccvL3NN9LQvtZwcBdUWxxF1dIhH+I980oQqH2NT5HTab44z+9vsI6PwUlGcyLs+LtX0c2q0aoooQI4kHuMGWz1BAhyHtc/6x/F4+OljDhmMeIoHTSm5ZH/ozQc3xjFeZkT2DC/ZPIRo4e+18HxGVgCIUlTYmKfdORGmWq3JHjt/DUP9KGnwKXh7QsSxvGU/MeOJMizUQ8vPqe39juN0NMd14s7cxPe8qCrV6vvu2HZ/PhD+1j83dM+h1J0rXdomyj6XZm/AEBb6un0OXXq5unVMWyz+unSZV95ua/srA4CayjlaT3uMlYozn2PRJDPpkf+mgO4mQz4g+vgWzaSyFJa+xef0TxMSuJHHAz5gTMgHo9f+WUHQW3eWv4kzbe+b1vtlnIXn3ExQGNUSIcsQ0hNZ0gpb4g4RVfongDeoGuST3EoJb5fNikXsyB/THsSncJGBh7pTlqLv9dB8bpDMQwS620xdkMuMSOUTgb4f/xhvH3kAfMHP50d9z7rWVFE2WW2TiaxSPYe+gg3v+vpI9vtgz656IFzAwERVtmm48hPk0aGbjqfCAWF2IQMZfUagd0pCxp+leIsEERvu3UDI4xJdp5xESNAjRiCRfMiesRKuJZbB7FnFGjTTk9sRFo7lyUhYd7e9S1/AYL/TpaD+tVRPXu5ZKzNF8ieCLCAkhVFEVPqWPnmgrV6U+IEWPS+dONMLdW+6mvqeJuPZcqtO2ohJUbDVUYD3+OfXemdSmPE7JtFSaPz7JaJ1CqvYm/boCQ5rpDNn98slH6G9pIjY1jcn3/5mrjnTQp1VQ4h7hPt0daBVejoUm8YzqN4QEJZkjYe5q8lPaG+C4qRpz6VrMehfKoBFlrJNAtEfaEFVO/JKtniTebu1noGGEjngxwVGDEHZgGXyRssZuph+LJ2wxgj+A0h8ky1LG4cuX07P7CFvdOWcWX3FtFjdlcQYtSdYIVW3yuiV2FEIhg9QWfxA988XpmlIT6deMk4Yr/xVel5ftK56mftdOAs6z8xb/CoVWgz8mRnJFUgyJ0g/5sdTGIGUXh4kb/TEXvrJf8hU+PyOCMbOAqyZnUZJqoa+5kY8f/A3hkMwVRFz08JPklY3+ifD+CP5XEt5/xcjIiFTBfe6559Dr9f9twvsfVXhFwttvTmY4r5iDfb/nsTFyJaS4tYdrv32PDakVzEyo4Xa+kr4eRuDN8FIsRLlSuVr6WiiqYHNkFruV41AFxPZHAX/QXC+RoPuzPiTOEYexw09fqJOOYJBp+mYuN76LRSFrp1aGp/FO6iUcKK4gdOrCVkZCzO3YwWWNK0jQD+AtieLT6Tm4/wKiYl5M0S7i4jo5eOBCyX1ApfYxduw6xo69E7/mEp7fWM/qY71MTKnnF6P/Lq0Xdp8FR+MVtHbr+IA8Qih468Ic2hqP0N7QgJoAvqiKI6FMTkRSpNeVo/HwcCCRdEJ8rNst1RlExCbEYu8bJKJUMn3HTjLiMtHrjXj3b5Lsh2qSTbTFm6WG7J6kJRwy5oonNAuGNlPsrCdF5+TKBYlsyHyWX609Lg06/HJ0JlMqU7nxnQMS2Y0NCxRFVOxVB9FGIKAQb4MCGfp+0uMO8fSFl7LlyzXENsdiD2aiMA0Snfw5m3umcqB3PM6gkeLYRslBQ6v089zsP6BTyTeQgCuB9s0PocwR2Bm/knPMzSRY5KGMaERB167bmHxhBl2Dv5cqj/vr47ha00FLrmxH5LVl8GHnHPb0TCLd1M35OND0lDE89498efS3uIImrLowLq+SlEgUvWGIRn8CGcYeLupqxKtNY2xJMS/32TnhNRCvDrH/0fN+NGlINNpfuGIBf3zNRm6/Et+Fd2GN5vGP5M9YG7uLX479JbeNu00+P50BibyKekpPVb+UXJV0x3hce7px7egifIr4/itUCXrUGSa8RwYkYujJD+L6uk08I8i4spKEyv845/675u9489ibPDLtESmV6PsQ7Xv2tw6zvqaPOKOayyozSTKfrcztPHA5fudBEpPOp89+jIC3WbKNChvGsn6gB4/Tj7q7gliXHIIhQkxxWxgcgymqk/S64lnxZuwqMoUpLIzL4lruwqZ2kBCM4fqB8ykK5ZLhSxL3RATTlLiMPmIaVRxWNlOlktOTUiIxFIRT0Mc1sTtxK8NtE9CGdRSO2k1KShONDjPrezNISE1hQtzF/OW7CCjdXDDvAOVJRfy96u+EImEskfHo3QuIhGJ4SJFCYY+85oQkm30lqmwLNSdtxCoFMqamYiiNp+/DWrSneHBnjI5xvxqHzqgmHAnzi7WXc4m2SuoqtBgv4vqJf0GtPLsRcDiOsXPnHezfP1cKIJk0+QvUah91dTMZHBBDD8BsFsjIGEVt7Uk0Oj1Bv1x51evt6PqaGC6M4d22y6WN15rbc0m1hDh46GLpZxThKJMOj2D0hhmMU3OsKBZD9wK6axbSpuxn1MxX0Rpkcqv3hEnv9ZHe7UMVidKWocfl+TXe/hJG5vwWQRGm2hnHGPMw9pCOh7Y+zByfQLEnTtpweAyduE9dgyLcKjcTRk2mrvY4qoCZ+OHxFFpDHDAexB8JUFY6mqFd8YT9EfRWNQ7PEEHzAIa0ALPnzKawuJBz3juPAWU3paGJvHf9q2iUGja1b5LkDsdbTGw9kixpqiUkjmDyD+JyFJCkUnL1hCbesL2Nt/N6wh75/K8ocNOoeI6o0k2lYzTDmhFOeFPw914srdnhU6lxal0zWdF+mvxTEFQjWPJfwt54D4SNaJVhvrnZRWH2ZezeOoftziF2deSR78wjJmygWztEvC8efVhPQPCyNW0H0WiI6b3TMUWsBBQBwm4N9999H7EpRlYd+Zw/HP1hMeeyUZfxYPZyeH02UYUG7jmBYEqg7fggzg9OIJYEdMVxxF9fKpHcr5/5E66hQXRmC5MfeIKbuhz0BcJkhAZ4UPEYvroUktO6CVt7qaKCv3M3PkG+V2aGulim/IIOstkoLCaBQR6J3o8BL2Wlz1OlnMVNx1vlO4e40fCEiQ2NkNzzPF5VL14hyuVbk9EG5cKHymTklodfwZAlzye8/vkmVjW4afZqcP/LhlF0J3ny4jEsH5PGrz8+wLoTQxIlfXRBEdctKDjzc4fahul3+FlSniJtdNa+doymI70UnPsAAZcLV/d0uutKUIW0FFbE4nY10FpdhSJ0dhMuXQ96AwQDkoeyLs7HwVHXsKUvkVGuehYPbJJS8hb94k7UGi1f/OUhWo8elsl6NErehEnM/8VdUvf6p2jhf8dPhPcUKisrWbBgAQsXLvxvSxr+FSLhFU+8Oe+/RVriAHMO5fN4ZS4B1Q9z2mMcLswtfeyw3YpOCPJq+qU8UnAHqcM2nju2kULWk4GYlAN7ohN433wuyvQAL518guPGAhZMfEv6njIc4YZvv+TK9V8xElPM0VEz+fiSHHIamtnTV4BolBRO0zMqp5WwRs1JXxFRo+hXG+F8PudiVtBYM4meIdkXMajykpHSQ3X7GBrDCaQqHCRph2g3qjjYP16SYJzGRbnbUERjWNlaJg07ZArDNEUSsAg+LtQc+0HlUkQcNmZFdnB74E66SJQ0eIvQMEa3jgHkNprB5SSjs5v64iLSOruYuVO2KJNe6+IriSmppGrb23ymz2ZT0lyp2rFwYDNF7rPJZtaUn+H3x+AQIghWNb/6wxgpyWdbk4ZXV9RQOQgFmdU8G4hn4NSAyERLB9cWfoopXraLyezyMqrJTcBgpPGcq+gf3kAgFORv9ZPo0HRx/+gynl0zkUFvLLeNeRtB10CRVsCkd1Ht0vC2TXy/BXKUKjLds6TXmj9oQNuxiPgyFX25t9DeN4fDvWOoTD3MrIw96FV+6fF+v/MhIlElD0x+hkS3leH6hWTNeY7d3RN56/h1P3reXVH0BeM9BoLuBGJydtF5ciHPu4vxo+TVaypYUp4q/ZwYbSt6morPzTg5hY/euY+KZzagnfwLNElyZUckes5lekpnVkoVK9fOLuyrWyTt2Wkk/nwM2jxZgxYNR6XggWCPC4VJg6BRSJP1EXcQ06x0oqGoVBUWf19yZ/Cfvbnoy+OJu7JEipz9z0CcQv/ycBd/29xAp+2szZ9GqeDqKVmSZEW09unu+ZwTJ36H2VRGZeVK7t5yFzs7N5Ggy+AyxQw6a31EImJwdoROUyejnAV4hQDqqJLzA5XERI3s0h3nTzmvEAkkMD2jgj0D66W/NSF5Ai32ZqyRQRbrLIwNJiGoPZj7KnG3T2KdRtbRziCbxJSTOC2N+JIjWCxGYjLvY9WuTxkT8ymKUxX/dzqTORJ14uu8jqCzFHXcTnTJsv2aiFnxs7g+5XomTZSDJsKuAPb1bTgOdKGKKqkzttKy1EPclgp6G52kF8Vgs7ejsIcZq4yVhmQPusV3VfQEFhDMQd4peJTzUuxMMXpRRsaSV3A1Hd0vkp52FRkZV7N//3l4fe1UH12O3R6DKqkRo9KPvUe81iMS+T09BCri5ptvxu128+WXH+D3i+d+hMzMGr4YmkbtcDFLc7dxU8UQI86tmExlUkiDweFiYtWIOBNLGCP1kRl8oRhFCNFTPMyEyZ+S2B9gTIPtjFjJZcpiZ2lY8t3u9caTYe7ipC2XN5yD3J/mQuuN40TdOfi9AgnWbBSdyQxaDkrVSnEy3692SXKU08gwlGPyZzHU5cKUE6DVv0865/XudLKs5WhKejh2rPrseabRsGzm5Xyxchtfl79IVIhImzExCW5753YiISPuxj9CVIFgVJAe56GjMBM/CnS7O0DUvQoRouL//GLnx4c+431URtn1Jbc3iUtqRzEn5QqO6Jr4ndeEV2GUiM28eDPxwhY0LgUr/GMIoEZQ2okz9TFkH4Uh5gAZWSu4MDGbTmcrnrpFWAP/3pVyqB1sS91GQBlgwclruLDiHNbVf4A6YCAoBEkLjSZOOcLb1rfojfORNqDDqw0TVsErU55n7PjZ8NosKc7Zr0vikHkhWefdT7I2gb4XD0tWH6pFcXzyzkP4xU1UWg5pRaX8I6uc5qiCzGgbD6tfxtl5BSdPtpMYsZCjDXLU2IHg1zJsNbE6czZDhlPzHt/DhVYnv4/pY09nMveFjAQEBZVDXQwf6acrlMTM4V2Ms1fTqUtjZcq5TLPtZLxdlkYNZ57PLXdfTk762dhx6XqKRGnpcvDqxgY+Pylbny0fm0p5mlWKqxfdNfQaBZ8fkvW6o5JNdAy5iNcp6PVEJZ/kqUWJLJmSifNvJ6RhUmvuDpInvM+J2jkMD2cQa9VzwUXFfPVVEyM2O9ZwE+qRQdTaXAbUZkI6g+Q7b2w9QTAc5e2s6wkqNNyiOoSh+ZA07yA6uVSedwkrHv+D5BV+4/OvYY6Pl3TWp3nHT4T33/ET4RUXTpdL0u+KkoTrr7+exMREPv74Yy6+WK5AnDx5kuLiYvbs2fNfGlo7feIlrtqBwni2JTpmqBafOwtDUEVdhgafVl7C7zvyNuMUdbymvZOSZj0JTtH+5tTvGFYx0/K29PkWcyVRlcA8235eMF3GM7HXkp42TJtOrrYUjDTwM99TrDRdxz7TLKa0NzNgd9PV/e+LhqgTckzNluyhlvTtJLd2gKhCQKFUEAlH6Amb2RgcRfhfNLEiKpKOkqAfYn3bPERVokhTglKT9SwmqVooVck+iUpCmPHgUJiZbtjHfNceeojj16p72O+SjfOT8DFPU0NM1M2ib9bi1hnZdM4iaeGYvWMLyd39OM8J41weRqk0EaOYyG2fz6ZHH8/y4S3Mm7Yeg7mE2i8TiYRayQ2lkhVOwjjlXIy6EUb2/wW6Bwjfcx+7V+ciCCEuS/8F+3SZ/MlxO5flBCj0PYM12kemTrzZqVD134wq2of1oslSZGk47GPI5WTOs4fwBML8+cJy2oc9vLatmZzkLrKLd6IN9nKxsUmqmn0zEkub43rqmxLxBGUyb4oMsXCoDaWmkDWpA7hPBQeI0CsDLEvex7AyyuaOWeREgzy4+F6pKhxwJaG19NKvGs1De8oI+9Kx0MPorgABQYc1ycvFs79GpThLJCNhFe9teYQdEQsFBjX/LFdy5EiE/KgOy6nigv7iAjpfeBirehyqlNH4BD/BLBXmNqVU4jCMSZQIsveo7PWptGoQtCoMYxKwLJCjiP+zGHy3Bt8JeUpdk21BnWqULKfEm6N5TgbWJWc1fyG7n2CPWwog+H7bcGfDII+sqpHiT0WIU+6LSlNoGXRxuF22g3pkeSk3TM8lEBhix07xuo0wfdoOfBj4xae/IL0zHfOp98Ni7WPcJDM9tdlUNhWxSnsAp+CXJDqlkVQ+H7eBDncHI5GzNnjKqJlHc2+nqfNrnBE1roCR8cnVJBvk8/3o8bk4xBtcTpjyrI/+7TgYTddhsUbo6foAUVkjvjynK5lHe/XYmn8tXTGG3OeIFwKkWFLIUeSQ0TuMRuNj+blPkZFxtiJd01LNJ+v+yVrtDnwKP+c4ryb7+CT08Y1kznkWhTJEKKKgxmnEt/0+rF550yPiZOJ+ZlwaR1z/s1Ly3fchpoUFg0MoFDoC/uvZs+eUr9wpTJo9HsH/Fvv3jZWioXNzR8jMWofVOp5AQEHVYQX9/fK53alSsdE1HrPaydOzH5YS805DEdajHhqhvClITFDWljdEs3gicj2pCg9TwsOco3pPWmeayMRbciWbNDP47EAncUoXN4x/l5iYPt5qmkO98ihz/KMx92dIz+k0RImYKBUrSIsjNjiLptouRuKOElHKHYkbr1+OkgCrX/QRFYbQl26juUuuAOp1arw+MSREQONJRDD48YnhKJF4ai3jqSkOo3P1E+PqxqFqxq3cQWzgXpoaYohY1FyrOILa5yGg0rCheAKd6ljUx2woXPIxiKoF4jM8FPa8QUNmHxaXmiX7EtFEVUwYdy5tTUeoDgRpN+VytSYXt8FBvUqe8K8KpnE0fHYgSnq+2f9AZZCH9sqHyymyFxFQhIgYixjnjyWi3sdJXQs7zCcYEALMTbmUv864H61BzcBAD39+4wlig/GECBIYqmHNxCaEiMAVey8nQdmBc6gTlUbLhb97CIWzEev6X2OOylX4Q/pZjL9vJc6N7VIinivi4PPIJkKms+TSpdGxr2QUv4l5ikzhAb7Zejb58t8gRInoNLgVOtzp2YyZNoPHW0SVM5TWH6Euf7TUBcxvPcGMzev4LO1iSeZhCAe5yebgE6uZAbUGU8jFxT1f067PYEvCHLRRuDE+nsnpMbiG/bhsPrptXr5ReGlTy13GH0OsQc30ggS+rT6b2PeviBhVTNdHmBNwEhebQMfQdhzfu7TUGg8jfiudgoVZZauYVTqasrJnpUKbKK0U4+TtHa20DivYlDiX2IiNpxY8Tqrxd2x+7TtCfj8qtYZQMMCY+UtY+POzQRaDgy0kJub9RHh/BP8rCe9vfvMbli9fLlVtu7u7efjhhyX7pNraWons3nbbbaxevZp33nlHCkD41a9+Jf3e7t1n/ff+K4T37vtXs3Gmnn59DAmBYdxKHV6lgYLOAfJ6oriMOnaXWrC4QyytslHYdXaRduoElKZmHEE7HmUfT6rfkPS4p3G5/0Ga3Km8tO8Z9pZM4qXLr8OjM6L29xJSxxNVqPnF6k9JZIih/Ajb+ypp9J6+UYqPoyQ2b5CewrGkDTtZXL2V9kA6rmAMYe0wdeEkRNOa3GAnHrOJPl8MaQo7E9VtFBecZI1mNn1H9PSfSgZLEavAgpPqcJpou89q9QNsUM1lMBpDTEBP2YQvUcQO0ueFmq4c1mf+hg5tMvc1reKrpkl0ijpVXxeLGvfyfsFCVIS41mhjWD0stUMLVEfR5PrYlzSBE8oc2vtTcR5RYAx6eX/t47judhPMi9Lz1RX09R8lxhtiQdq1KGPkCM6I30ngxEr6CxcypI5HxU6WmJ85U4EORVIYCv4WjaIeq+oDhoP34ovIQ4OqeBXaUYkYxiWhyTLz6rZmnlpbJ0U7Pry8jAdXHpcmZw8+sJDVx3rYXvV3lud+xYcnLmF7lzxtm2Low+ESfZl/qAlVC36W5h7lQN9Eut0/3FyUBgLcM/sBBLNMBMJ+I0WJ/2S36ghtG/eiPtgrVX3Eiepzr7uEo7sXMxKjllLf1M4M/DHNDDuT+f3uP0hylisdSq7Q64n/XnKPMxylyRdinFEtafmcl5spHzOB4U9PniG5EgSwLs2VPFL/szY6/wrRKWDgtWp0BTGS3lWhUeKpHmD4I9mNIv66UvSl8fhb7Qy9VytphHXzMjiYpmfA6WNvyzDfnbrZxBjU3DG3gGumZJ8ZhvrnrhYeXVWLRqXgH1dXSAlVh1vqWZz1HXOzC6k/mSpd9yJ8Ch+utFouyK2RjlfB7pdQ+LS8mPYeUYeVVL1XSptLju9DqfDTHxQ46VOyxq6B5luZmNTEd+0Lzry2FHOAv8z8TprM9vv17KirZGLZXmJUMqlqHU5FR5SUONk0PhwVAx2ivN8by5UJDtxhA4/vuRdbIA6rtotF6nqMIflcMRhsjK/4TrKPCwXvYfHi239wXMUBv3Wt6/jL3r/g9fm5cOgqxpe9g0H3Q5K63alifX8cC41Kxgcy8A7lk5BSgk/5IcYkuZP0YxAjuOtOnIfbHaVX4aVd30NffB9/nnA5A9VfYhtJJTe3CqXy7J1dvLkc6MzG2ToZVVjLisBovFEdlxZ+jVnjkjYHs0wzOVkt8Oekz5jQM4UFPhfnsgEdQY5E8jgZzWGZYi8mwUMdeTwbvoYdwXx8kkO5jIXqOiZa6qmPKDH44lGeIrrx8e2kpUU5fixLkipp8TN3ZA3W7PEcHLoOlUWgI3KAlDQjGZl/k2zOlIp4ggEXCpWfnp5CGhvkIodSGaCkdBe++mUMdZZiSxBbyRH6lWb2eLKIFbxMU7dIO5fw8uV8+lUvkWCEmQUR8jt/SOhEpxaHzsiO1EJUnQ66ywoJWXSk97Rz+crXpOJBXEo68274uTQ4ONLfhy+vjJBW/30eSJqmiBVur3QONYQTpbXaiJ9phsMkmgapMjRS2TsNBQo2BvLpjMhFjzRR+z3mAzKT99PsMdEyOIFYQyzTx97MzKJinv70fZpPdJMiiO7XcFzrJFOACcIsrrp9EatfepKWI4dQ6Az4i8cT8ruZq6thum+zVBz5LnUcCkuQzI6LGBxJY4emDkGhJBKrx+ER7fg8Uveo0KJncEQhJSyOCqXiCjnpUQyRkp5BY3IJ8YNt+Hpl4n4aYvFpVVBgU4bciRRR6RriDns7f2uPp8Zx9v6ZHlLQpYpg0ClY2rWGXkwIueOpd5rpi4alE3SCX0l6WEmvMsJhbYiQgHRmzfWrqVaG6FVFUSsFJiV4aXPr6XTJ/55rEpP6nFSFMvCgIWJQEiqTNzKCLwwxai4PHkAflqsK4npZUNjH8foU9gRyaIuIIVMCBpWHT24uJiik4wpHyIo3Ygl5eOild9nozcUvaJhtqiM/YmPs2BOUZ97HN888IVV6lSoVP3vxDSwJidLfcDiq2bP3FpYs3v8T4f0R/K8kvFdccQXbt29naGhIIrgzZszgz3/+M/n5+T8InhCrvN8PnvgxG7P/DOF95+fPMaF0kFUlFXR0Otgal0NBZxsPv/Ei+0aX8vm8y+hOSGXErGH2MQ8zTniIK1/FppwMVhsWogkGOL9qB7tGMknOcPKS63kKvB04MfJI4DaWrl1LmmeYoRho+EMsz5geYUiQB1tSB9q4sGoXEa0BpVLJ+eefj5+d/Oboa/TZxuDrvgJVNESgNJ7oSAB1r5vIqcGJ0yi3tfDnHa/Re+HFjL7zMla8+zdsnrPHQkwe2hAcRaJgZ4q6E40QwRm0oncWUBQdoDmuQzK1jxkcjzmml4RZT6OP6HD2LOCr5EI26qeTHurlyV0O7vKJI3c/xIXGXvJjdknDdKcRFhRsGzWO1nY9CluAC/y13LZzDQGri8E7hzC9l8x2pby4n5f5S7ThKFGfHaVVDgz4C15WIy9EVoWPPxjqOd+/DkfoKgLRU76V0tDgWee+Dncd3pCbfMtYtIlmTHMyeLK2C0utjTEoecgQot8T+N4wXBSTxosrYJDI+vL8tUwL76NhWy470hbSqYhDE/ZhDTmYMbyHTJMGv7+Eo6YSdpoFApEoYzKsUqXS2/U8Pp9cJew5uBxTmx6Hcw8DfpkMlVaOZ+GdD0pTwIHvfkVHxyEUPfejDBpor3wCv7WV949ezda+yVjDAguCam5QCtT4lFQalWgVgtS+fU3ws1IVQqtTEW/U8uzFYzDX2bFGo0RsHgzjU9AV/Xun4L+KSCCMoFb8gDSPrGrCtatbItXqNBPBPrcoXkccL7oHD0dP2WaJEKuh103N4e6Fo7DqzxIfEeLrEDXaolXWvyJN38vUcB8WZZDssmxWCau4cfyNjFEP4Pi6i5iu2QT0/Rye/Htq3DqmxXjOyA2+j5GggZ7+PF48cQPBiIZU5Qi2sFEiYeWqbm6d8goGg+N7zwmePHoldu9MYs1+rIGjUgiN+Njr22bS4czBqHZLOvBhXxwJuiF+N+lF4vUCRsN8tm61UFS8GrNZJspDgyVccsk3KBT/3nnZ172P3275ORfFeCnXh6Ux1kXTt2If2c3xGrFyDMMhgbjT4+//Ak//KPqqrqJ42af4QydQKg0kJS2lt/drSecpwpJ2Cy82H5d0qiIeycskNtREWuqlpKZdyrGOrzjcuZqNwy5aAkp0IR0LOxdSE8j5QTVSHKi9xnqcTQnfUmorI82TRpAIDQR4PfoeMcLZ1aAnksxvnU+wQyvrs0ViJ7q7tPq1xAheztMcl84LETq1GMrlZ8oU8Rj56O/PoaN9NHFCI/aDZ94VsifFM+PqKzhZ/wdCIbFCKR5PubrX3TOOE02zKczrwmN3kZV9GIOhn2g4hoaVj1GdZSPO3cx3gRJGorKkI13lYK6ygZXxE3B2iwOcSn6mOCxV4szDopZUQShWJCennmjQT3zvANk3PMAdoRGJXP7q6HYmGZRULF3OV089ir2/D21GDoPmBOl6OX3Lnqos5lV3DFWEWZq5iQRfgHpbCSkKJzGKsw4sIprDcWRWzGV0upXqLjsrDnYg4OOhKS+Qauxi2BfDnu5KfGEtx+3L6BoJIkTCzFc3kKr8YXLX+PHjOWfJEr59/glO9A5IjjpxsbGcd+WNeN9YSknwGK1CGg3Tgghil6rqGjROgX25pbRmxuMKW1jQsIeEETeGgJ+ASk1LQiYjunzOcdUR3PEVm+ddxOFRFQiRKOoBNwabhxifk9nOOvSRIAq3g5UT5hBMzeJPJTksT7SyobaPn79/SNro3j6nQJoxERFO1hMdG8dkRZCJb/wFgyBw3Quv8/jadr48/u9V2vEZFp6+bDyKbi+fvn6Ug5oQ6tFhtualE+O0Yz7cz4DPgFYRksI7vFG1JKvxTk9GbOmNr6nhRH+cdBolpqiIHRmhzafj8rFx/Or8yVz18lYahuR7j1YZxB9WS0UTf6yG4Jg4aRI1rz9I77FBqfMjdjXUhKV5mGz1IDfMN+JvU2Nb+z6FC87l/Jtuls/X7s85Wf8gTqeP889r/Ynw/gj+VxLe/ymc0dIc+AxL+SLQWfHV1dFyyaViuUS6C+oT/Hw+cz41MWNYM+msCb0iGibT08mwIh6n3oTZ42b2ur18u3QOBlWAWw99QLzbT6cigzFHjxLTNkDVBUmUmlppd1Xy/JhLGbEmcMHaD4lzDjF97nxGTQDnyFreaz3AJqeaOLWR5L3Xs99wlkiKyHT2kRnV4dPGYvUPs6R9BSUtDZJHrva7L6i9+6/YLPl4zP24TfK0vMnv4JbBD/Gkm3kncjV+8c4TFVAFzYQ0DpQhA7FDYxGiaiYss1Czqw7fSBpKvY0PZsXSaI3l2bdfQ5V0LvdrBOm2M18YYn00XrI3Ej1ZBwZSae6dhT4URB0OSAl2qwOl0s9+jokkcbhInFr2DhP1Odni28mQv5tJCePJNqzE5ypHb7mF/WEf94pRct+DyLuWG1u4zyWGMZ8lYeLlobSE6R/oY1PPB9LXrJpESq1TcYVGCEeC5FnGYVRZ+DNe1pwi0d+HTuHj52PfYWxiLVt3XsSccbP55T4Bfwju8XiI2I8Q9ovaslOVAIWKjAUX0pRUwRVT88gwK/nk8V+QPHMn/hEt9V/lS8dWrNDrlEEWpjQwyjIM8x6AmfcSGvbS9+JBogEBnWIPLlUR7ZVP0aMI8Oe99+E45TiQhJ/fpR8hjQ60Ji07PbE81zHjB8+93GzgnI4oWXGdLFPfhaJoEZz/dzD+3/d6jIYiDH1Uh69WTk8SoSmJ4/fdA2yyuxG3DTNLEkmy6rm8MpPyVLPk3/yDxwhHsa9upt/p54qGToa9QWYWJlAS7+P9g/14QwbSTfD5L6aTmhBD0OZkJHCI/uZ1OLqOEdD3EdH4MVizcblkvV+Py8jJriK0QwVYrP0UjDqMVu3glaM3cqhvPGXJcHNOkG8Pt7ApOErSaP+2op+ixKfOEMSv2sfzbZ3on/1/hkXl4s7Rb5OT0CxpZEVotWn4JZsusXoVJhRSM6rwG3JzR/3gXO3t/Yqm5melIJXTFeSJEz4nLka2tGtp+TvNLc9LnytVVuJiL6Tt+AFUhgEU0VyKx8/lxPpxNB0SSU6Ugil+pp0/HXOslWHbHmpq7sagz2H8+Pekx37m4DOST7L4mielTGRZ3vn0unt5tfpVSSurV+mZ4JtB/J7jxMSOpd8Qw8pAiWS2Jij9REMWLJouzlN0SAN3otVUY1DH7sgYyoQW7rR+Sosrm8GIlS/DsxgWTm3wIg7m+FUoA3G8afbhVcCsiJ3RoTAl+lUcUhdJg7cJia1kZx0lENDRo0pDtdWGu9uAUhci7JM3s0njBkmbPIDdnkTN8blcfnklB/rMPLbWz2mJebzgZl6Cg8Xj3kIQ+vEOLeJPcb9gZH8HPrtAvFEjyZu8QVHaJQ++iliQ7idjqJo4sxn//q2kL/ORlN5CU1UFvbYComoNk8eO4ZwLL+K3Jzt4r3uIBbEmXs6JZ8Wj9zPS3YU1OYWBrNEEXDaOh1K44eKlTMs20TkQ5rx/7peGqj45f4Ty0XNo7h/h261t7GzsIlM5QpLCjSeqJqnyXH5z7lhpwFP0cd1eP8DJXifT83R0D+zl5V2xuE8NdJ3G5JSDTE3bwYmWsUTdKVJlPlcxJG0qRAlgYoKVQ4flJMlsfR21kankaNZzi3OvJB95PukyDqYXUVjlkiraH01egFsrD+Rq/CECWhXKSFjqAkTEeEdxbVUpyOlp5WjiD+9Jp6H0BbmwejsJXifLZs9k4px50ibA7Q+x8PntdNm93D47n3sXFbHo+W00+AMEJiXKk2eie719kOVfvc7cc85l+uXX8lZVh9QxGuhxSUS5MNSKeqCeWbNmMmfOHI6sr+eLdet499yZhJWnjk8ogmbfwBk5isakxjk+jqheifrwEGW9Ick27ED43y0FoxoFQiCCVa/inRsq6XX6ue2Dw9JyHpiehGLQj6rFieCXr/uIRoEi8OPyCnFmJdmqZ82vZ+F3rqGm9h7p6zrdLGZMf+cnwvsj+Inw/v8R/5F43N/YKPbH6Lz9DqlUlf3UXYy0nuSyviRqc2W7mx/glFeZIhIlohDQ+v1cubGe0q7tNBelS7Zd213ZKAJOohVxtCblMHPfenqyhumIXcJQfBYptlYC/nfQBBql+oW4IP9l7F/QHA3ym1olYUUET5oFf4aJudUbqKjdhz+tmJDRgLa3DbVzEKs3giNhKhq1HAwQxoczbhdBjZqJ+w+Q39JMwhw/K3gBW0wLQe1Z6/Q4g0OapDa5/n0SP6QIEwruYumOTxFic2iffR9WlKQhcCceqYKREOfAabFg9Bl4qU/gsLKO18OJOKM6xgpuzlf1kR2KZVRUXij7BDu9tmpO2vaQY7RxcZac0hOIqJjhfYd+pYJZ9i4eshbzAj6+JSjdqG5R2Dk3O43cilyG/vE5weZ9BHuPs2dCJSMhUXcqLpw/3CMqFWqKrJMosEziF7gpGtpMjqsZp8rMkDaO1FAPE88bYf1ICV81LiHNqqPb7mNuUSLPLyvn4OpWGvZ3EvDWoo8ew+mVhyX0RgtL77qPxv27ObphDaZ4PSqNhZEe+fuCwsKMRTOZpN8JdfJgUzj/IgbaryLk1KFJgpjw7/DbshlUX0FH5ZM4NA62d05lXet87AELWqWPy4u+JlE/yCtHb8Ib0rMwewuTE2J4qmq86PXOFU4NmWEl5fo1zLK8jiAGBlzyFuTO+j9eA6FQ6Acphv8ZhB1+fA0jeP0hnuwc4PPDXVKd/TkMTM2PJ+GGMoSOnfDxlZBeAYv/LLl2RE+uw3Y4A88p3WUfEZwZRiZWprFh7wc4M77jueqfS5ZyE9NHuK/kWzzhY0TUZwfe/hUJCQsZHt5JOOxlYOBcTtbFolL5ENI6eaP+Sqlyf+OUXP5wbrGk9X9hr40NDXZpmOXhqS/h81RR7zHw171/kMjdtVOyKUuzSJ6axzuG6BywkRruJ18xgCuqZTBiIFthw6oSb6YBFi5MJhB8m1BIrhYX5P+W+oY3UChsBAPXs2TJQ9LXPZ4Wmpqfp79fDlIQK5V6Qx75uXeRnHzOD0hxc/NzBAKD5OXdg1abSNMndURqhjBnW9BnmdEVRRj4+ina2zUMBPMJJ05hwewMyXYuEgiiyTZjrEiV1gB/fSerm1fy/7R3FmB2lefavvfa7nvcPTKZuBsBAgT3Am2BllJK21Ohcupy2p5TF9oeSqEGLcXdPUiMuE1kJqMZtz3b3f7r+/ZMJhMCpS35kbNurrnITCZ7r21rPd/7Pe/z/njkrzI27mguqr2Qi0s+zQ/W9VIUG2Fe1E5faBP6RIythVvwpGwM9X2ENFpW61tZoGnmqUgDTdoaOYb9j/obyXWl+Frvt2gxZC/60wptXDvXSev9X6W1chYLe85hhzHGqyZFWqimxnVMSyiUa90o5jbWZSo5SA56l0KwxsHnHvkF2kyarRedht9r4YxXs58b24IYw4lFJJNG9is1bAtnF3QW4nK7epx6cxefXXYzHm0e3+z9EfqDPmkneOA/VhKOxrnur9uIpcWCPU2hFdYkdqJVMtjdeRhyNtJwajZybUtsBX+LfxxLOkVeLELdzAb64mkODI1wya5XscWzz6UmlWTAUEpRakguMB6MzcVqs/HE51dy/R3b2dfr54K5pdz04ezI4HH2dHu5f3s3z+zqIBjP4LJb+djKau7b1s1h92SLy5HHVqTFnNmFN+pkUfEuTq1qYfn8HxGLDTHg6ec7z5jwuw2camiTz/U4xSWHmDp1CxtTJ3Gr9ga+fPgOvnL4r0Q1Bq6d9UP26aYxd6SPa3wanj5pMbtJcTA0+b1SbzWhF9m9wYnPomnvEOlghirbCIrNRHdxOWGLUUZznrN/C5dMr+W0s87me6293NfrJjp2TEudNk7Ns8vH+cCwh5RRy1KnlUOhKJ5kCkfAyyUbHqfi2s/xk36vtIbcUeUidHA/O3ZMWE/KyspIt+3jpiXnM5JTQMVIPwX9XeyatQQiKUw73SQtOhKzc0CvsGJ3kF0DPilerzc6eb5aS2eLh1SJmYxFh67VL+8ro9WwbE01t6+q54/r27hxXTtKOCn/3fhmkvB0J6c4SOcZObPHx+fPnEvj/n3ct7mDgYyNUlc3g+EC3NE8Tq5NcGXt92gcrmVO7UqW1X8ClytHFbzHQRW8J5B/1C2ZEeOt0mk0Y4Jg+LHH2furX2MNhfDYbdx3xlnsnTabvgLhuMpijKc4rXkrC5paOe2lZ9i8YhndlZX40kaejM8gcEoFmLIrUUM6TlzExRyFffj3FI4e4hTtYgy92dX2OM3OfF6edxKmaJiPvPQw2vFGu0xGjvzVjw5m6xamGWjy8/HbYtLDZowmuODxR9Gm03RWnkl77UXk5viZumIDO/sdJOJa5m5vZlN+McboSeiSNiypERoGbmdbxcfRpPPEk0F151M8sqIc6lbxqdY4brsf3bCRTzD55ChcbM6MhgFNBpsmyrmGJixjWZIlkWEieitenQVL0ou2pRWNAvXVJzMY1bFOb+ZlpRIDCS7V72VGQMMS0zK+oAxyKJ1DribEBYYD5JOhdus2qg4fpjvHxoHyAvSKkdNLrqLJt5XR2AAuUyFRJcyQLxs7ZdE6MJlzGA0exuxwSkEQ9nkxW+x87Le38v3nO7l/e3ZIQ45Zz7NfXCVX6IKIP87og4dIN4/SH2lj9+jLBBKj6LRGUql4tmakaMmkX5+xevp1NzAvt4fUU//NSPS/SWRqUBhB2/YDRhvFa5TBX7yc5gXnkbP4Nqz5TfiTdm7Zcy3NnskLrKnGHr6y6pcoGS33rL2Bl6iiMpniiqCoryqcVPIEczO3gcjBvfI+qFst399ia91us4ksNlHykAu0F154gS1btnDmmWfKWL9jicfjclx3IBDAarXKJiwxmU08b6IZ7XN375TCUFTff3lGPcteHZQZs6apDvICH0fjbZ34LGU0eJOfJJQSgzZSGLU72ajJwa0JMS1Vwiv6/eSXNGMoHOBn2z9HPG1gek4L1zTcS6kuhm1oATZlFsXnriKWHMDr24HZVEFFxbVy6tHuPdeSTkfp7ZnJ5r5TeN43TUbqzUvHWeN3klMeYvZZEfKnrOL83+3DHYpzQe0zXDptHX9p/x4bDpmozbfy9BdWTR68IMVqWIrlzs5OmQsuEmMSiQTPP/88RqOR6z5xEb09P0OrszBr5v+yY8d/4w/cTTBQwuzZVzA49AThcDZqS6PRUVvzBXncWu2E3/ONiPcGGbp5twhaHftJgkLLNzCks6NqBcHkarzJ/5z8GZxbgNYC1h2XoVe6aTVP49GyaWwOBAhpw1zpns8FkQ4+OP8G9rgmzn0GUYHtbyeiN9JaWI6x2UOma/LnW69oWGnr4/bYV7jf/Qv6krX4alNctjLBTJMbTXiE4OY7+aHFy0uGYhKaJPHB6wkFJs6T1jToxXtCxD4cRV7cTXWyi01nniVFyJLd6zl5y/PyvBbOK2YkbwqPJURCiYbZ2n7m63oQrYv9rtmsHxQyT0OttZv5ORke6q+SjZYneV7jnGXTaOmMcfeCOcQyaWqDA8zsHSQ/MoA+loPTMxvFNoSt4UnuTy9ge/WpYqV83NekeqSP05p2YkglpYQbsufQkV9CX1ElHpG9u9ONM5aW09lE5u5jn11JRe4xU+zG6PdF+Nht22genLAlmPVaaW0odZnk50tk9oqF2H+cWkfX4f+lo/MmhiO53LT7yzz8+UvItxl58eAgt607QGOvG31Kw5r8rUyxdaPTWpg5I07ncCffc/wQv8aJK+Xj93t/yGn+rUQ1eq6Z9RNezV1MTixNrS/NjkKdtCpc80qAS86oomBxMTVmA/FUmk88tJcNzgzL2mK81jXK/HiI08NimIuBsEHDvats9Obr5TVp5kgv5tppbA8cX8CPM9Vi5KmF0+iPxvjQjkP0H6dgao2E+MCudVjiUQzuAZLivWB1sG7KHAZyCjDFY3zk2cdx9e0hZrCy5uNfZPHq5VJE3zcwSqFBx+qBND/f0MaLg14aShw88rmVtIWjRIUdTIxXHgzxpw3tbHdqSOSO5YinM9KSZ9iebXQtc5k5d1YRf97cSWRlsbyWX6OL850l84ikUvz1phsJRxLo9TH8WoUHfUvlRE2dkpD56xaDlr9cOZMVMypVwXscVMF7AvlX4kFCW7bSdc01k37WMXsBD65ZyUDSzpqtG5ky1E3R0BD2YJBnl59Mz7Ra7LEIh5L5rC9oYJazk70Vc0kpWlyBfs5bv44d02bQNGUOVW4/l2zdT9SSrRIKq4EwGykZHzG9iQcWrcZjdTC3u4UVrY04DXq8yazI0ofSaN3txEoq5VacQJewYvNNYUbTS5gjgxycdiUJg52GpjuoMg1Sdeff0RUU4HngAXpv/BUvLVhF1DwDbbKFGU27KOsZoLXucgZKsuH9/UU6rolDwRQfzsKXCW3bwu/iX2MzRsQ8tTbSNI55OQ2ZFBfipzIVQmPoY0SvOdJ8Nj7Aw3m4h3R4gC5bHY8VrDninVum66Rel/V46pJpglo9D8TmyYaL841N5GuyF4h8vZZ00y4S8TgLHKuYmrdC2vw0WkWOORUVs55wM7u9rxCOZ0ddKlodH/z+T9DuSNK84VXyTKXUXn8qXS49Z/1mHXlouCcvH1ssTc7l0zBWORi9/1B2K18B14V1xIYCPPHgjbhjvZi1NmLpsNwizjeWU2efi95mYc9II4Fgkyj1ym5p7fNRtJ4MGl0E3cDvGN0wEc+2a+7n8eTUM9vyJCc5/0LonG+TrLuMH/1hDxtHjXiVDEaNhv/UDpI3706M+Z0cbjmDH3ecJxthzq8+QEWvnYivjlm1r3GK508U6ON41vyGW9Z2kE4luMqygZrAVnk8Q7mLuWV05RG/oYj6W7Vq1SSxK8Z3C5En3/cZA/GMlulmH2FHBX8eqCaaSMut4t98aB6rphYQa/cycvt++bzrNJ24HA9imppPuvFpRpNfIZoSojpDbt69HAzt4QnE6z1BscHKxcZSnkz4+LmvjHhGh14D19YWsVJjomx2Hv25OpnhO73YLo9djPAUj2B6bg+trb/ksX1p/nbgw/L2piQUzpcjgicsMObcXvqKivhzf0KOd15QnmZbd9ZjfPf1S1lRN9kKkozHpe/6WNLptBxxLgbiiObaK664Qi4KBIFAO1u3TX5sGo2enJxl1NV+GYdjDm/VQjL0u10kB0aw1ETRz5oHL/8IW/I+0hkb0fRczMpr0lbRHvkJ4eoV5DqMshosLtRW7ZPk6G+duD3gnvz/4Mn8NXzA/Wf22Su5peLD2BMRlvVHaLRrGMjJmXwQqTSOdb0y0UEgsrBPj+iZmRD5GHHSGNBrwlyd/xks2uzna5x2vZkPlBSgTSn8pPpbFNSfxQMbmnh4zyCRMe+9WKatiOkZFFVFQ1wOMxhHVGZFcox4H9SF2jlr6EWeKzmbNlMVVcoopxnbWbBgwZGq30hEy3OZ2SQUPeY00kbh0se4ItyHecTNs8tmsKd+wmIiqBgdZEq4j0bHTEbsegq9UTltM27QogxFqRwYJdcRwJBKkFIUdlRNl9v7hniUsoF+BlxFRBzHiFmxpb59BFMoxT3XL2Vh1Zt76n2RBF+6bzc9nrBs7rxsYTkWw/F3XcR73j26ic8/EOC1zhQFlggfnn43nqiNu5oukztBg+EiubNxTcN9WAs+h6LL4VdDI6RLrdKTLc6hpnScZ3Z9jRnBXQQVCxctvYP9hmxjleD0PWFWNEVx5Oq44jvLZTrEzucP89rDbdnIPJHEYk6wWmMmEU5iyzGiM2gZHgnz2EILB2smcrZN8TQXbglhzDXw2evm8cKIj22jPhxGE/kGHR8ryydPgYceeoi9La2snzqXlqIKaQlY0nGQ5qJKvFY7BX4Pcw7twuYfpal6Bi3VM0grihwec/aB7cw5UAnR50lEWrE4XVz761sxHZW+JHAHY5z6y1fkYuTaldWymbllMMCz+waozLOwoDKH54d8/KhvkPDYacOSzPCfdhdFGjBsfpCO7ZtpVwrYXzeHfasmxm0Lzt/8HOXR8JEhGfuTRWxLVspUiOS8XPn/dDjE8AWrVMF7HFTBewL5V/Pwhn77W9x/+CMag4GMmKBy1BSVSbdvsXLN936FPRHn3H0b5Uni2fh0btL+moT1XBpdfQx31UsPrQiy3lbeQL23V4pjcVax+adiChej0T/EcH62yS2Sq+Nvs89HSaf55OP38JHBFG3TFrFF00LqqOYdJRYhJ+Qh1zoLj3sKGsVEJh0gHhSVXjh5305MyTim2fOwn3UZwzd+V14kM4qWjinTKOtswxjPdq6nDTrcC7/CPmOFPNktsr7AUvvvJx5n3E44PQeztoqudC6XZJbIfM5xpoaHOHn4abzmPPbmzsOtceFTbJg0cRpih1nWt1aOzLy77INoDVqmJno5xealZvlKXtu85cjW4X5/FVvNpZw82szFQ+vZN2sOma5WbDEfI4YC9hsXcppTyw0/uR6NTktyKEx49xDB1/pJRKI0+7dyOHiA2fmraDj/TBnLM47GoCXv6hms63RTu2UYU2jsNdUgJ17JYQ1aDbkfqkepMbH+nr/Sv+EAvvgw8XR2m6/MMpVlzlPRiUzKdPbitHbwCdyRgyiKnrNLP4ZZl8M2v5dpG/6bgL2KgeUfIRKN4E8VoZDkqoLP4Fh2MZz7iyMnzb4WLy/ctp+gJ+s5sxQ0U7n6l/LPDxy6kGc7J1IIxqk2+HlS80We1pzOAbIXeTFU5CM8QiV93MsFNDEFBwH8Y7nKNTU1coy3qF6Kym9XVxcGJY0j0c9vE+eTOOo1FayckscvPzAbpzaOxZEVStHN2xl9VJgVsp8njVkndwcy0TTDugCGkwoxT8vlrjv/LhsHq+ihizJZmRPNqtOrKxn8yV94xT+TP2qjtI81bi2K6vBo07SNxRGdMaMQfzTJ1o5sfNqfF9dS2OrjCs8IUTTMj2k5I67DW3GIgKWTmbGZ+NtE+knWwfmYLUqLbsKPf7J7I1+56gxmrZ4Qqq/8/S/sePIRSqZMZ9qylcxZc44c2nDkPDA0xB//+EdpC7HZbDJZZurUqbKavu6VD5BI75a+00z6JM4662vYbBOC4tChQ7z66qvSaym8iKJSnP2wpWHvfdC3k1hXmHRvMybtbjTCP663ivFm8tdG4t8iygry8v6COfAIw4laHnD/XPpibSYNK+1pqpWPo9N4uS1+OfOt+fx2ajnPFkz2gMvnbv93Oce7g76809hqLeMRay32uJ8Zng5+Mv0T4uXjP+Jmije4SXpeP7TkpJp1zLU+DUYbWPLBkgfWPFINH+DPt/yJ0Y5OFDH2tbSCUDjCI6svozfpxOiPklthxDIS4JLXokT999NkqWSg7lQ6/EkSR+WICyojXXSZKuTn4iJbO0r1ItmRvyg3SezAK5hb93JYV8STwiIyFvR/dcBAnv9pel0R7rz0U3Kxd+q2l+itnEpbQZkUTMejfNDNBw90YBqqIa2EiVj7ZBHCbXDw3Ky5+Mfe7/JzpYHz8p3MSoR5cDRIk2JEk0zzaZeL7y2eiDP8dxC7LOvXr2fhwoUUFRWxt8fLR//8PF+Y9zsqHb1EMfI//IqkoYyKXVvY1VuKViMSDXTEF+STyZuYfFhpMnBLQxULrDpivz8V0+gBehKz+ZX+RzRVaahP7+a/On7PE6PfJ5AupNLaROmyBWx9JUI6laFfn6LkKD/xtPI+Vt9wDkmtg9u/uw7CKZrLh3llVhEpjZHztw2QH0xh1RTwkR+s4JHHHqK1rZVly5ZTVVUp3/svv/wy3d3ZKZziE9/rKqDWrGf51Cm0xxL8jyGf6JiP+GimeAZZ2rybk6ZPp754CSV1dh756VcZ7eth/tkXcNq1n3rdvxEJMp+9e6f883lzSmQzXTw5uawszzo6DZcuq+JHZ9UTdw/x6C/+B3dP9pphMJvJLa/kr/PPoDF3IkLQHvDy6af+QioSJWnPIZZXwh5nNTvnzCY+tlOcDgVVwfsGqIL3BPLvBECPj6VMDAww8vtb8D/1FOmKSh6pnc6AySqTG7bOnEvabObkpnYGXRoqPMO40xZei8+gggTFusMU6SZXRQQJrYmpmWpCfYWQ2sJwSViUJZkRH+IKw11cN/PnPJ2/VP7uNV27+UJTmpTmEZ7TldCjlFIUM5Do3ksikc0k1St2MJ9OMrKeTDrbcFRYXMr89bvQhidySzUmF5loNiNVEHbmw8wL8RgSmLQ5RJK5NJOPoklzwZR7KHd0snO0jA17fXLIwAVnzeBnoVWs7dVSHB3AkQzQYq2TmYvaTJKU5vhVi/MGn6E23ElCa8CoSWOy2Tnjuv9g6pIV7Nmzh20bN+LftoGhpIF7yy6XjRQf7VpPr0Nhum8/EcXIfaWXE9BnhdtvF1q46PLVR24/HUkyem8T0easZzmaCqHTGNApemyrykj0Bom1T34dtHkmjNVOwjvGKu1OA3lXNzAc6ubxG38srRCChprFtHTuoUDjYl7rYUTrt2J3YV52DYp1JqlMirX99+GJdVNqmUKu/QJa4xoMMR9xY3YYxDgzzc9y6pXTYfF1r39PxFMMtvsY6QnS+EoPzoYfYy0+SDSYxwvbL6dJm0tLNB+LLkI8YZbbvDPiGlZrhmg3jRIQI6UzhRg0Ga6blqS9o0NWgT7D32mhhhc0J8uq+9EYtRnmJrbwlfj1hDFJ8RtPK7Ireamuk88tcbJt70G8ST2Xlo0wq7YENt1EOmnAZ/0mIc/cI3bqfnuApxJbJ93+1NpqPnz+qXiF7A4EZKVUDBV49ubteEfFsNkMO6wRXhaKYgyRey3zNY5JXCtMa6hHyzolSUlSw1VBI4sr7Tw/w8JfthyWW5G/PK+Swb2/Z7RpKkPDNdxjC6BLR+QwlIL4CBpF4aKvfFvGxx1Y9xLP3HzjpPsorpvKB771P5iENWQMYXEQlamRkeyWp8vlpMoSIzzYhEE0JCVz6MiUUlhYyIc//GGCfj8vPXQfnW7vkV0Yce6RYrnICo99Ftpeev2HRGeGZHZhlVlwLdGp38VQbqffN4DrT0uwaSK8Grqc5tAaNBkLc6yPsNT2EN5kEX8fvYk/rcljyKVDn05wydCLrM1dgdvgpOhwL8+7f0iur0l+lg1KknKLj5zqer5p/yGv6PV0FxgwJtJcur6fOTEDNatqiRUb5ejUrkSCZVU56I4SjsPDw6xdu5bR9hYie7ILVkFcb+CFVRfSU1xFvneYG1cuZDBo4pYnt1PVsYFpwYNi2gmGvOvwW3rxa7Q4o/kMZsw8bokfec1rQh1EtGYGTGNJNBm4wL2d6sA2scJil2M2G3IXMs+3m1Xe/cSVCPddeB0DheXMG9nKmU88gb96Pn6Ljc5ZFoaUKmq37qCyt53uwhqiVhNzDu7AbjibTGqURGRTdpmkMUAmQkajwdewgjbnyRgTUBiIc/LCCNt3biWhaHl69nL6XdmdgvMKnPxiegW5+n/OJ38sjzzyiDwXWiwWOThEvAW37biKaOQQijaH29OX8Txny991xkcxvjZILOzAUWahe7ZLLgBydFq+Ul3EFSV52MeHKx18kuR916Ijzu7QeUwt6EK34AaM2jYG97Xy8P4Pkj5qoXtIn5KvxXVByEmZabC/wmrrb8FWxOApP2fDY49yjrKWeMbEfdoz6KfoyL8ViTQmbYqQclSzWForQp4nPVa9Xi8X3aK34IYbbpCfj+ZQlAcHRtnuD+FNpFid6+CCQhd1JNm7d69MphjfYTm8dzcP/ug7csDS1T/9DYXVkxcdmx64i7/vcvNMeqJfZVFVjmxoPNjvJ89mpK7AKqvt588pZbSvl3v/66tEAn5sObmcd8PXKKtvkOeLeDpNi3uUA48/yLeLGvBbHXyzupBVTdvZdP9dNJZP48lTLpYNdXWxEBc27+YPXTl03HiVWuE9DqrgPYGciIkno4kk3zrUw6NDXpzxKJduXYtxLOdvfBt/S0I0bmVYqs+uaNuTOXgyVqq1oxxO5bA/VcTiZIrPxmK8rHuN0eJyCkJJPhJfgdn4Nx4rS/N0wSlscmUbIa4YeIbfNP9MVhW7Sr6NKXU6sS4fXaEmDvg3EYxPNKeJ7XchwkRV0qVxUNLTToE/jNM1DfOyz9I++BDNoQ5mTZvHtKVX88wjNzEUmaiEZveztPLLYNITj0zEEnU76ng070xZMftw70PkJtwMGfJZW3AaI4Y8OWGrzhGh7uBaeYGOlDVwKJMrfXvzul49auM5y5TFy4hHo0QDAXLLK2ja8AoPlVyMPh1nmWcrhfEReThtFUvRWEz0pgrYkyqgMObl5tPszDtlNbHdu4h3HiYVDNLnziMvNLEa98QG0Z2Tx/STTpKWhXhfUG5H6sts5F4xXVZ2w3uGiB8OYD+tgkgiyN+/9nnCfh92vZG5oyEc7Ydlk6He6aT4B9/Hc+99hDdvlrevLZ6FaeEnCGbCPNt7mxRwYsJaS9kVRGN96IzTmHt6HbXzCrC03oNz8zfQmBzwmc3gnBxUf6z43fLEHvraHifU3MhoMEauUUPJKeXoa57n0EgtP99xg1xo2FMZAsdMRhM+6DWGQ+SkBzGn/LKBKFcTod82i7aIg2ZNBfviRQSSovExe2EUSQp/vmYRnv5unvr7b+mW47MnEHnM13I/ZQwSV6oZOvd37OhyU1VUTlV+OX954k45QEZclIQnNicnh+uuu+7IRUrQsn2Ql/52kGQijc2WYbnuN9QZN/Jg4Zf4bu8CpjosXG510H3Qwy5jEm1Gw6y4lgdsMYJHFequChhZYdAzVwyMmZvPld0DcvBIFQpubZgzy1+m5DXRnXoYjUbLi3mnUh7tZkawWV4kKytz6e0ekoMgFub14SqvZVNLhkg4RoFDw2UL4lhErFT5Ilh8PXFXraxQ7dy5g1gsWwEd3/YViwq9Vks8lZFjtU3dLehCfjJaHaUnnc5QPIXfHSGtJFih38PpyZdQtGJIxllkMgb01SV0n/VhXs3ks6z1VXwdu5l23ufkglVUpS6/dROL++/mO/q7Jt4fGi2dpjIcqSB7hz7K7+rPYct0E5ZomqnbDjEvtp3H0ssJ2+ysLnVx29XzefpHX+LQwax9RRDXmWmyTKM4pfDS6YvpLq2UzbfLd76Cd9hEa84UUrNySNn02GIppvkyfKGhBFe4R3rDhRXE2r4fJRHD68jFGIsQ1xv505VfJqMoLGh8jdM3PsWzc86lecZcztzwGDN6DxA3TMNhPf917/mdhiRrLdnz6Id6H8CSChM02FB0emzJIswREb+WIuo8jwfOnE9t52ZWbH+Rtsp61p50Hn57jghCZt6BddxQfStNL88mHjYTSGkIpsxURnvocE6nZvly4pufwuAdPm4DrM5g5dwbvsjUxct5eUMTO+/tw5SEsClEyLmTKXXVdPe3srWqmi2F80lrFObYzTw0b4q8tXsHRuV1wBGPsKogh1JHdpEuItfS6TgGQ7ah82jEYvA3v/kNKZEcJCYnFpion/USD6UWYlJ0zK+5iq+2Z33WBelBhjWFzDwYptqb5rklNpI6DS5F4bFF05huzVoNwv44puHXGLntKxwIn8apTpHaoeG53I9imXcJRtOdeEKDPL/hWjLDNtky7FMy7DWFOM/2Ki5hGxmeybXO72DXBCe958dJafRst5xCylLEvmGFPrKLAE1aizFaSNQyOXJMnAvE4ChhUxGRoz09PSxatIjzzz9f5nKL52H69IlsX0HXfjeHtg1izzVRXOekfHoOWp3CE7/+KYc2b6CgsppLv/kDbLnZ53Xv2ud44Y83yWPdlLOUZmcDl5bG+NC8IgbaDtHX2oLN6SS3rIKaeQvJr6zmnu9+Be9AP4XVddKaNn5bx/LAwCifP9iFXavw8PwpdIai/MfBLhmeKXzfZ+zfgrO1kcPkcPNdt6mC9ziogvcEciJH/DUGwhTrFPoONTP6bDtFXis7XIdpi2RHHo5zIFnI1mR2EtZFkXU8uOB8dE3ZblHTVAVfTbGsKCiZNAt9hzhsLmDImP3AlUVGGDDlkNJo+Ujf4/ys3IZyypdl9FO8J4Bi1ZO2pHnxx5+jqWVY5hJesOhUAr1O1va9QDIztj2ZybC8Rk/uqk/x9J234NNahWsYl9NGxt2LQW8i15JhyCf6bCeLJ73RxMorr+WP6zp5MVku58iLcZGnJ2qoX2Ym7G1kzlkX0aEvlOMfjSaFn375c+QP95HW6ghNmU1Cq2fmjOkU+IapaJjNYEcb2598JLtCOApxohn2BjGnsxWCjFZPzey5ZKwODnoCRNMaHonOIqwxsjS6j0sOvcCc9l55xCM2M1vrSjFr7cyecwrJ/jgHhjfKznVRTZ6z5qxsE9v27WSSKazLshV0/3PPy5/lXPNRHrn1N/S2NGGPxFjR0os2k0GxWnFddhm5H/84+qJC0rEYwzfeKKee5V5zDZmMkcE/7mbXwDpa/Ttls1w0GJTNba7iSq74r//Gnpcvxq3BbWdBzzaYcgaDK35GYNQtq4ni9wfbW0hEIxTXTadM1499501s3e9h/fDE1LMcYxjX6hGcVSGebF3DI+0XHGmOnBL1UkwhWy0ZgiLYLSMqVm9tMMUp0wq49eqFmHs3wV2XE0sm+TuX0k8hy609DDjm09rvwUaYuv42fBErnTU1RywZJpNJZmeLTO3rr79ebvnLL7E9r+hJZ/Tse6mb9Y+1y6tmRUMuaz7egGHH7Whf/pq8jVA6l2jyaiLpNXiT0JLKoK+0M/PUcl4b8PGtV7OZnotMZr67aipTyix4/nZA3p7pimmse7GNJaMpWjNJ1idfxtKzU27/G22X0mgr4UVTlDOHX2JqaKLRrto6yiUV+2XM00jUwgNdswmnDNTZ3FxckY1Ek9ScAgs+SmLdr2kajjOqK+bWRZ9loy6P2sFuFrQ24oqEMIz0ow9MLD4FDpOdsLKUuK2azspeFsQPcU54KelUBZYFhYQvqGLN1iY8aVjRupc5ve3ynCWqfD97qZO/dQ7jTCZ5qPh5ehJefuM6lV32epKKTp4zlhrMvJbIfl5+UVJEYUpD50gIRaPBadCyqFjD2ttvwd/UKF+vpNmBNhJEI0L/x0hqdbx40vk0zlj0pu8TTSBBdXc3pw/vozQZItKyX0Yl/uHK/8Rs0NHgHWazK1uVFeJ55fa1bFh8urQZWMJBPvDI7ay3ncqUTCE5aQ3mjIZebRptqZ6lXRH2aPXEMlHCZW14nE6mte+juqdVNuMKvIYK7io5j8rCUR6Ofpuv5n2ep+rPzJ6nIjGUfT40owlqTYPEwynO63oaQ2asGKFo+dBPbya3IJdbbv4dqcZtaGMRNEqashVDLD3ze+jSNeRXVE+q8H/u+X1UPzGMOZGhZsYoqzXfYmdtgohZodG3hFvsn8OvszLfkGQQE33xCfubORHnt9PLmZtn5Hs77qYrnUdt7iymOwpYlVmP4r6b0tIraG7OZ/26TRTbFDQ2P/muRp7MO5lndOfJ29GmMszpjHFmawSDN01Cp+Fwvl42kImpnLUDCS7cHCDg1LHJkOB8xYKpK4Ld4EGfDjCarODU3J8x07BFTrrb7qrDkIpwyFfH7xMX05MpkCPoT7Xu4geGP5ITjuGz6emNVtCQbMeNS54LZnFIWtNSy29AP9IELc9Nen88Er+C/dRjiOeQMA6jJOzELEOYEgVc8ZELqZpaKrPoBYcPH+b222+X5+TVq1fLBaXYVb3qqqukbcg7GOa1R9to3zU5yzun2MKpV9djz0lyx9dvIDpWlV39sU9K3/2zN99IKpmkbtFSepsPyr9/M8S0umQ8hqOgiCt/+Es5spvenSB2QsWwpOoJi5CI7Dtr+6FJSRYCkUE8/cl7CUZjKPEoc2bN4pKrPqIK3uOgCt4TyP+vmdahHYN4HjhEijQPG7bgU8KYtDZ00WI2F5azvT8ku42/qHuIm2ZewWb3VHSdQTkZJr6yCH0mKUXhOBWZMGG0uDVGTKkoMcUgq3kfiB7gxjM/iHE8j1Aw3EzmlpPoDZpwXPADHKs+TubAk4zc8SNaA0a6I2m6Q9nHLqoRL+afSrNtYhVdFhvgmxfN4/yT55PY9wQju/ro+N+72TvnehI6IyFthsdc4oSXvUBWhQ/zQS2c/dHLqZmXDWI/lt9veI3AzT8lbjDywpkfoj+3iOLcXF5aXC87wAU9B/fRvms7rqIS6ccSXspxhAwWjRe6sQB6QdJsI1I5ldZMIRsStTIIfE18Oye3b6OusIztviHCpKkc8THHE8b2wat4YtDNgE2LLuhjRn4OSytqCfzoJ/L2XB/6IFqXC/etf5DfHywvpCPPjjaVZl6/Dy66lPlzZ2FbuRLtURfA4yFO1FFfgNu+8ilZrT76RCpEvDgZ1y1cgtbTQezmU3ilr4x9vjcfomLXRQkmjXIBEs8pkLPehYjVGlNUnTOIrdDP2q6T0SsJlpbsQAmlaX+ujsHofB7On0tIZ8GUilAe6SWqNRE0OKWvWojg/ESYc1IBPmK9lUJ7BNfccyGnmswLP+A172X4qWa68Xl0BNge+wRD8Vpi2hY8jkEyR21PVka66bOUksxo0WoVPrZkAc6eAImBEESHGY330JeYzkhyFgNja68ZCwtYcVYV8eZR/K/2Ykjtw6X/PQYlW32MphbiM3+ZvE+eji5/wk/7P08eYHO7m9s+tpgiR7aK5X26neC63iOFukgywJbhpxiMHpbibk/hOSyJ18u/9hXp0Q7FcKYGmKL9Az5jHn+xX0wqGeHLBdtZYzqIW1/L39d65TrsyusupGT0VWh+WnqUj2Ar5tGLHubTPQnp57v4+bspHu6beC9oNBSWmygIdXNg9OgGOT2hnPk8etoSLj3UhJk4ropifp9fTa8l+/m0R8NctXsTkVSc1pqZbDUVkBjr/tfEUmSME597k6IheiTZAT5amsfPp1fQ07SfA6+uJRoro2u/kUjieZRQNkFCsa3GoJ8vs4nTiQ5S8UNo9BCxmwg7tGwonslQUQ6enDw5KraheReLdm9iX/0C9jYsJDlm0cjxjHDhi/dS6B7gidMvp33aPO6aU8OnDhxmNJHCEQ5KO8E4umSCpE5PkXeEG8KjlJpMVNVVEXKWc+1ftxOMJSlNKlwSNfD4MjstZRNNhPZQjGtfvI/aSDPx+vn812C2uXbJAoV1BdndnLLDPZzdtYuWRD5b5e5alpmBg5w28or88/xzLuC0j2X9nh0dHdzx5z9hGB1k4VkKWsdLGA1FLF36DHqdA3p3wP5H5Gu/wz6Tr/N5LtkSktGRkTUPUXnYhqflNDIpI/25Ge5cbSeqyx5zWSqEyeNjyOokYM7ubujlgODXWx5mZXZzJXdQEnMTDtvI1w3jHl3EwcZPcsdpdnxWrSwKnLc9xIL2OJ0FOoad2ffA2rkWKXxnhIaY9VyG+kT2+pFNIJ58Ts6IeMCibXypfB0msag9CmGNas6tI89lJq9nr2xAOxYxlXIkbSeFjpzpK3Fd9BMwuWDbn6BzA4y2w+A+WUF+rPBb9A93MZNDFGZGIFnHVs9lmF0WllVtZmhIR1F9ORWXfYK77r6blpaJxl5BYV4RlcoKDu9zy8+0SPiZMStDypjP4YN+osHsAqawzIg5x8hgy7MkR14lktKTGhvYJHYOL/zyt0jEY7Tv2ErXvj2M9HRRVFNH2fSGbIGho5WOLS+zOqeRCFYqP/N3ciMt8PjnIXFU6sTp/yWz1SVRH7sCUb7RfJi2tJFwKsMVxbn8cnoFPs8of7j1VuKJhByW9dOf/lQVvMdBFbzvA8Eruq0Hb9pFyhPDcFoxmRk2CgonGljWb9vDS08/mp0YVQi/n3IRpvUDEM8wy9DPn+d1kFz+MZ453IPFmscVM2czkkjwsS0t7Ov0yq6JdKFJbhUu0/j469ypuPq3QTycPemIE/TUs7IxVeMCtOlp8HXD7MvZs3ELa2+/ledzTqbJXi8rWmadhrBIORg7OZ40JZ8vnzlNdrEGXnyRAw9u4DfGZWwxpUhrwJSBy/PsXDLHxPwzF6MZH6l0HGLpNN/fugeXw8HH6io5bVsz7kSS/5lSxvUVE8/L0Rxc/zKvPXSP3FYa6myTSQv2/AJZHbXn5kvx2N/TQ8xg5vaRCtqT2YtJQ7yNJQMbsadCOJwuTh2N4m9rZ8Oqk/DkTnRPGwe6sA/1sbRNbFGmCeu1RPU6hvUFPDFtBUGjBnsqwPlt2/jF9f/J4ZJyljmt3FhfSa3F+I/fA5kMX3/6edxbNvCh8y9kaU0VD/3ke4z2Zm0topvYZLcTdg8RTwjRmKGwooJ4OIQuGaBI0ytHVvdF7AxHbUdel4Qzj2hJNdqQH9NgF2aHkSvz15GuLaSjvpxAsJt0JigrVcmYQsezFQwP5eG1FLNs+ix8/XF8fc/L+xOLiKjWiCUVwWA9F7u5mEtzvoFTl/Uxt0aX85z3a2/8GEliNnViy/NQ8vyTFPsHiaxpYFv0CowaLVW6Ipk0EUxn6ImnCR5z7ZxqVJhhUsTbHreY4CaUpSXGdG6kUL/5iCUoqrHyWOxS0joLi87/EGX1s9Dpk7JyY7Y7Jqcc3LybRH8Ib3KEV4fvIxoNotXoWVxyLjMuOps9u4c50DThWxdYFDd/tKXpHx8vnYFFpU5+f+0idt55C/tfXUv13AV84Fv/Dd4u2PZn2HkHGVMOjycvZsehDgZzCqkb7JIeeTGpKmYwodVpGJ01hf01M3F2lXPynl4SyTbCNGMOZz3AKcXI1vkrqQx60bsHMMTCtFbPYO/0xbjzC7E3DqKv1DMqtugVDZqUSCIRqlGRTae1zQdp2L8TEblrKCugZ2otGE2cjpV9TZ00HHxMTujKctSWvXkZJtMK+d2IkqbHkOYzH5vDrh1P0919tKUpg2Z0CII+bOGJ6ljMYGRv/SK2zltF2GJDm0pS13GQQ3Wz+P3MavmZ/1JTN2VGPaWbDrJtTq3MRi0dHeLk/Vt4dOW5sinp8uIcfltfKSvQgh2HR7nm3p0kSsxoivR4DQYMmTTnRA6zQZuL2+ikIh3g6RWLKDCb+dULzdzYOUhqSvZ9MNUd5vnGi9ioLKP4/G/xoicPbzhBcaKPqdYoykA//W2HuPir38XimLDpCA+yaBJzuSwsWfockUgnxbpZzBRJLQPZYQ7jfGLGD8hrXEDlSJKoXoMpMXln6nCBjpdWRJkT2cOszg78/nyqlAHurT2dPWXZ4kJ9Zj8np9YRUKzsZw6NmjlHeh/O4zHmsRNdVMvajv9ke62dkEmRU8TSGg2GRIaKkRhtJRPJCILy0UF+YEvj1+9k3WtW6gdr0cVthJQkT5tT2NMaFolznWkYw8wROazlwsOPootm2JRu4AxXL9XBvZNuM2K3o73gFhJPfBJrIIzbpWfPnDxKIjlM2dWEPpkhaXXir19OQEwmjGcoau9G4x0bPywWzt4umcAwji9ZxP3uXxHPTNibppb0UHrOMh58Oju9cmp1A22Hm0lnUjg8MzHG8qg27WCZ9Q7y9F1gsBMrO4W9B5x0huZSbdrGVNMGnNoBNBpxLhGDexbhzVnE+V/8BkaLBcKjsOferGdeiPJZH4CVN4AxazNJPfgJtPseyB7QUQ2j5NZlbX3usTHfq78DrS9C92a5Y0U6QcZVSezCWzHVZkfWC0KhEDt37pRTZL/zne+ogvc4qIL3fSB4BSKqaTwu63V/l8lw7733yqxPwbDNyWjAyGuxKtko9MrXzpAXgPNvWi9P1iLIXGSFivGTybEqTirXSGJerryInDS6g/savyIjaCQGG4FPbGJUm49RpyXfZkB31HEMBaJ89a4tvNopxICGm6+az9mzSmRG5O9eapUB6YlU9n4WVuUwtzaHl/cN0jGcPQEsGW7jR1cvZerqrA3gn+XvfSN8tbkHh07hb7NrWe6ysT8YYbsvxIWFLnLeoOFjIJbApdNiOuY5DceTfOH2V3mhYzw/VKQBjPKts6Zy8rJ5/OWmmxgJh9HH41T4ArQX5MnueL13mKQrH4NOh755D5G0lr9XXDkpK3lRqYmVFzTwv13DRNJpcvVaecyLnZMzk4/llx0D/LIzO11rjs3Ms4umSTG77fGHZMUt6MmmDQic5jRnFzZSftToW0nd6TDvSuKVp9LZ0s4TDz1AwGBmwcJFcry28MjmRDpR7r0SggOkbdX4gzW87F+BbtkLWPLbyaQVChwfY+b8r6LTG4iGEtz/wwdxd28ip3Q6FfV6dj/3hIzR0lnPx5VTyqXLN2IY2srdTTcQilleZ23UpJNklInXSPy1LelFCY7gc015w+dEp4FyCxTodlCs2UgsfTo7Qg24pR47qlGNBPOqDzGvbC+m1vt5uHs+naGJCqFGscsEEqGGK2bMouGU02k4eTWKoiXpjuB5qYOnNtyEe6Cb/PJqlhddiGXUfGQbclfYS4IRGsxPsit0Md5UOR4TVJ5WRmWxjefuOkh5TCGhgdyiJMMHfyejAqet+AxnffJM9HoFzwNN7N27lh3tk7dxC2vqMK1ZydczFYTHcnfFFvQNT3qxRTN0zgPj4HqsowmMw71kUq8ftyx2XgIWGy/NOYvDyTKSUx1kHIZs/NVONxpfgkVzcnHsf5ZZh47M5Z1EQqOT1ieTsANphYUmAJkYGiUXneU0tPpKerUpHrbGEQPO5lYlucQWorPlEAaDQcbWidxh4SMV/mthSTGIITtkCOcXsdnjz45fjcLmghpCxblHmgzLFC39ySRJrYaLTRZefKKVWK6B8sIIq7sbufSsM/HWTOOaxnYRm8s1pXn8dFq53B0SjUpfbuomPmZvKjbouW12NQscVkaHWjmv2UdHUss8u4Uz8x285Paz3Z+twBUMxdh00QLsd6yBvl2w5n+ygubQc/DAxyAZg4tuhnnZGDvJrjth+22kxUCJYTek4ujyNTTOSMr314zmAMVuDYmGM2nJVYhHD2PwdfKadgWxtdehyWgQAQbzPzSVmooUL9z1GNHu2SJmhvyZj+Oo3Eo86CSvLY/++Ax2WmdJQVYRGCARs6CP5ZGOWwgVe3muoYz9BcfPai70JrliQ5AnF1vpLMpWb0VyT7XfTUFxMQWZFIVrn5RZwdWludS67iDmDBMaqiekCfFq7xJe8Cx9nUVtnM+eWs5Xz5pDaNfNxJselE3TWAuxr/4VOlspUX8rQ699hR5jL5H06JHmaHMoit8UnyisiOhId4yZzWF0osI61s/CtLOzmeCiAowYP72QV+NfId8Z5XCfXdqNBDGjm4zMks8nZOskYuvGpnfy8cSd5NIKovHXYJXNwm8Ft/N0vIkicuKN5Oq6ZFV2EiYnXPoXsVqGez4kLRoBQzHO+JjfeP5HYKQlK27fCCGGpSVIA8s/C6d9F/QTixGPx0Nubq4qeI+DKnjfJ4L3HxGJRGSepPi/iDkS0TM/fC3Ezm4/584uJhhLyXGTx7K4OgefSeHgcFCORIwvyZfVnnP7tvOX1FNotHpeLvoYn3lVkV2ogmKHia+fM53ltfk8uruX37/cKiOetIqGG6+Yy0XzJjdMdY+GuemlFh7a2SujpMYRoer/GdrLgkf/jKGqiprHHkUxTa4yvBVSmQwX7WyRFyrRX7XcaWODN9sIIUTwf1QUcnVpHgUGPd3ROPf1j/LUsFdOA5pmMfHgvDoKjROWj3F+e//z3LN7lIF0dsUuFgBrcj0UhdqxmU2c/sILmHr7WL9qFf1lE6H4Ak08yrpAGW3WWnLio9Rm3Oy1TJPC//SSFDdcsoBvDIXZFQjL7eMPFOXITmwhzl16LeFUmu5InEAqJS/iIvxcYNBo5MX7dzMquUhjJLLfTZfDw+MP30NlZQVrzjqbfHMc7W1nZC8IIuap9hRY+QUomZt9Pbq7eeyxx2QyQF5eHp/61KekKBkncWAjmns+gE6b9ZKlMjpe9H6a8IIWHBXZzFKjr4SUcRbxiIt5yz9D1G/DVeqhp+92OhvXEYt4iAUMhAfNaDTF2HPK8Y3UExnJRpyZdUmKIj4qXQW4dAppV4p1Hh1+/+TRzaK7fYpRK9Mh+kOjaPPs5E4vp7DaQf2yYpJa+NZ929nY5qYoqqUsrFCSVJiaryOXLmI+H72xmRNjpNlO2LteymDFMJ10vOl1jUWCqbkhzl1oRlc6i1cPptm+tQmz3c41v7gZizOH0NYeks/9EStPoc+0yX+zNucknqr5IlVr9ejGRocej0ToBVLxRjSKC0vlZVTWVjPadZiezjvQJ2Nsnn8ylzsKmFKTz6zT1qCNK7RGhnmweT/G/iQ5+w1EBxWsTgMVH53C1+5cR64SpjqmZebIMKnoRlktb6ttQCyjNk+bR2vVdBx+D0G9lbTZAGLAx55RMuEUyUorUzQ9XPhstnFt08LV0hKuDEYJJC3MCDTLpiz5emiLMNgvl93227V91GfKWRg3MmBIcp85QdSpIzEnj4xVJ8P8q0YHmFZVxdLKMk7XJPANDzF79uwjXsu7+tx8tbn7KHOR7AZF1xsmVWEl4zwqwziRxrh+EE0iTUOelrONhzj33HOZMiW7KHp40MNnDxyWr6YQsFMsRh4czHqexW6KOAecU+DEepRlqyUU5bydh/AfFSslmoY+aLLxlVnluCwG2PFXeOIL2f3vyhXQtWmyDWXVV7JezH0PZgXvcWipsdJVMbZIStnQKFE0mslxlJHuz7C3YykPzDJRUG3nqQXTpAh95KaNDDYfP7ryH3GwTM+OKSa8NoWQUaF8JEHCHObLe1oZHaglYoBXLivAaTfybaubaaON6Ib3g9bAdtsZPPvqFpmgIz4jU6duprhkwqPe4qnhwUMXkUjrcZkCFOfUYLPksnJqLZcsqDquHe1YxGfS59tBU/N3CIUm7Acm7NjIZZQemfxrNpQyU3sGjs4mNEs/nT2nCQ49D/ddDakY6YLpeM0x+g3V7Nu9hlgkTyYCaa05OOwx7JYB1ofcJFJJLuEZ5uZE4YwfwIHHYP/DY3fsEjO5weiA0Q78yXw2hD9NkbKPBdZH5eLCnyzM2i90xxfJ4v2X1BjRZ2JsZCEvchKzdZ0sqzBS0vUYGjGSWG/JDvAJDY39K7EarslWigXivD22a0NBPaz+NlStlLut/ld/j/OTj70rdMe7DVXw/h8RvMfjQJ9fVnXHNaZRp/DrD86TU3Ui8RTXrqxhSU2urFJ9cn8nTx8cROuOkZie3Zqb2hXhyqpCfv3CITklR/z7RCo9MbTpKMRkn59cOptZZZO77wWeRJI7+9z8qWUAt2iGc8fkXPLpcwt5bGYpvRddTCdauj/xKYynn8alhTlYx2Nv3iKhVIqvN/ccucCJU22pUU9vLCuglLHxlkLkZo4zqUd0QR9P9IpmqU2NLfzo2VbaQtmLb53Ow63XnUJlKkbfN79Fsrqa50tKSXpjRAYOEs0rpl1XyrpEndx6uzi5marSXHZ6DaxLZCNuZhpG+P6VK7kprvC8e3Il1piIU+UeoMIzJI+1ubiKXlc+n6osJF+v4xeHuqgLBrh1u5ZMKs4j5q3ExppnxBQvIQI0oeFsBcpZfqRaMjg4yGuvvcbu3bvl9yL79eqrr6a4eMLvG3z1VXq/9GW0ip/ykzwojlxSUy5kdFeUvfs1eNY4KJj3IIp24gKcTtqpqr6c3t67SGdeP1/+yO+lNLQ/80GmRvKps8xBO+bZlKsU0SiZzrAumCQ0piXsCsw0aSnSh4nsuJNkTzb7Mvfaa3FdfjnbbrmTH0SKabFNXmwIrHqFb5aHmdGykcHCGjpb+4j4OyCTXQjl2aeyMr8JXXqAZ0c/TUopY6H1HojvYYu7Uvr1Ssx+LNoEbUFRbdRwUfl+priCYC9F7vkHshX3jNbAE4Wf5NNTL5NbxMWeJMubokwbSGCIZ6idX8D0M8v57v2NuHqiePVheqcHGCgqkQkEUkiJYw4FuPSF58nPWcNUbxr9VCdzE2mUgTAa4a/VZCPy1gayz9HKy6bw3YNdNPb6OG16AQUOE7rBKEV7R+SY8lFXgL1TNWyYMrkz3RYK8O2RVuYW5bE3pfBa4z4qD2zHFI8SqZ9LXGNgMCcfxWhioC+FV8nljIFurKFBdOaTaCyx87wxjiaY4PqlJazJ11FanY/JmUNCyXBX1yB/G/QyeIzmF3aEb9SWcEGBSy5Sf94xwB96sovwq0vyZIVVfF7FVK4Go5Gnd/dx+/4+MkaFFdW5pPwJHtvcLX2kD356BXMrXK973e8WAvpQt1wkjvPZykK+XVtyxOZwvAbhv/e55WfNodNKv3KV+SibUSICD14HzeNjnYWivhrMLnhNVOuPQryWJ39NjsROJ+M8/dyLjPiCDGlyqZvVhdW2F70+azj3+QoI+GtIpmLEojaGhmooaZjNr4qn4U+luawoh/+dUUlnKMaNjzdhavJTPZQkrgN3boqaov0snjMLu30uw10BMtEAFW3/QzjcxcbUWazLO5Velw1bKsTUHoXyoTQd87V8Z/gqrPEEW4MfplDfwjQxuvx4aA3ytX8+sZBWTR1Lly1l3qIientfZnhELBrFlrwYLe5k7tw/4XIu5F9FJEwMDgk/e4ac3OWYjNlzkt/fSGPjZ2QqjcBma6C05AMUFp6D0TgWWbbnXjKPfmZSo2RnhZnucjszD4xijqalNUJYOPpMLvZHZ7GKrZg4KhNa7DBdfCvMuXziZ8Gh7DnUVUFgy+P0PvZ3KrVbjgxIEY2wJqcF7dTToWoFtK4ls++hI8fhxsm2Rf/LSG8HDf0PsID98uexqlMxXnpzVvQ+9Z/QvRUuvhlqT4Vtf4Fnvi5tDdnjylocjsYfy+D8aeBdqzveSVTB+39Y8Aq+//h+/rop27DzvQsapMg9HqKieMmuFvb4whhCSeJ2vRQh+l1uKYJFlfi3H5ovK7R/2dDBzS+3Eo6npEXh8oXlcrrP0TaHcZ4f8fHpA4fl7QuqzQa+XlPCt1t6ZANKndnIYDhCcOyiP35h/OHUMs4peP0FbRwh0gVHX8REteCegVF2+cN8vCxfRuiIeLc/dQ/LSuo4J+fYuKw4V/79xxs7jlxkb5tVwwybmUQ6QzyTnlQJSqXS/OD+jdy5xye3qaryLNxy1UIaSide922dbq56ZAvJ0TRpsX8tFgLaPhbqJ5I1WpQpbAxnQ+eNJDnLkWHGvEpCU4rwaTL4RkdxrH0KXXyycNQ7nEzNLSYxFOFgtBddOkXIYMaIDl08gN1sJxDJNrSJaB4xjECkG4wL3RdffHFSA8e8efOkjcFsNk9UWh55lP7vflc8WMzz5lH8gx9gmj4xWSq4cSPdm1rY5taiKziIRRtEX7EXU073xOvSmY9laCkucwlRaw8ecyOhTAStMYQ5L0bEbeTQw9XosVJsL2fRNVdSPmMW3kdaibV6YWERuwciPOP189IcC1XBDD85p545ugyjt/+Vkd9nB5a0Fdawq9yGMRVll3MhRZoGgroomnATaU0MR8pPSXRgwpYz/jpqFPY6Z7PBtZx5Siu3GX7JQGQJL/s/h5Y4Jzluw57ewuO9DcRFxucYFlMdH6l8ApvWTTCVi0kJoFPSMl1h15KvccnBYTlidGlfnILBJGsbTET0Gqp1Ou5ZPI1SjZZHf7uLTbEITy+yErAcNREsmZANg6JpKyeQ5Nq1Aayx7Pt7WJum2ZqUk/LEO+IDMQNENMQ1GZwfrOa/n22S40a/dna9/KwLFmb0nObTETZquOl8F3GdhtomL3MPv8yIy8qcg9uxiGlOx5CyuwiX1sJYJq4mrZOTFu3+erQpIxGLwgNLrBwu0stF4ouLpk1ucD0KYZV6zu2jLRwjlEpLa8H44tOmVbBoFYbGEgc+NyZI30pFUNinQrEUNflvbAHqj8V5yR1gozfIqbl22fjztjDSCnvvBXsxLLouu5DceQc0PgDBYRCNwWv+W47jHkdMGhQRWSIZ4KKLLqK9vZnnX7gZMlbWrPmE/Hl7ezvbtm2Tw0QE3QWlPDNjsVw81QY99FpdxITXlgzzertoKS7Fo9Wj12i4zqLhXCWBs7qGXIedAk2KrVue4j8COfSacsmNefnF7hsZdZ7Ewis+TX2uHUUIrL6d2Wri4U2yIUwiFnLFs6BoZtbC0Z5tyBOVxcyH70Njyu50jZNI+PF4NmG3z8ZsfuMYxH8XcT9d3X+hu/t2UqmJGEu9PgezuYqCgjNR/EN4D/6B/NEUpQPZ93ZCqyGl02Aa2205NvbMo83HXlyLTm+kf8qVbBu1ycW/ODceveN1hKhfvs7JDTcxsmMrL45+ltmXnsysU0sZGBiQsWgHt73CzI2fwUGItNaIUrWCTPcWNImwvP+XWMEGljBr9hzmzJkjh8+IJrSVK1dODI8RQlvsFKy/EeIB0q5KNPGwHLktHoHfUoPz67vf1brjnUIVvP/HBa8YO3nt7VupyrPyq8vnorxJM9hwPMEVu9tkFVQMqEqKX01nWODLkF/rZCSZJJLOyOqJEEjFOh1fn1LCQqf1uBerZ4d9XL+/k4SYi24zcX15ARcX5kjP7PrRAB/cIwYJZzEmE0zrbGOkuJR+W/a5PNc7zHfc3VScezb60lJZFWoJR/lrr1vaEsxaDecXuDg73yk9sEfC0I/DRk9A/hvRyDQST/KhklwuL86lMxLjA7ta5cXYrCiyyvSK2y+P+U+zajg9b/LrKkbR3nDPLnq9EewmHXd8fAk/FNnwAAA9BUlEQVQzS53SD/29Zw6SjKWOFC3nGDN80h4n44vgSlrIS9uwYmIzcX6Gn2HGxjeTYok2yPfOXMALjS9Kq0GOy4XOPoV97gTt/gBKJslM3QA2TbYqIcaUjscpxbQ6HllwKhe6R7C0Z6u3xlSG4kiUzJQaugaylUjRXT1jxgyWzJqJde1LBDdsOOKnjXd0kBYJEBoFx4XX47jwA2h0OhSjFsWsQ1doQZdjIrRriOH7moimhHDR0BmP01P9JM6qzXhaV8vuclFPt2hEc2FCZmkKTKltVF50O4olwfCefHo3i4QBzZGBDLOu/DhNzhJMRi07feEjlb9xzsxz8IMpZeS88CxP/uk2Bqypye5BjVF6So8loLUxYCzEbchjwFREv7GYpKiajFFmHOE/cx/B0LeGw74Z8mcl5nbm6n7Hfl8xHfEzUHRFaLSl2HVuLDYtQ74c7Noh1jh/zZaiCj4765tyzHfFcIyPvBxiyKnl2QUWegqy9yPE7MndSfbkKnht2feokhINQxmqu1pwdgzhidnpPXkWKYsOpydB7cEgc/wadsww05OjxTASI28whi3fQluxnlQ8RTAUh3iaeWVOmrq8xIMJ8hLg9cU4K6yneZGLpgqD9Gt+4gU/SjJIKtZIJhNHyOekdph0JoyizcPADBTdFDRajfTXpoXlVO6LZHEVWTjzs3P4lXdU+lxvbqj6h77zoxELXrHwvKNv5IjwFRO7fjKt/HWfsfcbwrc8buEQCK+8GI5wROAcNXDjmWeekQK4taCMtTMWHYn+K/UOc2rTLhyxMFGdnl2LT2WP8J6OeW/HJ76V+kfxmCxEDCassQjXDbahHeiVVrfa2lquvPJKOZBhEiF3VryLCY/jiIJCywswsBeW/UfW5/oOE4+PMjD4GEODT+Hz7zru70yb9n0qfHYyT9yAZsxfK5qiBwqNFAzH5JTQuF7LS+kVbEstkOe73FwrbveEkBbDOc477zxmzsxaoY7H/vW9vHJXMzqjQrKqlWF/1vIjKGSEj1vWYgofla5SuoCXtaeyrvs426NySqWL08+oxmqZQ3u7h/r6eixDO8nceTFKarKdRa3wvjGq4P0/Lnj/WbyJJFftbWfHWOPGW6HKZOBLVUWUmgzsDoRpDERoD8c4GIpIQXtxoYvfzaiSTSlHs8ET4HAkzjyHheqBXrouvoSoRuHv517CvWsukNFF+d5RCr2jBMvKGTCYjzSfHIs43VeaDdi0WspMej5emscik577PCEpkA+FxxvQsgixeLtTy5mL5koB/JkDnazzBF93m9+qLaEvlmBvIEyp0SAr1CusFv73kQPsPOxB0Smy6SgWyZ6UMjYdl66qZq8xLRtt5totrDaaOO/FITI9QQyVdmwrSkmatdy6aTcPtQUYTI6JQhJM1w5RoiQIJWpZf0x1UlR4TnbEqZ9eQWFJHjH/YQ63HGRHQR27irLbeyu7eljUeYBYZvLrV5MqpCFdxyuOEJ3Rdlbsa2Rhv4+Mp0M21sjHm1uF7bQvkhlLqDgWfbGVxGBICmTz3AKMdU4Sg4O8/FIf/RGTfL7ydRqZkDBgVzhYYaCj3Mg0q4mfLihFF3yF/R1fkbc1kp7Jvr3TcexoRUkmZPPLvunziZrMWMNBrOEARfE4vbZKnl11CmGLVS4Pzlr/JPX7sw0f++wzSNXVMmfP82gyCTlwoXbBQvLKq7Dl5fOHFg3PHE6iiOexxEy01M7s7lbCLgetecUYto+gSWZIW3RyDLYxmsSuMWJLaWT1zJJJ0RAzcorhZTrjM9inKSIvrSEnnRUXa2eb2DTDfMQyoklnKPInGHAZjnwvVPnr8oqjKQxbh6UXVSyyovHsIkmx6wkvzpeNo/8qDq3CR6x2Xh72c8CYkdaGT6wPsaTATv2yEmw5Rp754x7CIoxYxpyl0YzFLR0P4RMWgfynXDkds+04Va9/ErEzI84t/bEEZ+Q5ZKVXZQJRSGhsbJS7Mc0FZTySMTFj8DA1B3bJRfCsWbPYuHGjfB4PllSxqW62zDmWole8z8bea5XpBHfNn8rUXJccwPC3v/1NTh8TVcVLLrnkLVXT/x3EfYnc2mNF/duFGLQRifTgD+ylr/de+f/CgnOYNeum7GOLh8l4D+Ptf46kNYf8vmE0/bthyhpClTN5acuXaTk0E78/e97UaFIUFHQSCJQTiRjlgkQMrRCLA9HnIMami2v9xP2n+Nt3XyXqycayxRx9JDVR+Zjrl5RxyWXnZ9M4OtcTd1Tx4G4fh8QOW0aDktaT1mbPuaKSbDINUlu3Aa02zf59pxGN2nE40iyY6cXlfZTZzT7iBoWumkLMpdfg3rOfBZ+/+32lO94uVMF7Ank/Ct5xP+zP2ge4rWdYTnk5GrEdKawAotoqhO3koY6vR1zOhL3gPyoLKTO9+QVz9I6/433oIXQFBRyYWs93Zy+l2zw5o9YwZkm4VkmAzcrTcVjvCdIVPcqPNYYpFiVqzG7ri/rKUouBuqcfp9OZw/r5S7GGQ3z84C7aG2bjNBpIBoKstefiPs7M9dchJqrtdKP1jE3GEiv9GjuZCivp41TRv1hZyFfyctG5TK+7wD20qZkfPXUQT9rwuudujdMqRfb2SIwdvskitshh5AcXzuL0AjtPPdnMN6sUPOLQM2nqhvqxJqJE9AbcVgcanY2ITiEsog3GKImkOWkkyUmxOMs9WhRPMptNadJJMSuq+5l4inQoQWIwfKS3y7qsBNeFdUei46LxJPfu6qW538f+RJyDuToCx+gY0Ty4zGmjxPd3VifultmhIsZse2opwztdlO+cmNJ1LGIka39RDTElSU1fmzyMl/NOYW/NfBIL87CHg5zn8fL9i1bjctjojca5q9/NaDTB1pYRDurSZMw6GtoP8avf/EiO6fzd5R+lyVXJYLdYRrz5xX+VppGdmnpCab38zbNnFLFPm6KlLHsxNyfSLEjF2ThmIRHjd88ffpUvdtxNl+lDfKH+DEZNCtZ4mvKBGJ0HRyfdo0mn8IMz6llamcNtrf1sdYdoylWIGhTqe+LUd8dpKjfQk68jx5dkoC8gIyrSwnYkthIUDVqzjoISG73xCb+fuI9flBZz1dSiSTF/8UiS3S92sW9dL5FAAqNFx/JL6qiZW0AsnJCCQatXMNn06A3/nJde5e1HnCPE1rcQXkKACUH88MMPSzvSWZd+AHtpObmpBJ0eL2vDSUKKli/XlmI7aserra2NO++8U97WGWecwUknTQw8eLsQExD3798v04JEFrGoagtxLXaVTjTR2ABGQ4GcfPhW8Hq303n4VkZHY4yO6iksFOfxZuJxDzt3XEA4PLkXRQhg8VhElVx8PsSo5kP727H7pmGI50pfedDeRtTaJxPeZ8ysp6amWuqCZ599ltHRUTGdBId3Bvq4k6CjjZhZNKxNFHCE6M5kJo5fF7dTojNx+tVp2nteZs+eQny+YjWH901QBe8J5P0qeMcR2/23947IZq/ReJIcg45LCnMwj1VlRKzXj9r6eGbER3DMo3s0InJL+HTHWeiwyG3MWDojq34fK8un+DiNYuOEkim5fRrbspn03XdT0NVJgccto89EDJjAOHUqWqeTnqFhevUmIkYTW2bO5cmTTiduMFA4OsKHnn9c2iMc0Qix5mY0M2fyhas+zZ6co4P7J3BFI3yhtoRfDPgJj92PeCyCQDIt7Q6SVBptR1CKqXSJWQoPQWEizof62pnX0sSrBgt/O/lM2bz2u5efwHfFh3kiqWFNnlN2jYsmGUE4Guc3D2+iw6fQFUxTmmPm6+fPoL44+74SF6rH9/TxwoFspu2+Xh+d7qwAPrOhiP++aBbPB4N8Q3S8H129GT/WsZ9Vh9LM8qZ4uVBHSD/xexWhNJ9qi1FXZCe5soQch4kqs0E2yYkTfCoYJ3LALW0RlsVFRypEotIkbCtPDU+O5zEqGla4bKzJc8iEiT2BielBxZl+ruSvLGQiAsuTKme4p5SN/fX4Uw5CBiv5hhhzm/dg9AxMPBzgxfzVNDnrufaKmXTpMkfuW4xg/WJVkYyoE7nM44hki2sGOvlU1Ev+ksVEm5rxPfooKc8obYW17KlsYO28uexGQRNJySEM5kyIpemdFKa7yDV5ePHwKXTGqmWSScakJba8EAwKOYMDXKlZz7y81zik5NFPCTOjEeZ2xjAO7CSjg7SxkCdn/5i7XnMTSoihHxG+s2gb0d5Z7DlYTGFGjHDOPp+2XCPB0RhJBZZcMYUllrU8+1iG3pgFZ3GEFR+5hFs2dbOn20vrUJCKXAvLa/O4alkldYV2ftHRz01d2WbHG+sruLLk+GNMBclEip4mD0XVDsz2f796+14iFhuSvtDR0U0k4m4UrZn66f9Dbu4K3guIaCoheMd9+m+FrVu38vTTT8s/i3G78+fPn2S1GEd4SoUFwuU6fg+FSAES9ouDBw9K37H4XghC0SsgKpzHctppp7Fq1aq3vaos/NHiMYljEc+HaMItLCyU1WXxvXhsIr5LHJOwiQlBLn4mvLZChItqt5jeKI7L6/WyefOjZPgFoVAO+xrPQKNJU1vnpKc7Lp8TgfhdYfkZH9Msbq+ssIbASARPYvIU1KNRUkYpdheumoI9P8n2J/1EIlHixlFi5kHiBo9coSppHY6UA5/WT0ZJoknpKc2rYih0WD4ucQbURNN8/2c/fN/qjn8HVfCeQN7vgvef4ckhr4wFEkJDVH8/UpovQ+BF9fXXnQNs8YVel44gto3PLXBKD+4yl1XGchnHvGjHkvR4GPr5L/A9kp2YpthspENie33yrWoMBvSVFSQ/fDWDs+dQ/eB9hB59lEQqJbf+rEYDNQ89yA5HDp/c287wUe3cQpTawiG+cM/tlKSTLLniA/hOP4MaiwljwI/v4Yfx3Hc/Q6NeXlmwlJ3TZ7JjxmwKvKOs2r2N+c0HKBodonB0VOZXjvOzj3yKZ1ecKsehiuEe41i1ivSlCuH7j8gkEnJMcWDti8SaDxEeGuG+BRdxT+5sWSk1FlsIzs2RFXcR2p8S0TpHUWEy8OnyAnISGfYPBditS9EUjcmYNCHq3yj0SGT+/mhqGQucVvm6iulb4hK5JxBmqzfEY2PxbkJUiuYgYU+ZazfLSKjHhrz87vCgHBpg0moZiImYtbFmQ1FxN/SzKHY3izJb0GmyF5DhaB6PtZzD/MJGFhbtocNXwfO7TyU8bMGSCtOVW0lPVR2pUgsZu15aAkSe8bEIz/gZeU4sisL5hU7qLP9YGASTKRp3bGDvgf+ltLIZi2ZCpAfTVm7W/4RYJE5Ip9CjraIm08r3+LasVgtiKQM6jYjnSzMczsOqD2HRRznsL2fn4FyGI3lM03Vxeu0rpMYOJ9Azn5H9F5KOVsnGyHQy+/wsPidIQfon+JI9+Bx6kmOLk2SgkiU1nyKn4RLQHX+7WNhvIqk0S11vPsHvaETVNxFPoWg1mKz6E77l/U4RjfZxuOuP9PXdJ5MBjkartbJg/p04HHN4v/Lkk0+yfXt2oSnykEWld+7cubJyLESciLZ86aWXZDqNEI/CQlFaWiqtCULgiuqtqFaKBfjxKCkpkd5X0YwnbksIUoGIorvwwgulcBQCtby8XIpkMUo9smsX+qoqeiIRKTzFNr+4TyFWj0X4n4VFY8+ePfJ4/l3EgsFut8tjElgsXubN38KB/XPwerOT9t4q4jOzqP5kWjb4SJpH0dgjhOI+9HEHRcpM5p/rx5v6Ful0FE26DHdrPb7OlcS8FaS0EZK6IIZYnvTOx/V+gnkHSB2VJOE0FWLoqyUSTPDV2y9UdcdxUAXvCUQVvG8dUQ1e6/ZLu4RIVhACebNvolFgnAKDjg8X53JeoYuNniA7/SE+WV7AkrGLd0I0YCmKtD2kvF7CW7aSiceI1tZBWTmFLoc88fRE4zwy6JH3ucMfYnx4UR4ZymwW9o7NKxeX9cuKc3hxxI8nOdmg4QgGmNt7mIRORyKRZEp3B9V9PRyaMp19cxfSY7YSGROWjmhYNi6FDEYMqRT10SBlGvDZ7fi0elriSeJoMMTjnDncy8Gp9bKDXSAe7ym5dincyowGFjmtR7yN4sLivf8BRm65BZ/Xx6HKGqZ1dWCNRhi1O3l2wUk8uPRMPJX5oFVwHR7mxttuZPHDdzJkssic0e+39jFw1Fb38dCM5Y8Ky4qo5HsSKeldPvL3ckJWDGUgIqucAuF9FXmrYkrfzFwrM20WDgUjeJMpeX9yNO34eLPsg5HbrOKxbvaG5OLIIGK3Bv0sTWzm0qKHyDdPDNAYR4wU3eueT37FZVy68CJSGh23dA3x++5hWW0vlsebZCzYgEqjQQ4eODXP/oZRVMfD7V7HgYNfJx7PZmOGAnYadXMoMA8Qw8QfNZ9nmOwkP1EB/jFfpUQXxx2fzkB0Nrn5F6JPHcQa+R4GZUIsHw99SktCyQ4jENgSVlzF5xMIOIkFXyFqGJvCNP78p0XzkxFFHyOd1FPTm0fdmb9DI5qJmp7MZnrWnAwF0yeF9r8hUT/BsJ6W7cN07B1moM13ZO0oGtRWXz2d0qnZNBG5m7Ll1mxn/1k/BlvhcW8yGGrBoM/BYMjunGQFpYIyNlRENB0lkz7M5mr5GRXvbfFc6/UuFOXt9Xqm00n8gT2YjCWYTKUkEh7a2n9NX9/9ZMYi/JyO+VRUXIvZXElr289l4oBen8v8eX/Dbm/g/YgQtZs2bZLxhKLiKRDFGiFuRdKAEJRvBSFWxfZ+Q0OD/PfxeFwKVFExPRqRPiEa8USVVQhLcfvidXfYbCxLpsh77DFSHg+N8+ZxsH4iPk+8g5csXsyiJUsYaWqm89Ah2v0+hn0TO0niPTR/xgwq3G70+w+QqKokOnce5sICKebFYxXiXPxefn6+vH/xM1GJ3rt3L62trZMq0lVVVTItQYj1lpZXueeel+WAmMKidmbMyCcRX8zwcJxEop94PEHdlEoqyueyf38nPT19nH76GdRPr+ex3+yi99DY9EVNClfteioXbyGezmYYC9tFZiy6bOrU75DnuFLGyo10BxnuDjDS56M3voeocRh7qoxYIipFszlcLnfYcqv1XPnNk1XBexxUwXsCUQXvv4eIDxMDIF5w+zl0nHzccUT1UGzPiiixYxvshJ3i8SEv6z0BRHFsuctKvl7P0yPeSVmcxyJOqKK6/IWqIubYLRwMRvjQnjYG40lydVpSsRi+Y6qk/7/QZdIsjQT4uEVh9n13E3rlFYZcOXzuGz9i2JmDQoYKrcLhYx6gbiiMdrcHPRmuW1UnJ+qJGKcWb4Q7QwH6lDTT7WbqbSYZzC+sKi+NBvhr74gUqeNNT5lQEvFqJEz/gn/zaIF7NMLy8g8alHQjYRZbDjLVso+weR5B4ywc8YMUhZ6TjWej5HJQWUwjs8igMMsixuKmaYzo5Gt/dKVe/P58k4eVFj+dCSuNMTuhtCKr1AtNPr5bY6c6dz46nVUKsfb2G+ntu0f+e4uljpqiT5O+bSeDjz3B/Wefwx1nXyaFtikTYblpgC9MmcXCnCJ0OvvrqqGiiuj17cBqmYLBWMBI/5OMdj9CwmggpclQkH+6FFqRkR107P8ew+l2Msf6vjMZ8sNWcqdeg6N0DfaBPgY3PsBOSw+mguygC3ormTbYh0MzgjWURCc60JUcDmXOw6ufia5mMaaCIvLKbFLEJjM9DLT9CU/7HvwRLcMDywn2zcNWshdH1RaSUQfe9pOJukVWtIbqOfm4cjWkDr3MwJCZcNpFrs2Ha94KkikNyXha+n/NDj3GonsY8d8mD8tmmyF95KFwm5y453IuIJ1J4vVukwJCREk57LPxeLceWVwYDIXk5q6kqPA8cnNXHRHJx5JOJ/D5dzMw8CihYDNGYzF6Q54UtMmkH6OhEJ3ewdDQM8RiwgqjkJ93qvw3iUR2MZXjWkZ19WfJyVl+5LVLJoPs3HUVgcA+FMVAXd3X0OtcshlKiGbxu0IEH+0RFaKlqfm/8Pl2Ulp6BaUll6PTvfWqevY2MsRi/XJxIJ6X/1+VdSFQRQVWNMAdLXJFxVNYEESVVlRQRWKEEIjid+rq6mTFt6ysTIrct3qsws97//33S5uEQJ9Okxjb6bKLXdJwmJ6xLPDCwUESOj2evDeIkhM5vek0pXl5TDvYhOHVVyf/vfCf5+Wh0Wql1U1fUoKhtlbGLGaiEXyPPUbSPUruR67GdtFFDI+MyKqyqDgLQXw0breb4ZGH6ev7xRGBKt4bx+4MZO9WT0nJpdTU3EDEZ+aFv24iqV1P7rQX0FvHF/EKdbVfoqLi43LYRiaTJC9vbIDGMWzevFl6f8VFUVR9dUkLmoyWhD5A4RQL11//CVXwHgdV8J5AVMH79iGESCCZYpM3yB+7h2Un9xKnVdoeXvFk82XPznfI0PqRRJJXRgNs8AQn/LTHYaXLxvmFLtnkNu5FFekRwpssRG6txfi6LW2RGVpo0EmxvKmnn8a2TmwmExqHg306oxTmIqt3VY5NNu8JD7LwJA/GEug0GlmhFr5lUZkeTSSlTcOp06JXNDJ39LHte9ms0ROyZJMQ9Ik4ibEBDKZoFEMyjn8slk1giYTJ9XvpKyyZ7M0dY7bNzEnpGHN2bKHAnsMf4uWsb3G/4XNSnmvms6dO4cCAn5e7RunUpElbdWSc+uxUq2PuQ1R1dZ1BKViTdWIkrV5GV4nfc6Ih5o8Ti6fI6JWJqVjJNNquENrhqNjnx5jMyOl87TlaUrX27EWpK4iu1U9OqZ1pi4pZH3y95eWfoSJzmJk04iaPbZrl//D3nRkPF/IIlSYjlkQbupSbEQrZa/kILUyR1WnxXvAdVfVfNbSRLz11KzVVl5D/uc/if/IpNEYjjnPPQXec7de3SrxnI0Mbv0Q41kNSp8GQ1FBW+0nMK76dHcl6FH53iE3P/xhdwf1oRA7wOAkTqeY5eOIVOKauQ9FH8Xctxd+1hHigCFvpHooX3CUrxP+Q0TzaNn+JRHAs2P9N0Br9FM67D2dVduv6H6HR6OSF/s1wOhcyZ/YtcjExMPAYo55NeL27iccGyBw9LOAfHZvWRio1Ieas1mlMn/Z9cnKOP8I8kfCy/8BXcLtFZe/1CLEjFkNC/FZWXEt7x2/p73/wqL83Y7PVY7NOxWAsRK9zEIsPEY+PSBFfXHQh4XA7bW2/JCIn12mkKB8X4gZDAXm5J0vRZDKVMTj4OP0Dj2Cx1JCft5qcnBVvuBD4VxG+0AMHDkgBLKZzihza42bQ/psIUdl66BCGX/8Gzd69NM2op7mhgeRRFq9lox7qR93oS0ppaznEjupqAnY7tmCQ3HSaku4eilpbZaLKEUSaysKFWFetIrxlM6FNr73lYzLNnk3hf/4n1mVLSQVDhLduJR0MkA5HiOxrJLJrN4rFgubkKkZntONR9kgPrc06Hbt2OqPdrxKz+7L+rDd4f5eVfpjqms8R8O/DYqnGan3jUenHInzHwi4pXiPx+ghf8rp162Rl/qc//akqeI+DKnhPIKrgPXGIyocQqKIp6kft/dzcNT6CcTIzrCYuLHRxQaELk6JIG4PYKhdTimbZLbwbEVaM+MgIIfcoSkcHzw97+J/qBtxjQvfoXM2jET8RdoBNnqDME7YqGu6aWyer27/rGpLCW/7ecBTdIV+2wcqolU1WIkVCOxJDIwJ034CMVkPaqcdaZKGywIpVr8Ws10mvsd6qY0iTkUkb36srwanXyeZBMbHvqw/u4cm9/WQMCmmHngaziU8tr2Z+ZY4cipBnNcix07dt7OSH61oQ/VnGYJJVUwv46aWzKXSYaA1HeWbYJ60oYkEjpuQJe0dHJMbeQEQuJvL1CpW0Mz14F5lYL/u1S4hjZH56E2WafnJzlmMyVXLvwChPJ5fLjM1URghzLyUMoJDCj50mZuLR/GPf9DjC6nFDVRHXtB+g97Ofy27xi4XB+GJLp8M4barcbkSvQ5ebh66wUDZUmhoaMM+bi+YNvOmTSMYh0A8mB5jH7ARvQPuB9bS2/JRkxovWEEJnyi4K/xHh4ToUXyXOMgdYNhHLDGPImCgzLCSadDOYPkRaRJWlwDCQT9ws/pDBYC3DrLjI7Okl5i2FnBFSRcMk8r2gZMikFfq3XUNoYBauwl0UWj0Y804mqrMRCu8g7I/i755NMm5jwdktFDZkcLoW4XIulsMExFjZoeFn6O9/RIpUk6lCPp+RaNfrHkMqYUITWUll3ekM9XQT8g9hcxZSWFlMWO+mP9hPQc4CyjWnkc70Eog/gdFQhilzIRaHBUdedtjK8UgnEnTs/Dm9gYcxGgtxFS0nGu3B49kySTwfCbDOaMhpqiQyI0aUiebK4yHEciTSdcRSceSWNFr5NV45FMLZ6ZyHxzNZvFmtU5lS/lXyClbJXoUThRB/Yra09m3uSxn5058Y/tWNKA4HVX+/A011tRTbwhcsmsiEl3icdDxO4LnnSQX8OM48E11+1iYTbW7Gc++9RPfsxbpyJa4PXoGhvPzIv0sMDZHyeMkkE6RGPSR6e4k2N0nxSiqJ/eyzUYxGRm65NdsDIhpsp08n3tlJZqwx7Y1I5mbApsMYzSXlHpUDekQ6AzqIV0PwQ3pipVmbiJLUkz8yj5LomdhPXY2x9vgDn/5Z+vr6uOOOO/jmN7+pCt7joAreE4gqeP//ISwHQsyKLXhRrRXCT+R4TrW+9S7ldzOiGvyLAx2sDcXoionsWFjutGHVKWzzhYim09w5p5aVOXZp5fhYY8dxPdCi+Cqq4kIgCk/wuOuhxKjHkMrQu28ExROXwtSaY2Kl0YwhkpIjowVnzSrmAwvKpUD9ZxjwReVtGHQKhXbjG253HnaH6B6NML/ShdV4YiwjYvsxGu3FYChhgy/KLzsG2ObPPlfivTPbbpaNdE0BH7FklDh6EiLw7phjztFrOS3Xzrn5TtbkOzEoCqN33MHgj38i/968aCGZWJxoY6P8ftiVy4GaKYRMFsyxqGxkFBPxxAU1/9OfwlBXJy+2QgwrYxPu3o7x4Q+80oZVeY5puQ+SVgwUVn2CaTk19LXdije8n0QmggYtVcXXUFV+PTpH4ZFFpXiejMaCIx5aYcc40PhFPIEdb/kY7NoyagbsjOw0si14OYHU8SvDYpJdamzYyrzaFmafPQdbwxICgx78Xb2YLAoayzAH+79PPJnteE9GhM3iFMIjdXg0ZegUI0q/8Q2zg0dtCp2FeqqHEuQGs+9pEbGWTgr7S/YlnnFSKYvPrcFq1RA+eIiexn4GW9yE+0ZIDA1T3LMBWyg7NEBshzvOPZfkolNp2tPEoLsZW+2rmAuzfkz9A+XkrPOjTUfQzC9Fs6KCVLURCkykzRl0cRMpt49h7QbSSlZQ5eedRln5VdlM1hAYfcIGoSFaEqKz+xa83i1HqoXC+pKMexkaeJok2fewaY+e4q6l5Mw7Dcvy5fI9GNqwXopg1wc/hNZmJeX3E29vxzBlClrb620W4rUXzWIp4XE1muTgmfC2rUSFF7avL1s5XbIE28mr5C6DaJrNJOJy4WZbvRpTff2k2xMCNbx1G6H164h3HiYVDErBLJ47cTuxpoP0fP4GMvE4JT/+Ma5LL+GdJDk8LEWv54EHRJlb/kxfVYmhrByNXo9hSh2WRYvkMJ7wtu1E9+8n1tIin4dxrKecjOPsc6RNIrx5sxS/qXwQva7idZULYPE6mkyU/vSnOM4+a9IxyOdUvCnFAloUeHQ6ed//COG1Fs2BarP861EF7wlEFbwqJwKRIyuq1XkG3RG7RzydORIHNx7ZdnVjO695Q+TpdTJJQVS6j27SEtVxYa8QDf6iIjv+74YTSQpE5fZNJtO9nxAXleZwNDuUxDiRQCB+/qLbzz39o/L/YqiJiM0TkXmbvcFJUXsiC/lbtaWcn+8gsn07upwcWcEVDLe0clPPCH/FKBsTx5nuGeHrt/2Omtbm1x2TtiAfQ3kF+opyeWG1nHseA1odneEYllE30w7sJdbZSTwSYWtOIVsWLuWgYpC+azHhTKQwiMr3vQPuI/5l4V0WmcLi8YmItt5oQlbnv1+bI+PhhF/5rT1faemRFdVIs6VONpUlE6MEg824R9cTDnfIJAOxtV9UeC5Wa518Lts9IxAJEzrgIdq4hVhvC3pC5Os7ydd14qiuYrf7ZF7rWHbkvjSIY54sXrXGAAWzHiEeysfTehqteTbWzTLTk58VA0WeJOdvC1HiScmpcx1FOqqGk9QOJKSPeZy4TjwnokEw+71i1JAe72wUhflURIrglO6YxUcmTWWiGUvXHhIaI0MF8wk4qif9iimnQ954dLQWDRlc/nbyhvaQ4z2ELdhDRqMlpTWgT2YrfilbhvBJafS9GvLyVmOsqsL/9DNSeI2jWK3op9TiL+8hXOUj50AFllChFFvJTIjABSlCJ6flVo8YuGhdq2B9WYs2OPGeE828Ynvf/+yzZERTmhhJXF0tb1vYb6zLlsnKqPsPfyB4rP/12PeB+M8AGROkcjPEpmVIlmXQDWqwGaZDiYWowY22NYb+BQ+asQEqb4b15FVU/OEP75oUECHuxch086xZGOvr3/S4hEBNDg2R9HrlgtVYWztxO0NDRHbvJiqSI8R5Q+xOhkLytRMLC0HOlR+Wi4VEfz+eO+8iNjZK+gg6HfbVq3FdcTlaEacWCEiLRmjTJpIjI2QiEbkAU845m6prrlEF73FQBe8JRBW8Ku8kQvS8NOqXAx3GxbHKv4Y/mZJJD0LwiotePJ1mizckGyofGfIwHE8eyWNe6szmC4sFxtpRP99p6T3y9yIOrdhgkMkgohFQvCqfHOzk8ttuRRvwE0skOOzMpb2skrbyStrKKuktLGYoJ18OxBhnfvN++fXESacznPvm9gtRhf5IaR5FRr3MzX5gwPO637m0KEf+nrCkiMcppguKcb/CBiN2D8SXGM1daNDTFo5Kf7zwugvRb1Y0LHfZZdScmFgofPDi+RI+56kWo/TCi12I8ZHB48/DdflGTk4PkUjGsdnzKSjNDiDY+8Q6dr46SjhoRYTcpZQMHqsWUzyDLZYhZNQw7NTSUainsdqAz6rlwqGXOXdkHVtzluCPa1nasxNXLMXjyz/MHkctcyJhlh/Yz1Q3RNM5mG0pDpRqud2Ri19xktBqCJg1VIwkOWe7jyL/0cbLOMW6UZyFdiKmPLraJk9llL+STpHvb6K2LIm9qgi3T8toJofRmJWAe/JWuFx4aLK37wx0MkVziIJCLQZdhuAzTx6pKEpE4kxhIelIhPRRCQTHIhqwHOedi+GKFbSN3IQ/vm/80DHt02PT1aHsDaC8NiTdFtH5aRL1BpTeOPo+DVqPBiUMiZIMifJMVjRntBgKS8nEUhj0eThqlqGdUYzPfkg2+YVD7aS0r38ujnt8Q+Bal0th3lmYZ8+R1d3YoRZZ/RS2AjEaXjSOFX3zG1KUv5cQcX3B0ajMx9YZtRTXOOQgl5GeAJ6BMFUz8zCYj3/+zSSTDP7853ju+PvbdjzBVIolrS2q4D0OquA9gaiCV0Xl/Y+oit/SPcwt3UOykW0cYR0Zb5qsMxv53pRSKYSFYB6KJfj6oR6ZIiIQYlGkjbSEY2/YaCkaGIvdwwzkF8pO9XFyohFWbNvEzI4WKZRFNJ01EqY4FuXMaIDlujSOs86SzTuMZSR3hGNUm408Mezl92ODKE40JkVs4matNMdDVNddei1Noai02iipDLZomoBZwZRKsmr/Lubv2cm++gZenb8Up17LmrIiLrbqqbvvbwReXU+spf112duyjJs5fmUupdGwefYCXpuzgJ0Nc+nPyS4e9IkMrlAKbQYGnVqMOoX5DgtLxDTA/jianW70abAYdVROcTF9Xg4Wl1luOx+LbzhM5143XQdGGWjzEn8Tn7zVrsUZ7iY31UdFvULF1CD6UDuZkTairYdJ+JLo8vLRFNWQVIpJaQswnXYFxoY5R3zgopo+PPw8nYdvIRDI2mnGycTsiKklGusbi+d/HjE+3YXTuUBW9gMjjfjdO9EnbRgpwGduIknW31xUdCH10/9bNhyOH6uwMQgrzxuRSqRJJrPb+uMvrcGkRXkLY6fHE1H8/j2EQ22yGVA0lVVUfEw2P/6jSnImncHdF2TocAB3b1AeiziGsD9O0JMVuVExLeYoxHhui9PIUKdffm+06pi/ppIZK0qxOAx4h8K0bBsk6IkRDQcxWs3YgoMYW3aga9yASZfCdfllOM87j4xBSzDSRCjSRmB4D57urQQ1o5gGFawDRtI1NiIlcfRGFw7zFFK9w4wc2sfp32xUBe9xUAXvCUQVvCoq/3cQvl8xTnuDJ8CDgx5awzEpYkVD2+erCl83NEVc7MXwjW+19EyaOCjGLDdYzTLtY6bNTK1RT+GBfeT5PZinTGGopIyb+j2ywnpJUQ4fKMoh09SE/5lnZRNPcmiY0GuvyS3OIygKRd/5NrlXXvm6497mCXDXzn009w0yZDDiCAXJ9Xkxx2IYE3EMiYRMBwmarYw4c8gJ+Fh0sJGp3R3YwmFGnS521M9iOCePyv5eqgd6cAiPZjolBXh3dR0zTHpWGjU4y8oJVlbxeEEZd/qj0lZhUDSympw5JuPaGg3L2z9t+ybO3/AStkhYRCvIZqBx9JWVpNzuIw1GAl1REbqCfDJhH7GOHtk7prcmsVdE0WgypGIKGZFL7KzE2DAfy5qLMc1ZKMWqO55k//AoQ+kMSZ1OLkCeGPIedzT5kadW5HcbdLL6P8WSTWYRVW9tPEjK348v7KcrKR5jhgXRwyzsP8iMgRdwJKLsDZ9LU+Q0Gek2qZ1/DA0JHMYejMZhggYDMZ2CM+3FlXGjMw+TsIbx6OoJuc7ApinF6E8TGokQdkfJaDMYyw5hNjRjth/GUtiM1pC1UCRjNkI987DbetHaR0gbomh0CRJhF1FPFemkEY2SQqMkUbQJdGYvetsQmZSeYN9cQoNzKChqoLK+gUzaRCKakkJeCMLcUisldU7seSYpKJPJEF1df6bz8M3SP6/X51BQcBYu12KIBSA0hD4YQJfKEMxdwkBfkEhokEh0iEggQiwSweTqxpTbQTplIOYrI+6pwZCYjc02D8Vow2DRkV8bwJrfjaJLEIv2Mzj4LKFw0xu/bpkyzPq52KyzsTuFNaeQgDtMKOAjmRqUAjkU247e2kUinCfv13d4KeFBkcF8tFDOoDcp2HIshHxh0hk3ij6CJmPEaLERcCMbR101G3FW7icWsJII5WPKOSwfUypuI9CzQEYARty16KwGbHWHsZTuwmrehIa31nA6TiiU5qILO1XBexxUwXsCUQWvisr/TYSYFZXKHL3uTcdjC4bjCZ4f8ZNv0NFgM1N+lI/4X0VsgYsYpXh3D+EtWwi88IL8uWXxYjmFUHgMhShM+QMEN6wnNTwi/15jNmOeM0emR+jy81CsNnTFRTKvVHS3xzvaSfn8cpiLNidXRjaJZqjAi2uJHWqWDUzie11RoTCJ4334IZJ9/cc9Rn15OYrdTqK7m2AiKSvTQYuV6Yfb5XRC0dBU+PWvk+jrJbp3r2zuMy9YQOzAAXyPP4Hv8cdJj2XEir/L+/i1WJYtRy/ue/x5CIdJtu5E3/sUGjGAI+qDeED6cCdhdGQj3nJrYdZlMOtSsBcfeS3F4kVMgxTVcTEkR8QMDsYT0qpy/Hr1PyY3GWBaxkdNJkTY24dbk0uxN0W5O0k8UobJZ8F6lKf43yFo1NBRqsGV30hNrIdU8xIysaOTPjIo2jBm/ShKjo60NZd0LIUurWDM6MkvtFK3ooZ4DPY+385g9z+Or0sbIOoSqeBpdLE0NnsLFXNvx2B941jEf5Z00iDFo0ZJYLBP+J2PPKq0QtRbgdafh+K3EgkWkCoewlG1GUX75vF3b4Q2NRODUoui85PW9BJLdZPOxMhojMKjgEbOs/zXyIidCNE8qUy87smoTT6GaKCUhK+UZCgXo6sXo6tLPvaAtxa9NoLZ2SPHHQf8Oq77xs2q4D0OquA9gaiCV0VF5Z1GCDb3H//E8K9//Ya/I0RwztVXkXvNNbLh7m2772SS8I6dUijHu7qJdx0mcfgwsbb2bPf5GKL73Dx3rhS0Mq5tRj3GKW+eSSqquoGXXkbrdGA96aS3Fu0miIeh9UVoegq6t4Cn4/i/lz8dKpZAbg2IgRLtL0P/3uz3JfOkOE6ZcnAfeomB3kY6TKW0WioZ1TmJaI0kNTr0RitWk5VKbRqdwcxmbTHbMk5602/BU5/JUBaBUneC/FCGfBQsaRHFlkQJJSl0JzDGMiT1GSLWCCN2DV0uOyFLEp3BR0E8SGEojU7jI+5wsyF3Aa2WqiO3XTKaonYwQYE/Jf3QBysMxMdGVB9LbtzL8sA+TOkkW23T0YetnNTqId+nlaO0PUYzQaNBVulLPEmKPVk7yOvQpLAUNGOv2IFBVIzTIv88LRsRRVVUVJCF/UTEQZviKTmx0KzxY48lcWiKSdvyCVo1DOPBZxolo5sQrZm0lshoNemEmXTCRGiwgUx/Jf7o2GM+iiJLI/b8/UTyIig2D3rbCFpjUN63JqWQiVpJRO30ZyrY6prBlFQHDek9mBwDk/Otj0MSLSGsskXVxITH+VBqJs3ekwja0tiNgwxQSiNzKaGPpWyigX0UMSh/NxjLwzc6DX/XMuiqn0gd0YAjz4Q+34TbrqWv2MD+Qi2peJq8gRijvhiRYIAXv3CGKniPgyp4TyCq4FVRUXm3EGlslJ3fGZHjHArJBAAhEq0rVmBeuBDlBGa3HouIpYrs2SM720VOqr6i4k19nCeU8ChEPGKfHw5vhL33Qc/2bI7uP0NhA5TOz4rhkrlQPAvEaOc38H23RWJytHdHJI5dxPUZ9LKRUVhVRErK2QVOaZF4I2R0WCCB2SZ2BIRKGsqKd70ZbMVgzc9WrcXj6tslCu68ap3BOm+Qw5G4HJoyy26mwmTgNW9QjvO2kCQ3PIBZZAErOgY1JroUB6mjJsi9EWK8eBkRytJ+isMjlHlD5HiT6HRaklYrQZMDj9aBL2PAl9TiHE1T25XAFEzTnaelo0jPvqpsE6LAkEkxQxtjvsuOxZJLRDzeVFp6wEV84EKHkWoG0Hj3kgkOkApZ8Ps0eMI1RGIuXLVGHIVJeodjDLQm6cFIh05LuEBHuT3MvqSRw6l/rpnXlRnlVF5CR0KK2hEK6KGCEHamRdpwJsJstC8kqphpCLay2NeIoqRIaxQq0nHK8yvZaa9nCy6KTSYWuZxMS3so9hykOOHFoY2gjLZhbH4ZvIflfaYzCtG0nXjGjF07gtZgBGcZOMa+xJ/zp8n3XtRSwNreYc6fOkUVvMdBFbwnEFXwqqioqLwHESL48CYY2Aveboj5oWolVCzNisqBRvB2QXAwK3AXXQv52Ri69xsikWSPL8hrfYfln5eUVJJn0LO3t5WhkJ/q/DKm5pVQYzFNikb8ZxC2nvWeIK+OBmSiR1c0Nmkc+IlCxPKJ4UT+ZBpvMok3kZLxg6LB0qVTONmqYYU+SnNSx66Ygk2no9RoZJbDxpJcBw6tVg4yylUylPlbIThMTNETScRxBQ5nLTS5ddnFkHh/vFWrkuiMGzoIzU9nF1/+HvD1QmR8DPEb449lcP40oAre46AK3n/AzTffzC9+8QsZ5iwmvdx0000sWbKEt4IqeFVUVFRUVP45RLZ4dzTObn+YxmBEfm9WFCmohRgVTYTbfVk/tZhnJmTk+N+L/4tGSFEJFrF6RbKh0EiDzcRcu4VAKkVTMEqhUc9Z+Q6sR8X9iaq5MCyIKZHvShIR8PeBrwf8vdkvsSAb3A+D+4ThVxW8b4IqeN+E++67j49+9KPceuutLF26lN/85jc88MADctRhYeFEY8QboQpeFRUVFRUVlRNOOiXtK36/D2dBqVrhPQ7/2v7D/xFuvPFGrr/+eq699loaGhqk8LVYLNx2223v9KGpqKioqKioqGQRfm2D5Q194yqq4H1D4vE4O3bs4IwzzjjyM0VR5Pevvfaa+t5RUVFRUVFRUXmPoM4bfQNGRkZIpVIUFRVN+rn4vqnp+GHWsVhMfh1taVBRUVFRUVFRUXlnUS0NbyM/+clPcDqdR74qKirezptXUVFRUVFRUVH5F1AF7xuQn5+PVqtlcDAbBD2O+L64ODuB51i++c1vSqP4+Fd3d/e/8pqoqKioqKioqKi8jaiC9w0wGAwsXLiQtWvXHvlZOp2W3y9fvvy4/8ZoNOJwOCZ9qaioqKioqKiovLOoHt434ctf/jLXXHMNixYtktm7IpYsFArJ1AYVFRUVFRUVFZX3BqrgfRM++MEPMjw8zH/913/JwRPz5s3j2WeffV0jm4qKioqKioqKyrsXdfDECUQdPKGioqKioqLy/wtVd7wxqodXRUVFRUVFRUXlfY0qeFVUVFRUVFRUVN7XqB7eE0gmk5H/VwdQqKioqKioqJxoxvXGuP5QmUAVvCcQt9st/68OoFBRUVFRUVH5/6k/xAAslQlUwXsCyc3Nlf/v6upS33jvkZWxWJyIgSFqhvJ7A/U1e2+hvl7vPdTX7L2FGHpVWVl5RH+oTKAK3hOIomQt0mKVpQqo9w7q0JD3Hupr9t5Cfb3ee6iv2XtTf6hMoD4jKioqKioqKioq72tUwauioqKioqKiovK+RhW8JxCj0cj3vvc9+X+Vdz/q6/XeQ33N3luor9d7D/U1e2+hvl5vjDppTUVFRUVFRUVF5X2NWuFVUVFRUVFRUVF5X6MKXhUVFRUVFRUVlfc1quBVUVFRUVFRUVF5X6MKXhUVFRUVFRUVlfc1quA9Qdx8881UV1djMplYunQpW7duPVF3pfJvsm7dOi644AJKS0vRaDQ8+uij6nP6LuYnP/kJixcvxm63U1hYyMUXX0xzc/M7fVgqb8Itt9zCnDlzjgwvWL58Oc8884z6nL1H+OlPfyrPjV/84hff6UNReQO+//3vy9fo6K/6+nr1+ToKVfCeAO677z6+/OUvy0iynTt3MnfuXM466yyGhoZOxN2p/JuEQiH5GolFisq7n1dffZXPfvazbN68mRdeeIFEIsGZZ54pX0eVdyfl5eVSNO3YsYPt27dz2mmncdFFF7F///53+tBU/gHbtm3jD3/4g1ywqLy7mTlzJv39/Ue+NmzY8E4f0rsKNZbsBCAquqIC9bvf/U5+n06nqaio4POf/zzf+MY3TsRdqrxNiFXxI488IquGKu8NhoeHZaVXCOGTTz75nT4clbdIbm4uv/jFL7juuuvU5+xdSjAYZMGCBfz+97/nhz/8IfPmzeM3v/nNO31YKm9Q4RW7k7t371afnzdArfC+zcTjcVnFOOOMMyaeZEWR37/22mtv992pqPyfx+fzHRFQKu9+UqkU9957r6zIC2uDyrsXsZNy3nnnTbqeqbx7aWlpkda82tparrrqKrq6ut7pQ3pXoXunD+D9xsjIiDyhFxUVTfq5+L6pqekdOy4VlfcjYvdE+ApXrlzJrFmz3unDUXkTGhsbpcCNRqPYbDa5k9LQ0KA+Z+9SxKJEWPKEpUHlvbGz/Ne//pXp06dLO8MPfvADVq1axb59+2S/g4oqeFVUVN7jFShxQle9au9+xIVYbLeKivyDDz7INddcI20oquh999Hd3c0XvvAF6ZEXjdcq737OOeecI38WfmshgKuqqrj//vtV29AYaoX3bSY/Px+tVsvg4OCkn4vvi4uL3+67U1H5P8vnPvc5nnzySZmyIZqiVN7dGAwGpkyZIv+8cOFCWTn87W9/KxuiVN5dCFueaLIW/t1xxM6l+KyJ3pRYLCavcyrvXlwuF9OmTaO1tfWdPpR3DaqH9wSc1MXJfO3atZO2XcX3ql9NReXfJ5PJSLErtsRfeuklampq1Kf1PYg4LwrhpPLu4/TTT5cWFFGRH/9atGiR9IWKP6ti973RcNjW1kZJSck7fSjvGtQK7wlARJKJ7TpxgliyZInsahUNGtdee+2JuDuVt+HEcPQquKOjQ57URRNUZWWl+vy+C20Md999N4899pj0pg0MDMifO51OzGbzO314Ksfhm9/8ptxyFZ+nQCAgX79XXnmF5557Tn2+3oWIz9Wxnnir1UpeXp7qlX+X8pWvfEXmyQsbQ19fn4xFFQuTD3/4w+/0ob1rUAXvCeCDH/ygjEr6r//6L3kxFlEuzz777Osa2VTeHYhc0NWrV09asAjEokU0Aai8+4YYCE499dRJP7/99tv52Mc+9g4dlcqbIbbHP/rRj8pmGrEwER5DIXbXrFmjPnEqKm8DPT09Uty63W4KCgo46aSTZFa5+LNKFjWHV0VFRUVFRUVF5X2N6uFVUVFRUVFRUVF5X6MKXhUVFRUVFRUVlfc1quBVUVFRUVFRUVF5X6MKXhUVFRUVFRUVlfc1quBVUVFRUVFRUVF5X6MKXhUVFRUVFRUVlfc1quBVUVFRUVFRUVF5X6MKXhUVFRUVFRUVlfc1quBVUVFReZfxpS99iUsvvfSdPgwVFRWV9w2q4FVRUVF5l7F161YWLVr0Th+GioqKyvsGdbSwioqKyruEeDyO1WolmUwe+dnSpUvZvHnzO3pcKioqKu91dO/0AaioqKioZNHpdGzcuFGK3N27d1NUVITJZFKfHhUVFZV/E1XwqqioqLxLUBSFvr4+8vLymDt37jt9OCoqKirvG1QPr4qKisq7iF27dqliV0VFReVtRhW8KioqKu8ihJVBre6qqKiovL2ogldFRUXlXURjYyPz5s17pw9DRUVF5X2FKnhVVFRU3kWk02mam5ull9fn873Th6OioqLyvkAVvCoqKirvIn74wx/y17/+lbKyMvlnFRUVFZV/HzWHV0VFRUVFRUVF5X2NWuFVUVFRUVFRUVF5X6MKXhUVFRUVFRUVlfc1quBVUVFRUVFRUVHh/cz/AxI3gzkkkijGAAAAAElFTkSuQmCC",
       "text/plain": [
        "<Figure size 700x400 with 1 Axes>"
       ]
@@ -448,12 +494,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 700x400 with 1 Axes>"
       ]
@@ -475,7 +521,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -533,13 +579,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "94b59bbda4a549769e9b6fd0fde33b1f",
+       "model_id": "24ea5c51fdde42e5a790a7bc459f3009",
        "version_major": 2,
        "version_minor": 0
       },
@@ -578,7 +624,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -598,7 +644,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [
     {
@@ -790,9 +836,8 @@
        "6        21.2361  "
       ]
      },
-     "execution_count": 16,
      "metadata": {},
-     "output_type": "execute_result"
+     "output_type": "display_data"
     }
    ],
    "source": [
@@ -828,7 +873,7 @@
     "#======= Parameters for GBM comparison\n",
     "results_data = []\n",
     "params_ql = {'initial_value': 100, 'mu': 0.05, 'sigma': 0.2, 'maturity': 1.0, 'n_steps': 252, 'n_paths': 2**14, 'seed': cf.QUANTLIB_SEED}\n",
-    "params_qp = {'initial_value': 100, 'mu': 0.05, 'diffusion': 0.2**2, 'maturity': 1.0, 'n_steps': 252, 'n_paths': 2**14, 'replications': 3}\n",
+    "params_qp = {'initial_value': 100, 'mu': 0.05, 'diffusion': 0.2**2, 'maturity': 1.0, 'n_steps': 252, 'n_paths': 2**10 if IN_COLAB else 2**14, 'replications': 3}\n",
     "theoretical_mean, theoretical_std = calculate_theoretical_statistics(params_ql)\n",
     "\n",
     "# Add theoretical values once\n",
@@ -879,7 +924,7 @@
     "\n",
     "# Create DataFrame\n",
     "results_df = pd.DataFrame(results_data)\n",
-    "results_df.round(4)\n",
+    "display(results_df.round(4))\n",
     "\n",
     "# Store variables for visualization cell (extract individual values from params)\n",
     "paths, qmcpy_paths = quantlib_paths, qmcpy_paths\n",
@@ -892,12 +937,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1100x800 with 5 Axes>"
       ]
@@ -930,7 +975,7 @@
     "\n",
     "# Generate specific data for visualization (ensure we have data for both libraries)\n",
     "params_vis_ql = {'initial_value': 100, 'mu': 0.05, 'sigma': 0.2, 'maturity': 1.0, 'n_steps': 252, 'n_paths': 2**14, 'sampler_type': 'Sobol'}\n",
-    "params_vis_qp = {'initial_value': 100, 'mu': 0.05, 'diffusion': 0.2**2, 'maturity': 1.0, 'n_steps': 252, 'n_paths': 2**14, 'sampler_type': 'Sobol'}\n",
+    "params_vis_qp = {'initial_value': 100, 'mu': 0.05, 'diffusion': 0.2**2, 'maturity': 1.0, 'n_steps': 252, 'n_paths': 2**10 if IN_COLAB else 2**14, 'sampler_type': 'Sobol'}\n",
     "\n",
     "# Generate paths for visualization\n",
     "vis_quantlib_paths, _ = qlu.generate_quantlib_paths(**params_vis_ql)\n",
@@ -996,7 +1041,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1006,7 +1051,7 @@
     "    for sampler_type in samplers_to_test:\n",
     "        print(f\"QuantLib ({sampler_type}) timing:\")\n",
     "        benchmark_func = lambda st=sampler_type: qlu.generate_quantlib_paths(**base_params, sampler_type=st)\n",
-    "        timing_result = %timeit -n 10 -r 3 -o benchmark_func()\n",
+    "        timing_result = get_ipython().run_line_magic('timeit', f'-n {1 if IN_COLAB else 10} -r {1 if IN_COLAB else 3} -o benchmark_func()')\n",
     "        timing_results[sampler_type] = {\n",
     "            'average': timing_result.average,\n",
     "            'stdev': timing_result.stdev,\n",
@@ -1027,7 +1072,7 @@
     "    for sampler_type in samplers_to_test:\n",
     "        print(f\"QMCPy ({sampler_type}) timing:\")\n",
     "        benchmark_func = lambda st=sampler_type: qpu.generate_qmcpy_paths(**qp_params, sampler_type=st)\n",
-    "        timing_result = %timeit -n 10 -r 3 -o benchmark_func()\n",
+    "        timing_result = get_ipython().run_line_magic('timeit', f'-n {1 if IN_COLAB else 10} -r {1 if IN_COLAB else 3} -o benchmark_func()')\n",
     "        timing_results[sampler_type] = {\n",
     "            'average': timing_result.average,\n",
     "            'stdev': timing_result.stdev,\n",
@@ -1039,7 +1084,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [
     {
@@ -1047,17 +1092,17 @@
      "output_type": "stream",
      "text": [
       "QuantLib (IIDStdUniform) timing:\n",
-      "762 ms ± 4.04 ms per loop (mean ± std. dev. of 3 runs, 10 loops each)\n",
+      "1.09 s ± 4.85 ms per loop (mean ± std. dev. of 3 runs, 10 loops each)\n",
       "QuantLib (Sobol) timing:\n",
-      "835 ms ± 6.01 ms per loop (mean ± std. dev. of 3 runs, 10 loops each)\n",
+      "1.17 s ± 5.28 ms per loop (mean ± std. dev. of 3 runs, 10 loops each)\n",
       "QMCPy (IIDStdUniform) timing:\n",
-      "287 ms ± 6.01 ms per loop (mean ± std. dev. of 3 runs, 10 loops each)\n",
+      "279 ms ± 993 μs per loop (mean ± std. dev. of 3 runs, 10 loops each)\n",
       "QMCPy (Sobol) timing:\n",
-      "297 ms ± 3.86 ms per loop (mean ± std. dev. of 3 runs, 10 loops each)\n",
+      "275 ms ± 1.03 ms per loop (mean ± std. dev. of 3 runs, 10 loops each)\n",
       "QMCPy (Lattice) timing:\n",
-      "285 ms ± 2.8 ms per loop (mean ± std. dev. of 3 runs, 10 loops each)\n",
+      "277 ms ± 1 ms per loop (mean ± std. dev. of 3 runs, 10 loops each)\n",
       "QMCPy (Halton) timing:\n",
-      "2.01 s ± 5.91 ms per loop (mean ± std. dev. of 3 runs, 10 loops each)\n"
+      "1.93 s ± 58.6 ms per loop (mean ± std. dev. of 3 runs, 10 loops each)\n"
      ]
     },
     {
@@ -1093,49 +1138,49 @@
        "      <th>0</th>\n",
        "      <td>QuantLib</td>\n",
        "      <td>IIDStdUniform</td>\n",
-       "      <td>0.761604</td>\n",
-       "      <td>0.004041</td>\n",
+       "      <td>1.086473</td>\n",
+       "      <td>0.004846</td>\n",
        "      <td>-</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
        "      <td>QuantLib</td>\n",
        "      <td>Sobol</td>\n",
-       "      <td>0.834711</td>\n",
-       "      <td>0.006006</td>\n",
+       "      <td>1.170537</td>\n",
+       "      <td>0.005275</td>\n",
        "      <td>-</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
        "      <td>QMCPy</td>\n",
        "      <td>IIDStdUniform</td>\n",
-       "      <td>0.287149</td>\n",
-       "      <td>0.006005</td>\n",
-       "      <td>2.652299</td>\n",
+       "      <td>0.278809</td>\n",
+       "      <td>0.000993</td>\n",
+       "      <td>3.896829</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
        "      <td>QMCPy</td>\n",
        "      <td>Sobol</td>\n",
-       "      <td>0.297095</td>\n",
-       "      <td>0.003863</td>\n",
-       "      <td>2.563506</td>\n",
+       "      <td>0.274826</td>\n",
+       "      <td>0.001031</td>\n",
+       "      <td>3.953305</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
        "      <td>QMCPy</td>\n",
        "      <td>Lattice</td>\n",
-       "      <td>0.285152</td>\n",
-       "      <td>0.002803</td>\n",
-       "      <td>2.670867</td>\n",
+       "      <td>0.276884</td>\n",
+       "      <td>0.001002</td>\n",
+       "      <td>3.923928</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>5</th>\n",
        "      <td>QMCPy</td>\n",
        "      <td>Halton</td>\n",
-       "      <td>2.007001</td>\n",
-       "      <td>0.005915</td>\n",
-       "      <td>0.379473</td>\n",
+       "      <td>1.926630</td>\n",
+       "      <td>0.058623</td>\n",
+       "      <td>0.563924</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -1143,17 +1188,16 @@
       ],
       "text/plain": [
        "     Method        Sampler  Mean Time (s)  Std Dev (s)   Speedup\n",
-       "0  QuantLib  IIDStdUniform       0.761604     0.004041         -\n",
-       "1  QuantLib          Sobol       0.834711     0.006006         -\n",
-       "2     QMCPy  IIDStdUniform       0.287149     0.006005  2.652299\n",
-       "3     QMCPy          Sobol       0.297095     0.003863  2.563506\n",
-       "4     QMCPy        Lattice       0.285152     0.002803  2.670867\n",
-       "5     QMCPy         Halton       2.007001     0.005915  0.379473"
+       "0  QuantLib  IIDStdUniform       1.086473     0.004846         -\n",
+       "1  QuantLib          Sobol       1.170537     0.005275         -\n",
+       "2     QMCPy  IIDStdUniform       0.278809     0.000993  3.896829\n",
+       "3     QMCPy          Sobol       0.274826     0.001031  3.953305\n",
+       "4     QMCPy        Lattice       0.276884     0.001002  3.923928\n",
+       "5     QMCPy         Halton       1.926630     0.058623  0.563924"
       ]
      },
-     "execution_count": 19,
      "metadata": {},
-     "output_type": "execute_result"
+     "output_type": "display_data"
     }
    ],
    "source": [
@@ -1163,7 +1207,7 @@
     "# Create base params without sampler_type to avoid conflicts  \n",
     "base_ql_params = {k: v for k, v in params_ql.items() if k != 'sampler_type'}\n",
     "# Add the required parameters for QMCPy benchmarking\n",
-    "base_ql_params.update({'n_steps': 252, 'n_paths': 2**14})\n",
+    "base_ql_params.update({'n_steps': 252, 'n_paths': 2**10 if IN_COLAB else 2**14})\n",
     "# Create QMCPy parameters (note: diffusion instead of sigma)\n",
     "base_qp_params = {\n",
     "    'initial_value': 100, \n",
@@ -1171,19 +1215,19 @@
     "    'diffusion': 0.2**2,  # sigma^2 for QMCPy\n",
     "    'maturity': 1.0, \n",
     "    'n_steps': 252, \n",
-    "    'n_paths': 2**14\n",
+    "    'n_paths': 2**10 if IN_COLAB else 2**14\n",
     "}\n",
     "# Run benchmarks\n",
     "quantlib_timing_results = benchmark_quantlib_samplers(quantlib_samplers_to_benchmark, base_ql_params)\n",
     "qmcpy_timing_results = benchmark_qmcpy_samplers(qmcpy_samplers_to_benchmark, base_qp_params)\n",
     "# Create comprehensive timing table\n",
     "timing_df = du.create_timing_dataframe(quantlib_timing_results, qmcpy_timing_results, quantlib_samplers_to_benchmark[0])\n",
-    "timing_df.round(10)"
+    "display(timing_df.round(10))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1211,12 +1255,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABXgAAAJYCAYAAADYAI6PAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAsMxJREFUeJzs3QeYE1XXwPGzlKX33ntbepciIFVAELEAKiAgKi6IICCIUqRaqLqKIl2RIkVRpIiidKkqLiArSO+w9CK7+Z5zfZMvyfbdZFP2/3uegc1kMplMbpI7Z86cG2CxWCwCAAAAAAAAAPA5qTy9AQAAAAAAAACAxCHACwAAAAAAAAA+igAvAAAAAAAAAPgoArwAAAAAAAAA4KMI8AIAAAAAAACAjyLACwAAAAAAAAA+igAvAAAAAAAAAPgoArwAAAAAAAAA4KMI8AIAAAAAAACAjyLACwAAAAAAAAA+igAvAAAAAAAAAPgoArwAAAAAAAAA4KMI8AIAAAAAAACAjyLACwAAAAAAAAA+igAv/EpAQECUqV+/fjEu//7770f7mH/++UdSmn379kW7L/bv3x/r4+yXLV68uHi7UaNGOWzz3Llzxd/oa4ruvYxuyp49u6RkoaGh8vrrr0uDBg0kf/78ki5dOsmYMaOUKFFC2rdvLx988IFcuHDB05vp1+1TP5MAAP8RW78jQ4YMUqxYMenYsaMsW7ZMLBaLR7f12rVr8sYbb0jFihXN77/9tmrfGP5v/fr18tJLL0mVKlUkd+7ckjZtWsmSJYsEBQVJ165dZdGiRXLnzh1Pb6Zfee655xw+axs3bvT0JgF+gQAv/N68efNM581ZRESEfPjhhx7ZJm80Z86caOf7YwDUneiw+IarV6/K008/LZUqVZJ3331Xtm7dKufOnZN79+7J7du3zUmeVatWySuvvCKtWrXy9OYCAOAXNFB2/PhxWbFihTzxxBPSsmVLuXnzpse2p127djJhwgRzwld//5FyHDx4UGrXrm3a4CeffCJ//PGHXLp0Se7fvy83btyQAwcOyOeffy5dunQxJwEAwNul8fQGAO52/fp1E7zs37+/w/yvv/5ajh07xhsgIv/++68sXLgw2n3xxRdfyMSJEyVNGr4ufJVmIzRu3Dja+zJlyiQpjXbeNWP30KFDDvNz5colNWrUMFm8p0+flt9//9108iMjIz22rf5IM/0ff/xx223NkAEA+K/WrVub7Fg9iaq/rfb97x9++EH69Okj8+fP90iA75dffrHd1r7uQw89JFmzZjW3U/pVTv5sx44d0qxZsygnF0qWLCnly5c3fb+///5bDh8+bObTF3QtDaxrEN0qT548Ln4GIGUiYoMUQTN1NRNPLwGxmjZtmke3yZt8++23cvHiRdttvTRJg77q7NmzsmbNGnnkkUc8uIVICr3s8KuvvmIn/k+nTp0cgruBgYEyZcoUefHFFyV16tS2+eHh4ebkkH4+4DpNmjQxEwAgZfjoo49sZbz0xGmvXr0cArqaJfnee+9Jvnz5knW79Mode5pR/OWXXybrNiD5Xb582WRu2wd3CxUqZNpk06ZNHZY9evSoTJ061RwbwXWCg4PNBMC1KNEAv6Y/1iosLExWr15tm681taxn7LUWWI4cOeJcl3ZINctV63IWLlxY0qdPb+ozVa5cWQYPHiwnT56M9nEaHNIfsIYNG5rObbZs2UwnQZ+zZs2a8tprr8mRI0eifawub1+fSGm9Ms0u0PXotus6FixYIEnhXIbBuSZmQso0aC21zz77zJyZzZw5s8l+0Evcf/7552iX18ufNHNDg5C6PzV7QjMpy5UrJx06dJCxY8ea98+Znklfvny5yQQsWrSo2ReaHaJn3vXSe80ISYy4agrHVILBOl9LgtjT9yq2GlNnzpyRkSNHygMPPCA5c+Y0bUMzbps3by6zZs2yBdo9WR9VO7f6+vTzpO+P/p3QZa1OnDhhLnPT9qGfAX29+n5rRu24ceMcTjTE9r5oFpCWVtB6aZqFbH/yJjb6PbBhwwaHedpeX375ZYfgrtK2O2DAAIfvjqS2v+hqQGsWSdu2bc3+0KwhbTM//fST7TFa+61evXrmdernXjOhfv311yjr1rZlv27d91qKQmsMly5d2nxnaZ3h7t27m/cpuszmMWPGmNekn0f7msT6GvW7TzP6o8tiSWq7sacHXFofvVGjRpI3b14TgNfvEq3Z+OCDD5r3JKagu2Zj6dUaVatWNftKH6vr0AM2Palnny1ipeU47LdHg893794126Dr0fdW1/Xwww/L9u3bo31eAED86O+B8/e+9h137twZZZ5+1z/11FPmd9/6O6v9Q+036vd9dPQ73HlcDe0763z9Xbf2xazf9/b09zamPqD+fmhdfu2faSBaf1/0t0H7IZpEov3ZpGxPTMtq8Ltu3bqmD6BZjtrHsB43aF9o/PjxJuNUf+MLFCggPXv2NH1LZ7qut956ywQ2dR/a/76WKlXK7OeYfluj67to31yfS3/jdT3aT9D9oP2OmPz1118yaNAgqVWrlq3Pq9thPR6Kbrvd0U/WKxPtx1fQdqX9NufgrtIxGbT/oMcjzlzZJlz1Pkf3Xul+f/bZZ83jtF+nfcLhw4dH2yfSDHvtN+qxW5kyZUwf3VqTWJ9f+5CbNm2K9nVFd4yk/Vntt+p6UqVKZTumjKuknR4vaFupXr26+Zzo94b2k3XbdX0jRoyQvXv3Rrsd2s9/5plnTLvW/an7TNunte53fPuxmuSkfUptA7rftF/co0cPOXXqVLTPC3gFC+BHtEnbT2PHjrX93aJFC9ty3bt3t83v3bu3pVixYg6PO3r0qMN6T58+balTp06U9dtPWbJksXz99ddRtqlt27axPk6nDBkyWL7//vsoj3Xerm7dusW4jilTpiRqn507d86SJk0a23pKlChhuX//vqVAgQK2eYGBgZZLly7Fuc8LFy5s6dKlS7TbFxAQYPnss88cHrtp0yZL+vTp49w/H3zwgcPjLl++bHnooYfifFynTp0sd+/edXjsyJEjHZaZM2dOjK9H978z+7aj008//RTt/Jgm6/Jq+fLllqxZs8a6vLa7s2fPJug91ddkv47GjRsn+rHt27ePso36WhO6rPriiy8smTJlivX15s6d2/LDDz9E2S77ZbRtNmvWLMpj4+PZZ591eEyVKlUsCeXK9teuXTtL6tSpozxW533zzTeWV199Ndp16+fm119/dVi3ti37ZZo2bWopWbJktI/PkSOHZffu3Q6P37lzZ7zacKtWrSz37t1zWbvRfWJ1584dS82aNePcBl3G2fvvv+/wXRbdVLx4ccu+ffscHqff9/bLVKpUyVKjRo1oH58uXTrL9u3bE9xmACAlcf7udO5X37x5M8oyCxcutN1/7do1S+vWrWP9Pk+bNq1lxowZUZ5b+zz2y3Xt2jXKY51/L6Ob7PuA+ruhvx+xLa+/P/o7lNjtiW7ZDh06RPtcuXLlshw8eNBSv379aO/X3/7w8HCH7Vi6dGm8fuN79uwZ5TU4912eeOIJc+wS3eNr164dpY+gxo0bF+dvtH0f2Z39ZD1esV/HK6+8YkkoV7YJV77Pzu/VM888E+N7Va1aNdOntffee+/Fq52MGjUqyutyPhZy7nPbH3fFdDylDh06ZMmZM2ec2/Daa685PL/2ubXvHdfjtA9/5coVh8c6903btGlj9n9M3w3Ojwe8BQFe+BXnL+ALFy7YAogaYAwNDTUBTT1Ity7zxx9/xBrg1U6K/gDa368dA/3ib9CggSVVqlS2+fpczsEDDfBqJ7Ry5cqWJk2aWB599FETINFAqv068+fPb7l9+7bDY523Syf9wdNgtXPnJFu2bKbDnFCTJk1yWM+wYcPMfOfAknOQNaZ9rlPRokXNa7QPElsDxX/++aftsS1btnS4v3r16iYw1KhRI0vp0qVtgS/n53YO7ul+18c88MADUTqPzz//fLIEeD/88EPL448/HuU90+3S+dZp//79ZvktW7aYdmFdTttnrVq1LI888oilVKlSDuuoV6+eJTIyMt7vqXMnRYOm9ttgPy1evDjWx9q3eT3Y0o60tfOfkGV1PzkHMvUzoO2kYMGCDvM1CKwd2rjamS734IMPms9D9uzZ47VvnD93Q4cOtSSUK9ufTtrx1s6mtnn7+RkzZrR9tvU16neE/f36+bEX0wFr1apVTbA3c+bMUQ4MNKDqHODV56lbt67l4YcfNp9HPbBwPjhwPqGUlHZjH+DVA3z7+/Lly2cer5MG4/VEWnQB3gULFkR57goVKpj95txB19d38eLFGAO81kkP3PTxzgeX9icLAQBRxRXg1RP8zsvYB3ickyPy5MljfpP0t1L7kvZ9p9WrV8caPNNJ+x/ax9S+u/bTrH02/e127vdZ+0d9+vQx69NjCf0tsl9Of1f0tyAoKCjKc33++ecJ3p6YArzW166/986/ZdY+QpEiRcy2WG9bp/Hjx0cb4NU+uvYr9bm1z6kBWfv+qE4rVqyIs++ir0H7Cjo536cn9O1NnTo12uMZPS7S3/dChQpFaQPu6icfO3YsyrasWbMmQR9jd7QJV73P0b1X+plp2LChea+c++IaAI4uwKt9Uj3O1f2tbUWPhe2PeXXas2ePw2NjSnapWLGi+UyXK1cuXgHeF154weG+8uXLm4QI7cvqOqzfAc4B3l69ejk8Tvvk+pr1c+6cUNS8efN49WP1c6rHGs77TU9YAN6IAC/8ivOXstKggvW2dtZGjx5tu62BGhVbgFezTu3ve/nlly0REREOHRDtdFjv1x9CexpUjinwOmjQIId1O2fxOm+XZpVZM2mvX79ufjDt7//5558TvM80aGK/Dg14K80OjCtjLrp9rhm8//77r7lPX7f+GNvf36NHD9tjy5QpE2vGgJ4d1Q7ptm3bbPO0E+aciWgfNHYOJOp7c+DAAbcHeON7v5V2tOw7IL/88ovtPu2kvvjiiw7r+eqrryzxFVMnJbrJPrgW02Nff/11hzZvDQomZFkNftovp59F63J6YsP5YK5z584xvi86aUfz5MmTUZ4nLs4d4+iyf2Lj6vanQerff//dth+0A29/vx70nDhxwtx/5swZh5NT+rd9lkx0AV49iLU6cuRIlJMu8+bNs92vWSB//fVXtK9bs2Pss6+1w+yqdmPfBrXDbJ2vwVzn7069ukC/c+0/t/oczicJ7A94NDtFDwpjCuxHF+DV7yN9LqUnG+wDCvp3dNlJAID/OH+nWvvVmmGnfTrnIJiepLX+RuhVPPb36YlG+6thNLvP/oSlXnURW/BM171582aHPpZ1fc6/m/ZXHVnp74X9Mvr7Z5+9N2bMmCi/2/a/fQnZHudltY9ufS7tazjvVw34WfebBmXt79NguD1NcLH2J5xp8oH9YzUL0p5z30X7OfZXWznfb9/Xv3r1qu3krHXSPq7z7/v69esd+iDu6ic7H9/o5JxUEBdXtwlXvs/O74WeoNcT+FZ6rGl/3KpBW/vj3uPHj1vOnz8f7ev+9ttvo/TzYjsG0vdt5cqVDstYX0dsx0v6ep2P1e3duHHDbMvatWsdjrftX5c+t/1xsR7fasJETIH96Pqx9n1N5/ud9zvgLQjwwq84fzErzai13tYAhf0ZV70EOq4Ar3PgSX90nLMgnYMu9sEm7bTNnDnTnP3Us+YxXSYTXVac83Y5B4D79esX4+Vt8aGXaNs/3rmT7HyG3Br8jW2fO3cetRPrnNFnpWdPrfM1QPPOO+9YVq1aZX6knS9tt9IAe2ydC/Xkk086LKNno70pwKsdJ/tOiHb2nduUnjWP66AjOQK8ZcuWtQW64nqemJbVgwr716sBMudLypw7tJo1ad8Zdt5uzf5JDOcA78cff5ygx7u6/Tmf2HC+TO/tt992uN+5dICWj7FyPlDV7AvnjBb7sjXWy+ecD/L0e0UD6NouY7qcUjvJrmo39m1Qs1zs73vppZdMJtCOHTuiXEYY08GaHkg5P/d3333nsIyeHIspwKtZHs7PpVdgxLTfAQCO4tsHie5ka3BwsMN9ehWJcx9JT67G1G93Dp5psC0m8QnwOgejnfvimtTgfJLRPqCWkO1xXnb+/PkO9+vvsv399kFPLWvh/DvsbOvWrSbLUfv72s9yzsi0v/LHnnPfxTkA7Hw8YX+FkQZenfsm1kSQmLiznxxdgNf+RHx8uLpNuPJ9dn6v9P12Zn/8pZNzCT19PU8//bTJltWTKTG1E70qNbZjoOieOz7HS3r1m3W+tlNNztJyHZoQcevWrWjX9+6778baRtXgwYMdltHvmpj6ps6JDJpgFdfnC/AGaTxdAxhwNx0kR4vZa/F2HbzHOmKqFl7XgY3i4jwY0fr162NdXgfnOX36tCnIfvv2bTNgkg6iFB+xDUygdGAqe1rI3/m5E2LOnDkOt7t06RLltv2gAlqAXgceiokWv9cB6OxVqlTJ4bYWpo+IiDADWr355pumUL91n2lRfysdqEAHXdBBBl544QVzW+lABPZ0kLvo3vOlS5fabkc3oJQn6Wv47/jnP+Hh4abof2yS8hoaN24cZfCC+NJBrZwHH0vosseOHXN4vTrQgXPbrVChgnmPdSAJde3aNTPolw404UyXq1+/fiJejZhBMOz3pXN7iour25/z43UQi9g+P873x/aZ13U7Dz7nvD59b6yWLFliBqXQASWT+l2VkHZjTwd40+8YHQhTzZgxw0xW+r3apk0bM/CGdQAc5/dE25Lzc+t7Yi+290QH8HAeeDOp37UAgKj0N+2dd96RF198Mcbv561bt8a56/Qx0Q2Mq5wHUkuouH73dfCnoKAg04+13x4dSCyp2xNdH0H7jNH9psfVP5g8ebIZyCy5j0ecB5LWQXV1n3mqn6z9wOieTwcQ81SbcOX77EwHfHOm67MfDNi+L6iDik2fPl1c0U4S+9nTdvrVV1+ZfaDHAzrInpX27/Q1PfHEE2YgOx0kMCH98/i2GVcfcwPJhQAvUgT9AXAOcPXt29eM5ukO1iBySEiIQ3BXgy0atNQgqP5A6Q/qrl27bPfbd2aioyOQ2ktMAMVKA2lffvmlw7wpU6bIRx99ZLt9584dh/u/+OILM/JsXB2zhAQedbRWfU4d8fTQoUO20XB1+7Zt22amH3/8UZYvXx7tPnIOYLlSdIGuc+fOiSdY21RyK1iwYJKXdfV7pp3zxH529cDCvkO3evVq06bjy9WvRUcGtuf8upwDje6inzcdldy+zWtwvUaNGrbO8/fffy+3bt1yebuxpyMd68H8Z599JitXrpTdu3c7HEDoe6ffqwsXLjSjJxcrVszl74nz92xSv2sBIKXTUe8zZsxovp/1ez5v3rymP9yuXbsoAStX95ES+3tk5erfmIRsj6v6CGfOnHFIolBFihQxQbAMGTKY2/YB1OQ8HknufrImGehx2MmTJx36gg8//LCk9L6gHpM6B3fLlCkj5cqVk3Tp0pk+oPYF49tOEvvZ02D7/v37zfHh2rVr5c8//7Qdk2qSkPb/dNJ+oh4navtzd1/QG9o4EB/uiW4BXqZ9+/YOZ/a1M9mzZ894PVYzxuxt377d/IjENlnPtGp2qr1FixbJzp07ZcWKFebMZMeOHcVTVq1aZTIk7V28eNFk2Fon5/vPnj0ra9asiXGdV65cMY+zpz/K9goVKuTwI1m2bFmZOnWq/PHHH6bjcPz4cbNtFStWtC2j+8t6Ztb5/dDHOdOgsT3nx8Qmbdq0tr8vX77s0GHQjGwNOMUmPh0KDUrZL6cdmbjalP2JgOSUkEBqTMs6Z9Xoe6xn5O0dPHjQlr1r/YxGF2hL6DY5c85S1/azYMGCWB9jf5be3e3PlbRz7Mz586ht0Tpf27tVtWrV5MSJE+bzrt9V+t2VEEl5j/Rgs1+/fuakj2Zv6PeQnijTTH777xrrFQjO+zc0NNQcAHjjewIAKZEGavS3RK9u0d/cSZMmmSu0ogvuOn8/6+9PXH2kRx55JMbnTmoyR1y/+3piVH93YnuMK7cnMfTYxf4Erl7BqEkm3333nXlfPvjgA7c9d8mSJR1u60ncuK4Ucnc/2bkvOGvWLNMPdVVfMKFtwp2i66fG1Bd0Pm7VE/9//fWXOS7TdvLWW28l6LmT0tb1eHHcuHHmfdXgvR5f6lW0eoWYlR5TW7fZl/rngDsR4EWKoAHFAQMGmICRTnopWNasWeMdHLan6zl//nyU5cLCwsxlZm+//bZtnjUb1UqzF6z0B3PatGniKVpuwR2P0wwBa8dNA6L2l9Wo5s2bO6xLz5pbO02aGawZBdpRd76MRoPLyrkT/+mnnzp0yvSH3prtq7SDGJ9SHNGdbdbtnz9/vvlbg48adLpw4UKsj7dmQlg5B7yVZq488MADttu6/ZpF6hyU0v34008/Sa9eveJd5sMb6eutU6eO7ba+32+88YZERkbabg8dOtThMXoZvjsOgnS9TZs2dZj3/PPPy8cffxxl/2twUS9p1MdYubv9udLhw4cdyhvowZxmv0b3eXT+rtIyGNaTHfo+DRs2LN7Zu0mhpRk++eQTh8sac+bMadqPXo4X3XeCZhkXKFDA4TOnwQP793HUqFEOj40tGAAA8BznfrcGlaK7lFq/6/U3Tftm7uT8ezF69GiHK0vee+89h98s7Ufq75I3cf6N1yxqawBV+2DxLd2QGNrPsF4JZO2b6FWUzn2Kn3/+2RwbJUc/Wfuc9iXAdFt0O/WKQWfa9vRKUC0r54ttQq++3LNnj+32unXrHMozaF/b2i+O7bhVX5/23ZODJvZoRvmNGzds26j7UN8j+wCvfV9Q+9r2JwX08Vu2bLHd1oC79tnt0ReEP6JEA1IM/XHWKaGee+45c7mK9WynXgqil/fopWXaOdBMRC0tYP0h7969u+2x2jmxv5RF60vqD5N2SHQ9zj+kycU5E1cDOVp6ILpLgDSrN3/+/LZOlZ7F1Uw/DbrE1JHYvHmzOduuZ0r1sjD757HvROqlNV9//bXpQGjdTH0eDcZrsNz+zLcGfvUSIetlftaaykq3RTtNWitJ96eezbXPDND3T9cdXy1atDCXh9s/fvjw4eZ5NOAbF+caXnr2Wy8n18CvnlSYPXu2ma8d1WbNmtm2VQNo2s40+1svg9L3Q9uctQPctWtXSSxdj3NwzJ4GN6OrdetKEyZMMPvWGtTVgzL9bGgGt55ltw+Ea3twPjHgSosXL5aGDRuaz601eP/yyy/LiBEjTFvS/a/bo+1X3x/7kw3ubn+upu1PA6Z6YuvXX3+V69evO2QudO7c2fyt7U4PwKydaV1W3xttz/pZ1AMc7TjHdTleUmmm/ksvvWS2W+uk6zZmypTJ7GfngzfrftXvjPHjx0uPHj0cTjTNmzfPXIapBzb6PWalB47uPJgFACRey5YtTX/BOuaFBgS1D2g9maf9Iu0nWq/s0nJf7qS/F3rFiPUEv/bftVa7bo/2FZyzIbW/44ks3djoSVLdJmsfTINfWp5Bj2f0UndrkMwdtHapBkDtf3e1X6IZoboN2ufTfoa+nxqs1b6Hu/vJegzzzTffmIChtbSDvpf6fNr30L6P7qu///7bFnTW2rS+2Cb02EXHrdA2oPtS+3f2fblOnTrZMlntg+pKT5b/8ssvtj6kXj2VHDTYr0lQmmyg74Vm8+rfemWZfbDavi+oNY+7detm+n5K++TaX9f+uT5Wt9/+OE7HyElIWQ7AZ3h6lDfAlZxH94yvYsWKxTgarzpx4oSlVq1aMY7+G9OIoToSe6lSpaJdLleuXJahQ4fGOJp8dNvlzHmkVB0BND7ee+89h8e1bds21uVbtGjhsPwHH3xgu89+foECBSxt2rSJ9vXqaLiffPKJw3p19NX47NMJEyZEGcm0UaNGcT5OR9m9c+dOgvbZkSNHooxea50qVKgQZeRZ+1Ff1enTp82IrzG95/aWLFkS47LO06ZNmyzx5TwSbFyTfXt3fqxzm4zteWJbVukowRkyZIh1W3LmzGlZu3ZtlMfaL6Ofi6S6cuWKpXPnzvHaP9WrV0+29hfbqMLRjbxs/945jwaun8WKFStGu23ZsmVzGNFZTZ8+PcbX0rdv31i/j1zVblasWBGv96RGjRqWGzduOKx34sSJltSpU8f6uKJFi5rRvu3pPrRfRvexs9j2OwDAUWz9jPi4evWqpVWrVvH6PWjWrFmiv6+dfzf1Nzg6+ruhvx+xbYf+/ujvkLOEbE9cy8Z1XBBbX2ngwIExbvv7778f62Pj6rvE53d09OjRcf5GO/d53NVPtgoNDTX9ifisf8CAAcnWJpLyPju/Vy+++GKM+7By5cqmT2uvY8eOMb6Wd955J9b3Oa4+bHyX7d+/f7zeE31t9rTP/cQTT8T5OO3DO7/u+PRjY9vvgLfwrtOLgJfSLDCtX6V1wB577DFzxlsvb9KM1Ny5c5uzosHBweZssGZDWmlGrJ7V1ZIQemmJLq//a1afXoqsRes9wXp208qaxRcTPbsbnzINeoZU94GeddUantasVc3E0Hqa9jU0lV7uNGbMGHMJvGZn6Bl1zcbTs/l6Bv/ZZ581mZLOl+/rcnqWf8mSJdKhQwfz/ujZfH1PtN6rbq+1dqjOTwg9i63vmWZb6/Poa9Jt023V7Ew9ixwbzS7RbdOBQ7RtxHbG/sknnzRZpFrWQzNK9Qy5Zivr69B6WK1atTL7RzNc9X5fp9kVBw4cMNmVmgGvWR36evVzolkDmuGh92v2jrvpgBY6yKBmWQwZMsQ8v2Z26mfUuv/10i1tyzrAQ3K1P1fSrGz93tJL6jSzRNuyvkb9XGkGhPNoznqZq26z7gv97GpGr363aZaKO+vz2dN2rmUl9EoIHSVZP0/WchH6t2bb6LboZXea2WtP25VmXeuln5rho7UdtX3p51AzvLTchtYl9rZLZwEAjrTvqL+jWiNWa/VqVqX2DbWPqH2G6tWrm8vytV+u/U53098N/f3QwYg1809/V/T3RX8ndcwIPQb47bffogxk5k3ef/99kzmrVyVp30T7YPrbqPsvOa5q0aukdB9qqTt9/6x9QN2Xun91vvNxkbv7yZr9qWNraD9Pj1G076DtS9uZ9jE0e/SZZ54xV+LplUK+2Ca0T6fHnJrdqldKap9K6yJrRrT2pZyvyNSr3DTjWN8L7Xvp/Xr1mmbVPvXUU8myzXol17vvvmuOufU9sO5b7ZvqcZoeo+lVoPZlyJS2a63zre+n1lnWZfUx+pr1+O3RRx81r0/78DFdiQr4ugCN8np6IwAAQNLoyRA9yLDSIGlia20DAADAt+iYA5owYaUn6TWxCEDKQAYvAAAAAAAAAPgoArwAAAAAAAAA4KMI8AIAAAAAAACAj6IGLwAAAAAAAAD4KDJ4AQAAAAAAAMBHEeAFAAAAAAAAAB+VxtMb4IsiIyPl9OnTkiVLFgkICPD05gAAAKR4FotFrl+/LgULFpRUqchhiA19WQAAAP/qyxLgTQQN7hYpUiQxDwUAAIAbnThxQgoXLsw+jgV9WQAAAP/qyxLgTQTN3LXu9KxZsyZmFSmeZo5cuHBB8uTJQ5YNXIq2BXehbcGdaF9Jd+3aNXMC3tpP87QJEybI8uXL5eDBg5IhQwapX7++vPPOO1KuXLlYH7d06VJ566235J9//pEyZcqYx7Rp08Yhu2PkyJEyc+ZMCQ8PlwYNGsjHH39slo0v+rJJx2cW7kLbgjvRvkDb8t++LAHeRLCWZdDgLgHexP+w3Llzx+w/LqOEK9G24C60LbgT7ct1vKV81s8//yzBwcFSu3ZtuX//vrzxxhvSsmVLCQ0NlUyZMkX7mK1bt0qXLl1McPiRRx6RhQsXSocOHWTPnj1SqVIls8y7774r06dPl3nz5kmJEiVMMLhVq1ZmvenTp4/XttGXTTo+s3AX2hbcifYF2pb/9mUJ8AIAAAAutmbNGofbc+fOlbx588ru3bulUaNG0T5m2rRp8vDDD8vgwYPN7TFjxsj69evlww8/lBkzZpjs3alTp8qbb74pjz76qFlm/vz5ki9fPlm5cqV07tyZ9xEAACAFIsALAAAAuNnVq1fN/zlz5oxxmW3btsnAgQMd5ml2rgZv1dGjR+Xs2bPSvHlz2/3ZsmWTunXrmsfGFOC9e/eumewvAbRmcumEhNP9pgF39h9cjbYFd6J9gbblvZLapyDACwAAALi5w/7qq6+aernWUgvR0eCtZuPa09s633q/dV5My0RHSz6MHj06ynwdD0FLZiFx76kG7TXIS7kxuBJtC+5E+wJty3tdv349SY8nwAsAAFKciIgI+ffff8WbDrh0ezTYRrAoemnTppXUqVOLL9JavPv375fNmzd75PmHDRvmkBlsHcRDB7uNbTwJb/uceBP9zGptZW8bT8KXPyf4/7al9RcZjBruQPuCu9C2ki6+YynEhAAvAABIMTTbTjMdw8PDxZtYL/XWM/feMkiYN8qePbvkz5/fp/ZR37595dtvv5VffvlFChcuHOuy+trOnTvnME9v63zr/dZ5BQoUcFimWrVqMa43Xbp0ZnKmgcnogpPe+jnxxs/sjRs3vK49+uLnBI70vYvp8wkkFe0L7kLbSpqkfucT4AUAACmGNWilg11lzJjRawIgGizSbMA0adJ4zTZ5E90/t27dkvPnz5vb9sFNb97mfv36yYoVK2Tjxo1SokSJOB9Tr1492bBhgynnYKWDrOl8pevQwJ0uYw3oajbujh07pE+fPn7/OfEm3viZ9cXPCQAAcA0CvAAAIEXQy82tQatcuXKJN/HGYJG3yZAhg/lfg1f6Hnr7ZehalmHhwoXy9ddfS5YsWWw1cnVQNOtr6datmxQqVMjUyFX9+/eXxo0by6RJk6Rt27ayaNEi2bVrl3z66afmfm0bGvwdO3aslClTxgR833rrLSlYsKB06NDB7z8n3sRbP7O+9jkBAACuQYAXAACkCNZaopqRCN9kfe/0vfT2wNXHH39s/m/SpInD/Dlz5shzzz1n/j5+/LjD5Xj169c3QeE333xT3njjDRPEXblypcPAbEOGDJGbN2/KCy+8YAKxDRs2lDVr1iS5bpsVnxPf50ufEwAA4BoEeAEAQIriTdl28N/3TjM846KlG5w9+eSTZoptH7z99ttmcidf2tdwxHsHAEDKQ9V2AAAAAAAAAPBRBHgBAADgdqNGjbINDKa0TIGr6sYC/oLPCQAASAxKNCRASEiImXTwCQAA4B9q1Ure59u1K3GPO3HihIwcOdLUW7148aIUKFDABEhHjBiR7INhaV1ZDdZOnTrVNu+ff/4xg37t3bvXIZBrNWjQIOnXr1+ybidch89JwvE5AQAAyYUM3gSOhhwaGio7d+503zsCAADg5MiRI1KrVi05fPiwfPnllxIWFiYzZsyQDRs2SL169eTy5ctev88yZ86c7IFopCx8TgAAQEpFgBcAAMAHTjIHBgbKunXrpHHjxlK0aFFp3bq1/PDDD3Lq1CkZPny4bXCllStXOjw2e/bsMnfuXNvt119/XcqWLSsZM2aUkiVLyltvvSX//vtvlEvEFyxYIMWLF5ds2bJJ586d5fr167bSCj///LNMmzbNPJ9Omr2b0EvPrUaPHi158uSRrFmzyksvvST37t1L0r5CypXcnxM96cLnBAAAeAMCvAAAAF5Ms3PXrl0rL7/8smTIkMHhvvz588szzzwjixcvFovFEq/1ZcmSxQSy9KokDdLOnDlTpkyZ4rDM33//bQJg3377rZk0oDtx4kRznz5Gs4Z79+4tZ86cMVORIkUS9do0A/nAgQOyceNGk5m8fPlyE/AFfOFzohnDX3/9NZ8TAADgcQR4AQAAvJiWZdCgVIUKFaK9X+dfuXJFLly4EK/1vfnmm1K/fn2TnduuXTtTG3fJkiUOy0RGRprgVqVKleTBBx+Url27mmCs0oxezZLUzEYNnOmUOnXqRL02Xc/s2bOlYsWK0rZtW3n77bdl+vTp5vkBX/iczJkzh88JAADwOAZZAwAA8AFxZR5qsDQ+NItRg6iapXvjxg25f/++KY9gT4NamsFopQO6nT9/XlytatWqJlBspZnBuk06oFyxYsVc/nzwf8n5OdE2yucEAAB4AwK8PiK5Ry52t4AAkVWrPL0VAAB4v9KlS5uaoVrK4LHHHotyv87XGrZaQ1SXcw5w2dcN3bZtm7lUXcsgtGrVymTjLlq0SCZNmuTwmLRp0zrc1vWSVQtvxucEAACkZAR4AQAAvFiuXLmkRYsW8tFHH8mAAQMc6ouePXtWvvjiCzO4lNJAr9bEtb9s/datW7bbW7duNVmH1sGm1LFjxxK8TZoFGRERIUn122+/ye3bt22vafv27ZI5c+ZE1/RFysXnBAAADxswQCQsTC+nEb+xa5f4CgK8AAAAXu7DDz809UA163bs2LFSokQJ+fPPP2Xw4MFStmxZGTFihFmuadOmZlktdaAB2Ndff90hG7dMmTJy/Phxk7Vbu3Zt+e6772TFihUJ3h4t4bBjxw75559/TEA2Z86ctvsOHToUZXmtsRude/fuSa9evUy9U13XyJEjpW/fvpIqFcNEIOH4nAAAgJSK3jMAAICX08Dszp07pWTJkvLUU0+ZLNzWrVub4O6WLVtMkFVpqQXNftWB0Z5++mkzMJR9jdv27dubLGANolarVs1k9L711lsJ3h5drw6sFhQUZLKGNWhs1blzZ6levbrDdO7cuWjX06xZM/PaGjVqJJ06dTLbN2rUqETtI4DPCQAASKkCLHGNRIAorl27ZmrWXb16NcpgC+7ifzV4I2XVqvOSN29esnTgUlojUgcCom3B1Whbvu/OnTty9OhRk/2aPn168SbaHdNBnNKkSWPq3caHZrtOnjxZ1q9fLw888ICk9PfQE/0zXxXbvvLmz0liuOtzkpjPbHLxt/cwpaG/AdoXfPa765lnJG9YmKTypzDjruQr0ZDUviwlGgAAAHyQDpSmpRK0bm2dOnU4YQrwOQEAACkUAV4AAAAf1aNHD09vAuD1+JwAAAB/Rw1eAAAAAAAAAPBRBHgBAAAAAAAAwEcR4AUAAAAAAAAAH0WAFwAAAAAAAAB8FAFeAAAAAAAAAPBRBHgBAAAAAAAAwEcR4AUAAAAAAAAAH0WAFwAAAAAAAAB8VBpPbwAAAIBH1aqVvM+3a1eiHnbixAkZOXKkrFmzRi5evCgFChSQDh06yIgRIyRXrlxmmSZNmsjPP/8sEyZMkKFDhzo8vm3btrJ69WqzjlGjRtnmh4WFybhx42T9+vVy4cIFKViwoDzwwAPy2muvSa3/7ZuAgADb8lmzZpVKlSrJmDFjpGnTponcCfA5fE6ifE7q1KkjgwYNktq1a5tdxOcEAAB4Chm8AAAAXu7IkSMm2Hr48GH58ssvTVB2xowZsmHDBqlXr55cvnzZtmyRIkVk7ty5Do8/deqUWVaDwvZ27dolNWvWlL/++ks++eQTCQ0NlRUrVkj58uVNgNfenDlz5MyZM7JlyxbJnTu3PPLII2a7gJT4OVm+fLmUK1fOBHjt8TkBAACeQAYvAACAlwsODpbAwEBZt26dZMiQwcwrWrSoVK9eXUqVKiXDhw+Xjz/+2MzXwOuSJUtMILZBgwZm3rx586Rly5Zy/Phx2zotFos899xzUqZMGdm0aZOkSvX/5/2rVasm/fv3d9iG7NmzS/78+c2kz1WoUCGTzajbM2DAADl9+rSkS5fOtrxmF2fJkkUWLFjg9v0DJPfnROdrJru2fXt8TgAAgCeQwQsAAODFNOtw7dq18vLLL9uCVlYabH3mmWdk8eLFJuCkNMCl8zST0EozFXv27Onw2H379smff/5pMnXtg7v2gaqYWLfj3r178uSTT0pERIR88803tvvPnz8v3333XZTnBNyFzwkAAEjJCPACAAB4Mb3cXIO3FSpUiPZ+nX/lyhVTF9RKA6uanXjz5k355Zdf5OrVqyZj0Xm9SssxJMStW7fkzTfflNSpU0vjxo1NsPfpp592CCh//vnnJnNSawIDyYHPCQAASMko0QAAAOADrBm6MdHMXauqVauaS8q/+uor+emnn6Rr166SJk2aBK3PWZcuXUxQ9/bt25InTx6ZNWuWVKlSxdzXu3dvM9CU1jDV0g2aMayXtdsPOgUkBz4nAAAgJSLACwAA4MVKly5tAqUHDhyQxx57LMr9Ol8Drs4lFTSLNyQkxAwI9euvv0Z5XNmyZc3/Bw8eNDVK4zJlyhRp3ry5ZMuWzTyfPX28BpXnz59vaphq6Qct0QAkFz4nAAAgJaNEAwAAgBfLlSuXtGjRQj766COTPWvv7Nmz8sUXX5hsWWdaNuGPP/4wA0EFBQVFuV8HUtP5kyZNksjIyCj3h4eHR6n3q0E05+Cu1fPPP28yd7VUgwaCixQpkohXCyQOnxMAAJCSEeAFAADwch9++KHcvXtXWrVqZWrqnjhxQtasWWMCv5qJO2LEiCiPyZEjh5w5c0Y2bNgQ7To1K1iDsX/99Zc8+OCDsnr1ajly5Ij8/vvvMm7cOHn00UcTtI0aUD558qTMnDmTwdWQIj4nEyZMkA4dOiRoG/mcAAAAdyDACwAA4OW0nu7OnTulZMmS8tRTT0mxYsWkdevWJmi1ZcsWyZw5c7SP07INmTJlinG9derUkV27dpnMXK2jqwO2tW/f3pRYmDp1aoK2UUs3PP7442ZbEhr0Anztc6InQLT8iZYuSQg+JwAAwB2owQsAAFK2XbvEFxQvXtyUQLAaOXKkTJ482WQSPvDAA2bexo0bY13Hvn37oszT4Ne8efNifVx8B2TTQdaeeeYZSZcuXbyWhw/hc+LwOdHPxP379x0GL+RzAgAAPIUALwAAgA8aPXq0Cfpu377dZBimSuW5C7OuXLligss6aa1gwFvwOQEAACkBAV4AAAAf1aNHD/EG1atXN0Hed955R8qVK+fpzQEc8DkBAAD+jgAvAAAAkuSff/5hDwJ8TgAAgIcwyBoAAAAAAAAA+CgCvAAAAAAAAADgowjwAgCAFCUyMtLTm4BE4r1LPuxr38V7BwBAykMNXgAAkCIEBgZKqlSp5PTp05InTx5zOyAgQLyBxWKR+/fvS5o0abxmm7yJ7p979+7JhQsXzHuo7x1S3ufEm3jjZ5bPCQAAKRcBXgAAkCJo0KpEiRJy5swZE7zyJhqY0aw73UZvCRZ5o4wZM0rRokXNfkLK+5x4E2/+zPI5AQAg5SHAC88ZMEAkLEx7yP7zLuza5ektAADEQrMRNUComXcRERFes680UHTp0iXJlSsXwcsYpE6d2quyJf2Zt35OvIm3fmb5nAAAkDIR4AUAACmKBgjTpk1rJm8KFun2pE+f3quCRUiaX375Rd577z3ZvXu3yYhdsWKFdOjQIcbln3vuOZk3b16U+UFBQfLnn3+av0eNGiWjR492uL9cuXJy8OBBv/+ceBM+swAAwJuk2COIxx57THLkyCFPPPGEpzcFAAAAfujmzZtStWpVCQkJidfy06ZNM4Fg63TixAnJmTOnPPnkkw7LVaxY0WG5zZs3u+kVAAAAwBek2Aze/v37S8+ePaPNkgAAAACSqnXr1maKr2zZspnJauXKlXLlyhXp0aOHw3JaqiJ//vy8QQAAAEjZAd4mTZrIxo0bPb0ZAAAAQLRmzZolzZs3l2LFijnMP3z4sBQsWNCU9KhXr55MmDDB1MyNyd27d81kde3aNVuZAZ2QcLrfrAOtAa5E24I70b7g1rYVECCR/jZWQmTy/c4ntU+RxlfrlemlbrrM2bNnzaVvH3zwgdSpU8dj2wwAAAC4yunTp+X777+XhQsXOsyvW7euzJ0719Td1X6y1uN98MEHZf/+/ZIlS5Zo16UBYOe6verChQty584d3rREHoRdvXrVBHmpmw1Xom3BnWhfcGvbKlBALFoL1qL/+onz55Ptqa5fv+5/AV5rvTItodCxY8co9y9evFgGDhwoM2bMMJ3cqVOnSqtWreTQoUOSN29es0y1atXMyL/O1q1bZzIeAAAAAG+lZcSyZ88eJcnBvuRDlSpVTF9YM3yXLFkivXr1inZdw4YNM31n+wzeIkWKSJ48eSRr1qxufBX+fSCrA9HpPiTAC9oWfAXfXXBr2zpzRvKEhflXgDfvfzHG5KBXZvldgDeuemWTJ0+W3r172+qRaaD3u+++k9mzZ8vQoUPNvH379iXb9gIAAACuolmh2q/t2rWrBAYGxrqsBoHLli0rYWFhMS6TLl06MznTwCTBycTTAC/7EO5A24I70b7gtralV7X8b/IbqVIl41Ol8r8Ab2zu3btnSjdoJoL9TtD6ZNu2bXPLc3pD3TJ/K2MSEEB9FrgHdaXgLrQtuBPtyzX70F/8/PPPJmAbU0auvRs3bsjff/9tgsEAAABImXwuwHvx4kWJiIiQfPnyOczX2wcPHoz3ejQg/Ntvv5lyEIULF5alS5eaQSq8tW5Z6dLidwHecOqzwA2oKwV3oW3BnWhfnq9b5g4afLXPrD169Ki5yixnzpxmUDRNWDh16pTMnz8/yuBqWnqhUqVKUdY5aNAgadeunSnLoHV6R44cKalTp5YuXboky2sCAACA9/G5AK+r/PDDD/Fe1hvqlsVy1Z3PBnizC/VZ4HrUlYK70LbgTrQvz9ctc4ddu3bJQw89ZLtt7U92797dDJSmg6QdP37c4TE6cNeyZctk2rRp0a7z5MmTJph76dIl0xdt2LChbN++3fwNAACAlMnnAry5c+c2WQrnzp1zmK+38+fP75bn9Ia6Zf5UwsSK+ixwW9uiJh5oW/BBfHcljTfWkm3SpImppxsTDfI6y5Ytm9y6dSvGxyxatMhl2wcAAAD/4H094TjoQBM1a9aUDRs2OGS96O2YSiwAAAAAAAAAgD/yygzeuOqV6eVtemlbrVq1pE6dOjJ16lRTS7dHjx4e3W4AAAAAAAAAkJQe4I2rXlmnTp3MAGcjRoyQs2fPSrVq1WTNmjVRBl4DAAAAAAAAAH/mlQHeuOqVqb59+5oJAAAAAAAAAFIqn6vB60khISESFBQktWvX9vSmAAAAAAAAAAAB3oQIDg6W0NBQ2blzJ00HAAAAAAAAgMeRwQsAAAAAAAAAPooALwAAAAAAAAD4KAK8AAAAAAAAAOCjCPACAAAAAAAAgI8iwAsAAAAAAAAAPooALwAAAAAAAAD4KAK8CRASEiJBQUFSu3Zt970jAAAAAAAAABBPBHgTIDg4WEJDQ2Xnzp0JeRgAAAAAAAAAuAUBXgAAAAAAAADwUQR4AQAAAAAAAMBHEeAFAAAAAAAAAB9FgBcAAAAAAAAAfBQBXgAAAAAAAADwUQR4AQAAAAAAAMBHEeAFAAAAAAAAAB9FgDcBQkJCJCgoSGrXru2+dwQAAAAAAAAA4okAbwIEBwdLaGio7Ny5MyEPAwAAAAAAAAC3IMALAAAAAAAAAD6KAC8AAAAAAAAA+CgCvAAAAAAAAADgowjwAgAAAAAAAICPIsALAAAAAAAAAD6KAC8AAAAAAAAA+CgCvAAAAAAAAADgowjwAgAAAAAAAICPIsALAAAAAAAAAD6KAG8ChISESFBQkNSuXdt97wgAAAAAAAAAxBMB3gQIDg6W0NBQ2blzZ0IeBgAAAAAAAABuQYAXAAAAAAAAAHwUAV4AAAAAAAAA8FEEeAEAAAAAAADARxHgBQAAAAAAAAAfRYAXAAAAAAAAAHwUAV4AAAAAAAAA8FEEeAEAAAAAAADARxHgBQAAAAAAAAAfRYAXAAAAAAAAAHwUAV4AAADADX755Rdp166dFCxYUAICAmTlypWxLr9x40aznPN09uxZh+VCQkKkePHikj59eqlbt678+uuvvH8AAAApGAFeAAAAwA1u3rwpVatWNQHZhDh06JCcOXPGNuXNm9d23+LFi2XgwIEycuRI2bNnj1l/q1at5Pz58254BQAAAPAFaTy9Ab5EO+c6RUREeHpTAAAA4OVat25tpoTSgG727NmjvW/y5MnSu3dv6dGjh7k9Y8YM+e6772T27NkydOjQJG8zAAAAUmCANzIyUn7++WfZtGmTHDt2TG7duiV58uSR6tWrS/PmzaVIkSLiL4KDg8107do1yZYtm6c3BwAAAH6oWrVqcvfuXalUqZKMGjVKGjRoYObfu3dPdu/eLcOGDbMtmypVKtPn3rZtmwe3GAAAAD4Z4L19+7ZMmjRJPv74Y7l8+bLpiGp9sQwZMkhYWJipMabZBS1btpQRI0bIAw884NotBwAAAPxIgQIFTEZurVq1TID3s88+kyZNmsiOHTukRo0acvHiRXMlWb58+Rwep7cPHjwY43p1XTpZabKCNVFDJySc7jeLxcL+g8vRtuBOtC+4tW0FBEhkQIB/7eTI5OsnJbVPlugAb9myZaVevXoyc+ZMadGihaRNmzbKMprRu3DhQuncubMMHz7cBHwBAAAARFWuXDkzWdWvX1/+/vtvmTJliixYsCDRu2zChAkyevToKPMvXLggd+7c4a1I5EHY1atXTZBXs6gBV6FtwZ1oX3Br2ypQQCx6dZFF//UT55NvjIPr1697JsC7bt06qVChQqzLFCtWzFxCNmjQIDl+/HhinwoAAABIkerUqSObN282f+fOnVtSp04t586dc1hGb+fPnz/GdWh/XAdms8/g1TJqWlYta9asbtx6/z6QDQgIMPuQAC9oW/AVfHfBrW3rzBnJExbmXwHevP8/0K27pU+f3jMB3riCu/Y0u7dUqVKJfSoAAAAgRdq3b58p3aACAwOlZs2asmHDBunQoYPtgEpv9+3bN8Z1pEuXzkzONDBJcDLxNMDLPoQ70LbgTrQvuK1t6VUt/5v8Rqrku0onqX2yJA+yZqWDrH3yySfmMrKvvvpKChUqZC4lK1GihDRs2NBVTwMAAAD4hBs3bpixKayOHj1qArY5c+aUokWLmszaU6dOyfz58839U6dONX3nihUrmtIJWoP3xx9/NFfOWWkmbvfu3U2dXs3u1cfcvHlTevTo4ZHXCAAAAM9zSYB32bJl0rVrV3nmmWdk7969tkEctC7V+PHjZfXq1a54GgAAAMBn7Nq1Sx566CHbbWuZBA3Qzp07V86cOeNQxuzevXvy2muvmaBvxowZpUqVKvLDDz84rKNTp06mdq4OYnz27Fkz0PGaNWuiDLwGAACAlMMlAd6xY8eaEX+7desmixYtss1v0KCBuQ8AAABIaZo0aWIG4YqJBnntDRkyxExx0XIMsZVkAAAAQMrikmIShw4dkkaNGkWZny1bNgkPD3fFUwAAAAAAAAAA3BHg1VF77euLWemIvyVLlnTFUwAAAAAAAAAA3BHg7d27t/Tv31927NhhRmQ8ffq0fPHFFzJo0CDp06ePK54CAAAAAAAAAOCOGrxDhw6VyMhIadasmdy6dcuUa0iXLp0J8Pbr188VTwEAAAAAAAAAcEeAV7N2hw8fLoMHDzalGm7cuCFBQUGSOXNmV6weAAAAAAAAAOCuAK9VYGCgCewCAAAAAAAAALw4wNuxY8d4L7t8+XLxByEhIWaKiIjw9KYAAAAAAAAAQOIDvNmyZUtxuy84ONhM165dS5GvHwAAAAAAAICfBHjnzJnj2i0BAAAAAAAAACRIqoQtDgAAAAAAAADwu0HWvvrqK1myZIkcP35c7t2753Dfnj17XPU0AAAAAAAAAABXZvBOnz5devToIfny5ZO9e/dKnTp1JFeuXHLkyBFp3bq1K54CAAAAAAAAAOCOAO9HH30kn376qXzwwQcSGBgoQ4YMkfXr18srr7wiV69edcVTAAAAAAAAAADcUaJByzLUr1/f/J0hQwa5fv26+btr167ywAMPyIcffuiKpwHgBrVq+dduDQgQWbXK01sBAAAAAADgQxm8+fPnl8uXL5u/ixYtKtu3bzd/Hz16VCwWiyueAgAAAAAAAADgjgBv06ZN5ZtvvjF/ay3eAQMGSIsWLaRTp07y2GOPueIpAAAAAAAAAADuKNGg9XcjIyPN38HBwWaAta1bt0r79u3lxRdfdMVTAAAAAAAAAADcEeBNlSqVmaw6d+5sJgAAAAAAAACAl5domDNnjixdujTKfJ03b948VzwFAAAAAAAAAMAdAd4JEyZI7ty5o8zPmzevjB8/3hVPAQAAAAAAAABwR4D3+PHjUqJEiSjzixUrZu4DAAAAAAAAAHhpgFczdX///fco83/77Tcz4BoAAAAAAAAAwEsDvF26dJFXXnlFfvrpJ4mIiDDTjz/+KP3792ewNQAAAAAAAABwkzSuWMmYMWPkn3/+kWbNmkmaNP+tMjIyUrp160YNXgAAAAAAAADw5gBvYGCgLF68WMaOHSv79u2TDBkySOXKlU0NXgAAAAAAAACAFwd4rcqUKWMmLdHwxx9/SNasWSVHjhyufAoAAAAAAAAAgCtr8L766qsya9Ys87cGdxs3biw1atSQIkWKyMaNG8VfhISESFBQkNSuXdvTmwIAAAAAAAAArgnwfvXVV1K1alXz96pVq+TIkSNy8OBBGTBggAwfPtxvdnNwcLCEhobKzp07Pb0pAAAAAAAAAOCaAO/Fixclf/785u/Vq1fLU089JWXLlpWePXuaUg0AAAAAAAAAAC8N8ObLl89ktmp5hjVr1kiLFi3M/Fu3bknq1Kld8RQAAAAAAAAAAHcMstajRw+TtVugQAEJCAiQ5s2bm/k7duyQ8uXLu+IpAAAAAAAAAADuCPCOGjVKKlWqJCdOnJAnn3xS0qVLZ+Zr9u7QoUNd8RQAAAAAAAAAAHcEeNUTTzwRZV737t1dtXoAAAAAAAAAgDtq8AIAAAAAAAAAkh8BXgAAAAAAAADwUQR4AQAAAAAAAMBHEeAFAAAAAAAAgJQ8yNq1a9einR8QECDp0qWTwMBAVzwNAAAA4DaRkZHy888/y6ZNm+TYsWNy69YtyZMnj1SvXl2aN28uRYoUYe8DAADAPzN4s2fPLjly5Igy6fwMGTJIsWLFZOTIkabTDAAAAHiT27dvy9ixY00At02bNvL9999LeHi4pE6dWsLCwkw/tkSJEua+7du3e3pzAQAAANdn8M6dO1eGDx8uzz33nNSpU8fM+/XXX2XevHny5ptvyoULF+T999832bxvvPGGK54SAAAAcImyZctKvXr1ZObMmdKiRQtJmzZtlGU0o3fhwoXSuXNn0+/t3bs3ex8AAAD+E+DVQO6kSZPkqaeess1r166dVK5cWT755BPZsGGDFC1aVMaNG0eAFwAAAF5l3bp1UqFChViX0SvShg0bJoMGDZLjx48n27YBAAAAyVKiYevWraY2mTOdt23bNvN3w4YN6QwDAADA68QV3LWn2b2lSpVy6/YAAAAAyR7g1Xpls2bNijJf51kHo7h06ZKpywsAAAB4qzVr1sjmzZttt0NCQqRatWry9NNPy5UrVzy6bQAAAIDbArxaX3fKlClStWpVef75582kHeGpU6ea0g1q586d0qlTJ1c8HQAAAOAWgwcPlmvXrpm///jjD3nttdfM4GpHjx6VgQMHJmhdv/zyiylbVrBgQQkICJCVK1fGuvzy5ctNDeA8efJI1qxZTV3gtWvXOiwzatQosy77qXz58ol4pQAAAPAXLqnB2759ezl48KCpt/vXX3+Zea1btzad2OLFi5vbffr0ccVTAQAAAG6jgdygoCDz97Jly+SRRx6R8ePHy549e0ygNyFu3rxpEiB69uwpHTt2jFdAWAO8+nzZs2eXOXPmmADxjh07HMqhVaxYUX744Qfb7TRpXNKlBwAAgI9yWW+wRIkSMnHiRFetDgAAAEh2gYGBcuvWLfO3BlG7detm/s6ZM6ctsze+NOFBp/jSq9/saaD366+/llWrVjkEeDWgmz9//gRtCwAAAPyXywK84eHhpubugQMHbJkFmq2QLVs2Vz0FAAAA4FY6MLCWYmjQoIH8+uuvsnjxYjNfr1IrXLhwsu79yMhIuX79ugku2zt8+LAp+5A+fXpTxmHChAlStGjRZN02AAAA+FmAd9euXdKqVSvJkCGD1KlTx8ybPHmyjBs3TtatWyc1atRwxdMAAAAAbvXhhx/Kyy+/LF999ZV8/PHHUqhQITP/+++/l4cffjhZ976Oc3Hjxg156qmnbPPq1q0rc+fOlXLlysmZM2dk9OjR8uCDD8r+/fslS5Ys0a7n7t27ZrKyZiJrAFknJJzuN4vFwv6Dy9G24E60L7i1bQUESGRAgH/t5Mjk6ycltU/mkgDvgAEDTB3emTNn2mqA3b9/3wy29uqrr5p6YgAAAIC300zYb7/9Nsp8HVA4OS1cuNAEb7VEQ968eW3z7Us+VKlSxQR8ixUrJkuWLJFevXpFuy7N8NV1Obtw4YLcuXPHTa/Av+lB2NWrV02QN1Uql4xbDdC24HZ8d8GtbatAAbGISCqL/usnzp9PtqfSq7a8IoPXPrhrVpwmjQwZMkRq1arliqcAAAAA3EIHQ8uUKZPblk+oRYsWmUSJpUuXSvPmzWNdVgdjK1u2rISFhcW4zLBhw0zZCfsM3iJFikiePHkka9asLt32lHQgGxAQYPYhAV7QtuAr+O6CW9vWmTOSJyzMvwK8ef//JLu7aektjwd4tWN4/PhxKV++vMP8EydOxHipGAAAAOANSpcuLf3795fu3btLgQIFol1GMzV10DUtQ9aoUSMTNHWHL7/80oxjoUHetm3bxrm8lnD4+++/pWvXrjEuky5dOjM508AkwcnE0wAv+xDuQNuCO9G+4La2pVe1/G/yG6mS7yqdpPbJXBLg7dSpk7kkTOuE1a9f38zbsmWLDB48WLp06eKKpwAAAADcYuPGjfLGG2/IqFGjpGrVquYKNOsgZleuXJHQ0FDZtm2buUJNA7svvvhivNarwVf7zNqjR4/Kvn37zKBpWgpC13Xq1CmZP3++rSyDBpmnTZtmSi+cPXvWzNdxLqwDFw8aNEjatWtnyjKcPn1aRo4cKalTp6bPDQAAkIK5JMCrgV09C9StWzdTe1elTZtW+vTpIxMnTnTFUwAAAABuoQOWLVu2zFyRpmURNm3aJFu3bpXbt29L7ty5pXr16qYcmda/1WBqQsqYPfTQQ7bb1jIJGsTVgdJ0kDR9TqtPP/3U9KWDg4PNZGVdXp08edIEcy9dumTKAzRs2FC2b99u/gYAAEDK5JIAb2BgoMk00AEc9BIxVapUKcmYMaMrVg8AAAC4nWbVvvbaa2ZyhSZNmpjSDjGxBm3tM4njoqUbAAAAAJcHeK00oFu5cmVXrhIAAAAAAAAA4OoAb8eOHeO97PLly8UfhISEmCkiIsLTmwIAAAAAAAAAiQ/wWgd6SEms9dCuXbuWIl8/AAAAAAAAAD8J8M6ZM8e1WwIAAAAAAAAASJBUCVscAAAAAAAAAODzAd6HH35Ytm/fHudy169fl3feecfUrgUAAAC83aZNm+TZZ5+VevXqyalTp8y8BQsWyObNmz29aQAAAIDrSjQ8+eST8vjjj5tatO3atZNatWpJwYIFJX369HLlyhUJDQ01neDVq1dL27Zt5b333kvsUwEAAADJYtmyZdK1a1d55plnZO/evXL37l0z/+rVqzJ+/HjTtwUAAAD8IsDbq1cvk9mwdOlSWbx4sXz66aem46sCAgIkKChIWrVqJTt37pQKFSq4cpsBAAAAtxg7dqzMmDFDunXrJosWLbLNb9CggbkPAAAA8JsAr0qXLp0J8uqkNMB7+/ZtyZUrl6RNm9ZV2wgAAAAki0OHDkmjRo2izNer1sLDw3kXAAAA4N+DrGnHN3/+/AR3AQAA4JO0LxsWFhZlvpYeK1mypEe2CQAAAEi2AC8AAADgy3r37i39+/eXHTt2mLJjp0+fli+++EIGDRokffr08fTmAQAAAK4t0QAAAAD4k6FDh0pkZKQ0a9ZMbt26Zco1aFkyDfD269fP05sHwEmtWv61SwICRFat8vRWAAB8DQFeAAAA4H80a3f48OEyePBgU6rhxo0bZvDgzJkzs48AAADgnwHeiIgI2bJli1SpUkWyZ8/umq0CAAAAPCgwMNAEdgEAAAC/D/CmTp1aWrZsKQcOHCDACwAAAJ92584d+eCDD+Snn36S8+fPm3IN9vbs2eOxbQMAAADcVqKhUqVKcuTIESlRooQrVgcAAAB4RK9evWTdunXyxBNPSJ06dUzJBgAAAMDvA7xjx441A0+MGTNGatasKZkyZXK4P2vWrK54GgAAAMCtvv32W1m9erU0aNCAPQ0AAICUE+Bt06aN+b99+/YOWQ4Wi8Xc1jq9AAAAgLcrVKiQZMmSxdObAQAAACRvgFdrlAEAAAC+btKkSfL666/LjBkzpFixYp7eHAAAACB5AryNGzd2xWoAAAAAj6pVq5YZaK1kyZKSMWNGSZs2rcP9ly9f9ti2AQAAAG4L8Krw8HCZNWuWHDhwwNyuWLGi9OzZU7Jly+aqpwAAAADcqkuXLnLq1CkZP3685MuXj0HWAAAAkDICvLt27ZJWrVpJhgwZzGjDavLkyTJu3DgzCnGNGjVc8TQAAACAW23dulW2bdsmVatWZU8DAAAg5QR4BwwYYAZYmzlzpqRJ898q79+/L88//7y8+uqr8ssvv7jiaQAAAAC3Kl++vNy+fZu9DAAAAJ+RylUZvDoYhTW4q/TvIUOGmPsAAAAAXzBx4kR57bXXZOPGjXLp0iW5du2awwQAAAD4ZQZv1qxZ5fjx4ybjwd6JEyckS5YsrngKAAAAwO0efvhh83+zZs0c5lssFlOPNyIigncBAAAA/hfg7dSpk/Tq1Uvef/99qV+/vpm3ZcsWGTx4sBmoAgAAAPAFP/30k6c3AQAAAEj+AK8GdjWjoVu3bqb2rkqbNq306dPHXOYGAAAA+ILGjRt7ehMAAACA5A3w6mVq27dvl1GjRsmECRPk77//NvNLlSolGTNmTOrqAQAAALf6/fffpVKlSpIqVSrzd2yqVKnCuwEAAAD/CvCmTp1aWrZsKQcOHJASJUpI5cqVXbNlAAAAQDKoVq2anD17VvLmzWv+1ivTtOauM2rwAgAAwG9LNGjGw5EjR0yAFwAAAPAlR48elTx58tj+huvVquVfezUgQGTVKk9vBQAAgAsDvGPHjpVBgwbJmDFjpGbNmpIpUyaH+7NmzeqKpwEAAABcrlixYuaqtDNnzpi/AQAAgBQX4G3Tpo35v3379ubSNSu9tI1L2QAAAODtoivJAAAAAKSYAO9PP/3kitUAAAAAAAAAAJIzwPvvv//K22+/LTNmzJAyZcokdXUAAACAR3z22WeSOXPmWJd55ZVXkm17AAAAgGQJ8KZNm1Z+//33pK4GAAAA8ChNWNBavDHR0mMEeAEAAOCXJRqeffZZmTVrlkycONEVqwMAAACS3a5duyRv3rzseQAAAKS8AO/9+/dl9uzZ8sMPP0jNmjUlU6ZMDvdPnjzZFU8DAAAAuIX9QMEAAABAigvw7t+/X2rUqGH+/uuvvxzuo7MMAAAAb2exWDy9CQAAAIDnArw//fSTK1YDAAAAeMTIkSPjHGANAAAA8Eap3P0E58+fd/dTAAAAAEkO8GbMmJG9CAAAgJQV4NVO8IULF2y327ZtK2fOnLHdPnfunBQoUCBpWwgAAAAAAAAAcH2A986dOw71yn755Re5ffu2wzLUMwMAAAAAAAAAHy3RwCBrAAAAAAAAAOCjAV5vdOLECWnSpIkEBQVJlSpVZOnSpZ7eJAAAAPgZvbqtXbt2UrBgQZP0sHLlyjgfs3HjRqlRo4akS5dOSpcuLXPnzo2yTEhIiBQvXlzSp08vdevWlV9//dVNrwAAAAB+H+DVjqp9hq7zbW+VJk0amTp1qoSGhsq6devk1VdflZs3b3p6swAAAOBhOoZE165dTVBW+4ypU6d2mBJC+5dVq1Y1Adn4OHr0qBnT4qGHHpJ9+/aZPurzzz8va9eutS2zePFiGThwoBkUbs+ePWb9rVq1YmBjAACAFCxNUh6s9XXLli1rC+reuHFDqlevLqlSpfLq+rs68Jt18Lf8+fNL7ty55fLly5IpUyZPbxoAAAA86LnnnpPjx4/LW2+9ZfqLSUleaN26tZnia8aMGVKiRAmZNGmSuV2hQgXZvHmzTJkyxQRx1eTJk6V3797So0cP22O+++47mT17tgwdOjTR2woAAIAUGuCdM2eOuOtytvfee092794tZ86ckRUrVkiHDh0cltFMCF3m7NmzJnPhgw8+kDp16iT4ufQ5IiIipEiRIi58BQAAAPBFGlDdtGmTVKtWLdmfe9u2bdK8eXOHeRrY1Uxede/ePdN3HTZsmO1+TazQx+hjAQAAkDIlKcDbvXt3cQfr5Ww9e/aUjh07RrnfemmaZixo3TEtt6Cd30OHDknevHnNMtopv3//fpTHakkGveROadZut27dZObMmW55HQAAAPAtetLfU1ehaeJCvnz5HObp7WvXrsnt27flypUrJjEhumUOHjwY43rv3r1rJitdn4qMjDRTcvCBKm4JEhAQadpJcu0/xPZe+NfeoW3BnfQ7i+8uuK1tBQRIpL99KUcm3+98UvsUSQrwuktcl7PF59I0rVsWG+3kalawLl+/fv04l6VT7IaOCx9+r+Bv3790iuEudIjhTrQv1+xDV9DEAe0ffvLJJ2YgM38wYcIEGT16dJT5Fy5ckDt37iTLNpQuLX7X3wgPv2oCJdbydPAM2haQsN/Kq1f57oKb2laBAqKnyFN5abnWRDl/XpLL9evX/S/AGxtXXJqmHTGtr9a0aVMziEZc6BS7qVPMh98r0CkG4ocOMdyJ9uX5TrFVp06d5NatW1KqVCnJmDGjpE2b1uF+vQLMXXRsCB3kzZ7ezpo1q2TIkME20Ft0y+hjY6L9Zr36zT6DVzOV8+TJY9adHMLCxO/6stmzB5h9SIDXs2hbQML6G1pbnu8uuKVtnTkjecLC/CvAm/e/KgHJIX369CkrwHvx4sVEXZpmb8uWLabMQ5UqVWTlypVm3oIFC6Ry5crRLk+n2E2dYuHD7w3oFAPxQ4cY7kT78nyn2D6D11Pq1asnq1evdpi3fv16M18FBgZKzZo1ZcOGDbbxKbTt6O2+ffvGuN506dKZyZkGJpMrOOlPx3pWGiRJzn2I6NG2gIThuwvuEqBXtfxv8hupku83Pqn9CZ8L8LpCw4YNE3QZH51i9+DD7x386bvXik4LaFvwRXx3JY2rgmyuHGPixo0bEmZ3JvXo0aOmjFjOnDmlaNGiJong1KlTMn/+fHP/Sy+9JB9++KEMGTLEjEXx448/ypIlS0wpMivNxNVtrFWrlhlgWAPSOn6FtXQZAAAAUp40ri6foB1XvaQtTRr3xI5z586dqEvTAAAAgPjQq8X0Kq8DBw6Y2xUrVpT27dubPmhC7Nq1Sx566CHbbWuZBA3Qzp07V86cOSPHjx+33V+iRAkTzB0wYIBMmzZNChcuLJ999pkZTNi+hITWzh0xYoQZlE0HFl6zZk2Uq9sAAACQcrgkCqt1yvr16yfz5s0zt//66y8pWbKkmVeoUCHbwGeukNhL0wAAAIC4aMZtmzZtTGZtuXLlbOMxaM1aDb5qIkN8NWnSxIz9EBMN8kb3mL1798a6Xu3z0u8FAACAlUuuZdPLy3777TfZuHGjQ/0zHfhMa90m5nI2vXxNJ/vL2awZDpr9MHPmTBNQ1syKPn36cGkaAAAAkuyVV14xQdwTJ07Inj17zKR9UM2u1fsAAAAAv8zg1UvYNJD7wAMPmPpxVno5299//53g9cV1ORuXpgEAAMAdfv75Z9m+fbupk2uVK1cumThxojRo0ICdDgAAAP8M8GodsLx580aZrwM+2Ad8XXU5m6cuTQsJCTGT1mUDAACA/9HBda9fvx7tFWZaKgwAAADwyxINOoqv/ei+1qCuDgpRr1498RfBwcESGhoqO3fu9PSmAAAAwA0eeeQReeGFF2THjh0m4UAnzeh96aWXzEBrAAAAgF9m8I4fP15at25tgp/37983o/7q31u3bjWXuQEAAAC+YPr06aYsmCYppE2b1szT/q0Gd7WPCwAAAPhlgLdhw4ZmEDStTVa5cmVZt26d1KhRQ7Zt22ZuAwAAAL4ge/bs8vXXX8vhw4fl4MGDZl6FChWkdOnSnt40AAAAwH0BXqWjDc+cOdNVqwMAAAA8pkyZMmYCAAAAUkSAN3Xq1HLmzJkoA61dunTJzGNQMgAAAHirgQMHypgxYyRTpkzm79hMnjw52bYLAAAASLYArw4+EZ27d+8y2jAAAAC82t69e+Xff/+1/Q0AAACkmACvDkKhAgIC5LPPPpPMmTPb7tOs3V9++UXKly+f9K0EAAAA3OSnn36K9m8AAADA7wO8U6ZMsWXwzpgxw5RqsAoMDJTixYub+QAAAIAv6Nmzp0ybNk2yZMniMP/mzZvSr18/mT17tse2DQAAAHB5gPfo0aPm/4ceekiWL18uOXLkEH8WEhJiJmoKAwAA+Kd58+bJxIkTowR4b9++LfPnzyfACwAAAK+TyhUr0UvZ/D24q4KDgyU0NFR27tzp6U0BAACAC127dk2uXr1qrky7fv26uW2drly5IqtXr44yoDDgTsuWLZPSpUubqyS1JN6NGzfY4QAAwH2DrOmlbLHhUjYAAAB4s+zZs5sgmk5ly5aNcr/OHz16tEe2DcnnxIlXJTx8hfz77zkJCEgn6dKVkrx5X5HcuZ+L8TH37t0zWd8LFiyQEydOSMGCBeWll16SwYMHm3aTGHrFYI8ePczJhscff1wKFy7sksGrtYTesWPHTIJOkyZNkrw++CYdK0eTlw4ePCj379+XP/74QypVquTpzQIAeDrAq1kN9nQU4v3790t4eLg0bdrUFU8BAAAAuI0GvDR7V/uumjmZM2dO230aWCtWrJgJ3MG/3b17RDJmrCNp0+aR27f/kBs3NsuxYz0kffrykjnzA9E+ZtCgQfLBBx9IoUKFpHv37vL999/L66+/LmnTppUBAwYkajvOnDljgrtqyZIlkiqVSy68dCk95tPXiIS5fftPOXCgtlgstyVNmnxSterZGJfdu3evOVnw119/mTrguXPnNt9R7777bpK+j/r06WOuTG3RooUEBQWZ9SaVnjD4+eefZc6cOfLcczGfEAEAuIdLegorVqxwmL799ls5cuSIdOrUSR54IPqOEAAAAOAtGjdubAIUOsZEhw4dzG3rVK9ePYK7KUTp0t9IqVJLpWjRj6Rs2V8kVaqsZv69e0difMyiRYvM/++//7588sknMn36dHN73LhxJhNXTxhoJq8GgDUBRgN1WnpB582aNSvK+jZu3ChFihSx3dYSDZp5qzSrV082ZMiQQdKnTy9Vq1aVL774wrasZmI2a9bMZKTrMvo8GiBU+nyavWsdQ0Vvjxo1ytzetWuXPPzww6YMiZ7c0L9/++0323r1s6HLv/HGG9KoUSNz0uO7775L4t5OeSIjb8uRI53EYvk3XsufP39e0qRJIx07dpRnn33W1ALX97tXr15J2o5Dhw6Z/3VA9KlTp0r+/PnFm2hWPAAgYdx2KljPMg8cOFCmTJnirqcAAAAAXEoDYJs2bTKXMEc3wf9dvrxQjh/vJ3/91UgiI69JhgzVJVu2R2JcXgOtas+ePXLnzh3zv7p06ZIcP37clFjo3bu3nD59Wl599VWT8fv333/LU089FW2gTssxaCDXqn///raSeJpEoycc9Hbbtm3NVZOaNWwNxupl9z/++KNJstH5GuDV9mxdj3XwQN0mva3L6fY2aNDAZLHr/xrc/eGHH0xQ99SpUw7bpqUo9PV269ZNcuXK5YK9nfJKgNy7d1zy5389Xsu3atVKtmzZYk4EaNnDN99808zX9qO2b99usqgzZ85sTk5FRkZKw4YNTTD+rbfeirK+f/75x9xnHTS8VKlStjIiw4cPN7czZcpkAvjlypVzOJY/efKktG/f3rzv6dKlMyca9LbSExCavau07eo6rVm8hw8flieeeMKc4MiWLZs8+OCDtmWVLqfLa1Zxu3btzImJjz76KNH7GABSKpeUaIiJ/vBoTR8AAADAF0RXl9S+jqo1MAL/de3aOrl0aZ75OyAgULJnbyepUmWMcXkNpL344ovy3nvvmcne2bNnpUSJEiZLcvPmzTJv3n/r1eDYp59+Gu36NCg7YsQIc6m70sdaLV261FwxqYFjDezlyZNHzp07Z4K6ms179+5ds1zz5s3Npfzly5c3wTjrelauXGlKP/Tt29fW1jXIrBmTFStWNNtlDTLryY7PP//clJuw0is0v/zyy0Tu2ZTtypWv5OLFT6VEiS8kMjL+GaqXL1+Wt99+2wwC+fXXX5v3fejQoeY+DdBrbXANzur72LJlSxMQrl+/vi07217WrFlNYH/atGm2YKzOU2FhYVKtWjXJly+fea7ly5ebhC2tSa4nEzR7e9WqVWbd2ta03rT15IGecND2rCcErGUf6tSpY4LC+r+uT4PVmimsJUd0mV9//dU8n5Vmv+vr0ZMH2v4AAB4I8OoXvz2tX6Z1o/SyHT1zDAAAAPiC6MaW0DqYGsTTS+7h/4oXnyvFis2U27f3S1jYo3LmzNuSOnV2yZcv+nq6mp1bq1YtU3tXA6U1atSQRx991NynJQ9UxowZ5ZVXXjFZikr/12zGhCbP6PNomYfoLuW3BnE1eKtBWc3m1Mv7n376aRMsjqmOrwaL1Z9//mkme5p9aY+B2RLn7t1/5Nix3pIrVw/JmfNpuXhxbrwfe+3aNVtAVmkb0ACrlQZ7NeNaM7C1vIe2q4ULF5rSHs60/Ia2Eev69ESCtfzHzJkzTVBXs8T1pICWCdH3f926dSbAaz15oAFezcitUKGCyfa1rkdPMmiAV9ubNXt3zJgxpr3qujQjWGmWsJYS0YDuxx9/bNs2De5qcDqxAxMCQErnkgCvdnrtaedBzyZPmjTJdjkRAAAA4O2iC7pptplesqxJDbt37/bIdsH9IiPvmAp2qVIFSkBAWsmYsboZXO3ff0/I7du/m2W0durdu3p5fKT8++9/5Q40qFu9enUzKWvmZMmSJU0wy5rJq0EwDbrpsdKECRNMNqw1uBYfOs6JNVimNXP1eEuzbg8cOGASbJQGl7WNap1fHURLy0DMnz9fnn/+eXNpvDXop8FfK2u2pC67ePHiGE92KGs2MBImPPxriYgIl3v3/pGwsEfk3r2TZr7O09vFis2WtGn/OxngTNuIvr+ayat1nrXttG7d2mTQ6vuh7WnIkCG2gSK7dOliy8SOL32vNZvWGuyP7uSBZhFrO9YAsW6HPq9m5X711VfmBEZ0rOvTbbUPUkd38kDrnRPcBQAPB3j1xyQlCAkJMROX5gEAAKQsetmydWAi+Kc7dw7KX381kyxZmkjatPnk9u0DcuPGRnNf1qwtzf/37p2SP/+sYP4+e/ZXU1d0wYIFJhtRA2Ra43T9+vUm+KXJLkqDbnpV44ULF8xl7lpjVDPCNdNR6zprlm18WAfC0islBwwYYLIl9bJ6e4888ojJOtcyD3rMogE5lSNHDvN/0aJFTYamPv8333xjLuvXbGItxaCXzmugTwPT+jq0TqpmJZO16wr/BeCvX3c8brZY7srVq99JZOQtWxvUkwe3bqW3Ze9aSyho9q2+vxrg1bak760Gcm/dumXag9L6yFqvV0svaGmE+NJ2qMFYfbyeGNCyIlqLee3atbaTB9Y6u1pn+q+//jInDbR96CCCXbt2jfXkQd26dWXbtm22AK5us742e5w8AAAvrsHrb3TQAp30xyihl1QBAADA+/3++3+Zms6lx3RwKft6kfA/adLklowZa8qNG5slIuKKKcuQOXNjyZOnj+TM2SnGx2kw7MaNGyZIqgEszZTVAKpmfisN9Opl7lWqVJGRI0eaQNjq1atNwEvrp+pl7PHx5JNPmkCcXn6/Zs0aefnll818+wGrtO6ubodm+GqAV4NyWnO1UqVK5n59Pi0psWPHDtm6dasJ3nbo0MHUUtXMY70yU2sFa+Baa6FaL6tH0uTL96qZrLREw7FjPSRNmnxStep/QXhlPXmwb98y897piQH9/tH3T99PzeJWWltZM7mVvr8HDx40Jww0s1eDrfq3vpfWQfXie/JAg7evvfaaOUmgJRfs6YkADf5qaQatA2zNwLU/eaB0YDYd9K9jx46mVIO2f21vOoCflpbQExPaZjWj11rKAQDgwQCvXoIU30sorCPJAgAAAN5Mg7jax7VmrdnXh9RR7OG/AgMLS9my62JdJl264lKzpkUCAiKlSJHztqCqBr5iMmjQIDPZ0+BqbKyX5dvTrGDrFYUxGTZsmJli0qhRo2gz0bV9a9A4JlrbFclP3y+tjbto0SKTGVuwYEHp3LmzeY+1PWj27GeffWbmf/jhhybYqgOhaTa2ngDQ7PL40AxbPdEwffp0U89XyzzoCQU9mWClAdp9+/aZOr0aCNbsXM0c1qxiNXjwYBPY3b9/v5n0xIeWXdDgrp7w0BMaGhcoUKCAtG/f3rQ5AIDrBFicew7xpGd/40vPVPsTawavjgZqvWTG3WrVEr+ineJVpZ+RvGFhkipxTdA77dolvsYv29aq82ZQk5gGEwESQw+stA4dbQvuQPvynv7ZsWPHoh1bQi9d9hf0ZZOO/ob3oC8LxB/9Dbi1bT1DjMeT/bNEZ/D6W9AWAAAASOjgRAAAAIBf1eDVEVt1FFelI7paR5IFAAAAfMErr7xiBqjS/+3p5c86oJWOIA8AAAB4E5dcv6yXrGrtqdq1a5vOsE41a9aUZs2amRE+AQAAAF+gNS211qSz+vXry1dffeWRbQIAAADcHuDt16+fXL9+Xf7880+5fPmymbSwutaPcM5+AAAAALzVpUuXTP0zZ1oL7eLFix7ZJgAAAMDtAV4dcfWjjz6SChUq2OYFBQWZEV6///57VzwFAAAA4HZankH7ts60T1uyZEneAQAAAPhnDV4dLS9t2rRR5us8vQ8AAADwBQMHDpS+ffuaMmNagkxt2LBBJk2aRP1dJLsbN0T27BFp1IidDwAA3JzBq53f/v37y+nTp23zTp06JQMGDDB1eAEAAABf0LNnTxPMnTVrljz00ENm+vzzz+Xjjz+W3r17e3rzkMJo2efmzT29FfBXCxboeDqe3goAgNcEeHVUYa23W7x4cSlVqpSZSpQoYeZ98MEH4i+05ISWntDB5AAAAOCf+vTpIydPnpRz586Z/uyRI0ekW7dunt4spED//vvfBLhD9+4i33zDvgUAf+CSEg1FihSRPXv2yA8//CAHDx4087Qeb3M/O90cHBxsJu3oRzf4BgAAAHzf/fv3ZePGjfL333/L008/bebplWo60FrmzJk9vXkA4BIWy38TAMD3uSTAqwICAqRFixZmUuHh4a5aNQAAAJAsjh07Jg8//LAcP35c7t69a/q2WbJkkXfeecfcnjFjBu8EAAAA/K9Eg3Z4Fy9ebLv91FNPSa5cuaRQoULy22+/ueIpAAAAALfTcSVq1aolV65ckQwZMtjmP/bYY2awNQAAAMAvA7yayaBlGtT69evN9P3330vr1q1l8ODBrngKAAAAwO02bdokb775pgQGBjrM17EmdBBhAAAAwC9LNJw9e9YW4P32229NBm/Lli1NR7hu3bqueAoAAADA7SIjIyUiIiLKfB10TUs1AAAAAH6ZwZsjRw45ceKE+XvNmjW2wdUsFku0HWQAAADAG2mSwtSpUx3Gmbhx44aMHDlS2rRp49FtAwAAANyWwduxY0czwnCZMmXk0qVLpjSD2rt3r5QuXdoVTwEAAAC43aRJk6RVq1YSFBQkd+7cMX3cw4cPS+7cueXLL7/kHQAAAIB/BninTJliyjFoFu+7774rmTNnNvPPnDkjL7/8siueAgAAzxswQCQsTC9REb+xa5entwDwKoULFzaDBOsAwvq/Zu/26tVLnnnmGYdB1wAAAAC/CvCmTZtWBg0aFGX+AD0QBgAAAHzEhQsXJE+ePCagq5O9P/74QypXruyxbQMAAADcVoNXHTp0SPr27SvNmjUzk/6t8wAAAABfoQHc7777Lsr8999/X+rUqeORbQIAAADcHuBdtmyZVKpUSXbv3i1Vq1Y10549e8w8vQ8AAADwBQMHDpTHH39c+vTpI7dv35ZTp06Z5AUtQ7Zw4UJPbx4AAADgngDvkCFDZNiwYbJt2zaZPHmymbZu3SpvvPGGuc9fhISEmAE3ateu7elNAQAAgBto31X7tJs2bZIqVaqYKV26dPL777/LY489lqj+o45VkT59eqlbt678+uuvMS7bpEkTCQgIiDK1bdvWtsxzzz0X5f6HH3440a8XAAAAvs8lAV4dTK1bt25R5j/77LPmPn8RHBwsoaGhsnPnTk9vCgAAANykdOnS5kq0f/75R65duyadOnWS/PnzJ3g9OlCbZgSPHDnSXN2mV7m1atVKzp8/H+3yy5cvN31n67R//35JnTq1PPnkkw7LaUDXfrkvv/wy0a8VAAAAvs8lAV7NNtAsB2ebN2+WBx980BVPAQAAALjdli1bTNbu4cOHTdbuxx9/LP369TNB3itXriRoXXpVW+/evaVHjx7mKrAZM2ZIxowZZfbs2dEunzNnThNItk7r1683yzsHeDWj2H65HDlyJOk1AwAAwLelSewDv/nmG9vf7du3l9dff93U4H3ggQfMvO3bt8vSpUtl9OjRrtlSAAAAwM2aNm0qAwYMkDFjxkjatGmlQoUK8tBDD5kr03QAtpMnT8ZrPffu3TN9Yy1jZpUqVSpp3ry5KQERH7NmzZLOnTtLpkyZHOZv3LhR8ubNawK7ur1jx46VXLlyJfCVAgAAQFJ6gLdDhw5R5n300Udmci5r8NJLLyX2aQAAAIBks27dOmncuLHDvFKlSpnM3nHjxsV7PRcvXpSIiAjJly+fw3y9ffDgwTgfr7V6tUSDBnmdyzN07NhRSpQoIX///bcZ86J169YmaKzlHKJz9+5dM1lp2QkVGRlppuQQECB+JSAgUiwWi9v333+rT5Vs75Mvom0lxX9ti+aVcuj7nRzfXUihbSsgQCL97Us5Mvk+K0n9XCY6wMsXAgAAAPyNc3DXPvv2rbfeSrbt0MCuZgzXqVPHYb5m9Frp/VpOQgPQmtXbrFmzaNc1YcKEaK+qu3Dhgty5c0eSQ+nS4ncB3vDwqyZQom3DXa5fzyAi2WKs2wzaVtLkl+vXr8v587dpSimExnGuXnX/dxdSaNsqUEAs2mey6L9+4nzy/f7q97FHArzxER4eLp9//rn07dvXnU8DAAAAJEmbNm3MYGXZsmUztydOnGiuQsuePbu5fenSJTO2hA64Gx+5c+c2GbXnzp1zmK+34xqw7ebNm7Jo0SJ5++2343yekiVLmucKCwuLMcCrZSJ0sDf7DN4iRYpInjx5JGvWrJIcwsLE7wK82bMHmH3oziBJliz//a8lORA92lZS21gWyZv3fw0NKSIIFxDg/u8upNC2deaM5AkL868Ab97k+/1Nnz699wV4N2zYYLIOVqxYYQaGIMALAAAAb7Z27VqHMgbjx4+Xp556yhbgvX//vhw6dCje6wsMDJSaNWuafrG1tJke/OjtuPrGOo6FbovW/Y2L1gTW4HOBAgViXEYHZdPJmR7cJ9cBvj8d61lpkMTd+9C6agIxMaNtJbWNaRtO4krgU5LjuwspU4Bmhv9v8hupku9zktTPpMu29MSJEybLQOuBtWzZ0nxpaID37NmzrnoKAAAAwC30ctXYbieGZs3OnDlT5s2bJwcOHJA+ffqY7NwePXqY+7t16+YwCJuVJkpoUNh54LQbN27I4MGDzWDG//zzjwkWP/roo1K6dGlp1apVkrcXAAAAvilJGbz//vuvrFy5Uj777DPZtGmTGfThvffeky5dusjw4cMlKCjIdVsKAAAA+JBOnTqZOrcjRowwSQ/VqlWTNWvW2AZeO378eJRsDc0S3rx5sxnszZmWfPj9999NwFhLoRUsWNAkVowZMybaDF0AAACkDEkK8BYqVEjKly9vLh/TOmE5cuQw8zXACwAAAPgKvfpMJ+d5SaXlGGIqyaADozkrV65cjNnDGTJkMKUkAAAAAJcFeLUWmbUzrBkFAAAAgC/SoOpzzz1ny4S9c+eOGWQtU6ZM5rZ9fV4AAADAbwK8p0+flmXLlpk6Yf3795fWrVubbF5XZDsAAAAAyaV79+4Ot6Mb4Exr5gIAAAB+FeBNnz69PPPMM2b6+++/Zc6cOfLKK6+YzN5x48aZLIimTZuS3QsAAACvpv1YAAAAwBc5juqQBKVKlZKxY8fKsWPH5LvvvjOXsT3yyCO2QSQAAAAAAAAAAF6UwRsdHQlYSzXopKMGL1iwwNVPAQAAAAAAAABwZQZvdPLkySMDBw70mx0dEhIiQUFBUrt2bU9vCgAAAAAAAAC4N8Drb4KDgyU0NFR27tzp6U0BAAAAAAAAAAK8AAAAAAAAAOCryOAFAAAAAAAAAB9FgBcAAAAAAAAAfFQaV6wkIiJC5s6dKxs2bJDz589LZGSkw/0//vijK54GAAAAAAAAAODqAG///v1NgLdt27ZSqVIlCQgIcMVqAQAAAAAAAADuDvAuWrRIlixZIm3atHHF6gAAAAAAAAAAyVWDNzAwUEqXLu2KVQEAAAAAAAAAkjPA+9prr8m0adPEYrG4YnUAAAAAAAAAgOQq0bB582b56aef5Pvvv5eKFStK2rRpHe5fvny5K54GAAAAAAAAAODqAG/27Nnlsccec8WqAAAAAAAAAADJGeCdM2eOK1YDAAAAAAAAAEjuGrwAAAAAAAAAAB/N4FVfffWVLFmyRI4fPy737t1zuG/Pnj2uehoAAAAAAAAAgCszeKdPny49evSQfPnyyd69e6VOnTqSK1cuOXLkiLRu3doVTwEAAAAAAAAAcEeA96OPPpJPP/1UPvjgAwkMDJQhQ4bI+vXr5ZVXXpGrV6+64ikAAAAAAAAAAO4I8GpZhvr165u/M2TIINevXzd/d+3aVb788ktXPAUAAAAAAAAAwB0B3vz588vly5fN30WLFpXt27ebv48ePSoWi8UVTwEAAAAAAAAAcEeAt2nTpvLNN9+Yv7UW74ABA6RFixbSqVMneeyxx1zxFAAAAAAAAAAAJ2nEBbT+bmRkpPk7ODjYDLC2detWad++vbz44oviL0JCQswUERHh6U0BAAAAAAAAANcEeFOlSmUmq86dO5vJ32jwWqdr165JtmzZPL05AAAAAAAAAFI4l5RoUJs2bZJnn31W6tWrJ6dOnTLzFixYIJs3b3bVUwAAAAAAAAAAXB3gXbZsmbRq1UoyZMgge/fulbt375r5V69elfHjx7viKQAAAAAAAAAA7gjwjh07VmbMmCEzZ86UtGnT2uY3aNBA9uzZ44qnAAAAAAAAAAC4I8B76NAhadSoUZT5Wqc2PDycnQ4AAAAAAAAA3hrgzZ8/v4SFhUWZr/V3S5Ys6YqnAAAAAAAAAAC4I8Dbu3dv6d+/v+zYsUMCAgLk9OnT8sUXX8igQYOkT58+rngKAAAAAAAAAICTNOICQ4cOlcjISGnWrJncunXLlGtIly6dCfD269fPFU8BAAAAAAAAAHBHgFezdocPHy6DBw82pRpu3LghQUFBkjlzZlesHgAAAAAAAADgrgCvVWBgoAnsAgAAAAAAAAC8PMDbs2fPeC03e/bspDwNAAAAAAAAAMDVAd65c+dKsWLFpHr16mKxWJKyKgAAAAAAAABAcgZ4+/TpI19++aUcPXpUevToIc8++6zkzJkzKasEAAAAAAAAAMRTKkmCkJAQOXPmjAwZMkRWrVolRYoUkaeeekrWrl1LRi8AAAAAAAAAeHOAV6VLl066dOki69evl9DQUKlYsaK8/PLLUrx4cblx44ZrthIAAAAAAAAA4PoAr8PKUqWSgIAAk70bERHhylUDAAAAAAAAAFwd4L17966pw9uiRQspW7as/PHHH/Lhhx/K8ePHJXPmzEldPQAAAAAAAADAHQFeLcVQoEABmThxojzyyCNy4sQJWbp0qbRp08Zk8wIAAAApmY5ZoaXL0qdPL3Xr1pVff/01xmXnzp1rroazn/Rx9vRKuREjRpg+eIYMGaR58+Zy+PDhZHglAAAA8FZpkvLgGTNmSNGiRaVkyZLy888/myk6y5cvT8rTAAAAAD5n8eLFMnDgQNNn1uDu1KlTpVWrVnLo0CHJmzdvtI/JmjWrud9Kg7z23n33XZk+fbrMmzdPSpQoIW+99ZZZp46F4RwMBgAAQMqQpABvt27donQ6AQAAAIhMnjxZevfuLT169DC7QwO93333ncyePVuGDh0a7S7SvnX+/PmjvU+zdzVI/Oabb8qjjz5q5s2fP1/y5csnK1eulM6dO7PbAQAAUqAkBXj1MjIAAAAAju7duye7d++WYcOG2eZpCTMtqbBt27YYd9eNGzekWLFiEhkZKTVq1JDx48dLxYoVzX1Hjx6Vs2fPmnVYZcuWzWQH6zoJ8AIAAKRMSQrwAgAAAIjq4sWLEhERYbJr7entgwcPRrvLypUrZ7J7q1SpIlevXpX3339f6tevL3/++acULlzYBHet63Bep/W+mAZF1snq2rVr5n8NIuuUHPztor+AgEiTUe3u/fff6lMl2/vki2hbSfFf26J5pRz6fifHdxdSaNsKCJBIf/tSjky+z0pSP5cEeAEAAAAvUK9ePTNZaXC3QoUK8sknn8iYMWMSvd4JEybI6NGjo8y/cOGC3LlzR5JD6dLidwHe8PCrJlDizsGlr1/PoHnacv78ebc9h6+jbSVFfrl+/bqcP3/bZe8HvJsGkPQEoru/u5BC21aBAmLRU0cW/ddPnE++31/9Pk4KArwAAACAi+XOnVtSp04t586dc5ivt2Oqsessbdq0Ur16dQkLCzO3rY/TdRQoUMBhndWqVYtxPVomQgd7s8/gLVKkiOTJk8cM6pYc/vcS/CrAmz17gNmH7gySZMny3/8xDcoH2lbS21gWyZv3fw0NKSIIp7Xe3f3dhRTats6ckTxhYf4V4M2bfL+/SR0slwAvAAAA4GKBgYFSs2ZN2bBhg3To0MF28KO3+/btG691aImHP/74Q9q0aWNulyhRwgR5dR3WgK4Ga3fs2CF9+vSJcT3p0qUzkzM9uE+uA3x/Otaz0iCJu/ehddUEYmJG20pqG9M2nMSVwKckx3cXUqYAzQz/3+Q3UiXf5ySpn0kCvAAAAIAbaNZs9+7dpVatWlKnTh2ZOnWq3Lx5U3r06GHu79atmxQqVMiUUFBvv/22PPDAA1K6dGkJDw+X9957T44dOybPP/+87aD81VdflbFjx0qZMmVMwPett96SggUL2oLIAAAASHkI8AIAAABu0KlTJ1PndsSIEWYQNM26XbNmjW2QtOPHjztka1y5ckV69+5tls2RI4fJAN66dasEBQXZlhkyZIgJEr/wwgsmCNywYUOzzqRe1gcAAADfRYA3AUJCQsykl8sBAAAAcdFyDDGVZNi4caPD7SlTppgpNprFq5m+OgEAAACKoisJEBwcLKGhobJz505aDwAAAAAAAACPI8ALAAAAAAAAAD6KAC8AAAAAAAAA+CgCvAAAAAAAAADgowjwAgAAAAAAAICPIsALAAAAAAAAAD6KAC8AAAAAAAAA+CgCvAAAAAAAAADgowjwAgAAAAAAAICPIsALAAAAAAAAAD6KAC8AAAAAAAAA+CgCvAAAAAAAAADgowjwAgAAAAAAAICPIsALAAAAAAAAAD6KAC8AAAAAAAAA+CgCvAAAAAAAAADgowjwAgAAAAAAAICPIsALAAAAAAAAAD6KAC8AAAAAAAAA+CgCvAAAAAAAAADgowjwAgAAAAAAAICPIsALAAAAAAAAAD6KAC8AAAAAAAAA+CgCvAAAAAAAAADgowjwAgAAAAAAAICPIsALAAAAAAAAAD6KAC8AAAAAAAAA+CgCvAAAAAAAAADgowjwAgAAAAAAAICPIsALAAAAAAAAAD6KAC8AAAAAAAAA+CgCvAAAAADgRS5eFImIiHseAACAIsALAAAAAF6kbVuR/v3///bVqyLly4vMm+fJrYI/uHZN5M8/Heddvy6yf7+ntggA4AoEeAEAAADAi3TsKPLppyKXLv13e/p0kZs3RVq39vSWwdctWyZSq5bI2bP/P+/550V69/bkVgEAkooALwAAAAB4keBgkaxZRdas+e/25MkiL74oUqCAp7cMvu6xx0TSpRN5993/bp86JbJ0qUjPnp7eMgBAUhDgBQAAAAAvkjmzyODBIps3/3f7zh2R11/39FbBH2TPLjJggMjHH/93+7vvRIoWFene3dNbBgBICgK8AAAAAOCFWbzp0//3N9m7cCWt76xZvGr3bpHhw0UCA9nHAODLCPACAAAAgBdm8T71lEhAANm7cE8Wr8qZk+xdAPAHBHgBAAAAwAt99pnIiRPU3oV7sng1a/eFF8jeBQB/kMbTGwAAAAAAiCpVKpFChdgzcE8Wr9Z21gxxAIDvI4MXAAAAAIAUhuAuAPiPFBngDQ8Pl1q1akm1atWkUqVKMnPmTE9vEgAAAAAAAAAkWIos0ZAlSxb55ZdfJGPGjHLz5k0T5O3YsaPkypXL05sGAAAAwBfoKFVhYSIWi/iNXbs8vQUA3I3vLsAvpcgAb+rUqU1wV929e1csFouZAAAAAADwKAJwAAB/KNGg2bXt2rWTggULSkBAgKxcuTLKMiEhIVK8eHFJnz691K1bV3799dcEl2moWrWqFC5cWAYPHiy5c+d24SsAAAAAEtZn1bJhDz74oOTIkcNMzZs3j7L8c889Z/rH9tPDDz/MrgYAAEjBvDLAq2UTNPiqHeLoLF68WAYOHCgjR46UPXv2mGVbtWol58+fty1jra/rPJ0+fdrcnz17dvntt9/k6NGjsnDhQjl37lyyvT4AAAD4v/j0We1t3LhRunTpIj/99JNs27ZNihQpIi1btpRTp045LKcB3TNnztimL7/8MpleEQAAALyRV5ZoaN26tZliMnnyZOndu7f06NHD3J4xY4Z89913Mnv2bBk6dKiZt2/fvng9V758+Uxne9OmTfLEE09Eu4yWcdDJ6tq1a+b/yMhIMyUHfxvhNCAgUiwBARLpby8smdqDK/ll27JYku2ziZRD2xTfW3Br++K7K8n70NvEp89q74svvnC4/dlnn8myZctkw4YN0q1bN9v8dOnSSf78+ZPhFQAAAMAXeGWANzb37t2T3bt3y7Bhw2zzUqVKZS5h00yH+NBsXa3Bq4OtXb161ZSE6NOnT4zLT5gwQUaPHh1l/oULF+TOnTuSHEqXFr8LwoUXKCBa+TiVP9U/jiEjx5v5ZdsKv2oCJfrdALgyeHSV7y24s31d5bsrKa5fvy7+1me9deuW/Pvvv5IzZ84omb558+Y1ZRyaNm0qY8eOjXWwYJIVXI9kBe/hl8kKJMLATUhYAG0rgZIxgSCpyQo+F+C9ePGiREREmMxbe3r74MGD8VrHsWPH5IUXXrANrtavXz+pXLlyjMtrx1wvr7PP4NVL5vLkySNZs2aV5KAD9PpbxyW7nJE8YWH+FeDNm1d8jV+2rewB5vNJgBeu/sENOMP3FtzYvgL47koKrXHrb33W119/3YxJoUFh+/IMHTt2lBIlSsjff/8tb7zxhrnyTYPGOpBwdEhWcD2SFbyHXyYrcEIZbkLCAmhb3pvEl9RkBZ8L8LpCnTp14l3CwXoZnE7ONHiUXAEkf4qBWgVohuX/Jr/hgxmj/rT7rTRIkpyfT6QcfG/Bre2L764k8bfv/IkTJ8qiRYtMtq598Lpz5862vzVBoUqVKlKqVCmzXLNmzaJdF8kKrkeygvfwy2QFEmHgJiQsgLblvUl8SU1W8LkAb+7cuU12gvOgaHqbWmQAAADw9T7r+++/bwK8P/zwgwngxqZkyZLmucLCwmIM8JKs4B6c9PMOfpmsQCIMaF8J42cneX0V312eTVbwuU9BYGCg1KxZ0ww2YX8WSm/Xq1fPo9sGAAAAJKXP+u6778qYMWNkzZo1UqtWrTh35smTJ+XSpUtSoEABdjwAAEAK5ZUZvDdu3DBZCFZHjx41JRV0gImiRYuaerjdu3c3nV4ttzB16lS5efOmbYRiAAAAwNPi6rN269ZNChUqZGrkqnfeeUdGjBghCxculOLFi8vZs2fN/MyZM5tJ+8g68O/jjz9usoC1Bu+QIUOkdOnS0qpVK4++VgAAAHiOVwZ4d+3aJQ899JDttnWAM+0gz507Vzp16iQXLlwwHWDt+FarVs1kOTgPYgEAAOAzBgz4r5ikP11vvGuXpGRx9VmPHz/ucDnexx9/LPfu3ZMnnnjCYT0jR46UUaNGmZIPv//+u8ybN0/Cw8PNAGwtW7Y0Gb/RjRcBAACAlMErA7xNmjQRSxwHN3379jUTAAAA4K1i67PqwGj2/vnnn1jXlSFDBlm7dq1Ltw8AAAC+z+dq8HpSSEiIBAUFSe3atT29KQAAAAAAAABAgDchgoODJTQ0VHbu3EnTAQAAAAAAAOBxZPACAAAAAAAAgI8iwAsAAAAAAAAAPooALwAAAAAAAAD4KAK8AAAAAAAAAOCjCPACAAAAAAAAgI8iwAsAAAAAAAAAPooAbwKEhIRIUFCQ1K5d233vCAAAAAAAAADEEwHeBAgODpbQ0FDZuXNnQh4GAAAAAAAAAG5BgBcAAAAAAAAAfBQBXgAAAAAAAADwUQR4AQAAAAAAAMBHEeAFAAAAAAAAAB9FgBcAAAAAAAAAfBQBXgAAAAAAAADwUQR4AQAAAAAAAMBHEeBNgJCQEAkKCpLatWu77x0BAAAAAAAAgHgiwJsAwcHBEhoaKjt37kzIwwAAAAAAAADALQjwAgAAAAAAAICPIsALAAAAAAAAAD6KAC8AAAAAAAAA+CgCvAAAAAAAAADgowjwAgAAAAAAAICPIsALAAAAAAAAAD6KAC8AAAAAAAAA+CgCvAAAAAAAAADgo9J4egMAwOUGDBAJCxOxWPxn5+7a5ektAAAAAAAAXogM3gQICQmRoKAgqV27tvveEQAAAAAAAACIJwK8CRAcHCyhoaGyc+fOhDwMAAAAAAAAANyCAC8AAAAAAAAA+CgCvAAAAAAAAADgowjwAgAAAAAAAICPIsALAAAAAAAAAD6KAC8AAAAAAAAA+CgCvAAAAAAAAADgowjwAgAAAAAAAICPIsALAAAAAAAAAD6KAC8AAAAAAAAA+CgCvAAAAAAAAADgowjwAgAAAAAAAICPIsCbACEhIRIUFCS1a9d23zsCAAAAAAAAAPFEgDcBgoODJTQ0VHbu3JmQhwEAAAAAAACAWxDgBQAAANx4BVjx4sUlffr0UrduXfn1119jXX7p0qVSvnx5s3zlypVl9erVDvdbLBYZMWKEFChQQDJkyCDNmzeXw4cP8/4BAACkYAR4AQAAADdYvHixDBw4UEaOHCl79uyRqlWrSqtWreT8+fPRLr9161bp0qWL9OrVS/bu3SsdOnQw0/79+23LvPvuuzJ9+nSZMWOG7NixQzJlymTWeefOHd5DAACAFIoALwAAAOAGkydPlt69e0uPHj3MOA4alM2YMaPMnj072uWnTZsmDz/8sAwePFgqVKggY8aMkRo1asiHH35oy96dOnWqvPnmm/Loo49KlSpVZP78+XL69GlZuXIl7yEAAEAKlcbTG+CLtHOtrl27lmzPGREhfiUgIFKu//uvpI+IkFT/259+IRnbhKvQtnyED7YtfxMZyfcWaF/e/N1l7ZdZ+2medu/ePdm9e7cMGzbMNi9VqlSmpMK2bduifYzO14xfe5qdaw3eHj16VM6ePWvWYZUtWzZT+kEf27lz52jXe/fuXTNZXb161fwfHh5uvtuSQzI9TbL2Za/dvy+BkZH+1ZcNDxdfQ9vyET7YtvyRfufz3QXalnd+dyW1L0uANxGuX79u/i9SpEiidjr+U3avH+6JbNk8vQWgbQEJw/cW/Kx9aT9Ng56edvHiRYmIiJB8+fI5zNfbBw8ejPYxGryNbnmdb73fOi+mZaIzYcIEGT16dJT5xYoVS8ArgrNye/xwn+TI4ektAG0LSDi+u+BHbSuxfVkCvIlQsGBBOXHihGTJkkUCAgISs4oUT89MaIBc92PWrFlT/P6A69C24C60LbgT7SvpNNtBO8TaT4MjzSK2zwzWDK7Lly9Lrly56MsmEp9ZuAttC+5E+wJty3/7sgR4E0EvrytcuHCidjgcaXCXAC/cgbYFd6FtwZ1oX0njDZm7Vrlz55bUqVPLuXPnHObr7fz580f7GJ0f2/LW/3VegQIFHJapVq1ajNuSLl06M9nLnj17Il4VnPGZhbvQtuBOtC/QtvyvL8sgawAAAICLBQYGSs2aNWXDhg0OmbN6u169etE+RufbL6/Wr19vW75EiRImyGu/jGZj7dixI8Z1AgAAwP+RwQsAAAC4gZZF6N69u9SqVUvq1KkjU6dOlZs3b0qPHj3M/d26dZNChQqZGrmqf//+0rhxY5k0aZK0bdtWFi1aJLt27ZJPP/3U3K+lwV599VUZO3aslClTxgR833rrLXMpX4cOHXgPAQAAUigCvPAIvUxw5MiRUS4XBGhb8FZ8b4H2hYTq1KmTXLhwQUaMGGEGQdMyCmvWrLENknb8+HFT+suqfv36snDhQnnzzTfljTfeMEHclStXSqVKlWzLDBkyxASJX3jhBQkPD5eGDRuadaZPn543KBnxmwDaFnwR312gbfmvAItW8QUAAAAAAAAA+Bxq8AIAAAAAAACAjyLACwAAAAAAAAA+igAvAAAAAAAAAPgoArwAAAAAAAAA4KMI8ALwCffv3/f0JgAAAACJQl8WAOBOBHgBeL33339funTpIrdu3fL0pgAAAAAJQl8WAOBuBHgBeL3KlSvLqlWr5JVXXiHICwAAAJ9CXxYA4G5p3P4MSBEsFosEBARIZGSkpEqVKsp8IClatWola9askXbt2pk29uGHH0rGjBnZqUiymL6j+O4CgJSFvizcib4s3IW+LAArArxw2Y/K2rVrZcGCBZI/f35p0KCBPPbYY2Y+gRK4QpMmTeTrr7+WRx991NwmyIuksn43/fzzz7Jz5045ePCgPP3001KhQgUpUKAAOxguaV+hoaFy7NgxKVeunBQtWlTSpKHrBXgb+rJIDvRl4Wr0ZeFO9GV9DyUakGR6APvjjz/K448/Lnfv3pUdO3bIq6++KpMmTbLdr18OQFI1bdpUVq5cKUuWLJG+fftSrgFJot9Ny5cvl/bt28uBAwfk7Nmz8tprr8nAgQPl6tWr7F24pH3Vr19f+vTpI1WqVJF3333XBHsBeBf6skgu9GXhSvRl4U70ZX0PaSRwCT1gnTBhgvTr18/8/cUXX8jbb79tLqcfPHgwmbxI9BnDM2fOyLVr16RQoUIm861Zs2YmyNuhQwezHJm8SKzDhw/L0KFDzcmo559/Xi5fviwFCxaURx55RLJly8aORZK+u/755x+ZMmWKTJw4UTp27CifffaZzJ07V8LDw03At0SJEuxhwIvQl4Wr0ZeFu9GXhTvQl/VdBHiRpA/9/v375c6dO7J+/XqTpaSKFStmgiVq7Nixkjp1apMRRy1eJLR9rVixwgTgbt26ZWo7a/2y/v37S/PmzW1BXm1fU6dOlUyZMrGDkSCapZshQwbp1auX6SBru+rWrZuMGTPG3L97924JCgoyywDxpd9dW7dulQ0bNkjJkiVNm9Ka4W+88Yb5f8aMGWa5l19+WYoXL86OBTyEviySo33Rl4U70ZeFO9CX9V0EeJGkdP2uXbuaWpUXL16UnDlz2u7Pmzev9O7d2wTfBg0aJGnTpjXZvUB825fWRX3mmWfMSYLGjRvLTz/9ZAZae+WVV+SDDz4wwbhVq1aZjN506dKZTF4gNs71wK2d4tOnT0uLFi2kZcuWtuDbtm3bZNGiReaEggbpgIRYtmyZyd7VtqOZ4dZBIbV8kdJs3ps3b8rrr79u6vICSH70ZeHu9kVfFq5GXxbJhb6sbyLAi0T9qFy6dMlcdvrRRx9JmTJlZMuWLSbTUoO9w4cPN8vmyZNHnnvuORPc1cAJkJA29u2335raqJr9rWrWrGkGv3r//fflk08+MZfVP/TQQ6bzrG0NiE+72r59u9y4ccOcINATB1euXJEiRYqYEweaCW6lJ7D27dsnWbNmZcciwfT7KXv27DJt2jSZP3++OeFp/Z7SIO/t27dNVlf69OnZu0Ayoy+L5Gpj9GXhjnZFXxbJgb6sbyLAiwTRH5V169aZ4IcG2/QSea1VqcG3zJkz27J0rUHefPnymYNZvbweiG8bU/fv3zeZlffu3ZPAwEAzr23btuayea1j+c4775iavA8++CA7FvHqEOuZ6ODgYFPqo3Tp0ubyeD1ZoMG3sLAwU6ZBaz5rZvinn34qmzdvlty5c7N3Ee8Tn1p3Xn/vcuXKJW+99ZbJEte2pIFcLdVgbU/Dhg2TF1980eHKFwDJg74skqONKfqycBX6snAn+rL+gwAvElxoWw9e9YBVD1Q1+00DvHqJfM+ePc2ymnGpNVPHjRtnbhPcRWLamtZy1gy3P/74Q2rUqGHrLDdo0MAM4mcdEAuIrg0pa5vR/zdt2mSuKNDyHk8++aStZnPdunVl+vTp5nurUaNG5vssR44cJjO8cuXK7FzE6/vq66+/lnfffVeOHz9urmqpXbu2OQmlVxzoMtrG9Lfw6aefNiWMFMFdIHnRl0VytzX6skhKG1L0ZeFu9GX9S4DF+u0BxEEHtdKD0z179shff/0lTzzxhMnYnTBhgi3D8u7duxISEiLjx4+XQ4cOmSwmICb69RMREWEycY8cOWJrQ5odbg3m6kkEzditWLGiCcppRrhmVv74449cPo9oaea3c/Bfv6d+//13+fLLL02b0/rgmlmjbU/pvJ07d0r+/PlNuyL4hvhau3atPProo6ZeuP7maZBXA7oPP/ywORmltNbuxx9/bEobvfTSS5z4BDyEvixcjb4s3IG+LJITfVk/ogFeIC4nT5609OrVyzJjxgzbvEWLFlnSpEljef311y337t2zzb97967lypUr7FTE6JNPPrF8/vnnDm2pUKFCZipYsKDl+eeft9y+fdty69YtS4MGDSzFihWzVKlSxdKqVStLtmzZLHv37mXvIlqzZs2ylC5d2rSf+/fv2+Y/88wzlvr169tuR0ZG2v4+ePAgexOJ8u+//1peeOEFS58+fRx+A7/55htLzpw5LSNGjLDNHzlypOXw4cPsacBD6MvClejLwl3oyyI50Zf1L5RoQJw0Y3fUqFFy/vx5cxmzNem7U6dO5u+uXbuabLiRI0eaTF7rBERH29GGDRtMu9KM3GbNmsmgQYPkzTffNJc2h4eHy/PPPy8nT56Ub775xmTrzp49W06dOmWyLfUSe10OiI6WXNA64VrzVAdT09rgmp2rZT70qoK9e/dKlSpVzHeW1kvVGqlaM1wHWdMSDUAMJ8Ntl0k6j2Ct7cp+oEf9/dM6z7169TI1w69fvy5ZsmQxv6MAPIO+LFyJvizcib4s3IG+bMpAgBdxCg0NNcE1PYjVYIge2OoXhE6dO3c2l5rq/1qHd8SIEexRxErrT+oAQx999JEJ6m7bts0EeV944QXbZcsagNMalv379zfLWes7A3HRUh5q165dZlC+77//3gR39W+tiaq1wYcMGSJ16tQxA/hNmzbNHPgXKVKEnYsY6e+eHtDfvHlTSpQoIYsXL5YMGTJI+/btpV27dqZeuLa5WrVq2YK8WiZER1AH4Hn0ZeFK9GXhTvRl4Q70ZVMGAryI07PPPisZM2Y09QU1MKcBkapVq9qCvE899ZTJrLTWTQXiOnNYrVo1CQ4ONn9rjUoNrlmDu3fu3DEZulrDUrPCjx49agap0PudM+cAzcLVtmH930pr6eqJgscee8wE3zTIq8Fe/b56+eWXzUCQRYsWNXV3f/jhBxO0A2Jy6dIladq0qbRp00aKFy8uffv2lVmzZpn76tWrJ/Pnz5fPPvvMfEfpySml313axhhoFPA8+rJwFfqycDX6skgO9GVTCE/XiIB3sdalPHLkiOXAgQOWXbt22e5bunSppUmTJpYOHTpYfv/9d9vy9rUsgbjY10XV9vXcc89ZAgICHGryqhUrVlhKlChhOX36NDsVsTp69Kj5flJffPGF5cEHHzR/6/eUfl/lz5/fsnv3bjMvLCzMsnDhQsurr75q+eCDD6iJilj98ccftr/nz59vyZs3r/m+mjRpksNyX3/9taVatWqW2rVrW1q0aGF5/PHHLVmzZrXs27ePPQwkM/qycDf6snA1+rJwF/qyKQsBXtg6KtYO8VdffWUGKSpcuLAJjLRr184WZNPBsB566CFz8Lpnzx72HuLN2r7u3Lnj0DHWEwndunUzwdwFCxbYlhkyZIilXLlylgsXLrCXEatnn33WUrJkSRO0DQwMNAOfWFmDvAUKFLAFeYH40JMGVatWNYOdqHPnzplBHrNnz2554403zMkCezt27LB8+umnlo4dO5rBR//88092NJCM6MvC3ejLwl3oy8Id6MumPAR4U7i1a9c63P7ll18sGTNmtMycOdOyefNmy48//mgpXry4yUo6f/68WUaz32rUqGFGpdfRwoH4dohXr15teeSRRyyNGjUyQbe9e/ea+YcOHTJBXs2M04CKZvVqwNc+gxyIqV2phg0bmvbTp0+fKMtZg7xFixalTSHejh8/br6vmjZtarJ31cmTJ82JqIIFC1oGDhwYJchrbZdc2QIkH/qySA70ZeHOdqXoy8LV6MumPAR4U7DBgwebLF37S+DHjRtnadWqlcOPzZUrV0xgRLN2rZYtW2b5559/kn2b4XusbWnVqlUmu3LAgAGWkSNHWh544AHTrjQrXIWGhlp69+5tyZIli2X8+PGWy5cve3jL4Y0iIiKivaxNy8fUqVPHXCav5T5u3boVJciry5QvX95kiBOAQ3zamQZ09eRA/fr1bVcYKM3U1SCv/o4ePnzYzBsxYoTlm2++YccCyYi+LJIDfVm4En1ZJAf6sikTAd4UaufOnZbcuXNbtmzZYm6fOnXK/K/Zb5qda3X79m3zvx60ajBOL6cH4vNjYt95uXbtmgmuDR8+3GHZLl26mHalwV21fft2c5m91oAGYqIBNQ2mqSVLllieeOIJy19//WVuazCucuXKJshr/f6yHpydOXPGnMkGEtMxbty4sa1cgzXIq1e4PProo5bOnTubDHL9bQWQPOjLwl3oy8Ld6MsiOdCXTXn+f8hxpCjp06eXQoUKyYULF+TLL7+Ul156SW7evGlGmD9x4oTMnTvXtpxKmzatpEmTRjJnzuzhLYcvjAL7zz//mBHld+3aZWs/4eHhUrBgQXP77t275v+FCxdK7ty5Zdy4ceZ23bp1ZeLEiVKiRAkPvgp4exvbuHGjjB07Vh5//HHp1KmTPPLII1KmTBlz/4oVK6RUqVLy3nvvyVdffSV37tyRN954Q5o1ayb58+eXIkWKePolwEfod5nS38rp06dL9uzZZd68eTJ79mwzv3fv3jJhwgTJlSuX3Lt3T37//XepVauWh7caSDnoy8Id6MvC3ejLIrnQl0150nh6A+CZTosesJYvX15GjRolv/32m8yaNUsyZcpkAiMdO3Y0tzXDu0ePHiZAsnnzZsmaNatkyJCBtwyxtq0//vhDnnjiCalYsaIULlzYdhCWMWNGWbdunbz88suSLl06E+TV/+vXry8nT560rUfnATHRNqbfS9u3bzeBtjZt2kj37t3NffpdpW1Ng7x6surtt9+WKVOmyPHjx+Wbb75hpyJO+rsXEBBgTnRevHhRChQoYE5s6okBDfK+8sorJsirevbsKZ07d5YOHTqYdhkYGMgeBpIBfVm4u23Rl4U70ZeFO9GXTdnI4E1Bhg8fLj/88IPpvOTIkUMaNmxogrsVKlSQvHnzmvl6EPviiy9K5cqVZdCgQSYI3LRpU/n4449NMEUzlYCYOisHDx6Uxo0bm5MEH374oQm+2be//fv3y4ABAxwCuZcvX5YsWbJIRESE+UEC4kOzcZ9++mnZsWOH+a5SGty9ffu2+XvJkiUycuRIE/zdsmWL1KtXjx2LeHWI9QRBixYtpH379ub/0aNHm6sSihYtaoK8+vv5xRdfyIwZM2ztjuAukDzoy8Kd6MsiOdGXhavRl0WA1mlgN6QMXbp0MZcqa/BWffLJJ3L16lVzubOWZ9DMSs160wPcM2fOyKlTp+Trr782QV8N8pYuXdrTLwFeTLMnu3XrZk4WaHDX6t9//zVBXA2QbN261WS/aVkGDQQfPXrUBOI0SKcZv0BCXP+/9u4EuuY7/eP4E0uorcQSJUQpSlOCMWOrqZFKOlVBp5aamXYsgyqTg3FEiVbtJGodKtbQw4SO09EWxbSqZaaDkmoHLc3IGLsWY09///M8/3PvEUKj7pKfvF/n3MP95Zfk6/b25slzn9/ne+6cLF26VJKSkmyqd+rUqd6PZWZmSmRkJA8ofnBS6/q/r1u3zmI/tKn7+9//3iJj9GdlTEyMTYTrVS463atvHOhVCdrovf/++3mUgQChloU/Ucsi0KhlcTeoZXEjGrwF6J0cj/fff9+abp7pyiNHjtgvq5ohOGDAAHn22WdznA/kxbVr1+yNAH2T4KWXXrJj69evt4aJ5vFqs00jPsaPH2+Tb3r5c1hYmDVNPG86ALd7Ddu7d681bpVm6uoUuD6P9E0CbfLq61hycrJN7m7btk3S09NpvuG29I0nncjVJu3x48ctdqFZs2YycuRIy6hv2rSpvcl59uxZiYqKsrzwGjVqeGNlPDE0APyLWhaBQC0Lf6GWhb9Qy+J6NHgLIL3sVJtuOp3bpk0bu7xUJ3Z1+lKbvJoxqJsXAXdCGyC6Sdpjjz0mQ4YMkbfeesumdbUposc0x1InLDWf97XXXrNCR99o4NJm5PVSI31e6WaPmheux/TNKo2NOXXqlD3fEhIS7I2Eo0ePWt4zG17hdvT1JzY21qJlvvjiC9tETTfm02givWyydevW9tqlE7waLaNvVOmVB9OnT7dJXgDBQy0Lf6CWhT9Qy8JfqGVxE41oQMHTqVMnp0KFCs4777zjXLhwwY4dOXLEiYuLcxo0aOCsWbMm2EuEC23atMkpUqSIExkZ6ZQuXdqZO3euc+DAAfvYlStXnHbt2jk9evQI9jLhMhs3bnTuv/9+54033nCys7OdDRs2OCEhIc7DDz/sHD582M65ePGis3fvXic1NdU5ePBgsJcMl8jIyHCaNm3q1K9f3zl9+rT3+IwZM+z16uTJk3Zfn1dRUVFO165dnaysrCCuGIAHtSz8gVoW/kAtC3+hlsX12GTtHueJWNZLT3XK7fLly3Zfp91atGhhU7ubN2+2jYl0t/AFCxbYZFJ0dHSQVw430oiGgwcPyurVq+1P3bDPk91cuHBhuwz6wQcftOcl8d/IazaZTu8OGzZM+vTpY9O5vXv3thxG3ZxPr0LQKxD0SoT69etLr1697DkG3I7n9UefM5rjrK9NuqHamTNnvD8z9Xml2WZq37599pzTDUerVq3KgwsEELUsAolaFr5GLQt/oJZFbohoKAC0mau5p9oY6dy5s13WphvGqPj4eNthPi0tzS491U1jsrOzrRkH+IpGf2gsw8KFC21Tv9q1a/PgIs/Wrl1rb0DVrFnTXrs0F1VznDV7t1u3bhIeHi47duyQKlWq8KjitptQ6AY6+maA57K2okWL2t+HDh0qKSkplgeur1Fbtmyx1yzdELJMmTLyzjvvyM6dO6Vu3bo8wkAQUMsi2KhlcTeoZXG3qGWRF0zw3uP27Nkj/fv392589Y9//MN+idWJOKU5vNrYfeqpp2Tr1q12zLOrOOALy5Ytkz/+8Y8yf/58K25o7uJGnilJbb7l9s50+/btpUmTJvLJJ59Yc2748OF2XJtv+tql2c//+9//eGBxS/pz7T//+Y9dtfK3v/3Njnmau5MnT5bFixfba5Qe0zcRHn/8cenXr59lPOumO3//+99p7gJBQi2LYKOWxQ+hloW/UcsiL4rk6Sy4andhzwTu/v37rYGrv6Tq5c1Km7k6laSbxqhOnTrZ5fQ9evSwncGV5+sAd0sva9bYD92lXpsq9erV40HFLQsW3chK35DS2IXcXosyMzPls88+k4iICLu/adMmqVixol02X6xYMR5Z3JZGFGVlZdlmj7q5Y8uWLWXixIkyZcoUWblypTV2NbpIp8Lj4uJsalfjQHRqi80gAf+jlkV+RC2LvKCWRSBQy+KHENFwDzl27JhdqqyOHDlizdsDBw7Y9K5ezuyxbds2GTNmjDWBf/3rX9svs4C/aJalNt804xK4Fc1s1tejsLAwSUxMtObbjfR1TXNST548KQ0aNLB4GZ2s1MvqgbzQn4mDBg2y16RKlSrJmjVrbDKrXbt23nP+9a9/WYO3cuXKNjWubzTwxicQGNSyyI+oZZEX1LIIBGpZ3A4N3nvEt99+Kx07drRfWDWXUukvrjqtq5eMzJo1K0fDZPv27TJkyBDLtdRLU0uWLMkvsADyRcGiU1yjRo3yvmZ5Mqf0Ty2eR48eLY888oi9icVUOO6UXt2ikUUaS6Q/I/Vn4fXPM885GtfAhn1A4FDLAnA7alkEArUsboUG7z1C8yf1MmW9zFQbH9q0VX/961/tF9iHHnpIBg4cKM2bN/d+zqeffmoTStWqVQviygEgb4Wx3kaMGGGTvHPmzLHNr4Af4+uvv5YXX3zRrmTR51SrVq28zzNy6IHgoJYFcC+glkUgUMsiNzR47wGeX0jPnz8vS5YssY1ioqOjvU1e3VBNcwZ1B/qEhATbkAgA3FQYaw6qTlrOnj1bdu7caa9xgK+fZwCCg1oWwL2EWhbBep6hYKPB6+Ii2LOZ2o1NXm3spqam5mjyalyDbiRTtmxZeeWVV6Rp06ZB/lcAQN4KluHDh8t7770nM2fOtNzdRo0a8dDBZ8+zwYMHW67ztGnTpFmzZjyyQABQywK411HLIlDPM2pZePx/2BxcRRu5mkM5ffp023nec0yL5VKlSskLL7wgffr0kYyMDG+2oObz6v/4uvNilSpVgvwvAIDbq127tsyYMcNyUDt37iyvv/66ZabS3IWvn2f65mdERAQ/G4EAopYFcK+jlkWgnmfUsvBggtel9H9i3WhIR/G1oaubpV0/EaEbVSQnJ8u6detk+fLlUqdOHfu4TvhqExgA3GDfvn0ybNgwGT9+vOWLA/6gESChoaE8uEAAUcsCKAioZREI1LJQNHhdZMWKFda87dKli90fO3aszJs3T/r16yc9e/b0Nnk90Q3Hjh2zDdTS0tKka9euQV49APw4V69etUleAIC7UcsCKIioZQEEQpGAfBfctRMnTsjUqVOlXLlyUqRIEbtkeeTIkTaxO3fuXDunV69eUrlyZWvuXrt2TUJCQqR58+ZcdgrA1WjuAoD7UcsCKKioZQEEAhm8LlGxYkXbOE2btgsWLJD09HQ7npSUJL1797Ymr94yMzPtuDZ5dbf548ePS82aNYO8egAAABRk1LIAAAD+Q0SDC+iUrt50clc3GdKmbrFixaR///7SoUMHO0fzKZcuXWrN3OrVq1sGi+46rxm8DRs2DPY/AQAAAAUUtSwAAIB/EdHgAjq1q83d1atXy4YNG2wDtYyMDDl9+rQVzB07dpQRI0ZYc3fHjh12a9KkiWzevFnq1asX7OUDAACgAKOWBQAA8C8meF1CJ3fbtm1rsQvR0dFy/vx5SUhIkEqVKsmAAQMkPj7ee642fbWQ1hsAAAAQbNSyAAAA/sMEbz6nzdpChQrJhx9+KI0aNbK8XY+FCxfKb3/7W4tn0OD2X/7yl3ZczwcAAACCjVoWAADA/+gE5rMC2OPatWv253fffWd/lipVynJ1dXLX8/HGjRvLlClTLK5h3Lhxsnbt2iCtHAAAAAUdtSwAAEBw0ODNR3Tydv/+/Tatq5m7q1atsondixcv2vTuZ599Junp6XauflyFhoZKVFSUhIeHW3QDAAAAEAzUsgAAAMFBgzcfyc7OtozdNm3ayKuvvipdunSxbN377rtPWrduLWPGjJG+fftKamqqHD9+3KZ4P/jgA2nZsqUsWrRIIiIigv1PAAAAQAFFLQsAABAcbLKWT3LJrqfN3G3btsnQoUNlwoQJ1sjVid3Lly9LSkqKJCUlSa1atSx3NzMzU7Zs2cL0LgAAAAKOWhYAACD4aPDmg4I4KytLdu3aJTExMXb/qaeeknPnzsmePXssV7dt27biOI6EhITY523fvl327dtnebxxcXHW7AUAAACoZQEAAAoeGrxBbu5+/vnn0qNHD6lUqZKMGDHC4hkuXbpk57z00kuyfPlyb5NXL3srXLiwnDlzRsqVKxespQMAAKCAo5YFAADIP8jgDQKdxtXm7hdffCGPPfaYTeHOmTPHmruqePHidps0aZJ0795dnn76adm4caM1dydOnCj9+vWTCxcu2NcBAAAAqGUBAAAKLiZ4g+Ts2bO2gVrjxo0lOTk5x8e+++47KVmypOXuXrlyRQYMGCALFiywBvDHH39s+byNGjUK1tIBAABQwFHLAgAA5B9M8AbJxYsXvYWxx4cffmgbqD388MPy85//XEaNGmVTu/Pnz7eohnbt2klGRgbNXQAAAAQVtSwAAED+USTYCyiorl27Jl9++aVtrta6dWt5/fXXZenSpRIWFiZ9+/aVQ4cOydtvvy3R0dHyzDPPWFTD9RutAQAAAMFCLQsAAJB/ENEQRBMmTJCXX35ZatWqJYcPH5Zx48ZJbGysREVFyfnz522St2fPnjJmzJhgLhMAAAC4CbUsAABA/sAEb4B2GL506ZLl6erUbp06daRUqVKSmJhom6zptK5O8UZGRno/R2/a6K1evbq/lwgAAADkiloWAAAg/6PBG4CC+MCBAzJ58mTbIE2buWXLlpUOHTrI4MGDpVWrVtKyZcsc0Qv6OVOnTrXPi4mJ8ecSAQAAgFxRywIAALgDm6z5uSDes2ePtGnTxv4+aNAg2bp1qzz99NOybt06y9Xdu3dvjubu+vXrZciQITJr1ixZvXq11KhRw19LBAAAAHJFLQsAAOAeZPD6uSBu0aKFDBw4UF599VUJDQ31npOamiopKSlSuXJlWbZsmVSpUsWau9OnT5erV6/KtGnTLKIBAAAACCRqWQAAAHehwesn//73vyU6Olrat28vS5cuFcdxbFJXm7dFixa1czSGYezYsTJ37lzp1q2bHDt2TE6cOGFN3woVKvhraQAAAMBtUcsCAAC4BxENfrJr1y6JiIiwjdV0klebu9rk1eauTkWooUOHWgTDhg0b7H54eLhN7dLcBQAAQDBRywIAALgHDV4f0eatOnv2rP0ZHx8viYmJNpGblJTkbfKq6zN3ixcvLoULF/bVMgAAAIA7Ri0LAADgXjR4fUSbtv/973+la9euMmfOHDumm6j16tVLzp07523yXl9Ef/PNN1K6dGmJiYnxHgMAAAACjVoWAADAvWjw3iVP3IJm6+rGahrBsGLFClm4cKEdf+6553I0eXfv3m0FtN7+9Kc/yenTp6VVq1Y3TfYCAAAA/kYtCwAA4H40eO/2ASxUSLKysqyRe/ToUXnjjTekWrVqkpqammuTd/To0XLw4EGZPHmyNXgXLVokVatW9cV/SwAAAOCOUMsCAAC4X4hDLsBd04atNnHLly9vjduwsDDbQO3QoUPSu3dv6dmzp5335ptvypIlSyQjI0NOnjwp27ZtkyZNmtz9AgAAAIAfiVoWAADA3Zjg9YGaNWtKWlqaZGdny+DBgy12YerUqfLggw/eNMmrt0cffVR27txJcxcAAABBRy0LAADgbkzw+tCBAwdk4MCBtllaSkpKjknevn37yvPPP2/naVSDbq4GAAAA5BfUsgAAAO7EBK8P1a5dW2bOnGmbpV0/yavHJ02aJMuXL7fzaO4CAAAgv6GWBQAAcCcavH4ujM+cOSPjx4+XVq1aScuWLX397QAAAACfoZYFAABwHyIa/HiJW0JCgpw6dUoWL15sxXLhwoX99e0AAAAAn6GWBQAAcA8meP1EG7rJyckSEREhJUqUoLkLAAAA16CWBQAAcA8meP3sypUrEhoa6u9vAwAAAPgctSwAAED+R4MXAAAAAAAAAFyKiAYAAAAAAAAAcCkavAAAAAAAAADgUjR4AQAAAAAAAMClaPACAAAAAAAAgEvR4AUAAAAAAAAAl6LBCwAAAAAAAAAuRYMXAAqIkJAQWbNmTbCXAQAAANwxalkAuDUavADgIydOnJD+/ftL9erVpVixYlK5cmWJjY2Vjz/++J59jB9//HErtm91048DAAAg/6OWpZYF4F5Fgr0AALhXPPPMM3LlyhVZsmSJ1KxZU44dOyabNm2SU6dOyb1A/22hoaE5jr311lt2XB0+fFh++tOfysaNG+WRRx6xYzeeDwAAgPyJWpZaFoB7McELAD7w7bffykcffSSTJk2SNm3aSGRkpDU7ExMTpUOHDt7zUlJS5NFHH5WSJUtKtWrV5MUXX5Tz5897P7548WIpW7asrF27VurWrSslSpSQX/3qV3LhwgVrHNeoUUPKlSsngwYNkuzsbO/n6fHXXntNunfvbl+7atWqMnv27NuuWRuyXbp0se8XFhYm8fHx8s0333g//sILL0jHjh1l3LhxUqVKFVvPjfTzdFJZbxUrVrRj5cuXt/vPPfecJCUl3TQZok1fbXzndd362Pbu3du+fpkyZeQXv/iF7N69+w7+6wAAAOB2qGWpZQG4Gw1eAPCBUqVK2U0zbi9fvnzrF91ChWTGjBmyd+9ea9hu3rxZhg0bluMcbebqOStWrJB169bJBx98IJ06dZJ3333XbmlpaTJv3jxZtWpVjs+bMmWKNGzYUHbt2iXDhw+XP/zhD/L+++/nuo6rV69afETp0qWtMa0xErr+uLg470Su0kbsvn377Oto0/lOaFP2zTffzPF4LFu2zJq42qTN67qfffZZOX78uLz33nuyY8cOady4sbRt21ZOnz59R+sBAABA7qhlqWUBuJwDAPCJVatWOeXKlXOKFy/utGjRwklMTHR27959289JT093ypcv772/aNEiR1+av/rqK++xvn37OiVKlHDOnTvnPRYbG2vHPSIjI524uLgcX7tr167Ok08+6b2vX/cvf/mL/T0tLc2pW7eu8/3333s/fvnyZee+++5z1q9fb/eff/55Jzw83I7nxaFDh+x77Nq1y+5fvHjRHo+VK1d6z2nQoIHzyiuv5HndH330kVOmTBnn0qVLOc6pVauWM2/evDytCwAAAD+MWpZaFoB7McELAD7MLTty5Ii8/fbbNgmrk7c6baqxCx6aT6vTpzrFqtOzv/nNbyyjV6d2PTSWoVatWt774eHhFmWgkxXXH9Op1us1b978pvtffvllrmvViIOvvvrK1uCZ2NC4hUuXLsnXX3/tPU/jJH5sjm7x4sXt37dw4UK7v3PnTvn8888t+iGv69Z1aoSFxj541qm3Q4cO5VgnAAAA7g61LLUsAPdikzUA8CFtaj7xxBN2GzVqlMUUjB492pqamm/bvn176d+/v+XaakN169at0qtXL4tF0MauKlq0aI6vGRISkuux77///kevU5umTZo0keXLl9/0MU+WrtJc3Luh//7o6GjJysqSRYsWWTSD5hPfyTofeOABa5bfSLODAQAA4DvUsjlRywJwCxq8AOBH9evXt1xepfmx2pRNTk62LF715z//2Wffa/v27Tfdr1evXq7n6mTxypUrpVKlSrZxmb/oBPBPfvITmT9/vuXxzpo1647Wres8evSoFClSxKaYAQAAEDjUstSyANyBiAYA8AGNWdDpVN1EbM+ePRYhkJ6eLpMnT5b4+Hg756GHHrLNzWbOnCkHDx60zdLmzp3rs8dfN0rT77d//36ZPXu2fX/dsCw3PXr0kAoVKtjadJM1Xa9OyQ4aNMimbX1JJx8mTpyome+2WdydrDsmJsYiGzp27CgbNmywKehPPvlEXn75ZfnnP//p03UCAAAUVNSyt0YtC8ANaPACgA9oLuzPfvYzmTZtmrRu3VqioqIsoqFPnz7eqdWGDRtKSkqKTJo0yT6u8QgTJkzw2eM/ZMgQa3o2atRIxo4da98rNjY213M1DmLLli1SvXp16dy5s03MalSEZvD6eqK3e/fuNoGrf+plf3eybo2iePfdd+0x/d3vfid16tSRbt26SWZmpuUQAwAA4O5Ry1LLAnC3EN1pLdiLAADcHY0vSEhIsFt+o1O3umncp59+apELblk3AAAAAiM/14TUsgDcgAxeAIBfaByFXu43cuRIadas2U3NXQAAACC/opYF4CZENAAA/EKzdR944AGb3PVl1jAAAADgb9SyANyEiAYAAAAAAAAAcCkmeAEAAAAAAADApWjwAgAAAAAAAIBL0eAFAAAAAAAAAJeiwQsAAAAAAAAALkWDFwAAAAAAAABcigYvAAAAAAAAALgUDV4AAAAAAAAAcCkavAAAAAAAAADgUjR4AQAAAAAAAMClaPACAAAAAAAAgEvR4AUAAAAAAAAAl6LBCwAAAAAAAAAuRYMXAAAAAAAAAFyKBi8AAAAAAAAAiDv9Hw4/97i+4q+fAAAAAElFTkSuQmCC",
       "text/plain": [
        "<Figure size 1400x600 with 2 Axes>"
       ]
@@ -1255,7 +1299,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1363,12 +1407,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1600x1200 with 4 Axes>"
       ]
@@ -1394,7 +1438,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 25,
    "metadata": {},
    "outputs": [
     {
@@ -1457,8 +1501,8 @@
        "      <td>20.944804</td>\n",
        "      <td>0.407318</td>\n",
        "      <td>0.292635</td>\n",
-       "      <td>0.017228</td>\n",
-       "      <td>0.000108</td>\n",
+       "      <td>0.023385</td>\n",
+       "      <td>0.000189</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
@@ -1471,8 +1515,8 @@
        "      <td>7.248263</td>\n",
        "      <td>0.239544</td>\n",
        "      <td>13.989176</td>\n",
-       "      <td>0.001672</td>\n",
-       "      <td>0.000053</td>\n",
+       "      <td>0.001647</td>\n",
+       "      <td>0.000030</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
@@ -1485,8 +1529,8 @@
        "      <td>21.122113</td>\n",
        "      <td>0.046672</td>\n",
        "      <td>0.115326</td>\n",
-       "      <td>0.020083</td>\n",
-       "      <td>0.000352</td>\n",
+       "      <td>0.026723</td>\n",
+       "      <td>0.000335</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
@@ -1499,8 +1543,8 @@
        "      <td>12.455526</td>\n",
        "      <td>0.001055</td>\n",
        "      <td>8.781913</td>\n",
-       "      <td>0.002039</td>\n",
-       "      <td>0.000091</td>\n",
+       "      <td>0.001896</td>\n",
+       "      <td>0.000028</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>...</th>\n",
@@ -1527,8 +1571,8 @@
        "      <td>4.031370</td>\n",
        "      <td>0.113094</td>\n",
        "      <td>17.206069</td>\n",
-       "      <td>0.296038</td>\n",
-       "      <td>0.002294</td>\n",
+       "      <td>0.285090</td>\n",
+       "      <td>0.001583</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>80</th>\n",
@@ -1541,8 +1585,8 @@
        "      <td>21.051757</td>\n",
        "      <td>0.036463</td>\n",
        "      <td>0.185681</td>\n",
-       "      <td>0.802716</td>\n",
-       "      <td>0.007826</td>\n",
+       "      <td>1.167934</td>\n",
+       "      <td>0.003894</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>81</th>\n",
@@ -1555,8 +1599,8 @@
        "      <td>5.809188</td>\n",
        "      <td>0.000607</td>\n",
        "      <td>15.428251</td>\n",
-       "      <td>0.301287</td>\n",
-       "      <td>0.002927</td>\n",
+       "      <td>0.282971</td>\n",
+       "      <td>0.000132</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>82</th>\n",
@@ -1569,8 +1613,8 @@
        "      <td>6.154125</td>\n",
        "      <td>0.005287</td>\n",
        "      <td>15.083314</td>\n",
-       "      <td>0.292405</td>\n",
-       "      <td>0.003091</td>\n",
+       "      <td>0.291808</td>\n",
+       "      <td>0.003596</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>83</th>\n",
@@ -1583,8 +1627,8 @@
        "      <td>21.559537</td>\n",
        "      <td>0.000925</td>\n",
        "      <td>0.322098</td>\n",
-       "      <td>1.995156</td>\n",
-       "      <td>0.014354</td>\n",
+       "      <td>2.089140</td>\n",
+       "      <td>0.021533</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -1607,34 +1651,34 @@
        "\n",
        "      Std Dev  Mean Absolute Error  Std Dev Error  Runtime (s)  \\\n",
        "0   21.237439             0.000000       0.000000     0.000000   \n",
-       "1   20.944804             0.407318       0.292635     0.017228   \n",
-       "2    7.248263             0.239544      13.989176     0.001672   \n",
-       "3   21.122113             0.046672       0.115326     0.020083   \n",
-       "4   12.455526             0.001055       8.781913     0.002039   \n",
+       "1   20.944804             0.407318       0.292635     0.023385   \n",
+       "2    7.248263             0.239544      13.989176     0.001647   \n",
+       "3   21.122113             0.046672       0.115326     0.026723   \n",
+       "4   12.455526             0.001055       8.781913     0.001896   \n",
        "..        ...                  ...            ...          ...   \n",
-       "79   4.031370             0.113094      17.206069     0.296038   \n",
-       "80  21.051757             0.036463       0.185681     0.802716   \n",
-       "81   5.809188             0.000607      15.428251     0.301287   \n",
-       "82   6.154125             0.005287      15.083314     0.292405   \n",
-       "83  21.559537             0.000925       0.322098     1.995156   \n",
+       "79   4.031370             0.113094      17.206069     0.285090   \n",
+       "80  21.051757             0.036463       0.185681     1.167934   \n",
+       "81   5.809188             0.000607      15.428251     0.282971   \n",
+       "82   6.154125             0.005287      15.083314     0.291808   \n",
+       "83  21.559537             0.000925       0.322098     2.089140   \n",
        "\n",
        "    Runtime Std (s)  \n",
        "0          0.000000  \n",
-       "1          0.000108  \n",
-       "2          0.000053  \n",
-       "3          0.000352  \n",
-       "4          0.000091  \n",
+       "1          0.000189  \n",
+       "2          0.000030  \n",
+       "3          0.000335  \n",
+       "4          0.000028  \n",
        "..              ...  \n",
-       "79         0.002294  \n",
-       "80         0.007826  \n",
-       "81         0.002927  \n",
-       "82         0.003091  \n",
-       "83         0.014354  \n",
+       "79         0.001583  \n",
+       "80         0.003894  \n",
+       "81         0.000132  \n",
+       "82         0.003596  \n",
+       "83         0.021533  \n",
        "\n",
        "[84 rows x 11 columns]"
       ]
      },
-     "execution_count": 24,
+     "execution_count": 25,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1652,7 +1696,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 26,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1765,7 +1809,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.12"
+   "version": "3.13.13"
   }
  },
  "nbformat": 4,
diff --git a/demos/GBM/gbm_examples.ipynb b/demos/GBM/gbm_examples.ipynb
index 20b156f75..e35b8374b 100644
--- a/demos/GBM/gbm_examples.ipynb
+++ b/demos/GBM/gbm_examples.ipynb
@@ -8,6 +8,42 @@
     "This notebook demonstrates MAE plots and comparisons for GBM samplers. "
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/GBM/gbm_examples.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  import sys\n",
+    "  import os\n",
+    "  repo_root = \"/content/QMCSoftware\"\n",
+    "  notebook_dir = f\"{repo_root}/demos/GBM\"\n",
+    "  if not os.path.isdir(repo_root):\n",
+    "    !git clone -q --depth 1 https://github.com/QMCSoftware/QMCSoftware {repo_root}\n",
+    "  !pip install -q qmcpy\n",
+    "  !pip install -q QuantLib\n",
+    "  os.chdir(notebook_dir)\n",
+    "  if notebook_dir not in sys.path:\n",
+    "    sys.path.insert(0, notebook_dir)\n",
+    "  extra_path = f\"{repo_root}/demos/GBM/gbm_code\"\n",
+    "  if extra_path not in sys.path:\n",
+    "    sys.path.insert(0, extra_path)\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -25,13 +61,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "import matplotlib.pyplot as plt\n",
     "from matplotlib.ticker import FixedLocator, FixedFormatter\n",
     "\n",
+    "# colab-deps: QuantLib\n",
+    "# (needed transitively by averaged_mae -> quantlib_util)\n",
     "import config as cf\n",
     "import averaged_mae as am\n",
     "import plot_util as pu"
@@ -228,7 +266,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.12"
+   "version": "3.13.13"
   }
  },
  "nbformat": 4,
diff --git a/demos/acceptance_rejection.ipynb b/demos/acceptance_rejection.ipynb
index 7f6f99f1c..8bed5e925 100644
--- a/demos/acceptance_rejection.ipynb
+++ b/demos/acceptance_rejection.ipynb
@@ -13,21 +13,37 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/acceptance_rejection.ipynb)"
+    "**Reference:** Zhu, H. & Dick, J. (2014). *Discrepancy bounds for deterministic acceptance-rejection samplers.* Electronic Journal of Statistics, 8(1), 678–707. [DOI: 10.1214/14-EJS898](https://doi.org/10.1214/14-EJS898)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "**Reference:** Zhu, H. & Dick, J. (2014). *Discrepancy bounds for deterministic acceptance-rejection samplers.* Electronic Journal of Statistics, 8(1), 678–707. [DOI: 10.1214/14-EJS898](https://doi.org/10.1214/14-EJS898)"
+    "## Setup"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Setup"
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/acceptance_rejection.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
    ]
   },
   {
diff --git a/demos/asian-option-mlqmc.ipynb b/demos/asian-option-mlqmc.ipynb
index 2b91aeaf2..b67f19757 100644
--- a/demos/asian-option-mlqmc.ipynb
+++ b/demos/asian-option-mlqmc.ipynb
@@ -1,5 +1,28 @@
 {
  "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/asian-option-mlqmc.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -27,13 +50,6 @@
     "# Comparison of multilevel (Quasi-)Monte Carlo for an Asian option problem"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/asian-option-mlqmc.ipynb)"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
diff --git a/demos/brownian_bridge.ipynb b/demos/brownian_bridge.ipynb
index 7d0e3c41d..96cdaa00a 100644
--- a/demos/brownian_bridge.ipynb
+++ b/demos/brownian_bridge.ipynb
@@ -10,19 +10,36 @@
   },
   {
    "cell_type": "markdown",
-   "id": "0271b99b-5c80-4484-a30c-bb4170665b47",
+   "id": "f01eecc1-b4ff-47c3-8b66-1c008da8dd8d",
    "metadata": {},
    "source": [
-    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/brownian_bridge.ipynb)"
+    "`BrownianMotion` supports multiple path construction methods via the `decomp_type` parameter, including `'PCA'` and `'Cholesky'`. This notebook introduces `'BrownianBridge'`, which samples time points by conditioning on the two nearest time values that have already been sampled. The default order follows the van der Corput sequence, with the first term replaced by the terminal time and the full sequence scaled by the provided `t_final`. This ensures that each QMC dimension is used in decreasing order of variance. A custom order can also be provided through `monitoring_times`. "
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "f01eecc1-b4ff-47c3-8b66-1c008da8dd8d",
    "metadata": {},
    "source": [
-    "`BrownianMotion` supports multiple path construction methods via the `decomp_type` parameter, including `'PCA'` and `'Cholesky'`. This notebook introduces `'BrownianBridge'`, which samples time points by conditioning on the two nearest time values that have already been sampled. The default order follows the van der Corput sequence, with the first term replaced by the terminal time and the full sequence scaled by the provided `t_final`. This ensures that each QMC dimension is used in decreasing order of variance. A custom order can also be provided through `monitoring_times`. "
-   ]
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/brownian_bridge.ipynb)"
+   ],
+   "id": "efc21d5e"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
+   ],
+   "id": "647e9e4c"
   },
   {
    "cell_type": "code",
diff --git a/demos/control_variates.ipynb b/demos/control_variates.ipynb
index 2e604b6c0..2f22ad452 100644
--- a/demos/control_variates.ipynb
+++ b/demos/control_variates.ipynb
@@ -11,6 +11,15 @@
     "This notebook demonstrates QMCPy's current support for control variates. "
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "v_CDThSJUpUz"
+   },
+   "source": [
+    "## Setup"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -19,12 +28,19 @@
    ]
   },
   {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "v_CDThSJUpUz"
-   },
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
-    "## Setup"
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
    ]
   },
   {
diff --git a/demos/copula_examples.ipynb b/demos/copula_examples.ipynb
index 874d57a1e..d3ab52d64 100644
--- a/demos/copula_examples.ipynb
+++ b/demos/copula_examples.ipynb
@@ -165,6 +165,31 @@
     "Nelsen, R. B. (2006). *An Introduction to Copulas* (2nd ed.). Springer."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/copula_examples.ipynb)"
+   ],
+   "id": "de7b5ea9"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
+   ],
+   "id": "9773e229"
+  },
   {
    "cell_type": "code",
    "execution_count": 14,
diff --git a/demos/demo_resume_data/Iteration_Log_Tolerance_Demo.ipynb b/demos/demo_resume_data/Iteration_Log_Tolerance_Demo.ipynb
index 93f2b969a..1d2b3e9af 100644
--- a/demos/demo_resume_data/Iteration_Log_Tolerance_Demo.ipynb
+++ b/demos/demo_resume_data/Iteration_Log_Tolerance_Demo.ipynb
@@ -6,6 +6,31 @@
    "metadata": {},
    "source": "# Stop Re-running: Efficient Numerical Integration via Solver Log and Resumption\nSou-Cheng Choi \n\nMay 4, 2026\n\nIn high-dimensional integration, achieving high precision in the solution estimate often requires solving the same problem across a wide range of tolerances ($\\varepsilon$). Traditionally, this meant running the entire simulation multiple times, leading to prohibitive computational costs. This demo shows how using QMCPy's resume feature and internal solver logs can substantially reduce computational overhead while maintaining accuracy.\n\n## Approach 1. Classic Loop\nUsing the same approach as in, for example, [MCQMC2022_Article_Figures.ipynb](https://github.com/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/MCQMC2022_Article_Figures/MCQMC2022_Article_Figures.ipynb), we will set up to create the two tolerance subplots:\n\n1) Time vs tolerance and \n2) Number of samples, $n$ vs tolerance, each on log-log axes, with the Lattice series plus the $\\mathcal{O}(\\epsilon^{-1})$ reference trend.\n\nThis naive approach requires re-running the solver for every target tolerance. This method suffers from poor scaling, making it impractical for large-scale parameter sweeps.\n"
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/demo_resume_data/Iteration_Log_Tolerance_Demo.ipynb)"
+   ],
+   "id": "86e67406"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
+   ],
+   "id": "02988ece"
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -499,4 +524,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
\ No newline at end of file
+}
diff --git a/demos/demo_resume_data/accuracy_and_resume.ipynb b/demos/demo_resume_data/accuracy_and_resume.ipynb
index 20b9cdc38..d0b558f2e 100644
--- a/demos/demo_resume_data/accuracy_and_resume.ipynb
+++ b/demos/demo_resume_data/accuracy_and_resume.ipynb
@@ -83,6 +83,40 @@
     "Let's see how this works in code. We will use a Genz oscillatory integrand and QMCPy's `CubQMCLatticeG` routine."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/demo_resume_data/accuracy_and_resume.ipynb)"
+   ],
+   "id": "e5547174"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  import sys\n",
+    "  import os\n",
+    "  repo_root = \"/content/QMCSoftware\"\n",
+    "  notebook_dir = f\"{repo_root}/demos/demo_resume_data\"\n",
+    "  if not os.path.isdir(repo_root):\n",
+    "    !git clone -q --depth 1 https://github.com/QMCSoftware/QMCSoftware {repo_root}\n",
+    "  !pip install -q qmcpy\n",
+    "  os.chdir(notebook_dir)\n",
+    "  if notebook_dir not in sys.path:\n",
+    "    sys.path.insert(0, notebook_dir)\n"
+   ],
+   "id": "d7037d28"
+  },
   {
    "cell_type": "code",
    "execution_count": null,
diff --git a/demos/demo_resume_data/resume_examples.ipynb b/demos/demo_resume_data/resume_examples.ipynb
index e49585cb3..afefc1817 100644
--- a/demos/demo_resume_data/resume_examples.ipynb
+++ b/demos/demo_resume_data/resume_examples.ipynb
@@ -22,6 +22,40 @@
     "This demonstrates workflow and checkpointing correctness. For small examples, wall-clock timing differences can be negligible; performance gains become clearer when the initial run already used substantial work."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/demo_resume_data/resume_examples.ipynb)"
+   ],
+   "id": "0bc91a9d"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  import sys\n",
+    "  import os\n",
+    "  repo_root = \"/content/QMCSoftware\"\n",
+    "  notebook_dir = f\"{repo_root}/demos/demo_resume_data\"\n",
+    "  if not os.path.isdir(repo_root):\n",
+    "    !git clone -q --depth 1 https://github.com/QMCSoftware/QMCSoftware {repo_root}\n",
+    "  !pip install -q qmcpy\n",
+    "  os.chdir(notebook_dir)\n",
+    "  if notebook_dir not in sys.path:\n",
+    "    sys.path.insert(0, notebook_dir)\n"
+   ],
+   "id": "2667504c"
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -760,4 +794,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
\ No newline at end of file
+}
diff --git a/demos/digital_net_b2.ipynb b/demos/digital_net_b2.ipynb
index c8feb3d2c..fc51ada3c 100644
--- a/demos/digital_net_b2.ipynb
+++ b/demos/digital_net_b2.ipynb
@@ -7,6 +7,29 @@
     "# Digital Net Base 2 Generator"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/digital_net_b2.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -116,7 +139,7 @@
    ],
    "source": [
     "t0 = time()\n",
-    "s.gen_samples(2**25)\n",
+    "s.gen_samples(2**18 if IN_COLAB else 2**25)\n",
     "print('Time: %.2f'%(time()-t0))"
    ]
   },
diff --git a/demos/elliptic-pde.ipynb b/demos/elliptic-pde.ipynb
index 820fd2a27..039255111 100644
--- a/demos/elliptic-pde.ipynb
+++ b/demos/elliptic-pde.ipynb
@@ -5,10 +5,33 @@
    "metadata": {},
    "source": [
     "# Elliptic PDE\n",
-    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
     "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/elliptic-pde.ipynb)"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n",
+    "  !tmp=$(mktemp) && if { apt-get update -qq && DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends texlive-latex-base texlive-fonts-recommended texlive-latex-extra cm-super dvipng; } >\"$tmp\" 2>&1; then rm -f \"$tmp\"; else status=$?; cat \"$tmp\"; rm -f \"$tmp\"; exit $status; fi\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -389,7 +412,9 @@
   {
    "cell_type": "markdown",
    "metadata": {},
-   "source": "In the multilevel Monte Carlo method, we will rely on the ability to generate \"correlated\" solutions of the PDE with varying mesh sizes. Such correlated solutions can be used as efficient control variates to reduce the variance (or statistical error) in the approximation of the expected value $\\mathbb{E}[Q]$. Since we are using a factorization of the covariance matrix to generate realizations of the Gaussian random field, it is quite easy to obtain correlated samples: when sampling from the \"coarse\" solution level, use the same set of random numbers used to sample from the \"fine\" solution level, but truncated to the appropriate size. Since the eigenvalue decomposition will reveal the most important modes in the covariance matrix, that same eigenvalue decomposition on a \"coarse\" approximation level will contain the same eigenfunctions, represented on the coarse grid. Let's illustrate this property on an example using `n = 16` grid points for the fine solution level and `n = 8` grid points for the coarse solution level."
+   "source": [
+    "In the multilevel Monte Carlo method, we will rely on the ability to generate \"correlated\" solutions of the PDE with varying mesh sizes. Such correlated solutions can be used as efficient control variates to reduce the variance (or statistical error) in the approximation of the expected value $\\mathbb{E}[Q]$. Since we are using a factorization of the covariance matrix to generate realizations of the Gaussian random field, it is quite easy to obtain correlated samples: when sampling from the \"coarse\" solution level, use the same set of random numbers used to sample from the \"fine\" solution level, but truncated to the appropriate size. Since the eigenvalue decomposition will reveal the most important modes in the covariance matrix, that same eigenvalue decomposition on a \"coarse\" approximation level will contain the same eigenfunctions, represented on the coarse grid. Let's illustrate this property on an example using `n = 16` grid points for the fine solution level and `n = 8` grid points for the coarse solution level."
+   ]
   },
   {
    "cell_type": "code",
@@ -1000,7 +1025,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1014,9 +1039,9 @@
     "    tol = []\n",
     "    n_samp = []\n",
     "    for t in range(stopping_crit.n_tols):\n",
-    "        stopping_crit.rmse_tol = stopping_crit.inflate**(stopping_crit.n_tols-t-1)*stopping_crit.target_tol # update tol\n",
-    "        stopping_crit._integrate(stopping_crit.data) # call _integrate()\n",
-    "        tol.append(copy.copy(stopping_crit.rmse_tol))\n",
+    "        step_tol = stopping_crit.inflate**(stopping_crit.n_tols-t-1)*stopping_crit.target_rmse_tol # update tol\n",
+    "        stopping_crit._integrate(stopping_crit.data, step_tol=step_tol) # call _integrate()\n",
+    "        tol.append(step_tol)\n",
     "        n_samp.append(copy.copy(stopping_crit.data.n_level))\n",
     "\n",
     "        if verbose:\n",
@@ -1208,4 +1233,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 4
-}
\ No newline at end of file
+}
diff --git a/demos/gaussian_diagnostics/gaussian_diagnostics_demo.ipynb b/demos/gaussian_diagnostics/gaussian_diagnostics_demo.ipynb
index 2783acf31..a5023bcbe 100644
--- a/demos/gaussian_diagnostics/gaussian_diagnostics_demo.ipynb
+++ b/demos/gaussian_diagnostics/gaussian_diagnostics_demo.ipynb
@@ -13,7 +13,23 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/gaussian_diagnostics_demo.ipynb)"
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/gaussian_diagnostics/gaussian_diagnostics_demo.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
    ]
   },
   {
@@ -1795,4 +1811,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 4
-}
\ No newline at end of file
+}
diff --git a/demos/iris.ipynb b/demos/iris.ipynb
index 9848264eb..ef10f38a3 100644
--- a/demos/iris.ipynb
+++ b/demos/iris.ipynb
@@ -6,11 +6,34 @@
    "source": [
     "# ML Sensitivity Indices\n",
     "\n",
-    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/iris.ipynb)\n",
     "\n",
     "This notebook demonstrates QMCPy's support for vectorized sensitivity index computation. We preview this functionality by performing classification of Iris species using a decision tree. The computed sensitivity indices provide insight into input subset importance for a classic machine learning problem."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/iris.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n",
+    "  !pip install -q scikit-learn scikit-optimize\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 2,
diff --git a/demos/korobov_hammersley_latinhypercube_demos.ipynb b/demos/korobov_hammersley_latinhypercube_demos.ipynb
index fbf654e81..aa902c86f 100644
--- a/demos/korobov_hammersley_latinhypercube_demos.ipynb
+++ b/demos/korobov_hammersley_latinhypercube_demos.ipynb
@@ -25,6 +25,31 @@
     "5. [Summary: which sampler should I use?](#summary)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/korobov_hammersley_latinhypercube_demos.ipynb)"
+   ],
+   "id": "5c5ba22f"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
+   ],
+   "id": "c01c8c05"
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -475,4 +500,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
\ No newline at end of file
+}
diff --git a/demos/lattice_random_generator.ipynb b/demos/lattice_random_generator.ipynb
index 849687b2e..824bb3be7 100644
--- a/demos/lattice_random_generator.ipynb
+++ b/demos/lattice_random_generator.ipynb
@@ -7,6 +7,29 @@
     "# Random Lattice Generators Are Not Bad\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/lattice_random_generator.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 16,
@@ -471,4 +494,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 2
-}
\ No newline at end of file
+}
diff --git a/demos/lebesgue_integration.ipynb b/demos/lebesgue_integration.ipynb
index f1c7f4617..4db928774 100644
--- a/demos/lebesgue_integration.ipynb
+++ b/demos/lebesgue_integration.ipynb
@@ -12,6 +12,22 @@
     "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/lebesgue_integration.ipynb)"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 26,
@@ -305,4 +321,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 2
-}
\ No newline at end of file
+}
diff --git a/demos/linear-scrambled-halton.ipynb b/demos/linear-scrambled-halton.ipynb
index 35a165963..4582cff1c 100644
--- a/demos/linear-scrambled-halton.ipynb
+++ b/demos/linear-scrambled-halton.ipynb
@@ -59,6 +59,29 @@
     "### Here we set up the QMCPY environment:"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/linear-scrambled-halton.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -544,4 +567,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 2
-}
\ No newline at end of file
+}
diff --git a/demos/nei_demo.ipynb b/demos/nei_demo.ipynb
index eecc346a7..28fca267b 100644
--- a/demos/nei_demo.ipynb
+++ b/demos/nei_demo.ipynb
@@ -9,6 +9,29 @@
     "You can also look at the Botorch implementation, but that requires a lot more understanding of code which involves Pytorch.  So we tried to put a simple example together here."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/nei_demo.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -413,7 +436,7 @@
     "\n",
     "    vals[mc_strat] = np.array(vals[mc_strat])\n",
     "#reference_answer = compute_qei(next_x, 'lattice', 2 ** 7 * max(num_posterior_draws_to_test))\n",
-    "reference_answer = compute_qei(next_x, 'lattice', 2 ** 20)"
+    "reference_answer = compute_qei(next_x, 'lattice', 2 ** 14 if IN_COLAB else 2 ** 20)"
    ]
   },
   {
@@ -476,4 +499,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 2
-}
\ No newline at end of file
+}
diff --git a/demos/plot_proj_function.ipynb b/demos/plot_proj_function.ipynb
index 941a8722d..0bf549cc8 100644
--- a/demos/plot_proj_function.ipynb
+++ b/demos/plot_proj_function.ipynb
@@ -26,6 +26,29 @@
     "### Here we set up the QMCPY environment enabling us to utilize this function:"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/plot_proj_function.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -403,4 +426,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 4
-}
\ No newline at end of file
+}
diff --git a/demos/pricing_options.ipynb b/demos/pricing_options.ipynb
index 9838717f3..f5b8a6ff6 100644
--- a/demos/pricing_options.ipynb
+++ b/demos/pricing_options.ipynb
@@ -11,6 +11,29 @@
     "- The option is only exercised at expiry, unlike American options, which can be exercised at any time before expiry.\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/pricing_options.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 36,
diff --git a/demos/product_measure.ipynb b/demos/product_measure.ipynb
index 29e1c14c2..72a9b4432 100644
--- a/demos/product_measure.ipynb
+++ b/demos/product_measure.ipynb
@@ -26,6 +26,31 @@
     "A single outer sampler generates points in $[0,1]^d$. `ProductMeasure` splits each point along the final coordinate axis, sends each block to the corresponding marginal transform, and concatenates the transformed blocks."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/product_measure.ipynb)"
+   ],
+   "id": "70fcf150"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
+   ],
+   "id": "6a14b189"
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
diff --git a/demos/qei-demo-for-blog.ipynb b/demos/qei-demo-for-blog.ipynb
index b2ca867e1..05015e345 100644
--- a/demos/qei-demo-for-blog.ipynb
+++ b/demos/qei-demo-for-blog.ipynb
@@ -7,6 +7,29 @@
     "# QEI (Q-Noisy Expected Improvement) Demo for Blog"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/qei-demo-for-blog.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
diff --git a/demos/qmcpy-logo.ipynb b/demos/qmcpy-logo.ipynb
index 57b5c6b4d..b8db4b7b0 100644
--- a/demos/qmcpy-logo.ipynb
+++ b/demos/qmcpy-logo.ipynb
@@ -10,6 +10,31 @@
     "Generate three lightweight scatter-plot logos from a two-dimensional randomized digital net, deterministic digital net, and lattice transformed to a zero-mean multivariate normal distribution with covariance `[[2, 1], [1, 3]]`. The deterministic net starts at index 1 because its origin maps to non-finite Gaussian coordinates."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/qmcpy-logo.ipynb)"
+   ],
+   "id": "45d7d128"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
+   ],
+   "id": "3204c240"
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
diff --git a/demos/qmcpy_intro.ipynb b/demos/qmcpy_intro.ipynb
index e1407623a..17960da7a 100644
--- a/demos/qmcpy_intro.ipynb
+++ b/demos/qmcpy_intro.ipynb
@@ -12,14 +12,30 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/qmcpy_intro.ipynb)"
+    "Here we show three different ways to import QMCPy in a Python environment. First, we can import the package `qmcpy` under the alias `qp`."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Here we show three different ways to import QMCPy in a Python environment. First, we can import the package `qmcpy` under the alias `qp`."
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/qmcpy_intro.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
    ]
   },
   {
diff --git a/demos/quickstart.ipynb b/demos/quickstart.ipynb
index 39b1eed31..55491b95f 100644
--- a/demos/quickstart.ipynb
+++ b/demos/quickstart.ipynb
@@ -12,13 +12,6 @@
     "In this tutorial, we introduce QMCPy [1]  by an example. QMCPy can be installed with **pip install qmcpy** or cloned from the  [QMCSoftware GitHub repository](https://github.com/QMCSoftware/QMCSoftware)."
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/quickstart.ipynb)"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {
@@ -36,6 +29,29 @@
     "The Keister function is implemented below with help from NumPy [3] in the following code snippet:"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/quickstart.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 4,
@@ -198,4 +214,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 1
-}
\ No newline at end of file
+}
diff --git a/demos/ray_tracing.ipynb b/demos/ray_tracing.ipynb
index 9cedb4f09..61294dadd 100644
--- a/demos/ray_tracing.ipynb
+++ b/demos/ray_tracing.ipynb
@@ -11,6 +11,29 @@
     "- [Ray Tracing: Graphics for the Masses by Paul Rademacher](https://dl.acm.org/doi/10.1145/270955.270962)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/ray_tracing.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 9,
diff --git a/demos/sample_scatter_plots.ipynb b/demos/sample_scatter_plots.ipynb
index 2e1c7baa5..ab5672311 100644
--- a/demos/sample_scatter_plots.ipynb
+++ b/demos/sample_scatter_plots.ipynb
@@ -7,6 +7,29 @@
     "# Scatter Plots of Samples"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/sample_scatter_plots.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 14,
diff --git a/demos/scipywrapper_dependence_custom/scipywrapper_demo.ipynb b/demos/scipywrapper_dependence_custom/scipywrapper_demo.ipynb
index 7e04d612f..b0cbdd3c3 100644
--- a/demos/scipywrapper_dependence_custom/scipywrapper_demo.ipynb
+++ b/demos/scipywrapper_dependence_custom/scipywrapper_demo.ipynb
@@ -10,6 +10,31 @@
     "This notebook demonstrates independent and dependent distribution support in `SciPyWrapper`, including custom marginals, joint transforms, and diagnostic checks for user-defined distributions."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/scipywrapper_dependence_custom/scipywrapper_demo.ipynb)"
+   ],
+   "id": "7aabd19e"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
+   ],
+   "id": "12896311"
+  },
   {
    "cell_type": "code",
    "execution_count": null,
diff --git a/demos/some_true_measures.ipynb b/demos/some_true_measures.ipynb
index 4784acf3c..eb2eddee1 100644
--- a/demos/some_true_measures.ipynb
+++ b/demos/some_true_measures.ipynb
@@ -57,6 +57,29 @@
     "## Imports"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/some_true_measures.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
diff --git a/demos/statistics_for_TrueMeasure.ipynb b/demos/statistics_for_TrueMeasure.ipynb
index 9627042c8..33ddcd0db 100644
--- a/demos/statistics_for_TrueMeasure.ipynb
+++ b/demos/statistics_for_TrueMeasure.ipynb
@@ -21,6 +21,31 @@
     "`Uniform` and `Kumaraswamy` have diagonal covariance matrices, so they store and return the covariance as a sparse `scipy.sparse` `dia_matrix`. This notebook densifies it with `to_dense_statistic` before building the comparison tables and plots."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/statistics_for_TrueMeasure.ipynb)"
+   ],
+   "id": "3a719fcf"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
+   ],
+   "id": "77388722"
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
diff --git a/demos/talk_paper_demos/JOSS2026/joss2026.ipynb b/demos/talk_paper_demos/JOSS2026/joss2026.ipynb
index df5e6e86a..15f4849ea 100644
--- a/demos/talk_paper_demos/JOSS2026/joss2026.ipynb
+++ b/demos/talk_paper_demos/JOSS2026/joss2026.ipynb
@@ -10,19 +10,38 @@
   },
   {
    "cell_type": "markdown",
-   "id": "a32d4c28",
+   "id": "e862347b",
    "metadata": {},
    "source": [
-    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/joss/demos/talk_paper_demos/JOSS2026/joss2026.ipynb)"
+    "## Setup"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "e862347b",
    "metadata": {},
    "source": [
-    "## Setup"
-   ]
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/JOSS2026/joss2026.ipynb)"
+   ],
+   "id": "32b4a6c5"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n",
+    "  !pip install -q seaborn tueplots\n",
+    "  !tmp=$(mktemp) && if { apt-get update -qq && DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends texlive-latex-base texlive-fonts-recommended texlive-latex-extra cm-super dvipng; } >\"$tmp\" 2>&1; then rm -f \"$tmp\"; else status=$?; cat \"$tmp\"; rm -f \"$tmp\"; exit $status; fi\n"
+   ],
+   "id": "754742b8"
   },
   {
    "cell_type": "code",
@@ -44,7 +63,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "ae0d77e0",
    "metadata": {},
    "outputs": [],
@@ -62,7 +81,7 @@
     "MARKERSIZE = 5\n",
     "OUTDIR = \"JOSS2026.outputs\"\n",
     "FIGWIDTH = 500/72\n",
-    "assert os.path.isdir(OUTDIR)"
+    "os.makedirs(OUTDIR, exist_ok=True)"
    ]
   },
   {
diff --git a/demos/talk_paper_demos/MCQMC_Tutorial_2020/MCQMC_2020_QMC_Software_Tutorial.ipynb b/demos/talk_paper_demos/MCQMC_Tutorial_2020/MCQMC_2020_QMC_Software_Tutorial.ipynb
index f58532cca..82136d126 100644
--- a/demos/talk_paper_demos/MCQMC_Tutorial_2020/MCQMC_2020_QMC_Software_Tutorial.ipynb
+++ b/demos/talk_paper_demos/MCQMC_Tutorial_2020/MCQMC_2020_QMC_Software_Tutorial.ipynb
@@ -63,6 +63,30 @@
         "QMCPy can be installed with ``pip install qmcpy`` or cloned from the  [QMCSoftware GitHub repository](https://github.com/QMCSoftware/QMCSoftware).  "
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/MCQMC_Tutorial_2020/MCQMC_2020_QMC_Software_Tutorial.ipynb)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# @title Execute this cell to install dependencies\n",
+        "try:\n",
+        "  import google.colab\n",
+        "  IN_COLAB = True\n",
+        "except ImportError:\n",
+        "  IN_COLAB = False\n",
+        "if IN_COLAB:\n",
+        "  !pip install -q qmcpy\n",
+        "  !pip install -q torch\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": 1,
@@ -616,7 +640,7 @@
         "ld = qmcpy.Lattice(64)  #define a discrete LD distribution\n",
         "print(ld)  #print the properties of the lattice object\n",
         "start_time = time.time()  #time now\n",
-        "points = ld.gen_samples(2**20)  #construct some points\n",
+        "points = ld.gen_samples(2**14 if IN_COLAB else 2**20)  #construct some points\n",
         "end_time = time.time()  #time after points are constructed\n",
         "print(f'\\nLD Points with shape {points.shape}\\n'+str(points))\n",
         "print(f'\\nTime to construct points is %.1e seconds'%(end_time - start_time))"
diff --git a/demos/talk_paper_demos/Parslfest_2025/01_sequential.ipynb b/demos/talk_paper_demos/Parslfest_2025/01_sequential.ipynb
index 3367a9ff2..8a10d76e3 100644
--- a/demos/talk_paper_demos/Parslfest_2025/01_sequential.ipynb
+++ b/demos/talk_paper_demos/Parslfest_2025/01_sequential.ipynb
@@ -23,6 +23,42 @@
     "Our presentation slides for ParslFest are available at [Figma](https://www.figma.com/slides/k7EUosssNluMihkYTLuh1F/Parsl-Testbook-Speedup?node-id=174-95&t=t3jENVMltXWwdLdb-0)."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "542c89c4",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Parslfest_2025/01_sequential.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1f2bf29e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  import sys\n",
+    "  import os\n",
+    "  repo_root = \"/content/QMCSoftware\"\n",
+    "  notebook_dir = f\"{repo_root}/demos/talk_paper_demos/Parslfest_2025\"\n",
+    "  if not os.path.isdir(repo_root):\n",
+    "    !git clone -q --depth 1 https://github.com/QMCSoftware/QMCSoftware {repo_root}\n",
+    "  # This notebook shells out to `make booktests_no_docker`, which needs the\n",
+    "  # full test toolchain (coverage via pytest-cov, testbook, etc.), not just qmcpy.\n",
+    "  !pip install -q \"qmcpy[test]\"\n",
+    "  os.chdir(notebook_dir)\n",
+    "  if notebook_dir not in sys.path:\n",
+    "    sys.path.insert(0, notebook_dir)\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -69,7 +105,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "efac7e90",
    "metadata": {},
    "outputs": [
@@ -87,7 +123,9 @@
    "source": [
     "out_path = os.path.join(output_dir, \"sequential_output.csv\")\n",
     "if (not os.path.exists(out_path)) or force_compute:\n",
-    "    run_make_command(\"booktests_no_docker\", out_path, is_debug=is_debug)"
+    "    succeeded = run_make_command(\"booktests_no_docker\", out_path, is_debug=is_debug)\n",
+    "    if not succeeded:\n",
+    "        print(f\"Warning: 'make booktests_no_docker' failed; see {out_path} for details.\")"
    ]
   },
   {
@@ -153,7 +191,7 @@
   "kernelspec": {
    "display_name": "qmcpy",
    "language": "python",
-   "name": "qmcpy"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -165,7 +203,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.12"
+   "version": "3.13.13"
   }
  },
  "nbformat": 4,
diff --git a/demos/talk_paper_demos/Parslfest_2025/02_parallel.ipynb b/demos/talk_paper_demos/Parslfest_2025/02_parallel.ipynb
index 8f8f6c3be..2c4249517 100644
--- a/demos/talk_paper_demos/Parslfest_2025/02_parallel.ipynb
+++ b/demos/talk_paper_demos/Parslfest_2025/02_parallel.ipynb
@@ -9,7 +9,6 @@
     "\n",
     "# [Accelerating QMCPy Notebook Tests with Parsl](https://www.figma.com/slides/k7EUosssNluMihkYTLuh1F/Parsl-Testbook-Speedup?node-id=1-37&t=WnKcu2QYO8JXvtpP-0)\n",
     "\n",
-    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Parslfest_2025/02_parallel.ipynb)\n",
     "\n",
     "Joshua Herman, Brandon Sharp, and Sou-Cheng Choi, QMCPy Developers\n",
     "\n",
@@ -24,6 +23,42 @@
     "* Parsl: `pip install parsl==2025.7.28`"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "0a00e53c",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Parslfest_2025/02_parallel.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2a4b48ad",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  import sys\n",
+    "  import os\n",
+    "  repo_root = \"/content/QMCSoftware\"\n",
+    "  notebook_dir = f\"{repo_root}/demos/talk_paper_demos/Parslfest_2025\"\n",
+    "  if not os.path.isdir(repo_root):\n",
+    "    !git clone -q --depth 1 https://github.com/QMCSoftware/QMCSoftware {repo_root}\n",
+    "  # This notebook shells out to `make booktests_parallel_no_docker`, which needs\n",
+    "  # the full test toolchain (coverage via pytest-cov, testbook, parsl, etc.), not just qmcpy.\n",
+    "  !pip install -q \"qmcpy[test]\"\n",
+    "  os.chdir(notebook_dir)\n",
+    "  if notebook_dir not in sys.path:\n",
+    "    sys.path.insert(0, notebook_dir)\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -204,7 +239,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "id": "6bfa7a6b",
    "metadata": {},
    "outputs": [
@@ -234,8 +269,10 @@
     "if (not os.path.exists(par_fname)) or force_compute:\n",
     "    env = os.environ.copy()\n",
     "    env['PARSL_MAX_WORKERS'] = str(max_workers)\n",
-    "    run_make_command(\"booktests_parallel_no_docker\", par_output, is_debug=is_debug, env=env)\n",
-    "    \n",
+    "    succeeded = run_make_command(\"booktests_parallel_no_docker\", par_output, is_debug=is_debug, env=env)\n",
+    "    if not succeeded:\n",
+    "        print(f\"Warning: 'make booktests_parallel_no_docker' failed; see {par_output} for details.\")\n",
+    "\n",
     "    parallel_time = parse_total_time(par_output, r\"Total test time: ([\\d\\.]+)s\")\n",
     "    print(f\"\\n=== RESULTS FOR EXECUTION {execution_id} ===\")\n",
     "    print(f\"Parallel time: {parallel_time:.2f} seconds\")\n",
diff --git a/demos/talk_paper_demos/Parslfest_2025/03_visualize_speedup.ipynb b/demos/talk_paper_demos/Parslfest_2025/03_visualize_speedup.ipynb
index 6e50f0b4f..bffaf1ff9 100644
--- a/demos/talk_paper_demos/Parslfest_2025/03_visualize_speedup.ipynb
+++ b/demos/talk_paper_demos/Parslfest_2025/03_visualize_speedup.ipynb
@@ -1,5 +1,39 @@
 {
  "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Parslfest_2025/03_visualize_speedup.ipynb)"
+   ],
+   "id": "54f401f5"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  import sys\n",
+    "  import os\n",
+    "  repo_root = \"/content/QMCSoftware\"\n",
+    "  notebook_dir = f\"{repo_root}/demos/talk_paper_demos/Parslfest_2025\"\n",
+    "  if not os.path.isdir(repo_root):\n",
+    "    !git clone -q --depth 1 https://github.com/QMCSoftware/QMCSoftware {repo_root}\n",
+    "  !pip install -q qmcpy\n",
+    "  os.chdir(notebook_dir)\n",
+    "  if notebook_dir not in sys.path:\n",
+    "    sys.path.insert(0, notebook_dir)\n"
+   ],
+   "id": "28712456"
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
diff --git a/demos/talk_paper_demos/Parslfest_2025/output/01_sequential_output.ipynb b/demos/talk_paper_demos/Parslfest_2025/output/01_sequential_output.ipynb
index 14b2f7d33..2389cc644 100644
--- a/demos/talk_paper_demos/Parslfest_2025/output/01_sequential_output.ipynb
+++ b/demos/talk_paper_demos/Parslfest_2025/output/01_sequential_output.ipynb
@@ -23,6 +23,43 @@
     "Our presentation slides for ParslFest are available at [Figma](https://www.figma.com/slides/k7EUosssNluMihkYTLuh1F/Parsl-Testbook-Speedup?node-id=174-95&t=t3jENVMltXWwdLdb-0)."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Parslfest_2025/output/01_sequential_output.ipynb)"
+   ],
+   "id": "13703ae3"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  import sys\n",
+    "  import os\n",
+    "  repo_root = \"/content/QMCSoftware\"\n",
+    "  notebook_dir = f\"{repo_root}/demos/talk_paper_demos/Parslfest_2025/output\"\n",
+    "  if not os.path.isdir(repo_root):\n",
+    "    !git clone -q --depth 1 https://github.com/QMCSoftware/QMCSoftware {repo_root}\n",
+    "  !pip install -q qmcpy\n",
+    "  os.chdir(notebook_dir)\n",
+    "  if notebook_dir not in sys.path:\n",
+    "    sys.path.insert(0, notebook_dir)\n",
+    "  extra_path = f\"{repo_root}/demos/talk_paper_demos/Parslfest_2025\"\n",
+    "  if extra_path not in sys.path:\n",
+    "    sys.path.insert(0, extra_path)\n"
+   ],
+   "id": "ff1f3561"
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
diff --git a/demos/talk_paper_demos/Parslfest_2025/util.py b/demos/talk_paper_demos/Parslfest_2025/util.py
index b9a941623..88b4673ac 100644
--- a/demos/talk_paper_demos/Parslfest_2025/util.py
+++ b/demos/talk_paper_demos/Parslfest_2025/util.py
@@ -64,7 +64,7 @@ def run_make_command(cmd, output_file, is_debug=False, tests=None, env=None):
     Returns:
         bool: True if command succeeded
     """
-    is_linux = sys.platform.startswith("Linux")
+    is_linux = sys.platform.startswith("linux")
 
     if tests is None and is_debug:
         tests = "tb_quickstart tb_qmcpy_intro tb_lattice_random_generator"
diff --git a/demos/talk_paper_demos/SorokinThesis2025/sorokin_thesis_2025.ipynb b/demos/talk_paper_demos/SorokinThesis2025/sorokin_thesis_2025.ipynb
index 8e115eb62..95e13d4fe 100644
--- a/demos/talk_paper_demos/SorokinThesis2025/sorokin_thesis_2025.ipynb
+++ b/demos/talk_paper_demos/SorokinThesis2025/sorokin_thesis_2025.ipynb
@@ -9,6 +9,29 @@
     "https://www.arxiv.org/abs/2511.21915"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/SorokinThesis2025/sorokin_thesis_2025.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -1088,4 +1111,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 4
-}
\ No newline at end of file
+}
diff --git a/demos/talk_paper_demos/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026.ipynb b/demos/talk_paper_demos/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026.ipynb
index a3c3db549..78a468ba2 100644
--- a/demos/talk_paper_demos/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026.ipynb
+++ b/demos/talk_paper_demos/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026.ipynb
@@ -14,6 +14,31 @@
     "## Setup"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n",
+    "  !pip install -q sympy torch tueplots\n",
+    "  !tmp=$(mktemp) && if { apt-get update -qq && DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends texlive-latex-base texlive-fonts-recommended texlive-latex-extra cm-super dvipng; } >\"$tmp\" 2>&1; then rm -f \"$tmp\"; else status=$?; cat \"$tmp\"; rm -f \"$tmp\"; exit $status; fi\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -35,7 +60,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -54,7 +79,8 @@
     "COLORS = palettes.tue_plot\n",
     "MARKERS = markers.o_sized\n",
     "pyplot.rcParams.update(probnum2025())\n",
-    "pyplot.rcParams.update(cycler.cycler(color=COLORS,marker=MARKERS))"
+    "pyplot.rcParams.update(cycler.cycler(color=COLORS,marker=MARKERS))\n",
+    "os.makedirs(\"outputs\", exist_ok=True)"
    ]
   },
   {
diff --git a/demos/talk_paper_demos/pydata_chi_2023.ipynb b/demos/talk_paper_demos/pydata_chi_2023.ipynb
index c863016a2..4be7e706f 100644
--- a/demos/talk_paper_demos/pydata_chi_2023.ipynb
+++ b/demos/talk_paper_demos/pydata_chi_2023.ipynb
@@ -31,6 +31,31 @@
     "## Python Setup"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/pydata_chi_2023.ipynb)"
+   ],
+   "id": "31df2e6e"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
+   ],
+   "id": "f8b903bf"
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -1573,4 +1598,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
\ No newline at end of file
+}
diff --git a/demos/talk_paper_demos/why_add_q_to_mc_blog/why_add_q_to_mc_blog.ipynb b/demos/talk_paper_demos/why_add_q_to_mc_blog/why_add_q_to_mc_blog.ipynb
index 8e90d5a0c..d62ff27f0 100644
--- a/demos/talk_paper_demos/why_add_q_to_mc_blog/why_add_q_to_mc_blog.ipynb
+++ b/demos/talk_paper_demos/why_add_q_to_mc_blog/why_add_q_to_mc_blog.ipynb
@@ -1,5 +1,30 @@
 {
  "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/why_add_q_to_mc_blog/why_add_q_to_mc_blog.ipynb)"
+   ],
+   "id": "2a8b11ef"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n"
+   ],
+   "id": "1792a809"
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
diff --git a/demos/vectorized_qmc.ipynb b/demos/vectorized_qmc.ipynb
index 11d17a57c..0ab7d522d 100644
--- a/demos/vectorized_qmc.ipynb
+++ b/demos/vectorized_qmc.ipynb
@@ -12,14 +12,30 @@
     },
     {
       "cell_type": "markdown",
-      "id": "6df4c2a4-92ec-437e-80a1-28a82ea6544b",
-      "metadata": {
-        "id": "6df4c2a4-92ec-437e-80a1-28a82ea6544b"
-      },
+      "id": "f696f50e",
+      "metadata": {},
       "source": [
         "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/vectorized_qmc.ipynb)"
       ]
     },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "c318b211",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# @title Execute this cell to install dependencies\n",
+        "try:\n",
+        "  import google.colab\n",
+        "  IN_COLAB = True\n",
+        "except ImportError:\n",
+        "  IN_COLAB = False\n",
+        "if IN_COLAB:\n",
+        "  !pip install -q qmcpy\n",
+        "  !tmp=$(mktemp) && if { apt-get update -qq && DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends texlive-latex-base texlive-fonts-recommended texlive-latex-extra cm-super dvipng; } >\"$tmp\" 2>&1; then rm -f \"$tmp\"; else status=$?; cat \"$tmp\"; rm -f \"$tmp\"; exit $status; fi\n"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": null,
@@ -29,23 +45,13 @@
       },
       "outputs": [],
       "source": [
-        "%%capture\n",
-        "# @title Execute this cell to install dependancies\n",
-        "try:\n",
-        "  import google.colab\n",
-        "  import os\n",
-        "  !pip install -q qmcpy >> /dev/null\n",
-        "  !apt-get update && apt-get install -y --no-install-recommends texlive-latex-base texlive-fonts-recommended texlive-latex-extra cm-super dvipng\n",
-        "except:\n",
-        "  pass\n",
-        "\n",
         "import matplotlib.pyplot as plt\n",
         "\n",
         "plt.rcParams.update({\n",
         "\"text.usetex\": True,\n",
         "\"font.family\": \"serif\",\n",
         "\"text.latex.preamble\": r\"\\usepackage{amsmath}\\usepackage{amssymb}\\newcommand{\\bx}{\\boldsymbol{x}}\"\n",
-        "})"
+        "})\n"
       ]
     },
     {
diff --git a/demos/vectorized_qmc_bayes.ipynb b/demos/vectorized_qmc_bayes.ipynb
index bcb095ef2..2b4ac95be 100644
--- a/demos/vectorized_qmc_bayes.ipynb
+++ b/demos/vectorized_qmc_bayes.ipynb
@@ -12,7 +12,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "a306d01c-390a-4bb3-a2aa-b79f4c800d95",
+   "id": "e593c419",
    "metadata": {},
    "source": [
     "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/vectorized_qmc_bayes.ipynb)"
@@ -20,7 +20,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
+   "id": "cc63050b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy\n",
+    "  !pip install -q scikit-learn\n",
+    "  !tmp=$(mktemp) && if { apt-get update -qq && DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends texlive-latex-base texlive-fonts-recommended texlive-latex-extra cm-super dvipng; } >\"$tmp\" 2>&1; then rm -f \"$tmp\"; else status=$?; cat \"$tmp\"; rm -f \"$tmp\"; exit $status; fi\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
    "id": "7cb5370c-b821-45a0-b0ea-5fa311690954",
    "metadata": {
     "colab": {
@@ -31,24 +50,13 @@
    },
    "outputs": [],
    "source": [
-    "%%capture\n",
-    "# @title Execute this cell to install dependancies\n",
-    "try:\n",
-    "  import google.colab\n",
-    "  import os\n",
-    "  !pip install -q qmcpy >> /dev/null\n",
-    "  !apt-get update && apt-get install -y --no-install-recommends texlive-latex-base texlive-fonts-recommended texlive-latex-extra cm-super dvipng\n",
-    "except:\n",
-    "  pass\n",
-    "\n",
     "import matplotlib.pyplot as plt\n",
     "\n",
     "plt.rcParams.update({\n",
     "\"text.usetex\": True,\n",
     "\"font.family\": \"serif\",\n",
     "\"text.latex.preamble\": r\"\\usepackage{amsmath}\\usepackage{amssymb}\\newcommand{\\bx}{\\boldsymbol{x}}\"\n",
-    "})\n",
-    "!pip install scikit-learn\n"
+    "})\n"
    ]
   },
   {
diff --git a/docs/ci-testing.md b/docs/ci-testing.md
index 5f33765b4..97956fdb0 100644
--- a/docs/ci-testing.md
+++ b/docs/ci-testing.md
@@ -6,9 +6,11 @@ This page summarizes QMCPy's current GitHub Actions CI layout.
 
 | Workflow | Trigger | Runner / Python | Main work |
 |---|---|---|---|
-| `alltests.yml` | Feature-branch `push` | `ubuntu`, Python `3.13` | <ul><li>Non-Docker doctests</li><li>`unittests`</li><li>Coverage upload</li></ul> |
-| `alltests.yml` | `push` to `develop` or `master`; PR into `develop` or `master`; `workflow_dispatch` | `ubuntu`, `macos`, `windows`; Python `3.13` | <ul><li>Doctests</li><li>`unittests`</li><li>Coverage upload</li><li>Booktests</li><li>Linux-only UMBridge doctests when Docker is available</li></ul> |
-| `unittests.yml` | `push` to `develop` or `master`; PR into `develop` or `master`; `workflow_dispatch` | `ubuntu`, `macos`, `windows`; Python `3.5` to `3.14` | <ul><li>Install test and optional extras</li><li>Run `unittests`</li></ul> |
+| `alltests.yml` | Feature-branch `push` | `ubuntu`, Python `3.13` | <ul><li>Non-Docker doctests</li><li>MPMC doctests and unit tests (Ubuntu only)</li><li>`unittests`</li><li>Coverage upload</li></ul> |
+| `alltests.yml` | `push` to `develop` or `master`; PR into `develop` or `master`; branch name ending in `choi`; `workflow_dispatch` | `ubuntu`, `macos`, `windows`; Python `3.13` | <ul><li>Doctests</li><li>MPMC doctests and unit tests on all three OSes</li><li>`unittests`</li><li>Coverage upload</li><li>Booktests</li><li>Linux-only UMBridge doctests when Docker is available</li></ul> |
+| `unittests.yml` (`tests` job) | `push` to `develop` or `master`; PR into `develop` or `master`; `workflow_dispatch` | `ubuntu`, `macos`, `windows`; Python `3.10` to `3.14` | <ul><li>Install test and optional extras</li><li>Run `unittests`</li><li>No MPMC stack installed, so MPMC unit tests skip</li></ul> |
+| `unittests.yml` (`core-tests` job) | same as above | `ubuntu`, `macos`, `windows`; Python `3.9` | <ul><li>Build and install the no-extra user wheel, check dependencies, and import outside the source tree</li><li>Install `test_core`, then run `unittests_core` (no booktests)</li><li>Blocking test of the declared support-policy floor, on every supported OS</li></ul> |
+| `unittests.yml` (`prerelease-tests` job) | same as above | `ubuntu`; Python `3.15.0-rc.1` | <ul><li>Uses `actions/setup-python` with `allow-prereleases` (conda-forge has no 3.15)</li><li>Install `test_core`, run `unittests_core`</li><li>Non-blocking: expected to fail until `scipy` and `scikit-learn` ship cp315 wheels</li></ul> |
 | `docs.yml` | `push` to `master` | `ubuntu`, Python `3.13` | <ul><li>`uml`</li><li>`copydocs`</li><li>`mkdocs gh-deploy --force`</li></ul> |
 | `pep8.yml` | `push` to `develop` or `master`; `workflow_dispatch` | `ubuntu`, Python `3.13` | <ul><li>`check_pep8`</li><li>Open a badge-update pull request if badge assets change</li></ul> |
 | `pypi-stats.yml` | Weekly schedule; `workflow_dispatch` | `ubuntu`, Python `3.13` | <ul><li>Regenerate PyPI download statistics</li><li>Publish updated files</li></ul> |
@@ -18,13 +20,29 @@ There is no nightly CI schedule.
 ## Policy
 
 - Linux is the default feedback path and runs on every push.
-- macOS and Windows in `alltests.yml` are reserved for `develop`/`master` pushes, pull requests into those branches, and manual runs.
+- macOS and Windows in `alltests.yml` are reserved for `develop`/`master` pushes, pull requests into those branches, branches whose name ends in `choi`, and manual runs.
 - `concurrency` cancels superseded runs in both workflows; in `alltests.yml`, `push` and `pull_request` use separate groups so a PR does not inherit cancelled sibling checks from a same-SHA push.
-- `alltests.yml` pins Miniconda base Python to `3.13`; `unittests.yml` still uses the base environment without explicitly passing `matrix.python-version` into `setup-miniconda`.
+- Both `unittests.yml` and `alltests.yml` pass `matrix.python-version` to `setup-miniconda` and assert the running interpreter before any test runs, so their version labels are real. Steps that touch Python use a profile-loading shell (`bash -el {0}` on Unix, `pwsh` on Windows); the default non-login shell silently falls back to the conda base interpreter, which is how these matrices previously went green without testing the versions they named.
 - Booktests are skipped on feature-branch pushes and run only in the full sweep.
+- `unittests.yml` is tiered: `tests` installs the full `test` extra (needing Python `3.10`+ via `pytest >= 9.0.3` and `parsl >= 2026.01.05`), `core-tests` verifies the built no-extra wheel before installing the slim `test_core` extra, and `prerelease-tests` looks ahead to the next interpreter. Test modules self-skip through `pytest.importorskip` when an optional stack is missing.
+- The pre-release tier is informational and never gates a merge. Promote a version out of it into the `tests` matrix once the job passes; `Programming Language :: Python :: 3.15` is deliberately **not** in `pyproject.toml` classifiers until then.
 - UMBridge doctests run only on Linux full sweeps with Docker available.
+- MPMC steps in `alltests.yml` are **not** OS-gated: they run on every OS the matrix selects. See [MPMC Coverage by OS](#mpmc-coverage-by-os).
 - `workflow_dispatch` means manually triggered workflow.
 
+## MPMC Coverage by OS
+
+MPMC needs a platform-specific `pyg_lib` wheel that PyPI does not carry, installed separately by `qmcpy-install-mpmc`. Only `alltests.yml` does that, and its MPMC steps carry no `if: runner.os` condition, so they run on every OS the matrix selects.
+
+| Workflow / trigger | Python | Ubuntu | macOS | Windows |
+|---|---|---|---|---|
+| `alltests.yml`, full sweep | `3.13` | Run | Run | Run |
+| `alltests.yml`, feature-branch `push` | `3.13` | Run | Not in matrix | Not in matrix |
+| `unittests.yml` (`tests`) | `3.10`-`3.14` | Skipped | Skipped | Skipped |
+| `unittests.yml` (`core-tests`) | `3.9` | Skipped | Skipped | Skipped |
+
+"Run" covers both the MPMC doctests (`make doctests_mpmc`) and the MPMC unit tests in `test/test_dd_mpmc.py`. `unittests.yml` never calls `qmcpy-install-mpmc`, so those tests skip there via `pytest.importorskip("pyg_lib")` and its jobs pass without exercising MPMC — treat `alltests.yml` as the only source of MPMC signal. See [mpmc-compatibility.md](mpmc-compatibility.md) for the version-support policy behind this split.
+
 ## Related Docs
 
 - [tests.md](tests.md): local Makefile targets and coverage commands.
diff --git a/docs/mpmc-compatibility.md b/docs/mpmc-compatibility.md
index 4e9bbf424..ebe1939c9 100644
--- a/docs/mpmc-compatibility.md
+++ b/docs/mpmc-compatibility.md
@@ -7,7 +7,7 @@
 - Treat MPMC as an optional feature, not part of the minimum QMCPy dependency set.
 - Prefer `pyg_lib` plus `torch-geometric`; do not require `torch-cluster` as a separate dependency.
 - For reproducible local work and future CI pinning, prefer a modern PyTorch line with matching `data.pyg.org` wheels installed by `qmcpy-install-mpmc`.
-- Keep older Python jobs in `unittests.yml` for core QMCPy coverage, but do not require them to run MPMC.
+- `unittests.yml` runs the full suite on `3.10`-`3.14` plus a slim `core-tests` tier on `3.9` (see [Minimum Python Version by Role](CONTRIBUTING.md#minimum-python-version-by-role)); neither installs MPMC.
 
 ## Support Policy
 
@@ -17,7 +17,8 @@
 | `3.13` | Target | Supported | `torch >= 2.10`, `torch-geometric >= 2.6.1`, `pyg_lib >= 0.6.0` | Run MPMC doctests and unit tests |
 | `3.12` | Target | Supported | `torch >= 2.10`, `torch-geometric >= 2.6.1`, `pyg_lib >= 0.6.0` | Run MPMC doctests and unit tests |
 | `3.10` to `3.11` | Best effort | Not a release blocker for MPMC | May work with matching PyTorch / PyG wheels, but not required by current CI policy | Optional manual testing only |
-| `3.5` to `3.9` | Legacy core-package coverage only | Not supported for MPMC | Do not spend CI budget trying to keep MPMC running here | No MPMC doctests or unit tests |
+
+Python `3.9` is covered only by the slim `core-tests` tier, which never installs MPMC's PyTorch Geometric stack (see [Minimum Python Version by Role](CONTRIBUTING.md#minimum-python-version-by-role)).
 
 The distinction is intentional:
 
@@ -26,13 +27,14 @@ The distinction is intentional:
 
 ## CI Policy
 
-The current CI split should be:
+The current CI split is:
+
+- `alltests.yml`: the only workflow that installs the MPMC stack (`qmcpy-install-mpmc`) and runs `make doctests_mpmc` plus the MPMC unit tests, on Python `3.13`. The steps are not OS-gated: Ubuntu alone on feature-branch pushes, all three OSes on full sweeps.
+- `unittests.yml`: `3.10`-`3.14` on all three OSes, plus a `core-tests` tier on Ubuntu for `3.9`. Neither calls `qmcpy-install-mpmc`, so `test/test_dd_mpmc.py` skips throughout via `pytest.importorskip("pyg_lib")`. This workflow gives **no** MPMC coverage.
 
-- `alltests.yml`: full-sweep validation on Linux, macOS, and Windows for Python `3.13`, including `make doctests_mpmc` and the standard unit-test suite.
-- `unittests.yml`: a broader version sampler for the repository, with explicit MPMC jobs on Python `3.12`, `3.13`, and `3.14`.
-- Older `unittests.yml` jobs: keep them for core QMCPy regressions, but do not require MPMC there.
+See [MPMC Coverage by OS](ci-testing.md#mpmc-coverage-by-os) for the per-operating-system breakdown.
 
-This gives one place to enforce modern MPMC compatibility without forcing the entire repository to abandon older Python jobs immediately.
+This keeps MPMC enforcement in one place. The trade-off: MPMC regressions are invisible to `unittests.yml`, so raising MPMC coverage means adding a job to `alltests.yml`, not widening the `unittests.yml` matrix.
 
 ## Local Developer Commands
 
diff --git a/docs/tests.md b/docs/tests.md
index 73fb226be..bdb612e31 100644
--- a/docs/tests.md
+++ b/docs/tests.md
@@ -14,6 +14,13 @@ This document describes the available test targets in the Makefile for QMCSoftwa
 | `make doctests` | All doctests with Docker | Slow | Full docstring validation |
 | `make booktests_no_docker` | Jupyter notebook tests | Slow | Validate demo notebooks |
 | `make booktests_parallel_no_docker` | Notebook tests with Parsl parallelization | Variable | Distributed notebook execution |
+| `make check_colab_notebooks` | Audit enabled notebooks for Colab-readiness | Fast | Catch missing pip installs, repo-local imports, and source-install drift |
+| `make check_colab_notebooks_smoke` | Execute Colab notebook setup smoke tests | Fast | Run bootstrap plus early import/setup cells for enabled notebooks |
+| `make harden_colab_notebook [NOTEBOOK=...]` | Insert Colab bootstrap and classify notebook(s) | Fast | Harden one notebook, or attempt to harden unclassified demo notebooks |
+| `make report_colab_notebook_patterns` | Group notebooks by Colab bootstrap family | Fast | Audit which notebooks use basic, extra-pip, LaTeX, or repo-local setup cells |
+| `make open_colab_notebook NOTEBOOK=...` | Open a notebook in Colab from the current branch | Fast | Preview branch-only notebook changes in Colab before merge |
+| `make open_colab_notebook_gist NOTEBOOK=...` | Upload the working-tree notebook to a secret gist and open it in Colab | Fast | Preview uncommitted notebook edits in Colab (needs `gh`) |
+| `make open_notebook NOTEBOOK=...` | Open the working-tree notebook in local JupyterLab | Instant | Edit/run a demo notebook locally with full repo context |
 | `make coverage` | Display coverage report | Instant | View test coverage summary |
 | `make delcoverage` | Reset coverage tracking | Instant | Start fresh coverage analysis |
 
@@ -188,12 +195,6 @@ Runs notebook tests with **Parsl distributed parallelization** for compute-heavy
 - **Dependencies**: Parsl must be installed and configured
 - **Use when**: Running large notebook suites with distributed compute resources
 
-#### `make tests_parallel_no_docker`
-Runs only unit tests with parallel pytest workers (no doctests or booktests).
-- **Time**: ~13–20 seconds
-- **Coverage**: Incremental
-- **Use when**: Testing unit tests only in parallel mode
-
 ---
 
 ### Helper / Internal Targets
@@ -208,6 +209,72 @@ Auto-generates missing test stub files for notebooks.
 - **Output**: Reports any generated files
 - **Note**: Called automatically by `booktests_no_docker`; rarely used standalone
 
+#### `make check_colab_notebooks`
+Runs the strict static Colab-readiness checks.
+- **Behavior**: Validates the manifest, badge and bootstrap placement, early dependencies, and repo-local imports
+- **Use when**: You change a demo notebook or its Colab setup
+
+#### `make check_colab_notebooks_smoke`
+Runs a lightweight execution smoke test for each Colab-enabled notebook.
+- **Execution scope**: Simulates a Colab runtime, rewrites shell install commands to no-ops, then executes the bootstrap cell plus up to `$(SMOKE_CODE_CELLS)` smoke-safe import/setup code cells
+- **Purpose**: Catch runtime regressions in early import/setup logic that static checks miss
+- **CI usage**: Invoked in Linux CI after test dependencies are installed
+- **Default depth**: `SMOKE_CODE_CELLS=2`
+
+#### `make harden_colab_notebook [NOTEBOOK=...]`
+Hardens one notebook, or if `NOTEBOOK` is omitted, scans `demos/` for notebooks that are not yet listed in either `enabled` or `disabled`.
+- **What it does**: Inserts the badge, adds a generated Colab bootstrap cell, infers common extra pip dependencies, and adds repo-local `sys.path` setup when needed
+- **Classification rule**: Existing `disabled` entries are left untouched; unclassified notebooks are added to `enabled` only after hardening validates. Failures remain unclassified for manual review
+- **Force mode**: `make harden_colab_notebook FORCE=1` regenerates the Open in Colab badge and the `# @title Execute this cell to install dependencies` cell for every notebook already listed in `enabled`; `make harden_colab_notebook NOTEBOOK=... FORCE=1` does the same for one notebook
+- **Cell order**: The generated `import google.colab` bootstrap cell is always inserted after the Open in Colab badge
+- **Validation**: Runs the existing Colab checks after rewriting; if validation fails, the notebook and manifest are restored and the failure is reported
+- **Examples**: `make harden_colab_notebook NOTEBOOK=demos/plot_proj_function.ipynb`, `make harden_colab_notebook`, and `make harden_colab_notebook FORCE=1`
+
+#### `make report_colab_notebook_patterns`
+Groups notebooks already classified in `scripts/colab_notebooks_manifest.json` by the current Colab badge/bootstrap cell pattern.
+- **Pattern families**: Reports basic `qmcpy`-only bootstrap cells, extra-pip variants, LaTeX setup cells, repo-clone/path-setup cells, and disabled notebooks grouped by reason
+- **Dependency details**: Lists extra install commands for notebooks that need more than `qmcpy`
+- **Placement summary**: Reports where the badge and bootstrap cells appear, for example `badge cell 1, bootstrap cell 2`
+- **Use when**: You want to batch-normalize notebook Colab setup or review which notebooks will be affected by bootstrap changes
+
+Every enabled notebook, grouped by its Colab bootstrap pattern family (regenerate with `make report_colab_notebook_patterns`):
+
+- **Basic qmcpy bootstrap** (28): [acceptance_rejection.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/acceptance_rejection.ipynb), [asian-option-mlqmc.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/asian-option-mlqmc.ipynb), [brownian_bridge.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/brownian_bridge.ipynb), [control_variates.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/control_variates.ipynb), [copula_examples.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/copula_examples.ipynb), [Iteration_Log_Tolerance_Demo.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/demo_resume_data/Iteration_Log_Tolerance_Demo.ipynb), [digital_net_b2.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/digital_net_b2.ipynb), [gaussian_diagnostics_demo.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/gaussian_diagnostics/gaussian_diagnostics_demo.ipynb), [korobov_hammersley_latinhypercube_demos.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/korobov_hammersley_latinhypercube_demos.ipynb), [lattice_random_generator.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/lattice_random_generator.ipynb), [lebesgue_integration.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/lebesgue_integration.ipynb), [linear-scrambled-halton.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/linear-scrambled-halton.ipynb), [nei_demo.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/nei_demo.ipynb), [plot_proj_function.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/plot_proj_function.ipynb), [pricing_options.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/pricing_options.ipynb), [product_measure.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/product_measure.ipynb), [qei-demo-for-blog.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/qei-demo-for-blog.ipynb), [qmcpy-logo.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/qmcpy-logo.ipynb), [qmcpy_intro.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/qmcpy_intro.ipynb), [quickstart.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/quickstart.ipynb), [ray_tracing.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/ray_tracing.ipynb), [sample_scatter_plots.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/sample_scatter_plots.ipynb), [scipywrapper_demo.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/scipywrapper_dependence_custom/scipywrapper_demo.ipynb), [some_true_measures.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/some_true_measures.ipynb), [statistics_for_TrueMeasure.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/statistics_for_TrueMeasure.ipynb), [sorokin_thesis_2025.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/SorokinThesis2025/sorokin_thesis_2025.ipynb), [pydata_chi_2023.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/pydata_chi_2023.ipynb), [why_add_q_to_mc_blog.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/why_add_q_to_mc_blog/why_add_q_to_mc_blog.ipynb)
+- **Extra pip bootstrap** (4): [iris.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/iris.ipynb), [joss2026.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/JOSS2026/joss2026.ipynb), [MCQMC_2020_QMC_Software_Tutorial.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/MCQMC_Tutorial_2020/MCQMC_2020_QMC_Software_Tutorial.ipynb), [Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026.ipynb)
+- **LaTeX bootstrap** (4): [dakota_genz.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/DAKOTA_Genz/dakota_genz.ipynb), [elliptic-pde.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/elliptic-pde.ipynb), [vectorized_qmc.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/vectorized_qmc.ipynb), [vectorized_qmc_bayes.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/vectorized_qmc_bayes.ipynb)
+- **Repo-local bootstrap** (7): [gbm_examples.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/GBM/gbm_examples.ipynb), [accuracy_and_resume.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/demo_resume_data/accuracy_and_resume.ipynb), [resume_examples.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/demo_resume_data/resume_examples.ipynb), [01_sequential.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Parslfest_2025/01_sequential.ipynb), [02_parallel.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Parslfest_2025/02_parallel.ipynb), [03_visualize_speedup.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Parslfest_2025/03_visualize_speedup.ipynb), [01_sequential_output.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Parslfest_2025/output/01_sequential_output.ipynb)
+- **Repo-local bootstrap + extra pip installs** (1): [gbm_demo.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/GBM/gbm_demo.ipynb)
+
+### Opening a demo notebook
+
+| Target | Notebook source | Opens in | Requires |
+|--------|-----------------|----------|----------|
+| `make open_notebook` | working tree | local JupyterLab | `jupyterlab` |
+| `make open_colab_notebook` | `origin/<branch>` (or `<base>` when unchanged) | Google Colab | branch + notebook pushed to `origin` |
+| `make open_colab_notebook_gist` | working tree | Google Colab | `gh` CLI |
+
+#### `make open_colab_notebook NOTEBOOK=demos/<path>.ipynb`
+Opens a demo notebook in Google Colab from the **current git branch** instead of the committed `develop` badge URL, so you can preview branch-only notebook changes in Colab before they merge.
+- **When it uses the branch**: The Colab link points at the current branch when the notebook is new on the branch, or when its content on `origin/<branch>` differs from `origin/<base>`; otherwise it opens the `<base>` version, since the committed badge already covers that case
+- **Requires a push**: Colab loads notebooks from GitHub, so the branch and the notebook must already be pushed to `origin`; the target stops with a hint if they are not, and warns when your local working copy differs from what is pushed
+- **Base branch**: The comparison base is `COLAB_BASE` (default `develop`) and must itself be a branch on `origin`
+- **Output**: Prints the `https://colab.research.google.com/github/<owner>/<repo>/blob/<ref>/<path>` URL and opens it with `python -m webbrowser`
+- **Examples**: `make open_colab_notebook NOTEBOOK=demos/nei_demo.ipynb`, `make open_colab_notebook NOTEBOOK=demos/GBM/gbm_demo.ipynb COLAB_BASE=master`
+
+#### `make open_colab_notebook_gist NOTEBOOK=demos/<path>.ipynb`
+Uploads the **working-tree** copy of a notebook to a throwaway secret GitHub gist and opens that gist in Colab, so you can preview uncommitted edits without pushing to a branch.
+- **Requires**: The [`gh` CLI](https://cli.github.com), authenticated with `gh auth login`
+- **What it prints**: The gist URL, the `https://colab.research.google.com/gist/<login>/<id>/<file>` URL (also opened with `python -m webbrowser`), and the `gh gist delete <id>` cleanup command
+- **Gist visibility**: "secret" means unlisted, not private; delete it when finished
+- **Limitation**: A gist is a single file, so sibling `.py` helpers and repo-local imports will not resolve; the bootstrap cell's `git clone` falls back to `develop`. Use `make open_colab_notebook` for notebooks that depend on repo files
+- **Example**: `make open_colab_notebook_gist NOTEBOOK=demos/quickstart.ipynb`
+
+#### `make open_notebook NOTEBOOK=demos/<path>.ipynb`
+Opens the working-tree notebook in local JupyterLab (`jupyter lab <path>`, falling back to `python -m jupyterlab`).
+- **Use when**: You want to edit or run a demo notebook locally with the current source install, helper files, and uncommitted changes all in place
+- **Note**: Runs the Lab server in the foreground; stop it with `Ctrl+C`
+- **Example**: `make open_notebook NOTEBOOK=demos/quickstart.ipynb`
+
 #### `make coverage`
 Displays the current coverage report (must run other targets first to accumulate coverage data).
 - **Output**: Terminal summary of coverage percentages per file/module
@@ -217,15 +284,7 @@ Displays the current coverage report (must run other targets first to accumulate
 Deletes `.coverage` and `coverage.json` files to reset coverage tracking.
 - **Use before**: Running a fresh coverage report without accumulated data
 
-## Redundancy Analysis & Status
-
-### Removed Redundant Target ✅
-
-#### `make tests_parallel_no_docker` (REMOVED)
-- **Was redundant**: Ran only unit tests in parallel. `make tests_fast` is a strict superset (doctests + unittests + booktests in parallel).
-- **Status**: **Removed from Makefile** to simplify maintenance and reduce user confusion.
-- **Migration**: Users should use `make tests_fast` instead (faster, more comprehensive).
-
+ 
 ---
 
 ## Currently Active Targets: Justification
@@ -451,4 +510,4 @@ A second workflow, `.github/workflows/unittests.yml`, runs a matrix across Pytho
 - `.github/workflows/alltests.yml` – CI all test workflow
 - `.github/workflows/unittests.yml` - CI unit test workflow
 - `make clean_local_only_files` – Artifact cleanup utility
-- `scripts/pytest_xdist.py` – Parallel execution detection helper
\ No newline at end of file
+- `scripts/pytest_xdist.py` – Parallel execution detection helper
diff --git a/makefile b/makefile
index 924c0e9b5..7440be519 100644
--- a/makefile
+++ b/makefile
@@ -2,6 +2,7 @@
 PYTEST_XDIST ?= $(shell python scripts/pytest_xdist.py 2>/dev/null)
 PYTEST ?=
 PYTHON ?= python3
+SMOKE_CODE_CELLS ?= 2
 WITH_MPMC ?= 0
 HAS_MPMC ?= $(shell python -c "import importlib.util; mods=('torch','pyg_lib','torch_geometric'); print(int(all(importlib.util.find_spec(m) is not None for m in mods)))" 2>/dev/null || echo 0)
 
@@ -132,6 +133,21 @@ unittests: ensure_artifacts
 		--no-header \
 		test/ -W ignore::DeprecationWarning
 
+# Core unit tests only: skips test/booktests/ (needs the notebook stack); other
+# modules self-skip via pytest.importorskip. Pairs with the `test_core` extra so
+# interpreters at the `requires-python` floor can run this. Unlike `unittests`
+# this omits -x: on a compatibility run the full list of failures is the point.
+unittests_core: ensure_artifacts
+	@mkdir -p $(UNIT_COV_DIR)
+	COVERAGE_FILE=$(UNIT_COV_DIR)/.coverage \
+	python -m pytest $(PYTEST_XDIST) $(PYTEST_EXTRA_ARGS) \
+		--cov=qmcpy \
+		--cov-report term \
+		--cov-report json:$(UNIT_COV_DIR)/coverage.json \
+		--no-header -rs \
+		--ignore=test/booktests \
+		test/ -W ignore::DeprecationWarning
+
 tests_no_docker_no_mpmc: doctests_no_docker_no_mpmc unittests coverage
 
 ##########################################################
@@ -141,6 +157,88 @@ generate_booktests:
 	@echo "\nGenerating missing booktest files..."
 	cd test/booktests/ && python generate_test.py --check-missing
 
+check_colab_notebooks:  # faster
+	$(PYTHON) -m scripts.check_colab_notebooks --strict
+
+check_colab_notebooks_smoke:  # slower; executes bootstrap + a few cells of every enabled notebook
+	$(PYTHON) -m scripts.smoke_test_colab_notebooks --cells-after-bootstrap $(SMOKE_CODE_CELLS)
+
+harden_colab_notebook:  # Add Colab button if necessary
+	@if [ -n "$(NOTEBOOK)" ]; then \
+		if [ -n "$(FORCE)" ]; then \
+			$(PYTHON) -m scripts.harden_colab_notebook --notebook "$(NOTEBOOK)" --force; \
+		else \
+			$(PYTHON) -m scripts.harden_colab_notebook --notebook "$(NOTEBOOK)"; \
+		fi; \
+	elif [ -n "$(FORCE)" ]; then \
+		$(PYTHON) -m scripts.harden_colab_notebook --force; \
+	else \
+		$(PYTHON) -m scripts.harden_colab_notebook --all-unclassified; \
+	fi
+
+report_colab_notebook_patterns:
+	$(PYTHON) -m scripts.report_colab_notebook_patterns
+
+open_colab_notebook:  # Open NOTEBOOK in Colab from the current branch, but only when it differs from COLAB_BASE (default develop); usage: make open_colab_notebook NOTEBOOK=demos/foo.ipynb [COLAB_BASE=develop]
+	@nb="$(NOTEBOOK)"; nb="$${nb#./}"; base="$${COLAB_BASE:-develop}"; \
+	if [ -z "$$nb" ]; then echo "Usage: make open_colab_notebook NOTEBOOK=demos/path/to.ipynb [COLAB_BASE=develop]"; exit 2; fi; \
+	case "$$nb" in *.ipynb) ;; *) echo "Not a .ipynb file: $$nb"; exit 2;; esac; \
+	branch=$$(git rev-parse --abbrev-ref HEAD); \
+	slug=$$($(PYTHON) -c "import json; wprint(json.load(open('scripts/colab_notebooks_manifest.json'))['repo'])" 2>/dev/null); \
+	[ -n "$$slug" ] || slug=$$(git remote get-url origin 2>/dev/null | sed -E 's#(git@github\.com:|https://github\.com/)##; s#\.git$$##'); \
+	if [ -z "$$slug" ]; then echo "Cannot determine the GitHub owner/repo (manifest 'repo' or 'origin' remote)."; exit 1; fi; \
+	git fetch -q origin "$$base" "$$branch" 2>/dev/null || true; \
+	if ! git rev-parse -q --verify "origin/$$branch" >/dev/null; then \
+		echo "Branch '$$branch' is not on origin -- push it first (Colab loads notebooks from GitHub)."; exit 1; \
+	fi; \
+	if ! git rev-parse -q --verify "origin/$$base" >/dev/null; then \
+		echo "Base '$$base' is not a branch on origin -- set COLAB_BASE to a pushed branch (e.g. develop)."; exit 1; \
+	fi; \
+	if ! git ls-tree -r --name-only "origin/$$branch" | grep -qxF "$$nb"; then \
+		echo "'$$nb' is not committed on origin/$$branch -- commit and push it first."; exit 1; \
+	fi; \
+	git diff --quiet "origin/$$branch" -- "$$nb" || \
+		echo "note: local '$$nb' differs from origin/$$branch; Colab shows the pushed version."; \
+	if [ "$$branch" = "$$base" ]; then \
+		ref="$$base"; echo "On '$$base' -- opening the $$base version."; \
+	elif ! git ls-tree -r --name-only "origin/$$base" | grep -qxF "$$nb"; then \
+		ref="$$branch"; echo "'$$nb' is new (not on origin/$$base) -- opening the '$$branch' version."; \
+	elif git diff --quiet "origin/$$base" "origin/$$branch" -- "$$nb"; then \
+		ref="$$base"; echo "'$$nb' is unchanged vs origin/$$base -- the standard badge covers it; opening the $$base version."; \
+	else \
+		ref="$$branch"; echo "'$$nb' differs from origin/$$base -- opening the '$$branch' version."; \
+	fi; \
+	url="https://colab.research.google.com/github/$$slug/blob/$$ref/$$nb"; \
+	echo "$$url"; \
+	$(PYTHON) -m webbrowser "$$url" >/dev/null 2>&1 || echo "(could not auto-open a browser; copy the URL above)"
+
+open_colab_notebook_gist:  # Upload NOTEBOOK from the working tree to a throwaway secret gist and open it in Colab (needs the gh CLI); usage: make open_colab_notebook_gist NOTEBOOK=demos/foo.ipynb
+	@nb="$(NOTEBOOK)"; nb="$${nb#./}"; \
+	if [ -z "$$nb" ]; then echo "Usage: make open_colab_notebook_gist NOTEBOOK=demos/path/to.ipynb"; exit 2; fi; \
+	if [ ! -f "$$nb" ]; then echo "No such file: $$nb"; exit 2; fi; \
+	case "$$nb" in *.ipynb) ;; *) echo "Not a .ipynb file: $$nb"; exit 2;; esac; \
+	if ! command -v gh >/dev/null 2>&1; then \
+		echo "The 'gh' CLI is required (https://cli.github.com), then run 'gh auth login'."; exit 1; \
+	fi; \
+	base=$$(basename "$$nb"); \
+	url=$$(gh gist create --desc "qmcpy Colab preview of $$nb (safe to delete)" "$$nb") || exit 1; \
+	id=$${url##*/}; \
+	login=$$(gh api user -q .login 2>/dev/null); \
+	colab="https://colab.research.google.com/gist/$${login:+$$login/}$$id/$$base"; \
+	echo "gist (secret):    $$url"; \
+	echo "colab:            $$colab"; \
+	echo "delete when done: gh gist delete $$id"; \
+	echo "note: sibling .py helpers won't resolve from a gist; the bootstrap cell falls back to develop."; \
+	$(PYTHON) -m webbrowser "$$colab" >/dev/null 2>&1 || echo "(could not auto-open a browser; copy the colab URL above)"
+
+open_notebook:  # Open NOTEBOOK from the working tree in local JupyterLab; usage: make open_notebook NOTEBOOK=demos/foo.ipynb
+	@nb="$(NOTEBOOK)"; nb="$${nb#./}"; \
+	if [ -z "$$nb" ]; then echo "Usage: make open_notebook NOTEBOOK=demos/path/to.ipynb"; exit 2; fi; \
+	if [ ! -f "$$nb" ]; then echo "No such file: $$nb"; exit 2; fi; \
+	case "$$nb" in *.ipynb) ;; *) echo "Not a .ipynb file: $$nb"; exit 2;; esac; \
+	if command -v jupyter >/dev/null 2>&1; then exec jupyter lab "$$nb"; \
+	else exec $(PYTHON) -m jupyterlab "$$nb"; fi
+
 check_booktests:
 	rm -fr demos/.ipynb_checkpoints/*checkpoint.ipynb && \
 	find demos -name '*.ipynb' | while read nb; do \
@@ -420,9 +518,7 @@ format:
 	$(MAKE) markdown-unwrap MARKDOWN_UNWRAP_PATH="$(MARKDOWN_UNWRAP_PATH)"
 	@echo ""
 	$(MAKE) rm_trailing_whitespace FORMAT_PATH="$(FORMAT_PATH)"
-	@echo ""
-	$(MAKE) check_test_style
-	@echo ""
+	$(MAKE) harden_colab_notebook
 
 flatten_qmcpy_imports:
 	$(PYTHON) scripts/flatten_qmcpy_imports.py
diff --git a/pyproject.toml b/pyproject.toml
index dac48d235..570ba971d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -27,6 +27,14 @@ classifiers= [
     "Development Status :: 5 - Production/Stable",
     "Intended Audience :: Science/Research",
     "Programming Language :: Python :: 3",
+    # Keep these aligned with `requires-python` and the tested interpreter
+    # matrix. See CONTRIBUTING.md.
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Topic :: Scientific/Engineering :: Mathematics",
     ]
 readme = "README.md"
@@ -45,7 +53,9 @@ keywords=[
     ]
 license = {file = "LICENSE"}
 dynamic = ["version"]
-requires-python = ">= 3.5"
+# Deliberate QMCPy support-policy floor, not a source-language or transitive
+# dependency floor. CI verifies the built wheel on 3.9; see CONTRIBUTING.md.
+requires-python = ">= 3.9"
 dependencies = [
     "numpy >= 1.17.0",
     "scipy >= 1.1.0",
@@ -92,6 +102,18 @@ test = [
     "nbconvert >= 7.2.9",
     "pytest-xdist >= 3.8.0",
     ]
+# Minimal set for `make unittests_core` (test/test_*.py only). Omits the
+# notebook/booktest stack (parsl, testbook, ...) whose 3.10 floor would
+# otherwise force every unit-test job onto 3.10+, so CI can exercise the
+# published `requires-python` floor. See CONTRIBUTING.md.
+test_core = [
+    "pytest >= 7.0",
+    "pytest-cov >= 4.0",
+    "pytest-xdist >= 3.0",
+    "scikit-learn >= 1.0.0",
+    "pandas >= 1.3.0",
+    "pyyaml >= 6.0",
+    ]
 test_torch = [
     "torch >= 2.7.0, < 2.13", # kept in sync with the mpmc extra: PyG pyg_lib wheels stop at torch 2.12
     ]
diff --git a/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py b/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
index 0a463507f..89887d578 100644
--- a/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
+++ b/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
@@ -323,6 +323,8 @@ def __init__(
             repos = DataSource()
             if repos.exists(local_root + generating_matrices):
                 datafile = repos.open(local_root + generating_matrices)
+            elif repos.exists(generating_matrices):
+                datafile = repos.open(generating_matrices)
             elif repos.exists(
                 "https://raw.githubusercontent.com/QMCSoftware/LDData/refs/heads/main/dnet/"
                 + generating_matrices
@@ -354,8 +356,6 @@ def __init__(
                     "https://raw.githubusercontent.com/QMCSoftware/"
                     + generating_matrices
                 )
-            elif repos.exists(generating_matrices):
-                datafile = repos.open(generating_matrices)
             else:
                 raise ParameterError("LDData path %s not found" % generating_matrices)
             contents = [line.rstrip("\n").strip() for line in datafile.readlines()]
diff --git a/qmcpy/true_measure/product_measure.py b/qmcpy/true_measure/product_measure.py
index b644666a3..3f860e84b 100644
--- a/qmcpy/true_measure/product_measure.py
+++ b/qmcpy/true_measure/product_measure.py
@@ -1,10 +1,11 @@
 import numpy as np
+from scipy import sparse
 
 from .abstract_true_measure import AbstractTrueMeasure
 from ..discrete_distribution.abstract_discrete_distribution import (
     AbstractDiscreteDistribution,
 )
-from ..util import DimensionError, ParameterError
+from ..util import DimensionError, ParameterError, _univ_repr
 
 
 class ProductMeasure(AbstractTrueMeasure):
@@ -46,6 +47,9 @@ class ProductMeasure(AbstractTrueMeasure):
 
     Notes
     -----
+    For independent marginal blocks, means, variances, and standard deviations
+    are concatenated in marginal order, while covariance is block diagonal.
+
     Exact product weights are supported for direct marginal true measures. For
     recursively composed marginal measures, sampling is supported through
     QMCPy's recursive transform helper, but exact final-space product weights
@@ -177,6 +181,137 @@ def __init__(self, sampler, marginals):
 
         super(ProductMeasure, self).__init__()
 
+        self._mean_cache = None
+        self._variance_cache = None
+        self._standard_deviation_cache = None
+        self._covariance_cache = None
+
+        for statistic in (
+            "mean",
+            "variance",
+            "standard_deviation",
+            "covariance",
+        ):
+            if all(hasattr(marginal, statistic) for marginal in self.marginals):
+                self.parameters.append(statistic)
+
+    def _marginal_statistic(self, marginal, marginal_index, statistic):
+        """Return a statistic or identify the marginal that does not provide it."""
+        try:
+            return getattr(marginal, statistic)
+        except AttributeError as error:
+            raise AttributeError(
+                f"ProductMeasure marginal {marginal_index} "
+                f"({type(marginal).__name__}) does not provide {statistic}."
+            ) from error
+
+    def _concatenate_marginal_statistic(self, statistic):
+        """Concatenate a coordinate-wise statistic in marginal order."""
+        values = []
+        for marginal_index, marginal in enumerate(self.marginals):
+            value = self._marginal_statistic(
+                marginal, marginal_index, statistic
+            )
+            value = np.atleast_1d(np.asarray(value))
+            if value.shape != (marginal.d,):
+                raise DimensionError(
+                    f"ProductMeasure marginal {marginal_index} "
+                    f"({type(marginal).__name__}) {statistic} must have shape "
+                    f"({marginal.d},), got {value.shape}."
+                )
+            values.append(value)
+
+        combined = self._read_only_array(np.concatenate(values))
+        return self._scalar_if_univariate(combined)
+
+    @property
+    def mean(self):
+        if self._mean_cache is None:
+            self._mean_cache = self._concatenate_marginal_statistic("mean")
+        return self._mean_cache
+
+    @property
+    def variance(self):
+        if self._variance_cache is None:
+            self._variance_cache = self._concatenate_marginal_statistic("variance")
+        return self._variance_cache
+
+    @property
+    def standard_deviation(self):
+        if self._standard_deviation_cache is None:
+            self._standard_deviation_cache = self._concatenate_marginal_statistic(
+                "standard_deviation"
+            )
+        return self._standard_deviation_cache
+
+    def _compute_covariance(self):
+        """Build and protect the block-diagonal marginal covariance."""
+        blocks = []
+        for marginal_index, marginal in enumerate(self.marginals):
+            block = self._marginal_statistic(
+                marginal, marginal_index, "covariance"
+            )
+            if not sparse.issparse(block):
+                block = np.atleast_2d(np.asarray(block))
+            expected_shape = (marginal.d, marginal.d)
+            if block.shape != expected_shape:
+                raise DimensionError(
+                    f"ProductMeasure marginal {marginal_index} "
+                    f"({type(marginal).__name__}) covariance must have shape "
+                    f"{expected_shape}, got {block.shape}."
+                )
+            blocks.append(block)
+
+        if any(sparse.issparse(block) for block in blocks):
+            covariance = sparse.block_diag(blocks, format="csr")
+            # Rebuild from a read-only base so writes cannot be re-enabled.
+            data = self._read_only_array(covariance.data)
+            return sparse.csr_matrix(
+                (data, covariance.indices, covariance.indptr),
+                shape=covariance.shape,
+                copy=False,
+            )
+
+        covariance = np.zeros(
+            (self.d, self.d),
+            dtype=np.result_type(*[block.dtype for block in blocks]),
+        )
+        start = 0
+        for block in blocks:
+            stop = start + block.shape[0]
+            covariance[start:stop, start:stop] = block
+            start = stop
+        covariance.setflags(write=False)
+        return self._read_only_view(covariance)
+
+    @property
+    def covariance(self):
+        if self._covariance_cache is None:
+            self._covariance_cache = self._compute_covariance()
+        return self._covariance_cache
+
+    def __repr__(self):
+        """Represent ProductMeasure without expanding marginal sparse matrices."""
+        lines = [f"{type(self).__name__} (AbstractTrueMeasure)"]
+        for parameter in dict.fromkeys(self.parameters):
+            if parameter == "marginals":
+                marginals = ", ".join(
+                    f"{type(marginal).__name__}(d={marginal.d})"
+                    for marginal in self.marginals
+                )
+                lines.append(f"    {parameter:<15} [{marginals}]")
+            elif parameter == "covariance" and sparse.issparse(self.covariance):
+                covariance = self.covariance
+                summary = (
+                    f"sparse {covariance.format.upper()}, "
+                    f"shape={covariance.shape}, nnz={covariance.nnz}"
+                )
+                lines.append(f"    {parameter:<15} {summary}")
+            else:
+                formatted = _univ_repr(self, "AbstractTrueMeasure", [parameter])
+                lines.extend(formatted.splitlines()[1:])
+        return "\n".join(lines)
+
     @staticmethod
     def _expand_bounds(bounds, dimension, name):
         """
diff --git a/scripts/__init__.py b/scripts/__init__.py
new file mode 100644
index 000000000..e3d9df4d4
--- /dev/null
+++ b/scripts/__init__.py
@@ -0,0 +1 @@
+"""Repository maintenance scripts."""
diff --git a/scripts/check_colab_notebooks.py b/scripts/check_colab_notebooks.py
new file mode 100644
index 000000000..444ff0afe
--- /dev/null
+++ b/scripts/check_colab_notebooks.py
@@ -0,0 +1,567 @@
+#!/usr/bin/env python3
+"""
+Validate Colab support metadata for demo notebooks.
+
+Every notebook under ``demos/`` must be explicitly classified in the manifest:
+- enabled: notebook should expose the expected Colab badge and bootstrap cell
+- disabled: notebook is intentionally excluded, with a reason
+"""
+
+from __future__ import annotations
+
+import argparse
+import ast
+import json
+import re
+import sys
+import warnings
+from pathlib import Path
+from urllib.parse import urlsplit
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+DEMOS_DIR = REPO_ROOT / "demos"
+DEFAULT_MANIFEST = Path(__file__).with_name("colab_notebooks_manifest.json")
+
+CORE_BOOTSTRAP_FRAGMENT = "import google.colab"
+BOOTSTRAP_CELL_MARKER = "# @title Execute this cell to install dependencies"
+REPO_QMCPY_INSTALL_FRAGMENTS = (
+    "git+https://github.com/QMCSoftware/QMCSoftware",
+    "pip install -q -e",
+    "pip install -e",
+)
+EXTRA_PIP_DEPENDENCIES = {
+    "QuantLib": ("QuantLib", "quantlib"),
+    "parsl": ("parsl",),
+    "seaborn": ("seaborn",),
+    "skopt": ("scikit-optimize", "skopt"),
+    "tueplots": ("tueplots",),
+}
+UMBRIDGE_MARKERS = ("import umbridge", "from umbridge", "UMBridgeWrapper", "HTTPModel(")
+EARLY_EXTRA_DEPENDENCY_CODE_CELLS = 3
+REPO_FETCH_FRAGMENTS = ("git clone", "raw.githubusercontent.com", "wget ", "curl ")
+PATH_SETUP_FRAGMENTS = ("sys.path.insert", "os.chdir(", "%cd ", "cd ")
+IGNORED_NOTEBOOK_NAME_PREFIXES = (".tmp", "._tmp")
+EXTRA_DEPS_MARKER = "# colab-deps:"
+COLAB_URL_HOSTNAME = "colab.research.google.com"
+URL_PATTERN = re.compile(r"https?://[^\s)\]\"']+")
+
+
+def load_json(path: Path) -> dict:
+    try:
+        with path.open(encoding="utf-8") as handle:
+            return json.load(handle)
+    except json.JSONDecodeError as exc:
+        raise ValueError(
+            f"{path}:{exc.lineno}:{exc.colno}: invalid JSON: {exc.msg}"
+        ) from exc
+
+
+def as_source_list(source: str | list[str]) -> list[str]:
+    if isinstance(source, str):
+        return source.splitlines(keepends=True)
+    return list(source)
+
+
+def cell_source_text(cell: dict) -> str:
+    return "".join(as_source_list(cell.get("source", [])))
+
+
+def python_source_for_ast(source: str) -> str:
+    filtered_lines = []
+    for line in source.splitlines():
+        stripped = line.lstrip()
+        if stripped.startswith(("!", "%")):
+            # Replace rather than drop, so a magic-only block body still parses.
+            indent = line[: len(line) - len(stripped)]
+            filtered_lines.append(f"{indent}pass")
+            continue
+        filtered_lines.append(line)
+    return "\n".join(filtered_lines)
+
+
+def imported_modules(source: str, location: str = "<unknown>") -> set[str]:
+    cleaned = python_source_for_ast(source)
+    if not cleaned.strip():
+        return set()
+    try:
+        # Notebook code often contains valid runtime strings such as LaTeX
+        # preambles that trigger irrelevant SyntaxWarnings during static parsing.
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", SyntaxWarning)
+            tree = ast.parse(cleaned, filename=location)
+    except SyntaxError:
+        return set()
+
+    modules: set[str] = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                modules.add(alias.name.split(".")[0])
+        elif isinstance(node, ast.ImportFrom) and node.module:
+            modules.add(node.module.split(".")[0])
+    return modules
+
+
+def badge_markup(repo: str, git_ref: str, notebook_path: str) -> str:
+    return (
+        "[![Open In Colab]"
+        "(https://colab.research.google.com/assets/colab-badge.svg)]"
+        "(https://colab.research.google.com/github/"
+        f"{repo}/blob/{git_ref}/{notebook_path})"
+    )
+
+
+def contains_colab_url(source: str) -> bool:
+    # Parse candidate URLs and compare the exact hostname rather than
+    # substring-matching the domain, which a crafted URL could spoof.
+    return any(
+        urlsplit(match.group(0)).hostname == COLAB_URL_HOSTNAME
+        for match in URL_PATTERN.finditer(source)
+    )
+
+
+def is_any_badge_cell(cell: dict) -> bool:
+    if cell.get("cell_type") != "markdown":
+        return False
+    source = cell_source_text(cell)
+    return "Open In Colab" in source or contains_colab_url(source)
+
+
+def has_expected_badge(cell: dict, repo: str, git_ref: str, notebook_path: str) -> bool:
+    return (
+        cell.get("cell_type") == "markdown"
+        and badge_markup(repo, git_ref, notebook_path) in cell_source_text(cell)
+    )
+
+
+def is_any_install_cell(cell: dict) -> bool:
+    if cell.get("cell_type") != "code":
+        return False
+    source_lines = cell_source_text(cell).splitlines()
+    return bool(source_lines) and source_lines[0].strip() == BOOTSTRAP_CELL_MARKER
+
+
+def pip_install_lines(source: str) -> list[str]:
+    return [
+        line.lower()
+        for line in source.splitlines()
+        if line.lstrip().lower().startswith(("!pip install", "%pip install"))
+    ]
+
+
+def installs_qmcpy(source: str) -> bool:
+    install_lines = pip_install_lines(source)
+    if any("qmcpy" in line for line in install_lines):
+        return True
+    return any(fragment in source for fragment in REPO_QMCPY_INSTALL_FRAGMENTS)
+
+
+def installs_packages(source: str, package_names: tuple[str, ...]) -> bool:
+    install_lines = pip_install_lines(source)
+    return any(
+        package.lower() in line
+        for line in install_lines
+        for package in package_names
+    )
+
+
+def declared_extra_pip_packages(cells: list[dict]) -> list[str]:
+    """Escape hatch for deps outside EXTRA_PIP_DEPENDENCIES/EXTRA_IMPORT_DEPENDENCIES:
+    a `# colab-deps: pkg-a, pkg-b` comment anywhere in a code cell."""
+    packages: list[str] = []
+    for cell in cells:
+        if cell.get("cell_type") != "code":
+            continue
+        for line in cell_source_text(cell).splitlines():
+            stripped = line.strip()
+            if not stripped.startswith(EXTRA_DEPS_MARKER):
+                continue
+            for name in stripped[len(EXTRA_DEPS_MARKER):].split(","):
+                name = name.strip()
+                if name and name not in packages:
+                    packages.append(name)
+    return packages
+
+
+def is_bootstrap_cell(cell: dict) -> bool:
+    source = cell_source_text(cell)
+    return is_any_install_cell(cell) and (
+        CORE_BOOTSTRAP_FRAGMENT in source
+        and "except ImportError:" in source
+        and "if IN_COLAB:" in source
+        and installs_qmcpy(source)
+    )
+
+
+def notebook_code_cells(cells: list[dict]) -> list[tuple[int, dict]]:
+    return [
+        (idx, cell) for idx, cell in enumerate(cells) if cell.get("cell_type") == "code"
+    ]
+
+
+def early_non_install_code_cells(
+    cells: list[dict], limit: int = EARLY_EXTRA_DEPENDENCY_CODE_CELLS
+) -> list[tuple[int, dict]]:
+    early_cells: list[tuple[int, dict]] = []
+    for idx, cell in notebook_code_cells(cells):
+        if is_any_install_cell(cell):
+            continue
+        early_cells.append((idx, cell))
+        if len(early_cells) >= limit:
+            break
+    return early_cells
+
+
+def imported_modules_in_cells(indexed_cells: list[tuple[int, dict]]) -> set[str]:
+    modules: set[str] = set()
+    for idx, cell in indexed_cells:
+        modules.update(
+            imported_modules(cell_source_text(cell), location=f"cell {idx + 1}")
+        )
+    return modules
+
+
+def code_source_upto(cells: list[dict], end_index: int) -> str:
+    return "\n".join(
+        cell_source_text(cell)
+        for idx, cell in enumerate(cells)
+        if cell.get("cell_type") == "code" and idx <= end_index
+    )
+
+
+def find_first_module_import(cells: list[dict], module: str) -> int | None:
+    for idx, cell in notebook_code_cells(cells):
+        location = f"cell {idx + 1}"
+        if module in imported_modules(cell_source_text(cell), location=location):
+            return idx
+    return None
+
+
+def local_module_matches(notebook_dir: Path, module: str) -> list[Path]:
+    matches: list[Path] = []
+
+    def add_if_present(directory: Path) -> None:
+        direct_file = directory / f"{module}.py"
+        package_init = directory / module / "__init__.py"
+        if direct_file.exists() and direct_file not in matches:
+            matches.append(direct_file)
+        if package_init.exists() and package_init not in matches:
+            matches.append(package_init)
+
+    add_if_present(notebook_dir)
+    for candidate in notebook_dir.rglob(f"{module}.py"):
+        if candidate not in matches and "__pycache__" not in candidate.parts:
+            matches.append(candidate)
+
+    # A notebook nested in a subfolder (e.g. a demo's `output/`) may import a
+    # shared helper module that lives in an ancestor folder, up to demos/.
+    directory = notebook_dir.parent
+    while directory == DEMOS_DIR or DEMOS_DIR in directory.parents:
+        add_if_present(directory)
+        if directory == DEMOS_DIR:
+            break
+        directory = directory.parent
+
+    return matches
+
+
+def validate_strict_enabled_notebook(path: Path) -> list[str]:
+    notebook_path = path.relative_to(REPO_ROOT).as_posix()
+    notebook_dir = path.parent
+    payload = load_json(path)
+    cells = payload.get("cells", [])
+    errors: list[str] = []
+    full_source = "\n".join(
+        cell_source_text(cell) for _, cell in notebook_code_cells(cells)
+    )
+    early_imports = imported_modules_in_cells(early_non_install_code_cells(cells))
+
+    for module, package_names in sorted(EXTRA_PIP_DEPENDENCIES.items()):
+        if module not in early_imports:
+            continue
+        first_import_index = find_first_module_import(cells, module)
+        if first_import_index is None:
+            continue
+        source_before_import = code_source_upto(cells, first_import_index)
+        if not installs_packages(source_before_import, package_names):
+            errors.append(
+                f"{notebook_path}: imports '{module}' without installing {package_names[0]!r} before that import."
+            )
+
+    imported_roots = sorted(
+        {
+            module
+            for idx, cell in notebook_code_cells(cells)
+            for module in imported_modules(
+                cell_source_text(cell), location=f"cell {idx + 1}"
+            )
+        }
+    )
+    if "umbridge" in imported_roots or any(marker in full_source for marker in UMBRIDGE_MARKERS):
+        errors.append(
+            f"{notebook_path}: depends on UM-Bridge and should be classified as Colab-disabled."
+        )
+
+    for idx, cell in notebook_code_cells(cells):
+        for line in cell_source_text(cell).splitlines():
+            if "IN_COLAB" in line:
+                continue
+            hit = re.search(r"\b2\s*\*\*\s*(\d{2,})\b", line)
+            if hit and int(hit.group(1)) >= 20:
+                errors.append(
+                    f"{notebook_path}: cell {idx + 1} uses 2**{hit.group(1)} without an "
+                    "`... if IN_COLAB else ...` guard -- likely to OOM/timeout in Colab; "
+                    "guard the size or Colab-disable the notebook."
+                )
+                break
+        else:
+            continue
+        break
+
+    for module in imported_roots:
+        local_matches = local_module_matches(notebook_dir, module)
+        if not local_matches:
+            continue
+        first_import_index = find_first_module_import(cells, module)
+        if first_import_index is None:
+            continue
+        source_before_import = code_source_upto(cells, first_import_index)
+        if not any(fragment in source_before_import for fragment in REPO_FETCH_FRAGMENTS):
+            errors.append(
+                f"{notebook_path}: imports local module '{module}' without fetching repo files first."
+            )
+        if not any(fragment in source_before_import for fragment in PATH_SETUP_FRAGMENTS):
+            errors.append(
+                f"{notebook_path}: imports local module '{module}' without updating the working directory or sys.path first."
+            )
+        nested_match = next(
+            (match for match in local_matches if match.parent != notebook_dir), None
+        )
+        if nested_match is not None:
+            # Repo-root-relative (not notebook-relative) so this also works when
+            # the module lives in an ancestor of notebook_dir, matching the
+            # path harden_colab_notebook.py embeds in the generated bootstrap.
+            rel_parent = nested_match.parent.relative_to(REPO_ROOT).as_posix()
+            if rel_parent and rel_parent not in source_before_import:
+                errors.append(
+                    f"{notebook_path}: imports local module '{module}' from '{rel_parent}' without referencing that path in Colab setup."
+                )
+
+    return errors
+
+
+def manifest_sets(manifest: dict) -> tuple[set[str], dict[str, str]]:
+    enabled = set(manifest.get("enabled", []))
+    disabled = dict(manifest.get("disabled", {}))
+    return enabled, disabled
+
+
+def is_discoverable_notebook(path: Path) -> bool:
+    return ".ipynb_checkpoints" not in path.parts and not path.name.startswith(
+        IGNORED_NOTEBOOK_NAME_PREFIXES
+    )
+
+
+def discovered_notebooks() -> set[str]:
+    return {
+        path.relative_to(REPO_ROOT).as_posix()
+        for path in DEMOS_DIR.rglob("*.ipynb")
+        if is_discoverable_notebook(path)
+    }
+
+
+def validate_manifest(manifest: dict, allowed_missing: set[str] | None = None) -> list[str]:
+    errors: list[str] = []
+    enabled, disabled = manifest_sets(manifest)
+    discovered = discovered_notebooks()
+    declared = enabled | set(disabled)
+    allowed_missing = allowed_missing or set()
+
+    overlap = enabled & set(disabled)
+    if overlap:
+        errors.append(
+            "Manifest paths cannot be both enabled and disabled: "
+            + ", ".join(sorted(overlap))
+        )
+
+    missing = (discovered - declared) - allowed_missing
+    if missing:
+        errors.append(
+            "Manifest is missing notebook classifications for: "
+            + ", ".join(sorted(missing))
+            + " -- run `make harden_colab_notebook` to classify them"
+        )
+
+    extra = declared - discovered
+    if extra:
+        errors.append(
+            "Manifest references notebooks that do not exist: "
+            + ", ".join(sorted(extra))
+        )
+
+    for notebook_path, reason in sorted(disabled.items()):
+        if not isinstance(reason, str) or not reason.strip():
+            errors.append(f"Disabled notebook is missing a reason: {notebook_path}")
+
+    if not manifest.get("repo"):
+        errors.append("Manifest must define a non-empty 'repo' value.")
+    if not manifest.get("git_ref"):
+        errors.append("Manifest must define a non-empty 'git_ref' value.")
+
+    return errors
+
+
+def validate_enabled_notebook(path: Path, repo: str, git_ref: str) -> list[str]:
+    notebook_path = path.relative_to(REPO_ROOT).as_posix()
+    payload = load_json(path)
+    cells = payload.get("cells", [])
+    errors: list[str] = []
+
+    badge_positions = [
+        idx
+        for idx, cell in enumerate(cells)
+        if has_expected_badge(cell, repo, git_ref, notebook_path)
+    ]
+    any_badge_positions = [
+        idx for idx, cell in enumerate(cells) if is_any_badge_cell(cell)
+    ]
+    bootstrap_positions = [
+        idx for idx, cell in enumerate(cells) if is_bootstrap_cell(cell)
+    ]
+    any_install_positions = [
+        idx for idx, cell in enumerate(cells) if is_any_install_cell(cell)
+    ]
+    first_substantive_code = next(
+        (
+            idx
+            for idx, cell in enumerate(cells)
+            if cell.get("cell_type") == "code" and not is_bootstrap_cell(cell)
+        ),
+        None,
+    )
+
+    if not badge_positions:
+        errors.append(f"{notebook_path}: missing the expected Colab badge markup.")
+    if not bootstrap_positions:
+        errors.append(
+            f"{notebook_path}: missing a Colab bootstrap cell with the core qmcpy install command."
+        )
+
+    if len(badge_positions) > 1:
+        errors.append(
+            f"{notebook_path}: expected one matching Colab badge, found {len(badge_positions)}."
+        )
+    if len(any_badge_positions) != len(badge_positions):
+        errors.append(
+            f"{notebook_path}: found Colab badge markup that does not match the expected notebook URL."
+        )
+    if len(bootstrap_positions) > 1:
+        errors.append(
+            f"{notebook_path}: expected one Colab bootstrap cell, found {len(bootstrap_positions)}."
+        )
+    if len(any_install_positions) != len(bootstrap_positions):
+        errors.append(
+            f"{notebook_path}: found google.colab setup code that does not include the core qmcpy bootstrap."
+        )
+    if badge_positions and bootstrap_positions and badge_positions[0] > bootstrap_positions[0]:
+        errors.append(
+            f"{notebook_path}: Colab badge must appear before the Colab bootstrap cell."
+        )
+
+    if (
+        badge_positions
+        and first_substantive_code is not None
+        and badge_positions[0] > first_substantive_code
+    ):
+        errors.append(
+            f"{notebook_path}: Colab badge must appear before the first substantive code cell."
+        )
+
+    if (
+        bootstrap_positions
+        and first_substantive_code is not None
+        and bootstrap_positions[0] > first_substantive_code
+    ):
+        errors.append(
+            f"{notebook_path}: Colab bootstrap cell must appear before the first substantive code cell."
+        )
+
+    return errors
+
+
+def validate_disabled_notebook(path: Path) -> list[str]:
+    notebook_path = path.relative_to(REPO_ROOT).as_posix()
+    payload = load_json(path)
+    cells = payload.get("cells", [])
+    errors: list[str] = []
+
+    if any(is_any_badge_cell(cell) for cell in cells):
+        errors.append(
+            f"{notebook_path}: manifest marks this notebook as Colab-disabled, but a badge is present."
+        )
+    if any(is_any_install_cell(cell) for cell in cells):
+        errors.append(
+            f"{notebook_path}: manifest marks this notebook as Colab-disabled, but a Colab install cell is present."
+        )
+
+    return errors
+
+
+def run_check(manifest_path: Path, strict: bool = False) -> int:
+    manifest = load_json(manifest_path)
+    errors = validate_manifest(manifest)
+    enabled, disabled = manifest_sets(manifest)
+    repo = manifest["repo"]
+    git_ref = manifest["git_ref"]
+
+    for notebook_path in sorted(enabled):
+        errors.extend(
+            validate_enabled_notebook(REPO_ROOT / notebook_path, repo, git_ref)
+        )
+
+    for notebook_path in sorted(disabled):
+        errors.extend(validate_disabled_notebook(REPO_ROOT / notebook_path))
+
+    if strict:
+        for notebook_path in sorted(enabled):
+            errors.extend(validate_strict_enabled_notebook(REPO_ROOT / notebook_path))
+
+    if errors:
+        for error in errors:
+            print(error, file=sys.stderr)
+        return 1
+
+    print(
+        "Colab notebook check passed: "
+        f"{len(enabled)} enabled, {len(disabled)} disabled, "
+        f"{len(enabled) + len(disabled)} total."
+    )
+    return 0
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Check Colab badge/bootstrap cells for demo notebooks."
+    )
+    parser.add_argument(
+        "--manifest",
+        default=str(DEFAULT_MANIFEST),
+        help=f"Path to the Colab manifest (default: {DEFAULT_MANIFEST})",
+    )
+    parser.add_argument(
+        "--strict",
+        action="store_true",
+        help="Run additional static Colab-readiness checks for enabled notebooks.",
+    )
+    return parser.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    manifest_path = Path(args.manifest).resolve()
+    return run_check(manifest_path, strict=args.strict)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/colab_notebooks_manifest.json b/scripts/colab_notebooks_manifest.json
new file mode 100644
index 000000000..ed62ba8be
--- /dev/null
+++ b/scripts/colab_notebooks_manifest.json
@@ -0,0 +1,57 @@
+{
+ "repo": "QMCSoftware/QMCSoftware",
+ "git_ref": "develop",
+ "enabled": [
+  "demos/DAKOTA_Genz/dakota_genz.ipynb",
+  "demos/GBM/gbm_demo.ipynb",
+  "demos/GBM/gbm_examples.ipynb",
+  "demos/acceptance_rejection.ipynb",
+  "demos/asian-option-mlqmc.ipynb",
+  "demos/brownian_bridge.ipynb",
+  "demos/control_variates.ipynb",
+  "demos/copula_examples.ipynb",
+  "demos/demo_resume_data/Iteration_Log_Tolerance_Demo.ipynb",
+  "demos/demo_resume_data/accuracy_and_resume.ipynb",
+  "demos/demo_resume_data/resume_examples.ipynb",
+  "demos/digital_net_b2.ipynb",
+  "demos/elliptic-pde.ipynb",
+  "demos/gaussian_diagnostics/gaussian_diagnostics_demo.ipynb",
+  "demos/iris.ipynb",
+  "demos/korobov_hammersley_latinhypercube_demos.ipynb",
+  "demos/lattice_random_generator.ipynb",
+  "demos/lebesgue_integration.ipynb",
+  "demos/linear-scrambled-halton.ipynb",
+  "demos/nei_demo.ipynb",
+  "demos/plot_proj_function.ipynb",
+  "demos/pricing_options.ipynb",
+  "demos/product_measure.ipynb",
+  "demos/qei-demo-for-blog.ipynb",
+  "demos/qmcpy-logo.ipynb",
+  "demos/qmcpy_intro.ipynb",
+  "demos/quickstart.ipynb",
+  "demos/ray_tracing.ipynb",
+  "demos/sample_scatter_plots.ipynb",
+  "demos/scipywrapper_dependence_custom/scipywrapper_demo.ipynb",
+  "demos/some_true_measures.ipynb",
+  "demos/statistics_for_TrueMeasure.ipynb",
+  "demos/talk_paper_demos/JOSS2026/joss2026.ipynb",
+  "demos/talk_paper_demos/MCQMC_Tutorial_2020/MCQMC_2020_QMC_Software_Tutorial.ipynb",
+  "demos/talk_paper_demos/Parslfest_2025/01_sequential.ipynb",
+  "demos/talk_paper_demos/Parslfest_2025/02_parallel.ipynb",
+  "demos/talk_paper_demos/Parslfest_2025/03_visualize_speedup.ipynb",
+  "demos/talk_paper_demos/Parslfest_2025/output/01_sequential_output.ipynb",
+  "demos/talk_paper_demos/SorokinThesis2025/sorokin_thesis_2025.ipynb",
+  "demos/talk_paper_demos/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026.ipynb",
+  "demos/talk_paper_demos/pydata_chi_2023.ipynb",
+  "demos/talk_paper_demos/why_add_q_to_mc_blog/why_add_q_to_mc_blog.ipynb",
+  "demos/vectorized_qmc.ipynb",
+  "demos/vectorized_qmc_bayes.ipynb"
+ ],
+ "disabled": {
+  "demos/talk_paper_demos/Argonne_Talk_2023_May/Argonne_2023_Talk_Figures.ipynb": "Need Umbridge",
+  "demos/umbridge.ipynb": "Need Umbridge",
+  "demos/talk_paper_demos/MCQMC2022_Article_Figures/MCQMC2022_Article_Figures.ipynb": "Need Umbridge",
+  "demos/talk_paper_demos/ProbFailureSorokinRao/prob_failure_gp_ci.ipynb": "Need Umbridge",
+  "demos/talk_paper_demos/Purdue_Talk_2023_March/Purdue_Talk_Figures.ipynb": "Need Umbridge"
+ }
+}
diff --git a/scripts/harden_colab_notebook.py b/scripts/harden_colab_notebook.py
new file mode 100644
index 000000000..196c80aa8
--- /dev/null
+++ b/scripts/harden_colab_notebook.py
@@ -0,0 +1,503 @@
+#!/usr/bin/env python3
+"""
+Harden a demo notebook for Colab and classify it in the Colab manifest.
+
+This script is intentionally conservative:
+- it updates one notebook at a time
+- it inserts a standard badge/bootstrap before the first substantive code cell
+- it only auto-classifies notebooks that are not already in enabled or disabled
+- it can force-regenerate Colab bootstrap cells for notebooks already in enabled
+- it validates the result with the existing strict Colab checks
+"""
+
+from __future__ import annotations
+
+import argparse
+import copy
+import hashlib
+import json
+from pathlib import Path
+
+from scripts.check_colab_notebooks import (
+    BOOTSTRAP_CELL_MARKER,
+    DEFAULT_MANIFEST,
+    EXTRA_PIP_DEPENDENCIES,
+    REPO_ROOT,
+    as_source_list,
+    badge_markup,
+    cell_source_text,
+    declared_extra_pip_packages,
+    discovered_notebooks,
+    early_non_install_code_cells,
+    imported_modules,
+    is_any_badge_cell,
+    is_any_install_cell,
+    local_module_matches,
+    load_json,
+    pip_install_lines,
+    validate_enabled_notebook,
+    validate_manifest,
+    manifest_sets,
+    validate_strict_enabled_notebook,
+)
+
+
+EXTRA_IMPORT_DEPENDENCIES = {
+    **EXTRA_PIP_DEPENDENCIES,
+    "botorch": ("botorch",),
+    "gpytorch": ("gpytorch",),
+    "ipywidgets": ("ipywidgets",),
+    "seaborn": ("seaborn",),
+    "sklearn": ("scikit-learn", "sklearn"),
+    "sympy": ("sympy",),
+    "torch": ("torch",),
+    "umbridge": ("umbridge",),
+    "yfinance": ("yfinance",),
+}
+LATEX_MARKERS = (
+    "text.usetex",
+    "\\usepackage",
+    "dvipng",
+    "latexmk",
+    "computer modern",
+    "tueplots",  # tueplots bundles typically set text.usetex=True internally
+)
+COLAB_BADGE_IMAGE_FRAGMENT = "colab.research.google.com/assets/colab-badge.svg"
+
+
+def dump_json(path: Path, payload: dict, *, indent: int = 1) -> None:
+    with path.open("w", encoding="utf-8") as handle:
+        json.dump(payload, handle, indent=indent, ensure_ascii=False)
+        handle.write("\n")
+
+
+def json_indent(source: str) -> int:
+    for line in source.splitlines()[1:]:
+        if line.strip():
+            return len(line) - len(line.lstrip())
+    return 1
+
+
+def dump_notebook(path: Path, payload: dict, original_source: str) -> None:
+    dump_json(path, payload, indent=json_indent(original_source))
+
+
+def generated_cell_id(notebook_path: str, cell_kind: str) -> str:
+    return hashlib.sha256(f"{notebook_path}:{cell_kind}".encode()).hexdigest()[:8]
+
+
+def discovered_imports(cells: list[dict]) -> set[str]:
+    modules: set[str] = set()
+    for idx, cell in enumerate(cells):
+        if cell.get("cell_type") != "code":
+            continue
+        modules.update(
+            imported_modules(
+                cell_source_text(cell),
+                location=f"cell {idx + 1}",
+            )
+        )
+    return modules
+
+
+def local_repo_import_matches(
+    notebook_path: Path, cells: list[dict]
+) -> dict[str, list[Path]]:
+    notebook_dir = notebook_path.parent.resolve()
+    matches_by_module: dict[str, list[Path]] = {}
+    for module in sorted(discovered_imports(cells)):
+        if module == "qmcpy":
+            continue
+        matches = local_module_matches(notebook_dir, module)
+        if matches:
+            matches_by_module[module] = matches
+    return matches_by_module
+
+
+def needs_latex_setup(cells: list[dict]) -> bool:
+    source = "\n".join(
+        cell_source_text(cell)
+        for cell in cells
+        if cell.get("cell_type") in {"code", "markdown"}
+    )
+    return any(marker in source for marker in LATEX_MARKERS)
+
+
+def extra_pip_packages(cells: list[dict]) -> list[str]:
+    early_cells = [cell for _, cell in early_non_install_code_cells(cells)]
+    modules = discovered_imports(early_cells)
+    packages: list[str] = []
+    for module, names in sorted(EXTRA_IMPORT_DEPENDENCIES.items()):
+        if module in modules:
+            package = names[0]
+            if package not in packages:
+                packages.append(package)
+    all_install_lines = [
+        line
+        for cell in cells
+        if cell.get("cell_type") == "code"
+        for line in pip_install_lines(cell_source_text(cell))
+    ]
+    for _, names in sorted(EXTRA_IMPORT_DEPENDENCIES.items()):
+        package = names[0]
+        if package in packages:
+            continue
+        if any(name.lower() in line for name in names for line in all_install_lines):
+            packages.append(package)
+    for package in declared_extra_pip_packages(cells):
+        if package not in packages:
+            packages.append(package)
+    return packages
+
+
+def extra_repo_paths(notebook_path: Path, cells: list[dict]) -> list[str]:
+    notebook_dir = notebook_path.parent.resolve()
+    repo_matches = local_repo_import_matches(notebook_path, cells)
+    rel_paths: list[str] = []
+
+    for module in sorted(repo_matches):
+        for match in repo_matches[module]:
+            if match.name == "__init__.py" and match.parent.name == module:
+                parent = match.parent.parent.resolve()
+            else:
+                parent = match.parent.resolve()
+            if parent == notebook_dir:
+                continue
+            if parent == REPO_ROOT:
+                continue
+            rel_parent = parent.relative_to(REPO_ROOT).as_posix()
+            if rel_parent not in rel_paths:
+                rel_paths.append(rel_parent)
+
+    return rel_paths
+
+
+def bootstrap_cell_source(notebook_path: Path, manifest: dict, cells: list[dict]) -> list[str]:
+    notebook_dir_rel = notebook_path.parent.relative_to(REPO_ROOT).as_posix()
+    packages = extra_pip_packages(cells)
+    rel_paths = extra_repo_paths(notebook_path, cells)
+    latex_setup = needs_latex_setup(cells)
+    needs_repo_clone = bool(local_repo_import_matches(notebook_path, cells))
+
+    lines = [
+        f"{BOOTSTRAP_CELL_MARKER}\n",
+        "try:\n",
+        "  import google.colab\n",
+        "  IN_COLAB = True\n",
+        "except ImportError:\n",
+        "  IN_COLAB = False\n",
+        "if IN_COLAB:\n",
+    ]
+
+    if needs_repo_clone:
+        lines.extend(
+            [
+                "  import sys\n",
+                "  import os\n",
+                '  repo_root = "/content/QMCSoftware"\n',
+                f'  notebook_dir = f"{{repo_root}}/{notebook_dir_rel}"\n',
+                "  if not os.path.isdir(repo_root):\n",
+                f"    !git clone -q --depth 1 https://github.com/{manifest['repo']} {{repo_root}}\n",
+            ]
+        )
+
+    lines.append("  !pip install -q qmcpy\n")
+
+    if packages:
+        lines.append(f"  !pip install -q {' '.join(packages)}\n")
+
+    if latex_setup:
+        lines.append(
+            '  !tmp=$(mktemp) && if { apt-get update -qq && DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends texlive-latex-base texlive-fonts-recommended texlive-latex-extra cm-super dvipng; } >"$tmp" 2>&1; then rm -f "$tmp"; else status=$?; cat "$tmp"; rm -f "$tmp"; exit $status; fi\n'
+        )
+
+    if needs_repo_clone:
+        lines.extend(
+            [
+                "  os.chdir(notebook_dir)\n",
+                "  if notebook_dir not in sys.path:\n",
+                "    sys.path.insert(0, notebook_dir)\n",
+            ]
+        )
+        for rel_path in rel_paths:
+            lines.extend(
+                [
+                    f'  extra_path = f"{{repo_root}}/{rel_path}"\n',
+                    "  if extra_path not in sys.path:\n",
+                    "    sys.path.insert(0, extra_path)\n",
+                ]
+            )
+
+    return lines
+
+def badge_stripped_cell(cell: dict) -> dict | None:
+    if not is_any_badge_cell(cell):
+        return cell
+
+    kept_lines = [
+        line
+        for line in as_source_list(cell.get("source", []))
+        if COLAB_BADGE_IMAGE_FRAGMENT not in line
+    ]
+    if not "".join(kept_lines).strip():
+        return None
+
+    cleaned_cell = copy.deepcopy(cell)
+    cleaned_cell["source"] = kept_lines
+    return cleaned_cell
+
+
+def remove_any_badge_cells(cells: list[dict]) -> list[dict]:
+    cleaned_cells: list[dict] = []
+    for cell in cells:
+        cleaned_cell = badge_stripped_cell(cell)
+        if cleaned_cell is not None:
+            cleaned_cells.append(cleaned_cell)
+    return cleaned_cells
+
+
+def badge_bootstrap_insert_index(cells: list[dict]) -> int:
+    insert_at = 0
+    while insert_at < len(cells) and cells[insert_at].get("cell_type") == "markdown":
+        insert_at += 1
+    first_code_cell = next(
+        (idx for idx, cell in enumerate(cells) if cell.get("cell_type") == "code"),
+        len(cells),
+    )
+    return min(insert_at, first_code_cell)
+
+
+def remove_existing_bootstrap_cells(cells: list[dict]) -> list[dict]:
+    return [cell for cell in cells if not is_any_install_cell(cell)]
+
+
+def pending_unclassified(
+    manifest: dict, current_notebook: str | None = None
+) -> set[str]:
+    enabled, disabled = manifest_sets(manifest)
+    missing = discovered_notebooks() - enabled - set(disabled)
+    if current_notebook is not None:
+        missing.discard(current_notebook)
+    return missing
+
+
+def harden_notebook(notebook_path: Path, manifest_path: Path) -> None:
+    original_notebook_text = notebook_path.read_text(encoding="utf-8")
+    original_manifest_text = manifest_path.read_text(encoding="utf-8")
+    manifest = load_json(manifest_path)
+    notebook_payload = load_json(notebook_path)
+
+    original_manifest = copy.deepcopy(manifest)
+    original_notebook = copy.deepcopy(notebook_payload)
+
+    # Cells that survive unchanged: remove only the old badge/bootstrap cells.
+    # These dict objects are never modified; they are passed through as-is.
+    kept_cells = remove_any_badge_cells(
+        remove_existing_bootstrap_cells(list(notebook_payload.get("cells", [])))
+    )
+
+    insert_at = badge_bootstrap_insert_index(kept_cells)
+
+    badge_cell = {
+        "cell_type": "markdown",
+        "metadata": {},
+        "source": [
+            badge_markup(
+                manifest["repo"],
+                manifest["git_ref"],
+                notebook_path.relative_to(REPO_ROOT).as_posix(),
+            )
+        ],
+    }
+    bootstrap_cell = {
+        "cell_type": "code",
+        "execution_count": None,
+        "metadata": {},
+        "outputs": [],
+        # Pass kept_cells (not the final list) so the source scanner only sees
+        # the original notebook code cells, not the badge cell we just built.
+        "source": bootstrap_cell_source(notebook_path, manifest, kept_cells),
+    }
+
+    # Build the final cell list purely by concatenation — kept_cells are untouched.
+    cells = kept_cells[:insert_at] + [badge_cell, bootstrap_cell] + kept_cells[insert_at:]
+
+    notebook_payload["cells"] = cells
+
+    notebook_rel = notebook_path.relative_to(REPO_ROOT).as_posix()
+    if notebook_payload.get("nbformat_minor", 0) >= 5:
+        badge_cell["id"] = generated_cell_id(notebook_rel, "badge")
+        bootstrap_cell["id"] = generated_cell_id(notebook_rel, "bootstrap")
+
+    enabled = list(manifest.get("enabled", []))
+    disabled = dict(manifest.get("disabled", {}))
+    if notebook_rel in disabled:
+        raise ValueError(
+            f"{notebook_rel} is already classified as disabled; harden_colab_notebook does not reclassify disabled notebooks."
+        )
+    if notebook_rel not in enabled:
+        enabled.append(notebook_rel)
+    enabled = sorted(enabled)
+    manifest["enabled"] = enabled
+    manifest["disabled"] = disabled
+
+    notebook_changed = notebook_payload != original_notebook
+    manifest_changed = manifest != original_manifest
+    try:
+        if notebook_changed:
+            dump_notebook(notebook_path, notebook_payload, original_notebook_text)
+        if manifest_changed:
+            dump_json(manifest_path, manifest)
+
+        reloaded_manifest = load_json(manifest_path)
+        errors = validate_manifest(
+            reloaded_manifest,
+            allowed_missing=pending_unclassified(reloaded_manifest, notebook_rel),
+        )
+        errors.extend(
+            validate_enabled_notebook(
+                notebook_path,
+                reloaded_manifest["repo"],
+                reloaded_manifest["git_ref"],
+            )
+        )
+        errors.extend(validate_strict_enabled_notebook(notebook_path))
+        if errors:
+            raise RuntimeError("\n".join(errors))
+    except Exception:
+        if notebook_changed:
+            notebook_path.write_text(original_notebook_text, encoding="utf-8")
+        if manifest_changed:
+            manifest_path.write_text(original_manifest_text, encoding="utf-8")
+        raise
+
+
+def error_summary(exc: Exception) -> str:
+    return str(exc).splitlines()[0] if str(exc) else "unknown error"
+
+
+def validate_target_notebook(notebook_path: Path, notebook_rel: str) -> None:
+    if not notebook_path.exists():
+        raise FileNotFoundError(f"Notebook not found: {notebook_rel}")
+    if notebook_path.suffix != ".ipynb":
+        raise ValueError(f"Expected a notebook path ending in .ipynb: {notebook_rel}")
+
+
+def manifest_notebook_paths(manifest_path: Path, mode: str) -> list[Path]:
+    manifest = load_json(manifest_path)
+    enabled, disabled = manifest_sets(manifest)
+    if mode == "enabled":
+        notebook_rels = enabled
+    elif mode == "unclassified":
+        notebook_rels = discovered_notebooks() - enabled - set(disabled)
+    else:  # pragma: no cover - internal guard
+        raise ValueError(f"Unknown notebook selection mode: {mode}")
+    return sorted((REPO_ROOT / notebook_rel).resolve() for notebook_rel in notebook_rels)
+
+
+def harden_batch(
+    notebook_paths: list[Path],
+    manifest_path: Path,
+) -> tuple[list[str], list[tuple[str, str]]]:
+    successes: list[str] = []
+    failures: list[tuple[str, str]] = []
+
+    for notebook_path in notebook_paths:
+        notebook_rel = notebook_path.relative_to(REPO_ROOT).as_posix()
+        try:
+            validate_target_notebook(notebook_path, notebook_rel)
+            harden_notebook(notebook_path, manifest_path)
+            successes.append(notebook_rel)
+        except Exception as exc:
+            summary = error_summary(exc)
+            failures.append((notebook_rel, summary))
+
+    return successes, failures
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Harden a demo notebook for Colab and enable it in the Colab manifest."
+    )
+    parser.add_argument(
+        "--notebook",
+        help="Repo-relative path to the notebook to harden, e.g. demos/plot_proj_function.ipynb",
+    )
+    parser.add_argument(
+        "--all-unclassified",
+        action="store_true",
+        help="Attempt to harden every notebook under demos/ that is not yet listed in enabled or disabled.",
+    )
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Regenerate the Colab bootstrap for enabled notebook(s). Without --notebook, processes every enabled notebook.",
+    )
+    parser.add_argument(
+        "--manifest",
+        default=str(DEFAULT_MANIFEST),
+        help=f"Path to the Colab manifest (default: {DEFAULT_MANIFEST})",
+    )
+    args = parser.parse_args()
+    if args.notebook and args.all_unclassified:
+        parser.error("specify either --notebook or --all-unclassified, not both")
+    if args.all_unclassified and args.force:
+        parser.error("specify either --all-unclassified or --force, not both")
+    if not args.notebook and not args.all_unclassified and not args.force:
+        parser.error("specify --notebook, --all-unclassified, or --force")
+    return args
+
+
+def main() -> int:
+    args = parse_args()
+    manifest_path = Path(args.manifest).resolve()
+    if args.notebook:
+        notebook_path = (REPO_ROOT / args.notebook).resolve()
+        try:
+            validate_target_notebook(notebook_path, args.notebook)
+        except (FileNotFoundError, ValueError) as exc:
+            raise SystemExit(str(exc)) from exc
+        manifest = load_json(manifest_path)
+        enabled, disabled = manifest_sets(manifest)
+        notebook_rel = notebook_path.relative_to(REPO_ROOT).as_posix()
+        if notebook_rel in disabled:
+            raise SystemExit(
+                f"{notebook_rel} is already classified as disabled; update the manifest manually before reclassifying it."
+            )
+        if notebook_rel in enabled:
+            harden_notebook(notebook_path, manifest_path)
+            print(f"Hardened {notebook_rel} for Colab.")
+            return 0
+        try:
+            harden_notebook(notebook_path, manifest_path)
+            print(f"Hardened {notebook_rel} for Colab and added it to enabled.")
+            return 0
+        except Exception as exc:
+            summary = error_summary(exc)
+            print(
+                f"Could not harden {notebook_rel}; restored it and left it unclassified."
+            )
+            print(f"Reason: {summary}")
+            return 1
+
+    mode = "enabled" if args.force else "unclassified"
+    successes, failures = harden_batch(
+        manifest_notebook_paths(manifest_path, mode),
+        manifest_path,
+    )
+    for notebook_rel in successes:
+        print(f"Hardened {notebook_rel} for Colab.")
+    if failures:
+        print("")
+        print("Not yet hardened:")
+        for notebook_rel, error in failures:
+            print(f"- {notebook_rel}: {error}")
+    print("")
+    print(
+        f"Hardened {len(successes)} notebook(s); {len(failures)} notebook(s) still need manual follow-up."
+    )
+    return 0 if not failures else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/report_colab_notebook_patterns.py b/scripts/report_colab_notebook_patterns.py
new file mode 100644
index 000000000..2af0bd8f7
--- /dev/null
+++ b/scripts/report_colab_notebook_patterns.py
@@ -0,0 +1,164 @@
+#!/usr/bin/env python3
+"""
+Group demo notebooks by Colab badge/bootstrap cell pattern.
+"""
+
+from __future__ import annotations
+
+import argparse
+from collections import defaultdict
+from pathlib import Path
+
+from scripts.check_colab_notebooks import (
+    DEFAULT_MANIFEST,
+    REPO_ROOT,
+    cell_source_text,
+    is_any_badge_cell,
+    is_bootstrap_cell,
+    load_json,
+    manifest_sets,
+    validate_manifest,
+)
+
+def first_matching_cell(
+    cells: list[dict],
+    predicate,
+) -> tuple[int | None, str]:
+    for idx, cell in enumerate(cells, start=1):
+        if predicate(cell):
+            return idx, cell_source_text(cell)
+    return None, ""
+
+
+def extra_install_commands(source: str) -> list[str]:
+    commands: list[str] = []
+    for raw_line in source.splitlines():
+        line = raw_line.strip()
+        if not line.startswith("!pip install"):
+            continue
+        if "qmcpy" in line.lower():
+            continue
+        if " -q " in line:
+            commands.append(line.split(" -q ", 1)[1].strip())
+        else:
+            commands.append(line.split("!pip install", 1)[1].strip())
+    return commands
+
+
+def pattern_family(source: str) -> str:
+    if not source:
+        return "Enabled but missing bootstrap cell"
+
+    has_repo_clone = "git clone" in source
+    has_path_setup = "os.chdir(" in source or "sys.path.insert" in source
+    has_apt = "apt-get" in source
+    extra_installs = extra_install_commands(source)
+
+    if has_repo_clone and extra_installs:
+        return "Repo-local bootstrap + extra pip installs"
+    if has_repo_clone or has_path_setup:
+        return "Repo-local bootstrap"
+    if has_apt:
+        return "LaTeX bootstrap"
+    if extra_installs:
+        return "Extra pip bootstrap"
+    return "Basic qmcpy bootstrap"
+
+
+def placement_label(badge_position: int | None, bootstrap_position: int | None) -> str:
+    badge = "missing" if badge_position is None else str(badge_position)
+    bootstrap = "missing" if bootstrap_position is None else str(bootstrap_position)
+    return f"badge cell {badge}, bootstrap cell {bootstrap}"
+
+
+def print_grouped_notebooks(
+    title: str,
+    groups: dict[str, list[str]],
+    details: dict[str, dict[str, str]] | None = None,
+) -> None:
+    print(title)
+    for group_name in sorted(groups):
+        notebooks = sorted(groups[group_name])
+        print(f"- {group_name} ({len(notebooks)} notebooks)")
+        for notebook in notebooks:
+            suffix = ""
+            if details is not None:
+                detail = details.get(group_name, {}).get(notebook)
+                if detail:
+                    suffix = f" [{detail}]"
+            print(f"  - {notebook}{suffix}")
+    print()
+
+
+def run_report(manifest_path: Path) -> int:
+    manifest = load_json(manifest_path)
+    errors = validate_manifest(manifest)
+    if errors:
+        for error in errors:
+            print(error)
+        return 1
+
+    enabled, disabled = manifest_sets(manifest)
+
+    family_groups: dict[str, list[str]] = defaultdict(list)
+    placement_groups: dict[str, list[str]] = defaultdict(list)
+    family_details: dict[str, dict[str, str]] = defaultdict(dict)
+
+    for notebook_path in sorted(enabled):
+        payload = load_json(REPO_ROOT / notebook_path)
+        cells = payload.get("cells", [])
+        badge_position, _ = first_matching_cell(cells, is_any_badge_cell)
+        bootstrap_position, bootstrap_source = first_matching_cell(
+            cells, is_bootstrap_cell
+        )
+        family = pattern_family(bootstrap_source)
+        placement = placement_label(badge_position, bootstrap_position)
+        extra_installs = extra_install_commands(bootstrap_source)
+
+        family_groups[family].append(notebook_path)
+        placement_groups[placement].append(notebook_path)
+
+        if extra_installs:
+            family_details[family][notebook_path] = ", ".join(extra_installs)
+
+    disabled_groups: dict[str, list[str]] = defaultdict(list)
+    for notebook_path, reason in sorted(disabled.items()):
+        disabled_groups[reason].append(notebook_path)
+
+    total = len(enabled) + len(disabled)
+    print("Colab notebook pattern report")
+    print(f"Manifest: {manifest_path.relative_to(REPO_ROOT).as_posix()}")
+    print(f"Enabled: {len(enabled)}")
+    print(f"Disabled: {len(disabled)}")
+    print(f"Total: {total}")
+    print()
+
+    print_grouped_notebooks(
+        "Enabled pattern families",
+        family_groups,
+        details=family_details,
+    )
+    print_grouped_notebooks("Badge/bootstrap placement", placement_groups)
+    print_grouped_notebooks("Disabled notebooks by reason", disabled_groups)
+    return 0
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Group demo notebooks by Colab badge/bootstrap cell pattern."
+    )
+    parser.add_argument(
+        "--manifest",
+        default=str(DEFAULT_MANIFEST),
+        help=f"Path to the Colab manifest (default: {DEFAULT_MANIFEST})",
+    )
+    return parser.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    return run_report(Path(args.manifest).resolve())
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/smoke_test_colab_notebooks.py b/scripts/smoke_test_colab_notebooks.py
new file mode 100644
index 000000000..c0e447a60
--- /dev/null
+++ b/scripts/smoke_test_colab_notebooks.py
@@ -0,0 +1,379 @@
+#!/usr/bin/env python3
+"""
+Run lightweight Colab readiness smoke tests for enabled demo notebooks.
+
+This executes a temporary notebook prefix consisting of:
+- a prelude cell that fakes ``google.colab``
+- the notebook's Colab bootstrap cell (with shell installs rewritten to no-ops)
+- up to a few smoke-safe import/setup code cells after the bootstrap cell
+
+The goal is to catch runtime import/path/setup regressions in CI without
+executing entire notebooks or re-running heavyweight package installs.
+"""
+
+from __future__ import annotations
+
+import argparse
+import ast
+import copy
+import json
+import os
+import re
+import tempfile
+from pathlib import Path
+
+from scripts.check_colab_notebooks import (
+    DEFAULT_MANIFEST,
+    cell_source_text,
+    is_bootstrap_cell,
+    load_json,
+    python_source_for_ast,
+)
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+def make_prelude_cell(notebook_path: Path) -> dict:
+    notebook_dir = notebook_path.parent.resolve().as_posix()
+    repo_root = REPO_ROOT.resolve().as_posix()
+    source = f"""import os
+import sys
+import types
+
+google = sys.modules.get("google")
+if google is None:
+    google = types.ModuleType("google")
+    sys.modules["google"] = google
+
+colab = types.ModuleType("google.colab")
+google.colab = colab
+sys.modules["google.colab"] = colab
+
+os.environ["QMC_COLAB_SMOKE"] = "1"
+os.environ["QMC_COLAB_SMOKE_REPO_ROOT"] = r"{repo_root}"
+os.environ["QMC_COLAB_SMOKE_NOTEBOOK_DIR"] = r"{notebook_dir}"
+"""
+    return {
+        "cell_type": "code",
+        "execution_count": None,
+        "id": "smoke-prelude",
+        "metadata": {},
+        "outputs": [],
+        "source": source,
+    }
+
+
+def rewrite_shell_magics(source: str) -> str:
+    rewritten_lines: list[str] = []
+    for line in source.splitlines(keepends=True):
+        stripped = line.lstrip()
+        indent = line[: len(line) - len(stripped)]
+        if stripped.startswith("!"):
+            command = stripped[1:].rstrip()
+            rewritten_lines.append(f"{indent}print({command!r})\n")
+        else:
+            rewritten_lines.append(line)
+    return "".join(rewritten_lines)
+
+
+def rewrite_bootstrap_source(source: str) -> str:
+    repo_root = REPO_ROOT.resolve().as_posix()
+    source = source.replace('"/content/QMCSoftware"', repr(repo_root))
+    source = source.replace("'/content/QMCSoftware'", repr(repo_root))
+    return rewrite_shell_magics(source)
+
+
+def assignment_target_is_smoke_safe(node: ast.AST) -> bool:
+    if isinstance(node, ast.Name):
+        return True
+    if isinstance(node, (ast.Tuple, ast.List)):
+        return all(assignment_target_is_smoke_safe(elt) for elt in node.elts)
+    if isinstance(node, ast.Attribute):
+        return expression_is_smoke_safe(node.value)
+    if isinstance(node, ast.Subscript):
+        return expression_is_smoke_safe(node.value) and expression_is_smoke_safe(node.slice)
+    return False
+
+
+def expression_is_smoke_safe(node: ast.AST | None) -> bool:
+    if node is None:
+        return True
+    if isinstance(node, (ast.Constant, ast.Name)):
+        return True
+    if isinstance(node, ast.Attribute):
+        return expression_is_smoke_safe(node.value)
+    if isinstance(node, ast.Tuple):
+        return all(expression_is_smoke_safe(elt) for elt in node.elts)
+    if isinstance(node, ast.List):
+        return all(expression_is_smoke_safe(elt) for elt in node.elts)
+    if isinstance(node, ast.Set):
+        return all(expression_is_smoke_safe(elt) for elt in node.elts)
+    if isinstance(node, ast.Dict):
+        return all(
+            expression_is_smoke_safe(key) and expression_is_smoke_safe(value)
+            for key, value in zip(node.keys, node.values)
+        )
+    if isinstance(node, ast.UnaryOp):
+        return expression_is_smoke_safe(node.operand)
+    if isinstance(node, ast.BinOp):
+        return expression_is_smoke_safe(node.left) and expression_is_smoke_safe(node.right)
+    if isinstance(node, ast.BoolOp):
+        return all(expression_is_smoke_safe(value) for value in node.values)
+    if isinstance(node, ast.Compare):
+        return expression_is_smoke_safe(node.left) and all(
+            expression_is_smoke_safe(comparator) for comparator in node.comparators
+        )
+    if isinstance(node, ast.Subscript):
+        return expression_is_smoke_safe(node.value) and expression_is_smoke_safe(node.slice)
+    if isinstance(node, ast.Slice):
+        return (
+            expression_is_smoke_safe(node.lower)
+            and expression_is_smoke_safe(node.upper)
+            and expression_is_smoke_safe(node.step)
+        )
+    if isinstance(node, ast.IfExp):
+        return (
+            expression_is_smoke_safe(node.test)
+            and expression_is_smoke_safe(node.body)
+            and expression_is_smoke_safe(node.orelse)
+        )
+    if isinstance(node, ast.JoinedStr):
+        return all(
+            expression_is_smoke_safe(value.value)
+            if isinstance(value, ast.FormattedValue)
+            else expression_is_smoke_safe(value)
+            for value in node.values
+        )
+    if isinstance(node, ast.FormattedValue):
+        return expression_is_smoke_safe(node.value)
+    return False
+
+
+def statement_is_smoke_safe(node: ast.stmt) -> bool:
+    if isinstance(node, (ast.Import, ast.ImportFrom, ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef, ast.Pass)):
+        return True
+    if isinstance(node, ast.Assign):
+        return all(assignment_target_is_smoke_safe(target) for target in node.targets) and expression_is_smoke_safe(node.value)
+    if isinstance(node, ast.AnnAssign):
+        return assignment_target_is_smoke_safe(node.target) and expression_is_smoke_safe(node.value)
+    if isinstance(node, ast.AugAssign):
+        return assignment_target_is_smoke_safe(node.target) and expression_is_smoke_safe(node.value)
+    if isinstance(node, ast.Expr):
+        return expression_is_smoke_safe(node.value)
+    if isinstance(node, ast.Try):
+        return (
+            all(statement_is_smoke_safe(stmt) for stmt in node.body)
+            and all(
+                expression_is_smoke_safe(handler.type)
+                and all(statement_is_smoke_safe(stmt) for stmt in handler.body)
+                for handler in node.handlers
+            )
+            and all(statement_is_smoke_safe(stmt) for stmt in node.orelse)
+            and all(statement_is_smoke_safe(stmt) for stmt in node.finalbody)
+        )
+    if isinstance(node, ast.If):
+        return (
+            expression_is_smoke_safe(node.test)
+            and all(statement_is_smoke_safe(stmt) for stmt in node.body)
+            and all(statement_is_smoke_safe(stmt) for stmt in node.orelse)
+        )
+    return False
+
+
+def is_smoke_safe_code_cell(source: str) -> bool:
+    cleaned = python_source_for_ast(source)
+    if not cleaned.strip():
+        return True
+    try:
+        tree = ast.parse(cleaned)
+    except SyntaxError:
+        return False
+    return all(statement_is_smoke_safe(statement) for statement in tree.body)
+
+
+def build_smoke_notebook(notebook_path: Path, cells_after_bootstrap: int) -> tuple[dict, list[int | None]]:
+    with notebook_path.open(encoding="utf-8") as handle:
+        original_nb = json.load(handle)
+
+    bootstrap_idx = next(
+        (idx for idx, cell in enumerate(original_nb["cells"]) if is_bootstrap_cell(cell)),
+        None,
+    )
+    if bootstrap_idx is None:
+        raise RuntimeError("missing Colab bootstrap cell")
+
+    stop_idx = bootstrap_idx
+    safe_code_cells = 0
+    for idx in range(bootstrap_idx + 1, len(original_nb["cells"])):
+        cell = original_nb["cells"][idx]
+        if cell.get("cell_type") != "code":
+            stop_idx = idx
+            continue
+        if safe_code_cells >= cells_after_bootstrap:
+            break
+        if not is_smoke_safe_code_cell(cell_source_text(cell)):
+            break
+        safe_code_cells += 1
+        stop_idx = idx
+
+    temp_cells = [make_prelude_cell(notebook_path)]
+    source_indices: list[int | None] = [None]
+
+    for idx, cell in enumerate(original_nb["cells"][: stop_idx + 1]):
+        cloned = copy.deepcopy(cell)
+        cloned["id"] = f"smoke-{idx}"
+        if cloned.get("cell_type") == "code":
+            cloned["source"] = rewrite_bootstrap_source(cell_source_text(cloned))
+            cloned["execution_count"] = None
+            cloned["outputs"] = []
+        temp_cells.append(cloned)
+        source_indices.append(idx)
+
+    smoke_nb = {
+        "cells": temp_cells,
+        "metadata": copy.deepcopy(original_nb.get("metadata", {})),
+        "nbformat": original_nb.get("nbformat", 4),
+        "nbformat_minor": original_nb.get("nbformat_minor", 5),
+    }
+    return smoke_nb, source_indices
+
+
+def execute_smoke_notebook(notebook_path: Path, smoke_nb: dict, source_indices: list[int | None], timeout: int) -> None:
+    try:
+        from testbook import testbook
+    except ImportError as exc:  # pragma: no cover - depends on the local environment
+        raise RuntimeError(
+            "testbook is required for Colab smoke tests. "
+            "Install test dependencies, e.g. `pip install -e .[test]`."
+        ) from exc
+
+    notebook_dir = notebook_path.parent.resolve()
+    with tempfile.NamedTemporaryFile(
+        suffix=".ipynb",
+        prefix=".tmp_colab_smoke_",
+        dir=notebook_dir,
+        delete=False,
+    ) as handle:
+        temp_path = Path(handle.name)
+
+    try:
+        with temp_path.open("w", encoding="utf-8") as handle:
+            json.dump(smoke_nb, handle)
+
+        original_cwd = Path.cwd()
+        try:
+            os.chdir(notebook_dir)
+            with testbook(temp_path.as_posix(), timeout=timeout, execute=False) as tb:
+                for temp_idx, cell in enumerate(tb.cells):
+                    if cell.cell_type != "code":
+                        continue
+                    try:
+                        tb.execute_cell(temp_idx)
+                    except Exception as exc:  # noqa: BLE001
+                        source_idx = source_indices[temp_idx]
+                        if source_idx is None:
+                            location = "prelude cell"
+                        else:
+                            location = f"notebook cell {source_idx + 1}"
+                        detail = (str(exc).strip().splitlines() or ["(no message)"])[-1]
+                        detail = re.sub(r"\x1b\[[0-9;]*m", "", detail)  # strip ANSI from tracebacks
+                        raise RuntimeError(
+                            f"Colab smoke failed in {location}: {type(exc).__name__}: {detail}"
+                        ) from exc
+        finally:
+            os.chdir(original_cwd)
+    finally:
+        if temp_path.exists():
+            temp_path.unlink()
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Run lightweight Colab readiness smoke tests for enabled notebooks."
+    )
+    parser.add_argument(
+        "--manifest",
+        default=str(DEFAULT_MANIFEST),
+        help=f"Path to the Colab manifest (default: {DEFAULT_MANIFEST})",
+    )
+    parser.add_argument(
+        "--cells-after-bootstrap",
+        type=int,
+        default=2,
+        help="Maximum number of smoke-safe code cells to execute after the bootstrap cell (default: 2)",
+    )
+    parser.add_argument(
+        "--timeout",
+        type=int,
+        default=600,
+        help="Per-notebook execution timeout in seconds (default: 600)",
+    )
+    parser.add_argument(
+        "--notebook",
+        action="append",
+        default=[],
+        help="Optional manifest-relative notebook path to smoke test. May be passed multiple times.",
+    )
+    return parser.parse_args()
+
+
+def smoke_test_batch(
+    notebook_rels: list[str], cells_after_bootstrap: int, timeout: int
+) -> tuple[list[str], list[tuple[str, str]]]:
+    passed: list[str] = []
+    failed: list[tuple[str, str]] = []
+    for notebook_rel in notebook_rels:
+        notebook_path = (REPO_ROOT / notebook_rel).resolve()
+        print(f"Smoke testing {notebook_rel}")
+        try:
+            smoke_nb, source_indices = build_smoke_notebook(
+                notebook_path, cells_after_bootstrap
+            )
+            execute_smoke_notebook(
+                notebook_path, smoke_nb, source_indices, timeout=timeout
+            )
+        except Exception as exc:  # noqa: BLE001
+            reason = str(exc).strip() or type(exc).__name__
+            failed.append((notebook_rel, reason))
+        else:
+            passed.append(notebook_rel)
+    return passed, failed
+
+
+def main() -> int:
+    args = parse_args()
+    manifest_path = Path(args.manifest).resolve()
+    manifest = load_json(manifest_path)
+    enabled = list(manifest.get("enabled", []))
+
+    if args.notebook:
+        enabled = [path for path in enabled if path in set(args.notebook)]
+
+    if not enabled:
+        print("No enabled notebooks selected for Colab smoke tests.")
+        return 0
+
+    try:
+        import testbook  # noqa: F401
+    except ImportError:
+        print(
+            "testbook is required for Colab smoke tests. "
+            "Install test dependencies, e.g. `pip install -e .[test]`."
+        )
+        return 1
+
+    passed, failed = smoke_test_batch(enabled, args.cells_after_bootstrap, args.timeout)
+
+    if failed:
+        print("")
+        print("Failed:")
+        for notebook_rel, reason in failed:
+            print(f"- {notebook_rel}: {reason}")
+    print("")
+    print(
+        f"Colab smoke tests: {len(passed)} passed, {len(failed)} failed, {len(enabled)} total."
+    )
+    return 0 if not failed else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/test/README.md b/test/README.md
index d77d83930..be50051ed 100644
--- a/test/README.md
+++ b/test/README.md
@@ -14,6 +14,13 @@ This document describes the available test targets in the Makefile for QMCSoftwa
 | `make doctests` | All doctests with Docker | Slow | Full docstring validation |
 | `make booktests_no_docker` | Jupyter notebook tests | Slow | Validate demo notebooks |
 | `make booktests_parallel_no_docker` | Notebook tests with Parsl parallelization | Variable | Distributed notebook execution |
+| `make check_colab_notebooks` | Audit enabled notebooks for Colab-readiness | Fast | Catch missing pip installs, repo-local imports, and source-install drift |
+| `make check_colab_notebooks_smoke` | Execute Colab notebook setup smoke tests | Fast | Run bootstrap plus early import/setup cells for enabled notebooks |
+| `make harden_colab_notebook [NOTEBOOK=...]` | Insert Colab bootstrap and classify notebook(s) | Fast | Harden one notebook, or attempt to harden unclassified demo notebooks |
+| `make report_colab_notebook_patterns` | Group notebooks by Colab bootstrap family | Fast | Audit which notebooks use basic, extra-pip, LaTeX, or repo-local setup cells |
+| `make open_colab_notebook NOTEBOOK=...` | Open a notebook in Colab from the current branch | Fast | Preview branch-only notebook changes in Colab before merge |
+| `make open_colab_notebook_gist NOTEBOOK=...` | Upload the working-tree notebook to a secret gist and open it in Colab | Fast | Preview uncommitted notebook edits in Colab (needs `gh`) |
+| `make open_notebook NOTEBOOK=...` | Open the working-tree notebook in local JupyterLab | Instant | Edit/run a demo notebook locally with full repo context |
 | `make coverage` | Display coverage report | Instant | View test coverage summary |
 | `make delcoverage` | Reset coverage tracking | Instant | Start fresh coverage analysis |
 
@@ -195,11 +202,6 @@ Runs notebook tests with **Parsl distributed parallelization** for compute-heavy
 - **Dependencies**: Parsl must be installed and configured
 - **Use when**: Running large notebook suites with distributed compute resources
 
-#### `make tests_parallel_no_docker`
-Runs only unit tests with parallel pytest workers (no doctests or booktests).
-- **Time**: ~13–20 seconds
-- **Coverage**: Incremental
-- **Use when**: Testing unit tests only in parallel mode
 
 ---
 
@@ -215,6 +217,72 @@ Auto-generates missing test stub files for notebooks.
 - **Output**: Reports any generated files
 - **Note**: Called automatically by `booktests_no_docker`; rarely used standalone
 
+#### `make check_colab_notebooks`
+Runs the strict static Colab-readiness checks.
+- **Behavior**: Validates the manifest, badge and bootstrap placement, early dependencies, and repo-local imports
+- **Use when**: You change a demo notebook or its Colab setup
+
+#### `make check_colab_notebooks_smoke`
+Runs a lightweight execution smoke test for each Colab-enabled notebook.
+- **Execution scope**: Simulates a Colab runtime, rewrites shell install commands to no-ops, then executes the bootstrap cell plus up to `$(SMOKE_CODE_CELLS)` smoke-safe import/setup code cells
+- **Purpose**: Catch runtime regressions in early import/setup logic that static checks miss
+- **CI usage**: Invoked in Linux CI after test dependencies are installed
+- **Default depth**: `SMOKE_CODE_CELLS=2`
+
+#### `make harden_colab_notebook [NOTEBOOK=...]`
+Hardens one notebook, or if `NOTEBOOK` is omitted, scans `demos/` for notebooks that are not yet listed in either `enabled` or `disabled`.
+- **What it does**: Inserts the badge, adds a generated Colab bootstrap cell, infers common extra pip dependencies, and adds repo-local `sys.path` setup when needed
+- **Classification rule**: Existing `disabled` entries are left untouched; unclassified notebooks are added to `enabled` only after hardening validates. Failures remain unclassified for manual review
+- **Force mode**: `make harden_colab_notebook FORCE=1` regenerates the Open in Colab badge and the `# @title Execute this cell to install dependencies` cell for every notebook already listed in `enabled`; `make harden_colab_notebook NOTEBOOK=... FORCE=1` does the same for one notebook
+- **Cell order**: The generated `import google.colab` bootstrap cell is always inserted after the Open in Colab badge
+- **Validation**: Runs the existing Colab checks after rewriting; if validation fails, the notebook and manifest are restored and the failure is reported
+- **Examples**: `make harden_colab_notebook NOTEBOOK=demos/plot_proj_function.ipynb`, `make harden_colab_notebook`, and `make harden_colab_notebook FORCE=1`
+
+#### `make report_colab_notebook_patterns`
+Groups notebooks already classified in `scripts/colab_notebooks_manifest.json` by the current Colab badge/bootstrap cell pattern.
+- **Pattern families**: Reports basic `qmcpy`-only bootstrap cells, extra-pip variants, LaTeX setup cells, repo-clone/path-setup cells, and disabled notebooks grouped by reason
+- **Dependency details**: Lists extra install commands for notebooks that need more than `qmcpy`
+- **Placement summary**: Reports where the badge and bootstrap cells appear, for example `badge cell 1, bootstrap cell 2`
+- **Use when**: You want to batch-normalize notebook Colab setup or review which notebooks will be affected by bootstrap changes
+
+Every enabled notebook, grouped by its Colab bootstrap pattern family (regenerate with `make report_colab_notebook_patterns`):
+
+- **Basic qmcpy bootstrap** (28): [acceptance_rejection.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/acceptance_rejection.ipynb), [asian-option-mlqmc.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/asian-option-mlqmc.ipynb), [brownian_bridge.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/brownian_bridge.ipynb), [control_variates.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/control_variates.ipynb), [copula_examples.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/copula_examples.ipynb), [Iteration_Log_Tolerance_Demo.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/demo_resume_data/Iteration_Log_Tolerance_Demo.ipynb), [digital_net_b2.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/digital_net_b2.ipynb), [gaussian_diagnostics_demo.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/gaussian_diagnostics/gaussian_diagnostics_demo.ipynb), [korobov_hammersley_latinhypercube_demos.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/korobov_hammersley_latinhypercube_demos.ipynb), [lattice_random_generator.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/lattice_random_generator.ipynb), [lebesgue_integration.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/lebesgue_integration.ipynb), [linear-scrambled-halton.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/linear-scrambled-halton.ipynb), [nei_demo.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/nei_demo.ipynb), [plot_proj_function.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/plot_proj_function.ipynb), [pricing_options.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/pricing_options.ipynb), [product_measure.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/product_measure.ipynb), [qei-demo-for-blog.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/qei-demo-for-blog.ipynb), [qmcpy-logo.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/qmcpy-logo.ipynb), [qmcpy_intro.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/qmcpy_intro.ipynb), [quickstart.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/quickstart.ipynb), [ray_tracing.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/ray_tracing.ipynb), [sample_scatter_plots.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/sample_scatter_plots.ipynb), [scipywrapper_demo.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/scipywrapper_dependence_custom/scipywrapper_demo.ipynb), [some_true_measures.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/some_true_measures.ipynb), [statistics_for_TrueMeasure.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/statistics_for_TrueMeasure.ipynb), [sorokin_thesis_2025.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/SorokinThesis2025/sorokin_thesis_2025.ipynb), [pydata_chi_2023.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/pydata_chi_2023.ipynb), [why_add_q_to_mc_blog.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/why_add_q_to_mc_blog/why_add_q_to_mc_blog.ipynb)
+- **Extra pip bootstrap** (4): [iris.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/iris.ipynb), [joss2026.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/JOSS2026/joss2026.ipynb), [MCQMC_2020_QMC_Software_Tutorial.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/MCQMC_Tutorial_2020/MCQMC_2020_QMC_Software_Tutorial.ipynb), [Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026/Sorokin_random_LD_seq_QMC_fast_kernel_methods_2026.ipynb)
+- **LaTeX bootstrap** (4): [dakota_genz.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/DAKOTA_Genz/dakota_genz.ipynb), [elliptic-pde.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/elliptic-pde.ipynb), [vectorized_qmc.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/vectorized_qmc.ipynb), [vectorized_qmc_bayes.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/vectorized_qmc_bayes.ipynb)
+- **Repo-local bootstrap** (7): [gbm_examples.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/GBM/gbm_examples.ipynb), [accuracy_and_resume.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/demo_resume_data/accuracy_and_resume.ipynb), [resume_examples.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/demo_resume_data/resume_examples.ipynb), [01_sequential.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Parslfest_2025/01_sequential.ipynb), [02_parallel.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Parslfest_2025/02_parallel.ipynb), [03_visualize_speedup.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Parslfest_2025/03_visualize_speedup.ipynb), [01_sequential_output.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/talk_paper_demos/Parslfest_2025/output/01_sequential_output.ipynb)
+- **Repo-local bootstrap + extra pip installs** (1): [gbm_demo.ipynb](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/GBM/gbm_demo.ipynb)
+
+### Opening a demo notebook
+
+| Target | Notebook source | Opens in | Requires |
+|--------|-----------------|----------|----------|
+| `make open_notebook` | working tree | local JupyterLab | `jupyterlab` |
+| `make open_colab_notebook` | `origin/<branch>` (or `<base>` when unchanged) | Google Colab | branch + notebook pushed to `origin` |
+| `make open_colab_notebook_gist` | working tree | Google Colab | `gh` CLI |
+
+#### `make open_colab_notebook NOTEBOOK=demos/<path>.ipynb`
+Opens a demo notebook in Google Colab from the **current git branch** instead of the committed `develop` badge URL, so you can preview branch-only notebook changes in Colab before they merge.
+- **When it uses the branch**: The Colab link points at the current branch when the notebook is new on the branch, or when its content on `origin/<branch>` differs from `origin/<base>`; otherwise it opens the `<base>` version, since the committed badge already covers that case
+- **Requires a push**: Colab loads notebooks from GitHub, so the branch and the notebook must already be pushed to `origin`; the target stops with a hint if they are not, and warns when your local working copy differs from what is pushed
+- **Base branch**: The comparison base is `COLAB_BASE` (default `develop`) and must itself be a branch on `origin`
+- **Output**: Prints the `https://colab.research.google.com/github/<owner>/<repo>/blob/<ref>/<path>` URL and opens it with `python -m webbrowser`
+- **Examples**: `make open_colab_notebook NOTEBOOK=demos/nei_demo.ipynb`, `make open_colab_notebook NOTEBOOK=demos/GBM/gbm_demo.ipynb COLAB_BASE=master`
+
+#### `make open_colab_notebook_gist NOTEBOOK=demos/<path>.ipynb`
+Uploads the **working-tree** copy of a notebook to a throwaway secret GitHub gist and opens that gist in Colab, so you can preview uncommitted edits without pushing to a branch.
+- **Requires**: The [`gh` CLI](https://cli.github.com), authenticated with `gh auth login`
+- **What it prints**: The gist URL, the `https://colab.research.google.com/gist/<login>/<id>/<file>` URL (also opened with `python -m webbrowser`), and the `gh gist delete <id>` cleanup command
+- **Gist visibility**: "secret" means unlisted, not private; delete it when finished
+- **Limitation**: A gist is a single file, so sibling `.py` helpers and repo-local imports will not resolve; the bootstrap cell's `git clone` falls back to `develop`. Use `make open_colab_notebook` for notebooks that depend on repo files
+- **Example**: `make open_colab_notebook_gist NOTEBOOK=demos/quickstart.ipynb`
+
+#### `make open_notebook NOTEBOOK=demos/<path>.ipynb`
+Opens the working-tree notebook in local JupyterLab (`jupyter lab <path>`, falling back to `python -m jupyterlab`).
+- **Use when**: You want to edit or run a demo notebook locally with the current source install, helper files, and uncommitted changes all in place
+- **Note**: Runs the Lab server in the foreground; stop it with `Ctrl+C`
+- **Example**: `make open_notebook NOTEBOOK=demos/quickstart.ipynb`
+
 #### `make coverage`
 Displays the current coverage report (must run other targets first to accumulate coverage data).
 - **Output**: Terminal summary of coverage percentages per file/module
@@ -224,15 +292,6 @@ Displays the current coverage report (must run other targets first to accumulate
 Deletes `.coverage` and `coverage.json` files to reset coverage tracking.
 - **Use before**: Running a fresh coverage report without accumulated data
 
-## Redundancy Analysis & Status
-
-### Removed Redundant Target ✅
-
-#### `make tests_parallel_no_docker` (REMOVED)
-- **Was redundant**: Ran only unit tests in parallel. `make tests_fast` is a strict superset (doctests + unittests + booktests in parallel).
-- **Status**: **Removed from Makefile** to simplify maintenance and reduce user confusion.
-- **Migration**: Users should use `make tests_fast` instead (faster, more comprehensive).
-
 ---
 
 ## Currently Active Targets: Justification
@@ -458,4 +517,4 @@ A second workflow, `.github/workflows/unittests.yml`, runs a matrix across Pytho
 - `.github/workflows/alltests.yml` – CI all test workflow
 - `.github/workflows/unittests.yml` - CI unit test workflow
 - `make clean_local_only_files` – Artifact cleanup utility
-- `scripts/pytest_xdist.py` – Parallel execution detection helper
\ No newline at end of file
+- `scripts/pytest_xdist.py` – Parallel execution detection helper
diff --git a/test/booktests/__init__.py b/test/booktests/__init__.py
index 2ad77b1fe..a28ec9790 100644
--- a/test/booktests/__init__.py
+++ b/test/booktests/__init__.py
@@ -3,18 +3,27 @@
 Each tb_*.py file tests a single demo notebook.
 """
 
-import unittest, gc
-from pathlib import Path
-import psutil
 import gc
-import time
 import os
 import subprocess
 import sys
+import tempfile
+import time
+import unittest
+import uuid
+from pathlib import Path
+
+import psutil
 from testbook import testbook
 import nbformat
+
+if os.name == "nt":
+    worker_id = os.environ.get("PYTEST_XDIST_WORKER", "main")
+    mpl_config_dir = Path(tempfile.gettempdir()) / "qmcpy-matplotlib" / worker_id
+    mpl_config_dir.mkdir(parents=True, exist_ok=True)
+    os.environ.setdefault("MPLCONFIGDIR", str(mpl_config_dir))
+
 import matplotlib
-import uuid
 
 matplotlib.rcParams["text.usetex"] = False  # Disable LaTeX
 
diff --git a/test/test_colab_notebooks.py b/test/test_colab_notebooks.py
new file mode 100644
index 000000000..858c4c4b9
--- /dev/null
+++ b/test/test_colab_notebooks.py
@@ -0,0 +1,314 @@
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+
+import pytest
+
+from scripts import check_colab_notebooks as check
+from scripts import harden_colab_notebook as harden
+from scripts import smoke_test_colab_notebooks as smoke
+
+
+def markdown_cell(source: str, cell_id: str = "markdown") -> dict:
+    return {
+        "cell_type": "markdown",
+        "id": cell_id,
+        "metadata": {},
+        "source": source.splitlines(keepends=True),
+    }
+
+
+def code_cell(source: str, cell_id: str = "code") -> dict:
+    return {
+        "cell_type": "code",
+        "execution_count": None,
+        "id": cell_id,
+        "metadata": {},
+        "outputs": [],
+        "source": source.splitlines(keepends=True),
+    }
+
+
+@pytest.fixture
+def colab_repo(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
+    demos_dir = tmp_path / "demos"
+    demos_dir.mkdir()
+    notebook_path = demos_dir / "example.ipynb"
+    notebook = {
+        "cells": [
+            markdown_cell("# Example\n", "title"),
+            code_cell("import math\n", "imports"),
+        ],
+        "metadata": {},
+        "nbformat": 4,
+        "nbformat_minor": 5,
+    }
+    notebook_path.write_text(json.dumps(notebook, indent=1) + "\n", encoding="utf-8")
+
+    manifest_path = tmp_path / "manifest.json"
+    manifest = {
+        "repo": "QMCSoftware/QMCSoftware",
+        "git_ref": "develop",
+        "enabled": [],
+        "disabled": {},
+    }
+    manifest_path.write_text(json.dumps(manifest, indent=1) + "\n", encoding="utf-8")
+
+    monkeypatch.setattr(check, "REPO_ROOT", tmp_path)
+    monkeypatch.setattr(check, "DEMOS_DIR", demos_dir)
+    monkeypatch.setattr(harden, "REPO_ROOT", tmp_path)
+    monkeypatch.setattr(smoke, "REPO_ROOT", tmp_path)
+    return notebook_path, manifest_path
+
+
+def test_badge_stripping_preserves_intro_and_drops_badge_only_cells():
+    intro = markdown_cell(
+        "# ML Sensitivity Indices\n\n"
+        "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)]"
+        "(https://colab.research.google.com/github/QMCSoftware/QMCSoftware/"
+        "blob/develop/demos/iris.ipynb)\n\n"
+        "This notebook demonstrates sensitivity indices.\n"
+    )
+    badge_only = markdown_cell(
+        "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)]"
+        "(https://colab.research.google.com/github/QMCSoftware/QMCSoftware/"
+        "blob/develop/demos/iris.ipynb)\n"
+    )
+
+    cleaned_intro = harden.badge_stripped_cell(intro)
+    assert cleaned_intro is not None
+    assert "# ML Sensitivity Indices" in check.cell_source_text(cleaned_intro)
+    assert "sensitivity indices" in check.cell_source_text(cleaned_intro)
+    assert "Open In Colab" not in check.cell_source_text(cleaned_intro)
+    assert harden.remove_any_badge_cells([badge_only, code_cell("pass\n")]) == [
+        code_cell("pass\n")
+    ]
+
+
+def test_is_any_badge_cell_rejects_spoofed_hostname():
+    spoofed = markdown_cell(
+        "[click](https://evil.example/colab.research.google.com/assets/colab-badge.svg)\n"
+    )
+    genuine = markdown_cell(
+        "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)]"
+        "(https://colab.research.google.com/github/QMCSoftware/QMCSoftware/"
+        "blob/develop/demos/iris.ipynb)\n"
+    )
+
+    assert not check.is_any_badge_cell(spoofed)
+    assert check.is_any_badge_cell(genuine)
+
+
+def test_bootstrap_detection_uses_marker_and_real_install_command(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+):
+    misleading = code_cell(
+        '"""import google.colab\n# @title Execute this cell to install dependencies\n'
+        '!pip install qmcpy\n"""\n'
+    )
+    comment_only = code_cell(
+        "# @title Execute this cell to install dependencies\n"
+        "# import google.colab\n"
+        "# !pip install qmcpy\n"
+    )
+    assert not check.is_any_install_cell(misleading)
+    assert not check.is_bootstrap_cell(misleading)
+    assert check.is_any_install_cell(comment_only)
+    assert not check.is_bootstrap_cell(comment_only)
+
+    monkeypatch.setattr(harden, "REPO_ROOT", tmp_path)
+    notebook_path = tmp_path / "demos" / "example.ipynb"
+    notebook_path.parent.mkdir()
+    source = "".join(
+        harden.bootstrap_cell_source(
+            notebook_path,
+            {"repo": "QMCSoftware/QMCSoftware"},
+            [],
+        )
+    )
+    generated = code_cell(source)
+    assert check.is_bootstrap_cell(generated)
+    assert "except ImportError:" in source
+    assert "if IN_COLAB:" in source
+    assert "except:\n" not in source
+    compile(smoke.rewrite_shell_magics(source), "<bootstrap>", "exec")
+
+
+def test_extra_pip_packages_preserves_later_explicit_installs():
+    cells = [
+        code_cell("import qmcpy as qp\n"),
+        code_cell("import ipywidgets as widgets\n"),
+        code_cell(
+            "try:\n"
+            "    import QuantLib as ql\n"
+            "except ModuleNotFoundError:\n"
+            "    !pip install -q QuantLib\n"
+        ),
+        code_cell("!pip install -q seaborn\n"),
+    ]
+
+    assert harden.extra_pip_packages(cells) == ["QuantLib", "ipywidgets", "seaborn"]
+
+
+def test_needs_latex_setup_detects_tueplots():
+    cells = [
+        code_cell("import qmcpy as qp\n"),
+        code_cell(
+            "from tueplots import bundles\n"
+            "pyplot.rcParams.update(bundles.probnum2025())\n"
+        ),
+    ]
+
+    assert harden.needs_latex_setup(cells)
+
+
+def test_imported_modules_survives_magic_only_block_body():
+    # A shell-magic line as the *only* statement in a block used to leave an
+    # empty `if:`/`try:` body, making ast.parse raise and silently hiding
+    # every import in the cell (not just the magic line itself).
+    source = (
+        "import os\n"
+        "from util import helper\n"
+        "if True:\n"
+        "    !echo hi\n"
+    )
+    assert check.imported_modules(source) == {"os", "util"}
+
+
+def test_local_module_matches_finds_ancestor_directory(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+):
+    monkeypatch.setattr(check, "DEMOS_DIR", tmp_path)
+    (tmp_path / "util.py").write_text("", encoding="utf-8")
+    notebook_dir = tmp_path / "output"
+    notebook_dir.mkdir()
+
+    matches = check.local_module_matches(notebook_dir, "util")
+
+    assert matches == [tmp_path / "util.py"]
+
+
+def test_extra_pip_packages_honors_colab_deps_marker():
+    cells = [
+        code_cell("import qmcpy as qp\n"),
+        code_cell(
+            "# colab-deps: plotly, some-package\n"
+            "import plotly\n"
+        ),
+    ]
+
+    assert harden.extra_pip_packages(cells) == ["plotly", "some-package"]
+
+
+def test_dump_notebook_preserves_existing_json_indent(tmp_path: Path):
+    notebook_path = tmp_path / "example.ipynb"
+    notebook = {
+        "cells": [code_cell("pass\n")],
+        "metadata": {},
+        "nbformat": 4,
+        "nbformat_minor": 5,
+    }
+    original_source = json.dumps(notebook, indent=2) + "\n"
+
+    harden.dump_notebook(notebook_path, notebook, original_source)
+
+    assert notebook_path.read_text(encoding="utf-8") == original_source
+
+
+def test_harden_check_smoke_round_trip_is_idempotent(
+    colab_repo, monkeypatch: pytest.MonkeyPatch
+):
+    notebook_path, manifest_path = colab_repo
+    harden.harden_notebook(notebook_path, manifest_path)
+
+    assert check.run_check(manifest_path, strict=True) == 0
+    smoke_notebook, source_indices = smoke.build_smoke_notebook(notebook_path, 1)
+    assert len(smoke_notebook["cells"]) == len(source_indices)
+
+    sentinel = object()
+    old_modules = {
+        name: sys.modules.get(name, sentinel) for name in ("google", "google.colab")
+    }
+    old_environment = {
+        name: os.environ.get(name, sentinel)
+        for name in ("QMC_COLAB_SMOKE", "QMC_COLAB_SMOKE_REPO_ROOT", "QMC_COLAB_SMOKE_NOTEBOOK_DIR")
+    }
+    namespace: dict = {}
+    try:
+        for cell in smoke_notebook["cells"]:
+            if cell["cell_type"] == "code":
+                exec(check.cell_source_text(cell), namespace)
+    finally:
+        for name, value in old_modules.items():
+            if value is sentinel:
+                sys.modules.pop(name, None)
+            else:
+                sys.modules[name] = value
+        for name, value in old_environment.items():
+            if value is sentinel:
+                os.environ.pop(name, None)
+            else:
+                os.environ[name] = value
+
+    monkeypatch.setattr(
+        harden,
+        "dump_notebook",
+        lambda *_args, **_kwargs: pytest.fail("unchanged notebook was rewritten"),
+    )
+    monkeypatch.setattr(
+        harden,
+        "dump_json",
+        lambda *_args, **_kwargs: pytest.fail("unchanged manifest was rewritten"),
+    )
+    harden.harden_notebook(notebook_path, manifest_path)
+
+
+def test_checker_rejects_wrong_badge(colab_repo):
+    notebook_path, manifest_path = colab_repo
+    harden.harden_notebook(notebook_path, manifest_path)
+    notebook = check.load_json(notebook_path)
+    badge = next(cell for cell in notebook["cells"] if check.is_any_badge_cell(cell))
+    badge["source"] = [check.cell_source_text(badge).replace("develop", "wrong-ref")]
+    notebook_path.write_text(json.dumps(notebook, indent=1) + "\n", encoding="utf-8")
+
+    assert check.run_check(manifest_path, strict=True) == 1
+
+
+def test_harden_failure_does_not_disable_notebook(
+    colab_repo, monkeypatch: pytest.MonkeyPatch
+):
+    notebook_path, manifest_path = colab_repo
+    original_manifest = manifest_path.read_text(encoding="utf-8")
+    monkeypatch.setattr(
+        harden,
+        "harden_notebook",
+        lambda *_args, **_kwargs: (_ for _ in ()).throw(RuntimeError("failure")),
+    )
+
+    successes, failures = harden.harden_batch([notebook_path], manifest_path)
+
+    assert successes == []
+    assert failures == [("demos/example.ipynb", "failure")]
+    assert manifest_path.read_text(encoding="utf-8") == original_manifest
+
+
+def test_smoke_batch_continues_after_a_notebook_failure(monkeypatch: pytest.MonkeyPatch):
+    def fake_build(notebook_path: Path, cells_after_bootstrap: int):
+        return {"cells": []}, []
+
+    def fake_execute(notebook_path: Path, smoke_nb, source_indices, timeout):
+        if "broken" in notebook_path.as_posix():
+            raise RuntimeError("boom")
+
+    monkeypatch.setattr(smoke, "build_smoke_notebook", fake_build)
+    monkeypatch.setattr(smoke, "execute_smoke_notebook", fake_execute)
+
+    passed, failed = smoke.smoke_test_batch(
+        ["demos/broken.ipynb", "demos/ok.ipynb"], cells_after_bootstrap=1, timeout=60
+    )
+
+    assert passed == ["demos/ok.ipynb"]
+    assert failed == [("demos/broken.ipynb", "boom")]
diff --git a/test/test_sc_accumulate_data.py b/test/test_sc_accumulate_data.py
index 8de9d3ebd..dc17f4f13 100644
--- a/test/test_sc_accumulate_data.py
+++ b/test/test_sc_accumulate_data.py
@@ -2,8 +2,15 @@
 from unittest.mock import patch
 
 import numpy as np
+import pytest
 
 from qmcpy import CubBayesNetG, DigitalNetB2, Keister
+
+# `pf_gp_ci` imports torch and gpytorch at module level, so skip rather than fail
+# collection where those optional stacks are absent (as test_dd_mpmc.py does).
+pytest.importorskip("torch")
+pytest.importorskip("gpytorch")
+
 from qmcpy.stopping_criterion.pf_gp_ci import PFGPCIData
 
 

From f7b0e1cb82c0dccd2b398c027c65d01bcd73b3e0 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Fri, 4 Sep 2026 16:05:23 +0800
Subject: [PATCH 06/51] Better format

---
 test/README.md | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/test/README.md b/test/README.md
index be50051ed..123556dcb 100644
--- a/test/README.md
+++ b/test/README.md
@@ -54,12 +54,7 @@ python -m pytest test/ -k test_tm_      # every true_measure test
 make unittests PYTEST_EXTRA_ARGS="-k test_sc_"
 ```
 
-When a test spans two areas (say a stopping criterion exercised against a
-particular kernel), file it under the component actually under test and name the
-other in `<topic>` — e.g. `test_sc_cubbayes_kernels.py`. Reserve `ee` for cases
-where neither side is the clear subject. Do not invent new area codes: only the
-prefixes in the table are accepted, and `make check_test_style STRICT=--strict`
-fails on anything else.
+When a test spans two areas (say a stopping criterion exercised against a particular kernel), file it under the component actually under test and name the other in `<topic>` — e.g. `test_sc_cubbayes_kernels.py`. Reserve `ee` for cases where neither side is the clear subject. Do not invent new area codes: only the prefixes in the table are accepted, and `make check_test_style STRICT=--strict` fails on anything else.
 
 Notebook tests are separate: they live in `test/booktests/` as `tb_*.py` and are generated from `demos/` (see `test/booktests/README.md`).
 

From 6cc1dc6075283cf0299cae866410495dbd55ab46 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Fri, 4 Sep 2026 16:05:45 +0800
Subject: [PATCH 07/51] + check docstring tools

---
 docs/good_practices.md     |   9 +++
 makefile                   |  30 +++++++
 scripts/check_docstring.py | 158 +++++++++++++++++++++++++++++++++++++
 3 files changed, 197 insertions(+)
 create mode 100644 scripts/check_docstring.py

diff --git a/docs/good_practices.md b/docs/good_practices.md
index d87ebc827..81013cbb3 100644
--- a/docs/good_practices.md
+++ b/docs/good_practices.md
@@ -41,6 +41,15 @@ QMCPy documentation is built from docstrings, so public APIs should document the
 - Document parameters, return values, shapes, assumptions, and any stochastic behavior.
 - Include short doctestable examples when they clarify expected use.
 - Update docstrings at the same time as the implementation so the rendered API docs do not drift from the code.
+- Put a blank line before every section header (`Args:`, `Returns:`, `Raises:`, `Examples:`, ...) and write the header as `Name:` — not a NumPy-style `Name` followed by an `-----` underline.
+
+* `make check_docstring` scans public objects under `qmcpy/` for these conventions (NumPy-style sections, a missing blank line before a section header, malformed headers, and public objects with no docstring). It is informational by default;
+    - `STRICT=--strict make check_docstring` makes it fail. Pass
+    - `CHECK_DOCSTRING_ARGS=--skip-missing` to report only the style problems and not
+    the objects that lack a docstring, or 
+    - `DOCSTRING_PATH=qmcpy/true_measure`
+    to narrow the scan.
+* `make check_docstring_changed` runs the same checks on just the `qmcpy/*.py` files that changed relative to `DOCSTRING_BASE` (default `develop`), which is the quick check to run before opening a PR.
 
 ## Extend the Existing Object Model
 
diff --git a/makefile b/makefile
index 7440be519..0cc361a04 100644
--- a/makefile
+++ b/makefile
@@ -51,6 +51,36 @@ TEST_STYLE_PATH ?= test
 check_test_style:
 	@$(PYTHON) scripts/check_test_style.py $(TEST_STYLE_PATH) $(STRICT)
 
+DOCSTRING_PATH ?= qmcpy
+# Check that public docstrings under qmcpy/ are Google style: no NumPy-style
+# "-----" section underlines, a blank line before every Args:/Returns:/Raises:/...
+# header, and canonical "Name:" section headers. Also flags public classes,
+# functions, and methods with no docstring (pass --skip-missing via
+# CHECK_DOCSTRING_ARGS to check style only). Informational by default; pass
+# --strict to make it fail (e.g. STRICT=--strict make check_docstring).
+check_docstring:
+	@$(PYTHON) scripts/check_docstring.py $(DOCSTRING_PATH) $(CHECK_DOCSTRING_ARGS) $(STRICT)
+
+DOCSTRING_BASE ?= develop
+# Same checks as check_docstring, but only on qmcpy/*.py files that changed
+# relative to DOCSTRING_BASE (committed, staged/unstaged, and untracked).
+check_docstring_changed:
+	@set -e; \
+	changed_files="$$( \
+		{ \
+			git diff --name-only --diff-filter=ACMR "$(DOCSTRING_BASE)...HEAD" -- 'qmcpy/*.py'; \
+			git diff --name-only --diff-filter=ACMR HEAD -- 'qmcpy/*.py'; \
+			git ls-files --others --exclude-standard -- 'qmcpy/*.py'; \
+		} | sort -u \
+	)"; \
+	if [ -z "$$changed_files" ]; then \
+		echo "No changed qmcpy/*.py files relative to $(DOCSTRING_BASE)."; \
+	else \
+		echo "Checking docstring style on changed qmcpy files relative to $(DOCSTRING_BASE):"; \
+		printf '%s\n' "$$changed_files"; \
+		$(PYTHON) scripts/check_docstring.py $$changed_files $(CHECK_DOCSTRING_ARGS) $(STRICT); \
+	fi
+
 ##########################################################
 # Doctests
 ##########################################################
diff --git a/scripts/check_docstring.py b/scripts/check_docstring.py
new file mode 100644
index 000000000..ccb943c46
--- /dev/null
+++ b/scripts/check_docstring.py
@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+"""Check that public docstrings under ``qmcpy/`` follow Google style.
+
+A *public* object is a module, or a class / function / method whose name does
+not start with ``_``.  Only module-level functions/classes and the methods of
+public classes are inspected (helpers nested inside functions are skipped).
+For every public docstring this script flags:
+
+* ``missing``                  -- public class / function / method has no
+                                  docstring (suppressed by ``--skip-missing``)
+* ``numpy-section``            -- a section written NumPy-style (``Returns``
+                                  followed by a ``-----`` underline) instead of
+                                  Google style (``Returns:``)
+* ``no-blank-before-section``  -- a Google section header (``Args:``,
+                                  ``Returns:``, ``Raises:``, ...) is not preceded
+                                  by a blank line
+* ``malformed-section-header`` -- a section word on its own line that is not the
+                                  canonical ``Name:`` form (missing colon, a
+                                  stray space before the colon, ...)
+
+Usage:
+    python scripts/check_docstring.py [PATH ...] [--strict] [--quiet] [--skip-missing]
+
+PATH defaults to ``qmcpy``.  Informational by default (exit 0); ``--strict``
+makes the exit code non-zero when anything is flagged, so it can gate CI
+(``STRICT=--strict make check_docstring``).
+"""
+from __future__ import annotations
+
+import ast
+import re
+import sys
+from pathlib import Path
+
+# Canonical Google section headers, written as ``Name:`` on their own line.
+GOOGLE_SECTIONS = {
+    "Args", "Arguments", "Attributes", "Example", "Examples", "Keyword Args",
+    "Note", "Notes", "Raises", "References", "Return", "Returns", "See Also",
+    "Todo", "Warning", "Warnings", "Warns", "Yield", "Yields",
+}
+# Section words that, followed by a dashed underline, mean the docstring is
+# using NumPy style rather than Google style.
+NUMPY_SECTIONS = {
+    "Parameters", "Other Parameters", "Returns", "Raises", "Yields",
+    "Attributes", "Notes", "Examples", "See Also", "References", "Warns",
+    "Warnings", "Methods",
+}
+_DASHES = re.compile(r"^-{3,}$")
+# Canonical header: capitalised word(s), a single colon, nothing else.
+_HEADER = re.compile(r"^([A-Z][A-Za-z]*(?: [A-Z][A-Za-z]*)*):$")
+
+
+def _iter_public(tree):
+    """Yield ``(node, kind)`` for the module plus its public API objects."""
+    yield tree, "module"
+    for node in tree.body:
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            if not node.name.startswith("_"):
+                yield node, "function"
+        elif isinstance(node, ast.ClassDef) and not node.name.startswith("_"):
+            yield node, "class"
+            for sub in node.body:
+                if isinstance(sub, (ast.FunctionDef, ast.AsyncFunctionDef)) \
+                        and not sub.name.startswith("_"):
+                    yield sub, "method"
+
+
+def _doc_node(node):
+    """Return the string-literal node holding ``node``'s docstring, or None."""
+    body = getattr(node, "body", None)
+    if (body and isinstance(body[0], ast.Expr)
+            and isinstance(body[0].value, ast.Constant)
+            and isinstance(body[0].value.value, str)):
+        return body[0].value
+    return None
+
+
+def check_file(path, skip_missing=False):
+    """Return a list of ``(lineno, category, detail)`` findings for one file."""
+    findings = []
+    tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+    for node, kind in _iter_public(tree):
+        dnode = _doc_node(node)
+        if dnode is None:
+            if kind != "module" and not skip_missing:
+                findings.append((
+                    getattr(node, "lineno", 1), "missing",
+                    f"public {kind} `{getattr(node, 'name', path.stem)}` has no docstring",
+                ))
+            continue
+        lines = dnode.value.split("\n")
+        for i, raw in enumerate(lines):
+            s = raw.strip()
+            if not s:
+                continue
+            word = s[:-1].strip() if s.endswith(":") else s
+            nxt = lines[i + 1].strip() if i + 1 < len(lines) else ""
+            if word in NUMPY_SECTIONS and _DASHES.match(nxt):
+                findings.append((
+                    dnode.lineno + i, "numpy-section",
+                    f"`{word}` written NumPy-style; use Google `{word}:`",
+                ))
+                continue
+            m = _HEADER.match(s)
+            if m and m.group(1) in GOOGLE_SECTIONS:
+                if i > 0 and lines[i - 1].strip() != "":
+                    findings.append((
+                        dnode.lineno + i, "no-blank-before-section",
+                        f"add a blank line before `{s}`",
+                    ))
+            elif word in GOOGLE_SECTIONS and not _DASHES.match(nxt):
+                findings.append((
+                    dnode.lineno + i, "malformed-section-header",
+                    f"`{s}` is not the canonical `{word}:` form",
+                ))
+    return findings
+
+
+def main(argv):
+    strict = "--strict" in argv
+    quiet = "--quiet" in argv
+    skip_missing = "--skip-missing" in argv
+    paths = [a for a in argv if not a.startswith("-")] or ["qmcpy"]
+
+    files = []
+    for p in map(Path, paths):
+        files.extend(sorted(p.rglob("*.py")) if p.is_dir() else [p])
+    if not files:
+        print(f"no *.py files under {', '.join(paths)}", file=sys.stderr)
+        return 1
+
+    total = 0
+    by_cat = {}
+    for f in files:
+        try:
+            findings = check_file(f, skip_missing=skip_missing)
+        except SyntaxError as exc:
+            print(f"{f.as_posix()}: skipped (syntax error: {exc})", file=sys.stderr)
+            continue
+        for lineno, cat, detail in findings:
+            by_cat[cat] = by_cat.get(cat, 0) + 1
+            total += 1
+            if not quiet:
+                print(f"{f.as_posix()}:{lineno}: {cat}: {detail}")
+
+    if not quiet:
+        print()
+    if total == 0:
+        print(f"OK: {len(files)} file(s) scanned, public docstrings are Google style")
+    else:
+        summary = ", ".join(f"{v} {k}" for k, v in sorted(by_cat.items()))
+        print(f"{total} issue(s) across {len(files)} file(s) scanned: {summary}")
+
+    return 1 if (strict and total) else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

From ae6b9b072a498f1dda8cbc822078618c43170234 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Fri, 4 Sep 2026 16:08:19 +0800
Subject: [PATCH 08/51] Add empty lines in output

---
 makefile | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/makefile b/makefile
index 0cc361a04..0595fa369 100644
--- a/makefile
+++ b/makefile
@@ -548,7 +548,10 @@ format:
 	$(MAKE) markdown-unwrap MARKDOWN_UNWRAP_PATH="$(MARKDOWN_UNWRAP_PATH)"
 	@echo ""
 	$(MAKE) rm_trailing_whitespace FORMAT_PATH="$(FORMAT_PATH)"
+	@echo ""
 	$(MAKE) harden_colab_notebook
+	@echo ""
+	$(MAKE) check_docstring_changed
 
 flatten_qmcpy_imports:
 	$(PYTHON) scripts/flatten_qmcpy_imports.py

From 8ef9f27e7d2c76561c7ddb123d5d23ab5d8cf852 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Fri, 4 Sep 2026 16:49:30 +0800
Subject: [PATCH 09/51] Use pydoclint

---
 docs/good_practices.md     |  18 +++---
 makefile                   |  29 ++++++---
 pyproject.toml             |  15 +++++
 scripts/check_docstring.py | 128 ++++++++++++++++++++++++++++++++-----
 4 files changed, 157 insertions(+), 33 deletions(-)

diff --git a/docs/good_practices.md b/docs/good_practices.md
index 81013cbb3..4f9831373 100644
--- a/docs/good_practices.md
+++ b/docs/good_practices.md
@@ -38,18 +38,18 @@ When notebook-backed content changes:
 QMCPy documentation is built from docstrings, so public APIs should document their behavior clearly and consistently.
 
 - Use **Google-style docstrings** for public classes, methods, and functions.
-- Document parameters, return values, shapes, assumptions, and any stochastic behavior.
+- Start every docstring with a one-line summary before any section header.
+- Document every parameter and return value, plus shapes, assumptions, and any stochastic behavior. Constructor arguments go in the `__init__` method's own docstring, with the type in the docstring (`name (type): ...`).
+- Put a blank line before every section header (`Args:`, `Returns:`, `Raises:`, `Examples:`, ...) and write the header as `Name:` — not a NumPy-style `Name` followed by an `-----` underline.
 - Include short doctestable examples when they clarify expected use.
 - Update docstrings at the same time as the implementation so the rendered API docs do not drift from the code.
-- Put a blank line before every section header (`Args:`, `Returns:`, `Raises:`, `Examples:`, ...) and write the header as `Name:` — not a NumPy-style `Name` followed by an `-----` underline.
 
-* `make check_docstring` scans public objects under `qmcpy/` for these conventions (NumPy-style sections, a missing blank line before a section header, malformed headers, and public objects with no docstring). It is informational by default;
-    - `STRICT=--strict make check_docstring` makes it fail. Pass
-    - `CHECK_DOCSTRING_ARGS=--skip-missing` to report only the style problems and not
-    the objects that lack a docstring, or 
-    - `DOCSTRING_PATH=qmcpy/true_measure`
-    to narrow the scan.
-* `make check_docstring_changed` runs the same checks on just the `qmcpy/*.py` files that changed relative to `DOCSTRING_BASE` (default `develop`), which is the quick check to run before opening a PR.
+`make check_docstring` runs two checks over public objects under `qmcpy/`:
+
+- `scripts/check_docstring.py` for **formatting** — a one-line summary before the first section (`missing-summary`), no NumPy-style sections, a blank line before every section header, canonical `Name:` headers, and public objects with no docstring. After the overall count it prints a second summary restricted to files changed relative to `DOCSTRING_BASE` (default `develop`), so you can see your branch's contribution to the backlog.
+- `pydoclint` (configured in `pyproject.toml` under `[tool.pydoclint]`) for **content** — every parameter and return value is documented and matches the signature, in Google form.
+
+It is informational by default; `STRICT=--strict make check_docstring` makes both parts fail the build. Pass `CHECK_DOCSTRING_ARGS=--skip-missing` to skip the "no docstring" formatting check, or `DOCSTRING_PATH=qmcpy/true_measure` to narrow the scan. `make check_docstring_changed` runs the same two checks on just the `qmcpy/*.py` files that changed relative to `DOCSTRING_BASE` — the quick check to run before opening a PR (it is also part of `make format`).
 
 ## Extend the Existing Object Model
 
diff --git a/makefile b/makefile
index 0595fa369..4e2cd3c2b 100644
--- a/makefile
+++ b/makefile
@@ -52,16 +52,25 @@ check_test_style:
 	@$(PYTHON) scripts/check_test_style.py $(TEST_STYLE_PATH) $(STRICT)
 
 DOCSTRING_PATH ?= qmcpy
-# Check that public docstrings under qmcpy/ are Google style: no NumPy-style
-# "-----" section underlines, a blank line before every Args:/Returns:/Raises:/...
-# header, and canonical "Name:" section headers. Also flags public classes,
-# functions, and methods with no docstring (pass --skip-missing via
-# CHECK_DOCSTRING_ARGS to check style only). Informational by default; pass
-# --strict to make it fail (e.g. STRICT=--strict make check_docstring).
+DOCSTRING_BASE ?= develop
+PYDOCLINT ?= pydoclint
+# Two-part docstring check for public APIs under qmcpy/:
+#  1. scripts/check_docstring.py -- formatting: a one-line summary before the
+#     first section, no NumPy-style "-----" section underlines, a blank line
+#     before every Args:/Returns:/... header, canonical "Name:" headers, and
+#     public objects with no docstring (pass --skip-missing via
+#     CHECK_DOCSTRING_ARGS to check style only). It also prints a second summary
+#     restricted to files changed relative to DOCSTRING_BASE.
+#  2. pydoclint (config in pyproject.toml [tool.pydoclint]) -- content: every
+#     parameter and return value is documented and matches the signature, in
+#     Google form.
+# Informational by default; pass --strict (STRICT=--strict make check_docstring)
+# to make both parts fail the build.
 check_docstring:
-	@$(PYTHON) scripts/check_docstring.py $(DOCSTRING_PATH) $(CHECK_DOCSTRING_ARGS) $(STRICT)
+	@$(PYTHON) scripts/check_docstring.py $(DOCSTRING_PATH) --diff $(DOCSTRING_BASE) $(CHECK_DOCSTRING_ARGS) $(STRICT)
+	@echo ""
+	@$(PYDOCLINT) $(PYDOCLINT_ARGS) $(DOCSTRING_PATH) $(if $(STRICT),,|| true)
 
-DOCSTRING_BASE ?= develop
 # Same checks as check_docstring, but only on qmcpy/*.py files that changed
 # relative to DOCSTRING_BASE (committed, staged/unstaged, and untracked).
 check_docstring_changed:
@@ -76,9 +85,11 @@ check_docstring_changed:
 	if [ -z "$$changed_files" ]; then \
 		echo "No changed qmcpy/*.py files relative to $(DOCSTRING_BASE)."; \
 	else \
-		echo "Checking docstring style on changed qmcpy files relative to $(DOCSTRING_BASE):"; \
+		echo "Checking docstrings on changed qmcpy files relative to $(DOCSTRING_BASE):"; \
 		printf '%s\n' "$$changed_files"; \
 		$(PYTHON) scripts/check_docstring.py $$changed_files $(CHECK_DOCSTRING_ARGS) $(STRICT); \
+		echo ""; \
+		$(PYDOCLINT) $(PYDOCLINT_ARGS) $$changed_files $(if $(STRICT),,|| true); \
 	fi
 
 ##########################################################
diff --git a/pyproject.toml b/pyproject.toml
index 570ba971d..6e86e376c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -150,6 +150,7 @@ docs = [  # brew install weasyprint
     "mkdocs-print-site-plugin >= 2.7.2",
     "mkdocs-exclude >= 1.0.2",
     "pylint >= 4.0.5",
+    "pydoclint >= 0.5.0",
 ]
 dev = [ # brew install weasyprint
     "qmcpy[docs,test,torch,gpytorch,botorch,umbridge,mpmc]",
@@ -184,6 +185,20 @@ class = [
     "networkx >= 3.0",
 ]
 
+[tool.pydoclint]
+# `make check_docstring` reads this. QMCPy convention: constructor arguments are
+# documented in the __init__ method's own docstring, and parameter types live in
+# the docstring (`name (type): ...`), not in the signature.
+style = "google"
+allow-init-docstring = true
+arg-type-hints-in-signature = false
+arg-type-hints-in-docstring = true
+check-return-types = false
+check-yield-types = false
+check-class-attributes = false
+skip-checking-short-docstrings = true
+skip-checking-raises = true
+
 [tool.pylint.typecheck]
 # Members that live on compiled/C-extension objects (numpy, scipy, matplotlib)
 # which pylint's static inference cannot see, so they should not trigger
diff --git a/scripts/check_docstring.py b/scripts/check_docstring.py
index ccb943c46..72e233ca0 100644
--- a/scripts/check_docstring.py
+++ b/scripts/check_docstring.py
@@ -1,13 +1,19 @@
 #!/usr/bin/env python3
 """Check that public docstrings under ``qmcpy/`` follow Google style.
 
-A *public* object is a module, or a class / function / method whose name does
-not start with ``_``.  Only module-level functions/classes and the methods of
-public classes are inspected (helpers nested inside functions are skipped).
-For every public docstring this script flags:
+A *public* object is a module, a class / function / method whose name does not
+start with ``_``, or the ``__init__`` of a public class (QMCPy documents
+constructor arguments in ``__init__``'s own docstring).  Only module-level
+functions/classes and the methods of public classes are inspected (helpers
+nested inside functions are skipped).  For every such docstring this script
+flags:
 
 * ``missing``                  -- public class / function / method has no
                                   docstring (suppressed by ``--skip-missing``)
+* ``missing-summary``          -- the docstring opens straight with a section
+                                  header (``Args:``, ``Returns:``, ...) instead
+                                  of a one-line summary.  This is the common
+                                  cause of pydoclint's opaque ``DOC001``.
 * ``numpy-section``            -- a section written NumPy-style (``Returns``
                                   followed by a ``-----`` underline) instead of
                                   Google style (``Returns:``)
@@ -19,16 +25,21 @@
                                   stray space before the colon, ...)
 
 Usage:
-    python scripts/check_docstring.py [PATH ...] [--strict] [--quiet] [--skip-missing]
+    python scripts/check_docstring.py [PATH ...] [--strict] [--quiet]
+                                      [--skip-missing] [--diff [REF]]
 
 PATH defaults to ``qmcpy``.  Informational by default (exit 0); ``--strict``
 makes the exit code non-zero when anything is flagged, so it can gate CI
-(``STRICT=--strict make check_docstring``).
+(``STRICT=--strict make check_docstring``).  ``--diff [REF]`` (REF defaults to
+``develop``) prints a second summary restricted to the scanned files that
+changed relative to REF -- committed on the branch, modified in the working
+tree, or untracked.
 """
 from __future__ import annotations
 
 import ast
 import re
+import subprocess
 import sys
 from pathlib import Path
 
@@ -60,9 +71,12 @@ def _iter_public(tree):
         elif isinstance(node, ast.ClassDef) and not node.name.startswith("_"):
             yield node, "class"
             for sub in node.body:
-                if isinstance(sub, (ast.FunctionDef, ast.AsyncFunctionDef)) \
-                        and not sub.name.startswith("_"):
+                if not isinstance(sub, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                    continue
+                if not sub.name.startswith("_"):
                     yield sub, "method"
+                elif sub.name == "__init__":
+                    yield sub, "constructor"
 
 
 def _doc_node(node):
@@ -75,6 +89,14 @@ def _doc_node(node):
     return None
 
 
+def _is_section_word(s):
+    """Return the section word if ``s`` is a lone Google/NumPy section header."""
+    word = s[:-1].strip() if s.endswith(":") else s
+    if word in GOOGLE_SECTIONS or word in NUMPY_SECTIONS:
+        return word
+    return None
+
+
 def check_file(path, skip_missing=False):
     """Return a list of ``(lineno, category, detail)`` findings for one file."""
     findings = []
@@ -82,13 +104,16 @@ def check_file(path, skip_missing=False):
     for node, kind in _iter_public(tree):
         dnode = _doc_node(node)
         if dnode is None:
-            if kind != "module" and not skip_missing:
+            # A bare "no docstring" finding is noise for __init__ (pydoclint
+            # owns constructor-argument coverage) and meaningless for a module.
+            if kind not in ("module", "constructor") and not skip_missing:
                 findings.append((
                     getattr(node, "lineno", 1), "missing",
                     f"public {kind} `{getattr(node, 'name', path.stem)}` has no docstring",
                 ))
             continue
         lines = dnode.value.split("\n")
+        first_nonblank = next((j for j, ln in enumerate(lines) if ln.strip()), None)
         for i, raw in enumerate(lines):
             s = raw.strip()
             if not s:
@@ -103,7 +128,12 @@ def check_file(path, skip_missing=False):
                 continue
             m = _HEADER.match(s)
             if m and m.group(1) in GOOGLE_SECTIONS:
-                if i > 0 and lines[i - 1].strip() != "":
+                if i == first_nonblank and kind != "module":
+                    findings.append((
+                        dnode.lineno + i, "missing-summary",
+                        f"docstring opens with `{s}`; add a one-line summary first",
+                    ))
+                elif i > 0 and lines[i - 1].strip() != "":
                     findings.append((
                         dnode.lineno + i, "no-blank-before-section",
                         f"add a blank line before `{s}`",
@@ -116,7 +146,61 @@ def check_file(path, skip_missing=False):
     return findings
 
 
+def _changed_files(ref):
+    """Return resolved paths of *.py files that changed relative to ``ref``.
+
+    Union of files committed on the branch (``ref...HEAD``), files modified in
+    the working tree, and untracked files.  Raises ``RuntimeError`` if git is
+    unavailable or ``ref`` cannot be resolved.
+    """
+    commands = (
+        ["git", "diff", "--name-only", "--diff-filter=ACMR", f"{ref}...HEAD"],
+        ["git", "diff", "--name-only", "--diff-filter=ACMR", "HEAD"],
+        ["git", "ls-files", "--others", "--exclude-standard"],
+    )
+    names = set()
+    for cmd in commands:
+        try:
+            out = subprocess.run(
+                cmd, capture_output=True, text=True, check=True,
+            ).stdout
+        except (OSError, subprocess.CalledProcessError) as exc:
+            raise RuntimeError(f"`{' '.join(cmd)}` failed: {exc}") from exc
+        names.update(n for n in out.splitlines() if n.endswith(".py"))
+    return {Path(n).resolve() for n in names}
+
+
+def _summary(total, n_files, by_cat, label):
+    """Format one summary line."""
+    if total == 0:
+        return f"{label}: no issues in {n_files} file(s)"
+    breakdown = ", ".join(f"{v} {k}" for k, v in sorted(by_cat.items()))
+    return f"{label}: {total} issue(s) across {n_files} file(s): {breakdown}"
+
+
+def _parse_diff_flag(argv):
+    """Pull ``--diff [REF]`` out of ``argv``; return (remaining_argv, ref|None)."""
+    args, ref, i = [], None, 0
+    while i < len(argv):
+        a = argv[i]
+        if a == "--diff":
+            nxt = argv[i + 1] if i + 1 < len(argv) else ""
+            if nxt and not nxt.startswith("-"):
+                ref, i = nxt, i + 2
+            else:
+                ref, i = "develop", i + 1
+            continue
+        if a.startswith("--diff="):
+            ref = a.split("=", 1)[1] or "develop"
+            i += 1
+            continue
+        args.append(a)
+        i += 1
+    return args, ref
+
+
 def main(argv):
+    argv, diff_ref = _parse_diff_flag(list(argv))
     strict = "--strict" in argv
     quiet = "--quiet" in argv
     skip_missing = "--skip-missing" in argv
@@ -131,12 +215,14 @@ def main(argv):
 
     total = 0
     by_cat = {}
+    per_file = {}
     for f in files:
         try:
             findings = check_file(f, skip_missing=skip_missing)
         except SyntaxError as exc:
             print(f"{f.as_posix()}: skipped (syntax error: {exc})", file=sys.stderr)
             continue
+        per_file[f] = findings
         for lineno, cat, detail in findings:
             by_cat[cat] = by_cat.get(cat, 0) + 1
             total += 1
@@ -145,11 +231,23 @@ def main(argv):
 
     if not quiet:
         print()
-    if total == 0:
-        print(f"OK: {len(files)} file(s) scanned, public docstrings are Google style")
-    else:
-        summary = ", ".join(f"{v} {k}" for k, v in sorted(by_cat.items()))
-        print(f"{total} issue(s) across {len(files)} file(s) scanned: {summary}")
+    print(_summary(total, len(files), by_cat, f"{len(files)} file(s) scanned"))
+
+    if diff_ref is not None:
+        try:
+            changed = _changed_files(diff_ref)
+        except RuntimeError as exc:
+            print(f"--diff {diff_ref}: skipped ({exc})", file=sys.stderr)
+        else:
+            sub_cat, sub_total, sub_files = {}, 0, 0
+            for f, findings in per_file.items():
+                if f.resolve() not in changed:
+                    continue
+                sub_files += 1
+                for _, cat, _ in findings:
+                    sub_cat[cat] = sub_cat.get(cat, 0) + 1
+                    sub_total += 1
+            print(_summary(sub_total, sub_files, sub_cat, f"changed vs {diff_ref}"))
 
     return 1 if (strict and total) else 0
 

From 8d4358c53aef4cdbf9589afcc70faac478fe6537 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Fri, 4 Sep 2026 17:50:53 +0800
Subject: [PATCH 10/51] Turn test/test_sr_colab_notebooks.py into object class

---
 test/test_colab_notebooks.py    | 314 ------------------------------
 test/test_sr_colab_notebooks.py | 327 ++++++++++++++++++++++++++++++++
 2 files changed, 327 insertions(+), 314 deletions(-)
 delete mode 100644 test/test_colab_notebooks.py
 create mode 100644 test/test_sr_colab_notebooks.py

diff --git a/test/test_colab_notebooks.py b/test/test_colab_notebooks.py
deleted file mode 100644
index 858c4c4b9..000000000
--- a/test/test_colab_notebooks.py
+++ /dev/null
@@ -1,314 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-import sys
-from pathlib import Path
-
-import pytest
-
-from scripts import check_colab_notebooks as check
-from scripts import harden_colab_notebook as harden
-from scripts import smoke_test_colab_notebooks as smoke
-
-
-def markdown_cell(source: str, cell_id: str = "markdown") -> dict:
-    return {
-        "cell_type": "markdown",
-        "id": cell_id,
-        "metadata": {},
-        "source": source.splitlines(keepends=True),
-    }
-
-
-def code_cell(source: str, cell_id: str = "code") -> dict:
-    return {
-        "cell_type": "code",
-        "execution_count": None,
-        "id": cell_id,
-        "metadata": {},
-        "outputs": [],
-        "source": source.splitlines(keepends=True),
-    }
-
-
-@pytest.fixture
-def colab_repo(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
-    demos_dir = tmp_path / "demos"
-    demos_dir.mkdir()
-    notebook_path = demos_dir / "example.ipynb"
-    notebook = {
-        "cells": [
-            markdown_cell("# Example\n", "title"),
-            code_cell("import math\n", "imports"),
-        ],
-        "metadata": {},
-        "nbformat": 4,
-        "nbformat_minor": 5,
-    }
-    notebook_path.write_text(json.dumps(notebook, indent=1) + "\n", encoding="utf-8")
-
-    manifest_path = tmp_path / "manifest.json"
-    manifest = {
-        "repo": "QMCSoftware/QMCSoftware",
-        "git_ref": "develop",
-        "enabled": [],
-        "disabled": {},
-    }
-    manifest_path.write_text(json.dumps(manifest, indent=1) + "\n", encoding="utf-8")
-
-    monkeypatch.setattr(check, "REPO_ROOT", tmp_path)
-    monkeypatch.setattr(check, "DEMOS_DIR", demos_dir)
-    monkeypatch.setattr(harden, "REPO_ROOT", tmp_path)
-    monkeypatch.setattr(smoke, "REPO_ROOT", tmp_path)
-    return notebook_path, manifest_path
-
-
-def test_badge_stripping_preserves_intro_and_drops_badge_only_cells():
-    intro = markdown_cell(
-        "# ML Sensitivity Indices\n\n"
-        "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)]"
-        "(https://colab.research.google.com/github/QMCSoftware/QMCSoftware/"
-        "blob/develop/demos/iris.ipynb)\n\n"
-        "This notebook demonstrates sensitivity indices.\n"
-    )
-    badge_only = markdown_cell(
-        "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)]"
-        "(https://colab.research.google.com/github/QMCSoftware/QMCSoftware/"
-        "blob/develop/demos/iris.ipynb)\n"
-    )
-
-    cleaned_intro = harden.badge_stripped_cell(intro)
-    assert cleaned_intro is not None
-    assert "# ML Sensitivity Indices" in check.cell_source_text(cleaned_intro)
-    assert "sensitivity indices" in check.cell_source_text(cleaned_intro)
-    assert "Open In Colab" not in check.cell_source_text(cleaned_intro)
-    assert harden.remove_any_badge_cells([badge_only, code_cell("pass\n")]) == [
-        code_cell("pass\n")
-    ]
-
-
-def test_is_any_badge_cell_rejects_spoofed_hostname():
-    spoofed = markdown_cell(
-        "[click](https://evil.example/colab.research.google.com/assets/colab-badge.svg)\n"
-    )
-    genuine = markdown_cell(
-        "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)]"
-        "(https://colab.research.google.com/github/QMCSoftware/QMCSoftware/"
-        "blob/develop/demos/iris.ipynb)\n"
-    )
-
-    assert not check.is_any_badge_cell(spoofed)
-    assert check.is_any_badge_cell(genuine)
-
-
-def test_bootstrap_detection_uses_marker_and_real_install_command(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-):
-    misleading = code_cell(
-        '"""import google.colab\n# @title Execute this cell to install dependencies\n'
-        '!pip install qmcpy\n"""\n'
-    )
-    comment_only = code_cell(
-        "# @title Execute this cell to install dependencies\n"
-        "# import google.colab\n"
-        "# !pip install qmcpy\n"
-    )
-    assert not check.is_any_install_cell(misleading)
-    assert not check.is_bootstrap_cell(misleading)
-    assert check.is_any_install_cell(comment_only)
-    assert not check.is_bootstrap_cell(comment_only)
-
-    monkeypatch.setattr(harden, "REPO_ROOT", tmp_path)
-    notebook_path = tmp_path / "demos" / "example.ipynb"
-    notebook_path.parent.mkdir()
-    source = "".join(
-        harden.bootstrap_cell_source(
-            notebook_path,
-            {"repo": "QMCSoftware/QMCSoftware"},
-            [],
-        )
-    )
-    generated = code_cell(source)
-    assert check.is_bootstrap_cell(generated)
-    assert "except ImportError:" in source
-    assert "if IN_COLAB:" in source
-    assert "except:\n" not in source
-    compile(smoke.rewrite_shell_magics(source), "<bootstrap>", "exec")
-
-
-def test_extra_pip_packages_preserves_later_explicit_installs():
-    cells = [
-        code_cell("import qmcpy as qp\n"),
-        code_cell("import ipywidgets as widgets\n"),
-        code_cell(
-            "try:\n"
-            "    import QuantLib as ql\n"
-            "except ModuleNotFoundError:\n"
-            "    !pip install -q QuantLib\n"
-        ),
-        code_cell("!pip install -q seaborn\n"),
-    ]
-
-    assert harden.extra_pip_packages(cells) == ["QuantLib", "ipywidgets", "seaborn"]
-
-
-def test_needs_latex_setup_detects_tueplots():
-    cells = [
-        code_cell("import qmcpy as qp\n"),
-        code_cell(
-            "from tueplots import bundles\n"
-            "pyplot.rcParams.update(bundles.probnum2025())\n"
-        ),
-    ]
-
-    assert harden.needs_latex_setup(cells)
-
-
-def test_imported_modules_survives_magic_only_block_body():
-    # A shell-magic line as the *only* statement in a block used to leave an
-    # empty `if:`/`try:` body, making ast.parse raise and silently hiding
-    # every import in the cell (not just the magic line itself).
-    source = (
-        "import os\n"
-        "from util import helper\n"
-        "if True:\n"
-        "    !echo hi\n"
-    )
-    assert check.imported_modules(source) == {"os", "util"}
-
-
-def test_local_module_matches_finds_ancestor_directory(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-):
-    monkeypatch.setattr(check, "DEMOS_DIR", tmp_path)
-    (tmp_path / "util.py").write_text("", encoding="utf-8")
-    notebook_dir = tmp_path / "output"
-    notebook_dir.mkdir()
-
-    matches = check.local_module_matches(notebook_dir, "util")
-
-    assert matches == [tmp_path / "util.py"]
-
-
-def test_extra_pip_packages_honors_colab_deps_marker():
-    cells = [
-        code_cell("import qmcpy as qp\n"),
-        code_cell(
-            "# colab-deps: plotly, some-package\n"
-            "import plotly\n"
-        ),
-    ]
-
-    assert harden.extra_pip_packages(cells) == ["plotly", "some-package"]
-
-
-def test_dump_notebook_preserves_existing_json_indent(tmp_path: Path):
-    notebook_path = tmp_path / "example.ipynb"
-    notebook = {
-        "cells": [code_cell("pass\n")],
-        "metadata": {},
-        "nbformat": 4,
-        "nbformat_minor": 5,
-    }
-    original_source = json.dumps(notebook, indent=2) + "\n"
-
-    harden.dump_notebook(notebook_path, notebook, original_source)
-
-    assert notebook_path.read_text(encoding="utf-8") == original_source
-
-
-def test_harden_check_smoke_round_trip_is_idempotent(
-    colab_repo, monkeypatch: pytest.MonkeyPatch
-):
-    notebook_path, manifest_path = colab_repo
-    harden.harden_notebook(notebook_path, manifest_path)
-
-    assert check.run_check(manifest_path, strict=True) == 0
-    smoke_notebook, source_indices = smoke.build_smoke_notebook(notebook_path, 1)
-    assert len(smoke_notebook["cells"]) == len(source_indices)
-
-    sentinel = object()
-    old_modules = {
-        name: sys.modules.get(name, sentinel) for name in ("google", "google.colab")
-    }
-    old_environment = {
-        name: os.environ.get(name, sentinel)
-        for name in ("QMC_COLAB_SMOKE", "QMC_COLAB_SMOKE_REPO_ROOT", "QMC_COLAB_SMOKE_NOTEBOOK_DIR")
-    }
-    namespace: dict = {}
-    try:
-        for cell in smoke_notebook["cells"]:
-            if cell["cell_type"] == "code":
-                exec(check.cell_source_text(cell), namespace)
-    finally:
-        for name, value in old_modules.items():
-            if value is sentinel:
-                sys.modules.pop(name, None)
-            else:
-                sys.modules[name] = value
-        for name, value in old_environment.items():
-            if value is sentinel:
-                os.environ.pop(name, None)
-            else:
-                os.environ[name] = value
-
-    monkeypatch.setattr(
-        harden,
-        "dump_notebook",
-        lambda *_args, **_kwargs: pytest.fail("unchanged notebook was rewritten"),
-    )
-    monkeypatch.setattr(
-        harden,
-        "dump_json",
-        lambda *_args, **_kwargs: pytest.fail("unchanged manifest was rewritten"),
-    )
-    harden.harden_notebook(notebook_path, manifest_path)
-
-
-def test_checker_rejects_wrong_badge(colab_repo):
-    notebook_path, manifest_path = colab_repo
-    harden.harden_notebook(notebook_path, manifest_path)
-    notebook = check.load_json(notebook_path)
-    badge = next(cell for cell in notebook["cells"] if check.is_any_badge_cell(cell))
-    badge["source"] = [check.cell_source_text(badge).replace("develop", "wrong-ref")]
-    notebook_path.write_text(json.dumps(notebook, indent=1) + "\n", encoding="utf-8")
-
-    assert check.run_check(manifest_path, strict=True) == 1
-
-
-def test_harden_failure_does_not_disable_notebook(
-    colab_repo, monkeypatch: pytest.MonkeyPatch
-):
-    notebook_path, manifest_path = colab_repo
-    original_manifest = manifest_path.read_text(encoding="utf-8")
-    monkeypatch.setattr(
-        harden,
-        "harden_notebook",
-        lambda *_args, **_kwargs: (_ for _ in ()).throw(RuntimeError("failure")),
-    )
-
-    successes, failures = harden.harden_batch([notebook_path], manifest_path)
-
-    assert successes == []
-    assert failures == [("demos/example.ipynb", "failure")]
-    assert manifest_path.read_text(encoding="utf-8") == original_manifest
-
-
-def test_smoke_batch_continues_after_a_notebook_failure(monkeypatch: pytest.MonkeyPatch):
-    def fake_build(notebook_path: Path, cells_after_bootstrap: int):
-        return {"cells": []}, []
-
-    def fake_execute(notebook_path: Path, smoke_nb, source_indices, timeout):
-        if "broken" in notebook_path.as_posix():
-            raise RuntimeError("boom")
-
-    monkeypatch.setattr(smoke, "build_smoke_notebook", fake_build)
-    monkeypatch.setattr(smoke, "execute_smoke_notebook", fake_execute)
-
-    passed, failed = smoke.smoke_test_batch(
-        ["demos/broken.ipynb", "demos/ok.ipynb"], cells_after_bootstrap=1, timeout=60
-    )
-
-    assert passed == ["demos/ok.ipynb"]
-    assert failed == [("demos/broken.ipynb", "boom")]
diff --git a/test/test_sr_colab_notebooks.py b/test/test_sr_colab_notebooks.py
new file mode 100644
index 000000000..d494c2a51
--- /dev/null
+++ b/test/test_sr_colab_notebooks.py
@@ -0,0 +1,327 @@
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+from scripts import check_colab_notebooks as check
+from scripts import harden_colab_notebook as harden
+from scripts import smoke_test_colab_notebooks as smoke
+
+
+def markdown_cell(source: str, cell_id: str = "markdown") -> dict:
+    return {
+        "cell_type": "markdown",
+        "id": cell_id,
+        "metadata": {},
+        "source": source.splitlines(keepends=True),
+    }
+
+
+def code_cell(source: str, cell_id: str = "code") -> dict:
+    return {
+        "cell_type": "code",
+        "execution_count": None,
+        "id": cell_id,
+        "metadata": {},
+        "outputs": [],
+        "source": source.splitlines(keepends=True),
+    }
+
+
+class TestColabNotebooks(unittest.TestCase):
+
+    def _tmp_path(self) -> Path:
+        """Fresh temp directory, removed after the test (pytest ``tmp_path``)."""
+        path = Path(tempfile.mkdtemp())
+        self.addCleanup(shutil.rmtree, path, ignore_errors=True)
+        return path
+
+    def _setattr(self, target, name, value):
+        """Set ``target.name = value`` for the test only (pytest ``monkeypatch``)."""
+        patcher = mock.patch.object(target, name, value)
+        patcher.start()
+        self.addCleanup(patcher.stop)
+
+    def _colab_repo(self):
+        """Build a throwaway repo layout and point the scripts at it.
+
+        Returns ``(notebook_path, manifest_path)`` (pytest ``colab_repo``).
+        """
+        tmp_path = self._tmp_path()
+        demos_dir = tmp_path / "demos"
+        demos_dir.mkdir()
+        notebook_path = demos_dir / "example.ipynb"
+        notebook = {
+            "cells": [
+                markdown_cell("# Example\n", "title"),
+                code_cell("import math\n", "imports"),
+            ],
+            "metadata": {},
+            "nbformat": 4,
+            "nbformat_minor": 5,
+        }
+        notebook_path.write_text(json.dumps(notebook, indent=1) + "\n", encoding="utf-8")
+
+        manifest_path = tmp_path / "manifest.json"
+        manifest = {
+            "repo": "QMCSoftware/QMCSoftware",
+            "git_ref": "develop",
+            "enabled": [],
+            "disabled": {},
+        }
+        manifest_path.write_text(json.dumps(manifest, indent=1) + "\n", encoding="utf-8")
+
+        self._setattr(check, "REPO_ROOT", tmp_path)
+        self._setattr(check, "DEMOS_DIR", demos_dir)
+        self._setattr(harden, "REPO_ROOT", tmp_path)
+        self._setattr(smoke, "REPO_ROOT", tmp_path)
+        return notebook_path, manifest_path
+
+    def test_badge_stripping_preserves_intro_and_drops_badge_only_cells(self):
+        intro = markdown_cell(
+            "# ML Sensitivity Indices\n\n"
+            "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)]"
+            "(https://colab.research.google.com/github/QMCSoftware/QMCSoftware/"
+            "blob/develop/demos/iris.ipynb)\n\n"
+            "This notebook demonstrates sensitivity indices.\n"
+        )
+        badge_only = markdown_cell(
+            "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)]"
+            "(https://colab.research.google.com/github/QMCSoftware/QMCSoftware/"
+            "blob/develop/demos/iris.ipynb)\n"
+        )
+
+        cleaned_intro = harden.badge_stripped_cell(intro)
+        self.assertIsNotNone(cleaned_intro)
+        self.assertIn("# ML Sensitivity Indices", check.cell_source_text(cleaned_intro))
+        self.assertIn("sensitivity indices", check.cell_source_text(cleaned_intro))
+        self.assertNotIn("Open In Colab", check.cell_source_text(cleaned_intro))
+        self.assertEqual(
+            harden.remove_any_badge_cells([badge_only, code_cell("pass\n")]),
+            [code_cell("pass\n")],
+        )
+
+    def test_is_any_badge_cell_rejects_spoofed_hostname(self):
+        spoofed = markdown_cell(
+            "[click](https://evil.example/colab.research.google.com/assets/colab-badge.svg)\n"
+        )
+        genuine = markdown_cell(
+            "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)]"
+            "(https://colab.research.google.com/github/QMCSoftware/QMCSoftware/"
+            "blob/develop/demos/iris.ipynb)\n"
+        )
+
+        self.assertFalse(check.is_any_badge_cell(spoofed))
+        self.assertTrue(check.is_any_badge_cell(genuine))
+
+    def test_bootstrap_detection_uses_marker_and_real_install_command(self):
+        misleading = code_cell(
+            '"""import google.colab\n# @title Execute this cell to install dependencies\n'
+            '!pip install qmcpy\n"""\n'
+        )
+        comment_only = code_cell(
+            "# @title Execute this cell to install dependencies\n"
+            "# import google.colab\n"
+            "# !pip install qmcpy\n"
+        )
+        self.assertFalse(check.is_any_install_cell(misleading))
+        self.assertFalse(check.is_bootstrap_cell(misleading))
+        self.assertTrue(check.is_any_install_cell(comment_only))
+        self.assertFalse(check.is_bootstrap_cell(comment_only))
+
+        tmp_path = self._tmp_path()
+        self._setattr(harden, "REPO_ROOT", tmp_path)
+        notebook_path = tmp_path / "demos" / "example.ipynb"
+        notebook_path.parent.mkdir()
+        source = "".join(
+            harden.bootstrap_cell_source(
+                notebook_path,
+                {"repo": "QMCSoftware/QMCSoftware"},
+                [],
+            )
+        )
+        generated = code_cell(source)
+        self.assertTrue(check.is_bootstrap_cell(generated))
+        self.assertIn("except ImportError:", source)
+        self.assertIn("if IN_COLAB:", source)
+        self.assertNotIn("except:\n", source)
+        compile(smoke.rewrite_shell_magics(source), "<bootstrap>", "exec")
+
+    def test_extra_pip_packages_preserves_later_explicit_installs(self):
+        cells = [
+            code_cell("import qmcpy as qp\n"),
+            code_cell("import ipywidgets as widgets\n"),
+            code_cell(
+                "try:\n"
+                "    import QuantLib as ql\n"
+                "except ModuleNotFoundError:\n"
+                "    !pip install -q QuantLib\n"
+            ),
+            code_cell("!pip install -q seaborn\n"),
+        ]
+
+        self.assertEqual(
+            harden.extra_pip_packages(cells), ["QuantLib", "ipywidgets", "seaborn"]
+        )
+
+    def test_needs_latex_setup_detects_tueplots(self):
+        cells = [
+            code_cell("import qmcpy as qp\n"),
+            code_cell(
+                "from tueplots import bundles\n"
+                "pyplot.rcParams.update(bundles.probnum2025())\n"
+            ),
+        ]
+
+        self.assertTrue(harden.needs_latex_setup(cells))
+
+    def test_imported_modules_survives_magic_only_block_body(self):
+        # A shell-magic line as the *only* statement in a block used to leave an
+        # empty `if:`/`try:` body, making ast.parse raise and silently hiding
+        # every import in the cell (not just the magic line itself).
+        source = (
+            "import os\n"
+            "from util import helper\n"
+            "if True:\n"
+            "    !echo hi\n"
+        )
+        self.assertEqual(check.imported_modules(source), {"os", "util"})
+
+    def test_local_module_matches_finds_ancestor_directory(self):
+        tmp_path = self._tmp_path()
+        self._setattr(check, "DEMOS_DIR", tmp_path)
+        (tmp_path / "util.py").write_text("", encoding="utf-8")
+        notebook_dir = tmp_path / "output"
+        notebook_dir.mkdir()
+
+        matches = check.local_module_matches(notebook_dir, "util")
+
+        self.assertEqual(matches, [tmp_path / "util.py"])
+
+    def test_extra_pip_packages_honors_colab_deps_marker(self):
+        cells = [
+            code_cell("import qmcpy as qp\n"),
+            code_cell(
+                "# colab-deps: plotly, some-package\n"
+                "import plotly\n"
+            ),
+        ]
+
+        self.assertEqual(
+            harden.extra_pip_packages(cells), ["plotly", "some-package"]
+        )
+
+    def test_dump_notebook_preserves_existing_json_indent(self):
+        tmp_path = self._tmp_path()
+        notebook_path = tmp_path / "example.ipynb"
+        notebook = {
+            "cells": [code_cell("pass\n")],
+            "metadata": {},
+            "nbformat": 4,
+            "nbformat_minor": 5,
+        }
+        original_source = json.dumps(notebook, indent=2) + "\n"
+
+        harden.dump_notebook(notebook_path, notebook, original_source)
+
+        self.assertEqual(
+            notebook_path.read_text(encoding="utf-8"), original_source
+        )
+
+    def test_harden_check_smoke_round_trip_is_idempotent(self):
+        notebook_path, manifest_path = self._colab_repo()
+        harden.harden_notebook(notebook_path, manifest_path)
+
+        self.assertEqual(check.run_check(manifest_path, strict=True), 0)
+        smoke_notebook, source_indices = smoke.build_smoke_notebook(notebook_path, 1)
+        self.assertEqual(len(smoke_notebook["cells"]), len(source_indices))
+
+        sentinel = object()
+        old_modules = {
+            name: sys.modules.get(name, sentinel) for name in ("google", "google.colab")
+        }
+        old_environment = {
+            name: os.environ.get(name, sentinel)
+            for name in ("QMC_COLAB_SMOKE", "QMC_COLAB_SMOKE_REPO_ROOT", "QMC_COLAB_SMOKE_NOTEBOOK_DIR")
+        }
+        namespace: dict = {}
+        try:
+            for cell in smoke_notebook["cells"]:
+                if cell["cell_type"] == "code":
+                    exec(check.cell_source_text(cell), namespace)
+        finally:
+            for name, value in old_modules.items():
+                if value is sentinel:
+                    sys.modules.pop(name, None)
+                else:
+                    sys.modules[name] = value
+            for name, value in old_environment.items():
+                if value is sentinel:
+                    os.environ.pop(name, None)
+                else:
+                    os.environ[name] = value
+
+        self._setattr(
+            harden,
+            "dump_notebook",
+            lambda *_args, **_kwargs: self.fail("unchanged notebook was rewritten"),
+        )
+        self._setattr(
+            harden,
+            "dump_json",
+            lambda *_args, **_kwargs: self.fail("unchanged manifest was rewritten"),
+        )
+        harden.harden_notebook(notebook_path, manifest_path)
+
+    def test_checker_rejects_wrong_badge(self):
+        notebook_path, manifest_path = self._colab_repo()
+        harden.harden_notebook(notebook_path, manifest_path)
+        notebook = check.load_json(notebook_path)
+        badge = next(cell for cell in notebook["cells"] if check.is_any_badge_cell(cell))
+        badge["source"] = [check.cell_source_text(badge).replace("develop", "wrong-ref")]
+        notebook_path.write_text(json.dumps(notebook, indent=1) + "\n", encoding="utf-8")
+
+        self.assertEqual(check.run_check(manifest_path, strict=True), 1)
+
+    def test_harden_failure_does_not_disable_notebook(self):
+        notebook_path, manifest_path = self._colab_repo()
+        original_manifest = manifest_path.read_text(encoding="utf-8")
+        self._setattr(
+            harden,
+            "harden_notebook",
+            lambda *_args, **_kwargs: (_ for _ in ()).throw(RuntimeError("failure")),
+        )
+
+        successes, failures = harden.harden_batch([notebook_path], manifest_path)
+
+        self.assertEqual(successes, [])
+        self.assertEqual(failures, [("demos/example.ipynb", "failure")])
+        self.assertEqual(manifest_path.read_text(encoding="utf-8"), original_manifest)
+
+    def test_smoke_batch_continues_after_a_notebook_failure(self):
+        def fake_build(notebook_path: Path, cells_after_bootstrap: int):
+            return {"cells": []}, []
+
+        def fake_execute(notebook_path: Path, smoke_nb, source_indices, timeout):
+            if "broken" in notebook_path.as_posix():
+                raise RuntimeError("boom")
+
+        self._setattr(smoke, "build_smoke_notebook", fake_build)
+        self._setattr(smoke, "execute_smoke_notebook", fake_execute)
+
+        passed, failed = smoke.smoke_test_batch(
+            ["demos/broken.ipynb", "demos/ok.ipynb"], cells_after_bootstrap=1, timeout=60
+        )
+
+        self.assertEqual(passed, ["demos/ok.ipynb"])
+        self.assertEqual(failed, [("demos/broken.ipynb", "boom")])
+
+
+if __name__ == "__main__":
+    unittest.main()

From df168c777e5c5bcd37b543cd64ffdeb1698e52f2 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Fri, 4 Sep 2026 17:51:19 +0800
Subject: [PATCH 11/51] add  make check_test_style to alltests.yml

---
 .github/workflows/alltests.yml | 8 ++++++++
 makefile                       | 4 ++--
 test/README.md                 | 2 ++
 3 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/alltests.yml b/.github/workflows/alltests.yml
index 97486f78f..8c592f510 100644
--- a/.github/workflows/alltests.yml
+++ b/.github/workflows/alltests.yml
@@ -312,6 +312,14 @@ jobs:
         run: |
           make check_colab_notebooks
           make check_colab_notebooks_smoke
+      - name: Check test-suite conventions (Linux)
+        if: runner.os == 'Linux'
+        shell: bash -l {0}
+        run: |
+          set -e
+          make check_test_style STRICT=--strict
+          python -m pip install -q "pydoclint>=0.5.0"
+          make check_docstring   # informational (exits 0 without STRICT)
       # -----------------------------------------------------------
       # Install minimal LaTeX required by Jupyter notebooks (OS-specific)
       # -----------------------------------------------------------
diff --git a/makefile b/makefile
index 4e2cd3c2b..a8f7975e1 100644
--- a/makefile
+++ b/makefile
@@ -52,7 +52,7 @@ check_test_style:
 	@$(PYTHON) scripts/check_test_style.py $(TEST_STYLE_PATH) $(STRICT)
 
 DOCSTRING_PATH ?= qmcpy
-DOCSTRING_BASE ?= develop
+DOCSTRING_BASE ?= origin/develop
 PYDOCLINT ?= pydoclint
 # Two-part docstring check for public APIs under qmcpy/:
 #  1. scripts/check_docstring.py -- formatting: a one-line summary before the
@@ -77,7 +77,7 @@ check_docstring_changed:
 	@set -e; \
 	changed_files="$$( \
 		{ \
-			git diff --name-only --diff-filter=ACMR "$(DOCSTRING_BASE)...HEAD" -- 'qmcpy/*.py'; \
+			git diff --name-only --diff-filter=ACMR "$(DOCSTRING_BASE)...HEAD" -- 'qmcpy/*.py' 2>/dev/null || true; \
 			git diff --name-only --diff-filter=ACMR HEAD -- 'qmcpy/*.py'; \
 			git ls-files --others --exclude-standard -- 'qmcpy/*.py'; \
 		} | sort -u \
diff --git a/test/README.md b/test/README.md
index 123556dcb..73cc08d92 100644
--- a/test/README.md
+++ b/test/README.md
@@ -69,6 +69,8 @@ Notebook tests are separate: they live in `test/booktests/` as `tb_*.py` and are
 STRICT=--strict make check_test_style
 ```
 
+`STRICT=--strict make check_test_style` also runs in CI (the `alltests` workflow), so both conventions are enforced on every pull request.
+
 ## Detailed Descriptions
 
 ## Scope

From 1f66c7092ae1af19451bdf98f1a5c1c9a9a6c686 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Fri, 4 Sep 2026 18:10:26 +0800
Subject: [PATCH 12/51] Turn Numpy doc to Google doc

---
 qmcpy/discrete_distribution/dummy_sampler.py  |  3 +-
 qmcpy/true_measure/product_measure.py         |  6 ++--
 .../true_measure/zero_inflated_exp_uniform.py |  3 +-
 qmcpy/util/dig_shift_invar_ops.py             |  2 +-
 scripts/check_docstring.py                    | 31 ++++++++++++++-----
 5 files changed, 28 insertions(+), 17 deletions(-)

diff --git a/qmcpy/discrete_distribution/dummy_sampler.py b/qmcpy/discrete_distribution/dummy_sampler.py
index cf33720e5..d47d2c46a 100644
--- a/qmcpy/discrete_distribution/dummy_sampler.py
+++ b/qmcpy/discrete_distribution/dummy_sampler.py
@@ -15,8 +15,7 @@ class DummySampler(AbstractLDDiscreteDistribution):
     Direct calls to ``DummySampler`` raise an error because the sampler is only
     a construction placeholder and cannot generate meaningful QMC points.
 
-    Examples
-    --------
+    Examples:
     >>> from qmcpy import DummySampler
     >>> sampler = DummySampler(2)
     >>> sampler.d
diff --git a/qmcpy/true_measure/product_measure.py b/qmcpy/true_measure/product_measure.py
index 3f860e84b..d40982eca 100644
--- a/qmcpy/true_measure/product_measure.py
+++ b/qmcpy/true_measure/product_measure.py
@@ -45,8 +45,7 @@ class ProductMeasure(AbstractTrueMeasure):
     samplerless/template true-measure mode may be useful, but that is separate
     from this class.
 
-    Notes
-    -----
+    Notes:
     For independent marginal blocks, means, variances, and standard deviations
     are concatenated in marginal order, while covariance is block diagonal.
 
@@ -55,8 +54,7 @@ class ProductMeasure(AbstractTrueMeasure):
     QMCPy's recursive transform helper, but exact final-space product weights
     are not currently implemented here.
 
-    Examples
-    --------
+    Examples:
     Combine two one-dimensional uniform true measures:
 
     >>> from qmcpy import DigitalNetB2, DummySampler, ProductMeasure, Uniform
diff --git a/qmcpy/true_measure/zero_inflated_exp_uniform.py b/qmcpy/true_measure/zero_inflated_exp_uniform.py
index 11526556f..ce93ac1e9 100644
--- a/qmcpy/true_measure/zero_inflated_exp_uniform.py
+++ b/qmcpy/true_measure/zero_inflated_exp_uniform.py
@@ -114,8 +114,7 @@ class ZeroInflatedExpUniform(SciPyWrapper):
     The ``y_split`` keyword is retained temporarily for backward
     compatibility with the deprecated two-dimensional construction.
 
-    Examples
-    --------
+    Examples:
     Without replications:
 
     >>> from qmcpy import DigitalNetB2, ZeroInflatedExpUniform
diff --git a/qmcpy/util/dig_shift_invar_ops.py b/qmcpy/util/dig_shift_invar_ops.py
index 566176a87..9be22a182 100644
--- a/qmcpy/util/dig_shift_invar_ops.py
+++ b/qmcpy/util/dig_shift_invar_ops.py
@@ -117,7 +117,7 @@ def weighted_walsh_funcs(alpha, xb, t):
         xb (Union[np.ndarray, torch.Tensor]): Integer points at which to evaluate the weighted Walsh function.
         t (int): Number of bits in each integer in xb.
 
-    returns:
+    Returns:
         y (Union[np.ndarray, torch.Tensor]): Weighted Walsh function values.
 
     **References:**
diff --git a/scripts/check_docstring.py b/scripts/check_docstring.py
index 72e233ca0..8583237e6 100644
--- a/scripts/check_docstring.py
+++ b/scripts/check_docstring.py
@@ -20,9 +20,11 @@
 * ``no-blank-before-section``  -- a Google section header (``Args:``,
                                   ``Returns:``, ``Raises:``, ...) is not preceded
                                   by a blank line
-* ``malformed-section-header`` -- a section word on its own line that is not the
-                                  canonical ``Name:`` form (missing colon, a
-                                  stray space before the colon, ...)
+* ``malformed-section-header`` -- a line that names a known section but is not
+                                  the canonical ``Name:`` form: a missing colon
+                                  (``Examples``), wrong casing (``EXAMPLES:``,
+                                  ``examples:``), or stray characters around the
+                                  colon (``Args :``)
 
 Usage:
     python scripts/check_docstring.py [PATH ...] [--strict] [--quiet]
@@ -59,6 +61,8 @@
 _DASHES = re.compile(r"^-{3,}$")
 # Canonical header: capitalised word(s), a single colon, nothing else.
 _HEADER = re.compile(r"^([A-Z][A-Za-z]*(?: [A-Z][A-Za-z]*)*):$")
+# Case-insensitive lookup from any known section label to its canonical spelling.
+_CANON = {name.lower(): name for name in GOOGLE_SECTIONS | NUMPY_SECTIONS}
 
 
 def _iter_public(tree):
@@ -138,11 +142,22 @@ def check_file(path, skip_missing=False):
                         dnode.lineno + i, "no-blank-before-section",
                         f"add a blank line before `{s}`",
                     ))
-            elif word in GOOGLE_SECTIONS and not _DASHES.match(nxt):
-                findings.append((
-                    dnode.lineno + i, "malformed-section-header",
-                    f"`{s}` is not the canonical `{word}:` form",
-                ))
+            elif not _DASHES.match(nxt):
+                canon = _CANON.get(re.sub(r"\s+", " ", word).strip().lower())
+                if canon is not None and s != f"{canon}:":
+                    if not s.rstrip().endswith(":"):
+                        why = "missing colon"
+                    elif word != canon:
+                        why = (
+                            f"label must be `{canon}` "
+                            "(first letter capitalised, the rest lower-case)"
+                        )
+                    else:
+                        why = "stray characters around the colon"
+                    findings.append((
+                        dnode.lineno + i, "malformed-section-header",
+                        f"`{s}` should be `{canon}:` ({why})",
+                    ))
     return findings
 
 

From 424ad001f18829423606de5d8e7baf695b8f79b5 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Fri, 4 Sep 2026 18:21:27 +0800
Subject: [PATCH 13/51] Change to Google style

---
 qmcpy/true_measure/product_measure.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qmcpy/true_measure/product_measure.py b/qmcpy/true_measure/product_measure.py
index d40982eca..4c798e564 100644
--- a/qmcpy/true_measure/product_measure.py
+++ b/qmcpy/true_measure/product_measure.py
@@ -103,8 +103,8 @@ def __init__(self, sampler, marginals):
         """
         Initialize a product measure from one sampler and several marginals.
 
-        Parameters
-        ----------
+        Parameters:
+        
         sampler : AbstractDiscreteDistribution
             The sampler for the whole product measure. Its dimension must
             equal the sum of the marginal dimensions.

From 19322735fb3dde168815dd3952f5578e25996c3a Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Fri, 4 Sep 2026 18:22:02 +0800
Subject: [PATCH 14/51] Respond to github-code-quality Bot comment

---
 test/test_sr_colab_notebooks.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/test_sr_colab_notebooks.py b/test/test_sr_colab_notebooks.py
index d494c2a51..32548d2f9 100644
--- a/test/test_sr_colab_notebooks.py
+++ b/test/test_sr_colab_notebooks.py
@@ -6,8 +6,8 @@
 import sys
 import tempfile
 import unittest
+import unittest.mock as mock
 from pathlib import Path
-from unittest import mock
 
 from scripts import check_colab_notebooks as check
 from scripts import harden_colab_notebook as harden

From 53884643bc9146761861d7e2fb01ea36b57c05cd Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Sat, 5 Sep 2026 15:39:17 +0800
Subject: [PATCH 15/51] Add arg type following Google doc style

---
 docs/good_practices.md              |   4 +
 makefile                            |  40 +++
 scripts/add_docstring_arg_types.py  | 383 ++++++++++++++++++++++++++++
 test/test_sr_docstring_arg_types.py | 170 ++++++++++++
 4 files changed, 597 insertions(+)
 create mode 100644 scripts/add_docstring_arg_types.py
 create mode 100644 test/test_sr_docstring_arg_types.py

diff --git a/docs/good_practices.md b/docs/good_practices.md
index 4f9831373..ca5ecfc72 100644
--- a/docs/good_practices.md
+++ b/docs/good_practices.md
@@ -51,6 +51,10 @@ QMCPy documentation is built from docstrings, so public APIs should document the
 
 It is informational by default; `STRICT=--strict make check_docstring` makes both parts fail the build. Pass `CHECK_DOCSTRING_ARGS=--skip-missing` to skip the "no docstring" formatting check, or `DOCSTRING_PATH=qmcpy/true_measure` to narrow the scan. `make check_docstring_changed` runs the same two checks on just the `qmcpy/*.py` files that changed relative to `DOCSTRING_BASE` — the quick check to run before opening a PR (it is also part of `make format`).
 
+For annotated public APIs, `make add_docstring_arg_types` inserts missing Google-style argument types into existing `Args:` entries from the function signature. For example, `distance: float` becomes `distance (float): ...` in the docstring. Use `DOCSTRING_TYPE_PATH=path/to/file.py` to narrow the scan, or run `make add_docstring_arg_types_changed` to apply it only to Python files reported by `git diff --name-only develop -- '*.py'`. Use `DOCSTRING_TYPE_DIFF_BASE=origin/develop` to compare against a different base, and use `make check_docstring_arg_types_changed` to fail when changed files still need annotation-derived updates. The helper does not infer types for unannotated functions and does not invent missing scientific argument descriptions.
+
+For mostly well-formed Google-style docstrings, developers may also use the optional open-source `format-docstring` helper to normalize wrapping and existing argument type syntax. Install it locally with `python -m pip install format-docstring`, then run `make format_google_docstrings` to apply it under `qmcpy/`, or run `make format_google_docstrings_changed` to apply it only to Python files reported by `git diff --name-only develop -- '*.py'`. Always review the resulting diff because automated formatting can reflow examples and prose.
+
 ## Extend the Existing Object Model
 
 New functionality should fit the existing QMCPy class hierarchy instead of introducing parallel designs without discussion.
diff --git a/makefile b/makefile
index a8f7975e1..0bf7224f7 100644
--- a/makefile
+++ b/makefile
@@ -54,6 +54,13 @@ check_test_style:
 DOCSTRING_PATH ?= qmcpy
 DOCSTRING_BASE ?= origin/develop
 PYDOCLINT ?= pydoclint
+DOCSTRING_FORMATTER ?= format-docstring
+DOCSTRING_FORMAT_PATH ?= qmcpy
+DOCSTRING_FORMAT_DIFF_BASE ?= develop
+DOCSTRING_FORMAT_ARGS ?= --docstring-style google --fix-rst-backticks=False --include-arg-types=True --include-arg-defaults=False --include-return-and-yield-types=False
+DOCSTRING_TYPE_PATH ?= qmcpy
+DOCSTRING_TYPE_DIFF_BASE ?= develop
+DOCSTRING_TYPE_ARGS ?=
 # Two-part docstring check for public APIs under qmcpy/:
 #  1. scripts/check_docstring.py -- formatting: a one-line summary before the
 #     first section, no NumPy-style "-----" section underlines, a blank line
@@ -71,6 +78,39 @@ check_docstring:
 	@echo ""
 	@$(PYDOCLINT) $(PYDOCLINT_ARGS) $(DOCSTRING_PATH) $(if $(STRICT),,|| true)
 
+format_google_docstrings:
+	@command -v "$(DOCSTRING_FORMATTER)" >/dev/null 2>&1 || { \
+		echo "Missing $(DOCSTRING_FORMATTER). Install with: $(PYTHON) -m pip install format-docstring"; \
+		exit 127; \
+	}
+	@echo "$(DOCSTRING_FORMATTER) formats existing Google-style docstrings; it does not infer missing scientific argument types."
+	$(DOCSTRING_FORMATTER) $(DOCSTRING_FORMAT_ARGS) $(DOCSTRING_FORMAT_PATH)
+
+format_google_docstrings_changed:
+	@command -v "$(DOCSTRING_FORMATTER)" >/dev/null 2>&1 || { \
+		echo "Missing $(DOCSTRING_FORMATTER). Install with: $(PYTHON) -m pip install format-docstring"; \
+		exit 127; \
+	}
+	@set -e; \
+	changed_files="$$(git diff --name-only --diff-filter=ACMR "$(DOCSTRING_FORMAT_DIFF_BASE)" -- '*.py')"; \
+	if [ -z "$$changed_files" ]; then \
+		echo "No changed Python files relative to $(DOCSTRING_FORMAT_DIFF_BASE)."; \
+	else \
+		echo "$(DOCSTRING_FORMATTER) formats existing Google-style docstrings; it does not infer missing scientific argument types."; \
+		echo "Formatting Google-style docstrings in Python files changed relative to $(DOCSTRING_FORMAT_DIFF_BASE):"; \
+		printf '%s\n' "$$changed_files"; \
+		$(DOCSTRING_FORMATTER) $(DOCSTRING_FORMAT_ARGS) $$changed_files; \
+	fi
+
+add_docstring_arg_types:
+	$(PYTHON) scripts/add_docstring_arg_types.py $(DOCSTRING_TYPE_ARGS) $(DOCSTRING_TYPE_PATH)
+
+add_docstring_arg_types_changed:
+	$(PYTHON) scripts/add_docstring_arg_types.py --diff "$(DOCSTRING_TYPE_DIFF_BASE)" $(DOCSTRING_TYPE_ARGS)
+
+check_docstring_arg_types_changed:
+	$(PYTHON) scripts/add_docstring_arg_types.py --diff "$(DOCSTRING_TYPE_DIFF_BASE)" --check $(DOCSTRING_TYPE_ARGS)
+
 # Same checks as check_docstring, but only on qmcpy/*.py files that changed
 # relative to DOCSTRING_BASE (committed, staged/unstaged, and untracked).
 check_docstring_changed:
diff --git a/scripts/add_docstring_arg_types.py b/scripts/add_docstring_arg_types.py
new file mode 100644
index 000000000..479096dfb
--- /dev/null
+++ b/scripts/add_docstring_arg_types.py
@@ -0,0 +1,383 @@
+#!/usr/bin/env python3
+"""Add Google-style argument types from Python annotations.
+
+This helper is intentionally conservative: it rewrites existing ``Args:``
+entries for public functions and methods only when the corresponding argument
+has an explicit annotation in the signature. It does not infer types from
+implementation code and it does not invent missing argument descriptions.
+"""
+from __future__ import annotations
+
+import argparse
+import ast
+import re
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+
+SECTION_HEADER = re.compile(r"^\s*[A-Z][A-Za-z]*(?: [A-Z][A-Za-z]*)*:\s*$")
+ARG_ENTRY = re.compile(
+    r"^(?P<indent>\s*)"
+    r"(?P<name>\*{0,2}[A-Za-z_][A-Za-z0-9_]*)"
+    r"\s*"
+    r"(?:\((?P<type>[^)]*)\))?"
+    r"\s*:\s*"
+    r"(?P<description>.*)$"
+)
+
+
+@dataclass
+class Update:
+    path: Path
+    line: int
+    function: str
+    argument: str
+    annotation: str
+    previous_type: str | None
+
+
+@dataclass
+class Skip:
+    path: Path
+    line: int
+    function: str
+    reason: str
+
+
+@dataclass
+class FileResult:
+    path: Path
+    updates: list[Update]
+    skips: list[Skip]
+    changed: bool
+
+
+def _doc_node(node: ast.AST) -> ast.Constant | None:
+    """Return the string-literal node holding ``node``'s docstring, if any."""
+    body = getattr(node, "body", None)
+    if (
+        body
+        and isinstance(body[0], ast.Expr)
+        and isinstance(body[0].value, ast.Constant)
+        and isinstance(body[0].value.value, str)
+    ):
+        return body[0].value
+    return None
+
+
+def _public_functions(tree: ast.Module):
+    """Yield public module functions and methods from public classes."""
+    for node in tree.body:
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            if not node.name.startswith("_"):
+                yield node, node.name
+        elif isinstance(node, ast.ClassDef) and not node.name.startswith("_"):
+            for sub in node.body:
+                if not isinstance(sub, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                    continue
+                if sub.name == "__init__" or not sub.name.startswith("_"):
+                    yield sub, f"{node.name}.{sub.name}"
+
+
+def _annotation_text(source: str, annotation: ast.AST | None) -> str | None:
+    """Return the source spelling of a type annotation."""
+    if annotation is None:
+        return None
+    if isinstance(annotation, ast.Constant) and isinstance(annotation.value, str):
+        return annotation.value
+    text = ast.get_source_segment(source, annotation)
+    if text is not None:
+        text = text.strip()
+        if (
+            len(text) >= 2
+            and text[0] in {"'", '"'}
+            and text[-1] == text[0]
+        ):
+            try:
+                value = ast.literal_eval(text)
+            except (SyntaxError, ValueError):
+                return text
+            if isinstance(value, str):
+                return value
+    # ``ast.unparse`` turns a multiline annotation into a safe, single-line
+    # representation for a Google-style argument entry.
+    return ast.unparse(annotation)
+
+
+def _argument_annotations(node: ast.FunctionDef | ast.AsyncFunctionDef, source: str):
+    """Map argument names to explicit annotation text."""
+    annotations = {}
+    args = (
+        list(node.args.posonlyargs)
+        + list(node.args.args)
+        + list(node.args.kwonlyargs)
+    )
+    for arg in args:
+        if arg.arg in {"self", "cls"}:
+            continue
+        annotation = _annotation_text(source, arg.annotation)
+        if annotation is not None:
+            annotations[arg.arg] = annotation
+    if node.args.vararg is not None:
+        annotation = _annotation_text(source, node.args.vararg.annotation)
+        if annotation is not None:
+            annotations[node.args.vararg.arg] = annotation
+    if node.args.kwarg is not None:
+        annotation = _annotation_text(source, node.args.kwarg.annotation)
+        if annotation is not None:
+            annotations[node.args.kwarg.arg] = annotation
+    return annotations
+
+
+def _line_without_ending(line: str) -> tuple[str, str]:
+    """Split a line into content and original line ending."""
+    if line.endswith("\r\n"):
+        return line[:-2], "\r\n"
+    if line.endswith("\n"):
+        return line[:-1], "\n"
+    return line, ""
+
+
+def _find_args_section(
+    lines: list[str], start: int, end: int
+) -> tuple[int, int] | None:
+    """Return ``(args_line, section_end)`` indexes for a Google Args section."""
+    args_line = None
+    args_indent = None
+    for i in range(start, end + 1):
+        content, _ = _line_without_ending(lines[i])
+        if content.strip() == "Args:":
+            args_line = i
+            args_indent = len(content) - len(content.lstrip())
+            break
+    if args_line is None or args_indent is None:
+        return None
+
+    section_end = end
+    for i in range(args_line + 1, end + 1):
+        content, _ = _line_without_ending(lines[i])
+        stripped = content.strip()
+        if not stripped:
+            continue
+        indent = len(content) - len(content.lstrip())
+        if indent <= args_indent and SECTION_HEADER.match(content):
+            section_end = i - 1
+            break
+    return args_line, section_end
+
+
+def _update_args_section(
+    path: Path,
+    lines: list[str],
+    node: ast.FunctionDef | ast.AsyncFunctionDef,
+    function: str,
+    annotations: dict[str, str],
+    overwrite_existing: bool,
+) -> tuple[list[Update], list[Skip]]:
+    """Add annotation text to matching ``Args:`` entries."""
+    dnode = _doc_node(node)
+    if dnode is None or dnode.end_lineno is None:
+        return [], [Skip(path, node.lineno, function, "missing docstring")]
+
+    section = _find_args_section(lines, dnode.lineno - 1, dnode.end_lineno - 1)
+    if section is None:
+        return [], [Skip(path, dnode.lineno, function, "missing Args section")]
+
+    updates = []
+    seen = set()
+    _, section_end = section
+    for i in range(section[0] + 1, section_end + 1):
+        content, ending = _line_without_ending(lines[i])
+        match = ARG_ENTRY.match(content)
+        if match is None:
+            continue
+        display_name = match.group("name")
+        argument = display_name.lstrip("*")
+        if argument not in annotations:
+            continue
+        seen.add(argument)
+        previous_type = match.group("type")
+        if previous_type is not None and not overwrite_existing:
+            continue
+        annotation = annotations[argument]
+        description = match.group("description").lstrip()
+        suffix = f" {description}" if description else ""
+        replacement = (
+            f"{match.group('indent')}{display_name} ({annotation}):{suffix}{ending}"
+        )
+        if replacement == lines[i]:
+            continue
+        lines[i] = replacement
+        updates.append(
+            Update(
+                path=path,
+                line=i + 1,
+                function=function,
+                argument=argument,
+                annotation=annotation,
+                previous_type=previous_type,
+            )
+        )
+
+    skips = [
+        Skip(
+            path,
+            node.lineno,
+            function,
+            f"missing Args entry for annotated argument `{name}`",
+        )
+        for name in sorted(set(annotations) - seen)
+    ]
+    return updates, skips
+
+
+def update_file(
+    path: Path, check: bool = False, overwrite_existing: bool = False
+) -> FileResult:
+    """Update one Python file."""
+    source = path.read_text(encoding="utf-8")
+    tree = ast.parse(source, filename=str(path))
+    lines = source.splitlines(keepends=True)
+    updates = []
+    skips = []
+
+    for node, function in _public_functions(tree):
+        annotations = _argument_annotations(node, source)
+        if not annotations:
+            continue
+        node_updates, node_skips = _update_args_section(
+            path=path,
+            lines=lines,
+            node=node,
+            function=function,
+            annotations=annotations,
+            overwrite_existing=overwrite_existing,
+        )
+        updates.extend(node_updates)
+        skips.extend(node_skips)
+
+    changed = bool(updates)
+    if changed and not check:
+        path.write_text("".join(lines), encoding="utf-8")
+    return FileResult(path=path, updates=updates, skips=skips, changed=changed)
+
+
+def _changed_files(ref: str) -> list[Path]:
+    """Return Python files changed relative to ``ref`` using ``git diff``."""
+    result = subprocess.run(
+        ["git", "diff", "--name-only", "--diff-filter=ACMR", ref, "--", "*.py"],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    return [Path(name) for name in result.stdout.splitlines()]
+
+
+def _python_files(paths: list[str], diff_ref: str | None) -> list[Path]:
+    """Collect Python files from paths, or from ``git diff`` when requested."""
+    if diff_ref is not None:
+        candidates = _changed_files(diff_ref)
+    else:
+        candidates = [Path(p) for p in (paths or ["qmcpy"])]
+
+    files = []
+    for path in candidates:
+        if path.is_dir():
+            files.extend(sorted(path.rglob("*.py")))
+        elif path.suffix == ".py" and path.exists():
+            files.append(path)
+    return sorted(dict.fromkeys(files))
+
+
+def _parse_args(argv: list[str]) -> argparse.Namespace:
+    """Parse command-line arguments."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "paths",
+        nargs="*",
+        help="Python files or directories to update. Defaults to qmcpy.",
+    )
+    parser.add_argument(
+        "--diff",
+        metavar="REF",
+        help="Update Python files reported by `git diff --name-only REF -- '*.py'`.",
+    )
+    parser.add_argument(
+        "--check",
+        action="store_true",
+        help="Report files that would change without writing them.",
+    )
+    parser.add_argument(
+        "--overwrite-existing",
+        action="store_true",
+        help="Replace existing Google Args types with signature annotations.",
+    )
+    parser.add_argument(
+        "--quiet",
+        action="store_true",
+        help="Only print the final summary.",
+    )
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str]) -> int:
+    """Run the command-line interface."""
+    args = _parse_args(argv)
+    try:
+        files = _python_files(args.paths, args.diff)
+    except subprocess.CalledProcessError as exc:
+        print(f"git diff failed: {exc}", file=sys.stderr)
+        return 2
+
+    if not files:
+        print("No Python files to inspect.")
+        return 0
+
+    results = []
+    had_parse_error = False
+    for path in files:
+        try:
+            result = update_file(
+                path,
+                check=args.check,
+                overwrite_existing=args.overwrite_existing,
+            )
+        except SyntaxError as exc:
+            had_parse_error = True
+            print(f"{path}: skipped syntax error: {exc}", file=sys.stderr)
+            continue
+        results.append(result)
+
+    updates = [update for result in results for update in result.updates]
+    skips = [skip for result in results for skip in result.skips]
+    if not args.quiet:
+        for update in updates:
+            action = "would update" if args.check else "updated"
+            old = (
+                ""
+                if update.previous_type is None
+                else f" replacing `{update.previous_type}`"
+            )
+            print(
+                f"{update.path}:{update.line}: {action} "
+                f"{update.function}.{update.argument} ({update.annotation}){old}"
+            )
+        for skip in skips:
+            print(f"{skip.path}:{skip.line}: skipped {skip.function}: {skip.reason}")
+
+    changed_files = sum(1 for result in results if result.changed)
+    verb = "would change" if args.check else "changed"
+    print(
+        f"{len(files)} file(s) inspected; {len(updates)} Args type update(s); "
+        f"{changed_files} file(s) {verb}."
+    )
+
+    if args.check and updates:
+        return 1
+    return 2 if had_parse_error else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))
diff --git a/test/test_sr_docstring_arg_types.py b/test/test_sr_docstring_arg_types.py
new file mode 100644
index 000000000..a006cb35c
--- /dev/null
+++ b/test/test_sr_docstring_arg_types.py
@@ -0,0 +1,170 @@
+import shutil
+import tempfile
+import textwrap
+import unittest
+from contextlib import redirect_stdout
+from io import StringIO
+from pathlib import Path
+
+from scripts import add_docstring_arg_types
+
+
+class TestAddDocstringArgTypes(unittest.TestCase):
+
+    def setUp(self):
+        self.tmp_path = Path(tempfile.mkdtemp())
+        self.addCleanup(shutil.rmtree, self.tmp_path, ignore_errors=True)
+
+    def _write(self, source):
+        path = self.tmp_path / "sample.py"
+        path.write_text(textwrap.dedent(source).lstrip(), encoding="utf-8")
+        return path
+
+    def test_adds_annotation_types_to_existing_google_args(self):
+        path = self._write(
+            '''
+            def calculate_velocity(
+                distance: float,
+                time: float,
+                acceleration: float = 0.0,
+            ) -> float:
+                """Calculate velocity.
+
+                Args:
+                    distance: Distance traveled.
+                    time: Elapsed time.
+                    acceleration: Constant acceleration.
+
+                Returns:
+                    float: Velocity.
+                """
+                return distance / time + acceleration * time
+            '''
+        )
+
+        result = add_docstring_arg_types.update_file(path)
+        source = path.read_text(encoding="utf-8")
+
+        self.assertTrue(result.changed)
+        self.assertEqual(
+            [(update.argument, update.annotation) for update in result.updates],
+            [
+                ("distance", "float"),
+                ("time", "float"),
+                ("acceleration", "float"),
+            ],
+        )
+        self.assertIn("distance (float): Distance traveled.", source)
+        self.assertIn("time (float): Elapsed time.", source)
+        self.assertIn("acceleration (float): Constant acceleration.", source)
+
+    def test_check_mode_reports_without_writing(self):
+        path = self._write(
+            '''
+            def scale(x: int):
+                """Scale x.
+
+                Args:
+                    x: Value to scale.
+                """
+                return 2 * x
+            '''
+        )
+        original = path.read_text(encoding="utf-8")
+
+        output = StringIO()
+        with redirect_stdout(output):
+            status = add_docstring_arg_types.main(["--check", str(path)])
+
+        self.assertEqual(status, 1)
+        self.assertIn("1 file(s) would change", output.getvalue())
+        self.assertEqual(path.read_text(encoding="utf-8"), original)
+
+    def test_preserves_existing_type_unless_overwrite_is_requested(self):
+        path = self._write(
+            '''
+            def scale(x: float):
+                """Scale x.
+
+                Args:
+                    x (int): Value to scale.
+                """
+                return 2 * x
+            '''
+        )
+
+        result = add_docstring_arg_types.update_file(path)
+        self.assertFalse(result.changed)
+        self.assertIn("x (int):", path.read_text(encoding="utf-8"))
+
+        result = add_docstring_arg_types.update_file(path, overwrite_existing=True)
+        self.assertTrue(result.changed)
+        self.assertIn("x (float):", path.read_text(encoding="utf-8"))
+
+    def test_updates_public_constructor_without_documenting_self(self):
+        path = self._write(
+            '''
+            class Body:
+
+                def __init__(self, mass: float):
+                    """Initialize a body.
+
+                    Args:
+                        mass: Body mass.
+                    """
+                    self.mass = mass
+            '''
+        )
+
+        result = add_docstring_arg_types.update_file(path)
+
+        self.assertEqual(len(result.updates), 1)
+        self.assertEqual(result.updates[0].argument, "mass")
+        self.assertIn("mass (float): Body mass.", path.read_text(encoding="utf-8"))
+
+    def test_normalizes_multiline_annotations_and_colon_spacing(self):
+        path = self._write(
+            '''
+            def first(
+                values: list[
+                    float
+                ],
+            ):
+                """Return the first value.
+
+                Args:
+                    values :  Values to inspect.
+                """
+                return values[0]
+            '''
+        )
+
+        result = add_docstring_arg_types.update_file(path)
+        source = path.read_text(encoding="utf-8")
+
+        self.assertTrue(result.changed)
+        self.assertIn("values (list[float]): Values to inspect.", source)
+
+    def test_does_not_infer_a_type_for_an_unannotated_argument(self):
+        path = self._write(
+            '''
+            def scale(x):
+                """Scale a value.
+
+                Args:
+                    x: Value to scale.
+                """
+                return 2 * x
+            '''
+        )
+        original = path.read_text(encoding="utf-8")
+
+        result = add_docstring_arg_types.update_file(path)
+
+        self.assertFalse(result.changed)
+        self.assertEqual(result.updates, [])
+        self.assertEqual(path.read_text(encoding="utf-8"), original)
+
+
+if __name__ == "__main__":
+    unittest.main()

From b81d548810609bc953fcd42b771093cbfddcf77d Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Sat, 5 Sep 2026 15:41:08 +0800
Subject: [PATCH 16/51] mkae format_google_docstrings

---
 .../abstract_discrete_distribution.py         |  38 +-
 .../digital_net_any_bases.py                  | 101 ++--
 .../digital_net_any_bases/faure.py            |  27 +-
 .../digital_net_any_bases/halton.py           |  47 +-
 .../digital_net_any_bases/hammersley.py       |  45 +-
 .../digital_net_b2/digital_net_b2.py          |  46 +-
 qmcpy/discrete_distribution/dummy_sampler.py  |   4 +-
 .../discrete_distribution/iid_std_uniform.py  |  13 +-
 qmcpy/discrete_distribution/korobov.py        |  32 +-
 qmcpy/discrete_distribution/kronecker.py      |  61 +--
 .../discrete_distribution/latin_hypercube.py  |  57 +--
 .../discrete_distribution/lattice/lattice.py  |  33 +-
 qmcpy/discrete_distribution/mpmc/__init__.py  |  32 +-
 qmcpy/discrete_distribution/mpmc/mpmc.py      |  18 +-
 qmcpy/discrete_distribution/mpmc/utils.py     |   4 +-
 qmcpy/fast_transform/ft.py                    |  39 +-
 qmcpy/fast_transform/ft_pytorch.py            |  42 +-
 qmcpy/fast_transform/ft_qmctoolscl.py         |  30 +-
 qmcpy/integrand/abstract_integrand.py         | 118 +++--
 qmcpy/integrand/bayesian_lr_coeffs.py         |  20 +-
 qmcpy/integrand/box_integral.py               |  14 +-
 qmcpy/integrand/custom_fun.py                 |  30 +-
 qmcpy/integrand/financial_option.py           | 105 ++--
 qmcpy/integrand/fourbranch2d.py               |  12 +-
 qmcpy/integrand/genz.py                       |  17 +-
 qmcpy/integrand/hartmann6d.py                 |  10 +-
 qmcpy/integrand/ishigami.py                   |  12 +-
 qmcpy/integrand/keister.py                    |  17 +-
 qmcpy/integrand/linear0.py                    |   9 +-
 qmcpy/integrand/multimodal2d.py               |   9 +-
 qmcpy/integrand/sensitivity_indices.py        |  12 +-
 qmcpy/integrand/sin1d.py                      |   9 +-
 qmcpy/integrand/umbridge_wrapper.py           |  23 +-
 qmcpy/kernel/abstract_kernel.py               |  77 ++-
 qmcpy/kernel/common_kernels.py                |  91 ++--
 qmcpy/kernel/multitask_kernel.py              |  96 ++--
 qmcpy/kernel/si_dsi_kernels.py                | 466 +++++++++++-------
 qmcpy/stopping_criterion/abstract_cub_mlmc.py |  12 +-
 .../stopping_criterion/abstract_cub_mlqmc.py  |   3 +-
 .../abstract_stopping_criterion.py            | 122 ++---
 qmcpy/stopping_criterion/cub_mc_clt.py        |  10 +-
 qmcpy/stopping_criterion/cub_mc_clt_vec.py    |  11 +-
 qmcpy/stopping_criterion/cub_mc_g.py          |  12 +-
 qmcpy/stopping_criterion/cub_mlmc.py          |  36 +-
 qmcpy/stopping_criterion/cub_mlmc_cont.py     |  29 +-
 qmcpy/stopping_criterion/cub_mlqmc.py         |  21 +-
 qmcpy/stopping_criterion/cub_mlqmc_cont.py    |  23 +-
 .../cub_qmc_bayes_lattice_g.py                |  18 +-
 .../stopping_criterion/cub_qmc_bayes_net_g.py |  12 +-
 qmcpy/stopping_criterion/cub_qmc_lattice_g.py |  21 +-
 qmcpy/stopping_criterion/cub_qmc_net_g.py     |  26 +-
 .../cub_qmc_rep_student_t.py                  |   7 +-
 qmcpy/stopping_criterion/diagnostics.py       |  75 +--
 qmcpy/stopping_criterion/pf_gp_ci.py          |  66 ++-
 qmcpy/true_measure/abstract_true_measure.py   |  43 +-
 qmcpy/true_measure/acceptance_rejection.py    | 182 ++++---
 qmcpy/true_measure/bernoulli_cont.py          |  11 +-
 qmcpy/true_measure/brownian_motion.py         |  49 +-
 qmcpy/true_measure/clayton_copula.py          |  22 +-
 qmcpy/true_measure/copula.py                  |  30 +-
 qmcpy/true_measure/frank_copula.py            |  21 +-
 qmcpy/true_measure/gaussian.py                |  19 +-
 qmcpy/true_measure/gaussian_copula.py         |  14 +-
 .../true_measure/geometric_brownian_motion.py |  62 ++-
 qmcpy/true_measure/gumbel_copula.py           |  22 +-
 qmcpy/true_measure/johnsons_su.py             |   8 +-
 qmcpy/true_measure/kumaraswamy.py             |  25 +-
 qmcpy/true_measure/lebesgue.py                |   7 +-
 qmcpy/true_measure/matern_gp.py               |  24 +-
 qmcpy/true_measure/product_measure.py         |  88 ++--
 qmcpy/true_measure/scipy_wrapper.py           |  59 +--
 qmcpy/true_measure/student_t.py               |   6 +-
 qmcpy/true_measure/student_t_copula.py        |  27 +-
 qmcpy/true_measure/triangular.py              |   8 +-
 qmcpy/true_measure/uniform.py                 |   7 +-
 qmcpy/true_measure/uniform_triangle.py        |  12 +-
 .../true_measure/zero_inflated_exp_uniform.py |  39 +-
 qmcpy/util/abstraction_functions.py           |  11 +-
 qmcpy/util/data.py                            |  23 +-
 qmcpy/util/dig_shift_invar_ops.py             |  75 +--
 qmcpy/util/exceptions_warnings.py             |  29 +-
 qmcpy/util/latnetbuilder_linker.py            |  13 +-
 qmcpy/util/mlmc_test.py                       |  23 +-
 qmcpy/util/plot_functions.py                  |  24 +-
 qmcpy/util/shift_invar_ops.py                 |  14 +-
 85 files changed, 1865 insertions(+), 1452 deletions(-)

diff --git a/qmcpy/discrete_distribution/abstract_discrete_distribution.py b/qmcpy/discrete_distribution/abstract_discrete_distribution.py
index 708141c76..d9c846d78 100644
--- a/qmcpy/discrete_distribution/abstract_discrete_distribution.py
+++ b/qmcpy/discrete_distribution/abstract_discrete_distribution.py
@@ -62,17 +62,19 @@ def __call__(self, n=None, n_min=None, n_max=None, return_binary=False, warn=Tru
             n (Union[None, int]): Number of points to generate.
             n_min (Union[None, int]): Starting index of sequence.
             n_max (Union[None, int]): Final index of sequence.
-            return_binary (bool): Only used for `DigitalNetB2`.
-                If `True`, *only* return the integer representation `x_integer` of base 2 digital net.
+            return_binary (bool): Only used for `DigitalNetB2`. If `True`,
+                *only* return the integer representation `x_integer` of base 2
+                digital net.
             warn (bool): If `False`, disable warnings when generating samples.
 
         Returns:
-            x (np.ndarray): Samples from the sequence.
+            Samples from the sequence.
 
-                - If `replications` is `None` then this will be of size (`n_max`-`n_min`) $\times$ `dimension`
-                - If `replications` is a positive int, then `x` will be of size `replications` $\times$ (`n_max`-`n_min`) $\times$ `dimension`
+            - If `replications` is `None` then this will be of size (`n_max`-`n_min`) $\times$ `dimension`
+            - If `replications` is a positive int, then `x` will be of size `replications` $\times$ (`n_max`-`n_min`) $\times$ `dimension`
 
-                Note that if `return_binary=True` then `x` is returned where `x` are integer representations of the digital net points.
+            Note that if `return_binary=True` then `x` is returned where `x`
+            are integer representations of the digital net points.
         """
         return self.gen_samples(
             n=n, n_min=n_min, n_max=n_max, return_binary=return_binary, warn=warn
@@ -123,19 +125,21 @@ def _gen_samples(self, *args, **kwargs):
         raise MethodImplementationError(self, "_gen_samples")
 
     def spawn(self, s=1, dimensions=None):
-        r"""
-        Spawn new instances of the current discrete distribution but with new seeds and dimensions.
-        Used by multi-level QMC algorithms which require different seeds and dimensions on each level.
+        r"""Spawn new instances of the current discrete distribution but with
+        new seeds and dimensions. Used by multi-level QMC algorithms which
+        require different seeds and dimensions on each level.
 
-        Note:
-            Use `replications` instead of using `spawn` when possible, e.g., when spawning copies which all have the same dimension.
+        Notes:
+            Use `replications` instead of using `spawn` when possible, e.g.,
+            when spawning copies which all have the same dimension.
 
         Args:
             s (int): Number of copies to spawn
-            dimensions (np.ndarray): Length `s` array of dimensions for each copy. Defaults to the current dimension.
+            dimensions (np.ndarray): Length `s` array of dimensions for each
+                copy. Defaults to the current dimension.
 
         Returns:
-            spawned_discrete_distribs (list): Discrete distributions with new seeds and dimensions.
+            Discrete distributions with new seeds and dimensions.
         """
         s = int(s)
         if s <= 0:
@@ -171,14 +175,18 @@ def __repr__(self, abc_class_name):
 
 
 class AbstractLDDiscreteDistribution(AbstractDiscreteDistribution):
-    """Low discrepancy sequence. Alias for `AbstractDiscreteDistribution` used for compatibility checks."""
+    """Low discrepancy sequence. Alias for `AbstractDiscreteDistribution`
+    used for compatibility checks.
+    """
 
     def __repr__(self):
         return super().__repr__("AbstractLDDiscreteDistribution")
 
 
 class AbstractIIDDiscreteDistribution(AbstractDiscreteDistribution):
-    """IID sequence. Alias for `AbstractDiscreteDistribution` used for compatibility checks."""
+    """IID sequence. Alias for `AbstractDiscreteDistribution` used for
+    compatibility checks.
+    """
 
     def __repr__(self):
         return super().__repr__("AbstractIIDDiscreteDistribution")
diff --git a/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py b/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py
index 0504deb81..220104cec 100644
--- a/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py
+++ b/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py
@@ -9,26 +9,29 @@
 
 
 class DigitalNetAnyBases(AbstractLDDiscreteDistribution):
-    r"""
-    Low discrepancy digital net with arbitrary bases for each dimension. 
-    
-    Note: 
-        - Digital net samples sizes should be products of powers of bases, 
-        i.e., a digital net with bases $(b_1,\dots,b_d)$ 
-        will prefer sample sizes $n = b_1^{p_1} \cdots b_d^{p_d}$ for some $p_1,\dots,p_d \in \mathbb{N}_0$.
-        - The first point of an unrandomized digital net is the origin. 
-        - The construction of higher order digital nets requires the same base for each dimension. 
-        To construct higher order digital nets, either: 
-        
-            - Pass in `generating_matrices` *without* interlacing and supply `alpha>1` to apply interlacing, or 
-            - Pass in `generating_matrices` *with* interlacing and set `alpha=1` to avoid additional interlacing. 
-            
-            i.e. do *not* pass in interlaced `generating_matrices` and set `alpha>1`, this will apply additional interlacing. 
-    
-    A few examples below showcase how to pass in custom bases and generating matrices. Many other examples can be found in the Halton and Faure implementations
-    
+    r"""Low discrepancy digital net with arbitrary bases for each dimension.
+
+    Notes:
+        - Digital net samples sizes should be products of powers of bases,
+        i.e., a digital net with bases $(b_1,\dots,b_d)$ will prefer sample
+        sizes $n = b_1^{p_1} \cdots b_d^{p_d}$ for some $p_1,\dots,p_d \in
+        \mathbb{N}_0$.
+        - The first point of an unrandomized digital net is the origin.
+        - The construction of higher order digital nets requires the same base for each dimension.
+        To construct higher order digital nets, either:
+
+            - Pass in `generating_matrices` *without* interlacing and supply `alpha>1` to apply interlacing, or
+            - Pass in `generating_matrices` *with* interlacing and set `alpha=1` to avoid additional interlacing.
+
+            i.e. do *not* pass in interlaced `generating_matrices` and set
+            `alpha>1`, this will apply additional interlacing.
+
+    A few examples below showcase how to pass in custom bases and generating
+    matrices. Many other examples can be found in the Halton and Faure
+    implementations
+
     Examples:
-        >>> bases = 3 
+        >>> bases = 3
         >>> generating_matrices = np.array(
         ...     [
         ...         [[1, 0, 0],
@@ -59,7 +62,7 @@ class DigitalNetAnyBases(AbstractLDDiscreteDistribution):
                [0.30864198],
                [0.5308642 ],
                [0.75308642]])
-    
+
         >>> rng = np.random.Generator(np.random.PCG64(7))
         >>> bases = np.array(
         ...     [[2,5,7,23],
@@ -107,7 +110,7 @@ class DigitalNetAnyBases(AbstractLDDiscreteDistribution):
                 [0.16158904, 0.74257456, 0.19604142, 0.98366484],
                 [0.33578478, 0.31746094, 0.35948446, 0.75911922],
                 [0.64593022, 0.11007165, 0.63174328, 0.55910368]]])
-        
+
         >>> bases = 2
         >>> generating_matrices = np.array([
         ...     [[1, 0, 0],
@@ -139,15 +142,15 @@ class DigitalNetAnyBases(AbstractLDDiscreteDistribution):
                [0.375, 0.125]])
         >>> bool((x==x_b2).all())
         True
-    
-    **References:**
 
-    1.  Dick, Josef, and Friedrich Pillichshammer.  
-        Digital nets and sequences: discrepancy theory and quasi–Monte Carlo integration.  
+    **References: **
+
+    1.  Dick, Josef, and Friedrich Pillichshammer.
+        Digital nets and sequences: discrepancy theory and quasi–Monte Carlo integration.
         Cambridge University Press, 2010.
-    
-    2.  Sorokin, Aleksei.  
-        "QMCPy: A Python Software for Randomized Low-Discrepancy Sequences, Quasi-Monte Carlo, and Fast Kernel Methods"  
+
+    2.  Sorokin, Aleksei.
+        "QMCPy: A Python Software for Randomized Low-Discrepancy Sequences, Quasi-Monte Carlo, and Fast Kernel Methods"
         arXiv preprint arXiv:2502.14256 (2025).
     """
 
@@ -169,11 +172,13 @@ def __init__(self,
 
                 - If an `int` is passed in, use generating vector components at indices 0,...,`dimension`-1.
                 - If an `np.ndarray` is passed in, use generating vector components at these indices.
-            
-            replications (int): Number of independent randomizations of a pointset.
-            seed (Union[None,int,np.random.SeedSeq]): Seed the random number generator for reproducibility.
+
+            replications (int): Number of independent randomizations of a
+                pointset.
+            seed (Union[None,int,np.random.SeedSeq]): Seed the random number
+                generator for reproducibility.
             randomize (str): Options are
-                
+
                 - `'LMS DP'`: Linear matrix scramble with digital permutation.
                 - `'LMS DS'`: Linear matrix scramble with digital shift.
                 - `'LMS'`: Linear matrix scramble only.
@@ -181,24 +186,28 @@ def __init__(self,
                 - `'DS'`: Digital shift only.
                 - `'NUS'`: Nested uniform scrambling.
                 - `'QRNG'`: Deterministic permutation scramble and random digital shift from QRNG [1] (with `generalize=True`). Does *not* support replications>1.
-                - `None`: No randomization. In this case the first point will be the origin. 
-            
-            bases_generating_matrices (Union[str, tuple]): Specify the bases and the generating matrices.
-                
+                - `None`: No randomization. In this case the first point will be the origin.
+
+            bases_generating_matrices (Union[str, tuple]): Specify the bases
+                and the generating matrices.
+
                 - `"HALTON"` will use Halton generating matrices.
                 - `"FAURE"` will use Faure generating matrices .
-                - `bases,generating_matrices` requires 
-                    
+                - `bases,generating_matrices` requires
+
                     - `bases` is an `np.ndarray` of integers with shape $(,d)$ or $(r,d)$ where $d$ is the number of dimensions and $r$ is the number of replications.
                     - `generating_matrices` is an `np.ndarray` of integers with shape $(d,m_\mathrm{max},t_\mathrm{max})$ or $(r,d,m_\mathrm{max},t_\mathrm{max})$ where $d$ is the number of dimensions, $r$ is the number of replications, and $2^{m_\mathrm{max}}$ is the maximum number of supported points.
-            
-            t (int): Number of digits *after* randomization. The number of digits in the generating matrices is inferred.
-            alpha (int): Interlacing factor for higher order nets.  
-                When `alpha`>1, interlacing is performed regardless of the generating matrices,  
-                i.e., for `alpha`>1 do *not* pass in generating matrices which are already interlaced.  
-                The Note for this class contains more info.  
-            n_lim (int): Maximum number of compatible points, determines the number of rows in the generating matrices. 
-            warn (bool): If `False`, suppress warnings in construction 
+
+            t (int): Number of digits *after* randomization. The number of
+                digits in the generating matrices is inferred.
+            alpha (int): Interlacing factor for higher order nets. When
+                `alpha`>1, interlacing is performed regardless of the
+                generating matrices, i.e., for `alpha`>1 do *not* pass in
+                generating matrices which are already interlaced. The Note for
+                this class contains more info.
+            n_lim (int): Maximum number of compatible points, determines the
+                number of rows in the generating matrices.
+            warn (bool): If `False`, suppress warnings in construction
         """
         self.parameters = ['randomize','t','n_limit']
         self.all_primes = np.array([2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, 2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079, 3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 3169, 3181, 3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, 3259, 3271, 3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331, 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413, 3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 3517, 3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571, 3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637, 3643, 3659, 3671, 3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727, 3733, 3739, 3761, 3767, 3769, 3779, 3793, 3797, 3803, 3821, 3823, 3833, 3847, 3851, 3853, 3863, 3877, 3881, 3889, 3907, 3911, 3917, 3919, 3923, 3929, 3931, 3943, 3947, 3967, 3989, 4001, 4003, 4007, 4013, 4019, 4021, 4027, 4049, 4051, 4057, 4073, 4079, 4091, 4093, 4099, 4111, 4127, 4129, 4133, 4139, 4153, 4157, 4159, 4177, 4201, 4211, 4217, 4219, 4229, 4231, 4241, 4243, 4253, 4259, 4261, 4271, 4273, 4283, 4289, 4297, 4327, 4337, 4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409, 4421, 4423, 4441, 4447, 4451, 4457, 4463, 4481, 4483, 4493, 4507, 4513, 4517, 4519, 4523, 4547, 4549, 4561, 4567, 4583, 4591, 4597, 4603, 4621, 4637, 4639, 4643, 4649, 4651, 4657, 4663, 4673, 4679, 4691, 4703, 4721, 4723, 4729, 4733, 4751, 4759, 4783, 4787, 4789, 4793, 4799, 4801, 4813, 4817, 4831, 4861, 4871, 4877, 4889, 4903, 4909, 4919, 4931, 4933, 4937, 4943, 4951, 4957, 4967, 4969, 4973, 4987, 4993, 4999, 5003, 5009, 5011, 5021, 5023, 5039, 5051, 5059, 5077, 5081, 5087, 5099, 5101, 5107, 5113, 5119, 5147, 5153, 5167, 5171, 5179, 5189, 5197, 5209, 5227, 5231, 5233, 5237, 5261, 5273, 5279, 5281, 5297, 5303, 5309, 5323, 5333, 5347, 5351, 5381, 5387, 5393, 5399, 5407, 5413, 5417, 5419, 5431, 5437, 5441, 5443, 5449, 5471, 5477, 5479, 5483, 5501, 5503, 5507, 5519, 5521, 5527, 5531, 5557, 5563, 5569, 5573, 5581, 5591, 5623, 5639, 5641, 5647, 5651, 5653, 5657, 5659, 5669, 5683, 5689, 5693, 5701, 5711, 5717, 5737, 5741, 5743, 5749, 5779, 5783, 5791, 5801, 5807, 5813, 5821, 5827, 5839, 5843, 5849, 5851, 5857, 5861, 5867, 5869, 5879, 5881, 5897, 5903, 5923, 5927, 5939, 5953, 5981, 5987, 6007, 6011, 6029, 6037, 6043, 6047, 6053, 6067, 6073, 6079, 6089, 6091, 6101, 6113, 6121, 6131, 6133, 6143, 6151, 6163, 6173, 6197, 6199, 6203, 6211, 6217, 6221, 6229, 6247, 6257, 6263, 6269, 6271, 6277, 6287, 6299, 6301, 6311, 6317, 6323, 6329, 6337, 6343, 6353, 6359, 6361, 6367, 6373, 6379, 6389, 6397, 6421, 6427, 6449, 6451, 6469, 6473, 6481, 6491, 6521, 6529, 6547, 6551, 6553, 6563, 6569, 6571, 6577, 6581, 6599, 6607, 6619, 6637, 6653, 6659, 6661, 6673, 6679, 6689, 6691, 6701, 6703, 6709, 6719, 6733, 6737, 6761, 6763, 6779, 6781, 6791, 6793, 6803, 6823, 6827, 6829, 6833, 6841, 6857, 6863, 6869, 6871, 6883, 6899, 6907, 6911, 6917, 6947, 6949, 6959, 6961, 6967, 6971, 6977, 6983, 6991, 6997, 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, 7121, 7127, 7129, 7151, 7159, 7177, 7187, 7193, 7207, 7211, 7213, 7219, 7229, 7237, 7243, 7247, 7253, 7283, 7297, 7307, 7309, 7321, 7331, 7333, 7349, 7351, 7369, 7393, 7411, 7417, 7433, 7451, 7457, 7459, 7477, 7481, 7487, 7489, 7499, 7507, 7517, 7523, 7529, 7537, 7541, 7547, 7549, 7559, 7561, 7573, 7577, 7583, 7589, 7591, 7603, 7607, 7621, 7639, 7643, 7649, 7669, 7673, 7681, 7687, 7691, 7699, 7703, 7717, 7723, 7727, 7741, 7753, 7757, 7759, 7789, 7793, 7817, 7823, 7829, 7841, 7853, 7867, 7873, 7877, 7879, 7883, 7901, 7907, 7919],dtype=np.uint64)
diff --git a/qmcpy/discrete_distribution/digital_net_any_bases/faure.py b/qmcpy/discrete_distribution/digital_net_any_bases/faure.py
index 4c625d8b4..6a84750b3 100644
--- a/qmcpy/discrete_distribution/digital_net_any_bases/faure.py
+++ b/qmcpy/discrete_distribution/digital_net_any_bases/faure.py
@@ -2,12 +2,11 @@
 
 
 class Faure(DigitalNetAnyBases):
-    r"""
-    Low discrepancy Faure points.
+    r"""Low discrepancy Faure points.
 
-    Note:
+    Notes:
         - The first point of an unrandomized Faure sequence is the origin.
-    
+
     Examples:
         >>> discrete_distrib = Faure(4,seed=7)
         >>> discrete_distrib(25)
@@ -44,8 +43,8 @@ class Faure(DigitalNetAnyBases):
             t               28
             n_limit         2^(32)
             entropy         7
-        
-        Replications of independent randomizations 
+
+        Replications of independent randomizations
 
         >>> x = Faure(3,seed=7,replications=2)(9)
         >>> x.shape
@@ -71,7 +70,7 @@ class Faure(DigitalNetAnyBases):
                 [0.30097968, 0.36957094, 0.23358374],
                 [0.99369356, 0.78380717, 0.74090153]]])
 
-        Unrandomized Faure 
+        Unrandomized Faure
 
         >>> Faure(4,randomize="FALSE",seed=7)(25,warn=False)
         array([[0.  , 0.  , 0.  , 0.  ],
@@ -99,8 +98,8 @@ class Faure(DigitalNetAnyBases):
                [0.56, 0.36, 0.16, 0.96],
                [0.76, 0.56, 0.36, 0.16],
                [0.96, 0.76, 0.56, 0.36]])
-        
-        All randomizations 
+
+        All randomizations
 
         >>> Faure(3,randomize="LMS DP",seed=7)(9)
         array([[0.60869072, 0.76096155, 0.79807281],
@@ -162,8 +161,8 @@ class Faure(DigitalNetAnyBases):
                [0.25089638, 0.17805972, 0.95988146],
                [0.68344029, 0.77065782, 0.26676153],
                [0.4322891 , 0.40799837, 0.34911626]])
-        
-        Replications of randomizations 
+
+        Replications of randomizations
 
         >>> Faure(3,randomize="LMS DP",seed=7,replications=2)(9)
         array([[[0.46995809, 0.81347921, 0.84921511],
@@ -287,7 +286,7 @@ class Faure(DigitalNetAnyBases):
                 [0.59326363, 0.50120469, 0.9906825 ]]])
 
         Higher order Faure
-        
+
         >>> Faure(3,randomize="LMS DP",seed=7,alpha=2)(9)
         array([[0.07060326, 0.24965078, 0.49971375],
                [0.9104272 , 0.77359118, 0.02813304],
@@ -338,9 +337,9 @@ class Faure(DigitalNetAnyBases):
                [0.32098765, 0.43209877, 0.87654321],
                [0.43209877, 0.87654321, 0.32098765],
                [0.87654321, 0.32098765, 0.43209877]])
-        
+
         Replications of higher order Faure
-        
+
         >>> Faure(3,randomize="LMS DP",seed=7,alpha=2,replications=2)(9)
         array([[[0.65006542, 0.84004771, 0.39377772],
                 [0.73541117, 0.25289783, 0.11639162],
diff --git a/qmcpy/discrete_distribution/digital_net_any_bases/halton.py b/qmcpy/discrete_distribution/digital_net_any_bases/halton.py
index 0fd3eb1e3..e245d3905 100644
--- a/qmcpy/discrete_distribution/digital_net_any_bases/halton.py
+++ b/qmcpy/discrete_distribution/digital_net_any_bases/halton.py
@@ -2,13 +2,12 @@
 
 
 class Halton(DigitalNetAnyBases):
-    r"""
-    Low discrepancy Halton points.
+    r"""Low discrepancy Halton points.
 
-    Note:
+    Notes:
         - The first point of an unrandomized Halton sequence is the origin.
         - QRNG does *not* support multiple replications (independent randomizations).
-    
+
     Examples:
         >>> discrete_distrib = Halton(2,seed=7)
         >>> discrete_distrib(4)
@@ -24,8 +23,8 @@ class Halton(DigitalNetAnyBases):
             t               63
             n_limit         2^(32)
             entropy         7
-        
-        Replications of independent randomizations 
+
+        Replications of independent randomizations
 
         >>> x = Halton(3,seed=7,replications=2)(4)
         >>> x.shape
@@ -41,15 +40,15 @@ class Halton(DigitalNetAnyBases):
                 [0.89132308, 0.12030255, 0.35715804],
                 [0.04025218, 0.44304244, 0.10724799]]])
 
-        Unrandomized Halton 
+        Unrandomized Halton
 
         >>> Halton(2,randomize="FALSE",seed=7)(4,warn=False)
         array([[0.        , 0.        ],
                [0.5       , 0.33333333],
                [0.25      , 0.66666667],
                [0.75      , 0.11111111]])
-        
-        All randomizations 
+
+        All randomizations
 
         >>> Halton(2,randomize="LMS DP",seed=7)(4)
         array([[0.83790457, 0.89981478],
@@ -86,8 +85,8 @@ class Halton(DigitalNetAnyBases):
                [0.85362988, 0.72066823],
                [0.10362988, 0.05400156],
                [0.60362988, 0.498446  ]])
-        
-        Replications of randomizations 
+
+        Replications of randomizations
 
         >>> Halton(3,randomize="LMS DP",seed=7,replications=2)(4)
         array([[[0.70988236, 0.18180876, 0.54073621],
@@ -150,20 +149,20 @@ class Halton(DigitalNetAnyBases):
                 [0.34111023, 0.84596814, 0.0292313 ],
                 [0.71866903, 0.23852281, 0.80431142]]])
 
-    **References:**
-    
-    1.  Marius Hofert and Christiane Lemieux.  
-        qrng: (Randomized) Quasi-Random Number Generators.  
-        R package version 0.0-7. (2019).  
+    **References: **
+
+    1.  Marius Hofert and Christiane Lemieux.
+        qrng: (Randomized) Quasi-Random Number Generators.
+        R package version 0.0-7. (2019).
         [https://CRAN.R-project.org/package=qrng](https://CRAN.R-project.org/package=qrng).
-        
-    2.  A. B. Owen.  
-        A randomized Halton algorithm in R.  
-        [arXiv:1706.02808](https://arxiv.org/abs/1706.02808) [stat.CO]. 2017. 
-
-    3.  A. B. Owen and Z. Pan.  
-        Gain coefficients for scrambled Halton points.  
-        [arXiv:2308.08035](https://arxiv.org/abs/2308.08035) [stat.CO]. 2023. 
+
+    2.  A. B. Owen.
+        A randomized Halton algorithm in R.
+        [arXiv:1706.02808](https://arxiv.org/abs/1706.02808) [stat.CO]. 2017.
+
+    3.  A. B. Owen and Z. Pan.
+        Gain coefficients for scrambled Halton points.
+        [arXiv:2308.08035](https://arxiv.org/abs/2308.08035) [stat.CO]. 2023.
     """
 
     DEFAULT_GENERATING_MATRICES = "HALTON"
diff --git a/qmcpy/discrete_distribution/digital_net_any_bases/hammersley.py b/qmcpy/discrete_distribution/digital_net_any_bases/hammersley.py
index 2e765b549..7a2a777ce 100644
--- a/qmcpy/discrete_distribution/digital_net_any_bases/hammersley.py
+++ b/qmcpy/discrete_distribution/digital_net_any_bases/hammersley.py
@@ -8,21 +8,21 @@
 
 
 class Hammersley(DigitalNetAnyBases):
-    r"""
-    Hammersley point set: a deterministic, 'closed' low discrepancy point set.
+    r"""Hammersley point set: a deterministic, 'closed' low discrepancy point
+    set.
 
     With $p_1,\dots,p_{d-1}$ the first $d-1$ prime numbers, the point set
-    $\{t_0,\dots,t_{n-1}\}$ with $n$ points in $d$ dimensions is given by
-    $t_i = (i/n,\ \varphi_{p_1}(i),\ \dots,\ \varphi_{p_{d-1}}(i))$
-    for $i=0,\dots,n-1$, where $\varphi_p$ denotes the radical inverse
-    function in base $p$.
+    $\{t_0,\dots,t_{n-1}\}$ with $n$ points in $d$ dimensions is given by $t_i
+    = (i/n,\ \varphi_{p_1}(i),\ \dots,\ \varphi_{p_{d-1}}(i))$ for
+    $i=0,\dots,n-1$, where $\varphi_p$ denotes the radical inverse function in
+    base $p$.
 
     Being a 'closed' point set (n must be fixed in advance, unlike an
-    extensible sequence such as Halton), the QMC error bound gains one
-    fewer power of $\log n$ than the corresponding Halton bound:
-    $|I_d(f)-Q_{n,d}(f)| \le C_d\, (\log n)^{d-1}/n\, V(f)$.
+    extensible sequence such as Halton), the QMC error bound gains one fewer
+    power of $\log n$ than the corresponding Halton bound: $|I_d(f)-Q_{n,d}(f)|
+    \le C_d\, (\log n)^{d-1}/n\, V(f)$.
 
-    Note:
+    Notes:
         - This class is fully deterministic: no randomization is supported,
           and the `seed` argument has no effect on the generated points.
         - The first point is always the origin.
@@ -53,7 +53,7 @@ class Hammersley(DigitalNetAnyBases):
                [0.5 ],
                [0.75]])
 
-    **References:**
+    **References: **
 
     1.  J. Dick, F. Y. Kuo, and I. H. Sloan.
         High-dimensional integration: the quasi-Monte Carlo way.
@@ -74,22 +74,21 @@ def __init__(self,
                 ):
         r"""
         Args:
-            dimension (int): Dimension of the samples. Must be a scalar
-                `int` (unlike `Halton`, an array of indices is not
-                supported -- see class Notes).
+            dimension (int): Dimension of the samples. Must be a scalar `int`
+                (unlike `Halton`, an array of indices is not supported -- see
+                class Notes).
 
-            seed (Union[None, int, np.random.SeedSequence]): Unused; kept
-                for API consistency with the other discrete distributions.
-                This point set is fully deterministic, so `seed` has no
-                effect on the generated points.
+            seed (Union[None, int, np.random.SeedSequence]): Unused; kept for
+                API consistency with the other discrete distributions. This
+                point set is fully deterministic, so `seed` has no effect on
+                the generated points.
 
             t (Union[None, int]): Passed through to the internal `Halton`
-                generator used for dimensions 2,...,`dimension` (ignored
-                when `dimension` is 1). See `Halton`'s docstring for
-                details.
+                generator used for dimensions 2,...,`dimension` (ignored when
+                `dimension` is 1). See `Halton`'s docstring for details.
 
-            n_lim (int): Maximum number of points `n` this distribution
-                can be asked to generate.
+            n_lim (int): Maximum number of points `n` this distribution can be
+                asked to generate.
         """
 
         if not np.isscalar(dimension):
diff --git a/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py b/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
index 89887d578..257512a9d 100644
--- a/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
+++ b/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
@@ -9,10 +9,9 @@
 import platform
 
 class DigitalNetB2(AbstractLDDiscreteDistribution):
-    r"""
-    Low discrepancy digital net in base 2.
+    r"""Low discrepancy digital net in base 2.
 
-    Note:
+    Notes:
         - Digital net sample sizes should be powers of $2$ e.g. $1$, $2$, $4$, $8$, $16$, $\dots$.
         - The first point of an unrandomized digital nets is the origin.
         - `Sobol` is an alias for `DigitalNetB2`.
@@ -21,7 +20,8 @@ class DigitalNetB2(AbstractLDDiscreteDistribution):
             - Pass in `generating_matrices` *without* interlacing and supply `alpha`>1 to apply interlacing, or
             - Pass in `generating_matrices` *with* interlacing and set `alpha=1` to avoid additional interlacing
 
-            i.e. do *not* pass in interlaced `generating_matrices` and set `alpha>1`, this will apply additional interlacing.
+            i.e. do *not* pass in interlaced `generating_matrices` and set
+            `alpha>1`, this will apply additional interlacing.
 
     Examples:
         >>> discrete_distrib = DigitalNetB2(2,seed=7)
@@ -69,7 +69,8 @@ class DigitalNetB2(AbstractLDDiscreteDistribution):
         array([[0.25, 0.75],
                [0.75, 0.25]])
 
-        Generating matrices from [https://github.com/QMCSoftware/LDData/tree/main/dnet](https://github.com/QMCSoftware/LDData/tree/main/dnet)
+        Generating matrices from
+        [https://github.com/QMCSoftware/LDData/tree/main/dnet](https://github.com/QMCSoftware/LDData/tree/main/dnet)
 
         >>> DigitalNetB2(dimension=3,randomize=False,generating_matrices="mps.nx_s5_alpha2_m32.txt")(8,warn=False)
         array([[0.        , 0.        , 0.        ],
@@ -172,7 +173,7 @@ class DigitalNetB2(AbstractLDDiscreteDistribution):
                 [0.94219959, 0.39172304, 0.20285965],
                 [0.19716391, 0.64741585, 0.92494554]]])
 
-    **References:**
+    **References: **
 
     1.  Marius Hofert and Christiane Lemieux.
         qrng: (Randomized) Quasi-Random Number Generators (2019).
@@ -236,8 +237,10 @@ def __init__(
                 - If an `int` is passed in, use generating vector components at indices 0,...,`dimension`-1.
                 - If an `np.ndarray` is passed in, use generating vector components at these indices.
 
-            replications (int): Number of independent randomizations of a pointset.
-            seed (Union[None, int, np.random.SeedSeq): Seed the random number generator for reproducibility.
+            replications (int): Number of independent randomizations of a
+                pointset.
+            seed (Union[None, int, np.random.SeedSeq): Seed the random number
+            generator for reproducibility.
             randomize (str): Options are
 
                 - `'LMS DS'`: Linear matrix scramble with digital shift.
@@ -246,19 +249,28 @@ def __init__(
                 - `'NUS'`: Nested uniform scrambling. Also known as Owen scrambling.
                 - `'FALSE'`: No randomization. In this case the first point will be the origin.
 
-            generating_matrices (Union[str, np.ndarray, int]): Specify the generating matrices.
+            generating_matrices (Union[str, np.ndarray, int]): Specify the
+                generating matrices.
 
                 - A `str` should be the name (or path) of a file from the LDData repo at [https://github.com/QMCSoftware/LDData/tree/main/dnet](https://github.com/QMCSoftware/LDData/tree/main/dnet).
                 - An `np.ndarray` of integers with shape $(d,m_\mathrm{max})$ or $(r,d,m_\mathrm{max})$ where $d$ is the number of dimensions, $r$ is the number of replications, and $2^{m_\mathrm{max}}$ is the maximum number of supported points. Setting `msb=False` will flip the bits of ints in the generating matrices.
 
-            order (str): `'RADICAL INVERSE'`, or `'GRAY'` ordering. See the doctest example above.
-            t (int): Number of bits in integer represetation of points *after* randomization. The number of bits in the generating matrices is inferred based on the largest value.
-            alpha (int): Interlacing factor for higher order nets.
-                When `alpha`>1, interlacing is performed regardless of the generating matrices,
-                i.e., for `alpha`>1 do *not* pass in generating matrices which are already interlaced.
-                The Note for this class contains more info.
-            msb (bool): Flag for Most Significant Bit (MSB) vs Least Significant Bit (LSB) integer representations in generating matrices. If `msb=False` (LSB order), then integers in generating matrices will be bit-reversed.
-            _verbose (bool): If `True`, print linear matrix scrambling matrices.
+            order (str): `'RADICAL INVERSE'`, or `'GRAY'` ordering. See the
+                doctest example above.
+            t (int): Number of bits in integer represetation of points *after*
+                randomization. The number of bits in the generating matrices is
+                inferred based on the largest value.
+            alpha (int): Interlacing factor for higher order nets. When
+                `alpha`>1, interlacing is performed regardless of the
+                generating matrices, i.e., for `alpha`>1 do *not* pass in
+                generating matrices which are already interlaced. The Note for
+                this class contains more info.
+            msb (bool): Flag for Most Significant Bit (MSB) vs Least
+                Significant Bit (LSB) integer representations in generating
+                matrices. If `msb=False` (LSB order), then integers in
+                generating matrices will be bit-reversed.
+            _verbose (bool): If `True`, print linear matrix scrambling
+                matrices.
         """
         if graycode is not None:
             order = "GRAY" if graycode else "RADICAL INVERSE"
diff --git a/qmcpy/discrete_distribution/dummy_sampler.py b/qmcpy/discrete_distribution/dummy_sampler.py
index d47d2c46a..ac7477f90 100644
--- a/qmcpy/discrete_distribution/dummy_sampler.py
+++ b/qmcpy/discrete_distribution/dummy_sampler.py
@@ -3,8 +3,8 @@
 
 
 class DummySampler(AbstractLDDiscreteDistribution):
-    r"""
-    Placeholder discrete distribution for constructing true-measure marginals.
+    r"""Placeholder discrete distribution for constructing true-measure
+    marginals.
 
     ``DummySampler`` is useful when a true measure is needed only for its
     dimension, transform, range, and weight behavior. QMCPy's current
diff --git a/qmcpy/discrete_distribution/iid_std_uniform.py b/qmcpy/discrete_distribution/iid_std_uniform.py
index 195108ca8..623a15fb4 100644
--- a/qmcpy/discrete_distribution/iid_std_uniform.py
+++ b/qmcpy/discrete_distribution/iid_std_uniform.py
@@ -5,10 +5,10 @@
 
 
 class IIDStdUniform(AbstractIIDDiscreteDistribution):
-    r"""
-    IID standard uniform points, a wrapper around [`numpy.random.rand`](https://numpy.org/doc/stable/reference/random/generated/numpy.random.rand.html).
+    r"""IID standard uniform points, a wrapper around
+    [`numpy.random.rand`](https://numpy.org/doc/stable/reference/random/generated/numpy.random.rand.html).
 
-    Note:
+    Notes:
         - Unlike low discrepancy sequence, calling an `IIDStdUniform` instance gives new samples every time,
             e.g., running the first doctest below with `dd = Lattice(dimension=2)` would give the same 4 points in both calls,
             but since we are using an `IIDStdUniform` instance it gives different points every call.
@@ -53,8 +53,11 @@ def __init__(self, dimension=1, replications=None, seed=None):
         r"""
         Args:
             dimension (int): Dimension of the samples.
-            replications (Union[None, int]): Number of randomizations. This is implemented only for API consistency. Equivalent to reshaping samples.
-            seed (Union[None, int, np.random.SeedSeq): Seed the random number generator for reproducibility.
+            replications (Union[None, int]): Number of randomizations. This is
+                implemented only for API consistency. Equivalent to reshaping
+                samples.
+            seed (Union[None, int, np.random.SeedSeq): Seed the random number
+            generator for reproducibility.
         """
         super(IIDStdUniform, self).__init__(
             int(dimension), replications, seed, d_limit=np.inf, n_limit=np.inf
diff --git a/qmcpy/discrete_distribution/korobov.py b/qmcpy/discrete_distribution/korobov.py
index b3ae08e99..29a37ab36 100644
--- a/qmcpy/discrete_distribution/korobov.py
+++ b/qmcpy/discrete_distribution/korobov.py
@@ -11,8 +11,9 @@ def load_korobov_table(
         npz_path=Path(__file__).resolve().parent / "generating_params" / "korobov_p2_table.npz"
     ):
     """Load the Korobov table from the compressed .npz file. Cached via
-       lru_cache: the file is only actually read once per process, with no
-       explicit module-level global variable."""
+    lru_cache: the file is only actually read once per process, with no
+    explicit module-level global variable.
+    """
     with np.load(npz_path) as data:
         raw = data["raw"]
         lut = {
@@ -42,21 +43,22 @@ def get_a(lut, n, d):
 
 
 class KorobovLattice(AbstractLDDiscreteDistribution):
-    r"""
-    Korobov lattice rule with a tabulated, quality-optimized generating parameter.
+    r"""Korobov lattice rule with a tabulated, quality-optimized generating
+    parameter.
 
-    A rank-1 lattice rule with $n$ points and generating vector $z\in\mathbb{Z}^d$ is
-    $P_n(z) = \{(\{k z_1/n\},\dots,\{k z_d/n\}) : k=0,\dots,n-1\}$. The Korobov
-    construction restricts $z$ to a single integer parameter $a$:
-    $z(a) = (1,a,a^2,\dots,a^{d-1}) \bmod n$, with $\gcd(a,n)=1$.
+    A rank-1 lattice rule with $n$ points and generating vector
+    $z\in\mathbb{Z}^d$ is $P_n(z) = \{(\{k z_1/n\},\dots,\{k z_d/n\}) :
+    k=0,\dots,n-1\}$. The Korobov construction restricts $z$ to a single
+    integer parameter $a$: $z(a) = (1,a,a^2,\dots,a^{d-1}) \bmod n$, with
+    $\gcd(a,n)=1$.
 
     Rather than searching for $a$ at construction time, this class looks up $a$
     in a precomputed table, for every $(n,d)$ pair in the table, minimizing the
     weighted $P_2$ figure of merit (the squared worst-case integration error in
-    the weighted Korobov space of smoothness 2) with product weights
-    $\gamma_j = 1/j^2$.
+    the weighted Korobov space of smoothness 2) with product weights $\gamma_j
+    = 1/j^2$.
 
-    Note:
+    Notes:
         - Because the optimal $a$ depends on the *total* number of points $n$,
           a Korobov lattice cannot be incrementally extended the way `Lattice`
           can: `n_min` must be 0, and `n` must be one of the values in the
@@ -118,7 +120,7 @@ class KorobovLattice(AbstractLDDiscreteDistribution):
                [0.75 , 0.25 ],
                [0.875, 0.625]])
 
-    **References:**
+    **References: **
 
     1.  N. M. Korobov.
         The approximate computation of multiple integrals.
@@ -145,8 +147,8 @@ def __init__(
             dimension (int): Dimension of the samples. Must be between 1 and
                 250 (the range covered by the precomputed table).
 
-            replications (int): Number of independent Cranley-Patterson
-                shifts of the same underlying deterministic lattice.
+            replications (int): Number of independent Cranley-Patterson shifts
+                of the same underlying deterministic lattice.
 
             seed (Union[None, int, np.random.SeedSequence]): Seed the random
                 number generator for reproducibility.
@@ -156,7 +158,7 @@ def __init__(
                 - `'SHIFT'` or `'TRUE'`: Random Cranley-Patterson shift (the default).
                 - `'FALSE'`, `'NONE'`, or `'NO'`: No randomization. In this
                 case the first point will be the origin.
-    """
+        """
         super().__init__(dimension, replications, seed, d_limit = 250, n_limit = 131072)
 
         self.randomize = str(randomize).upper()
diff --git a/qmcpy/discrete_distribution/kronecker.py b/qmcpy/discrete_distribution/kronecker.py
index 89311121a..c33165981 100644
--- a/qmcpy/discrete_distribution/kronecker.py
+++ b/qmcpy/discrete_distribution/kronecker.py
@@ -55,18 +55,18 @@ def _suzuki_generating_vector(dimension):
     return 2 ** (np.arange(1, dimension + 1) / (dimension + 1))
 
 class Kronecker(AbstractLDDiscreteDistribution):
-    r"""
-    Kronecker sequence (additive recurrence sequence) for quasi-Monte Carlo.
+    r"""Kronecker sequence (additive recurrence sequence) for quasi-Monte
+    Carlo.
 
-    A Kronecker sequence is defined by
-    $$
-    \boldsymbol{x}_i =  i \boldsymbol{\alpha} + \boldsymbol{\delta} \bmod \boldsymbol{1} \in [0,1)^d, \quad i = 0,1,2,\dots,
-    $$
-    where $\boldsymbol{\alpha} \in \mathbb{R}^d$ is a generating vector and $\boldsymbol{\delta} \in [0,1)^d$
-    is an optional shift. The fractional part is taken componentwise.
+    A Kronecker sequence is defined by $$ \boldsymbol{x}_i =  i
+    \boldsymbol{\alpha} + \boldsymbol{\delta} \bmod \boldsymbol{1} \in [0,1)^d,
+    \quad i = 0,1,2,\dots, $$ where $\boldsymbol{\alpha} \in \mathbb{R}^d$ is a
+    generating vector and $\boldsymbol{\delta} \in [0,1)^d$ is an optional
+    shift. The fractional part is taken componentwise.
 
     These sequences are simple, extensible low-discrepancy sequences when
-    $\boldsymbol{\alpha}$ has components that are irrational and well-distributed.
+    $\boldsymbol{\alpha}$ has components that are irrational and
+    well-distributed.
 
     Notes:
         - The Kronecker sequence is fully extensible in $n$ (no restriction to powers of 2).
@@ -89,7 +89,7 @@ class Kronecker(AbstractLDDiscreteDistribution):
             randomize       SHIFT
             gen_vec_source  CBC
             entropy         7
-        
+
         Replications of independent randomizations
 
         >>> x = Kronecker(3,seed=7,replications=2)(4)
@@ -111,23 +111,24 @@ class Kronecker(AbstractLDDiscreteDistribution):
         <BLANKLINE>
                [[0.49700422, 0.41789272, 0.80339779],
                 [0.91944141, 0.77848924, 0.15206993]]])
-        
-        Switch from CBC to Richtmyer generating vector when the dimension is too large.
+
+        Switch from CBC to Richtmyer generating vector when the dimension is
+        too large.
 
         >>> Kronecker(15,seed=7,warn=False)(4).shape
         (4, 15)
         >>> Kronecker(15,replications=2,seed=7,warn=False)(4).shape
         (2, 4, 15)
 
-        CBC unrandomized 
-        
+        CBC unrandomized
+
         >>> Kronecker(3,generating_vector="CBC",randomize=False)(4)
         array([[0.        , 0.        , 0.        ],
                [0.42243719, 0.36059652, 0.34867214],
                [0.84487437, 0.72119304, 0.69734427],
                [0.26731156, 0.08178956, 0.04601641]])
-        
-        Richtmyer construction 
+
+        Richtmyer construction
 
         >>> Kronecker(3,generating_vector="RICHTMYER",randomize=False)(4)
         array([[0.        , 0.        , 0.        ],
@@ -145,7 +146,7 @@ class Kronecker(AbstractLDDiscreteDistribution):
                 [0.48055697, 0.16080129, 0.57818947],
                 [0.89477054, 0.8928521 , 0.81425745]]])
 
-        Suzuki construction 
+        Suzuki construction
 
         >>> Kronecker(3,generating_vector="SUZUKI",randomize=False)(4)
         array([[0.        , 0.        , 0.        ],
@@ -181,7 +182,7 @@ class Kronecker(AbstractLDDiscreteDistribution):
                 [0.77841423, 0.32842712, 0.96358566],
                 [0.96762135, 0.74264069, 0.64537849]]])
 
-        Custom generating vectors 
+        Custom generating vectors
 
         >>> Kronecker(3,generating_vector=2**(np.arange(1,4)/(3 + 1)),randomize=False)(4)
         array([[0.        , 0.        , 0.        ],
@@ -199,8 +200,8 @@ class Kronecker(AbstractLDDiscreteDistribution):
                 [0.84133696, 0.11091324, 0.78784635],
                 [0.03054408, 0.5251268 , 0.46963918],
                 [0.21975119, 0.93934037, 0.15143201]]])
-                
-        Subset dimensions 
+
+        Subset dimensions
 
         >>> Kronecker([0,2],generating_vector=2**(np.arange(1,4)/(3 + 1)),randomize=False)(4)
         array([[0.        , 0.        ],
@@ -211,7 +212,7 @@ class Kronecker(AbstractLDDiscreteDistribution):
     **References**
 
     1.  Richtmyer, R. D. (1951). "The evaluation of definite integrals and a quasi-Monte Carlo method."
-    
+
     2.  Niederreiter, H. (1992). *Random Number Generation and Quasi-Monte Carlo Methods*.
     """
 
@@ -230,23 +231,27 @@ def __init__(self,
 
                 - If an `int` is passed in, use generating vector components at indices 0,...,`dimension`-1.
                 - If an `np.ndarray` is passed in, use generating vector components at these indices.
-            
+
             replications (int): Number of independent randomizations.
-            seed (Union[None, int, np.random.SeedSeq): Seed the random number generator for reproducibility.
+            seed (Union[None, int, np.random.SeedSeq): Seed the random number
+            generator for reproducibility.
             randomize (str): Options are
 
                 - `'SHIFT'`: use `shift` if supplied, otherwise use a random shift $\boldsymbol{\delta} \sim \mathrm{Uniform}([0,1)^d)$.
                 - `'FALSE'`: zero shift.
-            
-            generating_vector (Union[str,np.ndarray]): Generating vector $\boldsymbol{\alpha}$.
-                
+
+            generating_vector (Union[str,np.ndarray]): Generating vector
+                $\boldsymbol{\alpha}$.
+
                 - `"CBC"`: uses the first $d$ components of a known good Component-by-Component (CBC) generating vector.
                 - `"RICHTMYER"`: uses $\boldsymbol{\alpha}_j = \sqrt{p_j} \bmod 1$, where $p_j$ are primes. This is the classical Richtmyer construction.
                 - `"SUZUKI"`: uses a deterministic construction $\boldsymbol{\alpha}_j = 2^{j/(d+1)}$.
                 - np.array: user-specified generating vector.
 
-            shift (np.ndarray): Shift vector $\boldsymbol{\delta}$. If `randomize=True`, this is ignored and a random shift is generated. Otherwise, a fixed shift is used.
-            warn (bool): If False, suppress warnings during construction 
+            shift (np.ndarray): Shift vector $\boldsymbol{\delta}$. If
+                `randomize=True`, this is ignored and a random shift is
+                generated. Otherwise, a fixed shift is used.
+            warn (bool): If False, suppress warnings during construction
         """
         self.parameters = ["randomize", "gen_vec_source"]
         self.input_generating_vector = generating_vector
diff --git a/qmcpy/discrete_distribution/latin_hypercube.py b/qmcpy/discrete_distribution/latin_hypercube.py
index 95aed4c8a..b7d619817 100644
--- a/qmcpy/discrete_distribution/latin_hypercube.py
+++ b/qmcpy/discrete_distribution/latin_hypercube.py
@@ -5,23 +5,22 @@
 
 
 class LatinHypercube(AbstractDiscreteDistribution):
-    r"""
-    Latin Hypercube Sampler for quasi-Monte Carlo and experimental design.
+    r"""Latin Hypercube Sampler for quasi-Monte Carlo and experimental design.
 
     Latin Hypercube Sampling (LHS) generates points with excellent univariate
     stratification: splitting $[0,1)$ into `n` equal strata along *any* single
     coordinate axis places exactly one point in each stratum. Introduced by
     McKay, Beckman, and Conover as a variance-reduction alternative to simple
-    random sampling for computer experiments, LHS is asymptotically at least
-    as accurate as Monte Carlo for the additive part of an integrand, with the
+    random sampling for computer experiments, LHS is asymptotically at least as
+    accurate as Monte Carlo for the additive part of an integrand, with the
     rate of improvement characterized by Stein and later by Loh via a
     multivariate central limit theorem.
 
-    Note:
+    Notes:
         - Unlike the low discrepancy sequences in this package (e.g. `Lattice`,
           `Halton`, `DigitalNetB2`), `LatinHypercube` points are *not* extensible
           in `n`: the entire point set must be regenerated whenever `n` changes,
-          since the strata boundaries themselves depend on `n`. 
+          since the strata boundaries themselves depend on `n`.
           Consequently `LatinHypercube` requires `n_min=0`, it cannot be generated starting from a nonzero offset.
         - `replications` produces independent randomizations (independent random
           permutations, and independent within-stratum jitter when `randomize`
@@ -67,31 +66,31 @@ class LatinHypercube(AbstractDiscreteDistribution):
                [0.875, 0.125]])
 
 
-    **References:**
+    **References: **
 
-    1.  M. D. McKay, R. J. Beckman, and W. J. Conover.  
-        A Comparison of Three Methods for Selecting Values of Input Variables in the Analysis of Output from a Computer Code.  
-        Technometrics, 21(2):239-245, 1979.  
+    1.  M. D. McKay, R. J. Beckman, and W. J. Conover.
+        A Comparison of Three Methods for Selecting Values of Input Variables in the Analysis of Output from a Computer Code.
+        Technometrics, 21(2):239-245, 1979.
         [https://doi.org/10.1080/00401706.1979.10489755](https://doi.org/10.1080/00401706.1979.10489755).
 
-    2.  M. Stein.  
-        Large Sample Properties of Simulations Using Latin Hypercube Sampling.  
-        Technometrics, 29(2):143-151, 1987.  
+    2.  M. Stein.
+        Large Sample Properties of Simulations Using Latin Hypercube Sampling.
+        Technometrics, 29(2):143-151, 1987.
         [https://doi.org/10.1080/00401706.1987.10488205](https://doi.org/10.1080/00401706.1987.10488205).
 
-    3.  A. B. Owen.  
-        Controlling Correlations in Latin Hypercube Samples.  
-        Journal of the American Statistical Association, 89(428):1517-1522, 1994.  
+    3.  A. B. Owen.
+        Controlling Correlations in Latin Hypercube Samples.
+        Journal of the American Statistical Association, 89(428):1517-1522, 1994.
         [https://doi.org/10.1080/01621459.1994.10476891](https://doi.org/10.1080/01621459.1994.10476891).
 
-    4.  W.-L. Loh.  
-        On Latin Hypercube Sampling.  
-        The Annals of Statistics, 24(5):2058-2080, 1996.  
+    4.  W.-L. Loh.
+        On Latin Hypercube Sampling.
+        The Annals of Statistics, 24(5):2058-2080, 1996.
         [https://doi.org/10.1214/aos/1069362310](https://doi.org/10.1214/aos/1069362310).
 
-    5.  B. Tang.  
-        Orthogonal Array-Based Latin Hypercubes.  
-        Journal of the American Statistical Association, 88(424):1392-1397, 1993.  
+    5.  B. Tang.
+        Orthogonal Array-Based Latin Hypercubes.
+        Journal of the American Statistical Association, 88(424):1392-1397, 1993.
         [https://doi.org/10.1080/01621459.1993.10476423](https://doi.org/10.1080/01621459.1993.10476423).
     """
 
@@ -103,16 +102,18 @@ def __init__(
             dimension (int): Dimension of the samples.
 
             replications (Union[None, int]): Number of independent LHS designs
-                to generate. Each replication is its own independently permuted,
-                independently jittered stratification into `n` strata.
+                to generate. Each replication is its own independently
+                permuted, independently jittered stratification into `n`
+                strata.
 
-            seed (Union[None, int, np.random.SeedSequence]): Seed for the random
-                number generator to ensure reproducibility.
+            seed (Union[None, int, np.random.SeedSequence]): Seed for the
+                random number generator to ensure reproducibility.
 
             randomize (str): Whether to jitter each point uniformly within its
                 stratum (`True`, the default) or place it at the stratum's
-                center (`False`), must be one of 'TRUE', 'FALSE', 'NONE', or 'NO' (case-insensitive).
-    """
+                center (`False`), must be one of 'TRUE', 'FALSE', 'NONE', or
+                'NO' (case-insensitive).
+        """
         super().__init__(dimension=dimension, replications=replications, seed=seed, d_limit=np.inf, n_limit=np.inf)
         self.randomize = str(randomize).upper()
         if self.randomize in ("NONE", "NO", "FALSE"):
diff --git a/qmcpy/discrete_distribution/lattice/lattice.py b/qmcpy/discrete_distribution/lattice/lattice.py
index 248692c32..7561d9d27 100644
--- a/qmcpy/discrete_distribution/lattice/lattice.py
+++ b/qmcpy/discrete_distribution/lattice/lattice.py
@@ -9,10 +9,9 @@
 
 
 class Lattice(AbstractLDDiscreteDistribution):
-    r"""
-    Low discrepancy lattice sequence.
+    r"""Low discrepancy lattice sequence.
 
-    Note:
+    Notes:
         - Lattice sample sizes should be powers of $2$ e.g. $1$, $2$, $4$, $8$, $16$, $\dots$.
         - The first point of an unrandomized lattice is the origin.
 
@@ -52,7 +51,8 @@ class Lattice(AbstractLDDiscreteDistribution):
                 [0.40212985, 0.94669968, 0.35605352]]])
 
 
-        Different orderings (avoid warnings that the first point is the origin).
+        Different orderings (avoid warnings that the first point is the
+        origin).
 
         >>> Lattice(dimension=2,randomize=False,order='RADICAL INVERSE')(4,warn=False)
         array([[0.  , 0.  ],
@@ -70,7 +70,8 @@ class Lattice(AbstractLDDiscreteDistribution):
                [0.5 , 0.5 ],
                [0.75, 0.25]])
 
-        Generating vector from [https://github.com/QMCSoftware/LDData/tree/main/lattice](https://github.com/QMCSoftware/LDData/tree/main/lattice)
+        Generating vector from
+        [https://github.com/QMCSoftware/LDData/tree/main/lattice](https://github.com/QMCSoftware/LDData/tree/main/lattice)
 
         >>> Lattice(dimension=3,randomize=False,generating_vector="mps.exod2_base2_m20_CKN.txt")(8,warn=False)
         array([[0.   , 0.   , 0.   ],
@@ -93,7 +94,8 @@ class Lattice(AbstractLDDiscreteDistribution):
                [0.25, 0.75, 0.75],
                [0.75, 0.25, 0.25]])
 
-        Two random generating vectors both supporting $2^{25}$ points along with independent random shifts
+        Two random generating vectors both supporting $2^{25}$ points along
+        with independent random shifts
 
         >>> discrete_distrib = Lattice(3,seed=7,generating_vector=25,replications=2)
         >>> discrete_distrib.gen_vec
@@ -154,24 +156,29 @@ def __init__(
                 - If an `np.ndarray` is passed in, use generating vector components at these indices.
 
             replications (int): Number of independent randomizations.
-            seed (Union[None, int, np.random.SeedSeq): Seed the random number generator for reproducibility.
+            seed (Union[None, int, np.random.SeedSeq): Seed the random number
+            generator for reproducibility.
             randomize (str): Options are
 
                 - `'SHIFT'`: Random shift.
                 - `'FALSE'`: No randomization. In this case the first point will be the origin.
 
-            generating_vector (Union[str, np.ndarray, int]): Specify the generating vector.
+            generating_vector (Union[str, np.ndarray, int]): Specify the
+                generating vector.
 
                 - A `str` should be the name (or path) of a file from the LDData repo at [https://github.com/QMCSoftware/LDData/tree/main/lattice](https://github.com/QMCSoftware/LDData/tree/main/lattice).
                 - A `np.ndarray` of integers with shape $(d,)$ or $(r,d)$ where $d$ is the number of dimensions and $r$ is the number of replications.
                     Must supply `m_max` where $2^{m_\mathrm{max}}$ is the max number of supported samples.
                 - An `int`, call it $M$,
                 gives the random generating vector $(1,v_1,\dots,v_{d-1})^T$
-                where $d$ is the dimension and $v_i$ are randomly selected from $\{3,5,\dots,2^M-1\}$ uniformly and independently.
-                We require require $1 < M < 27$.
-
-            order (str): `'LINEAR'`, `'RADICAL INVERSE'`, or `'GRAY'` ordering. See the doctest example above.
-            m_max (int): $2^{m_\mathrm{max}}$ is the maximum number of supported samples.
+                where $d$ is the dimension and $v_i$ are randomly selected from
+                $\{3,5,\dots,2^M-1\}$ uniformly and independently. We require
+                require $1 < M < 27$.
+
+            order (str): `'LINEAR'`, `'RADICAL INVERSE'`, or `'GRAY'` ordering.
+                See the doctest example above.
+            m_max (int): $2^{m_\mathrm{max}}$ is the maximum number of
+                supported samples.
         """
         self.parameters = ["randomize", "gen_vec_source", "order", "n_limit"]
         self.input_generating_vector = deepcopy(generating_vector)
diff --git a/qmcpy/discrete_distribution/mpmc/__init__.py b/qmcpy/discrete_distribution/mpmc/__init__.py
index 9ceea1244..8502009f7 100644
--- a/qmcpy/discrete_distribution/mpmc/__init__.py
+++ b/qmcpy/discrete_distribution/mpmc/__init__.py
@@ -1,23 +1,23 @@
-"""
-Message Passing Monte Carlo (MPMC) discrete distribution.
+"""Message Passing Monte Carlo (MPMC) discrete distribution.
 
-This module implements MPMC using PyTorch and PyTorch Geometric for 
-generating low-discrepancy point sets through neural message passing.
+This module implements MPMC using PyTorch and PyTorch Geometric for generating
+low-discrepancy point sets through neural message passing.
 
-Installation Requirements
---------------------------
-MPMC requires PyTorch and PyTorch Geometric. Install with:
+Installation Requirements -------------------------- MPMC requires PyTorch and
+PyTorch Geometric. Install with:
 
-    python -m pip install "qmcpy[mpmc]"
-    qmcpy-install-mpmc
+python -m pip install "qmcpy[mpmc]" qmcpy-install-mpmc
 
-For GPU support (NVIDIA CUDA), see https://pytorch.org/get-started/locally/
-For torch-geometric wheels, see https://pytorch-geometric.readthedocs.io/en/latest/install/installation.html
+For GPU support (NVIDIA CUDA), see https://pytorch.org/get-started/locally/ For
+torch-geometric wheels, see
+https://pytorch-geometric.readthedocs.io/en/latest/install/installation.html
 
-If these dependencies are not installed, attempting to use MPMC will raise an ImportError
-with installation instructions. You can check availability by running:
+If these dependencies are not installed, attempting to use MPMC will raise an
+ImportError with installation instructions. You can check availability by
+running:
 
-    python -c "import torch; import pyg_lib; import torch_geometric; print('MPMC dependencies ready')"
+python -c "import torch; import pyg_lib; import torch_geometric; print('MPMC
+dependencies ready')"
 """
 
 try:
@@ -29,7 +29,9 @@
     _missing_dep = str(e)
 
     class MPMC(object):
-        """Placeholder MPMC class shown when PyTorch dependencies are missing."""
+        """Placeholder MPMC class shown when PyTorch dependencies are
+        missing.
+        """
         def __init__(self, *args, **kwargs):
             raise ImportError(
                 f"MPMC requires PyTorch, pyg_lib, and PyTorch Geometric, but they are not installed.\n"
diff --git a/qmcpy/discrete_distribution/mpmc/mpmc.py b/qmcpy/discrete_distribution/mpmc/mpmc.py
index 59000b29b..efa929430 100644
--- a/qmcpy/discrete_distribution/mpmc/mpmc.py
+++ b/qmcpy/discrete_distribution/mpmc/mpmc.py
@@ -26,16 +26,16 @@
 }
 
 class MPMC(AbstractLDDiscreteDistribution):
-    """
-    Low-discrepancy generator trained by MPMC. Produces nbatch independent pointsets of size n in [0,1]^d.
-    
+    """Low-discrepancy generator trained by MPMC. Produces nbatch independent
+    pointsets of size n in [0,1]^d.
+
     Requires PyTorch and PyTorch Geometric. Install with:
 
-        python -m pip install "qmcpy[mpmc]"
-        qmcpy-install-mpmc
-    
-    For GPU support or platform-specific details, see https://pytorch.org/get-started/locally/
-    
+    python -m pip install "qmcpy[mpmc]" qmcpy-install-mpmc
+
+    For GPU support or platform-specific details, see
+    https://pytorch.org/get-started/locally/
+
     Examples:
         >>> mpmc = MPMC(
         ...     dimension=2,
@@ -300,7 +300,7 @@ def _spawn(self, child_seed, dimension):
     def _train(self, args: SimpleNamespace):
         """
         Returns:
-            x (np.ndarray): shape `(nbatch, nsamples, dim)`
+            shape `(nbatch, nsamples, dim)`
         """
         model = MPMC_net(
             dim=args.dim, nhid=args.nhid, nlayers=args.nlayers,
diff --git a/qmcpy/discrete_distribution/mpmc/utils.py b/qmcpy/discrete_distribution/mpmc/utils.py
index ded0beb4e..1c311f937 100644
--- a/qmcpy/discrete_distribution/mpmc/utils.py
+++ b/qmcpy/discrete_distribution/mpmc/utils.py
@@ -1,9 +1,7 @@
 import torch
 
 def _check_inputs(x, gamma=None):
-    """
-    x: (B, N, d) in [0,1]
-    gamma: (d,) nonnegative weights (optional)
+    """x: (B, N, d) in [0,1] gamma: (d,) nonnegative weights (optional)
     """
     if x.dim() != 3:
         raise ValueError(f"x must be (batch,N,d); got {tuple(x.shape)}")
diff --git a/qmcpy/fast_transform/ft.py b/qmcpy/fast_transform/ft.py
index 3aada030e..8233d78a5 100644
--- a/qmcpy/fast_transform/ft.py
+++ b/qmcpy/fast_transform/ft.py
@@ -4,10 +4,10 @@
 
 
 def fftbr(x):
-    r"""
-    1 dimensional Bit-Reversed-Order (BRO) Fast Fourier Transform (FFT) along the last dimension.
-    Requires the last dimension of x is already in BRO, so we can skip the first step of the decimation-in-time FFT.
-    Requires the size of the last dimension is a power of 2.
+    r"""1 dimensional Bit-Reversed-Order (BRO) Fast Fourier Transform (FFT)
+    along the last dimension. Requires the last dimension of x is already in
+    BRO, so we can skip the first step of the decimation-in-time FFT. Requires
+    the size of the last dimension is a power of 2.
 
     Examples:
         >>> rng = np.random.Generator(np.random.SFC64(11))
@@ -23,7 +23,7 @@ def fftbr(x):
         x (np.ndarray): Array of samples at which to run BRO-FFT.
 
     Returns:
-        y (np.ndarray): BRO-FFT values.
+        BRO-FFT values.
     """
     n = x.shape[-1]
     assert n & (n - 1) == 0  # require n is a power of 2
@@ -41,10 +41,10 @@ def fftbr(x):
 
 
 def ifftbr(x):
-    r"""
-    1 dimensional Bit-Reversed-Order (BRO) Inverse Fast Fourier Transform (IFFT) along the last dimension.
-    Outputs an array in bit-reversed order, so we can skip the last step of the decimation-in-time IFFT.
-    Requires the size of the last dimension is a power of 2.
+    r"""1 dimensional Bit-Reversed-Order (BRO) Inverse Fast Fourier Transform
+    (IFFT) along the last dimension. Outputs an array in bit-reversed order, so
+    we can skip the last step of the decimation-in-time IFFT. Requires the size
+    of the last dimension is a power of 2.
 
     Examples:
         >>> rng = np.random.Generator(np.random.SFC64(11))
@@ -60,7 +60,7 @@ def ifftbr(x):
         x (np.ndarray): Array of samples at which to run BRO-IFFT.
 
     Returns:
-        y (np.ndarray): BRO-IFFT values.
+        BRO-IFFT values.
     """
     n = x.shape[-1]
     assert n & (n - 1) == 0  # require n is a power of 2
@@ -77,9 +77,8 @@ def ifftbr(x):
 
 
 def fwht(x):
-    r"""
-    1 dimensional Fast Walsh Hadamard Transform (FWHT) along the last dimension.
-    Requires the size of the last dimension is a power of 2.
+    r"""1 dimensional Fast Walsh Hadamard Transform (FWHT) along the last
+    dimension. Requires the size of the last dimension is a power of 2.
 
     Examples:
         >>> rng = np.random.Generator(np.random.SFC64(11))
@@ -93,7 +92,7 @@ def fwht(x):
         x (np.ndarray): Array of samples at which to run FWHT.
 
     Returns:
-        y (np.ndarray): FWHT values.
+        FWHT values.
     """
     y = x.copy() + 0.0
     n = x.shape[-1]
@@ -115,8 +114,8 @@ def fwht(x):
 
 
 def omega_fwht(m):
-    r"""
-    A useful when efficiently updating FWHT values after doubling the sample size.
+    r"""A useful when efficiently updating FWHT values after doubling the
+    sample size.
 
     Examples:
         >>> rng = np.random.Generator(np.random.SFC64(11))
@@ -136,14 +135,14 @@ def omega_fwht(m):
         m (int): Size $2^m$ output.
 
     Returns:
-        y (np.ndarray): $\left(1\right)_{k=0}^{2^m}$.
+        $\left(1\right)_{k=0}^{2^m}$.
     """
     return np.ones(2**m)
 
 
 def omega_fftbr(m):
-    r"""
-    A useful when efficiently updating FFT values after doubling the sample size.
+    r"""A useful when efficiently updating FFT values after doubling the
+    sample size.
 
     Examples:
         >>> rng = np.random.Generator(np.random.SFC64(11))
@@ -163,6 +162,6 @@ def omega_fftbr(m):
         m (int): Size $2^m$ output.
 
     Returns:
-        y (np.ndarray): $\left(e^{- \pi \mathrm{i} k / 2^m}\right)_{k=0}^{2^m}$.
+        $\left(e^{- \pi \mathrm{i} k / 2^m}\right)_{k=0}^{2^m}$.
     """
     return np.exp(-np.pi * 1j * np.arange(2**m) / 2**m)
diff --git a/qmcpy/fast_transform/ft_pytorch.py b/qmcpy/fast_transform/ft_pytorch.py
index b06b2a7da..341b98b59 100644
--- a/qmcpy/fast_transform/ft_pytorch.py
+++ b/qmcpy/fast_transform/ft_pytorch.py
@@ -4,10 +4,11 @@
 
 
 def fftbr_torch(x):
-    r"""
-    Torch implementation of the 1 dimensional Bit-Reversed-Order (BRO) Fast Fourier Transform (FFT) along the last dimension.
-    Requires the last dimension of x is already in BRO, so we can skip the first step of the decimation-in-time FFT.
-    Requires the size of the last dimension is a power of 2.
+    r"""Torch implementation of the 1 dimensional Bit-Reversed-Order (BRO)
+    Fast Fourier Transform (FFT) along the last dimension. Requires the last
+    dimension of x is already in BRO, so we can skip the first step of the
+    decimation-in-time FFT. Requires the size of the last dimension is a power
+    of 2.
 
     Examples:
         >>> rng = np.random.Generator(np.random.SFC64(11))
@@ -36,7 +37,7 @@ def fftbr_torch(x):
         x (torch.Tensor): Array of samples at which to run BRO-FFT.
 
     Returns:
-        y (torch.Tensor): BRO-FFT values.
+        BRO-FFT values.
     """
     n = x.size(-1)
     assert n & (n - 1) == 0  # require n is a power of 2
@@ -54,10 +55,11 @@ def fftbr_torch(x):
 
 
 def ifftbr_torch(x):
-    r"""
-    Torch implementation of the 1 dimensional Bit-Reversed-Order (BRO) Inverse Fast Fourier Transform (IFFT) along the last dimension.
-    Outputs an array in bit-reversed order, so we can skip the last step of the decimation-in-time IFFT.
-    Requires the size of the last dimension is a power of 2.
+    r"""Torch implementation of the 1 dimensional Bit-Reversed-Order (BRO)
+    Inverse Fast Fourier Transform (IFFT) along the last dimension. Outputs an
+    array in bit-reversed order, so we can skip the last step of the
+    decimation-in-time IFFT. Requires the size of the last dimension is a power
+    of 2.
 
     Examples:
         >>> rng = np.random.Generator(np.random.SFC64(11))
@@ -86,7 +88,7 @@ def ifftbr_torch(x):
         x (torch.Tensor): Array of samples at which to run BRO-IFFT.
 
     Returns:
-        y (torch.Tensor): BRO-IFFT values.
+        BRO-IFFT values.
     """
     n = x.size(-1)
     assert n & (n - 1) == 0  # require n is a power of 2
@@ -135,9 +137,9 @@ def backward(ctx, dx):
 
 
 def fwht_torch(x):
-    r"""
-    Torch implementation of the 1 dimensional Fast Walsh Hadamard Transform (FWHT) along the last dimension.
-    Requires the size of the last dimension is a power of 2.
+    r"""Torch implementation of the 1 dimensional Fast Walsh Hadamard
+    Transform (FWHT) along the last dimension. Requires the size of the last
+    dimension is a power of 2.
 
     Examples:
         >>> rng = np.random.Generator(np.random.SFC64(11))
@@ -163,14 +165,14 @@ def fwht_torch(x):
         x (torch.Tensor): Array of samples at which to run FWHT.
 
     Returns:
-        y (torch.Tensor): FWHT values.
+        FWHT values.
     """
     return _FWHTB2Ortho.apply(x)
 
 
 def omega_fwht_torch(m, device=None):
-    r"""
-    Torch implementation useful when efficiently updating FWHT values after doubling the sample size.
+    r"""Torch implementation useful when efficiently updating FWHT values
+    after doubling the sample size.
 
     Examples:
         >>> rng = np.random.Generator(np.random.SFC64(11))
@@ -190,7 +192,7 @@ def omega_fwht_torch(m, device=None):
         m (int): Size $2^m$ output.
 
     Returns:
-        y (np.ndarray): $\left(1\right)_{k=0}^{2^m}$.
+        $\left(1\right)_{k=0}^{2^m}$.
     """
     if device is None:
         device = "cpu"
@@ -198,8 +200,8 @@ def omega_fwht_torch(m, device=None):
 
 
 def omega_fftbr_torch(m, device=None):
-    r"""
-    Torch implementation useful when efficiently updating FFT values after doubling the sample size.
+    r"""Torch implementation useful when efficiently updating FFT values after
+    doubling the sample size.
 
     Examples:
         >>> rng = np.random.Generator(np.random.SFC64(11))
@@ -219,7 +221,7 @@ def omega_fftbr_torch(m, device=None):
         m (int): Size $2^m$ output.
 
     Returns:
-        y (np.ndarray): $\left(e^{- \pi \mathrm{i} k / 2^m}\right)_{k=0}^{2^m}$.
+        $\left(e^{- \pi \mathrm{i} k / 2^m}\right)_{k=0}^{2^m}$.
     """
     if device is None:
         device = "cpu"
diff --git a/qmcpy/fast_transform/ft_qmctoolscl.py b/qmcpy/fast_transform/ft_qmctoolscl.py
index b36163c49..eaa45de59 100644
--- a/qmcpy/fast_transform/ft_qmctoolscl.py
+++ b/qmcpy/fast_transform/ft_qmctoolscl.py
@@ -20,10 +20,11 @@ def _parse_ft_input(x):
 
 
 def fftbr_qmctoolscl(x):
-    r"""
-    QMCToolsCL implementation of the 1 dimensional Bit-Reversed-Order (BRO) Fast Fourier Transform (FFT) along the last dimension.
-    Requires the last dimension of x is already in BRO, so we can skip the first step of the decimation-in-time FFT.
-    Requires the size of the last dimension is a power of 2.
+    r"""QMCToolsCL implementation of the 1 dimensional Bit-Reversed-Order
+    (BRO) Fast Fourier Transform (FFT) along the last dimension. Requires the
+    last dimension of x is already in BRO, so we can skip the first step of the
+    decimation-in-time FFT. Requires the size of the last dimension is a power
+    of 2.
 
     Examples:
         >>> rng = np.random.Generator(np.random.SFC64(11))
@@ -39,7 +40,7 @@ def fftbr_qmctoolscl(x):
         x (np.ndarray): Array of samples at which to run BRO-FFT.
 
     Returns:
-        y (np.ndarray): BRO-FFT values.
+        BRO-FFT values.
     """
     x, shape, d, n, n_half = _parse_ft_input(x)
     if n <= 1:
@@ -54,10 +55,11 @@ def fftbr_qmctoolscl(x):
 
 
 def ifftbr_qmctoolscl(x):
-    r"""
-    QMCToolsCL implementation of the 1 dimensional Bit-Reversed-Order (BRO) Inverse Fast Fourier Transform (IFFT) along the last dimension.
-    Outputs an array in bit-reversed order, so we can skip the last step of the decimation-in-time IFFT.
-    Requires the size of the last dimension is a power of 2.
+    r"""QMCToolsCL implementation of the 1 dimensional Bit-Reversed-Order
+    (BRO) Inverse Fast Fourier Transform (IFFT) along the last dimension.
+    Outputs an array in bit-reversed order, so we can skip the last step of the
+    decimation-in-time IFFT. Requires the size of the last dimension is a power
+    of 2.
 
     Examples:
         >>> rng = np.random.Generator(np.random.SFC64(11))
@@ -73,7 +75,7 @@ def ifftbr_qmctoolscl(x):
         x (np.ndarray): Array of samples at which to run BRO-IFFT.
 
     Returns:
-        y (np.ndarray): BRO-IFFT values.
+        BRO-IFFT values.
     """
     x, shape, d, n, n_half = _parse_ft_input(x)
     if n <= 1:
@@ -88,9 +90,9 @@ def ifftbr_qmctoolscl(x):
 
 
 def fwht_qmctoolscl(x):
-    r"""
-    QMCToolsCL implementation of the 1 dimensional Fast Walsh Hadamard Transform (FWHT) along the last dimension.
-    Requires the size of the last dimension is a power of 2.
+    r"""QMCToolsCL implementation of the 1 dimensional Fast Walsh Hadamard
+    Transform (FWHT) along the last dimension. Requires the size of the last
+    dimension is a power of 2.
 
     Examples:
         >>> rng = np.random.Generator(np.random.SFC64(11))
@@ -104,7 +106,7 @@ def fwht_qmctoolscl(x):
         x (np.ndarray): Array of samples at which to run FWHT.
 
     Returns:
-        y (np.ndarray): FWHT values.
+        FWHT values.
     """
     x, shape, d, n, n_half = _parse_ft_input(x)
     if n <= 1:
diff --git a/qmcpy/integrand/abstract_integrand.py b/qmcpy/integrand/abstract_integrand.py
index 4d838e81f..ea382a823 100644
--- a/qmcpy/integrand/abstract_integrand.py
+++ b/qmcpy/integrand/abstract_integrand.py
@@ -22,7 +22,8 @@ def __init__(self, dimension_indv, dimension_comb, parallel, threadpool=False):
                 - When `parallel = 0` or `parallel = 1` then function evaluation is done in serial fashion.
                 - `parallel > 1` specifies the number of processes used by `multiprocessing.Pool` or `multiprocessing.pool.ThreadPool`.
 
-                Setting `parallel=True` is equivalent to `parallel = os.cpu_count()`.
+                Setting `parallel=True` is equivalent to `parallel =
+                os.cpu_count()`.
             threadpool (bool): When `parallel > 1`:
 
                 - Setting `threadpool = True` will use `multiprocessing.pool.ThreadPool`.
@@ -92,11 +93,12 @@ def __call__(self, n=None, n_min=None, n_max=None, warn=True):
             warn (bool): If `False`, disable warnings when generating samples.
 
         Returns:
-            t (np.ndarray): Samples from the sequence.
+            Samples from the sequence.
 
                 - If `replications` is `None` then this will be of size (`n_max`-`n_min`) $\times$ `dimension`
                 - If `replications` is a positive int, then `t` will be of size `replications` $\times$ (`n_max`-`n_min`) $\times$ `dimension`
-            weights (np.ndarray): Only returned when `return_weights=True`. The Jacobian weights for the transformation
+            weights (np.ndarray): Only returned when `return_weights=True`. The
+            Jacobian weights for the transformation
         """
         return self.gen_samples(n=n, n_min=n_min, n_max=n_max, warn=warn)
 
@@ -108,43 +110,52 @@ def gen_samples(
         return y
 
     def g(self, t, *args, **kwargs):
-        r"""
-        *Abstract method* implementing the integrand as a function of the true measure.
+        r"""*Abstract method* implementing the integrand as a function of the
+        true measure.
 
         Args:
             t (np.ndarray): Inputs with shape `(*batch_shape, d)`.
             args (tuple): positional arguments to `g`.
             kwargs (dict): keyword arguments to `g`.
 
-                Some algorithms will additionally try to pass in a `compute_flags` keyword argument.
-                This `np.ndarray` are flags indicating which outputs require evaluation.
-                For example, if the vector function has 3 outputs and `compute_flags = [False, True, False]`,
-                then the function is only required to evaluate the second output and may leave the remaining outputs as `np.nan` values,
-                i.e., the outputs corresponding to `compute_flags` which are `False` will not be used in the computation.
+                Some algorithms will additionally try to pass in a
+                `compute_flags` keyword argument. This `np.ndarray` are flags
+                indicating which outputs require evaluation. For example, if
+                the vector function has 3 outputs and `compute_flags = [False,
+                True, False]`, then the function is only required to evaluate
+                the second output and may leave the remaining outputs as
+                `np.nan` values, i.e., the outputs corresponding to
+                `compute_flags` which are `False` will not be used in the
+                computation.
 
         Returns:
-            y (np.ndarray): function evaluations with shape `(*batch_shape, *dimension_indv)` where `dimension_indv` is the shape of the function outputs.
+            function evaluations with shape `(*batch_shape, *dimension_indv)`
+            where `dimension_indv` is the shape of the function outputs.
         """
         raise MethodImplementationError(self, "g")
 
     def f(self, x, *args, **kwargs):
-        r"""
-        Function to evaluate the transformed integrand as a function of the discrete distribution.
-        Automatically applies the transformation determined by the true measure.
+        r"""Function to evaluate the transformed integrand as a function of
+        the discrete distribution. Automatically applies the transformation
+        determined by the true measure.
 
         Args:
             x (np.ndarray): Inputs with shape `(*batch_shape, d)`.
             args (tuple): positional arguments to `g`.
             kwargs (dict): keyword arguments to `g`.
 
-                Some algorithms will additionally try to pass in a `compute_flags` keyword argument.
-                This `np.ndarray` are flags indicating which outputs require evaluation.
-                For example, if the vector function has 3 outputs and `compute_flags = [False, True, False]`,
-                then the function is only required to evaluate the second output and may leave the remaining outputs as `np.nan` values,
-                i.e., the outputs corresponding to `compute_flags` which are `False` will not be used in the computation.
+                Some algorithms will additionally try to pass in a
+                `compute_flags` keyword argument. This `np.ndarray` are flags
+                indicating which outputs require evaluation. For example, if
+                the vector function has 3 outputs and `compute_flags = [False,
+                True, False]`, then the function is only required to evaluate
+                the second output and may leave the remaining outputs as
+                `np.nan` values, i.e., the outputs corresponding to
+                `compute_flags` which are `False` will not be used in the
+                computation.
 
-                The keyword argument `periodization_transform`, a string, specifies a periodization transform.
-                Options are:
+                The keyword argument `periodization_transform`, a string,
+                specifies a periodization transform. Options are:
 
                 - `False`: No periodizing transform, $\psi(x) = x$.
                 - `'BAKER'`: Baker tansform $\psi(x) = 1-2\lvert x-1/2 \rvert$.
@@ -155,7 +166,8 @@ def f(self, x, *args, **kwargs):
                 - `'C3SIN'`: Sidi $C^3$ transform $\psi(x) = (12\pi x-8\sin(2 \pi x) + \sin(4 \pi x))/(12 \pi)$.
 
         Returns:
-            y (np.ndarray): function evaluations with shape `(*batch_shape, *dimension_indv)` where `dimension_indv` is the shape of the function outputs.
+            function evaluations with shape `(*batch_shape, *dimension_indv)`
+            where `dimension_indv` is the shape of the function outputs.
         """
         if "periodization_transform" in kwargs:
             periodization_transform = kwargs["periodization_transform"]
@@ -283,21 +295,22 @@ def _g2(self, t, comb_args=((), {})):
         return y
 
     def bound_fun(self, bound_low, bound_high):
-        """
-        Compute the bounds on the combined function based on bounds for the
-        individual functions.
+        """Compute the bounds on the combined function based on bounds for
+        the individual functions.
 
-        Defaults to the identity where we essentially
-        do not combine integrands, but instead integrate each function
-        individually.
+        Defaults to the identity where we essentially do not combine
+        integrands, but instead integrate each function individually.
 
         Args:
-            bound_low (np.ndarray): Lower bounds on individual estimates with shape `integrand.d_indv`.
-            bound_high (np.ndarray): Upper bounds on individual estimates with shape `integrand.d_indv`.
+            bound_low (np.ndarray): Lower bounds on individual estimates with
+                shape `integrand.d_indv`.
+            bound_high (np.ndarray): Upper bounds on individual estimates with
+                shape `integrand.d_indv`.
 
         Returns:
-            comb_bound_low (np.ndarray): Lower bounds on combined estimates with shape `integrand.d_comb`.
-            comb_bound_high (np.ndarray): Upper bounds on combined estimates with shape `integrand.d_comb`.
+            Lower bounds on combined estimates with shape `integrand.d_comb`.
+            comb_bound_high (np.ndarray): Upper bounds on combined estimates
+            with shape `integrand.d_comb`.
         """
         if self.d_indv != self.d_comb:
             raise ParameterError(
@@ -311,18 +324,24 @@ def bound_fun(self, bound_low, bound_high):
         return bound_low, bound_high
 
     def dependency(self, comb_flags):
-        """
-        Takes a vector of indicators of weather of not the error bound is satisfied for combined integrands and returns flags for individual integrands.
+        """Takes a vector of indicators of weather of not the error bound is
+        satisfied for combined integrands and returns flags for individual
+        integrands.
 
-        For example, if we are taking the ratio of 2 individual integrands, then getting `comb_flags=True` means the ratio
-        has not been approximated to within the tolerance, so the dependency function should return `indv_flags=[True,True]`
-        indicating that both the numerator and denominator integrands need to be better approximated.
+        For example, if we are taking the ratio of 2 individual integrands,
+        then getting `comb_flags=True` means the ratio has not been
+        approximated to within the tolerance, so the dependency function should
+        return `indv_flags=[True,True]` indicating that both the numerator and
+        denominator integrands need to be better approximated.
 
         Args:
-            comb_flags (np.ndarray): Flags of shape `integrand.d_comb` indicating whether the combined outputs are insufficiently approximated.
+            comb_flags (np.ndarray): Flags of shape `integrand.d_comb`
+                indicating whether the combined outputs are insufficiently
+                approximated.
 
         Returns:
-            indv_flags (np.ndarray): Flags of shape `integrand.d_indv` indicating whether the individual integrands require additional sampling.
+            Flags of shape `integrand.d_indv` indicating whether the individual
+            integrands require additional sampling.
         """
         return (
             comb_flags
@@ -331,18 +350,19 @@ def dependency(self, comb_flags):
         )
 
     def spawn(self, levels):
-        r"""
-        Spawn new instances of the current integrand at different levels with new seeds.
-        Used by multi-level QMC algorithms which require integrands at multiple levels.
+        r"""Spawn new instances of the current integrand at different levels
+        with new seeds. Used by multi-level QMC algorithms which require
+        integrands at multiple levels.
 
-        Note:
-            Use `replications` instead of using `spawn` when possible, e.g., when spawning copies which all have the same level.
+        Notes:
+            Use `replications` instead of using `spawn` when possible, e.g.,
+            when spawning copies which all have the same level.
 
         Args:
             levels (np.ndarray): Levels at which to spawn new integrands.
 
         Returns:
-            spawned_integrand (list): Integrands with new true measures and discrete distributions.
+            Integrands with new true measures and discrete distributions.
         """
         levels = np.array([levels]) if np.isscalar(levels) else np.array(levels)
         if (levels > self.max_level).any():
@@ -356,17 +376,17 @@ def spawn(self, levels):
         return spawned_integrand
 
     def dimension_at_level(self, level):
-        """
-        *Abstract method* which returns the dimension of the generator required for a given level.
+        """*Abstract method* which returns the dimension of the generator
+        required for a given level.
 
-        Note:
+        Notes:
             Only used for multilevel problems.
 
         Args:
             level (int): Level at which to return the dimension.
 
         Returns:
-            d (int): Dimension at the given input level.
+            Dimension at the given input level.
         """
         return self.d
 
diff --git a/qmcpy/integrand/bayesian_lr_coeffs.py b/qmcpy/integrand/bayesian_lr_coeffs.py
index e9003fbb3..d59a1d73b 100644
--- a/qmcpy/integrand/bayesian_lr_coeffs.py
+++ b/qmcpy/integrand/bayesian_lr_coeffs.py
@@ -6,8 +6,8 @@
 
 
 class BayesianLRCoeffs(AbstractIntegrand):
-    r"""
-    Logistic Regression Coefficients computed as the posterior mean in a Bayesian framework.
+    r"""Logistic Regression Coefficients computed as the posterior mean in a
+    Bayesian framework.
 
     Examples:
         >>> integrand = BayesianLRCoeffs(DigitalNetB2(3,seed=7),feature_array=np.arange(8).reshape((4,2)),response_vector=[0,0,1,1])
@@ -37,17 +37,23 @@ def __init__(
     ):
         r"""
         Args:
-            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]): Either
+            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
+                Either
 
                 - a discrete distribution from which to transform samples, or
                 - a true measure by which to compose a transform.
-            feature_array (np.ndarray): Array of features with shape $(N,d-1)$ where $N$ is the number of observations and $d$ is the dimension.
-            response_vector (np.ndarray): Binary responses vector of length $N$.
-            prior_mean (np.ndarray): Length $d$ vector of prior means, one for each coefficient.
+            feature_array (np.ndarray): Array of features with shape $(N,d-1)$
+                where $N$ is the number of observations and $d$ is the
+                dimension.
+            response_vector (np.ndarray): Binary responses vector of length
+                $N$.
+            prior_mean (np.ndarray): Length $d$ vector of prior means, one for
+                each coefficient.
 
                 - The first $d-1$ inputs correspond to the $d-1$ features.
                 - The last input corresponds to the intercept coefficient.
-            prior_covariance (np.ndarray): Prior covariance array with shape $(d,d)$ d x d where indexing is consistent with the prior mean.
+            prior_covariance (np.ndarray): Prior covariance array with shape
+                $(d,d)$ d x d where indexing is consistent with the prior mean.
         """
         self.prior_mean = prior_mean
         self.prior_covariance = prior_covariance
diff --git a/qmcpy/integrand/box_integral.py b/qmcpy/integrand/box_integral.py
index 5b930408f..9bcbcc5f3 100644
--- a/qmcpy/integrand/box_integral.py
+++ b/qmcpy/integrand/box_integral.py
@@ -5,10 +5,10 @@
 
 
 class BoxIntegral(AbstractIntegrand):
-    r"""
-    Box integral from [1], see also
+    r"""Box integral from [1], see also
 
-    $$B_s(\boldsymbol{t}) = \left(\sum_{j=1}^d t_j^2 \right)^{s/2}, \qquad \boldsymbol{T} \sim \mathcal{U}[0,1]^d.$$
+    $$B_s(\boldsymbol{t}) = \left(\sum_{j=1}^d t_j^2 \right)^{s/2}, \qquad
+    \boldsymbol{T} \sim \mathcal{U}[0,1]^d.$$
 
     Examples:
         Scalar `s`
@@ -55,7 +55,7 @@ class BoxIntegral(AbstractIntegrand):
         array([[1.        , 0.76519118, 0.66666666],
                [0.62718785, 0.62224086, 0.64273341]])
 
-    **References:**
+    **References: **
 
     1.  D.H. Bailey, J.M. Borwein, R.E. Crandall, Box integrals.
         Journal of Computational and Applied Mathematics, Volume 206, Issue 1, 2007, Pages 196-208, ISSN 0377-0427.
@@ -67,11 +67,13 @@ class BoxIntegral(AbstractIntegrand):
     def __init__(self, sampler, s=1):
         r"""
         Args:
-            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]): Either
+            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
+                Either
 
                 - a discrete distribution from which to transform samples, or
                 - a true measure by which to compose a transform.
-            s (Union[float, np.ndarray]): `s` parameter or parameters. The output shape of `g` is the shape of `s`.
+            s (Union[float, np.ndarray]): `s` parameter or parameters. The
+                output shape of `g` is the shape of `s`.
         """
         self.parameters = ["s"]
         self.s = np.array(s)
diff --git a/qmcpy/integrand/custom_fun.py b/qmcpy/integrand/custom_fun.py
index b7d730e2b..92ebae9f6 100644
--- a/qmcpy/integrand/custom_fun.py
+++ b/qmcpy/integrand/custom_fun.py
@@ -5,13 +5,13 @@
 
 
 class CustomFun(AbstractIntegrand):
-    r"""
-    User supplied integrand $g$. In the following example we implement
+    r"""User supplied integrand $g$. In the following example we implement
 
     Examples:
         First we will implement
 
-        $$g(\boldsymbol{t}) = t_1^2t_2, \qquad \boldsymbol{T}=(T_1,T_2) \sim \mathcal{N}((1,2)^T,\mathsf{I}).$$
+        $$g(\boldsymbol{t}) = t_1^2t_2, \qquad \boldsymbol{T}=(T_1,T_2) \sim
+        \mathcal{N}((1,2)^T,\mathsf{I}).$$
 
         >>> integrand = CustomFun(
         ...     true_measure = Gaussian(DigitalNetB2(2,seed=7),mean=[1,2]),
@@ -36,7 +36,10 @@ class CustomFun(AbstractIntegrand):
 
         Next we will implement the multi-output function
 
-        $$g(\boldsymbol{t}) = \begin{pmatrix} \sin(t_1)\cos(t_2) \\ \cos(t_1)\sin(t_2) \\ \sin(t_1)+\cos(t_2) \\ \cos(t_1)+\sin(t_2) \end{pmatrix} \qquad \boldsymbol{T}=(T_1,T_2) \sim \mathcal{U}[0,2\pi]^2.$$
+        $$g(\boldsymbol{t}) = \begin{pmatrix} \sin(t_1)\cos(t_2) \\
+        \cos(t_1)\sin(t_2) \\ \sin(t_1)+\cos(t_2) \\ \cos(t_1)+\sin(t_2)
+        \end{pmatrix} \qquad \boldsymbol{T}=(T_1,T_2) \sim
+        \mathcal{U}[0,2\pi]^2.$$
 
         >>> def g(t):
         ...     t1,t2 = t[...,0],t[...,1]
@@ -59,8 +62,11 @@ class CustomFun(AbstractIntegrand):
         ...     y.mean(-1)
         array([8.18e-04, 1.92e-06, -2.26e-10, 5.05e-07])
 
-        Stopping criterion which supporting vectorized outputs may pass in Boolean `compute_flags` with `dimension_indv` shape indicating which output need to evaluated,
-            i.e. where `compute_flags` is `False` we do not need to evaluate the integrand. We have not used this in inexpensive example above.
+        Stopping criterion which supporting vectorized outputs may pass in
+        Boolean `compute_flags` with `dimension_indv` shape indicating which
+        output need to evaluated,
+            i.e. where `compute_flags` is `False` we do not need to evaluate
+            the integrand. We have not used this in inexpensive example above.
 
         With independent replications
 
@@ -80,7 +86,6 @@ class CustomFun(AbstractIntegrand):
         >>> with np.printoptions(formatter={"float": lambda x: "%.2e"%x}):
         ...     muhats.mean(-1)
         array([3.83e-03, -6.78e-03, -1.56e-03, -5.65e-04])
-
     """
 
     def __init__(self, true_measure, g, dimension_indv=(), parallel=False):
@@ -88,16 +93,19 @@ def __init__(self, true_measure, g, dimension_indv=(), parallel=False):
         Args:
             true_measure (AbstractTrueMeasure): The true measure.
             g (callable): A function handle.
-            dimension_indv (tuple): Shape of individual solution outputs from `g`.
+            dimension_indv (tuple): Shape of individual solution outputs from
+                `g`.
             parallel (int): Parallelization flag.
 
                 - When `parallel = 0` or `parallel = 1` then function evaluation is done in serial fashion.
                 - `parallel > 1` specifies the number of processes used by `multiprocessing.Pool` or `multiprocessing.pool.ThreadPool`.
 
-                Setting `parallel=True` is equivalent to `parallel = os.cpu_count()`.
+                Setting `parallel=True` is equivalent to `parallel =
+                os.cpu_count()`.
 
-        Note:
-            For `parallel > 1` do *not* set `g` to be anonymous function (i.e. a `lambda` function)
+        Notes:
+            For `parallel > 1` do *not* set `g` to be anonymous function (i.e.
+            a `lambda` function)
         """
         self.parameters = []
         self.true_measure = true_measure
diff --git a/qmcpy/integrand/financial_option.py b/qmcpy/integrand/financial_option.py
index 2459540e1..6f9ce5752 100644
--- a/qmcpy/integrand/financial_option.py
+++ b/qmcpy/integrand/financial_option.py
@@ -7,8 +7,7 @@
 
 
 class FinancialOption(AbstractIntegrand):
-    r"""
-    Financial options.
+    r"""Financial options.
 
     - Start price $S_0$
     - Strike price $K$
@@ -17,11 +16,15 @@ class FinancialOption(AbstractIntegrand):
     - Drift $\gamma$
     - Equidistant monitoring times $\boldsymbol{\tau} = (\tau_1,\dots,\tau_d)^T$ with $\tau_d$ the final (exercise) time and $\tau_j = \tau_d j/d$.
 
-    Define the [geometric brownian motion](https://en.wikipedia.org/wiki/Geometric_Brownian_motion) as
+    Define the [geometric brownian
+    motion](https://en.wikipedia.org/wiki/Geometric_Brownian_motion) as
 
-    $$\boldsymbol{S}(\boldsymbol{t}) = S_0 e^{(\gamma-\sigma^2/2)\boldsymbol{\tau}+\sigma\boldsymbol{t}}, \qquad \boldsymbol{T} \sim \mathcal{N}(\boldsymbol{0},\mathsf{\Sigma})$$
+    $$\boldsymbol{S}(\boldsymbol{t}) = S_0
+    e^{(\gamma-\sigma^2/2)\boldsymbol{\tau}+\sigma\boldsymbol{t}}, \qquad
+    \boldsymbol{T} \sim \mathcal{N}(\boldsymbol{0},\mathsf{\Sigma})$$
 
-    where $\boldsymbol{T}$ is a standard Brownian motion so $\mathsf{\Sigma} = \left(\min\{\tau_j,\tau_{j'}\}\right)_{j,j'=1}^d$.
+    where $\boldsymbol{T}$ is a standard Brownian motion so $\mathsf{\Sigma} =
+    \left(\min\{\tau_j,\tau_{j'}\}\right)_{j,j'=1}^d$.
 
     The discounted payoff is
 
@@ -29,56 +32,77 @@ class FinancialOption(AbstractIntegrand):
 
     where the payoff function $P$ will be defined depending on the option.
 
-    Below we will use $S_{-1}$ to denote the final element of $\boldsymbol{S}$, the value of the path at exercise time.
+    Below we will use $S_{-1}$ to denote the final element of $\boldsymbol{S}$,
+    the value of the path at exercise time.
 
     # European Options
 
     *European Call and Put Options* have respective payoffs
 
-    $$P(\boldsymbol{S}) = \max\{S_{-1}-K,0\}, \qquad P(\boldsymbol{S}) = \max\{K-S_{-1},0\}.$$
+    $$P(\boldsymbol{S}) = \max\{S_{-1}-K,0\}, \qquad P(\boldsymbol{S}) =
+    \max\{K-S_{-1},0\}.$$
 
     # Asian Options
 
-    An asian option considers the average value of an asset path across time. We use the trapezoidal rule to approximate either the *arithmetic mean* by
+    An asian option considers the average value of an asset path across time.
+    We use the trapezoidal rule to approximate either the *arithmetic mean* by
 
-    $$A(\boldsymbol{S}) = \frac{1}{d}\left[\frac{1}{2} S_0 + \sum_{j=1}^{d-1} S_j + \frac{1}{2} S_{-1}\right]$$
+    $$A(\boldsymbol{S}) = \frac{1}{d}\left[\frac{1}{2} S_0 + \sum_{j=1}^{d-1}
+    S_j + \frac{1}{2} S_{-1}\right]$$
 
     or the *geometric mean* by
 
-    $$A(\boldsymbol{S}) = \left[\sqrt{S_0} \prod_{j=1}^{d-1} S_j \sqrt{S_{-1}}\right]^{1/d}.$$
+    $$A(\boldsymbol{S}) = \left[\sqrt{S_0} \prod_{j=1}^{d-1} S_j
+    \sqrt{S_{-1}}\right]^{1/d}.$$
 
     *Asian Call and Put Option* have respective payoffs
 
-    $$P(\boldsymbol{S}) = \max\{A(\boldsymbol{S})-K,0\}, \qquad P(\boldsymbol{S}) = \max\{K-A(\boldsymbol{S}),0\}.$$
+    $$P(\boldsymbol{S}) = \max\{A(\boldsymbol{S})-K,0\}, \qquad
+    P(\boldsymbol{S}) = \max\{K-A(\boldsymbol{S}),0\}.$$
 
     # Barrier Options
 
     - Barrier $B$.
 
-    *In* options are activate when the path crosses the barrier $B$, while *out* options are activated only if the path never crosses the barrier $B$.
-    An *up* option satisfies $S_0<B$ while a *down* option satisfies $S_0>B$, both indicating the direction of the barrier from the start price.
+    *In* options are activate when the path crosses the barrier $B$, while
+    *out* options are activated only if the path never crosses the barrier $B$.
+    An *up* option satisfies $S_0<B$ while a *down* option satisfies $S_0>B$,
+    both indicating the direction of the barrier from the start price.
 
     *Barrier Up-In Call and Put Options* have respective payoffs
 
-    $$P(\boldsymbol{S}) = \begin{cases} \max\{S_{-1})-K,0\}, & \text{any } \boldsymbol{S} \geq B \\ 0, & \mathrm{otherwise} \end{cases}, \qquad P(\boldsymbol{S}) = \begin{cases} \max\{K-S_{-1}),0\}, & \text{any } \boldsymbol{S} \geq B \\ 0, & \mathrm{otherwise} \end{cases}.$$
+    $$P(\boldsymbol{S}) = \begin{cases} \max\{S_{-1})-K,0\}, & \text{any }
+    \boldsymbol{S} \geq B \\ 0, & \mathrm{otherwise} \end{cases}, \qquad
+    P(\boldsymbol{S}) = \begin{cases} \max\{K-S_{-1}),0\}, & \text{any }
+    \boldsymbol{S} \geq B \\ 0, & \mathrm{otherwise} \end{cases}.$$
 
     *Barrier Up-Out Call and Put Options* have respective payoffs
 
-    $$P(\boldsymbol{S}) = \begin{cases} \max\{S_{-1})-K,0\}, & \text{all } \boldsymbol{S} < B \\ 0, & \mathrm{otherwise} \end{cases}, \qquad P(\boldsymbol{S}) = \begin{cases} \max\{K-S_{-1}),0\}, & \text{all } \boldsymbol{S} < B \\ 0, & \mathrm{otherwise} \end{cases}.$$
+    $$P(\boldsymbol{S}) = \begin{cases} \max\{S_{-1})-K,0\}, & \text{all }
+    \boldsymbol{S} < B \\ 0, & \mathrm{otherwise} \end{cases}, \qquad
+    P(\boldsymbol{S}) = \begin{cases} \max\{K-S_{-1}),0\}, & \text{all }
+    \boldsymbol{S} < B \\ 0, & \mathrm{otherwise} \end{cases}.$$
 
     *Barrier Down-In Call and Put Options* have respective payoffs
 
-    $$P(\boldsymbol{S}) = \begin{cases} \max\{S_{-1})-K,0\}, & \text{any } \boldsymbol{S} \leq B \\ 0, & \mathrm{otherwise} \end{cases}, \qquad P(\boldsymbol{S}) = \begin{cases} \max\{K-S_{-1}),0\}, & \text{any } \boldsymbol{S} \leq B \\ 0, & \mathrm{otherwise} \end{cases}.$$
+    $$P(\boldsymbol{S}) = \begin{cases} \max\{S_{-1})-K,0\}, & \text{any }
+    \boldsymbol{S} \leq B \\ 0, & \mathrm{otherwise} \end{cases}, \qquad
+    P(\boldsymbol{S}) = \begin{cases} \max\{K-S_{-1}),0\}, & \text{any }
+    \boldsymbol{S} \leq B \\ 0, & \mathrm{otherwise} \end{cases}.$$
 
     *Barrier Down-Out Call and Put Options* have respective payoffs
 
-    $$P(\boldsymbol{S}) = \begin{cases} \max\{S_{-1})-K,0\}, & \text{all } \boldsymbol{S} > B \\ 0, & \mathrm{otherwise} \end{cases}, \qquad P(\boldsymbol{S}) = \begin{cases} \max\{K-S_{-1}),0\}, & \text{all } \boldsymbol{S} > B \\ 0, & \mathrm{otherwise} \end{cases}.$$
+    $$P(\boldsymbol{S}) = \begin{cases} \max\{S_{-1})-K,0\}, & \text{all }
+    \boldsymbol{S} > B \\ 0, & \mathrm{otherwise} \end{cases}, \qquad
+    P(\boldsymbol{S}) = \begin{cases} \max\{K-S_{-1}),0\}, & \text{all }
+    \boldsymbol{S} > B \\ 0, & \mathrm{otherwise} \end{cases}.$$
 
     # Lookback Options
 
     *Lookback Call and Put Options* have respective payoffs
 
-    $$P(\boldsymbol{S}) = S_{-1}-\min(S_0, \ldots S_{-1}), \qquad P(\boldsymbol{S}) = \max(S_0, \ldots S_{-1})-S_{-1}.$$
+    $$P(\boldsymbol{S}) = S_{-1}-\min(S_0, \ldots S_{-1}), \qquad
+    P(\boldsymbol{S}) = \max(S_0, \ldots S_{-1})-S_{-1}.$$
 
     # Digital Option
 
@@ -86,21 +110,30 @@ class FinancialOption(AbstractIntegrand):
 
     *Digital Call and Put Options* have respective payoffs
 
-    $$P(\boldsymbol{S}) = \begin{cases} \rho, & S_{-1} \geq K \\ 0, & \mathrm{otherwise} \end{cases}, \qquad P(\boldsymbol{S}) =  \begin{cases} \rho, & S_{-1} \leq K \\ 0, & \mathrm{otherwise} \end{cases}.$$
+    $$P(\boldsymbol{S}) = \begin{cases} \rho, & S_{-1} \geq K \\ 0, &
+    \mathrm{otherwise} \end{cases}, \qquad P(\boldsymbol{S}) =  \begin{cases}
+    \rho, & S_{-1} \leq K \\ 0, & \mathrm{otherwise} \end{cases}.$$
 
     # Multilevel Options
 
     - Initial level $\ell_0 \geq 0$.
     - Level $\ell \geq \ell_0$.
 
-    Let $\boldsymbol{S}_\mathrm{fine}=\boldsymbol{S}$ be the *fine* full path. For $\ell>\ell_0$ write the *coarse* path as $\boldsymbol{S}_\mathrm{coarse} = (S_j)_{j \text{ even}}$ which only considers every other element of $\boldsymbol{S}$.
-    In this multilevel setting the payoff is
+    Let $\boldsymbol{S}_\mathrm{fine}=\boldsymbol{S}$ be the *fine* full path.
+    For $\ell>\ell_0$ write the *coarse* path as
+    $\boldsymbol{S}_\mathrm{coarse} = (S_j)_{j \text{ even}}$ which only
+    considers every other element of $\boldsymbol{S}$. In this multilevel
+    setting the payoff is
 
-    $$P_\ell(\boldsymbol{S}) = \begin{cases} P(\boldsymbol{S}_\mathrm{fine}), & \ell = \ell_0, \\ P(\boldsymbol{S}_\mathrm{fine})-P(\boldsymbol{S}_\mathrm{coarse}), & \ell > \ell_0 \end{cases}.$$
+    $$P_\ell(\boldsymbol{S}) = \begin{cases} P(\boldsymbol{S}_\mathrm{fine}), &
+    \ell = \ell_0, \\
+    P(\boldsymbol{S}_\mathrm{fine})-P(\boldsymbol{S}_\mathrm{coarse}), & \ell >
+    \ell_0 \end{cases}.$$
 
     Cancellations from the telescoping sum allow us to write
 
-    $$\lim_{\ell \to \infty} P_\ell = P_{\ell_0} + \sum_{\ell=\ell_0+1}^\infty P_\ell.$$
+    $$\lim_{\ell \to \infty} P_\ell = P_{\ell_0} + \sum_{\ell=\ell_0+1}^\infty
+    P_\ell.$$
 
     Examples:
         >>> integrand = FinancialOption(DigitalNetB2(dimension=3,seed=7),option="EUROPEAN")
@@ -195,7 +228,7 @@ class FinancialOption(AbstractIntegrand):
         >>> print("%.4f"%muhathat.sum())
         1.7982
 
-    **References:**
+    **References: **
 
     1.  M.B. Giles.
         Improved multilevel Monte Carlo convergence using the Milstein scheme.
@@ -224,24 +257,28 @@ def __init__(
     ):
         r"""
         Args:
-            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]): Either
+            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
+                Either
 
                 - a discrete distribution from which to transform samples, or
                 - a true measure by which to compose a transform.
-            option (str): Option type in `['ASIAN', 'EUROPEAN', 'BARRIER', 'LOOKBACK', 'DIGITAL']`
+            option (str): Option type in `['ASIAN', 'EUROPEAN', 'BARRIER',
+                'LOOKBACK', 'DIGITAL']`
             call_put (str): Either `'CALL'` or `'PUT'`.
             volatility (float): $\sigma$.
             start_price (float): $S_0$.
             strike_price (float): $K$.
             interest_rate (float): $r$.
             t_final (float): $\tau_d$.
-            decomp_type (str): Method for decomposition for covariance matrix. Options include
+            decomp_type (str): Method for decomposition for covariance matrix.
+                Options include
 
                 - `'PCA'` for principal component analysis,
                 - `'Cholesky'` for cholesky decomposition, or
                 - `'BrownianBridge'` or `'Bridge'` for brownian bridge construction.
             level (Union[None, int]): Level for multilevel problems
-            d_coarsest (Union[None, int]): Dimension of the problem on the coarsest level.
+            d_coarsest (Union[None, int]): Dimension of the problem on the
+                coarsest level.
             asian_mean (str): Either `'ARITHMETIC'` or `'GEOMETRIC'`.
             asian_mean_quadrature_rule (str): Either 'TRAPEZOIDAL' or 'RIGHT'.
             barrier_in_out (str): Either `'IN'` or `'OUT'`.
@@ -553,14 +590,14 @@ def payoff_digital_put(self, gbm):
         return np.where(gbm[..., -1] <= self.strike_price, self.digital_payout, 0)
 
     def get_exact_value(self):
-        """
-        Compute the exact analytic fair price of the option in finite dimensions. Supports
+        """Compute the exact analytic fair price of the option in finite
+        dimensions. Supports
 
         - `option='EUROPEAN'`
         - `option='ASIAN'` with `asian_mean='GEOMETRIC'` and `asian_mean_quadrature_rule='RIGHT'`
 
         Returns:
-            mean (float): Exact value of the integral.
+            Exact value of the integral.
         """
         if self.option == "EUROPEAN":
             denom = self.volatility * np.sqrt(self.t_final)
@@ -612,13 +649,13 @@ def get_exact_value(self):
         return fp
 
     def get_exact_value_inf_dim(self):
-        r"""
-        Get the exact analytic fair price of the option in infinite dimensions. Supports
+        r"""Get the exact analytic fair price of the option in infinite
+        dimensions. Supports
 
         - `option='ASIAN'` with `asian_mean='GEOMETRIC'`
 
         Returns:
-            mean (float): Exact value of the integral.
+            Exact value of the integral.
         """
         if self.option == "ASIAN":
             assert (
diff --git a/qmcpy/integrand/fourbranch2d.py b/qmcpy/integrand/fourbranch2d.py
index 04123c4f6..d21250faa 100644
--- a/qmcpy/integrand/fourbranch2d.py
+++ b/qmcpy/integrand/fourbranch2d.py
@@ -5,10 +5,13 @@
 
 
 class FourBranch2d(AbstractIntegrand):
-    r"""
-    Four Branch function in $d=2$.
+    r"""Four Branch function in $d=2$.
 
-    $$g(\boldsymbol{t}) = \min \begin{cases} 3+0.1(t_0-t_1)^2-\frac{t_0-t_1}{\sqrt{2}} \\ 3+0.1(t_0-t_1)^2+\frac{t_0-t_1}{\sqrt{2}} \\ t_0-t_1 + 7/\sqrt{2} \\ t_1-t_0 + 7/\sqrt{2}\end{cases}, \qquad \boldsymbol{T}=(T_0,T_1) \sim \mathcal{U}[-8,8]^2.$$
+    $$g(\boldsymbol{t}) = \min \begin{cases}
+    3+0.1(t_0-t_1)^2-\frac{t_0-t_1}{\sqrt{2}} \\
+    3+0.1(t_0-t_1)^2+\frac{t_0-t_1}{\sqrt{2}} \\ t_0-t_1 + 7/\sqrt{2} \\
+    t_1-t_0 + 7/\sqrt{2}\end{cases}, \qquad \boldsymbol{T}=(T_0,T_1) \sim
+    \mathcal{U}[-8,8]^2.$$
 
     Examples:
         >>> integrand = FourBranch2d(DigitalNetB2(2,seed=7))
@@ -44,7 +47,8 @@ class FourBranch2d(AbstractIntegrand):
     def __init__(self, sampler):
         r"""
         Args:
-            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]): Either
+            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
+                Either
 
                 - a discrete distribution from which to transform samples, or
                 - a true measure by which to compose a transform.
diff --git a/qmcpy/integrand/genz.py b/qmcpy/integrand/genz.py
index 73973b62f..1bc9e385b 100644
--- a/qmcpy/integrand/genz.py
+++ b/qmcpy/integrand/genz.py
@@ -6,14 +6,16 @@
 
 
 class Genz(AbstractIntegrand):
-    r"""
-    Genz function following the [`DAKOTA` implementation](https://snl-dakota.github.io/docs/6.17.0/users/usingdakota/examples/additionalexamples.html?highlight=genz#genz-functions).
+    r"""Genz function following the [`DAKOTA`
+    implementation](https://snl-dakota.github.io/docs/6.17.0/users/usingdakota/examples/additionalexamples.html?highlight=genz#genz-functions).
 
-    $$g_\mathrm{oscillatory}(\boldsymbol{t}) = \cos\left(-\sum_{j=1}^d c_j t_j\right)$$
+    $$g_\mathrm{oscillatory}(\boldsymbol{t}) = \cos\left(-\sum_{j=1}^d c_j
+    t_j\right)$$
 
     or
 
-    $$g_\mathrm{corner-peak}(\boldsymbol{t}) = \left(1+\sum_{j=1}^d c_j t_j\right)^{-(d+1)}$$
+    $$g_\mathrm{corner-peak}(\boldsymbol{t}) = \left(1+\sum_{j=1}^d c_j
+    t_j\right)^{-(d+1)}$$
 
     where
 
@@ -21,7 +23,9 @@ class Genz(AbstractIntegrand):
 
     and the coefficients $\boldsymbol{c}$ are have three kinds
 
-    $$c_k^{(1)} = \frac{k-1/2}{d}, \qquad c_k^{(2)} = \frac{1}{k^2}, \qquad c_k^{(3)} = \exp\left(\frac{k \log(10^{-8})}{d}\right), \qquad k=1,\dots,d.$$
+    $$c_k^{(1)} = \frac{k-1/2}{d}, \qquad c_k^{(2)} = \frac{1}{k^2}, \qquad
+    c_k^{(3)} = \exp\left(\frac{k \log(10^{-8})}{d}\right), \qquad
+    k=1,\dots,d.$$
 
     Examples:
         >>> for kind_func in ['OSCILLATORY','CORNER PEAK']:
@@ -53,7 +57,8 @@ class Genz(AbstractIntegrand):
     def __init__(self, sampler, kind_func="OSCILLATORY", kind_coeff=1):
         """
         Args:
-            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]): Either
+            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
+                Either
 
                 - a discrete distribution from which to transform samples, or
                 - a true measure by which to compose a transform.
diff --git a/qmcpy/integrand/hartmann6d.py b/qmcpy/integrand/hartmann6d.py
index c1fe57d13..39a90e72b 100644
--- a/qmcpy/integrand/hartmann6d.py
+++ b/qmcpy/integrand/hartmann6d.py
@@ -5,8 +5,9 @@
 
 
 class Hartmann6d(AbstractIntegrand):
-    r"""
-    Wrapper around [`BoTorch`'s implementation of the Augmented Hartmann function](https://botorch.readthedocs.io/en/stable/test_functions.html#botorch.test_functions.multi_fidelity.AugmentedHartmann) in dimension $d=6$.
+    r"""Wrapper around [`BoTorch`'s implementation of the Augmented Hartmann
+    function](https://botorch.readthedocs.io/en/stable/test_functions.html#botorch.test_functions.multi_fidelity.AugmentedHartmann)
+    in dimension $d=6$.
 
     Examples:
         >>> integrand = Hartmann6d(DigitalNetB2(6,seed=7))
@@ -29,7 +30,7 @@ class Hartmann6d(AbstractIntegrand):
                               (3, 3) 0.08333333333333333
                               (4, 4) 0.08333333333333333
                               (5, 5) 0.08333333333333333
-                             
+
         With independent replications
 
         >>> integrand = Hartmann6d(DigitalNetB2(6,seed=7,replications=2**4))
@@ -46,7 +47,8 @@ class Hartmann6d(AbstractIntegrand):
     def __init__(self, sampler):
         r"""
         Args:
-            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]): Either
+            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
+                Either
 
                 - a discrete distribution from which to transform samples, or
                 - a true measure by which to compose a transform.
diff --git a/qmcpy/integrand/ishigami.py b/qmcpy/integrand/ishigami.py
index 8ff3aa429..fecab2792 100644
--- a/qmcpy/integrand/ishigami.py
+++ b/qmcpy/integrand/ishigami.py
@@ -6,10 +6,11 @@
 
 
 class Ishigami(AbstractIntegrand):
-    r"""
-    Ishigami function in $d=3$ dimensions from [1] and [https://www.sfu.ca/~ssurjano/ishigami.html](https://www.sfu.ca/~ssurjano/ishigami.html).
+    r"""Ishigami function in $d=3$ dimensions from [1] and
+    [https://www.sfu.ca/~ssurjano/ishigami.html](https://www.sfu.ca/~ssurjano/ishigami.html).
 
-    $$g(\boldsymbol{t}) = (1+bt_2^4)\sin(t_0)+a\sin^2(t_1), \qquad \boldsymbol{T} = (T_0,T_1,T_2) \sim \mathcal{U}(-\pi,\pi)^3.$$
+    $$g(\boldsymbol{t}) = (1+bt_2^4)\sin(t_0)+a\sin^2(t_1), \qquad
+    \boldsymbol{T} = (T_0,T_1,T_2) \sim \mathcal{U}(-\pi,\pi)^3.$$
 
     Examples:
         >>> integrand = Ishigami(DigitalNetB2(3,seed=7))
@@ -44,7 +45,7 @@ class Ishigami(AbstractIntegrand):
         >>> print("%.4f"%muhats.mean())
         3.4646
 
-    **References:**
+    **References: **
 
     1.  Ishigami, T., & Homma, T.
         An importance quantification technique in uncertainty analysis for computer models.
@@ -55,7 +56,8 @@ class Ishigami(AbstractIntegrand):
     def __init__(self, sampler, a=7, b=0.1):
         r"""
         Args:
-            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]): Either
+            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
+                Either
 
                 - a discrete distribution from which to transform samples, or
                 - a true measure by which to compose a transform.
diff --git a/qmcpy/integrand/keister.py b/qmcpy/integrand/keister.py
index 949b3f644..57873fe3b 100644
--- a/qmcpy/integrand/keister.py
+++ b/qmcpy/integrand/keister.py
@@ -6,10 +6,10 @@
 
 
 class Keister(AbstractIntegrand):
-    r"""
-    Keister function from [1].
+    r"""Keister function from [1].
 
-    $$f(\boldsymbol{t}) = \pi^{d/2} \cos(\lVert \boldsymbol{t} \rVert_2) \qquad \boldsymbol{T} \sim \mathcal{N}(\boldsymbol{0},\mathsf{I}/2).$$
+    $$f(\boldsymbol{t}) = \pi^{d/2} \cos(\lVert \boldsymbol{t} \rVert_2) \qquad
+    \boldsymbol{T} \sim \mathcal{N}(\boldsymbol{0},\mathsf{I}/2).$$
 
     Examples:
         >>> integrand = Keister(DigitalNetB2(2,seed=7))
@@ -37,7 +37,7 @@ class Keister(AbstractIntegrand):
         >>> print("%.4f"%muhats.mean())
         1.8024
 
-    **References:**
+    **References: **
 
     1.  B. D. Keister.
         Multidimensional Quadrature Algorithms.
@@ -47,7 +47,8 @@ class Keister(AbstractIntegrand):
     def __init__(self, sampler):
         r"""
         Args:
-            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]): Either
+            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
+                Either
 
                 - a discrete distribution from which to transform samples, or
                 - a true measure by which to compose a transform.
@@ -69,14 +70,14 @@ def _spawn(self, level, sampler):
 
     @classmethod
     def get_exact_value(self, d):
-        """
-        Compute the exact analytic value of the Keister integral with dimension $d$.
+        """Compute the exact analytic value of the Keister integral with
+        dimension $d$.
 
         Args:
             d (int): Dimension.
 
         Returns:
-            mean (float): Exact value of the integral.
+            Exact value of the integral.
         """
         cosinteg = np.zeros(shape=(d))
         cosinteg[0] = np.sqrt(np.pi) / (2 * np.exp(1 / 4))
diff --git a/qmcpy/integrand/linear0.py b/qmcpy/integrand/linear0.py
index b43188edf..3e7d7bd00 100644
--- a/qmcpy/integrand/linear0.py
+++ b/qmcpy/integrand/linear0.py
@@ -4,10 +4,10 @@
 
 
 class Linear0(AbstractIntegrand):
-    r"""
-    Linear Function with analytic mean $0$.
+    r"""Linear Function with analytic mean $0$.
 
-    $$g(\boldsymbol{t}) = \sum_{j=1}^d t_j \qquad \boldsymbol{T} \sim \mathcal{U}[0,1]^d.$$
+    $$g(\boldsymbol{t}) = \sum_{j=1}^d t_j \qquad \boldsymbol{T} \sim
+    \mathcal{U}[0,1]^d.$$
 
     Examples:
         >>> integrand = Linear0(DigitalNetB2(100,seed=7))
@@ -31,7 +31,8 @@ class Linear0(AbstractIntegrand):
     def __init__(self, sampler):
         r"""
         Args:
-            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]): Either
+            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
+                Either
 
                 - a discrete distribution from which to transform samples, or
                 - a true measure by which to compose a transform.
diff --git a/qmcpy/integrand/multimodal2d.py b/qmcpy/integrand/multimodal2d.py
index 1291f1a5c..db4c1edeb 100644
--- a/qmcpy/integrand/multimodal2d.py
+++ b/qmcpy/integrand/multimodal2d.py
@@ -5,10 +5,10 @@
 
 
 class Multimodal2d(AbstractIntegrand):
-    r"""
-    Multimodal function in $d=2$ dimensions.
+    r"""Multimodal function in $d=2$ dimensions.
 
-    $$g(\boldsymbol{t}) = (t_0^2+4)(t_1-1)/20-\sin(5t_0/2)-2 \qquad \boldsymbol{T} = (T_0,T_1) \sim \mathcal{U}([-4,7] \times [-3,8]).$$
+    $$g(\boldsymbol{t}) = (t_0^2+4)(t_1-1)/20-\sin(5t_0/2)-2 \qquad
+    \boldsymbol{T} = (T_0,T_1) \sim \mathcal{U}([-4,7] \times [-3,8]).$$
 
     Examples:
         >>> integrand = Multimodal2d(DigitalNetB2(2,seed=7))
@@ -44,7 +44,8 @@ class Multimodal2d(AbstractIntegrand):
     def __init__(self, sampler):
         r"""
         Args:
-            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]): Either
+            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
+                Either
 
                 - a discrete distribution from which to transform samples, or
                 - a true measure by which to compose a transform.
diff --git a/qmcpy/integrand/sensitivity_indices.py b/qmcpy/integrand/sensitivity_indices.py
index 9c90d300b..a6b9af8f4 100644
--- a/qmcpy/integrand/sensitivity_indices.py
+++ b/qmcpy/integrand/sensitivity_indices.py
@@ -8,8 +8,7 @@
 
 
 class SensitivityIndices(AbstractIntegrand):
-    r"""
-    Sensitivity indices i.e. normalized Sobol' Indices.
+    r"""Sensitivity indices i.e. normalized Sobol' Indices.
 
     Examples:
         Singleton indices
@@ -97,7 +96,7 @@ class SensitivityIndices(AbstractIntegrand):
         >>> closed_total_approx.shape
         (2, 4, 4, 5, 6)
 
-    **References:**
+    **References: **
 
     1.  Aleksei G. Sorokin and Jagadeeswaran Rathinavel.
         On Bounding and Approximating Functions of Multiple Expectations Using Quasi-Monte Carlo.
@@ -114,8 +113,11 @@ class SensitivityIndices(AbstractIntegrand):
     def __init__(self, integrand, indices="singletons"):
         r"""
         Args:
-            integrand (AbstractIntegrand): Integrand to find sensitivity indices of.
-            indices (np.ndarray): Bool array with shape $(\dots,d)$ where each length $d$ vector item indicates which dimensions are active in the subset.
+            integrand (AbstractIntegrand): Integrand to find sensitivity
+                indices of.
+            indices (np.ndarray): Bool array with shape $(\dots,d)$ where each
+                length $d$ vector item indicates which dimensions are active in
+                the subset.
 
                 - The default `indices='singletons'` sets `indices=np.eye(d,dtype=bool)`.
                 - Setting `incides='all'` sets `indices = np.array([[bool(int(b)) for b in np.binary_repr(i,width=d)] for i in range(1,2**d-1)],dtype=bool)`
diff --git a/qmcpy/integrand/sin1d.py b/qmcpy/integrand/sin1d.py
index 9ffb69170..9d4d0b1aa 100644
--- a/qmcpy/integrand/sin1d.py
+++ b/qmcpy/integrand/sin1d.py
@@ -5,8 +5,7 @@
 
 
 class Sin1d(AbstractIntegrand):
-    r"""
-    Sine function in $d=1$ dimension.
+    r"""Sine function in $d=1$ dimension.
 
     $$g(t) = \sin(t), \qquad t \sim \mathcal{U}[0,2\pi k]$$
 
@@ -43,11 +42,13 @@ class Sin1d(AbstractIntegrand):
     def __init__(self, sampler, k=1):
         r"""
         Args:
-            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]): Either
+            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
+                Either
 
                 - a discrete distribution from which to transform samples, or
                 - a true measure by which to compose a transform.
-            k (float): The true measure will be uniform between $0$ and $2 \pi k$.
+            k (float): The true measure will be uniform between $0$ and $2 \pi
+                k$.
         """
         self.sampler = sampler
         self.k = k
diff --git a/qmcpy/integrand/umbridge_wrapper.py b/qmcpy/integrand/umbridge_wrapper.py
index 7f2caf7f8..16a02915c 100644
--- a/qmcpy/integrand/umbridge_wrapper.py
+++ b/qmcpy/integrand/umbridge_wrapper.py
@@ -7,8 +7,10 @@
 
 
 class UMBridgeWrapper(AbstractIntegrand):
-    """
-    Wrapper around a [`UM-Bridge`](https://um-bridge-benchmarks.readthedocs.io/en/docs/index.html) model. See also the [`UM-Bridge` documentation for the QMCPy client](https://um-bridge-benchmarks.readthedocs.io/en/docs/umbridge/clients.html).
+    """Wrapper around a
+    [`UM-Bridge`](https://um-bridge-benchmarks.readthedocs.io/en/docs/index.html)
+    model. See also the [`UM-Bridge` documentation for the QMCPy
+    client](https://um-bridge-benchmarks.readthedocs.io/en/docs/umbridge/clients.html).
     Requires [Docker](https://www.docker.com/) is installed.
 
     Examples:
@@ -69,13 +71,15 @@ def __init__(self, true_measure, model, config=None, parallel=False):
         Args:
             true_measure (AbstractTrueMeasure): The true measure.
             model (umbridge.HTTPModel): A `UM-Bridge` model.
-            config (dict): Configuration keyword argument to `umbridge.HTTPModel(url,name).__call__`.
+            config (dict): Configuration keyword argument to
+                `umbridge.HTTPModel(url,name).__call__`.
             parallel (int): Parallelization flag.
 
                 - When `parallel = 0` or `parallel = 1` then function evaluation is done in serial fashion.
                 - `parallel > 1` specifies the number of processes used by `multiprocessing.Pool` or `multiprocessing.pool.ThreadPool`.
 
-                Setting `parallel=True` is equivalent to `parallel = os.cpu_count()`.
+                Setting `parallel=True` is equivalent to `parallel =
+                os.cpu_count()`.
         """
         if config is None:
             config = {}
@@ -140,14 +144,17 @@ def _spawn(self, _level, _sampler):
         )
 
     def to_umbridge_out_sizes(self, x):
-        """
-        Convert a data attribute to `UM-Bridge` output sized list of lists.
+        """Convert a data attribute to `UM-Bridge` output sized list of
+        lists.
 
         Args:
-            x (np.ndarray): Array of length `sum(model.get_output_sizes(self.config))` where `model` is a `umbridge.HTTPModel`.
+            x (np.ndarray): Array of length
+                `sum(model.get_output_sizes(self.config))` where `model` is a
+                `umbridge.HTTPModel`.
 
         Returns:
-            x_list_list (list): List of lists with sub-list lengths specified by `model.get_output_sizes(self.config)`.
+            List of lists with sub-list lengths specified by
+            `model.get_output_sizes(self.config)`.
         """
         return [
             x[..., self.d_out_umbridge[j] : self.d_out_umbridge[j + 1]].tolist()
diff --git a/qmcpy/kernel/abstract_kernel.py b/qmcpy/kernel/abstract_kernel.py
index 94b89c3fe..bd108d405 100644
--- a/qmcpy/kernel/abstract_kernel.py
+++ b/qmcpy/kernel/abstract_kernel.py
@@ -78,20 +78,29 @@ def get_batch_params(self, ndim):
         }
 
     def __call__(self, x0, x1, beta0=None, beta1=None, c=None, **kwargs):
-        r"""
-        Evaluate the kernel with (optional) partial derivatives
+        r"""Evaluate the kernel with (optional) partial derivatives
 
-        $$\sum_{\ell=1}^p c_{\ell} \partial_{\boldsymbol{x}_0}^{\boldsymbol{\beta}_{\ell 0}} \partial_{\boldsymbol{x}_1}^{\boldsymbol{\beta}_{\ell 1}} K(\boldsymbol{x}_0,\boldsymbol{x}_1).$$
+        $$\sum_{\ell=1}^p c_{\ell}
+        \partial_{\boldsymbol{x}_0}^{\boldsymbol{\beta}_{\ell 0}}
+        \partial_{\boldsymbol{x}_1}^{\boldsymbol{\beta}_{\ell 1}}
+        K(\boldsymbol{x}_0,\boldsymbol{x}_1).$$
 
         Args:
-            x0 (Union[np.ndarray, torch.Tensor]): Shape `x0.shape=(...,d)` first input to kernel with
-            x1 (Union[np.ndarray, torch.Tensor]): Shape `x1.shape=(...,d)` second input to kernel with
-            beta0 (Union[np.ndarray, torch.Tensor]): Shape `beta0.shape=(p,d)` derivative orders with respect to first inputs, $\boldsymbol{\beta}_0$.
-            beta1 (Union[np.ndarray, torch.Tensor]): Shape `beta1.shape=(p,d)` derivative orders with respect to first inputs, $\boldsymbol{\beta}_1$.
-            c (Union[np.ndarray, torch.Tensor]): Shape `c.shape=(p,)` coefficients of derivatives.
+            x0 (Union[np.ndarray, torch.Tensor]): Shape `x0.shape=(...,d)`
+                first input to kernel with
+            x1 (Union[np.ndarray, torch.Tensor]): Shape `x1.shape=(...,d)`
+                second input to kernel with
+            beta0 (Union[np.ndarray, torch.Tensor]): Shape `beta0.shape=(p,d)`
+                derivative orders with respect to first inputs,
+                $\boldsymbol{\beta}_0$.
+            beta1 (Union[np.ndarray, torch.Tensor]): Shape `beta1.shape=(p,d)`
+                derivative orders with respect to first inputs,
+                $\boldsymbol{\beta}_1$.
+            c (Union[np.ndarray, torch.Tensor]): Shape `c.shape=(p,)`
+                coefficients of derivatives.
             kwargs (dict): keyword arguments to parsed call
         Returns:
-            k (Union[np.ndarray, torch.Tensor]): Shape `y.shape=(x0+x1).shape[:-1]` kernel evaluations.
+            Shape `y.shape=(x0+x1).shape[:-1]` kernel evaluations.
         """
         assert isinstance(x0, self.nptarraytype)
         assert isinstance(x0, self.nptarraytype)
@@ -253,16 +262,17 @@ def parsed___call__(self, *args, **kwargs):
         raise MethodImplementationError(self, "parsed___call__")
 
     def single_integral_01d(self, x):
-        r"""
-        Evaluate the integral of the kernel over the unit cube
+        r"""Evaluate the integral of the kernel over the unit cube
 
-        $$\tilde{K}(\boldsymbol{x}) = \int_{[0,1]^d} K(\boldsymbol{x},\boldsymbol{z}) \; \mathrm{d} \boldsymbol{z}.$$
+        $$\tilde{K}(\boldsymbol{x}) = \int_{[0,1]^d}
+        K(\boldsymbol{x},\boldsymbol{z}) \; \mathrm{d} \boldsymbol{z}.$$
 
         Args:
-            x (Union[np.ndarray, torch.Tensor]): Shape `x0.shape=(...,d)` first input to kernel with
+            x (Union[np.ndarray, torch.Tensor]): Shape `x0.shape=(...,d)` first
+                input to kernel with
 
         Returns:
-            tildek (Union[np.ndarray, torch.Tensor]): Shape `y.shape=x.shape[:-1]` integral kernel evaluations.
+            Shape `y.shape=x.shape[:-1]` integral kernel evaluations.
         """
         if self.npt == np:
             assert isinstance(x, np.ndarray)
@@ -281,13 +291,14 @@ def parsed_single_integral_01d(self, x, batch_params):
         raise MethodImplementationError(self, "parsed_single_integral_01d")
 
     def double_integral_01d(self):
-        r"""
-        Evaluate the integral of the kernel over the unit cube
+        r"""Evaluate the integral of the kernel over the unit cube
 
-        $$\tilde{K} = \int_{[0,1]^d} \int_{[0,1]^d} K(\boldsymbol{x},\boldsymbol{z}) \; \mathrm{d} \boldsymbol{x} \; \mathrm{d} \boldsymbol{z}.$$
+        $$\tilde{K} = \int_{[0,1]^d} \int_{[0,1]^d}
+        K(\boldsymbol{x},\boldsymbol{z}) \; \mathrm{d} \boldsymbol{x} \;
+        \mathrm{d} \boldsymbol{z}.$$
 
         Returns:
-            tildek (Union[np.ndarray, torch.Tensor]): Double integral kernel evaluations.
+            Double integral kernel evaluations.
         """
         raise MethodImplementationError(self, "double_integral_01d")
 
@@ -340,17 +351,29 @@ def __init__(
         Args:
             d (int): Dimension.
             scale (Union[np.ndarray, torch.Tensor]): Scaling factor $S$.
-            lengthscales (Union[np.ndarray, torch.Tensor]): Lengthscales $\boldsymbol{\gamma}$.
+            lengthscales (Union[np.ndarray, torch.Tensor]): Lengthscales
+                $\boldsymbol{\gamma}$.
             shape_scale (list): Shape of `scale` when `np.isscalar(scale)`.
-            shape_lengthscales (list): Shape of `lengthscales` when `np.isscalar(lengthscales)`
-            tfs_scale (Tuple[callable,callable]): The first argument transforms to the raw value to be optimized; the second applies the inverse transform.
-            tfs_lengthscales (Tuple[callable,callable]): The first argument transforms to the raw value to be optimized; the second applies the inverse transform.
-            torchify (bool): If `True`, use the `torch` backend. Set to `True` if computing gradients with respect to inputs and/or hyperparameters.
-            requires_grad_scale (bool): If `True` and `torchify`, set `requires_grad=True` for `scale`.
-            requires_grad_lengthscales (bool): If `True` and `torchify`, set `requires_grad=True` for `lengthscales`.
+            shape_lengthscales (list): Shape of `lengthscales` when
+                `np.isscalar(lengthscales)`
+            tfs_scale (Tuple[callable,callable]): The first argument transforms
+                to the raw value to be optimized; the second applies the
+                inverse transform.
+            tfs_lengthscales (Tuple[callable,callable]): The first argument
+                transforms to the raw value to be optimized; the second applies
+                the inverse transform.
+            torchify (bool): If `True`, use the `torch` backend. Set to `True`
+                if computing gradients with respect to inputs and/or
+                hyperparameters.
+            requires_grad_scale (bool): If `True` and `torchify`, set
+                `requires_grad=True` for `scale`.
+            requires_grad_lengthscales (bool): If `True` and `torchify`, set
+                `requires_grad=True` for `lengthscales`.
             device (torch.device): If `torchify`, put things onto this device.
-            compile_call (bool): If `True`, `torch.compile` the `parsed___call__` method.
-            compile_call_kwargs (dict): When `compile_call` is `True`, pass these keyword arguments to `torch.compile`.
+            compile_call (bool): If `True`, `torch.compile` the
+                `parsed___call__` method.
+            compile_call_kwargs (dict): When `compile_call` is `True`, pass
+                these keyword arguments to `torch.compile`.
         """
         if shape_scale is None:
             shape_scale = [1]
diff --git a/qmcpy/kernel/common_kernels.py b/qmcpy/kernel/common_kernels.py
index 193a694e8..2d652061d 100644
--- a/qmcpy/kernel/common_kernels.py
+++ b/qmcpy/kernel/common_kernels.py
@@ -39,10 +39,11 @@ def double_integral_01d(self):
 
 
 class KernelGaussian(AbstractKernelGaussianSE):
-    r"""
-    Gaussian / Squared Exponential kernel implemented using the product of exponentials.
+    r"""Gaussian / Squared Exponential kernel implemented using the product of
+    exponentials.
 
-    $$K(\boldsymbol{x},\boldsymbol{z}) = S \prod_{j=1}^d \exp\left(-\left(\frac{x_j-z_j}{\sqrt{2} \gamma_j}\right)^2\right)$$
+    $$K(\boldsymbol{x},\boldsymbol{z}) = S \prod_{j=1}^d
+    \exp\left(-\left(\frac{x_j-z_j}{\sqrt{2} \gamma_j}\right)^2\right)$$
 
     Examples:
         >>> rng = np.random.Generator(np.random.PCG64(7))
@@ -269,11 +270,14 @@ def parsed___call__(self, x0, x1, batch_params):
 
 
 class KernelSquaredExponential(AbstractKernelGaussianSE):
-    r"""
-    Gaussian / Squared Exponential kernel implemented using the pairwise distance function.
-    Please use `KernelGaussian` when using derivative information.
+    r"""Gaussian / Squared Exponential kernel implemented using the pairwise
+    distance function. Please use `KernelGaussian` when using derivative
+    information.
 
-    $$K(\boldsymbol{x},\boldsymbol{z}) = S \exp\left(-d_{\boldsymbol{\gamma}}^2(\boldsymbol{x},\boldsymbol{z})\right), \qquad d_{\boldsymbol{\gamma}}(\boldsymbol{x},\boldsymbol{z}) = \left\lVert\frac{\boldsymbol{x}-\boldsymbol{z}}{\sqrt{2}\boldsymbol{\gamma}}\right\rVert_2.$$
+    $$K(\boldsymbol{x},\boldsymbol{z}) = S
+    \exp\left(-d_{\boldsymbol{\gamma}}^2(\boldsymbol{x},\boldsymbol{z})\right),
+    \qquad d_{\boldsymbol{\gamma}}(\boldsymbol{x},\boldsymbol{z}) =
+    \left\lVert\frac{\boldsymbol{x}-\boldsymbol{z}}{\sqrt{2}\boldsymbol{\gamma}}\right\rVert_2.$$
 
     Examples:
         >>> rng = np.random.Generator(np.random.PCG64(7))
@@ -363,10 +367,12 @@ def parsed___call__(self, x0, x1, batch_params):
 
 
 class KernelRationalQuadratic(AbstractKernelScaleLengthscales):
-    r"""
-    Rational Quadratic kernel
+    r"""Rational Quadratic kernel
 
-    $$K(\boldsymbol{x},\boldsymbol{z}) = S \left(1+\frac{d_{\boldsymbol{\gamma}}^2(\boldsymbol{x},\boldsymbol{z})}{\alpha}\right)^{-\alpha}, \qquad d_{\boldsymbol{\gamma}}(\boldsymbol{x},\boldsymbol{z}) = \left\lVert\frac{\boldsymbol{x}-\boldsymbol{z}}{\sqrt{2}\boldsymbol{\gamma}}\right\rVert_2.$$
+    $$K(\boldsymbol{x},\boldsymbol{z}) = S
+    \left(1+\frac{d_{\boldsymbol{\gamma}}^2(\boldsymbol{x},\boldsymbol{z})}{\alpha}\right)^{-\alpha},
+    \qquad d_{\boldsymbol{\gamma}}(\boldsymbol{x},\boldsymbol{z}) =
+    \left\lVert\frac{\boldsymbol{x}-\boldsymbol{z}}{\sqrt{2}\boldsymbol{\gamma}}\right\rVert_2.$$
 
     Examples:
         >>> rng = np.random.Generator(np.random.PCG64(7))
@@ -473,21 +479,37 @@ def __init__(
         Args:
             d (int): Dimension.
             scale (Union[np.ndarray, torch.Tensor]): Scaling factor $S$.
-            lengthscales (Union[np.ndarray, torch.Tensor]): Lengthscales $\boldsymbol{\gamma}$.
-            alpha (Union[np.ndarray, torch.Tensor]): Scale mixture parameter $\alpha$.
+            lengthscales (Union[np.ndarray, torch.Tensor]): Lengthscales
+                $\boldsymbol{\gamma}$.
+            alpha (Union[np.ndarray, torch.Tensor]): Scale mixture parameter
+                $\alpha$.
             shape_scale (list): Shape of `scale` when `np.isscalar(scale)`.
-            shape_lengthscales (list): Shape of `lengthscales` when `np.isscalar(lengthscales)`
+            shape_lengthscales (list): Shape of `lengthscales` when
+                `np.isscalar(lengthscales)`
             shape_alpha (list): Shape of `alpha` when `np.isscalar(alpha)`
-            tfs_scale (Tuple[callable,callable]): The first argument transforms to the raw value to be optimized; the second applies the inverse transform.
-            tfs_lengthscales (Tuple[callable,callable]): The first argument transforms to the raw value to be optimized; the second applies the inverse transform.
-            tfs_alpha (Tuple[callable,callable]): The first argument transforms to the raw value to be optimized; the second applies the inverse transform.
-            torchify (bool): If `True`, use the `torch` backend. Set to `True` if computing gradients with respect to inputs and/or hyperparameters.
-            requires_grad_scale (bool): If `True` and `torchify`, set `requires_grad=True` for `scale`.
-            requires_grad_lengthscales (bool): If `True` and `torchify`, set `requires_grad=True` for `lengthscales`.
-            requires_grad_alpha (bool): If `True` and `torchify`, set `requires_grad=True` for `alpha`.
+            tfs_scale (Tuple[callable,callable]): The first argument transforms
+                to the raw value to be optimized; the second applies the
+                inverse transform.
+            tfs_lengthscales (Tuple[callable,callable]): The first argument
+                transforms to the raw value to be optimized; the second applies
+                the inverse transform.
+            tfs_alpha (Tuple[callable,callable]): The first argument transforms
+                to the raw value to be optimized; the second applies the
+                inverse transform.
+            torchify (bool): If `True`, use the `torch` backend. Set to `True`
+                if computing gradients with respect to inputs and/or
+                hyperparameters.
+            requires_grad_scale (bool): If `True` and `torchify`, set
+                `requires_grad=True` for `scale`.
+            requires_grad_lengthscales (bool): If `True` and `torchify`, set
+                `requires_grad=True` for `lengthscales`.
+            requires_grad_alpha (bool): If `True` and `torchify`, set
+                `requires_grad=True` for `alpha`.
             device (torch.device): If `torchify`, put things onto this device.
-            compile_call (bool): If `True`, `torch.compile` the `parsed___call__` method.
-            compile_call_kwargs (dict): When `compile_call` is `True`, pass these keyword arguments to `torch.compile`.
+            compile_call (bool): If `True`, `torch.compile` the
+                `parsed___call__` method.
+            compile_call_kwargs (dict): When `compile_call` is `True`, pass
+                these keyword arguments to `torch.compile`.
         """
         if shape_scale is None:
             shape_scale = [1]
@@ -536,10 +558,12 @@ def parsed___call__(self, x0, x1, batch_params):
 
 
 class KernelMatern12(AbstractKernelScaleLengthscales):
-    r"""
-    Matern kernel with $\alpha=1/2$.
+    r"""Matern kernel with $\alpha=1/2$.
 
-    $$K(\boldsymbol{x},\boldsymbol{z}) = S \exp\left(-d_{\boldsymbol{\gamma}}(\boldsymbol{x},\boldsymbol{z})\right), \qquad d_{\boldsymbol{\gamma}}(\boldsymbol{x},\boldsymbol{z}) = \left\lVert\frac{\boldsymbol{x}-\boldsymbol{z}}{\sqrt{2}\boldsymbol{\gamma}}\right\rVert_2.$$
+    $$K(\boldsymbol{x},\boldsymbol{z}) = S
+    \exp\left(-d_{\boldsymbol{\gamma}}(\boldsymbol{x},\boldsymbol{z})\right),
+    \qquad d_{\boldsymbol{\gamma}}(\boldsymbol{x},\boldsymbol{z}) =
+    \left\lVert\frac{\boldsymbol{x}-\boldsymbol{z}}{\sqrt{2}\boldsymbol{\gamma}}\right\rVert_2.$$
 
     Examples:
         >>> rng = np.random.Generator(np.random.PCG64(7))
@@ -631,10 +655,12 @@ def parsed___call__(self, x0, x1, batch_params):
 
 
 class KernelMatern32(AbstractKernelScaleLengthscales):
-    r"""
-    Matern kernel with $\alpha=3/2$.
+    r"""Matern kernel with $\alpha=3/2$.
 
-    $$K(\boldsymbol{x},\boldsymbol{z}) = S \left(1+\sqrt{3} d_{\boldsymbol{\gamma}}(\boldsymbol{x},\boldsymbol{z})\right)\exp\left(-\sqrt{3}d_{\boldsymbol{\gamma}}(\boldsymbol{x},\boldsymbol{z})\right), \qquad d_{\boldsymbol{\gamma}}(\boldsymbol{x},\boldsymbol{z}) = \left\lVert\frac{\boldsymbol{x}-\boldsymbol{z}}{\sqrt{2}\boldsymbol{\gamma}}\right\rVert_2.$$
+    $$K(\boldsymbol{x},\boldsymbol{z}) = S \left(1+\sqrt{3}
+    d_{\boldsymbol{\gamma}}(\boldsymbol{x},\boldsymbol{z})\right)\exp\left(-\sqrt{3}d_{\boldsymbol{\gamma}}(\boldsymbol{x},\boldsymbol{z})\right),
+    \qquad d_{\boldsymbol{\gamma}}(\boldsymbol{x},\boldsymbol{z}) =
+    \left\lVert\frac{\boldsymbol{x}-\boldsymbol{z}}{\sqrt{2}\boldsymbol{\gamma}}\right\rVert_2.$$
 
     Examples:
         >>> rng = np.random.Generator(np.random.PCG64(7))
@@ -726,10 +752,13 @@ def parsed___call__(self, x0, x1, batch_params):
 
 
 class KernelMatern52(AbstractKernelScaleLengthscales):
-    r"""
-    Matern kernel with $\alpha=5/2$.
+    r"""Matern kernel with $\alpha=5/2$.
 
-    $$K(\boldsymbol{x},\boldsymbol{z}) = S \left(1+\sqrt{5} d_{\boldsymbol{\gamma}}(\boldsymbol{x},\boldsymbol{z}) + \frac{5}{3} d_{\boldsymbol{\gamma}}^2(\boldsymbol{x},\boldsymbol{z})\right)\exp\left(-\sqrt{5}d_{\boldsymbol{\gamma}}(\boldsymbol{x},\boldsymbol{z})\right), \qquad d_{\boldsymbol{\gamma}}(\boldsymbol{x},\boldsymbol{z}) = \left\lVert\frac{\boldsymbol{x}-\boldsymbol{z}}{\sqrt{2}\boldsymbol{\gamma}}\right\rVert_2.$$
+    $$K(\boldsymbol{x},\boldsymbol{z}) = S \left(1+\sqrt{5}
+    d_{\boldsymbol{\gamma}}(\boldsymbol{x},\boldsymbol{z}) + \frac{5}{3}
+    d_{\boldsymbol{\gamma}}^2(\boldsymbol{x},\boldsymbol{z})\right)\exp\left(-\sqrt{5}d_{\boldsymbol{\gamma}}(\boldsymbol{x},\boldsymbol{z})\right),
+    \qquad d_{\boldsymbol{\gamma}}(\boldsymbol{x},\boldsymbol{z}) =
+    \left\lVert\frac{\boldsymbol{x}-\boldsymbol{z}}{\sqrt{2}\boldsymbol{\gamma}}\right\rVert_2.$$
 
     Examples:
         >>> rng = np.random.Generator(np.random.PCG64(7))
diff --git a/qmcpy/kernel/multitask_kernel.py b/qmcpy/kernel/multitask_kernel.py
index 9f5c3219a..dfa23a933 100644
--- a/qmcpy/kernel/multitask_kernel.py
+++ b/qmcpy/kernel/multitask_kernel.py
@@ -5,14 +5,16 @@
 
 
 class KernelMultiTask(AbstractKernel):
-    r"""
-    Multi-task kernel
+    r"""Multi-task kernel
 
-    $$K((i,\boldsymbol{x}),(j,\boldsymbol{z})) = K_{\mathrm{task}}(i,j) K_{\mathrm{base}}(\boldsymbol{x},\boldsymbol{z})$$
+    $$K((i,\boldsymbol{x}),(j,\boldsymbol{z})) = K_{\mathrm{task}}(i,j)
+    K_{\mathrm{base}}(\boldsymbol{x},\boldsymbol{z})$$
 
-    parameterized for $T$ tasks by a factor $\mathsf{F} \in \mathbb{R}^{T \times r}$ and a diagonal $\boldsymbol{v} \in \mathbb{R}^T$ so that
+    parameterized for $T$ tasks by a factor $\mathsf{F} \in \mathbb{R}^{T
+    \times r}$ and a diagonal $\boldsymbol{v} \in \mathbb{R}^T$ so that
 
-    $$\left[K_{\mathrm{task}}(i,j)\right]_{i,j=1}^T = \mathsf{F} \mathsf{F}^T + \mathrm{diag}(\boldsymbol{v}).$$
+    $$\left[K_{\mathrm{task}}(i,j)\right]_{i,j=1}^T = \mathsf{F} \mathsf{F}^T +
+    \mathrm{diag}(\boldsymbol{v}).$$
 
     Examples:
         >>> kmt = KernelMultiTask(KernelGaussian(d=2),num_tasks=3,diag=[1,2,3])
@@ -344,13 +346,20 @@ def __init__(
             base_kernel (AbstractKernel): $K_{\mathrm{base}}$.
             num_tasks (int): Number of tasks $T>1$.
             factor (Union[np.ndarray, torch.Tensor]): Factor $\mathsf{F}$.
-            diag (Union[np.ndarray, torch.Tensor]): Diagonal parameter $\boldsymbol{v}$.
+            diag (Union[np.ndarray, torch.Tensor]): Diagonal parameter
+                $\boldsymbol{v}$.
             shape_factor (list): Shape of `factor` when `np.isscalar(factor)`.
             shape_diag (list): Shape of `diag` when `np.isscalar(diag)`.
-            tfs_factor (Tuple[callable,callable]): The first argument transforms to the raw value to be optimized; the second applies the inverse transform.
-            tfs_diag (Tuple[callable,callable]): The first argument transforms to the raw value to be optimized; the second applies the inverse transform.
-            requires_grad_factor (bool): If `True` and `torchify`, set `requires_grad=True` for `factor`.
-            requires_grad_diag (bool): If `True` and `torchify`, set `requires_grad=True` for `diag`.
+            tfs_factor (Tuple[callable,callable]): The first argument
+                transforms to the raw value to be optimized; the second applies
+                the inverse transform.
+            tfs_diag (Tuple[callable,callable]): The first argument transforms
+                to the raw value to be optimized; the second applies the
+                inverse transform.
+            requires_grad_factor (bool): If `True` and `torchify`, set
+                `requires_grad=True` for `factor`.
+            requires_grad_diag (bool): If `True` and `torchify`, set
+                `requires_grad=True` for `diag`.
             method (str): `"LOW RANK"` or "CHOLESKY"
         """
         assert isinstance(base_kernel, AbstractKernel)
@@ -464,55 +473,74 @@ def _parsed__call__(self, task0, task1, k_x):
         return kmat[..., 0]
 
     def __call__(self, task0, task1, x0, x1, beta0=None, beta1=None, c=None):
-        r"""
-        Evaluate the kernel with (optional) partial derivatives
+        r"""Evaluate the kernel with (optional) partial derivatives
 
-        $$\sum_{\ell=1}^p c_\ell \partial_{\boldsymbol{x}_0}^{\boldsymbol{\beta}_{\ell,0}} \partial_{\boldsymbol{x}_1}^{\boldsymbol{\beta}_{\ell,1}} K((i_0,\boldsymbol{x}_0),(i_1,\boldsymbol{x}_1)).$$
+        $$\sum_{\ell=1}^p c_\ell
+        \partial_{\boldsymbol{x}_0}^{\boldsymbol{\beta}_{\ell,0}}
+        \partial_{\boldsymbol{x}_1}^{\boldsymbol{\beta}_{\ell,1}}
+        K((i_0,\boldsymbol{x}_0),(i_1,\boldsymbol{x}_1)).$$
 
         Args:
-            task0 (Union[int, np.ndarray, torch.Tensor]): First task indices $i_0$.
-            task1 (Union[int, np.ndarray, torch.Tensor]): Second task indices $i_1$.
-            x0 (Union[np.ndarray, torch.Tensor]): Shape `x0.shape=(...,d)` first input to kernel.
-            x1 (Union[np.ndarray, torch.Tensor]): Shape `x1.shape=(...,d)` second input to kernel.
-            beta0 (Union[np.ndarray, torch.Tensor]): Shape `beta0.shape=(p,d)` derivative orders with respect to first inputs, $\boldsymbol{\beta}_0$.
-            beta1 (Union[np.ndarray, torch.Tensor]): Shape `beta1.shape=(p,d)` derivative orders with respect to first inputs, $\boldsymbol{\beta}_1$.
-            c (Union[np.ndarray, torch.Tensor]): Shape `c.shape=(p,)` coefficients of derivatives.
+            task0 (Union[int, np.ndarray, torch.Tensor]): First task indices
+                $i_0$.
+            task1 (Union[int, np.ndarray, torch.Tensor]): Second task indices
+                $i_1$.
+            x0 (Union[np.ndarray, torch.Tensor]): Shape `x0.shape=(...,d)`
+                first input to kernel.
+            x1 (Union[np.ndarray, torch.Tensor]): Shape `x1.shape=(...,d)`
+                second input to kernel.
+            beta0 (Union[np.ndarray, torch.Tensor]): Shape `beta0.shape=(p,d)`
+                derivative orders with respect to first inputs,
+                $\boldsymbol{\beta}_0$.
+            beta1 (Union[np.ndarray, torch.Tensor]): Shape `beta1.shape=(p,d)`
+                derivative orders with respect to first inputs,
+                $\boldsymbol{\beta}_1$.
+            c (Union[np.ndarray, torch.Tensor]): Shape `c.shape=(p,)`
+                coefficients of derivatives.
 
         Returns:
-            k (Union[np.ndarray, torch.Tensor]): Kernel evaluations with batched shape, see the doctests for examples.
+            Kernel evaluations with batched shape, see the doctests for
+            examples.
         """
         kmat_x = self.base_kernel.__call__(x0, x1, beta0, beta1, c)
         return self._parsed__call__(task0, task1, kmat_x)
 
     def single_integral_01d(self, task0, task1, x):
-        r"""
-        Evaluate the integral of the kernel over the unit cube
+        r"""Evaluate the integral of the kernel over the unit cube
 
-        $$\tilde{K}((i_0,\boldsymbol{x}),i_1) = \int_{[0,1]^d} K((i_0,\boldsymbol{x}),(i_1,\boldsymbol{z}) \; \mathrm{d} \boldsymbol{z}.$$
+        $$\tilde{K}((i_0,\boldsymbol{x}),i_1) = \int_{[0,1]^d}
+        K((i_0,\boldsymbol{x}),(i_1,\boldsymbol{z}) \; \mathrm{d}
+        \boldsymbol{z}.$$
 
         Args:
-            task0 (Union[int, np.ndarray, torch.Tensor]): First task indices $i_0$.
-            task1 (Union[int, np.ndarray, torch.Tensor]): Second task indices $i_1$.
-            x (Union[np.ndarray, torch.Tensor]): Shape `x0.shape=(...,d)` first input to kernel with
+            task0 (Union[int, np.ndarray, torch.Tensor]): First task indices
+                $i_0$.
+            task1 (Union[int, np.ndarray, torch.Tensor]): Second task indices
+                $i_1$.
+            x (Union[np.ndarray, torch.Tensor]): Shape `x0.shape=(...,d)` first
+                input to kernel with
 
         Returns:
-            tildek (Union[np.ndarray, torch.Tensor]): Shape `y.shape=x.shape[:-1]` integral kernel evaluations.
+            Shape `y.shape=x.shape[:-1]` integral kernel evaluations.
         """
         kint_x = self.base_kernel.single_integral_01d(x)
         return self._parsed__call__(task0, task1, kint_x)
 
     def double_integral_01d(self, task0, task1):
-        r"""
-        Evaluate the integral of the kernel over the unit cube
+        r"""Evaluate the integral of the kernel over the unit cube
 
-        $$\tilde{K}(i_0,i_1) = \int_{[0,1]^d} \int_{[0,1]^d} K((i_0,\boldsymbol{x}),(i_1,\boldsymbol{z})) \; \mathrm{d} \boldsymbol{x} \; \mathrm{d} \boldsymbol{z}.$$
+        $$\tilde{K}(i_0,i_1) = \int_{[0,1]^d} \int_{[0,1]^d}
+        K((i_0,\boldsymbol{x}),(i_1,\boldsymbol{z})) \; \mathrm{d}
+        \boldsymbol{x} \; \mathrm{d} \boldsymbol{z}.$$
 
         Args:
-            task0 (Union[int, np.ndarray, torch.Tensor]): First task indices $i_0$.
-            task1 (Union[int, np.ndarray, torch.Tensor]): Second task indices $i_1$.
+            task0 (Union[int, np.ndarray, torch.Tensor]): First task indices
+                $i_0$.
+            task1 (Union[int, np.ndarray, torch.Tensor]): Second task indices
+                $i_1$.
 
         Returns:
-            tildek (Union[np.ndarray, torch.Tensor]): Double integral kernel evaluations.
+            Double integral kernel evaluations.
         """
         kint_x = self.base_kernel.double_integral_01d()
         return self._parsed__call__(task0, task1, kint_x)
diff --git a/qmcpy/kernel/si_dsi_kernels.py b/qmcpy/kernel/si_dsi_kernels.py
index 83ea718e9..dc991869b 100644
--- a/qmcpy/kernel/si_dsi_kernels.py
+++ b/qmcpy/kernel/si_dsi_kernels.py
@@ -161,17 +161,16 @@ def parsed___call__(self, x0, x1, beta0, beta1, c, batch_params, stable=False):
 
 
 class KernelShiftInvar(AbstractSIDSIKernel):
-    r""" 
-    Shift invariant kernel with 
-    smoothness $\boldsymbol{\alpha}$, product weights (lengthscales) $\boldsymbol{\gamma}$, and scale $S$:
-    
-    $$\begin{aligned}
-        K(\boldsymbol{x},\boldsymbol{z}) &= S \prod_{j=1}^d \left(1+ \gamma_j \tilde{K}_{\alpha_j}((x_j - z_j) \mod 1))\right), \\ 
-        \tilde{K}_\alpha(x) &= (-1)^{\alpha+1}\frac{(2 \pi)^{2 \alpha}}{(2\alpha)!} B_{2\alpha}(x)
-    \end{aligned}$$
+    r"""Shift invariant kernel with smoothness $\boldsymbol{\alpha}$, product
+    weights (lengthscales) $\boldsymbol{\gamma}$, and scale $S$:
+
+    $$\begin{aligned} K(\boldsymbol{x},\boldsymbol{z}) &= S \prod_{j=1}^d
+    \left(1+ \gamma_j \tilde{K}_{\alpha_j}((x_j - z_j) \mod 1))\right), \\
+    \tilde{K}_\alpha(x) &= (-1)^{\alpha+1}\frac{(2 \pi)^{2 \alpha}}{(2\alpha)!}
+    B_{2\alpha}(x) \end{aligned}$$
 
     where $B_n$ is the $n^\text{th}$ Bernoulli polynomial.
-    
+
     Examples:
         >>> from qmcpy import Lattice, fftbr, ifftbr
         >>> n = 8
@@ -183,7 +182,7 @@ class KernelShiftInvar(AbstractSIDSIKernel):
         >>> x.dtype
         dtype('float64')
         >>> kernel = KernelShiftInvar(
-        ...     d = d, 
+        ...     d = d,
         ...     alpha = list(range(1,d+1)),
         ...     scale = 10,
         ...     lengthscales = [1/j**2 for j in range(1,d+1)])
@@ -213,10 +212,10 @@ class KernelShiftInvar(AbstractSIDSIKernel):
         True
         >>> np.allclose(ifftbr(fftbr(y)/lam),np.linalg.solve(kmat,y))
         True
-        >>> import torch 
+        >>> import torch
         >>> xtorch = torch.from_numpy(x)
         >>> kernel_torch = KernelShiftInvar(
-        ...     d = d, 
+        ...     d = d,
         ...     alpha = list(range(1,d+1)),
         ...     scale = 10,
         ...     lengthscales = [1/j**2 for j in range(1,d+1)],
@@ -229,16 +228,16 @@ class KernelShiftInvar(AbstractSIDSIKernel):
         >>> kernel_torch.single_integral_01d(xtorch)
         tensor([10., 10., 10., 10., 10., 10., 10., 10.], dtype=torch.float64,
                grad_fn=<AddBackward0>)
-        
-        Batch Params 
-        
+
+        Batch Params
+
         >>> rng = np.random.Generator(np.random.PCG64(7))
         >>> kernel = KernelShiftInvar(
-        ...     d = 2, 
+        ...     d = 2,
         ...     shape_scale = [4,3,1],
         ...     shape_lengthscales = [3,2])
         >>> x = rng.uniform(low=0,high=1,size=(6,5,2))
-        >>> kernel(x,x).shape 
+        >>> kernel(x,x).shape
         (4, 3, 6, 5)
         >>> kernel(x[:,:,None,:],x[:,None,:,:]).shape
         (4, 3, 6, 5, 5)
@@ -249,7 +248,7 @@ class KernelShiftInvar(AbstractSIDSIKernel):
         >>> np.abs(kfast-kstable).max()
         np.float64(4.440892098500626e-16)
 
-        Derivatives 
+        Derivatives
 
         >>> rng = np.random.Generator(np.random.PCG64(7))
         >>> scale = rng.uniform(low=0,high=1,size=(1,))
@@ -309,10 +308,10 @@ class KernelShiftInvar(AbstractSIDSIKernel):
         >>> np.allclose(ynp,y.numpy())
         True
 
-    **References:** 
-    
-    1.  Kaarnioja, Vesa, Frances Y. Kuo, and Ian H. Sloan.  
-        "Lattice-based kernel approximation and serendipitous weights for parametric PDEs in very high dimensions."  
+    **References: **
+
+    1.  Kaarnioja, Vesa, Frances Y. Kuo, and Ian H. Sloan.
+        "Lattice-based kernel approximation and serendipitous weights for parametric PDEs in very high dimensions."
         International Conference on Monte Carlo and Quasi-Monte Carlo Methods in Scientific Computing. Cham: Springer International Publishing, 2022.
     """
 
@@ -341,22 +340,39 @@ def __init__(
         Args:
             d (int): Dimension.
             scale (Union[np.ndarray, torch.Tensor]): Scaling factor $S$.
-            lengthscales (Union[np.ndarray, torch.Tensor]): Product weights $(\gamma_1,\dots,\gamma_d)$.
-            alpha (Union[np.ndarray, torch.Tensor]): Smoothness parameters $(\alpha_1,\dots,\alpha_d)$ where $\alpha_j \geq 1$ for $j=1,\dots,d$.
+            lengthscales (Union[np.ndarray, torch.Tensor]): Product weights
+                $(\gamma_1,\dots,\gamma_d)$.
+            alpha (Union[np.ndarray, torch.Tensor]): Smoothness parameters
+                $(\alpha_1,\dots,\alpha_d)$ where $\alpha_j \geq 1$ for
+                $j=1,\dots,d$.
             shape_scale (list): Shape of `scale` when `np.isscalar(scale)`.
-            shape_lengthscales (list): Shape of `lengthscales` when `np.isscalar(lengthscales)`
-            tfs_scale (Tuple[callable,callable]): The first argument transforms to the raw value to be optimized; the second applies the inverse transform.
-            tfs_lengthscales (Tuple[callable,callable]): The first argument transforms to the raw value to be optimized; the second applies the inverse transform.
-            torchify (bool): If `True`, use the `torch` backend. Set to `True` if computing gradients with respect to inputs and/or hyperparameters.
-            requires_grad_scale (bool): If `True` and `torchify`, set `requires_grad=True` for `scale`.
-            requires_grad_lengthscales (bool): If `True` and `torchify`, set `requires_grad=True` for `lengthscales`.
+            shape_lengthscales (list): Shape of `lengthscales` when
+                `np.isscalar(lengthscales)`
+            tfs_scale (Tuple[callable,callable]): The first argument transforms
+                to the raw value to be optimized; the second applies the
+                inverse transform.
+            tfs_lengthscales (Tuple[callable,callable]): The first argument
+                transforms to the raw value to be optimized; the second applies
+                the inverse transform.
+            torchify (bool): If `True`, use the `torch` backend. Set to `True`
+                if computing gradients with respect to inputs and/or
+                hyperparameters.
+            requires_grad_scale (bool): If `True` and `torchify`, set
+                `requires_grad=True` for `scale`.
+            requires_grad_lengthscales (bool): If `True` and `torchify`, set
+                `requires_grad=True` for `lengthscales`.
             device (torch.device): If `torchify`, put things onto this device.
-            compile_call (bool): If `True`, `torch.compile` the `parsed___call__` method.
-            compile_call_kwargs (dict): When `compile_call` is `True`, pass these keyword arguments to `torch.compile`.
-            weights (Union[np.ndarray, torch.Tensor]): Alias for `lengthscales`.
+            compile_call (bool): If `True`, `torch.compile` the
+                `parsed___call__` method.
+            compile_call_kwargs (dict): When `compile_call` is `True`, pass
+                these keyword arguments to `torch.compile`.
+            weights (Union[np.ndarray, torch.Tensor]): Alias for
+                `lengthscales`.
             shape_weights (list): Alias for `shape_lengthscales`.
-            tfs_weights (Tuple[callable,callable]): Alias for `tfs_lengthscales`.
-            requires_grad_weights (bool): Alias for `requires_grad_lengthscales`.
+            tfs_weights (Tuple[callable,callable]): Alias for
+                `tfs_lengthscales`.
+            requires_grad_weights (bool): Alias for
+                `requires_grad_lengthscales`.
         """
         if shape_scale is None:
             shape_scale = [1]
@@ -423,15 +439,16 @@ def get_per_dim_components(self, x0, x1, beta0, beta1):
 
 
 class KernelShiftInvarCombined(AbstractSIDSIKernel):
-    r"""
-    Shift invariant kernel with
-    combination weights $\boldsymbol{\alpha}_1,\dots,\boldsymbol{\alpha}_d \in \mathbb{R}_{>0}^4$, product weights (lengthscales) $\boldsymbol{\gamma}$, and scale $S$:
+    r"""Shift invariant kernel with combination weights
+    $\boldsymbol{\alpha}_1,\dots,\boldsymbol{\alpha}_d \in \mathbb{R}_{>0}^4$,
+    product weights (lengthscales) $\boldsymbol{\gamma}$, and scale $S$:
 
-    $$\begin{aligned}
-        K(\boldsymbol{x},\boldsymbol{z}) &= S \prod_{j=1}^d \left(1+ \gamma_j \left(\sum_{p=1}^4 \alpha_{jp} \tilde{K}_p(x_j \mod 1 z_j)\right)\right)
-    \end{aligned}$$
+    $$\begin{aligned} K(\boldsymbol{x},\boldsymbol{z}) &= S \prod_{j=1}^d
+    \left(1+ \gamma_j \left(\sum_{p=1}^4 \alpha_{jp} \tilde{K}_p(x_j \mod 1
+    z_j)\right)\right) \end{aligned}$$
 
-    where, $\tilde{K}_p$ are defined in `KernelShiftInvar` for $p \in \{1,2,3,4\}$
+    where, $\tilde{K}_p$ are defined in `KernelShiftInvar` for $p \in
+    \{1,2,3,4\}$
 
     Examples:
         >>> from qmcpy import Lattice, fftbr, ifftbr
@@ -508,7 +525,7 @@ class KernelShiftInvarCombined(AbstractSIDSIKernel):
         >>> np.abs(kfast-kstable).max()
         np.float64(3.552713678800501e-15)
 
-    **References:**
+    **References: **
 
     1.  Kaarnioja, Vesa, Frances Y. Kuo, and Ian H. Sloan.
         "Lattice-based kernel approximation and serendipitous weights for parametric PDEs in very high dimensions."
@@ -543,25 +560,45 @@ def __init__(
         Args:
             d (int): Dimension.
             scale (Union[np.ndarray, torch.Tensor]): Scaling factor $S$.
-            lengthscales (Union[np.ndarray, torch.Tensor]): Product weights $(\gamma_1,\dots,\gamma_d)$.
-            alpha (Union[np.ndarray, torch.Tensor]): Weights $\boldsymbol{\alpha}_1,\dots,\boldsymbol{\alpha}_d \in \mathbb{R}_{>0}^4$.
+            lengthscales (Union[np.ndarray, torch.Tensor]): Product weights
+                $(\gamma_1,\dots,\gamma_d)$.
+            alpha (Union[np.ndarray, torch.Tensor]): Weights
+                $\boldsymbol{\alpha}_1,\dots,\boldsymbol{\alpha}_d \in
+                \mathbb{R}_{>0}^4$.
             shape_scale (list): Shape of `scale` when `np.isscalar(scale)`.
-            shape_lengthscales (list): Shape of `lengthscales` when `np.isscalar(lengthscales)`
+            shape_lengthscales (list): Shape of `lengthscales` when
+                `np.isscalar(lengthscales)`
             shape_alpha (list): Shape of `alpha` when `np.isscalar(alpha)`
-            tfs_scale (Tuple[callable,callable]): The first argument transforms to the raw value to be optimized; the second applies the inverse transform.
-            tfs_lengthscales (Tuple[callable,callable]): The first argument transforms to the raw value to be optimized; the second applies the inverse transform.
-            tfs_alpha (Tuple[callable,callable]): The first argument transforms to the raw value to be optimized; the second applies the inverse transform.
-            torchify (bool): If `True`, use the `torch` backend. Set to `True` if computing gradients with respect to inputs and/or hyperparameters.
-            requires_grad_scale (bool): If `True` and `torchify`, set `requires_grad=True` for `scale`.
-            requires_grad_lengthscales (bool): If `True` and `torchify`, set `requires_grad=True` for `lengthscales`.
-            requires_grad_alpha (bool): If `True` and `torchify`, set `requires_grad=True` for `alpha`.
+            tfs_scale (Tuple[callable,callable]): The first argument transforms
+                to the raw value to be optimized; the second applies the
+                inverse transform.
+            tfs_lengthscales (Tuple[callable,callable]): The first argument
+                transforms to the raw value to be optimized; the second applies
+                the inverse transform.
+            tfs_alpha (Tuple[callable,callable]): The first argument transforms
+                to the raw value to be optimized; the second applies the
+                inverse transform.
+            torchify (bool): If `True`, use the `torch` backend. Set to `True`
+                if computing gradients with respect to inputs and/or
+                hyperparameters.
+            requires_grad_scale (bool): If `True` and `torchify`, set
+                `requires_grad=True` for `scale`.
+            requires_grad_lengthscales (bool): If `True` and `torchify`, set
+                `requires_grad=True` for `lengthscales`.
+            requires_grad_alpha (bool): If `True` and `torchify`, set
+                `requires_grad=True` for `alpha`.
             device (torch.device): If `torchify`, put things onto this device.
-            compile_call (bool): If `True`, `torch.compile` the `parsed___call__` method.
-            compile_call_kwargs (dict): When `compile_call` is `True`, pass these keyword arguments to `torch.compile`.
-            weights (Union[np.ndarray, torch.Tensor]): Alias for `lengthscales`.
+            compile_call (bool): If `True`, `torch.compile` the
+                `parsed___call__` method.
+            compile_call_kwargs (dict): When `compile_call` is `True`, pass
+                these keyword arguments to `torch.compile`.
+            weights (Union[np.ndarray, torch.Tensor]): Alias for
+                `lengthscales`.
             shape_weights (list): Alias for `shape_lengthscales`.
-            tfs_weights (Tuple[callable,callable]): Alias for `tfs_lengthscales`.
-            requires_grad_weights (bool): Alias for `requires_grad_lengthscales`.
+            tfs_weights (Tuple[callable,callable]): Alias for
+                `tfs_lengthscales`.
+            requires_grad_weights (bool): Alias for
+                `requires_grad_lengthscales`.
         """
         if shape_scale is None:
             shape_scale = [1]
@@ -628,27 +665,36 @@ def combine_per_dim_components_raw_m1(
 
 
 class KernelDigShiftInvar(AbstractSIDSIKernel):
-    r""" 
-    Digitally shift invariant kernel in base $b=2$ with 
-    smoothness $\boldsymbol{\alpha}$, product weights $\boldsymbol{\gamma}$, and scale $S$: 
-    
-    $$\begin{aligned}
-        K(\boldsymbol{x},\boldsymbol{z}) &= S \prod_{j=1}^d \left(1+ \gamma_j \tilde{K}_{\alpha_j}(x_j \oplus z_j)\right), \qquad\mathrm{where} \\
-        \tilde{K}_1(x) &= 6 \left(\frac{1}{6} - 2^{\lfloor \log_2(x) \rfloor -1}\right), \\
-        \tilde{K}_2(x) &= \sum_{k \in \mathbb{N}} \frac{\mathrm{wal}_k(x)}{2^{\mu_2(k)}} = -\beta(x) x + \frac{5}{2}\left[1-t_1(x)\right]-1, \\
-        \tilde{K}_3(x) &= \sum_{k \in \mathbb{N}} \frac{\mathrm{wal}_k(x)}{2^{\mu_3(k)}} = \beta(x)x^2-5\left[1-t_1(x)\right]x+\frac{43}{18}\left[1-t_2(x)\right]-1, \\
-        \tilde{K}_4(x) &= \sum_{k \in \mathbb{N}} \frac{\mathrm{wal}_k(x)}{2^{\mu_4(k)}} = - \frac{2}{3}\beta(x)x^3+5\left[1-t_1(x)\right]x^2 - \frac{43}{9}\left[1-t_2(x)\right]x +\frac{701}{294}\left[1-t_3(x)\right]+\beta(x)\left[\frac{1}{48}\sum_{a=0}^\infty \frac{\mathrm{wal}_{2^a}(x)}{2^{3a}} - \frac{1}{42}\right] - 1.
+    r"""Digitally shift invariant kernel in base $b=2$ with smoothness
+    $\boldsymbol{\alpha}$, product weights $\boldsymbol{\gamma}$, and scale
+    $S$:
+
+    $$\begin{aligned} K(\boldsymbol{x},\boldsymbol{z}) &= S \prod_{j=1}^d
+    \left(1+ \gamma_j \tilde{K}_{\alpha_j}(x_j \oplus z_j)\right),
+    \qquad\mathrm{where} \\ \tilde{K}_1(x) &= 6 \left(\frac{1}{6} - 2^{\lfloor
+    \log_2(x) \rfloor -1}\right), \\ \tilde{K}_2(x) &= \sum_{k \in \mathbb{N}}
+    \frac{\mathrm{wal}_k(x)}{2^{\mu_2(k)}} = -\beta(x) x +
+    \frac{5}{2}\left[1-t_1(x)\right]-1, \\ \tilde{K}_3(x) &= \sum_{k \in
+    \mathbb{N}} \frac{\mathrm{wal}_k(x)}{2^{\mu_3(k)}} =
+    \beta(x)x^2-5\left[1-t_1(x)\right]x+\frac{43}{18}\left[1-t_2(x)\right]-1,
+    \\ \tilde{K}_4(x) &= \sum_{k \in \mathbb{N}}
+    \frac{\mathrm{wal}_k(x)}{2^{\mu_4(k)}} = -
+    \frac{2}{3}\beta(x)x^3+5\left[1-t_1(x)\right]x^2 -
+    \frac{43}{9}\left[1-t_2(x)\right]x
+    +\frac{701}{294}\left[1-t_3(x)\right]+\beta(x)\left[\frac{1}{48}\sum_{a=0}^\infty
+    \frac{\mathrm{wal}_{2^a}(x)}{2^{3a}} - \frac{1}{42}\right] - 1.
     \end{aligned}$$
 
-    where 
-    
-    - $x \oplus z$ is XOR between bits, 
-    - $\mathrm{wal}_k$ is the $k^\text{th}$ Walsh function, 
-    - $\beta(x) = - \lfloor \log_2(x) \rfloor$ and $t_\nu(x) = 2^{-\nu \beta(x)}$ where $\beta(0)=t_\nu(0) = 0$, and 
-    - and $\mu_\alpha$ is the Dick weight function which sums the first $\alpha$ largest indices of $1$ bits in the binary expansion of $k$ 
-    e.g. $k=13=1101_2$ has 1-bit indexes $(4,3,1)$ so 
-    
-    $$\mu_1(k) = 4, \mu_2(k) = 4+3, \mu_3(k) = 4+3+1 = \mu_4(k) = \mu_5(k) = \dots.$$
+    where
+
+    - $x \oplus z$ is XOR between bits,
+    - $\mathrm{wal}_k$ is the $k^\text{th}$ Walsh function,
+    - $\beta(x) = - \lfloor \log_2(x) \rfloor$ and $t_\nu(x) = 2^{-\nu \beta(x)}$ where $\beta(0)=t_\nu(0) = 0$, and
+    - and $\mu_\alpha$ is the Dick weight function which sums the first $\alpha$ largest indices of $1$ bits in the binary expansion of $k$
+    e.g. $k=13=1101_2$ has 1-bit indexes $(4,3,1)$ so
+
+    $$\mu_1(k) = 4, \mu_2(k) = 4+3, \mu_3(k) = 4+3+1 = \mu_4(k) = \mu_5(k) =
+    \dots.$$
 
     Examples:
         >>> from qmcpy import DigitalNetB2, fwht
@@ -661,7 +707,7 @@ class KernelDigShiftInvar(AbstractSIDSIKernel):
         >>> x.dtype
         dtype('uint64')
         >>> kernel = KernelDigShiftInvar(
-        ...     d = d, 
+        ...     d = d,
         ...     t = dnb2.t,
         ...     alpha = list(range(1,d+1)),
         ...     scale = 10,
@@ -692,10 +738,10 @@ class KernelDigShiftInvar(AbstractSIDSIKernel):
         True
         >>> np.allclose(fwht(fwht(y)/lam),np.linalg.solve(kmat,y))
         True
-        >>> import torch 
+        >>> import torch
         >>> xtorch = bin_from_numpy_to_torch(x)
         >>> kernel_torch = KernelDigShiftInvar(
-        ...     d = d, 
+        ...     d = d,
         ...     t = dnb2.t,
         ...     alpha = list(range(1,d+1)),
         ...     scale = 10,
@@ -719,16 +765,16 @@ class KernelDigShiftInvar(AbstractSIDSIKernel):
         >>> kernel_torch.single_integral_01d(xtorch)
         tensor([10., 10., 10., 10., 10., 10., 10., 10.], grad_fn=<AddBackward0>)
 
-        Batch Params 
-        
+        Batch Params
+
         >>> rng = np.random.Generator(np.random.PCG64(7))
         >>> kernel = KernelDigShiftInvar(
-        ...     d = 2, 
+        ...     d = 2,
         ...     t = 10,
         ...     shape_scale = [4,3,1],
         ...     shape_lengthscales = [3,2])
         >>> x = rng.uniform(low=0,high=1,size=(6,5,2))
-        >>> kernel(x,x).shape 
+        >>> kernel(x,x).shape
         (4, 3, 6, 5)
         >>> kernel(x[:,:,None,:],x[:,None,:,:]).shape
         (4, 3, 6, 5, 5)
@@ -739,26 +785,26 @@ class KernelDigShiftInvar(AbstractSIDSIKernel):
         >>> np.abs(kfast-kstable).max()
         np.float64(4.440892098500626e-16)
 
-    **References:**
-        
-    1.  Dick, Josef.  
-        "Walsh spaces containing smooth functions and quasi-Monte Carlo rules of arbitrary high order."  
+    **References: **
+
+    1.  Dick, Josef.
+        "Walsh spaces containing smooth functions and quasi-Monte Carlo rules of arbitrary high order."
         SIAM Journal on Numerical Analysis 46.3 (2008): 1519-1553.
 
-    2.  Dick, Josef.  
-        "The decay of the Walsh coefficients of smooth functions."  
-        Bulletin of the Australian Mathematical Society 80.3 (2009): 430-453.  
+    2.  Dick, Josef.
+        "The decay of the Walsh coefficients of smooth functions."
+        Bulletin of the Australian Mathematical Society 80.3 (2009): 430-453.
 
-    3.  Jagadeeswaran, Rathinavel, and Fred J. Hickernell.  
-        "Fast automatic Bayesian cubature using Sobol' sampling."  
+    3.  Jagadeeswaran, Rathinavel, and Fred J. Hickernell.
+        "Fast automatic Bayesian cubature using Sobol' sampling."
         Advances in Modeling and Simulation: Festschrift for Pierre L'Ecuyer. Cham: Springer International Publishing, 2022. 301-318.
 
-    4.  Rathinavel, Jagadeeswaran.  
-        Fast automatic Bayesian cubature using matching kernels and designs.  
+    4.  Rathinavel, Jagadeeswaran.
+        Fast automatic Bayesian cubature using matching kernels and designs.
         Illinois Institute of Technology, 2019.
-    
-    5.  Sorokin, Aleksei.  
-        "A Unified Implementation of Quasi-Monte Carlo Generators, Randomization Routines, and Fast Kernel Methods."  
+
+    5.  Sorokin, Aleksei.
+        "A Unified Implementation of Quasi-Monte Carlo Generators, Randomization Routines, and Fast Kernel Methods."
         arXiv preprint arXiv:2502.14256 (2025).
     """
 
@@ -787,24 +833,42 @@ def __init__(
         r"""
         Args:
             d (int): Dimension.
-            t (int): number of bits in binary represtnations. Typically `dnb2.t` where `isinstance(dnb2,DigitalNetB2)`.
+            t (int): number of bits in binary represtnations. Typically
+                `dnb2.t` where `isinstance(dnb2,DigitalNetB2)`.
             scale (Union[np.ndarray, torch.Tensor]): Scaling factor $S$.
-            lengthscales (Union[np.ndarray, torch.Tensor]): Product weights $(\gamma_1,\dots,\gamma_d)$.
-            alpha (Union[np.ndarray, torch.Tensor]): Smoothness parameters $(\alpha_1,\dots,\alpha_d)$ where $\alpha_j \geq 1$ for $j=1,\dots,d$.
+            lengthscales (Union[np.ndarray, torch.Tensor]): Product weights
+                $(\gamma_1,\dots,\gamma_d)$.
+            alpha (Union[np.ndarray, torch.Tensor]): Smoothness parameters
+                $(\alpha_1,\dots,\alpha_d)$ where $\alpha_j \geq 1$ for
+                $j=1,\dots,d$.
             shape_scale (list): Shape of `scale` when `np.isscalar(scale)`.
-            shape_lengthscales (list): Shape of `lengthscales` when `np.isscalar(lengthscales)`
-            tfs_scale (Tuple[callable,callable]): The first argument transforms to the raw value to be optimized; the second applies the inverse transform.
-            tfs_lengthscales (Tuple[callable,callable]): The first argument transforms to the raw value to be optimized; the second applies the inverse transform.
-            torchify (bool): If `True`, use the `torch` backend. Set to `True` if computing gradients with respect to inputs and/or hyperparameters.
-            requires_grad_scale (bool): If `True` and `torchify`, set `requires_grad=True` for `scale`.
-            requires_grad_lengthscales (bool): If `True` and `torchify`, set `requires_grad=True` for `lengthscales`.
+            shape_lengthscales (list): Shape of `lengthscales` when
+                `np.isscalar(lengthscales)`
+            tfs_scale (Tuple[callable,callable]): The first argument transforms
+                to the raw value to be optimized; the second applies the
+                inverse transform.
+            tfs_lengthscales (Tuple[callable,callable]): The first argument
+                transforms to the raw value to be optimized; the second applies
+                the inverse transform.
+            torchify (bool): If `True`, use the `torch` backend. Set to `True`
+                if computing gradients with respect to inputs and/or
+                hyperparameters.
+            requires_grad_scale (bool): If `True` and `torchify`, set
+                `requires_grad=True` for `scale`.
+            requires_grad_lengthscales (bool): If `True` and `torchify`, set
+                `requires_grad=True` for `lengthscales`.
             device (torch.device): If `torchify`, put things onto this device.
-            compile_call (bool): If `True`, `torch.compile` the `parsed___call__` method.
-            compile_call_kwargs (dict): When `compile_call` is `True`, pass these keyword arguments to `torch.compile`.
-            weights (Union[np.ndarray, torch.Tensor]): Alias for `lengthscales`.
+            compile_call (bool): If `True`, `torch.compile` the
+                `parsed___call__` method.
+            compile_call_kwargs (dict): When `compile_call` is `True`, pass
+                these keyword arguments to `torch.compile`.
+            weights (Union[np.ndarray, torch.Tensor]): Alias for
+                `lengthscales`.
             shape_weights (list): Alias for `shape_lengthscales`.
-            tfs_weights (Tuple[callable,callable]): Alias for `tfs_lengthscales`.
-            requires_grad_weights (bool): Alias for `requires_grad_lengthscales`.
+            tfs_weights (Tuple[callable,callable]): Alias for
+                `tfs_lengthscales`.
+            requires_grad_weights (bool): Alias for
+                `requires_grad_lengthscales`.
         """
         if shape_scale is None:
             shape_scale = [1]
@@ -899,24 +963,28 @@ def get_per_dim_components(self, x0, x1, beta0, beta1):
 
 
 class KernelDigShiftInvarAdaptiveAlpha(AbstractSIDSIKernel):
-    r""" 
-    Digitally shift invariant kernel in base $b=2$ with 
-    smoothness $\boldsymbol{\alpha} \geq \boldsymbol{0}$, product weights $\boldsymbol{\gamma}$, and scale $S$: 
-    
-    $$\begin{aligned}
-        K(\boldsymbol{x},\boldsymbol{z}) &= S \prod_{j=1}^d \left(1+ \gamma_j \tilde{K}_{\alpha_j}(x_j \oplus z_j)\right), \qquad\mathrm{where} \\
-        \tilde{K}_\alpha(x) &= \sum_{k \in \mathbb{N}} \frac{\mathrm{wal}_k(x)}{2^{{\alpha+1} (\mu_1(k)-1)}} = \frac{2^{\alpha+1}}{2^{\alpha+1}-2} - \left(\frac{2^{\alpha+1}}{2^{\alpha+1}-2}+1\right) 2^{\alpha(\lfloor \log_2(x) \rfloor+1)}, \\
-    \end{aligned}$$
+    r"""Digitally shift invariant kernel in base $b=2$ with smoothness
+    $\boldsymbol{\alpha} \geq \boldsymbol{0}$, product weights
+    $\boldsymbol{\gamma}$, and scale $S$:
+
+    $$\begin{aligned} K(\boldsymbol{x},\boldsymbol{z}) &= S \prod_{j=1}^d
+    \left(1+ \gamma_j \tilde{K}_{\alpha_j}(x_j \oplus z_j)\right),
+    \qquad\mathrm{where} \\ \tilde{K}_\alpha(x) &= \sum_{k \in \mathbb{N}}
+    \frac{\mathrm{wal}_k(x)}{2^{{\alpha+1} (\mu_1(k)-1)}} =
+    \frac{2^{\alpha+1}}{2^{\alpha+1}-2} -
+    \left(\frac{2^{\alpha+1}}{2^{\alpha+1}-2}+1\right) 2^{\alpha(\lfloor
+    \log_2(x) \rfloor+1)}, \\ \end{aligned}$$
+
+    where
+
+    - $x \oplus z$ is XOR between bits,
+    - $\mathrm{wal}_k$ is the $k^\text{th}$ Walsh function,
+    - $\beta(x) = - \lfloor \log_2(x) \rfloor$ and $t_\nu(x) = 2^{-\nu \beta(x)}$ where $\beta(0)=t_\nu(0) = 0$, and
+    - and $\mu_\alpha$ is the Dick weight function which sums the first $\alpha$ largest indices of $1$ bits in the binary expansion of $k$
+    e.g. $k=13=1101_2$ has 1-bit indexes $(4,3,1)$ so
 
-    where 
-    
-    - $x \oplus z$ is XOR between bits, 
-    - $\mathrm{wal}_k$ is the $k^\text{th}$ Walsh function, 
-    - $\beta(x) = - \lfloor \log_2(x) \rfloor$ and $t_\nu(x) = 2^{-\nu \beta(x)}$ where $\beta(0)=t_\nu(0) = 0$, and 
-    - and $\mu_\alpha$ is the Dick weight function which sums the first $\alpha$ largest indices of $1$ bits in the binary expansion of $k$ 
-    e.g. $k=13=1101_2$ has 1-bit indexes $(4,3,1)$ so 
-    
-    $$\mu_1(k) = 4, \mu_2(k) = 4+3, \mu_3(k) = 4+3+1 = \mu_4(k) = \mu_5(k) = \dots.$$
+    $$\mu_1(k) = 4, \mu_2(k) = 4+3, \mu_3(k) = 4+3+1 = \mu_4(k) = \mu_5(k) =
+    \dots.$$
 
     Examples:
         >>> from qmcpy import DigitalNetB2, fwht
@@ -929,7 +997,7 @@ class KernelDigShiftInvarAdaptiveAlpha(AbstractSIDSIKernel):
         >>> x.dtype
         dtype('uint64')
         >>> kernel = KernelDigShiftInvarAdaptiveAlpha(
-        ...     d = d, 
+        ...     d = d,
         ...     t = dnb2.t,
         ...     alpha = list(range(1,d+1)),
         ...     scale = 10,
@@ -960,10 +1028,10 @@ class KernelDigShiftInvarAdaptiveAlpha(AbstractSIDSIKernel):
         True
         >>> np.allclose(fwht(fwht(y)/lam),np.linalg.solve(kmat,y))
         True
-        >>> import torch 
+        >>> import torch
         >>> xtorch = bin_from_numpy_to_torch(x)
         >>> kernel_torch = KernelDigShiftInvarAdaptiveAlpha(
-        ...     d = d, 
+        ...     d = d,
         ...     t = dnb2.t,
         ...     alpha = list(range(1,d+1)),
         ...     scale = 10,
@@ -987,16 +1055,16 @@ class KernelDigShiftInvarAdaptiveAlpha(AbstractSIDSIKernel):
         >>> kernel_torch.single_integral_01d(xtorch)
         tensor([10., 10., 10., 10., 10., 10., 10., 10.], grad_fn=<AddBackward0>)
 
-        Batch Params 
-        
+        Batch Params
+
         >>> rng = np.random.Generator(np.random.PCG64(7))
         >>> kernel = KernelDigShiftInvarAdaptiveAlpha(
-        ...     d = 2, 
+        ...     d = 2,
         ...     t = 10,
         ...     shape_scale = [4,3,1],
         ...     shape_lengthscales = [3,2])
         >>> x = rng.uniform(low=0,high=1,size=(6,5,2))
-        >>> kernel(x,x).shape 
+        >>> kernel(x,x).shape
         (4, 3, 6, 5)
         >>> kernel(x[:,:,None,:],x[:,None,:,:]).shape
         (4, 3, 6, 5, 5)
@@ -1007,10 +1075,10 @@ class KernelDigShiftInvarAdaptiveAlpha(AbstractSIDSIKernel):
         >>> np.abs(kfast-kstable).max()
         np.float64(4.440892098500626e-16)
 
-    **References:**
-        
-    3.  Dick, Josef, and Friedrich Pillichshammer.  
-        "Multivariate integration in weighted Hilbert spaces based on Walsh functions and weighted Sobolev spaces."  
+    **References: **
+
+    3.  Dick, Josef, and Friedrich Pillichshammer.
+        "Multivariate integration in weighted Hilbert spaces based on Walsh functions and weighted Sobolev spaces."
         Journal of Complexity 21.2 (2005): 149-195.
     """
 
@@ -1042,27 +1110,48 @@ def __init__(
         r"""
         Args:
             d (int): Dimension.
-            t (int): number of bits in binary represtnations. Typically `dnb2.t` where `isinstance(dnb2,DigitalNetB2)`.
+            t (int): number of bits in binary represtnations. Typically
+                `dnb2.t` where `isinstance(dnb2,DigitalNetB2)`.
             scale (Union[np.ndarray, torch.Tensor]): Scaling factor $S$.
-            lengthscales (Union[np.ndarray, torch.Tensor]): Product weights $(\gamma_1,\dots,\gamma_d)$.
-            alpha (Union[np.ndarray, torch.Tensor]): Smoothness parameters $(\alpha_1,\dots,\alpha_d)$ where $\alpha_j \geq 1$ for $j=1,\dots,d$.
+            lengthscales (Union[np.ndarray, torch.Tensor]): Product weights
+                $(\gamma_1,\dots,\gamma_d)$.
+            alpha (Union[np.ndarray, torch.Tensor]): Smoothness parameters
+                $(\alpha_1,\dots,\alpha_d)$ where $\alpha_j \geq 1$ for
+                $j=1,\dots,d$.
             shape_alpha (list): Shape of `alpha` when `np.isscalar(alpha)`
             shape_scale (list): Shape of `scale` when `np.isscalar(scale)`.
-            shape_lengthscales (list): Shape of `lengthscales` when `np.isscalar(lengthscales)`
-            tfs_scale (Tuple[callable,callable]): The first argument transforms to the raw value to be optimized; the second applies the inverse transform.
-            tfs_lengthscales (Tuple[callable,callable]): The first argument transforms to the raw value to be optimized; the second applies the inverse transform.
-            tfs_alpha (Tuple[callable,callable]): The first argument transforms to the raw value to be optimized; the second applies the inverse transform.
-            torchify (bool): If `True`, use the `torch` backend. Set to `True` if computing gradients with respect to inputs and/or hyperparameters.
-            requires_grad_scale (bool): If `True` and `torchify`, set `requires_grad=True` for `scale`.
-            requires_grad_lengthscales (bool): If `True` and `torchify`, set `requires_grad=True` for `lengthscales`.
-            requires_grad_alpha (bool): If `True` and `torchify`, set `requires_grad=True` for `alpha`.
+            shape_lengthscales (list): Shape of `lengthscales` when
+                `np.isscalar(lengthscales)`
+            tfs_scale (Tuple[callable,callable]): The first argument transforms
+                to the raw value to be optimized; the second applies the
+                inverse transform.
+            tfs_lengthscales (Tuple[callable,callable]): The first argument
+                transforms to the raw value to be optimized; the second applies
+                the inverse transform.
+            tfs_alpha (Tuple[callable,callable]): The first argument transforms
+                to the raw value to be optimized; the second applies the
+                inverse transform.
+            torchify (bool): If `True`, use the `torch` backend. Set to `True`
+                if computing gradients with respect to inputs and/or
+                hyperparameters.
+            requires_grad_scale (bool): If `True` and `torchify`, set
+                `requires_grad=True` for `scale`.
+            requires_grad_lengthscales (bool): If `True` and `torchify`, set
+                `requires_grad=True` for `lengthscales`.
+            requires_grad_alpha (bool): If `True` and `torchify`, set
+                `requires_grad=True` for `alpha`.
             device (torch.device): If `torchify`, put things onto this device.
-            compile_call (bool): If `True`, `torch.compile` the `parsed___call__` method.
-            compile_call_kwargs (dict): When `compile_call` is `True`, pass these keyword arguments to `torch.compile`.
-            weights (Union[np.ndarray, torch.Tensor]): Alias for `lengthscales`.
+            compile_call (bool): If `True`, `torch.compile` the
+                `parsed___call__` method.
+            compile_call_kwargs (dict): When `compile_call` is `True`, pass
+                these keyword arguments to `torch.compile`.
+            weights (Union[np.ndarray, torch.Tensor]): Alias for
+                `lengthscales`.
             shape_weights (list): Alias for `shape_lengthscales`.
-            tfs_weights (Tuple[callable,callable]): Alias for `tfs_lengthscales`.
-            requires_grad_weights (bool): Alias for `requires_grad_lengthscales`.
+            tfs_weights (Tuple[callable,callable]): Alias for
+                `tfs_lengthscales`.
+            requires_grad_weights (bool): Alias for
+                `requires_grad_lengthscales`.
         """
         if shape_scale is None:
             shape_scale = [1]
@@ -1143,15 +1232,17 @@ def combine_per_dim_components_raw_m1(
 
 
 class KernelDigShiftInvarCombined(AbstractSIDSIKernel):
-    r"""
-    Digitally shift invariant kernel in base $b=2$ with
-    combination weights $\boldsymbol{\alpha}_1,\dots,\boldsymbol{\alpha}_d \in \mathbb{R}_{>0}^4$, smoothness $\boldsymbol{\alpha}$, product weights $\boldsymbol{\gamma}$, and scale $S$:
+    r"""Digitally shift invariant kernel in base $b=2$ with combination
+    weights $\boldsymbol{\alpha}_1,\dots,\boldsymbol{\alpha}_d \in
+    \mathbb{R}_{>0}^4$, smoothness $\boldsymbol{\alpha}$, product weights
+    $\boldsymbol{\gamma}$, and scale $S$:
 
-    $$\begin{aligned}
-        K(\boldsymbol{x},\boldsymbol{z}) &= S \prod_{j=1}^d \left(1+ \gamma_j \left(\sum_{p=1}^4 \alpha_{jp} \tilde{K}_p(x_j \oplus z_j)\right)\right)
-    \end{aligned}$$
+    $$\begin{aligned} K(\boldsymbol{x},\boldsymbol{z}) &= S \prod_{j=1}^d
+    \left(1+ \gamma_j \left(\sum_{p=1}^4 \alpha_{jp} \tilde{K}_p(x_j \oplus
+    z_j)\right)\right) \end{aligned}$$
 
-    where, $\oplus$ is defined in the docs for `KernelDigShiftInvar` and so are $\tilde{K}_p$ for $p \in \{1,2,3,4\}$
+    where, $\oplus$ is defined in the docs for `KernelDigShiftInvar` and so are
+    $\tilde{K}_p$ for $p \in \{1,2,3,4\}$
 
     Examples:
         >>> from qmcpy import DigitalNetB2, fwht
@@ -1269,26 +1360,45 @@ def __init__(
         r"""
         Args:
             d (int): Dimension.
-            t (int): number of bits in binary represtnations. Typically `dnb2.t` where `isinstance(dnb2,DigitalNetB2)`.
+            t (int): number of bits in binary represtnations. Typically
+                `dnb2.t` where `isinstance(dnb2,DigitalNetB2)`.
             scale (Union[np.ndarray, torch.Tensor]): Scaling factor $S$.
-            lengthscales (Union[np.ndarray, torch.Tensor]): Product weights $(\gamma_1,\dots,\gamma_d)$.
-            alpha (Union[np.ndarray, torch.Tensor]): Weights $\boldsymbol{\alpha}_1,\dots,\boldsymbol{\alpha}_d \in \mathbb{R}_{>0}^4$.
+            lengthscales (Union[np.ndarray, torch.Tensor]): Product weights
+                $(\gamma_1,\dots,\gamma_d)$.
+            alpha (Union[np.ndarray, torch.Tensor]): Weights
+                $\boldsymbol{\alpha}_1,\dots,\boldsymbol{\alpha}_d \in
+                \mathbb{R}_{>0}^4$.
             shape_scale (list): Shape of `scale` when `np.isscalar(scale)`.
-            shape_lengthscales (list): Shape of `lengthscales` when `np.isscalar(lengthscales)`
+            shape_lengthscales (list): Shape of `lengthscales` when
+                `np.isscalar(lengthscales)`
             shape_alpha (list): Shape of `alpha` when `np.isscalar(alpha)`
-            tfs_scale (Tuple[callable,callable]): The first argument transforms to the raw value to be optimized; the second applies the inverse transform.
-            tfs_lengthscales (Tuple[callable,callable]): The first argument transforms to the raw value to be optimized; the second applies the inverse transform.
-            torchify (bool): If `True`, use the `torch` backend. Set to `True` if computing gradients with respect to inputs and/or hyperparameters.
-            requires_grad_scale (bool): If `True` and `torchify`, set `requires_grad=True` for `scale`.
-            requires_grad_lengthscales (bool): If `True` and `torchify`, set `requires_grad=True` for `lengthscales`.
-            requires_grad_alpha (bool): If `True` and `torchify`, set `requires_grad=True` for `alpha`.
+            tfs_scale (Tuple[callable,callable]): The first argument transforms
+                to the raw value to be optimized; the second applies the
+                inverse transform.
+            tfs_lengthscales (Tuple[callable,callable]): The first argument
+                transforms to the raw value to be optimized; the second applies
+                the inverse transform.
+            torchify (bool): If `True`, use the `torch` backend. Set to `True`
+                if computing gradients with respect to inputs and/or
+                hyperparameters.
+            requires_grad_scale (bool): If `True` and `torchify`, set
+                `requires_grad=True` for `scale`.
+            requires_grad_lengthscales (bool): If `True` and `torchify`, set
+                `requires_grad=True` for `lengthscales`.
+            requires_grad_alpha (bool): If `True` and `torchify`, set
+                `requires_grad=True` for `alpha`.
             device (torch.device): If `torchify`, put things onto this device.
-            compile_call (bool): If `True`, `torch.compile` the `parsed___call__` method.
-            compile_call_kwargs (dict): When `compile_call` is `True`, pass these keyword arguments to `torch.compile`.
-            weights (Union[np.ndarray, torch.Tensor]): Alias for `lengthscales`.
+            compile_call (bool): If `True`, `torch.compile` the
+                `parsed___call__` method.
+            compile_call_kwargs (dict): When `compile_call` is `True`, pass
+                these keyword arguments to `torch.compile`.
+            weights (Union[np.ndarray, torch.Tensor]): Alias for
+                `lengthscales`.
             shape_weights (list): Alias for `shape_lengthscales`.
-            tfs_weights (Tuple[callable,callable]): Alias for `tfs_lengthscales`.
-            requires_grad_weights (bool): Alias for `requires_grad_lengthscales`.
+            tfs_weights (Tuple[callable,callable]): Alias for
+                `tfs_lengthscales`.
+            requires_grad_weights (bool): Alias for
+                `requires_grad_lengthscales`.
         """
         if shape_scale is None:
             shape_scale = [1]
diff --git a/qmcpy/stopping_criterion/abstract_cub_mlmc.py b/qmcpy/stopping_criterion/abstract_cub_mlmc.py
index a80db3092..8946d6833 100644
--- a/qmcpy/stopping_criterion/abstract_cub_mlmc.py
+++ b/qmcpy/stopping_criterion/abstract_cub_mlmc.py
@@ -9,7 +9,9 @@ class AbstractCubMLMC(AbstractStoppingCriterion):
 
     @staticmethod
     def _append_level_diff_samples(data, level, dp):
-        """Append raw level-difference samples when checkpoint caching is enabled."""
+        """Append raw level-difference samples when checkpoint caching is
+        enabled.
+        """
         if not hasattr(data, "level_diffs"):
             return
         while len(data.level_diffs) <= level:
@@ -126,7 +128,7 @@ def _construct_data(self):
         """Build a fresh Data object for a new MLMC integration run.
 
         Returns:
-            Data: Initialised with zero sample counts and warm-up allocation.
+            Initialised with zero sample counts and warm-up allocation.
         """
         data = Data(
             parameters=[
@@ -179,10 +181,12 @@ def _validate_level_diffs(data):
                 )
 
     def _update_replay_data(self, data):
-        """Replay cached level-difference samples, falling back to fresh draws.
+        """Replay cached level-difference samples, falling back to fresh
+        draws.
 
         Used during exact-resume replay to reconstruct the integration state by
-        consuming previously stored per-level samples before generating new ones.
+        consuming previously stored per-level samples before generating new
+        ones.
 
         Args:
             data (Data): Integration state carrying ``cached_level_diffs`` and
diff --git a/qmcpy/stopping_criterion/abstract_cub_mlqmc.py b/qmcpy/stopping_criterion/abstract_cub_mlqmc.py
index 9e95ed057..9e0a119c3 100644
--- a/qmcpy/stopping_criterion/abstract_cub_mlqmc.py
+++ b/qmcpy/stopping_criterion/abstract_cub_mlqmc.py
@@ -7,7 +7,8 @@ class AbstractCubMLQMC(AbstractStoppingCriterion):
 
     @staticmethod
     def _append_level_replication_sums(data, level, rep_sums, n_increment):
-        """Append replayable per-replication sums for one MLQMC level update."""
+        """Append replayable per-replication sums for one MLQMC level update.
+        """
         if (not hasattr(data, "level_rep_sums")) or (not hasattr(data, "level_n_increments")):
             return
         while len(data.level_rep_sums) <= level:
diff --git a/qmcpy/stopping_criterion/abstract_stopping_criterion.py b/qmcpy/stopping_criterion/abstract_stopping_criterion.py
index 8c1a56588..b974e13f1 100644
--- a/qmcpy/stopping_criterion/abstract_stopping_criterion.py
+++ b/qmcpy/stopping_criterion/abstract_stopping_criterion.py
@@ -72,8 +72,8 @@ def integrate(self, resume=None) -> tuple:
         """Determine the samples needed to satisfy the target tolerance.
 
         Args:
-            resume (Data, optional): Existing integration state to resume from,
-                if supported. A valid resume checkpoint must continue the same
+            resume (Data): Existing integration state to resume from, if
+                supported. A valid resume checkpoint must continue the same
                 numerical experiment without duplicating samples, losing
                 accumulated statistics, or weakening the requested tolerance
                 guarantee. Supported resume implementations validate and copy
@@ -81,9 +81,8 @@ def integrate(self, resume=None) -> tuple:
                 object is preserved. Defaults to None.
 
         Returns:
-            tuple[Union[float, np.ndarray], Data]: Approximation to the integral
-                with shape ``integrand.d_comb`` and the corresponding data
-                object.
+            Approximation to the integral with shape ``integrand.d_comb`` and
+            the corresponding data object.
         """
         raise MethodImplementationError(self, "integrate")
 
@@ -92,7 +91,7 @@ def _make_trace_logger(self) -> _IterationTraceLogger:
 
         Returns:
             _IterationTraceLogger: Trace logger configured from the stopping
-                criterion's optional trace attributes.
+            criterion's optional trace attributes.
         """
         requested_trace_iterations = bool(getattr(self, "trace_iterations", False))
         trace_verbose = bool(getattr(self, "verbose", False))
@@ -132,11 +131,12 @@ def get_iteration_log(
         """Return the latest iteration log as a pandas DataFrame.
 
         Args:
-            history (list[dict] | None): Iteration history to format. If ``None``,
-                uses ``self.iteration_history`` when available.
+            history (list[dict] | None): Iteration history to format. If
+                ``None``, uses ``self.iteration_history`` when available.
             printed_only (bool): If ``True``, include only rows that were
                 selected for printed output.
-            drop_empty_columns (bool): If ``True``, drop columns with no values.
+            drop_empty_columns (bool): If ``True``, drop columns with no
+                values.
             formatted (bool): If ``True``, return formatted display values when
                 available.
             view (str): Which log view to return. ``"all"`` and ``"current"``
@@ -146,7 +146,7 @@ def get_iteration_log(
                 stage.
 
         Returns:
-            pandas.DataFrame: DataFrame representation of the iteration log.
+            DataFrame representation of the iteration log.
         """
         self._validate_iteration_log_view(view)
         use_cache = (
@@ -208,16 +208,16 @@ def format_iteration_log(self, history=None, printed_only=True, include_header=T
         """Return the iteration log as formatted text.
 
         Args:
-            history (IterationHistoryTable | None, optional): Iteration history
-                to format. If ``None``, uses ``self.iteration_history`` when
+            history (IterationHistoryTable | None): Iteration history to
+                format. If ``None``, uses ``self.iteration_history`` when
                 available. Defaults to None.
-            printed_only (bool, optional): If ``True``, include only rows that
-                were selected for printed output. Defaults to True.
-            include_header (bool, optional): If ``True``, include the trace
-                label header before the table. Defaults to True.
+            printed_only (bool): If ``True``, include only rows that were
+                selected for printed output. Defaults to True.
+            include_header (bool): If ``True``, include the trace label header
+                before the table. Defaults to True.
 
         Returns:
-            str: Formatted iteration log text.
+            Formatted iteration log text.
         """
         if history is None:
             history = getattr(self, "iteration_history", None)
@@ -232,18 +232,18 @@ def print_iteration_log(self, history=None, printed_only=True, include_header=Tr
         """Print the iteration log for the latest run or supplied history.
 
         Args:
-            history (IterationHistoryTable | None, optional): Iteration history
-                to print. If ``None``, uses ``self.iteration_history`` when
-                available. Defaults to None.
-            printed_only (bool, optional): If ``True``, print only rows that
-                were selected for printed output. Defaults to True.
-            include_header (bool, optional): If ``True``, include the trace
-                label header before the table. Defaults to True.
-            file (typing.TextIO | None, optional): Output stream. Defaults to
+            history (IterationHistoryTable | None): Iteration history to print.
+                If ``None``, uses ``self.iteration_history`` when available.
+                Defaults to None.
+            printed_only (bool): If ``True``, print only rows that were
+                selected for printed output. Defaults to True.
+            include_header (bool): If ``True``, include the trace label header
+                before the table. Defaults to True.
+            file (typing.TextIO | None): Output stream. Defaults to
                 ``sys.stdout`` when None.
 
         Returns:
-            None: This method writes output to ``file``.
+            This method writes output to ``file``.
         """
         if history is None:
             history = getattr(self, "iteration_history", None)
@@ -279,7 +279,9 @@ def _prepare_resume_data(self, resume, validate_resume, restore_resume):
 
     @staticmethod
     def _detach_resume_stopping_criterion_history(data):
-        """Detach copied solver-owned history caches while preserving checkpoint history."""
+        """Detach copied solver-owned history caches while preserving
+        checkpoint history.
+        """
         stopping_crit = getattr(data, "stopping_crit", None)
         if stopping_crit is None:
             return
@@ -292,7 +294,8 @@ def _restore_resume_state(self, data):
         """Optional hook for subclasses to align state before resuming.
 
         Subclasses that need to restore RNG state or rewrite checkpoint fields
-        may override this method. The default implementation contains no operation.
+        may override this method. The default implementation contains no
+        operation.
 
         Args:
             data (Data): Deep-copied resume checkpoint that will be mutated by
@@ -301,7 +304,8 @@ def _restore_resume_state(self, data):
         return None
 
     def _capture_resume_provenance(self, resume):
-        """Capture resume bookkeeping before the live ``Data`` object is mutated.
+        """Capture resume bookkeeping before the live ``Data`` object is
+        mutated.
 
         Args:
             resume (Data or None): Resume checkpoint passed to ``integrate``.
@@ -364,7 +368,7 @@ def _finalize_integration_data(self, data, elapsed, resume_provenance=None):
             data (Data): Integration state to finalize.
             elapsed (float): Wall-clock time spent in the current ``integrate``
                 call.
-            resume_provenance (dict or None, optional): Output of
+            resume_provenance (dict or None): Output of
                 :meth:`_capture_resume_provenance`. Defaults to None.
         """
         data.stopping_crit = self
@@ -389,14 +393,15 @@ def _finalize_integration_data(self, data, elapsed, resume_provenance=None):
         self._annotate_checkpoint_metadata(data)
 
     def _resume_value_equal(self, current, saved):
-        """Deep equality check tolerant of arrays, lists, dicts, and QMCPy objects.
+        """Deep equality check tolerant of arrays, lists, dicts, and QMCPy
+        objects.
 
         Args:
             current: Value from the live stopping criterion.
             saved: Value from the resume checkpoint.
 
         Returns:
-            bool: True when the two values are considered equal.
+            True when the two values are considered equal.
         """
         if self._is_sparse(current) or self._is_sparse(saved):
             if self._is_sparse(current) != self._is_sparse(saved):
@@ -442,7 +447,8 @@ def _is_sparse(value):
         return hasattr(value, "nnz") and hasattr(value, "shape")
 
     def _require_resume_attrs(self, data, attrs):
-        """Raise ParameterError if any attribute in *attrs* is absent from *data*.
+        """Raise ParameterError if any attribute in *attrs* is absent from
+        *data*.
 
         Args:
             data (Data): Resume checkpoint.
@@ -459,7 +465,8 @@ def _require_resume_attrs(self, data, attrs):
             )
 
     def _validate_resume_object(self, label, current, saved, attrs):
-        """Validate that a saved sub-object is compatible with the current one.
+        """Validate that a saved sub-object is compatible with the current
+        one.
 
         Checks type equality and then compares each attribute listed in *attrs*
         using :meth:`_resume_value_equal`.
@@ -503,8 +510,8 @@ def _validate_resume_data(self, data, required_fields=()):
 
         Args:
             data (Data): Resume checkpoint to validate.
-            required_fields (tuple[str, ...], optional): Additional attribute
-                names that must be present on *data*. Defaults to ``()``.
+            required_fields (tuple[str, ...]): Additional attribute names that
+                must be present on *data*. Defaults to ``()``.
 
         Raises:
             ParameterError: If any compatibility check fails.
@@ -539,15 +546,15 @@ def _validate_resume_data(self, data, required_fields=()):
     def _validate_resume_with_state(self, data, required_fields=(), state_fields=()):
         """Validate resume data including algorithm-specific state fields.
 
-        Calls :meth:`_validate_resume_data` and additionally checks that all
+        Calls: meth:`_validate_resume_data` and additionally checks that all
         *state_fields* are present and that ``n_total >= n_init``.
 
         Args:
             data (Data): Resume checkpoint to validate.
-            required_fields (tuple[str, ...], optional): Extra data attributes
-                required beyond the standard set. Defaults to ``()``.
-            state_fields (tuple[str, ...], optional): Algorithm-state attributes
-                that must also be present. Defaults to ``()``.
+            required_fields (tuple[str, ...]): Extra data attributes required
+                beyond the standard set. Defaults to ``()``.
+            state_fields (tuple[str, ...]): Algorithm-state attributes that
+                must also be present. Defaults to ``()``.
 
         Raises:
             ParameterError: If any compatibility check fails.
@@ -581,12 +588,12 @@ def _resolve_error_fun(error_fun):
                 callable with signature ``(sv, abs_tol, rel_tol) -> tol``.
 
         Returns:
-            tuple[callable, str or None]: The resolved callable and its canonical
-                string key (``'EITHER'`` or ``'BOTH'``), or ``None`` when the
-                input was already a callable.
+            The resolved callable and its canonical string key (``'EITHER'`` or
+            ``'BOTH'``), or ``None`` when the input was already a callable.
 
         Raises:
-            ParameterError: If a string argument is not ``'EITHER'`` or ``'BOTH'``.
+            ParameterError: If a string argument is not ``'EITHER'`` or
+                ``'BOTH'``.
         """
         _error_fun_key = None
         if isinstance(error_fun, str):
@@ -620,10 +627,10 @@ def _checkpoint_rmse_tol(data):
     def _init_control_variates(self, control_variates, control_variate_means):
         """Validate and store control variates and their means.
 
-        Sets ``self.cv``, ``self.cv_mu``, and ``self.ncv`` after validating that
-        every entry in *control_variates* is an ``AbstractIntegrand`` instance
-        that shares the same discrete distribution and ``d_indv`` as the main
-        integrand.
+        Sets ``self.cv``, ``self.cv_mu``, and ``self.ncv`` after validating
+        that every entry in *control_variates* is an ``AbstractIntegrand``
+        instance that shares the same discrete distribution and ``d_indv`` as
+        the main integrand.
 
         Args:
             control_variates (list or AbstractIntegrand): Control variate
@@ -632,7 +639,7 @@ def _init_control_variates(self, control_variates, control_variate_means):
                 variate.
 
         Returns:
-            int: Number of control variates (``self.ncv``).
+            Number of control variates (``self.ncv``).
 
         Raises:
             ParameterError: If any control variate is incompatible.
@@ -679,20 +686,21 @@ def _restore_resume_rng_state(self, data):
         )
 
     def _compute_indv_alphas(self, alphas_comb):
-        """Distribute combined confidence levels to individual integrand dimensions.
+        """Distribute combined confidence levels to individual integrand
+        dimensions.
 
         Uses the integrand dependency map to allocate the per-combined-output
         alpha budget down to each individual output dimension.
 
         Args:
-            alphas_comb (np.ndarray): Per-combined-output confidence levels with
-                shape ``integrand.d_comb``.
+            alphas_comb (np.ndarray): Per-combined-output confidence levels
+                with shape ``integrand.d_comb``.
 
         Returns:
-            tuple[np.ndarray, bool]: ``(alphas_indv, identity_dependency)``
-                where *alphas_indv* has shape ``integrand.d_indv`` and
-                *identity_dependency* is True when each combined output depends
-                on exactly its matching individual output.
+            ``(alphas_indv, identity_dependency)`` where *alphas_indv* has
+            shape ``integrand.d_indv`` and *identity_dependency* is True when
+            each combined output depends on exactly its matching individual
+            output.
         """
         alphas_indv = np.tile(1, self.integrand.d_indv)
         identity_dependency = True
diff --git a/qmcpy/stopping_criterion/cub_mc_clt.py b/qmcpy/stopping_criterion/cub_mc_clt.py
index c2e72870b..3f56229b4 100644
--- a/qmcpy/stopping_criterion/cub_mc_clt.py
+++ b/qmcpy/stopping_criterion/cub_mc_clt.py
@@ -14,8 +14,8 @@
 
 
 class CubMCCLT(AbstractStoppingCriterion):
-    r"""
-    IID Monte Carlo stopping criterion based on the Central Limit Theorem in a two step method.
+    r"""IID Monte Carlo stopping criterion based on the Central Limit Theorem
+    in a two step method.
 
     Examples:
         >>> ao = FinancialOption(IIDStdUniform(52,seed=7))
@@ -144,9 +144,11 @@ def __init__(
             rel_tol (np.ndarray): Relative error tolerance.
             n_init (int): Initial number of samples.
             n_limit (int): Maximum number of samples.
-            inflate (float): Inflation factor $\geq 1$ to multiply by the variance estimate to make it more conservative.
+            inflate (float): Inflation factor $\geq 1$ to multiply by the
+                variance estimate to make it more conservative.
             alpha (np.ndarray): Uncertainty level in $(0,1)$.
-            control_variates (list): Integrands to use as control variates, each with the same underlying discrete distribution instance.
+            control_variates (list): Integrands to use as control variates,
+                each with the same underlying discrete distribution instance.
             control_variate_means (np.ndarray): Means of each control variate.
         """
         if control_variates is None:
diff --git a/qmcpy/stopping_criterion/cub_mc_clt_vec.py b/qmcpy/stopping_criterion/cub_mc_clt_vec.py
index 66ecebf6e..9a7964dab 100644
--- a/qmcpy/stopping_criterion/cub_mc_clt_vec.py
+++ b/qmcpy/stopping_criterion/cub_mc_clt_vec.py
@@ -14,8 +14,8 @@
 
 
 class CubMCCLTVec(AbstractStoppingCriterion):
-    r"""
-    IID Monte Carlo stopping criterion stopping criterion based on the Central Limit Theorem with doubling sample sizes.
+    r"""IID Monte Carlo stopping criterion stopping criterion based on the
+    Central Limit Theorem with doubling sample sizes.
 
     Examples:
         >>> k = Keister(IIDStdUniform(seed=7))
@@ -175,7 +175,9 @@ def __init__(
             rel_tol (np.ndarray): Relative error tolerance.
             n_init (int): Initial number of samples.
             n_limit (int): Maximum number of samples.
-            error_fun (Union[str, callable]): Function mapping the approximate solution, absolute error tolerance, and relative error tolerance to the current error bound.
+            error_fun (Union[str, callable]): Function mapping the approximate
+                solution, absolute error tolerance, and relative error
+                tolerance to the current error bound.
 
                 - `'EITHER'`, the default, requires the approximation error must be below either the absolue *or* relative tolerance.
                     Equivalent to setting
@@ -187,7 +189,8 @@ def __init__(
                     ```python
                     error_fun = lambda sv,abs_tol,rel_tol: np.minimum(abs_tol,abs(sv)*rel_tol)
                     ```
-            inflate (float): Inflation factor $\geq 1$ to multiply by the variance estimate to make it more conservative.
+            inflate (float): Inflation factor $\geq 1$ to multiply by the
+                variance estimate to make it more conservative.
             alpha (np.ndarray): Uncertainty level in $(0,1)$.
         """
         self.parameters = [
diff --git a/qmcpy/stopping_criterion/cub_mc_g.py b/qmcpy/stopping_criterion/cub_mc_g.py
index 99d151f45..77a55300e 100644
--- a/qmcpy/stopping_criterion/cub_mc_g.py
+++ b/qmcpy/stopping_criterion/cub_mc_g.py
@@ -15,8 +15,8 @@
 
 
 class CubMCG(AbstractStoppingCriterion):
-    r"""
-    IID Monte Carlo stopping criterion using Berry-Esseen inequalities in a two step method with guarantees for functions with bounded kurtosis.
+    r"""IID Monte Carlo stopping criterion using Berry-Esseen inequalities in
+    a two step method with guarantees for functions with bounded kurtosis.
 
     Examples:
         >>> ao = FinancialOption(IIDStdUniform(52,seed=7))
@@ -237,7 +237,7 @@ class CubMCG(AbstractStoppingCriterion):
             replications    1
             entropy         7
 
-    **References:**
+    **References: **
 
     1.  Fred J. Hickernell, Lan Jiang, Yuewei Liu, and Art B. Owen,
         "Guaranteed conservative fixed width confidence intervals via Monte Carlo sampling,"
@@ -270,9 +270,11 @@ def __init__(
             rel_tol (np.ndarray): Relative error tolerance.
             n_init (int): Initial number of samples.
             n_limit (int): Maximum number of samples.
-            inflate (float): Inflation factor $\geq 1$ to multiply by the variance estimate to make it more conservative.
+            inflate (float): Inflation factor $\geq 1$ to multiply by the
+                variance estimate to make it more conservative.
             alpha (np.ndarray): Uncertainty level in $(0,1)$.
-            control_variates (list): Integrands to use as control variates, each with the same underlying discrete distribution instance.
+            control_variates (list): Integrands to use as control variates,
+                each with the same underlying discrete distribution instance.
             control_variate_means (np.ndarray): Means of each control variate.
         """
         if control_variates is None:
diff --git a/qmcpy/stopping_criterion/cub_mlmc.py b/qmcpy/stopping_criterion/cub_mlmc.py
index 5fba7672f..ed43298a0 100644
--- a/qmcpy/stopping_criterion/cub_mlmc.py
+++ b/qmcpy/stopping_criterion/cub_mlmc.py
@@ -91,16 +91,22 @@ def __init__(
         Args:
             integrand (AbstractIntegrand): The integrand.
             abs_tol (np.ndarray): Absolute error tolerance.
-            rmse_tol (np.ndarray): Root mean squared error tolerance.
-                If supplied, then absolute tolerance and alpha are ignored in favor of the rmse tolerance.
+            rmse_tol (np.ndarray): Root mean squared error tolerance. If
+                supplied, then absolute tolerance and alpha are ignored in
+                favor of the rmse tolerance.
             n_init (int): Initial number of samples.
             n_limit (int): Maximum number of samples.
             alpha (np.ndarray): Uncertainty level in $(0,1)$.
             levels_min (int): Minimum level of refinement $\geq 2$.
             levels_max (int): Maximum level of refinement $\geq$ `levels_min`.
-            alpha0 (float): Weak error is $\mathcal{O}(2^{-\alpha_0\ell})$ in the level $\ell$. If `alpha0`$\leq 0$ then it will be estimated.
-            beta0 (float): Variance is $\mathcal{O}(2^{-\beta_0\ell})$ in the level $\ell$. If `beta0`$\leq 0$ then it will be estimated.
-            gamma0 (float): Sample cost is $\mathcal{O}(2^{\gamma_0\ell})$ in the level $\ell$. If `gamma0`$\leq 0$ then it will be estimated.
+            alpha0 (float): Weak error is $\mathcal{O}(2^{-\alpha_0\ell})$ in
+                the level $\ell$. If `alpha0`$\leq 0$ then it will be
+                estimated.
+            beta0 (float): Variance is $\mathcal{O}(2^{-\beta_0\ell})$ in the
+                level $\ell$. If `beta0`$\leq 0$ then it will be estimated.
+            gamma0 (float): Sample cost is $\mathcal{O}(2^{\gamma_0\ell})$ in
+                the level $\ell$. If `gamma0`$\leq 0$ then it will be
+                estimated.
         """
         self.parameters = ["rmse_tol", "n_init", "levels_min", "levels_max", "theta"]
         if levels_min < 2:
@@ -222,7 +228,9 @@ def _run_integrate_loop(
         return snapshots
 
     def _replay_resume_exactly(self, checkpoint, t_start=None, resume_provenance=None):
-        """Replay cached per-level diffs to reconstruct checkpoint state and trace rows."""
+        """Replay cached per-level diffs to reconstruct checkpoint state and
+        trace rows.
+        """
         shadow = self._construct_data()
         shadow.level_integrands = list(checkpoint.level_integrands)
         shadow.cached_level_diffs = [
@@ -266,16 +274,16 @@ def integrate(self, resume=None) -> tuple:
         """Run (or continue) the MLMC integration.
 
         Args:
-            resume (Data, optional): Checkpoint returned by a previous
-                ``integrate()`` call.  The new tolerance may be tighter *or*
-                looser than the one used when the checkpoint was created.
-                With a tighter tolerance the algorithm draws additional samples
-                from where it left off.  With a looser tolerance the existing
-                samples already satisfy the requirement and the method returns
-                immediately with no new sampling.
+            resume (Data): Checkpoint returned by a previous ``integrate()``
+                call.  The new tolerance may be tighter *or* looser than the
+                one used when the checkpoint was created. With a tighter
+                tolerance the algorithm draws additional samples from where it
+                left off.  With a looser tolerance the existing samples already
+                satisfy the requirement and the method returns immediately with
+                no new sampling.
 
         Returns:
-            tuple: ``(solution, data)``.
+            ``(solution, data)``.
         """
         t_start = time()
         resume_provenance = self._capture_resume_provenance(resume)
diff --git a/qmcpy/stopping_criterion/cub_mlmc_cont.py b/qmcpy/stopping_criterion/cub_mlmc_cont.py
index 5f47411df..92710f3da 100644
--- a/qmcpy/stopping_criterion/cub_mlmc_cont.py
+++ b/qmcpy/stopping_criterion/cub_mlmc_cont.py
@@ -90,8 +90,9 @@ def __init__(
         Args:
             integrand (AbstractIntegrand): The integrand.
             abs_tol (np.ndarray): Absolute error tolerance.
-            rmse_tol (np.ndarray): Root mean squared error tolerance.
-                If supplied, then absolute tolerance and alpha are ignored in favor of the rmse tolerance.
+            rmse_tol (np.ndarray): Root mean squared error tolerance. If
+                supplied, then absolute tolerance and alpha are ignored in
+                favor of the rmse tolerance.
             n_init (int): Initial number of samples.
             n_limit (int): Maximum number of samples.
             inflate (float): Coarser tolerance multiplication factor $\geq 1$.
@@ -165,17 +166,17 @@ def integrate(self, resume=None) -> tuple:
         """Run (or continue) the continuation-MLMC integration.
 
         Args:
-            resume (Data, optional): Checkpoint returned by a previous
-                ``integrate()`` call.  The new tolerance may be tighter *or*
-                looser than the one used when the checkpoint was created.
-                With a tighter tolerance the algorithm picks up the tolerance
-                ladder from ``max(checkpoint_rmse_tol, target_rmse_tol)`` and
-                continues down to ``target_rmse_tol``.  With a looser tolerance
-                the first step immediately converges on the existing samples
-                and no additional ladder steps are needed.
+            resume (Data): Checkpoint returned by a previous ``integrate()``
+                call.  The new tolerance may be tighter *or* looser than the
+                one used when the checkpoint was created. With a tighter
+                tolerance the algorithm picks up the tolerance ladder from
+                ``max(checkpoint_rmse_tol, target_rmse_tol)`` and continues
+                down to ``target_rmse_tol``.  With a looser tolerance the first
+                step immediately converges on the existing samples and no
+                additional ladder steps are needed.
 
         Returns:
-            tuple: ``(solution, data)``.
+            ``(solution, data)``.
         """
         self._active_t_start = t_start = time()
         self._active_trace = trace = self._make_trace_logger()
@@ -261,8 +262,10 @@ def _update_trace_solution(data):
             ).sum()
 
     def _replay_resume_exactly(self, checkpoint, t_start=None, resume_provenance=None):
-        """Ensure iteration number in `replay_iter_count` same in LOOSE-last and RESUMED-first iterations, 
-            by simply saving `level_rep_sums` and `level_n_increments`."""
+        """Ensure iteration number in `replay_iter_count` same in LOOSE-last
+        and RESUMED-first iterations, by simply saving `level_rep_sums` and
+        `level_n_increments`.
+        """
         shadow_trace = self._active_trace = None
         try:
             shadow = self._construct_data()
diff --git a/qmcpy/stopping_criterion/cub_mlqmc.py b/qmcpy/stopping_criterion/cub_mlqmc.py
index 7df24ac15..2ccd1a089 100644
--- a/qmcpy/stopping_criterion/cub_mlqmc.py
+++ b/qmcpy/stopping_criterion/cub_mlqmc.py
@@ -91,8 +91,9 @@ def __init__(
         Args:
             integrand (AbstractIntegrand): The integrand.
             abs_tol (np.ndarray): Absolute error tolerance.
-            rmse_tol (np.ndarray): Root mean squared error tolerance.
-                If supplied, then absolute tolerance and alpha are ignored in favor of the rmse tolerance.
+            rmse_tol (np.ndarray): Root mean squared error tolerance. If
+                supplied, then absolute tolerance and alpha are ignored in
+                favor of the rmse tolerance.
             n_init (int): Initial number of samples.
             n_limit (int): Maximum number of samples.
             alpha (np.ndarray): Uncertainty level in $(0,1)$.
@@ -222,16 +223,16 @@ def integrate(self, resume=None) -> tuple:
         """Run (or continue) the MLQMC integration.
 
         Args:
-            resume (Data, optional): Checkpoint returned by a previous
-                ``integrate()`` call.  The new tolerance may be tighter *or*
-                looser than the one used when the checkpoint was created.
-                With a tighter tolerance the algorithm draws additional samples
-                from where it left off.  With a looser tolerance the existing
-                samples already satisfy the requirement and the method returns
-                immediately with no new sampling.
+            resume (Data): Checkpoint returned by a previous ``integrate()``
+                call.  The new tolerance may be tighter *or* looser than the
+                one used when the checkpoint was created. With a tighter
+                tolerance the algorithm draws additional samples from where it
+                left off.  With a looser tolerance the existing samples already
+                satisfy the requirement and the method returns immediately with
+                no new sampling.
 
         Returns:
-            tuple: ``(solution, data)``.
+            ``(solution, data)``.
         """
         t_start = time()
         resume_provenance = self._capture_resume_provenance(resume)
diff --git a/qmcpy/stopping_criterion/cub_mlqmc_cont.py b/qmcpy/stopping_criterion/cub_mlqmc_cont.py
index a6393a871..459bfda09 100644
--- a/qmcpy/stopping_criterion/cub_mlqmc_cont.py
+++ b/qmcpy/stopping_criterion/cub_mlqmc_cont.py
@@ -97,8 +97,9 @@ def __init__(
         Args:
             integrand (AbstractIntegrand): The integrand.
             abs_tol (np.ndarray): Absolute error tolerance.
-            rmse_tol (np.ndarray): Root mean squared error tolerance.
-                If supplied, then absolute tolerance and alpha are ignored in favor of the rmse tolerance.
+            rmse_tol (np.ndarray): Root mean squared error tolerance. If
+                supplied, then absolute tolerance and alpha are ignored in
+                favor of the rmse tolerance.
             n_init (int): Initial number of samples.
             n_limit (int): Maximum number of samples.
             inflate (float): Coarser tolerance multiplication factor $\geq 1$.
@@ -172,17 +173,17 @@ def integrate(self, resume=None) -> tuple:
         """Run (or continue) the continuation-MLQMC integration.
 
         Args:
-            resume (Data, optional): Checkpoint returned by a previous
-                ``integrate()`` call.  The new tolerance may be tighter *or*
-                looser than the one used when the checkpoint was created.
-                With a tighter tolerance the algorithm picks up the tolerance
-                ladder from ``max(checkpoint_rmse_tol, target_rmse_tol)`` and
-                continues down to ``target_rmse_tol``.  With a looser tolerance
-                the first step immediately converges on the existing samples
-                and no additional ladder steps are needed.
+            resume (Data): Checkpoint returned by a previous ``integrate()``
+                call.  The new tolerance may be tighter *or* looser than the
+                one used when the checkpoint was created. With a tighter
+                tolerance the algorithm picks up the tolerance ladder from
+                ``max(checkpoint_rmse_tol, target_rmse_tol)`` and continues
+                down to ``target_rmse_tol``.  With a looser tolerance the first
+                step immediately converges on the existing samples and no
+                additional ladder steps are needed.
 
         Returns:
-            tuple: ``(solution, data)``.
+            ``(solution, data)``.
         """
         self._active_t_start = t_start = time()
         self._active_trace = trace = self._make_trace_logger()
diff --git a/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py b/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py
index ff54774e8..e9d82f3ea 100644
--- a/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py
+++ b/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py
@@ -12,9 +12,9 @@
 
 
 class CubQMCBayesLatticeG(AbstractCubBayesLDG):
-    r"""
-    Quasi-Monte Carlo stopping criterion using fast Bayesian cubature and rank-1 lattices
-    with guarantees for Gaussian processes having certain shift invariant kernels.
+    r"""Quasi-Monte Carlo stopping criterion using fast Bayesian cubature and
+    rank-1 lattices with guarantees for Gaussian processes having certain shift
+    invariant kernels.
 
     Examples:
         >>> k = Keister(Lattice(2, seed=123456789))
@@ -162,7 +162,7 @@ class CubQMCBayesLatticeG(AbstractCubBayesLDG):
             n_limit         2^(20)
             entropy         7
 
-    **References:**
+    **References: **
 
     1.  Jagadeeswaran, Rathinavel, and Fred J. Hickernell.
         "Fast automatic Bayesian cubature using lattice sampling."
@@ -200,7 +200,9 @@ def __init__(
             rel_tol (np.ndarray): Relative error tolerance.
             n_init (int): Initial number of samples.
             n_limit (int): Maximum number of samples.
-            error_fun (Union[str, callable]): Function mapping the approximate solution, absolute error tolerance, and relative error tolerance to the current error bound.
+            error_fun (Union[str, callable]): Function mapping the approximate
+                solution, absolute error tolerance, and relative error
+                tolerance to the current error bound.
 
                 - `'EITHER'`, the default, requires the approximation error must be below either the absolue *or* relative tolerance.
                     Equivalent to setting
@@ -213,13 +215,15 @@ def __init__(
                     error_fun = lambda sv,abs_tol,rel_tol: np.minimum(abs_tol,abs(sv)*rel_tol)
                     ```
             alpha (np.ndarray): Uncertainty level in $(0,1)$.
-            ptransform (str): Periodization transform, see the options in `AbstractIntegrand.f`.
+            ptransform (str): Periodization transform, see the options in
+                `AbstractIntegrand.f`.
             errbd_type (str): Options are
 
                 - `'MLE'`: Marginal Log Likelihood.
                 - `'GCV'`: Generalized Cross Validation.
                 - `'FULL'`: Full Bayes.
-            order (int): Bernoulli kernel's order. If zero, choose order automatically
+            order (int): Bernoulli kernel's order. If zero, choose order
+                automatically
         """
         super(CubQMCBayesLatticeG, self).__init__(
             integrand,
diff --git a/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py b/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py
index 9aa96fa5b..335ea77b3 100644
--- a/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py
+++ b/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py
@@ -15,9 +15,9 @@
 
 
 class CubQMCBayesNetG(AbstractCubBayesLDG):
-    r"""
-    Quasi-Monte Carlo stopping criterion using fast Bayesian cubature and digital nets
-    with guarantees for Gaussian processes having certain digitally shift invariant kernels.
+    r"""Quasi-Monte Carlo stopping criterion using fast Bayesian cubature and
+    digital nets with guarantees for Gaussian processes having certain
+    digitally shift invariant kernels.
 
     Examples:
         >>> k = Keister(DigitalNetB2(2, seed=123456789))
@@ -171,7 +171,7 @@ class CubQMCBayesNetG(AbstractCubBayesLDG):
             n_limit         2^(32)
             entropy         7
 
-    **References:**
+    **References: **
 
     1.  Jagadeeswaran, Rathinavel, and Fred J. Hickernell.
         "Fast automatic Bayesian cubature using Sobol’sampling."
@@ -207,7 +207,9 @@ def __init__(
             rel_tol (np.ndarray): Relative error tolerance.
             n_init (int): Initial number of samples.
             n_limit (int): Maximum number of samples.
-            error_fun (Union[str, callable]): Function mapping the approximate solution, absolute error tolerance, and relative error tolerance to the current error bound.
+            error_fun (Union[str, callable]): Function mapping the approximate
+                solution, absolute error tolerance, and relative error
+                tolerance to the current error bound.
 
                 - `'EITHER'`, the default, requires the approximation error must be below either the absolue *or* relative tolerance.
                     Equivalent to setting
diff --git a/qmcpy/stopping_criterion/cub_qmc_lattice_g.py b/qmcpy/stopping_criterion/cub_qmc_lattice_g.py
index d888ccc3a..b50a23a60 100644
--- a/qmcpy/stopping_criterion/cub_qmc_lattice_g.py
+++ b/qmcpy/stopping_criterion/cub_qmc_lattice_g.py
@@ -10,9 +10,9 @@
 
 
 class CubQMCLatticeG(AbstractCubQMCLDG):
-    r"""
-    Quasi-Monte Carlo stopping criterion using rank-1 lattice cubature
-    with guarantees for cones of functions with a predictable decay in the Fourier coefficients.
+    r"""Quasi-Monte Carlo stopping criterion using rank-1 lattice cubature
+    with guarantees for cones of functions with a predictable decay in the
+    Fourier coefficients.
 
     Examples:
         >>> k = Keister(Lattice(seed=7))
@@ -158,7 +158,7 @@ class CubQMCLatticeG(AbstractCubQMCLDG):
             n_limit         2^(20)
             entropy         7
 
-    **References:**
+    **References: **
 
     1.  Lluis Antoni Jimenez Rugama and Fred J. Hickernell.
         "Adaptive multidimensional integration based on rank-1 lattices,"
@@ -192,7 +192,9 @@ def __init__(
             rel_tol (np.ndarray): Relative error tolerance.
             n_init (int): Initial number of samples.
             n_limit (int): Maximum number of samples.
-            error_fun (Union[str, callable]): Function mapping the approximate solution, absolute error tolerance, and relative error tolerance to the current error bound.
+            error_fun (Union[str, callable]): Function mapping the approximate
+                solution, absolute error tolerance, and relative error
+                tolerance to the current error bound.
 
                 - `'EITHER'`, the default, requires the approximation error must be below either the absolue *or* relative tolerance.
                     Equivalent to setting
@@ -204,9 +206,12 @@ def __init__(
                     ```python
                     error_fun = lambda sv,abs_tol,rel_tol: np.minimum(abs_tol,abs(sv)*rel_tol)
                     ```
-            fudge (function): Positive function multiplying the finite sum of the Fourier coefficients specified in the cone of functions.
-            check_cone (bool): Whether or not to check if the function falls in the cone.
-            ptransform (str): Periodization transform, see the options in `AbstractIntegrand.f`.
+            fudge (function): Positive function multiplying the finite sum of
+                the Fourier coefficients specified in the cone of functions.
+            check_cone (bool): Whether or not to check if the function falls in
+                the cone.
+            ptransform (str): Periodization transform, see the options in
+                `AbstractIntegrand.f`.
         """
         super(CubQMCLatticeG, self).__init__(
             integrand,
diff --git a/qmcpy/stopping_criterion/cub_qmc_net_g.py b/qmcpy/stopping_criterion/cub_qmc_net_g.py
index 6a215b0e8..50254a440 100644
--- a/qmcpy/stopping_criterion/cub_qmc_net_g.py
+++ b/qmcpy/stopping_criterion/cub_qmc_net_g.py
@@ -10,9 +10,9 @@
 
 
 class CubQMCNetG(AbstractCubQMCLDG):
-    r"""
-    Quasi-Monte Carlo stopping criterion using digital net cubature
-    with guarantees for cones of functions with a predictable decay in the Walsh coefficients.
+    r"""Quasi-Monte Carlo stopping criterion using digital net cubature with
+    guarantees for cones of functions with a predictable decay in the Walsh
+    coefficients.
 
     Examples:
         >>> k = Keister(DigitalNetB2(seed=7))
@@ -201,7 +201,7 @@ class CubQMCNetG(AbstractCubQMCLDG):
         array([16384, 16384, 16384])
         >>> assert (np.abs(true_value-solution)<abs_tol).all()
 
-    **References:**
+    **References: **
 
     1.  Hickernell, Fred J., and Lluís Antoni Jiménez Rugama.
         "Reliable adaptive cubature using digital sequences."
@@ -236,7 +236,9 @@ def __init__(
             rel_tol (np.ndarray): Relative error tolerance.
             n_init (int): Initial number of samples.
             n_limit (int): Maximum number of samples.
-            error_fun (Union[str, callable]): Function mapping the approximate solution, absolute error tolerance, and relative error tolerance to the current error bound.
+            error_fun (Union[str, callable]): Function mapping the approximate
+                solution, absolute error tolerance, and relative error
+                tolerance to the current error bound.
 
                 - `'EITHER'`, the default, requires the approximation error must be below either the absolue *or* relative tolerance.
                     Equivalent to setting
@@ -248,12 +250,16 @@ def __init__(
                     ```python
                     error_fun = lambda sv,abs_tol,rel_tol: np.minimum(abs_tol,abs(sv)*rel_tol)
                     ```
-            fudge (function): Positive function multiplying the finite sum of the Fourier coefficients specified in the cone of functions.
-            check_cone (bool): Whether or not to check if the function falls in the cone.
-            control_variates (list): Integrands to use as control variates, each with the same underlying discrete distribution instance.
+            fudge (function): Positive function multiplying the finite sum of
+                the Fourier coefficients specified in the cone of functions.
+            check_cone (bool): Whether or not to check if the function falls in
+                the cone.
+            control_variates (list): Integrands to use as control variates,
+                each with the same underlying discrete distribution instance.
             control_variate_means (np.ndarray): Means of each control variate.
-            update_cv_coeffs (bool): If set to true, the control variate coefficients are recomputed at each iteration.
-                Otherwise they are estimated once after the initial sampling and then fixed.
+            update_cv_coeffs (bool): If set to true, the control variate
+                coefficients are recomputed at each iteration. Otherwise they
+                are estimated once after the initial sampling and then fixed.
         """
         if control_variates is None:
             control_variates = []
diff --git a/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py b/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py
index 4461a5add..29e762003 100644
--- a/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py
+++ b/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py
@@ -220,7 +220,9 @@ def __init__(
             rel_tol (np.ndarray): Relative error tolerance.
             n_init (int): Initial number of samples.
             n_limit (int): Maximum number of samples.
-            error_fun (Union[str, callable]): Function mapping the approximate solution, absolute error tolerance, and relative error tolerance to the current error bound.
+            error_fun (Union[str, callable]): Function mapping the approximate
+                solution, absolute error tolerance, and relative error
+                tolerance to the current error bound.
 
                 - `'EITHER'`, the default, requires the approximation error must be below either the absolue *or* relative tolerance.
                     Equivalent to setting
@@ -232,7 +234,8 @@ def __init__(
                     ```python
                     error_fun = lambda sv,abs_tol,rel_tol: np.minimum(abs_tol,abs(sv)*rel_tol)
                     ```
-            inflate (float): Inflation factor $\geq 1$ to multiply by the variance estimate to make it more conservative.
+            inflate (float): Inflation factor $\geq 1$ to multiply by the
+                variance estimate to make it more conservative.
             alpha (np.ndarray): Uncertainty level in $(0,1)$.
         """
         self.parameters = ["inflate", "alpha", "abs_tol", "rel_tol", "n_init", "n_limit"]
diff --git a/qmcpy/stopping_criterion/diagnostics.py b/qmcpy/stopping_criterion/diagnostics.py
index c58ec5a1b..2acf4a1f3 100644
--- a/qmcpy/stopping_criterion/diagnostics.py
+++ b/qmcpy/stopping_criterion/diagnostics.py
@@ -41,7 +41,7 @@ def __init__(self):
 
     @property
     def _column_names(self):
-        """Return the ordered column names stored in the table. """
+        """Return the ordered column names stored in the table."""
         return _ITERATION_HISTORY_COLUMNS
 
     @property
@@ -86,15 +86,15 @@ def _append(self, stage, row, visible_columns=None, printed=True):
         return len(self) - 1
 
     def _mark_printed(self, index, printed=True):
-        """Update whether a stored row is marked as printed. """
+        """Update whether a stored row is marked as printed."""
         self._columns["printed"][index] = bool(printed)
 
     def _row(self, index):
-        """Return one row as a dictionary. """
+        """Return one row as a dictionary."""
         return {column: self._columns[column][index] for column in self._column_names}
 
     def _rows(self):
-        """Return all rows as dictionaries. """
+        """Return all rows as dictionaries."""
         return [self._row(index) for index in range(len(self))]
 
     def _to_dict(self):
@@ -457,8 +457,8 @@ def __init__(self, stopping_criterion):
             stopping_criterion: Stopping criterion instance. The logger reads
                 the optional attributes ``trace_iterations`` (bool),
                 ``trace_label`` (str), ``verbose`` (bool), ``trace_print``
-                (bool), and the internal ``_trace_store_*`` flags to
-                configure storage and live printing.
+                (bool), and the internal ``_trace_store_*`` flags to configure
+                storage and live printing.
         """
         requested_trace_iterations = bool(
             getattr(stopping_criterion, "trace_iterations", False)
@@ -511,7 +511,9 @@ def __init__(self, stopping_criterion):
             )
 
     def _would_be_throttled(self, iter_count):
-        """Return True if an ITER row with this count would be suppressed by throttling."""
+        """Return True if an ITER row with this count would be suppressed by
+        throttling.
+        """
         if self.verbose:
             return False
         if iter_count is None or iter_count <= _THROTTLE_ITER_THRESHOLD:
@@ -521,13 +523,14 @@ def _would_be_throttled(self, iter_count):
 
     @staticmethod
     def _state_signature(data):
-        """Return a hashable snapshot of the data fields used to detect duplicate rows.
+        """Return a hashable snapshot of the data fields used to detect
+        duplicate rows.
 
         Args:
             data (object): Integration state object.
 
         Returns:
-            tuple: ``(n_min, n_total, m, xfull.shape)``.
+            ``(n_min, n_total, m, xfull.shape)``.
         """
         xfull = getattr(data, "xfull", None)
         return (
@@ -544,7 +547,8 @@ def _print_header_once(self):
             self.header_printed = True
 
     def _get_visible_columns(self, data, row=None):
-        """Return the ordered list of column names to display, inferred from data.
+        """Return the ordered list of column names to display, inferred from
+        data.
 
         The result is cached after the first call so all rows share the same
         columns.
@@ -554,10 +558,9 @@ def _get_visible_columns(self, data, row=None):
                 optional columns are present.
 
         Returns:
-            tuple[str, ...]: Column names from the set ``{'stage', 'iter',
-                'solution', 'bound_diff', 'comb_bound_diff',
-                'bound_half_width', 'bias_estimate', 'n_min', 'n_total',
-                'm', 'xfull.shape'}``.
+            Column names from the set ``{'stage', 'iter', 'solution',
+            'bound_diff', 'comb_bound_diff', 'bound_half_width',
+            'bias_estimate', 'n_min', 'n_total', 'm', 'xfull.shape'}``.
         """
         if self.visible_columns is not None:
             return self.visible_columns
@@ -571,13 +574,13 @@ def emit(self, stage, data, step_value=None, increment=False, iter_value=None):
         Args:
             stage (str): Row label, e.g. ``"ITER"`` or ``"RESUME"``.
             data (object): Integration state object.
-            step_value (int | None, optional): Value to assign to ``data.m``
-                before printing. Defaults to None.
-            increment (bool, optional): If True, advance the internal iteration
-                counter and assign the new value to ``data._iter_count``.
-                Defaults to False.
-            iter_value (int | None, optional): Explicit iteration count to
-                display (overrides ``increment``). Defaults to None.
+            step_value (int | None): Value to assign to ``data.m`` before
+                printing. Defaults to None.
+            increment (bool): If True, advance the internal iteration counter
+                and assign the new value to ``data._iter_count``. Defaults to
+                False.
+            iter_value (int | None): Explicit iteration count to display
+                (overrides ``increment``). Defaults to None.
         """
         if not self.enabled:
             return
@@ -623,7 +626,8 @@ def emit(self, stage, data, step_value=None, increment=False, iter_value=None):
             self.table_header_printed = True
 
     def resume(self, data, step_value=None):
-        """Emit a RESUME row and snapshot the current state for duplicate suppression.
+        """Emit a RESUME row and snapshot the current state for duplicate
+        suppression.
 
         Reads ``data._iter_count`` to restore the iteration counter so that the
         next :meth:`iteration` call continues counting from the right number.
@@ -632,8 +636,8 @@ def resume(self, data, step_value=None):
 
         Args:
             data (object): Integration state object from the resume checkpoint.
-            step_value (int | None, optional): Value to assign to ``data.m``
-                before printing. Defaults to None.
+            step_value (int | None): Value to assign to ``data.m`` before
+                printing. Defaults to None.
         """
         self._seed_history_from_resume(data)
         previous_iter_count = getattr(data, "_iter_count", None)
@@ -669,14 +673,14 @@ def _seed_history_from_resume(self, data):
     def iteration(self, data, step_value=None):
         """Emit an ITER row, unless state is unchanged since the last resume.
 
-        If :meth:`resume` was just called and the data state has not changed
+        If: meth:`resume` was just called and the data state has not changed
         (same ``n_total``, ``n_min``, ``m``, and ``xfull.shape``), the row is
         suppressed to avoid a duplicate log entry.
 
         Args:
             data (object): Current integration state object.
-            step_value (int | None, optional): Value to assign to ``data.m``
-                before printing. Defaults to None.
+            step_value (int | None): Value to assign to ``data.m`` before
+                printing. Defaults to None.
         """
         current_signature = self._state_signature(data)
         if (
@@ -720,7 +724,9 @@ def _flush_last_if_suppressed(self):
         self._last_printed_iter_count = self._last_iter_count
 
     def finalize(self):
-        """Force-print the last ITER row if throttling suppressed it, then clear snapshot."""
+        """Force-print the last ITER row if throttling suppressed it, then
+        clear snapshot.
+        """
         self._flush_last_if_suppressed()
         # DataFrame is built lazily in get_iteration_log() to avoid pandas
         # construction overhead on every integrate() call when tracing is off.
@@ -748,13 +754,12 @@ def _print_diagnostic(
         label (str): Stage label shown in the first column.
         data (object): Integration state carrying fields such as ``solution``,
             ``n_total``, ``n_min``, ``m``, and ``xfull``.
-        table_header (bool, optional): Whether to print the compact table
-            header before the row. Defaults to False.
-        verbose (bool, optional): Whether to print every ``ITER`` row.
-            Defaults to True. If False, the current iteration-log throttling
-            rules are applied.
-        visible_columns (tuple[str, ...] | list[str] | None, optional): Ordered
-            columns to print. Defaults to all supported columns.
+        table_header (bool): Whether to print the compact table header before
+            the row. Defaults to False.
+        verbose (bool): Whether to print every ``ITER`` row. Defaults to True.
+            If False, the current iteration-log throttling rules are applied.
+        visible_columns (tuple[str, ...] | list[str] | None): Ordered columns
+            to print. Defaults to all supported columns.
     """
     row = _extract_diagnostic_row(data)
     iter_display = row["iter"]
diff --git a/qmcpy/stopping_criterion/pf_gp_ci.py b/qmcpy/stopping_criterion/pf_gp_ci.py
index 5da66259f..3c1d1fbe6 100644
--- a/qmcpy/stopping_criterion/pf_gp_ci.py
+++ b/qmcpy/stopping_criterion/pf_gp_ci.py
@@ -74,8 +74,8 @@ def suggest(self, n, d, gp, rng, **kwargs):
 
 
 class PFGPCI(AbstractStoppingCriterion):
-    """
-    Probability of failure estimation using adaptive Gaussian process construction and resulting credible intervals.
+    """Probability of failure estimation using adaptive Gaussian process
+    construction and resulting credible intervals.
 
     Examples:
         >>> pfgpci = PFGPCI(
@@ -154,7 +154,7 @@ class PFGPCI(AbstractStoppingCriterion):
               error_ref: [2.01e-02   7.02e-03   1.28e-02   4.52e-03  ]
                   in_ci: [True       True       True       True      ]
 
-    **References:**
+    **References: **
 
     1.  Sorokin, Aleksei G., and Vishwas Rao.
         "Credible Intervals for Probability of Failure with Gaussian Processes."
@@ -197,26 +197,50 @@ def __init__(
         Args:
             integrand (AbstractIntegrand): The integrand.
             failure_threshold (float): Thresholds for failure.
-            failure_above_threshold (bool): Set to `True` if failure occurs when the simulation exceeds `failure_threshold` and False otherwise.
-            abs_tol (float): The desired maximum distance from the estimate to either end of the credible interval.
-            n_init (float): Initial number of samples from integrand.discrete_distrib from which to build the first surrogate GP
+            failure_above_threshold (bool): Set to `True` if failure occurs
+                when the simulation exceeds `failure_threshold` and False
+                otherwise.
+            abs_tol (float): The desired maximum distance from the estimate to
+                either end of the credible interval.
+            n_init (float): Initial number of samples from
+                integrand.discrete_distrib from which to build the first
+                surrogate GP
             n_limit (int): Budget of simulations.
-            n_batch (int): The number of samples per batch to draw from batch_sampler.
-            alpha (float): The credible interval is constructed to hold with probability at least 1 - alpha
-            init_samples (float): If the simulation has already been run, pass in (x,y) where x are past samples from the discrete distribution and y are corresponding simulation evaluations.
-            batch_sampler (Suggester or AbstractDiscreteDistribution): A suggestion scheme for future samples.
-            n_approx (int): Number of points from integrand.discrete_distrib used to approximate estimate and credible interval bounds
+            n_batch (int): The number of samples per batch to draw from
+                batch_sampler.
+            alpha (float): The credible interval is constructed to hold with
+                probability at least 1 - alpha
+            init_samples (float): If the simulation has already been run, pass
+                in (x,y) where x are past samples from the discrete
+                distribution and y are corresponding simulation evaluations.
+            batch_sampler (Suggester or AbstractDiscreteDistribution):
+                A suggestion scheme for future samples.
+            n_approx (int): Number of points from integrand.discrete_distrib
+                used to approximate estimate and credible interval bounds
             gpytorch_prior_mean (gpytorch.means): prior mean function of the GP
-            gpytorch_prior_cov (gpytorch.kernels): Prior covariance kernel of the GP
-            gpytorch_likelihood (gpytorch.likelihoods): GP likelihood, require one of gpytorch.likelihoods.{GaussianLikelihood, GaussianLikelihoodWithMissingObs, FixedNoiseGaussianLikelihood}
-            gpytorch_marginal_log_likelihood_func (callable): Function taking in the likelihood and gpytorch model and returning a marginal log likelihood from gpytorch.mlls
-            torch_optimizer_func (callable): Function taking in the gpytorch model and returning an optimizer from torch.optim
-            gpytorch_train_iter (int): Training iterations for the GP in gpytorch
-            gpytorch_use_gpu (bool): If True, have gpytorch use a GPU for fitting and trining the GP
-            verbose (int): If verbose > 0, print information through the call to integrate()
-            n_ref_approx (int): If n_ref_approx > 0, use n_ref_approx points to get a reference QMC approximation of the true solution.
-                Caution: If n_ref_approx > 0, it should be a large int e.g. 2**22, in which case it is only helpful for cheap to evaluate simulations
-            seed_ref_approx (int): Seed for the reference approximation. Only applies when n_ref_approx>0
+            gpytorch_prior_cov (gpytorch.kernels): Prior covariance kernel of
+                the GP
+            gpytorch_likelihood (gpytorch.likelihoods): GP likelihood, require
+                one of gpytorch.likelihoods.{GaussianLikelihood,
+                GaussianLikelihoodWithMissingObs, FixedNoiseGaussianLikelihood}
+            gpytorch_marginal_log_likelihood_func (callable): Function taking
+                in the likelihood and gpytorch model and returning a marginal
+                log likelihood from gpytorch.mlls
+            torch_optimizer_func (callable): Function taking in the gpytorch
+                model and returning an optimizer from torch.optim
+            gpytorch_train_iter (int): Training iterations for the GP in
+                gpytorch
+            gpytorch_use_gpu (bool): If True, have gpytorch use a GPU for
+                fitting and trining the GP
+            verbose (int): If verbose > 0, print information through the call
+                to integrate()
+            n_ref_approx (int): If n_ref_approx > 0, use n_ref_approx points to
+                get a reference QMC approximation of the true solution.
+                Caution: If n_ref_approx > 0, it should be a large int e.g.
+                2**22, in which case it is only helpful for cheap to evaluate
+                simulations
+            seed_ref_approx (int): Seed for the reference approximation. Only
+                applies when n_ref_approx>0
         """
         self.parameters = ["abs_tol", "n_init", "n_limit", "n_batch"]
         self.integrand = integrand
diff --git a/qmcpy/true_measure/abstract_true_measure.py b/qmcpy/true_measure/abstract_true_measure.py
index b7611b1f3..b7cc7d35e 100644
--- a/qmcpy/true_measure/abstract_true_measure.py
+++ b/qmcpy/true_measure/abstract_true_measure.py
@@ -42,14 +42,18 @@ def _set_moments(self, mean, variance, standard_deviation, covariance):
 
     @staticmethod
     def _read_only_view(value):
-        """Return a view which cannot be made writeable while its base is read only."""
+        """Return a view which cannot be made writeable while its base is
+        read only.
+        """
         view = value.view()
         view.setflags(write=False)
         return view
 
     def _scalar_if_univariate(self, value):
-        """For univariate (``d == 1``) measures, return a Python ``float`` scalar
-        (via :func:`numpy.squeeze`); otherwise return a read only array view."""
+        """For univariate (``d == 1``) measures, return a Python ``float``
+        scalar (via :func:`numpy.squeeze`); otherwise return a read only array
+        view.
+        """
         if getattr(self, "d", None) == 1:
             return float(np.squeeze(value))
         return self._read_only_view(value)
@@ -125,11 +129,12 @@ def __call__(self, n=None, n_min=None, n_max=None, return_weights=False, warn=Tr
             warn (bool): If `False`, disable warnings when generating samples.
 
         Returns:
-            t (np.ndarray): Samples from the sequence.
+            Samples from the sequence.
 
                 - If `replications` is `None` then this will be of size (`n_max`-`n_min`) $\times$ `dimension`
                 - If `replications` is a positive int, then `t` will be of size `replications` $\times$ (`n_max`-`n_min`) $\times$ `dimension`
-            weights (np.ndarray): Only returned when `return_weights=True`. The Jacobian weights for the transformation
+            weights (np.ndarray): Only returned when `return_weights=True`. The
+            Jacobian weights for the transformation
         """
         return self.gen_samples(
             n=n, n_min=n_min, n_max=n_max, return_weights=return_weights, warn=warn
@@ -173,42 +178,44 @@ def _jacobian_transform_r(self, x, return_weights):
             return t
 
     def _transform(self, x):
-        r"""Transformation from the standard uniform to the true measure distribution."""
+        r"""Transformation from the standard uniform to the true measure
+        distribution.
+        """
         raise MethodImplementationError(
             self,
             "_transform. Try setting sampler to be in a PDF AbstractTrueMeasure to importance sample by.",
         )
 
     def _weight(self, x):
-        r"""
-        Non-negative weight function.
-        This is often a PDF, but is not required to be
-        e.g., Lebesgue weight is always 1, but is not a PDF.
+        r"""Non-negative weight function. This is often a PDF, but is not
+        required to be e.g., Lebesgue weight is always 1, but is not a PDF.
 
         Args:
             x (np.ndarray): n x d  matrix of samples
 
         Returns:
-            np.ndarray: length n vector of weights at locations of x
+            length n vector of weights at locations of x
         """
         raise MethodImplementationError(
             self, "weight. Try a different true measure with a _weight method."
         )
 
     def spawn(self, s=1, dimensions=None):
-        r"""
-        Spawn new instances of the current true measure but with new seeds and dimensions.
-        Used by multi-level QMC algorithms which require different seeds and dimensions on each level.
+        r"""Spawn new instances of the current true measure but with new seeds
+        and dimensions. Used by multi-level QMC algorithms which require
+        different seeds and dimensions on each level.
 
-        Note:
-            Use `replications` instead of using `spawn` when possible, e.g., when spawning copies which all have the same dimension.
+        Notes:
+            Use `replications` instead of using `spawn` when possible, e.g.,
+            when spawning copies which all have the same dimension.
 
         Args:
             s (int): Number of copies to spawn
-            dimensions (np.ndarray): Length `s` array of dimensions for each copy. Defaults to the current dimension.
+            dimensions (np.ndarray): Length `s` array of dimensions for each
+                copy. Defaults to the current dimension.
 
         Returns:
-            spawned_true_measures (list): True measure with new seeds and dimensions.
+            True measure with new seeds and dimensions.
         """
         sampler = self.discrete_distrib if self.transform == self else self.transform
         sampler_spawns = sampler.spawn(s=s, dimensions=dimensions)
diff --git a/qmcpy/true_measure/acceptance_rejection.py b/qmcpy/true_measure/acceptance_rejection.py
index 13eb05ece..96e0bbead 100644
--- a/qmcpy/true_measure/acceptance_rejection.py
+++ b/qmcpy/true_measure/acceptance_rejection.py
@@ -13,34 +13,31 @@ def _next_pow2(n):
 
 
 class AcceptanceRejection(AbstractTrueMeasure):
-    """
-    Deterministic Acceptance-Rejection (DAR) sampler on the unit cube.
+    """Deterministic Acceptance-Rejection (DAR) sampler on the unit cube.
 
-    Implements Algorithm 2 from Zhu & Dick (2014). A (t,m,s)-net in
-    dimension s = d+1 is used as the driver, where the first d coordinates
-    form the candidate point and the last coordinate is the acceptance
-    threshold. This gives a star discrepancy bound of O(N^{-1/s}) on the
-    accepted samples, compared to O(N^{-1/2}) for standard random
-    acceptance-rejection.
+    Implements Algorithm 2 from Zhu & Dick (2014). A (t,m,s)-net in dimension s
+    = d+1 is used as the driver, where the first d coordinates form the
+    candidate point and the last coordinate is the acceptance threshold. This
+    gives a star discrepancy bound of O(N^{-1/s}) on the accepted samples,
+    compared to O(N^{-1/2}) for standard random acceptance-rejection.
 
-    The sampler dimension must be d+1 where d is the target dimension.
-    The number of driver points is always a power of 2 (required for the
+    The sampler dimension must be d+1 where d is the target dimension. The
+    number of driver points is always a power of 2 (required for the
     (t,m,s)-net property of Theorem 1).
 
     Args:
-        sampler (AbstractDiscreteDistribution): A QMCPy discrete
-            distribution of dimension s = target_dim + 1. Must mimic
-            StdUniform. The last coordinate is used as the acceptance
-            threshold.
-        target_density (callable): Unnormalised target density psi(x)
-            where x has shape (N, d). Must return shape (N,) and be
-            non-negative on [0,1]^d.
-        upper_bound (float): L = sup_{x in [0,1]^d} psi(x). Every
-            evaluation of psi must be <= L.
-        density_integral (float): C = integral_{[0,1]^d} psi(x) dx.
-            The acceptance rate is C/L.
-        max_retries (int): Number of times gen_samples will double the
-            driver size if not enough points are accepted. Default 4.
+        sampler (AbstractDiscreteDistribution): A QMCPy discrete distribution
+            of dimension s = target_dim + 1. Must mimic StdUniform. The last
+            coordinate is used as the acceptance threshold.
+        target_density (callable): Unnormalised target density psi(x) where x
+            has shape (N, d). Must return shape (N,) and be non-negative on
+            [0,1]^d.
+        upper_bound (float): L = sup_{x in [0,1]^d} psi(x). Every evaluation of
+            psi must be <= L.
+        density_integral (float): C = integral_{[0,1]^d} psi(x) dx. The
+            acceptance rate is C/L.
+        max_retries (int): Number of times gen_samples will double the driver
+            size if not enough points are accepted. Default 4.
 
     Examples:
         >>> import numpy as np
@@ -108,33 +105,32 @@ def __init__(self, sampler, target_density, upper_bound, density_integral, max_r
         super(AcceptanceRejection, self).__init__()
 
     def gen_samples(self, n=None, n_min=None, n_max=None, return_weights=False, warn=True):
-        """
-        Generate accepted samples from the target density.
+        """Generate accepted samples from the target density.
 
-        Unlike other TrueMeasures, this method cannot be decomposed into
-        a fixed 1-to-1 _transform because acceptance-rejection produces
-        a variable number of outputs from a fixed driver batch. gen_samples
-        is therefore overridden directly.
+        Unlike other TrueMeasures, this method cannot be decomposed into a
+        fixed 1-to-1 _transform because acceptance-rejection produces a
+        variable number of outputs from a fixed driver batch. gen_samples is
+        therefore overridden directly.
 
-        Supports continued sampling: calling with n_min=0 starts fresh,
-        and subsequent calls with n_min>0 continue from the same driver
-        sequence position.
+        Supports continued sampling: calling with n_min=0 starts fresh, and
+        subsequent calls with n_min>0 continue from the same driver sequence
+        position.
 
         Args:
-            n (int): Number of accepted samples to return. Treated as
-                n_min=0, n_max=n (always resets the driver sequence).
-            n_min (int): Starting accepted-sample index. Use 0 to reset
-                and start fresh. Use a positive value to continue from
-                the previous call.
-            n_max (int): Ending accepted-sample index (exclusive).
-                Number of samples returned is n_max - n_min.
+            n (int): Number of accepted samples to return. Treated as n_min=0,
+                n_max=n (always resets the driver sequence).
+            n_min (int): Starting accepted-sample index. Use 0 to reset and
+                start fresh. Use a positive value to continue from the previous
+                call.
+            n_max (int): Ending accepted-sample index (exclusive). Number of
+                samples returned is n_max - n_min.
             return_weights (bool): If True, also return importance weights
                 psi(x)/C for each accepted sample.
-            warn (bool): If True, warn when fewer than n samples are
-                returned after all retries.
+            warn (bool): If True, warn when fewer than n samples are returned
+                after all retries.
 
         Returns:
-            samples (np.ndarray): Shape (n, target_dim).
+            Shape (n, target_dim).
             weights (np.ndarray): Shape (n,). Only returned when
                 return_weights=True.
         """
@@ -210,49 +206,47 @@ def _spawn(self, sampler, dimension):
 
 
 class AcceptanceRejectionReal(AbstractTrueMeasure):
-    """
-    Deterministic Acceptance-Rejection (DAR) sampler on real space R^d.
+    """Deterministic Acceptance-Rejection (DAR) sampler on real space R^d.
 
-    Implements Algorithm 3 from Zhu & Dick (2014). Extends Algorithm 2
-    to densities on R^d by mapping the unit-cube driver through marginal
-    quantile functions (inverse Rosenblatt transform, Lemma 4) before
-    applying the acceptance test.
+    Implements Algorithm 3 from Zhu & Dick (2014). Extends Algorithm 2 to
+    densities on R^d by mapping the unit-cube driver through marginal quantile
+    functions (inverse Rosenblatt transform, Lemma 4) before applying the
+    acceptance test.
 
     The driver point (u_1, ..., u_d, u_{d+1}) is transformed as:
 
-        z_j = F_j^{-1}(u_j)   for j = 1, ..., d
-        u   = u_{d+1}          threshold coordinate (unchanged)
+    z_j = F_j^{-1}(u_j)   for j = 1, ..., d u   = u_{d+1}          threshold
+    coordinate (unchanged)
 
     Acceptance condition:  psi(z) >= L * H(z) * u
 
-    where H is the auxiliary bound function satisfying psi(z) <= L * H(z)
-    for all z in R^d. This gives the same discrepancy bound O(N^{-1/s})
-    as Algorithm 2.
+    where H is the auxiliary bound function satisfying psi(z) <= L * H(z) for
+    all z in R^d. This gives the same discrepancy bound O(N^{-1/s}) as
+    Algorithm 2.
 
-    Note:
-        inv_cdfs applies each quantile function independently per
-        dimension. This is exact when H factors as a product of
-        independent marginals (e.g. a product of univariate distributions).
+    Notes:
+        inv_cdfs applies each quantile function independently per dimension.
+        This is exact when H factors as a product of independent marginals
+        (e.g. a product of univariate distributions).
 
     Args:
-        sampler (AbstractDiscreteDistribution): A QMCPy discrete
-            distribution of dimension s = target_dim + 1. Must mimic
-            StdUniform.
-        target_density (callable): Unnormalised target density psi(z)
-            where z has shape (N, d). Must return shape (N,).
-            Must satisfy psi(z) <= L * H(z) for all z.
-        inv_cdfs (list of callable): List of d quantile functions
-            [F_1^{-1}, ..., F_d^{-1}], one per dimension. Each maps
-            a 1-D array of uniforms in [0,1] to R.
-            Example: [scipy.stats.norm.ppf] for a 1-D standard Gaussian.
-        H_func (callable): Auxiliary bound function H(z) where z has
-            shape (N, d). Must return shape (N,) and satisfy
-            psi(z) <= L * H(z) for all z in R^d.
+        sampler (AbstractDiscreteDistribution): A QMCPy discrete distribution
+            of dimension s = target_dim + 1. Must mimic StdUniform.
+        target_density (callable): Unnormalised target density psi(z) where z
+            has shape (N, d). Must return shape (N,). Must satisfy psi(z) <= L
+            * H(z) for all z.
+        inv_cdfs (list of callable): List of d quantile functions [F_1^{-1},
+            ..., F_d^{-1}], one per dimension. Each maps a 1-D array of
+            uniforms in [0,1] to R. Example: [scipy.stats.norm.ppf] for a 1-D
+            standard Gaussian.
+        H_func (callable): Auxiliary bound function H(z) where z has shape (N,
+            d). Must return shape (N,) and satisfy psi(z) <= L * H(z) for all z
+            in R^d.
         upper_bound (float): L satisfying psi(z) <= L * H(z) for all z.
-        density_integral (float): C = integral_{R^d} psi(z) dz.
-            The acceptance rate is C/L.
-        max_retries (int): Number of times gen_samples will double the
-            driver size if not enough points are accepted. Default 4.
+        density_integral (float): C = integral_{R^d} psi(z) dz. The acceptance
+            rate is C/L.
+        max_retries (int): Number of times gen_samples will double the driver
+            size if not enough points are accepted. Default 4.
 
     Examples:
         >>> import numpy as np
@@ -276,7 +270,8 @@ class AcceptanceRejectionReal(AbstractTrueMeasure):
             density_integral 1
             acceptance_rate 2^(-1)
 
-        Continued sampling: batches resume the driver sequence without restarting.
+        Continued sampling: batches resume the driver sequence without
+        restarting.
 
         >>> inv_cdfs = [lambda u: norm.ppf(u, loc=0, scale=2)]
         >>> m1 = AcceptanceRejectionReal(DigitalNetB2(dimension=2, seed=7), psi, inv_cdfs=inv_cdfs, H_func=H, upper_bound=2., density_integral=1.)
@@ -326,33 +321,32 @@ def __init__(self, sampler, target_density, inv_cdfs, H_func,
         super(AcceptanceRejectionReal, self).__init__()
 
     def gen_samples(self, n=None, n_min=None, n_max=None, return_weights=False, warn=True):
-        """
-        Generate accepted samples from the target density on R^d.
+        """Generate accepted samples from the target density on R^d.
 
-        Unlike other TrueMeasures, this method cannot be decomposed into
-        a fixed 1-to-1 _transform because acceptance-rejection produces
-        a variable number of outputs from a fixed driver batch. gen_samples
-        is therefore overridden directly.
+        Unlike other TrueMeasures, this method cannot be decomposed into a
+        fixed 1-to-1 _transform because acceptance-rejection produces a
+        variable number of outputs from a fixed driver batch. gen_samples is
+        therefore overridden directly.
 
-        Supports continued sampling: calling with n_min=0 starts fresh,
-        and subsequent calls with n_min>0 continue from the same driver
-        sequence position.
+        Supports continued sampling: calling with n_min=0 starts fresh, and
+        subsequent calls with n_min>0 continue from the same driver sequence
+        position.
 
         Args:
-            n (int): Number of accepted samples to return. Treated as
-                n_min=0, n_max=n (always resets the driver sequence).
-            n_min (int): Starting accepted-sample index. Use 0 to reset
-                and start fresh. Use a positive value to continue from
-                the previous call.
-            n_max (int): Ending accepted-sample index (exclusive).
-                Number of samples returned is n_max - n_min.
+            n (int): Number of accepted samples to return. Treated as n_min=0,
+                n_max=n (always resets the driver sequence).
+            n_min (int): Starting accepted-sample index. Use 0 to reset and
+                start fresh. Use a positive value to continue from the previous
+                call.
+            n_max (int): Ending accepted-sample index (exclusive). Number of
+                samples returned is n_max - n_min.
             return_weights (bool): If True, also return importance weights
                 psi(z)/C for each accepted sample.
-            warn (bool): If True, warn when fewer than n samples are
-                returned after all retries.
+            warn (bool): If True, warn when fewer than n samples are returned
+                after all retries.
 
         Returns:
-            samples (np.ndarray): Shape (n, target_dim).
+            Shape (n, target_dim).
             weights (np.ndarray): Shape (n,). Only returned when
                 return_weights=True.
         """
diff --git a/qmcpy/true_measure/bernoulli_cont.py b/qmcpy/true_measure/bernoulli_cont.py
index cadf9f727..50dcefa67 100644
--- a/qmcpy/true_measure/bernoulli_cont.py
+++ b/qmcpy/true_measure/bernoulli_cont.py
@@ -5,8 +5,9 @@
 
 
 class BernoulliCont(AbstractTrueMeasure):
-    r"""
-    Continuous Bernoulli distribution with independent marginals as described in [https://en.wikipedia.org/wiki/Continuous_Bernoulli_distribution](https://en.wikipedia.org/wiki/Continuous_Bernoulli_distribution).
+    r"""Continuous Bernoulli distribution with independent marginals as
+    described in
+    [https://en.wikipedia.org/wiki/Continuous_Bernoulli_distribution](https://en.wikipedia.org/wiki/Continuous_Bernoulli_distribution).
 
     Examples:
         >>> true_measure = BernoulliCont(DigitalNetB2(2,seed=7),lam=.2)
@@ -39,11 +40,13 @@ class BernoulliCont(AbstractTrueMeasure):
     def __init__(self, sampler, lam=1 / 2):
         r"""
         Args:
-            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]): Either
+            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
+                Either
 
                 - a discrete distribution from which to transform samples, or
                 - a true measure by which to compose a transform.
-            lam (Union[float, np.ndarray]): Vector of shape parameters, each in $(0,1)$.
+            lam (Union[float, np.ndarray]): Vector of shape parameters, each in
+                $(0,1)$.
         """
         self.parameters = ["lam"]
         self.domain = np.array([[0, 1]])
diff --git a/qmcpy/true_measure/brownian_motion.py b/qmcpy/true_measure/brownian_motion.py
index 564223a00..5384ac47f 100644
--- a/qmcpy/true_measure/brownian_motion.py
+++ b/qmcpy/true_measure/brownian_motion.py
@@ -7,9 +7,10 @@
 
 
 class BrownianMotion(Gaussian):
-    r"""
-    Brownian Motion as described in [https://en.wikipedia.org/wiki/Brownian_motion](https://en.wikipedia.org/wiki/Brownian_motion).
-    For a standard Brownian Motion $W$ we define the Brownian Motion $B$ with initial value $B_0$, drift $\gamma$, and diffusion $\sigma^2$ to be
+    r"""Brownian Motion as described in
+    [https://en.wikipedia.org/wiki/Brownian_motion](https://en.wikipedia.org/wiki/Brownian_motion).
+    For a standard Brownian Motion $W$ we define the Brownian Motion $B$ with
+    initial value $B_0$, drift $\gamma$, and diffusion $\sigma^2$ to be
 
     $$B(t) = B_0 + \gamma t + \sigma W(t).$$
 
@@ -70,7 +71,8 @@ class BrownianMotion(Gaussian):
             bridge_construction_times [1.   0.5  0.75 0.25]
             bridge_output_times [0.25 0.5  0.75 1.  ]
 
-        Example 4: With Brownian Bridge construction and independent replications
+        Example 4: With Brownian Bridge construction and independent
+        replications
 
         >>> x = BrownianMotion(DigitalNetB2(4,seed=7,replications=3),decomp_type='BrownianBridge')(2)
         >>> x.shape
@@ -85,9 +87,10 @@ class BrownianMotion(Gaussian):
                [[ 0.59845146,  1.10849282,  1.34022073,  1.02092441],
                 [-0.20298903, -0.23324496, -0.3026512 , -0.35202342]]])
 
-        Example 5: With custom monitoring times and passing bridge_vdc_gray_ordering=False (reaches all four cases)
+        Example 5: With custom monitoring times and passing
+        bridge_vdc_gray_ordering=False (reaches all four cases)
 
-        >>> true_measure = BrownianMotion(DigitalNetB2(4,seed=7),decomp_type='BrownianBridge',monitoring_times=[0.6,1.0,0.3,0.8],bridge_vdc_gray_ordering=False)        
+        >>> true_measure = BrownianMotion(DigitalNetB2(4,seed=7),decomp_type='BrownianBridge',monitoring_times=[0.6,1.0,0.3,0.8],bridge_vdc_gray_ordering=False)
         >>> true_measure.time_vec
         array([0.3, 0.6, 0.8, 1. ])
         >>> true_measure(2)
@@ -98,7 +101,8 @@ class BrownianMotion(Gaussian):
         >>> true_measure.bridge_output_times
         array([0.3, 0.6, 0.8, 1. ])
 
-        Example 6: With custom monitoring times. By default the times are sorted and inserted in van der Corput order 
+        Example 6: With custom monitoring times. By default the times are
+        sorted and inserted in van der Corput order
 
         >>> true_measure = BrownianMotion(DigitalNetB2(4,seed=7),decomp_type='BrownianBridge',monitoring_times=[0.6,1.0,0.3,0.8])
         >>> true_measure.time_vec
@@ -124,9 +128,9 @@ class BrownianMotion(Gaussian):
         >>> true_measure.bridge_output_times
         array([0.6, 1. , 0.3, 0.8])
 
-        **References:**
+        **References: **
 
-        1.  Art B. Owen. 
+        1.  Art B. Owen.
             Monte Carlo theory, methods and examples.
             Section 6.4, Detailed Simulation of Brownian Motion, 2013
             [https://artowen.su.domains/mc/](https://artowen.su.domains/mc/)
@@ -147,7 +151,8 @@ def __init__(
     ):
         r"""
         Args:
-            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]): Either
+            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
+                Either
 
                 - a discrete distribution from which to transform samples, or
                 - a true measure by which to compose a transform.
@@ -155,19 +160,25 @@ def __init__(
             initial_value (float): Initial value $B_0$.
             drift (int): Drift $\gamma$.
             diffusion (int): Diffusion $\sigma^2$.
-            decomp_type (str): Method for decomposition for covariance matrix. Options include
+            decomp_type (str): Method for decomposition for covariance matrix.
+                Options include
 
                 - `'PCA'` for principal component analysis,
                 - `'Cholesky'` for cholesky decomposition, or
                 - `'BrownianBridge'` or `'Bridge'` for brownian bridge construction.
-            lazy_decomp (bool): If True, defer expensive matrix decomposition until needed.
-            monitoring_times (Union[np.ndarray, list]): Optional custom sampling times for `'BrownianBridge'` 
-                with length d. The given order is the insertion order if `'bridge_vdc_gray_ordering'` is False.
-            bridge_vdc_gray_ordering (bool): For `'BrownianBridge'` when monitoring_times is specified. If True, 
-                monitoring_times is sorted to match van der Corput ordering. 
-            bridge_output_order (str): If `'increasing'`, output is returned in increasing order. If `'input'`, 
-                output matches the order given in `'monitoring_times'`. If a custom monitoring times is not given,
-                the output is given in increasing order.
+            lazy_decomp (bool): If True, defer expensive matrix decomposition
+                until needed.
+            monitoring_times (Union[np.ndarray, list]): Optional custom
+                sampling times for `'BrownianBridge'` with length d. The given
+                order is the insertion order if `'bridge_vdc_gray_ordering'` is
+                False.
+            bridge_vdc_gray_ordering (bool): For `'BrownianBridge'` when
+                monitoring_times is specified. If True, monitoring_times is
+                sorted to match van der Corput ordering.
+            bridge_output_order (str): If `'increasing'`, output is returned in
+                increasing order. If `'input'`, output matches the order given
+                in `'monitoring_times'`. If a custom monitoring times is not
+                given, the output is given in increasing order.
         """
         if str(decomp_type).upper() == "BRIDGE":
             decomp_type = "BrownianBridge"
diff --git a/qmcpy/true_measure/clayton_copula.py b/qmcpy/true_measure/clayton_copula.py
index fb25b2648..c446159f4 100644
--- a/qmcpy/true_measure/clayton_copula.py
+++ b/qmcpy/true_measure/clayton_copula.py
@@ -11,24 +11,22 @@
 
 
 class ClaytonCopula(AbstractCopula):
-    r"""
-    Clayton copula transform with user supplied marginals.
+    r"""Clayton copula transform with user supplied marginals.
 
     This implementation supports general dimension for ``theta > 0``. It maps
     independent uniforms to Clayton-dependent uniforms using the conditional
     inverse / inverse Rosenblatt transform. For coordinate ``j`` after
-    observing the previous ``m = j - 1`` coordinates, the conditional inverse is
+    observing the previous ``m = j - 1`` coordinates, the conditional inverse
+    is
 
-    $$
-    v = \left(1 + A
-        \left(w^{-\theta/(1 + m \theta)} - 1\right)\right)^{-1/\theta},
-    $$
+    $$ v = \left(1 + A \left(w^{-\theta/(1 + m \theta)} -
+    1\right)\right)^{-1/\theta}, $$
 
-    where ``A = 1 + sum(phi(u_i))`` over previous coordinates and
-    ``phi(u) = u^{-theta} - 1``.
+    where ``A = 1 + sum(phi(u_i))`` over previous coordinates and ``phi(u) =
+    u^{-theta} - 1``.
 
-    The base ``AbstractCopula`` class then applies each marginal quantile function.
-    SciPy calls the quantile function ``ppf``.
+    The base ``AbstractCopula`` class then applies each marginal quantile
+    function. SciPy calls the quantile function ``ppf``.
 
     Clayton copulas have positive lower-tail dependence for ``theta > 0``.
 
@@ -64,7 +62,7 @@ class ClaytonCopula(AbstractCopula):
         >>> ClaytonCopula(DigitalNetB2(2, seed=7), marginals=marginals, theta=1e-8)(4).shape
         (4, 2)
 
-    **References:**
+    **References: **
 
     1.  Roger B. Nelsen. *An Introduction to Copulas*. Second Edition,
         Springer Series in Statistics, Springer, 2006.
diff --git a/qmcpy/true_measure/copula.py b/qmcpy/true_measure/copula.py
index 67ade5612..7bb539367 100644
--- a/qmcpy/true_measure/copula.py
+++ b/qmcpy/true_measure/copula.py
@@ -7,25 +7,21 @@
 
 
 class AbstractCopula(AbstractTrueMeasure):
-    r"""
-    Abstract base class for copula TrueMeasures.
+    r"""Abstract base class for copula TrueMeasures.
 
     A copula layer maps independent uniform input points to dependent uniform
     points on the unit cube:
 
-    $$
-    U \in [0,1]^d \mapsto V = T(U) \in [0,1]^d.
-    $$
+    $$ U \in [0,1]^d \mapsto V = T(U) \in [0,1]^d. $$
 
     The base class then applies marginal quantile functions to obtain final
     target samples,
 
-    $$
-    X_j = F_j^{-1}(V_j).
-    $$
+    $$ X_j = F_j^{-1}(V_j). $$
 
     SciPy calls the quantile function ``ppf``. Concrete subclasses implement
-    ``_transform_to_uniform`` for the family-specific copula sampling transform.
+    ``_transform_to_uniform`` for the family-specific copula sampling
+    transform.
     """
 
     def __init__(self, sampler, marginals):
@@ -40,28 +36,27 @@ def __init__(self, sampler, marginals):
         super(AbstractCopula, self).__init__()
 
     def _transform_to_uniform(self, x) -> np.ndarray:
-        r"""
-        Transform independent uniforms ``U`` into dependent copula uniforms ``V``.
+        r"""Transform independent uniforms ``U`` into dependent copula
+        uniforms ``V``.
         """
         raise MethodImplementationError(self, "_transform_to_uniform")
 
     def copula_transform(self, u) -> np.ndarray:
-        r"""
-        Apply only the copula layer ``U -> V``.
+        r"""Apply only the copula layer ``U -> V``.
 
         Args:
             u (np.ndarray): Independent uniform points on ``[0,1]^d``.
 
         Returns:
-            np.ndarray: Dependent uniform points on ``[0,1]^d``.
+            Dependent uniform points on ``[0,1]^d``.
         """
         return self._transform_to_uniform(u)
 
     def gen_copula_samples(
         self, n=None, n_min=None, n_max=None, warn=True
     ) -> np.ndarray:
-        r"""
-        Generate dependent copula uniforms without applying marginal quantiles.
+        r"""Generate dependent copula uniforms without applying marginal
+        quantiles.
 
         This is the copula-only workflow ``U -> V``. Calling the object itself
         keeps the ordinary TrueMeasure workflow ``U -> V -> X``.
@@ -72,8 +67,7 @@ def gen_copula_samples(
         return self._transform_to_uniform(u)
 
     def _apply_marginal_quantiles(self, v) -> np.ndarray:
-        r"""
-        Apply marginal quantile functions to dependent uniforms.
+        r"""Apply marginal quantile functions to dependent uniforms.
 
         SciPy frozen distributions expose the quantile function as ``ppf``.
         """
diff --git a/qmcpy/true_measure/frank_copula.py b/qmcpy/true_measure/frank_copula.py
index 3f17d38c0..0afdbe436 100644
--- a/qmcpy/true_measure/frank_copula.py
+++ b/qmcpy/true_measure/frank_copula.py
@@ -11,11 +11,9 @@
 
 
 def _eulerian_coefficients(n):
-    """
-    Return Eulerian coefficients for Li_{-n}(z).
+    """Return Eulerian coefficients for Li_{-n}(z).
 
-    For nonnegative integer n,
-    Li_{-n}(z) = z * A_n(z) / (1 - z) ** (n + 1),
+    For nonnegative integer n, Li_{-n}(z) = z * A_n(z) / (1 - z) ** (n + 1),
     where A_n is the Eulerian polynomial.
     """
     if n == 0:
@@ -33,8 +31,7 @@ def _eulerian_coefficients(n):
 
 
 class FrankCopula(AbstractCopula):
-    r"""
-    Frank copula transform with user supplied univariate marginals.
+    r"""Frank copula transform with user supplied univariate marginals.
 
     This implementation supports general dimension for ``theta > 0``. Negative
     ``theta`` is supported only for the bivariate case, where the negative
@@ -43,9 +40,9 @@ class FrankCopula(AbstractCopula):
 
     The transform uses the inverse Rosenblatt construction for the Frank
     Archimedean copula. It maps independent uniforms to dependent uniforms by
-    recursively inverting conditional CDFs. The base ``AbstractCopula`` class then
-    applies each marginal quantile function. SciPy calls the quantile function
-    ``ppf``.
+    recursively inverting conditional CDFs. The base ``AbstractCopula`` class
+    then applies each marginal quantile function. SciPy calls the quantile
+    function ``ppf``.
 
     Examples:
         >>> import numpy as np
@@ -88,7 +85,7 @@ class FrankCopula(AbstractCopula):
         >>> FrankCopula(DigitalNetB2(5, seed=7), marginals=[stats.uniform()] * 5, theta=5.0)(4).shape
         (4, 5)
 
-    **References:**
+    **References: **
 
     1.  Roger B. Nelsen. *An Introduction to Copulas*. Second Edition,
         Springer Series in Statistics, Springer, 2006.
@@ -113,8 +110,8 @@ def __init__(self, sampler, marginals, theta):
             marginals (list): Length d list of SciPy-like univariate
                 distributions implementing a quantile function, called ``ppf``
                 in SciPy.
-            theta (float): Frank dependence parameter. Must be nonzero. Negative
-                values are currently supported only for ``d=2``.
+            theta (float): Frank dependence parameter. Must be nonzero.
+                Negative values are currently supported only for ``d=2``.
         """
         self.parameters = ["marginals", "theta"]
         super(FrankCopula, self).__init__(sampler=sampler, marginals=marginals)
diff --git a/qmcpy/true_measure/gaussian.py b/qmcpy/true_measure/gaussian.py
index 37d58982b..5207fa897 100644
--- a/qmcpy/true_measure/gaussian.py
+++ b/qmcpy/true_measure/gaussian.py
@@ -9,10 +9,10 @@
 
 
 class Gaussian(AbstractTrueMeasure):
-    """
-    Gaussian (Normal) distribution as described in [https://en.wikipedia.org/wiki/Multivariate_normal_distribution](https://en.wikipedia.org/wiki/Multivariate_normal_distribution).
+    """Gaussian (Normal) distribution as described in
+    [https://en.wikipedia.org/wiki/Multivariate_normal_distribution](https://en.wikipedia.org/wiki/Multivariate_normal_distribution).
 
-    Note:
+    Notes:
         - `Normal` is an alias for `Gaussian`
 
     Examples:
@@ -51,13 +51,16 @@ class Gaussian(AbstractTrueMeasure):
     def __init__(self, sampler, mean=0.0, covariance=1.0, decomp_type="PCA"):
         """
         Args:
-            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]): Either
+            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
+                Either
 
                 - a discrete distribution from which to transform samples, or
                 - a true measure by which to compose a transform.
             mean (Union[float, np.ndarray]): Mean vector.
-            covariance (Union[float, np.ndarray]): Covariance matrix. A float or vector will be expanded into a diagonal matrix.
-            decomp_type (str): Method for decomposition for covariance matrix. Options include
+            covariance (Union[float, np.ndarray]): Covariance matrix. A float
+                or vector will be expanded into a diagonal matrix.
+            decomp_type (str): Method for decomposition for covariance matrix.
+                Options include
 
                 - `'PCA'` for principal component analysis, or
                 - `'Cholesky'` for cholesky decomposition.
@@ -108,7 +111,9 @@ def _parse_gaussian_params(self, mean, covariance, decomp_type, lazy_decomp=Fals
             self._setup_scipy_mvn()
 
     def _compute_decomposition(self):
-        """Compute matrix decomposition (PCA or Cholesky). Raises ParameterError for BrownianBridge."""
+        """Compute matrix decomposition (PCA or Cholesky). Raises
+        ParameterError for BrownianBridge.
+        """
         if self._a_cache is not None:
             return self._a_cache
 
diff --git a/qmcpy/true_measure/gaussian_copula.py b/qmcpy/true_measure/gaussian_copula.py
index 276106157..9da4a15d6 100644
--- a/qmcpy/true_measure/gaussian_copula.py
+++ b/qmcpy/true_measure/gaussian_copula.py
@@ -14,8 +14,7 @@
 
 
 class GaussianCopula(AbstractCopula):
-    r"""
-    Gaussian copula transform with user supplied univariate marginals.
+    r"""Gaussian copula transform with user supplied univariate marginals.
 
     This TrueMeasure separates the dependence model from the marginal
     distributions:
@@ -26,9 +25,9 @@ class GaussianCopula(AbstractCopula):
     4. apply each marginal quantile function.
 
     SciPy calls the quantile function ``ppf``. The marginal objects must expose
-    this method. If they also expose
-    ``cdf`` and ``pdf`` or ``logpdf``, then ``_weight`` computes the Gaussian
-    copula joint density. Otherwise weights are treated as one with a warning.
+    this method. If they also expose ``cdf`` and ``pdf`` or ``logpdf``, then
+    ``_weight`` computes the Gaussian copula joint density. Otherwise weights
+    are treated as one with a warning.
 
     Examples:
         >>> import numpy as np
@@ -65,7 +64,7 @@ class GaussianCopula(AbstractCopula):
         >>> GaussianCopula(DigitalNetB2(1, seed=7), marginals=[stats.norm()], correlation=[[1.0]])(4).shape
         (4, 1)
 
-    **References:**
+    **References: **
 
     1.  Roger B. Nelsen. *An Introduction to Copulas*. Second Edition,
         Springer Series in Statistics, Springer, 2006.
@@ -84,7 +83,8 @@ def __init__(self, sampler, marginals, correlation):
             marginals (list): Length d list of SciPy-like univariate
                 distributions implementing a quantile function, called ``ppf``
                 in SciPy.
-            correlation (np.ndarray): d x d positive definite correlation matrix.
+            correlation (np.ndarray): d x d positive definite correlation
+                matrix.
         """
         self.parameters = ["marginals", "correlation"]
         super(GaussianCopula, self).__init__(sampler=sampler, marginals=marginals)
diff --git a/qmcpy/true_measure/geometric_brownian_motion.py b/qmcpy/true_measure/geometric_brownian_motion.py
index 9daa76c24..25d3d6cf1 100644
--- a/qmcpy/true_measure/geometric_brownian_motion.py
+++ b/qmcpy/true_measure/geometric_brownian_motion.py
@@ -21,10 +21,11 @@
 
 
 class GeometricBrownianMotion(BrownianMotion):
-    r"""
-    A Geometric Brownian Motion (GBM) with initial value $S_0$, drift $\gamma$, and diffusion $\sigma^2$ is
+    r"""A Geometric Brownian Motion (GBM) with initial value $S_0$, drift
+    $\gamma$, and diffusion $\sigma^2$ is
 
-    $$\mathrm{GBM}(t) = S_0 \exp[(\gamma - \sigma^2/2) t + \sigma \mathrm{BM}(t)]$$
+    $$\mathrm{GBM}(t) = S_0 \exp[(\gamma - \sigma^2/2) t + \sigma
+    \mathrm{BM}(t)]$$
 
     where BM is a Brownian Motion drift $\gamma$ and diffusion $\sigma^2$.
 
@@ -59,14 +60,21 @@ def __init__(
     ):
         r"""
         Args:
-            sampler (DiscreteDistribution/TrueMeasure): A discrete distribution or true measure.
-            t_final (float): End time for the geometric Brownian motion, non-negative.
-            initial_value (float): Positive initial value of the process, $S_0$.
+            sampler (DiscreteDistribution/TrueMeasure): A discrete distribution
+                or true measure.
+            t_final (float): End time for the geometric Brownian motion,
+                non-negative.
+            initial_value (float): Positive initial value of the process,
+                $S_0$.
             drift (float): Drift coefficient $\gamma$.
-            diffusion (float): Positive diffusion coefficient $\sigma^2$, where $\sigma$ is volatility.
-            decomp_type (str): Method of decomposition, either "PCA", "Cholesky", or "BrownianBridge".
-            lazy_load (bool): If True, defer GBM-specific computations until needed.
-            lazy_decomp (bool): If True, defer expensive matrix decomposition until needed.
+            diffusion (float): Positive diffusion coefficient $\sigma^2$, where
+                $\sigma$ is volatility.
+            decomp_type (str): Method of decomposition, either "PCA",
+                "Cholesky", or "BrownianBridge".
+            lazy_load (bool): If True, defer GBM-specific computations until
+                needed.
+            lazy_decomp (bool): If True, defer expensive matrix decomposition
+                until needed.
         """
         super().__init__(
             sampler,
@@ -196,14 +204,16 @@ def _spawn(self, sampler, dimension):
         )
 
     def _validate_input(self):
-        """
-        Validates the input parameters of the GeometricBrownianMotion class.
+        """Validates the input parameters of the GeometricBrownianMotion
+        class.
 
         Raises:
             ValueError: If the end time `t_final' is negative.
-            ValueError: If the diffusion coefficient is less than or equal to zero.
+            ValueError: If the diffusion coefficient is less than or equal to
+                zero.
             ValueError: If the initial value is less than or equal to zero.
-            ParameterError: If the decomposition type is not 'PCA', 'Cholesky', or 'BrownianBridge'.
+            ParameterError: If the decomposition type is not 'PCA', 'Cholesky',
+                or 'BrownianBridge'.
         """
         if self.t < 0:
             raise ValueError(
@@ -223,8 +233,8 @@ def _validate_input(self):
             )
 
     def _validate_samples(self, samples, strict=False):
-        """
-        Validate that generated GBM samples meet mathematical requirements.
+        """Validate that generated GBM samples meet mathematical
+        requirements.
         """
         min_val = samples.min()
         max_val = samples.max()
@@ -260,7 +270,8 @@ def _validate_samples(self, samples, strict=False):
         return validation_results
 
     def _setup_lognormal_distribution(self):
-        """Setup scipy multivariate normal for the log-transformed variables."""
+        """Setup scipy multivariate normal for the log-transformed variables.
+        """
         # Mean of log(S(t)/S0): (drift - 0.5*diffusion) * t
         log_mean = (self.drift - 0.5 * self.diffusion) * self.time_vec
 
@@ -273,9 +284,9 @@ def _setup_lognormal_distribution(self):
         )
 
     def _weight(self, x):
-        """
-        Compute PDF of multivariate log-normal distribution.
-        For log-normal: f(x) = (1/∏x_i) * φ(log(x/S0)) where φ is multivariate normal PDF.
+        """Compute PDF of multivariate log-normal distribution. For
+        log-normal: f(x) = (1/∏x_i) * φ(log(x/S0)) where φ is multivariate
+        normal PDF.
 
         Args:
             x (ndarray): GBM sample paths of shape (n_samples, n_timepoints)
@@ -300,17 +311,16 @@ def _weight(self, x):
     def gen_samples(
         self, n=None, n_min=None, n_max=None, return_weights=False, warn=True
     ) -> Union[ndarray, Tuple[ndarray, ndarray]]:
-        """
-        Generate GBM samples using the parent's transform pipeline.
-        
+        """Generate GBM samples using the parent's transform pipeline.
+
         Args:
             n (int): number of samples to generate
             n_min (int): minimum index of sequence
-            n_max (int): maximum index of sequence  
+            n_max (int): maximum index of sequence
             return_weights (bool): whether to return Jacobian weights
             warn (bool): whether to warn about sample generation
-            
+
         Returns:
-            samples (Union[ndarray,tuple]): GBM samples, optionally with weights if return_weights=True
+            GBM samples, optionally with weights if return_weights=True
         """
         return super().gen_samples(n=n, n_min=n_min, n_max=n_max, return_weights=return_weights, warn=warn)
diff --git a/qmcpy/true_measure/gumbel_copula.py b/qmcpy/true_measure/gumbel_copula.py
index 0ecbdf7c8..84db0da73 100644
--- a/qmcpy/true_measure/gumbel_copula.py
+++ b/qmcpy/true_measure/gumbel_copula.py
@@ -11,17 +11,16 @@
 
 
 class GumbelCopula(AbstractCopula):
-    r"""
-    Gumbel copula transform with user supplied marginals.
+    r"""Gumbel copula transform with user supplied marginals.
 
-    This implementation supports general dimension for ``theta >= 1``. It
-    maps independent uniforms to Gumbel-dependent uniforms by numerically
-    inverting the conditional CDFs from the inverse Rosenblatt construction.
-    The base ``AbstractCopula`` class then applies marginal quantile functions.
-    SciPy calls the quantile function ``ppf``.
+    This implementation supports general dimension for ``theta >= 1``. It maps
+    independent uniforms to Gumbel-dependent uniforms by numerically inverting
+    the conditional CDFs from the inverse Rosenblatt construction. The base
+    ``AbstractCopula`` class then applies marginal quantile functions. SciPy
+    calls the quantile function ``ppf``.
 
-    Gumbel copulas have positive upper-tail dependence for ``theta > 1``.
-    The boundary case ``theta = 1`` is the independent copula.
+    Gumbel copulas have positive upper-tail dependence for ``theta > 1``. The
+    boundary case ``theta = 1`` is the independent copula.
 
     Examples:
         >>> import numpy as np
@@ -59,7 +58,7 @@ class GumbelCopula(AbstractCopula):
         >>> bool(((0 <= independent_samples) & (independent_samples <= 1)).all())
         True
 
-    **References:**
+    **References: **
 
     1.  Roger B. Nelsen. *An Introduction to Copulas*. Second Edition,
         Springer Series in Statistics, Springer, 2006.
@@ -84,7 +83,8 @@ def __init__(self, sampler, marginals, theta):
             marginals (list): Length d list of SciPy-like univariate
                 distributions implementing a quantile function, called ``ppf``
                 in SciPy.
-            theta (float): Gumbel dependence parameter, requiring ``theta >= 1``.
+            theta (float): Gumbel dependence parameter, requiring ``theta >=
+                1``.
         """
         self.parameters = ["marginals", "theta"]
         super(GumbelCopula, self).__init__(sampler=sampler, marginals=marginals)
diff --git a/qmcpy/true_measure/johnsons_su.py b/qmcpy/true_measure/johnsons_su.py
index 1d0cc54e2..a8e79534b 100644
--- a/qmcpy/true_measure/johnsons_su.py
+++ b/qmcpy/true_measure/johnsons_su.py
@@ -6,8 +6,9 @@
 
 
 class JohnsonsSU(AbstractTrueMeasure):
-    r"""
-    Johnson's $S_U$-distribution with independent marginals as described in [https://en.wikipedia.org/wiki/Johnson%27s_SU-distribution](https://en.wikipedia.org/wiki/Johnson%27s_SU-distribution).
+    r"""Johnson's $S_U$-distribution with independent marginals as described
+    in
+    [https://en.wikipedia.org/wiki/Johnson%27s_SU-distribution](https://en.wikipedia.org/wiki/Johnson%27s_SU-distribution).
 
     Examples:
         >>> true_measure = JohnsonsSU(DigitalNetB2(2,seed=7),gamma=1,xi=2,delta=3,lam=4)
@@ -43,7 +44,8 @@ class JohnsonsSU(AbstractTrueMeasure):
     def __init__(self, sampler, gamma=1, xi=1, delta=2, lam=2):
         r"""
         Args:
-            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]): Either
+            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
+                Either
 
                 - a discrete distribution from which to transform samples, or
                 - a true measure by which to compose a transform.
diff --git a/qmcpy/true_measure/kumaraswamy.py b/qmcpy/true_measure/kumaraswamy.py
index 47d4bdd9d..cd769c3bd 100644
--- a/qmcpy/true_measure/kumaraswamy.py
+++ b/qmcpy/true_measure/kumaraswamy.py
@@ -7,8 +7,8 @@
 
 
 class Kumaraswamy(AbstractTrueMeasure):
-    r"""
-    Kumaraswamy distribution as described in [https://en.wikipedia.org/wiki/Kumaraswamy_distribution](https://en.wikipedia.org/wiki/Kumaraswamy_distribution).
+    r"""Kumaraswamy distribution as described in
+    [https://en.wikipedia.org/wiki/Kumaraswamy_distribution](https://en.wikipedia.org/wiki/Kumaraswamy_distribution).
 
     Examples:
         >>> true_measure = Kumaraswamy(DigitalNetB2(2,seed=7),a=[1,2],b=[3,4])
@@ -53,7 +53,8 @@ class Kumaraswamy(AbstractTrueMeasure):
     def __init__(self, sampler, a=2, b=2):
         r"""
         Args:
-            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]): Either
+            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
+                Either
 
                 - a discrete distribution from which to transform samples, or
                 - a true measure by which to compose a transform.
@@ -95,19 +96,17 @@ def __init__(self, sampler, a=2, b=2):
         assert self.alpha.shape == (self.d,) and self.beta.shape == (self.d,)
 
     def _compute_moments(self):
-        r"""
-        Compute the marginal mean and variance of each coordinate.
+        r"""Compute the marginal mean and variance of each coordinate.
 
         The Kumaraswamy raw moments are $M_n = b\,B(1 + n/a, b)$ [1], so the
-        mean is $M_1$ and the variance is $M_2 - M_1^2$. Forming that difference
-        directly causes cancellation error once the variance is small relative
-        to $M_1^2$ (e.g. large $a$).
+        mean is $M_1$ and the variance is $M_2 - M_1^2$. Forming that
+        difference directly causes cancellation error once the variance is
+        small relative to $M_1^2$ (e.g. large $a$).
 
         Instead, with the log-moment function $K(r) = \log M_r$,
 
-        $$\text{mean} = e^{K(1)}, \qquad
-          \operatorname{Var}[X] = \text{mean}^2\,(e^{q} - 1), \qquad
-          q = K(2) - 2K(1).$$
+        $$\text{mean} = e^{K(1)}, \qquad \operatorname{Var}[X] =
+        \text{mean}^2\,(e^{q} - 1), \qquad q = K(2) - 2K(1).$$
 
         Each log-moment is available in closed form via the log-Beta function
         [2], $K(r) = \log b + \ln B(1 + r/a, b)$, so ``mean`` and $q$ are
@@ -119,7 +118,7 @@ def _compute_moments(self):
         Every operation is elementwise on the per-coordinate parameters $a$ and
         $b$, so ``mean`` and ``variance`` are returned as length-``d`` arrays.
 
-        **References:**
+        **References: **
 
         1.  Kumaraswamy distribution. Wikipedia.
             [https://en.wikipedia.org/wiki/Kumaraswamy_distribution](https://en.wikipedia.org/wiki/Kumaraswamy_distribution).
@@ -135,7 +134,7 @@ def _compute_moments(self):
             [https://numpy.org/doc/stable/reference/generated/numpy.expm1.html](https://numpy.org/doc/stable/reference/generated/numpy.expm1.html).
 
         Returns:
-            tuple: Length ``d`` arrays ``(mean, variance)``.
+            Length ``d`` arrays ``(mean, variance)``.
         """
         inv_a = 1.0 / self.alpha
         beta = self.beta
diff --git a/qmcpy/true_measure/lebesgue.py b/qmcpy/true_measure/lebesgue.py
index ec507bb00..7de76cf30 100644
--- a/qmcpy/true_measure/lebesgue.py
+++ b/qmcpy/true_measure/lebesgue.py
@@ -7,8 +7,8 @@
 
 
 class Lebesgue(AbstractTrueMeasure):
-    r"""
-    Lebesgue measure as described in [https://en.wikipedia.org/wiki/Lebesgue_measure](https://en.wikipedia.org/wiki/Lebesgue_measure).
+    r"""Lebesgue measure as described in
+    [https://en.wikipedia.org/wiki/Lebesgue_measure](https://en.wikipedia.org/wiki/Lebesgue_measure).
 
     Examples:
         >>> Lebesgue(Gaussian(DigitalNetB2(2,seed=7)))
@@ -38,7 +38,8 @@ class Lebesgue(AbstractTrueMeasure):
     def __init__(self, sampler):
         r"""
         Args:
-            sampler (AbstractTrueMeasure): A true measure by which to compose a transform.
+            sampler (AbstractTrueMeasure): A true measure by which to compose a
+                transform.
         """
         self.parameters = []
         if not isinstance(sampler, AbstractTrueMeasure):
diff --git a/qmcpy/true_measure/matern_gp.py b/qmcpy/true_measure/matern_gp.py
index df389bcc3..82f8ea2fb 100644
--- a/qmcpy/true_measure/matern_gp.py
+++ b/qmcpy/true_measure/matern_gp.py
@@ -12,8 +12,7 @@
 
 
 class MaternGP(Gaussian):
-    r"""
-    A Gaussian process with Matérn covariance kernel.
+    r"""A Gaussian process with Matérn covariance kernel.
 
     Examples:
         >>> true_measure = MaternGP(DigitalNetB2(dimension=3,seed=7),points=np.linspace(0,1,3)[:,None],nu=3/2,length_scale=[3,4,5],variance=0.01,mean=np.array([.3,.4,.5]))
@@ -58,7 +57,7 @@ class MaternGP(Gaussian):
                 [0.2147053 , 0.33293508, 0.43572791],
                 [0.37343973, 0.46534628, 0.56356714]]])
 
-    **References:**
+    **References: **
 
     1.  [`sklearn.gaussian_process.kernels.Matern`](https://scikit-learn.org/stable/modules/generated/sklearn.gaussian_process.kernels.Matern.html).
 
@@ -78,11 +77,14 @@ def __init__(
     ):
         r"""
         Args:
-            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]): Either
+            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
+                Either
 
                 - a discrete distribution from which to transform samples, or
                 - a true measure by which to compose a transform.
-            points (np.ndarray): The positions of points on a metric space. The array should have shape $(d,k)$ where $d$ is the dimension of the sampler and $k$ is the latent dimension.
+            points (np.ndarray): The positions of points on a metric space. The
+                array should have shape $(d,k)$ where $d$ is the dimension of
+                the sampler and $k$ is the latent dimension.
             nu (float): The "smoothness" of the MaternGP function, e.g.,
 
                 - $\nu = 1/2$ is equivalent to the absolute exponential kernel,
@@ -90,15 +92,19 @@ def __init__(
                 - $\nu = 5/2$ implies twice differentiability.
                 - as $\nu \to \infty$ the kernel becomes equivalent to the RBF kernel, see [`sklearn.gaussian_process.kernels.RBF`](https://scikit-learn.org/stable/modules/generated/sklearn.gaussian_process.kernels.RBF.html#sklearn.gaussian_process.kernels.RBF).
 
-                Note that when $\nu \notin \{1/2, 3/2, 5/2, \infty \}$ the kernel is around $10$ times slower to evaluate.
-            length_scale (Union[float, np.ndarray]): Determines "peakiness", or how correlated two points are based on their distance.
+                Note that when $\nu \notin \{1/2, 3/2, 5/2, \infty \}$ the
+                kernel is around $10$ times slower to evaluate.
+            length_scale (Union[float, np.ndarray]): Determines "peakiness", or
+                how correlated two points are based on their distance.
             variance (float): Global scaling factor of the kernel. Retrievable
                 after construction via the `kernel_variance` property. (The
                 inherited `variance` attribute is the vector of marginal
                 variances, i.e. the diagonal of `covariance`.)
-            mean (Union[float, np.ndarray]): Mean vector for multivariate `Gaussian`.
+            mean (Union[float, np.ndarray]): Mean vector for multivariate
+                `Gaussian`.
             nugget (float): Positive nugget to add to diagonal.
-            decomp_type (str): Method for decomposition for covariance matrix. Options include
+            decomp_type (str): Method for decomposition for covariance matrix.
+                Options include
 
                 - `'PCA'` for principal component analysis, or
                 - `'Cholesky'` for cholesky decomposition.
diff --git a/qmcpy/true_measure/product_measure.py b/qmcpy/true_measure/product_measure.py
index 4c798e564..22a644d98 100644
--- a/qmcpy/true_measure/product_measure.py
+++ b/qmcpy/true_measure/product_measure.py
@@ -9,8 +9,8 @@
 
 
 class ProductMeasure(AbstractTrueMeasure):
-    r"""
-    Product true measure for independent composition of marginal true measures.
+    r"""Product true measure for independent composition of marginal true
+    measures.
 
     ``ProductMeasure`` represents an independent product of smaller true
     measures. Each marginal may be one-dimensional or multidimensional. If the
@@ -29,12 +29,11 @@ class ProductMeasure(AbstractTrueMeasure):
 
     For example, if the marginals are
 
-        marginal 1: 2D Gaussian
-        marginal 2: 1D zero-inflated exponential
+    marginal 1: 2D Gaussian marginal 2: 1D zero-inflated exponential
 
     then ``ProductMeasure`` uses a 3D sampler and returns samples with three
-    coordinates. The first two coordinates come from the Gaussian marginal,
-    and the third coordinate comes from the zero-inflated exponential marginal.
+    coordinates. The first two coordinates come from the Gaussian marginal, and
+    the third coordinate comes from the zero-inflated exponential marginal.
 
     The marginal true measures still have their own samplers because QMCPy's
     current ``AbstractTrueMeasure`` API requires every true measure to be
@@ -100,24 +99,23 @@ class ProductMeasure(AbstractTrueMeasure):
     """
 
     def __init__(self, sampler, marginals):
-        """
-        Initialize a product measure from one sampler and several marginals.
+        """Initialize a product measure from one sampler and several
+        marginals.
+
+        Args:
 
-        Parameters:
-        
-        sampler : AbstractDiscreteDistribution
-            The sampler for the whole product measure. Its dimension must
-            equal the sum of the marginal dimensions.
+        sampler: AbstractDiscreteDistribution The sampler for the whole product
+            measure. Its dimension must equal the sum of the marginal
+            dimensions.
 
-        marginals : list or tuple of AbstractTrueMeasure
-            Independent true measures to place side by side. A marginal may
-            itself be multidimensional.
+        marginals: list or tuple of AbstractTrueMeasure Independent true
+            measures to place side by side. A marginal may itself be
+            multidimensional.
 
-        Why one sampler?
-        ----------------
-        The product measure should be driven by one total-dimensional QMC
-        point set. We do not generate separate QMC samples from each marginal.
-        Instead, one sample u in [0,1]^d is split into blocks:
+        Why one sampler? ---------------- The product measure should be driven
+        by one total-dimensional QMC point set. We do not generate separate QMC
+        samples from each marginal. Instead, one sample u in [0,1]^d is split
+        into blocks:
 
             u = (u_marginal_1, u_marginal_2, ..., u_marginal_k).
 
@@ -194,7 +192,9 @@ def __init__(self, sampler, marginals):
                 self.parameters.append(statistic)
 
     def _marginal_statistic(self, marginal, marginal_index, statistic):
-        """Return a statistic or identify the marginal that does not provide it."""
+        """Return a statistic or identify the marginal that does not provide
+        it.
+        """
         try:
             return getattr(marginal, statistic)
         except AttributeError as error:
@@ -289,7 +289,9 @@ def covariance(self):
         return self._covariance_cache
 
     def __repr__(self):
-        """Represent ProductMeasure without expanding marginal sparse matrices."""
+        """Represent ProductMeasure without expanding marginal sparse
+        matrices.
+        """
         lines = [f"{type(self).__name__} (AbstractTrueMeasure)"]
         for parameter in dict.fromkeys(self.parameters):
             if parameter == "marginals":
@@ -312,12 +314,12 @@ def __repr__(self):
 
     @staticmethod
     def _expand_bounds(bounds, dimension, name):
-        """
-        Expand a marginal's bounds so they have one row per output coordinate.
+        """Expand a marginal's bounds so they have one row per output
+        coordinate.
 
-        Some true measures store bounds as shape (1, 2), meaning the same
-        bound applies to all coordinates. Others store bounds as shape
-        (dimension, 2), meaning each coordinate has its own bound.
+        Some true measures store bounds as shape (1, 2), meaning the same bound
+        applies to all coordinates. Others store bounds as shape (dimension,
+        2), meaning each coordinate has its own bound.
 
         ProductMeasure needs all marginal ranges stacked together, so every
         marginal range must be represented as shape (dimension, 2).
@@ -336,20 +338,18 @@ def _expand_bounds(bounds, dimension, name):
 
     @property
     def _has_recursive_marginal(self):
-        """
-        Check whether any marginal is itself recursively composed.
+        """Check whether any marginal is itself recursively composed.
 
         In QMCPy, a true measure can sometimes be built on top of another true
         measure. Sampling can still be handled by the recursive transform
         helper, but exact product weights in the final transformed space are
-        more delicate. For now, ProductMeasure only computes exact weights
-        when all marginals are direct true measures.
+        more delicate. For now, ProductMeasure only computes exact weights when
+        all marginals are direct true measures.
         """
         return any(marginal.transform != marginal for marginal in self.marginals)
 
     def _split_blocks(self, x):
-        """
-        Split an input array into marginal coordinate blocks.
+        """Split an input array into marginal coordinate blocks.
 
         The split always happens along the final axis, so this works for both
         ordinary samples with shape (n, d) and replicated samples with shape
@@ -365,18 +365,16 @@ def _split_blocks(self, x):
         return np.split(x, self._split_indices, axis=-1)
 
     def _transform(self, x):
-        """
-        Transform unit-cube samples into product-measure samples.
+        """Transform unit-cube samples into product-measure samples.
 
-        Steps
-        -----
+        Steps -----
         1. Split the full unit-cube sample into marginal blocks.
         2. Send each block to the matching marginal true measure.
         3. Concatenate the transformed marginal outputs.
 
         This implements
 
-            T(u) = (T_1(u_1), T_2(u_2), ..., T_k(u_k)),
+        T(u) = (T_1(u_1), T_2(u_2), ..., T_k(u_k)),
 
         where each marginal T_j acts only on its own coordinate block.
         """
@@ -390,17 +388,16 @@ def _transform(self, x):
         return np.concatenate(transformed_blocks, axis=-1)
 
     def _weight(self, x):
-        """
-        Compute the product density/weight for independent marginals.
+        """Compute the product density/weight for independent marginals.
 
         For independent components, the joint weight is the product of the
         marginal weights:
 
             w(x) = w_1(x_1) * w_2(x_2) * ... * w_k(x_k).
 
-        This method supports direct marginal true measures. Recursive
-        marginals are blocked for now because their final-space weights need
-        more careful handling.
+        This method supports direct marginal true measures. Recursive marginals
+        are blocked for now because their final-space weights need more careful
+        handling.
         """
         if self._has_recursive_marginal:
             raise ParameterError(
@@ -417,8 +414,7 @@ def _weight(self, x):
         return weight
 
     def _spawn(self, sampler, dimension):
-        """
-        Spawn a new ProductMeasure with a new outer sampler.
+        """Spawn a new ProductMeasure with a new outer sampler.
 
         QMCPy's spawn mechanism creates new randomized copies of a sampler or
         true measure. ProductMeasure preserves the same marginal structure and
diff --git a/qmcpy/true_measure/scipy_wrapper.py b/qmcpy/true_measure/scipy_wrapper.py
index 9f528b175..1b6def14c 100644
--- a/qmcpy/true_measure/scipy_wrapper.py
+++ b/qmcpy/true_measure/scipy_wrapper.py
@@ -60,8 +60,7 @@ def _custom_univariate_sanity_issues(dist, n_grid=64):
 
 
 class _MVNAdapter:
-    """
-    Small adapter that turns a SciPy multivariate normal like object into
+    """Small adapter that turns a SciPy multivariate normal like object into
     something with a simple ``transform(u)`` interface.
 
     Idea:
@@ -97,8 +96,7 @@ def __init__(self, mvn_like):
         self._chol = np.linalg.cholesky(cov)
 
     def transform(self, u):
-        """
-        Take u in (0,1)^d and turn it into correlated normal samples.
+        """Take u in (0,1)^d and turn it into correlated normal samples.
         """
         u = np.asarray(u, dtype=float)
         if u.shape[-1] != self.dim:
@@ -119,8 +117,7 @@ def transform(self, u):
         return x_flat.reshape(z.shape)
 
     def logpdf(self, x):
-        """
-        Forward to the SciPy logpdf, keeping shapes tidy.
+        """Forward to the SciPy logpdf, keeping shapes tidy.
         """
         x = np.asarray(x, dtype=float)
         if x.shape[-1] != self.dim:
@@ -134,12 +131,10 @@ def logpdf(self, x):
 
 
 class SciPyWrapper(AbstractTrueMeasure):
-    r"""
-    True measure that wraps SciPy style distributions.
+    r"""True measure that wraps SciPy style distributions.
 
-    This class keeps the original behavior of SciPyWrapper with
-    independent 1D marginals and adds an optional "joint" mode for
-    dependent distributions.
+    This class keeps the original behavior of SciPyWrapper with independent 1D
+    marginals and adds an optional "joint" mode for dependent distributions.
 
     Examples:
         Independent marginals from ``scipy.stats``:
@@ -181,12 +176,9 @@ class SciPyWrapper(AbstractTrueMeasure):
     """
 
     def __init__(self, sampler, scipy_distribs):
-        """
-        Parameters
-        ----------
-        sampler : AbstractDiscreteDistribution
-            Low discrepancy or iid sampler in dimension d, living on [0,1)^d.
-        scipy_distribs :
+        """Parameters ---------- sampler : AbstractDiscreteDistribution Low
+        discrepancy or iid sampler in dimension d, living on [0,1)^d.
+        scipy_distribs:
             One of the following:
 
             - A single SciPy 1D continuous frozen distribution.
@@ -234,8 +226,7 @@ def __init__(self, sampler, scipy_distribs):
     # ------------------------------------------------------------------
 
     def _looks_like_joint(self, obj):
-        """
-        Heuristic check to decide if the user passed a joint distribution.
+        """Heuristic check to decide if the user passed a joint distribution.
 
         We treat it as "joint" if:
           - it already has a ``transform(u)`` method, or
@@ -257,8 +248,7 @@ def _looks_like_joint(self, obj):
         return False
 
     def _setup_joint(self, joint_obj):
-        """
-        Configure the wrapper in "joint" mode.
+        """Configure the wrapper in "joint" mode.
 
         Either:
           - wrap a SciPy style multivariate normal in _MVNAdapter, or
@@ -308,11 +298,10 @@ def _setup_joint(self, joint_obj):
         self.range = np.tile(np.array([-np.inf, np.inf]), (self.d, 1))
 
     def _setup_marginals(self, scipy_distribs):
-        """
-        Configure the wrapper in "independent marginals" mode.
+        """Configure the wrapper in "independent marginals" mode.
 
-        We accept a single frozen dist or a list, and we also allow
-        user defined 1D distributions that have the right methods.
+        We accept a single frozen dist or a list, and we also allow user
+        defined 1D distributions that have the right methods.
         """
         rv_cont = scipy.stats._distn_infrastructure.rv_continuous_frozen
 
@@ -376,11 +365,10 @@ def _setup_marginals(self, scipy_distribs):
         assert len(self.sds) == self.d
 
     def _sanity_check_univariate(self, dist):
-        """
-        Light sanity check for a custom 1D distribution.
+        """Light sanity check for a custom 1D distribution.
 
-        The goal is not to be perfect, just to catch obvious mistakes and
-        warn the user. We never raise here, only emit warnings.
+        The goal is not to be perfect, just to catch obvious mistakes and warn
+        the user. We never raise here, only emit warnings.
 
         We check on a grid 0.01..0.99 that:
           - ppf is finite and roughly increasing,
@@ -444,11 +432,10 @@ def _sanity_check_univariate(self, dist):
     # ------------------------------------------------------------------
 
     def _transform(self, x):
-        """
-        Map unit cube samples to the physical space.
+        """Map unit cube samples to the physical space.
 
-        For joint mode we delegate to the joint object.
-        For marginal mode we call ``ppf`` dimension wise.
+        For joint mode we delegate to the joint object. For marginal mode we
+        call ``ppf`` dimension wise.
         """
         x = np.asarray(x, dtype=float)
 
@@ -461,8 +448,7 @@ def _transform(self, x):
         return t
 
     def _weight(self, x):
-        """
-        Compute unnormalised density weights.
+        """Compute unnormalised density weights.
 
         - For joint distributions with logpdf we simply exp(logpdf).
         - For joint distributions with no density we return 1.
@@ -501,8 +487,7 @@ def _weight(self, x):
         return rho
 
     def _spawn(self, sampler, dimension):
-        """
-        Create a child true measure that shares the same distribution
+        """Create a child true measure that shares the same distribution
         configuration but uses a new sampler.
 
         We simply reuse the original ``scipy_distribs`` argument so the
diff --git a/qmcpy/true_measure/student_t.py b/qmcpy/true_measure/student_t.py
index 510b11388..56a216643 100644
--- a/qmcpy/true_measure/student_t.py
+++ b/qmcpy/true_measure/student_t.py
@@ -6,8 +6,7 @@
 
 
 class _StudentTAdapter:
-    """
-    Multivariate Student t adapter for SciPyWrapper.
+    """Multivariate Student t adapter for SciPyWrapper.
 
     - transform(u): sequential conditioning using univariate t conditionals
     - logpdf(x): forwarded to scipy.stats.multivariate_t (if available)
@@ -103,8 +102,7 @@ def logpdf(self, x):
 
 
 class StudentT(SciPyWrapper):
-    """
-    Convenience true measure: multivariate Student t.
+    """Convenience true measure: multivariate Student t.
     """
 
     def __init__(self, sampler, loc, shape, df):
diff --git a/qmcpy/true_measure/student_t_copula.py b/qmcpy/true_measure/student_t_copula.py
index 998831ced..f05b28b06 100644
--- a/qmcpy/true_measure/student_t_copula.py
+++ b/qmcpy/true_measure/student_t_copula.py
@@ -13,19 +13,18 @@
 
 
 class StudentTCopula(AbstractCopula):
-    r"""
-    Student-t copula transform with user supplied univariate marginals.
+    r"""Student-t copula transform with user supplied univariate marginals.
 
-    This TrueMeasure uses the same marginal workflow as ``GaussianCopula``,
-    but builds dependent uniforms through a multivariate Student-t copula with
+    This TrueMeasure uses the same marginal workflow as ``GaussianCopula``, but
+    builds dependent uniforms through a multivariate Student-t copula with
     correlation matrix ``correlation`` and degrees of freedom ``df``.
 
-    The transform uses the inverse Rosenblatt construction for the
-    multivariate Student-t distribution. This is equivalent in distribution to
-    the standard correlated-normal plus shared chi-square scaling construction,
-    but it only needs d deterministic uniforms from the base QMCPy sampler.
-    It is not the incorrect shortcut of applying univariate ``t.ppf``, a
-    Cholesky factor, and then univariate ``t.cdf``.
+    The transform uses the inverse Rosenblatt construction for the multivariate
+    Student-t distribution. This is equivalent in distribution to the standard
+    correlated-normal plus shared chi-square scaling construction, but it only
+    needs d deterministic uniforms from the base QMCPy sampler. It is not the
+    incorrect shortcut of applying univariate ``t.ppf``, a Cholesky factor, and
+    then univariate ``t.cdf``.
 
     Examples:
         >>> import numpy as np
@@ -66,7 +65,7 @@ class StudentTCopula(AbstractCopula):
         >>> StudentTCopula(DigitalNetB2(2, seed=7), marginals=marginals, correlation=corr, df=1)(4).shape
         (4, 2)
 
-    **References:**
+    **References: **
 
     1.  Roger B. Nelsen. *An Introduction to Copulas*. Second Edition,
         Springer Series in Statistics, Springer, 2006.
@@ -95,7 +94,8 @@ def __init__(self, sampler, marginals, correlation, df):
             marginals (list): Length d list of SciPy-like univariate
                 distributions implementing a quantile function, called ``ppf``
                 in SciPy.
-            correlation (np.ndarray): d x d positive definite correlation matrix.
+            correlation (np.ndarray): d x d positive definite correlation
+                matrix.
             df (float): Positive Student-t degrees of freedom.
         """
         self.parameters = ["marginals", "correlation", "df"]
@@ -120,8 +120,7 @@ def _parse_df(self, df):
         return df
 
     def _dependent_t_samples(self, u):
-        """
-        Map independent uniforms to a multivariate Student-t sample.
+        """Map independent uniforms to a multivariate Student-t sample.
 
         A direct scale-mixture construction would need d normal uniforms plus
         one extra chi-square uniform for the shared radial scale. Since
diff --git a/qmcpy/true_measure/triangular.py b/qmcpy/true_measure/triangular.py
index aa035ab9b..76314fd24 100644
--- a/qmcpy/true_measure/triangular.py
+++ b/qmcpy/true_measure/triangular.py
@@ -5,12 +5,10 @@
 
 
 class TriangularDistribution:
-    """
-    Triangular distribution matching scipy.stats.triang behavior.
+    """Triangular distribution matching scipy.stats.triang behavior.
 
-    Support: [loc, loc + scale]
-    Mode: loc + c*scale, with 0 < c < 1
-    Provides ppf and pdf for SciPyWrapper custom-marginal usage.
+    Support: [loc, loc + scale] Mode: loc + c*scale, with 0 < c < 1 Provides
+    ppf and pdf for SciPyWrapper custom-marginal usage.
     """
 
     def __init__(self, c=0.5, loc=0.0, scale=1.0):
diff --git a/qmcpy/true_measure/uniform.py b/qmcpy/true_measure/uniform.py
index 0dc8c496e..3897acd52 100644
--- a/qmcpy/true_measure/uniform.py
+++ b/qmcpy/true_measure/uniform.py
@@ -6,8 +6,8 @@
 
 
 class Uniform(AbstractTrueMeasure):
-    r"""
-    Uniform distribution, see [https://en.wikipedia.org/wiki/Continuous_uniform_distribution](https://en.wikipedia.org/wiki/Continuous_uniform_distribution).
+    r"""Uniform distribution, see
+    [https://en.wikipedia.org/wiki/Continuous_uniform_distribution](https://en.wikipedia.org/wiki/Continuous_uniform_distribution).
 
     Examples:
         >>> true_measure = Uniform(DigitalNetB2(2,seed=7),lower_bound=[0,.5],upper_bound=[2,3])
@@ -52,7 +52,8 @@ class Uniform(AbstractTrueMeasure):
     def __init__(self, sampler, lower_bound=0, upper_bound=1):
         r"""
         Args:
-            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]): Either
+            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
+                Either
 
                 - a discrete distribution from which to transform samples, or
                 - a true measure by which to compose a transform.
diff --git a/qmcpy/true_measure/uniform_triangle.py b/qmcpy/true_measure/uniform_triangle.py
index 624b72229..92734395d 100644
--- a/qmcpy/true_measure/uniform_triangle.py
+++ b/qmcpy/true_measure/uniform_triangle.py
@@ -6,13 +6,10 @@
 
 
 class _UniformTriangleAdapter:
-    """
-    Uniform on triangle T = {(x, y): 0 <= y <= x <= 1}
+    """Uniform on triangle T = {(x, y): 0 <= y <= x <= 1}
 
     Exact transform:
-      u1, u2 ~ U(0, 1)
-      x = sqrt(u1)
-      y = u2 * x
+      u1, u2 ~ U(0, 1) x = sqrt(u1) y = u2 * x
     """
 
     def __init__(self):
@@ -50,10 +47,9 @@ def logpdf(self, x):
 
 
 class UniformTriangle(SciPyWrapper):
-    """
-    Uniform distribution on the triangle {(x, y): 0 <= y <= x <= 1}.
+    """Uniform distribution on the triangle {(x, y): 0 <= y <= x <= 1}.
 
-    Example:
+    Examples:
     >>> tm = UniformTriangle(sampler=DigitalNetB2(2, seed=7))
     >>> x = tm(4)
     >>> x.shape
diff --git a/qmcpy/true_measure/zero_inflated_exp_uniform.py b/qmcpy/true_measure/zero_inflated_exp_uniform.py
index ce93ac1e9..0b34c0b89 100644
--- a/qmcpy/true_measure/zero_inflated_exp_uniform.py
+++ b/qmcpy/true_measure/zero_inflated_exp_uniform.py
@@ -7,14 +7,13 @@
 
 
 class _ZeroInflatedExponential:
-    """
-    One-dimensional zero-inflated exponential distribution.
+    """One-dimensional zero-inflated exponential distribution.
 
     This distribution has probability mass ``p_zero`` at zero and an
     exponential distribution with rate ``lam`` on positive values.
 
-    It implements ``ppf`` so it can be passed to ``SciPyWrapper`` as a
-    custom univariate marginal.
+    It implements ``ppf`` so it can be passed to ``SciPyWrapper`` as a custom
+    univariate marginal.
     """
 
     def __init__(self, p_zero=0.4, lam=1.5):
@@ -27,13 +26,11 @@ def __init__(self, p_zero=0.4, lam=1.5):
         self.lam = float(lam)
 
     def ppf(self, u):
-        """
-        Generalized inverse CDF of the zero-inflated exponential.
+        """Generalized inverse CDF of the zero-inflated exponential.
 
         SciPyWrapper supplies one coordinate at a time. For example:
 
-            sampler output: (n, 1)
-            ppf input:      (n,)
+        sampler output: (n, 1) ppf input:      (n,)
         """
         u = np.asarray(u, dtype=float)
 
@@ -58,8 +55,7 @@ def ppf(self, u):
 
 
 class _DeprecatedZeroInflatedExpUniform2D:
-    """
-    Adapter for the deprecated two-dimensional ``y_split`` construction.
+    """Adapter for the deprecated two-dimensional ``y_split`` construction.
     """
 
     dim = 2
@@ -108,11 +104,10 @@ def logpdf(self, x):
 
 
 class ZeroInflatedExpUniform(SciPyWrapper):
-    """
-    One-dimensional zero-inflated exponential true measure.
+    """One-dimensional zero-inflated exponential true measure.
 
-    The ``y_split`` keyword is retained temporarily for backward
-    compatibility with the deprecated two-dimensional construction.
+    The ``y_split`` keyword is retained temporarily for backward compatibility
+    with the deprecated two-dimensional construction.
 
     Examples:
     Without replications:
@@ -254,8 +249,7 @@ def __init__(self, sampler, p_zero=0.4, lam=1.5, y_split=None):
             ]
 
     def _compute_moments(self):
-        r"""
-        Closed-form mean and variance of the zero-inflated exponential.
+        r"""Closed-form mean and variance of the zero-inflated exponential.
 
         The distribution is a two component mixture that places probability
         mass $p = $ ``p_zero`` at $X = 0$ and, with probability $1 - p$, draws
@@ -267,21 +261,20 @@ def _compute_moments(self):
         component raw moments [2]. Because the point mass sits exactly at zero,
         that component adds nothing to either moment, leaving
 
-        $$\mathbb{E}[X] = (1 - p)\,\frac{1}{\lambda}, \qquad
-          \mathbb{E}[X^2] = (1 - p)\,\frac{2}{\lambda^2}.$$
+        $$\mathbb{E}[X] = (1 - p)\,\frac{1}{\lambda}, \qquad \mathbb{E}[X^2] =
+        (1 - p)\,\frac{2}{\lambda^2}.$$
 
         The variance then follows from $\operatorname{Var}[X] = \mathbb{E}[X^2]
         - \mathbb{E}[X]^2$ (equivalently, the law of total variance [3]):
 
-        $$\operatorname{Var}[X]
-          = \frac{(1 - p)(1 + p)}{\lambda^2}
-          = \frac{1 - p^2}{\lambda^2}.$$
+        $$\operatorname{Var}[X] = \frac{(1 - p)(1 + p)}{\lambda^2} = \frac{1 -
+        p^2}{\lambda^2}.$$
 
         The measure is one dimensional, so ``mean`` and ``variance`` are
         returned as length-1 arrays for consistency with the other true
         measures.
 
-        **References:**
+        **References: **
 
         1.  Exponential distribution. Wikipedia.
             [https://en.wikipedia.org/wiki/Exponential_distribution](https://en.wikipedia.org/wiki/Exponential_distribution).
@@ -293,7 +286,7 @@ def _compute_moments(self):
             [https://en.wikipedia.org/wiki/Law_of_total_variance](https://en.wikipedia.org/wiki/Law_of_total_variance).
 
         Returns:
-            tuple: Length ``1`` arrays ``(mean, variance)``.
+            Length ``1`` arrays ``(mean, variance)``.
         """
         p = self.p_zero
         lam = self.lam
diff --git a/qmcpy/util/abstraction_functions.py b/qmcpy/util/abstraction_functions.py
index e2258b1cb..4f82ef9c3 100644
--- a/qmcpy/util/abstraction_functions.py
+++ b/qmcpy/util/abstraction_functions.py
@@ -3,8 +3,7 @@
 
 
 def _univ_repr(qmc_object, abc_class_name, attributes):
-    """
-    Clean way to represent qmc_object data.
+    """Clean way to represent qmc_object data.
 
     Args:
         qmc_object (object): an qmc_object instance
@@ -12,11 +11,11 @@ def _univ_repr(qmc_object, abc_class_name, attributes):
         attributes (list): list of attributes to include
 
     Returns:
-        s (str): string representation of this qmcpy object
+        string representation of this qmcpy object
 
-    Note:
-        print(qmc_object) is equivalent to print(qmc_object.__repr__()).
-        See an abstract classes __repr__ method for example call to this method.
+    Notes:
+        print(qmc_object) is equivalent to print(qmc_object.__repr__()). See an
+        abstract classes __repr__ method for example call to this method.
     """
     with np.printoptions(precision=3, threshold=10):
         unique_attributes = []
diff --git a/qmcpy/util/data.py b/qmcpy/util/data.py
index 7ed43f8ea..ac9b06b02 100644
--- a/qmcpy/util/data.py
+++ b/qmcpy/util/data.py
@@ -12,7 +12,7 @@ def __init__(self, parameters):
     def save(self, path, compress=False, overwrite=False):
         """Save this Data object to disk using pickle.
 
-        Warning:
+        Warnings:
             ``pickle`` files are not secure against untrusted input. Only save
             and later load checkpoint files that you created yourself or that
             come from a trusted source.
@@ -21,15 +21,14 @@ def save(self, path, compress=False, overwrite=False):
             path (str or pathlib.Path): File path to save to. If
                 ``compress=True``, a ``.gz`` suffix is appended automatically
                 when not already present.
-            compress (bool, optional): Gzip-compress the saved file. Defaults
-                to False.
-            overwrite (bool, optional): If False (default), raise
-                ``FileExistsError`` when the file already exists. If True,
-                overwrite any existing file.
+            compress (bool): Gzip-compress the saved file. Defaults to False.
+            overwrite (bool): If False (default), raise ``FileExistsError``
+                when the file already exists. If True, overwrite any existing
+                file.
 
         Returns:
-            str: The final path the file was written to (may differ from
-            *path* when ``compress=True`` appends ``.gz``).
+            The final path the file was written to (may differ from *path* when
+            ``compress=True`` appends ``.gz``).
 
         Raises:
             FileExistsError: If the target path already exists and
@@ -52,17 +51,17 @@ def save(self, path, compress=False, overwrite=False):
     def load(cls, path):
         """Load a Data object from disk.
 
-        Warning:
+        Warnings:
             ``pickle`` deserialization can execute arbitrary code. Only load
             checkpoint files that you created yourself or that come from a
             trusted source.
 
         Args:
-            path (str or pathlib.Path): Path to the saved file. Files ending
-                in ``.gz`` are decompressed automatically.
+            path (str or pathlib.Path): Path to the saved file. Files ending in
+                ``.gz`` are decompressed automatically.
 
         Returns:
-            Data: The loaded Data object.
+            The loaded Data object.
         """
         path = str(path)
         open_fn = gzip.open if path.endswith(".gz") else open
diff --git a/qmcpy/util/dig_shift_invar_ops.py b/qmcpy/util/dig_shift_invar_ops.py
index 9be22a182..9936afd90 100644
--- a/qmcpy/util/dig_shift_invar_ops.py
+++ b/qmcpy/util/dig_shift_invar_ops.py
@@ -4,11 +4,10 @@
 
 
 def k4sumterm(x, t, cutoff=1e-8):
-    r"""
-    $$K_4(x) = \sum_{a=0}^{t-1} \frac{x_a}{2^{3a}}$$
+    r"""$$K_4(x) = \sum_{a=0}^{t-1} \frac{x_a}{2^{3a}}$$
 
-    where $x_a$ is the bit at index $a$ in the binary expansion of $x$
-    e.g. $x = 6$ with $t=3$ has $(x_0,x_1,x_2) = (1,1,0)$
+    where $x_a$ is the bit at index $a$ in the binary expansion of $x$ e.g. $x
+    = 6$ with $t=3$ has $(x_0,x_1,x_2) = (1,1,0)$
 
     Examples:
         >>> t = 3
@@ -35,7 +34,7 @@ def k4sumterm(x, t, cutoff=1e-8):
         t (int): Number of bits in each integer.
 
     Returns:
-        y (Union[np.ndarray torch.Tensor]): The $K_4$ sum term.
+        The $K_4$ sum term.
     """
     total = 0.0
     for a in range(0, t):
@@ -66,16 +65,17 @@ def k4sumterm(x, t, cutoff=1e-8):
 
 
 def weighted_walsh_funcs(alpha, xb, t):
-    r"""
-    Weighted walsh functions
+    r"""Weighted walsh functions
 
     $$\sum_{k=0}^\infty \mathrm{wal}_k(x) 2^{-\mu_\alpha(k)}$$
 
-    where $\mathrm{wal}_k$ is the $k^\text{th}$ Walsh function
-    and $\mu_\alpha$ is the Dick weight function which sums the first $\alpha$ largest indices of $1$ bits in the binary expansion of $k$
-    e.g. $k=13=1101_2$ has 1-bit indexes $(4,3,1)$ so
+    where $\mathrm{wal}_k$ is the $k^\text{th}$ Walsh function and $\mu_\alpha$
+    is the Dick weight function which sums the first $\alpha$ largest indices
+    of $1$ bits in the binary expansion of $k$ e.g. $k=13=1101_2$ has 1-bit
+    indexes $(4,3,1)$ so
 
-    $$\mu_1(k) = 4, \mu_2(k) = 4+3, \mu_3(k) = 4+3+1 = \mu_4(k) = \mu_5(k) = \dots$$
+    $$\mu_1(k) = 4, \mu_2(k) = 4+3, \mu_3(k) = 4+3+1 = \mu_4(k) = \mu_5(k) =
+    \dots$$
 
     Examples:
         >>> t = 3
@@ -114,21 +114,22 @@ def weighted_walsh_funcs(alpha, xb, t):
 
     Args:
         alpha (int): Weighted walsh functions order.
-        xb (Union[np.ndarray, torch.Tensor]): Integer points at which to evaluate the weighted Walsh function.
+        xb (Union[np.ndarray, torch.Tensor]): Integer points at which to
+            evaluate the weighted Walsh function.
         t (int): Number of bits in each integer in xb.
 
     Returns:
-        y (Union[np.ndarray, torch.Tensor]): Weighted Walsh function values.
+        Weighted Walsh function values.
 
-    **References:**
+    **References: **
 
-    1.  Dick, Josef.
-        "Walsh spaces containing smooth functions and quasi–Monte Carlo rules of arbitrary high order."
-        SIAM Journal on Numerical Analysis 46.3 (2008): 1519-1553.
+        1.  Dick, Josef.
+            "Walsh spaces containing smooth functions and quasi–Monte Carlo rules of arbitrary high order."
+            SIAM Journal on Numerical Analysis 46.3 (2008): 1519-1553.
 
-    2.  Dick, Josef.
-        "The decay of the Walsh coefficients of smooth functions."
-        Bulletin of the Australian Mathematical Society 80.3 (2009): 430-453.
+        2.  Dick, Josef.
+            "The decay of the Walsh coefficients of smooth functions."
+            Bulletin of the Australian Mathematical Society 80.3 (2009): 430-453.
     """
     assert isinstance(alpha, int)
     assert alpha in WEIGHTEDWALSHFUNCSPOS, (
@@ -154,8 +155,8 @@ def weighted_walsh_funcs(alpha, xb, t):
 
 
 def to_bin(x, t):
-    r"""
-    Convert floating point representations of digital net samples in base $b=2$ to binary representations.
+    r"""Convert floating point representations of digital net samples in base
+    $b=2$ to binary representations.
 
     Examples:
         >>> xf = np.random.Generator(np.random.PCG64(7)).uniform(low=0,high=1,size=(5))
@@ -178,11 +179,14 @@ def to_bin(x, t):
 
 
     Args:
-        x (Union[np.ndarray, torch.Tensor]): floating point representation of samples.
-        t (int): number of bits in binary represtnations. Typically `dnb2.t` where `isinstance(dnb2,DigitalNetB2)`.
+        x (Union[np.ndarray, torch.Tensor]): floating point representation of
+            samples.
+        t (int): number of bits in binary represtnations. Typically `dnb2.t`
+            where `isinstance(dnb2,DigitalNetB2)`.
 
     Returns:
-        xb (Unioin[np.ndarray,torch.Tensor]): binary representation of samples with `dtype` either `np.uint64` or `torch.int64`.
+        binary representation of samples with `dtype` either `np.uint64` or
+        `torch.int64`.
     """
     npt = get_npt(x)
     if npt == np:
@@ -202,8 +206,8 @@ def to_bin(x, t):
 
 
 def to_float(x, t):
-    r"""
-    Convert binary representations of digital net samples in base $b=2$ to floating point representations.
+    r"""Convert binary representations of digital net samples in base $b=2$ to
+    floating point representations.
 
     Examples:
         >>> xb = np.arange(8,dtype=np.uint64)
@@ -218,11 +222,13 @@ def to_float(x, t):
         tensor([0.0000, 0.1250, 0.2500, 0.3750, 0.5000, 0.6250, 0.7500, 0.8750])
 
     Args:
-        x (Union[np.ndarray, torch.Tensor]): binary representation of samples with `dtype` either `np.uint64` or `torch.int64`.
-        t (int): number of bits in binary represtnations. Typically `dnb2.t` where `isinstance(dnb2,DigitalNetB2)`.
+        x (Union[np.ndarray, torch.Tensor]): binary representation of samples
+            with `dtype` either `np.uint64` or `torch.int64`.
+        t (int): number of bits in binary represtnations. Typically `dnb2.t`
+            where `isinstance(dnb2,DigitalNetB2)`.
 
     Returns:
-        xf (Unioin[np.ndarray,torch.Tensor]): floating point representation of samples.
+        floating point representation of samples.
     """
     npt = get_npt(x)
     if npt == np:  # npt==torch
@@ -242,8 +248,8 @@ def to_float(x, t):
 
 
 def bin_from_numpy_to_torch(xb):
-    r"""
-    Convert `numpy.uint64` to `torch.int64`, useful for converting binary samples from `DigitalNetB2` to torch representations.
+    r"""Convert `numpy.uint64` to `torch.int64`, useful for converting binary
+    samples from `DigitalNetB2` to torch representations.
 
     Examples:
         >>> xb = np.arange(8,dtype=np.uint64)
@@ -253,10 +259,11 @@ def bin_from_numpy_to_torch(xb):
         tensor([0, 1, 2, 3, 4, 5, 6, 7])
 
     Args:
-        xb (Union[np.ndarray]): binary representation of samples with `dtype=np.uint64`
+        xb (Union[np.ndarray]): binary representation of samples with
+            `dtype=np.uint64`
 
     Returns:
-        xbtorch (Unioin[torch.Tensor]): binary representation of samples with `dtype=torch.int64`.
+        binary representation of samples with `dtype=torch.int64`.
     """
     assert xb.dtype == np.uint64
     assert xb.max() <= (2**63 - 1), "require all xb < 2^63"
diff --git a/qmcpy/util/exceptions_warnings.py b/qmcpy/util/exceptions_warnings.py
index 663791b12..5e19e1421 100644
--- a/qmcpy/util/exceptions_warnings.py
+++ b/qmcpy/util/exceptions_warnings.py
@@ -7,27 +7,23 @@
 
 
 class DimensionError(Exception):
-    """
-    Class for raising error about dimension
+    """Class for raising error about dimension
     """
 
 
 class DistributionCompatibilityError(Exception):
-    """
-    Class for raising error about incompatible distribution
+    """Class for raising error about incompatible distribution
     """
 
 
 class NotYetImplemented(Exception):
-    """
-    Class for raising error when a component has been implemented yet
+    """Class for raising error when a component has been implemented yet
     """
 
 
 class MethodImplementationError(Exception):
-    """
-    Class for raising error when an abstract method has not been implemented
-    in the child class.
+    """Class for raising error when an abstract method has not been
+    implemented in the child class.
     """
 
     def __init__(self, subclass, method_name):
@@ -41,30 +37,25 @@ def __init__(self, subclass, method_name):
 
 
 class ParameterError(Exception):
-    """
-    Class for raising error about input parameters
+    """Class for raising error about input parameters
     """
 
 
 class ParameterWarning(Warning):
-    """
-    Class for issuing warnings about unacceptable parameters
+    """Class for issuing warnings about unacceptable parameters
     """
 
 
 class MaxSamplesWarning(Warning):
-    """
-    Class for issuing warning about using maximum number of data samples
+    """Class for issuing warning about using maximum number of data samples
     """
 
 
 class MaxLevelsWarning(Warning):
-    """
-    Class for issuing warning about using maximum number of data samples
+    """Class for issuing warning about using maximum number of data samples
     """
 
 
 class CubatureWarning(Warning):
-    """
-    Class for issuing warnings throughout cubature algorithms
+    """Class for issuing warnings throughout cubature algorithms
     """
diff --git a/qmcpy/util/latnetbuilder_linker.py b/qmcpy/util/latnetbuilder_linker.py
index a37536682..d2b4ce197 100644
--- a/qmcpy/util/latnetbuilder_linker.py
+++ b/qmcpy/util/latnetbuilder_linker.py
@@ -5,17 +5,16 @@
 def latnetbuilder_linker(lnb_dir="./", out_dir="./", fout_prefix="lnb4qmcpy"):
     """
     Args:
-        lnb_dir (str): relative path to directory where `outputMachine.txt` is stored
-            e.g. 'my_lnb/poly_lat/'
+        lnb_dir (str): relative path to directory where `outputMachine.txt` is
+            stored e.g. 'my_lnb/poly_lat/'
         out_dir (str): relative path to directory where output should be stored
             e.g. 'my_lnb/poly_lat_qmcpy/'
-        fout_prefix (str): start of output file name.
-            e.g. 'my_poly_lat_vec'
+        fout_prefix (str): start of output file name. e.g. 'my_poly_lat_vec'
 
     Returns:
-        str: path to file which can be passed into QMCPy's Lattice or Sobol' in order to use
-             the linked latnetbuilder generating vector/matrix
-             e.g. 'my_poly_lat_vec.10.16.npy'
+        path to file which can be passed into QMCPy's Lattice or Sobol' in
+        order to use the linked latnetbuilder generating vector/matrix e.g.
+        'my_poly_lat_vec.10.16.npy'
 
     Adapted from latnetbuilder parser:
         https://github.com/umontreal-simul/latnetbuilder/blob/master/python-wrapper/latnetbuilder/parse_output.py#L74
diff --git a/qmcpy/util/mlmc_test.py b/qmcpy/util/mlmc_test.py
index 5e421f31b..59a358315 100644
--- a/qmcpy/util/mlmc_test.py
+++ b/qmcpy/util/mlmc_test.py
@@ -10,18 +10,17 @@ def mlmc_test(
     levels_min = 2,
     levels_max = 10,
     ):
-    r"""
-    Multilevel Monte Carlo test routine.
+    r"""Multilevel Monte Carlo test routine.
 
     Examples:
         >>> fo = qp.FinancialOption(
         ...     sampler=qp.IIDStdUniform(seed=7),
         ...     option = "ASIAN",
         ...     asian_mean = "GEOMETRIC",
-        ...     volatility = 0.2, 
-        ...     start_price = 100, 
-        ...     strike_price = 100, 
-        ...     interest_rate = 0.05, 
+        ...     volatility = 0.2,
+        ...     start_price = 100,
+        ...     strike_price = 100,
+        ...     interest_rate = 0.05,
         ...     t_final = 1)
         >>> print('Exact Value: %s'%fo.get_exact_value_inf_dim())
         Exact Value: 5.546818633789201
@@ -43,12 +42,12 @@ def mlmc_test(
             gamma = 1.000000  (exponent for MLMC cost)
         MLMC complexity tests
             rmse_tol       value          mlmc_cost      std_cost       savings        N_l
-            5.000e-03      5.545e+00      3.339e+07      1.038e+08      3.11           8605392      1566846      559701       198886       70359        
-            1.000e-02      5.539e+00      7.272e+06      1.243e+07      1.71           2009192      365451       130781       46623        
-            2.000e-02      5.549e+00      1.827e+06      3.108e+06      1.70           503397       91821        33196        11736        
-            5.000e-02      5.474e+00      2.324e+05      2.556e+05      1.10           71432        13143        4617         
-            1.000e-01      5.466e+00      6.220e+04      6.389e+04      1.03           19477        3361         1225         
-        
+            5.000e-03      5.545e+00      3.339e+07      1.038e+08      3.11           8605392      1566846      559701       198886       70359
+            1.000e-02      5.539e+00      7.272e+06      1.243e+07      1.71           2009192      365451       130781       46623
+            2.000e-02      5.549e+00      1.827e+06      3.108e+06      1.70           503397       91821        33196        11736
+            5.000e-02      5.474e+00      2.324e+05      2.556e+05      1.10           71432        13143        4617
+            1.000e-01      5.466e+00      6.220e+04      6.389e+04      1.03           19477        3361         1225
+
     Args:
         integrand (AbstractIntegrand): multilevel integrand
         n (int): number of samples for convergence tests
diff --git a/qmcpy/util/plot_functions.py b/qmcpy/util/plot_functions.py
index 6c7c15ff4..3f25b756d 100644
--- a/qmcpy/util/plot_functions.py
+++ b/qmcpy/util/plot_functions.py
@@ -20,19 +20,27 @@ def plot_proj(
 ):
     """
     Args:
-        sampler (DiscreteDistribution,TrueMeasure): The generator of samples to be plotted.
-        n (Union[int, list]): The number of samples or a list of samples(used for extensibility) to be plotted.
-        d_horizontal (Union[int, list]): The dimension or list of dimensions to be plotted on the horizontal axes.
-        d_vertical (Union[int, list]): The dimension or list of dimensions to be plotted on the vertical axes.
-        math_ind (bool): Setting to `True` will enable user to pass in math indices.
+        sampler (DiscreteDistribution, TrueMeasure): The generator of samples
+            to be plotted.
+        n (Union[int, list]): The number of samples or a list of samples(used
+            for extensibility) to be plotted.
+        d_horizontal (Union[int, list]): The dimension or list of dimensions to
+            be plotted on the horizontal axes.
+        d_vertical (Union[int, list]): The dimension or list of dimensions to
+            be plotted on the vertical axes.
+        math_ind (bool): Setting to `True` will enable user to pass in math
+            indices.
         marker_size (float): The marker size (typographic points are 1/72 in.).
         figfac (float): The figure size factor.
         fig_title (str): The title of the figure.
-        axis_pad (float): The padding of the axis so that points on the boundaries can be seen.
+        axis_pad (float): The padding of the axis so that points on the
+            boundaries can be seen.
         want_grid (bool): Setting to `True` will enable grid on the plot.
         font_family (str): The font family of the plot.
-        where_title (float): the position of the title on the plot. Default value is 1.
-        **kwargs (dict): Additional keyword arguments passed to `matplotlib.pyplot.scatter`.
+        where_title (float): the position of the title on the plot. Default
+            value is 1.
+        **kwargs (dict): Additional keyword arguments passed to
+            `matplotlib.pyplot.scatter`.
     """
     try:
         import matplotlib.pyplot as plt
diff --git a/qmcpy/util/shift_invar_ops.py b/qmcpy/util/shift_invar_ops.py
index 35ba5cac8..46769cf08 100644
--- a/qmcpy/util/shift_invar_ops.py
+++ b/qmcpy/util/shift_invar_ops.py
@@ -11,12 +11,12 @@ class Polynomial:
     """
 
     def __init__(self, coeffs):
-        """
-        Polynomial evaluation with Horner's rule
+        """Polynomial evaluation with Horner's rule
 
         Args:
             coeffs (list or np.ndarray or torch.Tensor): vector of coefficients
-            e.g. coeffs = [a, b, c] corresponds to the quadratic polynomial a*x**2 + b*x + c
+            e.g. coeffs = [a, b, c] corresponds to the quadratic polynomial
+            a*x**2 + b*x + c
         """
         assert isinstance(coeffs, list)
         self.order = len(coeffs)
@@ -53,8 +53,7 @@ def __call__(self, x):
 
 
 def bernoulli_poly(n, x):
-    r"""
-    $n^\text{th}$ Bernoulli polynomial
+    r"""$n^\text{th}$ Bernoulli polynomial
 
     Examples:
         >>> x = np.arange(6).reshape((2,3))/6
@@ -103,10 +102,11 @@ def bernoulli_poly(n, x):
 
     Args:
         n (int): Polynomial order.
-        x (Union[np.ndarray, torch.Tensor]): Points at which to evaluate the Bernoulli polynomial.
+        x (Union[np.ndarray, torch.Tensor]): Points at which to evaluate the
+            Bernoulli polynomial.
 
     Returns:
-        y (Union[np.ndarray, torch.Tensor]): Bernoulli polynomial values.
+        Bernoulli polynomial values.
     """
     assert isinstance(n, int)
     assert n in BERNOULLIPOLYSDICT, "n = %d not in BERNOULLIPOLYSDICT" % n

From 8db3ee76e9fc36f50271504bb6640bea1bd606b9 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Sun, 6 Sep 2026 23:02:00 +0800
Subject: [PATCH 17/51] Fixed the doctest failure due to white spaces

---
 qmcpy/util/mlmc_test.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/qmcpy/util/mlmc_test.py b/qmcpy/util/mlmc_test.py
index 59a358315..158865178 100644
--- a/qmcpy/util/mlmc_test.py
+++ b/qmcpy/util/mlmc_test.py
@@ -159,5 +159,7 @@ def mlmc_test(
         mlmc_cost = sum(nl*cl)
         idx = np.minimum(len(var2),len(nl))-1
         std_cost = var2[idx]*cl[-1] / ((1.-theta)*rmse_tols[i]**2)
-        print('    %-15.3e%-15.3e%-15.3e%-15.3e%-15.2f%s'\
-            %(rmse_tols[i], p, mlmc_cost, std_cost, std_cost/mlmc_cost,''.join('%-13d'%nli for nli in nl)))
+        output = '    %-15.3e%-15.3e%-15.3e%-15.3e%-15.2f%s' \
+            % (rmse_tols[i], p, mlmc_cost, std_cost, std_cost/mlmc_cost,
+               ''.join('%-13d' % nli for nli in nl))
+        print(output.rstrip())

From 81afce5448e3ad18690e45df8123fd7788ef12c4 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Sun, 6 Sep 2026 23:05:56 +0800
Subject: [PATCH 18/51] Introduce tool for converting assert statements

---
 docs/good_practices.md          |   4 +
 makefile                        |  98 ++++++----
 pyproject.toml                  |   2 +
 scripts/convert_asserts.py      | 317 ++++++++++++++++++++++++++++++++
 test/test_sr_convert_asserts.py | 138 ++++++++++++++
 5 files changed, 521 insertions(+), 38 deletions(-)
 create mode 100644 scripts/convert_asserts.py
 create mode 100644 test/test_sr_convert_asserts.py

diff --git a/docs/good_practices.md b/docs/good_practices.md
index ca5ecfc72..ade5c308d 100644
--- a/docs/good_practices.md
+++ b/docs/good_practices.md
@@ -95,6 +95,10 @@ Several reviews focused on avoidable cleanup that is easy to catch before reques
 - Remove unused imports, trailing whitespace, and other style-only churn before requesting review.
 - Use explicit runtime exceptions such as `ParameterError` for invalid user inputs instead of relying on `assert` statements in production code.
 
+For a mechanical first pass, `make check_asserts_changed` reports standalone assertions in production Python files changed relative to `ASSERT_DIFF_BASE` (default `develop`) and returns nonzero when conversions are available. `make convert_asserts_changed` uses the open-source [LibCST](https://libcst.readthedocs.io/) codemod library to convert those assertions to explicit `AssertionError` raises while preserving comments and formatting. Use `make convert_asserts ASSERT_PATH=path/to/file.py` for a specific file or directory.
+
+`AssertionError` is the conservative default because it preserves the original exception class and message while making validation active under `python -O`. For a reviewed set of input checks, a developer may select an exception already imported by every target file, for example `make convert_asserts ASSERT_PATH=path/to/file.py ASSERT_EXCEPTION=ParameterError`. The tool does not infer whether a condition represents invalid input, a dimension mismatch, or an internal invariant; choose `ParameterError`, `DimensionError`, `ValueError`, or another public exception only after reviewing the API contract. Assertions sharing a semicolon-delimited line with another statement, or appearing in a one-line compound suite such as `if condition: assert invariant`, are reported but skipped. Always inspect the complete diff and run the focused tests after conversion.
+
 ## Add Demos or Blogs as Notebooks
 
 User-facing methods, new workflows, and mathematically important additions should usually come with an executable notebook.
diff --git a/makefile b/makefile
index 0bf7224f7..164072323 100644
--- a/makefile
+++ b/makefile
@@ -1,10 +1,13 @@
+# Prefer an active environment, then the repository's conventional qmcpy Conda
+# environment, before falling back to a system interpreter. Override with
+# ``make PYTHON=/path/to/python <target>`` when needed.
+PYTHON ?= $(shell command -v python 2>/dev/null || { [ -n "$$CONDA_PREFIX" ] && command -v "$$CONDA_PREFIX/bin/python" 2>/dev/null; } || { command -v conda >/dev/null 2>&1 && conda run -n qmcpy python -c 'import sys; print(sys.executable)' 2>/dev/null; } || command -v python3 2>/dev/null)
 # Emit pytest-xdist argument if available; can be overridden on the make command line
-PYTEST_XDIST ?= $(shell python scripts/pytest_xdist.py 2>/dev/null)
+PYTEST_XDIST ?= $(shell $(PYTHON) scripts/pytest_xdist.py 2>/dev/null)
 PYTEST ?=
-PYTHON ?= python3
 SMOKE_CODE_CELLS ?= 2
 WITH_MPMC ?= 0
-HAS_MPMC ?= $(shell python -c "import importlib.util; mods=('torch','pyg_lib','torch_geometric'); print(int(all(importlib.util.find_spec(m) is not None for m in mods)))" 2>/dev/null || echo 0)
+HAS_MPMC ?= $(shell $(PYTHON) -c "import importlib.util; mods=('torch','pyg_lib','torch_geometric'); print(int(all(importlib.util.find_spec(m) is not None for m in mods)))" 2>/dev/null || echo 0)
 
 # set environment variable for documentation
 export JUPYTER_PLATFORM_DIRS=1
@@ -51,6 +54,26 @@ TEST_STYLE_PATH ?= test
 check_test_style:
 	@$(PYTHON) scripts/check_test_style.py $(TEST_STYLE_PATH) $(STRICT)
 
+ASSERT_PATH ?= qmcpy
+ASSERT_DIFF_BASE ?= develop
+ASSERT_EXCEPTION ?= AssertionError
+ASSERT_CONVERT_ARGS ?=
+
+check_assert_codemod_dependency:
+	@$(PYTHON) -c "import libcst" 2>/dev/null || { \
+		echo 'Missing LibCST. Install the test tools with: $(PYTHON) -m pip install -e ".[test]"'; \
+		exit 127; \
+	}
+
+convert_asserts: check_assert_codemod_dependency
+	$(PYTHON) scripts/convert_asserts.py --exception "$(ASSERT_EXCEPTION)" $(ASSERT_CONVERT_ARGS) $(ASSERT_PATH)
+
+convert_asserts_changed: check_assert_codemod_dependency
+	$(PYTHON) scripts/convert_asserts.py --diff "$(ASSERT_DIFF_BASE)" --exception "$(ASSERT_EXCEPTION)" $(ASSERT_CONVERT_ARGS)
+
+check_asserts_changed: check_assert_codemod_dependency
+	$(PYTHON) scripts/convert_asserts.py --diff "$(ASSERT_DIFF_BASE)" --exception "$(ASSERT_EXCEPTION)" --check $(ASSERT_CONVERT_ARGS)
+
 DOCSTRING_PATH ?= qmcpy
 DOCSTRING_BASE ?= origin/develop
 PYDOCLINT ?= pydoclint
@@ -138,7 +161,7 @@ check_docstring_changed:
 doctests_minimal: ensure_artifacts
 	@mkdir -p $(DOCTEST_COV_DIR)/minimal
 	COVERAGE_FILE=$(DOCTEST_COV_DIR)/minimal/.coverage \
-	python -m pytest $(PYTEST_XDIST) -x --cov qmcpy/ --cov-report term --cov-report json:$(DOCTEST_COV_DIR)/minimal/coverage.json --no-header --cov-append \
+	$(PYTHON) -m pytest $(PYTEST_XDIST) -x --cov qmcpy/ --cov-report term --cov-report json:$(DOCTEST_COV_DIR)/minimal/coverage.json --no-header --cov-append \
 		--doctest-modules qmcpy/ \
 		--ignore qmcpy/fast_transform/ft_pytorch.py \
 		--ignore qmcpy/stopping_criterion/pf_gp_ci.py \
@@ -153,7 +176,7 @@ doctests_minimal: ensure_artifacts
 doctests_torch: ensure_artifacts
 	@mkdir -p $(DOCTEST_COV_DIR)/torch
 	COVERAGE_FILE=$(DOCTEST_COV_DIR)/torch/.coverage \
-	python -m pytest $(PYTEST_XDIST) -x --cov qmcpy/ --cov-report term --cov-report json:$(DOCTEST_COV_DIR)/torch/coverage.json --no-header --cov-append \
+	$(PYTHON) -m pytest $(PYTEST_XDIST) -x --cov qmcpy/ --cov-report term --cov-report json:$(DOCTEST_COV_DIR)/torch/coverage.json --no-header --cov-append \
 		--doctest-modules qmcpy/fast_transform/ft_pytorch.py \
 		--doctest-modules qmcpy/kernel/*.py \
 		--doctest-modules qmcpy/util/dig_shift_invar_ops.py \
@@ -162,26 +185,26 @@ doctests_torch: ensure_artifacts
 doctests_gpytorch: ensure_artifacts
 	@mkdir -p $(DOCTEST_COV_DIR)/gpytorch
 	COVERAGE_FILE=$(DOCTEST_COV_DIR)/gpytorch/.coverage \
-	python -m pytest $(PYTEST_XDIST) -x --cov qmcpy/ --cov-report term --cov-report json:$(DOCTEST_COV_DIR)/gpytorch/coverage.json --no-header --cov-append \
+	$(PYTHON) -m pytest $(PYTEST_XDIST) -x --cov qmcpy/ --cov-report term --cov-report json:$(DOCTEST_COV_DIR)/gpytorch/coverage.json --no-header --cov-append \
 		--doctest-modules qmcpy/stopping_criterion/pf_gp_ci.py \
 
 doctests_botorch: ensure_artifacts
 	@mkdir -p $(DOCTEST_COV_DIR)/botorch
 	COVERAGE_FILE=$(DOCTEST_COV_DIR)/botorch/.coverage \
-	python -m pytest $(PYTEST_XDIST) -x --cov qmcpy/ --cov-report term --cov-report json:$(DOCTEST_COV_DIR)/botorch/coverage.json --no-header --cov-append \
+	$(PYTHON) -m pytest $(PYTEST_XDIST) -x --cov qmcpy/ --cov-report term --cov-report json:$(DOCTEST_COV_DIR)/botorch/coverage.json --no-header --cov-append \
 		--doctest-modules qmcpy/integrand/hartmann6d.py \
 
 doctests_mpmc:
 	@mkdir -p $(DOCTEST_COV_DIR)/mpmc
 	COVERAGE_FILE=$(DOCTEST_COV_DIR)/mpmc/.coverage \
-	python -m pytest $(PYTEST_XDIST) -x --cov qmcpy/ --cov-report term --cov-report json:$(DOCTEST_COV_DIR)/mpmc/coverage.json --no-header --cov-append \
+	$(PYTHON) -m pytest $(PYTEST_XDIST) -x --cov qmcpy/ --cov-report term --cov-report json:$(DOCTEST_COV_DIR)/mpmc/coverage.json --no-header --cov-append \
 		--doctest-modules qmcpy/discrete_distribution/mpmc/*.py \
 
 doctests_umbridge: ensure_artifacts # https://github.com/UM-Bridge/umbridge/issues/96
 	@mkdir -p $(DOCTEST_COV_DIR)/umbridge
 	@docker --version
 	COVERAGE_FILE=$(DOCTEST_COV_DIR)/umbridge/.coverage \
-	python -m pytest $(PYTEST_XDIST) -x --cov qmcpy/ --cov-report term --cov-report json:$(DOCTEST_COV_DIR)/umbridge/coverage.json --no-header --cov-append \
+	$(PYTHON) -m pytest $(PYTEST_XDIST) -x --cov qmcpy/ --cov-report term --cov-report json:$(DOCTEST_COV_DIR)/umbridge/coverage.json --no-header --cov-append \
 		--doctest-modules qmcpy/integrand/umbridge_wrapper.py \
 
 doctests_markdown:
@@ -201,13 +224,8 @@ doctests: doctests_markdown doctests_minimal doctests_torch doctests_gpytorch do
 ##########################################################
 unittests: ensure_artifacts
 	@mkdir -p $(UNIT_COV_DIR)
-	@PYTHON_BIN=$$(command -v python 2>/dev/null || { [ -n "$$CONDA_PREFIX" ] && command -v "$$CONDA_PREFIX/bin/python" 2>/dev/null; } || { command -v conda >/dev/null 2>&1 && conda run -n qmcpy python -c 'import sys; print(sys.executable)' 2>/dev/null; } || command -v python3 2>/dev/null); \
-	if [ -z "$$PYTHON_BIN" ]; then \
-		echo "No Python interpreter found (tried: python, $$CONDA_PREFIX/bin/python, python3)."; \
-		exit 127; \
-	fi; \
-	COVERAGE_FILE=$(UNIT_COV_DIR)/.coverage \
-	"$$PYTHON_BIN" -m pytest $(PYTEST_XDIST) -x $(PYTEST_EXTRA_ARGS) \
+	@COVERAGE_FILE=$(UNIT_COV_DIR)/.coverage \
+	$(PYTHON) -m pytest $(PYTEST_XDIST) -x $(PYTEST_EXTRA_ARGS) \
 		--cov=qmcpy \
 		--cov-report term \
 		--cov-report json:$(UNIT_COV_DIR)/coverage.json \
@@ -221,7 +239,7 @@ unittests: ensure_artifacts
 unittests_core: ensure_artifacts
 	@mkdir -p $(UNIT_COV_DIR)
 	COVERAGE_FILE=$(UNIT_COV_DIR)/.coverage \
-	python -m pytest $(PYTEST_XDIST) $(PYTEST_EXTRA_ARGS) \
+	$(PYTHON) -m pytest $(PYTEST_XDIST) $(PYTEST_EXTRA_ARGS) \
 		--cov=qmcpy \
 		--cov-report term \
 		--cov-report json:$(UNIT_COV_DIR)/coverage.json \
@@ -236,7 +254,7 @@ tests_no_docker_no_mpmc: doctests_no_docker_no_mpmc unittests coverage
 ##########################################################
 generate_booktests:
 	@echo "\nGenerating missing booktest files..."
-	cd test/booktests/ && python generate_test.py --check-missing
+	cd test/booktests/ && $(PYTHON) generate_test.py --check-missing
 
 check_colab_notebooks:  # faster
 	$(PYTHON) -m scripts.check_colab_notebooks --strict
@@ -345,11 +363,11 @@ booktests_no_docker: check_booktests generate_booktests clean_local_only_files e
 	if [ -z "$(TESTS)" ]; then \
 		PYTHONWARNINGS="ignore::UserWarning,ignore::DeprecationWarning,ignore::FutureWarning,ignore::ImportWarning" \
 		COVERAGE_FILE=../../$(BOOKTEST_COV_DIR)/.coverage \
-		python -W ignore -m coverage run --append --source=../../qmcpy/ -m unittest discover -s . -p "*.py" -v --failfast; \
+		$(PYTHON) -W ignore -m coverage run --append --source=../../qmcpy/ -m unittest discover -s . -p "*.py" -v --failfast; \
 	else \
 		PYTHONWARNINGS="ignore::UserWarning,ignore::DeprecationWarning,ignore::FutureWarning,ignore::ImportWarning" \
 		COVERAGE_FILE=../../$(BOOKTEST_COV_DIR)/.coverage \
-		python -W ignore -m coverage run --append --source=../../qmcpy/ -m unittest $(TESTS) -v --failfast; \
+		$(PYTHON) -W ignore -m coverage run --append --source=../../qmcpy/ -m unittest $(TESTS) -v --failfast; \
 	fi && \
 	cd ../..
 
@@ -359,7 +377,7 @@ booktests_parallel_no_docker: check_booktests generate_booktests clean_local_onl
 	cd test/booktests/ && \
 	rm -fr *.eps *.jpg *.pdf *.png *.part *.txt *.log && rm -fr logs && rm -fr runinfo prob_failure_gp_ci_plots && \
 	PYTHONWARNINGS="ignore::UserWarning,ignore::DeprecationWarning,ignore::FutureWarning,ignore::ImportWarning" \
-	python parsl_test_runner.py $(TESTS) -v --failfast && \
+	$(PYTHON) parsl_test_runner.py $(TESTS) -v --failfast && \
 	cd ../..
 
 # Windows-compatible parallel booktests using pytest-xdist instead of Parsl
@@ -368,7 +386,7 @@ booktests_parallel_pytest: check_booktests generate_booktests clean_local_only_f
 	cd test/booktests/ && \
 	PYTHONWARNINGS="ignore::UserWarning,ignore::DeprecationWarning,ignore::FutureWarning,ignore::ImportWarning" \
 	COVERAGE_FILE=../../$(BOOKTEST_COV_DIR)/.coverage \
-	python -W ignore -m pytest $(PYTEST_XDIST) $(PYTEST) -v tb_*.py \
+	$(PYTHON) -W ignore -m pytest $(PYTEST_XDIST) $(PYTEST) -v tb_*.py \
 		--cov=qmcpy \
 		--cov-append \
 		--cov-report=term \
@@ -395,19 +413,23 @@ tests_no_docker:
 # Fast test target: run doctests, unittests, booktests concurrently
 tests_fast:
 	@echo "Running fast tests: doctests and unittests concurrently (splitting CPU cores)."
-	@make clean_local_only_files clean_coverage && \
+	@set -e; \
+	$(MAKE) clean_local_only_files clean_coverage; \
 	if [ "$(WITH_MPMC)" = "1" ] || [ "$(HAS_MPMC)" = "1" ]; then \
 		DOCTESTS_TARGET=doctests_no_docker; \
 		UNITTESTS_ARGS=""; \
 	else \
 		DOCTESTS_TARGET=doctests_no_docker_no_mpmc; \
 		UNITTESTS_ARGS="--ignore=test/test_dd_mpmc.py"; \
-	fi && \
-	set -e && \
-	$(MAKE) $$DOCTESTS_TARGET & \
-	$(MAKE) unittests PYTEST_EXTRA_ARGS="$$UNITTESTS_ARGS" & \
-	$(MAKE) booktests_parallel_no_docker  & \
-	wait
+	fi; \
+	$(MAKE) $$DOCTESTS_TARGET & doctests_pid=$$!; \
+	$(MAKE) unittests PYTEST_EXTRA_ARGS="$$UNITTESTS_ARGS" & unittests_pid=$$!; \
+	$(MAKE) booktests_parallel_no_docker & booktests_pid=$$!; \
+	status=0; \
+	wait $$doctests_pid || status=$$?; \
+	wait $$unittests_pid || status=$$?; \
+	wait $$booktests_pid || status=$$?; \
+	exit $$status
 	$(MAKE) coverage
 
 ##########################################################
@@ -422,7 +444,7 @@ coverage: ensure_artifacts # https://github.com/marketplace/actions/coverage-bad
 	@echo "============================================================"
 	@echo ""
 	COVERAGE_FILE=$(UNIT_COV_DIR)/.coverage \
-	python -m coverage report -m
+	$(PYTHON) -m coverage report -m
 
 combine-coverage-local: ensure_artifacts  # Combine coverage files and build reports locally (NOT official)
 	@echo "Combining coverage files from $(COV_DIR)/ into coverage-data/ and generating reports"
@@ -441,7 +463,7 @@ combine-coverage-local: ensure_artifacts  # Combine coverage files and build rep
 		echo "No coverage data found. Run tests first (e.g., make unittests / make doctests / make booktests_*)"; \
 		exit 1; \
 	fi; \
-	python scripts/combine_coverage.py --dir coverage-data --outdir coverage_html --keep
+	$(PYTHON) scripts/combine_coverage.py --dir coverage-data --outdir coverage_html --keep
 
 coverage_html: ensure_artifacts
 	@mkdir -p $(UNIT_COV_DIR)/html
@@ -452,7 +474,7 @@ coverage_html: ensure_artifacts
 	@echo "============================================================"
 	@echo ""
 	COVERAGE_FILE=$(UNIT_COV_DIR)/.coverage \
-	python -m coverage html -d $(UNIT_COV_DIR)/html
+	$(PYTHON) -m coverage html -d $(UNIT_COV_DIR)/html
 
 delcoverage:
 	@rm -f .coverage coverage.json test/booktests/.coverage
@@ -515,7 +537,7 @@ copydocs:  # mkdocs only looks for content in the docs/ folder, so we have to co
 	@./scripts/render_paper_for_mkdocs.sh
 	@cp test/booktests/README.md docs/booktests.md
 	@cp test/README.md docs/tests.md
-	@python scripts/make_qmc_software_page.py
+	@$(PYTHON) scripts/make_qmc_software_page.py
 	@mkdir -p docs/stats
 	@cp stats/pypi_downloads.md docs/stats/pypi_downloads.md
 	@cp docs/assets/logos/qmcpy_logo.png docs/apple-touch-icon.png
@@ -538,19 +560,19 @@ docnouml: copydocs runmkdocserve
 
 check_links: copydocs  # internal links + anchors only; fast, no network, safe for CI
 	@NO_MKDOCS_2_WARNING=1 mkdocs build -q -d site
-	@python scripts/check_links.py site
+	@$(PYTHON) scripts/check_links.py site
 
 check_links_external: copydocs  # also checks http/https links; slow and network-flaky, run locally
 	@NO_MKDOCS_2_WARNING=1 mkdocs build -q -d site
-	@python scripts/check_links.py site --external
+	@$(PYTHON) scripts/check_links.py site --external
 
 # The targets above check links inside the new site; these check the other
 # direction -- already-published URLs that would 404 after the next deploy.
 check_removed_urls: copydocs  # fetches the deployed sitemap.xml; needs network
-	@python scripts/check_removed_urls.py
+	@$(PYTHON) scripts/check_removed_urls.py
 
 check_removed_urls_verify: copydocs  # also HTTP-checks every redirect target
-	@python scripts/check_removed_urls.py --verify-redirects
+	@$(PYTHON) scripts/check_removed_urls.py --verify-redirects
 
 ##########################################################
 # PEP8
@@ -583,7 +605,7 @@ pep8: update_pep8_badge
 update_pep8_badge:
 	@mkdir -p $(LOG_DIR) docs/assets
 	@make check_pep8 > $(LOG_DIR)/pylint.out
-	@python3 scripts/update_pep8_badge.py $(LOG_DIR)/pylint.out docs/assets/pep8-badge.json docs/assets/pep8-badge.svg
+	@$(PYTHON) scripts/update_pep8_badge.py $(LOG_DIR)/pylint.out docs/assets/pep8-badge.json docs/assets/pep8-badge.svg
 
 
 ##########################################################
diff --git a/pyproject.toml b/pyproject.toml
index 6e86e376c..4b009427b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -85,6 +85,7 @@ mpmc = [
 test = [
     "pytest >= 9.0.3",
     "pytest-cov >= 6.1.1",
+    "libcst >= 1.9.0, < 2.0", # formatting-preserving source codemods
     "phmutest >= 1.0.1",
     "pytest-accept >= 0.1.10",
     "testbook >= 0.4.2",
@@ -109,6 +110,7 @@ test = [
 test_core = [
     "pytest >= 7.0",
     "pytest-cov >= 4.0",
+    "libcst >= 1.9.0, < 2.0", # required by source-codemod unit tests
     "pytest-xdist >= 3.0",
     "scikit-learn >= 1.0.0",
     "pandas >= 1.3.0",
diff --git a/scripts/convert_asserts.py b/scripts/convert_asserts.py
new file mode 100644
index 000000000..cab1c7e6d
--- /dev/null
+++ b/scripts/convert_asserts.py
@@ -0,0 +1,317 @@
+#!/usr/bin/env python3
+"""Convert Python assertions to explicit exception raises.
+
+The codemod preserves formatting and comments with LibCST. By default it
+converts ``assert condition, message`` to an explicit ``AssertionError`` so
+the validation is not removed by ``python -O``. A developer may select a
+different exception that is already in scope, but the tool deliberately does
+not guess domain-specific exception classes.
+"""
+from __future__ import annotations
+
+import argparse
+import re
+import subprocess
+import sys
+from collections import Counter
+from dataclasses import dataclass
+from pathlib import Path
+
+import libcst as cst
+from libcst.metadata import MetadataWrapper, PositionProvider
+
+
+EXCEPTION_NAME = re.compile(
+    r"^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*$"
+)
+
+
+@dataclass(frozen=True)
+class SourceResult:
+    """Result of transforming one source string."""
+
+    source: str
+    converted_lines: tuple[int, ...]
+    skipped_lines: tuple[int, ...]
+
+
+@dataclass(frozen=True)
+class FileResult:
+    """Result of inspecting one Python file."""
+
+    path: Path
+    converted_lines: tuple[int, ...]
+    skipped_lines: tuple[int, ...]
+    changed: bool
+
+
+def _parenthesize(expression: cst.BaseExpression) -> cst.BaseExpression:
+    """Parenthesize an expression unless it is already parenthesized."""
+    if expression.lpar:
+        return expression
+    return expression.with_changes(
+        lpar=(cst.LeftParen(),),
+        rpar=(cst.RightParen(),),
+    )
+
+
+def _exception_call(
+    exception: cst.BaseExpression,
+    message: cst.BaseExpression,
+) -> cst.Call:
+    """Build an exception call while reusing message-parenthesis whitespace."""
+    if (
+        not message.lpar
+        or not message.rpar
+        or isinstance(message, (cst.Tuple, cst.Yield))
+    ):
+        return cst.Call(func=exception, args=[cst.Arg(message)])
+
+    opening = message.lpar[0]
+    closing = message.rpar[-1]
+    unwrapped_message = message.with_changes(
+        lpar=message.lpar[1:],
+        rpar=message.rpar[:-1],
+    )
+    return cst.Call(
+        func=exception,
+        args=[
+            cst.Arg(
+                unwrapped_message,
+                whitespace_after_arg=closing.whitespace_before,
+            )
+        ],
+        whitespace_before_args=opening.whitespace_after,
+    )
+
+
+class ConvertAssertTransformer(cst.CSTTransformer):
+    """Rewrite standalone assertion statements as explicit conditional raises."""
+
+    METADATA_DEPENDENCIES = (PositionProvider,)
+
+    def __init__(self, exception: str):
+        self.exception = cst.parse_expression(exception)
+        self.seen_lines = []
+        self.converted_lines = []
+
+    def visit_Assert(self, node: cst.Assert) -> None:
+        """Record every assertion, including forms that cannot be rewritten."""
+        position = self.get_metadata(PositionProvider, node)
+        self.seen_lines.append(position.start.line)
+
+    def leave_SimpleStatementLine(
+        self,
+        original_node: cst.SimpleStatementLine,
+        updated_node: cst.SimpleStatementLine,
+    ) -> cst.BaseStatement:
+        """Rewrite an assert when it is the line's only small statement."""
+        if len(updated_node.body) != 1:
+            return updated_node
+        assertion = updated_node.body[0]
+        if not isinstance(assertion, cst.Assert):
+            return updated_node
+
+        condition = cst.UnaryOperation(
+            operator=cst.Not(whitespace_after=cst.SimpleWhitespace(" ")),
+            expression=_parenthesize(assertion.test),
+        )
+        exception = self.exception.deep_clone()
+        if assertion.msg is None:
+            raised_exception = exception
+        else:
+            raised_exception = _exception_call(exception, assertion.msg)
+
+        position = self.get_metadata(PositionProvider, original_node)
+        self.converted_lines.append(position.start.line)
+        return cst.If(
+            test=condition,
+            body=cst.IndentedBlock(
+                header=updated_node.trailing_whitespace,
+                body=[
+                    cst.SimpleStatementLine(
+                        body=[cst.Raise(exc=raised_exception)]
+                    )
+                ],
+            ),
+            leading_lines=updated_node.leading_lines,
+        )
+
+
+def transform_source(source: str, exception: str = "AssertionError") -> SourceResult:
+    """Transform standalone assertions in a Python source string."""
+    _validate_exception(exception)
+    module = cst.parse_module(source)
+    transformer = ConvertAssertTransformer(exception)
+    updated = MetadataWrapper(module).visit(transformer)
+
+    skipped = Counter(transformer.seen_lines)
+    skipped.subtract(transformer.converted_lines)
+    skipped_lines = tuple(
+        line
+        for line, count in sorted(skipped.items())
+        for _ in range(max(count, 0))
+    )
+    return SourceResult(
+        source=updated.code,
+        converted_lines=tuple(transformer.converted_lines),
+        skipped_lines=skipped_lines,
+    )
+
+
+def convert_file(
+    path: Path,
+    exception: str = "AssertionError",
+    check: bool = False,
+) -> FileResult:
+    """Convert assertions in one Python file."""
+    source = path.read_text(encoding="utf-8")
+    result = transform_source(source, exception=exception)
+    changed = result.source != source
+    if changed and not check:
+        path.write_text(result.source, encoding="utf-8")
+    return FileResult(
+        path=path,
+        converted_lines=result.converted_lines,
+        skipped_lines=result.skipped_lines,
+        changed=changed,
+    )
+
+
+def _validate_exception(exception: str) -> None:
+    """Require a simple or dotted exception name, not arbitrary code."""
+    if not EXCEPTION_NAME.fullmatch(exception):
+        raise ValueError(
+            "exception must be a name already in scope, such as "
+            "AssertionError, ValueError, or qmcpy.util.ParameterError"
+        )
+
+
+def _changed_files(ref: str) -> list[Path]:
+    """Return changed production Python files relative to ``ref``."""
+    result = subprocess.run(
+        [
+            "git",
+            "diff",
+            "--name-only",
+            "--diff-filter=ACMR",
+            ref,
+            "--",
+            "qmcpy/*.py",
+        ],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    return [Path(name) for name in result.stdout.splitlines()]
+
+
+def _python_files(paths: list[str], diff_ref: str | None) -> list[Path]:
+    """Collect Python files from paths or a production-code diff."""
+    if diff_ref is not None:
+        candidates = _changed_files(diff_ref)
+    else:
+        candidates = [Path(path) for path in (paths or ["qmcpy"])]
+
+    files = []
+    for path in candidates:
+        if path.is_dir():
+            files.extend(sorted(path.rglob("*.py")))
+        elif path.suffix == ".py" and path.exists():
+            files.append(path)
+    return sorted(dict.fromkeys(files))
+
+
+def _parse_args(argv: list[str]) -> argparse.Namespace:
+    """Parse command-line arguments."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "paths",
+        nargs="*",
+        help="Python files or directories to update. Defaults to qmcpy.",
+    )
+    parser.add_argument(
+        "--diff",
+        metavar="REF",
+        help="Use changed qmcpy/*.py files reported by git diff REF.",
+    )
+    parser.add_argument(
+        "--exception",
+        default="AssertionError",
+        help=(
+            "Exception name already in scope for every selected file. "
+            "Defaults to AssertionError."
+        ),
+    )
+    parser.add_argument(
+        "--check",
+        action="store_true",
+        help="Report convertible assertions without writing files.",
+    )
+    parser.add_argument(
+        "--quiet",
+        action="store_true",
+        help="Only print the final summary.",
+    )
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str]) -> int:
+    """Run the command-line interface."""
+    args = _parse_args(argv)
+    try:
+        _validate_exception(args.exception)
+        files = _python_files(args.paths, args.diff)
+    except (ValueError, subprocess.CalledProcessError) as error:
+        print(f"error: {error}", file=sys.stderr)
+        return 2
+
+    if not files:
+        print("No Python files to inspect.")
+        return 0
+
+    results = []
+    had_parse_error = False
+    for path in files:
+        try:
+            result = convert_file(
+                path,
+                exception=args.exception,
+                check=args.check,
+            )
+        except (cst.ParserSyntaxError, UnicodeError) as error:
+            had_parse_error = True
+            print(f"{path}: skipped parse error: {error}", file=sys.stderr)
+            continue
+        results.append(result)
+
+    if not args.quiet:
+        action = "would convert" if args.check else "converted"
+        for result in results:
+            for line in result.converted_lines:
+                print(
+                    f"{result.path}:{line}: {action} assert to "
+                    f"explicit {args.exception}"
+                )
+            for line in result.skipped_lines:
+                print(
+                    f"{result.path}:{line}: skipped assert in a compound "
+                    "one-line statement"
+                )
+
+    converted = sum(len(result.converted_lines) for result in results)
+    skipped = sum(len(result.skipped_lines) for result in results)
+    changed_files = sum(result.changed for result in results)
+    verb = "would change" if args.check else "changed"
+    print(
+        f"{len(files)} file(s) inspected; {converted} assert(s) converted; "
+        f"{skipped} assert(s) skipped; {changed_files} file(s) {verb}."
+    )
+
+    if args.check and converted:
+        return 1
+    return 2 if had_parse_error else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))
diff --git a/test/test_sr_convert_asserts.py b/test/test_sr_convert_asserts.py
new file mode 100644
index 000000000..4260453a7
--- /dev/null
+++ b/test/test_sr_convert_asserts.py
@@ -0,0 +1,138 @@
+import shutil
+import tempfile
+import textwrap
+import unittest
+from contextlib import redirect_stderr, redirect_stdout
+from io import StringIO
+from pathlib import Path
+
+from scripts import convert_asserts
+
+
+class TestConvertAsserts(unittest.TestCase):
+
+    def setUp(self):
+        self.tmp_path = Path(tempfile.mkdtemp())
+        self.addCleanup(shutil.rmtree, self.tmp_path, ignore_errors=True)
+
+    def _write(self, source):
+        path = self.tmp_path / "sample.py"
+        path.write_text(textwrap.dedent(source).lstrip(), encoding="utf-8")
+        return path
+
+    def test_converts_assert_message_and_preserves_inline_comment(self):
+        source = textwrap.dedent(
+            '''
+            def positive(x):
+                assert x > 0, f"expected positive x, got {x}"  # public input
+                return x
+            '''
+        ).lstrip()
+
+        result = convert_asserts.transform_source(source)
+
+        self.assertEqual(result.converted_lines, (2,))
+        self.assertEqual(result.skipped_lines, ())
+        self.assertIn("if not (x > 0):  # public input", result.source)
+        self.assertIn(
+            'raise AssertionError(f"expected positive x, got {x}")',
+            result.source,
+        )
+
+        namespace = {}
+        exec(result.source, namespace)
+        self.assertEqual(namespace["positive"](2), 2)
+        with self.assertRaisesRegex(AssertionError, "expected positive x, got -1"):
+            namespace["positive"](-1)
+
+    def test_preserves_multiline_condition_and_message(self):
+        source = textwrap.dedent(
+            '''
+            def bounded(x):
+                assert (
+                    0 <= x <= 1
+                ), (
+                    f"x outside [0, 1]: {x}"
+                )
+            '''
+        ).lstrip()
+
+        result = convert_asserts.transform_source(source)
+
+        self.assertIn("if not (\n        0 <= x <= 1\n    ):", result.source)
+        self.assertIn(
+            'raise AssertionError(\n            f"x outside [0, 1]: {x}"\n        )',
+            result.source,
+        )
+        compile(result.source, "sample.py", "exec")
+
+    def test_supports_an_explicit_exception_already_in_scope(self):
+        source = "def positive(x):\n    assert x > 0, 'positive required'\n"
+
+        result = convert_asserts.transform_source(source, exception="ValueError")
+
+        namespace = {}
+        exec(result.source, namespace)
+        with self.assertRaisesRegex(ValueError, "positive required"):
+            namespace["positive"](0)
+
+    def test_preserves_a_tuple_as_one_exception_argument(self):
+        source = "def f():\n    assert False, ('left', 'right')\n"
+
+        result = convert_asserts.transform_source(source)
+
+        namespace = {}
+        exec(result.source, namespace)
+        with self.assertRaises(AssertionError) as context:
+            namespace["f"]()
+        self.assertEqual(context.exception.args, (("left", "right"),))
+
+    def test_check_mode_reports_without_writing(self):
+        path = self._write(
+            '''
+            def positive(x):
+                assert x > 0
+            '''
+        )
+        original = path.read_text(encoding="utf-8")
+        output = StringIO()
+
+        with redirect_stdout(output):
+            status = convert_asserts.main(["--check", str(path)])
+
+        self.assertEqual(status, 1)
+        self.assertIn("1 file(s) would change", output.getvalue())
+        self.assertEqual(path.read_text(encoding="utf-8"), original)
+
+    def test_skips_assert_mixed_with_other_one_line_statements(self):
+        source = "def f(x):\n    assert x; return x\n"
+
+        result = convert_asserts.transform_source(source)
+
+        self.assertEqual(result.source, source)
+        self.assertEqual(result.converted_lines, ())
+        self.assertEqual(result.skipped_lines, (2,))
+
+    def test_skips_assert_in_a_one_line_compound_suite(self):
+        source = "def f(x):\n    if x: assert x > 0\n"
+
+        result = convert_asserts.transform_source(source)
+
+        self.assertEqual(result.source, source)
+        self.assertEqual(result.converted_lines, ())
+        self.assertEqual(result.skipped_lines, (2,))
+
+    def test_rejects_an_exception_expression(self):
+        error = StringIO()
+
+        with redirect_stderr(error):
+            status = convert_asserts.main(
+                ["--exception", "ValueError()", "unused.py"]
+            )
+
+        self.assertEqual(status, 2)
+        self.assertIn("exception must be a name already in scope", error.getvalue())
+
+
+if __name__ == "__main__":
+    unittest.main()

From e4ae5ddeaddbf1a803a9335cd2d1a4e797573d9a Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Sun, 6 Sep 2026 23:07:23 +0800
Subject: [PATCH 19/51] assert -> AssertionError

---
 .../digital_net_any_bases.py                  |  81 +++++++++-----
 .../digital_net_b2/digital_net_b2.py          |  74 ++++++++-----
 qmcpy/discrete_distribution/korobov.py        |   3 +-
 qmcpy/discrete_distribution/kronecker.py      |  30 ++++--
 .../discrete_distribution/lattice/lattice.py  |  47 ++++----
 qmcpy/fast_transform/ft.py                    |   9 +-
 qmcpy/fast_transform/ft_pytorch.py            |   9 +-
 qmcpy/fast_transform/ft_qmctoolscl.py         |   3 +-
 qmcpy/integrand/abstract_integrand.py         |  42 +++++---
 qmcpy/integrand/box_integral.py               |   3 +-
 qmcpy/integrand/financial_option.py           |  52 +++++----
 qmcpy/integrand/fourbranch2d.py               |   3 +-
 qmcpy/integrand/hartmann6d.py                 |   3 +-
 qmcpy/integrand/ishigami.py                   |   6 +-
 qmcpy/integrand/multimodal2d.py               |   3 +-
 qmcpy/integrand/sensitivity_indices.py        |  16 +--
 qmcpy/integrand/sin1d.py                      |   3 +-
 qmcpy/kernel/abstract_kernel.py               | 100 ++++++++++--------
 qmcpy/kernel/multitask_kernel.py              |  14 ++-
 qmcpy/kernel/si_dsi_kernels.py                |  79 +++++++++-----
 qmcpy/stopping_criterion/abstract_cub_mlmc.py |   3 +-
 .../stopping_criterion/abstract_cub_mlqmc.py  |   3 +-
 .../abstract_stopping_criterion.py            |   3 +-
 qmcpy/stopping_criterion/cub_mc_clt.py        |  22 ++--
 qmcpy/stopping_criterion/cub_mc_clt_vec.py    |  14 ++-
 qmcpy/stopping_criterion/cub_mc_g.py          |  11 +-
 qmcpy/stopping_criterion/cub_mlmc.py          |   3 +-
 qmcpy/stopping_criterion/cub_mlmc_cont.py     |   6 +-
 qmcpy/stopping_criterion/cub_mlqmc.py         |   6 +-
 qmcpy/stopping_criterion/cub_mlqmc_cont.py    |   9 +-
 .../cub_qmc_rep_student_t.py                  |  22 ++--
 qmcpy/stopping_criterion/pf_gp_ci.py          |  26 +++--
 qmcpy/true_measure/abstract_true_measure.py   |   3 +-
 qmcpy/true_measure/gaussian.py                |   3 +-
 qmcpy/true_measure/johnsons_su.py             |   5 +-
 qmcpy/true_measure/kumaraswamy.py             |   3 +-
 qmcpy/true_measure/matern_gp.py               |  24 +++--
 qmcpy/true_measure/scipy_wrapper.py           |   3 +-
 qmcpy/true_measure/uniform.py                 |   3 +-
 qmcpy/util/dig_shift_invar_ops.py             |  23 ++--
 qmcpy/util/shift_invar_ops.py                 |  12 ++-
 41 files changed, 496 insertions(+), 291 deletions(-)

diff --git a/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py b/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py
index 220104cec..e535a6d9b 100644
--- a/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py
+++ b/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py
@@ -222,16 +222,22 @@ def __init__(self,
                 raise ParameterError("must supply bases_generating_matrices")
         else:
             self.type_bases_generating_matrices = "CUSTOM"
-            assert len(bases_generating_matrices)==2
+            if not (len(bases_generating_matrices)==2):
+                raise AssertionError
             bases,generating_matrices = bases_generating_matrices
-            assert isinstance(generating_matrices,np.ndarray)
-            assert generating_matrices.ndim==3 or generating_matrices.ndim==4
+            if not (isinstance(generating_matrices,np.ndarray)):
+                raise AssertionError
+            if not (generating_matrices.ndim==3 or generating_matrices.ndim==4):
+                raise AssertionError
             d_limit = generating_matrices.shape[1]
             if np.isscalar(bases):
-                assert bases>0
-                assert bases%1==0
+                if not (bases>0):
+                    raise AssertionError
+                if not (bases%1==0):
+                    raise AssertionError
                 bases = int(bases)*np.ones(d_limit,dtype=int)
-            assert bases.ndim==1 or bases.ndim==2
+            if not (bases.ndim==1 or bases.ndim==2):
+                raise AssertionError
         self.input_t = deepcopy(t)
         self.input_bases_generating_matrices = deepcopy(bases_generating_matrices)
         super(DigitalNetAnyBases,self).__init__(dimension,replications,seed,d_limit,n_lim)
@@ -242,16 +248,22 @@ def __init__(self,
         if self.randomize=="OWEN": self.randomize = "NUS"
         if self.randomize=="NONE": self.randomize = "FALSE"
         if self.randomize=="NO": self.randomize = "FALSE"
-        assert self.randomize in ["LMS DP","LMS DS","LMS","DP","DS","NUS","QRNG","FALSE"]
+        if not (self.randomize in ["LMS DP","LMS DS","LMS","DP","DS","NUS","QRNG","FALSE"]):
+            raise AssertionError
         if self.randomize=="QRNG":
-            assert self.type_bases_generating_matrices=="HALTON", "QRNG randomization is only applicable for the Halton generator."
-            assert self.replications==1, "QRNG requires replications=1"
+            if not (self.type_bases_generating_matrices=="HALTON"):
+                raise AssertionError("QRNG randomization is only applicable for the Halton generator.")
+            if not (self.replications==1):
+                raise AssertionError("QRNG requires replications=1")
             self.randu_d_32 = self.rng.uniform(size=(self.d,32))
         self.alpha = alpha
-        assert self.alpha>=1
-        assert self.alpha%1==0
+        if not (self.alpha>=1):
+            raise AssertionError
+        if not (self.alpha%1==0):
+            raise AssertionError
         if self.alpha>1:
-            assert (self.dvec==np.arange(self.d)).all(), "digital interlacing requires dimension is an int"
+            if not ((self.dvec==np.arange(self.d)).all()):
+                raise AssertionError("digital interlacing requires dimension is an int")
         self.dtalpha = self.alpha*self.d
         if self.type_bases_generating_matrices=="HALTON":
             self.bases = self.all_primes[self.dvec][None,:]
@@ -261,7 +273,8 @@ def __init__(self,
             self.t = self.m_max if self.m_max>t else t
             self.C = qmctoolscl.gdn_get_halton_generating_matrix(np.uint64(1),np.uint64(self.d),np.uint64(self._t_curr))
         elif self.type_bases_generating_matrices=="FAURE":
-            assert (self.dvec==np.arange(self.d)).all(), "Faure requires dimension is an int"
+            if not ((self.dvec==np.arange(self.d)).all()):
+                raise AssertionError("Faure requires dimension is an int")
             p = self.all_primes[np.argmax(self.all_primes>=self.d)]
             self.bases = p*np.ones((1,self.dtalpha),dtype=np.uint64)
             self.m_max = int(np.ceil(np.log(self.n_limit)/np.log(p)))
@@ -283,14 +296,16 @@ def __init__(self,
         else:
             self.bases = bases.astype(np.uint64)
             if self.bases.ndim==1: self.bases = self.bases[None,:]
-            assert self.bases.shape[1]>=self.dtalpha
+            if not (self.bases.shape[1]>=self.dtalpha):
+                raise AssertionError
             if self.alpha==1:
                 self.bases = self.bases[:,self.dvec]
             else:
                 self.bases = self.bases[:,:self.dtalpha]
             self.C = generating_matrices.astype(np.uint64)
             if self.C.ndim==3: self.C = self.C[None,:,:,:]
-            assert self.C.shape[1]>=self.dtalpha
+            if not (self.C.shape[1]>=self.dtalpha):
+                raise AssertionError
             if self.alpha==1:
                 self.C = self.C[:,self.dvec,:,:]
             else:
@@ -298,20 +313,29 @@ def __init__(self,
             self.m_max,self._t_curr = self.C.shape[-2:]
             if t is None: t = int(np.ceil(-np.log(2**(-63))/np.log(self.bases.min())))
             self.t = self.m_max if self.m_max>t else t
-            assert (0<=self.C).all()
-            assert (self.C<self.bases[:,:,None,None]).all()
+            if not ((0<=self.C).all()):
+                raise AssertionError
+            if not ((self.C<self.bases[:,:,None,None]).all()):
+                raise AssertionError
             self.C = np.ascontiguousarray(self.C)
             self.bases = np.ascontiguousarray(self.bases)
         if self.alpha>1:
-            assert (self.bases==self.bases[0,0]).all(), "alpha>1 performs digital interlacing which requires the same base across dimensions and replications."
+            if not ((self.bases==self.bases[0,0]).all()):
+                raise AssertionError("alpha>1 performs digital interlacing which requires the same base across dimensions and replications.")
             if warn and self.m_max!=self._t_curr:
                 warnings.warn("Digital interlacing is often performed on generating matrices with the number of columns (m_max = %d) equal to the number of rows (_t_curr = %d), but this is not the case. Ensure you are NOT setting alpha>1 when generating matrices are already interlaced."%(self.m_max,self._t_curr),ParameterWarning)
-        assert self.bases.ndim==2
-        assert self.bases.shape[-1]==self.dtalpha
-        assert self.bases.shape[0]==1 or self.bases.shape[0]==self.replications
-        assert self.C.ndim==4
-        assert self.C.shape[-3:]==(self.dtalpha,self.m_max,self._t_curr)
-        assert self.C.shape[0]==1 or self.C.shape[0]==self.replications
+        if not (self.bases.ndim==2):
+            raise AssertionError
+        if not (self.bases.shape[-1]==self.dtalpha):
+            raise AssertionError
+        if not (self.bases.shape[0]==1 or self.bases.shape[0]==self.replications):
+            raise AssertionError
+        if not (self.C.ndim==4):
+            raise AssertionError
+        if not (self.C.shape[-3:]==(self.dtalpha,self.m_max,self._t_curr)):
+            raise AssertionError
+        if not (self.C.shape[0]==1 or self.C.shape[0]==self.replications):
+            raise AssertionError
         r_b = self.bases.shape[0]
         r_C = self.C.shape[0]
         if self.randomize=="FALSE":
@@ -358,9 +382,12 @@ def __init__(self,
                 new_seeds = self._base_seed.spawn(self.replications*self.dtalpha)
                 self.rngs = np.array([np.random.Generator(np.random.SFC64(new_seeds[j])) for j in range(self.replications*self.dtalpha)]).reshape(self.replications,self.dtalpha)
                 self.root_nodes = np.array([qmctoolscl.NUSNode_gdn() for i in range(self.replications*self.dtalpha)]).reshape(self.replications,self.dtalpha)
-        assert self.C.ndim==4 and (self.C.shape[0]==1 or self.C.shape[0]==self.replications) and self.C.shape[1]==(self.dtalpha if self.randomize=="NUS" else self.d) and self.C.shape[2]==self.m_max and self.C.shape[3]==self._t_curr
-        assert self.bases.ndim==2 and (self.bases.shape[0]==1 or self.bases.shape[0]==self.replications) and self.bases.shape[1]==(self.dtalpha if self.randomize=="NUS" else self.d)
-        assert 0<self._t_curr<=self.t<=64
+        if not (self.C.ndim==4 and (self.C.shape[0]==1 or self.C.shape[0]==self.replications) and self.C.shape[1]==(self.dtalpha if self.randomize=="NUS" else self.d) and self.C.shape[2]==self.m_max and self.C.shape[3]==self._t_curr):
+            raise AssertionError
+        if not (self.bases.ndim==2 and (self.bases.shape[0]==1 or self.bases.shape[0]==self.replications) and self.bases.shape[1]==(self.dtalpha if self.randomize=="NUS" else self.d)):
+            raise AssertionError
+        if not (0<self._t_curr<=self.t<=64):
+            raise AssertionError
         if self.randomize=="FALSE": assert self.C.shape[0]==self.replications, "randomize='FALSE' but replications = %d does not equal the number of sets of generating vectors %d"%(self.replications,self.C.shape[0])
         if warn and (self.bases==2).all():
             warnings.warn("It is more efficient to use DigitalNetB2 instead of DigitalNetAnyBases when all bases are 2")
diff --git a/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py b/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
index 257512a9d..bcff01e0e 100644
--- a/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
+++ b/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
@@ -330,7 +330,8 @@ def __init__(
             gen_mats = gen_mats >> compat_shift
         elif isinstance(generating_matrices, str):
             self.gen_mats_source = generating_matrices
-            assert generating_matrices[-4:] == ".txt"
+            if not (generating_matrices[-4:] == ".txt"):
+                raise AssertionError
             local_root = dirname(abspath(__file__)) + "/generating_matrices/"
             repos = DataSource()
             if repos.exists(local_root + generating_matrices):
@@ -374,7 +375,8 @@ def __init__(
             contents = [line.split("#", 1)[0] for line in contents if line[0] != "#"]
             datafile.close()
             msb = True
-            assert int(contents[0]) == 2, "DigitalNetB2 requires base=2 "  # base 2
+            if not (int(contents[0]) == 2):  # base 2
+                raise AssertionError("DigitalNetB2 requires base=2 ")
             d_limit = int(contents[1])
             n_limit = int(contents[2])
             self._t_curr = int(contents[3])
@@ -393,17 +395,20 @@ def __init__(
             )[None, :]
         elif isinstance(generating_matrices, np.ndarray):
             self.gen_mats_source = "custom"
-            assert generating_matrices.ndim == 2 or generating_matrices.ndim == 3
+            if not (generating_matrices.ndim == 2 or generating_matrices.ndim == 3):
+                raise AssertionError
             gen_mats = (
                 generating_matrices[None, :, :]
                 if generating_matrices.ndim == 2
                 else generating_matrices
             )
-            assert isinstance(
+            if not (isinstance(
                 msb, bool
-            ), "when generating_matrices is a np.ndarray you must set either msb=True (for most significant bit ordering) or msb=False (for least significant bit ordering which will require a bit reversal)"
+            )):
+                raise AssertionError("when generating_matrices is a np.ndarray you must set either msb=True (for most significant bit ordering) or msb=False (for least significant bit ordering which will require a bit reversal)")
             gen_mat_max = gen_mats.max()
-            assert gen_mat_max > 0, "generating matrix must have positive ints"
+            if not (gen_mat_max > 0):
+                raise AssertionError("generating matrix must have positive ints")
             self._t_curr = int(np.ceil(np.log2(gen_mat_max + 1)))
             d_limit = gen_mats.shape[1]
             n_limit = int(2 ** (gen_mats.shape[2]))
@@ -414,12 +419,13 @@ def __init__(
         super(DigitalNetB2, self).__init__(
             dimension, replications, seed, d_limit, n_limit
         )
-        assert (
+        if not (
             gen_mats.ndim == 3
             and gen_mats.shape[1] >= self.d
             and (gen_mats.shape[0] == 1 or gen_mats.shape[0] == self.replications)
             and gen_mats.shape[2] > 0
-        ), "invalid gen_mats.shape = %s" % str(gen_mats.shape)
+        ):
+            raise AssertionError("invalid gen_mats.shape = %s" % str(gen_mats.shape))
         self.m_max = int(gen_mats.shape[-1])
         if isinstance(generating_matrices, np.ndarray) and (not msb):
             qmctoolscl.dnb2_gmat_lsb_to_msb(
@@ -436,18 +442,23 @@ def __init__(
             self.order = "GRAY"
         if self.order == "NATURAL":
             self.order = "RADICAL INVERSE"
-        assert self.order in ["RADICAL INVERSE", "GRAY"]
-        assert isinstance(t, int) and t > 0
-        assert self._t_curr <= t <= 64, (
-            "t must no more than 64 and no less than %d (the number of bits used to represent the generating matrices)"
-            % (self._t_curr)
-        )
-        assert isinstance(alpha, int) and alpha > 0
+        if not (self.order in ["RADICAL INVERSE", "GRAY"]):
+            raise AssertionError
+        if not (isinstance(t, int) and t > 0):
+            raise AssertionError
+        if not (self._t_curr <= t <= 64):
+            raise AssertionError(
+                "t must no more than 64 and no less than %d (the number of bits used to represent the generating matrices)"
+                % (self._t_curr)
+            )
+        if not (isinstance(alpha, int) and alpha > 0):
+            raise AssertionError
         self.alpha = alpha
         if self.alpha > 1:
-            assert (
+            if not ((
                 self.dvec == np.arange(self.d)
-            ).all(), "digital interlacing requires dimension is an int"
+            ).all()):
+                raise AssertionError("digital interlacing requires dimension is an int")
             if self.m_max != self._t_curr:
                 warnings.warn(
                     "Digital interlacing is often performed on matrices with the number of columns (m_max = %d) equal to the number of bits in each int (%d), but this is not the case. Ensure you are NOT setting alpha>1 when generating matrices are already interlaced."
@@ -464,7 +475,8 @@ def __init__(
             self.randomize = "FALSE"
         if self.randomize == "NO":
             self.randomize = "FALSE"
-        assert self.randomize in ["LMS DS", "LMS", "DS", "NUS", "FALSE"]
+        if not (self.randomize in ["LMS DS", "LMS", "DS", "NUS", "FALSE"]):
+            raise AssertionError
         self.dtalpha = self.alpha * self.d
         if self.randomize == "FALSE":
             if self.alpha == 1:
@@ -627,19 +639,23 @@ def __init__(
             raise ParameterError("self.randomize parsing error")
         self.gen_mats = np.ascontiguousarray(self.gen_mats)
         gen_mat_max = self.gen_mats.max()
-        assert gen_mat_max > 0, "generating matrix must have positive ints"
-        assert self._t_curr == int(np.ceil(np.log2(gen_mat_max + 1)))
-        assert (
+        if not (gen_mat_max > 0):
+            raise AssertionError("generating matrix must have positive ints")
+        if not (self._t_curr == int(np.ceil(np.log2(gen_mat_max + 1)))):
+            raise AssertionError
+        if not (
             0 < self._t_curr <= self.t <= 64
-        ), "invalid 0 <= self._t_curr (%d) <= self.t (%d) <= 64" % (
-            self._t_curr,
-            self.t,
-        )
+        ):
+            raise AssertionError("invalid 0 <= self._t_curr (%d) <= self.t (%d) <= 64" % (
+                self._t_curr,
+                self.t,
+            ))
         if self.randomize == "FALSE":
-            assert self.gen_mats.shape[0] == self.replications, (
-                "randomize='FALSE' but replications = %d does not equal the number of sets of generating matrices %d"
-                % (self.replications, self.gen_mats.shape[0])
-            )
+            if not (self.gen_mats.shape[0] == self.replications):
+                raise AssertionError(
+                    "randomize='FALSE' but replications = %d does not equal the number of sets of generating matrices %d"
+                    % (self.replications, self.gen_mats.shape[0])
+                )
 
     def _try_gen_samples_float(self, r, n, d, n_start, mmax, r_x, return_binary):
         if return_binary or "NUS" in self.randomize:
diff --git a/qmcpy/discrete_distribution/korobov.py b/qmcpy/discrete_distribution/korobov.py
index 29a37ab36..0d0f9407d 100644
--- a/qmcpy/discrete_distribution/korobov.py
+++ b/qmcpy/discrete_distribution/korobov.py
@@ -168,7 +168,8 @@ def __init__(
             self.randomize = "FALSE"
         if self.randomize == "NO":
             self.randomize = "FALSE"
-        assert self.randomize in ["SHIFT", "FALSE"]
+        if not (self.randomize in ["SHIFT", "FALSE"]):
+            raise AssertionError
         if self.randomize not in ("SHIFT", "FALSE"):
             raise ParameterError(
             f"randomize must be one of 'SHIFT', 'TRUE', 'FALSE', 'NONE', or 'NO' (case-insensitive), got {randomize!r}."
diff --git a/qmcpy/discrete_distribution/kronecker.py b/qmcpy/discrete_distribution/kronecker.py
index c33165981..b498303a5 100644
--- a/qmcpy/discrete_distribution/kronecker.py
+++ b/qmcpy/discrete_distribution/kronecker.py
@@ -48,7 +48,8 @@
 
 def _richtmyer_generating_vector(dimension):
     PRIMES = np.array([2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, 2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079, 3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 3169, 3181, 3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, 3259, 3271, 3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331, 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413, 3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 3517, 3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571, 3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637, 3643, 3659, 3671, 3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727, 3733, 3739, 3761, 3767, 3769, 3779, 3793, 3797, 3803, 3821, 3823, 3833, 3847, 3851, 3853, 3863, 3877, 3881, 3889, 3907, 3911, 3917, 3919, 3923, 3929, 3931, 3943, 3947, 3967, 3989, 4001, 4003, 4007, 4013, 4019, 4021, 4027, 4049, 4051, 4057, 4073, 4079, 4091, 4093, 4099, 4111, 4127, 4129, 4133, 4139, 4153, 4157, 4159, 4177, 4201, 4211, 4217, 4219, 4229, 4231, 4241, 4243, 4253, 4259, 4261, 4271, 4273, 4283, 4289, 4297, 4327, 4337, 4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409, 4421, 4423, 4441, 4447, 4451, 4457, 4463, 4481, 4483, 4493, 4507, 4513, 4517, 4519, 4523, 4547, 4549, 4561, 4567, 4583, 4591, 4597, 4603, 4621, 4637, 4639, 4643, 4649, 4651, 4657, 4663, 4673, 4679, 4691, 4703, 4721, 4723, 4729, 4733, 4751, 4759, 4783, 4787, 4789, 4793, 4799, 4801, 4813, 4817, 4831, 4861, 4871, 4877, 4889, 4903, 4909, 4919, 4931, 4933, 4937, 4943, 4951, 4957, 4967, 4969, 4973, 4987, 4993, 4999, 5003, 5009, 5011, 5021, 5023, 5039, 5051, 5059, 5077, 5081, 5087, 5099, 5101, 5107, 5113, 5119, 5147, 5153, 5167, 5171, 5179, 5189, 5197, 5209, 5227, 5231, 5233, 5237, 5261, 5273, 5279, 5281, 5297, 5303, 5309, 5323, 5333, 5347, 5351, 5381, 5387, 5393, 5399, 5407, 5413, 5417, 5419, 5431, 5437, 5441, 5443, 5449, 5471, 5477, 5479, 5483, 5501, 5503, 5507, 5519, 5521, 5527, 5531, 5557, 5563, 5569, 5573, 5581, 5591, 5623, 5639, 5641, 5647, 5651, 5653, 5657, 5659, 5669, 5683, 5689, 5693, 5701, 5711, 5717, 5737, 5741, 5743, 5749, 5779, 5783, 5791, 5801, 5807, 5813, 5821, 5827, 5839, 5843, 5849, 5851, 5857, 5861, 5867, 5869, 5879, 5881, 5897, 5903, 5923, 5927, 5939, 5953, 5981, 5987, 6007, 6011, 6029, 6037, 6043, 6047, 6053, 6067, 6073, 6079, 6089, 6091, 6101, 6113, 6121, 6131, 6133, 6143, 6151, 6163, 6173, 6197, 6199, 6203, 6211, 6217, 6221, 6229, 6247, 6257, 6263, 6269, 6271, 6277, 6287, 6299, 6301, 6311, 6317, 6323, 6329, 6337, 6343, 6353, 6359, 6361, 6367, 6373, 6379, 6389, 6397, 6421, 6427, 6449, 6451, 6469, 6473, 6481, 6491, 6521, 6529, 6547, 6551, 6553, 6563, 6569, 6571, 6577, 6581, 6599, 6607, 6619, 6637, 6653, 6659, 6661, 6673, 6679, 6689, 6691, 6701, 6703, 6709, 6719, 6733, 6737, 6761, 6763, 6779, 6781, 6791, 6793, 6803, 6823, 6827, 6829, 6833, 6841, 6857, 6863, 6869, 6871, 6883, 6899, 6907, 6911, 6917, 6947, 6949, 6959, 6961, 6967, 6971, 6977, 6983, 6991, 6997, 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, 7121, 7127, 7129, 7151, 7159, 7177, 7187, 7193, 7207, 7211, 7213, 7219, 7229, 7237, 7243, 7247, 7253, 7283, 7297, 7307, 7309, 7321, 7331, 7333, 7349, 7351, 7369, 7393, 7411, 7417, 7433, 7451, 7457, 7459, 7477, 7481, 7487, 7489, 7499, 7507, 7517, 7523, 7529, 7537, 7541, 7547, 7549, 7559, 7561, 7573, 7577, 7583, 7589, 7591, 7603, 7607, 7621, 7639, 7643, 7649, 7669, 7673, 7681, 7687, 7691, 7699, 7703, 7717, 7723, 7727, 7741, 7753, 7757, 7759, 7789, 7793, 7817, 7823, 7829, 7841, 7853, 7867, 7873, 7877, 7879, 7883, 7901, 7907, 7919])
-    assert dimension<len(PRIMES)
+    if not (dimension<len(PRIMES)):
+        raise AssertionError
     return np.sqrt(PRIMES[:dimension]) % 1
 
 def _suzuki_generating_vector(dimension):
@@ -296,10 +297,14 @@ def __init__(self,
             if gen_vec.ndim >2:
                 raise ParameterError("generating_vector must be a 1D or 2D np.ndarray")
         gen_vec = np.atleast_2d(gen_vec).astype(float)
-        assert gen_vec.ndim==2, "gen_vec must be a 2D array"
-        assert gen_vec.shape[1]>=self.d
-        assert (gen_vec.shape[0] == 1 or gen_vec.shape[0] == self.replications)
-        assert gen_vec.shape[1]>self.dvec.max()
+        if not (gen_vec.ndim==2):
+            raise AssertionError("gen_vec must be a 2D array")
+        if not (gen_vec.shape[1]>=self.d):
+            raise AssertionError
+        if not (gen_vec.shape[0] == 1 or gen_vec.shape[0] == self.replications):
+            raise AssertionError
+        if not (gen_vec.shape[1]>self.dvec.max()):
+            raise AssertionError
         self.gen_vec = gen_vec[:,self.dvec].copy()
         self.randomize = str(randomize).upper()
         if self.randomize == "TRUE":
@@ -308,7 +313,8 @@ def __init__(self,
             self.randomize = "FALSE"
         if self.randomize == "NO":
             self.randomize = "FALSE"
-        assert self.randomize in ["SHIFT", "FALSE"]
+        if not (self.randomize in ["SHIFT", "FALSE"]):
+            raise AssertionError
         if shift is not None: assert self.randomize=="SHIFT", "require randomize='SHIFT' when shift is not None"
         if self.randomize=="SHIFT":
             if shift is not None:
@@ -317,9 +323,12 @@ def __init__(self,
                 self.shift = self.rng.uniform(size=(self.replications, self.d))
         else: # self.randomize=="FALSE":
             self.shift = np.zeros((self.replications, self.d))
-        assert self.shift.ndim==2
-        assert self.shift.shape[1]==self.d
-        assert (self.shift.shape[0] == 1 or self.shift.shape[0] == self.replications)
+        if not (self.shift.ndim==2):
+            raise AssertionError
+        if not (self.shift.shape[1]==self.d):
+            raise AssertionError
+        if not (self.shift.shape[0] == 1 or self.shift.shape[0] == self.replications):
+            raise AssertionError
 
     def _gen_samples(self, n_min, n_max, return_binary, warn):
         if return_binary:
@@ -380,7 +389,8 @@ def _square_periodic_discrepancies(self, n, k_tilde, gamma):
 
 
     def _spawn(self, child_seed, dimension):
-        assert self.input_shift is None, "spawn requires shift=None"
+        if not (self.input_shift is None):
+            raise AssertionError("spawn requires shift=None")
         return Kronecker(
             dimension=dimension,
             replications=None if self.no_replications else self.replications,
diff --git a/qmcpy/discrete_distribution/lattice/lattice.py b/qmcpy/discrete_distribution/lattice/lattice.py
index 7561d9d27..25ba28812 100644
--- a/qmcpy/discrete_distribution/lattice/lattice.py
+++ b/qmcpy/discrete_distribution/lattice/lattice.py
@@ -196,7 +196,8 @@ def __init__(
             n_limit = 1048576
         elif isinstance(generating_vector, str):
             self.gen_vec_source = generating_vector
-            assert generating_vector[-4:] == ".txt"
+            if not (generating_vector[-4:] == ".txt"):
+                raise AssertionError
             local_root = dirname(abspath(__file__)) + "/generating_vectors/"
             repos = DataSource()
             if repos.exists(local_root + generating_vector):
@@ -254,11 +255,13 @@ def __init__(
             n_limit = int(2**m_max)
             d_limit = int(gen_vec.shape[-1])
         elif isinstance(generating_vector, int):
-            assert 1 < generating_vector < 27, "int generating vector out of range"
+            if not (1 < generating_vector < 27):
+                raise AssertionError("int generating vector out of range")
             n_limit = 2**generating_vector
-            assert isinstance(
+            if not (isinstance(
                 dimension, int
-            ), "random generating vector requires int dimension"
+            )):
+                raise AssertionError("random generating vector requires int dimension")
             d_limit = dimension
         else:
             raise ParameterError(
@@ -281,20 +284,23 @@ def __init__(
                     + 1,
                 ]
             ).copy()
-        assert isinstance(gen_vec, np.ndarray)
+        if not (isinstance(gen_vec, np.ndarray)):
+            raise AssertionError
         gen_vec = np.atleast_2d(gen_vec)
-        assert (
+        if not (
             gen_vec.ndim == 2
             and gen_vec.shape[1] >= self.d
             and (gen_vec.shape[0] == 1 or gen_vec.shape[0] == self.replications)
-        ), "invalid gen_vec.shape = %s" % str(gen_vec.shape)
+        ):
+            raise AssertionError("invalid gen_vec.shape = %s" % str(gen_vec.shape))
         self.gen_vec = gen_vec[:, self.dvec].copy()
         self.order = str(order).upper().strip().replace("_", " ")
         if self.order == "GRAY CODE":
             self.order = "GRAY"
         if self.order == "NATURAL":
             self.order = "RADICAL INVERSE"
-        assert self.order in ["LINEAR", "RADICAL INVERSE", "GRAY"]
+        if not (self.order in ["LINEAR", "RADICAL INVERSE", "GRAY"]):
+            raise AssertionError
         self.randomize = str(randomize).upper()
         if self.randomize == "TRUE":
             self.randomize = "SHIFT"
@@ -302,14 +308,16 @@ def __init__(
             self.randomize = "FALSE"
         if self.randomize == "NO":
             self.randomize = "FALSE"
-        assert self.randomize in ["SHIFT", "FALSE"]
+        if not (self.randomize in ["SHIFT", "FALSE"]):
+            raise AssertionError
         if self.randomize == "SHIFT":
             self.shift = self.rng.uniform(size=(self.replications, self.d))
         if self.randomize == "FALSE":
-            assert self.gen_vec.shape[0] == self.replications, (
-                "randomize='FALSE' but replications = %d does not equal the number of sets of generating vectors %d"
-                % (self.replications, self.gen_vec.shape[0])
-            )
+            if not (self.gen_vec.shape[0] == self.replications):
+                raise AssertionError(
+                    "randomize='FALSE' but replications = %d does not equal the number of sets of generating vectors %d"
+                    % (self.replications, self.gen_vec.shape[0])
+                )
 
     def _gen_samples(self, n_min, n_max, return_binary, warn):
         if return_binary:
@@ -325,14 +333,16 @@ def _gen_samples(self, n_min, n_max, return_binary, warn):
         n_start = np.uint64(n_min)
         x = np.empty((r_x, n, d), dtype=np.float64)
         if self.order == "LINEAR":
-            assert (
+            if not (
                 r_x == 1
-            ), "lattice linear currently requires there be only 1 generating matrix"
+            ):
+                raise AssertionError("lattice linear currently requires there be only 1 generating matrix")
             x = self._gail_linear(n_min, n_max)[None, :, :]
         elif self.order == "RADICAL INVERSE":
-            assert (n_min == 0 or (n_min & (n_min - 1)) == 0) and (
+            if not ((n_min == 0 or (n_min & (n_min - 1)) == 0) and (
                 n_max == 0 or (n_max & (n_max - 1)) == 0
-            ), "lattice in natural order requires n_min and n_max be 0 or powers of 2"
+            )):
+                raise AssertionError("lattice in natural order requires n_min and n_max be 0 or powers of 2")
             _ = qmctoolscl.lat_gen_natural(
                 r_x, n, d, n_start, self.gen_vec, x, backend="c"
             )
@@ -341,7 +351,8 @@ def _gen_samples(self, n_min, n_max, return_binary, warn):
                 r_x, n, d, n_start, self.gen_vec, x, backend="c"
             )
         else:
-            assert False, "invalid lattice order"
+            if not (False):
+                raise AssertionError("invalid lattice order")
         if self.randomize == "FALSE":
             xr = x
         elif self.randomize == "SHIFT":
diff --git a/qmcpy/fast_transform/ft.py b/qmcpy/fast_transform/ft.py
index 8233d78a5..1addf5635 100644
--- a/qmcpy/fast_transform/ft.py
+++ b/qmcpy/fast_transform/ft.py
@@ -26,7 +26,8 @@ def fftbr(x):
         BRO-FFT values.
     """
     n = x.shape[-1]
-    assert n & (n - 1) == 0  # require n is a power of 2
+    if not (n & (n - 1) == 0):  # require n is a power of 2
+        raise AssertionError
     m = int(np.log2(n))
     shape = list(x.shape)
     ndim = x.ndim
@@ -63,7 +64,8 @@ def ifftbr(x):
         BRO-IFFT values.
     """
     n = x.shape[-1]
-    assert n & (n - 1) == 0  # require n is a power of 2
+    if not (n & (n - 1) == 0):  # require n is a power of 2
+        raise AssertionError
     m = int(np.log2(n))
     shape = list(x.shape)
     ndim = x.ndim
@@ -98,7 +100,8 @@ def fwht(x):
     n = x.shape[-1]
     if n <= 1:
         return y
-    assert n & (n - 1) == 0  # require n is a power of 2
+    if not (n & (n - 1) == 0):  # require n is a power of 2
+        raise AssertionError
     m = int(np.log2(n))
     it = np.arange(n, dtype=np.int64).reshape(
         [2] * m
diff --git a/qmcpy/fast_transform/ft_pytorch.py b/qmcpy/fast_transform/ft_pytorch.py
index 341b98b59..27e20c1b2 100644
--- a/qmcpy/fast_transform/ft_pytorch.py
+++ b/qmcpy/fast_transform/ft_pytorch.py
@@ -40,7 +40,8 @@ def fftbr_torch(x):
         BRO-FFT values.
     """
     n = x.size(-1)
-    assert n & (n - 1) == 0  # require n is a power of 2
+    if not (n & (n - 1) == 0):  # require n is a power of 2
+        raise AssertionError
     m = int(np.log2(n))
     shape = list(x.shape)
     ndim = x.ndim
@@ -91,7 +92,8 @@ def ifftbr_torch(x):
         BRO-IFFT values.
     """
     n = x.size(-1)
-    assert n & (n - 1) == 0  # require n is a power of 2
+    if not (n & (n - 1) == 0):  # require n is a power of 2
+        raise AssertionError
     m = int(np.log2(n))
     shape = list(x.shape)
     ndim = x.ndim
@@ -109,7 +111,8 @@ def _fwht_torch(x):
     n = x.size(-1)
     if n <= 1:
         return y
-    assert n & (n - 1) == 0  # require n is a power of 2
+    if not (n & (n - 1) == 0):  # require n is a power of 2
+        raise AssertionError
     m = int(np.log2(n))
     it = torch.arange(n, dtype=torch.int64, device=x.device).reshape(
         [2] * m
diff --git a/qmcpy/fast_transform/ft_qmctoolscl.py b/qmcpy/fast_transform/ft_qmctoolscl.py
index eaa45de59..3c5f6d2ae 100644
--- a/qmcpy/fast_transform/ft_qmctoolscl.py
+++ b/qmcpy/fast_transform/ft_qmctoolscl.py
@@ -15,7 +15,8 @@ def _parse_ft_input(x):
         n = shape[-1]
         x = x.reshape(-1, n)
         d = x.shape[0]
-    assert (n & (n - 1)) == 0  # require n is 0 or a power of 2
+    if not ((n & (n - 1)) == 0):  # require n is 0 or a power of 2
+        raise AssertionError
     return x, shape, d, n, n // 2
 
 
diff --git a/qmcpy/integrand/abstract_integrand.py b/qmcpy/integrand/abstract_integrand.py
index ea382a823..442e54ceb 100644
--- a/qmcpy/integrand/abstract_integrand.py
+++ b/qmcpy/integrand/abstract_integrand.py
@@ -66,7 +66,8 @@ def __init__(self, dimension_indv, dimension_comb, parallel, threadpool=False):
             self.parameters = []
         if not hasattr(self, "multilevel"):
             self.multilevel = False
-        assert isinstance(self.multilevel, bool)
+        if not (isinstance(self.multilevel, bool)):
+            raise AssertionError
         if not hasattr(self, "max_level"):
             self.max_level = np.inf
         if not hasattr(self, "discrete_distrib"):
@@ -231,8 +232,10 @@ def f(self, x, *args, **kwargs):
         if periodization_transform in ["C1", "C1SIN", "C2SIN", "C3SIN"]:
             xp[xp <= 0] = self.EPS
             xp[xp >= 1] = 1 - self.EPS
-        assert wp.shape == batch_shape
-        assert xp.shape == x.shape
+        if not (wp.shape == batch_shape):
+            raise AssertionError
+        if not (xp.shape == x.shape):
+            raise AssertionError
         # function evaluation with chain rule
         i = (None,) * d_indv_ndim + (...,)
         if self.true_measure == self.true_measure.transform:
@@ -240,25 +243,33 @@ def f(self, x, *args, **kwargs):
             xtf = self.true_measure._jacobian_transform_r(
                 xp, return_weights=False
             )  # get transformed samples, equivalent to self.true_measure._transform_r(x)
-            assert xtf.shape == xp.shape
+            if not (xtf.shape == xp.shape):
+                raise AssertionError
             y = self._g(xtf, *args, **kwargs)
         else:  # using importance sampling --> need to compute pdf, jacobian(s), and weight explicitly
             pdf = self.discrete_distrib.pdf(xp)  # pdf of samples
-            assert pdf.shape == batch_shape
+            if not (pdf.shape == batch_shape):
+                raise AssertionError
             xtf, jacobians = self.true_measure.transform._jacobian_transform_r(
                 xp, return_weights=True
             )  # compute recursive transform+jacobian
-            assert xtf.shape == xp.shape
-            assert jacobians.shape == batch_shape
+            if not (xtf.shape == xp.shape):
+                raise AssertionError
+            if not (jacobians.shape == batch_shape):
+                raise AssertionError
             weight = self.true_measure._weight(xtf)  # weight based on the true measure
-            assert weight.shape == batch_shape
+            if not (weight.shape == batch_shape):
+                raise AssertionError
             gvals = self._g(xtf, *args, **kwargs)
-            assert gvals.shape == (self.d_indv + batch_shape)
+            if not (gvals.shape == (self.d_indv + batch_shape)):
+                raise AssertionError
             y = gvals * weight[i] / pdf[i] * jacobians[i]
-        assert y.shape == (self.d_indv + batch_shape)
+        if not (y.shape == (self.d_indv + batch_shape)):
+            raise AssertionError
         # account for periodization weight
         y = y * wp[i]
-        assert y.shape == (self.d_indv + batch_shape)
+        if not (y.shape == (self.d_indv + batch_shape)):
+            raise AssertionError
         return y
 
     def _g(self, t, *args, **kwargs):
@@ -275,10 +286,11 @@ def _g(self, t, *args, **kwargs):
         else:
             y = self._g2(t, comb_args=(args, kwargs))
         expected_y_shape = self.d_indv + t.shape[:-1]
-        assert y.shape == expected_y_shape, "expected y.shape to be %s but got %s" % (
-            str(expected_y_shape),
-            str(y.shape),
-        )
+        if not (y.shape == expected_y_shape):
+            raise AssertionError("expected y.shape to be %s but got %s" % (
+                str(expected_y_shape),
+                str(y.shape),
+            ))
         return y
 
     def _g2(self, t, comb_args=((), {})):
diff --git a/qmcpy/integrand/box_integral.py b/qmcpy/integrand/box_integral.py
index 9bcbcc5f3..0e9c77707 100644
--- a/qmcpy/integrand/box_integral.py
+++ b/qmcpy/integrand/box_integral.py
@@ -77,7 +77,8 @@ def __init__(self, sampler, s=1):
         """
         self.parameters = ["s"]
         self.s = np.array(s)
-        assert self.s.size > 0
+        if not (self.s.size > 0):
+            raise AssertionError
         self.sampler = sampler
         self.true_measure = Uniform(self.sampler)
         self.s_over_2 = self.s / 2
diff --git a/qmcpy/integrand/financial_option.py b/qmcpy/integrand/financial_option.py
index 6f9ce5752..3a208aff4 100644
--- a/qmcpy/integrand/financial_option.py
+++ b/qmcpy/integrand/financial_option.py
@@ -315,34 +315,40 @@ def __init__(
         if self.level is not None:
             self.multilevel = True
             self.parameters += ["level", "d_coarsest"]
-            assert np.isscalar(self.level) and self.level % 1 == 0
-            assert (
+            if not (np.isscalar(self.level) and self.level % 1 == 0):
+                raise AssertionError
+            if not (
                 np.isscalar(self.d_coarsest)
                 and self.d_coarsest % 1 == 0
                 and d_coarsest > 0
                 and np.log2(d_coarsest) % 1 == 0
-            ), "d_coarsest must be an integer power of 2"
+            ):
+                raise AssertionError("d_coarsest must be an integer power of 2")
             self.level = int(self.level)
             self.d_coarsest = int(self.d_coarsest)
-            assert (
+            if not (
                 self.sampler.d == self.d_coarsest * 2**self.level
-            ), "the dimension of the sampler must equal d_coarsest*2^level = %d" % (
-                d_coarsest * 2**self.level
-            )
+            ):
+                raise AssertionError("the dimension of the sampler must equal d_coarsest*2^level = %d" % (
+                    d_coarsest * 2**self.level
+                ))
             self.cost = self.d_coarsest * 2**self.level
             dim_shape = (2,)
         else:
             self.multilevel = False
             dim_shape = ()
         self.call_put = str(call_put).upper()
-        assert self.call_put in ["CALL", "PUT"], "invalid call_put = %s" % self.call_put
+        if not (self.call_put in ["CALL", "PUT"]):
+            raise AssertionError("invalid call_put = %s" % self.call_put)
         self.option = str(option).upper()
         self.asian_mean = str(asian_mean).upper()
         self.asian_mean_quadrature_rule = str(asian_mean_quadrature_rule).upper()
         self.barrier_in_out = str(barrier_in_out).upper()
-        assert np.isscalar(barrier_price)
+        if not (np.isscalar(barrier_price)):
+            raise AssertionError
         self.barrier_price = float(barrier_price)
-        assert np.isscalar(digital_payout) and digital_payout > 0
+        if not (np.isscalar(digital_payout) and digital_payout > 0):
+            raise AssertionError
         self.digital_payout = float(digital_payout)
         if self.option == "EUROPEAN":
             self.payoff = (
@@ -352,13 +358,15 @@ def __init__(
             )
         elif self.option == "ASIAN":
             self.parameters += ["asian_mean"]
-            assert self.asian_mean in ["ARITHMETIC", "GEOMETRIC"], (
-                "invalid asian_mean = %s" % self.asian_mean
-            )
-            assert self.asian_mean_quadrature_rule in ["TRAPEZOIDAL", "RIGHT"], (
-                "invalid asian_mean_quadrature_rule = %s"
-                % self.asian_mean_quadrature_rule
-            )
+            if not (self.asian_mean in ["ARITHMETIC", "GEOMETRIC"]):
+                raise AssertionError(
+                    "invalid asian_mean = %s" % self.asian_mean
+                )
+            if not (self.asian_mean_quadrature_rule in ["TRAPEZOIDAL", "RIGHT"]):
+                raise AssertionError(
+                    "invalid asian_mean_quadrature_rule = %s"
+                    % self.asian_mean_quadrature_rule
+                )
             if self.asian_mean == "ARITHMETIC":
                 if self.asian_mean_quadrature_rule == "TRAPEZOIDAL":
                     self.payoff = (
@@ -627,10 +635,11 @@ def get_exact_value(self):
                     term2 / denom
                 )
         elif self.option == "ASIAN":
-            assert (
+            if not (
                 self.asian_mean == "GEOMETRIC"
                 and self.asian_mean_quadrature_rule == "RIGHT"
-            ), "exact value for Asian options only implemented for self.asian_mean=='GEOMETRIC' and self.asian_mean_quadrature_rule=='RIGHT'"
+            ):
+                raise AssertionError("exact value for Asian options only implemented for self.asian_mean=='GEOMETRIC' and self.asian_mean_quadrature_rule=='RIGHT'")
             Tbar = (1 + 1 / self.d) * self.t_final / 2
             sigmabar = self.volatility * np.sqrt((2 + 1 / self.d) / 3)
             rbar = self.interest_rate + (sigmabar**2 - self.volatility**2) / 2
@@ -658,9 +667,10 @@ def get_exact_value_inf_dim(self):
             Exact value of the integral.
         """
         if self.option == "ASIAN":
-            assert (
+            if not (
                 self.asian_mean == "GEOMETRIC"
-            ), "get_exact_value_inf_dim for the Asian option only available for self.asian_mean=='GEOMETRIC'"
+            ):
+                raise AssertionError("get_exact_value_inf_dim for the Asian option only available for self.asian_mean=='GEOMETRIC'")
             sigma_g = self.volatility / np.sqrt(3)
             b = 1 / 2 * (self.interest_rate - 1 / 2 * sigma_g**2)
             d1 = (
diff --git a/qmcpy/integrand/fourbranch2d.py b/qmcpy/integrand/fourbranch2d.py
index d21250faa..f2e6e6e27 100644
--- a/qmcpy/integrand/fourbranch2d.py
+++ b/qmcpy/integrand/fourbranch2d.py
@@ -54,7 +54,8 @@ def __init__(self, sampler):
                 - a true measure by which to compose a transform.
         """
         self.sampler = sampler
-        assert self.sampler.d == 2
+        if not (self.sampler.d == 2):
+            raise AssertionError
         self.true_measure = Uniform(self.sampler, lower_bound=-8, upper_bound=8)
         super(FourBranch2d, self).__init__(
             dimension_indv=(), dimension_comb=(), parallel=False
diff --git a/qmcpy/integrand/hartmann6d.py b/qmcpy/integrand/hartmann6d.py
index 39a90e72b..9a764de63 100644
--- a/qmcpy/integrand/hartmann6d.py
+++ b/qmcpy/integrand/hartmann6d.py
@@ -54,7 +54,8 @@ def __init__(self, sampler):
                 - a true measure by which to compose a transform.
         """
         self.sampler = sampler
-        assert self.sampler.d == 6
+        if not (self.sampler.d == 6):
+            raise AssertionError
         self.true_measure = Uniform(self.sampler, lower_bound=0, upper_bound=1)
         super(Hartmann6d, self).__init__(
             dimension_indv=(), dimension_comb=(), parallel=False
diff --git a/qmcpy/integrand/ishigami.py b/qmcpy/integrand/ishigami.py
index fecab2792..41b59b2b6 100644
--- a/qmcpy/integrand/ishigami.py
+++ b/qmcpy/integrand/ishigami.py
@@ -86,7 +86,8 @@ def _spawn(self, level, sampler):
     @staticmethod
     def _exact_sensitivity_indices(indices, a, b):
         a, b = np.atleast_1d(a), np.atleast_1d(b)
-        assert a.shape == b.shape and a.ndim == 1 and b.ndim == 1
+        if not (a.shape == b.shape and a.ndim == 1 and b.ndim == 1):
+            raise AssertionError
         mu = a / 2
         m2 = 1 / 2 + 3 / 8 * a**2 + np.pi**4 / 5 * b + np.pi**8 / 18 * b**2
         tau_closed = {
@@ -125,7 +126,8 @@ def _exact_fu_functions(x, indices, a, b):
         x = np.atleast_2d(x)
         n = len(x)
         a, b = np.atleast_1d(a), np.atleast_1d(b)
-        assert x.ndim == 2 and x.shape == (n, 3) and a.shape == (1,) and b.shape == (1,)
+        if not (x.ndim == 2 and x.shape == (n, 3) and a.shape == (1,) and b.shape == (1,)):
+            raise AssertionError
         x0, x1, x2 = x[:, 0], x[:, 1], x[:, 2]
         fus = {
             repr([]): a / 2,
diff --git a/qmcpy/integrand/multimodal2d.py b/qmcpy/integrand/multimodal2d.py
index db4c1edeb..0c3a808db 100644
--- a/qmcpy/integrand/multimodal2d.py
+++ b/qmcpy/integrand/multimodal2d.py
@@ -51,7 +51,8 @@ def __init__(self, sampler):
                 - a true measure by which to compose a transform.
         """
         self.sampler = sampler
-        assert self.sampler.d == 2
+        if not (self.sampler.d == 2):
+            raise AssertionError
         self.true_measure = Uniform(
             self.sampler, lower_bound=[-4, -3], upper_bound=[7, 8]
         )
diff --git a/qmcpy/integrand/sensitivity_indices.py b/qmcpy/integrand/sensitivity_indices.py
index a6b9af8f4..c39339c3d 100644
--- a/qmcpy/integrand/sensitivity_indices.py
+++ b/qmcpy/integrand/sensitivity_indices.py
@@ -125,7 +125,8 @@ def __init__(self, integrand, indices="singletons"):
         self.parameters = ["indices"]
         self.integrand = integrand
         self.dtilde = self.integrand.d
-        assert self.dtilde > 1, "SensitivityIndices does not make sense for d=1"
+        if not (self.dtilde > 1):
+            raise AssertionError("SensitivityIndices does not make sense for d=1")
         self.indices = indices
         if isinstance(self.indices, str) and self.indices == "singletons":
             self.indices = np.eye(self.dtilde, dtype=bool)
@@ -139,14 +140,16 @@ def __init__(self, integrand, indices="singletons"):
                     idxs_r[i, comb] = True
                 self.indices = np.vstack([self.indices, idxs_r])
         self.indices = np.atleast_1d(self.indices)
-        assert (
+        if not (
             self.indices.dtype == bool
             and self.indices.ndim >= 1
             and self.indices.shape[-1] == self.dtilde
-        )
-        assert (
+        ):
+            raise AssertionError
+        if not (
             not (self.indices == self.indices[..., 0, None]).all(-1).any()
-        ), "indices cannot include the emptyset or the set of all dimensions"
+        ):
+            raise AssertionError("indices cannot include the emptyset or the set of all dimensions")
         self.not_indices = ~self.indices
         # sensitivity_index
         self.true_measure = self.integrand.true_measure
@@ -168,7 +171,8 @@ def f(self, x, *args, **kwargs):
             del kwargs["compute_flags"]
         else:
             compute_flags = np.ones(self.d_indv, dtype=bool)
-        assert compute_flags.shape == self.d_indv
+        if not (compute_flags.shape == self.d_indv):
+            raise AssertionError
         z = x[..., self.dtilde :]
         x = x[..., : self.dtilde]
         v = np.zeros_like(x)
diff --git a/qmcpy/integrand/sin1d.py b/qmcpy/integrand/sin1d.py
index 9d4d0b1aa..97f2e9298 100644
--- a/qmcpy/integrand/sin1d.py
+++ b/qmcpy/integrand/sin1d.py
@@ -52,7 +52,8 @@ def __init__(self, sampler, k=1):
         """
         self.sampler = sampler
         self.k = k
-        assert self.sampler.d == 1
+        if not (self.sampler.d == 1):
+            raise AssertionError
         self.true_measure = Uniform(
             self.sampler, lower_bound=0, upper_bound=2 * self.k * np.pi
         )
diff --git a/qmcpy/kernel/abstract_kernel.py b/qmcpy/kernel/abstract_kernel.py
index bd108d405..959638a00 100644
--- a/qmcpy/kernel/abstract_kernel.py
+++ b/qmcpy/kernel/abstract_kernel.py
@@ -31,7 +31,8 @@ def __new__(cls, *args, **kwargs):
     def __init__(self, d, torchify, device, compile_call, compile_call_kwargs):
         super().__init__()
         # dimension
-        assert d % 1 == 0 and d > 0, "dimension d must be a positive int"
+        if not (d % 1 == 0 and d > 0):
+            raise AssertionError("dimension d must be a positive int")
         self.d = d
         # torchify
         self.torchify = torchify
@@ -51,7 +52,8 @@ def __init__(self, d, torchify, device, compile_call, compile_call_kwargs):
             self.nptkwargs = {}
         self.batch_param_names = []
         if compile_call:
-            assert self.torchify, "compile_call requires torchify is True"
+            if not (self.torchify):
+                raise AssertionError("compile_call requires torchify is True")
             import torch
 
             self.compiled_parsed___call__ = torch.compile(
@@ -102,20 +104,24 @@ def __call__(self, x0, x1, beta0=None, beta1=None, c=None, **kwargs):
         Returns:
             Shape `y.shape=(x0+x1).shape[:-1]` kernel evaluations.
         """
-        assert isinstance(x0, self.nptarraytype)
-        assert isinstance(x0, self.nptarraytype)
-        assert (
+        if not (isinstance(x0, self.nptarraytype)):
+            raise AssertionError
+        if not (isinstance(x0, self.nptarraytype)):
+            raise AssertionError
+        if not (
             x0.shape[-1] == self.d
-        ), "the size of the last dimension of x0 must equal d=%d, got x0.shape=%s" % (
-            self.d,
-            str(tuple(x0.shape)),
-        )
-        assert (
+        ):
+            raise AssertionError("the size of the last dimension of x0 must equal d=%d, got x0.shape=%s" % (
+                self.d,
+                str(tuple(x0.shape)),
+            ))
+        if not (
             x1.shape[-1] == self.d
-        ), "the size of the last dimension of x1 must equal d=%d, got x1.shape=%s" % (
-            self.d,
-            str(tuple(x1.shape)),
-        )
+        ):
+            raise AssertionError("the size of the last dimension of x1 must equal d=%d, got x1.shape=%s" % (
+                self.d,
+                str(tuple(x1.shape)),
+            ))
         if beta0 is None:
             beta0 = self.npt.zeros((1, self.d), dtype=int, **self.nptkwargs)
         if beta1 is None:
@@ -126,37 +132,43 @@ def __call__(self, x0, x1, beta0=None, beta1=None, c=None, **kwargs):
             beta1 = self.nptarray(beta1)
         beta0 = self.npt.atleast_2d(beta0)
         beta1 = self.npt.atleast_2d(beta1)
-        assert (
+        if not (
             beta0.ndim == 2 and beta1.ndim == 2
-        ), "beta0 and beta1 must both be 2 dimensional"
+        ):
+            raise AssertionError("beta0 and beta1 must both be 2 dimensional")
         p = beta0.shape[0]
-        assert beta0.shape == (
-            p,
-            self.d,
-        ), "expected beta0.shape=(%d,%d) but got beta0.shape=%s" % (
+        if not (beta0.shape == (
             p,
             self.d,
-            str(tuple(beta0.shape)),
-        )
-        assert beta1.shape == (
-            p,
-            self.d,
-        ), "expected beta1.shape=(%d,%d) but got beta1.shape=%s" % (
+        )):
+            raise AssertionError("expected beta0.shape=(%d,%d) but got beta0.shape=%s" % (
+                p,
+                self.d,
+                str(tuple(beta0.shape)),
+            ))
+        if not (beta1.shape == (
             p,
             self.d,
-            str(tuple(beta1.shape)),
-        )
-        assert (beta0 % 1 == 0).all() and (beta0 >= 0).all(), "require int beta0 >= 0"
-        assert (beta1 % 1 == 0).all() and (beta1 >= 0).all(), "require int beta1 >= 0"
+        )):
+            raise AssertionError("expected beta1.shape=(%d,%d) but got beta1.shape=%s" % (
+                p,
+                self.d,
+                str(tuple(beta1.shape)),
+            ))
+        if not ((beta0 % 1 == 0).all() and (beta0 >= 0).all()):
+            raise AssertionError("require int beta0 >= 0")
+        if not ((beta1 % 1 == 0).all() and (beta1 >= 0).all()):
+            raise AssertionError("require int beta1 >= 0")
         if c is None:
             c = self.npt.ones(p, **self.nptkwargs)
         if not isinstance(c, self.nptarraytype):
             c = self.nptarray(c)
         c = self.npt.atleast_1d(c)
-        assert c.shape == (p,), "expected c.shape=(%d,) but got c.shape=%s" % (
-            p,
-            str(tuple(c.shape)),
-        )
+        if not (c.shape == (p,)):
+            raise AssertionError("expected c.shape=(%d,) but got c.shape=%s" % (
+                p,
+                str(tuple(c.shape)),
+            ))
         if not self.AUTOGRADKERNEL:
             batch_params = self.get_batch_params(max(x0.ndim - 1, x1.ndim - 1))
             k = self.compiled_parsed___call__(
@@ -169,7 +181,8 @@ def __call__(self, x0, x1, beta0=None, beta1=None, c=None, **kwargs):
                     x0, x1, batch_params, **kwargs
                 )
             else:  # requires autograd, so self.npt=torch
-                assert self.torchify, "autograd requires torchify=True"
+                if not (self.torchify):
+                    raise AssertionError("autograd requires torchify=True")
                 import torch
 
                 incoming_grad_enabled = torch.is_grad_enabled()
@@ -275,15 +288,18 @@ def single_integral_01d(self, x):
             Shape `y.shape=x.shape[:-1]` integral kernel evaluations.
         """
         if self.npt == np:
-            assert isinstance(x, np.ndarray)
+            if not (isinstance(x, np.ndarray)):
+                raise AssertionError
         else:  # self.npt==torch
-            assert isinstance(x, self.npt.Tensor)
-        assert (
+            if not (isinstance(x, self.npt.Tensor)):
+                raise AssertionError
+        if not (
             x.shape[-1] == self.d
-        ), "the size of the last dimension of x must equal d=%d, got x.shape=%s" % (
-            self.d,
-            str(tuple(x.shape)),
-        )
+        ):
+            raise AssertionError("the size of the last dimension of x must equal d=%d, got x.shape=%s" % (
+                self.d,
+                str(tuple(x.shape)),
+            ))
         batch_params = self.get_batch_params(x.ndim - 1)
         return self.parsed_single_integral_01d(x, batch_params)
 
diff --git a/qmcpy/kernel/multitask_kernel.py b/qmcpy/kernel/multitask_kernel.py
index dfa23a933..4a8f05657 100644
--- a/qmcpy/kernel/multitask_kernel.py
+++ b/qmcpy/kernel/multitask_kernel.py
@@ -362,7 +362,8 @@ def __init__(
                 `requires_grad=True` for `diag`.
             method (str): `"LOW RANK"` or "CHOLESKY"
         """
-        assert isinstance(base_kernel, AbstractKernel)
+        if not (isinstance(base_kernel, AbstractKernel)):
+            raise AssertionError
         super().__init__(
             d=base_kernel.d,
             torchify=base_kernel.torchify,
@@ -372,13 +373,15 @@ def __init__(
         )
         self.base_kernel = base_kernel
         self.AUTOGRADKERNEL = base_kernel.AUTOGRADKERNEL
-        assert np.isscalar(num_tasks) and num_tasks % 1 == 0
+        if not (np.isscalar(num_tasks) and num_tasks % 1 == 0):
+            raise AssertionError
         self.num_tasks = num_tasks
-        assert (
+        if not (
             np.isscalar(rank_factor)
             and rank_factor % 1 == 0
             and 0 <= rank_factor <= self.num_tasks
-        )
+        ):
+            raise AssertionError
         self.method = str(method).upper().replace("_", " ").strip()
         if self.method == "LOW RANK":
             if shape_factor is None:
@@ -409,7 +412,8 @@ def __init__(
         )
         self.tfs_factor = tfs_factor
         if self.method == "LOW RANK":
-            assert self.raw_factor.shape[-2] == self.num_tasks
+            if not (self.raw_factor.shape[-2] == self.num_tasks):
+                raise AssertionError
         self.raw_diag = self.parse_assign_param(
             pname="diag",
             param=diag,
diff --git a/qmcpy/kernel/si_dsi_kernels.py b/qmcpy/kernel/si_dsi_kernels.py
index dc991869b..a1c19a4bc 100644
--- a/qmcpy/kernel/si_dsi_kernels.py
+++ b/qmcpy/kernel/si_dsi_kernels.py
@@ -402,8 +402,10 @@ def __init__(
             tfs_weights=tfs_weights,
             requires_grad_weights=requires_grad_weights,
         )
-        assert self.alpha.shape == (self.d,)
-        assert all(int(alphaj) in BERNOULLIPOLYSDICT for alphaj in self.alpha)
+        if not (self.alpha.shape == (self.d,)):
+            raise AssertionError
+        if not (all(int(alphaj) in BERNOULLIPOLYSDICT for alphaj in self.alpha)):
+            raise AssertionError
         if self.torchify:
             import torch
 
@@ -415,9 +417,10 @@ def get_per_dim_components(self, x0, x1, beta0, beta1):
         p = len(beta0)
         betasum = beta0 + beta1
         order = 2 * self.alpha - betasum
-        assert (
+        if not ((
             2 <= order
-        ).all(), "order must all be at least 2, but got order = %s" % str(order)
+        ).all()):
+            raise AssertionError("order must all be at least 2, but got order = %s" % str(order))
         coeffs = (-1) ** (self.alpha + beta1 + 1) * self.npt.exp(
             2 * self.alpha * np.log(2 * np.pi) - self.lgamma(order + 1)
         )
@@ -628,7 +631,8 @@ def __init__(
             tfs_weights=tfs_weights,
             requires_grad_weights=requires_grad_weights,
         )
-        assert self.alpha.shape[-2:] == (4, d)
+        if not (self.alpha.shape[-2:] == (4, d)):
+            raise AssertionError
         if self.torchify:
             import torch
 
@@ -642,9 +646,10 @@ def __init__(
 
     def get_per_dim_components(self, x0, x1, beta0, beta1):
         p = len(beta0)
-        assert (beta0 == 0).all() and (
+        if not ((beta0 == 0).all() and (
             beta1 == 0
-        ).all(), "KernelDSICombined does not support derivatives"
+        ).all()):
+            raise AssertionError("KernelDSICombined does not support derivatives")
         delta = (x0 - x1) % 1
         kparts = [None] * 4
         kparts[0] = bernoulli_poly(1, delta)
@@ -898,9 +903,11 @@ def __init__(
             tfs_weights=tfs_weights,
             requires_grad_weights=requires_grad_weights,
         )
-        assert self.alpha.shape == (self.d,)
+        if not (self.alpha.shape == (self.d,)):
+            raise AssertionError
         self.set_t(t)
-        assert all(1 <= int(alphaj) <= 4 for alphaj in self.alpha)
+        if not (all(1 <= int(alphaj) <= 4 for alphaj in self.alpha)):
+            raise AssertionError
 
     @property
     def t(self):
@@ -912,11 +919,14 @@ def set_t(self, t):
         if t is None:
             self._t = t
         else:
-            assert t % 1 == 0
+            if not (t % 1 == 0):
+                raise AssertionError
             if self.torchify:
-                assert 0 <= t <= 63  # torch only supports torch.int64
+                if not (0 <= t <= 63):  # torch only supports torch.int64
+                    raise AssertionError
             else:
-                assert 0 <= t <= 64  # numpy supports np.uint64
+                if not (0 <= t <= 64):  # numpy supports np.uint64
+                    raise AssertionError
             self._t = t
 
     def get_per_dim_components(self, x0, x1, beta0, beta1):
@@ -926,13 +936,15 @@ def get_per_dim_components(self, x0, x1, beta0, beta1):
         p = len(beta0)
         betasum = beta0 + beta1
         order = self.alpha - betasum
-        assert (1 <= order).all() and (order <= 4).all(), (
-            "order must all be between 2 and 4, but got order = %s. Try increasing alpha"
-            % str(order)
-        )
-        assert not (
+        if not ((1 <= order).all() and (order <= 4).all()):
+            raise AssertionError(
+                "order must all be between 2 and 4, but got order = %s. Try increasing alpha"
+                % str(order)
+            )
+        if not (not (
             (order == 1) * (self.alpha > 1)
-        ).any(), "taking the derivative of the order 2 digitally shift invariant kernel is not supported"
+        ).any()):
+            raise AssertionError("taking the derivative of the order 2 digitally shift invariant kernel is not supported")
         ind = 1.0 * (betasum > 0)
         delta = x0 ^ x1
         kparts = [None] * p
@@ -1194,20 +1206,24 @@ def set_t(self, t):
         if t is None:
             self._t = t
         else:
-            assert t % 1 == 0
+            if not (t % 1 == 0):
+                raise AssertionError
             if self.torchify:
-                assert 0 <= t <= 63  # torch only supports torch.int64
+                if not (0 <= t <= 63):  # torch only supports torch.int64
+                    raise AssertionError
             else:
-                assert 0 <= t <= 64  # numpy supports np.uint64
+                if not (0 <= t <= 64):  # numpy supports np.uint64
+                    raise AssertionError
             self._t = t
 
     def get_per_dim_components(self, x0, x1, beta0, beta1):
         t = self.t
         x0 = to_bin(x0, t)
         x1 = to_bin(x1, t)
-        assert (beta0 == 0).all() and (
+        if not ((beta0 == 0).all() and (
             beta1 == 0
-        ).all(), "KernelDigShiftInvarAdaptiveAlpha does not support taking derivatives"
+        ).all()):
+            raise AssertionError("KernelDigShiftInvarAdaptiveAlpha does not support taking derivatives")
         p = len(beta0)
         delta = x0 ^ x1
         flog2delta = self.npt.zeros(delta.shape, **self.nptkwargs)  # should be -inf
@@ -1429,7 +1445,8 @@ def __init__(
             requires_grad_weights=requires_grad_weights,
         )
         self.set_t(t)
-        assert self.alpha.shape[-2:] == (4, d)
+        if not (self.alpha.shape[-2:] == (4, d)):
+            raise AssertionError
 
     @property
     def t(self):
@@ -1441,11 +1458,14 @@ def set_t(self, t):
         if t is None:
             self._t = t
         else:
-            assert t % 1 == 0
+            if not (t % 1 == 0):
+                raise AssertionError
             if self.torchify:
-                assert 0 <= t <= 63  # torch only supports torch.int64
+                if not (0 <= t <= 63):  # torch only supports torch.int64
+                    raise AssertionError
             else:
-                assert 0 <= t <= 64  # numpy supports np.uint64
+                if not (0 <= t <= 64):  # numpy supports np.uint64
+                    raise AssertionError
             self._t = t
 
     def get_per_dim_components(self, x0, x1, beta0, beta1):
@@ -1453,9 +1473,10 @@ def get_per_dim_components(self, x0, x1, beta0, beta1):
         x0 = to_bin(x0, t)
         x1 = to_bin(x1, t)
         p = len(beta0)
-        assert (beta0 == 0).all() and (
+        if not ((beta0 == 0).all() and (
             beta1 == 0
-        ).all(), "KernelDSICombined does not support derivatives"
+        ).all()):
+            raise AssertionError("KernelDSICombined does not support derivatives")
         delta = x0 ^ x1
         kparts = [None] * 4
         flog2deltaj = -self.npt.inf * self.npt.ones(delta.shape, **self.nptkwargs)
diff --git a/qmcpy/stopping_criterion/abstract_cub_mlmc.py b/qmcpy/stopping_criterion/abstract_cub_mlmc.py
index 8946d6833..a1020d2d3 100644
--- a/qmcpy/stopping_criterion/abstract_cub_mlmc.py
+++ b/qmcpy/stopping_criterion/abstract_cub_mlmc.py
@@ -66,7 +66,8 @@ def _get_next_samples(self, data):
         return ns.astype(int)
 
     def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
-        assert rel_tol is None, "rel_tol not supported by this stopping criterion."
+        if not (rel_tol is None):
+            raise AssertionError("rel_tol not supported by this stopping criterion.")
         if rmse_tol != None:
             self.rmse_tol = float(rmse_tol)
         elif abs_tol != None:
diff --git a/qmcpy/stopping_criterion/abstract_cub_mlqmc.py b/qmcpy/stopping_criterion/abstract_cub_mlqmc.py
index 9e0a119c3..001ff57a2 100644
--- a/qmcpy/stopping_criterion/abstract_cub_mlqmc.py
+++ b/qmcpy/stopping_criterion/abstract_cub_mlqmc.py
@@ -100,7 +100,8 @@ def _resume_match_from_snapshots(snapshots, checkpoint):
         return None, None
 
     def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
-        assert rel_tol is None, "rel_tol not supported by this stopping criterion."
+        if not (rel_tol is None):
+            raise AssertionError("rel_tol not supported by this stopping criterion.")
         if rmse_tol != None:
             self.rmse_tol = float(rmse_tol)
         elif abs_tol != None:
diff --git a/qmcpy/stopping_criterion/abstract_stopping_criterion.py b/qmcpy/stopping_criterion/abstract_stopping_criterion.py
index b974e13f1..d50ef5921 100644
--- a/qmcpy/stopping_criterion/abstract_stopping_criterion.py
+++ b/qmcpy/stopping_criterion/abstract_stopping_criterion.py
@@ -649,7 +649,8 @@ def _init_control_variates(self, control_variates, control_variate_means):
         if isinstance(self.cv, AbstractIntegrand):
             self.cv = [self.cv]
             self.cv_mu = self.cv_mu[None, ...]
-        assert isinstance(self.cv, list), "cv must be a list of AbstractIntegrand objects"
+        if not (isinstance(self.cv, list)):
+            raise AssertionError("cv must be a list of AbstractIntegrand objects")
         for cv in self.cv:
             if (
                 (not isinstance(cv, AbstractIntegrand))
diff --git a/qmcpy/stopping_criterion/cub_mc_clt.py b/qmcpy/stopping_criterion/cub_mc_clt.py
index 3f56229b4..cfceeefe2 100644
--- a/qmcpy/stopping_criterion/cub_mc_clt.py
+++ b/qmcpy/stopping_criterion/cub_mc_clt.py
@@ -168,13 +168,16 @@ def __init__(
         self.rel_tol = rel_tol
         self.n_init = n_init
         self.n_limit = n_limit
-        assert self.n_limit > (
+        if not (self.n_limit > (
             2 * self.n_init
-        ), "require n_limit is at least twic as much as n_init"
+        )):
+            raise AssertionError("require n_limit is at least twic as much as n_init")
         self.alpha = alpha
         self.inflate = inflate
-        assert self.inflate >= 1
-        assert 0 < self.alpha < 1
+        if not (self.inflate >= 1):
+            raise AssertionError
+        if not (0 < self.alpha < 1):
+            raise AssertionError
         # QMCPy Objs
         self.integrand = integrand
         self.true_measure = self.integrand.true_measure
@@ -183,13 +186,15 @@ def __init__(
             allowed_distribs=[AbstractIIDDiscreteDistribution],
             allow_vectorized_integrals=True,
         )
-        assert self.integrand.d_indv == ()
+        if not (self.integrand.d_indv == ()):
+            raise AssertionError
         # control variates
         self._init_control_variates(control_variates, control_variate_means)
         if self.ncv > 0:
-            assert self.cv_mu.shape == (
+            if not (self.cv_mu.shape == (
                 (self.ncv,) + self.integrand.d_indv
-            ), "Control variate means should have shape (len(control variates),d_indv)."
+            )):
+                raise AssertionError("Control variate means should have shape (len(control variates),d_indv).")
             self.parameters += ["cv", "cv_mu"]
         self.z_star = -norm.ppf(self.alpha / 2.0)
 
@@ -276,7 +281,8 @@ def integrate(self, resume=None):
         return data.solution, data
 
     def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
-        assert rmse_tol is None, "rmse_tol not supported by this stopping criterion."
+        if not (rmse_tol is None):
+            raise AssertionError("rmse_tol not supported by this stopping criterion.")
         if abs_tol is not None:
             self.abs_tol = abs_tol
         if rel_tol is not None:
diff --git a/qmcpy/stopping_criterion/cub_mc_clt_vec.py b/qmcpy/stopping_criterion/cub_mc_clt_vec.py
index 9a7964dab..3ff22c4c8 100644
--- a/qmcpy/stopping_criterion/cub_mc_clt_vec.py
+++ b/qmcpy/stopping_criterion/cub_mc_clt_vec.py
@@ -215,11 +215,13 @@ def __init__(
         # Set Attributes
         self.n_init = int(n_init)
         self.n_limit = int(n_limit)
-        assert isinstance(error_fun, str) or callable(error_fun)
+        if not (isinstance(error_fun, str) or callable(error_fun)):
+            raise AssertionError
         self.error_fun, _ = self._resolve_error_fun(error_fun)
         self.alpha = alpha
         self.inflate = float(inflate)
-        assert self.inflate >= 1
+        if not (self.inflate >= 1):
+            raise AssertionError
         # QMCPy Objs
         self.integrand = integrand
         self.true_measure = self.integrand.true_measure
@@ -228,9 +230,10 @@ def __init__(
             allowed_distribs=[AbstractIIDDiscreteDistribution],
             allow_vectorized_integrals=True,
         )
-        assert (
+        if not (
             self.integrand.discrete_distrib.no_replications == True
-        ), "Require the discrete distribution has replications=None"
+        ):
+            raise AssertionError("Require the discrete distribution has replications=None")
         self.alphas_indv, _ = self._compute_indv_alphas(
             np.full(self.integrand.d_comb, self.alpha)
         )
@@ -356,7 +359,8 @@ def integrate(self, resume=None):
         return data.solution, data
 
     def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
-        assert rmse_tol is None, "rmse_tol not supported by this stopping criterion."
+        if not (rmse_tol is None):
+            raise AssertionError("rmse_tol not supported by this stopping criterion.")
         if abs_tol is not None:
             self.abs_tol = abs_tol
             self.abs_tols = np.full(self.integrand.d_comb, self.abs_tol)
diff --git a/qmcpy/stopping_criterion/cub_mc_g.py b/qmcpy/stopping_criterion/cub_mc_g.py
index 77a55300e..5b3120727 100644
--- a/qmcpy/stopping_criterion/cub_mc_g.py
+++ b/qmcpy/stopping_criterion/cub_mc_g.py
@@ -303,13 +303,15 @@ def __init__(
             allowed_distribs=[AbstractIIDDiscreteDistribution],
             allow_vectorized_integrals=False,
         )
-        assert self.integrand.d_indv == ()
+        if not (self.integrand.d_indv == ()):
+            raise AssertionError
         # control variates
         self._init_control_variates(control_variates, control_variate_means)
         if self.ncv > 0:
-            assert self.cv_mu.shape == (
+            if not (self.cv_mu.shape == (
                 (self.ncv,) + self.integrand.d_indv
-            ), "Control variate means should have shape (len(control variates),d_indv)."
+            )):
+                raise AssertionError("Control variate means should have shape (len(control variates),d_indv).")
             self.parameters += ["cv", "cv_mu"]
 
     def _get_main_stage_samples(self, data):
@@ -532,7 +534,8 @@ def _ncbinv(self, n1, alpha1, kurtmax):
         return eps
 
     def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
-        assert rmse_tol is None, "rmse_tol not supported by this stopping criterion."
+        if not (rmse_tol is None):
+            raise AssertionError("rmse_tol not supported by this stopping criterion.")
         if abs_tol != None:
             self.abs_tol = abs_tol
         if rel_tol != None:
diff --git a/qmcpy/stopping_criterion/cub_mlmc.py b/qmcpy/stopping_criterion/cub_mlmc.py
index ed43298a0..d1a44d56d 100644
--- a/qmcpy/stopping_criterion/cub_mlmc.py
+++ b/qmcpy/stopping_criterion/cub_mlmc.py
@@ -121,7 +121,8 @@ def __init__(
         else:  # use absolute tolerance
             self.rmse_tol = float(abs_tol) / norm.ppf(1 - alpha / 2)
         self.alpha = alpha
-        assert 0 < self.alpha < 1
+        if not (0 < self.alpha < 1):
+            raise AssertionError
         self.n_init = n_init
         self.n_limit = n_limit
         self.levels_min = levels_min
diff --git a/qmcpy/stopping_criterion/cub_mlmc_cont.py b/qmcpy/stopping_criterion/cub_mlmc_cont.py
index 92710f3da..06e237169 100644
--- a/qmcpy/stopping_criterion/cub_mlmc_cont.py
+++ b/qmcpy/stopping_criterion/cub_mlmc_cont.py
@@ -141,8 +141,10 @@ def __init__(
         self._active_trace = None
         self.alpha = alpha
         self.inflate = inflate
-        assert self.inflate >= 1
-        assert 0 < self.alpha < 1
+        if not (self.inflate >= 1):
+            raise AssertionError
+        if not (0 < self.alpha < 1):
+            raise AssertionError
         super(CubMLMCCont, self).__init__(
             allowed_distribs=[AbstractIIDDiscreteDistribution],
             allow_vectorized_integrals=False,
diff --git a/qmcpy/stopping_criterion/cub_mlqmc.py b/qmcpy/stopping_criterion/cub_mlqmc.py
index 2ccd1a089..d0b1173ac 100644
--- a/qmcpy/stopping_criterion/cub_mlqmc.py
+++ b/qmcpy/stopping_criterion/cub_mlqmc.py
@@ -107,7 +107,8 @@ def __init__(
         else:  # use absolute tolerance
             self.rmse_tol = float(abs_tol) / norm.ppf(1 - alpha / 2)
         self.alpha = alpha
-        assert 0 < self.alpha < 1
+        if not (0 < self.alpha < 1):
+            raise AssertionError
         self.n_init = n_init
         self.n_limit = n_limit
         self.levels_min = levels_min
@@ -121,7 +122,8 @@ def __init__(
             allow_vectorized_integrals=False,
         )
         self.replications = self.discrete_distrib.replications
-        assert self.replications >= 4, "require at least 4 replications"
+        if not (self.replications >= 4):
+            raise AssertionError("require at least 4 replications")
 
     def _validate_resume(self, data):
         self._validate_resume_data(data, required_fields=self._RESUME_REQUIRED_FIELDS)
diff --git a/qmcpy/stopping_criterion/cub_mlqmc_cont.py b/qmcpy/stopping_criterion/cub_mlqmc_cont.py
index 459bfda09..934b2b6b1 100644
--- a/qmcpy/stopping_criterion/cub_mlqmc_cont.py
+++ b/qmcpy/stopping_criterion/cub_mlqmc_cont.py
@@ -137,8 +137,10 @@ def __init__(
         self._active_trace = None
         self.alpha = alpha
         self.inflate = inflate
-        assert self.inflate >= 1
-        assert 0 < self.alpha < 1
+        if not (self.inflate >= 1):
+            raise AssertionError
+        if not (0 < self.alpha < 1):
+            raise AssertionError
         # QMCPy Objs
         self.integrand = integrand
         self.true_measure = self.integrand.true_measure
@@ -148,7 +150,8 @@ def __init__(
             allow_vectorized_integrals=False,
         )
         self.replications = self.discrete_distrib.replications
-        assert self.replications >= 4, "require at least 4 replications"
+        if not (self.replications >= 4):
+            raise AssertionError("require at least 4 replications")
 
     def _validate_resume(self, data):
         self._validate_resume_data(data, required_fields=self._RESUME_REQUIRED_FIELDS)
diff --git a/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py b/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py
index 29e762003..0ec0f6e27 100644
--- a/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py
+++ b/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py
@@ -253,7 +253,8 @@ def __init__(
         # Set Attributes
         self.n_init = int(n_init)
         self.n_limit = int(n_limit)
-        assert isinstance(error_fun, str) or callable(error_fun)
+        if not (isinstance(error_fun, str) or callable(error_fun)):
+            raise AssertionError
         if isinstance(error_fun, str):
             if error_fun.upper() == "EITHER":
                 error_fun = lambda sv, abs_tol, rel_tol: np.maximum(
@@ -268,8 +269,10 @@ def __init__(
         self.error_fun = error_fun
         self.alpha = alpha
         self.inflate = float(inflate)
-        assert self.inflate >= 1
-        assert 0 < self.alpha < 1
+        if not (self.inflate >= 1):
+            raise AssertionError
+        if not (0 < self.alpha < 1):
+            raise AssertionError
         # QMCPy Objs
         self.integrand = integrand
         self.true_measure = self.integrand.true_measure
@@ -278,12 +281,14 @@ def __init__(
             allowed_distribs=[AbstractLDDiscreteDistribution],
             allow_vectorized_integrals=True,
         )
-        assert (
+        if not (
             self.integrand.discrete_distrib.replications > 1
-        ), "Require the discrete distribution has replications>1"
-        assert (
+        ):
+            raise AssertionError("Require the discrete distribution has replications>1")
+        if not (
             self.integrand.discrete_distrib.randomize != "FALSE"
-        ), "Require discrete distribution is randomized"
+        ):
+            raise AssertionError("Require discrete distribution is randomized")
         self.alphas_indv, _ = self._compute_indv_alphas(
             np.full(self.integrand.d_comb, self.alpha)
         )
@@ -429,7 +434,8 @@ def _restore_resume_state(self, data):
         self.integrand.true_measure.discrete_distrib = self.discrete_distrib
 
     def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
-        assert rmse_tol is None, "rmse_tol not supported by this stopping criterion."
+        if not (rmse_tol is None):
+            raise AssertionError("rmse_tol not supported by this stopping criterion.")
         if abs_tol is not None:
             self.abs_tol = abs_tol
             self.abs_tols = np.full(self.integrand.d_comb, self.abs_tol)
diff --git a/qmcpy/stopping_criterion/pf_gp_ci.py b/qmcpy/stopping_criterion/pf_gp_ci.py
index 3c1d1fbe6..a5f69fbbf 100644
--- a/qmcpy/stopping_criterion/pf_gp_ci.py
+++ b/qmcpy/stopping_criterion/pf_gp_ci.py
@@ -58,13 +58,15 @@ class SuggesterSimple(Suggester):
     def __init__(self, sampler):
         self.sampler = sampler
         if isinstance(self.sampler, AbstractTrueMeasure):
-            assert (self.sampler.range == [0, 1]).all()
+            if not ((self.sampler.range == [0, 1]).all()):
+                raise AssertionError
         self.n_min = 0
         super(SuggesterSimple, self).__init__()
 
     def suggest(self, n, d, gp, rng, **kwargs):
         n_max = self.n_min + n
-        assert d == self.sampler.d
+        if not (d == self.sampler.d):
+            raise AssertionError
         try:
             x = self.sampler(n_min=self.n_min, n_max=n_max)
         except TypeError:
@@ -252,23 +254,29 @@ def __init__(
         self.failure_above_threshold = failure_above_threshold
         self.abs_tol = abs_tol
         self.alpha = alpha
-        assert 0 < self.alpha < 1
+        if not (0 < self.alpha < 1):
+            raise AssertionError
         self.n_init = n_init
         self.init_samples = init_samples is not None
         if self.init_samples:
             self.x_init, self.y_init = init_samples
-            assert self.x_init.ndim == 2 and self.y_init.ndim == 1
-            assert self.x_init.shape[1] == self.d and len(self.y_init) == len(
+            if not (self.x_init.ndim == 2 and self.y_init.ndim == 1):
+                raise AssertionError
+            if not (self.x_init.shape[1] == self.d and len(self.y_init) == len(
                 self.x_init
-            )
-            assert self.n_init == len(self.x_init)
+            )):
+                raise AssertionError
+            if not (self.n_init == len(self.x_init)):
+                raise AssertionError
             self.ytf_init = self._affine_tf(self.y_init)
         self.batch_sampler = batch_sampler
         self.n_batch = n_batch
         self.n_limit = n_limit
-        assert self.n_limit >= self.n_init
+        if not (self.n_limit >= self.n_init):
+            raise AssertionError
         self.n_approx = n_approx
-        assert (self.n_approx + self.n_init) <= 2**32
+        if not ((self.n_approx + self.n_init) <= 2**32):
+            raise AssertionError
         self.gpytorch_prior_mean = gpytorch_prior_mean
         self.gpytorch_prior_cov = gpytorch_prior_cov
         self.gpytorch_likelihood = gpytorch_likelihood
diff --git a/qmcpy/true_measure/abstract_true_measure.py b/qmcpy/true_measure/abstract_true_measure.py
index b7cc7d35e..6e426fe2c 100644
--- a/qmcpy/true_measure/abstract_true_measure.py
+++ b/qmcpy/true_measure/abstract_true_measure.py
@@ -144,7 +144,8 @@ def gen_samples(
         self, n=None, n_min=None, n_max=None, return_weights=False, warn=True
     ):
         x = self.discrete_distrib(n=n, n_min=n_min, n_max=n_max, warn=warn)
-        assert isinstance(return_weights, bool)
+        if not (isinstance(return_weights, bool)):
+            raise AssertionError
         return self._jacobian_transform_r(x=x, return_weights=return_weights)
 
     def _jacobian_transform_r(self, x, return_weights):
diff --git a/qmcpy/true_measure/gaussian.py b/qmcpy/true_measure/gaussian.py
index 5207fa897..63ae5a25d 100644
--- a/qmcpy/true_measure/gaussian.py
+++ b/qmcpy/true_measure/gaussian.py
@@ -72,7 +72,8 @@ def __init__(self, sampler, mean=0.0, covariance=1.0, decomp_type="PCA"):
         self._parse_gaussian_params(mean, covariance, decomp_type)
         self.range = np.array([[-np.inf, np.inf]])
         super(Gaussian, self).__init__()
-        assert self.mu.shape == (self.d,) and self.a.shape == (self.d, self.d)
+        if not (self.mu.shape == (self.d,) and self.a.shape == (self.d, self.d)):
+            raise AssertionError
 
     def _parse_gaussian_params(self, mean, covariance, decomp_type, lazy_decomp=False):
         self.decomp_type = decomp_type.upper()
diff --git a/qmcpy/true_measure/johnsons_su.py b/qmcpy/true_measure/johnsons_su.py
index a8e79534b..1f5bdc2f4 100644
--- a/qmcpy/true_measure/johnsons_su.py
+++ b/qmcpy/true_measure/johnsons_su.py
@@ -86,12 +86,13 @@ def __init__(self, sampler, gamma=1, xi=1, delta=2, lam=2):
         if not ((self._delta > 0).all() and (self._lam > 0).all()):
             raise ParameterError("delta and lam must be all be positive")
         super(JohnsonsSU, self).__init__()
-        assert (
+        if not (
             self._gamma.shape == (self.d,)
             and self._xi.shape == (self.d,)
             and self._delta.shape == (self.d,)
             and self._lam.shape == (self.d,)
-        )
+        ):
+            raise AssertionError
 
     def _transform(self, x):
         return self._lam * np.sinh((norm.ppf(x) - self._gamma) / self._delta) + self._xi
diff --git a/qmcpy/true_measure/kumaraswamy.py b/qmcpy/true_measure/kumaraswamy.py
index cd769c3bd..8b7bc7f69 100644
--- a/qmcpy/true_measure/kumaraswamy.py
+++ b/qmcpy/true_measure/kumaraswamy.py
@@ -93,7 +93,8 @@ def __init__(self, sampler, a=2, b=2):
             covariance=diags(variance, format="dia"),
         )
         super(Kumaraswamy, self).__init__()
-        assert self.alpha.shape == (self.d,) and self.beta.shape == (self.d,)
+        if not (self.alpha.shape == (self.d,) and self.beta.shape == (self.d,)):
+            raise AssertionError
 
     def _compute_moments(self):
         r"""Compute the marginal mean and variance of each coordinate.
diff --git a/qmcpy/true_measure/matern_gp.py b/qmcpy/true_measure/matern_gp.py
index 82f8ea2fb..06588cfc8 100644
--- a/qmcpy/true_measure/matern_gp.py
+++ b/qmcpy/true_measure/matern_gp.py
@@ -122,24 +122,30 @@ def __init__(
             raise ParameterError("points must be a one or two dimensional np.ndarray.")
         if points.ndim == 1:
             points = points[:, None]
-        assert (
+        if not (
             points.ndim == 2 and points.shape[0] == sampler.d
-        ), "points should be a two dimension array with the number of points equal to the dimension of the sampler"
+        ):
+            raise AssertionError("points should be a two dimension array with the number of points equal to the dimension of the sampler")
         mean = np.array(mean)
         if mean.size == 1:
             mean = mean.item() * np.ones(sampler.d)
-        assert mean.shape == (sampler.d,), "mean should be a length d vector"
-        assert np.isscalar(nu) and nu > 0, "nu should be a positive scalar"
+        if not (mean.shape == (sampler.d,)):
+            raise AssertionError("mean should be a length d vector")
+        if not (np.isscalar(nu) and nu > 0):
+            raise AssertionError("nu should be a positive scalar")
         length_scale = np.array(length_scale)
         if length_scale.size == 1:
             length_scale = length_scale.item() * np.ones(sampler.d)
-        assert (
+        if not (
             length_scale.shape == (sampler.d,) and (length_scale > 0).all()
-        ), "length_scale should be a vector with length equal to the dimension of the sampler"
-        assert (
+        ):
+            raise AssertionError("length_scale should be a vector with length equal to the dimension of the sampler")
+        if not (
             np.isscalar(variance) and variance > 0
-        ), "variance should be a positive scalar"
-        assert np.isscalar(nugget) and nugget > 0, "nugget should be a positive scalar"
+        ):
+            raise AssertionError("variance should be a positive scalar")
+        if not (np.isscalar(nugget) and nugget > 0):
+            raise AssertionError("nugget should be a positive scalar")
         self.points = points
         self.length_scale = length_scale
         self.nu = nu
diff --git a/qmcpy/true_measure/scipy_wrapper.py b/qmcpy/true_measure/scipy_wrapper.py
index 1b6def14c..f85b60d54 100644
--- a/qmcpy/true_measure/scipy_wrapper.py
+++ b/qmcpy/true_measure/scipy_wrapper.py
@@ -362,7 +362,8 @@ def _setup_marginals(self, scipy_distribs):
         self.range = np.asarray(ranges)
         self._is_joint = False
 
-        assert len(self.sds) == self.d
+        if not (len(self.sds) == self.d):
+            raise AssertionError
 
     def _sanity_check_univariate(self, dist):
         """Light sanity check for a custom 1D distribution.
diff --git a/qmcpy/true_measure/uniform.py b/qmcpy/true_measure/uniform.py
index 3897acd52..1bc5f68da 100644
--- a/qmcpy/true_measure/uniform.py
+++ b/qmcpy/true_measure/uniform.py
@@ -95,7 +95,8 @@ def __init__(self, sampler, lower_bound=0, upper_bound=1):
             (self.a.reshape((self.d, 1)), self.b.reshape((self.d, 1)))
         )
         super(Uniform, self).__init__()
-        assert self.a.shape == (self.d,) and self.b.shape == (self.d,)
+        if not (self.a.shape == (self.d,) and self.b.shape == (self.d,)):
+            raise AssertionError
 
     def _transform(self, x):
         return x * self.delta + self.a
diff --git a/qmcpy/util/dig_shift_invar_ops.py b/qmcpy/util/dig_shift_invar_ops.py
index 9936afd90..fcb541cde 100644
--- a/qmcpy/util/dig_shift_invar_ops.py
+++ b/qmcpy/util/dig_shift_invar_ops.py
@@ -131,13 +131,16 @@ def weighted_walsh_funcs(alpha, xb, t):
             "The decay of the Walsh coefficients of smooth functions."
             Bulletin of the Australian Mathematical Society 80.3 (2009): 430-453.
     """
-    assert isinstance(alpha, int)
-    assert alpha in WEIGHTEDWALSHFUNCSPOS, (
-        "alpha = %d not in WEIGHTEDWALSHFUNCSPOS" % alpha
-    )
-    assert alpha in WEIGHTEDWALSHFUNCSZEROS, (
-        "alpha = %d not in WEIGHTEDWALSHFUNCSZEROS" % alpha
-    )
+    if not (isinstance(alpha, int)):
+        raise AssertionError
+    if not (alpha in WEIGHTEDWALSHFUNCSPOS):
+        raise AssertionError(
+            "alpha = %d not in WEIGHTEDWALSHFUNCSPOS" % alpha
+        )
+    if not (alpha in WEIGHTEDWALSHFUNCSZEROS):
+        raise AssertionError(
+            "alpha = %d not in WEIGHTEDWALSHFUNCSZEROS" % alpha
+        )
     if isinstance(xb, np.ndarray):
         np_or_torch = np
         y = np.ones(xb.shape)
@@ -265,8 +268,10 @@ def bin_from_numpy_to_torch(xb):
     Returns:
         binary representation of samples with `dtype=torch.int64`.
     """
-    assert xb.dtype == np.uint64
-    assert xb.max() <= (2**63 - 1), "require all xb < 2^63"
+    if not (xb.dtype == np.uint64):
+        raise AssertionError
+    if not (xb.max() <= (2**63 - 1)):
+        raise AssertionError("require all xb < 2^63")
     import torch
 
     return torch.from_numpy(xb.astype(np.int64))
diff --git a/qmcpy/util/shift_invar_ops.py b/qmcpy/util/shift_invar_ops.py
index 46769cf08..77f711c42 100644
--- a/qmcpy/util/shift_invar_ops.py
+++ b/qmcpy/util/shift_invar_ops.py
@@ -18,9 +18,11 @@ def __init__(self, coeffs):
             e.g. coeffs = [a, b, c] corresponds to the quadratic polynomial
             a*x**2 + b*x + c
         """
-        assert isinstance(coeffs, list)
+        if not (isinstance(coeffs, list)):
+            raise AssertionError
         self.order = len(coeffs)
-        assert self.order >= 1
+        if not (self.order >= 1):
+            raise AssertionError
         self.coeffs = coeffs
 
     def __call__(self, x):
@@ -108,8 +110,10 @@ def bernoulli_poly(n, x):
     Returns:
         Bernoulli polynomial values.
     """
-    assert isinstance(n, int)
-    assert n in BERNOULLIPOLYSDICT, "n = %d not in BERNOULLIPOLYSDICT" % n
+    if not (isinstance(n, int)):
+        raise AssertionError
+    if not (n in BERNOULLIPOLYSDICT):
+        raise AssertionError("n = %d not in BERNOULLIPOLYSDICT" % n)
     bpoly = BERNOULLIPOLYSDICT[n]
     y = bpoly(x)
     return y

From a03c04d6dedb06550257d11f5b2a7d34ba259500 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Sun, 6 Sep 2026 23:47:40 +0800
Subject: [PATCH 20/51] Add tools for Google style doc for input and output
 parameters of public APIs

---
 docs/good_practices.md                        |   4 +
 makefile                                      |  20 +-
 .../abstract_discrete_distribution.py         |   4 +-
 .../digital_net_any_bases.py                  |  12 +-
 .../digital_net_any_bases/hammersley.py       |   6 +-
 .../digital_net_b2/digital_net_b2.py          |  16 +-
 qmcpy/discrete_distribution/dummy_sampler.py  |   2 +-
 .../discrete_distribution/iid_std_uniform.py  |   2 +-
 qmcpy/discrete_distribution/korobov.py        |   8 +-
 qmcpy/discrete_distribution/kronecker.py      |  10 +-
 .../discrete_distribution/latin_hypercube.py  |   4 +-
 .../discrete_distribution/lattice/lattice.py  |  10 +-
 qmcpy/discrete_distribution/mpmc/mpmc.py      |   2 +-
 qmcpy/fast_transform/ft.py                    |  10 +-
 qmcpy/fast_transform/ft_pytorch.py            |  10 +-
 qmcpy/fast_transform/ft_qmctoolscl.py         |   6 +-
 qmcpy/integrand/abstract_integrand.py         |  14 +-
 qmcpy/integrand/bayesian_lr_coeffs.py         |   4 +-
 qmcpy/integrand/box_integral.py               |   2 +-
 qmcpy/integrand/custom_fun.py                 |   2 +-
 qmcpy/integrand/financial_option.py           |  38 +-
 qmcpy/integrand/fourbranch2d.py               |   2 +-
 qmcpy/integrand/genz.py                       |   2 +-
 qmcpy/integrand/hartmann6d.py                 |   2 +-
 qmcpy/integrand/ishigami.py                   |   2 +-
 qmcpy/integrand/keister.py                    |   4 +-
 qmcpy/integrand/linear0.py                    |   2 +-
 qmcpy/integrand/multimodal2d.py               |   2 +-
 qmcpy/integrand/sensitivity_indices.py        |   2 +-
 qmcpy/integrand/sin1d.py                      |   2 +-
 qmcpy/integrand/umbridge_wrapper.py           |   4 +-
 qmcpy/kernel/abstract_kernel.py               |  20 +-
 qmcpy/kernel/common_kernels.py                |  22 +-
 qmcpy/kernel/multitask_kernel.py              |  18 +-
 qmcpy/kernel/si_dsi_kernels.py                | 130 ++--
 .../abstract_stopping_criterion.py            |  20 +-
 qmcpy/stopping_criterion/cub_mc_clt.py        |  20 +-
 qmcpy/stopping_criterion/cub_mc_clt_vec.py    |  14 +-
 qmcpy/stopping_criterion/cub_mc_g.py          |  20 +-
 qmcpy/stopping_criterion/cub_mlmc.py          |  16 +-
 qmcpy/stopping_criterion/cub_mlmc_cont.py     |  16 +-
 qmcpy/stopping_criterion/cub_mlqmc.py         |  10 +-
 qmcpy/stopping_criterion/cub_mlqmc_cont.py    |  16 +-
 .../cub_qmc_bayes_lattice_g.py                |  18 +-
 .../stopping_criterion/cub_qmc_bayes_net_g.py |  14 +-
 qmcpy/stopping_criterion/cub_qmc_lattice_g.py |  14 +-
 qmcpy/stopping_criterion/cub_qmc_net_g.py     |  18 +-
 .../cub_qmc_rep_student_t.py                  |  14 +-
 qmcpy/stopping_criterion/pf_gp_ci.py          |  42 +-
 qmcpy/true_measure/abstract_true_measure.py   |   4 +-
 qmcpy/true_measure/acceptance_rejection.py    |   8 +-
 qmcpy/true_measure/bernoulli_cont.py          |   2 +-
 qmcpy/true_measure/brownian_motion.py         |  18 +-
 qmcpy/true_measure/clayton_copula.py          |   2 +-
 qmcpy/true_measure/copula.py                  |   6 +-
 qmcpy/true_measure/frank_copula.py            |   2 +-
 qmcpy/true_measure/gaussian.py                |   2 +-
 qmcpy/true_measure/gaussian_copula.py         |   2 +-
 .../true_measure/geometric_brownian_motion.py |  20 +-
 qmcpy/true_measure/gumbel_copula.py           |   2 +-
 qmcpy/true_measure/johnsons_su.py             |   2 +-
 qmcpy/true_measure/kumaraswamy.py             |   2 +-
 qmcpy/true_measure/lebesgue.py                |   2 +-
 qmcpy/true_measure/matern_gp.py               |  18 +-
 qmcpy/true_measure/product_measure.py         |   2 +-
 qmcpy/true_measure/scipy_wrapper.py           |   2 +-
 qmcpy/true_measure/student_t.py               |   2 +-
 qmcpy/true_measure/student_t_copula.py        |   2 +-
 qmcpy/true_measure/triangular.py              |   4 +-
 qmcpy/true_measure/uniform.py                 |   2 +-
 qmcpy/true_measure/uniform_triangle.py        |   2 +-
 .../true_measure/zero_inflated_exp_uniform.py |   2 +-
 qmcpy/util/data.py                            |   4 +-
 qmcpy/util/dig_shift_invar_ops.py             |   8 +-
 qmcpy/util/exceptions_warnings.py             |   2 +-
 qmcpy/util/latnetbuilder_linker.py            |   2 +-
 qmcpy/util/mlmc_test.py                       |  12 +-
 qmcpy/util/plot_functions.py                  |  18 +-
 qmcpy/util/shift_invar_ops.py                 |   4 +-
 scripts/add_docstring_arg_types.py            | 263 ++++++-
 scripts/annotate_public_api_types.py          | 731 ++++++++++++++++++
 test/test_sr_annotate_public_api_types.py     | 230 ++++++
 test/test_sr_docstring_arg_types.py           |  87 ++-
 83 files changed, 1694 insertions(+), 429 deletions(-)
 create mode 100644 scripts/annotate_public_api_types.py
 create mode 100644 test/test_sr_annotate_public_api_types.py

diff --git a/docs/good_practices.md b/docs/good_practices.md
index ade5c308d..36261725d 100644
--- a/docs/good_practices.md
+++ b/docs/good_practices.md
@@ -53,6 +53,10 @@ It is informational by default; `STRICT=--strict make check_docstring` makes bot
 
 For annotated public APIs, `make add_docstring_arg_types` inserts missing Google-style argument types into existing `Args:` entries from the function signature. For example, `distance: float` becomes `distance (float): ...` in the docstring. Use `DOCSTRING_TYPE_PATH=path/to/file.py` to narrow the scan, or run `make add_docstring_arg_types_changed` to apply it only to Python files reported by `git diff --name-only develop -- '*.py'`. Use `DOCSTRING_TYPE_DIFF_BASE=origin/develop` to compare against a different base, and use `make check_docstring_arg_types_changed` to fail when changed files still need annotation-derived updates. The helper does not infer types for unannotated functions and does not invent missing scientific argument descriptions.
 
+For changed public APIs, `make annotate_public_api_types_changed` performs the reverse operation conservatively: it copies explicit, valid Google `Args:` and `Returns:` types into missing function annotations and adds `-> None` to constructors. It never replaces an existing annotation. Types that are prose, use syntax unsafe for Python 3.9, or reference names not already available in the module are reported and skipped. Then `make sync_docstring_types_changed` copies the resulting signature annotations back into existing `Args:`, `Returns:`, and `Yields:` descriptions. Run the annotation target before the synchronization target, review the complete diff, and run `make check_public_api_types_changed` for a non-mutating consistency check. All three targets default to files under `qmcpy/` changed relative to `develop`; override this with `PUBLIC_API_TYPE_PATH` or `PUBLIC_API_TYPE_DIFF_BASE`.
+
+These helpers synchronize explicit type information; they do not infer a scientific API contract from default values, implementation expressions, or one observed runtime type. They also do not invent missing docstring descriptions or sections. Resolve every reported conflict manually, especially scalar-versus-array inputs, optional values, shape conventions, and abstract interfaces.
+
 For mostly well-formed Google-style docstrings, developers may also use the optional open-source `format-docstring` helper to normalize wrapping and existing argument type syntax. Install it locally with `python -m pip install format-docstring`, then run `make format_google_docstrings` to apply it under `qmcpy/`, or run `make format_google_docstrings_changed` to apply it only to Python files reported by `git diff --name-only develop -- '*.py'`. Always review the resulting diff because automated formatting can reflow examples and prose.
 
 ## Extend the Existing Object Model
diff --git a/makefile b/makefile
index 164072323..6789747e2 100644
--- a/makefile
+++ b/makefile
@@ -59,12 +59,14 @@ ASSERT_DIFF_BASE ?= develop
 ASSERT_EXCEPTION ?= AssertionError
 ASSERT_CONVERT_ARGS ?=
 
-check_assert_codemod_dependency:
+check_libcst_dependency:
 	@$(PYTHON) -c "import libcst" 2>/dev/null || { \
 		echo 'Missing LibCST. Install the test tools with: $(PYTHON) -m pip install -e ".[test]"'; \
 		exit 127; \
 	}
 
+check_assert_codemod_dependency: check_libcst_dependency
+
 convert_asserts: check_assert_codemod_dependency
 	$(PYTHON) scripts/convert_asserts.py --exception "$(ASSERT_EXCEPTION)" $(ASSERT_CONVERT_ARGS) $(ASSERT_PATH)
 
@@ -84,6 +86,10 @@ DOCSTRING_FORMAT_ARGS ?= --docstring-style google --fix-rst-backticks=False --in
 DOCSTRING_TYPE_PATH ?= qmcpy
 DOCSTRING_TYPE_DIFF_BASE ?= develop
 DOCSTRING_TYPE_ARGS ?=
+PUBLIC_API_TYPE_PATH ?= qmcpy
+PUBLIC_API_TYPE_DIFF_BASE ?= develop
+PUBLIC_API_ANNOTATE_ARGS ?=
+DOCSTRING_SYNC_ARGS ?=
 # Two-part docstring check for public APIs under qmcpy/:
 #  1. scripts/check_docstring.py -- formatting: a one-line summary before the
 #     first section, no NumPy-style "-----" section underlines, a blank line
@@ -134,6 +140,18 @@ add_docstring_arg_types_changed:
 check_docstring_arg_types_changed:
 	$(PYTHON) scripts/add_docstring_arg_types.py --diff "$(DOCSTRING_TYPE_DIFF_BASE)" --check $(DOCSTRING_TYPE_ARGS)
 
+annotate_public_api_types_changed: check_libcst_dependency
+	$(PYTHON) -m scripts.annotate_public_api_types --diff "$(PUBLIC_API_TYPE_DIFF_BASE)" --root "$(PUBLIC_API_TYPE_PATH)" $(PUBLIC_API_ANNOTATE_ARGS)
+
+sync_docstring_types_changed:
+	$(PYTHON) scripts/add_docstring_arg_types.py --diff "$(PUBLIC_API_TYPE_DIFF_BASE)" --root "$(PUBLIC_API_TYPE_PATH)" --include-outputs --overwrite-existing $(DOCSTRING_SYNC_ARGS)
+
+check_public_api_types_changed: check_libcst_dependency
+	@status=0; \
+	$(PYTHON) -m scripts.annotate_public_api_types --diff "$(PUBLIC_API_TYPE_DIFF_BASE)" --root "$(PUBLIC_API_TYPE_PATH)" --check $(PUBLIC_API_ANNOTATE_ARGS) || status=$$?; \
+	$(PYTHON) scripts/add_docstring_arg_types.py --diff "$(PUBLIC_API_TYPE_DIFF_BASE)" --root "$(PUBLIC_API_TYPE_PATH)" --include-outputs --overwrite-existing --check $(DOCSTRING_SYNC_ARGS) || { code=$$?; if [ $$code -gt $$status ]; then status=$$code; fi; }; \
+	exit $$status
+
 # Same checks as check_docstring, but only on qmcpy/*.py files that changed
 # relative to DOCSTRING_BASE (committed, staged/unstaged, and untracked).
 check_docstring_changed:
diff --git a/qmcpy/discrete_distribution/abstract_discrete_distribution.py b/qmcpy/discrete_distribution/abstract_discrete_distribution.py
index d9c846d78..4443087ec 100644
--- a/qmcpy/discrete_distribution/abstract_discrete_distribution.py
+++ b/qmcpy/discrete_distribution/abstract_discrete_distribution.py
@@ -8,7 +8,7 @@
 
 class AbstractDiscreteDistribution(object):
 
-    def __init__(self, dimension, replications, seed, d_limit, n_limit):
+    def __init__(self, dimension, replications, seed, d_limit, n_limit) -> None:
         self.mimics = "StdUniform"
         if not hasattr(self, "parameters"):
             self.parameters = []
@@ -124,7 +124,7 @@ def gen_samples(
     def _gen_samples(self, *args, **kwargs):
         raise MethodImplementationError(self, "_gen_samples")
 
-    def spawn(self, s=1, dimensions=None):
+    def spawn(self, s: int = 1, dimensions: np.ndarray = None):
         r"""Spawn new instances of the current discrete distribution but with
         new seeds and dimensions. Used by multi-level QMC algorithms which
         require different seeds and dimensions on each level.
diff --git a/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py b/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py
index e535a6d9b..2a3e1085c 100644
--- a/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py
+++ b/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py
@@ -158,14 +158,14 @@ class DigitalNetAnyBases(AbstractLDDiscreteDistribution):
 
     def __init__(self,
                  dimension = 1,
-                 replications = None,
+                 replications: int = None,
                  seed = None,
-                 randomize = 'LMS DP',
+                 randomize: str = 'LMS DP',
                  bases_generating_matrices = None,
-                 t = None,
-                 alpha = 1,
-                 n_lim = 2**32,
-                 warn = True):
+                 t: int = None,
+                 alpha: int = 1,
+                 n_lim: int = 2**32,
+                 warn: bool = True) -> None:
         r"""
         Args:
             dimension (Union[int,np.ndarray]): Dimension of the generator.
diff --git a/qmcpy/discrete_distribution/digital_net_any_bases/hammersley.py b/qmcpy/discrete_distribution/digital_net_any_bases/hammersley.py
index 7a2a777ce..d7dffa371 100644
--- a/qmcpy/discrete_distribution/digital_net_any_bases/hammersley.py
+++ b/qmcpy/discrete_distribution/digital_net_any_bases/hammersley.py
@@ -66,12 +66,12 @@ class Hammersley(DigitalNetAnyBases):
     """
 
     def __init__(self,
-                 dimension=1,
+                 dimension: int = 1,
                  seed=None,
                  t=None,
-                 n_lim=2**32,
+                 n_lim: int = 2**32,
                  warn = True
-                ):
+                ) -> None:
         r"""
         Args:
             dimension (int): Dimension of the samples. Must be a scalar `int`
diff --git a/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py b/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
index bcff01e0e..bc3952e71 100644
--- a/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
+++ b/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
@@ -216,20 +216,20 @@ class DigitalNetB2(AbstractLDDiscreteDistribution):
     def __init__(
         self,
         dimension=1,
-        replications=None,
+        replications: int = None,
         seed=None,
-        randomize="LMS DS",
+        randomize: str = "LMS DS",
         generating_matrices="joe_kuo.6.21201.txt",
-        order="RADICAL INVERSE",
-        t=63,
-        alpha=1,
-        msb=None,
-        _verbose=False,
+        order: str = "RADICAL INVERSE",
+        t: int = 63,
+        alpha: int = 1,
+        msb: bool = None,
+        _verbose: bool = False,
         # deprecated
         graycode=None,
         t_max=None,
         t_lms=None,
-    ):
+    ) -> None:
         r"""
         Args:
             dimension (Union[int, np.ndarray]): Dimension of the generator.
diff --git a/qmcpy/discrete_distribution/dummy_sampler.py b/qmcpy/discrete_distribution/dummy_sampler.py
index ac7477f90..bd85ea202 100644
--- a/qmcpy/discrete_distribution/dummy_sampler.py
+++ b/qmcpy/discrete_distribution/dummy_sampler.py
@@ -28,7 +28,7 @@ class DummySampler(AbstractLDDiscreteDistribution):
     qmcpy.util.exceptions_warnings.ParameterError: DummySampler is only a construction placeholder for ProductMeasure child true measures and cannot generate samples.
     """
 
-    def __init__(self, dimension=1, replications=None, seed=None, warn=True):
+    def __init__(self, dimension=1, replications=None, seed=None, warn=True) -> None:
         # Keep the same constructor as other discrete distributions.
         del warn
 
diff --git a/qmcpy/discrete_distribution/iid_std_uniform.py b/qmcpy/discrete_distribution/iid_std_uniform.py
index 623a15fb4..4e6c694ca 100644
--- a/qmcpy/discrete_distribution/iid_std_uniform.py
+++ b/qmcpy/discrete_distribution/iid_std_uniform.py
@@ -49,7 +49,7 @@ class IIDStdUniform(AbstractIIDDiscreteDistribution):
                 [0.6171181 , 0.1239209 , 0.16809479]]])
     """
 
-    def __init__(self, dimension=1, replications=None, seed=None):
+    def __init__(self, dimension: int = 1, replications=None, seed=None) -> None:
         r"""
         Args:
             dimension (int): Dimension of the samples.
diff --git a/qmcpy/discrete_distribution/korobov.py b/qmcpy/discrete_distribution/korobov.py
index 0d0f9407d..aa14b92f1 100644
--- a/qmcpy/discrete_distribution/korobov.py
+++ b/qmcpy/discrete_distribution/korobov.py
@@ -137,11 +137,11 @@ class KorobovLattice(AbstractLDDiscreteDistribution):
     """
     def __init__(
             self,
-            dimension=1,
-            replications=None,
+            dimension: int = 1,
+            replications: int = None,
             seed=None,
-            randomize="SHIFT",
-        ):
+            randomize: str = "SHIFT",
+        ) -> None:
         r"""
         Args:
             dimension (int): Dimension of the samples. Must be between 1 and
diff --git a/qmcpy/discrete_distribution/kronecker.py b/qmcpy/discrete_distribution/kronecker.py
index b498303a5..504ed0415 100644
--- a/qmcpy/discrete_distribution/kronecker.py
+++ b/qmcpy/discrete_distribution/kronecker.py
@@ -219,13 +219,13 @@ class Kronecker(AbstractLDDiscreteDistribution):
 
     def __init__(self,
         dimension=1,
-        replications=None,
+        replications: int = None,
         seed=None,
-        randomize="SHIFT",
+        randomize: str = "SHIFT",
         generating_vector="CBC",
-        shift=None,
-        warn=True,
-    ):
+        shift: np.ndarray = None,
+        warn: bool = True,
+    ) -> None:
         r"""
         Args:
             dimension (Union[int, np.ndarray]): Dimension of the generator.
diff --git a/qmcpy/discrete_distribution/latin_hypercube.py b/qmcpy/discrete_distribution/latin_hypercube.py
index b7d619817..4303cbbf1 100644
--- a/qmcpy/discrete_distribution/latin_hypercube.py
+++ b/qmcpy/discrete_distribution/latin_hypercube.py
@@ -95,8 +95,8 @@ class LatinHypercube(AbstractDiscreteDistribution):
     """
 
     def __init__(
-            self, dimension, replications, seed, randomize="TRUE"
-            ):
+            self, dimension: int, replications, seed, randomize: str = "TRUE"
+            ) -> None:
         r"""
         Args:
             dimension (int): Dimension of the samples.
diff --git a/qmcpy/discrete_distribution/lattice/lattice.py b/qmcpy/discrete_distribution/lattice/lattice.py
index 25ba28812..d7c5f808e 100644
--- a/qmcpy/discrete_distribution/lattice/lattice.py
+++ b/qmcpy/discrete_distribution/lattice/lattice.py
@@ -141,13 +141,13 @@ class Lattice(AbstractLDDiscreteDistribution):
     def __init__(
         self,
         dimension=1,
-        replications=None,
+        replications: int = None,
         seed=None,
-        randomize="SHIFT",
+        randomize: str = "SHIFT",
         generating_vector="kuo.lattice-33002-1024-1048576.9125.txt",
-        order="RADICAL INVERSE",
-        m_max=None,
-    ):
+        order: str = "RADICAL INVERSE",
+        m_max: int = None,
+    ) -> None:
         r"""
         Args:
             dimension (Union[int, np.ndarray]): Dimension of the generator.
diff --git a/qmcpy/discrete_distribution/mpmc/mpmc.py b/qmcpy/discrete_distribution/mpmc/mpmc.py
index efa929430..a77636307 100644
--- a/qmcpy/discrete_distribution/mpmc/mpmc.py
+++ b/qmcpy/discrete_distribution/mpmc/mpmc.py
@@ -85,7 +85,7 @@ def __init__(
         pretrained_local_dir=None,
         pretrained_base_url='https://github.com/QMCSoftware/LDData/tree/main/pregenerated_pointsets/mpmc',
         prompt_on_missing=True,
-    ):
+    ) -> None:
         self.mimics = 'StdUniform'
         self.low_discrepancy = True
 
diff --git a/qmcpy/fast_transform/ft.py b/qmcpy/fast_transform/ft.py
index 1addf5635..727d1844e 100644
--- a/qmcpy/fast_transform/ft.py
+++ b/qmcpy/fast_transform/ft.py
@@ -3,7 +3,7 @@
 import itertools
 
 
-def fftbr(x):
+def fftbr(x: np.ndarray):
     r"""1 dimensional Bit-Reversed-Order (BRO) Fast Fourier Transform (FFT)
     along the last dimension. Requires the last dimension of x is already in
     BRO, so we can skip the first step of the decimation-in-time FFT. Requires
@@ -41,7 +41,7 @@ def fftbr(x):
     return scipy.fft.fft(xr, norm="ortho")
 
 
-def ifftbr(x):
+def ifftbr(x: np.ndarray):
     r"""1 dimensional Bit-Reversed-Order (BRO) Inverse Fast Fourier Transform
     (IFFT) along the last dimension. Outputs an array in bit-reversed order, so
     we can skip the last step of the decimation-in-time IFFT. Requires the size
@@ -78,7 +78,7 @@ def ifftbr(x):
     return xr
 
 
-def fwht(x):
+def fwht(x: np.ndarray):
     r"""1 dimensional Fast Walsh Hadamard Transform (FWHT) along the last
     dimension. Requires the size of the last dimension is a power of 2.
 
@@ -116,7 +116,7 @@ def fwht(x):
     return y
 
 
-def omega_fwht(m):
+def omega_fwht(m: int):
     r"""A useful when efficiently updating FWHT values after doubling the
     sample size.
 
@@ -143,7 +143,7 @@ def omega_fwht(m):
     return np.ones(2**m)
 
 
-def omega_fftbr(m):
+def omega_fftbr(m: int):
     r"""A useful when efficiently updating FFT values after doubling the
     sample size.
 
diff --git a/qmcpy/fast_transform/ft_pytorch.py b/qmcpy/fast_transform/ft_pytorch.py
index 27e20c1b2..721603e56 100644
--- a/qmcpy/fast_transform/ft_pytorch.py
+++ b/qmcpy/fast_transform/ft_pytorch.py
@@ -3,7 +3,7 @@
 import itertools
 
 
-def fftbr_torch(x):
+def fftbr_torch(x: torch.Tensor):
     r"""Torch implementation of the 1 dimensional Bit-Reversed-Order (BRO)
     Fast Fourier Transform (FFT) along the last dimension. Requires the last
     dimension of x is already in BRO, so we can skip the first step of the
@@ -55,7 +55,7 @@ def fftbr_torch(x):
     return torch.fft.fft(xr, norm="ortho")
 
 
-def ifftbr_torch(x):
+def ifftbr_torch(x: torch.Tensor):
     r"""Torch implementation of the 1 dimensional Bit-Reversed-Order (BRO)
     Inverse Fast Fourier Transform (IFFT) along the last dimension. Outputs an
     array in bit-reversed order, so we can skip the last step of the
@@ -139,7 +139,7 @@ def backward(ctx, dx):
         return _fwht_torch(dx)
 
 
-def fwht_torch(x):
+def fwht_torch(x: torch.Tensor):
     r"""Torch implementation of the 1 dimensional Fast Walsh Hadamard
     Transform (FWHT) along the last dimension. Requires the size of the last
     dimension is a power of 2.
@@ -173,7 +173,7 @@ def fwht_torch(x):
     return _FWHTB2Ortho.apply(x)
 
 
-def omega_fwht_torch(m, device=None):
+def omega_fwht_torch(m: int, device=None):
     r"""Torch implementation useful when efficiently updating FWHT values
     after doubling the sample size.
 
@@ -202,7 +202,7 @@ def omega_fwht_torch(m, device=None):
     return torch.ones(2**m, device=device)
 
 
-def omega_fftbr_torch(m, device=None):
+def omega_fftbr_torch(m: int, device=None):
     r"""Torch implementation useful when efficiently updating FFT values after
     doubling the sample size.
 
diff --git a/qmcpy/fast_transform/ft_qmctoolscl.py b/qmcpy/fast_transform/ft_qmctoolscl.py
index 3c5f6d2ae..dae6ae5e5 100644
--- a/qmcpy/fast_transform/ft_qmctoolscl.py
+++ b/qmcpy/fast_transform/ft_qmctoolscl.py
@@ -20,7 +20,7 @@ def _parse_ft_input(x):
     return x, shape, d, n, n // 2
 
 
-def fftbr_qmctoolscl(x):
+def fftbr_qmctoolscl(x: np.ndarray):
     r"""QMCToolsCL implementation of the 1 dimensional Bit-Reversed-Order
     (BRO) Fast Fourier Transform (FFT) along the last dimension. Requires the
     last dimension of x is already in BRO, so we can skip the first step of the
@@ -55,7 +55,7 @@ def fftbr_qmctoolscl(x):
     return xc.reshape(shape)
 
 
-def ifftbr_qmctoolscl(x):
+def ifftbr_qmctoolscl(x: np.ndarray):
     r"""QMCToolsCL implementation of the 1 dimensional Bit-Reversed-Order
     (BRO) Inverse Fast Fourier Transform (IFFT) along the last dimension.
     Outputs an array in bit-reversed order, so we can skip the last step of the
@@ -90,7 +90,7 @@ def ifftbr_qmctoolscl(x):
     return xc.reshape(shape)
 
 
-def fwht_qmctoolscl(x):
+def fwht_qmctoolscl(x: np.ndarray):
     r"""QMCToolsCL implementation of the 1 dimensional Fast Walsh Hadamard
     Transform (FWHT) along the last dimension. Requires the size of the last
     dimension is a power of 2.
diff --git a/qmcpy/integrand/abstract_integrand.py b/qmcpy/integrand/abstract_integrand.py
index 442e54ceb..b82d7fe45 100644
--- a/qmcpy/integrand/abstract_integrand.py
+++ b/qmcpy/integrand/abstract_integrand.py
@@ -12,7 +12,7 @@
 
 class AbstractIntegrand(object):
 
-    def __init__(self, dimension_indv, dimension_comb, parallel, threadpool=False):
+    def __init__(self, dimension_indv: tuple, dimension_comb: tuple, parallel: int, threadpool: bool = False) -> None:
         r"""
         Args:
             dimension_indv (tuple): Individual solution shape.
@@ -110,7 +110,7 @@ def gen_samples(
         y = self.f(x)
         return y
 
-    def g(self, t, *args, **kwargs):
+    def g(self, t: np.ndarray, *args: tuple, **kwargs: dict):
         r"""*Abstract method* implementing the integrand as a function of the
         true measure.
 
@@ -135,7 +135,7 @@ def g(self, t, *args, **kwargs):
         """
         raise MethodImplementationError(self, "g")
 
-    def f(self, x, *args, **kwargs):
+    def f(self, x: np.ndarray, *args: tuple, **kwargs: dict):
         r"""Function to evaluate the transformed integrand as a function of
         the discrete distribution. Automatically applies the transformation
         determined by the true measure.
@@ -306,7 +306,7 @@ def _g2(self, t, comb_args=((), {})):
                 raise e
         return y
 
-    def bound_fun(self, bound_low, bound_high):
+    def bound_fun(self, bound_low: np.ndarray, bound_high: np.ndarray):
         """Compute the bounds on the combined function based on bounds for
         the individual functions.
 
@@ -335,7 +335,7 @@ def bound_fun(self, bound_low, bound_high):
             )
         return bound_low, bound_high
 
-    def dependency(self, comb_flags):
+    def dependency(self, comb_flags: np.ndarray):
         """Takes a vector of indicators of weather of not the error bound is
         satisfied for combined integrands and returns flags for individual
         integrands.
@@ -361,7 +361,7 @@ def dependency(self, comb_flags):
             else np.tile((comb_flags == False).any(), self.d_indv)
         )
 
-    def spawn(self, levels):
+    def spawn(self, levels: np.ndarray):
         r"""Spawn new instances of the current integrand at different levels
         with new seeds. Used by multi-level QMC algorithms which require
         integrands at multiple levels.
@@ -387,7 +387,7 @@ def spawn(self, levels):
             spawned_integrand[l] = self._spawn(level, tm_spawns[l])
         return spawned_integrand
 
-    def dimension_at_level(self, level):
+    def dimension_at_level(self, level: int):
         """*Abstract method* which returns the dimension of the generator
         required for a given level.
 
diff --git a/qmcpy/integrand/bayesian_lr_coeffs.py b/qmcpy/integrand/bayesian_lr_coeffs.py
index d59a1d73b..fc01433b2 100644
--- a/qmcpy/integrand/bayesian_lr_coeffs.py
+++ b/qmcpy/integrand/bayesian_lr_coeffs.py
@@ -33,8 +33,8 @@ class BayesianLRCoeffs(AbstractIntegrand):
     """
 
     def __init__(
-        self, sampler, feature_array, response_vector, prior_mean=0, prior_covariance=10
-    ):
+        self, sampler, feature_array: np.ndarray, response_vector: np.ndarray, prior_mean: np.ndarray = 0, prior_covariance: np.ndarray = 10
+    ) -> None:
         r"""
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
diff --git a/qmcpy/integrand/box_integral.py b/qmcpy/integrand/box_integral.py
index 0e9c77707..b13719938 100644
--- a/qmcpy/integrand/box_integral.py
+++ b/qmcpy/integrand/box_integral.py
@@ -64,7 +64,7 @@ class BoxIntegral(AbstractIntegrand):
         [https://www.davidhbailey.com/dhbpapers/boxintegrals.pdf](https://www.davidhbailey.com/dhbpapers/boxintegrals.pdf)
     """
 
-    def __init__(self, sampler, s=1):
+    def __init__(self, sampler, s=1) -> None:
         r"""
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
diff --git a/qmcpy/integrand/custom_fun.py b/qmcpy/integrand/custom_fun.py
index 92ebae9f6..19ff3d223 100644
--- a/qmcpy/integrand/custom_fun.py
+++ b/qmcpy/integrand/custom_fun.py
@@ -88,7 +88,7 @@ class CustomFun(AbstractIntegrand):
         array([3.83e-03, -6.78e-03, -1.56e-03, -5.65e-04])
     """
 
-    def __init__(self, true_measure, g, dimension_indv=(), parallel=False):
+    def __init__(self, true_measure, g, dimension_indv: tuple = (), parallel: int = False) -> None:
         """
         Args:
             true_measure (AbstractTrueMeasure): The true measure.
diff --git a/qmcpy/integrand/financial_option.py b/qmcpy/integrand/financial_option.py
index 3a208aff4..badc9e053 100644
--- a/qmcpy/integrand/financial_option.py
+++ b/qmcpy/integrand/financial_option.py
@@ -239,22 +239,22 @@ class FinancialOption(AbstractIntegrand):
     def __init__(
         self,
         sampler,
-        option="ASIAN",
-        call_put="CALL",
-        volatility=0.5,
-        start_price=30,
-        strike_price=35,
-        interest_rate=0,
-        t_final=1,
-        decomp_type="PCA",
+        option: str = "ASIAN",
+        call_put: str = "CALL",
+        volatility: float = 0.5,
+        start_price: float = 30,
+        strike_price: float = 35,
+        interest_rate: float = 0,
+        t_final: float = 1,
+        decomp_type: str = "PCA",
         level=None,
         d_coarsest=2,
-        asian_mean="ARITHMETIC",
-        asian_mean_quadrature_rule="TRAPEZOIDAL",
-        barrier_in_out="IN",
-        barrier_price=38,
-        digital_payout=10,
-    ):
+        asian_mean: str = "ARITHMETIC",
+        asian_mean_quadrature_rule: str = "TRAPEZOIDAL",
+        barrier_in_out: str = "IN",
+        barrier_price: float = 38,
+        digital_payout: float = 10,
+    ) -> None:
         r"""
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
@@ -724,7 +724,7 @@ def _eurogbmprice(S0, r, T, sigma, K):
 
 
 class AsianOption(FinancialOption):
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, **kwargs) -> None:
         """Deprecated, please use FinancialOption"""
         if "option" in kwargs:
             raise ParameterError("please do not pass 'option' to AsianOption")
@@ -732,7 +732,7 @@ def __init__(self, *args, **kwargs):
 
 
 class EuropeanOption(FinancialOption):
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, **kwargs) -> None:
         """Deprecated, please use FinancialOption"""
         if "option" in kwargs:
             raise ParameterError("please do not pass 'option' to EuropeanOption")
@@ -740,7 +740,7 @@ def __init__(self, *args, **kwargs):
 
 
 class BarrierOption(FinancialOption):
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, **kwargs) -> None:
         """Deprecated, please use FinancialOption"""
         if "option" in kwargs:
             raise ParameterError("please do not pass 'option' to BarrierOption")
@@ -748,7 +748,7 @@ def __init__(self, *args, **kwargs):
 
 
 class LookbackOption(FinancialOption):
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, **kwargs) -> None:
         """Deprecated, please use FinancialOption"""
         if "option" in kwargs:
             raise ParameterError("please do not pass 'option' to LookbackOption")
@@ -756,7 +756,7 @@ def __init__(self, *args, **kwargs):
 
 
 class DigitalOption(FinancialOption):
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, **kwargs) -> None:
         """Deprecated, please use FinancialOption"""
         if "option" in kwargs:
             raise ParameterError("please do not pass 'option' to DigitalOption")
diff --git a/qmcpy/integrand/fourbranch2d.py b/qmcpy/integrand/fourbranch2d.py
index f2e6e6e27..fb5f60515 100644
--- a/qmcpy/integrand/fourbranch2d.py
+++ b/qmcpy/integrand/fourbranch2d.py
@@ -44,7 +44,7 @@ class FourBranch2d(AbstractIntegrand):
         -2.5042
     """
 
-    def __init__(self, sampler):
+    def __init__(self, sampler) -> None:
         r"""
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
diff --git a/qmcpy/integrand/genz.py b/qmcpy/integrand/genz.py
index 1bc9e385b..6e86966fb 100644
--- a/qmcpy/integrand/genz.py
+++ b/qmcpy/integrand/genz.py
@@ -54,7 +54,7 @@ class Genz(AbstractIntegrand):
         0.7200
     """
 
-    def __init__(self, sampler, kind_func="OSCILLATORY", kind_coeff=1):
+    def __init__(self, sampler, kind_func: str = "OSCILLATORY", kind_coeff: int = 1) -> None:
         """
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
diff --git a/qmcpy/integrand/hartmann6d.py b/qmcpy/integrand/hartmann6d.py
index 9a764de63..b5a9a4a1c 100644
--- a/qmcpy/integrand/hartmann6d.py
+++ b/qmcpy/integrand/hartmann6d.py
@@ -44,7 +44,7 @@ class Hartmann6d(AbstractIntegrand):
         -0.2599
     """
 
-    def __init__(self, sampler):
+    def __init__(self, sampler) -> None:
         r"""
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
diff --git a/qmcpy/integrand/ishigami.py b/qmcpy/integrand/ishigami.py
index 41b59b2b6..5c51cb902 100644
--- a/qmcpy/integrand/ishigami.py
+++ b/qmcpy/integrand/ishigami.py
@@ -53,7 +53,7 @@ class Ishigami(AbstractIntegrand):
         Proceedings, First International Symposium on (pp. 398-403). IEEE.
     """
 
-    def __init__(self, sampler, a=7, b=0.1):
+    def __init__(self, sampler, a: float = 7, b: float = 0.1) -> None:
         r"""
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
diff --git a/qmcpy/integrand/keister.py b/qmcpy/integrand/keister.py
index 57873fe3b..497a4a7d3 100644
--- a/qmcpy/integrand/keister.py
+++ b/qmcpy/integrand/keister.py
@@ -44,7 +44,7 @@ class Keister(AbstractIntegrand):
         Computers in Physics, 10, pp. 119-122, 1996.
     """
 
-    def __init__(self, sampler):
+    def __init__(self, sampler) -> None:
         r"""
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
@@ -69,7 +69,7 @@ def _spawn(self, level, sampler):
         return Keister(sampler=sampler)
 
     @classmethod
-    def get_exact_value(self, d):
+    def get_exact_value(self, d: int):
         """Compute the exact analytic value of the Keister integral with
         dimension $d$.
 
diff --git a/qmcpy/integrand/linear0.py b/qmcpy/integrand/linear0.py
index 3e7d7bd00..17654c265 100644
--- a/qmcpy/integrand/linear0.py
+++ b/qmcpy/integrand/linear0.py
@@ -28,7 +28,7 @@ class Linear0(AbstractIntegrand):
         -9.8203e-05
     """
 
-    def __init__(self, sampler):
+    def __init__(self, sampler) -> None:
         r"""
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
diff --git a/qmcpy/integrand/multimodal2d.py b/qmcpy/integrand/multimodal2d.py
index 0c3a808db..64fd16429 100644
--- a/qmcpy/integrand/multimodal2d.py
+++ b/qmcpy/integrand/multimodal2d.py
@@ -41,7 +41,7 @@ class Multimodal2d(AbstractIntegrand):
         -0.7366
     """
 
-    def __init__(self, sampler):
+    def __init__(self, sampler) -> None:
         r"""
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
diff --git a/qmcpy/integrand/sensitivity_indices.py b/qmcpy/integrand/sensitivity_indices.py
index c39339c3d..88010f225 100644
--- a/qmcpy/integrand/sensitivity_indices.py
+++ b/qmcpy/integrand/sensitivity_indices.py
@@ -110,7 +110,7 @@ class SensitivityIndices(AbstractIntegrand):
         [https://artowen.su.domains/mc/A-anova.pdf](https://artowen.su.domains/mc/A-anova.pdf).
     """
 
-    def __init__(self, integrand, indices="singletons"):
+    def __init__(self, integrand: AbstractIntegrand, indices: np.ndarray = "singletons") -> None:
         r"""
         Args:
             integrand (AbstractIntegrand): Integrand to find sensitivity
diff --git a/qmcpy/integrand/sin1d.py b/qmcpy/integrand/sin1d.py
index 97f2e9298..510e73176 100644
--- a/qmcpy/integrand/sin1d.py
+++ b/qmcpy/integrand/sin1d.py
@@ -39,7 +39,7 @@ class Sin1d(AbstractIntegrand):
         7.0800e-04
     """
 
-    def __init__(self, sampler, k=1):
+    def __init__(self, sampler, k: float = 1) -> None:
         r"""
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
diff --git a/qmcpy/integrand/umbridge_wrapper.py b/qmcpy/integrand/umbridge_wrapper.py
index 16a02915c..af40ce05e 100644
--- a/qmcpy/integrand/umbridge_wrapper.py
+++ b/qmcpy/integrand/umbridge_wrapper.py
@@ -66,7 +66,7 @@ class UMBridgeWrapper(AbstractIntegrand):
         [['-1.59e-08', '1.49e-04', '1.49e-04'], ['8.20e-06', '-1.38e-04'], ['-8.14e-06']]
     """
 
-    def __init__(self, true_measure, model, config=None, parallel=False):
+    def __init__(self, true_measure, model, config: dict = None, parallel: int = False) -> None:
         """
         Args:
             true_measure (AbstractTrueMeasure): The true measure.
@@ -143,7 +143,7 @@ def _spawn(self, _level, _sampler):
             parallel=self.parallel,
         )
 
-    def to_umbridge_out_sizes(self, x):
+    def to_umbridge_out_sizes(self, x: np.ndarray):
         """Convert a data attribute to `UM-Bridge` output sized list of
         lists.
 
diff --git a/qmcpy/kernel/abstract_kernel.py b/qmcpy/kernel/abstract_kernel.py
index 959638a00..91b28d2f9 100644
--- a/qmcpy/kernel/abstract_kernel.py
+++ b/qmcpy/kernel/abstract_kernel.py
@@ -28,7 +28,7 @@ def __new__(cls, *args, **kwargs):
             instance = super().__new__(cls)
         return instance
 
-    def __init__(self, d, torchify, device, compile_call, compile_call_kwargs):
+    def __init__(self, d, torchify, device, compile_call, compile_call_kwargs) -> None:
         super().__init__()
         # dimension
         if not (d % 1 == 0 and d > 0):
@@ -349,20 +349,20 @@ class AbstractKernelScaleLengthscales(AbstractKernel):
 
     def __init__(
         self,
-        d,
+        d: int,
         scale=1.0,
         lengthscales=1.0,
-        shape_scale=None,
-        shape_lengthscales=None,
+        shape_scale: list = None,
+        shape_lengthscales: list = None,
         tfs_scale=(tf_exp_eps_inv, tf_exp_eps),
         tfs_lengthscales=(tf_exp_eps_inv, tf_exp_eps),
-        torchify=False,
-        requires_grad_scale=True,
-        requires_grad_lengthscales=True,
+        torchify: bool = False,
+        requires_grad_scale: bool = True,
+        requires_grad_lengthscales: bool = True,
         device="cpu",
-        compile_call=False,
-        compile_call_kwargs=None,
-    ):
+        compile_call: bool = False,
+        compile_call_kwargs: dict = None,
+    ) -> None:
         r"""
         Args:
             d (int): Dimension.
diff --git a/qmcpy/kernel/common_kernels.py b/qmcpy/kernel/common_kernels.py
index 2d652061d..984b18d0d 100644
--- a/qmcpy/kernel/common_kernels.py
+++ b/qmcpy/kernel/common_kernels.py
@@ -457,24 +457,24 @@ class KernelRationalQuadratic(AbstractKernelScaleLengthscales):
 
     def __init__(
         self,
-        d,
+        d: int,
         scale=1.0,
         lengthscales=1.0,
         alpha=1.0,
-        shape_scale=None,
-        shape_lengthscales=None,
-        shape_alpha=None,
+        shape_scale: list = None,
+        shape_lengthscales: list = None,
+        shape_alpha: list = None,
         tfs_scale=(tf_exp_eps_inv, tf_exp_eps),
         tfs_lengthscales=(tf_exp_eps_inv, tf_exp_eps),
         tfs_alpha=(tf_exp_eps_inv, tf_exp_eps),
-        torchify=False,
-        requires_grad_scale=True,
-        requires_grad_lengthscales=True,
-        requires_grad_alpha=True,
+        torchify: bool = False,
+        requires_grad_scale: bool = True,
+        requires_grad_lengthscales: bool = True,
+        requires_grad_alpha: bool = True,
         device="cpu",
-        compile_call=False,
-        compile_call_kwargs=None,
-    ):
+        compile_call: bool = False,
+        compile_call_kwargs: dict = None,
+    ) -> None:
         r"""
         Args:
             d (int): Dimension.
diff --git a/qmcpy/kernel/multitask_kernel.py b/qmcpy/kernel/multitask_kernel.py
index 4a8f05657..3487538c5 100644
--- a/qmcpy/kernel/multitask_kernel.py
+++ b/qmcpy/kernel/multitask_kernel.py
@@ -328,19 +328,19 @@ class KernelMultiTask(AbstractKernel):
 
     def __init__(
         self,
-        base_kernel,
-        num_tasks,
+        base_kernel: AbstractKernel,
+        num_tasks: int,
         factor=1.0,
         diag=1.0,
-        shape_factor=None,
-        shape_diag=None,
+        shape_factor: list = None,
+        shape_diag: list = None,
         tfs_factor=(tf_identity, tf_identity),
         tfs_diag=(tf_exp_eps_inv, tf_exp_eps),
-        requires_grad_factor=True,
-        requires_grad_diag=True,
+        requires_grad_factor: bool = True,
+        requires_grad_diag: bool = True,
         rank_factor=1,
-        method="LOW RANK",
-    ):
+        method: str = "LOW RANK",
+    ) -> None:
         r"""
         Args:
             base_kernel (AbstractKernel): $K_{\mathrm{base}}$.
@@ -555,7 +555,7 @@ def __init__(
         self,
         base_kernel,
         num_tasks,
-    ):
+    ) -> None:
         super().__init__(
             base_kernel=base_kernel,
             num_tasks=num_tasks,
diff --git a/qmcpy/kernel/si_dsi_kernels.py b/qmcpy/kernel/si_dsi_kernels.py
index a1c19a4bc..55d0cbb93 100644
--- a/qmcpy/kernel/si_dsi_kernels.py
+++ b/qmcpy/kernel/si_dsi_kernels.py
@@ -40,7 +40,7 @@ def __init__(
         shape_weights,
         tfs_weights,
         requires_grad_weights,
-    ):
+    ) -> None:
         # alias lengthscales with weights
         if weights is not None:
             if lengthscales is not None:
@@ -317,25 +317,25 @@ class KernelShiftInvar(AbstractSIDSIKernel):
 
     def __init__(
         self,
-        d,
+        d: int,
         scale=1.0,
         lengthscales=None,
         alpha=2,
-        shape_scale=None,
-        shape_lengthscales=None,
+        shape_scale: list = None,
+        shape_lengthscales: list = None,
         tfs_scale=None,
         tfs_lengthscales=None,
-        torchify=False,
-        requires_grad_scale=None,
-        requires_grad_lengthscales=None,
+        torchify: bool = False,
+        requires_grad_scale: bool = None,
+        requires_grad_lengthscales: bool = None,
         device="cpu",
-        compile_call=False,
-        compile_call_kwargs=None,
+        compile_call: bool = False,
+        compile_call_kwargs: dict = None,
         weights=None,
-        shape_weights=None,
+        shape_weights: list = None,
         tfs_weights=None,
-        requires_grad_weights=None,
-    ):
+        requires_grad_weights: bool = None,
+    ) -> None:
         r"""
         Args:
             d (int): Dimension.
@@ -537,28 +537,28 @@ class KernelShiftInvarCombined(AbstractSIDSIKernel):
 
     def __init__(
         self,
-        d,
+        d: int,
         scale=1.0,
         lengthscales=None,
         alpha=1,
-        shape_scale=None,
-        shape_lengthscales=None,
-        shape_alpha=None,
+        shape_scale: list = None,
+        shape_lengthscales: list = None,
+        shape_alpha: list = None,
         tfs_scale=None,
         tfs_lengthscales=None,
         tfs_alpha=None,
-        torchify=False,
-        requires_grad_scale=None,
-        requires_grad_lengthscales=None,
-        requires_grad_alpha=None,
+        torchify: bool = False,
+        requires_grad_scale: bool = None,
+        requires_grad_lengthscales: bool = None,
+        requires_grad_alpha: bool = None,
         device="cpu",
-        compile_call=False,
-        compile_call_kwargs=None,
+        compile_call: bool = False,
+        compile_call_kwargs: dict = None,
         weights=None,
-        shape_weights=None,
+        shape_weights: list = None,
         tfs_weights=None,
-        requires_grad_weights=None,
-    ):
+        requires_grad_weights: bool = None,
+    ) -> None:
         r"""
         Args:
             d (int): Dimension.
@@ -815,26 +815,26 @@ class KernelDigShiftInvar(AbstractSIDSIKernel):
 
     def __init__(
         self,
-        d,
-        t=None,
+        d: int,
+        t: int = None,
         scale=1.0,
         lengthscales=None,
         alpha=2,
-        shape_scale=None,
-        shape_lengthscales=None,
+        shape_scale: list = None,
+        shape_lengthscales: list = None,
         tfs_scale=None,
         tfs_lengthscales=None,
-        torchify=False,
-        requires_grad_scale=None,
-        requires_grad_lengthscales=None,
+        torchify: bool = False,
+        requires_grad_scale: bool = None,
+        requires_grad_lengthscales: bool = None,
         device="cpu",
-        compile_call=False,
-        compile_call_kwargs=None,
+        compile_call: bool = False,
+        compile_call_kwargs: dict = None,
         weights=None,
-        shape_weights=None,
+        shape_weights: list = None,
         tfs_weights=None,
-        requires_grad_weights=None,
-    ):
+        requires_grad_weights: bool = None,
+    ) -> None:
         r"""
         Args:
             d (int): Dimension.
@@ -1096,29 +1096,29 @@ class KernelDigShiftInvarAdaptiveAlpha(AbstractSIDSIKernel):
 
     def __init__(
         self,
-        d,
-        t=None,
+        d: int,
+        t: int = None,
         scale=1.0,
         lengthscales=None,
         alpha=1,
-        shape_scale=None,
-        shape_lengthscales=None,
-        shape_alpha=None,
+        shape_scale: list = None,
+        shape_lengthscales: list = None,
+        shape_alpha: list = None,
         tfs_scale=None,
         tfs_lengthscales=None,
         tfs_alpha=None,
-        torchify=False,
-        requires_grad_scale=None,
-        requires_grad_lengthscales=None,
-        requires_grad_alpha=None,
+        torchify: bool = False,
+        requires_grad_scale: bool = None,
+        requires_grad_lengthscales: bool = None,
+        requires_grad_alpha: bool = None,
         device="cpu",
-        compile_call=False,
-        compile_call_kwargs=None,
+        compile_call: bool = False,
+        compile_call_kwargs: dict = None,
         weights=None,
-        shape_weights=None,
+        shape_weights: list = None,
         tfs_weights=None,
-        requires_grad_weights=None,
-    ):
+        requires_grad_weights: bool = None,
+    ) -> None:
         r"""
         Args:
             d (int): Dimension.
@@ -1350,29 +1350,29 @@ class KernelDigShiftInvarCombined(AbstractSIDSIKernel):
 
     def __init__(
         self,
-        d,
-        t=None,
+        d: int,
+        t: int = None,
         scale=1.0,
         lengthscales=None,
         alpha=1.0,
-        shape_scale=None,
-        shape_lengthscales=None,
-        shape_alpha=None,
+        shape_scale: list = None,
+        shape_lengthscales: list = None,
+        shape_alpha: list = None,
         tfs_scale=None,
         tfs_lengthscales=None,
         tfs_alpha=None,
-        torchify=False,
-        requires_grad_scale=None,
-        requires_grad_lengthscales=None,
-        requires_grad_alpha=None,
+        torchify: bool = False,
+        requires_grad_scale: bool = None,
+        requires_grad_lengthscales: bool = None,
+        requires_grad_alpha: bool = None,
         device="cpu",
-        compile_call=False,
-        compile_call_kwargs=None,
+        compile_call: bool = False,
+        compile_call_kwargs: dict = None,
         weights=None,
-        shape_weights=None,
+        shape_weights: list = None,
         tfs_weights=None,
-        requires_grad_weights=None,
-    ):
+        requires_grad_weights: bool = None,
+    ) -> None:
         r"""
         Args:
             d (int): Dimension.
diff --git a/qmcpy/stopping_criterion/abstract_stopping_criterion.py b/qmcpy/stopping_criterion/abstract_stopping_criterion.py
index d50ef5921..4206fe153 100644
--- a/qmcpy/stopping_criterion/abstract_stopping_criterion.py
+++ b/qmcpy/stopping_criterion/abstract_stopping_criterion.py
@@ -25,7 +25,7 @@ class AbstractStoppingCriterion(object):
     _RESUME_FORMAT_VERSION = 1  # Increment when checkpoint format changes in a non-backwards-compatible way
     _ITERATION_LOG_VIEWS = ("all", "current", "without_resume", "stage_last")
 
-    def __init__(self, allowed_distribs, allow_vectorized_integrals):
+    def __init__(self, allowed_distribs: list, allow_vectorized_integrals: bool) -> None:
         """Initialize a stopping criterion base class.
 
         Args:
@@ -81,7 +81,7 @@ def integrate(self, resume=None) -> tuple:
                 object is preserved. Defaults to None.
 
         Returns:
-            Approximation to the integral with shape ``integrand.d_comb`` and
+            tuple: Approximation to the integral with shape ``integrand.d_comb`` and
             the corresponding data object.
         """
         raise MethodImplementationError(self, "integrate")
@@ -123,10 +123,10 @@ def _make_trace_logger(self) -> _IterationTraceLogger:
     def get_iteration_log(
         self,
         history=None,
-        printed_only=True,
-        drop_empty_columns=True,
-        formatted=True,
-        view="all",
+        printed_only: bool = True,
+        drop_empty_columns: bool = True,
+        formatted: bool = True,
+        view: str = "all",
     ) -> "pandas.DataFrame":
         """Return the latest iteration log as a pandas DataFrame.
 
@@ -146,7 +146,7 @@ def get_iteration_log(
                 stage.
 
         Returns:
-            DataFrame representation of the iteration log.
+            pandas.DataFrame: DataFrame representation of the iteration log.
         """
         self._validate_iteration_log_view(view)
         use_cache = (
@@ -204,7 +204,7 @@ def _apply_iteration_log_view(log_df, view):
         positions = positions[positions >= 0]
         return log_df.loc[non_resume_indices[positions]].reset_index(drop=True)
 
-    def format_iteration_log(self, history=None, printed_only=True, include_header=True) -> str:
+    def format_iteration_log(self, history=None, printed_only: bool = True, include_header: bool = True) -> str:
         """Return the iteration log as formatted text.
 
         Args:
@@ -217,7 +217,7 @@ def format_iteration_log(self, history=None, printed_only=True, include_header=T
                 before the table. Defaults to True.
 
         Returns:
-            Formatted iteration log text.
+            str: Formatted iteration log text.
         """
         if history is None:
             history = getattr(self, "iteration_history", None)
@@ -228,7 +228,7 @@ def format_iteration_log(self, history=None, printed_only=True, include_header=T
             include_header=include_header,
         )
 
-    def print_iteration_log(self, history=None, printed_only=True, include_header=True, file=None) -> None:
+    def print_iteration_log(self, history=None, printed_only: bool = True, include_header: bool = True, file=None) -> None:
         """Print the iteration log for the latest run or supplied history.
 
         Args:
diff --git a/qmcpy/stopping_criterion/cub_mc_clt.py b/qmcpy/stopping_criterion/cub_mc_clt.py
index cfceeefe2..edcea6c07 100644
--- a/qmcpy/stopping_criterion/cub_mc_clt.py
+++ b/qmcpy/stopping_criterion/cub_mc_clt.py
@@ -127,16 +127,16 @@ class CubMCCLT(AbstractStoppingCriterion):
 
     def __init__(
         self,
-        integrand,
-        abs_tol=1e-2,
-        rel_tol=0.0,
-        n_init=1024,
-        n_limit=2**30,
-        inflate=1.2,
-        alpha=0.01,
-        control_variates=None,
-        control_variate_means=None,
-    ):
+        integrand: AbstractIntegrand,
+        abs_tol: np.ndarray = 1e-2,
+        rel_tol: np.ndarray = 0.0,
+        n_init: int = 1024,
+        n_limit: int = 2**30,
+        inflate: float = 1.2,
+        alpha: np.ndarray = 0.01,
+        control_variates: list = None,
+        control_variate_means: np.ndarray = None,
+    ) -> None:
         r"""
         Args:
             integrand (AbstractIntegrand): The integrand.
diff --git a/qmcpy/stopping_criterion/cub_mc_clt_vec.py b/qmcpy/stopping_criterion/cub_mc_clt_vec.py
index 3ff22c4c8..ad20665e1 100644
--- a/qmcpy/stopping_criterion/cub_mc_clt_vec.py
+++ b/qmcpy/stopping_criterion/cub_mc_clt_vec.py
@@ -160,14 +160,14 @@ class CubMCCLTVec(AbstractStoppingCriterion):
     def __init__(
         self,
         integrand,
-        abs_tol=1e-2,
-        rel_tol=0.0,
-        n_init=256.0,
-        n_limit=2**30,
+        abs_tol: np.ndarray = 1e-2,
+        rel_tol: np.ndarray = 0.0,
+        n_init: int = 256.0,
+        n_limit: int = 2**30,
         error_fun="EITHER",
-        inflate=1,
-        alpha=0.01,
-    ):
+        inflate: float = 1,
+        alpha: np.ndarray = 0.01,
+    ) -> None:
         r"""
         Args:
             integrand (AbstractIntegrand): The integrand.
diff --git a/qmcpy/stopping_criterion/cub_mc_g.py b/qmcpy/stopping_criterion/cub_mc_g.py
index 5b3120727..45f055ca7 100644
--- a/qmcpy/stopping_criterion/cub_mc_g.py
+++ b/qmcpy/stopping_criterion/cub_mc_g.py
@@ -253,16 +253,16 @@ class CubMCG(AbstractStoppingCriterion):
 
     def __init__(
         self,
-        integrand,
-        abs_tol=1e-2,
-        rel_tol=0.0,
-        n_init=1024,
-        n_limit=2**30,
-        inflate=1.2,
-        alpha=0.01,
-        control_variates=None,
-        control_variate_means=None,
-    ):
+        integrand: AbstractIntegrand,
+        abs_tol: np.ndarray = 1e-2,
+        rel_tol: np.ndarray = 0.0,
+        n_init: int = 1024,
+        n_limit: int = 2**30,
+        inflate: float = 1.2,
+        alpha: np.ndarray = 0.01,
+        control_variates: list = None,
+        control_variate_means: np.ndarray = None,
+    ) -> None:
         r"""
         Args:
             integrand (AbstractIntegrand): The integrand.
diff --git a/qmcpy/stopping_criterion/cub_mlmc.py b/qmcpy/stopping_criterion/cub_mlmc.py
index d1a44d56d..9d9199885 100644
--- a/qmcpy/stopping_criterion/cub_mlmc.py
+++ b/qmcpy/stopping_criterion/cub_mlmc.py
@@ -78,15 +78,15 @@ def __init__(
         integrand,
         abs_tol=0.05,
         rmse_tol=None,
-        n_init=256,
+        n_init: int = 256,
         n_limit=1e10,
         alpha=0.01,
-        levels_min=2,
-        levels_max=10,
-        alpha0=-1.0,
-        beta0=-1.0,
-        gamma0=-1.0,
-    ):
+        levels_min: int = 2,
+        levels_max: int = 10,
+        alpha0: float = -1.0,
+        beta0: float = -1.0,
+        gamma0: float = -1.0,
+    ) -> None:
         r"""
         Args:
             integrand (AbstractIntegrand): The integrand.
@@ -284,7 +284,7 @@ def integrate(self, resume=None) -> tuple:
                 no new sampling.
 
         Returns:
-            ``(solution, data)``.
+            tuple: ``(solution, data)``.
         """
         t_start = time()
         resume_provenance = self._capture_resume_provenance(resume)
diff --git a/qmcpy/stopping_criterion/cub_mlmc_cont.py b/qmcpy/stopping_criterion/cub_mlmc_cont.py
index 06e237169..31ab44dc8 100644
--- a/qmcpy/stopping_criterion/cub_mlmc_cont.py
+++ b/qmcpy/stopping_criterion/cub_mlmc_cont.py
@@ -77,15 +77,15 @@ def __init__(
         integrand,
         abs_tol=0.05,
         rmse_tol=None,
-        n_init=256,
+        n_init: int = 256,
         n_limit=1e10,
-        inflate=100 ** (1 / 9),
+        inflate: float = 100 ** (1 / 9),
         alpha=0.01,
-        levels_min=2,
-        levels_max=10,
-        n_tols=10,
-        theta_init=0.5,
-    ):
+        levels_min: int = 2,
+        levels_max: int = 10,
+        n_tols: int = 10,
+        theta_init: float = 0.5,
+    ) -> None:
         r"""
         Args:
             integrand (AbstractIntegrand): The integrand.
@@ -178,7 +178,7 @@ def integrate(self, resume=None) -> tuple:
                 additional ladder steps are needed.
 
         Returns:
-            ``(solution, data)``.
+            tuple: ``(solution, data)``.
         """
         self._active_t_start = t_start = time()
         self._active_trace = trace = self._make_trace_logger()
diff --git a/qmcpy/stopping_criterion/cub_mlqmc.py b/qmcpy/stopping_criterion/cub_mlqmc.py
index d0b1173ac..116cc4780 100644
--- a/qmcpy/stopping_criterion/cub_mlqmc.py
+++ b/qmcpy/stopping_criterion/cub_mlqmc.py
@@ -81,12 +81,12 @@ def __init__(
         integrand,
         abs_tol=0.05,
         rmse_tol=None,
-        n_init=256,
+        n_init: int = 256,
         n_limit=1e10,
         alpha=0.01,
-        levels_min=2,
-        levels_max=10,
-    ):
+        levels_min: int = 2,
+        levels_max: int = 10,
+    ) -> None:
         r"""
         Args:
             integrand (AbstractIntegrand): The integrand.
@@ -234,7 +234,7 @@ def integrate(self, resume=None) -> tuple:
                 no new sampling.
 
         Returns:
-            ``(solution, data)``.
+            tuple: ``(solution, data)``.
         """
         t_start = time()
         resume_provenance = self._capture_resume_provenance(resume)
diff --git a/qmcpy/stopping_criterion/cub_mlqmc_cont.py b/qmcpy/stopping_criterion/cub_mlqmc_cont.py
index 934b2b6b1..3223c6726 100644
--- a/qmcpy/stopping_criterion/cub_mlqmc_cont.py
+++ b/qmcpy/stopping_criterion/cub_mlqmc_cont.py
@@ -84,15 +84,15 @@ def __init__(
         integrand,
         abs_tol=0.05,
         rmse_tol=None,
-        n_init=256,
+        n_init: int = 256,
         n_limit=1e10,
-        inflate=100 ** (1 / 9),
+        inflate: float = 100 ** (1 / 9),
         alpha=0.01,
-        levels_min=2,
-        levels_max=10,
-        n_tols=10,
-        theta_init=0.5,
-    ):
+        levels_min: int = 2,
+        levels_max: int = 10,
+        n_tols: int = 10,
+        theta_init: float = 0.5,
+    ) -> None:
         r"""
         Args:
             integrand (AbstractIntegrand): The integrand.
@@ -186,7 +186,7 @@ def integrate(self, resume=None) -> tuple:
                 additional ladder steps are needed.
 
         Returns:
-            ``(solution, data)``.
+            tuple: ``(solution, data)``.
         """
         self._active_t_start = t_start = time()
         self._active_trace = trace = self._make_trace_logger()
diff --git a/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py b/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py
index e9d82f3ea..1b72bd701 100644
--- a/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py
+++ b/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py
@@ -183,16 +183,16 @@ class CubQMCBayesLatticeG(AbstractCubBayesLDG):
     def __init__(
         self,
         integrand,
-        abs_tol=1e-2,
-        rel_tol=0,
-        n_init=2**8,
-        n_limit=2**22,
+        abs_tol: np.ndarray = 1e-2,
+        rel_tol: np.ndarray = 0,
+        n_init: int = 2**8,
+        n_limit: int = 2**22,
         error_fun="EITHER",
-        alpha=0.01,
-        ptransform="C1SIN",
-        errbd_type="MLE",
-        order=2,
-    ):
+        alpha: np.ndarray = 0.01,
+        ptransform: str = "C1SIN",
+        errbd_type: str = "MLE",
+        order: int = 2,
+    ) -> None:
         r"""
         Args:
             integrand (AbstractIntegrand): The integrand.
diff --git a/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py b/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py
index 335ea77b3..d6e3987ce 100644
--- a/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py
+++ b/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py
@@ -192,14 +192,14 @@ class CubQMCBayesNetG(AbstractCubBayesLDG):
     def __init__(
         self,
         integrand,
-        abs_tol=1e-2,
-        rel_tol=0,
-        n_init=2**8,
-        n_limit=2**22,
+        abs_tol: np.ndarray = 1e-2,
+        rel_tol: np.ndarray = 0,
+        n_init: int = 2**8,
+        n_limit: int = 2**22,
         error_fun="EITHER",
-        alpha=0.01,
-        errbd_type="MLE",
-    ):
+        alpha: np.ndarray = 0.01,
+        errbd_type: str = "MLE",
+    ) -> None:
         r"""
         Args:
             integrand (AbstractIntegrand): The integrand.
diff --git a/qmcpy/stopping_criterion/cub_qmc_lattice_g.py b/qmcpy/stopping_criterion/cub_qmc_lattice_g.py
index b50a23a60..2a3b1e32e 100644
--- a/qmcpy/stopping_criterion/cub_qmc_lattice_g.py
+++ b/qmcpy/stopping_criterion/cub_qmc_lattice_g.py
@@ -176,15 +176,15 @@ class CubQMCLatticeG(AbstractCubQMCLDG):
     def __init__(
         self,
         integrand,
-        abs_tol=1e-2,
-        rel_tol=0.0,
-        n_init=2**10,
-        n_limit=2**30,
+        abs_tol: np.ndarray = 1e-2,
+        rel_tol: np.ndarray = 0.0,
+        n_init: int = 2**10,
+        n_limit: int = 2**30,
         error_fun="EITHER",
         fudge=_default_fudge,
-        check_cone=False,
-        ptransform="BAKER",
-    ):
+        check_cone: bool = False,
+        ptransform: str = "BAKER",
+    ) -> None:
         r"""
         Args:
             integrand (AbstractIntegrand): The integrand.
diff --git a/qmcpy/stopping_criterion/cub_qmc_net_g.py b/qmcpy/stopping_criterion/cub_qmc_net_g.py
index 50254a440..36630080f 100644
--- a/qmcpy/stopping_criterion/cub_qmc_net_g.py
+++ b/qmcpy/stopping_criterion/cub_qmc_net_g.py
@@ -218,17 +218,17 @@ class CubQMCNetG(AbstractCubQMCLDG):
     def __init__(
         self,
         integrand,
-        abs_tol=1e-2,
-        rel_tol=0.0,
-        n_init=2**10,
-        n_limit=2**35,
+        abs_tol: np.ndarray = 1e-2,
+        rel_tol: np.ndarray = 0.0,
+        n_init: int = 2**10,
+        n_limit: int = 2**35,
         error_fun="EITHER",
         fudge=_default_fudge,
-        check_cone=False,
-        control_variates=None,
-        control_variate_means=None,
-        update_cv_coeffs=False,
-    ):
+        check_cone: bool = False,
+        control_variates: list = None,
+        control_variate_means: np.ndarray = None,
+        update_cv_coeffs: bool = False,
+    ) -> None:
         r"""
         Args:
             integrand (AbstractIntegrand): The integrand.
diff --git a/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py b/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py
index 0ec0f6e27..def85c804 100644
--- a/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py
+++ b/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py
@@ -205,14 +205,14 @@ class CubQMCRepStudentT(AbstractStoppingCriterion):
     def __init__(
         self,
         integrand,
-        abs_tol=1e-2,
-        rel_tol=0.0,
-        n_init=256.0,
-        n_limit=2**30,
+        abs_tol: np.ndarray = 1e-2,
+        rel_tol: np.ndarray = 0.0,
+        n_init: int = 256.0,
+        n_limit: int = 2**30,
         error_fun="EITHER",
-        inflate=1,
-        alpha=0.01,
-    ):
+        inflate: float = 1,
+        alpha: np.ndarray = 0.01,
+    ) -> None:
         r"""
         Args:
             integrand (AbstractIntegrand): The integrand.
diff --git a/qmcpy/stopping_criterion/pf_gp_ci.py b/qmcpy/stopping_criterion/pf_gp_ci.py
index a5f69fbbf..97a915436 100644
--- a/qmcpy/stopping_criterion/pf_gp_ci.py
+++ b/qmcpy/stopping_criterion/pf_gp_ci.py
@@ -23,7 +23,7 @@ class Suggester(object):
 
 
 class PFSampleErrorDensityAR(Suggester):
-    def __init__(self, verbose=False):
+    def __init__(self, verbose=False) -> None:
         self.verbose = verbose
         super(PFSampleErrorDensityAR, self).__init__()
 
@@ -55,7 +55,7 @@ def suggest(self, n, d, gp, rng, efficiency, pct=0.5):
 
 
 class SuggesterSimple(Suggester):
-    def __init__(self, sampler):
+    def __init__(self, sampler) -> None:
         self.sampler = sampler
         if isinstance(self.sampler, AbstractTrueMeasure):
             if not ((self.sampler.range == [0, 1]).all()):
@@ -166,21 +166,21 @@ class PFGPCI(AbstractStoppingCriterion):
     def __init__(
         self,
         integrand,
-        failure_threshold,
-        failure_above_threshold,
-        abs_tol=5e-3,
-        n_init=64,
-        n_limit=1000,
-        alpha=1e-2,
-        init_samples=None,
+        failure_threshold: float,
+        failure_above_threshold: bool,
+        abs_tol: float = 5e-3,
+        n_init: float = 64,
+        n_limit: int = 1000,
+        alpha: float = 1e-2,
+        init_samples: float = None,
         batch_sampler=PFSampleErrorDensityAR(),
-        n_batch=4,
-        n_approx=2**20,
-        gpytorch_prior_mean=gpytorch.means.ZeroMean(),
-        gpytorch_prior_cov=gpytorch.kernels.ScaleKernel(
+        n_batch: int = 4,
+        n_approx: int = 2**20,
+        gpytorch_prior_mean: gpytorch.means = gpytorch.means.ZeroMean(),
+        gpytorch_prior_cov: gpytorch.kernels = gpytorch.kernels.ScaleKernel(
             gpytorch.kernels.MaternKernel(nu=2.5)
         ),
-        gpytorch_likelihood=gpytorch.likelihoods.GaussianLikelihood(
+        gpytorch_likelihood: gpytorch.likelihoods = gpytorch.likelihoods.GaussianLikelihood(
             noise_constraint=gpytorch.constraints.Interval(1e-12, 1e-8)
         ),
         gpytorch_marginal_log_likelihood_func=lambda likelihood, gpyt_model: gpytorch.mlls.ExactMarginalLogLikelihood(
@@ -189,12 +189,12 @@ def __init__(
         torch_optimizer_func=lambda gpyt_model: torch.optim.Adam(
             gpyt_model.parameters(), lr=0.1
         ),
-        gpytorch_train_iter=100,
-        gpytorch_use_gpu=False,
-        verbose=False,
-        n_ref_approx=2**22,
-        seed_ref_approx=None,
-    ):
+        gpytorch_train_iter: int = 100,
+        gpytorch_use_gpu: bool = False,
+        verbose: int = False,
+        n_ref_approx: int = 2**22,
+        seed_ref_approx: int = None,
+    ) -> None:
         """
         Args:
             integrand (AbstractIntegrand): The integrand.
@@ -427,7 +427,7 @@ def __init__(
         gpytorch_use_gpu,
         verbose,
         approx_true_solution,
-    ):
+    ) -> None:
         self.stopping_crit = stopping_crit
         self.integrand = integrand
         self.true_measure = true_measure
diff --git a/qmcpy/true_measure/abstract_true_measure.py b/qmcpy/true_measure/abstract_true_measure.py
index 6e426fe2c..d2be6b1ee 100644
--- a/qmcpy/true_measure/abstract_true_measure.py
+++ b/qmcpy/true_measure/abstract_true_measure.py
@@ -8,7 +8,7 @@
 
 class AbstractTrueMeasure(object):
 
-    def __init__(self):
+    def __init__(self) -> None:
         prefix = "A concrete implementation of TrueMeasure must have "
         if not hasattr(self, "domain"):
             raise ParameterError(
@@ -201,7 +201,7 @@ def _weight(self, x):
             self, "weight. Try a different true measure with a _weight method."
         )
 
-    def spawn(self, s=1, dimensions=None):
+    def spawn(self, s: int = 1, dimensions: np.ndarray = None):
         r"""Spawn new instances of the current true measure but with new seeds
         and dimensions. Used by multi-level QMC algorithms which require
         different seeds and dimensions on each level.
diff --git a/qmcpy/true_measure/acceptance_rejection.py b/qmcpy/true_measure/acceptance_rejection.py
index 96e0bbead..3ee00d929 100644
--- a/qmcpy/true_measure/acceptance_rejection.py
+++ b/qmcpy/true_measure/acceptance_rejection.py
@@ -75,7 +75,7 @@ class AcceptanceRejection(AbstractTrueMeasure):
         qmcpy.util.exceptions_warnings.ParameterError: n_min > 0 but no prior call was made. Call gen_samples with n_min=0 first.
     """
 
-    def __init__(self, sampler, target_density, upper_bound, density_integral, max_retries=4):
+    def __init__(self, sampler, target_density, upper_bound, density_integral, max_retries=4) -> None:
         self.parameters = ['target_dim', 'upper_bound', 'density_integral', 'acceptance_rate']
         self.domain = np.array([[0, 1]])
         self._parse_sampler(sampler)
@@ -104,7 +104,7 @@ def __init__(self, sampler, target_density, upper_bound, density_integral, max_r
         self._driver_offset = None
         super(AcceptanceRejection, self).__init__()
 
-    def gen_samples(self, n=None, n_min=None, n_max=None, return_weights=False, warn=True):
+    def gen_samples(self, n: int = None, n_min: int = None, n_max: int = None, return_weights: bool = False, warn: bool = True):
         """Generate accepted samples from the target density.
 
         Unlike other TrueMeasures, this method cannot be decomposed into a
@@ -290,7 +290,7 @@ class AcceptanceRejectionReal(AbstractTrueMeasure):
     """
 
     def __init__(self, sampler, target_density, inv_cdfs, H_func,
-                 upper_bound, density_integral, max_retries=4):
+                 upper_bound, density_integral, max_retries=4) -> None:
         self.parameters = ['target_dim', 'upper_bound', 'density_integral', 'acceptance_rate']
         self.domain = np.array([[0, 1]])
         self._parse_sampler(sampler)
@@ -320,7 +320,7 @@ def __init__(self, sampler, target_density, inv_cdfs, H_func,
         self._driver_offset = None
         super(AcceptanceRejectionReal, self).__init__()
 
-    def gen_samples(self, n=None, n_min=None, n_max=None, return_weights=False, warn=True):
+    def gen_samples(self, n: int = None, n_min: int = None, n_max: int = None, return_weights: bool = False, warn: bool = True):
         """Generate accepted samples from the target density on R^d.
 
         Unlike other TrueMeasures, this method cannot be decomposed into a
diff --git a/qmcpy/true_measure/bernoulli_cont.py b/qmcpy/true_measure/bernoulli_cont.py
index 50dcefa67..95d8664ba 100644
--- a/qmcpy/true_measure/bernoulli_cont.py
+++ b/qmcpy/true_measure/bernoulli_cont.py
@@ -37,7 +37,7 @@ class BernoulliCont(AbstractTrueMeasure):
                 [0.6345258 , 0.60241448, 0.84822692]]])
     """
 
-    def __init__(self, sampler, lam=1 / 2):
+    def __init__(self, sampler, lam=1 / 2) -> None:
         r"""
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
diff --git a/qmcpy/true_measure/brownian_motion.py b/qmcpy/true_measure/brownian_motion.py
index 5384ac47f..e82d63f4a 100644
--- a/qmcpy/true_measure/brownian_motion.py
+++ b/qmcpy/true_measure/brownian_motion.py
@@ -139,16 +139,16 @@ class BrownianMotion(Gaussian):
     def __init__(
         self,
         sampler,
-        t_final=1,
-        initial_value=0,
-        drift=0,
-        diffusion=1,
-        decomp_type="PCA",
-        lazy_decomp=True,
+        t_final: float = 1,
+        initial_value: float = 0,
+        drift: int = 0,
+        diffusion: int = 1,
+        decomp_type: str = "PCA",
+        lazy_decomp: bool = True,
         monitoring_times=None,
-        bridge_vdc_gray_ordering=True,
-        bridge_output_order='increasing',
-    ):
+        bridge_vdc_gray_ordering: bool = True,
+        bridge_output_order: str = 'increasing',
+    ) -> None:
         r"""
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
diff --git a/qmcpy/true_measure/clayton_copula.py b/qmcpy/true_measure/clayton_copula.py
index c446159f4..8276d397e 100644
--- a/qmcpy/true_measure/clayton_copula.py
+++ b/qmcpy/true_measure/clayton_copula.py
@@ -79,7 +79,7 @@ class ClaytonCopula(AbstractCopula):
         [doi:10.1016/j.jmva.2012.02.019](https://doi.org/10.1016/j.jmva.2012.02.019).
     """
 
-    def __init__(self, sampler, marginals, theta):
+    def __init__(self, sampler, marginals: list, theta: float) -> None:
         r"""
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
diff --git a/qmcpy/true_measure/copula.py b/qmcpy/true_measure/copula.py
index 7bb539367..ddd4ee09c 100644
--- a/qmcpy/true_measure/copula.py
+++ b/qmcpy/true_measure/copula.py
@@ -24,7 +24,7 @@ class AbstractCopula(AbstractTrueMeasure):
     transform.
     """
 
-    def __init__(self, sampler, marginals):
+    def __init__(self, sampler, marginals) -> None:
         self.domain = np.array([[0, 1]])
         self._parse_sampler(sampler)
 
@@ -41,14 +41,14 @@ def _transform_to_uniform(self, x) -> np.ndarray:
         """
         raise MethodImplementationError(self, "_transform_to_uniform")
 
-    def copula_transform(self, u) -> np.ndarray:
+    def copula_transform(self, u: np.ndarray) -> np.ndarray:
         r"""Apply only the copula layer ``U -> V``.
 
         Args:
             u (np.ndarray): Independent uniform points on ``[0,1]^d``.
 
         Returns:
-            Dependent uniform points on ``[0,1]^d``.
+            np.ndarray: Dependent uniform points on ``[0,1]^d``.
         """
         return self._transform_to_uniform(u)
 
diff --git a/qmcpy/true_measure/frank_copula.py b/qmcpy/true_measure/frank_copula.py
index 0afdbe436..7e402d3d9 100644
--- a/qmcpy/true_measure/frank_copula.py
+++ b/qmcpy/true_measure/frank_copula.py
@@ -102,7 +102,7 @@ class FrankCopula(AbstractCopula):
         [doi:10.1016/j.jmva.2012.02.019](https://doi.org/10.1016/j.jmva.2012.02.019).
     """
 
-    def __init__(self, sampler, marginals, theta):
+    def __init__(self, sampler, marginals: list, theta: float) -> None:
         r"""
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
diff --git a/qmcpy/true_measure/gaussian.py b/qmcpy/true_measure/gaussian.py
index 63ae5a25d..33a0e2b35 100644
--- a/qmcpy/true_measure/gaussian.py
+++ b/qmcpy/true_measure/gaussian.py
@@ -48,7 +48,7 @@ class Gaussian(AbstractTrueMeasure):
                 [ 1.1844196 ,  0.44964332,  1.27760936]]])
     """
 
-    def __init__(self, sampler, mean=0.0, covariance=1.0, decomp_type="PCA"):
+    def __init__(self, sampler, mean: Union[float, np.ndarray] = 0.0, covariance: Union[float, np.ndarray] = 1.0, decomp_type: str = "PCA") -> None:
         """
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
diff --git a/qmcpy/true_measure/gaussian_copula.py b/qmcpy/true_measure/gaussian_copula.py
index 9da4a15d6..ba23234f8 100644
--- a/qmcpy/true_measure/gaussian_copula.py
+++ b/qmcpy/true_measure/gaussian_copula.py
@@ -75,7 +75,7 @@ class GaussianCopula(AbstractCopula):
         [arXiv:1508.03483](https://arxiv.org/abs/1508.03483).
     """
 
-    def __init__(self, sampler, marginals, correlation):
+    def __init__(self, sampler, marginals: list, correlation: np.ndarray) -> None:
         r"""
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
diff --git a/qmcpy/true_measure/geometric_brownian_motion.py b/qmcpy/true_measure/geometric_brownian_motion.py
index 25d3d6cf1..7f27580cd 100644
--- a/qmcpy/true_measure/geometric_brownian_motion.py
+++ b/qmcpy/true_measure/geometric_brownian_motion.py
@@ -50,14 +50,14 @@ class GeometricBrownianMotion(BrownianMotion):
     def __init__(
         self,
         sampler,
-        t_final=1,
-        initial_value=1,
-        drift=0,
-        diffusion=1,
-        decomp_type="PCA",
-        lazy_load=True,
-        lazy_decomp=True,
-    ):
+        t_final: float = 1,
+        initial_value: float = 1,
+        drift: float = 0,
+        diffusion: float = 1,
+        decomp_type: str = "PCA",
+        lazy_load: bool = True,
+        lazy_decomp: bool = True,
+    ) -> None:
         r"""
         Args:
             sampler (DiscreteDistribution/TrueMeasure): A discrete distribution
@@ -309,7 +309,7 @@ def _weight(self, x):
         return normal_pdf * jacobian
 
     def gen_samples(
-        self, n=None, n_min=None, n_max=None, return_weights=False, warn=True
+        self, n=None, n_min=None, n_max=None, return_weights: bool = False, warn: bool = True
     ) -> Union[ndarray, Tuple[ndarray, ndarray]]:
         """Generate GBM samples using the parent's transform pipeline.
 
@@ -321,6 +321,6 @@ def gen_samples(
             warn (bool): whether to warn about sample generation
 
         Returns:
-            GBM samples, optionally with weights if return_weights=True
+            Union[ndarray, Tuple[ndarray, ndarray]]: GBM samples, optionally with weights if return_weights=True
         """
         return super().gen_samples(n=n, n_min=n_min, n_max=n_max, return_weights=return_weights, warn=warn)
diff --git a/qmcpy/true_measure/gumbel_copula.py b/qmcpy/true_measure/gumbel_copula.py
index 84db0da73..5d3f0cbd1 100644
--- a/qmcpy/true_measure/gumbel_copula.py
+++ b/qmcpy/true_measure/gumbel_copula.py
@@ -75,7 +75,7 @@ class GumbelCopula(AbstractCopula):
         [doi:10.1016/j.jmva.2012.02.019](https://doi.org/10.1016/j.jmva.2012.02.019).
     """
 
-    def __init__(self, sampler, marginals, theta):
+    def __init__(self, sampler, marginals: list, theta: float) -> None:
         r"""
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
diff --git a/qmcpy/true_measure/johnsons_su.py b/qmcpy/true_measure/johnsons_su.py
index 1f5bdc2f4..d9fa893eb 100644
--- a/qmcpy/true_measure/johnsons_su.py
+++ b/qmcpy/true_measure/johnsons_su.py
@@ -41,7 +41,7 @@ class JohnsonsSU(AbstractTrueMeasure):
                 [ 1.57765245,  1.00275   ,  1.64972468]]])
     """
 
-    def __init__(self, sampler, gamma=1, xi=1, delta=2, lam=2):
+    def __init__(self, sampler, gamma=1, xi=1, delta=2, lam=2) -> None:
         r"""
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
diff --git a/qmcpy/true_measure/kumaraswamy.py b/qmcpy/true_measure/kumaraswamy.py
index 8b7bc7f69..eaa0d2c0d 100644
--- a/qmcpy/true_measure/kumaraswamy.py
+++ b/qmcpy/true_measure/kumaraswamy.py
@@ -50,7 +50,7 @@ class Kumaraswamy(AbstractTrueMeasure):
                 [0.37253319, 0.45379743, 0.63366422]]])
     """
 
-    def __init__(self, sampler, a=2, b=2):
+    def __init__(self, sampler, a=2, b=2) -> None:
         r"""
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
diff --git a/qmcpy/true_measure/lebesgue.py b/qmcpy/true_measure/lebesgue.py
index 7de76cf30..7da6cf885 100644
--- a/qmcpy/true_measure/lebesgue.py
+++ b/qmcpy/true_measure/lebesgue.py
@@ -35,7 +35,7 @@ class Lebesgue(AbstractTrueMeasure):
                                                   (1, 1) 0.08333333333333333
     """
 
-    def __init__(self, sampler):
+    def __init__(self, sampler: AbstractTrueMeasure) -> None:
         r"""
         Args:
             sampler (AbstractTrueMeasure): A true measure by which to compose a
diff --git a/qmcpy/true_measure/matern_gp.py b/qmcpy/true_measure/matern_gp.py
index 06588cfc8..3df5e93e3 100644
--- a/qmcpy/true_measure/matern_gp.py
+++ b/qmcpy/true_measure/matern_gp.py
@@ -66,15 +66,15 @@ class MaternGP(Gaussian):
 
     def __init__(
         self,
-        sampler,
-        points,
-        length_scale=1.0,
-        nu=1.5,
-        variance=1.0,
-        mean=0.0,
-        nugget=1e-6,
-        decomp_type="PCA",
-    ):
+        sampler: Union[AbstractDiscreteDistribution, AbstractTrueMeasure],
+        points: np.ndarray,
+        length_scale: Union[float, np.ndarray] = 1.0,
+        nu: float = 1.5,
+        variance: float = 1.0,
+        mean: Union[float, np.ndarray] = 0.0,
+        nugget: float = 1e-6,
+        decomp_type: str = "PCA",
+    ) -> None:
         r"""
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
diff --git a/qmcpy/true_measure/product_measure.py b/qmcpy/true_measure/product_measure.py
index 22a644d98..3f71c3264 100644
--- a/qmcpy/true_measure/product_measure.py
+++ b/qmcpy/true_measure/product_measure.py
@@ -98,7 +98,7 @@ class ProductMeasure(AbstractTrueMeasure):
     (4, 3)
     """
 
-    def __init__(self, sampler, marginals):
+    def __init__(self, sampler, marginals) -> None:
         """Initialize a product measure from one sampler and several
         marginals.
 
diff --git a/qmcpy/true_measure/scipy_wrapper.py b/qmcpy/true_measure/scipy_wrapper.py
index f85b60d54..dc8d621ce 100644
--- a/qmcpy/true_measure/scipy_wrapper.py
+++ b/qmcpy/true_measure/scipy_wrapper.py
@@ -175,7 +175,7 @@ class SciPyWrapper(AbstractTrueMeasure):
         (4, 2)
     """
 
-    def __init__(self, sampler, scipy_distribs):
+    def __init__(self, sampler, scipy_distribs) -> None:
         """Parameters ---------- sampler : AbstractDiscreteDistribution Low
         discrepancy or iid sampler in dimension d, living on [0,1)^d.
         scipy_distribs:
diff --git a/qmcpy/true_measure/student_t.py b/qmcpy/true_measure/student_t.py
index 56a216643..dcf91a7f3 100644
--- a/qmcpy/true_measure/student_t.py
+++ b/qmcpy/true_measure/student_t.py
@@ -105,7 +105,7 @@ class StudentT(SciPyWrapper):
     """Convenience true measure: multivariate Student t.
     """
 
-    def __init__(self, sampler, loc, shape, df):
+    def __init__(self, sampler, loc, shape, df) -> None:
         super().__init__(
             sampler=sampler,
             scipy_distribs=_StudentTAdapter(loc=loc, shape=shape, df=df),
diff --git a/qmcpy/true_measure/student_t_copula.py b/qmcpy/true_measure/student_t_copula.py
index f05b28b06..52b0a683b 100644
--- a/qmcpy/true_measure/student_t_copula.py
+++ b/qmcpy/true_measure/student_t_copula.py
@@ -86,7 +86,7 @@ class StudentTCopula(AbstractCopula):
         "Weights will be treated as 1."
     )
 
-    def __init__(self, sampler, marginals, correlation, df):
+    def __init__(self, sampler, marginals: list, correlation: np.ndarray, df: float) -> None:
         r"""
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
diff --git a/qmcpy/true_measure/triangular.py b/qmcpy/true_measure/triangular.py
index 76314fd24..a836d1612 100644
--- a/qmcpy/true_measure/triangular.py
+++ b/qmcpy/true_measure/triangular.py
@@ -11,7 +11,7 @@ class TriangularDistribution:
     ppf and pdf for SciPyWrapper custom-marginal usage.
     """
 
-    def __init__(self, c=0.5, loc=0.0, scale=1.0):
+    def __init__(self, c=0.5, loc=0.0, scale=1.0) -> None:
         c = float(c)
         loc = float(loc)
         scale = float(scale)
@@ -58,7 +58,7 @@ def ppf(self, u):
 class Triangular(SciPyWrapper):
     """Convenience TrueMeasure wrapper around TriangularDistribution."""
 
-    def __init__(self, sampler, c=0.5, loc=0.0, scale=1.0):
+    def __init__(self, sampler, c=0.5, loc=0.0, scale=1.0) -> None:
         super().__init__(
             sampler=sampler,
             scipy_distribs=TriangularDistribution(c=c, loc=loc, scale=scale),
diff --git a/qmcpy/true_measure/uniform.py b/qmcpy/true_measure/uniform.py
index 1bc5f68da..7739b84d5 100644
--- a/qmcpy/true_measure/uniform.py
+++ b/qmcpy/true_measure/uniform.py
@@ -49,7 +49,7 @@ class Uniform(AbstractTrueMeasure):
                 [1.37943573, 1.10241448, 1.13481488]]])
     """
 
-    def __init__(self, sampler, lower_bound=0, upper_bound=1):
+    def __init__(self, sampler, lower_bound=0, upper_bound=1) -> None:
         r"""
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
diff --git a/qmcpy/true_measure/uniform_triangle.py b/qmcpy/true_measure/uniform_triangle.py
index 92734395d..8705d77df 100644
--- a/qmcpy/true_measure/uniform_triangle.py
+++ b/qmcpy/true_measure/uniform_triangle.py
@@ -58,5 +58,5 @@ class UniformTriangle(SciPyWrapper):
     True
     """
 
-    def __init__(self, sampler):
+    def __init__(self, sampler) -> None:
         super().__init__(sampler=sampler, scipy_distribs=_UniformTriangleAdapter())
diff --git a/qmcpy/true_measure/zero_inflated_exp_uniform.py b/qmcpy/true_measure/zero_inflated_exp_uniform.py
index 0b34c0b89..fb0545153 100644
--- a/qmcpy/true_measure/zero_inflated_exp_uniform.py
+++ b/qmcpy/true_measure/zero_inflated_exp_uniform.py
@@ -180,7 +180,7 @@ class ZeroInflatedExpUniform(SciPyWrapper):
     True
     """
 
-    def __init__(self, sampler, p_zero=0.4, lam=1.5, y_split=None):
+    def __init__(self, sampler, p_zero=0.4, lam=1.5, y_split=None) -> None:
         if y_split is not None:
             warnings.warn(
                 "`y_split` is deprecated. The 2D zero-inflated "
diff --git a/qmcpy/util/data.py b/qmcpy/util/data.py
index ac9b06b02..8fd142ab6 100644
--- a/qmcpy/util/data.py
+++ b/qmcpy/util/data.py
@@ -6,10 +6,10 @@
 
 class Data(object):
 
-    def __init__(self, parameters):
+    def __init__(self, parameters) -> None:
         self.parameters = parameters
 
-    def save(self, path, compress=False, overwrite=False):
+    def save(self, path, compress: bool = False, overwrite: bool = False):
         """Save this Data object to disk using pickle.
 
         Warnings:
diff --git a/qmcpy/util/dig_shift_invar_ops.py b/qmcpy/util/dig_shift_invar_ops.py
index fcb541cde..06733efcc 100644
--- a/qmcpy/util/dig_shift_invar_ops.py
+++ b/qmcpy/util/dig_shift_invar_ops.py
@@ -3,7 +3,7 @@
 from .torch_numpy_ops import get_npt
 
 
-def k4sumterm(x, t, cutoff=1e-8):
+def k4sumterm(x, t: int, cutoff=1e-8):
     r"""$$K_4(x) = \sum_{a=0}^{t-1} \frac{x_a}{2^{3a}}$$
 
     where $x_a$ is the bit at index $a$ in the binary expansion of $x$ e.g. $x
@@ -64,7 +64,7 @@ def k4sumterm(x, t, cutoff=1e-8):
 }
 
 
-def weighted_walsh_funcs(alpha, xb, t):
+def weighted_walsh_funcs(alpha: int, xb, t: int):
     r"""Weighted walsh functions
 
     $$\sum_{k=0}^\infty \mathrm{wal}_k(x) 2^{-\mu_\alpha(k)}$$
@@ -157,7 +157,7 @@ def weighted_walsh_funcs(alpha, xb, t):
     return y
 
 
-def to_bin(x, t):
+def to_bin(x, t: int):
     r"""Convert floating point representations of digital net samples in base
     $b=2$ to binary representations.
 
@@ -208,7 +208,7 @@ def to_bin(x, t):
             raise ParameterError("x.dtype must be float or int, got %s" % str(x.dtype))
 
 
-def to_float(x, t):
+def to_float(x, t: int):
     r"""Convert binary representations of digital net samples in base $b=2$ to
     floating point representations.
 
diff --git a/qmcpy/util/exceptions_warnings.py b/qmcpy/util/exceptions_warnings.py
index 5e19e1421..d0ab7edd1 100644
--- a/qmcpy/util/exceptions_warnings.py
+++ b/qmcpy/util/exceptions_warnings.py
@@ -26,7 +26,7 @@ class MethodImplementationError(Exception):
     implemented in the child class.
     """
 
-    def __init__(self, subclass, method_name):
+    def __init__(self, subclass, method_name) -> None:
         s_f = (
             "%s does not have an implementation of the  %s method. "
             + "See superclass for method description."
diff --git a/qmcpy/util/latnetbuilder_linker.py b/qmcpy/util/latnetbuilder_linker.py
index d2b4ce197..c18372290 100644
--- a/qmcpy/util/latnetbuilder_linker.py
+++ b/qmcpy/util/latnetbuilder_linker.py
@@ -2,7 +2,7 @@
 import numpy as np
 
 
-def latnetbuilder_linker(lnb_dir="./", out_dir="./", fout_prefix="lnb4qmcpy"):
+def latnetbuilder_linker(lnb_dir: str = "./", out_dir: str = "./", fout_prefix: str = "lnb4qmcpy"):
     """
     Args:
         lnb_dir (str): relative path to directory where `outputMachine.txt` is
diff --git a/qmcpy/util/mlmc_test.py b/qmcpy/util/mlmc_test.py
index 158865178..26d28519e 100644
--- a/qmcpy/util/mlmc_test.py
+++ b/qmcpy/util/mlmc_test.py
@@ -3,12 +3,12 @@
 
 def mlmc_test(
     integrand,
-    n = 20000,
-    l = 8,
-    n_init = 200,
-    rmse_tols = np.array([.005, 0.01, 0.02, 0.05, 0.1]),
-    levels_min = 2,
-    levels_max = 10,
+    n: int = 20000,
+    l: int = 8,
+    n_init: int = 200,
+    rmse_tols: np.ndarray = np.array([.005, 0.01, 0.02, 0.05, 0.1]),
+    levels_min: int = 2,
+    levels_max: int = 10,
     ):
     r"""Multilevel Monte Carlo test routine.
 
diff --git a/qmcpy/util/plot_functions.py b/qmcpy/util/plot_functions.py
index 3f25b756d..d73550bd0 100644
--- a/qmcpy/util/plot_functions.py
+++ b/qmcpy/util/plot_functions.py
@@ -8,15 +8,15 @@ def plot_proj(
     n=64,
     d_horizontal=1,
     d_vertical=2,
-    math_ind=True,
-    marker_size=5,
-    figfac=5,
-    fig_title="Projection of Samples",
-    axis_pad=0,
-    want_grid=True,
-    font_family="sans-serif",
-    where_title=1,
-    **kwargs
+    math_ind: bool = True,
+    marker_size: float = 5,
+    figfac: float = 5,
+    fig_title: str = "Projection of Samples",
+    axis_pad: float = 0,
+    want_grid: bool = True,
+    font_family: str = "sans-serif",
+    where_title: float = 1,
+    **kwargs: dict
 ):
     """
     Args:
diff --git a/qmcpy/util/shift_invar_ops.py b/qmcpy/util/shift_invar_ops.py
index 77f711c42..40059e230 100644
--- a/qmcpy/util/shift_invar_ops.py
+++ b/qmcpy/util/shift_invar_ops.py
@@ -10,7 +10,7 @@ class Polynomial:
     >>> assert np.allclose(y,y_true,atol=1e-12)
     """
 
-    def __init__(self, coeffs):
+    def __init__(self, coeffs) -> None:
         """Polynomial evaluation with Horner's rule
 
         Args:
@@ -54,7 +54,7 @@ def __call__(self, x):
 }
 
 
-def bernoulli_poly(n, x):
+def bernoulli_poly(n: int, x):
     r"""$n^\text{th}$ Bernoulli polynomial
 
     Examples:
diff --git a/scripts/add_docstring_arg_types.py b/scripts/add_docstring_arg_types.py
index 479096dfb..f26a376fb 100644
--- a/scripts/add_docstring_arg_types.py
+++ b/scripts/add_docstring_arg_types.py
@@ -1,10 +1,12 @@
 #!/usr/bin/env python3
-"""Add Google-style argument types from Python annotations.
+"""Synchronize Google-style docstring types from Python annotations.
 
 This helper is intentionally conservative: it rewrites existing ``Args:``
 entries for public functions and methods only when the corresponding argument
-has an explicit annotation in the signature. It does not infer types from
-implementation code and it does not invent missing argument descriptions.
+has an explicit annotation in the signature. With ``--include-outputs``, it
+also updates existing ``Returns:`` and ``Yields:`` descriptions from return
+annotations. It does not infer types from implementation code and it does not
+invent missing descriptions or sections.
 """
 from __future__ import annotations
 
@@ -26,6 +28,16 @@
     r"\s*:\s*"
     r"(?P<description>.*)$"
 )
+OUTPUT_ENTRY = re.compile(
+    r"^(?P<indent>\s*)(?P<type>[^:]+):\s*(?P<description>.*)$"
+)
+YIELD_CONTAINER_NAMES = {
+    "AsyncGenerator",
+    "AsyncIterator",
+    "Generator",
+    "Iterable",
+    "Iterator",
+}
 
 
 @dataclass
@@ -36,6 +48,7 @@ class Update:
     argument: str
     annotation: str
     previous_type: str | None
+    section: str = "Args"
 
 
 @dataclass
@@ -54,7 +67,7 @@ class FileResult:
     changed: bool
 
 
-def _doc_node(node: ast.AST) -> ast.Constant | None:
+def doc_node(node: ast.AST) -> ast.Constant | None:
     """Return the string-literal node holding ``node``'s docstring, if any."""
     body = getattr(node, "body", None)
     if (
@@ -67,7 +80,7 @@ def _doc_node(node: ast.AST) -> ast.Constant | None:
     return None
 
 
-def _public_functions(tree: ast.Module):
+def iter_public_functions(tree: ast.Module):
     """Yield public module functions and methods from public classes."""
     for node in tree.body:
         if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
@@ -131,7 +144,7 @@ def _argument_annotations(node: ast.FunctionDef | ast.AsyncFunctionDef, source:
     return annotations
 
 
-def _line_without_ending(line: str) -> tuple[str, str]:
+def line_without_ending(line: str) -> tuple[str, str]:
     """Split a line into content and original line ending."""
     if line.endswith("\r\n"):
         return line[:-2], "\r\n"
@@ -140,32 +153,149 @@ def _line_without_ending(line: str) -> tuple[str, str]:
     return line, ""
 
 
-def _find_args_section(
-    lines: list[str], start: int, end: int
+def find_section(
+    lines: list[str], start: int, end: int, name: str
 ) -> tuple[int, int] | None:
-    """Return ``(args_line, section_end)`` indexes for a Google Args section."""
-    args_line = None
-    args_indent = None
+    """Return the header and end indexes for a Google-style section."""
+    header_line = None
+    header_indent = None
     for i in range(start, end + 1):
-        content, _ = _line_without_ending(lines[i])
-        if content.strip() == "Args:":
-            args_line = i
-            args_indent = len(content) - len(content.lstrip())
+        content, _ = line_without_ending(lines[i])
+        if content.strip() == f"{name}:":
+            header_line = i
+            header_indent = len(content) - len(content.lstrip())
             break
-    if args_line is None or args_indent is None:
+    if header_line is None or header_indent is None:
         return None
 
     section_end = end
-    for i in range(args_line + 1, end + 1):
-        content, _ = _line_without_ending(lines[i])
+    for i in range(header_line + 1, end + 1):
+        content, _ = line_without_ending(lines[i])
         stripped = content.strip()
         if not stripped:
             continue
         indent = len(content) - len(content.lstrip())
-        if indent <= args_indent and SECTION_HEADER.match(content):
+        if indent <= header_indent and SECTION_HEADER.match(content):
             section_end = i - 1
             break
-    return args_line, section_end
+    return header_line, section_end
+
+
+def find_args_section(
+    lines: list[str], start: int, end: int
+) -> tuple[int, int] | None:
+    """Return ``(args_line, section_end)`` indexes for a Google Args section."""
+    return find_section(lines, start, end, "Args")
+
+
+def _yield_annotation_text(source: str, annotation: ast.AST) -> str | None:
+    """Extract the yielded item type from a standard iterator annotation."""
+    if isinstance(annotation, ast.Constant) and isinstance(annotation.value, str):
+        try:
+            annotation = ast.parse(annotation.value, mode="eval").body
+        except SyntaxError:
+            return None
+    if not isinstance(annotation, ast.Subscript):
+        return None
+    value = annotation.value
+    if isinstance(value, ast.Name):
+        container = value.id
+    elif isinstance(value, ast.Attribute):
+        container = value.attr
+    else:
+        return None
+    if container not in YIELD_CONTAINER_NAMES:
+        return None
+
+    item = annotation.slice
+    if container in {"Generator", "AsyncGenerator"} and isinstance(item, ast.Tuple):
+        if not item.elts:
+            return None
+        item = item.elts[0]
+    return _annotation_text(source, item)
+
+
+def looks_like_type(text: str) -> bool:
+    """Return whether text is syntactically usable as a type expression."""
+    try:
+        ast.parse(text, mode="eval")
+    except SyntaxError:
+        return False
+    return True
+
+
+def _update_output_section(
+    path: Path,
+    lines: list[str],
+    node: ast.FunctionDef | ast.AsyncFunctionDef,
+    function: str,
+    section_name: str,
+    annotation: str,
+    overwrite_existing: bool,
+) -> tuple[list[Update], list[Skip]]:
+    """Add a signature-derived type to an existing output description."""
+    dnode = doc_node(node)
+    if dnode is None or dnode.end_lineno is None:
+        return [], [Skip(path, node.lineno, function, "missing docstring")]
+
+    section = find_section(
+        lines,
+        dnode.lineno - 1,
+        dnode.end_lineno - 1,
+        section_name,
+    )
+    if section is None:
+        return [], [
+            Skip(
+                path,
+                dnode.lineno,
+                function,
+                f"missing {section_name} section for annotated output",
+            )
+        ]
+
+    header_content, _ = line_without_ending(lines[section[0]])
+    header_indent = len(header_content) - len(header_content.lstrip())
+    for i in range(section[0] + 1, section[1] + 1):
+        content, ending = line_without_ending(lines[i])
+        if not content.strip():
+            continue
+        indent = len(content) - len(content.lstrip())
+        if indent <= header_indent:
+            continue
+
+        match = OUTPUT_ENTRY.match(content)
+        previous_type = None
+        description = content.strip()
+        entry_indent = content[:indent]
+        if match is not None and looks_like_type(match.group("type").strip()):
+            previous_type = match.group("type").strip()
+            if not overwrite_existing:
+                return [], []
+            description = match.group("description").lstrip()
+            entry_indent = match.group("indent")
+
+        suffix = f" {description}" if description else ""
+        replacement = f"{entry_indent}{annotation}:{suffix}{ending}"
+        if replacement == lines[i]:
+            return [], []
+        lines[i] = replacement
+        slot = "yield" if section_name == "Yields" else "return"
+        return [
+            Update(
+                path=path,
+                line=i + 1,
+                function=function,
+                argument=slot,
+                annotation=annotation,
+                previous_type=previous_type,
+                section=section_name,
+            )
+        ], []
+
+    return [], [
+        Skip(path, node.lineno, function, f"empty {section_name} section")
+    ]
 
 
 def _update_args_section(
@@ -177,11 +307,11 @@ def _update_args_section(
     overwrite_existing: bool,
 ) -> tuple[list[Update], list[Skip]]:
     """Add annotation text to matching ``Args:`` entries."""
-    dnode = _doc_node(node)
+    dnode = doc_node(node)
     if dnode is None or dnode.end_lineno is None:
         return [], [Skip(path, node.lineno, function, "missing docstring")]
 
-    section = _find_args_section(lines, dnode.lineno - 1, dnode.end_lineno - 1)
+    section = find_args_section(lines, dnode.lineno - 1, dnode.end_lineno - 1)
     if section is None:
         return [], [Skip(path, dnode.lineno, function, "missing Args section")]
 
@@ -189,7 +319,7 @@ def _update_args_section(
     seen = set()
     _, section_end = section
     for i in range(section[0] + 1, section_end + 1):
-        content, ending = _line_without_ending(lines[i])
+        content, ending = line_without_ending(lines[i])
         match = ARG_ENTRY.match(content)
         if match is None:
             continue
@@ -234,25 +364,66 @@ def _update_args_section(
 
 
 def update_file(
-    path: Path, check: bool = False, overwrite_existing: bool = False
+    path: Path,
+    check: bool = False,
+    overwrite_existing: bool = False,
+    include_outputs: bool = False,
 ) -> FileResult:
-    """Update one Python file."""
+    """Update Google-style types in one Python file."""
     source = path.read_text(encoding="utf-8")
     tree = ast.parse(source, filename=str(path))
     lines = source.splitlines(keepends=True)
     updates = []
     skips = []
 
-    for node, function in _public_functions(tree):
+    for node, function in iter_public_functions(tree):
         annotations = _argument_annotations(node, source)
-        if not annotations:
+        if annotations:
+            node_updates, node_skips = _update_args_section(
+                path=path,
+                lines=lines,
+                node=node,
+                function=function,
+                annotations=annotations,
+                overwrite_existing=overwrite_existing,
+            )
+            updates.extend(node_updates)
+            skips.extend(node_skips)
+
+        if not include_outputs or node.name == "__init__" or node.returns is None:
             continue
-        node_updates, node_skips = _update_args_section(
+        return_annotation = _annotation_text(source, node.returns)
+        if return_annotation in {None, "None", "NoneType"}:
+            continue
+
+        dnode = doc_node(node)
+        if dnode is None or dnode.end_lineno is None:
+            skips.append(Skip(path, node.lineno, function, "missing docstring"))
+            continue
+        doc_start = dnode.lineno - 1
+        doc_end = dnode.end_lineno - 1
+        yields_section = find_section(lines, doc_start, doc_end, "Yields")
+        section_name = "Yields" if yields_section is not None else "Returns"
+        output_annotation = return_annotation
+        if section_name == "Yields":
+            output_annotation = _yield_annotation_text(source, node.returns)
+            if output_annotation is None:
+                skips.append(
+                    Skip(
+                        path,
+                        node.lineno,
+                        function,
+                        "cannot derive yielded item type from return annotation",
+                    )
+                )
+                continue
+        node_updates, node_skips = _update_output_section(
             path=path,
             lines=lines,
             node=node,
             function=function,
-            annotations=annotations,
+            section_name=section_name,
+            annotation=output_annotation,
             overwrite_existing=overwrite_existing,
         )
         updates.extend(node_updates)
@@ -275,13 +446,28 @@ def _changed_files(ref: str) -> list[Path]:
     return [Path(name) for name in result.stdout.splitlines()]
 
 
-def _python_files(paths: list[str], diff_ref: str | None) -> list[Path]:
+def _is_under(path: Path, root: Path) -> bool:
+    """Return whether a relative or absolute path is under root."""
+    try:
+        path.resolve().relative_to(root.resolve())
+    except ValueError:
+        return False
+    return True
+
+
+def python_files(
+    paths: list[str], diff_ref: str | None, root: str | None = None
+) -> list[Path]:
     """Collect Python files from paths, or from ``git diff`` when requested."""
     if diff_ref is not None:
         candidates = _changed_files(diff_ref)
     else:
         candidates = [Path(p) for p in (paths or ["qmcpy"])]
 
+    if root is not None and diff_ref is not None:
+        root_path = Path(root)
+        candidates = [path for path in candidates if _is_under(path, root_path)]
+
     files = []
     for path in candidates:
         if path.is_dir():
@@ -314,6 +500,15 @@ def _parse_args(argv: list[str]) -> argparse.Namespace:
         action="store_true",
         help="Replace existing Google Args types with signature annotations.",
     )
+    parser.add_argument(
+        "--include-outputs",
+        action="store_true",
+        help="Also update existing Returns and Yields descriptions.",
+    )
+    parser.add_argument(
+        "--root",
+        help="Restrict files selected by --diff to this directory.",
+    )
     parser.add_argument(
         "--quiet",
         action="store_true",
@@ -326,7 +521,7 @@ def main(argv: list[str]) -> int:
     """Run the command-line interface."""
     args = _parse_args(argv)
     try:
-        files = _python_files(args.paths, args.diff)
+        files = python_files(args.paths, args.diff, root=args.root)
     except subprocess.CalledProcessError as exc:
         print(f"git diff failed: {exc}", file=sys.stderr)
         return 2
@@ -343,6 +538,7 @@ def main(argv: list[str]) -> int:
                 path,
                 check=args.check,
                 overwrite_existing=args.overwrite_existing,
+                include_outputs=args.include_outputs,
             )
         except SyntaxError as exc:
             had_parse_error = True
@@ -367,10 +563,13 @@ def main(argv: list[str]) -> int:
         for skip in skips:
             print(f"{skip.path}:{skip.line}: skipped {skip.function}: {skip.reason}")
 
+    args_updates = [update for update in updates if update.section == "Args"]
+    output_updates = [update for update in updates if update.section != "Args"]
     changed_files = sum(1 for result in results if result.changed)
     verb = "would change" if args.check else "changed"
     print(
-        f"{len(files)} file(s) inspected; {len(updates)} Args type update(s); "
+        f"{len(files)} file(s) inspected; {len(args_updates)} Args type update(s); "
+        f"{len(output_updates)} output type update(s); "
         f"{changed_files} file(s) {verb}."
     )
 
diff --git a/scripts/annotate_public_api_types.py b/scripts/annotate_public_api_types.py
new file mode 100644
index 000000000..a24de4711
--- /dev/null
+++ b/scripts/annotate_public_api_types.py
@@ -0,0 +1,731 @@
+#!/usr/bin/env python3
+"""Add conservative public-API annotations from Google-style docstrings.
+
+Only public module functions, public methods, and constructors of public
+classes are considered. A docstring type is applied only when it is valid
+Python annotation syntax and every referenced name is already bound by the
+module or is a built-in type. Existing annotations are never overwritten;
+conflicts are reported for review.
+"""
+from __future__ import annotations
+
+import argparse
+import ast
+import re
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+import libcst as cst
+from libcst.metadata import MetadataWrapper, PositionProvider
+
+from scripts import add_docstring_arg_types as docstrings
+
+
+BUILTIN_TYPE_NAMES = {
+    "bool",
+    "bytearray",
+    "bytes",
+    "complex",
+    "dict",
+    "float",
+    "frozenset",
+    "int",
+    "list",
+    "memoryview",
+    "object",
+    "range",
+    "set",
+    "slice",
+    "str",
+    "tuple",
+    "type",
+}
+
+
+@dataclass(frozen=True)
+class FunctionSpec:
+    """Docstring-derived annotations for one public callable."""
+
+    function: str
+    line: int
+    arguments: dict[str, str]
+    rejected_arguments: dict[str, tuple[str, str]]
+    return_type: str | None
+
+
+@dataclass(frozen=True)
+class Update:
+    """One annotation inserted into a function signature."""
+
+    path: Path
+    line: int
+    function: str
+    slot: str
+    annotation: str
+
+
+@dataclass(frozen=True)
+class Conflict:
+    """A disagreement between an annotation and its docstring type."""
+
+    path: Path
+    line: int
+    function: str
+    slot: str
+    signature_type: str
+    docstring_type: str
+
+
+@dataclass(frozen=True)
+class Skip:
+    """A docstring type that is unsafe to place in a signature."""
+
+    path: Path
+    line: int
+    function: str
+    slot: str
+    docstring_type: str
+    reason: str
+
+
+@dataclass(frozen=True)
+class UnsafeExistingAnnotation:
+    """An existing annotation that repeats a rejected docstring type."""
+
+    path: Path
+    line: int
+    function: str
+    slot: str
+    annotation: str
+    reason: str
+
+
+@dataclass(frozen=True)
+class SourceResult:
+    """Result of analyzing and transforming one source string."""
+
+    source: str
+    updates: tuple[Update, ...]
+    conflicts: tuple[Conflict, ...]
+    skips: tuple[Skip, ...]
+    unsafe_existing: tuple[UnsafeExistingAnnotation, ...]
+
+
+@dataclass(frozen=True)
+class FileResult:
+    """Result of inspecting one Python file."""
+
+    path: Path
+    updates: tuple[Update, ...]
+    conflicts: tuple[Conflict, ...]
+    skips: tuple[Skip, ...]
+    unsafe_existing: tuple[UnsafeExistingAnnotation, ...]
+    changed: bool
+
+
+def _module_names(tree: ast.Module, before_line: int) -> set[str]:
+    """Collect module names bound before a callable's definition."""
+    names = set(BUILTIN_TYPE_NAMES)
+    for node in tree.body:
+        if getattr(node, "lineno", before_line) >= before_line:
+            continue
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                names.add(alias.asname or alias.name.split(".")[0])
+        elif isinstance(node, ast.ImportFrom):
+            for alias in node.names:
+                if alias.name != "*":
+                    names.add(alias.asname or alias.name)
+        elif isinstance(
+            node,
+            (ast.ClassDef, ast.FunctionDef, ast.AsyncFunctionDef),
+        ):
+            names.add(node.name)
+        elif isinstance(node, (ast.Assign, ast.AnnAssign, ast.NamedExpr)):
+            targets = node.targets if isinstance(node, ast.Assign) else [node.target]
+            for target in targets:
+                if isinstance(target, ast.Name):
+                    names.add(target.id)
+    return names
+
+
+def _annotation_expression(
+    text: str,
+    available_names: set[str],
+) -> tuple[str | None, str | None]:
+    """Validate and normalize a docstring type for runtime-safe insertion."""
+    text = text.strip()
+    try:
+        expression = ast.parse(text, mode="eval").body
+    except SyntaxError:
+        return None, "not valid Python annotation syntax"
+
+    if isinstance(expression, ast.Constant) and isinstance(expression.value, str):
+        return None, "string descriptions are not inserted as annotations"
+    unsafe = (
+        ast.BoolOp,
+        ast.Call,
+        ast.Compare,
+        ast.Dict,
+        ast.DictComp,
+        ast.GeneratorExp,
+        ast.IfExp,
+        ast.Lambda,
+        ast.ListComp,
+        ast.Set,
+        ast.SetComp,
+    )
+    if any(isinstance(node, unsafe) for node in ast.walk(expression)):
+        return None, "contains an expression that is unsafe in an annotation"
+    if any(isinstance(node, ast.BinOp) for node in ast.walk(expression)):
+        return None, "uses an operator that is not safe for Python 3.9 annotations"
+
+    referenced_names = {
+        node.id for node in ast.walk(expression) if isinstance(node, ast.Name)
+    }
+    missing = sorted(referenced_names - available_names)
+    if missing:
+        return None, f"name(s) not available in module: {', '.join(missing)}"
+
+    normalized = ast.unparse(expression)
+    try:
+        cst.parse_expression(normalized)
+    except cst.ParserSyntaxError:
+        return None, "cannot be represented by LibCST"
+    return normalized, None
+
+
+def _argument_defaults(
+    node: ast.FunctionDef | ast.AsyncFunctionDef,
+) -> dict[str, ast.expr]:
+    """Map parameter names to defaults present in the signature."""
+    positional = list(node.args.posonlyargs) + list(node.args.args)
+    defaults = {}
+    if node.args.defaults:
+        defaults.update(
+            {
+                argument.arg: default
+                for argument, default in zip(
+                    positional[-len(node.args.defaults):],
+                    node.args.defaults,
+                )
+            }
+        )
+    defaults.update(
+        {
+            argument.arg: default
+            for argument, default in zip(
+                node.args.kwonlyargs,
+                node.args.kw_defaults,
+            )
+            if default is not None
+        }
+    )
+    return defaults
+
+
+def _default_compatibility_reason(
+    annotation: str,
+    default: ast.expr | None,
+) -> str | None:
+    """Reject obvious contradictions between an annotation and a default."""
+    if default is None:
+        return None
+    expression = ast.parse(annotation, mode="eval").body
+    identifiers = {
+        node.id for node in ast.walk(expression) if isinstance(node, ast.Name)
+    }
+    identifiers.update(
+        node.attr for node in ast.walk(expression) if isinstance(node, ast.Attribute)
+    )
+    if identifiers & {"Any", "object"}:
+        return None
+
+    try:
+        value = ast.literal_eval(default)
+    except (ValueError, TypeError):
+        return None
+
+    if value is None:
+        permits_none = "Optional" in identifiers or any(
+            isinstance(node, ast.Constant) and node.value is None
+            for node in ast.walk(expression)
+        )
+        if not permits_none:
+            return "default is None but the documented type is not optional"
+        return None
+
+    if isinstance(value, bool):
+        compatible = {"bool"}
+    elif isinstance(value, int):
+        compatible = {"complex", "float", "int", "Integral", "Number", "Real"}
+    elif isinstance(value, float):
+        compatible = {"complex", "float", "Number", "Real"}
+    elif isinstance(value, str):
+        compatible = {"str"}
+    elif isinstance(value, bytes):
+        compatible = {"bytes"}
+    elif isinstance(value, list):
+        compatible = {
+            "Collection",
+            "Iterable",
+            "List",
+            "MutableSequence",
+            "Sequence",
+            "list",
+        }
+    elif isinstance(value, tuple):
+        compatible = {"Collection", "Iterable", "Sequence", "Tuple", "tuple"}
+    elif isinstance(value, dict):
+        compatible = {"Dict", "Mapping", "MutableMapping", "dict"}
+    elif isinstance(value, (set, frozenset)):
+        compatible = {
+            "AbstractSet",
+            "Collection",
+            "FrozenSet",
+            "Iterable",
+            "Set",
+            "frozenset",
+            "set",
+        }
+    else:
+        return None
+    if identifiers & compatible:
+        return None
+    return (
+        f"default value of type {type(value).__name__} conflicts with "
+        "the documented type"
+    )
+
+
+def _docstring_argument_types(
+    node: ast.FunctionDef | ast.AsyncFunctionDef,
+    lines: list[str],
+) -> dict[str, tuple[str, int]]:
+    """Extract explicit Google-style argument types and their source lines."""
+    dnode = docstrings.doc_node(node)
+    if dnode is None or dnode.end_lineno is None:
+        return {}
+    section = docstrings.find_args_section(
+        lines,
+        dnode.lineno - 1,
+        dnode.end_lineno - 1,
+    )
+    if section is None:
+        return {}
+
+    types = {}
+    for i in range(section[0] + 1, section[1] + 1):
+        content, _ = docstrings.line_without_ending(lines[i])
+        match = docstrings.ARG_ENTRY.match(content)
+        if match is None or match.group("type") is None:
+            continue
+        name = match.group("name").lstrip("*")
+        types[name] = (match.group("type").strip(), i + 1)
+    return types
+
+
+def _docstring_output_type(
+    node: ast.FunctionDef | ast.AsyncFunctionDef,
+    lines: list[str],
+) -> tuple[str, int] | None:
+    """Extract an explicit aggregate type from an existing Returns section."""
+    dnode = docstrings.doc_node(node)
+    if dnode is None or dnode.end_lineno is None:
+        return None
+    section = docstrings.find_section(
+        lines,
+        dnode.lineno - 1,
+        dnode.end_lineno - 1,
+        "Returns",
+    )
+    if section is None:
+        return None
+
+    header, _ = docstrings.line_without_ending(lines[section[0]])
+    header_indent = len(header) - len(header.lstrip())
+    for i in range(section[0] + 1, section[1] + 1):
+        content, _ = docstrings.line_without_ending(lines[i])
+        if not content.strip():
+            continue
+        indent = len(content) - len(content.lstrip())
+        if indent <= header_indent:
+            continue
+        match = docstrings.OUTPUT_ENTRY.match(content)
+        if match is None:
+            return None
+        candidate = match.group("type").strip()
+        if not docstrings.looks_like_type(candidate):
+            return None
+        return candidate, i + 1
+    return None
+
+
+def _collect_specs(
+    source: str,
+    path: Path,
+) -> tuple[dict[tuple[int, str], FunctionSpec], list[Skip]]:
+    """Collect validated docstring types for public functions and methods."""
+    tree = ast.parse(source, filename=str(path))
+    lines = source.splitlines(keepends=True)
+    specs = {}
+    skips = []
+
+    for node, function in docstrings.iter_public_functions(tree):
+        available_names = _module_names(tree, node.lineno)
+        if "." in function:
+            # A class is not bound to its module name until its body finishes.
+            available_names.discard(function.split(".", maxsplit=1)[0])
+        arguments = {}
+        rejected_arguments = {}
+        defaults = _argument_defaults(node)
+        for name, (text, line) in _docstring_argument_types(node, lines).items():
+            annotation, reason = _annotation_expression(text, available_names)
+            if annotation is not None:
+                reason = _default_compatibility_reason(
+                    annotation,
+                    defaults.get(name),
+                )
+                if reason is not None:
+                    annotation = None
+            if annotation is None:
+                rejection_reason = reason or "unsafe"
+                rejected_arguments[name] = (text, rejection_reason)
+                skips.append(
+                    Skip(path, line, function, name, text, rejection_reason)
+                )
+            else:
+                arguments[name] = annotation
+
+        return_type = "None" if node.name == "__init__" else None
+        output = _docstring_output_type(node, lines)
+        if output is not None and node.name != "__init__":
+            text, line = output
+            annotation, reason = _annotation_expression(text, available_names)
+            if annotation is None:
+                skips.append(
+                    Skip(path, line, function, "return", text, reason or "unsafe")
+                )
+            else:
+                return_type = annotation
+
+        specs[(node.lineno, node.name)] = FunctionSpec(
+            function=function,
+            line=node.lineno,
+            arguments=arguments,
+            rejected_arguments=rejected_arguments,
+            return_type=return_type,
+        )
+    return specs, skips
+
+
+def _annotation_code(annotation: cst.Annotation) -> str:
+    """Render one LibCST annotation expression without surrounding syntax."""
+    return cst.Module(body=[]).code_for_node(annotation.annotation)
+
+
+def _normalized_annotation(text: str) -> str:
+    """Normalize annotations for conflict comparison."""
+    try:
+        expression = ast.parse(text, mode="eval").body
+    except SyntaxError:
+        return re.sub(r"\s+", "", text)
+    if isinstance(expression, ast.Constant) and isinstance(expression.value, str):
+        try:
+            expression = ast.parse(expression.value, mode="eval").body
+        except SyntaxError:
+            return expression.value
+    return ast.dump(expression, include_attributes=False)
+
+
+class PublicAPIAnnotationTransformer(cst.CSTTransformer):
+    """Insert validated docstring types into matching public signatures."""
+
+    METADATA_DEPENDENCIES = (PositionProvider,)
+
+    def __init__(self, path: Path, specs: dict[tuple[int, str], FunctionSpec]):
+        self.path = path
+        self.specs = specs
+        self.updates: list[Update] = []
+        self.conflicts: list[Conflict] = []
+        self.unsafe_existing: list[UnsafeExistingAnnotation] = []
+
+    def _update_param(
+        self,
+        original: cst.Param,
+        updated: cst.Param,
+        spec: FunctionSpec,
+    ) -> cst.Param:
+        """Annotate one parameter or report a signature/docstring conflict."""
+        name = original.name.value
+        desired = spec.arguments.get(name)
+        line = self.get_metadata(PositionProvider, original.name).start.line
+        rejected = spec.rejected_arguments.get(name)
+        if desired is None:
+            if original.annotation is not None and rejected is not None:
+                existing = _annotation_code(original.annotation)
+                rejected_type, reason = rejected
+                if _normalized_annotation(existing) == _normalized_annotation(
+                    rejected_type
+                ):
+                    self.unsafe_existing.append(
+                        UnsafeExistingAnnotation(
+                            self.path,
+                            line,
+                            spec.function,
+                            name,
+                            existing,
+                            reason,
+                        )
+                    )
+            return updated
+        if original.annotation is not None:
+            existing = _annotation_code(original.annotation)
+            if _normalized_annotation(existing) != _normalized_annotation(desired):
+                self.conflicts.append(
+                    Conflict(
+                        self.path,
+                        line,
+                        spec.function,
+                        name,
+                        existing,
+                        desired,
+                    )
+                )
+            return updated
+
+        self.updates.append(Update(self.path, line, spec.function, name, desired))
+        changes = {"annotation": cst.Annotation(cst.parse_expression(desired))}
+        if updated.default is not None and isinstance(updated.equal, cst.AssignEqual):
+            changes["equal"] = updated.equal.with_changes(
+                whitespace_before=cst.SimpleWhitespace(" "),
+                whitespace_after=cst.SimpleWhitespace(" "),
+            )
+        return updated.with_changes(**changes)
+
+    def leave_FunctionDef(
+        self,
+        original_node: cst.FunctionDef,
+        updated_node: cst.FunctionDef,
+    ) -> cst.FunctionDef:
+        """Update an eligible function or method signature."""
+        line = self.get_metadata(PositionProvider, original_node.name).start.line
+        spec = self.specs.get((line, original_node.name.value))
+        if spec is None:
+            return updated_node
+
+        original_params = original_node.params
+        updated_params = updated_node.params
+        posonly_params = tuple(
+            self._update_param(original, updated, spec)
+            for original, updated in zip(
+                original_params.posonly_params,
+                updated_params.posonly_params,
+            )
+        )
+        params = tuple(
+            self._update_param(original, updated, spec)
+            for original, updated in zip(original_params.params, updated_params.params)
+        )
+        kwonly_params = tuple(
+            self._update_param(original, updated, spec)
+            for original, updated in zip(
+                original_params.kwonly_params,
+                updated_params.kwonly_params,
+            )
+        )
+        star_arg = updated_params.star_arg
+        if isinstance(original_params.star_arg, cst.Param) and isinstance(
+            updated_params.star_arg, cst.Param
+        ):
+            star_arg = self._update_param(
+                original_params.star_arg,
+                updated_params.star_arg,
+                spec,
+            )
+        star_kwarg = updated_params.star_kwarg
+        if original_params.star_kwarg is not None and star_kwarg is not None:
+            star_kwarg = self._update_param(
+                original_params.star_kwarg,
+                star_kwarg,
+                spec,
+            )
+
+        returns = updated_node.returns
+        if spec.return_type is not None:
+            if original_node.returns is None:
+                self.updates.append(
+                    Update(
+                        self.path,
+                        line,
+                        spec.function,
+                        "return",
+                        spec.return_type,
+                    )
+                )
+                returns = cst.Annotation(cst.parse_expression(spec.return_type))
+            else:
+                existing = _annotation_code(original_node.returns)
+                if _normalized_annotation(existing) != _normalized_annotation(
+                    spec.return_type
+                ):
+                    self.conflicts.append(
+                        Conflict(
+                            self.path,
+                            line,
+                            spec.function,
+                            "return",
+                            existing,
+                            spec.return_type,
+                        )
+                    )
+
+        return updated_node.with_changes(
+            params=updated_params.with_changes(
+                posonly_params=posonly_params,
+                params=params,
+                kwonly_params=kwonly_params,
+                star_arg=star_arg,
+                star_kwarg=star_kwarg,
+            ),
+            returns=returns,
+        )
+
+
+def transform_source(source: str, path: Path = Path("<memory>")) -> SourceResult:
+    """Annotate one source string without writing it."""
+    specs, skips = _collect_specs(source, path)
+    module = cst.parse_module(source)
+    transformer = PublicAPIAnnotationTransformer(path, specs)
+    transformed = MetadataWrapper(module).visit(transformer)
+    return SourceResult(
+        source=transformed.code,
+        updates=tuple(transformer.updates),
+        conflicts=tuple(transformer.conflicts),
+        skips=tuple(skips),
+        unsafe_existing=tuple(transformer.unsafe_existing),
+    )
+
+
+def update_file(path: Path, check: bool = False) -> FileResult:
+    """Annotate one Python file."""
+    source = path.read_text(encoding="utf-8")
+    result = transform_source(source, path=path)
+    changed = result.source != source
+    if changed and not check:
+        path.write_text(result.source, encoding="utf-8")
+    return FileResult(
+        path=path,
+        updates=result.updates,
+        conflicts=result.conflicts,
+        skips=result.skips,
+        unsafe_existing=result.unsafe_existing,
+        changed=changed,
+    )
+
+
+def _parse_args(argv: list[str]) -> argparse.Namespace:
+    """Parse command-line arguments."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "paths",
+        nargs="*",
+        help="Python files or directories to update. Defaults to qmcpy.",
+    )
+    parser.add_argument(
+        "--diff",
+        metavar="REF",
+        help="Use Python files reported by git diff REF.",
+    )
+    parser.add_argument(
+        "--root",
+        default="qmcpy",
+        help="Restrict files selected by --diff. Defaults to qmcpy.",
+    )
+    parser.add_argument(
+        "--check",
+        action="store_true",
+        help="Report annotations without writing files.",
+    )
+    parser.add_argument(
+        "--quiet",
+        action="store_true",
+        help="Only print the final summary.",
+    )
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str]) -> int:
+    """Run the command-line interface."""
+    args = _parse_args(argv)
+    try:
+        files = docstrings.python_files(args.paths, args.diff, root=args.root)
+    except subprocess.CalledProcessError as exc:
+        print(f"git diff failed: {exc}", file=sys.stderr)
+        return 2
+
+    if not files:
+        print("No Python files to inspect.")
+        return 0
+
+    results = []
+    had_parse_error = False
+    for path in files:
+        try:
+            results.append(update_file(path, check=args.check))
+        except (SyntaxError, cst.ParserSyntaxError) as exc:
+            had_parse_error = True
+            print(f"{path}: skipped syntax error: {exc}", file=sys.stderr)
+
+    updates = [update for result in results for update in result.updates]
+    conflicts = [conflict for result in results for conflict in result.conflicts]
+    skips = [skip for result in results for skip in result.skips]
+    unsafe_existing = [
+        issue for result in results for issue in result.unsafe_existing
+    ]
+    if not args.quiet:
+        action = "would annotate" if args.check else "annotated"
+        for update in updates:
+            print(
+                f"{update.path}:{update.line}: {action} "
+                f"{update.function}.{update.slot} as {update.annotation}"
+            )
+        for conflict in conflicts:
+            print(
+                f"{conflict.path}:{conflict.line}: conflict "
+                f"{conflict.function}.{conflict.slot}: signature "
+                f"`{conflict.signature_type}` != docstring "
+                f"`{conflict.docstring_type}`"
+            )
+        for skip in skips:
+            print(
+                f"{skip.path}:{skip.line}: skipped {skip.function}.{skip.slot} "
+                f"`{skip.docstring_type}`: {skip.reason}"
+            )
+        for issue in unsafe_existing:
+            print(
+                f"{issue.path}:{issue.line}: unsafe existing annotation "
+                f"{issue.function}.{issue.slot} `{issue.annotation}`: "
+                f"{issue.reason}"
+            )
+
+    changed_files = sum(result.changed for result in results)
+    verb = "would change" if args.check else "changed"
+    print(
+        f"{len(files)} file(s) inspected; {len(updates)} signature update(s); "
+        f"{len(conflicts)} conflict(s); {len(skips)} unsafe type(s) skipped; "
+        f"{len(unsafe_existing)} unsafe existing annotation(s); "
+        f"{changed_files} file(s) {verb}."
+    )
+
+    if had_parse_error:
+        return 2
+    if conflicts or unsafe_existing or (args.check and updates):
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))
diff --git a/test/test_sr_annotate_public_api_types.py b/test/test_sr_annotate_public_api_types.py
new file mode 100644
index 000000000..e3f12344e
--- /dev/null
+++ b/test/test_sr_annotate_public_api_types.py
@@ -0,0 +1,230 @@
+import shutil
+import tempfile
+import textwrap
+import unittest
+from contextlib import redirect_stdout
+from io import StringIO
+from pathlib import Path
+
+from scripts import annotate_public_api_types
+
+
+class TestAnnotatePublicAPITypes(unittest.TestCase):
+
+    def setUp(self):
+        self.tmp_path = Path(tempfile.mkdtemp())
+        self.addCleanup(shutil.rmtree, self.tmp_path, ignore_errors=True)
+
+    def _write(self, source):
+        path = self.tmp_path / "sample.py"
+        path.write_text(textwrap.dedent(source).lstrip(), encoding="utf-8")
+        return path
+
+    def test_annotates_public_method_inputs_and_output(self):
+        path = self._write(
+            '''
+            import numpy as np
+
+            class Model:
+
+                def evaluate(self, x, scale=1.0):
+                    """Evaluate the model.
+
+                    Args:
+                        x (np.ndarray): Evaluation points.
+                        scale (float): Output scale.
+
+                    Returns:
+                        np.ndarray: Scaled values.
+                    """
+                    return scale * x
+            '''
+        )
+
+        result = annotate_public_api_types.update_file(path)
+        source = path.read_text(encoding="utf-8")
+
+        self.assertTrue(result.changed)
+        self.assertEqual(len(result.updates), 3)
+        self.assertIn(
+            "def evaluate(self, x: np.ndarray, scale: float = 1.0) -> np.ndarray:",
+            source,
+        )
+
+    def test_annotates_constructor_and_adds_none_return(self):
+        path = self._write(
+            '''
+            class Body:
+
+                def __init__(self, mass):
+                    """Initialize a body.
+
+                    Args:
+                        mass (float): Body mass.
+                    """
+                    self.mass = mass
+            '''
+        )
+
+        annotate_public_api_types.update_file(path)
+
+        self.assertIn(
+            "def __init__(self, mass: float) -> None:",
+            path.read_text(encoding="utf-8"),
+        )
+
+    def test_annotates_decorated_public_method(self):
+        path = self._write(
+            '''
+            class Model:
+
+                @staticmethod
+                def normalize(x):
+                    """Normalize a value.
+
+                    Args:
+                        x (float): Value to normalize.
+
+                    Returns:
+                        float: Normalized value.
+                    """
+                    return x
+            '''
+        )
+
+        result = annotate_public_api_types.update_file(path)
+
+        self.assertTrue(result.changed)
+        self.assertIn(
+            "def normalize(x: float) -> float:",
+            path.read_text(encoding="utf-8"),
+        )
+
+    def test_preserves_existing_annotation_and_reports_conflict(self):
+        path = self._write(
+            '''
+            def scale(x: int) -> float:
+                """Scale a value.
+
+                Args:
+                    x (float): Value to scale.
+
+                Returns:
+                    float: Scaled value.
+                """
+                return float(x)
+            '''
+        )
+        original = path.read_text(encoding="utf-8")
+
+        result = annotate_public_api_types.update_file(path)
+
+        self.assertFalse(result.changed)
+        self.assertEqual(len(result.conflicts), 1)
+        self.assertEqual(result.conflicts[0].slot, "x")
+        self.assertEqual(path.read_text(encoding="utf-8"), original)
+
+    def test_skips_type_whose_name_is_not_available(self):
+        path = self._write(
+            '''
+            def evaluate(x):
+                """Evaluate points.
+
+                Args:
+                    x (ArrayLike): Evaluation points.
+                """
+                return x
+            '''
+        )
+        original = path.read_text(encoding="utf-8")
+
+        result = annotate_public_api_types.update_file(path)
+
+        self.assertFalse(result.changed)
+        self.assertEqual(len(result.skips), 1)
+        self.assertIn("not available", result.skips[0].reason)
+        self.assertEqual(path.read_text(encoding="utf-8"), original)
+
+    def test_skips_types_that_contradict_literal_defaults(self):
+        path = self._write(
+            '''
+            import numpy as np
+
+            def evaluate(x=None, tolerance=0.5):
+                """Evaluate points.
+
+                Args:
+                    x (np.ndarray): Evaluation points.
+                    tolerance (np.ndarray): Error tolerance.
+                """
+                return x
+            '''
+        )
+        original = path.read_text(encoding="utf-8")
+
+        result = annotate_public_api_types.update_file(path)
+
+        self.assertFalse(result.changed)
+        self.assertEqual(len(result.skips), 2)
+        self.assertTrue(any("not optional" in skip.reason for skip in result.skips))
+        self.assertTrue(any("conflicts" in skip.reason for skip in result.skips))
+        self.assertEqual(path.read_text(encoding="utf-8"), original)
+
+    def test_ignores_private_and_nested_functions(self):
+        path = self._write(
+            '''
+            def _private(x):
+                """Private helper.
+
+                Args:
+                    x (int): Value.
+                """
+                return x
+
+            def public():
+                """Return a nested callable."""
+
+                def nested(x):
+                    """Nested helper.
+
+                    Args:
+                        x (int): Value.
+                    """
+                    return x
+
+                return nested
+            '''
+        )
+
+        result = annotate_public_api_types.update_file(path)
+
+        self.assertFalse(result.changed)
+        self.assertEqual(result.updates, ())
+
+    def test_check_mode_reports_without_writing(self):
+        path = self._write(
+            '''
+            def scale(x):
+                """Scale a value.
+
+                Args:
+                    x (float): Value to scale.
+                """
+                return 2 * x
+            '''
+        )
+        original = path.read_text(encoding="utf-8")
+        output = StringIO()
+
+        with redirect_stdout(output):
+            status = annotate_public_api_types.main(
+                ["--check", "--root", str(self.tmp_path), str(path)]
+            )
+
+        self.assertEqual(status, 1)
+        self.assertIn("1 file(s) would change", output.getvalue())
+        self.assertEqual(path.read_text(encoding="utf-8"), original)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/test/test_sr_docstring_arg_types.py b/test/test_sr_docstring_arg_types.py
index a006cb35c..ddc1a7dbe 100644
--- a/test/test_sr_docstring_arg_types.py
+++ b/test/test_sr_docstring_arg_types.py
@@ -61,11 +61,14 @@ def calculate_velocity(
     def test_check_mode_reports_without_writing(self):
         path = self._write(
             '''
-            def scale(x: int):
+            def scale(x: int) -> int:
                 """Scale x.
 
                 Args:
                     x: Value to scale.
+
+                Returns:
+                    Scaled value.
                 """
                 return 2 * x
             '''
@@ -74,10 +77,13 @@ def scale(x: int):
 
         output = StringIO()
         with redirect_stdout(output):
-            status = add_docstring_arg_types.main(["--check", str(path)])
+            status = add_docstring_arg_types.main(
+                ["--check", "--include-outputs", str(path)]
+            )
 
         self.assertEqual(status, 1)
         self.assertIn("1 file(s) would change", output.getvalue())
+        self.assertIn("1 output type update(s)", output.getvalue())
         self.assertEqual(path.read_text(encoding="utf-8"), original)
 
     def test_preserves_existing_type_unless_overwrite_is_requested(self):
@@ -165,6 +171,83 @@ def scale(x):
         self.assertEqual(result.updates, [])
         self.assertEqual(path.read_text(encoding="utf-8"), original)
 
+    def test_adds_return_type_when_output_sync_is_requested(self):
+        path = self._write(
+            '''
+            def norm(x: float) -> float:
+                """Compute a norm.
+
+                Args:
+                    x: Input value.
+
+                Returns:
+                    Computed norm.
+                """
+                return abs(x)
+            '''
+        )
+
+        result = add_docstring_arg_types.update_file(path, include_outputs=True)
+        source = path.read_text(encoding="utf-8")
+
+        self.assertTrue(result.changed)
+        self.assertIn("x (float): Input value.", source)
+        self.assertIn("float: Computed norm.", source)
+        self.assertEqual(
+            [update.section for update in result.updates],
+            ["Args", "Returns"],
+        )
+
+    def test_replaces_existing_output_type_only_when_requested(self):
+        path = self._write(
+            '''
+            def norm(x) -> float:
+                """Compute a norm.
+
+                Returns:
+                    int: Computed norm.
+                """
+                return abs(x)
+            '''
+        )
+
+        result = add_docstring_arg_types.update_file(path, include_outputs=True)
+        self.assertFalse(result.changed)
+        self.assertIn("int: Computed norm.", path.read_text(encoding="utf-8"))
+
+        result = add_docstring_arg_types.update_file(
+            path,
+            include_outputs=True,
+            overwrite_existing=True,
+        )
+        self.assertTrue(result.changed)
+        self.assertIn("float: Computed norm.", path.read_text(encoding="utf-8"))
+
+    def test_extracts_item_type_for_yields_section(self):
+        path = self._write(
+            '''
+            from typing import Iterator
+
+            def indices(n: int) -> Iterator[int]:
+                """Yield indices.
+
+                Args:
+                    n: Number of indices.
+
+                Yields:
+                    Next index.
+                """
+                yield from range(n)
+            '''
+        )
+
+        result = add_docstring_arg_types.update_file(path, include_outputs=True)
+        source = path.read_text(encoding="utf-8")
+
+        self.assertTrue(result.changed)
+        self.assertIn("n (int): Number of indices.", source)
+        self.assertIn("int: Next index.", source)
+
 
 if __name__ == "__main__":
     unittest.main()

From b6eae55f34f9fe2580b6368327dd9a83d008a85c Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Mon, 7 Sep 2026 11:43:31 +0800
Subject: [PATCH 21/51] Restore return types

---
 makefile                                               |  2 ++
 mkdocs.yml                                             |  1 +
 .../abstract_discrete_distribution.py                  |  4 ++--
 .../digital_net_b2/digital_net_b2.py                   |  4 ++--
 qmcpy/discrete_distribution/iid_std_uniform.py         |  4 ++--
 qmcpy/discrete_distribution/kronecker.py               |  4 ++--
 qmcpy/discrete_distribution/lattice/lattice.py         |  4 ++--
 qmcpy/discrete_distribution/mpmc/mpmc.py               |  2 +-
 qmcpy/fast_transform/ft.py                             | 10 +++++-----
 qmcpy/fast_transform/ft_pytorch.py                     | 10 +++++-----
 qmcpy/fast_transform/ft_qmctoolscl.py                  |  6 +++---
 qmcpy/integrand/abstract_integrand.py                  |  8 ++++----
 qmcpy/integrand/financial_option.py                    |  4 ++--
 qmcpy/integrand/keister.py                             |  2 +-
 qmcpy/kernel/abstract_kernel.py                        |  6 +++---
 qmcpy/kernel/multitask_kernel.py                       |  4 ++--
 qmcpy/true_measure/abstract_true_measure.py            |  2 +-
 qmcpy/true_measure/acceptance_rejection.py             |  4 ++--
 qmcpy/util/abstraction_functions.py                    |  2 +-
 qmcpy/util/dig_shift_invar_ops.py                      |  2 +-
 qmcpy/util/shift_invar_ops.py                          |  2 +-
 21 files changed, 45 insertions(+), 42 deletions(-)

diff --git a/makefile b/makefile
index 6789747e2..5d2410e2f 100644
--- a/makefile
+++ b/makefile
@@ -547,6 +547,8 @@ copydocs:  # mkdocs only looks for content in the docs/ folder, so we have to co
 	@# Rewrite repo-root-relative link for the copied MkDocs page.
 	@perl -0pi -e 's!\(docs/good_practices\.md\)!\(good_practices.md\)!g' docs/CONTRIBUTING.md
 	@perl -0pi -e 's!\(docs/ai-assisted-contributions\.md\)!\(ai-assisted-contributions.md\)!g' docs/CONTRIBUTING.md
+	@perl -0pi -e 's!\(docs/tests\.md\)!\(tests.md\)!g' docs/CONTRIBUTING.md
+	@perl -0pi -e 's!\(test/README\.md(#[^)]*)?\)!\(tests.md$$1\)!g' docs/CONTRIBUTING.md
 	@cp community.md docs/community.md
 	@cp -r demos docs
 	@find docs/demos -mindepth 2 -name README.md -delete
diff --git a/mkdocs.yml b/mkdocs.yml
index 792731c47..af391e1d6 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -131,6 +131,7 @@ plugins:
             docstring_style: google
             docstring_options:
               ignore_init_summary: false
+              returns_named_value: false  # idiomatic Google style: `Type: description`, no invented name
             merge_init_into_class: true
   - glightbox:
       touchNavigation: true
diff --git a/qmcpy/discrete_distribution/abstract_discrete_distribution.py b/qmcpy/discrete_distribution/abstract_discrete_distribution.py
index 4443087ec..d59d57c95 100644
--- a/qmcpy/discrete_distribution/abstract_discrete_distribution.py
+++ b/qmcpy/discrete_distribution/abstract_discrete_distribution.py
@@ -68,7 +68,7 @@ def __call__(self, n=None, n_min=None, n_max=None, return_binary=False, warn=Tru
             warn (bool): If `False`, disable warnings when generating samples.
 
         Returns:
-            Samples from the sequence.
+            np.ndarray: Samples from the sequence.
 
             - If `replications` is `None` then this will be of size (`n_max`-`n_min`) $\times$ `dimension`
             - If `replications` is a positive int, then `x` will be of size `replications` $\times$ (`n_max`-`n_min`) $\times$ `dimension`
@@ -139,7 +139,7 @@ def spawn(self, s: int = 1, dimensions: np.ndarray = None):
                 copy. Defaults to the current dimension.
 
         Returns:
-            Discrete distributions with new seeds and dimensions.
+            list: Discrete distributions with new seeds and dimensions.
         """
         s = int(s)
         if s <= 0:
diff --git a/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py b/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
index bc3952e71..162f7006f 100644
--- a/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
+++ b/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
@@ -239,8 +239,8 @@ def __init__(
 
             replications (int): Number of independent randomizations of a
                 pointset.
-            seed (Union[None, int, np.random.SeedSeq): Seed the random number
-            generator for reproducibility.
+            seed (Union[None, int, np.random.SeedSequence]): Seed the random
+                number generator for reproducibility.
             randomize (str): Options are
 
                 - `'LMS DS'`: Linear matrix scramble with digital shift.
diff --git a/qmcpy/discrete_distribution/iid_std_uniform.py b/qmcpy/discrete_distribution/iid_std_uniform.py
index 4e6c694ca..c83e10fa5 100644
--- a/qmcpy/discrete_distribution/iid_std_uniform.py
+++ b/qmcpy/discrete_distribution/iid_std_uniform.py
@@ -56,8 +56,8 @@ def __init__(self, dimension: int = 1, replications=None, seed=None) -> None:
             replications (Union[None, int]): Number of randomizations. This is
                 implemented only for API consistency. Equivalent to reshaping
                 samples.
-            seed (Union[None, int, np.random.SeedSeq): Seed the random number
-            generator for reproducibility.
+            seed (Union[None, int, np.random.SeedSequence]): Seed the random
+                number generator for reproducibility.
         """
         super(IIDStdUniform, self).__init__(
             int(dimension), replications, seed, d_limit=np.inf, n_limit=np.inf
diff --git a/qmcpy/discrete_distribution/kronecker.py b/qmcpy/discrete_distribution/kronecker.py
index 504ed0415..4be207d4c 100644
--- a/qmcpy/discrete_distribution/kronecker.py
+++ b/qmcpy/discrete_distribution/kronecker.py
@@ -234,8 +234,8 @@ def __init__(self,
                 - If an `np.ndarray` is passed in, use generating vector components at these indices.
 
             replications (int): Number of independent randomizations.
-            seed (Union[None, int, np.random.SeedSeq): Seed the random number
-            generator for reproducibility.
+            seed (Union[None, int, np.random.SeedSequence]): Seed the random
+                number generator for reproducibility.
             randomize (str): Options are
 
                 - `'SHIFT'`: use `shift` if supplied, otherwise use a random shift $\boldsymbol{\delta} \sim \mathrm{Uniform}([0,1)^d)$.
diff --git a/qmcpy/discrete_distribution/lattice/lattice.py b/qmcpy/discrete_distribution/lattice/lattice.py
index d7c5f808e..8be3600c6 100644
--- a/qmcpy/discrete_distribution/lattice/lattice.py
+++ b/qmcpy/discrete_distribution/lattice/lattice.py
@@ -156,8 +156,8 @@ def __init__(
                 - If an `np.ndarray` is passed in, use generating vector components at these indices.
 
             replications (int): Number of independent randomizations.
-            seed (Union[None, int, np.random.SeedSeq): Seed the random number
-            generator for reproducibility.
+            seed (Union[None, int, np.random.SeedSequence]): Seed the random
+                number generator for reproducibility.
             randomize (str): Options are
 
                 - `'SHIFT'`: Random shift.
diff --git a/qmcpy/discrete_distribution/mpmc/mpmc.py b/qmcpy/discrete_distribution/mpmc/mpmc.py
index a77636307..99b173fb4 100644
--- a/qmcpy/discrete_distribution/mpmc/mpmc.py
+++ b/qmcpy/discrete_distribution/mpmc/mpmc.py
@@ -300,7 +300,7 @@ def _spawn(self, child_seed, dimension):
     def _train(self, args: SimpleNamespace):
         """
         Returns:
-            shape `(nbatch, nsamples, dim)`
+            np.ndarray: shape `(nbatch, nsamples, dim)`
         """
         model = MPMC_net(
             dim=args.dim, nhid=args.nhid, nlayers=args.nlayers,
diff --git a/qmcpy/fast_transform/ft.py b/qmcpy/fast_transform/ft.py
index 727d1844e..56b54a2e6 100644
--- a/qmcpy/fast_transform/ft.py
+++ b/qmcpy/fast_transform/ft.py
@@ -23,7 +23,7 @@ def fftbr(x: np.ndarray):
         x (np.ndarray): Array of samples at which to run BRO-FFT.
 
     Returns:
-        BRO-FFT values.
+        np.ndarray: BRO-FFT values.
     """
     n = x.shape[-1]
     if not (n & (n - 1) == 0):  # require n is a power of 2
@@ -61,7 +61,7 @@ def ifftbr(x: np.ndarray):
         x (np.ndarray): Array of samples at which to run BRO-IFFT.
 
     Returns:
-        BRO-IFFT values.
+        np.ndarray: BRO-IFFT values.
     """
     n = x.shape[-1]
     if not (n & (n - 1) == 0):  # require n is a power of 2
@@ -94,7 +94,7 @@ def fwht(x: np.ndarray):
         x (np.ndarray): Array of samples at which to run FWHT.
 
     Returns:
-        FWHT values.
+        np.ndarray: FWHT values.
     """
     y = x.copy() + 0.0
     n = x.shape[-1]
@@ -138,7 +138,7 @@ def omega_fwht(m: int):
         m (int): Size $2^m$ output.
 
     Returns:
-        $\left(1\right)_{k=0}^{2^m}$.
+        np.ndarray: $\left(1\right)_{k=0}^{2^m}$.
     """
     return np.ones(2**m)
 
@@ -165,6 +165,6 @@ def omega_fftbr(m: int):
         m (int): Size $2^m$ output.
 
     Returns:
-        $\left(e^{- \pi \mathrm{i} k / 2^m}\right)_{k=0}^{2^m}$.
+        np.ndarray: $\left(e^{- \pi \mathrm{i} k / 2^m}\right)_{k=0}^{2^m}$.
     """
     return np.exp(-np.pi * 1j * np.arange(2**m) / 2**m)
diff --git a/qmcpy/fast_transform/ft_pytorch.py b/qmcpy/fast_transform/ft_pytorch.py
index 721603e56..d937ee53c 100644
--- a/qmcpy/fast_transform/ft_pytorch.py
+++ b/qmcpy/fast_transform/ft_pytorch.py
@@ -37,7 +37,7 @@ def fftbr_torch(x: torch.Tensor):
         x (torch.Tensor): Array of samples at which to run BRO-FFT.
 
     Returns:
-        BRO-FFT values.
+        torch.Tensor: BRO-FFT values.
     """
     n = x.size(-1)
     if not (n & (n - 1) == 0):  # require n is a power of 2
@@ -89,7 +89,7 @@ def ifftbr_torch(x: torch.Tensor):
         x (torch.Tensor): Array of samples at which to run BRO-IFFT.
 
     Returns:
-        BRO-IFFT values.
+        torch.Tensor: BRO-IFFT values.
     """
     n = x.size(-1)
     if not (n & (n - 1) == 0):  # require n is a power of 2
@@ -168,7 +168,7 @@ def fwht_torch(x: torch.Tensor):
         x (torch.Tensor): Array of samples at which to run FWHT.
 
     Returns:
-        FWHT values.
+        torch.Tensor: FWHT values.
     """
     return _FWHTB2Ortho.apply(x)
 
@@ -195,7 +195,7 @@ def omega_fwht_torch(m: int, device=None):
         m (int): Size $2^m$ output.
 
     Returns:
-        $\left(1\right)_{k=0}^{2^m}$.
+        np.ndarray: $\left(1\right)_{k=0}^{2^m}$.
     """
     if device is None:
         device = "cpu"
@@ -224,7 +224,7 @@ def omega_fftbr_torch(m: int, device=None):
         m (int): Size $2^m$ output.
 
     Returns:
-        $\left(e^{- \pi \mathrm{i} k / 2^m}\right)_{k=0}^{2^m}$.
+        np.ndarray: $\left(e^{- \pi \mathrm{i} k / 2^m}\right)_{k=0}^{2^m}$.
     """
     if device is None:
         device = "cpu"
diff --git a/qmcpy/fast_transform/ft_qmctoolscl.py b/qmcpy/fast_transform/ft_qmctoolscl.py
index dae6ae5e5..841e7b4e7 100644
--- a/qmcpy/fast_transform/ft_qmctoolscl.py
+++ b/qmcpy/fast_transform/ft_qmctoolscl.py
@@ -41,7 +41,7 @@ def fftbr_qmctoolscl(x: np.ndarray):
         x (np.ndarray): Array of samples at which to run BRO-FFT.
 
     Returns:
-        BRO-FFT values.
+        np.ndarray: BRO-FFT values.
     """
     x, shape, d, n, n_half = _parse_ft_input(x)
     if n <= 1:
@@ -76,7 +76,7 @@ def ifftbr_qmctoolscl(x: np.ndarray):
         x (np.ndarray): Array of samples at which to run BRO-IFFT.
 
     Returns:
-        BRO-IFFT values.
+        np.ndarray: BRO-IFFT values.
     """
     x, shape, d, n, n_half = _parse_ft_input(x)
     if n <= 1:
@@ -107,7 +107,7 @@ def fwht_qmctoolscl(x: np.ndarray):
         x (np.ndarray): Array of samples at which to run FWHT.
 
     Returns:
-        FWHT values.
+        np.ndarray: FWHT values.
     """
     x, shape, d, n, n_half = _parse_ft_input(x)
     if n <= 1:
diff --git a/qmcpy/integrand/abstract_integrand.py b/qmcpy/integrand/abstract_integrand.py
index b82d7fe45..f1daf6a6a 100644
--- a/qmcpy/integrand/abstract_integrand.py
+++ b/qmcpy/integrand/abstract_integrand.py
@@ -94,7 +94,7 @@ def __call__(self, n=None, n_min=None, n_max=None, warn=True):
             warn (bool): If `False`, disable warnings when generating samples.
 
         Returns:
-            Samples from the sequence.
+            np.ndarray: Samples from the sequence.
 
                 - If `replications` is `None` then this will be of size (`n_max`-`n_min`) $\times$ `dimension`
                 - If `replications` is a positive int, then `t` will be of size `replications` $\times$ (`n_max`-`n_min`) $\times$ `dimension`
@@ -320,7 +320,7 @@ def bound_fun(self, bound_low: np.ndarray, bound_high: np.ndarray):
                 shape `integrand.d_indv`.
 
         Returns:
-            Lower bounds on combined estimates with shape `integrand.d_comb`.
+            np.ndarray: Lower bounds on combined estimates with shape `integrand.d_comb`.
             comb_bound_high (np.ndarray): Upper bounds on combined estimates
             with shape `integrand.d_comb`.
         """
@@ -374,7 +374,7 @@ def spawn(self, levels: np.ndarray):
             levels (np.ndarray): Levels at which to spawn new integrands.
 
         Returns:
-            Integrands with new true measures and discrete distributions.
+            list: Integrands with new true measures and discrete distributions.
         """
         levels = np.array([levels]) if np.isscalar(levels) else np.array(levels)
         if (levels > self.max_level).any():
@@ -398,7 +398,7 @@ def dimension_at_level(self, level: int):
             level (int): Level at which to return the dimension.
 
         Returns:
-            Dimension at the given input level.
+            int: Dimension at the given input level.
         """
         return self.d
 
diff --git a/qmcpy/integrand/financial_option.py b/qmcpy/integrand/financial_option.py
index badc9e053..9cefa5001 100644
--- a/qmcpy/integrand/financial_option.py
+++ b/qmcpy/integrand/financial_option.py
@@ -605,7 +605,7 @@ def get_exact_value(self):
         - `option='ASIAN'` with `asian_mean='GEOMETRIC'` and `asian_mean_quadrature_rule='RIGHT'`
 
         Returns:
-            Exact value of the integral.
+            float: Exact value of the integral.
         """
         if self.option == "EUROPEAN":
             denom = self.volatility * np.sqrt(self.t_final)
@@ -664,7 +664,7 @@ def get_exact_value_inf_dim(self):
         - `option='ASIAN'` with `asian_mean='GEOMETRIC'`
 
         Returns:
-            Exact value of the integral.
+            float: Exact value of the integral.
         """
         if self.option == "ASIAN":
             if not (
diff --git a/qmcpy/integrand/keister.py b/qmcpy/integrand/keister.py
index 497a4a7d3..564d48411 100644
--- a/qmcpy/integrand/keister.py
+++ b/qmcpy/integrand/keister.py
@@ -77,7 +77,7 @@ def get_exact_value(self, d: int):
             d (int): Dimension.
 
         Returns:
-            Exact value of the integral.
+            float: Exact value of the integral.
         """
         cosinteg = np.zeros(shape=(d))
         cosinteg[0] = np.sqrt(np.pi) / (2 * np.exp(1 / 4))
diff --git a/qmcpy/kernel/abstract_kernel.py b/qmcpy/kernel/abstract_kernel.py
index 91b28d2f9..5859558cc 100644
--- a/qmcpy/kernel/abstract_kernel.py
+++ b/qmcpy/kernel/abstract_kernel.py
@@ -102,7 +102,7 @@ def __call__(self, x0, x1, beta0=None, beta1=None, c=None, **kwargs):
                 coefficients of derivatives.
             kwargs (dict): keyword arguments to parsed call
         Returns:
-            Shape `y.shape=(x0+x1).shape[:-1]` kernel evaluations.
+            Union[np.ndarray, torch.Tensor]: Shape `y.shape=(x0+x1).shape[:-1]` kernel evaluations.
         """
         if not (isinstance(x0, self.nptarraytype)):
             raise AssertionError
@@ -285,7 +285,7 @@ def single_integral_01d(self, x):
                 input to kernel with
 
         Returns:
-            Shape `y.shape=x.shape[:-1]` integral kernel evaluations.
+            Union[np.ndarray, torch.Tensor]: Shape `y.shape=x.shape[:-1]` integral kernel evaluations.
         """
         if self.npt == np:
             if not (isinstance(x, np.ndarray)):
@@ -314,7 +314,7 @@ def double_integral_01d(self):
         \mathrm{d} \boldsymbol{z}.$$
 
         Returns:
-            Double integral kernel evaluations.
+            Union[np.ndarray, torch.Tensor]: Double integral kernel evaluations.
         """
         raise MethodImplementationError(self, "double_integral_01d")
 
diff --git a/qmcpy/kernel/multitask_kernel.py b/qmcpy/kernel/multitask_kernel.py
index 3487538c5..7abaa5ede 100644
--- a/qmcpy/kernel/multitask_kernel.py
+++ b/qmcpy/kernel/multitask_kernel.py
@@ -525,7 +525,7 @@ def single_integral_01d(self, task0, task1, x):
                 input to kernel with
 
         Returns:
-            Shape `y.shape=x.shape[:-1]` integral kernel evaluations.
+            Union[np.ndarray, torch.Tensor]: Shape `y.shape=x.shape[:-1]` integral kernel evaluations.
         """
         kint_x = self.base_kernel.single_integral_01d(x)
         return self._parsed__call__(task0, task1, kint_x)
@@ -544,7 +544,7 @@ def double_integral_01d(self, task0, task1):
                 $i_1$.
 
         Returns:
-            Double integral kernel evaluations.
+            Union[np.ndarray, torch.Tensor]: Double integral kernel evaluations.
         """
         kint_x = self.base_kernel.double_integral_01d()
         return self._parsed__call__(task0, task1, kint_x)
diff --git a/qmcpy/true_measure/abstract_true_measure.py b/qmcpy/true_measure/abstract_true_measure.py
index d2be6b1ee..406889ed3 100644
--- a/qmcpy/true_measure/abstract_true_measure.py
+++ b/qmcpy/true_measure/abstract_true_measure.py
@@ -129,7 +129,7 @@ def __call__(self, n=None, n_min=None, n_max=None, return_weights=False, warn=Tr
             warn (bool): If `False`, disable warnings when generating samples.
 
         Returns:
-            Samples from the sequence.
+            np.ndarray: Samples from the sequence.
 
                 - If `replications` is `None` then this will be of size (`n_max`-`n_min`) $\times$ `dimension`
                 - If `replications` is a positive int, then `t` will be of size `replications` $\times$ (`n_max`-`n_min`) $\times$ `dimension`
diff --git a/qmcpy/true_measure/acceptance_rejection.py b/qmcpy/true_measure/acceptance_rejection.py
index 3ee00d929..c5a0913a1 100644
--- a/qmcpy/true_measure/acceptance_rejection.py
+++ b/qmcpy/true_measure/acceptance_rejection.py
@@ -130,7 +130,7 @@ def gen_samples(self, n: int = None, n_min: int = None, n_max: int = None, retur
                 after all retries.
 
         Returns:
-            Shape (n, target_dim).
+            np.ndarray: Shape (n, target_dim).
             weights (np.ndarray): Shape (n,). Only returned when
                 return_weights=True.
         """
@@ -346,7 +346,7 @@ def gen_samples(self, n: int = None, n_min: int = None, n_max: int = None, retur
                 after all retries.
 
         Returns:
-            Shape (n, target_dim).
+            np.ndarray: Shape (n, target_dim).
             weights (np.ndarray): Shape (n,). Only returned when
                 return_weights=True.
         """
diff --git a/qmcpy/util/abstraction_functions.py b/qmcpy/util/abstraction_functions.py
index 4f82ef9c3..44ff3eccd 100644
--- a/qmcpy/util/abstraction_functions.py
+++ b/qmcpy/util/abstraction_functions.py
@@ -11,7 +11,7 @@ def _univ_repr(qmc_object, abc_class_name, attributes):
         attributes (list): list of attributes to include
 
     Returns:
-        string representation of this qmcpy object
+        str: string representation of this qmcpy object
 
     Notes:
         print(qmc_object) is equivalent to print(qmc_object.__repr__()). See an
diff --git a/qmcpy/util/dig_shift_invar_ops.py b/qmcpy/util/dig_shift_invar_ops.py
index 06733efcc..f4b6f990b 100644
--- a/qmcpy/util/dig_shift_invar_ops.py
+++ b/qmcpy/util/dig_shift_invar_ops.py
@@ -34,7 +34,7 @@ def k4sumterm(x, t: int, cutoff=1e-8):
         t (int): Number of bits in each integer.
 
     Returns:
-        The $K_4$ sum term.
+        Union[np.ndarray, torch.Tensor]: The $K_4$ sum term.
     """
     total = 0.0
     for a in range(0, t):
diff --git a/qmcpy/util/shift_invar_ops.py b/qmcpy/util/shift_invar_ops.py
index 40059e230..c9f87a6c6 100644
--- a/qmcpy/util/shift_invar_ops.py
+++ b/qmcpy/util/shift_invar_ops.py
@@ -108,7 +108,7 @@ def bernoulli_poly(n: int, x):
             Bernoulli polynomial.
 
     Returns:
-        Bernoulli polynomial values.
+        Union[np.ndarray, torch.Tensor]: Bernoulli polynomial values.
     """
     if not (isinstance(n, int)):
         raise AssertionError

From ac76efc89f2cb869044925de233be76db4245c43 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Mon, 7 Sep 2026 11:57:36 +0800
Subject: [PATCH 22/51] Change names

---
 ..._mpmc_optional_imports.py => test_dd_mpmc_optional_imports.py} | 0
 test/{test_sr_install_mpmc_pyg.py => test_ut_install_mpmc_pyg.py} | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename test/{test_sr_mpmc_optional_imports.py => test_dd_mpmc_optional_imports.py} (100%)
 rename test/{test_sr_install_mpmc_pyg.py => test_ut_install_mpmc_pyg.py} (100%)

diff --git a/test/test_sr_mpmc_optional_imports.py b/test/test_dd_mpmc_optional_imports.py
similarity index 100%
rename from test/test_sr_mpmc_optional_imports.py
rename to test/test_dd_mpmc_optional_imports.py
diff --git a/test/test_sr_install_mpmc_pyg.py b/test/test_ut_install_mpmc_pyg.py
similarity index 100%
rename from test/test_sr_install_mpmc_pyg.py
rename to test/test_ut_install_mpmc_pyg.py

From 7cb819d5dcd69bd8df25e32fdf983ea0df11f34e Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Mon, 7 Sep 2026 12:32:23 +0800
Subject: [PATCH 23/51] Restore return types

---
 makefile                                               | 10 ++++++----
 qmcpy/integrand/abstract_integrand.py                  |  6 +++---
 qmcpy/integrand/umbridge_wrapper.py                    |  2 +-
 qmcpy/kernel/multitask_kernel.py                       |  2 +-
 qmcpy/stopping_criterion/abstract_cub_mlmc.py          |  2 +-
 .../stopping_criterion/abstract_stopping_criterion.py  | 10 +++++-----
 qmcpy/stopping_criterion/diagnostics.py                |  4 ++--
 qmcpy/true_measure/abstract_true_measure.py            |  4 ++--
 qmcpy/true_measure/kumaraswamy.py                      |  2 +-
 qmcpy/true_measure/zero_inflated_exp_uniform.py        |  2 +-
 qmcpy/util/data.py                                     |  4 ++--
 qmcpy/util/dig_shift_invar_ops.py                      |  8 ++++----
 qmcpy/util/latnetbuilder_linker.py                     |  2 +-
 scripts/check_test_style.py                            |  2 +-
 14 files changed, 31 insertions(+), 29 deletions(-)

diff --git a/makefile b/makefile
index 5d2410e2f..b511542a3 100644
--- a/makefile
+++ b/makefile
@@ -637,13 +637,15 @@ MARKDOWN_UNWRAP_PATH ?= $(FORMAT_PATH)
 
 format:
 	$(MAKE) flatten_qmcpy_imports
-	@echo ""
+	@echo "---"
 	$(MAKE) markdown-unwrap MARKDOWN_UNWRAP_PATH="$(MARKDOWN_UNWRAP_PATH)"
-	@echo ""
+	@echo "---"
 	$(MAKE) rm_trailing_whitespace FORMAT_PATH="$(FORMAT_PATH)"
-	@echo ""
+	@echo "---"
 	$(MAKE) harden_colab_notebook
-	@echo ""
+	@echo "---"
+	$(MAKE) check_test_style
+	@echo "---"
 	$(MAKE) check_docstring_changed
 
 flatten_qmcpy_imports:
diff --git a/qmcpy/integrand/abstract_integrand.py b/qmcpy/integrand/abstract_integrand.py
index f1daf6a6a..6c4ad76f0 100644
--- a/qmcpy/integrand/abstract_integrand.py
+++ b/qmcpy/integrand/abstract_integrand.py
@@ -130,7 +130,7 @@ def g(self, t: np.ndarray, *args: tuple, **kwargs: dict):
                 computation.
 
         Returns:
-            function evaluations with shape `(*batch_shape, *dimension_indv)`
+            np.ndarray: function evaluations with shape `(*batch_shape, *dimension_indv)`
             where `dimension_indv` is the shape of the function outputs.
         """
         raise MethodImplementationError(self, "g")
@@ -167,7 +167,7 @@ def f(self, x: np.ndarray, *args: tuple, **kwargs: dict):
                 - `'C3SIN'`: Sidi $C^3$ transform $\psi(x) = (12\pi x-8\sin(2 \pi x) + \sin(4 \pi x))/(12 \pi)$.
 
         Returns:
-            function evaluations with shape `(*batch_shape, *dimension_indv)`
+            np.ndarray: function evaluations with shape `(*batch_shape, *dimension_indv)`
             where `dimension_indv` is the shape of the function outputs.
         """
         if "periodization_transform" in kwargs:
@@ -352,7 +352,7 @@ def dependency(self, comb_flags: np.ndarray):
                 approximated.
 
         Returns:
-            Flags of shape `integrand.d_indv` indicating whether the individual
+            np.ndarray: Flags of shape `integrand.d_indv` indicating whether the individual
             integrands require additional sampling.
         """
         return (
diff --git a/qmcpy/integrand/umbridge_wrapper.py b/qmcpy/integrand/umbridge_wrapper.py
index af40ce05e..0d915a092 100644
--- a/qmcpy/integrand/umbridge_wrapper.py
+++ b/qmcpy/integrand/umbridge_wrapper.py
@@ -153,7 +153,7 @@ def to_umbridge_out_sizes(self, x: np.ndarray):
                 `umbridge.HTTPModel`.
 
         Returns:
-            List of lists with sub-list lengths specified by
+            list: List of lists with sub-list lengths specified by
             `model.get_output_sizes(self.config)`.
         """
         return [
diff --git a/qmcpy/kernel/multitask_kernel.py b/qmcpy/kernel/multitask_kernel.py
index 7abaa5ede..42b92d794 100644
--- a/qmcpy/kernel/multitask_kernel.py
+++ b/qmcpy/kernel/multitask_kernel.py
@@ -503,7 +503,7 @@ def __call__(self, task0, task1, x0, x1, beta0=None, beta1=None, c=None):
                 coefficients of derivatives.
 
         Returns:
-            Kernel evaluations with batched shape, see the doctests for
+            Union[np.ndarray, torch.Tensor]: Kernel evaluations with batched shape, see the doctests for
             examples.
         """
         kmat_x = self.base_kernel.__call__(x0, x1, beta0, beta1, c)
diff --git a/qmcpy/stopping_criterion/abstract_cub_mlmc.py b/qmcpy/stopping_criterion/abstract_cub_mlmc.py
index a1020d2d3..48aece21c 100644
--- a/qmcpy/stopping_criterion/abstract_cub_mlmc.py
+++ b/qmcpy/stopping_criterion/abstract_cub_mlmc.py
@@ -129,7 +129,7 @@ def _construct_data(self):
         """Build a fresh Data object for a new MLMC integration run.
 
         Returns:
-            Initialised with zero sample counts and warm-up allocation.
+            Data: Initialised with zero sample counts and warm-up allocation.
         """
         data = Data(
             parameters=[
diff --git a/qmcpy/stopping_criterion/abstract_stopping_criterion.py b/qmcpy/stopping_criterion/abstract_stopping_criterion.py
index 4206fe153..d153f14a2 100644
--- a/qmcpy/stopping_criterion/abstract_stopping_criterion.py
+++ b/qmcpy/stopping_criterion/abstract_stopping_criterion.py
@@ -243,7 +243,7 @@ def print_iteration_log(self, history=None, printed_only: bool = True, include_h
                 ``sys.stdout`` when None.
 
         Returns:
-            This method writes output to ``file``.
+            None: This method writes output to ``file``.
         """
         if history is None:
             history = getattr(self, "iteration_history", None)
@@ -401,7 +401,7 @@ def _resume_value_equal(self, current, saved):
             saved: Value from the resume checkpoint.
 
         Returns:
-            True when the two values are considered equal.
+            bool: True when the two values are considered equal.
         """
         if self._is_sparse(current) or self._is_sparse(saved):
             if self._is_sparse(current) != self._is_sparse(saved):
@@ -588,7 +588,7 @@ def _resolve_error_fun(error_fun):
                 callable with signature ``(sv, abs_tol, rel_tol) -> tol``.
 
         Returns:
-            The resolved callable and its canonical string key (``'EITHER'`` or
+            tuple[callable, str or None]: The resolved callable and its canonical string key (``'EITHER'`` or
             ``'BOTH'``), or ``None`` when the input was already a callable.
 
         Raises:
@@ -639,7 +639,7 @@ def _init_control_variates(self, control_variates, control_variate_means):
                 variate.
 
         Returns:
-            Number of control variates (``self.ncv``).
+            int: Number of control variates (``self.ncv``).
 
         Raises:
             ParameterError: If any control variate is incompatible.
@@ -698,7 +698,7 @@ def _compute_indv_alphas(self, alphas_comb):
                 with shape ``integrand.d_comb``.
 
         Returns:
-            ``(alphas_indv, identity_dependency)`` where *alphas_indv* has
+            tuple[np.ndarray, bool]: ``(alphas_indv, identity_dependency)`` where *alphas_indv* has
             shape ``integrand.d_indv`` and *identity_dependency* is True when
             each combined output depends on exactly its matching individual
             output.
diff --git a/qmcpy/stopping_criterion/diagnostics.py b/qmcpy/stopping_criterion/diagnostics.py
index 2acf4a1f3..51cab2c0d 100644
--- a/qmcpy/stopping_criterion/diagnostics.py
+++ b/qmcpy/stopping_criterion/diagnostics.py
@@ -530,7 +530,7 @@ def _state_signature(data):
             data (object): Integration state object.
 
         Returns:
-            ``(n_min, n_total, m, xfull.shape)``.
+            tuple: ``(n_min, n_total, m, xfull.shape)``.
         """
         xfull = getattr(data, "xfull", None)
         return (
@@ -558,7 +558,7 @@ def _get_visible_columns(self, data, row=None):
                 optional columns are present.
 
         Returns:
-            Column names from the set ``{'stage', 'iter', 'solution',
+            tuple[str, ...]: Column names from the set ``{'stage', 'iter', 'solution',
             'bound_diff', 'comb_bound_diff', 'bound_half_width',
             'bias_estimate', 'n_min', 'n_total', 'm', 'xfull.shape'}``.
         """
diff --git a/qmcpy/true_measure/abstract_true_measure.py b/qmcpy/true_measure/abstract_true_measure.py
index 406889ed3..7c15ded54 100644
--- a/qmcpy/true_measure/abstract_true_measure.py
+++ b/qmcpy/true_measure/abstract_true_measure.py
@@ -195,7 +195,7 @@ def _weight(self, x):
             x (np.ndarray): n x d  matrix of samples
 
         Returns:
-            length n vector of weights at locations of x
+            np.ndarray: length n vector of weights at locations of x
         """
         raise MethodImplementationError(
             self, "weight. Try a different true measure with a _weight method."
@@ -216,7 +216,7 @@ def spawn(self, s: int = 1, dimensions: np.ndarray = None):
                 copy. Defaults to the current dimension.
 
         Returns:
-            True measure with new seeds and dimensions.
+            list: True measure with new seeds and dimensions.
         """
         sampler = self.discrete_distrib if self.transform == self else self.transform
         sampler_spawns = sampler.spawn(s=s, dimensions=dimensions)
diff --git a/qmcpy/true_measure/kumaraswamy.py b/qmcpy/true_measure/kumaraswamy.py
index eaa0d2c0d..f9593c39b 100644
--- a/qmcpy/true_measure/kumaraswamy.py
+++ b/qmcpy/true_measure/kumaraswamy.py
@@ -135,7 +135,7 @@ def _compute_moments(self):
             [https://numpy.org/doc/stable/reference/generated/numpy.expm1.html](https://numpy.org/doc/stable/reference/generated/numpy.expm1.html).
 
         Returns:
-            Length ``d`` arrays ``(mean, variance)``.
+            tuple: Length ``d`` arrays ``(mean, variance)``.
         """
         inv_a = 1.0 / self.alpha
         beta = self.beta
diff --git a/qmcpy/true_measure/zero_inflated_exp_uniform.py b/qmcpy/true_measure/zero_inflated_exp_uniform.py
index fb0545153..961b7392f 100644
--- a/qmcpy/true_measure/zero_inflated_exp_uniform.py
+++ b/qmcpy/true_measure/zero_inflated_exp_uniform.py
@@ -286,7 +286,7 @@ def _compute_moments(self):
             [https://en.wikipedia.org/wiki/Law_of_total_variance](https://en.wikipedia.org/wiki/Law_of_total_variance).
 
         Returns:
-            Length ``1`` arrays ``(mean, variance)``.
+            tuple: Length ``1`` arrays ``(mean, variance)``.
         """
         p = self.p_zero
         lam = self.lam
diff --git a/qmcpy/util/data.py b/qmcpy/util/data.py
index 8fd142ab6..86a439796 100644
--- a/qmcpy/util/data.py
+++ b/qmcpy/util/data.py
@@ -27,7 +27,7 @@ def save(self, path, compress: bool = False, overwrite: bool = False):
                 file.
 
         Returns:
-            The final path the file was written to (may differ from *path* when
+            str: The final path the file was written to (may differ from *path* when
             ``compress=True`` appends ``.gz``).
 
         Raises:
@@ -61,7 +61,7 @@ def load(cls, path):
                 ``.gz`` are decompressed automatically.
 
         Returns:
-            The loaded Data object.
+            Data: The loaded Data object.
         """
         path = str(path)
         open_fn = gzip.open if path.endswith(".gz") else open
diff --git a/qmcpy/util/dig_shift_invar_ops.py b/qmcpy/util/dig_shift_invar_ops.py
index f4b6f990b..ca4871656 100644
--- a/qmcpy/util/dig_shift_invar_ops.py
+++ b/qmcpy/util/dig_shift_invar_ops.py
@@ -119,7 +119,7 @@ def weighted_walsh_funcs(alpha: int, xb, t: int):
         t (int): Number of bits in each integer in xb.
 
     Returns:
-        Weighted Walsh function values.
+        Union[np.ndarray, torch.Tensor]: Weighted Walsh function values.
 
     **References: **
 
@@ -188,7 +188,7 @@ def to_bin(x, t: int):
             where `isinstance(dnb2,DigitalNetB2)`.
 
     Returns:
-        binary representation of samples with `dtype` either `np.uint64` or
+        Union[np.ndarray, torch.Tensor]: binary representation of samples with `dtype` either `np.uint64` or
         `torch.int64`.
     """
     npt = get_npt(x)
@@ -231,7 +231,7 @@ def to_float(x, t: int):
             where `isinstance(dnb2,DigitalNetB2)`.
 
     Returns:
-        floating point representation of samples.
+        Union[np.ndarray, torch.Tensor]: floating point representation of samples.
     """
     npt = get_npt(x)
     if npt == np:  # npt==torch
@@ -266,7 +266,7 @@ def bin_from_numpy_to_torch(xb):
             `dtype=np.uint64`
 
     Returns:
-        binary representation of samples with `dtype=torch.int64`.
+        Union[torch.Tensor]: binary representation of samples with `dtype=torch.int64`.
     """
     if not (xb.dtype == np.uint64):
         raise AssertionError
diff --git a/qmcpy/util/latnetbuilder_linker.py b/qmcpy/util/latnetbuilder_linker.py
index c18372290..316054b81 100644
--- a/qmcpy/util/latnetbuilder_linker.py
+++ b/qmcpy/util/latnetbuilder_linker.py
@@ -12,7 +12,7 @@ def latnetbuilder_linker(lnb_dir: str = "./", out_dir: str = "./", fout_prefix:
         fout_prefix (str): start of output file name. e.g. 'my_poly_lat_vec'
 
     Returns:
-        path to file which can be passed into QMCPy's Lattice or Sobol' in
+        str: path to file which can be passed into QMCPy's Lattice or Sobol' in
         order to use the linked latnetbuilder generating vector/matrix e.g.
         'my_poly_lat_vec.10.16.npy'
 
diff --git a/scripts/check_test_style.py b/scripts/check_test_style.py
index e1151c0de..61fabedbd 100755
--- a/scripts/check_test_style.py
+++ b/scripts/check_test_style.py
@@ -84,7 +84,7 @@ def main(argv):
     positional = [a for a in argv if not a.startswith("-")]
     test_dir = Path(positional[0]) if positional else Path("test")
 
-    files = sorted(test_dir.glob("test_*.py"))
+    files = sorted(test_dir.glob("test_*.py", recurse_symlinks=True))
     if not files:
         print(f"no test_*.py files under {test_dir}/", file=sys.stderr)
         return 1

From 087b0f097642c82bee4ee7a4922af95567e66622 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Mon, 7 Sep 2026 12:37:56 +0800
Subject: [PATCH 24/51] Reduce output

---
 makefile | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/makefile b/makefile
index b511542a3..a50594198 100644
--- a/makefile
+++ b/makefile
@@ -166,8 +166,8 @@ check_docstring_changed:
 	if [ -z "$$changed_files" ]; then \
 		echo "No changed qmcpy/*.py files relative to $(DOCSTRING_BASE)."; \
 	else \
-		echo "Checking docstrings on changed qmcpy files relative to $(DOCSTRING_BASE):"; \
-		printf '%s\n' "$$changed_files"; \
+		file_count=$$(printf '%s\n' "$$changed_files" | wc -l | tr -d ' '); \
+		echo "Checking docstrings on $$file_count changed qmcpy file(s) relative to $(DOCSTRING_BASE)."; \
 		$(PYTHON) scripts/check_docstring.py $$changed_files $(CHECK_DOCSTRING_ARGS) $(STRICT); \
 		echo ""; \
 		$(PYDOCLINT) $(PYDOCLINT_ARGS) $$changed_files $(if $(STRICT),,|| true); \

From 5d82301f3abcc4841aa64673ffb23f3194cb7ca3 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Mon, 7 Sep 2026 13:04:04 +0800
Subject: [PATCH 25/51] Minor updates

---
 docs/tests.md               |  6 +++++-
 scripts/check_test_style.py | 11 ++++++++++-
 2 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/docs/tests.md b/docs/tests.md
index bdb612e31..73cc08d92 100644
--- a/docs/tests.md
+++ b/docs/tests.md
@@ -54,6 +54,8 @@ python -m pytest test/ -k test_tm_      # every true_measure test
 make unittests PYTEST_EXTRA_ARGS="-k test_sc_"
 ```
 
+When a test spans two areas (say a stopping criterion exercised against a particular kernel), file it under the component actually under test and name the other in `<topic>` — e.g. `test_sc_cubbayes_kernels.py`. Reserve `ee` for cases where neither side is the clear subject. Do not invent new area codes: only the prefixes in the table are accepted, and `make check_test_style STRICT=--strict` fails on anything else.
+
 Notebook tests are separate: they live in `test/booktests/` as `tb_*.py` and are generated from `demos/` (see `test/booktests/README.md`).
 
 ### Conventions checked by `make check_test_style`
@@ -67,6 +69,8 @@ Notebook tests are separate: they live in `test/booktests/` as `tb_*.py` and are
 STRICT=--strict make check_test_style
 ```
 
+`STRICT=--strict make check_test_style` also runs in CI (the `alltests` workflow), so both conventions are enforced on every pull request.
+
 ## Detailed Descriptions
 
 ## Scope
@@ -195,6 +199,7 @@ Runs notebook tests with **Parsl distributed parallelization** for compute-heavy
 - **Dependencies**: Parsl must be installed and configured
 - **Use when**: Running large notebook suites with distributed compute resources
 
+
 ---
 
 ### Helper / Internal Targets
@@ -284,7 +289,6 @@ Displays the current coverage report (must run other targets first to accumulate
 Deletes `.coverage` and `coverage.json` files to reset coverage tracking.
 - **Use before**: Running a fresh coverage report without accumulated data
 
- 
 ---
 
 ## Currently Active Targets: Justification
diff --git a/scripts/check_test_style.py b/scripts/check_test_style.py
index 61fabedbd..4687186b1 100755
--- a/scripts/check_test_style.py
+++ b/scripts/check_test_style.py
@@ -84,7 +84,16 @@ def main(argv):
     positional = [a for a in argv if not a.startswith("-")]
     test_dir = Path(positional[0]) if positional else Path("test")
 
-    files = sorted(test_dir.glob("test_*.py", recurse_symlinks=True))
+    # Recursive: a misnamed/bare-function test file placed in a subdirectory
+    # should still be caught. test/booktests/ is excluded -- it has its own
+    # separate, documented naming convention (tb_*.py, generated from
+    # demos/) and isn't meant to comply with the test_<area>_*.py convention
+    # this script enforces; test/booktests/test_runtimes.py in particular
+    # isn't a test at all, just a runtime-estimates data module that happens
+    # to start with "test_".
+    files = sorted(
+        f for f in test_dir.rglob("test_*.py") if "booktests" not in f.parts
+    )
     if not files:
         print(f"no test_*.py files under {test_dir}/", file=sys.stderr)
         return 1

From 14d85d648a3d496755196e5c14b62a6c35fc1635 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Mon, 7 Sep 2026 17:56:25 +0800
Subject: [PATCH 26/51] Fix assert statements

---
 .../digital_net_any_bases/digital_net_any_bases.py            | 4 +++-
 qmcpy/discrete_distribution/kronecker.py                      | 4 +++-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py b/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py
index 2a3e1085c..c2789d85d 100644
--- a/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py
+++ b/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py
@@ -388,7 +388,9 @@ def __init__(self,
             raise AssertionError
         if not (0<self._t_curr<=self.t<=64):
             raise AssertionError
-        if self.randomize=="FALSE": assert self.C.shape[0]==self.replications, "randomize='FALSE' but replications = %d does not equal the number of sets of generating vectors %d"%(self.replications,self.C.shape[0])
+        if self.randomize=="FALSE":
+            if not (self.C.shape[0]==self.replications):
+                raise AssertionError("randomize='FALSE' but replications = %d does not equal the number of sets of generating vectors %d"%(self.replications,self.C.shape[0]))
         if warn and (self.bases==2).all():
             warnings.warn("It is more efficient to use DigitalNetB2 instead of DigitalNetAnyBases when all bases are 2")
         self.warn = warn
diff --git a/qmcpy/discrete_distribution/kronecker.py b/qmcpy/discrete_distribution/kronecker.py
index 4be207d4c..fec80af88 100644
--- a/qmcpy/discrete_distribution/kronecker.py
+++ b/qmcpy/discrete_distribution/kronecker.py
@@ -315,7 +315,9 @@ def __init__(self,
             self.randomize = "FALSE"
         if not (self.randomize in ["SHIFT", "FALSE"]):
             raise AssertionError
-        if shift is not None: assert self.randomize=="SHIFT", "require randomize='SHIFT' when shift is not None"
+        if shift is not None:
+            if not (self.randomize=="SHIFT"):
+                raise AssertionError("require randomize='SHIFT' when shift is not None")
         if self.randomize=="SHIFT":
             if shift is not None:
                 self.shift = np.atleast_2d(shift).astype(float)

From 6ae1662a8dec9f495f031f6ef9d8662e3bf724da Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Mon, 7 Sep 2026 18:16:20 +0800
Subject: [PATCH 27/51] Minor changes

---
 makefile | 1 +
 1 file changed, 1 insertion(+)

diff --git a/makefile b/makefile
index a50594198..3787f3f65 100644
--- a/makefile
+++ b/makefile
@@ -79,6 +79,7 @@ check_asserts_changed: check_assert_codemod_dependency
 DOCSTRING_PATH ?= qmcpy
 DOCSTRING_BASE ?= origin/develop
 PYDOCLINT ?= pydoclint
+PYDOCLINT_ARGS ?= -q
 DOCSTRING_FORMATTER ?= format-docstring
 DOCSTRING_FORMAT_PATH ?= qmcpy
 DOCSTRING_FORMAT_DIFF_BASE ?= develop

From df0befbd381078889cb403c3341d594040ad681b Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Mon, 7 Sep 2026 20:37:31 +0800
Subject: [PATCH 28/51] Fix indentation issues in docstrings

---
 .../abstract_discrete_distribution.py         |  8 ++--
 qmcpy/integrand/abstract_integrand.py         | 13 +++----
 qmcpy/integrand/keister.py                    |  2 +-
 qmcpy/integrand/umbridge_wrapper.py           |  2 +-
 qmcpy/kernel/multitask_kernel.py              |  2 +-
 qmcpy/true_measure/abstract_true_measure.py   |  4 +-
 qmcpy/true_measure/scipy_wrapper.py           | 29 +++++++-------
 qmcpy/util/dig_shift_invar_ops.py             |  2 +-
 scripts/check_test_style.py                   | 38 ++++++++++++++-----
 9 files changed, 59 insertions(+), 41 deletions(-)

diff --git a/qmcpy/discrete_distribution/abstract_discrete_distribution.py b/qmcpy/discrete_distribution/abstract_discrete_distribution.py
index d59d57c95..20abe9fef 100644
--- a/qmcpy/discrete_distribution/abstract_discrete_distribution.py
+++ b/qmcpy/discrete_distribution/abstract_discrete_distribution.py
@@ -70,11 +70,11 @@ def __call__(self, n=None, n_min=None, n_max=None, return_binary=False, warn=Tru
         Returns:
             np.ndarray: Samples from the sequence.
 
-            - If `replications` is `None` then this will be of size (`n_max`-`n_min`) $\times$ `dimension`
-            - If `replications` is a positive int, then `x` will be of size `replications` $\times$ (`n_max`-`n_min`) $\times$ `dimension`
+                - If `replications` is `None` then this will be of size (`n_max`-`n_min`) $\times$ `dimension`
+                - If `replications` is a positive int, then `x` will be of size `replications` $\times$ (`n_max`-`n_min`) $\times$ `dimension`
 
-            Note that if `return_binary=True` then `x` is returned where `x`
-            are integer representations of the digital net points.
+                Note that if `return_binary=True` then `x` is returned where `x`
+                are integer representations of the digital net points.
         """
         return self.gen_samples(
             n=n, n_min=n_min, n_max=n_max, return_binary=return_binary, warn=warn
diff --git a/qmcpy/integrand/abstract_integrand.py b/qmcpy/integrand/abstract_integrand.py
index 6c4ad76f0..ddf290bb8 100644
--- a/qmcpy/integrand/abstract_integrand.py
+++ b/qmcpy/integrand/abstract_integrand.py
@@ -98,8 +98,6 @@ def __call__(self, n=None, n_min=None, n_max=None, warn=True):
 
                 - If `replications` is `None` then this will be of size (`n_max`-`n_min`) $\times$ `dimension`
                 - If `replications` is a positive int, then `t` will be of size `replications` $\times$ (`n_max`-`n_min`) $\times$ `dimension`
-            weights (np.ndarray): Only returned when `return_weights=True`. The
-            Jacobian weights for the transformation
         """
         return self.gen_samples(n=n, n_min=n_min, n_max=n_max, warn=warn)
 
@@ -131,7 +129,7 @@ def g(self, t: np.ndarray, *args: tuple, **kwargs: dict):
 
         Returns:
             np.ndarray: function evaluations with shape `(*batch_shape, *dimension_indv)`
-            where `dimension_indv` is the shape of the function outputs.
+                where `dimension_indv` is the shape of the function outputs.
         """
         raise MethodImplementationError(self, "g")
 
@@ -168,7 +166,7 @@ def f(self, x: np.ndarray, *args: tuple, **kwargs: dict):
 
         Returns:
             np.ndarray: function evaluations with shape `(*batch_shape, *dimension_indv)`
-            where `dimension_indv` is the shape of the function outputs.
+                where `dimension_indv` is the shape of the function outputs.
         """
         if "periodization_transform" in kwargs:
             periodization_transform = kwargs["periodization_transform"]
@@ -320,9 +318,8 @@ def bound_fun(self, bound_low: np.ndarray, bound_high: np.ndarray):
                 shape `integrand.d_indv`.
 
         Returns:
-            np.ndarray: Lower bounds on combined estimates with shape `integrand.d_comb`.
-            comb_bound_high (np.ndarray): Upper bounds on combined estimates
-            with shape `integrand.d_comb`.
+            tuple[np.ndarray, np.ndarray]: Lower and upper bounds on the
+                combined estimates, respectively, each with shape `integrand.d_comb`.
         """
         if self.d_indv != self.d_comb:
             raise ParameterError(
@@ -353,7 +350,7 @@ def dependency(self, comb_flags: np.ndarray):
 
         Returns:
             np.ndarray: Flags of shape `integrand.d_indv` indicating whether the individual
-            integrands require additional sampling.
+                integrands require additional sampling.
         """
         return (
             comb_flags
diff --git a/qmcpy/integrand/keister.py b/qmcpy/integrand/keister.py
index 564d48411..3eff18311 100644
--- a/qmcpy/integrand/keister.py
+++ b/qmcpy/integrand/keister.py
@@ -69,7 +69,7 @@ def _spawn(self, level, sampler):
         return Keister(sampler=sampler)
 
     @classmethod
-    def get_exact_value(self, d: int):
+    def get_exact_value(cls, d: int):
         """Compute the exact analytic value of the Keister integral with
         dimension $d$.
 
diff --git a/qmcpy/integrand/umbridge_wrapper.py b/qmcpy/integrand/umbridge_wrapper.py
index 0d915a092..33c0bbb66 100644
--- a/qmcpy/integrand/umbridge_wrapper.py
+++ b/qmcpy/integrand/umbridge_wrapper.py
@@ -154,7 +154,7 @@ def to_umbridge_out_sizes(self, x: np.ndarray):
 
         Returns:
             list: List of lists with sub-list lengths specified by
-            `model.get_output_sizes(self.config)`.
+                `model.get_output_sizes(self.config)`.
         """
         return [
             x[..., self.d_out_umbridge[j] : self.d_out_umbridge[j + 1]].tolist()
diff --git a/qmcpy/kernel/multitask_kernel.py b/qmcpy/kernel/multitask_kernel.py
index 42b92d794..68abfa34f 100644
--- a/qmcpy/kernel/multitask_kernel.py
+++ b/qmcpy/kernel/multitask_kernel.py
@@ -504,7 +504,7 @@ def __call__(self, task0, task1, x0, x1, beta0=None, beta1=None, c=None):
 
         Returns:
             Union[np.ndarray, torch.Tensor]: Kernel evaluations with batched shape, see the doctests for
-            examples.
+                examples.
         """
         kmat_x = self.base_kernel.__call__(x0, x1, beta0, beta1, c)
         return self._parsed__call__(task0, task1, kmat_x)
diff --git a/qmcpy/true_measure/abstract_true_measure.py b/qmcpy/true_measure/abstract_true_measure.py
index 7c15ded54..d8ba7bf12 100644
--- a/qmcpy/true_measure/abstract_true_measure.py
+++ b/qmcpy/true_measure/abstract_true_measure.py
@@ -133,8 +133,8 @@ def __call__(self, n=None, n_min=None, n_max=None, return_weights=False, warn=Tr
 
                 - If `replications` is `None` then this will be of size (`n_max`-`n_min`) $\times$ `dimension`
                 - If `replications` is a positive int, then `t` will be of size `replications` $\times$ (`n_max`-`n_min`) $\times$ `dimension`
-            weights (np.ndarray): Only returned when `return_weights=True`. The
-            Jacobian weights for the transformation
+            np.ndarray: Jacobian weights, returned as the second result only
+                when `return_weights=True`.
         """
         return self.gen_samples(
             n=n, n_min=n_min, n_max=n_max, return_weights=return_weights, warn=warn
diff --git a/qmcpy/true_measure/scipy_wrapper.py b/qmcpy/true_measure/scipy_wrapper.py
index dc8d621ce..8cf080586 100644
--- a/qmcpy/true_measure/scipy_wrapper.py
+++ b/qmcpy/true_measure/scipy_wrapper.py
@@ -176,19 +176,22 @@ class SciPyWrapper(AbstractTrueMeasure):
     """
 
     def __init__(self, sampler, scipy_distribs) -> None:
-        """Parameters ---------- sampler : AbstractDiscreteDistribution Low
-        discrepancy or iid sampler in dimension d, living on [0,1)^d.
-        scipy_distribs:
-            One of the following:
-
-            - A single SciPy 1D continuous frozen distribution.
-            - A list of such frozen distributions (independent marginals).
-            - A custom 1D distribution object with ``ppf`` and ``pdf`` or
-              ``logpdf`` methods.
-            - A joint object with:
-                * ``transform(u)`` method
-                * optional ``logpdf(x)`` method
-                * ``dim`` or ``dimension`` attribute (otherwise ``sampler.d``).
+        """Wrap one or more SciPy distributions as a QMCPy true measure.
+
+        Args:
+            sampler (AbstractDiscreteDistribution): Low discrepancy or iid
+                sampler in dimension d, living on [0,1)^d.
+            scipy_distribs (Union[scipy.stats.rv_frozen, list, object]): One
+                of the following:
+
+                - A single SciPy 1D continuous frozen distribution.
+                - A list of such frozen distributions (independent marginals).
+                - A custom 1D distribution object with ``ppf`` and ``pdf`` or
+                  ``logpdf`` methods.
+                - A joint object with:
+                    * ``transform(u)`` method
+                    * optional ``logpdf(x)`` method
+                    * ``dim`` or ``dimension`` attribute (otherwise ``sampler.d``).
         """
         self.domain = np.array([[0.0, 1.0]])
 
diff --git a/qmcpy/util/dig_shift_invar_ops.py b/qmcpy/util/dig_shift_invar_ops.py
index ca4871656..fe5835382 100644
--- a/qmcpy/util/dig_shift_invar_ops.py
+++ b/qmcpy/util/dig_shift_invar_ops.py
@@ -189,7 +189,7 @@ def to_bin(x, t: int):
 
     Returns:
         Union[np.ndarray, torch.Tensor]: binary representation of samples with `dtype` either `np.uint64` or
-        `torch.int64`.
+            `torch.int64`.
     """
     npt = get_npt(x)
     if npt == np:
diff --git a/scripts/check_test_style.py b/scripts/check_test_style.py
index 4687186b1..139dc387a 100755
--- a/scripts/check_test_style.py
+++ b/scripts/check_test_style.py
@@ -64,18 +64,31 @@ def _subclasses_testcase(node):
 
 
 def classify(path):
-    """Return (has_testcase_class, has_test_callables)."""
+    """Return (has_testcase_class, has_bare_top_level_test, has_any_test).
+
+    ``has_bare_top_level_test`` only looks at module-level functions, so a
+    file with a proper TestCase class that *also* has a stray top-level
+    ``def test_*():`` still flags the violation instead of being masked by
+    the class. ``has_any_test`` still walks the whole tree, to distinguish a
+    file with no tests at all from one whose tests just aren't bare/top-level
+    (e.g. methods on a non-TestCase class).
+    """
     tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
-    nodes = list(ast.walk(tree))
     has_class = any(
-        isinstance(n, ast.ClassDef) and _subclasses_testcase(n) for n in nodes
+        isinstance(n, ast.ClassDef) and _subclasses_testcase(n)
+        for n in ast.walk(tree)
     )
-    has_tests = any(
+    has_bare_top_level_test = any(
         isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))
         and n.name.startswith("test_")
-        for n in nodes
+        for n in tree.body
     )
-    return has_class, has_tests
+    has_any_test = any(
+        isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))
+        and n.name.startswith("test_")
+        for n in ast.walk(tree)
+    )
+    return has_class, has_bare_top_level_test, has_any_test
 
 
 def main(argv):
@@ -100,10 +113,15 @@ def main(argv):
 
     class_based, function_based, no_tests = [], [], []
     for f in files:
-        has_class, has_tests = classify(f)
-        if has_class:
+        has_class, has_bare_top_level_test, has_any_test = classify(f)
+        if has_bare_top_level_test:
+            # Flagged regardless of has_class: a stray top-level `def
+            # test_*():` violates the convention even in a file that also
+            # has a proper TestCase class.
+            function_based.append(f)
+        elif has_class:
             class_based.append(f)
-        elif has_tests:
+        elif has_any_test:
             function_based.append(f)
         else:
             no_tests.append(f)
@@ -138,7 +156,7 @@ def main(argv):
     elif not quiet:
         print("  no misnamed test files found")
 
-    return 1 if (strict and (function_based or misnamed)) else 0
+    return 1 if (strict and (function_based or misnamed or no_tests)) else 0
 
 
 if __name__ == "__main__":

From 5e9bf3cdd263eddcc3e564251e561d3b313fb190 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Mon, 7 Sep 2026 20:45:24 +0800
Subject: [PATCH 29/51] Minor changes

---
 .github/workflows/alltests.yml |  1 +
 makefile                       | 11 ++++
 scripts/baseline_counts.json   |  5 ++
 scripts/check_baseline.py      | 94 ++++++++++++++++++++++++++++++++++
 4 files changed, 111 insertions(+)
 create mode 100644 scripts/baseline_counts.json
 create mode 100644 scripts/check_baseline.py

diff --git a/.github/workflows/alltests.yml b/.github/workflows/alltests.yml
index 8c592f510..b94c8cfab 100644
--- a/.github/workflows/alltests.yml
+++ b/.github/workflows/alltests.yml
@@ -320,6 +320,7 @@ jobs:
           make check_test_style STRICT=--strict
           python -m pip install -q "pydoclint>=0.5.0"
           make check_docstring   # informational (exits 0 without STRICT)
+          make check_baseline    # real gate: docstring/pydoclint/annotation issues must not increase
       # -----------------------------------------------------------
       # Install minimal LaTeX required by Jupyter notebooks (OS-specific)
       # -----------------------------------------------------------
diff --git a/makefile b/makefile
index 3787f3f65..b3fd95740 100644
--- a/makefile
+++ b/makefile
@@ -108,6 +108,17 @@ check_docstring:
 	@echo ""
 	@$(PYDOCLINT) $(PYDOCLINT_ARGS) $(DOCSTRING_PATH) $(if $(STRICT),,|| true)
 
+# Ratchet gate: check_docstring/pydoclint/annotate_public_api_types are
+# informational (existing backlog is large, see PR #613 review F9/F10), but
+# this fails if a change increases any of their full-tree violation counts
+# above scripts/baseline_counts.json. Run with --update after intentionally
+# reducing (or, with justification, increasing) one of the counts.
+check_baseline:
+	@$(PYTHON) scripts/check_baseline.py
+
+check_baseline_update:
+	@$(PYTHON) scripts/check_baseline.py --update
+
 format_google_docstrings:
 	@command -v "$(DOCSTRING_FORMATTER)" >/dev/null 2>&1 || { \
 		echo "Missing $(DOCSTRING_FORMATTER). Install with: $(PYTHON) -m pip install format-docstring"; \
diff --git a/scripts/baseline_counts.json b/scripts/baseline_counts.json
new file mode 100644
index 000000000..b1c86be78
--- /dev/null
+++ b/scripts/baseline_counts.json
@@ -0,0 +1,5 @@
+{
+  "check_docstring": 260,
+  "pydoclint": 135,
+  "unsafe_annotations": 109
+}
diff --git a/scripts/check_baseline.py b/scripts/check_baseline.py
new file mode 100644
index 000000000..c12bbde0b
--- /dev/null
+++ b/scripts/check_baseline.py
@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""Ratchet gate for the informational docstring/annotation checks.
+
+`check_docstring`, `pydoclint`, and `annotate_public_api_types` are
+informational today (see F9/F10 in the PR #613 review) because fixing every
+existing violation before enabling them as hard gates is a large, separate
+undertaking. This script tracks each check's full-tree violation count in
+`scripts/baseline_counts.json` and fails only if a count *increases* --
+new violations are blocked; the existing backlog is not required to be
+cleared just to land an unrelated change.
+
+Usage:
+    python scripts/check_baseline.py            # compare against the baseline
+    python scripts/check_baseline.py --update    # write current counts as the new baseline
+
+`--update` is for a change that intentionally reduces (or, with justification
+in the PR description, increases) one of these counts.
+"""
+import json
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+BASELINE_PATH = Path(__file__).resolve().parent / "baseline_counts.json"
+
+CHECKS = {
+    "check_docstring": {
+        "cmd": [sys.executable, "scripts/check_docstring.py", "qmcpy"],
+        "pattern": re.compile(r"^\d+ file\(s\) scanned: (\d+) issue\(s\) across \d+ file\(s\)", re.M),
+    },
+    "pydoclint": {
+        "cmd": ["pydoclint", "-q", "qmcpy"],
+        "line_pattern": re.compile(r"^\s*\d+: DOC\d+:", re.M),
+    },
+    "unsafe_annotations": {
+        "cmd": [sys.executable, "-m", "scripts.annotate_public_api_types", "--check", "--root", "qmcpy"],
+        "pattern": re.compile(r"(\d+) unsafe existing annotation\(s\)"),
+    },
+}
+
+
+def run_check(spec):
+    result = subprocess.run(spec["cmd"], capture_output=True, text=True, cwd=REPO_ROOT)
+    output = result.stdout + result.stderr
+    if "line_pattern" in spec:
+        return len(spec["line_pattern"].findall(output))
+    match = spec["pattern"].search(output)
+    if match is None:
+        raise RuntimeError(f"could not parse a count from output of {spec['cmd']}")
+    return int(match.group(1))
+
+
+def main(argv):
+    update = "--update" in argv
+    baseline = json.loads(BASELINE_PATH.read_text()) if BASELINE_PATH.exists() else {}
+
+    current = {}
+    regressed = []
+    for name, spec in CHECKS.items():
+        count = run_check(spec)
+        current[name] = count
+        base = baseline.get(name)
+        if base is None:
+            status = "no baseline yet"
+        elif count > base:
+            status = f"REGRESSED from {base}"
+            regressed.append(name)
+        elif count < base:
+            status = f"improved from {base}"
+        else:
+            status = "unchanged"
+        print(f"{name}: {count} ({status})")
+
+    if update:
+        BASELINE_PATH.write_text(json.dumps(current, indent=2, sort_keys=True) + "\n")
+        print(f"\nWrote new baseline to {BASELINE_PATH.relative_to(REPO_ROOT)}")
+        return 0
+
+    if regressed:
+        print(
+            f"\nRegression in: {', '.join(regressed)}. Fix the new violations, "
+            "or if the increase is intentional and justified in the PR "
+            "description, run `python scripts/check_baseline.py --update` "
+            "and commit the updated baseline file.",
+            file=sys.stderr,
+        )
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

From bc8f9c36eafd286388fe6ea6928292fad341997e Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Mon, 7 Sep 2026 20:55:41 +0800
Subject: [PATCH 30/51] Organize makefile targets

---
 makefile | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/makefile b/makefile
index b3fd95740..728f36cb7 100644
--- a/makefile
+++ b/makefile
@@ -655,10 +655,16 @@ format:
 	$(MAKE) rm_trailing_whitespace FORMAT_PATH="$(FORMAT_PATH)"
 	@echo "---"
 	$(MAKE) harden_colab_notebook
-	@echo "---"
+
+# Report-only: same conventions alltests.yml's "Check test-suite conventions"
+# step gates on, for running locally. Unlike `format`, nothing here writes to
+# the codebase.
+check:
 	$(MAKE) check_test_style
 	@echo "---"
 	$(MAKE) check_docstring_changed
+	@echo "---"
+	$(MAKE) check_baseline
 
 flatten_qmcpy_imports:
 	$(PYTHON) scripts/flatten_qmcpy_imports.py

From 46a1246a746d2cf0e799f960e479ac23f64f4d13 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Tue, 8 Sep 2026 14:55:25 +0800
Subject: [PATCH 31/51] Add sub-targets to make format and check

---
 makefile | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/makefile b/makefile
index 728f36cb7..a0d66d29f 100644
--- a/makefile
+++ b/makefile
@@ -655,6 +655,14 @@ format:
 	$(MAKE) rm_trailing_whitespace FORMAT_PATH="$(FORMAT_PATH)"
 	@echo "---"
 	$(MAKE) harden_colab_notebook
+	@echo "---"
+	$(MAKE) convert_asserts_changed
+	@echo "---"
+	$(MAKE) add_docstring_arg_types_changed
+	# format_google_docstrings_changed deliberately NOT included: verified it
+	# strips Returns: types and collapses Args:/Warnings:/Raises: structure
+	# into run-on paragraphs on this codebase's actual docstrings -- tested
+	# on real files, reverted, not safe to run unattended (see git history).
 
 # Report-only: same conventions alltests.yml's "Check test-suite conventions"
 # step gates on, for running locally. Unlike `format`, nothing here writes to
@@ -665,6 +673,8 @@ check:
 	$(MAKE) check_docstring_changed
 	@echo "---"
 	$(MAKE) check_baseline
+	@echo "---"
+	$(MAKE) check_asserts_changed
 
 flatten_qmcpy_imports:
 	$(PYTHON) scripts/flatten_qmcpy_imports.py

From 381da379bed7a09438d27f3fda8d53b8231edc99 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Tue, 8 Sep 2026 15:00:25 +0800
Subject: [PATCH 32/51] Convert assert to AssertionError

---
 .../abstract_cub_bayes_ld_g.py                | 19 +++++---
 .../abstract_cub_qmc_ld_g.py                  | 21 +++++----
 qmcpy/util/exact_gpytorch_regression_model.py | 19 +++++---
 qmcpy/util/torch_numpy_ops.py                 |  3 +-
 qmcpy/util/transforms.py                      | 47 ++++++++++++-------
 5 files changed, 68 insertions(+), 41 deletions(-)

diff --git a/qmcpy/stopping_criterion/abstract_cub_bayes_ld_g.py b/qmcpy/stopping_criterion/abstract_cub_bayes_ld_g.py
index 1ad2b1bc1..ad4e5c9b6 100644
--- a/qmcpy/stopping_criterion/abstract_cub_bayes_ld_g.py
+++ b/qmcpy/stopping_criterion/abstract_cub_bayes_ld_g.py
@@ -48,7 +48,8 @@ def __init__(
         # Set Attributes
         self.n_init = int(n_init)
         self.n_limit = int(n_limit)
-        assert isinstance(error_fun, str) or callable(error_fun)
+        if not (isinstance(error_fun, str) or callable(error_fun)):
+            raise AssertionError
         # _error_fun_key stores a simple, serializable string and ensures correct state saving
         # in __getstate__(), bypassing serialization of complex lambda functions, which often fails.
         self.error_fun, self._error_fun_key = self._resolve_error_fun(error_fun)
@@ -60,12 +61,14 @@ def __init__(
         super(AbstractCubBayesLDG, self).__init__(
             allowed_distribs=allowed_distribs, allow_vectorized_integrals=True
         )
-        assert (
+        if not (
             self.integrand.discrete_distrib.no_replications == True
-        ), "Require the discrete distribution has replications=None"
-        assert (
+        ):
+            raise AssertionError("Require the discrete distribution has replications=None")
+        if not (
             self.integrand.discrete_distrib.randomize != "FALSE"
-        ), "Require discrete distribution is randomized"
+        ):
+            raise AssertionError("Require discrete distribution is randomized")
         self.alphas_indv, _ = self._compute_indv_alphas(
             np.full(self.integrand.d_comb, self.alpha)
         )
@@ -79,7 +82,8 @@ def __init__(
         self.use_gradient = False  # If true uses gradient descent in parameter search
         self.one_theta = True  # If true use common shape parameter for all dimensions, else allow shape parameter vary across dimensions
         self.errbd_type = errbd_type.upper()
-        assert self.errbd_type in ["MLE", "GCV", "FULL"]
+        if not (self.errbd_type in ["MLE", "GCV", "FULL"]):
+            raise AssertionError
         self.kernel = kernel
         self.debugEnable = True
         self.ft = ft
@@ -446,7 +450,8 @@ def _validate_resume(self, data):
             raise ParameterError("resume data n_total must be a power of 2.")
 
     def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
-        assert rmse_tol is None, "rmse_tol not supported by this stopping criterion."
+        if not (rmse_tol is None):
+            raise AssertionError("rmse_tol not supported by this stopping criterion.")
         if abs_tol is not None:
             self.abs_tol = abs_tol
             self.abs_tols = np.full(self.integrand.d_comb, self.abs_tol)
diff --git a/qmcpy/stopping_criterion/abstract_cub_qmc_ld_g.py b/qmcpy/stopping_criterion/abstract_cub_qmc_ld_g.py
index 1e7d48e49..0cef6ed9c 100644
--- a/qmcpy/stopping_criterion/abstract_cub_qmc_ld_g.py
+++ b/qmcpy/stopping_criterion/abstract_cub_qmc_ld_g.py
@@ -74,7 +74,8 @@ def __init__(
                 ParameterWarning,
             )
             self.n_limit = dd_n_limit
-        assert isinstance(error_fun, str) or callable(error_fun)
+        if not (isinstance(error_fun, str) or callable(error_fun)):
+            raise AssertionError
         # _error_fun_key stores a simple, serializable string and ensures correct state saving
         # in __getstate__(), bypassing serialization of complex lambda functions, which often fails.
         self.error_fun, self._error_fun_key = self._resolve_error_fun(error_fun)
@@ -97,20 +98,23 @@ def __init__(
         super(AbstractCubQMCLDG, self).__init__(
             allowed_distribs=allowed_distribs, allow_vectorized_integrals=True
         )
-        assert (
+        if not (
             self.integrand.discrete_distrib.no_replications == True
-        ), "Require the discrete distribution has replications=None"
-        assert (
+        ):
+            raise AssertionError("Require the discrete distribution has replications=None")
+        if not (
             self.integrand.discrete_distrib.randomize != "FALSE"
-        ), "Require discrete distribution is randomized"
+        ):
+            raise AssertionError("Require discrete distribution is randomized")
         self.set_tolerance(abs_tol, rel_tol)
         # control variates
         self._init_control_variates(control_variates, control_variate_means)
         self.update_beta = update_beta
         if self.ncv > 0:
-            assert self.cv_mu.shape == (
+            if not (self.cv_mu.shape == (
                 (self.ncv,) + self.integrand.d_indv
-            ), "Control variate means should have shape (len(control variates),d_indv)."
+            )):
+                raise AssertionError("Control variate means should have shape (len(control variates),d_indv).")
             self.parameters += ["cv", "cv_mu", "update_beta"]
         else:
             self.update_beta = False
@@ -476,7 +480,8 @@ def integrate(self, resume=None):
         return data.solution, data
 
     def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
-        assert rmse_tol is None, "rmse_tol not supported by this stopping criterion."
+        if not (rmse_tol is None):
+            raise AssertionError("rmse_tol not supported by this stopping criterion.")
         if abs_tol is not None:
             self.abs_tol = abs_tol
             self.abs_tols = np.full(self.integrand.d_comb, self.abs_tol)
diff --git a/qmcpy/util/exact_gpytorch_regression_model.py b/qmcpy/util/exact_gpytorch_regression_model.py
index f3dc73864..5c179955c 100644
--- a/qmcpy/util/exact_gpytorch_regression_model.py
+++ b/qmcpy/util/exact_gpytorch_regression_model.py
@@ -15,16 +15,19 @@ def __init__(self, x_t, y_t, prior_mean, prior_cov, likelihood, use_gpu=False):
             x_t = torch.from_numpy(x_t)
         if isinstance(y_t, np.ndarray):
             y_t = torch.from_numpy(y_t)
-        assert x_t.ndim == 2 and y_t.ndim == 1 and len(x_t) == len(y_t)
+        if not (x_t.ndim == 2 and y_t.ndim == 1 and len(x_t) == len(y_t)):
+            raise AssertionError
         super(ExactGPyTorchRegressionModel, self).__init__(x_t, y_t, likelihood)
-        assert isinstance(
+        if not (isinstance(
             self.likelihood, ExactGPyTorchRegressionModel.allowed_likelihood_types
-        )
+        )):
+            raise AssertionError
         self.mean_module, self.covar_module = prior_mean, prior_cov
         self.d = x_t.shape[1]
         self.use_gpu = use_gpu
         if self.use_gpu:
-            assert torch.cuda.is_available()
+            if not (torch.cuda.is_available()):
+                raise AssertionError
             self = self.cuda()
             self.likelihood = self.likelihood.cuda()
 
@@ -52,7 +55,8 @@ def fit(self, optimizer, mll, training_iter, verbose=0):
     def predict(self, x, noise_const=0, chunk_size=2**15):
         if isinstance(x, np.ndarray):
             x = torch.from_numpy(x)
-        assert x.ndim == 2 and x.shape[1] == self.d
+        if not (x.ndim == 2 and x.shape[1] == self.d):
+            raise AssertionError
         self.eval()
         self.likelihood.eval()
         n = len(x)
@@ -86,12 +90,13 @@ def add_data(self, x_t_new, y_t_new):
             x_t_new = torch.from_numpy(x_t_new)
         if isinstance(y_t_new, np.ndarray):
             y_t_new = torch.from_numpy(y_t_new)
-        assert (
+        if not (
             x_t_new.ndim == 2
             and x_t_new.shape[1] == self.d
             and y_t_new.ndim == 1
             and len(x_t_new) == len(y_t_new)
-        )
+        ):
+            raise AssertionError
         if self.use_gpu:
             x_t_new, y_t_new = x_t_new.cuda(), y_t_new.cuda()
         fantasy_model = self.get_fantasy_model(x_t_new, y_t_new)
diff --git a/qmcpy/util/torch_numpy_ops.py b/qmcpy/util/torch_numpy_ops.py
index 144e5719b..2f31c5bac 100644
--- a/qmcpy/util/torch_numpy_ops.py
+++ b/qmcpy/util/torch_numpy_ops.py
@@ -7,5 +7,6 @@ def get_npt(x):
     else:
         import torch
 
-        assert isinstance(x, torch.Tensor)
+        if not (isinstance(x, torch.Tensor)):
+            raise AssertionError
         return torch
diff --git a/qmcpy/util/transforms.py b/qmcpy/util/transforms.py
index 2c1ae0b22..3c0f929d2 100644
--- a/qmcpy/util/transforms.py
+++ b/qmcpy/util/transforms.py
@@ -89,35 +89,46 @@ def parse_assign_param(
             if not isinstance(param, npt.Tensor):
                 param = npt.tensor(param)
             param = npt.atleast_1d(param)
-            assert isinstance(param, npt.Tensor), (
-                "%s must be a scalar or torch.Tensor" % pname
-            )
+            if not (isinstance(param, npt.Tensor)):
+                raise AssertionError(
+                    "%s must be a scalar or torch.Tensor" % pname
+                )
         else:
             if not isinstance(param, npt.ndarray):
                 param = npt.array(param)
             param = npt.atleast_1d(param)
-            assert isinstance(param, npt.ndarray), (
-                "%s must be a scalar or np.ndarray" % pname
-            )
+            if not (isinstance(param, npt.ndarray)):
+                raise AssertionError(
+                    "%s must be a scalar or np.ndarray" % pname
+                )
     shape_param = list(param.shape)
-    assert len(shape_param) >= 1, "invalid shape_%s = %s" % (pname, str(shape_param))
-    assert len(tfs_param) == 2, "tfs_scale should be a tuple of length 2"
-    assert callable(tfs_param[0]), "tfs_scale[0] should be a callable e.g. torch.log"
-    assert callable(tfs_param[1]), "tfs_scale[1] should be a callable e.g. torch.exp"
+    if not (len(shape_param) >= 1):
+        raise AssertionError("invalid shape_%s = %s" % (pname, str(shape_param)))
+    if not (len(tfs_param) == 2):
+        raise AssertionError("tfs_scale should be a tuple of length 2")
+    if not (callable(tfs_param[0])):
+        raise AssertionError("tfs_scale[0] should be a callable e.g. torch.log")
+    if not (callable(tfs_param[1])):
+        raise AssertionError("tfs_scale[1] should be a callable e.g. torch.exp")
     raw_param = tfs_param[0](param)
     if torchify:
-        assert isinstance(requires_grad_param, bool)
+        if not (isinstance(requires_grad_param, bool)):
+            raise AssertionError
         if requires_grad_param:
             raw_param = 1.0 * raw_param
         raw_param = npt.nn.Parameter(raw_param, requires_grad=requires_grad_param)
-    assert shape_param[-1] in endsize_ops, "%s not in %s" % (
-        str(shape_param[-1]),
-        str(endsize_ops),
-    )
+    if not (shape_param[-1] in endsize_ops):
+        raise AssertionError("%s not in %s" % (
+            str(shape_param[-1]),
+            str(endsize_ops),
+        ))
     if "POSITIVE" in constraints:
-        assert (param > 0).all(), "%s must be positive" % pname
+        if not ((param > 0).all()):
+            raise AssertionError("%s must be positive" % pname)
     if "NON-NEGATIVE" in constraints:
-        assert (param >= 0).all(), "%s must be non-negative" % pname
+        if not ((param >= 0).all()):
+            raise AssertionError("%s must be non-negative" % pname)
     if "INTEGER" in constraints:
-        assert (param % 1 == 0).all(), "%s must be integers" % pname
+        if not ((param % 1 == 0).all()):
+            raise AssertionError("%s must be integers" % pname)
     return raw_param

From 130840c3af4d23f69fdbed8531cfcf7a0cbdcca2 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Tue, 8 Sep 2026 15:15:50 +0800
Subject: [PATCH 33/51] Enhanced Makefile

---
 makefile | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/makefile b/makefile
index a0d66d29f..cd1b841e7 100644
--- a/makefile
+++ b/makefile
@@ -659,10 +659,10 @@ format:
 	$(MAKE) convert_asserts_changed
 	@echo "---"
 	$(MAKE) add_docstring_arg_types_changed
-	# format_google_docstrings_changed deliberately NOT included: verified it
-	# strips Returns: types and collapses Args:/Warnings:/Raises: structure
-	# into run-on paragraphs on this codebase's actual docstrings -- tested
-	# on real files, reverted, not safe to run unattended (see git history).
+	@# format_google_docstrings_changed deliberately NOT included: verified it
+	@# strips Returns: types and collapses Args:/Warnings:/Raises: structure
+	@# into run-on paragraphs on this codebase's actual docstrings -- tested
+	@# on real files, reverted, not safe to run unattended (see git history).
 
 # Report-only: same conventions alltests.yml's "Check test-suite conventions"
 # step gates on, for running locally. Unlike `format`, nothing here writes to
@@ -675,6 +675,14 @@ check:
 	$(MAKE) check_baseline
 	@echo "---"
 	$(MAKE) check_asserts_changed
+	@echo "---"
+	$(MAKE) check_links
+	@# check_links_external deliberately NOT included: its own comment already
+	@# says "slow and network-flaky, run locally" -- not something `check`
+	@# should depend on. check_pep8_changed also deliberately excluded: 664
+	@# existing violations in currently-changed files would break `check`
+	@# immediately (same shape as F9/F10's docstring backlog; would need the
+	@# check_baseline ratchet, not a hard gate, if added later).
 
 flatten_qmcpy_imports:
 	$(PYTHON) scripts/flatten_qmcpy_imports.py

From 24299efd0b78a2635185a584f24ec67cb09ea2df Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Tue, 8 Sep 2026 15:38:18 +0800
Subject: [PATCH 34/51] Enhance docstrings

---
 qmcpy/discrete_distribution/mpmc/utils.py | 102 ++++++++++++++++++++++
 scripts/add_docstring_arg_types.py        |  94 ++++++++++++++++++--
 scripts/annotate_public_api_types.py      |  47 +++++++++-
 scripts/baseline_counts.json              |   4 +-
 scripts/convert_asserts.py                |  52 +++++++++--
 scripts/flatten_qmcpy_imports.py          |  35 ++++++--
 scripts/remove_trailing_whitespace.py     |  17 ++++
 scripts/unwrap_markdown.py                |  38 ++++++++
 test/test_sr_colab_notebooks.py           |  18 ++++
 9 files changed, 382 insertions(+), 25 deletions(-)

diff --git a/qmcpy/discrete_distribution/mpmc/utils.py b/qmcpy/discrete_distribution/mpmc/utils.py
index 1c311f937..9b684de97 100644
--- a/qmcpy/discrete_distribution/mpmc/utils.py
+++ b/qmcpy/discrete_distribution/mpmc/utils.py
@@ -23,6 +23,14 @@ def _sqrt_safe(v):
 # L2 STAR (Warnock)
 # ----------------------------
 def L2star(x: torch.Tensor) -> torch.Tensor:
+    """Warnock $L_2$ star discrepancy of each point set in a batch.
+
+    Args:
+        x (torch.Tensor): Points of shape ``(batch, N, d)`` with entries in $[0,1]$.
+
+    Returns:
+        torch.Tensor: Discrepancy of shape ``(batch,)``, one value per point set.
+    """
     _, N, d = _check_inputs(x)
     t1 = (1.0 / 3.0) ** d
     p = torch.prod(1.0 - x**2, dim=2)
@@ -33,6 +41,15 @@ def L2star(x: torch.Tensor) -> torch.Tensor:
     return _sqrt_safe(t1 - t2 + t3)
 
 def L2star_weighted(x: torch.Tensor, gamma: torch.Tensor) -> torch.Tensor:
+    """Coordinate-weighted $L_2$ star discrepancy of each point set in a batch.
+
+    Args:
+        x (torch.Tensor): Points of shape ``(batch, N, d)`` with entries in $[0,1]$.
+        gamma (torch.Tensor): Non-negative coordinate weights of shape ``(d,)``, one per dimension.
+
+    Returns:
+        torch.Tensor: Discrepancy of shape ``(batch,)``, one value per point set.
+    """
     _, N, d = _check_inputs(x, gamma)
     g = gamma
     t1 = torch.prod(1.0 + g / 3.0)
@@ -47,6 +64,14 @@ def L2star_weighted(x: torch.Tensor, gamma: torch.Tensor) -> torch.Tensor:
 # L2 EXTREME
 # -----------------------------------------
 def L2ext(x: torch.Tensor) -> torch.Tensor:
+    """$L_2$ extreme discrepancy of each point set in a batch.
+
+    Args:
+        x (torch.Tensor): Points of shape ``(batch, N, d)`` with entries in $[0,1]$.
+
+    Returns:
+        torch.Tensor: Discrepancy of shape ``(batch,)``, one value per point set.
+    """
     _, N, d = _check_inputs(x)
     t1 = (1.0 / 12.0) ** d
     p = torch.prod(0.5 * (x - x**2), dim=2)
@@ -57,6 +82,15 @@ def L2ext(x: torch.Tensor) -> torch.Tensor:
     return _sqrt_safe(t1 - t2 + t3)
 
 def L2ext_weighted(x: torch.Tensor, gamma: torch.Tensor) -> torch.Tensor:
+    """Coordinate-weighted $L_2$ extreme discrepancy of each point set in a batch.
+
+    Args:
+        x (torch.Tensor): Points of shape ``(batch, N, d)`` with entries in $[0,1]$.
+        gamma (torch.Tensor): Non-negative coordinate weights of shape ``(d,)``, one per dimension.
+
+    Returns:
+        torch.Tensor: Discrepancy of shape ``(batch,)``, one value per point set.
+    """
     _, N, d = _check_inputs(x, gamma)
     g = gamma
     t1 = torch.prod(1.0 + g / 12.0)
@@ -71,6 +105,14 @@ def L2ext_weighted(x: torch.Tensor, gamma: torch.Tensor) -> torch.Tensor:
 # L2 PERIODIC
 # -----------------------------------------
 def L2per(x: torch.Tensor) -> torch.Tensor:
+    """$L_2$ periodic discrepancy of each point set in a batch.
+
+    Args:
+        x (torch.Tensor): Points of shape ``(batch, N, d)`` with entries in $[0,1]$.
+
+    Returns:
+        torch.Tensor: Discrepancy of shape ``(batch,)``, one value per point set.
+    """
     _, N, d = _check_inputs(x)
     t1 = (1.0 / 3.0) ** d
     xi, xj = _pairwise(x)
@@ -80,6 +122,15 @@ def L2per(x: torch.Tensor) -> torch.Tensor:
     return _sqrt_safe(-t1 + t3)
 
 def L2per_weighted(x: torch.Tensor, gamma: torch.Tensor) -> torch.Tensor:
+    """Coordinate-weighted $L_2$ periodic discrepancy of each point set in a batch.
+
+    Args:
+        x (torch.Tensor): Points of shape ``(batch, N, d)`` with entries in $[0,1]$.
+        gamma (torch.Tensor): Non-negative coordinate weights of shape ``(d,)``, one per dimension.
+
+    Returns:
+        torch.Tensor: Discrepancy of shape ``(batch,)``, one value per point set.
+    """
     _, N, d = _check_inputs(x, gamma)
     g = gamma
     t1 = torch.prod(1.0 + g / 3.0)
@@ -93,6 +144,14 @@ def L2per_weighted(x: torch.Tensor, gamma: torch.Tensor) -> torch.Tensor:
 # L2 CENTERED
 # -----------------------------------------
 def L2ctr(x: torch.Tensor) -> torch.Tensor:
+    """$L_2$ centered discrepancy of each point set in a batch.
+
+    Args:
+        x (torch.Tensor): Points of shape ``(batch, N, d)`` with entries in $[0,1]$.
+
+    Returns:
+        torch.Tensor: Discrepancy of shape ``(batch,)``, one value per point set.
+    """
     _, N, d = _check_inputs(x)
     t1 = (1.0 / 12.0) ** d
     u = torch.abs(x - 0.5)
@@ -104,6 +163,15 @@ def L2ctr(x: torch.Tensor) -> torch.Tensor:
     return _sqrt_safe(t1 - t2 + t3)
 
 def L2ctr_weighted(x: torch.Tensor, gamma: torch.Tensor) -> torch.Tensor:
+    """Coordinate-weighted $L_2$ centered discrepancy of each point set in a batch.
+
+    Args:
+        x (torch.Tensor): Points of shape ``(batch, N, d)`` with entries in $[0,1]$.
+        gamma (torch.Tensor): Non-negative coordinate weights of shape ``(d,)``, one per dimension.
+
+    Returns:
+        torch.Tensor: Discrepancy of shape ``(batch,)``, one value per point set.
+    """
     _, N, d = _check_inputs(x, gamma)
     g = gamma
     t1 = torch.prod(1.0 + g / 12.0)
@@ -119,6 +187,14 @@ def L2ctr_weighted(x: torch.Tensor, gamma: torch.Tensor) -> torch.Tensor:
 # L2 SYMMETRIC
 # -----------------------------------------
 def L2sym(x: torch.Tensor) -> torch.Tensor:
+    """$L_2$ symmetric discrepancy of each point set in a batch.
+
+    Args:
+        x (torch.Tensor): Points of shape ``(batch, N, d)`` with entries in $[0,1]$.
+
+    Returns:
+        torch.Tensor: Discrepancy of shape ``(batch,)``, one value per point set.
+    """
     _, N, d = _check_inputs(x)
     t1 = (1.0 / 12.0) ** d
     p = torch.prod(0.5 * (x - x**2), dim=2)
@@ -129,6 +205,15 @@ def L2sym(x: torch.Tensor) -> torch.Tensor:
     return _sqrt_safe(t1 - t2 + t3)
 
 def L2sym_weighted(x: torch.Tensor, gamma: torch.Tensor) -> torch.Tensor:
+    """Coordinate-weighted $L_2$ symmetric discrepancy of each point set in a batch.
+
+    Args:
+        x (torch.Tensor): Points of shape ``(batch, N, d)`` with entries in $[0,1]$.
+        gamma (torch.Tensor): Non-negative coordinate weights of shape ``(d,)``, one per dimension.
+
+    Returns:
+        torch.Tensor: Discrepancy of shape ``(batch,)``, one value per point set.
+    """
     _, N, d = _check_inputs(x, gamma)
     g = gamma
     t1 = torch.prod(1.0 + g / 12.0)
@@ -143,6 +228,14 @@ def L2sym_weighted(x: torch.Tensor, gamma: torch.Tensor) -> torch.Tensor:
 # L2 MIXTURE
 # -----------------------------------------
 def L2mix(x: torch.Tensor) -> torch.Tensor:
+    """$L_2$ mixture discrepancy of each point set in a batch.
+
+    Args:
+        x (torch.Tensor): Points of shape ``(batch, N, d)`` with entries in $[0,1]$.
+
+    Returns:
+        torch.Tensor: Discrepancy of shape ``(batch,)``, one value per point set.
+    """
     _, N, d = _check_inputs(x)
     t1 = (7.0 / 12.0) ** d
     u = x - 0.5
@@ -156,6 +249,15 @@ def L2mix(x: torch.Tensor) -> torch.Tensor:
     return _sqrt_safe(t1 - t2 + t3)
 
 def L2mix_weighted(x: torch.Tensor, gamma: torch.Tensor) -> torch.Tensor:
+    """Coordinate-weighted $L_2$ mixture discrepancy of each point set in a batch.
+
+    Args:
+        x (torch.Tensor): Points of shape ``(batch, N, d)`` with entries in $[0,1]$.
+        gamma (torch.Tensor): Non-negative coordinate weights of shape ``(d,)``, one per dimension.
+
+    Returns:
+        torch.Tensor: Discrepancy of shape ``(batch,)``, one value per point set.
+    """
     _, N, d = _check_inputs(x, gamma)
     g = gamma
     t1 = torch.prod(1.0 + (7.0 / 12.0) * g)
diff --git a/scripts/add_docstring_arg_types.py b/scripts/add_docstring_arg_types.py
index f26a376fb..a2de4c299 100644
--- a/scripts/add_docstring_arg_types.py
+++ b/scripts/add_docstring_arg_types.py
@@ -68,7 +68,14 @@ class FileResult:
 
 
 def doc_node(node: ast.AST) -> ast.Constant | None:
-    """Return the string-literal node holding ``node``'s docstring, if any."""
+    """Return the string-literal node holding ``node``'s docstring, if any.
+
+    Args:
+        node (ast.AST): Node whose docstring literal is wanted.
+
+    Returns:
+        ast.Constant | None: The docstring node, or ``None`` when absent.
+    """
     body = getattr(node, "body", None)
     if (
         body
@@ -81,7 +88,14 @@ def doc_node(node: ast.AST) -> ast.Constant | None:
 
 
 def iter_public_functions(tree: ast.Module):
-    """Yield public module functions and methods from public classes."""
+    """Yield public module functions and methods from public classes.
+
+    Args:
+        tree (ast.Module): Parsed module to walk.
+
+    Yields:
+        ast.FunctionDef | ast.AsyncFunctionDef: Each public function or method.
+    """
     for node in tree.body:
         if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
             if not node.name.startswith("_"):
@@ -145,7 +159,14 @@ def _argument_annotations(node: ast.FunctionDef | ast.AsyncFunctionDef, source:
 
 
 def line_without_ending(line: str) -> tuple[str, str]:
-    """Split a line into content and original line ending."""
+    """Split a line into content and original line ending.
+
+    Args:
+        line (str): Source line, with or without a line ending.
+
+    Returns:
+        tuple[str, str]: The content and the line ending that was removed.
+    """
     if line.endswith("\r\n"):
         return line[:-2], "\r\n"
     if line.endswith("\n"):
@@ -156,7 +177,18 @@ def line_without_ending(line: str) -> tuple[str, str]:
 def find_section(
     lines: list[str], start: int, end: int, name: str
 ) -> tuple[int, int] | None:
-    """Return the header and end indexes for a Google-style section."""
+    """Return the header and end indexes for a Google-style section.
+
+    Args:
+        lines (list[str]): Docstring lines to search.
+        start (int): First index to consider.
+        end (int): Index one past the last to consider.
+        name (str): Section header to look for, such as ``"Args"``.
+
+    Returns:
+        tuple[int, int] | None: Header and end indexes, or ``None`` when the
+        section is absent.
+    """
     header_line = None
     header_indent = None
     for i in range(start, end + 1):
@@ -184,7 +216,17 @@ def find_section(
 def find_args_section(
     lines: list[str], start: int, end: int
 ) -> tuple[int, int] | None:
-    """Return ``(args_line, section_end)`` indexes for a Google Args section."""
+    """Return ``(args_line, section_end)`` indexes for a Google Args section.
+
+    Args:
+        lines (list[str]): Docstring lines to search.
+        start (int): First index to consider.
+        end (int): Index one past the last to consider.
+
+    Returns:
+        tuple[int, int] | None: Header and end indexes, or ``None`` when there
+        is no Args section.
+    """
     return find_section(lines, start, end, "Args")
 
 
@@ -216,7 +258,14 @@ def _yield_annotation_text(source: str, annotation: ast.AST) -> str | None:
 
 
 def looks_like_type(text: str) -> bool:
-    """Return whether text is syntactically usable as a type expression."""
+    """Return whether text is syntactically usable as a type expression.
+
+    Args:
+        text (str): Candidate type expression.
+
+    Returns:
+        bool: Whether ``text`` parses as a Python expression.
+    """
     try:
         ast.parse(text, mode="eval")
     except SyntaxError:
@@ -369,7 +418,18 @@ def update_file(
     overwrite_existing: bool = False,
     include_outputs: bool = False,
 ) -> FileResult:
-    """Update Google-style types in one Python file."""
+    """Update Google-style types in one Python file.
+
+    Args:
+        path (Path): Python file to update.
+        check (bool): Report what would change without writing.
+        overwrite_existing (bool): Replace types already present rather than only
+            filling in missing ones.
+        include_outputs (bool): Also update the Returns section.
+
+    Returns:
+        FileResult: Counts of updates made and entries skipped.
+    """
     source = path.read_text(encoding="utf-8")
     tree = ast.parse(source, filename=str(path))
     lines = source.splitlines(keepends=True)
@@ -458,7 +518,16 @@ def _is_under(path: Path, root: Path) -> bool:
 def python_files(
     paths: list[str], diff_ref: str | None, root: str | None = None
 ) -> list[Path]:
-    """Collect Python files from paths, or from ``git diff`` when requested."""
+    """Collect Python files from paths, or from ``git diff`` when requested.
+
+    Args:
+        paths (list[str]): Files or directories to collect from.
+        diff_ref (str | None): Git ref to diff against instead of using ``paths``.
+        root (str | None): Repository root for the diff; defaults to the cwd.
+
+    Returns:
+        list[Path]: Python files to process, in sorted order.
+    """
     if diff_ref is not None:
         candidates = _changed_files(diff_ref)
     else:
@@ -518,7 +587,14 @@ def _parse_args(argv: list[str]) -> argparse.Namespace:
 
 
 def main(argv: list[str]) -> int:
-    """Run the command-line interface."""
+    """Run the command-line interface.
+
+    Args:
+        argv (list[str]): Command-line arguments, excluding the program name.
+
+    Returns:
+        int: Process exit status; ``0`` on success.
+    """
     args = _parse_args(argv)
     try:
         files = python_files(args.paths, args.diff, root=args.root)
diff --git a/scripts/annotate_public_api_types.py b/scripts/annotate_public_api_types.py
index a24de4711..e3a00271a 100644
--- a/scripts/annotate_public_api_types.py
+++ b/scripts/annotate_public_api_types.py
@@ -446,6 +446,13 @@ class PublicAPIAnnotationTransformer(cst.CSTTransformer):
     METADATA_DEPENDENCIES = (PositionProvider,)
 
     def __init__(self, path: Path, specs: dict[tuple[int, str], FunctionSpec]):
+        """Record the file and the annotations to apply.
+
+        Args:
+            path (Path): File being transformed, used in diagnostics.
+            specs (dict[tuple[int, str], FunctionSpec]): Annotation specification keyed
+                by ``(line number, function name)``.
+        """
         self.path = path
         self.specs = specs
         self.updates: list[Update] = []
@@ -510,7 +517,16 @@ def leave_FunctionDef(
         original_node: cst.FunctionDef,
         updated_node: cst.FunctionDef,
     ) -> cst.FunctionDef:
-        """Update an eligible function or method signature."""
+        """Update an eligible function or method signature.
+
+        Args:
+            original_node (cst.FunctionDef): Node before any child updates.
+            updated_node (cst.FunctionDef): Node with child updates already applied.
+
+        Returns:
+            cst.FunctionDef: The annotated node, or ``updated_node`` unchanged when
+            the function is not eligible.
+        """
         line = self.get_metadata(PositionProvider, original_node.name).start.line
         spec = self.specs.get((line, original_node.name.value))
         if spec is None:
@@ -595,7 +611,15 @@ def leave_FunctionDef(
 
 
 def transform_source(source: str, path: Path = Path("<memory>")) -> SourceResult:
-    """Annotate one source string without writing it."""
+    """Annotate one source string without writing it.
+
+    Args:
+        source (str): Python source to annotate.
+        path (Path): Path reported in diagnostics.
+
+    Returns:
+        SourceResult: Annotated source together with updates and conflicts.
+    """
     specs, skips = _collect_specs(source, path)
     module = cst.parse_module(source)
     transformer = PublicAPIAnnotationTransformer(path, specs)
@@ -610,7 +634,15 @@ def transform_source(source: str, path: Path = Path("<memory>")) -> SourceResult
 
 
 def update_file(path: Path, check: bool = False) -> FileResult:
-    """Annotate one Python file."""
+    """Annotate one Python file.
+
+    Args:
+        path (Path): Python file to annotate.
+        check (bool): Report what would change without writing.
+
+    Returns:
+        FileResult: Whether the file changed, and the updates and conflicts found.
+    """
     source = path.read_text(encoding="utf-8")
     result = transform_source(source, path=path)
     changed = result.source != source
@@ -658,7 +690,14 @@ def _parse_args(argv: list[str]) -> argparse.Namespace:
 
 
 def main(argv: list[str]) -> int:
-    """Run the command-line interface."""
+    """Run the command-line interface.
+
+    Args:
+        argv (list[str]): Command-line arguments, excluding the program name.
+
+    Returns:
+        int: Process exit status; ``0`` on success.
+    """
     args = _parse_args(argv)
     try:
         files = docstrings.python_files(args.paths, args.diff, root=args.root)
diff --git a/scripts/baseline_counts.json b/scripts/baseline_counts.json
index b1c86be78..1c3d6496a 100644
--- a/scripts/baseline_counts.json
+++ b/scripts/baseline_counts.json
@@ -1,5 +1,5 @@
 {
-  "check_docstring": 260,
-  "pydoclint": 135,
+  "check_docstring": 248,
+  "pydoclint": 147,
   "unsafe_annotations": 109
 }
diff --git a/scripts/convert_asserts.py b/scripts/convert_asserts.py
index cab1c7e6d..12b3e6d8a 100644
--- a/scripts/convert_asserts.py
+++ b/scripts/convert_asserts.py
@@ -91,12 +91,21 @@ class ConvertAssertTransformer(cst.CSTTransformer):
     METADATA_DEPENDENCIES = (PositionProvider,)
 
     def __init__(self, exception: str):
+        """Record the exception to raise in place of each assertion.
+
+        Args:
+            exception (str): Exception expression to raise, such as ``"AssertionError"``.
+        """
         self.exception = cst.parse_expression(exception)
         self.seen_lines = []
         self.converted_lines = []
 
     def visit_Assert(self, node: cst.Assert) -> None:
-        """Record every assertion, including forms that cannot be rewritten."""
+        """Record every assertion, including forms that cannot be rewritten.
+
+        Args:
+            node (cst.Assert): Assertion encountered in the tree.
+        """
         position = self.get_metadata(PositionProvider, node)
         self.seen_lines.append(position.start.line)
 
@@ -105,7 +114,16 @@ def leave_SimpleStatementLine(
         original_node: cst.SimpleStatementLine,
         updated_node: cst.SimpleStatementLine,
     ) -> cst.BaseStatement:
-        """Rewrite an assert when it is the line's only small statement."""
+        """Rewrite an assert when it is the line's only small statement.
+
+        Args:
+            original_node (cst.SimpleStatementLine): Node before any child updates.
+            updated_node (cst.SimpleStatementLine): Node with child updates applied.
+
+        Returns:
+            cst.BaseStatement: The rewritten statement, or ``updated_node`` unchanged
+            when the line holds more than the assertion.
+        """
         if len(updated_node.body) != 1:
             return updated_node
         assertion = updated_node.body[0]
@@ -139,7 +157,15 @@ def leave_SimpleStatementLine(
 
 
 def transform_source(source: str, exception: str = "AssertionError") -> SourceResult:
-    """Transform standalone assertions in a Python source string."""
+    """Transform standalone assertions in a Python source string.
+
+    Args:
+        source (str): Python source to transform.
+        exception (str): Exception expression to raise in place of each assertion.
+
+    Returns:
+        SourceResult: Transformed source with the lines seen and converted.
+    """
     _validate_exception(exception)
     module = cst.parse_module(source)
     transformer = ConvertAssertTransformer(exception)
@@ -164,7 +190,16 @@ def convert_file(
     exception: str = "AssertionError",
     check: bool = False,
 ) -> FileResult:
-    """Convert assertions in one Python file."""
+    """Convert assertions in one Python file.
+
+    Args:
+        path (Path): Python file to convert.
+        exception (str): Exception expression to raise in place of each assertion.
+        check (bool): Report what would change without writing.
+
+    Returns:
+        FileResult: Whether the file changed, and the conversion counts.
+    """
     source = path.read_text(encoding="utf-8")
     result = transform_source(source, exception=exception)
     changed = result.source != source
@@ -257,7 +292,14 @@ def _parse_args(argv: list[str]) -> argparse.Namespace:
 
 
 def main(argv: list[str]) -> int:
-    """Run the command-line interface."""
+    """Run the command-line interface.
+
+    Args:
+        argv (list[str]): Command-line arguments, excluding the program name.
+
+    Returns:
+        int: Process exit status; ``0`` on success.
+    """
     args = _parse_args(argv)
     try:
         _validate_exception(args.exception)
diff --git a/scripts/flatten_qmcpy_imports.py b/scripts/flatten_qmcpy_imports.py
index f48a5cbd1..33503e3a7 100644
--- a/scripts/flatten_qmcpy_imports.py
+++ b/scripts/flatten_qmcpy_imports.py
@@ -747,10 +747,19 @@ def flatten_imports(
 ) -> tuple[bytes, int]:
     """Flatten, combine, alphabetize, and deduplicate public imports.
 
-    `public_names` is qmcpy's public API surface (see `_load_qmcpy_public_names`).
-    When it's None, nested imports are left unchanged and existing top-level
-    star imports are deduplicated but left unexpanded. `protect_python` should
-    be true for Python files so strings and comments are never rewritten.
+        `public_names` is qmcpy's public API surface (see `_load_qmcpy_public_names`).
+        When it's None, nested imports are left unchanged and existing top-level
+        star imports are deduplicated but left unexpanded. `protect_python` should
+        be true for Python files so strings and comments are never rewritten.
+
+    Args:
+        content (bytes): File contents to rewrite.
+        public_names (frozenset[str] | None): Names treated as public; defaults to
+            the package's own public API.
+        protect_python (bool): Leave imports inside Python code blocks untouched.
+
+    Returns:
+        bytes: The rewritten contents, unchanged when nothing needed flattening.
     """
 
     change_count = 0
@@ -832,7 +841,14 @@ def _is_supported(path: Path) -> bool:
 
 
 def iter_target_files(paths: Iterable[Path]) -> Iterator[Path]:
-    """Yield supported files under paths, pruning generated and cache directories."""
+    """Yield supported files under paths, pruning generated and cache directories.
+
+    Args:
+        paths (Iterable[Path]): Files or directories to walk.
+
+    Yields:
+        Path: Each supported file, skipping generated and cache directories.
+    """
 
     seen: set[Path] = set()
     for path in paths:
@@ -876,6 +892,15 @@ def _display_path(path: Path, base: Path) -> Path:
 
 
 def main(argv: list[str] | None = None) -> int:
+    """Run the command-line interface.
+
+    Args:
+        argv (list[str] | None): Command-line arguments, excluding the program
+            name; defaults to ``sys.argv[1:]``.
+
+    Returns:
+        int: Process exit status; ``0`` on success.
+    """
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument(
         "--check",
diff --git a/scripts/remove_trailing_whitespace.py b/scripts/remove_trailing_whitespace.py
index bbdc65f58..5a158137d 100644
--- a/scripts/remove_trailing_whitespace.py
+++ b/scripts/remove_trailing_whitespace.py
@@ -38,6 +38,14 @@
 
 
 def iter_source_files(paths: list[str]) -> list[Path]:
+    """Collect the tracked and untracked files eligible for whitespace cleanup.
+
+    Args:
+        paths (list[str]): Files or directories to restrict the search to.
+
+    Returns:
+        list[Path]: Sorted regular files with a supported name or suffix.
+    """
     command = [
         "git",
         "ls-files",
@@ -105,6 +113,15 @@ def _strip_python_source(original: bytes) -> bytes:
 
 
 def remove_trailing_whitespace(path: Path, check: bool) -> bool:
+    """Strip trailing whitespace from one file.
+
+    Args:
+        path (Path): File to process; binary files are left untouched.
+        check (bool): Report whether the file would change without writing.
+
+    Returns:
+        bool: Whether the file changed, or would change under ``check``.
+    """
     original = path.read_bytes()
     if b"\0" in original:
         return False
diff --git a/scripts/unwrap_markdown.py b/scripts/unwrap_markdown.py
index b02004c8f..49d8b3be3 100755
--- a/scripts/unwrap_markdown.py
+++ b/scripts/unwrap_markdown.py
@@ -24,6 +24,15 @@
 
 
 def iter_targets(paths: list[str]) -> tuple[list[Path], list[str]]:
+    """Collect the Markdown and notebook files to process.
+
+    Args:
+        paths (list[str]): Files or directories to walk.
+
+    Returns:
+        tuple[list[Path], list[str]]: The files found and a message for each path
+        that was missing or of an unsupported type.
+    """
     files: list[Path] = []
     errors: list[str] = []
     for raw_path in paths:
@@ -92,6 +101,17 @@ def _paragraph_has_latex(lines: list[str]) -> bool:
 
 
 def unwrap_markdown_text(text: str, *, preserve_latex: bool = False) -> str:
+    """Join each Markdown paragraph onto a single line.
+
+    Code fences, and optionally display-math blocks, are passed through unchanged.
+
+    Args:
+        text (str): Markdown source to unwrap.
+        preserve_latex (bool): Leave display-math blocks unwrapped.
+
+    Returns:
+        str: The unwrapped text, preserving the original line ending style.
+    """
     if not text:
         return text
 
@@ -232,6 +252,15 @@ def _split_notebook_source(text: str) -> list[str]:
 
 
 def process_markdown_file(path: Path, check: bool) -> bool:
+    """Unwrap the paragraphs of one Markdown file.
+
+    Args:
+        path (Path): Markdown file to process.
+        check (bool): Report whether the file would change without writing.
+
+    Returns:
+        bool: Whether the file changed, or would change under ``check``.
+    """
     original = path.read_text(encoding="utf-8")
     updated = unwrap_markdown_text(original, preserve_latex=True)
     changed = updated != original
@@ -241,6 +270,15 @@ def process_markdown_file(path: Path, check: bool) -> bool:
 
 
 def process_notebook(path: Path, check: bool) -> tuple[bool, int]:
+    """Unwrap the paragraphs of every Markdown cell in one notebook.
+
+    Args:
+        path (Path): Notebook file to process.
+        check (bool): Report whether the notebook would change without writing.
+
+    Returns:
+        tuple[bool, int]: Whether the notebook changed, and how many cells changed.
+    """
     with path.open(encoding="utf-8") as handle:
         notebook = json.load(handle)
 
diff --git a/test/test_sr_colab_notebooks.py b/test/test_sr_colab_notebooks.py
index 32548d2f9..f23bdd49e 100644
--- a/test/test_sr_colab_notebooks.py
+++ b/test/test_sr_colab_notebooks.py
@@ -15,6 +15,15 @@
 
 
 def markdown_cell(source: str, cell_id: str = "markdown") -> dict:
+    """Build a minimal notebook Markdown cell.
+
+    Args:
+        source (str): Cell source text.
+        cell_id (str): Notebook cell identifier.
+
+    Returns:
+        dict: A Markdown cell in nbformat 4 shape.
+    """
     return {
         "cell_type": "markdown",
         "id": cell_id,
@@ -24,6 +33,15 @@ def markdown_cell(source: str, cell_id: str = "markdown") -> dict:
 
 
 def code_cell(source: str, cell_id: str = "code") -> dict:
+    """Build a minimal notebook code cell.
+
+    Args:
+        source (str): Cell source text.
+        cell_id (str): Notebook cell identifier.
+
+    Returns:
+        dict: A code cell in nbformat 4 shape, with no outputs.
+    """
     return {
         "cell_type": "code",
         "execution_count": None,

From 04a12ac8034e8bb9d1e565809f8f2e8275e4be13 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Tue, 8 Sep 2026 15:44:40 +0800
Subject: [PATCH 35/51] Better docstrings

---
 .../digital_net_any_bases.py                      |  3 ++-
 .../digital_net_any_bases/hammersley.py           |  3 ++-
 .../digital_net_b2/digital_net_b2.py              |  3 ++-
 qmcpy/discrete_distribution/iid_std_uniform.py    |  3 ++-
 qmcpy/discrete_distribution/korobov.py            |  3 ++-
 qmcpy/discrete_distribution/kronecker.py          |  3 ++-
 qmcpy/discrete_distribution/latin_hypercube.py    |  3 ++-
 qmcpy/discrete_distribution/lattice/lattice.py    |  3 ++-
 qmcpy/integrand/abstract_integrand.py             |  3 ++-
 qmcpy/integrand/bayesian_lr_coeffs.py             |  3 ++-
 qmcpy/integrand/box_integral.py                   |  3 ++-
 qmcpy/integrand/custom_fun.py                     |  3 ++-
 qmcpy/integrand/financial_option.py               |  3 ++-
 qmcpy/integrand/fourbranch2d.py                   |  3 ++-
 qmcpy/integrand/genz.py                           |  3 ++-
 qmcpy/integrand/hartmann6d.py                     |  3 ++-
 qmcpy/integrand/ishigami.py                       |  3 ++-
 qmcpy/integrand/keister.py                        |  3 ++-
 qmcpy/integrand/linear0.py                        |  3 ++-
 qmcpy/integrand/multimodal2d.py                   |  3 ++-
 qmcpy/integrand/sensitivity_indices.py            |  3 ++-
 qmcpy/integrand/sin1d.py                          |  3 ++-
 qmcpy/integrand/umbridge_wrapper.py               |  3 ++-
 qmcpy/kernel/abstract_kernel.py                   |  3 ++-
 qmcpy/kernel/common_kernels.py                    |  3 ++-
 qmcpy/kernel/multitask_kernel.py                  |  3 ++-
 qmcpy/kernel/si_dsi_kernels.py                    | 15 ++++++++++-----
 qmcpy/stopping_criterion/cub_mc_clt.py            |  3 ++-
 qmcpy/stopping_criterion/cub_mc_clt_vec.py        |  3 ++-
 qmcpy/stopping_criterion/cub_mc_g.py              |  3 ++-
 qmcpy/stopping_criterion/cub_mlmc.py              |  3 ++-
 qmcpy/stopping_criterion/cub_mlmc_cont.py         |  3 ++-
 qmcpy/stopping_criterion/cub_mlqmc.py             |  3 ++-
 qmcpy/stopping_criterion/cub_mlqmc_cont.py        |  3 ++-
 .../stopping_criterion/cub_qmc_bayes_lattice_g.py |  3 ++-
 qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py   |  3 ++-
 qmcpy/stopping_criterion/cub_qmc_lattice_g.py     |  3 ++-
 qmcpy/stopping_criterion/cub_qmc_net_g.py         |  3 ++-
 qmcpy/stopping_criterion/cub_qmc_rep_student_t.py |  3 ++-
 qmcpy/stopping_criterion/pf_gp_ci.py              |  3 ++-
 qmcpy/true_measure/bernoulli_cont.py              |  3 ++-
 qmcpy/true_measure/brownian_motion.py             |  3 ++-
 qmcpy/true_measure/clayton_copula.py              |  3 ++-
 qmcpy/true_measure/frank_copula.py                |  3 ++-
 qmcpy/true_measure/gaussian.py                    |  3 ++-
 qmcpy/true_measure/gaussian_copula.py             |  3 ++-
 qmcpy/true_measure/geometric_brownian_motion.py   |  3 ++-
 qmcpy/true_measure/gumbel_copula.py               |  3 ++-
 qmcpy/true_measure/johnsons_su.py                 |  3 ++-
 qmcpy/true_measure/kumaraswamy.py                 |  3 ++-
 qmcpy/true_measure/lebesgue.py                    |  3 ++-
 qmcpy/true_measure/matern_gp.py                   |  3 ++-
 qmcpy/true_measure/student_t_copula.py            |  3 ++-
 qmcpy/true_measure/uniform.py                     |  3 ++-
 qmcpy/util/latnetbuilder_linker.py                |  3 ++-
 qmcpy/util/plot_functions.py                      |  3 ++-
 scripts/baseline_counts.json                      |  4 ++--
 57 files changed, 122 insertions(+), 62 deletions(-)

diff --git a/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py b/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py
index c2789d85d..331fe4d64 100644
--- a/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py
+++ b/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py
@@ -166,7 +166,8 @@ def __init__(self,
                  alpha: int = 1,
                  n_lim: int = 2**32,
                  warn: bool = True) -> None:
-        r"""
+        r"""Initialize a DigitalNetAnyBases discrete distribution.
+
         Args:
             dimension (Union[int,np.ndarray]): Dimension of the generator.
 
diff --git a/qmcpy/discrete_distribution/digital_net_any_bases/hammersley.py b/qmcpy/discrete_distribution/digital_net_any_bases/hammersley.py
index d7dffa371..505e4fbae 100644
--- a/qmcpy/discrete_distribution/digital_net_any_bases/hammersley.py
+++ b/qmcpy/discrete_distribution/digital_net_any_bases/hammersley.py
@@ -72,7 +72,8 @@ def __init__(self,
                  n_lim: int = 2**32,
                  warn = True
                 ) -> None:
-        r"""
+        r"""Initialize a Hammersley discrete distribution.
+
         Args:
             dimension (int): Dimension of the samples. Must be a scalar `int`
                 (unlike `Halton`, an array of indices is not supported -- see
diff --git a/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py b/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
index 162f7006f..329f9e3b1 100644
--- a/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
+++ b/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
@@ -230,7 +230,8 @@ def __init__(
         t_max=None,
         t_lms=None,
     ) -> None:
-        r"""
+        r"""Initialize a DigitalNetB2 discrete distribution.
+
         Args:
             dimension (Union[int, np.ndarray]): Dimension of the generator.
 
diff --git a/qmcpy/discrete_distribution/iid_std_uniform.py b/qmcpy/discrete_distribution/iid_std_uniform.py
index c83e10fa5..77805ad0a 100644
--- a/qmcpy/discrete_distribution/iid_std_uniform.py
+++ b/qmcpy/discrete_distribution/iid_std_uniform.py
@@ -50,7 +50,8 @@ class IIDStdUniform(AbstractIIDDiscreteDistribution):
     """
 
     def __init__(self, dimension: int = 1, replications=None, seed=None) -> None:
-        r"""
+        r"""Initialize an IIDStdUniform discrete distribution.
+
         Args:
             dimension (int): Dimension of the samples.
             replications (Union[None, int]): Number of randomizations. This is
diff --git a/qmcpy/discrete_distribution/korobov.py b/qmcpy/discrete_distribution/korobov.py
index aa14b92f1..b04554764 100644
--- a/qmcpy/discrete_distribution/korobov.py
+++ b/qmcpy/discrete_distribution/korobov.py
@@ -142,7 +142,8 @@ def __init__(
             seed=None,
             randomize: str = "SHIFT",
         ) -> None:
-        r"""
+        r"""Initialize a KorobovLattice discrete distribution.
+
         Args:
             dimension (int): Dimension of the samples. Must be between 1 and
                 250 (the range covered by the precomputed table).
diff --git a/qmcpy/discrete_distribution/kronecker.py b/qmcpy/discrete_distribution/kronecker.py
index fec80af88..ddd03b1f3 100644
--- a/qmcpy/discrete_distribution/kronecker.py
+++ b/qmcpy/discrete_distribution/kronecker.py
@@ -226,7 +226,8 @@ def __init__(self,
         shift: np.ndarray = None,
         warn: bool = True,
     ) -> None:
-        r"""
+        r"""Initialize a Kronecker discrete distribution.
+
         Args:
             dimension (Union[int, np.ndarray]): Dimension of the generator.
 
diff --git a/qmcpy/discrete_distribution/latin_hypercube.py b/qmcpy/discrete_distribution/latin_hypercube.py
index 4303cbbf1..3dac43e57 100644
--- a/qmcpy/discrete_distribution/latin_hypercube.py
+++ b/qmcpy/discrete_distribution/latin_hypercube.py
@@ -97,7 +97,8 @@ class LatinHypercube(AbstractDiscreteDistribution):
     def __init__(
             self, dimension: int, replications, seed, randomize: str = "TRUE"
             ) -> None:
-        r"""
+        r"""Initialize a LatinHypercube discrete distribution.
+
         Args:
             dimension (int): Dimension of the samples.
 
diff --git a/qmcpy/discrete_distribution/lattice/lattice.py b/qmcpy/discrete_distribution/lattice/lattice.py
index 8be3600c6..3eb1efb9b 100644
--- a/qmcpy/discrete_distribution/lattice/lattice.py
+++ b/qmcpy/discrete_distribution/lattice/lattice.py
@@ -148,7 +148,8 @@ def __init__(
         order: str = "RADICAL INVERSE",
         m_max: int = None,
     ) -> None:
-        r"""
+        r"""Initialize a Lattice discrete distribution.
+
         Args:
             dimension (Union[int, np.ndarray]): Dimension of the generator.
 
diff --git a/qmcpy/integrand/abstract_integrand.py b/qmcpy/integrand/abstract_integrand.py
index ddf290bb8..f9da42928 100644
--- a/qmcpy/integrand/abstract_integrand.py
+++ b/qmcpy/integrand/abstract_integrand.py
@@ -13,7 +13,8 @@
 class AbstractIntegrand(object):
 
     def __init__(self, dimension_indv: tuple, dimension_comb: tuple, parallel: int, threadpool: bool = False) -> None:
-        r"""
+        r"""Initialize an AbstractIntegrand integrand.
+
         Args:
             dimension_indv (tuple): Individual solution shape.
             dimension_comb (tuple): Combined solution shape.
diff --git a/qmcpy/integrand/bayesian_lr_coeffs.py b/qmcpy/integrand/bayesian_lr_coeffs.py
index fc01433b2..0d6703c8e 100644
--- a/qmcpy/integrand/bayesian_lr_coeffs.py
+++ b/qmcpy/integrand/bayesian_lr_coeffs.py
@@ -35,7 +35,8 @@ class BayesianLRCoeffs(AbstractIntegrand):
     def __init__(
         self, sampler, feature_array: np.ndarray, response_vector: np.ndarray, prior_mean: np.ndarray = 0, prior_covariance: np.ndarray = 10
     ) -> None:
-        r"""
+        r"""Initialize a BayesianLRCoeffs integrand.
+
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
                 Either
diff --git a/qmcpy/integrand/box_integral.py b/qmcpy/integrand/box_integral.py
index b13719938..bfc24a1d0 100644
--- a/qmcpy/integrand/box_integral.py
+++ b/qmcpy/integrand/box_integral.py
@@ -65,7 +65,8 @@ class BoxIntegral(AbstractIntegrand):
     """
 
     def __init__(self, sampler, s=1) -> None:
-        r"""
+        r"""Initialize a BoxIntegral integrand.
+
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
                 Either
diff --git a/qmcpy/integrand/custom_fun.py b/qmcpy/integrand/custom_fun.py
index 19ff3d223..f888e6828 100644
--- a/qmcpy/integrand/custom_fun.py
+++ b/qmcpy/integrand/custom_fun.py
@@ -89,7 +89,8 @@ class CustomFun(AbstractIntegrand):
     """
 
     def __init__(self, true_measure, g, dimension_indv: tuple = (), parallel: int = False) -> None:
-        """
+        """Initialize a CustomFun integrand.
+
         Args:
             true_measure (AbstractTrueMeasure): The true measure.
             g (callable): A function handle.
diff --git a/qmcpy/integrand/financial_option.py b/qmcpy/integrand/financial_option.py
index 9cefa5001..67475cebc 100644
--- a/qmcpy/integrand/financial_option.py
+++ b/qmcpy/integrand/financial_option.py
@@ -255,7 +255,8 @@ def __init__(
         barrier_price: float = 38,
         digital_payout: float = 10,
     ) -> None:
-        r"""
+        r"""Initialize a FinancialOption integrand.
+
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
                 Either
diff --git a/qmcpy/integrand/fourbranch2d.py b/qmcpy/integrand/fourbranch2d.py
index fb5f60515..ba950b5f0 100644
--- a/qmcpy/integrand/fourbranch2d.py
+++ b/qmcpy/integrand/fourbranch2d.py
@@ -45,7 +45,8 @@ class FourBranch2d(AbstractIntegrand):
     """
 
     def __init__(self, sampler) -> None:
-        r"""
+        r"""Initialize a FourBranch2d integrand.
+
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
                 Either
diff --git a/qmcpy/integrand/genz.py b/qmcpy/integrand/genz.py
index 6e86966fb..b76759e35 100644
--- a/qmcpy/integrand/genz.py
+++ b/qmcpy/integrand/genz.py
@@ -55,7 +55,8 @@ class Genz(AbstractIntegrand):
     """
 
     def __init__(self, sampler, kind_func: str = "OSCILLATORY", kind_coeff: int = 1) -> None:
-        """
+        """Initialize a Genz integrand.
+
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
                 Either
diff --git a/qmcpy/integrand/hartmann6d.py b/qmcpy/integrand/hartmann6d.py
index b5a9a4a1c..413916a86 100644
--- a/qmcpy/integrand/hartmann6d.py
+++ b/qmcpy/integrand/hartmann6d.py
@@ -45,7 +45,8 @@ class Hartmann6d(AbstractIntegrand):
     """
 
     def __init__(self, sampler) -> None:
-        r"""
+        r"""Initialize a Hartmann6d integrand.
+
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
                 Either
diff --git a/qmcpy/integrand/ishigami.py b/qmcpy/integrand/ishigami.py
index 5c51cb902..d5dd7b9e9 100644
--- a/qmcpy/integrand/ishigami.py
+++ b/qmcpy/integrand/ishigami.py
@@ -54,7 +54,8 @@ class Ishigami(AbstractIntegrand):
     """
 
     def __init__(self, sampler, a: float = 7, b: float = 0.1) -> None:
-        r"""
+        r"""Initialize an Ishigami integrand.
+
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
                 Either
diff --git a/qmcpy/integrand/keister.py b/qmcpy/integrand/keister.py
index 3eff18311..2beb604cd 100644
--- a/qmcpy/integrand/keister.py
+++ b/qmcpy/integrand/keister.py
@@ -45,7 +45,8 @@ class Keister(AbstractIntegrand):
     """
 
     def __init__(self, sampler) -> None:
-        r"""
+        r"""Initialize a Keister integrand.
+
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
                 Either
diff --git a/qmcpy/integrand/linear0.py b/qmcpy/integrand/linear0.py
index 17654c265..5dc54cbe3 100644
--- a/qmcpy/integrand/linear0.py
+++ b/qmcpy/integrand/linear0.py
@@ -29,7 +29,8 @@ class Linear0(AbstractIntegrand):
     """
 
     def __init__(self, sampler) -> None:
-        r"""
+        r"""Initialize a Linear0 integrand.
+
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
                 Either
diff --git a/qmcpy/integrand/multimodal2d.py b/qmcpy/integrand/multimodal2d.py
index 64fd16429..d05853062 100644
--- a/qmcpy/integrand/multimodal2d.py
+++ b/qmcpy/integrand/multimodal2d.py
@@ -42,7 +42,8 @@ class Multimodal2d(AbstractIntegrand):
     """
 
     def __init__(self, sampler) -> None:
-        r"""
+        r"""Initialize a Multimodal2d integrand.
+
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
                 Either
diff --git a/qmcpy/integrand/sensitivity_indices.py b/qmcpy/integrand/sensitivity_indices.py
index 88010f225..cba72fad6 100644
--- a/qmcpy/integrand/sensitivity_indices.py
+++ b/qmcpy/integrand/sensitivity_indices.py
@@ -111,7 +111,8 @@ class SensitivityIndices(AbstractIntegrand):
     """
 
     def __init__(self, integrand: AbstractIntegrand, indices: np.ndarray = "singletons") -> None:
-        r"""
+        r"""Initialize a SensitivityIndices integrand.
+
         Args:
             integrand (AbstractIntegrand): Integrand to find sensitivity
                 indices of.
diff --git a/qmcpy/integrand/sin1d.py b/qmcpy/integrand/sin1d.py
index 510e73176..a9c40bc34 100644
--- a/qmcpy/integrand/sin1d.py
+++ b/qmcpy/integrand/sin1d.py
@@ -40,7 +40,8 @@ class Sin1d(AbstractIntegrand):
     """
 
     def __init__(self, sampler, k: float = 1) -> None:
-        r"""
+        r"""Initialize a Sin1d integrand.
+
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
                 Either
diff --git a/qmcpy/integrand/umbridge_wrapper.py b/qmcpy/integrand/umbridge_wrapper.py
index 33c0bbb66..2c8e44699 100644
--- a/qmcpy/integrand/umbridge_wrapper.py
+++ b/qmcpy/integrand/umbridge_wrapper.py
@@ -67,7 +67,8 @@ class UMBridgeWrapper(AbstractIntegrand):
     """
 
     def __init__(self, true_measure, model, config: dict = None, parallel: int = False) -> None:
-        """
+        """Initialize a UMBridgeWrapper integrand.
+
         Args:
             true_measure (AbstractTrueMeasure): The true measure.
             model (umbridge.HTTPModel): A `UM-Bridge` model.
diff --git a/qmcpy/kernel/abstract_kernel.py b/qmcpy/kernel/abstract_kernel.py
index 5859558cc..de02eb97c 100644
--- a/qmcpy/kernel/abstract_kernel.py
+++ b/qmcpy/kernel/abstract_kernel.py
@@ -363,7 +363,8 @@ def __init__(
         compile_call: bool = False,
         compile_call_kwargs: dict = None,
     ) -> None:
-        r"""
+        r"""Initialize an AbstractKernelScaleLengthscales kernel.
+
         Args:
             d (int): Dimension.
             scale (Union[np.ndarray, torch.Tensor]): Scaling factor $S$.
diff --git a/qmcpy/kernel/common_kernels.py b/qmcpy/kernel/common_kernels.py
index 984b18d0d..b190698d6 100644
--- a/qmcpy/kernel/common_kernels.py
+++ b/qmcpy/kernel/common_kernels.py
@@ -475,7 +475,8 @@ def __init__(
         compile_call: bool = False,
         compile_call_kwargs: dict = None,
     ) -> None:
-        r"""
+        r"""Initialize a KernelRationalQuadratic kernel.
+
         Args:
             d (int): Dimension.
             scale (Union[np.ndarray, torch.Tensor]): Scaling factor $S$.
diff --git a/qmcpy/kernel/multitask_kernel.py b/qmcpy/kernel/multitask_kernel.py
index 68abfa34f..dd3a39232 100644
--- a/qmcpy/kernel/multitask_kernel.py
+++ b/qmcpy/kernel/multitask_kernel.py
@@ -341,7 +341,8 @@ def __init__(
         rank_factor=1,
         method: str = "LOW RANK",
     ) -> None:
-        r"""
+        r"""Initialize a KernelMultiTask kernel.
+
         Args:
             base_kernel (AbstractKernel): $K_{\mathrm{base}}$.
             num_tasks (int): Number of tasks $T>1$.
diff --git a/qmcpy/kernel/si_dsi_kernels.py b/qmcpy/kernel/si_dsi_kernels.py
index 55d0cbb93..96493835a 100644
--- a/qmcpy/kernel/si_dsi_kernels.py
+++ b/qmcpy/kernel/si_dsi_kernels.py
@@ -336,7 +336,8 @@ def __init__(
         tfs_weights=None,
         requires_grad_weights: bool = None,
     ) -> None:
-        r"""
+        r"""Initialize a KernelShiftInvar kernel.
+
         Args:
             d (int): Dimension.
             scale (Union[np.ndarray, torch.Tensor]): Scaling factor $S$.
@@ -559,7 +560,8 @@ def __init__(
         tfs_weights=None,
         requires_grad_weights: bool = None,
     ) -> None:
-        r"""
+        r"""Initialize a KernelShiftInvarCombined kernel.
+
         Args:
             d (int): Dimension.
             scale (Union[np.ndarray, torch.Tensor]): Scaling factor $S$.
@@ -835,7 +837,8 @@ def __init__(
         tfs_weights=None,
         requires_grad_weights: bool = None,
     ) -> None:
-        r"""
+        r"""Initialize a KernelDigShiftInvar kernel.
+
         Args:
             d (int): Dimension.
             t (int): number of bits in binary represtnations. Typically
@@ -1119,7 +1122,8 @@ def __init__(
         tfs_weights=None,
         requires_grad_weights: bool = None,
     ) -> None:
-        r"""
+        r"""Initialize a KernelDigShiftInvarAdaptiveAlpha kernel.
+
         Args:
             d (int): Dimension.
             t (int): number of bits in binary represtnations. Typically
@@ -1373,7 +1377,8 @@ def __init__(
         tfs_weights=None,
         requires_grad_weights: bool = None,
     ) -> None:
-        r"""
+        r"""Initialize a KernelDigShiftInvarCombined kernel.
+
         Args:
             d (int): Dimension.
             t (int): number of bits in binary represtnations. Typically
diff --git a/qmcpy/stopping_criterion/cub_mc_clt.py b/qmcpy/stopping_criterion/cub_mc_clt.py
index edcea6c07..726f94e06 100644
--- a/qmcpy/stopping_criterion/cub_mc_clt.py
+++ b/qmcpy/stopping_criterion/cub_mc_clt.py
@@ -137,7 +137,8 @@ def __init__(
         control_variates: list = None,
         control_variate_means: np.ndarray = None,
     ) -> None:
-        r"""
+        r"""Initialize a CubMCCLT stopping criterion.
+
         Args:
             integrand (AbstractIntegrand): The integrand.
             abs_tol (np.ndarray): Absolute error tolerance.
diff --git a/qmcpy/stopping_criterion/cub_mc_clt_vec.py b/qmcpy/stopping_criterion/cub_mc_clt_vec.py
index ad20665e1..80a3443ae 100644
--- a/qmcpy/stopping_criterion/cub_mc_clt_vec.py
+++ b/qmcpy/stopping_criterion/cub_mc_clt_vec.py
@@ -168,7 +168,8 @@ def __init__(
         inflate: float = 1,
         alpha: np.ndarray = 0.01,
     ) -> None:
-        r"""
+        r"""Initialize a CubMCCLTVec stopping criterion.
+
         Args:
             integrand (AbstractIntegrand): The integrand.
             abs_tol (np.ndarray): Absolute error tolerance.
diff --git a/qmcpy/stopping_criterion/cub_mc_g.py b/qmcpy/stopping_criterion/cub_mc_g.py
index 45f055ca7..8bf9e8d94 100644
--- a/qmcpy/stopping_criterion/cub_mc_g.py
+++ b/qmcpy/stopping_criterion/cub_mc_g.py
@@ -263,7 +263,8 @@ def __init__(
         control_variates: list = None,
         control_variate_means: np.ndarray = None,
     ) -> None:
-        r"""
+        r"""Initialize a CubMCG stopping criterion.
+
         Args:
             integrand (AbstractIntegrand): The integrand.
             abs_tol (np.ndarray): Absolute error tolerance.
diff --git a/qmcpy/stopping_criterion/cub_mlmc.py b/qmcpy/stopping_criterion/cub_mlmc.py
index 9d9199885..be8e56ef6 100644
--- a/qmcpy/stopping_criterion/cub_mlmc.py
+++ b/qmcpy/stopping_criterion/cub_mlmc.py
@@ -87,7 +87,8 @@ def __init__(
         beta0: float = -1.0,
         gamma0: float = -1.0,
     ) -> None:
-        r"""
+        r"""Initialize a CubMLMC stopping criterion.
+
         Args:
             integrand (AbstractIntegrand): The integrand.
             abs_tol (np.ndarray): Absolute error tolerance.
diff --git a/qmcpy/stopping_criterion/cub_mlmc_cont.py b/qmcpy/stopping_criterion/cub_mlmc_cont.py
index 31ab44dc8..e0ad1606f 100644
--- a/qmcpy/stopping_criterion/cub_mlmc_cont.py
+++ b/qmcpy/stopping_criterion/cub_mlmc_cont.py
@@ -86,7 +86,8 @@ def __init__(
         n_tols: int = 10,
         theta_init: float = 0.5,
     ) -> None:
-        r"""
+        r"""Initialize a CubMLMCCont stopping criterion.
+
         Args:
             integrand (AbstractIntegrand): The integrand.
             abs_tol (np.ndarray): Absolute error tolerance.
diff --git a/qmcpy/stopping_criterion/cub_mlqmc.py b/qmcpy/stopping_criterion/cub_mlqmc.py
index 116cc4780..57e61ee1d 100644
--- a/qmcpy/stopping_criterion/cub_mlqmc.py
+++ b/qmcpy/stopping_criterion/cub_mlqmc.py
@@ -87,7 +87,8 @@ def __init__(
         levels_min: int = 2,
         levels_max: int = 10,
     ) -> None:
-        r"""
+        r"""Initialize a CubMLQMC stopping criterion.
+
         Args:
             integrand (AbstractIntegrand): The integrand.
             abs_tol (np.ndarray): Absolute error tolerance.
diff --git a/qmcpy/stopping_criterion/cub_mlqmc_cont.py b/qmcpy/stopping_criterion/cub_mlqmc_cont.py
index 3223c6726..e2e986ef8 100644
--- a/qmcpy/stopping_criterion/cub_mlqmc_cont.py
+++ b/qmcpy/stopping_criterion/cub_mlqmc_cont.py
@@ -93,7 +93,8 @@ def __init__(
         n_tols: int = 10,
         theta_init: float = 0.5,
     ) -> None:
-        r"""
+        r"""Initialize a CubMLQMCCont stopping criterion.
+
         Args:
             integrand (AbstractIntegrand): The integrand.
             abs_tol (np.ndarray): Absolute error tolerance.
diff --git a/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py b/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py
index 1b72bd701..253f8f4d1 100644
--- a/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py
+++ b/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py
@@ -193,7 +193,8 @@ def __init__(
         errbd_type: str = "MLE",
         order: int = 2,
     ) -> None:
-        r"""
+        r"""Initialize a CubQMCBayesLatticeG stopping criterion.
+
         Args:
             integrand (AbstractIntegrand): The integrand.
             abs_tol (np.ndarray): Absolute error tolerance.
diff --git a/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py b/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py
index d6e3987ce..f587b54d6 100644
--- a/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py
+++ b/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py
@@ -200,7 +200,8 @@ def __init__(
         alpha: np.ndarray = 0.01,
         errbd_type: str = "MLE",
     ) -> None:
-        r"""
+        r"""Initialize a CubQMCBayesNetG stopping criterion.
+
         Args:
             integrand (AbstractIntegrand): The integrand.
             abs_tol (np.ndarray): Absolute error tolerance.
diff --git a/qmcpy/stopping_criterion/cub_qmc_lattice_g.py b/qmcpy/stopping_criterion/cub_qmc_lattice_g.py
index 2a3b1e32e..59c0d183f 100644
--- a/qmcpy/stopping_criterion/cub_qmc_lattice_g.py
+++ b/qmcpy/stopping_criterion/cub_qmc_lattice_g.py
@@ -185,7 +185,8 @@ def __init__(
         check_cone: bool = False,
         ptransform: str = "BAKER",
     ) -> None:
-        r"""
+        r"""Initialize a CubQMCLatticeG stopping criterion.
+
         Args:
             integrand (AbstractIntegrand): The integrand.
             abs_tol (np.ndarray): Absolute error tolerance.
diff --git a/qmcpy/stopping_criterion/cub_qmc_net_g.py b/qmcpy/stopping_criterion/cub_qmc_net_g.py
index 36630080f..467c85842 100644
--- a/qmcpy/stopping_criterion/cub_qmc_net_g.py
+++ b/qmcpy/stopping_criterion/cub_qmc_net_g.py
@@ -229,7 +229,8 @@ def __init__(
         control_variate_means: np.ndarray = None,
         update_cv_coeffs: bool = False,
     ) -> None:
-        r"""
+        r"""Initialize a CubQMCNetG stopping criterion.
+
         Args:
             integrand (AbstractIntegrand): The integrand.
             abs_tol (np.ndarray): Absolute error tolerance.
diff --git a/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py b/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py
index def85c804..ee275cfae 100644
--- a/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py
+++ b/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py
@@ -213,7 +213,8 @@ def __init__(
         inflate: float = 1,
         alpha: np.ndarray = 0.01,
     ) -> None:
-        r"""
+        r"""Initialize a CubQMCRepStudentT stopping criterion.
+
         Args:
             integrand (AbstractIntegrand): The integrand.
             abs_tol (np.ndarray): Absolute error tolerance.
diff --git a/qmcpy/stopping_criterion/pf_gp_ci.py b/qmcpy/stopping_criterion/pf_gp_ci.py
index 97a915436..a271c576a 100644
--- a/qmcpy/stopping_criterion/pf_gp_ci.py
+++ b/qmcpy/stopping_criterion/pf_gp_ci.py
@@ -195,7 +195,8 @@ def __init__(
         n_ref_approx: int = 2**22,
         seed_ref_approx: int = None,
     ) -> None:
-        """
+        """Initialize a PFGPCI stopping criterion.
+
         Args:
             integrand (AbstractIntegrand): The integrand.
             failure_threshold (float): Thresholds for failure.
diff --git a/qmcpy/true_measure/bernoulli_cont.py b/qmcpy/true_measure/bernoulli_cont.py
index 95d8664ba..bf411615e 100644
--- a/qmcpy/true_measure/bernoulli_cont.py
+++ b/qmcpy/true_measure/bernoulli_cont.py
@@ -38,7 +38,8 @@ class BernoulliCont(AbstractTrueMeasure):
     """
 
     def __init__(self, sampler, lam=1 / 2) -> None:
-        r"""
+        r"""Initialize a BernoulliCont true measure.
+
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
                 Either
diff --git a/qmcpy/true_measure/brownian_motion.py b/qmcpy/true_measure/brownian_motion.py
index e82d63f4a..f65c13ddf 100644
--- a/qmcpy/true_measure/brownian_motion.py
+++ b/qmcpy/true_measure/brownian_motion.py
@@ -149,7 +149,8 @@ def __init__(
         bridge_vdc_gray_ordering: bool = True,
         bridge_output_order: str = 'increasing',
     ) -> None:
-        r"""
+        r"""Initialize a BrownianMotion true measure.
+
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
                 Either
diff --git a/qmcpy/true_measure/clayton_copula.py b/qmcpy/true_measure/clayton_copula.py
index 8276d397e..301be85ee 100644
--- a/qmcpy/true_measure/clayton_copula.py
+++ b/qmcpy/true_measure/clayton_copula.py
@@ -80,7 +80,8 @@ class ClaytonCopula(AbstractCopula):
     """
 
     def __init__(self, sampler, marginals: list, theta: float) -> None:
-        r"""
+        r"""Initialize a ClaytonCopula true measure.
+
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
                 A sampler or transform whose range is the unit cube.
diff --git a/qmcpy/true_measure/frank_copula.py b/qmcpy/true_measure/frank_copula.py
index 7e402d3d9..06d71c5b5 100644
--- a/qmcpy/true_measure/frank_copula.py
+++ b/qmcpy/true_measure/frank_copula.py
@@ -103,7 +103,8 @@ class FrankCopula(AbstractCopula):
     """
 
     def __init__(self, sampler, marginals: list, theta: float) -> None:
-        r"""
+        r"""Initialize a FrankCopula true measure.
+
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
                 A sampler or transform whose range is the unit cube.
diff --git a/qmcpy/true_measure/gaussian.py b/qmcpy/true_measure/gaussian.py
index 33a0e2b35..4f1494fd0 100644
--- a/qmcpy/true_measure/gaussian.py
+++ b/qmcpy/true_measure/gaussian.py
@@ -49,7 +49,8 @@ class Gaussian(AbstractTrueMeasure):
     """
 
     def __init__(self, sampler, mean: Union[float, np.ndarray] = 0.0, covariance: Union[float, np.ndarray] = 1.0, decomp_type: str = "PCA") -> None:
-        """
+        """Initialize a Gaussian true measure.
+
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
                 Either
diff --git a/qmcpy/true_measure/gaussian_copula.py b/qmcpy/true_measure/gaussian_copula.py
index ba23234f8..4299ae321 100644
--- a/qmcpy/true_measure/gaussian_copula.py
+++ b/qmcpy/true_measure/gaussian_copula.py
@@ -76,7 +76,8 @@ class GaussianCopula(AbstractCopula):
     """
 
     def __init__(self, sampler, marginals: list, correlation: np.ndarray) -> None:
-        r"""
+        r"""Initialize a GaussianCopula true measure.
+
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
                 A sampler or transform whose range is the unit cube.
diff --git a/qmcpy/true_measure/geometric_brownian_motion.py b/qmcpy/true_measure/geometric_brownian_motion.py
index 7f27580cd..83d8aa93a 100644
--- a/qmcpy/true_measure/geometric_brownian_motion.py
+++ b/qmcpy/true_measure/geometric_brownian_motion.py
@@ -58,7 +58,8 @@ def __init__(
         lazy_load: bool = True,
         lazy_decomp: bool = True,
     ) -> None:
-        r"""
+        r"""Initialize a GeometricBrownianMotion true measure.
+
         Args:
             sampler (DiscreteDistribution/TrueMeasure): A discrete distribution
                 or true measure.
diff --git a/qmcpy/true_measure/gumbel_copula.py b/qmcpy/true_measure/gumbel_copula.py
index 5d3f0cbd1..d61d8178a 100644
--- a/qmcpy/true_measure/gumbel_copula.py
+++ b/qmcpy/true_measure/gumbel_copula.py
@@ -76,7 +76,8 @@ class GumbelCopula(AbstractCopula):
     """
 
     def __init__(self, sampler, marginals: list, theta: float) -> None:
-        r"""
+        r"""Initialize a GumbelCopula true measure.
+
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
                 A sampler or transform whose range is the unit cube.
diff --git a/qmcpy/true_measure/johnsons_su.py b/qmcpy/true_measure/johnsons_su.py
index d9fa893eb..de80f0f87 100644
--- a/qmcpy/true_measure/johnsons_su.py
+++ b/qmcpy/true_measure/johnsons_su.py
@@ -42,7 +42,8 @@ class JohnsonsSU(AbstractTrueMeasure):
     """
 
     def __init__(self, sampler, gamma=1, xi=1, delta=2, lam=2) -> None:
-        r"""
+        r"""Initialize a JohnsonsSU true measure.
+
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
                 Either
diff --git a/qmcpy/true_measure/kumaraswamy.py b/qmcpy/true_measure/kumaraswamy.py
index f9593c39b..88e17bafd 100644
--- a/qmcpy/true_measure/kumaraswamy.py
+++ b/qmcpy/true_measure/kumaraswamy.py
@@ -51,7 +51,8 @@ class Kumaraswamy(AbstractTrueMeasure):
     """
 
     def __init__(self, sampler, a=2, b=2) -> None:
-        r"""
+        r"""Initialize a Kumaraswamy true measure.
+
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
                 Either
diff --git a/qmcpy/true_measure/lebesgue.py b/qmcpy/true_measure/lebesgue.py
index 7da6cf885..efba73152 100644
--- a/qmcpy/true_measure/lebesgue.py
+++ b/qmcpy/true_measure/lebesgue.py
@@ -36,7 +36,8 @@ class Lebesgue(AbstractTrueMeasure):
     """
 
     def __init__(self, sampler: AbstractTrueMeasure) -> None:
-        r"""
+        r"""Initialize a Lebesgue true measure.
+
         Args:
             sampler (AbstractTrueMeasure): A true measure by which to compose a
                 transform.
diff --git a/qmcpy/true_measure/matern_gp.py b/qmcpy/true_measure/matern_gp.py
index 3df5e93e3..8b51da755 100644
--- a/qmcpy/true_measure/matern_gp.py
+++ b/qmcpy/true_measure/matern_gp.py
@@ -75,7 +75,8 @@ def __init__(
         nugget: float = 1e-6,
         decomp_type: str = "PCA",
     ) -> None:
-        r"""
+        r"""Initialize a MaternGP true measure.
+
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
                 Either
diff --git a/qmcpy/true_measure/student_t_copula.py b/qmcpy/true_measure/student_t_copula.py
index 52b0a683b..fb5356043 100644
--- a/qmcpy/true_measure/student_t_copula.py
+++ b/qmcpy/true_measure/student_t_copula.py
@@ -87,7 +87,8 @@ class StudentTCopula(AbstractCopula):
     )
 
     def __init__(self, sampler, marginals: list, correlation: np.ndarray, df: float) -> None:
-        r"""
+        r"""Initialize a StudentTCopula true measure.
+
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
                 A sampler or transform whose range is the unit cube.
diff --git a/qmcpy/true_measure/uniform.py b/qmcpy/true_measure/uniform.py
index 7739b84d5..514591a13 100644
--- a/qmcpy/true_measure/uniform.py
+++ b/qmcpy/true_measure/uniform.py
@@ -50,7 +50,8 @@ class Uniform(AbstractTrueMeasure):
     """
 
     def __init__(self, sampler, lower_bound=0, upper_bound=1) -> None:
-        r"""
+        r"""Initialize a Uniform true measure.
+
         Args:
             sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]):
                 Either
diff --git a/qmcpy/util/latnetbuilder_linker.py b/qmcpy/util/latnetbuilder_linker.py
index 316054b81..a38faa969 100644
--- a/qmcpy/util/latnetbuilder_linker.py
+++ b/qmcpy/util/latnetbuilder_linker.py
@@ -3,7 +3,8 @@
 
 
 def latnetbuilder_linker(lnb_dir: str = "./", out_dir: str = "./", fout_prefix: str = "lnb4qmcpy"):
-    """
+    """Convert a LatNet Builder output directory into a QMCPy generating vector or matrix.
+
     Args:
         lnb_dir (str): relative path to directory where `outputMachine.txt` is
             stored e.g. 'my_lnb/poly_lat/'
diff --git a/qmcpy/util/plot_functions.py b/qmcpy/util/plot_functions.py
index d73550bd0..a495486b3 100644
--- a/qmcpy/util/plot_functions.py
+++ b/qmcpy/util/plot_functions.py
@@ -18,7 +18,8 @@ def plot_proj(
     where_title: float = 1,
     **kwargs: dict
 ):
-    """
+    """Plot two-dimensional projections of a point set.
+
     Args:
         sampler (DiscreteDistribution, TrueMeasure): The generator of samples
             to be plotted.
diff --git a/scripts/baseline_counts.json b/scripts/baseline_counts.json
index 1c3d6496a..0211d8b78 100644
--- a/scripts/baseline_counts.json
+++ b/scripts/baseline_counts.json
@@ -1,5 +1,5 @@
 {
-  "check_docstring": 248,
-  "pydoclint": 147,
+  "check_docstring": 188,
+  "pydoclint": 151,
   "unsafe_annotations": 109
 }

From ef5593034496e51de39c5c26dbac7c82b7afbd18 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Tue, 8 Sep 2026 16:12:13 +0800
Subject: [PATCH 36/51] Better docstrings

---
 qmcpy/integrand/abstract_integrand.py         |  18 ++
 qmcpy/integrand/bayesian_lr_coeffs.py         |  27 +++
 qmcpy/integrand/box_integral.py               |   9 +
 qmcpy/integrand/custom_fun.py                 |  10 +
 qmcpy/integrand/financial_option.py           | 219 ++++++++++++++++++
 qmcpy/integrand/fourbranch2d.py               |   8 +
 qmcpy/integrand/genz.py                       |  16 ++
 qmcpy/integrand/hartmann6d.py                 |   8 +
 qmcpy/integrand/ishigami.py                   |   8 +
 qmcpy/integrand/keister.py                    |  19 ++
 qmcpy/integrand/linear0.py                    |   8 +
 qmcpy/integrand/multimodal2d.py               |   8 +
 qmcpy/integrand/sensitivity_indices.py        |  29 +++
 qmcpy/integrand/sin1d.py                      |   8 +
 qmcpy/integrand/umbridge_wrapper.py           |   9 +
 qmcpy/util/data.py                            |   5 +
 qmcpy/util/exact_gpytorch_regression_model.py |  44 ++++
 qmcpy/util/stop_notebook.py                   |  14 +-
 qmcpy/util/torch_numpy_ops.py                 |  11 +
 qmcpy/util/transforms.py                      | 139 +++++++++++
 20 files changed, 616 insertions(+), 1 deletion(-)

diff --git a/qmcpy/integrand/abstract_integrand.py b/qmcpy/integrand/abstract_integrand.py
index f9da42928..7c9fb9c4e 100644
--- a/qmcpy/integrand/abstract_integrand.py
+++ b/qmcpy/integrand/abstract_integrand.py
@@ -11,6 +11,12 @@
 
 
 class AbstractIntegrand(object):
+    """Base class for integrands.
+
+    An integrand pairs a function $g$ with the true measure its argument is
+    distributed by, and exposes $f$, the composition that a stopping criterion
+    samples. Subclasses implement ``g``.
+    """
 
     def __init__(self, dimension_indv: tuple, dimension_comb: tuple, parallel: int, threadpool: bool = False) -> None:
         r"""Initialize an AbstractIntegrand integrand.
@@ -105,6 +111,18 @@ def __call__(self, n=None, n_min=None, n_max=None, warn=True):
     def gen_samples(
         self, n=None, n_min=None, n_max=None, return_weights=False, warn=True
     ):
+        """Generate discrete distribution samples and evaluate the integrand at them.
+
+        Args:
+            n (Union[None, int]): Number of points, taken from index ``0`` to ``n``.
+            n_min (Union[None, int]): Starting index of the sequence.
+            n_max (Union[None, int]): Final index of the sequence.
+            return_weights (bool): Accepted for API consistency; unused here.
+            warn (bool): If ``False``, disable warnings while generating samples.
+
+        Returns:
+            np.ndarray: Integrand values at the generated points.
+        """
         x = self.discrete_distrib(n=n, n_min=n_min, n_max=n_max, warn=warn)
         y = self.f(x)
         return y
diff --git a/qmcpy/integrand/bayesian_lr_coeffs.py b/qmcpy/integrand/bayesian_lr_coeffs.py
index 0d6703c8e..4560d1c79 100644
--- a/qmcpy/integrand/bayesian_lr_coeffs.py
+++ b/qmcpy/integrand/bayesian_lr_coeffs.py
@@ -85,6 +85,15 @@ def __init__(
         )
 
     def g(self, x):
+        """Evaluate the unnormalized posterior numerator and denominator.
+
+        Args:
+            x (np.ndarray): Coefficient vectors, coefficients along the last axis.
+
+        Returns:
+            np.ndarray: Stacked numerator (coefficient-weighted likelihood) and
+            denominator (likelihood), whose ratio is the posterior mean.
+        """
         z = np.einsum("...j,ij->...i", x, self.feature_array)
         z1 = z * self.response_vector
         with np.errstate(over="ignore"):
@@ -104,6 +113,16 @@ def _spawn(self, level, sampler):
         )
 
     def bound_fun(self, bound_low, bound_high):
+        """Combine numerator and denominator bounds into bounds on their ratio.
+
+        Args:
+            bound_low (np.ndarray): Lower bounds on the numerator and denominator.
+            bound_high (np.ndarray): Upper bounds on the numerator and denominator.
+
+        Returns:
+            tuple: Lower and upper bounds on the ratio, infinite where the
+            denominator interval straddles zero.
+        """
         num_bounds_low, den_bounds_low = bound_low[0], bound_low[1]
         num_bounds_high, den_bounds_high = bound_high[0], bound_high[1]
         comb_bounds_low = np.minimum.reduce(
@@ -127,4 +146,12 @@ def bound_fun(self, bound_low, bound_high):
         return comb_bounds_low, comb_bounds_high
 
     def dependency(self, comb_flags):
+        """Map combined-output flags onto the individual outputs they require.
+
+        Args:
+            comb_flags (np.ndarray): Flags for the combined outputs.
+
+        Returns:
+            np.ndarray: Flags for the numerator and denominator outputs.
+        """
         return np.vstack((comb_flags, comb_flags))
diff --git a/qmcpy/integrand/box_integral.py b/qmcpy/integrand/box_integral.py
index bfc24a1d0..7ed6adf9e 100644
--- a/qmcpy/integrand/box_integral.py
+++ b/qmcpy/integrand/box_integral.py
@@ -88,6 +88,15 @@ def __init__(self, sampler, s=1) -> None:
         )
 
     def g(self, t, **kwargs):
+        r"""Evaluate the box integral function.
+
+        Args:
+            t (np.ndarray): Points in the unit cube, dimensions along the last axis.
+            **kwargs (dict): Unused; accepted for API consistency.
+
+        Returns:
+            np.ndarray: $\lVert t \rVert_2^s$ for each exponent $s$.
+        """
         sum_squares = (t**2).sum(-1)
         y = sum_squares ** self.s_over_2[(...,) + (None,) * sum_squares.ndim]
         return y
diff --git a/qmcpy/integrand/custom_fun.py b/qmcpy/integrand/custom_fun.py
index f888e6828..cdaf08119 100644
--- a/qmcpy/integrand/custom_fun.py
+++ b/qmcpy/integrand/custom_fun.py
@@ -119,6 +119,16 @@ def __init__(self, true_measure, g, dimension_indv: tuple = (), parallel: int =
         )
 
     def g(self, t, *args, **kwargs):
+        """Evaluate the user-supplied function.
+
+        Args:
+            t (np.ndarray): Points distributed by the true measure.
+            *args (tuple): Positional arguments forwarded to the user function.
+            **kwargs (dict): Keyword arguments forwarded to the user function.
+
+        Returns:
+            np.ndarray: Function values.
+        """
         return self.__g(t, *args, **kwargs)
 
     def _spawn(self, level, sampler):
diff --git a/qmcpy/integrand/financial_option.py b/qmcpy/integrand/financial_option.py
index 67475cebc..04122cc92 100644
--- a/qmcpy/integrand/financial_option.py
+++ b/qmcpy/integrand/financial_option.py
@@ -448,6 +448,16 @@ def __init__(
         )
 
     def g(self, t, **kwargs):
+        """Evaluate the discounted option payoff along each price path.
+
+        Args:
+            t (np.ndarray): Geometric Brownian motion paths from the true measure.
+            **kwargs (dict): Unused; accepted for API consistency.
+
+        Returns:
+            np.ndarray: Discounted payoffs; for a multilevel problem, the coarse
+            and fine payoffs stacked together.
+        """
         gbm = t  # GeometricBrownianMotion already provides GBM paths directly
         discounted_payoffs = self.payoff(gbm) * self.discount_factor
         if self.multilevel:
@@ -463,12 +473,36 @@ def g(self, t, **kwargs):
         return discounted_payoffs
 
     def payoff_european_call(self, gbm):
+        """European call payoff at maturity.
+
+        Args:
+            gbm (np.ndarray): Geometric Brownian motion paths, monitoring times last.
+
+        Returns:
+            np.ndarray: Payoff of each path.
+        """
         return np.maximum(gbm[..., -1] - self.strike_price, 0)
 
     def payoff_european_put(self, gbm):
+        """European put payoff at maturity.
+
+        Args:
+            gbm (np.ndarray): Geometric Brownian motion paths, monitoring times last.
+
+        Returns:
+            np.ndarray: Payoff of each path.
+        """
         return np.maximum(self.strike_price - gbm[..., -1], 0)
 
     def payoff_asian_arithmetic_trap_call(self, gbm):
+        """Asian arithmetic-mean call payoff, trapezoidal averaging.
+
+        Args:
+            gbm (np.ndarray): Geometric Brownian motion paths, monitoring times last.
+
+        Returns:
+            np.ndarray: Payoff of each path.
+        """
         return np.maximum(
             (self.start_price / 2 + gbm[..., :-1].sum(-1) + gbm[..., -1] / 2)
             / gbm.shape[-1]
@@ -477,6 +511,14 @@ def payoff_asian_arithmetic_trap_call(self, gbm):
         )
 
     def payoff_asian_arithmetic_trap_put(self, gbm):
+        """Asian arithmetic-mean put payoff, trapezoidal averaging.
+
+        Args:
+            gbm (np.ndarray): Geometric Brownian motion paths, monitoring times last.
+
+        Returns:
+            np.ndarray: Payoff of each path.
+        """
         return np.maximum(
             self.strike_price
             - (self.start_price / 2 + gbm[..., :-1].sum(-1) + gbm[..., -1] / 2)
@@ -485,6 +527,14 @@ def payoff_asian_arithmetic_trap_put(self, gbm):
         )
 
     def payoff_asian_geometric_trap_call(self, gbm):
+        """Asian geometric-mean call payoff, trapezoidal averaging.
+
+        Args:
+            gbm (np.ndarray): Geometric Brownian motion paths, monitoring times last.
+
+        Returns:
+            np.ndarray: Payoff of each path.
+        """
         return np.maximum(
             np.exp(
                 (
@@ -499,6 +549,14 @@ def payoff_asian_geometric_trap_call(self, gbm):
         )
 
     def payoff_asian_geometric_trap_put(self, gbm):
+        """Asian geometric-mean put payoff, trapezoidal averaging.
+
+        Args:
+            gbm (np.ndarray): Geometric Brownian motion paths, monitoring times last.
+
+        Returns:
+            np.ndarray: Payoff of each path.
+        """
         return np.maximum(
             self.strike_price
             - np.exp(
@@ -513,22 +571,62 @@ def payoff_asian_geometric_trap_put(self, gbm):
         )
 
     def payoff_asian_arithmetic_right_call(self, gbm):
+        """Asian arithmetic-mean call payoff, right-endpoint averaging.
+
+        Args:
+            gbm (np.ndarray): Geometric Brownian motion paths, monitoring times last.
+
+        Returns:
+            np.ndarray: Payoff of each path.
+        """
         return np.maximum(gbm.sum(-1) / gbm.shape[-1] - self.strike_price, 0)
 
     def payoff_asian_arithmetic_right_put(self, gbm):
+        """Asian arithmetic-mean put payoff, right-endpoint averaging.
+
+        Args:
+            gbm (np.ndarray): Geometric Brownian motion paths, monitoring times last.
+
+        Returns:
+            np.ndarray: Payoff of each path.
+        """
         return np.maximum((self.strike_price - gbm.sum(-1)) / gbm.shape[-1], 0)
 
     def payoff_asian_geometric_right_call(self, gbm):
+        """Asian geometric-mean call payoff, right-endpoint averaging.
+
+        Args:
+            gbm (np.ndarray): Geometric Brownian motion paths, monitoring times last.
+
+        Returns:
+            np.ndarray: Payoff of each path.
+        """
         return np.maximum(
             np.exp(np.log(gbm).sum(-1) / gbm.shape[-1]) - self.strike_price, 0
         )
 
     def payoff_asian_geometric_right_put(self, gbm):
+        """Asian geometric-mean put payoff, right-endpoint averaging.
+
+        Args:
+            gbm (np.ndarray): Geometric Brownian motion paths, monitoring times last.
+
+        Returns:
+            np.ndarray: Payoff of each path.
+        """
         return np.maximum(
             self.strike_price - np.exp(np.log(gbm).sum(-1) / gbm.shape[-1]), 0
         )
 
     def payoff_barrier_in_up_call(self, gbm):
+        """Up-and-in barrier call payoff; pays only if the barrier is reached from below.
+
+        Args:
+            gbm (np.ndarray): Geometric Brownian motion paths, monitoring times last.
+
+        Returns:
+            np.ndarray: Payoff of each path.
+        """
         v = gbm[..., -1].copy()
         flag = (gbm >= self.barrier_price).any(-1)
         v[~flag] = 0
@@ -536,6 +634,14 @@ def payoff_barrier_in_up_call(self, gbm):
         return v
 
     def payoff_barrier_out_up_call(self, gbm):
+        """Up-and-out barrier call payoff; pays only if the barrier is never reached.
+
+        Args:
+            gbm (np.ndarray): Geometric Brownian motion paths, monitoring times last.
+
+        Returns:
+            np.ndarray: Payoff of each path.
+        """
         v = gbm[..., -1].copy()
         flag = (gbm < self.barrier_price).all(-1)
         v[~flag] = 0
@@ -543,6 +649,14 @@ def payoff_barrier_out_up_call(self, gbm):
         return v
 
     def payoff_barrier_in_down_call(self, gbm):
+        """Down-and-in barrier call payoff; pays only if the barrier is reached from above.
+
+        Args:
+            gbm (np.ndarray): Geometric Brownian motion paths, monitoring times last.
+
+        Returns:
+            np.ndarray: Payoff of each path.
+        """
         v = gbm[..., -1].copy()
         flag = (gbm <= self.barrier_price).any(-1)
         v[~flag] = 0
@@ -550,6 +664,14 @@ def payoff_barrier_in_down_call(self, gbm):
         return v
 
     def payoff_barrier_out_down_call(self, gbm):
+        """Down-and-out barrier call payoff; pays only if the barrier is never reached.
+
+        Args:
+            gbm (np.ndarray): Geometric Brownian motion paths, monitoring times last.
+
+        Returns:
+            np.ndarray: Payoff of each path.
+        """
         v = gbm[..., -1].copy()
         flag = (gbm > self.barrier_price).all(-1)
         v[~flag] = 0
@@ -557,6 +679,14 @@ def payoff_barrier_out_down_call(self, gbm):
         return v
 
     def payoff_barrier_in_up_put(self, gbm):
+        """Up-and-in barrier put payoff; pays only if the barrier is reached from below.
+
+        Args:
+            gbm (np.ndarray): Geometric Brownian motion paths, monitoring times last.
+
+        Returns:
+            np.ndarray: Payoff of each path.
+        """
         v = gbm[..., -1].copy()
         flag = (gbm >= self.barrier_price).any(-1)
         v[~flag] = 0
@@ -564,6 +694,14 @@ def payoff_barrier_in_up_put(self, gbm):
         return v
 
     def payoff_barrier_out_up_put(self, gbm):
+        """Up-and-out barrier put payoff; pays only if the barrier is never reached.
+
+        Args:
+            gbm (np.ndarray): Geometric Brownian motion paths, monitoring times last.
+
+        Returns:
+            np.ndarray: Payoff of each path.
+        """
         v = gbm[..., -1].copy()
         flag = (gbm < self.barrier_price).all(-1)
         v[~flag] = 0
@@ -571,6 +709,14 @@ def payoff_barrier_out_up_put(self, gbm):
         return v
 
     def payoff_barrier_in_down_put(self, gbm):
+        """Down-and-in barrier put payoff; pays only if the barrier is reached from above.
+
+        Args:
+            gbm (np.ndarray): Geometric Brownian motion paths, monitoring times last.
+
+        Returns:
+            np.ndarray: Payoff of each path.
+        """
         v = gbm[..., -1].copy()
         flag = (gbm <= self.barrier_price).any(-1)
         v[~flag] = 0
@@ -578,6 +724,14 @@ def payoff_barrier_in_down_put(self, gbm):
         return v
 
     def payoff_barrier_out_down_put(self, gbm):
+        """Down-and-out barrier put payoff; pays only if the barrier is never reached.
+
+        Args:
+            gbm (np.ndarray): Geometric Brownian motion paths, monitoring times last.
+
+        Returns:
+            np.ndarray: Payoff of each path.
+        """
         v = gbm[..., -1].copy()
         flag = (gbm > self.barrier_price).all(-1)
         v[~flag] = 0
@@ -585,17 +739,49 @@ def payoff_barrier_out_down_put(self, gbm):
         return v
 
     def payoff_lookback_call(self, gbm):  # include start price in min
+        """Lookback call payoff: final price less the running minimum, including the start price.
+
+        Args:
+            gbm (np.ndarray): Geometric Brownian motion paths, monitoring times last.
+
+        Returns:
+            np.ndarray: Payoff of each path.
+        """
         min_path = np.minimum(gbm.min(-1), self.start_price)
         return gbm[..., -1] - min_path
 
     def payoff_lookback_put(self, gbm):  # include start price in max
+        """Lookback put payoff: the running maximum, including the start price, less the final price.
+
+        Args:
+            gbm (np.ndarray): Geometric Brownian motion paths, monitoring times last.
+
+        Returns:
+            np.ndarray: Payoff of each path.
+        """
         max_path = np.maximum(gbm.max(-1), self.start_price)
         return max_path - gbm[..., -1]
 
     def payoff_digital_call(self, gbm):
+        """Digital call payoff: a fixed payout when the final price is at or above the strike.
+
+        Args:
+            gbm (np.ndarray): Geometric Brownian motion paths, monitoring times last.
+
+        Returns:
+            np.ndarray: Payoff of each path.
+        """
         return np.where(gbm[..., -1] >= self.strike_price, self.digital_payout, 0)
 
     def payoff_digital_put(self, gbm):
+        """Digital put payoff: a fixed payout when the final price is at or below the strike.
+
+        Args:
+            gbm (np.ndarray): Geometric Brownian motion paths, monitoring times last.
+
+        Returns:
+            np.ndarray: Payoff of each path.
+        """
         return np.where(gbm[..., -1] <= self.strike_price, self.digital_payout, 0)
 
     def get_exact_value(self):
@@ -692,6 +878,14 @@ def get_exact_value_inf_dim(self):
         return val
 
     def dimension_at_level(self, level):
+        """Return the number of monitoring times used at a multilevel level.
+
+        Args:
+            level (int): Multilevel level index.
+
+        Returns:
+            int: Monitoring times at that level, doubling with each level.
+        """
         return self.d_coarsest * 2**level
 
     def _spawn(self, level, sampler):
@@ -725,6 +919,11 @@ def _eurogbmprice(S0, r, T, sigma, K):
 
 
 class AsianOption(FinancialOption):
+    """Asian option.
+
+    Deprecated, please use :class:`FinancialOption` with ``option="ASIAN"``.
+    """
+
     def __init__(self, *args, **kwargs) -> None:
         """Deprecated, please use FinancialOption"""
         if "option" in kwargs:
@@ -733,6 +932,11 @@ def __init__(self, *args, **kwargs) -> None:
 
 
 class EuropeanOption(FinancialOption):
+    """European option.
+
+    Deprecated, please use :class:`FinancialOption` with ``option="EUROPEAN"``.
+    """
+
     def __init__(self, *args, **kwargs) -> None:
         """Deprecated, please use FinancialOption"""
         if "option" in kwargs:
@@ -741,6 +945,11 @@ def __init__(self, *args, **kwargs) -> None:
 
 
 class BarrierOption(FinancialOption):
+    """Barrier option.
+
+    Deprecated, please use :class:`FinancialOption` with ``option="BARRIER"``.
+    """
+
     def __init__(self, *args, **kwargs) -> None:
         """Deprecated, please use FinancialOption"""
         if "option" in kwargs:
@@ -749,6 +958,11 @@ def __init__(self, *args, **kwargs) -> None:
 
 
 class LookbackOption(FinancialOption):
+    """Lookback option.
+
+    Deprecated, please use :class:`FinancialOption` with ``option="LOOKBACK"``.
+    """
+
     def __init__(self, *args, **kwargs) -> None:
         """Deprecated, please use FinancialOption"""
         if "option" in kwargs:
@@ -757,6 +971,11 @@ def __init__(self, *args, **kwargs) -> None:
 
 
 class DigitalOption(FinancialOption):
+    """Digital option.
+
+    Deprecated, please use :class:`FinancialOption` with ``option="DIGITAL"``.
+    """
+
     def __init__(self, *args, **kwargs) -> None:
         """Deprecated, please use FinancialOption"""
         if "option" in kwargs:
diff --git a/qmcpy/integrand/fourbranch2d.py b/qmcpy/integrand/fourbranch2d.py
index ba950b5f0..768613be8 100644
--- a/qmcpy/integrand/fourbranch2d.py
+++ b/qmcpy/integrand/fourbranch2d.py
@@ -63,6 +63,14 @@ def __init__(self, sampler) -> None:
         )
 
     def g(self, t):
+        """Evaluate the four-branch function.
+
+        Args:
+            t (np.ndarray): Two-dimensional points.
+
+        Returns:
+            np.ndarray: Minimum of the four branches at each point.
+        """
         t0, t1 = t[..., 0], t[..., 1]
         return np.minimum.reduce(
             [
diff --git a/qmcpy/integrand/genz.py b/qmcpy/integrand/genz.py
index b76759e35..2345335c5 100644
--- a/qmcpy/integrand/genz.py
+++ b/qmcpy/integrand/genz.py
@@ -99,9 +99,25 @@ def __init__(self, sampler, kind_func: str = "OSCILLATORY", kind_coeff: int = 1)
         super(Genz, self).__init__(dimension_indv=(), dimension_comb=(), parallel=False)
 
     def g_oscillatory(self, t):
+        r"""Evaluate the oscillatory Genz function.
+
+        Args:
+            t (np.ndarray): Points in the unit cube.
+
+        Returns:
+            np.ndarray: $\cos(-c \cdot t)$ at each point.
+        """
         return np.cos(-(self.c * t).sum(-1))
 
     def g_corner_peak(self, t):
+        r"""Evaluate the corner-peak Genz function.
+
+        Args:
+            t (np.ndarray): Points in the unit cube.
+
+        Returns:
+            np.ndarray: $(1 + c \cdot t)^{-(d+1)}$ at each point.
+        """
         return (1 + (self.c * t).sum(-1)) ** (-(self.d + 1))
 
     def _spawn(self, level, sampler):
diff --git a/qmcpy/integrand/hartmann6d.py b/qmcpy/integrand/hartmann6d.py
index 413916a86..18bf810da 100644
--- a/qmcpy/integrand/hartmann6d.py
+++ b/qmcpy/integrand/hartmann6d.py
@@ -66,6 +66,14 @@ def __init__(self, sampler) -> None:
         self.ah = AugmentedHartmann(negate=False)
 
     def g(self, t):
+        """Evaluate the six-dimensional augmented Hartmann function.
+
+        Args:
+            t (np.ndarray): Six-dimensional points.
+
+        Returns:
+            np.ndarray: Function values, via BoTorch's ``AugmentedHartmann``.
+        """
         import torch
 
         t = np.concatenate([t, np.ones(tuple(t.shape[:-1]) + (1,))], axis=-1)
diff --git a/qmcpy/integrand/ishigami.py b/qmcpy/integrand/ishigami.py
index d5dd7b9e9..0334b627d 100644
--- a/qmcpy/integrand/ishigami.py
+++ b/qmcpy/integrand/ishigami.py
@@ -76,6 +76,14 @@ def __init__(self, sampler, a: float = 7, b: float = 0.1) -> None:
         )
 
     def g(self, t):
+        r"""Evaluate the Ishigami function.
+
+        Args:
+            t (np.ndarray): Three-dimensional points.
+
+        Returns:
+            np.ndarray: $(1 + b t_3^4)\sin(t_1) + a \sin^2(t_2)$.
+        """
         y = (1 + self.b * t[..., 2] ** 4) * np.sin(t[..., 0]) + self.a * np.sin(
             t[..., 1]
         ) ** 2
diff --git a/qmcpy/integrand/keister.py b/qmcpy/integrand/keister.py
index 2beb604cd..6036ee8be 100644
--- a/qmcpy/integrand/keister.py
+++ b/qmcpy/integrand/keister.py
@@ -61,6 +61,14 @@ def __init__(self, sampler) -> None:
         )
 
     def g(self, t):
+        r"""Evaluate the Keister function.
+
+        Args:
+            t (np.ndarray): Points, dimensions along the last axis.
+
+        Returns:
+            np.ndarray: $\pi^{d/2}\cos(\lVert t \rVert_2)$.
+        """
         d = t.shape[-1]
         norm = np.linalg.norm(t, axis=-1)
         k = np.pi ** (d / 2) * np.cos(norm)
@@ -94,4 +102,15 @@ def get_exact_value(cls, d: int):
         return I
 
     def exact_integ(self, *args, **kwargs):
+        """Return the exact value of the Keister integral.
+
+        Deprecated alias for :meth:`get_exact_value`.
+
+        Args:
+            *args (tuple): Forwarded to :meth:`get_exact_value`.
+            **kwargs (dict): Forwarded to :meth:`get_exact_value`.
+
+        Returns:
+            float: The exact integral value.
+        """
         return self.get_exact_value(*args, **kwargs)
diff --git a/qmcpy/integrand/linear0.py b/qmcpy/integrand/linear0.py
index 5dc54cbe3..135fa4a60 100644
--- a/qmcpy/integrand/linear0.py
+++ b/qmcpy/integrand/linear0.py
@@ -45,6 +45,14 @@ def __init__(self, sampler) -> None:
         )
 
     def g(self, t):
+        """Evaluate the centered linear function.
+
+        Args:
+            t (np.ndarray): Points, dimensions along the last axis.
+
+        Returns:
+            np.ndarray: Sum of the coordinates of each point.
+        """
         y = t.sum(-1)
         return y
 
diff --git a/qmcpy/integrand/multimodal2d.py b/qmcpy/integrand/multimodal2d.py
index d05853062..ced36790c 100644
--- a/qmcpy/integrand/multimodal2d.py
+++ b/qmcpy/integrand/multimodal2d.py
@@ -62,6 +62,14 @@ def __init__(self, sampler) -> None:
         )
 
     def g(self, t):
+        """Evaluate the two-dimensional multimodal function.
+
+        Args:
+            t (np.ndarray): Two-dimensional points.
+
+        Returns:
+            np.ndarray: Function values.
+        """
         t0, t1 = t[..., 0], t[..., 1]
         return (t0**2 + 4) * (t1 - 1) / 20 - np.sin(5 * t0 / 2) - 2
 
diff --git a/qmcpy/integrand/sensitivity_indices.py b/qmcpy/integrand/sensitivity_indices.py
index cba72fad6..0e461ec23 100644
--- a/qmcpy/integrand/sensitivity_indices.py
+++ b/qmcpy/integrand/sensitivity_indices.py
@@ -167,6 +167,17 @@ def __init__(self, integrand: AbstractIntegrand, indices: np.ndarray = "singleto
         self.d = 2 * self.dtilde
 
     def f(self, x, *args, **kwargs):
+        r"""Evaluate the numerator and moment terms needed for the sensitivity indices.
+
+        Args:
+            x (np.ndarray): Points from the discrete distribution.
+            *args (tuple): Forwarded to the wrapped integrand.
+            **kwargs (dict): Forwarded to the wrapped integrand; ``compute_flags``
+                selects which outputs to evaluate.
+
+        Returns:
+            np.ndarray: The $\tau$, mean, and second-moment terms.
+        """
         if "compute_flags" in kwargs:
             compute_flags = kwargs["compute_flags"]
             del kwargs["compute_flags"]
@@ -207,6 +218,16 @@ def _spawn(self, level, sampler):
         return SensitivityIndices(integrand=new_integrand, indices=self.indices)
 
     def bound_fun(self, bound_low, bound_high):
+        r"""Combine bounds on the moment terms into bounds on the sensitivity indices.
+
+        Args:
+            bound_low (np.ndarray): Lower bounds on $\tau$, the mean, and the second moment.
+            bound_high (np.ndarray): Upper bounds on the same terms.
+
+        Returns:
+            tuple: Lower and upper bounds on the indices, clipped to $[0,1]$ and
+            widened to $[0,1]$ where the variance bound is non-positive.
+        """
         tau_low, mu_low, f2_low = bound_low[:, 0], bound_low[:, 1], bound_low[:, 2]
         tau_high, mu_high, f2_high = (
             bound_high[:, 0],
@@ -226,4 +247,12 @@ def bound_fun(self, bound_low, bound_high):
         return comb_bounds_low, comb_bounds_high
 
     def dependency(self, comb_flags):
+        """Map combined-output flags onto the individual outputs they require.
+
+        Args:
+            comb_flags (np.ndarray): Flags for the combined outputs.
+
+        Returns:
+            np.ndarray: Flags for the three moment terms behind each index.
+        """
         return np.repeat(comb_flags[:, None], 3, axis=1)
diff --git a/qmcpy/integrand/sin1d.py b/qmcpy/integrand/sin1d.py
index a9c40bc34..c3328e06b 100644
--- a/qmcpy/integrand/sin1d.py
+++ b/qmcpy/integrand/sin1d.py
@@ -63,6 +63,14 @@ def __init__(self, sampler, k: float = 1) -> None:
         )
 
     def g(self, t):
+        r"""Evaluate the one-dimensional sine function.
+
+        Args:
+            t (np.ndarray): One-dimensional points.
+
+        Returns:
+            np.ndarray: $\sin(t)$.
+        """
         return np.sin(t[..., 0])
 
     def _spawn(self, level, sampler):
diff --git a/qmcpy/integrand/umbridge_wrapper.py b/qmcpy/integrand/umbridge_wrapper.py
index 2c8e44699..a2353b699 100644
--- a/qmcpy/integrand/umbridge_wrapper.py
+++ b/qmcpy/integrand/umbridge_wrapper.py
@@ -120,6 +120,15 @@ def __init__(self, true_measure, model, config: dict = None, parallel: int = Fal
         )
 
     def g(self, t, **kwargs):
+        """Evaluate the wrapped UM-Bridge model at each point.
+
+        Args:
+            t (np.ndarray): Points, model inputs along the last axis.
+            **kwargs (dict): Unused; accepted for API consistency.
+
+        Returns:
+            np.ndarray: Model outputs, flattened across the UM-Bridge output blocks.
+        """
         y = np.zeros((self.total_out_elements,) + tuple(t.shape[:-1]), dtype=float)
         idxiterator = np.ndindex(t.shape[:-1])
         for i in idxiterator:
diff --git a/qmcpy/util/data.py b/qmcpy/util/data.py
index 86a439796..24eeba46d 100644
--- a/qmcpy/util/data.py
+++ b/qmcpy/util/data.py
@@ -5,6 +5,11 @@
 
 
 class Data(object):
+    """Container for the state a stopping criterion accumulates while integrating.
+
+    Holds the parameters reported in the integration results and supports saving
+    to and loading from disk so a run can be resumed.
+    """
 
     def __init__(self, parameters) -> None:
         self.parameters = parameters
diff --git a/qmcpy/util/exact_gpytorch_regression_model.py b/qmcpy/util/exact_gpytorch_regression_model.py
index 5c179955c..765231f69 100644
--- a/qmcpy/util/exact_gpytorch_regression_model.py
+++ b/qmcpy/util/exact_gpytorch_regression_model.py
@@ -4,6 +4,12 @@
 
 
 class ExactGPyTorchRegressionModel(gpytorch.models.ExactGP):
+    """Exact Gaussian process regression model backed by GPyTorch.
+
+    Wraps ``gpytorch.models.ExactGP`` with fitting, chunked prediction, and
+    incremental data addition, optionally on the GPU.
+    """
+
     allowed_likelihood_types = (
         gpytorch.likelihoods.GaussianLikelihood,
         gpytorch.likelihoods.GaussianLikelihoodWithMissingObs,
@@ -32,11 +38,27 @@ def __init__(self, x_t, y_t, prior_mean, prior_cov, likelihood, use_gpu=False):
             self.likelihood = self.likelihood.cuda()
 
     def forward(self, x):
+        """Evaluate the GP prior at the given inputs.
+
+        Args:
+            x (torch.Tensor): Inputs of shape ``(n, d)``.
+
+        Returns:
+            gpytorch.distributions.MultivariateNormal: Prior distribution at ``x``.
+        """
         mean_x = self.mean_module(x)
         covar_x = self.covar_module(x)
         return gpytorch.distributions.MultivariateNormal(mean_x, covar_x)
 
     def fit(self, optimizer, mll, training_iter, verbose=0):
+        """Fit the model hyperparameters by maximizing the marginal log likelihood.
+
+        Args:
+            optimizer (torch.optim.Optimizer): Optimizer over the model parameters.
+            mll (gpytorch.mlls.MarginalLogLikelihood): Objective to maximize.
+            training_iter (int): Number of optimizer steps.
+            verbose (int): Print progress every ``verbose`` iterations; ``0`` is silent.
+        """
         self.train()
         self.likelihood.train()
         if verbose:
@@ -53,6 +75,18 @@ def fit(self, optimizer, mll, training_iter, verbose=0):
             optimizer.step()
 
     def predict(self, x, noise_const=0, chunk_size=2**15):
+        """Predict the posterior mean and standard deviation at new inputs.
+
+        Inputs are processed in chunks so large batches do not exhaust memory.
+
+        Args:
+            x (Union[np.ndarray, torch.Tensor]): Inputs of shape ``(n, d)``.
+            noise_const (float): Observation noise assumed at each new input.
+            chunk_size (int): Number of inputs evaluated per batch.
+
+        Returns:
+            tuple: Posterior mean and standard deviation, each of length ``n``.
+        """
         if isinstance(x, np.ndarray):
             x = torch.from_numpy(x)
         if not (x.ndim == 2 and x.shape[1] == self.d):
@@ -86,6 +120,16 @@ def _predict_batch(self, x, noise):
         return mean_post.numpy(), std_post.numpy()
 
     def add_data(self, x_t_new, y_t_new):
+        """Add observations to the training set and condition the model on them.
+
+        Args:
+            x_t_new (Union[np.ndarray, torch.Tensor]): New inputs of shape ``(n, d)``.
+            y_t_new (Union[np.ndarray, torch.Tensor]): New responses of length ``n``.
+
+        Returns:
+            ExactGPyTorchRegressionModel: Fantasy model conditioned on the combined
+            training set. The receiver is left unchanged.
+        """
         if isinstance(x_t_new, np.ndarray):
             x_t_new = torch.from_numpy(x_t_new)
         if isinstance(y_t_new, np.ndarray):
diff --git a/qmcpy/util/stop_notebook.py b/qmcpy/util/stop_notebook.py
index 1794c835f..bfb1a4a14 100644
--- a/qmcpy/util/stop_notebook.py
+++ b/qmcpy/util/stop_notebook.py
@@ -1,5 +1,17 @@
 def stop_notebook(query="Type 'yes' to continue running notebook"):
-    # This is a function to be able to stop a notebook when you run all cells
+    """Prompt at a notebook checkpoint and halt execution unless the user confirms.
+
+    Placed between cells so that "Run All" pauses instead of running an
+    expensive section unattended. Any answer other than ``yes`` (case
+    insensitive) calls :func:`sys.exit`, which the notebook kernel reports as a
+    stopped cell rather than a traceback.
+
+    Args:
+        query (str): Prompt shown to the user.
+
+    Raises:
+        SystemExit: If the answer is not ``yes``.
+    """
     keep_running = input(query)
     if keep_running.casefold() != "yes":
         import sys
diff --git a/qmcpy/util/torch_numpy_ops.py b/qmcpy/util/torch_numpy_ops.py
index 2f31c5bac..7358d5994 100644
--- a/qmcpy/util/torch_numpy_ops.py
+++ b/qmcpy/util/torch_numpy_ops.py
@@ -2,6 +2,17 @@
 
 
 def get_npt(x):
+    """Return the array backend module matching the input.
+
+    Args:
+        x (Union[np.ndarray, torch.Tensor]): Array whose backend is wanted.
+
+    Returns:
+        module: ``numpy`` for an ``np.ndarray``, otherwise ``torch``.
+
+    Raises:
+        AssertionError: If ``x`` is neither an ``np.ndarray`` nor a ``torch.Tensor``.
+    """
     if isinstance(x, np.ndarray):
         return np
     else:
diff --git a/qmcpy/util/transforms.py b/qmcpy/util/transforms.py
index 3c0f929d2..2497e9617 100644
--- a/qmcpy/util/transforms.py
+++ b/qmcpy/util/transforms.py
@@ -6,46 +6,132 @@
 
 
 def insert_batch_dims(param, ndims, k):
+    """Insert singleton dimensions into a parameter so it broadcasts against batched inputs.
+
+    Args:
+        param (Union[np.ndarray, torch.Tensor]): Parameter to reshape.
+        ndims (int): Number of singleton dimensions to insert.
+        k (int): Position at which to insert them.
+
+    Returns:
+        Union[np.ndarray, torch.Tensor]: ``param`` with ``ndims`` singleton axes
+        inserted after its first ``k`` axes.
+    """
     ones = [1] * ndims
     return param.reshape(list(param.shape[:k]) + ones + list(param.shape[k:]))
 
 
 def tf_exp(x):
+    """Exponential transform.
+
+    Args:
+        x (Union[np.ndarray, torch.Tensor]): Input values.
+
+    Returns:
+        Union[np.ndarray, torch.Tensor]: ``exp(x)``.
+    """
     npt = get_npt(x)
     return npt.exp(x)
 
 
 def tf_exp_inv(x):
+    """Inverse of the exponential transform.
+
+    Args:
+        x (Union[np.ndarray, torch.Tensor]): Input values.
+
+    Returns:
+        Union[np.ndarray, torch.Tensor]: ``log(x)``.
+    """
     npt = get_npt(x)
     return npt.log(x)
 
 
 def tf_exp_eps(x):
+    """Exponential transform offset by machine epsilon.
+
+    Args:
+        x (Union[np.ndarray, torch.Tensor]): Input values.
+
+    Returns:
+        Union[np.ndarray, torch.Tensor]: ``exp(x) + eps``, kept strictly positive.
+    """
     return tf_exp(x) + EPS64
 
 
 def tf_exp_eps_inv(x):
+    """Inverse of the epsilon-offset exponential transform.
+
+    Args:
+        x (Union[np.ndarray, torch.Tensor]): Input values.
+
+    Returns:
+        Union[np.ndarray, torch.Tensor]: ``log(x - eps)``.
+    """
     return tf_exp_inv(x - EPS64)
 
 
 def tf_square(x):
+    """Square transform.
+
+    Args:
+        x (Union[np.ndarray, torch.Tensor]): Input values.
+
+    Returns:
+        Union[np.ndarray, torch.Tensor]: ``x**2``.
+    """
     return x**2
 
 
 def tf_square_inv(x):
+    """Inverse of the square transform.
+
+    Args:
+        x (Union[np.ndarray, torch.Tensor]): Input values.
+
+    Returns:
+        Union[np.ndarray, torch.Tensor]: ``sqrt(x)``.
+    """
     npt = get_npt(x)
     return npt.sqrt(x)
 
 
 def tf_square_eps(x):
+    """Square transform offset by machine epsilon.
+
+    Args:
+        x (Union[np.ndarray, torch.Tensor]): Input values.
+
+    Returns:
+        Union[np.ndarray, torch.Tensor]: ``x**2 + eps``, kept strictly positive.
+    """
     return tf_square(x) + EPS64
 
 
 def tf_square_eps_inv(x):
+    """Inverse of the epsilon-offset square transform.
+
+    Args:
+        x (Union[np.ndarray, torch.Tensor]): Input values.
+
+    Returns:
+        Union[np.ndarray, torch.Tensor]: ``sqrt(x - eps)``.
+    """
     return tf_square_inv(x - EPS64)
 
 
 def tf_explinear(x):
+    """Exponential-linear (softplus) transform.
+
+    Behaves like ``exp(x)`` for small ``x`` and like ``x`` for large ``x``, so it
+    maps the real line to the positive reals without overflowing.
+
+    Args:
+        x (Union[np.ndarray, torch.Tensor]): Input values.
+
+    Returns:
+        Union[np.ndarray, torch.Tensor]: ``log(1 + exp(x))``, computed stably.
+    """
     npt = get_npt(x)
     if npt == np:
         return -scipy.special.log_expit(-x)
@@ -54,19 +140,52 @@ def tf_explinear(x):
 
 
 def tf_explinear_inv(x):
+    """Inverse of the exponential-linear transform.
+
+    Args:
+        x (Union[np.ndarray, torch.Tensor]): Input values.
+
+    Returns:
+        Union[np.ndarray, torch.Tensor]: ``log(expm1(x))``, falling back to ``x`` once ``x >= 34``
+        where the two agree to machine precision.
+    """
     npt = get_npt(x)
     return npt.where(x < 34, npt.log(npt.expm1(x)), x)
 
 
 def tf_explinear_eps(x):
+    """Exponential-linear transform offset by machine epsilon.
+
+    Args:
+        x (Union[np.ndarray, torch.Tensor]): Input values.
+
+    Returns:
+        Union[np.ndarray, torch.Tensor]: ``tf_explinear(x) + eps``, kept strictly positive.
+    """
     return tf_explinear(x) + EPS64
 
 
 def tf_explinear_eps_inv(x):
+    """Inverse of the epsilon-offset exponential-linear transform.
+
+    Args:
+        x (Union[np.ndarray, torch.Tensor]): Input values.
+
+    Returns:
+        Union[np.ndarray, torch.Tensor]: ``tf_explinear_inv(x - eps)``.
+    """
     return tf_explinear_inv(x - EPS64)
 
 
 def tf_identity(x):
+    """Identity transform.
+
+    Args:
+        x (Union[np.ndarray, torch.Tensor]): Input values.
+
+    Returns:
+        Union[np.ndarray, torch.Tensor]: ``x`` unchanged.
+    """
     return x
 
 
@@ -82,6 +201,26 @@ def parse_assign_param(
     npt,
     nptkwargs,
 ):
+    """Validate and normalize one kernel parameter, returning it in array form.
+
+    A scalar is broadcast to ``shape_param``; an array-like is converted to the
+    backend array type and checked against the supplied constraints.
+
+    Args:
+        pname (str): Parameter name, used in error messages.
+        param (Union[float, np.ndarray, torch.Tensor]): Value to normalize.
+        shape_param (list): Target shape used when ``param`` is a scalar.
+        requires_grad_param (bool): Whether the torch parameter requires a gradient.
+        tfs_param (tuple): Pair of forward and inverse transforms for this parameter.
+        endsize_ops (list): Permitted sizes for the trailing dimension.
+        constraints (list): Constraints the parameter must satisfy.
+        torchify (bool): Return a ``torch.Tensor`` rather than an ``np.ndarray``.
+        npt (module): Array backend, either ``numpy`` or ``torch``.
+        nptkwargs (dict): Backend keyword arguments such as ``dtype`` and ``device``.
+
+    Returns:
+        tuple: The normalized parameter, its shape, and its transformed value.
+    """
     if np.isscalar(param):
         param = param * npt.ones(shape_param, **nptkwargs)
     else:

From 90d105aeabab166c36d73575ab3f5e7d3d648533 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Tue, 8 Sep 2026 16:27:36 +0800
Subject: [PATCH 37/51] Fix typos

---
 .../abstract_discrete_distribution.py                     | 2 +-
 .../digital_net_b2/digital_net_b2.py                      | 4 ++--
 qmcpy/discrete_distribution/iid_std_uniform.py            | 2 +-
 qmcpy/discrete_distribution/latin_hypercube.py            | 4 ++--
 qmcpy/integrand/abstract_integrand.py                     | 2 +-
 qmcpy/integrand/sensitivity_indices.py                    | 8 +++++---
 qmcpy/kernel/si_dsi_kernels.py                            | 6 +++---
 qmcpy/stopping_criterion/abstract_stopping_criterion.py   | 2 +-
 qmcpy/stopping_criterion/cub_mc_clt_vec.py                | 4 ++--
 qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py       | 4 ++--
 qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py           | 4 ++--
 qmcpy/stopping_criterion/cub_qmc_lattice_g.py             | 4 ++--
 qmcpy/stopping_criterion/cub_qmc_net_g.py                 | 4 ++--
 qmcpy/stopping_criterion/cub_qmc_rep_student_t.py         | 4 ++--
 qmcpy/stopping_criterion/diagnostics.py                   | 4 ++--
 qmcpy/stopping_criterion/pf_gp_ci.py                      | 2 +-
 qmcpy/util/dig_shift_invar_ops.py                         | 4 ++--
 qmcpy/util/mlmc_test.py                                   | 2 +-
 18 files changed, 34 insertions(+), 32 deletions(-)

diff --git a/qmcpy/discrete_distribution/abstract_discrete_distribution.py b/qmcpy/discrete_distribution/abstract_discrete_distribution.py
index 20abe9fef..c31ade832 100644
--- a/qmcpy/discrete_distribution/abstract_discrete_distribution.py
+++ b/qmcpy/discrete_distribution/abstract_discrete_distribution.py
@@ -26,7 +26,7 @@ def __init__(self, dimension, replications, seed, d_limit, n_limit) -> None:
         self.no_replications = replications is None
         self.replications = 1 if self.no_replications else int(replications)
         if self.replications < 0:
-            raise ParameterError("replications must be None or a postive int")
+            raise ParameterError("replications must be None or a positive int")
         if (
             isinstance(dimension, list)
             or isinstance(dimension, tuple)
diff --git a/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py b/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
index 329f9e3b1..4916592f4 100644
--- a/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
+++ b/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
@@ -258,7 +258,7 @@ def __init__(
 
             order (str): `'RADICAL INVERSE'`, or `'GRAY'` ordering. See the
                 doctest example above.
-            t (int): Number of bits in integer represetation of points *after*
+            t (int): Number of bits in integer representation of points *after*
                 randomization. The number of bits in the generating matrices is
                 inferred based on the largest value.
             alpha (int): Interlacing factor for higher order nets. When
@@ -702,7 +702,7 @@ def _try_gen_samples_float(self, r, n, d, n_start, mmax, r_x, return_binary):
     def _gen_samples(self, n_min, n_max, return_binary, warn):
         if n_min == 0 and self.randomize in ["FALSE", "LMS"] and warn:
             warnings.warn(
-                "Without randomization, the first digtial net point is the origin",
+                "Without randomization, the first digital net point is the origin",
                 ParameterWarning,
             )
         r_x = np.uint64(self.gen_mats.shape[0])
diff --git a/qmcpy/discrete_distribution/iid_std_uniform.py b/qmcpy/discrete_distribution/iid_std_uniform.py
index 77805ad0a..8dd882d01 100644
--- a/qmcpy/discrete_distribution/iid_std_uniform.py
+++ b/qmcpy/discrete_distribution/iid_std_uniform.py
@@ -64,7 +64,7 @@ def __init__(self, dimension: int = 1, replications=None, seed=None) -> None:
             int(dimension), replications, seed, d_limit=np.inf, n_limit=np.inf
         )
         if not (self.dvec == np.arange(self.d)).all():
-            warnings.warn("IIDStdUniform does not accomodate dvec", ParameterWarning)
+            warnings.warn("IIDStdUniform does not accommodate dvec", ParameterWarning)
 
     def _gen_samples(self, n_min, n_max, return_binary, warn):
         if n_min > 0 and warn:
diff --git a/qmcpy/discrete_distribution/latin_hypercube.py b/qmcpy/discrete_distribution/latin_hypercube.py
index 3dac43e57..c37beacf8 100644
--- a/qmcpy/discrete_distribution/latin_hypercube.py
+++ b/qmcpy/discrete_distribution/latin_hypercube.py
@@ -129,7 +129,7 @@ def __init__(
     def _gen_samples(
             self, n=None, n_min=None, n_max=None, return_binary=False, warn=True
         ):
-        r"""..."""  # (inchangee)
+        r"""..."""  # (unchanged)
         if return_binary:
             raise ParameterError("LatinHypercube does not support return_binary=True")
         if n_min != 0:
@@ -166,4 +166,4 @@ def _spawn(self, child_seed, dimension):
         )
 
     def __repr__(self):
-        return super().__repr__("LatinHypercube")
\ No newline at end of file
+        return super().__repr__("LatinHypercube")
diff --git a/qmcpy/integrand/abstract_integrand.py b/qmcpy/integrand/abstract_integrand.py
index 7c9fb9c4e..dc7d5328c 100644
--- a/qmcpy/integrand/abstract_integrand.py
+++ b/qmcpy/integrand/abstract_integrand.py
@@ -176,7 +176,7 @@ def f(self, x: np.ndarray, *args: tuple, **kwargs: dict):
                 specifies a periodization transform. Options are:
 
                 - `False`: No periodizing transform, $\psi(x) = x$.
-                - `'BAKER'`: Baker tansform $\psi(x) = 1-2\lvert x-1/2 \rvert$.
+                - `'BAKER'`: Baker transform $\psi(x) = 1-2\lvert x-1/2 \rvert$.
                 - `'C0'`: $C^0$ transform $\psi(x) = 3x^2-2x^3$.
                 - `'C1'`: $C^1$ transform $\psi(x) = x^3(10-15x+6x^2)$.
                 - `'C1SIN'`: Sidi $C^1$ transform $\psi(x) = x-\sin(2 \pi x)/(2 \pi)$.
diff --git a/qmcpy/integrand/sensitivity_indices.py b/qmcpy/integrand/sensitivity_indices.py
index 0e461ec23..364cc895c 100644
--- a/qmcpy/integrand/sensitivity_indices.py
+++ b/qmcpy/integrand/sensitivity_indices.py
@@ -208,9 +208,11 @@ def f(self, x, *args, **kwargs):
             y[(slice(None), 2) + i + self.i_slice] = (
                 f_x[(None,) + self.i_slice] ** 2
             )  # sigma^2+mu^2
-            # here we copy mu and sigma^2+mu^2 since if these these were not copied there is a chance the bounds could change
-            # for mu and/or sigma and then an index which was previously approximated sufficiently woulud become insufficientlly approximated
-            # and it would then be difficult ot go back and resample the numerator for that approximation
+            # Here we copy mu and sigma^2+mu^2 since, if these were not copied,
+            # there is a chance the bounds could change for mu and/or sigma.
+            # Then an index that was previously approximated sufficiently could
+            # become insufficiently approximated, and it would be difficult to
+            # go back and resample the numerator for that approximation.
         return y
 
     def _spawn(self, level, sampler):
diff --git a/qmcpy/kernel/si_dsi_kernels.py b/qmcpy/kernel/si_dsi_kernels.py
index 96493835a..1af58a5eb 100644
--- a/qmcpy/kernel/si_dsi_kernels.py
+++ b/qmcpy/kernel/si_dsi_kernels.py
@@ -841,7 +841,7 @@ def __init__(
 
         Args:
             d (int): Dimension.
-            t (int): number of bits in binary represtnations. Typically
+            t (int): number of bits in binary representations. Typically
                 `dnb2.t` where `isinstance(dnb2,DigitalNetB2)`.
             scale (Union[np.ndarray, torch.Tensor]): Scaling factor $S$.
             lengthscales (Union[np.ndarray, torch.Tensor]): Product weights
@@ -1126,7 +1126,7 @@ def __init__(
 
         Args:
             d (int): Dimension.
-            t (int): number of bits in binary represtnations. Typically
+            t (int): number of bits in binary representations. Typically
                 `dnb2.t` where `isinstance(dnb2,DigitalNetB2)`.
             scale (Union[np.ndarray, torch.Tensor]): Scaling factor $S$.
             lengthscales (Union[np.ndarray, torch.Tensor]): Product weights
@@ -1381,7 +1381,7 @@ def __init__(
 
         Args:
             d (int): Dimension.
-            t (int): number of bits in binary represtnations. Typically
+            t (int): number of bits in binary representations. Typically
                 `dnb2.t` where `isinstance(dnb2,DigitalNetB2)`.
             scale (Union[np.ndarray, torch.Tensor]): Scaling factor $S$.
             lengthscales (Union[np.ndarray, torch.Tensor]): Product weights
diff --git a/qmcpy/stopping_criterion/abstract_stopping_criterion.py b/qmcpy/stopping_criterion/abstract_stopping_criterion.py
index d153f14a2..cb63b3a22 100644
--- a/qmcpy/stopping_criterion/abstract_stopping_criterion.py
+++ b/qmcpy/stopping_criterion/abstract_stopping_criterion.py
@@ -546,7 +546,7 @@ def _validate_resume_data(self, data, required_fields=()):
     def _validate_resume_with_state(self, data, required_fields=(), state_fields=()):
         """Validate resume data including algorithm-specific state fields.
 
-        Calls: meth:`_validate_resume_data` and additionally checks that all
+        Calls :meth:`_validate_resume_data` and additionally checks that all
         *state_fields* are present and that ``n_total >= n_init``.
 
         Args:
diff --git a/qmcpy/stopping_criterion/cub_mc_clt_vec.py b/qmcpy/stopping_criterion/cub_mc_clt_vec.py
index 80a3443ae..8a4215755 100644
--- a/qmcpy/stopping_criterion/cub_mc_clt_vec.py
+++ b/qmcpy/stopping_criterion/cub_mc_clt_vec.py
@@ -180,12 +180,12 @@ def __init__(
                 solution, absolute error tolerance, and relative error
                 tolerance to the current error bound.
 
-                - `'EITHER'`, the default, requires the approximation error must be below either the absolue *or* relative tolerance.
+                - `'EITHER'`, the default, requires the approximation error to be below either the absolute *or* relative tolerance.
                     Equivalent to setting
                     ```python
                     error_fun = lambda sv,abs_tol,rel_tol: np.maximum(abs_tol,abs(sv)*rel_tol)
                     ```
-                - `'BOTH'` requires the approximation error to be below both the absolue *and* relative tolerance.
+                - `'BOTH'` requires the approximation error to be below both the absolute *and* relative tolerance.
                     Equivalent to setting
                     ```python
                     error_fun = lambda sv,abs_tol,rel_tol: np.minimum(abs_tol,abs(sv)*rel_tol)
diff --git a/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py b/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py
index 253f8f4d1..ef2261f52 100644
--- a/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py
+++ b/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py
@@ -205,12 +205,12 @@ def __init__(
                 solution, absolute error tolerance, and relative error
                 tolerance to the current error bound.
 
-                - `'EITHER'`, the default, requires the approximation error must be below either the absolue *or* relative tolerance.
+                - `'EITHER'`, the default, requires the approximation error to be below either the absolute *or* relative tolerance.
                     Equivalent to setting
                     ```python
                     error_fun = lambda sv,abs_tol,rel_tol: np.maximum(abs_tol,abs(sv)*rel_tol)
                     ```
-                - `'BOTH'` requires the approximation error to be below both the absolue *and* relative tolerance.
+                - `'BOTH'` requires the approximation error to be below both the absolute *and* relative tolerance.
                     Equivalent to setting
                     ```python
                     error_fun = lambda sv,abs_tol,rel_tol: np.minimum(abs_tol,abs(sv)*rel_tol)
diff --git a/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py b/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py
index f587b54d6..80266a464 100644
--- a/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py
+++ b/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py
@@ -212,12 +212,12 @@ def __init__(
                 solution, absolute error tolerance, and relative error
                 tolerance to the current error bound.
 
-                - `'EITHER'`, the default, requires the approximation error must be below either the absolue *or* relative tolerance.
+                - `'EITHER'`, the default, requires the approximation error to be below either the absolute *or* relative tolerance.
                     Equivalent to setting
                     ```python
                     error_fun = lambda sv,abs_tol,rel_tol: np.maximum(abs_tol,abs(sv)*rel_tol)
                     ```
-                - `'BOTH'` requires the approximation error to be below both the absolue *and* relative tolerance.
+                - `'BOTH'` requires the approximation error to be below both the absolute *and* relative tolerance.
                     Equivalent to setting
                     ```python
                     error_fun = lambda sv,abs_tol,rel_tol: np.minimum(abs_tol,abs(sv)*rel_tol)
diff --git a/qmcpy/stopping_criterion/cub_qmc_lattice_g.py b/qmcpy/stopping_criterion/cub_qmc_lattice_g.py
index 59c0d183f..d4a419825 100644
--- a/qmcpy/stopping_criterion/cub_qmc_lattice_g.py
+++ b/qmcpy/stopping_criterion/cub_qmc_lattice_g.py
@@ -197,12 +197,12 @@ def __init__(
                 solution, absolute error tolerance, and relative error
                 tolerance to the current error bound.
 
-                - `'EITHER'`, the default, requires the approximation error must be below either the absolue *or* relative tolerance.
+                - `'EITHER'`, the default, requires the approximation error to be below either the absolute *or* relative tolerance.
                     Equivalent to setting
                     ```python
                     error_fun = lambda sv,abs_tol,rel_tol: np.maximum(abs_tol,abs(sv)*rel_tol)
                     ```
-                - `'BOTH'` requires the approximation error to be below both the absolue *and* relative tolerance.
+                - `'BOTH'` requires the approximation error to be below both the absolute *and* relative tolerance.
                     Equivalent to setting
                     ```python
                     error_fun = lambda sv,abs_tol,rel_tol: np.minimum(abs_tol,abs(sv)*rel_tol)
diff --git a/qmcpy/stopping_criterion/cub_qmc_net_g.py b/qmcpy/stopping_criterion/cub_qmc_net_g.py
index 467c85842..6a6dea801 100644
--- a/qmcpy/stopping_criterion/cub_qmc_net_g.py
+++ b/qmcpy/stopping_criterion/cub_qmc_net_g.py
@@ -241,12 +241,12 @@ def __init__(
                 solution, absolute error tolerance, and relative error
                 tolerance to the current error bound.
 
-                - `'EITHER'`, the default, requires the approximation error must be below either the absolue *or* relative tolerance.
+                - `'EITHER'`, the default, requires the approximation error to be below either the absolute *or* relative tolerance.
                     Equivalent to setting
                     ```python
                     error_fun = lambda sv,abs_tol,rel_tol: np.maximum(abs_tol,abs(sv)*rel_tol)
                     ```
-                - `'BOTH'` requires the approximation error to be below both the absolue *and* relative tolerance.
+                - `'BOTH'` requires the approximation error to be below both the absolute *and* relative tolerance.
                     Equivalent to setting
                     ```python
                     error_fun = lambda sv,abs_tol,rel_tol: np.minimum(abs_tol,abs(sv)*rel_tol)
diff --git a/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py b/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py
index ee275cfae..ef9def0aa 100644
--- a/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py
+++ b/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py
@@ -225,12 +225,12 @@ def __init__(
                 solution, absolute error tolerance, and relative error
                 tolerance to the current error bound.
 
-                - `'EITHER'`, the default, requires the approximation error must be below either the absolue *or* relative tolerance.
+                - `'EITHER'`, the default, requires the approximation error to be below either the absolute *or* relative tolerance.
                     Equivalent to setting
                     ```python
                     error_fun = lambda sv,abs_tol,rel_tol: np.maximum(abs_tol,abs(sv)*rel_tol)
                     ```
-                - `'BOTH'` requires the approximation error to be below both the absolue *and* relative tolerance.
+                - `'BOTH'` requires the approximation error to be below both the absolute *and* relative tolerance.
                     Equivalent to setting
                     ```python
                     error_fun = lambda sv,abs_tol,rel_tol: np.minimum(abs_tol,abs(sv)*rel_tol)
diff --git a/qmcpy/stopping_criterion/diagnostics.py b/qmcpy/stopping_criterion/diagnostics.py
index 51cab2c0d..cea58a0df 100644
--- a/qmcpy/stopping_criterion/diagnostics.py
+++ b/qmcpy/stopping_criterion/diagnostics.py
@@ -673,7 +673,7 @@ def _seed_history_from_resume(self, data):
     def iteration(self, data, step_value=None):
         """Emit an ITER row, unless state is unchanged since the last resume.
 
-        If: meth:`resume` was just called and the data state has not changed
+        If :meth:`resume` was just called and the data state has not changed
         (same ``n_total``, ``n_min``, ``m``, and ``xfull.shape``), the row is
         suppressed to avoid a duplicate log entry.
 
@@ -781,4 +781,4 @@ def _print_diagnostic(
         header_line = " ".join(header_values[column] for column in visible_columns)
         print(header_line)
         print("-" * len(header_line))
-    print(" ".join(aligned_row_values[column] for column in visible_columns))
\ No newline at end of file
+    print(" ".join(aligned_row_values[column] for column in visible_columns))
diff --git a/qmcpy/stopping_criterion/pf_gp_ci.py b/qmcpy/stopping_criterion/pf_gp_ci.py
index a271c576a..0e121ef05 100644
--- a/qmcpy/stopping_criterion/pf_gp_ci.py
+++ b/qmcpy/stopping_criterion/pf_gp_ci.py
@@ -234,7 +234,7 @@ def __init__(
             gpytorch_train_iter (int): Training iterations for the GP in
                 gpytorch
             gpytorch_use_gpu (bool): If True, have gpytorch use a GPU for
-                fitting and trining the GP
+                fitting and training the GP
             verbose (int): If verbose > 0, print information through the call
                 to integrate()
             n_ref_approx (int): If n_ref_approx > 0, use n_ref_approx points to
diff --git a/qmcpy/util/dig_shift_invar_ops.py b/qmcpy/util/dig_shift_invar_ops.py
index fe5835382..7fad7aefd 100644
--- a/qmcpy/util/dig_shift_invar_ops.py
+++ b/qmcpy/util/dig_shift_invar_ops.py
@@ -184,7 +184,7 @@ def to_bin(x, t: int):
     Args:
         x (Union[np.ndarray, torch.Tensor]): floating point representation of
             samples.
-        t (int): number of bits in binary represtnations. Typically `dnb2.t`
+        t (int): number of bits in binary representations. Typically `dnb2.t`
             where `isinstance(dnb2,DigitalNetB2)`.
 
     Returns:
@@ -227,7 +227,7 @@ def to_float(x, t: int):
     Args:
         x (Union[np.ndarray, torch.Tensor]): binary representation of samples
             with `dtype` either `np.uint64` or `torch.int64`.
-        t (int): number of bits in binary represtnations. Typically `dnb2.t`
+        t (int): number of bits in binary representations. Typically `dnb2.t`
             where `isinstance(dnb2,DigitalNetB2)`.
 
     Returns:
diff --git a/qmcpy/util/mlmc_test.py b/qmcpy/util/mlmc_test.py
index 26d28519e..863868897 100644
--- a/qmcpy/util/mlmc_test.py
+++ b/qmcpy/util/mlmc_test.py
@@ -75,7 +75,7 @@ def mlmc_test(
         cst = 0
         integrand_spawn = integrand_spawns[ll]
         for j in range(1,101):
-            # evaluate integral at sampleing points samples
+            # Evaluate the integral at sampled points.
             samples = integrand_spawn.discrete_distrib.gen_samples(n=n/100)
             Pc,Pf = integrand_spawn.f(samples)
             dP = Pf-Pc

From be8afbf2356a6462d5e8af55117f4c8cbad5100c Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Tue, 8 Sep 2026 16:32:02 +0800
Subject: [PATCH 38/51] Fix "make doc" warnings

---
 qmcpy/integrand/bayesian_lr_coeffs.py  | 4 ++--
 qmcpy/integrand/financial_option.py    | 2 +-
 qmcpy/integrand/sensitivity_indices.py | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/qmcpy/integrand/bayesian_lr_coeffs.py b/qmcpy/integrand/bayesian_lr_coeffs.py
index 4560d1c79..6b2608ce9 100644
--- a/qmcpy/integrand/bayesian_lr_coeffs.py
+++ b/qmcpy/integrand/bayesian_lr_coeffs.py
@@ -92,7 +92,7 @@ def g(self, x):
 
         Returns:
             np.ndarray: Stacked numerator (coefficient-weighted likelihood) and
-            denominator (likelihood), whose ratio is the posterior mean.
+                denominator (likelihood), whose ratio is the posterior mean.
         """
         z = np.einsum("...j,ij->...i", x, self.feature_array)
         z1 = z * self.response_vector
@@ -121,7 +121,7 @@ def bound_fun(self, bound_low, bound_high):
 
         Returns:
             tuple: Lower and upper bounds on the ratio, infinite where the
-            denominator interval straddles zero.
+                denominator interval straddles zero.
         """
         num_bounds_low, den_bounds_low = bound_low[0], bound_low[1]
         num_bounds_high, den_bounds_high = bound_high[0], bound_high[1]
diff --git a/qmcpy/integrand/financial_option.py b/qmcpy/integrand/financial_option.py
index 04122cc92..44d0eef06 100644
--- a/qmcpy/integrand/financial_option.py
+++ b/qmcpy/integrand/financial_option.py
@@ -456,7 +456,7 @@ def g(self, t, **kwargs):
 
         Returns:
             np.ndarray: Discounted payoffs; for a multilevel problem, the coarse
-            and fine payoffs stacked together.
+                and fine payoffs stacked together.
         """
         gbm = t  # GeometricBrownianMotion already provides GBM paths directly
         discounted_payoffs = self.payoff(gbm) * self.discount_factor
diff --git a/qmcpy/integrand/sensitivity_indices.py b/qmcpy/integrand/sensitivity_indices.py
index 364cc895c..11020a68d 100644
--- a/qmcpy/integrand/sensitivity_indices.py
+++ b/qmcpy/integrand/sensitivity_indices.py
@@ -228,7 +228,7 @@ def bound_fun(self, bound_low, bound_high):
 
         Returns:
             tuple: Lower and upper bounds on the indices, clipped to $[0,1]$ and
-            widened to $[0,1]$ where the variance bound is non-positive.
+                widened to $[0,1]$ where the variance bound is non-positive.
         """
         tau_low, mu_low, f2_low = bound_low[:, 0], bound_low[:, 1], bound_low[:, 2]
         tau_high, mu_high, f2_high = (

From 9c0b5b1b4e583a361e8a474892f9a188bcc8636e Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Tue, 8 Sep 2026 22:14:43 +0800
Subject: [PATCH 39/51] Add missing docstrings. Enhance docstrings format.

---
 .../abstract_discrete_distribution.py         |  19 +++
 qmcpy/discrete_distribution/korobov.py        |  11 ++
 qmcpy/discrete_distribution/kronecker.py      |  46 +++---
 .../discrete_distribution/lattice/lattice.py  |  15 ++
 qmcpy/discrete_distribution/mpmc/models.py    |  57 ++++++++
 qmcpy/kernel/abstract_kernel.py               |  73 ++++++++++
 qmcpy/kernel/common_kernels.py                |  32 ++++
 qmcpy/kernel/multitask_kernel.py              |  20 +++
 qmcpy/kernel/si_dsi_kernels.py                | 123 ++++++++++++++++
 .../abstract_cub_bayes_ld_g.py                |  86 ++++++++++-
 qmcpy/stopping_criterion/abstract_cub_mlmc.py |  19 +++
 .../stopping_criterion/abstract_cub_mlqmc.py  |  32 ++++
 .../abstract_cub_qmc_ld_g.py                  |  39 +++++
 .../abstract_stopping_criterion.py            |  10 ++
 qmcpy/stopping_criterion/cub_mc_clt.py        |  27 ++++
 qmcpy/stopping_criterion/cub_mc_clt_vec.py    |  27 ++++
 qmcpy/stopping_criterion/cub_mc_g.py          |  52 +++++--
 qmcpy/stopping_criterion/cub_mlmc.py          |  10 +-
 qmcpy/stopping_criterion/cub_mlmc_cont.py     |  22 +--
 qmcpy/stopping_criterion/cub_mlqmc.py         |  10 +-
 qmcpy/stopping_criterion/cub_mlqmc_cont.py    |  10 +-
 .../stopping_criterion/cub_qmc_bayes_net_g.py |  14 +-
 .../cub_qmc_rep_student_t.py                  |  33 ++++-
 qmcpy/stopping_criterion/pf_gp_ci.py          | 137 ++++++++++++++++++
 qmcpy/true_measure/abstract_true_measure.py   |  28 ++++
 qmcpy/true_measure/product_measure.py         |  16 ++
 qmcpy/true_measure/triangular.py              |  16 ++
 scripts/baseline_counts.json                  |   2 +-
 scripts/check_baseline.py                     |  10 +-
 scripts/check_docstring.py                    |  16 ++
 30 files changed, 944 insertions(+), 68 deletions(-)

diff --git a/qmcpy/discrete_distribution/abstract_discrete_distribution.py b/qmcpy/discrete_distribution/abstract_discrete_distribution.py
index c31ade832..48001d8fb 100644
--- a/qmcpy/discrete_distribution/abstract_discrete_distribution.py
+++ b/qmcpy/discrete_distribution/abstract_discrete_distribution.py
@@ -7,6 +7,12 @@
 
 
 class AbstractDiscreteDistribution(object):
+    """Abstract base class for QMCPy discrete distributions (samplers).
+
+    Every concrete discrete distribution (e.g. `DigitalNetB2`, `Lattice`,
+    `IIDStdUniform`) subclasses this and implements `_gen_samples` and
+    `_spawn`.
+    """
 
     def __init__(self, dimension, replications, seed, d_limit, n_limit) -> None:
         self.mimics = "StdUniform"
@@ -83,6 +89,9 @@ def __call__(self, n=None, n_min=None, n_max=None, return_binary=False, warn=Tru
     def gen_samples(
         self, n=None, n_min=None, n_max=None, return_binary=False, warn=True
     ):
+        r"""Generate samples from the sequence. Called by `__call__`; see its
+        docstring for the full `Args:`/`Returns:` description.
+        """
         if n is not None and n_min is None and n_max is None:
             n_min = 0
             n_max = int(n)
@@ -166,6 +175,16 @@ def _spawn(self, child_seed, dimension):
         raise MethodImplementationError(self, "_spawn")
 
     def pdf(self, x):
+        """Probability density function of the distribution this sampler mimics.
+
+        Args:
+            x (np.ndarray): Points at which to evaluate the density, shape `(*batch_shape, d)`.
+
+        Returns:
+            np.ndarray: Density values with shape `batch_shape`. The base
+                implementation is uniform on `[0,1]^d` (density 1 everywhere);
+                subclasses that mimic a different distribution override this.
+        """
         return np.ones_like(x[..., 0])
 
     def __repr__(self, abc_class_name):
diff --git a/qmcpy/discrete_distribution/korobov.py b/qmcpy/discrete_distribution/korobov.py
index b04554764..33e2917d8 100644
--- a/qmcpy/discrete_distribution/korobov.py
+++ b/qmcpy/discrete_distribution/korobov.py
@@ -26,6 +26,17 @@ def load_korobov_table(
     return raw, lut
 
 def get_a(lut, n, d):
+    """Look up the tabulated Korobov generator `a` for a given `n` and `d`.
+
+    Args:
+        lut (dict): Lookup table returned by the module's table loader, with
+            keys `n_values`, `d_values`, and `a`.
+        n (int): Number of points; must be one of `lut["n_values"]`.
+        d (int): Dimension; must be one of `lut["d_values"]`.
+
+    Returns:
+        int: The tabulated generator value `a` for this `(n, d)` pair.
+    """
     i = np.searchsorted(lut["n_values"], n)
     if i >= len(lut["n_values"]) or lut["n_values"][i] != n:
         raise ParameterError(
diff --git a/qmcpy/discrete_distribution/kronecker.py b/qmcpy/discrete_distribution/kronecker.py
index ddd03b1f3..eaabf912f 100644
--- a/qmcpy/discrete_distribution/kronecker.py
+++ b/qmcpy/discrete_distribution/kronecker.py
@@ -341,22 +341,23 @@ def _gen_samples(self, n_min, n_max, return_binary, warn):
         return points
 
     def periodic_discrepancy(self, n, k_tilde=None, gamma=None):
-        # """
-        # Calculates the discrepancy for a periodic kernel.
-
-        # Args:
-        #     n (int): the number of sample points
-        #     k_tilde (Tuple[function, float]): the function takes in 2 arguments: the sample points and the coordinate weights.
-        #         The float is the integral over the unit hypercube.
-        #     gamma (np.ndarray): shape (1xd)
-
-        # Returns:
-        #     discrep (np.ndarray): discrepancy
-
-        # Notes:
-        #     - If k_tilde is not specified, the second Bernoulli polynomial is used.
-        #     - If gamma is not specified, the coordinate weights will be just all ones.
-        # """
+        """Calculate the discrepancy for a periodic kernel.
+
+        Args:
+            n (int): The number of sample points.
+            k_tilde (Tuple[callable, float]): A `(function, integral)` pair
+                where the function takes the sample points and coordinate
+                weights and returns kernel values, and `integral` is that
+                function's integral over the unit hypercube.
+            gamma (np.ndarray): Coordinate weights, shape `(d,)`.
+
+        Returns:
+            np.ndarray: The discrepancy.
+
+        Note:
+            - If `k_tilde` is not specified, the second Bernoulli polynomial is used.
+            - If `gamma` is not specified, the coordinate weights are all ones.
+        """
         if gamma is None:
             gamma = np.ones(self.d)
 
@@ -367,7 +368,18 @@ def periodic_discrepancy(self, n, k_tilde=None, gamma=None):
 
 
     def wssd_discrepancy(self, n, weights, k_tilde = None, gamma = None):
-        # calculates the weighted sum of square discrepancy
+        """Calculate the weighted sum of squared discrepancies.
+
+        Args:
+            n (int): The number of sample points.
+            weights (np.ndarray): Weights applied to each squared discrepancy
+                before summing.
+            k_tilde (Tuple[callable, float]): Same as in `periodic_discrepancy`.
+            gamma (np.ndarray): Coordinate weights, shape `(d,)`.
+
+        Returns:
+            np.ndarray: The weighted sum of squared discrepancies.
+        """
         if gamma is None:
             gamma = np.ones(self.d)
 
diff --git a/qmcpy/discrete_distribution/lattice/lattice.py b/qmcpy/discrete_distribution/lattice/lattice.py
index 3eb1efb9b..411f6668d 100644
--- a/qmcpy/discrete_distribution/lattice/lattice.py
+++ b/qmcpy/discrete_distribution/lattice/lattice.py
@@ -372,6 +372,21 @@ def _gen_block_linear(self, m_next, first=True):
         return x
 
     def calculate_y(self, m_low, m_high, y):
+        """Refine 1D interval midpoints from level `m_low` up to `m_high`.
+
+        At each level, interleaves the current midpoints `y` with the new
+        midpoints introduced at that level, doubling the length of `y` each
+        step. Used internally by `_gail_linear` to build up linear-order
+        lattice coordinates level-by-level.
+
+        Args:
+            m_low (int): Starting level (`y` must already hold the midpoints for this level).
+            m_high (int): Final level (exclusive) to refine up to.
+            y (np.ndarray): Interval midpoints at level `m_low`, shape `(2**(m_low-1), 1)`.
+
+        Returns:
+            np.ndarray: Interval midpoints at level `m_high`, shape `(2**(m_high-1), 1)`.
+        """
         for m in range(m_low, m_high):
             n = 2**m
             y_next = np.arange(1 / n, 1, 2 / n).reshape((int(n / 2), 1))
diff --git a/qmcpy/discrete_distribution/mpmc/models.py b/qmcpy/discrete_distribution/mpmc/models.py
index 48deb56cf..3f96d55e7 100644
--- a/qmcpy/discrete_distribution/mpmc/models.py
+++ b/qmcpy/discrete_distribution/mpmc/models.py
@@ -10,6 +10,13 @@
 
 
 class MPNN_layer(MessagePassing):
+    """One message-passing neural network layer used by `MPMC_net`.
+
+    Implements `torch_geometric.nn.MessagePassing`'s `message`/`update`
+    interface: each node aggregates messages from its neighbors (from the
+    `edge_index` graph built in `MPMC_net`) and updates its own features.
+    """
+
     def __init__(self, ninp, nhid):
         super(MPNN_layer, self).__init__()
         self.ninp = ninp
@@ -30,22 +37,64 @@ def __init__(self, ninp, nhid):
         self.norm = InstanceNorm(nhid)
 
     def forward(self, x, edge_index, batch):
+        """Propagate messages over the graph and instance-normalize the result.
+
+        Args:
+            x (torch.Tensor): Node features, shape `(num_nodes, ninp)`.
+            edge_index (torch.Tensor): Graph connectivity, shape `(2, num_edges)`.
+            batch (torch.Tensor): Batch assignment for each node, shape `(num_nodes,)`.
+
+        Returns:
+            torch.Tensor: Updated, normalized node features, shape `(num_nodes, nhid)`.
+        """
         x = self.propagate(edge_index, x=x)
         x = self.norm(x, batch)
         return x
 
     def message(self, x_i, x_j):
+        """Compute the message sent from neighbor `x_j` to node `x_i`.
+
+        Called internally by `MessagePassing.propagate`.
+
+        Args:
+            x_i (torch.Tensor): Features of the target node, shape `(num_edges, ninp)`.
+            x_j (torch.Tensor): Features of the source (neighbor) node, shape `(num_edges, ninp)`.
+
+        Returns:
+            torch.Tensor: Message for each edge, shape `(num_edges, nhid)`.
+        """
         message = self.message_net_1(torch.cat((x_i, x_j), dim=-1))
         message = self.message_net_2(message)
         return message
 
     def update(self, message, x):
+        """Combine a node's aggregated message with its own features.
+
+        Called internally by `MessagePassing.propagate`.
+
+        Args:
+            message (torch.Tensor): Aggregated incoming message, shape `(num_nodes, nhid)`.
+            x (torch.Tensor): The node's own features, shape `(num_nodes, ninp)`.
+
+        Returns:
+            torch.Tensor: Updated node features, shape `(num_nodes, nhid)`.
+        """
         update = self.update_net_1(torch.cat((x, message), dim=-1))
         update = self.update_net_2(update)
         return update
 
 
 class MPMC_net(nn.Module):
+    """Graph neural network that transforms random points into a
+    low-discrepancy point set by minimizing a discrepancy-based loss.
+
+    Encodes `nbatch` independent batches of `nsamples` random points in
+    `dim` dimensions, passes them through `nlayers` `MPNN_layer`s connected
+    by a radius graph, decodes back to `dim` dimensions, and squashes to
+    `[0,1]^dim` via a sigmoid. Trained (elsewhere, e.g. `MPMC._train`) to
+    minimize `loss_fn` evaluated on the resulting points.
+    """
+
     def __init__(self, dim, nhid, nlayers, nsamples, nbatch, radius, loss_fn, weights):
         super(MPMC_net, self).__init__()
         self.enc = nn.Linear(dim,nhid)
@@ -79,6 +128,14 @@ def __init__(self, dim, nhid, nlayers, nsamples, nbatch, radius, loss_fn, weight
             raise ValueError(f"Loss function DNE: {loss_fn}")
 
     def forward(self):
+        """Transform the stored random points and compute the discrepancy loss.
+
+        Returns:
+            tuple[torch.Tensor, torch.Tensor]: `(loss, X)` where `loss` is
+                the scalar mean discrepancy loss (weighted by `self.weights`
+                if given) and `X` is the transformed point set, shape
+                `(nbatch, nsamples, dim)`.
+        """
         X = self.x
         edge_index = self.edge_index
 
diff --git a/qmcpy/kernel/abstract_kernel.py b/qmcpy/kernel/abstract_kernel.py
index de02eb97c..f004d2e10 100644
--- a/qmcpy/kernel/abstract_kernel.py
+++ b/qmcpy/kernel/abstract_kernel.py
@@ -9,6 +9,13 @@
 
 
 class AbstractKernel(object):
+    """Abstract base class for QMCPy kernels.
+
+    Concrete kernels subclass this and implement `parsed___call__` and
+    `parsed_single_integral_01d` (and optionally `double_integral_01d`);
+    `AbstractKernel` handles NumPy/PyTorch backend dispatch, batched
+    parameters, and `torch.compile` wiring.
+    """
 
     def __new__(cls, *args, **kwargs):
         if (
@@ -64,6 +71,10 @@ def __init__(self, d, torchify, device, compile_call, compile_call_kwargs) -> No
 
     @property
     def nbdim(self):
+        """int: Number of batch dimensions this kernel's output carries,
+        beyond the sample dimensions. Determined by calling the kernel on
+        empty inputs and inspecting the output's number of dimensions.
+        """
         empty = self.npt.empty((0, self.d), **self.nptkwargs)
         v = self.__call__(empty, empty)
         nbdim = v.ndim - 1
@@ -71,9 +82,20 @@ def nbdim(self):
 
     @property
     def batch_params(self):
+        """dict: This kernel's batched parameters (e.g. `scale`,
+        `lengthscales`), keyed by name, at their natural (unbroadcast) shapes.
+        """
         return {pname: getattr(self, pname) for pname in self.batch_param_names}
 
     def get_batch_params(self, ndim):
+        """Return `batch_params` with each value reshaped to broadcast against `ndim` extra dimensions.
+
+        Args:
+            ndim (int): Number of leading sample dimensions to broadcast against.
+
+        Returns:
+            dict: `batch_params`, each value passed through `insert_batch_dims(value, ndim, -1)`.
+        """
         return {
             pname: insert_batch_dims(batch_param, ndim, -1)
             for pname, batch_param in self.batch_params.items()
@@ -272,6 +294,11 @@ def __call__(self, x0, x1, beta0=None, beta1=None, c=None, **kwargs):
         return k
 
     def parsed___call__(self, *args, **kwargs):
+        """*Abstract method* computing the kernel on already-validated,
+        batch-parsed inputs. Called by `__call__` after input validation and
+        batch-parameter preparation; subclasses implement the actual kernel
+        formula here.
+        """
         raise MethodImplementationError(self, "parsed___call__")
 
     def single_integral_01d(self, x):
@@ -304,6 +331,10 @@ def single_integral_01d(self, x):
         return self.parsed_single_integral_01d(x, batch_params)
 
     def parsed_single_integral_01d(self, x, batch_params):
+        """*Abstract method* computing `single_integral_01d` on already-
+        validated inputs with batch parameters prepared. Called by
+        `single_integral_01d`; subclasses implement the actual formula here.
+        """
         raise MethodImplementationError(self, "parsed_single_integral_01d")
 
     def double_integral_01d(self):
@@ -319,6 +350,18 @@ def double_integral_01d(self):
         raise MethodImplementationError(self, "double_integral_01d")
 
     def rel_pairwise_dist_func(self, x0, x1, lengthscales):
+        r"""Lengthscale-normalized pairwise distance $\lVert x_0-x_1\rVert / (\sqrt{2}\boldsymbol{\gamma})$.
+
+        A common building block for stationary/RBF-style kernels.
+
+        Args:
+            x0 (Union[np.ndarray, torch.Tensor]): First input, shape `(...,d)`.
+            x1 (Union[np.ndarray, torch.Tensor]): Second input, shape `(...,d)`.
+            lengthscales (Union[np.ndarray, torch.Tensor]): Lengthscales $\boldsymbol{\gamma}$.
+
+        Returns:
+            Union[np.ndarray, torch.Tensor]: Normalized pairwise distances, shape `(...,)`.
+        """
         return self.npt.linalg.norm((x0 - x1) / (np.sqrt(2) * lengthscales), 2, -1)
 
     def parse_assign_param(
@@ -331,6 +374,23 @@ def parse_assign_param(
         endsize_ops,
         constraints,
     ):
+        """Validate, transform, and store a kernel hyperparameter.
+
+        Thin wrapper around `qmcpy.util.transforms.parse_assign_param` that
+        fills in this kernel's backend (`torchify`, `npt`, `nptkwargs`).
+
+        Args:
+            pname (str): Name of the parameter (for error messages).
+            param (Union[float, np.ndarray, torch.Tensor]): The raw user-supplied parameter value.
+            shape_param (list): Shape to broadcast `param` to when it is scalar.
+            requires_grad_param (bool): If `True` and `torchify`, set `requires_grad=True`.
+            tfs_param (Tuple[callable, callable]): `(to_raw, from_raw)` transform pair.
+            endsize_ops (list): Allowed sizes for the parameter's trailing dimension.
+            constraints (list): Named constraints to enforce (e.g. `["POSITIVE"]`).
+
+        Returns:
+            Union[np.ndarray, torch.Tensor]: The raw (unconstrained) parameter value to store.
+        """
         return parse_assign_param(
             pname=pname,
             param=param,
@@ -346,6 +406,12 @@ def parse_assign_param(
 
 
 class AbstractKernelScaleLengthscales(AbstractKernel):
+    """Abstract base class for kernels parameterized by a scale and lengthscales.
+
+    Adds `scale` and `lengthscales` hyperparameters (each stored internally
+    in an unconstrained "raw" form and exposed via a positivity-preserving
+    transform) on top of `AbstractKernel`.
+    """
 
     def __init__(
         self,
@@ -428,8 +494,15 @@ def __init__(
 
     @property
     def scale(self):
+        """Union[np.ndarray, torch.Tensor]: The scaling factor $S$, computed
+        from the raw (unconstrained) stored value via `tfs_scale`'s inverse transform.
+        """
         return self.tfs_scale[1](self.raw_scale)
 
     @property
     def lengthscales(self):
+        """Union[np.ndarray, torch.Tensor]: The lengthscales
+        $\\boldsymbol{\\gamma}$, computed from the raw (unconstrained) stored
+        value via `tfs_lengthscales`'s inverse transform.
+        """
         return self.tfs_lengthscales[1](self.raw_lengthscales)
diff --git a/qmcpy/kernel/common_kernels.py b/qmcpy/kernel/common_kernels.py
index b190698d6..110042a8b 100644
--- a/qmcpy/kernel/common_kernels.py
+++ b/qmcpy/kernel/common_kernels.py
@@ -8,10 +8,24 @@
 
 
 class AbstractKernelGaussianSE(AbstractKernelScaleLengthscales):
+    """Abstract base class for Gaussian / squared-exponential-family kernels.
+
+    Provides the analytic `[0,1]^d` single and double integrals shared by
+    this whole kernel family; subclasses need only implement `parsed___call__`.
+    """
 
     AUTOGRADKERNEL = True
 
     def parsed_single_integral_01d(self, x, batch_params):
+        """Analytic single integral of the Gaussian/SE-family kernel over `[0,1]^d`.
+
+        Args:
+            x (Union[np.ndarray, torch.Tensor]): Points, shape `(...,d)`.
+            batch_params (dict): Batch-broadcast `scale`/`lengthscales`, from `get_batch_params`.
+
+        Returns:
+            Union[np.ndarray, torch.Tensor]: Shape `(...,)` integral kernel evaluations.
+        """
         s = batch_params["scale"][..., 0]
         l = batch_params["lengthscales"]
         norm_class = (
@@ -26,6 +40,11 @@ def parsed_single_integral_01d(self, x, batch_params):
         return kint
 
     def double_integral_01d(self):
+        """Analytic double integral of the Gaussian/SE-family kernel over `[0,1]^d x [0,1]^d`.
+
+        Returns:
+            Union[np.ndarray, torch.Tensor]: Double integral kernel evaluations.
+        """
         erf = self.npt.erf if self.torchify else scipy.special.erf
         s = self.scale[..., 0]
         l = self.lengthscales
@@ -261,6 +280,9 @@ class KernelGaussian(AbstractKernelGaussianSE):
     """
 
     def parsed___call__(self, x0, x1, batch_params):
+        """Gaussian / squared exponential kernel evaluation via a direct
+        elementwise formula; see the class docstring for the formula.
+        """
         scale = batch_params["scale"][..., 0]
         lengthscales = batch_params["lengthscales"]
         k = scale * self.npt.exp(
@@ -359,6 +381,9 @@ class KernelSquaredExponential(AbstractKernelGaussianSE):
     """
 
     def parsed___call__(self, x0, x1, batch_params):
+        """Gaussian / squared exponential kernel evaluation via the pairwise
+        distance function; see the class docstring for the formula.
+        """
         scale = batch_params["scale"][..., 0]
         lengthscales = batch_params["lengthscales"]
         rdists = self.rel_pairwise_dist_func(x0, x1, lengthscales)
@@ -547,9 +572,13 @@ def __init__(
 
     @property
     def alpha(self):
+        """Union[np.ndarray, torch.Tensor]: The shape/mixture parameter
+        $\alpha$, computed from the raw stored value via `tfs_alpha`'s inverse transform.
+        """
         return self.tfs_alpha[1](self.raw_alpha)
 
     def parsed___call__(self, x0, x1, batch_params):
+        """Rational quadratic kernel evaluation; see the class docstring for the formula."""
         scale = batch_params["scale"][..., 0]
         lengthscales = batch_params["lengthscales"]
         alpha = batch_params["alpha"][..., 0]
@@ -648,6 +677,7 @@ class KernelMatern12(AbstractKernelScaleLengthscales):
     AUTOGRADKERNEL = True
 
     def parsed___call__(self, x0, x1, batch_params):
+        """Matern 1/2 (exponential) kernel evaluation; see the class docstring for the formula."""
         scale = batch_params["scale"][..., 0]
         lengthscales = batch_params["lengthscales"]
         rdists = self.rel_pairwise_dist_func(x0, x1, lengthscales)
@@ -745,6 +775,7 @@ class KernelMatern32(AbstractKernelScaleLengthscales):
     AUTOGRADKERNEL = True
 
     def parsed___call__(self, x0, x1, batch_params):
+        """Matern 3/2 kernel evaluation; see the class docstring for the formula."""
         scale = batch_params["scale"][..., 0]
         lengthscales = batch_params["lengthscales"]
         rdists = self.rel_pairwise_dist_func(x0, x1, lengthscales)
@@ -843,6 +874,7 @@ class KernelMatern52(AbstractKernelScaleLengthscales):
     AUTOGRADKERNEL = True
 
     def parsed___call__(self, x0, x1, batch_params):
+        """Matern 5/2 kernel evaluation; see the class docstring for the formula."""
         scale = batch_params["scale"][..., 0]
         lengthscales = batch_params["lengthscales"]
         rdists = self.rel_pairwise_dist_func(x0, x1, lengthscales)
diff --git a/qmcpy/kernel/multitask_kernel.py b/qmcpy/kernel/multitask_kernel.py
index dd3a39232..3b71e0910 100644
--- a/qmcpy/kernel/multitask_kernel.py
+++ b/qmcpy/kernel/multitask_kernel.py
@@ -431,20 +431,33 @@ def __init__(
 
     @property
     def nbdim_base(self):
+        """int: `nbdim` of the wrapped `base_kernel` (cached after first access)."""
         if self._nbdim_base is None:
             self._nbdim_base = self.base_kernel.nbdim
         return self._nbdim_base
 
     @property
     def factor(self):
+        """Union[np.ndarray, torch.Tensor]: Low-rank/Cholesky factor used to
+        build the task covariance matrix `taskmat`, computed from the raw
+        stored value via `tfs_factor`'s inverse transform.
+        """
         return self.tfs_factor[1](self.raw_factor)
 
     @property
     def diag(self):
+        """Union[np.ndarray, torch.Tensor]: Diagonal term added to the task
+        covariance matrix `taskmat`, computed from the raw stored value via
+        `tfs_diag`'s inverse transform.
+        """
         return self.tfs_diag[1](self.raw_diag)
 
     @property
     def taskmat(self):
+        """Union[np.ndarray, torch.Tensor]: The `(num_tasks, num_tasks)` task
+        covariance matrix, built from `factor` and `diag` using either the
+        `"LOW RANK"` or `"CHOLESKY"` parameterization (see `method`).
+        """
         factor = self.factor
         diag = self.diag
         if self.method == "LOW RANK":
@@ -552,6 +565,13 @@ def double_integral_01d(self, task0, task1):
 
 
 class KernelMultiTaskDerivs(KernelMultiTask):
+    """`KernelMultiTask` specialized for taking derivatives across tasks.
+
+    Fixes the task covariance matrix to the identity (`factor=1.0`,
+    `diag=0.0`, both non-trainable), so tasks are treated as independent and
+    the multi-task kernel reduces to `base_kernel` applied per task.
+    """
+
     def __init__(
         self,
         base_kernel,
diff --git a/qmcpy/kernel/si_dsi_kernels.py b/qmcpy/kernel/si_dsi_kernels.py
index 1af58a5eb..af9d9290f 100644
--- a/qmcpy/kernel/si_dsi_kernels.py
+++ b/qmcpy/kernel/si_dsi_kernels.py
@@ -13,6 +13,18 @@
 
 
 class AbstractSIDSIKernel(AbstractKernelScaleLengthscales):
+    """Abstract base class for shift-invariant and digitally-shift-invariant
+    (Walsh) kernels, parameterized by smoothness `alpha`, `lengthscales`, and
+    `scale`.
+
+    Subclasses implement `get_per_dim_components`, which builds the family-
+    specific per-dimension building blocks (Bernoulli polynomials for
+    shift-invariant kernels, weighted Walsh functions for digitally-shift-
+    invariant kernels); this base class handles combining them (optionally
+    with derivative orders `beta0`/`beta1`) into the full kernel evaluation,
+    plus the `[0,1]^d` single/double integrals, which are constant (`scale`)
+    for this whole kernel family.
+    """
 
     AUTOGRADKERNEL = False
 
@@ -113,17 +125,45 @@ def __init__(
 
     @property
     def alpha(self):
+        """Union[np.ndarray, torch.Tensor]: The smoothness parameter
+        $\\boldsymbol{\\alpha}$, computed from the raw stored value via
+        `tfs_alpha`'s inverse transform.
+        """
         return self.tfs_alpha[1](self.raw_alpha)
 
     def parsed_single_integral_01d(self, x, batch_params):
+        """Single integral of this kernel family over `[0,1]^d`, which is
+        the constant `scale` (a reproducing-kernel property of shift-
+        invariant/digitally-shift-invariant kernels).
+        """
         return batch_params["scale"][..., 0] + 0 * x[..., 0]
 
     def double_integral_01d(self):
+        """Double integral of this kernel family over `[0,1]^d x [0,1]^d`,
+        which is the constant `scale` (same reproducing-kernel property as
+        `parsed_single_integral_01d`).
+        """
         return self.scale[..., 0]
 
     def combine_per_dim_components_raw_m1(
         self, kparts, beta0, beta1, c, batch_params, stable
     ):
+        """Combine per-dimension kernel components into `(scale_term, remainder)`.
+
+        Args:
+            kparts (Union[np.ndarray, torch.Tensor]): Per-dimension components from `get_per_dim_components`.
+            beta0 (Union[np.ndarray, torch.Tensor]): Derivative orders for the first input.
+            beta1 (Union[np.ndarray, torch.Tensor]): Derivative orders for the second input.
+            c (Union[np.ndarray, torch.Tensor]): Coefficients of the derivative terms.
+            batch_params (dict): Batch-broadcast `scale`/`lengthscales`, from `get_batch_params`.
+            stable (bool): If `True`, use a numerically stabler (but more
+                expensive) product formula.
+
+        Returns:
+            tuple[Union[np.ndarray, torch.Tensor], Union[np.ndarray, torch.Tensor]]:
+                `(sc, v)` such that the full kernel value is `sc + v`;
+                `combine_per_dim_components` adds these back together.
+        """
         scale = batch_params["scale"][..., 0]
         lengthscales = batch_params["lengthscales"]
         ind = 1.0 * ((beta0 + beta1) == 0)
@@ -143,9 +183,27 @@ def combine_per_dim_components_raw_m1(
         return sc, v
 
     def get_per_dim_components(self, x0, x1, beta0, beta1):
+        """*Abstract method* building this kernel family's per-dimension
+        components (e.g. Bernoulli polynomials or weighted Walsh functions,
+        depending on the subclass), with derivative orders `beta0`/`beta1`
+        applied. Called by `parsed___call__`.
+        """
         raise MethodImplementationError(self, "get_per_dim_components")
 
     def combine_per_dim_components(self, kparts, beta0, beta1, c, batch_params, stable):
+        """Combine per-dimension kernel components into the final kernel value.
+
+        Args:
+            kparts (Union[np.ndarray, torch.Tensor]): Per-dimension components from `get_per_dim_components`.
+            beta0 (Union[np.ndarray, torch.Tensor]): Derivative orders for the first input.
+            beta1 (Union[np.ndarray, torch.Tensor]): Derivative orders for the second input.
+            c (Union[np.ndarray, torch.Tensor]): Coefficients of the derivative terms.
+            batch_params (dict): Batch-broadcast `scale`/`lengthscales`, from `get_batch_params`.
+            stable (bool): If `True`, use a numerically stabler product formula.
+
+        Returns:
+            Union[np.ndarray, torch.Tensor]: The kernel evaluation.
+        """
         sc, v = self.combine_per_dim_components_raw_m1(
             kparts, beta0, beta1, c, batch_params, stable
         )
@@ -153,6 +211,7 @@ def combine_per_dim_components(self, kparts, beta0, beta1, c, batch_params, stab
         return k
 
     def parsed___call__(self, x0, x1, beta0, beta1, c, batch_params, stable=False):
+        """Evaluate the kernel by building then combining per-dimension components."""
         kparts = self.get_per_dim_components(x0, x1, beta0, beta1)
         k = self.combine_per_dim_components(
             kparts, beta0, beta1, c, batch_params, stable
@@ -415,6 +474,9 @@ def __init__(
             self.lgamma = scipy.special.loggamma
 
     def get_per_dim_components(self, x0, x1, beta0, beta1):
+        """Per-dimension Bernoulli-polynomial components; see the class
+        docstring for the kernel formula.
+        """
         p = len(beta0)
         betasum = beta0 + beta1
         order = 2 * self.alpha - betasum
@@ -647,6 +709,10 @@ def __init__(
         )
 
     def get_per_dim_components(self, x0, x1, beta0, beta1):
+        """Per-dimension Bernoulli-polynomial components for orders 1-4,
+        later combined by `combine_per_dim_components_raw_m1` weighted by
+        `alpha`. Does not support derivatives (`beta0`/`beta1` must be zero).
+        """
         p = len(beta0)
         if not ((beta0 == 0).all() and (
             beta1 == 0
@@ -665,6 +731,9 @@ def get_per_dim_components(self, x0, x1, beta0, beta1):
     def combine_per_dim_components_raw_m1(
         self, kparts, beta0, beta1, c, batch_params, stable
     ):
+        """Weight the order-1-4 components by `alpha` and sum, then delegate
+        to the base class's combination logic.
+        """
         kparts = (self.alpha[..., None, :, None, :] * kparts).sum(-3)
         return super().combine_per_dim_components_raw_m1(
             kparts, beta0, beta1, c, batch_params, stable
@@ -914,11 +983,22 @@ def __init__(
 
     @property
     def t(self):
+        """int: Number of bits used in the binary representation of inputs
+        (see `set_t`). Must be set via `set_t` before use.
+        """
         if self._t is None:
             raise ParameterError("please use set_t to set the t value")
         return self._t
 
     def set_t(self, t):
+        """Set the number of bits `t` used to binarize inputs via `to_bin`.
+
+        Args:
+            t (Union[None, int]): Number of bits, `0 <= t <= 63` when
+                `torchify` (`torch.int64` limit) or `0 <= t <= 64` otherwise
+                (`np.uint64` limit). `None` clears the value, requiring a
+                later call to `set_t` before the kernel can be evaluated.
+        """
         if t is None:
             self._t = t
         else:
@@ -933,6 +1013,9 @@ def set_t(self, t):
             self._t = t
 
     def get_per_dim_components(self, x0, x1, beta0, beta1):
+        """Per-dimension weighted-Walsh-function components; see the class
+        docstring for the kernel formula. Inputs are first binarized to `t` bits.
+        """
         t = self.t
         x0 = to_bin(x0, t)
         x1 = to_bin(x1, t)
@@ -1202,11 +1285,22 @@ def __init__(
 
     @property
     def t(self):
+        """int: Number of bits used in the binary representation of inputs
+        (see `set_t`). Must be set via `set_t` before use.
+        """
         if self._t is None:
             raise ParameterError("please use set_t to set the t value")
         return self._t
 
     def set_t(self, t):
+        """Set the number of bits `t` used to binarize inputs via `to_bin`.
+
+        Args:
+            t (Union[None, int]): Number of bits, `0 <= t <= 63` when
+                `torchify` (`torch.int64` limit) or `0 <= t <= 64` otherwise
+                (`np.uint64` limit). `None` clears the value, requiring a
+                later call to `set_t` before the kernel can be evaluated.
+        """
         if t is None:
             self._t = t
         else:
@@ -1221,6 +1315,11 @@ def set_t(self, t):
             self._t = t
 
     def get_per_dim_components(self, x0, x1, beta0, beta1):
+        """Per-dimension components with a per-XOR-bit-length adaptive
+        smoothness; see the class docstring for the kernel formula. Inputs
+        are first binarized to `t` bits. Does not support derivatives
+        (`beta0`/`beta1` must be zero).
+        """
         t = self.t
         x0 = to_bin(x0, t)
         x1 = to_bin(x1, t)
@@ -1239,6 +1338,10 @@ def get_per_dim_components(self, x0, x1, beta0, beta1):
     def combine_per_dim_components_raw_m1(
         self, flog2deltas, beta0, beta1, c, batch_params, stable
     ):
+        """Combine per-XOR-bit-length components using a smoothness `alpha`
+        that adapts to each bit length, then delegate to the base class's
+        combination logic.
+        """
         alpha = batch_params["alpha"]
         p2alphap1 = 2 ** (alpha + 1)
         nu = p2alphap1 / (p2alphap1 - 2)
@@ -1455,11 +1558,22 @@ def __init__(
 
     @property
     def t(self):
+        """int: Number of bits used in the binary representation of inputs
+        (see `set_t`). Must be set via `set_t` before use.
+        """
         if self._t is None:
             raise ParameterError("please use set_t to set the t value")
         return self._t
 
     def set_t(self, t):
+        """Set the number of bits `t` used to binarize inputs via `to_bin`.
+
+        Args:
+            t (Union[None, int]): Number of bits, `0 <= t <= 63` when
+                `torchify` (`torch.int64` limit) or `0 <= t <= 64` otherwise
+                (`np.uint64` limit). `None` clears the value, requiring a
+                later call to `set_t` before the kernel can be evaluated.
+        """
         if t is None:
             self._t = t
         else:
@@ -1474,6 +1588,12 @@ def set_t(self, t):
             self._t = t
 
     def get_per_dim_components(self, x0, x1, beta0, beta1):
+        """Per-dimension weighted-Walsh-function components for orders 1-4,
+        later combined by `combine_per_dim_components_raw_m1` weighted by
+        `alpha`; see the class docstring for the kernel formula. Inputs are
+        first binarized to `t` bits. Does not support derivatives
+        (`beta0`/`beta1` must be zero).
+        """
         t = self.t
         x0 = to_bin(x0, t)
         x1 = to_bin(x1, t)
@@ -1498,6 +1618,9 @@ def get_per_dim_components(self, x0, x1, beta0, beta1):
     def combine_per_dim_components_raw_m1(
         self, kparts, beta0, beta1, c, batch_params, stable
     ):
+        """Weight the order-1-4 components by `alpha` and sum, then delegate
+        to the base class's combination logic.
+        """
         kparts = (self.alpha[..., None, :, None, :] * kparts).sum(-3)
         return super().combine_per_dim_components_raw_m1(
             kparts, beta0, beta1, c, batch_params, stable
diff --git a/qmcpy/stopping_criterion/abstract_cub_bayes_ld_g.py b/qmcpy/stopping_criterion/abstract_cub_bayes_ld_g.py
index ad4e5c9b6..483d7eb2f 100644
--- a/qmcpy/stopping_criterion/abstract_cub_bayes_ld_g.py
+++ b/qmcpy/stopping_criterion/abstract_cub_bayes_ld_g.py
@@ -12,6 +12,16 @@
 
 
 class AbstractCubBayesLDG(AbstractStoppingCriterion):
+    """Abstract base class for guaranteed Bayesian low-discrepancy QMC stopping criteria.
+
+    Implements the fast-transform Bayesian cubature error bound shared by
+    concrete lattice/digital-net Bayesian stopping criteria: doubling sample
+    counts each iteration, maintaining the running transform coefficients
+    (`_ytildefull`), and fitting the kernel hyperparameter
+    (`objective_function`, `_stopping_criterion`) to derive a
+    credible-interval error bound.
+    """
+
     _RESUME_REQUIRED_FIELDS = (
         "solution", "comb_bound_low", "comb_bound_high", "comb_bound_diff", "comb_flags", "n", "n_max", "xfull", "yfull"
     )
@@ -189,10 +199,24 @@ def __setstate__(self, state):
         if isinstance(self.error_fun, str):
             self.error_fun, _ = self._resolve_error_fun(self.error_fun)
 
-    # objective function to estimate parameter theta
-    # MLE : Maximum likelihood estimation
-    # GCV : Generalized cross validation
     def objective_function(self, theta, xun, ftilde):
+        """Compute the Bayesian cubature loss used to fit the kernel parameter theta.
+
+        Evaluates either the negative log marginal likelihood (MLE) or the
+        generalized cross validation (GCV) loss, per `self.errbd_type`, along
+        with the kernel eigenvalues and RKHS norm needed by the error bound.
+
+        Args:
+            theta (float): Kernel hyperparameter to evaluate the loss at.
+            xun (np.ndarray): Unique ordered node locations.
+            ftilde (np.ndarray): Fast-transformed function values at `xun`.
+
+        Returns:
+            float: Loss value (MLE or GCV, per `self.errbd_type`).
+            np.ndarray: Kernel eigenvalues `vec_lambda`.
+            np.ndarray: Ring eigenvalues `vec_lambda_ring`, used by the error bound.
+            float: RKHS norm estimate of the fitted function.
+        """
         n = len(ftilde)
         fudge = 100 * np.finfo(float).eps
         # if type(theta) != np.ndarray:
@@ -254,10 +278,22 @@ def objective_function(self, theta, xun, ftilde):
         )
         return loss, vec_lambda, vec_lambda_ring, RKHS_norm
 
-    # Computes modified kernel Km1 = K - 1
-    # Useful to avoid cancellation error in the computation of (1 - n/\lambda_1)
     @staticmethod
     def kernel_t(aconst, Bern):
+        r"""Compute the modified kernel ``Km1 = K - 1`` from Bernoulli polynomial values.
+
+        Working with ``Km1`` rather than ``K`` directly avoids cancellation
+        error when later computing $1 - n/\lambda_1$.
+
+        Args:
+            aconst (Union[float, np.ndarray]): Kernel parameter theta, scalar
+                or per-dimension array.
+            Bern (np.ndarray): Bernoulli polynomial values, shape ``(n, d)``.
+
+        Returns:
+            np.ndarray: ``Km1``, the kernel minus one.
+            np.ndarray: ``K``, the full kernel (``1 + Km1``).
+        """
         d = np.size(Bern, 1)
         if type(aconst) != np.ndarray:
             theta = np.ones((d, 1)) * aconst
@@ -278,11 +314,16 @@ def kernel_t(aconst, Bern):
         K = Kj
         return [Km1, K]
 
-    # prints debug message if the given variable is Inf, Nan or complex, etc
-    # Example: alertMsg(x, 'Inf', 'Imag')
-    #          prints if variable 'x' is either Infinite or Imaginary
     @staticmethod
     def alert_msg(*args):
+        """Print a debug message if a variable contains NaN, Inf, or complex values.
+
+        Args:
+            *args (tuple): The variable to check, followed by one or more of
+                ``"Nan"``, ``"Inf"``, ``"Imag"`` naming which conditions to
+                report. Example: `alert_msg(x, "Inf", "Imag")` prints if `x`
+                contains infinite or imaginary values.
+        """
         varargin = args
         nargin = len(varargin)
         if nargin > 1:
@@ -308,6 +349,23 @@ def alert_msg(*args):
                     print("unknown type check requested !")
 
     def integrate(self, resume=None):
+        """Determine the samples needed to satisfy the target tolerance.
+
+        Doubles the sample count each iteration, updates the running fast
+        transform (`_ytildefull`), and for each not-yet-converged output
+        calls `_stopping_criterion` to fit the Bayesian kernel hyperparameter
+        and derive a credible-interval bound on the integral. Stops once
+        every combined output is within tolerance or `self.n_limit` would be
+        exceeded.
+
+        Args:
+            resume (Data): Existing integration state to resume from, if
+                supported. Defaults to None.
+
+        Returns:
+            tuple: Approximation to the integral with shape ``integrand.d_comb``
+                and the corresponding data object.
+        """
         t_start = time()
         resume_provenance = self._capture_resume_provenance(resume)
         first_resume_iter = False
@@ -450,6 +508,18 @@ def _validate_resume(self, data):
             raise ParameterError("resume data n_total must be a power of 2.")
 
     def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
+        """Update the stopping criterion's target tolerance.
+
+        Args:
+            abs_tol (float): Absolute error tolerance, broadcast to
+                `self.abs_tols` with shape `integrand.d_comb`.
+            rel_tol (float): Relative error tolerance, broadcast to
+                `self.rel_tols` with shape `integrand.d_comb`.
+            rmse_tol (float): Unsupported; must be `None`.
+
+        Raises:
+            AssertionError: If `rmse_tol` is supplied.
+        """
         if not (rmse_tol is None):
             raise AssertionError("rmse_tol not supported by this stopping criterion.")
         if abs_tol is not None:
diff --git a/qmcpy/stopping_criterion/abstract_cub_mlmc.py b/qmcpy/stopping_criterion/abstract_cub_mlmc.py
index 48aece21c..9b5df29c6 100644
--- a/qmcpy/stopping_criterion/abstract_cub_mlmc.py
+++ b/qmcpy/stopping_criterion/abstract_cub_mlmc.py
@@ -6,6 +6,13 @@
 
 
 class AbstractCubMLMC(AbstractStoppingCriterion):
+    """Abstract base class for multilevel Monte Carlo stopping criteria.
+
+    Shared machinery for `CubMLMC` and `CubMLMCCont`: level statistics
+    (`_refresh_level_statistics`), level growth (`_add_level`), and resume
+    checkpoint construction/validation/replay used across MLMC stopping
+    criteria.
+    """
 
     @staticmethod
     def _append_level_diff_samples(data, level, dp):
@@ -66,6 +73,18 @@ def _get_next_samples(self, data):
         return ns.astype(int)
 
     def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
+        """Update the stopping criterion's target tolerance.
+
+        Args:
+            abs_tol (float): Absolute error tolerance, converted to an RMSE
+                tolerance via `self.alpha`. Ignored if `rmse_tol` is supplied.
+            rel_tol (float): Unsupported; must be `None`.
+            rmse_tol (float): Root mean squared error tolerance. Takes
+                precedence over `abs_tol` if both are supplied.
+
+        Raises:
+            AssertionError: If `rel_tol` is supplied.
+        """
         if not (rel_tol is None):
             raise AssertionError("rel_tol not supported by this stopping criterion.")
         if rmse_tol != None:
diff --git a/qmcpy/stopping_criterion/abstract_cub_mlqmc.py b/qmcpy/stopping_criterion/abstract_cub_mlqmc.py
index 001ff57a2..63c8c64ad 100644
--- a/qmcpy/stopping_criterion/abstract_cub_mlqmc.py
+++ b/qmcpy/stopping_criterion/abstract_cub_mlqmc.py
@@ -4,6 +4,13 @@
 
 
 class AbstractCubMLQMC(AbstractStoppingCriterion):
+    """Abstract base class for multilevel Quasi-Monte Carlo stopping criteria.
+
+    Shared machinery for `CubMLQMC` and `CubMLQMCCont`: replication-based
+    level statistics (`update_data`, `_update_bias_estimate`), level growth
+    (`_add_level`), and resume checkpoint validation/replay used across MLQMC
+    stopping criteria.
+    """
 
     @staticmethod
     def _append_level_replication_sums(data, level, rep_sums, n_increment):
@@ -100,6 +107,18 @@ def _resume_match_from_snapshots(snapshots, checkpoint):
         return None, None
 
     def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
+        """Update the stopping criterion's target tolerance.
+
+        Args:
+            abs_tol (float): Absolute error tolerance, converted to an RMSE
+                tolerance via `self.alpha`. Ignored if `rmse_tol` is supplied.
+            rel_tol (float): Unsupported; must be `None`.
+            rmse_tol (float): Root mean squared error tolerance. Takes
+                precedence over `abs_tol` if both are supplied.
+
+        Raises:
+            AssertionError: If `rel_tol` is supplied.
+        """
         if not (rel_tol is None):
             raise AssertionError("rel_tol not supported by this stopping criterion.")
         if rmse_tol != None:
@@ -108,6 +127,19 @@ def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
             self.rmse_tol = float(abs_tol) / norm.ppf(1 - self.alpha / 2.0)
 
     def update_data(self, data):
+        """Double the sample count on every active level and refresh statistics.
+
+        For each level with `data.eval_level[l]` set, doubles its replicated
+        sample count (or draws `self.n_init` if the level is new), evaluates
+        the paired coarse/fine integrand there, and folds the new
+        per-replication sums into `data.mean_level_reps`, `data.mean_level`,
+        `data.var_level`, and `data.var_cost_ratio_level`. Then refreshes the
+        bias estimate, `data.n_total`, and `data.solution`, and clears
+        `data.eval_level`.
+
+        Args:
+            data (Data): Integration state to update in place.
+        """
         # update sample sums
         for l in range(data.levels):
             if not data.eval_level[l]:
diff --git a/qmcpy/stopping_criterion/abstract_cub_qmc_ld_g.py b/qmcpy/stopping_criterion/abstract_cub_qmc_ld_g.py
index 0cef6ed9c..bbf0a81e1 100644
--- a/qmcpy/stopping_criterion/abstract_cub_qmc_ld_g.py
+++ b/qmcpy/stopping_criterion/abstract_cub_qmc_ld_g.py
@@ -18,6 +18,16 @@ def _lstsq_pyfunc(x, y):
 
 
 class AbstractCubQMCLDG(AbstractStoppingCriterion):
+    """Abstract base class for guaranteed low-discrepancy QMC stopping criteria.
+
+    Implements the fast-transform (FFT/FWT) cubature error bound shared by
+    `CubQMCLatticeG`, `CubQMCNetG`, and similar guaranteed lattice/digital-net
+    stopping criteria: doubling sample counts each iteration, maintaining the
+    running transform coefficients (`_ytildefull`, `_kappanumap`), optional
+    control-variate correction, and the cone-condition check that certifies
+    the error bound.
+    """
+
     _RESUME_REQUIRED_FIELDS = (
         "solution", "comb_bound_low", "comb_bound_high", "comb_bound_diff", "comb_flags", "n", "n_max", "xfull", "yfull"
     )
@@ -222,6 +232,23 @@ def _validate_resume(self, data):
             )
 
     def integrate(self, resume=None):
+        """Determine the samples needed to satisfy the target tolerance.
+
+        Doubles the sample count each iteration, updates the running fast
+        transform (`_ytildefull`) and its permutation (`_kappanumap`),
+        optionally corrects for control variates, and (if `self.check_cone`)
+        checks the cone condition that certifies the low-discrepancy error
+        bound. Stops once every combined output is within tolerance or
+        `self.n_limit` would be exceeded.
+
+        Args:
+            resume (Data): Existing integration state to resume from, if
+                supported. Defaults to None.
+
+        Returns:
+            tuple: Approximation to the integral with shape ``integrand.d_comb``
+                and the corresponding data object.
+        """
         t_start = time()
         resume_provenance = self._capture_resume_provenance(resume)
         first_resume_iter = False
@@ -480,6 +507,18 @@ def integrate(self, resume=None):
         return data.solution, data
 
     def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
+        """Update the stopping criterion's target tolerance.
+
+        Args:
+            abs_tol (float): Absolute error tolerance, broadcast to
+                `self.abs_tols` with shape `integrand.d_comb`.
+            rel_tol (float): Relative error tolerance, broadcast to
+                `self.rel_tols` with shape `integrand.d_comb`.
+            rmse_tol (float): Unsupported; must be `None`.
+
+        Raises:
+            AssertionError: If `rmse_tol` is supplied.
+        """
         if not (rmse_tol is None):
             raise AssertionError("rmse_tol not supported by this stopping criterion.")
         if abs_tol is not None:
diff --git a/qmcpy/stopping_criterion/abstract_stopping_criterion.py b/qmcpy/stopping_criterion/abstract_stopping_criterion.py
index cb63b3a22..d761582b3 100644
--- a/qmcpy/stopping_criterion/abstract_stopping_criterion.py
+++ b/qmcpy/stopping_criterion/abstract_stopping_criterion.py
@@ -22,6 +22,16 @@
 
 
 class AbstractStoppingCriterion(object):
+    """Abstract base class for QMCPy stopping criteria.
+
+    A stopping criterion drives adaptive sampling for a given `integrand`
+    until an error tolerance is met, via `integrate`. Concrete stopping
+    criteria (e.g. `CubQMCNetG`, `CubMCCLT`) implement `integrate` and
+    `set_tolerance`; this base class handles shared bookkeeping: checkpoint
+    resume/save, iteration logging, and validating the integrand/true
+    measure/discrete distribution combination.
+    """
+
     _RESUME_FORMAT_VERSION = 1  # Increment when checkpoint format changes in a non-backwards-compatible way
     _ITERATION_LOG_VIEWS = ("all", "current", "without_resume", "stage_last")
 
diff --git a/qmcpy/stopping_criterion/cub_mc_clt.py b/qmcpy/stopping_criterion/cub_mc_clt.py
index 726f94e06..087ca27ea 100644
--- a/qmcpy/stopping_criterion/cub_mc_clt.py
+++ b/qmcpy/stopping_criterion/cub_mc_clt.py
@@ -207,6 +207,23 @@ def _get_main_stage_samples(self, data):
         return y - ((ycv - self.cv_mu[:, None]) * self.beta[:, None]).sum(0)
 
     def integrate(self, resume=None):
+        """Determine the samples needed to satisfy the target tolerance.
+
+        Draws an initial `self.n_init` samples to estimate the standard
+        deviation, then uses the CLT-based normal quantile (`self.z_star`,
+        inflated by `self.inflate`) to size and draw a second, final batch,
+        producing a symmetric confidence-interval bound on the integral.
+
+        Args:
+            resume (Data): Unsupported; must be `None`, as `CubMCCLT` cannot
+                resume a prior checkpoint.
+
+        Returns:
+            tuple: Approximation to the integral and the corresponding data object.
+
+        Raises:
+            ParameterError: If `resume` is not `None`.
+        """
         t_start = time()
         trace = self._make_trace_logger()
         if resume is not None:
@@ -282,6 +299,16 @@ def integrate(self, resume=None):
         return data.solution, data
 
     def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
+        """Update the stopping criterion's target tolerance.
+
+        Args:
+            abs_tol (float): Absolute error tolerance.
+            rel_tol (float): Relative error tolerance.
+            rmse_tol (float): Unsupported; must be `None`.
+
+        Raises:
+            AssertionError: If `rmse_tol` is supplied.
+        """
         if not (rmse_tol is None):
             raise AssertionError("rmse_tol not supported by this stopping criterion.")
         if abs_tol is not None:
diff --git a/qmcpy/stopping_criterion/cub_mc_clt_vec.py b/qmcpy/stopping_criterion/cub_mc_clt_vec.py
index 8a4215755..d5f00cb30 100644
--- a/qmcpy/stopping_criterion/cub_mc_clt_vec.py
+++ b/qmcpy/stopping_criterion/cub_mc_clt_vec.py
@@ -265,6 +265,21 @@ def _restore_resume_state(self, data):
         self.integrand.true_measure.discrete_distrib = self.discrete_distrib
 
     def integrate(self, resume=None):
+        """Determine the samples needed to satisfy the target tolerance.
+
+        Doubles the sample count each iteration and forms a CLT-based
+        confidence interval (`self.z_star`, inflated by `self.inflate`) on
+        each not-yet-converged output. Stops once every combined output is
+        within tolerance or `self.n_limit` would be exceeded.
+
+        Args:
+            resume (Data): Existing integration state to resume from, if
+                supported. Defaults to None.
+
+        Returns:
+            tuple: Approximation to the integral with shape ``integrand.d_comb``
+                and the corresponding data object.
+        """
         t_start = time()
         resume_provenance = self._capture_resume_provenance(resume)
         trace = self._make_trace_logger()
@@ -360,6 +375,18 @@ def integrate(self, resume=None):
         return data.solution, data
 
     def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
+        """Update the stopping criterion's target tolerance.
+
+        Args:
+            abs_tol (float): Absolute error tolerance, broadcast to
+                `self.abs_tols` with shape `integrand.d_comb`.
+            rel_tol (float): Relative error tolerance, broadcast to
+                `self.rel_tols` with shape `integrand.d_comb`.
+            rmse_tol (float): Unsupported; must be `None`.
+
+        Raises:
+            AssertionError: If `rmse_tol` is supplied.
+        """
         if not (rmse_tol is None):
             raise AssertionError("rmse_tol not supported by this stopping criterion.")
         if abs_tol is not None:
diff --git a/qmcpy/stopping_criterion/cub_mc_g.py b/qmcpy/stopping_criterion/cub_mc_g.py
index 8bf9e8d94..724e100e6 100644
--- a/qmcpy/stopping_criterion/cub_mc_g.py
+++ b/qmcpy/stopping_criterion/cub_mc_g.py
@@ -329,6 +329,25 @@ def _update_main_stage_solution(self, data):
         data.n_total = data.yfull.shape[-1]
 
     def integrate(self, resume=None):
+        """Determine the samples needed to satisfy the target tolerance.
+
+        Draws an initial `self.n_init` samples to estimate the standard
+        deviation and kurtosis. If `self.rel_tol` is 0, sizes and draws one
+        additional batch via a Chebyshev/Berry-Esseen bound (`_nchebe`).
+        Otherwise, iteratively grows the sample size (`_ncbinv`) until the
+        Berry-Esseen confidence bound meets both the absolute and relative
+        tolerance or `self.n_limit` would be exceeded.
+
+        Args:
+            resume (Data): Unsupported; must be `None`, as `CubMCG` cannot
+                resume a prior checkpoint.
+
+        Returns:
+            tuple: Approximation to the integral and the corresponding data object.
+
+        Raises:
+            ParameterError: If `resume` is not `None`.
+        """
         t_start = time()
         trace = self._make_trace_logger()
         if resume is not None:
@@ -535,6 +554,16 @@ def _ncbinv(self, n1, alpha1, kurtmax):
         return eps
 
     def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
+        """Update the stopping criterion's target tolerance.
+
+        Args:
+            abs_tol (float): Absolute error tolerance.
+            rel_tol (float): Relative error tolerance.
+            rmse_tol (float): Unsupported; must be `None`.
+
+        Raises:
+            AssertionError: If `rmse_tol` is supplied.
+        """
         if not (rmse_tol is None):
             raise AssertionError("rmse_tol not supported by this stopping criterion.")
         if abs_tol != None:
@@ -544,19 +573,20 @@ def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
 
 
 def _tol_fun(abs_tol, rel_tol, theta, mu, toltype):
-    # """
-    # Generalized error tolerance function.
+    """Generalized error tolerance function.
 
-    # Args:
-    #     abs_tol (float): absolute error tolerance
-    #     rel_tol (float): relative error tolerance
-    #     theta (float): parameter in 'theta' case
-    #     mu (float): true mean
-    #     toltype (str): different options of tolerance function
+    Args:
+        abs_tol (float): Absolute error tolerance.
+        rel_tol (float): Relative error tolerance.
+        theta (float): Weight in `"combine"` case; 0 gives pure relative
+            tolerance, 1 gives pure absolute tolerance.
+        mu (float): True mean.
+        toltype (str): `"combine"` for a weighted sum of the two tolerances,
+            or `"max"` for their max.
 
-    # Returns:
-    #     float: tolerance as weighted sum of absolute and relative tolerance
-    # """
+    Returns:
+        float: Tolerance as a combination of absolute and relative tolerance.
+    """
     if toltype == "combine":  # the linear combination of two tolerances
         # theta == 0 --> relative error tolerance
         # theta == 1 --> absolute error tolerance
diff --git a/qmcpy/stopping_criterion/cub_mlmc.py b/qmcpy/stopping_criterion/cub_mlmc.py
index be8e56ef6..1985cf91c 100644
--- a/qmcpy/stopping_criterion/cub_mlmc.py
+++ b/qmcpy/stopping_criterion/cub_mlmc.py
@@ -13,10 +13,6 @@
 
 
 class CubMLMC(AbstractCubMLMC):
-    _RESUME_REQUIRED_FIELDS = (
-        "levels", "n_level", "sum_level", "diff_n_level", "cost_level", "level_integrands"
-    )
-
     """
     Multilevel IID Monte Carlo stopping criterion.
 
@@ -27,7 +23,7 @@ class CubMLMC(AbstractCubMLMC):
         >>> data
         Data (Data)
             solution        1.785
-            n_total         3577556
+            n_total         3199033
             levels          2^(2)
             n_level         [2438191  490331  207606   62905]
             mean_level      [1.715 0.053 0.013 0.003]
@@ -73,6 +69,10 @@ class CubMLMC(AbstractCubMLMC):
     2. [http://people.maths.ox.ac.uk/~gilesm/mlmc/#MATLAB](http://people.maths.ox.ac.uk/~gilesm/mlmc/#MATLAB).
     """
 
+    _RESUME_REQUIRED_FIELDS = (
+        "levels", "n_level", "sum_level", "diff_n_level", "cost_level", "level_integrands"
+    )
+
     def __init__(
         self,
         integrand,
diff --git a/qmcpy/stopping_criterion/cub_mlmc_cont.py b/qmcpy/stopping_criterion/cub_mlmc_cont.py
index e0ad1606f..30ad4cc86 100644
--- a/qmcpy/stopping_criterion/cub_mlmc_cont.py
+++ b/qmcpy/stopping_criterion/cub_mlmc_cont.py
@@ -13,10 +13,6 @@
 
 
 class CubMLMCCont(AbstractCubMLMC):
-    _RESUME_REQUIRED_FIELDS = (
-        "levels", "n_level", "sum_level", "diff_n_level", "cost_level", "level_integrands"
-    )
-
     r"""
     Multilevel IID Monte Carlo stopping criterion with continuation.
 
@@ -27,14 +23,14 @@ class CubMLMCCont(AbstractCubMLMC):
         >>> data
         Data (Data)
             solution        1.771
-            n_total         2291120
+            n_total         1480870
             levels          3
-            n_level         [1094715  222428   79666     912     256]
-            mean_level      [1.71  0.048 0.012]
-            var_level       [21.826  1.768  0.453]
+            n_level         [1145480  230538  104852]
+            mean_level      [1.71  0.048 0.013]
+            var_level       [21.819  1.766  0.451]
             cost_per_sample [2. 4. 8.]
-            alpha           1.970
-            beta            1.965
+            alpha           1.868
+            beta            1.969
             gamma           1.000
             time_integrate  ...
         CubMLMCCont (AbstractStoppingCriterion)
@@ -45,7 +41,7 @@ class CubMLMCCont(AbstractCubMLMC):
             n_tols          10
             inflate         1.668
             theta_init      2^(-1)
-            theta           0.010
+            theta           0.051
         FinancialOption (AbstractIntegrand)
             option          ASIAN
             call_put        CALL
@@ -72,6 +68,10 @@ class CubMLMCCont(AbstractCubMLMC):
     1. [https://github.com/PieterjanRobbe/MultilevelEstimators.jl](https://github.com/PieterjanRobbe/MultilevelEstimators.jl).
     """
 
+    _RESUME_REQUIRED_FIELDS = (
+        "levels", "n_level", "sum_level", "diff_n_level", "cost_level", "level_integrands"
+    )
+
     def __init__(
         self,
         integrand,
diff --git a/qmcpy/stopping_criterion/cub_mlqmc.py b/qmcpy/stopping_criterion/cub_mlqmc.py
index 57e61ee1d..e474b49eb 100644
--- a/qmcpy/stopping_criterion/cub_mlqmc.py
+++ b/qmcpy/stopping_criterion/cub_mlqmc.py
@@ -14,11 +14,6 @@
 
 
 class CubMLQMC(AbstractCubMLQMC):
-    _RESUME_REQUIRED_FIELDS = (
-        "levels", "n_level", "eval_level", "mean_level_reps", "mean_level",
-        "var_level", "cost_level", "var_cost_ratio_level", "bias_estimate", "level_integrands"
-    )
-
     """
     Multilevel Quasi-Monte Carlo stopping criterion.
 
@@ -76,6 +71,11 @@ class CubMLQMC(AbstractCubMLQMC):
         [http://people.maths.ox.ac.uk/~gilesm/files/radon.pdf](http://people.maths.ox.ac.uk/~gilesm/files/radon.pdf).
     """
 
+    _RESUME_REQUIRED_FIELDS = (
+        "levels", "n_level", "eval_level", "mean_level_reps", "mean_level",
+        "var_level", "cost_level", "var_cost_ratio_level", "bias_estimate", "level_integrands"
+    )
+
     def __init__(
         self,
         integrand,
diff --git a/qmcpy/stopping_criterion/cub_mlqmc_cont.py b/qmcpy/stopping_criterion/cub_mlqmc_cont.py
index e2e986ef8..ac6385094 100644
--- a/qmcpy/stopping_criterion/cub_mlqmc_cont.py
+++ b/qmcpy/stopping_criterion/cub_mlqmc_cont.py
@@ -14,11 +14,6 @@
 
 
 class CubMLQMCCont(AbstractCubMLQMC):
-    _RESUME_REQUIRED_FIELDS = (
-        "levels", "n_level", "eval_level", "mean_level_reps", "mean_level",
-        "var_level", "cost_level", "var_cost_ratio_level", "bias_estimate", "level_integrands"
-    )
-
     """
     Multilevel Quasi-Monte Carlo stopping criterion with continuation.
 
@@ -79,6 +74,11 @@ class CubMLQMCCont(AbstractCubMLQMC):
     1.  [https://github.com/PieterjanRobbe/MultilevelEstimators.jl](https://github.com/PieterjanRobbe/MultilevelEstimators.jl).
     """
 
+    _RESUME_REQUIRED_FIELDS = (
+        "levels", "n_level", "eval_level", "mean_level_reps", "mean_level",
+        "var_level", "cost_level", "var_cost_ratio_level", "bias_estimate", "level_integrands"
+    )
+
     def __init__(
         self,
         integrand,
diff --git a/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py b/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py
index 80266a464..52c811f58 100644
--- a/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py
+++ b/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py
@@ -299,9 +299,21 @@ def _shift_inv_kernel_digital(
 
         return vec_lambda, vec_lambda_ring, lambda_factor
 
-    # Builds High order walsh kernel function
     @staticmethod
     def BuildKernelFunc(order):
+        """Build a 1-D high-order Walsh kernel function.
+
+        Args:
+            order (int): Smoothness order of the digital-net Walsh kernel;
+                1, 2, or 3.
+
+        Returns:
+            callable: Function mapping an array of 1-D coordinates to the
+                corresponding Walsh kernel values.
+
+        Raises:
+            NotYetImplemented: If `order` is not 1, 2, or 3.
+        """
         # a1 = @(x)(-np.floor(np.log2(x)))
         def a1(x):
             out = -np.floor(np.log2(x + np.finfo(float).eps))
diff --git a/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py b/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py
index ef9def0aa..ab9c4c7e0 100644
--- a/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py
+++ b/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py
@@ -20,8 +20,6 @@
 
 
 class CubQMCRepStudentT(AbstractStoppingCriterion):
-    _RESUME_REQUIRED_FIELDS = ("xfull", "yfull", "n", "n_rep", "_ysums", "n_max")
-
     r"""
     Quasi-Monte Carlo stopping criterion based on Student's $t$-distribution for multiple replications.
 
@@ -202,6 +200,8 @@ class CubQMCRepStudentT(AbstractStoppingCriterion):
         [https://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=10408613](https://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=10408613).
     """
 
+    _RESUME_REQUIRED_FIELDS = ("xfull", "yfull", "n", "n_rep", "_ysums", "n_max")
+
     def __init__(
         self,
         integrand,
@@ -299,6 +299,23 @@ def __init__(
         )
 
     def integrate(self, resume=None):
+        """Determine the samples needed to satisfy the target tolerance.
+
+        Doubles the per-replication sample count each iteration and forms a
+        Student's $t$ confidence interval (`self.t_star`, inflated by
+        `self.inflate`, with degrees of freedom set by
+        `self.discrete_distrib.replications`) on each not-yet-converged
+        output. Stops once every combined output is within tolerance or
+        `self.n_limit` would be exceeded.
+
+        Args:
+            resume (Data): Existing integration state to resume from, if
+                supported. Defaults to None.
+
+        Returns:
+            tuple: Approximation to the integral with shape ``integrand.d_comb``
+                and the corresponding data object.
+        """
         t_start = time()
         resume_provenance = self._capture_resume_provenance(resume)
         trace = self._make_trace_logger()
@@ -435,6 +452,18 @@ def _restore_resume_state(self, data):
         self.integrand.true_measure.discrete_distrib = self.discrete_distrib
 
     def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
+        """Update the stopping criterion's target tolerance.
+
+        Args:
+            abs_tol (float): Absolute error tolerance, broadcast to
+                `self.abs_tols` with shape `integrand.d_comb`.
+            rel_tol (float): Relative error tolerance, broadcast to
+                `self.rel_tols` with shape `integrand.d_comb`.
+            rmse_tol (float): Unsupported; must be `None`.
+
+        Raises:
+            AssertionError: If `rmse_tol` is supplied.
+        """
         if not (rmse_tol is None):
             raise AssertionError("rmse_tol not supported by this stopping criterion.")
         if abs_tol is not None:
diff --git a/qmcpy/stopping_criterion/pf_gp_ci.py b/qmcpy/stopping_criterion/pf_gp_ci.py
index 0e121ef05..0e69a4a59 100644
--- a/qmcpy/stopping_criterion/pf_gp_ci.py
+++ b/qmcpy/stopping_criterion/pf_gp_ci.py
@@ -19,15 +19,45 @@
 
 
 class Suggester(object):
+    """Base class for future-sample suggestion schemes used by `PFGPCI`.
+
+    Subclasses implement `suggest` to propose the next batch of sample
+    locations, typically concentrated near the estimated failure boundary.
+    """
+
     pass
 
 
 class PFSampleErrorDensityAR(Suggester):
+    """Suggest new samples via acceptance-rejection on the GP error density.
+
+    Draws uniform candidates and accepts them with probability proportional
+    to the current GP's misclassification-error density, concentrating new
+    samples near the estimated failure boundary.
+    """
+
     def __init__(self, verbose=False) -> None:
         self.verbose = verbose
         super(PFSampleErrorDensityAR, self).__init__()
 
     def suggest(self, n, d, gp, rng, efficiency, pct=0.5):
+        """Draw `n` new sample locations via acceptance-rejection.
+
+        Args:
+            n (int): Number of samples to return.
+            d (int): Dimension of the sampling domain.
+            gp (ExactGPyTorchRegressionModel): Current GP surrogate, used to
+                evaluate the error density at candidate points.
+            rng (numpy.random.Generator): Random number generator for
+                candidate draws.
+            efficiency (float): Estimated acceptance rate, used to size each
+                batch of candidate draws.
+            pct (float): Target probability of accepting at least `n` points
+                within one candidate batch.
+
+        Returns:
+            np.ndarray: `n` accepted sample locations, shape `(n, d)`.
+        """
         if self.verbose:
             print(
                 "\tAR sampling with efficiency %.1e, expect %d draws: "
@@ -55,6 +85,13 @@ def suggest(self, n, d, gp, rng, efficiency, pct=0.5):
 
 
 class SuggesterSimple(Suggester):
+    """Suggest new samples by drawing the next block from a fixed sampler.
+
+    Wraps an `AbstractTrueMeasure`/`AbstractDiscreteDistribution` (or any
+    callable with the same interface) and advances through it sequentially,
+    ignoring the current GP state.
+    """
+
     def __init__(self, sampler) -> None:
         self.sampler = sampler
         if isinstance(self.sampler, AbstractTrueMeasure):
@@ -64,6 +101,23 @@ def __init__(self, sampler) -> None:
         super(SuggesterSimple, self).__init__()
 
     def suggest(self, n, d, gp, rng, **kwargs):
+        """Draw the next `n` sample locations from `self.sampler`.
+
+        Args:
+            n (int): Number of samples to return.
+            d (int): Dimension of the sampling domain; must match
+                `self.sampler.d`.
+            gp (ExactGPyTorchRegressionModel): Unused; accepted for
+                interface compatibility with other `Suggester`
+                implementations.
+            rng (numpy.random.Generator): Unused; accepted for interface
+                compatibility with other `Suggester` implementations.
+            **kwargs: Unused; accepted for interface compatibility with
+                other `Suggester` implementations.
+
+        Returns:
+            np.ndarray: `n` sample locations, shape `(n, d)`.
+        """
         n_max = self.n_min + n
         if not (d == self.sampler.d):
             raise AssertionError
@@ -311,6 +365,31 @@ def _affine_tf(self, y):
         )
 
     def integrate(self, seed=None, refit=False, resume=None):
+        """Determine the samples needed to satisfy the target tolerance.
+
+        Draws an initial batch (`self.n_init` points, or `init_samples` if
+        supplied), fits a GP surrogate, then repeatedly draws
+        `self.n_batch` more points via `self.batch_sampler`, updates the GP,
+        and refines the credible-interval bound on the probability of
+        failure. Stops once the bound is within `self.abs_tol` or
+        `self.n_limit` would be exceeded.
+
+        Args:
+            seed (int): Seed for the internal `DigitalNetB2` sampler used to
+                approximate the solution and (if `init_samples` was not
+                supplied) draw the initial batch.
+            refit (bool): If `True`, refit the GP hyperparameters from
+                scratch every batch rather than only on the first batch.
+            resume (Data): Unsupported; must be `None`, as `PFGPCI` cannot
+                resume a prior checkpoint.
+
+        Returns:
+            tuple: Approximation to the probability of failure
+                and the corresponding data object.
+
+        Raises:
+            ParameterError: If `resume` is not `None`.
+        """
         t0 = time.time()
         trace = self._make_trace_logger()
         if resume is not None:
@@ -471,6 +550,19 @@ def __init__(
         )
 
     def update_data(self, batch_count, xdraw, ydrawtf):
+        """Fold one new batch of samples into the GP surrogate and credible interval.
+
+        Refits the GP from scratch (on the first batch, or every batch if
+        `self.refit`), otherwise incrementally adds the new data to the
+        existing GP. Recomputes the probability-of-failure estimate and its
+        credible interval from the updated surrogate.
+
+        Args:
+            batch_count (int): Index of this batch (0 for the initial batch).
+            xdraw (np.ndarray): New sample locations, shape `(n_new, d)`.
+            ydrawtf (np.ndarray): Affine-transformed integrand values at
+                `xdraw` (positive indicates failure), shape `(n_new,)`.
+        """
         self.n_batch.append(len(xdraw))
         self.x, self.y = np.vstack([self.x, xdraw]), np.hstack([self.y, ydrawtf])
         if batch_count == 0 or self.refit:
@@ -530,6 +622,14 @@ def update_data(self, batch_count, xdraw, ydrawtf):
         )
 
     def get_results_dict(self):
+        """Collect the per-iteration history as arrays.
+
+        Returns:
+            dict: Per-iteration `"iter"`, `"n_sum"` (cumulative sample
+            count), `"n_batch"`, `"error_bounds"`, `"ci_low"`, `"ci_high"`,
+            and `"solutions"` arrays; plus `"solutions_ref"`, `"error_ref"`,
+            and `"in_ci"` if `self.approx_true_solution`.
+        """
         df = {
             "iter": np.arange(len(self.n_sum)),
             "n_sum": self.n_sum,
@@ -548,6 +648,17 @@ def get_results_dict(self):
         return df
 
     def plot(self, trace_only=False, **kwargs):
+        """Plot the convergence trace, plus a per-batch GP diagnostic panel if `d` is 1 or 2.
+
+        Args:
+            trace_only (bool): If `True` (or if `d` is not 1 or 2, or no GP
+                has been fit yet), plot only the convergence trace.
+            **kwargs: Passed through to `plot_1d`/`plot_2d` when a
+                per-batch diagnostic panel is drawn.
+
+        Returns:
+            matplotlib.figure.Figure: The assembled figure.
+        """
         from matplotlib import pyplot
 
         if self.d == 1 and not trace_only and self.saved_gps != []:
@@ -606,6 +717,19 @@ def plot(self, trace_only=False, **kwargs):
         return fig
 
     def plot_1d(self, meshticks=1025, ci_percentage=0.95, **kwargs):
+        """Plot, for each batch, the 1-D error density and GP fit with a credible band.
+
+        Args:
+            meshticks (int): Number of points in the `[0,1]` plotting mesh.
+            ci_percentage (float): Credible level for the plotted GP
+                prediction band.
+            **kwargs: Unused; accepted for interface compatibility with
+                `plot`.
+
+        Returns:
+            matplotlib.figure.Figure: The assembled figure.
+            matplotlib.gridspec.GridSpec: The figure's grid layout.
+        """
         from matplotlib import pyplot, gridspec
 
         beta = norm.ppf(np.mean([ci_percentage, 1]))
@@ -671,6 +795,19 @@ def plot_1d(self, meshticks=1025, ci_percentage=0.95, **kwargs):
         return fig, gs
 
     def plot_2d(self, meshticks=257, clevels=32, **kwargs):
+        """Plot, for each batch, 2-D contours of the true function, error density, and GP mean.
+
+        Args:
+            meshticks (int): Number of points per axis in the `[0,1]^2`
+                plotting mesh.
+            clevels (int): Number of contour levels.
+            **kwargs: Unused; accepted for interface compatibility with
+                `plot`.
+
+        Returns:
+            matplotlib.figure.Figure: The assembled figure.
+            matplotlib.gridspec.GridSpec: The figure's grid layout.
+        """
         from matplotlib import pyplot, gridspec, colormaps
 
         n_batches = len(self.n_batch)
diff --git a/qmcpy/true_measure/abstract_true_measure.py b/qmcpy/true_measure/abstract_true_measure.py
index d8ba7bf12..806eb36c7 100644
--- a/qmcpy/true_measure/abstract_true_measure.py
+++ b/qmcpy/true_measure/abstract_true_measure.py
@@ -7,6 +7,15 @@
 
 
 class AbstractTrueMeasure(object):
+    """Abstract base class for QMCPy true measures.
+
+    A true measure composes a transform (`self.transform`) on top of a
+    sampler (an `AbstractDiscreteDistribution`, or another
+    `AbstractTrueMeasure` for recursive composition), mapping unit-cube
+    samples to samples from the target measure. Concrete measures (e.g.
+    `Gaussian`, `Uniform`) set `self.domain`, `self.range`, and implement the
+    transform/weight/moment logic this base class exposes.
+    """
 
     def __init__(self) -> None:
         prefix = "A concrete implementation of TrueMeasure must have "
@@ -64,18 +73,34 @@ def _scalar_if_univariate(self, value):
 
     @property
     def mean(self):
+        """Union[float, np.ndarray]: The measure's mean, set via `_set_moments`.
+        A Python `float` for univariate (`d == 1`) measures, otherwise a
+        read-only array.
+        """
         return self._scalar_if_univariate(self._mean)
 
     @property
     def variance(self):
+        """Union[float, np.ndarray]: The measure's variance, set via
+        `_set_moments`. A Python `float` for univariate (`d == 1`) measures,
+        otherwise a read-only array.
+        """
         return self._scalar_if_univariate(self._variance)
 
     @property
     def standard_deviation(self):
+        """Union[float, np.ndarray]: The measure's standard deviation, set
+        via `_set_moments`. A Python `float` for univariate (`d == 1`)
+        measures, otherwise a read-only array.
+        """
         return self._scalar_if_univariate(self._standard_deviation)
 
     @property
     def covariance(self):
+        """Union[np.ndarray, scipy.sparse.spmatrix]: The measure's
+        covariance, set via `_set_moments`. Read-only; sparse covariances
+        are returned as-is, dense ones as a read-only view.
+        """
         covariance = self._covariance
         if sparse.issparse(covariance):
             return covariance
@@ -143,6 +168,9 @@ def __call__(self, n=None, n_min=None, n_max=None, return_weights=False, warn=Tr
     def gen_samples(
         self, n=None, n_min=None, n_max=None, return_weights=False, warn=True
     ):
+        r"""Generate samples from the measure. Called by `__call__`; see its
+        docstring for the full `Args:`/`Returns:` description.
+        """
         x = self.discrete_distrib(n=n, n_min=n_min, n_max=n_max, warn=warn)
         if not (isinstance(return_weights, bool)):
             raise AssertionError
diff --git a/qmcpy/true_measure/product_measure.py b/qmcpy/true_measure/product_measure.py
index 3f71c3264..88c961927 100644
--- a/qmcpy/true_measure/product_measure.py
+++ b/qmcpy/true_measure/product_measure.py
@@ -224,18 +224,29 @@ def _concatenate_marginal_statistic(self, statistic):
 
     @property
     def mean(self):
+        """np.ndarray: The measure's mean, concatenated from each marginal's
+        `mean` in marginal order and cached after first access.
+        """
         if self._mean_cache is None:
             self._mean_cache = self._concatenate_marginal_statistic("mean")
         return self._mean_cache
 
     @property
     def variance(self):
+        """np.ndarray: The measure's variance, concatenated from each
+        marginal's `variance` in marginal order and cached after first
+        access.
+        """
         if self._variance_cache is None:
             self._variance_cache = self._concatenate_marginal_statistic("variance")
         return self._variance_cache
 
     @property
     def standard_deviation(self):
+        """np.ndarray: The measure's standard deviation, concatenated from
+        each marginal's `standard_deviation` in marginal order and cached
+        after first access.
+        """
         if self._standard_deviation_cache is None:
             self._standard_deviation_cache = self._concatenate_marginal_statistic(
                 "standard_deviation"
@@ -284,6 +295,11 @@ def _compute_covariance(self):
 
     @property
     def covariance(self):
+        """Union[np.ndarray, scipy.sparse.spmatrix]: The measure's
+        block-diagonal covariance, built from each marginal's `covariance`
+        and cached after first access. Sparse if any marginal's covariance
+        is sparse, dense otherwise.
+        """
         if self._covariance_cache is None:
             self._covariance_cache = self._compute_covariance()
         return self._covariance_cache
diff --git a/qmcpy/true_measure/triangular.py b/qmcpy/true_measure/triangular.py
index a836d1612..ebefd1945 100644
--- a/qmcpy/true_measure/triangular.py
+++ b/qmcpy/true_measure/triangular.py
@@ -30,6 +30,14 @@ def __init__(self, c=0.5, loc=0.0, scale=1.0) -> None:
         self._m = loc + c * scale
 
     def pdf(self, x):
+        """Probability density function of the triangular distribution.
+
+        Args:
+            x (np.ndarray): Points at which to evaluate the density.
+
+        Returns:
+            np.ndarray: Density values, same shape as `x`.
+        """
         x = np.asarray(x, dtype=float)
         a, m, b = self._a, self._m, self._b
         out = np.zeros_like(x, dtype=float)
@@ -42,6 +50,14 @@ def pdf(self, x):
         return out
 
     def ppf(self, u):
+        """Percent point function (inverse CDF) of the triangular distribution.
+
+        Args:
+            u (np.ndarray): Probabilities in `[0,1]` at which to evaluate the inverse CDF.
+
+        Returns:
+            np.ndarray: Quantile values, same shape as `u`.
+        """
         u = np.asarray(u, dtype=float)
         a, m, b = self._a, self._m, self._b
         Fm = (m - a) / (b - a)
diff --git a/scripts/baseline_counts.json b/scripts/baseline_counts.json
index 0211d8b78..8721ace92 100644
--- a/scripts/baseline_counts.json
+++ b/scripts/baseline_counts.json
@@ -1,5 +1,5 @@
 {
-  "check_docstring": 188,
+  "check_docstring": 0,
   "pydoclint": 151,
   "unsafe_annotations": 109
 }
diff --git a/scripts/check_baseline.py b/scripts/check_baseline.py
index c12bbde0b..ceffcc31a 100644
--- a/scripts/check_baseline.py
+++ b/scripts/check_baseline.py
@@ -28,7 +28,13 @@
 CHECKS = {
     "check_docstring": {
         "cmd": [sys.executable, "scripts/check_docstring.py", "qmcpy"],
-        "pattern": re.compile(r"^\d+ file\(s\) scanned: (\d+) issue\(s\) across \d+ file\(s\)", re.M),
+        # check_docstring.py's summary line reads either "N issue(s) across
+        # M file(s)" or, once N reaches zero, "no issues in M file(s)" --
+        # match both so the ratchet keeps working after a check is fully fixed.
+        "pattern": re.compile(
+            r"^\d+ file\(s\) scanned: (?:(\d+) issue\(s\) across|no issues in) \d+ file\(s\)",
+            re.M,
+        ),
     },
     "pydoclint": {
         "cmd": ["pydoclint", "-q", "qmcpy"],
@@ -49,7 +55,7 @@ def run_check(spec):
     match = spec["pattern"].search(output)
     if match is None:
         raise RuntimeError(f"could not parse a count from output of {spec['cmd']}")
-    return int(match.group(1))
+    return int(match.group(1) or 0)
 
 
 def main(argv):
diff --git a/scripts/check_docstring.py b/scripts/check_docstring.py
index 8583237e6..5c1f4ce16 100644
--- a/scripts/check_docstring.py
+++ b/scripts/check_docstring.py
@@ -65,6 +65,20 @@
 _CANON = {name.lower(): name for name in GOOGLE_SECTIONS | NUMPY_SECTIONS}
 
 
+def _is_property_setter_or_deleter(node):
+    """True if ``node`` is decorated ``@<name>.setter`` or ``@<name>.deleter``.
+
+    Such methods share their contract with the ``@property`` getter of the
+    same name (which is separately checked), so requiring their own
+    docstring would be a false positive -- no Python convention expects one.
+    """
+    for decorator in node.decorator_list:
+        if (isinstance(decorator, ast.Attribute)
+                and decorator.attr in ("setter", "deleter")):
+            return True
+    return False
+
+
 def _iter_public(tree):
     """Yield ``(node, kind)`` for the module plus its public API objects."""
     yield tree, "module"
@@ -77,6 +91,8 @@ def _iter_public(tree):
             for sub in node.body:
                 if not isinstance(sub, (ast.FunctionDef, ast.AsyncFunctionDef)):
                     continue
+                if _is_property_setter_or_deleter(sub):
+                    continue
                 if not sub.name.startswith("_"):
                     yield sub, "method"
                 elif sub.name == "__init__":

From 526f980ac1156686b3bd67ca229c6acef253c7fe Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Wed, 9 Sep 2026 10:33:26 +0800
Subject: [PATCH 40/51] Add type hints to public APIs

---
 pyproject.toml                                |   2 +-
 .../abstract_discrete_distribution.py         |   9 +-
 .../digital_net_any_bases.py                  |  19 +-
 .../digital_net_any_bases/hammersley.py       |   8 +-
 .../digital_net_b2/digital_net_b2.py          |  26 +-
 qmcpy/discrete_distribution/dummy_sampler.py  |  15 +-
 .../discrete_distribution/iid_std_uniform.py  |   3 +-
 qmcpy/discrete_distribution/korobov.py        |   9 +-
 qmcpy/discrete_distribution/kronecker.py      |  27 +-
 .../discrete_distribution/latin_hypercube.py  |   3 +-
 .../discrete_distribution/lattice/lattice.py  |  17 +-
 qmcpy/discrete_distribution/mpmc/models.py    |  12 +-
 qmcpy/discrete_distribution/mpmc/mpmc.py      |  90 ++++-
 qmcpy/fast_transform/ft.py                    |  10 +-
 qmcpy/fast_transform/ft_pytorch.py            |  15 +-
 qmcpy/fast_transform/ft_qmctoolscl.py         |   6 +-
 qmcpy/integrand/abstract_integrand.py         |  27 +-
 qmcpy/integrand/bayesian_lr_coeffs.py         |  17 +-
 qmcpy/integrand/box_integral.py               |   9 +-
 qmcpy/integrand/custom_fun.py                 |  10 +-
 qmcpy/integrand/financial_option.py           |  63 +--
 qmcpy/integrand/fourbranch2d.py               |   9 +-
 qmcpy/integrand/genz.py                       |  11 +-
 qmcpy/integrand/hartmann6d.py                 |   9 +-
 qmcpy/integrand/ishigami.py                   |   9 +-
 qmcpy/integrand/keister.py                    |  13 +-
 qmcpy/integrand/linear0.py                    |  10 +-
 qmcpy/integrand/multimodal2d.py               |   9 +-
 qmcpy/integrand/sensitivity_indices.py        |  11 +-
 qmcpy/integrand/sin1d.py                      |   9 +-
 qmcpy/integrand/umbridge_wrapper.py           |  17 +-
 qmcpy/kernel/abstract_kernel.py               |  68 ++--
 qmcpy/kernel/common_kernels.py                |  54 +--
 qmcpy/kernel/multitask_kernel.py              |  39 +-
 qmcpy/kernel/si_dsi_kernels.py                | 367 +++++++++---------
 .../abstract_cub_bayes_ld_g.py                |  21 +-
 qmcpy/stopping_criterion/abstract_cub_mlmc.py |  16 +-
 .../stopping_criterion/abstract_cub_mlqmc.py  |  12 +-
 .../abstract_cub_qmc_ld_g.py                  |  15 +-
 .../abstract_stopping_criterion.py            |  67 ++--
 qmcpy/stopping_criterion/cub_mc_clt.py        |  33 +-
 qmcpy/stopping_criterion/cub_mc_clt_vec.py    |  34 +-
 qmcpy/stopping_criterion/cub_mc_g.py          |  35 +-
 qmcpy/stopping_criterion/cub_mlmc.py          |  23 +-
 qmcpy/stopping_criterion/cub_mlmc_cont.py     |  23 +-
 qmcpy/stopping_criterion/cub_mlqmc.py         |  22 +-
 qmcpy/stopping_criterion/cub_mlqmc_cont.py    |  22 +-
 .../cub_qmc_bayes_lattice_g.py                |  20 +-
 .../stopping_criterion/cub_qmc_bayes_net_g.py |  24 +-
 qmcpy/stopping_criterion/cub_qmc_lattice_g.py |  20 +-
 qmcpy/stopping_criterion/cub_qmc_net_g.py     |  28 +-
 .../cub_qmc_rep_student_t.py                  |  34 +-
 qmcpy/stopping_criterion/diagnostics.py       |  45 ++-
 qmcpy/stopping_criterion/pf_gp_ci.py          |  61 +--
 qmcpy/true_measure/abstract_true_measure.py   |   9 +-
 qmcpy/true_measure/acceptance_rejection.py    |  17 +-
 qmcpy/true_measure/bernoulli_cont.py          |   6 +-
 qmcpy/true_measure/brownian_motion.py         |  11 +-
 qmcpy/true_measure/clayton_copula.py          |   7 +-
 qmcpy/true_measure/frank_copula.py            |   7 +-
 qmcpy/true_measure/gaussian.py                |   5 +-
 qmcpy/true_measure/gaussian_copula.py         |   7 +-
 .../true_measure/geometric_brownian_motion.py |  18 +-
 qmcpy/true_measure/gumbel_copula.py           |   7 +-
 qmcpy/true_measure/johnsons_su.py             |   6 +-
 qmcpy/true_measure/kumaraswamy.py             |   6 +-
 qmcpy/true_measure/matern_gp.py               |   4 +-
 qmcpy/true_measure/product_measure.py         |  36 +-
 qmcpy/true_measure/scipy_wrapper.py           |   5 +-
 qmcpy/true_measure/student_t_copula.py        |   7 +-
 qmcpy/true_measure/triangular.py              |   4 +-
 qmcpy/true_measure/uniform.py                 |   6 +-
 qmcpy/true_measure/uniform_triangle.py        |  14 +-
 .../true_measure/zero_inflated_exp_uniform.py |  20 +-
 qmcpy/util/abstraction_functions.py           |   2 +-
 qmcpy/util/data.py                            |  10 +-
 qmcpy/util/dig_shift_invar_ops.py             |  20 +-
 qmcpy/util/exact_gpytorch_regression_model.py |  11 +-
 qmcpy/util/latnetbuilder_linker.py            |   2 +-
 qmcpy/util/mlmc_test.py                       |   3 +-
 qmcpy/util/plot_functions.py                  |  27 +-
 qmcpy/util/shift_invar_ops.py                 |  16 +-
 qmcpy/util/stop_notebook.py                   |   2 +-
 qmcpy/util/torch_numpy_ops.py                 |  11 +-
 qmcpy/util/transforms.py                      |  59 +--
 scripts/annotate_public_api_types.py          |  74 +++-
 scripts/baseline_counts.json                  |   2 +-
 scripts/check_baseline.py                     |   9 +
 88 files changed, 1228 insertions(+), 809 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index 4b009427b..68ee105aa 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -193,7 +193,7 @@ class = [
 # the docstring (`name (type): ...`), not in the signature.
 style = "google"
 allow-init-docstring = true
-arg-type-hints-in-signature = false
+arg-type-hints-in-signature = true
 arg-type-hints-in-docstring = true
 check-return-types = false
 check-yield-types = false
diff --git a/qmcpy/discrete_distribution/abstract_discrete_distribution.py b/qmcpy/discrete_distribution/abstract_discrete_distribution.py
index 48001d8fb..a03873060 100644
--- a/qmcpy/discrete_distribution/abstract_discrete_distribution.py
+++ b/qmcpy/discrete_distribution/abstract_discrete_distribution.py
@@ -1,3 +1,4 @@
+from typing import Union
 from ..util import (
     ParameterError,
     MethodImplementationError,
@@ -58,7 +59,7 @@ def __init__(self, dimension, replications, seed, d_limit, n_limit) -> None:
         self.spawn_key = self._base_seed.spawn_key
         self.rng = np.random.Generator(np.random.SFC64(self._base_seed))
 
-    def __call__(self, n=None, n_min=None, n_max=None, return_binary=False, warn=True):
+    def __call__(self, n: Union[None, int] = None, n_min: Union[None, int] = None, n_max: Union[None, int] = None, return_binary: bool = False, warn: bool = True):
         r"""
         - If just `n` is supplied, generate samples from the sequence at indices 0,...,`n`-1.
         - If `n_min` and `n_max` are supplied, generate samples from the sequence at indices `n_min`,...,`n_max`-1.
@@ -133,7 +134,7 @@ def gen_samples(
     def _gen_samples(self, *args, **kwargs):
         raise MethodImplementationError(self, "_gen_samples")
 
-    def spawn(self, s: int = 1, dimensions: np.ndarray = None):
+    def spawn(self, s: int = 1, dimensions: Union[None, np.ndarray] = None) -> list:
         r"""Spawn new instances of the current discrete distribution but with
         new seeds and dimensions. Used by multi-level QMC algorithms which
         require different seeds and dimensions on each level.
@@ -144,7 +145,7 @@ def spawn(self, s: int = 1, dimensions: np.ndarray = None):
 
         Args:
             s (int): Number of copies to spawn
-            dimensions (np.ndarray): Length `s` array of dimensions for each
+            dimensions (Union[None, np.ndarray]): Length `s` array of dimensions for each
                 copy. Defaults to the current dimension.
 
         Returns:
@@ -174,7 +175,7 @@ def spawn(self, s: int = 1, dimensions: np.ndarray = None):
     def _spawn(self, child_seed, dimension):
         raise MethodImplementationError(self, "_spawn")
 
-    def pdf(self, x):
+    def pdf(self, x: np.ndarray) -> np.ndarray:
         """Probability density function of the distribution this sampler mimics.
 
         Args:
diff --git a/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py b/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py
index 331fe4d64..308fb3f1c 100644
--- a/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py
+++ b/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py
@@ -1,3 +1,4 @@
+from typing import Union
 import warnings
 from ..abstract_discrete_distribution import AbstractLDDiscreteDistribution
 from ...util import ParameterError,ParameterWarning
@@ -157,12 +158,12 @@ class DigitalNetAnyBases(AbstractLDDiscreteDistribution):
     DEFAULT_GENERATING_MATRICES = None
 
     def __init__(self,
-                 dimension = 1,
-                 replications: int = None,
-                 seed = None,
+                 dimension: Union[int, np.ndarray] = 1,
+                 replications: Union[None, int] = None,
+                 seed: Union[None, int, np.random.SeedSequence] = None,
                  randomize: str = 'LMS DP',
-                 bases_generating_matrices = None,
-                 t: int = None,
+                 bases_generating_matrices: Union[None, str, tuple] = None,
+                 t: Union[None, int] = None,
                  alpha: int = 1,
                  n_lim: int = 2**32,
                  warn: bool = True) -> None:
@@ -174,9 +175,9 @@ def __init__(self,
                 - If an `int` is passed in, use generating vector components at indices 0,...,`dimension`-1.
                 - If an `np.ndarray` is passed in, use generating vector components at these indices.
 
-            replications (int): Number of independent randomizations of a
+            replications (Union[None, int]): Number of independent randomizations of a
                 pointset.
-            seed (Union[None,int,np.random.SeedSeq]): Seed the random number
+            seed (Union[None,int,np.random.SeedSequence]): Seed the random number
                 generator for reproducibility.
             randomize (str): Options are
 
@@ -189,7 +190,7 @@ def __init__(self,
                 - `'QRNG'`: Deterministic permutation scramble and random digital shift from QRNG [1] (with `generalize=True`). Does *not* support replications>1.
                 - `None`: No randomization. In this case the first point will be the origin.
 
-            bases_generating_matrices (Union[str, tuple]): Specify the bases
+            bases_generating_matrices (Union[None, str, tuple]): Specify the bases
                 and the generating matrices.
 
                 - `"HALTON"` will use Halton generating matrices.
@@ -199,7 +200,7 @@ def __init__(self,
                     - `bases` is an `np.ndarray` of integers with shape $(,d)$ or $(r,d)$ where $d$ is the number of dimensions and $r$ is the number of replications.
                     - `generating_matrices` is an `np.ndarray` of integers with shape $(d,m_\mathrm{max},t_\mathrm{max})$ or $(r,d,m_\mathrm{max},t_\mathrm{max})$ where $d$ is the number of dimensions, $r$ is the number of replications, and $2^{m_\mathrm{max}}$ is the maximum number of supported points.
 
-            t (int): Number of digits *after* randomization. The number of
+            t (Union[None, int]): Number of digits *after* randomization. The number of
                 digits in the generating matrices is inferred.
             alpha (int): Interlacing factor for higher order nets. When
                 `alpha`>1, interlacing is performed regardless of the
diff --git a/qmcpy/discrete_distribution/digital_net_any_bases/hammersley.py b/qmcpy/discrete_distribution/digital_net_any_bases/hammersley.py
index 505e4fbae..2cbe5c267 100644
--- a/qmcpy/discrete_distribution/digital_net_any_bases/hammersley.py
+++ b/qmcpy/discrete_distribution/digital_net_any_bases/hammersley.py
@@ -1,3 +1,4 @@
+from typing import Union
 from qmcpy.util import ParameterError,ParameterWarning
 import numpy as np
 from .halton import Halton
@@ -67,10 +68,10 @@ class Hammersley(DigitalNetAnyBases):
 
     def __init__(self,
                  dimension: int = 1,
-                 seed=None,
-                 t=None,
+                 seed: Union[None, int, np.random.SeedSequence] = None,
+                 t: Union[None, int] = None,
                  n_lim: int = 2**32,
-                 warn = True
+                 warn: bool = True
                 ) -> None:
         r"""Initialize a Hammersley discrete distribution.
 
@@ -90,6 +91,7 @@ class Notes).
 
             n_lim (int): Maximum number of points `n` this distribution can be
                 asked to generate.
+            warn (bool): If `False`, disable warnings when generating samples.
         """
 
         if not np.isscalar(dimension):
diff --git a/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py b/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
index 4916592f4..4780c49db 100644
--- a/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
+++ b/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
@@ -1,3 +1,4 @@
+from typing import Union
 from ..abstract_discrete_distribution import AbstractLDDiscreteDistribution
 from ...util import ParameterError, ParameterWarning
 import qmctoolscl
@@ -215,20 +216,20 @@ class DigitalNetB2(AbstractLDDiscreteDistribution):
 
     def __init__(
         self,
-        dimension=1,
-        replications: int = None,
-        seed=None,
+        dimension: Union[int, np.ndarray] = 1,
+        replications: Union[None, int] = None,
+        seed: Union[None, int, np.random.SeedSequence] = None,
         randomize: str = "LMS DS",
-        generating_matrices="joe_kuo.6.21201.txt",
+        generating_matrices: Union[str, np.ndarray, int] = "joe_kuo.6.21201.txt",
         order: str = "RADICAL INVERSE",
         t: int = 63,
         alpha: int = 1,
-        msb: bool = None,
+        msb: Union[None, bool] = None,
         _verbose: bool = False,
         # deprecated
-        graycode=None,
-        t_max=None,
-        t_lms=None,
+        graycode: Union[None, bool] = None,
+        t_max: Union[None, int] = None,
+        t_lms: Union[None, int] = None,
     ) -> None:
         r"""Initialize a DigitalNetB2 discrete distribution.
 
@@ -238,7 +239,7 @@ def __init__(
                 - If an `int` is passed in, use generating vector components at indices 0,...,`dimension`-1.
                 - If an `np.ndarray` is passed in, use generating vector components at these indices.
 
-            replications (int): Number of independent randomizations of a
+            replications (Union[None, int]): Number of independent randomizations of a
                 pointset.
             seed (Union[None, int, np.random.SeedSequence]): Seed the random
                 number generator for reproducibility.
@@ -266,12 +267,17 @@ def __init__(
                 generating matrices, i.e., for `alpha`>1 do *not* pass in
                 generating matrices which are already interlaced. The Note for
                 this class contains more info.
-            msb (bool): Flag for Most Significant Bit (MSB) vs Least
+            msb (Union[None, bool]): Flag for Most Significant Bit (MSB) vs Least
                 Significant Bit (LSB) integer representations in generating
                 matrices. If `msb=False` (LSB order), then integers in
                 generating matrices will be bit-reversed.
             _verbose (bool): If `True`, print linear matrix scrambling
                 matrices.
+            graycode (Union[None, bool]): Deprecated; set `order='GRAY'` or
+                `order='RADICAL INVERSE'` instead.
+            t_max (Union[None, int]): Deprecated; has no effect, as it can be inferred
+                from the generating matrices.
+            t_lms (Union[None, int]): Deprecated; set `t` instead.
         """
         if graycode is not None:
             order = "GRAY" if graycode else "RADICAL INVERSE"
diff --git a/qmcpy/discrete_distribution/dummy_sampler.py b/qmcpy/discrete_distribution/dummy_sampler.py
index bd85ea202..3190d94b4 100644
--- a/qmcpy/discrete_distribution/dummy_sampler.py
+++ b/qmcpy/discrete_distribution/dummy_sampler.py
@@ -1,3 +1,5 @@
+from typing import Union
+import numpy as np
 from .abstract_discrete_distribution import AbstractLDDiscreteDistribution
 from ..util import ParameterError
 
@@ -28,7 +30,18 @@ class DummySampler(AbstractLDDiscreteDistribution):
     qmcpy.util.exceptions_warnings.ParameterError: DummySampler is only a construction placeholder for ProductMeasure child true measures and cannot generate samples.
     """
 
-    def __init__(self, dimension=1, replications=None, seed=None, warn=True) -> None:
+    def __init__(self, dimension: int = 1, replications: Union[None, int] = None, seed: Union[None, int, np.random.SeedSequence] = None, warn: bool = True) -> None:
+        """Initialize a DummySampler discrete distribution.
+
+        Args:
+            dimension (int): Dimension of the placeholder sampler.
+            replications (Union[None, int]): Number of independent randomizations, kept
+                for API consistency with the other discrete distributions.
+            seed (Union[None, int, np.random.SeedSequence]): Unused; kept for
+                API consistency with the other discrete distributions.
+            warn (bool): Unused; kept for API consistency with the other
+                discrete distributions.
+        """
         # Keep the same constructor as other discrete distributions.
         del warn
 
diff --git a/qmcpy/discrete_distribution/iid_std_uniform.py b/qmcpy/discrete_distribution/iid_std_uniform.py
index 8dd882d01..50a04ae1f 100644
--- a/qmcpy/discrete_distribution/iid_std_uniform.py
+++ b/qmcpy/discrete_distribution/iid_std_uniform.py
@@ -1,3 +1,4 @@
+from typing import Union
 from .abstract_discrete_distribution import AbstractIIDDiscreteDistribution
 from ..util import ParameterError, ParameterWarning
 import numpy as np
@@ -49,7 +50,7 @@ class IIDStdUniform(AbstractIIDDiscreteDistribution):
                 [0.6171181 , 0.1239209 , 0.16809479]]])
     """
 
-    def __init__(self, dimension: int = 1, replications=None, seed=None) -> None:
+    def __init__(self, dimension: int = 1, replications: Union[None, int] = None, seed: Union[None, int, np.random.SeedSequence] = None) -> None:
         r"""Initialize an IIDStdUniform discrete distribution.
 
         Args:
diff --git a/qmcpy/discrete_distribution/korobov.py b/qmcpy/discrete_distribution/korobov.py
index 33e2917d8..5c775f151 100644
--- a/qmcpy/discrete_distribution/korobov.py
+++ b/qmcpy/discrete_distribution/korobov.py
@@ -1,3 +1,4 @@
+from typing import Union
 import numpy as np
 from qmcpy.util import ParameterError, ParameterWarning
 from pathlib import Path
@@ -25,7 +26,7 @@ def load_korobov_table(
         }
     return raw, lut
 
-def get_a(lut, n, d):
+def get_a(lut: dict, n: int, d: int) -> int:
     """Look up the tabulated Korobov generator `a` for a given `n` and `d`.
 
     Args:
@@ -149,8 +150,8 @@ class KorobovLattice(AbstractLDDiscreteDistribution):
     def __init__(
             self,
             dimension: int = 1,
-            replications: int = None,
-            seed=None,
+            replications: Union[None, int] = None,
+            seed: Union[None, int, np.random.SeedSequence] = None,
             randomize: str = "SHIFT",
         ) -> None:
         r"""Initialize a KorobovLattice discrete distribution.
@@ -159,7 +160,7 @@ def __init__(
             dimension (int): Dimension of the samples. Must be between 1 and
                 250 (the range covered by the precomputed table).
 
-            replications (int): Number of independent Cranley-Patterson shifts
+            replications (Union[None, int]): Number of independent Cranley-Patterson shifts
                 of the same underlying deterministic lattice.
 
             seed (Union[None, int, np.random.SeedSequence]): Seed the random
diff --git a/qmcpy/discrete_distribution/kronecker.py b/qmcpy/discrete_distribution/kronecker.py
index eaabf912f..e5f70a21a 100644
--- a/qmcpy/discrete_distribution/kronecker.py
+++ b/qmcpy/discrete_distribution/kronecker.py
@@ -1,3 +1,4 @@
+from typing import Union, Tuple, Callable
 from .abstract_discrete_distribution import AbstractLDDiscreteDistribution
 from ..util import ParameterError
 import numpy as np
@@ -218,12 +219,12 @@ class Kronecker(AbstractLDDiscreteDistribution):
     """
 
     def __init__(self,
-        dimension=1,
-        replications: int = None,
-        seed=None,
+        dimension: Union[int, np.ndarray] = 1,
+        replications: Union[None, int] = None,
+        seed: Union[None, int, np.random.SeedSequence] = None,
         randomize: str = "SHIFT",
-        generating_vector="CBC",
-        shift: np.ndarray = None,
+        generating_vector: Union[str, np.ndarray] = "CBC",
+        shift: Union[None, np.ndarray] = None,
         warn: bool = True,
     ) -> None:
         r"""Initialize a Kronecker discrete distribution.
@@ -234,7 +235,7 @@ def __init__(self,
                 - If an `int` is passed in, use generating vector components at indices 0,...,`dimension`-1.
                 - If an `np.ndarray` is passed in, use generating vector components at these indices.
 
-            replications (int): Number of independent randomizations.
+            replications (Union[None, int]): Number of independent randomizations.
             seed (Union[None, int, np.random.SeedSequence]): Seed the random
                 number generator for reproducibility.
             randomize (str): Options are
@@ -250,7 +251,7 @@ def __init__(self,
                 - `"SUZUKI"`: uses a deterministic construction $\boldsymbol{\alpha}_j = 2^{j/(d+1)}$.
                 - np.array: user-specified generating vector.
 
-            shift (np.ndarray): Shift vector $\boldsymbol{\delta}$. If
+            shift (Union[None, np.ndarray]): Shift vector $\boldsymbol{\delta}$. If
                 `randomize=True`, this is ignored and a random shift is
                 generated. Otherwise, a fixed shift is used.
             warn (bool): If False, suppress warnings during construction
@@ -340,16 +341,16 @@ def _gen_samples(self, n_min, n_max, return_binary, warn):
         points = ((i[:,None] * self.gen_vec[:,None,:]) + self.shift[:, None, :]) % 1
         return points
 
-    def periodic_discrepancy(self, n, k_tilde=None, gamma=None):
+    def periodic_discrepancy(self, n: int, k_tilde: Union[None, Tuple[Callable, float]] = None, gamma: Union[None, np.ndarray] = None) -> np.ndarray:
         """Calculate the discrepancy for a periodic kernel.
 
         Args:
             n (int): The number of sample points.
-            k_tilde (Tuple[callable, float]): A `(function, integral)` pair
+            k_tilde (Union[None, Tuple[Callable, float]]): A `(function, integral)` pair
                 where the function takes the sample points and coordinate
                 weights and returns kernel values, and `integral` is that
                 function's integral over the unit hypercube.
-            gamma (np.ndarray): Coordinate weights, shape `(d,)`.
+            gamma (Union[None, np.ndarray]): Coordinate weights, shape `(d,)`.
 
         Returns:
             np.ndarray: The discrepancy.
@@ -367,15 +368,15 @@ def periodic_discrepancy(self, n, k_tilde=None, gamma=None):
         return np.sqrt(self._square_periodic_discrepancies(n, k_tilde, gamma))
 
 
-    def wssd_discrepancy(self, n, weights, k_tilde = None, gamma = None):
+    def wssd_discrepancy(self, n: int, weights: np.ndarray, k_tilde: Union[None, Tuple[Callable, float]] = None, gamma: Union[None, np.ndarray] = None) -> np.ndarray:
         """Calculate the weighted sum of squared discrepancies.
 
         Args:
             n (int): The number of sample points.
             weights (np.ndarray): Weights applied to each squared discrepancy
                 before summing.
-            k_tilde (Tuple[callable, float]): Same as in `periodic_discrepancy`.
-            gamma (np.ndarray): Coordinate weights, shape `(d,)`.
+            k_tilde (Union[None, Tuple[Callable, float]]): Same as in `periodic_discrepancy`.
+            gamma (Union[None, np.ndarray]): Coordinate weights, shape `(d,)`.
 
         Returns:
             np.ndarray: The weighted sum of squared discrepancies.
diff --git a/qmcpy/discrete_distribution/latin_hypercube.py b/qmcpy/discrete_distribution/latin_hypercube.py
index c37beacf8..19258db8a 100644
--- a/qmcpy/discrete_distribution/latin_hypercube.py
+++ b/qmcpy/discrete_distribution/latin_hypercube.py
@@ -1,3 +1,4 @@
+from typing import Union
 from .abstract_discrete_distribution import AbstractDiscreteDistribution
 import numpy as np
 from qmcpy.util import ParameterError, ParameterWarning
@@ -95,7 +96,7 @@ class LatinHypercube(AbstractDiscreteDistribution):
     """
 
     def __init__(
-            self, dimension: int, replications, seed, randomize: str = "TRUE"
+            self, dimension: int, replications: Union[None, int], seed: Union[None, int, np.random.SeedSequence], randomize: str = "TRUE"
             ) -> None:
         r"""Initialize a LatinHypercube discrete distribution.
 
diff --git a/qmcpy/discrete_distribution/lattice/lattice.py b/qmcpy/discrete_distribution/lattice/lattice.py
index 411f6668d..d769c7d3c 100644
--- a/qmcpy/discrete_distribution/lattice/lattice.py
+++ b/qmcpy/discrete_distribution/lattice/lattice.py
@@ -1,3 +1,4 @@
+from typing import Union
 from ..abstract_discrete_distribution import AbstractLDDiscreteDistribution
 from ...util import ParameterError, ParameterWarning
 import qmctoolscl
@@ -140,13 +141,13 @@ class Lattice(AbstractLDDiscreteDistribution):
 
     def __init__(
         self,
-        dimension=1,
-        replications: int = None,
-        seed=None,
+        dimension: Union[int, np.ndarray] = 1,
+        replications: Union[None, int] = None,
+        seed: Union[None, int, np.random.SeedSequence] = None,
         randomize: str = "SHIFT",
-        generating_vector="kuo.lattice-33002-1024-1048576.9125.txt",
+        generating_vector: Union[str, np.ndarray, int] = "kuo.lattice-33002-1024-1048576.9125.txt",
         order: str = "RADICAL INVERSE",
-        m_max: int = None,
+        m_max: Union[None, int] = None,
     ) -> None:
         r"""Initialize a Lattice discrete distribution.
 
@@ -156,7 +157,7 @@ def __init__(
                 - If an `int` is passed in, use generating vector components at indices 0,...,`dimension`-1.
                 - If an `np.ndarray` is passed in, use generating vector components at these indices.
 
-            replications (int): Number of independent randomizations.
+            replications (Union[None, int]): Number of independent randomizations.
             seed (Union[None, int, np.random.SeedSequence]): Seed the random
                 number generator for reproducibility.
             randomize (str): Options are
@@ -178,7 +179,7 @@ def __init__(
 
             order (str): `'LINEAR'`, `'RADICAL INVERSE'`, or `'GRAY'` ordering.
                 See the doctest example above.
-            m_max (int): $2^{m_\mathrm{max}}$ is the maximum number of
+            m_max (Union[None, int]): $2^{m_\mathrm{max}}$ is the maximum number of
                 supported samples.
         """
         self.parameters = ["randomize", "gen_vec_source", "order", "n_limit"]
@@ -371,7 +372,7 @@ def _gen_block_linear(self, m_next, first=True):
         x = np.outer(y, self.gen_vec) % 1
         return x
 
-    def calculate_y(self, m_low, m_high, y):
+    def calculate_y(self, m_low: int, m_high: int, y: np.ndarray) -> np.ndarray:
         """Refine 1D interval midpoints from level `m_low` up to `m_high`.
 
         At each level, interleaves the current midpoints `y` with the new
diff --git a/qmcpy/discrete_distribution/mpmc/models.py b/qmcpy/discrete_distribution/mpmc/models.py
index 3f96d55e7..c88ff9111 100644
--- a/qmcpy/discrete_distribution/mpmc/models.py
+++ b/qmcpy/discrete_distribution/mpmc/models.py
@@ -17,7 +17,7 @@ class MPNN_layer(MessagePassing):
     `edge_index` graph built in `MPMC_net`) and updates its own features.
     """
 
-    def __init__(self, ninp, nhid):
+    def __init__(self, ninp, nhid) -> None:
         super(MPNN_layer, self).__init__()
         self.ninp = ninp
         self.nhid = nhid
@@ -36,7 +36,7 @@ def __init__(self, ninp, nhid):
                                           )
         self.norm = InstanceNorm(nhid)
 
-    def forward(self, x, edge_index, batch):
+    def forward(self, x: torch.Tensor, edge_index: torch.Tensor, batch: torch.Tensor) -> torch.Tensor:
         """Propagate messages over the graph and instance-normalize the result.
 
         Args:
@@ -51,7 +51,7 @@ def forward(self, x, edge_index, batch):
         x = self.norm(x, batch)
         return x
 
-    def message(self, x_i, x_j):
+    def message(self, x_i: torch.Tensor, x_j: torch.Tensor) -> torch.Tensor:
         """Compute the message sent from neighbor `x_j` to node `x_i`.
 
         Called internally by `MessagePassing.propagate`.
@@ -67,7 +67,7 @@ def message(self, x_i, x_j):
         message = self.message_net_2(message)
         return message
 
-    def update(self, message, x):
+    def update(self, message: torch.Tensor, x: torch.Tensor) -> torch.Tensor:
         """Combine a node's aggregated message with its own features.
 
         Called internally by `MessagePassing.propagate`.
@@ -95,7 +95,7 @@ class MPMC_net(nn.Module):
     minimize `loss_fn` evaluated on the resulting points.
     """
 
-    def __init__(self, dim, nhid, nlayers, nsamples, nbatch, radius, loss_fn, weights):
+    def __init__(self, dim, nhid, nlayers, nsamples, nbatch, radius, loss_fn, weights) -> None:
         super(MPMC_net, self).__init__()
         self.enc = nn.Linear(dim,nhid)
         self.convs = nn.ModuleList()
@@ -127,7 +127,7 @@ def __init__(self, dim, nhid, nlayers, nsamples, nbatch, radius, loss_fn, weight
         else:
             raise ValueError(f"Loss function DNE: {loss_fn}")
 
-    def forward(self):
+    def forward(self) -> tuple[torch.Tensor, torch.Tensor]:
         """Transform the stored random points and compute the discrepancy loss.
 
         Returns:
diff --git a/qmcpy/discrete_distribution/mpmc/mpmc.py b/qmcpy/discrete_distribution/mpmc/mpmc.py
index 99b173fb4..2dc32a2f1 100644
--- a/qmcpy/discrete_distribution/mpmc/mpmc.py
+++ b/qmcpy/discrete_distribution/mpmc/mpmc.py
@@ -1,3 +1,4 @@
+from typing import Union
 from types import SimpleNamespace
 from io import BytesIO
 import os
@@ -66,26 +67,69 @@ class MPMC(AbstractLDDiscreteDistribution):
 
     def __init__(
         self,
-        randomize='shift',
-        seed=None,
-        dimension=2,
-        replications=1,
-        d_max=None,
-        lr=1e-3,
-        nlayers=3,
-        weight_decay=1e-6,
-        nhid=32,
-        epochs=50_000,
-        start_reduce=40_000,
-        radius=0.35,
-        nbatch=1,
-        loss_fn='L2star',
-        weights=None,
-        use_pretrained=True,
-        pretrained_local_dir=None,
-        pretrained_base_url='https://github.com/QMCSoftware/LDData/tree/main/pregenerated_pointsets/mpmc',
-        prompt_on_missing=True,
+        randomize: str = 'shift',
+        seed: Union[None, int, np.random.SeedSequence] = None,
+        dimension: int = 2,
+        replications: int = 1,
+        d_max: Union[None, int] = None,
+        lr: float = 1e-3,
+        nlayers: int = 3,
+        weight_decay: float = 1e-6,
+        nhid: int = 32,
+        epochs: int = 50_000,
+        start_reduce: int = 40_000,
+        radius: float = 0.35,
+        nbatch: int = 1,
+        loss_fn: str = 'L2star',
+        weights: Union[None, list, np.ndarray, torch.Tensor] = None,
+        use_pretrained: bool = True,
+        pretrained_local_dir: Union[None, str] = None,
+        pretrained_base_url: str = 'https://github.com/QMCSoftware/LDData/tree/main/pregenerated_pointsets/mpmc',
+        prompt_on_missing: bool = True,
     ) -> None:
+        """Initialize an MPMC discrete distribution.
+
+        Args:
+            randomize (str): `'shift'`/`'true'` for a random shift, or
+                `'false'`/`'none'`/`'no'` for no randomization.
+            seed (Union[None, int, np.random.SeedSequence]): Seed the random
+                number generator for reproducibility.
+            dimension (int): Dimension of the generated pointsets.
+            replications (int): Number of independent pointsets to
+                generate. Ignored if `nbatch` is set.
+            d_max (Union[None, int]): Unused; kept for backward compatibility.
+                `self.d_max` always mirrors `dimension`.
+            lr (float): Learning rate for the MPMC network optimizer.
+            nlayers (int): Number of message-passing layers in the MPMC
+                network.
+            weight_decay (float): Weight decay (L2 regularization) for the
+                optimizer.
+            nhid (int): Hidden dimension of the MPMC network layers.
+            epochs (int): Number of training epochs.
+            start_reduce (int): Epoch at which learning-rate reduction
+                begins.
+            radius (float): Radius parameter for the discrepancy loss.
+            nbatch (int): Number of independent pointsets to train and
+                generate (overrides `replications` when not `None`).
+            loss_fn (str): Name of the discrepancy loss to train against; one
+                of the keys in `qmcpy.discrete_distribution.mpmc.utils`'s
+                discrepancy registry (e.g. `'L2star'`), optionally suffixed
+                `'_weighted'`.
+            weights (Union[None, list, np.ndarray, torch.Tensor]): Per-
+                coordinate weights, required when `loss_fn` names a weighted
+                discrepancy (or supplying them switches `loss_fn` to its
+                weighted variant automatically).
+            use_pretrained (bool): If `True`, load a pretrained pointset
+                generator instead of training a new one, when one is
+                available for the requested `dimension`/`nbatch`.
+            pretrained_local_dir (Union[None, str]): Local directory to search for (and
+                cache) pretrained generators. Defaults to a package cache
+                directory when `None`.
+            pretrained_base_url (str): Base URL to download pretrained
+                generators from when not already cached locally.
+            prompt_on_missing (bool): If `True`, prompt interactively before
+                training a new generator when no pretrained one is found.
+        """
         self.mimics = 'StdUniform'
         self.low_discrepancy = True
 
@@ -298,7 +342,13 @@ def _spawn(self, child_seed, dimension):
     # Training
     # --------------------------
     def _train(self, args: SimpleNamespace):
-        """
+        """Train an MPMC network and return its generated pointsets.
+
+        Args:
+            args (SimpleNamespace): Training configuration, carrying `dim`,
+                `nhid`, `nlayers`, `nsamples`, `nbatch`, `radius`, `loss_fn`,
+                `weights`, `lr`, `weight_decay`, `epochs`, and `start_reduce`.
+
         Returns:
             np.ndarray: shape `(nbatch, nsamples, dim)`
         """
diff --git a/qmcpy/fast_transform/ft.py b/qmcpy/fast_transform/ft.py
index 56b54a2e6..b29eaa7d2 100644
--- a/qmcpy/fast_transform/ft.py
+++ b/qmcpy/fast_transform/ft.py
@@ -3,7 +3,7 @@
 import itertools
 
 
-def fftbr(x: np.ndarray):
+def fftbr(x: np.ndarray) -> np.ndarray:
     r"""1 dimensional Bit-Reversed-Order (BRO) Fast Fourier Transform (FFT)
     along the last dimension. Requires the last dimension of x is already in
     BRO, so we can skip the first step of the decimation-in-time FFT. Requires
@@ -41,7 +41,7 @@ def fftbr(x: np.ndarray):
     return scipy.fft.fft(xr, norm="ortho")
 
 
-def ifftbr(x: np.ndarray):
+def ifftbr(x: np.ndarray) -> np.ndarray:
     r"""1 dimensional Bit-Reversed-Order (BRO) Inverse Fast Fourier Transform
     (IFFT) along the last dimension. Outputs an array in bit-reversed order, so
     we can skip the last step of the decimation-in-time IFFT. Requires the size
@@ -78,7 +78,7 @@ def ifftbr(x: np.ndarray):
     return xr
 
 
-def fwht(x: np.ndarray):
+def fwht(x: np.ndarray) -> np.ndarray:
     r"""1 dimensional Fast Walsh Hadamard Transform (FWHT) along the last
     dimension. Requires the size of the last dimension is a power of 2.
 
@@ -116,7 +116,7 @@ def fwht(x: np.ndarray):
     return y
 
 
-def omega_fwht(m: int):
+def omega_fwht(m: int) -> np.ndarray:
     r"""A useful when efficiently updating FWHT values after doubling the
     sample size.
 
@@ -143,7 +143,7 @@ def omega_fwht(m: int):
     return np.ones(2**m)
 
 
-def omega_fftbr(m: int):
+def omega_fftbr(m: int) -> np.ndarray:
     r"""A useful when efficiently updating FFT values after doubling the
     sample size.
 
diff --git a/qmcpy/fast_transform/ft_pytorch.py b/qmcpy/fast_transform/ft_pytorch.py
index d937ee53c..0819423ad 100644
--- a/qmcpy/fast_transform/ft_pytorch.py
+++ b/qmcpy/fast_transform/ft_pytorch.py
@@ -1,9 +1,10 @@
+from typing import Union
 import torch
 import numpy as np
 import itertools
 
 
-def fftbr_torch(x: torch.Tensor):
+def fftbr_torch(x: torch.Tensor) -> torch.Tensor:
     r"""Torch implementation of the 1 dimensional Bit-Reversed-Order (BRO)
     Fast Fourier Transform (FFT) along the last dimension. Requires the last
     dimension of x is already in BRO, so we can skip the first step of the
@@ -55,7 +56,7 @@ def fftbr_torch(x: torch.Tensor):
     return torch.fft.fft(xr, norm="ortho")
 
 
-def ifftbr_torch(x: torch.Tensor):
+def ifftbr_torch(x: torch.Tensor) -> torch.Tensor:
     r"""Torch implementation of the 1 dimensional Bit-Reversed-Order (BRO)
     Inverse Fast Fourier Transform (IFFT) along the last dimension. Outputs an
     array in bit-reversed order, so we can skip the last step of the
@@ -139,7 +140,7 @@ def backward(ctx, dx):
         return _fwht_torch(dx)
 
 
-def fwht_torch(x: torch.Tensor):
+def fwht_torch(x: torch.Tensor) -> torch.Tensor:
     r"""Torch implementation of the 1 dimensional Fast Walsh Hadamard
     Transform (FWHT) along the last dimension. Requires the size of the last
     dimension is a power of 2.
@@ -173,7 +174,7 @@ def fwht_torch(x: torch.Tensor):
     return _FWHTB2Ortho.apply(x)
 
 
-def omega_fwht_torch(m: int, device=None):
+def omega_fwht_torch(m: int, device: Union[None, torch.device] = None) -> np.ndarray:
     r"""Torch implementation useful when efficiently updating FWHT values
     after doubling the sample size.
 
@@ -193,6 +194,8 @@ def omega_fwht_torch(m: int, device=None):
 
     Args:
         m (int): Size $2^m$ output.
+        device (Union[None, torch.device]): Device to place the output tensor on.
+            Defaults to CPU.
 
     Returns:
         np.ndarray: $\left(1\right)_{k=0}^{2^m}$.
@@ -202,7 +205,7 @@ def omega_fwht_torch(m: int, device=None):
     return torch.ones(2**m, device=device)
 
 
-def omega_fftbr_torch(m: int, device=None):
+def omega_fftbr_torch(m: int, device: Union[None, torch.device] = None) -> np.ndarray:
     r"""Torch implementation useful when efficiently updating FFT values after
     doubling the sample size.
 
@@ -222,6 +225,8 @@ def omega_fftbr_torch(m: int, device=None):
 
     Args:
         m (int): Size $2^m$ output.
+        device (Union[None, torch.device]): Device to place the output tensor on.
+            Defaults to CPU.
 
     Returns:
         np.ndarray: $\left(e^{- \pi \mathrm{i} k / 2^m}\right)_{k=0}^{2^m}$.
diff --git a/qmcpy/fast_transform/ft_qmctoolscl.py b/qmcpy/fast_transform/ft_qmctoolscl.py
index 841e7b4e7..32e6a176e 100644
--- a/qmcpy/fast_transform/ft_qmctoolscl.py
+++ b/qmcpy/fast_transform/ft_qmctoolscl.py
@@ -20,7 +20,7 @@ def _parse_ft_input(x):
     return x, shape, d, n, n // 2
 
 
-def fftbr_qmctoolscl(x: np.ndarray):
+def fftbr_qmctoolscl(x: np.ndarray) -> np.ndarray:
     r"""QMCToolsCL implementation of the 1 dimensional Bit-Reversed-Order
     (BRO) Fast Fourier Transform (FFT) along the last dimension. Requires the
     last dimension of x is already in BRO, so we can skip the first step of the
@@ -55,7 +55,7 @@ def fftbr_qmctoolscl(x: np.ndarray):
     return xc.reshape(shape)
 
 
-def ifftbr_qmctoolscl(x: np.ndarray):
+def ifftbr_qmctoolscl(x: np.ndarray) -> np.ndarray:
     r"""QMCToolsCL implementation of the 1 dimensional Bit-Reversed-Order
     (BRO) Inverse Fast Fourier Transform (IFFT) along the last dimension.
     Outputs an array in bit-reversed order, so we can skip the last step of the
@@ -90,7 +90,7 @@ def ifftbr_qmctoolscl(x: np.ndarray):
     return xc.reshape(shape)
 
 
-def fwht_qmctoolscl(x: np.ndarray):
+def fwht_qmctoolscl(x: np.ndarray) -> np.ndarray:
     r"""QMCToolsCL implementation of the 1 dimensional Fast Walsh Hadamard
     Transform (FWHT) along the last dimension. Requires the size of the last
     dimension is a power of 2.
diff --git a/qmcpy/integrand/abstract_integrand.py b/qmcpy/integrand/abstract_integrand.py
index dc7d5328c..40e8a6a88 100644
--- a/qmcpy/integrand/abstract_integrand.py
+++ b/qmcpy/integrand/abstract_integrand.py
@@ -1,3 +1,4 @@
+from typing import Union
 from ..util import MethodImplementationError, _univ_repr, ParameterError
 from ..true_measure.abstract_true_measure import AbstractTrueMeasure
 from ..discrete_distribution.abstract_discrete_distribution import (
@@ -88,7 +89,7 @@ def __init__(self, dimension_indv: tuple, dimension_comb: tuple, parallel: int,
             )
         self.EPS = np.finfo(float).eps
 
-    def __call__(self, n=None, n_min=None, n_max=None, warn=True):
+    def __call__(self, n: Union[None, int] = None, n_min: Union[None, int] = None, n_max: Union[None, int] = None, warn: bool = True):
         r"""
         - If just `n` is supplied, generate samples from the sequence at indices 0,...,`n`-1.
         - If `n_min` and `n_max` are supplied, generate samples from the sequence at indices `n_min`,...,`n_max`-1.
@@ -109,8 +110,8 @@ def __call__(self, n=None, n_min=None, n_max=None, warn=True):
         return self.gen_samples(n=n, n_min=n_min, n_max=n_max, warn=warn)
 
     def gen_samples(
-        self, n=None, n_min=None, n_max=None, return_weights=False, warn=True
-    ):
+        self, n: Union[None, int] = None, n_min: Union[None, int] = None, n_max: Union[None, int] = None, return_weights: bool = False, warn: bool = True
+    ) -> np.ndarray:
         """Generate discrete distribution samples and evaluate the integrand at them.
 
         Args:
@@ -127,14 +128,14 @@ def gen_samples(
         y = self.f(x)
         return y
 
-    def g(self, t: np.ndarray, *args: tuple, **kwargs: dict):
+    def g(self, t: np.ndarray, *args: tuple, **kwargs: dict) -> np.ndarray:
         r"""*Abstract method* implementing the integrand as a function of the
         true measure.
 
         Args:
             t (np.ndarray): Inputs with shape `(*batch_shape, d)`.
-            args (tuple): positional arguments to `g`.
-            kwargs (dict): keyword arguments to `g`.
+            *args (tuple): positional arguments to `g`.
+            **kwargs (dict): keyword arguments to `g`.
 
                 Some algorithms will additionally try to pass in a
                 `compute_flags` keyword argument. This `np.ndarray` are flags
@@ -152,15 +153,15 @@ def g(self, t: np.ndarray, *args: tuple, **kwargs: dict):
         """
         raise MethodImplementationError(self, "g")
 
-    def f(self, x: np.ndarray, *args: tuple, **kwargs: dict):
+    def f(self, x: np.ndarray, *args: tuple, **kwargs: dict) -> np.ndarray:
         r"""Function to evaluate the transformed integrand as a function of
         the discrete distribution. Automatically applies the transformation
         determined by the true measure.
 
         Args:
             x (np.ndarray): Inputs with shape `(*batch_shape, d)`.
-            args (tuple): positional arguments to `g`.
-            kwargs (dict): keyword arguments to `g`.
+            *args (tuple): positional arguments to `g`.
+            **kwargs (dict): keyword arguments to `g`.
 
                 Some algorithms will additionally try to pass in a
                 `compute_flags` keyword argument. This `np.ndarray` are flags
@@ -323,7 +324,7 @@ def _g2(self, t, comb_args=((), {})):
                 raise e
         return y
 
-    def bound_fun(self, bound_low: np.ndarray, bound_high: np.ndarray):
+    def bound_fun(self, bound_low: np.ndarray, bound_high: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
         """Compute the bounds on the combined function based on bounds for
         the individual functions.
 
@@ -351,7 +352,7 @@ def bound_fun(self, bound_low: np.ndarray, bound_high: np.ndarray):
             )
         return bound_low, bound_high
 
-    def dependency(self, comb_flags: np.ndarray):
+    def dependency(self, comb_flags: np.ndarray) -> np.ndarray:
         """Takes a vector of indicators of weather of not the error bound is
         satisfied for combined integrands and returns flags for individual
         integrands.
@@ -377,7 +378,7 @@ def dependency(self, comb_flags: np.ndarray):
             else np.tile((comb_flags == False).any(), self.d_indv)
         )
 
-    def spawn(self, levels: np.ndarray):
+    def spawn(self, levels: np.ndarray) -> list:
         r"""Spawn new instances of the current integrand at different levels
         with new seeds. Used by multi-level QMC algorithms which require
         integrands at multiple levels.
@@ -403,7 +404,7 @@ def spawn(self, levels: np.ndarray):
             spawned_integrand[l] = self._spawn(level, tm_spawns[l])
         return spawned_integrand
 
-    def dimension_at_level(self, level: int):
+    def dimension_at_level(self, level: int) -> int:
         """*Abstract method* which returns the dimension of the generator
         required for a given level.
 
diff --git a/qmcpy/integrand/bayesian_lr_coeffs.py b/qmcpy/integrand/bayesian_lr_coeffs.py
index 6b2608ce9..c732cf357 100644
--- a/qmcpy/integrand/bayesian_lr_coeffs.py
+++ b/qmcpy/integrand/bayesian_lr_coeffs.py
@@ -1,3 +1,8 @@
+from ..discrete_distribution.abstract_discrete_distribution import (
+    AbstractDiscreteDistribution,
+)
+from ..true_measure.abstract_true_measure import AbstractTrueMeasure
+from typing import Union
 from .abstract_integrand import AbstractIntegrand
 from ..discrete_distribution import DigitalNetB2  #pylint: disable=unused-import
 from ..true_measure import Gaussian
@@ -33,7 +38,7 @@ class BayesianLRCoeffs(AbstractIntegrand):
     """
 
     def __init__(
-        self, sampler, feature_array: np.ndarray, response_vector: np.ndarray, prior_mean: np.ndarray = 0, prior_covariance: np.ndarray = 10
+        self, sampler: Union[AbstractDiscreteDistribution, AbstractTrueMeasure], feature_array: np.ndarray, response_vector: np.ndarray, prior_mean: Union[float, np.ndarray] = 0, prior_covariance: Union[float, np.ndarray] = 10
     ) -> None:
         r"""Initialize a BayesianLRCoeffs integrand.
 
@@ -48,12 +53,12 @@ def __init__(
                 dimension.
             response_vector (np.ndarray): Binary responses vector of length
                 $N$.
-            prior_mean (np.ndarray): Length $d$ vector of prior means, one for
+            prior_mean (Union[float, np.ndarray]): Length $d$ vector of prior means, one for
                 each coefficient.
 
                 - The first $d-1$ inputs correspond to the $d-1$ features.
                 - The last input corresponds to the intercept coefficient.
-            prior_covariance (np.ndarray): Prior covariance array with shape
+            prior_covariance (Union[float, np.ndarray]): Prior covariance array with shape
                 $(d,d)$ d x d where indexing is consistent with the prior mean.
         """
         self.prior_mean = prior_mean
@@ -84,7 +89,7 @@ def __init__(
             parallel=False,
         )
 
-    def g(self, x):
+    def g(self, x: np.ndarray) -> np.ndarray:
         """Evaluate the unnormalized posterior numerator and denominator.
 
         Args:
@@ -112,7 +117,7 @@ def _spawn(self, level, sampler):
             prior_covariance=self.prior_covariance,
         )
 
-    def bound_fun(self, bound_low, bound_high):
+    def bound_fun(self, bound_low: np.ndarray, bound_high: np.ndarray) -> tuple:
         """Combine numerator and denominator bounds into bounds on their ratio.
 
         Args:
@@ -145,7 +150,7 @@ def bound_fun(self, bound_low, bound_high):
         comb_bounds_low[violated], comb_bounds_high[violated] = -np.inf, np.inf
         return comb_bounds_low, comb_bounds_high
 
-    def dependency(self, comb_flags):
+    def dependency(self, comb_flags: np.ndarray) -> np.ndarray:
         """Map combined-output flags onto the individual outputs they require.
 
         Args:
diff --git a/qmcpy/integrand/box_integral.py b/qmcpy/integrand/box_integral.py
index 7ed6adf9e..e47c2d585 100644
--- a/qmcpy/integrand/box_integral.py
+++ b/qmcpy/integrand/box_integral.py
@@ -1,3 +1,8 @@
+from ..discrete_distribution.abstract_discrete_distribution import (
+    AbstractDiscreteDistribution,
+)
+from ..true_measure.abstract_true_measure import AbstractTrueMeasure
+from typing import Union
 from .abstract_integrand import AbstractIntegrand
 from ..discrete_distribution import DigitalNetB2
 from ..true_measure import Uniform
@@ -64,7 +69,7 @@ class BoxIntegral(AbstractIntegrand):
         [https://www.davidhbailey.com/dhbpapers/boxintegrals.pdf](https://www.davidhbailey.com/dhbpapers/boxintegrals.pdf)
     """
 
-    def __init__(self, sampler, s=1) -> None:
+    def __init__(self, sampler: Union[AbstractDiscreteDistribution, AbstractTrueMeasure], s: Union[float, np.ndarray] = 1) -> None:
         r"""Initialize a BoxIntegral integrand.
 
         Args:
@@ -87,7 +92,7 @@ def __init__(self, sampler, s=1) -> None:
             dimension_indv=self.s.shape, dimension_comb=self.s.shape, parallel=False
         )
 
-    def g(self, t, **kwargs):
+    def g(self, t: np.ndarray, **kwargs: dict) -> np.ndarray:
         r"""Evaluate the box integral function.
 
         Args:
diff --git a/qmcpy/integrand/custom_fun.py b/qmcpy/integrand/custom_fun.py
index cdaf08119..806247aba 100644
--- a/qmcpy/integrand/custom_fun.py
+++ b/qmcpy/integrand/custom_fun.py
@@ -1,3 +1,5 @@
+from ..true_measure.abstract_true_measure import AbstractTrueMeasure
+from typing import Union, Callable
 from .abstract_integrand import AbstractIntegrand
 from ..discrete_distribution import DigitalNetB2  #pylint: disable=unused-import
 from ..true_measure import Gaussian, Uniform  #pylint: disable=unused-import
@@ -88,15 +90,15 @@ class CustomFun(AbstractIntegrand):
         array([3.83e-03, -6.78e-03, -1.56e-03, -5.65e-04])
     """
 
-    def __init__(self, true_measure, g, dimension_indv: tuple = (), parallel: int = False) -> None:
+    def __init__(self, true_measure: AbstractTrueMeasure, g: Callable, dimension_indv: tuple = (), parallel: Union[bool, int] = False) -> None:
         """Initialize a CustomFun integrand.
 
         Args:
             true_measure (AbstractTrueMeasure): The true measure.
-            g (callable): A function handle.
+            g (Callable): A function handle.
             dimension_indv (tuple): Shape of individual solution outputs from
                 `g`.
-            parallel (int): Parallelization flag.
+            parallel (Union[bool, int]): Parallelization flag.
 
                 - When `parallel = 0` or `parallel = 1` then function evaluation is done in serial fashion.
                 - `parallel > 1` specifies the number of processes used by `multiprocessing.Pool` or `multiprocessing.pool.ThreadPool`.
@@ -118,7 +120,7 @@ def __init__(self, true_measure, g, dimension_indv: tuple = (), parallel: int =
             parallel=parallel,
         )
 
-    def g(self, t, *args, **kwargs):
+    def g(self, t: np.ndarray, *args: tuple, **kwargs: dict) -> np.ndarray:
         """Evaluate the user-supplied function.
 
         Args:
diff --git a/qmcpy/integrand/financial_option.py b/qmcpy/integrand/financial_option.py
index 44d0eef06..aa2ed048c 100644
--- a/qmcpy/integrand/financial_option.py
+++ b/qmcpy/integrand/financial_option.py
@@ -1,3 +1,8 @@
+from ..discrete_distribution.abstract_discrete_distribution import (
+    AbstractDiscreteDistribution,
+)
+from ..true_measure.abstract_true_measure import AbstractTrueMeasure
+from typing import Union
 from .abstract_integrand import AbstractIntegrand
 from ..discrete_distribution import DigitalNetB2
 from ..true_measure import GeometricBrownianMotion
@@ -238,7 +243,7 @@ class FinancialOption(AbstractIntegrand):
 
     def __init__(
         self,
-        sampler,
+        sampler: Union[AbstractDiscreteDistribution, AbstractTrueMeasure],
         option: str = "ASIAN",
         call_put: str = "CALL",
         volatility: float = 0.5,
@@ -247,8 +252,8 @@ def __init__(
         interest_rate: float = 0,
         t_final: float = 1,
         decomp_type: str = "PCA",
-        level=None,
-        d_coarsest=2,
+        level: Union[None, int] = None,
+        d_coarsest: Union[None, int] = 2,
         asian_mean: str = "ARITHMETIC",
         asian_mean_quadrature_rule: str = "TRAPEZOIDAL",
         barrier_in_out: str = "IN",
@@ -447,7 +452,7 @@ def __init__(
             dimension_indv=dim_shape, dimension_comb=dim_shape, parallel=False
         )
 
-    def g(self, t, **kwargs):
+    def g(self, t: np.ndarray, **kwargs: dict) -> np.ndarray:
         """Evaluate the discounted option payoff along each price path.
 
         Args:
@@ -472,7 +477,7 @@ def g(self, t, **kwargs):
             )
         return discounted_payoffs
 
-    def payoff_european_call(self, gbm):
+    def payoff_european_call(self, gbm: np.ndarray) -> np.ndarray:
         """European call payoff at maturity.
 
         Args:
@@ -483,7 +488,7 @@ def payoff_european_call(self, gbm):
         """
         return np.maximum(gbm[..., -1] - self.strike_price, 0)
 
-    def payoff_european_put(self, gbm):
+    def payoff_european_put(self, gbm: np.ndarray) -> np.ndarray:
         """European put payoff at maturity.
 
         Args:
@@ -494,7 +499,7 @@ def payoff_european_put(self, gbm):
         """
         return np.maximum(self.strike_price - gbm[..., -1], 0)
 
-    def payoff_asian_arithmetic_trap_call(self, gbm):
+    def payoff_asian_arithmetic_trap_call(self, gbm: np.ndarray) -> np.ndarray:
         """Asian arithmetic-mean call payoff, trapezoidal averaging.
 
         Args:
@@ -510,7 +515,7 @@ def payoff_asian_arithmetic_trap_call(self, gbm):
             0,
         )
 
-    def payoff_asian_arithmetic_trap_put(self, gbm):
+    def payoff_asian_arithmetic_trap_put(self, gbm: np.ndarray) -> np.ndarray:
         """Asian arithmetic-mean put payoff, trapezoidal averaging.
 
         Args:
@@ -526,7 +531,7 @@ def payoff_asian_arithmetic_trap_put(self, gbm):
             0,
         )
 
-    def payoff_asian_geometric_trap_call(self, gbm):
+    def payoff_asian_geometric_trap_call(self, gbm: np.ndarray) -> np.ndarray:
         """Asian geometric-mean call payoff, trapezoidal averaging.
 
         Args:
@@ -548,7 +553,7 @@ def payoff_asian_geometric_trap_call(self, gbm):
             0,
         )
 
-    def payoff_asian_geometric_trap_put(self, gbm):
+    def payoff_asian_geometric_trap_put(self, gbm: np.ndarray) -> np.ndarray:
         """Asian geometric-mean put payoff, trapezoidal averaging.
 
         Args:
@@ -570,7 +575,7 @@ def payoff_asian_geometric_trap_put(self, gbm):
             0,
         )
 
-    def payoff_asian_arithmetic_right_call(self, gbm):
+    def payoff_asian_arithmetic_right_call(self, gbm: np.ndarray) -> np.ndarray:
         """Asian arithmetic-mean call payoff, right-endpoint averaging.
 
         Args:
@@ -581,7 +586,7 @@ def payoff_asian_arithmetic_right_call(self, gbm):
         """
         return np.maximum(gbm.sum(-1) / gbm.shape[-1] - self.strike_price, 0)
 
-    def payoff_asian_arithmetic_right_put(self, gbm):
+    def payoff_asian_arithmetic_right_put(self, gbm: np.ndarray) -> np.ndarray:
         """Asian arithmetic-mean put payoff, right-endpoint averaging.
 
         Args:
@@ -592,7 +597,7 @@ def payoff_asian_arithmetic_right_put(self, gbm):
         """
         return np.maximum((self.strike_price - gbm.sum(-1)) / gbm.shape[-1], 0)
 
-    def payoff_asian_geometric_right_call(self, gbm):
+    def payoff_asian_geometric_right_call(self, gbm: np.ndarray) -> np.ndarray:
         """Asian geometric-mean call payoff, right-endpoint averaging.
 
         Args:
@@ -605,7 +610,7 @@ def payoff_asian_geometric_right_call(self, gbm):
             np.exp(np.log(gbm).sum(-1) / gbm.shape[-1]) - self.strike_price, 0
         )
 
-    def payoff_asian_geometric_right_put(self, gbm):
+    def payoff_asian_geometric_right_put(self, gbm: np.ndarray) -> np.ndarray:
         """Asian geometric-mean put payoff, right-endpoint averaging.
 
         Args:
@@ -618,7 +623,7 @@ def payoff_asian_geometric_right_put(self, gbm):
             self.strike_price - np.exp(np.log(gbm).sum(-1) / gbm.shape[-1]), 0
         )
 
-    def payoff_barrier_in_up_call(self, gbm):
+    def payoff_barrier_in_up_call(self, gbm: np.ndarray) -> np.ndarray:
         """Up-and-in barrier call payoff; pays only if the barrier is reached from below.
 
         Args:
@@ -633,7 +638,7 @@ def payoff_barrier_in_up_call(self, gbm):
         v[flag] = np.maximum(v[flag] - self.strike_price, 0)
         return v
 
-    def payoff_barrier_out_up_call(self, gbm):
+    def payoff_barrier_out_up_call(self, gbm: np.ndarray) -> np.ndarray:
         """Up-and-out barrier call payoff; pays only if the barrier is never reached.
 
         Args:
@@ -648,7 +653,7 @@ def payoff_barrier_out_up_call(self, gbm):
         v[flag] = np.maximum(v[flag] - self.strike_price, 0)
         return v
 
-    def payoff_barrier_in_down_call(self, gbm):
+    def payoff_barrier_in_down_call(self, gbm: np.ndarray) -> np.ndarray:
         """Down-and-in barrier call payoff; pays only if the barrier is reached from above.
 
         Args:
@@ -663,7 +668,7 @@ def payoff_barrier_in_down_call(self, gbm):
         v[flag] = np.maximum(v[flag] - self.strike_price, 0)
         return v
 
-    def payoff_barrier_out_down_call(self, gbm):
+    def payoff_barrier_out_down_call(self, gbm: np.ndarray) -> np.ndarray:
         """Down-and-out barrier call payoff; pays only if the barrier is never reached.
 
         Args:
@@ -678,7 +683,7 @@ def payoff_barrier_out_down_call(self, gbm):
         v[flag] = np.maximum(v[flag] - self.strike_price, 0)
         return v
 
-    def payoff_barrier_in_up_put(self, gbm):
+    def payoff_barrier_in_up_put(self, gbm: np.ndarray) -> np.ndarray:
         """Up-and-in barrier put payoff; pays only if the barrier is reached from below.
 
         Args:
@@ -693,7 +698,7 @@ def payoff_barrier_in_up_put(self, gbm):
         v[flag] = np.maximum(self.strike_price - v[flag], 0)
         return v
 
-    def payoff_barrier_out_up_put(self, gbm):
+    def payoff_barrier_out_up_put(self, gbm: np.ndarray) -> np.ndarray:
         """Up-and-out barrier put payoff; pays only if the barrier is never reached.
 
         Args:
@@ -708,7 +713,7 @@ def payoff_barrier_out_up_put(self, gbm):
         v[flag] = np.maximum(self.strike_price - v[flag], 0)
         return v
 
-    def payoff_barrier_in_down_put(self, gbm):
+    def payoff_barrier_in_down_put(self, gbm: np.ndarray) -> np.ndarray:
         """Down-and-in barrier put payoff; pays only if the barrier is reached from above.
 
         Args:
@@ -723,7 +728,7 @@ def payoff_barrier_in_down_put(self, gbm):
         v[flag] = np.maximum(self.strike_price - v[flag], 0)
         return v
 
-    def payoff_barrier_out_down_put(self, gbm):
+    def payoff_barrier_out_down_put(self, gbm: np.ndarray) -> np.ndarray:
         """Down-and-out barrier put payoff; pays only if the barrier is never reached.
 
         Args:
@@ -738,7 +743,7 @@ def payoff_barrier_out_down_put(self, gbm):
         v[flag] = np.maximum(self.strike_price - v[flag], 0)
         return v
 
-    def payoff_lookback_call(self, gbm):  # include start price in min
+    def payoff_lookback_call(self, gbm: np.ndarray) -> np.ndarray:  # include start price in min
         """Lookback call payoff: final price less the running minimum, including the start price.
 
         Args:
@@ -750,7 +755,7 @@ def payoff_lookback_call(self, gbm):  # include start price in min
         min_path = np.minimum(gbm.min(-1), self.start_price)
         return gbm[..., -1] - min_path
 
-    def payoff_lookback_put(self, gbm):  # include start price in max
+    def payoff_lookback_put(self, gbm: np.ndarray) -> np.ndarray:  # include start price in max
         """Lookback put payoff: the running maximum, including the start price, less the final price.
 
         Args:
@@ -762,7 +767,7 @@ def payoff_lookback_put(self, gbm):  # include start price in max
         max_path = np.maximum(gbm.max(-1), self.start_price)
         return max_path - gbm[..., -1]
 
-    def payoff_digital_call(self, gbm):
+    def payoff_digital_call(self, gbm: np.ndarray) -> np.ndarray:
         """Digital call payoff: a fixed payout when the final price is at or above the strike.
 
         Args:
@@ -773,7 +778,7 @@ def payoff_digital_call(self, gbm):
         """
         return np.where(gbm[..., -1] >= self.strike_price, self.digital_payout, 0)
 
-    def payoff_digital_put(self, gbm):
+    def payoff_digital_put(self, gbm: np.ndarray) -> np.ndarray:
         """Digital put payoff: a fixed payout when the final price is at or below the strike.
 
         Args:
@@ -784,7 +789,7 @@ def payoff_digital_put(self, gbm):
         """
         return np.where(gbm[..., -1] <= self.strike_price, self.digital_payout, 0)
 
-    def get_exact_value(self):
+    def get_exact_value(self) -> float:
         """Compute the exact analytic fair price of the option in finite
         dimensions. Supports
 
@@ -844,7 +849,7 @@ def get_exact_value(self):
             )
         return fp
 
-    def get_exact_value_inf_dim(self):
+    def get_exact_value_inf_dim(self) -> float:
         r"""Get the exact analytic fair price of the option in infinite
         dimensions. Supports
 
@@ -877,7 +882,7 @@ def get_exact_value_inf_dim(self):
             )
         return val
 
-    def dimension_at_level(self, level):
+    def dimension_at_level(self, level: int) -> int:
         """Return the number of monitoring times used at a multilevel level.
 
         Args:
diff --git a/qmcpy/integrand/fourbranch2d.py b/qmcpy/integrand/fourbranch2d.py
index 768613be8..18f77094c 100644
--- a/qmcpy/integrand/fourbranch2d.py
+++ b/qmcpy/integrand/fourbranch2d.py
@@ -1,3 +1,8 @@
+from ..discrete_distribution.abstract_discrete_distribution import (
+    AbstractDiscreteDistribution,
+)
+from ..true_measure.abstract_true_measure import AbstractTrueMeasure
+from typing import Union
 import numpy as np
 from .abstract_integrand import AbstractIntegrand
 from ..true_measure import Uniform
@@ -44,7 +49,7 @@ class FourBranch2d(AbstractIntegrand):
         -2.5042
     """
 
-    def __init__(self, sampler) -> None:
+    def __init__(self, sampler: Union[AbstractDiscreteDistribution, AbstractTrueMeasure]) -> None:
         r"""Initialize a FourBranch2d integrand.
 
         Args:
@@ -62,7 +67,7 @@ def __init__(self, sampler) -> None:
             dimension_indv=(), dimension_comb=(), parallel=False
         )
 
-    def g(self, t):
+    def g(self, t: np.ndarray) -> np.ndarray:
         """Evaluate the four-branch function.
 
         Args:
diff --git a/qmcpy/integrand/genz.py b/qmcpy/integrand/genz.py
index 2345335c5..9898442e2 100644
--- a/qmcpy/integrand/genz.py
+++ b/qmcpy/integrand/genz.py
@@ -1,3 +1,8 @@
+from ..discrete_distribution.abstract_discrete_distribution import (
+    AbstractDiscreteDistribution,
+)
+from ..true_measure.abstract_true_measure import AbstractTrueMeasure
+from typing import Union
 from .abstract_integrand import AbstractIntegrand
 from ..discrete_distribution import DigitalNetB2
 from ..true_measure import Uniform
@@ -54,7 +59,7 @@ class Genz(AbstractIntegrand):
         0.7200
     """
 
-    def __init__(self, sampler, kind_func: str = "OSCILLATORY", kind_coeff: int = 1) -> None:
+    def __init__(self, sampler: Union[AbstractDiscreteDistribution, AbstractTrueMeasure], kind_func: str = "OSCILLATORY", kind_coeff: int = 1) -> None:
         """Initialize a Genz integrand.
 
         Args:
@@ -98,7 +103,7 @@ def __init__(self, sampler, kind_func: str = "OSCILLATORY", kind_coeff: int = 1)
         self.parameters = ["kind_func", "kind_coeff"]
         super(Genz, self).__init__(dimension_indv=(), dimension_comb=(), parallel=False)
 
-    def g_oscillatory(self, t):
+    def g_oscillatory(self, t: np.ndarray) -> np.ndarray:
         r"""Evaluate the oscillatory Genz function.
 
         Args:
@@ -109,7 +114,7 @@ def g_oscillatory(self, t):
         """
         return np.cos(-(self.c * t).sum(-1))
 
-    def g_corner_peak(self, t):
+    def g_corner_peak(self, t: np.ndarray) -> np.ndarray:
         r"""Evaluate the corner-peak Genz function.
 
         Args:
diff --git a/qmcpy/integrand/hartmann6d.py b/qmcpy/integrand/hartmann6d.py
index 18bf810da..ba304836a 100644
--- a/qmcpy/integrand/hartmann6d.py
+++ b/qmcpy/integrand/hartmann6d.py
@@ -1,3 +1,8 @@
+from ..discrete_distribution.abstract_discrete_distribution import (
+    AbstractDiscreteDistribution,
+)
+from ..true_measure.abstract_true_measure import AbstractTrueMeasure
+from typing import Union
 import numpy as np
 from .abstract_integrand import AbstractIntegrand
 from ..true_measure import Uniform
@@ -44,7 +49,7 @@ class Hartmann6d(AbstractIntegrand):
         -0.2599
     """
 
-    def __init__(self, sampler) -> None:
+    def __init__(self, sampler: Union[AbstractDiscreteDistribution, AbstractTrueMeasure]) -> None:
         r"""Initialize a Hartmann6d integrand.
 
         Args:
@@ -65,7 +70,7 @@ def __init__(self, sampler) -> None:
 
         self.ah = AugmentedHartmann(negate=False)
 
-    def g(self, t):
+    def g(self, t: np.ndarray) -> np.ndarray:
         """Evaluate the six-dimensional augmented Hartmann function.
 
         Args:
diff --git a/qmcpy/integrand/ishigami.py b/qmcpy/integrand/ishigami.py
index 0334b627d..04a9d8b38 100644
--- a/qmcpy/integrand/ishigami.py
+++ b/qmcpy/integrand/ishigami.py
@@ -1,3 +1,8 @@
+from ..discrete_distribution.abstract_discrete_distribution import (
+    AbstractDiscreteDistribution,
+)
+from ..true_measure.abstract_true_measure import AbstractTrueMeasure
+from typing import Union
 import numpy as np
 from .abstract_integrand import AbstractIntegrand
 from ..discrete_distribution import DigitalNetB2
@@ -53,7 +58,7 @@ class Ishigami(AbstractIntegrand):
         Proceedings, First International Symposium on (pp. 398-403). IEEE.
     """
 
-    def __init__(self, sampler, a: float = 7, b: float = 0.1) -> None:
+    def __init__(self, sampler: Union[AbstractDiscreteDistribution, AbstractTrueMeasure], a: float = 7, b: float = 0.1) -> None:
         r"""Initialize an Ishigami integrand.
 
         Args:
@@ -75,7 +80,7 @@ def __init__(self, sampler, a: float = 7, b: float = 0.1) -> None:
             dimension_indv=(), dimension_comb=(), parallel=False
         )
 
-    def g(self, t):
+    def g(self, t: np.ndarray) -> np.ndarray:
         r"""Evaluate the Ishigami function.
 
         Args:
diff --git a/qmcpy/integrand/keister.py b/qmcpy/integrand/keister.py
index 6036ee8be..d3ae71f13 100644
--- a/qmcpy/integrand/keister.py
+++ b/qmcpy/integrand/keister.py
@@ -1,3 +1,8 @@
+from ..discrete_distribution.abstract_discrete_distribution import (
+    AbstractDiscreteDistribution,
+)
+from ..true_measure.abstract_true_measure import AbstractTrueMeasure
+from typing import Union
 from .abstract_integrand import AbstractIntegrand
 from ..discrete_distribution import DigitalNetB2
 from ..true_measure import Gaussian
@@ -44,7 +49,7 @@ class Keister(AbstractIntegrand):
         Computers in Physics, 10, pp. 119-122, 1996.
     """
 
-    def __init__(self, sampler) -> None:
+    def __init__(self, sampler: Union[AbstractDiscreteDistribution, AbstractTrueMeasure]) -> None:
         r"""Initialize a Keister integrand.
 
         Args:
@@ -60,7 +65,7 @@ def __init__(self, sampler) -> None:
             dimension_indv=(), dimension_comb=(), parallel=False
         )
 
-    def g(self, t):
+    def g(self, t: np.ndarray) -> np.ndarray:
         r"""Evaluate the Keister function.
 
         Args:
@@ -78,7 +83,7 @@ def _spawn(self, level, sampler):
         return Keister(sampler=sampler)
 
     @classmethod
-    def get_exact_value(cls, d: int):
+    def get_exact_value(cls, d: int) -> float:
         """Compute the exact analytic value of the Keister integral with
         dimension $d$.
 
@@ -101,7 +106,7 @@ def get_exact_value(cls, d: int):
         I = (2 * (np.pi ** (d / 2)) / gamma(d / 2)) * cosinteg[d - 1]
         return I
 
-    def exact_integ(self, *args, **kwargs):
+    def exact_integ(self, *args: tuple, **kwargs: dict) -> float:
         """Return the exact value of the Keister integral.
 
         Deprecated alias for :meth:`get_exact_value`.
diff --git a/qmcpy/integrand/linear0.py b/qmcpy/integrand/linear0.py
index 135fa4a60..640e39b0f 100644
--- a/qmcpy/integrand/linear0.py
+++ b/qmcpy/integrand/linear0.py
@@ -1,3 +1,9 @@
+from ..discrete_distribution.abstract_discrete_distribution import (
+    AbstractDiscreteDistribution,
+)
+from ..true_measure.abstract_true_measure import AbstractTrueMeasure
+from typing import Union
+import numpy as np
 from .abstract_integrand import AbstractIntegrand
 from ..discrete_distribution import DigitalNetB2
 from ..true_measure import Uniform
@@ -28,7 +34,7 @@ class Linear0(AbstractIntegrand):
         -9.8203e-05
     """
 
-    def __init__(self, sampler) -> None:
+    def __init__(self, sampler: Union[AbstractDiscreteDistribution, AbstractTrueMeasure]) -> None:
         r"""Initialize a Linear0 integrand.
 
         Args:
@@ -44,7 +50,7 @@ def __init__(self, sampler) -> None:
             dimension_indv=(), dimension_comb=(), parallel=False
         )
 
-    def g(self, t):
+    def g(self, t: np.ndarray) -> np.ndarray:
         """Evaluate the centered linear function.
 
         Args:
diff --git a/qmcpy/integrand/multimodal2d.py b/qmcpy/integrand/multimodal2d.py
index ced36790c..eb8e6c7f4 100644
--- a/qmcpy/integrand/multimodal2d.py
+++ b/qmcpy/integrand/multimodal2d.py
@@ -1,3 +1,8 @@
+from ..discrete_distribution.abstract_discrete_distribution import (
+    AbstractDiscreteDistribution,
+)
+from ..true_measure.abstract_true_measure import AbstractTrueMeasure
+from typing import Union
 import numpy as np
 from .abstract_integrand import AbstractIntegrand
 from ..true_measure import Uniform
@@ -41,7 +46,7 @@ class Multimodal2d(AbstractIntegrand):
         -0.7366
     """
 
-    def __init__(self, sampler) -> None:
+    def __init__(self, sampler: Union[AbstractDiscreteDistribution, AbstractTrueMeasure]) -> None:
         r"""Initialize a Multimodal2d integrand.
 
         Args:
@@ -61,7 +66,7 @@ def __init__(self, sampler) -> None:
             dimension_indv=(), dimension_comb=(), parallel=False
         )
 
-    def g(self, t):
+    def g(self, t: np.ndarray) -> np.ndarray:
         """Evaluate the two-dimensional multimodal function.
 
         Args:
diff --git a/qmcpy/integrand/sensitivity_indices.py b/qmcpy/integrand/sensitivity_indices.py
index 11020a68d..636c39a37 100644
--- a/qmcpy/integrand/sensitivity_indices.py
+++ b/qmcpy/integrand/sensitivity_indices.py
@@ -1,3 +1,4 @@
+from typing import Union
 from .abstract_integrand import AbstractIntegrand
 from .keister import Keister
 from .box_integral import BoxIntegral
@@ -110,13 +111,13 @@ class SensitivityIndices(AbstractIntegrand):
         [https://artowen.su.domains/mc/A-anova.pdf](https://artowen.su.domains/mc/A-anova.pdf).
     """
 
-    def __init__(self, integrand: AbstractIntegrand, indices: np.ndarray = "singletons") -> None:
+    def __init__(self, integrand: AbstractIntegrand, indices: Union[str, np.ndarray] = "singletons") -> None:
         r"""Initialize a SensitivityIndices integrand.
 
         Args:
             integrand (AbstractIntegrand): Integrand to find sensitivity
                 indices of.
-            indices (np.ndarray): Bool array with shape $(\dots,d)$ where each
+            indices (Union[str, np.ndarray]): Bool array with shape $(\dots,d)$ where each
                 length $d$ vector item indicates which dimensions are active in
                 the subset.
 
@@ -166,7 +167,7 @@ def __init__(self, integrand: AbstractIntegrand, indices: np.ndarray = "singleto
         )
         self.d = 2 * self.dtilde
 
-    def f(self, x, *args, **kwargs):
+    def f(self, x: np.ndarray, *args: tuple, **kwargs: dict) -> np.ndarray:
         r"""Evaluate the numerator and moment terms needed for the sensitivity indices.
 
         Args:
@@ -219,7 +220,7 @@ def _spawn(self, level, sampler):
         new_integrand = self.integrand.spawn(level, sampler)
         return SensitivityIndices(integrand=new_integrand, indices=self.indices)
 
-    def bound_fun(self, bound_low, bound_high):
+    def bound_fun(self, bound_low: np.ndarray, bound_high: np.ndarray) -> tuple:
         r"""Combine bounds on the moment terms into bounds on the sensitivity indices.
 
         Args:
@@ -248,7 +249,7 @@ def bound_fun(self, bound_low, bound_high):
         comb_bounds_low[violated], comb_bounds_high[violated] = 0, 1
         return comb_bounds_low, comb_bounds_high
 
-    def dependency(self, comb_flags):
+    def dependency(self, comb_flags: np.ndarray) -> np.ndarray:
         """Map combined-output flags onto the individual outputs they require.
 
         Args:
diff --git a/qmcpy/integrand/sin1d.py b/qmcpy/integrand/sin1d.py
index c3328e06b..8854dfe6a 100644
--- a/qmcpy/integrand/sin1d.py
+++ b/qmcpy/integrand/sin1d.py
@@ -1,3 +1,8 @@
+from ..discrete_distribution.abstract_discrete_distribution import (
+    AbstractDiscreteDistribution,
+)
+from ..true_measure.abstract_true_measure import AbstractTrueMeasure
+from typing import Union
 import numpy as np
 from .abstract_integrand import AbstractIntegrand
 from ..true_measure import Uniform
@@ -39,7 +44,7 @@ class Sin1d(AbstractIntegrand):
         7.0800e-04
     """
 
-    def __init__(self, sampler, k: float = 1) -> None:
+    def __init__(self, sampler: Union[AbstractDiscreteDistribution, AbstractTrueMeasure], k: float = 1) -> None:
         r"""Initialize a Sin1d integrand.
 
         Args:
@@ -62,7 +67,7 @@ def __init__(self, sampler, k: float = 1) -> None:
             dimension_indv=(), dimension_comb=(), parallel=False
         )
 
-    def g(self, t):
+    def g(self, t: np.ndarray) -> np.ndarray:
         r"""Evaluate the one-dimensional sine function.
 
         Args:
diff --git a/qmcpy/integrand/umbridge_wrapper.py b/qmcpy/integrand/umbridge_wrapper.py
index a2353b699..425047ad2 100644
--- a/qmcpy/integrand/umbridge_wrapper.py
+++ b/qmcpy/integrand/umbridge_wrapper.py
@@ -1,3 +1,7 @@
+from __future__ import annotations
+
+from ..true_measure.abstract_true_measure import AbstractTrueMeasure
+from typing import TYPE_CHECKING, Union
 from .abstract_integrand import AbstractIntegrand
 from ..discrete_distribution import DigitalNetB2
 from ..true_measure import Uniform
@@ -5,6 +9,9 @@
 import numpy as np
 import os
 
+if TYPE_CHECKING:
+    import umbridge
+
 
 class UMBridgeWrapper(AbstractIntegrand):
     """Wrapper around a
@@ -66,15 +73,15 @@ class UMBridgeWrapper(AbstractIntegrand):
         [['-1.59e-08', '1.49e-04', '1.49e-04'], ['8.20e-06', '-1.38e-04'], ['-8.14e-06']]
     """
 
-    def __init__(self, true_measure, model, config: dict = None, parallel: int = False) -> None:
+    def __init__(self, true_measure: AbstractTrueMeasure, model: umbridge.HTTPModel, config: Union[None, dict] = None, parallel: Union[bool, int] = False) -> None:
         """Initialize a UMBridgeWrapper integrand.
 
         Args:
             true_measure (AbstractTrueMeasure): The true measure.
             model (umbridge.HTTPModel): A `UM-Bridge` model.
-            config (dict): Configuration keyword argument to
+            config (Union[None, dict]): Configuration keyword argument to
                 `umbridge.HTTPModel(url,name).__call__`.
-            parallel (int): Parallelization flag.
+            parallel (Union[bool, int]): Parallelization flag.
 
                 - When `parallel = 0` or `parallel = 1` then function evaluation is done in serial fashion.
                 - `parallel > 1` specifies the number of processes used by `multiprocessing.Pool` or `multiprocessing.pool.ThreadPool`.
@@ -119,7 +126,7 @@ def __init__(self, true_measure, model, config: dict = None, parallel: int = Fal
             threadpool=True,
         )
 
-    def g(self, t, **kwargs):
+    def g(self, t: np.ndarray, **kwargs: dict) -> np.ndarray:
         """Evaluate the wrapped UM-Bridge model at each point.
 
         Args:
@@ -153,7 +160,7 @@ def _spawn(self, _level, _sampler):
             parallel=self.parallel,
         )
 
-    def to_umbridge_out_sizes(self, x: np.ndarray):
+    def to_umbridge_out_sizes(self, x: np.ndarray) -> list:
         """Convert a data attribute to `UM-Bridge` output sized list of
         lists.
 
diff --git a/qmcpy/kernel/abstract_kernel.py b/qmcpy/kernel/abstract_kernel.py
index f004d2e10..62a1a0773 100644
--- a/qmcpy/kernel/abstract_kernel.py
+++ b/qmcpy/kernel/abstract_kernel.py
@@ -1,3 +1,9 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Union, Tuple, Callable
+if TYPE_CHECKING:
+    import torch
+
 from ..util import MethodImplementationError
 import numpy as np
 from ..util.transforms import (
@@ -87,7 +93,7 @@ def batch_params(self):
         """
         return {pname: getattr(self, pname) for pname in self.batch_param_names}
 
-    def get_batch_params(self, ndim):
+    def get_batch_params(self, ndim: int) -> dict:
         """Return `batch_params` with each value reshaped to broadcast against `ndim` extra dimensions.
 
         Args:
@@ -101,7 +107,7 @@ def get_batch_params(self, ndim):
             for pname, batch_param in self.batch_params.items()
         }
 
-    def __call__(self, x0, x1, beta0=None, beta1=None, c=None, **kwargs):
+    def __call__(self, x0, x1, beta0=None, beta1=None, c=None, **kwargs: dict):
         r"""Evaluate the kernel with (optional) partial derivatives
 
         $$\sum_{\ell=1}^p c_{\ell}
@@ -122,7 +128,7 @@ def __call__(self, x0, x1, beta0=None, beta1=None, c=None, **kwargs):
                 $\boldsymbol{\beta}_1$.
             c (Union[np.ndarray, torch.Tensor]): Shape `c.shape=(p,)`
                 coefficients of derivatives.
-            kwargs (dict): keyword arguments to parsed call
+            **kwargs (dict): keyword arguments to parsed call
         Returns:
             Union[np.ndarray, torch.Tensor]: Shape `y.shape=(x0+x1).shape[:-1]` kernel evaluations.
         """
@@ -301,7 +307,7 @@ def parsed___call__(self, *args, **kwargs):
         """
         raise MethodImplementationError(self, "parsed___call__")
 
-    def single_integral_01d(self, x):
+    def single_integral_01d(self, x: Union[np.ndarray, torch.Tensor]) -> Union[np.ndarray, torch.Tensor]:
         r"""Evaluate the integral of the kernel over the unit cube
 
         $$\tilde{K}(\boldsymbol{x}) = \int_{[0,1]^d}
@@ -337,7 +343,7 @@ def parsed_single_integral_01d(self, x, batch_params):
         """
         raise MethodImplementationError(self, "parsed_single_integral_01d")
 
-    def double_integral_01d(self):
+    def double_integral_01d(self) -> "Union[np.ndarray, torch.Tensor]":
         r"""Evaluate the integral of the kernel over the unit cube
 
         $$\tilde{K} = \int_{[0,1]^d} \int_{[0,1]^d}
@@ -349,7 +355,7 @@ def double_integral_01d(self):
         """
         raise MethodImplementationError(self, "double_integral_01d")
 
-    def rel_pairwise_dist_func(self, x0, x1, lengthscales):
+    def rel_pairwise_dist_func(self, x0: Union[np.ndarray, torch.Tensor], x1: Union[np.ndarray, torch.Tensor], lengthscales: Union[np.ndarray, torch.Tensor]) -> Union[np.ndarray, torch.Tensor]:
         r"""Lengthscale-normalized pairwise distance $\lVert x_0-x_1\rVert / (\sqrt{2}\boldsymbol{\gamma})$.
 
         A common building block for stationary/RBF-style kernels.
@@ -366,14 +372,14 @@ def rel_pairwise_dist_func(self, x0, x1, lengthscales):
 
     def parse_assign_param(
         self,
-        pname,
-        param,
-        shape_param,
-        requires_grad_param,
-        tfs_param,
-        endsize_ops,
-        constraints,
-    ):
+        pname: str,
+        param: Union[float, np.ndarray, torch.Tensor],
+        shape_param: list,
+        requires_grad_param: bool,
+        tfs_param: Tuple[Callable, Callable],
+        endsize_ops: list,
+        constraints: list,
+    ) -> Union[np.ndarray, torch.Tensor]:
         """Validate, transform, and store a kernel hyperparameter.
 
         Thin wrapper around `qmcpy.util.transforms.parse_assign_param` that
@@ -384,7 +390,7 @@ def parse_assign_param(
             param (Union[float, np.ndarray, torch.Tensor]): The raw user-supplied parameter value.
             shape_param (list): Shape to broadcast `param` to when it is scalar.
             requires_grad_param (bool): If `True` and `torchify`, set `requires_grad=True`.
-            tfs_param (Tuple[callable, callable]): `(to_raw, from_raw)` transform pair.
+            tfs_param (Tuple[Callable, Callable]): `(to_raw, from_raw)` transform pair.
             endsize_ops (list): Allowed sizes for the parameter's trailing dimension.
             constraints (list): Named constraints to enforce (e.g. `["POSITIVE"]`).
 
@@ -416,33 +422,33 @@ class AbstractKernelScaleLengthscales(AbstractKernel):
     def __init__(
         self,
         d: int,
-        scale=1.0,
-        lengthscales=1.0,
-        shape_scale: list = None,
-        shape_lengthscales: list = None,
-        tfs_scale=(tf_exp_eps_inv, tf_exp_eps),
-        tfs_lengthscales=(tf_exp_eps_inv, tf_exp_eps),
+        scale: Union[float, np.ndarray, torch.Tensor] = 1.0,
+        lengthscales: Union[float, np.ndarray, torch.Tensor] = 1.0,
+        shape_scale: Union[None, list] = None,
+        shape_lengthscales: Union[None, list] = None,
+        tfs_scale: Tuple[Callable, Callable] = (tf_exp_eps_inv, tf_exp_eps),
+        tfs_lengthscales: Tuple[Callable, Callable] = (tf_exp_eps_inv, tf_exp_eps),
         torchify: bool = False,
         requires_grad_scale: bool = True,
         requires_grad_lengthscales: bool = True,
-        device="cpu",
+        device: Union[str, torch.device] = "cpu",
         compile_call: bool = False,
-        compile_call_kwargs: dict = None,
+        compile_call_kwargs: Union[None, dict] = None,
     ) -> None:
         r"""Initialize an AbstractKernelScaleLengthscales kernel.
 
         Args:
             d (int): Dimension.
-            scale (Union[np.ndarray, torch.Tensor]): Scaling factor $S$.
-            lengthscales (Union[np.ndarray, torch.Tensor]): Lengthscales
+            scale (Union[float, np.ndarray, torch.Tensor]): Scaling factor $S$.
+            lengthscales (Union[float, np.ndarray, torch.Tensor]): Lengthscales
                 $\boldsymbol{\gamma}$.
-            shape_scale (list): Shape of `scale` when `np.isscalar(scale)`.
-            shape_lengthscales (list): Shape of `lengthscales` when
+            shape_scale (Union[None, list]): Shape of `scale` when `np.isscalar(scale)`.
+            shape_lengthscales (Union[None, list]): Shape of `lengthscales` when
                 `np.isscalar(lengthscales)`
-            tfs_scale (Tuple[callable,callable]): The first argument transforms
+            tfs_scale (Tuple[Callable,Callable]): The first argument transforms
                 to the raw value to be optimized; the second applies the
                 inverse transform.
-            tfs_lengthscales (Tuple[callable,callable]): The first argument
+            tfs_lengthscales (Tuple[Callable,Callable]): The first argument
                 transforms to the raw value to be optimized; the second applies
                 the inverse transform.
             torchify (bool): If `True`, use the `torch` backend. Set to `True`
@@ -452,10 +458,10 @@ def __init__(
                 `requires_grad=True` for `scale`.
             requires_grad_lengthscales (bool): If `True` and `torchify`, set
                 `requires_grad=True` for `lengthscales`.
-            device (torch.device): If `torchify`, put things onto this device.
+            device (Union[str, torch.device]): If `torchify`, put things onto this device.
             compile_call (bool): If `True`, `torch.compile` the
                 `parsed___call__` method.
-            compile_call_kwargs (dict): When `compile_call` is `True`, pass
+            compile_call_kwargs (Union[None, dict]): When `compile_call` is `True`, pass
                 these keyword arguments to `torch.compile`.
         """
         if shape_scale is None:
diff --git a/qmcpy/kernel/common_kernels.py b/qmcpy/kernel/common_kernels.py
index 110042a8b..666bbdc36 100644
--- a/qmcpy/kernel/common_kernels.py
+++ b/qmcpy/kernel/common_kernels.py
@@ -1,3 +1,9 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Union, Tuple, Callable
+if TYPE_CHECKING:
+    import torch
+
 from .abstract_kernel import AbstractKernelScaleLengthscales
 from ..discrete_distribution import DigitalNetB2
 from ..util.transforms import tf_exp_eps, tf_exp_eps_inv, tf_identity
@@ -16,7 +22,7 @@ class AbstractKernelGaussianSE(AbstractKernelScaleLengthscales):
 
     AUTOGRADKERNEL = True
 
-    def parsed_single_integral_01d(self, x, batch_params):
+    def parsed_single_integral_01d(self, x: Union[np.ndarray, torch.Tensor], batch_params: dict) -> Union[np.ndarray, torch.Tensor]:
         """Analytic single integral of the Gaussian/SE-family kernel over `[0,1]^d`.
 
         Args:
@@ -39,7 +45,7 @@ def parsed_single_integral_01d(self, x, batch_params):
         )
         return kint
 
-    def double_integral_01d(self):
+    def double_integral_01d(self) -> Union[np.ndarray, torch.Tensor]:
         """Analytic double integral of the Gaussian/SE-family kernel over `[0,1]^d x [0,1]^d`.
 
         Returns:
@@ -483,43 +489,43 @@ class KernelRationalQuadratic(AbstractKernelScaleLengthscales):
     def __init__(
         self,
         d: int,
-        scale=1.0,
-        lengthscales=1.0,
-        alpha=1.0,
-        shape_scale: list = None,
-        shape_lengthscales: list = None,
-        shape_alpha: list = None,
-        tfs_scale=(tf_exp_eps_inv, tf_exp_eps),
-        tfs_lengthscales=(tf_exp_eps_inv, tf_exp_eps),
-        tfs_alpha=(tf_exp_eps_inv, tf_exp_eps),
+        scale: Union[float, np.ndarray, torch.Tensor] = 1.0,
+        lengthscales: Union[float, np.ndarray, torch.Tensor] = 1.0,
+        alpha: Union[float, np.ndarray, torch.Tensor] = 1.0,
+        shape_scale: Union[None, list] = None,
+        shape_lengthscales: Union[None, list] = None,
+        shape_alpha: Union[None, list] = None,
+        tfs_scale: Tuple[Callable, Callable] = (tf_exp_eps_inv, tf_exp_eps),
+        tfs_lengthscales: Tuple[Callable, Callable] = (tf_exp_eps_inv, tf_exp_eps),
+        tfs_alpha: Tuple[Callable, Callable] = (tf_exp_eps_inv, tf_exp_eps),
         torchify: bool = False,
         requires_grad_scale: bool = True,
         requires_grad_lengthscales: bool = True,
         requires_grad_alpha: bool = True,
-        device="cpu",
+        device: Union[str, torch.device] = "cpu",
         compile_call: bool = False,
-        compile_call_kwargs: dict = None,
+        compile_call_kwargs: Union[None, dict] = None,
     ) -> None:
         r"""Initialize a KernelRationalQuadratic kernel.
 
         Args:
             d (int): Dimension.
-            scale (Union[np.ndarray, torch.Tensor]): Scaling factor $S$.
-            lengthscales (Union[np.ndarray, torch.Tensor]): Lengthscales
+            scale (Union[float, np.ndarray, torch.Tensor]): Scaling factor $S$.
+            lengthscales (Union[float, np.ndarray, torch.Tensor]): Lengthscales
                 $\boldsymbol{\gamma}$.
-            alpha (Union[np.ndarray, torch.Tensor]): Scale mixture parameter
+            alpha (Union[float, np.ndarray, torch.Tensor]): Scale mixture parameter
                 $\alpha$.
-            shape_scale (list): Shape of `scale` when `np.isscalar(scale)`.
-            shape_lengthscales (list): Shape of `lengthscales` when
+            shape_scale (Union[None, list]): Shape of `scale` when `np.isscalar(scale)`.
+            shape_lengthscales (Union[None, list]): Shape of `lengthscales` when
                 `np.isscalar(lengthscales)`
-            shape_alpha (list): Shape of `alpha` when `np.isscalar(alpha)`
-            tfs_scale (Tuple[callable,callable]): The first argument transforms
+            shape_alpha (Union[None, list]): Shape of `alpha` when `np.isscalar(alpha)`
+            tfs_scale (Tuple[Callable,Callable]): The first argument transforms
                 to the raw value to be optimized; the second applies the
                 inverse transform.
-            tfs_lengthscales (Tuple[callable,callable]): The first argument
+            tfs_lengthscales (Tuple[Callable,Callable]): The first argument
                 transforms to the raw value to be optimized; the second applies
                 the inverse transform.
-            tfs_alpha (Tuple[callable,callable]): The first argument transforms
+            tfs_alpha (Tuple[Callable,Callable]): The first argument transforms
                 to the raw value to be optimized; the second applies the
                 inverse transform.
             torchify (bool): If `True`, use the `torch` backend. Set to `True`
@@ -531,10 +537,10 @@ def __init__(
                 `requires_grad=True` for `lengthscales`.
             requires_grad_alpha (bool): If `True` and `torchify`, set
                 `requires_grad=True` for `alpha`.
-            device (torch.device): If `torchify`, put things onto this device.
+            device (Union[str, torch.device]): If `torchify`, put things onto this device.
             compile_call (bool): If `True`, `torch.compile` the
                 `parsed___call__` method.
-            compile_call_kwargs (dict): When `compile_call` is `True`, pass
+            compile_call_kwargs (Union[None, dict]): When `compile_call` is `True`, pass
                 these keyword arguments to `torch.compile`.
         """
         if shape_scale is None:
diff --git a/qmcpy/kernel/multitask_kernel.py b/qmcpy/kernel/multitask_kernel.py
index 3b71e0910..9f421dcb4 100644
--- a/qmcpy/kernel/multitask_kernel.py
+++ b/qmcpy/kernel/multitask_kernel.py
@@ -1,3 +1,9 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Union, Tuple, Callable
+if TYPE_CHECKING:
+    import torch
+
 from .abstract_kernel import AbstractKernel
 from .common_kernels import KernelGaussian
 from ..util.transforms import tf_identity, tf_exp_eps, tf_exp_eps_inv, insert_batch_dims
@@ -330,15 +336,15 @@ def __init__(
         self,
         base_kernel: AbstractKernel,
         num_tasks: int,
-        factor=1.0,
-        diag=1.0,
-        shape_factor: list = None,
-        shape_diag: list = None,
-        tfs_factor=(tf_identity, tf_identity),
-        tfs_diag=(tf_exp_eps_inv, tf_exp_eps),
+        factor: Union[float, np.ndarray, torch.Tensor] = 1.0,
+        diag: Union[float, np.ndarray, torch.Tensor] = 1.0,
+        shape_factor: Union[None, list] = None,
+        shape_diag: Union[None, list] = None,
+        tfs_factor: Tuple[Callable, Callable] = (tf_identity, tf_identity),
+        tfs_diag: Tuple[Callable, Callable] = (tf_exp_eps_inv, tf_exp_eps),
         requires_grad_factor: bool = True,
         requires_grad_diag: bool = True,
-        rank_factor=1,
+        rank_factor: int = 1,
         method: str = "LOW RANK",
     ) -> None:
         r"""Initialize a KernelMultiTask kernel.
@@ -346,21 +352,24 @@ def __init__(
         Args:
             base_kernel (AbstractKernel): $K_{\mathrm{base}}$.
             num_tasks (int): Number of tasks $T>1$.
-            factor (Union[np.ndarray, torch.Tensor]): Factor $\mathsf{F}$.
-            diag (Union[np.ndarray, torch.Tensor]): Diagonal parameter
+            factor (Union[float, np.ndarray, torch.Tensor]): Factor $\mathsf{F}$.
+            diag (Union[float, np.ndarray, torch.Tensor]): Diagonal parameter
                 $\boldsymbol{v}$.
-            shape_factor (list): Shape of `factor` when `np.isscalar(factor)`.
-            shape_diag (list): Shape of `diag` when `np.isscalar(diag)`.
-            tfs_factor (Tuple[callable,callable]): The first argument
+            shape_factor (Union[None, list]): Shape of `factor` when `np.isscalar(factor)`.
+            shape_diag (Union[None, list]): Shape of `diag` when `np.isscalar(diag)`.
+            tfs_factor (Tuple[Callable,Callable]): The first argument
                 transforms to the raw value to be optimized; the second applies
                 the inverse transform.
-            tfs_diag (Tuple[callable,callable]): The first argument transforms
+            tfs_diag (Tuple[Callable,Callable]): The first argument transforms
                 to the raw value to be optimized; the second applies the
                 inverse transform.
             requires_grad_factor (bool): If `True` and `torchify`, set
                 `requires_grad=True` for `factor`.
             requires_grad_diag (bool): If `True` and `torchify`, set
                 `requires_grad=True` for `diag`.
+            rank_factor (int): Rank of the low-rank `factor` matrix when
+                `method="LOW RANK"` and `shape_factor` is not given; must
+                satisfy `0 <= rank_factor <= num_tasks`.
             method (str): `"LOW RANK"` or "CHOLESKY"
         """
         if not (isinstance(base_kernel, AbstractKernel)):
@@ -523,7 +532,7 @@ def __call__(self, task0, task1, x0, x1, beta0=None, beta1=None, c=None):
         kmat_x = self.base_kernel.__call__(x0, x1, beta0, beta1, c)
         return self._parsed__call__(task0, task1, kmat_x)
 
-    def single_integral_01d(self, task0, task1, x):
+    def single_integral_01d(self, task0: Union[int, np.ndarray, torch.Tensor], task1: Union[int, np.ndarray, torch.Tensor], x: Union[np.ndarray, torch.Tensor]) -> Union[np.ndarray, torch.Tensor]:
         r"""Evaluate the integral of the kernel over the unit cube
 
         $$\tilde{K}((i_0,\boldsymbol{x}),i_1) = \int_{[0,1]^d}
@@ -544,7 +553,7 @@ def single_integral_01d(self, task0, task1, x):
         kint_x = self.base_kernel.single_integral_01d(x)
         return self._parsed__call__(task0, task1, kint_x)
 
-    def double_integral_01d(self, task0, task1):
+    def double_integral_01d(self, task0: Union[int, np.ndarray, torch.Tensor], task1: Union[int, np.ndarray, torch.Tensor]) -> Union[np.ndarray, torch.Tensor]:
         r"""Evaluate the integral of the kernel over the unit cube
 
         $$\tilde{K}(i_0,i_1) = \int_{[0,1]^d} \int_{[0,1]^d}
diff --git a/qmcpy/kernel/si_dsi_kernels.py b/qmcpy/kernel/si_dsi_kernels.py
index af9d9290f..10d546b72 100644
--- a/qmcpy/kernel/si_dsi_kernels.py
+++ b/qmcpy/kernel/si_dsi_kernels.py
@@ -1,3 +1,9 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Union, Tuple, Callable
+if TYPE_CHECKING:
+    import torch
+
 from .abstract_kernel import AbstractKernelScaleLengthscales
 from ..util.transforms import tf_exp_eps, tf_exp_eps_inv, tf_identity
 from ..util.shift_invar_ops import BERNOULLIPOLYSDICT, bernoulli_poly
@@ -146,8 +152,8 @@ def double_integral_01d(self):
         return self.scale[..., 0]
 
     def combine_per_dim_components_raw_m1(
-        self, kparts, beta0, beta1, c, batch_params, stable
-    ):
+        self, kparts: Union[np.ndarray, torch.Tensor], beta0: Union[np.ndarray, torch.Tensor], beta1: Union[np.ndarray, torch.Tensor], c: Union[np.ndarray, torch.Tensor], batch_params: dict, stable: bool
+    ) -> tuple[Union[np.ndarray, torch.Tensor], Union[np.ndarray, torch.Tensor]]:
         """Combine per-dimension kernel components into `(scale_term, remainder)`.
 
         Args:
@@ -190,7 +196,7 @@ def get_per_dim_components(self, x0, x1, beta0, beta1):
         """
         raise MethodImplementationError(self, "get_per_dim_components")
 
-    def combine_per_dim_components(self, kparts, beta0, beta1, c, batch_params, stable):
+    def combine_per_dim_components(self, kparts: Union[np.ndarray, torch.Tensor], beta0: Union[np.ndarray, torch.Tensor], beta1: Union[np.ndarray, torch.Tensor], c: Union[np.ndarray, torch.Tensor], batch_params: dict, stable: bool) -> Union[np.ndarray, torch.Tensor]:
         """Combine per-dimension kernel components into the final kernel value.
 
         Args:
@@ -377,61 +383,61 @@ class KernelShiftInvar(AbstractSIDSIKernel):
     def __init__(
         self,
         d: int,
-        scale=1.0,
-        lengthscales=None,
-        alpha=2,
-        shape_scale: list = None,
-        shape_lengthscales: list = None,
-        tfs_scale=None,
-        tfs_lengthscales=None,
+        scale: Union[float, np.ndarray, torch.Tensor] = 1.0,
+        lengthscales: Union[None, np.ndarray, torch.Tensor] = None,
+        alpha: Union[float, np.ndarray, torch.Tensor] = 2,
+        shape_scale: Union[None, list] = None,
+        shape_lengthscales: Union[None, list] = None,
+        tfs_scale: Union[None, Tuple[Callable, Callable]] = None,
+        tfs_lengthscales: Union[None, Tuple[Callable, Callable]] = None,
         torchify: bool = False,
-        requires_grad_scale: bool = None,
-        requires_grad_lengthscales: bool = None,
-        device="cpu",
+        requires_grad_scale: Union[None, bool] = None,
+        requires_grad_lengthscales: Union[None, bool] = None,
+        device: Union[str, torch.device] = "cpu",
         compile_call: bool = False,
-        compile_call_kwargs: dict = None,
-        weights=None,
-        shape_weights: list = None,
-        tfs_weights=None,
-        requires_grad_weights: bool = None,
+        compile_call_kwargs: Union[None, dict] = None,
+        weights: Union[None, np.ndarray, torch.Tensor] = None,
+        shape_weights: Union[None, list] = None,
+        tfs_weights: Union[None, Tuple[Callable, Callable]] = None,
+        requires_grad_weights: Union[None, bool] = None,
     ) -> None:
         r"""Initialize a KernelShiftInvar kernel.
 
         Args:
             d (int): Dimension.
-            scale (Union[np.ndarray, torch.Tensor]): Scaling factor $S$.
-            lengthscales (Union[np.ndarray, torch.Tensor]): Product weights
+            scale (Union[float, np.ndarray, torch.Tensor]): Scaling factor $S$.
+            lengthscales (Union[None, np.ndarray, torch.Tensor]): Product weights
                 $(\gamma_1,\dots,\gamma_d)$.
-            alpha (Union[np.ndarray, torch.Tensor]): Smoothness parameters
+            alpha (Union[float, np.ndarray, torch.Tensor]): Smoothness parameters
                 $(\alpha_1,\dots,\alpha_d)$ where $\alpha_j \geq 1$ for
                 $j=1,\dots,d$.
-            shape_scale (list): Shape of `scale` when `np.isscalar(scale)`.
-            shape_lengthscales (list): Shape of `lengthscales` when
+            shape_scale (Union[None, list]): Shape of `scale` when `np.isscalar(scale)`.
+            shape_lengthscales (Union[None, list]): Shape of `lengthscales` when
                 `np.isscalar(lengthscales)`
-            tfs_scale (Tuple[callable,callable]): The first argument transforms
+            tfs_scale (Union[None, Tuple[Callable,Callable]]): The first argument transforms
                 to the raw value to be optimized; the second applies the
                 inverse transform.
-            tfs_lengthscales (Tuple[callable,callable]): The first argument
+            tfs_lengthscales (Union[None, Tuple[Callable,Callable]]): The first argument
                 transforms to the raw value to be optimized; the second applies
                 the inverse transform.
             torchify (bool): If `True`, use the `torch` backend. Set to `True`
                 if computing gradients with respect to inputs and/or
                 hyperparameters.
-            requires_grad_scale (bool): If `True` and `torchify`, set
+            requires_grad_scale (Union[None, bool]): If `True` and `torchify`, set
                 `requires_grad=True` for `scale`.
-            requires_grad_lengthscales (bool): If `True` and `torchify`, set
+            requires_grad_lengthscales (Union[None, bool]): If `True` and `torchify`, set
                 `requires_grad=True` for `lengthscales`.
-            device (torch.device): If `torchify`, put things onto this device.
+            device (Union[str, torch.device]): If `torchify`, put things onto this device.
             compile_call (bool): If `True`, `torch.compile` the
                 `parsed___call__` method.
-            compile_call_kwargs (dict): When `compile_call` is `True`, pass
+            compile_call_kwargs (Union[None, dict]): When `compile_call` is `True`, pass
                 these keyword arguments to `torch.compile`.
-            weights (Union[np.ndarray, torch.Tensor]): Alias for
+            weights (Union[None, np.ndarray, torch.Tensor]): Alias for
                 `lengthscales`.
-            shape_weights (list): Alias for `shape_lengthscales`.
-            tfs_weights (Tuple[callable,callable]): Alias for
+            shape_weights (Union[None, list]): Alias for `shape_lengthscales`.
+            tfs_weights (Union[None, Tuple[Callable,Callable]]): Alias for
                 `tfs_lengthscales`.
-            requires_grad_weights (bool): Alias for
+            requires_grad_weights (Union[None, bool]): Alias for
                 `requires_grad_lengthscales`.
         """
         if shape_scale is None:
@@ -601,70 +607,70 @@ class KernelShiftInvarCombined(AbstractSIDSIKernel):
     def __init__(
         self,
         d: int,
-        scale=1.0,
-        lengthscales=None,
-        alpha=1,
-        shape_scale: list = None,
-        shape_lengthscales: list = None,
-        shape_alpha: list = None,
-        tfs_scale=None,
-        tfs_lengthscales=None,
-        tfs_alpha=None,
+        scale: Union[float, np.ndarray, torch.Tensor] = 1.0,
+        lengthscales: Union[None, np.ndarray, torch.Tensor] = None,
+        alpha: Union[float, np.ndarray, torch.Tensor] = 1,
+        shape_scale: Union[None, list] = None,
+        shape_lengthscales: Union[None, list] = None,
+        shape_alpha: Union[None, list] = None,
+        tfs_scale: Union[None, Tuple[Callable, Callable]] = None,
+        tfs_lengthscales: Union[None, Tuple[Callable, Callable]] = None,
+        tfs_alpha: Union[None, Tuple[Callable, Callable]] = None,
         torchify: bool = False,
-        requires_grad_scale: bool = None,
-        requires_grad_lengthscales: bool = None,
-        requires_grad_alpha: bool = None,
-        device="cpu",
+        requires_grad_scale: Union[None, bool] = None,
+        requires_grad_lengthscales: Union[None, bool] = None,
+        requires_grad_alpha: Union[None, bool] = None,
+        device: Union[str, torch.device] = "cpu",
         compile_call: bool = False,
-        compile_call_kwargs: dict = None,
-        weights=None,
-        shape_weights: list = None,
-        tfs_weights=None,
-        requires_grad_weights: bool = None,
+        compile_call_kwargs: Union[None, dict] = None,
+        weights: Union[None, np.ndarray, torch.Tensor] = None,
+        shape_weights: Union[None, list] = None,
+        tfs_weights: Union[None, Tuple[Callable, Callable]] = None,
+        requires_grad_weights: Union[None, bool] = None,
     ) -> None:
         r"""Initialize a KernelShiftInvarCombined kernel.
 
         Args:
             d (int): Dimension.
-            scale (Union[np.ndarray, torch.Tensor]): Scaling factor $S$.
-            lengthscales (Union[np.ndarray, torch.Tensor]): Product weights
+            scale (Union[float, np.ndarray, torch.Tensor]): Scaling factor $S$.
+            lengthscales (Union[None, np.ndarray, torch.Tensor]): Product weights
                 $(\gamma_1,\dots,\gamma_d)$.
-            alpha (Union[np.ndarray, torch.Tensor]): Weights
+            alpha (Union[float, np.ndarray, torch.Tensor]): Weights
                 $\boldsymbol{\alpha}_1,\dots,\boldsymbol{\alpha}_d \in
                 \mathbb{R}_{>0}^4$.
-            shape_scale (list): Shape of `scale` when `np.isscalar(scale)`.
-            shape_lengthscales (list): Shape of `lengthscales` when
+            shape_scale (Union[None, list]): Shape of `scale` when `np.isscalar(scale)`.
+            shape_lengthscales (Union[None, list]): Shape of `lengthscales` when
                 `np.isscalar(lengthscales)`
-            shape_alpha (list): Shape of `alpha` when `np.isscalar(alpha)`
-            tfs_scale (Tuple[callable,callable]): The first argument transforms
+            shape_alpha (Union[None, list]): Shape of `alpha` when `np.isscalar(alpha)`
+            tfs_scale (Union[None, Tuple[Callable,Callable]]): The first argument transforms
                 to the raw value to be optimized; the second applies the
                 inverse transform.
-            tfs_lengthscales (Tuple[callable,callable]): The first argument
+            tfs_lengthscales (Union[None, Tuple[Callable,Callable]]): The first argument
                 transforms to the raw value to be optimized; the second applies
                 the inverse transform.
-            tfs_alpha (Tuple[callable,callable]): The first argument transforms
+            tfs_alpha (Union[None, Tuple[Callable,Callable]]): The first argument transforms
                 to the raw value to be optimized; the second applies the
                 inverse transform.
             torchify (bool): If `True`, use the `torch` backend. Set to `True`
                 if computing gradients with respect to inputs and/or
                 hyperparameters.
-            requires_grad_scale (bool): If `True` and `torchify`, set
+            requires_grad_scale (Union[None, bool]): If `True` and `torchify`, set
                 `requires_grad=True` for `scale`.
-            requires_grad_lengthscales (bool): If `True` and `torchify`, set
+            requires_grad_lengthscales (Union[None, bool]): If `True` and `torchify`, set
                 `requires_grad=True` for `lengthscales`.
-            requires_grad_alpha (bool): If `True` and `torchify`, set
+            requires_grad_alpha (Union[None, bool]): If `True` and `torchify`, set
                 `requires_grad=True` for `alpha`.
-            device (torch.device): If `torchify`, put things onto this device.
+            device (Union[str, torch.device]): If `torchify`, put things onto this device.
             compile_call (bool): If `True`, `torch.compile` the
                 `parsed___call__` method.
-            compile_call_kwargs (dict): When `compile_call` is `True`, pass
+            compile_call_kwargs (Union[None, dict]): When `compile_call` is `True`, pass
                 these keyword arguments to `torch.compile`.
-            weights (Union[np.ndarray, torch.Tensor]): Alias for
+            weights (Union[None, np.ndarray, torch.Tensor]): Alias for
                 `lengthscales`.
-            shape_weights (list): Alias for `shape_lengthscales`.
-            tfs_weights (Tuple[callable,callable]): Alias for
+            shape_weights (Union[None, list]): Alias for `shape_lengthscales`.
+            tfs_weights (Union[None, Tuple[Callable,Callable]]): Alias for
                 `tfs_lengthscales`.
-            requires_grad_weights (bool): Alias for
+            requires_grad_weights (Union[None, bool]): Alias for
                 `requires_grad_lengthscales`.
         """
         if shape_scale is None:
@@ -887,64 +893,64 @@ class KernelDigShiftInvar(AbstractSIDSIKernel):
     def __init__(
         self,
         d: int,
-        t: int = None,
-        scale=1.0,
-        lengthscales=None,
-        alpha=2,
-        shape_scale: list = None,
-        shape_lengthscales: list = None,
-        tfs_scale=None,
-        tfs_lengthscales=None,
+        t: Union[None, int] = None,
+        scale: Union[float, np.ndarray, torch.Tensor] = 1.0,
+        lengthscales: Union[None, np.ndarray, torch.Tensor] = None,
+        alpha: Union[float, np.ndarray, torch.Tensor] = 2,
+        shape_scale: Union[None, list] = None,
+        shape_lengthscales: Union[None, list] = None,
+        tfs_scale: Union[None, Tuple[Callable, Callable]] = None,
+        tfs_lengthscales: Union[None, Tuple[Callable, Callable]] = None,
         torchify: bool = False,
-        requires_grad_scale: bool = None,
-        requires_grad_lengthscales: bool = None,
-        device="cpu",
+        requires_grad_scale: Union[None, bool] = None,
+        requires_grad_lengthscales: Union[None, bool] = None,
+        device: Union[str, torch.device] = "cpu",
         compile_call: bool = False,
-        compile_call_kwargs: dict = None,
-        weights=None,
-        shape_weights: list = None,
-        tfs_weights=None,
-        requires_grad_weights: bool = None,
+        compile_call_kwargs: Union[None, dict] = None,
+        weights: Union[None, np.ndarray, torch.Tensor] = None,
+        shape_weights: Union[None, list] = None,
+        tfs_weights: Union[None, Tuple[Callable, Callable]] = None,
+        requires_grad_weights: Union[None, bool] = None,
     ) -> None:
         r"""Initialize a KernelDigShiftInvar kernel.
 
         Args:
             d (int): Dimension.
-            t (int): number of bits in binary representations. Typically
+            t (Union[None, int]): number of bits in binary representations. Typically
                 `dnb2.t` where `isinstance(dnb2,DigitalNetB2)`.
-            scale (Union[np.ndarray, torch.Tensor]): Scaling factor $S$.
-            lengthscales (Union[np.ndarray, torch.Tensor]): Product weights
+            scale (Union[float, np.ndarray, torch.Tensor]): Scaling factor $S$.
+            lengthscales (Union[None, np.ndarray, torch.Tensor]): Product weights
                 $(\gamma_1,\dots,\gamma_d)$.
-            alpha (Union[np.ndarray, torch.Tensor]): Smoothness parameters
+            alpha (Union[float, np.ndarray, torch.Tensor]): Smoothness parameters
                 $(\alpha_1,\dots,\alpha_d)$ where $\alpha_j \geq 1$ for
                 $j=1,\dots,d$.
-            shape_scale (list): Shape of `scale` when `np.isscalar(scale)`.
-            shape_lengthscales (list): Shape of `lengthscales` when
+            shape_scale (Union[None, list]): Shape of `scale` when `np.isscalar(scale)`.
+            shape_lengthscales (Union[None, list]): Shape of `lengthscales` when
                 `np.isscalar(lengthscales)`
-            tfs_scale (Tuple[callable,callable]): The first argument transforms
+            tfs_scale (Union[None, Tuple[Callable,Callable]]): The first argument transforms
                 to the raw value to be optimized; the second applies the
                 inverse transform.
-            tfs_lengthscales (Tuple[callable,callable]): The first argument
+            tfs_lengthscales (Union[None, Tuple[Callable,Callable]]): The first argument
                 transforms to the raw value to be optimized; the second applies
                 the inverse transform.
             torchify (bool): If `True`, use the `torch` backend. Set to `True`
                 if computing gradients with respect to inputs and/or
                 hyperparameters.
-            requires_grad_scale (bool): If `True` and `torchify`, set
+            requires_grad_scale (Union[None, bool]): If `True` and `torchify`, set
                 `requires_grad=True` for `scale`.
-            requires_grad_lengthscales (bool): If `True` and `torchify`, set
+            requires_grad_lengthscales (Union[None, bool]): If `True` and `torchify`, set
                 `requires_grad=True` for `lengthscales`.
-            device (torch.device): If `torchify`, put things onto this device.
+            device (Union[str, torch.device]): If `torchify`, put things onto this device.
             compile_call (bool): If `True`, `torch.compile` the
                 `parsed___call__` method.
-            compile_call_kwargs (dict): When `compile_call` is `True`, pass
+            compile_call_kwargs (Union[None, dict]): When `compile_call` is `True`, pass
                 these keyword arguments to `torch.compile`.
-            weights (Union[np.ndarray, torch.Tensor]): Alias for
+            weights (Union[None, np.ndarray, torch.Tensor]): Alias for
                 `lengthscales`.
-            shape_weights (list): Alias for `shape_lengthscales`.
-            tfs_weights (Tuple[callable,callable]): Alias for
+            shape_weights (Union[None, list]): Alias for `shape_lengthscales`.
+            tfs_weights (Union[None, Tuple[Callable,Callable]]): Alias for
                 `tfs_lengthscales`.
-            requires_grad_weights (bool): Alias for
+            requires_grad_weights (Union[None, bool]): Alias for
                 `requires_grad_lengthscales`.
         """
         if shape_scale is None:
@@ -990,7 +996,7 @@ def t(self):
             raise ParameterError("please use set_t to set the t value")
         return self._t
 
-    def set_t(self, t):
+    def set_t(self, t: Union[None, int]):
         """Set the number of bits `t` used to binarize inputs via `to_bin`.
 
         Args:
@@ -1183,73 +1189,73 @@ class KernelDigShiftInvarAdaptiveAlpha(AbstractSIDSIKernel):
     def __init__(
         self,
         d: int,
-        t: int = None,
-        scale=1.0,
-        lengthscales=None,
-        alpha=1,
-        shape_scale: list = None,
-        shape_lengthscales: list = None,
-        shape_alpha: list = None,
-        tfs_scale=None,
-        tfs_lengthscales=None,
-        tfs_alpha=None,
+        t: Union[None, int] = None,
+        scale: Union[float, np.ndarray, torch.Tensor] = 1.0,
+        lengthscales: Union[None, np.ndarray, torch.Tensor] = None,
+        alpha: Union[float, np.ndarray, torch.Tensor] = 1,
+        shape_scale: Union[None, list] = None,
+        shape_lengthscales: Union[None, list] = None,
+        shape_alpha: Union[None, list] = None,
+        tfs_scale: Union[None, Tuple[Callable, Callable]] = None,
+        tfs_lengthscales: Union[None, Tuple[Callable, Callable]] = None,
+        tfs_alpha: Union[None, Tuple[Callable, Callable]] = None,
         torchify: bool = False,
-        requires_grad_scale: bool = None,
-        requires_grad_lengthscales: bool = None,
-        requires_grad_alpha: bool = None,
-        device="cpu",
+        requires_grad_scale: Union[None, bool] = None,
+        requires_grad_lengthscales: Union[None, bool] = None,
+        requires_grad_alpha: Union[None, bool] = None,
+        device: Union[str, torch.device] = "cpu",
         compile_call: bool = False,
-        compile_call_kwargs: dict = None,
-        weights=None,
-        shape_weights: list = None,
-        tfs_weights=None,
-        requires_grad_weights: bool = None,
+        compile_call_kwargs: Union[None, dict] = None,
+        weights: Union[None, np.ndarray, torch.Tensor] = None,
+        shape_weights: Union[None, list] = None,
+        tfs_weights: Union[None, Tuple[Callable, Callable]] = None,
+        requires_grad_weights: Union[None, bool] = None,
     ) -> None:
         r"""Initialize a KernelDigShiftInvarAdaptiveAlpha kernel.
 
         Args:
             d (int): Dimension.
-            t (int): number of bits in binary representations. Typically
+            t (Union[None, int]): number of bits in binary representations. Typically
                 `dnb2.t` where `isinstance(dnb2,DigitalNetB2)`.
-            scale (Union[np.ndarray, torch.Tensor]): Scaling factor $S$.
-            lengthscales (Union[np.ndarray, torch.Tensor]): Product weights
+            scale (Union[float, np.ndarray, torch.Tensor]): Scaling factor $S$.
+            lengthscales (Union[None, np.ndarray, torch.Tensor]): Product weights
                 $(\gamma_1,\dots,\gamma_d)$.
-            alpha (Union[np.ndarray, torch.Tensor]): Smoothness parameters
+            alpha (Union[float, np.ndarray, torch.Tensor]): Smoothness parameters
                 $(\alpha_1,\dots,\alpha_d)$ where $\alpha_j \geq 1$ for
                 $j=1,\dots,d$.
-            shape_alpha (list): Shape of `alpha` when `np.isscalar(alpha)`
-            shape_scale (list): Shape of `scale` when `np.isscalar(scale)`.
-            shape_lengthscales (list): Shape of `lengthscales` when
+            shape_scale (Union[None, list]): Shape of `scale` when `np.isscalar(scale)`.
+            shape_lengthscales (Union[None, list]): Shape of `lengthscales` when
                 `np.isscalar(lengthscales)`
-            tfs_scale (Tuple[callable,callable]): The first argument transforms
+            shape_alpha (Union[None, list]): Shape of `alpha` when `np.isscalar(alpha)`
+            tfs_scale (Union[None, Tuple[Callable,Callable]]): The first argument transforms
                 to the raw value to be optimized; the second applies the
                 inverse transform.
-            tfs_lengthscales (Tuple[callable,callable]): The first argument
+            tfs_lengthscales (Union[None, Tuple[Callable,Callable]]): The first argument
                 transforms to the raw value to be optimized; the second applies
                 the inverse transform.
-            tfs_alpha (Tuple[callable,callable]): The first argument transforms
+            tfs_alpha (Union[None, Tuple[Callable,Callable]]): The first argument transforms
                 to the raw value to be optimized; the second applies the
                 inverse transform.
             torchify (bool): If `True`, use the `torch` backend. Set to `True`
                 if computing gradients with respect to inputs and/or
                 hyperparameters.
-            requires_grad_scale (bool): If `True` and `torchify`, set
+            requires_grad_scale (Union[None, bool]): If `True` and `torchify`, set
                 `requires_grad=True` for `scale`.
-            requires_grad_lengthscales (bool): If `True` and `torchify`, set
+            requires_grad_lengthscales (Union[None, bool]): If `True` and `torchify`, set
                 `requires_grad=True` for `lengthscales`.
-            requires_grad_alpha (bool): If `True` and `torchify`, set
+            requires_grad_alpha (Union[None, bool]): If `True` and `torchify`, set
                 `requires_grad=True` for `alpha`.
-            device (torch.device): If `torchify`, put things onto this device.
+            device (Union[str, torch.device]): If `torchify`, put things onto this device.
             compile_call (bool): If `True`, `torch.compile` the
                 `parsed___call__` method.
-            compile_call_kwargs (dict): When `compile_call` is `True`, pass
+            compile_call_kwargs (Union[None, dict]): When `compile_call` is `True`, pass
                 these keyword arguments to `torch.compile`.
-            weights (Union[np.ndarray, torch.Tensor]): Alias for
+            weights (Union[None, np.ndarray, torch.Tensor]): Alias for
                 `lengthscales`.
-            shape_weights (list): Alias for `shape_lengthscales`.
-            tfs_weights (Tuple[callable,callable]): Alias for
+            shape_weights (Union[None, list]): Alias for `shape_lengthscales`.
+            tfs_weights (Union[None, Tuple[Callable,Callable]]): Alias for
                 `tfs_lengthscales`.
-            requires_grad_weights (bool): Alias for
+            requires_grad_weights (Union[None, bool]): Alias for
                 `requires_grad_lengthscales`.
         """
         if shape_scale is None:
@@ -1292,7 +1298,7 @@ def t(self):
             raise ParameterError("please use set_t to set the t value")
         return self._t
 
-    def set_t(self, t):
+    def set_t(self, t: Union[None, int]):
         """Set the number of bits `t` used to binarize inputs via `to_bin`.
 
         Args:
@@ -1458,70 +1464,73 @@ class KernelDigShiftInvarCombined(AbstractSIDSIKernel):
     def __init__(
         self,
         d: int,
-        t: int = None,
-        scale=1.0,
-        lengthscales=None,
-        alpha=1.0,
-        shape_scale: list = None,
-        shape_lengthscales: list = None,
-        shape_alpha: list = None,
-        tfs_scale=None,
-        tfs_lengthscales=None,
-        tfs_alpha=None,
+        t: Union[None, int] = None,
+        scale: Union[float, np.ndarray, torch.Tensor] = 1.0,
+        lengthscales: Union[None, np.ndarray, torch.Tensor] = None,
+        alpha: Union[float, np.ndarray, torch.Tensor] = 1.0,
+        shape_scale: Union[None, list] = None,
+        shape_lengthscales: Union[None, list] = None,
+        shape_alpha: Union[None, list] = None,
+        tfs_scale: Union[None, Tuple[Callable, Callable]] = None,
+        tfs_lengthscales: Union[None, Tuple[Callable, Callable]] = None,
+        tfs_alpha: Union[None, Tuple[Callable, Callable]] = None,
         torchify: bool = False,
-        requires_grad_scale: bool = None,
-        requires_grad_lengthscales: bool = None,
-        requires_grad_alpha: bool = None,
-        device="cpu",
+        requires_grad_scale: Union[None, bool] = None,
+        requires_grad_lengthscales: Union[None, bool] = None,
+        requires_grad_alpha: Union[None, bool] = None,
+        device: Union[str, torch.device] = "cpu",
         compile_call: bool = False,
-        compile_call_kwargs: dict = None,
-        weights=None,
-        shape_weights: list = None,
-        tfs_weights=None,
-        requires_grad_weights: bool = None,
+        compile_call_kwargs: Union[None, dict] = None,
+        weights: Union[None, np.ndarray, torch.Tensor] = None,
+        shape_weights: Union[None, list] = None,
+        tfs_weights: Union[None, Tuple[Callable, Callable]] = None,
+        requires_grad_weights: Union[None, bool] = None,
     ) -> None:
         r"""Initialize a KernelDigShiftInvarCombined kernel.
 
         Args:
             d (int): Dimension.
-            t (int): number of bits in binary representations. Typically
+            t (Union[None, int]): number of bits in binary representations. Typically
                 `dnb2.t` where `isinstance(dnb2,DigitalNetB2)`.
-            scale (Union[np.ndarray, torch.Tensor]): Scaling factor $S$.
-            lengthscales (Union[np.ndarray, torch.Tensor]): Product weights
+            scale (Union[float, np.ndarray, torch.Tensor]): Scaling factor $S$.
+            lengthscales (Union[None, np.ndarray, torch.Tensor]): Product weights
                 $(\gamma_1,\dots,\gamma_d)$.
-            alpha (Union[np.ndarray, torch.Tensor]): Weights
+            alpha (Union[float, np.ndarray, torch.Tensor]): Weights
                 $\boldsymbol{\alpha}_1,\dots,\boldsymbol{\alpha}_d \in
                 \mathbb{R}_{>0}^4$.
-            shape_scale (list): Shape of `scale` when `np.isscalar(scale)`.
-            shape_lengthscales (list): Shape of `lengthscales` when
+            shape_scale (Union[None, list]): Shape of `scale` when `np.isscalar(scale)`.
+            shape_lengthscales (Union[None, list]): Shape of `lengthscales` when
                 `np.isscalar(lengthscales)`
-            shape_alpha (list): Shape of `alpha` when `np.isscalar(alpha)`
-            tfs_scale (Tuple[callable,callable]): The first argument transforms
+            shape_alpha (Union[None, list]): Shape of `alpha` when `np.isscalar(alpha)`
+            tfs_scale (Union[None, Tuple[Callable,Callable]]): The first argument transforms
                 to the raw value to be optimized; the second applies the
                 inverse transform.
-            tfs_lengthscales (Tuple[callable,callable]): The first argument
+            tfs_lengthscales (Union[None, Tuple[Callable,Callable]]): The first argument
                 transforms to the raw value to be optimized; the second applies
                 the inverse transform.
+            tfs_alpha (Union[None, Tuple[Callable,Callable]]): The first argument transforms
+                to the raw value to be optimized; the second applies the
+                inverse transform.
             torchify (bool): If `True`, use the `torch` backend. Set to `True`
                 if computing gradients with respect to inputs and/or
                 hyperparameters.
-            requires_grad_scale (bool): If `True` and `torchify`, set
+            requires_grad_scale (Union[None, bool]): If `True` and `torchify`, set
                 `requires_grad=True` for `scale`.
-            requires_grad_lengthscales (bool): If `True` and `torchify`, set
+            requires_grad_lengthscales (Union[None, bool]): If `True` and `torchify`, set
                 `requires_grad=True` for `lengthscales`.
-            requires_grad_alpha (bool): If `True` and `torchify`, set
+            requires_grad_alpha (Union[None, bool]): If `True` and `torchify`, set
                 `requires_grad=True` for `alpha`.
-            device (torch.device): If `torchify`, put things onto this device.
+            device (Union[str, torch.device]): If `torchify`, put things onto this device.
             compile_call (bool): If `True`, `torch.compile` the
                 `parsed___call__` method.
-            compile_call_kwargs (dict): When `compile_call` is `True`, pass
+            compile_call_kwargs (Union[None, dict]): When `compile_call` is `True`, pass
                 these keyword arguments to `torch.compile`.
-            weights (Union[np.ndarray, torch.Tensor]): Alias for
+            weights (Union[None, np.ndarray, torch.Tensor]): Alias for
                 `lengthscales`.
-            shape_weights (list): Alias for `shape_lengthscales`.
-            tfs_weights (Tuple[callable,callable]): Alias for
+            shape_weights (Union[None, list]): Alias for `shape_lengthscales`.
+            tfs_weights (Union[None, Tuple[Callable,Callable]]): Alias for
                 `tfs_lengthscales`.
-            requires_grad_weights (bool): Alias for
+            requires_grad_weights (Union[None, bool]): Alias for
                 `requires_grad_lengthscales`.
         """
         if shape_scale is None:
@@ -1565,7 +1574,7 @@ def t(self):
             raise ParameterError("please use set_t to set the t value")
         return self._t
 
-    def set_t(self, t):
+    def set_t(self, t: Union[None, int]):
         """Set the number of bits `t` used to binarize inputs via `to_bin`.
 
         Args:
diff --git a/qmcpy/stopping_criterion/abstract_cub_bayes_ld_g.py b/qmcpy/stopping_criterion/abstract_cub_bayes_ld_g.py
index 483d7eb2f..de6625167 100644
--- a/qmcpy/stopping_criterion/abstract_cub_bayes_ld_g.py
+++ b/qmcpy/stopping_criterion/abstract_cub_bayes_ld_g.py
@@ -1,3 +1,4 @@
+from typing import Union
 from .abstract_stopping_criterion import AbstractStoppingCriterion
 from ..util.data import Data
 
@@ -42,7 +43,7 @@ def __init__(
         alpha,
         error_fun,
         errbd_type,
-    ):
+    ) -> None:
         self.parameters = ["abs_tol", "rel_tol", "n_init", "n_limit", "order"]
         # Input Checks
         if np.log2(n_init) % 1 != 0:
@@ -199,7 +200,7 @@ def __setstate__(self, state):
         if isinstance(self.error_fun, str):
             self.error_fun, _ = self._resolve_error_fun(self.error_fun)
 
-    def objective_function(self, theta, xun, ftilde):
+    def objective_function(self, theta: float, xun: np.ndarray, ftilde: np.ndarray) -> float:
         """Compute the Bayesian cubature loss used to fit the kernel parameter theta.
 
         Evaluates either the negative log marginal likelihood (MLE) or the
@@ -279,7 +280,7 @@ def objective_function(self, theta, xun, ftilde):
         return loss, vec_lambda, vec_lambda_ring, RKHS_norm
 
     @staticmethod
-    def kernel_t(aconst, Bern):
+    def kernel_t(aconst: Union[float, np.ndarray], Bern: np.ndarray) -> np.ndarray:
         r"""Compute the modified kernel ``Km1 = K - 1`` from Bernoulli polynomial values.
 
         Working with ``Km1`` rather than ``K`` directly avoids cancellation
@@ -315,7 +316,7 @@ def kernel_t(aconst, Bern):
         return [Km1, K]
 
     @staticmethod
-    def alert_msg(*args):
+    def alert_msg(*args: tuple):
         """Print a debug message if a variable contains NaN, Inf, or complex values.
 
         Args:
@@ -348,7 +349,7 @@ def alert_msg(*args):
                 else:
                     print("unknown type check requested !")
 
-    def integrate(self, resume=None):
+    def integrate(self, resume: Union[None, Data] = None) -> tuple:
         """Determine the samples needed to satisfy the target tolerance.
 
         Doubles the sample count each iteration, updates the running fast
@@ -359,7 +360,7 @@ def integrate(self, resume=None):
         exceeded.
 
         Args:
-            resume (Data): Existing integration state to resume from, if
+            resume (Union[None, Data]): Existing integration state to resume from, if
                 supported. Defaults to None.
 
         Returns:
@@ -507,15 +508,15 @@ def _validate_resume(self, data):
         if not self._is_power_of_two(n_total):
             raise ParameterError("resume data n_total must be a power of 2.")
 
-    def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
+    def set_tolerance(self, abs_tol: Union[None, float] = None, rel_tol: Union[None, float] = None, rmse_tol: Union[None, float] = None):
         """Update the stopping criterion's target tolerance.
 
         Args:
-            abs_tol (float): Absolute error tolerance, broadcast to
+            abs_tol (Union[None, float]): Absolute error tolerance, broadcast to
                 `self.abs_tols` with shape `integrand.d_comb`.
-            rel_tol (float): Relative error tolerance, broadcast to
+            rel_tol (Union[None, float]): Relative error tolerance, broadcast to
                 `self.rel_tols` with shape `integrand.d_comb`.
-            rmse_tol (float): Unsupported; must be `None`.
+            rmse_tol (Union[None, float]): Unsupported; must be `None`.
 
         Raises:
             AssertionError: If `rmse_tol` is supplied.
diff --git a/qmcpy/stopping_criterion/abstract_cub_mlmc.py b/qmcpy/stopping_criterion/abstract_cub_mlmc.py
index 9b5df29c6..86c4ea2e2 100644
--- a/qmcpy/stopping_criterion/abstract_cub_mlmc.py
+++ b/qmcpy/stopping_criterion/abstract_cub_mlmc.py
@@ -1,3 +1,4 @@
+from typing import Union
 from .abstract_stopping_criterion import AbstractStoppingCriterion
 from ..util.data import Data
 from ..util import ParameterError
@@ -72,14 +73,14 @@ def _get_next_samples(self, data):
         )
         return ns.astype(int)
 
-    def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
+    def set_tolerance(self, abs_tol: Union[None, float] = None, rel_tol: Union[None, float] = None, rmse_tol: Union[None, float] = None):
         """Update the stopping criterion's target tolerance.
 
         Args:
-            abs_tol (float): Absolute error tolerance, converted to an RMSE
+            abs_tol (Union[None, float]): Absolute error tolerance, converted to an RMSE
                 tolerance via `self.alpha`. Ignored if `rmse_tol` is supplied.
-            rel_tol (float): Unsupported; must be `None`.
-            rmse_tol (float): Root mean squared error tolerance. Takes
+            rel_tol (Union[None, float]): Unsupported; must be `None`.
+            rmse_tol (Union[None, float]): Root mean squared error tolerance. Takes
                 precedence over `abs_tol` if both are supplied.
 
         Raises:
@@ -177,12 +178,15 @@ def _construct_data(self):
         return data
 
     @staticmethod
-    def _validate_level_diffs(data):
+    def _validate_level_diffs(data: Data):
         """Validate the ``level_diffs`` replay cache on a resume checkpoint.
 
         Args:
             data (Data): Resume checkpoint to validate.
 
+        Returns:
+            None
+
         Raises:
             ParameterError: If ``level_diffs`` is present but structurally
                 inconsistent with ``n_level``.
@@ -200,7 +204,7 @@ def _validate_level_diffs(data):
                     % (level, level)
                 )
 
-    def _update_replay_data(self, data):
+    def _update_replay_data(self, data: Data):
         """Replay cached level-difference samples, falling back to fresh
         draws.
 
diff --git a/qmcpy/stopping_criterion/abstract_cub_mlqmc.py b/qmcpy/stopping_criterion/abstract_cub_mlqmc.py
index 63c8c64ad..9c6d4fb97 100644
--- a/qmcpy/stopping_criterion/abstract_cub_mlqmc.py
+++ b/qmcpy/stopping_criterion/abstract_cub_mlqmc.py
@@ -1,4 +1,6 @@
+from typing import Union
 from .abstract_stopping_criterion import AbstractStoppingCriterion
+from ..util.data import Data
 import numpy as np
 from scipy.stats import norm
 
@@ -106,14 +108,14 @@ def _resume_match_from_snapshots(snapshots, checkpoint):
             return resume_iter_count, snapshots[i:]
         return None, None
 
-    def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
+    def set_tolerance(self, abs_tol: Union[None, float] = None, rel_tol: Union[None, float] = None, rmse_tol: Union[None, float] = None):
         """Update the stopping criterion's target tolerance.
 
         Args:
-            abs_tol (float): Absolute error tolerance, converted to an RMSE
+            abs_tol (Union[None, float]): Absolute error tolerance, converted to an RMSE
                 tolerance via `self.alpha`. Ignored if `rmse_tol` is supplied.
-            rel_tol (float): Unsupported; must be `None`.
-            rmse_tol (float): Root mean squared error tolerance. Takes
+            rel_tol (Union[None, float]): Unsupported; must be `None`.
+            rmse_tol (Union[None, float]): Root mean squared error tolerance. Takes
                 precedence over `abs_tol` if both are supplied.
 
         Raises:
@@ -126,7 +128,7 @@ def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
         elif abs_tol != None:
             self.rmse_tol = float(abs_tol) / norm.ppf(1 - self.alpha / 2.0)
 
-    def update_data(self, data):
+    def update_data(self, data: Data):
         """Double the sample count on every active level and refresh statistics.
 
         For each level with `data.eval_level[l]` set, doubles its replicated
diff --git a/qmcpy/stopping_criterion/abstract_cub_qmc_ld_g.py b/qmcpy/stopping_criterion/abstract_cub_qmc_ld_g.py
index bbf0a81e1..43db55b3c 100644
--- a/qmcpy/stopping_criterion/abstract_cub_qmc_ld_g.py
+++ b/qmcpy/stopping_criterion/abstract_cub_qmc_ld_g.py
@@ -1,3 +1,4 @@
+from typing import Union
 from .abstract_stopping_criterion import AbstractStoppingCriterion
 from ..util.data import Data
 
@@ -51,7 +52,7 @@ def __init__(
         allowed_distribs,
         cast_complex,
         error_fun,
-    ):
+    ) -> None:
         self.parameters = ["abs_tol", "rel_tol", "n_init", "n_limit"]
         # Input Checks
         if np.log2(n_init) % 1 != 0 or n_init < 2**8:
@@ -231,7 +232,7 @@ def _validate_resume(self, data):
                 "beta", data.beta, self.integrand.d_indv + (self.ncv,)
             )
 
-    def integrate(self, resume=None):
+    def integrate(self, resume: Union[None, Data] = None) -> tuple:
         """Determine the samples needed to satisfy the target tolerance.
 
         Doubles the sample count each iteration, updates the running fast
@@ -242,7 +243,7 @@ def integrate(self, resume=None):
         `self.n_limit` would be exceeded.
 
         Args:
-            resume (Data): Existing integration state to resume from, if
+            resume (Union[None, Data]): Existing integration state to resume from, if
                 supported. Defaults to None.
 
         Returns:
@@ -506,15 +507,15 @@ def integrate(self, resume=None):
         trace.finalize()
         return data.solution, data
 
-    def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
+    def set_tolerance(self, abs_tol: Union[None, float] = None, rel_tol: Union[None, float] = None, rmse_tol: Union[None, float] = None):
         """Update the stopping criterion's target tolerance.
 
         Args:
-            abs_tol (float): Absolute error tolerance, broadcast to
+            abs_tol (Union[None, float]): Absolute error tolerance, broadcast to
                 `self.abs_tols` with shape `integrand.d_comb`.
-            rel_tol (float): Relative error tolerance, broadcast to
+            rel_tol (Union[None, float]): Relative error tolerance, broadcast to
                 `self.rel_tols` with shape `integrand.d_comb`.
-            rmse_tol (float): Unsupported; must be `None`.
+            rmse_tol (Union[None, float]): Unsupported; must be `None`.
 
         Raises:
             AssertionError: If `rmse_tol` is supplied.
diff --git a/qmcpy/stopping_criterion/abstract_stopping_criterion.py b/qmcpy/stopping_criterion/abstract_stopping_criterion.py
index d761582b3..09f3e2d84 100644
--- a/qmcpy/stopping_criterion/abstract_stopping_criterion.py
+++ b/qmcpy/stopping_criterion/abstract_stopping_criterion.py
@@ -1,9 +1,11 @@
+from ..util.data import Data
+from typing import TYPE_CHECKING, TextIO, Union
 import copy
 import sys
-from typing import TYPE_CHECKING
 
 from .diagnostics import (  # noqa: F401
     _IterationTraceLogger,
+    _IterationHistoryTable,
     _format_iteration_log,
     _get_iteration_log_frame,
     _print_iteration_log,
@@ -78,11 +80,11 @@ def __init__(self, allowed_distribs: list, allow_vectorized_integrals: bool) ->
             self.parameters = []
         self.elapsed_time = float(getattr(self, "elapsed_time", 0.0))
 
-    def integrate(self, resume=None) -> tuple:
+    def integrate(self, resume: Union[None, Data] = None) -> tuple:
         """Determine the samples needed to satisfy the target tolerance.
 
         Args:
-            resume (Data): Existing integration state to resume from, if
+            resume (Union[None, Data]): Existing integration state to resume from, if
                 supported. A valid resume checkpoint must continue the same
                 numerical experiment without duplicating samples, losing
                 accumulated statistics, or weakening the requested tolerance
@@ -132,7 +134,7 @@ def _make_trace_logger(self) -> _IterationTraceLogger:
 
     def get_iteration_log(
         self,
-        history=None,
+        history: Union[None, list] = None,
         printed_only: bool = True,
         drop_empty_columns: bool = True,
         formatted: bool = True,
@@ -141,7 +143,7 @@ def get_iteration_log(
         """Return the latest iteration log as a pandas DataFrame.
 
         Args:
-            history (list[dict] | None): Iteration history to format. If
+            history (Union[None, list]): Iteration history to format. If
                 ``None``, uses ``self.iteration_history`` when available.
             printed_only (bool): If ``True``, include only rows that were
                 selected for printed output.
@@ -214,11 +216,11 @@ def _apply_iteration_log_view(log_df, view):
         positions = positions[positions >= 0]
         return log_df.loc[non_resume_indices[positions]].reset_index(drop=True)
 
-    def format_iteration_log(self, history=None, printed_only: bool = True, include_header: bool = True) -> str:
+    def format_iteration_log(self, history: "Union[None, _IterationHistoryTable]" = None, printed_only: bool = True, include_header: bool = True) -> str:
         """Return the iteration log as formatted text.
 
         Args:
-            history (IterationHistoryTable | None): Iteration history to
+            history (Union[None, _IterationHistoryTable]): Iteration history to
                 format. If ``None``, uses ``self.iteration_history`` when
                 available. Defaults to None.
             printed_only (bool): If ``True``, include only rows that were
@@ -238,18 +240,18 @@ def format_iteration_log(self, history=None, printed_only: bool = True, include_
             include_header=include_header,
         )
 
-    def print_iteration_log(self, history=None, printed_only: bool = True, include_header: bool = True, file=None) -> None:
+    def print_iteration_log(self, history: "Union[None, _IterationHistoryTable]" = None, printed_only: bool = True, include_header: bool = True, file: Union[None, TextIO] = None) -> None:
         """Print the iteration log for the latest run or supplied history.
 
         Args:
-            history (IterationHistoryTable | None): Iteration history to print.
+            history (Union[None, _IterationHistoryTable]): Iteration history to print.
                 If ``None``, uses ``self.iteration_history`` when available.
                 Defaults to None.
             printed_only (bool): If ``True``, print only rows that were
                 selected for printed output. Defaults to True.
             include_header (bool): If ``True``, include the trace label header
                 before the table. Defaults to True.
-            file (typing.TextIO | None): Output stream. Defaults to
+            file (Union[None, TextIO]): Output stream. Defaults to
                 ``sys.stdout`` when None.
 
         Returns:
@@ -265,7 +267,7 @@ def print_iteration_log(self, history=None, printed_only: bool = True, include_h
             file=file,
         )
 
-    def _prepare_resume_data(self, resume, validate_resume, restore_resume):
+    def _prepare_resume_data(self, resume: Data or None, validate_resume, restore_resume):
         """Validate and restore a resume checkpoint before integration.
 
         Args:
@@ -300,7 +302,7 @@ def _detach_resume_stopping_criterion_history(data):
         if hasattr(stopping_crit, "history_df"):
             stopping_crit.history_df = None
 
-    def _restore_resume_state(self, data):
+    def _restore_resume_state(self, data: Data):
         """Optional hook for subclasses to align state before resuming.
 
         Subclasses that need to restore RNG state or rewrite checkpoint fields
@@ -310,10 +312,13 @@ def _restore_resume_state(self, data):
         Args:
             data (Data): Deep-copied resume checkpoint that will be mutated by
                 the resumed integration run.
+
+        Returns:
+            None
         """
         return None
 
-    def _capture_resume_provenance(self, resume):
+    def _capture_resume_provenance(self, resume: Data or None):
         """Capture resume bookkeeping before the live ``Data`` object is
         mutated.
 
@@ -371,14 +376,14 @@ def _annotate_checkpoint_metadata(self, data):
             self.discrete_distrib
         )
 
-    def _finalize_integration_data(self, data, elapsed, resume_provenance=None):
+    def _finalize_integration_data(self, data: Data, elapsed: float, resume_provenance: Union[None, dict] = None):
         """Attach shared integration metadata before returning ``Data``.
 
         Args:
             data (Data): Integration state to finalize.
             elapsed (float): Wall-clock time spent in the current ``integrate``
                 call.
-            resume_provenance (dict or None): Output of
+            resume_provenance (Union[None, dict]): Output of
                 :meth:`_capture_resume_provenance`. Defaults to None.
         """
         data.stopping_crit = self
@@ -407,8 +412,8 @@ def _resume_value_equal(self, current, saved):
         objects.
 
         Args:
-            current: Value from the live stopping criterion.
-            saved: Value from the resume checkpoint.
+            current (Any): Value from the live stopping criterion.
+            saved (Any): Value from the resume checkpoint.
 
         Returns:
             bool: True when the two values are considered equal.
@@ -456,7 +461,7 @@ def _resume_value_equal(self, current, saved):
     def _is_sparse(value):
         return hasattr(value, "nnz") and hasattr(value, "shape")
 
-    def _require_resume_attrs(self, data, attrs):
+    def _require_resume_attrs(self, data: Data, attrs: tuple[str, ...]):
         """Raise ParameterError if any attribute in *attrs* is absent from
         *data*.
 
@@ -474,7 +479,7 @@ def _require_resume_attrs(self, data, attrs):
                 % ", ".join(sorted(missing))
             )
 
-    def _validate_resume_object(self, label, current, saved, attrs):
+    def _validate_resume_object(self, label: str, current: object, saved: object, attrs: tuple[str, ...]):
         """Validate that a saved sub-object is compatible with the current
         one.
 
@@ -483,8 +488,8 @@ def _validate_resume_object(self, label, current, saved, attrs):
 
         Args:
             label (str): Human-readable name used in error messages.
-            current: Live object (integrand, true measure, etc.).
-            saved: Saved object from the resume checkpoint.
+            current (object): Live object (integrand, true measure, etc.).
+            saved (object): Saved object from the resume checkpoint.
             attrs (tuple[str, ...]): Attribute names to compare.
 
         Raises:
@@ -511,7 +516,7 @@ def _validate_resume_object(self, label, current, saved, attrs):
                     "resume data has incompatible %s.%s." % (label, attr)
                 )
 
-    def _validate_resume_data(self, data, required_fields=()):
+    def _validate_resume_data(self, data: Data, required_fields: tuple[str, ...] =()):
         """Run standard cross-cutting resume compatibility checks.
 
         Validates stopping criterion type, integrand, true measure, discrete
@@ -553,7 +558,7 @@ def _validate_resume_data(self, data, required_fields=()):
         if int(data.n_total) > int(self.n_limit):
             raise ParameterError("resume data n_total=%d exceeds current n_limit=%d." % (int(data.n_total), int(self.n_limit)))
 
-    def _validate_resume_with_state(self, data, required_fields=(), state_fields=()):
+    def _validate_resume_with_state(self, data: Data, required_fields: tuple[str, ...] =(), state_fields: tuple[str, ...] =()):
         """Validate resume data including algorithm-specific state fields.
 
         Calls :meth:`_validate_resume_data` and additionally checks that all
@@ -617,7 +622,7 @@ def _resolve_error_fun(error_fun):
         return error_fun, _error_fun_key
 
     @staticmethod
-    def _checkpoint_rmse_tol(data):
+    def _checkpoint_rmse_tol(data: Data):
         """Extract the RMSE tolerance stored in a resume checkpoint.
 
         Args:
@@ -634,7 +639,7 @@ def _checkpoint_rmse_tol(data):
                 pass
         return None
 
-    def _init_control_variates(self, control_variates, control_variate_means):
+    def _init_control_variates(self, control_variates: list or AbstractIntegrand, control_variate_means):
         """Validate and store control variates and their means.
 
         Sets ``self.cv``, ``self.cv_mu``, and ``self.ncv`` after validating
@@ -676,7 +681,7 @@ def _init_control_variates(self, control_variates, control_variate_means):
         self.ncv = len(self.cv)
         return self.ncv
 
-    def _restore_resume_rng_state(self, data):
+    def _restore_resume_rng_state(self, data: Data):
         """Deep-copy the saved RNG state into the live discrete distribution.
 
         Ensures that samples drawn after resuming are independent of those
@@ -696,7 +701,7 @@ def _restore_resume_rng_state(self, data):
             saved_distrib.rng.bit_generator.state
         )
 
-    def _compute_indv_alphas(self, alphas_comb):
+    def _compute_indv_alphas(self, alphas_comb: np.ndarray):
         """Distribute combined confidence levels to individual integrand
         dimensions.
 
@@ -731,15 +736,15 @@ def _compute_indv_alphas(self, alphas_comb):
             alphas_indv = np.where(alpha_k_mat == 0, alphas_indv, np.minimum(alpha_k_mat, alphas_indv))
         return alphas_indv, identity_dependency
 
-    def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
+    def set_tolerance(self, abs_tol: Union[None, float] = None, rel_tol: Union[None, float] = None, rmse_tol: Union[None, float] = None):
         """Reset the tolerances.
 
         Args:
-            abs_tol (float): Absolute tolerance, when supported. If supplied,
+            abs_tol (Union[None, float]): Absolute tolerance, when supported. If supplied,
                 reset it; otherwise ignore it.
-            rel_tol (float): Relative tolerance, when supported. If supplied,
+            rel_tol (Union[None, float]): Relative tolerance, when supported. If supplied,
                 reset it; otherwise ignore it.
-            rmse_tol (float): RMSE tolerance, when supported. If supplied,
+            rmse_tol (Union[None, float]): RMSE tolerance, when supported. If supplied,
                 reset it; otherwise ignore it. If ``rmse_tol`` is not supplied
                 but ``abs_tol`` is, then ``rmse_tol = abs_tol / norm.ppf(1 -
                 alpha / 2)``.
diff --git a/qmcpy/stopping_criterion/cub_mc_clt.py b/qmcpy/stopping_criterion/cub_mc_clt.py
index 087ca27ea..bc2f9603b 100644
--- a/qmcpy/stopping_criterion/cub_mc_clt.py
+++ b/qmcpy/stopping_criterion/cub_mc_clt.py
@@ -1,3 +1,4 @@
+from typing import Union
 from .abstract_stopping_criterion import AbstractStoppingCriterion
 from ..util.data import Data
 
@@ -128,29 +129,29 @@ class CubMCCLT(AbstractStoppingCriterion):
     def __init__(
         self,
         integrand: AbstractIntegrand,
-        abs_tol: np.ndarray = 1e-2,
-        rel_tol: np.ndarray = 0.0,
+        abs_tol: Union[float, np.ndarray] = 1e-2,
+        rel_tol: Union[float, np.ndarray] = 0.0,
         n_init: int = 1024,
         n_limit: int = 2**30,
         inflate: float = 1.2,
-        alpha: np.ndarray = 0.01,
-        control_variates: list = None,
-        control_variate_means: np.ndarray = None,
+        alpha: Union[float, np.ndarray] = 0.01,
+        control_variates: Union[None, list] = None,
+        control_variate_means: Union[None, np.ndarray] = None,
     ) -> None:
         r"""Initialize a CubMCCLT stopping criterion.
 
         Args:
             integrand (AbstractIntegrand): The integrand.
-            abs_tol (np.ndarray): Absolute error tolerance.
-            rel_tol (np.ndarray): Relative error tolerance.
+            abs_tol (Union[float, np.ndarray]): Absolute error tolerance.
+            rel_tol (Union[float, np.ndarray]): Relative error tolerance.
             n_init (int): Initial number of samples.
             n_limit (int): Maximum number of samples.
             inflate (float): Inflation factor $\geq 1$ to multiply by the
                 variance estimate to make it more conservative.
-            alpha (np.ndarray): Uncertainty level in $(0,1)$.
-            control_variates (list): Integrands to use as control variates,
+            alpha (Union[float, np.ndarray]): Uncertainty level in $(0,1)$.
+            control_variates (Union[None, list]): Integrands to use as control variates,
                 each with the same underlying discrete distribution instance.
-            control_variate_means (np.ndarray): Means of each control variate.
+            control_variate_means (Union[None, np.ndarray]): Means of each control variate.
         """
         if control_variates is None:
             control_variates = []
@@ -206,7 +207,7 @@ def _get_main_stage_samples(self, data):
         ycv = np.array(data.ycvfull[:, self.n_init :], copy=False)
         return y - ((ycv - self.cv_mu[:, None]) * self.beta[:, None]).sum(0)
 
-    def integrate(self, resume=None):
+    def integrate(self, resume: Union[None, Data] = None) -> tuple:
         """Determine the samples needed to satisfy the target tolerance.
 
         Draws an initial `self.n_init` samples to estimate the standard
@@ -215,7 +216,7 @@ def integrate(self, resume=None):
         producing a symmetric confidence-interval bound on the integral.
 
         Args:
-            resume (Data): Unsupported; must be `None`, as `CubMCCLT` cannot
+            resume (Union[None, Data]): Unsupported; must be `None`, as `CubMCCLT` cannot
                 resume a prior checkpoint.
 
         Returns:
@@ -298,13 +299,13 @@ def integrate(self, resume=None):
         trace.finalize()
         return data.solution, data
 
-    def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
+    def set_tolerance(self, abs_tol: Union[None, float] = None, rel_tol: Union[None, float] = None, rmse_tol: Union[None, float] = None):
         """Update the stopping criterion's target tolerance.
 
         Args:
-            abs_tol (float): Absolute error tolerance.
-            rel_tol (float): Relative error tolerance.
-            rmse_tol (float): Unsupported; must be `None`.
+            abs_tol (Union[None, float]): Absolute error tolerance.
+            rel_tol (Union[None, float]): Relative error tolerance.
+            rmse_tol (Union[None, float]): Unsupported; must be `None`.
 
         Raises:
             AssertionError: If `rmse_tol` is supplied.
diff --git a/qmcpy/stopping_criterion/cub_mc_clt_vec.py b/qmcpy/stopping_criterion/cub_mc_clt_vec.py
index d5f00cb30..7d737954a 100644
--- a/qmcpy/stopping_criterion/cub_mc_clt_vec.py
+++ b/qmcpy/stopping_criterion/cub_mc_clt_vec.py
@@ -1,3 +1,5 @@
+from ..integrand.abstract_integrand import AbstractIntegrand
+from typing import Union, Callable
 from .abstract_stopping_criterion import AbstractStoppingCriterion
 from ..util.data import Data
 
@@ -159,24 +161,24 @@ class CubMCCLTVec(AbstractStoppingCriterion):
 
     def __init__(
         self,
-        integrand,
-        abs_tol: np.ndarray = 1e-2,
-        rel_tol: np.ndarray = 0.0,
-        n_init: int = 256.0,
+        integrand: AbstractIntegrand,
+        abs_tol: Union[float, np.ndarray] = 1e-2,
+        rel_tol: Union[float, np.ndarray] = 0.0,
+        n_init: int = 256,
         n_limit: int = 2**30,
-        error_fun="EITHER",
+        error_fun: Union[str, Callable] = "EITHER",
         inflate: float = 1,
-        alpha: np.ndarray = 0.01,
+        alpha: Union[float, np.ndarray] = 0.01,
     ) -> None:
         r"""Initialize a CubMCCLTVec stopping criterion.
 
         Args:
             integrand (AbstractIntegrand): The integrand.
-            abs_tol (np.ndarray): Absolute error tolerance.
-            rel_tol (np.ndarray): Relative error tolerance.
+            abs_tol (Union[float, np.ndarray]): Absolute error tolerance.
+            rel_tol (Union[float, np.ndarray]): Relative error tolerance.
             n_init (int): Initial number of samples.
             n_limit (int): Maximum number of samples.
-            error_fun (Union[str, callable]): Function mapping the approximate
+            error_fun (Union[str, Callable]): Function mapping the approximate
                 solution, absolute error tolerance, and relative error
                 tolerance to the current error bound.
 
@@ -192,7 +194,7 @@ def __init__(
                     ```
             inflate (float): Inflation factor $\geq 1$ to multiply by the
                 variance estimate to make it more conservative.
-            alpha (np.ndarray): Uncertainty level in $(0,1)$.
+            alpha (Union[float, np.ndarray]): Uncertainty level in $(0,1)$.
         """
         self.parameters = [
             "inflate",
@@ -264,7 +266,7 @@ def _restore_resume_state(self, data):
         self.integrand.discrete_distrib = self.discrete_distrib
         self.integrand.true_measure.discrete_distrib = self.discrete_distrib
 
-    def integrate(self, resume=None):
+    def integrate(self, resume: Union[None, Data] = None) -> tuple:
         """Determine the samples needed to satisfy the target tolerance.
 
         Doubles the sample count each iteration and forms a CLT-based
@@ -273,7 +275,7 @@ def integrate(self, resume=None):
         within tolerance or `self.n_limit` would be exceeded.
 
         Args:
-            resume (Data): Existing integration state to resume from, if
+            resume (Union[None, Data]): Existing integration state to resume from, if
                 supported. Defaults to None.
 
         Returns:
@@ -374,15 +376,15 @@ def integrate(self, resume=None):
         trace.finalize()
         return data.solution, data
 
-    def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
+    def set_tolerance(self, abs_tol: Union[None, float] = None, rel_tol: Union[None, float] = None, rmse_tol: Union[None, float] = None):
         """Update the stopping criterion's target tolerance.
 
         Args:
-            abs_tol (float): Absolute error tolerance, broadcast to
+            abs_tol (Union[None, float]): Absolute error tolerance, broadcast to
                 `self.abs_tols` with shape `integrand.d_comb`.
-            rel_tol (float): Relative error tolerance, broadcast to
+            rel_tol (Union[None, float]): Relative error tolerance, broadcast to
                 `self.rel_tols` with shape `integrand.d_comb`.
-            rmse_tol (float): Unsupported; must be `None`.
+            rmse_tol (Union[None, float]): Unsupported; must be `None`.
 
         Raises:
             AssertionError: If `rmse_tol` is supplied.
diff --git a/qmcpy/stopping_criterion/cub_mc_g.py b/qmcpy/stopping_criterion/cub_mc_g.py
index 724e100e6..a3316f84a 100644
--- a/qmcpy/stopping_criterion/cub_mc_g.py
+++ b/qmcpy/stopping_criterion/cub_mc_g.py
@@ -1,3 +1,4 @@
+from typing import Union
 from .abstract_stopping_criterion import AbstractStoppingCriterion
 from ..util.data import Data
 
@@ -254,29 +255,29 @@ class CubMCG(AbstractStoppingCriterion):
     def __init__(
         self,
         integrand: AbstractIntegrand,
-        abs_tol: np.ndarray = 1e-2,
-        rel_tol: np.ndarray = 0.0,
+        abs_tol: Union[float, np.ndarray] = 1e-2,
+        rel_tol: Union[float, np.ndarray] = 0.0,
         n_init: int = 1024,
         n_limit: int = 2**30,
         inflate: float = 1.2,
-        alpha: np.ndarray = 0.01,
-        control_variates: list = None,
-        control_variate_means: np.ndarray = None,
+        alpha: Union[float, np.ndarray] = 0.01,
+        control_variates: Union[None, list] = None,
+        control_variate_means: Union[None, np.ndarray] = None,
     ) -> None:
         r"""Initialize a CubMCG stopping criterion.
 
         Args:
             integrand (AbstractIntegrand): The integrand.
-            abs_tol (np.ndarray): Absolute error tolerance.
-            rel_tol (np.ndarray): Relative error tolerance.
+            abs_tol (Union[float, np.ndarray]): Absolute error tolerance.
+            rel_tol (Union[float, np.ndarray]): Relative error tolerance.
             n_init (int): Initial number of samples.
             n_limit (int): Maximum number of samples.
             inflate (float): Inflation factor $\geq 1$ to multiply by the
                 variance estimate to make it more conservative.
-            alpha (np.ndarray): Uncertainty level in $(0,1)$.
-            control_variates (list): Integrands to use as control variates,
+            alpha (Union[float, np.ndarray]): Uncertainty level in $(0,1)$.
+            control_variates (Union[None, list]): Integrands to use as control variates,
                 each with the same underlying discrete distribution instance.
-            control_variate_means (np.ndarray): Means of each control variate.
+            control_variate_means (Union[None, np.ndarray]): Means of each control variate.
         """
         if control_variates is None:
             control_variates = []
@@ -328,7 +329,7 @@ def _update_main_stage_solution(self, data):
         data.solution = y_main.mean()
         data.n_total = data.yfull.shape[-1]
 
-    def integrate(self, resume=None):
+    def integrate(self, resume: Union[None, Data] = None) -> tuple:
         """Determine the samples needed to satisfy the target tolerance.
 
         Draws an initial `self.n_init` samples to estimate the standard
@@ -339,7 +340,7 @@ def integrate(self, resume=None):
         tolerance or `self.n_limit` would be exceeded.
 
         Args:
-            resume (Data): Unsupported; must be `None`, as `CubMCG` cannot
+            resume (Union[None, Data]): Unsupported; must be `None`, as `CubMCG` cannot
                 resume a prior checkpoint.
 
         Returns:
@@ -553,13 +554,13 @@ def _ncbinv(self, n1, alpha1, kurtmax):
         # take the min of Chebyshev and Berry Esseen tolerance
         return eps
 
-    def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
+    def set_tolerance(self, abs_tol: Union[None, float] = None, rel_tol: Union[None, float] = None, rmse_tol: Union[None, float] = None):
         """Update the stopping criterion's target tolerance.
 
         Args:
-            abs_tol (float): Absolute error tolerance.
-            rel_tol (float): Relative error tolerance.
-            rmse_tol (float): Unsupported; must be `None`.
+            abs_tol (Union[None, float]): Absolute error tolerance.
+            rel_tol (Union[None, float]): Relative error tolerance.
+            rmse_tol (Union[None, float]): Unsupported; must be `None`.
 
         Raises:
             AssertionError: If `rmse_tol` is supplied.
@@ -572,7 +573,7 @@ def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
             self.rel_tol = rel_tol
 
 
-def _tol_fun(abs_tol, rel_tol, theta, mu, toltype):
+def _tol_fun(abs_tol: float, rel_tol: float, theta: float, mu: float, toltype: str):
     """Generalized error tolerance function.
 
     Args:
diff --git a/qmcpy/stopping_criterion/cub_mlmc.py b/qmcpy/stopping_criterion/cub_mlmc.py
index 1985cf91c..51bd57a9a 100644
--- a/qmcpy/stopping_criterion/cub_mlmc.py
+++ b/qmcpy/stopping_criterion/cub_mlmc.py
@@ -1,4 +1,7 @@
+from typing import Union
 from .abstract_cub_mlmc import AbstractCubMLMC
+from ..integrand.abstract_integrand import AbstractIntegrand
+from ..util.data import Data
 import copy
 from ..discrete_distribution import IIDStdUniform
 from ..discrete_distribution.abstract_discrete_distribution import (
@@ -75,12 +78,12 @@ class CubMLMC(AbstractCubMLMC):
 
     def __init__(
         self,
-        integrand,
-        abs_tol=0.05,
-        rmse_tol=None,
+        integrand: AbstractIntegrand,
+        abs_tol: Union[float, np.ndarray] = 0.05,
+        rmse_tol: Union[None, np.ndarray] = None,
         n_init: int = 256,
-        n_limit=1e10,
-        alpha=0.01,
+        n_limit: int = 10**10,
+        alpha: Union[float, np.ndarray] = 0.01,
         levels_min: int = 2,
         levels_max: int = 10,
         alpha0: float = -1.0,
@@ -91,13 +94,13 @@ def __init__(
 
         Args:
             integrand (AbstractIntegrand): The integrand.
-            abs_tol (np.ndarray): Absolute error tolerance.
-            rmse_tol (np.ndarray): Root mean squared error tolerance. If
+            abs_tol (Union[float, np.ndarray]): Absolute error tolerance.
+            rmse_tol (Union[None, np.ndarray]): Root mean squared error tolerance. If
                 supplied, then absolute tolerance and alpha are ignored in
                 favor of the rmse tolerance.
             n_init (int): Initial number of samples.
             n_limit (int): Maximum number of samples.
-            alpha (np.ndarray): Uncertainty level in $(0,1)$.
+            alpha (Union[float, np.ndarray]): Uncertainty level in $(0,1)$.
             levels_min (int): Minimum level of refinement $\geq 2$.
             levels_max (int): Maximum level of refinement $\geq$ `levels_min`.
             alpha0 (float): Weak error is $\mathcal{O}(2^{-\alpha_0\ell})$ in
@@ -272,11 +275,11 @@ def _replay_resume_exactly(self, checkpoint, t_start=None, resume_provenance=Non
                 delattr(shadow, attr)
         return shadow, snapshots[absorb_index:], replay_iter_count
 
-    def integrate(self, resume=None) -> tuple:
+    def integrate(self, resume: Union[None, Data] = None) -> tuple:
         """Run (or continue) the MLMC integration.
 
         Args:
-            resume (Data): Checkpoint returned by a previous ``integrate()``
+            resume (Union[None, Data]): Checkpoint returned by a previous ``integrate()``
                 call.  The new tolerance may be tighter *or* looser than the
                 one used when the checkpoint was created. With a tighter
                 tolerance the algorithm draws additional samples from where it
diff --git a/qmcpy/stopping_criterion/cub_mlmc_cont.py b/qmcpy/stopping_criterion/cub_mlmc_cont.py
index 30ad4cc86..174bad204 100644
--- a/qmcpy/stopping_criterion/cub_mlmc_cont.py
+++ b/qmcpy/stopping_criterion/cub_mlmc_cont.py
@@ -1,4 +1,7 @@
+from typing import Union
 from .abstract_cub_mlmc import AbstractCubMLMC
+from ..integrand.abstract_integrand import AbstractIntegrand
+from ..util.data import Data
 import copy
 from ..discrete_distribution import IIDStdUniform
 from ..discrete_distribution.abstract_discrete_distribution import (
@@ -74,13 +77,13 @@ class CubMLMCCont(AbstractCubMLMC):
 
     def __init__(
         self,
-        integrand,
-        abs_tol=0.05,
-        rmse_tol=None,
+        integrand: AbstractIntegrand,
+        abs_tol: Union[float, np.ndarray] = 0.05,
+        rmse_tol: Union[None, np.ndarray] = None,
         n_init: int = 256,
-        n_limit=1e10,
+        n_limit: int = 10**10,
         inflate: float = 100 ** (1 / 9),
-        alpha=0.01,
+        alpha: Union[float, np.ndarray] = 0.01,
         levels_min: int = 2,
         levels_max: int = 10,
         n_tols: int = 10,
@@ -90,14 +93,14 @@ def __init__(
 
         Args:
             integrand (AbstractIntegrand): The integrand.
-            abs_tol (np.ndarray): Absolute error tolerance.
-            rmse_tol (np.ndarray): Root mean squared error tolerance. If
+            abs_tol (Union[float, np.ndarray]): Absolute error tolerance.
+            rmse_tol (Union[None, np.ndarray]): Root mean squared error tolerance. If
                 supplied, then absolute tolerance and alpha are ignored in
                 favor of the rmse tolerance.
             n_init (int): Initial number of samples.
             n_limit (int): Maximum number of samples.
             inflate (float): Coarser tolerance multiplication factor $\geq 1$.
-            alpha (np.ndarray): Uncertainty level in $(0,1)$.
+            alpha (Union[float, np.ndarray]): Uncertainty level in $(0,1)$.
             levels_min (int): Minimum level of refinement $\geq 2$.
             levels_max (int): Maximum level of refinement $\geq$ `levels_min`.
             n_tols (int): Number of coarser tolerances to run.
@@ -165,11 +168,11 @@ def _can_replay_resume_exactly(self, data):
             return False
         return hasattr(data, "level_diffs") and len(data.level_diffs) == len(data.n_level)
 
-    def integrate(self, resume=None) -> tuple:
+    def integrate(self, resume: Union[None, Data] = None) -> tuple:
         """Run (or continue) the continuation-MLMC integration.
 
         Args:
-            resume (Data): Checkpoint returned by a previous ``integrate()``
+            resume (Union[None, Data]): Checkpoint returned by a previous ``integrate()``
                 call.  The new tolerance may be tighter *or* looser than the
                 one used when the checkpoint was created. With a tighter
                 tolerance the algorithm picks up the tolerance ladder from
diff --git a/qmcpy/stopping_criterion/cub_mlqmc.py b/qmcpy/stopping_criterion/cub_mlqmc.py
index e474b49eb..177848db0 100644
--- a/qmcpy/stopping_criterion/cub_mlqmc.py
+++ b/qmcpy/stopping_criterion/cub_mlqmc.py
@@ -1,4 +1,6 @@
+from typing import Union
 from .abstract_cub_mlqmc import AbstractCubMLQMC
+from ..integrand.abstract_integrand import AbstractIntegrand
 from ..util.data import Data
 import copy
 from ..discrete_distribution import DigitalNetB2, Lattice, Halton
@@ -78,12 +80,12 @@ class CubMLQMC(AbstractCubMLQMC):
 
     def __init__(
         self,
-        integrand,
-        abs_tol=0.05,
-        rmse_tol=None,
+        integrand: AbstractIntegrand,
+        abs_tol: Union[float, np.ndarray] = 0.05,
+        rmse_tol: Union[None, np.ndarray] = None,
         n_init: int = 256,
-        n_limit=1e10,
-        alpha=0.01,
+        n_limit: int = 10**10,
+        alpha: Union[float, np.ndarray] = 0.01,
         levels_min: int = 2,
         levels_max: int = 10,
     ) -> None:
@@ -91,13 +93,13 @@ def __init__(
 
         Args:
             integrand (AbstractIntegrand): The integrand.
-            abs_tol (np.ndarray): Absolute error tolerance.
-            rmse_tol (np.ndarray): Root mean squared error tolerance. If
+            abs_tol (Union[float, np.ndarray]): Absolute error tolerance.
+            rmse_tol (Union[None, np.ndarray]): Root mean squared error tolerance. If
                 supplied, then absolute tolerance and alpha are ignored in
                 favor of the rmse tolerance.
             n_init (int): Initial number of samples.
             n_limit (int): Maximum number of samples.
-            alpha (np.ndarray): Uncertainty level in $(0,1)$.
+            alpha (Union[float, np.ndarray]): Uncertainty level in $(0,1)$.
             levels_min (int): Minimum level of refinement $\geq 2$.
             levels_max (int): Maximum level of refinement $\geq$ `levels_min`.
         """
@@ -222,11 +224,11 @@ def _run_integrate_loop(
                 break
         return snapshots
 
-    def integrate(self, resume=None) -> tuple:
+    def integrate(self, resume: Union[None, Data] = None) -> tuple:
         """Run (or continue) the MLQMC integration.
 
         Args:
-            resume (Data): Checkpoint returned by a previous ``integrate()``
+            resume (Union[None, Data]): Checkpoint returned by a previous ``integrate()``
                 call.  The new tolerance may be tighter *or* looser than the
                 one used when the checkpoint was created. With a tighter
                 tolerance the algorithm draws additional samples from where it
diff --git a/qmcpy/stopping_criterion/cub_mlqmc_cont.py b/qmcpy/stopping_criterion/cub_mlqmc_cont.py
index ac6385094..3a1f71cef 100644
--- a/qmcpy/stopping_criterion/cub_mlqmc_cont.py
+++ b/qmcpy/stopping_criterion/cub_mlqmc_cont.py
@@ -1,4 +1,6 @@
+from typing import Union
 from .abstract_cub_mlqmc import AbstractCubMLQMC
+from ..integrand.abstract_integrand import AbstractIntegrand
 from ..util.data import Data
 import copy
 from ..discrete_distribution import DigitalNetB2, Lattice, Halton
@@ -81,13 +83,13 @@ class CubMLQMCCont(AbstractCubMLQMC):
 
     def __init__(
         self,
-        integrand,
-        abs_tol=0.05,
-        rmse_tol=None,
+        integrand: AbstractIntegrand,
+        abs_tol: Union[float, np.ndarray] = 0.05,
+        rmse_tol: Union[None, np.ndarray] = None,
         n_init: int = 256,
-        n_limit=1e10,
+        n_limit: int = 10**10,
         inflate: float = 100 ** (1 / 9),
-        alpha=0.01,
+        alpha: Union[float, np.ndarray] = 0.01,
         levels_min: int = 2,
         levels_max: int = 10,
         n_tols: int = 10,
@@ -97,14 +99,14 @@ def __init__(
 
         Args:
             integrand (AbstractIntegrand): The integrand.
-            abs_tol (np.ndarray): Absolute error tolerance.
-            rmse_tol (np.ndarray): Root mean squared error tolerance. If
+            abs_tol (Union[float, np.ndarray]): Absolute error tolerance.
+            rmse_tol (Union[None, np.ndarray]): Root mean squared error tolerance. If
                 supplied, then absolute tolerance and alpha are ignored in
                 favor of the rmse tolerance.
             n_init (int): Initial number of samples.
             n_limit (int): Maximum number of samples.
             inflate (float): Coarser tolerance multiplication factor $\geq 1$.
-            alpha (np.ndarray): Uncertainty level in $(0,1)$.
+            alpha (Union[float, np.ndarray]): Uncertainty level in $(0,1)$.
             levels_min (int): Minimum level of refinement $\geq 2$.
             levels_max (int): Maximum level of refinement $\geq$ `levels_min`.
             n_tols (int): Number of coarser tolerances to run.
@@ -173,11 +175,11 @@ def _can_replay_resume_exactly(self, data):
             return False
         return hasattr(data, "level_rep_sums") and hasattr(data, "level_n_increments")
 
-    def integrate(self, resume=None) -> tuple:
+    def integrate(self, resume: Union[None, Data] = None) -> tuple:
         """Run (or continue) the continuation-MLQMC integration.
 
         Args:
-            resume (Data): Checkpoint returned by a previous ``integrate()``
+            resume (Union[None, Data]): Checkpoint returned by a previous ``integrate()``
                 call.  The new tolerance may be tighter *or* looser than the
                 one used when the checkpoint was created. With a tighter
                 tolerance the algorithm picks up the tolerance ladder from
diff --git a/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py b/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py
index ef2261f52..f25b0ff95 100644
--- a/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py
+++ b/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py
@@ -1,3 +1,5 @@
+from ..integrand.abstract_integrand import AbstractIntegrand
+from typing import Union, Callable
 from .abstract_cub_bayes_ld_g import AbstractCubBayesLDG
 from ..discrete_distribution import Lattice
 from ..integrand import Keister, BoxIntegral, Genz, SensitivityIndices
@@ -182,13 +184,13 @@ class CubQMCBayesLatticeG(AbstractCubBayesLDG):
 
     def __init__(
         self,
-        integrand,
-        abs_tol: np.ndarray = 1e-2,
-        rel_tol: np.ndarray = 0,
+        integrand: AbstractIntegrand,
+        abs_tol: Union[float, np.ndarray] = 1e-2,
+        rel_tol: Union[float, np.ndarray] = 0,
         n_init: int = 2**8,
         n_limit: int = 2**22,
-        error_fun="EITHER",
-        alpha: np.ndarray = 0.01,
+        error_fun: Union[str, Callable] = "EITHER",
+        alpha: Union[float, np.ndarray] = 0.01,
         ptransform: str = "C1SIN",
         errbd_type: str = "MLE",
         order: int = 2,
@@ -197,11 +199,11 @@ def __init__(
 
         Args:
             integrand (AbstractIntegrand): The integrand.
-            abs_tol (np.ndarray): Absolute error tolerance.
-            rel_tol (np.ndarray): Relative error tolerance.
+            abs_tol (Union[float, np.ndarray]): Absolute error tolerance.
+            rel_tol (Union[float, np.ndarray]): Relative error tolerance.
             n_init (int): Initial number of samples.
             n_limit (int): Maximum number of samples.
-            error_fun (Union[str, callable]): Function mapping the approximate
+            error_fun (Union[str, Callable]): Function mapping the approximate
                 solution, absolute error tolerance, and relative error
                 tolerance to the current error bound.
 
@@ -215,7 +217,7 @@ def __init__(
                     ```python
                     error_fun = lambda sv,abs_tol,rel_tol: np.minimum(abs_tol,abs(sv)*rel_tol)
                     ```
-            alpha (np.ndarray): Uncertainty level in $(0,1)$.
+            alpha (Union[float, np.ndarray]): Uncertainty level in $(0,1)$.
             ptransform (str): Periodization transform, see the options in
                 `AbstractIntegrand.f`.
             errbd_type (str): Options are
diff --git a/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py b/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py
index 52c811f58..1c002da82 100644
--- a/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py
+++ b/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py
@@ -1,3 +1,5 @@
+from ..integrand.abstract_integrand import AbstractIntegrand
+from typing import Union, Callable
 from .abstract_cub_bayes_ld_g import AbstractCubBayesLDG
 from ..discrete_distribution import DigitalNetB2
 from ..integrand import Keister, BoxIntegral, Genz, SensitivityIndices
@@ -191,24 +193,24 @@ class CubQMCBayesNetG(AbstractCubBayesLDG):
 
     def __init__(
         self,
-        integrand,
-        abs_tol: np.ndarray = 1e-2,
-        rel_tol: np.ndarray = 0,
+        integrand: AbstractIntegrand,
+        abs_tol: Union[float, np.ndarray] = 1e-2,
+        rel_tol: Union[float, np.ndarray] = 0,
         n_init: int = 2**8,
         n_limit: int = 2**22,
-        error_fun="EITHER",
-        alpha: np.ndarray = 0.01,
+        error_fun: Union[str, Callable] = "EITHER",
+        alpha: Union[float, np.ndarray] = 0.01,
         errbd_type: str = "MLE",
     ) -> None:
         r"""Initialize a CubQMCBayesNetG stopping criterion.
 
         Args:
             integrand (AbstractIntegrand): The integrand.
-            abs_tol (np.ndarray): Absolute error tolerance.
-            rel_tol (np.ndarray): Relative error tolerance.
+            abs_tol (Union[float, np.ndarray]): Absolute error tolerance.
+            rel_tol (Union[float, np.ndarray]): Relative error tolerance.
             n_init (int): Initial number of samples.
             n_limit (int): Maximum number of samples.
-            error_fun (Union[str, callable]): Function mapping the approximate
+            error_fun (Union[str, Callable]): Function mapping the approximate
                 solution, absolute error tolerance, and relative error
                 tolerance to the current error bound.
 
@@ -222,7 +224,7 @@ def __init__(
                     ```python
                     error_fun = lambda sv,abs_tol,rel_tol: np.minimum(abs_tol,abs(sv)*rel_tol)
                     ```
-            alpha (np.ndarray): Uncertainty level in $(0,1)$.
+            alpha (Union[float, np.ndarray]): Uncertainty level in $(0,1)$.
             errbd_type (str): Options are
 
                 - `'MLE'`: Marginal Log Likelihood.
@@ -300,7 +302,7 @@ def _shift_inv_kernel_digital(
         return vec_lambda, vec_lambda_ring, lambda_factor
 
     @staticmethod
-    def BuildKernelFunc(order):
+    def BuildKernelFunc(order: int) -> Callable:
         """Build a 1-D high-order Walsh kernel function.
 
         Args:
@@ -308,7 +310,7 @@ def BuildKernelFunc(order):
                 1, 2, or 3.
 
         Returns:
-            callable: Function mapping an array of 1-D coordinates to the
+            Callable: Function mapping an array of 1-D coordinates to the
                 corresponding Walsh kernel values.
 
         Raises:
diff --git a/qmcpy/stopping_criterion/cub_qmc_lattice_g.py b/qmcpy/stopping_criterion/cub_qmc_lattice_g.py
index d4a419825..229e13960 100644
--- a/qmcpy/stopping_criterion/cub_qmc_lattice_g.py
+++ b/qmcpy/stopping_criterion/cub_qmc_lattice_g.py
@@ -1,3 +1,5 @@
+from ..integrand.abstract_integrand import AbstractIntegrand
+from typing import Union, Callable
 from .abstract_cub_qmc_ld_g import AbstractCubQMCLDG, _default_fudge
 from ..discrete_distribution import Lattice
 from ..true_measure import Gaussian, Uniform
@@ -175,13 +177,13 @@ class CubQMCLatticeG(AbstractCubQMCLDG):
 
     def __init__(
         self,
-        integrand,
-        abs_tol: np.ndarray = 1e-2,
-        rel_tol: np.ndarray = 0.0,
+        integrand: AbstractIntegrand,
+        abs_tol: Union[float, np.ndarray] = 1e-2,
+        rel_tol: Union[float, np.ndarray] = 0.0,
         n_init: int = 2**10,
         n_limit: int = 2**30,
-        error_fun="EITHER",
-        fudge=_default_fudge,
+        error_fun: Union[str, Callable] = "EITHER",
+        fudge: Callable = _default_fudge,
         check_cone: bool = False,
         ptransform: str = "BAKER",
     ) -> None:
@@ -189,11 +191,11 @@ def __init__(
 
         Args:
             integrand (AbstractIntegrand): The integrand.
-            abs_tol (np.ndarray): Absolute error tolerance.
-            rel_tol (np.ndarray): Relative error tolerance.
+            abs_tol (Union[float, np.ndarray]): Absolute error tolerance.
+            rel_tol (Union[float, np.ndarray]): Relative error tolerance.
             n_init (int): Initial number of samples.
             n_limit (int): Maximum number of samples.
-            error_fun (Union[str, callable]): Function mapping the approximate
+            error_fun (Union[str, Callable]): Function mapping the approximate
                 solution, absolute error tolerance, and relative error
                 tolerance to the current error bound.
 
@@ -207,7 +209,7 @@ def __init__(
                     ```python
                     error_fun = lambda sv,abs_tol,rel_tol: np.minimum(abs_tol,abs(sv)*rel_tol)
                     ```
-            fudge (function): Positive function multiplying the finite sum of
+            fudge (Callable): Positive function multiplying the finite sum of
                 the Fourier coefficients specified in the cone of functions.
             check_cone (bool): Whether or not to check if the function falls in
                 the cone.
diff --git a/qmcpy/stopping_criterion/cub_qmc_net_g.py b/qmcpy/stopping_criterion/cub_qmc_net_g.py
index 6a6dea801..aa210e319 100644
--- a/qmcpy/stopping_criterion/cub_qmc_net_g.py
+++ b/qmcpy/stopping_criterion/cub_qmc_net_g.py
@@ -1,3 +1,5 @@
+from ..integrand.abstract_integrand import AbstractIntegrand
+from typing import Union, Callable
 from .abstract_cub_qmc_ld_g import AbstractCubQMCLDG, _default_fudge
 from ..fast_transform import fwht, omega_fwht
 from ..util import ParameterError
@@ -217,27 +219,27 @@ class CubQMCNetG(AbstractCubQMCLDG):
 
     def __init__(
         self,
-        integrand,
-        abs_tol: np.ndarray = 1e-2,
-        rel_tol: np.ndarray = 0.0,
+        integrand: AbstractIntegrand,
+        abs_tol: Union[float, np.ndarray] = 1e-2,
+        rel_tol: Union[float, np.ndarray] = 0.0,
         n_init: int = 2**10,
         n_limit: int = 2**35,
-        error_fun="EITHER",
-        fudge=_default_fudge,
+        error_fun: Union[str, Callable] = "EITHER",
+        fudge: Callable = _default_fudge,
         check_cone: bool = False,
-        control_variates: list = None,
-        control_variate_means: np.ndarray = None,
+        control_variates: Union[None, list] = None,
+        control_variate_means: Union[None, np.ndarray] = None,
         update_cv_coeffs: bool = False,
     ) -> None:
         r"""Initialize a CubQMCNetG stopping criterion.
 
         Args:
             integrand (AbstractIntegrand): The integrand.
-            abs_tol (np.ndarray): Absolute error tolerance.
-            rel_tol (np.ndarray): Relative error tolerance.
+            abs_tol (Union[float, np.ndarray]): Absolute error tolerance.
+            rel_tol (Union[float, np.ndarray]): Relative error tolerance.
             n_init (int): Initial number of samples.
             n_limit (int): Maximum number of samples.
-            error_fun (Union[str, callable]): Function mapping the approximate
+            error_fun (Union[str, Callable]): Function mapping the approximate
                 solution, absolute error tolerance, and relative error
                 tolerance to the current error bound.
 
@@ -251,13 +253,13 @@ def __init__(
                     ```python
                     error_fun = lambda sv,abs_tol,rel_tol: np.minimum(abs_tol,abs(sv)*rel_tol)
                     ```
-            fudge (function): Positive function multiplying the finite sum of
+            fudge (Callable): Positive function multiplying the finite sum of
                 the Fourier coefficients specified in the cone of functions.
             check_cone (bool): Whether or not to check if the function falls in
                 the cone.
-            control_variates (list): Integrands to use as control variates,
+            control_variates (Union[None, list]): Integrands to use as control variates,
                 each with the same underlying discrete distribution instance.
-            control_variate_means (np.ndarray): Means of each control variate.
+            control_variate_means (Union[None, np.ndarray]): Means of each control variate.
             update_cv_coeffs (bool): If set to true, the control variate
                 coefficients are recomputed at each iteration. Otherwise they
                 are estimated once after the initial sampling and then fixed.
diff --git a/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py b/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py
index ab9c4c7e0..e54bbb021 100644
--- a/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py
+++ b/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py
@@ -1,3 +1,5 @@
+from ..integrand.abstract_integrand import AbstractIntegrand
+from typing import Union, Callable
 from .abstract_stopping_criterion import AbstractStoppingCriterion
 from ..util.data import Data
 from ..discrete_distribution import DigitalNetB2
@@ -204,24 +206,24 @@ class CubQMCRepStudentT(AbstractStoppingCriterion):
 
     def __init__(
         self,
-        integrand,
-        abs_tol: np.ndarray = 1e-2,
-        rel_tol: np.ndarray = 0.0,
-        n_init: int = 256.0,
+        integrand: AbstractIntegrand,
+        abs_tol: Union[float, np.ndarray] = 1e-2,
+        rel_tol: Union[float, np.ndarray] = 0.0,
+        n_init: int = 256,
         n_limit: int = 2**30,
-        error_fun="EITHER",
+        error_fun: Union[str, Callable] = "EITHER",
         inflate: float = 1,
-        alpha: np.ndarray = 0.01,
+        alpha: Union[float, np.ndarray] = 0.01,
     ) -> None:
         r"""Initialize a CubQMCRepStudentT stopping criterion.
 
         Args:
             integrand (AbstractIntegrand): The integrand.
-            abs_tol (np.ndarray): Absolute error tolerance.
-            rel_tol (np.ndarray): Relative error tolerance.
+            abs_tol (Union[float, np.ndarray]): Absolute error tolerance.
+            rel_tol (Union[float, np.ndarray]): Relative error tolerance.
             n_init (int): Initial number of samples.
             n_limit (int): Maximum number of samples.
-            error_fun (Union[str, callable]): Function mapping the approximate
+            error_fun (Union[str, Callable]): Function mapping the approximate
                 solution, absolute error tolerance, and relative error
                 tolerance to the current error bound.
 
@@ -237,7 +239,7 @@ def __init__(
                     ```
             inflate (float): Inflation factor $\geq 1$ to multiply by the
                 variance estimate to make it more conservative.
-            alpha (np.ndarray): Uncertainty level in $(0,1)$.
+            alpha (Union[float, np.ndarray]): Uncertainty level in $(0,1)$.
         """
         self.parameters = ["inflate", "alpha", "abs_tol", "rel_tol", "n_init", "n_limit"]
         # Input Checks
@@ -298,7 +300,7 @@ def __init__(
             self.alphas_indv / 2, df=self.integrand.discrete_distrib.replications - 1
         )
 
-    def integrate(self, resume=None):
+    def integrate(self, resume: Union[None, Data] = None) -> tuple:
         """Determine the samples needed to satisfy the target tolerance.
 
         Doubles the per-replication sample count each iteration and forms a
@@ -309,7 +311,7 @@ def integrate(self, resume=None):
         `self.n_limit` would be exceeded.
 
         Args:
-            resume (Data): Existing integration state to resume from, if
+            resume (Union[None, Data]): Existing integration state to resume from, if
                 supported. Defaults to None.
 
         Returns:
@@ -451,15 +453,15 @@ def _restore_resume_state(self, data):
         self.integrand.discrete_distrib = self.discrete_distrib
         self.integrand.true_measure.discrete_distrib = self.discrete_distrib
 
-    def set_tolerance(self, abs_tol=None, rel_tol=None, rmse_tol=None):
+    def set_tolerance(self, abs_tol: Union[None, float] = None, rel_tol: Union[None, float] = None, rmse_tol: Union[None, float] = None):
         """Update the stopping criterion's target tolerance.
 
         Args:
-            abs_tol (float): Absolute error tolerance, broadcast to
+            abs_tol (Union[None, float]): Absolute error tolerance, broadcast to
                 `self.abs_tols` with shape `integrand.d_comb`.
-            rel_tol (float): Relative error tolerance, broadcast to
+            rel_tol (Union[None, float]): Relative error tolerance, broadcast to
                 `self.rel_tols` with shape `integrand.d_comb`.
-            rmse_tol (float): Unsupported; must be `None`.
+            rmse_tol (Union[None, float]): Unsupported; must be `None`.
 
         Raises:
             AssertionError: If `rmse_tol` is supplied.
diff --git a/qmcpy/stopping_criterion/diagnostics.py b/qmcpy/stopping_criterion/diagnostics.py
index cea58a0df..aaa1fd08a 100644
--- a/qmcpy/stopping_criterion/diagnostics.py
+++ b/qmcpy/stopping_criterion/diagnostics.py
@@ -1,5 +1,6 @@
 """Diagnostics helpers for stopping-criterion iteration tracing."""
 
+from typing import Union
 import io
 import numpy as np
 import sys
@@ -454,7 +455,8 @@ def __init__(self, stopping_criterion):
         """Create a trace logger bound to the given stopping criterion.
 
         Args:
-            stopping_criterion: Stopping criterion instance. The logger reads
+            stopping_criterion (AbstractStoppingCriterion): Stopping
+                criterion instance. The logger reads
                 the optional attributes ``trace_iterations`` (bool),
                 ``trace_label`` (str), ``verbose`` (bool), ``trace_print``
                 (bool), and the internal ``_trace_store_*`` flags to configure
@@ -522,7 +524,7 @@ def _would_be_throttled(self, iter_count):
         return iter_count % step != 0
 
     @staticmethod
-    def _state_signature(data):
+    def _state_signature(data: object):
         """Return a hashable snapshot of the data fields used to detect
         duplicate rows.
 
@@ -546,7 +548,7 @@ def _print_header_once(self):
             print(f"=== {self.label} iteration log ===")
             self.header_printed = True
 
-    def _get_visible_columns(self, data, row=None):
+    def _get_visible_columns(self, data: object, row: Union[None, dict] = None):
         """Return the ordered list of column names to display, inferred from
         data.
 
@@ -556,6 +558,8 @@ def _get_visible_columns(self, data, row=None):
         Args:
             data (object): Integration state object used to determine which
                 optional columns are present.
+            row (Union[None, dict]): Pre-extracted diagnostic row to infer columns from,
+                if already available. Computed from `data` when `None`.
 
         Returns:
             tuple[str, ...]: Column names from the set ``{'stage', 'iter', 'solution',
@@ -568,19 +572,22 @@ def _get_visible_columns(self, data, row=None):
         self.visible_columns = _visible_columns_from_row(row)
         return self.visible_columns
 
-    def emit(self, stage, data, step_value=None, increment=False, iter_value=None):
+    def emit(self, stage: str, data: object, step_value: Union[None, int] = None, increment: bool = False, iter_value: Union[None, int] = None):
         """Print one diagnostic row for the given stage label.
 
         Args:
             stage (str): Row label, e.g. ``"ITER"`` or ``"RESUME"``.
             data (object): Integration state object.
-            step_value (int | None): Value to assign to ``data.m`` before
+            step_value (Union[None, int]): Value to assign to ``data.m`` before
                 printing. Defaults to None.
             increment (bool): If True, advance the internal iteration counter
                 and assign the new value to ``data._iter_count``. Defaults to
                 False.
-            iter_value (int | None): Explicit iteration count to display
+            iter_value (Union[None, int]): Explicit iteration count to display
                 (overrides ``increment``). Defaults to None.
+
+        Returns:
+            None
         """
         if not self.enabled:
             return
@@ -625,7 +632,7 @@ def emit(self, stage, data, step_value=None, increment=False, iter_value=None):
             )
             self.table_header_printed = True
 
-    def resume(self, data, step_value=None):
+    def resume(self, data: object, step_value: Union[None, int] = None):
         """Emit a RESUME row and snapshot the current state for duplicate
         suppression.
 
@@ -636,7 +643,7 @@ def resume(self, data, step_value=None):
 
         Args:
             data (object): Integration state object from the resume checkpoint.
-            step_value (int | None): Value to assign to ``data.m`` before
+            step_value (Union[None, int]): Value to assign to ``data.m`` before
                 printing. Defaults to None.
         """
         self._seed_history_from_resume(data)
@@ -670,7 +677,7 @@ def _seed_history_from_resume(self, data):
         self.stopping_criterion.iteration_history = self.history
         self._resume_seeded = True
 
-    def iteration(self, data, step_value=None):
+    def iteration(self, data: object, step_value: Union[None, int] = None):
         """Emit an ITER row, unless state is unchanged since the last resume.
 
         If :meth:`resume` was just called and the data state has not changed
@@ -679,8 +686,11 @@ def iteration(self, data, step_value=None):
 
         Args:
             data (object): Current integration state object.
-            step_value (int | None): Value to assign to ``data.m`` before
+            step_value (Union[None, int]): Value to assign to ``data.m`` before
                 printing. Defaults to None.
+
+        Returns:
+            None
         """
         current_signature = self._state_signature(data)
         if (
@@ -742,11 +752,11 @@ def finalize(self):
 
 
 def _print_diagnostic(
-    label,
-    data,
-    table_header=False,
-    verbose=True,
-    visible_columns=None,
+    label: str,
+    data: object,
+    table_header: bool = False,
+    verbose: bool = True,
+    visible_columns: Union[None, tuple, list] = None,
 ):
     """Print diagnostic information for an integration state.
 
@@ -758,8 +768,11 @@ def _print_diagnostic(
             the row. Defaults to False.
         verbose (bool): Whether to print every ``ITER`` row. Defaults to True.
             If False, the current iteration-log throttling rules are applied.
-        visible_columns (tuple[str, ...] | list[str] | None): Ordered columns
+        visible_columns (Union[None, tuple, list]): Ordered columns
             to print. Defaults to all supported columns.
+
+    Returns:
+        None
     """
     row = _extract_diagnostic_row(data)
     iter_display = row["iter"]
diff --git a/qmcpy/stopping_criterion/pf_gp_ci.py b/qmcpy/stopping_criterion/pf_gp_ci.py
index 0e69a4a59..79a4e72c1 100644
--- a/qmcpy/stopping_criterion/pf_gp_ci.py
+++ b/qmcpy/stopping_criterion/pf_gp_ci.py
@@ -1,3 +1,7 @@
+from __future__ import annotations
+
+from ..integrand.abstract_integrand import AbstractIntegrand
+from typing import TYPE_CHECKING, Union, Callable
 from .abstract_stopping_criterion import AbstractStoppingCriterion
 from ..discrete_distribution import DigitalNetB2
 from ..integrand.ishigami import Ishigami
@@ -17,6 +21,9 @@
 import torch
 import gpytorch
 
+if TYPE_CHECKING:
+    import matplotlib.figure
+
 
 class Suggester(object):
     """Base class for future-sample suggestion schemes used by `PFGPCI`.
@@ -40,7 +47,7 @@ def __init__(self, verbose=False) -> None:
         self.verbose = verbose
         super(PFSampleErrorDensityAR, self).__init__()
 
-    def suggest(self, n, d, gp, rng, efficiency, pct=0.5):
+    def suggest(self, n: int, d: int, gp: ExactGPyTorchRegressionModel, rng: np.random.Generator, efficiency: float, pct: float = 0.5) -> np.ndarray:
         """Draw `n` new sample locations via acceptance-rejection.
 
         Args:
@@ -48,7 +55,7 @@ def suggest(self, n, d, gp, rng, efficiency, pct=0.5):
             d (int): Dimension of the sampling domain.
             gp (ExactGPyTorchRegressionModel): Current GP surrogate, used to
                 evaluate the error density at candidate points.
-            rng (numpy.random.Generator): Random number generator for
+            rng (np.random.Generator): Random number generator for
                 candidate draws.
             efficiency (float): Estimated acceptance rate, used to size each
                 batch of candidate draws.
@@ -100,7 +107,7 @@ def __init__(self, sampler) -> None:
         self.n_min = 0
         super(SuggesterSimple, self).__init__()
 
-    def suggest(self, n, d, gp, rng, **kwargs):
+    def suggest(self, n: int, d: int, gp: ExactGPyTorchRegressionModel, rng: np.random.Generator, **kwargs) -> np.ndarray:
         """Draw the next `n` sample locations from `self.sampler`.
 
         Args:
@@ -110,7 +117,7 @@ def suggest(self, n, d, gp, rng, **kwargs):
             gp (ExactGPyTorchRegressionModel): Unused; accepted for
                 interface compatibility with other `Suggester`
                 implementations.
-            rng (numpy.random.Generator): Unused; accepted for interface
+            rng (np.random.Generator): Unused; accepted for interface
                 compatibility with other `Suggester` implementations.
             **kwargs: Unused; accepted for interface compatibility with
                 other `Suggester` implementations.
@@ -219,15 +226,15 @@ class PFGPCI(AbstractStoppingCriterion):
 
     def __init__(
         self,
-        integrand,
+        integrand: AbstractIntegrand,
         failure_threshold: float,
         failure_above_threshold: bool,
         abs_tol: float = 5e-3,
         n_init: float = 64,
         n_limit: int = 1000,
         alpha: float = 1e-2,
-        init_samples: float = None,
-        batch_sampler=PFSampleErrorDensityAR(),
+        init_samples: Union[None, float] = None,
+        batch_sampler: Union[Suggester, AbstractDiscreteDistribution] = PFSampleErrorDensityAR(),
         n_batch: int = 4,
         n_approx: int = 2**20,
         gpytorch_prior_mean: gpytorch.means = gpytorch.means.ZeroMean(),
@@ -237,17 +244,17 @@ def __init__(
         gpytorch_likelihood: gpytorch.likelihoods = gpytorch.likelihoods.GaussianLikelihood(
             noise_constraint=gpytorch.constraints.Interval(1e-12, 1e-8)
         ),
-        gpytorch_marginal_log_likelihood_func=lambda likelihood, gpyt_model: gpytorch.mlls.ExactMarginalLogLikelihood(
+        gpytorch_marginal_log_likelihood_func: Callable = lambda likelihood, gpyt_model: gpytorch.mlls.ExactMarginalLogLikelihood(
             likelihood, gpyt_model
         ),
-        torch_optimizer_func=lambda gpyt_model: torch.optim.Adam(
+        torch_optimizer_func: Callable = lambda gpyt_model: torch.optim.Adam(
             gpyt_model.parameters(), lr=0.1
         ),
         gpytorch_train_iter: int = 100,
         gpytorch_use_gpu: bool = False,
-        verbose: int = False,
+        verbose: Union[bool, int] = False,
         n_ref_approx: int = 2**22,
-        seed_ref_approx: int = None,
+        seed_ref_approx: Union[None, int] = None,
     ) -> None:
         """Initialize a PFGPCI stopping criterion.
 
@@ -263,15 +270,15 @@ def __init__(
                 integrand.discrete_distrib from which to build the first
                 surrogate GP
             n_limit (int): Budget of simulations.
-            n_batch (int): The number of samples per batch to draw from
-                batch_sampler.
             alpha (float): The credible interval is constructed to hold with
                 probability at least 1 - alpha
-            init_samples (float): If the simulation has already been run, pass
+            init_samples (Union[None, float]): If the simulation has already been run, pass
                 in (x,y) where x are past samples from the discrete
                 distribution and y are corresponding simulation evaluations.
-            batch_sampler (Suggester or AbstractDiscreteDistribution):
+            batch_sampler (Union[Suggester, AbstractDiscreteDistribution]):
                 A suggestion scheme for future samples.
+            n_batch (int): The number of samples per batch to draw from
+                batch_sampler.
             n_approx (int): Number of points from integrand.discrete_distrib
                 used to approximate estimate and credible interval bounds
             gpytorch_prior_mean (gpytorch.means): prior mean function of the GP
@@ -280,23 +287,23 @@ def __init__(
             gpytorch_likelihood (gpytorch.likelihoods): GP likelihood, require
                 one of gpytorch.likelihoods.{GaussianLikelihood,
                 GaussianLikelihoodWithMissingObs, FixedNoiseGaussianLikelihood}
-            gpytorch_marginal_log_likelihood_func (callable): Function taking
+            gpytorch_marginal_log_likelihood_func (Callable): Function taking
                 in the likelihood and gpytorch model and returning a marginal
                 log likelihood from gpytorch.mlls
-            torch_optimizer_func (callable): Function taking in the gpytorch
+            torch_optimizer_func (Callable): Function taking in the gpytorch
                 model and returning an optimizer from torch.optim
             gpytorch_train_iter (int): Training iterations for the GP in
                 gpytorch
             gpytorch_use_gpu (bool): If True, have gpytorch use a GPU for
                 fitting and training the GP
-            verbose (int): If verbose > 0, print information through the call
+            verbose (Union[bool, int]): If verbose > 0, print information through the call
                 to integrate()
             n_ref_approx (int): If n_ref_approx > 0, use n_ref_approx points to
                 get a reference QMC approximation of the true solution.
                 Caution: If n_ref_approx > 0, it should be a large int e.g.
                 2**22, in which case it is only helpful for cheap to evaluate
                 simulations
-            seed_ref_approx (int): Seed for the reference approximation. Only
+            seed_ref_approx (Union[None, int]): Seed for the reference approximation. Only
                 applies when n_ref_approx>0
         """
         self.parameters = ["abs_tol", "n_init", "n_limit", "n_batch"]
@@ -364,7 +371,7 @@ def _affine_tf(self, y):
             else self.failure_threshold - y
         )
 
-    def integrate(self, seed=None, refit=False, resume=None):
+    def integrate(self, seed: Union[None, int] = None, refit: bool = False, resume: Union[None, Data] = None) -> tuple:
         """Determine the samples needed to satisfy the target tolerance.
 
         Draws an initial batch (`self.n_init` points, or `init_samples` if
@@ -375,12 +382,12 @@ def integrate(self, seed=None, refit=False, resume=None):
         `self.n_limit` would be exceeded.
 
         Args:
-            seed (int): Seed for the internal `DigitalNetB2` sampler used to
+            seed (Union[None, int]): Seed for the internal `DigitalNetB2` sampler used to
                 approximate the solution and (if `init_samples` was not
                 supplied) draw the initial batch.
             refit (bool): If `True`, refit the GP hyperparameters from
                 scratch every batch rather than only on the first batch.
-            resume (Data): Unsupported; must be `None`, as `PFGPCI` cannot
+            resume (Union[None, Data]): Unsupported; must be `None`, as `PFGPCI` cannot
                 resume a prior checkpoint.
 
         Returns:
@@ -549,7 +556,7 @@ def __init__(
             parameters=["solution", "error_bound", "bound_low", "bound_high", "n_total", "time_integrate"]
         )
 
-    def update_data(self, batch_count, xdraw, ydrawtf):
+    def update_data(self, batch_count: int, xdraw: np.ndarray, ydrawtf: np.ndarray):
         """Fold one new batch of samples into the GP surrogate and credible interval.
 
         Refits the GP from scratch (on the first batch, or every batch if
@@ -621,7 +628,7 @@ def update_data(self, batch_count, xdraw, ydrawtf):
             )
         )
 
-    def get_results_dict(self):
+    def get_results_dict(self) -> dict:
         """Collect the per-iteration history as arrays.
 
         Returns:
@@ -647,7 +654,7 @@ def get_results_dict(self):
             )
         return df
 
-    def plot(self, trace_only=False, **kwargs):
+    def plot(self, trace_only: bool = False, **kwargs) -> matplotlib.figure.Figure:
         """Plot the convergence trace, plus a per-batch GP diagnostic panel if `d` is 1 or 2.
 
         Args:
@@ -716,7 +723,7 @@ def plot(self, trace_only=False, **kwargs):
         )
         return fig
 
-    def plot_1d(self, meshticks=1025, ci_percentage=0.95, **kwargs):
+    def plot_1d(self, meshticks: int = 1025, ci_percentage: float = 0.95, **kwargs) -> matplotlib.figure.Figure:
         """Plot, for each batch, the 1-D error density and GP fit with a credible band.
 
         Args:
@@ -794,7 +801,7 @@ def plot_1d(self, meshticks=1025, ci_percentage=0.95, **kwargs):
             ax.xaxis.set_visible(False)
         return fig, gs
 
-    def plot_2d(self, meshticks=257, clevels=32, **kwargs):
+    def plot_2d(self, meshticks: int = 257, clevels: int = 32, **kwargs) -> matplotlib.figure.Figure:
         """Plot, for each batch, 2-D contours of the true function, error density, and GP mean.
 
         Args:
diff --git a/qmcpy/true_measure/abstract_true_measure.py b/qmcpy/true_measure/abstract_true_measure.py
index 806eb36c7..ad5942bef 100644
--- a/qmcpy/true_measure/abstract_true_measure.py
+++ b/qmcpy/true_measure/abstract_true_measure.py
@@ -1,3 +1,4 @@
+from typing import Union
 from ..util import MethodImplementationError, _univ_repr, ParameterError
 from ..discrete_distribution.abstract_discrete_distribution import (
     AbstractDiscreteDistribution,
@@ -140,7 +141,7 @@ def _parse_sampler(self, sampler):
                 "sampler input should either be a AbstractDiscreteDistribution or AbstractTrueMeasure"
             )
 
-    def __call__(self, n=None, n_min=None, n_max=None, return_weights=False, warn=True):
+    def __call__(self, n: Union[None, int] = None, n_min: Union[None, int] = None, n_max: Union[None, int] = None, return_weights: bool = False, warn: bool = True):
         r"""
         - If just `n` is supplied, generate samples from the sequence at indices 0,...,`n`-1.
         - If `n_min` and `n_max` are supplied, generate samples from the sequence at indices `n_min`,...,`n_max`-1.
@@ -215,7 +216,7 @@ def _transform(self, x):
             "_transform. Try setting sampler to be in a PDF AbstractTrueMeasure to importance sample by.",
         )
 
-    def _weight(self, x):
+    def _weight(self, x: np.ndarray) -> np.ndarray:
         r"""Non-negative weight function. This is often a PDF, but is not
         required to be e.g., Lebesgue weight is always 1, but is not a PDF.
 
@@ -229,7 +230,7 @@ def _weight(self, x):
             self, "weight. Try a different true measure with a _weight method."
         )
 
-    def spawn(self, s: int = 1, dimensions: np.ndarray = None):
+    def spawn(self, s: int = 1, dimensions: Union[None, np.ndarray] = None) -> list:
         r"""Spawn new instances of the current true measure but with new seeds
         and dimensions. Used by multi-level QMC algorithms which require
         different seeds and dimensions on each level.
@@ -240,7 +241,7 @@ def spawn(self, s: int = 1, dimensions: np.ndarray = None):
 
         Args:
             s (int): Number of copies to spawn
-            dimensions (np.ndarray): Length `s` array of dimensions for each
+            dimensions (Union[None, np.ndarray]): Length `s` array of dimensions for each
                 copy. Defaults to the current dimension.
 
         Returns:
diff --git a/qmcpy/true_measure/acceptance_rejection.py b/qmcpy/true_measure/acceptance_rejection.py
index c5a0913a1..1e2929143 100644
--- a/qmcpy/true_measure/acceptance_rejection.py
+++ b/qmcpy/true_measure/acceptance_rejection.py
@@ -1,3 +1,4 @@
+from typing import Union
 from .abstract_true_measure import AbstractTrueMeasure
 from ..util import MethodImplementationError, ParameterError
 import numpy as np
@@ -104,7 +105,7 @@ def __init__(self, sampler, target_density, upper_bound, density_integral, max_r
         self._driver_offset = None
         super(AcceptanceRejection, self).__init__()
 
-    def gen_samples(self, n: int = None, n_min: int = None, n_max: int = None, return_weights: bool = False, warn: bool = True):
+    def gen_samples(self, n: Union[None, int] = None, n_min: Union[None, int] = None, n_max: Union[None, int] = None, return_weights: bool = False, warn: bool = True) -> np.ndarray:
         """Generate accepted samples from the target density.
 
         Unlike other TrueMeasures, this method cannot be decomposed into a
@@ -117,12 +118,12 @@ def gen_samples(self, n: int = None, n_min: int = None, n_max: int = None, retur
         position.
 
         Args:
-            n (int): Number of accepted samples to return. Treated as n_min=0,
+            n (Union[None, int]): Number of accepted samples to return. Treated as n_min=0,
                 n_max=n (always resets the driver sequence).
-            n_min (int): Starting accepted-sample index. Use 0 to reset and
+            n_min (Union[None, int]): Starting accepted-sample index. Use 0 to reset and
                 start fresh. Use a positive value to continue from the previous
                 call.
-            n_max (int): Ending accepted-sample index (exclusive). Number of
+            n_max (Union[None, int]): Ending accepted-sample index (exclusive). Number of
                 samples returned is n_max - n_min.
             return_weights (bool): If True, also return importance weights
                 psi(x)/C for each accepted sample.
@@ -320,7 +321,7 @@ def __init__(self, sampler, target_density, inv_cdfs, H_func,
         self._driver_offset = None
         super(AcceptanceRejectionReal, self).__init__()
 
-    def gen_samples(self, n: int = None, n_min: int = None, n_max: int = None, return_weights: bool = False, warn: bool = True):
+    def gen_samples(self, n: Union[None, int] = None, n_min: Union[None, int] = None, n_max: Union[None, int] = None, return_weights: bool = False, warn: bool = True) -> np.ndarray:
         """Generate accepted samples from the target density on R^d.
 
         Unlike other TrueMeasures, this method cannot be decomposed into a
@@ -333,12 +334,12 @@ def gen_samples(self, n: int = None, n_min: int = None, n_max: int = None, retur
         position.
 
         Args:
-            n (int): Number of accepted samples to return. Treated as n_min=0,
+            n (Union[None, int]): Number of accepted samples to return. Treated as n_min=0,
                 n_max=n (always resets the driver sequence).
-            n_min (int): Starting accepted-sample index. Use 0 to reset and
+            n_min (Union[None, int]): Starting accepted-sample index. Use 0 to reset and
                 start fresh. Use a positive value to continue from the previous
                 call.
-            n_max (int): Ending accepted-sample index (exclusive). Number of
+            n_max (Union[None, int]): Ending accepted-sample index (exclusive). Number of
                 samples returned is n_max - n_min.
             return_weights (bool): If True, also return importance weights
                 psi(z)/C for each accepted sample.
diff --git a/qmcpy/true_measure/bernoulli_cont.py b/qmcpy/true_measure/bernoulli_cont.py
index bf411615e..4784ebca4 100644
--- a/qmcpy/true_measure/bernoulli_cont.py
+++ b/qmcpy/true_measure/bernoulli_cont.py
@@ -1,3 +1,7 @@
+from ..discrete_distribution.abstract_discrete_distribution import (
+    AbstractDiscreteDistribution,
+)
+from typing import Union
 from .abstract_true_measure import AbstractTrueMeasure
 from ..util import DimensionError
 from ..discrete_distribution import DigitalNetB2
@@ -37,7 +41,7 @@ class BernoulliCont(AbstractTrueMeasure):
                 [0.6345258 , 0.60241448, 0.84822692]]])
     """
 
-    def __init__(self, sampler, lam=1 / 2) -> None:
+    def __init__(self, sampler: Union[AbstractDiscreteDistribution, AbstractTrueMeasure], lam: Union[float, np.ndarray] = 1 / 2) -> None:
         r"""Initialize a BernoulliCont true measure.
 
         Args:
diff --git a/qmcpy/true_measure/brownian_motion.py b/qmcpy/true_measure/brownian_motion.py
index f65c13ddf..614ea08bd 100644
--- a/qmcpy/true_measure/brownian_motion.py
+++ b/qmcpy/true_measure/brownian_motion.py
@@ -1,3 +1,8 @@
+from ..discrete_distribution.abstract_discrete_distribution import (
+    AbstractDiscreteDistribution,
+)
+from ..true_measure.abstract_true_measure import AbstractTrueMeasure
+from typing import Union
 from .gaussian import Gaussian
 from ..discrete_distribution import DigitalNetB2
 from ..util import ParameterError, ParameterWarning
@@ -138,14 +143,14 @@ class BrownianMotion(Gaussian):
 
     def __init__(
         self,
-        sampler,
+        sampler: Union[AbstractDiscreteDistribution, AbstractTrueMeasure],
         t_final: float = 1,
         initial_value: float = 0,
         drift: int = 0,
         diffusion: int = 1,
         decomp_type: str = "PCA",
         lazy_decomp: bool = True,
-        monitoring_times=None,
+        monitoring_times: Union[None, np.ndarray, list] = None,
         bridge_vdc_gray_ordering: bool = True,
         bridge_output_order: str = 'increasing',
     ) -> None:
@@ -169,7 +174,7 @@ def __init__(
                 - `'BrownianBridge'` or `'Bridge'` for brownian bridge construction.
             lazy_decomp (bool): If True, defer expensive matrix decomposition
                 until needed.
-            monitoring_times (Union[np.ndarray, list]): Optional custom
+            monitoring_times (Union[None, np.ndarray, list]): Optional custom
                 sampling times for `'BrownianBridge'` with length d. The given
                 order is the insertion order if `'bridge_vdc_gray_ordering'` is
                 False.
diff --git a/qmcpy/true_measure/clayton_copula.py b/qmcpy/true_measure/clayton_copula.py
index 301be85ee..f6eda3c9c 100644
--- a/qmcpy/true_measure/clayton_copula.py
+++ b/qmcpy/true_measure/clayton_copula.py
@@ -1,3 +1,8 @@
+from ..discrete_distribution.abstract_discrete_distribution import (
+    AbstractDiscreteDistribution,
+)
+from ..true_measure.abstract_true_measure import AbstractTrueMeasure
+from typing import Union
 from .copula import (
     AbstractCopula,
     _clip_unit_interval,
@@ -79,7 +84,7 @@ class ClaytonCopula(AbstractCopula):
         [doi:10.1016/j.jmva.2012.02.019](https://doi.org/10.1016/j.jmva.2012.02.019).
     """
 
-    def __init__(self, sampler, marginals: list, theta: float) -> None:
+    def __init__(self, sampler: Union[AbstractDiscreteDistribution, AbstractTrueMeasure], marginals: list, theta: float) -> None:
         r"""Initialize a ClaytonCopula true measure.
 
         Args:
diff --git a/qmcpy/true_measure/frank_copula.py b/qmcpy/true_measure/frank_copula.py
index 06d71c5b5..c6a5104fc 100644
--- a/qmcpy/true_measure/frank_copula.py
+++ b/qmcpy/true_measure/frank_copula.py
@@ -1,3 +1,8 @@
+from ..discrete_distribution.abstract_discrete_distribution import (
+    AbstractDiscreteDistribution,
+)
+from ..true_measure.abstract_true_measure import AbstractTrueMeasure
+from typing import Union
 from .copula import (
     AbstractCopula,
     _clip_unit_interval,
@@ -102,7 +107,7 @@ class FrankCopula(AbstractCopula):
         [doi:10.1016/j.jmva.2012.02.019](https://doi.org/10.1016/j.jmva.2012.02.019).
     """
 
-    def __init__(self, sampler, marginals: list, theta: float) -> None:
+    def __init__(self, sampler: Union[AbstractDiscreteDistribution, AbstractTrueMeasure], marginals: list, theta: float) -> None:
         r"""Initialize a FrankCopula true measure.
 
         Args:
diff --git a/qmcpy/true_measure/gaussian.py b/qmcpy/true_measure/gaussian.py
index 4f1494fd0..3d8896d5e 100644
--- a/qmcpy/true_measure/gaussian.py
+++ b/qmcpy/true_measure/gaussian.py
@@ -1,6 +1,9 @@
 from .abstract_true_measure import AbstractTrueMeasure
 from ..util import DimensionError, ParameterError
 from ..discrete_distribution import DigitalNetB2
+from ..discrete_distribution.abstract_discrete_distribution import (
+    AbstractDiscreteDistribution,
+)
 import numpy as np
 from numpy.linalg import cholesky, slogdet
 from scipy.stats import norm, multivariate_normal
@@ -48,7 +51,7 @@ class Gaussian(AbstractTrueMeasure):
                 [ 1.1844196 ,  0.44964332,  1.27760936]]])
     """
 
-    def __init__(self, sampler, mean: Union[float, np.ndarray] = 0.0, covariance: Union[float, np.ndarray] = 1.0, decomp_type: str = "PCA") -> None:
+    def __init__(self, sampler: Union[AbstractDiscreteDistribution, AbstractTrueMeasure], mean: Union[float, np.ndarray] = 0.0, covariance: Union[float, np.ndarray] = 1.0, decomp_type: str = "PCA") -> None:
         """Initialize a Gaussian true measure.
 
         Args:
diff --git a/qmcpy/true_measure/gaussian_copula.py b/qmcpy/true_measure/gaussian_copula.py
index 4299ae321..3a742bfa4 100644
--- a/qmcpy/true_measure/gaussian_copula.py
+++ b/qmcpy/true_measure/gaussian_copula.py
@@ -1,3 +1,8 @@
+from ..discrete_distribution.abstract_discrete_distribution import (
+    AbstractDiscreteDistribution,
+)
+from ..true_measure.abstract_true_measure import AbstractTrueMeasure
+from typing import Union
 from .copula import (
     AbstractCopula,
     _clip_unit_interval,
@@ -75,7 +80,7 @@ class GaussianCopula(AbstractCopula):
         [arXiv:1508.03483](https://arxiv.org/abs/1508.03483).
     """
 
-    def __init__(self, sampler, marginals: list, correlation: np.ndarray) -> None:
+    def __init__(self, sampler: Union[AbstractDiscreteDistribution, AbstractTrueMeasure], marginals: list, correlation: np.ndarray) -> None:
         r"""Initialize a GaussianCopula true measure.
 
         Args:
diff --git a/qmcpy/true_measure/geometric_brownian_motion.py b/qmcpy/true_measure/geometric_brownian_motion.py
index 83d8aa93a..0943cda25 100644
--- a/qmcpy/true_measure/geometric_brownian_motion.py
+++ b/qmcpy/true_measure/geometric_brownian_motion.py
@@ -1,5 +1,9 @@
 from .brownian_motion import BrownianMotion
+from .abstract_true_measure import AbstractTrueMeasure
 from ..discrete_distribution import DigitalNetB2
+from ..discrete_distribution.abstract_discrete_distribution import (
+    AbstractDiscreteDistribution,
+)
 from ..util import ParameterError
 from typing import Union, Tuple
 from numpy import (
@@ -49,7 +53,7 @@ class GeometricBrownianMotion(BrownianMotion):
 
     def __init__(
         self,
-        sampler,
+        sampler: Union[AbstractDiscreteDistribution, AbstractTrueMeasure],
         t_final: float = 1,
         initial_value: float = 1,
         drift: float = 0,
@@ -61,7 +65,7 @@ def __init__(
         r"""Initialize a GeometricBrownianMotion true measure.
 
         Args:
-            sampler (DiscreteDistribution/TrueMeasure): A discrete distribution
+            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]): A discrete distribution
                 or true measure.
             t_final (float): End time for the geometric Brownian motion,
                 non-negative.
@@ -284,7 +288,7 @@ def _setup_lognormal_distribution(self):
             mean=log_mean, cov=log_cov, allow_singular=True
         )
 
-    def _weight(self, x):
+    def _weight(self, x: ndarray):
         """Compute PDF of multivariate log-normal distribution. For
         log-normal: f(x) = (1/∏x_i) * φ(log(x/S0)) where φ is multivariate
         normal PDF.
@@ -310,14 +314,14 @@ def _weight(self, x):
         return normal_pdf * jacobian
 
     def gen_samples(
-        self, n=None, n_min=None, n_max=None, return_weights: bool = False, warn: bool = True
+        self, n: Union[None, int] = None, n_min: Union[None, int] = None, n_max: Union[None, int] = None, return_weights: bool = False, warn: bool = True
     ) -> Union[ndarray, Tuple[ndarray, ndarray]]:
         """Generate GBM samples using the parent's transform pipeline.
 
         Args:
-            n (int): number of samples to generate
-            n_min (int): minimum index of sequence
-            n_max (int): maximum index of sequence
+            n (Union[None, int]): number of samples to generate
+            n_min (Union[None, int]): minimum index of sequence
+            n_max (Union[None, int]): maximum index of sequence
             return_weights (bool): whether to return Jacobian weights
             warn (bool): whether to warn about sample generation
 
diff --git a/qmcpy/true_measure/gumbel_copula.py b/qmcpy/true_measure/gumbel_copula.py
index d61d8178a..f53d46d25 100644
--- a/qmcpy/true_measure/gumbel_copula.py
+++ b/qmcpy/true_measure/gumbel_copula.py
@@ -1,3 +1,8 @@
+from ..discrete_distribution.abstract_discrete_distribution import (
+    AbstractDiscreteDistribution,
+)
+from ..true_measure.abstract_true_measure import AbstractTrueMeasure
+from typing import Union
 from .copula import (
     AbstractCopula,
     _clip_unit_interval,
@@ -75,7 +80,7 @@ class GumbelCopula(AbstractCopula):
         [doi:10.1016/j.jmva.2012.02.019](https://doi.org/10.1016/j.jmva.2012.02.019).
     """
 
-    def __init__(self, sampler, marginals: list, theta: float) -> None:
+    def __init__(self, sampler: Union[AbstractDiscreteDistribution, AbstractTrueMeasure], marginals: list, theta: float) -> None:
         r"""Initialize a GumbelCopula true measure.
 
         Args:
diff --git a/qmcpy/true_measure/johnsons_su.py b/qmcpy/true_measure/johnsons_su.py
index de80f0f87..e6c270b01 100644
--- a/qmcpy/true_measure/johnsons_su.py
+++ b/qmcpy/true_measure/johnsons_su.py
@@ -1,3 +1,7 @@
+from ..discrete_distribution.abstract_discrete_distribution import (
+    AbstractDiscreteDistribution,
+)
+from typing import Union
 from .abstract_true_measure import AbstractTrueMeasure
 from ..util import DimensionError, ParameterError
 from ..discrete_distribution import DigitalNetB2
@@ -41,7 +45,7 @@ class JohnsonsSU(AbstractTrueMeasure):
                 [ 1.57765245,  1.00275   ,  1.64972468]]])
     """
 
-    def __init__(self, sampler, gamma=1, xi=1, delta=2, lam=2) -> None:
+    def __init__(self, sampler: Union[AbstractDiscreteDistribution, AbstractTrueMeasure], gamma: Union[float, np.ndarray] = 1, xi: Union[float, np.ndarray] = 1, delta: Union[float, np.ndarray] = 2, lam: Union[float, np.ndarray] = 2) -> None:
         r"""Initialize a JohnsonsSU true measure.
 
         Args:
diff --git a/qmcpy/true_measure/kumaraswamy.py b/qmcpy/true_measure/kumaraswamy.py
index 88e17bafd..92e6f9473 100644
--- a/qmcpy/true_measure/kumaraswamy.py
+++ b/qmcpy/true_measure/kumaraswamy.py
@@ -1,3 +1,7 @@
+from ..discrete_distribution.abstract_discrete_distribution import (
+    AbstractDiscreteDistribution,
+)
+from typing import Union
 from .abstract_true_measure import AbstractTrueMeasure
 from ..util import DimensionError, ParameterError
 from ..discrete_distribution import DigitalNetB2
@@ -50,7 +54,7 @@ class Kumaraswamy(AbstractTrueMeasure):
                 [0.37253319, 0.45379743, 0.63366422]]])
     """
 
-    def __init__(self, sampler, a=2, b=2) -> None:
+    def __init__(self, sampler: Union[AbstractDiscreteDistribution, AbstractTrueMeasure], a: Union[float, np.ndarray] = 2, b: Union[float, np.ndarray] = 2) -> None:
         r"""Initialize a Kumaraswamy true measure.
 
         Args:
diff --git a/qmcpy/true_measure/matern_gp.py b/qmcpy/true_measure/matern_gp.py
index 8b51da755..be413198e 100644
--- a/qmcpy/true_measure/matern_gp.py
+++ b/qmcpy/true_measure/matern_gp.py
@@ -86,6 +86,8 @@ def __init__(
             points (np.ndarray): The positions of points on a metric space. The
                 array should have shape $(d,k)$ where $d$ is the dimension of
                 the sampler and $k$ is the latent dimension.
+            length_scale (Union[float, np.ndarray]): Determines "peakiness", or
+                how correlated two points are based on their distance.
             nu (float): The "smoothness" of the MaternGP function, e.g.,
 
                 - $\nu = 1/2$ is equivalent to the absolute exponential kernel,
@@ -95,8 +97,6 @@ def __init__(
 
                 Note that when $\nu \notin \{1/2, 3/2, 5/2, \infty \}$ the
                 kernel is around $10$ times slower to evaluate.
-            length_scale (Union[float, np.ndarray]): Determines "peakiness", or
-                how correlated two points are based on their distance.
             variance (float): Global scaling factor of the kernel. Retrievable
                 after construction via the `kernel_variance` property. (The
                 inherited `variance` attribute is the vector of marginal
diff --git a/qmcpy/true_measure/product_measure.py b/qmcpy/true_measure/product_measure.py
index 88c961927..dc1809441 100644
--- a/qmcpy/true_measure/product_measure.py
+++ b/qmcpy/true_measure/product_measure.py
@@ -1,3 +1,4 @@
+from typing import Union
 import numpy as np
 from scipy import sparse
 
@@ -98,28 +99,27 @@ class ProductMeasure(AbstractTrueMeasure):
     (4, 3)
     """
 
-    def __init__(self, sampler, marginals) -> None:
+    def __init__(self, sampler: AbstractDiscreteDistribution, marginals: Union[list, tuple]) -> None:
         """Initialize a product measure from one sampler and several
         marginals.
 
         Args:
-
-        sampler: AbstractDiscreteDistribution The sampler for the whole product
-            measure. Its dimension must equal the sum of the marginal
-            dimensions.
-
-        marginals: list or tuple of AbstractTrueMeasure Independent true
-            measures to place side by side. A marginal may itself be
-            multidimensional.
-
-        Why one sampler? ---------------- The product measure should be driven
-        by one total-dimensional QMC point set. We do not generate separate QMC
-        samples from each marginal. Instead, one sample u in [0,1]^d is split
-        into blocks:
-
-            u = (u_marginal_1, u_marginal_2, ..., u_marginal_k).
-
-        This preserves the intended total-dimensional QMC construction.
+            sampler (AbstractDiscreteDistribution): The sampler for the whole
+                product measure. Its dimension must equal the sum of the
+                marginal dimensions.
+            marginals (Union[list, tuple]): Independent true
+                measures to place side by side. A marginal may itself be
+                multidimensional.
+
+        Notes:
+            Why one sampler? The product measure should be driven by one
+            total-dimensional QMC point set. We do not generate separate QMC
+            samples from each marginal. Instead, one sample u in [0,1]^d is
+            split into blocks:
+
+                u = (u_marginal_1, u_marginal_2, ..., u_marginal_k).
+
+            This preserves the intended total-dimensional QMC construction.
         """
         if not isinstance(marginals, (list, tuple)) or len(marginals) == 0:
             raise ParameterError("ProductMeasure requires a nonempty list of marginals.")
diff --git a/qmcpy/true_measure/scipy_wrapper.py b/qmcpy/true_measure/scipy_wrapper.py
index 8cf080586..67303c71b 100644
--- a/qmcpy/true_measure/scipy_wrapper.py
+++ b/qmcpy/true_measure/scipy_wrapper.py
@@ -1,3 +1,4 @@
+from typing import Union
 from .abstract_true_measure import AbstractTrueMeasure
 from ..util import DimensionError, ParameterError
 from ..discrete_distribution.abstract_discrete_distribution import (
@@ -175,13 +176,13 @@ class SciPyWrapper(AbstractTrueMeasure):
         (4, 2)
     """
 
-    def __init__(self, sampler, scipy_distribs) -> None:
+    def __init__(self, sampler: AbstractDiscreteDistribution, scipy_distribs: Union[scipy.stats._distn_infrastructure.rv_continuous_frozen, list, object]) -> None:
         """Wrap one or more SciPy distributions as a QMCPy true measure.
 
         Args:
             sampler (AbstractDiscreteDistribution): Low discrepancy or iid
                 sampler in dimension d, living on [0,1)^d.
-            scipy_distribs (Union[scipy.stats.rv_frozen, list, object]): One
+            scipy_distribs (Union[scipy.stats._distn_infrastructure.rv_continuous_frozen, list, object]): One
                 of the following:
 
                 - A single SciPy 1D continuous frozen distribution.
diff --git a/qmcpy/true_measure/student_t_copula.py b/qmcpy/true_measure/student_t_copula.py
index fb5356043..71e7259f1 100644
--- a/qmcpy/true_measure/student_t_copula.py
+++ b/qmcpy/true_measure/student_t_copula.py
@@ -1,3 +1,8 @@
+from ..discrete_distribution.abstract_discrete_distribution import (
+    AbstractDiscreteDistribution,
+)
+from ..true_measure.abstract_true_measure import AbstractTrueMeasure
+from typing import Union
 from .copula import (
     AbstractCopula,
     _clip_unit_interval,
@@ -86,7 +91,7 @@ class StudentTCopula(AbstractCopula):
         "Weights will be treated as 1."
     )
 
-    def __init__(self, sampler, marginals: list, correlation: np.ndarray, df: float) -> None:
+    def __init__(self, sampler: Union[AbstractDiscreteDistribution, AbstractTrueMeasure], marginals: list, correlation: np.ndarray, df: float) -> None:
         r"""Initialize a StudentTCopula true measure.
 
         Args:
diff --git a/qmcpy/true_measure/triangular.py b/qmcpy/true_measure/triangular.py
index ebefd1945..534a29eb6 100644
--- a/qmcpy/true_measure/triangular.py
+++ b/qmcpy/true_measure/triangular.py
@@ -29,7 +29,7 @@ def __init__(self, c=0.5, loc=0.0, scale=1.0) -> None:
         self._b = loc + scale
         self._m = loc + c * scale
 
-    def pdf(self, x):
+    def pdf(self, x: np.ndarray) -> np.ndarray:
         """Probability density function of the triangular distribution.
 
         Args:
@@ -49,7 +49,7 @@ def pdf(self, x):
         out[right] = 2.0 * (b - x[right]) / ((b - a) * (b - m))
         return out
 
-    def ppf(self, u):
+    def ppf(self, u: np.ndarray) -> np.ndarray:
         """Percent point function (inverse CDF) of the triangular distribution.
 
         Args:
diff --git a/qmcpy/true_measure/uniform.py b/qmcpy/true_measure/uniform.py
index 514591a13..1bd7f8e0d 100644
--- a/qmcpy/true_measure/uniform.py
+++ b/qmcpy/true_measure/uniform.py
@@ -1,3 +1,7 @@
+from ..discrete_distribution.abstract_discrete_distribution import (
+    AbstractDiscreteDistribution,
+)
+from typing import Union
 from .abstract_true_measure import AbstractTrueMeasure
 from ..util import DimensionError, ParameterError
 from ..discrete_distribution import DigitalNetB2
@@ -49,7 +53,7 @@ class Uniform(AbstractTrueMeasure):
                 [1.37943573, 1.10241448, 1.13481488]]])
     """
 
-    def __init__(self, sampler, lower_bound=0, upper_bound=1) -> None:
+    def __init__(self, sampler: Union[AbstractDiscreteDistribution, AbstractTrueMeasure], lower_bound: Union[float, np.ndarray] = 0, upper_bound: Union[float, np.ndarray] = 1) -> None:
         r"""Initialize a Uniform true measure.
 
         Args:
diff --git a/qmcpy/true_measure/uniform_triangle.py b/qmcpy/true_measure/uniform_triangle.py
index 8705d77df..0fd22a28b 100644
--- a/qmcpy/true_measure/uniform_triangle.py
+++ b/qmcpy/true_measure/uniform_triangle.py
@@ -1,6 +1,11 @@
+from typing import Union
 import numpy as np
 
 from ..util import DimensionError
+from ..discrete_distribution.abstract_discrete_distribution import (
+    AbstractDiscreteDistribution,
+)
+from ..true_measure.abstract_true_measure import AbstractTrueMeasure
 from .scipy_wrapper import SciPyWrapper
 from ..discrete_distribution import DigitalNetB2
 
@@ -58,5 +63,12 @@ class UniformTriangle(SciPyWrapper):
     True
     """
 
-    def __init__(self, sampler) -> None:
+    def __init__(self, sampler: Union[AbstractDiscreteDistribution, AbstractTrueMeasure]) -> None:
+        """Initialize a UniformTriangle true measure.
+
+        Args:
+            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]): A
+                2-dimensional sampler generating unit-cube samples to be
+                transformed to the triangle.
+        """
         super().__init__(sampler=sampler, scipy_distribs=_UniformTriangleAdapter())
diff --git a/qmcpy/true_measure/zero_inflated_exp_uniform.py b/qmcpy/true_measure/zero_inflated_exp_uniform.py
index 961b7392f..c29eea2ae 100644
--- a/qmcpy/true_measure/zero_inflated_exp_uniform.py
+++ b/qmcpy/true_measure/zero_inflated_exp_uniform.py
@@ -1,8 +1,13 @@
+from typing import Union
 import warnings
 
 import numpy as np
 
 from ..util import DimensionError, ParameterError
+from ..discrete_distribution.abstract_discrete_distribution import (
+    AbstractDiscreteDistribution,
+)
+from ..true_measure.abstract_true_measure import AbstractTrueMeasure
 from .scipy_wrapper import SciPyWrapper
 
 
@@ -180,7 +185,20 @@ class ZeroInflatedExpUniform(SciPyWrapper):
     True
     """
 
-    def __init__(self, sampler, p_zero=0.4, lam=1.5, y_split=None) -> None:
+    def __init__(self, sampler: Union[AbstractDiscreteDistribution, AbstractTrueMeasure], p_zero: float = 0.4, lam: float = 1.5, y_split: Union[None, float] = None) -> None:
+        """Initialize a ZeroInflatedExpUniform true measure.
+
+        Args:
+            sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]): A
+                1-dimensional sampler generating unit-cube samples to be
+                transformed. If `y_split` is set, a 2-dimensional sampler is
+                required instead (deprecated construction).
+            p_zero (float): Probability mass at zero.
+            lam (float): Rate parameter of the exponential component.
+            y_split (Union[None, float]): Deprecated. If set, uses the legacy
+                2-dimensional zero-inflated exponential-uniform construction
+                instead of the 1-dimensional interface.
+        """
         if y_split is not None:
             warnings.warn(
                 "`y_split` is deprecated. The 2D zero-inflated "
diff --git a/qmcpy/util/abstraction_functions.py b/qmcpy/util/abstraction_functions.py
index 44ff3eccd..caf315090 100644
--- a/qmcpy/util/abstraction_functions.py
+++ b/qmcpy/util/abstraction_functions.py
@@ -2,7 +2,7 @@
 from copy import copy
 
 
-def _univ_repr(qmc_object, abc_class_name, attributes):
+def _univ_repr(qmc_object: object, abc_class_name: str, attributes: list):
     """Clean way to represent qmc_object data.
 
     Args:
diff --git a/qmcpy/util/data.py b/qmcpy/util/data.py
index 24eeba46d..e13848006 100644
--- a/qmcpy/util/data.py
+++ b/qmcpy/util/data.py
@@ -1,5 +1,7 @@
 import gzip
 import pickle
+from pathlib import Path
+from typing import Union
 
 from ..util import _univ_repr
 
@@ -14,7 +16,7 @@ class Data(object):
     def __init__(self, parameters) -> None:
         self.parameters = parameters
 
-    def save(self, path, compress: bool = False, overwrite: bool = False):
+    def save(self, path: Union[str, Path], compress: bool = False, overwrite: bool = False) -> str:
         """Save this Data object to disk using pickle.
 
         Warnings:
@@ -23,7 +25,7 @@ def save(self, path, compress: bool = False, overwrite: bool = False):
             come from a trusted source.
 
         Args:
-            path (str or pathlib.Path): File path to save to. If
+            path (Union[str, Path]): File path to save to. If
                 ``compress=True``, a ``.gz`` suffix is appended automatically
                 when not already present.
             compress (bool): Gzip-compress the saved file. Defaults to False.
@@ -53,7 +55,7 @@ def save(self, path, compress: bool = False, overwrite: bool = False):
         return path
 
     @classmethod
-    def load(cls, path):
+    def load(cls, path: Union[str, Path]) -> "Data":
         """Load a Data object from disk.
 
         Warnings:
@@ -62,7 +64,7 @@ def load(cls, path):
             trusted source.
 
         Args:
-            path (str or pathlib.Path): Path to the saved file. Files ending in
+            path (Union[str, Path]): Path to the saved file. Files ending in
                 ``.gz`` are decompressed automatically.
 
         Returns:
diff --git a/qmcpy/util/dig_shift_invar_ops.py b/qmcpy/util/dig_shift_invar_ops.py
index 7fad7aefd..b8edf9e94 100644
--- a/qmcpy/util/dig_shift_invar_ops.py
+++ b/qmcpy/util/dig_shift_invar_ops.py
@@ -1,9 +1,15 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Union
+if TYPE_CHECKING:
+    import torch
+
 import numpy as np
 from .exceptions_warnings import ParameterError
 from .torch_numpy_ops import get_npt
 
 
-def k4sumterm(x, t: int, cutoff=1e-8):
+def k4sumterm(x: Union[np.ndarray, torch.Tensor], t: int, cutoff: float = 1e-8) -> Union[np.ndarray, torch.Tensor]:
     r"""$$K_4(x) = \sum_{a=0}^{t-1} \frac{x_a}{2^{3a}}$$
 
     where $x_a$ is the bit at index $a$ in the binary expansion of $x$ e.g. $x
@@ -30,8 +36,10 @@ def k4sumterm(x, t: int, cutoff=1e-8):
                 [-1.14, -0.89, -0.89, -0.86]])
 
     Args:
-        x (Union[np.ndarray torch.Tensor]): Integer arrays.
+        x (Union[np.ndarray, torch.Tensor]): Integer arrays.
         t (int): Number of bits in each integer.
+        cutoff (float): Stop accumulating terms once `1/2**(3*a)` falls
+            below this threshold.
 
     Returns:
         Union[np.ndarray, torch.Tensor]: The $K_4$ sum term.
@@ -64,7 +72,7 @@ def k4sumterm(x, t: int, cutoff=1e-8):
 }
 
 
-def weighted_walsh_funcs(alpha: int, xb, t: int):
+def weighted_walsh_funcs(alpha: int, xb: Union[np.ndarray, torch.Tensor], t: int) -> Union[np.ndarray, torch.Tensor]:
     r"""Weighted walsh functions
 
     $$\sum_{k=0}^\infty \mathrm{wal}_k(x) 2^{-\mu_\alpha(k)}$$
@@ -157,7 +165,7 @@ def weighted_walsh_funcs(alpha: int, xb, t: int):
     return y
 
 
-def to_bin(x, t: int):
+def to_bin(x: Union[np.ndarray, torch.Tensor], t: int) -> Union[np.ndarray, torch.Tensor]:
     r"""Convert floating point representations of digital net samples in base
     $b=2$ to binary representations.
 
@@ -208,7 +216,7 @@ def to_bin(x, t: int):
             raise ParameterError("x.dtype must be float or int, got %s" % str(x.dtype))
 
 
-def to_float(x, t: int):
+def to_float(x: Union[np.ndarray, torch.Tensor], t: int) -> Union[np.ndarray, torch.Tensor]:
     r"""Convert binary representations of digital net samples in base $b=2$ to
     floating point representations.
 
@@ -250,7 +258,7 @@ def to_float(x, t: int):
             raise ParameterError("x.dtype must be torch.int64, got %s" % str(x.dtype))
 
 
-def bin_from_numpy_to_torch(xb):
+def bin_from_numpy_to_torch(xb: Union[np.ndarray]) -> Union[torch.Tensor]:
     r"""Convert `numpy.uint64` to `torch.int64`, useful for converting binary
     samples from `DigitalNetB2` to torch representations.
 
diff --git a/qmcpy/util/exact_gpytorch_regression_model.py b/qmcpy/util/exact_gpytorch_regression_model.py
index 765231f69..c5efb9051 100644
--- a/qmcpy/util/exact_gpytorch_regression_model.py
+++ b/qmcpy/util/exact_gpytorch_regression_model.py
@@ -1,3 +1,4 @@
+from typing import Union
 import numpy as np
 import torch
 import gpytorch
@@ -16,7 +17,7 @@ class ExactGPyTorchRegressionModel(gpytorch.models.ExactGP):
         gpytorch.likelihoods.FixedNoiseGaussianLikelihood,
     )
 
-    def __init__(self, x_t, y_t, prior_mean, prior_cov, likelihood, use_gpu=False):
+    def __init__(self, x_t, y_t, prior_mean, prior_cov, likelihood, use_gpu=False) -> None:
         if isinstance(x_t, np.ndarray):
             x_t = torch.from_numpy(x_t)
         if isinstance(y_t, np.ndarray):
@@ -37,7 +38,7 @@ def __init__(self, x_t, y_t, prior_mean, prior_cov, likelihood, use_gpu=False):
             self = self.cuda()
             self.likelihood = self.likelihood.cuda()
 
-    def forward(self, x):
+    def forward(self, x: torch.Tensor) -> gpytorch.distributions.MultivariateNormal:
         """Evaluate the GP prior at the given inputs.
 
         Args:
@@ -50,7 +51,7 @@ def forward(self, x):
         covar_x = self.covar_module(x)
         return gpytorch.distributions.MultivariateNormal(mean_x, covar_x)
 
-    def fit(self, optimizer, mll, training_iter, verbose=0):
+    def fit(self, optimizer: torch.optim.Optimizer, mll: gpytorch.mlls.MarginalLogLikelihood, training_iter: int, verbose: int = 0):
         """Fit the model hyperparameters by maximizing the marginal log likelihood.
 
         Args:
@@ -74,7 +75,7 @@ def fit(self, optimizer, mll, training_iter, verbose=0):
                     print("\t\t\t%s %.2e" % (name.ljust(50, "."), val))
             optimizer.step()
 
-    def predict(self, x, noise_const=0, chunk_size=2**15):
+    def predict(self, x: Union[np.ndarray, torch.Tensor], noise_const: float = 0, chunk_size: int = 2**15) -> tuple:
         """Predict the posterior mean and standard deviation at new inputs.
 
         Inputs are processed in chunks so large batches do not exhaust memory.
@@ -119,7 +120,7 @@ def _predict_batch(self, x, noise):
             torch.cuda.empty_cache()
         return mean_post.numpy(), std_post.numpy()
 
-    def add_data(self, x_t_new, y_t_new):
+    def add_data(self, x_t_new: Union[np.ndarray, torch.Tensor], y_t_new: Union[np.ndarray, torch.Tensor]) -> "ExactGPyTorchRegressionModel":
         """Add observations to the training set and condition the model on them.
 
         Args:
diff --git a/qmcpy/util/latnetbuilder_linker.py b/qmcpy/util/latnetbuilder_linker.py
index a38faa969..f5d36ab6f 100644
--- a/qmcpy/util/latnetbuilder_linker.py
+++ b/qmcpy/util/latnetbuilder_linker.py
@@ -2,7 +2,7 @@
 import numpy as np
 
 
-def latnetbuilder_linker(lnb_dir: str = "./", out_dir: str = "./", fout_prefix: str = "lnb4qmcpy"):
+def latnetbuilder_linker(lnb_dir: str = "./", out_dir: str = "./", fout_prefix: str = "lnb4qmcpy") -> str:
     """Convert a LatNet Builder output directory into a QMCPy generating vector or matrix.
 
     Args:
diff --git a/qmcpy/util/mlmc_test.py b/qmcpy/util/mlmc_test.py
index 863868897..ec417a7f5 100644
--- a/qmcpy/util/mlmc_test.py
+++ b/qmcpy/util/mlmc_test.py
@@ -1,8 +1,9 @@
 import qmcpy as qp
+from ..integrand.abstract_integrand import AbstractIntegrand
 import numpy as np
 
 def mlmc_test(
-    integrand,
+    integrand: AbstractIntegrand,
     n: int = 20000,
     l: int = 8,
     n_init: int = 200,
diff --git a/qmcpy/util/plot_functions.py b/qmcpy/util/plot_functions.py
index a495486b3..4e722cfc2 100644
--- a/qmcpy/util/plot_functions.py
+++ b/qmcpy/util/plot_functions.py
@@ -1,13 +1,23 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Union
 import numpy as np
 import os
 import qmcpy as qp
 
+if TYPE_CHECKING:
+    from ..discrete_distribution.abstract_discrete_distribution import (
+        AbstractDiscreteDistribution,
+    )
+    from ..true_measure.abstract_true_measure import AbstractTrueMeasure
+    import matplotlib.figure
+
 
 def plot_proj(
-    sampler,
-    n=64,
-    d_horizontal=1,
-    d_vertical=2,
+    sampler: Union[AbstractDiscreteDistribution, AbstractTrueMeasure],
+    n: Union[int, list] = 64,
+    d_horizontal: Union[int, list] = 1,
+    d_vertical: Union[int, list] = 2,
     math_ind: bool = True,
     marker_size: float = 5,
     figfac: float = 5,
@@ -17,11 +27,11 @@ def plot_proj(
     font_family: str = "sans-serif",
     where_title: float = 1,
     **kwargs: dict
-):
+) -> matplotlib.figure.Figure:
     """Plot two-dimensional projections of a point set.
 
     Args:
-        sampler (DiscreteDistribution, TrueMeasure): The generator of samples
+        sampler (Union[AbstractDiscreteDistribution, AbstractTrueMeasure]): The generator of samples
             to be plotted.
         n (Union[int, list]): The number of samples or a list of samples(used
             for extensibility) to be plotted.
@@ -42,6 +52,11 @@ def plot_proj(
             value is 1.
         **kwargs (dict): Additional keyword arguments passed to
             `matplotlib.pyplot.scatter`.
+
+    Returns:
+        matplotlib.figure.Figure: The created figure.
+        matplotlib.axes.Axes: Array of subplot axes, one per
+            (`d_horizontal`, `d_vertical`) pair.
     """
     try:
         import matplotlib.pyplot as plt
diff --git a/qmcpy/util/shift_invar_ops.py b/qmcpy/util/shift_invar_ops.py
index c9f87a6c6..9aa061cc9 100644
--- a/qmcpy/util/shift_invar_ops.py
+++ b/qmcpy/util/shift_invar_ops.py
@@ -1,3 +1,9 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Union
+if TYPE_CHECKING:
+    import torch
+
 import numpy as np
 
 
@@ -10,13 +16,13 @@ class Polynomial:
     >>> assert np.allclose(y,y_true,atol=1e-12)
     """
 
-    def __init__(self, coeffs) -> None:
+    def __init__(self, coeffs: Union[list, np.ndarray, torch.Tensor]) -> None:
         """Polynomial evaluation with Horner's rule
 
         Args:
-            coeffs (list or np.ndarray or torch.Tensor): vector of coefficients
-            e.g. coeffs = [a, b, c] corresponds to the quadratic polynomial
-            a*x**2 + b*x + c
+            coeffs (Union[list, np.ndarray, torch.Tensor]): Vector of
+                coefficients, e.g., `coeffs = [a, b, c]` corresponds to the
+                quadratic polynomial `a*x**2 + b*x + c`.
         """
         if not (isinstance(coeffs, list)):
             raise AssertionError
@@ -54,7 +60,7 @@ def __call__(self, x):
 }
 
 
-def bernoulli_poly(n: int, x):
+def bernoulli_poly(n: int, x: Union[np.ndarray, torch.Tensor]) -> Union[np.ndarray, torch.Tensor]:
     r"""$n^\text{th}$ Bernoulli polynomial
 
     Examples:
diff --git a/qmcpy/util/stop_notebook.py b/qmcpy/util/stop_notebook.py
index bfb1a4a14..3b1e08dc9 100644
--- a/qmcpy/util/stop_notebook.py
+++ b/qmcpy/util/stop_notebook.py
@@ -1,4 +1,4 @@
-def stop_notebook(query="Type 'yes' to continue running notebook"):
+def stop_notebook(query: str = "Type 'yes' to continue running notebook"):
     """Prompt at a notebook checkpoint and halt execution unless the user confirms.
 
     Placed between cells so that "Run All" pauses instead of running an
diff --git a/qmcpy/util/torch_numpy_ops.py b/qmcpy/util/torch_numpy_ops.py
index 7358d5994..53618ef67 100644
--- a/qmcpy/util/torch_numpy_ops.py
+++ b/qmcpy/util/torch_numpy_ops.py
@@ -1,14 +1,21 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Union
+import types
 import numpy as np
 
+if TYPE_CHECKING:
+    import torch
+
 
-def get_npt(x):
+def get_npt(x: Union[np.ndarray, torch.Tensor]) -> types.ModuleType:
     """Return the array backend module matching the input.
 
     Args:
         x (Union[np.ndarray, torch.Tensor]): Array whose backend is wanted.
 
     Returns:
-        module: ``numpy`` for an ``np.ndarray``, otherwise ``torch``.
+        types.ModuleType: ``numpy`` for an ``np.ndarray``, otherwise ``torch``.
 
     Raises:
         AssertionError: If ``x`` is neither an ``np.ndarray`` nor a ``torch.Tensor``.
diff --git a/qmcpy/util/transforms.py b/qmcpy/util/transforms.py
index 2497e9617..05f549c55 100644
--- a/qmcpy/util/transforms.py
+++ b/qmcpy/util/transforms.py
@@ -1,11 +1,18 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Union
+import types
 import numpy as np
 import scipy.special
 from .torch_numpy_ops import get_npt
 
+if TYPE_CHECKING:
+    import torch
+
 EPS64 = float(np.finfo(np.float64).eps)
 
 
-def insert_batch_dims(param, ndims, k):
+def insert_batch_dims(param: Union[np.ndarray, torch.Tensor], ndims: int, k: int) -> Union[np.ndarray, torch.Tensor]:
     """Insert singleton dimensions into a parameter so it broadcasts against batched inputs.
 
     Args:
@@ -21,7 +28,7 @@ def insert_batch_dims(param, ndims, k):
     return param.reshape(list(param.shape[:k]) + ones + list(param.shape[k:]))
 
 
-def tf_exp(x):
+def tf_exp(x: Union[np.ndarray, torch.Tensor]) -> Union[np.ndarray, torch.Tensor]:
     """Exponential transform.
 
     Args:
@@ -34,7 +41,7 @@ def tf_exp(x):
     return npt.exp(x)
 
 
-def tf_exp_inv(x):
+def tf_exp_inv(x: Union[np.ndarray, torch.Tensor]) -> Union[np.ndarray, torch.Tensor]:
     """Inverse of the exponential transform.
 
     Args:
@@ -47,7 +54,7 @@ def tf_exp_inv(x):
     return npt.log(x)
 
 
-def tf_exp_eps(x):
+def tf_exp_eps(x: Union[np.ndarray, torch.Tensor]) -> Union[np.ndarray, torch.Tensor]:
     """Exponential transform offset by machine epsilon.
 
     Args:
@@ -59,7 +66,7 @@ def tf_exp_eps(x):
     return tf_exp(x) + EPS64
 
 
-def tf_exp_eps_inv(x):
+def tf_exp_eps_inv(x: Union[np.ndarray, torch.Tensor]) -> Union[np.ndarray, torch.Tensor]:
     """Inverse of the epsilon-offset exponential transform.
 
     Args:
@@ -71,7 +78,7 @@ def tf_exp_eps_inv(x):
     return tf_exp_inv(x - EPS64)
 
 
-def tf_square(x):
+def tf_square(x: Union[np.ndarray, torch.Tensor]) -> Union[np.ndarray, torch.Tensor]:
     """Square transform.
 
     Args:
@@ -83,7 +90,7 @@ def tf_square(x):
     return x**2
 
 
-def tf_square_inv(x):
+def tf_square_inv(x: Union[np.ndarray, torch.Tensor]) -> Union[np.ndarray, torch.Tensor]:
     """Inverse of the square transform.
 
     Args:
@@ -96,7 +103,7 @@ def tf_square_inv(x):
     return npt.sqrt(x)
 
 
-def tf_square_eps(x):
+def tf_square_eps(x: Union[np.ndarray, torch.Tensor]) -> Union[np.ndarray, torch.Tensor]:
     """Square transform offset by machine epsilon.
 
     Args:
@@ -108,7 +115,7 @@ def tf_square_eps(x):
     return tf_square(x) + EPS64
 
 
-def tf_square_eps_inv(x):
+def tf_square_eps_inv(x: Union[np.ndarray, torch.Tensor]) -> Union[np.ndarray, torch.Tensor]:
     """Inverse of the epsilon-offset square transform.
 
     Args:
@@ -120,7 +127,7 @@ def tf_square_eps_inv(x):
     return tf_square_inv(x - EPS64)
 
 
-def tf_explinear(x):
+def tf_explinear(x: Union[np.ndarray, torch.Tensor]) -> Union[np.ndarray, torch.Tensor]:
     """Exponential-linear (softplus) transform.
 
     Behaves like ``exp(x)`` for small ``x`` and like ``x`` for large ``x``, so it
@@ -139,7 +146,7 @@ def tf_explinear(x):
         return -npt.nn.functional.logsigmoid(-x)
 
 
-def tf_explinear_inv(x):
+def tf_explinear_inv(x: Union[np.ndarray, torch.Tensor]) -> Union[np.ndarray, torch.Tensor]:
     """Inverse of the exponential-linear transform.
 
     Args:
@@ -153,7 +160,7 @@ def tf_explinear_inv(x):
     return npt.where(x < 34, npt.log(npt.expm1(x)), x)
 
 
-def tf_explinear_eps(x):
+def tf_explinear_eps(x: Union[np.ndarray, torch.Tensor]) -> Union[np.ndarray, torch.Tensor]:
     """Exponential-linear transform offset by machine epsilon.
 
     Args:
@@ -165,7 +172,7 @@ def tf_explinear_eps(x):
     return tf_explinear(x) + EPS64
 
 
-def tf_explinear_eps_inv(x):
+def tf_explinear_eps_inv(x: Union[np.ndarray, torch.Tensor]) -> Union[np.ndarray, torch.Tensor]:
     """Inverse of the epsilon-offset exponential-linear transform.
 
     Args:
@@ -177,7 +184,7 @@ def tf_explinear_eps_inv(x):
     return tf_explinear_inv(x - EPS64)
 
 
-def tf_identity(x):
+def tf_identity(x: Union[np.ndarray, torch.Tensor]) -> Union[np.ndarray, torch.Tensor]:
     """Identity transform.
 
     Args:
@@ -190,17 +197,17 @@ def tf_identity(x):
 
 
 def parse_assign_param(
-    pname,
-    param,
-    shape_param,
-    requires_grad_param,
-    tfs_param,
-    endsize_ops,
-    constraints,
-    torchify,
-    npt,
-    nptkwargs,
-):
+    pname: str,
+    param: Union[float, np.ndarray, torch.Tensor],
+    shape_param: list,
+    requires_grad_param: bool,
+    tfs_param: tuple,
+    endsize_ops: list,
+    constraints: list,
+    torchify: bool,
+    npt: types.ModuleType,
+    nptkwargs: dict,
+) -> tuple:
     """Validate and normalize one kernel parameter, returning it in array form.
 
     A scalar is broadcast to ``shape_param``; an array-like is converted to the
@@ -215,7 +222,7 @@ def parse_assign_param(
         endsize_ops (list): Permitted sizes for the trailing dimension.
         constraints (list): Constraints the parameter must satisfy.
         torchify (bool): Return a ``torch.Tensor`` rather than an ``np.ndarray``.
-        npt (module): Array backend, either ``numpy`` or ``torch``.
+        npt (types.ModuleType): Array backend, either ``numpy`` or ``torch``.
         nptkwargs (dict): Backend keyword arguments such as ``dtype`` and ``device``.
 
     Returns:
diff --git a/scripts/annotate_public_api_types.py b/scripts/annotate_public_api_types.py
index e3a00271a..f88847bbd 100644
--- a/scripts/annotate_public_api_types.py
+++ b/scripts/annotate_public_api_types.py
@@ -125,29 +125,69 @@ class FileResult:
     changed: bool
 
 
+def _is_type_checking_test(test: ast.expr) -> bool:
+    """True for an `if` test of `TYPE_CHECKING` or `typing.TYPE_CHECKING`.
+
+    Names bound only under this guard are never executed at runtime, so an
+    annotation that references them is safe exactly when the module also
+    enables postponed evaluation (`from __future__ import annotations`) --
+    the annotation is then stored as an unevaluated string.
+    """
+    if isinstance(test, ast.Name):
+        return test.id == "TYPE_CHECKING"
+    return isinstance(test, ast.Attribute) and test.attr == "TYPE_CHECKING"
+
+
+def _collect_import_names(node: ast.stmt, names: set[str]) -> None:
+    """Add the names one import-like or binding statement introduces."""
+    if isinstance(node, ast.Import):
+        for alias in node.names:
+            names.add(alias.asname or alias.name.split(".")[0])
+    elif isinstance(node, ast.ImportFrom):
+        for alias in node.names:
+            if alias.name != "*":
+                names.add(alias.asname or alias.name)
+    elif isinstance(node, (ast.ClassDef, ast.FunctionDef, ast.AsyncFunctionDef)):
+        names.add(node.name)
+    elif isinstance(node, (ast.Assign, ast.AnnAssign, ast.NamedExpr)):
+        targets = node.targets if isinstance(node, ast.Assign) else [node.target]
+        for target in targets:
+            if isinstance(target, ast.Name):
+                names.add(target.id)
+
+
+def _has_future_annotations(tree: ast.Module) -> bool:
+    """True if the module enables postponed evaluation of annotations."""
+    return any(
+        isinstance(node, ast.ImportFrom)
+        and node.module == "__future__"
+        and any(alias.name == "annotations" for alias in node.names)
+        for node in tree.body
+    )
+
+
 def _module_names(tree: ast.Module, before_line: int) -> set[str]:
-    """Collect module names bound before a callable's definition."""
+    """Collect module names bound before a callable's definition.
+
+    Names introduced only inside an `if TYPE_CHECKING:` guard are included
+    too, but only when the module also has `from __future__ import
+    annotations`: such names are unavailable at runtime, and without
+    postponed evaluation a signature referencing one would raise NameError
+    the moment the function is defined.
+    """
     names = set(BUILTIN_TYPE_NAMES)
+    include_type_checking = _has_future_annotations(tree)
     for node in tree.body:
         if getattr(node, "lineno", before_line) >= before_line:
             continue
-        if isinstance(node, ast.Import):
-            for alias in node.names:
-                names.add(alias.asname or alias.name.split(".")[0])
-        elif isinstance(node, ast.ImportFrom):
-            for alias in node.names:
-                if alias.name != "*":
-                    names.add(alias.asname or alias.name)
-        elif isinstance(
-            node,
-            (ast.ClassDef, ast.FunctionDef, ast.AsyncFunctionDef),
+        _collect_import_names(node, names)
+        if (
+            include_type_checking
+            and isinstance(node, ast.If)
+            and _is_type_checking_test(node.test)
         ):
-            names.add(node.name)
-        elif isinstance(node, (ast.Assign, ast.AnnAssign, ast.NamedExpr)):
-            targets = node.targets if isinstance(node, ast.Assign) else [node.target]
-            for target in targets:
-                if isinstance(target, ast.Name):
-                    names.add(target.id)
+            for sub in node.body:
+                _collect_import_names(sub, names)
     return names
 
 
diff --git a/scripts/baseline_counts.json b/scripts/baseline_counts.json
index 8721ace92..f7669b751 100644
--- a/scripts/baseline_counts.json
+++ b/scripts/baseline_counts.json
@@ -1,5 +1,5 @@
 {
   "check_docstring": 0,
-  "pydoclint": 151,
+  "pydoclint": 101,
   "unsafe_annotations": 109
 }
diff --git a/scripts/check_baseline.py b/scripts/check_baseline.py
index ceffcc31a..323fee3f4 100644
--- a/scripts/check_baseline.py
+++ b/scripts/check_baseline.py
@@ -15,6 +15,15 @@
 
 `--update` is for a change that intentionally reduces (or, with justification
 in the PR description, increases) one of these counts.
+
+A mid-migration branch (e.g. adding type hints to signatures across many
+files) can make a count spike well above the committed baseline before it
+comes back down -- pydoclint's DOC105/106/107 cross-check every arg's
+signature type against its docstring type, so partially-applied hints
+surface more mismatches than having no hints at all. That is expected, not
+a bug in this script: `make check` will keep reporting "REGRESSED" for that
+check until the migration is complete and `--update` is run to record the
+new, lower count.
 """
 import json
 import re

From 057d8dc2c41e46a1113e626f1e6fb4d0cb3dcf65 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Wed, 9 Sep 2026 10:43:52 +0800
Subject: [PATCH 41/51] Add type hints

---
 pyproject.toml                                |  8 +++++--
 qmcpy/kernel/abstract_kernel.py               |  8 +++----
 qmcpy/kernel/multitask_kernel.py              |  8 +++----
 .../abstract_stopping_criterion.py            | 24 +++++++++----------
 qmcpy/stopping_criterion/diagnostics.py       |  8 +++++--
 qmcpy/true_measure/acceptance_rejection.py    | 19 ++++++++-------
 scripts/baseline_counts.json                  |  4 ++--
 7 files changed, 45 insertions(+), 34 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index 68ee105aa..a3744cebe 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -189,8 +189,12 @@ class = [
 
 [tool.pydoclint]
 # `make check_docstring` reads this. QMCPy convention: constructor arguments are
-# documented in the __init__ method's own docstring, and parameter types live in
-# the docstring (`name (type): ...`), not in the signature.
+# documented in the __init__ method's own docstring, and parameter types are
+# given in both the signature and the docstring (`name (type): ...`), kept in
+# sync by scripts/annotate_public_api_types.py. Optional heavy dependencies
+# (torch, matplotlib, pandas, ...) that a module only imports lazily are
+# referenced via `from __future__ import annotations` + `if TYPE_CHECKING:`
+# so the annotation never forces an eager import.
 style = "google"
 allow-init-docstring = true
 arg-type-hints-in-signature = true
diff --git a/qmcpy/kernel/abstract_kernel.py b/qmcpy/kernel/abstract_kernel.py
index 62a1a0773..1c55fdbdf 100644
--- a/qmcpy/kernel/abstract_kernel.py
+++ b/qmcpy/kernel/abstract_kernel.py
@@ -107,7 +107,7 @@ def get_batch_params(self, ndim: int) -> dict:
             for pname, batch_param in self.batch_params.items()
         }
 
-    def __call__(self, x0, x1, beta0=None, beta1=None, c=None, **kwargs: dict):
+    def __call__(self, x0: Union[np.ndarray, torch.Tensor], x1: Union[np.ndarray, torch.Tensor], beta0: Union[None, np.ndarray, torch.Tensor] = None, beta1: Union[None, np.ndarray, torch.Tensor] = None, c: Union[None, np.ndarray, torch.Tensor] = None, **kwargs: dict):
         r"""Evaluate the kernel with (optional) partial derivatives
 
         $$\sum_{\ell=1}^p c_{\ell}
@@ -120,13 +120,13 @@ def __call__(self, x0, x1, beta0=None, beta1=None, c=None, **kwargs: dict):
                 first input to kernel with
             x1 (Union[np.ndarray, torch.Tensor]): Shape `x1.shape=(...,d)`
                 second input to kernel with
-            beta0 (Union[np.ndarray, torch.Tensor]): Shape `beta0.shape=(p,d)`
+            beta0 (Union[None, np.ndarray, torch.Tensor]): Shape `beta0.shape=(p,d)`
                 derivative orders with respect to first inputs,
                 $\boldsymbol{\beta}_0$.
-            beta1 (Union[np.ndarray, torch.Tensor]): Shape `beta1.shape=(p,d)`
+            beta1 (Union[None, np.ndarray, torch.Tensor]): Shape `beta1.shape=(p,d)`
                 derivative orders with respect to first inputs,
                 $\boldsymbol{\beta}_1$.
-            c (Union[np.ndarray, torch.Tensor]): Shape `c.shape=(p,)`
+            c (Union[None, np.ndarray, torch.Tensor]): Shape `c.shape=(p,)`
                 coefficients of derivatives.
             **kwargs (dict): keyword arguments to parsed call
         Returns:
diff --git a/qmcpy/kernel/multitask_kernel.py b/qmcpy/kernel/multitask_kernel.py
index 9f421dcb4..880803cd5 100644
--- a/qmcpy/kernel/multitask_kernel.py
+++ b/qmcpy/kernel/multitask_kernel.py
@@ -499,7 +499,7 @@ def _parsed__call__(self, task0, task1, k_x):
         kmat = k_x * kmat_tasks
         return kmat[..., 0]
 
-    def __call__(self, task0, task1, x0, x1, beta0=None, beta1=None, c=None):
+    def __call__(self, task0: Union[int, np.ndarray, torch.Tensor], task1: Union[int, np.ndarray, torch.Tensor], x0: Union[np.ndarray, torch.Tensor], x1: Union[np.ndarray, torch.Tensor], beta0: Union[None, np.ndarray, torch.Tensor] = None, beta1: Union[None, np.ndarray, torch.Tensor] = None, c: Union[None, np.ndarray, torch.Tensor] = None):
         r"""Evaluate the kernel with (optional) partial derivatives
 
         $$\sum_{\ell=1}^p c_\ell
@@ -516,13 +516,13 @@ def __call__(self, task0, task1, x0, x1, beta0=None, beta1=None, c=None):
                 first input to kernel.
             x1 (Union[np.ndarray, torch.Tensor]): Shape `x1.shape=(...,d)`
                 second input to kernel.
-            beta0 (Union[np.ndarray, torch.Tensor]): Shape `beta0.shape=(p,d)`
+            beta0 (Union[None, np.ndarray, torch.Tensor]): Shape `beta0.shape=(p,d)`
                 derivative orders with respect to first inputs,
                 $\boldsymbol{\beta}_0$.
-            beta1 (Union[np.ndarray, torch.Tensor]): Shape `beta1.shape=(p,d)`
+            beta1 (Union[None, np.ndarray, torch.Tensor]): Shape `beta1.shape=(p,d)`
                 derivative orders with respect to first inputs,
                 $\boldsymbol{\beta}_1$.
-            c (Union[np.ndarray, torch.Tensor]): Shape `c.shape=(p,)`
+            c (Union[None, np.ndarray, torch.Tensor]): Shape `c.shape=(p,)`
                 coefficients of derivatives.
 
         Returns:
diff --git a/qmcpy/stopping_criterion/abstract_stopping_criterion.py b/qmcpy/stopping_criterion/abstract_stopping_criterion.py
index 09f3e2d84..261054839 100644
--- a/qmcpy/stopping_criterion/abstract_stopping_criterion.py
+++ b/qmcpy/stopping_criterion/abstract_stopping_criterion.py
@@ -1,5 +1,5 @@
 from ..util.data import Data
-from typing import TYPE_CHECKING, TextIO, Union
+from typing import TYPE_CHECKING, Any, Callable, TextIO, Union
 import copy
 import sys
 
@@ -267,18 +267,18 @@ def print_iteration_log(self, history: "Union[None, _IterationHistoryTable]" = N
             file=file,
         )
 
-    def _prepare_resume_data(self, resume: Data or None, validate_resume, restore_resume):
+    def _prepare_resume_data(self, resume: Union[None, Data], validate_resume: Callable, restore_resume: Callable):
         """Validate and restore a resume checkpoint before integration.
 
         Args:
-            resume (Data or None): Resume checkpoint passed to ``integrate``.
-            validate_resume (callable): Validator taking ``resume`` and raising
+            resume (Union[None, Data]): Resume checkpoint passed to ``integrate``.
+            validate_resume (Callable): Validator taking ``resume`` and raising
                 on incompatible state.
-            restore_resume (callable): Restorer taking ``resume`` and mutating
+            restore_resume (Callable): Restorer taking ``resume`` and mutating
                 the current stopping criterion into a compatible resumed state.
 
         Returns:
-            Data or None: A validated deep copy of the supplied checkpoint, or
+            Union[None, Data]: A validated deep copy of the supplied checkpoint, or
             None when no checkpoint was supplied.
         """
         if resume is None:
@@ -407,7 +407,7 @@ def _finalize_integration_data(self, data: Data, elapsed: float, resume_provenan
         data.history_df = getattr(self, "history_df", None)
         self._annotate_checkpoint_metadata(data)
 
-    def _resume_value_equal(self, current, saved):
+    def _resume_value_equal(self, current: Any, saved: Any):
         """Deep equality check tolerant of arrays, lists, dicts, and QMCPy
         objects.
 
@@ -595,11 +595,11 @@ def _is_power_of_two(n):
         return n > 0 and (n & (n - 1)) == 0
 
     @staticmethod
-    def _resolve_error_fun(error_fun):
+    def _resolve_error_fun(error_fun: Union[str, Callable]):
         """Resolve an *error_fun* argument from a string keyword or callable.
 
         Args:
-            error_fun (Union[str, callable]): ``'EITHER'`` or ``'BOTH'`` or a
+            error_fun (Union[str, Callable]): ``'EITHER'`` or ``'BOTH'`` or a
                 callable with signature ``(sv, abs_tol, rel_tol) -> tol``.
 
         Returns:
@@ -639,7 +639,7 @@ def _checkpoint_rmse_tol(data: Data):
                 pass
         return None
 
-    def _init_control_variates(self, control_variates: list or AbstractIntegrand, control_variate_means):
+    def _init_control_variates(self, control_variates: Union[list, AbstractIntegrand], control_variate_means: np.ndarray):
         """Validate and store control variates and their means.
 
         Sets ``self.cv``, ``self.cv_mu``, and ``self.ncv`` after validating
@@ -648,9 +648,9 @@ def _init_control_variates(self, control_variates: list or AbstractIntegrand, co
         the main integrand.
 
         Args:
-            control_variates (list or AbstractIntegrand): Control variate
+            control_variates (Union[list, AbstractIntegrand]): Control variate
                 integrand(s).
-            control_variate_means (array-like): Known means of each control
+            control_variate_means (np.ndarray): Known means of each control
                 variate.
 
         Returns:
diff --git a/qmcpy/stopping_criterion/diagnostics.py b/qmcpy/stopping_criterion/diagnostics.py
index aaa1fd08a..ac498ab0c 100644
--- a/qmcpy/stopping_criterion/diagnostics.py
+++ b/qmcpy/stopping_criterion/diagnostics.py
@@ -1,12 +1,16 @@
 """Diagnostics helpers for stopping-criterion iteration tracing."""
+from __future__ import annotations
 
-from typing import Union
+from typing import TYPE_CHECKING, Union
 import io
 import numpy as np
 import sys
 from contextlib import redirect_stdout
 from math import log10
 
+if TYPE_CHECKING:
+    from .abstract_stopping_criterion import AbstractStoppingCriterion
+
 # ITER rows up to this count are always printed; above it the log-scale throttle applies.
 _THROTTLE_ITER_THRESHOLD = 30
 
@@ -451,7 +455,7 @@ def _format_iteration_log(
 
 
 class _IterationTraceLogger(object):
-    def __init__(self, stopping_criterion):
+    def __init__(self, stopping_criterion: AbstractStoppingCriterion):
         """Create a trace logger bound to the given stopping criterion.
 
         Args:
diff --git a/qmcpy/true_measure/acceptance_rejection.py b/qmcpy/true_measure/acceptance_rejection.py
index 1e2929143..d43917262 100644
--- a/qmcpy/true_measure/acceptance_rejection.py
+++ b/qmcpy/true_measure/acceptance_rejection.py
@@ -1,5 +1,8 @@
-from typing import Union
+from typing import Callable, List, Union
 from .abstract_true_measure import AbstractTrueMeasure
+from ..discrete_distribution.abstract_discrete_distribution import (
+    AbstractDiscreteDistribution,
+)
 from ..util import MethodImplementationError, ParameterError
 import numpy as np
 import warnings
@@ -30,7 +33,7 @@ class AcceptanceRejection(AbstractTrueMeasure):
         sampler (AbstractDiscreteDistribution): A QMCPy discrete distribution
             of dimension s = target_dim + 1. Must mimic StdUniform. The last
             coordinate is used as the acceptance threshold.
-        target_density (callable): Unnormalised target density psi(x) where x
+        target_density (Callable): Unnormalised target density psi(x) where x
             has shape (N, d). Must return shape (N,) and be non-negative on
             [0,1]^d.
         upper_bound (float): L = sup_{x in [0,1]^d} psi(x). Every evaluation of
@@ -76,7 +79,7 @@ class AcceptanceRejection(AbstractTrueMeasure):
         qmcpy.util.exceptions_warnings.ParameterError: n_min > 0 but no prior call was made. Call gen_samples with n_min=0 first.
     """
 
-    def __init__(self, sampler, target_density, upper_bound, density_integral, max_retries=4) -> None:
+    def __init__(self, sampler: AbstractDiscreteDistribution, target_density: Callable, upper_bound: float, density_integral: float, max_retries: int = 4) -> None:
         self.parameters = ['target_dim', 'upper_bound', 'density_integral', 'acceptance_rate']
         self.domain = np.array([[0, 1]])
         self._parse_sampler(sampler)
@@ -233,14 +236,14 @@ class AcceptanceRejectionReal(AbstractTrueMeasure):
     Args:
         sampler (AbstractDiscreteDistribution): A QMCPy discrete distribution
             of dimension s = target_dim + 1. Must mimic StdUniform.
-        target_density (callable): Unnormalised target density psi(z) where z
+        target_density (Callable): Unnormalised target density psi(z) where z
             has shape (N, d). Must return shape (N,). Must satisfy psi(z) <= L
             * H(z) for all z.
-        inv_cdfs (list of callable): List of d quantile functions [F_1^{-1},
+        inv_cdfs (List[Callable]): List of d quantile functions [F_1^{-1},
             ..., F_d^{-1}], one per dimension. Each maps a 1-D array of
             uniforms in [0,1] to R. Example: [scipy.stats.norm.ppf] for a 1-D
             standard Gaussian.
-        H_func (callable): Auxiliary bound function H(z) where z has shape (N,
+        H_func (Callable): Auxiliary bound function H(z) where z has shape (N,
             d). Must return shape (N,) and satisfy psi(z) <= L * H(z) for all z
             in R^d.
         upper_bound (float): L satisfying psi(z) <= L * H(z) for all z.
@@ -290,8 +293,8 @@ class AcceptanceRejectionReal(AbstractTrueMeasure):
         qmcpy.util.exceptions_warnings.ParameterError: n_min > 0 but no prior call was made. Call gen_samples with n_min=0 first.
     """
 
-    def __init__(self, sampler, target_density, inv_cdfs, H_func,
-                 upper_bound, density_integral, max_retries=4) -> None:
+    def __init__(self, sampler: AbstractDiscreteDistribution, target_density: Callable, inv_cdfs: List[Callable], H_func: Callable,
+                 upper_bound: float, density_integral: float, max_retries: int = 4) -> None:
         self.parameters = ['target_dim', 'upper_bound', 'density_integral', 'acceptance_rate']
         self.domain = np.array([[0, 1]])
         self._parse_sampler(sampler)
diff --git a/scripts/baseline_counts.json b/scripts/baseline_counts.json
index f7669b751..cc7ab45b8 100644
--- a/scripts/baseline_counts.json
+++ b/scripts/baseline_counts.json
@@ -1,5 +1,5 @@
 {
   "check_docstring": 0,
-  "pydoclint": 101,
-  "unsafe_annotations": 109
+  "pydoclint": 0,
+  "unsafe_annotations": 0
 }

From 0f9413341f9d00966eab7fea6bff8c4ae1e8db0f Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Wed, 9 Sep 2026 10:52:55 +0800
Subject: [PATCH 42/51] `i.e. ` -> `i.e., `

---
 demos/acceptance_rejection.ipynb                              | 2 +-
 demos/lebesgue_integration.ipynb                              | 2 +-
 .../MCQMC_2020_QMC_Software_Tutorial.ipynb                    | 2 +-
 .../SorokinThesis2025/sorokin_thesis_2025.ipynb               | 4 ++--
 .../digital_net_any_bases/digital_net_any_bases.py            | 2 +-
 qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py  | 2 +-
 qmcpy/integrand/custom_fun.py                                 | 2 +-
 qmcpy/integrand/sensitivity_indices.py                        | 2 +-
 qmcpy/true_measure/matern_gp.py                               | 2 +-
 9 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/demos/acceptance_rejection.ipynb b/demos/acceptance_rejection.ipynb
index 8bed5e925..b6dfbba55 100644
--- a/demos/acceptance_rejection.ipynb
+++ b/demos/acceptance_rejection.ipynb
@@ -494,7 +494,7 @@
     "$$D^*_N(\\psi) = \\sup_{t \\in [0,1]} \\left| \\frac{\\#\\{i : x_i \\leq t\\}}{N} - \\frac{1}{C}\\int_0^t \\psi(x)\\,dx \\right|$$\n",
     "\n",
     "Theorem 1 of Zhu & Dick (2014) predicts:\n",
-    "- **Sobol driver (DAR):** $D^*_N = O(N^{-1/s})$ with $s=2$ for $d=1$, i.e. $O(N^{-1/2})$ in the worst case — but empirically faster due to the $\\log N$ factors.\n",
+    "- **Sobol driver (DAR):** $D^*_N = O(N^{-1/s})$ with $s=2$ for $d=1$, i.e., $O(N^{-1/2})$ in the worst case — but empirically faster due to the $\\log N$ factors.\n",
     "- **Random driver (standard A-R):** $D^*_N = O(N^{-1/2})$ always.\n",
     "\n",
     "The plot below measures this empirically for $\\psi(x) = 2x$ on $[0,1]$, where the CDF is $F(t) = t^2$ and $C = 1$."
diff --git a/demos/lebesgue_integration.ipynb b/demos/lebesgue_integration.ipynb
index 4db928774..3894898b1 100644
--- a/demos/lebesgue_integration.ipynb
+++ b/demos/lebesgue_integration.ipynb
@@ -3,7 +3,7 @@
   {
    "cell_type": "markdown",
    "metadata": {},
-   "source": "# QMCPy for Lebesgue Integration\nThis notebook will give examples of how to use QMCPy for integration problems that are not defined in terms of a standard measure. i.e. Uniform or Gaussian. "
+   "source": "# QMCPy for Lebesgue Integration\nThis notebook will give examples of how to use QMCPy for integration problems that are not defined in terms of a standard measure. i.e., Uniform or Gaussian. "
   },
   {
    "cell_type": "markdown",
diff --git a/demos/talk_paper_demos/MCQMC_Tutorial_2020/MCQMC_2020_QMC_Software_Tutorial.ipynb b/demos/talk_paper_demos/MCQMC_Tutorial_2020/MCQMC_2020_QMC_Software_Tutorial.ipynb
index 82136d126..aa7a8da55 100644
--- a/demos/talk_paper_demos/MCQMC_Tutorial_2020/MCQMC_2020_QMC_Software_Tutorial.ipynb
+++ b/demos/talk_paper_demos/MCQMC_Tutorial_2020/MCQMC_2020_QMC_Software_Tutorial.ipynb
@@ -2780,7 +2780,7 @@
             " |          - Pass in `generating_matrices` *without* interlacing and supply `alpha`>1 to apply interlacing, or\n",
             " |          - Pass in `generating_matrices` *with* interlacing and set `alpha=1` to avoid additional interlacing\n",
             " |\n",
-            " |          i.e. do *not* pass in interlaced `generating_matrices` and set `alpha>1`, this will apply additional interlacing.\n",
+            " |          i.e., do *not* pass in interlaced `generating_matrices` and set `alpha>1`, this will apply additional interlacing.\n",
             " |\n",
             " |  Examples:\n",
             " |      >>> discrete_distrib = DigitalNetB2(2,seed=7)\n",
diff --git a/demos/talk_paper_demos/SorokinThesis2025/sorokin_thesis_2025.ipynb b/demos/talk_paper_demos/SorokinThesis2025/sorokin_thesis_2025.ipynb
index 95e13d4fe..125d952c6 100644
--- a/demos/talk_paper_demos/SorokinThesis2025/sorokin_thesis_2025.ipynb
+++ b/demos/talk_paper_demos/SorokinThesis2025/sorokin_thesis_2025.ipynb
@@ -95,7 +95,7 @@
     "    dimension = 52, \n",
     "    randomize = \"LMS DS\", # Matousek's LMS then a digital shift\n",
     "    # other options [\"NUS\", \"DS\", \"LMS\", None]\n",
-    "    t = 64, # number of LMS bits i.e. number of rows in S_j\n",
+    "    t = 64, # number of LMS bits i.e., number of rows in S_j\n",
     "    alpha = 2, # interlacing factor for higher order digital nets\n",
     "    replications = 16, # R\n",
     "    order = \"radical inverse\", # also supports \"Gray code\"\n",
@@ -124,7 +124,7 @@
     "    dimension = 52, \n",
     "    randomize = \"LMS DP\", # Matousek's LMS then a digital permutation\n",
     "    # other options [\"LMS DS\", \"LMS\", \"DP\", \"DS\", \"NUS\", \"QRNG\", None]\n",
-    "    t = 64, # number of LMS digits i.e. number of rows in S_j\n",
+    "    t = 64, # number of LMS digits i.e., number of rows in S_j\n",
     "    replications = 16, # R\n",
     "    seed = None) # pass integer seed for reproducibility\n",
     "x = halton(2**10) # a numpy.ndarray with shape 16 x 1024 x 52"
diff --git a/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py b/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py
index 308fb3f1c..c88bd8809 100644
--- a/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py
+++ b/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py
@@ -24,7 +24,7 @@ class DigitalNetAnyBases(AbstractLDDiscreteDistribution):
             - Pass in `generating_matrices` *without* interlacing and supply `alpha>1` to apply interlacing, or
             - Pass in `generating_matrices` *with* interlacing and set `alpha=1` to avoid additional interlacing.
 
-            i.e. do *not* pass in interlaced `generating_matrices` and set
+            i.e., do *not* pass in interlaced `generating_matrices` and set
             `alpha>1`, this will apply additional interlacing.
 
     A few examples below showcase how to pass in custom bases and generating
diff --git a/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py b/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
index 4780c49db..c67f094bc 100644
--- a/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
+++ b/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
@@ -21,7 +21,7 @@ class DigitalNetB2(AbstractLDDiscreteDistribution):
             - Pass in `generating_matrices` *without* interlacing and supply `alpha`>1 to apply interlacing, or
             - Pass in `generating_matrices` *with* interlacing and set `alpha=1` to avoid additional interlacing
 
-            i.e. do *not* pass in interlaced `generating_matrices` and set
+            i.e., do *not* pass in interlaced `generating_matrices` and set
             `alpha>1`, this will apply additional interlacing.
 
     Examples:
diff --git a/qmcpy/integrand/custom_fun.py b/qmcpy/integrand/custom_fun.py
index 806247aba..a8b0fbbfb 100644
--- a/qmcpy/integrand/custom_fun.py
+++ b/qmcpy/integrand/custom_fun.py
@@ -67,7 +67,7 @@ class CustomFun(AbstractIntegrand):
         Stopping criterion which supporting vectorized outputs may pass in
         Boolean `compute_flags` with `dimension_indv` shape indicating which
         output need to evaluated,
-            i.e. where `compute_flags` is `False` we do not need to evaluate
+            i.e., where `compute_flags` is `False` we do not need to evaluate
             the integrand. We have not used this in inexpensive example above.
 
         With independent replications
diff --git a/qmcpy/integrand/sensitivity_indices.py b/qmcpy/integrand/sensitivity_indices.py
index 636c39a37..b7607de56 100644
--- a/qmcpy/integrand/sensitivity_indices.py
+++ b/qmcpy/integrand/sensitivity_indices.py
@@ -9,7 +9,7 @@
 
 
 class SensitivityIndices(AbstractIntegrand):
-    r"""Sensitivity indices i.e. normalized Sobol' Indices.
+    r"""Sensitivity indices i.e., normalized Sobol' Indices.
 
     Examples:
         Singleton indices
diff --git a/qmcpy/true_measure/matern_gp.py b/qmcpy/true_measure/matern_gp.py
index be413198e..8fef135dd 100644
--- a/qmcpy/true_measure/matern_gp.py
+++ b/qmcpy/true_measure/matern_gp.py
@@ -100,7 +100,7 @@ def __init__(
             variance (float): Global scaling factor of the kernel. Retrievable
                 after construction via the `kernel_variance` property. (The
                 inherited `variance` attribute is the vector of marginal
-                variances, i.e. the diagonal of `covariance`.)
+                variances, i.e., the diagonal of `covariance`.)
             mean (Union[float, np.ndarray]): Mean vector for multivariate
                 `Gaussian`.
             nugget (float): Positive nugget to add to diagonal.

From f5c0dae3bd76b7ceb327811ac3e1b7e7ecc9b549 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Wed, 9 Sep 2026 11:14:40 +0800
Subject: [PATCH 43/51] remove redundant spaces in docstrings in "**References:
 **"

---
 .../digital_net_any_bases/digital_net_any_bases.py        | 2 +-
 .../discrete_distribution/digital_net_any_bases/halton.py | 2 +-
 .../digital_net_any_bases/hammersley.py                   | 2 +-
 .../digital_net_b2/digital_net_b2.py                      | 2 +-
 qmcpy/discrete_distribution/korobov.py                    | 2 +-
 qmcpy/discrete_distribution/latin_hypercube.py            | 2 +-
 qmcpy/integrand/box_integral.py                           | 2 +-
 qmcpy/integrand/financial_option.py                       | 2 +-
 qmcpy/integrand/ishigami.py                               | 2 +-
 qmcpy/integrand/keister.py                                | 2 +-
 qmcpy/integrand/sensitivity_indices.py                    | 2 +-
 qmcpy/kernel/si_dsi_kernels.py                            | 8 ++++----
 qmcpy/stopping_criterion/cub_mc_g.py                      | 2 +-
 qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py       | 2 +-
 qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py           | 2 +-
 qmcpy/stopping_criterion/cub_qmc_lattice_g.py             | 2 +-
 qmcpy/stopping_criterion/cub_qmc_net_g.py                 | 2 +-
 qmcpy/stopping_criterion/pf_gp_ci.py                      | 2 +-
 qmcpy/true_measure/brownian_motion.py                     | 2 +-
 qmcpy/true_measure/clayton_copula.py                      | 2 +-
 qmcpy/true_measure/frank_copula.py                        | 2 +-
 qmcpy/true_measure/gaussian_copula.py                     | 2 +-
 qmcpy/true_measure/gumbel_copula.py                       | 2 +-
 qmcpy/true_measure/kumaraswamy.py                         | 2 +-
 qmcpy/true_measure/matern_gp.py                           | 2 +-
 qmcpy/true_measure/student_t_copula.py                    | 2 +-
 qmcpy/true_measure/zero_inflated_exp_uniform.py           | 2 +-
 qmcpy/util/dig_shift_invar_ops.py                         | 2 +-
 28 files changed, 31 insertions(+), 31 deletions(-)

diff --git a/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py b/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py
index c88bd8809..667f882fa 100644
--- a/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py
+++ b/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py
@@ -144,7 +144,7 @@ class DigitalNetAnyBases(AbstractLDDiscreteDistribution):
         >>> bool((x==x_b2).all())
         True
 
-    **References: **
+    **References:**
 
     1.  Dick, Josef, and Friedrich Pillichshammer.
         Digital nets and sequences: discrepancy theory and quasi–Monte Carlo integration.
diff --git a/qmcpy/discrete_distribution/digital_net_any_bases/halton.py b/qmcpy/discrete_distribution/digital_net_any_bases/halton.py
index e245d3905..b4630bb4a 100644
--- a/qmcpy/discrete_distribution/digital_net_any_bases/halton.py
+++ b/qmcpy/discrete_distribution/digital_net_any_bases/halton.py
@@ -149,7 +149,7 @@ class Halton(DigitalNetAnyBases):
                 [0.34111023, 0.84596814, 0.0292313 ],
                 [0.71866903, 0.23852281, 0.80431142]]])
 
-    **References: **
+    **References:**
 
     1.  Marius Hofert and Christiane Lemieux.
         qrng: (Randomized) Quasi-Random Number Generators.
diff --git a/qmcpy/discrete_distribution/digital_net_any_bases/hammersley.py b/qmcpy/discrete_distribution/digital_net_any_bases/hammersley.py
index 2cbe5c267..3fdfaf4e0 100644
--- a/qmcpy/discrete_distribution/digital_net_any_bases/hammersley.py
+++ b/qmcpy/discrete_distribution/digital_net_any_bases/hammersley.py
@@ -54,7 +54,7 @@ class Hammersley(DigitalNetAnyBases):
                [0.5 ],
                [0.75]])
 
-    **References: **
+    **References:**
 
     1.  J. Dick, F. Y. Kuo, and I. H. Sloan.
         High-dimensional integration: the quasi-Monte Carlo way.
diff --git a/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py b/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
index c67f094bc..240223708 100644
--- a/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
+++ b/qmcpy/discrete_distribution/digital_net_b2/digital_net_b2.py
@@ -174,7 +174,7 @@ class DigitalNetB2(AbstractLDDiscreteDistribution):
                 [0.94219959, 0.39172304, 0.20285965],
                 [0.19716391, 0.64741585, 0.92494554]]])
 
-    **References: **
+    **References:**
 
     1.  Marius Hofert and Christiane Lemieux.
         qrng: (Randomized) Quasi-Random Number Generators (2019).
diff --git a/qmcpy/discrete_distribution/korobov.py b/qmcpy/discrete_distribution/korobov.py
index 5c775f151..10f1b0b50 100644
--- a/qmcpy/discrete_distribution/korobov.py
+++ b/qmcpy/discrete_distribution/korobov.py
@@ -132,7 +132,7 @@ class KorobovLattice(AbstractLDDiscreteDistribution):
                [0.75 , 0.25 ],
                [0.875, 0.625]])
 
-    **References: **
+    **References:**
 
     1.  N. M. Korobov.
         The approximate computation of multiple integrals.
diff --git a/qmcpy/discrete_distribution/latin_hypercube.py b/qmcpy/discrete_distribution/latin_hypercube.py
index 19258db8a..2c1581fe9 100644
--- a/qmcpy/discrete_distribution/latin_hypercube.py
+++ b/qmcpy/discrete_distribution/latin_hypercube.py
@@ -67,7 +67,7 @@ class LatinHypercube(AbstractDiscreteDistribution):
                [0.875, 0.125]])
 
 
-    **References: **
+    **References:**
 
     1.  M. D. McKay, R. J. Beckman, and W. J. Conover.
         A Comparison of Three Methods for Selecting Values of Input Variables in the Analysis of Output from a Computer Code.
diff --git a/qmcpy/integrand/box_integral.py b/qmcpy/integrand/box_integral.py
index e47c2d585..aaf93720b 100644
--- a/qmcpy/integrand/box_integral.py
+++ b/qmcpy/integrand/box_integral.py
@@ -60,7 +60,7 @@ class BoxIntegral(AbstractIntegrand):
         array([[1.        , 0.76519118, 0.66666666],
                [0.62718785, 0.62224086, 0.64273341]])
 
-    **References: **
+    **References:**
 
     1.  D.H. Bailey, J.M. Borwein, R.E. Crandall, Box integrals.
         Journal of Computational and Applied Mathematics, Volume 206, Issue 1, 2007, Pages 196-208, ISSN 0377-0427.
diff --git a/qmcpy/integrand/financial_option.py b/qmcpy/integrand/financial_option.py
index aa2ed048c..3676b0e9d 100644
--- a/qmcpy/integrand/financial_option.py
+++ b/qmcpy/integrand/financial_option.py
@@ -233,7 +233,7 @@ class FinancialOption(AbstractIntegrand):
         >>> print("%.4f"%muhathat.sum())
         1.7982
 
-    **References: **
+    **References:**
 
     1.  M.B. Giles.
         Improved multilevel Monte Carlo convergence using the Milstein scheme.
diff --git a/qmcpy/integrand/ishigami.py b/qmcpy/integrand/ishigami.py
index 04a9d8b38..b8e8c6504 100644
--- a/qmcpy/integrand/ishigami.py
+++ b/qmcpy/integrand/ishigami.py
@@ -50,7 +50,7 @@ class Ishigami(AbstractIntegrand):
         >>> print("%.4f"%muhats.mean())
         3.4646
 
-    **References: **
+    **References:**
 
     1.  Ishigami, T., & Homma, T.
         An importance quantification technique in uncertainty analysis for computer models.
diff --git a/qmcpy/integrand/keister.py b/qmcpy/integrand/keister.py
index d3ae71f13..54399f8ad 100644
--- a/qmcpy/integrand/keister.py
+++ b/qmcpy/integrand/keister.py
@@ -42,7 +42,7 @@ class Keister(AbstractIntegrand):
         >>> print("%.4f"%muhats.mean())
         1.8024
 
-    **References: **
+    **References:**
 
     1.  B. D. Keister.
         Multidimensional Quadrature Algorithms.
diff --git a/qmcpy/integrand/sensitivity_indices.py b/qmcpy/integrand/sensitivity_indices.py
index b7607de56..7dc5ab703 100644
--- a/qmcpy/integrand/sensitivity_indices.py
+++ b/qmcpy/integrand/sensitivity_indices.py
@@ -97,7 +97,7 @@ class SensitivityIndices(AbstractIntegrand):
         >>> closed_total_approx.shape
         (2, 4, 4, 5, 6)
 
-    **References: **
+    **References:**
 
     1.  Aleksei G. Sorokin and Jagadeeswaran Rathinavel.
         On Bounding and Approximating Functions of Multiple Expectations Using Quasi-Monte Carlo.
diff --git a/qmcpy/kernel/si_dsi_kernels.py b/qmcpy/kernel/si_dsi_kernels.py
index 10d546b72..a82aac5be 100644
--- a/qmcpy/kernel/si_dsi_kernels.py
+++ b/qmcpy/kernel/si_dsi_kernels.py
@@ -373,7 +373,7 @@ class KernelShiftInvar(AbstractSIDSIKernel):
         >>> np.allclose(ynp,y.numpy())
         True
 
-    **References: **
+    **References:**
 
     1.  Kaarnioja, Vesa, Frances Y. Kuo, and Ian H. Sloan.
         "Lattice-based kernel approximation and serendipitous weights for parametric PDEs in very high dimensions."
@@ -597,7 +597,7 @@ class KernelShiftInvarCombined(AbstractSIDSIKernel):
         >>> np.abs(kfast-kstable).max()
         np.float64(3.552713678800501e-15)
 
-    **References: **
+    **References:**
 
     1.  Kaarnioja, Vesa, Frances Y. Kuo, and Ian H. Sloan.
         "Lattice-based kernel approximation and serendipitous weights for parametric PDEs in very high dimensions."
@@ -867,7 +867,7 @@ class KernelDigShiftInvar(AbstractSIDSIKernel):
         >>> np.abs(kfast-kstable).max()
         np.float64(4.440892098500626e-16)
 
-    **References: **
+    **References:**
 
     1.  Dick, Josef.
         "Walsh spaces containing smooth functions and quasi-Monte Carlo rules of arbitrary high order."
@@ -1179,7 +1179,7 @@ class KernelDigShiftInvarAdaptiveAlpha(AbstractSIDSIKernel):
         >>> np.abs(kfast-kstable).max()
         np.float64(4.440892098500626e-16)
 
-    **References: **
+    **References:**
 
     3.  Dick, Josef, and Friedrich Pillichshammer.
         "Multivariate integration in weighted Hilbert spaces based on Walsh functions and weighted Sobolev spaces."
diff --git a/qmcpy/stopping_criterion/cub_mc_g.py b/qmcpy/stopping_criterion/cub_mc_g.py
index a3316f84a..c694109b4 100644
--- a/qmcpy/stopping_criterion/cub_mc_g.py
+++ b/qmcpy/stopping_criterion/cub_mc_g.py
@@ -238,7 +238,7 @@ class CubMCG(AbstractStoppingCriterion):
             replications    1
             entropy         7
 
-    **References: **
+    **References:**
 
     1.  Fred J. Hickernell, Lan Jiang, Yuewei Liu, and Art B. Owen,
         "Guaranteed conservative fixed width confidence intervals via Monte Carlo sampling,"
diff --git a/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py b/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py
index f25b0ff95..1286841ac 100644
--- a/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py
+++ b/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py
@@ -164,7 +164,7 @@ class CubQMCBayesLatticeG(AbstractCubBayesLDG):
             n_limit         2^(20)
             entropy         7
 
-    **References: **
+    **References:**
 
     1.  Jagadeeswaran, Rathinavel, and Fred J. Hickernell.
         "Fast automatic Bayesian cubature using lattice sampling."
diff --git a/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py b/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py
index 1c002da82..780e6184e 100644
--- a/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py
+++ b/qmcpy/stopping_criterion/cub_qmc_bayes_net_g.py
@@ -173,7 +173,7 @@ class CubQMCBayesNetG(AbstractCubBayesLDG):
             n_limit         2^(32)
             entropy         7
 
-    **References: **
+    **References:**
 
     1.  Jagadeeswaran, Rathinavel, and Fred J. Hickernell.
         "Fast automatic Bayesian cubature using Sobol’sampling."
diff --git a/qmcpy/stopping_criterion/cub_qmc_lattice_g.py b/qmcpy/stopping_criterion/cub_qmc_lattice_g.py
index 229e13960..073ec5156 100644
--- a/qmcpy/stopping_criterion/cub_qmc_lattice_g.py
+++ b/qmcpy/stopping_criterion/cub_qmc_lattice_g.py
@@ -160,7 +160,7 @@ class CubQMCLatticeG(AbstractCubQMCLDG):
             n_limit         2^(20)
             entropy         7
 
-    **References: **
+    **References:**
 
     1.  Lluis Antoni Jimenez Rugama and Fred J. Hickernell.
         "Adaptive multidimensional integration based on rank-1 lattices,"
diff --git a/qmcpy/stopping_criterion/cub_qmc_net_g.py b/qmcpy/stopping_criterion/cub_qmc_net_g.py
index aa210e319..0ca1579bc 100644
--- a/qmcpy/stopping_criterion/cub_qmc_net_g.py
+++ b/qmcpy/stopping_criterion/cub_qmc_net_g.py
@@ -203,7 +203,7 @@ class CubQMCNetG(AbstractCubQMCLDG):
         array([16384, 16384, 16384])
         >>> assert (np.abs(true_value-solution)<abs_tol).all()
 
-    **References: **
+    **References:**
 
     1.  Hickernell, Fred J., and Lluís Antoni Jiménez Rugama.
         "Reliable adaptive cubature using digital sequences."
diff --git a/qmcpy/stopping_criterion/pf_gp_ci.py b/qmcpy/stopping_criterion/pf_gp_ci.py
index 79a4e72c1..0feda6432 100644
--- a/qmcpy/stopping_criterion/pf_gp_ci.py
+++ b/qmcpy/stopping_criterion/pf_gp_ci.py
@@ -217,7 +217,7 @@ class PFGPCI(AbstractStoppingCriterion):
               error_ref: [2.01e-02   7.02e-03   1.28e-02   4.52e-03  ]
                   in_ci: [True       True       True       True      ]
 
-    **References: **
+    **References:**
 
     1.  Sorokin, Aleksei G., and Vishwas Rao.
         "Credible Intervals for Probability of Failure with Gaussian Processes."
diff --git a/qmcpy/true_measure/brownian_motion.py b/qmcpy/true_measure/brownian_motion.py
index 614ea08bd..dc2e593da 100644
--- a/qmcpy/true_measure/brownian_motion.py
+++ b/qmcpy/true_measure/brownian_motion.py
@@ -133,7 +133,7 @@ class BrownianMotion(Gaussian):
         >>> true_measure.bridge_output_times
         array([0.6, 1. , 0.3, 0.8])
 
-        **References: **
+        **References:**
 
         1.  Art B. Owen.
             Monte Carlo theory, methods and examples.
diff --git a/qmcpy/true_measure/clayton_copula.py b/qmcpy/true_measure/clayton_copula.py
index f6eda3c9c..6b28cf8d1 100644
--- a/qmcpy/true_measure/clayton_copula.py
+++ b/qmcpy/true_measure/clayton_copula.py
@@ -67,7 +67,7 @@ class ClaytonCopula(AbstractCopula):
         >>> ClaytonCopula(DigitalNetB2(2, seed=7), marginals=marginals, theta=1e-8)(4).shape
         (4, 2)
 
-    **References: **
+    **References:**
 
     1.  Roger B. Nelsen. *An Introduction to Copulas*. Second Edition,
         Springer Series in Statistics, Springer, 2006.
diff --git a/qmcpy/true_measure/frank_copula.py b/qmcpy/true_measure/frank_copula.py
index c6a5104fc..ac591f12c 100644
--- a/qmcpy/true_measure/frank_copula.py
+++ b/qmcpy/true_measure/frank_copula.py
@@ -90,7 +90,7 @@ class FrankCopula(AbstractCopula):
         >>> FrankCopula(DigitalNetB2(5, seed=7), marginals=[stats.uniform()] * 5, theta=5.0)(4).shape
         (4, 5)
 
-    **References: **
+    **References:**
 
     1.  Roger B. Nelsen. *An Introduction to Copulas*. Second Edition,
         Springer Series in Statistics, Springer, 2006.
diff --git a/qmcpy/true_measure/gaussian_copula.py b/qmcpy/true_measure/gaussian_copula.py
index 3a742bfa4..4908ec3e0 100644
--- a/qmcpy/true_measure/gaussian_copula.py
+++ b/qmcpy/true_measure/gaussian_copula.py
@@ -69,7 +69,7 @@ class GaussianCopula(AbstractCopula):
         >>> GaussianCopula(DigitalNetB2(1, seed=7), marginals=[stats.norm()], correlation=[[1.0]])(4).shape
         (4, 1)
 
-    **References: **
+    **References:**
 
     1.  Roger B. Nelsen. *An Introduction to Copulas*. Second Edition,
         Springer Series in Statistics, Springer, 2006.
diff --git a/qmcpy/true_measure/gumbel_copula.py b/qmcpy/true_measure/gumbel_copula.py
index f53d46d25..96bff94d0 100644
--- a/qmcpy/true_measure/gumbel_copula.py
+++ b/qmcpy/true_measure/gumbel_copula.py
@@ -63,7 +63,7 @@ class GumbelCopula(AbstractCopula):
         >>> bool(((0 <= independent_samples) & (independent_samples <= 1)).all())
         True
 
-    **References: **
+    **References:**
 
     1.  Roger B. Nelsen. *An Introduction to Copulas*. Second Edition,
         Springer Series in Statistics, Springer, 2006.
diff --git a/qmcpy/true_measure/kumaraswamy.py b/qmcpy/true_measure/kumaraswamy.py
index 92e6f9473..a5765473b 100644
--- a/qmcpy/true_measure/kumaraswamy.py
+++ b/qmcpy/true_measure/kumaraswamy.py
@@ -124,7 +124,7 @@ def _compute_moments(self):
         Every operation is elementwise on the per-coordinate parameters $a$ and
         $b$, so ``mean`` and ``variance`` are returned as length-``d`` arrays.
 
-        **References: **
+        **References:**
 
         1.  Kumaraswamy distribution. Wikipedia.
             [https://en.wikipedia.org/wiki/Kumaraswamy_distribution](https://en.wikipedia.org/wiki/Kumaraswamy_distribution).
diff --git a/qmcpy/true_measure/matern_gp.py b/qmcpy/true_measure/matern_gp.py
index 8fef135dd..93f5d1212 100644
--- a/qmcpy/true_measure/matern_gp.py
+++ b/qmcpy/true_measure/matern_gp.py
@@ -57,7 +57,7 @@ class MaternGP(Gaussian):
                 [0.2147053 , 0.33293508, 0.43572791],
                 [0.37343973, 0.46534628, 0.56356714]]])
 
-    **References: **
+    **References:**
 
     1.  [`sklearn.gaussian_process.kernels.Matern`](https://scikit-learn.org/stable/modules/generated/sklearn.gaussian_process.kernels.Matern.html).
 
diff --git a/qmcpy/true_measure/student_t_copula.py b/qmcpy/true_measure/student_t_copula.py
index 71e7259f1..4316c1f47 100644
--- a/qmcpy/true_measure/student_t_copula.py
+++ b/qmcpy/true_measure/student_t_copula.py
@@ -70,7 +70,7 @@ class StudentTCopula(AbstractCopula):
         >>> StudentTCopula(DigitalNetB2(2, seed=7), marginals=marginals, correlation=corr, df=1)(4).shape
         (4, 2)
 
-    **References: **
+    **References:**
 
     1.  Roger B. Nelsen. *An Introduction to Copulas*. Second Edition,
         Springer Series in Statistics, Springer, 2006.
diff --git a/qmcpy/true_measure/zero_inflated_exp_uniform.py b/qmcpy/true_measure/zero_inflated_exp_uniform.py
index c29eea2ae..f1f5707c6 100644
--- a/qmcpy/true_measure/zero_inflated_exp_uniform.py
+++ b/qmcpy/true_measure/zero_inflated_exp_uniform.py
@@ -292,7 +292,7 @@ def _compute_moments(self):
         returned as length-1 arrays for consistency with the other true
         measures.
 
-        **References: **
+        **References:**
 
         1.  Exponential distribution. Wikipedia.
             [https://en.wikipedia.org/wiki/Exponential_distribution](https://en.wikipedia.org/wiki/Exponential_distribution).
diff --git a/qmcpy/util/dig_shift_invar_ops.py b/qmcpy/util/dig_shift_invar_ops.py
index b8edf9e94..d7459893e 100644
--- a/qmcpy/util/dig_shift_invar_ops.py
+++ b/qmcpy/util/dig_shift_invar_ops.py
@@ -129,7 +129,7 @@ def weighted_walsh_funcs(alpha: int, xb: Union[np.ndarray, torch.Tensor], t: int
     Returns:
         Union[np.ndarray, torch.Tensor]: Weighted Walsh function values.
 
-    **References: **
+    **References:**
 
         1.  Dick, Josef.
             "Walsh spaces containing smooth functions and quasi–Monte Carlo rules of arbitrary high order."

From f37c6ff27bd12056ba0a947a5beb67b60db61a6a Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Wed, 9 Sep 2026 11:24:59 +0800
Subject: [PATCH 44/51] Adjust spaces and minor issues in docstrings

---
 makefile                                           |  2 +-
 .../abstract_discrete_distribution.py              |  2 +-
 qmcpy/integrand/abstract_integrand.py              |  2 +-
 qmcpy/kernel/abstract_kernel.py                    |  2 +-
 qmcpy/kernel/multitask_kernel.py                   |  2 +-
 .../abstract_stopping_criterion.py                 |  2 +-
 qmcpy/stopping_criterion/cub_mc_g.py               |  4 ++++
 qmcpy/stopping_criterion/pf_gp_ci.py               |  6 +++---
 qmcpy/true_measure/abstract_true_measure.py        |  4 ++--
 qmcpy/true_measure/acceptance_rejection.py         | 14 ++++++++------
 qmcpy/util/exact_gpytorch_regression_model.py      |  2 +-
 qmcpy/util/latnetbuilder_linker.py                 |  4 ++--
 qmcpy/util/transforms.py                           |  4 ++--
 13 files changed, 28 insertions(+), 22 deletions(-)

diff --git a/makefile b/makefile
index cd1b841e7..743e9a58b 100644
--- a/makefile
+++ b/makefile
@@ -198,7 +198,7 @@ doctests_minimal: ensure_artifacts
 		--ignore qmcpy/kernel/ \
 		--ignore qmcpy/util/dig_shift_invar_ops.py \
 		--ignore qmcpy/util/shift_invar_ops.py \
-		--ignore qmcpy/util/exact_gpytorch_gression_model.py \
+		--ignore qmcpy/util/exact_gpytorch_regression_model.py \
 		--ignore qmcpy/integrand/umbridge_wrapper.py \
 		--ignore qmcpy/integrand/hartmann6d.py \
 		--ignore qmcpy/discrete_distribution/mpmc/ \
diff --git a/qmcpy/discrete_distribution/abstract_discrete_distribution.py b/qmcpy/discrete_distribution/abstract_discrete_distribution.py
index a03873060..1ac23439a 100644
--- a/qmcpy/discrete_distribution/abstract_discrete_distribution.py
+++ b/qmcpy/discrete_distribution/abstract_discrete_distribution.py
@@ -59,7 +59,7 @@ def __init__(self, dimension, replications, seed, d_limit, n_limit) -> None:
         self.spawn_key = self._base_seed.spawn_key
         self.rng = np.random.Generator(np.random.SFC64(self._base_seed))
 
-    def __call__(self, n: Union[None, int] = None, n_min: Union[None, int] = None, n_max: Union[None, int] = None, return_binary: bool = False, warn: bool = True):
+    def __call__(self, n: Union[None, int] = None, n_min: Union[None, int] = None, n_max: Union[None, int] = None, return_binary: bool = False, warn: bool = True) -> np.ndarray:
         r"""
         - If just `n` is supplied, generate samples from the sequence at indices 0,...,`n`-1.
         - If `n_min` and `n_max` are supplied, generate samples from the sequence at indices `n_min`,...,`n_max`-1.
diff --git a/qmcpy/integrand/abstract_integrand.py b/qmcpy/integrand/abstract_integrand.py
index 40e8a6a88..44a9495d4 100644
--- a/qmcpy/integrand/abstract_integrand.py
+++ b/qmcpy/integrand/abstract_integrand.py
@@ -89,7 +89,7 @@ def __init__(self, dimension_indv: tuple, dimension_comb: tuple, parallel: int,
             )
         self.EPS = np.finfo(float).eps
 
-    def __call__(self, n: Union[None, int] = None, n_min: Union[None, int] = None, n_max: Union[None, int] = None, warn: bool = True):
+    def __call__(self, n: Union[None, int] = None, n_min: Union[None, int] = None, n_max: Union[None, int] = None, warn: bool = True) -> np.ndarray:
         r"""
         - If just `n` is supplied, generate samples from the sequence at indices 0,...,`n`-1.
         - If `n_min` and `n_max` are supplied, generate samples from the sequence at indices `n_min`,...,`n_max`-1.
diff --git a/qmcpy/kernel/abstract_kernel.py b/qmcpy/kernel/abstract_kernel.py
index 1c55fdbdf..4c2c33988 100644
--- a/qmcpy/kernel/abstract_kernel.py
+++ b/qmcpy/kernel/abstract_kernel.py
@@ -107,7 +107,7 @@ def get_batch_params(self, ndim: int) -> dict:
             for pname, batch_param in self.batch_params.items()
         }
 
-    def __call__(self, x0: Union[np.ndarray, torch.Tensor], x1: Union[np.ndarray, torch.Tensor], beta0: Union[None, np.ndarray, torch.Tensor] = None, beta1: Union[None, np.ndarray, torch.Tensor] = None, c: Union[None, np.ndarray, torch.Tensor] = None, **kwargs: dict):
+    def __call__(self, x0: Union[np.ndarray, torch.Tensor], x1: Union[np.ndarray, torch.Tensor], beta0: Union[None, np.ndarray, torch.Tensor] = None, beta1: Union[None, np.ndarray, torch.Tensor] = None, c: Union[None, np.ndarray, torch.Tensor] = None, **kwargs: dict) -> Union[np.ndarray, torch.Tensor]:
         r"""Evaluate the kernel with (optional) partial derivatives
 
         $$\sum_{\ell=1}^p c_{\ell}
diff --git a/qmcpy/kernel/multitask_kernel.py b/qmcpy/kernel/multitask_kernel.py
index 880803cd5..a02c9cb97 100644
--- a/qmcpy/kernel/multitask_kernel.py
+++ b/qmcpy/kernel/multitask_kernel.py
@@ -499,7 +499,7 @@ def _parsed__call__(self, task0, task1, k_x):
         kmat = k_x * kmat_tasks
         return kmat[..., 0]
 
-    def __call__(self, task0: Union[int, np.ndarray, torch.Tensor], task1: Union[int, np.ndarray, torch.Tensor], x0: Union[np.ndarray, torch.Tensor], x1: Union[np.ndarray, torch.Tensor], beta0: Union[None, np.ndarray, torch.Tensor] = None, beta1: Union[None, np.ndarray, torch.Tensor] = None, c: Union[None, np.ndarray, torch.Tensor] = None):
+    def __call__(self, task0: Union[int, np.ndarray, torch.Tensor], task1: Union[int, np.ndarray, torch.Tensor], x0: Union[np.ndarray, torch.Tensor], x1: Union[np.ndarray, torch.Tensor], beta0: Union[None, np.ndarray, torch.Tensor] = None, beta1: Union[None, np.ndarray, torch.Tensor] = None, c: Union[None, np.ndarray, torch.Tensor] = None) -> Union[np.ndarray, torch.Tensor]:
         r"""Evaluate the kernel with (optional) partial derivatives
 
         $$\sum_{\ell=1}^p c_\ell
diff --git a/qmcpy/stopping_criterion/abstract_stopping_criterion.py b/qmcpy/stopping_criterion/abstract_stopping_criterion.py
index 261054839..147f26ef3 100644
--- a/qmcpy/stopping_criterion/abstract_stopping_criterion.py
+++ b/qmcpy/stopping_criterion/abstract_stopping_criterion.py
@@ -94,7 +94,7 @@ def integrate(self, resume: Union[None, Data] = None) -> tuple:
 
         Returns:
             tuple: Approximation to the integral with shape ``integrand.d_comb`` and
-            the corresponding data object.
+                the corresponding data object.
         """
         raise MethodImplementationError(self, "integrate")
 
diff --git a/qmcpy/stopping_criterion/cub_mc_g.py b/qmcpy/stopping_criterion/cub_mc_g.py
index c694109b4..a29b51bd4 100644
--- a/qmcpy/stopping_criterion/cub_mc_g.py
+++ b/qmcpy/stopping_criterion/cub_mc_g.py
@@ -594,3 +594,7 @@ def _tol_fun(abs_tol: float, rel_tol: float, theta: float, mu: float, toltype: s
         return theta * abs_tol + (1 - theta) * rel_tol * abs(mu)
     elif toltype == "max":  # the max case
         return max(abs_tol, rel_tol * abs(mu))
+    else:
+        raise ParameterError(
+            f"unknown toltype {toltype!r}; expected 'combine' or 'max'."
+        )
diff --git a/qmcpy/stopping_criterion/pf_gp_ci.py b/qmcpy/stopping_criterion/pf_gp_ci.py
index 0feda6432..76e2e83de 100644
--- a/qmcpy/stopping_criterion/pf_gp_ci.py
+++ b/qmcpy/stopping_criterion/pf_gp_ci.py
@@ -633,9 +633,9 @@ def get_results_dict(self) -> dict:
 
         Returns:
             dict: Per-iteration `"iter"`, `"n_sum"` (cumulative sample
-            count), `"n_batch"`, `"error_bounds"`, `"ci_low"`, `"ci_high"`,
-            and `"solutions"` arrays; plus `"solutions_ref"`, `"error_ref"`,
-            and `"in_ci"` if `self.approx_true_solution`.
+                count), `"n_batch"`, `"error_bounds"`, `"ci_low"`, `"ci_high"`,
+                and `"solutions"` arrays; plus `"solutions_ref"`, `"error_ref"`,
+                and `"in_ci"` if `self.approx_true_solution`.
         """
         df = {
             "iter": np.arange(len(self.n_sum)),
diff --git a/qmcpy/true_measure/abstract_true_measure.py b/qmcpy/true_measure/abstract_true_measure.py
index ad5942bef..98a137b41 100644
--- a/qmcpy/true_measure/abstract_true_measure.py
+++ b/qmcpy/true_measure/abstract_true_measure.py
@@ -1,4 +1,4 @@
-from typing import Union
+from typing import Tuple, Union
 from ..util import MethodImplementationError, _univ_repr, ParameterError
 from ..discrete_distribution.abstract_discrete_distribution import (
     AbstractDiscreteDistribution,
@@ -141,7 +141,7 @@ def _parse_sampler(self, sampler):
                 "sampler input should either be a AbstractDiscreteDistribution or AbstractTrueMeasure"
             )
 
-    def __call__(self, n: Union[None, int] = None, n_min: Union[None, int] = None, n_max: Union[None, int] = None, return_weights: bool = False, warn: bool = True):
+    def __call__(self, n: Union[None, int] = None, n_min: Union[None, int] = None, n_max: Union[None, int] = None, return_weights: bool = False, warn: bool = True) -> Union[np.ndarray, Tuple[np.ndarray, np.ndarray]]:
         r"""
         - If just `n` is supplied, generate samples from the sequence at indices 0,...,`n`-1.
         - If `n_min` and `n_max` are supplied, generate samples from the sequence at indices `n_min`,...,`n_max`-1.
diff --git a/qmcpy/true_measure/acceptance_rejection.py b/qmcpy/true_measure/acceptance_rejection.py
index d43917262..98a837028 100644
--- a/qmcpy/true_measure/acceptance_rejection.py
+++ b/qmcpy/true_measure/acceptance_rejection.py
@@ -134,9 +134,10 @@ def gen_samples(self, n: Union[None, int] = None, n_min: Union[None, int] = None
                 after all retries.
 
         Returns:
-            np.ndarray: Shape (n, target_dim).
-            weights (np.ndarray): Shape (n,). Only returned when
-                return_weights=True.
+            np.ndarray: Accepted samples of shape (n, target_dim). When
+                return_weights=True, a tuple (samples, weights) is returned
+                instead, where weights has shape (n,) and holds the importance
+                weights psi(x)/C.
         """
         if n_max is not None:
             if n_min is None:
@@ -350,9 +351,10 @@ def gen_samples(self, n: Union[None, int] = None, n_min: Union[None, int] = None
                 after all retries.
 
         Returns:
-            np.ndarray: Shape (n, target_dim).
-            weights (np.ndarray): Shape (n,). Only returned when
-                return_weights=True.
+            np.ndarray: Accepted samples of shape (n, target_dim). When
+                return_weights=True, a tuple (samples, weights) is returned
+                instead, where weights has shape (n,) and holds the importance
+                weights psi(z)/C.
         """
         if n_max is not None:
             if n_min is None:
diff --git a/qmcpy/util/exact_gpytorch_regression_model.py b/qmcpy/util/exact_gpytorch_regression_model.py
index c5efb9051..d5104de8d 100644
--- a/qmcpy/util/exact_gpytorch_regression_model.py
+++ b/qmcpy/util/exact_gpytorch_regression_model.py
@@ -129,7 +129,7 @@ def add_data(self, x_t_new: Union[np.ndarray, torch.Tensor], y_t_new: Union[np.n
 
         Returns:
             ExactGPyTorchRegressionModel: Fantasy model conditioned on the combined
-            training set. The receiver is left unchanged.
+                training set. The receiver is left unchanged.
         """
         if isinstance(x_t_new, np.ndarray):
             x_t_new = torch.from_numpy(x_t_new)
diff --git a/qmcpy/util/latnetbuilder_linker.py b/qmcpy/util/latnetbuilder_linker.py
index f5d36ab6f..e35cac16e 100644
--- a/qmcpy/util/latnetbuilder_linker.py
+++ b/qmcpy/util/latnetbuilder_linker.py
@@ -14,8 +14,8 @@ def latnetbuilder_linker(lnb_dir: str = "./", out_dir: str = "./", fout_prefix:
 
     Returns:
         str: path to file which can be passed into QMCPy's Lattice or Sobol' in
-        order to use the linked latnetbuilder generating vector/matrix e.g.
-        'my_poly_lat_vec.10.16.npy'
+            order to use the linked latnetbuilder generating vector/matrix e.g.
+            'my_poly_lat_vec.10.16.npy'
 
     Adapted from latnetbuilder parser:
         https://github.com/umontreal-simul/latnetbuilder/blob/master/python-wrapper/latnetbuilder/parse_output.py#L74
diff --git a/qmcpy/util/transforms.py b/qmcpy/util/transforms.py
index 05f549c55..1700ec991 100644
--- a/qmcpy/util/transforms.py
+++ b/qmcpy/util/transforms.py
@@ -22,7 +22,7 @@ def insert_batch_dims(param: Union[np.ndarray, torch.Tensor], ndims: int, k: int
 
     Returns:
         Union[np.ndarray, torch.Tensor]: ``param`` with ``ndims`` singleton axes
-        inserted after its first ``k`` axes.
+            inserted after its first ``k`` axes.
     """
     ones = [1] * ndims
     return param.reshape(list(param.shape[:k]) + ones + list(param.shape[k:]))
@@ -154,7 +154,7 @@ def tf_explinear_inv(x: Union[np.ndarray, torch.Tensor]) -> Union[np.ndarray, to
 
     Returns:
         Union[np.ndarray, torch.Tensor]: ``log(expm1(x))``, falling back to ``x`` once ``x >= 34``
-        where the two agree to machine precision.
+            where the two agree to machine precision.
     """
     npt = get_npt(x)
     return npt.where(x < 34, npt.log(npt.expm1(x)), x)

From 8f7af6ea54b5ee2e4e0f5f54aae98c4429a9caa5 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Wed, 9 Sep 2026 11:32:40 +0800
Subject: [PATCH 45/51] Better warning in docstrings

---
 qmcpy/util/data.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/qmcpy/util/data.py b/qmcpy/util/data.py
index e13848006..b5fa7d915 100644
--- a/qmcpy/util/data.py
+++ b/qmcpy/util/data.py
@@ -19,7 +19,7 @@ def __init__(self, parameters) -> None:
     def save(self, path: Union[str, Path], compress: bool = False, overwrite: bool = False) -> str:
         """Save this Data object to disk using pickle.
 
-        Warnings:
+        Warning:
             ``pickle`` files are not secure against untrusted input. Only save
             and later load checkpoint files that you created yourself or that
             come from a trusted source.
@@ -35,7 +35,7 @@ def save(self, path: Union[str, Path], compress: bool = False, overwrite: bool =
 
         Returns:
             str: The final path the file was written to (may differ from *path* when
-            ``compress=True`` appends ``.gz``).
+                ``compress=True`` appends ``.gz``).
 
         Raises:
             FileExistsError: If the target path already exists and
@@ -58,7 +58,7 @@ def save(self, path: Union[str, Path], compress: bool = False, overwrite: bool =
     def load(cls, path: Union[str, Path]) -> "Data":
         """Load a Data object from disk.
 
-        Warnings:
+        Warning:
             ``pickle`` deserialization can execute arbitrary code. Only load
             checkpoint files that you created yourself or that come from a
             trusted source.

From 8490235439904045d08ea8b762477d028875b720 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Wed, 9 Sep 2026 11:46:43 +0800
Subject: [PATCH 46/51] Better type hints in docstrings

---
 qmcpy/stopping_criterion/abstract_cub_bayes_ld_g.py     | 2 +-
 qmcpy/stopping_criterion/abstract_cub_mlmc.py           | 2 +-
 qmcpy/stopping_criterion/abstract_cub_mlqmc.py          | 2 +-
 qmcpy/stopping_criterion/abstract_cub_qmc_ld_g.py       | 2 +-
 qmcpy/stopping_criterion/abstract_stopping_criterion.py | 2 +-
 qmcpy/stopping_criterion/cub_mc_clt.py                  | 2 +-
 qmcpy/stopping_criterion/cub_mc_clt_vec.py              | 2 +-
 qmcpy/stopping_criterion/cub_mc_g.py                    | 2 +-
 qmcpy/stopping_criterion/cub_qmc_rep_student_t.py       | 2 +-
 9 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/qmcpy/stopping_criterion/abstract_cub_bayes_ld_g.py b/qmcpy/stopping_criterion/abstract_cub_bayes_ld_g.py
index de6625167..4fa56359e 100644
--- a/qmcpy/stopping_criterion/abstract_cub_bayes_ld_g.py
+++ b/qmcpy/stopping_criterion/abstract_cub_bayes_ld_g.py
@@ -508,7 +508,7 @@ def _validate_resume(self, data):
         if not self._is_power_of_two(n_total):
             raise ParameterError("resume data n_total must be a power of 2.")
 
-    def set_tolerance(self, abs_tol: Union[None, float] = None, rel_tol: Union[None, float] = None, rmse_tol: Union[None, float] = None):
+    def set_tolerance(self, abs_tol: Union[None, float] = None, rel_tol: Union[None, float] = None, rmse_tol: Union[None, float] = None) -> None:
         """Update the stopping criterion's target tolerance.
 
         Args:
diff --git a/qmcpy/stopping_criterion/abstract_cub_mlmc.py b/qmcpy/stopping_criterion/abstract_cub_mlmc.py
index 86c4ea2e2..99f1c2891 100644
--- a/qmcpy/stopping_criterion/abstract_cub_mlmc.py
+++ b/qmcpy/stopping_criterion/abstract_cub_mlmc.py
@@ -73,7 +73,7 @@ def _get_next_samples(self, data):
         )
         return ns.astype(int)
 
-    def set_tolerance(self, abs_tol: Union[None, float] = None, rel_tol: Union[None, float] = None, rmse_tol: Union[None, float] = None):
+    def set_tolerance(self, abs_tol: Union[None, float] = None, rel_tol: Union[None, float] = None, rmse_tol: Union[None, float] = None) -> None:
         """Update the stopping criterion's target tolerance.
 
         Args:
diff --git a/qmcpy/stopping_criterion/abstract_cub_mlqmc.py b/qmcpy/stopping_criterion/abstract_cub_mlqmc.py
index 9c6d4fb97..327906b58 100644
--- a/qmcpy/stopping_criterion/abstract_cub_mlqmc.py
+++ b/qmcpy/stopping_criterion/abstract_cub_mlqmc.py
@@ -108,7 +108,7 @@ def _resume_match_from_snapshots(snapshots, checkpoint):
             return resume_iter_count, snapshots[i:]
         return None, None
 
-    def set_tolerance(self, abs_tol: Union[None, float] = None, rel_tol: Union[None, float] = None, rmse_tol: Union[None, float] = None):
+    def set_tolerance(self, abs_tol: Union[None, float] = None, rel_tol: Union[None, float] = None, rmse_tol: Union[None, float] = None) -> None:
         """Update the stopping criterion's target tolerance.
 
         Args:
diff --git a/qmcpy/stopping_criterion/abstract_cub_qmc_ld_g.py b/qmcpy/stopping_criterion/abstract_cub_qmc_ld_g.py
index 43db55b3c..4d924810b 100644
--- a/qmcpy/stopping_criterion/abstract_cub_qmc_ld_g.py
+++ b/qmcpy/stopping_criterion/abstract_cub_qmc_ld_g.py
@@ -507,7 +507,7 @@ def integrate(self, resume: Union[None, Data] = None) -> tuple:
         trace.finalize()
         return data.solution, data
 
-    def set_tolerance(self, abs_tol: Union[None, float] = None, rel_tol: Union[None, float] = None, rmse_tol: Union[None, float] = None):
+    def set_tolerance(self, abs_tol: Union[None, float] = None, rel_tol: Union[None, float] = None, rmse_tol: Union[None, float] = None) -> None:
         """Update the stopping criterion's target tolerance.
 
         Args:
diff --git a/qmcpy/stopping_criterion/abstract_stopping_criterion.py b/qmcpy/stopping_criterion/abstract_stopping_criterion.py
index 147f26ef3..b784d7b04 100644
--- a/qmcpy/stopping_criterion/abstract_stopping_criterion.py
+++ b/qmcpy/stopping_criterion/abstract_stopping_criterion.py
@@ -736,7 +736,7 @@ def _compute_indv_alphas(self, alphas_comb: np.ndarray):
             alphas_indv = np.where(alpha_k_mat == 0, alphas_indv, np.minimum(alpha_k_mat, alphas_indv))
         return alphas_indv, identity_dependency
 
-    def set_tolerance(self, abs_tol: Union[None, float] = None, rel_tol: Union[None, float] = None, rmse_tol: Union[None, float] = None):
+    def set_tolerance(self, abs_tol: Union[None, float] = None, rel_tol: Union[None, float] = None, rmse_tol: Union[None, float] = None) -> None:
         """Reset the tolerances.
 
         Args:
diff --git a/qmcpy/stopping_criterion/cub_mc_clt.py b/qmcpy/stopping_criterion/cub_mc_clt.py
index bc2f9603b..cd35f5bf4 100644
--- a/qmcpy/stopping_criterion/cub_mc_clt.py
+++ b/qmcpy/stopping_criterion/cub_mc_clt.py
@@ -299,7 +299,7 @@ def integrate(self, resume: Union[None, Data] = None) -> tuple:
         trace.finalize()
         return data.solution, data
 
-    def set_tolerance(self, abs_tol: Union[None, float] = None, rel_tol: Union[None, float] = None, rmse_tol: Union[None, float] = None):
+    def set_tolerance(self, abs_tol: Union[None, float] = None, rel_tol: Union[None, float] = None, rmse_tol: Union[None, float] = None) -> None:
         """Update the stopping criterion's target tolerance.
 
         Args:
diff --git a/qmcpy/stopping_criterion/cub_mc_clt_vec.py b/qmcpy/stopping_criterion/cub_mc_clt_vec.py
index 7d737954a..b955f1991 100644
--- a/qmcpy/stopping_criterion/cub_mc_clt_vec.py
+++ b/qmcpy/stopping_criterion/cub_mc_clt_vec.py
@@ -376,7 +376,7 @@ def integrate(self, resume: Union[None, Data] = None) -> tuple:
         trace.finalize()
         return data.solution, data
 
-    def set_tolerance(self, abs_tol: Union[None, float] = None, rel_tol: Union[None, float] = None, rmse_tol: Union[None, float] = None):
+    def set_tolerance(self, abs_tol: Union[None, float] = None, rel_tol: Union[None, float] = None, rmse_tol: Union[None, float] = None) -> None:
         """Update the stopping criterion's target tolerance.
 
         Args:
diff --git a/qmcpy/stopping_criterion/cub_mc_g.py b/qmcpy/stopping_criterion/cub_mc_g.py
index a29b51bd4..d2978fada 100644
--- a/qmcpy/stopping_criterion/cub_mc_g.py
+++ b/qmcpy/stopping_criterion/cub_mc_g.py
@@ -554,7 +554,7 @@ def _ncbinv(self, n1, alpha1, kurtmax):
         # take the min of Chebyshev and Berry Esseen tolerance
         return eps
 
-    def set_tolerance(self, abs_tol: Union[None, float] = None, rel_tol: Union[None, float] = None, rmse_tol: Union[None, float] = None):
+    def set_tolerance(self, abs_tol: Union[None, float] = None, rel_tol: Union[None, float] = None, rmse_tol: Union[None, float] = None) -> None:
         """Update the stopping criterion's target tolerance.
 
         Args:
diff --git a/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py b/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py
index e54bbb021..12d242f50 100644
--- a/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py
+++ b/qmcpy/stopping_criterion/cub_qmc_rep_student_t.py
@@ -453,7 +453,7 @@ def _restore_resume_state(self, data):
         self.integrand.discrete_distrib = self.discrete_distrib
         self.integrand.true_measure.discrete_distrib = self.discrete_distrib
 
-    def set_tolerance(self, abs_tol: Union[None, float] = None, rel_tol: Union[None, float] = None, rmse_tol: Union[None, float] = None):
+    def set_tolerance(self, abs_tol: Union[None, float] = None, rel_tol: Union[None, float] = None, rmse_tol: Union[None, float] = None) -> None:
         """Update the stopping criterion's target tolerance.
 
         Args:

From 102c5ec0a0ed118483016bcda666e7cba7346305 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Thu, 10 Sep 2026 20:52:21 +0800
Subject: [PATCH 47/51] Add a demo and improve output clarity

---
 demos/makefile_dev_tools.ipynb                | 692 ++++++++++++++++++
 docs/good_practices.md                        |   2 +-
 makefile                                      | 148 ++--
 mkdocs.yml                                    |   1 +
 .../digital_net_any_bases.py                  |   4 +-
 qmcpy/discrete_distribution/kronecker.py      |   2 +-
 qmcpy/kernel/abstract_kernel.py               |   4 +-
 qmcpy/kernel/common_kernels.py                |   6 +-
 qmcpy/kernel/multitask_kernel.py              |   4 +-
 qmcpy/kernel/si_dsi_kernels.py                |  36 +-
 scripts/add_docstring_arg_types.py            |  16 +-
 scripts/check_baseline.py                     |  10 +-
 scripts/check_docstring.py                    |  21 +-
 scripts/check_links.py                        |  19 +-
 scripts/check_test_style.py                   |  34 +-
 scripts/colab_notebooks_manifest.json         |   1 +
 scripts/convert_asserts.py                    |  16 +-
 scripts/flatten_qmcpy_imports.py              |  13 +-
 scripts/harden_colab_notebook.py              |  16 +-
 scripts/remove_trailing_whitespace.py         |  15 +-
 scripts/unwrap_markdown.py                    |  12 +-
 test/booktests/tb_makefile_dev_tools.py       |  12 +
 22 files changed, 931 insertions(+), 153 deletions(-)
 create mode 100644 demos/makefile_dev_tools.ipynb
 create mode 100644 test/booktests/tb_makefile_dev_tools.py

diff --git a/demos/makefile_dev_tools.ipynb b/demos/makefile_dev_tools.ipynb
new file mode 100644
index 000000000..d78afacb8
--- /dev/null
+++ b/demos/makefile_dev_tools.ipynb
@@ -0,0 +1,692 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# `make format` and `make check`\n",
+    "\n",
+    "You run two commands around every change to QMCPy:\n",
+    "\n",
+    "| command | when | what it does |\n",
+    "|---|---|---|\n",
+    "| **`make format`** | before you commit | **changes your files**: imports, whitespace, asserts, docstring types |\n",
+    "| **`make check`** | before you open a PR | **only reads**: the same rules CI enforces |\n",
+    "\n",
+    "Each command runs a few small tools in order. This notebook walks through both, shows what each tool does on a tiny example, then lists the rest.\n",
+    "\n",
+    "The code cells run the real scripts when you are inside a QMCSoftware checkout. From a plain `pip install qmcpy` they print the same before/after as text."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/makefile_dev_tools.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title Execute this cell to install dependencies\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except ImportError:\n",
+    "  IN_COLAB = False\n",
+    "if IN_COLAB:\n",
+    "  !pip install -q qmcpy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Every import the notebook uses, in one place.\n",
+    "import json, os, pathlib, re, shutil, subprocess, sys, tempfile\n",
+    "\n",
+    "# The QMCSoftware checkout, or None when this notebook runs on its own.\n",
+    "REPO = next((d for d in (pathlib.Path.cwd(), *pathlib.Path.cwd().parents)\n",
+    "             if (d / \"scripts/convert_asserts.py\").exists()), None)\n",
+    "\n",
+    "def demo(tool, before, after, target, name=\"snippet.py\"):\n",
+    "    \"\"\"Print `Before`, then `After` running `tool` on it.\n",
+    "\n",
+    "    `tool` is the argument list for a script under scripts/. Inside a checkout\n",
+    "    the real script runs and its result replaces `after`; otherwise the canned\n",
+    "    `after` text is used.\n",
+    "    \"\"\"\n",
+    "    if REPO:\n",
+    "        f = pathlib.Path(tempfile.mkdtemp()) / name\n",
+    "        f.write_text(before)\n",
+    "        try:\n",
+    "            subprocess.run([sys.executable, *tool, str(f)], cwd=REPO,\n",
+    "                           capture_output=True, text=True, check=True)\n",
+    "            after = f.read_text()\n",
+    "        except (FileNotFoundError, subprocess.CalledProcessError):\n",
+    "            pass\n",
+    "    print(\"Before:\\n-------\\n\" + before)\n",
+    "    after_str = f\"After (make {target}):\"\n",
+    "    print(f\"{after_str}\\n\" + \"-\"*len(after_str) + \"\\n\" + after)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. The two pipelines\n",
+    "\n",
+    "`make format` and `make check` are just ordered lists of smaller targets. Here they are, read straight from the `makefile`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "make format\n",
+      "   flatten_qmcpy_imports\n",
+      "   markdown-unwrap\n",
+      "   rm_trailing_whitespace\n",
+      "   harden_colab_notebook\n",
+      "   convert_asserts_changed\n",
+      "   add_docstring_arg_types_changed\n",
+      "make check\n",
+      "   check_test_style\n",
+      "   check_docstring_changed\n",
+      "   check_baseline\n",
+      "   check_asserts_changed\n",
+      "   check_links\n"
+     ]
+    }
+   ],
+   "source": [
+    "DEFAULT = {\n",
+    "    \"format\": \"flatten_qmcpy_imports markdown-unwrap rm_trailing_whitespace \"\n",
+    "              \"harden_colab_notebook convert_asserts_changed add_docstring_arg_types_changed\".split(),\n",
+    "    \"check\": \"check_test_style check_docstring_changed check_baseline \"\n",
+    "             \"check_asserts_changed check_links\".split(),\n",
+    "}\n",
+    "\n",
+    "def steps(target):\n",
+    "    \"\"\"The sub-targets `make <target>` runs, read from the makefile.\"\"\"\n",
+    "    makefile = REPO / \"makefile\" if REPO else None\n",
+    "    if makefile and makefile.exists():\n",
+    "        block = re.search(rf\"^{target}:(?:.*\\n)((?:[ \\t].*\\n|\\n)+)\", makefile.read_text(), re.M)\n",
+    "        names = re.findall(r\"\\$\\(MAKE\\)\\s+(\\S+)\", block.group(1)) if block else []\n",
+    "        if names:\n",
+    "            return names\n",
+    "    return DEFAULT[target]\n",
+    "\n",
+    "for target in (\"format\", \"check\"):\n",
+    "    print(f\"make {target}\")\n",
+    "    for name in steps(target):\n",
+    "        print(\"  \", name)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Every step ends with **one summary line**, so a run is easy to scan:\n",
+    "\n",
+    "- `clean  (0/42 files)` — nothing to do\n",
+    "- `3 changed  (3/42 files)` — `make format` rewrote 3 files\n",
+    "- `WARNING: 2 problem(s)  (2/42 files)` — issues found, but this step does not fail the build\n",
+    "- `ERROR: 2 problem(s)  (2/42 files)` — issues found and this step fails (same as CI)\n",
+    "\n",
+    "Any details are listed just above that line, one `-` bullet each."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. `make format`: changes your files\n",
+    "\n",
+    "Run it before you commit. Every step is safe to run again and touches only what it needs to.\n",
+    "\n",
+    "| step | what it does |\n",
+    "|---|---|\n",
+    "| `flatten_qmcpy_imports` | rewrite `from qmcpy.sub.mod import X` as `import qmcpy as qp` then `qp.X` |\n",
+    "| `markdown-unwrap` | join hard-wrapped Markdown lines back into one line per paragraph |\n",
+    "| `rm_trailing_whitespace` | remove trailing spaces across the repo |\n",
+    "| `harden_colab_notebook` | add the *Open in Colab* badge to any demo notebook that lacks one |\n",
+    "| `convert_asserts_changed` | turn `assert` into a real `raise`, in changed files (next cell) |\n",
+    "| `add_docstring_arg_types_changed` | copy signature types into `Args:` lines, in changed files (cell after) |\n",
+    "\n",
+    "`format` has no docstring reformatter. `format-docstring` was tried and dropped: on this code it deletes `Returns:` and `Yields:` types and turns `**References:**` into `**References: **`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.1 `flatten_qmcpy_imports`\n",
+    "\n",
+    "Collapse a deep import path to the one public name. Anything exported by `qmcpy` should be reached as `qp.<Name>`, so imports stay stable when internal modules move."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Before:\n",
+      "-------\n",
+      "from qmcpy.discrete_distribution.lattice.lattice import Lattice\n",
+      "\n",
+      "After (make flatten_qmcpy_imports):\n",
+      "-----------------------------------\n",
+      "from qmcpy import Lattice\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "demo([\"scripts/flatten_qmcpy_imports.py\"],\n",
+    "\"\"\"from qmcpy.discrete_distribution.lattice.lattice import Lattice\n",
+    "\"\"\",\n",
+    "\"\"\"from qmcpy import Lattice\n",
+    "\"\"\", \"flatten_qmcpy_imports\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.2 `markdown_unwrap`\n",
+    "\n",
+    "Join each hard-wrapped Markdown paragraph back onto one line (code fences and math are left alone), so a later edit shows as a word change, not a whole-paragraph rewrap."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Before:\n",
+      "-------\n",
+      "QMCPy estimates an integral as the mean of an\n",
+      "integrand sampled on a low-discrepancy point\n",
+      "set, and stops once the error is small enough.\n",
+      "\n",
+      "After (make markdown_unwrap):\n",
+      "-----------------------------\n",
+      "QMCPy estimates an integral as the mean of an integrand sampled on a low-discrepancy point set, and stops once the error is small enough.\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "demo([\"scripts/unwrap_markdown.py\"],\n",
+    "\"QMCPy estimates an integral as the mean of an\\n\"\n",
+    "\"integrand sampled on a low-discrepancy point\\n\"\n",
+    "\"set, and stops once the error is small enough.\\n\",\n",
+    "\"QMCPy estimates an integral as the mean of an integrand sampled on a \"\n",
+    "\"low-discrepancy point set, and stops once the error is small enough.\\n\",\n",
+    "\"markdown_unwrap\", name=\"snippet.md\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.3 `rm_trailing_whitespace`\n",
+    "\n",
+    "Strip spaces and tabs at end of line across every git-tracked text file. Nothing to run on a snippet here — it asks git which files exist. Effect: `\"muhat = 1.80   \\n\"` becomes `\"muhat = 1.80\\n\"`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.4 `harden_colab_notebook`\n",
+    "\n",
+    "Add the *Open in Colab* badge cell and the dependency-install cell to any notebook under `demos/` that is listed in the Colab manifest but missing them. It works on real notebook files, not snippets; `make format` runs it for every still-unclassified notebook."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.5 `convert_asserts`\n",
+    "\n",
+    "`python -O` removes every `assert`, so a check written that way is gone when Python runs with `-O`. This rewrites it as a real `raise`, keeping comments and layout."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Before:\n",
+      "-------\n",
+      "def clip(x, lo, hi):\n",
+      "    assert lo <= hi, \"empty interval\"\n",
+      "\n",
+      "After (make convert_asserts_changed):\n",
+      "-------------------------------------\n",
+      "def clip(x, lo, hi):\n",
+      "    if not (lo <= hi):\n",
+      "        raise AssertionError(\"empty interval\")\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "demo([\"scripts/convert_asserts.py\", \"--exception\", \"AssertionError\"],\n",
+    "\"\"\"def clip(x, lo, hi):\n",
+    "    assert lo <= hi, \"empty interval\"\n",
+    "\"\"\",\n",
+    "\"\"\"def clip(x, lo, hi):\n",
+    "    if not (lo <= hi):\n",
+    "        raise AssertionError(\"empty interval\")\n",
+    "\"\"\", \"convert_asserts_changed\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.6 `add_docstring_arg_types`\n",
+    "\n",
+    "The type is already in the signature. This copies it into the matching `Args:` line (`name` becomes `name (type)`). It never makes up a type or a description."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Before:\n",
+      "-------\n",
+      "def disc_area(radius: float, n_sectors: int = 4) -> float:\n",
+      "    \"\"\"Area of a disc.\n",
+      "\n",
+      "    Args:\n",
+      "        radius: distance to the edge.\n",
+      "        n_sectors: wedge count.\n",
+      "    \"\"\"\n",
+      "    return 3.14159 * radius ** 2\n",
+      "\n",
+      "After (make add_docstring_arg_types_changed):\n",
+      "---------------------------------------------\n",
+      "def disc_area(radius: float, n_sectors: int = 4) -> float:\n",
+      "    \"\"\"Area of a disc.\n",
+      "\n",
+      "    Args:\n",
+      "        radius (float): distance to the edge.\n",
+      "        n_sectors (int): wedge count.\n",
+      "    \"\"\"\n",
+      "    return 3.14159 * radius ** 2\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "src = \"\"\"def disc_area(radius: float, n_sectors: int = 4) -> float:\n",
+    "    \\\"\\\"\\\"Area of a disc.\n",
+    "\n",
+    "    Args:\n",
+    "        radius: distance to the edge.\n",
+    "        n_sectors: wedge count.\n",
+    "    \\\"\\\"\\\"\n",
+    "    return 3.14159 * radius ** 2\n",
+    "\"\"\"\n",
+    "\n",
+    "demo([\"scripts/add_docstring_arg_types.py\"], src,\n",
+    "     src.replace(\"radius:\", \"radius (float):\").replace(\"n_sectors:\", \"n_sectors (int):\"),\n",
+    "     \"add_docstring_arg_types_changed\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. `make check`: only reads\n",
+    "\n",
+    "Run it before you open a PR. Nothing here changes your files. It runs the same checks as the *Check test-suite conventions* job in CI.\n",
+    "\n",
+    "| step | what it checks |\n",
+    "|---|---|\n",
+    "| `check_test_style` | each `test/` file is named `test_<area>_*.py` and uses a `unittest.TestCase` class (next cell) |\n",
+    "| `check_docstring_changed` | Google-style format plus `pydoclint`, on your changed files |\n",
+    "| `check_baseline` | the count of known issues did not go up (cell after) |\n",
+    "| `check_asserts_changed` | a dry run of `convert_asserts` on changed source |\n",
+    "| `check_links` | internal doc links and anchors resolve |\n",
+    "\n",
+    "Left out on purpose: `check_links_external` (needs the network) and `check_pep8_changed` (too many old violations to be a useful gate today)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.1 `check_test_style`\n",
+    "\n",
+    "One file that follows both rules, one that breaks both:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "  - 1 of 2 files use a unittest.TestCase class\n",
+      "  - 1 file(s) use bare pytest functions (no unittest.TestCase class):\n",
+      "    - test_zz_bad.py\n",
+      "  - 1 of 2 files use a test_<area>_ prefix (dd, ee, ft, ig, kn, sc, sr, tm, ut)\n",
+      "  - 1 file(s) have no recognized test_<area>_ prefix:\n",
+      "    - test_zz_bad.py\n",
+      "WARNING: 1 problem(s)  (1 of 2 files)\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "folder = pathlib.Path(tempfile.mkdtemp())\n",
+    "(folder / \"test_tm_ok.py\").write_text(\n",
+    "    \"import unittest\\nclass T(unittest.TestCase):\\n    def test_x(self): self.assertEqual(2, 2)\\n\")\n",
+    "(folder / \"test_zz_bad.py\").write_text(\"def test_x():\\n    assert 2 == 2\\n\")\n",
+    "\n",
+    "if REPO:\n",
+    "    # run from inside `folder` so the report shows plain file names\n",
+    "    result = subprocess.run([sys.executable, str(REPO / \"scripts/check_test_style.py\"), \".\"],\n",
+    "                            cwd=folder, capture_output=True, text=True)\n",
+    "    print(result.stdout)\n",
+    "else:\n",
+    "    print(\"test_zz_bad.py is flagged twice: it uses a bare function, and 'zz' is not a known area.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.2 `check_docstring`\n",
+    "\n",
+    "Two passes over public docstrings under `qmcpy/`: `check_docstring.py` for Google-style **format** (a one-line summary first, a blank line before each `Args:` / `Returns:`, canonical `Name:` headers) and `pydoclint` for **content** (every parameter and return documented). Informational unless `STRICT=--strict`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "  - mod.py:3: missing-summary: docstring opens with `Args:`; add a one-line summary first\n",
+      "  - 1 file(s) scanned: 1 issue(s) across 1 file(s): 1 missing-summary\n",
+      "WARNING: 1 problem(s)  (1 of 1 files)\n",
+      "\n",
+      "With STRICT=--strict the last line becomes 'ERROR: ...' and the exit is 1.\n"
+     ]
+    }
+   ],
+   "source": [
+    "mod = pathlib.Path(tempfile.mkdtemp()) / \"mod.py\"\n",
+    "mod.write_text(\n",
+    "    'def disc_area(radius):\\n'\n",
+    "    '    \"\"\"\\n'\n",
+    "    '    Args:\\n'\n",
+    "    '        radius (float): distance to the edge.\\n'\n",
+    "    '    \"\"\"\\n'\n",
+    "    '    return 3.14159 * radius ** 2\\n')\n",
+    "\n",
+    "if REPO:\n",
+    "    print(subprocess.run([sys.executable, str(REPO / \"scripts/check_docstring.py\"), mod.name],\n",
+    "                         cwd=mod.parent, capture_output=True, text=True).stdout)\n",
+    "else:\n",
+    "    print(\"  - mod.py:3: missing-summary: docstring opens with `Args:`; add a one-line summary first\")\n",
+    "    print(\"WARNING: 1 problem(s)  (1/1 files)\")\n",
+    "print(\"With STRICT=--strict the last line becomes 'ERROR: ...' and the exit is 1.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.3 `check_baseline`\n",
+    "\n",
+    "Some checks have many old violations, so they cannot fail the build yet. Their counts are stored in a file, and the build fails only if a count goes up."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "stored counts: {'check_docstring': 0, 'pydoclint': 0, 'unsafe_annotations': 0}\n",
+      "make check_baseline fails if any count goes above this.\n",
+      "make check_baseline_update saves new counts after you fix or accept a change.\n"
+     ]
+    }
+   ],
+   "source": [
+    "path = REPO / \"scripts/baseline_counts.json\" if REPO else None\n",
+    "counts = (json.loads(path.read_text()) if path and path.exists()\n",
+    "          else {\"check_docstring\": 0, \"pydoclint\": 0, \"unsafe_annotations\": 0})\n",
+    "print(\"stored counts:\", counts)\n",
+    "print(\"make check_baseline fails if any count goes above this.\")\n",
+    "print(\"make check_baseline_update saves new counts after you fix or accept a change.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.4 `check_asserts`\n",
+    "\n",
+    "The read-only half of `convert_asserts` (2.5): same detection, but it writes nothing and exits non-zero when an `assert` in changed code could be converted. This is the variant `make check` runs."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.5 `check_links`\n",
+    "\n",
+    "Build the docs site (`mkdocs build`) and check that every internal link and heading anchor resolves. No inline example — it needs the built `site/`. A failure reads:\n",
+    "\n",
+    "```\n",
+    "  - path/page.html: broken internal link '../missing.md'\n",
+    "ERROR: 3 problem(s)  (2/90 pages)\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Other tools\n",
+    "\n",
+    "Things `format` and `check` do not call directly:\n",
+    "\n",
+    "| tool | what it is for |\n",
+    "|---|---|\n",
+    "| **`$(PYTHON)`** | the makefile finds the interpreter once (active env, then `$CONDA_PREFIX/bin/python`, then `conda run -n qmcpy`, then `python3`) and every rule uses it (next cell) |\n",
+    "| **the `_changed` suffix** | most tools have a whole-repo form and a `_changed` form that looks only at files changed from a base branch. On a large codebase, only the `_changed` form is practical day to day |\n",
+    "| **`annotate_public_api_types_changed`** and **`sync_docstring_types_changed`** | the reverse of `add_docstring_arg_types`: copy a documented type into a missing signature annotation, then copy annotations back into the docstrings. `check_public_api_types_changed` only reports (last cell) |\n",
+    "| **`tests_fast`** | run doctests, unit tests, and notebook tests at the same time; the rule records each exit code so a failing suite fails the target |\n",
+    "| **whole-repo forms** | `convert_asserts`, `add_docstring_arg_types`, `check_docstring` also exist without `_changed`, for a full pass |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "interpreter: /Users/terrya/miniconda3/envs/qmcpy/bin/python\n"
+     ]
+    }
+   ],
+   "source": [
+    "def discover_python():\n",
+    "    \"\"\"The makefile's  PYTHON ?= $(shell ...)  cascade, written in Python.\"\"\"\n",
+    "    env = os.environ.get(\"CONDA_PREFIX\")\n",
+    "    if shutil.which(\"python\"):          # 1. active env on PATH\n",
+    "        return shutil.which(\"python\")\n",
+    "    if env and shutil.which(\"python\", path=env + \"/bin\"):   # 2. active env, not on PATH\n",
+    "        return shutil.which(\"python\", path=env + \"/bin\")\n",
+    "    if shutil.which(\"conda\"):                               # 3. the repo's qmcpy env\n",
+    "        out = subprocess.run([\"conda\", \"run\", \"-n\", \"qmcpy\", \"python\",\n",
+    "                              \"-c\", \"import sys; print(sys.executable)\"],\n",
+    "                             capture_output=True, text=True)\n",
+    "        if out.stdout.strip():\n",
+    "            return out.stdout.strip()\n",
+    "    return shutil.which(\"python3\") or sys.executable        # 4. system python3\n",
+    "\n",
+    "\n",
+    "print(\"interpreter:\", discover_python())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4.1 `annotate_public_api_types`\n",
+    "\n",
+    "The other direction: the types are only in the docstring and the signature is bare."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Before:\n",
+      "-------\n",
+      "def disc_area(radius, n_sectors=4):\n",
+      "    \"\"\"Area of a disc.\n",
+      "\n",
+      "    Args:\n",
+      "        radius (float): distance to the edge.\n",
+      "        n_sectors (int): wedge count.\n",
+      "\n",
+      "    Returns:\n",
+      "        float: the area.\n",
+      "    \"\"\"\n",
+      "    return 3.14159 * radius ** 2\n",
+      "\n",
+      "After (make annotate_public_api_types_changed):\n",
+      "-----------------------------------------------\n",
+      "def disc_area(radius: float, n_sectors: int = 4) -> float:\n",
+      "    \"\"\"Area of a disc.\n",
+      "\n",
+      "    Args:\n",
+      "        radius (float): distance to the edge.\n",
+      "        n_sectors (int): wedge count.\n",
+      "\n",
+      "    Returns:\n",
+      "        float: the area.\n",
+      "    \"\"\"\n",
+      "    return 3.14159 * radius ** 2\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "src = \"\"\"def disc_area(radius, n_sectors=4):\n",
+    "    \\\"\\\"\\\"Area of a disc.\n",
+    "\n",
+    "    Args:\n",
+    "        radius (float): distance to the edge.\n",
+    "        n_sectors (int): wedge count.\n",
+    "\n",
+    "    Returns:\n",
+    "        float: the area.\n",
+    "    \\\"\\\"\\\"\n",
+    "    return 3.14159 * radius ** 2\n",
+    "\"\"\"\n",
+    "\n",
+    "demo([\"-m\", \"scripts.annotate_public_api_types\"], src,\n",
+    "     src.replace(\"(radius, n_sectors=4)\", \"(radius: float, n_sectors: int = 4) -> float\"),\n",
+    "     \"annotate_public_api_types_changed\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5. Takeaways\n",
+    "\n",
+    "- Run `make format` before you commit, `make check` before you open a PR. One changes files, one only reads.\n",
+    "- Find the interpreter once. `$(PYTHON)` as a resolved variable removes a class of \"wrong Python\" bugs.\n",
+    "- Scope checks to the diff. A `_changed` target makes a whole-repo linter usable.\n",
+    "- Add a strict check to old code with a baseline count, not a hard gate.\n",
+    "- Use a codemod, not hand edits, for the assert and type changes, and keep a careless reformatter out of the pipeline."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "qmcpy",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/docs/good_practices.md b/docs/good_practices.md
index 36261725d..e4da6ed56 100644
--- a/docs/good_practices.md
+++ b/docs/good_practices.md
@@ -57,7 +57,7 @@ For changed public APIs, `make annotate_public_api_types_changed` performs the r
 
 These helpers synchronize explicit type information; they do not infer a scientific API contract from default values, implementation expressions, or one observed runtime type. They also do not invent missing docstring descriptions or sections. Resolve every reported conflict manually, especially scalar-versus-array inputs, optional values, shape conventions, and abstract interfaces.
 
-For mostly well-formed Google-style docstrings, developers may also use the optional open-source `format-docstring` helper to normalize wrapping and existing argument type syntax. Install it locally with `python -m pip install format-docstring`, then run `make format_google_docstrings` to apply it under `qmcpy/`, or run `make format_google_docstrings_changed` to apply it only to Python files reported by `git diff --name-only develop -- '*.py'`. Always review the resulting diff because automated formatting can reflow examples and prose.
+There is intentionally no full third-party docstring reformatter in the Makefile. `format-docstring` was evaluated and rejected: on this codebase it strips `Returns:`/`Yields:` types and rewrites `**References:**` to `**References: **`. If wrapping/whitespace normalization is ever wanted, prefer a tool that leaves section structure and type hints untouched (for example `docformatter` or `pydocstringformatter`), and still review the diff.
 
 ## Extend the Existing Object Model
 
diff --git a/makefile b/makefile
index 743e9a58b..812b8cda9 100644
--- a/makefile
+++ b/makefile
@@ -71,19 +71,15 @@ convert_asserts: check_assert_codemod_dependency
 	$(PYTHON) scripts/convert_asserts.py --exception "$(ASSERT_EXCEPTION)" $(ASSERT_CONVERT_ARGS) $(ASSERT_PATH)
 
 convert_asserts_changed: check_assert_codemod_dependency
-	$(PYTHON) scripts/convert_asserts.py --diff "$(ASSERT_DIFF_BASE)" --exception "$(ASSERT_EXCEPTION)" $(ASSERT_CONVERT_ARGS)
+	@$(PYTHON) scripts/convert_asserts.py --diff "$(ASSERT_DIFF_BASE)" --exception "$(ASSERT_EXCEPTION)" $(ASSERT_CONVERT_ARGS)
 
 check_asserts_changed: check_assert_codemod_dependency
-	$(PYTHON) scripts/convert_asserts.py --diff "$(ASSERT_DIFF_BASE)" --exception "$(ASSERT_EXCEPTION)" --check $(ASSERT_CONVERT_ARGS)
+	@$(PYTHON) scripts/convert_asserts.py --diff "$(ASSERT_DIFF_BASE)" --exception "$(ASSERT_EXCEPTION)" --check $(ASSERT_CONVERT_ARGS)
 
 DOCSTRING_PATH ?= qmcpy
 DOCSTRING_BASE ?= origin/develop
 PYDOCLINT ?= pydoclint
 PYDOCLINT_ARGS ?= -q
-DOCSTRING_FORMATTER ?= format-docstring
-DOCSTRING_FORMAT_PATH ?= qmcpy
-DOCSTRING_FORMAT_DIFF_BASE ?= develop
-DOCSTRING_FORMAT_ARGS ?= --docstring-style google --fix-rst-backticks=False --include-arg-types=True --include-arg-defaults=False --include-return-and-yield-types=False
 DOCSTRING_TYPE_PATH ?= qmcpy
 DOCSTRING_TYPE_DIFF_BASE ?= develop
 DOCSTRING_TYPE_ARGS ?=
@@ -105,8 +101,9 @@ DOCSTRING_SYNC_ARGS ?=
 # to make both parts fail the build.
 check_docstring:
 	@$(PYTHON) scripts/check_docstring.py $(DOCSTRING_PATH) --diff $(DOCSTRING_BASE) $(CHECK_DOCSTRING_ARGS) $(STRICT)
-	@echo ""
-	@$(PYDOCLINT) $(PYDOCLINT_ARGS) $(DOCSTRING_PATH) $(if $(STRICT),,|| true)
+	@out="$$($(PYDOCLINT) $(PYDOCLINT_ARGS) $(DOCSTRING_PATH) 2>&1)"; rc=$$?; \
+	[ -z "$$out" ] || printf '\n%s\n' "$$out"; \
+	$(if $(STRICT),exit $$rc,true)
 
 # Ratchet gate: check_docstring/pydoclint/annotate_public_api_types are
 # informational (existing backlog is large, see PR #613 review F9/F10), but
@@ -119,35 +116,11 @@ check_baseline:
 check_baseline_update:
 	@$(PYTHON) scripts/check_baseline.py --update
 
-format_google_docstrings:
-	@command -v "$(DOCSTRING_FORMATTER)" >/dev/null 2>&1 || { \
-		echo "Missing $(DOCSTRING_FORMATTER). Install with: $(PYTHON) -m pip install format-docstring"; \
-		exit 127; \
-	}
-	@echo "$(DOCSTRING_FORMATTER) formats existing Google-style docstrings; it does not infer missing scientific argument types."
-	$(DOCSTRING_FORMATTER) $(DOCSTRING_FORMAT_ARGS) $(DOCSTRING_FORMAT_PATH)
-
-format_google_docstrings_changed:
-	@command -v "$(DOCSTRING_FORMATTER)" >/dev/null 2>&1 || { \
-		echo "Missing $(DOCSTRING_FORMATTER). Install with: $(PYTHON) -m pip install format-docstring"; \
-		exit 127; \
-	}
-	@set -e; \
-	changed_files="$$(git diff --name-only --diff-filter=ACMR "$(DOCSTRING_FORMAT_DIFF_BASE)" -- '*.py')"; \
-	if [ -z "$$changed_files" ]; then \
-		echo "No changed Python files relative to $(DOCSTRING_FORMAT_DIFF_BASE)."; \
-	else \
-		echo "$(DOCSTRING_FORMATTER) formats existing Google-style docstrings; it does not infer missing scientific argument types."; \
-		echo "Formatting Google-style docstrings in Python files changed relative to $(DOCSTRING_FORMAT_DIFF_BASE):"; \
-		printf '%s\n' "$$changed_files"; \
-		$(DOCSTRING_FORMATTER) $(DOCSTRING_FORMAT_ARGS) $$changed_files; \
-	fi
-
 add_docstring_arg_types:
 	$(PYTHON) scripts/add_docstring_arg_types.py $(DOCSTRING_TYPE_ARGS) $(DOCSTRING_TYPE_PATH)
 
 add_docstring_arg_types_changed:
-	$(PYTHON) scripts/add_docstring_arg_types.py --diff "$(DOCSTRING_TYPE_DIFF_BASE)" $(DOCSTRING_TYPE_ARGS)
+	@$(PYTHON) scripts/add_docstring_arg_types.py --diff "$(DOCSTRING_TYPE_DIFF_BASE)" $(DOCSTRING_TYPE_ARGS)
 
 check_docstring_arg_types_changed:
 	$(PYTHON) scripts/add_docstring_arg_types.py --diff "$(DOCSTRING_TYPE_DIFF_BASE)" --check $(DOCSTRING_TYPE_ARGS)
@@ -176,13 +149,14 @@ check_docstring_changed:
 		} | sort -u \
 	)"; \
 	if [ -z "$$changed_files" ]; then \
-		echo "No changed qmcpy/*.py files relative to $(DOCSTRING_BASE)."; \
+		echo "  - No changed qmcpy/*.py files relative to $(DOCSTRING_BASE)."; \
 	else \
 		file_count=$$(printf '%s\n' "$$changed_files" | wc -l | tr -d ' '); \
-		echo "Checking docstrings on $$file_count changed qmcpy file(s) relative to $(DOCSTRING_BASE)."; \
+		echo "  - Checking docstrings on $$file_count changed qmcpy file(s) relative to $(DOCSTRING_BASE)."; \
 		$(PYTHON) scripts/check_docstring.py $$changed_files $(CHECK_DOCSTRING_ARGS) $(STRICT); \
-		echo ""; \
-		$(PYDOCLINT) $(PYDOCLINT_ARGS) $$changed_files $(if $(STRICT),,|| true); \
+		out="$$($(PYDOCLINT) $(PYDOCLINT_ARGS) $$changed_files 2>&1)"; rc=$$?; \
+		[ -z "$$out" ] || printf '\n%s\n' "$$out"; \
+		$(if $(STRICT),test $$rc -eq 0,true); \
 	fi
 
 ##########################################################
@@ -647,36 +621,74 @@ update_pep8_badge:
 FORMAT_PATH ?= .
 MARKDOWN_UNWRAP_PATH ?= $(FORMAT_PATH)
 
+RULE := ==========================================================================
+RULE2 := $(subst =,-,$(RULE))
+
+# `make format` rewrites files in place. Every step ends with one summary line:
+#     <tool>: clean         (0/N files)   -- nothing changed
+#     <tool>: 3 changed     (3/N files)   -- 3 files were rewritten
+# Review the result with `git diff` before committing.
 format:
-	$(MAKE) flatten_qmcpy_imports
-	@echo "---"
-	$(MAKE) markdown-unwrap MARKDOWN_UNWRAP_PATH="$(MARKDOWN_UNWRAP_PATH)"
-	@echo "---"
-	$(MAKE) rm_trailing_whitespace FORMAT_PATH="$(FORMAT_PATH)"
-	@echo "---"
-	$(MAKE) harden_colab_notebook
-	@echo "---"
-	$(MAKE) convert_asserts_changed
-	@echo "---"
-	$(MAKE) add_docstring_arg_types_changed
-	@# format_google_docstrings_changed deliberately NOT included: verified it
-	@# strips Returns: types and collapses Args:/Warnings:/Raises: structure
-	@# into run-on paragraphs on this codebase's actual docstrings -- tested
-	@# on real files, reverted, not safe to run unattended (see git history).
-
-# Report-only: same conventions alltests.yml's "Check test-suite conventions"
-# step gates on, for running locally. Unlike `format`, nothing here writes to
-# the codebase.
+	@echo "$(RULE)"
+	@echo "make format: rewriting files in place -- review with 'git diff' afterwards"
+	@echo "$(RULE)"
+	@echo
+	@echo "> flatten_qmcpy_imports"
+	@$(MAKE) flatten_qmcpy_imports
+	@echo
+	@echo "> markdown_unwrap"
+	@$(MAKE) markdown-unwrap MARKDOWN_UNWRAP_PATH="$(MARKDOWN_UNWRAP_PATH)"
+	@echo
+	@echo "> trailing_whitespace"
+	@$(MAKE) rm_trailing_whitespace FORMAT_PATH="$(FORMAT_PATH)"
+	@echo
+	@echo "> harden_colab_notebook"
+	@$(MAKE) harden_colab_notebook
+	@echo
+	@echo "> convert_asserts_changed"
+	@$(MAKE) convert_asserts_changed
+	@echo
+	@echo "> add_docstring_arg_types_changed"
+	@$(MAKE) add_docstring_arg_types_changed
+	@echo
+	@echo "$(RULE2)"
+	@echo "make format: done -- a 'clean' line for every step means nothing changed"
+	@echo "$(RULE2)"
+	@# No third-party docstring reformatter here on purpose: format-docstring
+	@# (tried on this codebase) strips Returns:/Yields: types under
+	@# --include-return-and-yield-types=False and rewrites `**References:**` to
+	@# `**References: **`. Wrapping/whitespace-only tools like docformatter are
+	@# safe to add later if wanted; a full reflow pass is not.
+
+# `make check` only reads -- it never edits the tree. Every step ends with one
+# summary line:
+#     <tool>: clean         (0/N files)   -- nothing to fix
+#     <tool>: 2 problem(s)  (2/N files)   -- 2 files need attention
+# Same conventions as alltests.yml's "Check test-suite conventions" step. It
+# stops at the first step that fails; fix that step and rerun.
 check:
-	$(MAKE) check_test_style
-	@echo "---"
-	$(MAKE) check_docstring_changed
-	@echo "---"
-	$(MAKE) check_baseline
-	@echo "---"
-	$(MAKE) check_asserts_changed
-	@echo "---"
-	$(MAKE) check_links
+	@echo "$(RULE)"
+	@echo "make check: read-only, same rules as CI -- nothing here edits the tree"
+	@echo "$(RULE)"
+	@echo
+	@echo "> check_test_style"
+	@$(MAKE) check_test_style
+	@echo
+	@echo "> check_docstring_changed"
+	@$(MAKE) check_docstring_changed
+	@echo
+	@echo "> check_baseline"
+	@$(MAKE) check_baseline
+	@echo
+	@echo "> check_asserts_changed"
+	@$(MAKE) check_asserts_changed
+	@echo
+	@echo "> check_links"
+	@$(MAKE) check_links
+	@echo
+	@echo "$(RULE2)"
+	@echo "make check: every step above is clean"
+	@echo "$(RULE2)"
 	@# check_links_external deliberately NOT included: its own comment already
 	@# says "slow and network-flaky, run locally" -- not something `check`
 	@# should depend on. check_pep8_changed also deliberately excluded: 664
@@ -685,10 +697,10 @@ check:
 	@# check_baseline ratchet, not a hard gate, if added later).
 
 flatten_qmcpy_imports:
-	$(PYTHON) scripts/flatten_qmcpy_imports.py
+	@$(PYTHON) scripts/flatten_qmcpy_imports.py
 
 markdown-unwrap:
-	$(PYTHON) scripts/unwrap_markdown.py "$(MARKDOWN_UNWRAP_PATH)"
+	@$(PYTHON) scripts/unwrap_markdown.py "$(MARKDOWN_UNWRAP_PATH)"
 
 rm_trailing_whitespace:
-	$(PYTHON) scripts/remove_trailing_whitespace.py "$(FORMAT_PATH)"
+	@$(PYTHON) scripts/remove_trailing_whitespace.py "$(FORMAT_PATH)"
diff --git a/mkdocs.yml b/mkdocs.yml
index af391e1d6..f448b8b29 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -89,6 +89,7 @@ nav:
       - QMCPy MPMC compatibility matrix: mpmc-compatibility.md
       - Unit tests on Jupyter Notebooks: booktests.md
       - Coding Agents: AGENTS.md
+    - Makefile Developer Tooling: demos/makefile_dev_tools.ipynb
     - JOSS 2026 Paper: paper/paper.md
 
 
diff --git a/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py b/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py
index 667f882fa..010b11b0d 100644
--- a/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py
+++ b/qmcpy/discrete_distribution/digital_net_any_bases/digital_net_any_bases.py
@@ -170,14 +170,14 @@ def __init__(self,
         r"""Initialize a DigitalNetAnyBases discrete distribution.
 
         Args:
-            dimension (Union[int,np.ndarray]): Dimension of the generator.
+            dimension (Union[int, np.ndarray]): Dimension of the generator.
 
                 - If an `int` is passed in, use generating vector components at indices 0,...,`dimension`-1.
                 - If an `np.ndarray` is passed in, use generating vector components at these indices.
 
             replications (Union[None, int]): Number of independent randomizations of a
                 pointset.
-            seed (Union[None,int,np.random.SeedSequence]): Seed the random number
+            seed (Union[None, int, np.random.SeedSequence]): Seed the random number
                 generator for reproducibility.
             randomize (str): Options are
 
diff --git a/qmcpy/discrete_distribution/kronecker.py b/qmcpy/discrete_distribution/kronecker.py
index e5f70a21a..4ebcf0617 100644
--- a/qmcpy/discrete_distribution/kronecker.py
+++ b/qmcpy/discrete_distribution/kronecker.py
@@ -243,7 +243,7 @@ def __init__(self,
                 - `'SHIFT'`: use `shift` if supplied, otherwise use a random shift $\boldsymbol{\delta} \sim \mathrm{Uniform}([0,1)^d)$.
                 - `'FALSE'`: zero shift.
 
-            generating_vector (Union[str,np.ndarray]): Generating vector
+            generating_vector (Union[str, np.ndarray]): Generating vector
                 $\boldsymbol{\alpha}$.
 
                 - `"CBC"`: uses the first $d$ components of a known good Component-by-Component (CBC) generating vector.
diff --git a/qmcpy/kernel/abstract_kernel.py b/qmcpy/kernel/abstract_kernel.py
index 4c2c33988..325a1ff3d 100644
--- a/qmcpy/kernel/abstract_kernel.py
+++ b/qmcpy/kernel/abstract_kernel.py
@@ -445,10 +445,10 @@ def __init__(
             shape_scale (Union[None, list]): Shape of `scale` when `np.isscalar(scale)`.
             shape_lengthscales (Union[None, list]): Shape of `lengthscales` when
                 `np.isscalar(lengthscales)`
-            tfs_scale (Tuple[Callable,Callable]): The first argument transforms
+            tfs_scale (Tuple[Callable, Callable]): The first argument transforms
                 to the raw value to be optimized; the second applies the
                 inverse transform.
-            tfs_lengthscales (Tuple[Callable,Callable]): The first argument
+            tfs_lengthscales (Tuple[Callable, Callable]): The first argument
                 transforms to the raw value to be optimized; the second applies
                 the inverse transform.
             torchify (bool): If `True`, use the `torch` backend. Set to `True`
diff --git a/qmcpy/kernel/common_kernels.py b/qmcpy/kernel/common_kernels.py
index 666bbdc36..85bfdca20 100644
--- a/qmcpy/kernel/common_kernels.py
+++ b/qmcpy/kernel/common_kernels.py
@@ -519,13 +519,13 @@ def __init__(
             shape_lengthscales (Union[None, list]): Shape of `lengthscales` when
                 `np.isscalar(lengthscales)`
             shape_alpha (Union[None, list]): Shape of `alpha` when `np.isscalar(alpha)`
-            tfs_scale (Tuple[Callable,Callable]): The first argument transforms
+            tfs_scale (Tuple[Callable, Callable]): The first argument transforms
                 to the raw value to be optimized; the second applies the
                 inverse transform.
-            tfs_lengthscales (Tuple[Callable,Callable]): The first argument
+            tfs_lengthscales (Tuple[Callable, Callable]): The first argument
                 transforms to the raw value to be optimized; the second applies
                 the inverse transform.
-            tfs_alpha (Tuple[Callable,Callable]): The first argument transforms
+            tfs_alpha (Tuple[Callable, Callable]): The first argument transforms
                 to the raw value to be optimized; the second applies the
                 inverse transform.
             torchify (bool): If `True`, use the `torch` backend. Set to `True`
diff --git a/qmcpy/kernel/multitask_kernel.py b/qmcpy/kernel/multitask_kernel.py
index a02c9cb97..12854cbd5 100644
--- a/qmcpy/kernel/multitask_kernel.py
+++ b/qmcpy/kernel/multitask_kernel.py
@@ -357,10 +357,10 @@ def __init__(
                 $\boldsymbol{v}$.
             shape_factor (Union[None, list]): Shape of `factor` when `np.isscalar(factor)`.
             shape_diag (Union[None, list]): Shape of `diag` when `np.isscalar(diag)`.
-            tfs_factor (Tuple[Callable,Callable]): The first argument
+            tfs_factor (Tuple[Callable, Callable]): The first argument
                 transforms to the raw value to be optimized; the second applies
                 the inverse transform.
-            tfs_diag (Tuple[Callable,Callable]): The first argument transforms
+            tfs_diag (Tuple[Callable, Callable]): The first argument transforms
                 to the raw value to be optimized; the second applies the
                 inverse transform.
             requires_grad_factor (bool): If `True` and `torchify`, set
diff --git a/qmcpy/kernel/si_dsi_kernels.py b/qmcpy/kernel/si_dsi_kernels.py
index a82aac5be..3d8f7f3fb 100644
--- a/qmcpy/kernel/si_dsi_kernels.py
+++ b/qmcpy/kernel/si_dsi_kernels.py
@@ -414,10 +414,10 @@ def __init__(
             shape_scale (Union[None, list]): Shape of `scale` when `np.isscalar(scale)`.
             shape_lengthscales (Union[None, list]): Shape of `lengthscales` when
                 `np.isscalar(lengthscales)`
-            tfs_scale (Union[None, Tuple[Callable,Callable]]): The first argument transforms
+            tfs_scale (Union[None, Tuple[Callable, Callable]]): The first argument transforms
                 to the raw value to be optimized; the second applies the
                 inverse transform.
-            tfs_lengthscales (Union[None, Tuple[Callable,Callable]]): The first argument
+            tfs_lengthscales (Union[None, Tuple[Callable, Callable]]): The first argument
                 transforms to the raw value to be optimized; the second applies
                 the inverse transform.
             torchify (bool): If `True`, use the `torch` backend. Set to `True`
@@ -435,7 +435,7 @@ def __init__(
             weights (Union[None, np.ndarray, torch.Tensor]): Alias for
                 `lengthscales`.
             shape_weights (Union[None, list]): Alias for `shape_lengthscales`.
-            tfs_weights (Union[None, Tuple[Callable,Callable]]): Alias for
+            tfs_weights (Union[None, Tuple[Callable, Callable]]): Alias for
                 `tfs_lengthscales`.
             requires_grad_weights (Union[None, bool]): Alias for
                 `requires_grad_lengthscales`.
@@ -642,13 +642,13 @@ def __init__(
             shape_lengthscales (Union[None, list]): Shape of `lengthscales` when
                 `np.isscalar(lengthscales)`
             shape_alpha (Union[None, list]): Shape of `alpha` when `np.isscalar(alpha)`
-            tfs_scale (Union[None, Tuple[Callable,Callable]]): The first argument transforms
+            tfs_scale (Union[None, Tuple[Callable, Callable]]): The first argument transforms
                 to the raw value to be optimized; the second applies the
                 inverse transform.
-            tfs_lengthscales (Union[None, Tuple[Callable,Callable]]): The first argument
+            tfs_lengthscales (Union[None, Tuple[Callable, Callable]]): The first argument
                 transforms to the raw value to be optimized; the second applies
                 the inverse transform.
-            tfs_alpha (Union[None, Tuple[Callable,Callable]]): The first argument transforms
+            tfs_alpha (Union[None, Tuple[Callable, Callable]]): The first argument transforms
                 to the raw value to be optimized; the second applies the
                 inverse transform.
             torchify (bool): If `True`, use the `torch` backend. Set to `True`
@@ -668,7 +668,7 @@ def __init__(
             weights (Union[None, np.ndarray, torch.Tensor]): Alias for
                 `lengthscales`.
             shape_weights (Union[None, list]): Alias for `shape_lengthscales`.
-            tfs_weights (Union[None, Tuple[Callable,Callable]]): Alias for
+            tfs_weights (Union[None, Tuple[Callable, Callable]]): Alias for
                 `tfs_lengthscales`.
             requires_grad_weights (Union[None, bool]): Alias for
                 `requires_grad_lengthscales`.
@@ -927,10 +927,10 @@ def __init__(
             shape_scale (Union[None, list]): Shape of `scale` when `np.isscalar(scale)`.
             shape_lengthscales (Union[None, list]): Shape of `lengthscales` when
                 `np.isscalar(lengthscales)`
-            tfs_scale (Union[None, Tuple[Callable,Callable]]): The first argument transforms
+            tfs_scale (Union[None, Tuple[Callable, Callable]]): The first argument transforms
                 to the raw value to be optimized; the second applies the
                 inverse transform.
-            tfs_lengthscales (Union[None, Tuple[Callable,Callable]]): The first argument
+            tfs_lengthscales (Union[None, Tuple[Callable, Callable]]): The first argument
                 transforms to the raw value to be optimized; the second applies
                 the inverse transform.
             torchify (bool): If `True`, use the `torch` backend. Set to `True`
@@ -948,7 +948,7 @@ def __init__(
             weights (Union[None, np.ndarray, torch.Tensor]): Alias for
                 `lengthscales`.
             shape_weights (Union[None, list]): Alias for `shape_lengthscales`.
-            tfs_weights (Union[None, Tuple[Callable,Callable]]): Alias for
+            tfs_weights (Union[None, Tuple[Callable, Callable]]): Alias for
                 `tfs_lengthscales`.
             requires_grad_weights (Union[None, bool]): Alias for
                 `requires_grad_lengthscales`.
@@ -1227,13 +1227,13 @@ def __init__(
             shape_lengthscales (Union[None, list]): Shape of `lengthscales` when
                 `np.isscalar(lengthscales)`
             shape_alpha (Union[None, list]): Shape of `alpha` when `np.isscalar(alpha)`
-            tfs_scale (Union[None, Tuple[Callable,Callable]]): The first argument transforms
+            tfs_scale (Union[None, Tuple[Callable, Callable]]): The first argument transforms
                 to the raw value to be optimized; the second applies the
                 inverse transform.
-            tfs_lengthscales (Union[None, Tuple[Callable,Callable]]): The first argument
+            tfs_lengthscales (Union[None, Tuple[Callable, Callable]]): The first argument
                 transforms to the raw value to be optimized; the second applies
                 the inverse transform.
-            tfs_alpha (Union[None, Tuple[Callable,Callable]]): The first argument transforms
+            tfs_alpha (Union[None, Tuple[Callable, Callable]]): The first argument transforms
                 to the raw value to be optimized; the second applies the
                 inverse transform.
             torchify (bool): If `True`, use the `torch` backend. Set to `True`
@@ -1253,7 +1253,7 @@ def __init__(
             weights (Union[None, np.ndarray, torch.Tensor]): Alias for
                 `lengthscales`.
             shape_weights (Union[None, list]): Alias for `shape_lengthscales`.
-            tfs_weights (Union[None, Tuple[Callable,Callable]]): Alias for
+            tfs_weights (Union[None, Tuple[Callable, Callable]]): Alias for
                 `tfs_lengthscales`.
             requires_grad_weights (Union[None, bool]): Alias for
                 `requires_grad_lengthscales`.
@@ -1502,13 +1502,13 @@ def __init__(
             shape_lengthscales (Union[None, list]): Shape of `lengthscales` when
                 `np.isscalar(lengthscales)`
             shape_alpha (Union[None, list]): Shape of `alpha` when `np.isscalar(alpha)`
-            tfs_scale (Union[None, Tuple[Callable,Callable]]): The first argument transforms
+            tfs_scale (Union[None, Tuple[Callable, Callable]]): The first argument transforms
                 to the raw value to be optimized; the second applies the
                 inverse transform.
-            tfs_lengthscales (Union[None, Tuple[Callable,Callable]]): The first argument
+            tfs_lengthscales (Union[None, Tuple[Callable, Callable]]): The first argument
                 transforms to the raw value to be optimized; the second applies
                 the inverse transform.
-            tfs_alpha (Union[None, Tuple[Callable,Callable]]): The first argument transforms
+            tfs_alpha (Union[None, Tuple[Callable, Callable]]): The first argument transforms
                 to the raw value to be optimized; the second applies the
                 inverse transform.
             torchify (bool): If `True`, use the `torch` backend. Set to `True`
@@ -1528,7 +1528,7 @@ def __init__(
             weights (Union[None, np.ndarray, torch.Tensor]): Alias for
                 `lengthscales`.
             shape_weights (Union[None, list]): Alias for `shape_lengthscales`.
-            tfs_weights (Union[None, Tuple[Callable,Callable]]): Alias for
+            tfs_weights (Union[None, Tuple[Callable, Callable]]): Alias for
                 `tfs_lengthscales`.
             requires_grad_weights (Union[None, bool]): Alias for
                 `requires_grad_lengthscales`.
diff --git a/scripts/add_docstring_arg_types.py b/scripts/add_docstring_arg_types.py
index a2de4c299..06f2f85ec 100644
--- a/scripts/add_docstring_arg_types.py
+++ b/scripts/add_docstring_arg_types.py
@@ -624,7 +624,8 @@ def main(argv: list[str]) -> int:
 
     updates = [update for result in results for update in result.updates]
     skips = [skip for result in results for skip in result.skips]
-    if not args.quiet:
+    if not args.quiet and (updates or skips):
+        print()
         for update in updates:
             action = "would update" if args.check else "updated"
             old = (
@@ -633,22 +634,29 @@ def main(argv: list[str]) -> int:
                 else f" replacing `{update.previous_type}`"
             )
             print(
-                f"{update.path}:{update.line}: {action} "
+                f"  - {update.path}:{update.line}: {action} "
                 f"{update.function}.{update.argument} ({update.annotation}){old}"
             )
         for skip in skips:
-            print(f"{skip.path}:{skip.line}: skipped {skip.function}: {skip.reason}")
+            print(f"  - {skip.path}:{skip.line}: skipped {skip.function}: {skip.reason}")
 
     args_updates = [update for update in updates if update.section == "Args"]
     output_updates = [update for update in updates if update.section != "Args"]
     changed_files = sum(1 for result in results if result.changed)
     verb = "would change" if args.check else "changed"
     print(
-        f"{len(files)} file(s) inspected; {len(args_updates)} Args type update(s); "
+        f"  - {len(files)} file(s) inspected; {len(args_updates)} Args type update(s); "
         f"{len(output_updates)} output type update(s); "
         f"{changed_files} file(s) {verb}."
     )
 
+    if changed_files == 0:
+        print(f"clean  (0 of {len(files)} files)")
+    elif args.check:
+        print(f"ERROR: {changed_files} would change  ({changed_files} of {len(files)} files)")
+    else:
+        print(f"{changed_files} changed  ({changed_files} of {len(files)} files)")
+
     if args.check and updates:
         return 1
     return 2 if had_parse_error else 0
diff --git a/scripts/check_baseline.py b/scripts/check_baseline.py
index 323fee3f4..f015e1d25 100644
--- a/scripts/check_baseline.py
+++ b/scripts/check_baseline.py
@@ -41,7 +41,8 @@
         # M file(s)" or, once N reaches zero, "no issues in M file(s)" --
         # match both so the ratchet keeps working after a check is fully fixed.
         "pattern": re.compile(
-            r"^\d+ file\(s\) scanned: (?:(\d+) issue\(s\) across|no issues in) \d+ file\(s\)",
+            r"^\s*(?:- )?\d+ file\(s\) scanned: "
+            r"(?:(\d+) issue\(s\) across|no issues in) \d+ file\(s\)",
             re.M,
         ),
     },
@@ -86,7 +87,12 @@ def main(argv):
             status = f"improved from {base}"
         else:
             status = "unchanged"
-        print(f"{name}: {count} ({status})")
+        print(f"  - {name}: {count} ({status})")
+
+    if not regressed:
+        print(f"clean  (0 of {len(CHECKS)} counts)")
+    else:
+        print(f"ERROR: {len(regressed)} regressed  ({len(regressed)} of {len(CHECKS)} counts)")
 
     if update:
         BASELINE_PATH.write_text(json.dumps(current, indent=2, sort_keys=True) + "\n")
diff --git a/scripts/check_docstring.py b/scripts/check_docstring.py
index 5c1f4ce16..d8f399890 100644
--- a/scripts/check_docstring.py
+++ b/scripts/check_docstring.py
@@ -254,15 +254,16 @@ def main(argv):
             print(f"{f.as_posix()}: skipped (syntax error: {exc})", file=sys.stderr)
             continue
         per_file[f] = findings
-        for lineno, cat, detail in findings:
+        for _, cat, _ in findings:
             by_cat[cat] = by_cat.get(cat, 0) + 1
             total += 1
-            if not quiet:
-                print(f"{f.as_posix()}:{lineno}: {cat}: {detail}")
 
-    if not quiet:
+    if total and not quiet:
         print()
-    print(_summary(total, len(files), by_cat, f"{len(files)} file(s) scanned"))
+        for f, findings in per_file.items():
+            for lineno, cat, detail in findings:
+                print(f"  - {f.as_posix()}:{lineno}: {cat}: {detail}")
+    print("  - " + _summary(total, len(files), by_cat, f"{len(files)} file(s) scanned"))
 
     if diff_ref is not None:
         try:
@@ -278,8 +279,14 @@ def main(argv):
                 for _, cat, _ in findings:
                     sub_cat[cat] = sub_cat.get(cat, 0) + 1
                     sub_total += 1
-            print(_summary(sub_total, sub_files, sub_cat, f"changed vs {diff_ref}"))
-
+            print("  - " + _summary(sub_total, sub_files, sub_cat, f"changed vs {diff_ref}"))
+
+    files_with_issues = sum(1 for findings in per_file.values() if findings)
+    if files_with_issues == 0:
+        print(f"clean  (0 of {len(files)} files)")
+    else:
+        prefix = "ERROR" if (strict and total) else "WARNING"
+        print(f"{prefix}: {files_with_issues} problem(s)  ({files_with_issues} of {len(files)} files)")
     return 1 if (strict and total) else 0
 
 
diff --git a/scripts/check_links.py b/scripts/check_links.py
index 8fc1405a1..4468f5be5 100644
--- a/scripts/check_links.py
+++ b/scripts/check_links.py
@@ -217,23 +217,30 @@ def main() -> int:
 
     site_dir = Path(args.site_dir)
     site_url = read_site_url()
+    pages = sum(1 for _ in site_dir.rglob("*.html"))
     problems = check_internal(site_dir, site_url=site_url)
-    print(f"Checked internal links under {site_dir}: {len(problems)} problem(s).")
-    for p in problems:
-        print(f"  {p}")
+    print(f"  - Checked internal links under {site_dir}: {len(problems)} problem(s).")
+    if problems:
+        print()
+        for p in problems:
+            print(f"    - {p}")
 
     if args.external:
         ext_broken, ext_warnings = check_external(site_dir, site_url=site_url)
         print(
-            f"\nChecked external links: {len(ext_broken)} broken link(s), "
+            f"\n  - Checked external links: {len(ext_broken)} broken link(s), "
             f"{len(ext_warnings)} warning(s)."
         )
         for p in ext_broken:
-            print(f"  {p}")
+            print(f"    - {p}")
         for p in ext_warnings:
-            print(f"  [warning] {p}")
+            print(f"    - [warning] {p}")
         problems += ext_broken
 
+    if problems:
+        print(f"ERROR: {len(problems)} problem(s)  ({len(problems)} of {pages} pages)")
+    else:
+        print(f"clean  (0 of {pages} pages)")
     return 1 if problems else 0
 
 
diff --git a/scripts/check_test_style.py b/scripts/check_test_style.py
index 139dc387a..68c95b329 100755
--- a/scripts/check_test_style.py
+++ b/scripts/check_test_style.py
@@ -128,34 +128,36 @@ def main(argv):
 
     misnamed = [f for f in files if not _area_ok(f)]
 
+    if function_based or no_tests or misnamed:
+        print()
+
     if not quiet:
-        print(f"{len(class_based)}/{len(files)} file(s) use a unittest.TestCase class")
+        print(f"  - {len(class_based)} of {len(files)} files use a unittest.TestCase class")
     if function_based:
-        print(
-            f"{len(function_based)} file(s) use bare pytest functions "
-            f"(no unittest.TestCase class):"
-        )
+        print(f"  - {len(function_based)} file(s) use bare pytest functions (no unittest.TestCase class):")
         for f in function_based:
-            print(f"  {f.as_posix()}")
-    elif not quiet:
-        print("  no bare-function test files found")
+            print(f"    - {f.as_posix()}")
     if no_tests and not quiet:
-        print(f"{len(no_tests)} file(s) define no test_* callables:")
+        print(f"  - {len(no_tests)} file(s) define no test_* callables:")
         for f in no_tests:
-            print(f"  {f.as_posix()}")
+            print(f"    - {f.as_posix()}")
 
     if not quiet:
         print(
-            f"{len(files) - len(misnamed)}/{len(files)} file(s) use a "
+            f"  - {len(files) - len(misnamed)} of {len(files)} files use a "
             f"test_<area>_ prefix ({', '.join(sorted(AREA_PREFIXES))})"
         )
     if misnamed:
-        print(f"  {len(misnamed)} file(s) have no recognized test_<area>_ prefix:")
+        print(f"  - {len(misnamed)} file(s) have no recognized test_<area>_ prefix:")
         for f in misnamed:
-            print(f"  {f.as_posix()}")
-    elif not quiet:
-        print("  no misnamed test files found")
-
+            print(f"    - {f.as_posix()}")
+
+    bad = {*function_based, *misnamed, *no_tests}
+    if not bad:
+        print(f"clean  (0 of {len(files)} files)")
+    else:
+        prefix = "ERROR" if strict else "WARNING"
+        print(f"{prefix}: {len(bad)} problem(s)  ({len(bad)} of {len(files)} files)")
     return 1 if (strict and (function_based or misnamed or no_tests)) else 0
 
 
diff --git a/scripts/colab_notebooks_manifest.json b/scripts/colab_notebooks_manifest.json
index ed62ba8be..e683f8291 100644
--- a/scripts/colab_notebooks_manifest.json
+++ b/scripts/colab_notebooks_manifest.json
@@ -21,6 +21,7 @@
   "demos/lattice_random_generator.ipynb",
   "demos/lebesgue_integration.ipynb",
   "demos/linear-scrambled-halton.ipynb",
+  "demos/makefile_dev_tools.ipynb",
   "demos/nei_demo.ipynb",
   "demos/plot_proj_function.ipynb",
   "demos/pricing_options.ipynb",
diff --git a/scripts/convert_asserts.py b/scripts/convert_asserts.py
index 12b3e6d8a..3ebba6c67 100644
--- a/scripts/convert_asserts.py
+++ b/scripts/convert_asserts.py
@@ -327,17 +327,18 @@ def main(argv: list[str]) -> int:
             continue
         results.append(result)
 
-    if not args.quiet:
+    if not args.quiet and any(r.converted_lines or r.skipped_lines for r in results):
         action = "would convert" if args.check else "converted"
+        print()
         for result in results:
             for line in result.converted_lines:
                 print(
-                    f"{result.path}:{line}: {action} assert to "
+                    f"  - {result.path}:{line}: {action} assert to "
                     f"explicit {args.exception}"
                 )
             for line in result.skipped_lines:
                 print(
-                    f"{result.path}:{line}: skipped assert in a compound "
+                    f"  - {result.path}:{line}: skipped assert in a compound "
                     "one-line statement"
                 )
 
@@ -346,10 +347,17 @@ def main(argv: list[str]) -> int:
     changed_files = sum(result.changed for result in results)
     verb = "would change" if args.check else "changed"
     print(
-        f"{len(files)} file(s) inspected; {converted} assert(s) converted; "
+        f"  - {len(files)} file(s) inspected; {converted} assert(s) converted; "
         f"{skipped} assert(s) skipped; {changed_files} file(s) {verb}."
     )
 
+    if changed_files == 0:
+        print(f"clean  (0 of {len(files)} files)")
+    elif args.check:
+        print(f"ERROR: {changed_files} would change  ({changed_files} of {len(files)} files)")
+    else:
+        print(f"{changed_files} changed  ({changed_files} of {len(files)} files)")
+
     if args.check and converted:
         return 1
     return 2 if had_parse_error else 0
diff --git a/scripts/flatten_qmcpy_imports.py b/scripts/flatten_qmcpy_imports.py
index 33503e3a7..9ee50ce0b 100644
--- a/scripts/flatten_qmcpy_imports.py
+++ b/scripts/flatten_qmcpy_imports.py
@@ -953,16 +953,21 @@ def main(argv: list[str] | None = None) -> int:
     if changed:
         file_label = "file" if len(changed) == 1 else "files"
         import_label = "import" if changed_imports == 1 else "imports"
+        print()
         print(
-            f"qmcpy imports {action}: {len(changed)} {file_label}, "
+            f"  - qmcpy imports {action}: {len(changed)} {file_label}, "
             f"{changed_imports} {import_label}:"
         )
         for display_path, count in sorted(changed):
             per = "import" if count == 1 else "imports"
-            print(f"  {display_path} ({count} {per})")
-    else:
-        print(f"  qmcpy imports {action}: 0 files")
+            print(f"    - {display_path} ({count} {per})")
 
+    if not changed:
+        print(f"clean  (0 of {len(targets)} files)")
+    elif args.check:
+        print(f"ERROR: {len(changed)} would change  ({len(changed)} of {len(targets)} files)")
+    else:
+        print(f"{len(changed)} changed  ({len(changed)} of {len(targets)} files)")
     return int(args.check and bool(changed))
 
 
diff --git a/scripts/harden_colab_notebook.py b/scripts/harden_colab_notebook.py
index 196c80aa8..d0cd83711 100644
--- a/scripts/harden_colab_notebook.py
+++ b/scripts/harden_colab_notebook.py
@@ -486,16 +486,20 @@ def main() -> int:
         manifest_path,
     )
     for notebook_rel in successes:
-        print(f"Hardened {notebook_rel} for Colab.")
+        print(f"  - Hardened {notebook_rel} for Colab.")
     if failures:
-        print("")
-        print("Not yet hardened:")
+        print()
+        print("  - Not yet hardened:")
         for notebook_rel, error in failures:
-            print(f"- {notebook_rel}: {error}")
-    print("")
+            print(f"    - {notebook_rel}: {error}")
     print(
-        f"Hardened {len(successes)} notebook(s); {len(failures)} notebook(s) still need manual follow-up."
+        f"  - Hardened {len(successes)} notebook(s); {len(failures)} notebook(s) still need manual follow-up."
     )
+    total = len(successes) + len(failures)
+    if not failures:
+        print(f"clean  (0 of {total} notebooks)")
+    else:
+        print(f"ERROR: {len(failures)} need follow-up  ({len(failures)} of {total} notebooks)")
     return 0 if not failures else 1
 
 
diff --git a/scripts/remove_trailing_whitespace.py b/scripts/remove_trailing_whitespace.py
index 5a158137d..307cfe2c1 100644
--- a/scripts/remove_trailing_whitespace.py
+++ b/scripts/remove_trailing_whitespace.py
@@ -142,17 +142,24 @@ def main() -> int:
     parser.add_argument("paths", nargs="+", help="tracked files or directories to process")
     args = parser.parse_args()
 
+    scanned = list(iter_source_files(args.paths))
     changed = sorted(
-        path for path in iter_source_files(args.paths)
+        path for path in scanned
         if remove_trailing_whitespace(path, args.check)
     )
     action = "would update" if args.check else "updated"
     if changed:
-        print(f"trailing whitespace {action}: {len(changed)} file(s):")
+        print()
+        print(f"  - trailing whitespace {action}: {len(changed)} file(s):")
         for path in changed:
-            print(f"  {path}")
+            print(f"    - {path}")
+
+    if not changed:
+        print(f"clean  (0 of {len(scanned)} files)")
+    elif args.check:
+        print(f"ERROR: {len(changed)} would change  ({len(changed)} of {len(scanned)} files)")
     else:
-        print(f"  trailing whitespace {action}: 0 file(s)")
+        print(f"{len(changed)} changed  ({len(changed)} of {len(scanned)} files)")
     return int(args.check and bool(changed))
 
 
diff --git a/scripts/unwrap_markdown.py b/scripts/unwrap_markdown.py
index 49d8b3be3..ad273bf48 100755
--- a/scripts/unwrap_markdown.py
+++ b/scripts/unwrap_markdown.py
@@ -337,11 +337,17 @@ def main() -> int:
         f"{changed_cells} markdown cell(s)"
     )
     if changed_paths:
-        print(summary + ":")
+        print()
+        print("  - " + summary + ":")
         for path in sorted(changed_paths):
-            print(f"  {path}")
+            print(f"    - {path}")
+
+    if not changed_paths:
+        print(f"clean  (0 of {len(targets)} files)")
+    elif args.check:
+        print(f"ERROR: {len(changed_paths)} would change  ({len(changed_paths)} of {len(targets)} files)")
     else:
-        print("  " + summary)
+        print(f"{len(changed_paths)} changed  ({len(changed_paths)} of {len(targets)} files)")
     return 1 if args.check and changed_paths else 0
 
 
diff --git a/test/booktests/tb_makefile_dev_tools.py b/test/booktests/tb_makefile_dev_tools.py
new file mode 100644
index 000000000..f04153a01
--- /dev/null
+++ b/test/booktests/tb_makefile_dev_tools.py
@@ -0,0 +1,12 @@
+import unittest
+from testbook import testbook
+from __init__ import TB_TIMEOUT, BaseNotebookTest
+
+class NotebookTests(BaseNotebookTest):
+
+    @testbook('../../demos/makefile_dev_tools.ipynb', execute=True, timeout=TB_TIMEOUT)
+    def test_makefile_dev_tools_notebook(self, tb):
+        pass
+
+if __name__ == '__main__':
+    unittest.main()

From cba037a11a2947728d3bd09169a3c364fcf5bc1e Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Thu, 10 Sep 2026 21:21:51 +0800
Subject: [PATCH 48/51] Update return type and description in docstring

---
 qmcpy/true_measure/abstract_true_measure.py | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/qmcpy/true_measure/abstract_true_measure.py b/qmcpy/true_measure/abstract_true_measure.py
index 98a137b41..68e934647 100644
--- a/qmcpy/true_measure/abstract_true_measure.py
+++ b/qmcpy/true_measure/abstract_true_measure.py
@@ -155,12 +155,13 @@ def __call__(self, n: Union[None, int] = None, n_min: Union[None, int] = None, n
             warn (bool): If `False`, disable warnings when generating samples.
 
         Returns:
-            np.ndarray: Samples from the sequence.
+            Union[np.ndarray, Tuple[np.ndarray, np.ndarray]]: Samples from the
+                sequence when `return_weights=False`, otherwise the pair
+                `(samples, jacobian_weights)`.
 
-                - If `replications` is `None` then this will be of size (`n_max`-`n_min`) $\times$ `dimension`
-                - If `replications` is a positive int, then `t` will be of size `replications` $\times$ (`n_max`-`n_min`) $\times$ `dimension`
-            np.ndarray: Jacobian weights, returned as the second result only
-                when `return_weights=True`.
+                - If `replications` is `None` the samples are of size (`n_max`-`n_min`) $\times$ `dimension`
+                - If `replications` is a positive int, they are of size `replications` $\times$ (`n_max`-`n_min`) $\times$ `dimension`
+                - The jacobian weights, when returned, drop the trailing `dimension` axis
         """
         return self.gen_samples(
             n=n, n_min=n_min, n_max=n_max, return_weights=return_weights, warn=warn

From 6a93dbebd6c6d70b895015c5dda7d58277fcf448 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Fri, 11 Sep 2026 17:33:32 +0800
Subject: [PATCH 49/51] Removed commented out imports

---
 qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py b/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py
index 1286841ac..26b9a7282 100644
--- a/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py
+++ b/qmcpy/stopping_criterion/cub_qmc_bayes_lattice_g.py
@@ -4,14 +4,10 @@
 from ..discrete_distribution import Lattice
 from ..integrand import Keister, BoxIntegral, Genz, SensitivityIndices
 from ..fast_transform import fftbr, omega_fftbr
-from ..util import ParameterError  # , ParameterWarning #MaxSamplesWarning,
+from ..util import ParameterError
 
-# from math import factorial
 import numpy as np
 
-# from time import time
-# import warnings
-
 
 class CubQMCBayesLatticeG(AbstractCubBayesLDG):
     r"""Quasi-Monte Carlo stopping criterion using fast Bayesian cubature and

From eea30aea4801262398c339975eaf5f9b8b6ebc53 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Fri, 11 Sep 2026 17:46:15 +0800
Subject: [PATCH 50/51] Fix remote doctests on ubuntu

---
 qmcpy/stopping_criterion/cub_mlmc.py      | 2 +-
 qmcpy/stopping_criterion/cub_mlmc_cont.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/qmcpy/stopping_criterion/cub_mlmc.py b/qmcpy/stopping_criterion/cub_mlmc.py
index 51bd57a9a..1643058a4 100644
--- a/qmcpy/stopping_criterion/cub_mlmc.py
+++ b/qmcpy/stopping_criterion/cub_mlmc.py
@@ -34,7 +34,7 @@ class CubMLMC(AbstractCubMLMC):
             cost_per_sample [ 2.  4.  8. 16.]
             alpha           2.008
             beta            1.997
-            gamma           1.000
+            gamma           ...
             time_integrate  ...
         CubMLMC (AbstractStoppingCriterion)
             rmse_tol        0.006
diff --git a/qmcpy/stopping_criterion/cub_mlmc_cont.py b/qmcpy/stopping_criterion/cub_mlmc_cont.py
index 174bad204..9617eff10 100644
--- a/qmcpy/stopping_criterion/cub_mlmc_cont.py
+++ b/qmcpy/stopping_criterion/cub_mlmc_cont.py
@@ -34,7 +34,7 @@ class CubMLMCCont(AbstractCubMLMC):
             cost_per_sample [2. 4. 8.]
             alpha           1.868
             beta            1.969
-            gamma           1.000
+            gamma           ...
             time_integrate  ...
         CubMLMCCont (AbstractStoppingCriterion)
             rmse_tol        0.006

From 35cf45f08effdff0eb553a2317af96f851a9a872 Mon Sep 17 00:00:00 2001
From: sou-cheng-choi <sou.cheng.choi@stanfordalumni.org>
Date: Fri, 11 Sep 2026 17:49:28 +0800
Subject: [PATCH 51/51] Fix obvious error

---
 qmcpy/kernel/abstract_kernel.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qmcpy/kernel/abstract_kernel.py b/qmcpy/kernel/abstract_kernel.py
index 325a1ff3d..27269f684 100644
--- a/qmcpy/kernel/abstract_kernel.py
+++ b/qmcpy/kernel/abstract_kernel.py
@@ -134,7 +134,7 @@ def __call__(self, x0: Union[np.ndarray, torch.Tensor], x1: Union[np.ndarray, to
         """
         if not (isinstance(x0, self.nptarraytype)):
             raise AssertionError
-        if not (isinstance(x0, self.nptarraytype)):
+        if not (isinstance(x1, self.nptarraytype)):
             raise AssertionError
         if not (
             x0.shape[-1] == self.d