From 39228197e2328abd8d9c1b3641ec1c89f0be0fcb Mon Sep 17 00:00:00 2001 From: Aditya Mukhopadhyay Date: Sun, 17 May 2026 16:17:11 +0530 Subject: [PATCH 1/7] docs(spec): add repo-split design doc for #231 Co-Authored-By: Claude Sonnet 4.6 --- .../specs/2026-05-17-repo-split-design.md | 129 ++++++++++++++++++ 1 file changed, 129 insertions(+) create mode 100644 docs/superpowers/specs/2026-05-17-repo-split-design.md diff --git a/docs/superpowers/specs/2026-05-17-repo-split-design.md b/docs/superpowers/specs/2026-05-17-repo-split-design.md new file mode 100644 index 0000000000..0f8d099608 --- /dev/null +++ b/docs/superpowers/specs/2026-05-17-repo-split-design.md @@ -0,0 +1,129 @@ +# Repo Split Design — #231 + +**Date**: 2026-05-17 +**Issue**: [project-minigraf/minigraf#231](https://github.com/project-minigraf/minigraf/issues/231) +**Status**: Approved + +--- + +## Goal + +Split language and platform binding packages out of the monorepo into independent repositories under the `project-minigraf` org. The core engine, FFI bridge crate, C bindings, REPL, benchmarks, and examples remain in `minigraf`. + +**Motivation**: reduce CI noise on core changes, enable scoped ownership, improve approachability. + +--- + +## Scope + +### Phase 1 (this plan) + +| New repo | Source directories | Publishes to | +|---|---|---| +| `minigraf-python` | `minigraf-ffi/python/`, `python-ci.yml`, `python-release.yml` | PyPI | +| `minigraf-node` | `minigraf-node/`, `node-ci.yml`, `node-release.yml` | npm (`minigraf`) | +| `minigraf-wasm` | `minigraf-wasm/`, `minigraf-wasi/`, `wasm-browser.yml`, `wasm-wasi.yml`, `wasm-release.yml` | npm (`@minigraf/browser`, `@minigraf/wasi`) | + +### Phase 2+ (deferred) + +`minigraf-java`, `minigraf-android`, `minigraf-swift` — their CI workflows (`mobile.yml`, `java-ci.yml`, `java-release.yml`) stay in the monorepo until their respective splits. + +### Stays in `minigraf` permanently + +- `src/` — engine +- `minigraf-ffi/` — UniFFI bridge crate (published to crates.io as `minigraf-ffi`) +- `minigraf-c/` — C header + static/shared lib (cbindgen; no independent package registry) +- `examples/`, `benches/`, `tests/`, REPL, fuzz harness +- Core CI: `rust.yml`, `rust-clippy.yml`, `rustfmt.yml`, `coverage.yml`, `coverage-gates.yml`, `cargo-audit.yml`, `bench.yml`, `fuzz.yml`, `smoke.yml`, `binary-size.yml`, `docs-check.yml`, `osv-scanner.yml`, `llvm-cov.yml` + +--- + +## Repository Structure After Phase 1 + +**`Cargo.toml` workspace members:** +```toml +members = [".", "minigraf-ffi", "minigraf-c"] +# minigraf-node removed +``` + +**Workflow count**: drops from 27 → ~16 after Phase 1 (removes 7 binding workflows). + +--- + +## Release Cascade + +### Version lockstep + +All binding repos release at the same version as core. `minigraf-node@1.2.0` on npm always corresponds to `minigraf@1.2.0` on crates.io. Binding repos have no independent versioning. + +### Sequence on `git tag v1.2.0` + +`release.yml` is cargo-dist owned and must not be manually edited (project policy). All custom release logic lives in a new standalone workflow: **`cascade.yml`**, triggered on the same tag pattern. + +`cascade.yml` sequence: + +1. `release.yml` runs in parallel — cargo-dist builds and publishes `minigraf` to crates.io +2. `cascade.yml` runs in parallel: + a. Publishes `minigraf-ffi` via `cargo publish -p minigraf-ffi` + b. Polls crates.io until both `minigraf@` and `minigraf-ffi@` are visible (max 3 min, 10s intervals) + c. Fires `repository_dispatch` to each Phase 1 binding repo in parallel: + +```yaml +- name: Dispatch to binding repos + env: + GH_TOKEN: ${{ secrets.MINIGRAF_RELEASE_TOKEN }} + run: | + VERSION="${{ github.ref_name }}" + for REPO in minigraf-wasm minigraf-node minigraf-python; do + gh api repos/project-minigraf/$REPO/dispatches \ + -f event_type=core-release \ + -f client_payload[version]=$VERSION + done +``` + +3. Each binding repo's `repository_dispatch` receiver: + - Updates `minigraf-ffi` version in its manifest (`Cargo.toml`, `pyproject.toml`, `package.json`) + - Runs CI + - Tags itself at the same version and publishes to its registry + +### Authentication + +`MINIGRAF_RELEASE_TOKEN`: a GitHub PAT with `contents:write` + `actions:write` scoped to the `project-minigraf` org, stored as an org-level Actions secret. Each binding repo inherits it automatically. + +### Development workflow + +Binding repos reference `minigraf-ffi` as a published crate. For local development against unreleased core changes, add a `[patch.crates-io]` override in the local `Cargo.toml` pointing to a local path — gitignored, never committed. + +--- + +## Migration Steps (Phase 1) + +Each binding repo follows this playbook: + +1. **Create repo** under `project-minigraf` org — public, MIT OR Apache-2.0, no template +2. **Copy files** from monorepo at the split-point commit — clean initial commit, no history +3. **Update manifests** — replace path deps on `minigraf`/`minigraf-ffi` with published crate versions +4. **Move CI workflows** — copy relevant `*-ci.yml` and `*-release.yml`, update paths, add `repository_dispatch` receiver job +5. **Delete from monorepo** — remove directory and its CI workflows, update `Cargo.toml` workspace `members` +6. **Update cross-references** — `README.md`, `ROADMAP.md`, `CHANGELOG.md` in monorepo; each new repo's `README.md` links back to core + +### Order within Phase 1 + +1. **Publish `minigraf-ffi`**: remove `publish = false` from `minigraf-ffi/Cargo.toml`, dry-run, publish — must happen before any binding repo can depend on it +2. **`minigraf-python`**: simplest (pure Python wrapper over UniFFI-generated code) +3. **`minigraf-node`**: NAPI-RS build with slightly more complex CI matrix +4. **`minigraf-wasm`**: covers both `minigraf-wasm/` and `minigraf-wasi/` into one repo + +--- + +## Decisions Log + +| Decision | Choice | Reason | +|---|---|---| +| Sync strategy | `repository_dispatch` fan-out from core | Automated, lockstep versions, no polling lag, each repo independently releasable | +| Git history | Clean start | Simpler migration; `git filter-repo` complexity not worth it for a hobby project | +| `minigraf-ffi` publishing | Publish to crates.io | Clean dep story; binding repos can't use path deps once split | +| Migration scope | Phased — Python, Node, WASM first | WASM + Node have the most CI churn; Android/Swift/Java deferred | +| `minigraf-c` | Stays in monorepo | No independent package registry; low CI noise | +| Cascade architecture | Direct fan-out (not polling, not orchestrator repo) | Simple, auditable, no shared infrastructure needed | +| Binding versioning | Lockstep with core | Clear correspondence for users; no independent versioning | From dab95cb1b6df9ced6255da48809e796e7557c07a Mon Sep 17 00:00:00 2001 From: Aditya Mukhopadhyay Date: Sun, 17 May 2026 16:44:25 +0530 Subject: [PATCH 2/7] docs(plan): add Phase 1 repo-split implementation plan for #231 Co-Authored-By: Claude Sonnet 4.6 --- .../plans/2026-05-17-repo-split.md | 1308 +++++++++++++++++ 1 file changed, 1308 insertions(+) create mode 100644 docs/superpowers/plans/2026-05-17-repo-split.md diff --git a/docs/superpowers/plans/2026-05-17-repo-split.md b/docs/superpowers/plans/2026-05-17-repo-split.md new file mode 100644 index 0000000000..79ad89a321 --- /dev/null +++ b/docs/superpowers/plans/2026-05-17-repo-split.md @@ -0,0 +1,1308 @@ +# Repo Split (#231) — Phase 1 Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Split `minigraf-python`, `minigraf-node`, and `minigraf-wasm` out of the monorepo into independent `project-minigraf` org repos wired into a `repository_dispatch` release cascade. + +**Architecture:** A new `cascade.yml` workflow in the core repo publishes `minigraf-ffi` to crates.io and fans out `repository_dispatch` events to each binding repo on every version tag. Each binding repo receives the event, stamps the version into its manifests, and publishes to its registry. The monorepo is left with only core Rust + FFI bridge + C bindings after Phase 1. + +**Tech Stack:** Rust/Cargo, GitHub Actions, `gh` CLI, maturin (Python), NAPI-RS (Node), wasm-pack (WASM), npm, PyPI + +--- + +## Prerequisites + +- [ ] You have `gh` CLI authenticated with an account that has **Owner** access to the `project-minigraf` org +- [ ] An org-level Actions secret `MINIGRAF_RELEASE_TOKEN` exists (PAT with `contents:write` + `actions:write` on the org). If not, create one at `https://github.com/organizations/project-minigraf/settings/secrets/actions` before starting. +- [ ] Confirm `NPM_TOKEN` and PyPI trusted publishing are already configured as org secrets (they were used in the monorepo release workflows). + +--- + +## File Map + +**Modified in core repo:** +- `minigraf-ffi/Cargo.toml` — remove `publish = false`, add `version` to `minigraf` path dep +- `Cargo.toml` — remove `minigraf-node` from workspace members +- `.github/workflows/cascade.yml` — **new** publish + dispatch workflow +- `README.md`, `ROADMAP.md`, `CHANGELOG.md` — update cross-references + +**Deleted from core repo (after each split):** +- `minigraf-ffi/python/` +- `minigraf-node/` +- `minigraf-wasm/`, `minigraf-wasi/` +- `.github/workflows/python-ci.yml`, `python-release.yml` +- `.github/workflows/node-ci.yml`, `node-release.yml` +- `.github/workflows/wasm-browser.yml`, `wasm-wasi.yml`, `wasm-release.yml` + +**New repo: `project-minigraf/minigraf-python`:** +- `Cargo.toml` — thin shim crate providing `uniffi-bindgen` binary +- `src/uniffi_bindgen.rs` +- `pyproject.toml` +- `build.sh` +- `minigraf/__init__.py` (copied) +- `tests/` (copied) +- `.github/workflows/ci.yml` +- `.github/workflows/release.yml` + +**New repo: `project-minigraf/minigraf-node`:** +- `Cargo.toml` — path dep replaced with crates.io version +- `build.rs`, `src/lib.rs`, `index.js`, `index.d.ts`, `package.json` (copied/updated) +- `packages/@minigraf/*/package.json` (copied) +- `test/basic.test.mjs` (copied) +- `.github/workflows/ci.yml` +- `.github/workflows/release.yml` + +**New repo: `project-minigraf/minigraf-wasm`:** +- `Cargo.toml` — thin wrapper crate, `minigraf` dep from crates.io with `browser` feature +- `src/lib.rs` — `pub use minigraf::*;` +- `wasm-pkg/package.json` (browser npm package metadata) +- `wasi-pkg/` (WASI npm package, copied from `minigraf-wasi/`) +- `.github/workflows/ci.yml` +- `.github/workflows/release.yml` + +--- + +## Task 1: Prepare `minigraf-ffi` for crates.io publication + +**Files:** +- Modify: `minigraf-ffi/Cargo.toml` + +The crate currently has `publish = false` and its `minigraf` dep has no version field. Both block `cargo publish`. + +- [ ] **Step 1: Edit `minigraf-ffi/Cargo.toml`** + +Change: +```toml +[package] +name = "minigraf-ffi" +version = "1.1.1" +edition = "2024" +description = "UniFFI mobile bindings for Minigraf (Android + iOS)" +publish = false +``` +To: +```toml +[package] +name = "minigraf-ffi" +version = "1.1.1" +edition = "2024" +description = "UniFFI bridge for Minigraf — bi-temporal graph database" +``` + +And change the `minigraf` dependency from: +```toml +minigraf = { path = ".." } +``` +To: +```toml +minigraf = { path = "..", version = "1.1.1" } +``` + +(`cargo publish` substitutes path deps with their crates.io version when the version field is present.) + +- [ ] **Step 2: Dry-run publish to verify the crate is publishable** + +```bash +cargo publish --dry-run -p minigraf-ffi 2>&1 +``` + +Expected: output ends with `Uploading minigraf-ffi v1.1.1` with no errors. Warnings about `path` dep substitution are fine. + +- [ ] **Step 3: Verify workspace still builds and tests pass** + +```bash +cargo test --workspace 2>&1 | tail -5 +``` + +Expected: all tests pass (935+). + +- [ ] **Step 4: Commit** + +```bash +git -C /home/aditya/workspaces/rustrover/minigraf add minigraf-ffi/Cargo.toml +git -C /home/aditya/workspaces/rustrover/minigraf commit -m "chore(ffi): prepare minigraf-ffi for crates.io publication (#231)" +``` + +- [ ] **Step 5: Publish `minigraf-ffi` to crates.io** + +```bash +cargo publish -p minigraf-ffi +``` + +Expected: `Uploading minigraf-ffi v1.1.1` then `Published minigraf-ffi v1.1.1 to registry`. Wait ~60s for crates.io to index it before proceeding. + +--- + +## Task 2: Create `minigraf-python` repo + +**Files:** All new files in the new GitHub repo. + +- [ ] **Step 1: Create the repo** + +```bash +gh repo create project-minigraf/minigraf-python \ + --public \ + --description "Python bindings for Minigraf — bi-temporal graph database" \ + --clone +cd minigraf-python +``` + +- [ ] **Step 2: Create `Cargo.toml`** + +The new repo needs its own Cargo workspace so maturin can find `uniffi-bindgen`. This thin shim provides only the binary; maturin's `manifest-path` points here. + +```toml +[package] +name = "minigraf-python-shim" +version = "0.0.0" +edition = "2024" +publish = false +description = "Build shim: provides uniffi-bindgen binary for maturin" + +[[bin]] +name = "uniffi-bindgen" +path = "src/uniffi_bindgen.rs" + +[dependencies] +minigraf-ffi = "1.1.1" +uniffi = { version = "0.31.1", features = ["cli"] } + +[workspace] +members = ["."] +``` + +- [ ] **Step 3: Create `src/uniffi_bindgen.rs`** + +```rust +fn main() { + uniffi::uniffi_bindgen_main() +} +``` + +- [ ] **Step 4: Create `pyproject.toml`** + +```toml +[build-system] +requires = ["maturin>=1.5,<2"] +build-backend = "maturin" + +[project] +name = "minigraf" +version = "1.1.1" +description = "Zero-config, single-file, embedded graph database with bi-temporal Datalog queries" +license = { text = "MIT OR Apache-2.0" } +requires-python = ">=3.9" +keywords = ["graph", "datalog", "bitemporal", "embedded", "database"] +classifiers = [ + "Programming Language :: Rust", + "Programming Language :: Python :: Implementation :: CPython", + "Programming Language :: Python :: 3", + "License :: OSI Approved :: MIT License", + "License :: OSI Approved :: Apache Software License", +] + +[project.urls] +Homepage = "https://github.com/project-minigraf/minigraf" +Repository = "https://github.com/project-minigraf/minigraf-python" +"Bug Tracker" = "https://github.com/project-minigraf/minigraf-python/issues" + +[tool.maturin] +manifest-path = "Cargo.toml" +bindings = "uniffi" +python-packages = ["minigraf"] +module-name = "minigraf.minigraf_ffi" +``` + +- [ ] **Step 5: Create `build.sh`** + +```bash +#!/usr/bin/env bash +# build.sh — build and install the minigraf Python extension. +# +# maturin (bindings = "uniffi") calls `cargo run --bin uniffi-bindgen` to +# generate Python bindings. This repo contains a thin shim crate (Cargo.toml) +# whose sole purpose is to provide that binary via minigraf-ffi from crates.io. +# +# Requires an active virtualenv (or conda environment). + +set -euo pipefail + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +cd "$SCRIPT_DIR" + +# Pre-build the uniffi-bindgen binary from the shim crate. +cargo build --bin uniffi-bindgen + +SUBCOMMAND="${1:-}" + +if [[ "$SUBCOMMAND" == "build" ]]; then + shift + maturin build "$@" +else + maturin develop + [[ "$SUBCOMMAND" == "test" ]] && pytest tests/ -v +fi +``` + +```bash +chmod +x build.sh +``` + +- [ ] **Step 6: Copy Python package and tests from monorepo** + +```bash +cp -r /home/aditya/workspaces/rustrover/minigraf/minigraf-ffi/python/minigraf ./minigraf +cp -r /home/aditya/workspaces/rustrover/minigraf/minigraf-ffi/python/tests ./tests +``` + +- [ ] **Step 7: Verify the build works locally** + +```bash +python -m venv .venv +source .venv/bin/activate +pip install maturin pytest +bash build.sh test +``` + +Expected: all Python tests pass. + +- [ ] **Step 8: Create `.github/workflows/ci.yml`** + +```yaml +name: Python CI + +on: + push: + branches: [main] + pull_request: + branches: [main] + +jobs: + test: + name: Python tests (${{ matrix.os }}) + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, ubuntu-24.04-arm, macos-14, windows-latest] + + steps: + - uses: actions/checkout@v4 + + - name: Install Rust toolchain + uses: dtolnay/rust-toolchain@stable + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: '3.11' + + - name: Install maturin + run: pip install "maturin>=1.5" + + - name: Create virtualenv + run: python -m venv .venv + + - name: Build and test + run: | + source .venv/bin/activate 2>/dev/null || source .venv/Scripts/activate + pip install pytest + bash build.sh test + shell: bash +``` + +- [ ] **Step 9: Create `.github/workflows/release.yml`** + +```yaml +name: Python Release + +on: + repository_dispatch: + types: [core-release] + workflow_dispatch: + inputs: + version: + description: 'Version to release (e.g. v1.2.0)' + required: true + type: string + +jobs: + set-version: + runs-on: ubuntu-latest + outputs: + version: ${{ steps.ver.outputs.version }} + steps: + - id: ver + run: | + if [ "${{ github.event_name }}" = "repository_dispatch" ]; then + echo "version=${{ github.event.client_payload.version }}" >> "$GITHUB_OUTPUT" + else + echo "version=${{ inputs.version }}" >> "$GITHUB_OUTPUT" + fi + + build-wheels: + name: Build wheel (${{ matrix.os }}) + needs: set-version + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + include: + - os: ubuntu-latest + build_args: --release --manylinux manylinux_2_34 --out dist + - os: ubuntu-24.04-arm + build_args: --release --manylinux manylinux_2_34 --out dist + - os: macos-14 + build_args: --release --target universal2-apple-darwin --out dist + - os: windows-latest + build_args: --release --out dist + + steps: + - uses: actions/checkout@v4 + + - name: Install Rust toolchain + uses: dtolnay/rust-toolchain@stable + with: + targets: x86_64-apple-darwin + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: '3.11' + + - name: Install maturin + run: pip install "maturin>=1.5" + + - name: Stamp version into pyproject.toml + shell: bash + run: | + TAG="${{ needs.set-version.outputs.version }}" + VERSION="${TAG#v}" + python3 -c " + import re, pathlib + p = pathlib.Path('pyproject.toml') + p.write_text(re.sub(r'^version = .*', 'version = \"${VERSION}\"', p.read_text(), flags=re.MULTILINE)) + " + + - name: Build wheel + run: bash build.sh build ${{ matrix.build_args }} + shell: bash + + - name: Upload wheel + uses: actions/upload-artifact@v4 + with: + name: python-wheel-${{ matrix.os }} + path: dist/*.whl + + publish: + name: Publish to PyPI + needs: [set-version, build-wheels] + runs-on: ubuntu-latest + environment: + name: pypi + url: https://pypi.org/p/minigraf + permissions: + id-token: write + + steps: + - name: Download all wheels + uses: actions/download-artifact@v4 + with: + pattern: python-wheel-* + path: dist + merge-multiple: true + + - name: Publish to PyPI + uses: pypa/gh-action-pypi-publish@release/v1 + with: + packages-dir: dist/ +``` + +- [ ] **Step 10: Create `.gitignore`** + +``` +/target/ +/.venv/ +dist/ +*.whl +__pycache__/ +*.pyc +# local dev override — never commit +Cargo.toml.local +``` + +- [ ] **Step 11: Initial commit and push** + +```bash +git add . +git commit -m "feat: initial Python binding repo (split from minigraf monorepo)" +git push -u origin main +``` + +- [ ] **Step 12: Verify CI passes** + +```bash +gh run watch --repo project-minigraf/minigraf-python +``` + +Expected: all matrix jobs green. + +--- + +## Task 3: Create `minigraf-node` repo + +**Files:** All new files in the new GitHub repo. + +- [ ] **Step 1: Create the repo** + +```bash +gh repo create project-minigraf/minigraf-node \ + --public \ + --description "Node.js bindings for Minigraf — bi-temporal graph database" \ + --clone +cd minigraf-node +``` + +- [ ] **Step 2: Copy source files from monorepo** + +```bash +cp -r /home/aditya/workspaces/rustrover/minigraf/minigraf-node/src ./src +cp /home/aditya/workspaces/rustrover/minigraf/minigraf-node/build.rs ./build.rs +cp /home/aditya/workspaces/rustrover/minigraf/minigraf-node/index.js ./index.js +cp /home/aditya/workspaces/rustrover/minigraf/minigraf-node/index.d.ts ./index.d.ts +cp /home/aditya/workspaces/rustrover/minigraf/minigraf-node/package.json ./package.json +cp -r /home/aditya/workspaces/rustrover/minigraf/minigraf-node/packages ./packages +cp -r /home/aditya/workspaces/rustrover/minigraf/minigraf-node/test ./test +``` + +- [ ] **Step 3: Create `Cargo.toml`** (path dep replaced with crates.io version) + +```toml +[package] +name = "minigraf-node" +version = "1.1.1" +edition = "2024" +publish = false + +[lib] +crate-type = ["cdylib"] + +[dependencies] +napi = { version = "3.8", features = ["napi6"] } +napi-derive = "3" +minigraf = { version = "1.1.1" } +serde_json = "1.0" + +[build-dependencies] +napi-build = "2.1" + +[workspace] +members = ["."] +``` + +- [ ] **Step 4: Update `package.json` repository URL** + +Edit `package.json` — change the `"url"` field in `"repository"`: +```json +"repository": { + "type": "git", + "url": "https://github.com/project-minigraf/minigraf-node.git" +}, +``` + +- [ ] **Step 5: Verify local build** + +```bash +npm install +npx napi build --platform --release +node --test test/basic.test.mjs +``` + +Expected: all Node tests pass. + +- [ ] **Step 6: Create `.github/workflows/ci.yml`** + +```yaml +name: Node.js CI + +on: + push: + branches: [main] + pull_request: + branches: [main] + +jobs: + test: + name: Node.js tests (${{ matrix.os }}) + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, ubuntu-24.04-arm, macos-14, windows-latest] + + steps: + - uses: actions/checkout@v4 + + - name: Install Rust toolchain + uses: dtolnay/rust-toolchain@stable + + - name: Set up Node.js + uses: actions/setup-node@v4 + with: + node-version: '20' + + - name: Install npm dependencies + run: npm install + + - name: Build native addon + run: npx napi build --platform --release + + - name: Run tests + run: node --test test/basic.test.mjs +``` + +- [ ] **Step 7: Create `.github/workflows/release.yml`** + +```yaml +name: Node.js Release + +on: + repository_dispatch: + types: [core-release] + workflow_dispatch: + inputs: + version: + description: 'Version to release (e.g. v1.2.0)' + required: true + type: string + +jobs: + set-version: + runs-on: ubuntu-latest + outputs: + version: ${{ steps.ver.outputs.version }} + semver: ${{ steps.ver.outputs.semver }} + steps: + - id: ver + run: | + if [ "${{ github.event_name }}" = "repository_dispatch" ]; then + TAG="${{ github.event.client_payload.version }}" + else + TAG="${{ inputs.version }}" + fi + echo "version=$TAG" >> "$GITHUB_OUTPUT" + echo "semver=${TAG#v}" >> "$GITHUB_OUTPUT" + + build: + name: Build .node binary (${{ matrix.settings.host }}) + needs: set-version + runs-on: ${{ matrix.settings.host }} + strategy: + fail-fast: false + matrix: + settings: + - host: ubuntu-latest + target: x86_64-unknown-linux-gnu + artifact-name: minigraf-linux-x64-gnu + - host: ubuntu-24.04-arm + target: aarch64-unknown-linux-gnu + artifact-name: minigraf-linux-arm64-gnu + - host: macos-14 + target: universal-apple-darwin + artifact-name: minigraf-darwin-universal + - host: windows-latest + target: x86_64-pc-windows-msvc + artifact-name: minigraf-win32-x64-msvc + + steps: + - uses: actions/checkout@v4 + + - name: Install Rust toolchain + uses: dtolnay/rust-toolchain@stable + with: + targets: ${{ matrix.settings.target == 'universal-apple-darwin' && 'aarch64-apple-darwin x86_64-apple-darwin' || matrix.settings.target }} + + - name: Set up Node.js + uses: actions/setup-node@v4 + with: + node-version: '20' + registry-url: 'https://registry.npmjs.org' + + - name: Install npm dependencies + run: npm install + + - name: Build native addon + shell: bash + run: | + if [ "${{ matrix.settings.target }}" = "universal-apple-darwin" ]; then + npx napi build --platform --release --target aarch64-apple-darwin + npx napi build --platform --release --target x86_64-apple-darwin + lipo -create -output minigraf.darwin-universal.node \ + minigraf.darwin-arm64.node minigraf.darwin-x64.node + rm minigraf.darwin-arm64.node minigraf.darwin-x64.node + else + npx napi build --platform --release --target "${{ matrix.settings.target }}" + fi + + - name: Upload .node binary + uses: actions/upload-artifact@v4 + with: + name: ${{ matrix.settings.artifact-name }} + path: "*.node" + + publish: + name: Publish to npm + needs: [set-version, build] + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v4 + + - name: Set up Node.js + uses: actions/setup-node@v4 + with: + node-version: '20' + registry-url: 'https://registry.npmjs.org' + + - name: Stamp version into package.json + run: | + VERSION="${{ needs.set-version.outputs.semver }}" + node -e " + const fs = require('fs'); + const p = 'package.json'; + const pkg = JSON.parse(fs.readFileSync(p, 'utf8')); + pkg.version = '${VERSION}'; + fs.writeFileSync(p, JSON.stringify(pkg, null, 2) + '\n'); + " + + - name: Install npm dependencies + run: npm install + + - name: Download all binaries + uses: actions/download-artifact@v4 + with: + pattern: minigraf-* + path: . + merge-multiple: true + + - name: Distribute .node binaries to platform packages + run: | + cp minigraf.linux-x64-gnu.node packages/@minigraf/linux-x64-gnu/ + cp minigraf.linux-arm64-gnu.node packages/@minigraf/linux-arm64-gnu/ + cp minigraf.darwin-universal.node packages/@minigraf/darwin-universal/ + cp minigraf.win32-x64-msvc.node packages/@minigraf/win32-x64-msvc/ + + - name: Sync platform package versions + run: | + VERSION="${{ needs.set-version.outputs.semver }}" + for dir in packages/@minigraf/*/; do + node -e " + const fs = require('fs'); + const pkg = JSON.parse(fs.readFileSync('${dir}package.json', 'utf8')); + pkg.version = '${VERSION}'; + fs.writeFileSync('${dir}package.json', JSON.stringify(pkg, null, 2) + '\n'); + " + done + + - name: Publish platform packages + env: + NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }} + run: | + for dir in packages/@minigraf/*/; do + npm publish "$dir" --access public || echo "Skipping $dir (already published or error)" + done + + - name: Publish main minigraf package + env: + NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }} + run: npm publish --access public +``` + +- [ ] **Step 8: Create `.gitignore`** + +``` +/target/ +node_modules/ +*.node +``` + +- [ ] **Step 9: Initial commit and push** + +```bash +git add . +git commit -m "feat: initial Node.js binding repo (split from minigraf monorepo)" +git push -u origin main +``` + +- [ ] **Step 10: Verify CI passes** + +```bash +gh run watch --repo project-minigraf/minigraf-node +``` + +Expected: all matrix jobs green. + +--- + +## Task 4: Create `minigraf-wasm` repo + +**Files:** All new files in the new GitHub repo. + +The browser WASM and WASI builds both compile the `minigraf` crate directly (it contains the `#[wasm_bindgen]` exports). The new repo provides a thin re-export crate so `wasm-pack build` can target it. + +- [ ] **Step 1: Create the repo** + +```bash +gh repo create project-minigraf/minigraf-wasm \ + --public \ + --description "Browser WASM and WASI bindings for Minigraf — bi-temporal graph database" \ + --clone +cd minigraf-wasm +``` + +- [ ] **Step 2: Create `Cargo.toml`** + +```toml +[package] +name = "minigraf-wasm" +version = "1.1.1" +edition = "2024" +publish = false +description = "wasm-pack build shim for Minigraf browser and WASI targets" + +[lib] +crate-type = ["cdylib", "rlib"] + +[dependencies] +minigraf = { version = "1.1.1", features = ["browser"] } + +[target.'cfg(all(target_arch = "wasm32", not(target_os = "wasi")))'.dependencies] +minigraf = { version = "1.1.1", features = ["browser"] } + +[features] +browser = ["minigraf/browser"] + +[workspace] +members = ["."] +``` + +- [ ] **Step 3: Create `src/lib.rs`** + +```rust +// Re-export all wasm_bindgen exports from the published minigraf crate. +// wasm-pack discovers #[wasm_bindgen] symbols at link time from the cdylib, +// so transitive re-exports are included in the generated JS/TS bindings. +pub use minigraf::*; +``` + +- [ ] **Step 4: Copy WASI npm package from monorepo** + +```bash +mkdir wasi-pkg +cp /home/aditya/workspaces/rustrover/minigraf/minigraf-wasi/index.js ./wasi-pkg/index.js +cp /home/aditya/workspaces/rustrover/minigraf/minigraf-wasi/index.d.ts ./wasi-pkg/index.d.ts +cp /home/aditya/workspaces/rustrover/minigraf/minigraf-wasi/package.json ./wasi-pkg/package.json +cp /home/aditya/workspaces/rustrover/minigraf/minigraf-wasi/package.test.js ./wasi-pkg/package.test.js +cp /home/aditya/workspaces/rustrover/minigraf/minigraf-wasi/README.md ./wasi-pkg/README.md +``` + +- [ ] **Step 5: Update `wasi-pkg/package.json` repository URL** + +Edit `wasi-pkg/package.json` — change the `"url"` field: +```json +"repository": { + "type": "git", + "url": "https://github.com/project-minigraf/minigraf-wasm.git" +}, +``` + +- [ ] **Step 6: Verify browser WASM build works** + +```bash +rustup target add wasm32-unknown-unknown +curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh +wasm-pack build --target web --features browser +``` + +Expected: `pkg/` directory created with `.wasm`, `.js`, `.d.ts` files. If `wasm-pack` does not pick up the re-exported `#[wasm_bindgen]` items (empty JS bindings), see the note at the bottom of this task. + +- [ ] **Step 7: Verify WASI build works** + +```bash +rustup target add wasm32-wasip1 +cargo build --target wasm32-wasip1 --release \ + --manifest-path /home/aditya/workspaces/rustrover/minigraf/Cargo.toml \ + --bin minigraf +``` + +Note: the WASI build compiles the `minigraf` REPL binary from the core repo. In the new `minigraf-wasm` repo CI, this is done by checking out the core repo at the matching tag and running `cargo build --target wasm32-wasip1 --release --bin minigraf` from it. The `wasi-pkg/` directory in this repo contains only the JS wrapper; the `.wasm` binary is produced during CI. + +- [ ] **Step 8: Create `.github/workflows/ci.yml`** + +```yaml +name: WASM CI + +on: + push: + branches: [main] + pull_request: + branches: [main] + +jobs: + build-browser: + name: Build browser WASM + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: dtolnay/rust-toolchain@stable + with: + targets: wasm32-unknown-unknown + - name: Install wasm-pack + run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh + - name: Build browser WASM + run: wasm-pack build --target web --features browser + + build-wasi: + name: Build WASI binary + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + repository: project-minigraf/minigraf + ref: main + - uses: dtolnay/rust-toolchain@stable + with: + targets: wasm32-wasip1 + - name: Build WASI binary + run: cargo build --target wasm32-wasip1 --release --bin minigraf +``` + +- [ ] **Step 9: Create `.github/workflows/release.yml`** + +```yaml +name: WASM Release + +on: + repository_dispatch: + types: [core-release] + workflow_dispatch: + inputs: + version: + description: 'Version to release (e.g. v1.2.0)' + required: true + type: string + +jobs: + set-version: + runs-on: ubuntu-latest + outputs: + version: ${{ steps.ver.outputs.version }} + semver: ${{ steps.ver.outputs.semver }} + steps: + - id: ver + run: | + if [ "${{ github.event_name }}" = "repository_dispatch" ]; then + TAG="${{ github.event.client_payload.version }}" + else + TAG="${{ inputs.version }}" + fi + echo "version=$TAG" >> "$GITHUB_OUTPUT" + echo "semver=${TAG#v}" >> "$GITHUB_OUTPUT" + + build-browser: + name: Build browser WASM + needs: set-version + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: dtolnay/rust-toolchain@stable + with: + targets: wasm32-unknown-unknown + - name: Install wasm-pack + run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh + - name: Set up Node.js + uses: actions/setup-node@v4 + with: + node-version: '20' + registry-url: 'https://registry.npmjs.org' + - name: Build browser WASM + run: wasm-pack build --target web --features browser + - name: Stamp package name and version + env: + VERSION: ${{ needs.set-version.outputs.semver }} + run: | + if [[ ! "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then + echo "ERROR: VERSION '$VERSION' is not semver. Aborting." + exit 1 + fi + node -e " + const fs = require('fs'); + const p = 'pkg/package.json'; + const pkg = JSON.parse(fs.readFileSync(p, 'utf8')); + pkg.name = '@minigraf/browser'; + pkg.version = process.env.VERSION; + fs.writeFileSync(p, JSON.stringify(pkg, null, 2) + '\n'); + " + - name: Publish @minigraf/browser to npm + working-directory: pkg + env: + NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }} + run: npm publish --access public + + build-wasi: + name: Build and publish WASI + needs: set-version + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + repository: project-minigraf/minigraf + ref: ${{ needs.set-version.outputs.version }} + - uses: dtolnay/rust-toolchain@stable + with: + targets: wasm32-wasip1 + - name: Set up Node.js + uses: actions/setup-node@v4 + with: + node-version: '20' + registry-url: 'https://registry.npmjs.org' + - name: Build WASI binary + run: cargo build --target wasm32-wasip1 --release --bin minigraf + - name: Check out wasm binding repo for wasi-pkg + uses: actions/checkout@v4 + with: + repository: project-minigraf/minigraf-wasm + path: wasm-binding + - name: Stage WASI npm package + run: cp target/wasm32-wasip1/release/minigraf.wasm wasm-binding/wasi-pkg/minigraf-wasi.wasm + - name: Stamp package version + env: + VERSION: ${{ needs.set-version.outputs.semver }} + run: | + if [[ ! "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then + echo "ERROR: VERSION '$VERSION' is not semver. Aborting." + exit 1 + fi + node -e " + const fs = require('fs'); + const p = 'wasm-binding/wasi-pkg/package.json'; + const pkg = JSON.parse(fs.readFileSync(p, 'utf8')); + pkg.version = process.env.VERSION; + fs.writeFileSync(p, JSON.stringify(pkg, null, 2) + '\n'); + " + - name: Test WASI package + working-directory: wasm-binding/wasi-pkg + run: npm test + - name: Publish @minigraf/wasi to npm + working-directory: wasm-binding/wasi-pkg + env: + NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }} + run: npm publish --access public +``` + +- [ ] **Step 10: Create `.gitignore`** + +``` +/target/ +/pkg/ +node_modules/ +wasi-pkg/minigraf-wasi.wasm +``` + +- [ ] **Step 11: Initial commit and push** + +```bash +git add . +git commit -m "feat: initial WASM/WASI binding repo (split from minigraf monorepo)" +git push -u origin main +``` + +- [ ] **Step 12: Verify CI passes** + +```bash +gh run watch --repo project-minigraf/minigraf-wasm +``` + +Expected: both browser and WASI build jobs green. + +> **Note on wasm-pack re-exports:** If Step 6 produces empty JS bindings (no exported functions), it means `wasm-pack` is not picking up the `#[wasm_bindgen]` items through the `pub use minigraf::*` re-export. The fix: add `wasm-bindgen = "0.2"` as a direct dependency and explicitly re-export the types in `src/lib.rs`: +> ```rust +> pub use minigraf::{MiniGrafDb, /* other exported types */}; +> ``` +> Then re-run `wasm-pack build --target web --features browser` and verify `pkg/minigraf.js` contains the expected exports. + +--- + +## Task 5: Add `cascade.yml` to core and clean up monorepo + +**Files:** +- Create: `.github/workflows/cascade.yml` +- Modify: `Cargo.toml` +- Delete: binding directories and their workflows +- Modify: `README.md`, `ROADMAP.md`, `CHANGELOG.md` + +All changes are in the `minigraf` core repo at `/home/aditya/workspaces/rustrover/minigraf/`. + +- [ ] **Step 1: Create `.github/workflows/cascade.yml`** + +```yaml +name: Release Cascade + +on: + push: + tags: + - '**[0-9]+.[0-9]+.[0-9]+*' + +jobs: + publish-ffi: + name: Publish minigraf-ffi to crates.io + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - uses: dtolnay/rust-toolchain@stable + + - name: Publish minigraf-ffi + env: + CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }} + run: cargo publish -p minigraf-ffi + + - name: Wait for minigraf-ffi to be indexed on crates.io + run: | + VERSION="${GITHUB_REF_NAME#v}" + echo "Waiting for minigraf-ffi@$VERSION on crates.io..." + for i in $(seq 1 18); do + STATUS=$(curl -s "https://crates.io/api/v1/crates/minigraf-ffi/$VERSION" \ + -H "User-Agent: minigraf-cascade/1.0" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('version',{}).get('num',''))" 2>/dev/null || echo "") + if [ "$STATUS" = "$VERSION" ]; then + echo "minigraf-ffi@$VERSION is live (attempt $i)" + break + fi + echo "Attempt $i/18: not yet available, waiting 10s..." + sleep 10 + done + + - name: Wait for minigraf to be indexed on crates.io + run: | + VERSION="${GITHUB_REF_NAME#v}" + echo "Waiting for minigraf@$VERSION on crates.io..." + for i in $(seq 1 18); do + STATUS=$(curl -s "https://crates.io/api/v1/crates/minigraf/$VERSION" \ + -H "User-Agent: minigraf-cascade/1.0" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('version',{}).get('num',''))" 2>/dev/null || echo "") + if [ "$STATUS" = "$VERSION" ]; then + echo "minigraf@$VERSION is live (attempt $i)" + break + fi + echo "Attempt $i/18: not yet available, waiting 10s..." + sleep 10 + done + + dispatch-bindings: + name: Dispatch to binding repos + needs: publish-ffi + runs-on: ubuntu-latest + steps: + - name: Dispatch to Phase 1 binding repos + env: + GH_TOKEN: ${{ secrets.MINIGRAF_RELEASE_TOKEN }} + run: | + VERSION="${GITHUB_REF_NAME}" + for REPO in minigraf-python minigraf-node minigraf-wasm; do + echo "Dispatching core-release to project-minigraf/$REPO @ $VERSION" + gh api repos/project-minigraf/$REPO/dispatches \ + -f event_type=core-release \ + -f "client_payload[version]=$VERSION" + done +``` + +- [ ] **Step 2: Remove binding directories from monorepo** + +```bash +cd /home/aditya/workspaces/rustrover/minigraf +git rm -r minigraf-node/ +git rm -r minigraf-ffi/python/ +git rm -r minigraf-wasm/ +git rm -r minigraf-wasi/ +``` + +- [ ] **Step 3: Remove binding CI workflows** + +```bash +git rm .github/workflows/python-ci.yml +git rm .github/workflows/python-release.yml +git rm .github/workflows/node-ci.yml +git rm .github/workflows/node-release.yml +git rm .github/workflows/wasm-browser.yml +git rm .github/workflows/wasm-wasi.yml +git rm .github/workflows/wasm-release.yml +``` + +- [ ] **Step 4: Update `Cargo.toml` workspace members** + +In `Cargo.toml`, change: +```toml +members = [".", "minigraf-ffi", "minigraf-c", "minigraf-node"] +``` +To: +```toml +members = [".", "minigraf-ffi", "minigraf-c"] +``` + +Also remove the workspace `uniffi-bindgen` stub binary entry (no longer needed since python split is out): + +In `Cargo.toml`, remove this section entirely: +```toml +# Stub that lets `cargo run --bin uniffi-bindgen` work from the workspace root. +# maturin calls this when bindings = "uniffi"; it execs the binary pre-built by +# build.sh (cargo build --bin uniffi-bindgen --manifest-path minigraf-ffi/Cargo.toml). +# Uses only std — no extra dependencies. Excluded from `cargo build --lib` so +# WASM builds are unaffected. +[[bin]] +name = "uniffi-bindgen" +path = "src/bin/uniffi_bindgen_stub.rs" +doc = false +``` + +And remove the stub file: +```bash +git rm src/bin/uniffi_bindgen_stub.rs +# Remove src/bin/ if now empty +rmdir src/bin/ 2>/dev/null || true +``` + +- [ ] **Step 5: Verify workspace still builds cleanly** + +```bash +cargo test --workspace 2>&1 | tail -5 +``` + +Expected: all tests pass (count should be stable since no Rust tests moved — Node and Python tests are in their own repos now). + +- [ ] **Step 6: Update `README.md`** + +Find the section that lists binding packages (look for `minigraf-python`, `minigraf-node`, `@minigraf/browser`). Add a note that each binding now lives in its own repo: + +```markdown +## Language Bindings + +| Language | Package | Repo | +|---|---|---| +| Python | [`minigraf` on PyPI](https://pypi.org/p/minigraf) | [minigraf-python](https://github.com/project-minigraf/minigraf-python) | +| Node.js | [`minigraf` on npm](https://www.npmjs.com/package/minigraf) | [minigraf-node](https://github.com/project-minigraf/minigraf-node) | +| Browser WASM | [`@minigraf/browser` on npm](https://www.npmjs.com/package/@minigraf/browser) | [minigraf-wasm](https://github.com/project-minigraf/minigraf-wasm) | +| WASI | [`@minigraf/wasi` on npm](https://www.npmjs.com/package/@minigraf/wasi) | [minigraf-wasm](https://github.com/project-minigraf/minigraf-wasm) | +| Java | (deferred — Phase 2) | — | +| Android | (deferred — Phase 2) | — | +| iOS/macOS | (deferred — Phase 2) | — | +| C | [`minigraf-c`](./minigraf-c) (in this repo) | — | +``` + +- [ ] **Step 7: Update `ROADMAP.md` "Current Focus"** + +Find the `**Next gate**: #231` line and update it to reflect completion. Add a note about the Phase 2 deferred splits (`minigraf-java`, `minigraf-android`, `minigraf-swift`). + +- [ ] **Step 8: Update `CHANGELOG.md`** + +Add an entry under the latest version (or a new `## Unreleased` section) noting the Phase 1 repo split. + +- [ ] **Step 8a: Update `CLAUDE.md`** + +Update the "Key Files for the Next Phase" section to reflect that Wave 5 is now unblocked. Change the line: + +``` +**Next gate**: #231 — Repo Split (gates Wave 5 and beyond; ecosystem work is cleaner post-split) +``` + +to note #231 is complete and Wave 5 is next. + +- [ ] **Step 9: Commit everything** + +```bash +git add Cargo.toml .github/workflows/cascade.yml README.md ROADMAP.md CHANGELOG.md +git commit -m "feat(split): Phase 1 repo split — python, node, wasm to separate repos (#231) + +- Remove minigraf-node, minigraf-ffi/python, minigraf-wasm, minigraf-wasi +- Remove 7 binding CI workflows (python-{ci,release}, node-{ci,release}, wasm-{browser,wasi,release}) +- Add cascade.yml: publishes minigraf-ffi + dispatches to binding repos on tag +- Update workspace members and README binding table" +``` + +- [ ] **Step 10: Verify core CI still passes** + +```bash +gh run watch --repo project-minigraf/minigraf +``` + +Expected: `rust.yml`, `rust-clippy.yml`, `rustfmt.yml`, `coverage.yml` all green. `cascade.yml` only triggers on tag, so it won't run here. + +--- + +## Task 6: Smoke-test the full cascade + +Verify the end-to-end release cascade works before closing the issue. + +- [ ] **Step 1: Check `CARGO_REGISTRY_TOKEN` is present in core repo secrets** + +```bash +gh secret list --repo project-minigraf/minigraf | grep CARGO +``` + +Expected: `CARGO_REGISTRY_TOKEN` listed. If absent, add it before proceeding. + +- [ ] **Step 2: Test `cascade.yml` via `workflow_dispatch` dry run** + +`cascade.yml` is tag-triggered only and doesn't support `workflow_dispatch`. Instead, verify by inspecting that the workflow YAML is valid: + +```bash +cd /home/aditya/workspaces/rustrover/minigraf +gh workflow view cascade.yml +``` + +Expected: workflow listed with correct triggers. + +- [ ] **Step 3: Test each binding repo's release workflow via `workflow_dispatch`** + +For each binding repo, trigger a dry run with the current version (won't re-publish since the version is already on the registry): + +```bash +gh workflow run release.yml \ + --repo project-minigraf/minigraf-python \ + -f version=v1.1.1 + +gh workflow run release.yml \ + --repo project-minigraf/minigraf-node \ + -f version=v1.1.1 + +gh workflow run release.yml \ + --repo project-minigraf/minigraf-wasm \ + -f version=v1.1.1 +``` + +- [ ] **Step 4: Watch all three run to completion** + +```bash +gh run watch --repo project-minigraf/minigraf-python +gh run watch --repo project-minigraf/minigraf-node +gh run watch --repo project-minigraf/minigraf-wasm +``` + +Expected: all three complete. Publish steps will either succeed (if not yet published at that version) or skip with "already published" messages. + +- [ ] **Step 5: Close issue #231 with a comment** + +```bash +gh issue comment 231 \ + --repo project-minigraf/minigraf \ + --body "Phase 1 complete: minigraf-python, minigraf-node, and minigraf-wasm are now in separate repos under the project-minigraf org. The cascade.yml workflow in this repo publishes minigraf-ffi and dispatches releases to all three on every version tag. Phase 2 (Java, Android, Swift) is deferred." + +gh issue close 231 --repo project-minigraf/minigraf +``` + +--- + +## Self-Review Notes + +- **`uniffi-bindgen` stub**: `src/bin/uniffi_bindgen_stub.rs` is removed from the monorepo in Task 5. The stub's only purpose was to let maturin find `uniffi-bindgen` during Python builds — that's now handled by the `minigraf-python` repo's own shim crate. +- **`wasm-pack` re-export caveat**: Task 4 Step 6 includes a fallback note if `pub use minigraf::*` doesn't surface the `#[wasm_bindgen]` exports. Resolve before pushing CI. +- **WASI `cargo build` in `minigraf-wasm` CI**: the WASI build checks out the core `minigraf` repo at the release tag to compile the REPL binary. This requires the core tag to be pushed before the dispatch fires — which is guaranteed because `cascade.yml` runs after the tag is pushed. +- **`CARGO_REGISTRY_TOKEN`**: Must exist in core repo secrets for `cascade.yml`'s publish step. This is the same token already used for `cargo publish minigraf` — confirm it's in the repo/org secrets before the next real release. From c24c8ddefc29b77ede6ea2914b913258b8b98402 Mon Sep 17 00:00:00 2001 From: Aditya Mukhopadhyay Date: Sun, 17 May 2026 17:04:29 +0530 Subject: [PATCH 3/7] chore(ffi): prepare minigraf-ffi for crates.io publication (#231) --- minigraf-ffi/Cargo.toml | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/minigraf-ffi/Cargo.toml b/minigraf-ffi/Cargo.toml index ce066d6e1f..007ee5d5d5 100644 --- a/minigraf-ffi/Cargo.toml +++ b/minigraf-ffi/Cargo.toml @@ -2,8 +2,7 @@ name = "minigraf-ffi" version = "1.1.1" edition = "2024" -description = "UniFFI mobile bindings for Minigraf (Android + iOS)" -publish = false +description = "UniFFI bridge for Minigraf — bi-temporal graph database" [lib] crate-type = ["cdylib", "staticlib"] @@ -13,7 +12,7 @@ name = "uniffi-bindgen" path = "src/uniffi_bindgen.rs" [dependencies] -minigraf = { path = ".." } +minigraf = { path = "..", version = "1.1.1" } uniffi = { version = "0.31.1", features = ["cli"] } thiserror = "2.0.18" serde_json = "1.0.149" From e295d9da956fedd03a2ad24c7072ee74e96bca85 Mon Sep 17 00:00:00 2001 From: Aditya Mukhopadhyay Date: Sun, 17 May 2026 17:14:05 +0530 Subject: [PATCH 4/7] chore(ffi): add crates.io metadata to minigraf-ffi (#231) --- minigraf-ffi/Cargo.toml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/minigraf-ffi/Cargo.toml b/minigraf-ffi/Cargo.toml index 007ee5d5d5..62c1f06e35 100644 --- a/minigraf-ffi/Cargo.toml +++ b/minigraf-ffi/Cargo.toml @@ -3,6 +3,12 @@ name = "minigraf-ffi" version = "1.1.1" edition = "2024" description = "UniFFI bridge for Minigraf — bi-temporal graph database" +license = "MIT OR Apache-2.0" +authors = ["Aditya Mukhopadhyay"] +repository = "https://github.com/project-minigraf/minigraf" +documentation = "https://docs.rs/minigraf-ffi" +keywords = ["graph", "datalog", "bitemporal", "embedded", "database"] +categories = ["database-implementations", "embedded"] [lib] crate-type = ["cdylib", "staticlib"] From 703c348dfecb232ca8acdbafae466d4f4142a672 Mon Sep 17 00:00:00 2001 From: Aditya Mukhopadhyay Date: Sun, 17 May 2026 18:17:39 +0530 Subject: [PATCH 5/7] =?UTF-8?q?feat(split):=20Phase=201=20repo=20split=20?= =?UTF-8?q?=E2=80=94=20python,=20node,=20wasm=20to=20separate=20repos=20(#?= =?UTF-8?q?231)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Remove minigraf-node, minigraf-ffi/python, minigraf-wasm, minigraf-wasi - Remove 7 binding CI workflows (python, node, wasm) - Remove uniffi-bindgen stub binary from workspace root - Add cascade.yml: publishes minigraf-ffi + dispatches to binding repos on tag - Publish minigraf-ffi to crates.io (previously internal) - Add minigraf-ffi/README.md for crates.io page - Update workspace members, README binding table, ROADMAP, CHANGELOG, CLAUDE.md --- .github/workflows/cascade.yml | 67 ++ .github/workflows/node-ci.yml | 39 - .github/workflows/node-release.yml | 154 ---- .github/workflows/python-ci.yml | 42 - .github/workflows/python-release.yml | 92 --- .github/workflows/wasm-browser.yml | 74 -- .github/workflows/wasm-release.yml | 185 ----- .github/workflows/wasm-wasi.yml | 66 -- CHANGELOG.md | 11 + CLAUDE.md | 7 +- Cargo.toml | 11 +- README.md | 13 + ROADMAP.md | 8 +- minigraf-ffi/Cargo.toml | 1 + minigraf-ffi/README.md | 22 + minigraf-ffi/python/README.md | 59 -- minigraf-ffi/python/build.sh | 34 - minigraf-ffi/python/minigraf/__init__.py | 3 - minigraf-ffi/python/pyproject.toml | 29 - minigraf-ffi/python/tests/__init__.py | 0 minigraf-ffi/python/tests/test_basic.py | 38 - minigraf-node/Cargo.toml | 20 - minigraf-node/README.md | 65 -- minigraf-node/build.rs | 3 - minigraf-node/index.d.ts | 12 - minigraf-node/index.js | 579 -------------- minigraf-node/package.json | 39 - .../@minigraf/darwin-universal/package.json | 20 - .../@minigraf/linux-arm64-gnu/package.json | 22 - .../@minigraf/linux-x64-gnu/package.json | 22 - .../@minigraf/win32-x64-msvc/package.json | 19 - minigraf-node/src/lib.rs | 93 --- minigraf-node/test/basic.test.mjs | 49 -- minigraf-wasi/README.md | 24 - minigraf-wasi/index.d.ts | 47 -- minigraf-wasi/index.js | 66 -- minigraf-wasi/package.json | 34 - minigraf-wasi/package.test.js | 67 -- minigraf-wasm/LICENSE-APACHE | 202 ----- minigraf-wasm/LICENSE-MIT | 21 - minigraf-wasm/README.md | 87 -- minigraf-wasm/minigraf.d.ts | 107 --- minigraf-wasm/minigraf.js | 757 ------------------ minigraf-wasm/minigraf_bg.wasm | Bin 703354 -> 0 bytes minigraf-wasm/minigraf_bg.wasm.d.ts | 18 - minigraf-wasm/package.json | 32 - src/bin/uniffi_bindgen_stub.rs | 41 - 47 files changed, 123 insertions(+), 3278 deletions(-) create mode 100644 .github/workflows/cascade.yml delete mode 100644 .github/workflows/node-ci.yml delete mode 100644 .github/workflows/node-release.yml delete mode 100644 .github/workflows/python-ci.yml delete mode 100644 .github/workflows/python-release.yml delete mode 100644 .github/workflows/wasm-browser.yml delete mode 100644 .github/workflows/wasm-release.yml delete mode 100644 .github/workflows/wasm-wasi.yml create mode 100644 minigraf-ffi/README.md delete mode 100644 minigraf-ffi/python/README.md delete mode 100755 minigraf-ffi/python/build.sh delete mode 100644 minigraf-ffi/python/minigraf/__init__.py delete mode 100644 minigraf-ffi/python/pyproject.toml delete mode 100644 minigraf-ffi/python/tests/__init__.py delete mode 100644 minigraf-ffi/python/tests/test_basic.py delete mode 100644 minigraf-node/Cargo.toml delete mode 100644 minigraf-node/README.md delete mode 100644 minigraf-node/build.rs delete mode 100644 minigraf-node/index.d.ts delete mode 100644 minigraf-node/index.js delete mode 100644 minigraf-node/package.json delete mode 100644 minigraf-node/packages/@minigraf/darwin-universal/package.json delete mode 100644 minigraf-node/packages/@minigraf/linux-arm64-gnu/package.json delete mode 100644 minigraf-node/packages/@minigraf/linux-x64-gnu/package.json delete mode 100644 minigraf-node/packages/@minigraf/win32-x64-msvc/package.json delete mode 100644 minigraf-node/src/lib.rs delete mode 100644 minigraf-node/test/basic.test.mjs delete mode 100644 minigraf-wasi/README.md delete mode 100644 minigraf-wasi/index.d.ts delete mode 100644 minigraf-wasi/index.js delete mode 100644 minigraf-wasi/package.json delete mode 100644 minigraf-wasi/package.test.js delete mode 100644 minigraf-wasm/LICENSE-APACHE delete mode 100644 minigraf-wasm/LICENSE-MIT delete mode 100644 minigraf-wasm/README.md delete mode 100644 minigraf-wasm/minigraf.d.ts delete mode 100644 minigraf-wasm/minigraf.js delete mode 100644 minigraf-wasm/minigraf_bg.wasm delete mode 100644 minigraf-wasm/minigraf_bg.wasm.d.ts delete mode 100644 minigraf-wasm/package.json delete mode 100644 src/bin/uniffi_bindgen_stub.rs diff --git a/.github/workflows/cascade.yml b/.github/workflows/cascade.yml new file mode 100644 index 0000000000..cbf023d33e --- /dev/null +++ b/.github/workflows/cascade.yml @@ -0,0 +1,67 @@ +name: Release Cascade + +on: + push: + tags: + - '**[0-9]+.[0-9]+.[0-9]+*' + +jobs: + publish-ffi: + name: Publish minigraf-ffi to crates.io + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - uses: dtolnay/rust-toolchain@stable + + - name: Publish minigraf-ffi + env: + CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }} + run: cargo publish -p minigraf-ffi + + - name: Wait for minigraf-ffi to be indexed on crates.io + run: | + VERSION="${GITHUB_REF_NAME#v}" + echo "Waiting for minigraf-ffi@$VERSION on crates.io..." + for i in $(seq 1 18); do + STATUS=$(curl -s "https://crates.io/api/v1/crates/minigraf-ffi/$VERSION" \ + -H "User-Agent: minigraf-cascade/1.0" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('version',{}).get('num',''))" 2>/dev/null || echo "") + if [ "$STATUS" = "$VERSION" ]; then + echo "minigraf-ffi@$VERSION is live (attempt $i)" + break + fi + echo "Attempt $i/18: not yet available, waiting 10s..." + sleep 10 + done + + - name: Wait for minigraf to be indexed on crates.io + run: | + VERSION="${GITHUB_REF_NAME#v}" + echo "Waiting for minigraf@$VERSION on crates.io..." + for i in $(seq 1 18); do + STATUS=$(curl -s "https://crates.io/api/v1/crates/minigraf/$VERSION" \ + -H "User-Agent: minigraf-cascade/1.0" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('version',{}).get('num',''))" 2>/dev/null || echo "") + if [ "$STATUS" = "$VERSION" ]; then + echo "minigraf@$VERSION is live (attempt $i)" + break + fi + echo "Attempt $i/18: not yet available, waiting 10s..." + sleep 10 + done + + dispatch-bindings: + name: Dispatch to binding repos + needs: publish-ffi + runs-on: ubuntu-latest + steps: + - name: Dispatch to Phase 1 binding repos + env: + GH_TOKEN: ${{ secrets.MINIGRAF_RELEASE_TOKEN }} + run: | + VERSION="${GITHUB_REF_NAME}" + for REPO in minigraf-python minigraf-node minigraf-wasm; do + echo "Dispatching core-release to project-minigraf/$REPO @ $VERSION" + gh api repos/project-minigraf/$REPO/dispatches \ + -f event_type=core-release \ + -f "client_payload[version]=$VERSION" + done diff --git a/.github/workflows/node-ci.yml b/.github/workflows/node-ci.yml deleted file mode 100644 index af8a27d5cc..0000000000 --- a/.github/workflows/node-ci.yml +++ /dev/null @@ -1,39 +0,0 @@ -name: Node.js CI - -on: - push: - branches: [main] - pull_request: - branches: [main] - -jobs: - test: - name: Node.js tests (${{ matrix.os }}) - runs-on: ${{ matrix.os }} - strategy: - fail-fast: false - matrix: - os: [ubuntu-latest, ubuntu-24.04-arm, macos-14, windows-latest] - - steps: - - uses: actions/checkout@v4 - - - name: Install Rust toolchain - uses: dtolnay/rust-toolchain@stable - - - name: Set up Node.js - uses: actions/setup-node@v4 - with: - node-version: '20' - - - name: Install npm dependencies - working-directory: minigraf-node - run: npm install - - - name: Build native addon - working-directory: minigraf-node - run: npx napi build --platform --release - - - name: Run tests - working-directory: minigraf-node - run: node --test test/basic.test.mjs diff --git a/.github/workflows/node-release.yml b/.github/workflows/node-release.yml deleted file mode 100644 index 8e122fdaf0..0000000000 --- a/.github/workflows/node-release.yml +++ /dev/null @@ -1,154 +0,0 @@ -name: Node.js Release - -on: - push: - tags: - - '**[0-9]+.[0-9]+.[0-9]+*' - workflow_dispatch: - inputs: - tag: - description: 'Release tag to publish to npm (e.g. "v0.25.0")' - required: false - type: string - checkout_ref: - description: 'Git ref to build from (e.g. "v0.22.0"). Defaults to triggered ref. Use for retroactive publishes from main.' - required: false - type: string - -jobs: - build: - name: Build .node binary (${{ matrix.settings.host }}) - runs-on: ${{ matrix.settings.host }} - strategy: - fail-fast: false - matrix: - settings: - - host: ubuntu-latest - target: x86_64-unknown-linux-gnu - artifact-name: minigraf-linux-x64-gnu - - host: ubuntu-24.04-arm - target: aarch64-unknown-linux-gnu - artifact-name: minigraf-linux-arm64-gnu - - host: macos-14 - target: universal-apple-darwin - artifact-name: minigraf-darwin-universal - - host: windows-latest - target: x86_64-pc-windows-msvc - artifact-name: minigraf-win32-x64-msvc - - steps: - - uses: actions/checkout@v4 - with: - ref: ${{ inputs.checkout_ref || github.ref }} - - - name: Install Rust toolchain - uses: dtolnay/rust-toolchain@stable - with: - targets: ${{ matrix.settings.target == 'universal-apple-darwin' && 'aarch64-apple-darwin x86_64-apple-darwin' || matrix.settings.target }} - - - name: Set up Node.js - uses: actions/setup-node@v4 - with: - node-version: '20' - registry-url: 'https://registry.npmjs.org' - - - name: Install npm dependencies - working-directory: minigraf-node - run: npm install - - - name: Build native addon - working-directory: minigraf-node - shell: bash - run: | - if [ "${{ matrix.settings.target }}" = "universal-apple-darwin" ]; then - # napi-rs does not internally handle universal-apple-darwin. - # Build each arch separately, then lipo-combine. - # napi-rs --platform names the output using npm platform names: - # aarch64-apple-darwin → minigraf.darwin-arm64.node - # x86_64-apple-darwin → minigraf.darwin-x64.node - npx napi build --platform --release --target aarch64-apple-darwin - npx napi build --platform --release --target x86_64-apple-darwin - lipo -create -output minigraf.darwin-universal.node \ - minigraf.darwin-arm64.node minigraf.darwin-x64.node - rm minigraf.darwin-arm64.node minigraf.darwin-x64.node - else - npx napi build --platform --release --target "${{ matrix.settings.target }}" - fi - - - name: Upload .node binary - uses: actions/upload-artifact@v4 - with: - # artifact-name must not contain '/'; use the sanitized artifact-name field. - name: ${{ matrix.settings.artifact-name }} - path: minigraf-node/*.node - - publish: - name: Publish to npm - needs: build - runs-on: ubuntu-latest - - steps: - - uses: actions/checkout@v4 - with: - ref: ${{ inputs.checkout_ref || github.ref }} - - - name: Set up Node.js - uses: actions/setup-node@v4 - with: - node-version: '20' - registry-url: 'https://registry.npmjs.org' - - - name: Set npm package version from release tag - shell: bash - run: | - TAG="${{ inputs.tag || github.ref_name }}" - VERSION="${TAG#v}" - node -e "const fs=require('fs'); const p='minigraf-node/package.json'; const pkg=JSON.parse(fs.readFileSync(p,'utf8')); pkg.version='${VERSION}'; fs.writeFileSync(p,JSON.stringify(pkg,null,2)+'\n');" - - - name: Install npm dependencies - working-directory: minigraf-node - run: npm install - - - name: Download all binaries - uses: actions/download-artifact@v4 - with: - pattern: minigraf-* - path: minigraf-node - merge-multiple: true - - - name: Distribute .node binaries to platform packages - working-directory: minigraf-node - run: | - # napi artifacts does not reliably copy files; do it explicitly. - cp minigraf.linux-x64-gnu.node packages/@minigraf/linux-x64-gnu/ - cp minigraf.linux-arm64-gnu.node packages/@minigraf/linux-arm64-gnu/ - cp minigraf.darwin-universal.node packages/@minigraf/darwin-universal/ - cp minigraf.win32-x64-msvc.node packages/@minigraf/win32-x64-msvc/ - - - name: Sync platform package versions - working-directory: minigraf-node - run: | - VERSION=$(node -p "require('./package.json').version") - for dir in packages/@minigraf/*/; do - node -e " - const fs = require('fs'); - const pkg = JSON.parse(fs.readFileSync('${dir}package.json', 'utf8')); - pkg.version = '${VERSION}'; - fs.writeFileSync('${dir}package.json', JSON.stringify(pkg, null, 2) + '\n'); - " - done - - - name: Publish platform packages - working-directory: minigraf-node - env: - NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }} - run: | - for dir in packages/@minigraf/*/; do - npm publish "$dir" --access public || echo "Skipping $dir (already published or error)" - done - - - name: Publish main minigraf package - working-directory: minigraf-node - env: - NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }} - run: npm publish --access public diff --git a/.github/workflows/python-ci.yml b/.github/workflows/python-ci.yml deleted file mode 100644 index ad1d47263b..0000000000 --- a/.github/workflows/python-ci.yml +++ /dev/null @@ -1,42 +0,0 @@ -name: Python CI - -on: - push: - branches: [main] - pull_request: - branches: [main] - -jobs: - test: - name: Python tests (${{ matrix.os }}) - runs-on: ${{ matrix.os }} - strategy: - fail-fast: false - matrix: - os: [ubuntu-latest, ubuntu-24.04-arm, macos-14, windows-latest] - - steps: - - uses: actions/checkout@v4 - - - name: Install Rust toolchain - uses: dtolnay/rust-toolchain@stable - - - name: Set up Python - uses: actions/setup-python@v5 - with: - python-version: '3.11' - - - name: Install maturin - run: pip install "maturin>=1.5" - - - name: Create virtualenv - working-directory: minigraf-ffi/python - run: python -m venv .venv - - - name: Build and test (workaround for maturin workspace uniffi-bindgen bug) - working-directory: minigraf-ffi/python - run: | - source .venv/bin/activate 2>/dev/null || source .venv/Scripts/activate - pip install pytest - bash build.sh test - shell: bash diff --git a/.github/workflows/python-release.yml b/.github/workflows/python-release.yml deleted file mode 100644 index efe94e254d..0000000000 --- a/.github/workflows/python-release.yml +++ /dev/null @@ -1,92 +0,0 @@ -name: Python Release - -on: - push: - tags: - - '**[0-9]+.[0-9]+.[0-9]+*' - workflow_dispatch: - inputs: - tag: - description: 'Release tag to publish wheels for (e.g. "v0.22.0")' - required: false - type: string - checkout_ref: - description: 'Git ref to build from (e.g. "v0.22.0"). Defaults to triggered ref. Use for retroactive publishes from main.' - required: false - type: string - -jobs: - build-wheels: - name: Build wheel (${{ matrix.os }}) - runs-on: ${{ matrix.os }} - strategy: - fail-fast: false - matrix: - include: - - os: ubuntu-latest - build_args: --release --manylinux manylinux_2_34 --out dist - - os: ubuntu-24.04-arm - build_args: --release --manylinux manylinux_2_34 --out dist - - os: macos-14 - build_args: --release --target universal2-apple-darwin --out dist - - os: windows-latest - build_args: --release --out dist - - steps: - - uses: actions/checkout@v4 - with: - ref: ${{ inputs.checkout_ref || github.ref }} - - - name: Install Rust toolchain - uses: dtolnay/rust-toolchain@stable - with: - targets: x86_64-apple-darwin # needed for universal2 on macos-14 (arm) - - - name: Set up Python - uses: actions/setup-python@v5 - with: - python-version: '3.11' - - - name: Install maturin - run: pip install "maturin>=1.5" - - - name: Set Python package version from release tag - shell: bash - run: | - TAG="${{ inputs.tag || github.ref_name }}" - VERSION="${TAG#v}" - python3 -c "import re, pathlib; p = pathlib.Path('minigraf-ffi/python/pyproject.toml'); p.write_text(re.sub(r'^version = .*', 'version = \"${VERSION}\"', p.read_text(), flags=re.MULTILINE))" - - - name: Build wheel (workaround for maturin workspace uniffi-bindgen bug) - working-directory: minigraf-ffi/python - run: bash build.sh build ${{ matrix.build_args }} - shell: bash - - - name: Upload wheel - uses: actions/upload-artifact@v4 - with: - name: python-wheel-${{ matrix.os }} - path: minigraf-ffi/python/dist/*.whl - - publish: - name: Publish to PyPI - needs: build-wheels - runs-on: ubuntu-latest - environment: - name: pypi - url: https://pypi.org/p/minigraf - permissions: - id-token: write # for PyPI trusted publishing - - steps: - - name: Download all wheels - uses: actions/download-artifact@v4 - with: - pattern: python-wheel-* - path: dist - merge-multiple: true - - - name: Publish to PyPI - uses: pypa/gh-action-pypi-publish@release/v1 - with: - packages-dir: dist/ diff --git a/.github/workflows/wasm-browser.yml b/.github/workflows/wasm-browser.yml deleted file mode 100644 index 59b5ec8cdd..0000000000 --- a/.github/workflows/wasm-browser.yml +++ /dev/null @@ -1,74 +0,0 @@ -name: WASM Browser - -on: - push: - branches: ["main"] - pull_request: - branches: ["main"] - -env: - CARGO_TERM_COLOR: always - -permissions: - contents: read - -jobs: - build: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - - - uses: dtolnay/rust-toolchain@stable - with: - targets: wasm32-unknown-unknown - - - name: Install wasm-pack - run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh - - - name: Build (release) - run: wasm-pack build --target web --features browser - - - name: Rename pkg/ → minigraf-wasm/ - run: mv pkg minigraf-wasm - - - name: Check gzipped binary size - run: | - SIZE=$(gzip -c minigraf-wasm/minigraf_bg.wasm | wc -c) - echo "Gzipped WASM size: ${SIZE} bytes" - if [ "$SIZE" -gt 1048576 ]; then - echo "WARNING: exceeds 1 MB gzipped budget (${SIZE} bytes)" - fi - - - name: Upload pkg artifact - uses: actions/upload-artifact@v4 - with: - name: wasm-pkg - path: minigraf-wasm/ - - test: - needs: build - runs-on: ubuntu-latest - strategy: - fail-fast: false - matrix: - browser: [chrome, firefox] - steps: - - uses: actions/checkout@v4 - - - uses: dtolnay/rust-toolchain@stable - with: - targets: wasm32-unknown-unknown - - - name: Install wasm-pack - run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh - - - name: Setup Chrome - if: matrix.browser == 'chrome' - uses: browser-actions/setup-chrome@v1 - - - name: Setup Firefox - if: matrix.browser == 'firefox' - uses: browser-actions/setup-firefox@v1 - - - name: Test (headless ${{ matrix.browser }}) - run: wasm-pack test --headless --${{ matrix.browser }} --features browser diff --git a/.github/workflows/wasm-release.yml b/.github/workflows/wasm-release.yml deleted file mode 100644 index c773e5d18a..0000000000 --- a/.github/workflows/wasm-release.yml +++ /dev/null @@ -1,185 +0,0 @@ -name: WASM Release Artifacts - -on: - push: - tags: - - '**[0-9]+.[0-9]+.[0-9]+*' - workflow_dispatch: - inputs: - tag: - description: 'Release tag to upload artifacts to (e.g. v0.21.0)' - required: true - -permissions: - contents: write - -jobs: - build-wasm-wasi: - runs-on: ubuntu-22.04 - steps: - - uses: actions/checkout@v6 - with: - persist-credentials: false - - uses: dtolnay/rust-toolchain@stable - with: - targets: wasm32-wasip1 - - name: Build WASI binary - run: cargo build --target wasm32-wasip1 --release --bin minigraf - - name: Stage artifact - run: | - mkdir -p target/wasm-artifacts - cp target/wasm32-wasip1/release/minigraf.wasm target/wasm-artifacts/minigraf-wasi.wasm - - uses: actions/upload-artifact@v6 - with: - name: artifacts-wasm-wasi - path: target/wasm-artifacts/ - - build-wasm-browser: - runs-on: ubuntu-22.04 - steps: - - uses: actions/checkout@v6 - with: - persist-credentials: false - - uses: dtolnay/rust-toolchain@stable - with: - targets: wasm32-unknown-unknown - - name: Install wasm-pack - run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh - - name: Build browser WASM - run: wasm-pack build --target web --features browser - - name: Rename pkg/ → minigraf-wasm/ - run: mv pkg minigraf-wasm - - name: Package minigraf-wasm/ directory - run: | - mkdir -p target/wasm-artifacts - tar -czf target/wasm-artifacts/minigraf-browser-wasm.tar.gz -C . minigraf-wasm/ - - uses: actions/upload-artifact@v6 - with: - name: artifacts-wasm-browser - path: target/wasm-artifacts/ - - release-upload-wasm: - needs: [build-wasm-wasi, build-wasm-browser] - runs-on: ubuntu-22.04 - steps: - - uses: actions/download-artifact@v7 - with: - pattern: artifacts-wasm-* - path: wasm-artifacts/ - merge-multiple: true - - name: Wait for GitHub Release to exist, then upload - env: - GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} - TAG: ${{ inputs.tag || github.ref_name }} - run: | - echo "Waiting for release $TAG to be created by cargo-dist..." - for i in $(seq 1 40); do - if gh release view "$TAG" --repo "$GITHUB_REPOSITORY" > /dev/null 2>&1; then - echo "Release found on attempt $i" - break - fi - echo "Attempt $i/40: release not yet available, waiting 15s..." - sleep 15 - done - if ! gh release view "$TAG" --repo "$GITHUB_REPOSITORY" > /dev/null 2>&1; then - echo "ERROR: Release $TAG not found after 40 attempts (10 minutes). Aborting." - exit 1 - fi - gh release upload "$TAG" wasm-artifacts/* \ - --repo "$GITHUB_REPOSITORY" \ - --clobber - - publish-npm: - name: Publish @minigraf/browser to npm - needs: [build-wasm-browser] - runs-on: ubuntu-22.04 - steps: - - uses: actions/checkout@v6 - with: - persist-credentials: false - - uses: dtolnay/rust-toolchain@stable - with: - targets: wasm32-unknown-unknown - - name: Install wasm-pack - run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh - - name: Set up Node.js - uses: actions/setup-node@v4 - with: - node-version: '20' - registry-url: 'https://registry.npmjs.org' - - name: Build browser WASM - run: wasm-pack build --target web --features browser - - name: Rename pkg/ → minigraf-wasm/ - run: mv pkg minigraf-wasm - - name: Stamp package name and version - env: - TAG: ${{ inputs.tag || github.ref_name }} - run: | - VERSION="${TAG#v}" - # Only publish stable releases; pre-release tags (e.g. v1.0.0-rc.1) are rejected here intentionally. - if [[ ! "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then - echo "ERROR: VERSION '$VERSION' does not look like a semver string. Aborting." - exit 1 - fi - export VERSION - node -e " - const fs = require('fs'); - const p = 'minigraf-wasm/package.json'; - const pkg = JSON.parse(fs.readFileSync(p, 'utf8')); - pkg.name = '@minigraf/browser'; - pkg.version = process.env.VERSION; - fs.writeFileSync(p, JSON.stringify(pkg, null, 2) + '\n'); - " - - name: Publish to npm - working-directory: minigraf-wasm - env: - NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }} - run: npm publish --access public - - publish-npm-wasi: - name: Publish @minigraf/wasi to npm - needs: [build-wasm-wasi] - runs-on: ubuntu-22.04 - steps: - - uses: actions/checkout@v6 - with: - persist-credentials: false - - uses: dtolnay/rust-toolchain@stable - with: - targets: wasm32-wasip1 - - name: Set up Node.js - uses: actions/setup-node@v4 - with: - node-version: '20' - registry-url: 'https://registry.npmjs.org' - - name: Build WASI binary - run: cargo build --target wasm32-wasip1 --release --bin minigraf - - name: Stage WASI npm package - run: cp target/wasm32-wasip1/release/minigraf.wasm minigraf-wasi/minigraf-wasi.wasm - - name: Stamp package version - env: - TAG: ${{ inputs.tag || github.ref_name }} - run: | - VERSION="${TAG#v}" - # Only publish stable releases; pre-release tags (e.g. v1.0.0-rc.1) are rejected here intentionally. - if [[ ! "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then - echo "ERROR: VERSION '$VERSION' does not look like a semver string. Aborting." - exit 1 - fi - export VERSION - node -e " - const fs = require('fs'); - const p = 'minigraf-wasi/package.json'; - const pkg = JSON.parse(fs.readFileSync(p, 'utf8')); - pkg.name = '@minigraf/wasi'; - pkg.version = process.env.VERSION; - fs.writeFileSync(p, JSON.stringify(pkg, null, 2) + '\n'); - " - - name: Test npm package - working-directory: minigraf-wasi - run: npm test - - name: Publish to npm - working-directory: minigraf-wasi - env: - NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }} - run: npm publish --access public diff --git a/.github/workflows/wasm-wasi.yml b/.github/workflows/wasm-wasi.yml deleted file mode 100644 index 87da788ce4..0000000000 --- a/.github/workflows/wasm-wasi.yml +++ /dev/null @@ -1,66 +0,0 @@ -name: WASM WASI - -on: - push: - branches: ["main"] - pull_request: - branches: ["main"] - -env: - CARGO_TERM_COLOR: always - WASMTIME_VERSION: v33.0.0 - WASMER_VERSION: v5.0.4 - -permissions: - contents: read - -jobs: - wasm-wasi: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - - - uses: dtolnay/rust-toolchain@stable - with: - targets: wasm32-wasip1 - - - name: Build (release) - run: cargo build --target wasm32-wasip1 --release --bin minigraf - - - name: Install Wasmtime - run: | - curl -sSfL \ - "https://github.com/bytecodealliance/wasmtime/releases/download/${WASMTIME_VERSION}/wasmtime-${WASMTIME_VERSION}-x86_64-linux.tar.xz" \ - -o /tmp/wasmtime.tar.xz - tar -xf /tmp/wasmtime.tar.xz -C /tmp - echo "/tmp/wasmtime-${WASMTIME_VERSION}-x86_64-linux" >> "$GITHUB_PATH" - - - name: Run WASI tests (Wasmtime runner) - run: cargo test --target wasm32-wasip1 --lib - env: - CARGO_TARGET_WASM32_WASIP1_RUNNER: wasmtime run --dir /tmp - - - name: Smoke test — Wasmtime transact + query - run: | - out=$(printf '(transact [[:alice :name "Alice"]])\n(query [:find ?e :where [?e :name _]])\n' | \ - wasmtime run --dir /tmp \ - target/wasm32-wasip1/release/minigraf.wasm) - echo "$out" - echo "$out" | grep -q "result(s) found" || { echo "SMOKE TEST FAILED: no results in output"; exit 1; } - - - name: Install Wasmer - run: | - curl -sSfL \ - "https://github.com/wasmerio/wasmer/releases/download/${WASMER_VERSION}/wasmer-linux-amd64.tar.gz" \ - -o /tmp/wasmer.tar.gz - mkdir -p /tmp/wasmer-install - tar -xf /tmp/wasmer.tar.gz -C /tmp/wasmer-install bin/wasmer - echo "/tmp/wasmer-install/bin" >> "$GITHUB_PATH" - - - name: Smoke test — Wasmer transact + query - run: | - out=$(printf '(transact [[:alice :name "Alice"]])\n(query [:find ?e :where [?e :name _]])\n' | \ - wasmer run --dir /tmp \ - target/wasm32-wasip1/release/minigraf.wasm) - echo "$out" - echo "$out" | grep -q "result(s) found" || { echo "SMOKE TEST FAILED: no results in output"; exit 1; } diff --git a/CHANGELOG.md b/CHANGELOG.md index 653209e736..2304ed5617 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,17 @@ All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## Unreleased + +### Infrastructure + +- Split Python, Node.js, and browser WASM/WASI bindings into independent repos under `project-minigraf` org (#231) + - `minigraf-python`: https://github.com/project-minigraf/minigraf-python + - `minigraf-node`: https://github.com/project-minigraf/minigraf-node + - `minigraf-wasm`: https://github.com/project-minigraf/minigraf-wasm +- Add `cascade.yml`: publishes `minigraf-ffi` to crates.io and dispatches releases to binding repos on every version tag +- Publish `minigraf-ffi` to crates.io (previously internal only) + ## v1.1.1 — 2026-05-17 Patch release. Fixes cargo-dist Windows build failure that prevented REPL binaries and crates.io publish from completing for v1.1.0. No code changes to the library itself. diff --git a/CLAUDE.md b/CLAUDE.md index a215324d38..20200956e1 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -174,11 +174,10 @@ See `TEST_COVERAGE.md` for the full per-file breakdown. ## Key Files for the Next Phase -Phase 8 is complete — v1.0.0 released. Wave 3 Reliability is complete. Phase 9 (Ecosystem & Tooling) is next. +Phase 8 is complete — v1.0.0 released. Wave 3 Reliability is complete. #231 Repo Split (Phase 1) is complete — Python, Node, WASM bindings are in separate repos. Wave 5 (Query Profiler) is next. -Phase 9 relevant areas (see `ROADMAP.md` for full spec): -- `examples/` — end-to-end annotated examples (agentic memory, offline-first mobile, browser PWA) -- `.wiki/` — cookbook-style guides for each Phase 9 deliverable +Wave 5 relevant areas (see `ROADMAP.md` for full spec): +- `src/query/datalog/` — query executor where profiling hooks will go (#185) - `BENCHMARKS.md` — post-1.0 performance baseline updates ## Testing Conventions diff --git a/Cargo.toml b/Cargo.toml index 64051f0285..8cc60a8de8 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,5 +1,5 @@ [workspace] -members = [".", "minigraf-ffi", "minigraf-c", "minigraf-node"] +members = [".", "minigraf-ffi", "minigraf-c"] exclude = ["fuzz"] resolver = "2" @@ -19,15 +19,6 @@ documentation = "https://docs.rs/minigraf" [lib] crate-type = ["cdylib", "rlib"] -# Stub that lets `cargo run --bin uniffi-bindgen` work from the workspace root. -# maturin calls this when bindings = "uniffi"; it execs the binary pre-built by -# build.sh (cargo build --bin uniffi-bindgen --manifest-path minigraf-ffi/Cargo.toml). -# Uses only std — no extra dependencies. Excluded from `cargo build --lib` so -# WASM builds are unaffected. -[[bin]] -name = "uniffi-bindgen" -path = "src/bin/uniffi_bindgen_stub.rs" -doc = false [package.metadata.wasm-pack.profile.release] wasm-opt = false diff --git a/README.md b/README.md index 187e2047fa..92b0bfe0bc 100644 --- a/README.md +++ b/README.md @@ -131,6 +131,19 @@ No other database offers this combination: **Embedded graph memory for agents, mobile, and the browser — SQLite's simplicity + Datomic's temporal model.** +## Language Bindings + +| Language | Package | Repo | +|---|---|---| +| Python | [`minigraf` on PyPI](https://pypi.org/p/minigraf) | [minigraf-python](https://github.com/project-minigraf/minigraf-python) | +| Node.js | [`minigraf` on npm](https://www.npmjs.com/package/minigraf) | [minigraf-node](https://github.com/project-minigraf/minigraf-node) | +| Browser WASM | [`@minigraf/browser` on npm](https://www.npmjs.com/package/@minigraf/browser) | [minigraf-wasm](https://github.com/project-minigraf/minigraf-wasm) | +| WASI | [`@minigraf/wasi` on npm](https://www.npmjs.com/package/@minigraf/wasi) | [minigraf-wasm](https://github.com/project-minigraf/minigraf-wasm) | +| Java | (in this repo — Phase 2 split pending) | — | +| Android | (in this repo — Phase 2 split pending) | — | +| iOS/macOS | (in this repo — Phase 2 split pending) | — | +| C | [`minigraf-c`](./minigraf-c) (in this repo) | — | + See the [Comparison](https://github.com/project-minigraf/minigraf/wiki/Comparison) wiki page for detailed analysis including temporal vs. time-series databases. ### For AI Agents diff --git a/ROADMAP.md b/ROADMAP.md index 60cb2c5c6b..e53e48016c 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -1692,9 +1692,11 @@ When evaluating features, ask: - ✅ Wave 3: Reliability — WAL fault injection, migration matrix, index corruption resilience, XTDB/Datomic compat, coverage gates (#209, #210, #212–#217, #219–#221) - ✅ Wave 4: Deferred Features — #180, #181, #182, #183 tagged milestone 2.0; #187 closed; #201 deferred -**Next gate**: #231 — Repo Split (gates Wave 5 and beyond; ecosystem work is cleaner post-split) +**Completed gate**: #231 — Repo Split complete (Phase 1: Python, Node, WASM split out; Phase 2: Java/Android/Swift deferred) -**Pending waves** (post-split): +**Next**: Wave 5 — Query profiler (#185); #184 → `minigraf-inspector`, #186 → `minigraf-visualizer` + +**Pending waves**: - Wave 5: Query profiler (#185) — stays in this repo; #184 → `minigraf-inspector`, #186 → `minigraf-visualizer` - Wave 6+7: Integration examples (#193–#200) → `minigraf-examples` repo (stub created) - Wave 8: Documentation — cookbook (#190), perf tuning guide (#191), error message guide (#192) @@ -1714,4 +1716,4 @@ See [GitHub Issues](https://github.com/project-minigraf/minigraf/issues) for spe --- -**Last Updated**: Wave 4 Complete (May 2026) — 935 tests passing, v1.1.1; milestone 2.0 issues queued; #231 repo-split is next gate +**Last Updated**: #231 Repo Split Complete (May 2026) — 935 tests passing, v1.1.1; Phase 1 bindings (Python, Node, WASM) in separate repos; Wave 5 is next diff --git a/minigraf-ffi/Cargo.toml b/minigraf-ffi/Cargo.toml index 62c1f06e35..98294efe7e 100644 --- a/minigraf-ffi/Cargo.toml +++ b/minigraf-ffi/Cargo.toml @@ -7,6 +7,7 @@ license = "MIT OR Apache-2.0" authors = ["Aditya Mukhopadhyay"] repository = "https://github.com/project-minigraf/minigraf" documentation = "https://docs.rs/minigraf-ffi" +readme = "README.md" keywords = ["graph", "datalog", "bitemporal", "embedded", "database"] categories = ["database-implementations", "embedded"] diff --git a/minigraf-ffi/README.md b/minigraf-ffi/README.md new file mode 100644 index 0000000000..9ed7aa8ebf --- /dev/null +++ b/minigraf-ffi/README.md @@ -0,0 +1,22 @@ +# minigraf-ffi + +UniFFI bridge crate for [Minigraf](https://github.com/project-minigraf/minigraf) — a zero-config, single-file, embedded graph database with bi-temporal Datalog queries. + +## Purpose + +This crate is the UniFFI bridge that language binding repos use to generate their native bindings. It is not intended to be used directly. + +## Language bindings + +Use the language-specific repo for your platform: + +| Language | Package | Repo | +|---|---|---| +| Python | [`minigraf` on PyPI](https://pypi.org/p/minigraf) | [minigraf-python](https://github.com/project-minigraf/minigraf-python) | +| Node.js | [`minigraf` on npm](https://www.npmjs.com/package/minigraf) | [minigraf-node](https://github.com/project-minigraf/minigraf-node) | +| Browser WASM | [`@minigraf/browser` on npm](https://www.npmjs.com/package/@minigraf/browser) | [minigraf-wasm](https://github.com/project-minigraf/minigraf-wasm) | +| WASI | [`@minigraf/wasi` on npm](https://www.npmjs.com/package/@minigraf/wasi) | [minigraf-wasm](https://github.com/project-minigraf/minigraf-wasm) | + +## License + +MIT OR Apache-2.0 diff --git a/minigraf-ffi/python/README.md b/minigraf-ffi/python/README.md deleted file mode 100644 index 5e55c7db21..0000000000 --- a/minigraf-ffi/python/README.md +++ /dev/null @@ -1,59 +0,0 @@ -# minigraf (Python) - -[![PyPI](https://img.shields.io/pypi/v/minigraf.svg)](https://pypi.org/project/minigraf) -[![License: MIT OR Apache-2.0](https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-blue.svg)](https://github.com/project-minigraf/minigraf#license) - -> Embedded bi-temporal graph database for Python — Datalog queries, time travel, pre-built wheels - -Minigraf for Python: pre-built wheels for Linux x86_64/aarch64, macOS universal2, and Windows x86_64. No Rust toolchain required. - -## Install - -```sh -pip install minigraf -``` - -## Quick start - -```python -from minigraf import MiniGrafDb - -# File-backed database -db = MiniGrafDb.open("myapp.graph") - -# In-memory database (ephemeral / testing) -mem = MiniGrafDb.open_in_memory() - -# Transact facts -r = db.execute('(transact [[:alice :person/name "Alice"] [:alice :person/age 30]])') -# '{"transacted": 1}' - -# Query with Datalog -q = db.execute('(query [:find ?name ?age :where [?e :person/name ?name] [?e :person/age ?age]])') -# '{"variables": ["?name", "?age"], "results": [["Alice", 30]]}' - -# Time travel — state as of transaction 1 -snap = db.execute('(query [:find ?age :as-of 1 :where [:alice :person/age ?age]])') - -# Flush dirty pages to disk -db.checkpoint() -``` - -## Response shapes - -| Command | JSON | -|---|---| -| `transact` | `{"transacted": }` | -| `retract` | `{"retracted": }` | -| `query` | `{"variables": [...], "results": [[...]]}` | -| `rule` | `{"ok": true}` | - -## Links - -- [Full Python integration guide](https://github.com/project-minigraf/minigraf/wiki/Use-Cases#python) -- [Repository](https://github.com/project-minigraf/minigraf) -- [Datalog Reference](https://github.com/project-minigraf/minigraf/wiki/Datalog-Reference) - -## License - -MIT OR Apache-2.0 diff --git a/minigraf-ffi/python/build.sh b/minigraf-ffi/python/build.sh deleted file mode 100755 index f62277c986..0000000000 --- a/minigraf-ffi/python/build.sh +++ /dev/null @@ -1,34 +0,0 @@ -#!/usr/bin/env bash -# build.sh — build and install the minigraf Python extension. -# -# maturin (bindings = "uniffi") calls `cargo run --bin uniffi-bindgen` to generate -# Python bindings. The actual binary lives in the minigraf-ffi workspace member, but -# maturin calls cargo without --package so cargo searches the workspace root only. -# -# Fix: a stub binary in the root package (src/bin/uniffi_bindgen_stub.rs) satisfies -# the lookup and execs the real pre-built binary at target/debug/uniffi-bindgen[.exe]. -# This script pre-builds the real binary before invoking maturin. -# -# Requires an active virtualenv (or conda environment). - -set -euo pipefail - -SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" -REPO_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)" -FFI_TOML="$REPO_ROOT/minigraf-ffi/Cargo.toml" - -# Pre-build the real uniffi-bindgen binary (no-op if already up to date). -# The stub in the workspace root execs this binary when maturin calls -# `cargo run --bin uniffi-bindgen`. -cargo build --bin uniffi-bindgen --manifest-path "$FFI_TOML" - -cd "$SCRIPT_DIR" -SUBCOMMAND="${1:-}" - -if [[ "$SUBCOMMAND" == "build" ]]; then - shift - maturin build "$@" -else - maturin develop - [[ "$SUBCOMMAND" == "test" ]] && pytest tests/ -v -fi diff --git a/minigraf-ffi/python/minigraf/__init__.py b/minigraf-ffi/python/minigraf/__init__.py deleted file mode 100644 index 98a3776bb0..0000000000 --- a/minigraf-ffi/python/minigraf/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -from .minigraf_ffi import MiniGrafDb, MiniGrafError - -__all__ = ["MiniGrafDb", "MiniGrafError"] diff --git a/minigraf-ffi/python/pyproject.toml b/minigraf-ffi/python/pyproject.toml deleted file mode 100644 index cf65c7c504..0000000000 --- a/minigraf-ffi/python/pyproject.toml +++ /dev/null @@ -1,29 +0,0 @@ -[build-system] -requires = ["maturin>=1.5,<2"] -build-backend = "maturin" - -[project] -name = "minigraf" -version = "1.1.1" -description = "Zero-config, single-file, embedded graph database with bi-temporal Datalog queries" -license = { text = "MIT OR Apache-2.0" } -requires-python = ">=3.9" -keywords = ["graph", "datalog", "bitemporal", "embedded", "database"] -classifiers = [ - "Programming Language :: Rust", - "Programming Language :: Python :: Implementation :: CPython", - "Programming Language :: Python :: 3", - "License :: OSI Approved :: MIT License", - "License :: OSI Approved :: Apache Software License", -] - -[project.urls] -Homepage = "https://github.com/project-minigraf/minigraf" -Repository = "https://github.com/project-minigraf/minigraf" -"Bug Tracker" = "https://github.com/project-minigraf/minigraf/issues" - -[tool.maturin] -manifest-path = "../Cargo.toml" -bindings = "uniffi" -python-packages = ["minigraf"] -module-name = "minigraf.minigraf_ffi" diff --git a/minigraf-ffi/python/tests/__init__.py b/minigraf-ffi/python/tests/__init__.py deleted file mode 100644 index e69de29bb2..0000000000 diff --git a/minigraf-ffi/python/tests/test_basic.py b/minigraf-ffi/python/tests/test_basic.py deleted file mode 100644 index 1991079af6..0000000000 --- a/minigraf-ffi/python/tests/test_basic.py +++ /dev/null @@ -1,38 +0,0 @@ -import json -import os -import pytest -from minigraf import MiniGrafDb, MiniGrafError - - -def test_open_in_memory(): - db = MiniGrafDb.open_in_memory() - assert db is not None - - -def test_transact_and_query(): - db = MiniGrafDb.open_in_memory() - result = json.loads(db.execute('(transact [[:alice :name "Alice"]])')) - assert "transacted" in result - - result = json.loads(db.execute("(query [:find ?n :where [?e :name ?n]])")) - assert result["variables"] == ["?n"] - assert result["results"][0][0] == "Alice" - - -def test_invalid_datalog_raises(): - db = MiniGrafDb.open_in_memory() - with pytest.raises(MiniGrafError): - db.execute("not valid datalog !!!") - - -def test_file_backed_roundtrip(tmp_path): - path = str(tmp_path / "test.graph") - - db = MiniGrafDb.open(path) - db.execute('(transact [[:bob :name "Bob"]])') - db.checkpoint() - del db - - db2 = MiniGrafDb.open(path) - result = json.loads(db2.execute("(query [:find ?n :where [?e :name ?n]])")) - assert result["results"][0][0] == "Bob" diff --git a/minigraf-node/Cargo.toml b/minigraf-node/Cargo.toml deleted file mode 100644 index adabe63e69..0000000000 --- a/minigraf-node/Cargo.toml +++ /dev/null @@ -1,20 +0,0 @@ -[package] -name = "minigraf-node" -version = "1.1.1" -edition = "2024" -publish = false - -[lib] -crate-type = ["cdylib"] - -[dependencies] -napi = { version = "3.8", features = ["napi6"] } -napi-derive = "3" -minigraf = { path = ".." } -serde_json = "1.0" - -[build-dependencies] -napi-build = "2.1" - -[lints] -workspace = true diff --git a/minigraf-node/README.md b/minigraf-node/README.md deleted file mode 100644 index da1541d443..0000000000 --- a/minigraf-node/README.md +++ /dev/null @@ -1,65 +0,0 @@ -# minigraf (Node.js) - -[![npm](https://img.shields.io/npm/v/minigraf.svg)](https://www.npmjs.com/package/minigraf) -[![License: MIT OR Apache-2.0](https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-blue.svg)](https://github.com/project-minigraf/minigraf#license) - -> Embedded bi-temporal graph database for Node.js — Datalog queries, time travel, native addon - -Minigraf for Node.js: a native addon (no WASM, full file I/O) with pre-built binaries for Linux x86_64/aarch64, macOS universal2, and Windows x86_64. No build step required. - -## Install - -```sh -npm install minigraf -``` - -## Quick start - -```typescript -import { MiniGrafDb } from 'minigraf'; - -// File-backed database -const db = new MiniGrafDb('myapp.graph'); - -// In-memory database (ephemeral / testing) -const mem = MiniGrafDb.inMemory(); - -// Transact facts -const r = JSON.parse(db.execute( - '(transact [[:alice :person/name "Alice"] [:alice :person/age 30]])' -)); -// { "transacted": 1 } - -// Query with Datalog -const q = JSON.parse(db.execute( - '(query [:find ?name ?age :where [?e :person/name ?name] [?e :person/age ?age]])' -)); -// { "variables": ["?name", "?age"], "results": [["Alice", 30]] } - -// Time travel — state as of transaction 1 -const snap = JSON.parse(db.execute( - '(query [:find ?age :as-of 1 :where [:alice :person/age ?age]])' -)); - -// Flush dirty pages to disk -db.checkpoint(); -``` - -## Response shapes - -| Command | JSON | -|---|---| -| `transact` | `{"transacted": }` | -| `retract` | `{"retracted": }` | -| `query` | `{"variables": [...], "results": [[...]]}` | -| `rule` | `{"ok": true}` | - -## Links - -- [Full Node.js integration guide](https://github.com/project-minigraf/minigraf/wiki/Use-Cases#nodejs--typescript) -- [Repository](https://github.com/project-minigraf/minigraf) -- [Datalog Reference](https://github.com/project-minigraf/minigraf/wiki/Datalog-Reference) - -## License - -MIT OR Apache-2.0 diff --git a/minigraf-node/build.rs b/minigraf-node/build.rs deleted file mode 100644 index 0f1b01002b..0000000000 --- a/minigraf-node/build.rs +++ /dev/null @@ -1,3 +0,0 @@ -fn main() { - napi_build::setup(); -} diff --git a/minigraf-node/index.d.ts b/minigraf-node/index.d.ts deleted file mode 100644 index 330b9b7fe4..0000000000 --- a/minigraf-node/index.d.ts +++ /dev/null @@ -1,12 +0,0 @@ -/* auto-generated by NAPI-RS */ -/* eslint-disable */ -export declare class MiniGrafDb { - /** Open a file-backed database. Throws on error. */ - constructor(path: string) - /** Open an in-memory database. Throws on error. */ - static inMemory(): MiniGrafDb - /** Execute a Datalog string. Returns a JSON string. Throws on error. */ - execute(datalog: string): string - /** Flush the WAL to disk. Throws on error. */ - checkpoint(): void -} diff --git a/minigraf-node/index.js b/minigraf-node/index.js deleted file mode 100644 index 307ffd33fd..0000000000 --- a/minigraf-node/index.js +++ /dev/null @@ -1,579 +0,0 @@ -// prettier-ignore -/* eslint-disable */ -// @ts-nocheck -/* auto-generated by NAPI-RS */ - -const { readFileSync } = require('node:fs') -let nativeBinding = null -const loadErrors = [] - -const isMusl = () => { - let musl = false - if (process.platform === 'linux') { - musl = isMuslFromFilesystem() - if (musl === null) { - musl = isMuslFromReport() - } - if (musl === null) { - musl = isMuslFromChildProcess() - } - } - return musl -} - -const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-') - -const isMuslFromFilesystem = () => { - try { - return readFileSync('/usr/bin/ldd', 'utf-8').includes('musl') - } catch { - return null - } -} - -const isMuslFromReport = () => { - let report = null - if (typeof process.report?.getReport === 'function') { - process.report.excludeNetwork = true - report = process.report.getReport() - } - if (!report) { - return null - } - if (report.header && report.header.glibcVersionRuntime) { - return false - } - if (Array.isArray(report.sharedObjects)) { - if (report.sharedObjects.some(isFileMusl)) { - return true - } - } - return false -} - -const isMuslFromChildProcess = () => { - try { - return require('child_process').execSync('ldd --version', { encoding: 'utf8' }).includes('musl') - } catch (e) { - // If we reach this case, we don't know if the system is musl or not, so is better to just fallback to false - return false - } -} - -function requireNative() { - if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) { - try { - return require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH); - } catch (err) { - loadErrors.push(err) - } - } else if (process.platform === 'android') { - if (process.arch === 'arm64') { - try { - return require('./minigraf.android-arm64.node') - } catch (e) { - loadErrors.push(e) - } - try { - const binding = require('minigraf-android-arm64') - const bindingPackageVersion = require('minigraf-android-arm64/package.json').version - if (bindingPackageVersion !== '0.25.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { - throw new Error(`Native binding package version mismatch, expected 0.25.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) - } - return binding - } catch (e) { - loadErrors.push(e) - } - } else if (process.arch === 'arm') { - try { - return require('./minigraf.android-arm-eabi.node') - } catch (e) { - loadErrors.push(e) - } - try { - const binding = require('minigraf-android-arm-eabi') - const bindingPackageVersion = require('minigraf-android-arm-eabi/package.json').version - if (bindingPackageVersion !== '0.25.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { - throw new Error(`Native binding package version mismatch, expected 0.25.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) - } - return binding - } catch (e) { - loadErrors.push(e) - } - } else { - loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`)) - } - } else if (process.platform === 'win32') { - if (process.arch === 'x64') { - if (process.config?.variables?.shlib_suffix === 'dll.a' || process.config?.variables?.node_target_type === 'shared_library') { - try { - return require('./minigraf.win32-x64-gnu.node') - } catch (e) { - loadErrors.push(e) - } - try { - const binding = require('minigraf-win32-x64-gnu') - const bindingPackageVersion = require('minigraf-win32-x64-gnu/package.json').version - if (bindingPackageVersion !== '0.25.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { - throw new Error(`Native binding package version mismatch, expected 0.25.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) - } - return binding - } catch (e) { - loadErrors.push(e) - } - } else { - try { - return require('./minigraf.win32-x64-msvc.node') - } catch (e) { - loadErrors.push(e) - } - try { - const binding = require('minigraf-win32-x64-msvc') - const bindingPackageVersion = require('minigraf-win32-x64-msvc/package.json').version - if (bindingPackageVersion !== '0.25.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { - throw new Error(`Native binding package version mismatch, expected 0.25.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) - } - return binding - } catch (e) { - loadErrors.push(e) - } - } - } else if (process.arch === 'ia32') { - try { - return require('./minigraf.win32-ia32-msvc.node') - } catch (e) { - loadErrors.push(e) - } - try { - const binding = require('minigraf-win32-ia32-msvc') - const bindingPackageVersion = require('minigraf-win32-ia32-msvc/package.json').version - if (bindingPackageVersion !== '0.25.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { - throw new Error(`Native binding package version mismatch, expected 0.25.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) - } - return binding - } catch (e) { - loadErrors.push(e) - } - } else if (process.arch === 'arm64') { - try { - return require('./minigraf.win32-arm64-msvc.node') - } catch (e) { - loadErrors.push(e) - } - try { - const binding = require('minigraf-win32-arm64-msvc') - const bindingPackageVersion = require('minigraf-win32-arm64-msvc/package.json').version - if (bindingPackageVersion !== '0.25.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { - throw new Error(`Native binding package version mismatch, expected 0.25.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) - } - return binding - } catch (e) { - loadErrors.push(e) - } - } else { - loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`)) - } - } else if (process.platform === 'darwin') { - try { - return require('./minigraf.darwin-universal.node') - } catch (e) { - loadErrors.push(e) - } - try { - const binding = require('minigraf-darwin-universal') - const bindingPackageVersion = require('minigraf-darwin-universal/package.json').version - if (bindingPackageVersion !== '0.25.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { - throw new Error(`Native binding package version mismatch, expected 0.25.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) - } - return binding - } catch (e) { - loadErrors.push(e) - } - if (process.arch === 'x64') { - try { - return require('./minigraf.darwin-x64.node') - } catch (e) { - loadErrors.push(e) - } - try { - const binding = require('minigraf-darwin-x64') - const bindingPackageVersion = require('minigraf-darwin-x64/package.json').version - if (bindingPackageVersion !== '0.25.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { - throw new Error(`Native binding package version mismatch, expected 0.25.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) - } - return binding - } catch (e) { - loadErrors.push(e) - } - } else if (process.arch === 'arm64') { - try { - return require('./minigraf.darwin-arm64.node') - } catch (e) { - loadErrors.push(e) - } - try { - const binding = require('minigraf-darwin-arm64') - const bindingPackageVersion = require('minigraf-darwin-arm64/package.json').version - if (bindingPackageVersion !== '0.25.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { - throw new Error(`Native binding package version mismatch, expected 0.25.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) - } - return binding - } catch (e) { - loadErrors.push(e) - } - } else { - loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`)) - } - } else if (process.platform === 'freebsd') { - if (process.arch === 'x64') { - try { - return require('./minigraf.freebsd-x64.node') - } catch (e) { - loadErrors.push(e) - } - try { - const binding = require('minigraf-freebsd-x64') - const bindingPackageVersion = require('minigraf-freebsd-x64/package.json').version - if (bindingPackageVersion !== '0.25.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { - throw new Error(`Native binding package version mismatch, expected 0.25.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) - } - return binding - } catch (e) { - loadErrors.push(e) - } - } else if (process.arch === 'arm64') { - try { - return require('./minigraf.freebsd-arm64.node') - } catch (e) { - loadErrors.push(e) - } - try { - const binding = require('minigraf-freebsd-arm64') - const bindingPackageVersion = require('minigraf-freebsd-arm64/package.json').version - if (bindingPackageVersion !== '0.25.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { - throw new Error(`Native binding package version mismatch, expected 0.25.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) - } - return binding - } catch (e) { - loadErrors.push(e) - } - } else { - loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`)) - } - } else if (process.platform === 'linux') { - if (process.arch === 'x64') { - if (isMusl()) { - try { - return require('./minigraf.linux-x64-musl.node') - } catch (e) { - loadErrors.push(e) - } - try { - const binding = require('minigraf-linux-x64-musl') - const bindingPackageVersion = require('minigraf-linux-x64-musl/package.json').version - if (bindingPackageVersion !== '0.25.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { - throw new Error(`Native binding package version mismatch, expected 0.25.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) - } - return binding - } catch (e) { - loadErrors.push(e) - } - } else { - try { - return require('./minigraf.linux-x64-gnu.node') - } catch (e) { - loadErrors.push(e) - } - try { - const binding = require('minigraf-linux-x64-gnu') - const bindingPackageVersion = require('minigraf-linux-x64-gnu/package.json').version - if (bindingPackageVersion !== '0.25.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { - throw new Error(`Native binding package version mismatch, expected 0.25.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) - } - return binding - } catch (e) { - loadErrors.push(e) - } - } - } else if (process.arch === 'arm64') { - if (isMusl()) { - try { - return require('./minigraf.linux-arm64-musl.node') - } catch (e) { - loadErrors.push(e) - } - try { - const binding = require('minigraf-linux-arm64-musl') - const bindingPackageVersion = require('minigraf-linux-arm64-musl/package.json').version - if (bindingPackageVersion !== '0.25.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { - throw new Error(`Native binding package version mismatch, expected 0.25.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) - } - return binding - } catch (e) { - loadErrors.push(e) - } - } else { - try { - return require('./minigraf.linux-arm64-gnu.node') - } catch (e) { - loadErrors.push(e) - } - try { - const binding = require('minigraf-linux-arm64-gnu') - const bindingPackageVersion = require('minigraf-linux-arm64-gnu/package.json').version - if (bindingPackageVersion !== '0.25.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { - throw new Error(`Native binding package version mismatch, expected 0.25.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) - } - return binding - } catch (e) { - loadErrors.push(e) - } - } - } else if (process.arch === 'arm') { - if (isMusl()) { - try { - return require('./minigraf.linux-arm-musleabihf.node') - } catch (e) { - loadErrors.push(e) - } - try { - const binding = require('minigraf-linux-arm-musleabihf') - const bindingPackageVersion = require('minigraf-linux-arm-musleabihf/package.json').version - if (bindingPackageVersion !== '0.25.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { - throw new Error(`Native binding package version mismatch, expected 0.25.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) - } - return binding - } catch (e) { - loadErrors.push(e) - } - } else { - try { - return require('./minigraf.linux-arm-gnueabihf.node') - } catch (e) { - loadErrors.push(e) - } - try { - const binding = require('minigraf-linux-arm-gnueabihf') - const bindingPackageVersion = require('minigraf-linux-arm-gnueabihf/package.json').version - if (bindingPackageVersion !== '0.25.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { - throw new Error(`Native binding package version mismatch, expected 0.25.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) - } - return binding - } catch (e) { - loadErrors.push(e) - } - } - } else if (process.arch === 'loong64') { - if (isMusl()) { - try { - return require('./minigraf.linux-loong64-musl.node') - } catch (e) { - loadErrors.push(e) - } - try { - const binding = require('minigraf-linux-loong64-musl') - const bindingPackageVersion = require('minigraf-linux-loong64-musl/package.json').version - if (bindingPackageVersion !== '0.25.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { - throw new Error(`Native binding package version mismatch, expected 0.25.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) - } - return binding - } catch (e) { - loadErrors.push(e) - } - } else { - try { - return require('./minigraf.linux-loong64-gnu.node') - } catch (e) { - loadErrors.push(e) - } - try { - const binding = require('minigraf-linux-loong64-gnu') - const bindingPackageVersion = require('minigraf-linux-loong64-gnu/package.json').version - if (bindingPackageVersion !== '0.25.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { - throw new Error(`Native binding package version mismatch, expected 0.25.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) - } - return binding - } catch (e) { - loadErrors.push(e) - } - } - } else if (process.arch === 'riscv64') { - if (isMusl()) { - try { - return require('./minigraf.linux-riscv64-musl.node') - } catch (e) { - loadErrors.push(e) - } - try { - const binding = require('minigraf-linux-riscv64-musl') - const bindingPackageVersion = require('minigraf-linux-riscv64-musl/package.json').version - if (bindingPackageVersion !== '0.25.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { - throw new Error(`Native binding package version mismatch, expected 0.25.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) - } - return binding - } catch (e) { - loadErrors.push(e) - } - } else { - try { - return require('./minigraf.linux-riscv64-gnu.node') - } catch (e) { - loadErrors.push(e) - } - try { - const binding = require('minigraf-linux-riscv64-gnu') - const bindingPackageVersion = require('minigraf-linux-riscv64-gnu/package.json').version - if (bindingPackageVersion !== '0.25.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { - throw new Error(`Native binding package version mismatch, expected 0.25.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) - } - return binding - } catch (e) { - loadErrors.push(e) - } - } - } else if (process.arch === 'ppc64') { - try { - return require('./minigraf.linux-ppc64-gnu.node') - } catch (e) { - loadErrors.push(e) - } - try { - const binding = require('minigraf-linux-ppc64-gnu') - const bindingPackageVersion = require('minigraf-linux-ppc64-gnu/package.json').version - if (bindingPackageVersion !== '0.25.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { - throw new Error(`Native binding package version mismatch, expected 0.25.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) - } - return binding - } catch (e) { - loadErrors.push(e) - } - } else if (process.arch === 's390x') { - try { - return require('./minigraf.linux-s390x-gnu.node') - } catch (e) { - loadErrors.push(e) - } - try { - const binding = require('minigraf-linux-s390x-gnu') - const bindingPackageVersion = require('minigraf-linux-s390x-gnu/package.json').version - if (bindingPackageVersion !== '0.25.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { - throw new Error(`Native binding package version mismatch, expected 0.25.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) - } - return binding - } catch (e) { - loadErrors.push(e) - } - } else { - loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`)) - } - } else if (process.platform === 'openharmony') { - if (process.arch === 'arm64') { - try { - return require('./minigraf.openharmony-arm64.node') - } catch (e) { - loadErrors.push(e) - } - try { - const binding = require('minigraf-openharmony-arm64') - const bindingPackageVersion = require('minigraf-openharmony-arm64/package.json').version - if (bindingPackageVersion !== '0.25.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { - throw new Error(`Native binding package version mismatch, expected 0.25.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) - } - return binding - } catch (e) { - loadErrors.push(e) - } - } else if (process.arch === 'x64') { - try { - return require('./minigraf.openharmony-x64.node') - } catch (e) { - loadErrors.push(e) - } - try { - const binding = require('minigraf-openharmony-x64') - const bindingPackageVersion = require('minigraf-openharmony-x64/package.json').version - if (bindingPackageVersion !== '0.25.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { - throw new Error(`Native binding package version mismatch, expected 0.25.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) - } - return binding - } catch (e) { - loadErrors.push(e) - } - } else if (process.arch === 'arm') { - try { - return require('./minigraf.openharmony-arm.node') - } catch (e) { - loadErrors.push(e) - } - try { - const binding = require('minigraf-openharmony-arm') - const bindingPackageVersion = require('minigraf-openharmony-arm/package.json').version - if (bindingPackageVersion !== '0.25.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') { - throw new Error(`Native binding package version mismatch, expected 0.25.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`) - } - return binding - } catch (e) { - loadErrors.push(e) - } - } else { - loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`)) - } - } else { - loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`)) - } -} - -nativeBinding = requireNative() - -if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) { - let wasiBinding = null - let wasiBindingError = null - try { - wasiBinding = require('./minigraf.wasi.cjs') - nativeBinding = wasiBinding - } catch (err) { - if (process.env.NAPI_RS_FORCE_WASI) { - wasiBindingError = err - } - } - if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) { - try { - wasiBinding = require('minigraf-wasm32-wasi') - nativeBinding = wasiBinding - } catch (err) { - if (process.env.NAPI_RS_FORCE_WASI) { - if (!wasiBindingError) { - wasiBindingError = err - } else { - wasiBindingError.cause = err - } - loadErrors.push(err) - } - } - } - if (process.env.NAPI_RS_FORCE_WASI === 'error' && !wasiBinding) { - const error = new Error('WASI binding not found and NAPI_RS_FORCE_WASI is set to error') - error.cause = wasiBindingError - throw error - } -} - -if (!nativeBinding) { - if (loadErrors.length > 0) { - throw new Error( - `Cannot find native binding. ` + - `npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` + - 'Please try `npm i` again after removing both package-lock.json and node_modules directory.', - { - cause: loadErrors.reduce((err, cur) => { - cur.cause = err - return cur - }), - }, - ) - } - throw new Error(`Failed to load native binding`) -} - -module.exports = nativeBinding -module.exports.MiniGrafDb = nativeBinding.MiniGrafDb diff --git a/minigraf-node/package.json b/minigraf-node/package.json deleted file mode 100644 index b8483e0469..0000000000 --- a/minigraf-node/package.json +++ /dev/null @@ -1,39 +0,0 @@ -{ - "name": "minigraf", - "version": "1.1.1", - "description": "Zero-config, single-file, embedded graph database with bi-temporal Datalog queries", - "main": "index.js", - "types": "index.d.ts", - "license": "MIT OR Apache-2.0", - "repository": { - "type": "git", - "url": "https://github.com/project-minigraf/minigraf.git" - }, - "keywords": ["graph", "datalog", "bitemporal", "embedded", "database"], - "engines": { - "node": ">=18" - }, - "napi": { - "name": "minigraf", - "triples": { - "defaults": true, - "additional": [ - "aarch64-unknown-linux-gnu", - "universal-apple-darwin" - ] - } - }, - "scripts": { - "build": "napi build --platform --release", - "test": "node --test test/basic.test.mjs" - }, - "devDependencies": { - "@napi-rs/cli": "^3" - }, - "optionalDependencies": { - "@minigraf/linux-x64-gnu": "1.0.0", - "@minigraf/linux-arm64-gnu": "1.0.0", - "@minigraf/darwin-universal": "1.0.0", - "@minigraf/win32-x64-msvc": "1.0.0" - } -} diff --git a/minigraf-node/packages/@minigraf/darwin-universal/package.json b/minigraf-node/packages/@minigraf/darwin-universal/package.json deleted file mode 100644 index df5f31158b..0000000000 --- a/minigraf-node/packages/@minigraf/darwin-universal/package.json +++ /dev/null @@ -1,20 +0,0 @@ -{ - "name": "@minigraf/darwin-universal", - "version": "0.0.0", - "description": "Zero-config, single-file, embedded graph database with bi-temporal Datalog queries (macOS universal)", - "os": [ - "darwin" - ], - "cpu": [ - "x64", - "arm64" - ], - "main": "minigraf.darwin-universal.node", - "files": [ - "minigraf.darwin-universal.node" - ], - "license": "MIT OR Apache-2.0", - "engines": { - "node": ">=18" - } -} diff --git a/minigraf-node/packages/@minigraf/linux-arm64-gnu/package.json b/minigraf-node/packages/@minigraf/linux-arm64-gnu/package.json deleted file mode 100644 index 2d26925ab0..0000000000 --- a/minigraf-node/packages/@minigraf/linux-arm64-gnu/package.json +++ /dev/null @@ -1,22 +0,0 @@ -{ - "name": "@minigraf/linux-arm64-gnu", - "version": "0.0.0", - "description": "Zero-config, single-file, embedded graph database with bi-temporal Datalog queries (Linux arm64 GNU)", - "os": [ - "linux" - ], - "cpu": [ - "arm64" - ], - "libc": [ - "glibc" - ], - "main": "minigraf.linux-arm64-gnu.node", - "files": [ - "minigraf.linux-arm64-gnu.node" - ], - "license": "MIT OR Apache-2.0", - "engines": { - "node": ">=18" - } -} diff --git a/minigraf-node/packages/@minigraf/linux-x64-gnu/package.json b/minigraf-node/packages/@minigraf/linux-x64-gnu/package.json deleted file mode 100644 index 177a5b0fbc..0000000000 --- a/minigraf-node/packages/@minigraf/linux-x64-gnu/package.json +++ /dev/null @@ -1,22 +0,0 @@ -{ - "name": "@minigraf/linux-x64-gnu", - "version": "0.0.0", - "description": "Zero-config, single-file, embedded graph database with bi-temporal Datalog queries (Linux x64 GNU)", - "os": [ - "linux" - ], - "cpu": [ - "x64" - ], - "libc": [ - "glibc" - ], - "main": "minigraf.linux-x64-gnu.node", - "files": [ - "minigraf.linux-x64-gnu.node" - ], - "license": "MIT OR Apache-2.0", - "engines": { - "node": ">=18" - } -} diff --git a/minigraf-node/packages/@minigraf/win32-x64-msvc/package.json b/minigraf-node/packages/@minigraf/win32-x64-msvc/package.json deleted file mode 100644 index 38883da073..0000000000 --- a/minigraf-node/packages/@minigraf/win32-x64-msvc/package.json +++ /dev/null @@ -1,19 +0,0 @@ -{ - "name": "@minigraf/win32-x64-msvc", - "version": "0.0.0", - "description": "Zero-config, single-file, embedded graph database with bi-temporal Datalog queries (Windows x64 MSVC)", - "os": [ - "win32" - ], - "cpu": [ - "x64" - ], - "main": "minigraf.win32-x64-msvc.node", - "files": [ - "minigraf.win32-x64-msvc.node" - ], - "license": "MIT OR Apache-2.0", - "engines": { - "node": ">=18" - } -} diff --git a/minigraf-node/src/lib.rs b/minigraf-node/src/lib.rs deleted file mode 100644 index 7c87ff2fd3..0000000000 --- a/minigraf-node/src/lib.rs +++ /dev/null @@ -1,93 +0,0 @@ -use minigraf::{QueryResult, Value}; -use napi::bindgen_prelude::*; -use napi_derive::napi; -use std::sync::{Arc, Mutex}; - -// ─── Value → JSON ───────────────────────────────────────────────────────────── - -fn value_to_json(v: &Value) -> serde_json::Value { - use serde_json::Value as J; - match v { - Value::String(s) => J::String(s.clone()), - Value::Integer(i) => serde_json::json!(i), - Value::Float(f) => serde_json::Number::from_f64(*f) - .map(J::Number) - .unwrap_or(J::Null), - Value::Boolean(b) => J::Bool(*b), - Value::Ref(u) => J::String(u.to_string()), - Value::Keyword(k) => J::String(k.clone()), - Value::Null => J::Null, - } -} - -fn query_result_to_json(result: QueryResult) -> String { - let val = match result { - QueryResult::Transacted(tx_id) => { - serde_json::json!({"transacted": tx_id}) - } - QueryResult::Retracted(tx_id) => { - serde_json::json!({"retracted": tx_id}) - } - QueryResult::Ok => serde_json::json!({"ok": true}), - QueryResult::QueryResults { vars, results } => { - let rows: Vec> = results - .iter() - .map(|r| r.iter().map(value_to_json).collect()) - .collect(); - serde_json::json!({"variables": vars, "results": rows}) - } - }; - val.to_string() -} - -// ─── MiniGrafDb ─────────────────────────────────────────────────────────────── - -#[napi] -pub struct MiniGrafDb { - inner: Arc>, -} - -#[napi] -impl MiniGrafDb { - /// Open a file-backed database. Throws on error. - #[napi(constructor)] - pub fn new(path: String) -> Result { - let db = minigraf::Minigraf::open(&path) - .map_err(|e| Error::new(Status::GenericFailure, e.to_string()))?; - Ok(Self { - inner: Arc::new(Mutex::new(db)), - }) - } - - /// Open an in-memory database. Throws on error. - #[napi(factory)] - pub fn in_memory() -> Result { - let db = minigraf::Minigraf::in_memory() - .map_err(|e| Error::new(Status::GenericFailure, e.to_string()))?; - Ok(Self { - inner: Arc::new(Mutex::new(db)), - }) - } - - /// Execute a Datalog string. Returns a JSON string. Throws on error. - #[napi] - pub fn execute(&self, datalog: String) -> Result { - let result = self - .inner - .lock() - .map_err(|_| Error::new(Status::GenericFailure, "mutex poisoned"))? - .execute(&datalog) - .map_err(|e| Error::new(Status::GenericFailure, e.to_string()))?; - Ok(query_result_to_json(result)) - } - - /// Flush the WAL to disk. Throws on error. - #[napi] - pub fn checkpoint(&self) -> Result<()> { - self.inner - .lock() - .map_err(|_| Error::new(Status::GenericFailure, "mutex poisoned"))? - .checkpoint() - .map_err(|e| Error::new(Status::GenericFailure, e.to_string())) - } -} diff --git a/minigraf-node/test/basic.test.mjs b/minigraf-node/test/basic.test.mjs deleted file mode 100644 index c2aaca873c..0000000000 --- a/minigraf-node/test/basic.test.mjs +++ /dev/null @@ -1,49 +0,0 @@ -import { test } from 'node:test' -import assert from 'node:assert/strict' -import { MiniGrafDb } from '../index.js' - -test('open in-memory database', () => { - const db = MiniGrafDb.inMemory() - assert.ok(db, 'expected non-null db') -}) - -test('transact and query', () => { - const db = MiniGrafDb.inMemory() - const txJson = db.execute('(transact [[:alice :name "Alice"]])') - const tx = JSON.parse(txJson) - assert.ok('transacted' in tx, 'expected transacted key') - - const queryJson = db.execute('(query [:find ?n :where [?e :name ?n]])') - const qr = JSON.parse(queryJson) - assert.equal(qr.results[0][0], 'Alice') -}) - -test('invalid datalog throws', () => { - const db = MiniGrafDb.inMemory() - assert.throws(() => db.execute('not valid datalog !!!')) -}) - -test('file-backed roundtrip', async (t) => { - const os = await import('node:os') - const path = await import('node:path') - const fs = await import('node:fs') - - const tmpDir = os.default.tmpdir() - const dbPath = path.default.join(tmpDir, `minigraf_node_test_${Date.now()}.graph`) - const walPath = dbPath + '.wal' - - t.after(() => { - try { fs.default.unlinkSync(dbPath) } catch {} - try { fs.default.unlinkSync(walPath) } catch {} - }) - - { - const db = new MiniGrafDb(dbPath) - db.execute('(transact [[:bob :name "Bob"]])') - db.checkpoint() - } - - const db2 = new MiniGrafDb(dbPath) - const qr = JSON.parse(db2.execute('(query [:find ?n :where [?e :name ?n]])')) - assert.equal(qr.results[0][0], 'Bob') -}) diff --git a/minigraf-wasi/README.md b/minigraf-wasi/README.md deleted file mode 100644 index f352efb063..0000000000 --- a/minigraf-wasi/README.md +++ /dev/null @@ -1,24 +0,0 @@ -# @minigraf/wasi - -WASI WebAssembly package for Minigraf. - -This package contains the `wasm32-wasip1` CLI binary as -`minigraf-wasi.wasm` plus a small Node.js ESM loader. It is intended for -server-side WASM runtimes such as Wasmtime, Wasmer, and Node's WASI support. - -```js -import { WASI } from "node:wasi"; -import { startMinigrafWasi } from "@minigraf/wasi"; - -const wasi = new WASI({ - version: "preview1", - args: ["minigraf"], - env: process.env, - preopens: { "/tmp": "/tmp" }, -}); - -await startMinigrafWasi(wasi); -``` - -Use `MINIGRAF_WASI_WASM_PATH` or the `wasmPath` option to point the loader at -an alternate `.wasm` file during tests or custom packaging. diff --git a/minigraf-wasi/index.d.ts b/minigraf-wasi/index.d.ts deleted file mode 100644 index 56098889bd..0000000000 --- a/minigraf-wasi/index.d.ts +++ /dev/null @@ -1,47 +0,0 @@ -export interface MinigrafWasiOptions { - wasmPath?: string; -} - -export interface WasiWithImportObject { - getImportObject(): WebAssembly.Imports; - start?(instance: WebAssembly.Instance): void; -} - -export interface WasiWithLegacyImport { - wasiImport: Record; - start?(instance: WebAssembly.Instance): void; -} - -export type MinigrafWasiRuntime = - | WasiWithImportObject - | WasiWithLegacyImport - | ({ wasi_snapshot_preview1: Record } & { - start?(instance: WebAssembly.Instance): void; - }); - -export function getMinigrafWasiPath(options?: MinigrafWasiOptions): string; - -export function readMinigrafWasi( - options?: MinigrafWasiOptions, -): Promise; - -export function compileMinigrafWasi( - options?: MinigrafWasiOptions, -): Promise; - -export function instantiateMinigrafWasi( - imports?: WebAssembly.Imports, - options?: MinigrafWasiOptions, -): Promise; - -export function instantiateMinigrafWasiWith( - wasi: MinigrafWasiRuntime, - options?: MinigrafWasiOptions, -): Promise; - -export function startMinigrafWasi( - wasi: MinigrafWasiRuntime & { - start(instance: WebAssembly.Instance): void; - }, - options?: MinigrafWasiOptions, -): Promise; diff --git a/minigraf-wasi/index.js b/minigraf-wasi/index.js deleted file mode 100644 index c98a00d798..0000000000 --- a/minigraf-wasi/index.js +++ /dev/null @@ -1,66 +0,0 @@ -import { readFile } from "node:fs/promises"; -import { fileURLToPath } from "node:url"; - -const DEFAULT_WASM_URL = new URL("./minigraf-wasi.wasm", import.meta.url); - -export function getMinigrafWasiPath(options = {}) { - return ( - options.wasmPath ?? - process.env.MINIGRAF_WASI_WASM_PATH ?? - fileURLToPath(DEFAULT_WASM_URL) - ); -} - -export async function readMinigrafWasi(options = {}) { - const buffer = await readFile(getMinigrafWasiPath(options)); - return buffer.buffer.slice( - buffer.byteOffset, - buffer.byteOffset + buffer.byteLength, - ); -} - -export async function compileMinigrafWasi(options = {}) { - return WebAssembly.compile(await readMinigrafWasi(options)); -} - -export async function instantiateMinigrafWasi(imports = {}, options = {}) { - const module = await compileMinigrafWasi(options); - return WebAssembly.instantiate(module, imports); -} - -export async function instantiateMinigrafWasiWith(wasi, options = {}) { - return instantiateMinigrafWasi(importObjectFromWasi(wasi), options); -} - -export async function startMinigrafWasi(wasi, options = {}) { - const instance = await instantiateMinigrafWasiWith(wasi, options); - - if (typeof wasi.start !== "function") { - throw new TypeError("WASI object must expose start(instance)"); - } - - wasi.start(instance); - return instance; -} - -function importObjectFromWasi(wasi) { - if (!wasi || typeof wasi !== "object") { - throw new TypeError("WASI object is required"); - } - - if (typeof wasi.getImportObject === "function") { - return wasi.getImportObject(); - } - - if (wasi.wasiImport) { - return { wasi_snapshot_preview1: wasi.wasiImport }; - } - - if (wasi.wasi_snapshot_preview1) { - return wasi; - } - - throw new TypeError( - "WASI object must expose getImportObject(), wasiImport, or wasi_snapshot_preview1", - ); -} diff --git a/minigraf-wasi/package.json b/minigraf-wasi/package.json deleted file mode 100644 index 238d5ab2cc..0000000000 --- a/minigraf-wasi/package.json +++ /dev/null @@ -1,34 +0,0 @@ -{ - "name": "@minigraf/wasi", - "type": "module", - "collaborators": [ - "Aditya Mukhopadhyay" - ], - "description": "WASI WebAssembly build of Minigraf, a bi-temporal Datalog graph database", - "version": "0.0.0", - "license": "MIT OR Apache-2.0", - "repository": { - "type": "git", - "url": "https://github.com/project-minigraf/minigraf" - }, - "files": [ - "index.js", - "index.d.ts", - "minigraf-wasi.wasm", - "README.md" - ], - "main": "index.js", - "types": "index.d.ts", - "scripts": { - "test": "node --test package.test.js" - }, - "keywords": [ - "graph", - "datalog", - "bitemporal", - "embedded", - "database", - "wasi", - "webassembly" - ] -} diff --git a/minigraf-wasi/package.test.js b/minigraf-wasi/package.test.js deleted file mode 100644 index 0dc8799b95..0000000000 --- a/minigraf-wasi/package.test.js +++ /dev/null @@ -1,67 +0,0 @@ -import { mkdir, writeFile } from "node:fs/promises"; -import { tmpdir } from "node:os"; -import { join } from "node:path"; -import test from "node:test"; -import assert from "node:assert/strict"; - -import { - compileMinigrafWasi, - getMinigrafWasiPath, - instantiateMinigrafWasi, - instantiateMinigrafWasiWith, - readMinigrafWasi, -} from "./index.js"; -import pkg from "./package.json" with { type: "json" }; - -const EMPTY_WASM_MODULE = Uint8Array.from([ - 0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, -]); - -async function writeFixtureWasm() { - const dir = join(tmpdir(), `minigraf-wasi-${process.pid}`); - await mkdir(dir, { recursive: true }); - const path = join(dir, "fixture.wasm"); - await writeFile(path, EMPTY_WASM_MODULE); - return path; -} - -test("package metadata describes the public WASI npm package", () => { - assert.equal(pkg.name, "@minigraf/wasi"); - assert.equal(pkg.type, "module"); - assert.equal(pkg.main, "index.js"); - assert.equal(pkg.types, "index.d.ts"); - assert.ok(pkg.files.includes("minigraf-wasi.wasm")); -}); - -test("loader reads and compiles the configured WASI wasm path", async () => { - const path = await writeFixtureWasm(); - - assert.equal(getMinigrafWasiPath({ wasmPath: path }), path); - - const bytes = await readMinigrafWasi({ wasmPath: path }); - assert.deepEqual(new Uint8Array(bytes), EMPTY_WASM_MODULE); - - const module = await compileMinigrafWasi({ wasmPath: path }); - assert.ok(module instanceof WebAssembly.Module); -}); - -test("loader instantiates the configured WASI wasm module", async () => { - const path = await writeFixtureWasm(); - - const instance = await instantiateMinigrafWasi({}, { wasmPath: path }); - - assert.ok(instance instanceof WebAssembly.Instance); -}); - -test("loader accepts a WASI object exposing getImportObject", async () => { - const path = await writeFixtureWasm(); - const wasi = { - getImportObject() { - return {}; - }, - }; - - const instance = await instantiateMinigrafWasiWith(wasi, { wasmPath: path }); - - assert.ok(instance instanceof WebAssembly.Instance); -}); diff --git a/minigraf-wasm/LICENSE-APACHE b/minigraf-wasm/LICENSE-APACHE deleted file mode 100644 index d645695673..0000000000 --- a/minigraf-wasm/LICENSE-APACHE +++ /dev/null @@ -1,202 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. diff --git a/minigraf-wasm/LICENSE-MIT b/minigraf-wasm/LICENSE-MIT deleted file mode 100644 index 24d751420e..0000000000 --- a/minigraf-wasm/LICENSE-MIT +++ /dev/null @@ -1,21 +0,0 @@ -MIT License - -Copyright (c) 2023-2026 Aditya Mukhopadhyay - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. \ No newline at end of file diff --git a/minigraf-wasm/README.md b/minigraf-wasm/README.md deleted file mode 100644 index 758f9b747f..0000000000 --- a/minigraf-wasm/README.md +++ /dev/null @@ -1,87 +0,0 @@ -# @minigraf/browser - -[![npm](https://img.shields.io/npm/v/@minigraf/browser.svg)](https://www.npmjs.com/package/@minigraf/browser) -[![License: MIT OR Apache-2.0](https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-blue.svg)](https://github.com/project-minigraf/minigraf#license) - -> Embedded bi-temporal graph database for the browser — Datalog queries, time travel, IndexedDB persistence - -Minigraf in the browser: zero configuration, persistent graph storage backed by IndexedDB, Datalog queries with recursive rules and time travel. One API, no server required. - -## Install - -```sh -npm install @minigraf/browser -``` - -## Quick start - -```javascript -import init, { BrowserDb } from '@minigraf/browser'; -await init(); - -// Persistent database (survives page reloads — backed by IndexedDB) -const db = await BrowserDb.open('my-graph'); - -// In-memory database (ephemeral / testing) -const mem = BrowserDb.openInMemory(); - -// Transact facts -const r = JSON.parse(await db.execute( - '(transact [[:alice :person/name "Alice"] [:alice :person/age 30]])' -)); -// { "transacted": 1 } - -// Query with Datalog -const q = JSON.parse(await db.execute( - '(query [:find ?name ?age :where [?e :person/name ?name] [?e :person/age ?age]])' -)); -// { "variables": ["?name", "?age"], "results": [["Alice", 30]] } - -// Time travel — state as of transaction 1 -const snap = JSON.parse(await db.execute( - '(query [:find ?age :as-of 1 :where [:alice :person/age ?age]])' -)); -``` - -## Response shapes - -| Command | JSON | -|---|---| -| `transact` | `{"transacted": }` | -| `retract` | `{"retracted": }` | -| `query` | `{"variables": [...], "results": [[...]]}` | -| `rule` | `{"ok": true}` | - -## Export / import - -The `.graph` binary format is byte-identical between browser and native builds. Export a snapshot or load a native-generated file: - -```javascript -// Export (Uint8Array — byte-identical to a native .graph file) -const bytes = db.exportGraph(); - -// Import a native .graph file (must be checkpointed — no pending WAL) -const file = document.querySelector('input[type=file]').files[0]; -await db.importGraph(new Uint8Array(await file.arrayBuffer())); -``` - -## Constraints - -- Requires a browser environment with IndexedDB. Not compatible with Node.js — use the [`minigraf` npm package](https://www.npmjs.com/package/minigraf) for Node.js instead. -- Single-threaded. Runs on the main thread or in a Web Worker; no shared state across workers. - -## wasm-pack clobbering note (for maintainers) - -`wasm-pack build` may overwrite this file. If it does, `wasm-release.yml` must copy the canonical -README from a stable source (e.g. a root-level `minigraf-wasm.README.md`) into the build output -directory before `npm publish`. Verify this on first release after any `wasm-pack` version upgrade. - -## Links - -- [Full browser integration guide](https://github.com/project-minigraf/minigraf/wiki/Use-Cases#wasm--browser) -- [Repository](https://github.com/project-minigraf/minigraf) -- [Datalog Reference](https://github.com/project-minigraf/minigraf/wiki/Datalog-Reference) - -## License - -MIT OR Apache-2.0 diff --git a/minigraf-wasm/minigraf.d.ts b/minigraf-wasm/minigraf.d.ts deleted file mode 100644 index d177ae43cf..0000000000 --- a/minigraf-wasm/minigraf.d.ts +++ /dev/null @@ -1,107 +0,0 @@ -/* tslint:disable */ -/* eslint-disable */ - -/** - * Browser-only Minigraf database handle backed by IndexedDB. - * - * All public methods return `Promise`s. Use `await` in JavaScript. - * - * **Not compatible with Node.js.** Use `@minigraf/node` for server-side use. - */ -export class BrowserDb { - private constructor(); - free(): void; - [Symbol.dispose](): void; - /** - * Flush all dirty pages to IndexedDB. - * - * Write-through means individual `execute()` calls already flush dirty pages, - * so `checkpoint()` is only needed after `import_graph()` or explicit bulk ops. - * No-op for in-memory databases. - */ - checkpoint(): Promise; - /** - * Execute a Datalog command string and return a JSON-encoded result. - * - * Returns a `Promise` in JavaScript. The JSON shape is: - * - Query: `{"variables": [...], "results": [[...], ...]}` - * - Transact: `{"transacted": }` - * - Retract: `{"retracted": }` - * - Rule: `{"ok": true}` - */ - execute(datalog: string): Promise; - /** - * Serialise the current database to a portable `.graph` blob. - * - * The blob is byte-for-bit compatible with native `.graph` files opened by - * `Minigraf::open()`. Pages are always in ascending `page_id` order. - * - * Call `checkpoint()` on native before importing a file here to ensure - * no WAL entries are missing from the main file. - */ - exportGraph(): Uint8Array; - /** - * Replace the current database with a `.graph` blob. - * - * The blob must be a checkpointed native `.graph` file (no pending WAL sidecar). - * All existing data is overwritten. After import, the new data is immediately - * queryable and all dirty pages are flushed to IndexedDB. - */ - importGraph(data: Uint8Array): Promise; - /** - * Open or create a database backed by IndexedDB. - * - * `db_name` is used as both the IndexedDB database name and object store name. - * Called as `await BrowserDb.open("mydb")` — NOT `new BrowserDb()`. - */ - static open(db_name: string): Promise; - /** - * Open an in-memory database (no IndexedDB — for testing only). - * - * Data is lost when the page is closed. Use `BrowserDb.open()` for persistence. - */ - static openInMemory(): BrowserDb; -} - -export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module; - -export interface InitOutput { - readonly memory: WebAssembly.Memory; - readonly __wbg_browserdb_free: (a: number, b: number) => void; - readonly browserdb_checkpoint: (a: number) => number; - readonly browserdb_execute: (a: number, b: number, c: number) => number; - readonly browserdb_exportGraph: (a: number, b: number) => void; - readonly browserdb_importGraph: (a: number, b: number) => number; - readonly browserdb_open: (a: number, b: number) => number; - readonly browserdb_openInMemory: (a: number) => void; - readonly __wasm_bindgen_func_elem_2769: (a: number, b: number, c: number, d: number) => void; - readonly __wasm_bindgen_func_elem_2781: (a: number, b: number, c: number, d: number) => void; - readonly __wasm_bindgen_func_elem_658: (a: number, b: number, c: number) => void; - readonly __wbindgen_export: (a: number, b: number) => number; - readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number; - readonly __wbindgen_export3: (a: number) => void; - readonly __wbindgen_export4: (a: number, b: number) => void; - readonly __wbindgen_add_to_stack_pointer: (a: number) => number; -} - -export type SyncInitInput = BufferSource | WebAssembly.Module; - -/** - * Instantiates the given `module`, which can either be bytes or - * a precompiled `WebAssembly.Module`. - * - * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated. - * - * @returns {InitOutput} - */ -export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput; - -/** - * If `module_or_path` is {RequestInfo} or {URL}, makes a request and - * for everything else, calls `WebAssembly.instantiate` directly. - * - * @param {{ module_or_path: InitInput | Promise }} module_or_path - Passing `InitInput` directly is deprecated. - * - * @returns {Promise} - */ -export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise } | InitInput | Promise): Promise; diff --git a/minigraf-wasm/minigraf.js b/minigraf-wasm/minigraf.js deleted file mode 100644 index 9b532badf8..0000000000 --- a/minigraf-wasm/minigraf.js +++ /dev/null @@ -1,757 +0,0 @@ -/* @ts-self-types="./minigraf.d.ts" */ - -/** - * Browser-only Minigraf database handle backed by IndexedDB. - * - * All public methods return `Promise`s. Use `await` in JavaScript. - * - * **Not compatible with Node.js.** Use `@minigraf/node` for server-side use. - */ -export class BrowserDb { - static __wrap(ptr) { - ptr = ptr >>> 0; - const obj = Object.create(BrowserDb.prototype); - obj.__wbg_ptr = ptr; - BrowserDbFinalization.register(obj, obj.__wbg_ptr, obj); - return obj; - } - __destroy_into_raw() { - const ptr = this.__wbg_ptr; - this.__wbg_ptr = 0; - BrowserDbFinalization.unregister(this); - return ptr; - } - free() { - const ptr = this.__destroy_into_raw(); - wasm.__wbg_browserdb_free(ptr, 0); - } - /** - * Flush all dirty pages to IndexedDB. - * - * Write-through means individual `execute()` calls already flush dirty pages, - * so `checkpoint()` is only needed after `import_graph()` or explicit bulk ops. - * No-op for in-memory databases. - * @returns {Promise} - */ - checkpoint() { - const ret = wasm.browserdb_checkpoint(this.__wbg_ptr); - return takeObject(ret); - } - /** - * Execute a Datalog command string and return a JSON-encoded result. - * - * Returns a `Promise` in JavaScript. The JSON shape is: - * - Query: `{"variables": [...], "results": [[...], ...]}` - * - Transact: `{"transacted": }` - * - Retract: `{"retracted": }` - * - Rule: `{"ok": true}` - * @param {string} datalog - * @returns {Promise} - */ - execute(datalog) { - const ptr0 = passStringToWasm0(datalog, wasm.__wbindgen_export, wasm.__wbindgen_export2); - const len0 = WASM_VECTOR_LEN; - const ret = wasm.browserdb_execute(this.__wbg_ptr, ptr0, len0); - return takeObject(ret); - } - /** - * Serialise the current database to a portable `.graph` blob. - * - * The blob is byte-for-bit compatible with native `.graph` files opened by - * `Minigraf::open()`. Pages are always in ascending `page_id` order. - * - * Call `checkpoint()` on native before importing a file here to ensure - * no WAL entries are missing from the main file. - * @returns {Uint8Array} - */ - exportGraph() { - try { - const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); - wasm.browserdb_exportGraph(retptr, this.__wbg_ptr); - var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true); - var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true); - var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true); - if (r2) { - throw takeObject(r1); - } - return takeObject(r0); - } finally { - wasm.__wbindgen_add_to_stack_pointer(16); - } - } - /** - * Replace the current database with a `.graph` blob. - * - * The blob must be a checkpointed native `.graph` file (no pending WAL sidecar). - * All existing data is overwritten. After import, the new data is immediately - * queryable and all dirty pages are flushed to IndexedDB. - * @param {Uint8Array} data - * @returns {Promise} - */ - importGraph(data) { - const ret = wasm.browserdb_importGraph(this.__wbg_ptr, addHeapObject(data)); - return takeObject(ret); - } - /** - * Open or create a database backed by IndexedDB. - * - * `db_name` is used as both the IndexedDB database name and object store name. - * Called as `await BrowserDb.open("mydb")` — NOT `new BrowserDb()`. - * @param {string} db_name - * @returns {Promise} - */ - static open(db_name) { - const ptr0 = passStringToWasm0(db_name, wasm.__wbindgen_export, wasm.__wbindgen_export2); - const len0 = WASM_VECTOR_LEN; - const ret = wasm.browserdb_open(ptr0, len0); - return takeObject(ret); - } - /** - * Open an in-memory database (no IndexedDB — for testing only). - * - * Data is lost when the page is closed. Use `BrowserDb.open()` for persistence. - * @returns {BrowserDb} - */ - static openInMemory() { - try { - const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); - wasm.browserdb_openInMemory(retptr); - var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true); - var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true); - var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true); - if (r2) { - throw takeObject(r1); - } - return BrowserDb.__wrap(r0); - } finally { - wasm.__wbindgen_add_to_stack_pointer(16); - } - } -} -if (Symbol.dispose) BrowserDb.prototype[Symbol.dispose] = BrowserDb.prototype.free; - -function __wbg_get_imports() { - const import0 = { - __proto__: null, - __wbg___wbindgen_debug_string_dd5d2d07ce9e6c57: function(arg0, arg1) { - const ret = debugString(getObject(arg1)); - const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2); - const len1 = WASM_VECTOR_LEN; - getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true); - getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true); - }, - __wbg___wbindgen_is_function_49868bde5eb1e745: function(arg0) { - const ret = typeof(getObject(arg0)) === 'function'; - return ret; - }, - __wbg___wbindgen_is_undefined_c0cca72b82b86f4d: function(arg0) { - const ret = getObject(arg0) === undefined; - return ret; - }, - __wbg___wbindgen_number_get_7579aab02a8a620c: function(arg0, arg1) { - const obj = getObject(arg1); - const ret = typeof(obj) === 'number' ? obj : undefined; - getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true); - getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true); - }, - __wbg___wbindgen_throw_81fc77679af83bc6: function(arg0, arg1) { - throw new Error(getStringFromWasm0(arg0, arg1)); - }, - __wbg__wbg_cb_unref_3c3b4f651835fbcb: function(arg0) { - getObject(arg0)._wbg_cb_unref(); - }, - __wbg_browserdb_new: function(arg0) { - const ret = BrowserDb.__wrap(arg0); - return addHeapObject(ret); - }, - __wbg_call_7f2987183bb62793: function() { return handleError(function (arg0, arg1) { - const ret = getObject(arg0).call(getObject(arg1)); - return addHeapObject(ret); - }, arguments); }, - __wbg_call_d578befcc3145dee: function() { return handleError(function (arg0, arg1, arg2) { - const ret = getObject(arg0).call(getObject(arg1), getObject(arg2)); - return addHeapObject(ret); - }, arguments); }, - __wbg_contains_04f0b15b3b6b3f6f: function(arg0, arg1, arg2) { - const ret = getObject(arg0).contains(getStringFromWasm0(arg1, arg2)); - return ret; - }, - __wbg_createObjectStore_11c03f9eac3c3672: function() { return handleError(function (arg0, arg1, arg2) { - const ret = getObject(arg0).createObjectStore(getStringFromWasm0(arg1, arg2)); - return addHeapObject(ret); - }, arguments); }, - __wbg_getAllKeys_122dfa5978e6ca9a: function() { return handleError(function (arg0) { - const ret = getObject(arg0).getAllKeys(); - return addHeapObject(ret); - }, arguments); }, - __wbg_getAll_19e833a015c08d39: function() { return handleError(function (arg0) { - const ret = getObject(arg0).getAll(); - return addHeapObject(ret); - }, arguments); }, - __wbg_get_4848e350b40afc16: function(arg0, arg1) { - const ret = getObject(arg0)[arg1 >>> 0]; - return addHeapObject(ret); - }, - __wbg_indexedDB_af74cb6df65fa636: function() { return handleError(function (arg0) { - const ret = getObject(arg0).indexedDB; - return isLikeNone(ret) ? 0 : addHeapObject(ret); - }, arguments); }, - __wbg_instanceof_IdbDatabase_0af111edb4be95f4: function(arg0) { - let result; - try { - result = getObject(arg0) instanceof IDBDatabase; - } catch (_) { - result = false; - } - const ret = result; - return ret; - }, - __wbg_instanceof_IdbOpenDbRequest_92df356941adf31e: function(arg0) { - let result; - try { - result = getObject(arg0) instanceof IDBOpenDBRequest; - } catch (_) { - result = false; - } - const ret = result; - return ret; - }, - __wbg_instanceof_Uint8Array_4b8da683deb25d72: function(arg0) { - let result; - try { - result = getObject(arg0) instanceof Uint8Array; - } catch (_) { - result = false; - } - const ret = result; - return ret; - }, - __wbg_instanceof_Window_c0fee4c064502536: function(arg0) { - let result; - try { - result = getObject(arg0) instanceof Window; - } catch (_) { - result = false; - } - const ret = result; - return ret; - }, - __wbg_isArray_db61795ad004c139: function(arg0) { - const ret = Array.isArray(getObject(arg0)); - return ret; - }, - __wbg_length_0c32cb8543c8e4c8: function(arg0) { - const ret = getObject(arg0).length; - return ret; - }, - __wbg_length_6e821edde497a532: function(arg0) { - const ret = getObject(arg0).length; - return ret; - }, - __wbg_new_40792555590ec35c: function(arg0, arg1) { - try { - var state0 = {a: arg0, b: arg1}; - var cb0 = (arg0, arg1) => { - const a = state0.a; - state0.a = 0; - try { - return __wasm_bindgen_func_elem_2781(a, state0.b, arg0, arg1); - } finally { - state0.a = a; - } - }; - const ret = new Promise(cb0); - return addHeapObject(ret); - } finally { - state0.a = 0; - } - }, - __wbg_new_from_slice_2580ff33d0d10520: function(arg0, arg1) { - const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1)); - return addHeapObject(ret); - }, - __wbg_new_typed_14d7cc391ce53d2c: function(arg0, arg1) { - try { - var state0 = {a: arg0, b: arg1}; - var cb0 = (arg0, arg1) => { - const a = state0.a; - state0.a = 0; - try { - return __wasm_bindgen_func_elem_2781(a, state0.b, arg0, arg1); - } finally { - state0.a = a; - } - }; - const ret = new Promise(cb0); - return addHeapObject(ret); - } finally { - state0.a = 0; - } - }, - __wbg_now_88621c9c9a4f3ffc: function() { - const ret = Date.now(); - return ret; - }, - __wbg_objectStoreNames_990d8e55c661828b: function(arg0) { - const ret = getObject(arg0).objectStoreNames; - return addHeapObject(ret); - }, - __wbg_objectStore_3d4cade4416cd432: function() { return handleError(function (arg0, arg1, arg2) { - const ret = getObject(arg0).objectStore(getStringFromWasm0(arg1, arg2)); - return addHeapObject(ret); - }, arguments); }, - __wbg_open_ac04ec9d75d0eeaf: function() { return handleError(function (arg0, arg1, arg2, arg3) { - const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2), arg3 >>> 0); - return addHeapObject(ret); - }, arguments); }, - __wbg_prototypesetcall_3e05eb9545565046: function(arg0, arg1, arg2) { - Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2)); - }, - __wbg_put_4485a4012273f7ef: function() { return handleError(function (arg0, arg1, arg2) { - const ret = getObject(arg0).put(getObject(arg1), getObject(arg2)); - return addHeapObject(ret); - }, arguments); }, - __wbg_queueMicrotask_abaf92f0bd4e80a4: function(arg0) { - const ret = getObject(arg0).queueMicrotask; - return addHeapObject(ret); - }, - __wbg_queueMicrotask_df5a6dac26d818f3: function(arg0) { - queueMicrotask(getObject(arg0)); - }, - __wbg_resolve_0a79de24e9d2267b: function(arg0) { - const ret = Promise.resolve(getObject(arg0)); - return addHeapObject(ret); - }, - __wbg_result_452c1006fc727317: function() { return handleError(function (arg0) { - const ret = getObject(arg0).result; - return addHeapObject(ret); - }, arguments); }, - __wbg_set_oncomplete_20fb27150b4ee0d4: function(arg0, arg1) { - getObject(arg0).oncomplete = getObject(arg1); - }, - __wbg_set_onerror_2b7dfa4e6dea4159: function(arg0, arg1) { - getObject(arg0).onerror = getObject(arg1); - }, - __wbg_set_onerror_3c4b5087146b11b6: function(arg0, arg1) { - getObject(arg0).onerror = getObject(arg1); - }, - __wbg_set_onsuccess_f7e5b5cbed5008b1: function(arg0, arg1) { - getObject(arg0).onsuccess = getObject(arg1); - }, - __wbg_set_onupgradeneeded_d7e8e03a1999bf5d: function(arg0, arg1) { - getObject(arg0).onupgradeneeded = getObject(arg1); - }, - __wbg_static_accessor_GLOBAL_THIS_a1248013d790bf5f: function() { - const ret = typeof globalThis === 'undefined' ? null : globalThis; - return isLikeNone(ret) ? 0 : addHeapObject(ret); - }, - __wbg_static_accessor_GLOBAL_f2e0f995a21329ff: function() { - const ret = typeof global === 'undefined' ? null : global; - return isLikeNone(ret) ? 0 : addHeapObject(ret); - }, - __wbg_static_accessor_SELF_24f78b6d23f286ea: function() { - const ret = typeof self === 'undefined' ? null : self; - return isLikeNone(ret) ? 0 : addHeapObject(ret); - }, - __wbg_static_accessor_WINDOW_59fd959c540fe405: function() { - const ret = typeof window === 'undefined' ? null : window; - return isLikeNone(ret) ? 0 : addHeapObject(ret); - }, - __wbg_target_732d56b173b7e87c: function(arg0) { - const ret = getObject(arg0).target; - return isLikeNone(ret) ? 0 : addHeapObject(ret); - }, - __wbg_then_00eed3ac0b8e82cb: function(arg0, arg1, arg2) { - const ret = getObject(arg0).then(getObject(arg1), getObject(arg2)); - return addHeapObject(ret); - }, - __wbg_then_a0c8db0381c8994c: function(arg0, arg1) { - const ret = getObject(arg0).then(getObject(arg1)); - return addHeapObject(ret); - }, - __wbg_transaction_f909284bfed41115: function() { return handleError(function (arg0, arg1, arg2, arg3) { - const ret = getObject(arg0).transaction(getStringFromWasm0(arg1, arg2), __wbindgen_enum_IdbTransactionMode[arg3]); - return addHeapObject(ret); - }, arguments); }, - __wbindgen_cast_0000000000000001: function(arg0, arg1) { - // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 237, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`. - const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2769); - return addHeapObject(ret); - }, - __wbindgen_cast_0000000000000002: function(arg0, arg1) { - // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Event")], shim_idx: 6, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`. - const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_658); - return addHeapObject(ret); - }, - __wbindgen_cast_0000000000000003: function(arg0) { - // Cast intrinsic for `F64 -> Externref`. - const ret = arg0; - return addHeapObject(ret); - }, - __wbindgen_cast_0000000000000004: function(arg0, arg1) { - // Cast intrinsic for `Ref(String) -> Externref`. - const ret = getStringFromWasm0(arg0, arg1); - return addHeapObject(ret); - }, - __wbindgen_object_clone_ref: function(arg0) { - const ret = getObject(arg0); - return addHeapObject(ret); - }, - __wbindgen_object_drop_ref: function(arg0) { - takeObject(arg0); - }, - }; - return { - __proto__: null, - "./minigraf_bg.js": import0, - }; -} - -function __wasm_bindgen_func_elem_658(arg0, arg1, arg2) { - wasm.__wasm_bindgen_func_elem_658(arg0, arg1, addHeapObject(arg2)); -} - -function __wasm_bindgen_func_elem_2769(arg0, arg1, arg2) { - try { - const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); - wasm.__wasm_bindgen_func_elem_2769(retptr, arg0, arg1, addHeapObject(arg2)); - var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true); - var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true); - if (r1) { - throw takeObject(r0); - } - } finally { - wasm.__wbindgen_add_to_stack_pointer(16); - } -} - -function __wasm_bindgen_func_elem_2781(arg0, arg1, arg2, arg3) { - wasm.__wasm_bindgen_func_elem_2781(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3)); -} - - -const __wbindgen_enum_IdbTransactionMode = ["readonly", "readwrite", "versionchange", "readwriteflush", "cleanup"]; -const BrowserDbFinalization = (typeof FinalizationRegistry === 'undefined') - ? { register: () => {}, unregister: () => {} } - : new FinalizationRegistry(ptr => wasm.__wbg_browserdb_free(ptr >>> 0, 1)); - -function addHeapObject(obj) { - if (heap_next === heap.length) heap.push(heap.length + 1); - const idx = heap_next; - heap_next = heap[idx]; - - heap[idx] = obj; - return idx; -} - -const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined') - ? { register: () => {}, unregister: () => {} } - : new FinalizationRegistry(state => wasm.__wbindgen_export4(state.a, state.b)); - -function debugString(val) { - // primitive types - const type = typeof val; - if (type == 'number' || type == 'boolean' || val == null) { - return `${val}`; - } - if (type == 'string') { - return `"${val}"`; - } - if (type == 'symbol') { - const description = val.description; - if (description == null) { - return 'Symbol'; - } else { - return `Symbol(${description})`; - } - } - if (type == 'function') { - const name = val.name; - if (typeof name == 'string' && name.length > 0) { - return `Function(${name})`; - } else { - return 'Function'; - } - } - // objects - if (Array.isArray(val)) { - const length = val.length; - let debug = '['; - if (length > 0) { - debug += debugString(val[0]); - } - for(let i = 1; i < length; i++) { - debug += ', ' + debugString(val[i]); - } - debug += ']'; - return debug; - } - // Test for built-in - const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val)); - let className; - if (builtInMatches && builtInMatches.length > 1) { - className = builtInMatches[1]; - } else { - // Failed to match the standard '[object ClassName]' - return toString.call(val); - } - if (className == 'Object') { - // we're a user defined class or Object - // JSON.stringify avoids problems with cycles, and is generally much - // easier than looping through ownProperties of `val`. - try { - return 'Object(' + JSON.stringify(val) + ')'; - } catch (_) { - return 'Object'; - } - } - // errors - if (val instanceof Error) { - return `${val.name}: ${val.message}\n${val.stack}`; - } - // TODO we could test for more things here, like `Set`s and `Map`s. - return className; -} - -function dropObject(idx) { - if (idx < 1028) return; - heap[idx] = heap_next; - heap_next = idx; -} - -function getArrayU8FromWasm0(ptr, len) { - ptr = ptr >>> 0; - return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len); -} - -let cachedDataViewMemory0 = null; -function getDataViewMemory0() { - if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) { - cachedDataViewMemory0 = new DataView(wasm.memory.buffer); - } - return cachedDataViewMemory0; -} - -function getStringFromWasm0(ptr, len) { - ptr = ptr >>> 0; - return decodeText(ptr, len); -} - -let cachedUint8ArrayMemory0 = null; -function getUint8ArrayMemory0() { - if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) { - cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer); - } - return cachedUint8ArrayMemory0; -} - -function getObject(idx) { return heap[idx]; } - -function handleError(f, args) { - try { - return f.apply(this, args); - } catch (e) { - wasm.__wbindgen_export3(addHeapObject(e)); - } -} - -let heap = new Array(1024).fill(undefined); -heap.push(undefined, null, true, false); - -let heap_next = heap.length; - -function isLikeNone(x) { - return x === undefined || x === null; -} - -function makeMutClosure(arg0, arg1, f) { - const state = { a: arg0, b: arg1, cnt: 1 }; - const real = (...args) => { - - // First up with a closure we increment the internal reference - // count. This ensures that the Rust closure environment won't - // be deallocated while we're invoking it. - state.cnt++; - const a = state.a; - state.a = 0; - try { - return f(a, state.b, ...args); - } finally { - state.a = a; - real._wbg_cb_unref(); - } - }; - real._wbg_cb_unref = () => { - if (--state.cnt === 0) { - wasm.__wbindgen_export4(state.a, state.b); - state.a = 0; - CLOSURE_DTORS.unregister(state); - } - }; - CLOSURE_DTORS.register(real, state, state); - return real; -} - -function passStringToWasm0(arg, malloc, realloc) { - if (realloc === undefined) { - const buf = cachedTextEncoder.encode(arg); - const ptr = malloc(buf.length, 1) >>> 0; - getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf); - WASM_VECTOR_LEN = buf.length; - return ptr; - } - - let len = arg.length; - let ptr = malloc(len, 1) >>> 0; - - const mem = getUint8ArrayMemory0(); - - let offset = 0; - - for (; offset < len; offset++) { - const code = arg.charCodeAt(offset); - if (code > 0x7F) break; - mem[ptr + offset] = code; - } - if (offset !== len) { - if (offset !== 0) { - arg = arg.slice(offset); - } - ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0; - const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len); - const ret = cachedTextEncoder.encodeInto(arg, view); - - offset += ret.written; - ptr = realloc(ptr, len, offset, 1) >>> 0; - } - - WASM_VECTOR_LEN = offset; - return ptr; -} - -function takeObject(idx) { - const ret = getObject(idx); - dropObject(idx); - return ret; -} - -let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }); -cachedTextDecoder.decode(); -const MAX_SAFARI_DECODE_BYTES = 2146435072; -let numBytesDecoded = 0; -function decodeText(ptr, len) { - numBytesDecoded += len; - if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) { - cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }); - cachedTextDecoder.decode(); - numBytesDecoded = len; - } - return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len)); -} - -const cachedTextEncoder = new TextEncoder(); - -if (!('encodeInto' in cachedTextEncoder)) { - cachedTextEncoder.encodeInto = function (arg, view) { - const buf = cachedTextEncoder.encode(arg); - view.set(buf); - return { - read: arg.length, - written: buf.length - }; - }; -} - -let WASM_VECTOR_LEN = 0; - -let wasmModule, wasm; -function __wbg_finalize_init(instance, module) { - wasm = instance.exports; - wasmModule = module; - cachedDataViewMemory0 = null; - cachedUint8ArrayMemory0 = null; - return wasm; -} - -async function __wbg_load(module, imports) { - if (typeof Response === 'function' && module instanceof Response) { - if (typeof WebAssembly.instantiateStreaming === 'function') { - try { - return await WebAssembly.instantiateStreaming(module, imports); - } catch (e) { - const validResponse = module.ok && expectedResponseType(module.type); - - if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') { - console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e); - - } else { throw e; } - } - } - - const bytes = await module.arrayBuffer(); - return await WebAssembly.instantiate(bytes, imports); - } else { - const instance = await WebAssembly.instantiate(module, imports); - - if (instance instanceof WebAssembly.Instance) { - return { instance, module }; - } else { - return instance; - } - } - - function expectedResponseType(type) { - switch (type) { - case 'basic': case 'cors': case 'default': return true; - } - return false; - } -} - -function initSync(module) { - if (wasm !== undefined) return wasm; - - - if (module !== undefined) { - if (Object.getPrototypeOf(module) === Object.prototype) { - ({module} = module) - } else { - console.warn('using deprecated parameters for `initSync()`; pass a single object instead') - } - } - - const imports = __wbg_get_imports(); - if (!(module instanceof WebAssembly.Module)) { - module = new WebAssembly.Module(module); - } - const instance = new WebAssembly.Instance(module, imports); - return __wbg_finalize_init(instance, module); -} - -async function __wbg_init(module_or_path) { - if (wasm !== undefined) return wasm; - - - if (module_or_path !== undefined) { - if (Object.getPrototypeOf(module_or_path) === Object.prototype) { - ({module_or_path} = module_or_path) - } else { - console.warn('using deprecated parameters for the initialization function; pass a single object instead') - } - } - - if (module_or_path === undefined) { - module_or_path = new URL('minigraf_bg.wasm', import.meta.url); - } - const imports = __wbg_get_imports(); - - if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) { - module_or_path = fetch(module_or_path); - } - - const { instance, module } = await __wbg_load(await module_or_path, imports); - - return __wbg_finalize_init(instance, module); -} - -export { initSync, __wbg_init as default }; diff --git a/minigraf-wasm/minigraf_bg.wasm b/minigraf-wasm/minigraf_bg.wasm deleted file mode 100644 index 165f191ad4a8c3deeda9b933780d43bae1cae2da..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 703354 zcmd44dzf5Ro%dU{tE#)ItGasky+Z=*DgtzXXx}e^K{g|xM}763tIu=hc|xbVgG2-j z@g3$lybv`=qfvt*Mn#PZLvT#nz6ol`dX?#hEE%OJ-m$ZB?3 zaDllnsiP=aB>lNw|by%6}*CkgzsG` zHQ{q_C22K$OaEKtG@e_O03qb-8&uK0+NHELOCi@P8CHv8x7cH=8mJ~;w4bqh`sOC< zYTL#7c8xSyV>I9F64tqfM?v+f3wJqPEZ4dW)MM7cY8P5e3)Vn&_)_n5V3%9RXV@yHdwe)g}| zZu*-WXJ^(9j?9ctPY+KHPS1`G&kRj30h8}ydg{9C*3OKMPpq3=PmRHm(V5xVCAu*5 zT(eePj0}uV4vq4e9GIOR9zAX23z0c}-3`~z8a5XXx6{GDZsQGqebem5nRV)B39R(H zV%J`O)26BGr)O_izxFTbB!aMU{# zKRz`Yv(u9^Z4ni!4!oP-35L3H;|&|v z4y_xXSwA&0J2o>rH8MClnaVG!wX(6+O|O`qp1tX&wd==cN7s!`ubZ729T=EcH@HMS z&r=&`Z+gXbFyZLX^x(k2*!t=5q4D9t@g*>DzU#>G_MdLLVdL!on0ndlO=~A72WBQ_ zM@Of}#s(*bCe|%c)gyj-J2e zf78_TrfYAwe(n0nfytqXk#*~5XGR7G2S=B{{#PIOc zz~Jcgz{Je(lJUxL5npmPIFL*a@ykXM~QqLgRwC?ci!07C{$9k#cCX15*Rj6Eo`uh9?H6CnhIHPOEmWS!=D2uOFI(NhXHZts5H}pB!Fd zBo{5h{GVTY{ica{a}Zhep<8`Nn33hSv{G zjLl9hQQd2z(*Uu4Xm()zB*PdQ93Glnzf}LHY2YuP`#+xj!oOTQI=Oyka&&TfbOakV zGBCOX1Ril{`WvqMUs8VKlQXkJBeRn;LqlWZOX+LR+X&AqW?yjaG>kWO(@WRRtRI~k zo0*y(8k?CIoLE1+gj=(8MU?LP$szRT%*gD-z|>Oe*7LYf?altCmtf7;P7Gp^#>d7d zr`E%X(@QBU&xH+DuYbkM*3E7-=W2YEs#EI*hNdQ_#)bx_m(U*`zYX=T#elxzdS`1! zCMU)w*3HZ!X@j%lBcn^O@iQEQENtKvI11~py&e@dJup2zH9oX%f`4P{M`o62!P{_i z@}}3VeZ}=Sjcc)p>qhV{5W&&)>+stady$KKM%rF+&DxtbZM^pSYu3)pjLrJ0q>b%s+{E)u+_>t`fY$QE9E@$vC|F5ffWlRrD3FL!p9yDsaTn3%|)k>pWT`7EVY-;$>)p3a=wQ) zJ9|onc71xve2Q)Pe5o_}klWebUM%FR)oRHKao7Ird}pzg>+Z}K`+%fa?CfkWUYN~y zchh9~T;=riWPzin+>_7e$M`Uoo|XKk#3YZ~^W}19p7vDuRMa2HU%Q@t>NLLuGGNb^0=lh!F+7~xasP*?5kV7`|=7z~f>Q*85} zVm?WM1*@7LZfhH+VgXv_N&+FzceXTGBqK}hTw9yCgg)ARYyP5+^%+hG3l~rlY;|_> zRVvRVa|DG%~xw?a7O$tt$5po01p-oT6MXLVR)t`jVE6m%rTxE4N|+D?{~Qizb~?`FQ5s7-9XC@ zf*ybd&$lI+0UDu6@yLBowP#@J+q;i`%o=LbgnmQ$IHNTz)|LXgQEjY-%rN zJ3tfI&w`d5Om=BmG7FECN|aOE?o)u)^ic+H)?RWvYdH|)QFs<=r3(yj3@=&AaBZ`3rXoK<5 zJ!43oSpiqbWid`LM*Ct2C!ZLmTzi%_3Nk68T0W}=?E{W-v{)E!G6LrN1(oXAr+_lI zkMU1?u^&r=x&qS>tN=z_|K;H!I6-WI%^?r#Coa(-JAs1-Jxp>B1GL^g^yv z)Zx>wC-$k6VR+a>n2fO#nPcRa3u~R7g^tcnAhm~rMeJWFT*x4;np2p*Dm{~u1k^s1 zMNOD2!zt~92v{4o5XsMG`}0yTi%^`vp|NOad`w|vvE?}iuIFg?D@EJ_sm`_%<{~FK z(imG8ev*L#R{;|6ElhY}Hl(N$pDemX*n`;$=`@tfC3;IT2X6DlbmIr&l8Mr!60~T8 z6axZ6z(CJZ`O*v=0=J3BtSM3uE1Lu8I#jjMI=VnO6kLwR!Ap{5SW=cK>vX2EmFFHY zo0)ixqP>vsveBsFHirx0q@X{K$7~ZN+FEnD3-K^IRzFi?$iee%;B$a6@zg-zt59wO zFVquqtr?mn4IpSaz7Z@$4&6moZXkyQqM<3{S(c)V{TYr;G!8xm+N*&gFmX;AKVXSc zxpW#dNwZpOC`YmP!jBtIV_nIE^d6Nw{(oCCWofhq*z)~ z^d=?S7(47iDO#p&D(D{{`=a6eC>T+OK909VP_^WMg^TejXb0qFOKm0ahp){Ah`?Gt zl@e^Fl%Pwg8tkItCRs|=KfX^)Kz$7Lrwda;0bs!VB4_eZ85myQ`X||7Tq;t`rt;Rk zE5c){yAJg&9?dmTg;ph%SLV_T8_HS{4{iYP61isUwvfu@{y3LQnbc@#Ai6nyWBMJL zcVu#zbgHANz~WH6dGma#*nDRuYGc~4i{D-Ds^?6cHP?#9d;Z`io$s*O`Oz9e-=d&7fkUsiuG*IusIP}Dhf zXM4}WoabKu0)sI1ma^hdEP<^}Cfu6xuARMZ_GN2_#>Xa8he}UXU}7+}w`;{|TNoRi zNPV)ay#alsS}od;8+t;nbZyi*rX(Z)>;Ete>+^&CIObbORIKsp*%l zHDu0iOntGp@R6o;Doz*Qp7}}nr{&vw{<-H%y`SuQDD%Vor*gyp(X+Ml^_`#W`Shz-|c&6&oA1(*!rIC2irf@e4_13tq-(6+VsBe zExo_V9O%Bi_nu&9`+U=U*DII3uJ`V~5B9#f??~^R9k(}quKnKb&lFy@>>J@%+7E_b z4Kj{0Hz9+iw>^|Bz*S){z9n0qWejWa}@AKt5y8o%?K=}4$yE}f_ z{k5L2wjS?1*}ZMq{*Eo>uXcQ{e1G@HdrlVb>)z9Itn}XQkM;br__y7k==oJ~cl&cb z+Wseh-+s-<+W-8KuK#HJVeir2AN2mH_s6{tl;61Qu4Uio`bG11Tfg7;_3oeMf1LkG z{#gEr_B*?_biA?aH63s6dR508x_;OGx~@Aq4tCw%aaY&oj@Nhny8Vu>-?qQD>&f;5 zU9ax=de>3pc;U%MXY__xjvc6_UISI1kr-q8NW_ASfqYCqWXo%TcF`};oBccSZ? zJ-07=p!Y|``+Ilyo#^>R&rkcdb|30_=dvHRf3)vVX=vof#qV|9+p@RoUy5Js`dDdC z>#K_QcWo=(Rr=emHyUcb>Eep@Az2x`)yk~-`4c5;?G;(UHo`?NAVrSw-?`2d~fl6#jm%1qI_TRVDmd$ z?k&Evcz^Mp_T#OeEdRLuwabpRe=z%a`{)mP-rIAuXX~<$^nRu9;og0HzwY~K&oBG# z?*38FdzbyD?^k_q?f!D#UE#^T|7^Xd`-eThXno(Z*Y>=n`_Ycq_x!l$MC%isZ|HgJ zve$HO?fFU1LoL7Ud}Gi3={JTS?)~S!V?7_uJ>K)F%HT%rBdtHne6sgvJ@07ydC!5qk96$~AJ2ZH`N_UFg&rl^M*=uaGCqd z_-k_ihhAxaM|wl}a7Q(LMJpqS()~fI3YfcsQ=5#^@zop3<#b;**T*Nw^!25iQbn>` zpV!(Gr=#?yc=Nv0%dcqdDf(vb?JTWQTG+UmHZ{m?=?#1{)bO?Cda-^Ld*#y>JHOsC z<-zLyjK_939_-B|Sn=&9qjF=452dbb19tN9oFV<4CX} z-gRhRwZtHIcDm}}mwQX1d_O`|$?Li^T`A~#U%JvlnHtPWIOwt-y71pSjIRq$+@cmQ zfq5s9^{OKJ>hSK);Ia%Ouzc52+P73q+c|LKNuCXHVs?*9%n)99ZCTm4?6KOio2 zqu(Dyx%hTB^8LYrkyB*_hF%0m=-+j}gxDnxxOWZ>_zM+JB7T(ho zWmczlXC)8)(7CmZ{+d>$QsbGuFk;lKWa_KpNe@_715G*Ui?UYI)E!7pzub7r`sfdy ztrnjXzMqy?r*>uIG}1$hnN^uR+3}2YLwu)$T|If#1EEnpCJ_$ST01YUH$(9#b0N)4 zx@KN`nr4ImpoT+9h;p#%N@XV8z2yT7xcmD{bGIRK9z>e{K}9YgwJ5qRE%MAKwt;e< z_T-xEfUZX*PTO-ryu|1K^4B~2G_LKrYC0}m*?O)aDD}1+t${aJgYJw9Ul6x=Dr8or zzK|YIi90~(PRhT?CFjYFNv7AN60+p45?T6#=eJ7H2!{BL_rVg+5KE-uX0d51E(tO{ ztMMY0Rt4L0;{lMbPF)t$POFC?yD|Kk6Z`m}<9`QPsiv4!_u1o_7bB4wE0c=1z3prV{m^UsuwMgnn3Ln8}t0C-r>pa*> z^rA=Rj$DF`224796Xv0~@ssd(lup7ovA>NMejnAy(g-WhOzFHIto3E^< zld_L(r|j7a%0@*sa(0wnUdhKPQ^m01CU27G(Mi_<16iBlD|3pJceBgen&in*+9Jlw zj5&vi>ki$+#I#?LQkh32!VMK;4wB@`c~AjzQ7C4!`!-ZUpDb;twEN`B4V4a(Qd3lu zNl~?~4V5mR%x|c4`?BQr_$0ZK>BCeb7ZI`~xywk3AmpCmljJUsir}@f0yH$EMO&g3 z`v1J;l{2H3IK2UL)lzA4en8@-Ec6N*@1myYOp_=PYc4J3+ArA#lk@&6zJPmpzBL^m zO?qz%WUavvCz^@ z{2=#-Hxd4(4Atyda8k@8L}bGq z*(+LclhX0XhKgkI`5P*Mb9DM)%DChkzNMjI;dLx{LZvrR+BcP^DV%hwsG)2trr#J= zE)1zB(oR-Qs=jb!zAmaDQKS|4o1KsCM`Xmiu@W#I@&lR%IC_=qn5Azu0qzvgF~bffy^8g;~;d#TU<@& zNM5}A;Ox<=3>KSyWev8aY0lfCaEqizG9{zbSZaS@wn@~$9pG`}!yQQz^O!1YVlSXC zst-)6e{#VnrTK665FAzYKD>CjGs$oPZk%BSm&JQin%8)8aQ8$@%19?K;LW|IO3^98 z?@PIjqufeoLD(oCHO2S7&1^~dtuE2;)IZTP$b#y#xoaN-6IyX{ERBWj|hbfz?Lvw&`n&WbgKYn@C-a6n<3#2azB(;AR~^{61!Rs&P<(0ZLFTYO7XM8@3vhbzrs{S8Z8@cFFCE(;z;KngSBVet zZ5+e!~v0VaDa=c99+FKg~ZscK&5Y53iRxkWWTd51w`Bu83o?0scQs^>qL-=i& zrWz7w)V0FM)JkVUfP;+$0KX|C%TbqmI_};5+9kO6oWwBIxiB66@#*j<2p#tRXKQvWNGbdruR?L^S5Ji+lL}dK8KpEZS<#KK|h84@i zTX!H087UZI7u>&5_vT5u``6v=pQCV`ou`w6aEF(v=_jepibTP?rT9zVH%x05b0_QyHWhM6`WuIuHg>13cEDxu$UXS{uB$$A zS4!*@>1(CwZ$+I-@g9{mD`=_@SUi)^jfdg2jZESp(4@C*u|?>JN|4D}gM~3bd=_Ar zdf3$l3h4QP_tNvZvcIjxsEr}5Fe6fG6h`pwBO5g~wCETfi}%7#HhN+A9x-gG7ZAO| z*%Rg{=}L1HRL*h?ezr^n$XK1~Gs>xBPdw>*FQVeUbR`j?z=hhD5}~jCsF6Z!!SL)@ zjI5)abtL?gT7ds6Z0<*w$OfQSYR9Qu#EtlaR)rn0Gse~AgG)pzT6*Ff;cc; z0*Zn0u?8`xZYlok+YCmUkUL;ZA_5AP3ixbSdDP6^k}=>p`zrIb<@)wrhusEKvW+QP zdiXsMZHS7HW)6>Zp*2f3JqE4b;J~(3hg46+>1+Pjik}njp!R{0>8Ti=w>e;$5iH|=Z zeb8$9foEjLpHPlDZju@0d{#M$5=>VjX;J0xRlZYDSq%5YVt zd%E6s1dc^ujngWq|GZ~jo+iVQ$iWn*l6K<*9TZnV81zYRLO~OuKW*vF; zn2Gx;RIS30Oy^g@l$LZQ?`|x~#D7(=!ybq3u^W%`QZV`h2(gfB^COwx0Y4RpBBF|G zQiquYDLe`HnHjsXwNx9h$q-82240tY*wJgn&;Pt};Kbfb@o&W$qY@5uX(`^P+d*!n zGaZFZYUK2%edv9cO_Hh-(gtdm3_-injA5n5&>FSHD;?~_K=5ps&ZVNV1`W0S6bMw$ zYdYXGEzuKcTDYYYACu5t?BQZ!X5<%8pcA%panYsp#)FUB7#TFgRRt&&{#&<=#{f^j zPUKR6OD=b%BlCPsE>n`r#3M!rM-ata(psh~3>Vd$Su8|Bcq+I#QjpNznzjZYT%oASJC4#6@S4pQfM3=L|2-&H%iEof??q zwVDB31&|d}(Yvyh3Mx8qYcyiWnim_s8#%EcIafuoE9YQ%0*HcgK_Rcol4)wU?mI@8(nSg;W=+AA6FUds#sUzfn}w;&kN> zsNB|CxnRM1%xPC|i0+BYo^tJTtGC=J#|1057AA=&WG)n4-qRRez69>Hz{7_WROy!K z_EI6ITqvG!0s3aimz8|=J(O&m{yXraN1aZKqmT_D!qYtbAK?RxgVu0 z@UnGFx!~UROF%K7Z-GtDi84`HS^Vvaj!B+fnpKqN|ST*m<2bPCUtFw?=m3v zW`rjd-b!5GC{kWuS4Y8YBU2 zJ)*67+D35(+40~pjaJ&g))N?q>)j#cKqiR{8<@bQxsL|pDiJi-E%6;c54fsTXo1ek zKBepr7~0d8B@BMLQoZ5dC+iSh0v9b?cL|Uf`9{)SCcEHVNrjp~oDVXI{|LBhU6`UU z9jzS9BpHSV#Xq~?9gQK}!?r}C53(s>Fy z4W3KZ;#VTTqPW;RVwHFSHIUOu^vXF&5K0{o7t1DV-_B*s{o!#jnIRw1D&bTlaj_N$ zqT*sLj6jn!??_=E4~qk!0N)6$;y;;sD~0IHS}R&_kD7c{IAB$VVJ?V^xmI97wPIT| z>dp)Hq8_vT?$&t;p-R?cwidZDYv!<=P=}TGKRz9f1Vs}2V*SaF{j7$uqid3wVDqA} zTkOk0?P6bI5yh&|0EoU@OEDFGkCgqg2BixT?ZI!~dddUX%pQD64~83R5YDy-TlL`5 zh6i9u-2OB%PmI0E1R;>x5*7{G;&a0AVt0lUzPiuttm!kkz=G{(OMY0 zK^&T+d`%oYqnIGj0D`bUKoo7rz+aA$fD0w!5D`AyX38jaIWxn)$S$l&#!ZRZvk-Pf zVW;JQ5H+u<2H?u>S<3XCYu1U2o0p_wEIGC${zZja6a73Jzq{-5V2Q&3sh_ayk5sly$)%J~k{?8`V$3kHU1 zb~d39@Ry?V>j(!>iUuxhX96-WI5daz>}^9q&U2N1QEO+ea;~_ePmE*Iss^(0lj)bU zqMr=rJ@?W`qnAVo@F_V~4$S_Xb8n7v6))}K%B}`R=eSeoFdoH=(7J`WDfK@0sn3yx zfXjSW^D;7l0$$!t0&wr_=J_+uR#XyhS= z$(pID=0tYQ{$Y=$t`i}s%R zR=QCJ9%Oo~gZ#laE(Tf9c#UDvE$5S3w0@}x>7O=uu>D=xGDbg_#c-M&Ocp)0Xw zLdl!)!!z*?Kh3O7>9tgaed7^}=2{xJC{TENpGq@XYuwg!h7E{3u)0ieHSEjNhGXr* zb6fMY+c48ldMpJYwfE}?^61$&^#kuBDUjSFWs{EYXNzklNHeLo+uL=UP3M@#rsFlX z%QYRpXhYocTH2Di# z$zpjVe&&^}x_l?aW;_iWCuZR`Yg6!zgGsA7Y4HE$IRbNUD-_WRA@N^Sh<-$iWccXXWC&e-tidncV%Zn+c7XUshjj7q64PIBBlJRjBjax(RDWtl0ZXjsI$H%IBzXVbVIv}gHR!bv5wLDk;e zv|(kc__O~zxR~=kc^_&=OY%Mx?uH!d0ey{xkH|}4SF;rLUlA%qx%UTGYiTxo9E%ga zv#WAx+*D!P-s%6;Qds3Ik5rJ6r3_YO`YM+KMRe(S=H@tEF~5vh`i%rN-`?vQW8&$S z`Q4VT{mqPo$A6*z4>YTcQu~{$Ik+eldv}0jM5IkG%rj$PpE3GbQOP-`3VNUo%<+Dl zr+;T4YT(bR#2RcBg_{>udBsHUf7z_JO1-^=h$DH?2W`9VzJixnfdi)(HiYlCfZ+Cg z62io;QrHR9c4sHpaB{G=iScNYYC19EdH6oFAV-_10Y>_RV<2!^t__pUuQxN^FwnQxr50gik_$Y(5jY%!qlf=-t*UsCBai7qYpzB5B ztlpC3?He}K(n+39tZAToNd@E4A6&--vOu%yTQQHFOz{e!yIKtI6vH_5kQ)l|rw}Y} zVy}m9>!lU-5Z|VTG&bjfS%`;5mMS50&s5!Z1|veI+RX3>Z4=mL?&rW_i9ul> z^-tY4n#u|9Mr$U3ifHfm1=tVM9KNGF{EtEfVQn0wnzF4lCm{Ym(Y5^X=Zps@)Crbu zix?Bm+blN40Vr`3inkDlnm((j6+dYFk)R=i6H~qo3Y_-*~Z)K1{wMK(_Rnd?Y6{FUE;(~nT!;{FW zbSTnn&>m<;!;^EcSqff|pOF4UNgUS|={n}GN1LKn5oSmNq(2Np&K8X5w~v8QPyzYs zaH1E{%l$!DWki=y9cqSy997GL)UP6_6D|A5*BH@)l)a;(m7{!=)yff4sbH30QQ{T2 zOsab61E`NU6zFvjU9w~3t;BAJv52#s2`RR`iLxULlz+jvw4NQE0R z(Xgk+2%{A~81*rMd0&kpANBEnCp?t8um zOWY#v6xraH5|OV0CYx|YfQKP^i$w2H&%y%cmZ{o5w77hi8NOO?AlYKL%03~!2JM%~ z9kA}Wnb3e+*sUo;P}&6`gFatr86=&xAa z2?ngzWwX_r*>SF>jI}zM+ti?d3#3i#jai-O(=)^!3y!JSN%J7yVte2QqA`3 z>k@q#7IqfG31LIc8>`_QH#DxM5m-X$auM^WR5ihiS{uS+Eo9Sg7Z*^ZSS-Cten5Tr zq*M(f4!>rr?++EEQjiGq+K@q$ws+wN3q|2W@%8Xj?4?~c!87~xD+^Sv7iU1L7`}?r->TH!f+dLv(=ekVu}W`krzG^N zQm)|<_gDbc9^-1PNgb6nAw09+Hd)ojcHrs8rk)m#%>%0kwXqqn4no-r@X7+wk$T%U z0taIL^dKThhmU0^TjfoIs{EVUf|{xr|O8T^-6c`e`V}8KWa>{R}3Sx;_&{tm^>k zRo4*Jsw<+ZR~R+%Jgh6q=LlE%u9ZPu@6MVB0TA?m7=+4xFRk0)PCYuep7o}SEBF4px#wsMKC$Fr3`@@QCtmr-34{gFEo1gi=pI7v*L~BP)Si6e!5wT$HZdMHONeRH5Dq{a{AK*fIC27s zlCVzLFR7VkRPlN%>+~D_lc?ocTgt2HH|np-9Br~aUXsD19>gO8iTlHNZ<-vtpqHWN z2qa+=oiI3Sv(~Hu+8-Ql!Z(=+-`_$JRdlf|0e>tHUQN#&r#a=E$jj@LgTKYAg3Y>u zp(i{Tnl`Yy-lRzuXXP|ih7l&?^A_NnGaI^y&&jRvxxIN{+)r*F^9SHw(J;M6ktMx3 z?kA3C8vF`Y5YH8I<_hBbbEWnYzCTyUZ5CGT324{GjG7QIK{2BE3B^u~*7XAas0D_V z+EsH!U2tDT{!`l}PvZZ)SMG%zp?7uItJLvh7C${FT1m>O&#ItV!I$s08m;i^*!XE1 z$PpH$P~*o;k)lGw4<{agy6OkV&M)3VP|i%I13DKzjGl@2TQ%`7TbXR}0w56z;6k~t z5&+3WRzToKtpZ!YPII&Ros%Mmtma4c^B4|y{u{0oF%y7=CWdabotQ&nXXKHNgDqq> z=1ltwk|&T4LB6d}Wrh=fWDgGDv%>wY7=dMe@n$RD`05k^527#e6Cb0%&r?YW2QUnP z`7}o(!p)+~e0+?8;Xmr+4KHYsx>*@Y153PgCwBwN*|%I+O|!y}D-VD zC~R$#RlQVOZu+o;hm4Hp^MdrDB>Zj4K;tIz@0<+7x?Bx&*BCl26IO}u{U}4ZKkbIn zSB!tA`w#g0UO)IFXbts#sL8R_A#nC-x2lX-X5(NJ6in2zXmdygD}55{gvcZa7K}h_lq7#X7j|WN}3fva^0p=>a%oWJyZJ zU@4AJf96wX5ycNPG|AiPEJ9tTsy|>^0RAg z5$Ik;4XHY5oQ3v&mjv{Hkwgf6bDBthg;JVY$?3ozDP_D3Ge>7i@a+BcHmT24Dzf+1 z8>e-qSSU*?9&FC2;q6e4SV~1_2mMSenQp&L2+X<{FXfqe>VisuLN<;uIpYn&;jBEN}Gk zw1+QmZ_bW-63Zj5iF!p~ErJM_b@v~P7*jR6|JyvnZ{;dUo#QI^->jDDVekHnaopVR za~!8fC%i^%!T-Y@&HV!_WdfqWHG=Jc+rIpJX0Va z{?WX+2&fh+5b{oGl^h3t zT47f9gfQsnrio{L_D3B+*TQd2n5iK}B)FxZ{8ea$<0#B}hFiZqpst00BYnJ)nL^A@ zUM8^xFRL=g%_)Sd>;54nwyT6QRY@czJfUV7sQk|!?`ygY+@#Wi44B6R-*f{lBlrqd zCqsK;!Nj&UG#_a73n~pmkp8?|<3fKnvXjO=S2(Ti-1^kI6H>w8r_r5mdi49~PB(En zjqXHGJEfSQK;%G;nvT@_#9q3VM;$deljbrt=#+e;mIR-PmTapjebgiR+o?y$1h&Pe z@5yQl{!?l?0Y|8^7Ses6wl!u}r*>$0K3c|Glj3H_^vKai6*NS^PH8JlOHJJCUr!ntT-D^VT;st8( zUiZRKF5ZdbqscOc716T|D@;0w4VYHQ60_P+S>wY1LlIj)CI5IY@)A~9z=1^M7L1C7%6@o@utU#IpzW4DV>EXJ7Na3ndca7rwZambIlDi)IOj$4q7%3sj>j7>eT);kp`0u3k7oDyVgS~B$56b;2hM2R3O0(lVauL$G;*%D-DzwU`Z?$ee1EqirkEVkeW z_snxopf*RB#zi|6TqEbcTrzF9*d-+`b_t6qW+~l!SZmZaO;-#Ws!E@p5{^>t;%T~a zPd80>t=lvmn~_Y@gNS__yfI?abPo2YPt*Gvr|EsNP79{#;ynC)#RkQUaJen-)vSi% zo)*oq@zY&atB^ z1hf(kb!)AXZI1zD;BlR6vp@=RdR>F5DU@JMN$OuXL&b#p>f)Xj!t0$TsBbz;MLcrO zMT&@B;-T81Uk$#iVOb2*a1>gX?h_ZKOAJ(VU?O)&+R>((H;nnT;5J+@f-MMc?-be* zh5LkZgpE0udAFwL=A>M`VRc4UMmV}kyr96?%(3HsG2<<(+>2CpWqa;vs__~&dVuYfg4fb7N&&ghwe za%}+2ocEs^9T1!#!i)`kAp=6}+7yb#_v-vX3x*#W6qA9$5vL(FQXT>6f~J}J&3XNo zsLz}ZzJzfoC+W2?foXeS3-?*f0Xtz9;Uq{S_#hrL4igexfb58l%LIU9*;;^%-7n!u zRcEJ)OSrW%=l#gBvFP2rc{mi?`}^CSXs|Mr#4l*a0LW;25ew56wUP*!X_B5MAd~$s zY+QOwN&{-n>k3yYfTgP<&WWl{BbEym3`9^gwDh*^F-amv+R)@0FkK8;VF}qIA5BQJ zmk7bp0=25RjYU3Mn#?E2Hvptg@iLmL7T`VN)T*Mq76~7ThMlto9;1=)o2K~o$|758 zAHhCV-(QF`E{?1jjmEin@{^1bgT#2G3^g%=xb_l1dM{&)vXhQ%Gz5yJ@k6(}S=q2t z_`x=@g!!~z?nUkBzy`a;B>197&0VGfheaBh_IY>qK;4~{qu`=e+EOAg9%FBam`K}_ z+?FDS9Db7{~IoWHKthnoGsu=(3Lxk(z9awNMTC|M-M?0STFeP4@j!$S! z`NwUx32crIer7LVof?R*{a zB;z%9(9Y>3h(dC9tR5&_a%b1ldnDXe3iaalQYfWeNKb0#1$(t!Q+jReiC%X8{9JC} zju!3r{Od0Xbz;1+g#&u3p+ZC;tu>m2L>sj@w*5OW^1i3jJ0URf<-mxHK9JGfeO zvTaLLg2CN6Zn&PNJ2>UH)zxxQyZSfm*BZ4{%j~LW(ax#|QCWH{PCZAP@`|$i&Dseq z3*-+m(EL_wr|d%}ipExK6x!Wv5ZC?=;L%9w(hjaxS9Bs!mj={?Q-EquG>2nzo+7*l zv^hJ)$>oWgX|WUqc7iJBm2d#JD`k7Ali_NER10x*rrCNCsX3m@Y>1D4L>oPHlB2sn z>Fzlgu2@5vP6&3>uHOT6hoNSB(TKxc!|!SZj8638k-PUd%r}_SNK^hJThf}f#=8@v{d zDA*#^M>s0Y5N)xQBeh%5mr#uT!Yyt!qoVyVEz*{z53$J{PbJNWnq2PkAo>|f@%lMx zSzSQu`_h2Pb!R$8!C{P1ZUS&lR|Czqi#5lGz=R<^{0bFB4Za_;Odf?_P zt)mV=xWU!-M7VrFa`_EDf~X6CF2Cj{00IX*aXtj#_*TP%B=DqRA6<_HmAuWToAoNN zY@_SrpxE$B8g`L3*F*Q*Fd!p2l)KHNOGrbQDOVLOOo3`QdF|-@8r?~Dy$2ZC3t4z76HD*q&fK$ z7xxsXjedPvm_@O3saC5cA6kvaF3p5diH3m;8 z46)2`N%OaSwdIA{`79jhK8qCT^&9q_8jAR448FRR3O}XdU@!bix0n&G<8bmyKAGqx z2tkkK#XyolT%)@Kn=U3A5AK6I?Ct6x>IM#AGWj-(_#S{QjH{^5n-W(G|qXVhX* z5^{^#Ifm_(cC$h@Y_X>=Z7O4xN@y43z3%7pfFPuGI@_tAI!MO${205q>jv6s&V`cS|Y zJ3rRinZvYW*f`>`aaf!Nc07IH`2Pxhz;VwNyusdL17X&Ld=#IZ@}J6?bupocz0@G> z3HM8XLXgtxl(xR=&_U*>;6d~bJm_ae#Xawv%N*wj|($ze7D}=cQqyc@!bzbqEQxSmfOWW0BhPo)74uyd%eyX5&x? z%!2(ggv&P@r~IXCobngixOrBkB-HVo7}t6}*y0%bkww6YPv$dX6t*oJ*F2J`q7|ex zrRmwcY$SE+(%WzH&9+nbu}qBQVNZ6dV2kVqwVkSUy2VtV1LLbEARNc2BMXv0(UV0S zv1No7!6mo=Nl;bhCC;7Q^p!316!+1LMI-Aq!SE)^3hZ zij|GMrE0!+$GmieG`ds`N%6vGI^cXUhKY@N$aQ`zdVVXJDocjxxX-bjcFY=I8Lv72 zvcD0k{{IH3G*oFwLJ>W!E!rlX@b(#>uAIqTbf$!*R!T3_n3y4>B4gw22 zNcYU>sbWUYRA-$zRJ7$Ex2O83~}u+uHJ!<2l{)+CcomXOTkhc%2x z4ri)oIH8oQg={&cR1<+S9;g;|S`epl1}RjWX(^qyC&thXCmVNyH~@R7yJGLATM?52 zcyJr-o5HFt|MTdKX!)PMltKZ%1An(g%@?Y`nWo07XRWXHE@!_s=K?R6LYvk1nd?{u zKWp7aj$?GZbcitp8>)o)xzPWblz4bAxrD}bqDX_v37?rtU7S7y=9&5FH%s=C#H-H8 zFIt^q>^Yr+l+kOI&!pVNw1w;>=kT=AL)7B?uz)6lOe-=MvR|?(IcZdHoyvz&w zKZ$Iw9kv8M(uzyCyC?Ot03sn#FLknDEC?xsSZX9&S3AsTWKmAH; zxF(JyDDB;32tc2>{pKdC%vUrKz+**C@zW#*VW6|dMKU~7Keoi5q_mXAYh1&|G}{PE z(QUju+!eG!JuT6yLqiVR?h=?uFf_$*c|?M6@9BY2NXekle4OPTy(}-F>WvBvjt5@U zy7yMF-17iqlSFM{X6ml^3OvZg%??OVYOll&UG3KG$%6kyfNLAn-d2*I`60nX^Uxv{u}!VEp!)b_y| zSIyyf;Le$kay%K4&W=5r_G%g_!j{xjtb$=xGwl9t|C>;O#G;WaDVT32m3d8T{9^D2gA=VDq+!<7tQZ@;PNnB@+lpN_@Bv0C)un48mDXn<$o)EMCa^TMSG%m)Lzzp+g^LvbnI7waEi= zZSet<2_GZSfV^BYNHeo?VTdQRD8{Bn@ni@mlq9**h(P6f;#)xw8;z5C0qiHowSDD| z3(YDi24FmC?lNI5H0NA~SKw{SxqDReux;o0a;a5?*$HYX6|LaH(H4w3ErA4~AWDnP z+hH}EZtIG85aeWi(9DdMnOSa30IB$CrIw9|P#8c&J}gQCnaRZl8pX-&BPndBH{u7h zAw}SJSrk+{%n9y@I4%$Ju($?Hx>{6KN;F!=;)bS`9Wa{3W@)KT0Q`MV0LkbFoMKG~ z5KD_Q=1!{C_)HP2ZC*{q^}v^>2*sC-eVKMJKV&?^u}kLjsHOcu)FD04&3N3}O*!Hx zG1HP=fF>g0^%;^1+Bxu~JKWx3*tTgyOZX#?C5GiVLJIC}7MU^UBB-{wU&m;R`ebQS zI)37+A!aHCihQ9ZG} z6c5KCxPUVa&oek|xr=E%hSd>l>}}>8J;5RVJMPu8i)pzq9pm%C;l(j6B&k*upx7cP}(s|`b+em~R_-6SkL;c)#=c}vE_|yju)G-#fzqi>?oSfN*(^@W z-xM=u*^c=CQ79p0{tQmCn_dVoj|W6i2$EywL4RdIM#bwil?*?Oo2P{IN9po(U60z zxU&EbI0=Tq)F2#^1DTzZ8SnfC8={U-yAeG`EEFpLoG^2sh@k!4A{?c``k@)faw&|P zpbHw+VuG4F^#>?Ec3?Gz1Uak?)-WfchYKzRapM|#lyu}paugJe@F4=PP9%GYvxb~; z2YcjR$euBU3UFMs-`8sw#@p`WiMBlk3j=L;W3^i_7#!W}gNj7P9K2vm`3Q%ZBO_4O zM*wTmYdB7e5aLwBgYjz()xy3!t@f-*nJ0RER8C3CFIsX;+7aZ`7yF{$zTAm}D< zfmT7_p(d}SJkJezL8{>|hIDo6XgcN$M41BGmAxfi=F)^Zndvv{4eevHgXWMsiB@0n zx4$#*(X=4A+Tsf8ofDf%hOd{|lQD0QxP=Zb`b7Zfl&yWe@^qnRyca4tZ(eshYj?@? zhYF166h=ObHL@^`<_=$GrXaP!*rmp#Sb3Q;Bcic=$y5}p4OuNQ;H6kBjGnvQTRs*M zL#|CL0$^igOg_+@6e4b(w4oH_Rx?)ORJYj4LlloIhb5N^qt|;giHofL3bd&iF?*7j zIP=SmxX3B{X=u5~xHY_`kV-LIgo|6^LUK=JpSSV|u++Fj*2>XV`i%V;j(HQ-Ngm>Q zIM2#aTJSLEHMnq`oIUCcKd9<^Q5>)DLm@a?Y_DOzLo=@q-nhh&Ej#^e!+gkInAdjY z=?r5q!>P&6DG)EBqEB(?an0aUqIVF=meLXp6qxwKYxX9xi>ly2*$heUJpmB8_q<^# zOZ|Jh*Z6%3iBnS&B%}$69rz?pg~J4kg4bBn#L<%b!I-;=l#ZcUf0AWW5+O0&nVQ?v-LAem53Z8z-oVtyGEq;M#P!8+E<#Pq6msD{Pp1CPk?6xvpv{elf?urkk@_JE^x6>!jWw z(_}NyXDLorioZ!16nH5P!nri@mQVeU0{2lT6QpT^o0TeDil0HePzUER4lq;-Ki{PH zGW>n`JZ(a^kj=-|PkuU2h=3nr zsG>^v%@*xB4laK~tt2r6S5fCg!`1a_wKfQr(?k&O2S(S-TLcxi;T;kK#Ki6zwRgZl z8k&~s*oHc^n15!Ug80LMJE^_lSs1fss!+Bn*R|{XmI0U{yMbv7 zGsIFq7s$c^4VuH1{$xGh7@u5sE>HLjHbDHPYcfbe<8f zU|-J@KY3K`rQ_TG4^gNfe4?dQv6(v-+})|WO!91N{VssrD1GwB$#a^Hf1^9KgnQx- zGAzZnUDaCPHzck2Z&e_z<|y7DL<|pkZ51~nuT?g0M>PsgYN&exM$UD&CO2I9EyDIV zxUv=Om}Ih_kIAnKqey4ETtd*D8%n~fxTeTB z7>_UF*?z;d6R>{KcRIUEl4hdMB_K-1C4+y#CCf~oOOAK|7`TY3jO@1~ zK29JU7`xvwH~x7Wd!E2gpExSrYge9C?yDXXV9Rode|GCz4l4b;1IY@(JrSOLfb+wA3=0Sxa@v z2wDoy&G9|_@k0Amj#B)jtOL9uMOGrn2fnovY$X7H6^^tKgNM!hju5xbb%a$!sLfC= zJklY|Q(PCAHVW6Ikg}+6O$yG9dbRjL;FHjSrFg9qm3Q;YaR^zm*@(-d-+9Py+E^`L zoMP{*4iZ2NuutN>E_)ho+Q=kKtYa!Ap%3jwJy*51#jAjIo8uz(9oA+0A-zIaiq|;V z#t!&lro*R{pYAAlX8IokVqa*%uLLj}*L{IwvAqGYDMm^}!3I7re&qgW` zX!m;fx~ADsNNAo!hnc=Zv$d03I|hYrY}4{)*j1XXq{xYw#w#zGeS&7Tu%vuxvT{w6 zp#{Z?s$oXsJ~5Ll1jD)jvi#D9CUHwlC-2%Y7__ks7HwQ^wK|DYBZN#+^PZDJ3N_Ig zsMkt|HH^-=h!XWqMEm#rrxneb*W?t_Zw;|(0I6Qowb}v*b*`8}2M0CgtRFKu&bbmC zYiRtiYh1sFlQfO`i$8}!jsNMFbr{=i*a}md9ShyGflju!x*fQ-lK@9nNX4M|iwBF-ukebp5MB!5E|NPY;vt=f4L z`fp8&nT|t1Ah#`iSWHv*jSk^;inqWq*Mn(Cmi_Qx66S!9)%ew1=Yfc^}}PhW9%fdEcK7D!>hRk)G3({=zo@m`Q4l;RFTx%kV*m34$;r zlEpd#T-Y_juml>!k3T-IacOSw$gf}xZA_=0s|ycdK6R@^E4UJW30(=tS;{z$Jx2-G zi=*HqwDU)Tn>;%()my+kFjFJ*n3;QOcA?P)>{3qHg@GmP0(r$QaKelA6W|Gx#E(jL zPD;L6v#K!+rE3hM(l#pFUWR^fe^B(B7VZu-CzD#NP0G-+rgqX8^qQ!hIO0vf$sc(+ zb4crozs)8h?aTJ6>KOoZ&kqC;)&0y1RfFe3ACeYib#-{K&6h967gOP}dIg7!gc9HK zFsk0SQv9pej6b8XKbh3bh=#lESEQ0D9iH}5f0VO{o&5w$y2VZ9&Qs*3gfV1WWGVg~ zGrEj+57kizn>m!_oFhJgs!7K?qz#?J@8`62?reis>AEPE~p-^yx2B>0TW!@Fc)Ord+V#qVTmBV0OsU2}ZiRjtkOYS8}E9~y;O zXtR8%+Z10&{&u(n%7Zz}{~hGZ#iKmvctJLE{abT8g&y3gx}czEC5`0lM+7xxt+gj4*_L)r)VExz25C6oBJb7OttPQf zLtx2quDnsN8DSu0&Y?Y1uC`|4;0p2I%&yr~%t+Ng(;`p^F(HpAi3`Sd4W~0o@u9;| z>vtXDPNEMgeHlt^^XA92bIO-7>-}sP+uZ+TMad2R4#`j?@pAW~4rYdPm6;4_Z3Hu* z#YEHoF&le!s(Dr*7H|}h z9FIqTXf$nbJigK9$8Df%I_SnGFTfcTHaq)OJ#AmMNntgCGcTYuA*{ChGN$It)WQ-C z+BAvTn8cVw$N&rg)3N_BnCuufiL;v-rNdtY=m??Kl1Ot3$h>A+plHB=1R)(R9*f47 zj6?zRWF+>AV=@Q}ek_20&NG_?ONx4P!dzxn9l}}2_LE>UOg3S5PY4q?J~7v_m}E(2 z4zspnoQR{~fDgZK6M~)ie-8ck1#)*qTzEbFSG~sxPdc`)^_=i|t;1yY-Y`LLWc($% zlfnQ;Nq1#CoSQt>*4@-jJ`p#tH1otbf?oR^y)5D-lg#)^YyoW?GK)>8L6Xm}L0mFd z2rSpo0-u)SyD(AAi<#|hzF9u5{?G)s5{}`Le%^BYpmMJ=%9 z=?p>gE&r9{FGNgoit$M|va>2R(@#UX)O@dq7wf#O5wX>?$uJs$uv!Vibye|$@B0q{bxj{IhJHVlclz-W^;xH-!G2nO+ zSicHDHTl|X2nWpuYgSH$CUOlAD7=v^v@A#{DxvONuO@$+0|;Hvao;$(7pKqSQd*Nb zlS_F`Y6TaBs*el&qJy;|h7Q)ol$E%!dqdMGwoBp_M=bVh8Wqp|44e1aUS-$u(1&xos;;Y2@a4Ej{{BPw}HOx z%rCLlX=Z@d;pskNW9j&|F@8FU%n2u<<_wDiY$ixBd6%LgCF4I$M&P#AjG%K$8e=g+rezT zF?{aj(#uiDOKC~(hwY$^@SYAlEmyvavlxC*iUVjxjke_!#eMD^er- zn2Y!P6l}YQatX-;BYEatTxN9YC{~^WJD!=gjcPv9Z;@iJ;a0?}kVOk!@1-F~j0$#U z6Tb&~h5y!ve(8nD?{!RWPPDg?CE+h9GK7o zM?Z5I-2mK2ec0)UO^^C<8=Xs@);obJ55Ak^lFKjmgtZ^al~?Yc8~%8=+0CeQ1+5Qp z^(fSyYbFwI=@?W?xi*9xT)9voEb}NxN&2=Y`j$}E3ab?F{{EwIRuZaE@m(3MFMsTh zf{xo-^jm4id2>FqG8G`Uzt5kPhj=j?|8Jc!!SG4u8C6hljb&0@|*z=yefpJkKa6klXt6)JtYvZzIaTdvWlQVgRRK&2Ki0jr* z#Ho?KYQVyEra8dQ9{3;%^~pv9t5`*6VRvg3D;kO)3 zVH=D!HVuY@BmP2N9ttXodXPF8RGTTc;JgSoJ4m*G$YKDs)rgeC8ybBN7de^V;sN3D?s*Qb5T9m{kWoxrN*hP%su+oU!A%8u{ zRXYcLi~CyC!ghI+Tsa%xTHB?47 z1YtcvLpGDxj2=IhE_KtIucj`SETPx>{t9$*c`-Z-c6X%Nt>Hkw_w%sk%J56gI{fco zApR0MK{sqwg(mTLgZh!LnN_K8xJ@`Pgk&+Yx3?Yc?$DW=d)WL_%hgUGD@a>j*>SuM zncAsqNV=TMNnmng(ztIM&m2EBd78Y$8-f*KnM57;gR^5@v=64y(4E*V*H=8v)^?z&nih51C(r4P^bLx3{tv?mJ{XX zR1bPCo3ry1B||wKDqm}YpS`dq*kVZwyp9VA9UP}ENFfTE>~c!^Wh}Alm=JcW_&Z+B z(P}!JGKqV{53*Ua${9>ON3V0PN>K^&r!T3rM7d|C*Fb$=8ZoodY)&C(LY&6wUrX_k z{bKcDo1oU#;lQ6|*b-b7%>@r?vdB+!yeR5^fYU+XPU2x3szIEJx9fnK$2+Ro)v1)} zvG_}Gh53GDFGbt$SQ`5`=%JGkK(^a_$!& zRos=ELy0gzBdD_+2Cte?;~(p&>g|4^Kz@x*p+Yp8wH$=zm6XllS;z=7i6mb?{UBdJ zZh$EeJ;qg#zmVkdi_6$mFs;5pu~QYY3D%m9^HFCNy*#FgqvfI!9Yn8TD7@3f(mtP? zHF0vaerfyWoHV?pSInlG5(a*^(p7awB54QnlBI7;Xy1lUnSPe52aR@ZMi)4C#_8u_*aR>@&nRb;>$Vut7*W^ z+~B;+8vuD=m6IKe6SnCJa9jP==zcf5EoHzQ+O0t)IafnGuVi|o%#B2!pg$9fO#D!W z-@o)v*#WO}lArO4rDb8C)2Hyj37X*kRxP!_)6eo&mo(~MLfC@1BHAg`ZWrTS6;$X#($s2 zZ{>KCmb5AM18<%ezwCfeY`Jvw{fvGH$_i@B@gf?#A1oDV-)TIwIqNLR7H_BL%ua`| zURLe3J(`FirzoYp7-AO>Q%j0ud1%3vL#!Rb>FifQpYA@ zwTVoePV1^ITOw}a=}xn}W@Syg2Q%X(`48J@8TYiYDzp+5P(TEQD4>uEII%)2w0aPY z06~`%C(#5ah+q;06e1Wm2qHjqlt#e{p3ishbML$FN0nt`0zETvRQJAf&(D4Kud~lS z`_v^Y`BBijvLnZD(#Jr=-;D z^slraP)u1VgfKr^RRq*K^`b4m*{AHwPp7oHRKsePWcLj`U2VI}0zgVb1nMx}JrU zi?z+s3V)Tj-@q$|s!S=biSNHH;$|1EUDq>vt67AFq1E#nSq_&!6#aT*^rPlOUY8%@ zY&kj(j7W-zR3QKK&mmKQ5v0_?#P3)DzZB2KIjCJ_Q1HYI>R`F%s|FduR$vIzv=P7U z6i?qKf03APf`oz;^7lD(vmh;8MM1*>FaKsijz`Ww_P)T6XFoyRay-hvE|L3>{jLc- zMHYUX53<5(-ZH$dc%*njU4yroiI2cxbQrAUFjFteVV?Vm1x?&b;V@*E;ajH-da#v} zX&lFJ;4|X7LWVD`bbf?5;Fv;B99-lF6Rc}5KoJxI69WrMAO0;o)hl8^+?`tv zjk}BSO90p>IqN&)4=W=TEW`rm5D9nzL#YUY@`l)vf?&+hT6}D2L7;qUWmpi*4hRA# zH1eW)~4}`NE4WBUAQ25 zB1pq2UYzm7|aD9flD0pNi;1<0hSAPwaNLUyB3|&v@2voqAR>N)-V{Y z%+|7)TVoa%7iKCb|QTlT&Z1=A)S=31ioR(W1FOA)c_!-mX}ryO>1G-i1>&W zDcTTE{DVd88mRZFnKE3z2X;?IsB9aHYj0Rif4d#rrYW?#)1N?so@i0w5hk+CW`}xR z7oy!hW5o%kp)Wz^3@vRqB6tWNK zS$|zLujjR!(Z6}Z#l_t7dDdA?TTmroq1sIlgo>gnYnR?_Boa?d?mW7?((C3sZY!{+ z1ynJZ4jRl%sgag$#ybgClbE_hfocV;16VIiKqBKrjyh3MupP-gm9(9hf)%;$s}*Kp zS>s$}Y|^%X|-eUyRX`gPj$KU z0kLJ?r=5DJG4WPxI}Y`6z27*R=zaug1Bppq89xMmtx4P@1yfPXShxm-++vB5bg+;% z!Yq`zEVp5!#%qkI*>XEmw{4iWV#F72@^=;9>{`VenPe^A1Wn(+(YnL)O{8|?iYBhG zWD-VW+_|napgx%kf0klX$Jk>2MiywoaG;|D_Pull%Q(-PZf4HSw$;S0ct9#f)m2TD zwJkp`UzS7iMWcxrb^nCA{az7M4q zEEz-{x90dlJg|y6nM_q~EUq zto+6uts9NivK9Fk%XLnz4|8Ztq&Kpa5jWm1){p@1Ex`;hSs2p)g|1V}FWSNAProKv zOVD>VuIF33y7l#1$0#;kw_}R{|25I=R(_@38;f5zW*x#Bf0wO(I$8J4_EO7J9bAcT zimnH$@wddQIwI@N8&DV60m>5!8Fzkjw?Safc`=5FG<>KtC9n|855?QM4Jxt4KKmec zB#}zGZy*YIsHI!fGEO1(GgM30YEi-wu}`n!3FClyrJ5Vxpp6jk%#GD*&`K6SqS z_|~}(e0u(P@|arbHl9-GA_3atE8*;y9*?i5JpC@;Y24q%)a&^Lq$MEU^^~%r%26B+ z^Bo2;+{bq1FT7BDs2itm>D6PeUd>ysFKfY;_yRseWTX~al&q=eSCIE=->mJb-TxDE zpRaZ8wxPqVF0OVNPO7X!H@J5a=W^KzX~_YpC4V@3aEyXP^TackCO&P*kAC^-C_RO5 z1HazzkezYCrAX}xS8}@9X;5ma23WENB*p1uxIU{2g|~(=Cf;EGW8=oXiak}1tfi_m{=4T}*LJd?KMh?!F;&liml#clu87?bqa=1m4 zEkSnw7|vO(Y&j6c&FoE70Ilp+2#aKk;2_}}6Jrs$8vB#sS^=HSf zPRvB-dxR>hJ6Z}<|D)s>mo2F2d0DY(5_=rIDICziG#redo~y}}mr_(PpWk!lkde_Il5Z9SfK9_tzxuxW$O7Rk^-`2~r;$QOV; z_ysz4VxAo`cV{(oZuIU_(4?(C%k z5-l#RRFOm)WoF8`2ouaG(5UW;O^a+X+RI>u(=D7 zz~eoQ*b2vEJACTdj_ZCalQq3;q;X`6Y_oLDvz=l0r!Sl4=4$_=B;^SbfhQEflICM# z9|Vp>Sk5-gaMHv}=pi9ybyt>p!7F^zO7n_mz1b30X83f@6A1w-ypB1)jvbmw!QJ?% zdL={Al*hK?6>FHuJq?-2i3gR=0{x=fN zSBuX!=&Odc38Vt2K~rGOUC4J3Feu5`uvyJMjqTT%9(4oQ&Oc_swBR=3P$+U8`dz`q z3zQ!*6=)RB$BU^b6ybFsdZ7rf3&PMuVc$|GEO6H9X$zdSw!m2}3FJEOYFpy0rZ&0_ zPs-p)#VI2a#FthVeCh9PMKd^ynQQ zVqsYJ_qJ+zWpu?g9PR*1*J#R?!|TfB3*xi7d;w@T2xvDjMI(UbXkT6G{li|Vyxb)p zV5qEAIBY54-5}uM9Azt&5`Z^Um29n4D7)79!dewtd)0va2fbo>xqvLdh%pdQ0KZw_ zr$tH$zqNuN_q)_Hf}osdHxuhjq3Unspn@(XL&vFFiJ*Y5vG?)01R2PqOQ% zCEr8I>$Q$hZHhc6YlGDXBl7xma#A(k91+OKWDrM^Q1Hoy*(O$UY_g8H8e~K9$TwvT z?1n;|B>z^#AjovR=rJKDAFnr~;&oZ=O+>Am$~Q?+hJcyZOK-VuGUMYL`AGV0F}^K| z*{)-w7^=0_v&%haCi5S~GmKWq8pV;=U#%9IH)kD1Q9_ zvrdQla@#(`Ghf7k)4ulSUFz3hJ-{bFTh;@7_7+F*_@Dh<5;o^o%7iC=kA&Ce`+r|uQ;uU_AYn~@w9GN5gthtMGGXEK zmScaB@U>SZYuuc_(Ad=-lR5w8{a4)t(0kYd0Eh8*?AiuElHC~0|Fz7F|5$F^*gqy? ze_JjzgU0@&5Hj=JGxn!goiX-8Rc+jFl|C(+ec|>{AO=r^Tzj4G#UN-C=-RTiG36W zf|oxeD5rgtN$sOx`9Z{JABD2)bSQsyA7w^(3Fa32C>CDNX+xVIzK`NGXevHSWov~Q zE4NW5i)|FPiq$_c28MaZ6vwZO%Cvq7+bDpPp7_X5n?xpZL4SIUIIw)dYc zasCldj^Eltp2{rU~bN~sgkN>68OKk^2t_}!<*3Rk%1oJ(nZJncL?^R$OBvdy3ls4U- z>Nd7_6}~`3W|2&x0S>wBdJ0tq^4gWvcC7BsZj-5i6~i_&wsRg5-M3#jSehH#<$fzG z`dEG$ho`}8q`9$Ok$ODau&D7uXtG2^QDahSQ?F33fpYZPB2|(|#&#Tf&D_p`GVYO? zkFl_DzXealtX%D^Nh@k2o7IHlu?<2@lOhD{;FDS!R2ox zz`2gH58!448x3%RZC@q8*|Z&wY8)Tg4&fZm+qWA~E4YiviQJcu)#buw`DS*##pD6zTxN#)+ zQ5fVU*aEH=;E+uTaJ?JAWr8z+%h{wOfWydn!0W>-Me*9e z0@U=tQq~Qzl===fCaWxE-C`_dEt(N5rSx0r0la7A4J^e(#8qQCr#FHO1n9sKpmR1v z<_^NJ?Ig|3^#*>xBEXnTG<&15v*G>v|8Hm+LpsKc3&nDO9t<+uYXRTY*{mc2_?2d} zC>2E1ly~JbQVgZp5he-Sj>Oq)wnp5Q$1V@Wrn$gAo3-1(wKyvHhV*Ce$W>~ya;upk zwlu5Y8Lg87AIh4ARy!k%Q{)Q;p2A{6P&552)<;?mX3eP`2Ns*|tddJ5VbQBxXA_?}T1k3+?^95)3rOHotgAB~QUl{1FR#5-?};J+;Y z2v3Dm_8Tpg#bygiA%lU7h-1<^V+~Ly3M$}$I_i?jy784cw2I8+ipiEHh_I2NEf%CB z$6K1s4;K^%ZO9A!Xn}e8w@S9q$0&3AEYVzLV^C`d2@HvDJppr58&0a z*dk{jnm{(A7H&RP3S%Y6N}9&hg&}~ZBt6FRg$5C)Fz9+mPZk~h?e$61uQ*EK5dD_F zEXu#C(0dFd%Aa}R-{GGNAR`6;itPl^w9OCI+vO7O^`QwqP?hR{3u`d-Bl!v_S zqx?Fu#gFXb@47oy?>37@R1@Jgy2z_KeZfjmli`fVF5bC`Bgz_-Zg!HaX_Y4YwlvvD zC^btq1b-F3tcL_%l}DZMuL@&4jcJ zhL4rv`ECCkFOGAjDQh+Kqq)FSGW-*jH()^q&CHrY{X- z3Is9BcnmbrYU|gyt(-I!N~Vi_y#wPY;;~b*h)afRTfjpus%G#cM>^O=cR8HQH-4)2 z@uFgIzbQ)tPY%Pn8)-wW$R)@TqN{BdL>S$~QbW%q&hWZ7=Xxdu#~1s>9AI~0jbq)5 zGGHS#l^6ahA7bi(VGOGDK~)eB%tlJYm?Rb~Tzg zsA<6t1-8etiSK)eNIB1M)0PZO2g+mOY7c8$g}0qt8HTq%dr?Xu(zt=1OuMmmW9Ndj zvS`=C58aP|0!5O5BDCB?5db;Soe%`DAP7b5ia8w*p|HBpEW04o^0s*si=zv>w4-GG zp;->80Qh7}K&`IM3+esL^V>RhH=uq9zaatoP%aHiz>ZM@JwaGsff_~{Egh7k%m zG)R6K1ex0;Pet`Q+2SMSP2O=y7%Xp`jbgCHP_YJK4Dg`>0f&Kx+GMB@C_^3dp<)FI zL!Iai74+6nl>%^#l0o>1a+TTt%_snH zNYHs8Axc9~f!Q_K7Xt@G4+ma}RjNdxtp1Q?8ek0_sEo4lWQ~%J+MoqUp&8-djxHQ; zOkmt0N(Hz0-BdHi6M--?7@wcR zH*&;NypQ>SZB^!DXI?AJ2O&~nKDgIf7Xg&O%$Ni7p-zN~#J*uSOw4$U0b^DlV*fB3 zJ{UdsP+ncCqI`ky5{r)Tyh)f82yfIaglBL`KBp*tG?1jfP=kqA@tu8WG6>%%9N&?H zC23#g`Y0DuC{9k>B$dPs3imKxvcWN)sdiLnl7#UhZWR^>RVT|H4`4hw47mZEdRY8d zkSzFvG$7E0x})C(<&^GnZvoS*rBBGxmPY(l1oLJQwZ#vZe183gw>XvZc>K6~N!pJUho{~OX!dHK*Ksquc&me2KY>&VCd;iRxcAdBL!x}5c}FTc7GJaO}|cjZJVMhD?$(1 zTf8$(i*qdr0*a7-4a%@UluP5}!PtN_Qb{Uda);LO+A68%kE7U0StfNC6YsjJ=}@qK z3c4tR%Sx0fHoXf3scuXh86?UYF3M0!f+&j!7FUQeY3vfsN}>f<-T-({l+h_>Ldu&7 zueQJ>QD%Z|LN^2%`(_+AO(28%941DP?1|+GM`1%?DwX)#)j{74;zVW$dq>IRwuWSj z!ZjkZSTu&KW2qJjXr$*sSc)8`wZ~zDD$kS$p|6Luech5LSn2*`LrZ88 zlm>CZ0jcSR!~%J506|Ca6@lshuB&4zU{qGucs>K^s;;0T>jfQIT?xf`Gqe_B`I@Ux zs>w&6Ods*Z2GA{dhDzDWNZ-AtVm)W4t-(#3@yaj)qhje(497;C?9xC*h-ew?uR=An zrr)4uIaodnaVTOv0kVSSg-U=G@KkXCP#sVY0%ju+P{}A*lo|ErSmA0G{6w(m*i=xZ z!t|JNM}vO36D9Lrij66YCeL@{<{l1*AApQ&{Wc|Mn8jaV{6rVRCn}t{717Hl8j*$d zonZM6zQdadqOG}LoOAZnmB{=)uXD~kuW&a0qqep_AKT)bRrZCr3%55CCQl-M1`Lus zx)aL49m5cbx@Tpz5}5XCi6}K);S}pEz&U~6A{{fFHC8m<->6f@*vJmidy7&JLg{Vk z9|3+gQ-Rw)LS$Dgc=350hiw;H&yv;g=Sq-U$W3BxLT)?3NOUuUY zltv2x`H_CHrci+PZA@2#tuih^2lp{4<|DB{(0$F2NSRv$xx%`ZCnI6w05Q{_0m)~< z_^sy5q8PybeXgj5DW(@==^IpVuZ5x4O>YYRrj#ofbG3vtX|#9+>F*MD(8@K6a)n6< z!c;k!5qMH*SQmQ;A=0O9R)3V^~k_9C#%(|hEl@?7V8NT~x<|R@rFPkVts;1P~C&Os?xdSiE zdKqT4p8~>6hKV>IceR+NU%*AZK|3fq>ml=eCX=C=lofc?OajsV3J8e-fEZB;Swh-* ztQ(6j7t?B`5WmC-yzx0lqsny7^~&yzJBybs2NdSpz{@UkfttMmf&YeL7TxYjJS8S_ zHPG#jUmbjd86m(Iye+|F-MNhP>c`keOXxhd*Z{4h0;vkHVO-86^Ik1K7fSXh_};SQ zeM^>9q;_YS1=F~vB;mI#M#8i?l7x+!3=+*Cj%nv<)Fiw-3SJz;tTTs+ZX z$BSW#l|2xMw>KRJdSwqTRkkF+z)_341(b~*N>nKzNpCDHu1aW4kfP6C<;Q9gbSinkvP*s?^ z9{s~qHLKkT9paO;+=X!%eTAzJ+0_MZF0ne8x)c7(#!r+u-21hdLi+)a2Dzsp#jW0>-pt0Vrh94OVWa$nSwLx5y;MkH38i}%gW$)h;3@P zlH^z#&~*#}EhHKW}~hjHFiY1VmYYYvN+Z9`HD)T{>>XtG$#KUho*hm8j!2XYS_KFT6jw7E8wZI`G4xH=)p#q#}FO~7qtlEd4br>TIX_^ zUkRMP39({HQ4Fq7;I%D}nG#rlYvdEyAh0sj@?xcR$slGR4@7`%0G6EPG}l1c`V~8auYH4lDh%lx&M7NfU67pWN#1AT z#R$^cT?p-tm+da}%09hx*%MY42a2-niC)>0OP767vJ(~#k)GxN(ZC@|?Z@x~%qqy; zOv8?lI4glFRS|ov*D?Iu>+W}P#Ii|v!O5uXh-U&rbO^`sE9m0jPIbP@d8}$IVDU)2 zke%0%&p(&-$W%EZT?l$0(G7AhTpv%$(y|a^wpouoM|=1Af^9b?*r*mFc^K6I6h#*N zl6hmOvJu_I3Kiyx0p_*Ic7LzSZgRW7M+&03g?B7acD6yUx^qau^emM#FcxwIIP0b_ z5~=Bgp44(&&oLEFF_9kQSFQzEV*D=gV{|E24(r1j_2(`A&Kmo*i7xMz2vC3C?C+`i zb2smcH`d5+_`aesvDKnUxu$VDd1#DijdoL_8rYyp@An4QYdH7$d#0eF_wr6w8yVSb zWMr|CVWUP0$CU;bAKmLUI$hgH5h8N>-Hp88qS5IBN8UGe5&XKvak0@gm21A*;OG$w zvJ71M9Cuw3FY-OhRI6~EOLF7y#S`iKH0VQu2AHkn;~|;B9VD4^hB1bJrctJNZV3;c z0m%WCYGvc!n@w0nfakE176TKd4M@1yEr|r7*V23wExx?hCfMmS?WxxRPpyY^IUBRo zfUyQ2dYUyX6=(`~O;b2YYSU5yuCRVF7}HyWu-SMGWd~s#8y1D$YLS>IEUovpfN)l` zwt%s)xBzfgw^Tq3K9>+K;G4zv6$lH%`vEMvc=_<{>oI+$#|Kc13@e7=D^eJSuZUt8 zz9J7B2?OrI_W@F0A^6fydJ85m2H!_%YZ$&z)DrL&jrGGV`oqDKd=1qPAfG zi{f5BeEWJkKykzH6~ztXFch~04vX^o;VY_ph2T3tb;Ix#)eXZ}a%>pBqPAi9isD`& z_zqCqFno>Th5_6s=Z3lPD=+8zuwsDfhG8tK8;0@iBVjCR8;0@UPR`YqptxZe|3i>- zeLe1{Iw?5PXQcmhY!eIprtMG*@?IY+%0p0AGW=63qRmy@Y_g({m`)gHt%@=t^)M*8 zt`eeUbt$e;P6teu#y2?>#X;F zG}KthVscSyC}X~`CBd2}aGR~Vl*4G4^_s7`NnnDtNFzbc2qdIRFo=@Ik9;AvGZFNp zrqy6==Y~l4Gq2jsp4Z&p;D#}=`(a)u9CcZRTZ;em>FJtBx2ImpEa%?}{>}2wuDj(BdCWM-cna>ik2ks8To5OT^L>H@ zo+L4mQ+DR>f6s!tcAhZwTuo_dx{yqt$(VldT3KA|yE<)s<3;|CtaB-u#T)4j#;;JJ z8l|Bm{cz0a`Ee+0%JRytfO4rVZU<4l8*8Uy4S8ejRLqTUJQs){t0x3X)XR;vBQZlN z%JdJNMKPE7ab3{|ubs@fewIbAqJHB)+DUj$(EjY*26*jND2~*T%M2E1&kFEAMqi3P zshgMzbi&_mY30LwEdT9TuG;H)FxrdZ|=-gS9sXYloI(bFw-) zh$l1AO*~i^Y|vC^%ek2v*B2X$4#AlFtWA&tSoOE|<7I0UG@$oJ6DdKXk(WZ8Z`hfB z-fo|@p}n3K8QQHp7}_lbjtxJvW$F&)F)nV;V%zA~mDpf7@N{n~@7%I#=jaBY=2pOd zP)}5V;oY-Z)s@@n3NYUi9D&EORQH+Ark^Lsi7-~#!3-IMXVbTXe?EtU<93SElHqeJ z^BAOvady#!IxMJ*{W(WzSVJ)7Qrkw18k=kPcqiWM(7D^8a~Cdb?FX=8t49i8jLiu* zcOaMVR{X9yIL6!=Lz+l`Y#c-8tmVuSo$m)R<`Io%o) zF@*pbZ`PoHNLd@|G}pBI5F*;hToLAj;FQL))2teG= zclMGUP#E#5fI0@C9_2fH!oNS=|NSK2_rV3c-|OvqRkFWTM8*vZ;DnI_@}*QvdysWv9hRilm-5$xF(LPNi3N-GX7J87PH|mc$2=D6My1O;z5{a zE7z{XIt6AG&Rd0M6R}QNL%jwDYW%1{bGSwv`V7&y{|@+yu(;~P>JyjLV2u@{?&}I_ zyA&m$wskkq_LyN$dY6OGqg;i_3%nEFXuNYiMBSG0$gUqK0cb#`(ES0DUu1%sOHa_Uk+Y+QWi@u`Rm>35 zjcvAWdz;SE_`*xyg;tvH8%hb!>Q+%Ekt2e`=9wGJi8V$!tuicZ*WW)Qe7p zIw&GBu!zGk0j9!yu23~9S@jtAfop=$X}I}x!Y+ObGn767 zb{g=3TA7t06L-Nelw3s2DG^SO*IhaX>25d;2Od6%J)< z6o9RDMMFpFW3v{2ZY3VR3NONM69D=-X+KR3)=z~>j5(TsRxDTOL_ykuYS!Z*7u#f3S(Y?`@ZM7ynKgmH_q@)ILEB(J5=l}697nII$(zlJ% zr8TyfFDA35b3L1>qB1VOc8V$vz$aV$zwCNj*hxCrwtB+s;HDwReeYq$c7$n1q!mj0 z^(gB~U9X*2y=1|kgtZ&(O2zj#)(Ljmu};~rpR6I<3MyO03QJmxh6w{a%z*Sfs5G6} zPH`() zja6Ka`}~15yuV}qdw=MtBgA$|HkLjH{5(?xIe)!X5#*BmC~=rHlzE;u^xN&qqq;4p z!oexSKEa#FmDxDw7^tT^v(YaErsKe&+pwST4qc~*yIVKaJ=fk8C6{H>;SO2GERhq? zy#~56{mcZdT6@c~nX;LNylK_HS4DLEAJdD*wr5!q)%I5vQ(1GSdvaxw8V%*na@e zmXC~J7-3|(dzYokL~$waVxaXw9}!fS8Z<1$r^!J13~O?UE3keX%u$p~g?dejRcVp~ zB-#!OPv+NGqe;&AD(Ose@|MlD`)QoFgSIpU*Y6QEZAjjXHpAm?r-{9UWmK+x3R{Tv z4?g|_t0Y4Vdx*y-qlM9R`ZHF%M@)!JYhW(vUbk6GA|s=NG2D#X_-O39C-KxujFDt3 z&17OU)1wh-)85X?N;^MWw1Z~qWGlX=PR?o^EWcm|L0Ybkdquwn~Q=x>tg}lZxnO&+bJ5k^fZPf19 zmF?ym;W-?&syQCj74O7v-<;g*&=Cuywvq{Br47cwnjJAmVB<2RDb`{JyO-gI7>i~G z<=@g-idp(xNY}v?KR<^y=4{E9AC^fBMI+;{#Mw{4TFrEWm~mV=i1$}145=uzPgTM? zv3YT3Jq?dcEF6wqe?Oqgfj)mlmqL8}_)1G=cexUlWvkP>RI#@=A1u0b;|aPQa8bS5 z(j9^Vskh5tV6g*kprgH@R9)&V6rT` z&X)Ytx;PZ>9tnjvzdR_wzy_hP>Z+jd;}s|j;>jxm2f@~%01`Palsb;F?eslO3s6Gy z1i+FO)1wXw+$(P=!wc9>ABhNMMIxln^^u6$xo;REtFH;knxG!cH>O_XYh%nLeQ>x;D#I zi2%K(()C$q$;2pPM${JiY29UD!OQ#bw;ao?*+`bVcqL; z#XgnmUS}T8pIG#b@<3mFt)3w&)E7$jVj*%H=a$a1!zCQ^`XXD}dPa znRi=gBG>388BfbgG^-sG?Q9t)| zYN-Y&%$HFRW0P9z_6#w;GyM!%@)M>)b;AcXoPr)>#}f`GViQaW?#hRfZsL=x`C|sP z*}54V>`ghZy6eJgP-rz)SXkY(>hgA35QoKq-Jfo;4(JZcv@%%*&>eIpOEYJ?~kl^LP<>~_?T}37za~^$KqAJ#sEsFxBSNfl4gv1BV{xW0(kDs znxSq>KSkYas?mvTB6KjOui1F{g9UzA?r4(`L^eMLP8t}Y(<#B%h~4Pqmw#{pz-eIG zHSYn=&xsIm8}6V&D4)GT?|b(mg^C43kH{bkvk}MwlJA2k)A?&aeVsTeNd@h;miL;H zUoE`Iy7#W1T%@J8EM9%&foAX4Y=}>UZeL4c(bpdkh^t>q($Uv{KlrsIBz@gG__ZV} zeSO>D*OJKe_3eXSOOn&q9~}Hz5}>~B8~j?5qrSdl@M}q&`uanIUrSQe*B>sw8l+0H z#R{44_iw@snJ0OS1&)|3ME{R@QQUn*p(5)e|T-+Jjp3Q39B)E!K_#+6V( ztUNTf$@mcxczAS!+(&{qR5Z+eIN4BcCtD}eU$V1kkW_l8sTc%y$VyC!gMZ~XFIz19 z-ssLdTg1a?kPYqYF(}``u5{Q2dcHSMqzz-Ss4Az^f zpZnO>O^h0TzQI}6z8=fcttr9>nuV32sRWi)48~YiF;ZEKvoRmGAJQ8s4wgbUOX8R1irv9-p2b zzYhr&X|Om+Jk1ihQr!|XVe-S2pg8{#u?5qWZjKf#dNFJq8?+Rzc`01qI-qcgv(pZ( z`MD4W4RdwMX6%_b{nh0zD|`Y?4RaonT-J==z|vne5L0e1Pu?z@jo;rdNhr-JRd`>2 zIRC9f3&QF-_D|li!WoIaKv}|Om)-?&SQ!l0o}TX9m;?snGz2aB7X&<39RDW%hSt#% zhs#<|qN5qJnlossoGB|BE8S3LwlvB7C?Jv=qGXFRRb>)>EGrlTYqF2fL%AyqRAIw% zMWl*KY&O}(pP9c^g!Yi029k`^k}@hEr+;G_cNFS`<3&fsw3J~ar#%nFWd>2tNs37drZdQ_Woj$qwz zOBAs*qM(s7SW*q#gpdreUpX~7!1K&Cj+ul? ztI$tHT}Jj6G*Z!)$xg2d?Ybg`H`#~rVO^ORHo^-gt+vSt#d&vWDi?YrTTqCvPIul^ zs?Os9k4z4+UmnCzPx8PkgX95O;iT+Ni_qa51-?C7!M6k2u$+9`^-0SYo^zbiudk1c zIr_pA9rsfo22WQTAKZ!^qgZrS7MjxQ2^fb$&PuzkV~_cBPk_~bHp^m&a3!*?Rut%Z zzMmYILJrAga-1GZv~hTPj9vK;dfD*h0A)k12YO!^TplBj*&|irXHv3U#5osEvO#}t zO6MBDegb%iWkg#cQqgODV{#F?oaGxgURW72Iar}enqt{&AqPp$ze3&lKdFqJ1y@Ye zgq(P|($&=>OQlTK5xuOJ={EgTgHQYLF92^?Am&%_T6X<`o&JroBsxnBIxgl-;5dL59(UG=SzsYNyo?l#}y3%NS4Rl$h3&81*M=(YfL4PSN#8jg_MeD_r7t4~y{bTqV;>4= zp=iOY9_Sx5k+FQxsz;OfcQ9xz&M}uPI@X27#!8VeR;IzMaR4g+1ICkoGOFOB;*$d> zMcp+_&yO4-%NquB6!;317s1!x7{FHm;&R`o=H;NQZ5@gcj6zxC63pJ20%hf`Y z4Ji9$IeW93y)aKilkTXq>LKylh2^3%Qng3UzO`NzR8y~H!0?uzL6;-76<$eYUa)9( z;@XxTSJGQ%L8{1iZ-fE58GDk45TW=v#j-Pnq#)fr#GOPCSk zFHW|BkhyXVy%x|zwb&?;EtmMhx5HAj$t9_fKmX1J$_bH7>nS8# zb$&+7jhz;$n_^nm6z5U;&lZ~k!L68p zFtrGZ#V0@$3lP$Ozls+K(3x%t%~oYj$Xd(^hcv391!$fT#2lIs5YQCr!ji?AVbFHf zhC}j#hW7f(&`fECM3@^BXpIVq^iU9`)h1%$Llo~+iZg45!J@E0Y^n)~y>+}&6MgHE zLLfGzO_`9t^P6H79;TU>YR<88*! zMAjge#ECJqGbO{&@eBv;|IfJ!RSqh-wIq^T|L*wKEfuzPWdBGUtxnGW;B2cZL9Uux z%}b?qZUq@E#jTELHPh`;uz10o?p>NZeSI?K%b%Zxn*SzXguiEgc4IBT_TCO0Bq{)ltG+r0g+qcU; zAh$_rMO?CeGyIp{kyKYw)=H0S!?G+yNM0)>FF4EC%1<8pSd_lUE`DwMXgJ7~X}Eb& zc~=&htFHc^2}*E8^+N^oXL>EndJDvEwHCHa=I;ew?G=;xPwKgRGXE*Tk7H%+Ws~S2 zq@|Pj`}E|hubG{2Y6Z;T%LcXcyCSSKdbi|bzwkyLU|`9^AGCD zjcXs$ldE{1)RUOrM|kE<^42Hw59@so?*y*?Ii^tqy0tp(#Jth869y;0IsLCQMD~(_ z@zr{jr-F_{D}jZ6`d>-dK$IDL<58xv#?8?|Vlc}BsCjI^W-|W|w5ArYVwIR>RZtGE zYy6H7iOmfay1cdh??sY)|B;GhZQQ1X=S~11mmzW zK&2VJtmwG#<=2sHq;X?~)P*qZ_0=Z+f)4kZxc=oe(H(4pHfuQ%_HoR*IbxUQVQmLl zcljOhn-2d$WIblmSb4Q^L9YwO`JWMrOKz3sv)4;n1zFnFPMCWh4adhf5IL%@N=mL| z^#Y@6zI4ixy$imd%%wjKN4nL*}et(+cu@UWX;Rj2yp*< z19vM3;cmg|&FOJj&;kajD?@|{aQJM98nEiyl0$L&!3s*PD@Wic)fwyxs3ccl>s*{4 z9_-3JYT+$JQutAY%v-86)I87`5p7>*ZW!py5M0*MnR8`ljt+L_UbS!^zA7);8ESs9 z&a55i%(_9yKooL}4v;xH*qQs)!UMRGyl7{r`NcY;T?Ln!K1~SGhCFuFxXJkfH9$FV zGbcALI6qWjFw67-CTUDxDB&brcnwA}W4Mz{I6>{m#;Agg%G$J%Apwjs*>>#2~mK5uo1SI@WJ=Bu32xCR{$JZvy zeMOb|F*qDaCy;eK>Tn(&gmy*3A}gx@)wXb7EM6gZV#(!kN4Ry=&U?w5)GWYzWZWG? zhId-jU^k^?b+=6vYqqSlkni~pDI@v1hd9JMmT{bD+E*v}KYge(!v`r-Y5t{H_YhCz zjosPI!yRtrX5jk7DGKlOB!e&|}}$Ld=~WmNSY3`!<)=_N;t9Ql5|eQc%j3Vc)a ziiYlF^OiLV9sE~2r)!O<5$fVNj@s!g&-YNzRQ~Eax-;B4Nxd^WRaXCHfMHj6MsyE) z2s}(77i`LFWlC*KXEPt!+IqY@tCKiWF~GcAGXWgbAcLI3Dr_@4oy|VUd9rL85KZPR zI=-bC|_TwN8Kpci@Tft}1deN(vc zCW8j3b$ahZu`9@JL^IiPF56_9rZUvPSjI$+n8_+Y3yu&@#ijrxi1L#KfQyXmPEdGP z2l%rr06Rhjo#_BIs^`;+q6sRT_R8<_c6aeD+yL$^F#$9AGetW90F}Fi{I%HFY)~^C z$6FK;-fbYu-8Q+*F)ZJ*U0S(*b>uBDgZY_%J67+^CV@e13mp<_ftmoA79x5CT7s34 zutcStGHgVVbZRK6Ng^cHra&wI*V;X8i)NY+V=ssx9D**;YEx+xNsNe^mia*^g|^X< zGS>z&*OZy+N;;x9b8}DA!8W-G@dTcVYyQ!mSa0{`}Z zqM(xHbZiA!GfkKu`k@<9Vbv!;_B6ds4_rHCTWc*X9HK0JO%&x{I%R=*1-NdiSpty6 z_Y=~#3{qfSYK)=Pou)RQ;_BaQ2BhRZv-Q4C_?A1teV7qTj%?;8!042(S26)_*rc%_ zMdF}~mX-N0vLXQN0{AvxL^({{6n$Vf0nTAl2WjmBSi0kzkMv0AsWrdQiC8355E-Ld z@3cQDByZ6wL)2hJOeFZ+>1b8Ho+7REb9PFp4JP1!GSPv6IA;wCs+VAnF7#?@R+*o0 zWxE=%dONKuM9AM3dNl=1>t8l4fVZ+~NRGK_f&Ox=N#KyWQ5Om^Y;s;JkT3&>eTm;TxPmjCmE>CYUo^xqsz|D>lsJDC2A*Z)UFy7%U@O654ary3&I9^uC{LHQpS z$&l7pNm=GprdI>o4#%w|P(5;m`?S$>X9Q8+iHXGKLHbK|_^;lC5g=3gQ_S$q(d^WW zW_T6oICre}z4_eSNvLe@z{x#3_%fxhx&cjVkxVH#EAzdh*F<}tcw!;4r`xDupaOFR zk1Xa2QKPjnsZiUtsdgJ}4yF(OOy@_7OcIeo#woA~rCz7`rBGeudni}KyryzgKAoQ~ z%Ry=4G34gN#6y~BUW_fZ#DXRtW(H%SEkDR>EJj2_F5^eyD3a-Yx$4GR7j&t_;;>1N`7hF zmxfaIS5r_OAmk>b6xFt5O{O}^+Bi^H!$a&{Lzm*y$KI6)9Gznu9F3I&N3jb!I$46V zWbXoJs{m)S%HI1jJ9}?dpsFfi>yusq;58Y%E1Q(UHwo8iaZ^ywleQyG{^$v(^(1^#E{ zrwxyFyS+~poz5>5k{U&!#Z$w>{p5u;gF28=wO_@$(pZ=X7lr(1k+z_q?zx1 zhWCT~Nxz^V8pd~%Jk!yk$;tO#pG$IXO=LB*%w@ftfBJda`7*7Il$9iQis8W_fzx%pa$ z?z7CTfxbKs)KDpT?yI59@tmtMD?BeJ9(9YDMHaE}e4>bjx!lR0#X3S)-XF_l)MA?K zlcxzWPVh$Y7&Lm~Q#Y^Y3Lss(X-9jK0RBnO-|_vES}MmQ0Axg1X9oH zIq|yajGheQFin1ecXcEEa;-Ziz-qy-4U1U2x}`@4`8OuF(j{$Y*%3sm2}^|4yjM?J zn$wdW5aCT7dXNYGyPpT$y_W~QzlR5dxtj-ZUAFUJsLYb0xiEX`xXhBYJ^-1}<9EbP zUo7TK3u@$CH5g~=I$NE&Y1;&V`8PJrOn)OE-+>CbJGa~hi4d?W0jq3|iu0DzAr&T8_GukZL{b}H+{TJyQR(+kyTmhp8SUBKq zTO*ucgn7UOmumycMLmJac|8HkIXyYAQ`6R}plRrAhdgbb_1A=Q0B2Zvv1b7ofhCUUJf3_8#gjUu& zF=PZEjKKSbVE`Rq&1)JyaWrkLSz9qsn%TsiS$a1-So}h+z*Oo1gt%wxt|>sPutT;D zFc6Vw0?l9E(=6=0fW;}IqjJPFP=OsD2hYQi>TD(;)8xZKs%JB4qt04gQ%O%1u&2&~ z%Z_vP^BfO_GQe{*YB)}9B*!_RIWpf-o^TM+>s2uwpEE*Di95ZuA?4GFk03=(R)Db& zAHf!*PMzs2bCAZCU;ik$jI?j!=IE0%&@hx{F%+EplyshL*rU8@AV>6se4pr1w~dEv z`lLX(gw%Pvy^4Q^DnkGP84IkJ>XiY47hEuP-!nxv($r@8-}Yd}&V#}1n6VnL(TmRp zConH{5Wm=Cl(+E{v&lhR>5_VJoJzr$5UUcdYFxV4M{((Vq2Oqs2+Ab+wX17gyFeog zYUFg02g<8vxJ-uA%5bj8u)jaUUffd78B20Nbtf(Cg=xIjStdsN5_PmXg52;zyruNl zr#e{l96hNVe(Tez&=8XQ@X!Kcf)ohT3;`24`(6Svx7&aWKps|d&IG19!Ywudd8LnI zM%Nn3u=Nt7(WHxC7+Kj`#v2H7#+V)5tr9u4lXjn1>@Zsp>p@er*-Pf z8(0`qGh0!FWE>oa6tuo^Amr8h>B=~s9T>-%B6i{;<9MnZN1@tO$0EFhrM%=xs*XiH z^pRL+H6sQ0(8MA>2yZBLzi(*hEmp8HwC4tfcD@KmxX92vO5i9Ybe-*QJFwBnCXs4L zW-*{aIt9!AJxJa46opDKEeEQ97UC&GC7co^A$pA!5em@MB0~S2RyxXvsZ|v<>xj|| zH4M3ONWTdHcoZ3ANL{F4&axB&;aL_lP`w**Ove?ml41w_=%(n)Xf3tSfBeknvfM-e zWyB!Uj7X$!03#FvK`L6%Pl6s6BrF%gLAhAYBw-QJGMIA*Q-7){R~+t&bPlnm2 ziJ+OB55ug8)m{t&@3IHggL`{Wy(f4f781(?S57Lz3Pup6zuvl@r4yS3tjNXAg{VD_9=s-j?1%W1w%4ht!iw?HC0J20Q`~z*AagA0U=i$(RSz zFM5E`2(V}i$JX%i0R1KggW@gpeu;ZXC+)#Q2@4jBZ*20Nre#XnFd_L^i)Ux>qg{ z(w>k>_g1_s$tw}=$AIOk>g9O}hj!TM6G#Xu_owytDg@hcROmmB^8LT~6z2eDXpr~~ z3SehmS8AF*ZeWUP>7CXv-KA-TS4Z1Sb%@D&sMqn0euB+DHH)U3LVWRzt&LV@Bqll?ZZ z(0#391FY=q3rCS|9W{GCPl@Yc-VSLO{S-7{EwO9e{xzA%~)^wlM$$%6@HWo{mr$NZ>wdPfZ{b~#(%4?QkdXk`UO$1^XEt+mJUXTVxr8sL=!cX2@jR} zt7{KpPT+BW;bf};X32D&Zr7OZb~gFl9ovlH?LOXUl(+BU4ff32|JLCN&Q$uVIGg?- zkoZ4#mUS7c5Ss%lIWe`dw&gLD__lCPOeB2SVxPZXU)T+x+f*R5jhE7GD%~ zw3IeYy=H)GZr!6Vt*tUH*#GwYPng+zRkpI`9#tk>9tDWL-UAgzJKx2K_rI#WZ1UT+ zmQ<+O$cJEbu}X7A#t)3nXd|+W9*i`b{F%`i8Ay-PCU1|z|L)6r@8A8fP(qv3>H|HZ z*`K9T+LkVe&So71FVI-rLda6$bv|c`AY@YT0E);rK`2@&D6md+n_BD}Eo62k*N}y+ zn7vO5C%dr_RDMH_kC2d`G(jEY163qQ(!0q5S1nLBWRdTvXIXE?2!7yUgaXNfWqp!< zXk`z>yaov?Yt3HZ3oOuOoprcnP3zN?E+EjL>ko%)k4~*nE(qz-ZBwi4)iS^Z0@L~* zA6OTcUlp+ALSS@L0E->oL14|`D;j{c(q8{x2dra|PYfW$hZ(<1d|nhsNhlUD%e*8^ z-~`M5mGDiiM558-{9eowKKn#}LPb4b|~u;~h*=et9X3$}a>j^0P1~ z^RqiVGQS~QsNd!?)GvP^<2@>udAGv&q$e%%NxDY)Y2I9ZF08DzP`6{L+q!Lu;Maxv z@lu|06F3s1tBfacGzkVf`N+aUy}qs+RiDZ|LAiLk6)xU{p4Pme!~*7hur(DTc7_V!3X#8$oxyRQg#Ex}-#Tos#iwM82J}7wqB)*;hadG0 z@3vdVRWCa$iIjx&k7TW;oBP<1H-?r9Vq3KeUZVLV$+Y{$h|neqH(*!g_If z;6Kl#S1@rNvS|a4$#95_V{AO1Y|wpLcodU(B1L`N^?Gob)W>LkEZr-Ph{aqNytChC z5xOkkdV2U8Isn3imRspN8Qz9uxA*$NP{f>lo9TOCgTf+1ko);2ZNH&SJnJ`=@pd!d z*oMD{kBb$oK5H^G`|Q2)Hq-~rd#QU=iWP-Q?N=#;C~fa&*gvBEberxsd)~X1mx)wfLtmfyKKzv5zvCw& zsKn3hES`m*xlZ)3mIIUSqRt7B)7pS$9-5NqTcCI|{m`^>-0rPz@o(1ZA@vZ6$Pip>%7_pIP`W|=^`4zwD=wB~H>F+7%H>SQ0U1z&jSI*d1 z{+?lVvI@I=oW85hPi-!s@p##Cm6U|dzC=527Zu*qs?)9&fMmZ*Ey5IPTN3_*8_AiK zTw}ocT`Sq5k>W&e_N7v|x>U=44N(27yBCgbomQdyE$Yv8nu0Ok)ltaIrh<1p*JcqVu<+k)pa zy-q(vbqD2l1GKz%+4Plh-W1j6Fb9*cPyz<~o_gKgF3sha#-?T#uu3Fs|`r*-~mewiW9e*GrD#u=y&6Ub_|O##ssrr@H@ zxMOOFnz8v??{Tf*Km0q`+B|OWuVK8mMW5Dtv@zLj-WpiaUz?m&53>bCgW?H8|GNKPGUE>cH%VZ1CAqKwnIM>Nf+ z&9bghPkw4PX}g2}Ib6|e3S%trS*}muuhdBYrGbNJA4D0){iJ4tSElrP6v~Lm>*k+4 zsce?DK3$8WB$kEW;?3Pd5C}nBQ)eNTS!8m+SuoIDBW&YR&0SzBkL|El9=D@a@z`Q> z%gZhK9-Cf_@+>rUra;~ML5aC|T{A3$dQ zGWARx$9>Q0rPDaQj+r|?=4SwqyX=#qGYu@&ZH)q$I1$8tt5SN~4H7U_0iU!=oa7%i&R(YXh0xLvOt2 zp+|4r0b5a9)Mc%wB*NQ=h2NrYnDbAV! zI&v{@S}XYox@%??pudC@2SEfoFH z$HZK=x!#QOkF(u|c0g*~ifD6>2KYDME5a`^rDH{kN-B+87il~$dyfg3p5Y5ft$G!Z z2(Kou9mx&p_d36cJCGnDbdfU@7m68jfG;2uDw)C~;Y0MDJ{9KUuKd}AFv_kUL-AHN znaJfKA-qk?aszHKr4<%Da{^c7OQ4jiVm3$myh!Cft;pr&HWX@5Jgp@H-CXrQR-6=a$GGk{-YT3+_T>|rH z{a4?C!i(XJ<0m%YW@W(Wkply6h5<`PFklX66a${t;Ba!SgNem}&1aY*PC`QPFklXE zgaJ3p0T-Elz|(yLZi;kFFxlV;bP%bwG3iAL38aH68mf(>{?fZ`+;DE=>Dbov>eH4P3$6 z%4meO#u^^TUA2rNqn25uS6apt+}ASmOTsLs2KQ-Z!18Kjb&i`e@hF~s8uj3x&@pt3 z{AvBTBB;r?d8uzk2QF$6%(UC&D(#1li zDpHtk+A+gY3Qy7aSU5|l(+_=OxRQH_htP(LVWAw@W8AwyAlDF#q2ynB;f3fSL&ED} zGBlqx)CK{&<{W_h*6BNzsyFJ)@w^r;l==wG7G|VJ%Ew0A|xFN93MDtoON(U42 z-}sq1p;)R<~ zmDA@udwNc*a@IchZ}=WLF%dH_m&X!9%C9#`g}%X1ureIMTZ@={fsUpNV^h~!Nm}}j zWQ&%=n;2^wJ%{8;Efc7<2=W|}sCDKo-HFYStTh(nnN+51bHtR{h$)k?5L)RYAKSbeBh*qtMtIRRKt+Z%_kcAVCFtP_@-m>1p$ix+k2$|nRf2@PG?FoIu{R#z?N9F_u zo%{}4FC?so@osuR@qo#`$t^)pp4kv(+7lU?-3yV0Sbtq4QA^hCo1^P^gHkrYm_#WX zqc@3&YFh9U8eMO!xp4*&VM*_YhXgWm5Q)REIPS)NZ-+aQhsgJ1ZNiNdu|;3NKF`QXtH?OsUM?)j_Nm;gcSxx7nz^6ttHEEN5)3wTW45k55V+UHp8sw(X<;KJ+pgFG(q zCstTAHz;lpE|lU4w`S@UBHXgMmW9z7W!2J8Vfj#{umbnYGs*ibJ>_DjKT+(2jItY} z9gaA-A{cPOJ*yFxs?u?ed=hUm{CXFS0Pf&SXW3gB+PO=G84bhID_f%p&oa*XUNKUO z>pw6LjGD*{O}ZP#EaQ~rsTMz27Pp~1Ev;j!r*(KIk-_3FF2wp22_vISETtqQ92{v! z@XMAaByI9a(>X~O@|h8B+CpwvM2~3GJam?5lgSM_gHHH*v(Ks7wS&#Vkx??Mpe(pY zlK-|DJ^M#%8&*ZjZ}i!Rm&UYVY~wehf^V=0cj%wHrihV$NGRT$J1C?0a%9mjCn{eU zRw;)nGcZ}qfVlcntZXcR;v9A6>wBP3PcfbT#!8R}?CkN@dQ`_?D*V%WE8Hxxujo;c za9J9mhE*h-FA}KtoN3{|xIC`!K?mP7LIsz)zyTrFd0?#2H~si53c=mJoDcyT5poO5 zo}JUpB#y_?pvUoBC2uW1M&d+~DC=&nAPyL8^XK$riJpF3Cjl|Te|36FQtgH4jYyzc z{&kiwua_{Y%L>%vp$-_mmB|0wr)%oN42dgJ|J22y7rf_N?e9Xii44Xxz0$oM2*s~W(& zd_5d7$`=kSh`7&Q0rK+L&appgkvS1!$fduwg0V*Vw|f`n$=BC~&}{y^Oes{vS4{b~ zKuGDolsc-|CQ~P~0jMlmj{QhKw+s{7>pOA&++RG!K>!9Mh>ROwfxVSFzqJgYrNTC>u*+Z&kz&iAh~3X-rIUNcb=GNa=e>QPMo*&F0Tsm zOzBr~t>ZN`?_N z7;wuP>cdTloz$9Ax++VA;0&|8(0IkplCbxbwjoB$mUh8B1y0HK{*0>%xb>cv4dfY@; z-$_gPSo#5Or36$m3cX7yHBz?02j=SL1{prRTc29Rr-{NtvYx+RA0|{woWF+tKgn-7 z@rdNpCs)aIH^9qh zZdY*Ym&V=Y^r^ON-c6(w;Md^uk3fNAalKy0pUx8AIhY{11Sdf*-6`5k@(=!@f%c=I zmxL}BYu?noIy0R=x9_7KrC~jHhP{LL{r?R-vM3En{_8_UnYYD@9d?Cert4uR>c?JKeOLq(26%3%H4daUMv53TRRhsuBZms5|AG7#%IUe)p{l5;-T; zCp&GlM8}U79j8mBnxM_JQxRNhViJZeu~E|)l}!b zg!nAy5$g7KYmW6?NL=Gz^}mechp+E)%#KZO;jEV7tI#`$(gC7&C%pFX1$6D=N^(EB zu)p3%gZMbom~MORo!7QD@t=4wo6^Rb?V(fsdO1vEza?w38#fPGF7mgoVjIvF0t`OP*~-itr4alVPlF}@+#G3ZBsO*If!Rrzrb;wC;{(H)L;!{1@<;m z%n6jO3HFRCnQ_jv$SW-OzCh*t5EaADe&pbks?yWBMaYzBY~Z4++7y^V7dZkzynFKIwOgNRhopk)V_|R!-KU}N%_R&Xr<<5{cIKR|Et*f1bNJ$Y%d-rix^9ksEr^kjpBe|XP&3@iS4JJ!4gXe!H&h{ne zY*NfCd@;0OT@ilRi}7ViL1y(TnVvDK9`F^tMtBP5BH`f7opF(hSh$!R-^SGxW_mWv zgYw60qWl$HNL&=QBm~*O6?)h3TodLKlLxqC?5X%vicM#}5|AqCtOE(B5()HXkh_@FK?K(d&4s5rAI_~&^JiV#f! zhTUE9q=bhe55?cLI{$aNrz|n`uU4wf3{txUfuD@0djYEc=mxIz=n6s9x*```cF2jz z0N_f6c={77by_SD3gTUgV*pj0i}NvU0b5iag5+7SW}7%XjO}?S z29fCs>bDYDF`6U2#ZST$0cTS-`m_>IoVqb^Hh_DYALjR~FLp|AjF!XP7)}sbS3-Y< z`tkn|_wLb_Rpo*2T5Iof&OYx|FDNLyS!Z|k&0&NJ<-G(5&^NWtfQX`3G?fgl!;$cZ zoy({q3&5=}^a z)cyUwxz^tM)B}l0MkqaN?YZXjo8SEA_nO~a4+Amj3wnU7c%wsC`lz_kN&vpvA57c1 zoJ=B;%F@lRUs}H9);)Xo?O$2G`8Ln-2KWO|{gctRSJMMRUAEq8pY%C@4_=Wpq>&QNAEyC z?$!gG=RNvy>LJv&0g^=SW12a{CeA(7&Ybugv4_MVJW;ff@HUuGFg|dpd`~hR2O2Lk z7SZ`iKn4HRjhjhhI{n#m#)FYdC7<+kfeRA02e(j;A3VEF?mH#MO|dk)pFXu|cy@ye zoL6YlD07!(mPxfH{tDZV**9Q_ZZZyRMtOd#n+%rA`U1v-J6naa-p-w^eA3&uU73&2 z{lUt7FjnTqe(B0QBUUDx5olUgYjx8o86+sqBdtqU)pIXQAS<8hdb9t>FH9B^3)Asg zSz4Kck#bHUR_3FFm3fF;OrCpXKG?2INBIjbQ7kHN3n~w-fz&W}fi#B)EA%m^5Y?p|HqwP$N*W(4aHShzz)37?Ox|pcUQCyqn+GpWnO_)a0QZGjP6L_w`ALC zV^AFy<>ViR%e~k2P%k)pMfr|&_Y1h-em=-fn<;xh!&V=jdS2Bx`RT`Y?lXE`MMiq` z!t9EXJC6P}I>jUvabMK)>KYJQ2z3RyW8Sv+$9C2?$!ZZXn(%B-&+U%D{CuBT`roz# z!bpQ9m|6NicauUaNHs_^ONZylsa&2{Gv!xj_0OX(tD%lh!78YaeHTz?c;789JRa9P zfZ?lqHN=I*;}LLClsl_@za#t3$OrGFBq?%?VsT~C=6^=d@BU6$3?UvY9pz5iBis&q z=b-1D#8hfa%O5()nUX<=jvHG#dJ%}*E~H-^>B8tb9zsvLvU(*!)}MQ!dN&3tO?NkF zcZByJ3yrAMD%^IzfLpO<3EhkTG&kONM?pU9ToS1Cuj&kjriT#Ayw1v>hXg1fhwE}T zHZB{fAN+;5UW%pz4C@hu$yY+sXtaKmuhv6fX>D2mhAC4e|Yt+V4$`j}L#>`#;_0`rI%zN_~F#yWaP~HrE%2sgdi+;qRt5 zf7Yhho8@;=(B5?D3xGp(HrtkrXyLp1NwY3wz1M>8zuo|Pj)MpiWH`(#V5LziY)1?P z_Ca+Ks#eoc^Ab=XfpdFkRA>bS?S5o_6*aux1D&V!p!Xq)@JUewo-QIqjrUPM^e1E4 zC|pfhPi9Y!-WK*gq2%yqIH^JA?NY^+`+8|vA* zU~d|$pU|Ei*~aQCpmgMnBi#zZ^bd`Z<|_Q^Nw5Z|I4~~!ycuirQ%zDAofbo??|ECG zlzmpO!h=|~j21}gEsW_$jkKrp2B7n}o+^^YE#YtH(68s}*H@BrFw;wpP>KW0%o;^< zUdlefBJ%o!AI7IVud?#<8xcC_SA0~Br?A&h^>%^8c)Ru2BMN)e;gOp9J=Sqr)uj%8 zVm}||wBQ?o;q3mw^{j* z@GN5Y)`WJvy-<~As?b<~QDF?)T1BK?{jp8;X$)p;6Z{e5i3^gPoABjRjyc~rRE)`L zvXLp6KV}Nh?1ZCIR=(awQ5tL|H=Q`=pV&GKju zS+>(BXdVn}{9{?n|7_G5ZJ&9qo&$BNcAYXkP7EA!f@z>rR{xF|z+?$b^d_D9!(?#- z{zFNq`;TV=0+oc?QmrF5bXTv70PcWv;KIG8>0%>qpI;r-p}}!UaRt zjfR_^VkuyoOUpS?mH}O1;NJ~hiM=4`iuW?2ciHAp^!yXvx2j=MI5t^{+20I$v@Wz&=QtzVCVGZqHeERtC z6JBa9gmuZ@8krKLI8#5@e0FfD=qH9nNdl^AIffXR%$+STjvpF~OZ2zAgC0hZkEX*Z z>qv(=!qYBuRvAa)0D!)&_Ulb^_`v>^5g zy#ES_9q+yVtnaz+Wq;0ht}dx&c6+hcc9sGM9JdqB9Gm^ifXIAOY@xlaUWFr@Cj;}1 zhBkotG3$+(tuer8E}8$?{@m^8z2^4z<5q(;)$A(?y+V;Dcgo16NVlWWAr~btrQFOb zLGb-IS6l{g?@olchZxe;^}&15u70BYDLiry<7)_06==?(pguic{`e)132pS;?O2)r zUgZEAh)HGhJASN*A4_=+nYZhEKYq!Mom>`kz^<<4UH~+_2;1e-5B=N%p;!Uc(hu!j z*x*}l;S@`}@#B{)gh0M=LC;P;EcTI4&g@j=?4P!~e>!4ue-q=mmw-n5K9R|fa=Y@L z|M243DGFfVe)!X8lZb7KfK2uBoqzE}=f!N@oVoK$N?;F%+l9t*zQRlgzSM2l)&a3YnB>c_)AYn`W#GuI2*0H6&n~bRl z$QtIvh!+b6)VppDR`qY2s&%(v zvffagvU}kScJ_Ryd~dH>U!8hmwQ09Aw8kvP&B)uWWAq7YPUY8luu>NQ8|GX`2%8b8B6BJ!l8=>LsqcSd?`=Y+@U3%_r{Z|^KurB^?{Mxvj_g~ zz1M0HKZQpK1Z(($wWc%!D}uiEXRdH${J62dp<25g8E>9(o^j(%eeTNJ4YpEIHGgA& z-K&U&M2=TMqHqOlDjee&A*11O4Z_VNJj!%^zmxK?Ve;&aQo>}lwmO40tJC>&W3}cc zz{e7rxsgye_N7{Tf1jU2!hE&T{OEOn@{V^UG2H#K%L1(SETuSSP6JwBa*1{7JNkBa@$F+ z3U)_Q!h+=_t9*PMn?{(8G9gwX!k$2^9Br?ChZFf4=V~(mGEx63g58XzKLe zSZ}hJDhMjxEynoMDR}T@tP3b6^!S@AaAI7|`83jMF!vD(4#0Fh(bEoU&FG+JH-xO% zjCWm~FLdhrA0A{U*&)6q!_&rFU3msgHS!`xt!00gK|;NW2x$L|6Keu;7It= zHI;Ks8I}LSBO{g188)-P&<}I=W_dIC(Zz^Z4EK1}P#_G!$I>U2N`tR;km5l%PT>Ss z9p3nQ_EfaPwq3Bbm&*|lA~jbwQZSK^`jgnunf=LoHKMD9XnH=o3Sw)*)w=mKU%%4< zvE$2Fm*Jf~81H-i1XJRt2-*8DH`F%VXg6g0=N_tGR}WJQc?n5ns4zXpdFg}9bo#M8 zb-IPZ)G8><;Yqc}uV8E&KpvYQN(3r31r=9rgOap5)kI$``{+D6^=B*wFKWLg5zM~h*g~=o z*bJIZ%7RAxlAXr%Qr@q39!zDM71bGtob(2fRWaguz%sJ5mB`w6YHx{bhl)%GLtnlr zs&~fuLcl|Y!8;U7uAwcRy5O~uBc8ty;Wj;CsoSFR)IE3c{`)XCWP>zOu92jN<-%Lia=);uH2m>mncS4NL8y8Vza#w z5o$15tAUsL-b~iy08%FhMzj>#vin4Mc4aXqbfM1rUgWxn94RrN&9VAd%!c`hY)Oka z09ORS&*22y-gjaOR>_1)nzc$H*q{+zPY8;UsOBd&%AnLC#YKfD5%fAq&_i}EU=We> zI@5>eipiv0UB+|iB#{>kBzmYzAX)$ppSQn&-J?$!RpW2EX(fJZvN-WS>v(`V^68l@ zbiI2zXuZHx()V--QcAQCuh9S;Un5Lg(g)v9)GiYCcgs(#_2qu9d~3E2^yaa7-`9;m zz3NxoNBnbE`Forz*6{r`R)?VD9uk;|ID5@qEGYjwZVKnOR_Cma&WLQdb9f&WH?$Bp zn21Z`DK{$%SW^bOvmN1rG#uTs@?1VYWyBf=Ld$pM$Y^mRMo}+^T{{)g%S%sQS(Na{ zqj)GQmvb^8b6a>%4*mVgjIS5_=Tc)4HsAH1iz<1EeJ&hpSQ8Y!1Q%+%7S+`IX?CT# z{3cZE_b?PgaO`(T_tDoW`f7=(RHn`Cv>`H$*Ebq&3XjptHqqyBAp#UkmaT1d=6iT( zZcUR;B)yPkqVZmNz5U)sG4~pdHq-kUPF!1rF^Z5dqsC6;w2+Hv~@7DR>Q!jkww|L+AH%6}+n0lPem5zT@&9edoiy z`?yaDkceg#0&e-sKnwZOVW<9g_?5;UBOx`x-M(L72bRTwJ!$+X&rI6GoExe!uqT2* zmfryY#EC55=h+%6FW-dGO&^d@|vCW1R=W z)_Xe!oy^Ohv^#;Nx1=5tH5~!VeWaPfo6RwpLY11FbxCcZXZdHf)!_i-cshwl8yA0f zNa3LO5x)N8rzRxR83VMHO5g|6BJUVifRFF0jj!t_(kWj*N5l0uMIfUdJIMX|rSQZ< zO%K&S)GI#KJW?Y8p3-udXlm3~!s_ftto($fM_6{jX}au(!C@sjx}`q_7;Q^Tc+z*~ z=ZF|_g83!YNh@mVEU!DRr_^#6P9~}g2Vt5a%1^$j9U1`yk&;#I#VRy_qyD#SFDT0* z6ef$jnSQp60yAPK8ThaPh7TliRroo!QC2(U2O&#oeB$|okPh7z82~#SnuDx{QkS13 z?f^o=1<-kGEVj{3@x#Flbjr`JFCZ|aw81fHA|SAg>=cn)v-%Op{pjHDW1eh+wFf&B z0W2Z20ke^im<^=b*qF!G8}^%e1GOzseak<9>Ptl#v>{; zr(c-nKHmH$#_DaTtWb~SfHPj4%RtU8&f!5PF%P&kq2iCjnKS7l^7fMFf5NJy55PG8 zmvw{sI(wiWKPLJA6d&ZiB2x$0l3|>ik`cwb7@qirV_&dJ`kSbDn(xr5@9E95Chx;>|$beI2HM7ZJSaGQ`$_(AfP+^Vlj4p)bfu`$c zzu2lN%tIZ7}OQm5(5#IV~Z>-1$|o*#7D@^*US#GUS)xYNgXFAZU0=R#B% zI+{V3;eLnzDpr*yy=vmJ{`98)EMtNw_bT3}xL3YUQ9UqFRzyz&`W>LfJ=7^cB}*c1 z(dLWM8f&z6%=ALZK*DLRTkqbrfPOipbha&_5WbLA)XYUi3)4~Obd#H`PH{{uN-6k(u-VVS8qhGn?Y2vpT~Q-0YyjW3HL-InfVUubSQo(%k&o1|dB{fh~In8hA569Rgz; ztPG#189JH_;-Qbhx7zIoTu;}S+ZsAjV!5FzLa$)Oy`8Be!Pq9G#s3QL2NmF`t3X<; z*OOGBu$iE8Oy@aBIqdxWi91gWYdSyIcAhQgxjKItAU|2>=j{A^>ipby(RtuH2io!f z%Qms_q8r4oYw?E32v?0MvCXLoII~D32~DPm$2ldsjkhTcx^V;CKM~!S57BKh(5;$D z$OgDihHToM`d&r=CM|^B4~LACkw;_1Emlxi^*KR0t3*#Z$7;YiBh9g48EI}dMVjM~ z8U!?syg)$JYj*1gz63owq$36Nh~M`OeoGGa`s-FY#A@!=cb(+ds+=F!G?x5P(w%}; z4*8Gc9Wfs*SxZP#Y^z`hMdggmFP-5qG{xy~)L#@l!#t}ojOyX$OcACJgX5YZ=+NLs0NL-+CUO3pOMr|_VW!=`T zeok${Nq?91vn!^K(H6pKs$c1+ycJWl-cTCtczHFR^gOQAiM=1kQp2I@O1{$LSEomu z3S@*t0CQaKv@>wQuMWNdwmv}Be2JqNcS?JxjT2dVQ+SEg{;mYcqtA>fr3LoXN58lt zU^Yf{zL5*3JhAq`jF9rw7k*A@Ko11m&u`llV?2gdc=3sCS?o{3jeS^`w@Sn?UjyM1 z?}2RDM}oFecmu40$pp$=$z;uN?k=Wyp-6}n!F$Q8A7es-XcLA=5NMdB``ZJsLvZ8? z0bZTvA80hgWJ*9VfKDWH4OqODjq8|KAW;DVALvX+DkO&TkqJod1Opg%iDdPcfBB(| z(5{H7)WfV;lZ)PZ`dq1z^*!CN0AZ$oG0(irc=9gh^eP{?!O*y;key5&(XZrf=D1@m z%slA{s)r!VQ9D``l3WG@s5`?zJ!lHJQT|OrJ2|e`SpnV-sRO)i6wmAhM?{;30|;jf zyJQsmxokVHbe8sy~kql!p*insZO2dlKD4 zPc(;fjg1J2LHz`D*-=e5RrkcXsX;ri?tpB4HQ`|eMG5c@d}?u8%#CxVGa^)Ms=b&k z7xQvX?+UhxVCHF&XZ@!4f=u2gNLTfa-H*yFWY##O)w7wwlJTTVs(zyjqoV3&#kH#< zaAIUtxEP0|5o5SC^*GYV-XfgLoYqEab^x*VOTsQtO0tBrmY}$T1@Xw2R@(A!Sf^`G z)P>^Uoy_k)nbrl=g3?hs`fxm@^9x9fwul@-@%AQ4=e0b4!Yz5nQJge9=-J2;v7;+- zcJZBfnx*Y*-^n$A?Ow(#stfd1QXS#Z1)_Ilw^8jBe+Rli$V(^XevsUpG}CK7tKW?R zs+-c^Z7tKS2KTViI8yxG$fNK`L2VAIU|cNjD?c$f-N_jVkr&3b?-X?Mh4b$pnFH0#{pIf*xgwv>MP22)JWO*)^#*^#O$m@y9q`2Z3 z7M~vr&7F1eJ!$UD^1f4Gu{oOL;UAbWR!Wv!#uz*lDK*VYa~?8)lERhHrQx~Bl+N8H zX}ob)ispZMb|wcwy%>tuv$@dZ!tB4$pNe3EZ2p6ezm9?!857LYJtvFlZlM^AGx2Ht zI};r4qT_F815WwTp84jDKnf{i5Kd`FAT;&pcEM2m;diib(XTJ*#+Nyu_jp>&P%It#T-sCJdz6=ojb9 zwX$&F+cJ8hTWNh4y2AQ}s;0HDh$Uh;7o+eJH>3daccWzE`Y!&@#d&cuc>;}>+gZ66 z3R6SC(27x=?q$n}z;tud0@_ByDj~yMkUi+a!$UX~`rP_rTl^kTlBpY`tm>lzh*7Jz z>okj5ti2C_2$B(1R;+e=9BML7_>ZW|l;T6dx2j^cePDOuibLVPK6GTyRk2W_h6Eh? z$O|J66CME>54oQ9g^tYOBA)G48T(h-`Jk!F_=H3@Notus`c5o{eA{p`qewirxNjOG8E-)aa_@BR+9%8 z6PAMC1%1fNcVH%t^XJqVr_c4+j-|v0la8o(gxspz<3b|1lemzG4!Ac&H*CeMuLcEp zTtVcns6$gVNR~1UnkrJR$BQ;w#0rb1;HV4{OiM=Nr=e1{LUiNG<3BOs?h_}5LeuQv zDz*;v322S*wjJN&j5AS)-A;~RAlsH+ALsRayHv6sqy6>$7~95xvYYgF(&-^*y6x{v z)8kTl#GYXxi7aHLQ{NLCX2462KDT3que1SUi;3yP83}myr>u#|ycC5+GYxss8fp^A ziOSL#YA}2lKo|;T;16nOLJX78QOB^qK@*Wg2e&GsgR*(j<1@33kZ-2bwai&(CB49i zXrz1_XLqbK$aV(TA$$M|uasan<69KvCDA&NuyZCGtKEs?JyG58vk->8;p#XB1T6rz z=SbO5;D!Wpu!mO zJ2~mZZmbJX0`RY#VhNao|9Z-x#J^^bWXd%vLN5ciVq`=sd6&Nkr$uKN$DfC4DKG+} zS7Jx+6xz|5zs;^9te}z$Ux*^HiVm^rL|{OzAaFH!K(t`Nq6GYus6A-qLGN`qwoW%& z@EY=McrgpeTtAN{R@KX{y7&F;sJCz?`oBZ?BdDCcAkfP<$19*OPXwnJ+p=5%X>>j4 zB6k4d|M%E*K4*MdkAX#u74;{JtPD2Cvl!kaNM61j{WEnga8HsPxN;8SBP;u>KLUyu@%&?+ z=QPi=_&f=iM26I{DWDQU2WE0WKEyy-Dp7Y zO;Sx|K_i#|QEY^#FtznJ_t4^RucbaZQTEqUBQNWt(m$LP2vpjo+`6;#q7PDxupsR? zn+aTZ)g1mVq1c`1O?vgN`n-8vAW`%EFo(rBRY%G!NHd>KjFmv9Cgx9kBCTHj0_){g z6>w1mM^j%!gV`qQtj?FD)%%87IVWTvR@Hg~(TiuxGAFkc?;qy2KCC`bANLA-!YCS> ziaJJ{vyOazUZ+P}JUFc55**&zLb6Q+)!UVHyAt z?&SOG29*6~(ZQwC&nsLJe70XIR&Q5_22n9=*brY*eaxkQ* z)6%{5@=BRHE*pHN9Z`LU>r+0S#Us`0q$xG0%X-BVMa-`3+|w?sz~sW0TR-Ih&(};rT3(ClxK7FiT~H2 zREJ|}IEN%DixW2N2W&SLCjnlyd+FjhmDHX?Du0XtaQFkQhrV`6HUAzs9AMIk^FXukLD$#&4}F9P^Qe*I&N zqGVY4FIt-W?Tg>~M=u-ypkZl;RlK>NRE?4B>oily@QJr*11z=vguSI%aubJOon-1=Lj z=S}*v)S`4c{|+YFFvy$I9TOoOhj|LgH+OCtaeTf$^tF$mdSK`~zps*V}UoGC-U~LG=bzW9tfF8#db^9#UI|pD?o(1W%gdN2~8pMo%|rtR;=>{Rim(FX6Ed0ul`?lCC?U8X6fK8 zr-UNFY2Qxjd?Z40lY%$w5Ya9{A4g8WX~>zRjJQI#V%r zRKSQMHpuR$;{;u#QC&Ue7G_1YId*|?ys%XVkXkZUV1F9Q)E@qFWXRj*=oaWyE!7Myvtj z;NWMMxOd0@COEdn5ScvEnyPx+H!-(yuW!3Z#}6!>b9*(j=Xd+77QL8#a9q~=&!%t_ z9=pi}R24WRb7*up_34eqdw?pk@Y!t4pSL|hW9pXk&vjG9t@jZ>h0z0Qi*7L%kuIw--CE-|GzZpw>IfXlMWr8xM?@> ziXj*tc;t+k=6a$xs$6&-w=UHacw{JL30kntOVo5D?~gNO{RwXv?Zqs4%P6(beDA>0 z(fl@Rip>D6By;I9pbAFlsg?<9V$WO{<99mLU3Iu~5Uij`sPkNWpgAcKU8nwjQq4?3 zSk5?h8~t$78kZ9C;%f6+BD}E42~N5?{%-?9E%p$^t{~*5t^`6XbYQ0uNw{@zT>4e@ z0HPpFW1M`M7|n`eF$W|k29R`3FmOGH^a)I13|Ol%UhZp*kHCUF`uA=}q{^L`UGP+;^g9 zaMuO>!2xuS|OZN<@iaP1EkY{Rm01g-QzN0Ag|aSj6fk zaBzHaj)djq?vM1ln>-EaUb_hfqk&Qgs1rcR-cB#E8{bHdDR*N$tY)D8hh>CjK$dLP8pXyT~qKON00ve2Y>sI4?Hug)&<`T zAh{~hHOIBx1?_Q-XF8tlVu}#pF>P#_O=n`8OZ{an4#qgrAu$qjiWRZ>P;;!dRqOn? zKBWrj|BIY$2HA^V!XH=-{6JpQfqLJwk0jqBI)jyehh1c1yZ6Vg)Ty(VEX1KACUSs| zyueA76@qhkD@8nJ`7Nv)Yo-rQwYRG8OS~`>%-q#)K(cV>C5T_fk8dJKwq$qkf%U2$ z)s-pMF!RR|>3|Qi4D%`?aQs+GH7T^FT11ArlVJhz&Xp;?Q`=;eoOG3s>EEV0Mf*jH zR#O=mkNiwGK7f4U&H86nRqRAUJR)Bo(~vMDijmce$5Y8OiRoeUNSQoJ;is;jaA!4M z5L6v!wVBS3Zl?3AHq($fsBZ!aP6f`I$l=7zhk{ziIy|nT zop#5ZlH5<#6EA~7a<-bnl&|l8x>VA&}en+3g%+- z2;wr!D4A#t;;8_knzK|Bdm2{n#+P> zIyE`f($zfVwM0V$x0v-rL<6IuDUli4W;iO{Np3NU6fh2CUB+l4(js2n5l&W9u5j0D z+QL{94W2-rQ-9shOpA1PkUqkR%Wo(rPq~MI$2nx3HJwBnMt~Q#l8hAGr35DwT+jrU zkjvHTwyW<<_tO3pAtl(22{@(+vk;EPgiW1b{sp!C710sMG~-sq2E|AL0!qbjJ46^D z3tGaRDN?$V&thZxDL0X*T75^*x`x`_G2ZI;_sNNdTc?)z`&(@M==2~wSn^+CGEm|+ z_x*AXkG3x*4d0!MDfbA9_FGFZkBhnB(Q}lb{qeJN&e3EfH6|Oa;nJsKiRiCSF<5=_ zk2FtxAJl+9ntm6L_?wAb@kuL0=#3t14BHE@XBHSM50Yx*sgd#rgSRQPi`y4M4k~`UhhIWWk2b?5 zSzJvP1cr<6#C^p{K)?(E0wyKc_xh~Z#l0X+IflvJO?=v{w+U)VmMdE=7S zI@bG{ou_=iUj>k;!mRWhUVOzdpweR^^^AuI;W!@PX+R)R07QzTU?Gfoy~Nkd#F+O` zr~TfK=}%1a{Vv|MxI3ecM@*~VTFQ~}sjk($?EbJDr$m^AFqY?aa<53hS zw$+0{+u6FqXCwS_T>1xet1nPVuow;x3!Rnla?wIRdQ73vu+>L~nRN^SXE=$M<_~?1 zU|8Lh)7SKn`E^)Cq*x$`Q}-qbOSJAmzTq&9>M_cR;3?s#F<&sknSNit9cm zJ?4-Uc5_jAoQRl#M|hY7c%Vq*&b&>5NGL7$=CAx7gTpACBE1whm(;4m}Ny+udsu*{G z>9?l0`3qOBJRorkuCWE>O4~{x%Nh**nL?nD}CsAdxD@6K8?SM&D@dFH@ zcT+XFyFdAV@CqP8T56L~Jq*6E@{prW^kwGwFH_bwMRD~AkWseNvFNjvFpl7Jk_uLRd|;abr0_zSwQ6`5UsL((q67H`6T+HISiWjPB6Wb}OJDqpQ_+3x?)Q$t^X5Zfdh>07 z=_mL$!1d8@v34fKcKo)UC$zLTOJ@HlMmoe0}qSa^9QsMe2so^WDC z`JYZt$yJm5sL7o{@=DgEKW_TiAbmL*`SG+geQKCqH2Lo&7FoT{^a@f~ejq>nJLAQ- zCyVaQ>x{hj49APY-%Y34y!<%`x}+Khu~=*gMTUR1ArOoR@gS%->M~Pi-QuA82Aso- zcuR)mO?i~J4gE1>q!4@B^tR~ONP!J=MXw`uZM?j++2{|#?=y7p!vD*?#A3B zB#28{c^iw#@ow!GC(efzCHUUB(PJ@->+6M3_5h^+cGjF)=Rf0nWO-xG6 z&3+su1=qeD1m}6D4(NQo3hA21wF}T-Jc&_C@L0~#{_)(Kqd4Trad0juPqV{gJ?tE* z8*y&oQ5hpnlPB&B1i-+`%;S8*yYbjYBtjmS8i|n0RTfV5am506kDl4Na^W<3n|o2g z1sP0er#kIC&YAGUA#ShFQ@QlS=PBoPUdLmD_Xc(}6P zludYizNOyRIrhvLd>RBx_2=vi2>K*iTa_DB{S>)qXOQI`fx&GCvYbhlbhbM87$rAnX$s{~I9%rH z(@2xgc5DZ%1a2Z$a9SxUTR1{fJenhU^a^G!jKW+!n>QQG5ff|sgKJ? z)*Ro*CL&n$k--?^FFGN3?QH$|4-+{Fxzw5(->=o9Y~pT34eNB-FX;1+&w4Xow|1lJZXJQYl2?NUgza2X4@cnfKL-r(MIWtoNIA}T2+l1njlgsgL>qwJb-dHQEni! zYjzD~zz#MncjLC-srn`YS6jOMIBNxM1g`j)Le7=%?BEF&aakj4pu$%i3|evrGuMv& zZJiXKJTtc0c$(~xm^k|lLBmwGCCg&6`RFdHQtr6PCgr=C>5Y*P1Qlm=2MKUfeC4g_W2+1MYyT$mxF|KV60L2ZEAk6RMb^q!+D5jt873N%kY@Rpd)5LF|EO_vwVJaq_e8q1W5EC-Xp>XSh-^!i z6BAjBO8q^%k~c^F6WSwY>+$QW8Sg@5ZBk0;%$P=zf+E*xXr$D&I)319SI=CZGIx&2 z+%YrX*Ir-aERa#qDiMz}HSo*qYsksrzlPm_6=QDJ9ciDKx0qt!Lo%<%_r+<9J* zb)z2bbq;$6g73nb`oXbABb?>hQPpfpu)UH}ve&Yl+kh!M+Rrlb#G zH(lVXUe+)0IW7Ht_0BNF*G>C64g5}UulL`b3b*Unmy1z z<);3r2uSxb;8XAI15U$aOyg)-Y(pN!bJhqS0Eg&av~M5c?R4Hw$M*-LjuUfAy_xtO z2im$|_U?t}%<9cRl)*SCqn2pCT2BWng33@A@IvP@dkucd8+H&?c%7*mjt?~ngsXY@ zk!lTyGNI1|V>QCYx@wjH$kXdtpY04AZ&*nlqHD+@8Ua${5Dpv z#Mvuu;H188`Ez*vXkx)_L@pm54lcisb88n+pnqeJ)DRGEu8cSp01qA~t{_g>=y)*3=1}F;+H@SJgP%?Lp7s58<$EWvrdHe(s) zu_h1}F)1;^Gy_I)NCcX}N_Y_q(Ul2YV!3j_yM=Z~7_Wuaa`b5@!(A)53BbMcwG}<4 zQ(*8Bzo!sL*&oo7PvzfO^h}$QphI0bx zPP3&r1~Ei|^;_xiRSp3hXEJ&+MDwfKZ|jWqV-^)yJ6WHpef`qJ-r=FL+nDX-eT+MC zwuk$g1yqBXU_)}K98-4amS5&*u$qWiX=QQ`h=X$NC!HzC(F>n|`W9Bs>lS3nTv`f= zak69#sX&qNQVwH68y#8;2%N&l1xdmnL zPK7yWf8f5_nxX0f%}O*31`c~3t+%~aX_teE zJIXugYtxJHh=Qcz{6$({s$;G@ zMiXc80gx~90OaN3^zLcxa}OiVR_bG74r2 zEFdT6HdEY`T&r$M8yv+?X(A^W+UC;(<{b(cMQG?}VtH?lm%ICw42Ij{Ht*{bfA z>>|%>M`~xW&&2KbhZE=%-tBVOnBFU|>vs?A?yIsYnEXjy`@F$mo5ubCH-G74`F_rF zG8a7}F+&lM0#KUr1PYhq;KwYD#o0dNU;yO$4k%YRaCRD8 zBSSc@FnrE7HsHLp#VtM+?de&#twJcZr)LFoIz7u4I&yS2mdjrD_4=+33>i<#mG5Ql zw`6xAutjh0c62eSyJwPR8zhH3ZIz^Tjmip9#FnVi)O#?E;Hsz!Bb(~KxfTAug1eXMS zm98D-ktFxdG)6gq*4%KW-z}v(R$r!D58!!p`Be4;hrHTkH^ol#yDsBJ z0;m>c21Tf&_g{P-MrO9S`qUfx5SWd;^Ek`T0+D4QjV_hB*8<4W^7fd zl2{}#%5Jkj*VkTyz4+tw;DxhP>1(16xy>s{fHoKzfyrCWc^(NDoAZT)l|&Kb@|_F3 zEf!byb8$#5okLKK=;5fWKI>{0D9v;c+_HtdvyJj}_nbjfTb&#hIB1iB2QYIjC9(;z zLFq^y4`AX<;oDgGcJ>g8(eg43IcSIw5OEY!5z_b2X(@7fU@B!pEQ@nWF%-jM7>0@3 z6n9b@M9er%I-WrMQW^x%Ku&F1a!cu4splJxBvf-Jb%jp^A}@%Gz2b zgEs6UBj%cn?G-#=dCzwpB=Co$HpArR!!+(@1SAkFg>E{^vGB04f|#eR30J8hU`Kz* zo#I0o5GVbf@!8JZRv?RRdN6nBC9#>*XJG>duu#u&6IuY4vtRs!eTrE9<*9u(uA7qAd&jzS5e{^Ln?_Y=5`KZzH z%G*xk!~}&1gVT$HHG`w!ANaM0n$yOU8iF>~?0-1?dJ#64!ZX)Z&Oh{|oMZ1#mCxWn zDrrc5M!0^sth3Z(@ICZVo+E~)Ox6#uMm^|T{<*)P5HdHBTs|A)w61gd(@g7RtO%BY z3@*cT?cu2!tLsYfo}9*KnymLGM#FslnLvxtynAzI8=6Z->bR;(hHAjmxiXa%AXeA3 z2ft(`qg7l9yUu9iFiq^L?LZhn6hqnmnsy+gz2zcxIARs8Vv4M)zY*&MmIz0mfcS z4Y4L;Of))G{(<31nW6ac%VP~*(9Hfk^?aX>Qr3yM@tAxX^{n`$THH9}iBXa#*hJX8 zFg1Kk}#FsAHUt)3!8 z!dA-)zFzrBV7N%9T1Y*RKPRYCAIqbs@ecC{s|N z!%(fRER|h2CYUDJ3u;2ci97E`7|31m7GhsKi023kGREZgy(MNdtA&^|hFhy(Kd6=6 zsm`y1Ifwv|T;zb@8a%YGS|DJj&A>^qE!itrGhH@+?|YbIW>F!}0XHo1bL@l&|KzzG z@qJf4^CF{7B#iWLrCrCq(5_7U84;1o*a93r^sN@p}A4oNMnocVZ}tvo;nEl<7=#L7i)* zS7;aXmj&h*WCvlyV-HUeGH-#ZZpoH&h|8cF7e*9zgp;WnzT$CM{wDi&0y53D1sd_J zs}#n9ShgyVIAtvV8VWQwHWon@n!@F;aHV2XpLV2(_4)ydrGf}~R&ftgdCx5?;)+cZ zuMyNedDc&@$_nW@dDh=pm6e^Xi=EAt>jVJ!H-zKB$;%%aEpO>X2TOm;yVg20ve$Gu zRrc7rm^I=Nq}1{=QnNIszdNOdO^4T5$28Sd-7D`jK7V|45^y_VjaV0G>94qo@?ee! z$hf>_`ZS1eH%=}cI~oxi-wxh%_<&zpz;GIfM(kM^)aB{dOR2+-e~g74vu4z^z(VFa z0es_*@;&h0%9S%>wfr7gFj@_0A@*R`Ig(Xd+n_R&49}A==NK^CCG-R@4X5jPy<8oS z({CRGB>=}_u|1Jl^2kFV7Tf6ELo=>+<%fOfXa1HNZ-(yMa*v1Gw++YTB?5!<058X(7l}fi9TT-DVu~GGGA#>n9T@c>`&M&y zeV#7Q*?n&TMhrz8&TMHwL26PHZCSciz@(6MgVl`lC+gr{7_+S5f+%~yN_Iuu_j`>^ zNxZce%uQ7Q2SSDqK6wu9uEDQd{r~0)JC0SP>16aET|g7r4rJJp&C#vgml;9><*(H< zTHK%uff%ql#Wr7)yudrSnN-)tIFm7kZ0tBI%j#{H!k(mAFjJ^$$nWR=I2rmxzmN&z zbUwz`=em@w;}0N|tgLchMY6Io4Pj-C%GzAXygE5z zUM(~xjW=2+=qu67fcJ4rRVNu`nDD(GAr({Z28)z(TU3yoCLu_iiG}A1N{uKlMBe8Odj7zUX zWp~S;H1#zq#ULTj2+<%RM!09P`a!YYGKo8ChX{he-aBTr*tTZ338KXcIRoqMbsV1mN&S68@L3R&puQb- zQvzGoQuRqkCbs^oyH+5JF+MmEhjrq7x4eBM-?3dyS6DTYSu8yeOhNTAL~#5+-P5CI zX=`;aggBew2pKSaptEZFGuV59BpZ_@jgBP}-qi$!1v(o=+dzUdS~#WPuXywF9|5*4 ztA?s6d*84u8b=eGe1QYus|pA)JdPPpwi!>VvRyE)n=9!x>e`EWXsYeU^=Voc>lLs} zRX0^LI5~{*`o6GEsuD-x?gm~TvK!v~R6pQbgey{Lr-JiAAT)$e=LM8iffuh2_Bz;- zTO1LU*4~jt#e5B0H*sgliwZg1ymR_*$XSmP%Iu_WOIeyPyr{~a@KL43PDDLwfE4_s z489{W3T;~y)-8af?gKqaB1uf0bW(AxhV+uzlUe@}Xg?Do(IzDE?6KYS{r9b9Dn|vT2Kf=R zHLbjd1Yy$EgV5c-pVNC%u2sBwgdeNxvjOJ$P!2tY`wdJ1^&a?bX3MzPN^fV0zoC+q z0sxn-^kPDE=s^MExC|S%Hw&mCQo;CSq5zb=+6u0fs(Ac>uTE9U5b>&EI#Lki&~iB2 zc!V%ecP>;dy%Z}t)rz>7Iq6;BLbTntRZvdI#|6C{Nv?b6f%v`fbnY&V>W?0QS;k*9ep{jIyXd!b*$h47~(OeG}RAQg0QL$` zIkS6wW?BuK7|jeRtI-f57`F?{eG-z8DTu+aH8GmSV#c_!T{BILW}rvv8Gw2`#b`EP zyIwkj_{@j$@Ul<86R^R#LrEzU{b^z|ds#ckA*Utyz*$x#|7WEJCbpry$}g;=hoD}H zx;%kSd|9(bin=@&k(|A->(QM4VC$4s4ZJV!TJHi0lI>y$s|AW~in|*YQVQ;SYbQBP z)`=o7Yl;9pBHpst5HE@=BiECS)(fR{$vOS0cJtl`_ypic;N|D2S4>H!U+Y zUO&OS#+^UqV`4D9pDDkH+D3R$Hq|s93vF7hbmT=C;hTx5rOou3{#qA*%9pZ`dL@1) zze%lekKsC+=Ix%mAJyKMC+YTnIapLd_xYrUtn+y8_c<=j3elLbku3Gpp5CZ@_{nqz_26&O4{~op3qTK(AU`U$ui?h#v6FYQvz+({-cRXyAlS z^05FKr>D_)BcqB^F`k50DGiKDX#@NJTBjtX1yY$0zA{L90P0QvW=(~o*oSvy_?o8H zP?Yi_ML{PUn59w{jgoL-Zj@do&{zZ`Ik;aSxVW-Wrv+O!Kls7W=LSDec6P#O9s7ZN zhEfg<9ZqVPZ2C_pIG#JH56;%GSi`Gq(VZmwP`}r@PfXkfHOMiB|IprhsW7dbSU+xL<64C&+!8-Lbty4y$@&VAISbgyAIr5{sty)JbZ`^wA}u8b5tE&BsN*L^p0Qq z(?{RV|4+l;=Wxb%d~c-a5A7w)lQ{|3Rt~zb|7P8YLPt<%DG~rB zffiJsLg@=EUfDo4ZW1;mBHB?z{D_pc+@HD^Im)1E*Yp+C4C`3bWj#-Z0qi-}QL*K- z3M$%=MNm?QSjnPL^y-}l$~z{Q*n>w_Zn^FDJMP-L8`ryn`KvgEY(Taf`%E|Fvzk0U zqnc^96c~nX{ZS^1AmK~-o}ayUCmy1(9|Tk?w$&@oGErhnc{|5ZsGHgi16AcJKM2NR z>^u5au~Esg`B{RkTWU9a{z!>aT%DS*rs2!kslVUhs&)WsaVoH}=#G{FrjD2W&-&E6 zP(egr;s-Q<|51%!#uD&tNFb%wXg_blmzcZBN+t9%9m7IfBd3-+LoKN?+<#$oE)&cQ zs{Wpz?std@$7#@d@+EetQ-5Re>U!M`%wC!`jdP^_Nfw{S>j!Q^n6LBeInod8b{OA; zUUus*|8Z7-`LhXTn@oapqAN0YaUpm<{X`FYa9p?Gwx6@@%O)hX*&~Ufd^*p%$?^+({3a{n?O}>gp=!WSFuae~G zYk7xVrtIBTJM%AEEqp%KfxP|} zfC#QAuTinVLFM(=A_*ocucv~E%IiOmr2P#B-tF`Ak%Z*L9uv`a@UD*}c5)U)<7)QN zNZM->vg{t8E0Gk~Os?IeJP;|b;|zRL0_aM25HdWhYqH`%>HWMi=> z@0nOGB$i+0=&yVRWDezMY(Aytmsm{Od3@lv9Qx&~I|lGl60|`>=9>Cr(dfMey>=1t zwR|$JvXVq69RkU${r3KO;>jfTp|<_cZp^0NAazN1XL5{S0_uWr+hr5yk-Z^ck{D2~ez}7uc}DS%0}uZNUpg|mbPHziDAv=(>Bs}wrS*W)5zze zk@_A=9^1(Mqm2xd{Z3S^e_#EDD2iNV6UqS!I5JK-f5IUp4OW&{b>C*4Ri_Ft$tc%r7Qw41%1L1gA(BhRewo zbr&^QJnY%Cx5m`rfyHtF47964B#j&z#I+B!W;bH)w;s0)Mk}C{b`Tk+c%T=IzWS#D zvk8NRfo=jFi~^tb8&=SS`dXQa>939Fy_*B-IeLo@2kVIOQ$ZCv+HDvuejRnP;TT_r z7}#Oh&LItCb7`Ppvr-b^4tMr@^={68wW+~BfU}r(&dRj-yhI&K-k5*lM{5g;ADzJ$ z03}~dl00s9l?M1=uDgwm#Q;CxG%mE?L(mJ4*-pJ8x4V*aa4O;(p*>%1j{(yWK}V_ z(DRX;R>@e^r8HrDC#K&#k^IgP;^FN9^dt0=F1rouxeRUTr(g**gxsUup01LPv01@S z`-6iV{U@%vQRAAj2Zv)DcWmP^wke0NyJ-rHdy-tJLv@Pidgc@J{B=r$I<>O&wOY`YaK{VFFKfx3G;tnt7>& z0K1xrXY^s(X222%AiSGYDib}@vG52U2L?F|4Y~tQg$z_cC&JWr^i)u4?<7wJ+|a}T zzGRF!d@C3|X%tBg3!-c%IV`A7^H{i<>A<)X-)2sJ3*)1H3*~E z^i)u6!CsbtMkW%ZTiE)&knpBar+)26oy|KRS%PV5g#vSz$ zr^Y*!8eA5#A#NAbZ|mh_t<|o(IlwktS&Soj*ML~E!n(70GMGQf{SNzew1Bn$U9N{N z_I2Ds)8)@NIV~`VWJfXvD!lT+DJ6sZ$&R*ts{@XL+KYMF&Ij;eWCRS@P05_ z5_rr_1H6lPLwj+4Dj&6#pBA459J`tkqDfsw_UdXuI0kgDBXtP5XI0@Na|Uqg-}r^q zpwp+ffgKr72s=swU_A2zhFH#2VYZ`*X}>DLh~41q{FTyS-CUtjO}Vk@`u)H8P*#6E zD-X|}5Z^Fji#8|vmN2n#aQ%XmA#eQRB%iwkq8jHoYh z&=8qwLr2BNkQS7>vVk#yRcpl6tW}W5`NC}!8b3GF(TsKTn=u-P?#uo#9UFc zRI<6h-C@?TaBm)z9IwC9W}m2^ zY+rk+d!!n`wySFtiQexJs6SL3f40e0MlZU3(Qcswy|xJjE0mU4>f zlQdUNi(xnK0EkL(!7Q+E29pDCvd_Zg=;u2rf-*QMv}uGh=~ySic_Iitp%UVo;koGN z7gzwhWRMnSs%eVmZ8#G`tRsGslH&Q}4he&-E{N4Os3Nz!uztk#m=fzDJs6yUilMC# zCX&qxms2*y^qo3jQ<4apI0M!V2}05`1?-tQ`O)0FK_9}nq_K>X=eJGd^KQ>+CDyS3 zl^Q$_)Ayy@$FN!UC)P|NkQXr;u$4ezJcV zZUC|67FcKz;oT7frC0aeczSFHK4+LNObj6bAhT0RfOp=xosB-s!_p}Hi1cx_O$xm~ zOXYH0C5d1=7s!g*6ybNohl14D)#{DGZ5dt)V3v`bJIDEL;NT_v&B`KU? z5g{@5fyAsw5eHmjAw{FZYJ~NwY68bbt09O&k81kJ3$AbOirLwpaT!NKVQH3oQk1Bz zI0mxXQwPwUR55!jgo{SG5LK~+g)$+;h&{?oHEl+_-#P}AN0eu7u3hmT4 zAfTo>svj`bAefdQXQlsoyyzsQ@v7J}9BGdgpAd$jaV|%wpZOy3VX=vYD>Nr6WvwG)8NCOrOcaQfzYIWjq**cK z3OMZxS%Yad;)Vi81f=0ttGtCD4{2l!J#ok^^+7fVGAzPahBVRw4mcr$rG-|oew8zFe4-yVX`md=$jtERg{bnUP$HT|~9V^?e)7 zIFi(NM$%|BO-p)t;=-6C4P?(T13{ajS}l!-9-#Egm^G#f1wy9O*to=xOZI@b)Gh~K zAaFRuH}lA4Bl#{Iy<-9c|3)Rw4r3c{UF4AjAbcTeb{e@fZS(mE;fuLv(mBc%WI+BZ zn(Bs_9`&`WwXKX$Z;4WPSIKWuHCCQ-etP9IeXAL5p5r_aN z2dJ^JL53j3HQ-`7=z?A^6|;leJR?G!4Tc=;Y6ELJ0j! zwa09y8xKYRx_Z+2ju3m8%MW~hUB6yjvfnJcH|{9+Y;;pPF)IF=V=2;DZb7{JXJVht zFjrTA(b^a>uL{s3xK3z1FP8R`IDTFMs*}ttg>NaZ!uEfTGk46;nFW`(K(s`ncDh<* zFaO#xq8f;!aa4j|GvaUk__tTG`um#fhx~Cj11mq{v6JVOtKRz!3Y|v{%zOPT9j;eM zi5hO}anxlj0+RRAS=;W^*0 zV=BLmFlU?wD%dH~ziQ@k_GhG~YGM=2&~#hXvqv*3zI+poP^s=^QeLrXZY(HFHynU9 zLV5DaZL$71qGYd{yVpCD$Cnbr)fTO|GBUrNKTTD=SM+-wXQviJY{`e`1az-{0GFxbl2Dth&|oHc!?)HguVf5mC z!&0di?1If0W5`U-#0VJp32*C=5m}=<{5{M%QIi4yh?h;=NdmZFJY;9Osp>og2Y{8V z{Ml;!p@eqoqV_dG;a0GuM`;=#l51%1nPfSyvl5aG5vU^1pq(k4+Aory#=Sqy0-P-~ zz|42QKR?uiCmWad(GkPeRv0m7BRB=XW*xmIBFI0WNYf2CzIk6JBOjSI>S`t~P=R76 zoj7RQ^9QhbaWZ+7X5~i@`D8Na90rhc?W+A|z$Isb(T~^9^t9HFPal~m*52Hc2&^QA zz+HADPQW}$oPcA`jWF^VVdM*`AV)^ig5#tS@)+Ko&^ZEG@D*(&CXJT51*71emBUk! z$_WF|t*F0BE~FNzW2h(y4+N@Ckz$}APv6HIrQjrD(^Jm0rOgX@T28X0!ZNs8v#|A6 zDy!WuIf|B3@IKTR%+%}<1Gs}WHthTSjMn2po+)Fx%*pm2QcYci6AZe>*mxdRO&#^E zQnf)03F+w=^HrUqkA_=86v zmEk2GxJ3Xoach%;%(o|axzT(5T9l)%+AmeB{ zpOOxd+e;H;f@by}rmNk@&`edQUiR)fNB95>^peoA#3-%qPf zjqiK4!>8aX!ITCP8q+OY4MW2?UB6q{pLa6Q2WQe?AnGi+!o=22KQ{)tT>e0H{|E|_ zmel2rv%4h~APz!4(xTf%3j_3Cc3N<* z#TPYp82@+8a{Ar@5%f!kTC^BApW&eVlw_RWIH%Q~SB5TPU19vV%v@I&*Eu;@i1lVb zt-w#{Dck~8a4rif9VvV(ZwY;?I*Q{;lRcM8HQBl3#2z00#wDSwurCbXj@ylK4aar^ zp>0<+G3*0E?r1H56&@pLwe7Rnhnb_pXe62rQxAL z3Q(gPFC)MVFJSK#1hmFiG$P!=} z126D0pcZInr^UZc`5)rKHD;_+@2)Y>*?m~rU9f2k0!=NNlA;|a7~YOE4=r^0UnBz4 zk4z*>@Cq(a`Q|LG!f?E>9hJ;#ChHG=m=RM4k>-=yR|7OZ-`s6VfLKI9r3||O*R|2B zD6DgPO@qf?+Ax+bZ5YEGH3(jB9DkQ7ObNxQkofqZlXb?9UY&>XN7^T&kG~O2psoNg z672IX_iz*8L|uo{(wU!Py*|iI7e&E&Qxt^ZW#U2bZrv~MJB1x(RmFf9#zGxaTdm!Q ziuzgjtgx0l+tPqX|3W;p--j-U_wS9DV=^p+N(jr-+*sZjA1^#(tA4%1;|UB@EPl3# zyibEqJdj_Ax}A##hDlFFlD3;ct|udjTV{tzPehV88Vqth!bV+rp%K$)-~+C<<&s@y z?iLUl0AP6J$3L>d;85JjOyLPJTj;DSPg!sOc`*Gj*@+XOY zS-ET+p66XP-QAL1us~y5vJ0WoO%HfRkD6Oj?MbIH#sFi0CPnax7qhB?WUd;ts+aQx z<_T<*{U3thh#+tSK;{2&@8DjV)xL1nQ?ykj4Om_gFyS#a~I_ z;A=v82w&JqY)nLK@J9_UIRpFXrF!;+mFho7uZJ02)S#;j3>v!`WRqdljt-`sWn$ec z;ni47zr|xxaeQK*d=ZgJhAq2vFi%zh}p@8v%}= zs8R=|yVs=0a-N{au?5|zIkS+U1MQ~sEWw!Fbc$gxl26AqDF1S`IXU1W7Zuz148b#9 z-4VPO8}9oiU~CawpBdd)(|Tu{cD-ZMNWXi1h)1x9vXO}BJCG*oKVnw^AEZN&3@8c% z_13&*QNx;z=Kh#ATDStXH;IF~$EFx8RbuS$15PC(&Qbkg>yJ$O5n_nO+4*a1^QmyI zYYQap^*McHc$c=D`%6RRAkm1csVLSR+1y!)@=Wz;u!jAgq1wHRcp#{q&*KaHJSTnJnm(SDe&LKKQQq9-sd%!M+_TDe6wZ-Q+ZZ#= zdmQqMo#c$vu(ZEk3>p=Xj?Hc{F`}NHpe80Ds zbK!RkX#Zb7(X;dk2sL+9L8~E$GIM~Y>6uGFs1xW>5l#Ol62O+mu=NJTC z7s<&-!Wt*KMT@jC>cVqe?eDNh6m5FMB}i$|kTx_--RZB47n3)St6{<&U~KiqnPw5v z-JkP#FDGPMRqk^2DtaUbRqwyK%FoU>R&zhwpT8H0W#>Z>g{$j>_m1tTKf%r~jo|(e zKo3#9zRw=9{P9bcsH>X4J)PfmbMV|PPws`BtG6lpoSpCe_$51(2RXmnFVQ`+1D>6~ z@#B{)~*VlJ(H>hI0a&fG+UcK)VXn@sM ztnB#@FP5DUQa23AlU5WzQ;zU% z?bT1(O090aS3fn;2=6c`b zZNdR`w)H~2zfAy|pUUck{=8MYIDt~Ba{rsgn+6%Izmk#LiA?`=GuR2@Jk+16x)1f^ zB=1Dhw;NxwyYnGd$P{_14w92sW5qQ}Im{md|1~f=EDpJL^|0et?_^e3)$l7Y7iyr; z1A0R*t*Eeqis<(=UQfN4l02?K(`djLMr_X?CNfYZ#fN6wItVtkT#X-Ka;r7v7mDC* zQypA$wL?@`ShvLeo348>Xx-kpv@B6nIfRPKgjnJBXr3eMc)EZ&P1mUVCgS?dSKOR} z)+{=gVpyjxkYpF;(W1@Swzg?(`SsQreDvFHpce_j@y z`FmT7P6<_Mmwm+qVbK|ofn?E{TPj$OSP5`eO2v+~=!79>uOzHYaYZ%cAhCP<=(Rk? zFUa1=sy_A~7^6vttvPft^$~XD2v*A9i5>Nt5)C6fp|lbOf6^y+%>_wsxX-XET&Ygc zjRP+>&=RUUYUPKeVM5TeVS9f+8wR}Vq8s1GuiD+4(4FHGy4#yiYCsZ^ zaqSUrt}9ivxw6%!BwkDyGq78~VVAllkE&smlm_lRyIq^UhTLp{7)QXKy%5`!Kpp5w z*&?W?{MVs}*0TmhX_1E2C6*3#sR`_Il2a{=dJhJJTb63!i)}P$*e`k4`bVL`Ujg$F zsY1C5{oq;yBGl?$z_t)0K$00ldfUD`Ht>GHjTb33>OIxMlpwa`-MH&3{878YMCC z+wx3NfNW`#Pto(DdnK>HAXwTJK7jLJyof>UvbTFBbQ5|?UApD3-cKI|wGKWgNrs^A z0+?8LERUdGrP~U+x@{oC|K%SW>dQIt<@AHcE3u+3nX{JtgXNq~E_Y5(O;;{zhYpN# zLm%|cv7%j5Y~=g~Oi{Rz&{)nvngFl^GcI8GL!fkBm6l0Y_mA`!khG{S*$iTq533eb zgIeLywd7g#n7oQLHLpju+ z{RNb?HoAOjT$N7~XbaF~E3_Mj#^6le<$Z~9uX5;R-fW8HG}L;va2l@hX?XvlX(+LYkD7*h{nws` zw}ok_fNo5~m)qp?by^ehHcdkYXkZ#@=|0gkB#)EnQq%AXZURF`_ z%a1<|w;XR8R!tmx8k%g&s4s42;WT_1dm0-#@82<|;qd@pavHvDcp3(f!!$f-)9|u# z8ty&GY52Ty8b0r&rs3vA)9@|ForV=!k1-98gM;B|xaBz0aM6GaO+#A`tJUz?X*jS# z+iF-1(X-QV5&wAd)9}OpO4IPoKOEEWwas{WDU{+;&u)NyFfz0&HL%H6JY+X>GUqg#)qji$OP_VjUL!w4dYH(i9%yY=zgN|}!432W|q{u=~ zInqiuB{Cl0RnBg`kx5PU_q8b!P!i05xPw`EMIM#k7kwgsZ-TuMk7bD3=0TTt%#hAa zgoMkNNzsqkVCmlMx9lu`60UOViBp;sxsX)3${ETkSGje)Nq3bCu3+pQ41kFJjpFs2 zO;f@5Du*>3UAE@S!WZ1}*0T>bX;cmIEufsCU!CB9q5UXsac9Xb4s8;`YSq)_=SKe> zr6_K3ncU(`xGY@;iCQTmqnsW64TZWA63Lk_<}rC*w28ifG!EwvddJzR{Y1HUvC%5M z-mvKzb>j6V!SH0f-2xf4`+edTj}w#8LT|T|AR`;2;O&O-cF^1H{?glxJyMP_jy;MF z1Sd26J{l<@4hac+782(;mc!K03s*YFyx{y25o@RT{kL{5;^!ed+j{6@?Tes_TaUCa z+OdPweRmLpamU4ao!iIjXSe(N9PhVYY43M^>WZz!FMIO$F4|gr>q{@SA4jg+c(INt zqqjoKMFk2*BXk?*E`S!8C0|h6}U}52xih5ZxlON%7rB zfDyck%VV`6Y7<$DeS*_0ei)7AhDSYS&bWfnjI0(n4SMT!T1PEewq9Qoefr3Yyp&qk z@qPw9DGr#U1X^uxyPRbe);-@0JIE-Ko zsce=+_*7s3O+vewVN(u;!`^{)u>ME!2G!XZReDXi8>f-QF(|yOgJI*9detQ)1S=sx z8fGEgyfV;(Bg`B1Kz;)TJ=|NG?-ab@M>%FI^z2OUfCT|3qo#8Q}ld&w3<|HJanrVJP zGXw(B0uHgAtwmDm#CV4V>j)698CZ0K1On14r*`>C0kaK{FWRzo3{qw>ChC%;!u@)7 zmB%32TBKh)HgME#e;F)kVSq)^YdkIp?AO#OU#p|lbTZBD+%*EDJCYCr0)29mZeT3o z%>rcP(NtSFD3tmtoWZ2NykwR>CdR&v|WWRFNOCjL)P}qpR+AftP$7w|zC_m!=}Ej1UGOz5>m1zhj zdJ--s4mp##U%dq}B^Bj$ak*;7nZ;`!4=OTl=d_xci^+`LI|Izt72R2>SoBeEnM1#9 z5c-kA4q+PT8PPHvYJ81>dLq=F2B-(>);+ZNp&8T@sy53fF7|`(2K9)$r;#Kz=w(RR z9N(qxk(I!yx=Xmbx_GXek3oj0N_Fp+;m1r0Uk@5_1ZWL>*`02tE(S5FM3x{ z5~8G+k`P@XFH#bspy%yf+7NBwrLU_8>Om#p2-7s!4-6*LPLRiyXjpr=kXi8eb@f{q zMU;fDC|x3FUrD&7QWENt^Wk=wS8c|JJtFGf%T0o5!xO-l=nkwg2%?wj-iZOj0pGBy zjrMi*TY|2BaWe~*gd+TbD#z46{$$LU0bTv^0AHw`pgxd6Fq8pZeZWdk68;u89u7&D zcAHybKsPx;3wKw#`i00bUHy-1M=W=nA9p2TBPZDSFEFf_Xr?u~1Ug4cei^t5%K4k6 zj%Z6S&vewRlyM2A{YOt@zDYe-jaFOz=8t&FfPVfs{jO>%RrHs;ZZI@ZDgV4Bjt4L7 zRFy+7ciFP?`5*AIVq9q4dD4PqrN5%s5@5WU5FFLQvedFtt|kg(TF; zYQnL^YCSpeY64omFH4Dy-k3wYU?~Z!NPw87L<`l4my!VK_jMh4T?3b=_$pW%`!Z?4 zbgwxNt|gKLC4)b!727ZKYJ^9!!DP$HR!XN^+}l^;Q<=Gk1E*!*tcWmj4r=0Ch8L#9 zEz>gFfdQnVfm)27nx<^9_@vb5BAFSYwYQhuA9sE2s{0LC^#o)t|lPlZs}Di z`d1n6<)=I@_<}~40K)Flpeo^#=qCMWJUFOHWI(4uBj#A&%Hh4N(L5A=40Ou(NRfCB zeE?V3aQ!FJZrTqgBfuCDr68eAQvX7<&Km<8ba}ovU7u~rAZBh zr*Ykd77k>X3K7twvn=X?ewxMH2SaDodBh`<(`^VpHRNJO6_Q$rX2)BX2U3Nwh*Tmh zLd;R;GYt;{tc`jNMKu24iUVFVMYICQ$vI1#BfL?w?8{u{r3@F)IH42KJ+9}AE(2vO zbnqp6qb^J)(n}!~6tAprdTkOAE-B`6-;D?bL8eedXU|6LlFxCy(^@LShi5w3f)`I% zljFRtH94VYmg1%x{2@$WBkzSOu!%F9ZycktX?eN{nAhuA-(OJqCYP!9@n?S zx^;^!u9uT81|@r^*fU?1!vjY7Gpy9+R=Gt1?Z_|OC&f+5XqB+7FB_K!lG6r0IO5qTAbC)2C=xK^iI)Q_-ozaV>a)*CVIU;#>df?ZmnY^ zyfbF0KvjzeIRmgdIY5*qio&7~2*mLXiU-b?!6I6ZqN1|Ov)fr5v;H<|sK0$FQu;?O+PLcQkfcEkjMZ3`%#t~GY?!jfFN zuv|u}NK=BGub^)S_20%Q_E}uPCN~B ziZn#QltTC|`+Au1UK@QR#$wL%AbU52DHDDO$BLk4m73JA+S`(1567~ZwAD!2n#RM@ zXryedYA8D|`c+!d>B)V1F58e^%44}g=5f2{hIA8;(`0g}6@+uiWBTlp!i_P#1k-nz zr@p=PT0+<9N@Y$Ur0VT%sOONXMpA#!o>H2M0w1tnfJ#UXy`H{^!ySy(Fby(F+51eY zi*(QfHYu(}kX0V~(<<)z{r7V)Fnh-t%o}vD+0Dz8(FD=#d#CfJai<5|C0fclk4Y5F zm6A_zA_L?y9IF#MGj5WyTo?F1vr$62h%fsL_rex)3EZANn~l5I`U#CLP`XH(56lBk zhV?2plQ>KdPqtwqxttH`thOTQK@dW!SDHQ8=4BoZ56A+QNq%b;JXV1zBW>_?B&j8{!w5@Hlq7>4Q=BW*niJx~4>;QcT^DT zRCV|Nu`$3OWu1(pnmW+_ZS30#wAjgsUbBt|!s@9h(+_Z5I{N{^Mo)?y-aR zI_JA7Dm0~Ltc`V!8D%|BPp$LAp%=FCFM(tJvUhoy`PvR?USp%U*;4{={`s5+0FE(;EYsFkx$99;ef4gz_A{E)TGXqTEPllp}3zG5mtEq*mc z%T%SIj}6;K-n$$+gclg~H;es!s3yHv*&vbvx(ztV0Yr7jH3MOX&cP_Il;HbP>S9LH zUy-@`tN5)N25nnEfUZg7Csgrrp`C@#ja+O-ST1tcv;V{ERWLZ4cbiRJN|_h?X3xu@ zlxS-vp#rh^NGI32aYt|8&Qrlkk(bn<^Cj?%&Idf-AWlP@t)AuMP1nm0WH;@LR@i2h zH>&d17UgA~S3?NOOnxAT3$pV7>7n`Jxl;u1vHD>x%1qyjLpD8ruMsC@@CXyOv`eWK zp98xIG_^X4jM1#VzqEBIyod`dMF?0Fx)AE@mM`lC>ay5hVkhONIy;ZkcyGXQQ=+v z(VQDh6Fj13r-(TFvc)m7aqkmJHTIqj67*`E97Xp?QYK>C=0wWE>NktClz`Q5rl_PX z|7|S?G4Y5^mdER6WHF8{nln$dM$W;d7RunY2xKs>=bPMPiCSXj=CGZ_I!+lEr|p#U zf}$5BT9NryWBZH+zFtinH_(&-TV{Dn1+QDM5G1bdRd2*THe8jmeq2S(&eHT zepw0vb4)!Lu)86^KgMIY^uUiQ?7hBJRu1hhWi&^V*+#3zHqyA1s+#IrtyP8OwBwrC z?qz8hvD`4_s*m92oVeS=;U*H$Wv^TGnl`v4Q71%W{wtTnX7Sve^l_|~L~#T)jJkGs z6lYXa#_`T6z%ltI;zBjySZ70dxF-;o%aASa*h7)~*-nFY_I+Z!ER{%ITx7ypi!YNX zBSOmW5geJ3IQok_xIkcTP9YF6WKdAm_TbAjf=D1aAk99Kq4EP{gWj4^XcXG8hPmrz zxXr>YA1&Lgb+oK0_`yJR;1y1TqL)=bx1J_e{b=6V=G8}4^=SK}iz&`S=YW^)S6a0( zSZPdO$JjVqe9EeCq^fW2e&3>8`!BYT4h+hOysI5XJ?zMXJ%wlrBLmSC+V0>#r})?- z!_gE*2BRquJNr63vWBB6w1=W8jFeSbeC#&S6spQkDw;y~cKmiMKK3Y6s;n$0s4~$M zs^1<>p);GzN?c^mABrs*O<@-pAqqBH_F3E@w(zTCY*Mile#xo2{L88;ODW`|4T1+a zHiMBZmMpk%7YHmYnBH;d;j z8Fax~SSqx(wNQot0BnWUP8l5S>j?#r2lz)N!6*$8e42*`)?US%G%gNXRoOZxox(Kb zt0j2G>U2h~1E!MDU3yxJ@M2Sx3gO)7Ajx!Yk)NiA^t3d4J@*HgipWkwwB~h%kx*wE zed0lV5`Ai0=4UXn9%A8f0rnBep-t_--orIwn>8{eQQ$)!4()p}&!pV;B?qw8$)r0v zFdftoC~=sz&=3ViJf6_btSVA5IDP%*weta=+96t+tRV_9=p&~tqaK2M`D#shFEE+w z#jP19o+Gb%c8*jtE4%LB-W<^p`-OAl4gaR*2w|V(y2v_mKl=+`NA{YDsa!{Pmvdw< zn;v<3z!YwjRJv#?hLvRBiB^*P!b(CrvIVx)fc||yR}%FJz?WW0_L}u9^ee0-p%;tG zW!Ks~F%(dQa1e`ElYR1zdUC4?8WUelHV&^Q8_Vbs^Q-}3HSr5lo$a%nTo9I%jSH5O z&Ayy$8dy%OJGPvJdXKl9%=>bpGKmF+=}#4$+~szu}deedcs#ltjkCHIhXRUj{9p3hr*7Mye_jt0E`XD4~UCH{KvC{rA%AW~Xo1 zV+Q;0G_RXoVX1R-PmEtT+qz+oKD72~Yfb|1EA&o2rBCxtaVskEi2vd2vT^U8JzM}O z9}{3rfUsy8tR-MeK&>c&3t&wJYy5m5JSOw zF7n2~sZ_ss7h2I*%CgBrDkN`VqQXX_k5KT8Yw3v)ir`~?T0A!OepLvtCowiDx+RA{ z24eQQg5S+%e((l0o1jimwdM6cXSAZ1z)34C2-BcJJ7vu83SA5LeL6?E~>0$_4=K=TNai$X_4%#TG zM0X#{(Sp60okzq0T6PL@vY48n>SgH+6-?w@W57j2W)bpPrm3{boXgr=K!giSja)Td zVVa?;5l~{__62l~$V`D6ayq$8e_p<=w>)32w=G+Xk6!H?osXs75HHqlbt*w`LjOzJpwMsP&lc_G(IaM;0#In-DAafkEXP> z9Dx;^{7M{HCi97{Q`8`v`{{b*Q_I!O(6Qw?zHU*zTw0hjD2EPs#Z+n1iSjeDqsw|{ zu8krwmnQ$i*E%OdPN@Edy_}Yx3AtXxFP=4n1%A?@x zlYTA(mRE`-?07jP1RKOa)VHFW{fTZ)GHP8uwM-g2a3?4<%B-!>b(^xCUzN$4NxVzm z^tzyk;ppk6l^(>4?GUPjRY`}QaMO>pgHRJWaz00VjPbc9ZUbb^RW}lsIMRZGY)8Q{ z0g`nYfG*?VxUACcY8=YIH0<^q*dOf94t6A57Zfz}fk0FOP`F=+TGfKxLL}n!*0i0K z6DP2$us{K-URgJ-Y_;lzhX7t5BHC2hg#cBBZ0kih2UQzoe?*(I9jKxs++2eJ0>F98 zqtRM2qvZGg%ZqfW3|Y(-kRg;MfDf%+BwGczKy!b#{ka6U0SfE>Cb3QWcJTdJya=Z1a_it)QA7bYWh>$^)DYX5LK&& zk}(in+oA);xrPcF;!6ulPk{?Qt7KwRw;>(?VI&omciWjC2>I zGxB^Q`3V%k^FTw7-5=JH7(h$3weg@ni$gH^Srn_41|FvcQxA~QQln~8gCOBn-A;{i ziQZtH>BV6XxCZ5H2L9;TVGvLrfiy}KSDz~sb~<0I<56pSghRoj7Hn`jgi`PqVWx-S z4%d7?&2gCX7IF$ibsi@ui&f&SCM7hARm!g$I;;=oJ}C1!5mb?kviF?s6$>TosY5*o zZ@X~cn@u8$`+I)6%jNdczIk)vYvZdMF$>G&mUlti&IQ1UBkiDht< zKiLPlIB5_KJ|2#W**axmj00tVSG_+blnwH;$PVQ1LwWp?%_$D>AwK8;JJGSD5-4>w zv>1kGRLq$q3y%=+s-9?26_$aL43dHl$tlI8P8%qB@p6cR386D1K6RPXx?O`u+hj}g z?4`^hlkZ<&hw~>)5|JDeQ?)XMq8^?XIfT#YFOGo8aDqP)b`Ti7f*nJPcs%3%2h*@$ zCi7q{wlnK+U~z3SlYj{daP+jh$Xp!6EmcEm=J`SdG;P6IU^OldU?KsS4WuZ=ei~QHJ13<&9{XXqp#-j1Ou=3Sq#Ma zIW+>W(sBSOdbyB=MXqV8j9OmIgA)v!04y%PB{)*Sp&qck(pe2!d?^p?hnsn@JaTBm zy8d#08Yi%01rWp_`~`?z@hJNfm$kdJOS2Uq<_OU14F5*PbZqA}3l>?}lkf==5G@ALf9Q1up9U z2AyVQ&XHLdZM;HANIJ#d-vLx#S75naYet|KP3*E^5Y zxfU(K-esQG$O1|6iyn|BA(XoDrLD#89WZG>xtoGq|0e*pu8pEzV;*-Qi=u^VD-)Gy zP@-#GN+48a;vBXGG08FBMXxM$1ZdX|$=eJb*i`s7x)huo@+o(v$ojg?vc>Y5H`Yc+ z{^>>B2R4>Qae|9r3Z=8aNW`ASn~?w7-I0!7{S$MEt%Y0+&r-N&ki@Fmx=S1 zMs$k(x&C1=-VY38Q8Mtq*!&qT+rh0jTyvtKY8AI(DoS{zNV7QG9gVwMxSH%4idV>9 z*D7W<`H5wFGmr2E%~^x{Xs{kfQKTJgQ%)K3fFML1M+S%J@Y;uUjDp0BR`Dyq zAYUyIk_22uh9?Mnu%kj?n@k$E9KRq)AfN#N>o#NO4uM#@<3AWM=r5G=s%f+;buV7A zW!8Dhc_~JhjRsO#dgq?Jy+;u?Bh&V<3KOu6-J+(VhSi06<{VQh&=W)8@y@h;W8ig& zTm%HwG0bc;s5$7tf*y&P7fBS4gDB3jkV+W?J!*kp{7(`R!b^~kai9tEF>ZqL6Qq7C zoPDJx-J&>}4uR+Zyy_GmGcK{B2LS7oDn4;mv0}T;cM(3IV-)-ZsFwafS8&$q5KApi>7nD|iP8(u^p9n&zR;9?rcL@RS=#W=sgQoX3sBLA^r>Pb zprYT&zYo#(w2@`_v&V=6pK4v?+`wytV>D`ZXnZkg52oZXv3=t3zqB65werW{v!x$R z+T!9>PRQ6^Os821fnax~^0d2B5qZ%|!d^^a%MU!3pd4~d?pzza@sSJ9i-=jq&)Uvn zd`C!u6iFe1W|gwcQn~{vgdZbMHjtv*sX2U$V&s+ocaiMu!FOuKx1}e>)rmdr|Fl=j zqgy@s4(R%75JC@H*{T+uUgPct%kW(?p2pZRNAdR3W$K#a8q}CIy!f;(OO3kXUsaOs zo{d;>29k95?1F;2dsf%_4dl{2wqaj9=Nhqor60F;4BK`t24yIVDm)_g+hfz>^aaR1 z-SAW)`%L>ei0tQD${@1OvXnt&6BuU!vY!LiPCp4`lV>5af$$i}KE03Zvxkt)-DgvZ zgPOyiVcW$uG0L*J7*}K1ULQNUwKvk)YP4CwA?UnlltLT?6uUC*`@?lSK&$i2P4o0& zX%stVS0PWI>x})&ycsUe;O)xe7-)B~D>hFbynB58!_$YPybH4{rxxoJ!Af$D2UI>i z_y{JXN(3%%B|*%c+a;BWJ7Y*_Mv*IieN3Mo!A>2kmh|blTw4tXKiFX%*u{miUo$hT z`bqxFdt7BFSO#2rcCjpAgKbMX}FdfCbeG~^yVEF-pmD%QWK*EZ1x z-iY&#Z`si5tnW92U~^8qX$rAqbvlDNqw?GFf(EdZ7NIcwWkY(0ngNgl3>YJzJV~a2 zUi`F8mZzoJKOf7m3cnc5JLacjc?tWa?yqqya0<%w>P>7E+5T?cbzdC~E6w#U*ytDa zjFQ6aE5nGtPItgx2VPk2PDIb z*ZD-97_X*goC|8kq+qwl`Cm;UnN1lV{$@{OjMsJa*zAe6U8(9nsTi*VWy?v!oDEbc z>59GFQ;6`2E%9lH@S1#IBD_MU2$dG&_2-x$9K|N~sCZh4_6kp0onC4hU)$R=RL6?9 zYVx1S{hEE$W${*p)1cV%w|>0UX%ZN!N*Wsut$KkAGSY5T1nVq0s17S(4UL5*l_yWc zXCfaqv53ectBQ9IBwEl^E2kqa5X+*E+K}R;pu21mSiPi}FI2wC_qz_KB$NI#$9Nz0 z>On@YyNq6ALs)O5f=i+}3K%VCLH5r6zHZB})DLJfjejeulFQqRQzd(|7McdxRmv1x zl_yofvw#i4dV$Tj44V5Ne$y@*o! zLr+T~@RIGxr1ND%QSQ)eXY;)yn9p;sWo)Zu(2+w-K1}2pQp8mAHeBKyZWNj_S0e zw<*^D3g88>3SLI=NkOdB3P8NsA%3xn+lj}hcxVy0%n<)rFGh;T`|v{IQl`*u3s7}* z!>Sl5Zu(H!V=-8?Brpg&O5rCg*qN{(S)I9eV^LMwZaZQ!j;4Dzt@pr=t17(Y>5!B zvnBk}*^;}-AV%ldJIF6y!GoPRwR6i$A_SlocmDy6j(6Vy5g5Kxy-lYQEinDOY(Pwa zhG{RkBc*A$Kr#a*D2+_mgqO$|B$lFOPh^=hY!En|rfz=Q3CW&}Vx9}8f{=PY{@a@2AFs4LVVWh#|~!oipqN>P9ycL1fkBh8fs%~={KUp%8N?$&|3 z&DMVofIYlyM*}~jz z(UrMWg+qIv-;?uhOgf#w=XJP6UFntuo#hj##WgWj5yuwNX$mTIki+PesBp$XV*A2L zV)0UgHoJBlG2UN~F3&rPfMEqWe(ITQVPV*0B3_-?an=AzuT3Id97rU5w`AHCr7@Xv z?DiR$I40l2s*QF_afn!v6#rvdibLDw+fi91%hRr{KG_eJ*wV{Cg<4##*hVdejrfmQ!peMS7WJWnu%}P>Smh{-Z13rgSq*N@ksTy zKW3`$XHe&EV-|cBml~=7Mw{1(7EvVhfo-IgH`cnn%KZjg{GsXXQ>q0#PI|x~!>GxL zs+mN22Iv*f0A{i#Od810&3^jGBJ~BW>*@ZuH!|B2J<4DuV${K5TZh$kAP0Fpg7ZsQ zl#0a}9>G;g0f2(+KCWA#4J!p~&!cbjMhu8DvLsU@zg=pwc6v-^Z>iso?U`|9&}^wQ z@DBt7C_H*~x}u!113m%3MPNN*!h@3(_|1{RT7*FVXxw&iTxP$uxET}{>$Na5BmxB9 zbeLf)B_N?BHk6dtLgUO5mvpE72Rlw(3e9*8V2uvy=RUg=%4;sWyw66!yA5pC*e!~C zn9Qh$@)-d!Hzq=l4_wt<;(`FFA zq>Muf^V4~=OgzSB_g8GzSgb`FA)JA;*%rnUEkK$XG&%*`EI7wux&s`SU9x7)0K4Vj zsZs`bt#ec-ufR`Pb{RvdPHfIOuMH*jjnbhM1!k!35Sv&r7(Q~=2JWeU;-Ht6926fB zfniz2Tmo|oo--kRn0sEv#YxlxCr9JYpGsmT_f3$AMUiV1xoTCzo@y;PPek}9xPo#B zVkvJbo<(S+*-(sxBWWBW^w(6}7 zF;$XiZ3&iIwl+{dmU|H)c3?eVuX)8@L+2{K3X`=Y$FTBiH)BZ^^G-ns4A<>3!|WCM zm!`TNH~rQOOvCJQg!uV^Se7=pt`!J6vvcCH9-)Jz@$(%H+b=9WIn0c(1G?dbflSP0 zOFx(bgdJ#DJw!Ogf<#HQcjPpk1z`sieZ*3ruR8S*S-Bpan zH$jYD^yj)D!iIV98;jkbfDLrDRa_=Zv)v0+C0*`GDeb76bs*E}uNDp%Y6#Vz8gIG_ z8_|vgJ=R@?VY8qIEtOa9DP4c9c+E9okmk~XAO{IVIO2ZSBUO+CP_Dz{TwcWb#Guj@ zJ))_|n2DlRr8`&#^dMSOq3&9LXc~nn+Bk(AKs*PH_R)q`=@w!@15dz#ycR+XBpNiU z3;`p#Sh$m&5Jv}LdAQER2@zm~Zv)P2HQaQ5qaN3^6_d81jwDLA z*j`Q(IqL|z75k16DnARw0J;u60YqU9m*9nV1C-us09KsGYI(gizQP-yJn6>2H`MsG zPqJ~?fi?a*YkZYAo}YB%-yLdv?nyR29UA|2(2Tn|QUZ@PQ*wzMKzmxEJuM9Fh!hU< zQEOZhhR}WujYANt6TkCNZ!EA{a(QEqkD#PCWYJZ~0;~WUcAk)$IB6t_w9a4*Cb5{* z2XzAETB9VB?LxtN&=R~k93c>CV$sul1TyMg!GmhsJlNvhX1B=a~yyD8UZQmz2$QHj+N}6^p}YgST|uoxw~O)6!?rjFb9h!9yQc9 z$$yPh1t5J1-E|AIz;A9dmj8*^NxXwEFpNpxb1?ZEHr-9RRU;>Hfl&l%27(uXKiSDA z4XQku%EW7!$~qnMzvmN*eM))w8MX z)n$$Afw-P$x_BwoVG3ss0Ni%pcL2pi#qUvHZ#gf0p&FNumTdO;Vrq(W@ol6(M8C#; zhjezI**p@x;#!zHO1F4Wjy<((-|4vRvn5+5kh(=XyF(6UqoXlD`dJiFtiVW75b*I` z@&w}2Kr%e6I-073&oQGcKj;YvA)nYrDloD{F@i)V5qCGu6@!ku{~yV^=I0+F%~seR zDSR=V!}KKw$C0f%4WKmU2zoxn&Cx1&f%H&wdG>Il{ITa_Y1uOu7_GWyJBq|S^l?)!KJ-zsJh4diM^ z5m`2QARU8`29y!_>hK2y6JZmZEq~#T9t3EPi*@Tci?2iO0oOxA1VDsgZZw1_$*(@2Ug| z2S-NRXHWbDx_*(7@T@>y(7TiY_VfNkWF`83{G(t~*D@9l(Nb}KcK@hEn^vIPdgl*< z&UIbs845Py>>VZ~(jI0R?xGT(;cdd5j}mp2ef4Da5m8$Z zSPL^mTB|qYHIbk?qlw#s9EuiqK!>Y}ra7BeaPNc*r7N}ZTUD+W5rDAcOz^Q;p7Xvs z;_BGg*O{a^Be=uRd(Z(mIw)rc2(4Ei(}Yf)+gAPZo((jqTD94hlY`fQ8WUB#cgJ>s z`orOlZH3}K!XCs|S=$Olhfn3M2p1lxF_~pMBcr1hJ!LK)`1-sNIc+^Z&0dfqObZX#6BR7R(om@T-f0Gsp9vg~ebQTH3rp>sIegarnUMl9AxYBHVGuZ* zh%}S!HJK5uPIHdx8unAW0x3)Q2|HU!vJ9d(Sq^f4(`)3$^^K+N*z4<>{$j9(%GM{P zl|qgJj{(Bm&)&+>wY8BNHCTKT2P{hgVHgOybs+P4No01*fB`%|5v`@}AK&_8Q8c^m z23~(`>yPuA->_#72XpiI&e@~!bvO~`0Ro}o)^_L`#68`s>tao+2B7-wP?8o(KCFZ3 z^s(nRW|o;3WRxALM6+L$y4nKoYW`xBON8gt9amI!^zWpx;0;)f&@O@nhjy!aZfgsO z>0Wa-K_N$vxzU>{cxyV4P``j=6UB?9&S`%`>eLwWamGkm*JtJ=)J<)t8#Xh3i5q}V zF|XCpMe?`73s{sgEQ_)d4B4k7`3w%Uk&0yr7FsORZmM-F)}M+zO}~^cayg^ed?cP> za;M~0L}PULEZ~p7&(}TK{fdvh;Uj-&rly!UoeT<(jBfK_vsBXPbcFuDu-l#!7Ej{& z&SD!dfr2=km*DBzl)JfT46m*K3khiuL-`g{<4kMFeFwq<2_m%T5sFijhOfEJ5mQr3kTnOf2Wm;;4q}UGx8xsV z35&U=1X3ug5UMA+f@_JYS@`fIPUw>oID8%o*`CC{#z`bz28U#=q`03bN{R^x0P?NV zN%U@Von%F0dpi5VSI@R*qwJf+-BguHGK2dkWXzw83xZ$xYV#f;=yfkC+CMW2U%C_a z7X3#A_WG-&GH)g; zRkZi2Ag5Zd#QxPQx=tI~(}n5?ow)(yN~zOC4ZpHV&akQcJEZzH@YZM^9!lP-*(H zv=|NU{bF6*EsP0CuKp<9Y zLkBMiqt0e9d%t``@?upeamI9+s5!LV0e>=JqfsVr?g{dSaKqdRp19|I^(*s2ZON$( z$>P*~z+lKwjn~D)YiPsksgf_cU?9}>cCp0c)&)D36mbXR>8>UcKHgjXk{Rz{^@~v` z9;|*D3?d6}GEl~we#4qPHf01>yNO~)%;V&yJ#+$&mmD<i9Wnl1j}o7Aiy+`Ja=z(g)O z*9U%Gyv;2o0#E;cl)SFesCZs6hhe%=d|F?wRbk^CF|ecMXW3P=>77$z6~qS)oLg`d z*EFO9=R#!d9DXc{^3Dx;cQ@Ae(b@J~uRFW*s@;U&V9r7LTuBh;WAYX?wz1bVM-Y3X zc=Rh}!*owIA)R>k(efRzSP7J37JHQW6|rkH4L(CIfLJEz%7Ju7uWg~5do90fo(r{lQf24JxIos_1L5hO~HvO-aKz=^J^8G$}YHmlyn7Stj~*=6Af z^a-g8Z5;S^tANxGR(BDb&Bp4F4ZxGAAI>S6o%+o^e{ub2)igYkTp32Y)kPvb5bOkQ z?(WI?vN>%WUv^2sj}Ag##tA4Esw0v4O7K)%Z!iD@vDm+mWL z&&vhlud5@PRoX=q-x`kLf7$>o@&JukX{%FOL@>~*AZBVB3!XSkV8M|`=)yx+@aIKG zt)y1*BU#X5s-1!zCIaQfo{N#Cbr{)lpFT8*{Vd^S);3N5m!v#F7)V_j(mx9y*z z&{yA)b0jgN8v%+JP=ICw{N*Vs5)phQVUw#ic+`rmT$xGqKa8E5j*T74EkMp+S*xTE z_mtM?De%Ip;^IKRMnufP!)AQ|p9&H}@B62#K0J83%J;Z`T*DKnb``)dCE)bpIJ%_P zWcnBGxYM?w+K#qM3T65sJsX#T=I1cwGT|jYGYy!O)Wf>6Tg%+u+34q3J(w<94&jcr z4k|0&js0A3ds&Ocf%*S;Dkkg;rv{)+mIO0{Rf)PIPi^+<0W{?TYZnufW%J+y5pRPV z>MB2p=Jn#5%Qqp$U!9NKppaVHRM$xdI16qfh64;a-XyZ8v0SXwmYu`DNCYhGW;o)j zHa8Swr4dJl8QAi1BjSSd5Y)r!9vqL}OOHLWm-P`|)y_ND0p@O&L!?MSR@*9Qsf<2G zbf(?wdLFXC+xFf*MbG&xXtXwRFipyqm;r;tS(8BzW?`gLiRo@07Q$HejJweXyF!p} zTFg*1Bd&8x5pzg4AD}hTU`yH=SP`8qYBUCxMA712P%eYC`>Xs2=_0ij~jY2=jUq5ns2*BU-IXBQH{%xdgj=%Urf&qxfe)}#A8 z+{`UpXvrVEFhEvo)Q1WW&m@-tPh)Jm2jVd0j3^^p>MW>69t-5NE3#>zH6^7*)8&Q$ z9in4or?Mjn47N1mhG5b|f{=(8gPZ-ew5yZA>TU|H;u}ZLkVWB^qi1j3!Sm)PHt6S( zKj7yT#l%i6*KBkw^jVB_iL}HaD~3f-i8dH81X6{b@(qwgIJ)Bp*9B=BV5|+eF=%s+ zI#$T5S8fb|D<1{9F`zIKc3F!BX~X7`?XJo;B*+38`y#>Q4h&EgT@J&c^6Ymsyo>;T zbQbp=X9r6(gi1nAgHHoM(ukT*k-Z5bLNOlN%V{RSaE2RFGhQnmZnPmO*H+ND^Z8mb z>54gRMBTr3op>zWfhyz)z$23eN|sRs6pbl;SC83ZsK=winR-oH4>Bd=Lg!nwiER6{ z^U-Sj94$O@1(QCbbiQ3#B|_Ws0#wekEYTgpo-1}PFQwjCZZ${@=#A%AP(DuBU@d<$ zCo2tTrCra1-QK!<6u8;vf*an5f#>5aG>QdG(2w3Sb&XJG`p&Ia)R=d(&)HRGT>{X_ zf<~0Nh8-gAa9;}n(FmTLEAX5rwy7n%B@v@GztMaG>Yn1_3kCq!G0bt>saWp7#z@Q* z3kD}?lt)GzJk$n{+SKWQZtY{=TGa!>R__eC_n^Mf=M{QHgpHfX&tT9sOHVgg1k;)M z3K~ZV`&C7Fn^6C74YEwj%JNK$EqI;)Ohs+#AMZv zV>)ozZgL!j>95veZj80HL3|eq(X`W~NU-clgq3?VGne^?m~YZMJcQI&Nz;J)%q1%= zgCsxval7P`jhKj2j9)uPH<9LC!xB>`ak`-ia%uSSo__5ay=*12BlXLuZ#n^PD@BG? z28O3M;klNPD~FyutLQ;YURf!rtVUl};e@g-E3;+;SugjjC{aS&$oVOcTRJyeH90i4g0cA#TjK1-AYRs%~Ci*ei90`8lGsh`PaR%#1`mu+uCW>fT)qsiU=xYn!`#WWKp4qAAY(NT#3dic_5RR)Z4wP0g zCW1)f9+8CCmOA%j>q(0&pFCRT>DFY3jU;%sZKy}Ej<}Bq-H@3PfMN6W*Jrc;)i>qBS6q^L<(&aH5?u2r8kPM zQ|9AE*|{`jFuU4fo1ijArco!IDdw)-L;S^@&~rj;Z>)IjO?TWMU9l}6BiM<)aV*95 zsNL#I_mw+B929@JWehST7#A{@mNOc*n=jR5N;9OW4eN$&lnE}+;zcg?Mp8(>@+FeOsSovAe&|j35z@*LHk3np9 zey0|Xz)-AJZM$8iE@mRb!D=`%8+w^pir)H z6xHD#R=l&4`)fnL=u`h&aSyqQ=X!z#{7DBt(-1=}6`0}_@e9F1fv#{Pwdh>D0I+^Z zn1Y8x?SeK>cS-@JFeGY2%f`HiO~$8&?V+*zp{*QZ}{Sc%%Dk>SzrZev9KMafacgvM%eQ zIixY%iCDL`2S!IQJeFEi+QLPV?kt+yd2OMbAYmtykkacUiL-DZnK;Vial(I>ti&t) zjfia=xM4tftY^mXSf|^)&E`QoT)Eca>!dSPc)Cc3T%WyJ8gEVytRRWuo#fG$GPw=X zm~e(KoxoUdwh^DSdckU}<DKI5CVN@7zu6-sTXuVK=FZ-jOi31jeb=a<{5W zHp3vov5<&6TlUp6fEJy~J9JGJDdt$Y|8L&U6?xfXNWj;C-d(P5!do}{A_$g1Wn%=> z6SrbOqzh$0G{p0!7k`$No+TwCrT0EdO3z@f^!gtru5|EkpXEx=+y!p$4-+XJdEit@ z>0u&!>3oYcK`tqoot%Z1Wl-{v$wU%;#}Zst5H{tK^9wAHWKihQj<3aa;%FgKt>Zfa zE`m+*5R%_-?3veE${9>t6f8++=F?z0VXVrlSq(GAsf?9-)m0L~ftD`gfRugNsw1-ejFq)95-8Y)lb@0E;RjRgO?U5^m2Gl_NJ+iFM)L|&9u{(>i z!;@x1A%a1#p&!kX^92554*u+g(I4_z{{C#(^rrnWQ@)w~#xhxUdZ>G)gCQd6PevxXB(v)6XlSp6oB5*X^yvp})eY zYv%`!ly7`(@YNI{&Ls!KEF?3yqDmPNF81bEh=Wb5(y1$m;O6t=JJ|H*?G5REJ!{2& zX?5rQoe6zzau4qXw|nvT9bG|wx62L zuftot8Zp^;Ix+^R?Q`^z_}u8-YL5%+@79yu=Ux3afg$@4nqzCL0q)qL(^7~GrNr`?xL-c6HLMP=_{m=G4NNOedF~8%m9x5XQ0seK%p43>HU14LT5?}-E@9@v#0_J-KVDwlT(QBB?^6~ zs6`<~YQ;Ml!oL`zPzJi9(7TUGp-{b3DAg>Y&_7{}->$Zy&;xoxp_(nBO<>4AY!pgc zfkJ6%DGH^Tr6`mJtP_Dk-$mWi$sK`04-8PKnj$#hlcLaf0sTvaxM|wJBl+Yhbn_sE zz9dlSyiw?_6%W0uqR=lpg)(8`q5L==g?_oBP~IvEz2&4Rbh@I@jZUE(D+- zQ0Nzq%R|2~%tNOKDRiT=P|i3q;NgBflvW!{`kXmG-Yc4bKIim=)r*6QK6t0txydcO z>!w})-U0y}9HLK#xuVYl$D~hKlhY^FETYffVT6B8?LnV6=?Q&mu7oyqJo6()pR^U| zla`jEPv?M(I4BKRCjx!mM%~lN&4E5|8lcZ3H1%XT=xsoMiI6o-8ysjjdHUQmNS~Jk z`n>D=NS|;0H$k6&`L95qfAw#SKEI>m9p-%_{)rDEQ!9zwSIFe4B^(HS``dT=!{lS7 z6zd)NrF13a@PZ}FhbC95f=x29cf=xUEL5VYac8{mr(wW;u!F zEsLDI^z3(mqv0P7I~uZ3%WYo{jqssVvSjH{N4y&Cn$uzrY34qtkHcPd`{NDKt5uH7 zLoSEPYGw4HU&dnXdX44IRqd~)@eR>$t0L`49gKbk?SG|HX0Ni!947OnXAL5@9nYsO3}~BC$JnoUg?#>0EGyuC0p7fp=RQNB!_z4X3^& z^UAD*-AObh!>Y^l`r-C+%sUBoDj9Uke|g>RAV=o4EfEV1=6(6n&U1blyN`rm_`R+j zK@u*nRT15C#ulp@h7r=uK0?qHHeCfv3@6Z%8KA*nVzuIs0yK#KBw$p+=fHB=_6nE_ zu8FAU$vIJsAuZ(Ow{o(XQhkJkA$o~iL0TkYq1lhv-;mLt7Cfv^QcyL1Xwy-Qqcj$- z5p|Kze$CsI%+%o)3)M{U=qQ@%n6yi#n%&WZg_OyOxzK7-hLJLZ`N%C%gXCq(XZQ&+ zoO#Dwu7sI$;+j>@$2@%G$N~OX#g;T*lg8QJ4e;&e;VtbzKrRT&SZ{j40(H0-{I42Qj zJxjzcr;7*WZw3o&oli#K;+&A4+RI@EjuD`?<6r{FlBKryIzoy3O**!hwe(srd&Axo z@rFw5vMa(Ju?<)GUYASwFj{L@P8>h{|Ea(Z2-LEJ6J+C5xs2K>nf;X#S{6Eo=-&hm zQAluwAOm!q1odcfC9~=kkahzd`)q|RVwBnCj`6JoPKjf9S&*?zgv0Iw`=dNnJ74En_Z-ijYD9;^}$E8%&?zP)9R{k#>^#lbRxDq(*dC;!WesAM)j zE>YduSc0fXTtrm2%3BDc(z7C}jTKF8dGiaZ%=+7yT>6g_oX+TVE6v_z35Xz6`VBQ3ez{H_`y+$`MV7{7Kf^JAxG(6%uYsEy1t(i&+<3y z%0c2yzVAtfrG(vT#bbUFEn{Eq&gGK`V&?__%a|< zx&Cm9&1JLI+qV_# zUP6@ zJ5)#18nyCETZ?t-cD=Ae2`w)CDibUWZ3_nvOAsC$`XMBQgR#Of{pq7ev0rt9lA%3tK-dx-%009wPY+TX^A-{g8&#JUOBVU2kL+G@XI@UlXE@1Z?76i{kc1* zCPfG2zs7vA;_S$Td!xss#XEJuAcgfu*GzWgGP~O%Na0;L)drweI>TQ{CURCoSh}QV zQJ7F8!X5EkA!(bqILj0inZ2$C4?-#%*?MO_a%b(9Ds0<7F<1CQV~YwM>d|fb*HoZ>vDRSFWY9F#A}%RN){axp^D3^ z^|oB0t;EN(hb&G%wdsoR2&7cW=5uNvxNSSn9BFpTw-r+*%PcpGZ1(oL)vl9a9DvgV zK+GF6EV-eeQQU7KN}stz@!%3fvG+%fDAdUl6U8G-69vf&iNcUp62&7#E*&I_x1B6e z?0d#?iUwlr0!H!XA2phwk0&OH!%LF{$qPwBC@U%A@B)hXt&^pQXD*x2K4l?Eyyi!Z zB-F_h)5MpTrU{Z4(u5(cB#JLDAd1^gmMEUNY@)uHO}sAo5tAqAUPQ^fRQF7etQHHx5*C#Hypm!=4k7gB^!R#L>nLln`<_Ma?8{BSKC zul={VaC~WLnjm>0O$;p@Us^yE2Y&d8;>Z%x#0@`cd_tW(F{Ak6(nLY>LZUFFm7L;> zLqx$X@Fzs=aAN9QYnM^&0o~52Ad6w)4 z%zJKlCR5LYI`eZ%yyuxK%P6Sb0$JwH_(x1LLLW~o%RI5PEJN}_Sw<);Wtk@y$TD}F ztSs{g= zJK6P_{JTCoFGmMIy&4>UaUQ^tVCeb) z0@CA`rhxQzUwn)uzesf5w2A_{`JD1JN0jU~VsZ#3yJCO_r*$hg*KpB8uH59wEjBl_ z{rPrIKM|00DyDi1Q$vAVNZjY>P|dIE z%PZ$KbI9wZ=24`0wZeSyJl%p74SHjUq5@U*z?X2x8I1cZ%97`wio0EN8!fY1p8xfy zKyF<8zgx%ZaoT7kIQ7KE^E_DRrzwrYD~`gke0x6qUM^dUy5Ojvbl8$`faoVZWJ$P@ z_LDwsNd!3TCw)9pT~H#fp4R5k`cLB&5@**C%P6KbMQzEx1)W2C_LC>BuatuH6I~Sq zsS?#nozy56J>g_T@#5obEH;*R_ybp*NzZCNxV<`GD!W$(s8*#9Xy)+VMY2Y$uK zn-C(NQi>)Dsq>f=9tzx5g} zuL*~v4+Tw=bYt8HAUQw2Ozz$r(o1>31J2^X+igTHrAIF?R^asR6Oboe#K1klLeZwKhkJyXmbV#WW2(6RGanB0V5Z&dBFhsY7#|en;W{B>U$0NFro{;Ds zH5xiMIV=K_w|bxGZtfG^jmibpeUvk!oY{g*jp{f)8mNwW5eHZWS$dmak{%~DZ0DT>F#o;yIn?hUmhg8BMUg4pPLuiiQ@Zk&^T$FI~ycB(HmqZ zmUjZO+Xva<6Mk%7_m?LmyH6Vtotr!;3VLve>^|5hJ7aK=-QzGjBS9xS@gZk+dyMSp zTt#+&ZG=`0(y_=+MfxMNB-tH*Jo;ouypBM1m!CA%9WtuBKkNj;wh|eVAezVjr>l&k zu}%~>TO;jce0)45KqmoB6`$00Qo9L&R7<(?ndn8LHTF^*TvXViJAPlsFeh~ifS9Hd zBnQj1Mil6j%JHfvHm|XA1whYkJB^=6|5gV(zbL!8D@aM;^Z|9-m+Ts1S5n$;0)rrhTdpPqMmZj zkT!LZSInQErGD*G^@V+LJ&&HRFZ}tf-?%Wc|J`-Le^nH1l!IsuXX-F_t)56 zhTIQZM_{vvq8Sf#4+s*>8lwIvtZ4S=2(oh-VsuhaQ~8@FNV3_lFLoy&V@)Vh9Why@ zZ#uNn%saR5&=v7{-kCjfFBb|Ojjo%$=Gr}b_wApbi?4!BNi{eHg-kJ&DRQlbNT*YK zV>(DXmXBWF>kuQ9@<+e>?Qi~n|8(!st9D;EJ6G0m^>tH2`&g>z=(?af>W92zaXzUp zZ|>-gWdE|9jXss_=0=67j?GK1cP1jS;j2J!-lmf|xa|{BMo{GhCXm=|XtkCL3~ap2_j)agEE$n&BiwjL2HpqsR;UE+kn*9<2ar0#ko2I zQ^+cH4|zMgXIT%8=?GLLvWv%&e{*oKVX_pJsmpr zJDyIRdT}X;n_lc3F#oDkb`E&W$tXsX8NbJ~&7y{K-+U|~IrgNNnuh>4d$tw!=jqU+ z?^Srv=~L08KT9s(KXQ4~GmTvCf0kUHqz3?s5AkAl3@lj|kYL zF2DLrBbU46Uvx@~(Yt?uvdckatEWYHIry{+FYmn?=>>=K#XY^sK3=XS&q1n zq%#ZEK5W+5Axh6M){J6q1g$sN1GHU>Vag9KKyOK5krrGYP0f7ri^)1N`x6jo_Jw;f zXliSlvZJ-n&ri9#aCw5df%`UR)1L)kO6u;-h&RexRXGO2_`s-fKK%Dy(?5YX@8>WNit*uZKb_)txR0M%?`t+WG{wxm``6^P3_87l_C zdC`c}E5Zlbmahq&h7VLEi*O`8imJqHY?r98QAXV(6P@%Sd;_$qaUs!@44KN6$g4y5 zrlB#zoMl!@yWhoPjH?$OnC9(2K(<1-kEdlZ+WT}aMqmQ2k}l#ZGf$PNV9!l=>N=MP zPll;5^0tFE?@V8So``mAbH$Sg_UTxDZr1YCIu%xOKv!xeSLNIsmM0cuDVjap)D_yX zLQCj2WOR?N|6&ut6f`SnMHAN?XiA}Ce#Tsj(yinhsEBE#PNIF{QJ4Pjou9A$Je*PYbtx2;Y012; z0f;>M%s_(rT;A>3o*nsl`ki_ZwYKgSwQy&`5LSC&PjxF3bH;Atl1feh81$AAMAa(j zA!4DAyyye(WRTz&3d%ar327EJ0|ziR_{*A%xal=-&qhD%L4(u*L7;Fd!$lbod>n2E zk87j%*jQ0{XTFxyu1>F#?cJkX(EwHu`3#u$E|I1($&PXj=h|rXRP5`AeoUkMv&cK< zL-X(C^(EJyA9Ef(4lYn;#>JRiMpzd4pCXRukRRhL{bs28(I$vvIa7U-J$B)BqWagM zX(sWD1$jL(R9gb;a{^uQ8i|9Uvh}I{hc2i%Q@hMyI@c!#Nk^ zf|(B^0qcn)fY3t%w#LP%ED|Li_(+L>hl?P9(4tpzTL7wMK;^9=fMnpIFK2BqL;+)K zLj)EC?aYQ~iZ|Aibv$ZXxy;FqYZ>yU-SX_0_R3X{{L#2L5&ItdagqN(HUP4-v_itS zP|gbMK^zylu1Zt~{?|eFLmzWiK0u*7QFS$Zz8u|BOU93LeQL&>BS2IaQABZ~pmW8H zViNL*6kZ74gGhFAx2B$^b#mdYsi#+o^t`+^^$bh&TT@q5x2BHfR)eg1+@NX&?bg)s z-10YbveJO4sJbNva(T+Es>5|h7gdkPatSumxWmjNNiom$!Pp)EQ1&{Obum&p z$rs|4#XM^}CE%J^tLdsWo|UU5s>#_tj3iny=FK^g!1>TF2`I#nDT^^la10&S4!+|j z`90qMed|wNLBeQ1;rA`UuYR-=@3DkVKgatlq1{jT3riU3Cw$xzTK$AiT7q4L?O=S? z5*qy+U$TUHKjAS;sPz-RK?3F|VrvztQm^ouzGunVPV*uhVWI4Qy5T~VXqBH#jt!;W zV4vi8D4S47{PhdLI!NU1Rat%HMX$xNQ;dV}{kMkI+lIv)Dp|s?>Rh3g9hO^v(%Mrk zTGSX?mtg~0a82SB*pWJK(Up}*9ISaVK*L)OH?>TeID+Mmaqhb~9(!PkMYdBdvbsN4i=pC=TYR|wQtCwq)>guGF>eRgUs|bE z(nwp<2wr!?(nw$M(WO8xjkFml@(nEH;K#&}aCK(0kTk+o>Uqi<1Rrr}#M>Hx$g3Pk zP@l2HTL05x&^P$YS~C+m_d3R!g1&umIb^sXP8G-@Lt;p?bD$R21b<_b% zh|Fyr+DOxoq7aCDs7b`qHKh<^@gbZ3tcr{vl;%vpu0ADa=2d+4gTy+7^s>*c&{ZZ; z_T@wr3RY))>u+}LXE}Vm|f_k9OB!S zg#o7|eCz?wRs$xIq;+OS)5s9dAbq@h|s(w4s99ef^77Wc_+X! zwAPtIAi=Ad`f+j48>?i$FJxf-NV5MXKZa^R-gRGpKrCD`AG80Hslb9X927BT+m4Sx z(z!N7iiS#>t0FDIVmEZh$R#eOU?((8s>CuuBPA1e&S&?Vm7Wyc+=)*pYLgK%v=4&sA|F}RhEnzp!fZ$C7hHEQ=3-%qw$P$J)cEb0;StI=>iI@5 z=0@u>pYA>9H>F^;-F%E=5mtXEx7<7~4x0bao`A}Nx)b;U|PG7&?^fbq{YEe$)k z=O7^v&Y5W{QK8qCBZm2T63$opp>*dIP7-ugqppX5?B*jv74LKcHmT}Kg9-GT;R0$# zW>4&%*ya%>2u6zg_I@DB{tQ1@2_sBv2_p!jc+Bb#VmSOpiVR4kkv$Sl9K;p)_-0e@ zwQ*0^SW{tZ8zM~U z)&Ve&3vdwTu@Qe19y7SjHFW*k)VT31&T~XP#X&CRR)?n21O_7&Yt3m7OW=XE> zKU^GTL$*%RozCW%j5=*XwB7ZlSkyphqNh%!)Uv-Ypyau3kOxO#^mQhl$q{(FSGI*> zTs39z@dvjj(3yR^A$?dw`7Tsz=fpPx#*0@@KYKJ;hZq#H85%M zb%~(dYz(JRJcwPFtQ@PGCX`zG4qd21@gnn0Y-A2tCFheo9~EyXKiQ_KbOWxzP#hKp#^%CWJapp{Qvr;FgOCDI$~4oDSzp7O>uqs3ucoPHZ zUyw>tyte!W4wB+^q&(<>q&(<>q&(<>q&*V z&=cCn;ZMK=8F0&0KPrCJdmr&iPZL0d+BEa%%<81IA+dJMGwL^MaYM2XB+8+`!CvTH zOZN0wEl#2|?f`h~D=dxZ6d-?WFR$x0D4N&IeN4WC1ulEgjk3rEQch^j=Hc~l-t5Eh z1s!oH0`odpnR9oA}v;J&F(T7bw@cc0<>cB z+UM*R`FfJ$mebTv6Gqs?{_%MB9T2ffY7MxMUB#(gu!i4u!70w z68;QOEEC5nyRadYKw2Tq-sV74UXyodE_~b0rC#!ALts z9DTjxdaJy*Q$ickO{C;y85OG&lh8_Z{)HhD2=9Kl+gXek{Xbe zubwHEFk4jNCGIKvT{45uV9|0qf0V%`N`aw~(KS{!mpq$6MrOWFRF@;gAsw<~dytfT z+7ouqG;S*QqE>%MrHiLiBJQ*p^k zRA1dQ%jR!tgygTmwQblYbNVqZSJkNsH6|o!*m6b@)<8a7<0ki%Hav%6nVkW8&O^?} znme_;DD~(dvR|Ab9@A zMjmi;{iq4sc2y?m@3kq|oqnUviILA{vv>nt*A7wg}yt=u>Wj16(4l^_xQ)yJ-QkPmjU0eZd6b zT#T@PR6mT|Nu3Upp?5EP6jJY!3#6=}%vp*2$I*{V)L>n;e-gk?Mt?ENUU$P_W;a(~ zu*7C}T~JT#wr4CiCyV2O3k|3jYHAKX@u@E!%qVyCBTElk)rn-Q8mVqp)}yWJFgOoO z7o@-YGF3aaiu7(r@lkc0#^oNto_#Haa+)TcZ$EkC+ z*rPcOWVMX9bHUcqUDTwxyXr1-W3{PKAvLkO2J0|OUYguHGH1RFbKgh5o2`^PmxrWG z+8GG}5)@|L(pM=?W1w-og-16}aL3}9kkGgsT4e-)W*!F<2L=GfE!ziG%AK$EuSOK` z;N52-?ud&6ASW>3-q{@dy91PikKb}4px*I+%!9EJgiw*T`m1t;1Zh8YtSh=>|0@F_ zudFUI?;~@+N8UbprkdyNZuY~yO{;O9YOcNH-_1*EFyhJPX##S0Gv^|nY+kav`Tu@= zUfe*Zf*gsb?zEC^&zbML_@|mz(*!W*G-6nTm0fJ!#b-!E zzIuhv%K1oNaUXR;sP1sJ&_xxyU9z#^Jdc>skh})cmu!WoanGP{VomjUa&k>``g^3! znF)~Q6&GAM>md*U)I+|xE4FLN40)JVU*wqN=4;JMPd$|~L8Ztn#a9F`>>C4F6L#5~h5b+40F0!kM2iT1veHP zQ&&ePnLSow^&q`qKt&e1@qBfWt_I@q8m>@?l_5s|;<4;g#w4R0bCD*|cILr4u-oBKZu$>J@%bckUiZYP$J2LtQj00cuOC%K9vuZPbc zaXlRH>MEvdLad+G!#9p*Jv^X~%q@ps4=Ul2Ha9dSY2 znis?^1qLjUlAW% zjUk|fR;-9a%8dg>{N3SK1fHiyToHHV6>-oN@iA_jdTbPtMtF29LK3i7G2As)#I2(h z@prKz4vejcTSqJ6w(%A5g_SEJ&7$qJE8^Z4%9{T=yW|T4@^PD$umkIdQ^j5kZGSRHI|8YXKs zu7iy+CCcPH3+GHaCe0Ee!D_HcpY1p%BQ?17C=&d0RMf4>B+jo@2+Ts9c=nQz&U21V zN&bDY9QJx-gfHJe)#VT?A(lo@NV!HehLY9K}lbbhntvO1OR!M1eEIl1Pb2wG;h7 z19bp(#_x+^D*D{j7aAw1l7*=tJ&R`YCxU{6-mN|&vk%S6LxY?|ItZpL_J`CWL+XsM zg%l3&Lqs7)4caW{@8+GANSWAk?H5bRG7sOW8MBG}j#P08Y22RrG=yd_s&*SneA@kh z@<*ncU>glPV%LIxmBb!69^^K;D_f_8U_gmM^`>yvYz0wjNa%Q-$3T#^X!>w28#;WnbEbA-6P-zd&3ORHHZj2>e}c-^@rX&)^zxHCsih6%9sgyhcHnyZ9tF++#O*b&}>tx6PykGO(yQp zY^QNn20Mox-cp|uNt&`SDVg4sXoeWuCaM(L&mSU#Di{%F2mfyK?a5z>#Sn|P|2Ez zis@H?Uz5`4(p2>hwh*0geUOF^b$9z|Y+|qkIar_7!+O2EULR0FJ8VETvJ+V7|={}YLR>RZj-ogE4*kaI8 zK>M-d_`M5)*0*L)S$#JtuGu?ZD~57$C+{w*JC|$_7yPAC!}pO+I2Zn2T~uG+ER*SX z%m{Oq>yM*r8o}`XP|#EZC{7z>gQGGW%t+1@hHye`oIY%d4>%$C;cFB^d?Rshp{Ir5 zE9@1c52A?~_E24mUt_(6vE z!d%7ESg*?YI492N{J$gunKaxF6O{nNO%9gS7uC+yU(Yk?A`=z|u}I=e^%0FCCqanI zlRrEM9bN=O9aM32`!=SN#n(xLc)zU0NxCQ413G!5b;dS{z(P?W^781itdED<$NVMk z(;u6ptqt7oO3%oyP#qp*b(4X z^QbGDJ3BHWUX-kuI5cze^&C+$bI*u_P=UsDLMuU-yJg}SeyQ7>#hAV!`;7z$ZbNA? z6qg1|KLUEiT2U|?i)${T3{rwC*6D7UgKwo0Gi~s#89RXEhN}7*EAakms-+M}9^Pe^ zpV+@rC#GTzFi$F!MN(j=R3N&JRI~&+wVsWq^XWi~s)k)i-EO-eRiYhf@CuSFLGcUJ z@QMi=OJ5W;oo{mKHJ7qAMRlK6v+SX>+eX5Q89m?$-TJ2xQc`5IFN^tQn=d=!1&h!} zj?+M38dc1-$NGe?P@Bd+O#DHrnD#ir7{8OAW+EixAP&tLzM+opy2?hdlUc5T6MLaUhgk4qgUwhY!& znE#%&C7IoJca#W%>v>_-RZt0AjVCNyYYzP8vcb-k02n)eq|@2ER9vQMd`WiMNQpU@ z8+odF&eMJ>(RU1d zE)>-+4O3we5N&Vtm!pH##ucI*w)-DBkPmS7phc(=lU>Brv(ySXgw_Mpq7~i-o;2?D z=NMW;>^D~*W4#;s!?s{L0cbSKb+Wml9?ei--jk%u1w;B5 z0Gl2H%;ihN zf)%5%0BZ?Yr-i45>6wwH$Ro1X*5N0* z*<9Ve0Y%I^SR@if)7qV(kPApL3oOXt_Ay>kLXJ&fm&bXR9n-7)FiR?b$+LY z9~#Tyk`U#z=bUb)D2M$^s`g%z5P`+#uld|e^BF*<&kvAyU|v%S2X?dY%y}peHdWa7 zpVYZ=|Cth`b=VB2*OG{3No$_oCw&ixf%HE0qL`1Y#9nJYVu?ZhO;X^u&#b4s8=XV4 zOs^B^m43#CQ4r4EP{9i=S^C1!R`wXv6EHOk6PFi|MC~oIspSiWRUJ8TS51N-E~2B?rS@O6Dg*#d(KW>YZ1M{F?i<=vP}0lt+iPGqPw!lo-}V)QiPJlmq>QhG zc{{!HUwMHYd-3U=Up5mw2#+sMkDGbi>m%Ep$1BsL8Lmi=X1Lr(q>nsanjX#Y()4JC zJwBpN;PEB#o3NWUoT>)&V%y=Khspr<@?z%_iqF*vBrr) z`NA{U(y@D9aB6<)>^`+KO$JEAR2u19y1uJ-65by4=cLYmf&pXmKuF+T)$A!i1!8BW zZjzs(S-%_JmqgE{uqK*)wY+{Pi&YKw75WHN1R5bPH3|fDQuI>3&g0k~6HLJKwB8xq zo;i3V5uKij?U|*Hk+Bo4T}oW{^#3;(s}b?##q~@U@od#Z0GZpsAmbr2EEr@wy6EDB z>3KL(Jd7qub3rKw;s0P3_ppbj)htT6A1^XAc5+`sXUV&{W=}2AXPiNn_(KPfpuJr( zy3u))qeEE_pUP(MyW3AG1ug$DrJ1@A-27;FxBLpL!^e6)e0Lof&C_HUy;pB8XqD#| zjD|()43m~tjV@Y}0Rt079@v!TVC+ew-yY1Nze9PoLd{f$Fd)WxK+zbZzlffJ^c_)5 z6X2@ex;~gYVhLUhgXK_Le$PzRrJJQal4fu(W~MspS%na+K>)o$HybrJW!PVmhS{`v z948BG7x6VoyzAk!JZ@P77`p5>Y9-v0#KED5&jJNR`b%~Pt-xw5h=9y43*l1;Ou-TN zD~?V7B0DXYnp2im|LKR%N@s9tN`@c2(p=r+mp*#UX`Za^;?t6>WJ2MO5}<^*I6|m1 z^j2vr4>!5eB>Jx|IX#8f#(rpsdgkLS?h(PVm?rA>0qh zfIr8Ps-TIo)hBS{?luQP4ctOp${;};0T?4*4)ODc5P$AtLHuWd`0K_XPIb+R3F1DE zAWou2-@yJz5YN3ChxqwN5AmN3h>z+RLYx5&A^x+6h4^L5A-?@^5dWbT;y?6+KzvVz z`1va!&N!;yJ}kt6%wZw^$$^8Xnj{=shYvW1VEOne+0ya#avnw<&+ zoAmumj>IT3uTFK@Q$heS1Jwii^9Y{y6H+lh=};W#bQV!r*qDf#rjb~Xp1t(LSZJ(} zey}S_VHjmVCA&h~gl7?N;)#sAW>hQWDdPKpYniid~!! zNWXGk7;Uoc)bUzzrrI;qd!#|poU=eXjHqugEp68`5(v6W6C{uu_Lvz@!w^Z1&PG)+ zd>ZHMg#rq!iz*L~dr|SNwtcCRS(JFqjl(wva-rBQ`#|;?pFD({k$YYF0Z?%j2yS`96EYnP5@4{yaCS#Hm!sw1~u_jkn(j6kWzLnm@Y5) zIKfK1p#;_&)(3P1470urwBA+D6wL0Te=p?ZrAR>chV?v=lp(wi(+AxWTk!T<@IreD zUM4!>_yk@cbA0u7O}#l*23e_GN}WLD2OWx8^q8 z=CZxgz_~5IZ>e~?VNhY7H zUy$LaIAOVXCyI|^19V{o2mKTqpuYvdQX3mUi7{2eZ^(_OAsuBuR!1l3rt&d>@398} z0BSO%P(vkcf$9lj`e-5(yyf61^g=`?C>dN){bcxwfMwEt1d1wA0Ha)q;p;>qTLpv0wl|EnXGaErw?zYpqb$VJf&SHpB z5oCMrDL4gHf<(d)a))PyN@9LkJ1kG##XUbXiQUH2^eRKh#XuyAv=@nbhlhi!l3+kZ zV!YX8oRSLPj6URYrzy1t(exxIC&nk>RLUb6V#na$FXthF?buR!bsMk*npFNg_}`H0 z$iDF|zo?3v(cljId@v9bphtQcqNfA!KhLM**j+rA9~fRpVD@0NP(3=44ovDfUlv+f zewh0ZHvrBCeIz{53l|`sl}DvbR?zMgCME!haaDVf7Bp7_N;1hnr5Hv?%ITd^w}6PI zi7^;{)f7Y$3|qi%XloceW(H@@ReGAT{SO@d0d1VFIGwLT9VYR_3=gR-K6y0rX^o?K zam|x?+WJzV$9XJ!$_2G`)B4e|jOd*80jv_m#nl0v%Dr82hkym*P`+tBPmArDe7=?z z5x<6_y}?9#B*$3{=3j9n&o(n2$+JzAv-@it$Z)$8V+XRt-V;P(y>IOU`8`JuK}oDS z!SLPPl`xc0;-diJ;~G%JK4uM?d0DZ?3CAIM^@dC}uOO{(x@ESpQ7v|j=qmEIRP*yV z++qPd9 zkSmuFQcY~LiJu;#D23rkodG?d3Z>ce2@d(Uf<4?2h@-&3dY*#i0$J*!4#^??f`$&R zD$qsRJRrIbn*#FU2EAH!2u*c@FVWEZvQ;J`9a-^yqVLK2DBe%;eJDQ)tgI$t+{Y9M zimM@+^7Sn}Y~9q#Xd?<*)wG!m`97C2hgj&dp(kQPvjbDF+Hebo{oSk_Q&MV}>-mTw zvv3L&nx6t?YA`#HAazJ#?;8_N?2Zs>1;W%^ZoK?x%&^^~0V^mRjElN2M$o2QT z1WjPpfkYxdi$psWtZ9wSoK2sgWMlSO%QJOQTu_TF&`}QPm9FqZ#+E4BKvA3nKnf~n z#%iFgJ$pR^LWtLDkK>&)A^O~Y2b=-K^xkFXLom$1AkqVa733@HwL*8X*iyJ2JHuV` zItH}Hc5{M*fKp1k2`Z4gVC&J3;X7SWm^gf=3(}{{6EuQ_RLz`_rxC zi3HZ~a|hkGTs-J4opB{9$REBkDXjJ!;DV^jN!XGT?)kCHc$-ac4?gX(%l+8jYwm~E z`{`JpADN6o|BC1Dc1`VGxwL)n<(FT6T4y^OBt;M}U3hTh1Po^!Y-?bk0f4D{isnI8 zuJ2y&I%?kCiM6Oo2oi-2hixy(``(cBd{G8SQw$UkxC4uLS8=#Nq$(e>rDnfH-a{Nd z2pRui-G=pKGu7NYtgDtHp%c}Q@w+F>BzR;Aq?)$#wK*`V2$ZBoJXdsRSP^xEKBA$< zg4$y1mb?L-;ckvvNlI(W4KBS@E3KwA#fqVB=-TEUt5yvC4I-ClEvkQ!ATJd1yUZ~J z?eU}C2E{`-Tzd3RIw}5R^@CPLqrEn^O(%T;zr9qIA@rm{VhYNuq3EY5F`_FLNpFyx z7m{^oL|Z`i4M-_rhb=MH#+8|}1MCK4Jw=$BuH0~`DJ!ss%bXrxp{8<-aHR9ouG7d1 zW+Q@D#%Qs6r{nwCG?huXs|l!uD(e|IpZM5O1`j>AcEqI zZCCNK%EN_3bQ0SO+mvt%2vpe{Q)PBmKx5D{1?gN2)3^%pc?<>6w(FODj*mBYSn z0}U-JQ(XqbGv?4T*>2J3@OH3UIGt_hhk@h5Q6qh0Um3{f87UDD4~13X-0?DuX}t&# z794^Rrx7O1yZuB6L0y>@{FCsA@*c$F5etb2otZ!w*y}g%z4U-XL;!&6Qq=sOjovJ{ z3KD#bcB}{q-zT3E!wmqmpMsnShZq>&@56ru{4f7L{L>!&XS)A??R$a$p~LO}m;WR0 z|Bruv|36Orf9dxE|GN$c|Godn@c+bP!T+AD$I?42nUdTCp)H9%Zann7p(%-B5|$l0 zD~*T#Bc>$RjG2;9oxFpx0v|`FBqSb%DM{`PJjKv>=y_^J!qD(Bjfegt>}|9gD6L17 z`D}p1fQF_d{}Ik$ZR4RYEjKJU^Khml|6005PCR z%4jU~JVrTgEX3HW*B{n&1W2qn|3}6`9}m-!o5OSj^+smnbr+VW!~9pJ`4|`zgSj(E zlFZVeiao81o&rvbKQOYN{?>sG%GfXHmyg)(Oj6-KOUxd3R-eUqv;8N_T4!1=IB(v! zR{uSC;^P5R-OhLXeP@Y3TfMmn(^p$AoWvAc@gvwPV$=xb`ho z76Bkr3xuHzCX*x{9C!Y`9 z(Xu%OUb}^EH_+*0`GB4>;_@e&Q`{6oE`LVGcjyDkj3q9g5`yS{kk3pi!KM^(@FO`s z?gL68`T047;zK!FOg<|md_afNv=VPmx7@kZm09hg+|i`QQgdx%;ououJ92<<@N93? zU5#Od zpUYxPy>Y>`L+zW8;e7}mJ#cv+0;UV@U;#1%p*(6OtyX&!lGa)JivT4_S`&m3$Jzz^ zk-KE;<1570c^`IRR++5|$>_XAL9QWYomR|>G3TUvQx1G` zD`2nLbd#W61(l(DCk`r@U7m| z)!a5JHivgD1*h;;ovddakO4^ZfbMK-iP6w@zxnj2XwTW@jI)M%#-e&Lw{ww;YK;Rv zoNmxc=y(VKQO%@Cequs)9bVa-G5$FvFxrNHL-5$30~oN98AKvVQ5;5f2${nq5axKO z`?IJj*9mb<`#{F*!EV%9oYeVORM29|2z~;F;pzt)m>Nvz*BQ@qgM1mwChrfU+~&db zPE-YGu?92Y2dAtP)2cZ(3d%%WjH3la7rO@Qnn^06RR!Sd;%Ocf({)($b=i1DH; zd4o4B%l(!+vjm$dnnb3L76U!u>79So&h6Gj!%}U{;g)L8b6qFb=;H_LAPUi2rM4!c zEoiKIy;j(OTrHW@3UZS_%X0E<`9PI^;6Qa@A+)Z;a;WbQ`gHLoPgAK`iC*nAwAF8jx*j7G}K9TDB^%|9tiVKbBrY*d}^&K0kEv zy!3OfIZrL0M>XE{5LH%xF&=$ejAT2dp|^R-q)nWj@r4nLpP(sic#y{_n$m_dOxz&j zlt(|#rh2&p@tt%Uu!yek5O-gsS)4qaW|oR%3e!u z6No#em^j?dxAC_pUA)BIMp7%k1E5pf?c2L$e{@?SAnk$+)u*yQV?Pzm;qRciBUZIg zjyq`XDcG=3N`R4TiNl#>^(8bnPI5rVm&Vp+CrCeNT?~Ta(V#@yXPUwRO3LaxV!qDS zhN3TJiqk5-A>GzCI@zY2xe!JtI~HhYu>{zQ06vrjfPbR;&2XaP ziJ)8M4k{j1E;+yfSiOn{)Snjh@D3Su{~k!X#k;)=ru{D4R3Z7-U2a(pn~(>yh{BD( zplKM`wqgpZ&k|uo{M)k*;jdfP>{8)>KeL7D(=23RVyOspI+-ZjvTEqnYhNllAp!FbfWWdl&g(BP;$gEpyF&xy5LXYXOIFP2V)q4!$_NBr!F=R zf8~Jr5Z_-hDN0vID#_+S7N}y|U?zooMn_na6j2~7z;w)1x6^04@$+pbs7$w}#nU@? z!@$~+e6)6(A3U}EGHGfN?(xmz4`e|q);fqRPPrU#=x_Yl|Vipeko&EaCYZldTZ z2}ziN{DdT{w&1G z+F^x}VXryKyhc2Tk{|0tQQ9TEltm6fwmPGmJV9e_k3GHfgM6=5>vS8WG(eb#A7lcz z$CHpXINa8q&2L>D(@8Kdv@@nuXlG#kT^Jnw4xty2nH8{N#zjsqA ze(xNU%9cpQ3H}yA(}%r%I0m>$(`5G^VzA9)6*`^P1rnHIt(DS9ulcigcbeBR&iPgS z0%JLu(j1qQt9rw6m`ubJYL)luM6xFXO+T3J~|2{SR@XH243nx$LM6v5@NNi?Q*X zI`1uYc`^N`iehQY#Y-RUa3^zf3CsXyy4+JMX;gBj`he?(FCNV9T}WqozxmR2^Dk_w z|6EVrunQBioz0IK3*pj>Ko`v(Zbu}v%hDsmo+&q}1zs19)WD>WqiYQcwd(v-wfi;~5293N$K?^p6) z?py#pQxT{4u9_?5flymCi(N5Xe;y@g=Z6hGyG z6nr4o=#97|iG~gpaEMvNgVwqU?>;Z02RUX3KS><^j{BkQ0c2pl z;x7dze^&z&_uvRdsdbQ5J_uYhFz*0@*<0Ah#{wpK0Oo@M%sVnL_dp|z12dd+GcdD% zZcN*g1mR7o)~HCmGU<974#42Aw6i-|8?rxA#6Ff&A`?!nB+ z!cH{zlsu+0YsAmU^iH7t|Kvmp109$B!Y_PnA_qKrrtS~*02~X znScWsOhQm1>agc!#^m;Ja_3lfYQaP(;VPIxnB+SVpUAj_(s>WN;i4{gEif!llWN!C z93TxniVKFg7gbAgsE2|g#s3`5pW*u8ryGe;D6>HAGM30geLzTv0IMmQ8^`h}m@=8x z%mUBDkHow46HHHa9U<+cZxU$aUz!g8Znc(6kuq@LhPddHT|%{WTg!G;FvJ0p-l5ad z!AVgjC;R0%`V^#X#t-ME9BC1qnV?a}JL(plFFLR!7|ByQ?zDq&#Ea>(s%~zqdPond zdTRKN@vs@f!O$vocOeUQ$`d+2K!9ion`R*iaZYR2(KM7C_E{!_b`dah85T67gjIj3 zgchp%H?%oU=++_BI;xCxXjtR5N2*bHGA<4~2T#k}B2XBSlDjntlOE74YPmSZ!`v`i zoVg6>GzC+HcedZ0ZNu|XW_@fzn{`g8E9s<89n{a*$C&LXAB;|!3E9_52?<4nGAI-V zAvflIXs8?5YTX^>j(UST6QQ{3w|R#V*RHda%Fz!|GaWk5TE8O+qv zAV4nR1~a{jJxI95ondtkfd^4$lp`is+hnG-3^VpHV2@1)lhI?(NsPLK`)SLRJ9OmR z|HxT`32pS)xVZH_a+X)I)sxcqB{c0Myel{;eS$Gy_y6Re*m9aV+51S6AxhcxE|LrArv<>dqkNr zkYlWmAVu{NQ7xh1F??MPyzL-s1)1Ri`SG41Pl}8fLMwqxm{X!T@K)R<--0_G*{d(E z2mGjBHsxj5Q^CL?fust=!@E!uIl- z(1FlrL;C5BOH*@$LMR{&g&|`6)*p=`HX!m_Fn?qOhDyMyTUnq?ZH#c=AJO$2-_D2i-bq5 zHO64kqYEJ)fnYb*8%8N0)??GR#hrCrZ?V4lm>hvicDUymTRCF`b%r8-v~)MkY9cyV+Z(@|uD9^9RVn084$ z!DK6#h@#AU;vH2N39v{7KsnWe3}0bTf$I@TkPmY#b$$r6i1#{nG0OEZvynoe14@IQ z;T!U8uaLz!#SD56lYs-<3@7r&x5Ze%aWvR)^-d^^KrfOsc8PUM!d&&&oAe}(sdF4P z9Z2K|lDg|uND)u|1ILE;#Tkj=#V|8CtvwAdhS{ciI&-B-oYS`d5r7*O8psaD95q)H zwJmU)ESeAEHoC>>^u=%q7K}m1KGYr3vHOoi$9`f39s61YFvV{EYw6fg!g4xxEPb4g zy+b;dd)gGNIbjf&_Z-twdJ(RSQ)6c}Dh(o7LDn8RB3XOK;~;DQG?TU09|c*P^GL*j z-H$}pzG*pG%idg0)_(6W+|z6KTEOt;5ifG!NHF~K6)^nzN?v4?upEYC>Ekdwv>Jx@ zt^vbQ>D4g&&Jkg#MeqXn2vX!RS(EQ(7+!Z2FwA+50)}sX(qQD4g&@DXA7c=q8(o|Juf(__H!9+hJe74+tz@Qx!`A{UZ{ zpWdKfy#gJoBGMDRaAj+HUepq!=JdZOjL1UMRPYiiA88-2@8B=E`#0ddOHvlg+eR!V zB~vikZrn5y*-6P7qmzq61+*5TPb7NMiIXQ6-yp8Gu9neMATBIz$8v!3sCmL=U|}McPYcEjK%+j;rNtC-la0Y(}pu zV@f>}LPu^X`dui!h*rEngvPjRBxs$O+k?k(to@;K@0*q0#o@uZ4D|v<*)bnPP){Q0 z0K_a}gLFQQ{??tKfcl99@{q-SwP@b^s`qr7ck;*Y#h|kV0~y%oE!CeN7g?&$tS5>_ z_zyvw6xHQ@Uc;z{H8bVHnXBGOI1Y_J3TPbYqBnMV^}zGwfRB;Xf+%G2i$uHFWhD*K zfjjL$G1lCmJFg6<2Uv3!B19C`D^m&jLxwKsl1^|s;l-ZFnoYKs2qZM7zVsMPB7`7* zq=BG%pn)WQ6k33Cf83y(5<+BHOc}PO3^i|jJDvqzCaMK8r=^Y92nsh)2+~C-;1Bx2 z+A!#LUaQwXg&dTL=?iV5G88#SCP!_Mqo?quK?DfyjE!%Bxhtis;X}K#pH|ViS{?+M zW(S=kX~rr^Yo>>+9IX+KyD5_;CXx-VhH+43vmuFUeu$-{ZM6~`so>CvI1SJ#Lpn98 zR?d`&!tRK!rGCkRwaTS6NA*!<+X1C9BSJKFI*En2vN6O$^aR<$m}tlg;Pdd7=UkBs z5-Zi0ghFk7D{_ejprub43WbO<&j2)Dula$wRw#ssNTE>hBdt*AhsK0LryQM7h#j$F zQbWw7h4eC^(7Q6{A_t1x!KtgetP(;tu}acw2s2IB6G2W9gh&qoX1Dt3JlU|Pbu#uM zT8rjyBs>@R@N+(TTz<}5pr|H75SSVxBR!BKWf3bxU~1f`)wi`~agEX*qJjU-_ADEP z&V`ueZL9U3)H!jXWOw8^8cJYMrt_6m$K@D4&Do+`3qF=cWPK4qM4Q!{`!*2xONo}_ z1&FLi{w(-kbRhO{v&UEvSe#Ksv#0X8+W<_K7jgESXXFWBPUg#fLuh}JQoC-n6+^@@ z%tS>QfuvZ+9Y$YNe*%(!CTT%~(G*Enn1|d9j_D>$_P$o>-QxgE+wwf{?;ql%JB1&Bv@O69 zmREyGuM*;;HR2f?KC%kHqt87rlo6omO!e}dS1LH?b+7&Lq>fn#zju~Z^~woPhY53@ zXJaQ9`)KgFmWku*{5C(5fYesgFtX;V|S^UMaKT7kk+n1Y%g+^tX2Bwlm zWd^W~^eIpRP!U|kJ~6Tn(>iQSp8{5aTo@%>z)_TJ#Uvxf(zj3rYngQ{qJVgKfVatX zuaj}F5vH6qm}ZfvZc#3rt$65Aq^9&Xm2P1hre0<`7Ia7oH4PiKh|F-*nigW6>iTYL zA!ZBqBwL7~S-~7k{KU`spb37S=bz_CUp1nfsNSZ97`-WmV_=6;>vhx$60o+U-LdPL zg<8`ttc9Li^l=*Zy?;6MLXME27jlHPp@$S9C~BvtDyJS0lip` z0X^a~Waud~)2}=z>M`h%-lit#$px)|-mt|rp!bF$^lV`adI$#q)w2`y&Q8$7K$Bx) z40^wJ80fuzHS~te(-RH74}34sgZEqpy%AHGp*Koc4!yDTRnYsJCk1-L7T18@wSO<@ z-EtV{{r2|?J>AJ3=iWQG9C{)DNqaBkKWpzjq(94`HxkQa=#3JVLvJj774-f#ptnE8 z!2xsPPL=l_GJE!3cB&fNd!)CiY40gTTCw+rEv^B*-x@;C7RL4-LLE0++I#1wy@y>l z$aHM){r+K~w|_PChQg;c_ugL)g$4(PLW7$AEE5{MG7Am1rdwJ=fPk9>#2!<1e-;{0 zN;CMCLW6o|^{pZf6ex`Y%Y+6g08KYcN|Vqaqd4h@yNV<}F}F+vzQ`sxeELPB#| z0j9*q2YEIW8r&2;yk|^kaJ51MJMO{PPUx*6G&r8BspOUr8f*@sLC6{C^hjc0lpr$U zY?&nnOziDS4BoE9;J{%d2A>*&ci-W``>G>>H{BfBl_S9rdknk}v20DQUR}1}-MfO~5O?#)Bs{*R$V=<*S8Z9<9A2bKf(>Q*9@fqU?A1DDpufx9OI z_Yr_8aKCtD;64%~a$K!M=r;te9T&LmbV8^jZOXvCd?j${^pS!4UV-~Z0(aj(B5?P8 zAGrTGzzw75kmgF%A~-;^blFp};#RB_a`{>v;7H~ zQnOvxsPlMN1s!*f@nneO=S7;4jl3uWRdOi9t3xx6k+|qd+J~1`G7dm$LID|1RiQBW zayT!PQO24F`GtnNV0emM1X||%Gn6rOchqHg6^81$TYW-b&(zSKr*O?Sy)3G4DmJ?j zhEMbkD+BMIc4r{l;J~AY)!Ww9oz@f|TZT0G;f=&y;Jw65>d1SrTTCmeO)h}~CjAQw z5f~c|SUkN>F5cP2N(giCIm5b>$VKRph$)F~k#gvOf9eb}(ox)X}})1AU-skn1lWYr7r)M5%=-<`sE`Lidun zwyu`(Fbx^_@`Pz4kD9ZUKu{Cnc@AwJDoRYw_mn4x$bs{qi!KaU`HPUkLsd}#D~E;= z!O&N_xyy?oC_%sIvsXn>Pdhpzg?-C;}vNS>k%&)y-L zdb(vQLzovwIDczLNTXVc{#&x*GL^#Pd0Dk&eT5l zGj<9j711#I`EFZJ5%pxreTOLL3f$UUo#xHA)0%5L2YW~K_mkdft3gB_L%(^enUD=e zRdK6n>Jd2%G^_C3bLwkdt`H#CJ4!D(?M5?92ct+$w&PW&Q{>Ly&Sj>Iz8xG-QRyX& z)ccZC!73~cn%`N`R~iEJbagcB&iJsgS5t!NR>X=u2@yskkHGg&O(Tb{NAyT0^YiRF zV=}oHtm(|&qE}$xST!oi+#PI&-_4SOZG)LJdPZ=+(g*OF*mDk4)6I}-;RU$kek*e# zr)-S4u4md{>IU{(!=};sY~AEUK~UpkwW0IWNK}7t zT5w2PM7Kb0lN)T4cD$jF13__JCks6geRZ4IGaM6eeEmHQjZ@w>+mvwum>CL$ zWSL8nrMMvEm(?+$r#;!6>J>Gj1e@KLy{(fWG$RcQ=T3%&D6ZNW(j)9GsfG&_S-g>L zQpYe>BwO%1Y)}T;CBg))6Vx@*aB0>9j)acJISkyxC1qj~!eU2-9Jxx6eAJ~>y-TEF zuy1v>A^oBNcoTK4rz)U~FD#01_w!N@78%}HIN&eLkZm%xfZ*3Qusw@#g08#?FW~M2 z{)KgE$zfp``W{{FC%BW5*9&$09(1=1l&SIGv$nWY1rYsS?@2a?zdg)U>CbvLZ@9vB zhj)|(^F+{soeIx7_;CeWF;zKrQegmues6%!CmF9}z6;%dn zhw6UlNe$J_kvLB3Xb3z;4Hc3eImWg+0oV4?$LW@6s^j=%p#f$9=s~byFDSW6??{=m$2fc7p!95X`_x ziw>FD2Zw?glp?hL;3}ag>1}Ef%sjYUFr%txiq^qBZaC08*iC8nMD>=TOvcLnmZjO; zTZ90H>z@4i`2}_^G^T$pj?zh*{VruP>_M15e1<4Is+@8vajL6Vi)XkEDcJ_CDV}+M z8xIDErSpkM^PF^J79GEwx%Wl6&DtXX{hh*@ladG2$lTo8T`q(9(Bo#)X=$8I zznNVTG8hjHj>P+A(;;pF3j@HCH(DOaV4`=9fz?>O0{XbQg%?@$cFu0)7UJQg-NG%z z%vzGaScDFbv*_XcjnF5{U${S|x`81%jUR!AuHGRAMJjMO(~WSFl$qLykPnnh^?}rM};w`yNj&s4+{HRIf=h>Vp{On*}_(7o<^TH7e zMCL}S!{|a(H>}A3bZ3h8G%}4-$S}5{NMwdP9`&$gst!Gr*vOvS&J*nf&EvzI*ZFF^ zz|=BOueU{e7`5$H$Ex-)4}TW0s5p#F=h@WB#ciQDl$(<%K0jscYeLN9J^aO$zj`S` zy|LM%Kg(w;oGR9ws?n?j9O)p_$8lWqbV6xxZpoHgFNZaVplzVI^mQhw4ZZL|`_7~` zyrNeWmo!+z2teixh&HeME0~FX^;^1+H@|c5yEXgEihe);xAD(!8hwtkzdru)#`wtk zR%M+lf8BV7>sFNBKmKw5ijUWifBYY7RQ;y$4A-oY;djR~ympNYw~S}FdW{TkAJ4Ea zWgt|}Xn5}&&v1FlFfpFtz2g}!U89LR%+SlT|7~6ta8DYq;Z8G5$fM+C0;tKh=rvVzJtF3Gv0*?;P;1fQUP!-R^Ox1< zLAIhENGs*zthXXH{~L-YqFdCBkp`A?&CT?yx#o4Lb0!_JYm`@V6n(4igFs{h4i`Qz za2rh*0-(9)5$wGiANF&_p2-ltn?K?11gc{{%F@k|mi}W-j z>ZU&bhTa*G!2k*5)A^2?q1pC>x8**0ypF>`o0@ilf*JInCjC^uk`dr2F#%nn%fOd<700e1=40#B6-UJM~&-1GFlxl-Wp`WCT(o>u?3L z0mUE8##M>gpaAodnT=Xr*V@3nQ9KA4JLyV!WFX_x(6;q3=FpRiWyiA zLThw)@SSSK)76`}eVp0F?nZu%;7uTY66RJh9UifCXI?G>4ka-i{LE7wOb0XWEe$c$ zd7it~UwMAw9w*bm&p6W|6DCl))mK>zEPc+^*=vkt$UcMhgBlV9qkk^-l1xJbg1rOHCI8Md5rFFmuqW0HG{VUi4RK=4)odjUsaQg1AMQxs z{0oCA+|c5%?(L@YkWN#(2?vxO_msO|^rGfpyjX!|@nY^m_o0jj7}CkJ>OP?kT!U6e zt2U&h&-O@+UWXqUj2!l?O?6J(R?hrjO=Fac&e>jR*JE$7JSG^O!>xYhsk}LdMfLj4 z9@DhY70OU9f>(iTIMjBVoBr%zr!F8r4k*NFKE`YF2_~D+Tg^dVZaRbuRm3Ev!s@kN zj>zZC6bA<)36_B=!vS=z&FqCfI*(Hm{3pxVi>o#NPwd5hqbJwnP$?0!-a1UGG)% zG2bz(%(Dzdr@DE_P*AI%GC#qUYY@mMg8%thTnK(5hYyq+N&Lk7M*IZC9EC@9%TFw_ zF;}w_%7sC7YllyIy@6K3&~(q59H6ZR*ywm6tS?*ap!%+@|EOo7`Q?98)XUa<V^~M0#nF(Aw61dJ5bkB}aC2+m} zFe>?9Uk#**BgMFaA(%))NpGMWLvx;H+$HM|A#*#-M&|Co)5}~CG3Ifzqn_B#CSp0A zT=kj|WV@`bB2Q~&`Q;7oI@q!$E2L|BzkRZV&dbWZU zHYPON#SkJKzoHT<92AS4&Z!*`28>zf|2ehu?|H&y^*nxX^gMUi8cf^=H>O5lapdBj zPi%l;6BE${xv3wU+O}6>&RnxSXF_c4=PZ6c_>Z6SM4XaET~2XIvNUt0tV3t9U;WB) zpjNSABK}^=cP`6`x2XH)PVMk(WzP+IfCF4_UAC$s@gY}04bp{>5bSqz(~}Jl8yej% zcDhW0oq+cTKcbA!kahbV5wfjmM1Z!niqM!B-BgCH%wE9u+%t;vc>=afY?>@25b-E% zUq}+s^Z5H^X7S)M*j_Y(?S+Sf?L94Qsbm#wfAQ4L|79;u?>wI$V9T1ytpVHH1GX2* zzB)B1bXqVdZE^XKoBG#+?Jq{pGi?8p#b1zMYtZ=&Tej)<2HgKN1nvv}{=f}nHv1Px z58T#SM)QRst`fK`^9S5ZL6whYxhB8 z(oEy&YglPK9rf!9BaNqf2%b?qogSerkR67llX=l%A(?5wj~FStwbUR3q;Im&Adlkd zu+)&6#!_QW`v$0e{+nBFsi71A3e>dlTRMJQxIxO zT<{meOAOb-21i49yXLA)3370hCv-NP)`7)Q@MY|s6CzCYoZAqANKoPtYI{Dm7)0QS zWP=LYYQ;n`RJWk>U-Pop9H2USVo*>_8Cq)7a?ATSZ%eEChX6@aht>Tn$NJZX*~Yqp z> zzSF$A9W(ng93oqobedP?PfkYI-Mk@760n}?Z-uPZ03%6n6iu<8ke0}Uqz{uJufkZU z;EQG#OMSz7igUID0yrk=R?NZ_7s^CINb-X!C$RvFkyWI&m8Xcdi;7TJw)o-x!Wyo^ zutUPr+snnbC$5^N2cO3Uz{m(ketfzZcg}X1zl(E=;k9sUS1w zs&+$Ss5KmnN_jFg|IMj#=-5(30-_*zF<#@cSAI8{T>ZHgM|uO<^duaUB0kHA7Wz$~ zM@FJ-s85mREe{+p9ilz%6l6^ANl|NQFBqem^&4|Z*lp!;0VnPj35R4QKJYVO9xr!{ zV-hNz;Hb3L?$L1fMFik1D?lPcS$#Ccw&j{uPXnw*ZaZea=}4TQ*f-X zobQ0NTP$}d-3{*S1g=wsq4%_5#<~hc9>&5-mU8a&j$w7l4k)+r4NmaxxK71rMKQzC z;;kDMmC2BBAtO+9f^uj06sCh^2#wR|Yz&iuUiAghJEMWMNlCWOlT69Crc4%INhHZ* zj}bDOO^oW9^YT6918!Vq&Uwiat?r)v0k%@}$nBhdYMz=`zArzKS^VRYLbUhZ7&y_1 zPw$+W##corqT#!bZR?WlRKbg&RlWlD^RF`!eJolhxsiiL4WyIk85ePE+QX9>ojH9o z$1<%&W^_cI$N8e~RCd^n!zpqYS- zG{Y@CON&Gtq4AF2Wu{C--7(A*RE@|jb^J49HH|U_RWr);H8ZK!pt<{oHLaj(Qc$6> z*|pC5s%Kz>)T`%FDTsAhUWGi%YtwyUH00TLXI?{FLr*m{64_=u&acq7fC!k6NX3FV`wK*B12LqxVQZ2Tm}V z3DR)wG3g9kt3vayk!~|l(g$`5DD*2OF<6nVmnBQ0`O`=LD-(cBu&JKK%Gjm#tM5fK zyR*4yx4-9XLFLEJuKxEhbS3E`D1n#*PDew@;SkS`1i{dYf(woYbOjp=%kxp&(ax^j zlp-1+k1mg0HpdR+X;AD^f(PWgq56^%;E*vo=Zl*1MV{9r*$nDYQX_?R=XgDvQYJA% zu_6;G)k{MGq0I;Tn0ium=H-l>rCFPzU#V?|wmVMoYG*RDR5{u<5x9ggxVRw|nr`k} z>A|l=HunvQGtEjMLLf-I%b|tg%pOJ?B!=WPJ#K#Q^ZD=UfYe+$8FEE12be597Ad;; z%}gn&n(FvS>ZH)#u;#$(v zr!EYeVtaeFB(ujKus@ecE)O-`)7;g0k4*dmci`;0?4;pJ8KK)ral_%K(#4W{BGmN$ zOtC{;h}%*KT<6ul2R=9*Q_5V?4B59wMcM&GKIZC3e=$CPsR)EX%3Y zeDoIi)VgJOI^vMTO3UBEO1o6xpR0(#;;Jf}r?mWY(08(ba#2H8GI7#UY_iastT6Z$ z5iEQD-g^$X;Smc53mq1;k+~jmnPqdtZW$2r2;E|lfD}`n#4E>58=VGT*>XiN$Z>c= zvE{VjiX&Vyy==>Nxc#c2GUPDD@b;_36OST9!h@wjDksQ;{DaklbUuRF`u)soNk6P1 z1$ly^KV8wsSc)T-?#tuzXRi8V?0h5{91{Efb=p(O_4AE;b`1NJ!#F*5q^Ih)hf$OM z=>>VZd17GvTE^z28@uZ0gFKB5OpCEHQ4Do=_A>U}OP24i_6;>ZT?BcL{5F+8hE^!auAjb=L{rGN~ z@YpiBJuTR1k4>5g1$CmlI~Z;mac?c}7<(;s^w9d|%j?MZKJS*8U^Ap@*dLG$k!h^j z;d@&fn=|sa?`=26-)Ff?D63u%p?d9cLNTW5cIGzylRnzs9_pQP2fl*J1VZ1+-&O;Q zO8snz03dU6f!g&(ly)^yxAyznU`hcMuYy*WAW+Nn^TKtpA9H*N<7I z>4VrIr`CmPU)5;X2lawT0eMC>V9}vwU5c*rC&j6q-?u&R?JfSo3}7VPwn-mU!KSt# za~vcsW#T1H$!LiJ&^arVux$eb`lI5cVt*HpSP>Tp&iK8>6*ZxjJ^UV5Xkxo+*jbf; zc(sN-Dt{Nf{|`>wB5h#l>(T+Mt7C^)nd2u1?4b_n$Fy3^e*REZ$0YoRP}QM4)uv?j zb3;JiJO=3ZEd%u8IH1FZBHTe4M)pt-%ZUtTEGPCl1Auvtzg#gSm@~*>7zrdudUIWX z`5NYNOjpO$b0^IZ%-0`VpAlv$uklmVtlx_bQS3}H?d*HtSXp%u-|Y$<1um=w9QeF_A}M2+RtxiM_g~) z?C0zJ1#OE@a+~x)E6&ina5?C1TN%O5HdU@fFC$NZdLe%L4_&?zt?u-gh1 z)v9!5K!Z0S33fXt)uD1he7+-7H}%fy_a`ENS-HaqGf!_Fo4hVH{8Fc?8@vxWF|u0x zb(Z@y-GKqKX7DnsJRC(_nWryvX@bU5@%ju}L-q2dBgY+ihH_BtSwFAp!9MEC)XvM< zW6?&=jNm-d=o(^AS9BB756@&fxhj$jN|T%6+NxWXim)WsbYOa^+(%0;Wugft`+VpX zetyZPuCrKA{8BxUQYV&*EBV0RpOwHQD#7`LjU)&82NwAmUXgtNga+C^H2Xh!d%mv+ z@->lNc+ZQ%woPfKf28V z7I4Tr6L`Z=7)ra?G(Cm+@@5leFj6u*8LD2qse18|r?3Mb5ll zw9r#Ww;?^@QI@#ICa=LuhX*No)8gV zXH0>(qE=ickl>ieN`1{;??5vDb;Nzb$o0-VDqaO`4SLn9*TbVR_vH=~F$s}E59uf# zbVfBk5d9*&?3Dly$3Fj@U44BsQx_j4%_98l^~brGldS_{!olPX&D@36Z&uu2<5iLC zFI(V#OK-M`#=OKPTH?~A#oUbZ3|iP1m$>gh#vAfZn84JbGY#{Sy5HyrnL5NIu+G{J zfzP5pe!o6Pn#P8gA-XfjS^H;e^^VkkB<+0d@Ksq;49!bnyySvxXNug6EzF7IRKS}n zlKac!;z}M?cn-Upd^5#zir0g^lm%g1B=(`bcLGO})?q8#;Zg&4-E^3IgiS%_SLWr#ZN9C`IN(DH8`0JlJ;HNC5S}Ivlaei3qwp{BeWCtO`ar);O zhpSaxeXjLQcduP*>g{IgrJ~wDTXSuLvf+X!Rso+djQXAMUhzl+cX@LFwOGuut?0%V0d^`OOeqLldM zA${wr11l$r5=qi^xlCN_Aq+rz;yHH+tGv2*8pOro48dW8#H6}%1Mks*v|JLUg-o2| zfdu5@2S3iPduv#Jh-IK#La$Z^Kb*Xpl=UJ+nFR8n$-MW$lt?r?V8}_XZEc?V;z7s( zk)p7D5m#Kab9Z36NR5`@&k5D)s!JYkEC?2&?}dfhumbTig*8U8dsi~RKn%0Xh#bue z)RD|8iC4l8-J(xcpb4>)6)~bTtfV?6Dddw=PPj;VSQSdz*2IJ}G^6T}?^_{)gtlj{ z-~7^s3kZ4Rr?R|pWG@hdK-5Iph|fAQmZEiW$&vo0X+r@)$AE$EjDb`%p`_bun^2Z1 z4^yc9WSN4K`-bsk*<4BmVYH9sWZ7KSzJ>Je^7c)OgXW6%P0@4Hdl6HJATtcYu53Sr zE!MJ6FKa)AoO#)&z3nHB2LzC7Zg|AOaJZ9{qaOaF#sY^eDT-X)&sVlBhAh4{nF>UY zHOkdY0sA)h0Dwb_gb>9RY$koNRxJc(f6Y4xV~Z(H?r#P0rGM<&xcUo4op%ER8If?P zLR1Q~)6fXl1wnqm#GE2ikYjyuK`4j69U6tYk8`V}6Tc@wg`kZE&kb;1qY$B~n{zS8 z3QRg<8$_`=XI_0XmI73)oz&I%q~ftkvCWo8pByB1gxiAPOcgk_G;;Lm;C+IVOkVSI3HJ|ph+A_&*SVG;BQEQD6U{2dj{ z7&_LE+k@`T<<42h4;|>(Z()KuQlY^SFyM*mGp%N2U&)bOnfj4Z~%cp=BT$r=&t21SA?vW6CL&~EW$(B@D%#-D;50vF@3=RG zyVa(J@Q$k%fH%v)KgUO5>@XlV>Hp_P4ssPRE2556y$*7m!Ed7lLy}PSE~-PYsF~~n zlfSlu+#_Yukum*2xzP^J)>2NYqCmcoU^tgUb_7ue8N}5Te$hB|_#w91_=l-nBJ3~M z{=fxUYk$~$xDWN=J}e&Y!?v|QKt!%Jju`MsopYO_neAtMt(rwjctfSeNd*IZ;xu921|CsYVI$WE)dFX8p#UgQxo0aAl;d;KsYKhQR z0Nc>PlFSu~k_ynJ;;nQ3yM~bXH7LXKg7NBai|7u2pwF9lYY=ZsQKoz0*&r4?z4!9$Nq_rtgU(XE-RQ} z+35%+7DSFc$LwOtXk`uG?s)jD<|Rx?_r<@k`&8dx4q5QbH>LTW!l|X<(sc(<$VNV- zo88ifP5Hz6*|yp{qgt{ZZ?(M5elg=A&i-i&UD^*ivQw!hCqhD>dE}_ju2BXH zW3ir}Wc6T~R1%~(QkGl5;3y^@p%nHLWQhWO3do(f|b+_+&v4`D;v7O_|mc$84A z&3kgBy>#ZossNcQgX!-uqm-+xsB9uGoxHLqK>iSX&gh** z8URbu6TH=luH&s+z1dKN%8}A1i>9l1-Nvqb=A3L-LDx#INj0FXdpr|PoYN!D_cz%3 zG2h>Swr}T~IHpdn(>)Ag+Rk=LSaY&dTTk{})5?*iIw)wTGfTVDM88#61dvU9INUV9 zW7#x6vFrMgc3nU6&tYA^@#xm|zVCg)iO+xJh5cwd;g60@czZ#CD|_YT1PbvZ*4vtE zJGb{_FK(MT(&}aa8Ik1963tRX@&?y864+Sa{;rKkUj4mKID+ycPxyD+3IFccgtvF; zIN>Yr(NXw*_zBPLJ=qg(Ge?^69LOJhk~^Cx{7tTKCEQ{Zf7hPyS1p_HFFzj4Jz?CV zBb=0BIS68RetfrmVTZQ*%%DbkoX_W;^@%Go`H(IxX+pwBv<~jM?^g z?b-gdWwZT+o|E5fXZxFDv;9BcIr+AuIVb;U*)%_{bCS57M_Sdr>ho!yeHhUrZTM1G z^~%tth6y=57Rl{B*~{8yjJ^hg(jy5z2(d3+zd5l(6|6QGpoD_%RJU&;F4i9Wv1LeM z*2eA;sU3|b!Um{5sKm9zlqa?fwRK67Tkq`#uoQ{doRcpPB8RjAxFAhIiF7;XQlJ*ZGM2 zHZp$BX8<0|XR5~}CC7$tyU%BZ3v!I<^WTw#u0B40(Pws|0@`6SpA8{RY6fG)VSl=f zG7A<=O0pN|2T4N9l9IkgQqlAmXiEi(v)y2n@vBL24X>lH5BaoenJ^Z2HsxfI0J~R$ z_y1HGimoM;u`Xg+e&Vq)|M2?Ar1b4wx`dOnY&HTGCmdl>$L!Wyx@5X3HMGS}A|FH0 zRW|=}H?kHMvDszdmS$cO%}l5Q)NDbc6%6aAcK%4GbFq=gh8 z5%3b&KzU7+glU!ErjsduQbephkqvD8 zWJGT7>6C@kzw7+E7gGduUdWU}3R;f;rp_5mZ^;6Tcz=!+Fn*-w@x+XfOX;~9!l|7+ zrMn?iJEBZTFvfU=0`<%}1QT|A>JtSy@3P8KUE7THqVpu^`UO7C2DtTQr!s}^17m?v z*<7xSPk4h5E29r$!+Iw5a@LR!syik?DS04?PiI*(3x2Z2!SpVa0^Ccw)6@x>`05}| z$!KQ#DT3TRsExoHtYjqL2zdZGeEmS3iLxHBs8b`vB9tMV?dLOF+8%kR6Vq?B-z$xqL2~OAVW4(IK?9dr`%o4y)*DvVao& zSCKY8p4vD$hPAzRx@2{@?0T_U8C{CLkcW-~NDLhYCiUC#qkInmSUW@X|7^y&s{c%& z^U?ujk6OIb-IZ-jUOJ59hsdy(M1~@Mf;+R}BVcSCO&nU)N2dWKq=?ZyL#FHny-33= zG+s~LyYy)1vZa?^dimac`w#3XUcv!HHQp{XbpxU|avDZ9TPqMfL39EtL2j)p&wyol z1sbtSuAr_*zw_`nAGrHnkG|yM%a-=EHC}R=`^tZmnmSkUJT(HAssC~VLTsw3`@2~a z-`>cMp`wfHDN2Ooccz}faBNv!=PJEpgvkXHGtaKUBjl%8i<6T#?=!EadY~Ey_PKDZ6Ja0lwQrgx(l9*DnmvaOJN&^ zZ0!0jCSUBP@{A&9iEQ0>b21hNYv34Fe+h7!M<4AXgvD5l{GBrj<#-(3XdaznYy-F| zfkUQba2y@+txm;{PYn>EBA3(K!B7s@fADtt?3t&$+xwU*&Mj9umS`NPI*rn@&z#91 zg>=Z#BWiB;eeocr+sd7S7>CV}gFqNLhfcMO&;HVa{iRMSPVq4c2%hjtwmHr%J76<5 z?im=$%To0QTb-)KhpD2gz;>Zfa?1_hr3hGx z>HW#f+vrdhU0KuVY+2{IIff`pD~A-RQ!7*N57YOPp^n$@7`F2r$?ryD?rDR&TRpKa;^KD0B$R_Ykc2{!~L5F6~db}d&ONr?YIG8}nV`}!Qn{(kd+8i$5}>YAS?Js+5Zj)C?y zKZI<8ax*qT_>?i;!ss3S=8eY8f#qS=pgYxuf^0CuSo*hNtf9>dZ$Aa<)%pdhXfiA{ z!a(C^B~fE<7q%O!BzJmxgAag~jw|(|a;jFJ6rNY3LhkeMXU&!~_eoYdv65_AF^8GD zQ^J&<|>m4Hnb=RlIZcGk$6`q610Ah`vGr5|vSwr(V?6LBTiMq1| zBU&Sk1;I%IY|<7|2QwzkS_vCA6Q5**)Z|Z4vg|&{$xcgWYUl&SkY3eN&XAB_-Kw5W z{q%M7>^I6}pqa@`Hf5HmHBS?>wn8=esK)Dgs|VP)F-8WL)!>DorlF;mvR^T<=upf1 zLw+H(#_>#IabDPaC-TFg1*K{; zh8kjRLc?09<}DaNi^oAweKtG=dWLaeD@RY+lAD@>12Q$SBQ8`6vvFH|Ce#v#CLe>4 zW`~d(Ir+_~BhH-|$MT~mlG@Y9O&3%27n@@@aC))a?0atbjX1!!q~%vj;>M(zZ2O2f zVO?2t*e&$k?I&JOSAldJZlelHJ>eoWy@U~ff04%1+9R_V5f4`zi{U#4yjtZ117V*t?{O zK;bdh&E@Y_fnD7_17>zmG&nb4>9cgwu*YNq;v@;MkObtJsf!b#*70c2X93(7jv%6H zIs%@6crBVALs~%Ro`%ec7P`&Pxh^M~i3<%@?;3{B56+@*8bwNqAQOtrKktEpod;&- zDKqUa%iJ|H-!~dF|G^FgtrAu|RQ27)v*PD=H#08qbN%z9L{wpfA*NXBU0HYEayf(r zhXAr9`aIk0Wlq`~S}Z?28x5=20Y03Fghygb<4So?k#p$U{6YFLw38Sv=a=oo1J6u|?VGMgaP| znE7&ICv*Sjhm&cx zn9SEBdCe>HgePt?zj)tcPv+Z7EU5Y~NoKP}C=zfND4EvbsVL57Makypqcg-YoK*j& z+`hE^N^F?A+b)MR%JI6c5Q`M127gynSI-1_3AUH#0~Kknq-4b(q$VJD8b&0CmGBkP zo)b&+FXsS&^5u2nib4NksI~smhL`i`r|G5Y<@MAR(5n+m^~=dplcTRVWrH7&rSKIb z67qqM)Jt(cTB#)wyij8J(Ml;dVY&F!ma|fFUD1{z!xeOC_8(%-UiUxQoIRS2BDduT z5;A(Ru=>q|-{B~K6|N{KdAyD-SYcH^63*EZsmB@tKkxZ2SwFY2*>OY{k6$*9=o~~3?Q(+TFclci_M4m2 z$Q%YdO56&r4v>21LbA@WTa(KpR&8ObHWN%PWXlm<9%t>=wA~(adGr$3A$7Zk%j5sg-rGRi zRhIX@^J9JNz1QB!By2)7^mgubGj4ZA$sl7K4&)Zb>7KcWq3RV+Z3n~Q?cj9SmXUBA z1k)UPFT&>2*dj*2Hd=}(C^;1r6)h<0Mo>`^IaVuL#E2+}s5yQW73Kc^&-2c?=30C0 zWG4_vdNi`v{CMa4@x0Ibe80~-#{0D;sgZ8nzvYoQdC`rDq_Q>4+tygy)abSZOb`=( zwHEt;Ux9$(nKm;@u>f+iEtDHU+_oTb5L^P7={N@vX)##*%$ zm6?cfyXr=*rZLMt%a9DNk4d*m&dcH1OlaaDO=s3e#n=As6J#;f&XM-|N7{dEj!XQQ z*o^XoX%hYx=OHx|lP|@*#eg?*tL#fj@yqEmi^I1PaBwwpcKb}dinkmSKe}VR8SMZq zI8GCn@31DQh{TSyim2kXR7Jzv?~P`GFhA$L_68~pHKW>Yk!$q3JJxF~`d;UP(SYC5 zk!IOAE?f#XYHx{QZxr99ZHb}!07q<|28RgUDDG0fL{W=#>vs;EJUSH+wAV*3lR{zp z;H~RS32OlW6l>3>QeHuy`)d2F7^FeUmjR&Vldf2lrUpX(vXp&!EF^rC*=YpDm+!=~z()#=NB9lZYeDtZ zYoDra-*9kGf9-ip{LPar5#Vnt7kh#bK$V1cAOf}R2Pu&0Hhu2_#zbo!_a?-L&2YjL z2!+{&(C8)m6rZC(BPhKgsYv!Rwl$c&SW@{&_RmeGK%LM2LLVSqy z1`=uXfiM^p+cA$5AcV5m33d*R6yPOq^nS{$10zF`|lc2bDAz<=Sz~ub^FcDt#WIixGAzKB^a`!<1rs@m8w99^AQfUvEZyll2 zn`^+-o{TEhh0L%l7ndHwX_bFH0smG)67(n@0 z#n9;D@m*+dzg`AwG2+ORC#xsf6-yC|6xb=2N@>K;`?0DU`$%V?ot)jv4$wJ5?^InW zjokCiP$!`(#Z&LK1AY;ivsXIxR8TEDP#_Ba?LvO6XA-$1<53c+a)o7&9IXopW ziR?2Vrt0$|g+si9zv*47UCZ01JLq)0(t@S%_fX(5V z!CAHbO0IV&$0s@0I_u_IuJKZ>e?8at;dEg;pnJKwmKO!U7puytTcspO#g%VEYPg6$ z+CE`f`zS4w@-gr68ztEwjRmD%Lw$jod!M^h1OVwlAE*>uLcDt&9 z9kMR8+1MgROw0UaT{dL`GTYb4F!4ZUzmUsC(v#=>;cDOICr9%E`Kcj6)*AIFC4{7I z>(q&~c;_dXLB=b&FIkUnWRropQEIn+fS@SU=>EFZa&+j(x01<6spsw9Gx)&@B_h+mM>*H)avCA-Qn@d|4B%a79%*B(268 z+6^wosWgTOAwFLziIyyCQz=uY>0?#sUpiAT^5x_Ph9T3ny(_+B3&F9pE^PO)%B8m=_~q#-#etU8KPk&Q2;bk>ROqg>06*0y3z(t z(bm!2^f*RN4_F{fuF8!GvFLP4h_KfJa`}L5xHuA4dcPp9<)C#Xbq5lt-4_az7sbRt zN1qBRLC7~m|x`@acm6=K~6ePN?Knl|x*3_<6H9(m`G!EDR?bo}^ z#@wo(15N0dJ8+XGnE27oK?uSCJp-j7(?Jfxd-s5ayCvE?qS+;yoOtmlxY(+2aXT|o zE3*(b`c@ze^uop#n}5!fvKaaQ#J)0G1V+7ieHBbz#kR+GvQ=>+bX){m z@EIvi)K;PsAmOuDeeZ!(yEZ7g!>UIx(9PAB8dz`pn!scPuPQDe&8KAtD=)P(C_EMS z4wuHTZ2+_?A0G@Ql>;KMveAv%TOiD|D8br=M}b@C4$6+^rt#8aV4{MUz3MXCIQH6k zIbHi54RX~;Fa_oVP6oOe)0yC8fCm73btF$&B&C}HScBPCL4&v+m~2C#J}d&PqzX}C zPY)~KBY*T#VLu2slIMY@gdqv#4Wf#u*p#twJVUGa6AKp#AL$b*ka9doq(r`!J1Oe5 z-it6&PpYPtD)@fErfkW`FKNKE;MJH`g4dylL+H9-`b9Y#DhSqtkCii+wM>&4d9!;Uy??#wq~R- zX0aeNY7H#=8N6mXnVCpz2Zaz;61)%z4{Cq0-j|7eM*DQfN>W|uqsW&(rJdSi4eQu4 z=rcKqOqyzt&e8f>Glf_`{QO_!rPXPUYMt9vCgmGs5k9bV%>h6&v}`>HEl1q($eQ;@ z7489j$$6l@u0%1^otY{M)3UPotO<$r-uw$xhh2@GEZ_T$*1BS1AGFqU_NKH_03f3s zPtMa>JLVxXLOEYUFw?NhU3S^8Ajq;@dpWj%icp%#gNmSvnCa3QSf%Lc(-Bfkvu;g< zoS$r>S+5#X5(cUvr&SQhWapO3(XS>@d||namy*k@2FP=zDR`5T%gWvkHq$4UjqVYa z_x0plyX=Rh49gBnd$|xSv1QlQEtR!Zaa9tw39@;?8i&Fh-)twqL-z=JMbP=1X(NH-c^#JdGylV z+Z8N()fl}TsHSZmc+pEatmo59iZ4trc`15n+%;X1gUHCT#X zRd8otkIa}j`Wwpi+9hvA|X>5ml&Nrh}8WVzP)YYFQqo_@O#Jfxas1W73<#%6r z2YY{u|6xBo#}l_x*I&~g8OllHdn?!3H7#rmMDEl-{)P%2R_xY~oO5N_kEyHzdTI^* zScR4@P!_{Zz3hb-S=l$~r``vvSHXJJt6VqZD5E=7C@XIDvKm;iL)W2GHX?g4Z$yta z>7|Sw#Ye4G*6MoCu}OVT0^zWigRy)M$0F+mta6a0L3C%;b6^3sgz5*}S=2mIIFS zLaQbDiv=k7LU7F=l?$_gTum~Gv2`1JlqqVZfkakIUViQkpTMw^eRVmlnD_9(rR>F| zBzRS_Fod&Y{oCFP_Y+|iZ2s!TKo%tFp$V_7PH55Wx>`u z5?F-h$cE!7MZ7OL3w2z7=rqQQY?ngf>1AeJGRIf;o zGE*t$2(6g#8S{;uKn@-2h1oUDQm7J`X6r-hL)!NVrVA*qI{w&21YPyBywmEh77`w8 z&wX$vkn+?-hp_!#4jAL~eU2>z+RGneNw$vSHjW?)fEH z{^h86g5T`BOU>MTjA+i1s;5349@Q*b)@$`*jjq(eH0O#AR?QUKo}}vEDt7Q=H9w-D zc{93Jhb_rcChpdyGyJe}4jW;7su8Q(2HN}pq;;*HC`ylg+ytkfxHb~|)Dxw!o#nxDM{c_n4srSUNOTj|#j9=Zgho!%}C-2&2|Kd0QTP_Y` zFBe+=yZdb|D$A-ZJ#?irvER2XSK3IwGf@P@w1$BS+(N~o_3jLK5=Ygyh3Nn<>z>5Q zVnDJc6nP(KhC3#**l56j;&Kn;BUz*I4q5FR9XLnlf=iZ7Qxi76p>gz!LH-(yX< zN;Vu#(^_OT^1|l9$ZCrWVj0Pak!r$aC`QC#1+ZmC88tYcK%0NWHE2}Gmd(PwLd)(~ z3M(j`4!zW_kp!|zAHTPR%xtnjTld)_QoR2ziy2Zx54~o?F{K_{L9n)k_EEMk=Eq{> zAx~kIQ7uF$&c3_EJ3x*N21+e-7h0t#A$?KYLL(j&$G9pAly+`Qa3wOLShK1LA0ERZ z48hkVgdpHJ)o4AQdpCOJybxr?o0K>z-wx3x<)kw>#dE7Z@n6Cu>=L@ibAneWEmw7j zV{u^M0S`6yN3fK2D)UB(+WoOBWeEkQ)S4tqh_{M&k|>o;em8;-oySV!rg6%Z&JX&z z-AX3VU@cLWrFVPJ9+vsD&f&GV>m0sX+kL`8Kl>fDL?2-G{?#NQ7fjfB++4-l0>*gF zw4?|MgZZ#^GPz-Mm;4f}t|74jOSIQ2^DIe3l~I9FNWLcG$l?Jww{Qj7i8ODZBDxyWZ-iyXu!!cu{e=GD`l7N~$7 z9dIQ_bFt{i*2Is_D>EKwyGWPjO9z7lEDH}j5XDW=l{omv91xsZYJCtC;Bq1YNE7)) zcH6QkJGY7h4z+UFYN<|`@9(Qg%o%Xjz0gU(IqtjQ_@3o0S>8l?vhRpSLBseD_vQRN zA}TzRePy|6cFb5722caZUyc zc2bFKdvC;G}?AsYx^RN)o6Ji6b*7QIdiWN4mHO8Wqn|Z?x?_`G4gf|uFaRBs(-K3M63_CtwFD-yCH9#3XRV?m$Tpc!f}TrMb}SezntI1- z&qq=BM~nY&BdDz%oCGQQqG9HhUr$IX;t>|*_{QvwhYQ12OtDbm--ORFC!@t*5jI$~ zlmi9CT2u|W*RTqV9a9KPQ%4uhQmc^eTs3`Mat`fYtZ3=t30&*Iln9{jKn+$W7faTq z1DC}TNQzx1zX=vNI6Fm~OC8k8qG-#VE%nMuVE;Z7lF{<9){45RtOECAFU(wSq|tk<|8x} zRe;{$fWC|spbr8GJk zSMeC)k?Z?j!dS`1$&6~0kiaXmvqJif()kJwZ!G_p%$LTupcb^8T}u*EU5P3w#;H67 z_NiTSR0kqwuRq*Na$vA^^VV@~f+;VdZ&r`qisD(HAzKy*+JiU(x20Lc`uCLuLpHyq z5Gb)%80Pd z2(Urqq-mAn0_Y`a#?lNg7^Zos0`|xI1Xxbul?1gY!2ar)0qol=rIpkIr!AneqWB={ zVvy`tShbme^(oz7QY2a@=@*k=??=92(V?!ExlHx`r82MvWmQ-Gy6SYfEE#u=*&Bwgz1_T?xX@-boi`j~QS#KqgM#NNHa-^9gjx?5S^eMxuEFYkV! zyXTd6ue*x7@$&9U-5p-uy{qr;Hr*{L-+j98?#sHXYWZg0yC3%5{YrOL3)|n!UDdOH z)ZKq7TX+YzszNoG(6ua)v}p8k!j<0TO9S7Mp^fM>>=^yKY4n>5plVkR44&kKcOIagkUiF3V_j z^zf}G9dEZ>Kj7Eo>8dG{b|*Qhd(-;-(mc88V%cz#Vprn#%&{Jk^cDm$wWE08dvh=x z$wG7S6jyXe>0psmKn>w?cJ+~F7FO5s7;fp(=UYB@l5|(={{tWAT5UeKa3jIR5gL)+ zsDY~{1}8j>WnA?b?&^i3C;}(uBQc7^>@()+iJ8f_9uajO67xb0E}byi)GX7C2tJiE zTqFNHRN((KCnaNq^qG*HOY_kDxH{ZjZ{P|G74%sZ*QAEA1r zVZ1X>;woZ}0Nk&Z`()*su~lj!*Pm6{C6iVJ?=)T30=Ei~FJ!~UnHcBRfiNa_(pOJ3 zM&d#dX}@%cinMo40?S2+v`7VwEyNHo^u@@t4?i<>{njLnG2mkE&?1;hvB-co{r_zL z3JJENxE&mH5D)C=OK?862A&X3(|cl@SRm)xxs%;^1Pe=nCEA0{I@M3}kC29%f4GS^ z+Oxtx{1(5<3(GP&a$C3kXWhsH1R{3G^YChRPzhCR)4FT);$$qhh%|2I88cy(;50OBkCkI#@`C z$TuVrJdw4})lm#edkp~`lU$@&#WIT%XgRdy+ak$f5=V*t$1%N>AZH&dAU7o?Z*P%F zRJ$P1^X^j{-(IGg+0iXi>Zu5f$~nlB$+9g)%BXLca~s93-Y4T8#vwBx8YS5mrC1(o zcE;k^joH`8q=+JHyVud4m57n#VG_QBk|ed2Iurf`ld#lS?knqS7;NYO^nr|r^h_sH zJ22&U1GbC~Q~yd+N8Rv!Ykeb86VM_#R~w1sUGR-W7!vGSO0`6tR(9cGZb{88y$!IRJHj#*+m^kJoR zGpfux%-;|Jv6-Vxtx9Hc`B^nkGT`e9be3&oG;f?qIe`TxClK4gTd)YT)|ZeyichEm z7_aEI^|cTMmQh66)l3-3%1HUi{3sScthd>hms4qgjc>N9eKPK!aBh}3UV~a06)05b zz%6lgI~0Opkas{`G}}41_Noow9rfz4yJbGsQ6pw&H;CJoS0Nwv=bJ{S9QhP&hq$B` z3L)SHdq%+f>O0v20-9O89|0jDHvb&tFa!Zd7LR~7jd)t}kxgdbay-<~>v%|hRDr{A zuqrDgw2jdWOR#i|3&t1K5HOA;ZRXI22nKv(KA@8}C2Jx~|GF3Eu%^l&60p)v?kaBK zw4LI9{)p6Y4AROXDTpRmX~%c5t_~a5`RzK{fmI9@1k?JS7XPXW243JbHItsCH96{- zA1JJ~0G_C_;_Ld1a<%%b7^7lUE#+s967EA73G@xOgl#M3C?MW1W#)D252y7AMd)4j zf!L7SyJUB?is9PGwYohjgQ|KXPz&LUfAa2Y4fweH_zU`=xIE6a(Xx^=FpoO_+=H~( zjjhI5VSGnvxzHP0;~^Q86r*(PsPgwi9%Ld8vTq$V5KxV$NGIw<|8lpUOUSl|W<;;SxGum5%#I4L>1+suA|{o2a#L?B?_EY?$~ ziYW*3_{$lll{+buX>qkG_&X~2?@1EZ_pCaEfV~|8$*i(Hw}_>)z{7#44z_~ms#*Xm z;K*&FT&Aw!_}z#rH^n#KI43?Sa_3=S)u+rCpL)&Rg)4aMP4gR~BJCQF3e@-!oINtw*<9uo~g z%N8trbp*hK8%tot)>;Ca!euH!Qe2iPW6g=VvQ#W&uO&voe}RM??GAa>PHSt`n#vvp zo8xDNLw6Fv6k#2zsJVa?>YR^?z_1EW>yAiP;OdnG0TG~!F-p3gE?QiOO~YE0YZTDw z)H8a(;5<^mpYQ@L4opR?!fKRK zMi2+}3u*9Js5O>-K1PQ%WLvsx`O%4%$rdp9zP6%7js~BPm5@%%BZ6P{6YIx`-hp*f z01x?G9njL(_tM16?`g6Ay~Grv#AI+b(#NOLLHJqc<2p7RF_>l#9YK?GreE&?jF%h& zV7#_942(ZsG#L4QC>X!K7%+ZwQDA%^J@~P4I2eEWw88j|#eng_MS=0+LjW6}7>bQQ zS~M8>eke9Ruoy7jv%Ff=oN_@BS%}YTNN$87A#o&``GJj^NP|JUEs&QotV$->ERc)i z_PPdRgDJI3h)bzLixY82odn`k%5(yUMr|Sz&U9*m=b`ap4|Sc|p28!b*Cqr8;j^Yw zQ)SSp$*V!$BxBIxi>Aw&h9dOcPEF0xoEH zHbup*cM-z-25N^F>yHLZtgN0ssuMDlHB3CltV@mT{ejKAQpGGHg7hRF7zQ5_tCb1p zl?VqZ>`ClaQT}v5e@^MPR(6{d=VLaKw5h&TRvoMAwp$_)`@M6sH_(kc$O#JM^aspf zINSB~(Pg=@=vUfD$kg=Eq82|BfTt*>_Nqt_Q9Cx#Se(ztvuZ*?EkaC(h-3Ry+-E4x z{EuKY2@zsQ@`NnJy$CT9yoklN#donac&G)|G(s#T9K9JUiFmjDAg74!#tIMX5FSRD z7iaG6{d0*q)N&N8zoR`ssQ8Krvo_E1HkD*uQAQTa1^Oq2BJZTo;yLj!FxoF} zzVwc$_>aY-{Md1>dEECIxMkug`xa;lDOe)mK7rCB!1fQ6%)CIE`LF=2OqtjoH)b~& z5PGl}3d+5Go;xU4?Gq?37}u`107}GakM!CrC@+v?7eKkL2g-W_Rw_(!uUP3}Ue7cr zcRoE(`sYJId6^7_%-=TsLdY)W*J2iXh_&pRf zjZyC{sB@H6J0d#{CRr#2YRnkbb`2shBXS+ zVhdVTRQLx)wu-#8YUTqKcYoHWD=6-Yssm3n1cTxgX$i%34#g7}f+EtpfssxeI5_?y z!12@yjxVm@xPc)_*9`~npmtqNQ2*-W_`PuV@pN|v({$4oI_%TS<1lNZBZedPO;V)>y}8gq@#lmeviC72Igs+^OVkphp`SQ% zL*M9x`ldm8hUZ*8%890zV_fz;B>=ZhG9nfV?YnrxGKo5vFj{s_HL`%)aH!b0I(^zy zG`D7-K3qbCHWl!LaUEb{USKWNqU!CD*&*EZlOkMLSbldzP8#*1Nd{M}t2azBl`=KB zQ3%<=tuKb+t%8G7H848@)hy_CII8)6DLf{YOgdMwZBgusq)W#@M(FewWC&IB5&0W#%M&d>!n2bQ;+D_v5 zR+Md&iXn5FRR+Y#x#rN|M-!$loBdSa$i9C#kC|W`e}S;Qm@7%U+VYs%(zLW!$h^Nq znA5_fUWCQ^!c=|5;KD?@wuR}HFq^6%D*3C{v#RlBsd_0cL2#D=@qOBwno9Lx3wjAd z@akxz1j<0C3jY~n7~RFF5yDZalO}S+SdJ(kvR|kz++5W~{w0^FI2__Ub{1J_w2m7H zzF?$n96~nakU;GjYAv{DsHG|48Uf`pO zcsq$QwSCsOLz2X05OGfo(#62ZY?@ca8nBJ#2GkC^-tg1eEa<7#B;g&22C}PU5RJ5B z86+|vqTdM(N!tjIFB7bqa z2}USz8=*M=I#aBN$g%;X8J(VmDy2@3TN3#+2* z4MgHvY5Tl_y5+;f!?TDXK2MYCwT5!8f15`YSyE$siV4>Pbb!n~Un#u2%m zhOY6mN{kbLmqE?+OE_w>u3@Yjl&MT>NcCxH%MYTdLrhWv0Z3agEaw}uUUSDXePwf% zks0%(1RZT!6Cq=@nho71%=RE#x5mYv5RB%n7&-6^dbM6MdYhCs^iZS|ux2|HToO3# zbs;^3XDJad=z~$cRBR@*4RpH7aTGx2^p7?QQanTQ{fd+{kHp<*V=vc<3pXoQ&Ja#IZj!4xF>Esf^Cf<2@e}?0R2bbJ!c2{E>R`t<%oGAr zG1F)&VKFxax;!>!N;u3V-L{x%dqHLzo2xH1c zNIk-e(R_3sLp5>&!0Crl@DdiE6A5;P{`v&V76oU+8PuTfR!_x9Z>j{iG9r`7Vu@oG z>ZY4C)j}Sn&LP^qsXIwj4dhl3R5$!-ute_Dd&sGDRJ>o(Xzd-UXfnev&7&n2c1#=r zKOF`tL64p(!vx2E5=N6<$-D>-O;&1PVgU7o80VjMq6owao~d3{2dC!tW-jtq#LrT0 zo!@Y1Bb}2ZrQY3F9;_yR584CcvSEQh45-X_DIF$AFr2w;M$n*&{`*3(Up*ZJd)49) z>>mTUce=$CKa`uYet5`GC;-%wa+1BDLD^IA0 z)NPPZO~>d%>YJ^Ct}P6$2i6HnXf6aZvYTDpwi0BTP-zq5r95&VrnbZ7Wg;t;N4Stu zCGu579iq~Ls3xPZ#SR$Hc51K6)& zi`JuS8uyE;<;p;^|4YMi5vXJ&2y3=V)Wit-r|L(vq?6f0Y69_B%M&TNa@6y9bxIl` zxx=|y(QQ=cg4@Qn_BZXiHBDrfd5XFHr6Tp&^$Zu-71!mZUAkG|46b z&e{21K!H1x%K%^YZ+L^G^v4D=1)(B}G=y+z!Pz?w(P%2tL@^_Dzbl7;yEqU>$kZf^ zkbj_hrn?aW_QglXk+O9~_vlC2S$Zv%R-L71;ESrTnbNmPXkcNo>b-0nBB0rh2}NmH zrW50gY!RWBgkY><`-h3>+Ibs)kjw7oH~Ul;b>69v@ybvs%mY;W!3ORw*#H(xlr8!< zMSs&k|JAp7^u40!U<)s6{6S%T6@RE0!Dz_{!lBvIfJLq&C-=GC1=^23rsx<=kin&j zUlGiPk$-p*cu*t%NY!=n|LlNik6;)E!oVUc$OINCRIXU$vk9iRhY+2TiaDVXIy8W~ zVFg4Kj1*nS9@4qW=)2O7cuNH4t0|SBz48_sZ&w_8h0#!`U#=~FO?l70k#^gfW0hl- zB1_1_^cYo;Q(u;(V$}<}BUS+F+wwgj=J7yU)~*q1)oXl?kmvF>l9%QFl7t|fwO&-# z0;7Cu*$>ZiZNgXU6hwykm}n)BI3UH=w0w_tj_SILB7lftX)d zEkl5HghLg}v)h*DErtYOde*QKGUZ7Q`v@6D!_^>DMy!EatbWO`Ne?pNWq1-G6CUn2 zWYh}79>UDmS4mXKLC02%j#{QH7Tm16wlJwT=^v}ee07F`gWFv!Gi zg=SXaVKc?&FaON@W$O3)lW<5Bf8{~HSUHYj;obA`JIwR|qRI3SLzOT?%fcZpUhMqt zoR%kq3VBLTvQI2SN0*67HnY@I8NHiI3J&VLZ-RFin(ov6YQHt9k-`M{zMM75mON`% z(Gn~C&Rbp4YxI%fjhf*oQN!!<^t3(IwXRp!HIEG&fQXY!G#gjA;{Y}|oJ}Ha zu|njCYZdqKOFTyz*FeuItG|UKpcYV@4PMUXu}@prteD=f6Fa?2v84W%q246>MLZ^ zWh>+BWNc`jSH#GZb6?<{hIdY$t|W~Y2S#1;j>FH~SWNyU%5h^$x4lWoLLNy9=61tD zm)()|=dC|qU&QN^OS_}Wq|++i{I5TX&n&X78__~hOm6CqU7Ecvn?iJC3JBrH1dv>u z+e5yKFY3mxT|YhB9bZ3vUe2tZ+wHu&MP>rx0Qh@>(7vk9Tk@w$9gLlR8}z9_e-V ztB)Y9)W=q@J@Br{DNjN_S04@U5VW@PKcqx(%ROE z7*y+jnumgqw9t7E>C3u}Z0zg_OCPHMcWqrSM!prv7T_d%#o5EL0B8O2#bSrD^+E3V ze#l9<19HdLAg2%ot58I(4!f&3<@m)w4d89)0Z%RW0q?XL@J?SCc&9t?&M@G)lENHm z>Utsza{Z|ez72igQ)Z@l;42?e2@@LNcdf-oEf(?K`y0e70q0Ws4caDH+LO_W4XYqS z^X$nA62v=grSQNVbY zuvVOl#2_Un!S)Ty!L?`)RLFAD06nNFFHT{bTUdW~|5CZ902=($uFRN1IaxhK;Tsz{ z;=5zXN$H8o@n3e)k=@a<8k7#WzcSJAbgX<@B|4>N(l+UjKDSK=*4!wEi+YQEKgLye zbQAIireWe|7@_GeR|WqJ0%$;#1iokHK~e4n{WGYfTK6cPli9c8F0L2$ewpjUGS_0Y zLM1c1A+JcX9o;a@Ewg^ zbA5mce)?d}lw2t*7E^>O4}9=@cV!2KjPo5_Xct>?_+D%e$WT7JV0lT-bLWDZa(lPR zJ(@6U<0VEvOae#oUN_j-@QC~GmlKvTS?n9r z8-Oj;f)^LpK^eH$5@{vH?~42bS#OO(_{O{}R?F=8=zph_=5x*a-aoQk$6K*K!8&loW5x%vg5WZP~wl|3i zWo5}ek0>j0cp^V8d9UNj_lzA&Aqgl!@P5#eTWCi0Z5cgi%7wX*2Sb8ipD1gyq(S1^ z`N0BTq(&N~ptzSxacaE61q)5B=#3MLHZ$Mmd{%8TVntYPaJqcTN^04pokL6$t4X^f zyRjBJqB~jn(g^KMY7@4@QH6~wij@CeM0lKy1#w;7@W3+!LQ|bYNf6o?+-UZ*tg}?& zFv6gbKi5JksDq9Dn1G<96Wc`rfw7JS0lo|^+anLO4bWB{x}nrTr%8-WfsVp?;=2-5G!~D-?odldbQo_Uaxb)| z7^d4D%d$tr1E9ImQtYki1b2;bv%+GuY-$*&hdKqqTE%Obze!}ddS45YYKp_taT=vh zsn(Kg{zSrHH^dN$r>{&;g&Y#z1t^5?|C?&AYl(@gI`f z=GJu^O!2_a=ahx&tA}fJisMR-7Cs!89Lsy-K}T=Q-T*@sM43)pF;g(B;sT;@PV|zi z_+chhEA3h4m=o0~k$BO{?CK+|G(C^V7XlE=PaPwV?tNi!-O0SG6<8Z2GkZ!7R|9RR zKf6Ztow(8KMLDzj$$nzL^!5GAc|T`}^Y=m=IwGYq;v7MP%>6L|@jSdAil-FF8+!)~ zp4@G$^y%2nkv&Mh+$oM&Gef|z1y8+@+OU~wyAAWkT#;4AAGPWgwO4BH>Q6>i5@rY1 z!DvQSk}jb;rXFJ?+r2GwD& zG+0>+Myjtm{lIzaLcr;rCiXOeQ>!Qdr}ktBaOlx<4;*RK5iSM8oNY;QvoL2Hk&+RY zbzegToSS3bFMv7bhv>%~d(^5qEl@NJb9yJ@b%y|l9tk*dz4T#D>3kW6IT}mAoKUR7 z9L7>&&fqHzHegP8RbdXE0D$vT2hQ%exK_Z~ZOaN>zjg*{1su5C?uC|>qIL$Bl|5?J zD+<8r9j`hJIP^%sA=0KFIAy@iFyLq`0XU&p1sujw0%!1*1{;7AUUjYr&b0k>8L89e zG6Ixke-Zq-9`G0Sx}xIp7lkLt4g2RtQxmzAU|rOJUb#eUI-Ka)W$l>T(j_uE)LHcI zpi>AYO*85vkxFD1r!&b^Iu!ty%-pR7>o*b2VdDy*k`yZOx-#jT%xr2Cp3X-nfLGn1 z-&A}*R8pJ(%_3Ilmp3uQopO&WlCQwGU!IVF!Q4r3XgmCg8A*R;z9)Qx~$I2Fi zgwL#B#;DJE(aI&wrqV((^CmN?Cte1~6w`{)nYTSTr4 zy56|yTy3T`OuI=IddE8~0mbZ9-+Lh4FcH}^zWgJttRmiklFrMW|8g6sxQRPCh`j~# zA*?5Wno86ZA28<#aguLacsR6AqADvF5ee}Vt6$}4Gon3;Jar{azl4SoeS|hzeI&cI z4nOgS>LJyekhFgGy51YQf35Dcr0Fhld;*Y`3Ri863_cRd6^?w_0#G)$Vt2_|Cn+ z>Z}S>1lPB+kL?Lkp3!1&kRofvfq_(i82vL2sl8#<_8wLtiUX^U?g>_&L}hQVB2mhL zffbou4kT7x88$Uzg~Ysu{;(<-pR#K)4e4J_3b$1rM#R<8Fh27kv#uf3-O(b-E;~%u zE68mw>o`gpoClN62W>lqosp>3Bjwu2kO*=!`*wKCrn~BGjGW{R9>snnvkfKapfWhB zX75^oU5QAAyz%P4U{4e07U|ZaeWrNCDd>N; zC-{lK#%=wHBO%6f^29TmYm+e5p>88&lOdqpdX3irA`E0N~T6reMHA` zFk2a#u9sn7lyqt&yO2D`YGUgipBAJ5EI*HjeXg^a20llQP~f|INw+N2OUAUngTqpC z3;sJZsx_hMj79%p$&0rrLpGzy^&hz;w6hAzUoidI`>hRqxd_0Aium^=-$1biwEcYWYak?-1E@Z?OrP65)P1dh8 zCrNl!hV4?7LU{FO`>jmb&KHOZzu6OqRVoy>A>2+^BfJu&RRH4HfaYX$@oI(j#OE3D zcvKpoiH;C0nJbeQVwK=Wk>RnzJg1;Z&m$3F2x|7o6FX7>8DGuFeG$_z(caQJFrnH*Z8zr~`QPZm_{J%XrC}9B?4v~Q zaxK9NuPAE}_1jwwbV>%$n5d6p+$`g3qL&p4%vF3QdQ;rlX68Mb7{T|VUg*r>JT)H( zx9Gve`AD5)WENEDJYg~hEch8r4%tww74{%quC4vOaM!otQDMm-MvoS!Vgn~nfLX!y zWXx_`5Py+-z50go{D4VfKkz@DLZ>?dJM3XfQFTe{27&n{3<|vfEo9@-QB=%GvEVT& z2_)rO0eh`sw2S*bK|uVwmeZE=a{XWzH(p{IDX2?LQh?r2h0IrmV8jBz5oessE_Q=R zb0QVUW$9v5$+ctI39t5?%YvGjVo_7Vc1A%JXeilX^z;PqVgd7}fq&09{BL4@n57VPIy4vSzw)c5o>yYKEd!LW{=We+6){EJZ zszC);SudvPfz^NWk@ieI{nQaE%3@0_gwUkWJnj(HY_^xYcP?UT9j9diU9Wv&#$8!l z@33pY?G%?WF4ba3ljnc&izd)mxkt?{(|EuWfdUO0k=RgvRN`Yp@$xHXxWBi zX3R2iWUm8X1XcTCmpJ|Bp5q~HL@33GfTjJT6!IzHM=YnsC>oXqnn0oQ){`9(5KZPd zKYbr-iY!#YGIcjxL%_FO(-0t5;0Y4?+XMELJ~$(|oPUZNP^6dGV`=ON}hzeqs z%XkWM2SjW{U9aRR+x)y6?RmDfn>{RdqFH>PH38E0l4m&CAUUhk4PKlltYs+Q>U74R zgxN@QtAp*d?;d5s*P*dgE;n{#$Z4+fLIou<@EcV_I7ZH6+;TC0$~Uyaea&shjA@%k z`QA9JcK|sF5D{NuwiR|4nvpY|L3%LzlCvMCk-!A8GFUDP2jYnBIQ#1IaXbA|cH~xe zF=>_|l2ZQ^N94>&9Bu@H+8tdJZTp+`-7%&Yyi-YRsE+7xUZ#N>zPengyfL1~VIB z>+A5}6;%kX7NFLMHsDdW_Tb@u;s?(qI|5gdFk?DX zVd1sB9dPw1*a6LiJxi!7=o8pk=gBxu_h>3uot~jh3DX3~P|;4HZQ4HKAHs+k3g`{f zFr$_Ha-`W2Ne@_AT-7(Jv-VxlZzZUG`wBBU%=>l$6Tt`eUm^N*Pa(p)WK0|yqZl@r zZ!{H|oQA+f+7_`{kz=h-CK|3`#~(>5NCZ@(JCYf|GHc=LQ5kkF{vCEZ^KQZ2&Sp;H zY^`~_og=v3-gZ0N$1n)(X9cr{?RJjpyPZ9VE{ED^w=)!d+p+_L-{B_8` z1Jjn0X#8j(|IXz}$iH*Bb0|x`L$)u^z0-wbj)9B;6_t;GyDlvjWJm9E1o_79Xze{I zZaiNHy0l#p%m=Nm<=WYPDG?g=TsxzvQC&_GhuC_y9ik*!*=G*RImc6u$3!jp69nE9 zNXM7M;l8bJjP$ssXA?J`mKF2j&#d-Gk+A9cK(Zn9kA$ftG7$N z)hcu3pz!Hk+th1B$JD%6>AV?fI2>$k5haFMBLG`shXfRnBxsJg;KbrUBmQ@eFKzSH zSdh?#E5udIrIefJ$fZT2G^>1m6U>g;`^h$9vrTWdpvPD*&cVWmI{k^t$Amkrnl<|3 z1Vo6U0n=L(L`=3@iWG#pXf!pf9hGstR2xB&y+EzvbFeEmdVG~2PkWR-xRfO55qFXU zy-;@Tk+pZMEF_i}LRpF2B%2%>vH$|PQNDCrZn%)NE<+QaFPrd1$wI)4s(0QNpa8}1 zPiU4)=&f~5r9d$PMOz3J%8ZAOSbl>5V7xY(vdQhWRqLt5+^}L|Rt%x!jq?~41jORU zrBs6UIr|nAJTAJ@P1GEeK|+S-8bM1QnvO*D9eXO$PO8A`rUi_nMDKg*5#?ROapk#3 zEJ;W=wlrL{@G>dUeHlo`^07T;An{KXI(`u*%7B>Ptqm2i#o{Z)b&)`XyIqBg8tlE#sae`oY~ zZ(V4R&@BI5Qn2oI{sBL(Tzh5+24P;g;+v1pX;s*6MiVxz62@X$l^PuHmvVG+kG_C- z#@S_}nxO^2Z7n#|eIEl_ZSiJpT?{SQcj1gSJu0g(l}M_;_c|&r@sDsuv&qsv_WeIb zV6U&X|0pZ1crZhE=$VS8v@WW8C(~vdmP7%79`klF5%tx0l9}Q^2%l6xwts&4PTPO} zL)iW!!g!J@w|!AkQ?{|eZG#u&FDOxNkvg@u%ZCj|fRYC1Z;?7pl;oKBbZN+lJgzoa z`*YQnZQH$%fqXn|v_9^s)#BBoZMRx>v>4 zjvrr#TtVgUb{ew<7l|)bg z&6`!uqjYojHtkcP5;j6! zo_U~DM^QC^lAlK>cAvcsK}f--FjJwk89*EzUA{0C1%eFb2rD6b5`W|#CZ(I-I~Y^DueZ<*;|*1*}3N9)$%1oz)vY}6i3QH%)F=>#WEZd9Ra7bHk2xk z)FDbOKC6Nt2^2~G{Xp5aAW(iD`=M7s&^HE+{R8DOyP4JR zSD&3!>LrO;P?xkA)86>#|Hg%i+d}k&y?MpM(W|>7{5_MMI0be9_$q}>I7T?ZI4(-W z)zLER$r7xawMtcTwzw-cJPfdUb}XBHbY_y5SU04^iTP-)#OYPlucB{_t?21$K;E#O zF(HuclXLk+@Iak>wxT@)k7;(^8+05uVAE&pkKSSVVo)k2%oDFT-W}C3eUT5S|B%0S zahp;oVl7b-1ic&z#V2+Yo+UhM7a#T{i&g^XfIMj75I$w+gc@oa7N*A9k$h}Tz_2{z zAU;U5D0FB7kYUIia>|~AF9EJt80&`;YCejOdY3gmbyY_YBB|)j?SpTW6~?XFd5g`W zB%3OaS}~IfeKE(`$1BGffiplO&7KO5Gf#8oCzS$HQ{OS7J?zJ<7)TNKBrLnvEF=d) z{8EQxy4EbTa2JZB5Z9_r8)HZp?kkg=1pqY^aIkcT*;B^O=uD3or(teJWKeVu8d{-p zE)tW8bG1tpPGvhl#5Kt+&VFb+*~MhQD|ePH41sTrmcFtQ0^iv)1h)12$qq^g^kn%8 z0vHA+6mh#dI15>@7Hq7L(B04-pExObfvZ+iP9mu9vJL5`-@~d+Xs-XmHu=t$%;>*_Pa2KC1TCyu~hVY3H0g)GQv4UTQ%GW+-n`#|7)9e9PgW zNB|8COViEiYY+!-$0jwq{r2^=K*yW!g5=SOW%6=N$>B^NtLh&P!_wuZEg7 zvTrPLJVBC#PcR%Po^RbVPnNGGR-r|qhJrF?n=3;WN6nVL$J{aY1^TP!j$vWda>v*^ zxUSx*NIiFq;&?*JQFjfS+7Bxg;v#`5cg%snhVLu}8~%RZvB5t%0N8LKfbhs-fbh0` z2ZDcc0D$mhT;G5?f>Z%B6!C)(s9Ehs*O9&Jc*mVC*Yfbq_MVFs_I8@9?d7A)9_7VD zSIyBK)N9zQGQV>@uUhIVs~uX$y9es{hrwg|q{s7r1O;(t1O%@|4JQ9E$TLQ=lqvcUeKQ`^FKWX{vJ! zxkIscQE@@=?1-80RK$TZM?~G&F9m3W731Il&le6>@Lb@61yF-Iuq_(mx=vWY6!750 zE)FMnwAr>|arc5%q(hM8AmTv6Y)+HH$E#Tb+GIqi(YnnyU3zi1#j2nZ%1J1)5-Tu> z9-p!=CfhN_1Y&d|7*L=3_q;P=j}+lSO8S^67QB7Imj(WiNUy96-P2q=^-Af3>Qhx9 z09hkEeiOcCJ#H55&E1qv(>dcNbfI&}Gs96oc4%|d&eO$&JNF9{{{BE#KIph&XPcJ}{Y>AA{=B@J&lE_%JcWL}akZPGzO$gkl%tTWX&WHekH1{3O*U z6k4_gnz=jLd^YPwdI+H=vNN2#vG_|h-7MaMs`6J{qM~U7U)mvejODf16+B5cZgaTW zLErKS$qxY2Vk`;DiaQ9O~Na1%r_;F9=0@KG8`Sa^_vau+y4n{SGNB{L*1p+JLP z5h<@c(QyYDuL(imk761UfR(qxmBrrZt<)3dNNfwi(PAG?4;4IhIQ_7L_pCym?!uuJ z0*gez)XEzh&xd1}stGN+T59Vqa~J^%vv`+2SPdEqzT7?vXrVIylvwepVjSDZSa)vn0KlD28xBNSVRu+dbf zb*hUNj?NQRwTho|5t~VPb#ko5154~jezR(Iy@4Ho;u(BrLG@6y6h?Ma9^Z6cw-xL~ zmQ9KMI#KqwqNHmvF63%&ZHNaDH!%C&1DAXvD!Rq&rP!?=LzB5w;4lmJoZByrWYTON zL`XX}1jCaBMCJZA`}&w4v0J1vhZv{P`^m%u%nb?1c0VW7PcW(h83~^j2V9ssaUMA2Xb}%rk-x>&Y5vq4RJXnC4>2mZl|2s!|n^NAZ$J&)kGDZ%s zWG+J{XX9ICI$F>6Ol`U-`Gk^BTNAnnY|9dW`$KX{ln(_u4yHX(qBNcsai3iVg(u=F zc!yv}^)Qct-s#M5c84F;Axy6Yx+~m~`zp{~5&Ya&f$o41xgNwek%QyuG`Haq<<|98 z787k(uPj!CQmwK$M=px#l%_Ov3W>-}#@-6gwG#PL-P1pHvbxt4RQ*%fB_MFk|f1`5fL(D#IWoII~6zx5^?0J6>q;c7}@`gPUDDCUyIaAQ4f`bn>d> z5}Ht;YrP12@T6_edtQC&=6{6B*#HL7#{B_@m>x9<928Y3n!GL{P zH4vOM1O!%M2n1NS*%u808|n}^$r^A7^oqQ=4+6dC)u&D%fxw}N2-oc$5xmHJL>TzA zLWDyR4A<`+3|?eD7zRF_2L`1%-=FoM^Xx^}jVzRkm63&WZABUlM28l2EWh zZB1+$vL?L9kVSz@E_!mZsDL&edSu~pXdQx69Rh=7 z!Hdi%3j?1X(q!RXdtVP;Wd3>>`1Fuo4>#<6J$RA%>tW#2YCY_Zdj<#FH6oi6!U3X~ zVuG}cWowWgFXM}NxgU`(^D9z}PKM(2QVTmx#UD8YML*L>HZ3x7OUgw&-5^27HaX#T zR|FHMd{ZTVrZ;A{%J^c!4q{*>?U&=Wqncs=2LH9g@*ov>?q!UN^ip7n%p^DzS!Y!c)-eiyGN zNH;(%#lR$Mp&T%Z{V|`n=FwF`BnE(RVNxYmgBjF>!vx{bZjqNU`z5kvb(=={=@NoZ z8M={J_6V$#x!y+f)?bAOpoiwElAQE0eIh@@ujZoc-AhH*i0rV~R>V;A=bI9eeM%Xm zdu=1LT2=Gg7JBNfY>J^B?G<6VtCo=!QPB{3izn2q!W($2loEN;xjevNmrICy1cDMw z)}T=GKMmVBSRD@GWj`RwFUrfP?XhG9jF7Nd|88rKN=2>UBZYO zJc7i$M|fz1e+?d`nxO8OE>MR@c-aq+@{2)uymJrmxT6LSb)W{1vbw4Rb$FC7Yw++# z!{K2D2Hprsji{RSR= z-1W|97aj;(Ew@pxt?krCI+1+2*G+{UeJbCdKCn%Na!Vo3DgIWhLoOsqqG3}Zjh+6ZmqcDLA0$U-BfJ(uO?ZUz^eByl$lIvCSQ59 zEFxt7PC|(qm7qc3q-~Uwe2k^tjON-nmFc&TFT zDWQDvf093m{$nw-&p(KKo_+N2J$zfWP?ds5BjQhrp%h0?#l_dYe@Czvnt;wb9l$u2 zy*@3TuacPi*F-D2DM!&2bCfLrwH+U4;${QU43mI(GFuLA5OB>x`Gc6$1-LEPm(XXcBBP3=w9ocPRW!Dx2tbI|zc03F9BUBG_Wx*B%>LQsUS!PH_&prUg%s<-+ z&?P8jqfkPPes|94|IQC3@|Tn)VVL8A8AQK!J%H_qU}PKqZu z2YuHXJ?D*wi%LYM3(_$NMmG_gsKnsZ4B_c*dl6E7{4gG}4?~7nYd0KBUB|yj?4S=SEh2zI?HcYhlb>p2ZPN`rSf02@Z;P2ZtG1-d1_09Odc1 zjaB0X((15RC>Z*7S?W<>C^I8_w6BfXyYIsd(kL$QAhzVDi_!0FZ+(MJB$Oq>N3IBh z&34>#2Nu^8g~E*|FJ?5FG%tZ zx$Xj4WccHKFyaAW<}|Nfm@7u0Hi9^55fvII3;Z@yHgWJMADwxUCcDk!EnPKB57(TE ziD+d%p(K>co;U^TnqF)lWr~(!f>pqtqO7|Is%ai5!VI9Gv0OgIIy_J$%6F4n%JE)8 zWht6WU2VyW^bv-CPpS77x0hGX+~_~D=+Xc9>5aZsjUG4@b7f}hF!~{C_QIq8)iXBt zA71q6|L4;ieQ)li+&#U?4?$j_zS9OZX_>1)RBi9@1wc4Tn*FPV#!Pn8!hDn#KeO7ha5u6yFV_d6J8T%Z zK~`+mnVU_7@wNhViWFi8eS<*Iy-7|62&BTTWpXmJ9zQ&(Ay5Dw4@tmw(YGj!|NS~9 z?S!pR`zGDGCnE}M{sbaR&$l8y6=XU}X*xYSr*J_(H6`h;M7lm!yqhxJ}FTJRqzKnh2 z@;+uPcmx3b*WP5A7FtR*0o|l#^3EvLL?THB#d^MnGIB)dp#WgjM3{#XhA2QHDPhJI z0$5yA?_`LYdlKzkGl=i7=bqF~(kVW&&*r-)nK!Cc5rYQ+clTt2F3X*qy?snFbme2z z&8yr!IZ&iBKMy>wKCR5pha3#vv3D4Fk@+wf__Tt-p|cKtcKCj;10px_1=hj;REz=? zEG?c;u0%U&ll8-Wx)nmz+@eLJ+jVCuQwzK|+tmP%WB&057F|7z#ryRT>85%p@<{a} z5gq_Sz=;SSB<&Qar??hGMFh0Ly%#nz8FlUOFf90|I61a*l8d+(&2@>yYWGckSY0V= zGO(&M8H#(Om0F3fS*e?-b6I^CSxATxx=6=pChM}kzE{f+Bn3h*U{U2O`n3D6Zj2jWHlQiV_0Th`i zi=7mj&8~^9PX2aalVcotFoRfptP?3VakM5#n#B zSqi0Vzy#rxP^>V2!Q*sd@1Ag;wC{Xrrut|d9YQ$Vv`M(x1xJ*XGpo3+%F029kge6S zh8_*794iF#U>zX=`GvW6=a$|3k=A*Lc@k2%-P!WES>7S}C2WZZ4(s*>4*2374i<5x zjxw?kaTVYYVyHmm0EiH2We*Gzy?8A7*pd?iB-S}3E)*oHfG!|W26PD$I`$f*XPdin zE&E7opz!Ff8Z2mvZq#7`*F`RhI=_gM5kw{GV^hT$UDhxe4ZGtnCrq8CNab_dgQ%yE z+TWe=%XP>Wd&}92laIf`%CRGZLKM|;WL?(fG!fk-M${2wWJASOX?HqajEgA+M=29_ zIGs+9BzTZ1s5(X~)d6y4wxIF6^K$o^n(9WAyCSq6)ko!BSKnD_@rC2RjS z=@w*46Ks4#H?f&~2^3VYrE5E4&9+3A!&kFOGD8LR;nU6CzKgpWoI0t&CG%g=MFYu@ zR~m!H4Ln1Io!8Z^2XSd2(jpKPhw}(TLsPh&M@XHR$0L#&kAO@s$RjN3)0U{@;flr& z6Bg$)kn5xwtoc((C~>`zR9@39AB2z%^7!*KSH=m@nk{S8_IY!1?&| zMhXF@+p6b+knv06MDV!Z;z=q= z2F3)jw+$M-z|;d-*3aOEM6QlvKY4ppT^*Im%E{Ymy1(Q~$CBmJ)$#L9s#_C14}U|7 zRojs;S4I4>dMuf?h5Gt!P7hz^D0(VCmZvoS&kW;hw5&!Iq(c1=X?w7wY*0Yph}l#p zblLKE;n5;lnExuQIJH;>rK2!~d5+jUvlkTDmv7eU0$V8fjQ@nt zoV9)j+tcT{|E%zzYeS_w!teI*yDj|AhTn6%_*wq5lc($ikf>DL3axij0x-K1&SA5} zV!t)E#O;9gc8upDrz|p2gxg8BIZ`x56`@cf@m4|hbF&25n$R}=MB0@+5Xp6Kir z)MQ3_OppkJts09eE64mbGO*jyEuAi_{LSqjL1Um<6eRvw2QVJv+W>=vG!RT)*_WaS ztFWyyX=Wz1ry}aI^N0~Bs=lnA?(#YRm$0fIbxzg9p&w!fBiR+tOJ?l!zw0@MmNTMzL(=3xRsYMjDYHf&mku?>78Sm%`y zmYze|1>dw}6i81-E`rldTB)G}q?-X@O7F(m1*ErSEHH-5xrPvjse>~ajE(RJQ=NY} zlMhqjW^*^1b2Lnx%%n4UES?+7*~kPs4@_}GsbT8CG4YEDGwO@fk#s_hnSC(H?mg1m z!F8p^)QDa?%~V@Zl8F7iTt%5vPq8$z@j3M@wMt2i2jRG%JmBLdf342Ebe9TJBhx_m z+>O7Oi?V-}({gfSd7gr=!fZ$kt_|<%>MA z{sPR%nPwmR=xQbO8fP+icMk7lVOF;Gv;5H+JYt*FEB)tG|2fHj)_IY&!j|KcX@1zM zmGe+Ja=-)rAH*!%7o|NR0smqrxEd!ZP#>FcqJYU%PmC!1Dqw;enUjF&EL$0xiqWa0 zcIxz&C7AP=usA;Pp&OXzU zvH?O_c|c%*e) zJ+pO8Wm-<-MZ>P#4o&#hw_-Ayl?jW?@1B!57FxkNlzbpvY;OJT+9I(My^eudf zvK=pw-fU-?-b|o^IXFChzy?10hpM$E!h4NKTRZm$sx1Hv9PPs@2dGBA#&f&rI}NCb z=V6nM9i;OxhQ#R`GOV5O^HA)$yyvhLNHWkAg2n2Y6Mqli)uciqwE;z{9y76txW!j@ z@#1Of$l9gM3FO$;L4Y!npl)6nc0xzA7;sRsD{4CiFr&0Y8rXIqg-U3@w0+4hjSCH_ zQab^YC@E!P3XE4alSIt|Xxk|!q$OY%9#{|9os$)y^PM==%1+J|V%7gi7m5@tsvp~} z7Kzd>X~#(makwqQ&8brQbIPVZ@$$wabc?vv1sM8i{t;kl{-Kp(+q|lb{S(9)Fm_{h z!I1+s1hdocrk*Y&;(~Pg?LReMOV-5y!XkSr#sf+yatr;GSR>H#qEhwm)BB+6SBgG!Y4NAUL ze6EJ5_%zl@G)XlB2O7RBFIvoIy`W#x?>qBeNY0kUWB!{bcoVdHudIKNmrpD($jf0D zSTGm^V_xJS`6djKt09A=v1exXzY+$<9W@>T*7%3MM>s1P=h_(k11-7Ck z<1{pLi-)Kd9>*U|NJtPqO!8Isu2BfNmm>y8^v5)KP8VyEhgfw}ejhevX`dAIz&v6JE2CMmgjh&hdDLG&gX!Em{A6CdT zN*?@AN+7AGK0Mk5hV-~x$3P*G8!3i{U%O1Iqm1G86213tU#1A06DezJGwdNgabtGh z5z4<|4P1Q$zYJf)E57t2q}h9x37({#G_XPj{wdg=5KA>0EiGFK9BJhp(+JfBU6v;&=Cmf4XvCmB3SmDG3z}yJ>_+56tEjo*-_NPhddmN7w>#y#@Lc z;e@(r(upKXsoPMRuh)W9)h=RzKCUVfdRn{CmTC(~*{L$h-|w+=4%q=>vyF^+uma%0 zXA1z2S3H(L*ZvbOJoKjq|;u}x`% zm|caAbw^mHQyhhIOssUmDi7luv5z3+BbyMN64i{1a`$0;HKMO52OZBorw1GcbZ@U! zutWRT@!cH%VUdW}LqB@1>JJo0_d3nfauW5zRUel_L)_h&nU=;)B z9xpI(aYN;k!I6Gyp^;wG0=~h!W&^FfYm5^*t8vPjXKQ)>IDgV_1AvF1shLROqOyw( zDM@shp+u?lr1FS(N+^&Ow)p->F7(|h%o@iXEyzcxR0LIOQ5ogJIbXb6@SHD;Jh1el+Ehj)@a*|y>$M8^ ze$H12TiDY%UsZ}xlvlzW7$8&S=X{x*7lOGzy>trT!0Kex=pc2NoHbjXyCU|$`LCdi zfC(+F$H?&=d=oJY#Yiu6t-C!4S<2R^8JZ_#VLy>IvnFH_&mB@W7P~Ac%bVh+bb3hO zr1|Uznr(X7CuZ$25!8E3%$hY*?@wYS*E|=?PLMk^P#dh+>XI~yWq}p;`e3EkWgq2m zHOK=)H<0MhxQ>Lhhnz6w$CL=DwU53jJgq)rO(3ccd}PK?)AiEqn}>NCPob81(KT4u z*Bg$gR|A+70o>oVrrIawIvt_~jMODPbk-Dg{?{D!;{mx@!%dt#!bZjMhcwd`jxA}k zJ0cm&6aZyaZRor)o;Rk*l?oo%$ptz{8XX`qOhFQ2`-puck#y7^Ce%TWRnm@c3lX5< z1eN4WZ;ETG^!9#?e&RWu-}~zreg8a+zID+fE;0IM!|3gM!suT=rz74Y zM&Gv2jUytme8_||zdeEU9+_6V8l-y%p?Bj z(;D%k!ETv5TQc(*hIr$`CQf4gHl0WQf1)2ZA%(x%4VyT3(97V~dfaX6g+e-{WpO(A zR+%_#10uQ+=MG6EN-F=aEO8bo2B&pDE<79=Q4TZ$e)OG{$X-9;`ca=$rJS8ox!DCQ z>lepUIP0Q^79{3=R~INBmK@k zV{f{3_>^i}$s%x9Y+=#3dxy+J$e>RjcfS&JKVPNjezrteJJAMYV60MGi>K1f7$&e_ zpcZa;4eO#+L^{m7ReWFDx7Cx)E45jh6CJj2r%l}Mr#1aNVyiVrVr1{dVvgSnrIBHx zoO34T70bFvvv{EM$SO9=KwP};)dR>~oXZ zNAPQwOA^N}`+UqDSe=yXn*YbKB)J-J+7LD1{%AlCkl_hmxl@CLD!AzhvrNH4>AP{l z%FJP@O+|S`vGk0w453Ts@Yb{eiewkc)iOA_Lk%}3JZa2+@NMZSDs6Enidg=Ierd5y zshD;yWr7X*c4#!}qzq41ObL~++>&@fR}kK`*x{dW#UlZn?(aO`HYDTp(t}2~eaciM zfTp6=$_Ee0j2-m@BnQStqo9Dy#bQ@NPAey0p7YF16<|<^iOrz>VX^J^$QPBz8RlEUG)Zt z&qucTa)3AQ#{egNfc|Mq*0TMb!SBXp`s}r(wz`59kzG1bF3S}mNdelokn@;Wabj?7 zl=Lht&Ju^AO6dtP)+gm8&;ldQWx!l26Fcs{ab6NzI=CP`+;qr##C&L`b9oy-GV05* z&yG4i%w1hAM~ehoXs8z-yhFYH86N5-2k%fnx}QTOz^!?H%HAj$MAPCd#d2{i)4g_y zLve@hCs!yb$GAdo*)dMki0v51Gk3{8?HEs>ubhKhZWzbV-eki#Tz3=Izii%a*|B_V z*sgIA35YFU5fufA72{^v5WLW20E&tEA3cL`OIv|FB?o5Km%!x_W^_J}()94(DHio3 zW4tV72~J127aNNtN93bAZOg32ILY%7XPiW+X+etdcq$>TJdP4qzk+y;5>T}rfFg0- z2LC^^4#Fm&VvG{Wa!A~U)tXxiCgrKi6{Fs zDAllsQGLNr{OyhE?vX{0YQHB+A!>aSHN9_RQc&Z<6LrVnM7?+M6Sdz%(&ogzA+`1m z_bl7Ug1Gnk!CCt1;%8~UaZjRH|Co5PPq?QV_ApWR436qE&%&s7&l?p__GwhAVZl)~ zvk&y6Uo(5l;?Zxv=jwpdiF*g<>T}P+Tp>3OU?5NSX|7bmf^*f#K0i3B&n|vc`%NmE zgQSA25BtKV_)K4n0@JRn6?E0A$IGrLd)H$g?t?z zRpEU)^3qFHelDE#+Bu839it7?RtsGabDcuSkpSFC#-SicMSiME;`<`@d#=*Kxk~qK zuK0ezxoTwh_Rm!#dq;cGbM;v4sT0buCe#!~5CUg~FDk&FKLh~Y?@}=OL(TJO0Y=q1 zV!Rsxmi&wpTA!{?rse1JX`>!yCdB_+z=f)2X2PR1gyN!6%Mxn6$h{Xw(E*}vsh0j= zd&yoGEV>H$b5AmDEgX7lJO9kdxY)7oI(WvqZGXpVsA_@$OU|}BunI9!v$V81vLLS> z(r1DJ!z|Bh*ay)FCjsiQ&eCM=*vp`E0JTIp2e6eOM2B+#?d-m$pFnOEDd=0_37i7R zXMPGGzCAwp|G9hjD7&gU-*-LsuBxOe$pRCICg+@8yK_eux8aa`Om}jG+g+;~6^@>J z^fukY(WA$`o_qYmkudD$acTNCLO}weLIgyO3YbPTsGx|-LlFxMh`fx-!w1^28wHeB z6vU_?_w)VExz^sh9!XWGka&#LT6;a_`pr3i^Y{M!X4nM~{nonx*4uH0>V4G+AvOB-+YSjj){z{>!Xl@Sdq+@SXu&!rWx_vb3*)4*a(K4qR2}T}eqc=>duwoD^$_ zbgr1E0lf)nBGgbt5c-OH4ubxKFhee=fv!-)uFvw}>Vpsx;_r^-K>XdPuiG?)8q*VJ z_&?#a{ZH5>On6m7IjSWyD9$Duq_`XL=*0&Je;3!YQa9uvXYo#}c41Mr`W;qCtxQ)` zAV?@(e|VCVUpn)@P!p}(@$v0R`CZnNw^{~W6&mh0v+yQ|`pvBS&FA#yL)DwWhDjDa zr zV_fGjgvFGlrW)D{SZp2*?cx^1LS6cbtqKa`Hd|T)4kmy;7YpVq{#ksi;q(|=Hx~>`1E4v@ zu!r14IiLM;zS%6dlJ@2RTzWx2m5VbFfH|kT#$H=_3=(a2rlA%kWHh{fclf5xe_MjGqBqgY{Arv&mi&JOxFa+ zhkPrSfdY0Fk{nzHebc!NRB^C&89bI&8OnILawv|AqW~Q#5eteRdImj<$VY{99`Yj+ zitq68D%Oq?2%1O=O)O^{M_;?P(Heh5vPd&e(70w^i@C4-If=|A@&Se3P%?&8ESVenBaa-_-&_s2DvF~FBz7-u z9*3EdzJ{bEy!*MbPc2%pIxy(d(Why+xRb=&(t8z44A#Ucjj>Ao3Ny(ds*7kv54?|o zd5}LY)k9U&Hszj__t{)Q5O6lC;v$G04mHr&gChb{^hAFKik(YDFC>){6x?ol(p3CH zxT%NuGf>=8_zvVp^$)rq*14#)z{nJK+a8^ymY;%U@3Z3`C3gOOT+iuG@UQ3s|bm-1kpOUnf$xb z8HC*+2z>5d7>sJTg8!=JdP2DcdYXe8cx zdGH5OU#bFcHFb0-34U0b$ut34Urt^JO%BV5#~9H{3q@t2iD~f;ss!*PxVXCP(}aR> zYlb;cbfmaDR&>Az$7pbEwUwu!;bwBp336Yq2Zs=Swy{?ZiwH3AC~1Pm_`~zX7d0lJ z#dnv1rH&Sd*n*FEC(F-V1b6+Tawi9Ghl+O~o3uMDv}!dhe3gLq8XHk3Hkq1|e2FAN z^F$4XF9JyM9>>6swmV}XE&`{whnP*EmsZK%z6$$7bJQ%TBifi#scCd+UAs}G-iP;V z^zih-9_*K9?!@KHsyz5gOsOY@^{mc6?|@T>$t%bIg?IA92Wj38+)fhH<9dK~_CpJF zT{DY%fc1vA3>Hf)8!gv}1y~Fq$-fF70MVr3R0~!#jtk&hoE2FC@^!Maz-88WPpRS| zmH%^Vp}nd#)~@!w<)U9E_fai-;;K1T%Uq~1KnUf@q}tzi>*>UhVYdyKF@nC9mTwj` ze=X@b)Ypn7o?>`w;H2Pg{0OYT>j-(=&i)4I-q1F>_{eA>=##0%mj=HoZ4xTvS`}jU zintP99*-aoJq}-03yclU+W6s6?vGkNble>i3k|>M6pz;3Bt1z~MG07ek%^33@Gk$X z_`woS3~i`z*TL;dPtZyY|3qYxDTThoCMA19=}FL%1Fag24L{6$<`y zyrj}vdJ5A3I~Dk;SdWGztWI?<#ED7OxjJ7|qOo5jf!HU|62wZRHwU`}=`8}EkU-o{ z%18T&&7sm0l$P-&_1GM^WUB*;i{!qn@s%Xc}v>NGE35$`w1?vAJQI6blRv#)%-y3^12 z#D@mrn@nQZ2`(*H70-FLr7?;1vRci0H45L6Oao)dGKNjE49i`!W=ec=xtQrlj$P5_ zC0$2UNmxoi`2DC;pf#m1%sPb|>_438BDUh0g_t|x z19Sicu?WC8xcGr0r;s%^ktBqe4d!x?CaGu*jNm&m$_42fA)z2zHp&$(=RUfRfts(fHGSxKB&BKY4=N%*X)n0 zFwws2U!%NQ<&b*%ceTTl)xWEwYdZ!1;mxz@-_sY&zJLDszV6@sQ~Gy*-M{6>K!+;BJFH<4+>J&m7>-C5sGSH-afwQcgGSd8Di7L4mpT?%Dm^yKDEV zcNJQ~_(D=Vnp;|IUf@{-XO?zh43UkUQn=EG15Rne6!RO_XUs0F2A%Qe|2?6{L^uky zq^`BB<4zORD9rVAkoo+s82{E2K~6=z8H(@-EyVx_AE>p35HX&Odd<;nI_-WjO32TQ zy1QRdjL^*c#enSfeldvet%moD=~+z;+1jYuR<9_8Kdq>0zZkDohF6lJm1Sc&3y9&O zThq_j!$F*V5ofHLVYDDcjd#!3g?l+;(|7H=2U6EA+RLtelbUlq)do!=^CQ#E83Ln` zJuQB|tW5+Enx!r)f5?gLI4*{8BcXouQ^j!WxfpO{afGtchSH2OT%MOuCmr9*252>T zdbmiwg4IGQs>ps?e1%1avWlz9$h0z`mdXpWc(s-~)RlEt6JXn=SixwiktVlzSW|6O z#6xDwLv62SZ6)O+p$d^H2xNYsEdkZE9+p#PQa-p$eP&ZwEpt)!h)$?}Mkf(*BVDz{e`?ui!8YwP4cQ;*BhsMTHz1t+Cm?5QktzCE-8K!EmNl)JUlX1(Dw zQXQMkkbt+^nzpW@s@$&Xf%5{dVKb{!a@nXm5J4{10~G9KYxDCU6Xlka!Q;r2(4AYj zr%T1X%WTXPRuvmDv8iwll!M3!mx)$yf>oL_(N{4W8of7$!yCe3Z|g(LUQA>qD7$%bu~6Tt)eqYeu+-x5=If&89A1HLWAeOlL~H zphngg7f(kcJ33+{f^zxUf4vn4SB9kA^5&Gev{TiwC=0fQ^evC3DTNBY zm0ES_YgQ~C$oXHIu;0!gwbBVC5|8TFGNcQA#W#os;XKq!=k29zH^iuLRt%^4sJTh{1)pOj6}K9LM959b z>q4MSi_aqO13vV4`B?UP0OV~n^~bQwL!~w7L9((b@-b6RaR`ixkJSlXA$_FYU;w#Y z=_6nsEtKPdZb+=EP&G2?ajhx)40xv4w2GZ%xRTdj|Iq3q7kP7hn zlf7j@FXa1tfgzQS{tdYxwLsVk(wPGLq1B4+FYXQuOp;p2 zf0Vc;I{-Bnutjrd5nfhHh%W5SMU{x=APEtogDfmT6B-Z%MCsuEDKap^N5S@0zKP`D zSBytZOJq!s@gDp1>{%GREvB~w+oA0!lFN0X+!i95Dsde>!?`VZT-#HUTZjS8M)T1s zxdqaP%(}jK=Q5&N9d+Kt$AXC^X0il67BAIS8iy#%CX>ay>INww8Jdy?58#y(n~Z6r z2!?@+sC@1X+d`wo22!um8SK@%Lhf{Il;)%Zw885{GOlk!Z81hcz>&oH#asA^!V8SA zO`iPDiua`=@_5tHN$|ZgFnT`o^C*~nfbS%eA4_Zi82nPo)`sAd@>OJ(7OWb5vyLzU z1LbN>K%-oJg4`I=#fjeNLsv_sM4{5^Fwk}}M<&2U8sSw6;?&cqYlO85+i>nGJhogd z8CaRl&vfmhehoLIc7sEEb7OEf|if_&?NidaqbDvdfxU ziAD%^yK1r9Zn&c_$UZmLK%*7h1s)fcf;*A{eQ+Gpip!sKv}#vg@L|kXRPaBPw-_EG zk6*dS8t9O`R(;xN$oWoU=l1*nqhul0kbowrLK>q^;%?#P=YKE(Yo~eY`qsXy`)Z>@ zsJW7j0zs>aQ1p~V(+$JV5*cpfbdqNZJ);$eh?b-P!H#ZP-u?~lu+NtxyoF0gB#3}l zZ9PWIsXp&J$$<>dYwvgUkXULSy5g8t^CX;t0GcThC*yT*8K!==z`|e=qK`QL7=8L$ zrgHQ%wu)rvvRg(0s7#B;7TdstIaS}n`05Q3Ev*;o z&eKMQz^bPTOu@L5(c&pX0Pi8KDO;u@oQzYXYtatGwc;z&86#)51EGeU`1G*;TBEPZkdf$^SX95(qZjOaEsX5*;mzkIiHeaZ*v+t}_GKNWH??~sF-4MN$0@(m8Y3z$=ktFn-DKKiSg zaVdaHI&%3S`)9;UNg{YFQz^*RFQ!$5jB`HNoAaSsGP3l4xx;PDEg8N%DLzAEDyQ#N zK|_nzYr(5YwjUXy%k(811psf2ln?6;e8amc8auRiNXxIVQ;{O;o=;vQh82gu%*!ix z;EcNWV2xNq?`z=jTS_5JitnkKwmMf9tW{cq4w!1^S{^)6j;qoBQ$r;WEZcS_sR~vt zL{5{V`kh4qY$88{`7~#Ux-6&`7=b`C0JH(VYy6;}BOMFsTryFgo6bBnZ6<20s*}ee zSF`QW!!LG^p5NC!`sWwBM`uS8)?@OW%^ZCu)h627(g2Lzc&O2GsMPqFGRc8g%{{E3t1z6WksZX zY2dTrCvrK(a|T)q!%qp-Dn-{Hehw)FpknVxmth@;zwB;S8*rTe(~_p6pwr3{gGf@F za}>lx+j*JDdZV#JEI_JaH3wm~%ZStE=jl8jk{)?}pxb6c6Pbmguq8yd^+va%49a+! ztjS-fm@JcudFWcO2Xu7}JItKA7M?#4yA}*NU0uTnGpDYF=MTiLO_?<;Fmvi!cz*u7 zhH0Z(Yc^STuQoFxB;20Bd)$SlC&hisq)@=zaIPX07njD}veM#-r3x`j(cHMkiVK1F ztVD5pvZuaxh?XqUZFtAd{jVLW@I%Dhu4_N6zTi916UbQSv*L(0`v*KKFLqA5=(;=Vyghto)BV&F4rYNR-P8fWP>X}N{R zow#cXG7Mo7yehXzR|sr}3Rytlx*+AeEo$U!2FVoNTX<$-+FY}RqGt=wpxZe~Ojh4W zH@-5(i!7HXo@e5(Bv?1JsVN`!kBLOT!udcf0GgHyk&42#I}3UjT5tJUyu3l!2c_Stezz5bc z?DgbapN2iudhJdcC&x`{1ksQ=?0E~d<=()v2Ac}O+U$Iet`o#j>?*>o8TUrB6#YfP zt(gT&F!L;u5)IT1h97AUHUpDjn6$^6#tB=HcjCa>R4yUR$z!XW1?8D*;x(#hT{2Us z1$5;^yTJ1U8$w_G1NET4{sDxbslP`|LnhH!5NQiT<0~IlHP^KGQlGR(hSDIykOuEe zwTX<2<;fwf@f}X`QLk`Cdk3_y{#w9pXWN){rZO8#|7ykJJ}|J+>|@HMffSnvt|I-d zc=}MSe;Dk+3N!YtyAKVwetM|LfG=%a9+-63i(CQ+efNfi9LdAJYnk04YMy4(L94)4 zDH6n7@>JF1o1_c`xJ#MpeCmBzF##sU2L?J8m6F&q2A*Ml)gooHl6eJg<=xLP@l3to zYO$p`6X-;~81!HE%?!Gp5$IjdOanSkO$9x?+UUGGOVB@2gZ};*LD#To)IT_jQSW+Y z8qjHJD(Kay*RReJ^s8&oXC8HO_YL~fyBT#oqfzgAW*X2{kYNhKgjXA#S7!EP|LSK80U^Px6*uK4vb=Ej5J03k)|FoMOCTs$IKE;U`#^SUZu z4BnBAmTSeM#VL3gTUUBgxi*;O6GkLnP-T1?*8{NRw-8edS?dTfba!tInroN;u zkUo8Q?7|2*8@sU6{)f4C;b#Y47b+z;E)h6#GOPu`Y#-jrtlSbXxr!?nZoZ9+m<`9a zBI!|+LQ$9*-a(ujV3uCOSolSW0OgH5Tdw8GRXTZ+KUIASqknhEnIdiR6ta*rc^F%g z)WKSB{H_bCo+2}WV&5_fW(89tgk%UFH}S+o{O;C61a@()3N?G3B!f4nq^0L);NZgI z$od~cw&TBMHkyxS{?}@Z-I0XYKrNx-a`Xf;k6@-8AYD?^@g;=N*OF{q$4Gih!Tg%B z=aY@C#<{KLCa7OytpD^j8<4f~2{JH|Nc90siFY`7GG!U(=Bg>CJz*2M$`W?FTjnZx zkm`=Cd4u;xLtU_z26$;w;?$IspI=r; z;bhe|qMfS%DI9ohMEzr}4+PtJSj$Yr5Uo^Y9wb3^eTCMMr0zacWZm8Q>KwZB%#7VR z8mP3KySl?hTA?@IMJseB?%4?p6%C*(H6iNhiq`ZVyE3xZUHR34-IeWWh@EBiH{mVP z70jjNPp}oD;*UCM zSPYJeva6D&AvWh9l#QzA13|ZT4<+7!Pxgix(L%PLo05A}%7&WNfO=uvt%VVW+4>L= z%fBZ=+{T1>aSo(||IIiq9iiPkifgn%ju@3#*-pXy_I&xFm7UTRj;v=;1lxcbMI|j8 zR%R_aNvk)#iT4E*rdGkX1yNzjNz;X43Q1jL0!yJk`my!AW?7O(oDxat> z?5~-)WIkr%W10z&HD^}kLn_Z@GK*)Z=yWP}*K*BCxIR5mY1w}Q!-gI$*}YNr6OkfY zMapaWaVy$stcp&SyS77Vl)HF6KNT?tRMQ&T06&n()mHNkr)Q9L2~TGDVti%&1{xr2 z!BiN%FKlU&4`PRr9u3ALlQ&qop2-we$#m64tYjc6y`BpuumQ!_H7=F8W_ zb4vk<2nCn4YBk6H>}?S4{FKA;J1_ZjbPru9ex(2v<^Sss<`J%mcUFx`PL6Sd;%wtqy(Xt@ba{j{dvzL%-ayD$Tig~D13uIjeA}gLvJ<^D)OWlFo0&M*)iDCMd9s(%t zu4JqSCCl^5a!{U`IHk?n-1(kAr@ojo5M%^-_&r~?EQ{A*`#`7`$j-v$7A_kedaWhG zQ1q2o>Ein+4Im#EoSlUpq8nh->YlA8RrhjtZ@-bE56;H|*k7yn(%)y`KQte}-&?Qe z9nmi!{R4#X+MUbB%M-!5ZhT7`m?gQ zNnG5y>%~U}yyAv}kJlf~vdWw5XZ&OoqrzJ(&!5O#Nc*z4i8vVu$$C2+tnlSJ4O7aU zo#kR@cjLAkFAm_> z%s=3_cF-l2nMTGGM|HT$O~D2D1v)End~}*$>x;`4D~zvr61%wuf@N9!QSsiFO8iX~ z$or{7Su8%gV_A5^$8isvTex{Sx+fa6rw(Dn7_Xc`C_`3UX`Zj3xFI1bFV5J1YW~Om#Q}V~1jFA)Y`=E?NBkz)R?;(|anO%Yy;T$;>RS!zTRHmHKrDDF zsoLUNYan_G(YzXHUZShvj_4EP8@5~(T|a>ab8YS}g32AR+SD~0EG~X2#IaF)c)7?( zKi7jWW>(}tVOs5@E>oZ~Nak7?Jf!@S!MoDh)jY^Tm7>Mc!_)&EgMfvoO`<>*waF^d z;(^0y@z5eosh`mCo~TVCO$I}#CWoP!LNynPS>U;QVWFD%nPmrtR-dQ<=&mwv@G=5y z(&D3i9!hLjkuY=C98P(~DsLDIgjmT5%pPd1fv5ZC0Ti$mLBXjTBhZ;vz0yEYz&*uS zbT?CJ68^M!f=b2e{rKtbhs%LlL(m8G)DX6K2H9O2{FHhFPkW=Cmoy=VsF(@;f%Eq1 zhJ<(y_!|h;!S3d{xHWeGP}E|br;3B3auArWYBP)aKGUf9|M(k^Eos+kli(pm8)-KX z6l=Rk127O-7@VDJk$!?o1G2gcB%W@8M^+OdNK|6pB)g41m zLfyyCRbdo;IVSdH)P1RNY)$B(7}$)a#^Ro3bzg3YeW|K1NUBl%!+=@onao-?YU2*_ zB`6@4Z2ZWI2eD#v&t>LxsTg;>zl_>nS_C)!_#sf081uYZIwGx}R{Toha)=goO?3KN zg$t(+1@_hA)7o>_*-Xks|<$5)bv7D zIjVC~439Wu+4{JwUgE8C=T||d20z}RQF8N$G)M=a4VP5l6$LTKeyrGK(FL2f5RD`f zB~*NWOIxl@C_pay)>ob`3AxRu#f^!WIDujy3mJG(XP)55WsxjI+*sg?;x2Ap2S~jQ zEnd)&5Iq@J0&$9tvJMUd<~!#jV23u2e2fXM1t^rkAq zp$U?e*IOdYgfor`kLc z?g^rs2#G$mE24+Y4nGPw7{1_k)udy*)FhbUCc!y<9AYJwrDj^qYsOmVB9d()P<6?m zIIT0kFuO(Vd~)JfEJ3EFI84C(aB6NHS7^I`7%~c+P8tV>kYR-)3sqfTyjOv=SU2sg zx3jxmkqhMQa~U%c3R>+r>%kHbUWT>q@PI7X)f{e9d-DA4xCXx~;Z|fL1RrrWM8`8p zj124>s*ohk|Hi>mEI>IEslXEmksVWR3BLETq0;rC{aav@E~>Dd2Y!&>-LvgxA!2e9hu&e?|$8GS54qhUu%NX z$?NuOz3UdiNdrCtlSE=l_$8dE1tb;GVr-+QX)?|ETy1h=5x|(dv@%6d(hx`oMv%E^ zbFlfWcIRN;7>?D7P#J?SVE1DBkho+*gTlRzCkVLVrCQb`-O3j#VN|jW11KFlmvnd&)1*Di66i1}~=Ml&9cv z63MC8gRBkoRQ~wdCM7{YidW#R)fNqmyvMsy-g^OlrIc+GJYL=#!78A}W#-)&zPP8| z81Ac@^>?b4SS-c2!fp&qMb}0SJ=-wMi0T)2q5AkCp!#|7%Yvx$n*u)kQ{nQT_glLb!r+5CG}Idg(^ zQvUnDmq%7Yw-ha53RfB@pX?_rgYh(>rT_l#1H}fVX&TXmB2tmKaWHWQ;OqQKe)3=M8Js zD8^F!^u`EnAb18UE$$hN+(-0BY3q$@OGc4Fk8@xRksG#YF9@hCKM{2}jlx?xl{%S- z@Ia^TqwK^yQCz7S;0!jL%g-=Kfv0LLAO@ZiNA65uYm_C>cro}n#SVvMm+C<5t`0U5 znir}w^+*#ys&rCFAhCN2o0T?BVxSY(xDL^312t%>b<8b%V@!~rXK|Zbwp4vRJ_}P9 zKIv(_hk1Zu?E?f}Eq-?h^c$v)WH=1J)xrxzqtzVzL$91qe3GftOFBw+GIy zqKAre6~;D;TXXF1$P^5jLJAaf&t=kk+6$uMul-VpD6D8RkAg=EI;`(A$`WGYZ>@&f zK)}QSBEP-&XA9tj9puj1?hY=e6^-*K6XzU;SGDj{ZDWtmgIFnKiC|pfV6DW~UtN+o zqJVcTAneA0X>i~oK6;gff3{CKiz3AQ*u?-N3xsydrs$1C!;%HO!Fh$n1C=}&u)KV3 zLwnr_ForIoJ+=nU13KUv<1mCSoyaAww)&!GQaeYP6UV zXd47BST|@*MG07%s@5c8Em2HdcWK+(nsK(g)ld7bm+A#>p^Bv+wE@q2wqC zr+{_f(DmH{Y=cg~br4Sx((h~r2>Eg_qe-U4whalCgs7Mx`IG4naCK;##JG$BXj^Qg zvmTb}zBo=ZJW_PO-yxUQn)QfA!@$5*ihnfJ@9a z-KdwDZ|1xui2*FcnNmLd>xraXS=`3P0CD((EP`aR60pvKX`+sn58nctSXTUUxg&ys zl55fu!v=-u!B0~jwR#2Ec=nL9*i^~LmDdtIfDDOx<(PqOIiapi3#&n8wfP@>MUA3Y7 zBcgy>bVyu;xqW3Z0P+jSXqXd98Oc8vp0Ej&>wH%Vfp+QBJS7WYE28;I;Te3BVG`+8u1PRou~~yWMji7NdO;O&kvifc z3j>OCUt?Gxq8bU3;&wvXP%n_s%GC9Ac#sQ)E@Zw?qKE3zc!M3>vF2&^&~Ku!r^#`X zJaX-CL9a(79vV}4LdrZ-$Y6pAlDMUe7iSX(7?$<;`1a)0YE)Jq=x-*yz@#GBL6{Mi zcv`&OY!1-!Ba$M-cc3zIy%;><`2xU?K%Y2nXg@khQ0C`j%I04;WOQIsA{9qUH3mm?8~lG-Ti6*}pyMB1cQ zHDk(?l1f~SiB~m4%)b#qpTI21cv4^if1h}bSS}X$dwzRcQa+HByEuky;`mf~p0*VI zcjXoizR{%?#1062GERlRB2iR|4tltH1y8DhaF@*A-1g5z9>gTtaueh}NBImFSBhW= zNkVJ+V3~q6sjd|l9wIfVeD3+YxJswpO~wYr0igq^shQOT>OxG!RgR;lnw?-g3g-i@Sp$CE5}MDe0L!dRV5qJswxT)gcgim!wpH&up2{ zv#N<)J&ReRA|`+vmUh5tGrxI&`JNXWX8e2hnZ!zIY8-&rtT?c^={#U$XnV#ux4?JOHE8B10v4jy8 zTwZuCR8p2O#@9qzmiT}a;3#Cs))Li~VF^O;`Pez2i4p|AmB3+iN~Bdj8kcX_atA~M z92i@1zBTYx@ag~wDe;=~V5JdQ)ttNa;(O%j1rxd%poKkTq;Ij;Pg4eD_zG14u)5l$ zfVhd-CYM8}GJI$OLNx+BSQk%YtVDwaJ?9H_zEHSIag*a5UsHKadBEONu1d#PfM}hs zh#7nG?8AGlrKkoUkr4cZec3_V3;^Jw6^$29if$UwdgT;55M@%y&1{rqE?xv^9H!gd ze4yjghMUrR5jGh4pJZ?10AYJ0c(H)K^zLrX#l9nwn-P8S61<>|%0DxWMSToiP3sq! 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

n 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

Fuq=U}gk#1q?LH29?Sbk-rby0!&n7R6h3! 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 void; -export const browserdb_checkpoint: (a: number) => number; -export const browserdb_execute: (a: number, b: number, c: number) => number; -export const browserdb_exportGraph: (a: number, b: number) => void; -export const browserdb_importGraph: (a: number, b: number) => number; -export const browserdb_open: (a: number, b: number) => number; -export const browserdb_openInMemory: (a: number) => void; -export const __wasm_bindgen_func_elem_2769: (a: number, b: number, c: number, d: number) => void; -export const __wasm_bindgen_func_elem_2781: (a: number, b: number, c: number, d: number) => void; -export const __wasm_bindgen_func_elem_658: (a: number, b: number, c: number) => void; -export const __wbindgen_export: (a: number, b: number) => number; -export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number; -export const __wbindgen_export3: (a: number) => void; -export const __wbindgen_export4: (a: number, b: number) => void; -export const __wbindgen_add_to_stack_pointer: (a: number) => number; diff --git a/minigraf-wasm/package.json b/minigraf-wasm/package.json deleted file mode 100644 index 9d75b4eeef..0000000000 --- a/minigraf-wasm/package.json +++ /dev/null @@ -1,32 +0,0 @@ -{ - "name": "@minigraf/browser", - "type": "module", - "collaborators": [ - "Aditya Mukhopadhyay" - ], - "description": "Zero-config, single-file, embedded graph database with bi-temporal Datalog queries", - "version": "0.0.0", - "license": "MIT OR Apache-2.0", - "repository": { - "type": "git", - "url": "https://github.com/project-minigraf/minigraf" - }, - "files": [ - "minigraf_bg.wasm", - "minigraf_bg.wasm.d.ts", - "minigraf.js", - "minigraf.d.ts" - ], - "main": "minigraf.js", - "types": "minigraf.d.ts", - "sideEffects": [ - "./snippets/*" - ], - "keywords": [ - "graph", - "datalog", - "bitemporal", - "embedded", - "database" - ] -} \ No newline at end of file diff --git a/src/bin/uniffi_bindgen_stub.rs b/src/bin/uniffi_bindgen_stub.rs deleted file mode 100644 index 7e89828565..0000000000 --- a/src/bin/uniffi_bindgen_stub.rs +++ /dev/null @@ -1,41 +0,0 @@ -// Stub that lets `cargo run --bin uniffi-bindgen` resolve from the workspace root. -// -// maturin (bindings = "uniffi") calls `cargo run --bin uniffi-bindgen generate ...` -// without --package, so cargo searches the workspace default members (root package -// only). This stub is compiled from the root package and execs the real binary, -// which is pre-built by build.sh before maturin is invoked: -// -// cargo build --bin uniffi-bindgen --manifest-path minigraf-ffi/Cargo.toml -// -// The real binary lives at target/debug/uniffi-bindgen[.exe] relative to the -// workspace root. Using exec-style dispatch keeps this a no-op passthrough with -// no extra dependencies and no nested-cargo issues. - -use std::path::PathBuf; -use std::process; - -fn main() { - let manifest_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")); - - let mut real_bin = manifest_dir - .join("target") - .join("debug") - .join("uniffi-bindgen"); - if cfg!(windows) { - real_bin.set_extension("exe"); - } - - let status = process::Command::new(&real_bin) - .args(std::env::args_os().skip(1)) - .status() - .unwrap_or_else(|e| { - eprintln!( - "uniffi-bindgen stub: failed to exec {}: {}", - real_bin.display(), - e - ); - process::exit(1); - }); - - process::exit(status.code().unwrap_or(1)); -} From e66b6539938fa5e89d04847936cf553d546d973c Mon Sep 17 00:00:00 2001 From: Aditya Mukhopadhyay Date: Sun, 17 May 2026 18:20:51 +0530 Subject: [PATCH 6/7] fix(cascade): fail on crates.io indexing timeout instead of silently succeeding --- .github/workflows/cascade.yml | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/.github/workflows/cascade.yml b/.github/workflows/cascade.yml index cbf023d33e..7f3ecd2cd2 100644 --- a/.github/workflows/cascade.yml +++ b/.github/workflows/cascade.yml @@ -23,31 +23,43 @@ jobs: run: | VERSION="${GITHUB_REF_NAME#v}" echo "Waiting for minigraf-ffi@$VERSION on crates.io..." + FOUND=0 for i in $(seq 1 18); do STATUS=$(curl -s "https://crates.io/api/v1/crates/minigraf-ffi/$VERSION" \ -H "User-Agent: minigraf-cascade/1.0" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('version',{}).get('num',''))" 2>/dev/null || echo "") if [ "$STATUS" = "$VERSION" ]; then echo "minigraf-ffi@$VERSION is live (attempt $i)" + FOUND=1 break fi echo "Attempt $i/18: not yet available, waiting 10s..." sleep 10 done + if [ "$FOUND" != "1" ]; then + echo "ERROR: minigraf-ffi@$VERSION did not appear on crates.io within 3 minutes" + exit 1 + fi - name: Wait for minigraf to be indexed on crates.io run: | VERSION="${GITHUB_REF_NAME#v}" echo "Waiting for minigraf@$VERSION on crates.io..." + FOUND=0 for i in $(seq 1 18); do STATUS=$(curl -s "https://crates.io/api/v1/crates/minigraf/$VERSION" \ -H "User-Agent: minigraf-cascade/1.0" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('version',{}).get('num',''))" 2>/dev/null || echo "") if [ "$STATUS" = "$VERSION" ]; then echo "minigraf@$VERSION is live (attempt $i)" + FOUND=1 break fi echo "Attempt $i/18: not yet available, waiting 10s..." sleep 10 done + if [ "$FOUND" != "1" ]; then + echo "ERROR: minigraf@$VERSION did not appear on crates.io within 3 minutes" + exit 1 + fi dispatch-bindings: name: Dispatch to binding repos From 2abb09710390acaa8e22302ff33bd3f102e37eee Mon Sep 17 00:00:00 2001 From: Aditya Mukhopadhyay Date: Sun, 17 May 2026 21:58:30 +0530 Subject: [PATCH 7/7] fix: resolve cascade publish race + update test count to 962 (#231) Move minigraf crates.io wait before cargo publish -p minigraf-ffi in cascade.yml so the FFI crate's path-dep version is available when published. Update stale 935 test counts to 962 in CLAUDE.md, README.md, and ROADMAP.md. Co-Authored-By: Claude Sonnet 4.6 --- .github/workflows/cascade.yml | 30 +++++++++++++++--------------- CLAUDE.md | 2 +- README.md | 2 +- ROADMAP.md | 4 ++-- 4 files changed, 19 insertions(+), 19 deletions(-) diff --git a/.github/workflows/cascade.yml b/.github/workflows/cascade.yml index 7f3ecd2cd2..938ae8b3e8 100644 --- a/.github/workflows/cascade.yml +++ b/.github/workflows/cascade.yml @@ -14,21 +14,16 @@ jobs: - uses: dtolnay/rust-toolchain@stable - - name: Publish minigraf-ffi - env: - CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }} - run: cargo publish -p minigraf-ffi - - - name: Wait for minigraf-ffi to be indexed on crates.io + - name: Wait for minigraf to be indexed on crates.io run: | VERSION="${GITHUB_REF_NAME#v}" - echo "Waiting for minigraf-ffi@$VERSION on crates.io..." + echo "Waiting for minigraf@$VERSION on crates.io..." FOUND=0 for i in $(seq 1 18); do - STATUS=$(curl -s "https://crates.io/api/v1/crates/minigraf-ffi/$VERSION" \ + STATUS=$(curl -s "https://crates.io/api/v1/crates/minigraf/$VERSION" \ -H "User-Agent: minigraf-cascade/1.0" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('version',{}).get('num',''))" 2>/dev/null || echo "") if [ "$STATUS" = "$VERSION" ]; then - echo "minigraf-ffi@$VERSION is live (attempt $i)" + echo "minigraf@$VERSION is live (attempt $i)" FOUND=1 break fi @@ -36,20 +31,25 @@ jobs: sleep 10 done if [ "$FOUND" != "1" ]; then - echo "ERROR: minigraf-ffi@$VERSION did not appear on crates.io within 3 minutes" + echo "ERROR: minigraf@$VERSION did not appear on crates.io within 3 minutes" exit 1 fi - - name: Wait for minigraf to be indexed on crates.io + - name: Publish minigraf-ffi + env: + CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }} + run: cargo publish -p minigraf-ffi + + - name: Wait for minigraf-ffi to be indexed on crates.io run: | VERSION="${GITHUB_REF_NAME#v}" - echo "Waiting for minigraf@$VERSION on crates.io..." + echo "Waiting for minigraf-ffi@$VERSION on crates.io..." FOUND=0 for i in $(seq 1 18); do - STATUS=$(curl -s "https://crates.io/api/v1/crates/minigraf/$VERSION" \ + STATUS=$(curl -s "https://crates.io/api/v1/crates/minigraf-ffi/$VERSION" \ -H "User-Agent: minigraf-cascade/1.0" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('version',{}).get('num',''))" 2>/dev/null || echo "") if [ "$STATUS" = "$VERSION" ]; then - echo "minigraf@$VERSION is live (attempt $i)" + echo "minigraf-ffi@$VERSION is live (attempt $i)" FOUND=1 break fi @@ -57,7 +57,7 @@ jobs: sleep 10 done if [ "$FOUND" != "1" ]; then - echo "ERROR: minigraf@$VERSION did not appear on crates.io within 3 minutes" + echo "ERROR: minigraf-ffi@$VERSION did not appear on crates.io within 3 minutes" exit 1 fi diff --git a/CLAUDE.md b/CLAUDE.md index 20200956e1..611c21b9ae 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -167,7 +167,7 @@ Auto-migrates v1/v2/v3/v4/v5/v6 → v7 on open/checkpoint. ## Test Coverage -**935 tests passing** (unit + integration + doc). +**962 tests passing** (unit + integration + doc). See `TEST_COVERAGE.md` for the full per-file breakdown. **Testing conventions** — see the Testing Conventions section below before writing any tests. diff --git a/README.md b/README.md index 92b0bfe0bc..9b81fd2ebd 100644 --- a/README.md +++ b/README.md @@ -91,7 +91,7 @@ let r2 = pq.execute(&[("tx", BindValue::TxCount(2)), ("entity", BindValue::Entit ```bash cargo run # interactive Datalog REPL -cargo test # run 935 tests +cargo test # run 962 tests cargo run < demos/demo_recursive.txt # recursive rules demo ``` diff --git a/ROADMAP.md b/ROADMAP.md index e53e48016c..39958ae837 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -1673,7 +1673,7 @@ When evaluating features, ask: - ✅ Phase 8: Complete (May 2026) — v1.0.0 - ✅ Wave 1 Performance: Complete (May 2026) — hash-join cluster + selective B+Tree lookup (#202, #203, #204, #208), 850 tests - ✅ Wave 2 Optimizer & Benchmarks: Complete (May 2026) — predicate push-down (#207, #206), cost-based not/or ordering (#205), SIMD crossover analysis (#229), 850 tests -- ✅ Wave 3 Reliability: Complete (May 2026) — WAL fault injection, migration matrix, index corruption resilience, property-based testing, coverage gates, long-haul smoke, XTDB/Datomic compat (#209, #210, #212, #213, #214, #215, #216, #217, #219, #220, #221), 935 tests +- ✅ Wave 3 Reliability: Complete (May 2026) — WAL fault injection, migration matrix, index corruption resilience, property-based testing, coverage gates, long-haul smoke, XTDB/Datomic compat (#209, #210, #212, #213, #214, #215, #216, #217, #219, #220, #221), 962 tests - ✅ Wave 4 Deferred Features: Complete (May 2026) — #182, #183, #180, #181 tagged milestone 2.0; #187 closed (no pre-1.0 users); #201 deferred to Wave 6 - 🎯 Phase 9: Ongoing (Ecosystem — integration examples, cookbook, GraphRAG/LangChain examples) @@ -1716,4 +1716,4 @@ See [GitHub Issues](https://github.com/project-minigraf/minigraf/issues) for spe --- -**Last Updated**: #231 Repo Split Complete (May 2026) — 935 tests passing, v1.1.1; Phase 1 bindings (Python, Node, WASM) in separate repos; Wave 5 is next +**Last Updated**: #231 Repo Split Complete (May 2026) — 962 tests passing, v1.1.1; Phase 1 bindings (Python, Node, WASM) in separate repos; Wave 5 is next