From a0734a389321ed680d3f1753eb79494578715f61 Mon Sep 17 00:00:00 2001 From: Appu Date: Fri, 28 Aug 2026 13:42:10 -0400 Subject: [PATCH] feat(apt): add OpenPGP signature verification for apt repository indices - Verify InRelease / Release.gpg signatures via gpgv or sqv and enforce Release SHA256 checksums on package indices. - Now requiring either gpg_keys or explicit allow_unsigned = True. - Auto-dearmor ASCII-armored .asc keyrings (requires sq or gpg) - A new e2e test for test failure Signed-off-by: Appu --- .github/workflows/ci.yaml | 18 +- .gitignore | 4 + README.md | 24 + apt/BUILD.bazel | 1 + apt/extensions.bzl | 151 +++++- apt/private/BUILD.bazel | 7 + apt/private/apt_deb_repository.bzl | 22 +- apt/private/pgp.bzl | 241 +++++++++ apt/private/util.bzl | 36 ++ apt/tests/BUILD.bazel | 3 + apt/tests/release_test.bzl | 238 +++++++++ e2e/invalid_key/.bazelversion | 1 + e2e/invalid_key/BUILD.bazel | 4 + e2e/invalid_key/MODULE.bazel | 32 ++ e2e/invalid_key/README.md | 5 + e2e/invalid_key/keys/BUILD.bazel | 1 + e2e/invalid_key/keys/invalid-key.asc | 18 + e2e/no_gpg_keys/.bazelversion | 1 + e2e/no_gpg_keys/BUILD.bazel | 4 + e2e/no_gpg_keys/MODULE.bazel | 30 ++ e2e/no_gpg_keys/README.md | 5 + e2e/smoke/MODULE.bazel | 4 + e2e/smoke/keys/BUILD.bazel | 3 + e2e/smoke/keys/debian-test-keys.asc | 769 +++++++++++++++++++++++++++ examples/MODULE.bazel | 4 +- examples/keys/BUILD.bazel | 3 + examples/keys/debian-test-keys.asc | 769 +++++++++++++++++++++++++++ 27 files changed, 2380 insertions(+), 18 deletions(-) create mode 100644 apt/private/pgp.bzl create mode 100644 apt/tests/release_test.bzl create mode 120000 e2e/invalid_key/.bazelversion create mode 100644 e2e/invalid_key/BUILD.bazel create mode 100644 e2e/invalid_key/MODULE.bazel create mode 100644 e2e/invalid_key/README.md create mode 100644 e2e/invalid_key/keys/BUILD.bazel create mode 100644 e2e/invalid_key/keys/invalid-key.asc create mode 120000 e2e/no_gpg_keys/.bazelversion create mode 100644 e2e/no_gpg_keys/BUILD.bazel create mode 100644 e2e/no_gpg_keys/MODULE.bazel create mode 100644 e2e/no_gpg_keys/README.md create mode 100644 e2e/smoke/keys/BUILD.bazel create mode 100644 e2e/smoke/keys/debian-test-keys.asc create mode 100644 examples/keys/BUILD.bazel create mode 100644 examples/keys/debian-test-keys.asc diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index abb69f9b..7771069a 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -30,11 +30,27 @@ jobs: name: examples - dir: e2e/smoke name: e2e-smoke + - dir: e2e/invalid_key + name: e2e-invalid-key + expect_failure_log: "GPG verification failed" + - dir: e2e/no_gpg_keys + name: e2e-no-gpg-keys + expect_failure_log: "signature verification is required by default" runs-on: ${{ matrix.os }} steps: - uses: actions/checkout@v7.0.1 - uses: bazel-contrib/setup-bazel@0.19.0 - - run: USE_BAZEL_VERSION=${{ matrix.bazel-version }} bazel test //... + - if: ${{ !matrix.workspace.expect_failure_log }} + run: USE_BAZEL_VERSION=${{ matrix.bazel-version }} bazel test //... + working-directory: ${{ matrix.workspace.dir }} + - if: ${{ matrix.workspace.expect_failure_log }} + run: | + if USE_BAZEL_VERSION=${{ matrix.bazel-version }} bazel build //... > stderr.log 2>&1; then + echo "Expected build to fail, but it succeeded!" + exit 1 + fi + cat stderr.log + grep -q "${{ matrix.workspace.expect_failure_log }}" stderr.log working-directory: ${{ matrix.workspace.dir }} - name: Upload test logs if: failure() diff --git a/.gitignore b/.gitignore index 265257eb..81994c45 100644 --- a/.gitignore +++ b/.gitignore @@ -2,6 +2,10 @@ # see https://github.com/bazelbuild/bazel/issues/20369 MODULE.bazel.lock e2e/smoke/MODULE.bazel.lock +e2e/invalid_key/MODULE.bazel.lock +e2e/no_gpg_keys/MODULE.bazel.lock +e2e/invalid_key/stderr.log +e2e/no_gpg_keys/stderr.log bazel-* .bazelrc.user .idea/ diff --git a/README.md b/README.md index e73e40f6..49092f8f 100644 --- a/README.md +++ b/README.md @@ -52,6 +52,30 @@ git_override( ) ``` +## GPG / OpenPGP Signature Verification + +`rules_distroless` verifies cryptographic OpenPGP signatures on repository indices +(`InRelease` or `Release` + `Release.gpg`) using `gpgv` or `sqv` on `PATH`: + +```starlark +apt.sources_list( + architectures = ["amd64", "arm64"], + components = ["main"], + gpg_keys = ["//keys:debian-archive-keyring.gpg"], + suites = ["bookworm"], + types = ["deb"], + uris = ["https://deb.debian.org/debian"], +) +``` + +> [!NOTE] +> **Keyring Requirements (`gpgv` vs. `sqv`)**: Distribution index files (`InRelease`) +> are often cross-signed by multiple keys (e.g., current release key, successor key, and transition keys). +> - `gpgv` strictly requires that **all** keys that signed the file are present in the keyring; it exits with code 2 if any co-signing key is missing. +> - `sqv` requires at least one valid signature from the keyring. +> +> To ensure reproducible builds across machines regardless of which verifier is installed on `PATH`, keyrings should include all co-signing keys present on the target release files (or the full distribution archive keyring). + # Examples The [examples](/examples) demonstrate how to accomplish typical tasks such as diff --git a/apt/BUILD.bazel b/apt/BUILD.bazel index 8d7350c8..d005233a 100644 --- a/apt/BUILD.bazel +++ b/apt/BUILD.bazel @@ -24,6 +24,7 @@ bzl_library( "//apt/private:deb_filemap", "//apt/private:deb_import", "//apt/private:lockfile", + "//apt/private:pgp", "//apt/private:translate_dependency_set", "//apt/private:util", "//apt/private:version_constraint", diff --git a/apt/extensions.bzl b/apt/extensions.bzl index cea40e0b..0ff13466 100644 --- a/apt/extensions.bzl +++ b/apt/extensions.bzl @@ -6,6 +6,7 @@ load("//apt/private:apt_dep_resolver.bzl", "dependency_resolver") load("//apt/private:deb_filemap.bzl", "deb_filemap") load("//apt/private:deb_import.bzl", "deb_import") load("//apt/private:lockfile.bzl", "lockfile") +load("//apt/private:pgp.bzl", "pgp") load("//apt/private:translate_dependency_set.bzl", "translate_dependency_set") load("//apt/private:util.bzl", "util") load("//apt/private:version_constraint.bzl", "version_constraint") @@ -23,7 +24,7 @@ def _get_auth(mctx, urls): netrc = read_user_netrc(mctx) return use_netrc(netrc, urls, {}) -def _start_downloads(mctx, urls, dist, comp, arch, integrity, index_type, source_id, cached_format = None): +def _start_downloads(mctx, urls, dist, comp, arch, integrity, index_type, source_id, cached_format = None, hashes = None): """Initiate all format downloads for a given index type with block=False. If cached_format is set, only that extension is attempted — avoiding @@ -51,11 +52,29 @@ def _start_downloads(mctx, urls, dist, comp, arch, integrity, index_type, source ("", ["true"]), ] + # Filter extensions if we have verified hashes from Release file + if hashes != None: + available_extensions = [] + for (ext, cmd) in extensions: + if index_type == "Packages": + path = "{}/binary-{}/{}{}".format(comp, arch, index_type, ext) + else: + path = "{}/Contents-{}{}".format(comp, arch, ext) + if path in hashes: + available_extensions.append((ext, cmd)) + extensions = available_extensions + if not extensions: + if index_type == "Packages": + fail("No Packages index found in Release file for suite '{}', component '{}', arch '{}'".format(dist, comp, arch)) + else: + return [] + if cached_format != None: extensions = [(ext, cmd) for (ext, cmd) in extensions if ext == cached_format] base_auth = _get_auth(mctx, urls) tokens = [] + for (url_idx, url) in enumerate(urls): for (ext, cmd) in extensions: # Each (url, ext) gets a unique output directory to prevent @@ -65,16 +84,32 @@ def _start_downloads(mctx, urls, dist, comp, arch, integrity, index_type, source ext_name = ext.lstrip(".") if ext else "raw" output = "{}/{}/{}/{}/{}{}".format(source_id, target_triple, url_idx, ext_name, index_type, ext) if index_type == "Packages": - dist_url = "{}/dists/{}/{}/binary-{}/{}{}".format(url, dist, comp, arch, index_type, ext) + path = "{}/binary-{}/{}{}".format(comp, arch, index_type, ext) + dist_url = "{}/dists/{}/{}".format(url, dist, path) else: - dist_url = "{}/dists/{}/{}/Contents-{}{}".format(url, dist, comp, arch, ext) + path = "{}/Contents-{}{}".format(comp, arch, ext) + dist_url = "{}/dists/{}/{}".format(url, dist, path) + auth = {} if url in base_auth: auth = {dist_url: base_auth[url]} + + sha256 = "" + if hashes != None: + if path not in hashes: + fail("Missing SHA256 checksum in Release file for '{}' (suite '{}', component '{}', arch '{}')".format( + path, + dist, + comp, + arch, + )) + sha256 = hashes[path] + token = mctx.download( url = dist_url, output = output, - integrity = integrity, + integrity = integrity if hashes == None else "", + sha256 = sha256, allow_fail = True, auth = auth, block = False, @@ -135,8 +170,19 @@ def _fetch_and_parse_sources(mctx, repo, glock, snapshot_indices, formats): pending = [] seen = {} used_keys = {} + verified_releases = {} + + def get_release_hashes(dist, urls, gpg_keys): + cache_key = (dist, tuple(urls), tuple([str(k) for k in gpg_keys])) + if cache_key in verified_releases: + return verified_releases[cache_key] + release_content = pgp.download_and_verify_release(mctx, urls, dist, gpg_keys) + hashes = util.parse_release_file(release_content) + verified_releases[cache_key] = hashes + return hashes + for source_key, source in repo.sources().items(): - (urls, dist, component, architecture) = source + (urls, dist, component, architecture, gpg_keys) = source # Deduplicate: multiple dict entries can map to the same logical source # (one entry per URL in the urls list). Only process each unique @@ -163,6 +209,10 @@ def _fetch_and_parse_sources(mctx, repo, glock, snapshot_indices, formats): cached_pkg_format = formats.get(pkg_fact_key) cached_cnt_format = formats.get(cnt_fact_key) + hashes = None + if gpg_keys: + hashes = get_release_hashes(dist, urls, gpg_keys) + # Pass 1: Initiate all downloads with block=False # For snapshot suites, integrity hashes from facts enable instant cache hits. # Cached formats narrow downloads to only the known-good extension. @@ -177,6 +227,7 @@ def _fetch_and_parse_sources(mctx, repo, glock, snapshot_indices, formats): "Packages", source_id = len(seen), cached_format = cached_pkg_format, + hashes = hashes, ) cnt_tokens = None @@ -191,6 +242,7 @@ def _fetch_and_parse_sources(mctx, repo, glock, snapshot_indices, formats): "Contents", source_id = len(seen), cached_format = cached_cnt_format, + hashes = hashes, ) pending.append(( @@ -206,6 +258,8 @@ def _fetch_and_parse_sources(mctx, repo, glock, snapshot_indices, formats): # Pass 2: Wait, decompress, parse for (urls, dist, comp, arch, pkg_tokens, cnt_tokens, pkg_fk, cnt_fk) in pending: + if not pkg_tokens: + continue mctx.report_progress("resolving Package indices: {}/{} for {}".format(dist, comp, arch)) (output, url, integrity, ext) = _resolve_downloads(mctx, pkg_tokens, "Packages", dist, comp, arch) if pkg_fk in snapshot_indices: @@ -215,7 +269,7 @@ def _fetch_and_parse_sources(mctx, repo, glock, snapshot_indices, formats): mctx.report_progress("parsing Package indices: {}/{} for {}".format(dist, comp, arch)) repo.parse_package_index(mctx.read(output), urls, dist) - if cnt_tokens != None: + if cnt_tokens: mctx.report_progress("resolving Contents: {}/{} for {}".format(dist, comp, arch)) contents_result = _resolve_downloads(mctx, cnt_tokens, "Contents", dist, comp, arch) else: @@ -292,6 +346,22 @@ def _distroless_extension(mctx): for sl in mod.tags.sources_list: uris = [uri.removeprefix("mirror+") for uri in sl.uris] architectures = sl.architectures + gpg_keys = list(sl.gpg_keys) + + if gpg_keys and sl.allow_unsigned: + fail( + "\n\nRepository source for suite(s) {} from {} specified both GPG keyring(s) and `allow_unsigned = True`.\n\n".format(sl.suites, sl.uris) + + "These options are mutually exclusive. Either remove `allow_unsigned = True` to enable signature verification, or remove `gpg_keys` to allow unsigned repositories.\n", + ) + + if not gpg_keys and not sl.allow_unsigned: + fail( + "\n\nRepository source for suite(s) {} from {} has no GPG/OpenPGP keyring specified (`gpg_keys`).\n\n".format(sl.suites, sl.uris) + + "Cryptographic OpenPGP signature verification is required by default to guarantee repository integrity.\n" + + "To resolve this, either:\n" + + " 1 - Provide the repository GPG keyring(s) via `gpg_keys = [\"//keys:debian.gpg\"]` (or `.asc`).\n" + + " 2 - Explicitly allow unsigned repositories by setting `allow_unsigned = True` in `apt.sources_list`.\n", + ) for suite in sl.suites: glock.add_source( @@ -303,7 +373,7 @@ def _distroless_extension(mctx): ) repo.add_source( - (uris, suite, sl.components, architectures), + (uris, suite, sl.components, architectures, tuple(gpg_keys)), ) # Seed cached formats from facts (which extensions each remote serves) @@ -623,18 +693,79 @@ examples showing how to do this for Debian and Ubuntu: For more infomation, please check https://snapshot.debian.org and/or https://snapshot.ubuntu.com. + +### GPG / OpenPGP Signature Verification + +`rules_distroless` supports verifying the cryptographic OpenPGP signatures on repository +indices (`InRelease` or `Release` + `Release.gpg`) before downloading package indexes. + +You can specify keyring files using `gpg_keys`: + +```starlark +apt.sources_list( + architectures = ["amd64", "arm64"], + components = ["main"], + gpg_keys = ["//keys:debian-archive-keyring.gpg"], + suites = ["bookworm"], + types = ["deb"], + uris = ["https://deb.debian.org/debian"], +) +``` + +The extension auto-detects `gpgv` or `sqv` (Sequoia PGP) on `PATH`: +- Verifies `InRelease` clearsigned files (or `Release.gpg` detached signatures). +- Extracts the verified `SHA256:` checksum table for index files (`Packages.xz`, `Contents-*.gz`). +- Passes SHA256 hashes to Bazel download actions to guarantee end-to-end repository integrity. + +> **Keyring Formats**: Both binary OpenPGP keyrings (`.gpg` / `.kbx`) and ASCII-armored +> keyrings (`.asc`) are supported. When using `gpgv`, ASCII-armored keyrings are +> automatically converted to binary format using `gpg --dearmor` if needed. + +> **Valid-Until & Expiration Notice**: `Valid-Until` timestamps in `Release` files are +> intentionally not enforced. Bazel's execution model is hermetic (no host clock in Starlark), +> snapshot archives have expired dates by definition, and wall-clock enforcement would cause +> reproducible builds to spontaneously fail ("time bombs") when evaluated in the future. +> +> **Security Implication**: Snapshot repositories (`snapshot.debian.org`, `snapshot.ubuntu.com`) +> are immutably tied to a point-in-time snapshot, mitigating rollback and freeze attacks. +> However, for rolling suites (such as `deb.debian.org/debian bookworm`), an active network +> attacker or compromised mirror could theoretically serve a stale-but-validly-signed `Release` +> file without being detected by `rules_distroless`. Users requiring protection against freeze +> attacks should use snapshot archive URLs. + +If you are using an unsigned internal repository or do not wish to verify signatures, +you must explicitly opt in with `allow_unsigned = True`: + +```starlark +apt.sources_list( + allow_unsigned = True, + architectures = ["amd64"], + components = ["main"], + suites = ["custom"], + types = ["deb"], + uris = ["https://internal.repo.corp.example.com"], +) +``` """ sources_list = tag_class( attrs = { + "allow_unsigned": attr.bool( + default = False, + doc = "Allow unverified/unsigned repository indices without GPG keys.", + ), + "architectures": attr.string_list(), + "components": attr.string_list(), + "gpg_keys": attr.label_list( + allow_files = True, + doc = "Optional list of GPG/OpenPGP keyring files (.gpg or .asc) for repository signature verification.", + ), "sources": attr.string_list( # mandatory = True, ), + "suites": attr.string_list(), "types": attr.string_list(), "uris": attr.string_list(), - "suites": attr.string_list(), - "components": attr.string_list(), - "architectures": attr.string_list(), }, ) diff --git a/apt/private/BUILD.bazel b/apt/private/BUILD.bazel index ed5777b4..4681dd6b 100644 --- a/apt/private/BUILD.bazel +++ b/apt/private/BUILD.bazel @@ -145,6 +145,13 @@ bzl_library( visibility = ["//apt:__subpackages__"], ) +bzl_library( + name = "pgp", + srcs = ["pgp.bzl"], + visibility = ["//apt:__subpackages__"], + deps = [":util"], +) + bzl_library( name = "util", srcs = ["util.bzl"], diff --git a/apt/private/apt_deb_repository.bzl b/apt/private/apt_deb_repository.bzl index 037dbee6..04bfda89 100644 --- a/apt/private/apt_deb_repository.bzl +++ b/apt/private/apt_deb_repository.bzl @@ -120,7 +120,7 @@ def _filemap(state, name, arch): return state.filemap[arch][name] def _add_source_if_not_present(state, source): - (urls, dist, components, architectures) = source + (urls, dist, components, architectures, gpg_keys) = source for arch in architectures: for comp in components: @@ -128,14 +128,24 @@ def _add_source_if_not_present(state, source): "%".join((url, dist, comp, arch)) for url in urls ] - found = any([ - key in state.sources - for key in keys - ]) + found = False + for key in keys: + if key in state.sources: + found = True + (_, _, _, _, old_keys) = state.sources[key] + if sorted([str(k) for k in old_keys]) != sorted([str(k) for k in gpg_keys]): + fail("Conflicting GPG configuration for source '{url}' suite '{dist}' component '{comp}' arch '{arch}': previously registered with gpg_keys = {old}; conflicting definition has gpg_keys = {new}.".format( + url = key.split("%")[0], + dist = dist, + comp = comp, + arch = arch, + old = old_keys, + new = gpg_keys, + )) if found: continue for key in keys: - state.sources[key] = (urls, dist, comp, arch) + state.sources[key] = (urls, dist, comp, arch, gpg_keys) def _create(): state = struct( diff --git a/apt/private/pgp.bzl b/apt/private/pgp.bzl new file mode 100644 index 00000000..423a0d06 --- /dev/null +++ b/apt/private/pgp.bzl @@ -0,0 +1,241 @@ +"OpenPGP verification utilities for APT repositories" + +load(":util.bzl", "util") + +def _find_pgp_verifier(mctx): + """Detect available OpenPGP verifier, preferring sqv over gpgv.""" + if mctx.which("sqv"): + return "sqv" + if mctx.which("gpgv"): + return "gpgv" + return None + +def _format_verifier_output(res, verifier): + details = [] + if res.stderr: + details.append("stderr:\n" + res.stderr) + if res.stdout: + details.append("stdout:\n" + res.stdout) + out_str = "\n".join(details) if details else "no output" + return "{} exit code: {}\n{}".format(verifier, res.return_code, out_str) + +def _is_verification_success(res, verifier): + """Evaluates whether the verifier execution resulted in a successful verification.""" + if res.return_code == 0: + return True + if verifier == "gpgv": + # When an index is signed with multiple keys and the provided keyring only + # contains a subset of them, gpgv returns non-zero (exit code 2) due to + # missing public keys for the other signatures. With --status-fd 1, verify + # that at least one trusted signature is good and no signature is bad. + out = res.stdout + has_good_sig = "[GNUPG:] GOODSIG " in out or "[GNUPG:] VALIDSIG " in out + has_bad_sig = "[GNUPG:] BADSIG " in out + if has_good_sig and not has_bad_sig: + return True + return False + +def _verifier_cmd(verifier, keyring_args, mode, sig_path, msg_path = None, out_path = None): + """Builds execution command arguments for gpgv or sqv.""" + if verifier == "gpgv": + cmd = ["gpgv", "--status-fd", "1"] + keyring_args + if mode == "clearsigned": + return cmd + [str(sig_path)] + return cmd + [str(sig_path), str(msg_path)] + elif verifier == "sqv": + if mode == "clearsigned": + return ["sqv"] + keyring_args + ["--cleartext", "--output", str(out_path), str(sig_path)] + return ["sqv"] + keyring_args + ["--signature-file", str(sig_path), str(msg_path)] + else: + fail("No OpenPGP verifier found (gpgv or sqv).") + +def _strip_pgp_clearsign_armor(content): + """Strips PGP cleartext signature framing from InRelease content.""" + if "-----BEGIN PGP SIGNED MESSAGE-----" not in content: + return content + + lines = content.splitlines() + output_lines = [] + in_message = False + in_header = False + for line in lines: + if line.startswith("-----BEGIN PGP SIGNED MESSAGE-----"): + in_header = True + continue + if in_header: + if line.strip() == "": + in_header = False + in_message = True + continue + if line.startswith("-----BEGIN PGP SIGNATURE-----"): + in_message = False + break + if in_message: + if line.startswith("- "): + line = line[2:] + output_lines.append(line) + if not output_lines: + fail("Malformed PGP clearsigned message: failed to extract signed content.") + return "\n".join(output_lines) + +def _build_keyring_args(key_paths): + """Build repeated --keyring arguments for a list of keyring paths.""" + args = [] + for k in key_paths: + args.extend(["--keyring", str(k)]) + return args + +def _is_ascii_armored(content): + """Returns True if the content is an ASCII-armored OpenPGP block.""" + return "-----BEGIN PGP" in content + +def _verify_inrelease(mctx, verifier, keyring_args, in_release_path, output_verified_path): + """Verifies InRelease using gpgv or sqv and returns (success, content_or_error).""" + + # sqv creates its output with create_new(true) and fails with os error 17 if the output file already exists. + # Since module_ctx lacks repository_ctx.delete(), we remove any leftover file from earlier runs. + mctx.execute(["rm", "-f", str(mctx.path(output_verified_path))]) + + cmd = _verifier_cmd( + verifier, + keyring_args, + "clearsigned", + mctx.path(in_release_path), + out_path = mctx.path(output_verified_path), + ) + res = mctx.execute(cmd) + if not _is_verification_success(res, verifier): + return (False, _format_verifier_output(res, verifier)) + if verifier == "gpgv": + return (True, _strip_pgp_clearsign_armor(mctx.read(in_release_path))) + return (True, mctx.read(output_verified_path)) + +def _verify_detached_release(mctx, verifier, keyring_args, release_gpg_path, release_path): + """Verifies detached Release.gpg signature against Release using gpgv or sqv.""" + cmd = _verifier_cmd( + verifier, + keyring_args, + "detached", + mctx.path(release_gpg_path), + msg_path = mctx.path(release_path), + ) + res = mctx.execute(cmd) + if not _is_verification_success(res, verifier): + return (False, _format_verifier_output(res, verifier)) + return (True, mctx.read(release_path)) + +def _prepare_keyring_paths(mctx, verifier, gpg_keys): + """Prepares keyring file paths, automatically dearmoring ASCII keys if using gpgv.""" + paths = [] + for key_label in gpg_keys: + key_path = mctx.path(key_label) + if verifier == "gpgv": + key_str = str(key_path) + + # Binary keyrings (.gpg, .kbx) require no dearmoring; avoid reading raw binary data + if not key_str.endswith(".gpg") and not key_str.endswith(".kbx"): + content = mctx.read(key_path) + if _is_ascii_armored(content): + dearmored_rel_path = "dearmored_key_{}.gpg".format(util.sanitize(str(key_label))) + dearmored_path = mctx.path(dearmored_rel_path) + + gpg_bin = mctx.which("gpg") + sq_bin = mctx.which("sq") + if gpg_bin: + res = mctx.execute([ + "gpg", + "--dearmor", + "--batch", + "--yes", + "-o", + str(dearmored_path), + str(key_path), + ]) + if res.return_code != 0: + fail("Failed to dearmor ASCII key '{}' with gpg:\n{}\nPlease ensure a modern version of `gpg` (GnuPG 2.x) is installed on PATH.".format(key_label, res.stderr)) + paths.append(str(dearmored_path)) + continue + elif sq_bin: + res = mctx.execute([ + "sq", + "--overwrite", + "packet", + "dearmor", + "--output", + str(dearmored_path), + str(key_path), + ]) + if res.return_code != 0: + fail("Failed to dearmor ASCII key '{}' with sq:\n{}\nPlease ensure a modern version of `sq` (Sequoia PGP >= 1.0 supporting `sq packet dearmor`) is installed on PATH.".format(key_label, res.stderr)) + paths.append(str(dearmored_path)) + continue + else: + fail("Key '{}' is ASCII-armored, but `gpgv` requires binary OpenPGP format. Please install a modern version of `gpg` (GnuPG 2.x) or `sq` (Sequoia PGP >= 1.0) on PATH to auto-dearmor, or provide binary .gpg keyrings.".format(key_label)) + paths.append(str(key_path)) + return paths + +def _download_and_verify_release(mctx, urls, dist, gpg_keys): + """Downloads InRelease (or Release + Release.gpg) and verifies with gpgv/sqv.""" + verifier = _find_pgp_verifier(mctx) + if not verifier: + fail("GPG verification requested for dist '{}', but neither `gpgv` nor `sqv` was found on PATH. Please install a modern version of `gpgv` (GnuPG 2.x) or `sqv` (Sequoia PGP >= 1.0).".format(dist)) + + keyring_paths = _prepare_keyring_paths(mctx, verifier, gpg_keys) + keyring_args = _build_keyring_args(keyring_paths) + errors = [] + + for (url_idx, url) in enumerate(urls): + in_release_url = "{}/dists/{}/InRelease".format(url, dist) + in_release_path = "inrelease/{}/{}/InRelease".format(dist, url_idx) + verified_path = "inrelease/{}/{}/Release.verified".format(dist, url_idx) + + mctx.report_progress("Downloading InRelease from {}".format(in_release_url)) + download = mctx.download( + url = in_release_url, + output = in_release_path, + allow_fail = True, + ) + if download.success: + mctx.report_progress("Verifying InRelease signature using {}".format(verifier)) + ok, res = _verify_inrelease(mctx, verifier, keyring_args, in_release_path, verified_path) + if ok: + return res + fail("GPG verification failed for InRelease from {}:\n{}".format(in_release_url, res)) + else: + errors.append("Failed to download InRelease from {}".format(in_release_url)) + + # Fallback to Release + Release.gpg + release_url = "{}/dists/{}/Release".format(url, dist) + release_gpg_url = "{}/dists/{}/Release.gpg".format(url, dist) + release_path = "inrelease/{}/{}/Release".format(dist, url_idx) + release_gpg_path = "inrelease/{}/{}/Release.gpg".format(dist, url_idx) + + mctx.report_progress("Downloading Release from {}".format(release_url)) + dl_rel = mctx.download(url = release_url, output = release_path, allow_fail = True) + if dl_rel.success: + mctx.report_progress("Downloading Release.gpg from {}".format(release_gpg_url)) + dl_gpg = mctx.download(url = release_gpg_url, output = release_gpg_path, allow_fail = True) + if dl_gpg.success: + mctx.report_progress("Verifying Release signature using {}".format(verifier)) + ok, res = _verify_detached_release(mctx, verifier, keyring_args, release_gpg_path, release_path) + if ok: + return res + fail("GPG verification failed for Release from {}:\n{}".format(release_url, res)) + else: + errors.append("Failed to download Release.gpg from {}".format(release_gpg_url)) + else: + errors.append("Failed to download Release from {}".format(release_url)) + + fail("Failed to fetch or verify repository Release/InRelease for dist '{}':\n{}".format( + dist, + "\n".join(errors), + )) + +pgp = struct( + build_keyring_args = _build_keyring_args, + download_and_verify_release = _download_and_verify_release, + is_ascii_armored = _is_ascii_armored, + is_verification_success = _is_verification_success, + strip_clearsign_armor = _strip_pgp_clearsign_armor, + verifier_cmd = _verifier_cmd, +) diff --git a/apt/private/util.bzl b/apt/private/util.bzl index 066a2e23..ec467142 100644 --- a/apt/private/util.bzl +++ b/apt/private/util.bzl @@ -85,6 +85,41 @@ def _prune_uncacheable_facts(indices, formats, used_keys, snapshot_indices): } return (cacheable_indices, cacheable_formats) +def _split_whitespace(s): + """Splits a string by contiguous whitespace (spaces, tabs, newlines).""" + parts = [] + current = "" + for i in range(len(s)): + c = s[i] + if c == " " or c == "\t" or c == "\n" or c == "\r": + if current: + parts.append(current) + current = "" + else: + current += c + if current: + parts.append(current) + return parts + +def _parse_release_file(content): + """Parses SHA256 hashes for index files from Release/InRelease contents.""" + hashes = {} + lines = content.splitlines() + in_sha256_section = False + for line in lines: + is_continuation = line.startswith(" ") or line.startswith("\t") + if line.startswith("SHA256:"): + in_sha256_section = True + continue + elif line.startswith("SHA512:") or line.startswith("SHA1:") or line.startswith("MD5Sum:") or (line and not is_continuation): + in_sha256_section = False + if in_sha256_section and is_continuation: + parts = _split_whitespace(line) + if len(parts) == 3: + sha256, _size, path = parts + hashes[path] = sha256 + return hashes + def _warning(rctx, message): rctx.execute([ "echo", @@ -101,4 +136,5 @@ util = struct( is_snapshot_uri = _is_snapshot_uri, index_fact_key = _index_fact_key, prune_uncacheable_facts = _prune_uncacheable_facts, + parse_release_file = _parse_release_file, ) diff --git a/apt/tests/BUILD.bazel b/apt/tests/BUILD.bazel index bdff1ce1..701a8239 100644 --- a/apt/tests/BUILD.bazel +++ b/apt/tests/BUILD.bazel @@ -5,6 +5,7 @@ load(":extensions_test.bzl", "extensions_tests") load(":facts_test.bzl", "facts_tests") load(":linker_script_test.bzl", "linker_script_tests") load(":lockfile_test.bzl", "lockfile_tests") +load(":release_test.bzl", "release_tests") load(":resolution_test.bzl", "resolution_tests") load(":translate_dependency_set_test.bzl", "translate_dependency_set_tests") load(":version_test.bzl", "version_tests") @@ -25,6 +26,8 @@ linker_script_tests() lockfile_tests() +release_tests() + translate_dependency_set_tests() extensions_tests() diff --git a/apt/tests/release_test.bzl b/apt/tests/release_test.bzl new file mode 100644 index 00000000..f2b0da0b --- /dev/null +++ b/apt/tests/release_test.bzl @@ -0,0 +1,238 @@ +"unit tests for Release file parsing and PGP verification utilities" + +load("@bazel_skylib//lib:unittest.bzl", "asserts", "unittest") +load("//apt/private:apt_deb_repository.bzl", "deb_repository") +load("//apt/private:pgp.bzl", "pgp") +load("//apt/private:util.bzl", "util") + +_TEST_SUITE_PREFIX = "release/" + +def _strip_pgp_armor_test(ctx): + env = unittest.begin(ctx) + + clearsigned = """-----BEGIN PGP SIGNED MESSAGE----- +Hash: SHA256 + +Origin: Debian +Label: Debian +Suite: bookworm +- - A dash escaped line +Date: Sat, 10 Feb 2024 22:33:13 UTC +-----BEGIN PGP SIGNATURE----- + +iQIzBAEBCAAdFiEE... +-----END PGP SIGNATURE-----""" + + stripped = pgp.strip_clearsign_armor(clearsigned) + asserts.true(env, "Origin: Debian" in stripped) + asserts.true(env, "- A dash escaped line" in stripped) + asserts.false(env, "-----BEGIN PGP SIGNED MESSAGE-----" in stripped) + asserts.false(env, "-----BEGIN PGP SIGNATURE-----" in stripped) + + # Unarmored text remains unchanged + plain = "Origin: Debian\nSuite: bookworm" + asserts.equals(env, plain, pgp.strip_clearsign_armor(plain)) + + return unittest.end(env) + +def _parse_release_file_test(ctx): + env = unittest.begin(ctx) + + release_text = """Origin: Debian +Label: Debian +Suite: bullseye +Version: 11.9 +Codename: bullseye +Date: Sat, 10 Feb 2024 22:33:13 UTC +Valid-Until: Sat, 17 Feb 2024 22:33:13 UTC +Architectures: amd64 arm64 +Components: main contrib +MD5Sum: + 11111111111111111111111111111111 1234 main/binary-amd64/Packages.xz +SHA1: + 2222222222222222222222222222222222222222 1234 main/binary-amd64/Packages.xz +SHA256: + e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 main/binary-amd64/Packages + 8f434346648f6b96df89dda901c5176b10f6075361a446da52e96e204f947104 1234 main/binary-amd64/Packages.xz + 0a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b 5678 main/Contents-amd64.gz +SHA512: + 33333333333333333333333333333333333333333333333333333333333333333333333333333333 1234 main/binary-amd64/Packages.xz +""" + + hashes = util.parse_release_file(release_text) + asserts.equals(env, 3, len(hashes)) + asserts.equals( + env, + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + hashes.get("main/binary-amd64/Packages"), + ) + asserts.equals( + env, + "8f434346648f6b96df89dda901c5176b10f6075361a446da52e96e204f947104", + hashes.get("main/binary-amd64/Packages.xz"), + ) + asserts.equals( + env, + "0a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b", + hashes.get("main/Contents-amd64.gz"), + ) + + # Test tab-delimited and tab-indented Release file + tab_release = """Origin: Debian +Suite: bookworm +SHA256: +\t1111111111111111111111111111111111111111111111111111111111111111\t100\tmain/binary-amd64/Packages.gz +\t2222222222222222222222222222222222222222222222222222222222222222 200\tmain/binary-arm64/Packages.xz +SHA512: +\t3333333333333333333333333333333333333333333333333333333333333333\t100\tmain/binary-amd64/Packages.gz +""" + tab_hashes = util.parse_release_file(tab_release) + asserts.equals(env, 2, len(tab_hashes)) + asserts.equals( + env, + "1111111111111111111111111111111111111111111111111111111111111111", + tab_hashes.get("main/binary-amd64/Packages.gz"), + ) + asserts.equals( + env, + "2222222222222222222222222222222222222222222222222222222222222222", + tab_hashes.get("main/binary-arm64/Packages.xz"), + ) + + return unittest.end(env) + +def _build_keyring_args_test(ctx): + env = unittest.begin(ctx) + + args = pgp.build_keyring_args(["/path/to/key1.gpg", "/path/to/key2.asc"]) + asserts.equals(env, [ + "--keyring", + "/path/to/key1.gpg", + "--keyring", + "/path/to/key2.asc", + ], args) + + return unittest.end(env) + +def _deb_repository_stores_gpg_keys_test(ctx): + env = unittest.begin(ctx) + + repo = deb_repository.new() + repo.add_source(( + ["https://deb.debian.org/debian"], + "bookworm", + ["main"], + ["amd64"], + ("@my_repo//:key.gpg", "@my_repo//:extra.asc"), + )) + repo.add_source(( + ["https://custom.repo.org/apt"], + "custom", + ["main"], + ["amd64"], + ("@my_repo//:custom.gpg",), + )) + + sources = repo.sources() + asserts.true(env, len(sources) > 0) + for _key, source in sources.items(): + (_urls, dist, _comp, _arch, gpg_keys) = source + if dist == "bookworm": + asserts.equals(env, ("@my_repo//:key.gpg", "@my_repo//:extra.asc"), gpg_keys) + elif dist == "custom": + asserts.equals(env, ("@my_repo//:custom.gpg",), gpg_keys) + + return unittest.end(env) + +def _is_ascii_armored_test(ctx): + env = unittest.begin(ctx) + + # Realistic ASCII-armored public key block + asc_key_sample = """-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: GnuPG v2 + +mQENBF2X... +=abcd +-----END PGP PUBLIC KEY BLOCK-----""" + asserts.true(env, pgp.is_ascii_armored(asc_key_sample)) + + # Armor file headers + asserts.true(env, pgp.is_ascii_armored("-----BEGIN PGP ARMORED FILE-----\n...")) + asserts.true(env, pgp.is_ascii_armored("-----BEGIN PGP SIGNED MESSAGE-----\n...")) + + # Binary OpenPGP data / non-armored files + asserts.false(env, pgp.is_ascii_armored("binary-keyring-data-here")) + asserts.false(env, pgp.is_ascii_armored("Suite: bookworm\nOrigin: Debian")) + asserts.false(env, pgp.is_ascii_armored("")) + + return unittest.end(env) + +def _verifier_cmd_test(ctx): + env = unittest.begin(ctx) + + cmd_gpgv_clear = pgp.verifier_cmd("gpgv", ["--keyring", "k.gpg"], "clearsigned", "InRelease") + asserts.equals(env, ["gpgv", "--status-fd", "1", "--keyring", "k.gpg", "InRelease"], cmd_gpgv_clear) + + cmd_gpgv_detached = pgp.verifier_cmd("gpgv", ["--keyring", "k.gpg"], "detached", "Release.gpg", msg_path = "Release") + asserts.equals(env, ["gpgv", "--status-fd", "1", "--keyring", "k.gpg", "Release.gpg", "Release"], cmd_gpgv_detached) + + cmd_sqv_clear = pgp.verifier_cmd("sqv", ["--keyring", "k.gpg"], "clearsigned", "InRelease", out_path = "Release.verified") + asserts.equals(env, ["sqv", "--keyring", "k.gpg", "--cleartext", "--output", "Release.verified", "InRelease"], cmd_sqv_clear) + + cmd_sqv_detached = pgp.verifier_cmd("sqv", ["--keyring", "k.gpg"], "detached", "Release.gpg", msg_path = "Release") + asserts.equals(env, ["sqv", "--keyring", "k.gpg", "--signature-file", "Release.gpg", "Release"], cmd_sqv_detached) + + return unittest.end(env) + +def _verification_success_test(ctx): + env = unittest.begin(ctx) + + # Return code 0 is always success + asserts.true(env, pgp.is_verification_success(struct(return_code = 0, stdout = "", stderr = ""), "gpgv")) + asserts.true(env, pgp.is_verification_success(struct(return_code = 0, stdout = "", stderr = ""), "sqv")) + + # Non-zero return code for sqv is failure + asserts.false(env, pgp.is_verification_success(struct(return_code = 1, stdout = "", stderr = ""), "sqv")) + + # Multi-signature with gpgv: exit code 2 but GOODSIG / VALIDSIG present and no BADSIG -> success + multi_sig_stdout = """[GNUPG:] NEWSIG +[GNUPG:] GOODSIG 605C66F00D6C9793 Debian Stable Release Key +[GNUPG:] VALIDSIG A4285295FC7B1A81600062A9605C66F00D6C9793 +[GNUPG:] NEWSIG +[GNUPG:] ERRSIG 0E98404D386FA1D9 +[GNUPG:] NO_PUBKEY 0E98404D386FA1D9 +""" + asserts.true(env, pgp.is_verification_success(struct(return_code = 2, stdout = multi_sig_stdout, stderr = ""), "gpgv")) + + # Multi-signature with BADSIG -> failure + bad_sig_stdout = """[GNUPG:] NEWSIG +[GNUPG:] GOODSIG 605C66F00D6C9793 Debian Stable Release Key +[GNUPG:] BADSIG 0E98404D386FA1D9 Debian Archive Automatic Signing Key +""" + asserts.false(env, pgp.is_verification_success(struct(return_code = 1, stdout = bad_sig_stdout, stderr = ""), "gpgv")) + + # No matching key (only ERRSIG / NO_PUBKEY) -> failure + unknown_sig_stdout = """[GNUPG:] NEWSIG +[GNUPG:] ERRSIG 0E98404D386FA1D9 +[GNUPG:] NO_PUBKEY 0E98404D386FA1D9 +""" + asserts.false(env, pgp.is_verification_success(struct(return_code = 2, stdout = unknown_sig_stdout, stderr = ""), "gpgv")) + + return unittest.end(env) + +strip_pgp_armor_test = unittest.make(_strip_pgp_armor_test) +parse_release_file_test = unittest.make(_parse_release_file_test) +build_keyring_args_test = unittest.make(_build_keyring_args_test) +deb_repository_stores_gpg_keys_test = unittest.make(_deb_repository_stores_gpg_keys_test) +is_ascii_armored_test = unittest.make(_is_ascii_armored_test) +verifier_cmd_test = unittest.make(_verifier_cmd_test) +verification_success_test = unittest.make(_verification_success_test) + +def release_tests(): + strip_pgp_armor_test(name = _TEST_SUITE_PREFIX + "strip_pgp_armor") + parse_release_file_test(name = _TEST_SUITE_PREFIX + "parse_release_file") + build_keyring_args_test(name = _TEST_SUITE_PREFIX + "build_keyring_args") + deb_repository_stores_gpg_keys_test(name = _TEST_SUITE_PREFIX + "deb_repository_stores_gpg_keys") + is_ascii_armored_test(name = _TEST_SUITE_PREFIX + "is_ascii_armored") + verifier_cmd_test(name = _TEST_SUITE_PREFIX + "verifier_cmd") + verification_success_test(name = _TEST_SUITE_PREFIX + "verification_success") diff --git a/e2e/invalid_key/.bazelversion b/e2e/invalid_key/.bazelversion new file mode 120000 index 00000000..96cf9496 --- /dev/null +++ b/e2e/invalid_key/.bazelversion @@ -0,0 +1 @@ +../../.bazelversion \ No newline at end of file diff --git a/e2e/invalid_key/BUILD.bazel b/e2e/invalid_key/BUILD.bazel new file mode 100644 index 00000000..3132c64b --- /dev/null +++ b/e2e/invalid_key/BUILD.bazel @@ -0,0 +1,4 @@ +alias( + name = "invalid_key", + actual = "@bullseye//tzdata:data", +) diff --git a/e2e/invalid_key/MODULE.bazel b/e2e/invalid_key/MODULE.bazel new file mode 100644 index 00000000..aa2e1ac6 --- /dev/null +++ b/e2e/invalid_key/MODULE.bazel @@ -0,0 +1,32 @@ +bazel_dep(name = "rules_distroless", version = "0.0.0", dev_dependency = True) +local_path_override( + module_name = "rules_distroless", + path = "../..", +) + +apt = use_extension("@rules_distroless//apt:extensions.bzl", "apt") +apt.sources_list( + architectures = [ + "amd64", + ], + components = [ + "main", + ], + gpg_keys = ["//keys:invalid-key.asc"], + suites = ["bullseye"], + types = ["deb"], + uris = [ + "https://snapshot-cloudflare.debian.org/archive/debian/20240210T223313Z", + "https://snapshot.debian.org/archive/debian/20240210T223313Z", + ], +) +apt.install( + dependency_set = "bullseye", + packages = [ + "tzdata", + ], + suites = [ + "bullseye", + ], +) +use_repo(apt, "bullseye") diff --git a/e2e/invalid_key/README.md b/e2e/invalid_key/README.md new file mode 100644 index 00000000..1092d8ff --- /dev/null +++ b/e2e/invalid_key/README.md @@ -0,0 +1,5 @@ +# Invalid GPG Key Negative E2E Test + +This sub-workspace verifies that configuring `apt.sources_list` with a GPG keyring that does not contain the repository's signing key fails during build and emits a `GPG verification failed` error. + +It is executed in CI as an expected-failure build step (`! bazel build //...`). diff --git a/e2e/invalid_key/keys/BUILD.bazel b/e2e/invalid_key/keys/BUILD.bazel new file mode 100644 index 00000000..511d3585 --- /dev/null +++ b/e2e/invalid_key/keys/BUILD.bazel @@ -0,0 +1 @@ +exports_files(["invalid-key.asc"]) diff --git a/e2e/invalid_key/keys/invalid-key.asc b/e2e/invalid_key/keys/invalid-key.asc new file mode 100644 index 00000000..88c11e4a --- /dev/null +++ b/e2e/invalid_key/keys/invalid-key.asc @@ -0,0 +1,18 @@ +-----BEGIN PGP PUBLIC KEY BLOCK----- + +mQENBGqkaioBCADEAKSzLcdu/9IfDF+ob8fn6rV4VWw2+aMCht3gUGWDBgh01KDX ++yc6HiiJkSqnsODNXQjpPU+3Ztxgbc2c04chjawqMMUANzWapr7DeZBgTNIBU/q6 +plSSxwg6ZaF/vhUiYIMm7fyrIe8g0ApPgUXJMKTV18xy+NWa6Sc1Q85Aj3W0iYKJ +YtMZKiQ/ZNC6vxSOywhe2Cy2xH7BrrGpORqmh5/FLEDJw+jVT2aAlWylgRXMMVDh +6oqT+P4MWD14tSGzHLe6ZLf+G7qxKoHHnK3JX0v3DFpxOF+idYQsYf+zVEGrJFo7 +yfKyvPFAE86D4uxISHIBVzrKwFdnTvoNcj2XABEBAAG0MUR1bW15IEludmFsaWQg +S2V5IDxkdW1teS1pbnZhbGlkLWtleUBleGFtcGxlLmNvbT6JAU8EEwEKADkWIQSc +teZKrc83ZsJuIUjd+mtvSdHN1AUCaqRqKgMbLwQFCwkIBwIGFQoJCAsCBBYCAwEC +HgECF4AACgkQ3fprb0nRzdRjUggAgcnxI57XOpHZDgiNgDSvmm4wu4fZxk/Rrb17 +TP+Do4km01jYGAtZolYGWHHBK0FK/uBBzUk8H9SN+vKaVuW94p/LF1aGB3mFFiMS +Wng3caCPHd7oCN+yxyGelRO7mV95OI8L6gPjCmrBpp83Q+HBvShhqQZSNJ7jR5jc +oM7lg/ptoj4vmnR5t3VZO4WdzxWEMwvR9eq5LnxR2GVy0dUG0RgWDXOchg3TRtcU +hzQziaE+ky87txbxsOwHpTEEqUIquSR5HMFAaMJ0fmiO40eFhqmwh4Om+w9iugy4 +pmucHHxkhAG/Bos79Jb55YVref8wYXxOdGjJnWNybi1vdE30gg== +=oAfA +-----END PGP PUBLIC KEY BLOCK----- diff --git a/e2e/no_gpg_keys/.bazelversion b/e2e/no_gpg_keys/.bazelversion new file mode 120000 index 00000000..96cf9496 --- /dev/null +++ b/e2e/no_gpg_keys/.bazelversion @@ -0,0 +1 @@ +../../.bazelversion \ No newline at end of file diff --git a/e2e/no_gpg_keys/BUILD.bazel b/e2e/no_gpg_keys/BUILD.bazel new file mode 100644 index 00000000..4f3cf2ab --- /dev/null +++ b/e2e/no_gpg_keys/BUILD.bazel @@ -0,0 +1,4 @@ +alias( + name = "no_gpg_keys", + actual = "@bullseye//tzdata:data", +) diff --git a/e2e/no_gpg_keys/MODULE.bazel b/e2e/no_gpg_keys/MODULE.bazel new file mode 100644 index 00000000..36ae7d78 --- /dev/null +++ b/e2e/no_gpg_keys/MODULE.bazel @@ -0,0 +1,30 @@ +bazel_dep(name = "rules_distroless", version = "0.0.0", dev_dependency = True) +local_path_override( + module_name = "rules_distroless", + path = "../..", +) + +apt = use_extension("@rules_distroless//apt:extensions.bzl", "apt") +apt.sources_list( + architectures = [ + "amd64", + ], + components = [ + "main", + ], + suites = ["bullseye"], + types = ["deb"], + uris = [ + "https://snapshot.debian.org/archive/debian/20240901T024950Z", + ], +) +apt.install( + dependency_set = "bullseye", + packages = [ + "tzdata", + ], + suites = [ + "bullseye", + ], +) +use_repo(apt, "bullseye") diff --git a/e2e/no_gpg_keys/README.md b/e2e/no_gpg_keys/README.md new file mode 100644 index 00000000..3e4c432b --- /dev/null +++ b/e2e/no_gpg_keys/README.md @@ -0,0 +1,5 @@ +# No GPG Keys Negative E2E Test + +This sub-workspace verifies that configuring `apt.sources_list` without specifying `gpg_keys` (and without opting in to `allow_unsigned = True`) fails immediately during extension evaluation before making any network requests. + +It is executed in CI as an expected-failure build step (`! bazel build //...`). diff --git a/e2e/smoke/MODULE.bazel b/e2e/smoke/MODULE.bazel index 1117f3dc..4e431d37 100644 --- a/e2e/smoke/MODULE.bazel +++ b/e2e/smoke/MODULE.bazel @@ -22,6 +22,7 @@ apt.sources_list( "main", "contrib", ], + gpg_keys = ["//keys:debian-test-keys.asc"], suites = ["bullseye"], types = ["deb"], uris = [ @@ -35,6 +36,7 @@ apt.sources_list( "arm64", ], components = ["main"], + gpg_keys = ["//keys:debian-test-keys.asc"], suites = ["bullseye-security"], types = ["deb"], uris = ["https://snapshot-cloudflare.debian.org/archive/debian-security/20240210T223313Z"], @@ -45,11 +47,13 @@ apt.sources_list( "arm64", ], components = ["main"], + gpg_keys = ["//keys:debian-test-keys.asc"], suites = ["bullseye-updates"], types = ["deb"], uris = ["https://snapshot-cloudflare.debian.org/archive/debian/20240210T223313Z"], ) apt.sources_list( + allow_unsigned = True, architectures = [ "amd64", "arm64", diff --git a/e2e/smoke/keys/BUILD.bazel b/e2e/smoke/keys/BUILD.bazel new file mode 100644 index 00000000..e5b62dd6 --- /dev/null +++ b/e2e/smoke/keys/BUILD.bazel @@ -0,0 +1,3 @@ +exports_files([ + "debian-test-keys.asc", +]) diff --git a/e2e/smoke/keys/debian-test-keys.asc b/e2e/smoke/keys/debian-test-keys.asc new file mode 100644 index 00000000..2afa7076 --- /dev/null +++ b/e2e/smoke/keys/debian-test-keys.asc @@ -0,0 +1,769 @@ +-----BEGIN PGP PUBLIC KEY BLOCK----- + +mQINBGAEHQwBEAC7MhpIQlLicwR8tmMH0yFkMIsqIbfudnBCuV043sSSSdUT/XjA +XKdsdOCpfb6Tfiau1uY9Yb8gWLM8JxmSuaIa1jKlYiRZ5G79D7NOVIcqBrqp3lzV +HShLEXs4421f0Y4bSMuDcY/cdmRt+S+qlJvqKLwAbyejyi1i1N39UfJtK/OdZfuP +Njz8VoWPgJff7CaIYYREo4QWzAnuq65gN6DP3q33vh5OcoZgMDR+toEKYyGqhjXI +YEJU9qYz/wpglyijbFoyS3jn0oCTHpS2NwKc01vBGVZpfR+DVSgDWWQHjlrSpb9E +7bAxn2RfUZnQ6Sh3qcoihOjyI0RZ9ZYH8uQlur1JSS2n3/RxtCaV6uRtXDB5GuXj +NfqNsprZVhYYhBcX4z/4oMVim5ABkXwGNQMezrESHGq3oiIeJaBI5Oso2g/D1MIS +2W5B6NzSTqB4CaGzZ+IY30vvkxhnIG7gr4y76FzcafdJKM1cH/XlFXjnSGQ6UmA0 +E6hpXnjsQWGPL7InpDYHFVl1dH2syHOqHUmEU8CcZayb6hVygnQHh7DlhsrtnrN8 +4qEkuXfitC4Aqaq7lMflGB+ymphxBM+CC4OfiyvW2FDuzQAIWPVRwmKuKxMCRnPm +Sd+UPkyD0jm6yb1F2Fl8Y5T4lYOJJ9OfOpUz38LEqdVx0BosBn68shCwPwARAQAB +iQJOBB8BCgA4FiEEH4mYPgCB/eAY88yWc6Tye43UeTYFAmAEHQ8XDIABgOl28UpQ +ikjpyj/pvDciUsoc+WQCBwAACgkQc6Tye43UeTYUrg/+LEMuHp3zMwvR6zok7CAV +n6Wy2QNj7uNEvx7S4jmd8oMcjPZqkF5kjNso2iJs+l+6AeluoQq4b4gnCbGlarqB +Ee0BwKdHKo0eXcOzmx3XoJ7Gt4J+/iIrBANt4cXmvT6kyreq5unj4AkxQDDgeaBX +Ukkr7B0WtzZpRWyYhrHELlGEEdPSAgnIzmLYNXQT5cUrBwLawtn1IfC4SYpVfehW ++ltr+q7OlV18ggLxjsXTD4EppPGtUn9k8NYzMK6IB6NnDxT2pwCsJZzItxv9TU8m +VwchJ+NZ+EKCRgK3QfZkxEfXuZuxRdjyZp3ZYuq+1nT/7BRx1m/Skkj8/zrv/aFQ +iLi9uT3gqAG0PRZBgXbYDHGByTayZayZuW73lBV5dZyEpBEJ55DXgbnDk7rmKPDQ +itXpVvXEZVDo3xMaxu+XP/M3THz159ll3//8MgUKeQWw0wHYD9/iWSDmeo0i6XT+ +6cQU3khJv7IvoiK5S6slOa2h3RRoNbtIHhtQVGz7Q5RfoVkczOeV4jo9eiJW3Q8V +2SUhzI8WIIrEjdQJaG/gnDNM8dlO4gnvCfTQVThEtxkYEAWBreo2DfWsKwqi7ZJa +jMdpPGTIvU+pJwDY6i7zNuoHrkph1sgc8dYraX0VzjtfJYLMv0z+oTfdHkNKQ6s/ +zhCBw9V3a5w4UtIKaSKGUwiJAk4EHwEKADgWIQQfiZg+AIH94BjzzJZzpPJ7jdR5 +NgUCYAQdDxcMgAH7+r21QbXclVvZum7bFs9bsSUlxAIHAAAKCRBzpPJ7jdR5Nmn4 +EACMtvbnCpFKD+MzkF3b5ccFQLk03cC7sPzRipKsR1SoKKXV7Vcps2telPZPx88F +zjRoj3jBLtsFNELYvpFANFCLO1Nexv9a79sG8vYrhqKDLT6ecgSJDHbRl9DovAjl +VbAGsHBjbmV4J7o7F6xcXgB4t0DIObe2yU4oiCa+S4ku2p9a5ZPrKMJmbRg8EfwD +2VVfw8KCycW977JV7MuihXYjjrHugI40h76+rTbKbuZLcTBxMsi1Dfx5rpLVYZgu +kMU0N9WwBdCC+x6WBQGmOFMDy15f0cuXYTjDuiZExFaSb04e9O6p3wf2vOjfsexF +IQIy9sXJ7KLfpZoULVzoUuAWgZfKxtH3D4imJ9jeiFKbPomeLpo7vsxfZ9W8UMRf +FCKUZG5kS6HKC00ThKD8qXCOz66Ypfy6BJvvTAKr32Y8lgQNqqu7DIntjNrmAJXY +SKlE5h+B/tVD5VdszimE1tEEcgf8lA19C3iqUTIle17w0WvhJgBITE+TP2SUiw4t +fWYQ55y4oUfJi4lJVck4PuV/ELzwlZmN2A8PSgj7JmivfEQhq+ANGRpnGJ7AvmhA +OsuPfakHmsiAdeo0EOIPy5hYFxWGZcFI8xX0ywMH9Kh4hS97oZInCeOsBfWGWUrL +4NWogLYDIsdVLDxlDT+ZPnXzqlbtHhwuoniVpVWXH6sMbokCTgQfAQoAOBYhBB+J +mD4Agf3gGPPMlnOk8nuN1Hk2BQJgBB0PFwyAAYyCPe0QqoBBY54SEFrOjW4MFKRw +AgcAAAoJEHOk8nuN1Hk2QmcP/A1IBxQMUaPom/NzStJhOMibGUGgcCx306ioq3By +gu5L6Tfo5QoaJINj57Nee+0Dy2dHe9FCaMdv+Cl7cGL6egq6VyIhDyYef/edVRXa +ukzi/dUIW57704lDyudHKBy2KTbzY/WJBNOBXmRG76Q7vTxX4JOYv6whtd5ulyYn +om2KUlctOJ1sfNXg+D0QWo2XjhTkevdewME4aQEaPuJabAcfcr1LoR3Gnsw+l06h +BzuUn1kOMO37ocveGzwLshzIee2b0bhCcc2o2SH7R2xxGkAAleSeS3nXsn0qH/R+ +3juQfwKqonmqF/dMx+JhcbIvGi8TfZ0vzhC3YJGqUdK12un0wFF0c0IHR3ZnbkvP +4Fh+yThFgTxMhR3XiX27+n/ic/C1fm3pN0RnQabUHODlP0VgAVk2fwoa+rjZq+Xq +iwZe3qqfXDQrB6blF5/K9jyEaph3D9Ug7Z0wVyFJ8BBgN4+b1DaBRFt43vTOOx2u +VuRDqGjF/LuBAw97kphFK4e8xAkKfUzjygQqZRt8yFr2LvfaFyrBklEqZXDjCs2/ ++sZkS0e/EZ4T6yaUM2jPzt6MBM9A65VZE0LtvWTLQuvxpbdrwxDyOfqX9GW0RCAX +bz08y5h6EqBeBha0s5Mtdy0V4FgFNNTeTUR5GCTi+wWUkwni3aCOBPnEjHwCWYSs +uBLwiQJOBB8BCgA4FiEEH4mYPgCB/eAY88yWc6Tye43UeTYFAmAEHQ8XDIABMJkR +vqlm0GEwUwRXEbTl/xWw/YICBwAACgkQc6Tye43UeTY3wQ/+LjebzIjgcLJaFePu +VICRZdTjtyj0EEWDc3rjbYUhLH/oMMDt5wjvKaRiF5TixJdP+BqbYOaNbC1q1zSX +e3WKp7rKf3Y23A4ib6qpI8jiAG3vZRyki5yh4Upe3BsTlRHYVd4O4pWzNktv3NYw +xg0HHv6T7ZMs0oGT+ewQDbVpovWaiaaLgFPtFYrN2qPhi66J+K+QTNJdTpvWUQo1 +m92YRVlG2C7rx3Y1x2do5SM/vhRJ8Di9bMU0ZCXQGLoNedTEq/3OgjqPUUdEtcUw +f0jO/fPnaEhaqRDjtTteGNx21Iy5adM8otUw4XQmmDe7makdmYTi3LDTlOVkOyMl +nWQT4k601ySvnSmdRwUT7vOV7pqUnHPTklBwoWO99/N0DF524LW8/IobNuUyX8hk +Q70krpC7/suT7cq+l8Q45nJ1zTNnYNUdtLktB4MwQchedynsmPjGjADpqgCFF5gC +yY25RIJ/S2CBObE+z9Kx9s+CAvQyoTYVaQdwXmavybHpPmocXGJCBG0V6JAkJTpJ +DFNZM4MstcAltUH6JgNZ5YkKvDAzLBFXROvo0Se4xsEiMkhPixXqqtiITiynQIIg +Lgb9BQB9MxZ1FD1E5xC+ayMuD5W0gXGNQUNflaywJHIGTY66axrIVXPXhi6vhLWO +8YYIsewgcR/rQDc9kc5SGBvDxs+JAk4EHwEKADgWIQQfiZg+AIH94BjzzJZzpPJ7 +jdR5NgUCYAQdDxcMgAHHT2rJ6TOzBn9S8z+kWexnFbBwXwIHAAAKCRBzpPJ7jdR5 +NhsQEACf8Cwrte2o8ZoUo6GhLasJF0Jkh0d5kC7utqxK3056ykRz4QcHmacWdYzT +hZoYtsSzM9UudclTgObbRnnGFZz9X+UlEzM/D1wgQ0uDbdaYbMpNtexChRnoYugn +gzhgcZI9kzWXLSGeRR13TVoqHFTRiDkl69OCxGf002MoSYKAqwUUoaBnb+uAoDFd +pj+UoFwKqcCiDUcZ00vXtfR62f8i/+kYHjVMMrE9kksk0Q8Q+cj8K2e7znaLD2hJ +Wre2ctLUX9HON2Xi+Dnw944GtbdVMIZjoTgeTphW+eGr8B3+WHYUoO1MHMb3eezB +ZSZHKbYLgPLv3qz6dm/VHVBR0MOSJu7y2ljDIb4XAvvam0btK/JeothXWgUr+ou3 +Bjc7YXH+Q4KYgJ1ALs34PmmyTaKmT3lpbI+3qyDcvx4yEGZJLE3hE9fuOwYLvtXC +c8+wxfLpRdQ7puuFTAL97i1eHGODj/ZZDmUivp1eUzjoRUTDyuvWOMVtC7D2CHai ++yRQVtN6uCinTwCnhlq/+B+MMrlEL92kNEvoVwVkGsogTupTiUy9DySk4b8iyKsy +thnwN2zCF+GfwjEDetXJnO4kLQGc0TX01TSLp4b9mqGXKKYZyp2tFOJm3+QtD4/1 +4tpGFTZWqfLDzCNXUSXUQFTHUFcJ9guUJp653054YfJAIhl0VrRJRGViaWFuIEFy +Y2hpdmUgQXV0b21hdGljIFNpZ25pbmcgS2V5ICgxMS9idWxsc2V5ZSkgPGZ0cG1h +c3RlckBkZWJpYW4ub3JnPokCVAQTAQoAPhYhBB+JmD4Agf3gGPPMlnOk8nuN1Hk2 +BQJgBB0MAhsDBQkPCZwABQsJCAcDBRUKCQgLBRYCAwEAAh4BAheAAAoJEHOk8nuN +1Hk2o5oQALUciYUFb+EKd0pz5zDYpYTLxyzFk6d1mMVJCejG8ZiEJ5Jv6FVYMvDi +Gmku0yrIjnKe5vfPXGHOQO7WOBbge2M/VQcmQp/mkOEcvAz+2lF71dPHq7/RadJF +LmRxnvHhbDANl+lgO4LNWHEJRN7s29IJVBzrfOXAoDgVs4gKjVK5JC4qNA7be+TI +uQwyCQfWs6tmOpKaF578APfYdeao3kNZTe85ahUm6WrtVEBcQtv4TlxY0X4/5EBS +lhyNux12fvA/0/s/iB7Of+SFHbj7xZ/Ep4R1BxmX9cBFaNVUD9UQUkJLstMb0KnF +75PRcohPjGnPN6cpeNwOX3D2zAwn7mGeRxJP3ttppV031HzzI5WBiKT6jCONNuHS +6uw3yhfTD96OHOwhDG3ikmOh8jO7cqAP0Bdl1TICZ3RIMqMR/iYLFmLLrlqGI3OZ +IRMMJZe+7C8uFRHN/hX3Y2f41FC7lf+IKfTYL33x2CGzTlW0fQIz/cERkvHTIY+t +UjOvC518F/8Rq3+MAg0eoa/hQR9v7c4vFBzC7V3Ix8+A1MJq+E5aEqsy2vIBoVbM +Of5cjUy5q/bCq7HU5v/hr8gzQHArfvIYgkC/AXfWM17G3DR2fsUE+lyc2ReAneMr +/oqSl3u51ScSAHMeN6/6Le73aZ4yYwhPIS2M/KDf2wNURv/rMc0NiQIzBBABCgAd +FiEEgNFYI7f9FWH597zd3DDXwjy7q+4FAmAEHtsACgkQ3DDXwjy7q+40iQ//am8n +YLA4VOAw//lz8CMgk+Uyn5HS2t2aAdMvep5wAVPVGZZb5Wa5eoNh4Rg5GnurVvl2 +N0OXo57vD9vXHhJkooA3p/UaeVMRnilNgSWdphW1l4rRXFWCw6l8frLp0iVq4yOx +olOWTrWmpCYI+fgRrOknnaiqUS5+TH0a6RJtFJsO0x7wjPobdXhY6vfnhBIzdfnJ +/oH+EkYbXhtMNtpUT75bywtB12Bj6Y+CPbel7u9yMOwBK7R9t/56rpqF8WwExr9O +wJkmfgVkScy8SOBTv0Wv+jG9JSGZKVNqCATYnKga/QgOMuDmrIbIe+OMjgRhiSfc +zXBVWQ7Xd9DMzh5682+DEiK7cawBmpoGnJNkERR0P3uqn8vn+TYkEHpvNHQ0kISt +/9IIiI9BOX3aA26xaD3RMSldsCzq2n64Y3THwXX2hTT8FCYLSAlrdlaqVajsgAsJ +HimcbDnPVmYfq2YlBeEiRbdeeZijKO/OKmgKtSble3/7Z8JylyCIGsZzYu65ZYr3 +v5QfSRSmJYPsG/MvI1dMpiohBs9o4/JYrph6/ulgZVMaMqyWnAv7+MsBSApXPRi0 +13k1oInnO+toUvFWh2NdoARKzCQnVf/xozkhSvyAbVTM58jTZQjsAVIOUAKixeRV +7xR99VUoJYDrZKSewoE+cHkXWYPTf081wPBDdhWJAjMEEAEKAB0WIQReYbIXJl2p +gHojxf9N+rJwyqlt+gUCYAQfFwAKCRBN+rJwyqlt+oVSD/9nQjSynGhzlBF0817m +JNRH3m1eXEeWc5vbuEkMHTjphctidfhEgmC5Ay/DvJlN+HNhsLoYZb9It5vyhkPE +AM46UroQ4mcx9Sj/IuJNrUF7UBLGx9TWDx+7UQIA7/rCDnSdMfHkX1l/1KD8t7yi +sTXRiwWvIn6pEwlZQ6fUOgzy2emZU7l1UlWQI/kWFb2gmkgAb+/jStbjsIJIRaQC +WTvkasgU56vCu5oqb2/b2gUSX0MBTIboszEZxnZe1z15oX/RD/EU3zPr0w4wmN7v +dLBtqbFxbnuVhDAPJH4zRgPdTB9E/n0PeFE37OxqOlC4eQJMKrFr4yw1nn5O5HMe +nkRHnXWQHwMDSE8ZEQ5OB3BRC8J6eUz5hk0oUNepcag0h2DUDsvSes/Ogf0azipd +P3h2UCNrNqe6RXKO14JmR9028Lpps2LxOncjpoPKWw74zD10Ts3iO1IuCOc96Miv +Qtwbnu5pQhq/LyNKmXsIkMVv7oW0Ca/EuUl73UVXptwLyJJTEtFJgXibmY9NQ9aV +Ii7mJOLopR8bqYP3Esl8Uqtk/j2UsV+Tl/V4a2KgbpR0b4cmfGJA7SyrtBWRtVDS +KfzSvrZkvC9eAQdizTlcGM32r5jesNnui/HyBcRjX360gWzzMeOdEcHqRQ27qimg +Qk+PhMXfJ9thcG09Tri1Zt8rKIkCMwQQAQoAHRYhBKxTDVIPLzJp9emDE6SESQRK +rVxdBQJgBB/dAAoJEKSESQRKrVxd1WEQAKIOigIdl5WR/YqQrn7u8nXdU0ghMPNz +9xTQvbIQC6f+A5Qk1Lwu6mD3keKEKu/aQ6wN1DSu86xAKwnW1ZRzcHJd1HVjpjNI +Q2j53KmPAtMjQSlzsUz1yfp1wSai4BGa9LbobIbC3nbtndiUmbYVtvn4fGa6k2Qh +tti+TzSy3wQ3lPEe3aVD+3BWr9F0kOO5f2N2Os6iaF4ZFffn99D5qry1K0sg3IBF +fLryUVkOUokHV5W5TaKfpvM71iJU/Sua6E0XvDiD6pXksqOVG3kQNqa7AEESzPHm +2+X1XydUxFkXK41F/8z+mNOy1z5wYz3QfL9gp76IV48jjYNaIFCkq1jQOlOo7YDa +EvlKJPJ/0/eejI6mLJO/7irqYaSgYlCTe60SHLMjmx4rmYi0YEdgyEk9tnqnKvws +SYdPZdaC8Kl3VSM2lg7B6AFjD4NCvrBcbKgZBNx/NrUg5i88lHFmK3ErGyBSFNoL +VbEsaEzUm2Wml/S58XOlxB7vKSnVL26WfedqF/W/6jihABb0EN6I8Hraa7/V59dV +iKa1EmvEz64/C1J2nAb7cnNAPPnkdgwqrsBMcP6GXPpwOSA9U1tcHSFJfxuMuAY6 +nWns2e3cC6FpTHR9Tnnp+wpv53Nd0CYdo6jYngPPaPRvQSZo2PcYNF54lq8UaowZ +vm+emPRqJ59AiQIzBBABCgAdFiEEgOl28UpQikjpyj/pvDciUsoc+WQFAmAEIpMA +CgkQvDciUsoc+WQW0g//TDVm35jty3V7Dmql9P2ioDIbsTGb1RTGdIr1p4gLZTyA +9jbJyVpEjyUwWHa/DbAWAOLYkuPjujFH80r439kKYvcbwNcA6I3P8nvdYIkgpxT6 +AyF8YA2lLWB6MWQy93Bm0R2fk7J7O1I7/uvBLjs3pbklhSyQsDSaPD9VE5jJ9zYw +FdYkSEqcOrC5XKqt9pp9e1y+QVTWViXvOch9l5NanA7fMEpO56xue0EYRnXcxfov +o0/unBuUcFJ7zwYmFTAicKlBWmErRcV3n8DcTbTF51ZyMHtkq30K/ZQb/f9LVSN8 +1Om9gspAzRpUP/XB3IY6cnbpbIcxdgAphm8O8bhMjCztjfPK9zcwhmzAprW6f5S+ +vfl5ndGBhNkAcFdEJsODVVPYQNR+nxfUjfyZTl3/lEEpdhagkjkw2DPStpStGKDW +wNnmGs1RMNOKCZtnKI1s+oeBFxxnUFQ+/DYcjWz+t27QIAZNx2vGbND0JIjGebf2 +WFFpDXjqF7xaa0mRfCUtu7jyuNAAj3eg+fARserqRugyoHsu2QlGI24HGyHQO02e +ne6l7+n5Y3M3FtgsLRjPlKUP8gUO9xW3Bpi1+pnaSzbM85pK6dooH7tj6OF9pNXc +SMf1Fq0l1Fw/gEt+H3bX51i2eJkQfGcx3Fr+90ibVYsStFh/uXs6bH40M5q8kxyJ +AlUEEgEKAD8WIQT7+r21QbXclVvZum7bFs9bsSUlxAUCYAQyziEaaHR0cDovL2dw +Zy5nYW5uZWZmLmRlL3BvbGljeS50eHQACgkQ2xbPW7ElJcSndxAAiZFxjtM3OalP +J/VI8yF16lNHrHR1KMpSt9azMRMRvEx2B1LkNCxCFL+ZiIY4SgXdG8pt4nRNRUwO +h+mbPIxjTi6BU6jJbNEV/x0aZHMvthPXqzY5T3ZcfYxvvAm2PiOE/T37Vj5OAlkm +uEhBi9TA88wpjFiMzNvkhXxnjiezviAStsjADjqxJ8cipX4cTcoqt9A+ftdEp8Hk +qMWewMBLkRWizDFW7uXCFXGcLvi6FnXAOvi4CU6g/VUkDhExrqA0rRNXdmTJRNDC +WEGH9i/2vafMHziEpBWDCLESSxpjt2X0YAEWr/NSWRfiygVkl23mC+Cgs8N5QUUb +/w9BeO0kagaelCak28aHvfJRsdD7qObDlQdhWRWqXZlemEcHGyaMsVsZRDArPxe3 +y6OSeyR3c/cET/KalAsYhC7LL5YSjeVL8D7fgSpMahnmB09nmMztWFQ0XXMnvhBR +ZZfwM+GDeIxNhVUb+R1hgCibc/aMLZvzZXqF/urupWVAycVzqTD3vi5zrYFEZ0C6 +q+YzcHENHN0t2HyNlGFobiTmv0DQiuAu3Wcpor3zFAwaHIbZiq6jhesJOq4vAjVT +dVoYY/NhwSSe2EdaFuaDTh1CNnk0tpAKP/SxQ+3Odn7xQZ0wlKl4vFl3EiFv+dD+ +q0M2KlEjaoj/d8kunKPnO+A/kS1ene65Ag0EYAQdDAEQALxyG4hn47Yqk8SKE03a +vuNFlLP0NFWg149k7csVIDRZNygicf+6RSCZHSr6ep3gYIX/f8xsmqSyckznIerA +gCRmr5TDqs7SsGOIyMetOHol+soiJqggunmX6clkVFT2KAOecq/3A6uw4M3JNlvG +XeSRtsMlSHTdS0wK2m3n++VVr9tZ//NFlmnSnnAOAazomM3Od74Ne6fD9xRfFF9O +l4NS29oXqwJS5NpsCU0nfoxEEADFRVBmLiGFTbMN0LtBLzciznTsGvKsZNdBAafE +aNgW6RFYY+eTdlgQbdILwXuU7TE+n+AUhVaWsV0ldCjNlFdUhTde1ldTBfycpBF9 +8hzdV1KguE3vpJW6xmPSrXgtHrBzFHMpMEBP59J5cRsoD4kJU7IdhGGnKqZGVmoX +XZOqYDXs8iJ74PKye5jk96ooNHO6etX0lLrb7HMVJIRXkPiv3Oj04QDEZcxrxnqZ +0Su2m8S5/SLK37W4Rnp/KTWaifUPI0xyEEfssz/i/fdXta+XvoaMSH4zHzaXQnVY +QDoN9CH312k0N+PYSDlxSVMinBn2Lh1JTghRDl+Ww8GplcOSoO8k8hRPeqbXMnCw +fpXrU7GOPkMv7K98pAZx47bohgVNA+SGY83eUFlmQ7MdhIiWu1deLJT8jQoFz2aN +eW3DxgN1Ltqxh8e9ABDvYTdNABEBAAGJBHIEGAEKACYWIQQfiZg+AIH94BjzzJZz +pPJ7jdR5NgUCYAQdDAIbAgUJDwmcAAJACRBzpPJ7jdR5NsF0IAQZAQoAHRYhBKcj +aIbzzMqtFIon+A6YQE04b6HZBQJgBB0MAAoJEA6YQE04b6HZbYQQALP5Em7+PaMd +nhtyeGEX7pISquoZOuBA4RV5oWkJtCjYjtWq85/dDRoo17EzIkxhJCUypnELwavd +PVOrKmDNv36mrdtdkOe8xsm+ITN4w0EbMif+SByvXtTEv0u9CBYfeq4EKCig1YcC +glUPaTJsmSLZUv/k+d+dQht9FQaEUk9ZSYjpYdU1gZOsfzVY3FMwLpUlGtg6JoQM +ObpxsW9uNSYUbEDl8mFfc1odz+lFw3mhU7Nov8IW1QNMrg8Yu6hY4yQkxw8A7bs+ +JBz8XKVQXMP/0Zb5NROuISI/btPDkmQfU6ruD91cPVXXGy9PluV5+E9g7Cs/RlaM +8TmAp0NAWKQixnPHoOwfRmuqYTc0WWuyZSaQdE5z0nPKB9Wc9nGUdZhXooqHADrm +6TXFk/4w2xEkKKneGXHHBCaKhPjQRpwcKm6wVJ0gSmr9X9FLCjrHu+K5Fry5UkX+ +pWVsbdL2gIyKK5FtNx0ujuAlZxE94PStQUC74rZ2s/ac6QqbD3FKEW1jcVe1KPMH +q/6+JzaSN7isIi+s6jsXg7K/sYMh5J0h6heMpZhoIuMGqQ93doyA9rRa47wLB4g2 +h1c2hx2uLK1VS4SJ9+0yvkNoNJSYGzFoMc0UnBVqP1p03sSBxwd6F9cs3bvOE3jX +XslUBcmyzFP971eKI5Kc7MwbfbM4kFoWWOAP/27m7zRuZSrAkFD2UCabCUWbEQwp +4vafcYjsdJFuennaLhqybQe41P5IXvcJwvDIjzJXfgrq3IyBrWNI+fZzCo3I7XeW +Ldm3McXP0Q9X/UmMHuZ0aBqc26OHvFH5f2od/hwc3G9sB66sB4/rfWBOHMWJHTkN +nzNMljTK7kPC9YT7n4DYVrdPTacvXrh2MkHGz1hEgznlW3VzF1Mk4qYBkWeIpcdX +wHDfHXDYWIVXWtrEiqBMjLDH8Bpx5nee98KvFQpTzMbU9lE1rInSskw7+iGRONEB +XcGs3fRJB8NvALsYMp0MU7hx3wQWmX9q58mb4qXvypFn+IqTOuN1AVCqSVEDn+gc +dehCG8vkjOIKMANfKEqRrbQmY7CJtI4BxkJwtUCTVPaRDVdW3RTv4K8K8KAM+hVz +7rnFYTONiO51yPCCuVHSQ9ivZv5GohbyDO5nNTve1no6Fzl5l/CSpb5XCvOcGMvg +MWP22nlLGoSNG4g3TWlUabxrXmPEANG7D+qEhhuebeFC6OpX2i1JgYEpUgoTFtFC +96299K38JSWRK/x0FPigzxvUkxVt7rG3APIPJlYQhYRq2rmDA4zRQL/ZDtFF9+QH +IIvMDlYYZCLKlxoEjYlCusJLiwHiO5uiHDiLRA1vu1qeJVJ8o435g/gRLJALZojZ +1UKhwK2BVhqTmCWbmQINBGAEHLABEACob9fgQVEt9lqNWKPyzMdenmg+sIE+1ZXw +Un6QzJhGedE42FY6ov6NAzYh08DOPYZsxpU7C5vX9nuM2Fp1tKgGXIfQZmc6EpLs +YmPsKpAFOHfKs1SLbcwgc9pgLvJ6ZvUS/c2T2SHxMStHyFlJbMkLd8B/DQSx8XaI +vjlHWiTiLv/+UuAfd4yQeatMyPvhnVLuUf5Utgdvl5Twwm47IxUMX9426VKg19/2 +2uJyWN0kfI0uLy7hg1cHArR5JOoiPRf1xR4ZF3zgu4gwCDD1Puv8iJuWM2U0DQDP +KOuH2DdasezHiGCVrQ9LWijTZvpyT/fg1qaY3w/1gx8QK6TpsFL3Fwxopx2VrD7e +2+FX3mmxfqhJGlAAfG0gOpie6t2WH6dfcubWCt8hjY2gN+NT24gotDqk6Uz3TgLD +G439+A6Tazji2shvQp74iTpVjyiBsdjF8ZbLBX1mGFLjniuZxuzOk/skUaInZ6g4 +SGw2qy8f0uBbdPxeIuNe8QLxEotXt5YCh265BDp6QpnHh5qfFc3IqwBA0hjkgvuz +H+uNm1lA2dlKscPsqntw2c2epN4w/H8VZYlv80KBEHx7vaneoVMxQkYDTNA2pJJJ +vWO1fKnIlpPMu4HWeAeiFOYnju5/Vdz4JuBmOQ9ATiHfZDBuC35IWzU1r/Tq6LoP +IqKm13xJawARAQABiQJOBB8BCgA4FiEErFMNUg8vMmn16YMTpIRJBEqtXF0FAmAE +HLUXDIABgOl28UpQikjpyj/pvDciUsoc+WQCBwAACgkQpIRJBEqtXF1npA//RSkQ +vkVQqOtQdoZliUKFR2w1RZrH7BXRMDudrjOcJ44GNuhrwPndnDYXEmEmIKKXamT3 +0BwDiD9sn4Xmwr6r8YkO0lE9vvL6vvP385P7mdDmd0uqH9jm8fxQelOwuf/8IAFo +hthBi6ajfsPUTgGncGXqAUvExlShhXZK/rq+3lWFy+hhyxKC0nrEMGskiATUY2Hy +Qoiy47BheAWQs5IsQfc43QS/C0ySgrNsm8KENlUcAAntRdutL1JV8ORlpgRUvGka +fT5vKN5tT07BpPh6ry3cwSEpMaQQmq5CT57hf92k5A2idEh/u1YDNGnIrRRTLIrR +wRucSoVfgrxpHbFgq9p5bL6RkjpIm1L5ytS6gFF0Bt+/QuIt82MCfTjCykavI4Yf +O6qkewA/4aoEecJ0z0QAflg8sJcpEFTiRtnMTRvFqfjYQcMTgZDBS7zaFgsZbqc/ +coOf/uozBzBqob8vPBDeiSC4Hp/a/Gy5vw+ADJgQ5OAwcp68KdBN5EmSU1S+xqyK +EtKAr3CKin/+e0kqyV+2jaR+jBcPveZK89MEpEMxIsGIeSZh4OYkc7bS7iPO+Eua +fmek5uSbhlpejUBy2gOAj+W7HK2mpte8rWWEueVaAOj+bFd5VNgt2s7LS3D6jy3n +zp4eAl9PI+K4Yaiyy4P2GVIyRESj2n4OlBdVMoyJAk4EHwEKADgWIQSsUw1SDy8y +afXpgxOkhEkESq1cXQUCYAQctRcMgAH7+r21QbXclVvZum7bFs9bsSUlxAIHAAAK +CRCkhEkESq1cXRDGD/0bkA471LRZzYURNP3oAITwEy/6NKcVY3EAPe6gQVMtOI03 +qQU8nSLG50yNHlLETfN7zDFOWUAbgNqnss7fP3HUsrZ/XUbuathnkTQyVcmQfGYO +jTXQI21YsUmwXUsbm8AHCKToxBpIe+Z0nSlqjJJg60GK0d2g19IgE4kji4575BUC +FDUypkYNh5v6/0zZ4vriomRfeHmZ9ne+XkQ0kujjpvpy6LIhb7a3ckC/X5QrjGsp +yPeQN8oYfZZrvyo5JmbOI7XgiCmNTGIJP7C0l0UEMufkmCvoetbhlj6pUWJBsCHG +bZgVYuD8hWmLoAUzp5EjWjMVERpHncI3TPevlwqZczUoDYsIKGMqrowzZj88PdWH +Wlyq6dvXTMlCUufFZzPDsCjC6vPxhKdwUq0Nj3oV4HXfEHydC3XHmaFv3oglLGSq +Q9VuCnzvpNnH0MRIFxBKFUR5J8rBjNXDNN3UtXkf927e/l7JyYIJ5XaHUzlTK53F +EZRPeeJckyEd6NIrrm/BC73/3mMuAQZ4033PeY3qD+uZNWp8Epfs6idRJstkGzK8 +tlOyfT3L/MkcBYXBVEiyH7MUy2SbEjTgC40FtrmGP0YpmZ4MPj7pUymFps/eLRQB +ACnHum12k2fxxbyO80DWge8oMRHQMBr+TnFgGV18HmjYcq14LhchnhYC1eE0IokC +TgQfAQoAOBYhBKxTDVIPLzJp9emDE6SESQRKrVxdBQJgBBy1FwyAAYyCPe0QqoBB +Y54SEFrOjW4MFKRwAgcAAAoJEKSESQRKrVxdfBUP/RAFKP+TbfOLzFeK9oNDABJI +ztB1xXXoqMyPUoLqqv1AEdgtu1qvvkPiaqBLYCHmA/sm7A9+p4lxnlYC38ahxMJh +cZ/QXhaQaEOU336WfsNcu4Ir/4ST3hUwsFtxluSEd89/IfFiIs53ZpTtrH88nxJK +oXa+U84WT6xP9OHW5nvvH5bLveQCpDZCkW/Q2RkbHMnlPaXHAe7nLS8S2Lgy4St3 +ldVZzKDC/zhBVnWaUPuFGmDQnImzwpklFnAXFYTRJ6CX2nDw02Vu20NA+V3b64V0 +BIdgb0Ylkit5R2hN5gmXUCXdftzv302szwhMF47NqPZ4T14kSwLh7LtDiYioDJxm +nYvG1hxCu/cA1UeDxtTxA6tksz+QM8g+bN8ULTDfoNUX2ZFTyk+eF+J5calR6A06 +mxmHGOfc/dbEy4r+ztmSTnrfaPhCiHSBvCYtU7Q7GCa5EKVw9FtUJhY7oNrr15AQ +FrK5EJN3nIxZxHQDocAv7e77jBGzUsh3r0DVOJlHX7Vjh3VcmgEh5P0vb3vZGFOg +SdL9mZ/kuZAdJv8zJlSlShBT+P0zTicl7EGzLSx/sZtGi98TrOIqrqgBEPIJn3Qo +kiIxVSeGfQtz9nrvkV7uvUMe5ABRu6mxNzc6JHtA7VZNMLFhp5imBKneMq5qksmT +Xkpb9bw7IoEPB1ddpBFXiQJOBB8BCgA4FiEErFMNUg8vMmn16YMTpIRJBEqtXF0F +AmAEHLUXDIABMJkRvqlm0GEwUwRXEbTl/xWw/YICBwAACgkQpIRJBEqtXF2LAQ// +dC9eL4nDDmW2YRZExS5cgbMCYTeGkCUrMcL75px8HaNASxAWyUGxouT6XbiyCvIZ +RmyAEsLYOm1txIVyddnHvH7v9HwRh08ystodyXqXTPnluHppVelQPIG071LLpyM1 +VM8qwrT3twdP7zXHWRzPwbUO2C8U9Fu6wiZCZb4Zcooldqj79487XKjPKws7f3gd +kVYR7U3rwrfd0By3QSMlyh8aWe3YehU/zZ6MdxFIrAkHF0a9mrDRINy6BOtEc0Th +Bk5n/q8f7zxqf3Now9M8luok+eoVjXcAjrqHIY7rZ3TbCzV9e5OFoGHlsL1Wieqx +pZMmbS0UN2HGTyB/MpAJkYh1cB1nLNVOUnlOwjdM0PoKpdxtfUK3mtOuoB0TTCWw +hi1FBI6oDYvbuMH4HOuvFqhGMiYmXC6Ln/eCVimWsnd0PsvrfomvJEZ2lFZzKw8Q +DOT4Z8xnopcVwuMq+JbAyVRCsXpqloybMntB4SRQ/JwMf9+evnVh7hQWg6B32FhA +joOBRJTX6DxXYB8nqDVTh1iRUP3jO75rOiiYzgsfjDcDVO8+a4Cd8lySNvjMvpyK +kjNs9pymkuTJwW1iWteZw71pdjRIUSd3o/7zOX08+saPakU/FT5E9xYANR4ZxR+i +SHckgYJbiVYvrlE6LyZ7Ycty/fhhnLJ/92sDCj6wHkyJAk4EHwEKADgWIQSsUw1S +Dy8yafXpgxOkhEkESq1cXQUCYAQctRcMgAHHT2rJ6TOzBn9S8z+kWexnFbBwXwIH +AAAKCRCkhEkESq1cXaYeD/4mxXBxPtjNaet+/3FvwO8h4G6nUuN5PqciXdeOpXKJ +WX+Rb4MZ0GhUxpievAW0JCZHzqFKTUfAEWuhQOYkTFAxINA6G48bdFtyDmAYiRGr +GKglPcYWKEF9EjDfrDhL0a5Adbg6ICtA21e8Y/VVSkl5uHFsjwPgjWmYKyvSw45s +UT99Iv8JztkbbJVVoPSq55rXFasiDSN6RdsDX10ZNBA6ci6uSq3low3bKaNjkTHH +rahat47MGh9YdCdmHvWPI44FlvJNGb9UGFG3I3pKSxQbntS2Vb6WGeXrA1hCMksn +ApoWIkBHytTBOSUnowrCXh2aY+w2PxWZGs6RJTsX/41rpWyS9LmOEf+rtes6vPk9 +D3mGbkv/puRZli2RlPwqsSi4nHegb7ajtbLuOFUHXGi8LSFVYvD/8YxrS02pwsrX +lub6v/HffyFMg4rXzKsPaWv+Q54seXjIw1K1kaNdPTDC3sTuKKr8zzumDGrWYxOL +mtzOwBy4XiQ0RJ9NlsJlNBcyY7P6cSX1pJumrTZMD5cmOCHf+qYHRkWIjfdgB20k +x/vBgutDpP8AQ5dA8kt1RjCGCRLfU9UEOytT8Hf4Kp7SK83Oi9E6Auex8vMMSczP +GrWSkmeUxPJxuE4+5KYTRkcJMl4WKEmQAae0ni0WskXeO/3YujWC7n3ho6+UNoyL +XLRSRGViaWFuIFNlY3VyaXR5IEFyY2hpdmUgQXV0b21hdGljIFNpZ25pbmcgS2V5 +ICgxMS9idWxsc2V5ZSkgPGZ0cG1hc3RlckBkZWJpYW4ub3JnPokCVAQTAQoAPhYh +BKxTDVIPLzJp9emDE6SESQRKrVxdBQJgBBywAhsDBQkPCZwABQsJCAcDBRUKCQgL +BRYCAwEAAh4BAheAAAoJEKSESQRKrVxdiXQP/383ukp2BKlwoMBJacl3CV6wB2iu +i8BA19MOmlxQd3f/V7/3sQBf+4J8H+SUFjJS4x3xBCOGn8u4k08BLTDEMr0ec8ed +EmhR2v/eMTzU0R2t5N7VWnapPf0H6vQbR3njwwmf7Xh6V+UiLUQIgb2ORq+35rg+ +I2pDgPUfKv++4jTzi+V3Xupb2ZB9iWPC1uRCmEOzpXb9DSDzANHnw2QbJ8a2KGMD +3DHTuxV2uprQA01LIvRQrPQw7j6uDrIGjujwxMS8ut0mi7nDohiCgNwvujuzH9Ye +L40xLBqmJrB4UnHV2ZT4uQKH07jOs/N38+BH1Bl4qtSgyGmbUkN+P6MP73CWWHtW +sJG2yG4WfRHteNkzWi4MqBTQJlQm1l1/JdvbRdw7NIvbDSAYbVy7dhHmWFiR70FY +6xHmlmUWA3QyrdP6Fu6DvxZjxCPCui3Mp2qzt18Zb0Ktz22tw2Gip1TI5bfqK2e5 +NcUWylNfsoo7J4i+MK1/zXbKjGNkB8WiNHpc2VZ64njshuBWxuL4oibgUTi2aAD4 +rNVRfRtchq7ZdGnzHqB9FyflAohS03npF2Va4tjx+mzRi7b/QekpdG6gREu5r+29 +m5togJKG28821PidDZdH+dd8cotFlNgBMBu/zbOuuk/jPZb9GBLafC/jsR4hkIwH +Rh2mr+pnrFWxYkfaiQIzBBABCgAdFiEEgNFYI7f9FWH597zd3DDXwjy7q+4FAmAE +HvEACgkQ3DDXwjy7q+7vFRAAoFGxubvIG1tmdrL3u6bzVs4DaCd6yomZru3EgZB0 +oJheNH1Howqai7LWkff4qzDbaz4CGFWXup5aXya2IBbX8CESUDI444aHC185bQfW +ITqFd84Dhj2isf8G6GwxwrbBQcG3LoVDepArzyBidmeB4QtpaE+lWX5TzLwzUEpF +cxzvlsfTDtwiWe7jhuZ+dWLbva3xRHoeXRgDrPVakwZOJ2cvTatgfPJt1EoEGmYk +OlL26luFVtaY7vAOaJQxraqAyiOMbefEgKQmbvbwKc6lF4IQWyZoKillzofdlrKH +Ajo7jsranOCy4NiZz6jXsWc9WoBQBXu0uidVmSTwOum8LQGDo8v+e+2A1yMAz6UI +FBwNw3FFwwZNsscwZfjo1EZQt0xcL5B0Ufr5pibclfVnBFUPt8c1yxjnULQKL4fv +Jgk07Tk1hqlTwq/qpzgDkJJPWK8j7h0RB4qfsQW+hF94QZJtEQy9pL1UjNj6k3ng +jB/OXqc+cV7p4wRPtiqp8BqQPJLsnvbdcS1SUDdML9YafU3J3vj8yRtWqkcQ1gFN +CaynzEwZc39IuRweSbpYkfucj70m+9BXMO/wXdgh1GjBmavciFCTefEEHdpprAnM +dy27Ps0r0Xidv6wvX9XX2cZbISj51y59bM1+NKYmOzNthFl7VE9SxcwrmL4s5Hsm +ExWJAjMEEAEKAB0WIQQfiZg+AIH94BjzzJZzpPJ7jdR5NgUCYAQfrgAKCRBzpPJ7 +jdR5NrkrD/9aw4QPW2rnetBXRacMQ1VC9GKwZRJgW/5BvpWhtgEWnekxB9KLMmeD +JIau/E86hhl4rnt8cPZbtiZEAi/pl8nRV3r6aL9M2Umv/7wxbkX7mdLJCYUuyJa5 +lHd6uEDV6t2FCSC6wHV4DAnKfodIFgwS+Vq5l6+v2Y/1k+2d/oplTRE/3xW4Ae4D +5hNE4MGLUGrb+PgBlaxLTf560zDyxyy77LjPUbm/a7Ud6cpMCI2nF7kZm9l6IU0l +MsxTn+tFLgcxn24Q0LASHUvN1YbhTax6OX3FBNRNhzYDKiQX5o/6Qwq3kms3Mam3 +gLLZ2ntcX+jg1bLfXeCEN/YAVDGT3dTKYhFblHzUfF0QltnklkrI7kOJ1gzGY8xn +rTWdUCfPbzzJqdREcrEYro9BW/QKbwELKsUIpN1lj6U/P7BmQuaU/W2UQY5ll6Xl +SOsRHfz0mOnYMNdsE6Cqr6hQLRrhiK3c5r33lJXs78pHKvgfREGOkwGOwQ8zzHd8 +43S2xC+4nROOV/EbQ7b1BzchsJbkcNMpTBKaXMY1wMJZFuy6raP3QO518OjYkIam +pPdpLBvHia+hsLkO12A7eS134Swlrg0YLTETyeRQqURLYzyghKtRVTwhZFaQKKzP +p4Jp+qkc2SDhXqNZqYT20FhxLBH2Bz5oNzaVw0WfEjw6NrjW3RKazokCMwQQAQoA +HRYhBF5hshcmXamAeiPF/036snDKqW36BQJgBB8HAAoJEE36snDKqW36VYkP/1EU +lC8KnR/dj583OI7EVgz7ezIOi2HKeNTFrnxPIpQfnfnaJZgFzfYkpo/0kPlLdQvW +vqao5xKChtVmePX6ZPWnSlMQJvlv7879EpakYbHWhGibTBR4FHDrEVuJ77s9uOaA +5q29fnAwYfvLkwHPijgJWbYblTpctFQCswqzBKXHQ/AvTDUj2II0BFUAeeBTrMX4 +Lysq1auKO6lvlBhvt1/XYFSpN0b336+7vCEmqTru6zQHx2ctjS1POWYMvD3rjPet +S9luQ/00lp+gzpAhX1yb877YSTX2k5F/lW0NO7+EpqzE9j/9D8XtyaMFh9WnFKlk +Ns0lnT4HrptNsNvyM9gx4NJZQ74E/o+DXzYI+zrrhqkljrg2GnTqSDcHc5kUak1V +FNjDOHHTkSH/J9szNG6BvdhsbSow70+gh1vT/8G7b5nNG2TVEaNP+DHNBbJ22GdC +Oh6TZX6LfdeodbIaJTSvPdqOVCWt1XjzpHihGiggJWQncp5fJ3SQFpk93exw344m +Ye6/YZNh4TrC1EgufGruUVOVzt5TZRqekmhxLCg9ZfI5MG8mRnK3Ecqf7PiIAFcm +ZHbJvmIUBzgVL4KWmE3vBGeg4C8v4lYlmvf1IQLhtA7YBnPg+3ZhZYJQWVB6l9rU +jvFlYwkv1ACSmsxU5Bc/2zLZZJ15KawtClrADrHJiQIzBBABCgAdFiEEgOl28UpQ +ikjpyj/pvDciUsoc+WQFAmAEIqIACgkQvDciUsoc+WSJ9A//VO7mREA0FDDTx4IU +XET7AB71wHBRY+yNtF8zgllXXqiOobVoHSCjZKMYjFhe5qKv3n1/kR0AxxbPWBBw +futKFFoiRgt+SSB3iuaWxJ6jm6znBZUn9ys1t+Y1xydKLDHdoYyHhtg6vrQhs/gK +wBMX/ccGVxD4h2eljbp66YTSByoSRGjs4efeYemelIsgrwP/Ap3iNrYdPjh/uBP3 +XTNQEkDqHzyVTFeMFIkvonNQQsAEgl3QcP+MWq+KBBozjqtgDAoiF0JAaVArayKW ++eExDBUZXr+y7DS5v2nulAfQiZzVB4q39mMfYCoj6mCyLBZsx6Xosg8K0rh46PuQ +b/0TasrYV44bjRF9SBVaOBW8eqWRc66y6OHUX1a5KkOxsDt03gHKYWC+NBfeck37 +xbL9J6d5QsA0yNdbCYvfKqp7i6mLPaa+u+2zBk1Pp9aNgbWzx5CFZxRjqUFf/drx +ao+9jVKzn+cE9XtKouzy19OShdZe3SyLFTvXLdQj7emJN/JUIUgo8BrJYNzsAOo+ +UVCbliVr0dU0i1JQOf7k8iNdNWOYcUZq8sCRbQ9IJnnfVVX4OqRFhM7yzxyGFBEz +FGu0h+hc+sDK9zK1jl99oX49V+RSvCdic0P1EIA63f8doHuUysIigiTyaQkXMfJG +oR9uKm1F4+7hd/xfi5lXJuez5lOJAlUEEgEKAD8WIQT7+r21QbXclVvZum7bFs9b +sSUlxAUCYAQy6yEaaHR0cDovL2dwZy5nYW5uZWZmLmRlL3BvbGljeS50eHQACgkQ +2xbPW7ElJcR0ZxAAn/yWrs1CCw7plbiHCLqv/fk61wuXTFAjqiF77CXvekZulGjr +7eN96LeXkrPCJIai7rJ2D7x2g1wXUiWZMWKh8M71tVzgY4UV8/+eEJFV8Gqmdrxm +enaQFqvuAV6y/HV7cJw1EQCpsWC3sujjWUvOmc+rBrBhkfueLP5EqdMJ+wyaX5j1 +iT2SsxcMNb6rPLlfSTafv2yqvnGhIFL+ZD916ke0tPpzUemjb2SrrTqj7l147pMv +72H2KxR1wXjGgqQMjoOys5bgTBbyzTUFDCbJc8o5c/HfeUnFDfTEvPzoxLL20mnQ +/Mq1j6Za/LcEdJe0liVDzDSI3ng43huZLNOkT5LVLyNqedJ4M1bSI2/TSyTpHOTJ +VWSAUpH7706e2JomPWvKpwYU45WycXveviEfGaMWFxZpInzSWVZ2I0n8sH595sir +FaEUF0vb7PYddh3OsTa/UwsccIQnxgzNqy+o/SqlHwR9nSMkvg6V3T0f4mvqRfiJ +fqtiMhqnxMpe124s9M7II8ACu1fjYf6j0rcwlhreD0r598oOqjmdiIAXRtRtVbW9 +YSLd+G563RAcoSBgs4Xu7557i107UPYOKQbpuGzFhymtK1wBik8DilvkFrc51BGk +UNjKq5eUZHrUFHjYdVXXJW+6JHzECm8qCywz7cwVNBhNzCD9RkyK/hlKh3y5Ag0E +YAQcsAEQAOvMWEKqTinNyE7ii0xbHFEegMhYAkSdHm6kVDcDBu51I/rz6Yww94xv +vTs819oLxPp1GCEwblnry3mD4NZ3vSeefzvK86BFX16tRUmAUP4qgE3PUKNFEWC3 +8toGKFKOAqpEw9TCoCKzyTAQ7qj64jtweIW20KHJ8FpZL9JkoImZSLp2AVA7gmJl ++aUWVAJ6TBBmmGGWBl5St33nYXvlmoOC1CBWcW8qG0wGRh81ftQg0/klzGQElTWy +U4CuPAhCnwYKccnOcOVPjcdp+rgvvJwc02/qX1WI3ZPJFOqr75il99cqreoSEmO6 +hJEL7GUUGcANoqqWUTe4SIYi3R97aqlOF9OyS9+o0Bufl0c9TZYDaRTJrIVs4D2j +xJ2gaN49kztAifENYfS+wzE64YtbgNOlR4XvERs3D+08vwigqATeyApfxRs/VH7g +/G3LVcIBIYJCHdnST/AglTcAQ7iWvwLlhFJ2aSYH0rpMVjBmSlTJmvqKHLI6wLnC +22c5vATnNYzO0Sh9Nokz6nfUUjNJruZkbIIYC1Ohu+8aEuDLThirvwDR03VIWDeF +3BhFQdkdKfkfZtzAY8Lr7rWGxb3HpbR+slekC6dzclLj2g6be48zsE6Az2ek//mV +1farAPejpmA2vC9B5indR9XKNntCKuFU2KRHCShhsw9xfQUIcOpLABEBAAGJBHIE +GAEKACYWIQSsUw1SDy8yafXpgxOkhEkESq1cXQUCYAQcsAIbAgUJDwmcAAJACRCk +hEkESq1cXcF0IAQZAQoAHRYhBO1UExKjPxEo8QscbFRAR2K7tuhTBQJgBBywAAoJ +EFRAR2K7tuhT5OAP/0oBtjjVGeU9BNWczY+/gxEhbBuoBG6+/d0M60fk6npZq2yc +cAIwbcJzh6pOBPPjbA0imRC38Fz2sZotO+Rt2eELT0QEcKDOlvhH/syj4R9+bDuI +ax22A9QtLnBpICrBKt4LazuOC4LzYqScYZmoO4EWXNOZICO7lggL43ScLNerpE6Z +j5nGHO+74wrIY93HUdoRROvtzdRO6n8+GU6XW12JacdeK/wk9hbD4Qqa5HOtNTxO +D4ZjLPS0QuGdUy2fCOfuUgYc55aCf6YJqysr/nX8188AyAKkPBd5TQ8QE2nOK+1B +JC+/gitE4oSpP/oYWjxbfxJcviZUooNImD9cNV6cLrHF+vc4MMDzFqAQlWIuACka +A6as3sA5Ev6wdJyfTtF7RhI8B/V7HGGp0QUwhNy9HCvaVOq23cydK24V2zEjv1Qh +8ak7yNggTviPQo73eVFoh2VIrW6GjTDyrkxRR1Fswh8IotRGvfl9+h8FNn+3bobI +btURIAxzzngjOMIABG4+dLq+PHorctCSAXEf4F6qKgBSnHKcFRpusQjtzNdqRanf +wA0p9lnN+8tLR4Dx1UuvQnbglg4eTy5pVvoTR37jVB/PhNnfVipn+aH4FsizShjI +365Dvn9JRNQNYOHdyu2qAHBoSwldPTlTb6w9Wp7ONoXc7nC28mCQpV2FPhWdpiUP +/1OJFCuVGxHrMc2YBPdiMOajZmu5pqG2Gyt8jOqbyLVXH2Q5J9gRZcfEUd0EF7ZW +a7/gjxsHkSldaOD4TqFL4WB+MH2+WQu+kXo6unCy0HF66LNa3LY4rELiukt22q5X +BwDlaZ8DPM0oTEtieVXGsB6gGMDdktRRFF/um3jyht54zEv8MAXvwQeIMNVxPHBM +4d1pSJq37tPZE2vfbPjHr9zzm2wKNSymR5+CXueXkphYG+dZ5qmkWnvs6kYyBNZP +oxMu4ik4EKYt8sIC2HvvfdhUhax58gjSWMJART20eNFIim7cLBRpmo1+tH40M26K +Bhzvuh4EPX7WYUge7wXqqSIgko9C0FZCTJBqKik4zMtZO+2k3fjbuotHlV8ZkqRm +xsxZvicQA7TbIl/0CBiEZDVLE7f3QzYdedaFtJFRtunFEF6ipr6BySo0vHbmDx5L +Ws1gsNvxxw6AY1uwS6LZh9v3LJPL3hzdkKVfDRZX+wJwHgfxC0JwNL4+uRAcJMAG +wM/Z54nv3nOCfVlANcZxJ0+LfH4+gE11hm12YLO3wyprn3MVx9Ou7bJYaPnsxyUo +1fa+t18WpqM2JBkIJWAy6ZTZHPH5LCgq13simS7zaTnC94kGaAsljS4jATglXGYX +KXTVlr0oUlNgYsNoTT9yj35WJXkuIZ7GV189g3gogTpumQINBGAoEk4BEADG6NQ0 +Ex5gy0OlnGlFZsTpiZV2LiUhACFj6ZHVEYQQNWgEgRnZuZeAXbTnFywzrJUYhx51 +pNjxfoViN/4Jyn2oMrmaBEuDxEwhVZDsMTzb9dx0MNnmjMr45z/4EGjln07tFzes ++J+0eVizJOWehQ40IEwyCZIG9QOfsC1e1estm0KLZKWb4gTihGFSahM4zeD6XlZ8 +krTlkWV9i7+oatCkNziuOTf8+ZXEqoNm/dJxG6pGWcalo+DiTE3l4HCFr6MZoiCo +WVaKYn1jtIUeioDVW8zPalt3VcPmjvYb6ZNHhFK8d3DDV17wv7TFJIOn1j2n82jz +bDZwQAWIA6iKPjXDJJqmv4qcZ5a5l8qirhjZhQEemftYsGBLTjx9ANfPcDFoQ69o +jDw34Nchig2nJ+7ut9h5mjeB9QmOx10HDposRaZq8yPChFpheHNlKwh9PYba0Z9V +b3mI04ywkw1oGc6YQD/VGhoGiMembzEK110DsCcZenD5dOWHug5LF7QTH+120eG4 +Qt0RcPLqI33+3FUOjzOQubw0QATYs8Dw2E36LVOUx1yrtDqjJs/ZXfr+LCfaZRsh +vYfcl3soHCXxVqEwoXUmxJK741RS4ej8w79clniZPMLc68XpFZ7qsKoKBHeoG1l8 +XvuAp9EpW4vujsehEwRudn1SNoc5fTFG9k8qlQARAQABtElEZWJpYW4gU3RhYmxl +IFJlbGVhc2UgS2V5ICgxMS9idWxsc2V5ZSkgPGRlYmlhbi1yZWxlYXNlQGxpc3Rz +LmRlYmlhbi5vcmc+iQJUBBMBCgA+FiEEpChSlfx7GoFgAGKpYFxm8A1sl5MFAmAo +Ek4CGwMFCQ8JnAAFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AACgkQYFxm8A1sl5Ot +bBAAuI9V8uztBX+gZhvI7LYRZkuWzmNa/qiDGHAF6DIAOYKqCZUDSrkF9qsIkeeZ +dEP7hLoIo6TkprvF5iLFTfzFWPT1VR9E/itBBzEZa2VrgT0ye8gYrsRdNkso2vqZ +Qd3muDJvg9UrT37+Nt0eOpFAfc3JYfqwjhVIngiNLwjGTC5oinEesdDCgqxo8Z6e +6NyMLdDtS4W26q7GxcuG5YcBoYi3pjxJx8ZGsNHqEe6RvU3YGahEgWWY80xCRarm +8RVYgfU4LZfm6D4o1ZO3B2UmK6+TgkTjYWzC/yMrcbK4lyumB36OCSg8byrJ3qUN +7zKKU0DIxPqFFCLxxhYxf4QrMPik0BTgloWntP2VFLUo3DxJQKAqQULr+H/WEgbs +gAuU8U0VLTlj9sCXn0iN0pHzNaEJJ4sz5mdIWOdJJobkbiQT+xAGwfoKDff9l9fu +82p569sK9U+omHMuDfxTT0X13U/6d2m5nIFwf1MitshU8frYxuZs3Lp0Qi1Xsqtw +c/wrIDt5c0M4wluypuz//eRLLwsMn6KEl1/Be/RebHSbFKOA2tdsc/hfABsVQCFp +RHgBmpLfL/5Qwd/K7dKKpuh/7pV4B1cNgviKwMFhhR2eGzTfbXqxytnYmJkV++bK +LtX1SkNx1TBb4lqICzdFOV5QjtjPBVZR7Ugx7sp7yZn4bw2JAjMEEAEIAB0WIQRy +A2MOLI5yclFoT+vFzl3CxULNWQUCYCgSfgAKCRDFzl3CxULNWR3gD/wLYa1UBOMs +zWu/BTLt42QHcd6onTTboP4S9w1Gs/ak5iQiEN45CVVLbJ5wS1iaeuMZ85fOtcEv +J9KqMvwvGXlsCD/+O0QJJbEpeJpHarj4ZtxaL659ipciqeSIQAsAb6/9SKZZ7HGQ +FD6DAF9kzV9HpKnNvE8BGQ8I38Ez9lfRiQuD16r4cqNgS076Z1AoQU8ES5N8VO5v +1fbAHsyLq9ZToE28BKGU4o59Fj5uqpfDrm0DrnSn053jUK942IGmIwKtUAn/j2sG +9mcow47xjifVTKuMXyNGDM30n6ITRtiTaZsUZGIw/yKM3ZosuxobxvJoef8B43Mp +EHYV/xZHYxegT3xlu5h8FlUQrr/WR7FtT7Awlapm6llIa/2G0nrPhQlX5nN5gJiK +O92rOvKM4wTadBjL41jfYZb5EE44T51hCpJUB1g2GSQkUpYM/MgcNfqmq7+7bAxi +nej/iCzhziv925mUOhIGhAUEYCZMFI4tIEVFFAUb4pi1CtXo3V8DJRu5TkuETwDd +K+FfBU2e3q7b0q/CTHdHfD8T7VuTaYm01meCqWG8HS3h2OSgtWrUgDBDKAU3O83K +K7n6K+SAXW1iOaUzW9GErZnYqlEOMJVQn1pU+txUAAdTfQy05mUvCUvHo5VOcC3w +ybU5HCZJ3cWe6HCOviBheeIysa+iSvBAU4kCMwQQAQoAHRYhBApVt8USIzlChux0 +w1OUR53TUkxRBQJgNqemAAoJEFOUR53TUkxRYSUP/Rt9FTybIXwOW6FE3LPF7GvE +WX//loxKRhiBSQ8Fwmkdchz3iJSAcZ8HgcISMH5P77Ip8U9z8GAucy46Bi7tsais +WOUVxu5gvh6zLui7PkCRubIxcCxA+JjX5oZm3LSy49s1SEC/o0MB4TRwpqRfuEot +s6H0Z9eHzvJKjoeX9Ku7SjfSSRWY3TWMMIjQBATRZGcTmgA3iJ4/9dFmBGsYhQq1 +WsY7bCmCahemAmAkdCxkB3hr8BA1Dm/GHgL0++txJhjCFwKj89yh+Or8l/C95qpt +S2uAxioDM9952DUm65oWtApsFs8VpcJxSdApmWmH4s8/B/ESPKv7apLq3BSgLy4U +A4FdFz+XS9xw3GItcPunzGZQfI6Dd5jPUMwYYqcr1cVB2vTiQB//smNjWq2skWTK +Btjk2xpPOMCKC5mdGI467RT8HpDMcKWUbg1kaPqCCzpQ9NJQuk+M9+jw78MELtUG +Vi8wIZSZCjR2zXduenyVUWmQTHSNfS2R3iWsYH6m7fL2iA9j4Zi7sEjffGbLkQfQ +qH+c4XBDWNzJnC+/jQeWKG++zcYtEHv0mk37agw2qB9HQdTO2xGJcfNF+dervAj1 +O2fvasOMj9aptRZVpKVMs25zbkplBR5mqPXven+SraDOQb5fppcPrKPt88G3e+dB +uBzElOXBWpIsMJuvutFniHUEEBYIAB0WIQTKYZ1lpyp7rfyW0oAZZBiq63TIoQUC +YDaonAAKCRAZZBiq63TIoR41AQCLcs+WlaZTZ0rg/cWhvApi12mZpXQC60bxvmrt +TyHH4AEA2pJLfGVHOualRCNbeGEYjfC0WiC+EYCC3NBVe18slw+ZAg0EY8vQFQEQ +AOZbk1044fA8gmWA+7okNwrD81kk9HyWwPcrztkzXyDPJBkkP7CezpNJc6zH4Gam +i4dmC+HcVAAOP+GEuOk1KofkgfTFjueJz0G5J7IrHZa98brbLHBdwWTBPGhakXe2 +DRy/6RPhUDcx9WPkZ5u5LgX0m/TVa4aTFSWXN3N4CgLvQhg04pX4C/uFflw5oICC +8MJCaFWdDo3Ph9d090wdWh2U+wpu/zKZWx+9vxTNDp2X3DWAi73hLQUJB4R49KKL +beMchJjCS79/qG5AbFKMDLzLFpvRpmyGX3xzekYZ84kee2YfA4aCpX4abWFtwGNz +pfzJsvYoSv8u7jEArfFJCY/607ow3F8FMJ6jx9dFP3mmqPu3dAci74ttViuQtDpK +32Z06BRSwB1Vhcnd6Hxj4J+OYHLA1GLM4YesSnwmwBxLT5r3IEv4FhaFLgEv8R55 +pxEtP2R/MipLU4P9Ev/hBuLYYsYWyIdooVSfjGx7bRlerle0QvqW1BUiv+ICUG11 +I6eB79mQ293dJAjILZAE0DLrtC61LzKJoITa+2vyLkZA67Z+CvU0nRWO7CyGaAm9 +tnab/1mrVinWIyc9Um05Zw3FNkBYkM3gvk52ipto6SpL/5yAvLZROxzQDtzG3/a6 +A62Wf+61ex+BvdCejr3IK5JtCZUzU2vC9lXE8haLsHaBABEBAAGJAk4EHwEKADgW +IQS4uAtbYj6rath3XEW3xdfWNQlH+AUCY8vQFxcMgAGA6XbxSlCKSOnKP+m8NyJS +yhz5ZAIHAAAKCRC3xdfWNQlH+NMxEAC3oyW3PPvGTtEYgZoX66DRBKiH2fTtjSjE +QBvVw9K+jejnCfFDplgi6SvYpMWRdoOHflelegDZn1R/rDPiHwGcXwNaFuj7axKr +1q7QnXpuwu4gd+HMlZdLDJ6Qc6suKKJJ+GN7L15DOA5PyMmwSPIXN/G0w5N6ldfz +JB2nhIrdZh1WMBxvCMUZxuHlWpAiyvX4x2VpVyGpY/W+bUAO9AULzuFCOGkzNChT +tZWQlayqUy5eH3mHn2H9Kd0GIcpcdB+z8sAzszYr9+BL34Rs9ZZ8L3v/xKqleF4O +y8K+566ZPLNQI1cWk0bBRQDWo7oZNozAeNpf8B4JpEzEJBwt1DTtvrNzXd2qIwAA +vV5JDXRMU/2QPZCjI+MXqWHRLnGyEdYRPl27DvUqNgAA4Z2/wnf0MYy9Pw50vxSS +UgnLsouPEk6NjbWg8IeDHVxAos40KA4BxDhmbME4/yxZnuV3w5Up7hz9s6rBtEws +1dTC5Um56PC+jKkI7Ft2VhSd8vrffBUxAEzyKWiD7ZPJ1K1XgBQJBWwgLDiJpdRT +4HqCHV66+C8JbXerukwUkM9ukL4QULUWXhFP4IUsTxcbSRcdDfEdaj79vj3Hcxi/ +nBLff41ml90cS4crDJt9MhWyGU9TyteavCZVc72JGYBzONyh5hk5MjkQnPbQ8GLr +nAB2kAVUF4kCTgQfAQoAOBYhBLi4C1tiPqtq2HdcRbfF19Y1CUf4BQJjy9AXFwyA +Afv6vbVBtdyVW9m6btsWz1uxJSXEAgcAAAoJELfF19Y1CUf4ptkP/i6gG11Hkt1k +aHmwMGOFwMn7T2+FqAOHj+UuyIfn8cSZjkzR/BRO+fNXTQGy7fK79uXIppf+itqb +WMHPC5yqQhcXH8oXoSsyQcFCLTDsqpv6djWzbisPr75Uv9kgDkAIugzEP/FY03QY +Dcgxrkeq4DF6OGCkoHUObtBwRpvYmTaGeUIUGCaO6fXESpvYg7R+Z9eNESlEFvO+ +Y5MKQRSbwIiKQnLsIeYAhU4mfFBnIrlu5rTl8pk4lC9vtWaaEnD/V4Tn5VTR8wdt +kORV4vQs4B5yk8Yfe4IRdp/gnQ+7iNcIerP1Q8w1FrA1YRwFFNmirkzkalGQik+m +3yPuMahBoozltTG2xLT7wvnqfTcnnFYHL7IRA9icEmzmfrX91xxpHCo7jtMmwAMi +qDtPlD6/3v7XFfMxzwqRNu1Bq1Z26Q25Wtss1eUtgj+w8KGoy1knvJb1CHP6WMmc +EqRhOMbk4uOwicHzRw0U6RkyOyP2BCABqBLCqWX8ghevLTMoX9kDcBGbLsbm+O+o +/weNJZtypuN3Pbv8fxmf8doZErkbCgFL/gLIOK6+ur1tLpuTsThCXo2LZQXtuuMR +QuJh9sx0vQcdooe5TetYEJm0VHJUnfJQo/9QB3G1LxXBuRgE4imBLhjpHBd5CYL0 +bpyuddHqGw4OzkTjuGK6B/8eSG/JDoImiQJOBB8BCgA4FiEEuLgLW2I+q2rYd1xF +t8XX1jUJR/gFAmPL0BgXDIABjII97RCqgEFjnhIQWs6NbgwUpHACBwAACgkQt8XX +1jUJR/i6jQ/+L6bxKesUXshyymkwvp2zE6+KhS3l0FteCRJsJSF1yJbnzdLTiapL +yKJwyhRJeD5YpdYn5RoCd+HrJYtxt5ikfxJn5Nf4nda4uPgQI94xh8sZjh56Eogm +qcQN9Wq2hzyDnD0nEWCVkFNn88l7KPojai/NUbVgfZkRHRy9G+K3LBYE/d50MFr8 +o8fMFUtp5a64fbxoAYcXake0SH6cN9D8RuUOU9SQZyWe7v0TzaB2XdbQa9xsxdxx +Ui+KT0gc8jTjaZ7gonDLtfeqg0Zuff5d2K0gD7qtvU37AYN1CQOz0y8aahCjGzmI +WLmRb8Ah0gwcJH4Doww7goZDoTpQN38MzeIWHZX6Bq+S2TzmwiROHLfvyXclBGJ1 +Gm2J9MmMRKfIz81SM3wkxvql7KfTErJgTq40r1xkCZsRYYJ1l+nraA9Sjp1HsEd7 +ZrWomiS99Il2Nm1zMG5ai0WzoRBwK5EOqnJLOstiK0I3E2onQUb6SvKu45tVeCvj +L6vULv4JzOYYXSbzOnUG4ZpPqlvHtfpWprNhJ86RBKThbKTz1HLjlFmaDv0yC/Wz +o03PieBbstg0mAxlfBgcv31SIvjt04UEIhdOpVdRHBT4GRXHCpkGrXQFZ36p0w8a +XyGwDfOLrg8kyDS7hhpaz+NqxlpZokjq2/8zVax9DdMJmu1PpgSeGJ6JAk4EHwEK +ADgWIQS4uAtbYj6rath3XEW3xdfWNQlH+AUCY8vQGBcMgAEwmRG+qWbQYTBTBFcR +tOX/FbD9ggIHAAAKCRC3xdfWNQlH+KUbD/9b5yRXWW3TR0D5LZMvuppB6Gn//TcZ +ecLgJFURZqVqgTKVyoeW/JSJBzr6vjhmSgtNFJp01a3oQghIVpk6IgQOvPOk1RW7 +/2F5B4l547M84VDQsE0jzrGjx7USa9YwEsN/o0Ylm2gbWoE0jImTTHvHnWk4Z/uH +zGW8QOjcXQk0Ln83UWO10Ad3IDwctAWR48hYdSb6HvqWAXdnlwTczKHtcDQ18p7f +emAjsJaFs2IXrZeE4wBUzouuOT5mnsVYOmVKI274ndNONHSwCSkflR/hXeLvMiGV +UoqFX4q2vmiO6PzTlTW2hysfrxsGfjB4sN8/Manitnloygqor6exNhnMWvo1gFAb +9yOzQyPyDlYO9csugn1oLOFC8+oDOCSV7YRC7NvdBI5B2Dgqi5v9pAgHRMaOApgz +tYCP8QKgrSGTfDTvtUvsx4bw7ipK5tbW2hnRmtptYZG0npbFM1zw2p1kdmFmd8Oo +lDphWem66+WkAwFl9MgwJAOmB/BsMDdmYBC5iKQHonKvbyB7m/21h1kgiKXg/Xsl +2Zr+6ydVKmUasNnMOrEAz6w6xd6ON0AgyenD22KUhrvLbcJ5+Wyp3MmwDFmKaKnN +K5FTb1Unfl0S0y+rEvlxsFUxyXUVBcYhyGta1IOXPLbRa5CmK1096O587Rhx1kJO +jzdbN7Y4UgqaMYkCTgQfAQoAOBYhBLi4C1tiPqtq2HdcRbfF19Y1CUf4BQJjy9AY +FwyAAcdPasnpM7MGf1LzP6RZ7GcVsHBfAgcAAAoJELfF19Y1CUf4TYMQAM7AJ7pR +ACiPJeZBIs95Ef3B/KR54CpWjC3XkvdJ6AXcIZ/9bI94Dujh/CDrQMy5vzVS0Nqd +MHazlrIYf9vMuGEMX9eNqi3ISjHr8nX/OmCKdVOdhFSzyYl6akSta6KuJ+wofOHd +VP+m/fmvBuUeEx0ePa3Ghm1MdrkyOB5F3ehP42Vtsbp+KsoLMYJV3DqzPjvxrFry +2DAbrkY9r/iVFkJ89h3rakDYcuV8XCOAMLnHVw5TphEdV1fVUnRASv76g4VY2L2C +tsFmNmk1I3YUWley+8DfPNoIZ9RVnlOLgYqwL9ENuYhkUtCsXy/VsRNJANa3gXnr ++eNxAxwg5inTJYG9EqElR4QdWXe760ZoyXvh/n0xk0+Y2djrLZ1oMhExgmZyNqBh +xNKkVqvozOJE3a96lDSRUPFejK2a3TmQ04sWQ+BwqurB5U/tHmZXL7//D312vHjt +PAl6KLv8aK5M3cUtzaCfnCah66veGSybTkqD32DGvyLWN4oYIa1Yt4DYqHp16jM6 +wCPJP7hxfjCHuZQ7yU5O9Gn9ZGqo2jdpN16VXF2Yo6O2qu6RWMstpjUsu+VAT0ri +OyFxAGJ2vU2Z0KX3NX8hnM/fb2O67gy8ru7LLMdLFdIbmO3TC7izMg7OmACqGxNq +wtAyLlnVx1/L41+qVWT++aZJhJoGWarZCCdftElEZWJpYW4gQXJjaGl2ZSBBdXRv +bWF0aWMgU2lnbmluZyBLZXkgKDEyL2Jvb2t3b3JtKSA8ZnRwbWFzdGVyQGRlYmlh +bi5vcmc+iQJUBBMBCgA+FiEEuLgLW2I+q2rYd1xFt8XX1jUJR/gFAmPL0BUCGwMF +CQ8JnAAFCwkIBwMFFQoJCAsFFgIDAQACHgECF4AACgkQt8XX1jUJR/jrWA//Wnr8 +3M+9iwR9SbrMlhMgMobX/MZ4gL0Sw46W4koOBliJjqiBhQOFE31fzfIEzMhCRUXz +xI5C5PZ9mT0o504DN0CBzkIHuK+iH8/jgd5pzGMBvbPz+0kkpbY7gHcenJZH5ifl +rKZ0sl75kWwF1/JTtE+WjHjajvNmZ/VlApBKgFlvtfcSreWrjjZl7COyOxGKKOVM +4N+noQQgdiFjy8aFT+XKqnA+QZV+X8b6zjeP8wCjlvlMF4bYn1a2oFjL5obxxEza +8mhSsxlHQZm+B9sxW6fXsHGDt7Pg6JiFVuXHeUxC/bkGdqBBOlFCBXTbXG7DjRxH +087Lr7IHBFRg3OIZmLfWuu/NPOYXD1zFXuWmCMAzBkmJ8ZkKV1oMHFhRBHc54DOf +T2VGGk50Vekz4wzkZeBFU+YeG3KfrTEsyLLk0JG4y3OY/85oKVEov0GNac4fc3Oy +MC9zVW02PQNJUZO2ezAOYBCAVlVhh6yOmJM0UTsQNMEJPW5hWEgyvd9XVRLdUh8o +RmUmtsH0UBxxaoL+gdP8NS+GOcOELfBF0KGURt8LGpqIdT76Cw3ron2vpkj3k8Lj +DRfc7WFcl5a2b13wzRLGYB8nh4E9U4/IWA4jg4Uzx8UWJ7kx4CTgGw3RDK7aEPmD +ZEIVgiKdt8WxJ1bZZBVrra6gd9aDAs/BjP6xaMCJAjMEEAEKAB0WIQQfiZg+AIH9 +4BjzzJZzpPJ7jdR5NgUCY8vVLAAKCRBzpPJ7jdR5NvQdD/4/DOdIEG0RXt4tLqpm +lLuSiw/lpVqBSRxM7xQzFmRSoGGbbJbxXzzmRKJzutk55Zx3Q0WtWlMYfksfeGL9 +rXcHVLby/tbLUDE12UclV8fltGrhpIma0I01tuEf3Yi7OlX9gpzLe54V1DeywtZY +oFVzxQZr6qsCt7kNeaZrDAwuVnXobs4LtjKmk3YTMWd/WsLwBXc7VS2lks2rwyRY +CT/rlRMNtMxLh/ogzntn2l6YFazFMErIApd24qrzOR2e/wH5E+4+DKGolSInhGB6 +y5jDgCEqqI7gJhCbmAr0gf6Ew3og1QEc6Sfbo6TKMCtmAXD85LutPcFmKepKWhaI +E+ECD/jB2D5iP+YaS0ndSK7Rn/9BVnr85ZEAAw0JuvBlwAO32kQJFLbjLyVs26Jx +9cHuvD7JfyPWZeWKXLqRWk+10AmmQTrZwdsxiwwpWRQUFBL0KfU++jlSoHeL7pHH +HnRMqSrk4t/9lyIXDhK1lgFGUfOA6LIFlEKLz7N7rWCavO/1nlp3pQLPSxhqtroy +a9C/U2j4796Zpo7Q3XlsoW7O1+a6heZZKH3d6Tlk0LwqNviEeSXfULUkY+5saxFq +irxhN5UgUSBgjPN9WCh9x4PL2hW2NxFiKQMBsNhWC9LN5USLTlNMFFbxdqP9HEhL +30zGiD/qhI0PkLOOgnsOe5Paq4kCMwQQAQoAHRYhBAWrkDQMDF55f0SoyCVM87Wu +wKjwBQJjy9QhAAoJECVM87WuwKjw7QMP/02meRqVavu2G7WuHXxoi0AXevr9M5Hf +KF/PssJFhac7Hha51XjH/5bWuEUXEHsS8TnUXM6OCgaoLZzakGn5RH/5ixQrIJ7a +JN/jP9mTEYaCnHbc/P39sxC1DtgoHXIPu5e7r1JpPWAlU47OIW6ClXwvvBfXWq6R +MclTWwx6ZaBsdXIskCNeSsO3XUpym9SHWrUJxUxAl2EHrGQ+EkFEetjUPGDqqKlc +3d3sIPwBoP2nhFzwwk70XcPrcmSZG8GfQRy+yfHGCj9mXSdtlLIw4NBkDzJ68Wqs +6bIbyjasjO8z9+M2KICeIihzK3+zIrTYsI2zeWm8YOoA2S8W9jF9oYbk7mZLqm/o +GxEHHOgVkjnP45c0zwhfDmGAPHnvto9ty7q3W1GtZRKvkR8Vs3mtipS0QIHujXTR +vhoVc4/ovLrZY1AAEGR6dP9p5QYjlVWDonnf4z04BRqCpJW6hUFrr8Bm0P5Y3+IG +xFzyPBaNa9v5ua8r983nBPsD0/7Hzsj3TttBtP+qjAMl63mRHR/4D0XvPLpFdtDU +wJgv1GZSUpf5qfeDuz1lxCyxsp+y840W2J4jbGB0v2kthkqLAnZDvAXrUhoPzxiL +mKi+1sfwTCrPmUJLOJvyHwmoLm8UCP4qCOEUlevp0LkOoin0O8SInOiByuWZXrVJ +aODYrcQgn1noiQIzBBABCgAdFiEErFMNUg8vMmn16YMTpIRJBEqtXF0FAmPL1IkA +CgkQpIRJBEqtXF3MZA//ferM6vGUA6Ky60qmLTfyquEF6BmlYg+gUTTmVIxdBU4N +VGipsxToRpYoQUFtfwfS/43eHziAistFYBoOF2Y++Jjm8nNgmipZ3rsZK/ORZksT +v+cxOeLU3Pi4y4+ATP/a4a2hfg3yGkO+2r7f1hrNOP3a3W8aMcvda6h+/zMSXsCR +S++rip1/COP/6nhBLO6bnGnT8+U0hsdfIaClHxHXMnNMietnvz9sS5uaTlVKJk6W +fBUFbt1+DaUdv0QqvVO1CM7raG382wgQBJM3uwdIM6obdAwAEVn9MV/RU29B1Tsr +iyDD02fGSo/42E4jG7VLdH+KL9GZvAxZptFJBvlmkDHEzRju64pf3bBaZUU4p8oi +p1WKxbP+GM9EQEINe7AhKvk/NSCT0l3X6JMgc+79dcq1gO3yhPKJfyb8RrdC0L2v +4iXxmPkBdZWBWOV0s8oNVFvwHKEWO5rDkeqi98+IvZlhxK3vDlkZFvxUPYcCqncH +r7ZHM5VFFCuntPBiHDdgaw2CCoN2mO/uLhWJkcPaxRs7/UYhJo89+IhKoCjJI3ZP +AKeowVzpj6JeWYd7k3jg7fsvMOD+VVGQS6XjuJ9VV8XzrzEfNajhYZd1kser7HSR +Q2OGt9Td+luYgACStLKmj09u6nppy/t+qsWYtyO/lR6D0cmIq9pqvXVkirWPDrOJ +AjMEEAEKAB0WIQSA6XbxSlCKSOnKP+m8NyJSyhz5ZAUCY8vYowAKCRC8NyJSyhz5 +ZDvUD/4u2hlI+FCelUk+rTwzwo1KFpR5ARQKHhkohNYA6bk1dQ0nvzff/mmXKmCZ +QlTC5e3CQK9UW6n4vJkim1vMAsPEuSx4hjiVq7eQR95Pom+whL9K+CNQE+RfqHSL +cuDQaB+K/7c1/T5uwYBLtOLojT/qCl4DTXczTy5R2lwkNK7U60IJ2hYPkq84AC5T +Tr9DYvfss4KiWwLpnl+uDdoFoOZJwElzkLs9JkDiE06Kaq/iJlDHfTQo4UfU6HIF +Fk53Vtbxq1Cigj8kSGOHV0l0ho6DKM8FcUnylhjZj0yzQ5remmtc1rRcJiARxPmt +hkQW6nb0fX4kWNNxip5zAtTJxgYfcyepF2quJnCIdQrRSL8ymI+VLYORv/YLPqJY +yklIC28R60JWBIykaxOUWAqNywE3rRSa95uZbvNqNc6aAVTlwdNSgaZs2jf2Irt+ +BAf9ZylIKv5szCtKrovgABYhHZOvrERsMlAqCHfdoTOyBTY5XD6okpAvheJxaSLS +6X9D3jOW2htEDzqKrGHv6yl9gFgJoIxgHmUiUMV8ctbrZyKbfphesG36npXIHckZ +69czi6ntue6YVz3RgOPR2yHqrnn4EDQk9bE888BZB7kKIuZ3v6HHnEAnzn7XO0VL +P3XDhVpD2M6gRvkgLy5rIvJf0Yzrjq6YVkJWqsrIcceOGyHzhokCVQQQAQoAPxYh +BPv6vbVBtdyVW9m6btsWz1uxJSXEBQJjy+0pIRpodHRwOi8vZ3BnLmdhbm5lZmYu +ZGUvcG9saWN5LnR4dAAKCRDbFs9bsSUlxLzhD/96H7I48hCpMX+dzEYml6fmkIIy +zR1Wj10/0QnvFzZ5JInRWEl311+kmpMxSqWOn/M94OJFGWGlmMxJdiDQQwy3a9tn +2DVL1xJthTsCWiC+npWV4rfeEO5KgtpscRMbvylKmrZiYYJSfjsDJbvN2xZXSUzS +SIGEnG5aOXwH6mZfNIkWqbrck8H3Med0vG41rLjZScuwNOLsHboE0p5tCsHlmKg5 +78iGmcejEXy/mx1Igi9gp3+9ETllr+5jL7ZwyaOMtAPohf9/3IkNz6yp6Fbj8OAm +BTtyraUEkz7fkC5QMjzoyrMb/YHC0qe21fwUrLv0UgAwC/pJ/etCjI5x9KN5J7cU +XkMPUhJH8jJ+Oj9Zn+bLn0oAOrAQxzB3dClxDBEhe0MTUtR7NZABtZ3lxpjd3SNm +hwbgqsNOGSiQuyX+QySZtM7wLqgl1W/6DYAPYwcYFHNK0MHM0sqZy46rZS2U/TcA +KXlhxhjoBjtZrLkLPyj32XZ+uBUd/pMexzGNGfdzEfg9ds546f4ZPKTQ8KpzJQGz +pHP+07Y0CDLNCV//qUPykihIUeb9MR6q55lkoCIZOh0hAtLRrwYpmkaZWyO1tdLO +7vwJR2O5yx1RtrB9dDhjLuSVXXyb0RCOJatUwFhfyeeTIS8Cx8zjKX3/I5Xxj1D8 +0R77BmOyE7UCKQH7VbkCDQRjy9AVARAA5SIpEu4Q1OzxuuLRebzk3VEgbot+hz6H +tLe8H6G7ZAwsyrJvJVcs+wwIKPiJI+sxe6HDO7fD6zfG9HNnTUcORg3FTMXTRAtO +vwXru/Jlp3Kx/2DK1gW5UmAxEHFEaWR7cjFPQuScAiU9fgPKzk/7pB05m2Sb0fw4 +RTMZeSQFAamJtjM0aPsggk5w1yLj0vgYz+TLOcMWdQHxB8cPukGP+bxqkYaZSO/A +9Q6BW0UlHte59yUgeQkJ6jiX6mml15BODy5nZ6VYioQ0BnQJuPpYv7Lahb8OGWYO +4UeSC9/+EqVxO1AwYgfbZk1AqON6oqhVOePYkXeBDLzElD72dz9hkPddEgMIq0y+ +zRkHHBaChgdjcTzNGET/LHKq4Bf+7wFNohLg7fDm2XW2XoO/awg2NetvwVMBzB7i +26jnG0mBKtiThJ1tQiiHYyCfbybDghq8/Qc0zdoVBr8WXpj9WQYsgKivVRN7f712 +9MAeSPDQtse6r2B5SK4OpHn6Fl35IEZMJ2KZl9MsLSxdrd1O8Xw2JLEHfJD/9NuW +AmHgdLftDg4gxzZRZ5lRFOW8di/R8O0gpQJzqGXQind5oa15eA5XOtTbQJ5wcm1j +bBSFyQTiXEyF9T2HXAQOwTwYHq6YAGFRC3q4WbpLIQFppqmgF5v/HIaEnlhHX5wV +Kb7ZnYBvALcAEQEAAYkEcgQYAQoAJhYhBLi4C1tiPqtq2HdcRbfF19Y1CUf4BQJj +y9AVAhsCBQkPCZwAAkAJELfF19Y1CUf4wXQgBBkBCgAdFiEETLUBkCB7R1ij9zp5 +btDnuCZD4TEFAmPL0BUACgkQbtDnuCZD4THhbhAAx4zqhSukpgMAE+Scw5ClPqJC +j+xCV8/FWGICnVcbMqhH4zHMYefZbgsnzZELJcvIps91bbIna0H79ks47xvA6nqB +tLM5JNvV8IHO0gg13vl0qb6V4a9SWvc63YdHK9kOeipvowM7dUStue/PcCG1iDgo +YwfIOMi8mKyODRnICx1JJcQyodiZRoD4pcvhRtQpA/kr5V0rCpTIcsirfxrN8Qh/ +BjK/duv0gq0FbKPKIdD0SrN6gm/+kL8KVyS0ph0rJmvBk+IhUFsuD/+GRYhTcxLG +y8d9yatr/HF/HfCzRo3kKz4Vt5CQSHg2nkzBCpFBKIdjZspPQilcc606T6H9oIga +Y8siGydrNRuzLL4b8ciCMSS9Rg/7t9brA97Bc0kNmOuB8vbTYmEbK3loYk4UsR9i +Y9IVrUspdqZo2AcoL0W0sY5L98LhPVCRL3hYu2rsiCx55rcKbRyIOfdoDqagI3FR +zEbbfkKTQxDgnmSJoafqx8nreK3QnXfwJZASNO30e8oFn/DvKdutnErkziJj6lSN +/Au1qcoor4fgdbiBCpWYHJpY6e19pFUJZ+QAgMhKfzZbYimApGRRifpjAtc7mT+E +H7pf4P8FJAXhYqzoLkxIs/yjy4F+doFMNg+LkerZg36PGwPSSKP7T8qs/L4TI7ul +AlV1FPUg1bjLYlY3B8gnmg/9GFeZyOzutnIUvUlTEniCIQ2Lgq4xG7RFxljLA7zL +Tyv9k0qbQUFkFEnR6VhHkJrQp0UwUNrL0fsBgVzEyPKWAwDQbaRAcUboSfgZj11m +gJeVMSSIHzEKEMBKVvnEhT1UoYLKiNUwuH963LxrWkAWuP3KALB9ZkIji7qVKgzc +Q2GiQkcpp/vbYH715AZlr0terlHBw0nmjxCl3zOfqxvpez28YrmPDbGNZsYvvQ8W +oSbz3nFMxLc/7HwAtpn0q2e7Hvp4DRrh52afyFZrWm5IyM57gfE/5ggsgY0gQslN +grn5wD9f0hRM5OR5YDNVvxzM2MMr+wDf5VlLR88Vs9bg0+zwEybL+4H+zle7KP5i +mKtynz8vI+Jz52YeAVEfr7kn6E0YICKf5q3WL2yALSsmGpwvsejvsejC4hBCmkvo +9Q9wXwI0zhA1yBVb7ncN4F5pc0urXRmtMovo7Roril7P7SGwvTTUrBMGuBoeinkB +i6ppxYyC4PhC+2GrOX/dbn5h048zDLPG6eIyrTg2z0AcUT0ODFLSzWbB3+itOTT8 +gdmkVDz/RSwbumar+2JE/j0tX8bgq4MMm+lswuzqXVvTB4VQT/uQTxMT2ZlUZfKN +beb8wYMYQ4GxPrgdkux26WNgVbm1VNtpUpIoypIuuEJnFJ6fOBA2UHZPpsoZxgao +vsuZAg0EXLLnwAEQANOzwoO1BFybllsjFbeDli8jnO+uY5F5K58HtZftLyYq+lU7 +5w4KwSGVvc0J2nuP8Fzw7xxy83yT7Jf+lBpIoln8abOFn4WCPPU/GdMtigILQ1Ip +IRnwQXlp+bnMJ2/NOlszZL/UvLBiQUFSoWAVyowwUvGHwao6gpCCptjlkCZjMLS/ +5DRPWnP+NDKZ3DB1Si28uzaSeQkHP27vFNoZ18rBLy8hKefIz9CsuldL9ZJKBXNh +Pjoe/rftZw/N75aNVDguFcRvBVJGy0eI5vEg9o3O59tui2UBXN4qJWc27qqCcorj +9CllRhbO0Yiixk82jdIsU9uF7Tac0YLI3BjSwYWxoFQf5RD6Hy04dRee5/hCj3t4 +xU/UNrRRY+FYNni4+MEOkJkh1VresnqSxIiQKUD2i9mUj99h1Mj8DmUSldm/MjFw +KhxIyNTyHNTmixhfQmOWCYBQ/8fsIDQtbFchlm4MAs+C/IuNrDsLhT9lE9cQ/hUG +NfNptv3erldjdZQFshyR/6Um911k2/zAcUKYA3REt4VlH9CiM+/G+mCuVJWzWF63 +OKxdwaFDJm0bOB9p2oGUkAoqaORTvDhONqAuhI5jOUTBL/09YUuKPbTq3GqQypFa +HGFYXUtlFpFvo5AtipdBSDqhaJPNl/EUASDHHtxHqilrDLHzrF/YcyZVH4M1ABEB +AAGJAk4EHwEKADgWIQReYbIXJl2pgHojxf9N+rJwyqlt+gUCXLLnxRcMgAGA6Xbx +SlCKSOnKP+m8NyJSyhz5ZAIHAAAKCRBN+rJwyqlt+iWBEACzon7SVpMMB3svB8d/ +ux3AV6aQNpMHqaQ6WgX+fwKAYDnODVqkl95BdObAl4VQBEuIcg/LNoSXMiLU1qTJ +HeXxWzbLMm9WBYNfjAm4WGXLFlO/TSC3WFD5H32fdXu+dff/oOZr9+N2bMe0AfjF +Zdr7bOQ5JE7+RR7ITMwIWrtr7/WE/ZDXbMOQmdsJPvIEuukL9oQqFf4/ni9nw2dD +GiXDuDqPOiBORuMdCX1fnMlHHulLpN4tCPrTFp5w3yNz6TJVAgG8MMOL/4N4QYK7 +IxlTJFr59NJtgFkVn9G0iZPydAagNk5geRUTDKviCAQpqwN+RsfjqcN+a7AbOuzF +oEB3nTSxXuJImB+bB/vhJ3nZdypCPLENxgUhSNyeGZ8tNuTqYQ6Guqch8IBxXvD3 +QM/MBZoRPEHeoZ3AAm8dKxPGTY2AP7PXPV6duSzNTc9DdU8g06eHLqShPHpILBCr +AWfbMf0/4UNk/I1aZmOCX3KdYs/uiPIfnrwcBzrlb+zMWYyA63hJvK2QXZTinGpv +MxrNlnThmdHrVFhPl1j/GWHV4N1TVrV/qHXqhLA6GK+JnCZ6jTsKTOM9kY48FU9M +dAIhiJAkmKM7gHuc6c+qoCEFVpqpAoAA1ZiaMMxbbWzziqWZ0/2B9qjYhyjHtLAQ +P+AiCk8QbNzMmM0hag7BT5nVDYkCTgQfAQoAOBYhBF5hshcmXamAeiPF/036snDK +qW36BQJcsufFFwyAAfv6vbVBtdyVW9m6btsWz1uxJSXEAgcAAAoJEE36snDKqW36 +P/gP/AwKWv3b0QzxL5tMwDvQqYD73gQ9shrMYivvZ5m3XrLgUwaLTaYj5eKnBAf6 +ggq55ei/teX8jWwUz/fdhmrR1RZrYQCORBJjiDpklP//1jQ9raVuBX6g69P9uCgE +7fcc1yKQpC5ttq84/pG48OrzZB+MXDHUkDv7u0bVeiFbftm3EiylF8gncKI/1B3+ +FieY2zlBmxDxkY+Z++ledvSlZGdIhxfnVEyAFCSvYg+waqLBRliZscsnvr4DoAyg +A3FQgKipRqikyY9t5i/hXThcz7Tf3rJ99qm3qKC7HKrkUSxbjXCw8XFr3RLeRc+x +uDB2Zkh6oWRgMHqgjQk+hT0ZVDdQRxX5bhqshd5StPO9PfXYOaxgtlwZahPoxsqY +NZiDAwfvtmZT74RxoJCWVsQHUcrdHREXP1AbrBiKF34iWPlH9gRgtTjtknkNBcBL +xbDVFcbQnEOd+lmdvbnCAmR8IRqahKqnSX1IsuCojPbMRMnpaF3cXZ4TDdLU1Kjb +0SlJtMrhta+9Zo7i75EqsIHMMn6sdVO19K4coGG93LfpHTuMExScPPixlCA0dqaB +KaEj0BZmin9fuGYme81l7bH+4U4e8fNwikE0HQKrIS6qkM11/WTgDbgIQZwX9+f5 +gb16eU+Fr8rMOu802tDnw2lfWEwpYz3rn0KLQS2yksETHoY/iQJOBB8BCgA4FiEE +XmGyFyZdqYB6I8X/TfqycMqpbfoFAlyy58UXDIABjII97RCqgEFjnhIQWs6NbgwU +pHACBwAACgkQTfqycMqpbfqGZg//X5VqOV+CuzzQwxe/QCuCkaD7li+KCog+7vgu +7BkYcb1p+xaJx11JhGeBNtoU2Kpzqs1kNe2cSu4Oi+rsIhKiTIe8zRU2JJNjy9qn +/89Bb/z5lbJbtl5AO6pTchHO9gBXdEC7Ylo25lZortzODYnxPgaPV0VgDB/g4/Hb +HVrcexFNAIaKhOuty6ENu6E68Af6ZjVqRiRZcZ2x7TisqVf0c2hIsqDCgWWoW7EC +RbRjLupnM06HEJsxkmiOhHVtoTQp56v3ysXQ5W4e1Bu8435abiFiSS73V+AUnVyC +9hBUT6WScwTrQMfuR6JQsGaNAjBwJsb083XM66z78ScDlb+p/yU9f+uHa2mmZ8AR +Rs3LGM7NN0SnOuD5SuHtXl8BOFNw0pKthKNtjQI3bsQFpqJVNZi0Rjr7Xd6KlBXr +LKMaIAArC9r96GUXMWClF+YQRlnOrtRLfZOfOfEnSVT5iCygmj7dM7cHvuEB639N +9T25BrWd99SkgDwJZ/YwgpjaV9dnkAXZrWE+lY8Ibd8HtgRPOaBlFicR9pLfOS1K +UdQpnNRdwzXMHNSYapSqAFsc/bCcP8fTLTW5t9/wLntL+wnU5MkK3z+udPrC088s +0vdw9gV+kfW8hz21iW5o3vydaqZ+pGdoPneYkzX2ALElw4CBQguQ6ilGXxlK2urC +KmK2PiGJAk4EHwEKADgWIQReYbIXJl2pgHojxf9N+rJwyqlt+gUCXLLnxRcMgAEw +mRG+qWbQYTBTBFcRtOX/FbD9ggIHAAAKCRBN+rJwyqlt+pmwEACYs2eBwT2Twuy0 +lIrMwYvy5bItGr4N4AcxDg5lPxpruloz08s942OmS2fEC2+gPL9mglpJVaFMAwMw +P/M8ui7VUzjcnV0Ex7mY3rdVHpAZW6l+O5DiHqQt3bYVRe+evE96ctOcQx9KzRkn +rnvEucO8PJnLXTGh+33IkfEcVFwPbfKcapCpq1ykWW0+J6hJPrgrMmYBOj6Ztron +29jgNGt+HPdZXYflGxa54kAJiwp2RbTllo9Qe6Mhm10QWyUZuk+A/z1PdQGYRWVN +c2bn26HRY52W8DwRItCarNXvRT6x7xY/rin1hdhb9YyHTzeyra+tW5Xu3hgpwtYE +HrVNwEOBXMpdOXYp17TxgQDvCZUbQQfUPAVEeTGKub4/JobK66jKR74s1nVipJ2s ++02tML/ZZciJyVV96oXNzVtVy70TYwV/1J/YaOmLuHjG8SIrvpqnb7Dbd4UhEjUM +jmkav+vICmMajj02tk6hwojBS1kFnqJVkAG1/wQ/CB4x5rbnQTBHBKZTfrDSFtrc +j/cb+dkEq0bjfB5xiSnuEUFs5D8jcBE97cRyZ2vXhtpEipVnA0voXhWVgxpfPWMo +BdeS2SuarYT6ZRC8r9FHVxCD0UyS8xMUHPtLySpzRG9FxmS4nSjIxpRCzJmYQd1S +adVUK12D+pSS3hyWjAuc1J+DNjM/FIkCTgQfAQoAOBYhBF5hshcmXamAeiPF/036 +snDKqW36BQJcsufFFwyAAcdPasnpM7MGf1LzP6RZ7GcVsHBfAgcAAAoJEE36snDK +qW36eRwQAIQcBQieulJtg/PE+nMRZ7a0w7k5BrZRFMDnQX2LlPEnlusbCErY4tX7 +ug4hHHjE5MHwNg2OCKTcT33FZy2IGlIc7KRIQQdwl6UvcI3yFyYkpiUvlx0yVtlO +zr4lXSOOnpBGCoFsc1Rc1T0kG0fY+eIoznhv16BwpuyWM/ljs4+vBK27TyB3eWCc +8c3rMZR8eNzC3WiNtWeGXvW/emBgEqjHTbNra8+98YrhtONktFV6R8WB5YUF4cZb +tgIN4uOicEQP3odKwEu+pZIKOuH8q7fV5X+cOt39+GtB6aaL3CyEE8ZXJaP1DNLy +kizhKGA4F1xrr7d0kA90rp2Pd8QcX7pn1Rm+APcUBqfQbbqXUlbuvJCwP+JBnkC5 +/EmRHcg/yKLJoYFSF2CDKsGoESizWxKC2OlR7B1RspXBQ+097mLBIVXIKmwrszvf +11AxBoS/GS+iEvZu82FfZP4GZK9UiV5kBgnO7M9YlXPDm1+nIugYweE36c7lVeb2 +30QZIlvAO2a2TEC+h4leCEevdWE19kaUyLChIMgkdOLqtoPdnooxqtdlviKH40bw +XBc8PaWfDz9zhuP96pI5CA/F5j6EkbxDCJS2duDe1K7jFNUr2adUQcfocAblpDJG +d/K6zo1M45llZobt0kWwIK2MhbMnR8YoRIfP9vxX8KuXru1gkJmZtFBEZWJpYW4g +U2VjdXJpdHkgQXJjaGl2ZSBBdXRvbWF0aWMgU2lnbmluZyBLZXkgKDEwL2J1c3Rl +cikgPGZ0cG1hc3RlckBkZWJpYW4ub3JnPokCVAQTAQoAPhYhBF5hshcmXamAeiPF +/036snDKqW36BQJcsufAAhsDBQkPCZwABQsJCAcDBRUKCQgLBRYCAwEAAh4BAheA +AAoJEE36snDKqW366YcQAIn1QYnL7c+lz1bf0L8JI7T8NSVOh3BDqOTVZb9rKnWF +hfedYma2nR2EN0RjHR4bNzNY3egWEmHn82jtUz9aKxMO6GE8dKE4nu72Dc6UnbvR +HkV+4yyRoXqu1qJ5xO1fpbbFiVgMwSa601nBW4zD++1l1Sr9wsYnUMGA9dDqVtfe +j2O59EjCusNnQ5TVHV8Vbr64ES6eLGI2OLfNx/n8N/0qrnA7nA4v04z/BFsc9tIM +P13dU4NKIN1ZxIFBV6kzHv8++Z0v/jrq35rWQYEw4/kgHyqjROemxQunOPsk328f +y3sUsqGMHW8XafF9IroNmNltU7tq+sr4ZsuYrsYFVoCXlXjhby9qlNOcpmHYKp6A +NYaQBbH4vn6XNIv1miXP48lGAOd8BKmVa8tyiAZAQurJ1uK22aiYOL+tTFxD55RD +WSLujcwwFInmeoQ2W4eD16rcyy/OEzv7Q7Yquy58eji0UR0RVdX7mYxGn5xXbdM2 +R34zAvkw5h6Tb8s/NFHXef9U90Zt7vAlA3UuVs6rpqeIPMS/LK1AeFtSw5a/KsY3 +imHBL5YgCi9LROCzXW7Py2IM7d2WS5zJ69HBs3jhTtfKim3v9Pdfy3ImqmGlqx9C +qx/PhXUEO2eo+3B15vzZ0OAbckDx82KVR+TdPXjPURpOcDSj6170byS0/Ox48Hx3 +iQIzBBABCAAdFiEE4c8g3f/kuJ6AJljx4LEYlPZq7JgFAlyy68cACgkQ4LEYlPZq +7JjHmhAAjZVe6kHV9cWoFxtyVfJGiJP0GnTZW+guyUcKSPTEQIgVrr9zuqoGx8N3 +lah//uKHJkda3wiRh3Os5WdhRHsKzEmsRTMR4oFOFY8vfR2xVXIFUVbRJh6LRP1E +m+wNyEAd7MK85oM2FrdpnuvYqz6BhUUwjmApma27Z/ts5uS+ziEHsHB+5No7GVta +smJIiUec0vofJFcwLlx+tEjhVHFnEvRR3a0J7YSVzAzTBBBS/ZaUK3h0zZOLqhBp +pPZ7x3Qy37GOP0rSgpxpVSzoEApOroCX+87WwOW//G5HNbJxw9jpFmteV3po/X3I +8dQdMlKtPSHhU/JP7ssSUmXWBKGV0XACsVCaY0iywRAroW2RNmQprthNGvUdUgDf +61V0neKJXG2wPNzKw8EPnZky2A0kAtNVHmnNb00h0mbTm+FTJBJDF5v59sFdtsuZ +SUiU9tsfpndFpWLd0ZTjkWRT4CM2shJM3NGObNxvRR5hfVNHEVbs+i1Ng808kfc/ +RmLuY/HkiibZqaBLcwyDuf/W4ttMKN+4bglKLeTP6VYfbCFgyE5r/1qiwKjMkDX3 +WFDVcxPurat1OBbpJR/ABj/iCzcRqpM00Y6OT7VDJcGmruc/YQqX/ud2Mm4QzuFD +B0MWSOwj1l5zQv+r8D9U36lbXFzIq/14CR3vcRAZf25tGz83YLKJAjMEEAEIAB0W +IQRu1vXLX6b7L0YK6I7toNI4iuIrqQUCXLLs6QAKCRDtoNI4iuIrqW0iD/0Q/VnB +7S3NcooG/JSki5OxjJlHPfDSuu//YS7MxjxjdQT97SFjM9K29M+tepH9a7DVBFsg +7XSNebgpb6alvIMHssrSAm9kVrDKdmnTnPrk1y+2+c+nHBhG0GxD9pJCOPqgEtbt +XbWfZfnMU0RFlxfQ7SPBlBOf+DSGAyt3aVghbpvnhu/CY6dmA2u+kdHA+UsI8U8O +MGylcBLl5jWlZxDw2t9EKTTJ/EtlHYC2VoOgSaGzBoZWNqf5xwGEAOczC4I/2IQI ++IKSve0zJVYatWD5ahb3rxOuAcchkL7uzEYdTzAX/0Q+xGX49J9RAvJSh1Xr5R+p +EstCeM4kETyLW85mMGlq8xYWr7jKVieDxLC2L8v4RCbbAY4n/LMS6FvTzwWyisD7 +EQBOB6ntruPqb4mi5AK7MckqBpJHQhgp7ZPsXvdEytNnc0OOix1oN4I63TGr//i5 +seqr0sGvxuxhQPYQCiX14YzEitLFTxBjZERPF35YGe29vtmA+8IELlpbQD0cPzGt +zL4oiDc9ZTucx2pVV9EFmvISZ3Cs1uhbxL+53fHIPJRBIWgzb4sIQ65O7CFwPQ29 +yIejIvxXVyYnIzD6MJPz9GK3pewDBcgtu1KNT1DwOTA22zkqydxJjpbdBHa3p8uL +DMpruosJLbIClAYYbfgH4FBYJtb/3XCKzI/rSIkCMwQQAQoAHRYhBIDpdvFKUIpI +6co/6bw3IlLKHPlkBQJcsu8HAAoJELw3IlLKHPlkCxoQAJ+sYIkoFk/vNtwT4Qoj +bVXSZ6Crdt33qCopUZjk6y84McCC/MJ69eGXYsISJckJCPckIPKfCf1VWgieWgrt +dl3uJhvUFnQJ7w+k+5diOLy+LWwdxNlkWbofq4egh37z3l6vxrcYA69Zpov3nccD +l/F1XzsZhNOd4pHEkmkw27+J0WfVl3F9TCg5mcEW4pvI0BxzxZZGvtcJkOrxfQ8F +rdsGunzeHew0p1KCh8jdkH2E0PxwbHAmbEQoRh1VF/Y2kRj/LLAFdpcnhCVYlE10 +UAO32YbV92indOy9LIUIbMv13e1EVubmu1VP1cDNI+6K3diYvSnJzwtxZ8f6Ry6d +HedS9u2oo0YEFLPTnA2R+7TyXhNY9NCG6Lr9aCCBiSueN85aJsedyanH/+0Yy/Fo +YE+zDYDNsyM41NoZhR8nfFylyVo21d/B1yUdCcf763+nx5pSfjBuY5TweS2A9rvV +YueIovelIc6bkWzgXE2I87jc9sH5SBRqdQPBoansgavlYOSnwPvJuWun92Yko+Sj +dH1MfC5kQVSMnPOd/jb1BsSyP9DU0i07VkgEJXcClsTwrJTcRJ+aZB6zkgO3+5b+ +5ycaX8Xl9S8Nyg3jZIMENJZqzpIs90zsxNbCh2Gs7qWSNC4Mo54a38YKPsNwBfw6 +bt98bD5H9n0nqS6KDIm+IZiHiQJVBBABCgA/FiEE+/q9tUG13JVb2bpu2xbPW7El +JcQFAlyzi+UhGmh0dHA6Ly9ncGcuZ2FubmVmZi5kZS9wb2xpY3kudHh0AAoJENsW +z1uxJSXEeu0QAIrnRqQc8Ooof8fnjFw2gGQ8Hsi50Eum1RHd+x+ar8LOsNdhSIU8 +gF0LhqVLIgDRphDmd8JpznhUz5Jgcy3N5IyV7YS5MGpT41WEpQ6tWW86O8UqpbHZ +Wdye04VCzmBO273udMOO7Jxe9fjDwZTtJWemKXQ4PTAtIQzDrHXYDgfno++3O7R2 +sJqYlKsn/fmIYj1PKmYA3lP2SMyqtN6J+nERxQW90444vaakgGDoXxe4Bi8wxfys +YHZl5CBnIBk7M0wK0vA67Y1B0W0VVH+wR01lF/237jqgKHvM5vaI9wtyJSh1+DoI +Qau30LpumUN5sp85C7dVkBVr1yYOJOGgMavcvHm2g0dsM7wPqpmBs9wzT9w0PPp4 +65IlL1BIBNdELsa+N/4u13ljbexroGxt6CLH0Ggk/WqSojRcOLSwbgAQwP5OtYtg +NVH82ptK5vlFwtyMUlzML33+P4FXrXC6z8XLKLU5Mj2I4KHBy+otumfsznDGe5WD +E7SLSuKZ4/OcWmvBDiCyEbeKhA2SgClb3XPw3K7IMsiTuWcvJO+TAnTme1jZFAfy +rdKyApQT1BpyjCObpkoQ6K8blsJmeho+wyph8NBeprYzti3Pq2UT6/1V+AjLPYm6 +tq85yFM1XYJH1CLgDs9LZnk7eANjw3CISmK8JBNnppHVTX96y29GpWkLuQINBFyy +58ABEADNMz56VUq7Jvb0xSD5yOnVwCe1eaQSssXlGZaaFHsGd1ASgtaD4FyOcJ6/ +G5tkt99t5qxi57gdZ3IbwpRcIJLuHn9H7Ynt/XlKjuTbUwLZifismkqZ0c5MCUaY +qjsPoHm/C9IXURDEUfc9F9VEOgz2q3Hj4L/e6rswFdJcECyEawGdBNmB0O3yh2Tk +DC3bE6sL4RjVf+cbTps2/Aphas0MWxz+1ONEqXgl35Ser8ktwrC/kI8uJJIWUtat +wNJGitzGSUrKF8ZxoKh9xLTQQO77uortnf3nzOplZ5NHnNbiY9walyDwSbobWpfy +UCSu/lWW2MlBqMiNIat4yj1oeI4BGOsn+y3dJjti5LMm4d3EduV2Tx9Xv+elpIef +gM1/TSg6yCl7T1eGayrFWFgjwzGDM/k1JxE1URUqxaIvdYA2iz8SNOWfekhJOasb +CrYUWFN3b/x+T1ynrBkCH9TIl1fcJ91Z2BEUznT3NzLp6Pt2ViRicg7DZ4fATAKL +g8qSUGMdoVcJuQ/feiJ2Fkyvz2Z8xEHLianAMCEzlu/5QDaoGEgxC3CO2tu9b9CN +5FgQoNOuWLqG6nMY2V5qNy8TKc7O0vSaK7TK2QMSNNgoRcXpTKSg6XQBYdfxRLd0 +gejtxRSTom43nmdCl4Mgn15C4GZASom1ZUl4HfnQ2nsQMhze3QARAQABiQRyBBgB +CgAmFiEEXmGyFyZdqYB6I8X/TfqycMqpbfoFAlyy58ACGwIFCQ8JnAACQAkQTfqy +cMqpbfrBdCAEGQEKAB0WIQRSN87u8hLz1Rx0q+ARJpWg5WKzKgUCXLLnwAAKCRAR +JpWg5WKzKk6nD/4/dTAIux+ku4CzRCk1Ql+U82bQCyQoNRbTszXhIowrqm78RuRA +TWQKvSEp4dGN3V0Z4yXsGSKGmL7xFLplK3wvatxDBqH0g0NBHK2Nbivq3iUHvyrc +isg2sEcQDjSEk1uT6lw5DjuRMyL4G22LA+iz9yluKhIQNU7Uyd1+Da+2maOiCoTU +fLBlxBallgoCCxSx6eAUtMSYQJFFFLwpsgJjJUJdRd7yAJ9yCIOzumIowaZz693r +aBNo1WgLyOQVDBYu9nNmMpvsYVL/kjwWRt8bC04aplhgZVZ/uxvtYRB87nscrFSO +cYhsK9BhuC7a4zXOROeLLZ+5tdDvBavFlA9JeFjZv4Me2YszGFI+LiZOj4Ei1VuP +vYuzFbweHFyNqthGinBZ/zYNtluesZ17HtfkkrTSYGg4SPNdwUz7JIjMON+tML5r +oGeiQy2L74QN0hwWa7h8E7tLvN57qedtPbpNsw+xS81mZTaOEnIWnIGvY8qHVohu +UylLLABiyeIO1AI8xtQPiTdUBKHAYbYIBgp5WfKDai/ike1w4dT5nWFSLeuGfBnZ +W4ibKZ47f/uSroxQrwa7sQdSbiy7dFu37OVjSuw8pefeo8T65UMo9ZXPu0sjr+jc +mtH2nwc2XttWBLD4n6hZ8Z7GTtP+gkHri3vkSeSJlZC3Nh2/OITYXZzBxXL6D/4w +Ep2HpKsa/NFpWhkSe+ymmGm4qB2Z70URe6qZRqnDO3A0rvX5KSNf+Uk1Y26fTcdB +DdPyPu0uXAS7oBQ9ATdxSEp57O3y9XhUDQhD76K1C+Ob5kp14sBVLJbwv6SMGG8N +S6DZUsasARofWzICMmJCy8hF472rdC6MHMa1ERd4mBIUuLt95C8/r5BbbnM2dWWx +qZL74DtPLLdYjUAFCorQGpzDGSg5BorWzkXoGxEfUb3SORjCXp5TpwYlgij12oDT +/46Ub+5HFcGYXG42Ur+Q3W4lzS662uZeBxAEeUd1LsxDI0AcndRhJMhJQ4mCyoxA +Z6Jnf1SkGAvnRklT0pRfElhZTOv9gS1HPNWWv9vj4DGwAyNl0B6KZnxjZgcDs/4z +jPukq3wCMsjs97rEo47YKhmSoW/XyHww77Jd4FHyIlBBc9VRkLImXbV5DUOm+lPF +H0DgUJmtqE0TGxNkD3C/qUsJLt9UatuCLuwhXWAb1Hat4aeQdKfRzuDdEF2egNJt +5uUh8hTS4BM6fi6YNMSCDeOKb6pyjUl2eCGVh0My3McH7GT4zOYfh3fF+LZbpd9m +dt0hJQvyPMroCXp96AdBzi7dJI+PafUq1J83xXpBTFhzQCEASDpJmw9Ayp1AjWsQ +6ZDxX0OZW3322Ukm9NcVRdnsrYkxfR/ykNbsq1HTMg== +=qdgb +-----END PGP PUBLIC KEY BLOCK----- diff --git a/examples/MODULE.bazel b/examples/MODULE.bazel index 1732b2bf..a323a10f 100644 --- a/examples/MODULE.bazel +++ b/examples/MODULE.bazel @@ -53,7 +53,7 @@ http_archive( apt = use_extension("@rules_distroless//apt:extensions.bzl", "apt") # Debian Bullseye sources (for debian_snapshot example) -# Using September 2024 snapshot +# Using September 2024 snapshot with OpenPGP signature verification apt.sources_list( architectures = [ "amd64", @@ -63,6 +63,7 @@ apt.sources_list( "main", "contrib", ], + gpg_keys = ["//keys:debian-test-keys.asc"], suites = [ "bullseye", "bullseye-updates", @@ -76,6 +77,7 @@ apt.sources_list( "arm64", ], components = ["main"], + gpg_keys = ["//keys:debian-test-keys.asc"], suites = ["bullseye-security"], types = ["deb"], uris = ["https://snapshot.debian.org/archive/debian-security/20240901T024950Z"], diff --git a/examples/keys/BUILD.bazel b/examples/keys/BUILD.bazel new file mode 100644 index 00000000..e5b62dd6 --- /dev/null +++ b/examples/keys/BUILD.bazel @@ -0,0 +1,3 @@ +exports_files([ + "debian-test-keys.asc", +]) diff --git a/examples/keys/debian-test-keys.asc b/examples/keys/debian-test-keys.asc new file mode 100644 index 00000000..2afa7076 --- /dev/null +++ b/examples/keys/debian-test-keys.asc @@ -0,0 +1,769 @@ +-----BEGIN PGP PUBLIC KEY BLOCK----- + +mQINBGAEHQwBEAC7MhpIQlLicwR8tmMH0yFkMIsqIbfudnBCuV043sSSSdUT/XjA +XKdsdOCpfb6Tfiau1uY9Yb8gWLM8JxmSuaIa1jKlYiRZ5G79D7NOVIcqBrqp3lzV +HShLEXs4421f0Y4bSMuDcY/cdmRt+S+qlJvqKLwAbyejyi1i1N39UfJtK/OdZfuP +Njz8VoWPgJff7CaIYYREo4QWzAnuq65gN6DP3q33vh5OcoZgMDR+toEKYyGqhjXI +YEJU9qYz/wpglyijbFoyS3jn0oCTHpS2NwKc01vBGVZpfR+DVSgDWWQHjlrSpb9E +7bAxn2RfUZnQ6Sh3qcoihOjyI0RZ9ZYH8uQlur1JSS2n3/RxtCaV6uRtXDB5GuXj +NfqNsprZVhYYhBcX4z/4oMVim5ABkXwGNQMezrESHGq3oiIeJaBI5Oso2g/D1MIS +2W5B6NzSTqB4CaGzZ+IY30vvkxhnIG7gr4y76FzcafdJKM1cH/XlFXjnSGQ6UmA0 +E6hpXnjsQWGPL7InpDYHFVl1dH2syHOqHUmEU8CcZayb6hVygnQHh7DlhsrtnrN8 +4qEkuXfitC4Aqaq7lMflGB+ymphxBM+CC4OfiyvW2FDuzQAIWPVRwmKuKxMCRnPm +Sd+UPkyD0jm6yb1F2Fl8Y5T4lYOJJ9OfOpUz38LEqdVx0BosBn68shCwPwARAQAB +iQJOBB8BCgA4FiEEH4mYPgCB/eAY88yWc6Tye43UeTYFAmAEHQ8XDIABgOl28UpQ +ikjpyj/pvDciUsoc+WQCBwAACgkQc6Tye43UeTYUrg/+LEMuHp3zMwvR6zok7CAV +n6Wy2QNj7uNEvx7S4jmd8oMcjPZqkF5kjNso2iJs+l+6AeluoQq4b4gnCbGlarqB +Ee0BwKdHKo0eXcOzmx3XoJ7Gt4J+/iIrBANt4cXmvT6kyreq5unj4AkxQDDgeaBX +Ukkr7B0WtzZpRWyYhrHELlGEEdPSAgnIzmLYNXQT5cUrBwLawtn1IfC4SYpVfehW ++ltr+q7OlV18ggLxjsXTD4EppPGtUn9k8NYzMK6IB6NnDxT2pwCsJZzItxv9TU8m +VwchJ+NZ+EKCRgK3QfZkxEfXuZuxRdjyZp3ZYuq+1nT/7BRx1m/Skkj8/zrv/aFQ +iLi9uT3gqAG0PRZBgXbYDHGByTayZayZuW73lBV5dZyEpBEJ55DXgbnDk7rmKPDQ +itXpVvXEZVDo3xMaxu+XP/M3THz159ll3//8MgUKeQWw0wHYD9/iWSDmeo0i6XT+ +6cQU3khJv7IvoiK5S6slOa2h3RRoNbtIHhtQVGz7Q5RfoVkczOeV4jo9eiJW3Q8V +2SUhzI8WIIrEjdQJaG/gnDNM8dlO4gnvCfTQVThEtxkYEAWBreo2DfWsKwqi7ZJa +jMdpPGTIvU+pJwDY6i7zNuoHrkph1sgc8dYraX0VzjtfJYLMv0z+oTfdHkNKQ6s/ +zhCBw9V3a5w4UtIKaSKGUwiJAk4EHwEKADgWIQQfiZg+AIH94BjzzJZzpPJ7jdR5 +NgUCYAQdDxcMgAH7+r21QbXclVvZum7bFs9bsSUlxAIHAAAKCRBzpPJ7jdR5Nmn4 +EACMtvbnCpFKD+MzkF3b5ccFQLk03cC7sPzRipKsR1SoKKXV7Vcps2telPZPx88F +zjRoj3jBLtsFNELYvpFANFCLO1Nexv9a79sG8vYrhqKDLT6ecgSJDHbRl9DovAjl +VbAGsHBjbmV4J7o7F6xcXgB4t0DIObe2yU4oiCa+S4ku2p9a5ZPrKMJmbRg8EfwD +2VVfw8KCycW977JV7MuihXYjjrHugI40h76+rTbKbuZLcTBxMsi1Dfx5rpLVYZgu +kMU0N9WwBdCC+x6WBQGmOFMDy15f0cuXYTjDuiZExFaSb04e9O6p3wf2vOjfsexF +IQIy9sXJ7KLfpZoULVzoUuAWgZfKxtH3D4imJ9jeiFKbPomeLpo7vsxfZ9W8UMRf +FCKUZG5kS6HKC00ThKD8qXCOz66Ypfy6BJvvTAKr32Y8lgQNqqu7DIntjNrmAJXY +SKlE5h+B/tVD5VdszimE1tEEcgf8lA19C3iqUTIle17w0WvhJgBITE+TP2SUiw4t +fWYQ55y4oUfJi4lJVck4PuV/ELzwlZmN2A8PSgj7JmivfEQhq+ANGRpnGJ7AvmhA +OsuPfakHmsiAdeo0EOIPy5hYFxWGZcFI8xX0ywMH9Kh4hS97oZInCeOsBfWGWUrL +4NWogLYDIsdVLDxlDT+ZPnXzqlbtHhwuoniVpVWXH6sMbokCTgQfAQoAOBYhBB+J +mD4Agf3gGPPMlnOk8nuN1Hk2BQJgBB0PFwyAAYyCPe0QqoBBY54SEFrOjW4MFKRw +AgcAAAoJEHOk8nuN1Hk2QmcP/A1IBxQMUaPom/NzStJhOMibGUGgcCx306ioq3By +gu5L6Tfo5QoaJINj57Nee+0Dy2dHe9FCaMdv+Cl7cGL6egq6VyIhDyYef/edVRXa +ukzi/dUIW57704lDyudHKBy2KTbzY/WJBNOBXmRG76Q7vTxX4JOYv6whtd5ulyYn +om2KUlctOJ1sfNXg+D0QWo2XjhTkevdewME4aQEaPuJabAcfcr1LoR3Gnsw+l06h +BzuUn1kOMO37ocveGzwLshzIee2b0bhCcc2o2SH7R2xxGkAAleSeS3nXsn0qH/R+ +3juQfwKqonmqF/dMx+JhcbIvGi8TfZ0vzhC3YJGqUdK12un0wFF0c0IHR3ZnbkvP +4Fh+yThFgTxMhR3XiX27+n/ic/C1fm3pN0RnQabUHODlP0VgAVk2fwoa+rjZq+Xq +iwZe3qqfXDQrB6blF5/K9jyEaph3D9Ug7Z0wVyFJ8BBgN4+b1DaBRFt43vTOOx2u +VuRDqGjF/LuBAw97kphFK4e8xAkKfUzjygQqZRt8yFr2LvfaFyrBklEqZXDjCs2/ ++sZkS0e/EZ4T6yaUM2jPzt6MBM9A65VZE0LtvWTLQuvxpbdrwxDyOfqX9GW0RCAX +bz08y5h6EqBeBha0s5Mtdy0V4FgFNNTeTUR5GCTi+wWUkwni3aCOBPnEjHwCWYSs +uBLwiQJOBB8BCgA4FiEEH4mYPgCB/eAY88yWc6Tye43UeTYFAmAEHQ8XDIABMJkR +vqlm0GEwUwRXEbTl/xWw/YICBwAACgkQc6Tye43UeTY3wQ/+LjebzIjgcLJaFePu +VICRZdTjtyj0EEWDc3rjbYUhLH/oMMDt5wjvKaRiF5TixJdP+BqbYOaNbC1q1zSX +e3WKp7rKf3Y23A4ib6qpI8jiAG3vZRyki5yh4Upe3BsTlRHYVd4O4pWzNktv3NYw +xg0HHv6T7ZMs0oGT+ewQDbVpovWaiaaLgFPtFYrN2qPhi66J+K+QTNJdTpvWUQo1 +m92YRVlG2C7rx3Y1x2do5SM/vhRJ8Di9bMU0ZCXQGLoNedTEq/3OgjqPUUdEtcUw +f0jO/fPnaEhaqRDjtTteGNx21Iy5adM8otUw4XQmmDe7makdmYTi3LDTlOVkOyMl +nWQT4k601ySvnSmdRwUT7vOV7pqUnHPTklBwoWO99/N0DF524LW8/IobNuUyX8hk +Q70krpC7/suT7cq+l8Q45nJ1zTNnYNUdtLktB4MwQchedynsmPjGjADpqgCFF5gC +yY25RIJ/S2CBObE+z9Kx9s+CAvQyoTYVaQdwXmavybHpPmocXGJCBG0V6JAkJTpJ +DFNZM4MstcAltUH6JgNZ5YkKvDAzLBFXROvo0Se4xsEiMkhPixXqqtiITiynQIIg +Lgb9BQB9MxZ1FD1E5xC+ayMuD5W0gXGNQUNflaywJHIGTY66axrIVXPXhi6vhLWO +8YYIsewgcR/rQDc9kc5SGBvDxs+JAk4EHwEKADgWIQQfiZg+AIH94BjzzJZzpPJ7 +jdR5NgUCYAQdDxcMgAHHT2rJ6TOzBn9S8z+kWexnFbBwXwIHAAAKCRBzpPJ7jdR5 +NhsQEACf8Cwrte2o8ZoUo6GhLasJF0Jkh0d5kC7utqxK3056ykRz4QcHmacWdYzT +hZoYtsSzM9UudclTgObbRnnGFZz9X+UlEzM/D1wgQ0uDbdaYbMpNtexChRnoYugn +gzhgcZI9kzWXLSGeRR13TVoqHFTRiDkl69OCxGf002MoSYKAqwUUoaBnb+uAoDFd +pj+UoFwKqcCiDUcZ00vXtfR62f8i/+kYHjVMMrE9kksk0Q8Q+cj8K2e7znaLD2hJ +Wre2ctLUX9HON2Xi+Dnw944GtbdVMIZjoTgeTphW+eGr8B3+WHYUoO1MHMb3eezB +ZSZHKbYLgPLv3qz6dm/VHVBR0MOSJu7y2ljDIb4XAvvam0btK/JeothXWgUr+ou3 +Bjc7YXH+Q4KYgJ1ALs34PmmyTaKmT3lpbI+3qyDcvx4yEGZJLE3hE9fuOwYLvtXC +c8+wxfLpRdQ7puuFTAL97i1eHGODj/ZZDmUivp1eUzjoRUTDyuvWOMVtC7D2CHai ++yRQVtN6uCinTwCnhlq/+B+MMrlEL92kNEvoVwVkGsogTupTiUy9DySk4b8iyKsy +thnwN2zCF+GfwjEDetXJnO4kLQGc0TX01TSLp4b9mqGXKKYZyp2tFOJm3+QtD4/1 +4tpGFTZWqfLDzCNXUSXUQFTHUFcJ9guUJp653054YfJAIhl0VrRJRGViaWFuIEFy +Y2hpdmUgQXV0b21hdGljIFNpZ25pbmcgS2V5ICgxMS9idWxsc2V5ZSkgPGZ0cG1h +c3RlckBkZWJpYW4ub3JnPokCVAQTAQoAPhYhBB+JmD4Agf3gGPPMlnOk8nuN1Hk2 +BQJgBB0MAhsDBQkPCZwABQsJCAcDBRUKCQgLBRYCAwEAAh4BAheAAAoJEHOk8nuN +1Hk2o5oQALUciYUFb+EKd0pz5zDYpYTLxyzFk6d1mMVJCejG8ZiEJ5Jv6FVYMvDi +Gmku0yrIjnKe5vfPXGHOQO7WOBbge2M/VQcmQp/mkOEcvAz+2lF71dPHq7/RadJF +LmRxnvHhbDANl+lgO4LNWHEJRN7s29IJVBzrfOXAoDgVs4gKjVK5JC4qNA7be+TI +uQwyCQfWs6tmOpKaF578APfYdeao3kNZTe85ahUm6WrtVEBcQtv4TlxY0X4/5EBS +lhyNux12fvA/0/s/iB7Of+SFHbj7xZ/Ep4R1BxmX9cBFaNVUD9UQUkJLstMb0KnF +75PRcohPjGnPN6cpeNwOX3D2zAwn7mGeRxJP3ttppV031HzzI5WBiKT6jCONNuHS +6uw3yhfTD96OHOwhDG3ikmOh8jO7cqAP0Bdl1TICZ3RIMqMR/iYLFmLLrlqGI3OZ +IRMMJZe+7C8uFRHN/hX3Y2f41FC7lf+IKfTYL33x2CGzTlW0fQIz/cERkvHTIY+t +UjOvC518F/8Rq3+MAg0eoa/hQR9v7c4vFBzC7V3Ix8+A1MJq+E5aEqsy2vIBoVbM +Of5cjUy5q/bCq7HU5v/hr8gzQHArfvIYgkC/AXfWM17G3DR2fsUE+lyc2ReAneMr +/oqSl3u51ScSAHMeN6/6Le73aZ4yYwhPIS2M/KDf2wNURv/rMc0NiQIzBBABCgAd +FiEEgNFYI7f9FWH597zd3DDXwjy7q+4FAmAEHtsACgkQ3DDXwjy7q+40iQ//am8n +YLA4VOAw//lz8CMgk+Uyn5HS2t2aAdMvep5wAVPVGZZb5Wa5eoNh4Rg5GnurVvl2 +N0OXo57vD9vXHhJkooA3p/UaeVMRnilNgSWdphW1l4rRXFWCw6l8frLp0iVq4yOx +olOWTrWmpCYI+fgRrOknnaiqUS5+TH0a6RJtFJsO0x7wjPobdXhY6vfnhBIzdfnJ +/oH+EkYbXhtMNtpUT75bywtB12Bj6Y+CPbel7u9yMOwBK7R9t/56rpqF8WwExr9O +wJkmfgVkScy8SOBTv0Wv+jG9JSGZKVNqCATYnKga/QgOMuDmrIbIe+OMjgRhiSfc +zXBVWQ7Xd9DMzh5682+DEiK7cawBmpoGnJNkERR0P3uqn8vn+TYkEHpvNHQ0kISt +/9IIiI9BOX3aA26xaD3RMSldsCzq2n64Y3THwXX2hTT8FCYLSAlrdlaqVajsgAsJ +HimcbDnPVmYfq2YlBeEiRbdeeZijKO/OKmgKtSble3/7Z8JylyCIGsZzYu65ZYr3 +v5QfSRSmJYPsG/MvI1dMpiohBs9o4/JYrph6/ulgZVMaMqyWnAv7+MsBSApXPRi0 +13k1oInnO+toUvFWh2NdoARKzCQnVf/xozkhSvyAbVTM58jTZQjsAVIOUAKixeRV +7xR99VUoJYDrZKSewoE+cHkXWYPTf081wPBDdhWJAjMEEAEKAB0WIQReYbIXJl2p +gHojxf9N+rJwyqlt+gUCYAQfFwAKCRBN+rJwyqlt+oVSD/9nQjSynGhzlBF0817m +JNRH3m1eXEeWc5vbuEkMHTjphctidfhEgmC5Ay/DvJlN+HNhsLoYZb9It5vyhkPE +AM46UroQ4mcx9Sj/IuJNrUF7UBLGx9TWDx+7UQIA7/rCDnSdMfHkX1l/1KD8t7yi +sTXRiwWvIn6pEwlZQ6fUOgzy2emZU7l1UlWQI/kWFb2gmkgAb+/jStbjsIJIRaQC +WTvkasgU56vCu5oqb2/b2gUSX0MBTIboszEZxnZe1z15oX/RD/EU3zPr0w4wmN7v +dLBtqbFxbnuVhDAPJH4zRgPdTB9E/n0PeFE37OxqOlC4eQJMKrFr4yw1nn5O5HMe +nkRHnXWQHwMDSE8ZEQ5OB3BRC8J6eUz5hk0oUNepcag0h2DUDsvSes/Ogf0azipd +P3h2UCNrNqe6RXKO14JmR9028Lpps2LxOncjpoPKWw74zD10Ts3iO1IuCOc96Miv +Qtwbnu5pQhq/LyNKmXsIkMVv7oW0Ca/EuUl73UVXptwLyJJTEtFJgXibmY9NQ9aV +Ii7mJOLopR8bqYP3Esl8Uqtk/j2UsV+Tl/V4a2KgbpR0b4cmfGJA7SyrtBWRtVDS +KfzSvrZkvC9eAQdizTlcGM32r5jesNnui/HyBcRjX360gWzzMeOdEcHqRQ27qimg +Qk+PhMXfJ9thcG09Tri1Zt8rKIkCMwQQAQoAHRYhBKxTDVIPLzJp9emDE6SESQRK +rVxdBQJgBB/dAAoJEKSESQRKrVxd1WEQAKIOigIdl5WR/YqQrn7u8nXdU0ghMPNz +9xTQvbIQC6f+A5Qk1Lwu6mD3keKEKu/aQ6wN1DSu86xAKwnW1ZRzcHJd1HVjpjNI +Q2j53KmPAtMjQSlzsUz1yfp1wSai4BGa9LbobIbC3nbtndiUmbYVtvn4fGa6k2Qh +tti+TzSy3wQ3lPEe3aVD+3BWr9F0kOO5f2N2Os6iaF4ZFffn99D5qry1K0sg3IBF +fLryUVkOUokHV5W5TaKfpvM71iJU/Sua6E0XvDiD6pXksqOVG3kQNqa7AEESzPHm +2+X1XydUxFkXK41F/8z+mNOy1z5wYz3QfL9gp76IV48jjYNaIFCkq1jQOlOo7YDa +EvlKJPJ/0/eejI6mLJO/7irqYaSgYlCTe60SHLMjmx4rmYi0YEdgyEk9tnqnKvws +SYdPZdaC8Kl3VSM2lg7B6AFjD4NCvrBcbKgZBNx/NrUg5i88lHFmK3ErGyBSFNoL +VbEsaEzUm2Wml/S58XOlxB7vKSnVL26WfedqF/W/6jihABb0EN6I8Hraa7/V59dV +iKa1EmvEz64/C1J2nAb7cnNAPPnkdgwqrsBMcP6GXPpwOSA9U1tcHSFJfxuMuAY6 +nWns2e3cC6FpTHR9Tnnp+wpv53Nd0CYdo6jYngPPaPRvQSZo2PcYNF54lq8UaowZ +vm+emPRqJ59AiQIzBBABCgAdFiEEgOl28UpQikjpyj/pvDciUsoc+WQFAmAEIpMA +CgkQvDciUsoc+WQW0g//TDVm35jty3V7Dmql9P2ioDIbsTGb1RTGdIr1p4gLZTyA +9jbJyVpEjyUwWHa/DbAWAOLYkuPjujFH80r439kKYvcbwNcA6I3P8nvdYIkgpxT6 +AyF8YA2lLWB6MWQy93Bm0R2fk7J7O1I7/uvBLjs3pbklhSyQsDSaPD9VE5jJ9zYw +FdYkSEqcOrC5XKqt9pp9e1y+QVTWViXvOch9l5NanA7fMEpO56xue0EYRnXcxfov +o0/unBuUcFJ7zwYmFTAicKlBWmErRcV3n8DcTbTF51ZyMHtkq30K/ZQb/f9LVSN8 +1Om9gspAzRpUP/XB3IY6cnbpbIcxdgAphm8O8bhMjCztjfPK9zcwhmzAprW6f5S+ +vfl5ndGBhNkAcFdEJsODVVPYQNR+nxfUjfyZTl3/lEEpdhagkjkw2DPStpStGKDW +wNnmGs1RMNOKCZtnKI1s+oeBFxxnUFQ+/DYcjWz+t27QIAZNx2vGbND0JIjGebf2 +WFFpDXjqF7xaa0mRfCUtu7jyuNAAj3eg+fARserqRugyoHsu2QlGI24HGyHQO02e +ne6l7+n5Y3M3FtgsLRjPlKUP8gUO9xW3Bpi1+pnaSzbM85pK6dooH7tj6OF9pNXc +SMf1Fq0l1Fw/gEt+H3bX51i2eJkQfGcx3Fr+90ibVYsStFh/uXs6bH40M5q8kxyJ +AlUEEgEKAD8WIQT7+r21QbXclVvZum7bFs9bsSUlxAUCYAQyziEaaHR0cDovL2dw +Zy5nYW5uZWZmLmRlL3BvbGljeS50eHQACgkQ2xbPW7ElJcSndxAAiZFxjtM3OalP +J/VI8yF16lNHrHR1KMpSt9azMRMRvEx2B1LkNCxCFL+ZiIY4SgXdG8pt4nRNRUwO +h+mbPIxjTi6BU6jJbNEV/x0aZHMvthPXqzY5T3ZcfYxvvAm2PiOE/T37Vj5OAlkm +uEhBi9TA88wpjFiMzNvkhXxnjiezviAStsjADjqxJ8cipX4cTcoqt9A+ftdEp8Hk +qMWewMBLkRWizDFW7uXCFXGcLvi6FnXAOvi4CU6g/VUkDhExrqA0rRNXdmTJRNDC +WEGH9i/2vafMHziEpBWDCLESSxpjt2X0YAEWr/NSWRfiygVkl23mC+Cgs8N5QUUb +/w9BeO0kagaelCak28aHvfJRsdD7qObDlQdhWRWqXZlemEcHGyaMsVsZRDArPxe3 +y6OSeyR3c/cET/KalAsYhC7LL5YSjeVL8D7fgSpMahnmB09nmMztWFQ0XXMnvhBR +ZZfwM+GDeIxNhVUb+R1hgCibc/aMLZvzZXqF/urupWVAycVzqTD3vi5zrYFEZ0C6 +q+YzcHENHN0t2HyNlGFobiTmv0DQiuAu3Wcpor3zFAwaHIbZiq6jhesJOq4vAjVT +dVoYY/NhwSSe2EdaFuaDTh1CNnk0tpAKP/SxQ+3Odn7xQZ0wlKl4vFl3EiFv+dD+ +q0M2KlEjaoj/d8kunKPnO+A/kS1ene65Ag0EYAQdDAEQALxyG4hn47Yqk8SKE03a +vuNFlLP0NFWg149k7csVIDRZNygicf+6RSCZHSr6ep3gYIX/f8xsmqSyckznIerA +gCRmr5TDqs7SsGOIyMetOHol+soiJqggunmX6clkVFT2KAOecq/3A6uw4M3JNlvG +XeSRtsMlSHTdS0wK2m3n++VVr9tZ//NFlmnSnnAOAazomM3Od74Ne6fD9xRfFF9O +l4NS29oXqwJS5NpsCU0nfoxEEADFRVBmLiGFTbMN0LtBLzciznTsGvKsZNdBAafE +aNgW6RFYY+eTdlgQbdILwXuU7TE+n+AUhVaWsV0ldCjNlFdUhTde1ldTBfycpBF9 +8hzdV1KguE3vpJW6xmPSrXgtHrBzFHMpMEBP59J5cRsoD4kJU7IdhGGnKqZGVmoX +XZOqYDXs8iJ74PKye5jk96ooNHO6etX0lLrb7HMVJIRXkPiv3Oj04QDEZcxrxnqZ +0Su2m8S5/SLK37W4Rnp/KTWaifUPI0xyEEfssz/i/fdXta+XvoaMSH4zHzaXQnVY +QDoN9CH312k0N+PYSDlxSVMinBn2Lh1JTghRDl+Ww8GplcOSoO8k8hRPeqbXMnCw +fpXrU7GOPkMv7K98pAZx47bohgVNA+SGY83eUFlmQ7MdhIiWu1deLJT8jQoFz2aN +eW3DxgN1Ltqxh8e9ABDvYTdNABEBAAGJBHIEGAEKACYWIQQfiZg+AIH94BjzzJZz +pPJ7jdR5NgUCYAQdDAIbAgUJDwmcAAJACRBzpPJ7jdR5NsF0IAQZAQoAHRYhBKcj +aIbzzMqtFIon+A6YQE04b6HZBQJgBB0MAAoJEA6YQE04b6HZbYQQALP5Em7+PaMd +nhtyeGEX7pISquoZOuBA4RV5oWkJtCjYjtWq85/dDRoo17EzIkxhJCUypnELwavd +PVOrKmDNv36mrdtdkOe8xsm+ITN4w0EbMif+SByvXtTEv0u9CBYfeq4EKCig1YcC +glUPaTJsmSLZUv/k+d+dQht9FQaEUk9ZSYjpYdU1gZOsfzVY3FMwLpUlGtg6JoQM +ObpxsW9uNSYUbEDl8mFfc1odz+lFw3mhU7Nov8IW1QNMrg8Yu6hY4yQkxw8A7bs+ +JBz8XKVQXMP/0Zb5NROuISI/btPDkmQfU6ruD91cPVXXGy9PluV5+E9g7Cs/RlaM +8TmAp0NAWKQixnPHoOwfRmuqYTc0WWuyZSaQdE5z0nPKB9Wc9nGUdZhXooqHADrm +6TXFk/4w2xEkKKneGXHHBCaKhPjQRpwcKm6wVJ0gSmr9X9FLCjrHu+K5Fry5UkX+ +pWVsbdL2gIyKK5FtNx0ujuAlZxE94PStQUC74rZ2s/ac6QqbD3FKEW1jcVe1KPMH +q/6+JzaSN7isIi+s6jsXg7K/sYMh5J0h6heMpZhoIuMGqQ93doyA9rRa47wLB4g2 +h1c2hx2uLK1VS4SJ9+0yvkNoNJSYGzFoMc0UnBVqP1p03sSBxwd6F9cs3bvOE3jX +XslUBcmyzFP971eKI5Kc7MwbfbM4kFoWWOAP/27m7zRuZSrAkFD2UCabCUWbEQwp +4vafcYjsdJFuennaLhqybQe41P5IXvcJwvDIjzJXfgrq3IyBrWNI+fZzCo3I7XeW +Ldm3McXP0Q9X/UmMHuZ0aBqc26OHvFH5f2od/hwc3G9sB66sB4/rfWBOHMWJHTkN +nzNMljTK7kPC9YT7n4DYVrdPTacvXrh2MkHGz1hEgznlW3VzF1Mk4qYBkWeIpcdX +wHDfHXDYWIVXWtrEiqBMjLDH8Bpx5nee98KvFQpTzMbU9lE1rInSskw7+iGRONEB +XcGs3fRJB8NvALsYMp0MU7hx3wQWmX9q58mb4qXvypFn+IqTOuN1AVCqSVEDn+gc +dehCG8vkjOIKMANfKEqRrbQmY7CJtI4BxkJwtUCTVPaRDVdW3RTv4K8K8KAM+hVz +7rnFYTONiO51yPCCuVHSQ9ivZv5GohbyDO5nNTve1no6Fzl5l/CSpb5XCvOcGMvg +MWP22nlLGoSNG4g3TWlUabxrXmPEANG7D+qEhhuebeFC6OpX2i1JgYEpUgoTFtFC +96299K38JSWRK/x0FPigzxvUkxVt7rG3APIPJlYQhYRq2rmDA4zRQL/ZDtFF9+QH +IIvMDlYYZCLKlxoEjYlCusJLiwHiO5uiHDiLRA1vu1qeJVJ8o435g/gRLJALZojZ +1UKhwK2BVhqTmCWbmQINBGAEHLABEACob9fgQVEt9lqNWKPyzMdenmg+sIE+1ZXw +Un6QzJhGedE42FY6ov6NAzYh08DOPYZsxpU7C5vX9nuM2Fp1tKgGXIfQZmc6EpLs +YmPsKpAFOHfKs1SLbcwgc9pgLvJ6ZvUS/c2T2SHxMStHyFlJbMkLd8B/DQSx8XaI +vjlHWiTiLv/+UuAfd4yQeatMyPvhnVLuUf5Utgdvl5Twwm47IxUMX9426VKg19/2 +2uJyWN0kfI0uLy7hg1cHArR5JOoiPRf1xR4ZF3zgu4gwCDD1Puv8iJuWM2U0DQDP +KOuH2DdasezHiGCVrQ9LWijTZvpyT/fg1qaY3w/1gx8QK6TpsFL3Fwxopx2VrD7e +2+FX3mmxfqhJGlAAfG0gOpie6t2WH6dfcubWCt8hjY2gN+NT24gotDqk6Uz3TgLD +G439+A6Tazji2shvQp74iTpVjyiBsdjF8ZbLBX1mGFLjniuZxuzOk/skUaInZ6g4 +SGw2qy8f0uBbdPxeIuNe8QLxEotXt5YCh265BDp6QpnHh5qfFc3IqwBA0hjkgvuz +H+uNm1lA2dlKscPsqntw2c2epN4w/H8VZYlv80KBEHx7vaneoVMxQkYDTNA2pJJJ +vWO1fKnIlpPMu4HWeAeiFOYnju5/Vdz4JuBmOQ9ATiHfZDBuC35IWzU1r/Tq6LoP +IqKm13xJawARAQABiQJOBB8BCgA4FiEErFMNUg8vMmn16YMTpIRJBEqtXF0FAmAE +HLUXDIABgOl28UpQikjpyj/pvDciUsoc+WQCBwAACgkQpIRJBEqtXF1npA//RSkQ +vkVQqOtQdoZliUKFR2w1RZrH7BXRMDudrjOcJ44GNuhrwPndnDYXEmEmIKKXamT3 +0BwDiD9sn4Xmwr6r8YkO0lE9vvL6vvP385P7mdDmd0uqH9jm8fxQelOwuf/8IAFo +hthBi6ajfsPUTgGncGXqAUvExlShhXZK/rq+3lWFy+hhyxKC0nrEMGskiATUY2Hy +Qoiy47BheAWQs5IsQfc43QS/C0ySgrNsm8KENlUcAAntRdutL1JV8ORlpgRUvGka +fT5vKN5tT07BpPh6ry3cwSEpMaQQmq5CT57hf92k5A2idEh/u1YDNGnIrRRTLIrR +wRucSoVfgrxpHbFgq9p5bL6RkjpIm1L5ytS6gFF0Bt+/QuIt82MCfTjCykavI4Yf +O6qkewA/4aoEecJ0z0QAflg8sJcpEFTiRtnMTRvFqfjYQcMTgZDBS7zaFgsZbqc/ +coOf/uozBzBqob8vPBDeiSC4Hp/a/Gy5vw+ADJgQ5OAwcp68KdBN5EmSU1S+xqyK +EtKAr3CKin/+e0kqyV+2jaR+jBcPveZK89MEpEMxIsGIeSZh4OYkc7bS7iPO+Eua +fmek5uSbhlpejUBy2gOAj+W7HK2mpte8rWWEueVaAOj+bFd5VNgt2s7LS3D6jy3n +zp4eAl9PI+K4Yaiyy4P2GVIyRESj2n4OlBdVMoyJAk4EHwEKADgWIQSsUw1SDy8y +afXpgxOkhEkESq1cXQUCYAQctRcMgAH7+r21QbXclVvZum7bFs9bsSUlxAIHAAAK +CRCkhEkESq1cXRDGD/0bkA471LRZzYURNP3oAITwEy/6NKcVY3EAPe6gQVMtOI03 +qQU8nSLG50yNHlLETfN7zDFOWUAbgNqnss7fP3HUsrZ/XUbuathnkTQyVcmQfGYO +jTXQI21YsUmwXUsbm8AHCKToxBpIe+Z0nSlqjJJg60GK0d2g19IgE4kji4575BUC +FDUypkYNh5v6/0zZ4vriomRfeHmZ9ne+XkQ0kujjpvpy6LIhb7a3ckC/X5QrjGsp +yPeQN8oYfZZrvyo5JmbOI7XgiCmNTGIJP7C0l0UEMufkmCvoetbhlj6pUWJBsCHG +bZgVYuD8hWmLoAUzp5EjWjMVERpHncI3TPevlwqZczUoDYsIKGMqrowzZj88PdWH +Wlyq6dvXTMlCUufFZzPDsCjC6vPxhKdwUq0Nj3oV4HXfEHydC3XHmaFv3oglLGSq +Q9VuCnzvpNnH0MRIFxBKFUR5J8rBjNXDNN3UtXkf927e/l7JyYIJ5XaHUzlTK53F +EZRPeeJckyEd6NIrrm/BC73/3mMuAQZ4033PeY3qD+uZNWp8Epfs6idRJstkGzK8 +tlOyfT3L/MkcBYXBVEiyH7MUy2SbEjTgC40FtrmGP0YpmZ4MPj7pUymFps/eLRQB +ACnHum12k2fxxbyO80DWge8oMRHQMBr+TnFgGV18HmjYcq14LhchnhYC1eE0IokC +TgQfAQoAOBYhBKxTDVIPLzJp9emDE6SESQRKrVxdBQJgBBy1FwyAAYyCPe0QqoBB +Y54SEFrOjW4MFKRwAgcAAAoJEKSESQRKrVxdfBUP/RAFKP+TbfOLzFeK9oNDABJI +ztB1xXXoqMyPUoLqqv1AEdgtu1qvvkPiaqBLYCHmA/sm7A9+p4lxnlYC38ahxMJh +cZ/QXhaQaEOU336WfsNcu4Ir/4ST3hUwsFtxluSEd89/IfFiIs53ZpTtrH88nxJK +oXa+U84WT6xP9OHW5nvvH5bLveQCpDZCkW/Q2RkbHMnlPaXHAe7nLS8S2Lgy4St3 +ldVZzKDC/zhBVnWaUPuFGmDQnImzwpklFnAXFYTRJ6CX2nDw02Vu20NA+V3b64V0 +BIdgb0Ylkit5R2hN5gmXUCXdftzv302szwhMF47NqPZ4T14kSwLh7LtDiYioDJxm +nYvG1hxCu/cA1UeDxtTxA6tksz+QM8g+bN8ULTDfoNUX2ZFTyk+eF+J5calR6A06 +mxmHGOfc/dbEy4r+ztmSTnrfaPhCiHSBvCYtU7Q7GCa5EKVw9FtUJhY7oNrr15AQ +FrK5EJN3nIxZxHQDocAv7e77jBGzUsh3r0DVOJlHX7Vjh3VcmgEh5P0vb3vZGFOg +SdL9mZ/kuZAdJv8zJlSlShBT+P0zTicl7EGzLSx/sZtGi98TrOIqrqgBEPIJn3Qo +kiIxVSeGfQtz9nrvkV7uvUMe5ABRu6mxNzc6JHtA7VZNMLFhp5imBKneMq5qksmT +Xkpb9bw7IoEPB1ddpBFXiQJOBB8BCgA4FiEErFMNUg8vMmn16YMTpIRJBEqtXF0F +AmAEHLUXDIABMJkRvqlm0GEwUwRXEbTl/xWw/YICBwAACgkQpIRJBEqtXF2LAQ// +dC9eL4nDDmW2YRZExS5cgbMCYTeGkCUrMcL75px8HaNASxAWyUGxouT6XbiyCvIZ +RmyAEsLYOm1txIVyddnHvH7v9HwRh08ystodyXqXTPnluHppVelQPIG071LLpyM1 +VM8qwrT3twdP7zXHWRzPwbUO2C8U9Fu6wiZCZb4Zcooldqj79487XKjPKws7f3gd +kVYR7U3rwrfd0By3QSMlyh8aWe3YehU/zZ6MdxFIrAkHF0a9mrDRINy6BOtEc0Th +Bk5n/q8f7zxqf3Now9M8luok+eoVjXcAjrqHIY7rZ3TbCzV9e5OFoGHlsL1Wieqx +pZMmbS0UN2HGTyB/MpAJkYh1cB1nLNVOUnlOwjdM0PoKpdxtfUK3mtOuoB0TTCWw +hi1FBI6oDYvbuMH4HOuvFqhGMiYmXC6Ln/eCVimWsnd0PsvrfomvJEZ2lFZzKw8Q +DOT4Z8xnopcVwuMq+JbAyVRCsXpqloybMntB4SRQ/JwMf9+evnVh7hQWg6B32FhA +joOBRJTX6DxXYB8nqDVTh1iRUP3jO75rOiiYzgsfjDcDVO8+a4Cd8lySNvjMvpyK +kjNs9pymkuTJwW1iWteZw71pdjRIUSd3o/7zOX08+saPakU/FT5E9xYANR4ZxR+i +SHckgYJbiVYvrlE6LyZ7Ycty/fhhnLJ/92sDCj6wHkyJAk4EHwEKADgWIQSsUw1S +Dy8yafXpgxOkhEkESq1cXQUCYAQctRcMgAHHT2rJ6TOzBn9S8z+kWexnFbBwXwIH +AAAKCRCkhEkESq1cXaYeD/4mxXBxPtjNaet+/3FvwO8h4G6nUuN5PqciXdeOpXKJ +WX+Rb4MZ0GhUxpievAW0JCZHzqFKTUfAEWuhQOYkTFAxINA6G48bdFtyDmAYiRGr +GKglPcYWKEF9EjDfrDhL0a5Adbg6ICtA21e8Y/VVSkl5uHFsjwPgjWmYKyvSw45s +UT99Iv8JztkbbJVVoPSq55rXFasiDSN6RdsDX10ZNBA6ci6uSq3low3bKaNjkTHH +rahat47MGh9YdCdmHvWPI44FlvJNGb9UGFG3I3pKSxQbntS2Vb6WGeXrA1hCMksn +ApoWIkBHytTBOSUnowrCXh2aY+w2PxWZGs6RJTsX/41rpWyS9LmOEf+rtes6vPk9 +D3mGbkv/puRZli2RlPwqsSi4nHegb7ajtbLuOFUHXGi8LSFVYvD/8YxrS02pwsrX +lub6v/HffyFMg4rXzKsPaWv+Q54seXjIw1K1kaNdPTDC3sTuKKr8zzumDGrWYxOL +mtzOwBy4XiQ0RJ9NlsJlNBcyY7P6cSX1pJumrTZMD5cmOCHf+qYHRkWIjfdgB20k +x/vBgutDpP8AQ5dA8kt1RjCGCRLfU9UEOytT8Hf4Kp7SK83Oi9E6Auex8vMMSczP +GrWSkmeUxPJxuE4+5KYTRkcJMl4WKEmQAae0ni0WskXeO/3YujWC7n3ho6+UNoyL +XLRSRGViaWFuIFNlY3VyaXR5IEFyY2hpdmUgQXV0b21hdGljIFNpZ25pbmcgS2V5 +ICgxMS9idWxsc2V5ZSkgPGZ0cG1hc3RlckBkZWJpYW4ub3JnPokCVAQTAQoAPhYh +BKxTDVIPLzJp9emDE6SESQRKrVxdBQJgBBywAhsDBQkPCZwABQsJCAcDBRUKCQgL +BRYCAwEAAh4BAheAAAoJEKSESQRKrVxdiXQP/383ukp2BKlwoMBJacl3CV6wB2iu +i8BA19MOmlxQd3f/V7/3sQBf+4J8H+SUFjJS4x3xBCOGn8u4k08BLTDEMr0ec8ed +EmhR2v/eMTzU0R2t5N7VWnapPf0H6vQbR3njwwmf7Xh6V+UiLUQIgb2ORq+35rg+ +I2pDgPUfKv++4jTzi+V3Xupb2ZB9iWPC1uRCmEOzpXb9DSDzANHnw2QbJ8a2KGMD +3DHTuxV2uprQA01LIvRQrPQw7j6uDrIGjujwxMS8ut0mi7nDohiCgNwvujuzH9Ye +L40xLBqmJrB4UnHV2ZT4uQKH07jOs/N38+BH1Bl4qtSgyGmbUkN+P6MP73CWWHtW +sJG2yG4WfRHteNkzWi4MqBTQJlQm1l1/JdvbRdw7NIvbDSAYbVy7dhHmWFiR70FY +6xHmlmUWA3QyrdP6Fu6DvxZjxCPCui3Mp2qzt18Zb0Ktz22tw2Gip1TI5bfqK2e5 +NcUWylNfsoo7J4i+MK1/zXbKjGNkB8WiNHpc2VZ64njshuBWxuL4oibgUTi2aAD4 +rNVRfRtchq7ZdGnzHqB9FyflAohS03npF2Va4tjx+mzRi7b/QekpdG6gREu5r+29 +m5togJKG28821PidDZdH+dd8cotFlNgBMBu/zbOuuk/jPZb9GBLafC/jsR4hkIwH +Rh2mr+pnrFWxYkfaiQIzBBABCgAdFiEEgNFYI7f9FWH597zd3DDXwjy7q+4FAmAE +HvEACgkQ3DDXwjy7q+7vFRAAoFGxubvIG1tmdrL3u6bzVs4DaCd6yomZru3EgZB0 +oJheNH1Howqai7LWkff4qzDbaz4CGFWXup5aXya2IBbX8CESUDI444aHC185bQfW +ITqFd84Dhj2isf8G6GwxwrbBQcG3LoVDepArzyBidmeB4QtpaE+lWX5TzLwzUEpF +cxzvlsfTDtwiWe7jhuZ+dWLbva3xRHoeXRgDrPVakwZOJ2cvTatgfPJt1EoEGmYk +OlL26luFVtaY7vAOaJQxraqAyiOMbefEgKQmbvbwKc6lF4IQWyZoKillzofdlrKH +Ajo7jsranOCy4NiZz6jXsWc9WoBQBXu0uidVmSTwOum8LQGDo8v+e+2A1yMAz6UI +FBwNw3FFwwZNsscwZfjo1EZQt0xcL5B0Ufr5pibclfVnBFUPt8c1yxjnULQKL4fv +Jgk07Tk1hqlTwq/qpzgDkJJPWK8j7h0RB4qfsQW+hF94QZJtEQy9pL1UjNj6k3ng +jB/OXqc+cV7p4wRPtiqp8BqQPJLsnvbdcS1SUDdML9YafU3J3vj8yRtWqkcQ1gFN +CaynzEwZc39IuRweSbpYkfucj70m+9BXMO/wXdgh1GjBmavciFCTefEEHdpprAnM +dy27Ps0r0Xidv6wvX9XX2cZbISj51y59bM1+NKYmOzNthFl7VE9SxcwrmL4s5Hsm +ExWJAjMEEAEKAB0WIQQfiZg+AIH94BjzzJZzpPJ7jdR5NgUCYAQfrgAKCRBzpPJ7 +jdR5NrkrD/9aw4QPW2rnetBXRacMQ1VC9GKwZRJgW/5BvpWhtgEWnekxB9KLMmeD +JIau/E86hhl4rnt8cPZbtiZEAi/pl8nRV3r6aL9M2Umv/7wxbkX7mdLJCYUuyJa5 +lHd6uEDV6t2FCSC6wHV4DAnKfodIFgwS+Vq5l6+v2Y/1k+2d/oplTRE/3xW4Ae4D +5hNE4MGLUGrb+PgBlaxLTf560zDyxyy77LjPUbm/a7Ud6cpMCI2nF7kZm9l6IU0l +MsxTn+tFLgcxn24Q0LASHUvN1YbhTax6OX3FBNRNhzYDKiQX5o/6Qwq3kms3Mam3 +gLLZ2ntcX+jg1bLfXeCEN/YAVDGT3dTKYhFblHzUfF0QltnklkrI7kOJ1gzGY8xn +rTWdUCfPbzzJqdREcrEYro9BW/QKbwELKsUIpN1lj6U/P7BmQuaU/W2UQY5ll6Xl +SOsRHfz0mOnYMNdsE6Cqr6hQLRrhiK3c5r33lJXs78pHKvgfREGOkwGOwQ8zzHd8 +43S2xC+4nROOV/EbQ7b1BzchsJbkcNMpTBKaXMY1wMJZFuy6raP3QO518OjYkIam +pPdpLBvHia+hsLkO12A7eS134Swlrg0YLTETyeRQqURLYzyghKtRVTwhZFaQKKzP +p4Jp+qkc2SDhXqNZqYT20FhxLBH2Bz5oNzaVw0WfEjw6NrjW3RKazokCMwQQAQoA +HRYhBF5hshcmXamAeiPF/036snDKqW36BQJgBB8HAAoJEE36snDKqW36VYkP/1EU +lC8KnR/dj583OI7EVgz7ezIOi2HKeNTFrnxPIpQfnfnaJZgFzfYkpo/0kPlLdQvW +vqao5xKChtVmePX6ZPWnSlMQJvlv7879EpakYbHWhGibTBR4FHDrEVuJ77s9uOaA +5q29fnAwYfvLkwHPijgJWbYblTpctFQCswqzBKXHQ/AvTDUj2II0BFUAeeBTrMX4 +Lysq1auKO6lvlBhvt1/XYFSpN0b336+7vCEmqTru6zQHx2ctjS1POWYMvD3rjPet +S9luQ/00lp+gzpAhX1yb877YSTX2k5F/lW0NO7+EpqzE9j/9D8XtyaMFh9WnFKlk +Ns0lnT4HrptNsNvyM9gx4NJZQ74E/o+DXzYI+zrrhqkljrg2GnTqSDcHc5kUak1V +FNjDOHHTkSH/J9szNG6BvdhsbSow70+gh1vT/8G7b5nNG2TVEaNP+DHNBbJ22GdC +Oh6TZX6LfdeodbIaJTSvPdqOVCWt1XjzpHihGiggJWQncp5fJ3SQFpk93exw344m +Ye6/YZNh4TrC1EgufGruUVOVzt5TZRqekmhxLCg9ZfI5MG8mRnK3Ecqf7PiIAFcm +ZHbJvmIUBzgVL4KWmE3vBGeg4C8v4lYlmvf1IQLhtA7YBnPg+3ZhZYJQWVB6l9rU +jvFlYwkv1ACSmsxU5Bc/2zLZZJ15KawtClrADrHJiQIzBBABCgAdFiEEgOl28UpQ +ikjpyj/pvDciUsoc+WQFAmAEIqIACgkQvDciUsoc+WSJ9A//VO7mREA0FDDTx4IU +XET7AB71wHBRY+yNtF8zgllXXqiOobVoHSCjZKMYjFhe5qKv3n1/kR0AxxbPWBBw +futKFFoiRgt+SSB3iuaWxJ6jm6znBZUn9ys1t+Y1xydKLDHdoYyHhtg6vrQhs/gK +wBMX/ccGVxD4h2eljbp66YTSByoSRGjs4efeYemelIsgrwP/Ap3iNrYdPjh/uBP3 +XTNQEkDqHzyVTFeMFIkvonNQQsAEgl3QcP+MWq+KBBozjqtgDAoiF0JAaVArayKW ++eExDBUZXr+y7DS5v2nulAfQiZzVB4q39mMfYCoj6mCyLBZsx6Xosg8K0rh46PuQ +b/0TasrYV44bjRF9SBVaOBW8eqWRc66y6OHUX1a5KkOxsDt03gHKYWC+NBfeck37 +xbL9J6d5QsA0yNdbCYvfKqp7i6mLPaa+u+2zBk1Pp9aNgbWzx5CFZxRjqUFf/drx +ao+9jVKzn+cE9XtKouzy19OShdZe3SyLFTvXLdQj7emJN/JUIUgo8BrJYNzsAOo+ +UVCbliVr0dU0i1JQOf7k8iNdNWOYcUZq8sCRbQ9IJnnfVVX4OqRFhM7yzxyGFBEz +FGu0h+hc+sDK9zK1jl99oX49V+RSvCdic0P1EIA63f8doHuUysIigiTyaQkXMfJG +oR9uKm1F4+7hd/xfi5lXJuez5lOJAlUEEgEKAD8WIQT7+r21QbXclVvZum7bFs9b +sSUlxAUCYAQy6yEaaHR0cDovL2dwZy5nYW5uZWZmLmRlL3BvbGljeS50eHQACgkQ +2xbPW7ElJcR0ZxAAn/yWrs1CCw7plbiHCLqv/fk61wuXTFAjqiF77CXvekZulGjr +7eN96LeXkrPCJIai7rJ2D7x2g1wXUiWZMWKh8M71tVzgY4UV8/+eEJFV8Gqmdrxm +enaQFqvuAV6y/HV7cJw1EQCpsWC3sujjWUvOmc+rBrBhkfueLP5EqdMJ+wyaX5j1 +iT2SsxcMNb6rPLlfSTafv2yqvnGhIFL+ZD916ke0tPpzUemjb2SrrTqj7l147pMv +72H2KxR1wXjGgqQMjoOys5bgTBbyzTUFDCbJc8o5c/HfeUnFDfTEvPzoxLL20mnQ +/Mq1j6Za/LcEdJe0liVDzDSI3ng43huZLNOkT5LVLyNqedJ4M1bSI2/TSyTpHOTJ +VWSAUpH7706e2JomPWvKpwYU45WycXveviEfGaMWFxZpInzSWVZ2I0n8sH595sir +FaEUF0vb7PYddh3OsTa/UwsccIQnxgzNqy+o/SqlHwR9nSMkvg6V3T0f4mvqRfiJ +fqtiMhqnxMpe124s9M7II8ACu1fjYf6j0rcwlhreD0r598oOqjmdiIAXRtRtVbW9 +YSLd+G563RAcoSBgs4Xu7557i107UPYOKQbpuGzFhymtK1wBik8DilvkFrc51BGk +UNjKq5eUZHrUFHjYdVXXJW+6JHzECm8qCywz7cwVNBhNzCD9RkyK/hlKh3y5Ag0E +YAQcsAEQAOvMWEKqTinNyE7ii0xbHFEegMhYAkSdHm6kVDcDBu51I/rz6Yww94xv +vTs819oLxPp1GCEwblnry3mD4NZ3vSeefzvK86BFX16tRUmAUP4qgE3PUKNFEWC3 +8toGKFKOAqpEw9TCoCKzyTAQ7qj64jtweIW20KHJ8FpZL9JkoImZSLp2AVA7gmJl ++aUWVAJ6TBBmmGGWBl5St33nYXvlmoOC1CBWcW8qG0wGRh81ftQg0/klzGQElTWy +U4CuPAhCnwYKccnOcOVPjcdp+rgvvJwc02/qX1WI3ZPJFOqr75il99cqreoSEmO6 +hJEL7GUUGcANoqqWUTe4SIYi3R97aqlOF9OyS9+o0Bufl0c9TZYDaRTJrIVs4D2j +xJ2gaN49kztAifENYfS+wzE64YtbgNOlR4XvERs3D+08vwigqATeyApfxRs/VH7g +/G3LVcIBIYJCHdnST/AglTcAQ7iWvwLlhFJ2aSYH0rpMVjBmSlTJmvqKHLI6wLnC +22c5vATnNYzO0Sh9Nokz6nfUUjNJruZkbIIYC1Ohu+8aEuDLThirvwDR03VIWDeF +3BhFQdkdKfkfZtzAY8Lr7rWGxb3HpbR+slekC6dzclLj2g6be48zsE6Az2ek//mV +1farAPejpmA2vC9B5indR9XKNntCKuFU2KRHCShhsw9xfQUIcOpLABEBAAGJBHIE +GAEKACYWIQSsUw1SDy8yafXpgxOkhEkESq1cXQUCYAQcsAIbAgUJDwmcAAJACRCk +hEkESq1cXcF0IAQZAQoAHRYhBO1UExKjPxEo8QscbFRAR2K7tuhTBQJgBBywAAoJ +EFRAR2K7tuhT5OAP/0oBtjjVGeU9BNWczY+/gxEhbBuoBG6+/d0M60fk6npZq2yc +cAIwbcJzh6pOBPPjbA0imRC38Fz2sZotO+Rt2eELT0QEcKDOlvhH/syj4R9+bDuI +ax22A9QtLnBpICrBKt4LazuOC4LzYqScYZmoO4EWXNOZICO7lggL43ScLNerpE6Z +j5nGHO+74wrIY93HUdoRROvtzdRO6n8+GU6XW12JacdeK/wk9hbD4Qqa5HOtNTxO +D4ZjLPS0QuGdUy2fCOfuUgYc55aCf6YJqysr/nX8188AyAKkPBd5TQ8QE2nOK+1B +JC+/gitE4oSpP/oYWjxbfxJcviZUooNImD9cNV6cLrHF+vc4MMDzFqAQlWIuACka +A6as3sA5Ev6wdJyfTtF7RhI8B/V7HGGp0QUwhNy9HCvaVOq23cydK24V2zEjv1Qh +8ak7yNggTviPQo73eVFoh2VIrW6GjTDyrkxRR1Fswh8IotRGvfl9+h8FNn+3bobI +btURIAxzzngjOMIABG4+dLq+PHorctCSAXEf4F6qKgBSnHKcFRpusQjtzNdqRanf +wA0p9lnN+8tLR4Dx1UuvQnbglg4eTy5pVvoTR37jVB/PhNnfVipn+aH4FsizShjI +365Dvn9JRNQNYOHdyu2qAHBoSwldPTlTb6w9Wp7ONoXc7nC28mCQpV2FPhWdpiUP +/1OJFCuVGxHrMc2YBPdiMOajZmu5pqG2Gyt8jOqbyLVXH2Q5J9gRZcfEUd0EF7ZW +a7/gjxsHkSldaOD4TqFL4WB+MH2+WQu+kXo6unCy0HF66LNa3LY4rELiukt22q5X +BwDlaZ8DPM0oTEtieVXGsB6gGMDdktRRFF/um3jyht54zEv8MAXvwQeIMNVxPHBM +4d1pSJq37tPZE2vfbPjHr9zzm2wKNSymR5+CXueXkphYG+dZ5qmkWnvs6kYyBNZP +oxMu4ik4EKYt8sIC2HvvfdhUhax58gjSWMJART20eNFIim7cLBRpmo1+tH40M26K +Bhzvuh4EPX7WYUge7wXqqSIgko9C0FZCTJBqKik4zMtZO+2k3fjbuotHlV8ZkqRm +xsxZvicQA7TbIl/0CBiEZDVLE7f3QzYdedaFtJFRtunFEF6ipr6BySo0vHbmDx5L +Ws1gsNvxxw6AY1uwS6LZh9v3LJPL3hzdkKVfDRZX+wJwHgfxC0JwNL4+uRAcJMAG +wM/Z54nv3nOCfVlANcZxJ0+LfH4+gE11hm12YLO3wyprn3MVx9Ou7bJYaPnsxyUo +1fa+t18WpqM2JBkIJWAy6ZTZHPH5LCgq13simS7zaTnC94kGaAsljS4jATglXGYX +KXTVlr0oUlNgYsNoTT9yj35WJXkuIZ7GV189g3gogTpumQINBGAoEk4BEADG6NQ0 +Ex5gy0OlnGlFZsTpiZV2LiUhACFj6ZHVEYQQNWgEgRnZuZeAXbTnFywzrJUYhx51 +pNjxfoViN/4Jyn2oMrmaBEuDxEwhVZDsMTzb9dx0MNnmjMr45z/4EGjln07tFzes ++J+0eVizJOWehQ40IEwyCZIG9QOfsC1e1estm0KLZKWb4gTihGFSahM4zeD6XlZ8 +krTlkWV9i7+oatCkNziuOTf8+ZXEqoNm/dJxG6pGWcalo+DiTE3l4HCFr6MZoiCo +WVaKYn1jtIUeioDVW8zPalt3VcPmjvYb6ZNHhFK8d3DDV17wv7TFJIOn1j2n82jz +bDZwQAWIA6iKPjXDJJqmv4qcZ5a5l8qirhjZhQEemftYsGBLTjx9ANfPcDFoQ69o +jDw34Nchig2nJ+7ut9h5mjeB9QmOx10HDposRaZq8yPChFpheHNlKwh9PYba0Z9V +b3mI04ywkw1oGc6YQD/VGhoGiMembzEK110DsCcZenD5dOWHug5LF7QTH+120eG4 +Qt0RcPLqI33+3FUOjzOQubw0QATYs8Dw2E36LVOUx1yrtDqjJs/ZXfr+LCfaZRsh +vYfcl3soHCXxVqEwoXUmxJK741RS4ej8w79clniZPMLc68XpFZ7qsKoKBHeoG1l8 +XvuAp9EpW4vujsehEwRudn1SNoc5fTFG9k8qlQARAQABtElEZWJpYW4gU3RhYmxl +IFJlbGVhc2UgS2V5ICgxMS9idWxsc2V5ZSkgPGRlYmlhbi1yZWxlYXNlQGxpc3Rz +LmRlYmlhbi5vcmc+iQJUBBMBCgA+FiEEpChSlfx7GoFgAGKpYFxm8A1sl5MFAmAo +Ek4CGwMFCQ8JnAAFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AACgkQYFxm8A1sl5Ot +bBAAuI9V8uztBX+gZhvI7LYRZkuWzmNa/qiDGHAF6DIAOYKqCZUDSrkF9qsIkeeZ +dEP7hLoIo6TkprvF5iLFTfzFWPT1VR9E/itBBzEZa2VrgT0ye8gYrsRdNkso2vqZ +Qd3muDJvg9UrT37+Nt0eOpFAfc3JYfqwjhVIngiNLwjGTC5oinEesdDCgqxo8Z6e +6NyMLdDtS4W26q7GxcuG5YcBoYi3pjxJx8ZGsNHqEe6RvU3YGahEgWWY80xCRarm +8RVYgfU4LZfm6D4o1ZO3B2UmK6+TgkTjYWzC/yMrcbK4lyumB36OCSg8byrJ3qUN +7zKKU0DIxPqFFCLxxhYxf4QrMPik0BTgloWntP2VFLUo3DxJQKAqQULr+H/WEgbs +gAuU8U0VLTlj9sCXn0iN0pHzNaEJJ4sz5mdIWOdJJobkbiQT+xAGwfoKDff9l9fu +82p569sK9U+omHMuDfxTT0X13U/6d2m5nIFwf1MitshU8frYxuZs3Lp0Qi1Xsqtw +c/wrIDt5c0M4wluypuz//eRLLwsMn6KEl1/Be/RebHSbFKOA2tdsc/hfABsVQCFp +RHgBmpLfL/5Qwd/K7dKKpuh/7pV4B1cNgviKwMFhhR2eGzTfbXqxytnYmJkV++bK +LtX1SkNx1TBb4lqICzdFOV5QjtjPBVZR7Ugx7sp7yZn4bw2JAjMEEAEIAB0WIQRy +A2MOLI5yclFoT+vFzl3CxULNWQUCYCgSfgAKCRDFzl3CxULNWR3gD/wLYa1UBOMs +zWu/BTLt42QHcd6onTTboP4S9w1Gs/ak5iQiEN45CVVLbJ5wS1iaeuMZ85fOtcEv +J9KqMvwvGXlsCD/+O0QJJbEpeJpHarj4ZtxaL659ipciqeSIQAsAb6/9SKZZ7HGQ +FD6DAF9kzV9HpKnNvE8BGQ8I38Ez9lfRiQuD16r4cqNgS076Z1AoQU8ES5N8VO5v +1fbAHsyLq9ZToE28BKGU4o59Fj5uqpfDrm0DrnSn053jUK942IGmIwKtUAn/j2sG +9mcow47xjifVTKuMXyNGDM30n6ITRtiTaZsUZGIw/yKM3ZosuxobxvJoef8B43Mp +EHYV/xZHYxegT3xlu5h8FlUQrr/WR7FtT7Awlapm6llIa/2G0nrPhQlX5nN5gJiK +O92rOvKM4wTadBjL41jfYZb5EE44T51hCpJUB1g2GSQkUpYM/MgcNfqmq7+7bAxi +nej/iCzhziv925mUOhIGhAUEYCZMFI4tIEVFFAUb4pi1CtXo3V8DJRu5TkuETwDd +K+FfBU2e3q7b0q/CTHdHfD8T7VuTaYm01meCqWG8HS3h2OSgtWrUgDBDKAU3O83K +K7n6K+SAXW1iOaUzW9GErZnYqlEOMJVQn1pU+txUAAdTfQy05mUvCUvHo5VOcC3w +ybU5HCZJ3cWe6HCOviBheeIysa+iSvBAU4kCMwQQAQoAHRYhBApVt8USIzlChux0 +w1OUR53TUkxRBQJgNqemAAoJEFOUR53TUkxRYSUP/Rt9FTybIXwOW6FE3LPF7GvE +WX//loxKRhiBSQ8Fwmkdchz3iJSAcZ8HgcISMH5P77Ip8U9z8GAucy46Bi7tsais +WOUVxu5gvh6zLui7PkCRubIxcCxA+JjX5oZm3LSy49s1SEC/o0MB4TRwpqRfuEot +s6H0Z9eHzvJKjoeX9Ku7SjfSSRWY3TWMMIjQBATRZGcTmgA3iJ4/9dFmBGsYhQq1 +WsY7bCmCahemAmAkdCxkB3hr8BA1Dm/GHgL0++txJhjCFwKj89yh+Or8l/C95qpt +S2uAxioDM9952DUm65oWtApsFs8VpcJxSdApmWmH4s8/B/ESPKv7apLq3BSgLy4U +A4FdFz+XS9xw3GItcPunzGZQfI6Dd5jPUMwYYqcr1cVB2vTiQB//smNjWq2skWTK +Btjk2xpPOMCKC5mdGI467RT8HpDMcKWUbg1kaPqCCzpQ9NJQuk+M9+jw78MELtUG +Vi8wIZSZCjR2zXduenyVUWmQTHSNfS2R3iWsYH6m7fL2iA9j4Zi7sEjffGbLkQfQ +qH+c4XBDWNzJnC+/jQeWKG++zcYtEHv0mk37agw2qB9HQdTO2xGJcfNF+dervAj1 +O2fvasOMj9aptRZVpKVMs25zbkplBR5mqPXven+SraDOQb5fppcPrKPt88G3e+dB +uBzElOXBWpIsMJuvutFniHUEEBYIAB0WIQTKYZ1lpyp7rfyW0oAZZBiq63TIoQUC +YDaonAAKCRAZZBiq63TIoR41AQCLcs+WlaZTZ0rg/cWhvApi12mZpXQC60bxvmrt +TyHH4AEA2pJLfGVHOualRCNbeGEYjfC0WiC+EYCC3NBVe18slw+ZAg0EY8vQFQEQ +AOZbk1044fA8gmWA+7okNwrD81kk9HyWwPcrztkzXyDPJBkkP7CezpNJc6zH4Gam +i4dmC+HcVAAOP+GEuOk1KofkgfTFjueJz0G5J7IrHZa98brbLHBdwWTBPGhakXe2 +DRy/6RPhUDcx9WPkZ5u5LgX0m/TVa4aTFSWXN3N4CgLvQhg04pX4C/uFflw5oICC +8MJCaFWdDo3Ph9d090wdWh2U+wpu/zKZWx+9vxTNDp2X3DWAi73hLQUJB4R49KKL +beMchJjCS79/qG5AbFKMDLzLFpvRpmyGX3xzekYZ84kee2YfA4aCpX4abWFtwGNz +pfzJsvYoSv8u7jEArfFJCY/607ow3F8FMJ6jx9dFP3mmqPu3dAci74ttViuQtDpK +32Z06BRSwB1Vhcnd6Hxj4J+OYHLA1GLM4YesSnwmwBxLT5r3IEv4FhaFLgEv8R55 +pxEtP2R/MipLU4P9Ev/hBuLYYsYWyIdooVSfjGx7bRlerle0QvqW1BUiv+ICUG11 +I6eB79mQ293dJAjILZAE0DLrtC61LzKJoITa+2vyLkZA67Z+CvU0nRWO7CyGaAm9 +tnab/1mrVinWIyc9Um05Zw3FNkBYkM3gvk52ipto6SpL/5yAvLZROxzQDtzG3/a6 +A62Wf+61ex+BvdCejr3IK5JtCZUzU2vC9lXE8haLsHaBABEBAAGJAk4EHwEKADgW +IQS4uAtbYj6rath3XEW3xdfWNQlH+AUCY8vQFxcMgAGA6XbxSlCKSOnKP+m8NyJS +yhz5ZAIHAAAKCRC3xdfWNQlH+NMxEAC3oyW3PPvGTtEYgZoX66DRBKiH2fTtjSjE +QBvVw9K+jejnCfFDplgi6SvYpMWRdoOHflelegDZn1R/rDPiHwGcXwNaFuj7axKr +1q7QnXpuwu4gd+HMlZdLDJ6Qc6suKKJJ+GN7L15DOA5PyMmwSPIXN/G0w5N6ldfz +JB2nhIrdZh1WMBxvCMUZxuHlWpAiyvX4x2VpVyGpY/W+bUAO9AULzuFCOGkzNChT +tZWQlayqUy5eH3mHn2H9Kd0GIcpcdB+z8sAzszYr9+BL34Rs9ZZ8L3v/xKqleF4O +y8K+566ZPLNQI1cWk0bBRQDWo7oZNozAeNpf8B4JpEzEJBwt1DTtvrNzXd2qIwAA +vV5JDXRMU/2QPZCjI+MXqWHRLnGyEdYRPl27DvUqNgAA4Z2/wnf0MYy9Pw50vxSS +UgnLsouPEk6NjbWg8IeDHVxAos40KA4BxDhmbME4/yxZnuV3w5Up7hz9s6rBtEws +1dTC5Um56PC+jKkI7Ft2VhSd8vrffBUxAEzyKWiD7ZPJ1K1XgBQJBWwgLDiJpdRT +4HqCHV66+C8JbXerukwUkM9ukL4QULUWXhFP4IUsTxcbSRcdDfEdaj79vj3Hcxi/ +nBLff41ml90cS4crDJt9MhWyGU9TyteavCZVc72JGYBzONyh5hk5MjkQnPbQ8GLr +nAB2kAVUF4kCTgQfAQoAOBYhBLi4C1tiPqtq2HdcRbfF19Y1CUf4BQJjy9AXFwyA +Afv6vbVBtdyVW9m6btsWz1uxJSXEAgcAAAoJELfF19Y1CUf4ptkP/i6gG11Hkt1k +aHmwMGOFwMn7T2+FqAOHj+UuyIfn8cSZjkzR/BRO+fNXTQGy7fK79uXIppf+itqb +WMHPC5yqQhcXH8oXoSsyQcFCLTDsqpv6djWzbisPr75Uv9kgDkAIugzEP/FY03QY +Dcgxrkeq4DF6OGCkoHUObtBwRpvYmTaGeUIUGCaO6fXESpvYg7R+Z9eNESlEFvO+ +Y5MKQRSbwIiKQnLsIeYAhU4mfFBnIrlu5rTl8pk4lC9vtWaaEnD/V4Tn5VTR8wdt +kORV4vQs4B5yk8Yfe4IRdp/gnQ+7iNcIerP1Q8w1FrA1YRwFFNmirkzkalGQik+m +3yPuMahBoozltTG2xLT7wvnqfTcnnFYHL7IRA9icEmzmfrX91xxpHCo7jtMmwAMi +qDtPlD6/3v7XFfMxzwqRNu1Bq1Z26Q25Wtss1eUtgj+w8KGoy1knvJb1CHP6WMmc +EqRhOMbk4uOwicHzRw0U6RkyOyP2BCABqBLCqWX8ghevLTMoX9kDcBGbLsbm+O+o +/weNJZtypuN3Pbv8fxmf8doZErkbCgFL/gLIOK6+ur1tLpuTsThCXo2LZQXtuuMR +QuJh9sx0vQcdooe5TetYEJm0VHJUnfJQo/9QB3G1LxXBuRgE4imBLhjpHBd5CYL0 +bpyuddHqGw4OzkTjuGK6B/8eSG/JDoImiQJOBB8BCgA4FiEEuLgLW2I+q2rYd1xF +t8XX1jUJR/gFAmPL0BgXDIABjII97RCqgEFjnhIQWs6NbgwUpHACBwAACgkQt8XX +1jUJR/i6jQ/+L6bxKesUXshyymkwvp2zE6+KhS3l0FteCRJsJSF1yJbnzdLTiapL +yKJwyhRJeD5YpdYn5RoCd+HrJYtxt5ikfxJn5Nf4nda4uPgQI94xh8sZjh56Eogm +qcQN9Wq2hzyDnD0nEWCVkFNn88l7KPojai/NUbVgfZkRHRy9G+K3LBYE/d50MFr8 +o8fMFUtp5a64fbxoAYcXake0SH6cN9D8RuUOU9SQZyWe7v0TzaB2XdbQa9xsxdxx +Ui+KT0gc8jTjaZ7gonDLtfeqg0Zuff5d2K0gD7qtvU37AYN1CQOz0y8aahCjGzmI +WLmRb8Ah0gwcJH4Doww7goZDoTpQN38MzeIWHZX6Bq+S2TzmwiROHLfvyXclBGJ1 +Gm2J9MmMRKfIz81SM3wkxvql7KfTErJgTq40r1xkCZsRYYJ1l+nraA9Sjp1HsEd7 +ZrWomiS99Il2Nm1zMG5ai0WzoRBwK5EOqnJLOstiK0I3E2onQUb6SvKu45tVeCvj +L6vULv4JzOYYXSbzOnUG4ZpPqlvHtfpWprNhJ86RBKThbKTz1HLjlFmaDv0yC/Wz +o03PieBbstg0mAxlfBgcv31SIvjt04UEIhdOpVdRHBT4GRXHCpkGrXQFZ36p0w8a +XyGwDfOLrg8kyDS7hhpaz+NqxlpZokjq2/8zVax9DdMJmu1PpgSeGJ6JAk4EHwEK +ADgWIQS4uAtbYj6rath3XEW3xdfWNQlH+AUCY8vQGBcMgAEwmRG+qWbQYTBTBFcR +tOX/FbD9ggIHAAAKCRC3xdfWNQlH+KUbD/9b5yRXWW3TR0D5LZMvuppB6Gn//TcZ +ecLgJFURZqVqgTKVyoeW/JSJBzr6vjhmSgtNFJp01a3oQghIVpk6IgQOvPOk1RW7 +/2F5B4l547M84VDQsE0jzrGjx7USa9YwEsN/o0Ylm2gbWoE0jImTTHvHnWk4Z/uH +zGW8QOjcXQk0Ln83UWO10Ad3IDwctAWR48hYdSb6HvqWAXdnlwTczKHtcDQ18p7f +emAjsJaFs2IXrZeE4wBUzouuOT5mnsVYOmVKI274ndNONHSwCSkflR/hXeLvMiGV +UoqFX4q2vmiO6PzTlTW2hysfrxsGfjB4sN8/Manitnloygqor6exNhnMWvo1gFAb +9yOzQyPyDlYO9csugn1oLOFC8+oDOCSV7YRC7NvdBI5B2Dgqi5v9pAgHRMaOApgz +tYCP8QKgrSGTfDTvtUvsx4bw7ipK5tbW2hnRmtptYZG0npbFM1zw2p1kdmFmd8Oo +lDphWem66+WkAwFl9MgwJAOmB/BsMDdmYBC5iKQHonKvbyB7m/21h1kgiKXg/Xsl +2Zr+6ydVKmUasNnMOrEAz6w6xd6ON0AgyenD22KUhrvLbcJ5+Wyp3MmwDFmKaKnN +K5FTb1Unfl0S0y+rEvlxsFUxyXUVBcYhyGta1IOXPLbRa5CmK1096O587Rhx1kJO +jzdbN7Y4UgqaMYkCTgQfAQoAOBYhBLi4C1tiPqtq2HdcRbfF19Y1CUf4BQJjy9AY +FwyAAcdPasnpM7MGf1LzP6RZ7GcVsHBfAgcAAAoJELfF19Y1CUf4TYMQAM7AJ7pR +ACiPJeZBIs95Ef3B/KR54CpWjC3XkvdJ6AXcIZ/9bI94Dujh/CDrQMy5vzVS0Nqd +MHazlrIYf9vMuGEMX9eNqi3ISjHr8nX/OmCKdVOdhFSzyYl6akSta6KuJ+wofOHd +VP+m/fmvBuUeEx0ePa3Ghm1MdrkyOB5F3ehP42Vtsbp+KsoLMYJV3DqzPjvxrFry +2DAbrkY9r/iVFkJ89h3rakDYcuV8XCOAMLnHVw5TphEdV1fVUnRASv76g4VY2L2C +tsFmNmk1I3YUWley+8DfPNoIZ9RVnlOLgYqwL9ENuYhkUtCsXy/VsRNJANa3gXnr ++eNxAxwg5inTJYG9EqElR4QdWXe760ZoyXvh/n0xk0+Y2djrLZ1oMhExgmZyNqBh +xNKkVqvozOJE3a96lDSRUPFejK2a3TmQ04sWQ+BwqurB5U/tHmZXL7//D312vHjt +PAl6KLv8aK5M3cUtzaCfnCah66veGSybTkqD32DGvyLWN4oYIa1Yt4DYqHp16jM6 +wCPJP7hxfjCHuZQ7yU5O9Gn9ZGqo2jdpN16VXF2Yo6O2qu6RWMstpjUsu+VAT0ri +OyFxAGJ2vU2Z0KX3NX8hnM/fb2O67gy8ru7LLMdLFdIbmO3TC7izMg7OmACqGxNq +wtAyLlnVx1/L41+qVWT++aZJhJoGWarZCCdftElEZWJpYW4gQXJjaGl2ZSBBdXRv +bWF0aWMgU2lnbmluZyBLZXkgKDEyL2Jvb2t3b3JtKSA8ZnRwbWFzdGVyQGRlYmlh +bi5vcmc+iQJUBBMBCgA+FiEEuLgLW2I+q2rYd1xFt8XX1jUJR/gFAmPL0BUCGwMF +CQ8JnAAFCwkIBwMFFQoJCAsFFgIDAQACHgECF4AACgkQt8XX1jUJR/jrWA//Wnr8 +3M+9iwR9SbrMlhMgMobX/MZ4gL0Sw46W4koOBliJjqiBhQOFE31fzfIEzMhCRUXz +xI5C5PZ9mT0o504DN0CBzkIHuK+iH8/jgd5pzGMBvbPz+0kkpbY7gHcenJZH5ifl +rKZ0sl75kWwF1/JTtE+WjHjajvNmZ/VlApBKgFlvtfcSreWrjjZl7COyOxGKKOVM +4N+noQQgdiFjy8aFT+XKqnA+QZV+X8b6zjeP8wCjlvlMF4bYn1a2oFjL5obxxEza +8mhSsxlHQZm+B9sxW6fXsHGDt7Pg6JiFVuXHeUxC/bkGdqBBOlFCBXTbXG7DjRxH +087Lr7IHBFRg3OIZmLfWuu/NPOYXD1zFXuWmCMAzBkmJ8ZkKV1oMHFhRBHc54DOf +T2VGGk50Vekz4wzkZeBFU+YeG3KfrTEsyLLk0JG4y3OY/85oKVEov0GNac4fc3Oy +MC9zVW02PQNJUZO2ezAOYBCAVlVhh6yOmJM0UTsQNMEJPW5hWEgyvd9XVRLdUh8o +RmUmtsH0UBxxaoL+gdP8NS+GOcOELfBF0KGURt8LGpqIdT76Cw3ron2vpkj3k8Lj +DRfc7WFcl5a2b13wzRLGYB8nh4E9U4/IWA4jg4Uzx8UWJ7kx4CTgGw3RDK7aEPmD +ZEIVgiKdt8WxJ1bZZBVrra6gd9aDAs/BjP6xaMCJAjMEEAEKAB0WIQQfiZg+AIH9 +4BjzzJZzpPJ7jdR5NgUCY8vVLAAKCRBzpPJ7jdR5NvQdD/4/DOdIEG0RXt4tLqpm +lLuSiw/lpVqBSRxM7xQzFmRSoGGbbJbxXzzmRKJzutk55Zx3Q0WtWlMYfksfeGL9 +rXcHVLby/tbLUDE12UclV8fltGrhpIma0I01tuEf3Yi7OlX9gpzLe54V1DeywtZY +oFVzxQZr6qsCt7kNeaZrDAwuVnXobs4LtjKmk3YTMWd/WsLwBXc7VS2lks2rwyRY +CT/rlRMNtMxLh/ogzntn2l6YFazFMErIApd24qrzOR2e/wH5E+4+DKGolSInhGB6 +y5jDgCEqqI7gJhCbmAr0gf6Ew3og1QEc6Sfbo6TKMCtmAXD85LutPcFmKepKWhaI +E+ECD/jB2D5iP+YaS0ndSK7Rn/9BVnr85ZEAAw0JuvBlwAO32kQJFLbjLyVs26Jx +9cHuvD7JfyPWZeWKXLqRWk+10AmmQTrZwdsxiwwpWRQUFBL0KfU++jlSoHeL7pHH +HnRMqSrk4t/9lyIXDhK1lgFGUfOA6LIFlEKLz7N7rWCavO/1nlp3pQLPSxhqtroy +a9C/U2j4796Zpo7Q3XlsoW7O1+a6heZZKH3d6Tlk0LwqNviEeSXfULUkY+5saxFq +irxhN5UgUSBgjPN9WCh9x4PL2hW2NxFiKQMBsNhWC9LN5USLTlNMFFbxdqP9HEhL +30zGiD/qhI0PkLOOgnsOe5Paq4kCMwQQAQoAHRYhBAWrkDQMDF55f0SoyCVM87Wu +wKjwBQJjy9QhAAoJECVM87WuwKjw7QMP/02meRqVavu2G7WuHXxoi0AXevr9M5Hf +KF/PssJFhac7Hha51XjH/5bWuEUXEHsS8TnUXM6OCgaoLZzakGn5RH/5ixQrIJ7a +JN/jP9mTEYaCnHbc/P39sxC1DtgoHXIPu5e7r1JpPWAlU47OIW6ClXwvvBfXWq6R +MclTWwx6ZaBsdXIskCNeSsO3XUpym9SHWrUJxUxAl2EHrGQ+EkFEetjUPGDqqKlc +3d3sIPwBoP2nhFzwwk70XcPrcmSZG8GfQRy+yfHGCj9mXSdtlLIw4NBkDzJ68Wqs +6bIbyjasjO8z9+M2KICeIihzK3+zIrTYsI2zeWm8YOoA2S8W9jF9oYbk7mZLqm/o +GxEHHOgVkjnP45c0zwhfDmGAPHnvto9ty7q3W1GtZRKvkR8Vs3mtipS0QIHujXTR +vhoVc4/ovLrZY1AAEGR6dP9p5QYjlVWDonnf4z04BRqCpJW6hUFrr8Bm0P5Y3+IG +xFzyPBaNa9v5ua8r983nBPsD0/7Hzsj3TttBtP+qjAMl63mRHR/4D0XvPLpFdtDU +wJgv1GZSUpf5qfeDuz1lxCyxsp+y840W2J4jbGB0v2kthkqLAnZDvAXrUhoPzxiL +mKi+1sfwTCrPmUJLOJvyHwmoLm8UCP4qCOEUlevp0LkOoin0O8SInOiByuWZXrVJ +aODYrcQgn1noiQIzBBABCgAdFiEErFMNUg8vMmn16YMTpIRJBEqtXF0FAmPL1IkA +CgkQpIRJBEqtXF3MZA//ferM6vGUA6Ky60qmLTfyquEF6BmlYg+gUTTmVIxdBU4N +VGipsxToRpYoQUFtfwfS/43eHziAistFYBoOF2Y++Jjm8nNgmipZ3rsZK/ORZksT +v+cxOeLU3Pi4y4+ATP/a4a2hfg3yGkO+2r7f1hrNOP3a3W8aMcvda6h+/zMSXsCR +S++rip1/COP/6nhBLO6bnGnT8+U0hsdfIaClHxHXMnNMietnvz9sS5uaTlVKJk6W +fBUFbt1+DaUdv0QqvVO1CM7raG382wgQBJM3uwdIM6obdAwAEVn9MV/RU29B1Tsr +iyDD02fGSo/42E4jG7VLdH+KL9GZvAxZptFJBvlmkDHEzRju64pf3bBaZUU4p8oi +p1WKxbP+GM9EQEINe7AhKvk/NSCT0l3X6JMgc+79dcq1gO3yhPKJfyb8RrdC0L2v +4iXxmPkBdZWBWOV0s8oNVFvwHKEWO5rDkeqi98+IvZlhxK3vDlkZFvxUPYcCqncH +r7ZHM5VFFCuntPBiHDdgaw2CCoN2mO/uLhWJkcPaxRs7/UYhJo89+IhKoCjJI3ZP +AKeowVzpj6JeWYd7k3jg7fsvMOD+VVGQS6XjuJ9VV8XzrzEfNajhYZd1kser7HSR +Q2OGt9Td+luYgACStLKmj09u6nppy/t+qsWYtyO/lR6D0cmIq9pqvXVkirWPDrOJ +AjMEEAEKAB0WIQSA6XbxSlCKSOnKP+m8NyJSyhz5ZAUCY8vYowAKCRC8NyJSyhz5 +ZDvUD/4u2hlI+FCelUk+rTwzwo1KFpR5ARQKHhkohNYA6bk1dQ0nvzff/mmXKmCZ +QlTC5e3CQK9UW6n4vJkim1vMAsPEuSx4hjiVq7eQR95Pom+whL9K+CNQE+RfqHSL +cuDQaB+K/7c1/T5uwYBLtOLojT/qCl4DTXczTy5R2lwkNK7U60IJ2hYPkq84AC5T +Tr9DYvfss4KiWwLpnl+uDdoFoOZJwElzkLs9JkDiE06Kaq/iJlDHfTQo4UfU6HIF +Fk53Vtbxq1Cigj8kSGOHV0l0ho6DKM8FcUnylhjZj0yzQ5remmtc1rRcJiARxPmt +hkQW6nb0fX4kWNNxip5zAtTJxgYfcyepF2quJnCIdQrRSL8ymI+VLYORv/YLPqJY +yklIC28R60JWBIykaxOUWAqNywE3rRSa95uZbvNqNc6aAVTlwdNSgaZs2jf2Irt+ +BAf9ZylIKv5szCtKrovgABYhHZOvrERsMlAqCHfdoTOyBTY5XD6okpAvheJxaSLS +6X9D3jOW2htEDzqKrGHv6yl9gFgJoIxgHmUiUMV8ctbrZyKbfphesG36npXIHckZ +69czi6ntue6YVz3RgOPR2yHqrnn4EDQk9bE888BZB7kKIuZ3v6HHnEAnzn7XO0VL +P3XDhVpD2M6gRvkgLy5rIvJf0Yzrjq6YVkJWqsrIcceOGyHzhokCVQQQAQoAPxYh +BPv6vbVBtdyVW9m6btsWz1uxJSXEBQJjy+0pIRpodHRwOi8vZ3BnLmdhbm5lZmYu +ZGUvcG9saWN5LnR4dAAKCRDbFs9bsSUlxLzhD/96H7I48hCpMX+dzEYml6fmkIIy +zR1Wj10/0QnvFzZ5JInRWEl311+kmpMxSqWOn/M94OJFGWGlmMxJdiDQQwy3a9tn +2DVL1xJthTsCWiC+npWV4rfeEO5KgtpscRMbvylKmrZiYYJSfjsDJbvN2xZXSUzS +SIGEnG5aOXwH6mZfNIkWqbrck8H3Med0vG41rLjZScuwNOLsHboE0p5tCsHlmKg5 +78iGmcejEXy/mx1Igi9gp3+9ETllr+5jL7ZwyaOMtAPohf9/3IkNz6yp6Fbj8OAm +BTtyraUEkz7fkC5QMjzoyrMb/YHC0qe21fwUrLv0UgAwC/pJ/etCjI5x9KN5J7cU +XkMPUhJH8jJ+Oj9Zn+bLn0oAOrAQxzB3dClxDBEhe0MTUtR7NZABtZ3lxpjd3SNm +hwbgqsNOGSiQuyX+QySZtM7wLqgl1W/6DYAPYwcYFHNK0MHM0sqZy46rZS2U/TcA +KXlhxhjoBjtZrLkLPyj32XZ+uBUd/pMexzGNGfdzEfg9ds546f4ZPKTQ8KpzJQGz +pHP+07Y0CDLNCV//qUPykihIUeb9MR6q55lkoCIZOh0hAtLRrwYpmkaZWyO1tdLO +7vwJR2O5yx1RtrB9dDhjLuSVXXyb0RCOJatUwFhfyeeTIS8Cx8zjKX3/I5Xxj1D8 +0R77BmOyE7UCKQH7VbkCDQRjy9AVARAA5SIpEu4Q1OzxuuLRebzk3VEgbot+hz6H +tLe8H6G7ZAwsyrJvJVcs+wwIKPiJI+sxe6HDO7fD6zfG9HNnTUcORg3FTMXTRAtO +vwXru/Jlp3Kx/2DK1gW5UmAxEHFEaWR7cjFPQuScAiU9fgPKzk/7pB05m2Sb0fw4 +RTMZeSQFAamJtjM0aPsggk5w1yLj0vgYz+TLOcMWdQHxB8cPukGP+bxqkYaZSO/A +9Q6BW0UlHte59yUgeQkJ6jiX6mml15BODy5nZ6VYioQ0BnQJuPpYv7Lahb8OGWYO +4UeSC9/+EqVxO1AwYgfbZk1AqON6oqhVOePYkXeBDLzElD72dz9hkPddEgMIq0y+ +zRkHHBaChgdjcTzNGET/LHKq4Bf+7wFNohLg7fDm2XW2XoO/awg2NetvwVMBzB7i +26jnG0mBKtiThJ1tQiiHYyCfbybDghq8/Qc0zdoVBr8WXpj9WQYsgKivVRN7f712 +9MAeSPDQtse6r2B5SK4OpHn6Fl35IEZMJ2KZl9MsLSxdrd1O8Xw2JLEHfJD/9NuW +AmHgdLftDg4gxzZRZ5lRFOW8di/R8O0gpQJzqGXQind5oa15eA5XOtTbQJ5wcm1j +bBSFyQTiXEyF9T2HXAQOwTwYHq6YAGFRC3q4WbpLIQFppqmgF5v/HIaEnlhHX5wV +Kb7ZnYBvALcAEQEAAYkEcgQYAQoAJhYhBLi4C1tiPqtq2HdcRbfF19Y1CUf4BQJj +y9AVAhsCBQkPCZwAAkAJELfF19Y1CUf4wXQgBBkBCgAdFiEETLUBkCB7R1ij9zp5 +btDnuCZD4TEFAmPL0BUACgkQbtDnuCZD4THhbhAAx4zqhSukpgMAE+Scw5ClPqJC +j+xCV8/FWGICnVcbMqhH4zHMYefZbgsnzZELJcvIps91bbIna0H79ks47xvA6nqB +tLM5JNvV8IHO0gg13vl0qb6V4a9SWvc63YdHK9kOeipvowM7dUStue/PcCG1iDgo +YwfIOMi8mKyODRnICx1JJcQyodiZRoD4pcvhRtQpA/kr5V0rCpTIcsirfxrN8Qh/ +BjK/duv0gq0FbKPKIdD0SrN6gm/+kL8KVyS0ph0rJmvBk+IhUFsuD/+GRYhTcxLG +y8d9yatr/HF/HfCzRo3kKz4Vt5CQSHg2nkzBCpFBKIdjZspPQilcc606T6H9oIga +Y8siGydrNRuzLL4b8ciCMSS9Rg/7t9brA97Bc0kNmOuB8vbTYmEbK3loYk4UsR9i +Y9IVrUspdqZo2AcoL0W0sY5L98LhPVCRL3hYu2rsiCx55rcKbRyIOfdoDqagI3FR +zEbbfkKTQxDgnmSJoafqx8nreK3QnXfwJZASNO30e8oFn/DvKdutnErkziJj6lSN +/Au1qcoor4fgdbiBCpWYHJpY6e19pFUJZ+QAgMhKfzZbYimApGRRifpjAtc7mT+E +H7pf4P8FJAXhYqzoLkxIs/yjy4F+doFMNg+LkerZg36PGwPSSKP7T8qs/L4TI7ul +AlV1FPUg1bjLYlY3B8gnmg/9GFeZyOzutnIUvUlTEniCIQ2Lgq4xG7RFxljLA7zL +Tyv9k0qbQUFkFEnR6VhHkJrQp0UwUNrL0fsBgVzEyPKWAwDQbaRAcUboSfgZj11m +gJeVMSSIHzEKEMBKVvnEhT1UoYLKiNUwuH963LxrWkAWuP3KALB9ZkIji7qVKgzc +Q2GiQkcpp/vbYH715AZlr0terlHBw0nmjxCl3zOfqxvpez28YrmPDbGNZsYvvQ8W +oSbz3nFMxLc/7HwAtpn0q2e7Hvp4DRrh52afyFZrWm5IyM57gfE/5ggsgY0gQslN +grn5wD9f0hRM5OR5YDNVvxzM2MMr+wDf5VlLR88Vs9bg0+zwEybL+4H+zle7KP5i +mKtynz8vI+Jz52YeAVEfr7kn6E0YICKf5q3WL2yALSsmGpwvsejvsejC4hBCmkvo +9Q9wXwI0zhA1yBVb7ncN4F5pc0urXRmtMovo7Roril7P7SGwvTTUrBMGuBoeinkB +i6ppxYyC4PhC+2GrOX/dbn5h048zDLPG6eIyrTg2z0AcUT0ODFLSzWbB3+itOTT8 +gdmkVDz/RSwbumar+2JE/j0tX8bgq4MMm+lswuzqXVvTB4VQT/uQTxMT2ZlUZfKN +beb8wYMYQ4GxPrgdkux26WNgVbm1VNtpUpIoypIuuEJnFJ6fOBA2UHZPpsoZxgao +vsuZAg0EXLLnwAEQANOzwoO1BFybllsjFbeDli8jnO+uY5F5K58HtZftLyYq+lU7 +5w4KwSGVvc0J2nuP8Fzw7xxy83yT7Jf+lBpIoln8abOFn4WCPPU/GdMtigILQ1Ip +IRnwQXlp+bnMJ2/NOlszZL/UvLBiQUFSoWAVyowwUvGHwao6gpCCptjlkCZjMLS/ +5DRPWnP+NDKZ3DB1Si28uzaSeQkHP27vFNoZ18rBLy8hKefIz9CsuldL9ZJKBXNh +Pjoe/rftZw/N75aNVDguFcRvBVJGy0eI5vEg9o3O59tui2UBXN4qJWc27qqCcorj +9CllRhbO0Yiixk82jdIsU9uF7Tac0YLI3BjSwYWxoFQf5RD6Hy04dRee5/hCj3t4 +xU/UNrRRY+FYNni4+MEOkJkh1VresnqSxIiQKUD2i9mUj99h1Mj8DmUSldm/MjFw +KhxIyNTyHNTmixhfQmOWCYBQ/8fsIDQtbFchlm4MAs+C/IuNrDsLhT9lE9cQ/hUG +NfNptv3erldjdZQFshyR/6Um911k2/zAcUKYA3REt4VlH9CiM+/G+mCuVJWzWF63 +OKxdwaFDJm0bOB9p2oGUkAoqaORTvDhONqAuhI5jOUTBL/09YUuKPbTq3GqQypFa +HGFYXUtlFpFvo5AtipdBSDqhaJPNl/EUASDHHtxHqilrDLHzrF/YcyZVH4M1ABEB +AAGJAk4EHwEKADgWIQReYbIXJl2pgHojxf9N+rJwyqlt+gUCXLLnxRcMgAGA6Xbx +SlCKSOnKP+m8NyJSyhz5ZAIHAAAKCRBN+rJwyqlt+iWBEACzon7SVpMMB3svB8d/ +ux3AV6aQNpMHqaQ6WgX+fwKAYDnODVqkl95BdObAl4VQBEuIcg/LNoSXMiLU1qTJ +HeXxWzbLMm9WBYNfjAm4WGXLFlO/TSC3WFD5H32fdXu+dff/oOZr9+N2bMe0AfjF +Zdr7bOQ5JE7+RR7ITMwIWrtr7/WE/ZDXbMOQmdsJPvIEuukL9oQqFf4/ni9nw2dD +GiXDuDqPOiBORuMdCX1fnMlHHulLpN4tCPrTFp5w3yNz6TJVAgG8MMOL/4N4QYK7 +IxlTJFr59NJtgFkVn9G0iZPydAagNk5geRUTDKviCAQpqwN+RsfjqcN+a7AbOuzF +oEB3nTSxXuJImB+bB/vhJ3nZdypCPLENxgUhSNyeGZ8tNuTqYQ6Guqch8IBxXvD3 +QM/MBZoRPEHeoZ3AAm8dKxPGTY2AP7PXPV6duSzNTc9DdU8g06eHLqShPHpILBCr +AWfbMf0/4UNk/I1aZmOCX3KdYs/uiPIfnrwcBzrlb+zMWYyA63hJvK2QXZTinGpv +MxrNlnThmdHrVFhPl1j/GWHV4N1TVrV/qHXqhLA6GK+JnCZ6jTsKTOM9kY48FU9M +dAIhiJAkmKM7gHuc6c+qoCEFVpqpAoAA1ZiaMMxbbWzziqWZ0/2B9qjYhyjHtLAQ +P+AiCk8QbNzMmM0hag7BT5nVDYkCTgQfAQoAOBYhBF5hshcmXamAeiPF/036snDK +qW36BQJcsufFFwyAAfv6vbVBtdyVW9m6btsWz1uxJSXEAgcAAAoJEE36snDKqW36 +P/gP/AwKWv3b0QzxL5tMwDvQqYD73gQ9shrMYivvZ5m3XrLgUwaLTaYj5eKnBAf6 +ggq55ei/teX8jWwUz/fdhmrR1RZrYQCORBJjiDpklP//1jQ9raVuBX6g69P9uCgE +7fcc1yKQpC5ttq84/pG48OrzZB+MXDHUkDv7u0bVeiFbftm3EiylF8gncKI/1B3+ +FieY2zlBmxDxkY+Z++ledvSlZGdIhxfnVEyAFCSvYg+waqLBRliZscsnvr4DoAyg +A3FQgKipRqikyY9t5i/hXThcz7Tf3rJ99qm3qKC7HKrkUSxbjXCw8XFr3RLeRc+x +uDB2Zkh6oWRgMHqgjQk+hT0ZVDdQRxX5bhqshd5StPO9PfXYOaxgtlwZahPoxsqY +NZiDAwfvtmZT74RxoJCWVsQHUcrdHREXP1AbrBiKF34iWPlH9gRgtTjtknkNBcBL +xbDVFcbQnEOd+lmdvbnCAmR8IRqahKqnSX1IsuCojPbMRMnpaF3cXZ4TDdLU1Kjb +0SlJtMrhta+9Zo7i75EqsIHMMn6sdVO19K4coGG93LfpHTuMExScPPixlCA0dqaB +KaEj0BZmin9fuGYme81l7bH+4U4e8fNwikE0HQKrIS6qkM11/WTgDbgIQZwX9+f5 +gb16eU+Fr8rMOu802tDnw2lfWEwpYz3rn0KLQS2yksETHoY/iQJOBB8BCgA4FiEE +XmGyFyZdqYB6I8X/TfqycMqpbfoFAlyy58UXDIABjII97RCqgEFjnhIQWs6NbgwU +pHACBwAACgkQTfqycMqpbfqGZg//X5VqOV+CuzzQwxe/QCuCkaD7li+KCog+7vgu +7BkYcb1p+xaJx11JhGeBNtoU2Kpzqs1kNe2cSu4Oi+rsIhKiTIe8zRU2JJNjy9qn +/89Bb/z5lbJbtl5AO6pTchHO9gBXdEC7Ylo25lZortzODYnxPgaPV0VgDB/g4/Hb +HVrcexFNAIaKhOuty6ENu6E68Af6ZjVqRiRZcZ2x7TisqVf0c2hIsqDCgWWoW7EC +RbRjLupnM06HEJsxkmiOhHVtoTQp56v3ysXQ5W4e1Bu8435abiFiSS73V+AUnVyC +9hBUT6WScwTrQMfuR6JQsGaNAjBwJsb083XM66z78ScDlb+p/yU9f+uHa2mmZ8AR +Rs3LGM7NN0SnOuD5SuHtXl8BOFNw0pKthKNtjQI3bsQFpqJVNZi0Rjr7Xd6KlBXr +LKMaIAArC9r96GUXMWClF+YQRlnOrtRLfZOfOfEnSVT5iCygmj7dM7cHvuEB639N +9T25BrWd99SkgDwJZ/YwgpjaV9dnkAXZrWE+lY8Ibd8HtgRPOaBlFicR9pLfOS1K +UdQpnNRdwzXMHNSYapSqAFsc/bCcP8fTLTW5t9/wLntL+wnU5MkK3z+udPrC088s +0vdw9gV+kfW8hz21iW5o3vydaqZ+pGdoPneYkzX2ALElw4CBQguQ6ilGXxlK2urC +KmK2PiGJAk4EHwEKADgWIQReYbIXJl2pgHojxf9N+rJwyqlt+gUCXLLnxRcMgAEw +mRG+qWbQYTBTBFcRtOX/FbD9ggIHAAAKCRBN+rJwyqlt+pmwEACYs2eBwT2Twuy0 +lIrMwYvy5bItGr4N4AcxDg5lPxpruloz08s942OmS2fEC2+gPL9mglpJVaFMAwMw +P/M8ui7VUzjcnV0Ex7mY3rdVHpAZW6l+O5DiHqQt3bYVRe+evE96ctOcQx9KzRkn +rnvEucO8PJnLXTGh+33IkfEcVFwPbfKcapCpq1ykWW0+J6hJPrgrMmYBOj6Ztron +29jgNGt+HPdZXYflGxa54kAJiwp2RbTllo9Qe6Mhm10QWyUZuk+A/z1PdQGYRWVN +c2bn26HRY52W8DwRItCarNXvRT6x7xY/rin1hdhb9YyHTzeyra+tW5Xu3hgpwtYE +HrVNwEOBXMpdOXYp17TxgQDvCZUbQQfUPAVEeTGKub4/JobK66jKR74s1nVipJ2s ++02tML/ZZciJyVV96oXNzVtVy70TYwV/1J/YaOmLuHjG8SIrvpqnb7Dbd4UhEjUM +jmkav+vICmMajj02tk6hwojBS1kFnqJVkAG1/wQ/CB4x5rbnQTBHBKZTfrDSFtrc +j/cb+dkEq0bjfB5xiSnuEUFs5D8jcBE97cRyZ2vXhtpEipVnA0voXhWVgxpfPWMo +BdeS2SuarYT6ZRC8r9FHVxCD0UyS8xMUHPtLySpzRG9FxmS4nSjIxpRCzJmYQd1S +adVUK12D+pSS3hyWjAuc1J+DNjM/FIkCTgQfAQoAOBYhBF5hshcmXamAeiPF/036 +snDKqW36BQJcsufFFwyAAcdPasnpM7MGf1LzP6RZ7GcVsHBfAgcAAAoJEE36snDK +qW36eRwQAIQcBQieulJtg/PE+nMRZ7a0w7k5BrZRFMDnQX2LlPEnlusbCErY4tX7 +ug4hHHjE5MHwNg2OCKTcT33FZy2IGlIc7KRIQQdwl6UvcI3yFyYkpiUvlx0yVtlO +zr4lXSOOnpBGCoFsc1Rc1T0kG0fY+eIoznhv16BwpuyWM/ljs4+vBK27TyB3eWCc +8c3rMZR8eNzC3WiNtWeGXvW/emBgEqjHTbNra8+98YrhtONktFV6R8WB5YUF4cZb +tgIN4uOicEQP3odKwEu+pZIKOuH8q7fV5X+cOt39+GtB6aaL3CyEE8ZXJaP1DNLy +kizhKGA4F1xrr7d0kA90rp2Pd8QcX7pn1Rm+APcUBqfQbbqXUlbuvJCwP+JBnkC5 +/EmRHcg/yKLJoYFSF2CDKsGoESizWxKC2OlR7B1RspXBQ+097mLBIVXIKmwrszvf +11AxBoS/GS+iEvZu82FfZP4GZK9UiV5kBgnO7M9YlXPDm1+nIugYweE36c7lVeb2 +30QZIlvAO2a2TEC+h4leCEevdWE19kaUyLChIMgkdOLqtoPdnooxqtdlviKH40bw +XBc8PaWfDz9zhuP96pI5CA/F5j6EkbxDCJS2duDe1K7jFNUr2adUQcfocAblpDJG +d/K6zo1M45llZobt0kWwIK2MhbMnR8YoRIfP9vxX8KuXru1gkJmZtFBEZWJpYW4g +U2VjdXJpdHkgQXJjaGl2ZSBBdXRvbWF0aWMgU2lnbmluZyBLZXkgKDEwL2J1c3Rl +cikgPGZ0cG1hc3RlckBkZWJpYW4ub3JnPokCVAQTAQoAPhYhBF5hshcmXamAeiPF +/036snDKqW36BQJcsufAAhsDBQkPCZwABQsJCAcDBRUKCQgLBRYCAwEAAh4BAheA +AAoJEE36snDKqW366YcQAIn1QYnL7c+lz1bf0L8JI7T8NSVOh3BDqOTVZb9rKnWF +hfedYma2nR2EN0RjHR4bNzNY3egWEmHn82jtUz9aKxMO6GE8dKE4nu72Dc6UnbvR +HkV+4yyRoXqu1qJ5xO1fpbbFiVgMwSa601nBW4zD++1l1Sr9wsYnUMGA9dDqVtfe +j2O59EjCusNnQ5TVHV8Vbr64ES6eLGI2OLfNx/n8N/0qrnA7nA4v04z/BFsc9tIM +P13dU4NKIN1ZxIFBV6kzHv8++Z0v/jrq35rWQYEw4/kgHyqjROemxQunOPsk328f +y3sUsqGMHW8XafF9IroNmNltU7tq+sr4ZsuYrsYFVoCXlXjhby9qlNOcpmHYKp6A +NYaQBbH4vn6XNIv1miXP48lGAOd8BKmVa8tyiAZAQurJ1uK22aiYOL+tTFxD55RD +WSLujcwwFInmeoQ2W4eD16rcyy/OEzv7Q7Yquy58eji0UR0RVdX7mYxGn5xXbdM2 +R34zAvkw5h6Tb8s/NFHXef9U90Zt7vAlA3UuVs6rpqeIPMS/LK1AeFtSw5a/KsY3 +imHBL5YgCi9LROCzXW7Py2IM7d2WS5zJ69HBs3jhTtfKim3v9Pdfy3ImqmGlqx9C +qx/PhXUEO2eo+3B15vzZ0OAbckDx82KVR+TdPXjPURpOcDSj6170byS0/Ox48Hx3 +iQIzBBABCAAdFiEE4c8g3f/kuJ6AJljx4LEYlPZq7JgFAlyy68cACgkQ4LEYlPZq +7JjHmhAAjZVe6kHV9cWoFxtyVfJGiJP0GnTZW+guyUcKSPTEQIgVrr9zuqoGx8N3 +lah//uKHJkda3wiRh3Os5WdhRHsKzEmsRTMR4oFOFY8vfR2xVXIFUVbRJh6LRP1E +m+wNyEAd7MK85oM2FrdpnuvYqz6BhUUwjmApma27Z/ts5uS+ziEHsHB+5No7GVta +smJIiUec0vofJFcwLlx+tEjhVHFnEvRR3a0J7YSVzAzTBBBS/ZaUK3h0zZOLqhBp +pPZ7x3Qy37GOP0rSgpxpVSzoEApOroCX+87WwOW//G5HNbJxw9jpFmteV3po/X3I +8dQdMlKtPSHhU/JP7ssSUmXWBKGV0XACsVCaY0iywRAroW2RNmQprthNGvUdUgDf +61V0neKJXG2wPNzKw8EPnZky2A0kAtNVHmnNb00h0mbTm+FTJBJDF5v59sFdtsuZ +SUiU9tsfpndFpWLd0ZTjkWRT4CM2shJM3NGObNxvRR5hfVNHEVbs+i1Ng808kfc/ +RmLuY/HkiibZqaBLcwyDuf/W4ttMKN+4bglKLeTP6VYfbCFgyE5r/1qiwKjMkDX3 +WFDVcxPurat1OBbpJR/ABj/iCzcRqpM00Y6OT7VDJcGmruc/YQqX/ud2Mm4QzuFD +B0MWSOwj1l5zQv+r8D9U36lbXFzIq/14CR3vcRAZf25tGz83YLKJAjMEEAEIAB0W +IQRu1vXLX6b7L0YK6I7toNI4iuIrqQUCXLLs6QAKCRDtoNI4iuIrqW0iD/0Q/VnB +7S3NcooG/JSki5OxjJlHPfDSuu//YS7MxjxjdQT97SFjM9K29M+tepH9a7DVBFsg +7XSNebgpb6alvIMHssrSAm9kVrDKdmnTnPrk1y+2+c+nHBhG0GxD9pJCOPqgEtbt +XbWfZfnMU0RFlxfQ7SPBlBOf+DSGAyt3aVghbpvnhu/CY6dmA2u+kdHA+UsI8U8O +MGylcBLl5jWlZxDw2t9EKTTJ/EtlHYC2VoOgSaGzBoZWNqf5xwGEAOczC4I/2IQI ++IKSve0zJVYatWD5ahb3rxOuAcchkL7uzEYdTzAX/0Q+xGX49J9RAvJSh1Xr5R+p +EstCeM4kETyLW85mMGlq8xYWr7jKVieDxLC2L8v4RCbbAY4n/LMS6FvTzwWyisD7 +EQBOB6ntruPqb4mi5AK7MckqBpJHQhgp7ZPsXvdEytNnc0OOix1oN4I63TGr//i5 +seqr0sGvxuxhQPYQCiX14YzEitLFTxBjZERPF35YGe29vtmA+8IELlpbQD0cPzGt +zL4oiDc9ZTucx2pVV9EFmvISZ3Cs1uhbxL+53fHIPJRBIWgzb4sIQ65O7CFwPQ29 +yIejIvxXVyYnIzD6MJPz9GK3pewDBcgtu1KNT1DwOTA22zkqydxJjpbdBHa3p8uL +DMpruosJLbIClAYYbfgH4FBYJtb/3XCKzI/rSIkCMwQQAQoAHRYhBIDpdvFKUIpI +6co/6bw3IlLKHPlkBQJcsu8HAAoJELw3IlLKHPlkCxoQAJ+sYIkoFk/vNtwT4Qoj +bVXSZ6Crdt33qCopUZjk6y84McCC/MJ69eGXYsISJckJCPckIPKfCf1VWgieWgrt +dl3uJhvUFnQJ7w+k+5diOLy+LWwdxNlkWbofq4egh37z3l6vxrcYA69Zpov3nccD +l/F1XzsZhNOd4pHEkmkw27+J0WfVl3F9TCg5mcEW4pvI0BxzxZZGvtcJkOrxfQ8F +rdsGunzeHew0p1KCh8jdkH2E0PxwbHAmbEQoRh1VF/Y2kRj/LLAFdpcnhCVYlE10 +UAO32YbV92indOy9LIUIbMv13e1EVubmu1VP1cDNI+6K3diYvSnJzwtxZ8f6Ry6d +HedS9u2oo0YEFLPTnA2R+7TyXhNY9NCG6Lr9aCCBiSueN85aJsedyanH/+0Yy/Fo +YE+zDYDNsyM41NoZhR8nfFylyVo21d/B1yUdCcf763+nx5pSfjBuY5TweS2A9rvV +YueIovelIc6bkWzgXE2I87jc9sH5SBRqdQPBoansgavlYOSnwPvJuWun92Yko+Sj +dH1MfC5kQVSMnPOd/jb1BsSyP9DU0i07VkgEJXcClsTwrJTcRJ+aZB6zkgO3+5b+ +5ycaX8Xl9S8Nyg3jZIMENJZqzpIs90zsxNbCh2Gs7qWSNC4Mo54a38YKPsNwBfw6 +bt98bD5H9n0nqS6KDIm+IZiHiQJVBBABCgA/FiEE+/q9tUG13JVb2bpu2xbPW7El +JcQFAlyzi+UhGmh0dHA6Ly9ncGcuZ2FubmVmZi5kZS9wb2xpY3kudHh0AAoJENsW +z1uxJSXEeu0QAIrnRqQc8Ooof8fnjFw2gGQ8Hsi50Eum1RHd+x+ar8LOsNdhSIU8 +gF0LhqVLIgDRphDmd8JpznhUz5Jgcy3N5IyV7YS5MGpT41WEpQ6tWW86O8UqpbHZ +Wdye04VCzmBO273udMOO7Jxe9fjDwZTtJWemKXQ4PTAtIQzDrHXYDgfno++3O7R2 +sJqYlKsn/fmIYj1PKmYA3lP2SMyqtN6J+nERxQW90444vaakgGDoXxe4Bi8wxfys +YHZl5CBnIBk7M0wK0vA67Y1B0W0VVH+wR01lF/237jqgKHvM5vaI9wtyJSh1+DoI +Qau30LpumUN5sp85C7dVkBVr1yYOJOGgMavcvHm2g0dsM7wPqpmBs9wzT9w0PPp4 +65IlL1BIBNdELsa+N/4u13ljbexroGxt6CLH0Ggk/WqSojRcOLSwbgAQwP5OtYtg +NVH82ptK5vlFwtyMUlzML33+P4FXrXC6z8XLKLU5Mj2I4KHBy+otumfsznDGe5WD +E7SLSuKZ4/OcWmvBDiCyEbeKhA2SgClb3XPw3K7IMsiTuWcvJO+TAnTme1jZFAfy +rdKyApQT1BpyjCObpkoQ6K8blsJmeho+wyph8NBeprYzti3Pq2UT6/1V+AjLPYm6 +tq85yFM1XYJH1CLgDs9LZnk7eANjw3CISmK8JBNnppHVTX96y29GpWkLuQINBFyy +58ABEADNMz56VUq7Jvb0xSD5yOnVwCe1eaQSssXlGZaaFHsGd1ASgtaD4FyOcJ6/ +G5tkt99t5qxi57gdZ3IbwpRcIJLuHn9H7Ynt/XlKjuTbUwLZifismkqZ0c5MCUaY +qjsPoHm/C9IXURDEUfc9F9VEOgz2q3Hj4L/e6rswFdJcECyEawGdBNmB0O3yh2Tk +DC3bE6sL4RjVf+cbTps2/Aphas0MWxz+1ONEqXgl35Ser8ktwrC/kI8uJJIWUtat +wNJGitzGSUrKF8ZxoKh9xLTQQO77uortnf3nzOplZ5NHnNbiY9walyDwSbobWpfy +UCSu/lWW2MlBqMiNIat4yj1oeI4BGOsn+y3dJjti5LMm4d3EduV2Tx9Xv+elpIef +gM1/TSg6yCl7T1eGayrFWFgjwzGDM/k1JxE1URUqxaIvdYA2iz8SNOWfekhJOasb +CrYUWFN3b/x+T1ynrBkCH9TIl1fcJ91Z2BEUznT3NzLp6Pt2ViRicg7DZ4fATAKL +g8qSUGMdoVcJuQ/feiJ2Fkyvz2Z8xEHLianAMCEzlu/5QDaoGEgxC3CO2tu9b9CN +5FgQoNOuWLqG6nMY2V5qNy8TKc7O0vSaK7TK2QMSNNgoRcXpTKSg6XQBYdfxRLd0 +gejtxRSTom43nmdCl4Mgn15C4GZASom1ZUl4HfnQ2nsQMhze3QARAQABiQRyBBgB +CgAmFiEEXmGyFyZdqYB6I8X/TfqycMqpbfoFAlyy58ACGwIFCQ8JnAACQAkQTfqy +cMqpbfrBdCAEGQEKAB0WIQRSN87u8hLz1Rx0q+ARJpWg5WKzKgUCXLLnwAAKCRAR +JpWg5WKzKk6nD/4/dTAIux+ku4CzRCk1Ql+U82bQCyQoNRbTszXhIowrqm78RuRA +TWQKvSEp4dGN3V0Z4yXsGSKGmL7xFLplK3wvatxDBqH0g0NBHK2Nbivq3iUHvyrc +isg2sEcQDjSEk1uT6lw5DjuRMyL4G22LA+iz9yluKhIQNU7Uyd1+Da+2maOiCoTU +fLBlxBallgoCCxSx6eAUtMSYQJFFFLwpsgJjJUJdRd7yAJ9yCIOzumIowaZz693r +aBNo1WgLyOQVDBYu9nNmMpvsYVL/kjwWRt8bC04aplhgZVZ/uxvtYRB87nscrFSO +cYhsK9BhuC7a4zXOROeLLZ+5tdDvBavFlA9JeFjZv4Me2YszGFI+LiZOj4Ei1VuP +vYuzFbweHFyNqthGinBZ/zYNtluesZ17HtfkkrTSYGg4SPNdwUz7JIjMON+tML5r +oGeiQy2L74QN0hwWa7h8E7tLvN57qedtPbpNsw+xS81mZTaOEnIWnIGvY8qHVohu +UylLLABiyeIO1AI8xtQPiTdUBKHAYbYIBgp5WfKDai/ike1w4dT5nWFSLeuGfBnZ +W4ibKZ47f/uSroxQrwa7sQdSbiy7dFu37OVjSuw8pefeo8T65UMo9ZXPu0sjr+jc +mtH2nwc2XttWBLD4n6hZ8Z7GTtP+gkHri3vkSeSJlZC3Nh2/OITYXZzBxXL6D/4w +Ep2HpKsa/NFpWhkSe+ymmGm4qB2Z70URe6qZRqnDO3A0rvX5KSNf+Uk1Y26fTcdB +DdPyPu0uXAS7oBQ9ATdxSEp57O3y9XhUDQhD76K1C+Ob5kp14sBVLJbwv6SMGG8N +S6DZUsasARofWzICMmJCy8hF472rdC6MHMa1ERd4mBIUuLt95C8/r5BbbnM2dWWx +qZL74DtPLLdYjUAFCorQGpzDGSg5BorWzkXoGxEfUb3SORjCXp5TpwYlgij12oDT +/46Ub+5HFcGYXG42Ur+Q3W4lzS662uZeBxAEeUd1LsxDI0AcndRhJMhJQ4mCyoxA +Z6Jnf1SkGAvnRklT0pRfElhZTOv9gS1HPNWWv9vj4DGwAyNl0B6KZnxjZgcDs/4z +jPukq3wCMsjs97rEo47YKhmSoW/XyHww77Jd4FHyIlBBc9VRkLImXbV5DUOm+lPF +H0DgUJmtqE0TGxNkD3C/qUsJLt9UatuCLuwhXWAb1Hat4aeQdKfRzuDdEF2egNJt +5uUh8hTS4BM6fi6YNMSCDeOKb6pyjUl2eCGVh0My3McH7GT4zOYfh3fF+LZbpd9m +dt0hJQvyPMroCXp96AdBzi7dJI+PafUq1J83xXpBTFhzQCEASDpJmw9Ayp1AjWsQ +6ZDxX0OZW3322Ukm9NcVRdnsrYkxfR/ykNbsq1HTMg== +=qdgb +-----END PGP PUBLIC KEY BLOCK-----