From 413789fcaeb25b13be823470413f06a183df7118 Mon Sep 17 00:00:00 2001 From: RubenGlez Date: Thu, 6 Aug 2026 23:42:06 +0200 Subject: [PATCH 01/11] add native Windows support --- .github/workflows/ci.yml | 39 ++++++++++++++++++++++++++- .goreleaser.yaml | 9 ++++--- README.md | 28 ++++++++++++++++--- cmd/init.go | 13 +++++++-- cmd/permissions.go | 28 +++++++++++++++++++ cmd/permissions_unix.go | 9 +++++++ cmd/permissions_unix_test.go | 19 +++++++++++++ cmd/permissions_windows.go | 43 +++++++++++++++++++++++++++++ cmd/permissions_windows_test.go | 48 +++++++++++++++++++++++++++++++++ cmd/review_fixes_test.go | 8 +----- cmd/unlock.go | 11 ++++---- go.mod | 6 ++--- 12 files changed, 235 insertions(+), 26 deletions(-) create mode 100644 cmd/permissions.go create mode 100644 cmd/permissions_unix.go create mode 100644 cmd/permissions_unix_test.go create mode 100644 cmd/permissions_windows.go create mode 100644 cmd/permissions_windows_test.go diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index d82d7e9..daee081 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -10,7 +10,11 @@ permissions: jobs: build-test: - runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, windows-latest] + runs-on: ${{ matrix.os }} steps: - name: Checkout uses: actions/checkout@v7 @@ -33,16 +37,49 @@ jobs: # govulncheck is call-graph aware: it only fails on advisories this code # actually reaches, so it does not flag unreachable ones in dependencies. - name: Vulncheck + if: runner.os == 'Linux' run: go run golang.org/x/vuln/cmd/govulncheck@latest ./... # Dogfood the policy: doctier's own private docs must be encrypted at rest. # The repo ships them as ciphertext, so this passes without any key — a key # is only needed to READ them, not to verify they are encrypted. - name: doctier check + if: runner.os == 'Linux' run: | go build -o /tmp/doctier . /tmp/doctier check + - name: Git for Windows hook smoke test + if: runner.os == 'Windows' + shell: pwsh + run: | + $ErrorActionPreference = 'Stop' + $bin = Join-Path $env:RUNNER_TEMP 'doctier-bin' + New-Item -ItemType Directory -Force $bin | Out-Null + go build -o (Join-Path $bin 'doctier.exe') . + $env:PATH = "$bin;$env:PATH" + $repo = Join-Path $env:RUNNER_TEMP 'hook-smoke' + git init $repo + git -C $repo config user.name 'doctier-ci' + git -C $repo config user.email 'doctier-ci@example.invalid' + Push-Location $repo + try { + doctier init + Add-Content .doctier.yml "`npolicy:`n uncovered: block" + Set-Content unclassified.md 'must be rejected' + git add unclassified.md + $ErrorActionPreference = 'Continue' + git commit -m 'must fail' + $commitExit = $LASTEXITCODE + $ErrorActionPreference = 'Stop' + if ($commitExit -eq 0) { + throw 'pre-commit hook did not reject an unclassified document' + } + Write-Host "pre-commit hook rejected the invalid commit (exit $commitExit)" + } finally { + Pop-Location + } + # Dogfood the bundled GitHub Action (action/): installs the latest release # binary (checksum-verified) and runs `doctier check` on this repo. action-check: diff --git a/.goreleaser.yaml b/.goreleaser.yaml index 4be4507..e7f7b77 100644 --- a/.goreleaser.yaml +++ b/.goreleaser.yaml @@ -8,13 +8,10 @@ project_name: doctier builds: - env: - CGO_ENABLED=0 - # No windows: the hooks are sh scripts and nothing is tested under - # Git-for-Windows — shipping untested binaries of a fail-closed security - # tool is worse than not shipping them. Re-add with a Windows CI job when - # there is demand. goos: - linux - darwin + - windows goarch: - amd64 - arm64 @@ -36,6 +33,10 @@ builds: archives: - formats: - tar.gz + format_overrides: + - goos: windows + formats: + - zip name_template: "{{ .ProjectName }}_{{ .Version }}_{{ .Os }}_{{ .Arch }}" checksum: diff --git a/README.md b/README.md index 83fcec5..3a05b58 100644 --- a/README.md +++ b/README.md @@ -124,9 +124,31 @@ curl -fsSL https://raw.githubusercontent.com/RubenGlez/doctier/main/install.sh | go install github.com/rubenglez/doctier@latest ``` +On Windows, download the `windows_amd64` or `windows_arm64` ZIP and +`checksums.txt` from the Releases page, verify it, then place `doctier.exe` on +your user `PATH`: + +```powershell +Get-FileHash .\doctier_*_windows_amd64.zip -Algorithm SHA256 +# Compare the hash with checksums.txt before extracting. +New-Item -ItemType Directory -Force "$HOME\bin" | Out-Null +Expand-Archive .\doctier_*_windows_amd64.zip -DestinationPath "$HOME\bin" -Force +$userPath = [Environment]::GetEnvironmentVariable('Path', 'User') +if (($userPath -split ';') -notcontains "$HOME\bin") { + [Environment]::SetEnvironmentVariable('Path', "$userPath;$HOME\bin", 'User') +} +# Open a new terminal, then run: doctier version +``` + macOS binaries are signed with a Developer ID certificate and notarized by Apple, so Gatekeeper runs them without a security prompt. +Windows requires Git for Windows. Doctier installs standard extensionless Git +hooks with an `sh` shebang; Git for Windows supplies and invokes that shell. +Decrypted private files receive a protected NTFS DACL granting access only to +the current Windows user. Windows release ZIPs are checksum-verified artifacts; +they are not Authenticode-signed yet. + ## Quick start ```bash @@ -318,9 +340,9 @@ separate, deliberate grant — see [docs/agents.md](docs/agents.md). a GUI git client's PATH lacks the install dir (e.g. `~/.local/bin`) — checkouts and adds touching private files fail with git's opaque "external filter ... failed". Fix the client's PATH, or temporarily `git config filter.doctier.required false`. -- **Windows is not supported.** The hooks are `sh` scripts and nothing is tested - under Git-for-Windows, so no Windows binaries are shipped (WSL works — it is - just Linux). +- **Windows requires Git for Windows.** Native Windows builds, filters, hooks, + encryption and owner-only plaintext ACLs are covered in CI. WSL remains a + separate Linux environment and uses the Linux binary. Encryption is age-only by design (a separate private-repo backend is an explicit non-goal). diff --git a/cmd/init.go b/cmd/init.go index c0f3ea8..4e4f51b 100644 --- a/cmd/init.go +++ b/cmd/init.go @@ -5,6 +5,7 @@ import ( "os" "os/exec" "path/filepath" + "runtime" "strings" "github.com/rubenglez/doctier/internal/agex" @@ -152,13 +153,21 @@ editing .doctier.yml to sync the generated artifacts with the rules.`) } fmt.Println("\nNext steps:") - fmt.Println(" 1. Add recipients: doctier grant \"$(cat ~/.ssh/id_ed25519.pub)\"") + if runtime.GOOS == "windows" { + fmt.Println(" 1. Add recipients: doctier grant (Get-Content $HOME\\.ssh\\id_ed25519.pub -Raw)") + } else { + fmt.Println(" 1. Add recipients: doctier grant \"$(cat ~/.ssh/id_ed25519.pub)\"") + } fmt.Println(" 2. Edit .doctier.yml to classify your documents, then re-run") fmt.Println(" 'doctier init' to sync .gitattributes/.gitignore with the rules.") fmt.Println(" 3. Verify: doctier check") fmt.Println("\nHeadless / CI / agent runs (no interactive key):") fmt.Println(" • grant a dedicated key: doctier grant \"\"") - fmt.Println(" • provide it at runtime: export DOCTIER_IDENTITY=\"$(cat ci_key)\" (path or inline PEM)") + if runtime.GOOS == "windows" { + fmt.Println(" • provide it at runtime: $env:DOCTIER_SSH_KEY = '.\\ci_key' (path or inline PEM)") + } else { + fmt.Println(" • provide it at runtime: export DOCTIER_IDENTITY=\"$(cat ci_key)\" (path or inline PEM)") + } fmt.Println(" • decrypt the worktree: doctier unlock (or read one file: doctier cat )") return nil } diff --git a/cmd/permissions.go b/cmd/permissions.go new file mode 100644 index 0000000..f8b0b0f --- /dev/null +++ b/cmd/permissions.go @@ -0,0 +1,28 @@ +package cmd + +import ( + "errors" + "os" +) + +// writeOwnerOnly writes sensitive plaintext only after the destination has +// been restricted to the current user. Creating an empty placeholder first is +// intentional: platform ACL setup may require an existing filesystem object, +// and an ACL failure must occur before any plaintext reaches disk. +func writeOwnerOnly(path string, data []byte) error { + if _, err := os.Stat(path); errors.Is(err, os.ErrNotExist) { + f, createErr := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o600) + if createErr != nil { + return createErr + } + if closeErr := f.Close(); closeErr != nil { + return closeErr + } + } else if err != nil { + return err + } + if err := restrictToCurrentUser(path); err != nil { + return err + } + return os.WriteFile(path, data, 0o600) +} diff --git a/cmd/permissions_unix.go b/cmd/permissions_unix.go new file mode 100644 index 0000000..bff868a --- /dev/null +++ b/cmd/permissions_unix.go @@ -0,0 +1,9 @@ +//go:build !windows + +package cmd + +import "os" + +func restrictToCurrentUser(path string) error { + return os.Chmod(path, 0o600) +} diff --git a/cmd/permissions_unix_test.go b/cmd/permissions_unix_test.go new file mode 100644 index 0000000..2864f33 --- /dev/null +++ b/cmd/permissions_unix_test.go @@ -0,0 +1,19 @@ +//go:build !windows + +package cmd + +import ( + "os" + "testing" +) + +func assertOwnerOnlyPermissions(t *testing.T, path string) { + t.Helper() + info, err := os.Stat(path) + if err != nil { + t.Fatal(err) + } + if perm := info.Mode().Perm(); perm != 0o600 { + t.Fatalf("unlock must write 0600, got %o", perm) + } +} diff --git a/cmd/permissions_windows.go b/cmd/permissions_windows.go new file mode 100644 index 0000000..e1281f4 --- /dev/null +++ b/cmd/permissions_windows.go @@ -0,0 +1,43 @@ +//go:build windows + +package cmd + +import ( + "fmt" + + "golang.org/x/sys/windows" +) + +// restrictToCurrentUser replaces inherited permissions with a protected DACL +// granting full control only to the user running doctier. Windows does not +// enforce Unix mode bits, so os.Chmod(0600) is not a security boundary here. +func restrictToCurrentUser(path string) error { + user, err := windows.GetCurrentProcessToken().GetTokenUser() + if err != nil { + return fmt.Errorf("resolve current Windows user: %w", err) + } + acl, err := windows.ACLFromEntries([]windows.EXPLICIT_ACCESS{{ + AccessPermissions: windows.GENERIC_ALL, + AccessMode: windows.GRANT_ACCESS, + Trustee: windows.TRUSTEE{ + TrusteeForm: windows.TRUSTEE_IS_SID, + TrusteeType: windows.TRUSTEE_IS_USER, + TrusteeValue: windows.TrusteeValueFromSID(user.User.Sid), + }, + }}, nil) + if err != nil { + return fmt.Errorf("build owner-only Windows ACL: %w", err) + } + if err := windows.SetNamedSecurityInfo( + path, + windows.SE_FILE_OBJECT, + windows.DACL_SECURITY_INFORMATION|windows.PROTECTED_DACL_SECURITY_INFORMATION, + nil, + nil, + acl, + nil, + ); err != nil { + return fmt.Errorf("apply owner-only Windows ACL to %s: %w", path, err) + } + return nil +} diff --git a/cmd/permissions_windows_test.go b/cmd/permissions_windows_test.go new file mode 100644 index 0000000..9afa7bc --- /dev/null +++ b/cmd/permissions_windows_test.go @@ -0,0 +1,48 @@ +//go:build windows + +package cmd + +import ( + "testing" + "unsafe" + + "golang.org/x/sys/windows" +) + +func assertOwnerOnlyPermissions(t *testing.T, path string) { + t.Helper() + sd, err := windows.GetNamedSecurityInfo( + path, + windows.SE_FILE_OBJECT, + windows.DACL_SECURITY_INFORMATION, + ) + if err != nil { + t.Fatal(err) + } + control, _, err := sd.Control() + if err != nil { + t.Fatal(err) + } + if control&windows.SE_DACL_PROTECTED == 0 { + t.Fatal("unlock DACL must be protected from inherited access entries") + } + dacl, _, err := sd.DACL() + if err != nil { + t.Fatal(err) + } + if dacl == nil || dacl.AceCount != 1 { + t.Fatalf("unlock must install one protected user ACE, got %#v", dacl) + } + var ace *windows.ACCESS_ALLOWED_ACE + if err := windows.GetAce(dacl, 0, &ace); err != nil { + t.Fatal(err) + } + gotSID := (*windows.SID)(unsafe.Pointer(&ace.SidStart)) + user, err := windows.GetCurrentProcessToken().GetTokenUser() + if err != nil { + t.Fatal(err) + } + if !gotSID.Equals(user.User.Sid) { + t.Fatalf("unlock ACL belongs to %s, want current user %s", gotSID, user.User.Sid) + } +} diff --git a/cmd/review_fixes_test.go b/cmd/review_fixes_test.go index 13eb18c..3a9dec7 100644 --- a/cmd/review_fixes_test.go +++ b/cmd/review_fixes_test.go @@ -138,13 +138,7 @@ func TestUnlockWritesOwnerOnlyPermissions(t *testing.T) { if err := runUnlock(nil); err != nil { t.Fatalf("unlock: %v", err) } - info, err := os.Stat(filepath.Join(root, "secret/doc.md")) - if err != nil { - t.Fatal(err) - } - if perm := info.Mode().Perm(); perm != 0o600 { - t.Fatalf("unlock must write 0600, got %o", perm) - } + assertOwnerOnlyPermissions(t, filepath.Join(root, "secret/doc.md")) } // gc must exit non-zero when a removal genuinely fails, instead of printing diff --git a/cmd/unlock.go b/cmd/unlock.go index 82891dc..d0365b8 100644 --- a/cmd/unlock.go +++ b/cmd/unlock.go @@ -72,11 +72,12 @@ plaintext in the working tree are left untouched.`) failed++ continue } - // 0600: this is deliberately-encrypted content landing on disk. Tighten - // before writing — WriteFile's perm only applies when creating, and the - // ciphertext copy usually already exists (wider) at dest. - _ = os.Chmod(dest, 0o600) - if err := os.WriteFile(dest, pt, 0o600); err != nil { + // This is deliberately-encrypted content landing on disk. Tighten the + // existing ciphertext path before writing plaintext. On Unix this is + // mode 0600; on Windows it is a protected DACL containing only the + // current user's SID. If the file is absent, create an empty placeholder + // first so no plaintext is ever present under inherited permissions. + if err := writeOwnerOnly(dest, pt); err != nil { return err } n++ diff --git a/go.mod b/go.mod index 470bb7a..f0faa6c 100644 --- a/go.mod +++ b/go.mod @@ -6,10 +6,8 @@ require ( filippo.io/age v1.2.1 github.com/bmatcuk/doublestar/v4 v4.7.1 golang.org/x/crypto v0.52.0 + golang.org/x/sys v0.45.0 gopkg.in/yaml.v3 v3.0.1 ) -require ( - filippo.io/edwards25519 v1.1.0 // indirect - golang.org/x/sys v0.45.0 // indirect -) +require filippo.io/edwards25519 v1.1.0 // indirect From efeb8b6220da458882f07d007761e44c58c83c4d Mon Sep 17 00:00:00 2001 From: RubenGlez Date: Fri, 7 Aug 2026 00:34:31 +0200 Subject: [PATCH 02/11] fix: secure Windows checkout and release scope --- .github/workflows/ci.yml | 57 +++++++++++++++++++++++++++++++ .goreleaser.yaml | 5 +++ README.md | 46 ++++++++++++++----------- cmd/filter.go | 9 +++++ cmd/filter_test.go | 7 ++++ cmd/permissions_windows_test.go | 59 +++++++++++++++++++++++++++++++++ cmd/unlock.go | 5 +++ 7 files changed, 168 insertions(+), 20 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index daee081..599fbfe 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -80,6 +80,63 @@ jobs: Pop-Location } + - name: Secure Windows checkout smoke test + if: runner.os == 'Windows' + shell: pwsh + run: | + $ErrorActionPreference = 'Stop' + $bin = Join-Path $env:RUNNER_TEMP 'doctier-bin' + $env:PATH = "$bin;$env:PATH" + $key = Join-Path $env:RUNNER_TEMP 'doctier-test-key' + ssh-keygen -q -t ed25519 -N '""' -f $key + $env:DOCTIER_SSH_KEY = $key + + $source = Join-Path $env:RUNNER_TEMP 'secure-source' + git init -q -b main $source + git -C $source config user.name 'doctier-ci' + git -C $source config user.email 'doctier-ci@example.invalid' + Push-Location $source + try { + doctier init + @' + version: 1 + docs: + - path: "secret/**" + visibility: private + lifetime: durable + recipients_file: .doctier/recipients.txt + '@ | Set-Content .doctier.yml + doctier init + doctier grant (Get-Content "$key.pub" -Raw) + New-Item -ItemType Directory -Force secret | Out-Null + Set-Content secret/plan.md 'TOP SECRET' + git add -A + git commit -q -m 'add encrypted document' + } finally { + Pop-Location + } + + $clone = Join-Path $env:RUNNER_TEMP 'secure-clone' + git clone -q $source $clone + Push-Location $clone + try { + doctier init + $doctier = (Join-Path $bin 'doctier.exe').Replace('\', '/') + git config --local filter.doctier.smudge "'$doctier' filter smudge %f" + Remove-Item secret/plan.md + git checkout -- secret/plan.md + $checkedOut = Get-Content secret/plan.md -Raw + if ($checkedOut -notmatch 'BEGIN AGE ENCRYPTED FILE') { + throw 'normal Windows checkout materialized plaintext before an owner-only DACL could be applied' + } + doctier unlock + if ((Get-Content secret/plan.md -Raw).Trim() -ne 'TOP SECRET') { + throw 'doctier unlock did not materialize the expected plaintext' + } + } finally { + Pop-Location + } + # Dogfood the bundled GitHub Action (action/): installs the latest release # binary (checksum-verified) and runs `doctier check` on this repo. action-check: diff --git a/.goreleaser.yaml b/.goreleaser.yaml index e7f7b77..fc6587e 100644 --- a/.goreleaser.yaml +++ b/.goreleaser.yaml @@ -15,6 +15,11 @@ builds: goarch: - amd64 - arm64 + # Windows ARM64 remains unpublished until it is exercised on a native + # ARM64 runner or physical machine rather than only cross-compiled. + ignore: + - goos: windows + goarch: arm64 flags: - -trimpath ldflags: diff --git a/README.md b/README.md index 3a05b58..fd184b4 100644 --- a/README.md +++ b/README.md @@ -22,7 +22,8 @@ fail-closed, to let a private doc be committed in cleartext. > Status: **early (v0.x), actively developed.** The core — manifest, age clean/smudge > filters, fail-closed checks, merge driver, ephemeral GC, work-state-aware -> `doctier agents` — works end-to-end and ships as signed, notarized binaries. +> `doctier agents` — works end-to-end. Release artifacts include checksums; +> macOS binaries are additionally signed and notarized.

doctier demo: one manifest classifies the docs, git stores age ciphertext, the worktree reads plaintext, doctier check passes @@ -51,10 +52,10 @@ or shared), committing docs to a working branch and deleting them by hand later `doctier` builds the **two missing axes on top of git** instead of inventing a new store, and it was designed from the start for **coding agents working in parallel -git worktrees**. Because tracked docs — public *and* private (encrypted) — travel -to every worktree through git's own checkout, an agent spawned in a fresh worktree -sees exactly the docs it should, with private ones already decrypted in its working -tree, and nothing extra to set up per worktree. +git worktrees**. Tracked docs — public *and* private (encrypted) — travel to every +worktree through git's own checkout. On Linux and macOS, configured filters can +decrypt private docs during checkout; on Windows, `doctier unlock` materializes +them with an owner-only DACL after checkout leaves them encrypted. ## How it works @@ -124,9 +125,8 @@ curl -fsSL https://raw.githubusercontent.com/RubenGlez/doctier/main/install.sh | go install github.com/rubenglez/doctier@latest ``` -On Windows, download the `windows_amd64` or `windows_arm64` ZIP and -`checksums.txt` from the Releases page, verify it, then place `doctier.exe` on -your user `PATH`: +On x64 Windows, download the `windows_amd64` ZIP and `checksums.txt` from the +Releases page, verify it, then place `doctier.exe` on your user `PATH`: ```powershell Get-FileHash .\doctier_*_windows_amd64.zip -Algorithm SHA256 @@ -145,9 +145,11 @@ Gatekeeper runs them without a security prompt. Windows requires Git for Windows. Doctier installs standard extensionless Git hooks with an `sh` shebang; Git for Windows supplies and invokes that shell. -Decrypted private files receive a protected NTFS DACL granting access only to -the current Windows user. Windows release ZIPs are checksum-verified artifacts; -they are not Authenticode-signed yet. +For security, checkout keeps private files encrypted on Windows; run `doctier +unlock` to write plaintext with a protected NTFS DACL granting access only to +the current user. Windows release ZIPs are checksum-verified artifacts, but are +not Authenticode-signed. Windows ARM64 remains experimental and is not published +until it has been validated on native ARM64 hardware or a runner. ## Quick start @@ -161,10 +163,11 @@ doctier check ``` Decryption uses your SSH private key (`$DOCTIER_SSH_KEY`, else `~/.ssh/id_ed25519` -or `~/.ssh/id_rsa`). The key must be passphrase-less: git filters cannot prompt, -so a passphrase-protected key leaves private docs encrypted in your worktree (you -get a warning on checkout and from `doctier status`). Point `$DOCTIER_SSH_KEY` at -a dedicated key if your main one has a passphrase. +or `~/.ssh/id_rsa`). On Linux and macOS the key must be passphrase-less because +git filters cannot prompt; a passphrase-protected key leaves private docs +encrypted. Windows checkout always leaves them encrypted so `doctier unlock` can +apply the DACL before writing plaintext. Point `$DOCTIER_SSH_KEY` at a dedicated +key if your main one has a passphrase. ## Joining a repo that already uses doctier @@ -173,7 +176,8 @@ ENCRYPTED FILE-----` blocks) — expected, not broken: the filter and hooks live in `.git`, so they don't travel with the clone. To get to plaintext: 1. Install doctier and run `doctier init` in the clone — it wires the filter - and hooks so future checkouts decrypt automatically. + and hooks. On Linux and macOS, future checkouts can decrypt automatically; + Windows checkouts intentionally remain encrypted until `doctier unlock`. 2. Get granted: send your `~/.ssh/id_ed25519.pub` to someone who already has access; they run `doctier grant ""` and commit the result. You cannot self-serve by adding your own key — it can't decrypt blobs that were @@ -240,8 +244,9 @@ What happens as you work: - **`docs/architecture.md`** — committed as normal plaintext. Travels to every clone and worktree. - **`docs/strategy/roadmap.md`** — the clean filter encrypts it on `git add`, so - the blob in git is age ciphertext; the smudge filter decrypts it on checkout, so - it is plaintext in your working tree. Grant a teammate with + the blob in git is age ciphertext. On Linux and macOS the smudge filter decrypts + it on checkout; on Windows checkout keeps ciphertext and `doctier unlock` + writes the protected plaintext. Grant a teammate with `doctier grant "$(cat their_key.pub)"` and it is re-encrypted to include them. - **`feature-x.prd.md`** — committed as plaintext and reviewed inside the PR. When the PR merges, the `post-merge` hook (or CI) runs `doctier gc --trigger pr-merge`, @@ -340,8 +345,9 @@ separate, deliberate grant — see [docs/agents.md](docs/agents.md). a GUI git client's PATH lacks the install dir (e.g. `~/.local/bin`) — checkouts and adds touching private files fail with git's opaque "external filter ... failed". Fix the client's PATH, or temporarily `git config filter.doctier.required false`. -- **Windows requires Git for Windows.** Native Windows builds, filters, hooks, - encryption and owner-only plaintext ACLs are covered in CI. WSL remains a +- **x64 Windows requires Git for Windows.** Native Windows builds, filters, + hooks, secure checkout and owner-only plaintext ACLs are covered in CI. + Windows ARM64 is not published until native validation exists. WSL remains a separate Linux environment and uses the Linux binary. Encryption is age-only by design (a separate private-repo backend is an explicit diff --git a/cmd/filter.go b/cmd/filter.go index 44203ed..ebce548 100644 --- a/cmd/filter.go +++ b/cmd/filter.go @@ -4,6 +4,7 @@ import ( "fmt" "io" "os" + "runtime" "github.com/rubenglez/doctier/internal/agex" "github.com/rubenglez/doctier/internal/config" @@ -123,6 +124,14 @@ func smudge(file string, ciphertext []byte) ([]byte, error) { // Never encrypted (e.g. added before the filter was configured). return ciphertext, nil } + if runtime.GOOS == "windows" { + // Git owns the smudge destination and creates it with inherited access + // before this process can return any bytes. Emitting plaintext here would + // therefore bypass the owner-only DACL boundary. Keep checkout encrypted; + // unlock owns the destination and can protect it before writing plaintext. + fmt.Fprintf(os.Stderr, "doctier: %s left encrypted on Windows; run `doctier unlock` to decrypt it securely\n", file) + return ciphertext, nil + } // Fail open — emit ciphertext rather than failing the checkout — but never // silently: a passphrase-protected or missing key would otherwise degrade // with no signal at all. git relays filter stderr to the user. diff --git a/cmd/filter_test.go b/cmd/filter_test.go index 8ee89e2..f62c3d8 100644 --- a/cmd/filter_test.go +++ b/cmd/filter_test.go @@ -6,6 +6,7 @@ import ( "encoding/pem" "os" "path/filepath" + "runtime" "testing" "filippo.io/age" @@ -138,6 +139,12 @@ func TestCleanSmudgeRoundTrip(t *testing.T) { if err != nil { t.Fatalf("smudge: %v", err) } + if runtime.GOOS == "windows" { + if !agex.ValidCiphertext(got) { + t.Fatal("Windows smudge must keep ciphertext for secure unlock") + } + return + } if string(got) != string(plaintext) { t.Fatalf("round-trip mismatch: got %q want %q", got, plaintext) } diff --git a/cmd/permissions_windows_test.go b/cmd/permissions_windows_test.go index 9afa7bc..af47fdb 100644 --- a/cmd/permissions_windows_test.go +++ b/cmd/permissions_windows_test.go @@ -3,12 +3,71 @@ package cmd import ( + "os" + "path/filepath" "testing" "unsafe" + "filippo.io/age" + "filippo.io/age/agessh" "golang.org/x/sys/windows" + + "github.com/rubenglez/doctier/internal/agex" ) +func TestWindowsSmudgeLeavesCiphertextForSecureUnlock(t *testing.T) { + privPEM, pubLine := keyPair(t) + recip, err := agessh.ParseRecipient(pubLine) + if err != nil { + t.Fatal(err) + } + ct, err := agex.Encrypt([]byte("secret\n"), []age.Recipient{recip}) + if err != nil { + t.Fatal(err) + } + t.Setenv("DOCTIER_SSH_KEY", "") + t.Setenv("DOCTIER_IDENTITY", string(privPEM)) + + got, err := smudge("secret/doc.md", ct) + if err != nil { + t.Fatalf("smudge: %v", err) + } + if !agex.ValidCiphertext(got) { + t.Fatal("Windows smudge must leave ciphertext for doctier unlock to write with an owner-only DACL") + } +} + +func TestUnlockHardensExistingPlaintextWithoutClobberingIt(t *testing.T) { + root := initRepo(t, privManifest) + privPEM, pubLine := keyPair(t) + write(t, root, ".doctier/recipients.txt", pubLine+"\n") + recip, err := agessh.ParseRecipient(pubLine) + if err != nil { + t.Fatal(err) + } + ct, err := agex.Encrypt([]byte("committed\n"), []age.Recipient{recip}) + if err != nil { + t.Fatal(err) + } + write(t, root, "secret/doc.md", string(ct)) + git(t, root, "add", "-A") + write(t, root, "secret/doc.md", "uncommitted work\n") + + t.Setenv("DOCTIER_SSH_KEY", "") + t.Setenv("DOCTIER_IDENTITY", string(privPEM)) + if err := runUnlock(nil); err != nil { + t.Fatalf("unlock: %v", err) + } + got, err := os.ReadFile(filepath.Join(root, "secret/doc.md")) + if err != nil { + t.Fatal(err) + } + if string(got) != "uncommitted work\n" { + t.Fatalf("unlock overwrote plaintext edits, got %q", got) + } + assertOwnerOnlyPermissions(t, filepath.Join(root, "secret/doc.md")) +} + func assertOwnerOnlyPermissions(t *testing.T, path string) { t.Helper() sd, err := windows.GetNamedSecurityInfo( diff --git a/cmd/unlock.go b/cmd/unlock.go index d0365b8..5262407 100644 --- a/cmd/unlock.go +++ b/cmd/unlock.go @@ -56,6 +56,11 @@ plaintext in the working tree are left untouched.`) // uncommitted edits (an earlier unlock or a smudged checkout, then work). // Overwriting it with the index version would silently destroy that work. if cur, err := os.ReadFile(dest); err == nil && !agex.IsEncrypted(cur) { + // Do not overwrite uncommitted plaintext, but repair permissions left + // by older Windows versions that decrypted during smudge. + if err := restrictToCurrentUser(dest); err != nil { + return fmt.Errorf("protect existing plaintext %s: %w", f, err) + } kept++ continue } From b95a1f278a668fa16dbeaa8dd58b6ad130913e0f Mon Sep 17 00:00:00 2001 From: RubenGlez Date: Fri, 7 Aug 2026 00:35:28 +0200 Subject: [PATCH 03/11] ci: allow manual validation --- .github/workflows/ci.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 599fbfe..18997f6 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -4,6 +4,7 @@ on: push: branches: ["**"] pull_request: + workflow_dispatch: permissions: contents: read From b8085f1160b2a473295a014f3227997aa2f5f585 Mon Sep 17 00:00:00 2001 From: RubenGlez Date: Fri, 7 Aug 2026 00:38:15 +0200 Subject: [PATCH 04/11] ci: accept expected hook rejection --- .github/workflows/ci.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 18997f6..6619a32 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -77,6 +77,7 @@ jobs: throw 'pre-commit hook did not reject an unclassified document' } Write-Host "pre-commit hook rejected the invalid commit (exit $commitExit)" + $global:LASTEXITCODE = 0 } finally { Pop-Location } From d3120f1bff173cf193d662b55ddaed23b385133c Mon Sep 17 00:00:00 2001 From: RubenGlez Date: Fri, 7 Aug 2026 00:40:38 +0200 Subject: [PATCH 05/11] ci: generate unencrypted Windows test key --- .github/workflows/ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 6619a32..68861fc 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -90,7 +90,7 @@ jobs: $bin = Join-Path $env:RUNNER_TEMP 'doctier-bin' $env:PATH = "$bin;$env:PATH" $key = Join-Path $env:RUNNER_TEMP 'doctier-test-key' - ssh-keygen -q -t ed25519 -N '""' -f $key + ssh-keygen -q -t ed25519 -N '' -f $key $env:DOCTIER_SSH_KEY = $key $source = Join-Path $env:RUNNER_TEMP 'secure-source' From a9872a471ac0e8ba697a3c1f470e2e4971547fca Mon Sep 17 00:00:00 2001 From: RubenGlez Date: Fri, 7 Aug 2026 08:29:05 +0200 Subject: [PATCH 06/11] fix: protect Windows merge plaintext --- .github/workflows/ci.yml | 34 ++++++++++++++++++++++++++++++++++ README.md | 6 ++++-- cmd/merge.go | 10 +++++++--- cmd/merge_test.go | 1 + 4 files changed, 46 insertions(+), 5 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 68861fc..f1a88ba 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -135,6 +135,40 @@ jobs: if ((Get-Content secret/plan.md -Raw).Trim() -ne 'TOP SECRET') { throw 'doctier unlock did not materialize the expected plaintext' } + + git switch -q -c merge-other + Set-Content secret/plan.md 'THEIRS' + git add secret/plan.md + git commit -q -m 'edit private document on other branch' + git switch -q main + doctier unlock + Set-Content secret/plan.md 'OURS' + git add secret/plan.md + git commit -q -m 'edit private document on main' + $ErrorActionPreference = 'Continue' + git merge merge-other + $mergeExit = $LASTEXITCODE + $ErrorActionPreference = 'Stop' + if ($mergeExit -eq 0) { + throw 'private merge unexpectedly resolved without a conflict' + } + $global:LASTEXITCODE = 0 + if ((Get-Content secret/plan.md -Raw) -notmatch '<<<<<<< ours') { + throw 'private merge did not materialize plaintext conflict markers' + } + $acl = Get-Acl secret/plan.md + if (-not $acl.AreAccessRulesProtected) { + throw 'private merge conflict inherited access rules' + } + $rules = @($acl.Access) + if ($rules.Count -ne 1) { + throw "private merge conflict has $($rules.Count) access rules; expected one current-user rule" + } + $currentSid = [System.Security.Principal.WindowsIdentity]::GetCurrent().User + $ruleSid = $rules[0].IdentityReference.Translate([System.Security.Principal.SecurityIdentifier]) + if (-not $ruleSid.Equals($currentSid)) { + throw "private merge conflict grants $ruleSid; expected current user $currentSid" + } } finally { Pop-Location } diff --git a/README.md b/README.md index fd184b4..cdf31bf 100644 --- a/README.md +++ b/README.md @@ -317,8 +317,10 @@ separate, deliberate grant — see [docs/agents.md](docs/agents.md). randomized, so two branches touching the same private doc always collide; the `merge.doctier` driver (wired by `init`) decrypts both sides, 3-way merges the plaintext and re-encrypts the result. Real conflicts appear as plaintext - markers in the working tree (the index keeps ciphertext). On a keyless machine - the driver reports a conflict and tells you how to keep one side + markers in the working tree (the index keeps ciphertext); on Windows the + temporary plaintext and conflict output use the same owner-only DACL boundary + as `doctier unlock`. On a keyless machine the driver reports a conflict and + tells you how to keep one side (`git checkout --ours/--theirs`). - age has no authenticated associated data: encrypted blobs are not bound to their path or version, so a writer without keys can swap or roll back diff --git a/cmd/merge.go b/cmd/merge.go index 80916a4..083cd74 100644 --- a/cmd/merge.go +++ b/cmd/merge.go @@ -92,8 +92,10 @@ func runMerge(args []string) error { } if conflicted { // Only the worktree receives this; the index keeps the three encrypted - // stages, so plaintext markers here leak nothing into git. - if err := os.WriteFile(current, merged, 0o600); err != nil { + // stages, so plaintext markers here leak nothing into git. The merge + // result is still sensitive plaintext on disk, so protect %A before + // writing it; Git uses that file as the worktree result. + if err := writeOwnerOnly(current, merged); err != nil { return err } return conflictErr(path) @@ -127,7 +129,9 @@ func merge3(contents [3][]byte) (merged []byte, conflicted bool, err error) { files := [3]string{filepath.Join(tmp, "base"), filepath.Join(tmp, "ours"), filepath.Join(tmp, "theirs")} for i, f := range files { - if err := os.WriteFile(f, contents[i], 0o600); err != nil { + // Encrypted sides have already been decrypted before merge3. Apply the + // platform security boundary before any plaintext reaches these files. + if err := writeOwnerOnly(f, contents[i]); err != nil { return nil, false, err } } diff --git a/cmd/merge_test.go b/cmd/merge_test.go index 1324d7d..0b04850 100644 --- a/cmd/merge_test.go +++ b/cmd/merge_test.go @@ -96,6 +96,7 @@ func TestMergeDriverLeavesPlaintextConflictMarkers(t *testing.T) { if agex.IsEncrypted(got) { t.Fatal("conflict output must be plaintext, not armor") } + assertOwnerOnlyPermissions(t, a) } // Without a key the driver must fail (conflict) with instructions and leave From d91c869e5dc1975edc316785eb1462919cb103d4 Mon Sep 17 00:00:00 2001 From: RubenGlez Date: Fri, 7 Aug 2026 08:32:10 +0200 Subject: [PATCH 07/11] ci: fail on native command errors --- .github/workflows/ci.yml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f1a88ba..5a33968 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -55,6 +55,7 @@ jobs: shell: pwsh run: | $ErrorActionPreference = 'Stop' + $PSNativeCommandUseErrorActionPreference = $true $bin = Join-Path $env:RUNNER_TEMP 'doctier-bin' New-Item -ItemType Directory -Force $bin | Out-Null go build -o (Join-Path $bin 'doctier.exe') . @@ -87,6 +88,7 @@ jobs: shell: pwsh run: | $ErrorActionPreference = 'Stop' + $PSNativeCommandUseErrorActionPreference = $true $bin = Join-Path $env:RUNNER_TEMP 'doctier-bin' $env:PATH = "$bin;$env:PATH" $key = Join-Path $env:RUNNER_TEMP 'doctier-test-key' @@ -120,6 +122,8 @@ jobs: $clone = Join-Path $env:RUNNER_TEMP 'secure-clone' git clone -q $source $clone + git -C $clone config user.name 'doctier-ci' + git -C $clone config user.email 'doctier-ci@example.invalid' Push-Location $clone try { doctier init From 5c1c0e2da3bce11e72c5c7acfd86b44bfd5033cc Mon Sep 17 00:00:00 2001 From: RubenGlez Date: Fri, 7 Aug 2026 08:37:15 +0200 Subject: [PATCH 08/11] fix: keep Windows merge conflicts encrypted --- .github/workflows/ci.yml | 18 +++++++++++------- README.md | 6 +++--- cmd/merge.go | 27 ++++++++++++++++++++++++--- 3 files changed, 38 insertions(+), 13 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 5a33968..2c615f3 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -153,13 +153,17 @@ jobs: git merge merge-other $mergeExit = $LASTEXITCODE $ErrorActionPreference = 'Stop' - if ($mergeExit -eq 0) { - throw 'private merge unexpectedly resolved without a conflict' - } - $global:LASTEXITCODE = 0 - if ((Get-Content secret/plan.md -Raw) -notmatch '<<<<<<< ours') { - throw 'private merge did not materialize plaintext conflict markers' - } + if ($mergeExit -eq 0) { + throw 'private merge unexpectedly resolved without a conflict' + } + $global:LASTEXITCODE = 0 + if ((Get-Content secret/plan.md -Raw) -notmatch 'BEGIN AGE ENCRYPTED FILE') { + throw 'private merge materialized plaintext before an owner-only DACL could be applied' + } + doctier unlock + if ((Get-Content secret/plan.md -Raw) -notmatch '<<<<<<< ours') { + throw 'private merge did not materialize plaintext conflict markers' + } $acl = Get-Acl secret/plan.md if (-not $acl.AreAccessRulesProtected) { throw 'private merge conflict inherited access rules' diff --git a/README.md b/README.md index cdf31bf..3c93c91 100644 --- a/README.md +++ b/README.md @@ -317,9 +317,9 @@ separate, deliberate grant — see [docs/agents.md](docs/agents.md). randomized, so two branches touching the same private doc always collide; the `merge.doctier` driver (wired by `init`) decrypts both sides, 3-way merges the plaintext and re-encrypts the result. Real conflicts appear as plaintext - markers in the working tree (the index keeps ciphertext); on Windows the - temporary plaintext and conflict output use the same owner-only DACL boundary - as `doctier unlock`. On a keyless machine the driver reports a conflict and + markers in the working tree (the index keeps ciphertext). On Windows the + driver keeps conflict output encrypted until `doctier unlock` materializes + the markers behind an owner-only DACL. On a keyless machine it reports a conflict and tells you how to keep one side (`git checkout --ours/--theirs`). - age has no authenticated associated data: encrypted blobs are not bound to diff --git a/cmd/merge.go b/cmd/merge.go index 083cd74..abb13dc 100644 --- a/cmd/merge.go +++ b/cmd/merge.go @@ -5,6 +5,7 @@ import ( "os" "os/exec" "path/filepath" + "runtime" "github.com/rubenglez/doctier/internal/agex" ) @@ -20,9 +21,10 @@ import ( // pre-commit hook guards a merge commit), so the result of a private path // must be re-encrypted before it is handed back — writing plaintext would // store a cleartext blob in the merge commit. On a conflict git stages the -// three original blobs and only the worktree gets the output, so plaintext -// conflict markers are correct there: the user resolves them and the clean -// filter re-encrypts on git add. +// three original blobs and only the worktree gets the output. Linux and macOS +// receive plaintext conflict markers directly. Windows receives encrypted +// markers and materializes them safely through `doctier unlock`; after the user +// resolves them, the clean filter re-encrypts on git add. // // Without a usable key the driver cannot merge; it leaves the current side in // place and exits non-zero (a conflict for git) with instructions. @@ -91,6 +93,25 @@ func runMerge(args []string) error { return err } if conflicted { + if private && runtime.GOOS == "windows" { + // Git for Windows copies the merge driver's temporary %A output + // into the worktree after the driver exits. That copy inherits the + // directory DACL, so returning plaintext here would bypass the + // owner-only boundary. Keep the conflict encrypted until unlock can + // protect the real worktree path before writing plaintext to it. + recipients, err := agex.LoadRecipients(recipientsPath(m, root)) + if err != nil { + return fmt.Errorf("merge: cannot encrypt the conflicted %s: %w", path, err) + } + ct, err := agex.Encrypt(merged, recipients) + if err != nil { + return fmt.Errorf("merge: encrypt conflicted %s: %w", path, err) + } + if err := os.WriteFile(current, ct, 0o600); err != nil { + return err + } + return fmt.Errorf("merge: conflicts in %s — run `doctier unlock` to materialize protected plaintext conflict markers, resolve them, then git add", path) + } // Only the worktree receives this; the index keeps the three encrypted // stages, so plaintext markers here leak nothing into git. The merge // result is still sensitive plaintext on disk, so protect %A before From d8265a0c93dfc4d1b3e042514c506c3479db6c9c Mon Sep 17 00:00:00 2001 From: RubenGlez Date: Fri, 7 Aug 2026 08:39:29 +0200 Subject: [PATCH 09/11] test: cover encrypted Windows merge conflicts --- cmd/merge_test.go | 32 ++++++++++++++++++++++++++------ 1 file changed, 26 insertions(+), 6 deletions(-) diff --git a/cmd/merge_test.go b/cmd/merge_test.go index 0b04850..12388bc 100644 --- a/cmd/merge_test.go +++ b/cmd/merge_test.go @@ -3,6 +3,7 @@ package cmd import ( "os" "path/filepath" + "runtime" "strings" "testing" @@ -73,9 +74,10 @@ func TestMergeDriverMergesEncryptedSidesCleanly(t *testing.T) { } } -// Real conflicts surface as PLAINTEXT conflict markers plus a non-zero exit, -// not interleaved base64 armor. -func TestMergeDriverLeavesPlaintextConflictMarkers(t *testing.T) { +// Real conflicts return a non-zero exit and resolvable plaintext markers. On +// Windows the driver encrypts those markers until unlock can protect the real +// worktree path; other platforms can return them directly. +func TestMergeDriverProducesResolvableConflictMarkers(t *testing.T) { root := initRepo(t, privManifest) o, a, b, privPEM := mergeFixture(t, root, "line1\n", "line1 ours\n", "line1 theirs\n") @@ -90,13 +92,31 @@ func TestMergeDriverLeavesPlaintextConflictMarkers(t *testing.T) { if readErr != nil { t.Fatal(readErr) } + if runtime.GOOS == "windows" { + if !agex.ValidCiphertext(got) { + t.Fatalf("Windows conflict output must stay encrypted until unlock, got:\n%s", got) + } + if !strings.Contains(err.Error(), "doctier unlock") { + t.Fatalf("Windows conflict error must explain how to reveal markers, got: %v", err) + } + id, loadErr := agex.LoadIdentity("") + if loadErr != nil { + t.Fatal(loadErr) + } + got, readErr = agex.Decrypt(got, id) + if readErr != nil { + t.Fatal(readErr) + } + } if !strings.Contains(string(got), "<<<<<<< ours") || !strings.Contains(string(got), ">>>>>>> theirs") { - t.Fatalf("expected plaintext conflict markers, got:\n%s", got) + t.Fatalf("expected resolvable conflict markers, got:\n%s", got) } - if agex.IsEncrypted(got) { + if runtime.GOOS != "windows" && agex.IsEncrypted(got) { t.Fatal("conflict output must be plaintext, not armor") } - assertOwnerOnlyPermissions(t, a) + if runtime.GOOS != "windows" { + assertOwnerOnlyPermissions(t, a) + } } // Without a key the driver must fail (conflict) with instructions and leave From f12044a2acc1395888433233c652ceb111bcf904 Mon Sep 17 00:00:00 2001 From: RubenGlez Date: Fri, 7 Aug 2026 08:42:59 +0200 Subject: [PATCH 10/11] fix: unlock encrypted merge conflicts --- cmd/permissions_windows_test.go | 57 +++++++++++++++++++++++++++++++++ cmd/unlock.go | 13 ++++++-- 2 files changed, 67 insertions(+), 3 deletions(-) diff --git a/cmd/permissions_windows_test.go b/cmd/permissions_windows_test.go index af47fdb..9176a56 100644 --- a/cmd/permissions_windows_test.go +++ b/cmd/permissions_windows_test.go @@ -3,8 +3,11 @@ package cmd import ( + "fmt" "os" + "os/exec" "path/filepath" + "strings" "testing" "unsafe" @@ -68,6 +71,60 @@ func TestUnlockHardensExistingPlaintextWithoutClobberingIt(t *testing.T) { assertOwnerOnlyPermissions(t, filepath.Join(root, "secret/doc.md")) } +func TestUnlockDecryptsEncryptedMergeConflictWithoutStageZero(t *testing.T) { + root := initRepo(t, privManifest) + o, a, b, privPEM := mergeFixture(t, root, + "line1\n", "line1 ours\n", "line1 theirs\n") + stages := [3]string{ + gitOut(t, root, "hash-object", "-w", "--no-filters", o), + gitOut(t, root, "hash-object", "-w", "--no-filters", a), + gitOut(t, root, "hash-object", "-w", "--no-filters", b), + } + t.Setenv("DOCTIER_SSH_KEY", "") + t.Setenv("DOCTIER_IDENTITY", string(privPEM)) + + if err := runMerge([]string{o, a, b, "secret/doc.md"}); err == nil { + t.Fatal("conflicting merge must return an error") + } + conflictCiphertext, err := os.ReadFile(a) + if err != nil { + t.Fatal(err) + } + if !agex.ValidCiphertext(conflictCiphertext) { + t.Fatal("Windows merge conflict must remain encrypted before unlock") + } + dest := filepath.Join(root, "secret", "doc.md") + if err := os.MkdirAll(filepath.Dir(dest), 0o755); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(dest, conflictCiphertext, 0o600); err != nil { + t.Fatal(err) + } + + var indexInfo strings.Builder + for i, sha := range stages { + fmt.Fprintf(&indexInfo, "100644 %s %d\tsecret/doc.md\n", sha, i+1) + } + cmd := exec.Command("git", "update-index", "--index-info") + cmd.Dir = root + cmd.Stdin = strings.NewReader(indexInfo.String()) + if out, err := cmd.CombinedOutput(); err != nil { + t.Fatalf("create unmerged index: %v\n%s", err, out) + } + + if err := runUnlock(nil); err != nil { + t.Fatalf("unlock merge conflict: %v", err) + } + got, err := os.ReadFile(dest) + if err != nil { + t.Fatal(err) + } + if !strings.Contains(string(got), "<<<<<<< ours") || !strings.Contains(string(got), ">>>>>>> theirs") { + t.Fatalf("expected plaintext conflict markers after unlock, got:\n%s", got) + } + assertOwnerOnlyPermissions(t, dest) +} + func assertOwnerOnlyPermissions(t *testing.T, path string) { t.Helper() sd, err := windows.GetNamedSecurityInfo( diff --git a/cmd/unlock.go b/cmd/unlock.go index 5262407..5492264 100644 --- a/cmd/unlock.go +++ b/cmd/unlock.go @@ -17,8 +17,9 @@ import ( // - a headless/CI/agent run, where the key arrives via $DOCTIER_IDENTITY and // there is no interactive checkout at all. // -// It reads each file's ciphertext from the index (which always holds the -// encrypted blob) and writes plaintext to disk. +// It normally reads each file's ciphertext from the index. During a merge +// conflict the index has three stages instead of one canonical blob, so it +// decrypts the worktree ciphertext produced by the merge driver instead. func runUnlock(args []string) error { fs := newFlagSet("unlock", `usage: doctier unlock @@ -66,7 +67,13 @@ plaintext in the working tree are left untouched.`) } blob, err := gitx.StagedBlob(f) if err != nil { - continue + // An unmerged path has no stage-0 blob. On Windows the merge driver + // deliberately leaves its conflict markers encrypted in the worktree + // so this command can protect the final path before decrypting it. + blob, err = os.ReadFile(dest) + if err != nil { + continue + } } if !agex.IsEncrypted(blob) { continue // already plaintext in the index (added before the filter) From 9d28cd0f4450f201d6b54aa6e25aaca20928f9a8 Mon Sep 17 00:00:00 2001 From: RubenGlez Date: Fri, 7 Aug 2026 08:46:31 +0200 Subject: [PATCH 11/11] docs: record native Windows support --- .harness/adr/0001-age-in-place-encryption.md | 199 +-- .../0008-reuse-ssh-keys-as-age-recipients.md | 150 +-- ...0013-windows-owner-only-materialization.md | 65 + .harness/engineering/architecture.md | 1134 +++++++++-------- .../features/windows-x64-support.md | 53 + .harness/product/announcements-2026-08.md | 38 + .harness/product/roadmap.md | 315 ++--- .harness/qa/report.md | 338 ++--- AGENTS.md | 3 + cmd/merge.go | 2 +- 10 files changed, 1256 insertions(+), 1041 deletions(-) create mode 100644 .harness/adr/0013-windows-owner-only-materialization.md create mode 100644 .harness/engineering/features/windows-x64-support.md create mode 100644 .harness/product/announcements-2026-08.md diff --git a/.harness/adr/0001-age-in-place-encryption.md b/.harness/adr/0001-age-in-place-encryption.md index 5c1581b..977c63c 100644 --- a/.harness/adr/0001-age-in-place-encryption.md +++ b/.harness/adr/0001-age-in-place-encryption.md @@ -1,100 +1,103 @@ -----BEGIN AGE ENCRYPTED FILE----- -YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IHNzaC1lZDI1NTE5IExRMGNCZyBiLzk5 -WGw0MkVUSHRlYUhPMjZLbkd2TUJJWTA2WXZIaGZCZzdxeEZGL3djClA2dEprbzFJ -cVdpUnFRemcwY3BibHRyNmRlM0hic0hsZ3k1a3BzbmRTemsKLS0tIDcrTDNzQ1FT -WTFjMkNEV3ZLREV4Y1U0SHhhUEVlVi9JSXUraXVlYjZWVmMKcqiKwvyWl0pTbZ0n -qZEQulzDjbHSF2UdCiCZ0YPFCxEFy9Sg5KYkZkDWure0msqAlj6kLm9l+uIlM7hQ -SxHIEGBjQ4T34slddPFcaGNxAft+lS1YsqDdaLQTqptLpJxxdhnIeTlIlM9BwRir -sqV6XAtF35XDZ5VrvitW2K8CsCyJ+5WcRrYnUVHwYmKNLItZsAyw8iOKTAeJ9vfM -Pyber9D1wlyG9BEf6QvrUaUondBOYxbk9fcUemLk+S91vcgUlHIkTQaEbD3qbFbb -NMR+O1+fhF3hLfuhYkxfoK44tfhFh5gsEBvZDvbOvJk/2IN6GuHxVHNzwLk46Fz7 -cFzCpqIz3+2Jxu6cAAV9Lq2AfnOi/eNJI4zSmB2fuLzK370iZzFB4lWEZ0QFcZUM -WUOMltkfJefWTCx2e08o4FCk15xX6pcucaAv/hy6AAAtYFM6xnsx4k8jGbAmLg6y -glTy2LnHKzgf8wZfJV4EsScZ0xDA9RW7T5hlOj/2I3nXRqbflu5kQrYgKmD6K//g -EbD5wPZ8qJHrA3eKA0n1tHYquQBVQ/EFWkUX7Nd5i6IvLL+Xl6ewDezmuaVy5gY6 -6GmjtwiR6ec7unzHSvTLFuem3jaF9pNuLlAyB3Yn9brPx/KiJEV+CHggvZGmV3TD -S/Jm/gylYCJNSivZFxOLLQOJimbHV58J+U68bCGPydN1Zq1IHLzfL//9zx+RLXDB -FSmwRXwFqphZ8kzPnhR0HY7Gsgff8t4J0WbV52H6hSbUj8G5juViBsR7WGaQvpgp -xTF+EZo3tpqCEy+EFKnkJTDDWID7D4VnF7vLCtj4hpTKV3gX7jPNzqfx1pHkiBKL -AdV0/reVy77Te0foxeVy8HHn+S7am4clvS1lZSJCul10PLcPkXpeCBZAM8+YAhvo -dQqRiJnYl5FlvJBkOBZ1tyK4HQhgv0ARl2oblIDf8/rc8Xi+MKYhDCq+Vpg43vqj -/sDmhNgStafNBC7GdpUfy3wJaJro9ZoebIwq45cuCxN276knMigVeMExqQfqnc0X -3nbBtRso9+A6n6chUKCno/5IJSU//NLyegonCsXDZbnLH7pK18ZJE7BS6icChOOX -Itdlqdq9QLoRouf9t2HlY+juSXaOHMQotEAAfUANxI663Kbgj10ESoaep0whRwJN -T4RvJZ5+HSyDV3tD7k+N98qlh5LBn97XHWg1LdLDb941sSJnRMTckHey2UOLg4GP -BEbCK99a3C8gHW5BT/qYHme6Max1TqBjls3d5ZtHmscND6uPDSRwm76yWRJQh3mV -KJc/ApUiBx7w0rM09H3LE8JYOfBX+gq4HWjiLlEjWoCM2eenBmzo4C9s193/7ZnH -9XOIMiU5ljDdK0THkwsnrvG1f0G4mCsD3tAklJ3dTF3BoZCubodY1bb0xZ3XLj/k -a5wrt3yKwFKR/ljpuo7SilzrNnm0N6sH6MKRCifripnFvmg7QL6WyqYLtRxqZoux -m2sR6/eIfg0JNCEaKDW5kP3/cp6CF4Fq1WcPDfMRWdMX1FAyABOvcEvhudUP8Q2b -wJjxvfhkETub+CqtXYFFvCmbYhyxI+IYdvomZ3csMk62P5S8aCfQHNHKFOQj70o5 -cCXLjj9TEYg3s8awjJUZ/vc5/5fYh6FWQkJlBVsDE03rPWPZe7jXfwQp3Di5EcvO -9nxel2bqOm9BdJweGzVdgURoH5JQYx9uF0SWCavirPzm8zae1VXvIkOalWJAu9U7 -F+8UjVN88SITew26tF/Xqc11bgMtUqwpvIolnQB2j1I2w2azVWdXV0t2jdVnaViS -5tRTjnjhgZDZSKgihsr5qoM/T7OlnVPlQfX+S7dFxd4f7dN1vd9Uc+Mx2AU/4Wup -mOqHyXa/GtQW5m6EmbK4FlTtWBtVko99CH4WL+ZptSCdiyRHFQH5RTC0YxT7e7k5 -qwnD9m6OKNkaAZQn+VB0y3FjacCHeXOKhmdefjn16i/X0enjq8WmyHBXDkCXXmlb -UpqOi13TXlMHyYIOAmjULUmFo/hBN1Yl3m/orw0nQ4opBbwe1glBXtK3nV/swwK9 -8fssExXWGlZtr9u9Sq/AAkhuYC38P5ARYf9dPPu/YtyASe5R78TaPcxzPefOTiCW -4cB/3Kx6YFW7fqE3HeeDIni67qx+jugXVRt6XT/UzDPW06qefZVjHdKMCW0urWV4 -J862/KUbno977GEUwFZle3GuHYstYuD1IuvzwCD24fJxqx3inBe8eE0ZBSCHN/Zu -eZzBr/Ml+Y1nbexNorsAOvy6CDFSzAJKbMWFBPcMhLvyAsZDYZvgz2Dt/zBNaFVY -HJzJQRRxWcYofPGvGZjgUN7b231fHePh/vSLMpy+EUHGiDTmNbh73+MtJGunI/HU -LZb8byTai0D/rBykzsvWreiC/CNVuD+SO7XbxtZS0zRBCVZnZh7Dm0nrGcBcTUOW -G+Xslqu4f/NHODTaYCr1OUZ7yzz5s435qBylQ1SzkNlVKcD7MVlkKMTkhMporrPh -U1xrROk6scN90QfIzvdiS4Z64KfUiVuDs8ZXHF7LmdlS4pEuBXL0T6L9TPOKckgo -1Eunx59CnTgPBvb1JBHK+YOooK0p12zgKQE3K4atnPydGT0GtVmt+2d4oj0D05/y -toYa2CKVvEmI/ahtLuuGU0eHXlv6s6vxIkIbAHoWtesJKu5+kFXuXZPGAxJ/9mzU -q65UgK7BRRG2zEJKDah77vtAHbMAcpPKy5mKizAUHD6L6VCAN44c+laEuNfMYSVz -ZePR6yWdG/StmlVgek0Srqy/0vSHxcjq6ky5xY2XnUHrkNlaq8yLRs98BmyPjSbV -eae+eXPbudOvpbc5UcweMPOzVNmFuICVRHTW310EHsgRxLMbHkHyRWFVkUzkwIGw -Fnv6YPQc2GCR6lNJBkPIpQKZ90wMiHwPxaVQoMjEwTjssCRT2RdHWyYGvGopXPma -Y8Dd7ZfIrZu7vn4kzlZYWmyjYacAtG267AFouThXT1WgAicNNF7glfjduAYRmsdg -KLCD+6tZ4zmaneHkLP5CcSAc90XdMLAxo3UYLJXSeVT3q1NrLU9cqODT8DQ/jXJe -eyU1enoOtkbHA7VRU9OYSHjj0g7LmUjsKE3c3qqb86jKExXZuw39/w+mhCV/IZCG -Nyd0ZTij71mYo6wGyBcs+03bo611IY1zoWkVHivrxtV5pOo9Hfm6WX48U/q+hy6y -b998Jvz/AoQ7KrUSaeQ9M+q0KQ0wM+F4YgL4LDeJPXO/F3/B7O6zOL0mywU8/CKD -y/dsvCAF0LDle5zrUm1TruB+9cTIoG0JBYQA7IZ8LCoXaBFLyoymM1hBE9Kvzy8u -LSGi8N1vi3LmdMmV/L9g845fM6RE7Dq/rWYq9fvg7Ie0Jg78tDgUV51y4jEMeMSw -7nj+Zm52Vd5g0vly8D6yGeOuXfb26mBJCB7fTFz06eVQvkv5FQbU+9pAO90ibVaQ -rVdaYyZ7ox6+T5B5J42rxwfT0MQ0QT83kesag3uOYisuRyMBTKdZNd8UunIlXFcX -0nX7Co1ObpNEeuh2IMfAjwJfVVkKUPq1XkXbe5Bv2hJo1cecACFl7H7a5D83ilPL -XndbURoX5lBy7ke7+bLdPZHApFOQs2wGp/kIt/blDo18RYcouuZ06+Jm5cHUvr2M -T+v+B76I7Qn9xsbaAeAdyzQHlw+NgXoroiwkmtjmlXgyNcZFPs/lS2tgDw0Se9g0 -GQPe+3H3ktvGFIPU+bdjX4UOIeBHzrYA9enjc+sL9i/SJvB4f6hpGMXPIAYPXXvb -284Q8vRwj7jCwtVGu/8LTY+heiKXfHzCTQ/ds2vWvsDR2R/FA2st6uiBI52MxWLN -AswXVTpw6TsS8TibRuKVWSEIm65RSKmQCkdkkzZWfzfFuADy57n7L1w6JYRYzg9H -ARRsHPrMjXBPK0rdKcchLkPoY5FXvqnyt5WU2yDPEX9KPXdklc0t5zt0RVrvkxMd -+9Vm+8Y2dn7UZrwu5xGSpWi/LfXWvF4K4PUo1C+s5FQcQPe7WFfGgPM7Gw159mB5 -t4CQD9Ky+JZsI2bCHbp73RH2cZ/QIQ8C9UgW/cbob+UdCCgFYX67ztpUoZrDsQ4s -kBzpLWdZ3mFqQCFvPIu7/mHSEZIqvNY2zOsgMJJjz1RmnkQBGw9StiXBEGFdqc5y -98BV1UuaL5uwVzrZAalgFKaW/SjHkhLYhRXT22hKUDWLfSQvaHSZ3K26NNjDuROX -4MAe6fEhczsiVV+5aHlcvdxc/npkfxpBaE1+qAQqpYRthw+puJiSLWZbgCVIinnu -p7jvQgq83Pxwzo8xl8ND+F9W1D3NGvkBOLUhYW/RwuFrCPDRJCLY4Le97vyHrKcR -WwZlfYYQEf40wMfKlkislzMufFawRDpGjN3a1yrMGPZ1GKiewWxKz+h++eCudwYf -xZbaDZu8UZOJi/carMqR2RX07T+YMMgDx/Xfs+lIKIEZzo6iMMl+vgdq3cDDw+Lg -XrsQbRqGOYyQ4+1o3MK2hdB3lFiQfk1ddNH4fTFraQMdIiGCbWdNNa+lrchpx7bl -gusqIqLSS7vpVbH/vMPsgkgAXdOq93YbKHT8hKZZHih/zyQBhb0yOuVryxEepu8g -e8NLkIuAikRGO2imvNqET6XG2fmcbxK6H3TzULzLgzLEseoUFkMsLHCNoUIBxFBr -5169lhZfjmpEyIsU+tWEWdNriyAIET5T2NgaDYqpAvVT4uWQd4yLxMokPKl0f6Yy -R4Y1q2xynq75bDqJLdvMck/KdPOLZoVl8svuorG2VlOgRhmthFd0NDtfGNUwCAzu -unc9rQgQ/11q05g654xGYsWDWMBkCm1vD3dR3kb7MDysWusHMC8Y90q1vFkoPAFt -9CYq6W+5+z01y5givpIjLHv8as7CLxRR7/wdhCe66ijlZLK/9EI4Ev7Pq/9qQS9V -MmmuNAaoy6DK/UfCxl8DqSCqgdTE4O7t9TM2L6fNGoR6NGa+2OLeKpI39llCOPzI -okzSnBhCNxU9J+gcVyClw6Q/m1T9T6VkK8mioH3bP05NjJSCNA56fsnJSt+gGUiT -JlU8FmypQ7hQ19QJOD3SenlRyqPRj2ZiDd0ogPk5S7j9Z4iaqLHQaJvifErFa3iT -isNXvUx5COLaBjKD+EBWAdh+R6fZ2WqdhROogodNMJwBB3Krjsw3A/kufD5vT3SE -VpQXP3Z7ec2ROhEZkPhehADjYWh5u3CTn22gNqBg6RzYGiJtxv+2fPRgbiokYhD7 -ndiI8MV3YJ2wvCzsjMY0skgfneleBJ4emnHNnhFYWz/dMllpdIpzVTmrKBLN812u -stmds3b7M2BuAmJax5ccuOOEhYv/J0pjSwAVaVAuW5fiLgz++NQB/iNnzntYTn0C -axigz4dhWV5/4GpzdoWzKLVcyaeIIlYvNtliUEn7g1p0GfQWKjwstEBllxVDtHjm -O74gDDTAWVFwodx9zLSEy/Su1f/ysQ7rjkIKv1n2eWPnQinu8JkiMSR/+fYCMzqO -f5YJysTaGCUY9bAo7Ao4TxkfxeowEoYpeLNsty+8jWCy1Sv3IPyx9aR//3n8WUPu -x56xDfb19INzgUd+mo1Aw93crLVlGLXi62INlU/vHaj6rH9RHSRvqdKQNRhuUa9L -3RCuh3oNK2mTioj052fIdUHvyOYPqHtx8JHMZYkj6P/4soj/aLqkMiucj5iFji3G -UO4i+Z1fBuOuEesFDXwdVzJicvfL4I+l8IsEgZcgwihB8BFb9tWoxbOFcOF07oJy -8vC1CWxplMllnQMYthq0MkrOSH25TL0pT52zEiY39HdU3NFZELf5oZX3OLLlEnyu -/tthUtOdAu7fJP0aUAKAhdWVNg5/UzGHcBNNTXCxzmBRMQnpES5BzbdHnIIdKov0 -vHLFjwucvJ2oWFNJZke/SMSVo8S7eOie+Caxawcg1rzFKbfF/znl4b6rm+jVX445 -M99VxRf/u4AXVyWbXfKpnghgF8s= +YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IHNzaC1lZDI1NTE5IExRMGNCZyA1allN +emtCYzJzWkR4RXBzNFhUTEwvSy9DNDFqRytXY016STNpUUZzRkcwCkQ0OGdGUUpz +QTRnZ05YOTZ1RERKSU9UQzBFUFNoSU1WRkdGTHdzVnZMYU0KLS0tIGtUQ2NLSG5W +SlI4WjFzN1RETXpERTQydEpvNVZMSFg0Q2xVZXdJWU5abTgKF7A5CKDrEdQMZxo+ +MtjiVFj1QTxk5ljTo592auB4ybIGbbo1BkOUsdYKsu6AZ5+5Yo8UKNqdILD8QTA2 +/WXexOJzoWX+rpEGeI4FQsveM3KIzvCsmqTdnSmbowJAZj0YsbvVHCYmCfzoKU1i +tskle19MvXL85sOIOwW4twNHqCR/87DlfMCIdPhd84qZkFp11hkfcgVaFjYLc4DQ +NK4vjAo65LeV55uYcaMul6HiU1hl/wHS/znT3b1Xi5PHTR+YNp2opiMbfPCeL5du +VVNkBov+GXJnRT9is4/u8DMUP8ZTIyaKIiaP24RD9L9ee83Vf/Itc35sB1EAZhFL +8SvfJkTGuaQ8aXmSSeujLtr6txCPYu+D0+CZHS2mrqpW/BDXQXJH1I9UM9D7s35N +gYy/SBtXrNsqR3XzexjQBcCEU0nl5GtCbl0hu8eoyxs/iSXejFiKRPcf5mY/R1sM +eu5hjz315Y616jJv+j2ASL2yHgwPjAPKk80i78/52yl0dG7EXisgKdPV6gsgp4XH +xHom5nJFGF9w8g9MLFkcaF35Vfv5ZJjx5hjLLNjTYAx3sop9VKS0+xVklagoHTGb +G4agNhJfOyssXHKlheVRjZ4edBfAm59Qt+gLC/26+aZt5p7WUXBolrul/5qidZlG +K+jsF+XtjAwmH6xajjoy2fotumZjrjLmYjyD7AoDJMD61BOsFu8RtlEVml3z/dGG +71awTyp6iK2wI5pnoBO6cSjPB2dSuyQwZLMp2O51VAumbC/XCm5fhbgs+poraaev +g/HPuhYFVuIh6E9/TckDRywxamUT+TJcE25ZUm95JrZQPq10sEAi7J1mkQkvm4Tq +fDFHR6iw//BxV/bFoMKEHWlSIE0oFnqVCGAs6r+gltLi1W0uPx03AgxdsGIcGWpN +DT72VlUZwwIxWlpFevNneyvvwz+UI7CEi5tC+Wmw+jeDyHeSfxStELNtijEOVBwi +mGuxLNZsxMzcaXu2QPpvxpQxTm3t0dSTqu56Am0z5n4wqMm4Hxbd98ttyHxEVf6S +hYcC84SwqBwTYWEaX3BWwpHbnwVqF3t8PP5Syfbk+3WkqI57fI9ULCoioMRS5SZD +c8ZANbrq5GlDNjf0tY72qDwvkwYEmHiyJWP8fXL4NaPx8Lyy3Mzg7zfcWooBRICp +j5TRCNQUaL1o/2wFPDBUBi2u7dIcYYGcoYNe0j0EqxRsfnRapCH7zuqZ8oCfpfLO +Yw/JMacQQI+Izevubgyhr+E9H+3fOsvSJRFK9P68plImrloA1DRRa98UjNCuMtfL +5fOhV95PU3bbQmZ3PU4xsZvDqw41bIY7SM2eytR9K2I5muHLVs2OyDe7lBdtH7mc ++cebHVnfiMIirerMtB+ZdUxRgI+Tw7DIU3Nr7q9ZJTSqTBu+wAZpMv9zT0/oAGU9 +rD57QW8YPCiOZJDmL+QVdUASxTU1LRxxV9nKlz4MHa7xVUJe/Hf7uIKo2BzDj8FL +oXUXHBa9dIZ7oqIWvskdCWLMfmFbdlMylFv+Vp0Mxh7VdJ/qzMr5VBdttyPben19 +yyrG7N/tlxxzrTM3iXYFlqws72fcsK8U7Mn63DIpm8rNLfBqDxpucZ0Bg1msj6yP +hF0VwPLi8WIeZiNdJW4gUr9n7+pMx9YiRv0IS6Fd2q3BxCZA8WiPK/t+CMV/E/JA +lhilrm1/GN+rD5w0o/BsMWwjVNb4l+E7OgO9mWB0ic2XpmLW2SH7sn9fznhrEPRP +BopysBAkM1h2zcUJEvGtLNa882nHeZoJkgPvgxUC2/CSJtRmH2rVBkghdIk9JDfr ++dIamaGnrwSQayQi8mM5x1Gb0xYz77Jl5MlCIz2qTfD5LLwOK5qTAD8ftyVEjQ4N +Hkq1U7kQjs5vp/jHQPl0NBMjptEmgl8RA7nzhWJ6G1Ti4H9nhHdiBwS4gjjy/0nk +HhgAQO3jZ3vmK1HMeeYhIxt/CkojuT4glqwdirzDzUiYMTrgceNI2KXQP7YaXnN+ +EBLAl+7vfpDu8AD/HlVf6KGk1+EXL2jDIkjpzIBGNvYg7GRBA+XDBenvr2on5v3C +3xJ3BQd+P8FRh5V4VAI8NcqRvI5d84dWFH/7Znp2ADa8gywLkKRKAshWjxEF+iJm +SzeYNJgUG5R2imPvbGERos8vGBM79gNNVpneTgA0PBeAk0RYlL4nO+d9z5GNnWSy +96LOorWEAEPFhX3PuO94hQwv3RKvqV51gzIp2TzvUSdkGlk/DKdqvmU0a3wY1xJD +9uL0CxfP9CDw6+RCJv5QYcfNyDE4FGCSw99/DElQfYQrAAMM9OD1BgPp6fyBh4mp +rGHwKkGiEDUdDa87uhV8DmDMhuAcg1AX+B0kC6X2oaJWTUofUKUo6TkKuLI4OQag +hqyGwZiPsETI8r7pTvtWQfIjDzxJkYUy+HCMaSdXNpnkg7thOcw43Fpjzblx+X0a +8xVVH3NUX83V0p7BdFrz2hfmotKkTV0n7r8OfnNUixukt2dHchqSLldrD4J/yLaN +zA7cRnSqKoi/uXha5SAKly8Ro4lOWs4oh2XzJFyc1GsKYOjfjzW8M3pWn2ewF4dj +y7zQMSDD56jG0OXr5k4ZWUCl2lWruvnuYZ76AYaAxfWPhEOgmxgpXBR+PSS5H8Rf +inII6W30KrDfiuzGHrFfGbQjnspBRL+z0QdVLDMSb8eHJ6GRwuIeA+oyDh0hnEXD +FPW5gWtWDlRUrBusTEJXv+zASbHcSmVCIU10nSFYSKsFu7kYneFyv2fd0sOjY7xP +JtGCpF8ed19tPNJaigNyFxL2O/MJ2sUup06er3QhKqHSPJgOYRRK7iO/RQtW6/kx +1i0oJs3wVjK4oWTFJMzlENsRug+8Z9vMd1aSLj+xGWAmzxxrXjVbPGKj4aDKIajd +2fHmsMaAgCPFkxqYJAdcl4CM9j3/sD9wqVkdowC5XP0XYYIbrdts8tfQ2A6eltfT +a1Mz+00ICG/7OyDC+jy+NEcKj0wj5UOLuCqmg3g869Ec22tGnTGSG4vXP84b05/Z +JR4VxjxkdUuZh/OdtV26T/N0JdgjNMvnjXap2GjBvQItcYppi5FjwrZP9mt2Ue21 +tHsW1kjfJPOh+2OXB1ZMWcpELqgKmd/NM/pMxwaB4uqreIc3aNilB7aQqvQcH0x7 +Nce5HA7lKRANuR9qzfB+lc5bJGI9tLU3l4fhqOGwqShOupooAnEFYNPGg+XnZlRk +viWj4oMfdMpxHjC2IioIRi1XxmujvC5wKJ2JcfxbZa1gSXWBv+/MvJngD893AXiB +slFyS8LNjTDFL6vcB+wY9Ei8k6S6PmZGMr/6zNL561UnUuBvRFPP/xTW4vDMpHTc +/NsXSLugtKjIm4ldxiSsYdWlpy8nFE1Do2KV5dQFguJZpP70N+Yv49kf4vsAcsVW +H3S+FMdWIHN8p/hDJ36QsU/5DvrzVZsq5NDpk2R06LQAeh8h8ozgDZMcbgbHLgnZ +6euVtiZSf725Ip1KpQrd1YEbg2ScGW0KSHwkJrJ40cZD+Pekif9UPCkhmG1KFfxT +ldjITOQOoKfaahP73su1nHBlcajuZHouIrkWkAXdYeZQ6d2TxGQNauB+3v3CA4MK +lUd2jOnxj2pn66UbSPbh180pUH0Q8/44YMFXHKqWuqPLhF5phwubdL9TWBS4Ztqk +WkPF1P/bmAtRIVC0sWQ+PUa+J0Gf2CBw2ktwPLbZD9mcQ9OtVIYc3axVOveSEUOO +VYlvKq2rTaLqVPgF6vMSzd3ZVqD1+O5qhLWNHQM3ki9LfvxKiO7z2KisqC/alJ39 +23p8npNu8tEc/C24S/xMP/Pzko7pjihxX8xIAqdCGvKUKxCBUM5C+szhJ0wnO+uE +Yu5YqPqDWe7rtNBW445/ad3tOjcdTsaF/Qf7HWT9tEzLh0b4p4DSYNA6TvU3oIH7 +ifvIaLboSTgAWktCRfItpDkXmTs+04R7e9I+CIjuFqH+Ck8ZEbKK1kSFIZSUb4BU +qRSENN2Pq7tk1gYLj72mrAfviddRcPSDMz/j9jqB0ZoqFNdBfgm/gjnKhdoaOnLr +LRbpTQI2Jv6KdiyZ1t8Wl+Wcnb6Xa/RXUskpGHda9WTleMsBiRbsZ2+VGI8XYDXC +MR5V+AD5R6fZnE61LdLZi8zHg1bquTWSfy90q5OUSunfYdiTOcTgDRzlNbX21Xfc +dH8SevVWAXay5h3Xxxx0O3cgL00FQGArRWiSt0WwlX43pGvhsBepZHLItmCVhooy +go7+b8CVCGR65Yhk8aNSFWlstnAYIVvzbphBmfXt4NaUdBYkKGdrhZVrGyrVsnmi +st84TwPWCNlHql5zZ4lUbp9RDZ+vXmnpJFc+9br/Q05PrDpIsUghxUta6oeO4fl+ +oS218WJdobjsZLERR4C9gVheK4KpTQjmHI+gg3LGj7KtEj+56YZM6TBtFc5WmGYb +sOMmTXXVp3SZbDAa4nSVT2ByMvwTAr6kYeEyzoU8A56XdVskD6Yx9OMUzdJQO6f0 +BDpjHB2c/QUjz8wLk4wdmZPf+3mDIwi+joG5CNwBFlxNCS6b8WK5aKyhPvEHilXU +AiIhlra65AU/cb7e0uwZmWQZNe0Jyp/2LI4tbQ3cAFrrxxhLQ7ahdPTq1hhN8w3h +eU681GFFzOOK4BOCfBAHyHumVj4IF2UzAHw/8B4oy6bNN0dh3Q+UZq4jgyuW7FNN +Uhgd4oJBWJPYm5tufHAoxQVXf4wbaOp9T+f07D+HIYORr9RdVgqLrqru+jfeLUqi +gTbW0KHmz8QlfzWcl8PfQQeFdTdpxjUJIDTrh8pGmw2DRyZCzErh9nACnZocASYE +sD15lB7raPF4rb4UW2TMRlV5f9NNUxWYRoQk1s5dLME5Mo2177vfSJm1AaoarQmR +g6rDJjhabWEl648Rk1gPuEf+Qc7+KPVAt+0com+Lcb7ft2gsK8zSn+ALNEuZMQYk +oNgBCqZk1UqD/2PpLMga20VemyN5q8nMMOtNBA2E+cltzGXmAB/QkR1i9VLqCAFR +HrFzdjMkT7U2TiufBnFupKIx5jPuKdrfR9rvi1PX13Xp6Ktgv/awDz72t4IKMBSv +UODIIQf35KELhDK363L8cKjgpH5InaHtqRweSzxxKVAeuIfuLCSHCfgKhfotmUY4 +AxwmOrYzkbku5GoD2/s9xH481sGg0gxBqCnSkqamSCHRZjt0Psjv0UKw1vZ/kfsg +YmDFAAye1Qfq/Navo1nsHaRuT7RMdqZXZjlF6t6pskJjq+g7JMO1bgYFxLveTljf +kX7WliD+baCTIGBk9j+ukh7W3hsO9K8NX9MLEOPnhHPgsuevBZvlGS1evlgEq8IV +ROim8G0hfnB2R3IIfo/xD7jmfSwoqTpux+FGS5+D6p1z3ad6412ZTzZ0ellPb7YD +ifJBo7DWCjvFjfeRW4TACatDrXmTpa5Qj05WHTfK/bhBLCdjIg0kolrobkkhJjiY +byBjzJ9ARW6/tkmQ12fAM6ajlZofsl/eiIbrH8zBYKRs+Elfze7k7ScJiqQ5sgCH +WQ/uP5xVO2uoi9EYBgmlpwd89vFBTC1gplTqQ9/v3uTs1cHhG+D/T8895T71NKoX +IB3qGfMzdunysuwueoKokP7bpyNUcgOK8uiTseCZr4JNSvkEVkiqp7nccOQCaVPK +aeNCLILVmfTRQMZJJlVbqNfppJib4aw6Fd4ebCqJe6NmZ9UQk/DZA2bHy8FzCMAd +Y4yc5sF/sImG88Y7sCQ9RLc9NMs0JZdWydpNEjtQTGtu27T2D7+Gy61A3qQ3Y6F8 +UsoNaw9L+wvkQPSGM3COwNw/RE6ez72lF6FYdhaBu7rHSbgehHSssQje2+PlKMdd +cKRSd0gX4N4UvBi/NigpY43I0D2Ga9sIgM7+VQLbY9OPuyl6xHDplX1D1UlBfbtN +tgbq6PciasKBJ4ZYokJpJsybt0fCR5eOPtPTFmowy+aacUfZ+fm3yAv5Paqg3cPR +enYYiRqaKe6cBnWyz/e8QEA9p55VpXQSOgm5z2sGjTjJBPypc7gD/Ggn9FovSQof +qVNXqTfysH+kUzFsLUvwMFbeCjKdW5NkUMWney7T0NS7pa+fLemv+R1CoNB25i4O +adeXkulALY3IMzT4so64hjryP383n0zk7Zo5kTZvDt5PmwC2RzHGa427qNvog9zF +M2QH1G4pP0hSIwlxKEwVwX/ecWtZfb/yE8k= -----END AGE ENCRYPTED FILE----- diff --git a/.harness/adr/0008-reuse-ssh-keys-as-age-recipients.md b/.harness/adr/0008-reuse-ssh-keys-as-age-recipients.md index a2cb5ff..f366c8b 100644 --- a/.harness/adr/0008-reuse-ssh-keys-as-age-recipients.md +++ b/.harness/adr/0008-reuse-ssh-keys-as-age-recipients.md @@ -1,76 +1,78 @@ -----BEGIN AGE ENCRYPTED FILE----- -YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IHNzaC1lZDI1NTE5IExRMGNCZyBSd0c0 -K2U2TW52ejFXV2ZXeFFUWHJxYVFMR2VCc0ludW9yNER3WjZnSXhnCnJDaUE2SFhi -SWtiQkp3Q2UwR2daamt3dC9vNWRkeTcrRzJSSFhaWlU0Z2cKLS0tIEpsMUExZkxz -elBXbWVoZERkTHVvTmlHbFJjQlpUSHM0dnlwaEhIUDlYTUUK6RTzP5raNknX9NPT -Duj0SafEkIcRVimS9H27DnmPFYCD3FIbC2Px/Fo8O9LObc9mkGZkgoNMkyz2bcGp -DgIsr0hh99O8eYBYO6kdzIjP3WefEhO0kYAjdAbFWhXGUTZsFXrTk1SDB6SXbUs/ -EeJ4OI2myp74lbT00toDkt8klidI85TbEKRtlF8LQ6+njYkuTOL/pT+hXYv7ElHK -q2Mp0yz8WTLJIoQP2nhVmST1PZ3mvrxfKWI+7FxMorYFU8ucbLD9ZnQJYhDALbPq -QQmxEgv6YQE2pdWQmtkt9DkMI7AvFrD1Ox2PP7E6pCliJFAGiQRHh3nRYGuf/4SK -JTAPgj9HRyTSYlUSnzqNuTT+G907hJaDWD6c4lilwDPeV6N6mKxn/gOu866RlSCh -NfZnlM8DmW7I76ZWmTKksc/h1FUpTdb/nosH1Ks/5eLdTN2HBDNFffFnydyh/eyS -BJrV8mSz1Z40v1WGXDxfN5+mW7E0JilCo/YyySijIAXirXa+kwLyO9JGXk2jFvg3 -CFHPpNj+3L6U6YvG86D+kTdk8QwrUwXSSJvWgslfy09GOpzjJ3qlsBjHF4LIybHX -fU98rCdpF6M8vgyRkY/rae+oki5JjFLGTk8wjKvQRp73bfC0//b2XEnxkVtrrb+Z -FkXktCwiDcWvmdHkCmn6PSZihdw1xLTgUDLLEyhNrNnxyIiblcYwxwqjOeqxo8nL -AOkt9FM+bw7iw6INP3ZR7sqFmIkxgEgsIQoNaU2/MqbNiIRw2fH6y1ucxZR67uTW -++AZtuyaXB8ERg4UYKampFtVRT8TYtjncrsWJRRtbxn+5RWKaAH970XZWiV88TUW -fZ2V1x3E9FIeOnci3YuHeiY4qvmntTyH8KiYxkZuIuOEvnjJDvVsz+YS4V97SrKy -doWkdEl7QSACUp9LEyYb5auKC2xc+Wna789G5yGgRr+NJFheD9l5CvM2CLnSVHFF -QMAjdEc50NWR1j6TfG2/EVJ7xy8/zTuGuQRRJ3MwcemqquwJIUY+irPvhqOAZytG -/mj8laGIe/x6OMx+VaqDhYx7W424z1hAlxzvixqKm5lpsQo1RluyoId3f8Z3CMpL -KwEnZ+CRqV6+sWopn+bZqJ7TRZdTCD02xx7CL0lm3zfpolDCZIFprIfS9T9hM5ZO -78IoIkyVM5KiwfJ7G6wJPZlFkoR67+i7+CB5Er8BJhI1LT9+ksW5TSI9W+jA8WqE -vGCCyFFZa5x/8zuhLij2fHFkMlibQnwEBiqbHtxsrYGeDLCHXpxEdiFWhCUbk+VN -7WhGwuiCBhgQryLCunsVHmu1h+hLyXL/apgQAbJE7ArkSP7b+OBDXO+F22HF31y3 -pEa5PppS/TYFtWuYosZY2A4qvAHeWsyo8O/wLhc34BN3btqVnsQASsOmW4VG5t3L -qocDUtd1y4rFPuYH1iZUwXbXMBZlykWY2kDFFH/mdRK8EcTue1ur5rSs4gtrd8Gr -HMhBkTh4S04Uuhy7Wkx45tcWPIR6oca4/+e3eKOM7b1hVxHP5IGJnLe/RhVJFMxJ -hx7n56NVmvfqKeTdxIIIFXImYO8ja1ORQROjrho5qmTk/1CO0kOXLi14rhWaZ7le -67AzcRARgWNGKNRbk1y6YJpkl1YR+Mr/L+eB1qUZEtF0WW+LpTHT5LK4a5rZf7W/ -7qseiqwT8+IjfobWLp5SRfmSqsf6AFHwSdhvhKGY3duhQspAP/+8BglYM7dHUWVx -EnEYcjaoJx8hq5N0/nDSePIemfSOU7po7os2t+hdVRwQ2fUKUH49HhsOouY0evuC -CzQpAP9j7I5PebphsnfvDyACZA5xU4GIJqzuOhJk0PGnHEvNYiHdU150fHdxQWYp -UGD/FHZiv4j4YauFbM71kQXfJBuP3uVG4bxv5lvM5Bw6TeT+AAYeXY5JbZJGQq9g -3r2af9GzPmNMQuG5enKGsKYXcSHd/W9DgAb1m3/FChE0HfX6qC4y4bFrQTWCjzUD -m+j9AHSKCWV5/SoCRvWXKaIQIerWqMOaB3hCiXdVpMOOj9PVul5c2NOXHx1q4NfB -bkSAGMO2M1hLDvDSMDwH3679XCKcOf+43GaACuEP5Ut9U/7x0UsKGPhJjbMWBo7a -HUH05qY9VHnrB83dXw4HMr5RvrhI0mt+fBv6tJXr4SI93tYTir6i85jPjp1e3kqd -8yk4e2g4/AgsmPyzhNN8z3C4/laJiwIxH0Gf/p167TzTyD5YUqEd0zFzexzElers -DeLrmWk+425jiFBg3KjhnAEVdNonOWom8/L43zXGrC02TpsA+1eZTRiVWhhXJerU -qxYdCE7yJYd9AMaPbNvHECwe/LQjxoJ+BUbd0nI8TFz12rVvO+AX6+QAQlhGeQJc -li/ODzZsvpwh00btVLY18iRvMb49VOjc2qBwqB2otSZeTpVLl9q0k9wlfOvgixDw -h+/bCsHV/XXk+uKqj889mZRc4Wm5o5sYYAHgvokYgD26wNXHicYl8u1kCq05ImpI -f4I2CGvL2zFUilzVJXLMgWMq9jPETsXmFwA9DQ6EIMsykr0oRGr2AL8EQhq0N1O5 -1m0KBtlNzuup5y183fw0d6Yg8Fi4oRv86mcB5u0+gYWJKtrHmsBvhzqTcDaq28O+ -4fjIJ8fYM01W+OdgntY2JApXQMYnkQJDIhQiBFWNb35hXXmOnK5d9RDiFESrpR3Q -1MEj+vwBIndiS0W5nEoyxSTKvNRrzRjAwq9qZNQfYkhvG2/h8sQnIT7p1/TltN5J -2O+OsygCyYvvqBYqOTD0+l8A7p0DQNn3R9xiJFlNuy4H1CdpU3JnhCfq2d3zPzaz -NvQpZOj3sUSWaqd8lBJTNkCtID9uhISI2MzeUSPMdCypvM+YVHBVFmvU/wCJvRnB -/2a8k0RVl5tRalE4fIWfKK0DyugkeNxy5vGD0my4CQj4utpwByf3HzCP2tw4qvZv -rqtMVEByK0ekgDRIkM75iIMW95fhbZXo8tQMIZpUN1al+qGbmRCazic1wbT0pFyx -8+jmGE/sVoQ6tdubOjYYgL/ZNmYmkPnA9fjmW6c+jJQzqSfLv8JiZDmC73e+Z7wg -teT2fimWN+jp06SratVKsukiuSsLhpwfJQG3O1QhtKUtRZQGSdLkyq9ePPKTCJGK -9TXzLyd4KP0rc4btaF9PReWOd33REhiH6DJDkGqL50ic9jlETQMaqi0OBrO8/H/R -FPeFGIQiCPpkKfi8VPlHb+/thejHILYC7B3UvyvsqUbvSc6TA9JlDgt09bC6IqIs -gkF07kYwbryKQqFhPM0Bu3iXr4mDiIAWpw+T2IjRXk6+HCJ6mvG3ZnTna7zqJ/Y/ -59dyXGmcL+GyIn0no3O+6wKwfC1ZzmuLMp9WcpEDmd8dgkr9bUc6rUHYyWnyGOCy -5ra2IHrkXJuS5yUkrerXuOpMOex0T2PC/924rNDX19zckziil0eG0PDzC3Wdl2i5 -lu6BGGQ4NLEyCvSBXOUoxLXEyLzGxiVR0OYa5e47hYL1HtArKg4P0fvhpHZVBz9J -ccg0AbHSQ77IOwp6ENO/wkreY9f8yiSPU2IQdJodpziAAP4BI3sGMAzMdHPDRcWY -nviX1+HX5pcteVmoyWrJKpHDgFljjscWGNhD1FLPHptmaZHjyQxqZUt2StQ6KGOI -qChxuVW0cYJloA/7JO0NnGh6n5SnQKRq4NnGz8TM9ETmkn9maCTndMdGKtti4d3p -e6mdMBwd9ZY1WKL0x6I+qXXwYEKiZJFQQph0YA8q9CIbn2iAGYOmGkCNoa2v9wLr -FZuCpgwleaul7zYUVXUCpJy1wOgUaGlV+GQ+Mj37xSKnykZNv5b+lFY+bYWaroUp -q+QUUgX7mhr46oH6H6HtAWr5dYruvc5FrdrVekA4BFYmgIuVvAbx1vez0mkVNkSo -hSqV0BMRN6DnN+BoJbeI23Ih5o3A5gDLrHCTw0OhHqG6f2jWMIYlCt5VknKxXqJ4 -V8rbwvQATo9poq+KyvDZwlMam4eWfb8rBdefJajPvPsl8vzZWKhfrlxpgKuIjq1x -7YlUxmjuAkRMMBAWFucbuRV/8CfB1hYf6MQoTkLSwqOt42MffCaDZC77pbJ08Yym -FwwAd/TIQ+DklqLdO2gDT1jiSzqugmWKkfLf+BWlVmx+JIgSaEtVKqi1GBLmkv3B -5p5gpq2nF3/6npIn1//+XmU8yWN/m+z1N+ITH9cm7XjGOkDhUhhYsqRb5uWr9wVv -WiCF2/J3+ZaB3kIB9nUaRRvuS9+gMb9vK0ICJoP+Fc7yWHu7XL04JXRMYE4m7x63 -jMuTB5ok1jD6mizvcjID/LOUXmGi1WqryMNJIhWkvLzu0ySaMmyT4v4IUSVRJjVw -j5M8Xt607LQ0mYuE3p2YjvIjh0HaHueiK2MAq7JHu0sj/jc1yUlUdcDk/vXxzME+ -U0lyTEkSljCOWob38ruteAjfm/pEAfrvfN6+L6qOv+4OHbfUqYTx1A== +YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IHNzaC1lZDI1NTE5IExRMGNCZyBVUGR3 +bzhBTExvdStQR0NjWi9uMDVJUng4MTVZTHFCNHNTZmtMQkdBcjFnCjlzYlMyN3R6 +czBYbTl2VndNRWJQdmkwdDh3Y0I3SnF3N3BNcGpvRlFDV0UKLS0tIGlaUGZZb2tq +bVFwOUt2aGMrWEZmalh2UDhNTjBLQzNjQlptT0RNSWhaekEKnJDX/yO1zQQN4g2S +9SL0iBKr2l0Il9+ffmeI6h6OD1jtMbiGhaOjw9YXvFTK6OWQYQaY+hSc8a77iPK3 +VINQZj0WnFobT79DnW4SntlD8E2ASKgoCuxb70UVDT1U9B8rtaUX/q2hEl6n2qR9 +1FlWIGYYaFfiFnHckXE1EknAdgPqoP66W9628l8fmg8DzVuuCc82pFjbjNISLHlB ++82a0HSl8pz29P9jnS745bv0d59R6Rznd1izZzkcoWdfB8CAxJAX39lvj2UGf74e +EWpxVfGRCkSEoSDuaZJ5J61D2KYEVxygp0nswwK1fUBwXS5izuw9OhV3iG2TynOC +4gUbamS0n9S4wP3WMy9wkl0aE7V74d0yCVtxFUn7rJlU5KA12NnC08zL1Q4kPGg1 +km6SR4/7ydoB44Wkw1CORRJCPJgdgfj8WmC2Mzzed8N141noSNwfs0oVzCRDug4i +95vrSPzM97RJxYtYo9OBJwMh8SmC0l7PjQZmwZHjU54xdsgPmLGdf7IjfuP6+mrw +NUQ38F5j1HJyqqNEEDrOjT621CkC0u04vcCLool+tTKI05v8eEo9aoIyZ6r8E114 +eoGP0j7NHr9/3qjjpRVVp9ByQ9PEH5gJJa4cxxsZu1nyOSWPO0AEaXE+cc0i0OkD +yalK122JVHNz/XKDuBchugvlEAM0VS+rv3e/H0qD1i8Ho6AeNjcLxV2Y/pyvbTm2 +Gg7rc57w5LDMMJFZ6vx7PjbCwJTPuuz2TobRdFmZaZGMIyqE6toAoLPPHu8Y7mPc +QT2BmyYAnOJCRz3CTpaFAxfnja58eKNNVCrL/3CjNV00PJCHdqbYz28zxSw03XoJ +8Khngq03xEuZFbgKoyvxdymEWO9BnpdrsCQna+tnzkQVYXjjAzqgzd0dMrY+gicI +nBRfOeU1D77YJJAh1STn0gCfoMUNS3eh77KPsLRy1dY0dY87ff/+rbdlv8MPfAp7 +y4E0UzXfE5lSU+p+n2PVL3llg87ojav22v3hDbkpZ/AhObGLJCTq7kcdRk2XylSQ +IqQ7I+9F1a5XpMijhN1YzSMF05HlO+kBXNfcf1tk63zx4MLnjR0hEj0KqGfwMR8O +D6FYw6iHcKvIoYcz74lmqbSksvlyT/wBAvdr1u2EbqGy81IpU/gpeUVSv8U+Dxuh +TPgVhtuk4gNokh0wz9ZqmZD++pJ0qtYHIS7jxMi1Ik7xcUNazpihKDPUUkHt6kAo +IvdcVH/Mj3xMDhjz6cVGWdwRsiZsAPIYdNXcUU4Ca1NTG7+WxsE/2Xmdcm6lE7ae +sByVjlWtl1eCAwPqpHYNWLskxWBCTUk4Dvz2lpImMWzQGJbYMD8BFN3IwHy1Sp/y ++GwMOhzHnd+ZoBKsnWth0lWoIOWLybSOCULZtcSRYV8hhAhPCYHEaL+psVwGuSH9 +guYXcXV1mqFx/xtImweWNmdi8djsiKZ0RVWEpXomLAoghxZ0iy4xGEJ4cxCH4Vq+ +CY8vFf3Jt+lFjwiYzJMwEr8zdlNB5V14+XYXZwI4MKaMU2u9NZGczu3DrS7Euj/9 +arjJqhaNMm5ytNg6uy61lDy00nkOL9xIM6EkW9OlSz/pjSN4UVUIq0KcdUyix0r2 +6O/2uSGXI4bG7bkiOeXZifTgHdD9rpsrJQtjcAHZStocWdL3w3osDG6pFi8ZafwE +M33xXln4cKhtaDUxlA9a/qSxBVkXzUGWVlh8kX3jV13kHIeNHb7BSFMgWFKhDzOP +3OkNyOVyVqNqTOj8ymhd0bgxbgj0nVF/hLZMFPf0kBptZROHggR6x/a9Q5uCZRm+ +4ZhGVWOMiHah2JGyZySoHRl/pD+TQQihVgrq8HmBZ8XPW73iFMoT8o5/zuakLj2M +Ok9VSorx+CXan2VB1axibwHvB5XIZQWj2mTpXG/Bls8JShaxQ9tQLYK6wp+9+ous +HHN/X4g5fTQR7YVhLcxXxNbOlO8xRqpLg1oclse89PsL0MYkmoe6B/2P7xFPCeda +Jw+XNxn4g3qTD8HxzRGaOz1R5btGDOSwgQxc1UM/0T9AjJY2bqBwncIUnACkkZZ8 +LNyUDbrrda71LD0ocl0zHDGoRqOb9LROC0SXFmqtLXVtc9m9rQSkz/98wo4tdvga +ArhFlQQEJZpW9ht5uJEy7plw+axGyvmb+oNhU6MuXfUDCzdpYOX5OvRmId0kT/HX +qjDyAyq2PxwCI2RSclM7sNaI1SfjT7IyooZxdV5ccorcXNK9BsiV06OEJodS16Jb +ot3IzZUunIHyjLEOzkZ2zf4T3CLBWdkCqhGGDo2vN6kUEXiBr9zY9GuCcd23hKu8 +u2NFwTPuzDv7B6qYR2AAWHMPGTDkmUYrNEZPaWdPhyqH5ADL63WjV0LRBLu741Pk +Pba22Fbn/ziEsae24ibQerQb0mpoh2Bl0+Q2RYni0Rmtf2MB8lw4/2K8jehjBqvx +Jy5zuCe/B8i6xRFMR0jyG3iGbgjbRYPAWQSdbzOQ+h23hIekPsn5cUlvd66ujvIW +jb1BAiW3A1wNt5nCYjJ85pHAbgXcOS8lxa3abXnmNCkNCF0+2TO5OuGb33PVaywJ +1sEmDcs4bfYYI2xakrDNufC5MV8jeSJmuF5KmSDiODNlOljtbRs5qa/9HXXeVfHe +yZN0fLToX7ySkldQucdYOCdZ7mtxW5Z7fwZaZnBJBtCsZLzLnRlOn1iAWd72yepu +jCXyWn7itG8vkToEgzNqDi+Ya0jdo2mUA8nnYo6rEOYBG3YgtVofAZDk+k4kEHbT +68BECIR8d3l3OeaeGvu13cOx3qmN1TLR3DZPZZGF9iPFl17T9aTiUcQV2dGjv9Oj +fjeJOwZ5xPtRXEWwfHGz5yF0XVx8Xh1reHHlgwDZzsBosCTS6BMwHtgI+F4ebNJi +tdxRK/cfMNg6K2q/LbYQgY1PX5/GoPVCMG8dIPM/G+D5RBKMoskUIwrV6hzYxef2 +dDAFhkYCThmhcBt15qsKU9qfBZ1SFmmk8NfoHNNs29fxpmAO625UlTM6ff36gIjA +CA4zKzjVD1xPyyJzeRmTN3pEYPAd7dY96G5XUTnrOLhclC8UHv5JRqh4rPgQTKnH +1lzNbiygPLdBv2qDrji7fOA08yTyDChZlpBzP03/qkmsOEx2jhQ/8SkxCTtHYHJm +pbIbrli+hP8a2+4Jlj1Dw6IRCHW3mYc8TlcCvooP7BV2n22pOzybmnKyFkrD/gPX +vTt+wOlf+yNncbcwQJXORP+S5E0t5Lil26/rjPWPbZoEi/sjPnqomnQ16vfIpty1 +qQVxNNiZFEpRu4ssYivsFufx+ayZP+PwkU1MpGmziXXkSFRdUs2J40+Wsexrr5U9 +afP97H8jUfhzSgDFTD6I4pDhNFomv1uH+Q0NqJQ8/v8TcCjfPCob4RRSNPQ1lwnk +fV0LXk51z5cfYQTkXPaTEprQiz3jQ7/9CYKqFci+f82hDn8f+3cuoUKxwbVilm4O +9Sh3EfmTcYT8mkOQcmqEDfLQ3qhLNpVK1ZEbBMVa3p7qfQ9Sjl5HhI9yYsuIzfq+ +YeGYeKYjF/RrjTDy6HWeDBf1lDi/+rXg5xO7s5lz0zqr5efSkX6PD3jU6/554OJb +ajsO1yiJdFbLGPvtUVAird858FP5LVOwaNWtIgKZYiyAgxsHMjGqQDpmCLl9o9l7 +sncMxkiCCpH+UzdkLn55xpDWKiuZoLu2/f92nPe4YQSKH7N8EzAs1xsfFEWUV6M8 +MRlEjzhB2TLu7JEG8YE+nplSOGdrHgW2CIEThBtOedXUoY5hRNmxrGoAoQD+Fz2S +IkWP51f9cwXZvr9JgfmN+mIMP4JYwk65Ps4K92XrKPYGd1nhT0ckSowuHEG9RRvL +9oi2ZvetOZOgeBraJOdvExeOwl2RTkB6ktMgVeBeb9j1NvqDFW36jiQID+q4aJQ8 +Dj21Da3UhC9afIitZDn/EeIae4wab/5lI4HzNr0u8izilSUp2n9oLSO4ePsXXlwG +8OLg2KJjobiH+wXrVLkFsNKLY5EfZp7JsiVqq9O4PsEKdbblObQscBT3XhxQX0N7 +vlE9GyNrXR3h5TdgQpYpJ+Uuk2VzMAiPhmmXEm5i92hbizjdwhxnflmmBsGOVE3r +9fLVQ2mryHlRCdndogIF8IgU1xYj9CGokRWSyczxbOTRWut/O3j/SEFvN0asDhlm +8HN8cGMwMpX+QUumAz9kZaUppgDhZ4n3piwMdJ2tGgq+lyR62GuLBn6wvr5eYzfj +MfZwi7KAO5YGTKoJUKOwCY2JoiyaeQUXlYoXHgLCioNYe+bxQHH3ZOAKUJx7o731 +xUhOWJ+45xcBP0pEgImP5SdHHrnNwQa/HTG/BbfI88zI08JHCpgD9Z/57bEeJaVL +c3MYtt7L5Jw8zCOICoGHAyW+lPeQWbwFk7jgs/mQVnRY1io4na/GcdKy4B7AQyU9 +g+wWm/qDWdBy/NABwaHOIws5qdaS9mfP0mBKK/slIr3ii4xeJbotS2ISwxcv9mw0 +kj+KG0Vd37svKpqm3F3tFXeY/OAqGsQhxUTWCb/75HmjNZn7g+7Cex79UOX8p5kC +ua27X2RryGJW6jVag4Mc2jiyOvC5hrJ8DN7CsdU= -----END AGE ENCRYPTED FILE----- diff --git a/.harness/adr/0013-windows-owner-only-materialization.md b/.harness/adr/0013-windows-owner-only-materialization.md new file mode 100644 index 0000000..6b27cff --- /dev/null +++ b/.harness/adr/0013-windows-owner-only-materialization.md @@ -0,0 +1,65 @@ +-----BEGIN AGE ENCRYPTED FILE----- +YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IHNzaC1lZDI1NTE5IExRMGNCZyBqL1Nv +bHhXQmdtUUx4ZDlEQXZ3U3JWVFdYSzdyU3h6bXk4NEdHenhBOFc4CmhXZGtab1Ri +b0xtS0RVRisySVU3Y01nYWtuUlBURmJiUXVLbytwVlV4aDgKLS0tIDlTbktYVjJ3 +ajhWMVVNWXhrcXZFUTI2QVVuUUU5aTZwUHFHTWhKV2VhM3MKdYvfWpTs5b72zO68 +4GO8wrEWE4Qy0CBAGc4Gs/sjhcIn9l4hCARnQzMjnfzVMeBetf53ylgjG8bj102j +13KO0Sr7URsF75EJ/37iiw/cV131ZqLdkF2dHGQ8OalqCz7oB8qgWlKO7kAoA+SM +ewZ2j1bdUIuiRwd+vAw03BhPJgRLjnPqHtIi9V63nDNmcc5OMv8j0HAVwtSwK7Ts +gP/RpT0LxTAAVJybrTly1cn/D/DS9bUEW8rh1zzFjSQr7AxpdRI19oWQAIKIxabB +zaK6RWwh4wn7cyWy5458JeO7AxcgS4Z4iwRQ8xQGwBKAOuw3qHPuvMVzLd3YEK+V +IhZn8U5hiHozbImUsKzv7VEnzUWWDOlVz3SK+vExlzWbpD9Luwm/XN4yYO7FBsPs +2QvyfMi6uiIQnJx8o+zyIVyG/kyQ0hlBSSgUopyeQWh0g8ogQi+5a4F4zMbmbiiV +Jjh16+mmgM8YEDhS3WdmZ5WTRCn92sYKaqF9x6JRJ3x4LuNTEEEKJ6nuz9MNnq6s +UtVp4qDra7KiFNNocYknNtqbGMHqKty8jE6PHK4+SIiPEaOJ+L/twFMJYN7nAHbI +KLhNtgVn8GRM11PMKiqIeReTh/RcY/EDWE2V68cIm/319RhxW6i0w1RVpvvfOTgN +1feKYJMy5fBxdrdrTBvMnj1NrvZ8LgU4wN4vhUpn3djqV74l2Xlgy2bQaIoEt7ic +rElYbuiJjbZOSg4qmx0S3p6dl9clwp/rRMDgpI94vrftAzt8dCvIbss+zcZd9IR5 +gBDTviYM/4eduOHYBvkLM4KYc7KuYbxxeuO7ihgiQFLZlEo0RBEA5uzt3ByBjN2S +ha8piNNdFXvCnjYpL04umk2vsFMDEMTsUNA5uJlxObKkKGXXi7Z0rWmdq5U4zbCd +XqCsxN7Y3lnnhPHQehwxqheStV+WavvMnRgJy22WdUq+VyWhWAuszHVkLiNdMtxn +UyhYG836nc93MTNnqaduJj8evZS4fkXjxLPp5/+tI26ODA+vW8+yAEtRgNIik1fh +/3NC5LzA9e0om21cJLsqdBodGbPDT5lKMhnurU/MYefZZCqznbxQ+tM4sYdab4Qw +gV4jRjH31BHlSdR43L1PpgyozR1+e54R3TCM7YneRF+M8gX+goKmDcnFqGd9KYCa +dCzZ6l9tkK9QrIvr/UUbsUhzRYn7eodq8bL3k32Eye31+tnxKlQZTTwcqIR5c7M4 +/wdqOimqXpU+jURzmRWU2EuxBDXyEKZ2oODv2IotTGswk86RJ2QSR6ykirfdLoXx +szqylEhsG/jcaw6roNmoVR7wYCZD3ghbLyJEZlEsJ1iEUZBMUtidps70LZUn+O8o +O92sGIdUKoH/rSjWX+L7Z5pDMZ/6IW3lxXOSR+Ud2/edmleJGbIquVlc1JRYOh4L +6CLT0i6KHR5+R29dc90OGv/xSGvLspNSaTxYX60CqyqfuRsMNL5AwN/8aNNAyyZ3 +7WAeh0nAxqCKLiIq53xaqDIjCQT3muIoeAHk8z7DkYn3h0zOXVSxvRP3IXQw4Bne +gxl5U701GHwvgJlNNYSB6NenmVtl4KWg4qPdV6UQS4vYEl6ELEX83iGI0hKJUWTa +Fd7oLcagCLFMK1SBYUSOlmJHlsobHXx107Y7dE/aVVRkB0uD2ahdiZR0uNPVb2Pb +uTlJtUAOYS3sJSXtf4uj8X1uL6NxXNQCN0YJPK/2AmEoSdMdSp628E9MjzM7W6LK +MsssQrkV4K11IuVYgthnJX6mCdw0b/lKoqJWqcgqhpZaB4mh6b6V3ogvUL95rB5r +2oilHmbI/Rlq1Gw2GRd4Q9D1EtRaQvazeq7DNc6ZQNkzap551sD4+TzyBz9SCeNM +P97UH3hXrg2C/NJ2RC8RuMVe+qRozFNSNZ9UiX/4G3p/KA8P8VWrLKFoQEc9gvf0 +qNGEWNkBehypxPRzbp/t2i4FQjiNK2gWOYNARTG+xjbErnJtwqaWP/HfJZEd6X6L +LJGJIZu8dymcEeNCOsrTZXZdsrVGeB9/Jwv7Af2GpVWBkM6c/oKc8LmVhSwHhKA3 +wzqWl+OLbsD9csCNckxqbm1h0yuo8elNPjp/Ev7lorhb0FpZnlFjKVBoKH+C9jNv +FVENEKrXT9r36R8iSnIu61cMkIzGH4v2YNlHulZL3rBLnsLFXvFuJazy7hvUemoF +X6DAy0IWMpFdyKZLyR4otnH9Iq0Ja/GNtH+hXJ/Ap++rId17jo4lmcz0LdN0Rvww ++staiq5I+3nRQ/rMbSmu8OKw+Aq00/uZnErVDlviecV5W1vduyLUB/NprrqbLYfa +4x4BVN5QYPjgk4uMRMqhD736i/6k9O03jLSiFpREtd7OFw91Lynvb2pCknlb8m+D +9M6QZoWlbV6gnOvuR4CFhYblYOanoQ49905aX2WLkQXhh6vMuzQ5dggFGc3ieRe8 +le62gINQrIChl9aC4ILqMQdU0Uw60iJt2GDefdeAmAL2HU7o7zsuN6PRyFswd1wo +k569TWFZ8SXb3cpfeu2j49/X0htQOm5uI5skmo8O9z1Y6Vtb6n3WV1SAfh6Zfowb +tUWJztjXIQf8j8ufZas+Li7T712x2mtlyOr74Lssr/m3rpDIGO45iX+CcT3BUqiA +V3zqhwwtRr4rvISfDOeUbjjXwDPW8A+sAtiOGYlY884TR+QaBjM/784iY9Ajb1tp +buc/RSW+XEmD/nkGL7tXCJDufSbuOmKeS8sNUQNK+ifq80pgjUHx9p4GiaZAq5i8 +wOqu5SNfsUkHTzn6XFPV10cMKEvqMllvNs+Hv8/Mv4N62RMs3KH5xAt9+NAihA3W +obSKcVcQklQbgDYyhV93NHjWmKlTDe4yl/JtuSkxIaLtFImKGN2QEZi8MJFbhbwV +Mz4DfjxeTHtZDTLJl9IOuJYgTMstamKwwNfBvHmc93a+huDyoRwLuEmnMRStjUP/ +TyoJ19TO5GmJYrXt++1jOrGzK7kNeo6AeLOJnnCEzL6cj0IcogQznMCa3vvMw+97 +CSFA0kyt+Ogoi4fD5XqSaNoe/N5t9uAmVN/NVyNX3pLBNjOUH78wJ+R/UstZ1bWA +4LeCSrlJXkMzLErS9iGbgBGmTkr5SB7xZy+73lw4c7RJn8sIjFFLDt/Zth5KgJZz +3tj4PeF3Tq4qH6K9QtyvIYlL8Jp5QtE1RsnU6OkBWtSaYMoTfW+DclNGxHbEg5m7 +COsWBnRTT+OMdsf0W6VHTdc6yoFBL8knUNMkgJbfZ6RtD2hOck2tVPw8VSbtgQI3 +kyMMBgt48le4KkjPDtBXgdISzuuQlzvUoyswWx7YbLWl1wTv93jpo6RJYGgWPiUN +N4CUmsw2GaGKZF2+hbxMNR3hePh5sEne7qik5GIQphqya9MaO2R8EPUvdIghWZib +S/bYLzSjEkNorZfVT4kXm8l4pieX1Sb4Ce0WrKl1niO2worHfYvD/wDbsyJ5LqL+ +UpqjwMKFZVSgqjTRjPYNWG9LZD70LfNVq7S8jxgfQhUsKi6QwHO2RzM3+3jc9u6x +0hhkCCLk65cRAOGzykCB+bRC+kAKwgQk5HSg6TlJ3Wr5QveD1ZMJWb0E7lt370t7 +yyxAXr/hD3Di194yfVS92LKof3SsLCCgYAMAExtIShMSCjyp3Al5/kdYP0aDbBan +ma/bzpifByJ+CR+3ze4EYjvQbnMpDefqu8Z82RM0drGCpe71sRM9QkHXN5A9VTZ5 +S65dU3LDZoe+sNMUqY+F2WHKyY4Cv6w= +-----END AGE ENCRYPTED FILE----- diff --git a/.harness/engineering/architecture.md b/.harness/engineering/architecture.md index 5e201e0..6ff4ab0 100644 --- a/.harness/engineering/architecture.md +++ b/.harness/engineering/architecture.md @@ -1,565 +1,573 @@ -----BEGIN AGE ENCRYPTED FILE----- -YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IHNzaC1lZDI1NTE5IExRMGNCZyBhZE00 -NHhZUEwvZnRlMUVXVkRHWFh2b3dWRTFCblBPam4vSnQydU1ZNEdrClN6ZEdBZ0Nx -YTVxVUsrdVl3R0R5aVR0eEJodVJvTDlWY1hYUnRKajFaOEEKLS0tIGx4MVF3MHN1 -MHVvSkxiRGFtYU9lbi91RGk0ZDNxTXVsOVFuUEc1U0oyVHcKMrV3cCGmNztyp5ah -me67sEmqqUyokLR+PLQbiT6llPU0xRFFTJJ2QOCQpyH0qddJ7YujU9VebFtI4Gli -ohBPl8/Cly2+wD0uehVXHLxJnyAlwNPjp5NlvwJ9IkrZwUb9NCHNWMzyoz9AgQhI -WiCRA0Z55ihDwMKBkoe4wWFm8qvDl1RQ8UMM8N0ajSDf5whKF6QHVqwtKtvvjmSN -GDjKnlN59bogSSHp2TIf2zR2yD1btUOAxiRZ4ZusSsYnDtZz1C/hJOHvpA3mMeaw -ZZK6dAqVp3EoV3ktP4K6GIb66xjyvIA0BRSAHrEDppKIQl554JRsOLmEVZ3AmOQJ -gTCAb44RPGVdvExe2xh5dcNgxJ/T4VOctzeOvRX5tmCR3QREnT9REwpcXGBIi60i -s3lmdkWiAC9qQDbnFGiVl7LQJqpFuLDVAtrX5sy3WS46Gmeen0PN7+VzjTZEG0bk -fkU0WAKSUgvovQRi1tFtxeuW9ka39uzfBtQTKNNGq5t05qEduzd1EtNnZT2Intxc -kZQgPDYCQw1GqZau4xAe2+93EA+5RRLaJseMWHCMuEOYngN4sJcdrmd6xFiTSjAV -Y9+ZQSgfE7OMx63tOH+6tTV3bEhHtqyoKfoQrmfEENiMuIiwDFWFkfbuqh+ZfQwe -RylAndP5G2yAkMa/W/fR+aDUp7hqYRM3tbhin20zTxbSfmp6lounJuGS15schnKF -vrifhjb2m+qsvDVFlmwqVZjv+0wvlSkZGuLwlls0URCWLe/sdxvNnCGVCN8/t4dq -rgKo9OpX+sl22FxmqmZsZv5+dCVHYpgQkfppbJlDP3M2kPc98FGud5vwB/WtKNmf -fvMu4Hc9i4PvChnJiYmbjVVUqcMk9BjTXAGA5vBllzVPX4Wm2yqwF1SHetVOVHCF -/v3NgpTnoAt5PI3YgmB1eya2z5pkwoPhJAGIu1NqC3FZpeASd6i7Ge7/dtE9ZNJG -EzCAKPg11hhcL7Frkqr1EL4PNUFOmKn/XvTLsR7DNaf3SStPU02TR8j6ZHJWdUd3 -lND2zh70/2Pe/yCjjx07OqJUBtABO1H7Yg02ZY5vTPCWl1u7bKbjpghMbQsDMBdO -t9TmoWkNGoxCz0TCP8Lkad2l78YwGVTxu1aGkWNd9U4mSPsyHcjh4jrfsd2VacNi -1XGUlrXuG2V7xAClVx+/96wfOKh0k6wCR1sARsMhN1vt7XAN0d53wMKg4ldXHjPi -IHDNB5Z5VgdMe6SzCZVPV/itDz8Co+rpB5q1Qb6uc1aeuAcjXphOnOlJUk/I0gGU -Ub53cx/tLNQAUZAelsj4Wr5vE44MfncpBVQb/lTaFLNjqfhRdo2klYxeQo5jOcB1 -2sYKUZce4LJ0V2FU434WLmkmu18AikH2gRucjaeHt3bskK64IO6BmnicnMEm8D7Y -zUY7DqLAYp2WIqdqULyLR+dTxif1gfjjWMsjg+cG662i4GSDGlP+eKsl59gOVquH -9vupVFvyfeWezN44utm78PBLXxoOtv+i9eX+upTdEca+sRKsj8xhu0q/Bx1mp5gV -y+Gpz/E6spaHB2w5FEdds/YAXP1Ih63UjzxILTInuAEyMu2bvDZ7PBCdJvqlS2Gm -ThFuemJJgijEYiihjLUS3VGS5qeAcW6G2BsaANm50CVZMFErAbcs5bUReHwBh7lB -w5K/eXRJfFOCyaqMpOqSdbXj/Q19chBymINeDiuMBRkPG4WVdbG5AFf6eQAXj192 -79DJOFSVVz4t72RMR3aluSh4nPvInmBih7vtnAo3NF4zQidovFQfuCJowxnqCIq1 -bey+sEH07PHFSxbA7UpELhVlwjdnOQKvTBkWOqZjIXD2DbQkWil9DXu1RLdV+Sek -jW6jUGx0hOPTgDO5uQjpz9Jgpx6fP307O+0VIwpQciwCdn22ajkXxcKsXlf8y7T7 -mvdjbiRO6uBN8xvJ8PMFkJhhuQZlhSwx+EnW8OON182ZH4/06Vdst72sEUm1IQap -ehu9wY6SQO+4aiTVUjHMaW40KWcp+nEqS2JekEar7b/lBAHRm1d+p0O4KptvKrSc -Qk/qaAU93c9BrMvOWRZCEge5qvUctjTADSUbNROx7OtikbLBCO1OFd6/iejodPUU -c22JFql9+Fw0aNZHNxB5h3YB+cmBa2RXFMyZZdKfg/+JOT+K91q5mBXldQqTqySP -nieDwLXM9Je/WM7YrpYrIW2ppKgasHlmSHoF13mtEy4TQ3Qy9Zhhv/CUSk8+Plqx -a0gu+kMwqJ6d3XXt1GPbhjE7FsjFYWTpG+C1TglP3k25yFKNtIzQJH0lXAZ8993J -70VPvAFg47aGpXYw10Altk5K9MkiWU9j7qQy7NiAngZ3vpu/cefBcDVYxvmpGboT -EpulKou7BRGAWM740yS4yX9uKrq0wh+0Q1vsM/ZRe8K19J029LJb0JM+afNY+kBF -mfi2IAsQ4ONJzmuRqysjReHqb0S8J0U3YRRPNyVhuc+VOa+n/uXj/tL1+6STp59b -DDHxbttrFWOHcMRQ+YuEHL+ynw7aJ3fbpNfEhVwt9FWwDjViASSK3Vv5cXNVtzpU -IxpllkWOJsj4vcPp0a7pWSaHppm3NepfI0mnoQPM2HntUiStnyixazZ1lSOjyvab -8XZjNihvmCzfe+v1QFmHIqicls6Ln6R3vy3JMAeBAp5dF+niqDxsMn3re+OFklkt -3y4WKPcf//FkYRjnh0X8NphRsxKLIqucKEpXRkJsPLdl8QG93p6d2UJwHt6D/11X -IYVhCP5YW4M8SrDgNEQ/SS52K4jrzCCTJKWtEgHcG/BklDSKi2MXdpaNI/b4ffWb -/IuFIecCYZcrVA5jZUl8qKlp9NC4lx2R/G3rsVn0XGwAT3V7hFO5+UQrqSzPNLSI -HVwrXyZwJZFt0UR9OSmO/qaOjqyw1vXizcoY6gu/ighmxAHW62dls5WDLDwjqKzW -SSD0I9aJjBKE8eitJnm9QU7ao5bnubfhFKmfmb4KVM2M0eswCL1LljEK+HVEPwpP -iYHMHx490l9GKLIZH0MG7jfOOnwQYLp7rHAf5QXfJEfQB5Mdu9PlMQb0UOGpMFCl -255/aT7kqIjxjRW4aK+/A8WZd3yperzIZ5dAJB/UiDZbeUMXflQfJxEgJ484PnEC -AmN0uUSG0RxaxodFAusdB1D3g/MJRuPibievAoUkPla1ySIjHwIbS3NyvM+nYU7d -fMm3Rw30PN9mkvK6Cq+nEERlOtf3iqb9AXxwjI+BFObGt6fHPegXPgAvafTCuIpb -TuvGlr5mMGdqfooVh0R8938F49oFKmJc6KNliBohqZpQZor7DrlzX8JYX/XGZmrK -xpGCAyjN1CCp4sAFYZ3RgqvaMXfWQ4nAyd0HhotSSWvMLeypvl7AokAKoo7SqgN1 -L1ueodwXFoMspaRGLNRJnWz7NQwlHfQHIDee9pCjh6/3Dx0AyYsHoGMaJLszsQE7 -rn7iLnls6L1yAj2fAWrwWY8qqTS+csKBI0gMPFjosAM/MIlA1kKwuynNpXBHOCxE -gWqcznJkgddqC1eRT4/wrwrSWBe8UkFORwmNjbF6vO623nTbWLcp8q/NInPz4X5t -ZLfGdQjjbcC8vj3R/TxGDc1Iin0p4GrDsgTrWjHGQd/jVWXnrd20OnBOkATZc2RX -l0BOCvEulMxrlDcmMMGZuEuLRwNcoX0IPt0YrOwG7KwjiX4UUnGHprukH9SensSn -S5FXGQeaV4dz2GTEOwiYQFxsCi+c/ZvlJYzIVPE748CrhgeNfI2MfXlD/NQksQlm -hZfee5BPLlVx7vXBjio3En6UM+7z1tEjQD9JhpTU73nno8oGgLmWVb6+0jSxevZZ -JNHWE5kOmEXclSDxQYHpsZm5/9RsHUxY4swpg4MUbQh7yg5M6jO4Hqt3VeWhesCR -gZSbKOwb+e8khxk78MtQ8esChjLtBywAroB29GinX5qVYVoaKXWS617/PgKA3vWw -QXgl1HctpBdQD9l8P0wvXIzwDUITbOB9Y3OB1OuCRAGQYZtDpXE4iPNFXfMuwJyU -CHTnIOL8yAx/jdLpTj92zPWMmd2HJMVNrI51CteDLNnifsAU3NfDokXvftNUCrsT -O2ximVUJliIeEQzXELFTev2xzrPGFpbONwenRK2xVWGPSJG4/a4jYMImA94dtj8A -eMwyaPvr+gBKWf5bL0s9s46LBdMEY5HWJ74i/ZPD+xq4PFBTbN9bM9Gfp38Zsbph -pHLOQu2b/7lswX/AN1HpPHFZkshSjwq6FSpa475LJ34sh1oFBfDDdySmytsq4NwG -kcrDz4IEwG8LjickYUBueGkhue+88Puzo0OJuCbjybdJxx/aOnxnh3PgaIc54fC/ -p2aDMK74B67JWM5cJB6gKZo3QL5b7IWFvbe6HuMuS9R/G8x/xj/tlU8QjP2cePcC -lIiuxoqbLmn4VXoKe/oDJfULOVQPlFXp+T/qumo1aUclbbXeWzGAHbxOiJOp7y7k -Fygnso6UHAlrq8EjN8XFcxNVtacYOsPm63Sd9tjRVqfC3UjaciGRcSqMP41dF0o9 -ezTxJdM/9W2Myyz6gc6vRtHTYBc/BCg+sYXtiY6dQc4Tn9HkFs+Ke4z2BhV5npDW -iVxKKsKq8TTcfcZX9Ay/gooIGuvGYLhrzUea1Jac13kpJjMGxaybAvuSahyfp6Yw -Dj+2XXixOm+QTbtkDshVJ1y8wwIjYvVxkRIAh77S+ugAGYFE8THj+FCdnAXy8aFx -Be78JM4ET1+Trx30CzAW+lkQZoXKrS4UhgpxMstDkJri1VMIEm97S0Fxkfn4PI8v -BcK9XeaGaeDzyTx7IZjKtNdTQqMn3y8pr8c6dRQm06vJwaL6cxiqx0OdrHcR0QGb -ttAzy6k5CLKnaN3+4hF32pAA8aEQHs6vwGF/V53vWWt1hAb20uY1W16Vh5zh57ga -Ilet3cq8mOc1GOh29Yfv2rgXZCOcyvjxLOOS0nwYus891KUM4aW2x0EEBzwWS74I -VEcgoGOFzyi6QGoT8nWGLCfpzNow+7+Gr7Udm/y7vJZaq0JsYtiVECA0q53Gvcw5 -Qafc+ONxdQDuSWt8dRaYvHUjSyQsy/0ctIlMpDFAQQP3wxrbwm+uv3O3DAdBlrEu -PBc7jssuUdflTC8EJQGBDujVghIYqr8uJrSl4CAwUTBJa0VHKBKQ+yeXQDgiAyLp -ZGrk5J8txSBPM/X4oWKmdlhka+j9BT5spnBNMAcebvQdLW7jdWKd/qVsMR4z+kWx -QwRJkbkq0dpI76VPt8Dbppr5agFLVLRLVGE7yBVL6xzjtCA/p6TLvJy0XXCH2hug -SGt5GezBztFBobUwfG2774mv7hOVwtCP+OKyw4IfdGTe9v8sR7fkQk/MQQcQh/5p -7q87gJ4qr4Ytpw0pF0QnkhOVMVnDRIStNzy4Dpnv4aiDarg3uIfLfzccWFDdIJb+ -XXyN0T7xhbX22cNznbOTEsikq5F/PC4Qnet+1PWljuJahXmjMFDhPMsmC+v4R6UA -7lzhPtIxdFo0IX/BhTvLcztvvX/TUuT9zZoXyEmzafwhWjNeUaEU7KDzIf3jwRip -uDtOp4XzqJvQ+pvk/CLCz7X+ZAG+XJDoS/2groPIH7DozRgysIxRm90yhQ+qu/qB -2fc2DErHo7sttINw/+qD6HH1/223k8H7wSIdY4SiCTtbedli4ggI3Bny7o62Dqf6 -nv3v9uB2cwZeCQvYTcsAfMAhYZMfUeJFUL6pKxcI+pk3pab37CsWY7OGvtqldTJB -3c3vVl40F++nDPgAagQAAAx5kyOQtIRIx1F22klrXZYAfCFKOi4uLOGnGaTyh2J3 -plkJTFMSIkQwLvaaIxMWDSrmcgQwRyZM5qr/Rx7ToubA5vBdI0O672d/eZFX2Txv -byvjQq8CYgFtK+vbdGa2IQ+X2AUfXfYOYSuWPL+AMuibWhgE9+npy+8dvZW7iAUT -P8WBxZcN7RWnp5PerAyoNKnuQNAvvXH2LpGhP2O1XY6Npy7QzWfIgwqGg360fPZS -hHQJe94kbM01WwsvLHYqnDhrmmvzcpwZlJ0tKcz29IpIzzh1CP+CmZz1eTbMjIHh -CptV2BNQFaYx9f3BRfzRuh2IiZ2oSL94jzeBhWk1cQllH075Ia69810Iyv5OSibl -+qUY0eX9/eD2ruKLRK6QBXnKSxVFvBBxjxu8GvjMWmamErGV1vephnEg5HNrYyCL -z4Ra1lmVdgSvnuNonpahTq6tXiigwOYRYpprrmyN51H3FCP31WngW8TnX5GCObB+ -kjgIqh/aWczA8yYt3ikCSB69kMpOBnxhXquXSAf/H9X2MEXdyIiwOIbxoE1dNOVL -lYGqufOHpwyORVc5DnkJ114BcaE1s1x6XKdLBgyAX/3fqWcnrRSzRwcKXl8sa/Y1 -kAeHttE5HxvlAjIvHsCd1VDieIOgjqUEym9YicDPm/wkxYDTxt8ogIfCNf/0UTNI -8CIpX9LHVt99M0vJvnR8nfPlrNgY/peg7wsu6dl7D1tWxi6yfhXqbrJRMpbGiAcc -vMxyYJzQXCnZbXKBdIBMFUOoQ03se82M/VEesX3JXyT0B8M3u2mrtMxxEJy27Mw/ -ho7EuVCXf1es3ao27EgUkexmiiNuunQsmuMdixCQYk0JwyR2w7ZQU+4k8pwwQD/E -47MY9D3FStjGan2xfxvsElOAU01jnvR9lUHKS/M1X1nBT/2cJcFf2a6RAl50ac4i -9nCNXQ5kNYDmIAo55rME5GzPvzUwV7ITWMy+S6WpXgqGQw8r3XXTqWMEevRvJEiZ -5BoH15xtufGZPUdiX2InaVn/A/76/V3Ae6GckAGr4KZZz5nH8cvr7XAd3kFPJVGy -/QZ/rxXw2EX/iY2F4UMky/y+bxIpeaNN4fJ2Ai/tMPJEnvMq1Ow1ly/O+FnWxdav -sh/jZNXRZLRvhViIa6VQA/l5Hjje4T1Ug7ZjFsDG8BalB5E0zTtkSlNeWuIP12Kf -BMDbQHvunynAYDRD9BnYF4k6qeBpZDw7BHjS0LLCp7tkNL9tRI/feQNpFtG0CijL -WX8qjsZqdVbEjPZLcdxTd8si2NOFHGbtV3KYa0GOIBE2mx5+/eh5TOMq0OzP4wkc -kGEChAp+wqvEITlfxYyzicz9BVgHbclST9hylzSsDVwH+mgmy/b27q0HmLTC0jxg -oefbBrOt8PtPGWi5S2l516zJbi8bZwf6RNw4E61VvFkBxxlzD6WVsbF///PTDpuk -bBZeNVxv0VOGBhRNEunlil3SlSV99NKjwRMpbh2u2fwpbf0iXkisPAsWOS3vyWeM -orTzmkoUp12E0RaBmLX3UU6CVqmTPUtnLo46285FYO2nEr6lKSMg6Jb+F8Jvjsqi -5RUk8lpAfmxgIkrtDDeop9PVqteHBHk/SGc/f7bG8qfnumVWWyMnzhTJFpGkthSP -RgPwZOVtxig41liQ6dlIULncULfuULQBJLanjtn9l77eB5D7sFgQRTIa4pM3+wp7 -OsprdTWb4LLD2q44b81l6167U5nhgmTexee2tqyS14t09I1RXvD9yzCrxGzQeV5f -Z2mqcKKjz7mhelQqBxhoi0/SSNVli3yZsEPQmdL5KHoX9m6PTbXjNgFWDB/XUz1k -6XElG6vwws1M+t5z2qvwptKhQyvxAqifcCDNq80vYwh5m6bORcZprMVS5/pdFU4G -OlEcNXPNGt/eDBLzvegkhnD05UGym1ZxZnY0zygpNG3MucYhRnB1awr/d9UbwLtc -aZpuXSJs9umO2pVFRqndVQcPcP5VyhS9HmbiMbaOALzTgbV6ed2Fnjl8I2CbhpFv -6q0YtrHir95OkdJe/RedX1lBBW/weCUlP5hgujVhNwBsNTtlkTlrFLRLKVIUVeNG -wtCQLHq9WLqSQcS3OaqY26GMMpBUfJ9fa38isDXwe7r7oF2e3xDKpWzrIy7h7N1B -rf24xhn40GqdZqIAnXrEXNzUFlwUWZn/ggXsYOoxlI1Vd5rrKmWviYKmZx6e5/6f -bRi2oo7/hIc7f0GvMcQ84lnm7ae2gt/cChY6cRZEXCNlnNiDoMs1xqDs/4L+o4aT -a0EEVCG6sBNYXp6FuW3FRGvh2BzzwZTEAszQNXj12g3LoFFNTZE21bCzueE0hn0B -Xer4SQEJIglAq3qXIzUboFC5pvNfColrENc7HAcAllfI8vcZoJ7k4Ze6rEgnABAG -ujVaqEikwgHNhQnoiFm9mYi3yoOHWcS3SzpFKOi6rciWSgoEE7K2+wg6GPIhylGd -WK+aRORDnXI+2ObEGnvuk9T3VXs4NLbrtGDfKBn72RE7nhXWFC1lVeD35g5p0G+C -mdBromhxbrXEBvu3Hca/YcV9TvkzEAGvEYIZb4v6U7UmnMI0ePxoM/fxIiKjO7ZU -ZjfllADGCkGW/lpqtWpnutuVYbIWjCtK0uw1nv7QZbqSEkrPvobT8A2oUf9UkRI4 -ucQ3olbJ5tTWg4x7eXz7LI7IEyMQO++AGJ9fxcCdtxy1IJiKxuM+gN7E1KXwjdRB -lxEZZUv7+6gDZQYysw7Xde0Srus2KZXJ4+xHjcrYagjHWmCUNxwXhbDA4X+SHUpc -qZV5gvBtuFqQlSvfpaq8ggKBGmag+X01fGyYpnhIPiAKRZIifovbTohmLlopH+In -vB5BlVexBTm6Dwh1Pl147udyfL5cLBf57ZHi62gQjZ+8dTrEuDgg/LsJsacISJzr -1hqtIO3YaK1kZAy1TR2O/1g9G6SS61bCw9kNgO7SmOw5wW4psk0GVgHGmOBhBJsz -kNf0HOIcT3Q2Rpgxo9BefdYvTDIEHLGFTocmUpvsYrDgziu616I4jofqevdu5iE7 -phsoL3XKu0LZeWjVLSkpGTH86Ni68pcdxfbG3XGvCuBmYt+8S60VMiLcv5Dzma2J -hpZL0A15W8C0XG6VkSK3lFYfgLPt4pLgYAAri4PHvyeFvGy74Swetwty0Ha0OKRW -7sggX6Zjr259j4d3kvLpRE9m0C/cPKB2fwydCgH84RESOj7aCSIX1p5kntvEI/ah -9z2ySO6zjkleBjfTomeQUFVwAuHkPeR6iUiXFgvrqkrKS0MaI+YpP28jGIItqrqB -WCppI2QxyRg36rYa0ZSFdv0X5pzTLIqIyV+GBck1wa/2hMKnWJWPNg575Km0BeoS -98XvrkuTr93xVopq52X2Ia/2x8WHiRoaEAnBirNR95iPLIjD6F6qEX4JdSheYOJZ -+hKhEWvU1CC6ng1Vlm8OUCNgTRFR2OXfrq1JmvzxXRvVXEJDQ1w8ad94ILjaqO0V -s/fm8SSYIiXz7UaQ6kz5UMUEuI/JrLI52TnwZw34bYh/UUxL762FAr7tH9V574JV -oeLT5JuJ5Z6MalJU77Qgf7Igtd2V4tZn6tEXfdoP+ho5gA1VjclC0rdOS+i1+OW8 -1Gg2mwc5HlZNgyysAegGzSzgYRZj8Sy9yJ6S3la4sxMKVtr0/7mALk7KCkcXtQeb -+2eVPTGbZvBgZypPu5kyO9AHmw3LF34BLWmo/mbmu9UfEd2wNVEI+OknHQdt4h++ -qvqBDouvryXeYi5YHNhb6Q9S/2mNWO6yKv0W0Hvu9dCycZd7/M5eGEI8d9nUiKi/ -e4p/Ov2F09jlNuMO0j/czJSIR/cAiqJys5kDL+WHg5b377h1lTzNF6IXg+pMOpbR -XaJV4SdtYc7oEHoROF6W2IqbA+/Xu0FreDQy1tTwMUQLVs9VphseFm18PSGAimrn -6bfyzqLp8AhAxzmqEoMKFTUv50NO3XTM9tgoJs8KGU5U6g6Q7XNYq8qSDpE4SpDq -y82JUpIIx1dUiPTaSoodQRsjcG8DAX+xAG4+g9NPYOYWJutbjZnGBpRHRUei3jEE -A0wO1x8Tf1GVHtrACpYF95XpsV7FosIU/FyTW8MprcdBJv0KBhWye18J0Pie6G5L -YpgUVqGLLNJXoISk0fm57FeaOEWoqrkpbV0Tm5YzdjRfhTuwwKxDpm7Y1TpLVn9V -Uudc7G4Hhm9V2zwP/RlEx+QM4EddS8CwBklxeVIwRZeu1/4VxgT9I0fDXwH5v9br -i82x00Pt8920Mc3TEskiUd8n+BBXJzwDPkvXX57jRleDwiARjkE7y3WXy3CdogBu -26IlTMc2FCAPQ6K17lD+TQVZkyMUvVOQKjyhqzJ/PuFjt5fgXM4ueM3jAdY0WqVr -lvQIjUR+oWcNnYJnndFSqLiM2sihbeV+yn6DF5T+IL91I9B6MtmqQs1kR9VAq/uj -01H1uo3AdzycO0o11mpR/UNP1qjyArldBCPYWqiEAB+0Onjos5xEIlBQgvNiZMVa -gN6vg0rqcw+mmES/W9MrBqJDmGgYfckuFA4JGr2J/LEPAGpZgqFQ28C8jAN9rCX0 -1gcWwbDBSQvQjFGiggU+NotxPIZFMGvbF8CnjAnaXSVaVu7adoYsbAKaHm2AiP5y -mQwDumv+ZYzJBUbpFAzAUTqEpisA4oDH/3f8XkvWGO/cUZcLokBhQVI1YyVKsTNb -ZvoiJt9A3ZStucF48VznlIPE5YxoxFxPFsqY8zpt0NLN+U+i5zcjUZHDU7tKKrD1 -gho7KAjwBldEXYJXocKAkEI4STe4WiskgPsyTnBnQ2UtvOTYA4WJYOz1J1aj/73q -MjxDNZSd0l4l64fxQpasWi9z2TJfNabYrpgiqjeD1StwHjCN+yZuRlFECDxecrJ6 -gOKUC/ODDZZcyu7stQ3Vmq1XdIjz9mqH/TIeqDoqnQg77Tvgh9izzUQoRz2zcMUc -V3h4RQPx39mpp+Qf9HSzkOyoBnxGnp+koajm2g9nIRd/KJZejrwNdkkhXfiUhnZH -iee4KVYSn7f3/M9kBFDQsX/TlmF5cHzJ9Drn7qe3xEb9Go5WxUwKBPmmM7NOsF4T -B05PJVbk3NtxdUls7zk6iBRfN/pTEwiLEEmsegKSGuz54rTRLK4VEoBthRCeZbEd -Ea0J0DEmYGy9hpB8y6UHp0TI+ioGtX8tm5UKw8Pr1c/P0ESkKIOuz7wVFzzejUDs -rSgiGbwabgvA8kPyXyaA1TepYqzTClJgD1XsTuryU8wm1s1WOwsWuiJFHNPePjJM -LkK2D2kuczGJCB2bVLZTkqJUtQzykxKB8aNyc6m35yRe4MjyK/TEakSfIwUNh5Fo -ROurAFrSEYrAGWezXTgFqEMN6x290+RrngQlyNnR/Mvtwaoovcu7J3c0HHzgULe4 -vk4OgSJm9yRA6VbIrbYZMvChgvZzz0WvRsSiODqG3dsjcYbYMGh9c98ggjGjYBG5 -RBGtsbwhf41rLZo8V/IQZAKLEUfHsrckY+tOj9fGrcKs2FWW9qPi6bi5ngdsoY2i -YWgS1G6vPjeVJX3jBOMeQZkxmlTXPLbs9Q2ulEqcSuLdZlXna2+0kW6nRfxGe2Ph -OTS2qp7FeVhknHi2VJEMVtkL5YHPg5LK5mJB4PNHUELYq6yZUhguZUQ6MSKNCzgM -56rnH9Jg7z+7zN7QSrioYZR2bOJ4otLYgf/MxPP/rmjLX8JO5YsoxfRc3UAE54aT -On4NP6vyZauJxf4DxWpt05Jwx67vrvtzyVdabHGFKgD5S1QIz1wMPdvrs5JF5h1N -OLRrEl+CLHY1WdmXM0nFTBbkBHN2JFX+hUjDTDYbo+ECkSJycAPcrJ5lh0hSLjwC -Li4vRI07UkZukRksiauLnOWyatIBrDtacBXptLmrwrajm1oi8eVm6u2BXAezqfH+ -BVEGUTsL2wRZt+edH/NvlNW0HwKbVuKz7MzNu+pjuXO/9TPQL0B3Oyn9ZmP6zHdu -RoCsiMrKXPG6O9/DtyRBav5A/ASwEfMQiCI5Ho6T3mG59+lld50JiVAmOJkDx4L4 -BviVPjDq5W6i3Svp9j4aHliy7t6LMEWaqaYjGpUxFpRGh0gKlR9pVm4S5RBOWnXz -1tAIZifrZK+Z3aw/MA7qhqncCHh2ATfSw81VoXQQTFYxRNdp8EzHaxeg+oaI/5vs -2HB8Qs7zH3uXq4tBwZgy0HYFRs/H8zVQuUb0NvtpC6EMdaCHUilKlRLZc/EdFXYq -CzkNW2gyoTVw4QXqje1RVuI0yVx06rO5MV2+weHu95MEXsqkTHZt1hL+Qm44dQQL -I9QenyNGIWRc+NTyCpcwwSM/a6l4ybvAaHT+0sETu6PTsFmI1rawzteYJegezfAb -bWjo2mEYXGBqVVM4+bM63TpDD74D6tlA0spO9iR2spDqreMzKLO29nXU3hRx0qTh -wLxWVR0bc56s37j3n1YNvQMHHpWP6GwMc4I3xkYdFiqQeAcsdKQo6lYxrSLT/f7H -amduryTdJ2KyxojF/aLeEFe4gfzcsI2l6KrArtsliZl8agf4mry94NLYnZceGvNq -6c34lZVChjhEJE8rwywbDYQVmruHSOTe/xDbf0qhqUK7++2DEk8qz2vEM96nTQHI -/ev9pZkpFFhSb/H3uC8nOtDfcNE+ZbchdQxBjwKxoIl00mYYBo9T8bfkCuD0y3J4 -rtpo0Z8k7vZYBNEaCIzdgI8JejXPpQZkCRL+TK1LCaTP+i4Js9BonmCT2E0pVF+s -kwk546I7nFECdJLeyESd6PE8KjMOalII3nMipwzkud+jhILIKE/xI93ZDFn0Ys/D -hRG7Tf8pGeQKPC2nc6YEB5StyIkWQYjnxljJ/PrGCVsTs3QbSN94qIWJXq4RSdGs -pfPP+Tm7F8tRE8QmaIXd9HDsr1sSxk/2ToUGYEBznHrw5iDQRmB+GcE3j1Pv23VH -WQlVzLTNKKacfVcKy4VShmXWBebcVjvzko8uWVU6Hk4TCcOP80dEKsUyv8g+fxAX -ENf9VY6d3j4oSGK3YwsbUWRikOwG3sgdXfsUeQFk07NbEAkuDUNYeh2HCrxLtyi1 -mwskzJiS4z5pw4wMaLTWAkBFGqP5HG8WbOeeNAL7zCJCWac10PF8+1FsRzyjV3hZ -K+oHNxcCwUuUeYgbxrEFcfV/qMFc3zVUqlxcUrj5FQLaj6V87P8Aquix4+ITwau0 -v149nOWV7OYVZXDKoJjk9uy43JPkRQTePVO6rnk6UivL0jMEN45LqHnUOorox86j -DaaTrkFrfgZatMJ5jqBrPp9t0g8EZuLy8sWhQmp6A4yT3/zllplAJP1qyuzMTF1d -Tncfx5y75Bt5RcZE3MfTa/LoVZTwFm3sk9mwrwRFq1WuXDPbubYLEFW6N2SeyS8Q -FE/34i/Hyn6c673VeNz+u777+6Vc0J6SCnuHBoKA9AVfGT1oJbPcgS7UMmxIMKU+ -9MdRombPcaOx1c59smSjGVoBqG/LXO30Zu+pHbKS5UQ7BSSz0eJPcbHya3oxrZdR -0y27cJ2c1foXA3VwQHx4PCjHZZEXQv3kxaDKnqbTzxYJtNN3W4ADlghS4G6bEZtC -lz4uV0304sdxgxgyMeg+BbDNLqkvYMxUR0YGHzuojnkVY0KMfZP12PqkCH4Mdw17 -64SxlgU2hHXL9/rJQRx94QAbXA9222B4iSoudGDvKIzYKL46Xa6ep0/hvBFP8TB1 -M4YijF/SWMzRK+TGNL/MYF6LSQ7nCK3xhURDrtGzh+zgao+CfvlUYGI0tU3VzLJZ -+giZsP8gvsgFLDIMiQTF5VmMMOgZ7RbgXe1k8qRDcozNUwMY756/XpEGYTsoWT+z -gDsrfGm9CqehjOEQiQZ9lxsTmwEK/m7U5EfOTx67Xz3oCJu8kR4PtNfy5C6ABEJC -c1Ut3z+8sWaqJAiOtnIk0vv9N4nwjtC6LjwNly/ffVN2GWonZoI3fFg5sEORoZEP -zGAqr22iEW+ICKKMq4jr9eBcmrVZIXjH04iknRJe199QsvTIkjAs3uHkPKjBj3+j -kyR6bZQWsGwM9of9Dg1i1EskOOVafQYYy+6HdzgmEP3mTFOI6xmh2iWahrnxRZU+ -TiAYMyLNfXuwV/az3UqLeSWUiFr+cdtR9kk/jSv5+HfjydLeHMS3ehyAi4LJs5ZL -fxXMiiBolSYrjYcG4Gcfpaslm2fmkcPi0eb3V1luuJKjULHbbAxgFrxh3eKsEl70 -+ZuntqFZJSpRrG2OSnbMjNVPd2fwJndh2sLxUFOw2LeHRiK3zsjarN8CtzvBjgVf -uH14AaljEKuV8NZPalFib/vOD24QeACarrdrV5UOnDyLpBkrpvvyKImheWvg2arO -+DRcVU5cHOX+U4C+CPKDSbPPYpj+/t5J0V1FYkkLmBS6ilBG0/ZRdgthfaHo5+K1 -VdW0xYAjU6yQWoW14GdJT2aVwq5fJhC8ITobUg0L48075fGXC8XPX4i+jo+DRxSI -DUD6BcDQjYJx4VIB5VuxFxbs51fuwkr6mZWYy0FSVTJRVKGlFnHofVqm84y8S5XY -X1rz4Krk0IkCdItjM8adfIssyHtmS/Y7TXMmpGxE9Q2/ukob61XH2HDBngo+tvf5 -I7G1E7bbJeNxmYNfti1bSY8Se3UTpyNUM7wre5m20hT0fiN/NOd/hoKtXj2N/6NJ -ig4IxgcW6R1GU7bexLGLjtS8ij+w8rFKuLmVj1KQXHfrEmt1HcpPMk6CscaBpDQt -YQO6FvgtdRR2ZWJycNz2/brsDbR6SBF2HeQL/W0wjxPqH3eJFG5ZleoI1qg/mGkS -OVGtQy2cXr9UUVpHdacDyGFqiKc8zLVs2NgajoypB2bIyyKj7OYyNWDON4cwAove -ohlxFiHY/Ry2v9lPccYAEJSQyWXc9bYHbD/QTQYpqW0EtqKO4vFEj+p+A1/gvNrk -t7yc5fponXxDrzSYK60TU0/JtARMfLsKYJ8XiaUzMfMW0ci4TZ+Js88qaRE4a32G -xf6JBHR6+zAxiHFzlrbNFPslrfxFo3AoZiyLlbJ2IKSRUf+naNLEENq3sAmRpHjl -ZbGbuzKYPDQ03eHu6mMzmHQLV63UJXnznewkH+GNYw2lgFUIyBmYmoXJAaL2gn+4 -lyToRgLJpGK6LkBVCJmmIueFm2rDw8eXW3P1YlR5kMH+p3qL2BVqNiur2kkHu4Qt -YhBFXVdiO7jHSu6CWTrPjIAX0cRZz2fiOjxBVs3f66Ym0xpn/c8dVZas+VZBpJIi -F/t0YlhqXIVL+s4PCCNS0AbewqSleuGoC9hTVOnpWGGxsur5gS5THUZIYUwZgZo8 -IJzh1+lff1haf1fYnLTo18wtbAeVEwKhlhe6UXW+m0IWkjk8uE4bVPtt3Qh5uXq2 -wpDstBi8rk6YV/ezP2u87ZNwX8SlzUPvxxCRGOn0wdzwuaUK/bCUigq5i6aHrvnt -nQS2FzzlH1d1h888pUCmqrjcZB8H29eCn/evTyWS6eB7SSrj/lW3Yi0upY9a3tAh -5I0RWXDfDE65qCrU9dap5CEO53orf4Deb/3a5n0ZeW5bbj62GesJXn7qwQ+G2tOs -OuINUlJs3WICF2260+zOpi08rMDV2GXwiivVQ0RmBcaME6g459+DKOEbhPFf8ABe -HeBskz2ymE/1EtHfeB2RBQe8S0EJx9/n4VWuR61RusO5bbSsEKO7eQI0DCtV1NMz -zNxGedl9KNf223tojILVkf52iv6aKyeJrMI94U/q3XOW57D+I6HCFs0yalWrk7wP -3vJzJ9w+Z3dwrzEyy4JDH7uz934N8P/dBt8WnphcJnLezze+gUtEqKIfE2u3hqv6 -Azi9G23v+gYmvnQTk4sqffDFweR+lvVRRp02sGOi91STnKzoWak3cA3Nb1bpukNp -hF63kZYhY50oSrmyTgnFE6QK3X4YHGqNp0hUT4hKAb99aO5n05bjnpVwP3DC0tPz -hmqYavZXZCMqlQW/tSao26B/u296hAHwONogjXCydaIe8gFTP+tJ/qkPDxRIbpPH -cT/jliBz22cQ5YoP3966d8xNfKphWlXichjsguwcLIq1Gt1TnKwe9xdWeVWNyTe9 -ieLQx+8T1CC/QXDH9g7zdhTqOcaz2ceZHjsBffIq4WHD7LOAwdbSABloxiqZyXvJ -GUSG5hv8CVAzH73OMAS0pl4Om5OmBmwqmGqfFbcmqfxaJ2K7ALYQX2Y/ivDgzF2C -ZLdi2/oEnc4TIVVoj/LwH8wgimjYuWujY384tQk9txFZRXnr5JorEimM4tPxD8Bn -YVAWQdj0OpNmvTNtL8px6IN+3fs1be1WPb/ZVW6Nw3a6ealN3ucca26jOMu/Jszx -1ue47+2hUy2DM1Sm6ok2Fo5Zk0IpREvo+/qq11KsOlE9c+f6UQ9sAZGN8oKis12J -Awe/JgAdGtHcrH3gY0T0gF4ZbWGtuaLmT2CtAjp/oTA1l7kmDYYPaOM5AqHlLxZR -VyYl0jf3mnktmDBX9kPUOZMMghyDeDLLvjFR1TQhm8UjBMAcdIaIuLBfA+zxXzzA -N2AOPFwh1awHtqJaXGyqY4/Pf+ZpKja4F0AS4T36TA2xE6f8tBkcz5BARnjjtavg -4vqKYzDwNB9n2uc2L94ktaM1MoRW5bdsBvzhlMw32mGRrhOnpn4J/iRpZEsfalLu -02BsUxAeEtU0ba0FiTYju0O/dqKYeYqe7uVBMgkfuac5Vb6Yzk3oedpYLMwzC//T -gPnAU9wdBcOWdctqnGktJSvV/E7ho0adXBbz5YRZkdft4SIeJWhEcnjxMSLDfs01 -s/0EcNRPgntAPwGP6i5hCwuHVngkicViGxzX2tJGVNh4+NE0zblxiihw2SUxXrb9 -Tp3vT/Ky1SWfrBBxnNOV9sBa6jT7FOrUpjerqPOLyYtJRXlFTYXlj1YFQiL/jMfI -KqGXDi3/s65eWWJLYIMIAagqH4CoVV7BQVXsie6c0Q+9N1RnU+w/u1r2VDuTI6D+ -LGZO/cVq6WpnDX/KCSwn2fK6RLuTZaRpcaiXy8XZPysXOcbmA6SgiWpfA+JBauQE -YiL4FaIJGKLJlfqRorFwnfffZn0fjgemiYV0YCqssX/AXuqGB1Pch0DvU1te2w2J -JNS2ITBZozMEXbfBHQEN9PLoEEoOVT3T1nTda48t474tKUuFoAHpwquT+BvQrHZW -ILjfaa8xKwmqVHM+qOVVq+b2h7nCMez8dQTAyjwRvps2/dR4+RobsNVIaAQML3BG -Jj+RxLZIu7/FDJf97yIGD7RO5Eb1/hzepkbp11sHmy7xT0a3LxK1wVKfnvnl37as -MGaBesblJvziXbqtBIU9Lqte9GxAXs3qANvWTczNg5pE0aNahKUNKfhJ/qIuzW29 -CHv3ccxD8MzwzUpxzshe0/sfIUxHiR3RbQQRxOs3cnuaIX1wuv1PInbkIMUBDYn0 -aeDjeHrSETVrVRmZWlK5wtra+bAqB6CZtGfpHNuWu0y08I0RK7uimNlhoms3H4fM -2KG6i1AR31eD1s4z0Ej+pnRVVv/UbRjSU24jMVpNriiQj8gpbWGEsQgylVyFekJZ -xirIv9RdrY0u8AIVg0kMwjO9UxDp4Vv1J80qCBk29xoKZGIC8uN3OPxL36ux/lkZ -DC9fLqZZPtyxDzDv+2yMnuzcE1eTXa/RmWkt5OyD/vx/oEXwfqcLOBdhuaUK6afF -oLSzAaazu7jUnmXJEHoFeFdTf2mCqebjQ+2nCy2IjSe5s7zcShBErcoene/JsdTb -8yZKctemm0mMfD43jdvV+ic6sNPF43B4j0Aku/uqP5Jp30i8ED1x3thrvO67gfv/ -6FU+9qAq0M8zrf9N2ddueqUPoriykKY4M6G0cRFLPox2DuVHlyyX8gFqubPIgHYJ -E46IvqpVgGLxOYWjqa2nRAMtndEXuFtkcmb63gjH9ICUnQUgO9y7RhZ+IB+D6TFg -WUoZVX5e8j9iWy6fSZOvICZ/taymMosGMMnxkp0UtpSLeyzHB8ngcYD5huU1FpdJ -9th/3eiBU+ZcQwqQmfecujVvdndAmVieNE3TTAN5HHbHe7EfK3H3indYO888H5By -zsnBkhAcWKthc7s1m5j08X+XiujdPeEZNponGN3sO+Yn7Wq2/qepI/5Pl/rCtDA1 -XF1NjhDEArrXtzj51mTt/JM0MnhFjH/3JDsncPpehXDACsfPHHslCL/zB5vpmKUL -V/KcYRpYDKk3AuZGLu/jIDieF3qZuJ8235PgMXzvq8F8MEYDtKjKJ2ZFnf6sztR4 -MsZTB4VhDGPNfnVGg8snqGgvhYjNgbgeRFHnP/LB5Nc0g22FAwVPSvGoqvNEwNFZ -dW7G45vJyX5QQR+IuuoLCDRFWd8JWhbys7oGWcxgYNT5A7LGaCX+9xpo3TB/XNzy -uBNh4KdqGc9137Mn+mJg5i4LhyK4wBhKmJ9flzcu8EN34MVkOXUoB09Ks5RErEF3 -/5IfaXMAhzbswUoQYVt9fR+UR0NFg+Uudn8K1uxJUWqvp6vmo+eyRZmPt0Et1Eac -WMgrydt7WZc5+kcS9+mRCj6F8czdQL97RYvWEZiReiUSd8YP0DonuZWqdgicuT4g -Of4o3MVEKmUXbW8MzRTMDmpZfoRStP2J+4a75uc6U4irOnkgBHn9gKeTM5rfdkA1 -CjfemLyB/xDBKGudW2coFqLL3R4yyAKEmRPYwUMSwUz9WCBO+UBnk4+DjQ3LZfba -s4/1+il7hJB3dzJ1E/w5yr7swlAdoP/Teb2RUz8Cj/eEqhOGSDZlOVCtQEZ7r+he -W81dA7WKvBgsuzvTU7EoZK933RLk/AVkk/Hr9dVRCu9hCOnYs9bPehrw3ln/xgxo -G3UgfgIe0U6l/cO5SHyC7sG1n4wOntxvlPmDhgUTtUm05Opvcf9SZTjrhSumZDpu -9cnO6CFJc/WFCkw31SjMI6+uULLOx9h8apIS584hleESnpXemjQ+SlJe4wMX5p4D -y3LrqcI66TlpwAgM5iE7BLagpTVnX9vYIkxRarPWaFMkRGraQAeFVpaP5xNp5zZ1 -195hCNFE1tosmpjkq5AvhSimUoyV9otxsB/RzOW3JMftNbSQQuwYYWa61D1xNRGF -iaD3XJoPl8LIMKDBx7HHj+1Xx2n+QsBuuan2tU0yD6mslX7H1MKk5odyTy6ozDTQ -s3gJgophzwbz4NTD+JaRc+kOWyZblS3eHG2T/Ab+/nXY6QBAXOUp4+Dc0Uufp1kn -3HrXqw9kU/gWQ6EZhmR7BXgxPuv19Np5UUP20SQSDO+CmlBg8WKwiA9PPeiF1SGg -tYsc0NCE5IDM9RG78dBMZCbgpgp8mdpXNRsJuMQcZIUPjIdUKtH1E9fueazYiRmF -HUn3zKQViX158lb2L68zala2ucik2yroMklDMLjItvWBMTa4UwC0rWarvap9h1fb -gvQCVz6QuqpjsXOGhcaxTKtEZTA2V/zXoR0SVlzNta5QQGzK5ORO2vbL2mIlAn2I -EgPk2bwqEODXtUyhWlfM2ZimfqmaeC3Ca9T75098wx0hGUw33AS2ccFi35zxNSTX -J5NYHlLhaOSIQY96crJOUMYMqqBdcA6jB5F7kKnSA0rKLFGmzEMwjk5FbtzDJ2UB -JdBd6EBZ4A4vnvtVI+URaUfYat+3JXaNl0N5CNlti8bDEhYP6UEEdgvSx7ZZ3B8P -0OC/wQmfcFP8slLb35AyNAUFIRo01Kh+Ri5p3iGHVcWscFL5/AQCvGnUTN5NoRsV -Q2HAAFZ4YHGWaMFAqwZRI5wmpfrGijrvMZl9etwm3p5stI99oJLBYLLbZ9/UMSNL -is+wfBCvtXyAn3vnHg2bX5T8mE410rocaVByuwVgdFlHNhmRMfm2vgEo02GQ3qKp -7V2kY/KmaEnBZE182JNBWrHMRvV3VGCOVzP/s9WdETLmUizMRINVWVNuIJXAj4+b -l9d/QHxdTbJDewxmPdbyNXEBqLFwGgpHmMOXSrP/40Irex6OXgfnbvaTzrqRRCYh -3zmYvNXRY0lSBPeLTBMLpeZsgzKv8BBGno1ZuZ4jomtfUkBUCBClTgBauDghVibS -xlTCUBENVtfK3yYJlw34JYa1zRh59JDBYBUgPUGeMqr8xOE0jo/dGiiIpUno86YK -k1lqdeKWpi90wMPnXoRQV9yUErhDfSeKu3B6AhN5cnk0b/mDp5bgAWHwKbKe3v9S -+jzW8dqGFTHlIBXl7Rv7QMhJjK4R4TZZiC8bDGTgAZ8Ju5xcSRQK569n1WmloqYd -zxfkiwAGlJ/He2xtbjOIQs5QAA8HGFro+yPYmvhuKsaoU5pxQszFkcaEPbP0SRtS -WKnjlJzYADQn9XaJmgBg7464Emp4qQwxuH1RPLdquJbUupp6zkmK2rqAeKVx93Ea -pFFknPMJUcD6kmQiNuhiTXVKmpgZ+8d6uStV/ONTSVrBIjo0RKq5MbAk3mtMhwha -ETCnB22EaSUauGpTAQ3rBeL5hQTuLLEn3E/Wz7E27mpJrF/1yHbiTc/tqcA7TzMi -g1EyeoZUEqM4/0TJZZSxXV64mJU4+A/jwilHLtXXOvFrpmxcQ4CoyAx8p4WQabuM -F9Mlo01haRJL01gTkKERlG+EzuJ/JIQAScmAmBRxK4XiZYMpd18WoNSzWfyDWXK1 -oujBN84l3esanFMlZz224zviUaZXkdBJmMZaecZwuMCm4f6N5WwplnlCKE0Oforn -D7VjqiP0Tkqd+OrXB7pE1pPCXv6hKYSltKZ20X4mafQFoy4FoFsqcpff+N5A+8wo -KF0cLS9ror+oLhmHbU4J+SPX8D+gn15VE6uf0H6eQ2AxJWr0zA1vMdqDA8W26oGB -olkk/blgYBXzZ6ImuOaaF1iyY16gOqaroVHchlS/8XhPmwSS0CKRc7MEwnFeCkhT -itmmNhehciBqhMOXWddPYliPR9fd4QYHHka7M9kEhymu1fIpMEk4sDK1jTAOd2Bd -IzLzZ466vrDzz8VgUkoOJ0y79twjzKcv40j1jMk3yJQwkoL7o0hw2c/eUOHJ6eGR -N4o46Zij+7XoaF9bPIx90mSXmQYr5qBcLVtiAeQu+Gxuw1ymS3tZLVKK7eezcqtG -iBPHjh4KhYll0EtCRk3BXs1unGg2BY555VRoWjxwmFGzOicuMJJwc4ZpgXU+gs8e -0D80W+V71CPQHzlMlIQGQBX1N95pibHk31v1S04iXzgJo/gPSx5u8V+LvbghJyb+ -Bv4enUugvusaFQ4edTle/m+JmeMYnL1YHja9058KuHpGq+qTKSxQ/0jb5npaO4g1 -K/uIS5R8+Rn/tzCVgx38nAXs5Uz6HIbou8jXvn+0AoozJICTyAO4VFrjmwpzhaeA -9nYsnbYaJARDIgCeGTb0hmNRT66S28XCq99ETeU56L7dr37wtH1S2ZASTIggE5kQ -xP0KpRctB7MJxIqfVkrG1GTwy8bBzB+5xl9HdsuDT5dUrekISnxa9wMWGnXixGGS -Bj1YvbaDuMDSf6lLeGXA4IiWXHojAiZ8EdwVigdQZSwtWb+DYe9JxxFddfmZ5RDL -6ApYEzBDId1fQfT/4ojELbNA53NxDAHyLEQlNjpXt5GrH5ErCtwXTB59IenvJXfa -hS932OpsQzM1RI4CY39XXa44nVSMZQehGj8qZ+v+i1fVveFwJkQSY3IekPWH6WUI -nk3mC20s6fe9Kmf+/KinxOzYE47RE0825+dJiogYkfgkifz93QrhFbwCFAB4THWu -6eyhAwztxY+YDXC/00EzBAYEvzt6S0lRzZ7T1yCP9M9fH/x7zfAFp6UoKow734AG -sYqN4hGWzpaTHxFGazdhBSzWsls1A93r3Vn9naLG0L2R3OUVZ1VNUWcpno1tVbo3 -zZM0I272DQ/dOef4DAwwUhgbMaqgMr2rcPgpLapod/mpJhcUNCD09RexgqQ3At/W -VA2Hz4yAKVQsSXHL8lWKDq79jPsNb9/dAH1EVbbEY2LIAPn5GSINjwF/nuD01mKR -7maDxFuGN+M/1A7Fwk9jgsvbhnEQBGtnYetKZwrOZhAyksukydV4FgsZWqolh7GI -SedXCoaxvXAfUn37UFsfEZn+Bi7GQlP3qpTKn5Ly4aYf5u2qLChpkQrnD/opFM6W -ZhtT9gb5/dr91Cz8jbGASykkfKTBrQl7P+NVPgYSOwGROBkRTBNNJC00XeRZZ+Ka -xeNWA0TpE9bqp4Wp5nXSl035XZi0hVEVuB1wedIIpFi6ZkUuPEVuOyhKiwlSwMIs -v5WWNgK21GybYg3IIJmiup/8pNrlEBpFYBqDxhzaz/jjnnKnzqu3vkk6yQ8nuXZ5 -oCylb9JwZO9/Lf1Mmi5xx3lCB8FRkxTFlOKZQGiME8/vPxWTsiOJ9qjjL4R/P2Lg -GL3Ik0T0OguwHmIOwrSxPxPeD9uogYvUnj0nSso63iwQtUgsAsnA/OVFGp1KnrSf -eh+je0i9sAtACY/NPc/h5K4OTLnWogZmgNo/vnwdB0fzYuu8zDOn55Cs30IEjbPe -ZCpz5bSi1uGsOEX2tlM5vyR8xiV6duo3hQMOy6odgIy59LLLCQBI05BWQu4N2mkv -LL3HC78AVdPIbOOUlVXYiaafSmfOnMOcEz1KYy+pOhX9EOonVx9g+pM1ZrF/8CBo -5OxbGKSWH3LFXCw8mTdLJNf3RwIE3ig1AguJZ4Bh6N6MhN426MxtHqYP+NprbGud -AQsyoRLD9ogI/zFJdjNKNtRl/2pZlYoellQE2qMzbu8LbyRoS9ao0kLmG2dThl37 -uNOwbnQ87U0nnlR5KuGZfzUSZ4rfZ3+WbNXY3oov1Xq4TW7/e6gQv5hMQ5191nyA -gSGFJj3/VxsS8dsjWHGpZd0K8fI5Hq7eA330JJ0NevBwd2hyjnKveL06dVVk4ZBL -nvBgNYOhWFdCeBmtiTczoo1kkVGkWJX0443pfDibqhVWD1+tRPJ0iAgOblneUwC/ -VH15Zu2838+1hZSy0U8/Dg7f1XJKXU1ap3w4WE4E/8gbczf6pG3BygSufswoVWUa -1/47B9Xaob1nNLWkuAE9zSbwjhlOKyxe/Lo0vxcVrIk6GvaEv9QSyJqlelRUcYJm -eFmc4Ix7CNakXwaTun17cMEa90e22PjdeonE7WaQxm4G+5k5cO1U/5qk4ZB9R/+H -tnVYfgWcRI9MjhkrfW8jC56YM0Tez8Yigv/y6NaIbSEkTtNCB5Vkhwaoay4FrEfM -9cJMf6b/0dz7ePWaokDmr37aqzxkYmd7G/ow+J5tPDYRpUKN1w0K6FSTjxpRyEln -5Gtu3FK2rb6/6qAWDNhu/VruoeX0k2GkG56C+UMBDdo+0tjHVLrdRLT7g1Fg6nBz -pMiFsWede82q4P7EXscgYWdeddYnKDIVdNgu1RDfQUZFEUZDWxkCOSDae+ppr2G/ -p2y6bSdK6BHKvulNurI4+UV2UWyINjJApvvdqPE2mzsPWYwTouNfuz+z7lRxDodv -6P5GEaHpi+eJfCmVs24hKEkOWojqgi/oE+ODlleH5mmm0b/P8UCd3c5JwMaUOIsW -1lhLIUdhIKcNyKt55oQ3FPv2BiygmfgK2oyeg6R7aA/aFSbHdytVoEaat4rrCmWz -npHOYKFKtf+rButmGo6hLYXq31egJP28iifqam5Yzp86pmP0FEDqlMvEgNyu4acU -RlPiCOkbxyaiSefle6Pwgug8VzsAWHeA74Y4fYKRcfaGe2A890iWbtEvnNnZfbwi -WbhFzIxbaPgLlZ0lr79OdihDQlHjzTMy5/GO6m4OO39UfWpAU/mMVmtS7N3zzq3p -+uKmhz2n+zZ2qR9jYRKyMgTDvOfxKWAiSRZzxOqcpROrauvpnjm8+C9685Ouf6oT -7LJvidAqxkEAcYc0tCKbb+IbC/BlYr92B7fupAL6COW9nCGWhOdEVo9rcj0A6Wnt -zqc09baTaCoXzp8Gb7TEjvidxbvCeB8sfEIU8TAS9AsaPDgJ/A3UnXZmFoGz30Vy -xvBCIv6Q7+K6B9JsElKJRfOq6bFoWj3bGaW2da5jcECGEcmo0dJrOhEeg9wVrSvP -nG9j2ppi97lOxpGIdLDcfcLHzOESJi2OcjiWwiun/rBzqZnYxIdxbr97b9AGkWxe -Q1PpsrartkcKi2zpnazPm9v4HzvKb8YM1Q55jgRxRHAEmHx5JJvKcKw/qXhEFvF3 -FlZua6OvnD2NV8qQ8iRLw7HvQ3/6wRNpnzEpziCxotzD4/m4c7DB11N7nmkoTtfU -BB661sXDrWvknaweuOxmKE8q5pKQfBsu1lMZ+a1VoTIBm35aC0EIX33HpyyNFWXv -/nqHCEPDNqpnM03G6/V4d+rJI1MWBk2jws1YLXxwXMP/BC1Ar4yW0x3bsjJFZr6z -r68qRidYA0vkQSWpekOuHMLPgWuY0efhgTMuScKeRz/3JcDF1ISLa2a+nX2waAgC -6ZtUBU8/YUIskH5PIIBSJRVpNIAtiS5gP7ilCCjAxd7JX2iD4jsKDJuE2k8XP8IU -u80ufCxnbyik6NmvZayv22hqO/iknZ6Thyubja1d33Hx50o/CsGCgjBoWY0t7x3b -Sc8fldK3AJGRHDswJ5SlPNu9Ej8WP+GI0S7SwtKZY4oMUuQzj5FBggonW9ox/JU1 -vqiA3mnFT7Tp5MfzSPY0ijW1pff58wuijDnpwEmVkpIJxo6uOqiayWExNKcLQwkN -dyDTr16ZDmZK9JRa6Ym+vr3UjpxxxhwlYl02ss6ZQM1OYCGgL4sikR4ONQu3yDar -0KM6uObj/OmEDJy06dKL9NGEnJsJTX9h3e5jFT3DNmzdcc40IiogjCj/lBDhBe94 -IWibOSe4r4Dc91cM8Ep6Itd1pLPogpfxLlnFqSOl0hQQUfjmWNEyr3NEnHhnETB+ -zHHSkn6tlwvkXb1yrcYcUc/53oRRp8AxAs3SKNZKUT8fv0EDhX8xDRVZnlFuquCk -WsJZac5uBVgB4oIbUb7uix1X+RNpcCFuNp6+9HvjNZFZmQGjl49laa9paWdRQUxp -FxThkDrMdcpTtV0yhJlGy8bgmg4Fls3cyIx7Ty9W13vDwp1MjUT8Sq0SYNPoSQJD -vZyAOlnmIC5RIGsryuvjyVkWz4/tOH41oa+T7kUkrHeAKD2oc36MVl5LgB+Rx5jy -UliL+au0Q1/mivNkmVnyrh7jeKa0JUWfNoN4UQECoqz7Coe26vHjxlTUl7brlMNs -HskvZw57A82NnIVNakXIV/fxIbj09KAHUFxwr9tbJBPVdhLLZ8HaFo6DW460e8PY -J3Z67eJTfKK869iQa0SP9tiOW5i++Yd0egH2vAHJVrouQXXvmeLozC6h4f5+vo2e -EwYldFXAZNQ3bFxBIerNF+V3EEdN6MkDOl5yoRVG8IS0TojgYzrvn5tfiLquihVg -Rz+NWDXo6xtxh4OwiqFpxe1uavb3k4R0akcHUUPYvVygl9JbAuyOjrT/lo0Vtzh6 -tndVWwCizYnCNx/fYOCoaitILh41Mx9yoT8QxQSl2XcPDw0fYL8bADATEq5w+Zb+ -kJyOG0P0IRXqyRLWqpCtm8y2TQOf2SCP/LJh2WfnmW5S3QgmsIl8nKmEgMhmNYXv -AXpd/BriCeKSiP5RUfzT5pDNUD4+9W3CV1CiNh6redxOFRGypgRoIAuQbJh/bobP -c+GlWssPM3cCLtSCTfq/dUeZ7cdWOWme/MWKoOP4UGw0IOK3PbonVwAfgaypCYXV -/IERbOFPBYEHAYWc1758K+5sCkf5JSyBdutiv3WdFNgJQwdmUMDGapYspmIj1T0a -tGiYLR1vKIa72LCpYwEUlNN4ZPewtfs6nD3vHplcZVkrzbuh5SE/TsuVPMwGzR2N -QWhjL280k5P4B4+DFaiwV+wKTQSh6gCxfejXECtbKiHsaIq+MP1iePe01GuoSOMK -xQlCFW3blvdoOcJfNLh0tL9UK2Oh214EkURP6hCKkw1rgNxhupyKSly2BQ0l2uqk -Lb0ECUSahC0TC1k0EY79eLr5jCyE1WRQWPpgcYNxeR2L830TnwT0d8RcNSzk5TFo -lwjPpv3JRccz4pbsrDwZa5kszExHVKUKaYh8hjHYP4Ny+u30aZ63Fzxh0NZ5Ojcc -i4Dwua+zF7ifyXxxA/ObIM8SDPh5j59nMrfvS0phFDb8RtlFybqPJnPB4cG4YHD7 -6v7MdTXJGC4mWk8HGVYe76H7+n3yvwoJogO/Eo/hnzDBaqmJFoxxPxGeva8bvmaJ -dY8QBbt/inaSxLH+N+yjfVA5XprVXUhIpc/RnNFJv4Hc9z3UgErycCN7hdlDsjvf -/0ySP0dUZdpkZWLwuoa7JIbKNGZVFt3NXnphmkm7esUXD/nhXCUupwAVJcyw8Rbk -P6ZwpkbUvrLbBnuekHAwEricWfEceXmMkVaKlUEgCLOgLulFY87I5lv831jVXAue -HWQU9fENlwqyvY9412KPn6MgVDoXRzFzWC6ncr1bzwxiS804EkdRYVzTMItJpLBD -fXkaYSgL+5khEClaWOD5lvCOJnj26h2ObHjnXfctR6dJ4pNlqQ/G81gB3Flr+8Yr -1DEs8ui2NepTiNqmC8RhqHxQQ6JU9cQ+sqXgt3PcQkTXcHjO4e2mfMPDTQXEDS/3 -yeVSMqQ28NSDO/xxsCBCRX/Qa3gBFhIz/pP2/LZdj/VotKfgxxFl/ZUNelGQd2ed -CXgn+WaMT7CLVzYWki9zyhdv286OoEoYYLShnW/0YIxmxyfw92nL6Nxvw1GFF2b7 -pNhjPk2sQX+ZZSKgP+CrJzL4qHWzBY9Lm0oL0B6P9F75KSunILhcSTif/Eh+DLhh -h11ei23BhpD+cvdvmFDNuJnv+lWi1mdgWO7z4Dv2jFwxRSQ2Gg/vQ36yyvdZGEGT -gntcS85szzspcn38FHHDqTk8K8JZE1Lxi7h2XLVj4l7CrDw8LbIImwdgIziUVFkF -ZgkNVSuqjZxHIFoQPZJXX74Ku9m9odBSyJdAOFKxJG3R3O+qgiVArmen+tvJ7BVs -GyeBJH4TTF+MZOK8+Oa/IOw6Xf2jgleU+qoY4k9xu4n7gfc86dwbHKZEoBjTT4hf -ytoDIpTl3A5bDtSCMoT5MXQnBEGPSEQPi9j3b4ETIoyR44x6oejcm04TFTf/EzfN -jTPJWFb4M27xQa25D/3cPsyQv7qCysKVowTH3rBE+9Hpk9Hs8hnhoItgKyJ/3llu -LVq/uavF2ahtxUCgVg80/ej0F084wNuSVegRL0+7aAmHLO00LYYOTxHbdcQlUekP -+qvUYiur4PQlYpdVZvFCa1wB4RPxX9cjzbMxmBZBA7+bzmJdaC34NRSnv0SLY91q -IHdxfiboILNvWwSgijiYcrLGGeZtdTv3ZyaoiylNsaeM7j5Pfm6JCjfNIpa1NfxI -8jwPOn4Lcym3p18I3WPoUeosWOSycGOYmm/rACbfndQq1G8xBuWc/yksu4nLJYKa -BWuvtYjrd9Jv5ycl3z3jaDp5rl4kELylx2rTesh6hmk/7MkauI/IyNgnHyOcJp+L -5QRjXh3Itz5Jd/6zDf/itLUEAdIPBBU5dUQTHgG4w14rzQ0jNGCS77a30+j9OWub -WiM0ye4lZZ+5+wN4wSV+pr0WM3ytii0vTd/HCDz5Fdf1KsoN71DD8J0An2+wikSV -Nlpu239q1lA2uiDH3SjX6ssxlbc+ZW/FmqYqBljwJhyXfa973ZpRjq7K4RnYm6em -WKA1E9NeHn1TbrV7Cjr4tliqU5shFLwO6Wt5AdSveV2orWIcX0OTXN0lXawF+l32 -eFBwyOd/BY4BThuoO7PlNRWHjXLBd/xcKd1wOB72XKvwgyY7vdiy+sh2U1EzLWwJ -QxcRTY49A0Y/VEmhSmlywFkATeefLxlMevAJo/tHeCDOX27x/wFGXu5uKkfI6QYj -8yIUHdsCe0Y5TbIK5dzkgEfddeY1QaEl7OqfDwHuTdJATk2QST2ue89hK58ZDIo7 -kLDX6i9JD/xf0afkRdHqAvwZGRvpJTqqpizvgstuq4yeke8n5GGxyp7SZ2/TR+DW -Ui4Prjsw6XEJYc3PnPD2jNX03m+RwEochO6oN/viXsqTwozjSVsIqZmG6Iu7p1pP -HuZ0X4vMZobdaUHzTr8J5qzhGF6r1UkGaH0XDNmET5qCBX+RQzTGQHoH0v7DWSX0 -/eyy2oi8omtDVfo4yZlvpJV+Y6s2y57pJ95bFd6XHSqH2v4MpSDlwLg2lXNpmeqn -mlqj3doKFhS6SYM4TJt2MJMT61kRx2OtXeKyCvo2yXIDjjKnwGKn3xI3wAX7lESh -UaUa/plnQpiTR/W8hZ9qfba0RO2btyV2oVMKPSYDdNgKh+RjjXcgyqYWq2T63YIG -UOz/QzBPSFFuB9EH4KZekCHkdYmFRae+dxC8Ics3dcMQpKOMC6SdjtUWTvnirTJo -YIetcbbeoX8SWmkHXNskXFoCs0aq9bmwOQEXMZSt+jo2i7gLnnwsjUoNkGw/Baft -RklgiXBAsfI5CRIunD68lS9e02Yn/hNNQvUG7SrxXvipbfx0WN4TE9nFxyp5kbE9 -djvh0Rn7q+RA+2wrGA1n3udjElDdGb/fxr91YDBz4d87yzK9SsQaWpZkOBgTBzoQ -bMIUMZlrhXymb9UNR4COG7XtCuOuXBo9rZhQJDkELsohxi+CTdwkMbgUbpV9zMwd -I57CnwO7soRLXskHQRd0C7jTmaMop1M3p08/SqVeveHIYq81wTjSBDSSJ8wXuWVb -DDPEf7ILtFP5OmioRFUgf28trbEq+/SBApH/ph9jthkcsRjSzrvHyiMFeNSKbr4k -tu6xi4JZiTrax9ODMvnVUle87ySsS+7qDrmAMF9msmZTB0NGepMITI8W8+FqKObs -guPkpBvdKSV/9WA5IzhCxcyU9GeDYwtgAkFkIpU0XIUZpdxRE/QuQ2JA5swtNCjn -VsnW/TC00hquqekDecBnpSk2ulhdZU5HRKn10gXDEJ4p0DGV2QofON3RETC3Pskl -9asOS5DtsxhjbeUErTpBiL8LiJ1DZWyGQcKAPbQsLjK8XNzxKxP+1N5Wc4tLNe8Z -M8oKO3iG2ZF/gQt0a+BdiBqstp6NU4BJZVqZLJmPViK5wTCRrmIrLd6g9X6CZJtG -9umfdC77tWFLb7Q62GRZkZ94mf8dLnQ81HqiMXDhvhX611Q1beAnsu4OWc5XPLgR -CHvuHzquhvmrzs1vrZSTJsQ+4Ezr1KkNBOONssMtm5P33arC5/DBfQvb935+4SaA -89mA83jt9KDTmFfzbUivqGAIuP4Q+U3//4xDbq7JpNMkzX4Ar+uKrBrGzgaNxEXR -+2PAH/P7X8LkMXBfEDqGmjDF7gi3HtIHEuiHxAZxYbuc+JGuspn+UVNPf8nPKZgO -VzuDi5NOcd3a0NB1cc4Q/cCZXshwjiBwOusmRcP5wL7k06u7UUk+sxiL/ae03FcB -5C3UCVP2WkRTaXcupBuP9sD3+Dz9APlggI6JT9Hs/iC/Xztd4NdIGKtjk4H1tEfS -2FtvjQQqZ9ImJ1GWqcZWl1aW9nWKImQ86eU8inS5r//TbE3sFXmR7z6Tgl4gQVw8 -r3ACyMAVdBjqrW2cGa684l0RnOi5TGD3eqHZTUh6z5N56Qty6SVIBZd/iaJhFRNw -MxiywtMduwNMd/L8HdGOJmNwx/fP4ty00ZbsvezL4pZfq9Tdg855Ke3OKeWF7iHQ -DRQp8qpIdAQhivvhY07+Bygr86ysoLeHDoNL2owJTx3o0WA8cwaMSlkD/rEsSQ+F -Y4SHIAiDen4GxeCWTWLOiOPj+k2XWwuS5OnTo/lD4zrjFguyqUNEcmbQWjuIR1FS -YARrxaRMalq3YB+uXwxLXqDrwQ4W1bJBU7GtEdMiSLIsqyfgpf2D6Ff9yiHPm0ZR -7zqcMDk3EoajiYIfOybnlAF8Lve58E9joCp20IrIPuquVHvL0BNFC+CgrIDWuTgD -/YVbebA0WmZLb0B97qxkMPM+59jvMgNX/dsK/6HwOu/UpXlwkgqE8WiDqN30kRdC -fEOQINW3PS0NVHKb7eJtPbayDtOMrXMLTWrNgwNCWtId5xwuou7CmFSVJPAfg5gU -APpeZJS5DZn6yZKqDqkZqcqS/7dwYcMSAJrCeJx7RmHSzUiF1e7ZRqy07R14d2sm -QuED7Z+r85eWrl5bf/yUnca5YtqYMI9xA+nUQ8jNxZtHScdQsA/yObPLRJeBmRg4 -D+GKKyp2E/mrWWxc4UtLo1w05tgEyhpZIj1CHF5aDxVHfh8nChf1OxPgAVRabyfA -jQP7gokIsi2EjeYD0Jp2SKYgZHXBRChHaRx/Y6TU82d3YC85/mIRcqKRxyKLAFn0 -dmDtHcMbSKXGm2OAOX9xpCA81AmwQdrT7STYbSxXNJZR+wBOvRBZmU9SiQqXQiYI -VSwGASTfVChinBqUZ426fKzwojsG77KqGj21T/XKkPsd/IcRIB/7Hrq1P53w+s6O -1tvKD5EtXucGb409T3I7pT3gKKAjMgWnMO6NvuNNyLylbz0ToAcJxspixk+bgoJq -iQhDUXSVt4u/XGMxuo1begKgXL71E5uPmeYL2xvzk3hA80bcOdelZgxe0WRVB7fR -K7rpinsRxYRIAcidLrrcO/qQ003dQpksFgjWsvp9TUaq4oPr9sdut0Npd3qPYUlJ -dW+jAw85kMftbMTDWthCBh5jPwnU2PfAMHrs4kJEng0LwjOSnfDrW+B9/ZdVERo/ -9Rg9GQQ3Qaoy7zSuFkeIBS92vleAr4oNgqePyVwixl8B6LRzjsdij3H+ZoGwnctP -lEd7khCbj/H6L+2+qiad3uPlMbeuvfy9r8OzfHA7sPY9P/g3vlu2pEwQqjMApr0c -THjjyvs2VjYQl07y+lHxd104dYq/bHZ/eCjF7iNyUaWJai9x192viOO9mqEiVTWC -99Xkjs0KsnaXgX0V7VXec3fekIA2KohHnlLBFjbsxqpl3OcUFDY9HogFG5yHVGQR -H1mWo/Phv+di5fNDlkxw1wgVeiQPRXkhZLcutlwlCG05lqP5GWDbZJrGlQ7uqWvV -aBHBIkBqmeFm8k6iEu5h4VsHFY6o7nOCryOsP6UlPJQ17blTViSeyoxV0Q2EuHUD -fUL9MFNxbcIEPNDtrDu21CXa1jOjsnUQZrKkqOHyOoZ/v28qlQrfnCP1x9+INcxS -OsoS82jbx5we477pJBrEfSvOA0JFToHFUF6Ei8Rrjj7X2fv21NeOlnKEyZiakxCj -/NrFGaC9B+yXuagJVBJaeBlzuVffHLz0FddVq4uYtsei5UfwikSJiQ5z5t9v+gIz -lvIet9uhmNmH6KMOOmkLh8lmEjSjX4JKI+bju+dsZEY448kbKYmfSLA5qFsoeUdd -W2wRIMujdT970j8BE+ZUY0E4f7q/CR4GmytVKe1mP+2tcBEjMFgQ+ulLmuOYrK// -cno7sVHm0/xbeFrFRLPejlQlJYJb2yGY7V6BZzz0rMWCRm7vM4cY/9xjYyBW3nfa -/dICcSbCG4qAq9LjS4B8c4TDP6pkIpKRmXu3neg6dZdBkHaMhxvb4RppL1GZoH/U -dBuFBcGssoRBBKRCE7FcnZfpjaGaWgOhZRhlftozqhYAmfkjaXYSlQoliML8LF4L -CR1Ki7zP9iZKHWwrkXMJ0Q5oELG0rlHp+mrPGHfnkN5EtKHMTmsSapwpa4nn9dsM -HnwIrS3WYet6LFYpgfwN53ZToYInVq4/rU2Mry2a5nWy2jcT69Aa/TQznERi62Z8 -RvQHygWRZYbqfd+SDB5fDOiftKNz0k7wRReDH6EULXAPVDccWOe8Sa7MY7OyRCxb -KZeSbtRMPvqIeAauz/YbaUgwr4g3+wdgdLD/u8iTPRCiud1e0rxgiwz3xnEsveKv -GpVwOm16BrxV7jQ6t+BwBUyOyZ8l8W9UnTe9+mVoXPiVSHpUbb/N7j0LOiAagELa -QsvdfqWpDOVri/F+S0DRIXbGMGh71k+6ftjfV1KeOzZKqpOMXVhZQMxC0earYgYY -yiqSOiIOxQbfJVOqt/AeiyPNlcFaOBlpssEhi8pGO7nr3vFahnphRVmkTzfo9997 -DWzE3uMe5sVq/1NSDR2jFCI/ncbV+y6Bq7pyY8Ecu/3aAKxYb1W5GGY/2O9XvEUc -jKqlnXGY6v+70i/quqGI+VnjbsTzO4Xj5TVJBBXnG+QPcg7V7Qj3xEmh7W659kZM -JcJ6SOrXra/JcUGPBhtIlJRAG9tXAH/LYa9FZ77VzKdor/oNsADUv5MzoFnvz3Ln -VdxGQCipw6TrzG9iPLMwzZ+wk5w+b0vBZnIbedwffBZ9msOeUsBoiggucK1EgCTn -iu85no2eUa5J8BIv80AQqfXpPhKH0mQstr4vEatL8dRnvTgyaoY603hDmpHKxO4D -et4jTWk4SJ2aA9Rb0LwiLmbtnbGp1c1GBfBDiS9Yr7YmudGIOo5Rl92TtG1AvYka -N4exhwqPh3+pvXdJdCDD9Dpj3Uf/RTAS6magwGEU/7J/qob5uPuFeMJHRnNDC128 -+qIbDMzfb1WqCRihKC0YjOzFHHLGSvqKL3P6UrZV56PhE2EB1eacw7rZqiF05j9W -oLHzM/RnDtg0IMoaIOomhtoHdh3Ft8MscZj3q/I3DAsR7u9cS+owebGU+1JZityy -MtFwWZhYt5YdBQlNQ4pPRThOygiZPQ679jUak/IWQBq0Er8gqjbkYkVmm7Vsx5T1 -9UAa+63e9ZRaOliL/NFjp5E/EGAzONFhmq0WZ62jj4qFkqgmtJOnv0PDTR1GKFWl -0GAtkT+7a4dT/xmQtF5nBrNfV/gSeir0tRJRn9ccg1why698cO0qNH9Iar0j6S8I -JJ7IorObumrL7aGhiialsAsLNZYTJLRnVPEJYtEKM7sV81SKiWqiA4f+N66jQLCZ -sHFb+2flCU5UUo5XIvqLSukdNgFPihMCGh5crV7B7pUo2i7qJOCzjtTBkjJ/v9jI -E4Xn3KGvZEuQo1uP89uIBQrF+2Z2Jinq6Bb48G5VV296ivMqIKOVy05VBGPpl64V -5EGm2nkWUKd0JL84F9ySfcDJ+oC5iIncNxNQbzK53CdKfyLMke2fa0rVKE+XcjXd -XV9ItyTeKEdoHrzoVvksiex2PCVBgztR3pQi5IH6crB5FFVc5PAAlzTINrlQfaGH -hix1ABoBrcSDGETVWCOsvh0YGdC4/eVa2LSvGZXPdN8NF7La95hvgjt7UvUdiKxW -J7vTNOv4tdbxCjV3txo6T4r4zFAkSIF7dU05im96c5PvcCRS+2PcutoDcbuu0TJd -R7onYj3uPOJnEKOFTAcNaVnXzLIpZrK9CUK59ZLIm8gbdWybaak6JOjoCLyRFOnd -Je4Qo3dPlTjHvZ3Qn5uDX+Nsc4jp4JVWfTUw2zA2zFlD52hAzK8rB3Gfy8IyGvom -TYZV3YM0DvTKeYX02qbXBtH3bBdB2KJ9m5bxqa31WYAntiCSGmW2AJQL/QiLyxJA -wrgcjC8B3Gw6yB1N/IVn+x4Nt56Al+bkuc7uKUWKtLkD1KNCA7VcBs3OFmF/RMpm -sm4zRgJWL5iJqWE0xjnWFmvc/tznuv9ufndzFt1LuXnn/AX9zREQexaYmm8ywdgw -pBaIhsEmLvr5+5hel8A03vNdacorhUc26P4EkYO4L3AlKh2DBfBP22WW2pyB/kmA -tX8Jiq2fWmS6MJZ8O6TuXL+v21Xurh56wLcw00Jhz2HvGV8JnbBOoxqZZXetKY5F -Ar5uR4Ka9fhBYZA4VfdNYvJ+hcUZR9ZHAb0H7sJGvJwDmHhE9uPud/mH/UIzljvX -WofzAXki7dzyqxrxMm6yKTalcWMyBzPFTyRVCiqjNB7rrVrPP2yX7PInz1jLj/lu -pfkqyJecDge5cc+vZmZqinlv88Q1WALxNrGZJVvH5ZR12qijjualCIV2E+J+3Bis -IKpHfaPzAUN8liVNwMiIHiSEn+G2+rw1cULwoord/5+/FBVzj9WdYmp8eKreTejf -zeQnrYHr7pmKdlZ4SRA0/xYeEag3h/mNjqqvwxt1xxNWT0XpkZUkQykxvVAn+7uE -liRlSbBgp0BWCxVDDQgz/x7aFJFb9MMmf0uC96mRIL4fwwCVAzpAlBQI9wwJy9aW -fmPpI84b9lmvnlAVytR+kfEhn3gZ3dr3rBM/ISwINGDQ/mmGEPueLOK/RALNd03R -BvrUjuus853oIM2PeqNZBLG2GqvxsW4kB0x5zPuLW4PbBeiBKMAg9ZTdEuspXCy5 -gEojgt8akU2CTl6HPXp8ZraRnKWPEi8ALbYoTUZeE0fkMrdtYVR+0gb230R0Il/g -4ZTycvwm5TGZqQ11cJB67fZRO+Kj4L6FIw1W8AEMBeANg3OOwGfDqhjahqO1k4fG -6q7hZqf5fZLuWmbCqrQNvy+MGzAnCeKUbwEmAw/2nxHlGqa10EshRPxxnfXA+hsf -E3ClVKCzY9ludW8clR6d4PGT7Rqcx0NwYVyp1qcWbtPzP2EOK37iulQcPvdBl0RM -/Bi/JFVCsyblDdAbmufx5uS89mkjeOZq9YF2+41+QaRWn9f9Ml8C7qsbbJzcUxiI -OJGHIfroHuXgGwcPASHQ67D8SmWOFQQpnhaj8mkHf+OtJIhnSGw5+wcvhq7LCD6X -3L/zqipab6QLhGXKjb81vwBxPlvztSTOCwAR0wqzNXMUmwcIHcBro8txIl8IMh+7 -9sdrT4/G1HdzSvk0LRT5fHx+ezXsJ7jH91KKC34weqHolWKI5u7k3JM3hTDk095G -HQe00bRqwgdUNA4TW3vz5WbeWBAbp0F/WgPOOy3BXo6VFCpUFs3luc30QOOQjsoU -9Iga/lhm0TVMD2L6mJa9V3ujjgXc5X1xX4MXNs4QNC13b+3jgXtwXfEOGjtWv6e5 -9VdJeZ0jlA7AIghjaGx1xVPNk1aLItw274VZPagkbWuSR4yysnU6q6n5d8zfsUzn -LIJRGI5GWO3/zWa3AxZSGk8RIEYaKf1HnnYJSyJrWTKb0IJziSvrTA8tDqmQWrzz -5UpHw0ffdd5DV3ZsIyuRX6zbqsPluI3tVSQd1akZ7XpCkAKXezbP+sN/nSx4iZJh -9MqA1nXGOBzHYevHxXdqB7gVnV3gWYcqrKI3shFpIWyo1Wjfz+GTHtbx2TuIJn1K -oFzP9h9y8RNfPCcREpeX3ySnyvlJ2L+LvpOfxolrvemrH4RpOr8cmyDxObz+QnoU -tm5cDark2Ipit42D+vlE+9qZ/GrKkChxyQkKnjcV8OFOUJy2ZZ10ZuvLiQDaLtUk -aMK9w+bN5f2USmqLkzZ1E/SyqAWAxMFzgwCvPRM6CjiKFi7hc56ODMQ3d+CS+8rY -BjFOH/UFjterNQaOAiciGf0JnFONrGGSB7U7cd8WWymfeM/i5kvyasm8sraRYBKZ -F+zjWJSKFtIX4nMquQRgdD1fmmRIZQiu719hiUmQpapGV7/2qF0j3v9DKDCRQFI9 -Y/HTjENN9veKMDhqfDxstZ+/nylxzgddtekFqWe0x25jHGp/FpfErBndGGKHexBN -P5v6LsaDXVIvdUWB93SvT4qsp9QvTutYHg3xrV+IX1Q3P7UL2sOSwCwuIQgSJWH9 -CA335O62YjMkPLbcMpUPl7nyGjECK6nMl8VGWj6z2xUTbHGNxivaLFumykzAabc5 -V0Bgr3nwcrAUQ1T5rytaCJTUjwzbs4rNrftOPohDPwE7KklBEPOG6Gb/88pxHquS -wjMbQbjD8z+oQxlb6UpFtTz0ByI6flEyg+8mJkA7w62rBaVhcYZsRQIZQtmzfd3r -jFHi0ELWuQCpALhoNj2GaPoKZoqxNX+6YYhWb2VEDbCqKjiVVmMcn4KtkYKQDk5E -7jkz6oeciQBnEztC9JDcuLajxvIGpqrw0aEueCQb4XAh1ne32h68c9nc5NAaGYEI -zDD3SOS2dYwEOKXZfv3+E5XD+EtZ0oPAoNoW7AuK4W/iQxNNlkHFcswI1llWo9VQ -pSjSLPiPSFVE39YxMJVhBoF+Q3efSqGOkrSmHeW0JfdB8wLOINkNCOs= +YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IHNzaC1lZDI1NTE5IExRMGNCZyBvSlhv +aGEybXovWkNKTVQzV1N4T0NNZ1lOanl0ay92Q3psNjJ6VUFnS0M4CjQ2SmlrYytV +bENLY05CcUF0eUNhczJ5WElNL3lyZjMyeFBTWjVmbEdiQnMKLS0tIE45VytoS2t4 +Y3dwUWhUVFU5TjF5TERhbENLYmNIVXF6QnEydU91NU5mZW8KZs+peYulpXnXT3BN +ifLoFydk2cG0K1aXRB2T0nwXT/VoWbEfmJhscb1AJmd8vaMjUmBsc8FJ8JUmjHHK +Ifa+MEukZrj7cgKYS/jfMUE4k8+xA8DKc0xUQRvR+HabYBzFsveCw/LSf60s02UA +Xt5V2Avi0d5UCAsTAE08SWLXsW0+XIaTTWykiX2QS4kkPAuroCuG3AAe4PMnyfhC +zlDi7riSIVWNAXvjsi6D+BT31frCxVRe1CigxDZxt/4mj2NfaHig87u7cg9CKVQC +n/gyJMV0S5q9oQiN0O0jivvDWwzSkd4BQC0BShyKDSBBKD4uUG7NY434xi7CDhns +zTx5nhCHtrqAu5wSle4mLqFjyIiJMOvZ2PgVNSxTfMtmpn2g+fiZ338b7qeMlOZF +XwNPzDu9bsFb0BhG3x0E0dy6Ls/KaVT9TlhXGE7h0/T6sfxOkcc1RpnlKyVRoV1j +/TOADrmMidXXRKQHFp+Buiae0hYSToLKza4NpQkzi9nsfwlHawoCQ+wKbGy3Iphe +PsLKSRT6hZECvUHryhpLkrsIXLwyiQvdgdZZyt8PaIiIV/DsrUt97A1o3xHAxLJz +G9TvW/VvdJp79jqch2PEOW+K2BkIJqVrhZj7vNyvILw58cST1Cj7oY8sJTQUxoS/ +TN6Sr4GMWBtObKHCDA14eC/KvJ55AIF1EzhCKWlLTm3Wx3R4e5Ue4OlCbSANTQ5M +oy6Z6BpgidBPHE7SWIX1q8jMrW7GhuNzVcPtwDkwhDUkQK7xpxf2k0baDUq7MQip +tsXJQFiq2pxe6C0GZ4U+Dwop6n/NueAPPpMQIoCXIF/xHdAjTjEphWAH9c5FulL0 +n8iQ7uhpgOWCmy2K+U2ZqOcVUsfIqRrSTxxl3M8t8WBTFDbCvw1tdtpAs/5qpuuz +uloreXviteIO/rbTTaFPb0PiuRYZDk5qTh6yhQq7hKw7FHBWEVDuANuMAr8SwWlT +g7KnIm5Nc2vc3NwP1P+RCeAS5EpOBfxitd9m2+hGc3aO6D8e67MhK3Wg2ZMX/RSR +lmzia+CzVbBunUzXJ1fh9rT6NGWXhTi9xyFCIS+CkX0CPyRRs4kkmCAiF4dYa0OR +fSz0ft2+rWeCZVDyhx80xKi44vHZ1sXwSwlwvxItna3VszLPVP+dd//jNEUg90EQ +fXzflp4v7e9lVfHBQx6PMKn7ut47aQHmdMUH2MLWR7YPlrs6nc1/3+EPpJhfp3Ey +mTHHtMhw6BzHC42cem08kl9oWGqnGGwhRU2rmWNkvZD3GxNbrmqYuwX7XNRhpMgn +g3veGzxwtNuFtAQmZu5gGWNihPHHuomIEgwurOyGjZXTaVqLZDwD9jqUt56wT9Mu +WyQpx8lIimf5r/sv0vho41/LjA23O1QkixDDd8C4iJXbIbLqcDjHBgK07BweWfb0 +2NDpLEmA82Vb9xa0+iKTDwIsIiWlAm6qTu3PAX+Cacvip0XRNEhaHT7ufRDXBsUP +617qyYDQ7rZQLKheQZP2CiRq7ff1tXERbx6plaeDQJmTLiDmJ6n+YwJKqhxYTkRb +vElL/f7NnlNxM3Dj9ah6QSLF5N3lzVPeoKH+nRk0WPHYutwIpIjRf14ZjO9MUyqF +zaSxShTpjK2fLqdo9zdMTS9+gemMmRBITBFD5GS7ItFHmQZ/AedjgmMOuIj355ww +WflyTn9GDB9JK5tN8ZpE+QJoTxcSxUre5Xc4fqxQ6IdPT8/b+n0NBjEUnGNAXaLK +wHLZUygbuDHWq5wo+SiSxwXETn6TRr9KLPgR2Vr1YaAL6L4BrrCCIrjDo1vIZvEf +GnednpswSgLCDRB1MY8imMg6J60J1wAm/Io0oiAEwf29NzNfZBpNzXXv9Nrj5gPB +EWXi2PfT0dSeASxHw4cHKm6UJVZsl8Fsz5215QB4cqEUSqx4QChLe+o2ISzltGOi +OGXX0Z/v6YBmhW9LEfUeatUtvCp4akzXiHM28h16+gXSFFaIR9NW5+BFpo6g3pw/ +xjXlmeEWB8QP+eL2rQAfOH2yGtWHbwu372cpONNl0+JHfjzzi/Nhyn8hNj7aVJEJ +jfcZRrv3Kz5oVTCk7YeBF9Zjdw+mFfQh1WTMSaS9wxPsHR4+aLP2pIz7UY5nOCGd +VVaeRc2Xba+QNsRYsV5+vb8NjO0klXceFSsvmDA4JKqcadZ5OYES9hSzTbKyXB6k +veYYOcTOFnwKDl+YB6iYzwUcCeWgAdUiNhJFWpFPNoP1Biyh9COtMV9+gWdwjPoq +6AxHOyvUPMTJEAFpDhe609NWTt2sFHojF0RNLIEK/HbDtMQf5+Ql23zkkon7UBUT +QGCJQF5lvh/NGnyEz37Su8rLgETAJpqD0rLKvNfWNqZ96Oxy4ZwznsKtT8HwacRA +rLVbcJa92NDEuDisRQbZyvDfe8K1c6eKYsc1dNUsolcRdK7zoza3o0ZqtUW9dMyK +JQYsHTtfxz0nGyW4fn3zQeWNGX/M2tgwG3QfsKXGexKUzwH6qY5FjB6920dJPg5s +F2vHODiSCFcGlMisU+yVqubpoYzEdEQRPlOMYrWNOrpciUQvSpNHHfESTOVkjfBr +VUrJHygk/AAQir9nwORbH4kBqELSeOD910vzKa5p6iWjMAYiLgc7zZRJipdhHTby +WZHyZqKFjYIwiIBK14CHP8qffR0Uba5IIqn7X/84QtUXAqLxkxJZTfmHcXerZFaT +oW1d1FW/4gVg0eBIBgEZQUo4H9ZTOPclVVG2KPWL7N3zsfJpwrgzwN4awVUyGBNM +TORMET06Qgzd4hsHoFm3/76rZHvPcB6efILPp56G+Ns1xUrfDUnm3jlQqeG35HMl +AzvUQ0CtyhH7WzXf3i8YIMGtH9gx2zpmE5D4BzyN6FpnKzGFtHQbDs9mgZuf3cSD +zoVxcNG0Z2ffMznG+fCgIhJJsCIwLoyIVwdSMYlOWRFUWQNRs6+KP4fVNvXqKBoE +GTTzRG8iiQHNc5ochHpqNkaiATQ/QmEvMNUI2Q8PLmslgOEPmgOrpm+TLk27B7fp +p4datWzxm8NhydJZSSLpKNK1JUGTJ+osaftXvaJpTku7nILu2CFLHtTKZjyTxmjt +ViDdSTB+lapVAIysOllyWChax5uGo/c66pQe/xTa/Z7IIlr/Zc3TU+RM8KkpW2dS +13EaMVMZjbbWQfpLgRzjctHK8x2wtU3avRzFXhLaR2yjMeyra/VGVPn5DZcer0nP +RswVeRnZ4X2jrjskbdZkm7igiwaHXJKs9Bccb0wP/lknLZ0/hA/czLkehKIpmEfI +d2hr8ra8f3PiXUkQELTP2J73vLB3hlXo2dCoeb/tmif339MHTTHOsYlmWwf844Tk ++ebWlEdj9UXrqmLe19oLRQH9/vIBhgTuSxb8D4e2jlQtA689g+DEIsamj6Yj7jm/ +uAaws5n9S53JSXdQuHSlEFMxDTKiCPYY9cuAxgL+MlXo6fgIdrzOpxJS2XiTfuPu +C4pBwRi9PYmjvtYfs+kZc+GZKqWMpNM5hlLRc97ghqxlIep8xK2v5XYP1VK+Wc7D +eEced2jGcJxKByeC+ZZo9QhoBJM2g0LZbly0UVQn72aMwnOPKD19HBkQhoLU5d6Y +RAOov9zK2kYg1eD1ybnksqtJhWYS6C3W2f35HMhALGOXws9U1lHIFhI4WbVKuga4 +JKIVc+C80DubUMP9tYC7vaMhSanDbmL9ssdG5o2ArJWp6pggrOsOawvswjjdGFIV +KrQvSEcTZxx9KWYSrS1mNMhE1PusLITx1aYnc4jcXEsQ1vF2Zm3hm7X70oU1Fe2B +q4gLeqGgdwrhwFAWhXslp5bBwiv6xyvz/WkEliTTBX0e/tCvm4ZnspGWz5wjKzxa +jwp08+4fbA15Wskw1KyYDXd98axBsBcRRBXTRX8/k+5zUaXzfbd2NyU0VkomGZEj +PVWslebEZpgkR4dRiK9mprBR5UkpbMjCTM7ANdcDdooZTf5v6m/ASGS5nuDZCg1A +leioL7iGAeW8LEVvhM4rZ8h1xFmFvKlNLMnjLIYXpX9R3lWMC1BGG2KR7lA+hmOZ +VEiQP5NLYV+hq1O5BqBkiqy9/NRLdrLUM0VQtGQpSw+0UFoYUY4een2jXvcaWti2 +oYlr/YJWzebNZARRif0lJtUMFojAO53F3CRHkwmCIryl9lP4Vh/kNZJSfW0uzveV +wbLYQbsNuYoRjGINioYKoyv+OZZaeqZImXV6hh5HVn+VoHgaYlypvVmCmKzG/Wgh +r+4wZzQybg072qmD7gTBmgRoZfqAtDtSuSdMfO+MKDEkucRyR10p+OoHSa40BSwr +i5TMz0oakNzLzlXkpXn7Nk/A91zOVT0/gn6ZcnFOEn+btYZCCMe2jfeRrb5hBUpp +K7DHEszKQl4uiNVgjI6OfA0HsJitIDvedBk8ohbR1do+8bSEtb1DMdi0w9IPno0f +cZABNtLydipVxDRoRJON6otDnDPKn3fxLeRtxgGnPT9zQNRHyS/5aza9f20lhV96 +SjNzY/zbk+GgGn3ssbQn4g3RLYTg8eZOoYWcPdJG/Sr8K1bM4OkBn2JZWVPY5ozP +f+Hz4Nyn/itQ7pjxYKjMpNMi+8MuFsEWSrAA7Hu8XKbnMA7xKiLPph5GZ9BQyIs2 +yC8ziixE5g1+yKwa4fdPVW3QSCzvZSPitfUtJnEFRZ+IUIkithSx5a5BMlH0olbD +ZaJXHbfDwq5lQRtXzoGs5UWyTQyThqc78rg1Loc0OyAqj6dbwvJgljplzIdJ1jTd +rsZsRCoDp4jYk/rlAdQizgTwW6zfMNhGRQ2c6PucDacffPtFchdRfXcnqHA3BpQk +v4PZuHXzC1zchTaT55+xoSWy3f78Op1apkeb1oFjij/5eSZfxLLXW+5Jh/5Kvki1 +dLgBfUg/wb2muIUDciD4lg85xPEGOACjCumCdc5Y6U9Rz9bmX1Dq+4sC1XZuVwY0 +SfxFqThWJrDbFJmOIeIFO9Q6/mYDjMLIPe7PJmr27QdoqVtYWFFEJA5vaF6p4rRm +2ldKeI1k7f+R8Tl1Rb1oxm2MFLYCm+cZXJR9f7k98ofRwiwIH5rM6ugaOuMJpfAV +t+WbNg5S3+zdcPHYWGA+OMsQIV4Bvz56GfrUBBmRHV6teoacoIswED3YeBSg1Msr +CfykEfD4352vVnUoD0sfXKHFsaJwLevst3cccOAg+Y4meLCOh2GR/g9pJd/MW/gU +31N2zljHGMKmXX/MQe3oUEf3VRFfnohxnn7CB0sXBcE5vABjnLECkEZA56aVTND7 +FOr+wyHz2kcKA+F4+B6pYMRS6rd4zdMog1wJO6y1DtciRJhrebG0i/vpZERuzEDv +YMF/XnSqUedpUewjWGi7Z4FnkqULusUSBAGnHjHpyZLnm9jL+ZOCCKbMVCoBfC8W +CPprfo/gjp5mUu1JK6q1/s1uWXL4MB0ZhfoiOCpyySS+RORh3jhB1dam0SVHBCZe +bsnOgKN1qYYzWwybKrXHb+UgCVqZqMNRo1kgHhceziIymSAPvRa8Hjp5oCJ/Xwxj +dSW3JR5ShKkm7ldNk4VcAcrZ+idtLOkrDDrc2+Usfo02kGdzTei58upVo09RFfI0 +yq2qqw9lZdvPMBuZJvOnmdon104ZXnULY2CyKadcfTVJ62s5+z+RCTrmS7YhPXaw +ikk4rZ7Zq/EG1ks7eEWMeTJUOd2NVxSPSLHV0r3rWNZ4MYdpJfmtxWVNc+WvuTI7 +Po+UNnQopdA0RXrB1J9O9FcBqYz2MzPufFlZaKbTdV5VJUOJSyVkodQXGvIwWrEb +wbnD4X0JDMOIlOwwRblOu4tYFSZODiKK1Bm6+qR/MOVgG+F/9Rlv0vNNpymKVrIV +qWGseQyDt2QpfWwkFdVK+578rXbzXMuCx86g0VMm+c3ZnyZipH6wFK69kOFprmYJ +hJjubqVqrYnLUFZ2Kb4zRCDn0Pb9+vr6XKKc6hAiMdURlAuYwIk6AvUsbJaeLgR5 +Ua1NTeJ45B9oJHC38a6Sa+Xzk2RxYWEepTXUWy3OQlxICuAT29LI7sqp7misMjOL +H8OQAc/iuY36/NgX+W5CsmN5Z3PVR7jGENp9XiojIkk17PRNfX76CR+lXc5otfzb +tCcQZ1gk33z49Dro2OJ6LEdTXpJOyPj1ZwxdaZtjYhmZMP8GCQYykE/lw44OyP3/ +VHAX3xP4sAwyx6Q9l/MHc0lzLIXY/3zMrgaAyqDPmh4Pmnq/5+Sva/jdU4cBGlJ2 +UlsQK+PZhW6wyCv61bzq7D0279g8/x+1BVyJTKIiO4oNFaTV6Bi1WUPSVqX/CQGk +0+NDCuqcpGfvzTkPc5Ab0L31jFux4usl1TQM78B4rMtB8BtH6eWCr2agOQTnQsvI +NdY3aZjDvSexXlyUYsyLGuiMzxIuvxFldiAA+ngd6xxHo77CjryCEbX1P4JiMO8T +9O2iOyKE0zyRNRDXawmA6vbSbtAoyRr2OxL6RL2+dKZh0OVP3Fi+6WkQcgSq9+B9 +KG9cXI7RMIQK6Hg98PF4sIKs/uGUL6nCJjUul2dFhd6+dk0o1ut8DT/fRldpsEp+ +xAkrUr/rRpyjUJ1YDp01iduyjMAcpS2B+6CuNXgWaHLql73nJ3yhGlcNTUiJmMvf +UV/PlWxHffjGTO+RwJswMkoh+Mp1fX9VO6iwu0xLDRvhMyooBSOQguvq5LKxnE88 +nJ6NYLzkRIYWaANLFGjYslrsWINCgjuk8BQ53+qpKYzY3KnzGBrRe7j/7kPZNboJ +gzQviroyZSbmeFluDJxtP968Kk2VKCWQbXHrLt8iP+qYu5Vr4aHUmbvubCAaGmIp +fg/9/UYEyJTJ5HCWoezF3i7Dpw6xCRURgs+KZJibGmeVHTpJbgCeA9M6uTtcbQ0q +K6t/vTMtqq/BCJ46nOGdrJ9XbGmGRMXSpkA5dTzMInBSuabUsZzHIK2Ab3j7lBQ+ +vaOQrbCsOCQfLITIk9zh+OqjrTFmdERkPxLQxMNuEiLp21Qv/Mf3ZV03rMkEB47F +5RtHKA0R0DelzaiCek9LwPTpatdxNIZgQOQRUdRsCkf73EjzvsbJ5q3qj19Gez73 +0pJWKnZFnCkubxxXuMn7CJam5vLFUZcyhB+H1oiZVPfG1bzdI0XcbUDZ4ElGSrXj +7qrB8/gwvavOv7QOa2YjqjOgdYY2gV/NTAzbaJDlu0t5LRzar/q/RvrJ3mlVJZg8 ++a1WaO54sXipWgUhkiVXaTQfRUZuN59mFmcXmnwxe5ZZL5i5K+gmhvUVmn2sjeQW +wZzRlWaqvTXm1ik/y6vvqP2G1+Sw6X+8KD/OQwu2Xp9nAEAfUJF1EZihXYGTIh+H +e2GLA9D1p3LTkPOTVNmtMu6YCe0Y5l7LPfjBJLYfnrbdfHA79Rrzi2d4qOfeE7LV +WCFucZihGi1yoCfhIZIV7iMzKAzl5DUsS3+yhAjENgqX7mwU7MdKertJMN+1IYMd +to8j94DGbpJ4i2ito/TAGMYCc9a0UKGry3FPxzVxmU9gYgiqaK7EDXjTqQkO5EOX +SYTx2YZ/4y+ppqvqbHiZHIx0SN7KBbgkL6VKbpbVrfTf6TNltj9zlEq069f8Biu4 +wM6SgRTc9FpWz1hitComnWKSyfFxy3iQonavtjJgL7XIFuT3JDG+WEbN8H/jojlc +BEREc7Tn5Dau2qD4+/nY8TZ0wsTdDO2W5o0NEd7R6KRsDjjGZwPaascwi3isxryF +PV1QETURfC2dzYuvQuuet2zGGo4562NmeN2KU7PFEURhtKhvmY2Do+4inWCa/2Rk +FKb1ranUvCfOa8Hz2oDJ8oO5GvJCfmhpoNl7ipaR6zMHLr0E2/EJS3TcOm75UlWd +MlXPyvnpU6rSPPs8sIUOhSYIDLYn3Dtg/o62okj8QPVHab9JtvHpHqIXn1w1MxY9 +3RdmEPAHoz06LOPU10n1BDNdZVQDm/MeDQgJrOULGc04DmfgVilK4txgr6dsiany +wG9TFE/JrQUNuur9g/tasG+q7PRReD1debykntcYy8nVsIa/ccoQv67AfFUNmdpR +6E/jCgTXuI1vOQnObsCe7NQ0RKZpzkpSGBlP9cLzJDGJIWbCkSUCab0Z3EQBNfOx +3fTEkq5vmcakJivU1NJ04dHq8yElnUkCiFx21vYlv/eECerhsVhzReeCBGE25D4k +pTrk6LwQYq/iYipRpDXesMitJck8K1/XMTVF7HQM6uh4ZDm92fZ8TBKDB/VtWmaE +A2svoiDJ1egs8Hoxa5H5468rAIWX4obz2dXLrt30orKhsNLvRDgwME80nRnzC7ng +AJ6VA9nvX16JK7Gvw4Y9Jx6dP/UKT8xUq9agz1GpjSGJzVRHX443XzTmuBtJFfTZ +h0B4ys2hsQB3v9pD/EQ6RH9hMh/ExPrKlvSZsXreJ2thDWeDBowp21PxPnBbGfbq +mck4gUcnmpUMeN32KslPOM84JgzTrKMJ8RwU4KgmTvs9w3YOXokgxWgrrbnprPXF +os5P+gynvoUgl5DM2rCPynVwOVRQAVTOk0Cn/G9LqxtPNppxq7MEKQoTA07QcROR +r/LDxR9Qc3JXrr2j10S83vcyXKUAjabeknNkUfRIZcNkAb26zEXNAEfjpbzvcPS7 +nCtPas2AD/sAvEzZSZqznScIRPHMS2Wl8doad54AhMGxgX8daY1WTJzKtvnB7j+H +xPTZu9b2PlPLzdKgozxFVEDe71ddu2Z23wvAYhu5YwpLveElRknTLo2GTTeE1C7I +gPBIv5tphW7tmOtnbhx0kXPV2AhtyQN0dQK3HhytJe0oJcXXHsRS2wmZuMnA/7bm +FGkJ+9hlpTO4r8BtLNb7epAsCvh4UkTe9urWJcssAxv94/yOZ5cqWqIPSJ3vF7gU +UazNeHA1dHXUP1AGmZnplu83wj9AE3ePLgRrRLSeW/nA7+InM9YRBx6Qqma1d80/ +cKWSgoVBFX3KunCIhAoRhzv9WFehnYhGSLAUJC3fwb3MLNMcSQEXZD+Uqm4ONgHW +i1BMK9eqChTWVDO22UHpflW8FspPaDPMLELem0yQJPP+v3P87C7zIQ1fs9osgi9O +EG14B6JivttCF+eJe8Grdel6U9mQ6Y5ZbV2trDVtQN5Il8SpB8ggkCD7/ZZnpM+z +Wa7cHRQvjfUmgp+hMhZq1G3Y5dwissK5+tl95nFkAc2KHHtxEhtsmniHtmoxZQ1u +EvJA5Lr57ZykSGruk7nJLlr4FDrC9ofiGcvM2YrNpyf3CRjYxefGfJEjWju98+b0 +7HP7rOquJuvYntyWj9vCm5mpY9HPti+Dh0hH6QlW2bo2K3KV+wk2sCNxMfFd1nGh +kdex4wo2eHLZM2vrY3UG9d2KfjNlv6kVErL7PWkj2kCdc3wJsfVeos2Fp7hcckMy +E1N5SPB2lW5Qldr7WgbMrkpQWBaLRpsiURVqYrBmwd8eG/fiAfOQ4MMiSLE4/l7u +990M4HODSkLZ5jAZ08V6GR6zUuewhAQGa0chZK8KvIpX0706FSPUtew/ZkxDAaAj +BtMFKCDaW9bolu5tkCJoRnBKmX0Xq57cevV/5skXipNiYn8iE3lAPYgxxglTkYmU +tsgvcPu4f7MQpKZKzBBgSPqPS/NupeLaYRosl7eC1PdpSjC3iFvX1aVZdsiTM/qA +4IrPOZnKQNcTgds/ckYIucyJ6U2F9AVQ5H1zyaEeV1YQta6Vk5QcGKMmVlxJwggp +Ud5wV6ZjzFNirGHleijlLm76lR82kxWGSBqJIrNca0yNL2QZdwDxd+WLhgI2ZzA6 +B30O17ANJ8j1dKYojXs8WQwiSDq6kE1C+6b+5so+bnnvszwkGKYEVJrOCmQL693j +mNQExEE+DscdSi5K/epEAMjgEQM2f8gLyxU8wH92ilY1LPC0dWVVweGbJ3hTQ6TF +ryHY2b8V3HFJGjOHaxnt1VF9+dwEhMBsvP16GXx+Ymy+N9ubReQiyqCjo6XUQcir +jM1mwtANM1DrH+xKuIkxWq1AldROSU6cBjCJl9nKJnwthpkVzzb0blDBMyCqA3wv +rjk154RYQ66jqlCfLK5UogLNNHSsHqkJl4Zy+jhLv+eYfiooiTtltv832Q0NIs7G +RAJcqwZo0Y39bjodLSZPc17OyTnWzgRJRiCTmZuPtyQsY2iW6X/E1W3ii2japOiB +pB7b7aZlsKEMoGNELQYlpF5ro2H6/V1N3CvmPJDFrbEVkzO89VeYRJoHBYY5Y4TX +KIcSSobbWSG5SWNhF9KcmntS+9NZFe+hYoMErjhM/oekmhdLZZW94tb5fHXt2Yb4 +fhbb6ZYewCKq3iXJ4R0P9VrnX9ARTt4EpWZ1QE37IW2sSyId/8XQ5eo6+M/lyNST +6rLIqSD8aNuDDyaLF5Nm/cigk5Je0K+gAWQBrKMQavPg6T4zfTjwrx18P9pkWIjD +DYQuYMCAo7HOsNE4VJpC8D3cVRWH7A4jehIPZcFANLFpzZzOXaqKB975Yl7Crjqa +MT5sYvxA7KLxLJ9IRrXP68a+tSr7BBkcwc9WDnJ/rdHTUcrTJC1QK0AzsK0gDPks +wKyXiScciIfaE7xg8ZNG4twnSaWNFAw/egWJ5jrnEsUw3d4/lT8B1kkByHmuPe83 +9h2TC/WzNvn6KgwKHJcTVpuvm72ZvSy1HfhSfYZtRd/W354cfrTLJQfR6bXp9+/h +iCTVjvuRM4SmAHv5r7JJs0jXZmSkb9rnSntN8LYy0qZdIMOQs1TXuqrMw8IpKMmj +zody/K9h3br6Hrc2delzUjmqLDbstY1sKBizoK42uC4izt28UnfEbrYoz47VXmha +9iEuKGeUS/xS2b3RorZyyxLOhw+l+LqDXPKNQrR0oeRNytfCHD1HY+YN64ikspMk +BMJg2GPeyKhcU0h5HuUiCNko4EZV3Sbi1bR/Z5RlCpc7gZXVm0/T4nWqNABzZo5D +ktUd/scOI0sxOvf9BThuO20riY+utoJ2OBBw0PyaqPLsH55xQL/PuSb/Ol6aOs8B +obKZd5Dj8Ig9TceUUlOhcDEAILrGqzkLIlW4/Ny3hXkVPcNoz6o6K7XP3Tp1yA5o +Ue4CMQ06Hon3BBw4/SgWr6vZmw4GhkWt0Cp8BzVVfOdBi5qvqSVV+yr2H9d9zpLa +MwMgPTYnopWrATHdhm/QZ6KXmzuKGImHrAaZNQyQbzMurSC1jUemfTi+f+rR8FvS +j/4POuOcpVFvY0u30CvevEUO1Y0MVU34Um81ocaZSYym+w8lMikrVVxnI89HL3w2 +dxcajWP3aNktzE9uN842gxABcgjlR84GEkYmwFLQ9V0zbRp3fa915+Y26YgcsAuK +PrAGmLPrVwaeqnDt8aGaLodDlJofiOFuJE9afAjRNJ8GXYHREyKgErAG/ugw/qVT +IwLPAkwkZflL5MW921BpmVfG1Yr3J8FKaH+O6pTY0u1ESxWs/TJ8IkI2nxqH6DEQ +ukaCvDdA0tdg9MPZL0hiOvLOAAYgSyC4BzRVf6fwJCzf9oGdEE9RbUvZcT8gq0p4 +BY0CMe+dkaIuMa/fdWu2g8ZqpKbTB1QU5z5iiF6xVxh/k4SOndK4vaFKqywMdmWr +QqwozU0wWDe1cj3FjF9qUze0LXhiJe5Wl1YDb3hRPK13q0xE1o37J1JhFRWkT3ZL +M08P0N626/8RhvJgca5y1V7I40n9AmPNFqUoPb8HnJhG+c+WOcyy9t0KJGGGgA41 +Lem3VJlQVdu2VOu1fkneQi4fVziz74OUV7w3ECi0eRPlZvq04C5IJccWyU6ygPzR +R3ISGtFMCtvWotNLiaOwhG6jzTJCb2Ew48qnL5vb/zrBhgZU1c6A3StUkGJij+p4 +qr5dTq8k7vvKfNkktGPPBa+D+o0z1jmJLAH35rgErZ5JYSi5PRdMAwXaBYsZd75r +97x0OptSm/3NCAcy4EoN20Qf915pN406bVVvIH/b/Urh0bT4GhwUXdbaeJ1VEZGP +LSrlHU6wNeAwjw/mECAN9x3uXTwHemDyM6M+HvT2JFtYc5cl6H4uunF9kK0wTb9i +LBi2q6sChOeSXsqzC0accyqiZUnjd4nz4c93Wdp/lEZfRsbE1/djRCl8Q3luGsE6 +Dv07dnGd8R/Ovx/OqJ5uud6Z6/DPQxSO7K8DmpVzvZZ99XfuyYlqQvQL7uiFgAXq +5scetajtfcSDAy+pJATJjFwkYjNgJoe69NHy4lwOHq4ZziVcwgPNbFTjgb09LKzL +tAgCqaRJB0G1On39p/DG0RD+HTEIDjw2Bg48VAC8LP7aweAz0z09C8ZWAWSV4orK +S6IxC6O7hAX5x+bXeKda5kJr7e/iMlwyIyCk47KVAuqlnGhSAJyEcTFvUvfQuDqz +mNJvhVYub6poeBlnwF5H7l6WHK/vAlSh+wNJ2MCqW8eGxxUUQVFQy1+T39nlqbaP +jgybVo8rHGPnGE/PYS/v3QDtj10vRfHbgodaPdcUkEyNpGIBoM1rqF4NZsAFYo3g +XcLH3btNP5TflXAGpLENhj3X+dCY+bOw4rZSxlzalq6+oQu9wpNW0onpejRDVGSR +n90/7+reZshkZRfSXmpLc4G2BtOLf6GUIhc02qhuV/24uXZq/Gj13DccHET2s0ha +LDGnvzacONMon8UCoDdQ1sV9z0Oauap4noIjSx2Os4U47sb8OHH+Ib/UoOPpxl50 +g9/YAYtnB3FWwJmDVY+8LbsKwR8rUSPavk2LEKWqMihDkusGJbWTxTIfu1HCZ/3g +wj2OCdGP5oN0GEVNiN39/8P+AV9qV2/hMQij1Y2qYMUTqT1qrN6n+mVTlesQoKvY +VD20B3c/6zI00LZwL3/Ldy2vbScXWEhkX19LQ+qoczzCFgz7fSLsltLpuAZRYG7I +vgLQWx+WGWkgoCbGFwP7dgN4ua3wyA6phUqp9t78TxieknmPPUn75iX+/7dNqcyH +XntAY24mOwLuqroIqistp1cGtibUuxUlBwySwVpy0osvO9NXtHOA/lQ14zLeWL55 +pWV6QGJRuPfLQ9p/b1XmteyfR5fD24n3PDNa/H2DPiabXk2Pd9JdAuxktcosNiH3 +szLaop2LwhmoTy4hQ2JQAoErFZpbBCYPCOv8bbb0bpkjvu29KtaoYNVfTRo8W0GK +D/FpyFbBvtz1llHe2EQ+rvcFPQh1pvMmSLNGebyry5+v4WbGzayQP48Jwr1lbSwJ +N1Rea58Werh9tHuigCOygAS8TCVE7fwvpAgtssJpy6I1jx/33iG04C1mES0xwnF+ +GAljj7X/io58KRy4iSQL39BN40QtRKqNwtOx3LQKnxBa+ZHHxaWmeBdjxCV+qj45 +qfD2kUcSzSSGufPef0D+7dkq9YYzUM5Qu65OzbeFi8xeNXc+EBQBlpQ5qiw+XDyu +JepksEj2rlqsE9YB2wr9j2VEMZEzuviQ98kbMyP5DcHvHL4D371F+cwOxx7QnTKC +uS2PF0POsJGB8lSdLzDBerkyCDwOkqOodISCl8pnaeh98/rnt2nf0K3M99WMwgJj +/9o8fMdBfiWJPT9edwYRCxIRGNXC3QU5Z18NJv684XxdXYdI7IWbByS6iA17fmjn +CH3lPkbTzT0ye3jK+h0yf4KVisAzdzzgQK2u5V+SFe4Ib8Fl0uz1h9Z9C4YdZOb2 +c76zSZZFK/GFn7Zhdx/mM3pE3BaNjxHNw98xsL8x/G3O3D0W7i+XyalMG5xhw2pq +tKCzAMfHozUVj1JL4tzaAjJj+UKET3dU1PEp7cp9YkSwStcDNs8+UpjTTJQKJ9+b +RbCKBUCyY0l7dJbNR7+JG9fJsw/JQ+1Z7V+75YHhe9edx4bThiBTCnlJX1Z7WKBA +kd0i1BGSndoqsFagIpsh6qj1uvzTZFpvYYii78/NGuRq9lAnNL6Bo+CnED9fO3cJ +fc42mdUmurLVDDGPjVV19Iqg9h3vfatvKobrYAZa0M4Ur+VO7L8AxQdZzbGuP90N +QqdXs9fPgml4dVmolg/uyoipdEM2ohnnk34uKg+WvD3K3eWwfMUup34f/yW+T2uB +0AkgdGHVEv7BOyjmBRrn5Zr5CPhmUSFBYWWbo3IEGqu9jV9C52hv05NSvpTslNwl +V+8rCLdEbIAePNTiQzcTslvhPWuOhCVmlxmdfi238a2nxOpFyfgP5o9R1f2aXBai +0UBndMaR3ULKPNnbVLwYY4iiWsiw36i5SCuTgpBBbCP4OkRFL5GKeahVcxZa7rcT +pQs8WRz6KsdDshEgQz5yxIacZ7/tJKYPbyWu0Ju8wWtGFjytu1ZgAerBa1u5gbRv +UbRzO6YuZY111/HCy+wFS78xVqSExU3t7HVQgsMIf9vkQvwJHm+Tfd07/L1xSW7k +uAM4o0LmON7fd1Xr3yeVnM88WZ41lnVeN3UqeFj0bxMJp3JVcfvpKC4eWyhVcUVf +QMXIMajFsSc9Dx5E8RK+QA0i/sHJGOx5A1OeCJ8Z4Uev23azm96Um+zu6biM9mfY +feA4gt7z8y53IeOCFjpU0EiMBWVeDuINncxnzUBVX8qG8rBDQ+CaAeEIQ5tp/ITn +UV8Caz+nT/ebyhEkw09H7AL6uBJwRV2J7nxo27xJSt3k7jbpDMU9CHqMJgD8Rcjz +8qtymhS6zoqRFzvIDAncxT15W/KPcvPPv8zng6tYZRE1p9AhrX6KBMHroYBC/gbQ +aUz/pIcw9kcT1qB/CpGZC25tEqXiBeOkDs7Su/w/QWkhkaT9mFfIhbAlQ3drO8d9 +HuKrkhhfOCYyq9RtDHPN617r4HdCw77zxQsad3KORVk9V+E3XpZhr15NqicfjUGu +rxu+JRk2m5SEJm1m+vi/NKsy40lpVxUyH5PQZ/An/98+is1JMhC+8vqJIN18BWbI +MwRvYcGTV/OH+IBIJbB53XjyYwsXqQwPfDiJtyBiVMWfrmcOitebhfkEB8a7iBuS +P6i0Ze/bbMtVxcFnSVZpIDC3mh+MuGzdz+sFxq/t+6plmW8lG/kvAk0vSbGSe4VZ +gfEWXZjnvODBNSPp+Z+vQR1wleqEcuUWwvQEQpZwCvgB+kYwhCY/P1VCSiyX9FNI +mO0+7Jy++XIiw4y+uRCwXQEejAZ4SI+zkYtw8v2HUCZeEZi1gGsMrcqOqY4nfCJ/ +AIfpihhyzUzGAVQmAgKxr8BgSISncVjPDSjngLRRI1Q9Wy1cx8ZBM6O++I4oKNFJ +AiGeoCsnoJxHFKzYQSkG+q+faN67VCuJY25iU3hE7Jz4e2jVN1nAP9JwMApkrpdr +1Pclm9uJg4CEg1gEabjN36gHpV3LlSvEcXN0olGcF9Nzg54NBb/o0Sxjaagk6Tgf +tQ1Pj0lhRtGcxBqf1h8rpJD+AefJp6lPqu/ePaNc8QNbDYWdbHuEH0E8dGqLl2Ku +IIomTJutivxWri+qeLyJAkpWPATE6R+pjw582BaichuoIEL0lPF6D+l8+GjTs411 +5Iby/NMxWnUP5uF/BcwASt3S/5rYkRcw8fakrAY350C2mD1lImOM9wHuAWf5Hhe1 +5W/h7RgTP2h5314e2ajvukDllCafK4/uCkOt9FUDTvKPLZ+5fDB2Y/+b1nO4dLUt +f2i/h0LJ7FIXsJhig7ayKvMaCyPyCn7X+TEh7m6l7+oRkw0uJvwVorGiyv0v8AvV +NqId6VxEkRfgJIS/ZqOEnVwS3omQFFVv9mRZziMbKMZU4IeRyjDyxKpT5I+Uh2dE +yTTKkCH+xUV1feMKP9rx4vB9kN4dnV7FsoKdu/z4nTUdry3uaZnwIDiGNeHez4rl +Rd3SgM0BVv49IwMNsqJdkLyT02ztPxKZaBQLOZB4d3cGkmL3taFmFPobZqXvKyZm +m8X06z/nseeiRuKhVMHXWwDhqXRsSJI+x9GFxYgcNJCBVdhDoZ4wl+m+6JH7QRSE +SAqjs9flBQZbIWlaz+c5ObeVH2D4M71fO6xr2G/zjTfpZ4MeWf1Yy7PlBQNSVkrS +eP4cR7GKcnecspeFRTq+1b1tYsUgzgEF4QWMBcRvsOep57j6JjPBa9TVOK+tlCTb +SythJ9oQ+W0nj0KzMa8oLmc6yk0mXILwTP7UkSJ/QW55R2gf8sistS5WA7gy0dq5 +kRAcNpDUAJzWvHWeFnh0k1K0qb3nQenFnMplCF/2LAvxOK3nsOnKOtk5neKgzmie +dpMkZEhMLfyE/M2Q5OoQioAR5lYD9TvMFjb2J4uYSrHyHxtRfVIYw6rNShSzzyBX +hu3bR38rEDwUKPu7vPsjH7NXoax4B/pXtfYaL3/lhMvAM2UoJTqpHJYWPmQPBF94 +JpNR4tcfCeQzcjUv4oqR5qcIG7DewUp2QzWQ529MtvNBZZv5Q3VWvIS6AEACkh3R +qo6sMz26axq2kUzRJLpv56P5QhBvHiy0nVHs3SPp6KkWnMsXEbzEvJjIWXEnzDcM +bkYXP6JXKAbw3W0OZxg1S+UQHonvQhObPyfmxdH/JTPQvvZKlVzlWzZdm6FN5ElJ +bwbv03xplDwhfx1WoMWmGagPM/LksaHpuUySmjaBjNTGxpwIN2nAy6MUCENf2Qyq +E66b9aTTcUNPUImzok8kckDfO+BorlwwuSHkA4d1i1znOZBVKpLa6t74qBzx0boG +nwuTJqwQySbGnY20uVD/U/QHpnUDSAIZNsiOTuIlV0raYyCWfMBp/MLHK0d0FFx7 +E3TqjUqqOjRY2wBhVZhTPbNICh74gJDJjXFo5aweOkgg/jsA4L4W4SvqnykW37qu +TPXs193VWuFPTnYPNzIJ1M9Roq/cMqCqvwNaqegjMI3TpbgLdemnWzotkzYbCk+D +fo3qnx7GDhVxQGn7vxrtbusU+zQaLxdloiWD/kboyjnhWo4NVdIZUCEgPLX71t9P +kLA08nBEo2WdChbVhVsQp6nHaLG+tS9FZzKOgvq2Eqilrht0Ybot/nW490ynOVmu +ZmFHXbbN4oMmAUUW8rlZ0DKc166n2vw0cwV6yVYPoXsH05fj7TAoAQGRhTa15QEZ ++MWZwX+36H5Dz22FgR9Hgx1rpreVAkzAsts+qmE12D6CZtmwKUPnY4G57oijE4f6 +fH1u1puRFr11mBTXzY7/chTUoubVbCZjfl7Sxj0xjbVh9dzJGxBmybZaiHsMdeQC +7PPA5kNf4n/x3uMuRAasdcqSehO8JfpZds+As46XIHGk+MnxC2QbGdgqvAIFux5R +1h8vsW5MnJDSVUb5takW0Henk6iegfaKeY79xEwwgf9dv/sqId3Q0HvyXEnD+j8P +YXILcuqcWyRNcfPtUr1KxvI4XOnRSHh4Nfl/pq7y5ufSy7TVoEdrPJOHMvhEdHtQ +NRcqFiTk0wDpADkmZBk3bzZ1ghahBm4B+Lhk3Lp5K7cvVDU7fCdQcuEwy1zymBt5 +N9xEgvJ1GvOelLjz1LNQBLB/gZnMci8T9jEoQmj+O71fJIv3lo9TFDxHO3uOAKAS +ctqx36pGmdGseaZHKXNQeeiVYBJcB4MnP7XYUDE9XfZnClRklik99TNfOCoVYTEs +0W5xhcZQVd3SRQAtl/d00QxN0oF7Mr/OrP5itC1DsF+dgK61R+HVZckx9P3fWEH8 +Nmo5WE3NKiPcMNWiz4cf+po3vdVFIgxE7hHUKxaEMjxH8QXBKrnizhuaOkCYCrlh +nbZJhi0KT5oWbOjF0PBeDgOVHzIhRxy+S90qKwIvHafGyXYymlZmVgudp+phQHJI +U7On3vgevZVqk0QeHcQLKyvtrldU8PgCa+SL+VBcgMTMQJ6FFwOdBAYeDJFSanLR +qiTRwERD54ZzcahPE6zmCFlD36tWlpVYhztH4Y9OJNExVu2Sn5sdODsgdyVYr7TN +yEtC3i08L+NiBRBXmzNJqz0JXc6W4kub1bYIVKkWijdEFMr9qGX02hZKrokWwcDj +aC+y6AdvKRL2khx3UxvhHAlTo5cQgmrYs/VFKMIZaXli1YG0hx16/5bsMlAcvGpc +gqY2zY3NzTOVteqLr6NoT6nUMusNmA4UpU6c9jbAntT7fx0j7EmuNiKhTTq+w8zQ +tia4txMealzGDHARkG3pJoA9VPbnqyiN5pEUiPdmSm9198cunY4+wB7GH0/09gmE +Alc1/4VqJuwcrSg/yeHtxlGfcFh2r4y3Uy5UYDqtm0M9XL6sEXH/HQXHLr0/hC9N +v7OISESdTJuxAcDRrBXvZ3KL+m1V2NEolHtbualaeB/oLvd5F4xIKxj3ZrZPHVkw +RisvvlRV6JD6gd+tOIZnrMRvYanRxwdVO6Ka0QqI1GgGuAVH/1WKVFp3a2j886Yq +lVk6s8NRf8DTxX/IqeCQGtxnUe3WtySm5emFJuIExup5OonmWzkG++OSzBrdu0ef +ucpf1xM4IfXHIgoXQ2u/AE+uhqCK3mu5uytkXVUkfwdHdhjNo1Tj+3hYvGUlwU0t +VCMEx7eqFGHQRpw+HVxFD1FLFjtvAxEAl4CRB2RWE1AikzThhFf1lsduyOyT1Rr8 +c1doRUyV1GyJz+9hI8WIgm7mlRqVStPXgwkbi0xCfW2WFbU46bDFS+MLoDYz03LL +yHUkpqFRdY2ovzaNw067InHIK2vv+f1sRn/jIml8iUiZqGaI66KNc4osSWdMsalM +CpllYZWXVmSYlLr0sdLQyfg0IiZo3gEQeLkmF79JpZQoLozHU9u0VjHxfbeGzidz +prvMuuCr2Wkqgnx5KrcdN2jpbVIHYZI1dZ+u2Y6PetmLSwosipTt9bJEWILGyGmI +0edxWnPx5/ImW8jFVL12gT81T0PCtSR7bn+desS3URKv2A+ZyOOvn8kol+L/FfQa +85EDS6VvBPIcy1Vg5O7tP8vIe+zzUFiYCvf0hHZzkbb3yw09ArCzXVB3lgkE5cK4 +judWiw9kiVRnoEicaXxzFaqXsX3Q/JCVBQU5o+MBpdEzlAnqmNqSnaPisFEnj4uN +QshS15yUbMvOwZfW2eUc6fqkh+wZvayKtZV8eMBBkpEGaLIAtAJgtGYJAsJekjH2 +Rg2S2PfRZ+rJSKjVJkL4v1GM1cqaMiRU1o7xU/vUjmYP4+gg3EYcXZo9yYpXgisB +qxW+UTd9/EnShZ5nWSqsAg7xeo5A9AhvigPeMH7grdkYW5VKx6TwPzTZU9yd+XVK +UIaZHwlDBKKuqeb+Ul3Z/GElIcplpQXp333eBL7mbkHTOZcFW+LGRMkvWv9NyGhp +NhW3QuVvNsKa6yhwA9jS3MJl6FH7QN8vVYcrqZWsKMXX9Jig4qIfcFb1UwZZmoHG +OZ+TE3AqVaUk2fYIlpQRdl3lmrvp5diuuL270GysSKw6tgG0DveFwMZ+g0vOPv6i +FCWcVdsE7VSg/g6lOitASlsc0u5BbpDDItMGzssTHahSUw/Ve0bQpUey9Z/TMdMJ +s4KSjrlV7VVhKKF2EpmmsGsSOROR54hDLzBS9KlVB7Og3888GmHFdUQPJcpaGD/V +PHxRov+oioBnVZZw7yDQNlSZ7nwfGrmB+mVcS3uX8TwKUyyo4yxqroWM+DIwuLaq +gQNhydwvVahoHJ4Qph3AdKLs5djxsgMSp+GEuFw8HavphODTTwoz/8K604wiUu1Q +xAxsRjSmJ4BvHhXHJWFSsLLYeFvLYSefbqCRr3Ky+jcRLGAKHc2I8GAqxNmbi3Kz +FVeuHK3Ybzv5RfFiOWPjKCCQXJiTnSPPTWRHuCBNSwPwCvLlUPAZQmhF41LKbp2+ +pIrtFKT+uDFBDPeH38A38FtP+g9h6jHd5Bf6sORCxnFYlj8G9f5JJI96gucT/JtJ +7d5F5ZH/BPi894uuI2HMN0cqSfRGXr9CrR2l78gcS4EhRJS5o/jNJExp0eL9IPE0 +/JAZ/nC193/eEHsGol2thJYtUt4z99zXoWBPf7zZdNRfCs+rYjlIm2asSn46j7xu +kGE+2KDsjybhebRFYhmHR2ogwpk6C+ioCgDftqYtVqkTTMld4eqJt7ghJ8Ta24Q9 +5f927dBw4qhdvMJBSyxEWolgShEYoEi6Ba66W8ET5YXunnue2i5KEj2VeCU1otAq +95+EZKq9nl5S//oorq0Y6IokfNrn1H5OpKXoU/orB4YaU0oRJjjyoGFi9U/L4Yl+ +LSBtk9EvMWHsASK0K2NHspwNJtG+3GGfDmVVtkFGd7bOhB79zE4Dv+u2evrsBc8Q +KVyWrTqMe1OxnrxvvkzYDANzyJ6YdQPBKj2asTQW4RBytt7NcyANjp50jxT9FPZj +9nWEHSTcfdAgHPFgTgGPr+ksSUfiryrD1VNQxwFAx2wmUYzqGfuFILsJ4t4sxALL +C7IUkLylslwmppR97nhbhN2PUn3rJnkEOO04qGLqPpb1xo7Wb4GP/Z3x3xz43Ky2 +l022Zq+N2L3I7pKKCOGXpEs0zFd6uTQXc6pjfXTFogb2hZwhdXZ0sXaN8VE1LGOv +KI2fMhr/pU2gklg33xawJX2USVD/yy7Zn13Y6t+ys3BJDL4qlJc/pqFL/FF3XxUM +5pDdVopAxXS+V7ZaU/Vxm2dseuo6TS4GVitbcJoCYurWK5xZ/AuKi2vlYnzsHqIa +wVbrVYacgD5vrzZyEVEqw39qtUqSbnR1UIsTuNtXm1hP1gUad8dnKpUoIq2usWwO +6RFfdyALMCCuy1ZoCQOco0AHBTvKwMEoFBy6x/cTaXzqwq+66Z8bh69k7ZtpkyWq +8hy47mEUxyAexjanMqbhBlQYbvnQrEmCBVIbxd9XwjcSIdRN+lONf/MI+QIhyH6G +A8HDNJ5K4997jYEN9rFHAJNDbYlOk0B7OJ9X9xJLTmKZFE+ni1pkpokFbZQDYVD4 +C7E5d2dlCm8Na8SRc/p6ZG5z4pEdK7bedFGQw2rIidWh7EazzXmlE5oDG0eWqHN1 +ZchmH3fc5HGczMy/xU09L+LoNMCvtf8F0oazv+zdzLQVVW6M3u82JZuFBnNA9Aew +IWd/tNXyxwOGwIPo0vKYipoXD0dMou/x+9+r2ibiTmBG4GoavXiu8aykgVgV6Ysu +X6CtVqjHXaGjRBFb08kIRSAfTUcEDO8hIXsgslmc7BS3+fFXl6WxB6CQTzycefMU +i5Lqu5rVm4JsUjsBeylEjOaT8zrH4xBsyuTIX8DarkU1xy0QRlHXPGJQip+pRIxz +YjOF/PO79tVfpKt4X8H+29SQ+ftWP2iviUH75GIcDXxng9dstvrGJo91G3WH9DVd +FzIkNgQKdc5Aj5Kj83v7KziQpr/mmAtnZJjV4utR74mv9dzp+ey3WbOLwYBru403 +WP3zuAbWrvy7cArz8q1odgZEzssmDjpb1TKvoAU1gOEIfSGFSqVAVQYeTNbAYF0N +eGPY751DKAFeNmhHIi5amupO+ziiCFhvL4bax4KGXMNWlos5U/MPvglbsa4TGz+1 +JFK9acU+VGMOEawSpORyG2xKt0J3cYL2iJYXPTkxnXyYpbl2M1IflzJHUTftzucD +F2ZgQ8ON388ounTX+yoEUyi8977r4XwQXGeOiWWE34kbGedZOqDtdqHKR3FVDlP5 +UGNGFnVFy/eB3jTAzJZRjimqmXWyx3pY/hhmRpUCmVVMpGWZD7Cbp9Dw8m58IYRZ +Syq7qUCEptuYgfLnVz8cRFcalEt6/xzE0KWxzc4xAn/4AnPjdk++cmAk1fVEyLc7 +MJZ2ioNvamC8IjdP6/OofENxvYlTjFF7nErg5IshZESI7t/5gULlJXO82k0fx9Ke +lgM413gJ9fovTQ9HsSnuz2l/nfINEmu1TusVMghVLyoQbHk2XqG1OnagwB5ccGJK +HNjji7B2hTwwv4wLdNeWFR6Vm/h1wttjdSyFcA2lPdb5Ghl9QLFU6eTrX0eKmfNu +CwDDVoeXmAFb+Hg61qmE/NWE1KuU8QqMM/9KlCTqGPBVrHaxMFuf3zNUtHom7ySB +9E+bQjKjrxW7nmClnjhcCY8l4jfJASugnQrnDwiPPIQUXpGizcuAMeupoblR3J6/ +bYddzpgtmYfVF6BoOGfrmNwSo6mFRNu641JVWSzEuu3WKy/KjPLQByYPLkoS44If +JoaTGzv1uMZOF88Gc7w1zh/YhmtTW+batIPCfBGGdzqx9IugKvCmw9hdkyuz1s14 +RnuAZISxDuTcXa/5FpLQ/RpTmaR4//SGynmLdAhEOMEyKwzmdzUN1fK5JeIWUfh/ +ySfUjjyq1JH/6uMlhzb1EVz3fyv2+yhaw2PbpzglZwXMHOG2fGLAvyevmmSCGiy0 +LPwuCqnQbegHaPQxAwGYaa6BVTouOtO6BCHqpUDknlU1vNFHFD9/xYtXjCX4EnYm +NUpvOondq0yU0NJUz1M7c4hQX+Uu13f/00pIG0ZSGGe9/VaK+V+l2fqd1OXPkKEi +T1Rp09AVDZhiz0itGfbODzXNW9KfJWtIFiecB0XhDa94QUSLvHZJ2LdHJLwsomBY +41uA0LD1r+cfRe09zdadaV6y+9Zl3E3x22IbHsxug4tn4o7ap5o4TulPUd5mxvcR +aR+GEJquSI8zDZ0S5sN/lu4f59p3RwxuPK1Vw5HZs2CNbUGTvf5pKwqdvnW2gTIa +JMS7CQ5GZQ6KTWd8gtkISwdljQorZ3hC0hoSwdo3cvKvVgmNWdPL5toYb6gfVfkQ +dthipRnA4vkEkV8dcHJEAA/wSKJ2faicrCKTHihUUJ4i8/uY1qIKra6h9Cw16yd6 +tt3no5iqK/rPZ/G3DXcqK1C9q1pH13KEkFoZXRXHesv9w1fJm9U/LNJRrmGeeJhr +ErwNqURrVpj4v/gWUB0VZir7LFpTiko7emTW2FUZmWZM802GoPoUOOXtg9r6RvNB +BIVw686juN1LN8Nwh67/9qDdnL9kFTRFaFGyfWSbGgYhhmTCvd+09kDG4MPrzxym +yMS5w15jvbEdlws5UXDRL4iR4bGzFxzFdUTdp8e3xykUCUlIHZlBSC8GCRV08pqa +/wKOzffj6pSPSHM6ZefEfGoa5ee5+DUzPrhayZTgaD+4dhXdAoi+Foy+vWLTur1t +P4EUpuyt/iJn8hqvQyxgx7teGB3KTDeiuPMf5WWy+0sI86v9Jqjjns09F7p7ldrq +BqmI4WZDWqE9qjUkcetkN+N5YPCUMr11uY7IUg/G5c5klLHTTc9g84/O+s/7ffdd +OHLmtDYPPDhEoBVLTJMbazCkmIqZBTMrwWjv3lM6IX1gXvxs/BGbX9Z6PeWgGwP4 +uz6YYT1+ahtvlktoX0jdU6K0wOy5gCAvKCPC4WuS/4rK/pL0EQA+Jn60VrLleRMH +GzlOs3GgUzahSAqWYVsPFhqBgUU18i8RCNvx/vbyUaMSmc4qWbQRt/lfxpKlPc1t +zO4wjqfLfN4+qieqybEzQqh8XGwakfHRKZYEI38smOTnzhnRd0IVD/FKH4jzOV7N +Pw4/5Gc5fNytmK3Rc4cRMX/1dsYnEJ2+6oZSSJRWoLkpWFnXgU3itTWJsLHXeo/X +Y50WAtzzUXm8Wd+7SIVgl4KT3rFjsh4Xsix6t8gPkHHM6R2x78yzXn7aHOpWLiwm +22K3rvbnbB1czYbzY8LGVutnrbx/Djysg2AzqhhhF+b2O4vox85bnGlQCOMrh6sK +hnNNpj9HNRCTKH2FC1/9CYIhT4Pqml03BrEQhXDeqWEslaTIiHa2fz30QUZcCpfK +YKSuC2lxfnsUEKb21QnIMj32HCxQFd545gyvL0ZLdj2k+/DPL6TEtftno/TqzjYu +VOB+YdKJ7V3u7TVvHAC+EIDnFSzBJGJ+Hc4Da0AKxXdl3rObcOKlL54nq3rws7Ht ++uVdemujWx3jiuAgfX5N9k6OXMB+7x403P1fJO46hbJfih0MCUpDZP+hXfcwJo2J +KA3JV7wMZBlTIikDEHFyz/peZygkwQAF8JI6IjXNwmXuyKSPLJAJdCD2GHIz778b +c9BziY1wTAKB5Ag/6uOtl5EOJKGAhPhzkEYPsIWoLcp51xGr9yQY5veKwbobT2l7 +vyD599C90ZQhaR7gCjECiyczjxnPdT9I4hXZeh5dUvRhcjfLKl4Q/WPzqz5xIYjA +bXiU6HoNhqlH/47wb1r1X4AOmLG0ofXBUcc2EpkQFQDJk5R/Zqm/4q/kjNTKMIPC +fKGoxB2oyhiENgjj8a7XdKegBBJ+iYcfmCa3C/+qSoYhgQex7roCDhd2wEPRIDq+ +GLKARny1VVDBkKOZORIe4tOct35N7S8qvO4sJ1Vdxq5GrtS9rzQj7Soq6kkxROXP +O8zejg+n5E3uWxTX5uommqZxKfRFgqErQ2AEV3sleQyHVzJsaLSMzeUGIWHmrMbx +URCfvfaqoKeLJ/3kUHUZ58OXEui69d3zY7luYoDYmDXm2Z2Kb1tTWx408ghDDEYI +5onQXEoETBMp51L0YhMr23lkezFf9SueRvn3YNs91xGQZRleMHB8fyogBtTpXb65 +yJEkmbeYMViHFFpOPRsSdT2X5ACpmIj/OOseHIZ378ReNM4Wei2O7SECbIGodUFa +7hTclrjXz2036r86ZoZzRQCsRqlAwSCf+7PBJBQSa9MBIyQ+Q9oHHXGCd2z9LIcH +Y/NeAH7JzwrKegpdlIrrA4RB23mbPbPgJoIbXEd/zZIViwrr7Pi54cihzTfvhlhN +bMe62PotnpaWmBLGfCbptqoa/nyHg0zH3kqAZzUqJzrx9+SKc3XotWu9zOS6Ew9O +fJkbVBPWFACuFabOtfmiouqmnAhWoJfzXbx0gV4gwy35cPdfwoHbX5a240/+5GrY +tzcXXUe0Kb6RLO0QHRTKYSwk5pwIR2Dlhuz1n1Vm1GCuXN0A4g+uhGsZmFVO0MYx +24Xij+nX4NqWKh8sEeeQ3i1ruu54AyCgL8c6ap2EXFKM+yz7sWSShxpdfthZTDAy +vpBlgMjhislLJxyyLIWyQPM3VpQMmz1+Y7RfonT/vrbH7iZhMNbReC9JmlIH7EyG +FeymDSkuqBzV6jBHxZOfoyKJraO8Upx7jqj02tmzx5YfgbysgjpGE7l8X/fyPKo3 +/iFBGl30bc/lHirMDE2xFeRZ9Wx8bXn5fj/h017hIMTUBrIfAa6pQevz/jLT+Vp6 +pBHvFyy+CG6XXkJH2s87C4ONboFTgRb+TbewoOsFY0PWrHhAkuu4g8iBltSCQQyE +bC2RVyK64plkz6225jhjsv0nufnxVY1JLizRaZeVzbIHiOUz4LoJsyre4OGL/HTE +UQxi7475kzHpczfwCZnT9dq/3B2jLBCxInlGwCVBapyGuyegNJzH7PyCqpij9kRO +CRlhKQd060ayyzKGjxTRNkJWVxeQdGVyoN3m/V/9+Q5u96jCl4R1oH/yR/5/4Iil +nGtrru598n8Lg9MmiGE+X5x5ypQYbRQRvcHnxKhXkE42E34F2phXEcgYAWwAaZTE +SjeOoPvV69aKs6Xj033w3Mb+mPD8sYdwqXBuvRHamCiK5ahigqjGDZ/gnCK4EP5a +NoMrOy+F8VurIK+rOsT01Ie0tLf6I1wm3o648gBTvTVUMom5p7MmQjoR70+8DGBn +SrjuUGQO4+Adk7/J7t3mai8DIlRRGyxdSlFmsZbOxV4ue4WDBTJKiwPENAC6rDym +3KbXmzqS5qfAyQOP8A4ON4yILdkvOK1XkQhFLiFvIqDHBa+EbzfNpnNfckLRxXp6 +YeT+cLHxbvg5zSVLIZdBuvubtVj7jfosEaJaEVZltOzfIxDVtMwe7x5RgKCLZkaB +R2RyoS1Xjehis3A0IAxI3GTkW4KseYG5P1NifWPLZYwy1QG+7wpAYlhlhHzwiu7Q +wyFyjGIYQKzInmfCxQR/hzqZN2OdNSfneCZ6HmSefnbV4WjortCR271uii+PyoFJ +Zcvzu6AzxCZEwt0WSKwaptOfdguoTEqk1gwsPu5GmnpEDujDASZAVBn7xqOb+8m4 +S64Uixq9UjH+5viLMyRf2vJe3BYqlDkBXJF8iKwes3YU+E2AEwH8rQseHzYmbi02 +Y4E7rjoU2Ph5OQi6qOANLwhigTBwKwfucr7Pa0Cv5whEri0pmhrXTlTNR781v568 +l0GXfhS8fe2cJVB5anwTg7oD5KtZGsmvFhBwEVFsfMlFCKBRIAHpLBSCc9jVInlr +eYjizaXEtJLLhBIg0WqvIPyLEseAw0mUoCFlY44tN+yORCoXYPqLhugfn7VMlX4C +uq2zlfOSCMrp/v21yLaGX+hOZmG6hoaIDb/BbLwlmT5ObN9+KUYnxcUrESHZhFZI +PSf2J5P1Lb5E6GQeoXxDWuaONS2+ixl21p5FCU1EY64zgYTiucBs+5RPsqW4jPEb +EhIyb0D3YiVBbgt2yBB7SDY92SJO1SdVj1m4KCvdebIPhxPQNPCh8Ig+gP97+cSk +bKwnqcBti6+CanpARKmiHp/nQj5Xj+JJZm1ynwL+Y4nT0E1j7w7+OHea8643kkjK +FM9TqeBk1k87o8XlznMpJA/Ndacksb0w8RAbYqShQFjjmAo7xFkzDJGdXXr6cqv8 +XQef1VwJ12bLTp6IDb0qqjrr5TM+ibo83x9KYBqgb3EyxJw2W9oP0wTnoeBeWBB6 +ettNOM16wX7lrJOcUvjqjktpNn6CN9rhBBs3XMjvlgxOB19mLC79PgdIbUaBY4P8 +iAf4+LnmxctdFYgeYS0+hRHy5BL/u1tcs5CNIIPIdlTYGRPe8AqTl4PfagmW7Pph +Aq90TyM2lWG5lfBr7M4McAxzbVGAi7rCmhKHWxBX8aj+KPnzZDrFYuWgHlxTzlw5 +a3+PeJWtccMctnsBBxBAnM0UwUTbgcjy/mmDvPTzZGBQu1aCyi8GW1ZBlpYigjTs +Ae9oKXG2VDkj7fKzgIWUS6Ci8jx8G/LITvjZBBXPQRkQI74euBWp+jT1ZaEqijjA +Wc1Og+25mMnbklAxsM8JYrxYTQgZ5Xz0aZ6Y38u7hj5WfYNZPVTT0bX3Eq6fwSVZ +ve/ygQH4J8ZuejQY8NjJ1FN2lfbfTg6GjQXshqzvIy0gPNayNhf1hsV0t32uzNZf +XDhTwEW8JG3zoD1RDtEu6fCfHGmugA+APEHpl35FqNR801WAHrS1oanYhTc52vMG +WFM7omhsVn4fDz3Opi+7FS2picouN+nQcP5Q5F48l+s0MHTVD0Eq9AwvLyM6ocT9 +1qF30Su5BXMZ19uzQO7Bz3T13d2seROCYVguoaTdGRZsUSgaOpJIYqE27Anjb/T1 +PUsG4tw326OrKvsYoHf1Y57VtRMmnT3OEHWwzT5TebGlYJfTAeNiTjMEaFdTB0cZ +xTZytXeE88ZI1Oilr34QQq/YjrmAA8A+OASYdtIePslVIPVAKg+aa/TekVvPbj1x +19cYGMmIo6TQEB4qPlMgHDiKboil9qWRHU82i+qWOWMkEvH4OkmrTCQiVDpoU+ev +xOBOAJCK855Bl/kx6kXwuy3gcWxH1WuYyZteKnTx7lVK4Npd1YuZ+RI29Zo0BCxP +1UkrkKxkn/ry3IV7iWRXN+2hcRT/Q8yZsHwyhTiPLcpzqvEdn6iwdXkkZO2XmOBe +7/MkqH6hPl37r5H+eJAVWzw7u6nvHf+ndUPs+DwWDwq9fP2W/djqs3nulrmkLuEY +Gu+gYMBeJMh/y7OXqhLyV2Ak9ndnB6E34IOJcwFiAg2IgrUs4CHxh8q86io88yFd +nekvb30shHTzRqkPeB+Ax7NNkeSHX3JX5H3WbzS/npr49pSkOVYK2TGTacGQ/PvQ +GJv37LgRth63/ySMN9+zjpv5shlD+LFE2wJ4X/FDe0pkG2AX39NyhPlQMei5RRjn +s6u1CuqXPpSOO2kj/ln4EJpZOmnRgJwrBIgTMOTRMWQFfzjGsEfAUbARfpA2Z5O1 +PkxYncqXcrkDNrw7o9/aJT6btd0dVpMCnY0N10nlcUVs7YnG4Pfzlrt+rUyP5jku +lb7lHo/T3i+I9M808OwAxWako68r4edQ8XKypI2OiZP7wR5CIzV+aj07j9s0IcIe +aHyDn126ogaHlj1SCTARLTesw1zHoXt33C/S2xQpCbAIHizQb22M/4u1Tac1Dghc +rQ68DlvclGriI29pVRHZv49GD2r9wE3QsvIgIz2ukgnrbGg2HxpVNXll9cgrf0Gh +tY+oB5q64i5XJS/Ukr2eBZEZNg7CmKim0PL/qCkAoYLShEvT0IIEsVh3+jJz27vW +MzoNfVqw9rEkaWNC3KFpYnubFYIfoqSqbwELeG6ZreS5CO2NrLaEoacUgKP4JSft +URVyo3BEaO436X8jBrr/LPk5PHolPfEBzO3sOQ9e4B7xe4bPOUFxQ5AfOm4cU1w1 +HY8bKd6q3RNujYtGTcYIQ3penAUHDmzTHru4s4hxCJMa21dvhLkZVFeM6626TE5o +rCqaGqXyO1ptzL0ajIu4cyo61YI5BJsjsb5+Tw5vJA4XgFtyQ8ntJaGo8qFwKICC +E5EMmKoIYlJJrg22cfwuxwrfKHiO5m5DGmN5JBuQxGXe7ZJHMFSf68B8r81K9voG +04zCdAAxgQc+vAZiy8ZgCSHdZLA+OstrkTS6epfY2RkLexW4Sobk8Fe8kgAOEcyn +IEhpj2ATtvwqqgfwX0ipnhC2+Zh3EJqYMzPO40GzN60rUFCfikMHl8VUiTg3qBN8 +up2xZdUHR7el+/nNgYs2FeVsIksLTV7+VKAAsU4o7URaGImYSAEj9aYnyQOrADKR +uhwVzzj3I6NlywoO8nLK87Q4XEcI/jjFtAak3WmzdARjyeCguKgCgjD30bZJ8QBu +FbWfaTLu8GRKBNvSwhLkf3Gv0UrH2X7095Lxfj0IG/E95zPnkNzPYUgBMoMLtGHO +ur+G8PWkmrUL9LE9X3YvQPJ8PEnFlDGb4PhLK/ZKV3XYh8w0Tx28EsCLwHECELoC +CcBzR0eo5+qUAG7oVa34KTbv9NGcOlTKrXqG9ksnfGZtUduy7nQKil61AH0DjFGB +YDWsnQOykONbjeTpMem9gaV2kcV12GC1efW7w/w9EvXg4IVHgeUTXMWAW/E2J7AP +PQ/QjiNws18MUWiZAwRzk/kPdoytrJArbZ0LOhzb3ZJs4tWg9nrbWY7Ac9K3curE +NvFRDT/f7AS003twdjdUrAhFkEYlTlEmuVdRDKe1qfBZ6g/0tcZeSIcBBIk5esTf +2acnza21cmed0O4RsR98ezExtYSnkyt+jgVra9g0iK/PVUixukil/TZk0DeocMk0 +2Js2YNLf3icKd8V45cvHXS0am2Moo8p5X9JfBE54eBdt/L+YjJITptcSL7DIoVWf +2JMW/ofwiuNjLj9skQh63Xpf6r06HNlryTekRm5VYbs9c2XVKcoUv4GDqd5vK2UU +/HHLEaNYca0pdL+DhEHiNZH5vi4IwL3fvPAqvzsfnNJFcac8H848o8tXWBoTk67v +Q46qcLUmWHLvo+VYiWbL6xJIStaHAjvfY8WMGwj2iCK9PHdql8hY/5ifJHX5rljv +QkLObHycncZwK5IIkerJQbvQ8Uwv1r+b2lj8PDfnDRDJQKNYvIhxfoNvHGf2ZgFM +Ltx9N1KGSrBiC/hCyN7WiBzQ6mSOj1WQ4EYTlYGIQTuQJBKxRToxlGHi7+Rwrmpw +Yhj9Xp/fKbrdwqwrqenok/VqTE7EK4lTbgltx+9RrIGMYq0FbMTYxjAO8U1mclHT +UF689YaWcu2tO0HgmdQvscziaXIzRecz6SmtX3HCt2r2e1Mh384ORqUP8+4syxDB +BUOjItfkvYcu3Gd2UAJTufcwWW8FqUKZwiZWz673lMQd3K2xah4yLA5wyKaJI2uw +rR6FubHcwc9d6a9OeIMbF3MRdrMTIj3FEWbEEGZf5ZbnwTVDvN9WeLMF3CHsa/0c +mCjFbXibTW0N+2+V+0NeAQCTVYZaC4auriTX90QkcSVu1UgDhxt1hihLNvFvkLaO +WV7h5+3F4GvUQrsGcKii+ZsetBCvGLRITRZB0+Beqzj2bsfFRu96P/pW0KIKUf9L +Q+dGCFHdhqLp9mEkz1voDH7ZcYrh5njAUSushpn0LvCAQP/1P/7qSAHi6tkSgZIS +scnNU7TB+Wpsty+cYnIqQZ7uNKjctOgwob97XSbBuB2Nl4LPFo60BQl+sE/mK9kX +G9qujOlKmv9lULag/FrM3Jy9bbuBAkLsY8slXWzAAebuQe1bBqmyp6e6D2mqEJSK +y4FX+xJVulVI+CmmOxncnuoaT65XUcHNcKikPjGqxIgb4IM2MGgfMw9S3BKpawsR +ewv7flWJOC+UHM2zr8Z+Kuj9SYjb5y5lQOAAqrJQUQNCGXw7gIwTqnfz6zPZ8e4C +501vDeJWEM6xIM2MOSt7Qmj0AYGsk1FnjLBmQxHFRti7RPnXgO6oDmjmvjLacw6L +dkYg0VYJsWSgSAmffk3NVmClsx3P0g9LNmhUTaXQc/2d41cElUMxlSpFkiU6/BnB +RDYQFEbdjPi8I3+hwTTLCs0DDSSUlUDqCTfZyb4nY/I+cbwbKWkBQ4p2KweP9eCi +3LMhD83NvI6e4Ug8dIqqu9VYLFDqvTXV3hj7Z1gUJwOFHM3wN86YvTkcNylfMUVh +Facj+cu2YKZ6eM+3t+z9fLXUxKlei3KzR6HEDoooUdPBS0gFIlQ3roHsWmi0OCMD +2lrTFz7yo5niqP5BVDlTNGltqlZGY9efvZbLLXtDtTWpsmxpz9t6p0UOYqHPH4rW +rULYmELPJVuUppW1TmK7RB7zStgfjc/rvCGJZuuzt4PUGb/B7fpqw7KCqIHSBad7 +gT6j9t2YKr8GitLCUFfzrAIsAPpR0xG/cs85xnbQ4UYLL7rdPuV2rB/D4D4n6AQl +8VYJVhVKzhS6/BZJwGoSya9IeMpVLrw3vjt1s+U/gHx6n1BbIdM4NkNsEkey42Jh +Z/gg/j4L7Klgp/6sOMm8HxlMmTEmYK9fKNcpI8R7Ie0pvPKQB2FwQfq+7HVm+Z8R +vp42WTsUAGxz9GHYXtq4W/GGt4c6egCMrUDsKA2r69czZI2tMcd5ADgQfamHyszp +gB+VulTos3qnhsP0ytp9FVwYAg/l8X5JYgNQz5ZX8T/+nGbFnv8zcUcGkka0UjX+ +aOIFw0NDMLzQhWVaHR/XyNuEacO5rQ/IHoMOCum9iV+tmpeZGA7awqtYO2OXXnXP +BEryefV5G9N58g0geIzGaAF0te4Kr1XAkgTRaTdS6xIuzax81kHMsDLab6gjw4BC +v4ws7YvCETwsM091XP6tr/Ic0oQ/nkgelcnm89qBnl7tsc2tIo/7tjzMG14/7Tp5 +0lWEaTDE7IMJfocygqVP0wXvx9FKAB5FtQ9CNvz72f/FUuyfG6tjiXz9WT8G3ndD +zmRC7K2S8U/5zEhhrRh4Pb+qCYbubsNBHZhKwR3HzTEER8UBBOrrUqwYyN8I6G13 +lfEz8g33FjzFECUXapwxr7yQFgSBkg21hUxLubj/fecbFLNtm11z3c4Z5l3N6qAP +vLvrUnxx13EMBnWH48sPG58dMXTutySpIaPH3HUZNd7CksB9wz+FL2x8NiUTjmVl +fP+7ILPOkNykvvHkzMYMe7pRxc7S4K/8vRlhA5GjFKAj16ql/SVz6TpFL6mxApYh +VvAuzl/HpYha3fzBFA71geL6/VtJfojB/LRGWL+buWlwSLiRkeoS8YqrX+cEcfbg +vxKvsTGE/LPeY9TRyOgWmUakjlM/OnnXHVzaOuZmDzMVe26FyG+k3r7DGKTum0i0 +IkD7rYpBKyZTiNc5cjiAtpyPnfHdlXCkt9sMANXBLHYrQVbCslHB2i0r6WFbMd0e ++lBInT8GB8ac85sPHBm+ak/1VYyg/NkWrXlEAnqn0lT+0UvWs74Clq4bEZ7bkCbJ +jA54Z7oNPnn6sGGKIyb7uiHZLFPS9H4ZrAFUpIyfoz5HG311lJqXb9J/RerIusxe +11diiDtqkF9hReILLFuPJn3xpWJGJ+NFmKewm+rjugXfCQuov9o7svrKE6MJS+SB +RRGLYIPT5QFKl9L8IhcrHNUfYP53j61Dc63q+KMgi3evyeo8q9cgevQXRXjNA2Cw +rLspt4vz9NFy0Pgn+nyjy0k2E7rOezv5sK1y+jZb5BH8Ao3iINS4NV8kNloAhVYA +jslviT6mN+z6kAk6qBNI0bsppJz4gPp+3buo2l6UCmv55mGvQzGcKq2v1lgs5Xyw +UvpP4T2qwQvjib8QbGOajevvo42d52Way7jC8yXO6gKqIuRK3M32RBl0U42D9ld6 +IUhrM+61hw6x0SfgWd5Qlow6Hseousg4lsdsDfyL8i9DqcZxUnHkjqTotVaeUzUN +65dVAtyD2dUpqvtdSsE/Ia8X8Gkv4mWSHr3O0yXITbOg/mzhE/uDRKLhG/faZo/z +JeyG/9s43E7JqucZ0RlBGIknN8t4tvVUm8FwMmZAWGp8oOvftiUOArak2p1DHbRl +4AR8XS8pqBn7V8YnGgShkyNKkfItxUyvWvYElO4JaxhS9TWncoNgBcZRDmPYwLS+ +YXfgwLAKPTODIzOxuUxGmsodWTzP/1PJKtCt47RWwFYXL081bR8rth0dM+IRTcNN +A15NWPAh0ka2muuTtP5S+KHECN92VJE8Ecstw/4sBhq/HTm5iSbO/GgmOXciliPQ +7Io6TjTwOorU0owr9wkXIXEKG+AyG3HnK+iviBoRIYPhXYwI0q0kEmXihHw1LPZj +52ugxInarsm0rMlFFDPK8Khn2XxT5aWxJ4XNi+18t0dxbbcn86yKxQ9HmJeWZ/oz +DHMNxldR/LKkk+qs2coXfjxg4lTJDMSjtYeFnD1EPra4aHy9zlpeR5NguzcGcNmy +FcUGT7HQtKPfhWK4J4WJvrnm6hrxiXHocoI8f+m98jO0iL3zzF01M+a3Ab0KSiNt +Wc4OMmJb2y3LpHV8c8znjJf1eE0q5t1+Vqsmvvy0Q2MeUMlPxtO+r8D1ne/JLmRK +NXZ5Uz45raUPKQ3HuAqRNByxNhBg5beCjFiw0QVnbnNL+zfAw8Q4o5kQhzq88SQs +LscdSe4gBwLnRPrLYtjWsu2MWbfZ7DDVwdXsyKbjJgpX8bZMfKZK+1gmMDADw6iz +KlU/LFvFAuftOSx/4fnJxlqVKbIKTyEFjxeW/tOtvvwSZJq9h5fjYrQChvLd28Jd +pP3TCuR6qtNj80Iyl9EnOGKiRtFNnjhPwL2zaWxIjwa/9I7jVVNclV6YUasri+C9 +Mg+MU1BqgQhhobRfI0IOaKsG5lc+5faLfAJPPWsw8ClTzBTIPLSVDdYMSDl+aDIp +RZhhgGjCbAOC0aDOakMvpLhjeikWyATqS8kPeCSJyUE6cMT5AQxBOO+NcrXbubbL +naYrJRHXndwUPTXLrmGpxPD40OcrjYIKr7pbFwWwrlhB2UwIq6HW+4Qmevoo7QGY +DZMKU66NdQPaA2y6Cbv5AtVMnn8b9E9DloMWHFtbCJ02N9JtqyomYG0scSieO0jm +kgvmwWTS5ZwpPkPQnIoKmcOLUZNRNDyML9SVJWv2x4jW23PE5DuUNILaM3nOQKix +UbblQOjNv0EF67l8zRSuVoRYQeBq3UsEMU+3WuImnq3gDli8AblX/jksEFpmmLbl +LWXnb7xEIFOIyQQNm3VxshayLAKjB7ke8hqtdgGQbEWYJSgW41kxnbBd7As0VhUh +ifNaHtpOPRnPhY52/ilaU6LyK04V7NVYdriceH8VLuurNI95sWWiEFLlMoNYwxU/ +5fvFVNYgVRDlVc82KpDqk/1W+rW36TAmWkjXU49zxdW4iBou7aU6HGi4DS1uneyi +r87ZB2RKNP5j36qzZpH3FvOTtORCVI2Idg396rB7nbZjHP6oBlCqhqKVGSf+cOBH +Ylijg/is3sVCABYci52PNz2mflytkqnIm9DJf3hBXjYLXgeviP9rd3hpGHKTl+rO +BZ3AI0/7ZIRTVNp8B3DppGuaR4/OrKuyQXx/7kWmu/jlRVvViI5AtXaXLC2i2ObI +Ll6/nXGnvKT/BZE7gy72rKJOoCeoA4LZo0WC3/lFyhViscME/bZ5i6nyZOcPDuEb +icH16O7FmniboDiAQxWswpRRMdx2ZB1wcObQGj8fGgOEOsIwVc9nw58OF8sXkpXo +4Uijy48Nm7868Wbv6eJroFzwhneEaNoUX827Xx86COWa5G0LJTmbleTZrPG9vte+ +uSaYxnzm6+pM1O7Fgb5hbWPQU52oWNtD3EN6nExaykTQ2NkrGZdC/HWXhJDHQxpM +6t6h7LDBUV12BdM1topizUI/uoBvelix7y/YblMF0G697O7S3G/G1AS7hA65kt48 +kGQ6naz0dfSOwQ4IJKvumpz2oc2FiZmYQJDZIqUWh0njI1gC8sQKa8ssLqy8tJ7x +fT+qNCgYkquO8X5rjpKuQMiKNQEB+42Pq+6sfiz/DRPibH35fcJ9rOyYKf0jIA3r +y9hQuO1R0ks9Vpo0vr/9Zvp5nouEGvvuoReb7RRT01FKR1d7tdFRyNDKHlUywg5M +Ii+YIXj58/6AVqpd5rh+h/+sh1vwnEtOa43FKO282p3yaP3lqwNOzzVuMtV0XHo/ +G36p299B+Sp0uRhW7atdWv+bFOvswfBObJi0o3+O+QfwTMWUbcyL3Y+GcmH6I1J8 +/tbMSyMK2H/NjfXZaoC5EjxCZicFFAw4COX9CDOpJHL3mefAnU5Kaz5qU75n4LZc +Hndfsv3YgQMfvi+rAo7tJKe0blib94nZ5pZ02zH6i+zBEuqiH2muR1eNfkZ2b6Ze +AZ9TkHLfrbLaG4sHPI4jKlK2nYkVGZZzbWnKMdfcqQLUUzps8OHFZyeja0gwwbYI +8t176yEcZrr22NBrQ70+0D1LVaBvdcxPd/CDmh+QVdrPtrGXoTlqs34HKPp8ItYW +UfKm1n9nDDLJQuzSTmXXF+Kc8VZKdXwi01mqqfzZGlUzgr0KoBAmH/f2VhfdQmpM +NGQhIUXNEoxRny+7WTQUppXRZcf6FMBInEOy9fUQRcNX5xNlg8PoI6lUsrZwEUdI +wgY3pfoNwciuOeYiR4qGKonHBZ4CCF6RtN/rrnKXCAWbGIu1vl7V6VjHSFrRp6t3 +2TDTyWXoke3VnxRgAAk+ll/ntmwQL+jnUzhc2m68pj1ZKwPBx41RRrBbdMoYoina +aacKeUNdT5VhdtYifrlHnVqiAQt1e+xEgqVAaChBdV6Icf2KtrLkSic/EoCLaW7p +0azZ9hp5Hs8irg+q1d+JqVWOuUtEU+XmrVvYycmk6HxrR0EEzvVFFUXWrma3pMil +rcHaIgpSyRq7XhL/Z33X26gSfOig6vNBTfiELFvv5vAhxNdXooACg8QvYb7879ZP +vrfv6aXaFgAHFol0QwXFHhVFC1cCeb0IMcj9/aS+utmkiRCu7q1yWEAY8biEvyIr +Ayd7Zs5mmOlw4AmZQzgFyqO8uFNe3pIQEIPExQED1egw9D/Q5nBrBU3klIt4n2G0 +KYKAw1+8j0YRJeNsJdqSY9IirCpo6+f9swfi+azm9Tpg22s28dE9d7AwdUIRrhlx +J8Px1x5I5EULStQbaYuUkgWSr+NyV1BnNNYkTDnYc/+5DJnW6Mm3aJy9YOPszDgJ +NgTSpBYKgVOzL+g9njl6RqL39xGVJ0SumKoTquyrrJ0P6+vbrVy2LtYEhdlRCW2f +U5ep9Blus2hKAA/HZx2smQ9XXXOOU7Tel5vJ6mvaVnVEfZkJBsUhssmEmnj6995v +sCDFJQL27icAiDtTVLAJFvwR4MYiv3xw/fEG3xmywsBYQmEEILcFgWZ5npU8Lw+H +lDQFw+QzKNpbCGZzPBl1E1zhr2P8Yti5NoieLc634yEg3DZWeGJZG6INzMkcjJ5g +SxSSPkKvYr3Jp51S65pVwr1YSd4CWRGvhwRDe1OB2vJfw7CIKfE+Sp1VkMpnq05b +xOltKyL3fcrxiNPBgvFLSTofZbTMWyVrMdBJQW5nHZmBW8GAhXryqqBce9zpRk0T +w67FoeB3ynsXt5vtHLKQe2ywNXj5jmW2S2NNqgDl+ITppZca8Buvq4twrpA21LoD +SIg05AMGIBJVr7JavWEq2p+38R5V0sO+pxAGUaS2WO2Y702h1H26cJ3iQFsoCjHx +2IrkQhjZP170TsmBbkgARsXSW+Kx0tDtmvnMg1iA8eeXWTp/rk3rYGPnXog+DgZ7 +dx3XkHQQVDd0VNclrbjz8ZzlKHww35wt7rcs2EClpp8PgayZBFpJ1HqMGCxDBT4n +BvRHAoIyPO+xl9udXm2h2qbjJPfTZcV6z1RO1G84o/u++lk59xfn338In33rrw5x +fxYroJsxa5giTxDYc91DuTHtwE+40WI4/3hTGNkVynJkCiroi7/+Cc3qBc1w7mZO +goxF0eRp+Cz17UMdiPPcEajfMI0If6iv2WFxVeU4jl6a7GDspUgEJWWGmyh7ylkY +LcBidyrcvIyvcx2ek7YuXxJfHAFIJDBnEGbpdq6/DsyNZiGCytB029acLB0z0xe7 +yc3+2DH035mqL5xkfiWU8tUiSGaaLJUvL9g= -----END AGE ENCRYPTED FILE----- diff --git a/.harness/engineering/features/windows-x64-support.md b/.harness/engineering/features/windows-x64-support.md new file mode 100644 index 0000000..ae5aa1f --- /dev/null +++ b/.harness/engineering/features/windows-x64-support.md @@ -0,0 +1,53 @@ +-----BEGIN AGE ENCRYPTED FILE----- +YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IHNzaC1lZDI1NTE5IExRMGNCZyBCdU0v +N0N1TG1QVmo0dDJHL2gyNUNPdnZFWGtXWlpIYk0ycWtZbGxsRnlvCjd2RVJ5V3RH +RnhRUzcvZnhlNUdBWnNiNFowYVNKYlUyK3dzOTd2VFYwRFEKLS0tIEQrc3V5S3M5 +SWlqVW03cnFmbUlqT0hCK2hYSVFDdXhaZmJtc2d0RmhYTjgKIJL2Qhrp96BSRGKy +SEZPugQ4JX265tAdzJxDlsKdzvUa/cs/dr07pofGKJYoVyD4qEaYAu0k1dTCFa0m +E1wO9wt4FiiyrNTpatKTLJpp2D6TEcKButCshBKPikxDa0Udi2kTvDSb7EX+Ya1V ++i64DfWKeHqmsmnz3VaJTPUB0aN+aWoEsY2zS2uiOkEjTp1BUFhQ1F2FKaQd2kc8 +aWbsyHpyVH6GxqdfBv+ukZu7V7Kl4GO+VuQH8ZIWJb//JsyKXEO28eFK+m+QovFO +7c8tT838EMfZuzjRJ3r/CXC4y1gRzuNJJmhdrx8rBNKyqoEN+48jJhQT4KHOISs9 +YHCfW5DMfUF8c/+HthBUqlRYHcFk7yoeG6QuWECooU1paDxH+k56ot2pKDsn6xnA +8bXcgq/9Pp6ZXnw/fsgmjFlAyPmgP2+T2f9WXTqdoqbDox7jcpWD+xhuI4jevOrW +CxNeSZs8UxhnNVdl28CClN+FGuuyOHdkBBYhHOHuBtw0/5GUmCLf4zTsyBYpfh03 +81BZUXaAL8rLQLM1sXh5LdG9ckLOO2CMy8lrUixxm9X7cTjVfV9mB4M0h5GgOM82 +9Gn1Vet3d+agODrpNbvM5zwoWYavvgdjVvVBJtwu/tumn+v8/t+FFLVBBcbQZQsu +lmxV6UPOQgN9sSFXwlxHmpRdSyJ4UkNEQQ81Pg1ujwxIyOpmMgnNihIvTYI8dQ8T +9hz+FtOmMjrW8H9Mn8yjPvdtyutoL1hJz3EmTg2k7tRK+ir5Xs6VRK6Ewmx4ChKL +aSTN7c/qB5WVdwaGxxMCZd1+iCgWyu5Ng4miw6yyEk8ScDrXQo6WnEhMPD1wV/LW +CIu7PnvL+vIDiRGykj3pzgdwPkkuO9wkElzUZccxeO3IlwD9EHLpxgQ7xf/Kgxa2 +F6YruZ5k0caHQ/Lh9mUUpWOf5u5Ou5Bk9KZfZH9a5QuIH0tktdM/p8tqWb0miFft +/fXYTbz073wwCHpiMn9eKnhqaTvYKHBxC72e30Ox6LuKknQ/5e7g6qg4oqtKHDlF +2ZytRaYukkKKKB8LHgwx9SSDb0n8yoeIQVXF8mkP61WsKjh+mpjUpcwILdh28HAW +ChIlHDry2sStbAFT7IRlSJYEH/xvG2tbfz9aJMzyVZE5XVDlSLfjg/D1lp4s0CmS +238gihdXinOzlTvbbqrmR9FArhM5Coh8YREnEwbnc3Jkv3kbYGlZpCtn8c8TzEKa +wdfEDI3DJ5Qs46azeLWhiVabg4GpNa6xIIVIyKDKAAvyg0hAgxrxlSfqKB+oV6z8 +aUUobXTI0Jx6LuPNFDG+BhEo4bjRLObKH4q9Xjz7t8zk4JdBOoSKzyplJTXpxmcO +3vYPN/cjX6qrcmnyTAGklYTUAKl0R4YBpXEkH9e8OvE9cUZC6GG6g2SKQpAGZEmU +I0rLghq2yxtdxk59WTofBUch39kQjdjWO8zEYyxad+r/f45vSSt9bCTWGY3Kccjn +SL915wzxoggC05TV1tbNUh0EISyP3HSYcp8AzKp37DK871y+HesjFCvIulv0RWtL +7w+h3o75iD0xAMlYVNb7urPUD38oTzHbZArde2iGUWU3yNMgZGsj7vK5ZJZopX+y +N/KSMSov7NlQxZnF52OOJ5diWw+bbi0eMHEwgG7HSoziGgIJk2C/ABAOiCv+sHwL +dKaiZ3UMJdGJgG58hG1L2GfBJDpNkGEXbaeTZoIj9lZP3BUuqH3LlyetQciCpmfI +ltc3XbUNEnQcSYu5JM3I692wXwWC7LYEBUd2uSuXxVgwsi38/OG4jCnDAOAhkVEe +S4rfxnwSoEps05douUvs/KKJJAZfAhYtFcude5rg4hQzHZyPv/r/gOWZx5xApAzG +DX/R+B8p0MPbIpd0DwcBmzJyaYkEy+bmXgBC4QiK3BClbIhNTbb/kLgqXx6SpOot +qr3KM+yJEMLFPB1RUwAbgGB3LUnrGC8HfW42guE1DJYKydyWuzgcSggqt0Au+QQ6 +8fIhIJtnfnunKEC7gMBxKf+0LF+VeTG8irvA9da/D4eA2yYmTrTO8cgZP8sUwV9s +S2F5lxrkPIQTTYWml+su21F+wluIUK4YIcHpO1dqHMpV82E1nA92WrAKW8vOdi9v +FdK6tLv6p7Gsko/KsO+Hd42eZTqULzRkgQHxYefMkd80JBdmG3wutY99cXxCLD54 +3DChQM3vB6Cn8S7oQ57eddFEnHt4RFHwB4X1sWfdBVvfQRQnJHYL/LBSPjUpHWN4 +WW0JppuVVtxH5CQs+1pK5FWPAviqFjSvnTa810/agzujkoDrzz9PnqdP/qwFnF1x +a9CBnIELvONFDzqz8M0HV2DhU75O1bOlegRYcP+qN4JNfO7Xi0ZL8UhXrJvvymLo +7puD0Q0Mwn8wZxgw6d0plED4P+nC6M3p2ar8/IrcusgQoUcIg5zU+PgY2D34ZCkh +shgoqHXKpLdQqGAZEzFLxldH9OaZ4JHcy+h54LuLHwuWjcspV2YgEZopBYJne3CC +0HIfMs1gSnz588CjpFWkMRCpdVB2+MlgwVAwa2wGLmAsahpci+2imATeJYQPS3Fw +ihxlDKlLEslWkJzjDjeiymbZXBJMKmIOJ6PfzAJuLLyTGAhg6KKT6QfwEEro3TqE +hzfAtKHI0aFRo2tZd3F9WXuakUUxLQ3zYB33cAkixQR0iDlWmuieDzFhtY42FFcL +l8DxaS3c2M1WrpG/5kIkZHpmNUQQBYQmFTvTB/YfUd3sI8LD6TVgRns9r1bMN/Gu +C3/y319rWtd0foxRqUCDV0DtaEnHR8jQKbfu0fh/+X50WTzCahcwJFkXI2orGb/b +OD+/jCviRTJO20kiwMfS7fpc/PpKUoBpQXIV9JfsLMLHKBzKx4pop/pGW6OLPdTQ +sb+iEy3fAvFgvV3Wevx7C33eJZu1SnI/KGcmE5FFGxvYKE1UyT+nskAEOiecvjBH +fOURlkv1afPhxTJwXKUrJuO7f6PP7sg2PZnGZYSByWgIjI88u2tPN0I= +-----END AGE ENCRYPTED FILE----- diff --git a/.harness/product/announcements-2026-08.md b/.harness/product/announcements-2026-08.md new file mode 100644 index 0000000..2822f49 --- /dev/null +++ b/.harness/product/announcements-2026-08.md @@ -0,0 +1,38 @@ +-----BEGIN AGE ENCRYPTED FILE----- +YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IHNzaC1lZDI1NTE5IExRMGNCZyAyck9r +V094anc0MTB6YWcyQWJ6TTd0R1RLeWQyakd1UktFYUp3NUVXSEc4CmRPTE5nTVJX +bFQ2a3pQY29iSzlFcmx2dDhzU3lObkpFQ0p4MzBxanZkTE0KLS0tIGNvRXZBdkJW +K3hRT0Jxa1ZBQVZkWEFOZkdVVzZYU3lDOWpJVHp2SHpOMmsKkGETc6WlrhRzSAus +Yc0qumuO4nC0BJuDyEGJD0VupFC6ZrUkyMunQTvMOq3eFY5gPwNwyltBPhQ5hhpp +LeYTWXxWQsv/97kGa5OXeRTOLxuRPszes+4ZWG7seJfEhUV73UYACpI7Tm50z4RD +LKhqfxiExmmIthltqFG1gKPZF7pu8gIV28VCTl0m20duBUwqRJxeWL8SQEpMUuLm +cAB9jIzfxQM4AGNbuun89w82AgKfSMvPPYjn/ut9ZMjMEvXLrMl12ryIssoSrMUT +r7GdZwMVhYcX4We+MWI+F21wHoLQYJfx+HTnxIRNN0FppbNVZ0uwklN2SK5En45p +cf+MrY1LVzEgYieuxIaAD4MgcGS0JLCcY4HEbDCt6CwCToSKz6yEIQdoFLZSccVz +hF7RhQn8FjsY7QNjRSRHvoALmqpt4QkQgL1ZNDasWaJ7M2lwiIjLniGSAjqu1qwB +2RReGfGIPaNbnEUICRfmxlWfFsHJvAIv4X+LWAmbWIadIOIOFHI1xhEYhzrAMpfk +iN4+Ou8eWO6F5zVyQbeQuqAZsKEl+H23WUs3CLEy82zBTSR7Yq0AOgoQJXj1ksV3 +WKeQ5eojY5sbxYvLuxW/vZcCoEOg0xPoxA9y+TKS42loSK1/A78VPZIg7dBtnOYm +VLl49cgz5EIzZCdoYcz4IZyPcuk06SAFkxyqu4/slRCIeW4//3kmXGt12HoKGceE ++kpY1C3NiVg8SMlyr21yjnvhoTY4p7BbM3hGLPDtODjn9huwDCzGpP4BXLudOdTm ++NcctwOMPrDeMjtRRqz80SvtkKoMchP6VSh9qVQBrPnUko6K+gXmxiD2CG/VCuv4 +JmjcdBxgjGMs59yt/M+fpsj5QlGA25djcGfoRrmy+Et+Q4nJsa5jofmkb9g8gsN7 +IAaEE0n/TEstrBbrZv5V3r7SZu/al8cuaWxDg1IWqE5kJbm56vaYsnmpf4GiuMrt +nJ0l2wE0kMpRRIVBO+t0rZTAN9GciCsMVmv5bBP+hxofxTsRutA3P6rmfkFBMlk4 +s9khHZwgYmjs1oUYE06X/4AQ9VLdaWHN5AZ/ArCCxbQGL8rUYELZBJPr4XPzARfN +0GzMK7leQ+d245ZJ+SVFfZa26F+qmADmQaJGKoA3XOCFqV2xosG8aQSA3zDFYp0E +VCtqsyqdEDxNc5Z3x9eRQSzknv/Q1nbotRTZmaTCjXaL7XAD1ldBF/GwvDWeSJGc +gK8XQinSoI8+/Nql6A2KBvbK0Jy3ox5pzwrKAOSe1Z+u3sKg38qXbXG5A9SKwjMF +G5cHZWtKmPSXRUZAAbxTrota+c0nHWbdBBjzQ4CJn1dEZRi7E6MDVZb6GTA5rbEU +IW9SwHf7sDCj9Qog5q1AJwT5SsXpzdWaT+ZUhM7LigeVYxn9kngI6CQZYYeXJ5IH +o9EUYaGlORkG2iK56CNHSbaXweC78NpggYyhOiBxNgXAcvkPJNFUC8pcLwoQx5NP +DlkrHx2PRoI96iOEWQ8vzZZZtIoge/icmmVGjGQ46kZus82PX+jEealSyafhkf9/ +W+f6mZLZ/0rvZAnWTPt/VwCwA4KtHOVXRrtV/OhGw6t3z39GJ64W6v4eAhq8z/9I +S+r+591OOsuE1B8r1xLD63Q054I8cYfqQYB1UQdTVTGPrkFhrvIKBPfYxcesZPJ9 +e8Ie/IMKUvcW9Ox2lVr1EDDRR21f1IgZAfs9W8a2TeThKk2nEbS2WYFMng1URR4x +0fJnefKfCQr0J/3ONewa8TkT7rwwRZ5lPq/RRF+z3lPLMfexUGhkNYqgUIpUv/Fg +8aCHPP9Xab2HRVxn0QAdTKwyKBhoukWheGvV4nhKDu/kBd2gyjlcm7ifHPBkORmL +5QUkwmd2gNqYh0MYVPK1XDq5Um1k712JzJ3OErb5AyKPvVUB6tFQwi4JbBfbZgw9 +w7gNK+hW5Idw2JYoPL6ostzp/UcM8Zqs3tPglkYXVKIu8OS3y5GOHDFMogXmfSa7 +VIs2CKnYmde9dA== +-----END AGE ENCRYPTED FILE----- diff --git a/.harness/product/roadmap.md b/.harness/product/roadmap.md index 7999385..7803fe9 100644 --- a/.harness/product/roadmap.md +++ b/.harness/product/roadmap.md @@ -1,157 +1,162 @@ -----BEGIN AGE ENCRYPTED FILE----- -YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IHNzaC1lZDI1NTE5IExRMGNCZyByV1pS -bFBJVUFaV1o1SDBiSXFtemYvaFY0ZytpWjVJM1ovWndJRmF0K0NRCmUvQW1lS0RG -MjZwVXBiNjQ2ZWc4dGZqbzhzN25vTitWUkF3NVo2cG1vTW8KLS0tIDh5UnhQRW1O -ZVJvTnVBUGpGenZad1hXRUVYdVBBR1BZdVgzK2FqYTdlT2MKKjETeY3UHGInwsqz -NfyB0oshSb46fn83JKzrGQhXPAW+rgYMPZ/5X9h+lyZ1WwyskyO6sud5c3trgzHt -nPCx+QT0gu1KX+31TyYRDf0GTnpf14G31dcALklqOIer4e8hHj9eXQlOuzK7xptQ -CvNTGMgPckdqMhD0krB8XZIUxmKBemOYFRK3I+9WsPJvwXJR/+cxO+YECA0sGNfq -EgBl6NBGqhKwYPHvfNR0AHNWGYvRQnvzkU8Qsarb9SnHqHwNOx1it2DjWDk+ntJV -CFyYhB31xDUpvgbOQBotisKOfZtUkrF+t900kz2sYn+B9Z/fKIX6q3EtSKhOHtv7 -WINIjoh66mND3L65srSZc7umYa/LI+PEHBpLFH53wUyM6N/jiiZEjrHhFnTE4D79 -Te3RWKLYHhPbKgCiu+1e2BTrDLwGQQfgLB31VDnX81bDzfI0+4PNEYpBPs2XkXFG -O07QYDzvFMJ8nBLBMw1gRNTc88oXgYRuVI1D4xEIlRBTVkJhbV6GazYMNG4AF9vt -gIM20CfxyfVO5UFDiIhenTqGGQkdhKnoMxRZ/1Z1CJitVXOgIDZ3Askl7Q7dLXnz -ateudgy0IGZHslwJllMh+OQofLA4zUqyhqfG6zuOzx4o/wilGCUkNMpK7sfyKAee -kg5DZH5pDnQPP8cjPXzU1Aq2PDzR5sKiu7ztfC/CR66Kw1kWTvUpUtz6Cko5iv15 -vZ6JzipoA8oNhBnYtnHOr2RqAQB4aTEiMSK2wynnrlgp1F9uUTI+RtKzFNCUZ+rS -+P0d1E8naBpydPUANOUZ3erFDQP1md2x5IA+IAJZ2zPGUJ8rTN12zFqxuUJW8OJa -l+a8oHkcq/it/I4tD51ZXW1hOquTGdurGVukCMh3QfMhezBLDyJAGRyY/e6Q7qTA -N0v4Wf5XDYOlrSRuoHCeXoXT3SrBBMSUGBSXWhiyvJuJKwY9GV3Vtw/i+sZwrian -icsqUlcEeKXn7Nx9c3WAdX51rKJgT9XuN+VO6y6IAnkNgnXa+BYl3oq4w8Ha5Oxm -KmlrS6QltUmp/DpYHeNmUFXgURrp+6+YKGB31V9q/ssYjIdYmZK7vs76rO00KY30 -A2PxYkpSX8pnnKnroAtI+/nnRHB1i52QIwuJfkwEeAOo4Zos6821XTwlqF8x7Ima -vuQnRgsZANhK8RdemXfPgsQ1Lwa7z7xTYtH9vqDBMKmCLf80vYwxlcR6KUdelfMa -FSsN9vx4E9eD55kckWn+ifp8nUemPlEcs3crCBYQs4nwyADd+caBarWx7vRH7gPa -b8yPXBDDbjeU9njCqZi6t8kRjN9zFb31WNqgusPW36D9yX/yLwaudJjkS/SmZxF8 -efpYevwDQ6VJKGNIIWKtb5onG7ezIM39eVLa4OxAnZFJhDl9xlpXzvFKHbGWG3FG -zVMG4K6seofaeOT+rQMn6h+jmXAByvFMJbbQZ9oSgvml1PjusbIPkyDSjwOm8sny -I7Kxd5DIb6KCA7TiCeChS/Gc/+LZpj3UbUj3caJeFZ5kEexj4Le4K9M9OKnua9st -AdS34LEuZJXjfhH65qS/W++bxf4RmCZrZ55VwyaVfJXJbMQhuxs3ULi/zgCPsxzG -0uZkxQCDSXpq0fHh+TjMbKe6kbG9ziGCeR767flEBXz0CtKJvdQE/4L4C0deuGou -f8mE72IRifinseiRsXzQ0C59lPELOjUJqz2e3ahJG0M1j4eZ8OXQMVkkJbbVG+9d -n+7C7S7k2ZK/ApuX6rrPGlOdH86VGjSFMgxajwy8gNGQJrShpboup+RBV1SinSl5 -zDIHay9h0Sf46ZDy3rFLX6hwP5OGVHESlH0nU5NHfbJO73Y5WCaVzvcuui2es7+y -JfxTYr2oqw0GlYOwm/fSos3EzsL00KPxFGP462A/JReL4Q7zu03LPX0wzqbbHY11 -FBmgQJ4bgsOg/ZlHFJA2IzvAvCpAn8tVL7KRZ0ToXh6R9cw1kXLKQyb+ROLj2Qv5 -1+C9SwbudQCIBo/4R3ers8t/5HAcqHsn7BOwXbRiKQidhmlwZ2dotdWvddixj5Uc -magIFIXzhq5JJ07KylbM8ZOS9WZRHVckIdUOrNwp6yhW7DYO0QRHW9A74kYm8yMp -Dvl491+N9PJ5Zo4G01b+pFX12xbpVvW75ooqcYW0teJOIQYUzKUj0sj/dsucq4qc -nYO3Dv/6DoMOUD9RdOkgenlat/ihWhTcC5ay8YV/wjkYV09tWvMNj29PXmZcxa94 -28+lqD6P+7qt4zj9ZpLP2r2rpgoIndY7l/ArVtUMJyiRjx0f3hc85o/NfQjp12Ga -WCGOxCGi+gwYSp64PL3kbN1qjOl6zXZrU83bIc+/Omm0fS2Sg14I6SSrNoIc/pTN -TiSIWCRhmVy2r6zdsnV+Z9KF7CzwfxzrzuW5Eeoz8qtTDLhqmHrHstxnR6iw13vY -+6cIo9ILxH3DH73KF/+cwl5iDVXqnzoh/M6gd5xYtpQI4hPj02hoUJCaMc3qEtrz -j8EakbgetMIKKSBdSCFj077OP+kq8NVtauOXUoRQwKliIbcIrNRG0oiaZyT76Uk2 -Qr5AGc10jHe/332Nl1DWi1bAJuDdrU5qcfAygOG4wlDcoRtKcT2SHjygUE9TzF2M -vei+U/mRacR20PjW0LX0U+yJ7p7k/gK5PNZk2ql449ZUegXBlKujZlG7egExOUHJ -DcLbJ6U0NxRTTpo9JwNpZx08rQaDR/31OibUCtlxq6iMdvR4gZ7IJ3fWRfkmUpfk -9OnEtrMJANJFAJUNuN0O/bCiZoLv1w3MXvvWLRPTrdvLN8we076SUdz/V31LaMw6 -KoT/ImTPpCyPQTbyCGFs7dPtGc5KyCEdNTeO+a9wO7tgptERDVfjTy73yMeLugEp -qb9Eoy4nGFRE34+SFG4vLndf/gAENUaTkeB5yaamz3ZShySYURA9VpfcFTgx5wmH -Ntj4SF1lgXVwzCgLVxF6sePco039PEE7aQWnZx7mohywFHFP4JiZrwVkWLA/1s3q -PKmoGfrFx+GGusS+Td1gXwzyvoF2FPLdyU47gTGB237a2/s+nT08ncVy1ixekndo -qel7eR6YJNyKu/ZlmB5W4nDoCmgviwpjBurjrboOQCEI3qulfKN88KKkmNokRPEh -se0l+eo6i+s8+yxLBukRhap7FsTERVP87MxTJ8SSqU5IJ5JmYjpzjNA2NH1Mb7Yt -3G9qbQzRmAyPc932LtWOEdvjSG3yhP6/GoaRKGWv9AzK+sovxYCqHTw4TisfV0cQ -8HQdyaQcLLyYv0sD6vo28b3ofeUwISGy0lEMc85ybQ2jk7qq2mDpB5C6cCRTPpG1 -yhj9MsMs00uiJHxG/8WUuyd1lJbXYU9hbEMffp3KzSvgwsePxvSluwzOH9NbcSL+ -JG4qOjw3LHAH+jSvakxrxeiW3CozlMTjYfESaYd6wT1tCIJ6/shNfCzlPgxYG8pP -Te6CGYXryPA6NQwvGMZ6VAquSdCxqqUFZiIqt058pEvGTbkfzsQ8QsZpQpsVY8A3 -ehZy0UFQCBAr8tO6LTTle04EX/8UGueUbXfSZ4g2f+F/TWyV+3zxzeIlp0F7PGQj -C8EqPQxlz2gcGxVNS64Dwl5/3Vfe8/mRby8RBZtQNBGsPAYESxkdIa65gLxQ9eAs -tepNWBINI5j1TGSF4kkVYbdOXaUM1JOdiJURamM6O1ojOTplsnty+/2Tv72Lwoat -RVUN4k5It+icKQc+irPw06HwhWHOBTIVfjdOYAck3SoTgVehngM9BEgy1bFjBPVa -46trcG2AM94+1uCVuv3Nl7JLFVHCNLK6s2ZWavHtKK2HlrgNROZRCVAUPskvWNoL -WME7ZMi6bZKOzxuxnxLfKCDjxeb/10Zqb0/lEV16a4JqHOZucZEPp/ybHhoKwicb -LUwXEvWQ9KQ8fsL5tMzP95g6Yo1xLk8+ibZ8R8O8OQ+j0CTezm5fVxeJYlwkFVNu -nnmImx1veE92lJzL+b0D0Wq+XBSPRmMtHRJ+izgwzx2zC7exXJ1BBqo5L6u8bRAJ -jdZfakAYeyfYsg+JywX2ycRbFWr48N3imMkjSy6J4zcLI6YH51zWi6QQISU94raa -SHDu6mPPNmcKHYaU89Dd9FHrmmvSBkYsI4wwihXSo98EL7xtYsthz/6MCzDwRnJk -xTir6PcbBYY85w5r8uGooksAlUCq9ip2HYeNHaIjDBe3wM0QbkfsuR4QYkc5WoS9 -u5iFxF811C2WKJk9l2uZPuVdi/N3doQpnExLGG0I9Igt8LokBwvbsraek4ybcpB1 -lYLfaxEPmki5+teiBysDMWqMljVjSNRUCiL3tE94isbOvvhH/lpZgJx8ZpmARF3c -VXe1L3lAcksgG+iMVpk1C80HfCyW9rZf61kMw+jxuV+bx76QFk+C4y/Vg7OofnUy -4RCqfAdNjvgpKTZuKW2YOZghxb+xNOI9HHAlb9AnYfpXlJWYVb5Mfum2xcO5qXgV -Y3bQqhYyXCSdMz4qkV6qzNNjAfCpozeFgumoZs1LQrgjOuUFlYZCXKjnUX7KmGOS -m0WVBshIryqbF35u25/Yzo5PmnWmpy0dJwXY+XrgQOCqOl5A7LcavjYVxOlMywBU -sNsHlwexc5BVDMWi9veuys9lqhYILeP1dadbK7mGxhORdyYSNQ6rlK4Bw1o6xmyt -bbZ9hTXvKLw6qwbuGQRFYOSRbE6NjkWPprgsVFSGjyURVvE29jlBm9c3IETQmblx -erRSmifqvENs6VT3/2JGpd4d5z0UrL94MmnS5R19J2Evxy14K/qV4jcx2LckLgiN -mSqZa7gH1LUgPFUAx1aR6mKT/nFS4kt4ltySs815japHO/o06hlWk3/kILsP0bOE -g8cacv2Z6GkqLvvzjKEJ7RyX5MA2Uq9DLPJc9CASRpz0s1fRs7E/PXpdE/RXbasv -8e46A3dNcZV6L0rK/VpwMyghKYncLh9t1zxza5xfVA8YdPQ9utwFUFSrbdN2ApqX -YCUsNn8IqaPeoZA6Lx8rnB4QD8i5XYem3JBqKtE3KMKXPxp9KnwHC28KWCt2YiMX -PjukZeITdTT3DxS5gsGHa2QbiipOe8Ov3Avb2THQc/sHfjeTmQ5Fr/J73OrZlJgV -EzRnZt4gKahhxT1CNTIxMNHuVNIKdxZOcrIZXu4jSV49D7p9+LL7a2kLJhGlTLwg -bRgehO1KhWYiO5m+ptXOoM8dj2QQgM5ZbJZA+/IHqHpnVhcMr4OO0gnhOsZJUX2x -3O51sykxQm2IwcYMRTwBSjOv9KkmO2n0JMx/IxmXfppBvvqLm0xTvYojb9M8toI2 -Iv0Qhg7ARiwvZfBGULUPLJLv4wgX4+r2ETJY73tOqwP1l7iTtyrhD7cdlR4i/TxF -R7CUX3E96XZLM5ylfiiEQij+F7Hv+E/I6a2RepuYVQEQjCggI9GhsZc6oeG7OB53 -ZcEDBSu4ynuUR8VllRpoLKTdHw7sIEz6yLz2o3vOU1Vbibh549BEaneepqA6b9T9 -5eQV5OvpVWhTdbyVzSTmqXXQ3z4Y4UrrCUkH7NZwVOaM52H2Ft7KmOGIimj+XYxL -gyCeJxt9KBkcyAkB4uDeYRcFPHF87xDpFhsuj9FL0SYYl4+nPZ+aMu7OfDkCkZlc -gz9v5vRttukVgvWzX6HJfnfd9IZxgToSosg2r05LiBNnYchLoh6azNdEeT5KNc1+ -aeaE8ypJR44pmn5WfvnUdJoNRw4rjuIyeMOoaz3/vh90hBH+RrBMUWFAvKTc0lTE -HA5r6Yxk4n9HiL3hpMb5R0yLLZlHHfdDxiHJlbI87qPaw0VVuLISRHT77nr68hK2 -sLKcc4P4WIDRr/nYXVCBTmRjV4VTEfLLRSmn9YbyK1PnAB9KJI2W5giPmq806BRP -19iwAPPdU2fh0BWkn7TOmQqaq2gIktHGX9vrr9n8+zNs/q3mxp0MdV1zhqbYwa5f -ZUMc5PqlYOiLLGP2YtnCWIoHR8Y2G478//eK2IB29PAJ+pYtjeHo7AhS7KyFwCIK -waSn7qued2hkV66MbNXDwtkIuycriw2nsh6srkRvvm32RkRVIaoBxrfvMRDwxCc2 -9B7cIAnWfUdx3CFAiWQ9NIwKtCZilH1VDEUnpLrnoQx3Mm6xDE4LHdU34WUfwEmD -RrWHuErBXqA9A2BJCAI9wznpcnvsf1V6/3h5W/Zlkm0PiHw3+dnwjYLXALcf3sSD -l63kWDHT8s0ySvILbabG5s7BKc+jdzcZOJpEgJJK0JXIj7fsWHxgJJpxVVg58UJr -QfKJcMNPKJXkfYYEdiI6zu6quRy1US+V1OxNKd8e83J9TlllpLkhjfDZuUKzvf/k -ougSbebqM4rshk21nb0syYXlcFjBu3k9WFp73mudMBOtUwbaLiEa6x8IgtDH4I4r -+hOQDBfkhQpmkUoVKYDxinfTVeU68H2mzZKGz51aYEqqMa1+e2CxfW4U2uZUTbcs -GQgHp+2ID/tGjBTxcf/VrbDN+1dGyWjMqXq8arQ5aTaeN0VH2MffJbLBR4r4lxdv -RVvIzaRjUw2XrS0ZL6oZCAiZTYChTwq/qN9hjMm8ZnuRw03cLyOT4ndma21zMQAh -G/u2thLwkbQM770xUXphEXKxdJgGz4PkOj4RAaCk283Q/E1HqY5M/vOHL4uuy/Zq -BTS6Btjc13cNysta3ds1Pkm8yTD5Bz8w32S/SSdPti0E8PucMIcTWmSfH/5eUmp3 -kMym4INn+M7ElEhkKp5rn4VP2q6tYkzXhvJR7mOZTg9+7l8Xba8heZieUS9A2a0S -NBpdcuBDGHDVY+zolqU9ID5eV1OLhrpMFwwzpbjQ0BkkHW9K/AGUGUNLDWjCQAf/ -mZt1Krwc+csnUuO2VcVC8Sf+bZ6wqJDWfZgXb821xFb3RGX0GSODUTURz4HEAY8G -u+3SDRocZCGNUZ/CZhAh356Mx+Bvp6NrLFe7b9y0YIWa+ibyDjCkMoRY+eDM0pkq -Mmq32VVSYXpH63ZKXXWM9QedGXLrkPXxzf7JhtTUUC5ga0jFgckKcYor1YM71C6b -fimRmwRpkq1qFCnlptuJbaVxN+GSBUPJt1FXduwcUkItZt7pQ9qe1cc1TrJIWq9k -bVJjOTM0hoyG2lajHGD2pQ1pYhzkRC6msp30uQ0hEehB59O4/eZFsHrvs+pz2XVq -Y88CwLtC9skDhrVjG8NdkTW4fNLkNeHNuNoj57uIE6gcVWAPGEMKp2t7U0zwDQLD -zaXNr51745c07QXirq/5pgbybWOeEOCy0ATdJWaAlG5/bwPusAIYHP8unCptOn5/ -r32S4bBxvZg38KfoRcwL9GV9gQ/3yGh7b5rfl/88x/icrp1WhCQLSa4QLgsjNHen -6pBn+abyMIQEaYI3lWuR1Z4RlHWKfST9Qm2IbDNoYkyTGWq18owIf4ha4oz3h+Rk -PF3ZUwBNlV5ICFL0gyD6+MHsRvRnVA7dBv1ujoWcWWjuf8PJtCGhQgz5fISRhKIW -vR+UHYK4qp5G6sXDjijWtCBp0PdezztTc7zR/RJxS0Zyx1uoS6Cx+GZZ+LSbJO7r -LtMBQ07r5klUG0GaKayS9sApccUeuBLKsV8GJ8huQIO7qbRYpngnIWoxUjTmm/61 -SPRLWGCv6pOKmRDIWeL+jeUzelpK7KinhwJf1GEb8jKAtKU7R7rGNe4JK6krHgtt -PjyRhGKjczg0AYb1vJo5H/MsjOrEUdyRduSzp9m48Iu2IKGNhVBTpFZBmIp4KeiK -HKPiHQAi1pZiiru4wcgMMQfStCORtb0bUwmhjW7ZfjmdQAk5FKdY5NfhFBWkBsSy -4TN89+pwGJ75KxYPUFumbyNPHuVkS3MsU1q8s1BeFtxwZ89iS9NvZ6pmi/yjNuKd -XXAwF4ed50tVopLj0U4NxyVyY3m3Yt/Dw0C2lHscmKtKC5g/0QqtLS2VZrDoEs99 -0nACZL0BCXJcx3iFhYBbia8waiK3QxgtclwMBm8TNz0CdLL1oPHPpFiXRyIt6PVI -8OxMyqH0J09uoMw/pg9w4xVisgL2U8SzEYmQS//WfO4ALCpfVMBFfgkwJGKnr+/9 -X0aefwk/v8FUi2BvSu5tB9B8ok6sIeL/4bdPxO4hkyXiyLvjxAPUkx0+reKl5jO5 -mEEayljikO/n5dMCQeJjmXSxcP7yCfcwykMW4gvVaIyaEWb+gBUzy5Pjnbv+VLAl -7fJIU1Dqk2T/ftSLpgGvyvtvlK2WnISodh5JXbFbt2uUKurGdcuR+CRdLpbFo28K -y5MTCinZW5n4H5C0bF5IlrjwRUuVJnmICsdBcBglR/1CMqqh+H/sKEKhw+bIxCxQ -+DITNgEJ/9pQXXVUCMxMihRMuPLjMHLKa7U9bIOh5DF4R2pSaJpbEyyIfDPwWdEM -VFH/q5slTxs2Tpb9uIbuwXFrlky3g61AJi/qHdlGVtEICEcszTeHOen17wSn3Qjl -dIl9iN1rzutBHvLYm+SDLCI8Kb63w9Z1LeqlQaG2O++UrET5pdgyz/sRdJoVi67o -3ihw/wg6anLAIWlWgJEBq0wB7Yzrl52I7yor0Piw9u146/VguiiZKjuvXfew49Ee -RQ55PO0hhKnrIuGgTpNwbP/SPbYTpVESK2ZcHc1tig9tg3JWiBBIWHeqgJjKx1R7 -rtron513m81Ifqf2drEyKVHfSf/0B4HAEC01Jp036T7LxIvAB/tv+gUAeGNfyV+O -NBd7shDpF399DdEqbl2DjePCCdQQqW/XDcEQxCMoDaQkGRjMtnSWLBcuhs/Q2a/A -1us03bnZHfixux6tyM2psVcKTVgb2h2f/PIhLQZ9ya4fmU26tkaz5Xn92DrqO+Rx -UlY85xiGy5qbVYMMuthTT73BiEzt5P8fvkXEGoaOdbHF7JTOAf2CJG8+EobFH3dg -d7/lLCY2U2ngQeRo9/0VM5PZz1mFCAYwtwpJR2EDxJjMDHscvLbrfWpyam9kTTRm -6odmuWaVkNP4c/xN4/VY7Of3lmGER7EW+vNxcfeDwxtLpgFp+7lxh8iVa8ULLYRI -kDWBiTPueYI49OHWkHWJYzbdoA8EM3SReCi4ZgDe0/9cbU/fBA27+imFXVXcL8Bl -n+OkxSIxq94hpjUUysU8o2Nxm57OS9BxX/TMjY1luge4HmDddiKkPRsmHehzr5ml -Lrs+2GFf6iBPjiVy21Pn9echMMRWt4HJQZGLYQi32TKHaUFAD/owh7YJSVzKyHdK -+xIl0P6aFREpZQ0BbgjyQo9FR/2ItBoRa4HPItKvfe7eWR598kJ1XAmTu1R+fVYi -0Mwu3mdp5oraGf+m1bby3x54PWzBYEgR3LlAruu7BiMWWls5YouEpJ/2judiLNga -cdmAnxtVTjm90ecb8iFZSwnWbX64zjFR2Ys4Bdpz7q7vFUH0qDdn2Wf+BgIAss+I -MEMu4UZpofE5zMu30xcuupsjm8bfXOK3lJxL4aU0AYAIuHAS0zSHOG+56selnm1m -3geC1FrUaJod0vmllaWsXGiUx/mMnjGxY5MV+5exlcxCM6+Xq+AhQ/OZAmTvAFex -O9gfmRnk3iLeKf40vVq8K8tbE6zMIr2qp4T/jssYKIcmOBqod2D4SboR4BpsUB52 -2GjElDlJwtg= +YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IHNzaC1lZDI1NTE5IExRMGNCZyBxajZK +MHJUZDdxZThIUUxrQTZiclZ1UjlUb1R1ZGRPWU1ib2NhVEJDVEV3Ci9uRUJ5Qm9E +Kzg2Qm5NYVY2UVRYOUwxNERGTVd6MlptM2dNUHNJZk14OU0KLS0tIFJBTjZIOVRH +NVM3R0xjSmVsMTdyaDhCVUNtNTdwVDV4NDJaUUZrSzN3MUEKv2yIFQjDZKHKOBHq +BqtSuLLz5ksX4bsnVw1Q9vDeS38P7fEme5WEmjOAXGDN8GcNMuzDaNjqiKncizuR +VPc0xlBc7j7/voi1qRIB1zro4LVOP4xSBCX7wIwtJjE4CLXdRVLEfRmZX6DN7jq6 +f2BIa3P5D1VTfnjUQLOFvnQ9lai1lQCpp3Hwlgcu5FYLWynMnwCcIo9jYL5G4HdQ +ikof9UR8GyKS/lQx7/RCBlNRcZt/lqWvzmF2NB1IRc+XNXsZcjeNWClyxh0IwzG8 +e7TEcOMVo4Xqq9CTTVk0BJFVRhBRnw7drXhnDGVdoXom0nC2Zms1uRaf2kmZwBHv +pYh0Rimy5mcyU5LCICvNUreHub97/s/T0yIImIN/Rc83uhREuaOrB+kx8z6VVgQt +ibKHcaYcr0XDbZNBhJQ2fXbIjkwz9XhL5Ad06E8tsyRAoW0gVOsHBgHhJd8DRHO5 +M9KTVoYz2202OlSZ+ng/IzI/j8t2frAiriQPfT3eelt7enxYmTbeRIUqFmTAc38l +TvqyQZi9NezeqN2ULdfUWoLD5e7z5v1tXZkGZ9hN1HwubWB3UluNbDhr2vw1E+vR +0f+h3D7OV5lBCWCP8WXh8CoBN4gRPUfqAInkufmk6gk8MxSJP14JG4xgSFjF2Lg4 +otcQ+oJQFloYqVz5IA4yuCkedW6c7HItN6qXQNekHtD5znr+sHRdbY5PHsKNd7mM +xl7Mn2nk/ehMZjjqtXkWTie+nbaXZeEg7FMDIVdNPYSxURn2DJZxAOZ/uibT3ipB +xhQ6sr8QvdkOCCjNoz5lbYWkB9P29peA/EKxIvjxonTdvpDoaVN+4PMGwHUmXTjn +tmOzg++RZj/WzA2ep6hjyRKiiEmfx+tHgV5hoZPr3gRbKggx7/cwlksuppBYjC1b +jiykttBbrrctFkpAin+qeZebfDerFcFq52/O3H9tL7y2ifVoZKeNE9xiphRPD8ms +gil/jAW5U3W6qgxQBoj3JtqtV59bsRQjCmwkp3tZ4tu3NQ7Vc/U4tfC3ePJy/3Aw +GlQxUVPRG5iMFFSP8M0jb7JXKgJhY380cEfn3dXcUaFFCYRBdKO+Oqdj1YzOd/mH +cIISy3rs8DP2my7I46Y4vKe5Sq8EJuvvC1vB1p5sFIxPnF5TqpK5Xa0EDsfnQF4t +3t/U/i01pHEFO/SAF7nY9G5obLAqT8juJBoW17KgV+9eaihs6ykg91l+TyMYbQBm +PPoK8nz+G/g5yMaooWsOGskNNvp2LaiEeLehy52Zwrz0a2XIWvS/zO0eSsPLBo85 +RGAaajVm+o2ldPi23Dhs3CdrM/X7QcU2SJiwdBPz2tZMMYt8dH8j2KKkuvNx+jYI +Wrsfh4HRwQVtgMaqjQ86qclQDd+Pb2RqA6IUJXNgwOlNweE5B2xL11tu2jJ/3LA2 +odh7Zh0YGGHAc542oLutSM9NMUygGAW4xogHni0VPLSkkegZEuuD8sGbip7XrXvj +33XUua1dA0vp4r0qD/LiG+Vr3+/UDzRCy/dFPrWSpzT11eFWi3nutqXzmNF5Dv3/ +yfMJcPob0ogVRV6Hhi+63jN3BdF/xrhTikOMvlY3Ux905vT8mZKd+PoBUooTpRWL +ri3/3kSV0ps9yrSOva3sjrmQNjB1I4n4UgIkjyZk3Qlzsi5Qv0yomMKnaQ7f0VR/ +0ArzSMB0jQE37TXLJRUwCEsevww30ubPACeHEpMoU089un63kmub5o+N3Jpvg8zT +TmyRNqQt2QqAjqOPJExBXnYImRdpVOoq+lDMFT4DTYW82LOaGtziIi5Mf7BNn/Sd +2qP+lOQqSRZYL43UMNFU6xFq9/bFWPkaR5oPhDg3k1BJY8nsD0mIXUqglQLGjoFx +T58M906Gj7T+AYkZRuSdttTFosddZZB5GPKyw2Og8NSzysA+c4FMPzm4btO4fzcH +dkpReWOl098pqQYfpIv/JCikVffumPCAKlIMVso1Ta/APP5AIO+QbSMVdR+Xnmst +kEr2EdehxIrhqPpv+CjympFc5t6n4L3dd//pDVvv/0wXP+q/LVb7pW9nRsAZvG66 +gwowkpmppZcwt3kgczcB81Rx7ihAynFIe3BvtBcCZ2x4KpXniF6n/DEJMRZ8lRqh +RJwSN6eKbFPgFG8DOJLtjUrSC72GNz8CFB7Dfr3m+1vre29CkVj1v8p16jZJOs9k +XXub1p5E1ptu1iDG0VAcX7L3bSmZSAA9Qc3qv2ClXqdGGNogOJ1ayjxtZ45N3VsC +hYMh5DXX4JcYhgrvPL9D99PNpMgmV/n+oHj+Vm0p9ql4TgN5PU0J02z6DH1k2Xpn +gjxIz5LSANnEU2LX1+l2cGs5APlj65RGHhZOno21cXDrDNy0ejN5Y+XatxNFtcbE +j6W+c5cX2WWu1cWvrS5g2s6B4ICCVSddOlOErX0LUVbDTZSt2aX4XhiHX4860zvU +GYhRgP8We7kvaFk8J1RvuS7KWxwwjJflTqQO8o+Mr5CBqRcAm4OPDE2nULC5hLx8 +f42npYMmkYOOtGpYc2gBv2OGvMz8ON0l+ibAxZ6EpaM1+MRt3VKJ2ASECGwWST9N +X1OVDHhnxdKsOAFSUdfsXjdw8/oetsOc4ThJVF8V5ngFvVhQyFB7zMgC6T+uR9Qo +K1euf/Uu7cuKKP72izyMUzFW04AakWC48AFHb6g/hdmVqt4kYce7tmQRl97t/qbT +nH17M8tID16U53UzMKnsNT+801ywD5RBHxHCm7J7rt0GecKhfWHoGYmZK+sATdZC +xS7CIAQrCMsnZpjm91IUzHc/EjewyRSVAtnYk7foQ7K1KcBZqz+0oK3gfSkh11oJ +2gcI+waDAAVGpNI4he7CaD24cJkaxXXd3s1HHI4bbRLcTZDa/ddj6c1ikcnGVY31 +TSD8YYg7hA0jPtizL3lOf/v35V/XdSMImPzg+g3aNzYsojAU63fyFZfx71dRJV3n +AkqlEl5/rGK1eeoxLk9UfUIZ3xM6KwMlQ+wG08bv7zR3TUX+e0MIEiS/6yvBLtrt +tDBvmpxab7d4O2cQRBjiHNEHU9ixPbJc0Ny1Dss+kxaA2abEnuvRWOkPT26aYTSl +TI0omfGZWe36L46YuImsYZ+bD4F67k1ymsRRbnSjM6wa7LtSLCrFvW1DcD4Ileiu +5+01kgNr6TSVwgxWniTDRllZv0l+rUC0GLbGFgWgKH9unuTIy4yMiKq/uAbT+Exv +IguMRRTFH0t8ZGqXCEzlEY9RaiLiOsTooq7KdAKtC/BQj/zmntQmeU6htQ+azmJF +eV8AlRunZQr6ZU2QfilBEJZu1TCHxhmH+XuOfNRE4GeW1sEldGeTHaDP6N5vx6x6 +1havVvv0r4vX9nDmjnT8mWAclQE6mLbKq1KMpZEXLzyC+pijgpDgaLOENLlF5mtn +wGhGpDOt4JIjDALNh6rOmUOoZ39anfqJ+b+B8I2Lr1e3ZZmtfune2VNwMyMyF5ju +UYMDk/1ZETVzi4tzjI1c8qXIk71c5nglJu6rWotIjRQkygF9CEJzZo8cb9dEa7I0 +DSToJLSF66S8G5SfJRF35MHaiAT2cKM7CgdjO1jniOd7vgikKrtlhBh3gKkDn7zT +HNimB6qYYVxw+jqJUwsAR6J1LMDmgHJ1ERaF/3B/zO18Cc0mayadPhJ0uYkkiUJM +mTfAHNelllXsmB8fXd6JFGIEswBqawBIY3fTM8imK5r8N6jUXWILIMraMW2XF+yg +/ve/KH5HhwL9F0oTIQbTu9EFuoIpBfdzL5UjoeNRxNdYogaWXSgMcj99w5gG67HY +4IjfZI5ULEA850REWADKqI2Zeeo3xufBi3d3ztKpMJsZxEbXgxp3/MVlntlqcnx2 +hmjup+GpUwsaj7mAZmifsBXg1sYBSEummUwpclQVv0A95Po0dPQRCHbON5pWPLHK +6nrwVes/oCBkLOwgE8j638YzcvHvYobr3AwUY/R0m5t0zgMoD9ZZ+SSOqE6dmPGu +CfPpd+zaJX+LCokmdXDpaIfwxHgJbSUdflYknYrPMXMWS853sbN7+EGAIWVK4A7I +cfctPwAP8gTTY0F9ZwYgmLh3dlzG02EotInUjGne7olrQuzN3TBZXLKJQZNrmZLq +ehyYB2sZgZYGqrMmTi9ysISLM1XOpIWa7yXztOcreXzXs7p/nklv/wABls6LrLMC +z0M6xcAumXq6oeIfZn7rr4K1cPgK8BPQebaNlUAp4O0oGPiRh70eF/pEvdmsh3Zs +fdRr9j268yBgyKTSbNiDmIb/7AIeT2SwS9lOK6mjueWAuqQg+KpY9iDvPH1j7ioP +MkzlaD2r3DdruJVn0iie6IlVCozAc8yBxI8TAU2Po1Yc9Xf00EOpjlHrdq1S467x +2OpIYwEXF3PmRHhjGUBK9gU8R50d7DGpRV1b76RAe2hdi2cXL7VVFV/JAOkfru9p +HXKFsd7q5X4eulQ579NXRSdAchNoYcPj63qc5GlCh90gwuub1MJpd0rFhjlH/GNH +nrdX92/KabCMR9YRBpIjYYSO/tCaImotjjs88LKTTFCiN6keFL3Sv1DpsVUSaAlu +tXAg2Vanh3fp7P2VdSJyVFwU9Cf0/QHynFFIR4psLOUnpMGVyADYVckkhC1ugfIC +Q5FYMqzhV/KgLoL9GNzDf0XifjeE7R/MidVwldrUpyPrMR918jSe7Z4XruChDAca +AxF2A0kjLF7OWS3VwVB8NooJojMqkA/4rgrRG3ntUd3Z1QoYVT+J220j/jqIb9EC +KCnimrM6v1y34AROjehRgtwX6kIogMmVWyunfqn5VLsAeAQqGnxBSiOV1LXUpwT5 +W5hSxhaXObnmZ3PWOAcdW8jI0V4RoFnbwo8WK0xzcvTVpHyjXNoBziLSMx0SwfRl +1U3bdNufWlDi4w7NBSbz/MdpwdM6AFroz1bf5KrrUrrAw9hrvaibK7G1t4b/Hx5u +zGd6r7Zm5FhF4+cJ3iQ3iGhGQ69FvUgdIOudVVonlPeYZXew+mS3B6xfICsPXd9C +q35O175jxDEMLtiyHp5WHYY7Uq9ja+2qi/0LpC0OfvTEu7OQFnQrKfJ54lGgCbGO +xHUQuR6t0NrC5Z2UW6zwj5qqn1ep0+flFFEV+ZjK36OzoKsv+MkjNjqSgNxpo7ps +xLiXop4EINaMP6jmzjnwKK7UlIu+vbRApP7V2TA/MJCbyjRpKvmF3d+6mbO5AqhS +LM9a5Lec5lLuzeUvBvu40/SObSJpMGWCSWkHkCgyFy7YALJEPuShLskhYQixRI+a +e21BzUhvBORer8QDEtydzpGhKsFxfu6H5mAwZPOtDf7yaKotxsDuaAArgAoe78so +ksB7n1HXKFDeUl6P4XjCZqHXv4gTBzWXlR7opabIB/B1jWZHVugNLc6k95Kh/h8c +bVDXQ0XQIgiN/sj2ZyQMrxzMSyDhxC5q35CUC6XwRzbfKe07WtxS87UN3rxYoCn2 +aLIGjq2YxCURunT5/tMYA2D+kAriVfQBhW1J9URyBiqgpDH5K3LwZ1zdAGzesdn3 +I/7NZY5kXyRbmk/r+EymxEHTitTIZKr9nYYjJCeV9HDK9dleVfRBJPhYXgyLldO0 +I2i5LqWu9HE2xNqnny7OEC9kehXW1188w1RsWwFKQzcC1SsFCTteeFtInORLjLY2 +r6X84PEkU7WihLVnHix1X8em/0fB47t/+FD5sumG9BJU3WOD8XrKP+oXigcli1n4 +KIlf/u/8KDVDbbu4IPzQa+vA2DAYTPcyDtaRZOhUY5qJVyHfyPmb/53+PHRkCY0n +dsP6sGn6dpMHMUEpR1pvyhO6g5jUeWyDpTQNzijR+POLTRFLZD50tlqIyE/A4MoR +XtM1FroPqe8CskXSucd9iksh/AP/jBoheHrlOHe8EVXEeTkTEmlWKCgfspoBV/ZL +U3cmleaAwooOW+PcpAsXqVFXJzq5tgbwhwDlz4kk/T1i6/dSVHfqG3UyNtYISWXJ +ScLyIM3LDbmB+xtXXyFEBWfXpaU40G3xVsxNWeuYh4xtGiK1MJk1H4V4KpaSAUwS +DnylM/46qLnI7YvYJ8f4tVCMOMaCYe4fxjxxMdZQhW5giDCeeVMJQlQG0GBhft72 +IzyLfv+MIVivS5kMp5OIgzErcto68tD4GDtRu+O9NJ4FBYrqAEwFJOEf7GgnHGhd +gD2ocXW9WF9pjYCBvHxtEYUWIMzkE9gLgQD0CEVKVrFqSKf1k+2vZn6aw/ryGz1R +nRyPRbIT9w/O7eJhhNgl5TeiEMlyIlksxbNwP86DgNcnm/Pd5CvWwMaDC6f17she +DgqInTVVDBOeYT7OHwX8KgUKa/+QMv/XVtZHE5y+dDiTH7MZTbkFhsmeNjjpkKn5 +0arMPVt0+AWhL4c2cU6knK37YI4qWAsrFUMtDdAiHaqcKpugfoc/SSQC+B4fnCab +RaydmwCZ88LWadScVl4OYkrvNTrt0lEX8vBYD5+FvoFNGfEtuT0OaSfD1RBDUPPC +tThMxn2ZuXOQDPze78ht8QdUTGwoyKTX7wrnKMPp9YahuQDDVle017imiw3rB1Pl +85JiTjLOvFVHf6WfwkwFNkTqpms+H9LmKgJ7zNzwDBnbU8/A82brPu9wPPPNXK1N +qnGe4mUKxH+E9C4KPKqulGGBtpC1/KTVRoDgo8bsMDmHATqlYrQtM2qGw4QKWFJK +v8yKJsLm0qSxYc0s96p1oadnVPVeQR4hLSFtAL7VSBhPsbMLsUQjy2kh4GwLhlGk +QXLlqKPVyJ2L+FBIWMC/MU4Tj5Qqc+Br794U79YOZwIl7sKlZJ5jEMhqe2o3Ntyx +Oqo5wqNojZih8IsOzsCyT6qRWzzd7uc4qFMF4biHf7mZC2Xnof0L+Zuy9CvYn745 +EL5VTVwKdwNNWHtVWEAAVtSbwp5nCMOzXX1u3sGdJakZa8iNcMDzEQZkiZ08n5Ny +GorVOqCcLqbiE/YA/YVNjt8eSPV5ND4B0gh8Xi3mf19/NseIxwe3ZAUyMXFuoYiN +elNmwnyBxcn+GDaOB8STogcVLFyplj6crXj8kItnsnOuAVOFRfvK8lIFt5OxBJW+ +oJ3ci7h8KYCfKmmQ74MfQ6+BEOMEAmCK2TGTBBwMSUv7YcDqRVW+2OdhelUF9HbM +07NUQA9DClxqa2AuIsMTcOpdUa5IBsc60H6u9ajs2cM3wVz1n0LID9N1VZbjvYs4 +1qmo2MDeZCbU+UH+8Qz7/lV/J3jY4hSP2RcLvia2Ih9R2JXQlStuOqv+ulsmH1UU +plkLyA5gOJ8gvQGZ1rDPK90pYoaw3DLMxL6GHAqosy8D2UU+FN730VeRLQOGRu2Z +yl9wDFTS8SokReAU10dqDzOTk89KZyw/DQte/Is9aN25ZCgmTl6rvYXQSJc2nHax +tLKDpJGGRBvoJpCpAHK5Tu9FdBWIinHujA/jJAMLW+J76Lrmn/TBjrMPnnfvv9ll +tCqjtp2JCAMgnvKEeVMXn9h1CQ2CYJyC1nF5iQwXQ4ozFQtzYu9wZZLymNj/9GpS +SMr7e/DrQjy6ODOJkCKQQib8OR+p0y4AWLwiWulBfewpV8pk5zOT4gTkNujwirp5 +P+vzJIgw4Zuqv82c8erd+ZAskWZT/DjXndIZmuuWbEER0u+BCe6sm44KGa0nmbXC +CwfA0G770B1keSPOcEjBOHFmSb0Lia3Af+8yzqa0UZk45aMhl7sONDwy8s9NdVG1 +poBdKOHu7o5EAF9m055vvPaAgwVCVEG9rPpT7dhxkiBgwQbHPewLEHRHZO5P7oDl +v6DyvtY92rbtPfjtI+/ynvqijDvgsIKiihTJnoRNkyblo4419zkJdjxR14XENDkr +rzfu19Oko6T5SNU6Wg9AQrBB3vFPrEv8q6g+Pe9ivfsoRQWn1NyXgGUpkms2YQ5e +/bwsqXED+7v6GARV10/DrG2WnqXkZQN/XGHwP5MmWeicZoMmje5RL04uLOOX7XUu +mFcIsK5qty97+DU03ZfKpeJxSNwvwuRL7RbB8HOwGVtkQc3D+w0a7kx8QjyNUBRf +m8zS6Jwyh1p0FIK6Qwa5C5DLiuvesMjFLMQOO920YnmAcudXrDViZNlUywCqpLSQ +qeaGGoiqxfZII5cw5y1Q0Hi5mq4qDSjrKjDGS5GXEz878FVBx0V1TO3/JI8532L+ +U9PTPoFFGR8qyibiDRiT1tjcpzT5uHW4C+kWKQM1aU7BKK0KDx3wplPnmb/VOHJR +IXrwbPgmi0MnVAquG/iXMygDkj+rDXBbvAh0SjzemjIiH+a9OtT+uNJM2dOR567P +1fXRm1GncvWspKF2G9zcjnjBpPqLSTBRpyngXezBKLEPJuiZYJiZ0tsm7tUOM465 +Ja3TghLBEWFSBYvoHTycdi/3J7irarkokKPpopTYMpxRGPiPiChBwDh9lkvwupQk +SK6SpgvzWwmks+0IRA4pmwKUXn0G01XdXAIti02Dwa62UEJVZf4+5i9X1OUDqa9l +duoLR/8lpL2J9NbBJA0Dd7eHFQtL/ZYmU7iUnkx+Wid3I+/n/00xyDyDniESNk04 +SfaJ6G/MArN93UznYTCOuCnynLbrFBLnt/PDiPp+GbU24b0nemEcae2csY9hILSi +siyebFPAH9/JcLdZyqVmHawA7u+t85zn8ijHaw4fp1tT9xz2xhLjgLUucY8yS1b1 +ngbu7sZDrDk5zY8HanHcHKf+D+MUV0AWubHrQyaW0h3GFg5ZG1cFeNeYZkaNvKbo +flZCj+CNRQaszIo38Xw496ZhiPmhLoOtDATaihPonqDhHRct5uhT6p1z4RmuyNZf +a9uSzq2rZ8LeE3sZNP84tIcev9IkFhsQfBtjnjW4eMmldr7gvPMUWW8cBi+ldjMb +LCta+oA6tl9GIO+QmkpVpySwbSZB79PVIl1JKJoXavamxs/C4JSoYWZQ5S0v5KNw +JiLNPsM9yvYXrYHhVePPtDjCuLQr6h3Glk5RDPx/8FDl6FF5MuP+Gaqqy/aHp4hi +Sem27T+UFnbr5VP9qsq7uc0ATvEw4B39+UWx+JkDXMhz23ljnfhFVjo3veIjTu2O +tRXI+NyxCb60qKB2CEiN+G5pviKADufg2r9jpP5q8coOmHx0Q2YMFo6RjNKhYnnF +I+jzQ0Q77PtrhEVqA0krSaX+4giNbd0xPTJ4a58FVLcuSdYoJ81QmvBtKidFIt7K +TPsAJ3pQwTxiSK/M9CS/Z4SGe+r69L5QfjZpo/SWmqVYC8S6bMmZFLZ0YQfi6cRz +hI0DcZV/cI1DCT1jjdh+X3KmjPNS129DErR+yBAs/5UtSp1cTcg0oetJOFUtPwRX +pwHMi/fSl9mFJ3ArVIv5ZvJ/nlbVc+DU6uEv1WFMBmmix6nNQ8UZrrVYYOSeesxy +A5fxFURoiR+Im6tX5AaEW4B40DOdCncK4hsGvb5iHJ+RHZMkEzwJpBDbKYOSABoe +97koPLCoD0Aqa6O4nMpIPe+YM6cpYcT6kbLgoUXco0UnAMWJ0dy79Gbqdavzftii +f6RU0U+w3oNEPLMbnWsDJS2A78/PAt8d4CEPO5r5Z8ZRYa90MQms85nIKcYCV3SA +UqNWyN0KZ9gRitUsk+GPXXuLYJCEHk7hYIz3jx7HYjuBT9WI0v+oilGOvSaESPJs +YUIJcsnkEWroep/50bmufEZ6zRB3pfrpeNe/pYGmXNAmJBvTJnektGuGsjNfWwh5 +4zCDIIhz943XHFQc14+FEdLxOwcYMm+CTShhyqul63l5K10AhXYl53P9ff+LmU8h +NlLs6JvDsm8Tbh6OqSCO6tg0DwU4Ti2IViud/W+omXL7IqbOQneOlPzoY4bFhu+l +KIhlfH4eDhPikTZGeMI2s5AbO9QMegPPhf1w5bshEQt/e5iQXYqPDxeU8gvSLx5Q +yOxOjZ6HqguqglOZ95j1+3Vxj2QA3s07gvz3djeToAYjL3Elkg85Niwwa0Zz2LBQ +Gst8kNDq8NC1UlkROVPYP6k3MPdcQx9pP36Mp14CG21ZY4tQtDBmZS4DGw== -----END AGE ENCRYPTED FILE----- diff --git a/.harness/qa/report.md b/.harness/qa/report.md index 67d082c..a3c3515 100644 --- a/.harness/qa/report.md +++ b/.harness/qa/report.md @@ -1,152 +1,190 @@ -----BEGIN AGE ENCRYPTED FILE----- -YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IHNzaC1lZDI1NTE5IExRMGNCZyBZbVRD -dmt3VFlQdWF0aENhVnBBcjF3bHd5SVFKMVNtTlE0L0tYc2NBREFFClc3STZYTWQ5 -TnpiWnJKRjFyUmcveEk3aVd4aUVLZUdMbmhvcVNrWkJQUTQKLS0tIEtvVFl1dEZh -SWFiR1MvVVBSQXMrZXZ5Z3ROelRuaFFldFhnZy9RU29SRUEKAGYT4XiVm9FJWmcE -sptrL+K83soYlFSEAKclk+YMl0hGesh/vRbFQ/20ZVZbK6JiTP44uvlNMC9TaE2t -521mtqxXvjQNekp9+Xpwhtfx3Vobzz6jw0gS0cQLHMeyfC9P+3SEW73vPbmWjLZ+ -6dW+STWNhc1jFuFtwT/8KB+ikX5vCzjYwu5FYxzPB9qVv8EssQ6nffcZZzefSXc5 -9drJUqIEeXDgQFZjA2LwHrboT4h05inNfXTwwPYAMbwIKKYAq+6+Rn4hOM9kDOlG -9s4xWtoDIbd8e0ywCmSVVEqDGZfik93EWgJVgPGt2ub/TWASGc2BaQaQiJAbsQy2 -RqxxhXY3CLw6MPjx1+piZM0O2oTZdVv0WtI9ZAtoO0XClifzdjsgbcLZXCHA6KPX -mOf3yz2ahaX9V7bFh8r2LObCDETgM4UOtyAF4qijlTVccErzh4DbPd/Oml+kVMwC -AN+aTcwwzkVDl0RLm8f/RPBdvIzklMMhngsa4HVDnNSsZxT+yL4VEMyFDhoyEiy5 -Xp2YpQzyI2dzAOZQp+dUxhLeP/OWf5iH1XdXtbBrx1MM/oPQc4HgCVFjZMVBEbVG -s67Hj3+ptcP4wLw9gkAMMcbjXTJrLQhlvMxDfC5i+f6CEbrNz5+NXs9B4ImwD4ub -YqBrIogiTNWE7Bl2TvtFvFRnVNgCbfT2rHK7PieqOPvA5D2okBQqnXI8kY3L7/zc -uXJRD73ZwZaTrNxEf61lRzDnWeU68DAL+5oxqk1RJvIDXep8CqaxJDYif6Lq6DjC -Bh6TRos4ycajeaSysGKnGqCR+Mjfuv9BcXtDyf/dOu0ZutXOrkzt6zwT8mzZl1+0 -ZsiT508WS45cUK51t67M/gr5gMzqiiGk2Z13RNMGL9Fka9b5Zih/kkbQ0qGtS7Tn -Jm5K92r2mA8q1piKqjwj/CFsccZAVRVLWWYml8f89u8m4f7niM/laBDkzueWnNt2 -4qwPhlZXjhPz50jkmAWpLcLFvwd0xOc/uCX0if/W134WyRCaK50Z8/3CSb6DuwWQ -8w7MLbgk2YwjpfKZ/95gsRTnYvo8tW7XzkIyikbipEtQRkuINhKdAyEXOM9VlVVb -E+/zWbYp3bwSbKUUIjdvBShrUHFe/wgXSQ0PCxv+OQNNO8Ura4N50m5Hg7V6t/lh -TTjmPoz/f3A7eUEwmmxZbsGtMUGvi/xBjc2QBPppX/gXm79RamzgRC/HFJaFiVD5 -x1zueF2ZnpIc8+rk5tu7GagtTmWgAOTdMUecqwH7hwiWAyZheynIlAtoM/4kklWC -1vQtNrfP5rve0sYv19fzM/O8bG+KnabqnLseaw5rDYkrHYpv8PD5nX2vG/zn96jb -I/IeNCdk4WWsKd9xttgJyYNLCGZieSIBatnnEZwT4Cl+JKHRdyt3zRirJN+z2bLU -ti8VKN3QbJcfjckcwQsqpPuxnLwpYILx/i9NM2mzQqrPcMFnGXYyGvgZORA3uQC6 -YIjmlwbOoFq05dSDaUU4zmSBCk9xEvhxV591ZFf763t+MDBnPsMbNt1IYGAih3Tt -cdLFFuviEsu3ACnUzIsBYcHVT++ke0pprBLrGCxT/arrzLUmOD1tpZ2JHUstkNcO -/jkShoMzNykV0FzZOAy/Yzsf7h2mbM4b9cGd3SczHV2F638ZByInaejoFz3Tndpu -XLOxnRvS1IPOEY+WLWZugk5iNaQy6h4zZSizQv/HMJKPGxB2458mYYvs61SZRcgL -AFBihfnXK10mda0ZMzVtaYVgGFEfibFWPXblyEB+IoOoE1g4/piFpd2179Hub3Aa -wY4QqIF6ubEAxPY0DOZeZZhH+d11LwjpUdGE7AgEmvY+Emkjw2StNCAAunHN8rsc -G6Vpu1JSPo5A0rzilAW+N3RvsNBdtwoK5gaVblgJ+74XsBv+y0vzesF4J598/SRn -R0dPOjpBmhxOoK2QUDxnKbYIZ0Nz7IAUDi7bhXyC5jpWAugCD0Ia/R9npFaN8Yl1 -HxxLYHijX2WCf/0Z8EVhwb3PIEDtF6p1Z2EtXES34F4JY/d3lyXxWR4vRzVTJLtN -ko/ahAOHcDtpK+pmzTAjdKTNFDg5wfm5naxLW8ikATF90JfnQr3EREJrTNmtRZN0 -xQMvTb4cUn5WwfUAYViw6T96vh/QDFbI4699peWyg5pwkU87JVbz9dO29q34SuZ1 -mu3+uxcbCQy1mrxiK00HOL9Vsk7BCiwqXbDPTj7fDJJ1/UEFmLt+CxvZI5MC2xxY -SRboiTm9RlrHqRClx/Ea/xKapkfsWEjysPinyvgX1Hr3shZoHnbj+BGzy9n9s6ot -zz2yphMshTqHh8mFy9ZxrvGQhSeGcJtx5MnYiugN+M0PsDKYQEkJWW6t1cCKdfn2 -YrdGlCqzXNPunKBpT+GpVxnB8xjG+tVbIKglgHZBCJjVoTyhqkhGqULExGTsRTQ+ -/4F3zDDtEFegX7K+giXpXiEVMX+VDvDYkA292+wv1ibwEEwgTK3L4hft7eIg0s4q -WAdo23zzzEat8oVB8jn/9HZeZ6JTmG0lqMq32YJ936WQHPZk5BxTG8uXuv6Q0eJk -AUMYK7NCoC1jLnntRhDiDueTYR9ssjtMPQLfy5jrUcXyeya0nc/YJR5/3UmxztAg -dQQgBERwyE3cfuD9ItEOzfR/oHXxL0GjtDNU11DtY1hpVtafZs+ZwQVLodaPs4y8 -xYsfsXyxjE38WoBtZII8W+h7APzo51qDsnQUYl06Jqa92vsf83WeQ3+UOdvC4Kho -oq1LES1+aQowd5tsMhmO8ujH8RUgiqpGiGnf84+wZNA4cFR34XBgUryPdb6xnc6q -RcobN6LEX/ExlOINY43p70lhq7RY172DV+eDLw02YR1+mCtOLOTIi0DR2G+a5Kcz -XQd79s6seiYI3Px0waJzkW14kSDL/M1apx6EdakOCsZo2MkZSxF61S6OzJEDYOxS -Un8jdDsxwTFgRCXlpqxr7GsNMlqoDzIDI2eLTFPL1y/Cu/zq0X5aT7ToXcLD+ti2 -TtAX08V0bCO67bVGStbcHUg7DdVc4ZdhE8N5LMiR8c5eT8ncs50kNGIH77wQsF6I -9gao3d0Gh/UdOI3Ziha0pdJ8y5MVF+BtJfBTkKDtTcZ6xrv0lBDRa+5r6YTyk+IW -ua/PGOddsAPlVBQ2sj2EZK8aZp0lK+3ZUXWwjdTGpKiGTPMhzpsrypg8tX6h502t -75LzQs7Pe34B7cSMwpzfkj+e/W5HSFopCTbsp3xoEA73zvtge6dVufsU0qLMwoxW -dwQMmRZHunaoADfd7ecF+37Rd2V/7UCznGQsXyAzunBud6Ed0rx/HQtMKfMuRwou -EvlgPi0KjJM5PlA/njE7zIei+CypJGpMuqWXwngapp4RNU5/CxXJ0NL1G46fTw6Q -YcyZp9toO1Bl2wbrmHdy4kBKDEWHy6DUtwakG6eflx5Kouf+VJ2dUZ5bsvit8ala -Cy+JggeA5yCquHyzQhKRQw+9BB3DNkVdWxzZpw5fELd8WqbYrL8ktZ4NrbkhXtYW -yhhxwVBQNPvJQNk0xNj8+28kdDGHOx7pJ9tO8+3d/d2Q7eq9jjAkotd8SGttvreG -kCgzV62PpEsz5NxC+I0jnGSM8N9ztd6247Ef9G20jdRB18ImdR4S0zwB7N8eLMR/ -4xTN/2DYq6YJ8BhIRMO7dgBl6zgR1jxKOg7FO2SF5Wn07JQuHodjw9B5tWAZfWdl -S+qJSyozz5u1+ZYDgXqL+aA8AS7OXyrfiMgHZZY085B9h7Z8PEmPRmLQn/7SrBf8 -KTK0gRC7ufg1Uy+QlVOezhaMhMqpRfVrUTi3M/KtH7sbiqyK7W6+8VAxi2/mMD5u -okM9Ex7lVbm8c+8HOQ0/ixhkGBrcmbdPIrm10qc39Ukf1KzsxLZKYNhNUumaNMnm -LhKbfMzGwT91VhLuip5zq2rhxHI8s2/F8CyS1IGPTek9/zOVPq9X35yqqjwDdHPZ -0N48wQ4/K4Z9BoV2cN9tz20GScVeki+BUqVBxSa/rKSIKYKWGz2bowgul+QA//Ep -tl77j5Yx9kCM+ma1Eflb8jAxkWIuG6s62n0K6wlXyWsN29z/pJ1nf5Ch5ha+WJkC -+k2lR2mZbm2Il8mj1cxu836W79k2CVAK04aSXzaKddmVUz6F3y2LP6fXSH/UWkPt -egzaRvkLK6ZQoOJU1zBEdwhPtR7LFXohgrMQwpcT31jNgQAQ9qboQfy2nYCJToH1 -NB+C9igppVj6DqYUgNRMoxu+QSX8u6J8kb9p6bE3vBwjL/CtJka5FSAkmzDdUw7W -/e6xtbYve7RW3BWqYTO85uxZTzysx7GwraJ7Nr1r4SxB2DA1pa5hEZvf6tpLzk4j -Zo3jj3hQc/IVpIsOjqETPGUSuvFcqqQmJbBBODPpwge5jg6kwtd6wdC3VK//r7rR -w4UZ9Sp3SvoT5c2gFXd9r8r2/rgJq4HM4YFmE7iB7EATbGOraQqARbUbb5SWqNVN -+FEwouf9ds1d48btZesRKcNlTSIdhZLyL1pc5hzVPYrELfgSlv+hVzSz3puluO2e -XmiPOqnvnUWT2+d2gIlywsMithoWynrqvwJToCS7LgQADuq0isGm/H9Gh5mPsgUo -c3JrxgWVLcnew4lkUwcOp59doujk+BFY/0zfWxdQPFhpdjQOUqJwUtRCEMuMyL84 -uslrSqm5p+c1kaci7Oh13dTeRcRxEjReeP/+OhNsiMaD+tDESXt9TwmUyiLXG0SW -UWaWHNEo3/5chA59R1WcQgieYjD8DNj9oxKL7U6PcggnhWnvLcDRYu3u8boewJFn -WS8MlHfd/iGtFemktdR8pQh61OXxjNYVpvjpQckEQAYPbAQDhMBtBGt06jJ6T4fO -HQ526KiN3OkriyjXEF67OdO7PHRvpM8UrYURtQ+ATaUMTBDx6nRmT3UfLfQXMGA6 -M1cAJNuQKzdFQTdRyZej/buS+ICSjNxZXOEBUpSArj/0YeYFcn3ZqMSqbdlUDlbQ -4X/x417gwMvKeljNvXUpY2j1p8eYdiFAsXt5yUdsAwmabdeJaHkv8I/hWZAp2ff2 -eqz22NcdTrAzhyC6r2MZLetMcOgnZYqcg21uqCrU94sPGwuqfhtSS6i8loPZKwCf -AJz6wQ25fiV5Zq1eNAmKMHUSAa9gqD44lJI0ka5+3WqOLJQgfpkrRtiOFDUuQoGP -bWx5R6cFztGaTcUJ3BlL/p2VZYJdXGT9++v0QWvWte2Jk6uAZQpG2mdX+5mOxUDm -I4zVP3sstHaosryT3IzwweUbxjkc8BTwfM/APajmekaUCm9Z3+oW6+8FrWJk3Lk2 -HsqYdbgBsMfj0lapyZC5tHixuFHEuA0iaSKVWQdaH8Zwgo7+y29dXrgVYd75eR97 -sM8OXQm4zFUa9i9lyk39ITX5/0WVfhYfOusK/tJnDqQukUVkrsO7iyQFHemZc+cS -TfTjkmC3/mKVOWY0t9ENaIGoQEQQp/5L592BJciImDVyVg+bHwUVHBmPlotqNEdq -wIC/WgZhy78yC/0CJrop8/PN/KDRSsmvUBWe63lZeuG1jR1rgaBv3eZVd+n1fpva -n0/GyX8e4m3/by4uvePIZ0we5gAxTVrMTCxTU55xUPVK++QnnXhPdCYRkUeo87y0 -1Wi88kwY1G9Y7QCpSJR0xvVv2lLyY3a1m5C8inM9vypLgJ3c/ZKm7OVPjYRzkA1n -JKBXl0TDPqlfNlB2r22u4E/SM192EoUzbVYbMR4F6uW+KdwMzkrxeqlQuTC5Mi4r -enLJEMXF4RfqF+lNRWGeevRfDwNY+D3DxSLgxS5JGUCQdzL6019hqD3+q/Bc16qx -v5zGCyBnaRzX3R8RYMEsqddmbnjFvBM6X24SC8hI7mN5y/yh25/eCTwyAuXvKe6k -EpENh99z+D0ADfm8HPDmNmcHc1PnaX/LRGmKNWgcJRaP94D+CFqmBnx0nPyASLSc -jh+DMN85sVYefkYmblJ5L9ZiM0YRDRU//jTWp8dUPapqz7F0vrdI9SP7L0SspHOb -CfecO3irfa99LlSH7h+y+OhvG23kxeaJUcwwsfBmzMc+xBqYtWEIzVyZfMqB0YuU -vb9UNkalVgnpcqdmxSkcrHZjPkDvyz53zxE2j/b4qlAz1Hr5RbP8VqtAHplCMpKF -kI6T5+02jI4omQ9dwri+9AeZ75vWhXYYxQNAM95nDDulsnDpnsMamvBIXKDm5u1D -PVC2MC0hiWqN5bhzo6/ccpRfJV52BFdFaq97kekQ9e8yfZ7D06CK6R482Sf0FkYD -J1zWf+D7LZP/UoqTvf7TkpugLu9ITn1bw5RX00KWFNBTgn11CrwthWVZHyvJLu85 -DtW7N++c9+fvOIGTSN3MomtdvY0ly7Gqlo1h39696slEcQZNyUhCEzkCWFZxnOnu -pDrT79gyI6TNhYY9I/uY90fKJ+aj0JpJsp2OnQbmTZEe/a2yc5jnz2cFTwI5mWPk -z1WqeBdD0PtJDiuPqvQOXugC/TyVe7pvEhLjtsZOe3PX1BFHm06oTufx4csQLUcy -6zTywPTzbAxgpWWUzWBQ9B2CSAziY7JZKccMCNbD03TIqFi43mHI3wwYhfNNVyfY -+ccWSycevkUL69G5rGw/pVfw7Gt6MFiMe/icyHuml5hwEhNi42/lf5wc7cwFwX/3 -5G0IKhocJUzx+Q6dKvRjOxOH54zvuVFwf+iYBmMg99TVJIec8bLVnezXrctdeG4c -SbdsNm5apzXJO4lFaTjnXsm01d/2ziAYhoe5gAdJxutwHhpfN43GKLVdPV5mhvRR -MToFQSq6sb2AGLcRB6MHNSkw8nbir8sruJyw+RVoL9Fqd+3/a23Qk/ldClMGDq1W -OA6AmhgAgU+RVRYGGNwJ002NiUAnme0NH8wXEsYXaSkG+snovqNeoGWCOCvh8I+4 -0J95xjtXhBTcodAC2qlGp4HtU7k8SwRtCjqQ3NZVZadRh7LM9OhYgWE7KIM78aQX -DPNb31vZvm+5mV5EkD746PQ7H03OPDDlFgXsYBvzSZQKv1bStf02v4UIR7VMoPos -AsftFwox8B+L49t20fE0aEjcMh4csxKpd9oHMPECUiD66Z8kwL1KxGfkOPgYeG0w -kKodc1Pa1XwTyhyOjj15NVeGLFMFm1+HYw4khxWc00VIyQLEMz/TI/qHcyK68eYo -sSPPDLCj9MSuUG3Op8tAz+VTg1Hsno3UqqI73WwXBvURdr0mW5XHNyFJ9VrH1JIL -rMumMjl1S5z8INg86X2DqdNCrMa5fgkYdFDvR+tEBPMNcNLyiCadnyQfV86nvCpY -oAmH7HYs4CjRc7pAPaXzrDfUcpumIKmnp8ImezVLS/g8S5oAsYMiI/8rxsbHUGdh -aSy3RVR6dFH+RIE3s5uefm73V239bZ2rNGo5B/LyYXo0gdZocb6YoXB1JK2hzZJh -KtGgqfxjV7ODQBu+uKuXlK2q+P2L1iXOrcY7XvAJQeGhDWY8FYubewk3KosAUp+B -KN1eDPsjd+vrlcTlqF7K74biLzGfmx9wikD7LbOthTS9kH9YCVnlq8QMYQ/pbQD5 -WZQ3dC2+eIrb7f6HbIyhhJ4nG/b45pRf6sSWhNt3HW/qv+CDrCR9BuQ1Q5vht4p2 -L0TtHOxZ5Vgu/7fsnwbD66dK9UrG3o1LyT3/OFYUdvg5m9KScMyxuxZqqKV8K9tV -Sm6ChntjqB1X6fTdd7EeFd4XhxKXJ4bNJpJZRRwUB3vvTUjl1gtT+Wa73Xanosgt -1vCRVfOL1RIDfKKLxK27nOyKtYyZ3LOVNsF1t8Wi5IP1vBVvB4sfhyvc3DK4m5Uv -4bntX1BQsGA1wM/kxiRYjs9uifT2koN80wT/iAcZmys1XVRL+mk3VrzNA+RwtO+6 -WkeKGMligjgcKgUQGJYnQ5Xsc+IUx3rzkRAqjTYqw4RcyK33NU38dP33tW3AlqEi -MaJWTtOjjwx2m2qQeu8TjwkeGSHHKkeF9nNtd0HazTnfsacHgP+E7GcdYdjvzvoJ -0BmLcDPkRO5B5yapiLwE2samwDcd9cBRHCghcs0RscSj9yof9E9LQ9+GW5tm8moP -3alwKdeb6rcMNci2961mJQ/epNawhZy/cOQQYkmTnhAn2ejtZYdLmW3c/RNA4adb -WyYzCdR5qN1aClHysjAj3gM79jaqt5S/22Fz7MfOzURAkiuqe9sI6b584X2MzfU9 -LcQzHgZmkfUkD7MoYL0odYMD8Z/8FXYFio/vMG/k/LX0b/YL6buNO2gIRS+asFbH -iAa+SU1ZrsZ31wSQgSeAakbt/GGr+e666+laBvLQP50QEfSAISgpM8Q7yHzNb2Jw -83s1ERNBPUC4YnQEkzfs8FuCOVIQbQUjCUZRrQ4zrjejkErT6Z/rWnMQgUo/1DUq -OpDwYtmgnDwkJPVQ0zESZWmwBlzKDoI+DVVwxLCcyD4LTW//wnDJCb7ywYyv3gKf -XwRopZ8MUiuaekM1WvfY9eNx1aHODxW9QajAYtTSfXH2GEWSLzkliAUuuWn7SSSI -AosKGcaWVCFp/ghR88WLcjK1a1hwgDdzKCKbVYYLmD3WQ6JXn/7JZt8plyUa7lKb -DdDCFaHuYu8Oy6i20WLNfcvUPXuRBveEK0KZmZesNlTgZJ5qQkXISN8Tu8qLzuyr -PPQ73k7sA7t6v65WyvLomiswIBbZaV25acGRJgArjkZZYjkwnrjsGu+Ej3jpjUqz -0EPAmPnv/XCovElKjaxCGoq/VuFNtY3CqUetazcANJADh4m+1tRGYeEbWGn47S63 -etVHdQYeAyg4lI5FnD7dGbFExG5PueHaMXc3Dw2/jkbquTEP/5tZOMZZxj1vYqa6 -L+r8XVTUE7hvcvMVROELxtD+HquIpGStTKIY2TyrGZerPyrDlU6irx1aEEpk2h6p -RYLFHagp/ygO+WRs+zBRmbgVdKM0IsUkAzQkxqJylarRlt3Gc8CuYEIhUSWXSfjQ -YBG1LnR9NWDf01T8pfp2p6iDKrdqcoRBVAsHkjrc1hxN+lDyml7fdR+Wn+WCh1bp -J43Mn4XomE2kajQBH4JszqJrbHqn8BLVH7ipXphK5nyIXWOG1AegNh0Nuc4ykqu0 -xoRjdDqKPHXjuT4DhcfGyWzwDyA8auYfPI7wH2XBMwiQPlajvQpf9zla48jYuyre -jE0G1ULb56YWP85Fhsw/CJnWmtFGQzfICt3t2yZo8nQqVE5Q8q+00lML9d2TcZeJ -ac4ov3hVVRvoPNghaXfc7tzylvSYsHYOYk2gSspan4NPusTQPJurRx49cHpLdnS6 -Me7RZ8P34OBUy0CwpC08P2EDujDrHXXFtt/2TUwp39UB0wkAew== +YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IHNzaC1lZDI1NTE5IExRMGNCZyA3T0NM +Y3Bkd0QwM0JvcUlLaGdvc0N2VEhmL0xCM2JQNVQybDBoSHJzK0RNCkpTeFJmd3Vi +dHFDVWtiTXpsTU1oekF2VUcxeFlvSHV0SmppaktyWlV4d0UKLS0tIGxKNHFKWldY +aGh5dFlPL1d5VEd6dC9vUW13NmR3Q1lGVWl2bzFTamY1VVUKhgJz6MbOvlPsXsrc +7iAHaeu7w0mFaNaCX+gv0jtuEjtFgsqccnIpoqf3UmyRljcUerRRBkVBHY9TQHlH +9Ii0yitk3M1VoVlXBmafu1M8URqwg3YnnUrXSvwdZClo8CEZZrlQjT0Y7R3bkVfT +a101+wtCu58scdn9TPWUNDia4RM3wbstNkNA6M+z/7pvf0+SsZ6eETXL24dUnOWM +9rtijQ0haz1t8NEjnNBXrbV2PvNJWoF+KLbsQRiR5ECEkAsx3MegPWlZpUz5vzZs +0Wti5OjrdKD5wxaviQbNLuKDbykM7pzKmp/O0kI9mBPoBiggqrGRoYy84ikfhWIZ +ltKS+mIjzYy8o6vozPYdmCe26I0wNLkXomk+2kb2eJIUvwSKi6ZfEEcdhKBpD/R1 +/e1Xgdg0NrX7CPogP9j8EY0UV3Mpw7TcAjcQfnLkA5ovNlyx7wAxQ7NWturg0aw6 +jdJzKzlW2uEfBlySBi78oMofzeCRYySa5egv5TVltAUklIZFUVoQ45DR9L9Z/fb+ +cix2IWOMjZIc+7juuB+el1SRtNfu471Q3C0Cs+qdBngLxg8tLeac/VwjKNWEt4BV +gG6nuPsI8CdJ3OV7d0TqPIxMxMgTG8j/xCqJ+Br4Rxft1XWR643XSt/Ugsy6Rh04 +JikWoHl7gLLlzCcwpf+hGVzgfybUNu0EOJl+LHTjYPQGHPHYnADOF+uoBqlkvOcu +h8m1e7WmNTH20/e5cjN/IBCuIFL+8LFZBDOmLphb/tOQiJ0KxKeO0ermY87Le9WI +WMsdermt+bCS3n4rzEqOowaGvZ2SXeE71TYyvErBGkpjowcZhz8weKrxLA6OeMUR +vLcxfu5U9vAYRu3Hk0EMJYwluEq7bS27dPo8Kmn4U40lKDjv9kw+pihe4Gj/w/nb +srbEdsh0rkiuL8/mMvymjYabY8RRdzpTY0nt7F0xjNnVPEYz77D5cQJNoLKN6l1E +9XV4FFiduTfFoR15Dl6UoO+U4OtS4noaEttqHszwUAJIGQVw9h8K/85qKZajTlsE +6+LBtcx16+iFfFT9PXjy/RiyIqIezdw7/JJIDS/RN1nKWxPtjD1ZoeTa5yT0DKLF +gjjlLVxCXT2kwfmWCPbzX/QY+4SYQt04np7jIm9YFJBNxrjv3PXHXrDkj1AMoNzN +zrXjC+PPR37TC4NIIQqGU+oogtktUSG/r/ba2ymt4y59DpWKOFl+jSIj/yAAUUFA +lJwwp8slLjiEycPdIHYM4DeRm8Z77dHzA2IlqUcylYI5a6YsPcZyB2bGUYcfCD1r +6x71C3ZI+awiJkFtGgxUDhuMkW+4BhV9uM/218qKG04VZ42ZDdRMrI5aEg6smmnG +2tthPf2/iJ9Eq2kayF4qxlbSBP5W15kxwZipVcEyu9qkV/SUH+1RZkl0/3urfXua +6qO0hyWMnQEdCKHPCJJxhX39TApGbFEkot3cw9gFHtTRuT0jTu6LOeTUHEjqN3kg +Dn6BJngVXuIwWp/kanuhdY5/Ssi3DmHTLNa8MaAcz8H8tj2sxgsvzj5Il1z+v38x +hKA8FrJKvQgnb+SO05M9lKfgqtY7TaYUcxInrUhPIYakGhESD7vNZ+WrPbaZ2ZD+ +NvaeSrsM9I74owczm4VgdPdAni3OP3InmsVVRIwy8CSKKDnRV8P82KiuUR8zevHR +Q5eF2HRJyLkxqU3vobRh3qlXuzzgXiEFfPUsPQW02lsoS5r+pYPV0r+umMkWe4NE +PFNegGsiVc/4BblWp6zHfGpHnefHANORFAzqTE84tCvjH+3+Z1ld716uu3PLVGWm +f32ENZUoZ57vw3BLBvBSp2l3hWwJBQiS64Ym2GyGNqx3fg+iJMP0ICPfvTFLtYD6 +Ds6UOZ57gVMVAXfF/UC8lR3MCxyuQMzhYdKlS/aYfxcIk0nNu7hCRAUk0EECAlGf +KdXdDzhnpiTb0O0uGHW78yC4bCu0Yir+9muDREKuGC/FxC3mkz5gbVfpfNT4InS8 +6rnBqwmPUNUvo07gsB6+Xmdeu9HofHoc5QK8hjdOqqzNnu24B+5nqk0V8iAGkebq +A8hp15A8qQVBVrM7e+FVV7qR88Xe04UKm6av0CaJGCpKVQ7xgKgVC+YS9oh7ZnQX +hhrLkkYv6BqB1qsKP8gddzTj+IAv6ma/c0okLrMSSWkAL2BRime8xHm/RGh3ysrJ +Z3YYGEiMHVSxyGEH6DDiMUYzdrM7tW7XMjHnjyIaSoim1MT6dRIXFGBJ4UgG47qT +0OOPy6Z1e0ZkUB5HqATBZfatBoAL9QGCWSjD2G0qjJ/KeJI7B4GS+iKJPJh9x49P +85PS5i7IAISO4hD05Ivc9IG1Xi+iZTI4lP/CLj/KuQXheIzsdpvtaZCzmogKLK21 +RV9HZZ5zfQt3mx3YS2XfEZYG9zY/rxyg2JHkWXd6RWez8GhvuoymJzLWjaNdr2EL +RP1M4bMMEXMTelGdhDq2kR5fd+jcsd2SvWAPGYRYUkTIN0K00M8pNcYhroaki8Qv +21noQFJ687DOYIz9lVONusUM3pdBAAppawVzRvZ6F+QJaoQHGfTo2925fpA3y7RU +rElKD6BoLE0OlKqkBbIEvup9T82KDHuEKDfa7ad6KsUKgO9TiuNPYJv2u33XtByw +crIjyrGRc+OP0V1j2ERhz1d1fabpfYpV4X5pJZNE8o4UC0O7xAWz3YKqs7jWj2U3 +sEbYB5qSO/6kL9t2G8V/Ym+2C328y8lwQqV3pvjij1XcyIczXh8KkG6acwNGrg90 +XI1uYMkUKpP2tpkbUmi60mOiYDUzF2qEvQcDyZ8Li/63CuRR9mRwU79eLpdJ/M6/ +Wn7GKaNDRm3XN/k6xuXa1CfgGr4lreD1cBcjM+ATETUL1wEDO8sI01mvEsw2Hahx +Xh+2bzrPE9cQs7BkdDtUjh0QpJj2DxY/RJUdwWiazQhNomhpnaCLxHgp+isrZnnP +4C09JaJzLL1zo8I4/ibkPcihNmDxShY4uJmGZ+Wf+Usq4rHtl5uFIz4klbLkS8GB +NrXOdZKyHVMwGQh4S4R0zQo4wSiTtMMqXdv7F4uhEXcAXfuyIskd6xBKn8q0TQkn +zmqRvmrcNw5G248fiDlfLo/3FvFLc9ZkQblatS4xXg3mKZMLjSDVYTw3z52ph48w +nhMZLNCZSTIHilIFb7OAAEO94jfgjnDjvIuR/7IwRND+IDAVMRsRuYPeeg/YawXo +nfSzNlJLMIOXX8EN+i+F596htmhAxp5G+rzBdByOz0r99SKn50qTUGvmW3LcWxvZ +sEs6uOZNQa4PAYaRnc9XFhZwmOYO7tVVBpk4w07KZpnphxmrj7zNEEGkfRMbrP/p +lNPuHOt8kLUDmOA4emVphNYjrtmRiLEsGv1in1QnUO0LFUwIGFhNAkTXnf/PGdcV +VVYlQLb05Kwgss8c56lCczwigutUJTonVkQW2QklqU+bwG3f2mw9hl9X6J2Cjq32 +5H7voP746qZXFGVhuwefOulGLjWPz1IxKQBFys0FMVAGrhOLzRG7nsDIV6ohamhU +Fp2Af2iGbBBSexyPVTQJVgalHL3uzgV7+aFO4iYdCpPs9jFRwuHeed8qwOfdQInI +NtJn0SY4uNcCrTggre7CJnnfCY/483OD1AaFoTU1TXVi8KuD06WLpbsYFAoPCC+6 +36bH/bMBLJcubWlOXVkLrtcoAtG8/s+n5e0l+fK794YzIKaFT7Vx8vX0FMXwjFIk +tYKLBjltUD/WcgDn3fCkDArjDIKzr46+PlZ+msiz5Ys49GDBidc8O2kyFZaextEg +NdcS/RPG0JGFUmPZl4UljPFSJUXwm+ZXJlVbIAdTAGsFt1zrvALs3VhtmDXAhqp3 +4/RofgEjaFQjjGgqaaohQenBgwHwap3vIkqeHz7piulcdDSqZctOc1Mg8634z0Iu +OcYsJSfZvx78BPRIXZKeCFHSvvSzW9qqjOof1ECeIyE/Gbwlmev+A9Q2/O/pO+PR +3G4e0bMehM9R8o9F6cn6rD0ZvVCfa0i08pV83lsg7zujqKVdW1Ho/7dEpkcCLfxZ +SyoEmTblpfMyeWZ1vho+OgH+8RqA/QBa5zLLMHcsahYX459ppbG7uIDtYUQvFITY +4HEFBHY42Q6FGysTRIkvLlE/a8XyVQ0yzHzqw42tihCC3xAGLSNAxVUMd2xi5Xo5 +9sss/hxPiLpu/jDkqfsGteNknphIxSTYTQ2QXjYRnOga41NdTB6yJqQkkF1DAKhx +t6KCxup9HiBb9Nme9qJPhLbohba03Q0aSDW8l6XmKai331EljpFCfFuEi11BMkLT +GkFH/7/Xt/IifuMKfTMgI+j8s/7dOCzLS55bTzKOIPfLtJAHqbkOyQIjH4m6laES +5zcAgaFnoC/Psg7w57tz4Zo1yv+uacBZJ3AdCfmwNVrlYPue7kNvUAGoucgTTxQs +sWKTBaS/Q6Xo//+cVAmWblcmSsuPQbYpfybsOHYYJVZSg3vL3soStBB/I6gr2wS3 +dDkVCcG/VblzCED1xzM62fhcKO5OycxKfTyQOJc/Mzx5bJstwl9rZTI1aknd9XZa +VzC04Tz4BIoLIHrD3ZmZlxO7gYRR8n2Vg1mQikk0JiNbxrC9XJq6ELLLGHP6AfdN +x3Tqcv3VNvPe3Gx2BBg4bFctynjWKA0BC7am8MV46Dbx1L8vDN0DnMkYIn+fG4Vo +7WxWRz5jXrai9GDxfl7Fni/zjyHV3cqd05PwGu34rczW4PodiGpbIxv2FsjahOux +gqZaNAOerLaKcA2T+aKb94HGksoEmIPkfFmLXCflw0sOJM1icFHRIDaSe4q/1avf +aR+MKGr/x7MiVUbif/joPGmYvsW9/2PJCEvj40YpLM0ebiAfHLqRQHpR6Xld1E+Q +id/u21aQJz2Q8IsVBaUl4r/95jC6ECcGtxNFmaEIfvSQNM3lF3p5fbyKvakoSg/t +jXQpFynTO00nvEwVebcDNNd2eHrQE3kHjpQfKqRGdLeUmyvOH0s9mKd2+gangZPA +g27juveXG6XBxqp+XHJYoVCIFS0hDy2P0T6iesp+7T7VN3wP2xYMu3uPqUGcqgV+ +Ie4ekMITn8XRZfKp4XbN3nb0BR1DRK3tfYsv1qfQrioEsZrwp6y2E/a6lsA5InoG +vCo4pVoPO65lFl594PP2QhE6WnudtcPW46hOxe7lJEV+VeftHVn5Cri4oNjG6mdH +2/a0XY+pjhLZX/Ru9etI8yqA5MwvJCRAiuGJ+ly4+rluEe0ksl4dJJPEawaccfUU +lsPOfvWVbrBxPC/e6oo8VYjE3yfUPV3PRAcU1S/2Rzf/TruOlv3q4Anu/n6jr4Mf +NV9yDnTfs+rYTy2m9H0Si4CxBR9nLlAJ9ySRTgvwgKjTnFNYI66fEpa2endmSjYI +J/61Zz7NDe8QmHmtSd7XIflPJs5e4GO7mketr+Dpgs3KtqDBeU8MGt//u0m+JaKI +S/3J6zLu9ETuKOKkBQAN4ehcK1ebGr7orqYrjfRlwP9aMmy2gJGEqQbzCxmi3QTL +BtskB92MiXAHO1C2lfc62CIZvX3Ds6MlzoRsz/JCz3X+QCM8N3cV+gnxjYeLP+Vz +iqhF8Z7Wr+XA82sKi2Y9hJYgBCkQi1SiaoPJqHTiW6WT9J8/Drg+Z6qOUlznNHJU +BkdApws6Pv7UjzFSMhUpA/Ap+YL/FEAEWL4kvUXo0odoT+HS27XmMLGYy6yC3ZB3 +TzT091RaMUOg8Xq9atlcj4HjqfbbHYz1i3xKCI5YQq9qbIA4n5VmyGf8/6oqIaeh +WfOnGZlOR1P8oS303bMKG1946+/335JWEWk1GhkdqiE/cxkBz/pU7HT/hTSa9l0n +QfVILSm8DqMqpKWU6CTethlb4dET1DDq0axOfllKBSCMVWynh84svFLyxsiiXIkr +FqacHvQzHGjxFNycaky+4dzkbY35/yxmdr6LGQV3HZHMlP9kzQ6rKOUQzp62WQEr +YBIUeyKI2SaWYm1OyGR3C5b9hfXRKDuq9WfrXQwaM68cOLThquSxd6ic+JqdeDmx +wS5FOjTD8hpIBDQU8Tn0Ec4gzaJ8Ul8ho9I05/sPKbqz8fysoscOuAnoSHP0jJyk +eJ9BLB3+i82knoM+XdHt5T4DI7V9YMJQrfnCIorLyHjt0YjiZccI6MjfOizweZfo +MJTLkJz3f7gx8DU9c0+2BlrI5Dh4BckPPi1R/Lvn9RwdFKosrddATm3/2XcxWuUh +cCinEgJ2mLZ3IpPhIzt+548SVZrmFw/HBhz2Qv/jSoIBiLXJLAZEzTQHkgsSeDho +jdII2HTGDyNon7LYm1mA5CGk93mwaSf0hU4e7QVGI2/WBNhkX8GBD9pQUCCNck8d +QYNcxJ973rblmT72GG+0gZ2Uw+trPfGuKjVpvxqJ7AuiJ9u9mvYVaeejx6R7FVVx +k5En8SRTYk+M4ft5RDZeAbEEzcHpzHnFcm8QW6fbU6gQKvHwlRRqa7KD+UkwvcIV +SDka0xKnLwZbMWrDI4Yorp/U0x3vqGQbeN60r1iAe2oggT9C0HeKmuDiTDybnTAW +PyZ4b7PSc48d9hfxz8aB6xOQzPrEwu5bP6EJhiTzXhvmQWyVU87S7p3i7Hgv/Gb5 +cVVeUvRTX5femeYRxfS8Mk8MeAxFJvxqIc6P8QenT56UF99oNDOAs4Q+dAxC3y+a +JQ4eLUuk5u56m9oNTfThjXbzXhhL4+sw17SFEdwV3JMdHVDYfBW7jUNEjRH7aA4p +8Fc7xvuJ1uaK1cHIXU2wCi3IL+Vela4zGgOZzWKwAZdbgsiDlijECpdxnxxFqcBB +MkhgnA3VZ9dfrp39OBLdilWaeAJi5YQkU7B7cO/pK2EHGLtpT8tQQq8QoXedfu0X +53Dkhti1fT4V8uxoxgRWue9jfwgMHCl06t14oI7VRGTsy9cMK1GiqQciYGmeyVrN +m7XqyL29Wldb8IEtLWaPPbPTsnzH+BuIz0pa2qvjOUcWuVV+n+WKdCJlNMWn/5pq +nNJ6HFXKx2G1dfklihNyLbmJWKgBSnHU1xTyU9+s5frdNQfQy3tO7mQMgLZ3lT6c +Yeo29j4gOgHJOQ3PD7eV30aQwWefpx6RY7lMjDtGDxZLcPXmYCW2mAN9AQfj95TX +UtP08p2E3kyl1K4fugjfjXQY+XvDWFp/TuaclMOfZQ0yJpyxIpdkE5/0l+AUxaFc +1Pf26eQuiK8gRcpzbkc8lCIWWpHZiLZ4owFnSbvDs6sAeH3NLpM8kjGAuWvBQ4s0 +nX3fbMjvYHAm+SmrhEMvz7waaHlSg95vuc6OBjQtBz3pfp/wR5HV9KBuZsLJicMi +lRcsVETTE+y1g9uUpPZNyS85Ubryv+YXJY9UIMMNDdG2jG/NxY8GXO5wDY9WTdi+ +ZBrrrNMoBCrKMQQVlO1LWPAIsNegummSst7YAMees9YjjOpmKGMbcI/qNiEi7q9j +JVw+Ndgxu3RkWTh6TCyy8VYKz/RZh4Py7o1NB42u41x6/0t1KTTs+Sk/wWI7Qi0t +FfujTSHS7WoayYSX5NxPKN0pvglj5AvEOsSYZtQI3+UFJn9Ipci+XhYGhzRpAuAH +8icnA/znERnBKxWcZNbzqcnDJlcrkpLrqMrvZ/1AZakhC2gfVlaxIiO3Yf4ULgs2 +gB+ei1ndjU7LR8/0bKPkvw9qBUaQICVb2ohj3jCwZI5OA5L+EzhiBViRcd9utKM8 +tmaHMMecYr1nf0Gexc5uTIpNXZE60seKrqQYWEVHmhvE4D2o9qAK/BhUhLUot4WA +0UywhSh7jh9nyR4+oqUIAQI86XtZg0r95lTW8H6i5KNi3KfzOE3Gv7GJiSeMoK8l +cYEXjymlMICcv+xEf0GKJo8XhNs6gD5XjpFWdGfK5D0FdKj2TIB2GqVsOrBvxJrm +vz5pyIfVi+caLcogPKfcUmuKmBxMfCseHD5dHJVr/5t+/00HHVGl7VPGomZQpW+1 +oGfU7m3oyXTaGLXKII7vBxqsczfkzJIm1CKpxQE+ROCkc5nPjL4b8z0IlcP/i5Ty +4NqkZsfN9BNx9F2bfkhbr9VISOlhvwCWIxIK6RNTTj9D7kj4mR3ALeCN0GG2F+W7 +Bn3U/Sxv7G2D0O0Z3R9Xab7RxFFj5D8pDNhqwG7RD+dsiD2ubTQhPhug7OiV6R8c +WyupSHoUu/A7eXvxJ5Sx4xvi0mLPRoiemiCSFAEtBkTPew9IuBEfuuCQlI8pw6Z1 +31p6RYDOhvZDLnXDdD+cXTDz0mh38xcZxGJyiGHN9xfZNNSGWdcoV9zjWUDgfS5+ +bDNkr83JTQrPBOEoz6UGCyNX5+Dui4Nhkr3v8B5kqbfsLolNUN1KfXBLGchaGPXC +vJ+JGlNr+hioZH8H5l7MW07MhdkVgJzl+1oCzx7E1NEy41+OGZQcE1NATHT8aPZA +zbsBMU54w5BEd+X0UUk/aoOYMd/L7aQD350eO2jD3TdVELSghIVVHkkKbNUA5k85 +oMOut/xFqOTi8edBdZ86ACABp/K2hb2QLw49Lvj7pxxzZ5wayOnDCm1I3UFPTM5B +bDroR7YjYmo9a5nyWepiFr/C2FDhpmfsSpcQp9ohGIGo+pYmn7z5rgJyY+573j8o +7C64znCuMOlgQCeMfsvyjOr966YqRYWwuEzUkxFHyGb3w/qoJCI0F1eW9opgD0Rk +IHXxmoL96xu58i5XblhT+/vK9gnEIKW6znZTiasuUFifXgN77Ruox2jRn1RZIMID +ImYDW043pPEInHquP0JWkuoMnTb/S4NSOIrLX6T4MeMOCrF/DIgwJIIeUy5aNw0h +VWwdGiROl9FrLNKwdA/MXiQvOQvv2fCmxQOiW1R7So57Ex9U5hLQrXkY3PV0b7ji +0h+U81PPh1IVxA8B6bRXPgNTw/rceTUYlCT/g5VsxxqlaT7WPbgskJcucBYv5ye4 +bSwr2Kyt43uQU/EVN2jUf8rgNNKjUH+PbcRxIeeAl4N0CtrqFQ3xKkamxf+VA+Qe +7zfGp0rvs2jMs1GT8UKDTnDs96Pb/VPBRgwkXcwmIwD7DnGjRchwQONIHrXQao1h +7+PPn7/B/6MglCD2ac8q4kfKqYBO3xdtwslGFpHBvbe70rOFz+m/PE9ksGPTFjya +8TUbpkk2+LZMO++q3Tz617ePv0K6bVFM2h+zkn/QW1YHp5CKg4JUbzpJ4f8Oo6qS +Q1VtZ5lyeYLxyi6lUx5zykBnUWemZlLcPftHQu19Rr1FLM8nIoCr73/fHKE7fOCn +uv6wd7qtfAgafr3L63d9IKd5pUHiUHVd2saBCPqtvUedqHjOkaXnTald5A0Q2tym +og17OitdI0HrPM3amtPiAduDOEdrsIYPMdksMVyTMGiRb8pWuSI54xxrL8LDNXaY +5ZoWhqFL6rdUYbYBkUPcXDyOLGvnfka27NSvc3x6EhklsgZds7RURLxE0hUOGRPd +uQO9WFSq1dQ9wKGIV02lY4CD5dnk8EzszJh0f8YN7MDzm6F9P8/QNV5VSvUv68gO +HJd6U9Iz1ZQdQSbNtSQDUb8hupUWPSyTrK1s37U0o88J5jHa2z8Hw5CvcqWlofT7 +xCmSoV/M1kuZuXdBw390oY3hTnfSdLIwzbrcHZSod3ji3Us0xfKQ20nocBS1wucD +ONLz6gRgz/HfsLz7NwgqxpY7hCSrm4UW8McheKpIwogvUD0QNupycPKaztN5Dxju +zUKkcMyHFqKk98+BaHQ7muT0daMm25pFqmzRXYd+Xn4yDlCs3bnCfLpKx4kN5Dcp +xjzxFBv8WK750W6Fi4/uC39X/5/m2T4G+fn7Z+YpmgmHHq81m16cmo9sx7uMY8uU +hSCvqqa/Ys8ylO2a14Aa3+7PbxLvjowVEjO24nczkUIeXfrrAOgYmk7o5ehlYbq3 +3EPwRxYaYfN+4e/kbp5/LHgyw1VkYEj6HYwdDVDGXPdjIs1WFRKreDusAMXdhtVi +vAvb7pgMZ5atBfN28yJ4SASkD7RN22y+cvIAueNvJ0eiuvV2g8JrEgRRqvdOXZlK +FWsckHdHx3V01xEixWtrClfkFqrEvbkusEgbS+rLQSJ5cHXL2aw1KAMz6Mm30kT4 +VaIaGTJkSoQaUvG24iUigSGIKtGT97oALAW6hTiJtxYOl+JJp6SSpBDPR5QlxMl4 +rhTsckt8MsXjcVQMqKN29fFS8vgg+qOdwuKT5Kx+kDDTnFKPMfJdLG9YBM/QbToU +/Fpo1Oy+bq1Rc4MDLUGQ9qLPY33QWvuhLSQWo0/1IHBOODZ64mI0hrH3tzwSp06f +Kmfqnrksqgv8gqZUPWFx2anIISzdvpkHLhKCnPZ9frNDEhJaKv1f7AHhdam2MAB9 +mxD5ok86t1RlOQSjvffj37XPHYgPKoGUqvBFOAK91LToMFsOvsCQKVRNi8LZd2Jt +yXRudNPePh8ku1DYa5jdoyJRK4PP6hHpowqoffcziiE9gYVZOwB03+d7b4CjJ3Yo +quz6Hy7IeTXxxGHVrl+6B7nnkSK+xzA8JfzP4MUFA3LvctyTe7SZZ5q5vdIym7SB +ZU6GwVztFlP+XV2YuLdCFmHW9ACc3Nt88+xetNEuS5/WUM2crlHa2b4XB4mRFY0g +psG5IBnuJycVWpgFWIfAEY/BnN299ugH9obziDAVv+CPa9e6yOn0/exYUaBMWoPO +uv7Uq5oX9UuOeCWYg72KEUg8lR6Bb0vAOaYZz5Db8vTn7nEYlK7Re9TRh2+saGcu +GCgGWnyIv6oZSQOsU6DdoVl8TCy2n80AfBC9ZRyFNK+6CWBKFEC4ubun3u6lNFuD +mLyF0Gha1wrw0NwJeiYyO+i0S3nojsJU5bXAs/UpFRT5qoQ1Fp5QryaZXI16AopO +yaOhq9vxZRLFdHkO0hIJpuwS19oDyNJ6uxV3uexNAVHVN+NIiIPtrmGo6cEGkYag +rNXanJBxQLm9MSGFQbU3xzHtQgHYQeuESDnXUy1teENew1v4CxTmSH0SfHhLN/Yf +m4R774a8iYWgwgtpqGf3F9b9ke71xJlOdgTWozcUpm7l5mwnAtaoi2Qx4Z3KDX5F +VeL0Ms4OoiTbI9R/Llq1Uqp9TgRgIw8kSDD2B3XHwOmuGKducCzKgkJ538kR4TTB +g/DiTm3UPlXab2xrMkH3XrpBivdDph+XvgZb7R1IHkrSjEpEDRGJ78H1SrCcXbQx +Nup0petSghoZ1XxCceh6Vq+oELwBe7dN0gW8scaFztHHMIW3x66VxWAFusHm1fEa +tq3ALVyumHji4DlFeS8TQxZs57XIXffL+q6+6aFOfW35XXNXO5jHeZzE77uEox3v +o64aRkluXkolV+3XmiJckwN/0CAImEA7VdPSaLb87Ljaff75QJrjqWUszXlDbHEF +DL2esh/kkTQc5jwV6tXG4y9MiZ55jMH9PficRjoFtkrQR7xozX8taxl5d722Qp9V +Y9TkGr/9O3GqL/poF5cty8w+m54uqeSW6X00a4DadiU2c0e8GevGKRo/YydlYUEK +jjSVMivz4/xpIphEplV5FhjdFo728UNyBcysmEWP/uQpmp1AX1y4QJY8toi5H9nc +8vuuzliVoHYq2X+ehxq21v0Wglwg3TdlC9JlzsaQvb8bsmtD56sdghKkwVWuR1vs +mmBCKcu9K22yJpFaeE2VtXXMhSpaPiMW1te27BBVpKczen2E87bi0TZnQlPYXoCe +G1Na1h5lKIR+m8+9nEHjAyPHTxUYc2TPso187ssOqb1bop+7DetR8Xj5azoUhTg8 +Uw== -----END AGE ENCRYPTED FILE----- diff --git a/AGENTS.md b/AGENTS.md index cff663d..092702a 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -17,10 +17,13 @@ Read these for project context: - `.harness/adr/0010-yaml-first-match-manifest.md` - `.harness/adr/0011-branch-ephemeral-scope.md` - `.harness/adr/0012-macos-native-codesign-on-macos-runner.md` +- `.harness/adr/0013-windows-owner-only-materialization.md` - `.harness/engineering/architecture.md` - `.harness/engineering/features/branch-ephemeral-scope.md` +- `.harness/engineering/features/windows-x64-support.md` - `.harness/engineering/features/work-state-agents-filtering.md` - `.harness/product/announcements-2026-07.md` +- `.harness/product/announcements-2026-08.md` - `.harness/product/competitors.md` - `.harness/product/product.md` - `.harness/product/roadmap.md` diff --git a/cmd/merge.go b/cmd/merge.go index abb13dc..c7b8687 100644 --- a/cmd/merge.go +++ b/cmd/merge.go @@ -110,7 +110,7 @@ func runMerge(args []string) error { if err := os.WriteFile(current, ct, 0o600); err != nil { return err } - return fmt.Errorf("merge: conflicts in %s — run `doctier unlock` to materialize protected plaintext conflict markers, resolve them, then git add", path) + return fmt.Errorf("merge: conflicts in %s: run `doctier unlock` to materialize protected plaintext conflict markers, resolve them, then git add", path) } // Only the worktree receives this; the index keeps the three encrypted // stages, so plaintext markers here leak nothing into git. The merge