diff --git a/.circleci/config.yml b/.circleci/config.yml index 10c385d02e6..69a60dd2621 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -135,6 +135,7 @@ jobs: - run: name: Run tests + no_output_timeout: 20m command: | export TESTFILES=$(cd securedrop; circleci tests glob 'tests/test*py' 'tests/**/test*py' |circleci tests split --split-by=timings |xargs echo) docker rm -f securedrop-test-xenial-py2 || true diff --git a/.gitignore b/.gitignore index f747423d84a..748d996fb80 100644 --- a/.gitignore +++ b/.gitignore @@ -8,6 +8,9 @@ install_files/ansible-base/group_vars/all/site-specific # ignore securedrop-app-code wheelhouse archive wheelhouse +# ignore the instance information JSON file to prevent commit of private info +securedrop/tests/functional/instance_information.json + # ignore the ATHS/THS hostname file ansible places app-ssh-aths app-document-aths # leave this here for historic reasons @@ -156,3 +159,6 @@ raw-test-output/ #These files are used in CI/dev env for determining whether to rebuild docker #images *.checksum +#Functional test logs +securedrop/tests/functional/firefox.log +securedrop/geckodriver.log diff --git a/Makefile b/Makefile index 1e133d12d45..7e55fb227cd 100644 --- a/Makefile +++ b/Makefile @@ -30,7 +30,7 @@ install-mypy: ## pip install mypy in a dedicated python3 virtualenv if [[ ! -d .python3/.venv ]] ; then \ virtualenv --python=python3 .python3/.venv && \ .python3/.venv/bin/pip3 install mypy ; \ - fi + fi .PHONY: typelint typelint: install-mypy ## Runs type linting diff --git a/changelog.md b/changelog.md index c1f55cf6179..2c39ba8c28e 100644 --- a/changelog.md +++ b/changelog.md @@ -34,7 +34,7 @@ ### Operations * Ensured WiFi related packages are not installed on Xenial on upgrade (#4163) -* Try harder to attach to a `tmux` session on upgrade (#4221) +* Try harder to attach to a `tmux` session on upgrade (#4221) * Control locale during Ansible runs (#4252) ### Tails Environment @@ -157,7 +157,7 @@ * Updated OSSEC to 3.0.0 and use GPG signatures for verifying sources (#3701) * Update paramiko to 2.4.2 (#3861) -* Enforce use of the latest grsecurity-patched kernel on servers (#3842) +* Enforce use of the latest grsecurity-patched kernel on servers (#3842) ### Development @@ -206,7 +206,7 @@ https://github.com/freedomofpress/securedrop/milestone/44 ### Web Applications -* Adds a new supported language: Swedish (#3570) +* Adds a new supported language: Swedish (#3570) * Replace PyCryptodome with pyca/cryptography (#3458) * Add explanatory text to source interface screensaver (#3439, #3455) * Rename "Delete collection" on journalist interface for clarity (#2419) @@ -312,7 +312,7 @@ https://github.com/freedomofpress/securedrop/milestones/0.7. * Add commands to check for and apply updates to the securedrop-admin CLI (#2976). -### Developer Workflow +### Developer Workflow * Make the Docker-based development environment the default (#2902). * Rebase branches prior to running CI jobs (#2934). @@ -531,12 +531,12 @@ https://github.com/freedomofpress/securedrop/milestones/0.4.1. The issues for this release were tracked in the 0.4 milestone on Github: https://github.com/freedomofpress/securedrop/milestones/0.4. -This changelog shows major changes below. Please diff the tags to see the full list of changes. +This changelog shows major changes below. Please diff the tags to see the full list of changes. ### Deployment * Enable optional HTTPS on the source interface (#1605). -* Standardize SecureDrop server installation on a single username (#1796). +* Standardize SecureDrop server installation on a single username (#1796). * Add `securedrop-admin` script and update version of Ansible running in the workstation (#1146, #1885). * Add validation of user-provided values during SecureDrop installation (#1663, #749, #1257). * Removes `prod-specific.yml` configuration file (#1758). @@ -549,10 +549,10 @@ This changelog shows major changes below. Please diff the tags to see the full l ### Developer Workflow * Reconciles divergent master and develop branches (#1559). -* Increases unit test coverage to from 65% to 92%. -* Adds testinfra system configuration test suite (#1580). +* Increases unit test coverage to from 65% to 92%. +* Adds testinfra system configuration test suite (#1580). * Removes unnecessary test wrappers (#1412). -* Major improvements to SecureDrop CI and testing flow including adding the staging environment to CI (#1067). +* Major improvements to SecureDrop CI and testing flow including adding the staging environment to CI (#1067). ### Web App: Source @@ -569,10 +569,10 @@ This changelog shows major changes below. Please diff the tags to see the full l * Adds minimum password length requirements for new journalist accounts (#980). * Delete submissions that have had their sources deleted (#1188). * Bugfix: Empty replies can no longer be sent to a source (#1715). -* Bugfix: Handle non hexadecimal digits for the 2FA secret (#1869). +* Bugfix: Handle non hexadecimal digits for the 2FA secret (#1869). * Bugfix: Handle token reuse for the 2FA secret on /admin/2fa (#1687). -* Bugfix: Handle attempts to make duplicate user accounts (#1693). -* Bugfix: Fix confusing UI on message/reply icons (#1258). +* Bugfix: Handle attempts to make duplicate user accounts (#1693). +* Bugfix: Fix confusing UI on message/reply icons (#1258). ### Tails Environment diff --git a/docs/set_up_admin_tails.rst b/docs/set_up_admin_tails.rst index b1353d8daa2..0e0791f929d 100644 --- a/docs/set_up_admin_tails.rst +++ b/docs/set_up_admin_tails.rst @@ -21,7 +21,7 @@ specific Tails session and click *Add*. And finally click *Start Tails*. .. note:: The *Administration password* is a one-time password. It - will reset every time you shut down Tails. + will reset every time you shut down Tails. After Tails finishes booting, make sure you're connected to the Internet |Network| and that the Tor status onion icon is not crossed out @@ -51,7 +51,7 @@ Start by running the following commands to download the git repository. git clone https://github.com/freedomofpress/securedrop.git .. note:: Since the repository is fairly large and Tor can be slow, - this may take a few minutes. + this may take a few minutes. .. caution:: Do not download SecureDrop Git repository as a Zip file, or any other means. Only download by using the given git @@ -151,8 +151,8 @@ To use the template: on the encrypted persistent volume, this additional passphrase is not necessary. .. warning:: You will not be able to access your passwords if you - forget the master password or the location of the key - file used to protect the database. + forget the master password or the location of the key + file used to protect the database. In case you wish to manually create a database, the suggested password fields in the admin template are: diff --git a/install_files/ansible-base/roles/app-test/defaults/main.yml b/install_files/ansible-base/roles/app-test/defaults/main.yml index 86dacbbb7f5..043e67f44b5 100644 --- a/install_files/ansible-base/roles/app-test/defaults/main.yml +++ b/install_files/ansible-base/roles/app-test/defaults/main.yml @@ -2,3 +2,11 @@ # Username for Apache service, used to set permissions on the # Source Interface config to enable logging in the staging environment. apache_user: www-data + +# Specify TBB functional_test.json file defaults +tbb_sleep_time: 160 +tbb_selenium_user: journalist +tbb_selenium_password: correct horse battery staple profanity oil chewy +tbb_selenium_secret: JHCOGO7VCER3EJ4L +test_sd_root_dir: "{{ lookup('pipe','git rev-parse --show-toplevel') }}" +tbb_funcfolder: "{{ test_sd_root_dir }}/securedrop/tests/functional/instance_information.json" diff --git a/install_files/ansible-base/roles/app-test/files/tor_app.fact b/install_files/ansible-base/roles/app-test/files/tor_app.fact new file mode 100644 index 00000000000..b4818591b56 --- /dev/null +++ b/install_files/ansible-base/roles/app-test/files/tor_app.fact @@ -0,0 +1,44 @@ +#!/usr/bin/env python3 +# +# +# Ansible local fact producer for tor onion details of app server +# to be chucked into /etc/ansible/facts.d/ with a .fact suffix + +import json +import os + +TOR_SVC_PATH = "/var/lib/tor/services/" +JOURNALIST_DIR = "journalist" +SOURCE_DIR = "source" + + +def extract_sd_onion_data(tor_path=TOR_SVC_PATH, + journalist_dir=JOURNALIST_DIR, + source_dir=SOURCE_DIR, + protocol="http"): + + for interface in [journalist_dir, source_dir]: + hostname_file = os.path.join(TOR_SVC_PATH, interface, 'hostname') + try: + with open(hostname_file) as f: + tor_config = f.readline().rstrip().split() + + onion_addr = "{p}://{a}".format(p=protocol, a=tor_config[0]) + auth_token = tor_config[1] + + # This must be a source interface because we dont see hidservauth info + except IndexError: + source_int = onion_addr + # One of the files doesn't exist :| Maybe tor setup hasnt run yet. + except IOError: + return dict() + else: + journalist_int = onion_addr + + return dict(journalist_location=journalist_int, + source_location=source_int, + hidserv_token=auth_token) + + +if __name__ == '__main__': + print(json.dumps(extract_sd_onion_data())) diff --git a/install_files/ansible-base/roles/app-test/tasks/extract_apptor_test_config.yml b/install_files/ansible-base/roles/app-test/tasks/extract_apptor_test_config.yml new file mode 100644 index 00000000000..b44aa78329c --- /dev/null +++ b/install_files/ansible-base/roles/app-test/tasks/extract_apptor_test_config.yml @@ -0,0 +1,38 @@ +--- + +- name: Create ansible fact directory + file: + path: /etc/ansible/facts.d + recurse: yes + state: directory + owner: root + group: root + +- name: Copy over tor application fact file + copy: + src: tor_app.fact + dest: /etc/ansible/facts.d/tor_app.fact + mode: 0755 + +- name: Refresh remote "local facts" for glory + setup: + filter: ansible_local + +- name: Gather apptest facts to dict to prepare for output + set_fact: + _tbb_selenium_dict: + hidserv_token: "{{ ansible_local.tor_app.hidserv_token }}" + journalist_location: "{{ ansible_local.tor_app.journalist_location }}" + source_location: "{{ ansible_local.tor_app.source_location }}" + sleep_time: "{{ tbb_sleep_time }}" + user: + name: "{{ tbb_selenium_user }}" + password: "{{ tbb_selenium_password }}" + secret: "{{ tbb_selenium_secret }}" + +- name: Dump facts to local json for in-take + copy: + content: "{{ _tbb_selenium_dict | to_nice_json }}" + dest: "{{ tbb_funcfolder }}" + become: no + delegate_to: localhost diff --git a/install_files/ansible-base/roles/app-test/tasks/main.yml b/install_files/ansible-base/roles/app-test/tasks/main.yml index a475e019ffd..c94759719b3 100644 --- a/install_files/ansible-base/roles/app-test/tasks/main.yml +++ b/install_files/ansible-base/roles/app-test/tasks/main.yml @@ -5,3 +5,9 @@ - apache - include: modern_gettext.yml + tags: + - modern_gettext + +- import_tasks: extract_apptor_test_config.yml + tags: + - functional_test diff --git a/install_files/ansible-base/roles/build-securedrop-app-code-deb-pkg/files/changelog-trusty b/install_files/ansible-base/roles/build-securedrop-app-code-deb-pkg/files/changelog-trusty index e5e1c0d1d27..0083f2baf61 100644 --- a/install_files/ansible-base/roles/build-securedrop-app-code-deb-pkg/files/changelog-trusty +++ b/install_files/ansible-base/roles/build-securedrop-app-code-deb-pkg/files/changelog-trusty @@ -12,13 +12,13 @@ securedrop-app-code (0.12.2+trusty) trusty; urgency=medium securedrop-app-code (0.12.1+trusty) trusty; urgency=medium - * See changelog.md + * See changelog.md -- SecureDrop Team Wed, 20 Mar 2019 20:20:21 +0000 securedrop-app-code (0.12.0+trusty) trusty; urgency=medium - * See changelog.md + * See changelog.md -- SecureDrop Team Wed, 27 Feb 2019 00:36:47 +0000 diff --git a/install_files/ansible-base/roles/build-securedrop-app-code-deb-pkg/files/changelog-xenial b/install_files/ansible-base/roles/build-securedrop-app-code-deb-pkg/files/changelog-xenial index 3da7358ebf8..bcbe88e451a 100644 --- a/install_files/ansible-base/roles/build-securedrop-app-code-deb-pkg/files/changelog-xenial +++ b/install_files/ansible-base/roles/build-securedrop-app-code-deb-pkg/files/changelog-xenial @@ -12,13 +12,12 @@ securedrop-app-code (0.12.2+xenial) xenial; urgency=medium securedrop-app-code (0.12.1+xenial) xenial; urgency=medium - * See changelog.md + * See changelog.md -- SecureDrop Team Wed, 20 Mar 2019 20:20:40 +0000 securedrop-app-code (0.12.0+xenial) xenial; urgency=medium - * See changelog.md + * See changelog.md -- SecureDrop Team Wed, 27 Feb 2019 00:37:02 +0000 - diff --git a/install_files/ansible-base/roles/tor-hidden-services/handlers/restart-tor-carefully.yml b/install_files/ansible-base/roles/tor-hidden-services/handlers/restart-tor-carefully.yml index 2d0be507f9b..8be5bc89e6e 100644 --- a/install_files/ansible-base/roles/tor-hidden-services/handlers/restart-tor-carefully.yml +++ b/install_files/ansible-base/roles/tor-hidden-services/handlers/restart-tor-carefully.yml @@ -48,3 +48,7 @@ search_regex: OpenSSH state: started become: no + +- name: Refresh ansible local facts + setup: + filter: ansible_local diff --git a/molecule/upgrade/create.yml b/molecule/upgrade/create.yml index 8cf7a517ded..96d64dd4398 100644 --- a/molecule/upgrade/create.yml +++ b/molecule/upgrade/create.yml @@ -57,3 +57,14 @@ content: "{{ instance_conf | to_json | from_json | molecule_to_yaml | molecule_header }}" dest: "{{ molecule_instance_config }}" when: server.changed | bool + + - name: Ensure roles dir in-place + file: + path: "{{ lookup('env', 'MOLECULE_EPHEMERAL_DIRECTORY') }}/roles" + state: directory + + - name: Over-ride stable apt-test role logic with one from current branch + file: + src: "{{ lookup('pipe', 'git rev-parse --show-toplevel') }}/install_files/ansible-base/roles/app-test" + dest: "{{ lookup('env', 'MOLECULE_EPHEMERAL_DIRECTORY') }}/roles/app-test" + state: link diff --git a/molecule/upgrade/playbook.yml b/molecule/upgrade/playbook.yml index b916109a56d..6a49ba99e16 100644 --- a/molecule/upgrade/playbook.yml +++ b/molecule/upgrade/playbook.yml @@ -85,7 +85,6 @@ tags: always become: yes - - import_playbook: apt.yml tags: apt diff --git a/molecule/vagrant-packager/box_files/app_trusty_metadata.json b/molecule/vagrant-packager/box_files/app_trusty_metadata.json index 2fd80820e11..8aa495cbc54 100644 --- a/molecule/vagrant-packager/box_files/app_trusty_metadata.json +++ b/molecule/vagrant-packager/box_files/app_trusty_metadata.json @@ -1,83 +1,72 @@ { - "description": "This box contains securedrop app server.", "name": "fpf/securedrop-app-trusty", + "description": "This box contains securedrop app server.", "versions": [ { + "version": "0.7.0", "providers": [ { - "checksum": "468923f1e77068b8de96808ed8f52dbe93db3ff0aba8647c37c2d2e83b8367e9", - "checksum_type": "sha256", "name": "libvirt", - "url": "https://s3.amazonaws.com/securedrop-vagrant/app-staging_0.7.box" - } - ], - "version": "0.7.0" - }, - { - "providers": [ - { - "checksum": "524056caec12a170132ed02f3b8727056d1aeb3ce7050c074be34f259dc6beed", + "url": "https://s3.amazonaws.com/securedrop-vagrant/app-staging_0.7.box", "checksum_type": "sha256", - "name": "libvirt", - "url": "https://s3.amazonaws.com/securedrop-vagrant/app-staging_0.8.box" + "checksum": "468923f1e77068b8de96808ed8f52dbe93db3ff0aba8647c37c2d2e83b8367e9" } - ], - "version": "0.8.0" + ] }, { + "version": "0.8.0", "providers": [ { - "checksum": "6fb8c12821b902b0905f967d7405c620443f4f4345b18d05b59005f798a08e50", - "checksum_type": "sha256", "name": "libvirt", - "url": "https://s3.amazonaws.com/securedrop-vagrant/app-staging_0.9.1.box" + "url": "https://s3.amazonaws.com/securedrop-vagrant/app-staging_0.8.box", + "checksum_type": "sha256", + "checksum": "524056caec12a170132ed02f3b8727056d1aeb3ce7050c074be34f259dc6beed" } - ], - "version": "0.9.1" + ] }, { + "version": "0.9.1", "providers": [ { - "checksum": "cf2c4c8ac89bd132d3f75ee77e2d97b68c562e1ee36aa059bb1d4e6b37499f62", - "checksum_type": "sha256", "name": "libvirt", - "url": "https://s3.amazonaws.com/securedrop-vagrant/app-staging_0.11.0.box" + "url": "https://s3.amazonaws.com/securedrop-vagrant/app-staging_0.9.1.box", + "checksum_type": "sha256", + "checksum": "6fb8c12821b902b0905f967d7405c620443f4f4345b18d05b59005f798a08e50" } - ], - "version": "0.11.0" + ] }, { + "version": "0.11.0", "providers": [ { - "checksum": "e832c4940ef10e8d999033271454f7220c85f4b0a89f378906895d4a82478eee", - "checksum_type": "sha256", "name": "libvirt", - "url": "https://s3.amazonaws.com/securedrop-vagrant/app-staging_0.11.1.box" + "url": "https://s3.amazonaws.com/securedrop-vagrant/app-staging_0.11.0.box", + "checksum_type": "sha256", + "checksum": "cf2c4c8ac89bd132d3f75ee77e2d97b68c562e1ee36aa059bb1d4e6b37499f62" } - ], - "version": "0.11.1" + ] }, { + "version": "0.11.1", "providers": [ { - "checksum": "db9f077d0b9f960c5d36a8a804a791151271009c7490fe3a4c715b71998afcd8", - "checksum_type": "sha256", "name": "libvirt", - "url": "https://s3.amazonaws.com/securedrop-vagrant/app-staging-trusty_0.12.0.box" + "url": "https://s3.amazonaws.com/securedrop-vagrant/app-staging_0.11.1.box", + "checksum_type": "sha256", + "checksum": "e832c4940ef10e8d999033271454f7220c85f4b0a89f378906895d4a82478eee" } - ], - "version": "0.12.0" + ] }, { + "version": "0.12.0", "providers": [ { - "checksum": "4c668f06619a532293409d8bc64f69ee66697a2122f2a9a461a15ad57869a6b5", - "checksum_type": "sha256", "name": "libvirt", - "url": "https://s3.amazonaws.com/securedrop-vagrant/app-staging-trusty_0.12.1.box" + "url": "https://s3.amazonaws.com/securedrop-vagrant/app-staging-trusty_0.12.0.box", + "checksum_type": "sha256", + "checksum": "db9f077d0b9f960c5d36a8a804a791151271009c7490fe3a4c715b71998afcd8" } - ], - "version": "0.12.1" + ] } ] -} \ No newline at end of file +} diff --git a/molecule/vagrant-packager/box_files/app_xenial_metadata.json b/molecule/vagrant-packager/box_files/app_xenial_metadata.json index f25c05a37f6..fb9f440baad 100644 --- a/molecule/vagrant-packager/box_files/app_xenial_metadata.json +++ b/molecule/vagrant-packager/box_files/app_xenial_metadata.json @@ -25,4 +25,4 @@ "version": "0.12.1" } ] -} \ No newline at end of file +} diff --git a/molecule/vagrant-packager/box_files/mon_trusty_metadata.json b/molecule/vagrant-packager/box_files/mon_trusty_metadata.json index fa6cb846e13..21ebddba5a5 100644 --- a/molecule/vagrant-packager/box_files/mon_trusty_metadata.json +++ b/molecule/vagrant-packager/box_files/mon_trusty_metadata.json @@ -1,83 +1,72 @@ { - "description": "This box contains securedrop monitor server.", "name": "fpf/securedrop-mon-trusty", + "description": "This box contains securedrop monitor server.", "versions": [ { + "version": "0.7.0", "providers": [ { - "checksum": "4358d2e31ee5dcfe4098fd2bedba3122967992de4c9b2dfb773805141d5ad633", - "checksum_type": "sha256", "name": "libvirt", - "url": "https://s3.amazonaws.com/securedrop-vagrant/mon-staging_0.7.box" - } - ], - "version": "0.7.0" - }, - { - "providers": [ - { - "checksum": "c18fe9dddf28cc70b858b878550c5ae202e4a2c752119528ab7d2062dab15842", + "url": "https://s3.amazonaws.com/securedrop-vagrant/mon-staging_0.7.box", "checksum_type": "sha256", - "name": "libvirt", - "url": "https://s3.amazonaws.com/securedrop-vagrant/mon-staging_0.8.box" + "checksum": "4358d2e31ee5dcfe4098fd2bedba3122967992de4c9b2dfb773805141d5ad633" } - ], - "version": "0.8.0" + ] }, { + "version": "0.8.0", "providers": [ { - "checksum": "9891c88aa7148129f2f91638d7dfed1e7815eb980bba1de8a9c075f14ae0ddeb", - "checksum_type": "sha256", "name": "libvirt", - "url": "https://s3.amazonaws.com/securedrop-vagrant/mon-staging_0.9.1.box" + "url": "https://s3.amazonaws.com/securedrop-vagrant/mon-staging_0.8.box", + "checksum_type": "sha256", + "checksum": "c18fe9dddf28cc70b858b878550c5ae202e4a2c752119528ab7d2062dab15842" } - ], - "version": "0.9.1" + ] }, { + "version": "0.9.1", "providers": [ { - "checksum": "baba21e8799fe2093d902b332b45d7a8342adf019fa195382011fbdfa54cd1d5", - "checksum_type": "sha256", "name": "libvirt", - "url": "https://s3.amazonaws.com/securedrop-vagrant/mon-staging_0.11.0.box" + "url": "https://s3.amazonaws.com/securedrop-vagrant/mon-staging_0.9.1.box", + "checksum_type": "sha256", + "checksum": "9891c88aa7148129f2f91638d7dfed1e7815eb980bba1de8a9c075f14ae0ddeb" } - ], - "version": "0.11.0" + ] }, { + "version": "0.11.0", "providers": [ { - "checksum": "bbc8ed55fab20ed96c3b090126b69baabbd41e95faa60676dff72bc69af67376", - "checksum_type": "sha256", "name": "libvirt", - "url": "https://s3.amazonaws.com/securedrop-vagrant/mon-staging_0.11.1.box" + "url": "https://s3.amazonaws.com/securedrop-vagrant/mon-staging_0.11.0.box", + "checksum_type": "sha256", + "checksum": "baba21e8799fe2093d902b332b45d7a8342adf019fa195382011fbdfa54cd1d5" } - ], - "version": "0.11.1" + ] }, { + "version": "0.11.1", "providers": [ { - "checksum": "0ac7538f52b3450a1791a06b8a02fe81b65637da92bb00a61b669beccef87f8d", - "checksum_type": "sha256", "name": "libvirt", - "url": "https://s3.amazonaws.com/securedrop-vagrant/mon-staging-trusty_0.12.0.box" + "url": "https://s3.amazonaws.com/securedrop-vagrant/mon-staging_0.11.1.box", + "checksum_type": "sha256", + "checksum": "bbc8ed55fab20ed96c3b090126b69baabbd41e95faa60676dff72bc69af67376" } - ], - "version": "0.12.0" + ] }, { + "version": "0.12.0", "providers": [ { - "checksum": "56d1fee8e1b5f27e69a6aa2159e38340dbb3b33326977428cf43af0fc74ae0ba", - "checksum_type": "sha256", "name": "libvirt", - "url": "https://s3.amazonaws.com/securedrop-vagrant/mon-staging-trusty_0.12.1.box" + "url": "https://s3.amazonaws.com/securedrop-vagrant/mon-staging-trusty_0.12.0.box", + "checksum_type": "sha256", + "checksum": "0ac7538f52b3450a1791a06b8a02fe81b65637da92bb00a61b669beccef87f8d" } - ], - "version": "0.12.1" + ] } ] -} \ No newline at end of file +} diff --git a/molecule/vagrant-packager/box_files/mon_xenial_metadata.json b/molecule/vagrant-packager/box_files/mon_xenial_metadata.json index 14c5e2a179e..63b06703c19 100644 --- a/molecule/vagrant-packager/box_files/mon_xenial_metadata.json +++ b/molecule/vagrant-packager/box_files/mon_xenial_metadata.json @@ -25,4 +25,4 @@ "version": "0.12.1" } ] -} \ No newline at end of file +} diff --git a/molecule/vagrant-packager/destroy.yml b/molecule/vagrant-packager/destroy.yml deleted file mode 100644 index 1ce71fc8f7c..00000000000 --- a/molecule/vagrant-packager/destroy.yml +++ /dev/null @@ -1,41 +0,0 @@ ---- - -- name: Destroy - hosts: localhost - connection: local - vars: - molecule_file: "{{ lookup('env', 'MOLECULE_FILE') }}" - molecule_instance_config: "{{ lookup('env',' MOLECULE_INSTANCE_CONFIG') }}" - molecule_scenario_dir: "{{ lookup('env','MOLECULE_SCENARIO_DIRECTORY') }}" - molecule_yml: "{{ lookup('file', molecule_file) | molecule_from_yaml }}" - molecule_ephemeral_directory: "{{ lookup('env', 'MOLECULE_EPHEMERAL_DIRECTORY') }}" - tasks: - - name: Destroy molecule instance(s) - molecule_vagrant: - instance_name: "{{ item.name }}" - platform_box: "{{ item.box }}" - provider_name: "{{ molecule_yml.driver.provider.name }}" - force_stop: "{{ item.force_stop | default(True) }}" - - state: destroy - register: server - with_items: "{{ molecule_yml.platforms }}" - - - name: Destroy local molecule ephemeral dir - file: - state: absent - path: "{{ molecule_scenario_dir }}/.molecule" - - # Mandatory configuration for Molecule to function. - - - name: Populate instance config - set_fact: - instance_conf: {} - - - name: Dump instance config - copy: - # NOTE(retr0h): Workaround for Ansible 2.2. - # https://github.com/ansible/ansible/issues/20885 - content: "{{ instance_conf | to_json | from_json | molecule_to_yaml | molecule_header }}" - dest: "{{ molecule_instance_config }}" - when: server.changed | bool diff --git a/molecule/vagrant-packager/prepare.yml b/molecule/vagrant-packager/prepare.yml deleted file mode 100644 index 112da199828..00000000000 --- a/molecule/vagrant-packager/prepare.yml +++ /dev/null @@ -1,9 +0,0 @@ ---- -- name: Prepare - hosts: all - gather_facts: False - tasks: - - name: Install python for Ansible - raw: test -e /usr/bin/python || (apt -y update && apt install -y python-minimal) - become: True - changed_when: False diff --git a/securedrop/bin/run-test b/securedrop/bin/run-test index d06b146fbb9..ca2753a9ed0 100755 --- a/securedrop/bin/run-test +++ b/securedrop/bin/run-test @@ -5,9 +5,8 @@ set -euo pipefail source "${BASH_SOURCE%/*}/dev-deps" -run_xvfb -run_redis & setup_vncauth +run_redis & run_x11vnc & urandom run_sass --force --update @@ -26,6 +25,7 @@ mkdir -p "/tmp/test-results/logs" : "${PAGE_LAYOUT_LOCALES:=en_US,ar,fr_FR}" export PAGE_LAYOUT_LOCALES +export TOR_FORCE_NET_CONFIG=0 py.test \ --page-layout \ diff --git a/securedrop/dockerfiles/trusty/python2/Dockerfile b/securedrop/dockerfiles/trusty/python2/Dockerfile index 982248d0296..6e5d5e885ca 100644 --- a/securedrop/dockerfiles/trusty/python2/Dockerfile +++ b/securedrop/dockerfiles/trusty/python2/Dockerfile @@ -6,19 +6,45 @@ ARG USER_ID ENV USER_ID ${USER_ID:-0} RUN apt-get update && \ - apt-get install -y devscripts vim \ + apt-get install -y devscripts \ python-pip libpython2.7-dev libssl-dev secure-delete \ - gnupg2 ruby redis-server firefox git xvfb haveged curl \ - gettext paxctl x11vnc enchant libffi-dev sqlite3 + gnupg2 ruby redis-server git xvfb haveged curl \ + gettext paxctl tightvncserver enchant libffi-dev sqlite3 wget \ + libasound2 libdbus-glib-1-2 libgtk2.0-0 libfontconfig1 libxrender1 \ + libcairo-gobject2 libgtk-3-0 libstartup-notification0 RUN gem install sass -v 3.4.23 -ENV FIREFOX_CHECKSUM=88d25053306d33658580973b063cd459a56e3596a3a298c1fb8ab1d52171d860 -RUN curl -LO https://launchpad.net/~ubuntu-mozilla-security/+archive/ubuntu/ppa/+build/9727836/+files/firefox_46.0.1+build1-0ubuntu0.14.04.3_amd64.deb && \ - shasum -a 256 firefox*deb && \ - echo "${FIREFOX_CHECKSUM} firefox_46.0.1+build1-0ubuntu0.14.04.3_amd64.deb" | shasum -a 256 -c - && \ - dpkg -i firefox*deb && apt-get install -f && \ - paxctl -cm /usr/lib/firefox/firefox +ENV FF_ESR_VER 60.2.0esr +RUN curl -LO https://ftp.mozilla.org/pub/firefox/releases/${FF_ESR_VER}/linux-x86_64/en-US/firefox-${FF_ESR_VER}.tar.bz2 && \ + curl -LO https://ftp.mozilla.org/pub/firefox/releases/${FF_ESR_VER}/linux-x86_64/en-US/firefox-${FF_ESR_VER}.tar.bz2.asc && \ + gpg --recv-key --keyserver gpg.mozilla.org 0x61B7B526D98F0353 && \ + gpg --verify firefox-${FF_ESR_VER}.tar.bz2.asc && \ + tar xjf firefox-*.tar.bz2 && \ + mv firefox /usr/bin && \ + paxctl -cm /usr/bin/firefox/firefox + +COPY ./tor_project_public.pub /opt/ + +ENV TBB_VERSION 8.0.3 +RUN gpg --import /opt/tor_project_public.pub && \ + wget https://www.torproject.org/dist/torbrowser/${TBB_VERSION}/tor-browser-linux64-${TBB_VERSION}_en-US.tar.xz && \ + wget https://www.torproject.org/dist/torbrowser/${TBB_VERSION}/tor-browser-linux64-${TBB_VERSION}_en-US.tar.xz.asc && \ + gpg --verify tor-browser-linux64-${TBB_VERSION}_en-US.tar.xz.asc tor-browser-linux64-${TBB_VERSION}_en-US.tar.xz + +RUN tar -xvJf tor-browser-linux64-${TBB_VERSION}_en-US.tar.xz && \ + mkdir -p /root/.local/tbb && mv tor-browser_en-US /root/.local/tbb &&\ + paxctl -cm /root/.local/tbb/tor-browser_en-US/Browser/firefox.real && \ + paxctl -cm /root/.local/tbb/tor-browser_en-US/Browser/libnspr4.so && \ + paxctl -cm /root/.local/tbb/tor-browser_en-US/Browser/plugin-container + +ENV GECKODRIVER_CHECKSUM=9d80799bff034eda2a233493a78e3250b7c6118c9010ec37a871783081963fda +RUN wget https://github.com/mozilla/geckodriver/releases/download/v0.22.0/geckodriver-v0.22.0-linux64.tar.gz && \ + shasum -a 256 geckodriver*tar.gz && \ + echo "${GECKODRIVER_CHECKSUM} geckodriver-v0.22.0-linux64.tar.gz" | shasum -a 256 -c - && \ + tar -zxvf geckodriver*tar.gz && chmod +x geckodriver && mv geckodriver /bin && \ + paxctl -cm /bin/geckodriver + # # This can be removed when upgrading to something more recent than trusty @@ -30,13 +56,14 @@ RUN echo deb http://archive.ubuntu.com/ubuntu/ xenial main > /etc/apt/sources.li apt-get update COPY requirements requirements -RUN pip install -U setuptools==40.8.0 && \ - pip install -r requirements/securedrop-app-code-requirements.txt && \ +RUN pip install -r requirements/securedrop-app-code-requirements.txt && \ pip install -r requirements/test-requirements.txt RUN pip install supervisor RUN if test $USER_NAME != root ; then useradd --no-create-home --home-dir /tmp --uid $USER_ID $USER_NAME && echo "$USER_NAME ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers ; fi +RUN cp -r /root/.local /tmp/ && chmod +x /tmp/.local/tbb/tor-browser_en-US/Browser/firefox && chmod -R 777 /tmp/.local +RUN chown -R $USER_NAME.$USER_NAME /tmp/.local/ STOPSIGNAL SIGKILL diff --git a/securedrop/requirements/securedrop-app-code-requirements.txt b/securedrop/requirements/securedrop-app-code-requirements.txt index 17f9b861e00..e8f59f70392 100644 --- a/securedrop/requirements/securedrop-app-code-requirements.txt +++ b/securedrop/requirements/securedrop-app-code-requirements.txt @@ -17,6 +17,7 @@ flask-babel==0.11.2 flask-sqlalchemy==2.3.2 flask-wtf==0.14.2 flask==1.0.2 +idna==2.6 # via cryptography ipaddress==1.0.22 # via cryptography itsdangerous==0.24 # via flask jinja2==2.10.1 diff --git a/securedrop/requirements/test-requirements.in b/securedrop/requirements/test-requirements.in index e8768e4bf29..fb9063f57c4 100644 --- a/securedrop/requirements/test-requirements.in +++ b/securedrop/requirements/test-requirements.in @@ -7,5 +7,7 @@ py pytest pytest-cov pytest-mock -requests -selenium < 3 +requests[socks]>2.21.0 +selenium +tbselenium +pyvirtualdisplay diff --git a/securedrop/requirements/test-requirements.txt b/securedrop/requirements/test-requirements.txt index 11224d0ae1d..e3b40217162 100644 --- a/securedrop/requirements/test-requirements.txt +++ b/securedrop/requirements/test-requirements.txt @@ -11,6 +11,7 @@ certifi==2018.11.29 # via requests chardet==3.0.4 # via requests click==6.7 # via flask, pip-tools coverage==4.4.2 # via pytest-cov +easyprocess==0.2.3 # via pyvirtualdisplay first==2.0.1 # via pip-tools flask-testing==0.7.1 flask==1.0.2 # via flask-testing @@ -24,11 +25,14 @@ pbr==3.1.1 # via mock pip-tools==1.11.0 pluggy==0.6.0 # via pytest py==1.5.2 +pysocks==1.6.8 # via requests pytest-cov==2.5.1 pytest-mock==1.7.1 pytest==3.3.2 -requests==2.21.0 -selenium==2.53.6 +pyvirtualdisplay==0.2.1 +requests[socks]==2.21.0 +selenium==3.13.0 six==1.11.0 # via mock, pip-tools, pytest urllib3==1.24.1 # via requests werkzeug==0.14.1 # via flask +tbselenium==0.3.3 diff --git a/securedrop/tests/functional/functional_test.py b/securedrop/tests/functional/functional_test.py index 23ec5a35015..d8077f3b375 100644 --- a/securedrop/tests/functional/functional_test.py +++ b/securedrop/tests/functional/functional_test.py @@ -1,26 +1,36 @@ # -*- coding: utf-8 -*- +from datetime import datetime import errno import mock +from multiprocessing import Process import os +import logging +from os.path import abspath, dirname, join, realpath, expanduser import pytest import signal import socket import time import traceback +import shutil import requests -from datetime import datetime -from multiprocessing import Process -from os.path import abspath, dirname, join, realpath +import pyotp +import pretty_bad_protocol as gnupg from selenium import webdriver from selenium.common.exceptions import (WebDriverException, NoAlertPresentException) -from selenium.webdriver.firefox import firefox_binary from selenium.webdriver.support.ui import WebDriverWait from selenium.webdriver.support import expected_conditions +from selenium.webdriver.common.action_chains import ActionChains +from selenium.webdriver.common.keys import Keys +from selenium.webdriver.remote.remote_connection import LOGGER +from tbselenium.tbdriver import TorBrowserDriver os.environ['SECUREDROP_ENV'] = 'test' # noqa + +from sqlalchemy.exc import IntegrityError +from models import Journalist from sdconfig import config import journalist_app import source_app @@ -28,7 +38,21 @@ from db import db -LOG_DIR = abspath(join(dirname(realpath(__file__)), '..', 'log')) +TBB_PATH = abspath(join(expanduser('~'), '.local/tbb/tor-browser_en-US/')) +os.environ['TBB_PATH'] = TBB_PATH +TBBRC = join(TBB_PATH, 'Browser/TorBrowser/Data/Tor/torrc') + +os.environ['SECUREDROP_ENV'] = 'test' # noqa + +FUNCTIONAL_TEST_DIR = abspath(dirname(__file__)) +LOGFILE_PATH = abspath(join(FUNCTIONAL_TEST_DIR, 'firefox.log')) +FILES_DIR = abspath(join(dirname(realpath(__file__)), '../..', 'tests/files')) +FIREFOX_PATH = '/usr/bin/firefox/firefox' + +TBB_PATH = abspath(join(expanduser('~'), '.local/tbb/tor-browser_en-US/')) +os.environ['TBB_PATH'] = TBB_PATH +TBBRC = join(TBB_PATH, 'Browser/TorBrowser/Data/Tor/torrc') +LOGGER.setLevel(logging.WARNING) # https://stackoverflow.com/a/34795883/837471 @@ -47,20 +71,79 @@ class FunctionalTest(object): def _unused_port(self): s = socket.socket() - s.bind(("localhost", 0)) + s.bind(("127.0.0.1", 0)) port = s.getsockname()[1] s.close() return port - def _create_webdriver(self, firefox, profile=None): + def _create_webdriver(self, profile=None): + log_file = open(LOGFILE_PATH, 'a') + log_file.write( + '\n\n[%s] Running Functional Tests\n' % str( + datetime.now())) + log_file.flush() # see https://review.openstack.org/#/c/375258/ and the # associated issues for background on why this is necessary connrefused_retry_count = 3 connrefused_retry_interval = 5 + # Don't use Tor when reading from localhost, and turn off private + # browsing. We need to turn off private browsing because we won't be + # able to access the browser's cookies in private browsing mode. Since + # we use session cookies in SD anyway (in private browsing mode all + # cookies are set as session cookies), this should not affect session + # lifetime. + pref_dict = {'network.proxy.no_proxies_on': '127.0.0.1', + 'browser.privatebrowsing.autostart': False} for i in range(connrefused_retry_count + 1): try: - driver = webdriver.Firefox(firefox_binary=firefox, + driver = TorBrowserDriver(TBB_PATH, + pref_dict=pref_dict, + tbb_logfile_path=LOGFILE_PATH) + if i > 0: + # i==0 is normal behavior without connection refused. + print('NOTE: Retried {} time(s) due to ' + 'connection refused.'.format(i)) + return driver + except socket.error as socket_error: + if (socket_error.errno == errno.ECONNREFUSED + and i < connrefused_retry_count): + time.sleep(connrefused_retry_interval) + continue + raise + except WebDriverException: + if i < connrefused_retry_count: + time.sleep(connrefused_retry_interval) + raise + + def _create_secondary_firefox_driver(self, profile=None): + self.f_profile_path = "/tmp/testprofile" + if os.path.exists(self.f_profile_path): + shutil.rmtree(self.f_profile_path) + if self.journalist_location.find('.onion') != -1: + os.mkdir(self.f_profile_path) + profile = webdriver.FirefoxProfile(self.f_profile_path) + # set FF preference to socks proxy in Tor Browser + profile.set_preference("network.proxy.type", 1) + profile.set_preference("network.proxy.socks", "127.0.0.1") + profile.set_preference("network.proxy.socks_port", 9150) + profile.set_preference("network.proxy.socks_version", 5) + profile.set_preference("network.proxy.socks_remote_dns", True) + profile.set_preference("network.dns.blockDotOnion", False) + profile.update_preferences() + self.second_driver = webdriver.Firefox(firefox_binary=FIREFOX_PATH, + firefox_profile=profile) + self.second_driver.implicitly_wait(15) + + def _create_webdriver2(self, profile=None): + # Only for layout tests + # see https://review.openstack.org/#/c/375258/ and the + # associated issues for background on why this is necessary + connrefused_retry_count = 3 + connrefused_retry_interval = 5 + for i in range(connrefused_retry_count + 1): + try: + driver = webdriver.Firefox(firefox_binary=FIREFOX_PATH, firefox_profile=profile) if i > 0: # i==0 is normal behavior without connection refused. @@ -74,79 +157,140 @@ def _create_webdriver(self, firefox, profile=None): continue raise - def _prepare_webdriver(self): - log_file = open(join(LOG_DIR, 'firefox.log'), 'a') - log_file.write( - '\n\n[%s] Running Functional Tests\n' % str( - datetime.now())) - log_file.flush() - return firefox_binary.FirefoxBinary(log_file=log_file) + def _javascript_toggle(self): + # the following is a noop for some reason, workaround it + # profile.set_preference("javascript.enabled", False) + # https://stackoverflow.com/a/36782979/837471 + self.driver.get("about:config") + actions = ActionChains(self.driver) + actions.send_keys(Keys.RETURN) + actions.send_keys("javascript.enabled") + actions.perform() + actions.send_keys(Keys.TAB) + actions.send_keys(Keys.RETURN) + actions.perform() + + def swap_drivers(self): + if not self.second_driver: + self._create_secondary_firefox_driver() + # Only if we two drivers + if self.driver and self.second_driver: + self.driver, self.second_driver = self.second_driver, self.driver + + def init_gpg(self): + """Initialize the GPG keyring and import the journalist key for + testing. + """ + gpg = gnupg.GPG(homedir="/tmp/testgpg") + # Faster to import a pre-generated key than a new one every time. + for keyfile in (join(FILES_DIR, "test_journalist_key.pub"), + join(FILES_DIR, "test_journalist_key.sec")): + gpg.import_keys(open(keyfile).read()) + return gpg def setup(self, session_expiration=30): - self.__context = journalist_app.create_app(config).app_context() - self.__context.push() - # Patch the two-factor verification to avoid intermittent errors - self.patcher = mock.patch('models.Journalist.verify_token') - self.mock_journalist_verify_token = self.patcher.start() - self.mock_journalist_verify_token.return_value = True + self.localtesting = False + self.driver = None + self.second_driver = None + self.new_totp = None # To be created runtime - self.patcher2 = mock.patch('source_app.main.get_entropy_estimate') - self.mock_get_entropy_estimate = self.patcher2.start() - self.mock_get_entropy_estimate.return_value = 8192 - - signal.signal(signal.SIGUSR1, lambda _, s: traceback.print_stack(s)) + instance_information_path = join(FUNCTIONAL_TEST_DIR, + 'instance_information.json') env.create_directories() self.gpg = env.init_gpg() - db.create_all() - - source_port = self._unused_port() - journalist_port = self._unused_port() - - self.source_location = "http://localhost:%d" % source_port - self.journalist_location = "http://localhost:%d" % journalist_port - - # Allow custom session expiration lengths - self.session_expiration = session_expiration - - self.source_app = source_app.create_app(config) - self.journalist_app = journalist_app.create_app(config) - def start_source_server(app): - config.SESSION_EXPIRATION_MINUTES = self.session_expiration + if os.path.exists(instance_information_path): + # Blocked by an upstream tbselenium issue, see: + # https://github.com/webfp/tor-browser-selenium/issues/105 + raise NotImplementedError('External server testing is unsupported') + else: + self.localtesting = True + self.__context = journalist_app.create_app(config).app_context() + self.__context.push() - app.run( - port=source_port, - debug=True, - use_reloader=False, - threaded=True) + self.patcher2 = mock.patch('source_app.main.get_entropy_estimate') + self.mock_get_entropy_estimate = self.patcher2.start() + self.mock_get_entropy_estimate.return_value = 8192 - def start_journalist_server(app): - app.run( - port=journalist_port, - debug=True, - use_reloader=False, - threaded=True) + db.create_all() - self.source_process = Process( - target=lambda: start_source_server(self.source_app)) - - self.journalist_process = Process( - target=lambda: start_journalist_server(self.journalist_app)) + # Add our test user + try: + valid_password = "correct horse battery staple profanity oil chewy" # noqa: E501 + user = Journalist(username='journalist', + password=valid_password, + is_admin=True) + user.otp_secret = 'JHCOGO7VCER3EJ4L' + db.session.add(user) + db.session.commit() + except IntegrityError: + print("Test user already added") + db.session.rollback() + + source_port = self._unused_port() + journalist_port = self._unused_port() + + self.source_location = "http://127.0.0.1:%d" % source_port + self.journalist_location = "http://127.0.0.1:%d" % journalist_port + + # Allow custom session expiration lengths + self.session_expiration = session_expiration + + self.source_app = source_app.create_app(config) + self.journalist_app = journalist_app.create_app(config) + + # This user is required for our tests cases to login + self.admin_user = { + "name": "journalist", + "password": ("correct horse battery staple" + " profanity oil chewy"), + "secret": "JHCOGO7VCER3EJ4L"} + self.admin_user['totp'] = pyotp.TOTP(self.admin_user['secret']) + self.sleep_time = 10 + + def start_source_server(app): + config.SESSION_EXPIRATION_MINUTES = self.session_expiration + + app.run( + port=source_port, + debug=True, + use_reloader=False, + threaded=True) + + def start_journalist_server(app): + app.run( + port=journalist_port, + debug=True, + use_reloader=False, + threaded=True) + + self.source_process = Process( + target=lambda: start_source_server(self.source_app)) + + self.journalist_process = Process( + target=lambda: start_journalist_server(self.journalist_app)) + + self.source_process.start() + self.journalist_process.start() + + for tick in range(30): + try: + requests.get(self.source_location) + requests.get(self.journalist_location) + except Exception: + time.sleep(1) + else: + break - self.source_process.start() - self.journalist_process.start() + signal.signal(signal.SIGUSR1, lambda _, s: traceback.print_stack(s)) - for tick in range(30): - try: - requests.get(self.source_location) - requests.get(self.journalist_location) - except Exception: - time.sleep(1) - else: - break + # Allow custom session expiration lengths + self.session_expiration = session_expiration if not hasattr(self, 'override_driver'): + # Means this is not pages-layout tests + self._create_secondary_firefox_driver() try: self.driver = self._create_webdriver(self._prepare_webdriver()) except WebDriverException as e: @@ -155,6 +299,14 @@ def start_journalist_server(app): # up for the subsequent tests. self.teardown() pytest.fail(e) + else: + # We will use a normal firefox esr for the pages-layout tests + self.driver = self._create_webdriver2(self.new_profile) # noqa # pylint: disable=no-member + + # Set window size and position explicitly to avoid potential bugs + # due to discrepancies between environments. + self.driver.set_window_position(0, 0) + self.driver.set_window_size(1024, 768) # Polls the DOM to wait for elements. To read more about why # this is necessary: @@ -169,37 +321,33 @@ def start_journalist_server(app): # will only report failure after 60 seconds which is painful # for quickly debuging. # - self.driver.implicitly_wait(10) - - # Set window size and position explicitly to avoid potential bugs due - # to discrepancies between environments. - self.driver.set_window_position(0, 0) - self.driver.set_window_size(1024, 768) + self.driver.implicitly_wait(15) self.secret_message = ('These documents outline a major government ' 'invasion of privacy.') - def wait_for_source_key(self, source_name): - filesystem_id = self.source_app.crypto_util.hash_codename(source_name) - - def key_available(filesystem_id): - assert self.source_app.crypto_util.getkey(filesystem_id) - self.wait_for( - lambda: key_available(filesystem_id), timeout=60) - def teardown(self): self.patcher.stop() env.teardown() if hasattr(self, 'driver') and not hasattr(self, 'override_driver'): self.driver.quit() - self.source_process.terminate() - self.journalist_process.terminate() - self.__context.pop() + if self.second_driver: + self.second_driver.quit() + if self.localtesting: + self.source_process.terminate() + self.journalist_process.terminate() + self.__context.pop() - def wait_for(self, function_with_assertion, timeout=5): + def create_new_totp(self, secret): + self.new_totp = pyotp.TOTP(secret) + + def wait_for(self, function_with_assertion, timeout=None): """Polling wait for an arbitrary assertion.""" # Thanks to # http://chimera.labs.oreilly.com/books/1234000000754/ch20.html#_a_common_selenium_problem_race_conditions + if not timeout: + timeout = self.sleep_time + start_time = time.time() while time.time() - start_time < timeout: try: @@ -209,19 +357,49 @@ def wait_for(self, function_with_assertion, timeout=5): # one more try, which will raise any errors if they are outstanding return function_with_assertion() + def safe_click_by_id(self, id): + self.wait_for(lambda: self.driver.find_element_by_id(id)) + + el = self.driver.find_element_by_id(id) + + self.wait_for(lambda: el.is_enabled() and + el.is_displayed) + + el.location_once_scrolled_into_view + actions = ActionChains(self.driver) + actions.move_to_element(el) + actions.perform() + + el.click() + + def safe_click_by_css_selector(self, selector): + self.wait_for(lambda: + self.driver.find_element_by_css_selector(selector)) + + el = self.driver.find_element_by_css_selector(selector) + + self.wait_for(lambda: el.is_enabled() and + el.is_displayed) + + el.location_once_scrolled_into_view + actions = ActionChains(self.driver) + actions.move_to_element(el).perform() + + el.click() + def _alert_wait(self): - WebDriverWait(self.driver, 10).until( + WebDriverWait(self.driver, self.sleep_time * 6).until( expected_conditions.alert_is_present(), 'Timed out waiting for confirmation popup.') def _alert_accept(self): self.driver.switch_to.alert.accept() - WebDriverWait(self.driver, 10).until( + WebDriverWait(self.driver, self.sleep_time).until( alert_is_not_present(), 'Timed out waiting for confirmation popup to disappear.') def _alert_dismiss(self): self.driver.switch_to.alert.dismiss() - WebDriverWait(self.driver, 10).until( + WebDriverWait(self.driver, self.sleep_time).until( alert_is_not_present(), 'Timed out waiting for confirmation popup to disappear.') diff --git a/securedrop/tests/functional/journalist_navigation_steps.py b/securedrop/tests/functional/journalist_navigation_steps.py index f16dabb2ca6..0a487574a66 100644 --- a/securedrop/tests/functional/journalist_navigation_steps.py +++ b/securedrop/tests/functional/journalist_navigation_steps.py @@ -1,21 +1,38 @@ +import gzip +import os +import random +import re +import tempfile +import time +from os.path import dirname + +import requests + import pytest +from selenium.common.exceptions import NoSuchElementException +from selenium.webdriver.common.action_chains import ActionChains +from selenium.webdriver.common.keys import Keys try: from urllib.request import urlopen, Request except ImportError: # Python 2/3 compatibility from urllib2 import urlopen, Request -import re -import tempfile -import gzip -import os -from selenium.common.exceptions import NoSuchElementException -from selenium.webdriver.common.keys import Keys +# A generator to get unlimited user names for our tests. +# The pages-layout tests require many users during +# the test run, that is why have the following +# implementation. +def get_journalist_usernames(): + yield "dellsberg" + yield "jpb" + yield "bassel" + while True: + num = random.randint(1000, 1000000) + yield "journalist" + str(num) -import tests.utils.db_helper as db_helper -from models import Journalist -from sdconfig import config + +journalist_usernames = get_journalist_usernames() class JournalistNavigationStepsMixin(): @@ -33,6 +50,27 @@ def _get_submission_content(self, file_url, raw_content): return content + def return_downloaded_content(self, url, cookies): + """ + This downloads and returns the content to the caller + :param url: URL to download + :param cookies: the cookies to access + :return: Content of the URL + """ + proxies = None + if ".onion" in url: + proxies = { + 'http': 'socks5h://127.0.0.1:9150', + 'https': 'socks5h://127.0.0.1:9150' + } + r = requests.get(url, cookies=cookies, proxies=proxies, stream=True) + if r.status_code != 200: + raise Exception("Failed to download the data.") + data = b"" + for chunk in r.iter_content(1024): + data += chunk + return data + def _input_text_in_login_form(self, username, password, token): self.driver.get(self.journalist_location + "/login") username_field = self.driver.find_element_by_css_selector( @@ -49,40 +87,62 @@ def _input_text_in_login_form(self, username, password, token): def _try_login_user(self, username, password, token): self._input_text_in_login_form(username, password, token) - submit_button = self.driver.find_element_by_css_selector( - 'button[type=submit]') - submit_button.click() + 'button[type="submit"]') + submit_button.send_keys(u'\ue007') + + def _login_user(self, username, password, otp, maxtries=3): + token = str(otp.now()) + for i in range(maxtries): + + self._try_login_user(username, password, token) + # Successful login should redirect to the index + self.wait_for(lambda: self.driver.find_element_by_id( + 'logout'), timeout=self.sleep_time+10) + if self.driver.current_url != self.journalist_location + '/': + new_token = str(otp.now()) + while token == new_token: + time.sleep(1) + new_token = str(otp.now()) + print("Token: {} New token: {}".format(token, + new_token)) + token = new_token + else: + return - def _login_user(self, username, password, token): - self._try_login_user(username, password, token) - # Successful login should redirect to the index - assert self.driver.current_url == self.journalist_location + '/' + # If we reach here, assert the error + assert self.driver.current_url == self.journalist_location + '/',\ + self.driver.current_url + " " + self.journalist_location def _journalist_logs_in(self): # Create a test user for logging in - self.user, self.user_pw = db_helper.init_journalist() - self._login_user(self.user.username, self.user_pw, 'mocked') + self.user = self.admin_user['name'] + self.user_pw = self.admin_user['password'] + self._login_user(self.user, self.user_pw, self.admin_user['totp']) - headline = self.driver.find_element_by_css_selector('span.headline') - if not hasattr(self, 'accept_languages'): - assert 'Sources' in headline.text + assert self.driver.find_element_by_css_selector( + 'div.journalist-view-all') def _journalist_visits_col(self): - self.driver.find_element_by_css_selector( - '#un-starred-source-link-1').click() + self.wait_for(lambda: self.driver.find_element_by_id( + 'cols')) + + self.safe_click_by_id('un-starred-source-link-1') + + self.wait_for(lambda: self.driver.find_element_by_css_selector( + 'ul#submissions')) def _journalist_selects_first_doc(self): self.driver.find_elements_by_name('doc_names_selected')[0].click() - def _journalist_clicks_on_modal(self, click_id): - self.driver.find_element_by_id(click_id).click() + def doc_selected(): + assert self.driver.find_elements_by_name( + 'doc_names_selected')[0].is_selected() - def link_not_displayed(): - assert ( - (not self.driver.find_elements_by_id(click_id)) or - (not self.driver.find_element_by_id(click_id).is_displayed())) - self.wait_for(link_not_displayed) + self.wait_for(doc_selected) + + def _journalist_clicks_on_modal(self, click_id): + self.safe_click_by_id(click_id) def _journalist_clicks_delete_collections_cancel_on_modal(self): self._journalist_clicks_on_modal('cancel-collections-deletions') @@ -96,24 +156,33 @@ def _journalist_clicks_delete_collection_cancel_on_modal(self): def _journalist_clicks_delete_collections_on_modal(self): self._journalist_clicks_on_modal('delete-collections') + def collection_deleted(): + if not hasattr(self, 'accept_languages'): + flash_msg = self.driver.find_element_by_css_selector('.flash') + assert '1 collection deleted' in flash_msg.text + self.wait_for(collection_deleted) + def _journalist_clicks_delete_selected_on_modal(self): self._journalist_clicks_on_modal('delete-selected') + def submission_deleted(): + if not hasattr(self, 'accept_languages'): + flash_msg = self.driver.find_element_by_css_selector('.flash') + assert 'Submission deleted.' in flash_msg.text + self.wait_for(submission_deleted) + def _journalist_clicks_delete_collection_on_modal(self): self._journalist_clicks_on_modal('delete-collection-button') def _journalist_clicks_delete_link(self, click_id, displayed_id): - assert not self.driver.find_element_by_id(displayed_id).is_displayed() - self.driver.find_element_by_id(click_id).click() - - def link_displayed(): - assert self.driver.find_element_by_id(displayed_id).is_displayed() - self.wait_for(link_displayed) + self.safe_click_by_id(click_id) + self.wait_for(lambda: self.driver.find_element_by_id(displayed_id)) def _journalist_clicks_delete_selected_link(self): - self._journalist_clicks_delete_link( - 'delete-selected-link', - 'delete-selected-confirmation-modal') + self.safe_click_by_css_selector( + 'a#delete-selected-link > button.danger') + self.wait_for(lambda: self.driver.find_element_by_id( + 'delete-selected-confirmation-modal')) def _journalist_clicks_delete_collections_link(self): self._journalist_clicks_delete_link( @@ -144,14 +213,6 @@ def _journalist_uses_delete_selected_button_confirmation(self): def _journalist_uses_delete_collection_button_confirmation(self): self._journalist_clicks_delete_collection_link() self._journalist_clicks_delete_collection_cancel_on_modal() - - # After deletion the button will redirect us. Let's ensure we still - # see the delete collection button. - def delete_collection_link_displayed(): - assert self.driver.find_element_by_id( - 'delete-collection-link').is_displayed() - self.wait_for(delete_collection_link_displayed, timeout=60) - self._journalist_clicks_delete_collection_link() self._journalist_clicks_delete_collection_on_modal() @@ -163,11 +224,11 @@ def _journalist_uses_delete_collections_button_confirmation(self): sources = self.driver.find_elements_by_class_name("code-name") assert len(sources) > 0 - self.driver.find_element_by_id('select_all').click() + self.safe_click_by_id('select_all') self._journalist_clicks_delete_collections_link() self._journalist_clicks_delete_collections_cancel_on_modal() - self.driver.find_element_by_id('select_all').click() + self.safe_click_by_id('select_all') sources = self.driver.find_elements_by_class_name("code-name") assert len(sources) > 0 @@ -179,50 +240,51 @@ def _journalist_uses_delete_collections_button_confirmation(self): assert len(sources) == 0 def _admin_logs_in(self): - self.admin, self.admin_pw = db_helper.init_journalist(is_admin=True) - self._login_user(self.admin.username, self.admin_pw, 'mocked') - - if not hasattr(self, 'accept_languages'): - # Admin user should log in to the same interface as a - # normal user, since there may be users who wish to be - # both journalists and admins. - headline = self.driver.find_element_by_css_selector( - 'span.headline') - assert 'Sources' in headline.text - - # Admin user should have a link that take them to the admin page - links = self.driver.find_elements_by_tag_name('a') - assert 'Admin' in [el.text for el in links] + self.admin = self.admin_user['name'] + self.admin_pw = self.admin_user['password'] + self._login_user(self.admin, self.admin_pw, self.admin_user['totp']) + + # Admin user should log in to the same interface as a + # normal user, since there may be users who wish to be + # both journalists and admins. + assert self.driver.find_element_by_css_selector( + 'div.journalist-view-all') + + # Admin user should have a link that take them to the admin page + assert self.driver.find_element_by_id( + 'link-admin-index') def _admin_visits_admin_interface(self): - admin_interface_link = self.driver.find_element_by_id( - 'link-admin-index') - admin_interface_link.click() - if not hasattr(self, 'accept_languages'): - h1s = self.driver.find_elements_by_tag_name('h1') - assert "Admin Interface" in [el.text for el in h1s] + self.safe_click_by_id('link-admin-index') + + self.wait_for(lambda: self.driver.find_element_by_id( + 'add-user')) def _admin_visits_system_config_page(self): - system_config_link = self.driver.find_element_by_id( - 'update-instance-config' - ) - system_config_link.click() - if not hasattr(self, 'accept_languages'): - h1 = self.driver.find_element_by_tag_name('h1') - assert "Instance Configuration" in h1.text + self.safe_click_by_id('update-instance-config') + + def config_page_loaded(): + assert self.driver.find_element_by_id( + 'test-ossec-alert') + + self.wait_for(config_page_loaded) def _admin_updates_logo_image(self): + dir_name = dirname(dirname(dirname(os.path.abspath(__file__)))) + image_path = os.path.abspath(os.path.join(dir_name, + 'static/i/logo.png')) logo_upload_input = self.driver.find_element_by_id('logo-upload') - logo_upload_input.send_keys( - os.path.join(config.SECUREDROP_ROOT, "static/i/logo.png") - ) + logo_upload_input.send_keys(image_path) - submit_button = self.driver.find_element_by_id('submit-logo-update') - submit_button.click() + self.safe_click_by_id('submit-logo-update') - if not hasattr(self, 'accept_languages'): - flashed_msgs = self.driver.find_element_by_css_selector('.flash') - assert 'Image updated.' in flashed_msgs.text + def updated_image(): + if not hasattr(self, 'accept_languages'): + flash_msg = self.driver.find_element_by_css_selector('.flash') + assert 'Image updated.' in flash_msg.text + + # giving extra time for upload to complete + self.wait_for(updated_image, timeout=self.sleep_time*3) def _add_user(self, username, is_admin=False, hotp=None): username_field = self.driver.find_element_by_css_selector( @@ -239,19 +301,17 @@ def _add_user(self, username, is_admin=False, hotp=None): hotp_secret.send_keys(hotp) if is_admin: - is_admin_checkbox = self.driver.find_element_by_css_selector( - 'input[name="is_admin"]' - ) - is_admin_checkbox.click() + self.safe_click_by_css_selector('input[name="is_admin"]') - submit_button = self.driver.find_element_by_css_selector( - 'button[type=submit]') - submit_button.click() + self.safe_click_by_css_selector('button[type=submit]') - def _admin_adds_a_user(self, is_admin=False): - add_user_btn = self.driver.find_element_by_css_selector( - 'button#add-user') - add_user_btn.click() + def _admin_adds_a_user(self, is_admin=False, new_username=''): + self.wait_for(lambda: self.driver.find_element_by_id( + 'add-user').is_enabled()) + self.safe_click_by_css_selector('button#add-user') + + self.wait_for(lambda: self.driver.find_element_by_id( + 'username')) if not hasattr(self, 'accept_languages'): # The add user page has a form with an "ADD USER" button @@ -261,8 +321,10 @@ def _admin_adds_a_user(self, is_admin=False): password = self.driver.find_element_by_css_selector('#password') \ .text.strip() + if not new_username: + new_username = journalist_usernames.next() self.new_user = dict( - username='dellsberg', + username=new_username, password=password, ) self._add_user(self.new_user['username'], is_admin=is_admin) @@ -273,27 +335,26 @@ def _admin_adds_a_user(self, is_admin=False): h1s = self.driver.find_elements_by_tag_name('h1') assert "Enable FreeOTP" in [el.text for el in h1s] - # Retrieve the saved user object from the db and keep it around for - # further testing - self.new_user['orm_obj'] = Journalist.query.filter( - Journalist.username == self.new_user['username']).one() + shared_secret = self.driver.find_element_by_css_selector('#shared-secret').text.strip().replace(' ', '') # noqa: E501 + self.create_new_totp(shared_secret) # Verify the two-factor authentication token_field = self.driver.find_element_by_css_selector( 'input[name="token"]') - token_field.send_keys('mocked') - submit_button = self.driver.find_element_by_css_selector( - 'button[type=submit]') - submit_button.click() + token_field.send_keys(str(self.new_totp.now())) + self.safe_click_by_css_selector('button[type=submit]') - if not hasattr(self, 'accept_languages'): - # Successfully verifying the code should redirect to the admin - # interface, and flash a message indicating success - flashed_msgs = self.driver.find_elements_by_css_selector('.flash') - assert (("Token in two-factor authentication " - "accepted for user {}.").format( - self.new_user['username']) in - [el.text for el in flashed_msgs]) + def user_token_added(): + if not hasattr(self, 'accept_languages'): + # Successfully verifying the code should redirect to the admin + # interface, and flash a message indicating success + flash_msg = self.driver.find_elements_by_css_selector('.flash') + assert (("Token in two-factor authentication " + "accepted for user {}.").format( + self.new_user['username']) in + [el.text for el in flash_msg]) + + self.wait_for(user_token_added) def _admin_deletes_user(self): self.wait_for(lambda: self.driver.find_element_by_css_selector( @@ -310,23 +371,31 @@ def _admin_deletes_user(self): self._alert_wait() self._alert_accept() - if not hasattr(self, 'accept_languages'): - flashed_msg = self.driver.find_element_by_css_selector('.flash') - assert "Deleted user" in flashed_msg.text + def user_deleted(): + if not hasattr(self, 'accept_languages'): + flash_msg = self.driver.find_element_by_css_selector('.flash') + assert "Deleted user" in flash_msg.text + + self.wait_for(user_deleted) def _admin_can_send_test_alert(self): alert_button = self.driver.find_element_by_id('test-ossec-alert') alert_button.click() - if not hasattr(self, 'accept_languages'): - flashed_msg = self.driver.find_element_by_css_selector('.flash') - assert ("Test alert sent. Please check your email." - in flashed_msg.text) + def test_alert_sent(): + if not hasattr(self, 'accept_languages'): + flash_msg = self.driver.find_element_by_css_selector('.flash') + assert ("Test alert sent. Please check your email." + in flash_msg.text) + self.wait_for(test_alert_sent) def _logout(self): # Click the logout link logout_link = self.driver.find_element_by_id('link-logout') + logout_link.send_keys(" ") logout_link.click() + self.wait_for(lambda: self.driver.find_element_by_css_selector( + '.login-form')) # Logging out should redirect back to the login page def login_page(): @@ -346,10 +415,12 @@ def _new_user_can_log_in(self): # Log the admin user out self._logout() + self.wait_for(lambda: self.driver.find_element_by_css_selector( + '.login-form')) # Log the new user in self._login_user(self.new_user['username'], self.new_user['password'], - 'mocked') + self.new_totp) if not hasattr(self, 'accept_languages'): # Test that the new user was logged in successfully @@ -362,7 +433,7 @@ def _new_user_can_log_in(self): def _new_admin_user_can_log_in(self): # Test login with mocked token - self._check_login_with_otp('mocked') + self._check_login_with_otp(self.new_totp) # Newly added user who is an admin can visit admin interface self._admin_visits_admin_interface() @@ -373,8 +444,11 @@ def _edit_account(self): edit_account_link.click() # The header says "Edit your account" - h1s = self.driver.find_elements_by_tag_name('h1')[0] - assert 'Edit your account' == h1s.text + def edit_page_loaded(): + h1s = self.driver.find_elements_by_tag_name('h1')[0] + assert 'Edit your account' == h1s.text + self.wait_for(edit_page_loaded) + # There's no link back to the admin interface. with pytest.raises(NoSuchElementException): self.driver.find_element_by_partial_link_text( @@ -396,16 +470,21 @@ def _edit_account(self): assert ('/account/reset-2fa-hotp' in hotp_reset_button.get_attribute('action')) - def _edit_user(self, username): - user = Journalist.query.filter_by(username=username).one() + def _edit_user(self, username, is_admin=False): + # XXXX + self.wait_for(lambda: self.driver.find_element_by_id( + 'users')) new_user_edit_links = [el for el in self.driver.find_elements_by_tag_name('a') if el.get_attribute('data-username') == username] assert 1 == len(new_user_edit_links) new_user_edit_links[0].click() - # The header says "Edit user "username"". - h1s = self.driver.find_elements_by_tag_name('h1')[0] - assert 'Edit user "{}"'.format(username) == h1s.text + + def edit_user_page_loaded(): + h1s = self.driver.find_elements_by_tag_name('h1')[0] + assert 'Edit user "{}"'.format(username) == h1s.text + self.wait_for(edit_user_page_loaded) + # There's a convenient link back to the admin interface. admin_interface_link = self.driver.find_element_by_partial_link_text( 'Back to admin interface') @@ -418,8 +497,7 @@ def _edit_user(self, username): # it's already checked appropriately to reflect the current status of # our user. username_field = self.driver.find_element_by_css_selector('#is-admin') - assert (bool(username_field.get_attribute('checked')) == - user.is_admin) + assert bool(username_field.get_attribute('checked')) == is_admin # 2FA reset buttons at the bottom point to the admin URLs for # resettting 2FA and include the correct user id in the hidden uid. totp_reset_button = self.driver.find_elements_by_css_selector( @@ -427,7 +505,6 @@ def _edit_user(self, username): assert '/admin/reset-2fa-totp' in totp_reset_button.get_attribute( 'action') totp_reset_uid = totp_reset_button.find_element_by_name('uid') - assert int(totp_reset_uid.get_attribute('value')) == user.id assert totp_reset_uid.is_displayed() is False hotp_reset_button = self.driver.find_elements_by_css_selector( '#reset-two-factor-hotp')[0] @@ -435,19 +512,22 @@ def _edit_user(self, username): 'action') hotp_reset_uid = hotp_reset_button.find_element_by_name('uid') - assert int(hotp_reset_uid.get_attribute('value')) == user.id assert hotp_reset_uid.is_displayed() is False def _admin_can_edit_new_user(self): # Log the new user out self._logout() - self._login_user(self.admin.username, self.admin_pw, 'mocked') + self.wait_for(lambda: self.driver.find_element_by_css_selector( + '.login-form')) + + self._login_user(self.admin, self.admin_pw, self.admin_user['totp']) # Go to the admin interface - admin_interface_link = self.driver.find_element_by_id( - 'link-admin-index') - admin_interface_link.click() + self.safe_click_by_id('link-admin-index') + + self.wait_for(lambda: self.driver.find_element_by_css_selector( + 'button#add-user')) # Click the "edit user" link for the new user # self._edit_user(self.new_user['username']) @@ -458,8 +538,8 @@ def _admin_can_edit_new_user(self): new_user_edit_links[0].click() def can_edit_user(): - assert ('"{}"'.format(self.new_user['username']) in - self.driver.page_source) + h = self.driver.find_elements_by_tag_name('h1')[0] + assert 'Edit user "{}"'.format(self.new_user['username']) == h.text self.wait_for(can_edit_user) new_username = self.new_user['username'] + "2" @@ -471,6 +551,13 @@ def can_edit_user(): 'button[type=submit]') update_user_btn.click() + def user_edited(): + if not hasattr(self, 'accept_languages'): + flash_msg = self.driver.find_element_by_css_selector('.flash') + assert "Account updated." in flash_msg.text + + self.wait_for(user_edited) + def can_edit_user2(): assert ('"{}"'.format(new_username) in self.driver.page_source) self.wait_for(can_edit_user2) @@ -480,9 +567,13 @@ def can_edit_user2(): # Log the new user in with their new username self._logout() + + self.wait_for(lambda: self.driver.find_element_by_css_selector( + '.login-form')) + self._login_user(self.new_user['username'], self.new_user['password'], - 'mocked') + self.new_totp) if not hasattr(self, 'accept_languages'): def found_sources(): assert 'Sources' in self.driver.page_source @@ -490,15 +581,27 @@ def found_sources(): # Log the admin user back in self._logout() - self._login_user(self.admin.username, self.admin_pw, 'mocked') + + self.wait_for(lambda: self.driver.find_element_by_css_selector( + '.login-form')) + + self._login_user(self.admin, self.admin_pw, self.admin_user['totp']) # Go to the admin interface - admin_interface_link = self.driver.find_element_by_id( - 'link-admin-index') - admin_interface_link.click() + self.safe_click_by_id('link-admin-index') + + self.wait_for(lambda: self.driver.find_element_by_css_selector( + 'button#add-user')) + + new_user_edit_links = filter( + lambda el: (el.get_attribute('data-username') == + self.new_user['username']), + self.driver.find_elements_by_tag_name('a')) + assert len(new_user_edit_links) == 1 + new_user_edit_links[0].click() + + self.wait_for(can_edit_user) - # Edit the new user's password - self._edit_user(self.new_user['username']) new_password = self.driver.find_element_by_css_selector('#password') \ .text.strip() self.new_user['password'] = new_password @@ -517,19 +620,16 @@ def update_password_success(): self._logout() self._login_user(self.new_user['username'], self.new_user['password'], - 'mocked') + self.new_totp) self.wait_for(found_sources) - # Log back out and log back admin in for subsequent tests - self._logout() - self._login_user(self.admin.username, self.admin_pw, 'mocked') - def _journalist_checks_messages(self): self.driver.get(self.journalist_location) # There should be 1 collection in the list of collections code_names = self.driver.find_elements_by_class_name('code-name') - assert 1 == len(code_names) + assert 0 != len(code_names), code_names + assert 1 <= len(code_names), code_names if not hasattr(self, 'accept_languages'): # There should be a "1 unread" span in the sole collection entry @@ -544,13 +644,19 @@ def _journalist_stars_and_unstars_single_message(self): # Journalist stars the message self.driver.find_element_by_class_name('button-star').click() - starred = self.driver.find_elements_by_id('starred-source-link-1') - assert 1 == len(starred) + + def message_starred(): + starred = self.driver.find_elements_by_id('starred-source-link-1') + assert 1 == len(starred) + self.wait_for(message_starred) # Journalist unstars the message self.driver.find_element_by_class_name('button-star').click() - with pytest.raises(NoSuchElementException): - self.driver.find_element_by_id('starred-source-link-1') + + def message_unstarred(): + with pytest.raises(NoSuchElementException): + self.driver.find_element_by_id('starred-source-link-1') + self.wait_for(message_unstarred) def _journalist_selects_all_sources_then_selects_none(self): self.driver.find_element_by_id('select_all').click() @@ -573,6 +679,9 @@ def _journalist_selects_documents_to_download(self): def _journalist_downloads_message(self): self._journalist_selects_the_first_source() + self.wait_for(lambda: self.driver.find_element_by_css_selector( + 'ul#submissions')) + submissions = self.driver.find_elements_by_css_selector( '#submissions a') assert 1 == len(submissions) @@ -581,21 +690,16 @@ def _journalist_downloads_message(self): # Downloading files with Selenium is tricky because it cannot automate # the browser's file download dialog. We can directly request the file - # using urllib2, but we need to pass the cookies for the logged in user + # using requests, but we need to pass the cookies for logged in user # for Flask to allow this. def cookie_string_from_selenium_cookies(cookies): - cookie_strs = [] + result = {} for cookie in cookies: - cookie_str = "=".join([cookie['name'], cookie['value']]) + ';' - cookie_strs.append(cookie_str) - return ' '.join(cookie_strs) + result[cookie['name']] = cookie['value'] + return result - submission_req = Request(file_url) - submission_req.add_header( - 'Cookie', - cookie_string_from_selenium_cookies( - self.driver.get_cookies())) - raw_content = urlopen(submission_req).read() + cks = cookie_string_from_selenium_cookies(self.driver.get_cookies()) + raw_content = self.return_downloaded_content(file_url, cks) decrypted_submission = self.gpg.decrypt(raw_content) submission = self._get_submission_content(file_url, @@ -609,8 +713,7 @@ def _journalist_composes_reply(self): reply_text = ('Thanks for the documents. Can you submit more ' 'information about the main program?') self.wait_for(lambda: self.driver.find_element_by_id( - 'reply-text-field' - ), timeout=60) + 'reply-text-field')) self.driver.find_element_by_id('reply-text-field').send_keys( reply_text ) @@ -619,16 +722,22 @@ def _journalist_sends_reply_to_source(self): self._journalist_composes_reply() self.driver.find_element_by_id('reply-button').click() - if not hasattr(self, 'accept_languages'): - assert ("Thanks. Your reply has been stored." in - self.driver.page_source) + def reply_stored(): + if not hasattr(self, 'accept_languages'): + assert ("Thanks. Your reply has been stored." in + self.driver.page_source) + self.wait_for(reply_stored) def _visit_edit_account(self): - edit_account_link = self.driver.find_element_by_id( - 'link-edit-account') - edit_account_link.click() + self.safe_click_by_id('link-edit-account') def _visit_edit_secret(self, type): + + def edit_self_loaded(): + assert self.driver.find_element_by_id('reset-password') + + self.wait_for(edit_self_loaded) + reset_form = self.driver.find_elements_by_css_selector( '#reset-two-factor-' + type)[0] assert ('/account/reset-2fa-' + type in @@ -636,12 +745,13 @@ def _visit_edit_secret(self, type): reset_button = self.driver.find_elements_by_css_selector( '#button-reset-two-factor-' + type)[0] + self.wait_for(lambda: reset_button.is_enabled()) reset_button.click() - def _visit_edit_hotp_secret(self): - self._visit_edit_secret('hotp') - def _set_hotp_secret(self): + self.wait_for(lambda: self.driver.find_elements_by_css_selector( + 'input[name="otp_secret"]')[0]) + hotp_secret_field = self.driver.find_elements_by_css_selector( 'input[name="otp_secret"]')[0] hotp_secret_field.send_keys('123456') @@ -649,14 +759,22 @@ def _set_hotp_secret(self): 'button[type=submit]') submit_button.click() + def _visit_edit_hotp_secret(self): + self._visit_edit_secret('hotp') + def _visit_edit_totp_secret(self): self._visit_edit_secret('totp') def _admin_visits_add_user(self): add_user_btn = self.driver.find_element_by_css_selector( 'button#add-user') + self.wait_for(lambda: add_user_btn.is_enabled() and + add_user_btn.is_displayed()) add_user_btn.click() + self.wait_for(lambda: self.driver.find_element_by_id( + 'username')) + def _admin_visits_edit_user(self): new_user_edit_links = [el for el in self.driver.find_elements_by_tag_name('a') if (el.get_attribute('data-username') == @@ -674,6 +792,12 @@ def _admin_visits_reset_2fa_hotp(self): '#reset-two-factor-hotp')[0] assert ('/admin/reset-2fa-hotp' in hotp_reset_button.get_attribute('action')) + self.wait_for(lambda: hotp_reset_button.is_enabled()) + + hotp_reset_button.location_once_scrolled_into_view + actions = ActionChains(self.driver) + actions.move_to_element(hotp_reset_button) + actions.perform() hotp_reset_button.click() def _admin_accepts_2fa_js_alert(self): @@ -690,7 +814,10 @@ def _admin_visits_reset_2fa_totp(self): def _admin_creates_a_user(self, hotp): add_user_btn = self.driver.find_element_by_css_selector( 'button#add-user') - add_user_btn.click() + self.wait_for(lambda: add_user_btn.is_enabled()) + add_user_btn.submit() + self.wait_for(lambda: self.driver.find_element_by_id( + 'username')) self.new_user = dict( username='dellsberg', @@ -710,7 +837,13 @@ def _journalist_confirm_delete_selected(self): self.wait_for( lambda: self.driver.find_element_by_id('delete-selected')) confirm_btn = self.driver.find_element_by_id('delete-selected') - confirm_btn.click() + + def button_available(): + confirm_btn = self.driver.find_element_by_id('delete-selected') + assert (confirm_btn.is_enabled() and confirm_btn.is_displayed()) + + self.wait_for(button_available) + confirm_btn.submit() def _source_delete_key(self): filesystem_id = self.source_app.crypto_util.hash_codename( @@ -718,33 +851,39 @@ def _source_delete_key(self): self.source_app.crypto_util.delete_reply_keypair(filesystem_id) def _journalist_continues_after_flagging(self): - self.driver.find_element_by_id('continue-to-list').click() + self.wait_for(lambda: self.driver.find_element_by_id( + 'continue-to-list')) + continue_link = self.driver.find_element_by_id('continue-to-list') + + actions = ActionChains(self.driver) + actions.move_to_element(continue_link).perform() + continue_link.click() def _journalist_delete_none(self): self.driver.find_element_by_id('delete-selected-link').click() def _journalist_delete_all_confirmation(self): - self.driver.find_element_by_id('select_all').click() - self.driver.find_element_by_id('delete-selected-link').click() + self.safe_click_by_id('select_all') + self.safe_click_by_css_selector( + 'a#delete-selected-link > button.danger') def _journalist_delete_one(self): self.driver.find_elements_by_name('doc_names_selected')[0].click() self.driver.find_element_by_id('delete-selected-link').click() def _journalist_flags_source(self): - self.driver.find_element_by_id('flag-button').click() + self.safe_click_by_id('flag-button') def _journalist_visits_admin(self): self.driver.get(self.journalist_location + "/admin") def _journalist_fail_login(self): - self.user, self.user_pw = db_helper.init_journalist() - self._try_login_user(self.user.username, 'worse', 'mocked') + self._try_login_user("root", 'worse', 'mocked') def _journalist_fail_login_many(self): - self.user, self.user_pw = db_helper.init_journalist() - for _ in range(Journalist._MAX_LOGIN_ATTEMPTS_PER_PERIOD + 1): - self._try_login_user(self.user.username, 'worse', 'mocked') + self.user = "" + for _ in range(5 + 1): + self._try_login_user(self.user, 'worse', 'mocked') def _admin_enters_journalist_account_details_hotp(self, username, hotp_secret): @@ -770,7 +909,6 @@ def _journalist_uses_js_filter_by_sources(self): assert len(sources) > 0 for source in sources: assert source.is_displayed() is False - filter_box.clear() filter_box.send_keys(Keys.RETURN) diff --git a/securedrop/tests/functional/source_navigation_steps.py b/securedrop/tests/functional/source_navigation_steps.py index d8a46f87389..ac53104b7ec 100644 --- a/securedrop/tests/functional/source_navigation_steps.py +++ b/securedrop/tests/functional/source_navigation_steps.py @@ -8,7 +8,6 @@ class SourceNavigationStepsMixin(): def _source_visits_source_homepage(self): self.driver.get(self.source_location) - if not hasattr(self, 'accept_languages'): assert ("SecureDrop | Protecting Journalists and Sources" == self.driver.title) @@ -26,7 +25,7 @@ def _source_clicks_submit_documents_on_homepage(self): submit_button_icon = self.driver.find_element_by_css_selector( 'a#submit-documents-button > img.off-hover') - assert submit_button_icon.is_displayed() + self.wait_for(lambda: submit_button_icon.is_displayed()) # The source hovers their cursor over the button, and the visual style # of the button changes to encourage them to click it. @@ -37,6 +36,9 @@ def _source_clicks_submit_documents_on_homepage(self): assert submit_button_icon.is_displayed() is False submit_button_hover_icon = self.driver.find_element_by_css_selector( 'a#submit-documents-button > img.on-hover') + ActionChains(self.driver).move_to_element( + submit_button_hover_icon).perform() + self.wait_for(lambda: submit_button_hover_icon.is_displayed()) assert submit_button_hover_icon.is_displayed() # The source clicks the submit button. @@ -53,7 +55,10 @@ def _source_chooses_to_submit_documents(self): def _source_shows_codename(self): content = self.driver.find_element_by_id('codename-hint-content') assert not content.is_displayed() - self.driver.find_element_by_id('codename-hint-show').click() + + self.safe_click_by_id('codename-hint-show') + + self.wait_for(lambda: content.is_displayed()) assert content.is_displayed() content_content = self.driver.find_element_by_css_selector( '#codename-hint-content p') @@ -62,7 +67,10 @@ def _source_shows_codename(self): def _source_hides_codename(self): content = self.driver.find_element_by_id('codename-hint-content') assert content.is_displayed() - self.driver.find_element_by_id('codename-hint-hide').click() + + self.safe_click_by_id('codename-hint-hide') + + self.wait_for(lambda: not content.is_displayed()) assert not content.is_displayed() def _source_sees_no_codename(self): @@ -72,10 +80,8 @@ def _source_sees_no_codename(self): def _source_chooses_to_login(self): self.driver.find_element_by_id('login-button').click() - logins = self.driver.find_elements_by_id( - 'login-with-existing-codename') - - assert len(logins) > 0 + self.wait_for(lambda: self.driver.find_elements_by_id( + 'login-with-existing-codename')) def _source_hits_cancel_at_login_page(self): self.driver.find_element_by_id('cancel').click() @@ -91,8 +97,7 @@ def _source_proceeds_to_login(self): 'login-with-existing-codename') codename_input.send_keys(self.source_name) - continue_button = self.driver.find_element_by_id('login') - continue_button.click() + self.safe_click_by_id('login') if not hasattr(self, 'accept_languages'): assert ("SecureDrop | Protecting Journalists and Sources" == @@ -133,9 +138,12 @@ def _source_continues_to_submit_page(self): continue_button.click() - if not hasattr(self, 'accept_languages'): - headline = self.driver.find_element_by_class_name('headline') - assert 'Submit Files or Messages' == headline.text + def submit_page_loaded(): + if not hasattr(self, 'accept_languages'): + headline = self.driver.find_element_by_class_name('headline') + assert 'Submit Files or Messages' == headline.text + + self.wait_for(submit_page_loaded) def _source_submits_a_file(self): with tempfile.NamedTemporaryFile() as file: @@ -157,23 +165,35 @@ def _source_submits_a_file(self): assert toggled_submit_button_icon.is_displayed() submit_button.click() - self.wait_for_source_key(self.source_name) - if not hasattr(self, 'accept_languages'): - notification = self.driver.find_element_by_css_selector( - '.success') - expected_notification = ( - 'Thank you for sending this information to us') - assert expected_notification in notification.text + def file_submitted(): + if not hasattr(self, 'accept_languages'): + notification = self.driver.find_element_by_css_selector( + '.success') + expected_notification = ( + 'Thank you for sending this information to us') + assert expected_notification in notification.text + + # Allow extra time for file uploads + self.wait_for(file_submitted, timeout=(self.sleep_time*3)) + + # allow time for reply key to be generated + time.sleep(5) def _source_submits_a_message(self): self._source_enters_text_in_message_field() self._source_clicks_submit_button_on_submission_page() - if not hasattr(self, 'accept_languages'): - notification = self.driver.find_element_by_css_selector( - '.success') - assert 'Thank' in notification.text + def message_submitted(): + if not hasattr(self, 'accept_languages'): + notification = self.driver.find_element_by_css_selector( + '.success') + assert 'Thank' in notification.text + + self.wait_for(message_submitted) + + # allow time for reply key to be generated + time.sleep(5) def _source_enters_text_in_message_field(self): text_box = self.driver.find_element_by_css_selector('[name=msg]') @@ -182,7 +202,6 @@ def _source_enters_text_in_message_field(self): def _source_clicks_submit_button_on_submission_page(self): submit_button = self.driver.find_element_by_id('submit-doc-button') submit_button.click() - self.wait_for_source_key(self.source_name) def _source_deletes_a_journalist_reply(self): # Get the reply filename so we can use IDs to select the delete buttons @@ -194,20 +213,34 @@ def _source_deletes_a_journalist_reply(self): delete_button = self.driver.find_element_by_id(delete_button_id) delete_button.click() + def confirm_displayed(): + confirm_button_id = 'confirm-delete-reply-button-{}'.format( + reply_filename) + confirm_button = self.driver.find_element_by_id(confirm_button_id) + assert confirm_button.is_displayed() + + self.wait_for(confirm_displayed) + confirm_button_id = 'confirm-delete-reply-button-{}'.format( reply_filename) confirm_button = self.driver.find_element_by_id(confirm_button_id) - assert confirm_button.is_displayed() confirm_button.click() - if not hasattr(self, 'accept_languages'): - notification = self.driver.find_element_by_class_name( - 'notification') - assert 'Reply deleted' in notification.text + def reply_deleted(): + if not hasattr(self, 'accept_languages'): + notification = self.driver.find_element_by_class_name( + 'notification') + assert 'Reply deleted' in notification.text + + self.wait_for(reply_deleted) def _source_logs_out(self): - self.driver.find_element_by_id('logout').click() - assert self.driver.find_element_by_css_selector('.important') + # New thing to delete XXX + logout = self.driver.find_element_by_id('logout') + logout.send_keys(" ") + logout.click() + self.wait_for(lambda: + ("Submit for the first time" in self.driver.page_source)) def _source_not_found(self): self.driver.get(self.source_location + "/unlikely") diff --git a/securedrop/tests/functional/test_make_account_changes.py b/securedrop/tests/functional/test_make_account_changes.py index 3606fdc76db..7313527174d 100644 --- a/securedrop/tests/functional/test_make_account_changes.py +++ b/securedrop/tests/functional/test_make_account_changes.py @@ -16,11 +16,11 @@ def test_admin_edit_account_html_template_rendering(self): self._admin_logs_in() self._admin_visits_admin_interface() # Admin view of admin user - self._edit_user(self.admin.username) + self._edit_user(self.admin, True) self._admin_visits_admin_interface() self._admin_adds_a_user() # Admin view of non-admin user - self._edit_user('dellsberg') + self._edit_user(self.new_user['username']) # User view of self self._edit_account() self._logout() diff --git a/securedrop/tests/functional/test_source_warnings.py b/securedrop/tests/functional/test_source_warnings.py index 74a3cc9cfb9..80fa0278a04 100644 --- a/securedrop/tests/functional/test_source_warnings.py +++ b/securedrop/tests/functional/test_source_warnings.py @@ -1,13 +1,19 @@ -from . import source_navigation_steps -from . import functional_test +import os +import shutil + +import pytest from selenium import webdriver +from . import functional_test, source_navigation_steps + class TestSourceInterfaceBannerWarnings( functional_test.FunctionalTest, source_navigation_steps.SourceNavigationStepsMixin): + @pytest.mark.xfail(reason="due to bug 3793") def test_warning_appears_if_tor_browser_not_in_use(self): + self.swap_drivers() self.driver.get(self.source_location) warning_banner = self.driver.find_element_by_id('use-tor-browser') @@ -24,25 +30,43 @@ def test_warning_appears_if_orbot_is_used(self): orbotUserAgent = ("Mozilla/5.0 (Android; Mobile;" " rv:52.0) Gecko/20100101 Firefox/52.0") + self.f_profile_path2 = "/tmp/testprofile2" + if os.path.exists(self.f_profile_path2): + shutil.rmtree(self.f_profile_path2) # Create new profile and driver with the orbot user agent for this test - profile = webdriver.FirefoxProfile() + os.mkdir(self.f_profile_path2) + profile = webdriver.FirefoxProfile(self.f_profile_path2) profile.set_preference("general.useragent.override", orbotUserAgent) - self.driver = webdriver.Firefox(profile) - self.driver.get(self.source_location) + if self.journalist_location.find('.onion') != -1: + # set FF preference to socks proxy in Tor Browser + profile.set_preference("network.proxy.type", 1) + profile.set_preference("network.proxy.socks", "127.0.0.1") + profile.set_preference("network.proxy.socks_port", 9150) + profile.set_preference("network.proxy.socks_version", 5) + profile.set_preference("network.proxy.socks_remote_dns", True) + profile.set_preference("network.dns.blockDotOnion", False) + profile.update_preferences() + self.driver2 = webdriver.Firefox( + firefox_binary=functional_test.FIREFOX_PATH, + firefox_profile=profile) + self.driver2.get(self.source_location) - currentAgent = self.driver.execute_script("return navigator.userAgent") + currentAgent = self.driver2.execute_script( + "return navigator.userAgent") assert currentAgent == orbotUserAgent - warning_banner = self.driver.find_element_by_id('orfox-browser') + warning_banner = self.driver2.find_element_by_id('orfox-browser') assert ("It is recommended you use the desktop version of Tor Browser" in warning_banner.text) # User should be able to dismiss the warning - warning_dismiss_button = self.driver.find_element_by_id( + warning_dismiss_button = self.driver2.find_element_by_id( 'orfox-browser-close') self.banner_is_dismissed(warning_banner, warning_dismiss_button) + self.driver2.quit() + def banner_is_dismissed(self, warning_banner, dismiss_button): dismiss_button.click() @@ -50,3 +74,10 @@ def banner_is_dismissed(self, warning_banner, dismiss_button): def warning_banner_is_hidden(): assert warning_banner.is_displayed() is False self.wait_for(warning_banner_is_hidden) + self.swap_drivers() + + def test_warning_high_security(self): + self.driver.get(self.source_location) + + banner = self.driver.find_element_by_class_name('js-warning') + assert "Security Slider to High", banner.text diff --git a/securedrop/tests/functional/test_submit_and_retrieve_file.py b/securedrop/tests/functional/test_submit_and_retrieve_file.py index 299a6ae9e73..2acf096a1aa 100644 --- a/securedrop/tests/functional/test_submit_and_retrieve_file.py +++ b/securedrop/tests/functional/test_submit_and_retrieve_file.py @@ -14,11 +14,13 @@ def test_submit_and_retrieve_happy_path(self): self._source_continues_to_submit_page() self._source_submits_a_file() self._source_logs_out() + self.swap_drivers() # To use Firefox self._journalist_logs_in() self._journalist_checks_messages() self._journalist_stars_and_unstars_single_message() self._journalist_downloads_message() self._journalist_sends_reply_to_source() + self.swap_drivers() # To use Tor self._source_visits_source_homepage() self._source_chooses_to_login() self._source_proceeds_to_login() diff --git a/securedrop/tests/functional/test_submit_and_retrieve_message.py b/securedrop/tests/functional/test_submit_and_retrieve_message.py index eef263a47c2..6262ff83402 100644 --- a/securedrop/tests/functional/test_submit_and_retrieve_message.py +++ b/securedrop/tests/functional/test_submit_and_retrieve_message.py @@ -14,6 +14,7 @@ def test_submit_and_retrieve_happy_path(self): self._source_continues_to_submit_page() self._source_submits_a_message() self._source_logs_out() + self.swap_drivers() # To use Firefox self._journalist_logs_in() self._journalist_checks_messages() self._journalist_downloads_message() diff --git a/securedrop/tests/pageslayout/functional_test.py b/securedrop/tests/pageslayout/functional_test.py index 54d5e95d049..8dfe225506c 100644 --- a/securedrop/tests/pageslayout/functional_test.py +++ b/securedrop/tests/pageslayout/functional_test.py @@ -20,9 +20,6 @@ from os.path import abspath, dirname, realpath import pytest -from selenium.webdriver.common.action_chains import ActionChains -from selenium.webdriver.common.keys import Keys - from selenium import webdriver from tests.functional import functional_test @@ -46,34 +43,15 @@ def webdriver_fixture(self, request): 'screenshots', self.accept_languages)) if not os.path.exists(self.log_dir): os.makedirs(self.log_dir) - firefox = self._prepare_webdriver() - profile = webdriver.FirefoxProfile() - profile.set_preference("intl.accept_languages", self.accept_languages) + self.new_profile = webdriver.FirefoxProfile() + self.new_profile.set_preference("intl.accept_languages", + self.accept_languages) self.override_driver = True - self.driver = self._create_webdriver(firefox, profile) - self._javascript_toggle() - yield None - self.driver.quit() - def _screenshot(self, filename): - self.driver.set_window_size(1024, 500) # Trim size of images for docs self.driver.save_screenshot(os.path.join(self.log_dir, filename)) - def _javascript_toggle(self): - # the following is a noop for some reason, workaround it - # profile.set_preference("javascript.enabled", False) - # https://stackoverflow.com/a/36782979/837471 - self.driver.get("about:config") - actions = ActionChains(self.driver) - actions.send_keys(Keys.RETURN) - actions.send_keys("javascript.enabled") - actions.perform() - actions.send_keys(Keys.TAB) - actions.send_keys(Keys.RETURN) - actions.perform() - def _save_alert(self, filename): fd = io.open(os.path.join(self.log_dir, filename), 'wb') fd.write(self.driver.switch_to.alert.text.encode('utf-8')) diff --git a/securedrop/tests/test_i18n.py b/securedrop/tests/test_i18n.py index 1e6dbd9f71e..ca01d6d44c6 100644 --- a/securedrop/tests/test_i18n.py +++ b/securedrop/tests/test_i18n.py @@ -30,6 +30,7 @@ import journalist_app as journalist_app_module import pytest import source_app +from utils.env import TESTS_DIR from sh import sed, pybabel @@ -174,14 +175,14 @@ def test_i18n(journalist_app, config): del journalist_app sources = [ - 'tests/i18n/code.py', - 'tests/i18n/template.html', + os.path.join(TESTS_DIR, 'i18n/code.py'), + os.path.join(TESTS_DIR, 'i18n/template.html'), ] i18n_tool.I18NTool().main([ '--verbose', 'translate-messages', - '--mapping', 'tests/i18n/babel.cfg', + '--mapping', os.path.join(TESTS_DIR, 'i18n/babel.cfg'), '--translations-dir', config.TEMP_DIR, '--sources', ",".join(sources), '--extract-update', diff --git a/securedrop/tests/test_template_filters.py b/securedrop/tests/test_template_filters.py index 69e7d07ba99..c2ef48204d6 100644 --- a/securedrop/tests/test_template_filters.py +++ b/securedrop/tests/test_template_filters.py @@ -10,6 +10,7 @@ import journalist_app import source_app import template_filters +from utils.env import TESTS_DIR from sh import pybabel @@ -98,9 +99,9 @@ def do_test(config, create_app): i18n_tool.I18NTool().main([ '--verbose', 'translate-messages', - '--mapping', 'tests/i18n/babel.cfg', + '--mapping', os.path.join(TESTS_DIR, 'i18n/babel.cfg'), '--translations-dir', config.TEMP_DIR, - '--sources', 'tests/i18n/code.py', + '--sources', os.path.join(TESTS_DIR, 'i18n/code.py'), '--extract-update', '--compile', ]) diff --git a/securedrop/tests/utils/env.py b/securedrop/tests/utils/env.py index 0aaa50e7df4..caf95126de5 100644 --- a/securedrop/tests/utils/env.py +++ b/securedrop/tests/utils/env.py @@ -15,7 +15,8 @@ from db import db -FILES_DIR = abspath(join(dirname(realpath(__file__)), '..', 'files')) +TESTS_DIR = abspath(join(dirname(realpath(__file__)), '..')) +FILES_DIR = join(TESTS_DIR, 'files') # The PID file for the redis worker is hard-coded below. Ideally this # constant would be provided by a test harness. It has been intentionally @@ -30,6 +31,8 @@ def create_directories(): """ for d in (config.SECUREDROP_DATA_ROOT, config.STORE_DIR, config.GPG_KEY_DIR, config.TEMP_DIR): + if isdir(d): + shutil.rmtree(d) if not isdir(d): os.mkdir(d) diff --git a/securedrop/tor_project_public.pub b/securedrop/tor_project_public.pub new file mode 100644 index 00000000000..57e13a71681 --- /dev/null +++ b/securedrop/tor_project_public.pub @@ -0,0 +1,2297 @@ +-----BEGIN PGP PUBLIC KEY BLOCK----- + +mQINBFSOr7oBEADQMs+Q5cAshRhj3YkKgCBKyrjFWMZqVhlf9Y3ePtFQ9kFEnYIS +G9rzMhFC6KMXPn9bgg6OBPPUnnJ29UsKvAk+qa8F35R+s0ZXmPRfmv5/6PqxLOn4 +G733K67K0/eXYW1mTkz9sjY8u9E3T10JNT0zE/60WihuZGKZQDIqqig0fOsdvdGa +g+srAW91T56kAT+y59VcvqVCQNjS897E3T9hsUNkQNCdOitQcnN8/5VNQUL0SjyD +BV0y5ry+pUt1rnojj82KQ3WzZuD+XsDE+w2JSGqhcqf9b7D6puy1smhCNwZJ9L1l +pJlrCap6YQN8TPFTkf4aFBctxonAdQDDxbON6sPJALc/myPwTVTxD3nJJhv12yft +2iwZLaCJcdq6tp96re1dwaETpvvKeWqhWGVkmNaAPhShcCKpVYC3+Jil6nTqN6LI +hKD0ILBGOT/2/Rxd4kj1uDzvc2RVHe6LKLc5EQYO80/wSIL8LMdqZSX2R/AnhcNg +G/k7yOQWWNY7RPU1cV+E9QKNwqS4Zj2VyU6s6ikaPuUnjW59iMkSGUuS+gJUR2hp +jOKjNzu8vxbotBgZ01upDUdl69OnR1dv9X+bMzGWUyOjAjK6SP8rFtWFBjWgWcED +OHu51YpicSdN3uf7lppEXGx91n45xVMhL9d2KNp3DhWkKDuWhdliWC/r1wARAQAB +tEBUb3IgQnJvd3NlciBEZXZlbG9wZXJzIChzaWduaW5nIGtleSkgPHRvcmJyb3dz +ZXJAdG9ycHJvamVjdC5vcmc+iQIiBBIBCgAMBQJWJAcdBYMHhh+AAAoJEEUMun+W +jwlLEiQP/2kyeMhw3biKHavu0wTaHmzNeE3w2tz1/PXb78KgtEZo6FxNENz12cTc +2e8W8Dkx6eYVSl4cBA+cQuxU7GDoVObGL4csRGg0SXO/yAth8ycWhk/zRyOXohJW +joqHYb19+wK9WyxpnTIMeJzAanDQ/UoRlWVxnkIsqZGjbuz7ImDUtDs7c195A556 +xz4ZA3u/ZZlXpDpsyz4s0opYwHZEU8cy1LYDsH1ecCtXtC3Q9VhlhauuHGVnnvjE +XVOnn0iF2EmDrVyrZ8CA/3Grqp4s2EX39OAV4ZUigcmxJ9YAhHxMe9T70S9ab9Eo +1wR+hyFq4Mb9/vsqa96W6X4jcCqOkF6MKRUqLSZ0PIC+Nh3FYKv9lli32X1ByM1V +qxwW2+OqkQUYOJS6cQb1tpxyDIXHOwVPf/0Md9kjJfTTAoucgoa7sKJxq5JYBUZ4 +6G5CYavLbhjg8q+Ds1Z9NEMyjumGoNF8kXgHzuRLnf4tKppaoSY4Gj2nA62rZ8Ij +TM0DawU4TnL7Wn3ilKOQQZbwvnY2iHpp/0WFJU0blxuNuwjWPMlEnF8hx7ffaaUu +wmcdXHVTfMX5FsgnnHzenUB71KK6U7b93sZAqpO4gXVlbaKcZwAKdpoAcb/A9gsU +wJdoRNzemvGTm9r8kE8EQU4LQEXfwhulYdhBz1ROBbUwvVYEj33xiEYEEBECAAYF +AlWla5EACgkQ+y7y9FbF3ZAQmACbBJdYyWuOZqW65TQHuhBWUylmvosAoI7ZcRHt +hsc7rbxyyrVyxf7KQynciF4EEBEIAAYFAlaFeWIACgkQDChl4xJJA59WuQD+KFwk +FRDR+btvd2i9AsDDuUaNKgLD2chPSBqGdunp7EMA/RljHbiv2IBT9/Qwh+OhsdlP +NndZP8hlso3aLhnwmC/riF4EEBEIAAYFAlaFeYIACgkQSrRpVGbBgo3QGgEAk8kS +k1JGmWgqN5Z/hPaKWphZPTGKILU1ti5SbtWOX+8A/R/xhCSNvfo6hj9gD7Ke0RQD +f6oaUYP+9QkLKrCtmVYpiF4EEBEIAAYFAlamHJsACgkQZ9V9uxJTl7vDXwEAh2D9 +WTqu9pMv6EtUwVXHbKuJqMQgdnlc5aQzsRMLOQ8BAJWpb4Yz/4kg0CReS2VEQQ0u +5D3nQ4faAB/k0oba8pNxiQEcBBABAgAGBQJVEjP0AAoJEB06P1DNYsLzp2YH/3Na +Y9upY/1JNHSir5vTCti5P60JJA0N5ZGE7FpQYcahsm1EugAiG4avfDf9aRTJT98W +0zvNC5fnM4Ubiae4vk0bciG7cbzrNP7HyKZpe7NmVTIIeINXyzy3z267wKmbHuqz +dE1GIIGiWsJbg7ojQ/1CQIlNdGLmGGe2nEx4To+z+mueLEJB8ClO2ucFN3Z0ISUp +x1nZCUlJAvXZRGOxJy+oru2RI8yLaAa/Fmf8UTMtVN8ktDGPCEl0Iz2m8R1B9WGm +OlDpR5f61ZF95BSMPjasj0PW0NqChW7tZtPBpDu9OkYRgZIa4HcSCqWoUijPjTdY +O2tEd1U/jGajXGXE5WGJARwEEAECAAYFAlUTRtkACgkQWCE+ooJH3UWzcQf/YSRL +IRNV+RZ90f8cwqlk4Cj/XNGjgrG10iO4NlPoRsjI0mKA9KgGCa1UN5hqOqwOdW3V +Wq97QotF9U8MRWGdky006uwfx+p43ZSACHYegjmH3is5G7tMGpJh4sPwyLjtoZsc +PNva/LoFOiEg93JxklUZV78ndxZKdZqqxDaMGSwxmUpa5RwX772R/BeoPIMlbtm7 +7V1MFZ9f0yC54YMF1fGdAeqwwJC1vFXoA+E2o7IzdkZ7Ik1YgOyHtM6C5SHHOWIs +RJS2cvNQSeCnHs97WVEwRh3VQBBKezyKrq/9vE8t4OLMHqwwMM5QH40Wy/XAnplu +LdXyqfihRfMKhJTLaIkBHAQQAQIABgUCVS8zAgAKCRDKkPFV7oCnVI6vB/49fRFE +WSEI5hzxteKl0nUZ6S2Ls6KF4x5CvRYN0Uo4fK5fH/Gcb7fRKCdrHD0ecTHJoRoo +grSY0Drd7yWWAwe4N9hwgNH2hWy3p7JdIna4JXXImiR/eTGriAW7Dj+yk/uMnaS2 +eM6rQrRLoyIbrMEUPDOWzDAwf7ky0uy0p5Ks4pxmYL/4yy0HbAx/sU6xDlkz+zUZ +wdwHzdD8vRi1W1Fuch0Ip+N2RsiNzg/TOVJRVlQtvD+qCcFr7IOEzmD2TKq2Xm3x +XkAue4BCNCLE/5S1SA/lYvml34ZEFasRabJ7D9QYS0+mkfnNzBdihsAm7nXs3nYT +VXD+G5XuNDPzbAqSiQEcBBABAgAGBQJWdVMcAAoJEBjGsF0UDVTocX0IAKIc6Lmu +NYPLUZteJ4asvyWStWmw7Y2sEQFkT8BaW2jyOgD84n4KZ5HkwnC5jrBPyqOemqJb +0jDTZmZFYLdgRkJPvM+z6IV0yYp9J7A2rpOoDuBnEiPlcQuEBWiw+faKX2SC5liQ +Tv5XfxlFJFAIGE2g8PVgZvM790fhHBBtrE/h9/6rujRQ09z/DlgKyzvCyhjjXMdq +QOsWI975b76L4go+JBTQ3sOj9onNgn7NtzF6sHUVlowOZa/ZXw9PS0jlH4B7m4d9 +Zr/Gtxg9aeJH2lSlWYaO0derjXAa94KYbsKRVX/cKeH0QonoB1Wx2pWyOFh15h5h +0bVS1XszCNt6ifGJARwEEAECAAYFAlekf9kACgkQNmmNs52lQGU9WAf/WVq/GmfI +33xfS6ub/slVbcSbPk0tyYBKNf5VrJ+c4Y97aak0ryMTnhkVzEPhwEDFJ7SFHzSw +NmQLGtFXNokaGwq2RQk8n5NvLcF+hh7bEZlF5ujDGEDeQzHL+5pK8urbx8mFwBIE +sGxc4VqTQTyXv07/aYy2+t8fxnNDqYTyzkMRkboWVgCm9+S9/xDL9hq2xy7QnhrO +nDHlxMJDRLCpJSPmE0m79yCjaQEMjoJa91WpbK4HBfjA21DcQDGUEcvParyRx0En +TEHXDlCbAHaQSqNTdTl8VjWQSowxX8srGobzMMJnTpASEpdcvSjX0qPYtz8Hys7D +3pSsUTKrIe5p6YkBHAQQAQgABgUCVLUlJAAKCRBBbwYQY/7mWar7CACWno76ZAaM +xYSDbAB8FJjit4aG+C2JWU4bGCHD3RHdPfI/svYAos3frt+ewWWN6PsKzoe3Sapl +NrybVwK0k8KAxPn9neWFJkRe2llRU4SmdUNk61rS9UL+brzhBxz/uYmNI1ZE3yqG +hFgYCHdS3f4dEQbjb11cBcwsHNI+T/LS27f5A8cTKcyW2stBatFkLgyV6UbKeLDC +PZQtQLf1RQz2CHtMdFZ/jCzJYpLc0n50XRzfSRMA1zwryjDx0sgTR8skr7qIxDiM +rP2Mlpqjvj+sIUMaJPhGP+XiCSemteDUOGTgwf0Qb7/sK/S+6czGiElHiusup3d4 +G8tpcfEaMrodiQEcBBABCAAGBQJWDfqiAAoJEAWnN/Y6+kUYfEwIAIarbj9rlslD +YAGcgyiRVONu/t/YyzqThQdz5vdpwvFC0fGEfiKG54iqvOU/+uv34MmGUKovKCn+ +qFU6RstJPWUk6GWfl/D/QMpsWHy3yAfdd0rWsOKF3EfsYftEPXGiGrnr5AAJ0pLQ +7slC91OFjA2/Vyyi9HfDOUCALblttku2UlMSJEqKJvx5JaWVIuYerPvrhULhp4as +pTBV4QtpPET7bAmDQpHXL3SuCghfVTNWK10eQwa42jUE+X12d5iXGkQewaMZAcBA +75bEbeuxA+7PKI7uPNAPKnYB9vWBLd/+XW3ZB4jxWHc/Ga9X1jReEQliteVO8DkH +wmLVxR5aeKeJARwEEAEIAAYFAlZOFkEACgkQp+axXpLQghfUEQf+OrPcZa3pWmph +Ipbhe2pDDknCy56NWOLHyvBSU5115FWGWRC+PJRJHFH76CVciakgRX3k5RXnEN+s +H8kHBEhr0Ah32tSVDmSsf79ah/zKdAe+YodZHC2VNasH9ONf4CA16dPLBPjReGO1 +rEJYfl2w8OoRu9aL5rwuFH9fvu9C5sAHUFpE3Xvz3jnDzHEczmAXLBXkMAsqnRDU +LOaPCigLLnZXGqsBxjPsUr6GMZYI38jSkD9ExoqAYgEiCyq0OP+wmv5iyeuSqYXa +AEnwAaZx3mdVi02nR7baqQ7ndYAEubOrYFTUVhwM1GvfOBigW6BTP16wNz2Ir5i2 +Q64PKUgDkokBHAQQAQgABgUCVpAS2wAKCRB37AfRtpL9a+1xB/9eHSTC0jZydARx +JiHYZX/kQNrWDmtb1GdrWo7xOxfhEQZx8m/7SK/uAdQRNQCTIf3uAcFFrOfRNujR +BhlikCVQlGuBaYc/facbYgIK6vn47L4jRLcpKBs1i7Mv2qM6MCTgzJDtXH6dGYHB +RTAp4JSB4URJekfgnoxk0sI/8IhpuQ6WopuH5XEp1ly9/lmX+rrIvWmTr7ENGnuw +JAcGKRPmKe2GBE0adREwSulvoTLnr6+1Sx3voI/jSNDnN0P681e63mN7kANCIRNE +5MnUmsdxuG40ctzTAhg9ofSs9lL9JlQkGrsMIcJDPEreUNoqHPaQJJ9RwUd0VDXC +Z13qFwquiQEcBBABCAAGBQJW4t52AAoJEIYPFBQYifLDbPgIAILq5yzZ0Xf812Fr +YHaO7tN4ZqtvdJOqjFXct/TBl2B/MdXSwmG/kwBgKJNhFEma4d17J5g7XNsBX4x5 +5x6tCPbBOL63t3mkgTRkiZVRI3yptV//unAzSNZB5IXsI5MBCSKVZ9oe0BA0GPX6 +WNizKIGYsgvxT+/73q0IocwHmSMN01mK+tSgmIYsojvKoPvBPOF8p62ELFtStCyO +frJ73b89SlxhYMV+U5059m7PIQtFUDHtqnV0de8zAjWJUNIGnjAqSyYjTgayeK4x +QRU2aoShrwfIE0g80cCNNARNeMb3ckolv+K2C85RTDe1HYEPt5/aUBaHQgPTKPNv +mlUSLlqJARwEEAEIAAYFAlcnSooACgkQDC5fyREfiHUADAgAjSn1OYu8xFloaBzj ++r3ZH1+/GouoTq05gZ2SZouUOigl2yj8vnizSw+Gafohg/KK3SeLg1xXU1gmhnzT +zgzZPiwKAE9EcxyBwVAbuEyiaNvLD9xHr+wyf+TcdrHdwjHBnGLQqhEiaV0lXjQZ +YBijuT1a+/wTUWLthSIUapHcrECCzjRKpntqZo45pVIwwlh1ufFcx0we+uYBrG/w +lH2ZIUSc4I8/CllKr4QbEUhvzHYFZ0k/H+R3bMcX6skKulwzJxGqYyRzqWQv+xlB +tKPC1MSkq29JgTv6Z/Zpi+Rx9jLLCIqRjTijmVg/1Pqvv+oBD1DLPw3cuCwYXnTg +M7jN+YkBHAQQAQgABgUCV77uXgAKCRCD9WVq7ETKt/C7CACqxQ6CCIXqtvffOptt +n0Rsu8kQlSWeJusa9wUmwufZRDwqLQ4+mer73o72AZb4qnto4RRnpP2TiHD+oedc +wKcvZv3txc8VnvFNHkEE86XjumLcPkU3CUs3mERA0S3+/7OTEmjlW+RPTtbxtDKz +ZnQXcjKH/l+8FkOS/iF2N0CjqHMgxEXTJGFAQ8rmxMVTUnLoFjUBqaLPtOXuefMv +yVkdMGG7efe1UE3/67PXibw6gnyyICQtjxvIgd7Hd4GXQ9H1jAM0q7790JMM7LK8 +GSv89XzTh3fRFFv0H95JiA62NGX0J8GzgUXzE/yMFEAxSPFdIvd5Q05yRkC3tm6S +OtZeiQEcBBABCAAGBQJXvy77AAoJEI5EJuZR7f4otfgH+gJO9+z6/KdnCzJZG69C +0yCE3suwAQFuNewUNkq+W0Kxn4TIpfhei+Q0GuR/or5o1RkAOZzqwHY4q8mqifgD +ixbidVgzXkIVrzyWaQPCcvULhd6EPuzQm9ORhMB4WOPS51+AyCPXyz2F2y2FG8gn +QhWRaCZDaZ1E5U+y4Z/Gtn7zkJMpD0oHirnE0TFMbMYMHXomLRSWejHj0xdLwKQ7 +wZsclLEeLklWYoMxxGSm7QL9opEt/mA/SRw5wcyzJR+ULbiBdFMCY8GZsGsPduHq +ZorfzBjiO/gm67W33UYO+lF6UAjwXWEs08L31tbyhPIxwTnnMLK3vwx4jMkfHXoK +4O6JARwEEAEIAAYFAle/ty8ACgkQABHAjFdUuK1R5gf/YvuT/9YfjuzmYxEHY+r2 +NHeLp4M1aAoCNIwoWqrxBAE/beqc5Pwu3slrFZe20+iWgjkoVToNJ3q0N/gHlJGR +DEj0Lu6gGsBsTaIQ+kepVdh1dvJcEQIkfIgtGebR2IjUT56vyb07ZAHsE+mDGt/G +9xOpQZs1dbK+fq32qA6iMaJ0ATlN8sETzjb/Y8OKiLz6R8xZPUVibToHGkSv9Jbe +FApzj33SJWaGkEMvk+kCqj5XBjxa7RoUMcpdV/njbFq1I5/ZfXLJcmide+E2974b +T7z/m1V6SfDjk5UYnW90IDu87jJpmDEOiWkLH28s9sLWa5gn2Dzc5ji0qOwcyAcU +FokBHAQQAQgABgUCV8Di0gAKCRDNjJt+fEivprzFB/9fwX1KeXdM/jQKqf6+wswM +EzUjXXvloCn8nQUMe1fclgzv+qCkkeeJHrnAhf6finr8nYdkGnxYuHFcUcHKZKSQ +5F+i1gCTMT+qQrXK5PRALvuUzQmQr9yzrJD1srbvzPxWdscc+0kWKT83E1VltNsf +wI3slRv9dwxtGyzxBJZiL5ujNEXu6Hwu2ScUt4yn8M+HakUdEQamfPJ2+tuf7WGg +nYy1LLXhBbhM1zy75Cr2jqapoojG8nMt7tIDPDHtZMASzOEJORaVGorIwzDTQi7v +KpRdsH714JoZ6zoANAtWH4kxwj+7vU3LqvI7IH/MZBpxRiyhPyvK4wyjXS0hq640 +iQEcBBABCgAGBQJWC5m7AAoJEC2zYkPPOLFg//YIAIInDFZ/OT6wSkkiupik/fKE +CZEBRqvPeYaodMgw8sSJSzf0F9b2E3mX3j/Ua+Z/j1B7uG+UDmiDyuFoNQxzsS/k +E45ymt9PiF186hqXKC/OQJk82Uf/Dxc1h9e30TYpnwM/aC4KPJ8Rzg3uYYIxnTnt +3yqRNFmoPnKBirI5PO/fHaxfTUB93tOjzSoJmCUndLMoHGmG8dhVwzncaySWRi3Y +9p1n/WBioBqqivVb5Ukc0FN4tnt/E2leYlDQV21AKXjf4s9BiGH5EqfjI1vXO8MI +IpgKefSVQ57jxGK5fiQzOJyv3OU8yby0JBbKYETqJKgXnObkJU5W5BgxtOA9+XKJ +ARwEEAEKAAYFAldoSukACgkQtL+xDMQTzZgYYwf/by5eFJnBHuXhgj/Kq3gbB3il +CDqxDI9P+GsJAoSFQulghHCUtpEnZwCZpiBBEbBMeY4TiAyzhfssuY4piNRqkFKH +58F+ck1+KXR1KEi9iDBAJ3nRsTPlcGphWuZaympu0D3Gl4DShr6ofQIcKxckgU6K +XY1lx6WLTfGgm2VCoDRnUuseopY3SL/GrTbxBVGquZk0r16IcYjmHosdeZeMUmRR +Zlr+Q20lCNAtSiLeN4pJ1/dzpDSg7ibvnfJvZOH2hTYZDQc7PBMCVLXmB0QaED28 +LY+vg50CY2YxviX629uYWV5iPaNXgfqpvLDxEFsxARES3Bumi/ke+9t62swaB4kB +IAQQAQIACgUCVmvepQMFATwACgkQprLysGe07OpJ+Qf+JWGZuPMxH+GqH8XEbSH+ +wow+cAXgi2KLBzwBXD759R16uvfhPxCBp7LA01GOonLEql9HRayKu8z6kCbacyWY +12PNlftIjSMvUS0YQfThogM2QCr7P+oGM5JrEa3oYrhot7a3YElKB9aodneYsdY1 +vxNZgH30/ACuF/hdoobYn5CpctkoUCRfh0NkbfGimMCmaUgSghXJ/J7i+06rKQP+ +EHFFa96siRyv1BOy6/AmK5dt5dJsU56NrBKz5KmicBt7blsvFgUd91gQg9xKTWDb +BmZGlSvicoEhA6AWNYTeqHTnip/3K47/W4A7+DKX/Y346zIsRmzkYon22MMWOC8l +iIkBnAQQAQIABgUCVZRrpAAKCRBeWmshHQAymBM4DACr3N/DgNpdp4dkfh/WJHV0 +mddRn6TVfKvGBgeBVLCQCMJ7VSfiOgWDsJ5EIA7BECwyluJKJ/7XexG0TV1Mr3vq +AMnAAk6eOjJOezugRPiqUnVNgQIYCaTd6aArcSdPevLVJZViJaiE5hoCXYeWZGte +Kt2uMFTy/vFqBzc2L0kUkRPy5HQKmk4P50Mvs1uNdmuxJ7HqeBE+PiN2XmUjflkn +J+uojz6+UqLD/JN5KoFw14QLWSBbTLQFWVbRJ0Rjci5JV+tNDzqfoW01z6sCfN7g +tIOn36vX1qOBQDuTWIMYAftTC8s1W175ehr8aKd9uyt3zk6Nf43NI8sTVy57aj33 +1vIZfBdTFVSkvlxC6qZU5wu99XZPMVNMoJEg4dl0MUiM1hj9hwjpbvBM581E+u0d +k58EHR0o9PgE91IygVRl7BghvTvPFZKAht143X24Lg+VzDAJ/LHEf/M7g2KIKqbx ++1WZh1EmDh/rot5uTsu5QuEn/z7DNgzao4giGI6lH0yJAhwEEAECAAYFAlTvJPsA +CgkQIGcAGxtnimPu7A//UaXhi58zA/x7U9+1kjAUweyiwzn+AIKYfdci0puPSQe3 +oNXlV8zK56hh/y+mo/tXqQd9kGmid9vadoln3bd8EkdDeXgMrPp6Ru0YSm07qlvy +pJdhW49xTeLzKBFXz/o6jPLB/mODkJ3jkBgaaAp00jeBGv94dKnz+McVTMwJHmtz +406tNpHdcWgN3zk5cuiM78Aqt2rkqpBvCY5h31MewYpOaZX976DRYcBnx/Tg+Iv3 +s5zmqhQHJ4Y7BO9x31hcKGi3eryfqMkYSUErOx4ZORfHDiJqtRwYQppfruFzzYir +f48rNb3SqqBTJQ53EjD+LOQAQdvWKs+3Q4A8cJlc6Tt9oTqg3RE5PrR9eM5pOgle +95Bz1B2+Q4n1Fn262NY48qj2Itgr/L8oYoh5wVqlvmnCfu05glKe+twrlNJwLHYI +SV1LjwGqiTf2pvWFk9floEmHpEfLIStwd8D8GwoZONQq1ziw/J1FVsnRvkCURozG +DOW6KdWI9gtZby/8WEg4KVD5z17jtKhT4x2l8jitfZgcKxCE1Ia4Blamyh/z6GQq +7b2zLp7Vly0izuvnpS3f7Tdl0Mvez+ITmyqMghW8frEjKfy66z8R0kOB+k3jd7Dx +xf1JK4+2FjSCyuPZYo0BD7CJS7xs+ZIBIRU4fHizGqd5X1ea4V5QLw7BZcxWt3uJ +AhwEEAECAAYFAlTyb3oACgkQryOzSZXId+Wr1A//Tv3xfJEgwEyUkzLUARwiq+Dp +uyfZ1PfVYAUxqqTA71IZSLTmnS/YyQXSACczx35dkXIr5SqbJs5oiNq01AAcVCgD +lvoSc6JI/ZU0XtNaOZ31u1BkwgT3ZypFMIBrHmSN0i09k3IqVV9mo2K7LoxC4boU +uIEXSc+6sNndlaaZzFcwuFotFQV0jb2qIHhdmiP0E2YIwzQGAp7EVM+pxskLqUTc +cSuXDx3Y9pprLWbkaa7490s7HnOuSoBGcDS/DxjY/jlIc8u5iIJZGkmqFQU//qMj +kcfdpOWI39v95cG/OKSb50mODNwSCb0aIJ89Ffhto8TAkfqMVABkGlXv0gJ7FWgx +w2VEu1zDTRXxjOs6Zv44WIr1ZqmmFz43gjpgegDSQUeSt6wtpuXizi/z65E95cCz +9AH2TLGBlLBFuRmsGoA3I2KHNcMShKKq6eBfv9uGG65Z2+QdspO5hSB3wWynLDoR +ZvYtKZu9IdasVKE5Xg5eqSIiXE98DnQ0MoCuN3scDMLFuI0b6SQgtlqRGLg51tPq +tGAO+TgUy3vhaJzsBWSayYpW6iUaPMyYJZ9jPpsavyDMdTreEUmG17a/pGUQb3RR +dMXBxLg1421M+15KMkUkgz/K1OAYjeUno/vuRr2A8nvgVhxxH9239r2G7WZVLdOn +U3zKLMcrXUz/TZW2TKuJAhwEEAECAAYFAlUG0QMACgkQJLZC31l+0JXwyxAAmn+F +inC83HPjzJnV1/HArNVjjvlRRsTkaCqiuu7nmxkESX5VNMEG04xlLOOj6IjOIMoN +G+px1KSMy0gkq4UtSYAComUWsblB/dE0tQbQS0lsboeCryjmP6fMXSwUqT09stjA +dz8EjESXqUT7m5i0auVJmiyFZjrDjnBso4tf9rWjvGml7ktGn9SoSdVYrqfHIvOJ +GsUYXmNUYm2S142Bu0YQDLhHKkmqIMeO5UaL8PhnI/bk5bJdCla2tQJMzKWwXNbk +XDHUeXVdYXBe1PFvBOMg1FfY7NsJ5hZeykOEXrtz4oy2P5lxXa2UonSo4ilu0Zsx +GbJw2g1CdWD4kw/g0C+CdxCwvwoPyrmAPeClMwX0xFm5xHbjxdjJCrEuMyFukslb +VafJt+0YONCP4Hw3WYfD5/e1TO3i0Xh/1F4f4so9gbW9HC5lEUEItawAkKsgg915 +B9qvVl1/kqpFVKWCaf4J1INR+EcQ3EcBCOwI7wpxTTszcSwMCk5ItdnEH9FFH4C4 +OrWBOWIWtMWQwH5PJUmy8GD494eWj7WUnyhXZGAyncIL4ymX+LJQev+RnUz4Hqt+ +pifd+lZmV4r55ku7L0cejrSwDSRc0djyDX41fldpevKuCrg82Q8GziznRF27d9XL +3jI85K59XxceXdRLDnpus72RQab5t/6EljMMoyuJAhwEEAECAAYFAlUewEMACgkQ +g4LJXCkCPfmmsw//VeIrcKSNSN4cHAs2dYCCwBJaZXqroMZv2FcdiMsjMiRFjcm7 +fAjHb/JlWQ6TPItoDmTTBmHktwhgJ/AhF0TJHNvPAZg55TuBzmM4ndVS7GupJxxY +lT9t3Gw8kOvbGYlXE4L2l/Odo+56JsX5zIjxi5WYN1dpvY8S0r1etdR1cw4PXlBO +Knenn+ZU3Jt+OYmYS/74xsQqAPGrNmV/Cwy7EM0X29S9N+USMPnbSVf8Yw37SmqW +QEaQpP4zLPdi7FbvoLoKCiIUmg2ohVklPu4phYPymWa56xplHo6vl5xUEioXuwQV +I2uTe8cv7wea9vnN6OoXcKXcdK0cg8Yv6touKZFVUoF6Rc2426uAVe21Oapkh2yt +dzQuOfglrbC/c0gTho3Q6JKzERm3OlNf+lihFWK1TI45oBpdAn1gfFpZeokeh+sl +JoPK8cu1VfFXIBWVBBV6Wiz8GoK2ESVPPMY7paiHlNxUszAGY/IPk4fSmmS5HNlP +MshC0H3OHmLI/aMvY9D0cT69iT9aN49zRYGQoKq0jZOw3ScprcWm6SNrkoK7Gwcb ++nKNttU5FT5i/hlgKAvr06fxtD7WDRj1elOsfwhsq+ySGdf3/sWb4jqMnjOHtKXD +eLANwwrCZlJBXOHeIEplWyz04hRVnnDcZaVTexcraxXHnBQ6hjWLf5igIk+JAhwE +EAECAAYFAlUy5tUACgkQft5C22lRtPqblw//cYCrjVK5bA5Z0lDGS//Zmys05swj +4TAPnZekJ3Z6oq0ZQrfxLgf94awo/6OF9JopGyoGuNKngn0sP+0qjTYtIV3ra/zm +BUFzDR7/bDl5/DR1gs4B9XsRecu73IbYEpu5xXFulPbXJyN1ogBjJLUfNpl5+46k +d6k0E/hsxFm8/7E2aJXnLFZ0v88+alUOKFAF1YzpbSm7mrdPpW17qQkA++aO43mq +wWhuaLAtwryIRLoAaFK5wYw3+3r0hw1cdpu+apWxCkLUzmqxID1CfBkvkIP+vy9+ +Hfr78Rtvem7zxESKx371OK2WgMAn1mUOT5RKsaFRv79LzGgjNujKRYxUI+rEApC4 +38sI3USm5vlBQqVxuKkU/9OhoYRVQM9WI6TJnf/GhlPFuzMVqkokKckYFWSo10Em +3oydv6Cda1zMIaUhGO1xJ/4nlKurNTu4jwSjbG9jPc41t+2f4Q/tQFZuNRlgZnjx +4dFCkMNPkmgSN1oFFT/X/xK0b/gWxVQnRh86yKyC5Kt/TkWhF63aC/jj6846xayX +ulklfw+Y9CuD5pbG75Uv60Z46oUioV5UmyLfGOUDa2x4JCveSW5hgn86vc3Dts5o +MMJF28elwZXca0wBtibTGcNZhqASiqjBzB82nzivv/KGjRfSw0rH2xXgAO/gx1bc +47o4tU2cb7ITVc2JAhwEEAECAAYFAlYXe74ACgkQTv1P3D9G1B527RAAtzBLhCEa +rYY/Cw7htiYA8XfJW5m8YFgj2/M21k8fViUUCJVJjWQMl3HLRtswMsd54I/1N8lq +B65SGjkvUQVEv+4mKGge96no4cb024MevIobHiH5gj35Wbxb7CAkpGxpSMrxBKV2 +VQewIXhhQIMsiWps+vJfp15BgDFMU3OxX8PGB8KwzZIbU0P60+tlS1pTg6tOqtYT +b3RhonD17cAjpII8LpDSJ+Jz7qMz1v2WAqibb8nO0/vZ7kpvxTwInWCNtzaLOh0L +9X2KZ+RDTgbQMzd8S5r9I6Vxpc4lc0VXlf84TGlpCj6P93S9ZBeIMH5kR38Mt/S7 +L2z3JxnyzMKScwvXXxaMZJwi5QuADx9rkaF45YvJCcMy/ix765w0iOIeL40m5Km+ +f7VEmzF611dyjq5wA1cKnlV4oi3svmAL0UV2Xisfx4ofTSEEJC0s0dtUmkv96tLe +QVUGxb342Ujdzwqdam+/52kcuvYJ6OFmGlVyra7BeQfGeJjkS7upnVO2mXDDG604 +KtwTKeiWsDi89o9McU21UnKX65HuezEd/1AdZxb7AgHMd7cGB6zov8+gAZai/rs5 +ImEZlXB15vAsdMNtS0vGWqnQTo8+3ymITwZWQFkYqINRxZHALsdYH0qclqTngz2O +FtuRnE69T0Uurb46chZH/uPc/kNrjcv26g+JAhwEEAECAAYFAlYcuoIACgkQlFuq +zo4JKo1qvQ/+M9+3afv3rFiofxVVKXFVcnNUhmCzn4+Kc4jz6Orvqla3B9MILUAn +7NjBwkRD20bD92bvlM0uoJcxINnaue3ZihT0astDcWiqhunSIuZDRByDC4ID8uqH +L5c7OhRPrqrU2s5d45HCoUd56MBN5+STQUJESAC7ERIyEmhZ/MUWBiaCi3PKSnZc +Ynd66HOW0h/kJRSGus8EgBPWqUPzeo7KI8xm1Jd+lGIYakIVNl2NpWNyv+2qWxa9 +QlWATlshL2yraLETSHhaQ3lgU7AAW16OKFYUpeD/9gg4ehcHYCAIqfaavTQ5YOTC +hLsy4EQ930tskIRNoHgwhu4z9bobNWJcrgnDtzG6CQKitmRP0O4u6gHMa9Ofiu1j +K3wBs6MajvSczvZvBNu2tPvQVHT6mA7Nf5Ny1sD57+TsSNyA7GUzc72Ok7CkTIIu +OgjHj3RYYSEmPZIQFpDX6HRa4z39pcwSLE7sRfZ7MpyQxp1c9hp4cmr3BuKoqV6F +cHRbM0V2YzvsRiJi3dAr6IJrjEDpgoEvD2rB+dUeLSQ7Tvu81YsHbLmCikXQc+rE +0V2i96i2xS67I2MbbofZX7tkYvwjMgwzO2HHAz86soaDGOpxklXOdbVpPGsCiz6C +B7SyA1SvgwR1HxePO+RxLU+hxPuhAAkuLcy9ToTKbHAlFsy2fR4Z3jOJAhwEEAEC +AAYFAlb6eCQACgkQ++oxEKhTeJRyyw//V8G0nVx+82k1thkynXTlvYYuZ5AYWhec +OOjRc5bJI/alo7LhJfYbro3loCnq3zlokTYHzADwD79VmgXhgbQSqOpxrxofFoyE +1OqnMBMcHzgyVJDlutHmpeIQ+J+wP53Zwtxf2B81jNoUKqxOZiCrlra0ysuHz7XC +1FYmJHk4zmchYly5nWTAQtjBOHZaOBX8j6g4YRapEjbNF8+OVFkOjZ5rhHjFweYV +jX0hjjpBtoi1hMkUIAjtztlsylSz/MsvGksx2AcO3V+/JaU6VHAuhMdxHFrdMQd0 +B1uJRwsfVOzlCi4UG29adDcKU+/yh9ET9HgWyrm8tTXYl+1VGaunFCe48Lj/pbG2 +aErB73rAVVJMLsmOe2bf4yce32uVT/TAsQNlZc2zXdxDQ6O2ge/iSnRlQYq7g0UF +xB7PQ/yiGjp6nYiRjMYakzbGaBhNSNeSo9cMeUXHG3hAKAEJEMNXNsGamk1wrG1Q +BZwkPNMgtbw3uBCvjuYD3IPWZA4JoxDkQI+JVcLPI0Q99BlUwBvt7UIdhaw5etgE +kp6xThuttRxXFORL9ez12nrz+srd1pdhL/DjvqCroUU+VfO6i579/U51CMR8vDSZ +PgRC2pQreeiapCQ+rJYX2Cr9LdOB7cA0ksAYX76T3Y5vBiLcXjN7BAx/kMPeCSxI +2LGU55KRYWSJAhwEEAECAAYFAleC6P0ACgkQhOOSas46CKvwHg//XLZiFlYfPCLH +aeEtF6wh3aPvZw2w6l8nTtAR1xsNXbKiUrnK60O6itOTLx03EL+r0f43SsYmdHyE +nTc1tKS77y4HEOtx0lQW/C4aE4TvjC8e6w2NpmSTjZmLQMEqvAfDTtSpGzHnoSbI +M8WsLK+Ne6VZMyqD9h416tpBLEgXC9v+2BU3g8aZzq37lGtGw8JQUCh+5Gl/aXC1 +n1UGqYBVx81+v5zhNNn6QQ/3RpR7+h0FBw1TGmmPVztp7dhq0OnrlY3oW7Tf5pMt +M3r9Hawgv/JDbT97uSd1JDQWG5V3Nc30JCw1fC4Pan4ql3Dgpx+iuGU1f+jjMi2f +gJeskfrFTBNZRHSxvmPkG4FFl70P2Tf3oJvk11t6/wh+E8n5FRjRg9c83uFcxYzq ++wEYy0bu1TuIsFyR6dEr5OfFR63nEznAgDWQ1R8tGUyCI8jWCqL8trnOUR+mgu4b +vPjdptvmD5i+C++4Ivg+y1tAE1+GbfQrF49spAyEow3oHruCGZDM9ik5NveulOKO +bAs1ZhsLv0AaThfudx/voMjQPzmkqsIG1l02mWABcftT1PeWRyJwwcrB/U8CcYxg +jcpWUWDlBRDK6akAjRz/RQl5vHHV9KWGV3FfhbgLGUHPP2dLbOTQfe4SKe9jSOD5 +MeMjkJ4AU1M3EOqm66da8Kc7r+sVvhmJAhwEEAEIAAYFAlT6pHkACgkQEuJIc5Bm +U91IIg//QJVibZkRjE76aALEY65BPf4jBCZ2be76lz//w8zbXfAbJAOWxDvM47tK +0zHgwQkuZohh67eozrIN00/mZBOCqPYqwbwGb8iaM2hAq8gC9/UagjfYmPzEpjCP +I77RxO8oXxAAYZ/s/R9vtbBaD3r/Br/88SCyW6UvEEipv389Ew0AQYRBWagGEkUJ +/sxi6Kmf0hFYOmQVMyG541lGNSqU2JKVbgxvodERBvSTq+sWgBUXa44AjRh2ldZL +yS/exKGmfkDqLd3/w9YD52L2yPkoM1M/bmiJ6TzZPpFqwkvo+1m7lZKnwXogEDVu +4kgVij/Le9qzB5JoxCVzlq65zxgKAaFyPcE8GUIQILgChHWvmsVCzej4h3zihT0c +or8GVeKgV9sQ592mvChRttsMwhXuFQAPprbnPjoNc9Jn8rwfi6JDnlsnnfL4RT/T +YzNwmGqnIQDarC6JE8gg+ZMq+gOVMeZ8WfcDMzy/wHTBGrHIBBr/b8yKPav9YYQ7 +JMfg7hXOaiVm8DKGxIuEaxtbF/qdJi+FvN5Sns0RGTKyYv6TahfsLiPWkQEYBPIq +J8VRZoMaF+atbtmcxqzqeRpME4Sm5Y3PggqhRJkdjK90my8sPHfH4LIWUywtRUHL +S5woJWaALUIF8nn+71pXWzZlpfsCqL+tXat+oRxTbnBytvNGHtyJAhwEEAEIAAYF +AlUl2ooACgkQ53J8VijCowDHpQ/+ORc0FFAnQGcOX1XHjELwZdl7jFmPietHTK0W +XFN26rPbE5bK4EqJmVevVFqt8Yc4KnrUvvS/tWSR1DEuQ/O4ZjyLcJr90CL7AAEu +7pb873Zn2u8xg4eJMo2F1UNFw9l4hE5uXzaYoLL1mi0SsIY28z953Jo1+qOoeC8R +oa5Sz4ALUFtSocpkd2XA1u4ZMWA304GOnrhm58oaXpi7dk8nKjfAVrfO/WckmO92 +lL/+YgIuSxBKEgTOWqMbLE2JPUpFnP64lxHLbaFu0SuPiap8G4aN0CcpnQW+lY1Q +WQJYlLjk/J2sUrkCq7z2yMKYRT0Q8vzFT4TIqLkk/FcxAhieFY1xTDIQGKVuayq6 +j2Dsv12nhtnl38fWoedtyLeSiaQ9bd9dIGkIYfz/Cfh8Uf1gCtTKD5GsX+rPeBA8 +8R3lqI8YD33mLs01mh643AH9bYuARgHUkESBbBl4rMiNNbH2TIgfKkoi9LahlKiY +OUdGhl+VSUkguSCdUR2zvHEEszy1d7HrHnd/P1ob1JgDIXZUqAZhy6n0yYCKQ6MP +mDY3tTmN7WWIKppfEV+GakGXdEVFW+l1FfgVm5TiGrH5F+qlbGMbtWT5JxsqDkRw +S6/dnc3LKnqyKrnUGMgbmQ6KYxIATeZ784cjsQRg5gQWx2aoFVK+G0CPtzBLovJE +4pGyVL6JAhwEEAEIAAYFAlUpkQcACgkQIU9HDI5LHigeQRAApGtgpwrxonIaH7TL +/3yW8njx3INJxlc/Vt/BYbK4GNqG89H2A4HAjaVsFvGW90AKZ2FwQiJinIVRqNZe +I89aerMROjFOxOowZuzXrpTCFXXF8KGF0H7Bc10JYisfuEsISRr3FTh34AFgZUSR +OrHD1859WwAhsnbn98U+W6IFYBHd9lTwIFGUXj1ppGdAUfnvIwPRyhCTkaPLPHXM +JWiYQNAXPaLp2ZUmsgUu7RwMZamODC3QH1OIrJZ4pfS+FBNi20nnj++l5DsUlxll +mon9APFInFRVeXkQDO5hiY0Qng2g9246AVdJ9DRE7RsZGah/x+EeWPX/LNwRVvx7 +lF8Ju3jN/rVvsse01NT9Rj0PKBA4E06ImSzaFwKXq0+KuCuTEZcEAyqR/LdzL653 +nGcM9nn0zQqcrvJgTGXzL5dd2pJD3sSVojlFiYWVhEAZv6OYmnNq8E0MW8BzhgCX +Vfq6JAH07gx5O/UDVtPk+YrTP+90bWSmDAbQHIC0uNgIfwXl55f/Dhi9Y0EOSCcY +77YRwkXbphJzy9J/YqBn84mAbX0rsIrbnQto7NevKLKFDbuMqnLBfeqT40ze0lbP +hVwVt+hyQNwVPH126kA1AI31ZG4DhCEbYMAGTQ3oZec7qs6hfd8wwd1K7PcbZr7L +t+qHoeHamcAU8IzcKGxDOMt8ZkmJAhwEEAEIAAYFAlV4YbQACgkQaEBE4hHFoKgB +9g//fycT79g/YhQiyXjy9vHF1fKNklB17cI79LpmXwG+mkzilhzBmUJEEUBM89aG +GRF9gQyVo9knO4Tqkn2W3FwWStJEpsWmKRnpS/sN30aev4ikOwh4Ch1UqyYKLXkQ +b20XU52lDuPFN5ET71FQR7IAq5Hq4/Jm4jgkHZjQ3kyoo5e0fprmJWt0g4eeHImh +e+KSLhjBtMbP5fcBSeh+gIhqx3OkQifQqtTZZdBTXLNz6OBf1ebmGIWrZ1hwn+dN +Cry7sZtzywufiUfqt5vEBkED70kj2u2e5LqwBm0zguz8vpUPD3YLRgZ5O2nEpUBG +5AhOlmBT6ItxFC1bxQFxELjI3zjlLVK1KmKf/03a4Gj1nPMgJyWU/jSI44dQ/OfU +05vpLtHa7XrPnV5Ln+sEaIVfxzpxmZmqPHzzcvZLhzAggW84IfNGwggUbbFmxIq/ +xOce4Zdd9gEgFaCmd3URNJ7s1Vxn91EW8ehtIetEAtBmAb5AVMCAxvVyzqsL9RaD +lANZ9WA4ku5LnPV+SUUTqGR/nrY0px/w6EgKm+Q00qFKpWogPcjxc8qHPwXzsTqK +1xyUhO5WmItviLlweQhKZOkItGgzfaRJKTxBrZUhFaRySzDPxwGJPDxooW47D8kk +QKY5oV3fKcetMdiiQcT8R09oqThK1m8dVGLKHd7ENqTHTZ2JAhwEEAEIAAYFAlWd +P4cACgkQgM58fgyq1JPI2g//ZsMEtpK96L1XKpGdlDEva/ptSYG5KL2vP5EXipt4 +J0aVz+vMHv9f0z8pbJ14DXwSE6FSwjcfxYe670oiL0ms4XUOcH5734gtuGc2uSyM +0Eo0al/a2bZ7DgjEDhc2mOroKugTNSCo2twcX4jE8omP78cuMhyituuvlSVeqekX +RmYdczKxwpZTWWmml+oUbDIA0+NETIhMT4n4X85aXoJCHm07WpxNUzJ5injkFExB +JTrZ6KaQ9tAb4yQxE2c7yhZApXPwJmXshJO6B0j0IoxlNueR/UmI14roKrDwn1jn +orns8jHSe9/NWZr2HLlArfWPyUc4//FYjcoArh62cKzfLYQpGRaIGcv+JvNS/01l +gqiZenlB44R31ZA0n7TtfsW9mqXsr6EaBbwZtS+BOZ7eoQ6YsS1Qbt5WzXB6inBq +TRXH7RZIxJyAeQsbPsqvsHPsfbssdbQes5afT3byuli3s549Mx5ldlt2MzGiY+jy +6Jp/AzAquiV2CPLjPTxA1gS/gKXWGy4CDCYBw3C+hRc5SnBG2zhToFxOzR5Lvaee +FFrd3CS4nzC9C8II29xP4WG76jeXIiBZl6ZaOKw7zMisIx3xZIJvrRqk3jAQHbQ8 +nY9/Nu0AKdd5iHKx3IHoNybn35/r2sHZTZqqIIwDZjOykyLQfegmL5okMQI16qO+ +qoWJAhwEEAEIAAYFAlWwzgUACgkQuY6AKrXIUtHBwg//RC2mWMuxBJBa34X0f7N/ +bvhutP1QNwYFC9X1bXyIleh72o8R4QFo5wKEXlb/Sf0tKn1Xml+UQ4S7g+FpVtCI +Rt2mwc+OoYZBpQy1ELhlVzH77tEX72rvOdA1UorxDsOgGAxyJxGLBuiAfBG7WgDQ +94AtOBOnexXQxQ5pzZT3K6dpgpXu/ZO7TbKDbCR1IKZmgJDjH0n/6AbqUmbGpWHi +uq+VNJ+515VcRfLKJW/WBff6lVRbb1ysUYkQQtUgMPE7ZVbSTjyuO7+k7O6/bOQh +C8tVhds9olm1I8x60jCR5mNI7CBccpZbs/J3jZ/G4MqstvwAE31uyXeT9luvd9b6 +Whg6DBhurTP4BMV86MWatDfxlcVY0LTX2k93vRyn8dEX1ye9AHeGEJKFb8y2pxpY +AjAuPzlpVRD44R0AvvgNrfV5Ap8ogcA6LI+3ftL1tYFm3WO+9nTLwlUxsleEGhYD +bXB5zpzGlkGi+wnod5GjfR09krM6mdm0Y3V4l12g/SIkqQGUgQR2Vkn/kd91ZsIV +JBP91XrdJRZL5ZQ7Z5oFo+FcafDiP9Rz3Wjd4I4Jvum4O7NoEilONB9InPS/uvDF +7J3vPMk9fjbf7HGmnSmBIK0SG3HrcksHkeneG54Wc9Ojnk071UOCI0Zj9K4Flc+s +E7STURNTGOpfahAkf8Mw1YmJAhwEEAEIAAYFAlW1qOoACgkQKeBHm5nIo5fqgxAA +iVV5vnxD1bFd+dMwkvoYOaaiHqqzpxcSumhreiE/lPjOkmf+Gxy+1/W21IVAeihg +0uqfLK7iKo8TgUFC0Kq5y5hUzj4kDxbf3o0fLUfYAx75Irn2C6GUuoOFs9kBfYbR +qvBiKhTyYgTOAmCkO+UpKf41O2tw0spxzGEBO5MANFx+4RGUGB6z7GEXqgoxD/U/ +OU25SPV0b9GoH66Mj/lxWjoyDc1EjvDhtt+5GtU7yUtV9wIskjiYXDrYDAODSrWu +UPNFDp2THjaQJj9o/R8iif451csP6V+6xPSoqsThsWnwWb2q6A3vH8RBCYerfqTj +RiOkmIkRdPUnpRRPmlxPRIEeZqnc0uRJtdxHjXkInQ5StyNMk9gdBE6Oww4cfU/n +z/o3Mf0FVCuQ2RLbLqxJbfo64BjbTUdJmvSRk/qFvqfLk2q4D0pUouelbcS50tCM +kiLP1LHJZcXzqTwChxfNWr8titlF6AMFCS8N5p81y78znbLA7URT4a8rJ83y1Ah0 +2fC8xZmTWs4qlX1Xa0HJDYY44UpQ5Gf2GAWik1HlSer/heuW9mJCeHH6m0IQqTux +FqXZlKRw1MV3A3QLBgNlL5LAESx5MqnwGb9E4IY3lZQ6bI5exD/gxY5PFF1nn2mv +jK71vcx2RNL17x0ASizKPCCd8JfwsIMrSsRAXnI5Hv+JAhwEEAEIAAYFAlXBwtYA +CgkQx7W17J5zg6H+phAAoo7Y1pj83rroZNZ6Ad5zJPCKh9dZ7KJ2lEKVslwqlMCE +NCY9kaPmesseeAr8LYJD0YOPFwT7Y6aCdlylHQ6b2sJteambtcNgPSPt7TC5pgd4 +NegEOd5AINaieek9WXOtmsEB0al2+Z0qVA4BOfxzJwKESKERuywi1zbPhtsUpNjN +tmEcd3aFNSXUxo8ZvBWUFHK6b5phbW6Indsdh5aqx0F+WJkJq3vDmql/4AlqjCZB +9NjnSPcIdYv/ZZilx9iBB70HHSC08wWKx9LfY4qhmVSdOaoIWa5Ix4/Ypp6X3Aql +i6Rg4v5AoHpn6xPguwoyX31jPvWexpytQ+F1mRlg0u1pocixzdD3DY3Tn45WkHfE +1rnIEQfDKFhl4w0ZIYpOwPRixJTdNt/6WSKz87/GXkLfsfe7LjfZSVz1h+yhOZ5F +sW4/97cldiPmZ2GCKx/wjiqC8BzXpdFybvDAYBUWUOnxdWswQFSDTqiN8QuDgNJ7 +IXr4p8sh5EuV3+PBKnteppN6yP8qjQ5+764YPZ/fIPsuSARodit6H8+RerJ4GMJV +fqaKxZCVy1TU8Owpy0hJkXUTKJZlTrW8IyBIC2JPsLXpuH+bSflrZ6Uk7nsmGN6c +rg1tVLRA/mLdaK2Vne2BUgqY/qOvHzWf0C/I7Ki5Lij3rw05cMBwrzaCc8psJRWJ +AhwEEAEIAAYFAlXBxbsACgkQx7W17J5zg6FbMBAApeDK42d/MYkv2v1I6QAxZuz/ +zwyexQiXydA6CMg7knEUFGK+yXIrJ4Bg7tumKk/7cyrUQ786wbpdmDUcZwLQqagd +OVGxvieGsDny2806zjmZSGOHmLAGVruFZ+JrV9nr0tWyrWx2LlXRCorK/8M9vR8C +4s5LkmldT5SC4CiicN0C1MllL5Cf8XRk9+ZyCKgy8cazv/w+oU+f5duswiK2vUqf +4LFMICVFRrkERo87q7MoP7O9SOcsWmak6brsk1TJnRrD/zUvGuIEPida+u9J4N31 +iuPOCXJyhzIJvY8CjwjVXzqEyfb88gnTS32hBH1z0m0QdljqIeqjljRXi2jSz1Jo +N9DPX2DPtevi0wRUEhGnwjkzMV4BjapcyIFHIkGC49OyzyEqkHfgqs0ou5ZBcoFS +fxzTmUflQtYWrgALegsZb+YYdT38H33aXEcgu3XRUZDmMOypuPqdJKEDK37gxjE5 +vXzRHLE8z9kbL9W29DPfST4/yZ7sO1IE8PwgHw2w+c+agfUNUGbur8A9etV+EnIK +8Nrppqhl50hjbpw6x6mvQmoqAIDWqYC7Fqu2iDm3Jwrr3AtLgRvAPVxHSY8QyGn7 +v/sbaEbNaRKW6KlmGY1IvcrNhpo+WEJRNyTL9jng2Eszih7lcIbxxYlzNVN7Dthe +XRshaxuQEsS/ISHCa4uJAhwEEAEIAAYFAlXcY7AACgkQm1FOwO/L8u1IUw/9Eq8l +1UvQCfErMo1dG2IH6109fxmC9XlIPmgItU/6KYX0FdLjc5NuAZAhOPws6LhEjsxV +lxE457Fnibt+tmbHAzKrHq2bx1NVpo1a162Y0nXWCcWObjm6p0o3iU5zY5JrGWYM +iBHs27zNLfC4zCodF6m9gNqCa8utDEC1iPBoVrG/q7w/zfGI71CWNX1y0nozdEDU +mTUJGBODbhD+8B6pZ7ufP9+lQBPtmkUIoIcS3hlto0rGNrMKiwo2+FJjQEsR+q4e +XH9zCojz8RMOvbAEUBEYHDl1c0YF1sS9ThDrD7dxItW11J+efC4XOimLr5PWYKW4 +lsDRuhf+zPIbyS0uWCu6Ayondib2gQ9bvMWwtBQE4/gq5W0OJXmOxjBWoR7rdHzx +TOESDQgfVrei+PgC2X4VUmBKP0Tr7t9PcRGBPIDl99sij9ZOxScX00fU43JXm4+U +Vj8LGDrDp3Y6kyHkLs+MDS82FWcfjwtmPkZf4kd/zz2vYvgnkbp5vKZqDI4BnmG7 +p9NM5BqpXV2F27ubH7U+QLc4V+0XOkeA/iRkgZ8/3A/p3xHUlkFcDq5Lp3OHSRvT +EDeIubKnDeCup4B8DDZsLhqEJBNEW6fAN7Sv3ex8I53GKNqpTYA3y4mmgViCsKPY +IRV4b90Zyo9/YJtu9ccCcj8T760zovVBEoz2LFSJAhwEEAEKAAYFAlSOs9IACgkQ +lDc6qUt8MiOWPxAAu7XAgRRbowGu0eoz/YuQATzQflGask4FkTm4NI1PrtUrKuvH +GUu78sHRsNbG/xNfDpRUPdd+DcVt0sWE/oWONLTsW1gE1wre/JUcP9jw4+3oguEB +likykXBi1gMRdcOt11D+yZm3+2r60ZueIgYa6z+rTt6p/r7ITkfD3rHY5EYgOAnD +hvb3gawgFYBfVqQLWiYYT6ok1FI9H3cbKuGkT5JVIsYLyuBq9C1RE4mJyzzZcG0C +LWozrY9GPkDBv/Wxs+1cYpGpxVU+iKlM5ETqD5kBLp4CvUl44EMGsZN5nMlua0sn +BEYw5ul2n2ZJLXKV9zQtx7mWgB6bj8+rGCP6JAlZ7dfObOLH2hnB5UE6muf6yFTp +1Jp5Q6L9tsw4BqceKSMKsYpFKvCft99oDCt90naVg63PAYYjAgu+az9Gxtm7HktC +eMUD7CR6c5hJWmmcr6YeByErHqweOaRChO28jh62dGkn10NE13t/MRFOP7Zh5Znw +Xl9jtB2MA6ec5KahlFvvbb7d+EB2GlvuRKDimqDM5pN0FV4AqWFWNRFERUpP+Uv2 +2TIe9ghGGe/lkq3wsU3I4wu2RfBCoLY+yJAuKlFMJXolMiIoAZwVv9bGe2Lgy65n +Cu3U4tgDLN2i8jO74Kf4OXjhtNXIujVxj44h6Z+2q4lGilu85SXmT81+gs2JAhwE +EAEKAAYFAlXYB0kACgkQx7W17J5zg6EbbQ//drAlh61P4dcBucHFe9nztXKPmGAf +mJKGgSnuAh1kiFEa2HDrwqs2NUt9GEGHGCkzjNT0EjFc4O/bCDreHNZtjrd4/0OX +gXjee6ah6O9WMFRzlISjAi2cDOCSq5MwIhXeQHu0WaxiCVJyvlhE+GpJaKwD5ro6 +stKBKBrQwEJWM+4HSTxZENvrhdQdBmCv3/xY0K1VD5aE3N0ih7Uv9QzU8E2qwvJa +JXroOF39STY3AiAfR0Zh16tk0TCUF48DI07YwCv9o1eeDOlfW6f8cSwHqnkj9TX7 +K1V6ptb6GLiH5zfWMt47OHj3Ley2o9W3LMo8SaieRu/l6aR6neOAZW0HrI6WdL36 +qr0+fM7Cd0bTuUiEVZ92azzsjtFLj42PMg7q4BXnucMnKJ1OVkk5YloZ09VPACFJ +rN/sQQF9vkaiHfEJ9FlB5gDplAY7Kpux5IkX0VMQqr5gTqJnKXkRbSJ2xziryLNM +Bdy4CkxcjZ9Vnr3qwVQNW2uTcn0W34uV8TF6bSupWSf+BNx+LyPnuT2P44AEDz4c +NpLbOZ4OE+RZCyzf4x92OCeZ955/Lv20A7sgFKp3Tu4YOZ4k4aIA2Vr+1NkvzXFa +7zdX0lfOTIrCJnrBwLyvPR/XXpZ8htjS14rIswP2iqtOxlJNTrEHJqUx4A5gma47 +tlz0aEMycqQU436JAhwEEgEIAAYFAlcnOKUACgkQahTKCduWrpOrSA/9GLgwCuQe +v+QhZ+4lIt/gJ/KLm5u9eYhfF/JJEdQTpOuB4Mk2nksw5Zp4+9l2H/8J7nHwqbMC +pMX+0AIZwACSYdg6rsC+ivRN/AoRdE9oJTwdmHdNZbmi9pg4oZa15c/I4DgLFCKY +MvQJPu2ssyEh8c6dsApKQ5DR36FKXGlONcHrNahgk2poQN7tPF+mYXTGMrJkFOPC +JJpanaL+kb+4qk63Lj3YS9oHHNVMKSyeByNmQ9sBLJ3DyVxCeJviW1IPrN0gURK8 +gFXJe/gc/yGrjIvl/siWX6/qrIZl5IvL9XNzI9uI7/k21rdlGOvMCRBqiQSvKB7o +LS/XCsWJoTYiI4dIulCiBoKSNgw02V6O32wGHQvCyx10/VfvKorqc86t4Rd++s/+ +mEGiXjeLbykGHvbwu3vI5AkfNfUoOAC+WU390aomHGIeEWDuFbzS/CaTGXpDoqj0 +qDq0wNYV5z6LNmZcaYQfpiLyaZUrgjqxqevMqGrgaDa2/fjaw0JVjlP33qFcwZnt +Dgzoif3l84VDanArNusryM0iYF49Ft52nV8aUA9RztDZY2HSiTzoytlvUU/ABNEf +ZGMkC0A0gchLldAXPe/oiE0GwqkqE9w4PwKlSgJJLsgJjJbCIbJiznLBVYTg2IkG +Myap6MGFLXtqCwwqRylSHcalCzA2CWVkxaKJAhwEEwEKAAYFAlbn7ggACgkQKVx0 +aYSvfwyRghAAkrxojYgskOsBYXf+gtwNrMvk7XLSFyT5lTGZRs8LGA3O+xVwKIWJ +5352AytTLwvyKVypdjMNJaIdm0LyiOGhvA1+T3DicL4gPTh1wSLsB6fQmEZPz7F5 ++SgEbjgmm9FL+zoHBkmIU9VanxOcurm0ChCzCFdfexYZOgwC64Rr3+bitpyxCjh7 +tNSBzoCOnv9ORj4qSrHuZ7Y/PWRB8Xmzix4kyqzIPyXWKGghLCcTuzFjIsobMwcL +Yinf9ofYyW6MeM7Qi6WYd9JWW8JTDtT8LX3mQkX5f6CLzGkvfN8obFEui2EJPljD +3u2zDGfont3KLcGInSmigBDlSxTWj7PImnmx534DY36OqX8D1v+ewib9lX4oXdfi +KTNk0nD0ZIDYNn8NwvAwxe1wqAdOPAwCOnFVAYW6w9JRYjxw0e4WF6tAho1lDZrd +vFx27wKvb4pfrbmix5ahrohT4ipOG/rKPNCEmQCTON4TA3K68GAbb4C1zW1CYR7U +uVyCt8DgBdQObs2knThoCf/FbG6i7UYWfHVnTNAGZkDGGLCJtI8I06cHVw+iY2hq +8HpgFIUXaGncfWKOwvMAZkMqYem3LOudatRP0byj0qtwG7lsSeZfy1moBliH8w/D +lX31tldGIpW+zQ0ELFR18codBgpq22Eja7lPJa3N3QGqp2vm8VlWWSOJAhwEEwEK +AAYFAlbn7jEACgkQCvYtwMnW8JDckhAA4h7xagVmmGXzrf6TC+XrCQfGeQQHDB2c +TWYdgIYyx1kfyjeCTtpfTGZ0ME1HQ3i4XwOq3LsxTcRmpYQzL1yVhhRFcv+n1dqs +plTtTpbCxj8Kh9zuZoAOC47Slh7ympDLuJTqCfJzXFniaFbPyF+9bRp1yH10JwhJ +5t5C20qrmcyQMt77dRf2aeFYX+GRqd2JyeHBGbkxyFspOPC9jZCHIVQvpwDsHhrV +5V9fVWhCgHbTEYbKGQlS9TAWdPCkCqMok+usnRSbvwXg9AyVx1jMRf8dNummurIT +3EUPPTeuIxiHM4U8KPfhMLtDl3fh011mggI3yD2cybnScRYfAmFWxC5jLDdi8FRC +ruNmoUSIbJzRCy1yXqwdAP0NIhFQlj34+hs0inp3/tA3xm+ap0rsoe1AbRcY3xq7 +0ggdO7H4O+mNXVihRRTSVKNbIzagiP1lCefyPlmzb8QDw/Mb51hDPWao2sjzBhXy +Yl79Fro1+rl2Lv08mWjhCdkPrn061BWWWYDLaFzdpUD2ph3ZRTnZUH2rzB//utM6 +UOMyDG6+GILWoAMsqdNPDZcvXXLSItu0j+nWpAl+6/CLmJuy9YwggoxhSyBpCoFQ +3J0OiY1Ed4HY484O0UZhOb/8GVFiR46GMlPFstHRc7ZOnc1VQwB4AAT2nzm+WAPy +H0oYn1MCTziJAh8EEAEKAAkFAlUFkpkCBwAACgkQV02MpYueRGlNKA//Q+2M9igs +EMdOZ64CWtwDEj4MNk3WrgjdYxVthqF0c0YSz6kZtUpVRNfJqF5KaWFZDkb0CREI +9H/is+vYcANN+rh4G2Nhj+nm9VZ37qxnSXZQCX4fB5pRYQdK+wPjBtDRSyJ7Mxre +BLZkByqi7f0bpZ1YtCnRmZgziVhN5eP2tfpDK7GjGLRbOhoRxN4B1rumQU+wEZ7u +NXfFXrV45Kh5hKCTbtybQCF7K4ZcKhv3MpR9kB1bvYnCjomtRcZGjWl9H7Uuo/Gd +UvlnnHR6/ES45l7MKt8puxZOeERjkcIX8oe/0NU4XNVv5jk0iQh50oK7gJ8eyW7S +1L30rUFmr/cDhrVHcGWNZ86ib8a3h5/sFjrk11mOnaMJrNr0WHmxTSR+aAtbdJHL +48tMZy0T1U3XIoR0lEZ7Uof4NPvj7jTkm/eEwPQ+JnEN13w5uQcw8C8wqfhT0A1R +/SLVuiRQw+ZOwkGCGtsPe9DhbQazg7286AK7Smg0TFsFCxeML4cgEkZQVg4g3wjv +3GvBXWg7R/Q7SEIJuZAzqvRaZaMTIcjRY7x7HCjErD12SQnP8B7dMs6pEyC7tcR/ +Dm93dPpT67R4oXuRsjZaOm9sgEVt8r6kLsWFqvUaY39kGRjjV/A0I7XC1vF3xBn6 +mjjhl+D7+ZNcCAAqv6RkfBJwO474o+leUAeJAiIEEAEKAAwFAlTuAD4FgwPFCgAA +CgkQq98KBV5P0v7S3RAAsSMgIMWxhXm2BwhXwgy7NGv+oRsGgt0dX4bBynTIWoJm +1OM98x0kdC4z0IMFC4ibE36nkGLREo/7XFNWYjxB98DGYqMXuDT1WvtAPJNilLln +A+PnVq0hBK/PZYza0hpmAJP4F+ZNI3G/E9W/EJanhkjzjjBwuYA7mJ8/tE7pnOh0 +d0+XWWVMcPraXWcCs3GhOd8Pro3yQsKsNLtxvO4hE+RJVw73xheXDC1bK1YL79Se +SlAirBaWOdKdF6IX0GJKo0kWXa3zCcQZ/OtR3AhDMceBsGLNCP2UcGQig4w+Ky+Z +sghKOi8Hsua5jAMSIi9aPr1Bap2H0op9zPElhktUQgeyZbOcQN+WqNsShfwIZUZq +rcr38al4ZoPZ5v0b+ztihcLHvPG0wqJgmu05pG4OsXQjU9WR/4ecH8eZvy5pWhDc ++N+3d280JH/JOgBw7/7JZ8RfFg/9811zvqqH1cqf6sZSloPHSIq4MtIw/IOhxgsq +/RPsfIbZShNsMXCFlk3ZyAErs5aiUTBVQN14TD5m6UmSSLi5x32bXZ7uKi5Mg26U +UEDkYPGk2mFCInEQU3SqjA/ifjBYudMcbGcOmDExd73FxOHD6Kjy12XZkMStj7II +teEyZnNvyLEcRPX0K5JTjebAJM2EDQcjpVLqz9y9+DJZhqBJ+gs0G0n+rN7BT6iJ +AiIEEQEIAAwFAldtilsFgwPCZwAACgkQZqth2wp80XIo/Q/+KSmZMYuE+W6orS7v +0G9KKNhnWto+Zn7HApAxG3TSUMJXBU4rWqrNeJFdjFX3IMQq/GxAfOdllygW/Vnk +JdwXGd9upVzCeWhHolJHGnanCbDCh3a+IaLKJSLdxVgWxa84FF5gVZDqUoyiRipV +lEEKw3dKaIFr3D8B4ArA3id71f1j4uAl9JsAAIRIKti9HW9XtgYSkktd0ObEGA5D +Inm4Xe6HA7hoDH0d6jM1+w1F3Pv3CEDIh4b/4v5O6SjcU0a1AMcb4ZwRsoOv+lal +SKYzAmrC1AWwAYFxZkXOMGXyNMxIV5W8r9cRPZcggi5UdClR0D08fWoh04XjaE3o +HTAS+85lFnRNfIBoxUbdNhbEaswMuM9oQCB1VCXy2tk4kO2H9euAVAJmzIAIGI1w +3bm4EsURuDGJhQbA2Atm7MMwX+vbaF7+U/SlEj3GCe5lcpgWbZ6BSahqZRKQzAC3 +77FSQzZ/gtPXj7NOva+VG1qkaB5G3ts2ag4t3eFZGsEYIVJBxi4mzlpQVZhS5ka3 ++HMyMbkH6NkZHYVQIoFk/lisw4D3i1H2axo9fNs+Btf1arIgigdA94X3b2zjwQH1 +iXCqFRFMUPPTMq7DWEasNlWOCY6UtJfeamEhVdW2E7CENUy26LSiUzvxC6FUuXGj +L8KITIMaNyHrjsXzSao6+tu6v/OJAiIEEgEKAAwFAldANiYFgweGH4AACgkQprwB +wV1+3anfcA/+LqA1XAKGrVJUP+h02/khUw95o6VrSrup/9UobjK50MRBqp/+++Af +fRcQOosiU8qEbzEGXLt2qpXrSv5eeMowo9iKA5T5Op8raNrnO4isCOLL4NrPqWuB +SGFrcs0QVPx7Yfd3ko8pL9CMncYRHrvdvZXg6ueH1ubm+rayP9DwtijeEVDW0WSl +T57wANFvVvuKdLUflVD4NAg24Ys3+cbMyrv8RNSR81LxKwKtS5xNAB6lGjdMxg4K +70A7febE+lHy8lb/JcItRtmnZs90EYZ2D3i8pmbmM0OId9yCuBFR+r2vIhQdrlwB +abuJt8BR/lYKd4H9EUNKlA0TsSc/MlvaPCO/PqRamioSE+vUpfyCG1ED6cLV8wZw +sAKY5XcEHaUQByIIH/j/tRxGpZ6Fb8ZobmUvbLNwIfPJ8VFmOCUe9pAEsZx1R78K +hPmwhedd44igeZMfOJxVf4Ag75SacdkI/ug3m8V3QZ4+uG9qaW73EUmI8SyKTHKQ +0xy75aqIvkMvrI3dmg0FxaWg+RL1bz+ia97Lymxo/+finnSf3KpUduh6AxarodcE +hB32qH31QRb1i+A5I7mVe8xcc7ssM0S/65G+gZeRuImH2ygEJUvMKISlLqzZaWtu +BUKW8Fqn8kA/rHL10eAN3ADqSjXNsAPXBBsInQkO+jAxsrl9mtNbq+mJAjcEEwEK +ACEFAlSOr7oCGwEFCwkIBwMFFQoJCAsFFgIDAQACHgECF4AACgkQTixuh5MpgpCw +FQ/+M9usccajUbed0/4xrKh+93U80/2r33lLM0WoeATdNYdS3dDgzR9IxX+LI5nd +BYKXPG+zrgtxaf0NhEk/v2m0c4umkJgDjGfxLAx2mYwYRCrKI52isjK+wCZXw3oE +lcSjOLNECb1ZsqZ0HyqSlxvdlw4f0vtyv2ZdtozMWd/Ks+k9gAck3GhePLzElX9M +V9BocbuY1EY8EV9Hs82/UsCRVHXjxLHbUr2bjKKSiMdM+knlHRB7/MuPgiBziWql +U2NovTmzy4PLh7iRfM4yeVmIXtVB4jDEmxrGIRqDBBF6YBdBPY0TAI7DBPXWQt3I +FPQy2YuahLWBCIfsUQuXVdvy+5bkj8cGj/dILqE5QhUt+BI22pycTgn0M9/Oz3VS +UNJaVCB37rsJE345Au4mRoDjqHyQ31nONXHDbcQhIHw6rg+IS07O2T6AZIocSZR+ +5MBD6AdjQqKZZYqFoAHvDL7DTtBNsCR3t7x+TM57JimUn5/E6FvATWqBtT+XCZJf +rYzqopENr1rtUt8bK3LltoIyKMF0SIvF35LlhNr7A/QiJr2s0qv6cDTmuPQ/8vD2 +1Jj3mU1/2yIeocdY+lZ7ORRrHgLTgai/KQl+tgwfYQA6DzvA5B5RNgEanTsl10J3 +YeFSy6039foIxTEZg9oVwB1mvkfPRNlVUzyhZg83/q4Gx6mJAj0EEwEKACcCGwEF +CwkIBwMFFQoJCAsFFgIDAQACHgECF4AFAlXdokUFCQq09AMACgkQTixuh5MpgpAB +ExAAtDhyC2qUAv21Sh82raT8ypZpRf+wAaKlko+kcq9IFSBuaHA+weupcPwHErb+ +nO9wKSjjxweBHrSW6Y1mXZiHvaPc/xrNV+Y3EDB+NcvxCD7rYNGDvD6MSkUyaS6h +XuEg3euELF06cGDq0/tXdW/HBFisSDtTmr4kDMfxrSagvfxOUyslyQDQ6yHopJ2n +mVOLCdAxi/WOYwAbMiSjqPkjXQVDESik+VNn4xavZhl45NnTbcaO50Dp/5lOdEwN +X8gwVXFZ0NWyEWIGvMjlkHIxKMn514gG0Vtjfqa9DEVgb2799nxGRiOculqHbdPa +oH+ZZ04fO3zu9SpwDepqM3oeR0MIM2LlOOI6rp49ydb0ZY/2VbAMH5pw7lWukVB3 +h+4si1YUYKXhHg/MC4cptrMS8TVFE5W4dN3X4Gm0RhCRbg0eZ1lOHJLhtLAE2ZTw +hiLvok/fTYTgkkF5bBscDqKVZMQyJoYini4mZheF0OcTNSqDvZ54kc/D1paBveNB +ncASRAWQmUWniUWdOkdwVZSTzJ5SWMzS5XWgu69rH/xXnwM4xI334NUF2dvomkuW +4h3agf0Fju8x1j9/YR0DKwk98/830+DSxZQnvM1+IcBBbqGdZm4IGkm5WC+RR5b8 +e+/0xSY2C0a+J6xwy1lRTYoVEZ5TgA8STwKOok3lP6pLLMqJAkoEEgEKADQFAlYZ +CWAFgwWjmoAnGmdpdDovL2dpdGh1Yi5jb20vaW5maW5pdHkwL3B1YmtleXMuZ2l0 +AAoJEBMY76xfu9vO6cAP/jFXHWEyPQoEWLgNxOZ/oI5Br7UUFbs+MpJkFb2tLh+K +fJybu35xNi8vPFt5FXmdyE0xJNNPLMGbqQ8/kh8BFsSejRN84qREbXHhp5B2e2rg +6RN62sWaMTYKHsiSW+Z7GxoFYixw1r43FA2JGNPj+4TuE/FvW83KCTzHsRZGyNOK +KzhWAWgEJjiqtzVg5dXd7dmCWQ+on1/5npw3+zErythQqv+3vaaRDACAEreHlaRu +aAY+kYuSMkr6F4eMW6Zt78LC3ZxfB2okOmdqI7+zQj82Zj3OAshi/6vS7po3slcu +EVjeMhzaF8Gt6Lyxe/KZW+Vf2AB/FzRMibLepZV+v8uOwrpoeLufrscqoZrkmjc0 +0iUeQbfGnwUhvCH8P1+D5HE0JBOsdF06JOrewFocaMNg1TuAqmrkjUMSwL5tjQPe +jOHCeg8BK2ULAOq3bB+E0lQ3L7Sc985tGL1jQpgSYLdNw1IncjJCgHBEKDybO4CF +o9V37An5jejG77gxNX0K81ErDIJw6oeLpicQjR3B363tXNDzhHBBmyjzafimsB2p +E6cajMz3x+bUzSL3X7yGcAyWVkPIEir34u+z2+jfwfnK1XX2TjFlXLo7BtM4dyoo +eB5CM0s5nHjfoDkDeazxd5lKkCPeJMbG88EZcC30/FJSOhtEpvnG5Lm3ZhV+254b +iQEcBBABCAAGBQJX49vAAAoJEEtEVOI5SB2W7A4H/3kiksXnIL+TgCNL1Qd2S7eO +cwKFOzwxFgt5ibUA0MxdPxhF1EJ5Zo9payBfKXFibYgCa6+PlB9TcsfuoBDjIkkh +jMKyZZPrZ2drgFM7ASnQRMQUF57dY6zl+CHXFpVlT8orTXqZ7HUI4hw8458sHW6y +fjcQl4wWHvmB+SEMON6XmE0w+KUMnjbZiQ+fsnWTctaAmfeX/gsC7xIcKVfxpDR7 +Syn/jYbsW/VInp0RtoBkW7bD8aVF0V7hAHt0BbLP+aaZDgDvA4EPdXM89B3zOfFJ +pB5dZ3fc7kBC9B0MX1YDVNTLTaeudv2m/wpXJmxbF0JuR0AXawNPDkVNUqpfn8+J +ARwEEAEIAAYFAlf7QxUACgkQo/9aebCRiCSZAAgAlswIBoZXfZEIqhGp8rT5G3uO +jr1XTRfxdzkLF2PkRX3gzLzFLuVvPp5I553F0XxN7GBKHsB34/GGVB43YSYQINn+ +M7cqyXbcszZRl/RXtWd9LvvcFk3gmiufa78q/5TdFjCJw6rFYberV/dU5RhaNL0Y +rYxENTYH4esQdtOiy9C8WUMxcZvkgBlCoXGhpotV/gjK1Xrjx+bhCYZMnm+RJM9T +5R0LvN6nPDPB+ah/L5L3mpuynxt4TnAe+EBixI2CfMQgi3Mdl1KjfQ084N7fbDwQ +hSXwvXEA37bafDSbuYBCFrzbOYganRplNSQHjPiWWjQMjzl0WIuCqAy0u8t1gokB +HAQQAQgABgUCWCjv6QAKCRABFQplW72BAlMCB/9VrmooiboSZiDwS2A0ik9ImbVQ +oVoDVGWehEUGSiF3spDFcKvFnOpPKr1oFb+IB1E9gsv/EW628uSL2c3lDBvcBoxC +a7GzFs/zEgNG/ddLg/Qu7mT8ZqWGQD5UcxldXdB4P+lliAE04eas5C1wRZ39Oou0 +Uk6x90NkilPproN4oFMaiRj/sFRFCVj5L7f4r83bXIS+ooNOTbEXSBIgFFnMex0M +X+8/dimIFbeDY0b41QGdeYgUsYLbsUOHUBe0hk2Nb3Qb5dQCLVOzi07eawqmVS5X +vVsjNw7gwZnSaox/KiL4eetPrGxPgQBpjBDJ8nHpeAZSrffrCamY4Dg7ORxMiQEc +BBABCAAGBQJYRQwiAAoJEBZQX7ST05Z9304H/0SHndrVnGgQUIsrF6VHaX+Aaq4d +wVWEhq+S7NDQIAco2tdEx+1qUrp8VqDFppH6QO2dsepOJivxXLBEm++6Choy9Vhq +Ay6dfgkkw6nNjP/SLySVt1NUKv6mY1q5uKczkRTBJTXbAQo1doZPJklsoJWtklWY +wDkCVq0AMQr0fWAE5wH2G3B+ON8LSgjcSB6fVCGomFJi1t6yThchwDoByx+jKKsE +ukeP3nJ2scZZ6gCtORDWaGJkYH7q6aR1Yld0xB9KDCyM57nId1ruqq9gruEfWNse +mTWjTpUTu9QNd0+yF+BSqT2pGZiUSx1MkmOLKwIdgZUFPI9iBIGCfsyOCaqJARwE +EAEIAAYFAliB5u8ACgkQYetqaVZWutRCMggAoqrk/5/1i3PaZWTpPGtA+65o59eM +xCz7Th8ss0LwkgDCvtmfemq7ShOnh1VXDMCbybcAwDqtVKMg1C/am3YMlVmwTLxc +XwSpxDI9siP9mGb5pEBgmc7vOA/04Djg4HCvB76J91HBj/fPvwwXU3hGWQGN9Cjd +W2Wk5J205FknIM8l3biLxd6HBtxFRcQ6wzRn91hLe0PT3vEqttMNUfuMxG+wwn33 +R6s/X5VWmVa+67jFGON5l9IMonNCEyUZSO84GJ8JpWwlNVTOw/44yD6Ej8TAEudP +44C7fgUeEEmkxzcAVO+Hbo0IO8WwxRel4qb+vX3l+IpGK8suOa4b5Yh1NYkBHAQQ +AQgABgUCWLsz2wAKCRAHBDBue5t8XPShCACHITFHbaola9eoo2+0up+mzSo2b38G +fnXQUJ8AS5iwxui8ahd5zArrCoQxnya/mOiOvgMFWSVisyQMiayvJUtg6qH7u48w +oVmqkgDcZq2EHHs1QnqDXrK9TUV+Tz/vEsjT51fJHecgyQEbIqGsekUgtlECMIog +Pga8FICQpF7pFWjx2fgnIujPkk+PrcqZENDZsyyih+hDR7X/cWjr4dN37exXwAWS +9Ge7FhlvIuydG1QCmw+Gu2Jb5FagrJK4IghfWUrfekrNVLPw68DvmwSBacelHB2M +/KCwh8eP4SdSiFejmHDDnkbzKNr4ruso4p0OGiKh0GCPsMROQZUo2pEGiQEcBBAB +CAAGBQJYwvUIAAoJECWkaE37RwvuKmsH/jsqGnbh3a255VGPH/s72LfkJ93OYoH7 +JZLTDafxpECpEF2TYKdaFVnIrHXzV04UKVyuNHeRlF3mvw1+ZrxhYcpWvh6x/pBG +I7L14NVH2HYVCRLhkM2u5h/TzMNpGVbEjvaTlvCM+McOIQzH7tRltDo28W0fP1rA +a4mOv7Osq2PcDHaTrJ+g/lOpKFQp3uEv4GVL7Mi1F16+HqzadEs7aHauj/6a5t93 +QUYhYICYWrwzjXuXIK84G7LTLiKiDs4vwOlwbQqbeE5/k+qh87PogCrbqzftozON +eakPDf8xLQYEgR5i21riOfGxNKQ+TMZZNKW/WtRHLccbAhgsGFNyytaJARwEEAEI +AAYFAlj8OfsACgkQGMujHt3lFlddjAf/ecv3tOkjaua0Mwk8iQ+FEJhsHEiINeII +qPF46us1bszyvcIHpuzETzXGVC29P8Noc6empB4R4jqvoi9sceE9Lv+X32hHveCN +7iGsML9V6uRKQyzm32sDW3xM7HedQXu70W7NEd+wrXBL8lpnnAJwyIeUIeo1g47h +HENo53QE+9Vy4frENexqU3ukjvWF9OQMyW7etF0BM/QytC+4qe9kmgxkHEf5sry2 +7IqgufrULy6Ie1fQC0/wzgMTVFOta5TsD0Aur3w9xZkvm69TFkFz2X9GeXsGQv5i +uqBC0sJ2vV9B+AkgavFszlE6YfEDSewbMXOPSLBba7RlF/mRz/0POIkBHAQQAQgA +BgUCWQPYbgAKCRDRHg0nTp0kyHJMB/97x44lq6n1nMrnfgzDEK00IksCUvD/tIgs +JGgQZJG7DgUjZ2fSjYylQHwIzCPz9MHuqNl/H1MvbDuNp96lIEn6zJ5q8Z+HLEHj +Wch/yzdDiYcbdnL3y2ifGozB9KTQUSRRwQxC7Tr5BC3G2dNR/xmD+fEHaKZIpkNA +cannPjTboub7jsrZSXThtKdbkMiw0a5XTt8JVwFlMHxYtix8s6CsqPADgXUqerra +JRNjvaiZ/JBJCD4mcBwzZyyTe2RRmMOj/iUda/VsWrGPNVUGlzTQHTh+InEKyA7F +KFKvYeiADVXBaL47meJapCEjyq8g/KD1GVYaHlRLzQaWSyArWzUEiQEcBBABCAAG +BQJZTKdKAAoJED02/IRpRG4F8XUIAI7bRK70TUk6QtgSAgJBQLXHvmpFMAWf38KK +NzbGjZDXu+q0fe5WmQ5klO3Qr+8QW+xRNL+ATScNgHtUZ3Ke7JYQ7MuiaF9+mbUE +3yqkGb7ROBAc/A6lUVF7lSVHT/XYI1jxQSiVo4ZhwCkjxtUbIktS0+o/iHesI+kU +zbywFNx3n4KlCDBrtQkAIhttpm/biUADtD50OY15V4zklPxcyMUxfbsmZVanD0gb +CktDvPnr3u+XbkyjI2A8y4Z7MKJJpbTofxAvcmgShuiNVuNmxyoLTKJRPCMplwba +UK/umVMrv+v7cHCUFv8TAEmWZP00tU9D0AIVATtTEQAPQtsDKCuJARwEEAEIAAYF +AlmJTPkACgkQW25sF6M8yg/qpQgA0D2PIrFjmsgRfb8p6UcFHu3LWhnQVcBIzBa1 +1AxA0RQfdkByNm9v1n4lqHc3rH9Oco9vZ3vtWUVbJFyrB6ZVQeq2t6OnbV5AzwJa +gn5OxKJvLUzp7H68ihcXs6YX1D0rjDfQpQBWHEZWUwMpMuSMio1OihZ9o2JliZAb +Oer5itO1kH7YpyJWA+fIzcMLKIgK6s0Ou32xKh957TW2E9/PV+LxO/RkEoAVN5zt +tRD6ACv8La7X9OLbFU70dfhm0iF6f3TwVbK/cBrHBSWyPvqk/e+z9NmMR/ILNiAJ +Q1HDeVwJwaHy/MQ4J3P+80rohHclDv/Ob15UHcXnHzNhQg0TPokBHAQQAQoABgUC +WCuChQAKCRCKv3Mw1+xAKIC0CACXgDAVmpF/UtpQYqy3JWp8wS2LCLYC9a/ntjxm +c0m8eh+uqsCLV01JcL3pCA+zAflmY0SY2TnZ0xSWGeSVjNdhwKGL+JAIRLb7lZwB +W50NetqOO2g9HCSpse5l17csBLGAao2V6WLiuiJ64CrpXQ7zgr0kESNX4+zJ1NO6 +x9l86Aoo595ayjXmmVFqL9RV3Iyg09+Qtt6LVL43vOoFrOsV/P7F1qkeeVMjYyoQ +mE+8ngRpe2mpHQfWxXfewhtsjrMf4ZAhLN82N/WmmaNd9kmUkplgpAfWEGLZ26tc +3mpQuyKT4y//7pCxH9WqJMA09RIGboF7x1aDjgwXVXsEWrUMiQIcBBABAgAGBQJX +xJuZAAoJEIdFGO2nWCJ8K60P/3KFcrmTAZ6+rxPVGbrEVu0p5+MwbQbDo0iz3XXh +edvOpsnu33yw3H9+veZSuRDczs62c5bxbaJod9/BhdxxtchPl0v3RRzXWuKmcxwV +7XN1K3TJm4iL1Ajb989+Mx6MxesFkXF7f7sDNVUH45AnPwsHQOuMJqU+40n4WdC1 +z/llOMyvHKzBvM4aCrsEgByWuitwo+lJw93aSVl2iL6KlwTuN515kXNPlh2Iztcp +mkGqHeLhf9yN1xLzEF4uTFu/7gLi2gJwFDhWqd/agZWqq3mFWtMVGzWkeaUxblEh +eGf3CMrY+EsnrYuyIGeVc8eAqUSWleSlL/M0gLaYQdozcNipS9r7i4PcjIjJ7S2V +elyceR049gWE2U90FH86nwHBS34OP/6i9sVsIUf3g4QkqpYavKg1YbWzqKDFVlh/ +/N8EyyCeWMzq5pGA2Tlsif3nGugc6PPz/GyfOGLdBCmNdgC4yDrdzgMe/4bGFv0R +9/O+d6H/nCziJpn4r8K+UKw1Va1/efOvlXTE6ZmnvbCsNjf7/8J3HoC0VhURNmqA +cvyAAsMEcEdETHJaQcWsAKy0c3g9m31JWTaTR6+xWMYnMV2kR/hrCxwu+D0h3Qel +Zpremdm8X7A5UlsHhdndvBdApaElAgz3Co2xkWp6N30Ke7U/ZHGjXk55+oLC3arG +c/tPiQIcBBABAgAGBQJZWl3sAAoJED/OWzQRPUtLhbUP/iIioWrReCLiz6CD3h6t +6Zr0+frcMQR4WRnyoF8hG6DmMZxmQKXAaPoj4+bek6VT3zOl6N6TWlYGz9W1ah1i +V0ZBGXaQgp66y1tV4nZEqNEFlKfCZplZfhO+GELwOQOArcLJRR8S45CY8vRAaSzl +LJLapqZT7+tw8H20lEZTPJzHYXnbyPkq+OjbtQqYlW37OkaHPH3sNdT93M+PcgdV +gfW/gW4YKUazDwBX/FDs4IKL+ni4K35J4NNxjuBiVwapHMUSAC0O3Y1B4hUhz+M5 +HSrj8K7+GwBNTX4Q9LGanWb6EkV5cEA2yZ3ONY0OUgXBmHHm6AKxX6vMt8uWpOyF +odgQeuJaa3SI/Iu3G204KejoQyTPYruKynKxebctKyogbhQ/bcrf7Bwuaajpdqc6 +AzGhq0WAqZruuDPpBgKRR9riUq8wZmdns6LGoPH5f+GeGmDgOWDp2RfeotqCniWp +fQcp3n/JVDY93G7T+/d8Tr5CMIqZ1wA+nL4bbkyMmWbSMwQDxzTfUmI9ZvwiK1cv +6L0jSVs80HppZ91VQKbahRbxJJOpPOOTWssOM+lV30SL8cmVUVdb6qu8jsMxcFco +DkQ/UV/OVsXJPiYqYOWLSvJS5NrMV5zZHJC8xkEwtVsZNTiCCM1DZOmFLk+r0FKB +3yJ0q1SYRDgYQIinEBObgHRjiQIcBBABCAAGBQJX+0LFAAoJEAJ4If97HP7G0k8P +/i3k3+hXDVIBump8YPZwrnalWH0SSSGZFGXGQ7XpMWstnJJPk+4nDsUwHNjAXKC/ +/Odx3MlW2Wf4NdoNa26Kvypejw1rWZi/vIbWiosfFMhhh+D8yG7Ec+e2ykEvSe06 +3zahDRbviCyMo5qvaQwcqrIB9nAZFdPCpSJTFt4j1DuVoyiuCspeac8ktaprod48 +nZQLqP6afK9zOY8UXpDTfuvzT7OSV3S8kcRqJqaz+BJv6nKMWEUXl+Vnlq+Fj53d +AJ0jGgrbmjv/vdqeioDARz+MAeEba1j7GB2/TqgJw9bt7NLqdoo9kZ3zVZDwEBLy +2o30nMnrJkAeQQxd/O6o7VV/JWg+bcoChVPHjwc80xfo+BUhBP5cKWN4v5ikaoub +z7Vro/GF8jASWXJ1QAakeik+SZFmrR31ZIWvVRz6i2eKNxtJ6fh9ZUQc127jGh84 +or1/pJ+GvpMZcrOOED1AgODK+XahePQXJfGC/ndDUJX9LBYfr42Jgap0yukmXUkB +AC0BczAQ03Zwu2YLuYNP0UrF95S+I1y41K+gr01FGF0LEccRUNhI8mqvUmYEu058 +J4ZA+HrZPo5WJdMIaFpzpD3ZHfFsrUOyIFXBsnQMnhSvzQkYLWENREvL0/0WNEHb +PXH/6XkammdZQ/+eo/lt+lDpwG7zZNpXNuLSHV7SgAIXiQIcBBABCAAGBQJYB+Wu +AAoJEIsEzw11u343HsgP/2GjG1f1CJ9of3EAdQ4lpN25RLR2yrEcWlEAfSggkOct +veIZijFxhierWOJ5VRj337r9A1bZkB+yeEEOZYHwbsPIK9fYImlovc5MEnopXwzm +ny1TUUVkq24J4UiaEHvI0ST9nFRp7yzQoMFDGveftJcNWxrnYd2ejFv+wKMQc3/+ +5IUfp7YE0sl/eMN1mHD9NjM9g3svJjJofZCEiGTIOeh1TAXE8q0FeYAlYmeGWpyH +Pu5cIgJZl55nwiwTEqpowQ+xL9r/Vl7XmPvdR53e+zlx34Xc5VbFmxRrmbVEN/87 +rpA7atfoJ3U3XIVo9u7cQGriQqpNH9wrzRITBsMyuDdnD1lXPFP6dn2cgO8egJAF +ukGNz6gJdvXwrJPAPoYCa6o9LyWSoyXeBArOhxrh/x6CH5spAjNM2zjJztlHp/+9 +C+YHPWz1f1VozeRC+6H6UCEeSd56u1sCXENr9Iv+gNXfcdhiMCyQ2eGmN1agyRFl +2Py37IEBf9UnykSsSwja5hBjlDPhZrvqkhXwbDlkQhQp3FlqvGF7Ffi9yJEGUebQ +MKK0W993lnXw1muo4OEl5KjXfqCcP+DD2X7pITK3KmzrfgITMSj6X/1KclYUAore +c/H9Qy6Try+rn0eETwgTZzA0cQIzMLtm1TcVG9uIXI4sHlChGCmyfM5rXUit4qPm +iQIcBBABCAAGBQJYRoCvAAoJENUv47V+fXxVJ04P/2OJmctB+v/eEUsHI7CmvDOI +4aMGfoaNcdCIhvJM03mc6y3fc1eJPf0xmf6kAffgopJdremFCBOTmFzYZhDpq85H +rOcWx776mNmuR6oMO7hJQLgzvsD6CR69Roonkt3GMrlHV10ULaEdyXpnNV9iamrx +013saJAAstYHZwg1bo3twSByvZuUVyzUgWT7FhjAGITYBMOowfJJ2cleN0MBf13R +IVtAJG0JO8ucSU1NFJeeRzcTk7JDoHROpr2MvlKSMUtSenjSierMzOTe4qyUvCQ3 +0SZP1SVbJfvAEro+NUdU3/21Dny84y6x/h57x45BRbd5JWHT+ipfr/6+pM2HQoDd +a4S53FRUoA4U1lpj0r/FYPjhGozGyuk4B9tx2q+lm3Qzvfv/nQuezeWHFWSq9hiM +woZ8kDDGsCQ5O9QnIDOH/ncdv9s57b630PUqIH/oRTA/jiig4CwbMcc7sL01GKOU +LI8M0OZH0UQpdDXq012ICdfgQpUSq5GY56o6dHnjwxRazsKLEekQlf0YrhfUnVc6 +HfoiamwL9XPHfhl0sBmg17nncMMTkN4j2Q0drP0pT4zMQgmt9pEX720J4f0iLoTy +mws38ok8Ya7oVm5waDXnhi5u+mgTepgOwfHmQpfgH7egOMtsbByhL1xQmPgrT03N +HAHZ8tig3dmQGhnaI1ssiQIcBBABCAAGBQJYtsMBAAoJEGKrbC2pNmtMiFwP/2qQ +S3QkCiHltKD7JJWMosQrhxJ0Kqyurm3G/EJxKFzLGOfwJ0Hyw6gmH08QBaWMWlsE +CP7iC0mBQcLAzWSyWzsYzkDaXf4UtSDR2tWSDFdIhAB4oz6xq/hhDmBZJuSKb6VR +nHuOyL9c6Tf7TX4ZSaNe8eTDKYKbzcyKONSYoSNVhGvfzusnlXxJe0nT8KikYz3I +qJsSkWnNeb7eFzgkk4NSwvD8YGDst+AA9ldiPu1Mn2qvK5xfVelZ4xc1Fus89SNx +lu1ollBA2d8gnvfF2OnPB24A509TOAzphfPVecbB/leHPSng3CWwgPxgXE/nY+JT +YV8SC36DvcnfHNFofHyz7+HGplXbx2Gjz0cl57gu5k0lYbpjIGx6yZOpFzfRovJd +VGG9lJogSMqbCghZXDYRr9p0X5KFpMxBH4bZYihpTUYqMD/hLVp5MoGWSWvvLT8N +bCoCPBZOkXHBjQYTzrJdnc93HK1SpG26WNUzdPQ6LOTW7gcR90llaZ1bJN3y7AVf +X0ajNAFuMtJ6DSHDGAwV8eAWte3DAylcZMaMzRTzBMaLAWUAhPArlUu/q/x5wM8d +rvOJx6lck9NGea7TuBO8laKRiPMh+lws3eIxsW/1F6HBp0WhhbqbQFAE6OUJc4Gd +/OshRBaRzE1xdWaSDoS/LBNTRbVU3ZB/XNB0cAIPiQIcBBABCAAGBQJY1pTtAAoJ +EMwGdOAxj7UExk4P/jV+gbVX8vs1XvOtzLOzIVaRsy4tDgbSOTNObipdWnaiauWk +BOJg6zIAekwQwUre5RaisC7zviPA6dcgp7SYQrBiIs3J6fAyHOFd1rq/LLpPPj+4 +3VH0jtbJQYTXNE5bHQrWIz23gIH913lxBNIswFZpMciIQEilPIiHoMJk5FkvD8un +/1xbYNafVklpiVGdy9+rd6LNLFWPvucyZ6bCjJ6Ry5rQHh3eopoUkq+Lgx/y36kJ +f9XXT9rwwk5kpEaOBuOPJWSs8fl0HJxpGVnFiQXij+vO/mIv0UEsQbthsBf4WNYn +V2W4Bo4uTvEsyxk9SpwP7zg535w+gJiWnedDRpjyLJ1trJTZ1rMAatd9VR3NGLL1 +mxTe4zk2zoWsW38oolKP9yJSL889BpPJjM0wjqA6ORgWSfeezPlQpLj8kx5rdJ9S +SYa5XuI1u7anSnQrbJ9cbuLVIi/xGNXBAIwfngeleVz/Ps9vGrRDV/Y5xHNbAqzt +LKxuloJEgsqkrIi1uJa7JAh0Ixi7ZjaCM6hNyW3ldHEd5/WY9Y8GbobOQFCqdCFN +nPFYSELpVV4buPRHUUR0GFe2B+gJwhzXi2fMZ2v3WJ92rBLSB3yW24BeSDHxdu16 +5hxMgfrB0GlDwCYZn+jVb70lNczcDQgU6OtZMeV1v8cDcfNjJGYxUuMSkwGUiQIc +BBABCAAGBQJY/E1SAAoJEKVV1BJckbMCLe8QAIZ2e9L9ULFi1PeUIb+L+sCgPoLu +wJDRJDyxi2VMlmxA8cQggLRz7H/+IK6k90GTjtWJjVorc/e+QMJZaVudMWfTP1S5 +6fIPr0hlrzy1Mb+EBdnG9gQhOks1SrzHGg5BDbwSjh4buc7T18lhYPh1wa4xBxc5 +Qe3VBq1+kwu9H3Ftfo3mSH/ZoGSlOrWFtg81rcBK8EfiVnHNO4uUDCpBS0s/ccFC +WnxGorHBp26MfCBwmr91sbr8oirrLV7HvD6yUU4F1S3OMgG1FBgmS84QQ5hAO3rA +nJQMVLigoVk8BP38duQ9b9t4dSCw4v9q+mSneDgzo4fZCEbKgoCW1Q0RuSmjLT8S +wXPBW0v66Tzscqim+AesrwVrohxfj0PJ0/NoC1sDwTeb0oERh1anZoCvn03jinGj +cwZq0vNchl+asuuk/I7Fcg6KALZ1/P0jE/K5bVjij+Os4HdSDG//3UibHGSdXM+1 +ETLUjnwSoc9T5TRXLXBDlWEVLl/48HsB0MIllCmGUi5azloO0+5sBNVNvkyHxKKL +TdTnAqz5ejqPHo9SxbzvAacG2No/23LqWZeZZmTTd3bcoJdIA7QOwn/VAYgZnREe +U8S1Z4qQLKNjO/GwukmJtGyZIJz/9kbTtgBQqU08T8RZmSPXP6hVJPM2ZxqZ4s5h +i3cQvrpGwWUlImF/iQIcBBABCAAGBQJZAU1WAAoJEI/yQJkYHOAe0zIP/17KcZFK +QkJi9V57oYQATL5W+rBoLrAGwZHd8tkUmgA70ofhX+VnPUPFp7zP19OUfnU+eD8q +iF1vLHYElGCyaUKbxgoxZePKFooIWHXBbH+nFENtv7eJ3Txb+pPD/lhQFzf3YjLo +0o5cMlUmBbNCtLToFi4Ufx9jFHkeI8g1msmycRUPhoEiz16DTILLHD6P9FLYt3Oi ++iyKRhVxDY7X7bBp41wsze5l4+cH+Mtt35OlPaDNcQEujZbanqkx+ZnLC65CcadT +Msk4NW86EloUbTwmtWjJ8HS0t8uKcqMwxkkRXxuQ8HSa1htL/gJHMCHISUB2VHrm +mVkQgC9z7JtQZF8/mriPvvt+mgIgQ0hQT4NqEy6YJ0malNQCvY9I0sPvZGOPbgaN ++UD/NdMeOC3fOqQk1awgeKPe1ybfizFEDWQ3leIwnIX7neohht1lmcDGWHWJrWlF +cDVMt97n6LcjPRjHFwshNk3+v5R9DH0Cj0GuPeB40/h0YGo3mY9llTcIx3HNYVbn +rXHrkaUkQGRFzQZNNbpvQrtkJUs18jBtptFIAHy4JB3f31EwXKD1gXODN1f6LoFs +c6cgSKkz86dj2XaYXRT7BAzH8Qa6LQ4U6dd4EvMKXHOKEHwd2PxBHpSlh6iEZoSO +bGizSubNWe3NqTwg4RpBozfLTRcPrdLoTT2+iQIcBBABCAAGBQJZBTo3AAoJEHJs +YbmSaB2MbToP/2ROkR5l+h4tNnE1eiAD0ouUr74DRa6iq/d7EQTyFTXNGrxD6tvq +n4tFXA72+hKX6Qxs+yDDP7KeVpAYMt3mfFekOqzj1X1AqF1XxpbMBRfdFvU2QxZI +/k9r8I+XDuu01MwbSqWWDJ0zAQKEjSEFVDIu5PMflny5w7KB54eTbL6nS9vFqTOl +rvQ2x15UenOQCgUIYiZcD8E+EthZR0CYGVicAxRxRT+ANsSUQlfowr3sVZd7Vkzq +YH6rAIEb17lCtO6HNJpC6dWtzlkwyiK0kLmopUJA2TQY+Z3PBgdAN8tayd2cyf+m ++o9jHqV5sjn12lGhirjjrPPuxXWVsMqr6G/ePLnz7Yj83JWJ7ygrtqHeCrsDexmT +scZleCx/gOa1jlT1lCuGB0mGWJBbehWusa+9oaUeUGinzdTTLdWxoW7q1VxIXa1v +ra6PKb6U4i5LqdNEE/L6gHirr7c8nsWg0u2LPK2H6hqTlyZ0F/ACJjoMXBCpU8hu +j2vIQozHSqVomiGmRGWCxcEDDTea7j6YJdqExUMo8gwuf+MGukLYhPN7tfwJdwlb +RAhLaUAWvBXcu6bQlM7vuZrHasJW4ZHrAKJLHS18fpG+POvUubNtli8HXbbANgP3 +zJLKVHqeDkJf4QuJRK9TK8IwkbL73fJUlFiP/4B9JI+DWsVYtDDxwas8iQIcBBAB +CAAGBQJZKeplAAoJEK8UTk1XZ0xzFtoQALfnLVfFmxvCnfnv9lexAeh01AQJkr9o +jKdIrPGs8/Kph9HVZ0bQxDlg8cIs074Zg1FNaWo9wR1eT9glS5JjAi/VdU6b6Lwr +FB3fHF+kK8hYF9wNnm4xZd0N5sGtOWplH54wBwLFgYNCRS7nE0DgzHSoKxWItFPI +NJ49inbwgA6n5hE4R9FI1rc/vmlGr622EkziENY7EfMPTD2TSBaZc1pKh4hq57qz +jG3E1/uOkmTEfOn55p6qvMoZNmzpYbFDKIsZg0qAULKBHFrMl8fisND9wXGuiRBe +Jop0yB9i0P64O62+h9PV5rKubIlYPoPDhvl8OwB9lwHAQRYFwGX/CMfDwOBzmLiX +7xcfAswzyFEJokwwiIhyShawRJum+KE7JTysI5WTwu91lYanxy26gx75wijBNngE +9Q7ksAcisNdVLM734jVMn1oJIqFuhToe7rEb7JCOa+k3Q81N0pX98uIJeNI4AP9U +jtj5xZ7i9LoAiEhCgNTBPHW74IJpo6MuduneX+lmLkniro7PJX3lKfKFdW11gQ4R +r7lyDrmgs5CjrmKXF0HwK4QUdpzT1mPbDwVvt/Ofmgmp1dNkgfk2zPgIIrmwEtOz +J9bpZYbGxfB1EbkCJjsyzSj1apzMCsO/Wyw8NU2VBShaKXAsbouT3N2rLBGQC+Jd +c87oHAu55QCTiQIcBBABCAAGBQJZdpGlAAoJECcA3t4YbfKN8W8QAKBwQl3khts7 +yzpaiqZR+3rQc4yGdQqHRl4c/SbOyfzlC2libTMLTffPwg9vEqR/NH9ZTQJjJAXj +T/QKuMhdxWWIrUA6I97G10WLQ9nGaFbOkBiY87RUXE/yHWFne4hhtdoCREqGxeKk +HBoWbVdM25WJvItngA9Zlw5Zr6xMsGuejYcu9d2UMV0TbtvOaKGc6dwHeFPWO/8t +YzXECBheI1zii0wk7B0dbqVeNguNWm2REo6hl1zhB0LCj43rm0KfFSQKlQsYHMRs +6+nAV2GD/mOpEHwjAWxtqwtBAwp9I/8o9cfLFZPdkHj1/fSRbZjKKPPJ3750afAK +igQPmJ0NxsPPhT5iNffrtddHzC3zUNrbQtZiVSYWQ6RVU87/PGi5Nr8O0WChCOmo +N8O4E/XoSG+sFHUf+61/DT5b/8yfIyz44vXtJHgp2+QD9UwtJhck5Lw6ampURX22 +S+4Z2ClXPXHLHwAxPuTd+5C7hleOwlqlHw3QweMJIlOa3vpbjaM1l2yTTnd+5k35 +KifHpr8KkY0wQyhIIY8JLmYU6UHtBziF1vZQQctmx7oZJvGu24HKaey8El/AH/+1 +jwgtzv7Jwkz/WkNvRSSvoWBObVtFIKS44kZ8xFuO4eKfsEDjJNyeCgsDkG5KbM6S +Et/FXWWT+sxS4Heanvbc474d4XBAh7hliQIcBBABCAAGBQJZfagVAAoJEH+8EgIk +03Uu2PYP/1pt2pHGWk5CsaNMX7/XdW/y0+2sIurDP+5x7ZEJ3+NGZy3b5y2alwEi +yaNHFtKgGX0NTl7WL8sXxRyyC0e2IZyhsW4oUyw/WZEs11xj8fRzLK3fIav6Lvm4 +NtSritJGSayUeaPGpNLFJyCAQtVVWFPeksBrvHhI3mDC1hNATuHrEQe3aN44HNqc +bwhHY5FruC2Kl+mC26YeOuuXLihSxzJboJLiXikJZAOiaxDnE0rrLkoWKKW5Yll9 +4yYR7P2l6zlWdywSEB//WUmewV+hhFP/jaTQDBaoa5v1w+Hucp4MzKe8ykmDSiSR +KJadmwkPIVxBfnu/pCPvQ3yzrvtyObdrPH3bC+cq5DUior5CUXW6FKwnGzJOofxQ +7Ny9ZhWohJNlGam+KKXVvQhNnbryH0KcaD2F5K9rnJMBB+EYDde/yeV+nFkk3sTE +mI3vhVOIEYrDdktPSwfblv0paIqo8Yrym3lKoA9HBHAq9YvWHzvxGh6p3aykeocS +UexqYoQE9JNHauVVJWs6RBC0Qk2eUBfzEWwsMlZUHuoFOMlftyseMBc2VqwWNeZI +dbu7mLZAYqQKKpmdkO+pCUWR3gFA0NMCFro52DhN63Zry0iZORmsA8ie1nndWpNG +/7YmfrGEc5+xFYlg/INqkoZJ2sZ/6QZc6ltdB6R+xSeeQpX1ZQE3iQIcBBABCAAG +BQJZiogEAAoJEA6TdwmQAJUAFOEP/RVDQDxbhTZ/1b3vI2REzbo9UvFPMecOnesi +c42floDqSy3vLq0eQwK49itmokaHf+U/3AAOHmrKiVuHe2CB7b351GitSdAFayhR +dwa4E8yIkoGf4+p1oP7oGZSQ2SV4m/qSAHhgOu2P0GqYJBx3RnPvquvpEVbkxo9M +qPhOKteFkJ23vSif9FBXtZ2p6ToLhS2yjhdJpxLQFc2DdJpTHi1I8A6GHVF43Hh0 +/1eGsVr8Kyrmw24wkO9C4aMr8jhD/EY41Qt8pkzqhrByx/AbWo2l+Naftamb47Z7 +TPOMnTl+hlK/B1jKaHZ4692Yx178tp+mEWZcipD/uoguKhn9IWwBrL5rMB9pHTZx +poY+PNyo/VMTsTQT639bIkhsWeewwAG8ZVDZDVzl4xVCQAVdyqA3zZqaWWxeG6Zc +F/tdNYe8nf4wU9VhuyMpCEjulnH2jTNriGAq2hZaBrKPUABSop6RSZQchkj/mlv7 +rT5F4ojkU6h3hsfajRqqX9dF+jj1NcJ5CQDMdgtUniFLWGZTGyGnMMg7o4x/s8vO +WMqsnniDG1TSxFog8m8lEIPeKKdw+qfW3YfeZuLG7CpvJP9Bvvgd84KB4pmeyue8 +HWC5ORHLgZAac84T3svA4gXwexS0HIx/K2f51VLGJ8RyZuqS+TXVLnmtA8pJc7J8 +d+oqFLYFiQIcBBABCgAGBQJYtsN/AAoJEGKrbC2pNmtMUbIP/3k1ZBw/dFe4uxso +yupNOwE9TVIeivWOD93NMk2G+3ZWByQoYa41MtPOXz5BZzLOWzLiLL3UKNmuiM7z +ctZDL/ONX78Fo8hQrxmvq+WMHkEap5WhvTgO74XLLojPe8qsaoU228gSDUEcH2P2 +zzh0KsJc1Alpmfu170dmJdVGc8UTa2Wt6gbFYMNy7w7kTZIG/vqnRdBmf85b9ONr +3wM5L7hqaMl921Z5Xlut4vetwIPXb3/14OMcnSfj5pdsqmYZcmwjZu02cw8YTRHY +oUrsV1PJc9rKzRAmu9KSn1MlcFvwaHWfyGbiy9UW/k/u/7pKuRCn47/mLIQ+/n2i +k5kO38qQKX/d4ps8+JPisEMMO11w/bTT67RZbfqhxkvzt6ki/rVVF4JmxQ1lBQkB +1fLo4kX75g4vf9mnZHCk02zkzLJ/z4phVP/QiwPubhZCmFGmsfGv+i2L8wJ5pod4 +hTGY4j2MKC9uqIwFWzoD+BIYYSjDFev4j0/lkmv7JPaBGRyFTVzVylZS9Ol4f3PQ +z5ib2D7SrJKFIjVzEsPvWIIRGT4LOQ7NEUAnfD6AFfS5Ms+6tXqzbB0E6nY3BP/N +JGUDcFI1VV7Lbo4ZS2TwDdpINusjhAiwt6zalHSHkGjcORkF2usZArHCb8VQiCBA +GOKtvOCecrWJF/9b6yumYztL+BHaiQIcBBABCgAGBQJY540/AAoJEJV0mXRBX7ik +7a8P/RYlXFSXnepZRsAuiSxADxE3DFiQiqdpqRCa07gzumv6QyI3+Whx3V49GAea +HTWHte7R5CD5r8TqLYI2L9octN52D5l98b1Yy4v/KADODGmnuX+YfsDIAPumoikx +gnXWv0LL63p5MFgfUam8BNek5h3fymEtjqvoMQ9YE8tm2Yl04+YHgQaCFe39FBoW +tAfcD3srbiJ9BotVwgmBhW4s9j1y1sA2OszCa5m0ochlv1uMVERxNWE65IRT3V9i +je8tm8WklnEjvEkKAilZftRM5+KDzGmtJVD5n4LlHI7DZisBlI4h4c55H9muQGiB +kXIiGx0HmOWYddn/1VZTfI8R685KTHtzh3rrX83TK4zA3nt2yKE0K7l8qrf0XGYz +nmwZvk0FT7wRK7x1UzhxiikZ4uU6Os/v5MANFr7JZRYfm5PB8dhNVU12h0X1PotT +NxQxNDtfdQlRzCPDhKsSnouV41nD+5b8UfLguSlgSiQarGpv6z4nQDb3nHDD3Ovf +edbFLnFd8b3ymMVQ/B6cLllSfUIwN5kZj+29dOp3n6bINDfDVISj9fBssBc2+lS8 +bLGZo4dYjGJ5oUKdONhQVimDkQJWfhCnN7rVwoEKKg+CQP4B69UizZ71J/q1LkBN +HwWP+3BZw03M1LsNM1OjaKFnNcUuuBHez921PCgzxiudTQiziQIcBBABCgAGBQJY +8+HKAAoJEGyxttb+a7J6VmEP/1zmP3Kdo+4kbd/3MZdYgGA1fZId5Yeejs64twEG +CY5UeqIZXonzXvJrq/i8C+6H131ClTxR/D8vDbhyKad2AVfFANg/jiNVL37v+KM8 +/0KTD87OcYxtunTHBZLPBqVr1UUlGGX6/7s6jx2AIy2gSmixIw+JhYI1NJsnzhUl +L+R4hwoGa2uNr8Pni6Mj3EYrBBMm7DqSUNmN782ByJR+408QeMGuHB8ts7HJoqYx +tmOhgZhpPSyUv4C8/EFPyIjeDuX46xteWY+FA/Xo1jg9nTEj51AhWvCFrxQF4o59 +elU6e78YkNqfjgLahsmp9i+lBa6etoYbmAvm9b2WdD2S5IvNGaqVCst8IJpqx18A +jtkxHXA5QhWoLbH39osuz+WgebIrW7GJrK1O6Fg7Ixn8ZoE7dpvDAtabEOCXUKpo +69xpN5wS3D+bZZD5fRkIfjHPmrxmztT4sQiq/34CklNUtzVmkuOMrfzI4c5K2b5J +VZToZyCtJ9Z7GH3DMrcHf6kXDLWpHTF919l7xVQJKuAe6AnRFJkf4qq3knEksRRf +CG7yBg120mS4zeBLKo7/JVMwYiWspEFNMoqz8Tua16g2lF0kB7Yie8pUbUxYkl61 +YwIxCCDRgzq6+tBiyzjqXlKmfrzt7rBEaS8m+iXcjLTp9nosxtqGqj65Htx0tPPd +qdv+iQIcBBABCgAGBQJZJhhzAAoJEIA5T5GHmDUSn+cP/i+8MhJS2OGB0lExfAW6 +EIacZx7jwhX9xE3Q0454jtMkdHwIy+SbXmFrSgJXL5MbbGThMJvHIklFcDzatDmT +dP4LKuLrUqxszV/uN7Yp+tyRLVll5lnvokv5Z0OpPL16bE5+poogEOCeBKgrxvhL +RYDxUG2fbDiy2cuwIZQjSOjSA3tps15LDaT3VrxLC2GpB3hgZzHlV7GuozOS06G3 +Q7eXIWSk1jGEb8DaJWG4WLJyZtmiPnVymvSn6gUxIQ0NysAIZb6/d+pwI0E+YzlY +Orzeq5AD521qp/YlJ5SYnvWV7qxnDHgMldeBuU+b4QH55sZ6v/x/s238vEDPcBUk +f318rF7kRiQWExaxulYW1E6yYjm5aQRtWm7H7hvXSylC07tP+7nikwXC32wcY87O +u7GM/SV6YTu4fXtDL22AfojumFH01hACxIR4vcgdzdCrt/8r8SQbx1Sca2j4UWaB +XgKr53OVh/VK3UyfXccbUjFllqkuGip3h8mXzCV5ovLEFbFwZ8aeEx1aDuz/QF3n +kDI7YrVa90i1V6Y518aQPkjt3a2vh1mAc0d5fr2V0jvmO/hnZwgNoErHBObZkGaC +sLkRYum56gqs3sjSiKrMpztXhhzgjwZ0aE7O3549VU84P4RWfZEjTog1dh2La8Ro +tWpC5AAbDu+54Wpy5h9N1xmviQIcBBABCgAGBQJZtWnkAAoJEGKrbC2pNmtMt+wP +/jB/8fxKXrB/gfmp05UoKji8mtyPsqfSDZ9lD/h+qfFxLKE1yaeMNVvIAylgUmem +RjrStVXnuos9rydTTPBE5jyZD40QZloCLPuCtTnlng9QhL0jLW1ljvpg05l2CE2J +WT1mB7aXFOTKe7c6aI1277y7Rl+7Pt3U15+XFRmRNuu2wmUl3U6XVn3NNVZLqYgF +x5nsndIMkQ37qqN8t4FMLK/69fsAkNZcjuA0bR2s6SeMO0pPLuzFMZwTrbRp1bUR +Zr7asqQITXjoC+KIgxrimyJcOQGrYroBZ0qS/co2VvQklCAZk7uDb/E3Nub1IJzy +dkMc7whqE7mTDuA60k3iJKYfaMQh3oICmh6Dmk9AgRRDW9cvfkfrVYQeRV//LY2c +xWMMiTrDI5vwgrNhuY8w1V0aAZQy9IRUbYkvi7MLt8XaDSQ1Uhec9a6A6z42sKG7 +mu4sS5HfNamfhrju+1i7IxOIgKeMnarsqDOzQkgIF+NnCJr2RHMVmVCKjGERztX3 +uWzVfmYcvcBIaKICkZOFnglcsxoWK4/wqVowkq6qJZV86O75NduObCIw+uxfItMK +GfzElMJRfhJlz4KpC7npaCkHevmCwmQquZlKuFRSBNjrJBNbE2hmrbGd1BvN8Sim +Ed3JOq++3TTekpRKm8wyu1JCwd7A9b+ouAZLgFrvs+U8iQIcBBIBCAAGBQJZYsog +AAoJELbLlXgIqntd+2UP/RXAsvkS9g+yJNkGZoTAX2TN5bQSKPB2N4LM64BgvT77 +7mGoXPkgYM6y35BGTACxLAEMKhUkrTuHzAz49ysebcGF1S33hgDMcEqWa1H4hEgs +FzlE0DfNmPiEgYg0ta0wgVFhYiwViMJxCgalAbPqfhh/vk0gjOm8P7LWvrOUFrX1 +CkQQbzwEDboeys+lJmOgM1Vye0TLMe4N6LrqENO48VqaBjITbHmrozQUXfnzXQG1 +9ZkYtyyf+7AtJYfJsbzd8+q0yJ1u8n+w5rMQrkaRRzR6WdnUoiV4pvm0GBSj5C+5 +XfItDIdoUImmPXhTz4HtlmEyZ2Roxk4HPJuVfPsU+LaRLU51PEaOeVXIgBb+rUDA +s85VMn1xtGActPzG229JW23CA0QWxh5VTFHwlAtdZOQbS9g0QxhGKdaMV0/MT+K1 +sGNizD9gThPQ5BFCQEzAWYLpfTCICEieT0I4J3aFd4jwt0/yIEI7Bw33seXKvom5 +C++k9W29ugnSF150QE/7t1e1S/N+/wkepk/RzXf10ZOJAkS1fz42afoONxHc5dt9 +TjxK3FSlRC6N8dbdF/kYjkresYx5GDZWOA4OL7mjcAzcs1yYOROwlkCoHe68nvxK +QSx0x0RWL4Id1lsw68Fat+13dwHceGnIIAGPN5xpFmDff0fmC5N6KO1ICyJtMNS+ +iQIcBBIBCgAGBQJZom8fAAoJEHNRihW6PBR2NRcP/2MHHaSpSzvhQYwRfcICuBle +H+h0/h3a84F3ecZIZBsst9LjKopjhLMsRrHpCjQVbc9yakc4IwRhOjcPJoQkMFLP +9sy7p5Vq69EdcCFLQl3Qg9BpSHUWuiZtyNF7kEewBTPQEE0IfWccv8r7ZMk6FWUg +uFswPn5XkdcGTRcG4p9sa+BJZD+Ez4ortxeHQIjO7ka3C2C+vWJsDzWhAt+EDB0j +LST/NoYD19nXaf2qtTEvWMbjAsDvbrCokaFHIMSiOWVd2ZD/yig4yOYuvRZGcmph +Fj+z5O0wErRlOU4lq7MZZOzbwoajIFeeUxYPE0VvzmBvETJH1InMigL9am1GHnma +ytuJsoE6RXIsq9M6fMts9aCTbDeE3Y+EpfOCg9M0HiND159z51U2CL6mhUoLY4v1 +7BA+lSfXJupcekFoGc412WVWd0sO+hrV9UGyyF11Su0bPa7JMLPEFyHmlwiiXb8V +r7Devu0pfOCc5C/wqzBB0jLYtyLEQmjhXYMoMJ0sR1HCVLMnhPcL3dDogSE+8V92 +m9PZRI/uHDM8G9iMCyvGni/CBZ+SYGH1GSF8E/9EOYtRnhfjcUiuKPfjfs6lzxb6 +rj/bgaIoR/3ctT9OR2Zx7j2DH4uskP+ZFQSQmAqyHUXvGlheKJiFNgMOyT+M/Zqn +GbpD9oPhzgSFw6G5AwZdiQIiBBABCgAMBQJX3ivnBYMB4TOAAAoJEJQMBeckpP/a +CYwP/1zdr4N5y5cMwPbCuMKuC070Xo3sN5QSEssrcp2Liv9DA++wQeZMqxwDkMtS +vmufpyolIB2TnsvmsoTCcLziJahTfedJtgjzzK5ZetHnjSehYRGF5mCz7XDA6Vuc +EOJCLNXMDNcvuxvpkCZesuUvvTxCNRkRrzt0XzPfOnUPvj4518tUK++C3XF+wMAl +RCTEquCrIyd9yBgPR/V3o62oVwrC6QlXvtKWgoZvGCS7j3o2x73eLl1XvLXRUi6d +gNOryX78Xox0QZfhsUb7f8lOkfAPbA2nIqpARFkuPtnnsK5VVSZ0dsKt2h1U0qDu +wthGXc9GQloElI7AC8jN3S2ikLFH1NyzLr7St3nb8T/FAfPj+nPC66fa8iwO1j5H +KxXDULG4trfDVM6YVkgp5eDm9eu2/bfZyry2o7ff57zxZKSPInxl2ar7jt3uRB+c +wiQh+YWYJt37sVpxw9HBUx4mNkrm35Jobk4e3QOZGbdr1L0L90ZNa+NlO1dlJiok +/WljolwQlwWguv0b15vFmNDzEEJD+x618//r1PTZZtNW/6ceqtghDH/cMQWOcE5L +P9VkW4Ro/lheHM+Fz7gnkriJGGy9cA4AiYY7Vd4ZrsFzqgJZTu8GgAmuG/tTojIk +QuHnTRp5ZNvGvY0yZG1ddQnr+jDthgX6TWJMGX/3sBbYAT93iQIiBBABCgAMBQJZ +JtR5BYMHhh+AAAoJEBiy39sR9AcEix8P/iBEvM24b5nzF2kak7kTYoqMZvnGXDcn +j1T3Dy+HrEXBGIsY4h3/ex5gHxM00v3a4C47kSn0MNEjRJwJOZQlUD8CzDFF2k5C +0wDZvatJsLOUV6ErBKmhgv009txCDqVrdGILlbDCYrEnAlprcaMbzFODv9rx40ac +2TIfYaglNg2+ybDnKH6m2d5GwjXxZ520OF+hjWqT3SXLAN0JuXsL9K/rlvoTgKHg +aKhHOyyOkiClBrqp6OFYaqlp7w64FU7BXnSqaE9V/L7kqUxVMcK96NcRmv5bRAYn +2GgMBTBT3cz9Th/a+mqL7no9g8WSavFsf4wiAR2CwISTm8QxAfJySPkx7REUtd+L +8bx2ovY+8f2J2OjoidLjuQOPK5pK3kebtlAdwLDSCOrmbE3u49HqAEi5IoxavRyZ +0WgxkEw+ER6RGwY6CQqRHIDhWKeDGmKEtgbcjY0y49jb//qk9T59is38QU+8mIf4 +4/5Rjj57Da0dXZPTVzLlziinpo17EjpQlC8ov4pcTtPRONYwLaZ09JL/5780TvHs +oWFUIduS7hAIVlPdaX7fWsmSozTwTho5qOCLEhU1yMMz447o8aehe6rxMbTP0l/p +qXyRyOJFPWN9wqRTP5vHf2hl68/e2ikVUEvLBN7X2cPa+Vk3QecADMRjNnAqwDAp +1hD8fI3P38PUiQIiBBEBCgAMBQJYpcthBYMHhh+AAAoJECRbS3HAKbkWpbcP/Rbn +Sl73RD185zXYGtSnzvO0DhY50FbyVUSPm3/gobiqIB0YfPmWPqtGoPswBi/KjnCj +CUhwxXcuEpkgTaLqz/5MtYgW4IUhLJvKchBbZugEVhcBepDM8ZzhoxWhlCjpfncy +09WdlwcdeZ5CvQ5poQh0cPgG1N1qt5Aqe4Pl7tjAWnRqahVRxpqjJA9m7+QbJEUk +pjvSrJ3JiLgPP5V5ciO5xOZIz9b5atn4GgwgSyZ70jofsBBdfyWFytEfcCMEt3Kh +zn7RFGIX0ZxcdeRy+/CtYHgWK1bcNVUQg0nvEmOTmR8dTIW6RVP/UvGyAAoMa1/+ +vwohs9z56ieFaWuhyeVv90vnMBlb5b09bMpw/k2TL309NVXoWf9YTGvORDSq7TqK +3EZ61DhnWJ7iFeJ26Xoi4ETmVtLjr5fTCpTrl0T732kxbmO5v8iSPeY3WFzMwyPh +o08dnxb8w51vAkNzeJYUf9fg7+iCnl0ltAq/3BuIbQ9algtpHso5ddqC14saPUBy +XXZ7htawXs/hyDsv/lfN2HYAv3Nl6+8Uv51xK6gbPdZYAzOgfiqOWXt0t0LrTcjw +doaQlraF1jxWNEF8pAUGbmubL+M7dQ0IWjmItEzonagggJpWWKrNuuKRmS0Bf44a +gEVuIeZPPNIZtKsnHRg3LxblDHpooxrskpbkKaVuiQIiBBIBCgAMBQJV3No7BYMH +hh+AAAoJEIAdAxfhnHxIKiwP/Ry5me6VWkNmuFpEEJn1q50W1xGzsJxrh2ckhdWP +1ySBdJDLmWZHQKBRsd8cEP/b5tQz0bDPoAHRJtIZk2J3odceBiyr2mWXuSIG1DXj +55Mr+8bXFdgbfDmo6qXRWXHiAhuMj6nXwZazkTbqtNMMvnz9ZOeDsRTaUW/aBqhf +368JVRpXUbAaMSTf8FRam+XFDq35nOdrIeYeFyG2cfNEFY5HnXfXj9Ff4BZQ52sd +zosOqLc3G3jVGLROULzKsInkV7pKkhJl+Oym9qTKQYgH+4yZS4bXF0XS8/dkv55v +mYw38xjrmgRSgdc1JcR0o+Ver51cZDSi3M2z5bZ250QFTQJvoyWcO6YvMnOyNWIy +SSjEIBm+7+SOh5w5GCqNE2TeNwSZ6UxUHGTIap3sVpgmW6YmZuMQL8qBkvAvr8eF +2lbCqaR6yRdSGrnNc8NyHZHZV2LH9h1Y17n4zYmbcAyIur/lyv9JZPJ99LOmqkBB +lFpuFT80jfIQ0mRjqdNgc5rxIofFlUVBfpPhBvsGpcSUmUo87qx3I7a7PO1VH1m0 +WMtCmEqSJsi/DJFwgTmmTf4gq17VQuYO8dH2VY/06Qu58BfIJizsfyfO9YAzgpPB +yHXUGIYgJWxiG1f1OHBPtJZhpbvxa0X2v6JHyKW4BsUcj5/x96j0bJugyra3REXh +EyDkiQIiBBIBCgAMBQJY5nA/BYMFJ62AAAoJEHNBQBZJD+JoYb0P+gNazWweLZ+p +sYXaeWgr66BwrtQ+fnjUlgfxx/mTqdwOjT9BpW82P9TBYg37e4XKUS9Hl4YbFEl+ +4r6Vp0f0s0cQdeMRLuDpAeEhRhyuV79QiClro9c3VV5lAQeCM6jpz0802XKEzfRJ +RFN3EuavKRvHSfFsnM2OiQSiPi7Qrvs9b675Ok9yi2pcjW0GDhW+zJpewwyKjf3l +OTTIuA0SobIFNWouaB2u1GiTPNy9lk3NL8GUZvFXMDiN6FR0IRl4hDDUCqU6EKnG +89H9gi9ijDLUOFrxh9xO72JKMz1OqgRNg4TYhFjgI71f5EU9FvqQ/VJemOkKlOqR ++MxQumRStosssOEMKUbS5OIIzVZm9b3oGm6nRDtz0des+X0gpoxILG8AcQEyV0ov +DNcOD6+2ODRI/UUAT+APl6KdcAT2vQCrZgO3hCPuw6StBajEmp0DHxbN5XshhLeZ +p7K5W615xjmpVMgHN7L1rhEnNmL/AgamB6tGbA/uAOrsKqLoL+Bgup5VqVoH/LqI +jsLh02nPT6/CUrSDBgFm7+9NIbihKVnMO4Zcrzp9pAgFnFmhmm/vM6g5N16yb0vn +DGN77MIt1EMPqGlzxpoNd6zGhKIE83nlYWvRue45k28iyDqw8rYi6pihJfYpfgnT +xBDUhD6149AvV1sm0AJJgmN5KfZ5pa0ziQIiBBMBCgAMBQJYLT9oBYMHhh+AAAoJ +EKI41NSYIPRnYB0QAKSKToGnz02F/0ksQp2LA/RUf1lQR1LRG5rUuyKWjhhCGNFj +0ddfKsw1SQvVuQ+uhnBaQuez8+kqgfw9ep0xlH2rP08DU/Ee8EuZQyxF87sV2ZYn +H9d+nIaxMQJZqFECNc5ACl8zBjNpLeCZcFce0Xj3PugjhCaGD7np+vEeA4oYRm/A +S6L6Bfw6p5MHJi6llLx0yUX9qYX54zKbSSXkoCJdi3yeDiGoWL+URQiH85dL+6R/ +tF5vBnvEuPV6EY8y0lupOdGLEqZnROWRE6WCuFsNTH4emk7kncl4OnSykB6DfFLw +D/fRUuuPBEfvALoiM974XJs7hT+IA1mrrC9Wjcr7vU8mUiM66z+GaHKIqCSXJiPj +J8qzu5YN19r9hJDMEIyHqkw6hi0Bu+r0I7thZ5GCJfvb19qGQ4ajDyqRaI8E/x5u +VY/QtDhrA7nQ4z/0xEH+6ulAXebnW1sYeBfWXEji4lWjP8vDXQzH6wVBe7OZyd+v +hztErCNIsd5PylvByoLmuLqnV3V6V02D+ps/tBXa9MaWh7bJKanqGbGsoX7BtIbf +YlbxrC3CWclzZjloReXbMpz0LC+ZDFHLopDKh2EBB8l/nkl7tKKcScSakhMIYA/k +jgJW8E+/Mx5IiKONbaQ/z8uL1Tntdr0Ps+E4EnXO7TwbeqUly39JawgO04EXiQIi +BBMBCgAMBQJZljpTBYMHhh+AAAoJEGhhhLp1Dn8CxkcP/1ayIBoOYuDto5rRVKuk +0Q0ASgggBUDSupnf8G1t1q+IMtWyfsDHz9BkAFeTBdLE/SUICYiJXfWdT0dZ3Znu +54nkHnRmO1yFU7mq6PyE7+Fqfzp0vI9lvU1Xej/IH/VSQ/mBkLD3Ns4jsFGL8H3f +vcMc/ZN/3/AYseQSuK/87cMeC5ZAZ80Okkh70kfZqk61mLE3KGbjAOSDQEZ6lJNG +2nrRiQAfOI+Lybxo/0e6sdFs35u731C2AXW42tANQGEW0kJgfMZzCaZ1A0f/hjb9 +LaPDN977AEpLivNnPm+50PhMa97ZxZfPax6PED4BzweoGlozvAJ6Fe6xMODg961g +7p0OR6XVv/+RKi4PxaQkl+K8ukcbGYRYIgImuR5bfjf6Sg5AZLoD7I9QKCFfITq8 +/xkaTAEy1fB8De1GUz9R5KK3N/hxrtQPNMNZBwnkiONlRUeSatLx73kHEb6aA7g0 +9Qf98tkUUmzomfyb75ujn/4GbPyk9RTY8LjjmUC4nHNBJe1NLtKns1hA7LQCmkzx +ZhaTSeKp53VBU/TBNBvaM0+u2qikOXv/zFySDNM5ht0GeqvrkO9/aVRKekUfgnTz +UGxa6BwlqPmC0t63wrViNQFOm1W3I0ttteD6r5g7KdRuQJjiYvTE0CLJ+pQZW3th +xW73X5Gt7uEzm7bUeAA4rg76iQIzBBABCAAdFiEESVXutFs3GeXK3w7DcDJAmytf +MjQFAliU5pMACgkQcDJAmytfMjSpwQ/9HYMxCu7Ag6LmpcR8ZgNPjiMwCR4Qs3kg +iP4gs8CZJffrx4AncbR7shkU5b/Lo4NoaYrOqnzq/zEuTm+ZJX/HKg0hiVK3F3xr +SoIkenLVShZs4FVSa5rI3fd8bQqfTLkLh1BGlgL/n3eFJaV5WJuXiKN7sT7iib39 +Pem431UKpoaQRXaboPxT/LdRhlSpjT/bJN19TTcwdHjgb4w2LwqHouTEsTZkd48+ +0oQYU/dRHvW8vqebGCBTw2vjH7p2fDNYO+qYsE0+DY3Mil52TZ2Nfy8c5VVq7rMF +BE6dhdzeZyC9KW65kqt/fSqDLAV1qllEzQod6F/sJJqFU+Az0pD2QGE4jA9lGcpE +YhyrAwJo0b0rOUw7czRQ386KSqVThSkZr1lIaUP6xUEYKGsmlupxvZCPCu440N/W +fkUXPi6PtZsPCNC6s2E5wOwSMvUpCL34OvGSvEu6vG74unvFo3qluXOcpokTPDA/ +b7PZ63wsNWT+LE2qJ0Jia/2pVfzOJx8tfAx/H8hsSU9YLYcrYoHqv+hOW2xk3CFi +XNYRLy7GMVw9C9YyF8hMFezRQi0SNwY+ludufMTsQFOLjFe2rUTKAySoJPsq0wiY +PdIuoKe5miU70J70WH59vefBySlREU3XJOd4LVOZl5fmoC2TrHUzUlg7YQsk+0+z +Hn0atWp3zcqJAjMEEAEKAB0WIQQZGDXtDq7GNipHOpJcG46CuAMPygUCWRn3aQAK +CRBcG46CuAMPyngnD/9lmZ5T9PAIE52ohs8HOSVNjNsr3Ircowy/GTVGgmErZqTM +jIIZaZyLTaJvCRVvdmhTLHDy6DIK3idQ9Cw7h9nKBwIrstReoRudbjVV1qKWxSxd +XmMwGGor1jLH5SQDeW6tTaVkik8kOaD97mAmdv5y/eBiMiAJKgJNJpxW//m4QpKg +2/5WTome/fhzGPmVbnh88ImN1SdjhvGE9AsbMOcRTHWthOc4fABjpCXmuWksJU8A +oUXa8ElMG/4N52mSOG62xyJw3FHU8lnI/ojgNU8Muk8Bg2tGaiZEHzm7k83Ksq82 +vld0iYPZONflytrZdhGm/nRnA55/1/En1jKUP0lwWZhtWdAfDBxVfzsaMPmZTLBP +QAYZ1EBprmBh6JB8b35Nsa4UTaqUPjZvD6uuz8ERYoS6b16LUlrb0yxj4pnZkuFe +fPNoWYe2Q8/yFrDPSzeZYEECNBmnJ4NeJfYgpXEdQgO96xhmTUJecgcNkTN1NlXt +jVrQgldNM/+6EjWzLgtnJRTjuTQAyzp1g3gCeFc8NGX2TAOS3ebNpGK+3CP5D1/6 +Q77ohpUTvqAYsbs/bRSivC74Tbf6yltRUISonPvhANgVRkvxYfgYZ30nAUQEM70w +PSIMzVo46SVlaO+uDn0atVWn2VE6AvXy20iiJIvqlNS6N91DrcgC8LAazV+dtYkC +MwQQAQoAHRYhBHKpf3By3c4oBY3vMDI8nxeEvd1DBQJZY1XMAAoJEDI8nxeEvd1D +26wQALphSj0pcC79ES9xVqzMssJE4ui7VODpmiqUYLEsrAS/3BWm87a8KFFb6vw1 +oVeZNV11Jsfv42nu/wDhrxmUgQUsaR6KxoKfYzIOHnT6xDA1kgPgb9qIubf6Kksv +XsubhWhwLpZiFvavK0H9ZOBpQ9hPN8OEUyOG2iIwRcJl0G0rFkjaNYvnh7NAb5t9 +B9QucH4SqD0Yvl2d4/aIA8gz0KFODPWG2OORiYe77LbMi0o78gZvD8gEXgOD0tTK +G3kiqNgf83m83T8qP5jCDB57lUBubmqAox63Gn4+qt9FDtEoGyjyKQ1fTNsxF+Bq +nFg0pKCBiWvfNBz56e/SuYzy6NLNHD0vGBSXx3qAYTmN+fdfUJ/yGjM3oB7WYzO0 +JpRAP0wZLEMH5XDekAVvk6fhf0LKqppOoD2NbpeeZSgT4p5X6lkg5DtRWMHwzZR3 +HJfW6RE693k2tSyMBlMwf5OTiWINR9K5bbAkt4HKY9wlSmpqW10WdYdO+aWyIui7 +2/vb8aU32OrMTMSzQaudEVY9ll8V9fP7y6qUqdIESCX3SQ0d9F5vDC4T8YPNnWW8 +6w6Jn7KAv0mu7g31iBy9EljSWyAKd4ZjV9qJnpSH/WBNJt3BqWUTsd0s9MqWjzCi +QzxsQsWMRh8yVnRUKwBNZPoqVDgtleiNW/YhWAlQpTpXrhsuiQIzBBABCgAdFiEE +my/52H2krRdju+d2+GQcuhDvLUgFAllyVR0ACgkQ+GQcuhDvLUgFlRAAr7F9Phff +SHCco8fTPtjVtwnndITPazVHi47kHpsorRfnB1MsyIMnF8xZf+OWqPIe+pTHY/bG +l7hYWz6R9sbRxoWDpsrSt8nPy4kSWCBPusjWOZLYtbgN9+8t3r/fcEGFwOojZhhJ +6dptTNVU6D3sWfjGjqC4Q/ZZykvz+hHy/cU4Q3QiWWiuaPgIk8qe92+fixqKJH7m +PQKSIrA4q8YRazplP8WJRiy1+A5XeORcxbt3Gm3b8lrAgRFITp57VYnfUDfVDlkG +LugI2TBBCiODEqsPWMPTxWSihhzsoYWtW9LsS/GOcF2I6wAieLo0QRrNxU4fI6Fp +yYb0L8UdvPxvyBfaLBtNEdtKWeBhB180ePRr1nDqhFs5strVDMAAGmhDAczlnS1d +qcWFUzjtUUDaAe0A2J5sYGMFWdKQaaKfS9P90eqSK7axxUQAScfSDAtoxPVoD8Xh +l6OMjgUlkElScfzD1SwwwNVW2NIabh9L4FoiaNCB3Ndvk0dDtGlHRV8BUhTu1RpY +AB1Ts1gXbdkzqx6qh842i71iDHWrJsQTyr2aFCMl2tJ7LLGcqBtuvrRK/RMTqtQD +zvan7zASbQEzEb6keLiQqMjy6OtrkvstKLAxJA1AYwoA7wrKY/m1BZyv2Fgz1Hle +FNASbRfeJDVDAquxur4ooue2CvPa/1VJjcuJAjMEEAEKAB0WIQTcHt/LgNLaLI6u +riJJY1dCGGn7bAUCWSyoNgAKCRBJY1dCGGn7bFs/D/4mTFRfwv9JFHfgTHTI0wE6 +w4ghMr7DjFY27XZ2ROnWljglsBlCBbNoEg08ehwl54vqpj81NysSMHsyjFKuEiWP +ymc94mxCTWUOT+Byj3dtzvET5erAtyw2ed3ZqckOxaBU0XBOtLZZsSpn0CRkirw4 +k+wcPBV0S79ZLmvN85jp7uPY8SjClvzLYe9Yw5XLJFoKDPLQDux9reF/BCPB5rKQ +Y8lg+ELC1DbCkjKOi/TikY5hdpVlGXOgr8qKb6tsQHcCEgp1aXkWI8TJGZ11cLNe +3l0RSpiu0czpgGCjGn1nme+Y5nJHYrEP/fSY3+v+PVDTA7b08iL576x7PJaEBvKV +0BPSukk+6X9lBEga/40a4jtnItOqVLmgdDmmYq5NmnxnjGfFurC05/wvjROOelpv +MrupUPus3nhYv8OJXm92aZRyJTus92k4kuRzCh4KUWkHWZthtpQ+pFnBbDd3z91/ +423fdd/AUs34OIcX10B0OAughM2Q9iWUAT7jOT2Fh7KMH+UfSW/faJG7rG77W1Cp +I1FEC9jl4ODNqMtmJWUFPD6c+ITSEa9DMfDcdtKGQRXhUnRrXJrSZzfqipmNNtvR +/iODnIHkBNCMTIQ3H46cOJ+YeHLoas9J6liRZcuBZ6++cr9VMbfiDdkxxqzRerUJ +OliEVn/zan+QQfAIDRESzYkC7QQTAQoA1wUCV9VIEgWDCWYBgE8UgAAAAAAeACh2 +ZXJpZmllZEBwYXR0ZXJuc2ludGhldm9pZC5uZXRFRjZFMjg2RERBODVFQTJBNEJB +N0RFNjg0RTJDNkU4NzkzMjk4MjkwSxSAAAAAABoAKGlzaXNAcGF0dGVybnNpbnRo +ZXZvaWQubmV0MEE2QTU4QTE0QjU5NDZBQkRFMThFMjA3QTNBREI2N0EyQ0RCOEIz +NS4aaHR0cHM6Ly9ibG9nLnBhdHRlcm5zaW50aGV2b2lkLm5ldC9wb2xpY3kudHh0 +AAoJEKOttnos24s1nN8P/ieIfPJ0kB6rSYprYis7b+kJklYILrAfjvGS5AmYbLHD +49VHEQFdY0ybazC3a/C4VVG3uWMtZCURQmytZCWYSgJXQpw26nsMhwusk5Gwenxw +t3Hc8J6lK9LPSoCmRDX/mI6ErxSwsIqs2Dz8SsxNHF4wRKXOK/EHlofGpLJPfna9 +MCSJzQMdzf+zOBvzhe59uYdzbYrjN1lGFIWHlO/cyT/Esficdhao/Oegh6hFX3om +y3SA/cZDYZA2bOpp/d+8qM1RyHbwH1aVy9ivW9EmRjvp16CoINFpZoKVLYW0dQ1T +WpcXTu7AWmTUKqQP37v+hwqjiAmVc4dGAau2cMEIteZo00sysEQFh6Qy3zV+mmjU +xBB7viz0IZYNB6WGX9MHMeEPn3COvlDR+bhxwznQaRZwxhp9S4tXcXvEgVuG5S3N +JKo43MM/A1U2a9/FyxtClx39znSAWso4XDKlxM1+iB3n0Dl0Q/u87Xnc0ojq2Jkw +G+F9JI4pqwjXNhxeKYtoXbXUHEomQZKqCSj+s4aqEhc8Ic+atNhp6YEhEem+ns/9 +bUj12xaGQiS/EJ3X/5MlMAvyZqWRBLwXhfvGlzNyallMGAhQq23B9iuTRAFNs7c9 +aakNAB0OxQvndw7a+RD+RiWIlQPGnTIvgNDjTIRarNuxglIK4NbMIyox+Pz1WK1P +iQQ9BBIBCgAnBQJW2HHJIBpodHRwczovL21pa2UudGlnLmFzL3BncC9wb2xpY3kv +AAoJEKmT5xVuDpkjZ9sf/RTPRuL0/vwyxwEgTJAq+QSRX2IPi/yMlwHNtGa9HD5E +ntoNGw9+cr4BYt80ZHojSioXRnr5KLjFIwTZaLfJxprHifmh4ZfP54zb+IdwzhI+ +rmHIVOe+qVr15Ju+XLl7zLQHR440/VdHf/aieiQ6soTIcfG0avEPtXX2yIDtm2KQ +8lr///////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////// +//////////////////////////////////////////+JAhwEEAECAAYFAlnOWswA +CgkQZzACGjAnp/e8VA//QYy3Bi8oohqQF66Xgfh8Lv8CkpixeqqYFYgBV1tsU8pS +gZLOAJ/6xPdx+rUgIEdlAuJzHvhcDkeNlDDVn/7SMx9IcLeKM6k9bYR/IOmOzsNY +dfPX4UcVlVxQ8Gfu8xbAhjS2I/ENdsQQzIPbtDg7bZq9dNaaC3orRak5+VXGOjCY +w6Cw/6QjxK72EI5Cfdwc03xOdz0obAvxVMSkWHQFPhxfs7hgzBXH1y/30fHSVpLz +GYz6WZnMU5LPlja2Z11NoQbP2BSA1ahWwvhJ4IEP5590kg6SkYgP3uq4xaIe4bXR +qKcq1L7ElsYKHzDaK2LmVgWl7u1oLJ5WYtbpfYlSgVq/rcmmHWB1fxOecDHQArr4 +HMiemGiUWjikRnfTIQ764ZCtvkSUgl/1jVL++zkDiXV1OFhY9S8yQaTM2IeIAcry +GmA4lhi7nl8B/PqCLN6y1obbYuanFm86wl+bNsfTxJIxFHuimamnzPAnEeFGlEuV +4mTcLdFVnBgifUdVe/knwKr7iRg1UY6Ka4358YmbsHhCVQZb8iwLTPv2zcv+1fK0 +JXX66VnfhoYRHQ2TFSiTrzmQiYmcHxgPQqfy7qt6FMKQyWgjU0UG9N+HDwr95QhV +cs5a/azhdiaAY6t9PyhIbnFju7ckIS0ft75jPZ101+j15i3j4eoG86ucv5H9VZuJ +AjMEEAEIAB0WIQRHvH3oPUYui+0YqoYSJNvSmaT18wUCWd1H+QAKCRASJNvSmaT1 +81ZOD/9N9FqtMR+OX6BlZAnywQxVtQgDtCtptWrZCNLNJhcaMun1Mt3JyhGmf7a1 +UE1mODhJlQe5jFVZtTHpP9vfd1nUns+9cvpU/ruQi4NwJFe18/a1eJnskMpItgya +wbrXWxgnY3Rv8EDOKBKMSPctqbbA/mRae42/p8jWiRsAc8f9QVxfC9JOo5o6U3XE +igVrxk+KND6gSFyB8zdfpl29sw0Xyb4xWlYeBKXyGI8VvqhStDyZ9GC7UlV5fxAg +7Ms6CnHn90PFKvnd4BMqAWgVQgbSIx0IXvsgdproC8lxQNd8uA8JEMfjMsBQjx7n +ywAkZuqTUZn6egfBjM+Wr/tDkGbZ6BoyfCGxDzqWzf51zvnVFBn2Q34emge/UsX3 +lD47R44tmQCbhiNh/4ttaHz7wIMYI3iC+qhCZ5AYZjft0ARjyJKeG9i/JaqwonbR +v0TyjoBmsvhTNn40EnSNsnBm8xDgj8rEINpr1XL4hfVPDen/gGd/kCOEbWk26Viy +tVkmai6RuT801NfrjCxCRbNnufuTrHGgyMufI+7x30Fv7LPw3Rf42VwPz10Ay+fK +kU4QmETl4COOa4Bw6w66MHf7+Gp7tkuhjLKRZb24QrJcvqrC0hxKbPMzx19s07Ax +NmOieOMLlOJsRKOdn+PAgNQbyhr1eDGePSAN+UPqQ1XK2ZXyQokCMwQQAQgAHRYh +BJkCZhdnzUCBVRaPIEi4VzBPyXGPBQJZ0fPaAAoJEEi4VzBPyXGPwaAQAJF4acA9 +k8Txr9yKp23yuviRa5c5Pc/g9pkyNr7+YuJvT8Az89l94Tj8vnlKEVpg+r+3isyV +h/+R1Y5e58YqoU0f/r0K5eod510/Tvi+wxyaO3jLoj5MIAW4BR9VQxabyUTKRq7B +3RhumcHAE90qnSDi0+tQz1hLePmoXJhgdIPZUMoVVySEiSbSSKArOVx+N6u4FENn +bfIcfLosl0LL0EwsxIwoD8B/QYVQB8vMa97g6k14eaZ3a3kzSkuDuSTtPBSmuyL3 +XtW++betwW4IX3mSmMAsMwziV1Kk+06DdWBF7Z/1BpV7LeyNB7tsKW3QklnrvS+X +1PkAv/FelazLmRt/Wx7deuBufEcMLV1IH0WF0zc4WitOytW5pjgHTXx48UxxVnwh +tWC9UHaC3IHd8l3V1eCcqB5/pOi4UYljo0SYc6OG6zMhnqb8X/ZiEqodsBJ6j8ZV +2QmEki8HyHwUd1BIlfYusjPa3Bcyw0gap0LpxVl/Rsciib/Bz8wDiI9yE+5IQtdR +kzzLoyMVpg7bxAGIFtGZpCWKgfRnDNE5wmvNACgv3Hk0ikXMLdVKvjR14EobeLqe +jKE10xUd6kujK5dw7houiS5jmRiUc+tCYbOucMC5HuTzprxu13jtU36g/W1X2tB3 +OeEvfYUTLDTVlB+d0Vojqlxp8wRAetV/5nEaiQEcBBABCgAGBQJZ+1uWAAoJEPJg +ng/nNHPQLvcH/iqUMrJwOmDdFNvDDxDxCnmxuCq5QKLptZxuiSdn3a/XkDvbY55K ++XddAMSDhY5/psOtXXx2nzzExy0dbkjzxCcaNQhOzl7EdoymG2oSGcXTLs7GkNSY +WmcAcZ1E0kGOk36Sy/ho505wA9Xz8ls9MsKMm41kwUxs3mnBl4WoRWQcKHm2lb4i +FJSI6ijtylLGNo6FrDLmUcfC+6NNXVEePAAHNwtqQZV6zBgkQemKQ7y3xrHdccyh +Io0vkwFr2QGefDl4+SJR+640vF7XUYI+PCVpuSfNvGnNX9XwaF85LK+C92WIgc65 +vZnh5bgs8iQgBgfwtGC4N0ppzsg8t9RkPM2JAZwEEAEKAAYFAln1jcIACgkQv9MW +SXfStIBi/QwAzL9AWJsYPkpfhzRaHT3IAJez1emADHyn1cfXafO6KdpzgqZARZKk +BpagbwCnl1ve/aNT/Chcct8GdimAP7BPkGMNdqKbQ0YlewhaRimQFeXQQiiI+G1L +/F2qYRS5kJ8V/cramZTztO8u9SO4C3m9YEroTfhjbUKnxiFyI6SuT/t6B2RRY/Pw +J6SYN2oCoOEWtVMWBKymYNdld+ZckpnFFi2c+Vlxqnj/nAn80zp4n83kAeNcZizx +rsfEtyczeY97GBdf5lCWKGpkDGFqysqV5ANIFGzN1C0BVt/9YOEVmIWuKf7/lmzo +gBGqhUu8Y2aCINIYJoexWga6TjNeuJj4kgt7GSW0kGjIYuB1e2F8hwC5QJKjf9LM +jKdgUa+04mH3wPzm0OdFHkANK1bG5097xkzN/XCLQQJOBvXBlKq0aByay+yo7pKy +y/aX9rnUWSaLKdoXgcVbobrI7IoNkTfcMd8qjPsfIyWqNcf09REDkmdtpoWgL4nJ +G1+r0ohufA6ViQIzBBABCAAdFiEEXMJMAcZB2h1qZKMXNncuxnC2cmQFAln4kU0A +CgkQNncuxnC2cmTcvw//S3W6jDW0DHOyVwf6JHiC5wk8PATWgwA7JCuuJBm320W2 +4LIl4i+JnOux8UwbntU6+dEh2rXpw0N2CjzGaRIbBxpco/R3lW7zz6+FlLZPhEQp +x7gtnq2BsnuEToZyFbGFQC1zVRF1s8Cn6p4zXVOQixlhRBpgIs/CIOQyiMenN6CI +CwDwOlUFfNcfOo2XnloZyaIWyYR1v9t4/nS8IAr26akHC41PbNM5vk8Knr2SffB+ +sp50TUemzxoKtKU80O3V/8Og4MffZXMg6R91Zpwh4/i4TpkMF0EBNWW4qJclbH7v +gWPinUvh6lJw7gb/bY3wQVwg9XppwxBcWtq9NA4h/Jl0vJVi0WOS3M4y/HG2IhoE +1+iBrhWJF+XwVjERh2vuJk8fEaaq8O/aOMSyo04LO5sPQJlZwaxZorodFAVjV166 +1SEFbM9SpAv7y4IaUeSVwbaAkO18cWRXF3aBgkFmbu+IiLuJeoq4ChBjojUvuxyz +j0uWESU9uQaqIXlFLwVILqrx9ws03DiTPIUXpyHo/cNEx9WNMvYCPh7M3z3x+KoE +fBCHBuLHZQqY1ARQwFrVMg9Mqt/hQlhYxsPZPbVc09lo8wU8OiwxGcA6wCbxGKEy +ejKpnckStrr2t7o57lra7TYp7HgX8NZnqm3F8Uw7b+66liGl7kAbeFTJ++5j25mJ +AjMEEAEIAB0WIQTUIPXHzR5LwngZ7XwhvLgWHLcvxAUCWfDfzwAKCRAhvLgWHLcv +xIvlEACynWpGD4V4D6C6L8kB/S6p8GpR432JtjgPcbCncDB30nTv+qxvphWfBl2o +6Osy2nZJT3+oDmSiFgA5vTax/s/LmQaKnshWGI5m9SjQjViHfVVK3M177BFc4j5L +Om5JFExyxhAwfNCCxwS0hiLY/EFM9R+DvPIhJbxClFMbCYg1Ry0RHyBKg/t/4Znr +YP3fjoQVok7Tc+Ciof8mbTMBko33YtyM1ALUDdKQAkuu4aeZQLRirI6nKqXe+JS4 +KvDiEsKpIyzwkNjEGNuqTG9wzNEFiN/Xt3hv6+5L6Ujj7MBc7Te+zK0CcYuzy2qe +kagLan7HwItVokjuOw87Ni6GUC8Fmafo7Ggz9FQcIjTWbEfH/wLVGNnHlEoC+Q6+ +uVrFDeP8JzoroK9tGqFoKaGZ2fsBbvKp3vgOmi2X+h82jGRy/pyGplzS2B1nudJX +IlOYdldEqfdDqDrMY0vdoBGMb4yA2kK4sRu3R90JaCWqmRCbv6mN6WWgsiCV+thN +Cc2GVVCK2T+8hKijn5Od7ZOIVdkQpOg4zYi6NHkJ+daU0CVxfW1r7ICiQy6KsUZx +swyBPxGVnrmoYJEsCP/DsVMgvVyh2fS6TaOWnYhfNPBJKTThK11U2D8QEdpXCPuA +4DnVAELk11R6d6xT0ZgtrE6qgU9HKrZoKGyLcmm9MRAxZNoNL4kCOQQSAQoAIxYh +BKKDx3++KxXYfvQW6bfkcytN50YxBQJZ8vF7BYMB4TOAAAoJELfkcytN50YxBYsP +/2xGMjim/8bNil30KBAItASF1VKSR0tBg3MQn9UhSCT3tQCyBv/LiySUI/cMSbIm +epgZDZBa3UOtVpCgpJovX5VqI3TJlogeTa76KRwETBD6S8oECZ8gbWEIw7GwXPGh +XqI0+8fyhQf1Wjmn9tQpmbGQeK5tn7mv5kJ71zDKFREB5AIYmUx9LO0V55U7vhGl +AYCbcDvhzXFScLBSeEOtdD/nJ7id/G+HeiAvf+Xjz4noiqyk3a02eeJx5KBrq6UZ +rhvmB4vWc+VGWEdL507ghibgCt74Iddj1tq7gw4EFPRn/VcYHzwCWt1K9cxbpjvD +3COL2wPCYf07xNxYH2arh3Y2dHx+3zRO9TJypq6RZVxzM1cOReIawMC2PPdryIeo +sGS4tPRMdne8M/b8kh9/mhf8H67PsW9TuSuiXjl5uZLX+by11mVgSqt3pVztUjIJ +tKxmEsthLxYVk+91obsm0y91MVi/yGQGyu0Cq2+/2Zpvax1veoNcFKtdC2VlvsxA +p+j7OKWjUTm7ZHmzSiuY/hgRrOM+Jrf2xI2klWf+SXAR+rt46mifMwvOxwIwnkcW ++SEbsj2E2xQUQSr1aXRLISmTVi07uuoE8E8w/O/O0c+zeQdOvd2Sh6Q7tD1Af4Nr +C9dNOBTNe8YSZ7uP1lOSmuS0RT2samZKXiraHYqm6D5UiQEcBBABCgAGBQJaI1M8 +AAoJEOdr4GuipsukFfIH/iidFSeJN3gx1nYE4i3BvFqmSIa4zg6a48kxmmzDSj5m +gNccqwGODthDlM2Zjzmtv06PukviC02s0HjbzAxtCHowuvTL/Ksd2Lnh1kIUOqlU +gT9ZHkNmkCECMc4CxX8IXCRlgpP59Hkrh5LpjkDFUuCVfzZMThBAFcPn63Ng8/Ln +4fKJ6PUIko6m/HxwepRnXIE1UPTw+P/nnTtrrdAYmtR4iH8DaqTH/k0451Ielygg +nOwr9PUEMxI5BSUKd6dGpIuEWWmNygTaws3hnuoW/elGrgaXIBAzYFKKEExB2WH6 +rHUQeixS9J+gqVDeGJARZFrO0O1DhzCDY2bewHzqmRSJARwEEAEKAAYFAlp81KAA +CgkQsTsPr7t0ug/+PQf/UQPEtKbeGUQh2noopB3QC2ixL1rk9HyxLIV3iECBGWDn +mYHV9lhd+KKZm9ufDhTs+ZWJRBKbn0gzFeUXbiiXowoFOaCd0SVOr/WRThVvw9/u +BWr+PbmAjWC4cWRJCeg37F1DoVROuhngDrxgFbXqlZMxcDBmK7kaFjhxtP/wJ377 +CwU7BmzQKmBuF7N9LoU3sWgNU4K9SG0akVcMeWckOiV0lue8mDxYegq7bbkaYWpK +BMnqHSkwhwoipGyeOWRKfNQNz7QESZfoAeXorvN/71LZ7quEGeVCBZT/7jGDfvs+ +X4l3/T9h3XK0aUtr++BRGwH3Qtwk6cmJRAhNUNEaP4kBMwQQAQgAHRYhBCPPrTqb +fGjyjd9aLmuwuptwyx3dBQJaCdtUAAoJEGuwuptwyx3dVLMIAMcs/5MI9BWOOuMr +FJkjQmRYpMJPMSBrKzN5FCPvQfhH9Cq97aikxrdB0JurPOWjTQRIvcKhpGOaIhyJ +GSZa4ya3o0SP2nG+YtqpidKf70EkL8z9GSnDhvtLAOVLbS9gGTVEwGocIQ5eT2vL +qr33QXAN9dzjEUFebQHv04Xc/z/HrfO1g1WnFFGsHMh0ckeJCaSBgd8o6by63MKW +iI0Ggbd3ZKh8txEZcPJePp5XH+WRM+M4XQ0plkepFff9diYmokKs8gN0l7SvAgOP +Xdp9DL8jzbskBADM9tZeHgCPrgJwwk48iqQ4z6P8m0vMf81j800JSF0OIlOzMAMe +g9eWMzOJATMEEAEIAB0WIQQwY1NT3QMj8uSFwkjz8iffTP+GPAUCWnwsPAAKCRDz +8iffTP+GPI/aB/9CXsNb014rVGFluwF4eeeqyJOnMHFWGN7Zv+jw/bN09IZsaclf +PyKNlwCFiOzOvahdpYnmnz2chy/PconQZioqtFzUcudv+TzzoYdi6Y/kldFbIZZp +UUtfhT4KXAxbsaRaMcgVevFNRFZ6zBX2iDVIBQRDIpyQsDUmg5nQbfcTZx9zzdCl +6QtUl/iiGyLcEaRx7hSrIV/F8ymHM6vl3an70QURItbzQdp9hhSwOLqcvLshzaoX +gse5AGyjkF7z0DOZl0DjSVypjM7u5/c+eiGnVH5zm8+hzIjPVaYyyx7mdoH9aB/A +kyxKjpnrCsNPIX5YFewX3nq4CWVhZoAPty9fiQEzBBABCAAdFiEEaBrzbYtAxPjA +fxrnpB7HMp/goA8FAlpPjD4ACgkQpB7HMp/goA9QjQf/Sj7WFDlgYZIqOvP0SOyE +swtDvUdV1ZIj6tNlZkLa5rPICM+mJ5D411O8kzmeK6iWyNUz44jVhI1G5q08VgaX +HT0uLStUYxXhJ0SLPnf5D6/4/Dch/cr/3/7Z4FyizVydBJPfV9RMDvN8/wCisgft +myyb02NFrVKUxeg4YeR/bjL2ZlVvohG2pySWk70cHN9Pjs9gSD+Qt0SBzvRYM9WB +0YHvhuzVEFaoUU0OL+aT/3ADbfa3iK5BEYVpwSJIIluLW0RjFRyMGy/tWp116OFo +AIi1lmy/gHQAZ+UbeQntdj5YkTioAPy43gQ0OFPibKUGQtY/YwWk03mu7K/zT6Iv +64kBMwQQAQgAHRYhBIc7N7R0s6XGcUKmh7eiS6Il3/uLBQJaTMFpAAoJELeiS6Il +3/uLD3AH/3ooXxY3yiC5DtIEEC2spHYcJsf30IGLZ9+iTHR5LFHj5JqhXoE4n6rl +hC8lCOSj1WiWgenCkbova8O6Z9Ne37wI1LaFR8OZMWNmi+z1OCeqdJ6rpqa5/Y57 +Q/UM00RWGGj52ropFnBqxJchvWbQWxHQAmtmZlHv5b72YaGoAADKR2QEg6tIBQ10 +AM9QrnY9EnOBEksiSJKBewdyXzc7RwSi4A+JkVDz/PSI5LvCn2rqY6lkzk5NBgWc +vau5MgVegjuoU4sZVAd3f5Gg7Mh9nVpA6a2/crBrx8YCXrMp83s3vLZ+s7OJxlQt +4pskf4OEuF3cuo7pDLZmJFTFKzpTGkmJATMEEAEIAB0WIQSHlN5EYN4uRvqmCrCt +2bekmwyDbgUCWhsh2wAKCRCt2bekmwyDboWuB/4r0qrycj/YJgC7OqWbS3a8DQ4K +6NLwRPGlAdQaDkt4a/xNqnCyVaYuM3QM5Kxw1OhEY37q80d+0C0Fsy1co4Xfm1Gp +1jZ5VG+wtK4B8EIeBgpC8Jd5+rOrtqRwiWfBpT4ebA+gFFxkkyHxHfb2FyeZA+Js +u69ZzZci8V7YfV/knde5+Lz1tTW+8mAd/2HOyqhfe1QwZh6vHh18qBcMelOTm3cB +ord4Zfe7QVsADPycqlfwV6cFlQoAluigl1LxsK4qKIk2XO4WzlS28M8pZ5yQcUnf +2b7DP7P5WVoOWhJqfPyF/LO7oEg3Tf0LoYPOt4Ps7D9Ucks/uOhAGg4IGqOmiQEz +BBABCAAdFiEEjV7wDXsBRe+k+P9H6qJ3QkUHC3gFAloh4x4ACgkQ6qJ3QkUHC3hb +7AgAmE3fh0GC+h7opgQN4tO/RwRnliT6ofLXPeAKC+2FXLbVWi/HaR6p2Xu/AlxJ +whr1rMWZgERwh/bd+Pr5bYc4HQDIGv5Ph0xs1vnyUldhXwNVLutCOiLDe5VWkiJ/ +ZWwzoS2bnSFn9i5Kb+ryRw2EcwDXvnELp0kFlvkX9HQ5pc+im0mAT9Jf+trAwzLY +UdOZ/IDWsM7L/KhP3wzu66cYFPh5Zn9SMKnymhAiDQbsUZ3Ae5SC1ZHVUlIcnzGP +P3JwsISwpqd41OhCw6/GUyZHq/SyffORgPyvoBuN1a/b05qyAWE9hh/laFh4MvTF +uut9Oe2QN+e6/1lznR3ltrIcFokBMwQQAQgAHRYhBKNO0mLrfdITCAwo5dSBgbRe +GiyQBQJaZwb/AAoJENSBgbReGiyQgpYH/1Rfar35A9DNPcDm1tZ2VzWHFQL87IMt +DYp8M53KKmTxppqFH3+8suo5Qlyd+4niSq8E9QfgNVLaYyPuEyLDqU0lh6/HGThk +Nyfz1wxQh30GR+5qNlWsJI1u7iq9aJVcAweaPa9/55HWQicvhQqTkoGp1YLiXITA +/qyHweq8j7g6N1dO+1XnIK99UDje3+GIPxwVO8qvfRBEKxZ5d9F90/AOgd+KSv7W +ns0ut/T4cMvntDYwh2ftIo92tNdmSQ/U//84tUn5fBGycZHbGtt876OYqdTHrj8d +wtJJhyx8gBVHzEA+nyc1lqQJqFtzevhgtAHtYc4RorgtS2cwxigkp5CJATMEEAEI +AB0WIQS1TeUUEuWHr44SueQaZNL3opd5sgUCWl/LWwAKCRAaZNL3opd5sszfB/9l +q0Olt5vUm/mW7+N8HoBFKeO+CWUL/gA0B0iGL1Qxta5bsrC6PGq6XdOTnvxpIsBa +z/H4K4BMl4YZKJGNOFEQrGFG7CVDYk0Rl66AhXN+tXx1Q3Dey+IAnB8nO3KPoVBr +4cc62AXQrSRS48hHYF7qIKHYBiDDq7flBM/6mzwESkVnmcU3b0/qqQB7mhb9QJma +VfvccT932LXnyJCGcuG8ordVPHQ09W4cF2GMMdMnmjPqfhtj3+BlZfDu9sbX/d3M +I0aAhFlqh64jl0quznjmM0PYK+WJP9zc07OLWpov/ysGJBe5B6UsvDjdDELwCtwX +/YMyuL2lipOH/BPLAJgciQEzBBABCAAdFiEEwvGGrN8JPjrhpzfkzbRyCF5nXfgF +Alp80vsACgkQzbRyCF5nXfiKpwgAvUBTZk9L79BS9Qa5wmUu3mrAk2mdqXilxP48 +lixrRRXbMWwDoPVdJ5Qxr/ldBP2ABfyt3umdlNLp1mxrlb2YmRGnWvO2vL/ZTofh +UPeXkfEdz82WywXR7Zy1SyibeYa01/Esam/BGOzee/8iTsC1tGX/K0FhhKobepSH +Ht/i0+MMOM4bOtcpJxqw6MUX4IKycd3gGs+NpGarMfl/ih6oMzoI3LsL7MN9Lg7y +v7ea9wOKgnS4NEBgcRoRYP97sVefashBUwyFtlmU9nTde4S/J+/dpG6WV3tZlrW/ +dNdg9cm0Mn/nIqKp1KvnkdZ/uOwu6L+wJ3wEvzjQCyitHPLRF4kBnAQQAQoABgUC +WgehOwAKCRBLOGbzKS7umVgxC/9ujh9+KI8Ee9XZqgkGtLV+pAo4mApL5X5JvZQH +2vxul1f3bzq+RPC1aPvQZa5OqKMPE5FKnPJNxRKOcV1yO1LbcA9ljIKirmlkRWoY +lRLbDkddSN7cOEmsBnuYKfO1h7Jv1SK9Mi5UH4brgdUHWrjAm6hg+nFpfde7UA18 +q6ASI4bonIVSxyjYJVLhrZuC8phTicbayVosThSepOx2FIuwOnZaMafKYjt0NUDd +DmHeyanjLcg1Zo8wnUmdFSihsRdPcQNxe5baZ19eo7wjlzhJ0A1nHlMx3+wHn+au +Sg/K09QgLMpZ0askt9HcbiSXhxwRNMxR6CluqPuMJC9Co4jVNE85i/J84+UOuWlr +65Blkckn2Ns04k8W95U7FDEnjv0T4Oy+6kfbAIe4XZM/tMEfX1oi6hYaOSNQMKUM +7x+STOdc5Z5aeq43xZcaE4Z4q65sYOCYsiEQtZUKFfclZl5VKTBD+K2Y9DUmNQNM +MgXq7cZ8NQJ8tPj3bmPfYMg2UlmJAbMEEAEIAB0WIQRncpjtiWmfZkQAZb89xzW+ +imM/UQUCWqAt8wAKCRA9xzW+imM/URqTC/9J52za0UqUusR6iTJbtgjAV8bTqwux +70U1fQtDV42iu8B6m/7G7OI7qfy2+MO+Jn5OCcl/2EiEicuXzM6B+nBbadvPFDDO +m7A9LQEDJGqe3kcCTVv9kNyfMWwbJnHH+mXHdnaeveNgHT6bjHmcGBIiECSbeS0h +pa0yYaFU+HFu7hzuqfqeRUEswY7CXXoJ7Uav+0TzCTsySdIAFe3KaBd0asMYYhim +O5A06VO+7KgRZ3n0TEzGE2LD7f0K9RL9vBKHIMQNjPHZmVJwCdjNAB1epSvjPreo +8RnyMiqhRu2sW6LVGlskX71Us1MaBzIOzGRbY4vEc/pEaG3t1BKiBIaeM0AGBZuW +b9A5KLudvXV5AZ7YhE/qxrjyHhm4EGANkEWYlJhJdGylbu4VaYZp7jB74AMusjlQ +/orMUoZL71Zur8j+5a2IeqCrTLuP/nyxLE/f/vv39J+lzB3bbScmeA7WndNygLhV +RP5FoQrcPO3at0geuT22F0umiWyQh6zurDGJAhwEEAECAAYFAlqHt+wACgkQmEI4 +zvz5qY1vsRAAwQNPdfq7D4QKRS84IElY5cBwSwYP130iu3gHUbFZq4TzWF2OpMRt +4n42QXuCT2th4D/KkFVizLntOhqjlHHuCN/QKUurU9M0B/pu423f/vuv9CTIIjDU +n2Zsn/g30Sym3W7aF87adigWreN3qer5L22D9aWjQlanOdrQCziGzgJ5vZ3UEtiP +HpIfPMzNYGVB9niRkNWTsCY230AgHQT+2BODXrcmFGdCCvL7NIcIp1viDCvRFI43 +g4Xi8T40s0FkDEvI48H9x4ybIZrMxZN+11vB7XHYN+vyYPAXlLcY2mtVdZh+DrUF +sps3GIL0kcIigZgdS1RCSphLC9LdghM2UoFNMBl3Mxs+409mXp2phzvUb8FayQvf +yscLbLeMGsvZe1cmB76Zn/NzbykD90UqY6dzof2R5MF23AuN79Q+8NDk40fGExi6 +bkwXTI8xoxMbjHno28Zqs7JYMfazWirbyRi8q8EsUTT+3mLeDPCfAch+2KTwOrN0 +3ZDmpuL8IpUIJyV5RuBtXmvnZDuUUwL+KFP8GzRb93BSNTve+lPm2VwF9HtRX6i0 +3a9lF+0YYfAvxeHnO6mN8nF9CyD5x5i67+R6sXSBfNZa7a8Mmr/+sz3mRLbrNbhd +I8B+x5chLhMsEHntCKzRxRt8EoCZof9dSR54K1QEGfZVeJOqQJA65/aJAhwEEAEI +AAYFAlpsQRoACgkQRrA9C26Kc4Wv3xAAx2uiREkWinVfzUaxDqML43w8x4fX+73i +3IkBw8NisMMoAHnWYGSXRdqOppud3l9+9uMSCkg+L7DoSlq5XlLea1CPLCyAnvaE +Zqa52QVbQGYupcUrtBv0uNBq1CD4Stydph9Aug9LSOM5X7YuuLBXALJdlPnvxzUG +9DH9ApnMVLW/nevdavNHB5mc3DOTfoQGrH7OJdD2/7cLDe9o8mwUWJB2NyBT+lU7 +XUO+zwtesWmE5G8laDbHbgqL2LQ2r48XnWXil9GkV6sPbBI/+qOBbxVsxqBy8pnR +PU4UiHp+wHeHXpmJzbZ2jFx+9tZ/5DSBVZGbaQ/AK5zMkjAq7zZ25Ij1D+nMfBZl +GyleUJPIlmrmuAy1ZSkrKKYbrsL4Mh/koFZfeOur5W1keggGCH3mczWn494rFU7L +sIWMIOEB5Vwb52lE5suOjMErBTFBIlfahdCLqJ3hxcYfICav1Pf/SFwDsAzQstOA +ewyth7xOXLbSmHLsAiVJA7PQf2ajxNpjViqMubcMhMYPDdu7Q65UB8pKYhy9qwY2 +CHIm/MhvIDLEcsvXgXpvc7W5uvYlMIwxmiQ1aaCoAly2xmJZ4GgXn1u8TxZinUkO +nhdwCyDQ0BDVUJRfIdhU2/KTIdxqXLMjfKNG9zY8yaJSAKpBcJJQKm7mHWTRnI65 +ypaROuld58mJAhwEEAEIAAYFAlpsQUcACgkQXLkvbCg99Roh7A//UHnjjeMKTpcS +3le0DdF9/9lp/vQTrwab9JJKObIS16bpmpEMTG+Aly6ZL6Ifun94Ps7IF5df5im8 +LMT8t6likNZQxFObsv8yIa/efr0S1ddgbVYSy2M7jVP/FZPBCxjaeby0+8znBybq +ZV7cwtQlCXe47y9X0QzkQ52hRvxAHtveHA7E8ulcvZZlOdq0h0jTcAr7Hb81HnLN +HmbBTTfDn2Fh6CDU96EbHkUdR5uO6vC9UCtoUzd6/dmKnH5Td2xCjmgt2HmIjMCr +iYZHSGMEdL1KhGRgDlXuqIMHU65Z3ljX7194o3Toij/iWUzFHtRQaq1UH4aoFfnz +MPPJ533d/qusS0h81zPvhEbun4ASZpQyy5fpTT0FEeB/ddlA/XmxUA27BdwaLS3W +/LMA8WHEfVwkATL/6/BCJVa3fasjqq311AHUbzoY7Qr7djyYqr7bdRUCugBpQXYZ +4M/ON+in8FjEOnit/SV1DYHY6meD9fSXAihCjjDcMQ/OxTtZ9eG/v+KStCf5qDBJ +qHWZiBuAwFrgc95Gtxwm1W/6dvuzKVkyfqFvYN09vNLE5WD0/lNN7To35eQ4uvBk +G7+4wkPah84xBeTNP/OHVyoGGm+pYmrEU6qZ2zyzyWndPTOSEI06IcAIIYI9q7Kx +RLQfNC8/mMPBBrHPs8relR1cg9Rlf1SJAhwEEAEKAAYFAlqWhVoACgkQ2sWfmfEE +61h4mw/+NxSH9ZWIBNHbf4stwsmZUFQLHz6gZtH5km0+XejKmiPesJ5Kg0J1oIYu +ezFeVnJfo1MW8ts720Vpls8DlyNeUzeFc+RX9oGA9PxvjjBRrw6mx0qvVECSt5Ze +aXNxPNYYVCAaZgjjqWTJpDH/ca7sjpdEE0svNvt7W0TcG0/fCD7nL9/qaqMc+8yU +HttUCIXoBbnwALJ/BjfrYOBnFHvr+xRzZCKVHssi79SQKkp5K3ylYuz+C04LSKOD +NQ7AMMTR8DjxmZvAOtyJguLKBDVM14zmoaXEx4KNpJrgEV7duXqmGbkg1QqJYKpG +xs24QzQfS0lUi/oMy9bbxXgmsuz5ZXgb/jVYU0Sgkk9lgeyf02yQDTuiuoYZ+Sji +4QFc6a/YTWeXGxgr2BNpaQTrFJgwjPr+ymsV0lCM7nVmw+CTiUN8SPIxMANkWcxc +3linsVSTlc+qaGWm6vNZNxyUziLwkt8OMbUfhWtlzZhMR387VYzN1tRoJK5Gfnrj +swIGNjgY4dMIHbYb8jPvjAofeHiFdFiGJ6QHkK69sNKiYZoe3AHyxdqHTx1fdo+S +Owwx/NJdRHYRFJvSTmCeOZG84kSgdckEagxoF2l0Ud8iZYfemC4+Hmr6kgcREs3v +gYNbpCKwX2lq8aUrP9WTG/g3b7LI8keG5CDDhIe838PcUpriY6yJAjIEEAEIAB0W +IQQbP02Dj0IG8ZURVmFN1vakkgPMYQUCWroI+AAKCRBN1vakkgPMYf8oD/dVE795 +1GzftnUAUXPQlZUmxrJdlV+NPIEPGiihQJnjA3P5JP3oCCf/VnSV6YEga780GHPH +isc2VZKY91FuYHbN2TyY0prGrghOJ+Q8pb+2AT6lLL0iG0s7uX1wqZJCoQnq8Fgd +PA06TNDEca5sL1VOSZ3p2y5eSZitRHpOZPfMtgQUdVKtVZTgRWUffVoOuYJHo1tf +DLVjOjycSzSiy6Q7VFnXreOj7bpxw7OfoSuHB9HMtQqTaDALWLYx5w7KYC47xPFI +i4FrEiQg4HL5fn9nZwlMHg8DlQxXFfbzb1YRHRyDhH2nGjbRjwJ9tCcqOJ4ymfir +NQ+Z5oYhu+j3Nd/QA07BjHtbmD9R5fnFrYNAPTwbLARjzVl5sn2YwF5yCtItdtsu +EJQL3C2Uq5PdgGtvd/jqkBdgL0NmQIVaPIPICV2eVAVA/gYmPQ1lCARj0TZ1JG6n +UY8uw3XaeyBa4XAp7vKVtxnvx/VsLcyVCv/PC+JhLpHOVNRKYKLwfWukMuqbnzi9 +yPGw0UY7yL1qHCQeEkX7uO3IbcWErspcoGkomKau8A+0IIhvHRIDRJrV+cHoGMhO +kP6TY2Y6GaWWgO5UxrU0wRJPxVgVp+eQnWIgr3WhIpMjU8eOFfFzdSnUF145GxvM +O21h9mNgr7UUbM/L5DZ23Fhvj2MspPzm9y8viQIzBBABCAAdFiEEDzrS4H7uxmzX +FxZAqdrTUlhCTNEFAlqwMb4ACgkQqdrTUlhCTNEstg/9HXKZlxj0GR74Bl+0tPsx +lg7Efq86+lFe79j0AjVLUy89jX2sC5Jb+JA0SWvgOKwZy5yDGpQ74p8r4tYeTLVv +DPMXHWq1HmmUir9T7KuTYdVnjNMIL7CW782ZUXwFTknaNA6yIY62ygn48+mjNZGz +Z4iA3cuVgVMQ+gmxiXjkTDezPMSluO+iYDa654w6mmec1T5/A8lGXVIm9pxyC6d9 +RSjl37CXqm1FcUgOx07jYHjzWzGhfDvUXo5t8TESZB5BdplObzYLwLFVsxClIIkg +DgqENjpOBOs7TjqgL9f5AN1js+jf/IkJowfi6+cZZDokEiisx7uRJV6m6uxvt4B5 +feMyTyky2+CgPxroBwGFN08+QQtoMWEgow1h1avxoHHxfW7Ngqt7RfKg5BVks22f +6UYaTrWqTRdFjsb61Suk5yEO7AzOZEbRsSPXL/TzsPV4BQAenv56s2ixzNnT2k4s +D4bN4aHgzhbTK3DEKxCZcteJjHAarSqdc9N6jO56tyEevo/oEmoTlHqLRCMFpvtk +CmF9QKGUcwfFMAdZPPVWZKInFlOjbsWsoYuc/0Hlj8w8FAPJwdIZgkLwKfHOmAsV +Q1g2nqyX4B+5ppFntROYE/dsJc/QDMEMklyHpTholoqqFVlLKFgyy2eFMSsx/7wP +Dk4x0miRMwhrI5e46GZjPN2JAjMEEAEIAB0WIQQuv2CnP3ja9x1rzpjt8rCQ4HMi +lgUCWppVrQAKCRDt8rCQ4HMiliTJD/481QDPkJEkVEKfPe9AhsGE5qCZfqYdMAqB +sWJFCzwbVYoA4ZMVR3JO6RGOPsCddVnspECeedJwZ5s6hM1b0O4d/NSU8om6RqLI +flqwS0V03irP8wE7idFoxMsOubaVVIkJi4ZVQdKm4pVa6ftpCwttvpcQtHghwzOZ +CngfTZ8mgKpYp2pXexUobj8cP2Fkq4O0qE+HV0BAmrXyJEn1otB1TIKi2iA7phrW +9bK1MVj0EKABQRvYcfWxuZPwE3VzsEkOIntDGiDMhpQlASnEQvKi5BG7zDu7p/19 +F3u5bfN2y1//ynReGhgCJZxzZfYuYsvjNoNWQ6fUQh0FQU0t1S7fqXtZVY1tNzKe +2qIflj2Y7nFqiCr/YbjKl4sfvKbltgpnAtWMIdSybnDznxNwnSybYF7YPXjVxVSA +imeNnSaAQiEh1oh0xxdyc4qWkYYLhex0JYi7EQUaKHl1W35yCHtNW2f1R62+2Q7k +gHxORhkSNiAqGkM+4h1E4rHYvs0PXOLld3/JrAVJCbUh+rCw4ECdeYrrq1lf13Rf +EzwcLDQDCvZaN6onBABqCYcZZDWCe5T9HaJst5aXBB5zrOsBNR7jkH7hnXehwBHu +kuAm5p9pzboF8Y5FwCTqMXiwfukmqqo71R6latEQIYX34hWCSE/NKAuHte+LDpeL +mnV5kfCDtokCMwQQAQgAHRYhBDNxQHPY0bldoljc2LzVsdZLFn4eBQJaGnhzAAoJ +ELzVsdZLFn4ey2gP/1IjRR+8IYP+1USe0cAtzWBysyxu3nCmBOon/Qx8XYraBTBF ++m6qb6ZZ9zY9HDgnZABowtuIq4xLjZkynYQ9PCpKc+JbUwgNSXIutF7l1RSGZ1Tn +uHWu9e0sjWoUV6EG88B492iObRdnvN3YcHF2I7NL2ua7Q/IivIJqdnTMlOCpAuZx +bmyHL5tLI1/Z9vuWLqOjCykHPlHT7gLG+iYTxBKqt7imI7BnZRU+A3VJby++asG7 +Z8QmYqJXuqJtVSV5NG3cyd/cFb7Rb4rMT80ecbA4NB1XR1Sfvwwv1XpP/0h9U1Pu +SI8nQa/+4TtxWVilzBBlT6jt9QK63fUJz+fXLxORvFBdsV039GMHboU+r/X1/Kic ++2rXKoDADErfB1cVJ1C0Cnjip5qbSLjWx+j1ngcMENaJFJL9UY6WGcdiRK+6llVY +1IRmI7l4bDStpL/i/TUBQtF/OSBjEMS4zip9cm/r7lSpT0fCoYbUW8vEhmNh17RF +MvNkeHwgbSjml4IEjSWLCt2GxtFefKhqrJSp1YEMXTaNTOvuA9W2hAad3yO69N6e +RmXBRef4KkuyEapKVCFqQ6CP/N48FMO7hFfn2Q9QQ+w0S1JUpViOq+PLzq6c6yuM +8a1L8SQk26dHSogqOyKaZZpPBwQDie+o9mS3421CtNJIdNMJHlSRqAecj7KqiQIz +BBABCAAdFiEEbNYuc3qO72TZuWe3+p9au3g0L8YFAlp4ojMACgkQ+p9au3g0L8bq +KA/+JMKtJHlPdENOKl7YusbDa2kON/4L2p4EpDBJ5tR8Y3SAuqrKn4ZctCYDzalY +oGZ8dogHtDiRDv2U3aFsEQ34DUCm6+Sq7CmXPAKI8Lh1SVwQnRUptPW/6DIKuIML +DiPjbjJ3mMiA5lSz6y/PN2glrJL7RHjvX4KyxM43eeAV9dFR72Vvzfz5b7BnDpgW +it1nMhcao6jVYDpks0Vc+/QpGPG3BAP3BBoIVeAqE2f5HDWWppuKXTGcBVkNq+uQ +9Pu0ZnTkgFh0L0kZBtu4+2Ocdt5/7f33ZEBTQDxhngiKKbKJ5WckcV4cbMFORYIG +PsNxEgPohPICOZKpDBn9Z5zuYAhYu+xpfqNc61PBTH/1VRLcFkZZlyqWIxcBKSNN +ZuxjiQXfYezRut96zQakc8P8bVakXTz3RjBcT44rffXnb/zFz9EzutjNWq69wMKg +3WFp3VCEgTDiOqHJl2RYC0t3Ad2eK7KY+jiasgAV8uOm6z+FCY6avBjjZEaDj97u +kbZoTkQ7HygiW7aCiV9+qM2loNRXM4M9UwUjJrBsZRJO+q59FD2jGvzuxb78mnoj +dCUxXnvx7a77HZKm+Bto5D2IJRn0lkLJ7w2VQ7n3VdSOXXvpt73L83dVMLTCYEf1 +ZqM9qvjhioKJus+vGL0EkhV5wYwjXXp4RmFPuUkXy58Q1zKJAjMEEAEIAB0WIQS1 +bUZY482JVw+ofstab4yMWI7QQAUCWmmjXgAKCRBab4yMWI7QQIWREACU5K4wwWFe +uqMtCtmlksrlcH2mk8yOdiAv20IDYIgHpPJjSVGdHYFfeok5vl/HCDLryh18coUa +AkGzYPc+HsUWnVbeoc2X0ko1aJWPXUlt/RIR+vUMehAXEk6ANwRwsl0v+R2Ico2f +WHK6gy2rlm/8qboK7rakUZB7UUYA9brXquPffHo5yl1IgNr2G7AbPksn5/iplvxq +8gG0Vqf/9zvoQayX59ARK/3Z8JC1WVeb6RkZUgANwHcguXI25SyB9Hk4Qh3jPTBt +4aHaWWs7zlGy/PUJUZxCkAJs37PSBNCXoADCB+RdZhDqvIZN1yvvvro4QZ/tzz4Y +iPp+M61zKP8zEvDZ9Zr5kQawGemKBkGlx68RgjTb4hzkgZWcqGk1IoWq4ywibpk8 +OD2I2nEbG5t8jc8MnX2YXHHy++kuUlUHlOg6utnYfGoQ6YS48NUGSbLUThPR9TIB +wswRZaBD1B7l/dce7STAkqRtISIKTBeoCXPXIIk0qKYWnyLaHDvajlewfqPRKMBw +QoyRKeB/g4aw7cw4IXfPBW1gZ/HEFB7Ofr7YQTRqER75+AjWFY2UWb1exiumAYlk +IhiaQOwPs7As+QtslIdNYvrvtcYZPB0mv9fBpbYnWpWCv+58N4VMIbr13cT4Y58T +lNLgu4c5APmFN+ltasQ2ENhCERMwovBiQIkCMwQQAQgAHRYhBMOGIjicHSCXsD79 +yaQ2edYogQk0BQJabPehAAoJEKQ2edYogQk0AwMP/3DgjeWLYsHo0tCoZis+IUvq +DRDBRojn6FHHLcyPg4FCMWj5zP8Sk5FlyQwMCmJe4w20F4phQfAIOtUkx4YYdjQ5 +I/xFMfkVREhT1AaewdVXfFiMovQD7DhxDp4d6P83+Z4eNQiHI+qXvGsjNQQe/q3T +2fnr68GfLSTmipjCJzIpzvVULFXyFZy3TBvbMFfBgsH5i6cKwWbfu+KZMBBmGm0y +cSHcQB6W6yLF7zH+aqLZjUjCzxnn+nEhwaIeLSdpLyDIJiCXR5EeKOwxyMgzoG1k +7B1CAlFSFmucgDBoiCDKEksxK4inLzZ7N0WII39v8evBRpecqGWiConvFhRi7Uos +0aQy/c9zL+l+17Mga8M3eHJ6ldapZOt6Tfl2nHeUN23OXiAioMpmTSkKON8hdq+o ++Ez5uMXSk9gC0sSTbCx46iqoAN1FB8D9fiz278g71dF6EkQ/9ovXUTQIceOOSpXG +WleqV7pnyrtf1Au9qIAjEqDgMkJ/fx5Kn5IYUCPxxg2a4nu/62zbZgNpHIRR+Qau +CoXGmQMVrCTG7F0SJFDQV8+HbSOqDAC50FnatQRyMvm4hZrWvOEZoRMWV0HzSodA +JQ0fci8ADWYEuyEZAL0tZ5OPjyuPm//lj1j32Cth2jydM5Jwh1FBIcd4hPtm1VG7 +iEf+yjr2tAQeSc9L6IwBiQIzBBABCAAdFiEE1sqZlh2zGmJ/LFqOIFuBFV8dscAF +Alp2tSQACgkQIFuBFV8dscBJAQ/+MGEnFtOIEeP5GNdhFqsLS2gUqyc0qI1Bbl7w +IO/fQmvO54DHwPWUuCdJ4fCr7moqM6y/9KuAAmXUbop3wauSqc0w8Slw6zTgN9qt +RDn84HD4SaaD/s/I63ljwsePnmcVpIIIl2BsAJFCeIHDlH9RJD6G2oWaO6/ob0mX +sFDStpNgOcVy7XVY1lkIRSdz0J/+Zgx4rTw+paOmvjreWTEGREo2kgFPVVQFcY/7 +H79J7r/tz+01LdWUcRGbxMDsxzn5fXmfFqMh1yrDpju6ckGDCLapjYugSRtt9FnT +g2FvOYr7Y8pwFla6iJYUQalyODgwAlCGi5g6Z4y0epVQsDlEIfCQcBUPhNH5ESzL +mwlaDesbdCe1qQM9x1OCWl2KemZy/XLAVyTT51r0n98oSdtGDmj8PmveYmJEKVFc +u16cK1aIz7xhdwMJHKC+esbP5MtpgwrUdH+zZm/gBvVJs4OocUuZskdPYnByBp7Q +Wtga+vNh2OZ2bdDaGAfryj6y5Amu8VuNAfRcmzr9OHW5kRJEfGkIto1v59orgHBh +2D3lyXVtOWGs0xSjCubeYbsXiGrKT1dTzGQW313WOJDSEGoFlA4huGfyhkhD4I9J +9JQSNdb72N5rSLQq+HeyBvzMe/63N3Gey5l9HfDxtHkmiiS6+4l3mDBF9PZqnyOZ +t6dUq9eJAjMEEAEIAB0WIQTd0rUz1Fw5wtL8jSt5Xv7aO9xW3QUCWlT6VgAKCRB5 +Xv7aO9xW3fC2EACRSk5ar5FGPggsBvT/CnMlRfcjbbgHTN180fpZgKXOTEnMZ5aV +O9C8j2IbXKu0SY9dwPqVFJnIh7coiB4nr02uzHjiisgIruT4HSn1uAvs9VtiR9Yc +gYPNBVla55fKsKFccHSKe+CNW3Eja2Vg0WQTfe5420ly+DtvNJkSN/xIexFdkB6x +5CjVGSkYlm+GqVUam+4oZyVKM1PTMCJhT3Crsz8DxMXmz0NalGeyVWqyt5prcJ1T +LVvayC/2/FvLsGigwfINVPKoAYerdoh43mup23oFHZBNtTbAHi5dseML59KGHOAH +xcBgndEoP5kjJo6WgRsn5ICouHpVWBZEQJVwc06pqrDXUvaCqwEbL5K6wFI43Mxk +42EQafNFlQ7pACkzJksALP0g6OOdCNDgGyImHnJzzz9az5Mrcg4fiP5kOE95xK2l +uY8kB8+wYLOkIf891LhRn6e8ZBI2eGm4GYO+Ls1Y59Kdfv5Gfkz+NPe6vle6o8Rx +SUwgQJn5vLqMc56AtjK7YajFTmokmt021NWow2wiHJufnbqIgXkLHwFPp5RNVmVL +Gz1Lqhf36Y7Nm5VEGjpxcfJH6M+Zck2LEQek6ddlzZiZ5MfaMsFYkOcBUF41dQdA +eoCK42hZKIH/GVY1Wh7s3jmXG6QKuIOK7MS4W/aBKGBI4JzROVrsLNbAUIkCMwQQ +AQgAHRYhBO+sw7dTUnVXGPmVznr2DVSXJN7vBQJaI+CfAAoJEHr2DVSXJN7v47cP +/ArG472N3pb3jbNCV9vtbxDi43oruvkHeEpf8AVJqQUTdv8jWqWtZSsyPMs95JDZ +oDGQtIqvNhDpwE4FPp1sK28Pf/YA1nA9WaIN0xvQ/xESCMRD6EoTVxvRboEiwuI/ +CvG/M5zrCHHQyjw62dgF/CLyAuu6ZwKLdTeRQqbPXpHevjYS11BPjVbXu3N6yhs/ +Km+BSQqFtYelfF7yx+omT6SLqEZFBr4JnipGqBxR24Sk93mcgrot7ZPih6s5/bSF +eNrhC9ksZWIEm6WqszzY7jH8up+6UnoCm7QUbxBYc557qPelCxiuAbOxcwuIOoeA +ms2yCDL3cY9ojIrJ3RqymOY7TH1fVVYbh4NXOmw+jwfHSM+n5q3/JT3xDYzwnFRX +/lMksp6N0xF80iDqprbdohyFl/zPruIOsOfrSu8s6tQ87rFNqdEIcmZo5NLOraJt +rYuPrZeXA11oIvvvpA1YNbRY5INk4oK4m0fcpi4H0h2JeX1e19qlp86VQ1Yp+JDc +82AieZ48GUBWi+KFpx///iLMv+wyNwn1xEXDxDpr6vRs0PhrrLm4K37izhJxzUIh +hh5ojtPtVLain8BYaEBO0/+2P79fybNdM6gevUDlBcFcXtJ2t/c7YFoc2ZBayopS +uSkdAQ2PbiHXVrxRSi7IImVeCn2D6Ap9sJ0IUMOH/K+eiQIzBBABCgAdFiEEE6zP +PtTjs29ib9OuQVxlNBO0NHUFAlquaqkACgkQQVxlNBO0NHXB2hAAu0bR4Ube5AWI +CIHcIywmTzWxFesJQa0Q9BAQy48IRStneanTEALOEAtwF1qpoWaxfZNkwghyKReX +doEAes6lrarUk5L7f7/2wEgkY6cUHavcV1dgVyekLruoHOttPvoyJAhPTRRefZ5h +lDp9xi2CeCnI1CFpZMEJ6rrlFYBDo1fiL2ZBnnEk0kpWM4Lex9Zu7YeKUyeMjOaG +M6+LzeENnvwpxC+eauGjvLUVEx1JvGi+ht8dUT29Tf8I7iHSHtEtbf8lnzs4wepe +n/8L3PKHbGnId0biw/6c+0PCak8ZspIViZ7LGEY5GUJ5HQRP7KOI/qFH3EdpUl5o +7UijN6LFB/Fh9qkvw6YC7SfV14rFHcOwQWqwAt7p7Q6nuKUtJh1isgpIgWYAP1rn +koU+OjXS5AmvMyPCNMg2DRxTaro9uOHIBaSLQTRSTh5nBCXGX6Junm8NLV1l0AIe +lP6W5iXJh4aBmtchWD9cP9Ntg20gSPybgl8rgZYFF5unyI15xM9elyfmBkum9US5 +iSZbCBWxG7Ajuo+iN7JG82UB90rult6WZfUZ/pQwXTGmvzyzzFN/mcH+dNQx0SBA +gtfotrxAOp9cgJkHKYx0o3Pyr8Jsz5Nut7l6XybV7jgRrgUPpf+PRTXOZuLzi/GK +APVQjRgspi81EXzrmTTBklKbaSMwoOuJAjMEEAEKAB0WIQSwJ9pJBXmBWkENQv2k +haDtUbi3xAUCWhTPlgAKCRCkhaDtUbi3xJ3RD/9TJXzx8Js1cLtV/iWPXns2ppIU +r0sQpP4iaF0uLzlY6y3FUgXFMq4/aMkdzxaH/5qWH5O8z4GfVRJ1hE2+SGHoWn9Y +vbDu75WCnRH8wgoKGXsmXgk1S1eJHjWutZcZj5Ypp6Q5HkDKBSqYZYQxQSbuTXo8 +4a2xTr58mJKBm1rh1wXhdlkSj4cr6ZBBB9+PQtCjCfEPV4dfDirPk0SonOuKw5hg +yIpI8L/wcSF1M7xXzhT7mdrEjdcq6C2ebaZ1AnCseJJpqL/jiEWOi1CS11XtyH8B +oQ/cC03Qy2oMrSnGVR+DIAPQSVyfOgdpC0VfN4Zu8GaatwVlBl9hz+Zv7fQgKmEP +d6yPqtlXn+uyROtJdyimlYiin1ys3JG4xJPN2ATEb9Itixv6quoyWCjpklmxgqjj +Xl1NGaFmeqonqwAkKV4BpfLVsFZye56oh8PCzNf/0Xw6jYdFzKGTEPEaRBJy76ho +hVu7Y4Dw/eqqkyGTg9H0POQC69Z2UVxFK2QtNeVHGKfpacncsIfUJg+AFfR4w+QT +JvdtYIJajEDUVal+0aOoDTYR3lTtOaDrW5xzA2aLdmChgfcCfaFX4IOMItEEZaX0 +13lBwyy7iDis/UJWhizoOpFvuzPX95VEC6Mb8pTKpriO/r5bjRCi3LNlrFBl7Jk8 +xLg1Zr4wsFsjkzT3uIheBBAWCAAGBQJaXmXUAAoJEBu4nAYCNnRJnzgBAKwOIN9r +Cr80PZluX6Xf5CbyE1y6kmAvMG8PzLV7KMPFAQCDUDZv1wNvRIAXbLbBkalvVrHf +OxD5WkHD0JBjN5UdD4kBMwQQAQgAHRYhBGpVcLswZ/Ff2r7cwEnBoMJzggEbBQJa +vdkaAAoJEEnBoMJzggEbJIMH/2HZVRxxbPw/XsH6BwAYcrtoK4hRVVPphJ+zb9aD +PQ3yt94Rk2nQOo7NT9ys/q+XQr29W+TKCOC/tuhyBVQBtnp6cOsBuvGkIWAc5/uz +6ZVlDPv2P4fwnxH31MNHbormwtZBe92W8bxpN97BRCVPIMCo2l5ojN6jNHXp3jFd +pbEdIEjQ56g8e5yR707LFHyKnGZGVHmnPZD8kRMM8PP2DLt23wFsyxjXfxNMen/a +qbZSlDgASM7omXEwVq3gmvckXQDtYNei0GzWeQQ2ZsbV9vWNa1pvZem14pdP6cH/ +g3FSBxPkwFFCXDksGT/H8YJ3El4FcjqgiNXsvTJ1QtPPmQiJATMEEAEIAB0WIQSL +R4ic3FPbAz0jOzowBS+LgH42tAUCWs4lVgAKCRAwBS+LgH42tLTnB/9/CQ+EPI0Z +bx/M2dWHG+gTY9bxD3+059UPpm+AN/HQPhVVjOVF3LXY7jpFrm9m53x5Om9pr3O5 +10N13uVkvAmADEKGfuqLji+zKfKqwib3bS3o+Vb7Apmobkw5dipAEkYSo4BUpvtS +IDZLJ9uwZs006ORAhrVZujnlbpkaCpuJsTaAtBtGiZn5WzmxlbAXRME6MZ9QNp52 +uO0IvM4YTeF1SvxJh9AXXabIpJ5Wa8Ursg8ENeIEYawIj2xPC1mTzgpGTQ8Mj+9n +x9wiTEDHC0O24bRXrHvxE67qjaMMD3YRMyjHqRuTYg2zLmymL0/B1SVCA7xwUu4Y +IIjtZq4HNwdHiQEzBBABCAAdFiEErrMiEo9pEjytdRR2d+KglHgnvtYFAlrBITkA +CgkQd+KglHgnvtb/+QgAorFmYcP0Gki1X0eVSJpe0OdB4UB0NG3AVyRmHx3ALayg +bAtGufrWXMIidbzyZx7IsDOTPPVgMy/vZvV/55FlzAZ4q8HkCGF4E34zKy5lkrFY +p79Jpa2PfTa8uOxtQVCi2TzrzmZSPN5WfoLpBqb31dflpKw1itmAYSdIvGvVDhS5 +yrVbNI01Zdlv2S0yMj6C7fYCbSwpqUDWy/UjXCBUgiNWwoSvtHR3Jn125z9ewjnI +HZpd01aIm6rDJEDi434Asr0ZdgiGsGqJh3+lELyhghNN1JfWBIz8R64V9y83ZDPm +RzUEYmIXUg5J5vSG9u7Rv2YjY98MACYquNBDJgG5wIkCMwQQAQgAHRYhBIzPD661 +hz7Yx4ema61pKoAv+LgYBQJaxUCKAAoJEK1pKoAv+LgYgcIQAJmtZSTypPoFNEqG +ax9jPMUUx9VlurJcJyX6bJ+nSODPi5bLIl8uOvOTuybPalB7u9O8fF6ZHAKNK1F/ +jpSOjrXGQbG0ewEYC+f34qkLxMOvzB3mEAFZYtUvRSsJU/KztCxJ25dXqSR/5Gda +7U97D4kfP5hV7mPyPsQEQqtg1XgYqiE1tbt+myk/NlcxRwWgkVKY/0Wq7Yu5Coym +eYgeL7OcyLioE04znorIp7gwGfSD26rfhe2LcGgGI4NCDsUulwHt1rhF96kL6DMK +dHRDUdl4WIbhfRaM4F2TehzT8aU6uUJcYLC0awC1DU0McyscXDOp1B/PJkQuKgYW +MOofXoMMSVscyRIBVD9DVuuMmucN33imAjSJP46yvOXCSWBCeo09gzI9dqeKOXXm +2MJ2LXmpGZuesjc6doTzjgRMWZUFE0Fv3QMldZMe22v7ksB935Phsma39f9nzlaN +gPSMPhZ01+SKlqd8N86y33/eaaQ8Jr+OBe9vzP1IvfOtHCOe4Zfuzq4oNkZ/OLuL ++UzNtEyt/3tFJyQ7hPSGl4Sfg+QmOuGTrrjEwU80vM3ospZMTWSzrNrJ1fDOAD0T +tQAg9NrVQiLMNZdksBS/WXb4YU1hvsihH8z0Jr4sKRylq+pniv7jvVqVok9jSR4w +fg8iq2PMokEXnHFr6u+uzIoO50LOiQIzBBABCAAdFiEEH4h4N+5MFp8AeaMrZs9p +H28egU4FAlrWtP0ACgkQZs9pH28egU6U2A//XPKKR/Nrt8bazdurYfP9pk27dKSp +q666PNwQYXAQ6LLkZD106UAJboZZg18TUMWm/Sl3GTSNlEcYB58SdmdjPbc4l59H +lwDtfiwkIiM6Kd2vC90elbj8gJQ11hh1IUug388XbU7HThD2XKBGbmUoXN9xGwt1 +734irdxuS9EHxGCJh5V958GLmGE3urAn9Q3WZGXLPau2VK29DHXijgHT9FBrZYOQ +au28i+yJMrYszVSpqqgN1e3DGkAyGsuQu7YlkXfa/NVsrvYzSUtseVWli/AFdpnS +MxR2z6jzok5+O3j4RNQwyr2WXJhaUzQwWUqGclwemRms929x98R9TWicsq/9iOwo +GwBzCoqYvJpINP69Dkc9+lENcV2wymmM5AGZVAJp7Ja6b9Q33nWoLe4Dn/5rn7S7 +BeEMupzNE0cQQ0JJQN/XtOXY3K34EDfjgrlX5ZFq2HZoemOE87lKha3iRtbioUU7 +TcCkv6pZ6m45hL36BxFHU8+eMHSRBK8pCwLlVI0EbCypebWThwLTlVCSdDw1I71B +SNaDouRfBLGP8bC2cx41c7tAWQji0rGbxQsxg9qPq9WLPxhBIcHWSyy6HX17W8S/ +Go1HjPvxgr65H1ScQ/O2dDx0/YlQBtMDAqDOA5O7AQQ1wcRa72fPr4ih8t4KH31Q +scVW/r51mvIQQSqJAjMEEAEKAB0WIQTEH8IbJrqdmqrRrrdqNUoiHvvuqAUCWszK +AQAKCRBqNUoiHvvuqC8iEACiD+yxMM69gMeboowKpofUSbMJ+EbUvPzUXaQjK9l0 +zS688x+sJP6q8XqpbLNx5Q9q79ItA7mpJOsJmHXICLbs/zL3PDXQKQnhBcFgCNvJ +JVw/CqLmsXUplF6Hdn5hmdKEBIy+uD5du7y1BYuK+ZLKUOXGo28R7buLXFW9wpKv +jlYbt3NEm/7JOcKXxxUXITGDAHrfuVDC8gKNKR8dr/VLrO6q22L51cUfZozb9co/ +ZQr4G0YWgz3VIXVlxBQGObtpZGPoyIhjx+MBaVfm4BlwxgF2QcxN1M/IvsIYXhho +lefI9zoJYFuV17yHFfy3m4Y54lPofm7bmFZ0iNHALDET0gLhffymmSf/ar2Hk52g +VhH/GzQRG+/YB2p3TAxbctDwJvwB5/KONG+TmT+yucqS1L7oyOPUW+S4CAURurhG +f51OY1u8So4nBBJGCl8AGAo7P7shwdceJbxwETYg9IRhMaOwIxTH8p7GqFhRKnwI +sCDk4YWJbGWRycpVOo00dyk1JF3lzQNbdylwkPD9ClXoaoOKPG8Gdm2CyOpaOBqw +bq11tZJwzBE5JVdtAte5F8kYU6wVwuB6UfYXxwqeb3UdPCqekc8h1a1L859uPXZ0 +Hm1H+lGwt3WagXRTPq8lJOBsfpDMPDoH5AlvYwCoqZFLQacgiqeRahhphbOW/mEf +uYkCMwQQAQgAHRYhBEW+vuyVCr0Fzw71w1CgTQw7ZRfyBQJa6rMgAAoJEFCgTQw7 +ZRfyV+0P/07mJFiYH+QjaWRYkjzdphYsB9B/By5oOOW5Q4ng3qJ9jCPI/H17ZeAe +zItSWpAB1jRLLp/BPqsu8K7v4cZQHkJOqTOvr1k930DjguzcnP6Vt+Np9YNI7HHi +26knVZ2MZFfDsYHRNcm7enHLeBYm0wu0zwxaA8YPJTsiv9Gwhz0fKntesqVuVUEE +cO+XO76zfW3WodKj1M7KXGsCNwI/cqXm72igCMc34fErApL8vzzxgMtRIa1bIwaA +6kf68KI9Snx65AKb1VkAdAeOc+qWaSoZSFU455BWrlLMfHrNFipGfWenmFC3dVXn +7lut2HNk252E8gpPsNPtY1F1C9+b8BRVnReam67aD+ktaQwEuV9fG6p5XSVl0mVb +ggBAoc03aAXzVc/KAlIP17H68Y8QOfQ9SPfrebgEVy1xSXlf2av32UwIThky2Neq +dOpfnI7zDKClPcIdJZcNoDNT5j8kQBy/T/6jP7oTXAsaZ50loJzoo4wGhk6aBsZM +EwhcFLr1axYx4GxxtPkbH4g8TS2gmXHNo8lTqgwSy8HxHiU/9pa3YLbcmOId+YUF +vxisH/Uf4Rqjt/hiN7tIrk2JhUPWtWBFBzmuN1+j2H+ufXEiK8EeEKqFVlF8bQw9 +1lNntCkiCtyLxmO0njuVFHtNEuQlTD6UCcgbtydk6aQen7EaBqfZiQIzBBABCAAd +FiEEPeeb7+apgK3O7G8Oo1CEmSKBUgcFAlr92DkACgkQo1CEmSKBUgdP0w//e0yd +Om8mM2E1l9JwJMRUBH067QMyo6L9JwtYnjyNon46XSWhkYX8kEVcSaXKHXtqBGRx +rZJdQ8Q3s3KwCIJ2MEgDb7LR0kuajh02rn1QpNqhL8K8lgEAE9fMjZ+MMxdm3oxy +sqaOkN25X/vXN+RBCH0/wghDjZE1to5pGhVNgZQKTCXNPg0S0ONgzeyaGHdfMWlT +/LaBjej9tpv0nIlmekDjTeJXmp26z5xSljTCGaWISwhksL6iMnM1pGpOrV4CbMag +DvuoLxlMTngwzNVjHc553gnj/kjnDI/RuPhX5e2qRYKXfGHiCT8U8Q1Smk+1gdnj +Up542BhrilDB4SuXhKwfnbfX1fmysOhmvohfo53QZJYCL+asyUKa9ES7BlS4N2Me +neYAnTEsZ7ivAkJsK9qyS9+tYbStB7WpPCes0e30wEK5TyZGjSxRI4vKUenNOgzf +VPvhTr+kQxfmg9fRVhmPk3iaFbSSq80KY5BOQDbt1Q35BEZD1CdH/ZUTtXHQumLA +X+3r07VI9IG0ns4hK5MGp+P1aFLVhtg6oiyn0sP0ZEx93M2QiDdrcQk0+HjsNH3l +UPq7M6EJJp7BPW7S/CDhS12ZkFS46FnIlr+ZV8rznOQt8Gm8DxRtt8DMWibnfNm/ +M+DaSb9gmxxuUNhyjGdoGAHtoU/JMXyMXJrS5yKJARwEEAEIAAYFAlsME0AACgkQ +SqRu6efkbqrgGQgAjDTi9hdY7XP6iUM8LYm5j424g1hjVYSUFt2QFmRYrnggnvnJ +jr6yMuo8S7ygzngGnWr/1dRDWtITkYPmsac53NHPu9MpaqPLkDJj1NE77TbCdp+o +hp1Bw1DRD+6kpAEizCLxpXp4qex8Amqw6g1ijdl4ksALLJl9+JCOR1rGSj839tVA +yrRRFgfD9fP8YAPh0SYBz4P/F28TY4Z7zo/F4gAjlzKzU89r589Iia+EPb1tX3Wh +E2laeSkM0JNq4KiIK2UAcjB7l/sJt+IeUMZjW1M6vscIjykqgGqDzkATCOgXhLNM +e5ZcLefFW1M3Tcvqtzt5ckEngbbVGKz1jdw/QokCMwQQAQgAHRYhBFO+THBMycRh +pqPYqn7qMYioZ/QXBQJbB/rxAAoJEH7qMYioZ/QX5RwP/RWIEYTw5vFqfy2k4zh9 +eNnXuZAC+4vhc1wGsN3zE4kqzFNxU3NytrlJW+uI78fHwaLc0YAGV7kyVrd6D2S/ +vxP5AI0sUy89Yf3auGbGk7xzFIRGdguddz5EM46nV90S50fvyNoULtrJCjUrSDWb +l6itC+4DIS0a3zivxYs4Gn1ZhNwv8As8vTuI+x93MlzSMOBJulaMjfM+vsmDpouE +jNWLjr0ut9fO74PN8EMdA4H4tIm0saTqptTQW3nABkosFUQ/wmd777TDJPbQsdbZ +EtztAIvRYr5JX4HALjYLg/f5aZ+rkUgIMk7JQU0WGTda4t1Ejfy86wGWK+sado/w +wPrefudR2DmWPwai5tbyFRaLzhks2RZ2FvHJW1iPN5s+T7GKS28wH7yKVhEDRG1t +o6d2PzKXJnkdmcKz3MYTSOAGtLGyXCfiHfD8Ag4vOONxAVCMsWmnmHcO1n7T4gaM +QPWTkBQAV04l2EqdPHVlozKs/R3el0MLKWOX6Sei0Dn+B3IcIrHRDda4kaAm8tTK +ESi/I6fVp3WSiLwGyU241fPXrquOuqD9dK7tUdA5e554OpZDm5AE8rjkAs9rVSns +xKYgXN/J3FZagfFyo+zD079bvXBAOCaY8YTyll6uHQINi/f2v2sBWcF87dz9M7w9 +wEEHvbRiBls09OJ+WuGZrx9piHsEEhYKACMWIQR/aiF+3g5HHpmWTVr0PSVTUQGi +xAUCWw8WRwWDBDSNdgAKCRD0PSVTUQGixMaQAQD3aNBCbjny1Lf2BhoGgA2MxdUL +b/GLNKr9wChE8WO2BAD9GGIQiL3rm+OGyG0nQh+AOExUXdhCzdkKSZ046EUuhQaI +ewQSFgoAIxYhBH9qIX7eDkcemZZNWvQ9JVNRAaLEBQJbDxrHBYMENIj2AAoJEPQ9 +JVNRAaLEknUA/RL48a6sKJ7xbQ2WJd8mfm+E1HSINe5zRa8769QX8jm0AQCLyxIe +pyljZiows3oUEonLmLi0yi+hihoNHOVxHlXgDIkBMwQQAQgAHRYhBBy+SdQORk2O +9zNDP4QcnosdgjL+BQJbGo1OAAoJEIQcnosdgjL+yuAH/iRNbkxKXgLQqi1xZ6LD +Xdg47lVfVqpQDFXPUtQskYpDGaHX6LOrXDE1RQiFr6qgBYEM5oyYVPR3CNbtYHBK +7mA4Zxj9kcaLwRc7Ar5Xda9lpgNM1T0VsUJUb6EpGAWwXRnU0id2iH8v+/Rf4plH +bhOicyuZd7OrVFdHqRrf9dEDij2OKuVIsW2UxQj8+tAUy67hUgVF09+f2l0fcuXC +DasrVB+Rne7tLUxJRSzelVUOqnvEdsyik2ZD+ylZG+Sg+ah9kTT+p8afAP1z/8Dh +nVBhPQEL0AfzMPEOMvwFEhh+d+s1xfKKxy/pZela1SHZdIM1aqjj/Xmr/iotpt7/ +DDSJATMEEAEIAB0WIQSz8c9jDQyeYagL+AOjd6EP7G8VgwUCWxy+ZQAKCRCjd6EP +7G8Vg5auB/9XMtNm8XPLVYvlSGm3umGoqZRvT2IrF5gCYJQzJeWXBRtNP+sLmdhJ ++iW7NnkMFFRps+mUXZoLWmOT2bJERLhBcOsf5rLm3bc7oPYq9aoVI/YghOsneV+R +KBy0575MhP5I6G/jymLI3WsGmDggPi6YYmRKSpgl+KW72yGJkLogSpyS92wvtlPZ +1cMlIdLLGNJPU0GRUzyPsTrs1DBniFWRm1HVwqW7bhdQXFeEWBNLm+BojjD0NOXb +qxxy08YUBZW15rdTyr4wDZi4tdvopQARBacw0GSMhkS8SL6S7L1iE6qZ9nVNmrBM +X9K4/azbGlDbXBv1OxoscM0LBcMljsVWiQGzBBABCAAdFiEEX59mrLPxUc9ptjyi +TVmShO8U8ycFAlsWdjoACgkQTVmShO8U8yes4AwAxOqo83Xu67SAI3XlyhMdY+pM +FUupgxL9gu3st+voxa7doAVC1abZCsp3D/PB41yccJhwuDQyh+7ubH+OTA3R7tTn +Qpw1/tzsF1yaJTJ5M0oKkf0WCwUUXa6Mo/TJ6/h0/7ec4fdiqgM/uN02pQErwd5X +JZCaSvpz3yo83JcNXQeJa3F4pwcQExYiKSfG5I8k8IWxRR28ddB2avnmpXPwI86k +C3rb86jQA9JP5an3u+c5MmPS9PcZcrC4IQ6x+OIWdb99pAxvo+xvUiRI4d/Mn6+v +zyAwnx3MnM6Dn6BJ+8YOXqqPMCTbbYw9+udSinfBExGyyjGl1LebRDg9CS4zEJq0 ++N3e54vIMlLV8EAQFTMRVTYKtWf7x2nOlPnK0WWDxfy4F+o8siuv9tchP0KLNI+o +U4/ffugEN05OzrMVLGEjib7WJe4HX86xIMu3KCrIiSJ6YYZM9qnpLoqiofjrfEEq +/Ky5SdUr/EqX7Jkr3Wvwf6dc4N3q+zsTdAazW302iQIcBBABCgAGBQJbF9epAAoJ +EIIYRTMICZMcYdsP+gKiofLxPkbqBuE4M47vmMizzlevu5veretY4e/Q5eInHXHi +rXXeSJhvFZiG3eN6vE3gL7AzWK1qdFNY8v4blZTFF2CmnU3o6AhQ/HjqP7ipTikx +lfB5bNHV5DJB/mz/0C5a5BDjltgl3PgbJYHyRLnzc24xRWdiPEYq+Jt/KaPDDEzA +7wDYgV3aL6b7ZaxmAJuC2bzBiKwBhmLWHOlVkMFGv+2+M532gqb5GGIlH9bEEz49 +GnAVDKS5xQX+kMgtAnkqWRFFei3EhNiQzG7+Czcpcff4nYMZrhvcScNC5kbkce1C +Ld1YFdtqtkO9IrwgcgcUgrAR+d6aGqwFQxuewEfhrmLvm9bOI96j2zwVrPqK9plo +BwY2hYFZrdQXXGviHNPjNbPh5yfNuolZeC+iU8c51Su3rV+QHjGAKCDQLT9852Gx +Bnbj27E+Nt7RT+VIMkF8WLhGQ1PdMciX5rEbIZFzN9I5MxgvdGrDswYspA5/GO5y +ZQPEMrmzUdl2/Xo+JP8MH6OUO2YLG6+RaZ3e5Wgx5uZXdBFtfKkwxip/y665WXhl +GUhfewwX1H0nBrkQ1fjeL80LplgN3kWw6gca3BnfhrLe8mAnE4Yug/s/ZL+k5MsA +SdohjkGYSDWAmsmVugzmpdEXjPnU6yS6Wo4HmASNukNqwjwSB7V8shEO1ymYiQIz +BBABCAAdFiEEx1KHV8A8xRipkYkaErRTbPZHieQFAlrsYD8ACgkQErRTbPZHieSL +DRAAsdWPBk3kSefKrn2wnltBt60sae62lC0fmgQXHc5OBzb2OsLYVs8qfKYdRr9L +8s6oW+qpuUJWKmV09aQAavScJD2NQhvLJQEP5oKs1AZm/k/4rIrma9beQaLYm5z6 +Iw5TuP8MOqRRNTCxIG4O/mdVL5mc03rAf86gSB+KDt2e0qpagHPeIJQlwbVZwAd9 +h10eLmtwmmdiPM86cPE2FLPMXXjeVHxWY/1SMEuzhy1GJ1ifiSkX2T6YY2HU5Jyj +XZowd0IyacVwM4cr4ipt6x8bVQonV8B3auK36RBuIgXnooqml+wydgEOyflMf+OC +wpQu+Gl/plWBw22Rv3+I99N8H3oDid0+OLZRIBzLgGF4vuOKRx2DckFYRuLhSBcx +z8sBEwksrThcG0nb9uyotlzopvM7xRfXcTKjrdYtOhuNE+/peCZreppsFCBydMqt +qr/vCLSukxD7zR86OdLfxlqX8Hyo4xdjKdy+suse5Eaz0fqcUM5Y9Z/5d8BsLXPE +nUvszH3uAlS6+cm3cKJpm6mEcKUJut40LWDxlDkyphDy5Cbi3klEXFs+rgz9sOSI +toYIAML0+K07bfQ5Za2XUIQIvUxjdYtJeL9/3DQ8ReFDoC7hPSMRND5AS3Nlin85 +NiGwOCob+nxSt1y7nRHQQZ3OSS/5yZ30EoBRzxKSd/DwV4SJAjMEEgEKAB0WIQQd +MaMdfHDsm7XljXyMgWCK39s/oAUCWw3L8wAKCRCMgWCK39s/oNNlD/wK4Ui6lYTF +VwGDaHhewEuu02ixWAqsLv6hDISpqW0P8C6wpTQWyiU0zMPEYb1Zz6BUzPQPyeKW +b/ys0xMp/zV22hblxHK/9TI9ZfQrfogO3lasvh2+1RThuLWC74p26aB2FXRKDCbO +f5sMK0bjUqvAAK4dBI8A92pfVL0Ig4cy8uhbfKtS8jaPMF+en18sYZk1f1h5ngQn +Q2tU1Uo2gFu7lSd+Ep4gJ/9YnBjCSii23rqAW0rbdX3fPnH2ISI5jMFut1WrGnwG +jLKy2RRFNNITQjhiWnkVHaLDANWUUomLnrXDOJY0Z5BwYkyNx4ZGFFSQMv2LwU9z +DzMnbrTBobTeChARXFe0rf5sVWyk/SiYPb+R9O6oMzGpmVdbwYmbakCPgW1YrXXu +PuljMvIcWXJiw6x33orSyxa2iug0sUaqi33G9YVR7zdH5XiuVG7k7TKsz1hZqqld +2vcsnScH1jQt5UApC0ElAgYzdVqM8F1bfvbkUp3AABWlQmk5PtTkPnWm8Iio1dOl +ozXaOnN2Hc+InXO9fB9WKSFvwk7vdVYQf+RERPWKeEi57gOOx3YG1R1JLjAF73kb +JV5OKaLzxvk7lzfT1Lolcb5FASsnCPyin5LfrW+E9n+67iciTB2AEj/bAzd/4eRT +TJj4GaJ0eVFW2n57tO+SkvFyxsbEqBDULYkBMwQQAQgAHRYhBMPUf8i6Dv1ivCkC +FuPfGoGk5SwcBQJbKaJJAAoJEOPfGoGk5SwcHD0IAKjCbD4MaRwjOq86+2I+kNsM +q0Dn+0LOiEYyDXz5QSLYN1SvlCoGHw12xOr3YlNduun4Ip16lWLy2YvM9rEaaNDn +f7pPZf55R7W1GmkU5DvRZhcX284zK7czyIItLgQgOHhdU4yyG0YzXm8nXKHVPunl +nRsQuobjFxYDgFwhGfEVQ8X4aRCgY83ydOpIfLvOmDh9kdruQqz5/ghfJbTWSewB +VnZvOiTi22ZrR0wvWsfLoelrtcE8OgTpLe0yis/s5ghKRYNlvd6yJ9FtvjkOSEyW +5g85aKKfnrBVkiUlQw7NDyxhOdVirPn8VR6zwrdf2gdWxTQWk5vYq+mtt2C6OfiJ +Ah8EEAECAAkFAlsyS2ICBwAACgkQxWcqCbJaUQGiERAAz2q1knCKX5nY0TPSSAIB +3F7rwu8rDVmC3I6uBppr8J1+iWGP6K1EoMxOc0Yato38HCcMjQWe9dhYmVH0OXVm +H9CkYF5knM/mS1xNjze2YudQrxEyGWyNW489DwJ3DtncU4qa07B9LU7EnFXDzGKd +b1jcmEblNnsbXP5a1FK73iyychLJwIHk3xrvygCKZd7s4nJzbcFFNNMtR6Vhv94J +4P3tTX/DEDI3u6Y9EcUzxv1FANl+OwxIjlhYm0JwsKQvw1NZSkfKBDDGYvzK7ljW +J9egiMS2MATaYUNruGlhShWKCgtoiRZCW2nN3LhZ5+CAcEMWpzFbkQ7XZqnT0DaG +TUqy0hfcOYtytAmD2YrTCIDu6oqZy4L+XB630HvvLayL/biHtwv3wAqNwYGDl32t +rNSePnh0LNLCvIn4Wnma6jKVtx99bC9yL0cV885OjuL69Ck+FwjIbVqmesuV7bC6 +mEU5yoeYdUu0UAPmNRy7nYh2g6LmThvLWFQJSm/7LC3Etr1S87gQ+A5QuoE6RpVp +d2x3CvIea80rh7XjY/KeU3+61pqakdVQTMyd+GF44GLNy6C6kmVdbaC6mjNBvRzN +3qudJgCDqAkzm5afLQNSaC9BAQfzyBeEVriW0ccDc5x0OIt+/gn7U8UFGNdV6rB/ +5w0h5RLSfaAz6cPxO3iQ/4qJATMEEAEIAB0WIQRahFyXKq+g1bZ4NOJ557z+bMi+ +oQUCWzl36wAKCRB557z+bMi+oR5CB/4r3trGiVUwsRk8DiHn0b5cXXHcCb3QBZHG +EH/Hv1KyxN+w27wDzWpKRogWGNMKFxAUWA3R6tBz+xfeDXAAJkinAv0rvZpUtQZ0 +gYtRz5mhO/pb8RfrXg1O8IqWQQUfmjvM2sN60ZK5yL1MsIvMqJfObepD7kV7WYp/ +e9ityhcyycDbSMv0Ajm81gl6it6xqliKQivz/oAExl6VN4/43ov48nf3LEpWYhRY +ny52fCC9b9UW2FVCrTQNd2YrxTWubXkU+saliOarW/4c5GEqgxTZTDv5RjFS4DIC +G09h3YEKba0nu5WI5iXDxXZXpaJ8SvYOIh9sqGx12O1iWIY1eK9BiHUEEBEKAB0W +IQRU87+eXAbRlrXmj4WVB7xPkrT46QUCWz7FDgAKCRCVB7xPkrT46R2SAQCWbHhX +IjEoVtILp3cL8vHmM+E41bzFwwLciy1CgAyEOAD+Ow5/XHQ/A8GmjxImV/KJx5mR +lzHrYlgMUvrt0MJC/AOJAjMEEAEIAB0WIQSsFPqM1BjxktTO+0ebb4gnzcchEAUC +WxfhywAKCRCbb4gnzcchEOkAD/423cnz/WQ5h39okLADabkDm0HZEKqL6Ih8OdJ4 +yttcKqZXnzP2hhBwv2xZSBpYJc9Kj7hiZstLgyMl2tz67H05azsDdKG3Q3K9vH4u +hdE18vOb8FYq5T1tUF2fyPsHAHxGrNt3KRj0Fviprh2vHiROW5pXkCzZG4JIWqd6 +S3oapfrurrhK4mCXV5ixqgUQ5oZcLob+D0iVyk+wM6raYT5x48CX9F+obHnEVw+Z +29QeivnxFlLcQz5VcqjmgRHbkbNpOQnI9YYDuPBQyCsyF8x9Kq5DOipa0Mf02SFz +mV3ER/J9IuLrYYYu0PKb1UU05EsAN6kH3uwAYq8sKIC2rBKcZa2PeBDWjzcOzPg5 +UpoZOF6ldnHtk5vJg92wHLPNkmPnxxlrhtqMqHnZchGMPUClVg3jIMn/nIQpS8uH +dOQO19gol8cp6zMSgKYkReWno3jb/Q+KeGHPPBAIXT1eMptrm15KSjfogsCSaC+C +2oq/oT+3PMEZ4MFVTVEqLJ92WDTyGSFgfPaIqcfpib05hbCRmmTqZzCJ4GJqFpkz +uCt6xQqdsxSSLion1p9O1NwCAey6xgOy1yT9iCdUjq0/g1lFdbzM3ILWKJvxVBii +bCSMS7pU4DX/ee0mFNiW/4H1y/Rr7G81Lmnxu4yTehCsJ9q+1n+2ccZmVDX4cqf2 +ovHZrYkCMwQQAQgAHRYhBPJM2D8HxZ6PYeZ5hoIYRTMICZMcBQJbQP/LAAoJEIIY +RTMICZMc3Q4QAMUVjKZ0lOMB+NXfj8b6Ue+namNLWadQG7KlTk6I8Rxo9+WWAG6z +EHNyjjCFRUn1X3IIPlF+j/5EHEnASX/MPZOgCEmCb1NhgyidfPnptrRiUaNW4oVZ +VYo79htin2x9kQWB/gNqk7S25GrZwDEMXLSzqJ8hUGRy4Lnqyu2BZKDCpyHZHDDc +LPm+BoGy01VThV7Ufd76VrEAxYfJnOd0DFkOWPtOzg+ay+/gU7k4RDfRhpt8y9yS +7wuvm0w1nRyzCObAsZl5koo9nmMUaJimY8bPjJfOJOKBVgu+cu12GV9mRzWx2JFd +f2eHkDp52+jznMYPi+wG6759YHCt4fDpqs8tokgClY06W/HruOp9WHj/BfDew1zi +HFDjsaNC9HCte20eJZ6PmObUu6pTBvjwgzZGJR1LxOUNqxteLD0PiizIAvcuV8et +AzgVgYhIiUHsJWza0TeJNzWhf4hJDiTv8/UElrevFmdJ+VITOZQlnZbAfPftYVPk +VonIqiSay4R2z4AudYSwHtY8v9U8OZ634VvJ1sveV8hVGosPr1KY/Habredje5p7 +9SEBHJAxl3tBj5Lt+WtM7P3ukgRwOrBk5fX+dljYN44sdURAPNuu0nLdOv8b3Skb +V7MVCr2JxrDfe0J4mkGJNXi/FKUVENls+le7WPFFVKj5RzGu+277XbCiiQEzBBAB +CAAdFiEE/qbzhzwZg5NkRH82q/c8/W/jdkwFAltGfLwACgkQq/c8/W/jdkwtfQf+ +NVzplUnC3yLpXkCAOVI73cPOxK3WqSKSNCQwpHxCM0uW+4pzenBaGmU7RCs8RtcX +ISIWKOMsmly/ESh/qNx8uUY5rJKRp8j3Wfb1KvpODcTfjOFpKdF56hbFj6dk/QYB +e3qDGnTcds1Pngl+kbDC1kUmNG7M3YsU84KS2I/U15Ev/vF6Qq5O1RtOwdw4nB4L +4MiE/47uceoPc31cRNqPYprH4Qcs5rz1btnzxh7Ux1AZa3T3K5cGe3IwNf75gSI0 +vaGBGYChq/9LuX7YzjWjxkFlyvS9bEBIywieEKgkUVMKaemcF21Ch5by15AEKbl2 +36JhjVyoClEVamFMQMmKwokBMwQQAQgAHRYhBP6m84c8GYOTZER/Nqv3PP1v43ZM +BQJbRn8XAAoJEKv3PP1v43ZMuhkH/3NPbaI9q8TXHKjLvnMXedOaBkWzDmUwWxNv +BCb9q/DZxvSC+NsWo6KEID5deMvzgWuhlgZYhuSYMqiAO2JhQLKSF/SDRqSaZe9W +wWbWoVVr1g3BW5JsmhlIvcosOyjY/8ITSXRGDJBBbOSLbi8czmNX3rXbFdb04w7f +oetHW3jpnhXjWt7N7jaFy8oU18DACQfRYkuAywmarQA4pqnyiYgHz+2yTE93lq5Q +fNBdBGE9PSnn/nf+hGa/fC6E7PR97hse4zlqdVgOPNc3pr92V+RdVsq5Bb6K0C/2 +vuqzwQnS7ZSxBuFGgolvIcmMJSRqYXW5Xd4PsEqGWxvgf0toXOqJAaIEEgEKAAwF +Altl0u8FgweGH4AACgkQHB6H7CwLKLWZpgv/X2YcAn9UnmygZFYgnZNWuGAbEKhL +IgA+A2pMJOtXQQRykUJIC7s44EF2/QvrnNi6AuFL2w1KKPw5QuyKVxB4t05vAdmj +srnuhqbmipgOMDrfa0H6FrKDXcxvJajHKylNWRNXU3JQG5TKv2+YIqg8GJC36hbq +Bx7TdZ9W9TNM8aT7LmolR0bvR8NaoM1pORDLv6I2QtbEPYpw47/c7yCL4YRCKPXI +HbIsfm16wdVSjejZiA1Aoo5n1opFVvPcrN68Jhn3D+cU+1bf6DXRqobHCFgOrYSx +r/1Zsvz8Cy0ebM8CN4bIBz2fsx6nxWwguSPcFhLQRpTZJ8HFUQTL2LHiuPBOqTp+ +0gLzKKxLMWXjMhTAJ4+16gJuyx6Pa1A7rj9OXlx1PUZXyit6tIjq572h2HcQNnT9 +/OTK26zU2AHrzfvH3tHH3daZOljXrFReC/P4jnhtdKiFOwuJrmPfBQs7CgspIEhC +UifFLT1PKvcslgGDdrSR5SM9Nmc45/aG/OXkiQIcBBABAgAGBQJbb8SAAAoJEDLb +4U8nxzkd6wcQAJMfkOB9Vk/c+baQWaLj66PUxRNbwTwzRU0wpNlkLARS6bV9oB31 +ekQMhovoY4SfjvCIFgqXK5zyqHhEDiKYWlLenPFQpibgLAb7P9fMwc3PumgRCwXM +jH2WdQ3SfnDvCHSjg7UnqCXiLaKs29bBcfas6ICqWnZSlDPwHSOB58hmrekzt4z7 +yk3hhw0dZOEhdZm0Pqa7/6oAqiTbE4DPqyUhhcHFakjyJrGWHSVfwIcffsnvhf2w +gA5gB+R8mk7q88fRm0PwTTplpnptwV67gA4qiaY89tS1uiX2/ddhPWsKsQwgYz79 +7xNyT0C3AD3o5779A7yLMk+utsXFOub34QZec/REsLw7hOESCu8fBVpspUMH6XAF +h61OLl8KVuhzUaJHyt/2OC5YsLG58MlgORYPO71jB3PB1MEGplIJLRHav3V4kEtA +R5fNvCMDjNuH2OA886xIdL8xGfbHE7UztzvUTmze+HAiUb/VVZ1vvU42mBYRqjAg +6Eb36KOkL2ZyqxjZSGysFKAvMu3fTeZuNFR+X5N0rIz53Qg3Em20f86HO8xFh0rw +INjHr8PxjrXnFMQdgkOcDoYw5a61X72HAUWfdvZtR83PVhz9t8e1KghJ0DqZ/cWo +9e1/9ajPtvtrd2391vKxsw2QVI5KXzvTThUwBnSE8YowDHbUcop/e+R8iQIyBBMB +CAAdFiEEM1tv3Biv98dOf4M1Xx081MKweT0FAlt9K9oACgkQXx081MKweT1vbw/2 +OBZg7YRuXyF0To6FZMMijNFHSXWWTWj8CjRBWKvQcrM5uzXHAe+dt9UWV/Dol8+m +jiHzAppOlW52dwbYENLbA3q2bpv7ouHXmJSxw0DiSJz/M44OLzntFp6oi/mh+RrZ +Fr6crONXT5UtN6ceBMOz90kHAaKPAFUDn4/1G+4aE6LtUti4wTe8HMatrFQmyTx8 +vemYs1T5jqvdIa5s8VoijO+g+aCElqDL6YKUYie7Ypu5Idtd9uE14ZJT7WIsES1M +3iktptCQz21H9icIYtPxadfqANyDSmL83+cnTsunO6t7IHDu0lv4ZQRG7gJ8ejE1 +WUyxpVkC2c4Q6vH3NLycTZgj8VKGQ/pci9fkLHHYZogKf95Dfr3vlP5Vt2QgELFA +TJjza1LJZFfl7MFuvnsBLREBKzO8Spg5H/2ayAfDj9uFnHa4Cz6wvnIGTOF6f8dO +g+l3qC/ZTCm6hI6cScKYXPHT5yZAtg/hZ6cIyBvp+GRbPU6fJ/COv+FiZVot0AN2 +NNnj4clu/jzbCTd1RlTDoupRPG/Ny7girCegQKD0C4Y/uYoX6LNWtvJhIUdHlHoG +m3CxvYvx84+92mGrd8jeFHZOOvqkavi56Xcmb5d/00A9kzbPdFvo11nIU/gkYUwT +2SCKWrix2jto0KkkSQ235wfzSvPMhkKnDL7hAH/JN4kCMwQQAQgAHRYhBD06qOp2 +Oql9olIHFJf54hNiDwcdBQJbexVLAAoJEJf54hNiDwcdm80P/RBEIh3E/38whIlf +uL7IQBDuZ3APBHnIjgrMYKHuRRHGoDjpiZMcx1LMJQhZ5EffnWF4or4qzl/I+rnp +5ipK/1YET2764HC2+9DQv/bZhO6rie+FtKtfWU+rCLe7d4hdesPb/s2/5d6EERay +M4qU5rpTfzlZZDuUXco/Et+MoNWUdNVs2qhP6+31D8GnTCwFXphWfTSVf35xm/LA +t8DyvDjXYFSn80aTIlnMkY8zPk1mK/RamAAf/g5TGBq9aAhWeTHzk+zy+/CUl4Na +y5JJWP/fihRhprrhwvl2JDFrjHKD7gJ2pjXdtcY4Vn4mOuQXtkxClMe/5zfXMfcU +Fq86VbwRw56hW298QgktYDwOuEh77eLOTGBfbGhG8H15h7FTOV76EplJhKWSaOM8 +dSLj6b7w6n0Otc7D3meyROYuXC7fZZk319ImiH7pfNtIG/O/sDAhooevZaXrKfQ+ +4jqVOml9W0k9w+nq072sTAZn+8s19hjcYoqsfMJilGxGodtIsLF3asLfARJHokQP ++8Thb2nwp6ZdArs43eA7S98a9huGmBgUHA+Ie4bd2s09FAIFuyGoHYYVEOca8pCr +7P6Y+Y4CRCh6Grn2m84WxQKbtR2/lg3REwLzY441LHOhoyMh8E3OOX177ryG4kqh +eH5QGpMd1Q75rB4Ser4nBhdUHYJsiQIzBBABCAAdFiEEZ5/Ap473p1qUHw1U45lZ +iUJBSb8FAluQiekACgkQ45lZiUJBSb+qMA/7BBM1xZMHuYeSzwOq6SpMRAynb7RT +Yy2di1TQ2Tmw177Nu3LXL0dq7VEw2CRxyUuTzXwPzp92e73bdVOAmN+vlVBQ+5A8 +e4KeeLJcphGclb8KVw2FcaZxKgLK/tGdQ+aUvJxWzGuRx0g+QQYkpsnp3MHaUcqG +fGQokLcyV8+VHIm9gir1nzJ2Giqm0E7b7XnAtnLXGE9D0q/R2IrURTUkbzXBDGtS ++ncUm+vsgBbeYGG3c36Dz9SxcxIPuaNxZ2S8ASYUGjR2scf0y9vFQA+n7nU8KKUY +1v734cCjhNvg4gh2SnyRZdC73rrc5E1p9dUw897FPcB6UCjQCrYWHrWJt+mIXzwO +wEg04r3/DWzh99Cp5Mb8o4owfokETDZ/wrJ8afs80PnLSHrnR1HDuZWCTLy3+Qnc +MQAE1NymC1LfYCn1YHjj0MbSfItXeqhzW4kfHY/gX4/p3G9V22jKeiAPm/+U9fBH +UL24Jts/sSOIri+Pu87ioVoVKmw39mFGuMg/Kb2fFKNqLq0EgO6+HhkzaMOnlb6K +yYKlTGZ+lSCixi7hhM4HQwV9ajIE2pN4nB8cEOSim2/WbCm9/WTXWJ4jvk3Zovr/ ++LPSaAUKfcujGZY6nBYUcVHPJmjR2PVzngKkrBb2kr7PnV6SRiZAHQHv7Cov1tUr +VBnln0vBTpw1DLeJAjMEEAEIAB0WIQSY0yzH4w4hIQKQA2z8qKGVIjGfnAUCW5U2 +ZgAKCRD8qKGVIjGfnIuED/4nDhKA87yjDQjEJ2iuv02j8J4l0clbLSz3O49+xQPU +YV57C/uIJtk1jpVNOk2Gr1W0xnpfh+G3roPx17Fleo4550fX70Gwexv6jNV7L07D +6xR4Qq0JpveGOh1R3YL4qkYeItH7m9hqaAhctkcjQQ89oNFL4+WUedUAWPUBU9gy +6YvRx0KiSGI3qTnTa9putszw5ZSgwpnz1A9FQj2AWmk8vIL9g4m8P9vg0yBfvViL +vjbUx08Ba8KUycS/01oQn3G/kkqR+iennJvwZJRzD9zYl7BwGqpgrAKK2Xv8d+JM ++a6yU23kHD6pRx6CuBe1ztZsRqWW6NE9q97ytzX55A7JQywB394eSpAdLvy3hl8R +DYcWssknVQO7BRBSKE9scX4asnrozpUGAstqdCKkSPx5Pjed8MW/CnfhBP9KdVqH +GnDOeGzIknwgJycl0KxLI+BAUZ18I8YY5RKB4LXVgPAzUIhyN6BdzOmaJj4Hm4ia +Lq7yhOgDP+1cEONKzkvc/MfY6ijYq9rblZX/lxjD05sdlYPekRwxF5Ed0esH/Bzl +Tv1BbC8NfYKSiVY9ANsDMNvCZn1UvOYDi4XutcOt25pEpCPv28lSMWJkcg4OJpVY +FEiPICqjpTp4/aorsV0DqmDDewIyVNX/KCgntxyM4b9eIaGwGQhnTKWkKeT8KySq +r4kBMwQQAQgAHRYhBDlMtbIBwpLPBqeG6+qHdapqpeHKBQJbqlGfAAoJEOqHdapq +peHKsgcH/0LyNGMeYplg2t06Zo7KwD7+hnhDwfViu6e++5mox/nNaGcp48NRAEEb +zGQWX6RtYGl3hEGmSKadyHDdETbBZ47QFJ2HxOPVoVAY+QAdGQIRq1oh9jPrEfT6 +cw8DX69Jc1FRYYDOhvvDa0mACkF6+E2UG/464ExbGdHDfG8kXWyxVNQOA/HshFc/ +8kGFs+TnsvGuBTggqoxXVkUWsTL/yt8nmWh/1JCryAo3y4HuNntUfJSMbEH8SERN +ebf8+GdvWeMCuLG1Gr1HtxblJ3XWpoeD1WJNJGOCTQc7UJzzLEDP9euNG3E8queM +noRhuUFwnk5LRr5UzVquBDHNHGydFkuJATMEEAEIAB0WIQRAscE1zN7OQNJ/m93t +PQ0P2ULWhgUCW6oyowAKCRDtPQ0P2ULWhiyoCACbxtnj7QeudE63+9tWF3YuYlYi +VoJrilBTu+jUWUPiOSQJJyakmiyWe6rPwmOHVHbjrnw3tVKyoe8vTN8Xw56rfiJy +S8BQzkDhEi7YCjQfoBJ9OGtthRxMqRVwdK+tsA4nD0i5M6brbXgwNgMTv/Tob+W5 +72ojj6cvgjwxB73+YTPCPy7z157HyGut66AlfWIEiF1c5aTUqt6PT4JKN4nk5FED +GuwHIfLq4WWX+J2hZbRFlLLUFl+MHK3zrmzr+J5aYilUx4P03LHDnu38fkwxSHpZ +eGta1E70pPpUaaC21Pl3e0Vf7wOBqiRcmTGgt9/xh5buXRo/zIjqRneQJOgmuQIN +BFSOr/sBEADKozhKT/c1dbHuIf4H3kigdq6VsvNGlDKJQakbTJuMKxVRc4nu4j2M +UhgawlzvNQWiUEf5CC5X/BqU5wdL1ybhhFdxsXgkCLeFpxim1d+FIf0vBv9XdB+Z +5Dv4w70Cemw4qM2HiXyaKltwEyc0U7ZN8w+PWmp56M+9yDgYwWn8vi7GtbAEugaF +9c0jvlmK5C0l6XKULMr+CstYRdMyC1A6yhe3avWu7uUQXmwPLUj3mwzyZSYU0sT9 +Kw2LmJ+wOVJZSgxIfGFv9CRAzrxl4IZn22s8FYonxU/9Dy7vd2RB2E9zRx/hnf9k +svThcga9bCV9jEa00rLV1MTI2iqsLdo/hOhFMYDF/kT0lSakck1ROsnUhImMqbXH +XbQXmqTErblWZbHSupdx+iM2OuFQhnhcMl2NRx1DNCqZNZ4h5vO/2yfGZjkJig1b +AKZY9JB6FrX98Yg1bS1ViTME1U3yAmQexaOX645oluq/ZFG4CJt2uizbe/Xr+h+7 +k20Y/goMO3Qb28j/gzrcoUVmIEtttBQFBUb4y8/UdEPKw19yWFyMJtBRKDAFb6fw +Tx/60DGaX/uI/mh2bt1nCyH1uOTpO7vAveLxRnMvTZNVeY59SbhWvyg9+LxJV5DO +GhYN/rMwJkSiDFKxKAZtZZsBu5zToUiZ/04YsBDYVqEBDJd6tW3UFwARAQABiQRE +BBgBCgAPAhsCBQJV3aG7BQkFEViwAinBXSAEGQEKAAYFAlSOr/sACgkQcBetzvZc +IDbJ6hAAxbiuUJdQgLdALz0vN8lJBDhx48YdqSvOn2AMADj6+ETvC3oVhp1V4viC +I4BQyjuXuG0Av2sV5ue3OKmeCFEPniHA3+s7jt0kmuhnDIpXX8kHF0wVtrCI4oPy +JknUz7C7DslsIqa6tXzwsgEWKV8zWuE4r+K08qT9GDc4T0p46ybQBJnAZv19JR9/ +XJ/zzcGocgboxp7iU58GHAjM1yTD/g549uR755j38sBHZGEpRUBP47cyyF/aXErH +RXGbroGUJcmHpj502UYlkycdS3epxRnuZBj9G2ownfAGyWcI5rSGB4XBbjdMq3mt +MwzMK3lWgR+s9aIkrXo7PNQrKwt3Nb5GI/lWeSCPGDV8TMQp7/Gvrz5EFmi7dGss +4L6ZeRGsooS5nTA4GaQUeIaXvNJc7/gUVRqk1/N4OviyfzJZMBtA8z/57fgxTORp +Qq4pwdbGNyYV84x+YOTW+1ye65c5neBo5/W+IZ0ja6Vx2shix0EfXzoYYX0W0rBh +1CzDGIho5ec4IDBN+sPyXO1WkMgZYFo1T3jRx1k46qlc8Ic1+CbyNkf+Zms7ZRSq +U4Zpbx6EUgyEgTOTQdkcI7QMJVn0Rd/Z1+/Xqseks7QP9/r3cw0sUVhhI5OA/toF +jDGtsnScvSDKbEK+zNbN3f2N9zpmFV46fcnLgthgqzIDBPeZRcYJEE4sboeTKYKQ +aUkQAKmIUb9kJAJEQ1RvgKoFI5yORKWGERlz2TObvPGm3ZS1UHh9q1h/iwy//DIr +J35iVr/AYtYoHIdFvJ8Q1HbYyI5xnGi6VcCKOA2V++ky56/49jtSB70g4j3RCBYE +hbDwOQjAjlEpre61ppN8GMTBkgYQVn2YDY4+tXuWePlrUnbGPAS5i3V0qN7bq+Zr +MbdfvAPzk73AP8svOAenDrz8AJBC5JcguPwMBrkU7nIOvLSAPetAyMySCBeOnSdY +LXe+mFqJxR6CMTYUV/8HcvuwmtJ8oZVyLrzsji/+/it1V0v5VHRUAOgV9Lu1jhdN +POhrOwywCxdPRqprtcOOLutwj81RRnzuHzQjn/LxSi1KH3A6ZCu0Bb1+t1UwF8VD +ZJKvtCinKck4lUM7Zr9gj5kFLvRv1tTXsSw2sSMGykPhU/nUlSjRklE96w4A7/W8 +nHeD0Ic/ROLbhvk0cS4sxao85+wM5Pn09L25JkQPvNw5sr8sdfC46RG9aVqEvJi1 +R7+JnzcziuDbgH1FsU/1r0d8+2l874cVpTa3y2DkqeF7LLzxQaVEuajQeclIikSX +eIjE/aLhhu15DZVKssnyfWhH3QoqtMgfHaiG/WhdDlMfhovcErVqjW6F59ZOjuqU +q03zhLf7ikIAJVUZ+6O050R3xYzpKLPTNhdAEWGhnEdUCckLuQINBFSOsFYBEADB +79YviDFjY6mwjFD0uw105uCRsNRfPIH92B1cEhe3WX1HR0uH2+uX1bOAD2nymakK +2pdKowyLCNqGYLnnduPyAxfSSGFl/ipLOVmxyT95OxpOvMA3BgZxjEqGirzkLXPy +9/+wB54cZxb7bA/GsnbVHwTSAQYjcwF7H6T/1n/rRles/u1Pgk+8BN1AqLdhK2/1 +HeT1UqvBjB2UfiKOOV2w2RBwrZloLN5fs/M4eC5xX9xz/lLgzZdjwpsQKpfllziN +zWweuNDvuGOLCMbdPAt8Msyrhh+pCJUb1xr2O5AviTX5/KDBtZJynju1n93Q87lC +vULwhsTZts8jm7887ffpQr4yZ3aTRFBA5XvG6N8Wo0AXsZughWCN5bmYxGyyjCNh +WNFpd0dmxJgpNxvp5UJZnP/ubO6pmGUqP2Z74KFA01DIb1cqYE5MnSuPs6ELsneq +hR23ilmj6+nmSI3TuSd7eb/tlmxYwKl1v/Pax7/WlWmYli+w5LJqwYL8ViB64k3c +KbQ3zWHhTpyAkJAh6lKFkNloK1g7rqF7PrdGzp2ujSRykjWZ9huJh2aovLVL9tiJ +pGGiFVQ5pKBnInWz79epw756FOpttn4vQiqKqBVTSsMi0c+7fVagjNmdk6qnOTxr +8N6H9XIaiDldfAA/35NZB7XynJ/S/QPV/m17hVIPnQARAQABiQREBBgBCgAPAhsC +BQJV3aJrBQkFEVkQAinBXSAEGQEKAAYFAlSOsFYACgkQLhrGjtQIFOCSoxAAl61K +CTOIrJBf7UQnOu25f0FlcuEQ0JVYXAn51AJ7iK++n9xI7mKqw+nPEGnG0xc4IE8L +bWF8dPTH9wN/PE/42R1f/R5Dxt3MaYKTZqv2IkIcQlb3bx6PyBpKUvVDLeH+4RY7 +C+3ZVtee8rPDkPHIEUkNAPxRHjL8xOrp4u3GGeJXy5K0vPeqNJWsov7goOwSkYc+ +OGvZWFqUPnewRQvq5jBJO54VoFHi42/qC9tjLFbp20ROHJRCmL8k+tweIprZsybH +RokDyv/scwnMGKrUTiPa+3To0hyiOVNLNT/z7122Yqc8oTRcUzy/HzkVvAyUlunY +XdOAfoqc+GTBDJMsDTllPMOhHr1bbOw5OTL7mrj2bEjUiS8lWZgfS5Y1zW2ATBrF +wuXtTNPUb6OV1XSo/D4GyfYqQlm3H7tRgUYj3/3KxB+Tl0gVp80Jbfjc7i/+upED +blgip0Pyu79ufEJXh2GOfxO0p+MUYjE2uU3Pp5mJhgcldMDYwZkcV1qbWeA2OHKZ +dU3w5e4lhK4qnPmTpkNVIouYZDekr5vGuLvjkoPPGZZ6wxELUEUYNnXSpxreO1qh +G5OvSf9XVlbk126nXxqlJ7lu8GdBSpTDmpA0IqYC13MooAvw4wFBkHfUbzCqEQPr +YCST9K+awwnYvgmHFMo0X8Lg6lMnATc9R/P5UyQJEE4sboeTKYKQUoEP+gL9exaJ +P2o238YgQnmmW5bL7x8z+1XDHWv4Hgv95+lWWSuUcaY1Wm/jnoeNx2by17iT/7Sy +D4LMZ/iIeOOgztQJ0GbHQgT2HL7cmDYAb2L8hYNuFgdsa7IDElDX8W3XFDIDNwvA +lv7MSFVDBXVDry8ZIohttmU3AMoVRQn+9ZBkYeDbBnlJR0xiHw6sq5P+m+yIvzrw +a4+8L4z026mhaZDmD6qi5L+j7ckOp/mxe27sAMPD0x1WvxPGNjqMGQcqU00K8IaD +6Y8JNtmYwpwfyMqdNgnZ8a4GUCjAnnws3a6CSpDBEBYtD0INg9HtgQecxh6Ts4yC +s+d0HfSE0XAMOMJhR40fKb69VIXSaW4ShJ+HeyVuYnlGg0+Ufdc86e+3d+OU4FOg +IbUSFA+qQLpHjl4FaxtnVRFs3EijK4CbkJABrKF0if6CrDxB3TdW2aoBuAJq95SN +1PhdIM5EHZFkb9wV9/FQCbHxMUcKnVA4pU+DHd+0aWUyEzFxoso1eEIGlMvuOltz +9lIyZCDS4EEsgTkPYRPIn3PRKBAfUpQj2U7kP+GfZ3t2fbNvRyN1WiqeBKwYJcSJ +GosGe/dNVLoEcCp9KJzk0vc+UU/j5AaZe7FPQQrlyK+uV4ZCblKnNOpD2LLU6DAk +6qHeLlzFfhE9ywdqqBmseVjajG8KdwRvxGMMuQINBFSOsOoBEADknavzdE/HW/D0 +7rX5AUVbZHVab4bppClm4waDeAsAPAVWUgH3YDQhO+Lcj/pOz2vNNnkAVBOn9I+K +w/BO6IRjutb6N2SyCDDxgkDi7bzk4TSlPGQZwj3VG5OprGz5p34fSoc998xpI6M8 +697i5EQyqoMArttrIMTDGvks7NsgaXo2m+JkkYJTYBIJtbC8aCFAV9g87leo4ePi +d4wgkjklA0pfBxdxC2gXmzaNlXoBnbzqkzijy2afvHf//Hs4v1utsFIcSZbSbBT0 +SsN6xZCHhoElKIOaKF/1fVfWDtFLA5gjt1YMubOG8nLYArhG8WtmT2m8K0YKWl1I +Dhrv2uTwztb3nrAiYSmwLh78IJ7Wjg6WOj45pzQP/UM6yoVKQGKeI3kgDcbXdrSx +TPp/x8CuJ/MsZwXDNnanNlnm32Qxzczcqghr/twroE6Lqlve3ICT20uyJBDAFZts +8oDHs8d8t6e21QudNksZBrJy3MPR/qmwUoNNb/IYilbSP+4xUUMQB0pqUDrZPmO4 +wKcaMddtwRjrSSo7MZFKNRhJPqyKQpLp/g5NdzZWMOAzbSCj0AZ4MfjgTYvVy0tL +OWbJXzsJOH8U3SZZjQBi5l77FcqDgLCaPirexx+SiiiS+2FKxO2uufBv+mbomMvV +21iONLS6SqwKxaHUzjfVuvgHqhtW0QARAQABiQIfBCgBCgAJBQJV3aDtAh0CAAoJ +EE4sboeTKYKQld0QAIsyTVuD3SmvdBIgFS+t7U5c+Pi+GoTxTV2HgeVl7f9n2Uve +wfJK97hT+xpxo+6I4+P/vcer01ohYLh8N2RqSUZFnqB0S4HvngMZfQF17TA3XiZN +Ic6ndeDY9t3kZrLKKngLUJtc1z75pgtMm35uwsZwCHb2TQiE7eCdIOmzKsnq0due +dPmWOpgJTf8euSTX5ht1yd16OlighsvIWjo2lq3EzPQUdcDPNuuq2giWpI2Vy4Ti +yVjEQL3GCMKQnSigE3vgHKA0+TfIECZoAyY10X7LRiz5CZJrvYZqPQHy462YbakR +nsZmj56m9nkEr5c7gA2brsvRsiMefrfOauzh7O+6cmAZvPLKNi5CW8IS+dVzSVus ++o9Y1/bm2y4GZiZQJMfJzZlTFj3sSh69mhPpx5EZrkvXtkyCu6OXLrZbdDLiEYwc ++Ui6wepu0x+eN/2Jvof71sY10hhTnjH1cenvM6TQ7uFpkT5kfEJR165zoZVrsBWN +5CBmhFrViMWpSs9V8mYo2lp2fgCGwJ3y4VT043MGpMthJtDQ0Kgi8JOI8LllAcs8 +FbqzSZMAMJYV1Yd3AMlfH4sA16KSOEc8q4HLlvsi8grF0xdBYKeys2JHy6OTPThp +Srz1by5gs7vqEYn9hBlQXRo+/uuaVeBN/2E3c7MPBHWAWSin3rcQE2PWSXATiQQ+ +BBgBCgAJBQJUjrDqAhsCAikJEE4sboeTKYKQwV0gBBkBCgAGBQJUjrDqAAoJEC0A +CYhYmDmjtlEP/3JlkkpH24Ej8AE+XBZwt4qanBb2Pi/vzg3Ke9t7pyMH7JWkg7LF +GSpQTIG4/HOfRGahG68SQNKyPS+MUwhtqQrrEfOGnmXf+TS2F1TqKVGIsFpNiNSi +5zW4Q2GBlhwDTsPGOsnAAjlsRjkgwwegq6UEDJYTz3X1tkbY2iFH4oSr/hdpgOeI +4Z2rHQmgJNGhpHSZidOP9gYZMFqQXqRaZevljMHtaANJTQoP3l4aMVvAU+RMSusN +Jc6dv+D/cGY1bQGKTjlPUnR4+4NV6R+r2r2qUJXM/DX8Pgcl+mSyK9WGkKTrDq/x +AXI8sNNiwj4j/rSKPwcOKPI5vPjiLf6p6xKpcASwRZUDuTYrMug6+7sqhAC7+zBm +xMSZt945wksh0eaMkQxSOAWIqdj3RWeVgFCmb5aufpYfmHdwX/LgtpYzGQ+hHeqw +KdNDODFi581Jqz4P+Cc1nO0vleXQWRIRFiXrD1PE+8a/LrRu29i8RV2M2UauY0sq ++tljzGyx85UUyHc7AXTbAZyS4KOTwmx8CEMRl3iaB1nfmEx7TDkQRd7gqQvwIByo +qFOedYqXMdXvGhcqbJDMWWUR5ZUzm8CnsXjvHNn09VfRr0JxJ+e9pdEKWPc893bg +fN7PNK6R55ejY0aMBGz7qgSqSyMcN2u1qN9fakUA2DhZvU16ztAg2fDGO/sP/A0o +vCkg0TcazG4TBNUfwnEjaAUK0DqBkiS3QYVvUEhIzD/uoQE5Hp2xpq1cZdZiAsx7 +ql4K/iVvdg2z8EfM+gNZOUjvFdcTnrF+84LdrMuUb3zWXvZpommtAsXmOmBtDWqh +dvjgOb76R14d78BjnDePNa0y3SheJUIc76c3R5WFE2MLX9zCMADiXc7GQfoxiaYU +Yel0vpkwAbQIoFxQD/dNbEX4i/uNWaNZ0LZu7IwVYR1RCEjmxWS03V8L05+bn8Pt +65mOV+Z/ANkCtVfY+MtA2BZNT+HVvTqGp1lP5C0cqjw7D46/BMtFHmchLq+B1wXR +bnMtRZ9vxLVBU2FmjzqslZdPyJSk5XxmNOeupf5+PJMDsfz+DxyFa9+rROlxz0Qd +Xeroun6c45thYAu6HY52toA/SIRwHi34xtcL11x3BQnmR3X9QdJ4nIr8WABm9DXP +CApfPVjHyqfvyzMw9PAJc89ujH5oJb+sycdidG/KbjBLU4jOBEqw1azMXsIm2eHC +PXtYPOllxj5SGdAKYnBZa+vW0yD8yGDZmMFqmm9raptDEFUaTQ1jCJFif69005jT +fhar/NuxaO6kfM4z1YvA8qCphc34MmtmaBO6HeWxoO5XDO1IcxD38GVDKimmsJa5 +86stbBiyYtEGRK1IR6N7VPbB2KgLVBDb7OCwu3RBiF4EEBYIAAYFAlpeZdQACgkQ +G7icBgI2dEmfOAEArA4g32sKvzQ9mW5fpd/kJvITXLqSYC8wbw/MtXsow8UBAINQ +Nm/XA29EgBdstsGRqW9Wsd87EPlaQcPQkGM3lR0PiHsEEhYKACMWIQR/aiF+3g5H +HpmWTVr0PSVTUQGixAUCWw8WRwWDBDSNdgAKCRD0PSVTUQGixMaQAQD3aNBCbjny +1Lf2BhoGgA2MxdULb/GLNKr9wChE8WO2BAD9GGIQiL3rm+OGyG0nQh+AOExUXdhC +zdkKSZ046EUuhQaIewQSFgoAIxYhBH9qIX7eDkcemZZNWvQ9JVNRAaLEBQJbDxrH +BYMENIj2AAoJEPQ9JVNRAaLEknUA/RL48a6sKJ7xbQ2WJd8mfm+E1HSINe5zRa87 +69QX8jm0AQCLyxIepyljZiows3oUEonLmLi0yi+hihoNHOVxHlXgDLkCDQRXvYRg +ARAAq1mfFMHMVjjgfb7HCZdBT+q92yE6t8yLcnDxRs6mjJkCz/pGCeXlS6fK7JLp +dCJJoHMVqhnnpO4QWdW+72Yw/AqtVKVGy0B4dcz3Wd3k/dbqIztn3iZniJE3P3x7 +mkHzrDuC35FP2I0siG11n3vFVEXDVCLfpwWjzR2hcQm/U95L7lEbtLmKMcruX2DN +ZZ/TJ6xTy42Fh57XgU+OPIKN//7z676jZOIzVJViIX+P0gYxfsVpajifjc0dPg5g +nHwGEezD40Mx+Ur4pRgYspSkEuzfJY2Wc1gJPRIPNzR10PBBh0uwBsKWTNV7A981 +XTpsiKDuG5KbskeUhhizh4YpdwxE5nFIzZFzBsX/5MLvafmyzq3Wj+qv7ovgo9cs +nIycgFbOcsOJD79x84uHjUYXZt9f4W2iotpkqwXI/t9nijhEN9bbysEQKuB5Dpx9 +LCfn84O5TPPex67nHvmPJflW8MwkON1I1ATLbwg207ZeGMUXLHjBgJjn9EXltae/ +o5GFUF6gB0AFMvROl17gswv447Rrqo/Yp+9Xxr9zsU8z2ZFq8bwIaA6K0GYjJpSm +MYPT0qBiqf/3vvGk1vf5hLhqCchYY2nh8zHNCJYGR6pdsYQXLRL2CZfHXa3GZd5O +7LF5jFSb2wKgiblGfGgWiHGGrmW03AHX8BzL9Gfow0prEdMAEQEAAYkCHAQQAQgA +BgUCVhAERAAKCRDCGFJYGfeEUapsD/47E3WAIkdNQAb18RbIg0cboq6uvz4Pc6al +iYa4Ihkh97i0NPh4wVm/x4+7FEHSqr3qsYend+dyUzp7OJYw3/kmE3gCNxWVM9WH +xPiRdgHM7TPyc75/DB9awPXZ1FpJ084EdGKvHdz8DI8u6qYUN9lvt22l+kakmmd4 +zinsvbAdJXOi0kcJYH7QgyEvufQst3ap/IzascbcyuKtQAer5bg3bbBj04ZavGS3 +EwbusLcoOyjJSv3/aFz2X3BriS85QAxDQ/YLWT5JnBIIiIBdAeeXbTIGBzBUZBm+ +n57csryczcnE8kkXyPy3aIUcDvsFNjJu3L/bdC2pINueaTWZUX/D0dmVwDXvojEN +wrd586+mFTM54sETWpqEB7iOuER9J0Plz+l0EhHaoi3MwjWVM939byFPxXyMwwlD +UbhAt3itGiEXKBmX6Y2wUiIYYtZijlNYa5j+unp7iD01xn+8GvwXXSCbrwzCBitm +4tV5DsiP3t/5o0oHk7x55tdSHdcUA9rGMDU+hw65upnQJjF0WPAD+ENhdRvJz39i +lanDyhhOlhLSD5uFWvHDgTry+ox4O6lYZcTq9IbFsubug7eysEvLi4ZDCPfpirlQ +6WEOhleV/844dtNZ0RyljqsC3qNlHeFGIMmLXi8qd+4m8rOrMBEkk2SrkyWHv5V2 +nhrguFt04YkCHAQQAQgABgUCVhPy8QAKCRAT2/zQiyI2EeG9EAC0uG+RdmYGtLCy +NBmOBWYhX34N/WQgRvJe6aWl/CLaYEFUE+82FledloDR55ofvU35sPACU0RODhnL ++4rjAe/f2qhV3agPIShbaOYPXIgaXZHqwbJS9OykZD8hoN7aL0GsMgumP5kU6664 +iMcIfsNARRN3gdQiEup4AEYbEMgPLfTMBgXZu/mG/F14D6PN9y2AYzhZ4MQVUR77 +2VIXOMyUh+jhGwa+NFEK2ClNSfeYunjZZ4uZn8W98SvtDpCykcSrBUyQ0/+qhs4/ +p8jjaTWfJApnCi0R0JLexy2iHMwNyjRH2yI6prHbxdDuMtlXhKP5EK/1Mtui02oI +vOVWyXQMQJVKy7wtDn/c4YF6P4iJ1WAtiouV5P4oL70gHqfnp6If5/8swsrIGbCZ +FVArh5JJWSteeI5iO6M4l0Mjq5r6omqo6WSn7bKj5gMQlXNMQjOqZAlLDWJHCyA3 +/yEhQbXjG1KmHXgDF+B1Gi6o+QwSy5NfGWgKi91Nrmx0m40h1o8i5Q+5ZngYQoBy +948TUkYdK2gpXeRL0E3FXIrO06rx5pfjSviqJwNo0yqXzKjvKynyOeVa7a4vNdaj +LKYCyTPl0EtevhXbiBL1WnjqDcDEbeIGE29ly+VB5Yc6ej1UY1EJgAEcnqcxHFNH +7hfzUgufjKQHd7JiL8IEnbvEpircAIkCHAQQAQgABgUCVtg5hgAKCRBAPCZXzZlP +cyIgEAClyh/BlglZmQMDZ2RlzxAHnpU/9VhqTL0OQGvTOJHeRLUHWLs3vnZ6RrE5 +djXzEV9WCQeoKQG7qdriwkFKM8NATeX+3/35JAxXWadNYEGoazEiLizxxWuwuMC2 +kU7NjOyeAHXXTgYRbGYHs0fZnFnmajSuCCwIWREVjRDmMKaC9RGKDyzFxog5kvRg +wlAZ6tijUMRaITIm+Rbp8VXrIfIGcVwVvL0RMBoS6ZYrdXQsucylWsSgvcHJq0ha +9wIjt+dU5GMVYzWr94ikEurdb3WwGNBKH6ls5n6mysM99BPh814cl5nsbv1wuF8b +2qbNFQ7VSgXjArE9xhOJhcbwftGzbnHn2UF8OcpXg+GuWJpqEhdu95ZPqPJV0p+B +HwT4b0dQb3fNtNBTQho0ZQPSD7Eo53i7uQWbqo16Emg4K6hTCwkYGmTR1YFKPRrV +TLs95oYUSUAcU2VdxAHHWRjnXp77vssRbxDKvOwYtvt9/Wejxy18Uzfz7etHUO9m +/eWHi8so4bY+tR70WH9mCffW7Xikrq7Xa7zKLONLIhni6WIa3NPXZXj24BKLs+dI +tKNcEu9lFD0EaYy9DJLfET9VUO0aQRg1GKKQLNQ0363AVaV3NXNinTZDl7lnzTbL +PwBDw1ul/yJjiBtfuNRdFicH05ankED90y4Gn3m5AMUzhx9pJYkCHAQQAQgABgUC +VuyQBAAKCRB8MYgMphHn2QHiD/4hu2JH7zjBJtEOIKU72N29CRQfU0vsViUC6Eli +mt3KUZStpgBaQUkgxTPTZenayE1EkjgIls9Kuy97lD5oa6znMEGHc4HscapfPk3k +juURDyPk37qPDQATJV69cq21YWpckd/USgywgRxUAmb7C4qso9Sxns4eDrRhWJDR +ejO0DXMFlIKRrcAw2Sr6VgfMoCZNB8RbBTyc78yOUcFzBmogkdBui7gqzLtcHQFG +Xz7S5ApKFtKpzsi2gwNgWG29cuubReuZd86U1DpHwXAg+I6c3TY3fCOSxqEKp2CD +U+lSJNtPRYfNF5BDKgZ/IXo5h1ivwDTx9SpUznUYR9iVy5+auLo7ebEZbKELJxas +LxYhFhvApzN8u5IJMEAafnF9hRQRET6AUdQmo/QIPFcq9mU0AWPtn7qs6x1/fY8S +RF78g2AOg4QIidqz/+NAVsVoeQIYXx2YxGizE1vLZeFdXicBn+EGTxbzjZ2s1i0H +Kys/v3EA3dqmJzm6ph0+vjlOoCnvQrJm/zOXuOLk8j91e29M0GDZG6Uwns/1WEa0 +VvAFNyxeT6qW5fUEUrFQThq4v89dlC7fpz6c1/mloRDc7HZhmoFZAzOj71UuosN5 +PUGEuZe4yEXBbL7JmXlf+szuDuAE1m1yupBWTPkzbEKbmRnwdd2iTlFEhaf0JSIg +HCELC4kCHAQQAQgABgUCV4C7ZAAKCRBZcSzK7rVwFZyDEACej+0TVb1icBvs/Wi2 +AgCMkjg2StWURDE6g8hShWjoY/qRkvngktGJOBJxifr2Kd1W4116sn9MgOYRpwhU +lqhuENDAo30pWE+goZTviJl3mfp+DPubED/03fJuaIfLEuLtwGAGFMP5yh8R/ifx +uVPXE2K6DtkpKxfwidToHLdcG2s5o7osoXxCcuoJE+DUoh8QfjctZUTe+2QM4bh7 +b7qjB1TeJmwfeUBec3j7a+b3GQsBnFFsfSf5UVpS2zJnU3yG3k7upoe/9gg+5hxH +3uC2Y+1F7cJKQFxniOSwyCgZHV0tyVEY9OqUiqS5UyoVYfDLuCMPr6CNItQMIq4s +PhOgnlJPqSEWUlX4eSdtu7srr2lsA4a2tsOwQzx1vizkm8Maw6coB4JH7fUm7WiS +dOgDmG/tySCFiNv2SayTeaaLtF694EOwRRaJQl18ly5WJcYcCMkgEjXRv+F1Qbta +KQv7/3gRZ3gA+txCgqqjmm0DHr6DPCO/nxYAs5vtVqb6qFR+j+XnOtmqK9zpOeDY +HNRvpVBaiR9LoqoicXDMhShhBDStp37/67PsFHqjuM+8nnJnjGoDMxrBkDsAYyc7 +8qTjhjGI5VC8uQ60XmMI521qH8TN2JF5MaZnJQ9izZTHf/kzB4M2vUVATYyCdSPt +MMudbkMC3VttjTbnSH5ZIIiGy4kCHAQQAQgABgUCV8jTXgAKCRDaOr3cF2zvkKe7 +D/0XLTBN2cd+iwlqJ3gdy1laf/yKCeN+MbbhO/EaFnqpM+akwyRCQYm2YYONmAcj +cvopgdql0ZfOzxFwzC3fedEaQG0QmDfAeg9sAkyn86Gp8eAy8lQVo2DdGXERtpEh +tumHkmE2zuXTRdcJX0B26DIoxpBhvQ3bu7y+JMN0xQ9rpSd80xmVCu/muMw7HAhf +dqfxV0fil/C85Gg97kuzd0sWlCi6WlGj63OTmNss23ZnqGUcRpdcNMm20LBjjRNa +i/iYLWpdj1bLPZ9IWSoJvW7hIWxX0iaUX57N8Y1PGz80tulDIQCuX7ATiFq4A8au +8kmJRjx1C4hAAeGfj3Sep8y9xU8adBU4Vgoq6nidJ4OOdCmm1VAef5cogJekdR0c +a4KJE/+ar07L3WkOPD+ZWCe+tWIGt+4qYOqBtiUgnXPc472O7Aa0m66o8/4IpFjr +OsR1RflPKFXjLLsKs1tnLvyEYbqmbfE+0g3KdteJggn8MRA8dyJFgSk23bGVnNTD +mTa7S/Ngs8lsROXGfaku7XPxAZR7gKkOJQd2PWRAVrygSt7Jdog08rrOwYGIAQaM +Ag2SVXXdxymSxZumgzCjTpQDTSAdIIXqEM7aJL3pTBrP1bDYmt8mvacyXQyFqvno +xYuRoET2kiXnxAO3hg6pHrtPcw17Jsgkk0WrQj/sIipW6YkCHAQQAQgABgUCV/Uo +vQAKCRBqoN5qqe0Ov2tQEACECE5yQbk3lK58Ugd3sk6YYV2c7oaXYzboOXg09Xol +6A/qJQ7EF/Och0HAla5epbcnHMWS0k7EJQP1BPxtmJqgR5D/dbxgN+YIGYBMGqnA +N5ELOupaex4c5U4TPbtegs6DB6HVIyIe1oKkM1J4ZiuluQajE2PGGUMR1X/LQbRB +hvEUXBFha8l5x0YaSqidSExZB1S9WhQ9/jPJI1c01PZQP2oGyUBasKpRgsM+DuMd +hKd6vGENoI+opa2dcvyA9qAiNXIDkCBqiCrXXvCbsaKc444YxfWDNF3L8gyonxJ0 +m2nI1w63burUttY6HQswfmxJ8m5nS0SIIYs4dHfM7npLMiB5nw1uiH91ZCs6NrH6 +JCdVxp+zCu2XkmW8xE48goev0m0PV5oWAkmehfpV0uB+3L6jLLe4GA8F6woKiJ9w +qiyBJoQoY88DCijh6Ki45wADzLcgg+s83KpQO5ZaY19k0sUJRHO6jJW/Z2lFgBbX +a5zO/6dgbXqRcpDYIzT02kGeRSnAhPEAghxyFYjKKaCDLOpxKF9gB3lim5Mbs18b +4QHQoFyD/thwFCZhoX3VHrZ96JP0pDKSeZE+OOW68gnFsauEmgmEK8csmgUX76f3 +RegzjQN7tIcH5mdmddR2SXUKc+BRyeLvQl/LIfJTVhc2fDDlx9II75/mdfU5AUVt +LokCHAQQAQgABgUCWBSYvAAKCRAQScIEtcIO1phrEACRYJwn5T69DJqJebxXKWyM +uNTWzfb2FNzuw/5dUHi/AkElAZixANQ4T8aKAXSx6GdSIz3AKN4TGi5dxxzmRUJx +7OWLgAc4fM9V9r3lrTQpm0fPABr8o+j37bgZi60VtHnjR9uzbrSUsOGpNVcJ+r0a +TjX8vN32Flj6OtVuXqdgOOlgsbK74QUtooZi/PBwhrhSiGyL7PZyYm01ti4SMr3H +l1DU8Xbdsj3+iJu1F13CvWBQmYbvjUO+QHLL0SkH7AjSv1g6DhDwcIbhZvyMNOeY +vWJCJZAhVWlSTig+nGOmLrODggQcUb1mQt70oJkmMeq9xerWKQPkRgKyKx7n1Kwu ++5Icm56soBN0Xw0UDcEhGktuLOo+tVzsn1+BBC3jSkmqVTHPV3OV9AmkX9EA0yJz +DdHW2gV0CsdmjPFDtkOlKoiXf+ubWYzpT9GWPnXa4sUzRLxXQZdAu2QV5EiWDGdS +zE/Ulus2FvCXg6JDYntiVsGKa5ilsHPEVt7j/+EOuuz5OVCnYtkOvpMtXXx4jTeo +tirLGjxOmRSYZAY5qxnlYa8QfS0xWwBzDP+I2GMR/8XdvnrqSeL9bQKOwLGcrI45 +S/QHLLhF+n9lTqKLGfZs9ZqKWO79MjIJvcwBqFGs3I6pIMdEZAmpOI2EZR+e3I1i +KiTnATjBI0SmJbuMdEJmiYkCHAQQAQgABgUCWESN7QAKCRB0UAo+LxIDfrNuEACh +5rveGrgFvbbbdG3rxdWpzkqnrkpFIZVSeZrwhGWyohfWS4nHVnwkwowWC9nP2cEJ +nhtUU2STnPqY6HBHXFvYCePop1MO1JRVnP+6VThA5OUlrMh5I1k7gNdEtjfOyZV4 +WO7TfwIyTJyBjPqRKF8NouJnMctzREQtZFqxhwtwemetO4XHuCz5tqAhifmQQMzN +lt7nICNyKnCG/2Q8KWJ9MC7rvHHD8Pcf+du8CxFRKH/NVaQzniAf4JabRBA5xz5h +cQD4HJLajV74EB3IvI/ja7PZssN6UgAdwceqz9PYhL0gfk0mrRhbi1cFvMcft3LO +VNtdcHSfTE8RGTUGED7LS0HxauFF87F50aQKgeZnW72NlvFEAbsJt+GrC+OM7zMf +wWkW7iF3xfxSmfiJvb1w09FZD7ZVC3JwwQSTnNCyXwzMV048IsptX/4C9/75P3qh +cM8SIxuhnz/J5HS/XO95ccmovU+Sq+DgynJXAVe+UrH/zG+QPBeWTjKrG7ROsVi9 +QoOYe8tijCdw5xn4F2LssNPDX0f9if8fLBBpusxQzhyVigiu5t23Uy8xVjvEVb3B +l+/YkC+6HD4CzqCNMM8CfvSThVYdqiF2htbPcnpIkA6utajGS44QIui1eDqitn5F +Xe4EpHML5YVyy+QjmwQPUFmKxsSBg1KwcVkqXKCVeIkCHAQQAQoABgUCVVs7uQAK +CRBbghqBO5SnxB0dD/4/25V5mUo9Nx5ztl4Ht9XnjjgIVo4VF6PxKlo1m1PBPetc +drYamdzTxY+HMmU4SWuY4UZtqSnaPJfHWDMNDhCN816y//F/VgUYlek6oexUg3vs +6fqNxaqUVQZY15MZYIdEI24LP0u2zMNYU1aeXNQJV817pYN7JyAyJRsc2kWclNAQ +0FijebUDmwszo3+ICL/5MxPwVza1+h/uvGZ+KO2zsd9JFvJCu5Xr4eEKBo/jjMHP +yBG1c6mDJdD9z80GVTyiZe988jqAJWM4VdRjxs6EL1qDVw2c8D0YVypUuCgrbqS6 +o/pZxGALWsnX/FUy3/sQJbQtCko6I4ANcSg5dYYF1mZ9fkdyq2VHD/8s2z0hcxPN +Keo/bS2xh7Bk1shdhH+Tux4rLw9HAKw6Bu+f8Atzf9bed2j9aILMauPiMlXpUNX/ +g7UrNxBObgdtTXjeyn7XjKu2cjcbhfnjhBxn3S0zVvuaDgo1L2gG65dPu3fo2Od5 +b1LnEUMt8njunWRw60BbUIMopoVQiMTKE/NJWp8Mlve+w1gjnXNEsICME8DiwAZQ +iV1FgDFMVV9+l1Bw5h2tsu1ngrFn3IgrzjhF9tJdUeNzAeSENgv0Gq2aNude/7pK +hIrKcGfS+kkezGFe9gPkGs/2UC2WYhNQcoSr0xMJgrv1O1IG84JqAJu1U2C5m4kC +HAQQAQoABgUCVgVDPQAKCRB3zAv9xNaBBZb7D/9dG3q7COQM+MVhVaUzmsh51rvV +epFUc16cZoeCnCPm6pmCX6ZAOZpLaqvPhMUgYrvSJy6g6ftJ3QbxcJBcRtNTR95f +fovQghrIQufVMHO5zEOLaIHINhqXpIYloB6PQTTg6SsNGDYAxkj+imw0TOvHkBIT +Qw4PeQp4K32IXrHXXHMeCCwNMBTxucagGZ/eDmDuLA1+mxYffSrUFLZXQlGJwSz6 +/JUUExMCTTaddQr0Aw57trkDwsRF2pT+Z90lOXbIlGC7iVQyjOfbRF9Qc7jEOcFh +ngUU9tkHb+aEVSFbVoR1BC5qhBlweKPOVHzmGrRFB508LFjj3VXc8KYcBwSMVRRx +5zt+VOTf0DOY1gx8OW/vlZZmkqcuvTjjmt1UxbotF0aCdv331/CL7uTMLTMgAlz5 +ZNwFPyuCBJ62865W8L6P3r3BpiONLjuDjerGJGWkRtrj0e7CiY6Ekigi9QAeNUNG +qKgTB9Utn8Zd5JPKZ4qDBjs9mJFwgbat7d8Le2ETzdB5m8W5ygsuhP9hG/5gpQh1 +d0iXPVbNNSs4hmcT2Pgc+HBoJBocLDXNyhaXybMAjqge+//otliawBVlo7GBlwv5 +lSmW9YvQEBwKvHgIPs0HfZGUAejWm/SJrkCXzMw4cxJYfkgWp/CNdKdS6zlfazjQ +h7t7rXzDwx+1Y+AdT4kCHAQQAQoABgUCVnbamwAKCRDHtbXsnnODoeKHEADILox3 +597d4I9JP7tfx/KqItwgtTIEA0/EK5ls+1A9jsH+szPmU5nLCWuEMj1fKkmTi1bt +0Q2hEYnlk8W1wV2x+ER+LiWLEeNlKyVTEpnVNXAgHwedUvXp0WeTwso4RD/zaA27 +Lca0NoaPqBweiKv8dbQkt6Bk/YSQn03w6AW9eKOIBJOfPPUWbEhKa6izf+9wsTzb +Zpq1/yVA+/PrqEJ2mKoXjappqgrfOOS6pqu+MBvHAJ7HRxLu24/JlaEWAVRYwTkx +Pl27RPp01wOUpbv2Wx6JjEkasL8NLvtmVp4TimNC9rmdOMABWqFKwy4X5h47BkP4 +5ucXjiqAEjb5lVy96Gq2UaHlqavd1jZcL1XjMdHaxnYbO8e9cs6vtZKeKqKfdT2z +69xwiiSxI+FW9zNfjFpnQ+OGs2p33AwKq5eIbplVQ3nBJqBcu1MuTfxop75qV4An +t3mvxGiiOKkbZYdOGRdnIp+1LCEnBPGgBDekKIKG4IONjfC6Z5tkQj7rutrhDTzy +ak7kb7aurF4Cn8zocgtia934HdCuI8wFVXvqmtWeE8gQ0Bp19bq2UvdXxgHvju8L +kYt5M0hcwqCJWNJRrvK32i+f/bS4HsAkNY8YSpea436p55prrX7KNN/KIqRyd5PE +PP4bKHptV1uWuBvIfs9zSnEI2O+Iv423qmQuvokCHAQQAQoABgUCVn5M8gAKCRCr +1zgzpYbQ5kWSD/9aJ2DO3qydrOKYKDScbLtu3Y9RtMA80VkM6Zks1aGwEGqW1AlI +OzyvfMBNZuCLuFNxWc6ekTdVBIQvRP94x0NYAKTt/YuBPacDbhVDJOpHSTXBy33p +6JsK68sBjgdIsNUePPo3u8+t3sZdn+3u+9KvLOTZ2JKIs2NGkfua8O0Lvcz6Aw9P +80NzEx8foA+b21iykcpkVcx/Ze8YU82butSXWf4jZphToe4NxbEgoVpEWX/cWZ3o +1HU46HIjV351ElAugVw4FSmvV31KJHLF/u4bhxE9r2b6H9vSSsFaEFuqoSpyVMPs +VLrvPL3tw4fVJZuvP2wbdFHKuxTKeTcuk5hU8SK+PM8zKQduj7mOF7jZ8qQIHljs +Oxd69AfejwU2NGsmr51O1hI7tSXC3GxC5E4c8tuVdWvIxlWsZgyBPmMEHsuAz1bg +tKW78KGsBNV71CpuxglSRyTi05lHsSN4jNjYJzSwXCBbxpZd8jylIRArLbtAZRe5 +CPD2pDUnh7d1HKzM1yz9YiGoDthuCZyFXWggRgkbDCtQoG8yd7SsgEH7g++67J6L +jFCnOXxHrWNivoA9UNUcvbGQwVPZSHHn1xrl/gOKQUG6hnUum31X3aOhaOZQgDbx +5gEPmV5qSc56gbGwynG1KTLKuksnQ+OSyN577fNLpsX94emMuVbujctJtIkCHAQQ +AQoABgUCVrkoRQAKCRAjJ1GJuOdibDTTD/94MoIw9q1OzNKopu7XoHoxptYxN8K2 +0NDjKyNQbjhb9nymfzVPmgXacZ83AGr83Aw29Ldc5lYVcXn4h7z9xg4GY1f5pNyI +mpW+R1AyGm8uscOmuoTLlZheKuIUgtfUHiV7dgDeznl7eAUyM8R5G5l37XRekv42 +G8gu/pf4tvFPAewg5HFztSDnsEDYILKC0PzniFqMSS9hhfInheqq17+tp3Qmy/XR +aCLTSHpjOtlDLuBhEZ0RtDAXANHxz38S9Hsp3n9Xyq3V92Z1ggyplGOf+gytLX+T +f/9q6EBOsiukjANXbBEa9iYdFGHTUgtv7XQI6Vy/llGVAk1TtG8pk9fOT3iPLPla +eQS06T2QyQDztQ+UEnMji2U7aB0lb1VVVPe8bSW3Fxjijr97nuMHqahMx673ZBVU +4PAdrc2OumEYdz/Tluj2Dk/Qa04p1bPo7Km8ZFfxB1AUCgfuwTil/GA7P9DMruCK +FfuP/nM39ntr0pKtIVk98XKHP0dDeQo1Z3O2zY9vJwdVa0hBrNWaDayAJcBpf7jT +t+cp0Z974nkgY8GnAD/153m5cmdH04W8WK2o9gTlmNdI6MZLQDWQg9hWQF4FlyZz +a3gyOrosY0+ze/bUu/yg1a2Dzz16RdBxqiJIYd0X8NuYjH3H6IxEYrFCoXTmaSoU +TjzKjl7wgc1/KYkCHAQQAQoABgUCV/y0HgAKCRBuDt7TgN4x2sLUD/4g6p41RXL3 +qYp4I7K1GRXwkaN4G1ttkhtDzt9CusrmKG0mnkKY2OJA09udaJkzVFLC+kQDdqlP +pBK5XFFAZB8OMaDUDx1ItktOiw3pIrVrqJCsLHo4egWODNUcfWMSANmJbRLzSNDs +tgrCglKJYRD1BcX1fEIMpY0U76jR8kveGt9Tjy/1JS0lhaV/pi/nheMN41ZU9GEO +B7inYR0SWUsjIZApHFNWGPLwix8SNmzlL0HC3/s/W3Z92Io+J3S00FRMMbh8VhTG +oyHcuTfblrlsKKWPKE35c3Ra0W+RigwXACD4Y0U+WTWD5UvhZ0AJ1g4bhQdtNPHY +/E2AmDpi1mJGAC7gbu+kzLSXhJPL0a+JHss/776saDQoS1RN1cSeRc9FSQdyn7Ju +rC97dRkyr7PSClhRTnl1OYsJxJIs5AZU/DXBPOnNccYQROYFYiyl+/DTTnja+bHN +aWzbobqLFWQ8YdhE13IL8EQv6tf4mjYfLAKXin2wE32sQn/Cf46rPJrMyK/JsVTM +Vz/Dim8qyHCd7TtRfimn5hLUbsKLoXJQYaOc1tnFerfw+21zGTvgAvPyib6GmNfZ +FBw7qs8Z3mw07v2nEMYFG2bVkD1AEcFtbtK7mMy6gi+HKrv28gAaAbzr4EHtEPS3 +zdeELglyBeXyB0KO4/lGhDKnaxB63BQvjokCHAQSAQgABgUCVz4SGAAKCRBqFMoJ +25auk2UBD/9vWQ21bbtZmXWnGVlx31Zz7zZERlNUmPNsX3C8uFyOPrW6rQm4ImyY +5NNGlHlApirf3TVjZAEhbMiX/hoMN2C8ZQHYKsQBQIae/giADnyGccE6/7/d5j4K +3hQoveKeinBzuR/sURIBdN4A8wVJzbhgfl0/UvEDulQ3qntOfVX70o0s0Qruy5QQ +YIV5cMdQ68pOM9zSJG9Eo+h6KXj7m25bckEQyqM9xq6vZU01gTRmUuGVz5EWqofN ++G8riUhv3xdDGTKQ1OVHS1u1SZhWDwsCc9gIOqAAp7VqUys3celNSW19T6Z3U5Fs +MVpIc6MFEXeHUukjkyiRLg/XYEJroqZtMwpQ/uqPFk7vyLX90GWJ8vGeIo28X+cS +/cK8Nse4eE91LCLA204BLkhF+2dE2/cPpF0vr7SToJwuLCUUhwmfJXxWac4IgrcH +lkVdwuwlDYNOrFQcueKOPTCSq026dbTULndkBTs9dN2mvDMK5mz27hjU6+wotUMI +MoCOmZ5MTqOAGt2DCzYuSGjZz32PxJtk24ECybL68zAbRhF+RqazIGyBmv2FF4Sj +0GgrbK3UcJJEMuzglDv617Z+G5OPkjL/jprnVUVXueC6+1nDXE12FDqBUriz6C+b +/wyZg9jT7duOEOGssA3NhBpWzdr7zkFpRnJTInwu1EYdUOAQeiKs+IkCHAQTAQoA +BgUCVufuIQAKCRAvmfkhu3flVAu5D/9ovMPlNS4H4gZ4bAolcpD2RRXUarO+vnic +YWINR5AnJAih2gJVXKfDDx5qHFx0IxfHvVcIlput+0ZoPGCIp1js8Nb5FMpUGAJR +ziSf6FyVQPegwFawSWV3/+RrUftURQYTW6QzZol6kUIIEg+efWgnqMPEyebXDvO0 +KNieSjvGUm7MedfWGySkKq81P/Ets1q+nvBKzTbwsNM7UClt31uhbvZUIuG7vSLW +pvCaS1MWwNda/ZHffvETbucnL4TcForZ04cDob7bQ5LX6dbS9siFbcTaorfgUqZL +YviOfrK02n4htGIUior9d0o3VTBT4Y+X7XOH0UP5yoYQb1AXrv9b7Gftd7Ga77J0 +lTFvRAnfFUzMfdp5oCEjCni2UoDBEWOUmhlyk+cXsns250tdkKQ3UWc5FuJuF4C9 +5o/JmsflFI7lI90Mo3wBprX+ThvzWaDABGIDzmrCDWekWRvMBQ4kgRUKD74xbZ1y +UKVMEJMiKxzi7SuBgtdjrwV8/6aDdPmg1MJbabK3khoUZrle3tSkK1GGTScYxGWT +zDtijo4SFKA6kT0Ge6HqpC1XD5wZUnOfHJRwze/oh5rNnkOH6BsI299InoKbNiNB +ag4xiveR9zPfUP1Vn/8qDihu1CtTEhiJ+M54ukj3lH5FWnxtClNeTuHXzsnGbsOp +6I7+I30G0okCHAQTAQoABgUCWJHIzgAKCRBSuOLwgqnPgTM5D/9cJ8Tm+3fuJBXI +DVR+uqlSVYQ/oP9rlsKueTwWdYuYbj5aBj5krI5hh2m6LGJN/xYgrl5lOjncKUTv +3Q6uoANwNPuGPFjoEWOc5ICt0uWRqD+yxOexN50iQIYnc0UH4OnI9znMh1A0rh4R +F/oY4ivzcnwZgnXfZpbHCtMmHSEk2bY43uaOFxoGjBgdgg8fyf+dBcBDQHFPgWes +OH15dYWizhImh/0E5MrVbFlPbnNF90jl/jKD1lBHVzFEP9mUVKTcJM2sTxJ/M6Ps +mD4e82DD0k9cyK8/pvh7hhKHcu9Zq0bodq1cDu6lstuoVwtqECDy2a1MeLe4m+wv +VN2C1Pbo3VCzxg6nd/0uOk64kLVvJjHNjNJeq2SA7TZKul9kbHC7a2ypi6mhS5OY +FyERYYOaeJJ16JvP6zPKO8ge9Wszhv7m04CgMm8XryCZywPIPbKE1hN9ykjDSe3w +PXTNSpMOwZFwWDS/MJtIvCVPb+W76Z2vMTnu72L1rAduInNiiezczCkUb0LVibEY +lzxfkYQkaegYuiA939v/GuGdw1k9qY8RrUI4L1ppGeI9BHyeZ2TP08MVUXPWUXjx +KlcPd/P5sZtChcgJNnn1SskU/yhKDTx7Zm+5hEj5JrQSSmWyQpKuu46tkGCC7DuQ +EIcvy4PRTE+SJlURE/UyfKt0orLPQIkCIAQQAQgACgUCV4CdlwMFATwACgkQa4qj +/cna96rAcw/9FaHBt0d1fY3urcDKjgAcsh59tb2vSD2cUqar2M58UEfVPqNoMt/s +2yjl9wTDfTt9yrUlIeJlXQtmemtZYh5Z+F2MNe6BIaOsX5DOEqzoEK3bxQJObX3k +KUX+zSkxKgDKbEPmgbOK5X0cdE4bDME/zb1DEbrrYwX6e3e4fZV0rC8z0DDuAwcA +NvE1VErKNVzdrXzCkvfMGRiOjZpxLY3A9AbP6Lel2Fj2zssZXRjDyhQuFDIJjCNj +yS46h4FT2y2wEa6LUJDBUkLzq6txskJLXar9Uo4S5OjiOvNJGLS5yeKtfNfhmvLo +s9CapjZZ/a1FjARXU9ybKqRo5a7zYHOUqexUOFYv19iVhqa5jw+7NqKMsXkoWHGb +yi4mhiqX08Ne0oRKUidgcgb3QC+Ue0fSD+rhNYCHPfTuLe77/lNr+f8CfBl7Gcqc +C/Qf65fWi0xuIltiYqC+/pGVMI/KRB66tp5oPPpsICy1pCdNxYxAEJrm3WBaavga +bULxCWmfuFIvyRPzv5TMA1DoaUBfqYaA23vGI7+sAt0YRXkfgAAjSaA/BeIIx/tK +MRkXpC3HluLgb3BuSRaZi5wXDuCx8vdTIlA+7EJ84ustqYDC8hcIDG+/6rnDa7Nt +Nm7JvWTPjXgKvsyWXO51L26a1sUnLuzW8ynUl05SVPFUnsE5Do0ujCyJAiIEEAEI +AAwFAlUh0uUFgweGH4AACgkQPfx6oTqYgg9bGg//elBtDplqD3otCCiayUjl+kEG +A092y4GedP24DcwxyHzcL/KsPkwZWKHxWk4QSf0OUSkLZc3Hds4D5dWFCru5sv8g +I6WjugSp0uOy1hjg5S4r5iG2m4SF4svdfjgBR9yvWJEet43Mwb5XobYYJXG+s4yu +SMj4ds5st0Pr488jEz9uCUoE5xs8dCsZfGqpm/iBxkd/e5nIKK1UeqaVdLF23A6F +kGg6LejdNvtpcHukXCuYERNR5IR0MVmd2MQSlV5RaduqOE5xhrqr+cFULw/g+mQg +xuepZjKubAAsPLUvqL/j6i418G8uSvFwtV+2Dsk1QZioF727nHFnPMO0HrGlHquh +buzoIzjx0Lw0KTt+wTGf4E2k6ik1Erg1n3w931MlWKDP0lK6XFan/fZ4mqJWqaxh +eiPZ2boYtDDQxq7zE5v1ybAjEN8yKcokTQJdte6QL4uZd6GGFBjXcgQHzZIbmS// +KV3kL+Z3Z0vIl9x1qc2VxBWozwocgreesIi78QAS+7NiQy+zoAM5jiLr5T7n/jpc +FFD7oHQcFcXRy+TX4PDqBXoeOHOLvM0JGsZHikMBmz0fP9ZJ1blwp/Kg6bU6dJ0q +KUNqeeiZEaSnlB/aBuKNxUqPd+GZRRqzn5qSHbwBCSjj91CCDdnephiNKv7OqAFq +zn4PvcjXFxaX+wH9HeOJAiIEEwEKAAwFAlZSEwcFgwHj1oAACgkQj2bz1ZN0RXBr +ug/+Mqq9JBgWmPhmA2QanCvp4p9UnlaUNeZKzI3J64Dt6jyJryn42BLaSZbFVHyb +JaqwCnuy9zQ65c7FThA7ZstusLHcyDDAgYkP3ynWmiPhENBoqaSLY0pom5E1oJ1i +7FtUlHCqvvHBrZp0nfoBstjw5LVGvf+8dLeK3laQWzoCNzR88ymHjGpWeZ73TsEI +Sin2GirPrk42i77hhyNhaKnwKPZVZsDg9dUxLRsz7wP1QSSR9tQE/eqQIWmD4hEJ +py7gm1LDoGd7Qhlm3pJVFJgY0kgPQm9GDVcOjaoK6rVXCj/tO8HDrgKb/qqAtLqy +QF6VT8xJ7YSD4lzTFGJPHQ/isSL1K5VXq3dtgToFd99pTbm/rSUVlbeJqZZ863IB +jp7gUh85jEgLgJJTi9Xj4Z/Eahk4V7zcFlry0MC1HmFVXjIU2g3012nxdET7PZdu +ojS2+kO6V8cbjcV6DoPforJz0Iz1UhWgtDGR90dO3CPp5TPKM1PbPoom9gGmAEbu +qtE2dRvaavBC4Dd2/3CgbFFO29Ql8s94Trxtxia7Yw9GlX7ZvVQo9ROQJHcgd3iv +g1dADx+S/Kl+aSct51I7iOLUhn+gx0pAfMRIQNPCyh/cgUbvqtK72HPcF2wSflDi +CYVTOOMcN+juIsJoaBtYcMawUvADrtqlO2jUtdLGA1o3QH2JAiIEEwEKAAwFAlgn +YrkFgweGH4AACgkQcBQmyjWo0uLCeA//Q1jM6fn5VmP6tz4nuX2uRBZUm+P4wesZ +8pcjWHLtEc+tSIBcsy4ruZq7Kpqvipour0m2u1q7LF6XoKbsPYcaaETd8TaQyhim +SEwIlPlkbdgFkLWdsp8fKLohR8U4exWq9D1+igVauju0w5pdfl0pUliuvpiDZDQH +fDglqjF3SVRWSF8XnQ0cHrkh1OyZKeYqRiyFmZMkaOk5xLpgtBYYfNWLGLtV9gzH +rWDFXKrmeKjrwdRQKENW17tlQw0O57ibq/ZCdHbU+EIWaCOksWi41ZX1Yr7yokft +N8t9jKt5T6UCEUtF1yK6KucL7sHbDuXvw5r9/A6mdcvjMtnb+sKnYKAFKDRvLSKd +C/qxsoRCXZTuS0TwpFF2V+T2fMwCKgaakXxbbYiwBR1/Zge/BRD8mAY8vJuZYvWf +w3jTOHZTt6nqhQWyQUyKcG+VFtWt0FpBZBgLt+e310HrN0QTfpKDme9+inxcmk98 +It2bUB+g7icZzDsG6ZeB6obRLprR4E5gUkFTfSgZexrzEpbJkCRlG+pbPbg8wkcN +377CN2DzN1QWOdLz+tK6IUZrHo7iGDS+rOVFCX7mLzAQvaP64LWUSifo0MwcXsk1 +K6I7Y6QoYT+EvdShUsZcps2ZBXmGfc+QTpACFVcH10bfKtUNgP/WcG6Rkt0mUWGv +q3UQBk+36/KJAkkEEAEIADMFAlftbLosGmh0dHBzOi8vZW1pbHlzaGVwaGVyZC5t +ZS9zaWduaW5nLXBvbGljeS50eHQACgkQqR9xEdmvC11/uQ//TCWZ1VcNGSGyyQ6a +k8C5wSJ1Z/H4KXTyWk0yY0MqDx7Nxm64Dn8KdBYaj7WXXz62FKjXjVqY+BUIEpJf +OS0J9uI9N5xwLHOt7OEA3Fdz2tH15GnTRgLoyRhft9kpfjaMhftgrDnb8LT0z+AF +Xo3OI2RATm+utYMSTGITd01b/7UayAFXSvhUVtDZsJfBRcw6UkUj2JV5otaIMbxm +zh04NM6wQQ9g9f1jKJaKFEWChFS36UHbRb8S6uL7R3ckrI9WqHXRVezgflw+wWzK +mCiKYL17qylfuJ2gdyhDaZ7fVCIOxrpb5jlN26x6vzgzD91t7G+mZCBOSPSRyj8H +jDxYElyGEqFeY+6FKAswj2CKjrQmYMRbs3timD7D6seaxtWELfuEBDf44Y+7Mhrk +Hp9WPTn/w7pGLfFEe0Y7zIeZ9MOZvy/Vy23gsjfeQXgKWfr+T3JTG1IumFwbOvX6 +L67IWcUt5AGIXx9uA4SPYE6zccJyg4Xc3nlmYj39ZiJmgVGQrU4PFDqKcusXcpCs +gBkpcz6zSKek/sHYz9cUpu3GtV5UZ+u/DIt+N9SJLdXZF6DGeijt+FWkuW6JpJ+s +Aw2BBUSYVWPBA8jaoKpC/5Be8bvtrR0FgTC4XfzW49kLgVsCcaaGogN47CFG1wro +QfVfx/g7qJchxwr8g6ZkpCThzwOJAu0EEwEKANcFAlUAxKIFgwlmAYBPFIAAAAAA +HgAodmVyaWZpZWRAcGF0dGVybnNpbnRoZXZvaWQubmV0RUY2RTI4NkREQTg1RUEy +QTRCQTdERTY4NEUyQzZFODc5MzI5ODI5MEsUgAAAAAAaAChpc2lzQHBhdHRlcm5z +aW50aGV2b2lkLm5ldDBBNkE1OEExNEI1OTQ2QUJERTE4RTIwN0EzQURCNjdBMkNE +QjhCMzUuGmh0dHBzOi8vYmxvZy5wYXR0ZXJuc2ludGhldm9pZC5uZXQvcG9saWN5 +LnR4dAAKCRCjrbZ6LNuLNWqvD/0Y63vIFRFsa0bY958Si8grdYkkei4gR3WrwW1o +9Juz41B9e/SjwXUrPpLUn7/vTtXHl1Bl4eLJFe4xsmsGbIQ1YbHc/mzp5iZMwH90 +ATqh3Bet6nXeg4xg2WEuWyco1Tu8zwP2TNYMEjlT4aTgteM2zbbwHoyCwGNjNEBt +R8/p7wk87E0AFaL7MGcyUM6hr1eBtwKwjFDkVoYhWlUkh33rYjAbvCAEv9lBPQXG +dnx734oEMeHLjB5nv2abXSngJ20LDq/zYOLhDUdFuRYusG6S30vrg4DC6IF7QrQn +rnhu7wdm6PACBeYmOuN3DdLBo2Hpi/rghbCQ4MJDUuJ4X58fSPh8OtHex76TM5My +xRx7KyqHAnXUlEkDpxR4QTC0yZ4E1/5pGXuBt8Sg9CSaQQNfj/A3l1k646KZq+OC +GfbEtjISB9/Wdr1ZcdwhP/MvCxwbs6vhcS3yIYIVyaOha5lBluMZiu+tHf3jLC8p +/+tYA54UGRDzh/USuLNeFCjr/bxsb4OmOaERIhrFfJEOlT6qBp1bKOjvSzyKGuXY +kMlUhiOTRjtG6QSd0T9nrWzN6DXhBxyxKF1PCm3Khi5G/MJzyih5Wxsuvrng/wcb +PjrI/RXNnZ42/rn7Vl2BTyo7jTbvouGvZLfYvFgF2MU4BMA0oPcjiWaYd87S/93A +khQu2okEPQQSAQoAJwUCVthxySAaaHR0cHM6Ly9taWtlLnRpZy5hcy9wZ3AvcG9s +aWN5LwAKCRCpk+cVbg6ZI2fbH/0Uz0bi9P78MscBIEyQKvkEkV9iD4v8jJcBzbRm +vRw+RJ7aDRsPfnK+AWLfNGR6I0oqF0Z6+Si4xSME2Wi3ycaax4n5oeGXz+eM2/iH +cM4SPq5hyFTnvqla9eSbvly5e8y0B0eONP1XR3/2onokOrKEyHHxtGrxD7V19siA +7ZtikPJa5Eb3hjilhy8y98IdoWNksHtge0sHrI2585t5IjctXNrgJTIQzTn9aBU4 +7IA5LmYTsPVCOfK5C1dK88IjerZqiBn4MeJ/xYqiuSHRaEHrd+/c5vniDDPjaPBx +i0xsfRvrRrEoVtuHZiPRNTyAuYoRLKsjeQA/CJP85+0rpdtusL/ImnSDZNAIFLyo +3D4mpk7ysxlniKSr3j9cRUEq1JLE0ICYjP749H4NrTfjGMC8JLNSfVMdAWoyUXLq +emh1Lxha3DV0lxCURDCjz38L6pZC1nZikTLG/GIwlaOKJQk8hjywkQpfeVy2xSj5 +TIHc1bPYtAg5iGBAP/iiybUNaHnH2nEKuDtuoGuzAMmqXFPt+Xxqn3D28CuQthAz +oN6rUi2rCXq/Y7/gBW4EUzO4HgQyZ7ihK0yWIlnB1nU2xZEdZ1azb829f06x17y3 +TSm5pfDbLKHWOJHC0g5B9txF5VlBxL3hW1QeWFI8no5yy7euGK1ZCjwV5BNX3oY5 +RhW7HxvlVhcKocN270YwF3gA32za6Lq8quVT4VjuJmEXXk67XvinAypavEmKqM35 +lBM6VaGwxjRBMCcDMhRYXgA33hVFkVnj2Jv8XcAHDPLEGcNU8QFDTyZTHW5ukGBu +dndo6OL3oPQoXOdOqGFXI0O1qjSv0Pl3SLboYnWTRqZRDb0xfs7QvT0g4+eHj14A +HfsQaVTn6HWDVfFfCBdMzqPX6t3PS5udIlctq9FXMxOxS+G54in7agDjo5ay7kSc +wvwZVpbFQUE9rOJOzqCNrB60XhDlz7E2sk3yfohjtH4/hTtmy7eI5wFjuTohhuTg +vcK6SO0XHqSxV9piwFjw8niy5Y6iDK+/4idPTuaOn53MBPJjBV+p96FX/ScfntAJ +l/5LiX7Bju0qTuY+cw83Lpxy5Ic5jC82+7l9dcnIg8WENBJgEjU8kT/Fh3jctriy +oBypQa6m67p5xClyJcfo+oNB9lWBZRgfDPNtntkR7kSfKkt7CpCFlmkAMg783mGx +xijtYkbkwuLSCRs2NaOGgKkxFk2PkYHvclW2CxSPdss9o1q6BQPOi5hgFPItfczx +FgS7XtPsm0d461qGLVzmgxWr90/w+Rg9cV1qVGcOMYMnT/G3ind4QMMhtjsSFuuV +daEkKzxI9pOEJ259nuCSwe2Vtcn2Pun+ITsCcw4XdevZbYmoiQREBBgBCgAPBQJX +vYRgAhsCBQkDwmcAAikJEE4sboeTKYKQwV0gBBkBCgAGBQJXvYRgAAoJENFIP6bD +wHE2+rkP/1HMxGVRc7DUsSAc3w+2oB3lEXvmfYkx9UJ6QD9eHY0Va2I17U85liD3 +S5kAkTm+tHzXj7UKu5odQe4QkvFuZ2ON2WNdQUfftkvi48+BvpfKeHQpbFu34DgS +mRAi6DVR1HzoXFt+tu0H4qk1i1v23a4UGfgowABklvM+t7fcuvyENqbyMaEz34t+ +zauS9bVK41M1hPB6HOmx1zduObRTqUtaaQ2AqptAvV2dt0I7J90QJ77R0+KT5wTe +sGn945W3R+CG+Ks0QyOJLyEHgoNmmdgiJcatYoUf6+ZU9FHn/kfbDqVX2o+b9Lgk +UGdq+mNWnwnwsul5XQeCwMMse8mrRPeYT4MaLHFFBtxeQuVBXM9cErHg/HUdCvij ++4ALmOiqhlGOYkDfGXy8YhSvPZZd46vaosX4ewd236frJdGngdyKvvVjXmzdOlFX +54NDXT6JW5I+SVbmJ/cTSz4NmXUfYbTnfiLHgM/J5v8gnSmQ4PeFALBoub7+UpXd +3J40Fnv23WpKZbRB+II3UaFF8udIK4x/iScBYy42MEAyEjyv8HwYBgXzqMN1XIm7 +DJRfqcIti7HvGqX4Wg/hcqxvxRBbD7n9JGpGD7AON4KqrkxIFgsIH/Ai54qx3sJ0 +JdwPG9rz3qzlrPFkOA65whrbt1N1d84ksBIB4NRaTpeQPZ4dRBdv/B0QAMbh55yI +6gr038yqf6wCJ4k9Lg6QXHAGPKqEJvXxh0MzOhjW4unwZ1AaEJUoka0QCZaXgxaU +nnQB21MhiBjPpGDxfHg+zygt49mJ1PJ6s1LJXwjajiMatKbTYtNe98+TRrq4ZZKE +G8xB9+BhpVzr3f11X5znnfqXAy1ojXv45c8NkswdtaAQbvYQpkZvgN2KcVnVkFoG +AipSLZxFvAEeyDk48tUdUPX4Tr5u8qA6/x6d50RTLYv2ahEPWSn61/1v+UD5//tU +4VnfYw0x9mE7I1v5TNXTwVQY9ewaadYU2hlNYVluiCwmqRcynX3AQhujqWNh9oR6 +5LCCdSQJWsEeuvS7QUl80IRlPyD13lADiyb4Sp56yhAkMfMt7AHlIf2d+qph9B2d +tH1WZ3SuVyOZSqJma5V5xTXN3xdyh68fIZT66yEhBvakSVtuFjpxy6NRlcD6aMK6 +BPZf2CTufN6i0bzcML57RiXc1SJvV24hpxE8vT9x1i370KbxHiQLGOZNkU2k3tqS +nogN+u7rmADBnLYN+C54G4E2I3nCn0G1bhdAzWL+IZLbj+tzg4dWuyX0HLRbAdRG +IgrcsdFSBoi8MM/1Qc0v8IJAYk0CjGgiVxJsBxtomQpXcgioZe0PjCuMvJEr5bEA +FDAypwr2nRs6dkoZloOu8lTa9ZTbQp4DW63YiQIcBBABCAAGBQJX+0LFAAoJEAJ4 +If97HP7G0k8P/i3k3+hXDVIBump8YPZwrnalWH0SSSGZFGXGQ7XpMWstnJJPk+4n +DsUwHNjAXKC//Odx3MlW2Wf4NdoNa26Kvypejw1rWZi/vIbWiosfFMhhh+D8yG7E +c+e2ykEvSe063zahDRbviCyMo5qvaQwcqrIB9nAZFdPCpSJTFt4j1DuVoyiuCspe +ac8ktaprod48nZQLqP6afK9zOY8UXpDTfuvzT7OSV3S8kcRqJqaz+BJv6nKMWEUX +l+Vnlq+Fj53dAJ0jGgrbmjv/vdqeioDARz+MAeEba1j7GB2/TqgJw9bt7NLqdoo9 +kZ3zVZDwEBLy2o30nMnrJkAeQQxd/O6o7VV/JWg+bcoChVPHjwc80xfo+BUhBP5c +KWN4v5ikaoubz7Vro/GF8jASWXJ1QAakeik+SZFmrR31ZIWvVRz6i2eKNxtJ6fh9 +ZUQc127jGh84or1/pJ+GvpMZcrOOED1AgODK+XahePQXJfGC/ndDUJX9LBYfr42J +gap0yukmXUkBAC0BczAQ03Zwu2YLuYNP0UrF95S+I1y41K+gr01FGF0LEccRUNhI +8mqvUmYEu058J4ZA+HrZPo5WJdMIaFpzpD3ZHfFsrUOyIFXBsnQMnhSvzQkYLWEN +REvL0/0WNEHbPXH/6XkammdZQ/+eo/lt+lDpwG7zZNpXNuLSHV7SgAIXiQIcBBAB +CAAGBQJYRoCvAAoJENUv47V+fXxVJ04P/2OJmctB+v/eEUsHI7CmvDOI4aMGfoaN +cdCIhvJM03mc6y3fc1eJPf0xmf6kAffgopJdremFCBOTmFzYZhDpq85HrOcWx776 +mNmuR6oMO7hJQLgzvsD6CR69Roonkt3GMrlHV10ULaEdyXpnNV9iamrx013saJAA +stYHZwg1bo3twSByvZuUVyzUgWT7FhjAGITYBMOowfJJ2cleN0MBf13RIVtAJG0J +O8ucSU1NFJeeRzcTk7JDoHROpr2MvlKSMUtSenjSierMzOTe4qyUvCQ30SZP1SVb +JfvAEro+NUdU3/21Dny84y6x/h57x45BRbd5JWHT+ipfr/6+pM2HQoDda4S53FRU +oA4U1lpj0r/FYPjhGozGyuk4B9tx2q+lm3Qzvfv/nQuezeWHFWSq9hiMwoZ8kDDG +sCQ5O9QnIDOH/ncdv9s57b630PUqIH/oRTA/jiig4CwbMcc7sL01GKOULI8M0OZH +0UQpdDXq012ICdfgQpUSq5GY56o6dHnjwxRazsKLEekQlf0YrhfUnVc6HfoiamwL +9XPHfhl0sBmg17nncMMTkN4j2Q0drP0pT4zMQgmt9pEX720J4f0iLoTymws38ok8 +Ya7oVm5waDXnhi5u+mgTepgOwfHmQpfgH7egOMtsbByhL1xQmPgrT03NHAHZ8tig +3dmQGhnaI1ssiQIcBBMBCgAGBQJW5+4xAAoJEAr2LcDJ1vCQ3JIQAOIe8WoFZphl +863+kwvl6wkHxnkEBwwdnE1mHYCGMsdZH8o3gk7aX0xmdDBNR0N4uF8Dqty7MU3E +ZqWEMy9clYYURXL/p9XarKZU7U6WwsY/Cofc7maADguO0pYe8pqQy7iU6gnyc1xZ +4mhWz8hfvW0adch9dCcISebeQttKq5nMkDLe+3UX9mnhWF/hkandicnhwRm5Mchb +KTjwvY2QhyFUL6cA7B4a1eVfX1VoQoB20xGGyhkJUvUwFnTwpAqjKJPrrJ0Um78F +4PQMlcdYzEX/HTbpprqyE9xFDz03riMYhzOFPCj34TC7Q5d34dNdZoICN8g9nMm5 +0nEWHwJhVsQuYyw3YvBUQq7jZqFEiGyc0Qstcl6sHQD9DSIRUJY9+PobNIp6d/7Q +N8ZvmqdK7KHtQG0XGN8au9IIHTux+DvpjV1YoUUU0lSjWyM2oIj9ZQnn8j5Zs2/E +A8PzG+dYQz1mqNrI8wYV8mJe/Ra6Nfq5di79PJlo4QnZD659OtQVllmAy2hc3aVA +9qYd2UU52VB9q8wf/7rTOlDjMgxuvhiC1qADLKnTTw2XL11y0iLbtI/p1qQJfuvw +i5ibsvWMIIKMYUsgaQqBUNydDomNRHeB2OPODtFGYTm//BlRYkeOhjJTxbLR0XO2 +Tp3NVUMAeAAE9p85vlgD8h9KGJ9TAk84iQIfBBABCgAJBQJVBZKZAgcAAAoJEFdN +jKWLnkRpTSgP/0PtjPYoLBDHTmeuAlrcAxI+DDZN1q4I3WMVbYahdHNGEs+pGbVK +VUTXyaheSmlhWQ5G9AkRCPR/4rPr2HADTfq4eBtjYY/p5vVWd+6sZ0l2UAl+Hwea +UWEHSvsD4wbQ0UsiezMa3gS2ZAcqou39G6WdWLQp0ZmYM4lYTeXj9rX6Qyuxoxi0 +WzoaEcTeAda7pkFPsBGe7jV3xV61eOSoeYSgk27cm0AheyuGXCob9zKUfZAdW72J +wo6JrUXGRo1pfR+1LqPxnVL5Z5x0evxEuOZezCrfKbsWTnhEY5HCF/KHv9DVOFzV +b+Y5NIkIedKCu4CfHslu0tS99K1BZq/3A4a1R3BljWfOom/Gt4ef7BY65NdZjp2j +Caza9Fh5sU0kfmgLW3SRy+PLTGctE9VN1yKEdJRGe1KH+DT74+405Jv3hMD0PiZx +Ddd8ObkHMPAvMKn4U9ANUf0i1bokUMPmTsJBghrbD3vQ4W0Gs4O9vOgCu0poNExb +BQsXjC+HIBJGUFYOIN8I79xrwV1oO0f0O0hCCbmQM6r0WmWjEyHI0WO8exwoxKw9 +dkkJz/Ae3TLOqRMgu7XEfw5vd3T6U+u0eKF7kbI2WjpvbIBFbfK+pC7Fhar1GmN/ +ZBkY41fwNCO1wtbxd8QZ+po44Zfg+/mTXAgAKr+kZHwScDuO+KPpXlAHiQIiBBAB +CgAMBQJU7gA+BYMDxQoAAAoJEKvfCgVeT9L+0t0QALEjICDFsYV5tgcIV8IMuzRr +/qEbBoLdHV+Gwcp0yFqCZtTjPfMdJHQuM9CDBQuImxN+p5Bi0RKP+1xTVmI8QffA +xmKjF7g09Vr7QDyTYpS5ZwPj51atIQSvz2WM2tIaZgCT+BfmTSNxvxPVvxCWp4ZI +844wcLmAO5ifP7RO6ZzodHdPl1llTHD62l1nArNxoTnfD66N8kLCrDS7cbzuIRPk +SVcO98YXlwwtWytWC+/UnkpQIqwWljnSnReiF9BiSqNJFl2t8wnEGfzrUdwIQzHH +gbBizQj9lHBkIoOMPisvmbIISjovB7LmuYwDEiIvWj69QWqdh9KKfczxJYZLVEIH +smWznEDflqjbEoX8CGVGaq3K9/GpeGaD2eb9G/s7YoXCx7zxtMKiYJrtOaRuDrF0 +I1PVkf+HnB/Hmb8uaVoQ3Pjft3dvNCR/yToAcO/+yWfEXxYP/fNdc76qh9XKn+rG +UpaDx0iKuDLSMPyDocYLKv0T7HyG2UoTbDFwhZZN2cgBK7OWolEwVUDdeEw+ZulJ +kki4ucd9m12e7iouTINulFBA5GDxpNphQiJxEFN0qowP4n4wWLnTHGxnDpgxMXe9 +xcThw+io8tdl2ZDErY+yCLXhMmZzb8ixHET19CuSU43mwCTNhA0HI6VS6s/cvfgy +WYagSfoLNBtJ/qzewU+oiQIiBBEBCAAMBQJXbYpbBYMDwmcAAAoJEGarYdsKfNFy +KP0P/ikpmTGLhPluqK0u79BvSijYZ1raPmZ+xwKQMRt00lDCVwVOK1qqzXiRXYxV +9yDEKvxsQHznZZcoFv1Z5CXcFxnfbqVcwnloR6JSRxp2pwmwwod2viGiyiUi3cVY +FsWvOBReYFWQ6lKMokYqVZRBCsN3SmiBa9w/AeAKwN4ne9X9Y+LgJfSbAACESCrY +vR1vV7YGEpJLXdDmxBgOQyJ5uF3uhwO4aAx9HeozNfsNRdz79whAyIeG/+L+Tuko +3FNGtQDHG+GcEbKDr/pWpUimMwJqwtQFsAGBcWZFzjBl8jTMSFeVvK/XET2XIIIu +VHQpUdA9PH1qIdOF42hN6B0wEvvOZRZ0TXyAaMVG3TYWxGrMDLjPaEAgdVQl8trZ +OJDth/XrgFQCZsyACBiNcN25uBLFEbgxiYUGwNgLZuzDMF/r22he/lP0pRI9xgnu +ZXKYFm2egUmoamUSkMwAt++xUkM2f4LT14+zTr2vlRtapGgeRt7bNmoOLd3hWRrB +GCFSQcYuJs5aUFWYUuZGt/hzMjG5B+jZGR2FUCKBZP5YrMOA94tR9msaPXzbPgbX +9WqyIIoHQPeF929s48EB9YlwqhURTFDz0zKuw1hGrDZVjgmOlLSX3mphIVXVthOw +hDVMtui0olM78QuhVLlxoy/CiEyDGjch647F80mqOvrbur/ziQIiBBIBCgAMBQJX +QDYmBYMHhh+AAAoJEKa8AcFdft2p33AP/i6gNVwChq1SVD/odNv5IVMPeaOla0q7 +qf/VKG4yudDEQaqf/vvgH30XEDqLIlPKhG8xBly7dqqV60r+XnjKMKPYigOU+Tqf +K2ja5zuIrAjiy+Daz6lrgUhha3LNEFT8e2H3d5KPKS/QjJ3GER673b2V4Ornh9bm +5vq2sj/Q8LYo3hFQ1tFkpU+e8ADRb1b7inS1H5VQ+DQINuGLN/nGzMq7/ETUkfNS +8SsCrUucTQAepRo3TMYOCu9AO33mxPpR8vJW/yXCLUbZp2bPdBGGdg94vKZm5jND +iHfcgrgRUfq9ryIUHa5cAWm7ibfAUf5WCneB/RFDSpQNE7EnPzJb2jwjvz6kWpoq +EhPr1KX8ghtRA+nC1fMGcLACmOV3BB2lEAciCB/4/7UcRqWehW/GaG5lL2yzcCHz +yfFRZjglHvaQBLGcdUe/CoT5sIXnXeOIoHmTHzicVX+AIO+UmnHZCP7oN5vFd0Ge +Prhvamlu9xFJiPEsikxykNMcu+WqiL5DL6yN3ZoNBcWloPkS9W8/omvey8psaP/n +4p50n9yqVHboegMWq6HXBIQd9qh99UEW9YvgOSO5lXvMXHO7LDNEv+uRvoGXkbiJ +h9soBCVLzCiEpS6s2WlrbgVClvBap/JAP6xy9dHgDdwA6ko1zbAD1wQbCJ0JDvow +MbK5fZrTW6vpiQLtBBMBCgDXBQJX1UgSBYMJZgGATxSAAAAAAB4AKHZlcmlmaWVk +QHBhdHRlcm5zaW50aGV2b2lkLm5ldEVGNkUyODZEREE4NUVBMkE0QkE3REU2ODRF +MkM2RTg3OTMyOTgyOTBLFIAAAAAAGgAoaXNpc0BwYXR0ZXJuc2ludGhldm9pZC5u +ZXQwQTZBNThBMTRCNTk0NkFCREUxOEUyMDdBM0FEQjY3QTJDREI4QjM1LhpodHRw +czovL2Jsb2cucGF0dGVybnNpbnRoZXZvaWQubmV0L3BvbGljeS50eHQACgkQo622 +eizbizWc3w/+J4h88nSQHqtJimtiKztv6QmSVggusB+O8ZLkCZhsscPj1UcRAV1j +TJtrMLdr8LhVUbe5Yy1kJRFCbK1kJZhKAldCnDbqewyHC6yTkbB6fHC3cdzwnqUr +0s9KgKZENf+YjoSvFLCwiqzYPPxKzE0cXjBEpc4r8QeWh8aksk9+dr0wJInNAx3N +/7M4G/OF7n25h3NtiuM3WUYUhYeU79zJP8Sx+Jx2Fqj856CHqEVfeibLdID9xkNh +kDZs6mn937yozVHIdvAfVpXL2K9b0SZGO+nXoKgg0WlmgpUthbR1DVNalxdO7sBa +ZNQqpA/fu/6HCqOICZVzh0YBq7ZwwQi15mjTSzKwRAWHpDLfNX6aaNTEEHu+LPQh +lg0HpYZf0wcx4Q+fcI6+UNH5uHHDOdBpFnDGGn1Li1dxe8SBW4blLc0kqjjcwz8D +VTZr38XLG0KXHf3OdIBayjhcMqXEzX6IHefQOXRD+7ztedzSiOrYmTAb4X0kjimr +CNc2HF4pi2hdtdQcSiZBkqoJKP6zhqoSFzwhz5q02GnpgSER6b6ez/1tSPXbFoZC +JL8Qndf/kyUwC/JmpZEEvBeF+8aXM3JqWUwYCFCrbcH2K5NEAU2ztz1pqQ0AHQ7F +C+d3Dtr5EP5GJYiVA8adMi+A0ONMhFqs27GCUgrg1swjKjH4/PVYrU+JAhwEEwEK +AAYFAlbn7ggACgkQKVx0aYSvfwyRghAAkrxojYgskOsBYXf+gtwNrMvk7XLSFyT5 +lTGZRs8LGA3O+xVwKIWJ5352AytTLwvyKVypdjMNJaIdm0LyiOGhvA1+T3DicL4g +PTh1wSLsB6fQmEZPz7F5+SgEbjgmm9FL+zoHBkmIU9VanxOcurm0ChCzCFdfexYZ +OgwC64Rr3+bitpyxCjh7tNSBzoCOnv9ORj4qSrHuZ7Y/PWRB8Xmzix4kyqzIPyXW +KGghLCcTuzFjIsobMwcLYinf9ofYyW6MeM7Qi6WYd9JWW8JTDtT8LX3mQkX5f6CL +zGkvfN8obFEui2EJPljD3u2zDGfont3KLcGInSmigBDlSxTWj7PImnmx534DY36O +qX8D1v+ewib9lX4oXdfiKTNk0nD0ZIDYNn8NwvAwxe1wqAdOPAwCOnFVAYW6w9JR +Yjxw0e4WF6tAho1lDZrdvFx27wKvb4pfrbmix5ahrohT4ipOG/rKPNCEmQCTON4T +A3K68GAbb4C1zW1CYR7UuVyCt8DgBdQObs2knThoCf/FbG6i7UYWfHVnTNAGZkDG +GLCJtI8I06cHVw+iY2hq8HpgFIUXaGncfWKOwvMAZkMqYem3LOudatRP0byj0qtw +G7lsSeZfy1moBliH8w/DlX31tldGIpW+zQ0ELFR18codBgpq22Eja7lPJa3N3QGq +p2vm8VlWWSOJAjMEEAEIAB0WIQRJVe60WzcZ5crfDsNwMkCbK18yNAUCWJTmkwAK +CRBwMkCbK18yNKnBD/0dgzEK7sCDoualxHxmA0+OIzAJHhCzeSCI/iCzwJkl9+vH +gCdxtHuyGRTlv8ujg2hpis6qfOr/MS5Ob5klf8cqDSGJUrcXfGtKgiR6ctVKFmzg +VVJrmsjd93xtCp9MuQuHUEaWAv+fd4UlpXlYm5eIo3uxPuKJvf096bjfVQqmhpBF +dpug/FP8t1GGVKmNP9sk3X1NNzB0eOBvjDYvCoei5MSxNmR3jz7ShBhT91Ee9by+ +p5sYIFPDa+MfunZ8M1g76piwTT4NjcyKXnZNnY1/LxzlVWruswUETp2F3N5nIL0p +brmSq399KoMsBXWqWUTNCh3oX+wkmoVT4DPSkPZAYTiMD2UZykRiHKsDAmjRvSs5 +TDtzNFDfzopKpVOFKRmvWUhpQ/rFQRgoayaW6nG9kI8K7jjQ39Z+RRc+Lo+1mw8I +0LqzYTnA7BIy9SkIvfg68ZK8S7q8bvi6e8WjeqW5c5ymiRM8MD9vs9nrfCw1ZP4s +TaonQmJr/alV/M4nHy18DH8fyGxJT1gthytigeq/6E5bbGTcIWJc1hEvLsYxXD0L +1jIXyEwV7NFCLRI3Bj6W5258xOxAU4uMV7atRMoDJKgk+yrTCJg90i6gp7maJTvQ +nvRYfn2958HJKVERTdck53gtU5mXl+agLZOsdTNSWDthCyT7T7MefRq1anfNyokC +HAQQAQgABgUCWAflrgAKCRCLBM8Ndbt+Nx7ID/9hoxtX9QifaH9xAHUOJaTduUS0 +dsqxHFpRAH0oIJDnLb3iGYoxcYYnq1jieVUY99+6/QNW2ZAfsnhBDmWB8G7DyCvX +2CJpaL3OTBJ6KV8M5p8tU1FFZKtuCeFImhB7yNEk/ZxUae8s0KDBQxr3n7SXDVsa +52Hdnoxb/sCjEHN//uSFH6e2BNLJf3jDdZhw/TYzPYN7LyYyaH2QhIhkyDnodUwF +xPKtBXmAJWJnhlqchz7uXCICWZeeZ8IsExKqaMEPsS/a/1Ze15j73Ued3vs5cd+F +3OVWxZsUa5m1RDf/O66QO2rX6Cd1N1yFaPbu3EBq4kKqTR/cK80SEwbDMrg3Zw9Z +VzxT+nZ9nIDvHoCQBbpBjc+oCXb18KyTwD6GAmuqPS8lkqMl3gQKzoca4f8egh+b +KQIzTNs4yc7ZR6f/vQvmBz1s9X9VaM3kQvuh+lAhHkneertbAlxDa/SL/oDV33HY +YjAskNnhpjdWoMkRZdj8t+yBAX/VJ8pErEsI2uYQY5Qz4Wa76pIV8Gw5ZEIUKdxZ +arxhexX4vciRBlHm0DCitFvfd5Z18NZrqODhJeSo136gnD/gw9l+6SEytyps634C +EzEo+l/9SnJWFAKK3nPx/UMuk68vq59HhE8IE2cwNHECMzC7ZtU3FRvbiFyOLB5Q +oRgpsnzOa11IreKj5okCSgQSAQoANAUCVhkJYAWDBaOagCcaZ2l0Oi8vZ2l0aHVi +LmNvbS9pbmZpbml0eTAvcHVia2V5cy5naXQACgkQExjvrF+7287pwA/+MVcdYTI9 +CgRYuA3E5n+gjkGvtRQVuz4ykmQVva0uH4p8nJu7fnE2Ly88W3kVeZ3ITTEk008s +wZupDz+SHwEWxJ6NE3zipERtceGnkHZ7auDpE3raxZoxNgoeyJJb5nsbGgViLHDW +vjcUDYkY0+P7hO4T8W9bzcoJPMexFkbI04orOFYBaAQmOKq3NWDl1d3t2YJZD6if +X/menDf7MSvK2FCq/7e9ppEMAIASt4eVpG5oBj6Ri5IySvoXh4xbpm3vwsLdnF8H +aiQ6Z2ojv7NCPzZmPc4CyGL/q9LumjeyVy4RWN4yHNoXwa3ovLF78plb5V/YAH8X +NEyJst6llX6/y47Cumh4u5+uxyqhmuSaNzTSJR5Bt8afBSG8Ifw/X4PkcTQkE6x0 +XTok6t7AWhxow2DVO4CqauSNQxLAvm2NA96M4cJ6DwErZQsA6rdsH4TSVDcvtJz3 +zm0YvWNCmBJgt03DUidyMkKAcEQoPJs7gIWj1XfsCfmN6MbvuDE1fQrzUSsMgnDq +h4umJxCNHcHfre1c0POEcEGbKPNp+KawHakTpxqMzPfH5tTNIvdfvIZwDJZWQ8gS +Kvfi77Pb6N/B+crVdfZOMWVcujsG0zh3Kih4HkIzSzmceN+gOQN5rPF3mUqQI94k +xsbzwRlwLfT8UlI6G0Sm+cbkubdmFX7bnhuJAiIEEgEKAAwFAlYkBx0FgweGH4AA +CgkQRQy6f5aPCUsSJA//aTJ4yHDduIodq+7TBNoebM14TfDa3PX89dvvwqC0Rmjo +XE0Q3PXZxNzZ7xbwOTHp5hVKXhwED5xC7FTsYOhU5sYvhyxEaDRJc7/IC2HzJxaG +T/NHI5eiElaOiodhvX37Ar1bLGmdMgx4nMBqcND9ShGVZXGeQiypkaNu7PsiYNS0 +OztzX3kDnnrHPhkDe79lmVekOmzLPizSiljAdkRTxzLUtgOwfV5wK1e0LdD1WGWF +q64cZWee+MRdU6efSIXYSYOtXKtnwID/cauqnizYRff04BXhlSKBybEn1gCEfEx7 +1PvRL1pv0SjXBH6HIWrgxv3++ypr3pbpfiNwKo6QXowpFSotJnQ8gL42HcVgq/2W +WLfZfUHIzVWrHBbb46qRBRg4lLpxBvW2nHIMhcc7BU9//Qx32SMl9NMCi5yChruw +onGrklgFRnjobkJhq8tuGODyr4OzVn00QzKO6Yag0XyReAfO5Eud/i0qmlqhJjga +PacDratnwiNMzQNrBThOcvtafeKUo5BBlvC+djaIemn/RYUlTRuXG427CNY8yUSc +XyHHt99ppS7CZx1cdVN8xfkWyCecfN6dQHvUorpTtv3exkCqk7iBdWVtopxnAAp2 +mgBxv8D2CxTAl2hE3N6a8ZOb2vyQTwRBTgtARd/CG6Vh2EHPVE4FtTC9VgSPffG5 +Ag0EWwnQdAEQAK8MRUxjsvvZFGt3dScnI20cvlL4LM3ReesedqrFEOcZP8q5kVxi +u3n1zT64BXRza2EiYPttymbh56ynLk/SxxcM1qdGhn1qwdCEav//TYJK4eE0ZRPb +dOL6YY9hkfBPZUONBD+YYnohsOUnAYRNaRsSjlAwsaoDauJMSOGl7Fam0E2GDvzA +YeCEjE9SYFwW1jGGmvEKjAV9zqjeMwH0A7NWYuTo9VXmCyxRPPhAKw/3XsMuJ1WO +nL9rPz4yo2ZQlyLf342IFKpvQLw+H3NqRYpJa8P5bi1cKYGHP97UZFHLOu5rzvoy +FmTU82H0oc2BQDIacZzwmVVwyM0wOg4evdRXmv/2KvtuwxosF58kXZTtCQ7miWRW +UPGMX4PR71I70KBBDcLWZMptmW8Ey+oE7DjOUMv77sGeBZdF/pBW0Oy4qgNF/tX/ +/NkoI2dKBBuEQMikQLgfuEoGF/5zueWJdLjEDESeZB9nXgWEaADwiH+nzcuUYivC +YR2yszRpRTv2GwcUoYbT1Cb8L3Qy77xq21BiOxs5OWylfUS0yLZN9XOP/qwa5MDP +mpS1kAw3IcBf9MA825PFxXQY/mv9rvd5gmip+vfwBT8F3ZvXzQHAWBF0bXTONmp/ +CxujjE1PkJBQ+mOg5x/wyYEVw+HkfZgSIwfVFFJ+MXkKYeXXVHg5+lubABEBAAGJ +BHIEGAEKACYWIQTvbiht2oXqKkun3mhOLG6HkymCkAUCWwnQdAIbAgUJBFNsAAJA +CRBOLG6HkymCkMF0IAQZAQoAHRYhBBEHdbXRAfs2vGyRG+t3RJHZ/wbiBQJbCdB0 +AAoJEOt3RJHZ/wbi170P/0Rvg0uBdrHsnKOjfqwPZ6k4I1Wwx2tpkrsb4wKVVxoR +TZFOiF1DE33gZ1Dkf1jczfwdpBZQbC70gkaLz2WpbbBRtg6RIZQO53psM+wmYRO1 +C4P+ByMJ9bf8V28pzKTsBV3jU3ACp2uNWft7wIzUq/6AHHf6RgVvikglC+RcUxLb +OHdXzLpgM8ItzotD3UBq+g67um3VG1HC3/1RaA+tqvrg/uehEjhiC753XYgz2VkH +lRVVoM74KoXC3HKxChwArpT5lAfqwUwvcvvOiPL4ZsBivl452tQOPfef9XBgV7LS +QnS1Wy8x0L+ncClP8OiEdC3DpZSgZKeFJ1V+xsis9V0Bzs/Pv4VH+s7spvm1Al7B +wkNXQkxn2csaws1lIuS7cfB6sbdkNNGxAeQSOfCLOCWJU01niy/NVRQiEEjbhCSM +Hwj1AEf6B+sGghmj5BEfCdfB27o4eCrv/xQCJri7g0FlYFypnaxc/lHojNQZZCAH +A3Av/RCcbEoBQ1JBdR2f9oUQ86ZJtHVbUKU4k39jSA/b8eqSQQB6y/2dkNdW2VnX +iM/Ai8aj1FJQTX4K+j5pCGy/+AR241qfeImr3JtMav2SrkfuD72dUPbKowFeKq3M +0p3912peoH82PVnLgsD7uhRTYbhLUOefYG8JvoovnhQH6X9RvMEQ3aZyvRfgkNyR +gfMP/0daFS10RBYcqEt8VkbkYFQrFwwl3tM9m1+r0ZsV+kd3m6jUxj9ZDH0uPx7Y +hO7U0nvtSLWBriv0lOqMkUqZdNWSCkZMOl6TJW0hTkGCFr8yZP3ycTghP/hPFJj/ +ARNDJtQodlWWXfZwRSDZIo2Dw7IIRDYBvLxp17FnMkFILHoK2CaZN5B+nE8Z91R1 +nrJ92bXNwWIHb3d0t+01TXEBdOk7kHNbabBww/bIdg6D4qj/LL4F+H2iR/6BMpA0 +gWdpcICEEmQnQkf0gfHKn3lAZsqX1Fs+vUwPSCXdlWUkUPuIMopenU8PTM0f5jAT +kbYUVcfL45tyqnhPoV3DzT+A+1KtR3vGkVxHGTrCeusFmAzkDSWTuWhv8LQNzArt +Sam39cKirZfIPHHJrvL803fZ408B4tu56NSZaT/HqMF+wVgege4AmGWnRlaOtuXw +LIKmpt8oKoUzCg6JkXAAYzArt1unoRambB1PNubFyEZGlDeAWtWVD4GRFnAT6UpT +iBJehnUxQENT1K2LWniEXoUbNLtlo+HyBHUjPSjC4gIjGLQ63+cd2r8hkgT3h4zk +eny90pNCgJnFinn6UTcSomThUWiXJmqOeK1DmTqNWfiemPwFdKXSAor5BF7PS3sx +RCysf9JS8z3b8XGN7xRGrataP2EWDD9qaMFvMBoOAikp7n25 +=NE79 +-----END PGP PUBLIC KEY BLOCK-----