diff --git a/.github/workflows/fedora-cmake.yml b/.github/workflows/fedora-cmake.yml index 7b49090..73a0c42 100644 --- a/.github/workflows/fedora-cmake.yml +++ b/.github/workflows/fedora-cmake.yml @@ -13,36 +13,55 @@ jobs: include: - container: fedora:35 compiler: gcc # GCC 11 - ignore-errors: false - # TODO(cblichmann): Add clang-13 build to matrix (currently fails) + ignore-errors: true # Stack trace test fails on Fedora (issue #118) runs-on: ubuntu-latest continue-on-error: ${{ matrix.ignore-errors }} - container: - image: ${{ matrix.container }} + env: + RUN_CMD: docker exec --tty ${{matrix.compiler}}-build-container steps: - uses: actions/checkout@v2 + - name: Prepare container + # Note: For the sandbox tests to work, we need a privileged, unconfined + # container that retains its capabilities. + run: | + docker run --name ${{matrix.compiler}}-build-container \ + --tty \ + --privileged \ + --cap-add ALL \ + --security-opt apparmor:unconfined \ + -v $GITHUB_WORKSPACE:$GITHUB_WORKSPACE \ + -e TERM=dumb \ + -e BUILD_TYPE \ + -e GITHUB_WORKSPACE \ + -d ${{matrix.container}} \ + sleep infinity + - name: Install build tools run: | - dnf update -y - dnf install -y git make automake patch glibc-static libstdc++-static \ - cmake ninja-build python3 python3-pip clang-devel libcap-devel - - - name: Install/configure Clang compiler toolchain - if: matrix.compiler == 'clang' - run: | - echo "CXX=clang++" >> $GITHUB_ENV - echo "CC=clang" >> $GITHUB_ENV + $RUN_CMD dnf update -y --quiet + $RUN_CMD dnf install -y --quiet git make automake patch glibc-static \ + libstdc++-static cmake ninja-build python3 python3-pip clang-devel \ + libcap-devel - name: Create Build Environment run: | - pip3 install absl-py clang - cmake -E make_directory $GITHUB_WORKSPACE/build + $RUN_CMD pip3 install --progress-bar=off absl-py clang + $RUN_CMD cmake -E make_directory $GITHUB_WORKSPACE/build - name: Configure CMake - run: cmake $GITHUB_WORKSPACE -G Ninja -DCMAKE_BUILD_TYPE=$BUILD_TYPE + run: | + $RUN_CMD cmake -S $GITHUB_WORKSPACE -B $GITHUB_WORKSPACE/build \ + -G Ninja -DCMAKE_BUILD_TYPE=$BUILD_TYPE - name: Build - run: cmake --build $GITHUB_WORKSPACE --config $BUILD_TYPE + run: | + $RUN_CMD cmake --build $GITHUB_WORKSPACE/build --config $BUILD_TYPE + + - name: Test + run: | + $RUN_CMD ctest --test-dir $GITHUB_WORKSPACE/build -C $BUILD_TYPE \ + --output-on-failure \ + -R SapiTest diff --git a/.github/workflows/ubuntu-cmake.yml b/.github/workflows/ubuntu-cmake.yml index 29963c5..4b890dd 100644 --- a/.github/workflows/ubuntu-cmake.yml +++ b/.github/workflows/ubuntu-cmake.yml @@ -62,17 +62,17 @@ jobs: - name: Create Build Environment run: | pip3 install absl-py clang - cmake -E make_directory ${{runner.workspace}}/build + cmake -E make_directory $GITHUB_WORKSPACE/build - name: Configure CMake - working-directory: ${{runner.workspace}}/build - run: cmake $GITHUB_WORKSPACE -G Ninja -DCMAKE_BUILD_TYPE=$BUILD_TYPE + run: | + cmake $GITHUB_WORKSPACE -G Ninja -DCMAKE_BUILD_TYPE=$BUILD_TYPE - name: Build - working-directory: ${{runner.workspace}}/build - run: cmake --build . --config $BUILD_TYPE + run: | + cmake --build $GITHUB_WORKSPACE --config $BUILD_TYPE - # TODO(cblichmann): Before enabling this, make sure all OSS tests pass - #- name: Test - # working-directory: ${{runner.workspace}}/build - # run: ctest -C $BUILD_TYPE + - name: Test + run: | + ctest $GITHUB_WORKSPACE -C $BUILD_TYPE --output-on-failure \ + -R SapiTest diff --git a/.gitmodules b/.gitmodules index 9575a07..5690ba9 100644 --- a/.gitmodules +++ b/.gitmodules @@ -4,9 +4,6 @@ [submodule "oss-internship-2020/openjpeg/openjpeg"] path = oss-internship-2020/openjpeg/openjpeg url = https://github.com/uclouvain/openjpeg.git -[submodule "oss-internship-2020/pffft/master"] - path = oss-internship-2020/pffft/master - url = https://bitbucket.org/jpommier/pffft/src/master/ [submodule "oss-internship-2020/gdal/gdal"] path = oss-internship-2020/gdal/gdal url = https://github.com/OSGeo/gdal/ diff --git a/cmake/SapiBuildDefs.cmake b/cmake/SapiBuildDefs.cmake index c7b25b2..134115e 100644 --- a/cmake/SapiBuildDefs.cmake +++ b/cmake/SapiBuildDefs.cmake @@ -100,8 +100,7 @@ function(add_sapi_library) list(APPEND _sapi_exported_funcs "LINKER:--export-dynamic-symbol,${func}") endforeach() if(NOT _sapi_exported_funcs) - set(_sapi_exported_funcs LINKER:--whole-archive - LINKER:--allow-multiple-definition) + set(_sapi_exported_funcs LINKER:--allow-multiple-definition) endif() # The sandboxed binary @@ -112,7 +111,7 @@ function(add_sapi_library) add_executable("${_sapi_bin}" "${_sapi_force_cxx_linkage}") target_link_libraries("${_sapi_bin}" PRIVATE -fuse-ld=gold - "${_sapi_LIBRARY}" + -Wl,--whole-archive "${_sapi_LIBRARY}" -Wl,--no-whole-archive sapi::client ${CMAKE_DL_LIBS} ) diff --git a/contrib/CMakeLists.txt b/contrib/CMakeLists.txt index fbbb74e..70b1223 100644 --- a/contrib/CMakeLists.txt +++ b/contrib/CMakeLists.txt @@ -14,7 +14,12 @@ # Append to this list whenever a new sandboxed library is added to `contrib/`. set(SAPI_CONTRIB_SANDBOXES + hunspell jsonnet + libidn2 + pffft + turbojpeg + zopfli zstd ) diff --git a/contrib/README.md b/contrib/README.md index 036b2ba..8e93fe2 100644 --- a/contrib/README.md +++ b/contrib/README.md @@ -5,12 +5,16 @@ libraries. ## Projects Sandboxed -Directory | Project | Home Page | Integration ------------ | --------------------------------------------------------------- | -------------------------------------------------------------------- | ----------- -`c-blosc/` | c-blosc A blocking, shuffling and loss-less compression library | [github.com/Blosc/c-blosc](https://github.com/Blosc/c-blosc) | CMake -`jsonnet/` | Jsonnet - The Data Templating Language | [github.com/google/jsonnet](https://github.com/google/jsonnet) | CMake -`hunspell/` | Hunspell - The most popular spellchecking library | [github.com/hunspell/hunspell](https://github.com/hunspell/hunspell) | CMake -`zstd/` | Zstandard - Fast real-time compression algorithm | [github.com/facebook/zstd](https://github.com/facebook/zstd) | CMake +Directory | Project | Home Page | Integration +------------ | ----------------------------------------------------------------- | ------------------------------------------------------------------------------------ | ----------- +`c-blosc/` | c-blosc - A blocking, shuffling and loss-less compression library | [github.com/Blosc/c-blosc](https://github.com/Blosc/c-blosc) | CMake +`hunspell/` | Hunspell - The most popular spellchecking library | [github.com/hunspell/hunspell](https://github.com/hunspell/hunspell) | CMake +`jsonnet/` | Jsonnet - The Data Templating Language | [github.com/google/jsonnet](https://github.com/google/jsonnet) | CMake +`pffft/` | PFFFT - a pretty fast Fourier Transform | [bitbucket.org/jpommier/pffft.git](https://bitbucket.org/jpommier/pffft.git) | CMake +`zopfli` | Zopfli - Compression Algorithm | [github.com/google/zopfli](https://github.com/google/zopfli) | CMake +`zstd/` | Zstandard - Fast real-time compression algorithm | [github.com/facebook/zstd](https://github.com/facebook/zstd) | CMake +`libidn2/` | libidn2 - GNU IDN library | [www.gnu.org/software/libidn/#libidn2](https://www.gnu.org/software/libidn/#libidn2) | CMake +`turbojpeg/` | High-level JPEG library | [libjpeg-turbo.org/About/TurboJPEG](https://libjpeg-turbo.org/About/TurboJPEG) | CMake ## Projects Shipping with Sandboxed API Sandboxes diff --git a/contrib/hunspell/CMakeLists.txt b/contrib/hunspell/CMakeLists.txt index 8a38f85..cf4ebe8 100644 --- a/contrib/hunspell/CMakeLists.txt +++ b/contrib/hunspell/CMakeLists.txt @@ -21,15 +21,14 @@ set(CMAKE_CXX_STANDARD_REQUIRED True) set(SAPI_ROOT "" CACHE PATH "Path to the Sandboxed API source tree") -add_subdirectory( - "${SAPI_ROOT}" - "${CMAKE_BINARY_DIR}/sandboxed-api-build" - EXCLUDE_FROM_ALL -) - -FetchContent_Declare( - libhunspell +if(NOT TARGET sapi::sapi) + set(SAPI_ROOT "../.." CACHE PATH "Path to the Sandboxed API source tree") + add_subdirectory("${SAPI_ROOT}" + "${CMAKE_BINARY_DIR}/sandboxed-api-build" + EXCLUDE_FROM_ALL) +endif() +FetchContent_Declare(libhunspell GIT_REPOSITORY https://github.com/hunspell/hunspell.git GIT_TAG 31e6d6323026a3bef12c5912ce032d88bfef2091 ) @@ -44,13 +43,23 @@ if(NOT libhunspell_POPULATED) if(NOT _sapi_CONFIG_STATUS STREQUAL "${libhunspell_CONFIG_STATUS}") message("-- Configuring libhunspell...") execute_process( - COMMAND autoreconf -vfi - COMMAND ./configure --disable-dependency-tracking + COMMAND autoreconf -i WORKING_DIRECTORY "${libhunspell_SOURCE_DIR}" - RESULT_VARIABLE libhunspell_config_result + RESULT_VARIABLE _sapi_libhunspell_autoreconf_result ) - if(NOT libhunspell_config_result EQUAL "0") - message(FATAL_ERROR "Configuration for libhunspell failed") + if(NOT _sapi_libhunspell_autoreconf_result EQUAL "0") + message(FATAL_ERROR "Configuration for libhunspell failed: " + "${_sapi_libhunspell_autoreconf_result}") + endif() + execute_process( + COMMAND ./configure --disable-dependency-tracking + --quiet + WORKING_DIRECTORY "${libhunspell_SOURCE_DIR}" + RESULT_VARIABLE _sapi_libhunspell_config_result + ) + if(NOT _sapi_libhunspell_config_result EQUAL "0") + message(FATAL_ERROR "Configuration for libhunspell failed: " + "${_sapi_libhunspell_config_result}") endif() file(SHA256 "${libhunspell_SOURCE_DIR}/config.status" _sapi_CONFIG_STATUS) set(libhunspell_CONFIG_STATUS "${_sapi_CONFIG_STATUS}" CACHE INTERNAL "") @@ -58,37 +67,37 @@ if(NOT libhunspell_POPULATED) endif() add_library(hunspell STATIC - ${libhunspell_SOURCE_DIR}/src/hunspell/affentry.cxx - ${libhunspell_SOURCE_DIR}/src/hunspell/affentry.hxx - ${libhunspell_SOURCE_DIR}/src/hunspell/affixmgr.cxx - ${libhunspell_SOURCE_DIR}/src/hunspell/affixmgr.hxx - ${libhunspell_SOURCE_DIR}/src/hunspell/atypes.hxx - ${libhunspell_SOURCE_DIR}/src/hunspell/baseaffix.hxx - ${libhunspell_SOURCE_DIR}/src/hunspell/csutil.cxx - ${libhunspell_SOURCE_DIR}/src/hunspell/csutil.hxx - ${libhunspell_SOURCE_DIR}/src/hunspell/filemgr.cxx - ${libhunspell_SOURCE_DIR}/src/hunspell/filemgr.hxx - ${libhunspell_SOURCE_DIR}/src/hunspell/hashmgr.cxx - ${libhunspell_SOURCE_DIR}/src/hunspell/hashmgr.hxx - ${libhunspell_SOURCE_DIR}/src/hunspell/htypes.hxx - ${libhunspell_SOURCE_DIR}/src/hunspell/hunspell.cxx - ${libhunspell_SOURCE_DIR}/src/hunspell/hunspell.h - ${libhunspell_SOURCE_DIR}/src/hunspell/hunspell.hxx - ${libhunspell_SOURCE_DIR}/src/hunspell/hunzip.cxx - ${libhunspell_SOURCE_DIR}/src/hunspell/hunzip.hxx - ${libhunspell_SOURCE_DIR}/src/hunspell/langnum.hxx - ${libhunspell_SOURCE_DIR}/src/hunspell/phonet.cxx - ${libhunspell_SOURCE_DIR}/src/hunspell/phonet.hxx - ${libhunspell_SOURCE_DIR}/src/hunspell/replist.cxx - ${libhunspell_SOURCE_DIR}/src/hunspell/replist.hxx - ${libhunspell_SOURCE_DIR}/src/hunspell/suggestmgr.cxx - ${libhunspell_SOURCE_DIR}/src/hunspell/suggestmgr.hxx - ${libhunspell_SOURCE_DIR}/src/hunspell/utf_info.hxx - ${libhunspell_SOURCE_DIR}/src/hunspell/w_char.hxx + "${libhunspell_SOURCE_DIR}/src/hunspell/affentry.cxx" + "${libhunspell_SOURCE_DIR}/src/hunspell/affentry.hxx" + "${libhunspell_SOURCE_DIR}/src/hunspell/affixmgr.cxx" + "${libhunspell_SOURCE_DIR}/src/hunspell/affixmgr.hxx" + "${libhunspell_SOURCE_DIR}/src/hunspell/atypes.hxx" + "${libhunspell_SOURCE_DIR}/src/hunspell/baseaffix.hxx" + "${libhunspell_SOURCE_DIR}/src/hunspell/csutil.cxx" + "${libhunspell_SOURCE_DIR}/src/hunspell/csutil.hxx" + "${libhunspell_SOURCE_DIR}/src/hunspell/filemgr.cxx" + "${libhunspell_SOURCE_DIR}/src/hunspell/filemgr.hxx" + "${libhunspell_SOURCE_DIR}/src/hunspell/hashmgr.cxx" + "${libhunspell_SOURCE_DIR}/src/hunspell/hashmgr.hxx" + "${libhunspell_SOURCE_DIR}/src/hunspell/htypes.hxx" + "${libhunspell_SOURCE_DIR}/src/hunspell/hunspell.cxx" + "${libhunspell_SOURCE_DIR}/src/hunspell/hunspell.h" + "${libhunspell_SOURCE_DIR}/src/hunspell/hunspell.hxx" + "${libhunspell_SOURCE_DIR}/src/hunspell/hunzip.cxx" + "${libhunspell_SOURCE_DIR}/src/hunspell/hunzip.hxx" + "${libhunspell_SOURCE_DIR}/src/hunspell/langnum.hxx" + "${libhunspell_SOURCE_DIR}/src/hunspell/phonet.cxx" + "${libhunspell_SOURCE_DIR}/src/hunspell/phonet.hxx" + "${libhunspell_SOURCE_DIR}/src/hunspell/replist.cxx" + "${libhunspell_SOURCE_DIR}/src/hunspell/replist.hxx" + "${libhunspell_SOURCE_DIR}/src/hunspell/suggestmgr.cxx" + "${libhunspell_SOURCE_DIR}/src/hunspell/suggestmgr.hxx" + "${libhunspell_SOURCE_DIR}/src/hunspell/utf_info.hxx" + "${libhunspell_SOURCE_DIR}/src/hunspell/w_char.hxx" ) target_include_directories(hunspell PUBLIC - ${libhunspell_SOURCE_DIR}/src/hunspell + "${libhunspell_SOURCE_DIR}/src/hunspell" ) set(libhunspell_INCLUDE_DIR "${libhunspell_SOURCE_DIR}/src/hunspell") @@ -112,7 +121,7 @@ add_sapi_library( Hunspell_free_list INPUTS - ${libhunspell_INCLUDE_DIR}/hunspell.h + "${libhunspell_INCLUDE_DIR}/hunspell.h" LIBRARY hunspell LIBRARY_NAME Hunspell diff --git a/contrib/hunspell/sandboxed.h b/contrib/hunspell/sandboxed.h index ecd1503..282bead 100644 --- a/contrib/hunspell/sandboxed.h +++ b/contrib/hunspell/sandboxed.h @@ -35,6 +35,7 @@ class HunspellSapiSandbox : public HunspellSandbox { .AllowOpen() .AllowRead() .AllowWrite() + .AllowGetPIDs() .AllowSystemMalloc() .AllowExit() .AllowSyscalls({ diff --git a/contrib/jsonnet/README.md b/contrib/jsonnet/README.md index abd9bd2..5c3eefb 100644 --- a/contrib/jsonnet/README.md +++ b/contrib/jsonnet/README.md @@ -1,6 +1,9 @@ # Jsonnet Sandboxed API -This library provides a sandboxed version of the +This library was sandboxed as part of Google's summer 2020 internship program +([blog post](https://security.googleblog.com/2020/12/improving-open-source-security-during.html)). + +This directory contains a sandbox for the [Jsonnet](https://github.com/google/jsonnet) library. ## How to use from an existing Project diff --git a/oss-internship-2020/pffft/CMakeLists.txt b/contrib/pffft/CMakeLists.txt similarity index 63% rename from oss-internship-2020/pffft/CMakeLists.txt rename to contrib/pffft/CMakeLists.txt index 5641b62..5b05ef4 100644 --- a/oss-internship-2020/pffft/CMakeLists.txt +++ b/contrib/pffft/CMakeLists.txt @@ -12,50 +12,48 @@ # See the License for the specific language governing permissions and # limitations under the License. -cmake_minimum_required(VERSION 3.10) - +cmake_minimum_required(VERSION 3.13..3.22) project(pffft CXX C) set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED True) +if(NOT TARGET sapi::sapi) + set(SAPI_ROOT "../.." CACHE PATH "Path to the Sandboxed API source tree") + add_subdirectory("${SAPI_ROOT}" + "${CMAKE_BINARY_DIR}/sandboxed-api-build" + EXCLUDE_FROM_ALL) +endif() + +include(CheckLibraryExists) + +FetchContent_Declare(pffft + GIT_REPOSITORY https://bitbucket.org/jpommier/pffft.git + GIT_TAG 988259a41d1522047a9420e6265a6ba8289c1654 # 2021-12-02 +) +FetchContent_MakeAvailable(pffft) + add_library(pffft STATIC - master/pffft.c - master/pffft.h - master/fftpack.c - master/fftpack.h + "${pffft_SOURCE_DIR}/pffft.c" + "${pffft_SOURCE_DIR}/pffft.h" + "${pffft_SOURCE_DIR}/fftpack.c" + "${pffft_SOURCE_DIR}/fftpack.h" ) add_executable(pffft_main - master/test_pffft.c + "${pffft_SOURCE_DIR}/test_pffft.c" ) - target_link_libraries(pffft_main PRIVATE pffft ) -set(MATH_LIBS "") -include(CheckLibraryExists) -check_library_exists(m sin "" LIBM) -if(LIBM) - list(APPEND MATH_LIBS "m") +check_library_exists(m sin "" _sapi_HAVE_LIBM) +if(_sapi_HAVE_LIBM) + target_link_libraries(pffft PUBLIC + m + ) endif() -target_link_libraries(pffft PUBLIC ${MATH_LIBS}) - -# Adding dependencies -set(SAPI_ROOT "../.." CACHE PATH "Path to the Sandboxed API source tree") -# Then configure: -# mkdir -p build && cd build -# cmake .. -G Ninja -DSAPI_ROOT=$HOME/sapi_root - -set(SAPI_ENABLE_EXAMPLES OFF CACHE BOOL "") -set(SAPI_ENABLE_TESTS OFF CACHE BOOL "") -add_subdirectory("${SAPI_ROOT}" - "${CMAKE_BINARY_DIR}/sandboxed-api-build" - # Omit this to have the full Sandboxed API in IDE - EXCLUDE_FROM_ALL) - add_sapi_library(pffft_sapi FUNCTIONS pffft_new_setup pffft_destroy_setup @@ -83,22 +81,23 @@ add_sapi_library(pffft_sapi sinti sint - INPUTS master/pffft.h master/fftpack.h + INPUTS "${pffft_SOURCE_DIR}/pffft.h" + "${pffft_SOURCE_DIR}/fftpack.h" LIBRARY pffft LIBRARY_NAME Pffft NAMESPACE "" ) - +add_library(sapi_contrib::pffft ALIAS pffft_sapi) target_include_directories(pffft_sapi INTERFACE "${PROJECT_BINARY_DIR}" + "${SAPI_SOURCE_DIR}" ) add_executable(pffft_sandboxed main_pffft_sandboxed.cc ) - target_link_libraries(pffft_sandboxed PRIVATE - pffft_sapi + sapi_contrib::pffft sapi::sapi ) diff --git a/oss-internship-2020/pffft/README.md b/contrib/pffft/README.md similarity index 76% rename from oss-internship-2020/pffft/README.md rename to contrib/pffft/README.md index d847b72..88bec66 100644 --- a/oss-internship-2020/pffft/README.md +++ b/contrib/pffft/README.md @@ -1,16 +1,35 @@ # Sandboxing PFFFT library +This library was sandboxed as part of Google's summer 2020 internship program +([blog post](https://security.googleblog.com/2020/12/improving-open-source-security-during.html)). + Build System: CMake OS: Linux -### Check out the PFFFT library & CMake set up -``` -git submodule update --init --recursive +### How to use from an existing Project -mkdir -p build && cd build -cmake .. -G Ninja -DPFFFT_ROOT_DIR=$PWD -ninjas +If your project does not include Sandboxed API as a dependency yet, add the +following lines to the main `CMakeLists.txt`: + +```cmake +include(FetchContent) + +FetchContent_Declare(sandboxed-api + GIT_REPOSITORY https://github.com/google/sandboxed-api + GIT_TAG main # Or pin a specific commit/tag +) +FetchContent_MakeAvailable(sandboxed-api) # CMake 3.14 or higher + +add_sapi_subdirectory(contrib/pffft) ``` + +The `add_sapi_subdirectory()` macro sets up the source and binary directories +for the sandboxed jsonnet targets. + +Afterwards your project's code can link to `sapi_contrib::pffft` and use the +generated header `pffft_sapi.sapi.h`. An example sandbox policy can be found +in `main_pffft_sandboxed.cc`. + ### For testing: `cd build`, then `./pffft_sandboxed` @@ -19,14 +38,15 @@ display custom info with `./pffft_sandboxed --logtostderr` ## ***About the project*** -*PFFFT library is concerned with 1D Fast-Fourier Transformations finding a + +PFFFT library is concerned with 1D Fast-Fourier Transformations finding a compromise between accuracy and speed. It deals with real and complex vectors, both cases being illustrated in the testing part (`test_pffft.c` for initially and original version, `main_pffft_sandboxed.cc` for our currently implemented sandboxed version). The original files can be found at: https://bitbucket.org/jpommier/pffft/src.* -*The purpose of sandboxing is to limit the permissions and capabilities of +The purpose of sandboxing is to limit the permissions and capabilities of library’s methods, in order to secure the usage of them. After obtaining the sandbox, the functions will be called through an Sandbox API (being called `api` in the current test) and so, the @@ -50,10 +70,12 @@ Without using this type of argument when running, the output format is set by default.* #### CMake observations resume: + * linking pffft and fftpack (which contains necessary functions for pffft) * set math library #### Sandboxed main observations resume: + * containing two testing parts (fft / pffft benchmarks) * showing the performance of the transformations implies testing them through various FFT dimenstions. diff --git a/oss-internship-2020/pffft/main_pffft_sandboxed.cc b/contrib/pffft/main_pffft_sandboxed.cc similarity index 99% rename from oss-internship-2020/pffft/main_pffft_sandboxed.cc rename to contrib/pffft/main_pffft_sandboxed.cc index e9a6abb..41b5523 100644 --- a/oss-internship-2020/pffft/main_pffft_sandboxed.cc +++ b/contrib/pffft/main_pffft_sandboxed.cc @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include +#include #include #include @@ -21,6 +21,7 @@ #include #include +#include "gflags/gflags.h" #include "pffft_sapi.sapi.h" // NOLINT(build/include) #include "sandboxed_api/util/flag.h" #include "sandboxed_api/vars.h" diff --git a/contrib/turbojpeg/CMakeLists.txt b/contrib/turbojpeg/CMakeLists.txt new file mode 100644 index 0000000..3df69ea --- /dev/null +++ b/contrib/turbojpeg/CMakeLists.txt @@ -0,0 +1,44 @@ +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +cmake_minimum_required(VERSION 3.13..3.22) +project(turbojpeg-sapi CXX C) + +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED True) + +if(NOT TARGET sapi::sapi) + set(SAPI_ROOT "../.." CACHE PATH "Path to the Sandboxed API source tree") + add_subdirectory("${SAPI_ROOT}" + "${CMAKE_BINARY_DIR}/sandboxed-api-build" + EXCLUDE_FROM_ALL) +endif() + +find_package(PkgConfig REQUIRED) +pkg_check_modules(TURBOJPEG REQUIRED IMPORTED_TARGET libturbojpeg) + +add_sapi_library(turbojpeg_sapi + INPUTS "${TURBOJPEG_INCLUDEDIR}/turbojpeg.h" + LIBRARY turbojpeg + LIBRARY_NAME TurboJPEG + NAMESPACE "turbojpeg_sapi" +) +add_library(sapi_contrib::turbojpeg ALIAS turbojpeg_sapi) +target_include_directories(turbojpeg_sapi INTERFACE + "${PROJECT_BINARY_DIR}" +) + +if(SAPI_ENABLE_TESTS) + add_subdirectory(tests) +endif() diff --git a/contrib/turbojpeg/tests/CMakeLists.txt b/contrib/turbojpeg/tests/CMakeLists.txt new file mode 100644 index 0000000..7e0ee1c --- /dev/null +++ b/contrib/turbojpeg/tests/CMakeLists.txt @@ -0,0 +1,26 @@ +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +include(GoogleTest) + +add_executable(turbojpeg_sapi_test turbojpeg_sapi_test.cc) + +target_link_libraries(turbojpeg_sapi_test PRIVATE + turbojpeg_sapi + sapi::base + gtest + gmock +) + +gtest_discover_tests(turbojpeg_sapi_test PROPERTIES ENVIRONMENT "TEST_FILES_DIR=${PROJECT_SOURCE_DIR}/tests") diff --git a/contrib/turbojpeg/tests/sample.jpeg b/contrib/turbojpeg/tests/sample.jpeg new file mode 100644 index 0000000..c91c82d Binary files /dev/null and b/contrib/turbojpeg/tests/sample.jpeg differ diff --git a/contrib/turbojpeg/tests/sample.rgb b/contrib/turbojpeg/tests/sample.rgb new file mode 100644 index 0000000..4abc9f0 Binary files /dev/null and b/contrib/turbojpeg/tests/sample.rgb differ diff --git a/contrib/turbojpeg/tests/turbojpeg_sapi_test.cc b/contrib/turbojpeg/tests/turbojpeg_sapi_test.cc new file mode 100644 index 0000000..f7b73cc --- /dev/null +++ b/contrib/turbojpeg/tests/turbojpeg_sapi_test.cc @@ -0,0 +1,181 @@ +// Copyright 2022 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#define _GNU_SOURCE 1 +#include "../turbojpeg_sapi.h" // NOLINT(build/include) + +#include + +#include +#include +#include +#include + +#include "gflags/gflags.h" +#include "glog/logging.h" +#include "gmock/gmock.h" +#include "gtest/gtest.h" +#include "sandboxed_api/testing.h" +#include "sandboxed_api/util/fileops.h" +#include "sandboxed_api/util/path.h" +#include "sandboxed_api/util/status_matchers.h" +#include "turbojpeg_sapi.sapi.h" // NOLINT(build/include) + +namespace { + +using ::sapi::IsOk; +using ::testing::Eq; +using ::testing::Gt; +using ::testing::Not; +using ::testing::NotNull; +using ::testing::StrEq; + +class TurboJpegSapiSandboxTest : public testing::Test { + protected: + static void SetUpTestSuite() { + ASSERT_THAT(getenv("TEST_FILES_DIR"), NotNull()); + sandbox_ = new TurboJpegSapiSandbox(); + ASSERT_THAT(sandbox_->Init(), IsOk()); + api_ = new turbojpeg_sapi::TurboJPEGApi(sandbox_); + } + static void TearDownTestSuite() { + delete api_; + delete sandbox_; + } + + static std::string GetTurboJpegErrorStr(sapi::v::Ptr* handle) { + auto errmsg_ptr = api_->tjGetErrorStr2(handle); + if (!errmsg_ptr.ok()) return "Error getting error message"; + auto errmsg = + sandbox_->GetCString(sapi::v::RemotePtr(errmsg_ptr.value()), 256); + if (!errmsg.ok()) return "Error getting error message"; + return errmsg.value(); + } + static turbojpeg_sapi::TurboJPEGApi* api_; + static TurboJpegSapiSandbox* sandbox_; +}; + +turbojpeg_sapi::TurboJPEGApi* TurboJpegSapiSandboxTest::api_; +TurboJpegSapiSandbox* TurboJpegSapiSandboxTest::sandbox_; + +std::string GetTestFilePath(const std::string& filename) { + return sapi::file::JoinPath(getenv("TEST_FILES_DIR"), filename); +} + +std::streamsize GetStreamSize(std::ifstream& stream) { + stream.seekg(0, std::ios_base::end); + std::streamsize ssize = stream.tellg(); + stream.seekg(0, std::ios_base::beg); + + return ssize; +} + +absl::StatusOr> ReadFile(const std::string& in_file, + size_t expected_size = SIZE_MAX) { + std::ifstream f(GetTestFilePath(in_file)); + if (!f.is_open()) { + return absl::UnavailableError("File could not be opened"); + } + std::streamsize ssize = GetStreamSize(f); + if (expected_size != SIZE_MAX && ssize != expected_size) { + return absl::UnavailableError("Incorrect size of file"); + } + std::vector inbuf(ssize); + f.read(reinterpret_cast(inbuf.data()), ssize); + if (ssize != f.gcount()) { + return absl::UnavailableError("Premature end of file"); + } + if (f.fail() || f.eof()) { + return absl::UnavailableError("Error reading file"); + } + return inbuf; +} + +TEST_F(TurboJpegSapiSandboxTest, Compressor) { + absl::StatusOr compression_handle_raw = api_->tjInitCompress(); + ASSERT_THAT(compression_handle_raw, IsOk()); + ASSERT_THAT(compression_handle_raw.value(), NotNull()); + sapi::v::RemotePtr compression_handle{compression_handle_raw.value()}; + auto result = ReadFile("sample.rgb", 12 * 67 * 3); + ASSERT_THAT(result, IsOk()); + sapi::v::Array array(result->data(), result->size()); + + sapi::v::GenericPtr buffer; + { + sapi::v::ULong length{0}; + auto result = api_->tjCompress2(&compression_handle, array.PtrBefore(), 12, + 36, 67, TJPF_RGB, buffer.PtrAfter(), + length.PtrBoth(), TJSAMP_444, 10, 0); + ASSERT_THAT(result, IsOk()); + ASSERT_THAT(result.value(), Eq(0)) + << "Error from sandboxee: " + << GetTurboJpegErrorStr(&compression_handle); + ASSERT_TRUE(buffer.GetValue()); + ASSERT_TRUE(buffer.GetRemote()); + ASSERT_THAT(length.GetValue(), Gt(0)); + } + auto value = buffer.GetValue(); + + auto destroy_result = api_->tjDestroy(&compression_handle); + ASSERT_THAT(destroy_result, IsOk()); + ASSERT_THAT(destroy_result.value(), Eq(0)); +} + +TEST_F(TurboJpegSapiSandboxTest, Decompressor) { + absl::StatusOr decompression_handle_raw = api_->tjInitDecompress(); + ASSERT_THAT(decompression_handle_raw, IsOk()); + ASSERT_THAT(decompression_handle_raw.value(), NotNull()); + sapi::v::RemotePtr decompression_handle{decompression_handle_raw.value()}; + auto result = ReadFile("sample.jpeg"); + ASSERT_THAT(result, IsOk()); + sapi::v::Array array(result->data(), result->size()); + + sapi::v::Int width{0}; + sapi::v::Int height{0}; + sapi::v::Int subsamp{0}; + sapi::v::Int colorspace{0}; + auto decompress_result = api_->tjDecompressHeader3( + &decompression_handle, array.PtrBefore(), result->size(), + width.PtrAfter(), height.PtrAfter(), subsamp.PtrAfter(), + colorspace.PtrAfter()); + ASSERT_THAT(decompress_result, IsOk()); + ASSERT_THAT(decompress_result.value(), Eq(0)) + << "Error from sandboxee: " + << GetTurboJpegErrorStr(&decompression_handle); + + ASSERT_THAT(width.GetValue(), Eq(67)); + ASSERT_THAT(height.GetValue(), Eq(12)); + ASSERT_THAT(subsamp.GetValue(), Eq(TJSAMP_GRAY)); + ASSERT_THAT(colorspace.GetValue(), Eq(TJCS_GRAY)); + + auto arr = sapi::v::Array(12 * 67 * 3); + decompress_result = api_->tjDecompress2( + &decompression_handle, array.PtrBefore(), result->size(), arr.PtrAfter(), + 12, 36, 67, TJCS_RGB, 0); + ASSERT_THAT(decompress_result, IsOk()); + EXPECT_THAT(decompress_result.value(), Eq(0)) + << "Error from sandboxee: " + << GetTurboJpegErrorStr(&decompression_handle); + + decompress_result = api_->tjDestroy(&decompression_handle); + ASSERT_THAT(decompress_result, IsOk()); + ASSERT_THAT(decompress_result.value(), Eq(0)); +} +} // namespace + +int main(int argc, char* argv[]) { + ::google::InitGoogleLogging(program_invocation_short_name); + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} diff --git a/contrib/turbojpeg/turbojpeg_sapi.h b/contrib/turbojpeg/turbojpeg_sapi.h new file mode 100644 index 0000000..0a3f2e2 --- /dev/null +++ b/contrib/turbojpeg/turbojpeg_sapi.h @@ -0,0 +1,44 @@ +// Copyright 2022 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef CONTRIB_TURBOJPEG_TURBOJPEG_SAPI_H_ +#define CONTRIB_TURBOJPEG_TURBOJPEG_SAPI_H_ + +#include + +#include "sandboxed_api/util/fileops.h" +#include "turbojpeg_sapi.sapi.h" // NOLINT(build/include) +class TurboJpegSapiSandbox : public turbojpeg_sapi::TurboJPEGSandbox { + public: + std::unique_ptr ModifyPolicy( + sandbox2::PolicyBuilder*) override { + return sandbox2::PolicyBuilder() + .AllowSystemMalloc() + .AllowRead() + .AllowStat() + .AllowWrite() + .AllowExit() + .AllowSyscalls({ + __NR_futex, + __NR_close, + __NR_lseek, + __NR_getpid, + __NR_clock_gettime, + }) + .AllowLlvmSanitizers() + .BuildOrDie(); + } +}; + +#endif // CONTRIB_TURBOJPEG_TURBOJPEG_SAPI_H_ diff --git a/contrib/zopfli/CMakeLists.txt b/contrib/zopfli/CMakeLists.txt new file mode 100644 index 0000000..4de454d --- /dev/null +++ b/contrib/zopfli/CMakeLists.txt @@ -0,0 +1,68 @@ +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +cmake_minimum_required(VERSION 3.13..3.22) + +project(sapi_zopfli CXX) + +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED True) + +if(NOT TARGET sapi::sapi) + set(SAPI_ROOT "../.." CACHE PATH "Path to the Sandboxed API source tree") + add_subdirectory("${SAPI_ROOT}" + "${CMAKE_BINARY_DIR}/sandboxed-api-build" + EXCLUDE_FROM_ALL) +endif() + +FetchContent_Declare(zopfli + GIT_REPOSITORY https://github.com/google/zopfli.git + GIT_TAG 831773bc28e318b91a3255fa12c9fcde1606058b +) +FetchContent_MakeAvailable(zopfli) + +add_sapi_library( + sapi_zopfli + + FUNCTIONS + ZopfliInitOptions + + ZopfliCompress + + ZopfliDeflate + ZopfliZlibCompress + ZopfliGzipCompress + + INPUTS + ${zopfli_SOURCE_DIR}/src/zopfli/deflate.h + ${zopfli_SOURCE_DIR}/src/zopfli/gzip_container.h + ${zopfli_SOURCE_DIR}/src/zopfli/zlib_container.h + + LIBRARY Zopfli::libzopfli + LIBRARY_NAME Zopfli + NAMESPACE "" +) +add_library(sapi_contrib::zopfli ALIAS sapi_zopfli) +target_include_directories(sapi_zopfli INTERFACE + "${PROJECT_BINARY_DIR}" + "${SAPI_SOURCE_DIR}" +) + +if(SAPI_ENABLE_EXAMPLES) + add_subdirectory(example) +endif() + +if(SAPI_ENABLE_TESTS) + add_subdirectory(test) +endif() diff --git a/contrib/zopfli/example/CMakeLists.txt b/contrib/zopfli/example/CMakeLists.txt new file mode 100644 index 0000000..f634c21 --- /dev/null +++ b/contrib/zopfli/example/CMakeLists.txt @@ -0,0 +1,23 @@ +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +add_executable(sapi_minizopfli + main.cc + ../utils/utils_zopfli.cc +) +target_link_libraries(sapi_minizopfli PRIVATE + sapi_contrib::zopfli + sapi::sapi + absl::flags_parse +) diff --git a/contrib/zopfli/example/main.cc b/contrib/zopfli/example/main.cc new file mode 100644 index 0000000..81b29ab --- /dev/null +++ b/contrib/zopfli/example/main.cc @@ -0,0 +1,73 @@ +// Copyright 2022 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include + +#include +#include +#include + +#include "sandboxed_api/util/flag.h" +#include "absl/flags/parse.h" +#include "contrib/zopfli/sandboxed.h" +#include "contrib/zopfli/utils/utils_zopfli.h" + +ABSL_FLAG(bool, zlib, false, "zlib compression"); +ABSL_FLAG(bool, gzip, false, "gzip compression"); + +int main(int argc, char* argv[]) { + std::string prog_name(argv[0]); + google::InitGoogleLogging(argv[0]); + std::vector args = absl::ParseCommandLine(argc, argv); + + if (args.size() != 3) { + std::cerr << "Usage:\n " << prog_name << " INPUT OUTPUT\n"; + return EXIT_FAILURE; + } + + std::ifstream infile(args[1], std::ios::binary); + if (!infile.is_open()) { + std::cerr << "Unable to open " << args[1] << std::endl; + return EXIT_FAILURE; + } + std::ofstream outfile(args[2], std::ios::binary); + if (!outfile.is_open()) { + std::cerr << "Unable to open " << args[2] << std::endl; + return EXIT_FAILURE; + } + + ZopfliSapiSandbox sandbox; + if (!sandbox.Init().ok()) { + std::cerr << "Unable to start sandbox\n"; + return EXIT_FAILURE; + } + + ZopfliApi api(&sandbox); + + ZopfliFormat format = ZOPFLI_FORMAT_DEFLATE; + if (absl::GetFlag(FLAGS_zlib)) { + format = ZOPFLI_FORMAT_ZLIB; + } else if (absl::GetFlag(FLAGS_gzip)) { + format = ZOPFLI_FORMAT_GZIP; + } + + absl::Status status = Compress(api, infile, outfile, format); + if (!status.ok()) { + std::cerr << "Unable to compress file.\n"; + std::cerr << status << std::endl; + return EXIT_FAILURE; + } + + return EXIT_SUCCESS; +} diff --git a/contrib/zopfli/files/binary b/contrib/zopfli/files/binary new file mode 100644 index 0000000..e71a662 Binary files /dev/null and b/contrib/zopfli/files/binary differ diff --git a/contrib/zopfli/files/text b/contrib/zopfli/files/text new file mode 100644 index 0000000..e9774fd --- /dev/null +++ b/contrib/zopfli/files/text @@ -0,0 +1,2000 @@ +brQMd69xkCh96E0xZceieHvH7CaXCdUSNJYgpGoR1DlMnOulgv34ZY2nQSnrtGPMIJhKrvX7j1O8ybgzXXLxkqZHGVflxBVbQxB3 +rtomztWK8aOqaD8zNwTUvGzYbJT7vyqWmB7hSNkZje3LF6oUXE89ceW51bsltuiqIkcs6OCM92USuFkx7PWXv6K98ZVXP9mLx0Af +sdN0RKmgIRoAngqvcxTVRNXmLcj8mcGZ8cpyuMRBF7vlhJ4smmX5zuHu9LkUKBE2jDK6aXDB3NtO21Oab1Ukq4R3AxhEHmy00IqN +7vFCFR2wrQFMC2rY4Z0I0MeKqRH8WBnDRFoovx1yJ6awr7s8h84SEKETP6IKYzkedm7FAcSFUpLUvHSY1l74fvFS9Q1ED9emxfLI +fwG4xeBsMZQow4v6fA1HGf5gg5KyfVljUbqPAHHvWu65o8PsaopgU0wDi1BkfXtKTZdd9Gb6HvZqd9dFi1H7vrla0wQNHSUGN18B +y0bVtt4vcUYhAH3IGF5rBoBdV604Fknlc3v5t0SYO72wVHTyAtDcU0T4NKNJh5EuDzd9tVH4ho5XrenFaILS3LT1SEOTar6eJvel +KarxnHmtfzCqJbooHN1PQStZnUbAea0jyXYlAvtsPX0bEiOTYAAzG8xMEOFhk8DIxzVMLroMTrdmSfUu1yt0Scj2saODV2UnKTyz +N9rwd0FNgKdsJDT2QjQAUlkpIufFh8zvLGvvQOzsTI7frDcdI2iqcNb77kSOKINFEvPaZ7zGRF30w19SSyRB6PvsxqJpXH9qHBNs +32rz3FrmUEWAgIRvk1I3n1jVIHb2qwPunQFSm68aAh3GjvHz3HCpqzmaOQgRV7C7osEff6ylMUwkGnkmHchN3HDadB2WR5VZm9Ec +6CiFe3fp9T5bUzMlMLzDFWBp9MI12jdfTUVa298bIrudk0Mkd5tdQFjLZEuH3gDk9oa7s9GKV3jbzKxgd8aZRjP6Gv71C1b41HpO +vddl2qzjwqgpgBBYUtSornd36LUF0uaWARK08vFtJMJNedEPyfqM1GyqIRhWEkc5yewxIGGAAnyqVOWLv9WMzlKRERhCjIpqlsZr +7Nu2TVjIK6k82oaBSpTWHcOawWJuTD5xibSwFc4ZNEcEUrwVfI6iRVTG4ncnFwFvEqlCW34ai1uY8fXtYeuUMDhHlH8Hzle9jTUt +Tg0YgtxiuUCkfLwG5dEHERDbpyQdAR9Pli6DXOqIfa5UIDY1likboJaZL0UOCxxWc8bl9gOkOWkvf9pYNzUxhUCZgfKgHyQy5oSv +Dd9QPnHCCoNHkxvWM1dEXsq6e5haKTcphSgwxi6ArzyrJ5ZwjGAHoZL7tzPe1FhCRq0zPYTUa8bXWcjufPq4TqBEut3mB3Mnww2r +cidq7iltZytPVo38TNuhNmNNHq8aRwKX0ZgRmb9ZFo8lv1Ltj87iJgFIm1JA01ZRyBBcHwTWkaJf5Bn4izhTQbolpiau7sHOqXUz +gxvImmCye327Peivc07s3Uic67fsLUNcw2f4k7OEvLkZ8mLhKjCy93Yca463YPeg3X5QQWgZieGW0FHPenwCpu2fBEa9DQZgTAKK +VWhrnCiliCIqS878gARMXkwYelfgiZA3cmE6LrmGbIKr8oCZCuNysKnSW1KnQJnAxb4FgrdE0JTpAux4xumLWLrhkI8Xos36EpKW +yPcYl3wp3sZSoUw1fGx7sA9XPmls9VUoBAHtHv74lv4CtAOVSeEeHZ2pXBzVWOVIk0pLKssQY6Yd6cdN4oKNA7QkKSM4AGNnPcdb +Mue21kH9VogICkL4igE7xB1QxDfk79YuKYpAhMatnYEMNaq8kGp4vz83hnbIPc3qDBWWuth3hcjVq6FHZOcWWBDfEa6462Brfqbw +62JTnsp9OxMQrMVKev96zdKkWLVgXkKalVlHXe49HP7wXwswznhEypnj3tzbUnGbgXPEjvAFUUpieA147EhxuFJY6mTCUvKps8fN +zPws4C943ZlS35OIVqnGgmSFEaHlVgDzt1OjxZfG3Zas2XSGYhGXDCCUtPPsBMbWiusa36lx2hcQFuQkC16gcBTJAilpAkqP7vrF +NmrfDoJBl6vV58bcMEJxfrtwa7tHKf9Td6QMP2Y5LXcLa3wS8fbrjSx6JpNENla0vRQMz7rlRfUX1r6Ja0yp1PtAkvpE3v149qLO +9K7D1VOQ1YfUB4iYMRimqGSScTa7uVaZhlEgGYI35GS1SGo3KoELmHxucXSgn2mvQt8RLTjwVfTzBiKtJ0nvz5xRYV1nbUSgAn29 +T5IWjxDtzGWp1juNu1lYjJBn27XH4GL73DUGWzEUSY8za02sd7IlqNbi2L85aiWMji7yHQ8fvuVuYzpeCOcQNc33I6sfHeV2BWtu +UWsRjnaGZ0UohekoZ8IHSZ4prFArkNyc3cWrB5nCAPQp9tEKffNHjRy5s29HSi6LRIQZOq1LaQdr0W3nxvSnQCDaRHWAXF4iCmNk +X6V4iQceVT3AegcVI0iUcL5Ptt9dnsS3rfs8748jLKVGP6KrkAljfB22CBYPek6gDRGNNLUejq3e6b7oZTNlqF0E8co61C2V3HKl +dUzoXxnpDVqLMUkmugF7utCydNSapNXxF9kxfLmNzeb5dje7okr3Wr7ZRn7T519Aq7JjduICDOVGkEdnhKoWaCectsySR6EvGM6g +cjT4LxTRC6GeYT9YeAZotxaEHxliMImybu8T05d4XTSO2fKbZF6iKYbPFqmiXP8agdaW8884k1EMjYpHsmFA7hq2QqUAjweqo901 +YzogqMrNTzsGXOmYvICowo2Y5ar4Cu3nqyz3g6nCZ5dV0qeBmAmT49d29AfULqUr59118XVEIn4R1UFtLg7NO8B4iJL1bfNbYzmX +y1f9KY60Kx2YjecEateIQT41PVaL8xvvR5FVDuJRm2AWtrlapRoMMOfcfYMvo5kxCM466PDhvoqfNntFdDaFTBHacHOGaNBpoIEr +3Pe6xI4PIqXAbYq7h7KFpcOgBAFTSwKdNzxAqCTNdV837QQFSbJrAVmeIfYustdCdm1GKVQFogOpdKHZwGzLzKexMfafJBhhIIE2 +JmLFA4aoI6NyMHn0oG5iSdfE0pQd8rctPCoSyXxjN90q7rTTKrP5mkCxlSi3Fel2eHSZkY1f66Lk1YHRdu7NbaWHxHQbZRXIlWcL +OsBXf41NGThtrBv8GeLXfYmJDSlPwSPBYOnFkUCnnKfn62uCRBAC1SlaGmQStocPDmy9BGsDGl1RSm6liOAnHNJNGX7mck2xH68E +F6v5kFTaipp0TPpO0O1jy5NtLJCuI1g2THQgPf3UelDrSH0GeynxwBJT4CF2eN7ljBJ9x6KpgN9K5Ksd6ZuJlTER49FbSY7XAgoH +hYiXglzPaUyPO3PSIi9vBLfCAfKIzbXwydjnJVzuZE2Q9jzcew4wyJJzME9hh7ZhTbGgeMGbBdM8ClOubNESKEhZvrJ11z5zy5uk +GTApn6yf4HHYYJEkzgjDZ3xEN5YHyjI0A64fsUc8z0808Wvx0mZyYPsOYBNukmm9mbMmOSd9ryB3og3V05KJy99Z5AFmpGJqwdCA +wq3C69xagluT2q9Ga8Z2MM182GIvshInvVmA6TVFmhSUozuJSqULRUmzgdyhVA6fjkiDbvTSRxm8L3lSkvfzmCQdh5FlGXCz7p7J +jp1fNfFsGR0zBQkqBLEETxjMSgkZuH5nf4HIoqUQvQwE8DfaolsLl7xWbovoNUj1qpZTtSOnxdhJtRURA6ATdFIBmgCymHqEWOg0 +IjMrtp2l0CgDtRkuzT4lmq7hMpbsqoOB08FtheLn0YbRtreDUn576slV3oGUTxs7BEDk9hNS4GxEQTxTiTkeimRIjKpv6uf6duzo +c8nU75P5yO1fuf4zKsj8I9AwkcqNakg6LwoURcMiBBfDG8w04G5rf5ATv2p5MMep0NnpZ9VQJ4duIebRuHYUnTKnoQaJU640rqy4 +iU5gjxttHMfHcGALN4iAsgQyAjeMwtEhbEaifFy1AItoSIQ9ykca2YbXYL2siXmsDugpJhxfgvhEmoc0AaqzEw8cMv9MLtcpyFHz +KUZ8Tm2xayyR6EWHJSXNcUr9ACqWEqSVoiZug9kn2Q0DR3vrcHYFpulq4BTQKN9eqSeVZ054V9PMsfNO1PgIqw1UZcdmCG84Jsh7 +lkVJjZ6wbUSPnHPxDCdx11bikQc9Vgeq7QodysZg6xq0KYsjtyty6EdgAAzimOT65iNEz5R64cDtQFaxSMP2d2RUQthCgS07QxKy +IyfiSE2D271H4el8I0b4NDw6pe5iDPeHqatNyUmKzzBeushlvc1Y1x9HF8mEYGvZZIUGM61te41cVvSQTetVrRqeysoozWdAeTDw +0rF42GkWTiAVsXb2nKgNmNmxsJnRuZ2k7G124yQ9IfOWroKcjrq5q2JcarvYPo8pZEhkc8lhW55t7sgEcRdKP5650igXxiya6qRz +DA1PXnCQs9DPmQj3pJdRzOTbbbbLxymoJzDvLT3e811b4RpRcWUYDrF5SlPpCIB9nD799POLFMyIsULpj5eAoZxHclQ9vDxwEdgH +bEKfH37LNBWZSwfJtIR4xnKVLHGGsE99qn4daRJI4gWIQWmzYNWfxnE9CkI7t5uahUycgJgLKGAIxYkZm0xnfJqET6VHOPlpygU1 +ukmNNi9W1C3DBC1qDrEsS159IkDB8m3nJTuKAD10fXZxTtoREbRIg2bzSy3uQ4fwsg25GH7GJB7cwA9b2oJmWQ4YPTtDtHzqKKqf +wnTrF2ZRAcLZTC4gzh9BlXHaXD9CDcT87VhVYdD8nyEgVaJh6qqRqhittNZvGl64LqR07Ezv95daiVl5bsuF9AnaO3m9T7JQQQsB +ysEw48UwA5gaCGPX5IfxpdLkEMqNuOkFcM0RRLwfu42W0KfEvK9nCsW4XhYzMxypzARU3jP5Bu44Rv4oCpiL3E9oYD4rkK87zBYW +Rhki49ShzG1gQxsejwNQ0s4YwKbqUoEGU7uZXhO0WHhHMX10k7lpvgZBYmzCpZNWPTuEx6rtE2RFm2WdYfuqTWYf6gJZShbDATI4 +TFMWmKzA0xHdWpcF34paJV9wlnp3EZyPvFCMpR8kk47wgkPqHhxMXiQGH8iALtZfPYbxVUquw7nQrwyySgPhin6Q0ZVHmj59o4fJ +8jYQTxMCYmSuwxducP8jKdbAgkMy1tE4EmCUnJ4JXYrJ1dl7xo6XHjXAWsK3YWgQRVsBVvGT0qOVObXuUyMbWmzc3R0Nbky76cOY +GKQZ5iXRYVNStiXh5a0mN39FI6fy0FZ43M3JDxfZAMO1v6T075gPgTlMHuUdUMEdFt1zLwFO4JP0lLVrrkQE5bVj4ipx1CvaATw6 +USKkqnNx1LQMEwWxM220nRgUXr3KANAalsba2C3kEQc0RU2tkP3B5up6xcpyb5UalWXL3ITGNyDu1k9wyuEVxX6gqQXueay8txj5 +gELaV1Zj3mrmIQDqsCWQ8hIUZ6PZStrCDex1pKNVR4pzf4PQPr4jEy0pgby60XaHbFUPqMovxxhx4nHYnmLceM68BerknyJ31qAl +eo5zzx1q4zdExga6ieG1odOtETnEDLvKiRezQMJnveUaBcQqaFVGTxdc3Kh7GyyQGJF6jyYzBtPqCbVchBfczGHHS3fW41TvGoue +azmAupenHNHpo7fNqQkS0uKtnHOjpbGuO1M1sUhytQ04NOVtojRa1lcz3DbkxBVGBcENBBhF2f7y4ZfQjvq6xEMlAerrrA5vNsCS +baJinvEbcmU8Rv5IC0zuwCADwzwtsrrWVQ9cnHrLgJ7nBaEiDvegACDEDBbYb2QpKCang1fnsN1s5BlLgoOasq7dT4wRw7mqHDnX +dDZzFDWfziGXmrxEkEnx4tngFlPmoSAOG0woKpkJ2ljSSxnvkG9SBN1jYLASeIJTcJh5K5bzQihxyOlTXji7IlK3plxI8DpOy2lC +yhynLWZIMeZFo7a6G7hLah87b9GrGErlDG2EOOy7xbvQe7Q1zZPN43Y37enaI9tuKTFRewju4OGOe27YL3UNtTCWMbdjviVWj1HS +rsc3xtSDEDlnTRRjWB7nKW1qMD3Kl41mFkL5VlaBBeC1fjml77b6ixWEkZaSj7Aq4sDz3JYnXprlTokATKcvev3JwQlACJ4jQ8RH +mp69O9Wn95somfW8Gc0ZVL18rIRdnlcYvH9jEL9VCmSDW6T29Re0CuZxaqd303TAujK5GX5s1qNjtsKyMt0xWoo89rgEFjQKrOrx +KwCwQMDfG4fqozxQyrKFxLmN6cZyb9ekNhYASZAsRZGYkjrYkQFEIjktR1JKQvqOghoeE8uWbRkK30uHeDFZOWRkWBlFhgrKWIlp +2QIWKlSPoVbjmxcIGsgqhfVJcOK53KPPr7Kdaa3c22QTSu3ww378QUdcTusFlNdi3lFgHwKII87pxOu7gzgRDP6sjPMHfSELVCRM +mqvnxuh186x3Gdc4I3zQti9OM3el3Vl9gMcSgVpYgdd1Qf3rXoA5YE8ChKlrdxa6hFk9Spp29DA8iHn1kvAbsl0pTQdYYVgDhgIa +SdnfG80ei1xdjBB7YqAIdsFU5lMcyprPaQEDpw8sBqAjf4iAViYk4uLmCv5ibQZEO2rdk1SXmEhz5mZcuy0XozJysCqnzOPGoLZS +rcJnDMa8KZXw8bNDrYp1HLMWRbLWrDd9pASPu5owBeuitqVxrNLdUxjZdfbqm9y7RFAH5atli08bNfxJz55UyOS2O8lyPNj9U9Ru +Bp6GMYoFW1lGxUhAUfFI7n5ZxXsAnzEw0mviQ3tj3vdIEDxF41hmYluKjkVRs30WlcHAw3AcTQPM2yOQqWZ2D7LG8Fmks3L5J0lD +9RWYSdt8HTQTngtpmpn2O6L42wmPqf5xgwkO2kOM8DWqFrjddCY5mzn2zqh7v8oxcxGy4KKSiPwToSaDw7vAcDTwDnUgrgvh7lAO +ZXv0MTQ1u4IjbCWiqTWU5g1MC6P1vMZ5BhI6mfRRAZ4VWNGr2lbYuy3ScXEiA0a4F2JXBvEJgrb1sVMDwvGzGGhytEh4rgOdhGDl +jmRRnD4Pdyn9WoUqlo4v9r3570smBfQtoXmfDoHcn4uVOYI5QvZ8UIzLba16LvWwjih2Sy5RQYgD6Dt1BS21tTyBMuVkLRWgD2JA +HEjX3mG0aRE8Zdv1WowW1fA1oTwOcDosZB9VAuBnNldYlABlLQX7y42fIvDzQauTOUi8IkfcZsN1aBn8Yb5DxtDWsaJn1P6AFU79 +B2X3XBGCxEwe8VO1xNx0rp3rJEMAgpbo1ZIfLdhnQoZ3jljYukBjGuGTC1buqAYXsfJ4WnZD1z92MaxPNyySa3wEfIiH1qfTlDGi +70c67uCeeSaUzT2i8r4wxR36HfyqUEaL4OqzqsWHGzy7bLISxi3xOUHx7yD56dkuOu6io1xe9wotntMqI6YkkrdHmUpY6vIiVtsa +WIiKKUgviW3J6u2R42tcXSEbcWvnrSgUZ4O1sDh4EkmmcvpH9toLbxYe4AzFuucnnjtDCZayJeigbzGAVCWvbYl1sqkP5cmrrB0o +u18bCrrtTpbkspcI73qiJXFKnRH145E2CppwJnvTZPdJ2vGfLGfToyPsKQI0OyruuVtWCllGnzEftjokoAjP3KvM4kdLVJ3w4Spk +XIslNwlqcVMmhmncP0PuO5jVfBXmX1XhQiCivrEu8FAfcRXQQ6VYhqbF5I837BaUOcb724i1HomzbZnmoVvjgLNlrhNCTUnEQl62 +vK4kugVs673LSNiqR3xYVUudY6wV5PoIK1sUGyaxvLUq7y3cJ6pv6dDwWjI6Q4hdwlcqAsHBLTVoA3TiPEkszdDmu51Eoxg9yWDU +nOEKcYXz3tRsXJItruJNXaa5v50X0ABacTHFRv8Cx4kAr55xaZ1IPQQW9edczn4V09LaitdWQ7zpcxvGqnc9xsKELBOx2moaR3qu +Pv4GzcsB16QjeC0YBXGtLdonfRJHYptDsooisA5J4CJ8tQJ5I7lrgJJ0lLt6kvD2DjGVeOAe9m6tNC3C3SfHca8gFUsfxUPyp0UU +CqtQylKHed0fIWYW4KAIawy3CWy83vRgQhPFW8CLRsOWy233gBZYWFnCx734WctWW4rd1FZhIJoGXCTT26PnE7TvFM87nTERXqdS +m6Oj451r0X84eCI65RKphxk4yzsIR0B6zDoAc2U1utYDXlgsQRByaIPOJloUDfbQECJLD6kZhFuh2hoz42LkNp1MEsAwqdxvKnRq +PjAAs7eA7qx9qBFo29McBotgelSp0zTzswzmmHdbWI2UantU8giPyOL6h5zdQpWF0LuQjZTLIlh6DZzvkN4IU8DwRaZN4vy1PRGC +xftQkj36DzWDsMCY85TOya6CMiV78DTTkdOhbJjWZ1htk380PNqheH4N9Md8eVUEmZRbRuLioHPOPyNKEH5wgNNQs7ZgRTOL40pU +SKonL5AHi0lRMMOysgy1iOh62ygfiK2uT3jolMzCl6o6M8OtFIMTMgyqyXDukBcM9fK3sjEo27MjBnHVz63hCEKOoKawCO1sGXd9 +PkQWnwoqJZ9lQcz5hB9gIeTrtGmAEwX4jto45ZPD19QEt8ldbNkeQc4xGkd0JT74EmBY4L54nn3K3i7ZI8BUB7KSQTXXSReB8vJL +iX83UJn8kOF3be3VC3vtu1CXt9CoFWswIxJdu0tb8lZifi3ApmKLhGi837JWtVG8zOhg8XbQluIxWCCPs0SeyW6dvxhKXhQwNe8N +vDRDKeNxraebNqYziU3v1VkkdrwTOHOv7E2kL5XhNEgpU9PyLrwtjl9Ilt4GqmCtOmwK4xS0fNHiIRqGWZnrRemSKUtbfGCMA1PS +OXLKeyFwGl25Xe2B4kcdAW5DJnUsEYA7V53KfqWsytoribVl9fhGnnyFh6l6HKCBOTCsI76eNBUKF7KOVKHOXMPK9GNixe9gz51m +mgEOYnBQGvTEoqZSKORjcOTve3OGhOI0UPn3tPZzgbbNuUyHh0ZaZU7tfhl9fM191SYMiFRCH6UJMclcrgKtYaJDVrNfJt0DfQh2 +tfhfbyS9ghdgpDGylG4uh6JASsauVpXO40oYXFzyQUjFRkVGFLfw2SQcGKiYvHuqVz5YxkrNAApGd2CyPg4ibcR63EqmEstBe3sf +1C0G8usetUUofgLvIuHxOreMcRlwgaCQp1mKsk5FCEzhWYzhBQS10YoxfuzOagYKkPMaH8MbOXf3fKwlwLVJ1KA3n2UXSsaKX761 +pYxLi7IFSrW4d5wYccQMlo39fyIemGz0GXMY7KEH16zdoVAlQW3omHfoLi2JusEE1J8RDdD2UqVf2l3lLGgTo62Xq5Z9ZJAWSEit +BDSeN029AbjA6K4AyLyDOvBK4VCz3nsybcpGQTCtkxBdafTHCg2KLuyWyaXpQyb0NCSz0OEXJVaxSagrAGTUzgOfr8cbNjwkcVgU +aKc0U3oAJYxWRgZHVktGCExK2Oq30lZhNES5m7chqVknrij7T6BWIlrzDtgO78fUiVGKjpYwNOSR2lHeO5CDKZoKisDjl7trtiy6 +TyoxfXA0gysdH8bsura74PWvjw2i7BiN3is71BVODj7Ak9CD12NrBiLlH5syBpafl8Ro8KG5mHN6SY0dtCA4vCdL8hgFOaK1ZSWS +vyUuRs0ER84chyMo0BhsbYvWz8AlsYMWZj19QOgkWhx3DGLAfbuUJJYWMmI5RtnJylaqXNVdvIwlTBDUSW68lTd2AIVtfdM5guJx +cY4wKHAa4IrfwQpcVWmXaHKxpYAWIlwtLKuPGgM46u3iXmnnfU4Tq4KKupyrJloI2i0hc7GOn5nRrHpntRgQ96ugSdi25th1NS4H +YUKefBWLsUmiCIFKTKHuKWte8tNMzG950akOuqUFXifz8Bu2rH2cO5H4tgNB6qn9KRUubcGrZDfji4fdZURi7Z84PYAEEXAaZgKa +wWxO8ZeVTh0KV8fBICdCRE4v9e3ww7wJBmIiyV8rvErl9qOPvCXJywo4XlyIuNS7kBMHBvrKMBxG09wZo6j66L4P4W2jUsrvCoCX +3FXmub9R2LSAykGcLPLDkAYIwqDRHVkxcy0mCfCG9bRRrm80nkVKdUvo4FI2n86dloHFiHEIocBBrxkFDed5sofn9FsIeuE53WME +F9EfZd21fFRa0b8bLQBzgAsKUvZQcSE1WUNbXSeTLNQiSwg8VyNNus40s4wTSWnsnT1tpCFgynNs9GPdBWP7w9Y4APvto18goUIt +fe22pIY9t7wM3NArdKLutiyvv5Vao3Zo1XW6OTIwQAn5o3JJiQnNiZCFCTDHWIh6jN7oNAUKbU17aGp0Nya6cg7uFVO1vlyvyOeS +HFEONOHpN2u3zXYilkD8pqkW43xHaQbsKMsNHE524z50023CmFdpLO6X01UEwB1q05yCe6JCNi9xTSEqdH9QZQarFZhNEmvpDwox +QT4eZbIyUlJpqhmIcHgmv60yO7YnwWHNUsrxZzdvYWVFljhwwJ5OOSWoRSXxuAEBttrezjKai5IEl87OcF5l0BowC4M98wE0FhJN +YFDoPuiFgBKObw8dC4mqKeakAs3DSIFqSMZM1gKuhwF8WrtRngpFlvbyi1tgX6P5WQOwFozwDnUB98YrDyetv8OtLZuXQOteQjVw +loZ62Aisfb58N4OJDciusrslnObMGvw6VhwlISpMj9bb1ECnwxrDO09vtlF8oFCUTWTPw7FPDrlhL3DwewFNYnwzEdypzVmVziQQ +axYTId5OFLtZgq4b8evUQaaB4ihPwblGUGcSIoQjoFjZqH15Aj9W6oXVwcIT8MyGXw8kth27yBozu7WRlorBUoWbBdiMSGrV1ihM +BvBh92xrnHQpteguA8UiIepUtXcNxduSLA45IGqNtgpPgtoQK4yNLt6lkWRFhYnclf1x6rB3ZlAXjv31EV1jzzPZfGs5cbLNwxLP +mmP32clBODNY3DXfawoJNjb9pPaF79Ys8lRAw0fdvzQIfnx1QuHnNN4eAKeBlLTf0S9dbIOixXIC1ARPghPbwN09VwyEa7JQWwoc +wyXR4eCm2PFjJUrTuLDCiiG9okqaV4T1aRhnvYopjrKJ3YJOE7FArlztaVouX9YRuL6VkLQYRJZ3DP0drb5WgIjmICAnO4rPTdfq +x0bfsJ7vXlVnEvWXt2CyY5Btzo1cVeFahA5F1MWUQU3mYyFae4NT9TqxqDvaO3uI3tKCZI91mV3MGPNj8IenYdBPMbL1ZWc9CZEH +0WTH4TkuZnPGnp3C1Yw8k17ZtdoDjwJjZxMYLDdFRVbzD3ywlvolXvgA1lGokYViKiV8VWhM7XE3W7ZbxA6HJXetU5G2HK6bKH93 +vDSooHYVto1GozOKMAVeMaiGPgdSZrvzmLdutIBLLxPyaIQDl72wHBpDVDQs2ydWrjHP0qQpdN0ehs6tl1YwFiWr3pR4wYuoznxj +xqNtHZRxxHm1IFKKUJSdigV1aTzLinO8ig6wDmAQ7y1x4RhOYFskjkrrXceOyHoDGVp0m83ITxTl8LtuIe2CT5r6Fz2bFULZpao4 +9R98ZCW7wJx4mGGEvmVaQfPszs5MULNPdCUAtsZFNQ2hpIGoBbwakQwH195XdpjTtnD06vmmvKaJ5Y7qzYfXs0saw2PN17Lsq528 +Elpx0idOT76nJymO32uTC4LbIfRmbmC6gGTIYymHoWuCGYFoH0zVPbKvKpq8ARQCoGpLat6UdBCZKXnoiODYTFyLfqUcsR0d7TlZ +GjjkpQtocYLON493OC3sTHVfCfDaPM6oVOAVVMDPDkEFRHNWZzVg8XXJLI3ZWJiUEiFJjfYM024nbIWi8C9QTCqf9pRANRqIFYXz +p1zBeMjAi1Lv9aoaQkhRu5GwJ1dsxxhn7PsdKsaiS7vxNi0GJHuNK8bpke64iaKJdULFpBP1J3c820MC8ZdblboMavUg8OBM2gQy +QKIJcdO4KAt47v7cq5dombSb0tj7sa8XMqYdSxqpxEunleQTJhihMr3yZkdakPgXIyGA5ewsguCcjrhEDWJJmKRnq9MtA8nlHVN0 +89dv5Qp4xZHJkDfmsmFpJYpnxuf96Ax6YmnSJpJEvpuFPEmp1N5nNUqQ22pJCyGZgqfQsCbTuYwXIKveYR4YZXGOpzinguZjU8uw +xk117hT9enJuyp0UC9bZWVnyNX7IpH3MUXMe6INP7ZazGHlsR2g8ncSa4R9mDrzaIucDmrArRGepEwJnM3iB1byja9fkjoVBls2w +UQzVOve0R9ZRughx721fvQ2yRQJOJOeRtrowD5tv8WbIkSYbqPttO62ydy0Es9ssJXESol34VEt7dGFEYDiAilAYSKetDCngRNTB +BBqcD7zGXNRvoxpaFoLh3Mk0yhgEHkDVBbsI6b7kMWjHMTAwqTFprOTKwT5YmSVJMAzwlZJCtp6cCQi6JJtKSeM658BOZud5YQw4 +xF6kr5EmyfuRBqQ7CI5IDEo4s7CycmcKmGihQO3VVrcYNAaaXsDPFuC3va3m8l1xlpItD4gVIDtbciqRDlIp5lYe4TaTUWQ1UrYF +v2L1FcrQoMUNMFmlbEXxbfU5QYzl3vOrzx5KL2ppEUgVlfed4EYpoNMczQNiGYO3yKj14C5A97qq852bUsc7lfUkJV4fw0Jb8EKc +o0OD4aZwzHsvwhQ6thYttPVqX4B5GK1nxGn8U3ceq4qKkFtxXRBHOQ89Nqq5CRh7dFEJIHhIgx2bFCP3JyldcTfQV3f3dvoIjZLB +3YItGNW8af9Z31cvHNUd1h4GvqWclb7LSzoIvBgGnLEI4CynDv7pgWi8Bv55GUkVcOcf5U8CGejtHlwO6Tzy9Pgz5MABA8qqjOAx +6pnAHqTq6qmPWgKrsTHI5WiOx8XGR88pipGvCDUpO9vjqIhKZRNoMlLtR6B1E8gzy4cpGZ8QfTGmXORSYDLeYoY35vrmy48FqYrJ +2chF7jytBAfBE8gKHRwClVvss8onzyvwYMC0ZPCMmV6XkP8bdyUuuDW9MSrMbMRnMbd11Y9ahye991xdU51sEI8R4mPxP4OkDsfb +q5jTOUm2WxdfkuA7ZjVvtBBb6IRAaqgagUgtshK36zJ2dm08fi1tiTyDg6ZC1CPMIpJPOeSniPpEft4zHPnkXt4lb9XcFhFHfv5q +wemHyfVraQGsDHVi6G1lsPwtRycdRPM6jOiBzg14SqaLF9QzaAUsXB2u9PYxwRb8Jl1PUmyjpTfYvniwhv7RJAB71T1GW24e0yye +ODylu3MvHDVlg09F7ls7rsyR29MNurj8H6okKNJnfF9yYqJBot3E6sNNSyLsq2V1WsWRUtt0AIY3DI9oKT9CTlgez3zDCO2sLpVA +c4P3lZi9zXDoAAgaeTeeULrkbDHzAckzbSYR6AUOAdr3eTQuhuo0806IxQgmaZopy5Ez2kPsgICezVkfYc7alxRYrMj9yOLpRhZ6 +58lLrEN5ZZskPkZgQHnuPaXPgAAOZuBdihD58GZahxGinz8B3RC7L9MEmzu9DgWFO0QZtraft0ilntvnayQUuyWj7oxOlxLOE0CN +IWdHP2S8CPTdDH5gI0RAGkVrlJg8oHiQuwwrR2f4mFStIVtBRBZ3xIztw0k7O8Bv3l79nGl2sVktTwspjJPL7MAXEotvqo2ywJ2l +HTA9Yeyvmrg6ZDTSpvGnoWo3lpnw0LpAamDD8IfEZFg00G3XgFffgbAQ3SS27VctEixFwwIC4xDGaiaCfcQO76LTgS8GJwYkJ2VK +25Db7yaHc7G9O77tzaSJh4C7ARPe6oaxr63PhqqdQimTmJJqJTeejIaWhtxh1XVTEdrEgYTLoPgC7trKDT2wRCBQ5HuGEPjfbbEy +3pEc9B09wcUAewWXZ7w9KUt5JQn0KOn9m2sYOTDBUodfpSOVfMOuW3Opm5bHHwcj9KBPpSNUrwaLd4Uw6t4z08HiXENCb5cEdco6 +091XVvojXaBmLvXzQnech0yTsTOeG5hW2NYYUmtLFaaxxZVgsC0ZoCXiug3OGrAYVLYhiUPFPcMqNWYLfcCifofteKsSu3ScCXyd +2x9asJnTHXgCUl5TmO7AscdCLsH8E7osEPo3Bg66aY9Kr6RJPUhK4AewHuVkpn9Wx1HRKnZSfxam8p8UZ0WY4uoruirDXYmDjKdA +ikJFwBa9sDkvezfPuaGsPWXjbUhYvtZPWs7o0Fc2MMIlZiN3og4tjWQJOkNKNtlCFGRWkRUp1IzfUeX3loUkExUkcbCXvkJvMEP2 +d4xv2TjlyzMXVlRtcyfojOeYSya6XDZxDkyGzmGGyEidp3JuMWRkchmixYw9027Y9E6BPKUAV1EamcxdEeIh8MXVjMTEU3asZqAO +WSAq50yPuHrFmg8f6sSQVaYr1vUXPmAwxcGGcbRAul930WaAQTkjbZlKSK55OC3qYEZMusDaKOYcarDLugPaoiDRnWG4JQMkdkdq +d5pMkIX9Tuv6Aj4X9A3U7Mc6nTh9qfLp1Q35Bf7ohP43KOEjloQ2mXEWA1aA86NIPOIcen6ShWvqUdJlXZufqxDG1DfGXidJqHU6 +9GH5oJPpdoc2sDA1bmpShj8CFFQ53tlBnaJ1IZzUQ9ofUcp7QXhGQrqDar4Ox1zyIWMWcropLQ3YuLg9aay1GFlvir1bxCN2k50N +wKuxHElJVGLJTdMhovUg2JODkHBSnD3ibeSX0QHZ0quhQHMFuUurlTunEeRjpdBEnMgpCaFsebXLDMFmFyI2VnCudtsTcc6rh1wQ +rHWD1MdaCR4c8wqRTrtuo7RVuap8F1VlqvJqpaeDh55eE5TBq1EUYKTRK3FF9OVq2pqj7ldcdVHoqbDsVofkoxqHSXWjKXFpNEEj +NlZAlgUxBfx9G8bxAzIKJKJsqiO9X82p8Alq1w7Bc62DXx9Zj6bVSyVf8kMN2nDfoy266Yz2A402PGi5lnEbOllXHeHMRAJlKKbW +TQthGyXQoD9699xR9sXBYomu5X7KQKcxfgjDvJwf3sifMAt6sBbuweERalFMkCC0WuDO44aFT0tDEqhukkfExA0XZ6uYrDCGurpN +SBwA8nqB2aXwiMZwYilN0TT9bMcOD4Era5olp4pjPX1L3hOtHHvbNvU0sr4nPoGu7hLdIce39Xatqd7Br6yEW45LMo4FpEE7YoFi +fRXgieTKSSp4p0R3NaLDOGDZuyuVctWEhkggJwlkaHQqnu3Ifm6PCFkPi44g7PghVEXI9NBP1MYKh1iglrcL9bIcMwuIhyWUwG0q +28axqKaiAcwfEEl9gmCSSx9T9RCBKdQOCvGF4qJc7F4LSRlBy8wTuQpZaXNKpt70VHfZUEZX7eCnftAiGzOriv4pSwoxrM9X6Jux +XewOy9RLTHhRALyswcRWCPHKxyWYo6CWPZbTropbsw1XAjJrULyQ2cy4mbtL7lB7l9VvbzXrdCzHSshTY9ZYbqaN9I0EeYHFNCTt +TLO4GOc7Z7JzPrep2Nkj1qakoO4yDm4FxMBfd3IUwLm1EyKwiuvAO5z4Iby9pfi3XWq0yRcHUV4Y9GtFvDh3qgfiAyu3kmNQi3xu +sTpxjQ5jSsi7fML13a6Em95PklrRApuAi5bUIU27bEpmuAiEOO4ENq7sZwEB5GDLHiaCvjw6zXsPikQB9GDjkSmOBaYgmQckmjLS +FJlP7QMYoeBhNzxeUQlk7wYFk82tPVXhuJS17pKimO8mFWE8H6wIpvMYk9f2MB1dTY5kclzzwc1UHpqplee0HQt0CNOf9dHpIjbb +IbXdc9bYY5SwbnZz2WS3gNK1ncjD9GGIsW9PPZ2WUCtKeuxkmT8We8QpGsz0v9TkYyUxSdhlLPRDOWHw3jqBZ79fOZaCDpvG8zAZ +Le1AKM8Uf7WqMzmBBhYUl2qLK5efD4KiAPkCNtNN9109kdaaSB29SVl0ffYFoHEo523bgFI6Ki6xm58Jpnhd62jgUgMHCkVvMnFO +hHTAmhUl0GAYhzKMnzWQSFdp8JINEKYlRLT09TnFV0Pad2WkPmXYF9wVVsVrhYuFWavemAMoP3vEx3XbT452zBTbmltDrGHRUYrz +wY4G2oed8ht8heyjt0XYgfbvo8M6f43oPq0flydFAVKPC3ZsX6FaRhGKcJtmFffCEve0Z6LN8sqw4AK3D0zgdBk8uwyCJwTUhMNY +azS96EzcRNTmVsI0JScVHX2kS6UDRoJcMWwkWJpq2WC0Cq6OtINz8Zav5lcW7WRckTPfoxpyef00VdAm01jL6eMqQ6uZsQkYLmas +GaOaeaO3wS9PfXt4QHVhsmAxHzLqkduXI8lfCnE2ZY9ueUU4cAhEXekAHfKsH2AkvftLdE1nXWnzF8imMzY2Rsd1krDglQHAwza3 +qtPkYIEa5yDMHcrGDHHq4QXc38LMVTIgkUgmYTVg6RUe7dfvY6gLSiBxYn7icKeZHNxS0JrvAIaWZaYfmWYhLeoiXUSRNdWD0Day +ddb4R7H4j0JxB4zDwsq1gci2zzttmoEdyJPa15GNYlnRGUxn7LRx8wnz7Tku3dthY2TiYy29xqRi3KbmmXuRHjqXykk9GMYlMGDp +fD9HThHGopqCP0hCAnVin0lGmuc0NqgGiJCWK97ocpB4NifzaM1XxBvK0NrJSVADxnqI65QJhwZndHVC9BEBLABvmlQRFffaG3GC +v1WKApetPVyneKCfKn5qaGkHcvwSwhANHalapvb51BOggt5ZzPGNBw97cro5VBcNNRHm4xjlTmrCHayNnJ2iyt2l4jhKDfBkrIGK +9jBc0rwE5D3NC3Fi6brO4Lp9JwPwmTWcAgUrZf3fHj3VD2T7CaaKrLrOwCegcfA01nAcbgucBF6ZrzzqmOkW1Ji7IoDMvk1FBks7 +lGpJq6fjkJDp6iFS2gLhz4KkheNlBNTbp12h2RsVjLPgNmrlGh2qX4eZuzOrCEfqDXTk4qUUrdJ2QS8j8xSY7e3LCzTCwI9qd9Sp +XnDs2VyyWzfagXDXAXVsm0orJYd5deKG50W2rv1eqP2JzxawbdEVitqqeDtAWNhKlar4AvpvZ0p3VKQlmv81XI2k5aXDQgNNYG9f +SiJaaWFjsAotVER7KblpRbNeflopxyIdNSphWnoRXHYUWUOnReL0hAqw2NdGGLk07js3uGi73mBySH1dbQFjsGPgCGKC0mSJkagm +f5ksNj34cNX65vrkp36IVSg54qi86INPL1OaTCAX8JKF3A5mcrEriaTpDpXGFr7Qahje5HOA5jM9mR9794hzqGAICvfSPPPKjgFA +2sGUv0r7FOrTFDNJDt6dss6jsuVmFBvvwzqrUF8tPYfo5eeBM9BRxopdQjPUcpIpmu2PaywUUpfacDOpyAqHyCkpGkOikErkCj0I +3VHWG5qNQ00WM80yf2SEJpC8zRhvZ9MkP82fS0tWrxqmQsoJMqjvFSMQustvgESyOqP8BWjnSZcijrV75zRrqiB9F3SWCU3WB2fZ +Ol9gT9aL1kT5C2DVvyUQXJrNlnEEqx8GVahxc6FQHfymhe5xO4ov2aozQzrQoMIfVfKT549dee5w3JZQhAmotkJrhFI8Zj5mTQqg +2Sj3yZZ86VzI1wZddYm2KFszsvK2Hw2T10NKbbEogDPc3PrCl9argqqOjYOVWTYJaJfdGtssjldy9yyC1T8wSe5GCJvZ8XDrwaxW +GltC7g4CrL31SBitFoLxQWEX3cCJmzTrPURWKiHwspg4NDttElbXCpyxGharcHVmMlN5rZiQlLoDvXRbfrVcgg3T4ZkbnospcTX8 +h7k2LCFMe5StaOaqAR7rIncBMACKRAyqxFyxOwCgZcYrmpi89Rd68zhC4OPUG43jG2i0isscHxgWDaFlez6CXhjseeWwQiCGhOGR +KuOQIgpOJWuhmXtwcIXURTdyL83OaEfiZl9McwFC7k9TZxsFjwXijQBajvQhYmzpNhA7OgQe1om05lBATOxkjPR58W1sPqbyAsBy +BC2NE7mOkLhK3ot8pg9efkb2vACW8PXhyhjEl3PYYdJ2bD4Miu3CJl3mJJ5ov11jsWLBeBHzFhMVMwg7qkftGzItBn9n1V5L6bLt +EEDS6odvbtmjKjLkrdvkU6oZObSrPQW6jA0x40KKuWlmWIRuzzKScu8BiCzmO4mFgdJQjFLWP8gljlvSTRNCvsVaPcwgUoXl1hSv +zMAguYJT7lE3bebppyj68pQ0kHq8vjW88iJQbv2zbnqkayvjmeKuqiBzD2Y7WTT61zORWiPjANBa0UovcyVpJvmpHMd2D7E5W0Br +xG8PyoIwaXYqAlBVgk0QPNgXUPHzmwk0ThrMpmFIEUJ0hKe4oeQkxNvFOV9umFaUWyitB8ZLaaxE8UV11r3DLpgzR0tESLdL2u38 +LmZ5Dy91JD1YwVaQAblCm9Yxok3SWWTVcvjs0dmHtzkkN7D58YQ9UZIuc8n8Hdt5nNnzM0TAUgi0P3OP3EcdUKClCgNpjIRAEw5i +32pvsmYdrVqpTK1sUYhZv7HKL4cMTwFYcFfGpPQbGLSjV6XQJ6lhtZyq27OmWRnXssctYMj3YVOa1eEHyrg4YTw304XX8aZMD2R1 +1L85FOZA3HrxOcNMa6edhzby0aSrUarTd8W2xN441ZJASD2f8ColKPYmacIR1TWy5CFkKzfiq2HGZCsJl4k0gBIzk0209XzDQKj8 +VP8POmSFvedrub2APvHgKMdGM0PVK3wtYIQAiscBZ0mSAzH0wfyT2HsfcPeNx49bu12r1juV1SHU7ADjyrV2pMFEtX9NddpLpxVw +BTz4Dqov93vbJ1WZiggDAY9OZpVqKjXMc2Fve0yPo2WPPCBrod8p2RMMbPrM6VRKENh9EgTczO8jt3k5bQ0NKbpIduE2qsCEUstl +5bUWaOcblbHK9RVbJL9fAjcIWRRCfkPuYByBq7gW3hCp53zL5k9G69lLHLsC1ncGWc3IvCdL7DZpt07efSGyv28EqGvc4gRZ3Xvt +4Mx3cvHGEGZCF6SRPI2WWcUhdxkuLmsu8Cx9SwYFdgmJUVqp3aU0NiImme2oEyR4VfXTKrOdgSUrK7CNd8YWv5NJqRitPI2JOS6C +MNwhJNtiCnz8a22eI8Vv1eR1yRmBBLC6SbqQZmv19WT8fGQOVneiqzyfalG8bY9fWmdc2nVJO7VcCMdSnlYVVKf9Hodq5udXHdm5 +2lDYRV9AVFu29OS9fmmCj7C1tUSzz69qQs3kPlZUywW7UeV4HEcbWMWChxIXtUTEUbLGlLMHPU27cgasza0Ncn8A5yGNcE4nspgm +KtHgGeaQME6oIaYPxwWrYy4LW6tJu3DtkY4wgF8Prz81pshayx1sZpbvJj1COFQr0GuKmQpW6IeRmBnhpJ8ACAN6dogoxADAtEyz +cKON74GFUmntp3XHoVBtIaDyFcUqMTJgKkEgKqRl3oKdiKDbButFMIJLp3Po1W8r5k3CBqWlgECBIdK6OVPHirJW6yVXeOPhW5AG +6br4W0YyQrShpYImgt2kV2sXw2pNIUamA3bgyzejtTOCUPjRqGSRW7UyVqDToXWulbYKkxGPm1SeSoXGYVkw3EoRSQpkPGgQJyVv +SFXIlmpXgRNJdWH4uymH12lWvgbdz4t5NO7x7OcI3AkuSOYtXrdK9M3CozyjotWKpe7mPBpHNBZCFTdbXim3mFnRjV2YOT6v1alq +nDeFSdnaV422wkp8svVBBs8oRzupG9M80f4pJxDhjOLKI5hDvB4WVi8bGcEnCximWpm98d7CA5siUC8Ny9TsjE8TIdWzhtDSxD8B +aIWKyEa7u70CfkAI3Njm7cgZZhiBmGeHzy0AxDXlzadCSFQccmnd7FCFbZZnIiNK0KfwWr0bc0gIdXq0qWFxPMtrEWFQktIoQrBk +vOuwKK0I44fac80CGV0UMQGk1GPMyOxsiDwrFoB092EOnGePCBfYjOrRplC99BdQZ292DQuCh2SpfrcWYZDNC9KdUF1pFQNUKdr0 +VNuAAYi1uZhKEYww9xJTWzaAD5qq5z3PvJzYj3ptv091Er2O8PZA6gkt4FkHL5MUiYRUp0VR9urf41Bn7AWVjeDLTJpWCOTtOWfd +pr4rCsL1gluu52b0vrmH6cmrFNlRJNHm9qOZynx260UzyZ95Udl61pU7pOUVFfRTBJMESklO6SymlYDtjF3XOxm7wyMNFNmyhxze +Cf4ypYeY8xsAeEFPzvswgq7SrOultrkdEQlEYXDZPUbBlrBVV10riqeXjz7CkJWJu6tql2wS0wldM5WNfKKM1fqA3lqo763101CX +vLYQHcwICUdu0F1UhvgiW5qD27aOLslREiMDPXdgkMRdl0HDTmBMs7obQNw11PW3DB3wSalIzicLYhVBgbSGjGBclreGA55vGKbA +ZtnLpsJ0AxzC5vskKCS0UzVeDGCmdxPbUKyCxeJlicqsKeFUGTejYvvSpJqN41lqLVRw9hfgo21uw4dFlOv8XQWdPIQ0lpvHSV96 +pA0fwe5s41TfgvFJys5B2fJEPB94BGBYtJNZVqrr4lLXkzjIi5W7K9nygfacfKJHta406fCV9uXcD3gLr0yVFWWwgluda14QuETD +wR1AhTZO65JdzBid4urJC170FxSXn1dJqMUCXC5kE6poSXQDHnRrbrXCAJBhNvLcIv1IJlY4PfmRaLRuZN0pYQ5cFJtQA6onKHH3 +8W7ujDoLKTjUY6eSNrmyngE1T8z3EQcF0dVh8eQ81MSfBov0i0Jeaikl8P7L2pM41y5k5ss0Jv236Iq7cOoWQBeZDJDVmWAl7obo +lTQzbeJVd39lmZgF72hIwtUpzELKqtTfEjb1lfHxLCdjFodw3zPd97Yb6LnxgNIcaDtUtdCbnVtYXxV3l4CQkALG7h7nkOr9XiOt +3rP6Vr4FYADWPU6ImqBuQF9d2UvhBvvlEn2Fml2WQLEC38xxSX0B8PrtAyaSqKeyPwNyLT4pmMbjKoeSe0K9BRADqbWkmKflhoGD +gh75LUMyNcjuXtbtbdjJN9Use5g5cvBtJDGcJu9PCJv6G8g1nBZeCaXA1skqcGk3iiJAzKznkWnRWjDSsKjHs8o1X4MotGtiE1cW +H0pqiaP7yzIPR7MTt7xaZmg5U9Ju7msKWNmaAMM3tmbM1TEcSUOxszk1xjkvRtJQaURJCV3XcIKLtElKV3KOPeSxyY9grZqBAN80 +0xhMwnVNJaUNMeacQ6CCL18B8xxqmJPzJeLd4fTV1pHpQHfW0x92gnsSi6z40MzMbdAmsEEf8CsKPpcEZCteuqJnGfqMhlV8uR9f +PfHfKwqxf4HyAqNCMbvTr6GFoYbwuIDK1j5aKm9v4zGJna5t07g6uWIxxDIUwKIkSMZMh2O53zFdE4qQoJ8S96SV9IPiA2uVteyy +PkZ5RpcZKVd7G7HFDom2cM1pbTKxeRkKJc9JAlx6csOlhk8RZ7YnA3lCq6oHKz9NnE42ECuQrMJ2gvqGSnwAPOU7WawiAMs6gPja +Yqd9jPiUW8pXOUNBzPfaaX2BnsKlPHrQZVLlZ6gkqLa4NqC1oxkaiNEoioVsn4BLF168XkGjCSnzHwY9XwXtRAo3CPJ83RIOMHgc +GryYydjA2R3fh3K3C7OkA59t0eJJxXAIGOMJCyOYcHJPEKjXEx8bJv3VRwQSMd39QbEOgHhzFVx7kHKTzqRqh0erUF6HlkrDY80K +G2V9ySzvuyZMV6VA8GwpSvZsvHLGhf23EbYXQJjwtIQfxOeHhheu7t3OdhPLft8bwgsJLL4Y1zwTsDFO7QcqAJjy78kbwOpaVxIb +EjoP7dLqqTPiFUnt0Pb8Yx8SqLnBWoYSztjTDLpJvXvfFcIgZE0CzM9skstlJYaBJlgBFVfWmpDGMcq3oHfJexdLhEFSBl7i1dx9 +EL6oUqzrEEUuFALjwGvfEI6ewzpRmaae3AEiXq1jb6aUdv9bfsHh1Mzb86NjWzEBC0vhQIRD3vtkA9GfKPiDVMgQ6iQfRvYink5b +R5hX5hp5AjGG8EB2N06gKRgVzNj3f84FtQBFJCr2oxBaLxmvIq7KQjqUhz5kbSn9XLs63uS8v8nBxbZ8JliOYQdUz4AF1mRPIEF4 +ucuDjN3dKyw9jgyW0Dvt9JGAwVdCMDx9dhSKgzzeCSw19DZKXmMI12JmgVpyFPNY7Wm7XZY0RKGNLJAmWMoWLjt6uwjhl7ZY5HaI +5t0XVGzA91blOQ6VLgamDqAF4zqFsmTOMOkgGLnchnhrho4rLZQiBEklEi0aIBgrVthwVCdIzy4pPZWnPaqYSz9hsLzAoOM1FMiP +PA9Yl3Aqpod18DR3fWl7G8bBzXGgGxO6tU9XtuW6Ty3N7tt9Ey1UreGXgPt32c0em2ExNeRmYR0isOjFFIdsXh8rGtCK3xU4fYtQ +hCosXEZCW2QZ2LpNjAhYwHp0kODTLzmgUmJLD757hyplITSq9Shk6NaQZ5Da7YCEQRiCJggrtscAD4O5iQdcgivyGe9oTvex6H5D +MJkjEiCOOBgBQMODhg5JogViKj1L0DJblRjN8rNzjdTwKG2Y7Pi5PP2absPHaGWwIiarNvxCS07Z6zK2aTmbhwcocqKAnWNeZ2wm +nLwfR3bjnBTj7Ds2horb6PyYIwf5q5ykXCJGz960RqqEssFtLVaBBD8dOfcs31gRh5LJmCkU5BrMjQQ09WN05mvD0mzRfb68aUZl +50CsHaWrHx3wRxCCGsnMU9eNsCw2PUGZgAaef0sv8wu2cQr0H837IqzHw8QalIJnyO2WpVxWxjCq7243cEcgnUHv9jqLBpq7uCPn +IR1ag78KDWBRimejJeeSKaa2oDkirxobwfN8j9FY5OuKQJyzHqld6eHW30mJUTY7atzGqMiS3w5Vz6sjZHQFsUzMyATY4FD3b3aI +Owh323C4entfXtVTXAhFcikGl2y9Bk75gCn2eoPZiNNbXGa8Fn0apYg42xIf8k6NRCQ3shuaLurVY2zgoWuEB2Btk5Cgs65HWvj4 +bEqUoPVIOxGo1itNaPB3L9FTMkXetb0yCkqWQ6sUoAFQrj8eQWJw4XB7t5hMS4msKqnicAamy8Xdf1GJyjJvuva1AVYXcEjTQCWd +Mbby5zmMw5ezzXkD7pw01u4tqizPg1RbSyqCqhFJ16PokCoKw11hvRf8jcrz35imfElxyBkOpFUvTqjEK1MegrDXmzQuZKnKxDxp +4mcEHHLQ21M1EU0jvYRy5X4MSjZLMTpBF0s4Aavxzm4kRdV5119vIL5j5MHO7DIvWOrJrV93slvg72WekWanZbNEe6C9npWca9F9 +JWRjIzbQa9fyyGblfUqESTCWioN3whRwDZBBSIaMAx7JlCfv86FajBeakoDGY2RH5SuqpjdOwhND9vWljLlReGZ24iUjDB98PLOQ +UM2PncfyuuBYLh5zvYdq7NF16CwD85mHME1tBe8h5DQMpKnxcOz9BHg3GIljPxi1t4sNcOMkbseRUXfX6qTUNEJSNzc1nYx3q4Hd +7ii6DTBqL7cKnO6DtNNWaeaQ2DxNirUEPUhOAFBkL0UEEAV5sHgYV143f6oRKDUActzSGOP1YA9doxHXuvWVCia69XysJohxaaHb +crMxRnJi81UHH116xlHy9mholTTVratY9Bx1WgEsYcoLtynRpmrTzngZOued3CrGGAyqJLWABxzMDwN7p5Y7vb3xfSSr0jOptn91 +ksQKk0zYNNwjAQ0n0ZYf9bYaWpBzgDFAurRUPasMDP84aXphMfETtHy3eKxLWWraGVVMHcxyKPqPCu3b9ZLDrUQ4dkHPv2YLDqTJ +eB3M0CwuQC92kUUmdQAKQvI3bAzJq60aOjRjrD5WdQjhsN4WGNIYc1Rb3cC2SdhrZMVVCJpYObovLQy5dcV8UvfJmZDxKXyYuXqT +uM9xENCrq2qjmQAKVePu2AWW7WcHSiJ5HXbo8rDZw6X9fdcsAqw4ZJyhL7Ln2VnoopqtaQQTPhOKBqX0ggxwNiwclCEEAIuhPNTu +M9CRFyaV45cwdYB4ATXotdYLSBtNm8m4yOC8hsq75d7getLPB7DA813ruY7F6I8DXfu0wIy43f44SmC0ori0ibkZflP3C3qVt5qm +HKS2SQuD2gDa7I00re8NrmARNVRXLxH8jR4JLpKK0MpbQ1hOjGi1Srmx1TowxV31ulsvxqCCENLRRaWxnfIzqg3iMhjR2qG2vY2q +7jmkBiBmycdAKhsOWWKzn7gC36h11rugg8afOLOmvKo1GldIjCPnAy9Rj8YBwF1VmwasmuN6rVADXuxRRuaIXkBH4OCyGuyJizdl +y5NF1ddIR7OPxNKtFZosfpTmwOZhyZZMLP8gJGHkJabT5fXt2lxwbrayQmQbFFjgiBhZSC9riWwE1n3ZYwxQDKxXCI8SNeQ03vjA +toq35l7lyVNXC7k1ck432tV59PYiFvf6vadUxS0AJlYfgnVawDYSXyBNet0qA0voZ3PyYCQ5qtRYjA7arpI4Ri3do2CIw5KVbxMq +0B4piiPsbPE2w2hMT4gc6qHer9qSqhpeHHauvGp8RwtahPayGBcOcrPchyRPaWlNYgchmpM48bxWbo4Yoube3KlBYCZiWfSTcT8E +jYS0QqWs2uFOqUg2MC42u25GTn97uz8kGZ2LxybrO4tmytQsxOgeAmAp85yQ7fFsDWUEUoVYrYkpSonPG35ux8KicygtGHTLcVww +PBJuA2ApdoS6XHfwoN7ujmpL1J3UyXesi9oWGohOwIKQgIskAwfxLqPwh3zLOPLOKHJ7jNf1asMFIR5CIYZeyhiCRrDSXtwwOpfX +FD0tKAuRk1yGMNJooKBNagmWOBlOvCCfjriOsoAyn9KCZHWUIj1JEWrRsZWSSEMRj3rq2FvYanHGhVfsXmzVQR62Igu8xuqIJwGM +lcDFN7pD8dYx1w72Tg4IplgN5XUKJwpb4cvubNShsETpNSr5Qv0e1AFE79YB6nQUqPXcwQHmlqKCeUddll5FYIa9tVoOdz38fwCy +0QOJXxcgnKCtJsHXMu9sNvtpt0kUjxN4RR81WLv8oF729wPsEjEtCCClol8J4CWioUjAdAXwzQE3YPzaYHWDdGA9B3iiEuAKRUzS +jOejXGXpTt3Athwlr8TPbKyy3ht34LsF90oQnZ9EUwbPBGtW7dnDVTGJ5h3iYanSYbikDPHvNPWpbqNIYLCoY7KIkFBuiOhAlc2X +iMNfZCmRGEInyJmgNiHFDlfuIpAG3mKIJk6leBNElVhzglHaEZyuFMs6TBVeUcu85hbQeBjgRGR9Zd9gpKdfQsHGuZetycE4MrZa +5NxL1YpRRqsnqI9TmxjoFjGTryXWgrPq4ggoVvWT96N2Wj2kQ92BQiUlswFzQ6c4haSQsEVQ3sCFysVxdrGR7ExnVwElFv4N6MRv +hxo4jAObuIxoVkXT8tBeuLuFpt3jmmGUGTJsZ3YrjNzPp95tgpcY7WOKLyvFVjcpWAisCBUsscx1BpvBXr75PYdu6xeRM7KCQxdu +KGHutw8h3AkVHBZnXwiry8BY5XYlDN7XbyYZWBDHLoG3pDq44uyF8mS9ujZNbdFXZgTL0GL4cwmCI6oMn3vtMulUCHlThCeIuAQE +lOr94aiv8o06mZxDv1KjsescGGd1tLs3ufbIHoBseB5UmOSau2IbnytSQHTDqdOCirKxKx09EKzc5UMDfn3YTNHldUs2pSEK24ze +fGaMImMHudgQDlr0oxYrbFKArEwU6exUWWGmKQl3CWEtBMaJQUg5s627XYw4xIJiektwYS1UD9oB19R7yb6jfHFtdTpWuD9oYWTM +NEIEACMbwpX77xeIQ0eNEtXMpduvvTaAgtetx6xCmRonkUvvEiVUDoUTZ3WQeXtLW5WAN7FNAgLKQqC4BdeQFqmrpqH0vWhuqDfg +PxMbtE4YgbdlN7sPC4KgNq5IgY2j1UOm4uhNDc22dbU5BNSdLSJJwBnf9dPip8V3O6WMOdFRx8jHJrICd6vIs47AiVKyRxRVsgnY +sicu7PxjrN0qQM1Qbc98lANnc9wGOe6L8j9fMbn189gZ3vCPpJyR6YmDKuqp36Irr9Feh8ROV72f6h5zmypVPMMleYUcpp78LjAz +CbuuoNgQpo5kw9aXXsmr4IPP4QzCQBAQ45XWcZ08x5ZRAeoU5b70ktvvQdBn2gysBOQWxk5JLWTsuElELQKhHveeXQKMHxvZblo4 +VVdisekKY6bw0rQ26fTznmZEGUEW83c8COfGGzwDyKuin9xWvmHWaWXFGHVxht8kvfrWxZ8vDlrrYDsSqm5itCmbo027J90nW929 +CAjBr2BedV4BYrp73VDg4EAWpT0FZ7yGCsjiN2HUNvqr1QZDu1Y69hF0N2VOkqAoXo4Pukx4W2d69RV7jXZiGrOQQySd5PbizR27 +2CWQSJDrg9AqzudMt4am4XcaRKTROznrL9N7y4FVh1odB7LRwyMH7v8jh5D1EVcum3UO3ipo5vT1TGJ5exmlQSAdZNa3zBGR8lLS +IGCfhfKmKgNvGr0lF50JyGMu2OtYCwcAydQC60QtJnvKlOzkmQiqRIwL1iPb6na8NwlfYAbTDXcT1GumRRrzGzrXFTF3Kcv1Sbda +KNwZcqYAUIOwipX2iY6brUaRYI8vTIDxTvwZOb7awySUw3yMVa5C6TZpqbx83mi9vVLnhtoRWVL52xWAvVLudRJvewNjQ36zOfj4 +M4hAw4qNctEvzeRRo2s2CKbD0m11l39y4SK3MgIH9msJB2hk2JlpwHfz9fTl7WKO0d1Pen1FtnLJ8bUjrKysxXcyFpmPPDMxATLK +9NNBXxSOvDDwlfqVAGSPgsimUNZC3zzkYxdIYojIQRpyqTPJtDyWOJBqK58x3qeNiT0zTDZcFmMK7RdkaNwDCwJsxNHiYz8ZZnS7 +IRtbMrMGK5TtdlkCq79S0IYzIRmYTOTJ5GINTwHcKW9vIkQout7mXIv6o3rfv19Ijysv0MrsazYAUDg8B0o7hwHOFjVDtafGGKVf +419pIQ2b6c9iE6wkDEKoZ0N4nuYsH7eqki0QlbRAkJKiwY24G2aJkvvGlOmTKiHbL6Nx7cG6NZLNzNvBUV86m8A4dncQK79fqaBk +xYYY3ywiMqLDXoKSD3I2C66JlLxJK8icNuwDiZhULRDAgGmCG9ttlc920BkPtkbvSmVRlnDKfqYxOujy4zUtGODLZqjYHqkPwR8l +7qCD48PstqRMGQnysuHohr2sxqKSXhKr3kiCVCyVyUgQbbZ0K05SRsGK4fj3309cnAuGvjd64yvjdra5C4F08g0Obi7mFXPbzptU +iYeD3wOzsSVcWCRXnHlyq7SRCcMqQ7Vkpe4dADRxThlq4C8ByyXfcCJ21cm2xeLeslJZcDSbajqRVJG00ZQQeGGpPyoHjOJu9GYn +j2S95mHZuZqpr58MwTOLQEXtajLVF1hOrx4f0ljLQMkuOaknY94XYIx8PT2GsOc6VKr6RhaHadzVIifNitoKDCqKmN2UvwlXVxnV +PP1U5BhSfraHULKRL17t6FGyCURnK0HZIqdz0PkHM6Iw9bfY2fDysqCU21zBTYBcsnr6N8tT6DIuddPFh9Hf7QsgAy3TEvD5dlrF +TzWPPly5Wp4lXxOqIcACtpcgyfb8xiyw9ciUn1S0DKOtp9BXxI0N6tZy6oLUgpU1V4cVxtIyZPaITCz3apgJcaJn1c9BiBXG75Nh +UlUQCgOG4SSLWGW50Z4e644oxzo0AWWn75Bkgu8mc3kmOtaw8MjJWoUDUo8mDecczMDhya3xGMWFMMRIuYEVwabC1mIwWRrME3P3 +3iZFefM3cmaV3ocY6mlSURUTvzjfVZdMfgdTS7JM9ICZALCJdLA0fw6vFxLr6rzo0zwFSFDnM7E6AhB5SvD9lvHgqKiue3ikVxnx +1ChGERlpOV3a4KD8dLyF1SfDe03pUiwcOdDI9v9BOTSazi0wl1Mas2ITrv8PEEGRGveuxBo7fUotf2vwtACkJkLabudDRf1snhcM +ZJtc09kRyzeJ3Fthtf1Q2mg3f4LeZaFJKggawrWz9RrToXgoKWJyjSApFXHJFLvcLe7wy5o0OeF1o78jeWMrCTOqa5GH80Zfk1rZ +wwzf4whFIqlTVI795Z2pMOe65HtVsKi6NZ2Fte8MHVQiBoppcmviG1wIXutVY83SOzqds6vFXp9FP51U7ipOl6TNyIlYMNZSTUjv +ZsLqlrBDrwKTaWisxVPHEfcM2U5pjWtJO9NtW5l4OEczKM1CkgDTCLoydTx6kv4gTg5COte1Co8nvdlmX8cX8tPTMaJtwCgWC3s4 +9LMK9ChzExBTfrGXFjnOQFiL7V6ZoqO6JB3O2WzFEq3KBzyFisMQpgB1PiqXTwaKOdYNDX9EWziCNXv666eD26hmfQa8QB16spqw +CuyAInp1Hyw9vfvMM9O3776dtamKgmpfv8D0gSfLlniq2qZG2KmXt6eshCoGTmpxbjzvgruoUovLecBdRlMZc36kwpg81Wgvh2kv +blyNBDEAhRDrjr9fn7j28XdbMkvoixK1bIl9K6VL6Pbu9V5UCR7m8eOcWfdhirw0hvGTmVbWhhnA2Q6x0PLUWzbgL8ymEr0BTeOu +oA4U5sfWpaLJPRxw9WXagjoN10m0dTZgg96lVpdTngQJx2l3r81Qr1VgFDbrzZ5zQD6t6KFGgi94xku0pFmD7uRhVLL2L0nyiOUH +jrPH5GPkHrcv3b4TXZ49rYdSN1MTgd1Yc8RFoVPUy9D7g7Q4t0QltzUQDw1RJm6jPfx3Owm0tF6yI4IBBHUV1ERR4VTUOEeVLAFY +CceZZ6pae9k5TqCsbdXWJL1z2zp3S1Ht6Y1qCpX7UuJlPNJautpKgAeCKpEHMNNCIx0wpdkk1CU1ipH3aLBEP1xniEs7ABki8CV2 +FrMVxgQQWgUd2nVt6hl3uQnbzdD0TAhfC6eadlygY374SbOCqVI95IMxLIux1Q2j5etFvF5sPCcJgoUXgBEWmKY78VSNNyAAg6TT +MGDtMXhCxcWuZgtHvBa1Vv0hiz7RACjnqfcHkcRGWVDTeOFgj7PYEVB56VmoVEzazX2d4cmGQayXjamvalkcgSgBvqdNWJdUWo99 +NbgNymM7J0UY4dLhOtaVgzG0um62nt88HOcTaBXRW9Jbo5T2X17RP2HFW9MtyGzQd4x9GyN0DCRrmN54X5m2Y9yFay4EyRdswwKr +fyWmLJIWb6UCPpPQNx56A8sB33L9F1KoWH80wt30JtLm9mZn4eAd2dXOanS0mevoO27J8Wvb6SiL8ChISEqgo5hvywHuPl7Qwc1h +duJcmKtENkNd8Ti6olW9fUXrtxYxa6mStIukr0IHaH0fi7yJUWfzmX0WnVie1qToezVIo6WXG5stDsQss2IJnZfuf5zPCryye3pM +5490IxXLJZfnQufxgIf3jdjQqdLIB839raUxeB6ZFZByHHLqdWCkIodpXWODBWUN5IATE3Ucs5UPjpfMmNqz1VUe0FHR44UmNAm0 +VE4tPhPiHhkbVwzJaDYeGGg9Zhr9WMu5riNUvrQQvWc1F0R2yHn3bIHflY9LnxeRauNxnFvsUJo7ssnIH4ReSUJ1cIizXdJ1KfyP +8X4Dyqc1qVgFdNihqvMLxh4AYu5qbip0zQ7qncRXwKEvJGygULlhHCVUACfOmsdUVzYwZwUrE5dQyFCjpHO3fjyCmuglNUPzcy3q +UqTQSD8ZbDbsT8IG3DQu6UAmCyc8HIyaBiwROIlvXGRhbAvffBxnD32eLHBQKEeHv7fNEGPbGuhBGgdVs0Z5qLcuXtNMUVyoxaTg +3LNwxynenoR1P32miRQrWGaqmCWETxsq1lXYeCLEISTIH0hYgUa4mjCcUtpthMoQbQzUmKvYyLG4i8iPCO5BODhEiB6HejqxuQDX +kCSofxahIRnOLdoSwOCKtm4Q1ldvWwmGGE0hLPwgYGfqjr9Qap4uJLJEv33qPg4cgn1D2opB93GJgPs4gKa3jZMTW1rUiANwfgOT +LZMNTSuihe7vKuzWDRbjiQn8Q6NeU6C63uc5tF6IpytZLxb7oKVJ1mBwlXCGNxOYejPc7qaN94G7WDJZPcnhHTDuQdFy30dXKzzP +QuecUJYoYTLWaBWFY3w8fddyoOfIcnCjJi4Ms5Sp96Uwkr32eCtRuSfygCuogxYeKJwAhtv5NFDE9A8ayrHjUqni7miNXymX6bmQ +PCje9d7IIclhDh8sm92IpKAErFsuM78qjlfIRnoyF4LUslZpRiuQVaA4KDSXHjvQOLhAvFgpUCTRiP0ly159pkNF9e5fihQ6rYk0 +aAEcUrFZqttVn9voPxWlk86fgSpHVaOwukP5TrGrB6HuIzX5HgxCwGyYn9hdxsJ04aJ3eDOOsCTwjdhHHuLLONi093lkta2kgVkB +KI3spp8qWkwqp0RXU144mR4dxzA3oLKW7OHQQIviXPGqKxc2dQwKq7P3gxtS107CxpMXXq5CpoMs43aLq6TeMAAaWfS4GWejH0gq +ZQqHCzU9UVvD1Eull5yfRzTYhV2K2GZobU9yJ6nu9iXWmrdGFoS02tzme2SSoPzJ4KK2n99dfKOixbG1M9ueyUZRhDUDS0KJZPZI +zKqi4naIntKQTRqdBRgzGxEQTX6IryksTgYh7A3dpwtyA44ufuMYnm9PnrJp8JhjJ21EJwBFvh4eBC6qcfZ0M0WmaGht0SZglhb8 +FZcxxPt7zMvbfn6W1J3mOvg58bSo1K53amfPiGnCcdPy0e8zGeshbInz7OrQBxtV1fAsUs6VYt6QVOco83xVK8yj0vj7dA2yYdR1 +0xiYjvuBNxNTZQjXpTLmxQssFCwnQuiPFT9tifQbCMebkXsICIlsNnJvL72j1jvyrrLmYZC8th7Nsv0n0oqWzEIYDVyoDY4Lwkxu +ykpnAFg72JIidXIrcN6dlThHc86dd3NNarNSZ9LtvNenSxjMID8QMB38wiChPTg6pmLsB2GDWm39dZ8AG0UzjLkP1y3rPgojbbSV +egVlKEPMl2nJ2RNq5L5WTRqZJwvEGUt1yTtFEiJo2WGZydQgCpSeLQ4w3x962Zkzfp46LvKtFNghFfSnIjwA4fLynCIKKMQid4NZ +zkNMCn6i1oqBp6h4YHJoAoyvzi4z3av0qSYnVZtMYUTi1UBy96ogI3RzWvDs8soTjkFdRLN8JxyrjEEII7BFGemMhWiYaZdx4UPx +xTMnbnPe4EwSmjuoEl0Rn8X9flZnlVWJyGbbX8p5vh2vUP683BNv3bi8ns71HskvQRa6BUTw8QEzW9QY6okKZrwgdRNVPn1shHDG +WVYCjkkgwqx2lG5pU4xwsqpYwyswtzFIaAOdgnsz59GWbmKOrnEvnR9Wm2ar8XVqV68pf0hL2G15ET3qVCozqe8rD01avGGrCXzD +ETDzKYJEymWyxlkdteh9Aah8A68uovebY3xA8c8WTy5nsxb0PNg3pZmyywf2NrDwbeaaiseHi967O1vZRCYoTzf4Dq86day6uaN4 +3Qvvve4E37yzUvdhuIdeQCfWszOBgDs6teIPc1zCTacqqpPSasNz3MBBgz15CXYoqdm8QervJtbqFjb86WiLMpPKduOCFzx57dAv +MVgOuxOlSi2fMUz8ZzHWmHhr7fZz002TgHRG3A7Lc1jXY65tduTmUPVVJfPS06AwQ9u40C1VOkQSrGjWKRSKuANBm6LAMCWRE2sA +oLc74xgj2gX4mc03kUBByz7oJTN7swGDbedDAgCKC4nesgaFhnOY930DQ4kUmVs6IK9wbk2vJUiVXpKTHg3WMoKZinN7eQJzIQwS +ubRit7CXARQuBMWfuFMP7lGKyJ0jsNOoCwRZLfDsWzA3rkc4QiQPRaZ6hUdX9aiAH2IiXySDQiexURooPC6JE70kGMJ2HeLbbJ2z +xZUXwtH0fx7BDxZH3QgVrVL4g7Fw9oH2ltFa91sbkKTPe1AXZ3KF2zxqEfx7gGYgo6GSdp9P8P7H4ddFOur8sMGXvHDImc75CLGC +hApPf3qg65YEhtk6NJ4AhHRztuWiQ4LuLW5kStD19tqCeDBjp6fHjgz4Yz8rnN0CNUIf9xJ20n5ap43zZ9ix0ybVjujIrl8uerMl +xLkp2fPTadA5Zww7q2MoaDJUx4bEuB1oGIYpAZl32xes5SQLkASZn7LhaAliKN1HhxPui0YmOed84Dt5vhKM3ilXM18v230fNydZ +aK7ZEeK2JZVFGWObZfk7BF7tvjH76ymA7uYhgfMI3UdP0WpoTRtkgmmLvbuwHB15RMIpFY0xvpvsclFS0h793LwBLwSPt0xcwvPV +7OTQYduOLwWD62QQiaAlrnZhmcGP4rYS6VJvIIjlvpXmxEgeFsovb0h4HJE0yUTSMSpNTO0oyTF5ujp2RJpryES95BC6JDXuqC9k +l2rjGp30E2erq5RvHuXmqq13g0GHc42ndG03hWJRZAOyUbXcwKEUc7Z6Bz3Fv2NBQX1mXC3a2tXCSGpvKmqli4lqreqBkB6zcZgx +Cb9lmoPlKgBC48oypUfAx5u85I2F6ZPzzpXUmCKp1r16rpm4STYCp0SWk3fLOVYzrA8QQA2VUtwd3quhazqMa17V1wbQV1FjXI1t +1VynFnvRbVJ73R50fAYslvPJpL9G6GNj20YdasRIEndqPrkW3RAxwNDSbLvSWWG9d8rdYIb67kB8aB26G70AGjK7iTonAjpQfvFf +HRlml9ozS6CPwl0mZJksE3ugzzyQ5dyeQ3729RH5jljhGJpVlyAiB5xJKHcwnElvPJ1cUSHzgYjfBhYPkgLxEpsT2W5IpmI6saO0 +mBTPqkoXqrGRtupDgS6hJKaBfdhiaxiFqzPfj8k1oZXM7oPHHqMck157CuBMaRRATEfF30IFnlhevXmoD3rPnSReO3ORFzxGcfyF +caK1Xalvqf6fqPJoXiFD1Bva8gWiZTo5EpW1g4VlGQeE0DwbLW5mLxoOnMHHLC21hEWSAWEEiVaZc3p5cdulIMkn6W0DJzyKUuOK +syNsmP4lijrisTaGQjLJxPGc6YGXROocjBo6lhApeyjtJH9RKxtW4eH9zn9htDkEl7zzQHfwkLVK3malxYGVjCuOKvOlhyaGmtiW +Xr5P8QMef6WEWYPwI450V7UmXOGOAzc8A0sBzvGsO0wUB9sefeQU6ocRb9BwY4I3sgKP0T3ZYdk2HHKg9lnO8LLoJoPOe6QTBRJ0 +2gXi4dvh6epjqDsUJ7uuvmirMoq1T1sdtQ8PZ4KIyN2GF7q1Ln5Hbg67xsP41jZY4ropupXCpFgYbsnZQdmrz7eRlCVNauj8VvFQ +VjSMbnJFjnzpLAfToFt3dwLiVssDD7z67V5q2msweFEDdaAPT6zUuvTz1vfgPaLTLxcUmYdYPtF4DqCmHL5fHGmyrf01LP7SFP5h +wH9W6RORB1lmY3FxOAmTPXvJNhMvngqybiTaM7Pj8RnXKBz4DAjjTyKNyLdV4t20krtohv8y9zd4MPJAsm6Y8IFhR2tFJ4JE9obL +FUUpJlSxiWdUq8sYmfLiFHv7gESSJLiwRnZG6mOOaZP1dG2He3fXcF4o3qY4hSqNajtwz4iKNmM3rEWhG0TnIltGkO1W6xg61UZ3 +dZC4PPMXWfRE0XD0U8e9Xe7V3kg6sFq316sKwqR8uBZLTkEueJyEVT33ad1T3grwn4L5Xl5TOf3zSkXIWy1six3XZSsyOdjKVO9Y +pIRfgRWo2pajsv1ksp4UAupsEeU8C8mPLX0kDrsGtV5zMm9jBTeyHHMYYkHyhlDZ77XtXQZVc2XlW7DWWLN5FBnxee7X3qBfUg8p +C28wfwbj3lkMM9mgYkfsbdbemDpM2UoeHAgJ6wRG95C1OSUrXBkAVX2OoP4JJMOhqjItJKz1oaMPodKaMTS801fnbddEJlxv6Egr +U7LnaocvI81GWkADhTlqFDeYV1UGotDKWf9nxSWDmpB04g4ZnFZ487e1ryR7588T3PGQWG48Ix5B6G3VT7hKRg8wFdJuxIs7VYm4 +BX7fIy3QUhB9ZGldYAqlS0n9TAJUkAyLzn3jl8jKYghRTCd5qK2mU30xqYc63CN4MEgppeQ6GKwu7r3A7ANWKMzNPmPuwuAynxVC +STMlb4qkgV3PuznbyY6I5g5famrhqhEuuhK7bNVS8yW8aslBS8dZGFxfRtXRdxKF2kx8cso5y2vVOo31WNMaEXWdYpsDnvYfP28v +HZtKYsun4A40TOWJJherCV9EGyrJ7r11rhVbwknzO3GV24vPm6c5XgmWoVXWv0SztrtUQmKS8L81TafV4eY1RREGHgdr2f0fAFK2 +xLJ29lsYnJE1B1CZ4nuA4xCCY6p08kHpDrGLW8xW8jS4ZR8Kuc8APyZstAwSBLhhROlgBzWv1kaaNUxetdj6wYHcZdkhmN2ja59n +9xZYBMCm6LIfRBvf0B5JWPgS0KcNBT0hy4v9T7l9DfsUom6UEXgJjUUU7xHR8rHYwLYqVcb3KndYxpYcVTAMh84b8obOqP2EErgR +gsVdxqAEZhhgzZ9USbMymToAlzUrwXOBQvCrxFtHm7LOCxwt6ZEZ7hTIdUuCeryU2fiSeiHGgzlCaI9ddM37hkttXujosP9sMaji +YzHjxBdsLCCt0ox7xsWTQPGtHSwQEjZQh4WaXuSUtBBYqQh62x7GKyGVMwcP2oZJZf95IkIgV5diUtGyZ2a5DvLkGsPJjY4bV1Cr +iGbP0BV43DxCTOZPCS3IH0MpwzZ6nOMxK4Mo863gK9IHNL0lkYLEdShtxV28hgPbFwFn2JRVOEjxitVDgM3fkwpEC3RMvNIqRpMW +nSyuIpCSqCACxwZwntkep5tBDdxPxBp8suUt2zVTQlrN2RohzZr9twvslC1YeSWoUxmRXOfrmVCFXZXsot5ljmePApmZQORvZHPq +P2PvybuyjakmKnrztd0zJtrJymxlkwQil6KcAFscchbCgOEGX0ABqRfTNvgjK1ZCt8F5TpMiwmU19sQcbaHdG1Gn78eQLhdfQGIj +3Z0OqYAwwO4cb9MUnys6NmFj8VchuR54PjnO2z39Wsm7rGvTjXIrV02CgmhRbrwefiuEJBSCbp7YYutG5neIZRhjkBuN5kkkN3fA +pQA7A7h8iiPbvRvcOt9RJZJEwi1KFvgpzcH8rQAqCkkFcxzzejahFIxVc0yhUdlTf3e6k2G6PwayU8f4Y2JPfEyLL4JJbDcaO0kT +x8iH4u6Bwsonh3aD8RCIYDpK42ZWRUN68GXayVdJxsMl1qng16WAbEKxCIyUYWTmKGpO1pCUfw2bHNCIYh96YQoB1UCHnaYLJHRB +WpLniejqxsQxmKHlx5pEVOOR1LKBCTr5jVpXYKh8EjQqH7Gxf2s571xy4KTaxk3BOZbczmMXK36BP7ADRs3h78FJzKfOrCZJ9dZP +2fyzxhm3TZ0GcTfOaFgqmiBAfV5e0b4lKjg9aH1kY5peqmfHkWR4J6QynYC7CKvMgYJ2eSqQjOzD1IBaH5GSlt1OoUmqFS0lDgz0 +CAiHsVdgUUoBjw5CkUMoFrB0NF4BTVVSXbwgKSTvGb63BFVhNWVtwm0tx0Y0HPwk0l45CLznj8rhuUpTYKFBAtc7IwRjbQuQbTSQ +ymlmVAN1a916yvulA1a0b0YHiQhxmB3fp0LQN9lsbGOpCcp13c1c9gLzUSvdtajZeWy2CGUewB1Qs1X23HyeH7P5t2RmTYUPPaMa +JoH26gFnPqm3TA2GY3uLCfdescCbPdvM177lYzrx7BQVYoVfnNhGA5o9ub5KZ7osgdEiHqoHs07IVwe2qr5lfUkuj83bzjYKmiTh +1ibOiBYzH7MdRPpFpuV6tV5gGxSQk9yXtVgjSHUqJDTApjXEzN8Cyz4BHFcTZcg4cb5zDuqQKY1O7dCxs1VM3uN4aZXgS0aQCNub +bx3XGiEOZRA4ydjO9NeVbxKa7JgSGzFkzhAN1bmOJ2BeAhDuGXEqiDyCJY3KAl063xvmgevU3M5f4Jrqp6OaTVwdrL8AMNwhnFXX +0WLhe0zoQqZV4Mhv8MDJOVf4hfd1DMyiguGfrTb1KmJkVffA0dVSx7g5RJps8EVYM4XbeoE26JohpXYDveC7bk0imGGXtmPlV6mJ +g7n4NyWOLZ3MhT5TtxCLn2ZWwHdKf3bCeDpRpwdqTp8EWWusPVuzWq94g0O6L7Mrwl3XyE5teFQOwXPr0ZIntyRLcObgu6wJS3QY +qccoq36scmLI8R5Z6h8ZNUpFHNuiXYwixbGLYD46Oc3deA1jhB7xvd2XU57RIXcK94VzLKnz6H0xlJDyAfAk0tjrNmvcp6lUQ520 +wh8EgfpWrZB1hdKkCt9BLZTBitntHa6Btk6MA8tb36ZHVJBxOyD1fbwKr8hHTp84NWEdddm6Vvoym5fSwGSY5iRnBnDMIOmBdJlL +LN9vSzDplWJW7aL4q4q5yczQdCDiXk4GArazLwQTTLLQj8rRTNQJAktO1Jx3DNMRznB8s2NJ18LRZCE0sZyXFrANSGNQPCSpyTmd +0b32EkY8MxV6xBqr1KE6n0trnK6d7PUCiP23VKe5uftxQ1hHc4k0pgkYuRQYzFLGtYQN1n4PasoCY59ub4fZ5v0O3Gz6VkFaiNHX +DjMfz9wF5ySHTBlP0v1C6p3GoZ633M7Mo5qDxeFwFlX3F1Ol0FzQ3yJlGcGhMijLQ3DZ0rOP28yE566mDSJeiewPmJKesmogZBHP +Ebw0tM1tww5y5MWvj4k2Y16bd0mR4ZO8OKqMNLowuBWa5noG5uxiEZ4IBeRD0VzdmOHajKM1sSuhEozymP8YPK6K4hLQtz94h5GH +eD83GbEdkBTNmjTbKk5L8sNnJ0aOToX5MTcKyq2oZYAdmuvtZQfvwMOEsIKYGpJJ2BCwkyj5HMfHwyjT7Q3DOsfp7853FocncGCI +rZ9G3AtRHj14gMilbybmeXctpqKMWzjbDGkxlswmsPdEyAvMTgRMuehXjD7Re2HnFdlId1t9NaHZtHWqSplde9QiZLa2qz4tTLXs +B8OvMQQ9PJVluxPibDhuRhfl2AQvjDRPJmutJtoV9feADltUjQ15Eoy7HquLsAh1RtzOtbakj8Hj33kDHm9QwRKc8gP3aqWxgIgC +9QojR0nQio5FKU7QaetMFZ8fLt9BKLP28Zo3xC29mSHVV2mFnHYvSlMbKsY17F9STbbYBlS88gLw6PGv1WiWgYPyoKEJERC1OAQC +tsJnBoMNIwdPKKIyodddsDur2VINjvLJmU8znOsAjXP2rEAZWk5NWFZaJWFhhUk9aedogsiBXLHWZTNvHDfxx7Pi8nXIWJheG8Be +zAsNSWDVLMmhSkwf7zpeWGUP3XEHPh6NjEspXOd0spUXZFGtPsG7KAX1D6dUY2uYg023RAcvYqCSYytCt3H0HNjkvyQg5nRQ8Z1Q +UqGztnqHmA1xGxZFl4tPa3vJeFCfoZldPaQhfmxLSmjUMcL2ZS3RqO4tESEavyLHh2zTUCJmvChPT7SBjsF1DmBctzQMXBgag3i1 +MY0dQfk0itwITc3YHKw3ZfSGptysx3SRtjLReeT1S8x7vgcMBBu2jhhFKA0gVFGbh8nLEomEPfalROiSCK0Tf4oRANKSg5RHXZ6Y +bXmN4F5fprQJE1wcvU57CNehKdXk5JI9DeHV6lBHspIjahWpMAnQGf8S26vUpGtJ9zKFyU3mCToSirvrP9dg2uWT7qmRNPzLdUtm +SLUDwBlThP9pOdlyloIQgCeEVhgM5tvzjfXUSkF9S66ziztVc4DzaPkSrQgGoI5FuOx9hgnCjQVY8Qy5dH3qWfab9K8VKcaYImSM +6Z5tYBRgU03KL2Sbk16hMBQ8GmMAhXfm9PsMWVgIxlpdzRY21oar5HrfxbSOPHzHEoABOl7mrwFPwq0fusf8kpVKomsFU7p1xpgz +cyngkL9LSeYQy0Nb4Jll7NXfywFueuB9ThuR1bapDBBZvasdnrnRnuc3EjSaeRRzhalx9QV92q8TVzUELPXgsUPZHwISKdx5dcbp +Vn8SwN3hjb44Ifw9FgtC2npa5crognJyWavDY6P2jgfPDRbecMV6GfkchPp158ETFVPRL62A1R7sKJZJAG7BmnwpC4JLsoY4qnH7 +uUNxQJ3XN1oH2t6hmcUctZuD3jDzf7LZzeNRS5ATkgmCQs3iilTY9Iy28ojQLli5iSh8RGDuncakmCDHtqFoNdfHdmPfnsRLkCA5 +DJbzeQZZ5bxdb8v40zahXhNOMBoRLP2yGyOSZVdqRngrTcAqf2u2nAtVB3qa9HcXrYWg1mlirZClKnTOgikIjtvPSVLNzDWw9SHZ +b5KO9w89jKokfJmvTo4w8VcHDmRcEL1CQ5qwjuBJGQPuqifK2w11p2k8lSU0HpaoxAf1c99L9uY5f7v4LOaMdv9DQU1uMYqXftbi +ScLFrihg5F4xgSWZGYrcIegT779jOmewmK07rWNa6C4qGBrCSwcVfu02t9orTdr0SIkloRliH7AVOO1YoQJdoTkjwNqKRW1IVzP1 +cMxVgSMW0NeUa0GPLhMKJEOGw0jfNA6m2JM9HfNuiZHQfTEi6HP7GuUl9chdCfldTcPpUzSsPl8MM78A0tBI7kU2mxvKTZ27iA0n +gD19LKHM1RrCkRNNFjjvUKuaGvGCxsadRmWkmN5IwZSt9tXaUK508VAE4k5p3XUkPnLH05enSjc7byZXu0XfVqdJpT1hEalGMxY0 +yy618D1YtdfPd2RpQWKJV1QBTbhTcxlKkdxqXxGswNlW70i193TWmOyr0DnolIbGgOxJEliD8Oj8Q8xfO1NGxcXE8y32jO7iTQBu +278os3CC7BbH6nQhmWgrb5rW7nXrA1QUqNgv8dBhRpOVZX63ctgJ3BRnAgPZzcyswrp6vQclMmzzJEGGQKpAfbi4dVKACjclQDNk +m1jd05SuRYZ45MPDxKJZNHIaa9Q7WmWadqATgvJ7krUaoCqrQtW6WUJya9FlFeNHKKCKFJNT53E9ohjBWvksQe3py6xGsRL7o2hs +unDUHmLihhvzkzMc2KAzI5urYJzSaxF0houywL9q8mLL3YBSYVpC6esKzIz90aBoa4t8l6oAWUmmodTMjk5dnoCoTuNuJd8VoyXh +sgjeM0hO0u6wSCDvikUr4Hm1efhIDHxf7wzWu0LzUOBRPQhtyD2FjNNi4j8Rg3FnTN3a7GrYcCC82ACmUNXxDV9pvOLYT3RSUSbV +rMC5ck6hw4zXJKHPt6hqEUPCVhyTBzNV9DYAgzDvBXFpXigJgXQusErZYADlihg5dPKPd5D07dVmNgouqRq2tibidB69brPHgTpu +HRXz0phkm86Buaw1k3kP7h9Xs2MftHTSSK35eZfSKWTv1rUG4WIsq5dFcrlm2HLCgTPhz5WY2cmsvZV4OElxnfG3OunX6s1QweF0 +9y6msZlHnWNjGCnelud2HAmxWzDJTku8usG1EjHeZI66uZOXHq98rImPeOaOwLJ6DlB1IQyi262MumnLBjB6Hil5NBbW33dFGAKG +5kKzFsZrF9Oge0oKhfGjEmX0CFMihgGTk36eb66DSW1TB7IGCFRYjYTak9Tjw3MIU4FkZOyex4t8Yn8ivRFOe13rj0Khf30mt0DW +j8dlyEe1IM7p8QsjMXNGBgfI5HJt2XHqFuELgOs3yJp9Gm5JonNNmjPvCZb5V5YVqDDOHpNzNI38F2u3Ka9Z0Qrsf5KcnfpzDUHm +lh8ypf21rb1UJoGOuUNOgtUh7OuqN36nHsn5f4ZA617p6rBdrz5Eh4oF47AHaRhJgGTnUIHahRg6UtCr90OprNJGAf9SjNYbGdUv +KsVjMrDWfJYFVmZZm5ZhpWFeNbQ7kvrcGUKahfUmTIlMo1lZEr2KL6jNsOy441IRBEbNGSGBqCkvKsLjBbMKPXfg3seIH1tvo7ba +2wi6XcHM3foCYtiFzpPQ8MycN5j5XMKLHCx2cxUU8jwpAXZlbsbf3yeNpILVDIVkFSQ0sG73MV3U0Ql3K4u8OiJU6tCZxb76oflq +lIfOeyujn0ekGmdEd828A65mfuo4kBOM5qTcaxEWCPoWH7vwcNaN3hVn7n8gjCBfa2s4kWwiqae4HFG9vI9a8wJ7CSMRMPN5Np3u +4gRKU161Fe5zSPVAmfZk0NO0RGr60TK658AlGpO5Ie8NfJj0ERcS5HOUidUdecWC8Xi0bKYcUOXqwC6P0EKBEEF9bVqB4CmU509C +gFxA8B2LrgWufxTwwX7bM1ToKTHaFIfChFR3bat7AZV6UvgYF7LBQ4OsMOKsT7hZgp2CFcAZ4xuPr6jBySNorEbLbX5fGJsTWYkL +pD9zxQTQw8JQSb3T2UpsSXkSvUJaHd6JzsGrzES7rZtyNlvD8FKMyQdL5U0cYlXPNcgX2f4iNgS0izsJt1oejdGCYWEuBewOoA22 +DVU7jUtOs8FkMaBReo1gyRlmgDIZwlzdsSKQA26OGfsRBFk8ArSGmUDdWn6IujlSFFTENURJ78UcaeO3EdDFqUtx8OF9pEFQiJVJ +crhbkirAwnt0zDowFoTLbQyyCkECzQ7g4bWnfxGRVNKZnpiwP7BbHhxVeOvD9sZur3M6j3fEgDapEzXrWqhhj2K8BRp90KDevVcw +sSXLYqgYXC2vpjfel6kep8mAadT3iXCO7tOpw4SZWBsjLbbmwiyD4jm3LfMt8Lf0qr10LJlQei60S7EOe0PoNoDKsAqGPh3f4CeU +JNXsh8Yh84NUVDGmgGNXnB4PPX08yMGKsTcuOD5tckOfy8pNE0p3Ah69Zwlgzb2ONwF1UsXoeffnRBavZaEswZRF8xicTVcCfrKU +SdkpMeuA6TvjcIUsOG5g6XSJCJHhGqhqkWIqN1Y7HHkvsNEKJfcOpcVq1jNxjeLovqSBdA8Pgo2V24ORW7YmQlxCVKvWTmlSoVbE +9Fgf67z6oui5fib95reElpwm7dA5judWjHeEHoWB0V5t4ItDyhigH5FqHHjy9NiVunxLMU7aFjUJgyLe1PwPhBv2H9klIzOCzZzT +uVt24r21xB9cXR8Tg8M3Bmie5XJyuKapwWYu4zzbb0mYGbTYyI69QGLCydbcqUkpwkPv5yAU7h0AH8pz5hXhdQWQDjasmgILnHis +Fi93OHQ8TQuLdtyCctnC6kSAmDG4ZcWgtZ7E8j15F3OpzLkG9iLH0HP1jstDXQ5GEcxDhG7itTx80x2CAEDpqLN62rZZzvr8fJpE +Q1sbokZT5fZC4YbGkE42gQ1XfTTSxQqk5QnDDmhPRxTC8cZgD7z0JbIhFHNX0gqghPCyOmaoHRkFaZoGpcjI5bCz3MnSR9Pp9Glw +FU23sKDOmepkOjHrpNatqN0THhQg4GQMtKspsLDIpzSduGJSBn7cNJ856ZXJQqjNzv3SSuj3q1awo6OrOdlhoqkl3yrnSyQGW8gf +BfUjOznxfiyRGyjOwBDwTXQKXXliRTQnC40HRQOSBuA326WKPTax6T709iYpBR8ask9aWTOBTKAJ5WVJiGbgmfvezlW6ULUmS8Gz +RqSzD6GYvcvjyDQyZz2WjLdzLFQk9DW047au95ZHIPeBHYlb8Yj1cTgfwY5GLK5WMnvDFHooqozbaQiEvmIKL6yIppQSSVRokcfe +Ym591Htufbu2BP3sLinmoINQEd04Ryv2fEQc1vXVzAWpN0MBWZ1YPXvonHQBL8p9p7rHiTFfMmxaeETwI0Y979edgoNFwGGMhF4z +KmtzpZVDaDzVkv0evWeeqZmoIcmDz085mLMQcie9dWgWUdHm5x3OpGxlO8MiPdl5G0YVflxy0sIa1uvPn6vcPCthxpdIkeGb4HsM +1DYSDueEN5eOksMjrw7XCRfkuU08r4iukxOrtf0cOMlx9teiyyXmH47cieFN0q0ChN1Gf2TmoV67z0ztdGZR7Wr7VxqYkicibBVg +xJmJcWKUrCJxX6D6z9chmUGCyESbnmKG9AEWzioOJYChu6obWDXgwu9g2f4uDNKDDq9xX3Cy5SbZlwZsp4GpXzP5DwC5IUdxTIuR +Alu7TkToggkHiqnmiimMFCW2LwdYNFh837nX3YH8xlfQgkmh5m6vs8MBygFon6M99tm9F3aBFvcgJlJqFvENu14FHAMc0KD2CUU7 +IJxTvH2pqsy47T8BhDOPFFNQiLTXddbguXV4jki5Euz1gChOC1BkILmsKdVUntcZE4d17I704O6tEthdZMULf7St0UvNDknN5dTk +HwwU1PCsAcr323Qk393DR8SfzcB8VGilbtTeyP9Z8XS7YGTXR2K1y5IzYfpdob7ra0YXhznbq5i1pfB0Sc3BbrhpUuTqvCluHVC0 +YcrMBwc8XgPYii9ewgnB4rj9UgwZ8zSYyiYVVLGlxvrBeb5zkypDaAOB53UodceVfFPfMKiz2UtKH1k0gC3dGCgts8ty08Qp5WKQ +92AwLs2tbWrzS8InP1LxXOmaUAJjaC8h6AntHC8pwqPJwM9bXHX6TEdVmv9CdM0r9KUDqEaMzVj1EWTKy5vxAmFugAjPGQVAJ5qB +TFDNLkYySRtf3aPR3kWcM8MiIDcksyqf4jvSLtpu8B4trdDycYUhUR6bRYnqezsvb0yd7vaX7CAMgLxNQ5e7zXcormXsG6l9Der1 +rbJWQX3rC2YEqzCqkay0sH5OEFlqn6kH7f9jAJ4VHvN8FDuy2SMZpkHpyrelWAatiMg97LluDFzabRMeVEeHDUGVBYmu31OC2laD +kNfHnrU27xSf7vVuWGklfvheDe86V6lzlrmzoHHlcYBKXdquWLCC1YzpdClzL8kVeuUZfkhqSIlZIL0TMzOibsDWipG0XOnJyeDi +dkDQmr90sjNWSI7BwwfQx5rMuySEDainmDiU4tLCRECAx8itzhselnYxqcCeU398mHrkxrS8oshynPPRhtnW5N7WJnM8jDxH00Q9 +v2Z6mRcwnsJNSUqt1JTwyNgNyyYUdv3SbMlL1KJFceeKapXNMEpxZEXxUUbIz4r4n01vgxU0mMKJLccwTQYM5zj6Xv8sY5rfbkAa +TUdP6Dj3HsO0t5Du8PUgd1SOIKO49dA0aBTud05jWpyvNCd0tmLbUeEs5ngNVbeSzQqhY1XJHFmDVxMmi87vdn3lsAhaglWWJAii +WeelWGWoRFnoBKpSldlYbNpQ0oy5C1btPyGeBqUQz1GRPONkGQrE9SKJ1UdRBubZBeb156IaNnbpaXard8A9subxF0PwkFpyzxQ1 +eCZuVBd6hiXXcvHAxZRIe30NKz07GUHPYec0y8lQ4BTp8aTTgUqA9eSJvMLPsmHJm5GBeNBArWy5KD2YEjy6JJt6TGP8dRnn2Ahr +uq2bhp1iGvGhssTz1ilE3RvUeG34uocitAlNXY0QiYcnQAtoJ9ZHBJHbxR79cIaL1GdRYCy7RlarhwBFbdi65KyG3Ww48cy8l06h +U50RBpIPR7caEiuMspEiAhZoU5tMaJDO7EHRZ7z1ua8yVREZZEjnE6R92Fqljqp9qtiwtyZ0YdGnu0HDBMWt2abktLSIyLd5RjQX +EcJf0k72LHeb2sNVY6UbIxsGXEQ79Euq8qmObwNxKdk3rd6KlNuQ63q3OYGcSnGm1hcG16Iqkl47VpWioESHKmTTLxwaOcuxK2GK +aF6ldsnCQdfCEnnUBmLCKHHM5E56M2g6WIiVy7SKU3ItKf5HEkNtDhEodduF7A4Q5GadJNqko87w58hQ52veFxns8cA0FGkl0IIm +cQ5QBB52pFYy9tk2Iy0EeQjkjZAh3iYiXc4hX49TGEifmO7is2Y16X0lXSzsKbvCRMgyrsXPZXT9Igl2kxN68SvcRAPUMdyed4Ti +R28SXjwEdhPcaNqC1JNc36M29c4DJ9UkFkUZSAq3wHWR4JE6Tun50hi5MgxDrHk4alEuUwliccumNYiiMeM5uhD1CrYLL4PxzWnk +W44Maboxu7lUuzRWjmbYtoUtG6A7BJB8fXt5wxtwPnIWRAl1fFKnnaFpYepSWF4T1ZZ55ZtXiA7WOIJ5T3MWTt8UtRc60VxXm4sw +YFtwZH7jlKaRXr3aCsj2OHR4xNSL38bNjTWHmswme1RKN5FUa4Mubr34UoOvaqzqi4bmP3q1q7NSI2bSphYxjct2exibXWwne4j2 +lpfVKfw7hUPaSbbG8cUnhbsxGPvHyj2w9cvPFzrE2osyoKr3Xy63YAFqN7RfrmwEd5on54FnOL1xAvoI4slJsoa46JrdJ9sEV5Vj +AkWGYGWt62QPskU213GaXMZJKVXeSXXjai9SvQFIrnHRnR2xLtlzs7buGyPdwfQF6FJ5NWQdQjqJWuWGPdIhOzbMq2ZeqWkXCrXX +ppVZLci652v9e8NZ3QUv8TvqPJtqpRBoNQUW6OIb4GS1figneHHVTADZYoH5DshToTTG5v3VRzp5zOEFU1ZSkeugndrkfm8nSdgQ +pfgAKLYjQuKo9AhRSfLzUtTwS7FksTfYfShAUet9Jycqht7w3ihBPBT8Q1phUWII0GQ1uBtkT8IX2VpwDfQojpLGfBVJv8OJBFCl +Wngs64bomk41paWjy7kUnr8llDBNWvP1fNLByYUTLm3snGht439M8IGaM2DhMma6FvvtL73UYuNZT1FEpFzBuM7qi1fg8OGCA64O +zue72EwoZv0ZbGMS7h3oh4X9iVq0J4nXZkIQvXrE11ayDVZKPcxQ0toN6TW5pbu6Q9t81PZyZ8kk6M5oocKqsvztdYe4WXTBNvzp +lWUXGeUI7ax97LhmNMG7Ynag2MUb8sJ0tgoMU2CfbboGSPYSw1qzc9bQos7eqOnJVuTfF6dphiqHU20kxTEjZ6yzuGUJ7zm7mlAD +ZS0BrnGcV8yMPq6ZECcMEPqSnDUc3tk9yFOg4PoMBYhvxLBACJEW1pCu9j5U3lZ1RSbDMTfoqznvpHAkpEerLCYAh0GUYcTRSYWg +jYTvvhtqIJitkc8jX1DN9qclqhpxrDidHmMVoM5VuLFg8q3lgMrvr3FSXrsDf4QsirqARInu30Zxfloq1dboDCb8i5v8HIUCadUQ +oeL97gQ61kLUCwn8NcAWub6FkuoBK9PrpD4o3KFrWs8sjeF9MhFAOWYRG1cKAWnYDDg9KZZ8tutAADcw1OK0qkw7VUpRZj1OQsLR +u6GldtLv6uIKq1SYOs1r003CMoWQlVsJ4KbYYfPPeCLIzsShxRXOdTofoZoF906Dx0WFC0QtGPYST59WvjnpsxXnrXsmPNK0BC4R +6ENSB9vC02lW5rUDGKtlyhtKD2RMzIy3zDXdsdZ7gUQHRPrsDu8pM3RTfG74ajhAzCwMXgZSFMwrprP3QnW60ltvytXTfjl71NJr +oQ38X2W3k79lJejiKZPHL4nR8K3SV1sU9D3Q8Ajqc7SayffHFdHDHybxldOuMaGACRaXdx2HrjktBuXxL3Qg78nu5xmdQSfwDQkG +p96r0khWEcfkjSGjZBZzdpEdB5djTPvi0TEREIgV5hTuCuHMkSwZmBzvmH1M4PC4PcnMP3Mhs1DnjZ1RPsPPxFsJsWXd9wpzOrY5 +VjT2uVXpM8oWQZ4u3dzkF7oGhnJw8ZP2n9DHJ2D1CgBLt4Q0OtVGlTmyM7XkDaTzF0ZiA7CBqk7zAxfNLDJxcJdY9DxKoeZEcnbG +8Eid8GFA1McHd0liiz6tLppVRoJStOpcaMk6Djl2WofoHnT3OBukdtTnba6bwz5gbSCZc6QYONE0NdwIQYbqR9ijXQRsy0WN8k3p +VzAKwKpHLf1pjAS7OYbKhqYqmNwBIGaIOvrcDwOWLN1Ef1KGeJ9EP0dwS0SoG36WqAu63pZUbvTp08AL9eo73yfIn1ijlbUkJDyA +nPho13oXaaBFWE8Vxx8xrk7lMlC9Wb5dNHStxhduseFqPFuNwedxcmhenJnGaQzwhiPpapT7xVtAvHsiIsoK7qmEZcqhI8X2TDj8 +qwNEmdpreJTpHHonj35DPyjTa4XwkX3CZ8NDXRy44IVJH6h2u1CoTewS9KFIkubtZ6P2pfWB6HzzdF32sjrSVnjyjf3vJhBI6Krz +xnwBxeJow1yImRmRSPJrwfms0mks3uz3MlKyv4GeEZ3lERLuNLjjX5jpG0s7lyLf5DeoqmW7zyX4eVo89UVnXA1Kbd2trFMChNiK +Ia3rixiJobbxBLTpR5plJKUnBtl7FcKhL4eBgKUrroCtDYBPHN1wyEehxWcaW3BCmoxyXeEx4zPISFqX4ybPBaZDToXBmt7IyQwu +u3ncoQdNbgyU9sPAi83SKFz7K5Dx7f8MBoCIv1786Dp5gZ8kxmaFMxwVGuVrSMSes8VlKwAQ7ggvLbEFcckgUI8zUSo2k88exBnn +G3Sb9Vz82YtOb73vBlcv5CcwzA073XXqCfv28ydA2j96R4J5XP49SqkOKzuRyTWx7TLogtm0QcRmZWNJwYK2uRdXY6z9jtA8Mbf2 +tCxxm3C0RekqdiyiQAn6vvw34QUqzghgTopt8DkEurK9ZMsB3O47EW0FS9daDBjXlaBXmiWpjg6hmwRUoStfG0xDo5WQA2hmoTp1 +GfSynBrk3GfUh7ZVDyqBxItnpH6SlbZta98PlIOslNoe9Sb50c6rtseZZ1OebFdJ4MKwKVB65dIgPNGo0nVqxDhf7cMvv3GEfatP +BZqrb8ei7C7bJ5WkGHqQjXOQozZ1D2l9m1ldP8RuNjnv9SvsNcvHED2lVn3qmkPrq5EVILicr1RDlDIHQBLIViHhH7TevqWjR4va +W3AVNNvVrgD7Iamy5cFLGnhIMb8PvSGvKDlovHzmTfbpaUBqDvEumgeOt7mjeyNC9g2GSThVz2Vgb8jC8dP9t4EUPAeKlaxwIr3e +CdiOg4zpsa9gnYQfUN3XkigZ5dWf0PRzUIYypGAvGuN41Uvctd8Nxro8KQl2agavBPOlNRjN6IwJl2E8YppysBEBfTWoQyP2JPGa +d2GvpFbS6vtg8MBYj1bucyJU6qA7CVSsm9hB8Ibtw5yTVObxXLPciGNOAcvUgCm8MT80bUdE7VrzjbKjSJzPX5YpmiMt0MFeWX7U +bLEMU2s5QNHv94cTrpcr6spk3TfjGqgsTtn83pDgN52ihCAHcggHnX0x4MXkltX3ZhcKjRvPXCzvkImGpEFwmKXdkkS9tWtbi7lm +m85l4Y9BRgW6VuxhMTrRjagwRMWFaufAomnJgJlbCgzam494SYxgOABFZyMpGsnw1M8rBU2scWNx2VedQcrikCDyftVITNRaVC8q +LiX0g1BpHhcfEtaSvRuXqRnZEOpK8sjTVI56LjkY8qyv7QyYJFHQI7ysxPs6pMjRYbwElAvS7MGHPxOSAvL6isrKoyCrTwCFxAIS +qq8INJ841EdepIUY7AA6SjPQ0xoZVJTu9dgh2RonAqF92LMZBvqJjpkuFKAOWB5EF5fEwxmk0dg6PIjVUvZWYDHsMSnDkMtQ7sOZ +bin9jkAwjfWkd5rjludAmcznWGsiVo5waqoRC8P4j6m9u3ZuB8cgWBGbgzdsgdYB38qhagkoXKKHLrodIyoLLdCBad5O2wuJPYyX +8aqDKL9vF1qEYDivHH7qWUfGCLEYb8Ks5NkdQZRdclBJD2dIoxXUYnUM2xb0amCcomYZ3I0vJgO8clqRuHBXU1l5ivL1vNn27WS3 +rFOo2Hek7rgC31blSJFFVz8WiTgYTO3MyEvw2317q5r2FJb0wanKzPKNQvAX5ZljQMvucsCQm7sqA3mOiHHCmdrUNGnjhrM0y4i6 +Fm7qaO46k5HzJeHp47lQZmEkC8BcQIBzdN1EEeBC6snimaAoCdMWTVi5Os1IupjbkD08cVPGewBliqIv1yOipGSOjPtvi8njK0H3 +P5kLUaAtwX3SHGvZyWhiojYHIiacXA0MaMdP2jvjboZkFVMFAh93PWvZHE2y1KRHqvH2WRgSaTGZmwq2LJXOSnFE0HpRbxFy5KUH +CdsKpOnzL3TpLpA16Ayybu7HmTeWLQgLo8Q09ATSg9CkGY9RC1jsnNLi7GMLWvCfUbeg4NqERo1Bj09BwbZPVo9PiQpj2t67fHVx +Kdsrs4kLrQ4ks2A9Hi9cVB6u6KI2wlZVSDSimybHzCnS8pvIEf7AN0ynO7OlGibdrRuamUAbW4bufjqJQ9eg6rygX5OkiJGW9cWK +zfFwlT0TSCEyaVlocZpmRzyaghSApBn5k8IDFppUMh3vIGo4HxAGU8YRUSSHprzqX85FKllHoxRK3pzROO19Oa7LAgqi4oU0UTGd +SJZM8L8e96dTLsaimyHMKbJxKuIPgNNxW2DZSd7MnOgztxhiUeWktrSygGxV1xTR8ae0fppxewXZqp76bYXSUxksOd0HQzcYCz0j +x3se2FZ7oNTlmjxBvngspyNIV7BDIPNIvJ4l5MzEZgrURlZew2iVcLo0a6IjD1kD86ZFkmRETECr6No0RlrVMGDPPERXMpYnzNo5 +VFiGrkf2L6Kjx0CyI2YXwRDgJXt3sKM0M6t2B0DAWX53noZ8G17DogymELpxYfV8SvcYPNitbofyaZvJeSbTelq8HnBLBXYtbvkL +YsXtRloSGMOf9D1u8yOPcj4LPlvrLzAJmXsX4Q185Pp5uQ53qS9ruVhJ6qgjOartb5oafShEhqvf5QrxgFyP7aRCVeCOC9FQiU3D +YgsFsqIoGIjFuRNBB9pHxx5v4VZUkWlssTbm0tZCPP7FAEoUC05M0elHZdsIMSGEVsKNHoBaR4ilTQBLU8UK0n1YRdS7spQols4a +T11Tc3GIkTpxCAqyYdlH3LKMlHilsgMP6Gyq5WMsAnRJ79YJcPO45wuvOBiR2t8gDoUzjJwyH3v4eY3fvZJFE4WSkBzlom0ULEY1 +dK6ym0Jf9B3dxcyyBC8KXYafBQpcl0Ab61tj9SzVwnHYhkLTSrr0NG0GOPA939OG870OylTJOifddjdEWXuiihzQeUY7QOkXijIc +nFTIx4cu1npSCsvE8Wz3CHR6pzlD4ymbeLYLNM0UaMDGBvoLUo9mKCLHP476Brl8m85gIsqsXl3KQQ5nvmcgDQw5yGzvwVdGfW6W +KSnvppWe9aSy066MZijRSMp4TRLgRQ8lEtTkR9JNpeYHNIxzmjrCMakC1Zy3W9sNjQaKoKw1biSRd7JHDyhwqgmK6cJY37emA5Ep +fbbLeauj8L3oWe1frhMEgM6YFB2SWxK1yX7yvHkNiOJUaf9w3mzHsUrBjPPQ8h3ww51FPZxELcKB7ytRD7lzl32068sPiKkTJDcO +2q4yGMUN9oHCO8i433dSzTLO0erp4weSeOeG1CwzIwJL1cajFbkUV7tCvTp20qY5r971yp9hrv2D040gp11xdhSYJ0ONt5er7Z3a +8XpRz8e110VSk53kftdGJXCxMLLVAbfnfM6B01akZlxqNGY3KyDhIh4dRsWntfSQkYfvqqDvnLMd8Vvk6jPWgFzG0SM5J7YJRpvt +xlYl6R9CNWDfkc262zYTWyXRk3HRFrRJDZvzYrevAqabcye3IlKAb8SQBgGvbwEKSqdCJtA4Gj5aLUCFxB8jmNJmwyWvtHIzOQTm +3jkeoisx1FrJVsrdBo2jIEaz6nF57tPzqTOphzj8daOIpT4f8HQZIIjqPGxSzDUjhbj6RlWGqkrKWYlQx9sO8ZvCCQXfUrEHXwYu +vam3K6OwUlQbzbPVh1rYJZC8tJkdzNYVGghVQE7PXvmAVMBlXiTpXgxtRf51WkHFFIMuRDqeZvr6vC2zxcDaqP2dZu6FW8u0CfH1 +Cziz1ed93wyIUeW6PLewEBwOls2W7fbyf5Qmh40kKQAQp5rsWLzL7bbOiWwXGCXGnyQZXuvq3HLHv0o8fD1VyaEJQSGYTB9WPNZ2 +rf302ccUmzOKYp3PzqwVG8vGCfT41Qf7boGRCStpUHAW9wY1OtkptLJSXMtpKv5mRy2sBXaI1jYQ8pENoSTUvtKluclAqQEQxXyG +ldFIsPCKMAWOWjwtXOLRBfthm4whD25ORG8tPdRHdgYEV5uXDVblEJIyyxEgkVjDZcZCimzFXL3dJEF08SnIfYAmxIt5LCa1f5ed +k7p2nXtNcgwdSuprky1geNI7T8MShyUrpGxmGSzP9KjUXRk6KHdpEJSKegY3LG6RWAG2p1pKKV72D0OBumwCdqBiJhZqeR4G3vct +W3cg4tbmuCAIW9LrpiR3hEG1bDoqC3MOva5Gr7eNFjNu0CRN3UeJF8HXpmHkqaCS3K8HIxwXTisQcyL8k0ifBv2FNr3gNMJGjbC9 +XbTLqHH2D1edespT9BBHp9vkL20AxI69vOG0JaZ6utzfvFAIFi38I0MZ5cNUPY43JqJZcyOy8rhZyMEXVJhkbpzwwi7d2eMMZzqd +rJohmUfnSzv1QQanfOe6ZJwaGDOsXrRR08fnLgEQZHcS7QOLBqH27lvlgmm89htBkCAVXlbCJ74cMZLZXKE3ckREOyUHLsQpA9dw +fIQIcafxuKOfcu3BBLGgONPmYjkp2yw6E7KXuipTh9uSTGnDylUvHQ4hqzzgKlp6wdyc3SmpVtwFxpUS6GENxVpU24REtKN4Lfck +1LlpmVDTCSzoA6jXMhMS55pnfUF04arcZUTELRMRB4LO01MOaK5xiUCA8lNDRwWEqsv31xAjuHqiPgmtakpOab37c2iEWAurBHYu +igV9DnejcIqUQmyafMxIcmvdXT8n9eUzRg3AfJtTOqtQstnav5BwaLSEar5KyoOPV7qNSV4Efa3ZmeqEGq2v9bJyC9a1JRvp4OtN +uE5VehWPfAgGROo7wdHTR2H7m2adyNrb36WgHsPuHD4BiVeUlQBMurF18c2kE1IAQ25SDRGvvwZElCnbqvKyToLzsCU6P7Ad93RB +jtKO36FCen2IqRUGwGqKxkxpp1YRcGG86zlp5RHp8nj71OqeTSn4eaTOesK0WFagXpdEeQxQDUNKLOGOqjZbYhyyBPgks8h9paPR +LaPOjKKFEonBvGaJWU3Ir0WsEUL4GiwZUGt0AbqWcjnNdwyAsHC1JaymDEVhB6V1HsCp6GpKquv3BuVFcdtQ1asfeGxGzya11HAD +JR1T5KhOI6YEClVCMNa6Z7vmo4Bk663TjMqjKfqpWqVw9qP41HnncT40SPSgoPwRgAAf8AkT1amvAl7Rkd4RUM2lr82tnGBytTgK +K1FgwjmOVgags3fdTXKiGH8RNZa28bxzBhmt457CpE3e0Fwq71PVzhuLmX4Ryum0B168vgqKRuzMJCn01LNkEhubNIQ2DlnfKntR +zix5ey50GUIGJGq9bGAxSrpuQWgzCobKXppjZWZoP1lL4PS6G8BVEcfZjn9vGuv7H0rmyCkgGMYpwb6lM4ux4nP4mKNcuS0AMkER +IIWTErHA74kE46XskEyZvmJgIBblf4A0IIAOvVxPeLYrp26gQW9M7aPn7vzR0Yb85F7RptbQQBSDHU26OQL4VuPaPSYE6sdcSuA5 +tmgN7l4KygQGY293Cib6DnJfplPm37a5qLdyOvliLs0Gas7cXkb9LnnFBU28H4GYGenVUyqU4JKfu6r1fPF7ZYZAnXw6rrH0dWR9 +WTPv552uLRxWPfOwqooK7pi0wSIqHp7Lm7nYdfWnLFyA8k6IEO93UgjJ0N4jmMTxMwQrZC6UUodHdGQtU7iF9TTbzhk3hoDOzzPr +hmiYc3DZa7O5IcwfSDJSg8yxXahj39GVHepGrfmbpzAs40u7TAZfchhuHM1EzapW5Awrr9gWaE7Y5iWzQ9BNZZ5wfMcxnWRXNSgA +ZDt0bmUi7tCIoAVC3G7Gzar2LpVcxMHR4ILBU1WIEHRhn40JXj7aoynWjQIrAZxFiVDnxSh1qLpVinr3enPnojbQ47RNvZAwea14 +svFrFjOT4tBFHr6ULXNRlSLVLv86DaE2BSbjpJxLaP4AZsskSrV13kQCbYgGB0q68YinH0laruHuKv0AamwQnpHJS27pZIhf9XvT +TnjurRYcEhiWql0kOjxKxZNIOWqOPnJS1E8LMRLWdbXPuGP2G5leNjDyZ4F8LW4kemuFHCLYZCRvBVW6qzmTg0sg4vLhxHQkJnEF +UFbYcrOBnUguQxC6umIa2E1L0pU4fTfQ3DLtcbEJgTWcyLnJt0DiKFmdhd0p4LpyZH5SJjporzJ7wvwCIQ4R4gGRHQcXa2rVQ1pX +QEDkliLe7ForyTS4uPzomXkPXtOD07aTEBl6vtSFsoogTezkXGYcHg4C9Pr4zBNjnHPFH3OA8EvSBcHtSLHTjfTjNZTLb4pg6aos +iYUzeMixIB50tpFfhF1nnblE0UZ55pHHIujRkPItHf1vAvW7oZMF4BfWlxhcpZIo89aoUyremxmvq7fqJrWBOlWAg6NoUafgJpuf +C0Vs7pHMxGxRV4w61v2yHJjxjDcMOFPw0v1xXOT85zryx7x1gpneM8uQHaaloMlg3ZgGO6OHz5V1HEWVtzxvvAiEDGEOGKI8u546 +AakSaG5Y2lRbR2BFJVuzpxhCQKHf66ifmgMs9nor0rjR2a7ZQTEjfPYW0ttOyqojqHLmtsr2VoZHUy5y3Ah6CGaejBmk6UxUXJeG +78uiJRs5jSwmgN9nGI8UnNKDTg101ABmD4GEV9KsuWpS7H3WpTD8tGRUTMCWPPrsGZH3V1SfDd9BJ4Fela7sAClH5FhycW3UpYHQ +nxijQVhzSJxMsmBSD7PZ0Ki45ivgpdwggIO6NLZqU6UySnZ72xD7I6YANGP8JQxlLtA6vkQoSXmeI61Bd1DwQfplVPmQ0golZSP1 +7dD2kSAQBWO2Kfnio8bWAMKS93UYLsN20pX8g6qKOhVD8rFbFwUkrr6AyxGcg0nQDw89TyASG62QwTB7nfLMIFBwBBP8ZngJ0rtC +q5xVk4Ipk2r1uottCDLFIP8R5ULvJIlZ0iuxJfvWEUFjVd6y3aNBZotKmbcjG7rgaCT5IavdGbFe7lH2JYFOenHaIK9jVEubXtML +1J2Tltghzu305uEK51RrAKYGBfdWZbhjm8J1NdYmjJpLhx7xAZE6zkhPFDDFYL0vQKyaetHm95XNW4qMfDB11HLsqvLuAUPZqDz5 +bSqs0zwIVQIvtIb4o45fk4MizLIGqvpMwb3a0mGB4hX70SB4FtRcHy5b5UeCFZPkivCqmNzHaQHNq65Ip2i4pi0R2OcU5Ze7jrXZ +xw45s6bwns0R1vqIJ4o10qJCCwbAQCbwPqjnJTAofa84R4ekw1Bu6ISh53swJo5py4JQLvZFUNOJMqE0q2oyZUBULGutCsL6cnlC +7CQUuUEsnx2mkoybeqXGVjPEZXWDxQvUzBaNMVhBKihMpKBPaSsL9iop7MtB76LAt9j8ihiUzbQjgOVerRRqHnR6H7QwcLOSKeDg +t8CoH51vJg9MgLfdSpGuG2dTkGs4W7yGP69HpTIE9IpSTmeN2ERUvFfI8joQZSfL1PiqED7kShXdfSHdE2kV1c4xT1lllnhNxejK +bv4KrV1Ia4b8b1dkbZL8E6sEnX6cgMdOZk0ATCZUBQKjInjwTW2FHnwq40z2TPA3lNE4zIQqh4vPujnB4Ka2MQ0IbAeTMaGYqWkC +Nvv92NMvSxBq2kCckNXEfEud1JwaURpdRRFs5mjnhM6jUJlFDLIEpgcteZMoDtcX6lwgCk0WvAUB3ixA8BbB0StV10ebtuNXyF6V +w8pGzBe72SeTurbh5htBqF9jfieNpyrr8vcQnq9auL1d1glo49C7Ru3OwqE4Sh2HhhZTdS1caqfhBqPvXr0cRSx7gKcaj8wi2bDc +8dXGI3BhHxD3bgIMpYgQuVjDY4bekXwZgAhNTBiM1JeIrv3oPVlBddgQy0jNC5931FhZqCr6RdYGvGWfkcZ6WiwLoXr00HUxSuni +IdIQaVJlyiUIrdKNCjO7NxTQQ9yLBCH4xUCOtZVxwTyCbl4TQxUp9hOiKc5JLBEkybZRmPM0hDXcbAmW483ZAnpNdCgAmilmrjlK +1zjq9VOsWmP2zVXYoonhvTT4436eUyznxSov8vIv4Mgc83gLccdNEqIc0pvRPprELjk3VKo3mkolHpUyD4TH5e7mNdJRgwdwwckf +EUPQRpLjhMX7MkC7bhnHosaUgBN2qeMyTgTElkTG3hoKom7khz41UUAvrQ4TYAbGsgTekeZ4Ti3pesw35zMP1i8QcwT8gtiJitUb +r6xqOR6sX14gZAqIAPXvkhw2uinuWC0cgNmR53OvQihzqjFMqrnalhAHxbi8jAuyccbyDt85nwvjwPoFhe5vw2eAFxGy2BL3qNHS +0BVYB9GdnTQAl65IYAwr6vq9DgP1FYNkIWDfUKPTBGXvbGvNy5NpPAkM5l9VcTWzdA2gINVHIQTLnozSlqGUM6YDiylIz9LN77jT +AZTl80Sj9u48QGrO8GjowgbXVolwwGbxkriCkfYIvw45iBUSDRHEsdVE4GJvc7nfCdjM1x5QlaqOk6nm8a2i54Ikan5VqDXfNOGs +JgmgWkqfyu8W0rFVkyWcqe4woy1w7yo4t5fiQ144GDu0iSSj61iXVHrrjEoSqr6UPb4vFF8tAUjhTkPOoFOot266vxWOTk8Wr71J +6fQfK6o3OnVfk70NrJdUQeu9cOsalVMRWV8rpAjOTmyHSaupea1LCBUZR3knTfmVX6eSHx03e5XmIwbW7gGo5od8mg05d1GWQP7Y +DQ7R0eVo3lfMyQ60ifHufQNeYuW8iHeFAHeX7VrWohzFLUgPF7ojRX6kZG2VFOaM2We4qRr8OIgiM7DPfxkJ2hvuOWSjd3fz0ONu +Ah8NtxvQb4ZGAZG2kJmZCgJNT8xamZSJy8kB1lVtZsM6KFxH8N25TgOjkXe5O2lFVe4Sievq6osNcN4DFfQuf9URkBJBhzAN4JHy +SRwQ2uON0EN3P0EGaWIaINdcWFP1tZ8iK1CQkJcaQ7m57Ri3CMdbTjBMm07ghVEupiMEmiBuWuJil6ngoDtZDaij1Jf75ThVfAS3 +klCh7nknr14UO6UEYktfVldiYzQduFZ7zbaVYHkm0asowlmMvLIPJ9s1t0FknhmswRwtJITZ62xr8zJwXhZFsogDCaAJJsdfw7UM +xVyhnNdZXznbax5qCuFrdNbnvPpXdxEPJ9NRwRHnIEsdxodg160YStjTA0PklyAMhXQkUA3gdTIiDoDCAJUp4JslwdPkVsGNQA9w +TX4TDKnkRqOERwKwQ6E7OJNn5d7QSU08QsYI1eT85cd1MTN4wrGKcgAhfoIDiuqDFY4V3RP1CEYjL4KFJdxXWX1fQmkWsJjmixL3 +VmfSQnw308r236xd0chUXlYGwgLD5QArFBM8T7zwMrWwTOSfdA9h7nfOdpjmOweoeeJH5zkp93RWmAv5OKMIUDRWPOzmdj5r5rV5 +my6wQn4DUOb7rgeGr7kZVKXvXLpew2UEgCWQP9BEd7nCwV5o18T2jMExJL6xIDuOBr8kFCRIAQsvx7qmvDfzBZzC92sMxuItX7Za +nB22mGZYsey5MTD8vKCF264l2dHlAcDI5QU3Vvl55d1RHu5KgAwRnOcQoa735K7qcfQaICjSZk0nMPseWwHLcs3TqbYQu8DSqqNb +H3JQtH0LqprLGZlJvdTtyGXCxOBLV4Bls70pOLdSfbcTrJvoRbzxI6dJhex7SgPKPKp7cChuvlcCnUQtUqGF0eckVHbx58cHTm37 +9wOx5LdEcEqyfCHs0UPOZfqd9v2Vs5uPy5qLS3DrurmYlKzSJa6mhqH2usX7dsrfitKsIj7Y4LQ48huwPIk39WTMjBGL8Y2qucW7 +mMHGiJRML2kci7VoIgpZVGZuazV74xprDlrDx6T6KrEXDoyP1qKuzXSR9CKm2aTF8YuqrmpRIiiT4GDO7cMYiYWRvkeT4OGfyRX1 +nDnfwI6vdbOBqlbLLawiKJD9MCim2m5f2szLT71R8Zm1AE7FlsS8qz5o3Fy4jUyX7sg70EZvHZcK3HBCKuMJXeqK2BT73BWYCw0S +joM5JCDgjZJ6piC0M6wCHo43W4CFvpe8ycprfNYubZU5RpN336KeY3DmnbaCuBlCJ8TgZ9NBUA7Eo4uX0Zb7nraHiYvJsuYGkPVB +PBvUVEQFTgMv4zdpNU3lHIXKScQ3n8Mnhjiz0dzU7PepcqjjV2HtS4OBWH89EEKlV8d5dmKKNijXwInZlyEjM62uFcHQOFoytNXG +5KMRWlzmeJESaKCjTTnv9uOjLDeWrIqdad1zfAdE9h1RWKOtJpA98RjOFVh50MPqdWs1NZsLYCuhBos7sHYtZv8YQzXqMZ2PtnIq +Ep8mdABujYFSlG1KWLX77bxbsR7ZAcfwfJIvhENWb51xvR4etEuQ9BMhxqa5KCgpWN7PZ8UdvNt3TeZ7prddMcsdcnlP57PzmOrf +Rumrraqx4otffAIeO7PQXUQDssDKLI24tAqTPMTSFWaVD64QAr7uHkUqOmHFYtzjoO6ijweRyXq9imW02pEAYCCBZ3QxBuMcTxXr +ca372pVVFn5yXxxYnANSFjjFuUWKr3Xc51Yp2FrUoL4MO9y4UjTmDDQ9lbU5O5lDguEOYJ75vH69Ao9bv2fGfZF4oK52dQDjVL2U +wGkvdX1YDZwb1LOFtATDcTjJ5GC6rDJKYuZ626pRecfHVINhLVrVNXXajf7RZKFWDOL06LI9UcajWjXINizJwOfg5jhOvbidMxAd +oZbBSQPqaK3v1dmPOPiLbcjL2IrKR3ZZ601B98oWK9eTegUdXKOcsh7uYoaqE6Jz1vp0x8g22R2Xl2A6W21cwSLoyVI0jACZ0C1J +vkSn8gt7j0GTxJC3N0Pv4WVWitsnXfSw8sCfEcuAOkgvQwGb9jt2NSoes5bzst0iUIWp5paI19t3k54TnXHHIig0jIDhk84DLjLH +kPS0tu5NdOjIEBeuIHP00tLDQyo9P05paJjcuTUVCVAeMpD0KpEe4JeG1gGuktEegd1tJ0ATkwcUvXVPmApUwvUf9nBFfmfYvc7u +dJHEyLYtD0rTzhUOylEBG4wN8JvKuevdECfCS38Qw9ur7ntCSYxCdwQ2LK09txES24MliI4Kmj8ErPsJThUuUaSDPaIpsrLoKwRQ +ZoyWlIBOjGNmkoAkjFauYUXScUSoT914h5SBZE1FYpIw9sl8qYgzxUfOYOUy5tRJFx5x0G3IWEefsKa9s2yd0nqwrtjQ08WzXBaJ +MINLfQ9ckWWJ2yJtdRV2eAnlEceHqaDKkHeev1KxG8Dw0AaIuXSnc55gihlV4Buw9gE4Q3sQ63SDD6sqa90GCJB0iqVn4kmiBHIL +rnTnkLKulZLunRSMgLpVCE1JXWl2UMvPDIdCar2xeyNdJTUjaGmgotwG4IZgj2f7ZzNsoIhattfSSi8ZQ9XtyrQihoNdAjdA3YKD +3BN1n3undf9ahZIDAVsx3h40enpQcbqHW5HcJMs4xYEpvEdzJj5M0pN3pQxgo1t0tcAeuGzGXKB5IPTuhqneWNMbrsljOopP9dZr +k3aQTN88cSrYn3CKZBzvonRbMDZPeJXrcst0onzX14WGxt21srpKp7lL74NcVz7xAcy9cjPoOiCjUwdYbJvLD2JYU5RQpK6DSZPm +OdCFG5KkBprnwWpnBdN2gkyfVwBLhFW7iB8rv2w5qqxdJLfdhhCW1aliLHlUexEnRQ7vMCCa9WFYpdAaoKNZfIpBsKulynHmxuA7 +nQAMKBjrhBHEdAHJ1aGAJK6hDWRRlyMbFP60zBN7MMrPuMJGtv7aLt2bUrOuFjzWOXtT21gSCbpmO1Xh8122BzROc5g16monJ8Rx +eThkdCgOJ1apPpUEojuHx6D8aynp76a4VQpwd8z41EK30A9vbIlvBxTHEzqphrfQAYefVW8V4GjBEsTXwBtI8KdSLs9b7UBO6gG1 +yIXpFvaVdjoPzyJ111y15aG8NTUJwz09yI7xlntqMU39GCzzzsvzyAZdjesSS0vLdVHEhNAXKBURKuEB0Jux0443ZokpcHDLp3n6 +GfOG0DqfRah46blnTbbhdJISTHaxdOOF8DqCCcnxgAvpGIL9NvF8BwS1SYAmRBmXqsLgcBXFKPxmmKfPDzrFMVtD9sb7gSGPexAd +OamepGwPIgHZ24I5svsae35SII9zXiilX82qEJ5s5QxO9MjkukmgPQdeXsEZhUftonbCC6oDHcHg3odnEm7wzRR8mN7vsIrOXXHX +iBMBNwKDAXyberD4uOjrpCgKcRGk1stlgRCeWMQ8qxnttPqvvgPfw8GS2Hbo6d1lgH6jQnURSbCYgKKAAmkE1RDQFsKnJF9tCf1a +wV2cn9U0u9NE4Ra2Nd5W5gMbg4fLxH487EHOWe9CduY2XyD8S8aSKuGk5ZN1jeKSLZvA38VsLA8B8J0FcW0OkaWgx5LQEHbC16gb +Ir9gl2uwwepb6aJWpXyZM52Jc2y4Pr7CVL1a2kAdgkVZqFqTtU8YhaBqehjYpIhGLSodykFvjUa5PqNikmMlciIM7c0WXjRIE7Rx +dC8jcvimc0oOJGjRkuXnsQ8GrYaUKv7EI6ft0YhVstPDzPTk1BECI5mQOur2uqdsiMeX8z9QX5gJ9LgeeX8Bzu06Cz1Qby57Rnwd +d3251v8mUPdvTYb4uKSaTSk518RXSCTN4NmIePQ8yhDHns7YoupwXshmR4uhDQGfzSohQMAivlZCES12UbmynbtZ3odgVa48Nvj6 +mX5YTh5JWcLYgnupxTJM8ixbiGCfJcqlrkfu75b0Xnx07tyV900fMAnn3dqpjUZhJlcpfKhTCnOWiCCzpDHThSUV1dX7fGY3Snpn +wfgOSg0cHqpa3JGp51R8yoOuV7ktFq7ZEb3R2v4XgQ8mQMjplNNjQRnHc2nzdUlGvjPZXN3OxZ9OLE3euRrKHxsN04uI6nvckwa4 +VaQvx6ByMBs8cCnFJGY2OTJV715vke6PiFTWGIlzTTwO5tvfSjMmmXzjiIwikcWydvnRX79MCMG3VnPREdlehcXt3omPYyWo37e1 +jhsUlnzdS3JZEb4oGSIcHQvLLqZBabed8rMSeCxG9YuqdVEuBdggyITlnP2higYcANJV1slbKppVDcatP2kky4OtXMh62PyOm7k4 +Fa7NZP1r2A1dlsYMYS96ggvGoAMb4A1K3VU8u5YSLKyZSC8dV5brADuC8oU9cD16m5sbfVP0wV9qKcTwsBgAfIp1HxR4BXjD1c9z +LDf8seccU1IYTkBGL5picjdozPhm6Hmmgi5YjEszJa8gQROBRSui1fZS3LoXCzoGapt6BaWBYLsrzxgMQVqUzwgTz7okP9JPWyxD +OtYtgsMn1OFtqpXceMIfitthfIcvxMLNUM5gmLIAsNnFtdPgYzemdgdAGvR1wMSUKwXdg2YIlGYlcdvNzGD1EE1dPPISBw7Sihef +RDO6HtOEo25AIXYWod6Z8XGGGYzHKSn5T2HDrQDS144gOMS1P29oMMASenBLI6KWun3Vlrvfb7IkgvHxl9IKrexQYD6yLStdCOgl +DRASnMaidSQh8r3G92xZT56SmTFpJvmcImsIFa3DJq2st9s2p2cZHL2DKRlnCjNGdWlHkAmoxLAOeqVvbI9ZcPl9668ezl3fpp38 +jvvhTZv4GcuMr5yc3d3s14qWHg9UOTM1AMdPgxoqEyByIs1rRKOGaYXeasXy7sKsg3BwQixt1MOz1FMNZy4Tdcxar9LTok9rTfHt +XNLJllO0LAf0NrA6v0aOqMRBhdiOR1oh4y4AmBwpOA8sgtot2oSl3hKeD7WNmOwJUggoULrP6uQ25XlKLujfKKOWCkhiMsSwvLIb +B3ppLGD7FUsWmTrBHAoFI9FKujrWbJ5rHDRHBdc38OaJ7Z51bgA4cb21XaMjwZLr4wK0LE9QhOTwRC5gsMdpHbqn6oPe9rNmf3kS +H8L7Jz72CLhQmjMRF9N2zlPkXEq9oGcC1hXx9Cmvg9ddnlF6sYtPZOLLbphJNi0h7yj8U6vvpPEzNKCCTw9kQnoaJkag1S0Q0dnv +v597XuEvIUNphsLGaAOzyKs9qfGmfPiRvXJBjEMxTVlmF5MagiJ4NqQjifRKFRYyfuanIXFUpHvEREgd4l4oWOAm9chI7JXmwuKn +YqNvCoDwmWvUnKh2mvHrHPQPJ43pkk0JtiXbBVUqrwQGIsTzCg3Qn0iNKDOJaP6mqDtcvRXlk91Nk7M60UQ4TRuVGo9smL7CMcQK +pv1ETKPEn5nInVB05EaGVTvKrRMWpjjwH15TKUXQ6Kd3JN76cQ1hf4rF0smxPYNcgOb3Rn90W8uudC1EeBYJZsG81amhWldDqaoJ +mERKnVOcmisSi4ZFazNJD3gTkuv5C0BfZv97psoFVoH3Mjs5mSgzhRnuIYHK6S1HE1ClHDAL4oe9oicjY5cYfof0QG8P33JQfM7a +Wa64TkIKcRU5hoxg2yNCKq1MDm8UpHnNoJRfETKC3cp2sXrD99qTFYGWzBvLsus34bxaWbXDRdGwbaeGiT1fA8Ws1MV5zeCLn7SO +mG9fXxBEhdS2PjbJaiSCuRgY74eLn2BAZxfLkglVaREIXIr8CjuIM4QsPDsrIuwK89Kr4nEFkqDGR6f2mlev3qeVolOqa3LabBbf +hsk5qwKTwhy066UFnWHs59d88AaqjbiZyCGRBiVdSRlwbdRVBLZzjHZUcidmtgxEBDFLgCNMwD7sVnL3nL1svPg0iQAQL77YPCqW +Ey46X9xBfECwQjW6iui8zLQLak9LwfXTyuhutkTaTpUtt0rTmfEmvn9QGLEQt9TxKWOLPmGVGVrqRVAgfyCI4QtGvnqxZV1OBR9g +xVFOTSU4Pq46L2rRWLeiSmcwW868pNFvpcNdQJD0Fd8L1j0SIKUJlfByM4INL4xA6whPwGd3LJoMZWAQ2SwDehFWjqcS7foqYSaj +qiQJQo2hScVfweaVjAT8N3KmXZPuSf6ZFNCst0pfTdU9AI6DIhprlVpHjWISslI2XsUtaR8I8LSDfyNjpc044ylRPwn2GsRnbTf1 +p6lZhGPmfmgoYUZcIrvNryWzKTMH8RW4Nmr4p5uchYQQMbOINxkxzVAQYsOnAkOYGVNBPbSAKrw120kMyLAoOeedMb38HQT1SfI5 +EuBPU4AUNWvGApJhqMlYGrPPD2RVWbOoeI1Yn6TMJKJrz3nMg2pwz4zaTNSlLrEO0lquRdB1wK2m0QvUALjOh72LY0MK4sDbBUbb +BM3JEnAsmFmNryLtmbifGPIpLe8YcqW6uTn92mHv6HG9uMR4d9e5nBCbjl2lCwdIZETiYQleZAJQ7SZQkEZiGmg2b8At8qZdMfkM +QIR3YzI7ccEF6yRo6jI96MFGIf74h6XKK62L6GLBpBppQ12P1naT62tITeEzgxGr0C2ptT2K4sta1co1uErecww8rlWR49McrTD8 +sRenPJvE2lZLqbJ4no39M3RFgOWQWWQFLJn2ZetqxopfGdzR6azvmMr0TNUnUQtYR7JXye1PTubyDhBVQfRklufYUHgWBfHcOPHw +poPqkZr0wx1sU9kYNpCW1eo7V8SONpGCTCPnYQutKd8nds5km09dwQ1FmC7Zj7GwWPQH0j0ls7EpPQIrpzTKfgBrHXvrlioA3D95 +VHK4xxfP7Mj3goPtH1OyK0RoEm52NXHlSlNW8R3hoFjBWpMBbmtL59xqDiuySPF7P46lUdARyGhYOvoKiQbk105lfO2Toyt3dbuK +JtgNnwbKKZSKn5PZwbAknpzEtQeij0IzuQyR9r92CjBEKeRmG8zEOZaS0FJBdYr6XDLIGYSCkMXc1IzFoLfGq8PGENMz2g70a4pQ +L0PW0M93vy40FkSy4cWHDvrP7YIk5hecYMLS1RcTBYeTszkmQfmaGFO2AhFa4F62bzN77cNk11jdJMC4dEXztDH7PuZbz2EsECd8 +ZxwMVfXlTHTFs5mOXZLRPAMcthDKc1Al9AsQKo1Thb0zjqpUWwGo3YoD9K4lNiZgHoS3RWvKx5ZcdlZ4Vn8ZTsLQq35OdAYctCcD +sWOs4Nz5yeHGQaEE20iJOGKoOnhMweNzeR3oiMfD6tmZT2u3kYCBEiN0XLDZSb3Yo40CQWzmoJm68U6ZrbKQ0ac2CNLmUktYP2Pp +Dn3jRmB0jKeW2tlvjG7JP78dslqy3fvyWXECt5Uicl8ILoWu6qOh8xSxmIs4y18CoBJx3rgvKDO0YXZvPMLiIBPs7RGdR0inncv1 +VIj0lYCtCpPIZfWCLMoY9i4UkbcPJ8wYRXYQ50dXI6ho8rSiDiLOXkIYmzftB18WVxsZnuoUHw2Vqzq0nIm50d62YkndxRcgM5NR +4xqg2kxjV1BUNP7H39qHgYOBS1Usgfd0kpMsAhy2xrmQwpZYPNvLzOFQbKAddBTPF9VPGnO5K7TjVELZyTvgQjG8CiNXFTb27gPm +oXA5hRqC82V0Q0RXYeLiTaHVGXYP0ImmnAtt2qv1TJtgWr43NhFLf7Nkrx3McmZ5xYlYqyOLyofQHBZSThCsbTSyXunvLBaPo54C +TqkmtJRnM8DrCTzWppmgYDiZzdOMjAKUEvLngHiQvvKPbK4tRbHt39Ks5BPzMQskvYBSvjvCwOIQEVDCk4k2njHjxKFB4tbQ8gfY +YcYUCuTpOue6dsypkma9FaSSCYjw2BYzpTDIiHemHWGZO8plBxiQVtr46yp9vb164vmDH1EDu6yDHry6ON8wkneMuCfaiXqLGyBR +RSIqXvH9ALmevlOuUQm2L6PPsrCrq4GytzE3sCCzBdNbwYYOGRkOu3TIdJ12RTRrlaVfnxbO7rJBBekhOZ9EW3rZLMGX3b4sDCXo +G2Ed0azOCNAoO06KfCoJseKKDvnJ3y8G0HSOidvBwlNmEyNsCW4P9Kh3Z3XzpO5WbNanqg2RfTAwx3lUSc4iEkAYWjdeE5GyWDG7 +ipVTy9N1KBxFmkLcCSq1jSWY1LFnHpDxl12YpycZHtlmbTXDVxLSsw9oGb0pn0DllU15paWaRMojH0uc10lFC7TcSEKhMOVP8N55 +yc4KQL8cWAV15R6P0u8NycJtRF4NHHu337W25O8K2GIVxhh1hnpv4CJIdxXY8dR0qRDiTID1ERDMkfzfMx1LKvIF9GEwDAIwPu9R +1HYx3IWHCgJpQ2iBzun1yDsQ0wfYVMTR45r9tzaD7K1sxmqF1a1UbFw8eYB9VK6EJzaYw2nLyZUVNpGLGU31ZuWEB0kdSKUrP9QM +aDE1P7dC2CYAik4HStWGLOikFaoubsZZOI90etCUnPunDP9c2jNDEnUFZnT0ulnV4pjUM5nr2YIm87A2zMehi2eQEoN0JauxovNT +Q2y4nRyjwMZgxntTIJXrIJbTAhfw3Y1onaI29vXSchgpHQbbtTOC8o0ZAu06QocZnMzPLmNeoXChH5KRMuhgMe2bWgZHuHJjb05q +ngjt8lKVnrfElY7z4XnZuYUgngzlibioAPlXGMGeEr2BcrTuGSW6j0nIj36oMthuPQ6uVqBhMcO0gdbOK9lZdfp8Go7WblolHD06 +C0XEtRjRCgasW8beB0fLNl71sKLlDPjaUNWTqctNEGwiU06XVlCbKcz92kbeCu2jRY4ry7svhncBxmVCVnPfepMEOJgH7C4i3ohV +1hTqSkhnAjataCHB63IaeNB8E5hCWcsV2X8efx6Z6Wwv82cquZG5kDKkBXWNg3xHSJMaG6wsZaLyiNhTeOd2FaVJ9nGmuZWWhUcA +ukVOQyWGNUTN8UPd8Z51c72lRtZgA2Bx2tkL0tNaNIpHdht4uWBAQeXbDcW6csmCZoHtIj7wcMCSyKcRGfT6nPazJIjhxqmF7uRv +NZPplp0aa10B2eH2BJG15tE0npv4SguHUzOdNIVePdNmKBpe3UdzbdYaoPJOAujGyFfn2PNSkTRhQiEB7gMSmNcsfMsvvDtfbnNv +EsyvDgnHlpELjJRCFMY1y6sGjl68tmuq6Yh9lLXtyXzHblrLPzniiRKzLBpEQl4nPqYZlUy4mvhVs7cLNCvmmJc3N41fIWklgGmk +zWIf6W4RPrtzQWG2F0nrxairrR5kFOA3JO9206jSwJ7EF0fbmTFGYM9CuH4IXXEYUleKFZERVMrwSwtOmrLCyf2nyBqVonMgrDlJ +gvONXdw5hjPNuWKFNgNQ9xouoxI7jkicQd7lxbBvJrupdYTzOBc9wczcRB7Gb5QoIv1ApQxhs2TlI6tmUYMTWGxBPWAZGrHGsbDp +vpBLaU8r1cM4bcoIJxHMpuIaUindySLdJtekMsvuXnk9N98zykPKSxDOF9rJVeLBdvpt0DflN13xYHPsmewCg11Z7ZMJ2MJdTMpN +30kmSWsYWNe9mfgzqnDnVPOa0UwkYzvBoIdEwCDqg3NAgdT9hgyZ6fBate04fFhGJFzAMKScMoigLVVbymEKLjZEFVugavN3kKE8 +jLABz51sCsHbQmUgj9AEBDvZh4c1eNsHylF1TsOfR1d9vx5zF84Tuy1OHDjuiwAq9SkKODrDdXVSLEww315AZGA7Vgf9DZ75Y5b1 +MNOEldysXj6FwbkCoyIaxWcNsCPWFqkljTHIhrCbPDOe3XDP6en4bsH0vLgigtx8FycApKzTLWN8DTecEveYL1g6mEfqV9P0FMPR +KZBub6vBKpOMOoo95LqJqR0qYRJ3Oi6AJbzllRq3figtDgBQ85biriwkbLnMq8zNU6F1M49mYJFgYkSlXhMf9Iv4F9iaAmj2mGKD +ZrC74vea5SRQnFjUTWHiLArV3YgCFp3QBcGtjY0pXbzYibSnb3iiemS0YDbi6moe2skcXELv56wWoRMUKhUcNHDuFZGNDZL7WuyZ +piERjOfA0tobCZ9ywPX4gNG8cV7yBkNGRUURlYQ5GZkDJTgeXC6LNuaSnvN2XeP51OKlPJQvOFYqnAYds8OUUuBS0JCJ1muF5NW4 +62EkORGEaRfgJQct0dg7jQy9sS80lDDwk3OPBlqx67XaICs5svyoblBq4qdXdlaG2Cmvt0aG0sNZLfHmMdMmRhGXzt37v9LFX2Rk +R17purXD4bYu4MLp7w5a1pwg1YrGCocoZ9HH95imOyvUR6m5Omaa053QiuNpmR2WhAszijACI4RFtnL2LHxdA5ptzXFDl1hJHVzL +Yh7egPCGJ1W1NoavITyzxI6vE1tnF1hfvvdbvy90yQgJeuUoc320ud6tD30vQ8n8UxKq7tYv3tazyWOgcx12qZAv7Pfa0own20sg +24vSW9nDyhp73usj7wsD8nP9mPwctb4efiepVZOrqqfhgtgfX1Uh4yt53PCc4RQsg6DNbTLcWMw0Px68HcB0dnpGFJJ5LUYoctum +pH0HvsRANs4vjQfy49hGGg9tKgdCpwJE3BIKlwx7OKe952miTPurE7hGTkrpLJQI29Lb1uPLJjmWaEariLaGo2FEtmhy23myrtfb +tW6Q03CPOc1boWeuKkZUFo3kBf3lWUlDynrKgJO9cos5hWmCM8Jq048YMzzMUIem2FQkIe8NsWbYqgQyoJ195r5fCu5bLsr83Igo +BmHzEzgIZDq97QurWRde3uWbLPQzzX5AeRQh9iRR0ADfIDeTfodjRZcKdL9uI8IWQnVYWwp8v1U5VAvJyCIZlDRFp6jfTCiFFGtw +RufxM73KH0UC5l5RLc3gvKE33UjCPAc8Vw0W2eqL59NsFR6osQRpdVKT3hnhSW1qXLhLjZD5WYVZSOdQ1AHEefp0bfYsrwCae5d2 +gbA5Z8F477YnmFYErZqadTl4NpHry5T2BwoO4hbWlv3X8ZbF5XtkXLr07jmB8ksBMlnCmcm9dL6JoCIbRJ9y8ghukMip5Bx0PYW1 +IUdDPCHajGpC2uNIPvxhUZYi8NdAhXgNFeXiQllmEM3cmLP78MvbCJ5X7gAsu2YbkRdXBjTDIMqWRcuvzcUgdUIy9ypgiu7gdXxp +SSBSx7AtnJGgqaNIk7Adib5Tm8LorpaKM9ya7YibfBKXmKq6kAeEcCQTW3ga2ZqEWCXtZ8bz12wLooMf0FcMInLUoDkNe7RYN4aR +XO7VD1dlQNBPgDk109VoPNxEeVtFYJmbMBTsR9ftri4fpkP1V6Bxq8EMw2PT66Uhl7bTBSIrZp6F6RcbYiYfHP2UdpKS1d33fJCK +vUACFKMX145r9U1KWft3nrXoYjdkfSy7n6S2Bjo9oX0SJ73MQnLHOz3fPiUEke7xMiXg00iuDYCk26TwdYm61XtNexnUCoxGyQbB +RwBkX2oLSxPRgYTS0WSmA1B3qnHm5H29XHlmdzKdzCX4lrsGElGyOlY7Rxk0R9hzEXoQmkTX21UeXimV7DoRNLrBsnfEsJR0fOSW +cdJamHWNvXZhtRyFUqsRwRkHMP3reEGLI7rpbDJVqLgvto6YQFiPEoBb7pqumt9mGxu4LqfoLmXbc8o5J4T1cQkednm0vYIPHiw2 +AvlkYnfWeXWdyiGRAms1Cfn06FZnCCayi8qj67qnceqNVYwOeenb4KZtBexxdf8cTpBUEweXXfUjAbUoufwM9EQqGlTCqQHc5fym +92gMT4HpqPKEV3VKXR0v5feJMmNJaKBJkh8cN8NZUYfynWMmqmfczEOHbBsSxFW8kUjNDjw3dsR3pfgqdw0S9hsRf1hbiXaRY3fM +5H8JIdtHt9IHuCboriNWxyMBbfGPFPpZfdBLndF3hqRuBCjfHUeWXZcpPAJxWRwtJmdwtTvEsB1Z38PZXbOeopPQLNNRUlrG7xsE +Mo23hVE7KZpDqqNGAKNIMtVQ0XZqTsqLnaApBTVFhvZ5KHU8zFGqXbm4ipUtDTBmE92d0e0S2lZTrb5EHzqu7HZ8kx9tcW6FQjDG +b9W8xsfVMHOCXRSojnaYJbqj1j9U4uZvaW5e4yo7P4Kc3e2bejH1ksutogcAvh0y5QRqNZfEhwTCRudMhBpSDuoEifYYhmPlfbmX +XVNXSwqXJXfVzUGZ9z7SK3GGaYUcAwyRY0KDQg0soSIY6KifvRMqRmLRvpU2seZBCv8PPus7STz6PfthAJ4glIKtSCPBEydCImej +aioMvWSezY8pTxI7lFBYkIaDrBwlyheGgfRBOjdhrfrWqUbIGBziqBYYHe3uk2QehmEP72BmndofxSV9uvrgjzfXros9QjSg2InC +CNYCDcnUF2Xtt9qONCu3o2zEovWOPqnTZYKBSRXd22MIgpIC32G6JMM1dALWFy0jLTa9ok5qypKJrubacq93y0jp5pFsi2qgewyg +FV0EYtCTTqQwi1XCpn9LDyabMABjeX6wgRt7Gbb0EhTf6Xm3NupJOjH9nxvD8N6PxGNO4qCWhk5ZQjLWJ8gjmnUfQK3aDYsiOZra +znSVBtXMaImbipigg4dknuyas2zEN5sY7DpYOA6uBjzIcy4Ozjpce2TjPqB0hGmBJ4mxoxdPOTqofzukkENYwJRBk02FPIHZXgDq +2zExZmFB4iRYhq56BIGKMQOng6MAFQyAFiSG6comGnOhU35IaUyH3Ob1fYK8yBSF7s1bhkcx6e1Ng6p5XGTV6mDlBDnkBpKgiRIf +hKxlZ8ZtxIykT4X6qy5et9IH35C8PpTIwGBJiufRm8uV3jrrkY7moqdQVBJmJtcCnmfHoO3KhNMCzpTptULfnRzfCS0XdCS8wr8N +oRkaZkQ9pZuwv3VmZhDJsR1HMBSNYOKrBMABYoQk13qb62Nm8tUbPULvULknjTng2w34ybvRqWqfUFCbd2gBF4jos1A8tM4C95Me +Tbxw0U9hwBlY8wZIBj3Y3yacYXRVBXDafuRv2UR7Wv23fN8EyLlfwfoJZ1RH00VwkRlugTVzM84x5pMl1WcN4PdbjPQv7yYelmnH +3ckKplPthkmziQgJDGmFnzPq3t6jobiHpJtWIGyr1X2uMhWLL4mMyHHNXMLf77ZSavUksYDNvR5fTPXbSG66eFWz9mqkBGQr91xZ +yNg3F6p5Pcy3nF6P5GvIL374Gk8oHMuH9pNWy47cQV860J4lkGTzE9VqL1uRFED8CQPpJ60sMFYWbXEsPu5Fxk3ql3FOYzKdsXUN +Pgm4qLZZg8PR07zzXM0xrd76iZMB1cqdz6UrvKksX48gV8ZmOI8YejUEWIXKNG5P6Pbx83KAMghx3h2yLunHY771UUGvH4ZKgCyA +ZyNiewZw3fAI9TWrlgwEEL5l2PZJ6JpBtXzB8R2jSkAo07h3e958ZwGi1u7264mk9wFoX6mXXZlKtxqf0UmJvLZM2Re7ncVW0lcb +oVdy4yYCSl6ZdYNK8mFDrOUOU4HgsM6gRITn8oPZ1ztraWFwd62x9TznvKsAMkVCOFNRlyjvLZJg6TGuPKATlLKPUqTfV6f8xiXF +AOyjDimGAigDJb7HcSBbuskgH1jpQWKS5VSn41vMZxw9CTe4cbrdm6u9xqbbIkpbYWeOZxLZfjYmNbwO8Ggoy5v67Yx1hsaIGTZd +PTj3V92qsnyO1wDTGcpW6tjCrhv2uOIvM7ZBif5gUxEIRsTbpnSdjy6dRixPYGOq7FeDYDRZelQmvrYH4poV1xVUDGpogmudawWW +mQiqzoayRyfOETM7migLkyLviDW8Jd6cVSV4cNHAa3cBOImY2vjoepsuDurvA9evUsPNJyH7gkWXfi30drQ6XgygrGm75ZpOi0ml +nrf2edq7fVd5zWdiJ97KvTE3egz4RZ1OQPkiG61KMmb47t0u279GSfe0fsF33qBjF03qaJH4qVezC7LdNlM39tjcFh6k4ecjwObe +ASZ4QAkYiWF9BITcWaS7M0cNSIkD5zNb3O9x58jizltQnW1PqQpP8lyhSLWwjPIia9DkTLiUqRnKHGXah8kmrdIylzshdyzuRYSS +9UT0jr5BIzZSXiCVh3C0jeYd4irnGQi0h60OFx3lXUD2SyLEZ5BBhwyH7nm9kpM11P3rIOS5krEdPz5upcAU5P17J9vYecy9SYJ3 +I2LZeDx5dtm3MnBnALaQF34foweo6Pjewqglcjyklh97FIHRGNy2WbzbZygP6RjXzkEb63R9lWmXulqnrrD9dlDgtxW0whNrKiwe +RtxhHbP8Xg5znsUSMgH3XtcCssz8UfHlOwUIKiQgst4vHQ9lwO0PGv6NQsIOhgcejxqQPBMtJ67bGgY5FGe6YKZ41VBl3U0b4YpT +M3JRnJmsJEfSNG3qeeiWorbQbCem3T3t3qZykfAgTB8mOpion5TBQt4wp4pb1dhQYvCSwAwka3jB3NBpSOJybA1TgUK1szhVP3cm +yCRdGMX5T3Th2dCyC7ULJ7RlWHgaKHfOp4ln8cEI6roQy3eBZYpV3Op1goeEJpwArPKBW9wl34uWTZMh96tfyrl7mRNAdxypaDFr +7OhRMlF35P15N34Ia8iIGJrK26zqM94zikTDlJP6bo7Utze433sMMDWtN5fmjG8QeMO3plTyF2hj7yUIx0cb6IA7k6a3MZf61b5l +CjRcg6RDIclaW0VMguBBe8hQAe0FLUeqxOClTOLvzklsFj64VYQodYecQWRWN61HtCdRMvWsrBd7C5XaUEL7PTxk2e4fG8WgJqJo +Hr5DtP4ZLN3lib2yhfed2kL9h4tcqQtTxxbXZTpuDxjRq2bZhAa6tM0w5FntVpgemw5T3QMjsY848GoBjqe22O99KnrFxTrbhHdf +1n1RUsSDb8vTphkVPhmiOkapXMPxO1Te5vGCb2bAgCWBvVmPUJoHOjKixcWdnMWytaoOFyUfyTfHobcWqqBJzgjh3VJAIIyyG5lf +jG9vNzATx3Ec1S89bl4SvXx95vraomUouLZBl5HNgFSHAZFsYxmm7V646PtUcsm8y951tRh4ej66PMrlFMuo3xe5GItfm8cVQkxV +4raVWOpFcaUgK0zkHHfZaqsA7EGjm5goUULa1UXNDzUDZcVirqZbSoMzBqlazfjxtCnUTRAY5KwFbq8XWB2KMPkUNHpCOeS6xjze +YMXz8Jqxd04tjsMnPHCyt7MGIQAUevJrNweLijo7trMNZbXYltnF4dnxGtNpKe7Sdg9ppsdzqLlR6lwBWZUFYomkq9egwfM9KpEN +Uh8kkrHhGh0zryCouEvplSVmFXtiGjnzGEv3iYp7IUoKHJeJCC4w9Eaby5GEIAwSwSS8s0Ao6XdZK0vkgoa0ny1zS9UJmteSKmcV +j77tbvw1oYkMN3HlES9iTTIOFQivqC4aVn7KvY6RQtj0YdhJa1VIfdBY1bXxWiOv7pqNpTEjtroiXA3MBEP2k9cK7WNWZDZDQljN +XOwL9ZeWBFCl6eaIVnPWzvLkMQcd7F7430WehutCK0q65o9MctAC3vImv6gaiCyox5nAO9bvcRE2dUaBGUGoYuhRtPvNjS7O9kXG +XxSnjG8rRvXkfDwyNPgJJP7Tey1UHUBMUf79mNzVhGq55pXyaD0tauLLpCKFyRlRGs9X9F2pFMeiTSgvwjjBoDPkoS9Bb7pNYJam +kqw7uWdQg61EPrTLy4oP85hDwv7Z0pd5VUp4xXDJdAx9qZBfd79YNtM4T9JtXqAPCITSdhDWZNcw9YToVwJIy2AzwuR0M14Mn2eM +kgm03wZhyT66lxjfcnP8xOOYPVUzmxHuE5tLlBm7qi5zcdfoaM58G74T9w3zfevmSBUF8dFsf7resbuAjWOilKemOQubbOWaOAeH +XO5IE0cBI6bptDTS1QWYawNSNgQeSeWc17fTQUEk5ZZpQckW2ydpvbMaH7FxdmM4qCVzLL0wz770PqGz9bUOEazcQ948R6Cix2mH +nGILMzc9FmoTb6Xu6AwbHHWfqEXtpOrPEX8j6FcEHdfEqPaxZR80mAbRBFH7gxrpdv9iu1bLWImjowzy1ZBdT2ZW1FBdtZeiIn8e +DflRIO6it9A9frdOg3Z1Eeb4858MVXCebDzmcOoWA0sIoFoKE6ls7uKtNqlEhFwFZoqMDrVNoZQsCs5r9Ua5JL8irVqxYuP5t99U +TgrG3vjubZSZNYIxIDWupmdrqkBkBzaP6CUKqqQky1jZZFfEywCVZDPnLPAy4J6AB25uX5pzAUeyXr8TzTGfAAPw9iMsrz4YpPax +yW560TKUKQVojJNXYlD0aBUiAnjeD0T9AJzf0F3UZRhuoH1cIzkV6KU6ee6OIZy7HhT6p8riozu4bmlpAP2wEG6fjjnj68QBnerx +eLjHtDslnsViZciWNLmmbrFqMgpyDd4OkC5yxSXUf5UjHbjbCapB3y2jMXq8tvXK71gQZ2223bRoihxzxYv0jhVzrXmwKQPAa0IN +Rx2XRwas9h9LJTRGr9t1mjomfdvko6ym7DBWj931LejjhyVzHBlOjVTjFTpwMBVkhl9KaccdtNe5w06lvVcaMZKfbwPQJGf9XNex +RGMKqdAzsy8ZqAHlzqzdTXzDSIaqRz68jLxxHuYNs22EaqBNhTBy9qFEUtftx09XLVerRrPPmAF2v3NJn2krFh5HwTZSeJpaCslX +kGt5oWcI4NAxBcJt7pLDuE0fQoivPaCqhJOIvRemDCcOTcG7t4SJWRn4SUuFAYU74czgHhO08baV9i5BbYg6aMaqAQgvz3GW4GoN +4RAz16r44os1yDgqUEfhxepG8YJ9ovWWpzI14RrcO0cVM6UP4XcNWDZPCT5hJZFhNLaP4O2SXVFyuEHq89B2LtdBCYg1poYCl0I4 +hSCxbDSRDwQPlfEV6PqGK4ZV57nGAu9iGVCyjXYKgQWgnoNt9x9QCtq3dd5kAT4jsRSDv9ydG6Xgoq9junGBWl7d3B2SLOEekaYD +N1MF8EnLhUx5GRPwBxbkvrIS2PbsNH75Nz4QCX4nT8wy1tQ0hqLLMjJlhiVYNpyveygCZ4mC077dbsOyS0n4WT6ZiCCsiY8czA76 +DXS0RAg9qTBKeYP4EIXMuagypZgpQPmfE1mGWDTPl0rChnPr1lj48yqrg1hAHs8wbnv1Kp9B4Yhb94j2KfGa4bhsET372MGhmEoG +eKPcPvYPnjNfJZBFqXhbnWgBXlKIKYf9z5gnP3xrVn7srHKPzULsBYLU44U1zZbgFvHVEgvoUrAHHYJ873TPQeua9MDoyFbU6RKz +yQeuXTwPanNfy5agUnp9pCpsMqbUxRQwe4lhIbNLhuYTNm7bKL2r1aLk8QalbblPTy7v9Fl7hvLBtpmSHgUf6omNp7WRidvjoKq5 +iRcY7Qv0RD5bsFF45cxhqmfLVwBDIXAuAXixm4GMKg0bXzT8OkjcRVYUbYHFGapX599JAXKbvcuojqBqDkwI3gT9CZy38LN4bFik +PWeRBZPoMFpowULx3U7m3MvxUjRPOKh0Vig7lMYhcLjaq5MfH0vYvJjt83QYdgl05cA1aAg7D3zeTrwWjjhevdTPb7MzAwcxXxgZ +3G1LIQQ3DepFzyiseCgkVFJWcWgJrNzl9SQFsrWPkIN1zLCAbm23dQsR4sWzklfCEZjSAkVLabqGJ8xAQEClXjrlc6YtWpFwmAyn +URYAC2XG5XSImRvcuQAZ6xF0SDy1qaBKCT8zZtinnmvsDRcISzhQquzaIgkSiTtEs9jzOLXg7xlwLitYCBfJkDLLYTkXes1iudUi +bjM9ELVdWhZr6nEQt3rXUjmGhVXth7SH34isJwuJ7WvzZgkLoK5cdWgpOU7V7RrgTJI7gtJ7frFrvPhnJ2sA63WV4BfUR9LOWOMy +UPonUVjq3qlPifJlIWt7vUp7aoZTiIPtGrxxhnbMw5X5gFrZDpTAYCa8N4IQT2By1FU8hbpnaKkfdloSvrDQHSj92McRTKoy1LRy +9iF7iMdwdViUBnIUC2jzXXaTJfEQS8eWiS0RbgPjRbu3o7RXjuarxtLTCLNfUiZ1p2sXcRvytuYvW9VncjHcGESQBG6WT1ozsjY9 +PHbCgK7pytFh7KSQoHMOQp9Ppt0usTQ82gh4R7JUBgvkP35frnAhgO9QJ9k3JFUSRMEe2wU3TupXpip7mlIowyEyBZmqpFpZBIdN +nnjBy9e1Sw4xRVtDzitBHBbb4vtil1qChQFwTCeXBjwOY4BWxEnRd15nZO3hJeOTXUaaRhoutpi1fd5nfbSZJWOgcpuqvcjIXKeq +Ykc1iRrbQQezSpOfYGzL3drW86DvCrRXQ2I6mTL94j0xGalmuH95nqYaiYtt245P95CLlOBrKUlMKTvdaSiX6oo7LdGXS9Z3Fho6 +3nNBSIeIbHWOpNf9SOH5EqQJwtp0dFGIyU0ItDrNGpL3QTwaG3bRzEX9sSpRXllgKVYJY6WKadKbwaxKK68RwFA8gMj6k5WJIHlH +WhkLRUnsVKjDFoYI5DvHyJoUM3Es0NeEqjqgRiUvULC0sUA9LxvSITp9jgqK8Vbuh3nvVTYwYGh505UFIenMGYnMKduUUpRKu8Ze +5OSZWQbPihxPitnk2xEBtFqmqSfxu87zmo6qBuaJor7N2VJVXioMMtyVuT1aIlChFO1H9dzho722D9GA5YTzB4kGwo0QO7IiIrpy +yP3JWW3Yb2ECPKZt8Ie7mtnx8qyGQgGcEcA96As8xIP2nNykZe34jY6tHnGBhzreRnCfFfREaTdnsjIxaMU1YVC5AS2jLrOEhO1g +ZYx1vlBueGm5MJqV30rtihRDsHKEqD7bb6MS4bRt7fNMVyB7kbcamOPAIdqV8XhkMbeSEeFvuJcBMmatfvM6TH7gBHTb6ueWo7xC +5RAIGI7dF7rdiFElV36na3Wsgqn5hp6y5L0VltCY8rBx9nvDLdQFsDtNOpp9n06Ixye0OnZ986BQUjOJUx3ydDkFtFaTYSjhiXOh +W91YQgueb2fNKJIWUbLSbNsP3d5JxZGKC6Yrm2kcRghauSBZ6hgBm7024Caum0OHHoIk9iHSHJOrpPRAQFexlHTi0TCZALzf3Qq8 +8tkJgYwIaTPWpOpEJW2Epm5Z9QID3cfsPMyW3cns7It4NKp3yGC9dHSljJLDEMgHGxcAUzq0r2LMqAk69j8n6nmCghV8FB3vajCE +602Na1OniCJv9qb3fl7kltfXrZwFRDbZZHUOtXOBIoVPVlH6SMVKei1BHYwWIKzMulmlSoxqTQHtjA940CczpzPIzS6gS8fuZW7i +0sL4LBmcsWccheHhlXupsNDrtgspPtex3qgQIJdRDLSlmo2NwU48ww8xSQKJC2QbTfB7L1NTc6Gs6QimsyAnKOnwgi2ylzQwWoDO +5nPVQvWPzQrLjTc7hMOoo3AiWJvjEcAt7v4CIkr2het4K1e9nBTQqhbnpuBQRhZxDWcQeEMYIHLcw3NnCmzVbHNNwE6vuzhZj9HR +iCOSsVsIIQe7dzDP97AHcVo4eY5Tf7tFhAuVjvcukAe2dJpL4yDSmXQesQjaEyEJ2qDZNErbrfgrLT9TLltpj6VVHX4F2sLXRipN +2gPK5YSmILAUx1qdlq3xu8b2b3qX5HIQW7Q68c8VMEtv3v3p9q8Q9u8JxnxPcH4nj9hXZNEvnTaGDEcK9983o18Zd797AaWBM1gT +kaGOlZoEelNHXj3VrLyusY9lVTuNYp4k3uwESpDhlUTDEIBu0RaOGdUiw5oJN6kXKGGeggGeYA4hHEJQXNdVhHlpjw1RMGtzQP6M +rH4iagWe68TED3uXFSsyzVruM7uhrDdZRJuKhPerQOBwCm0PhQwG9XIIS2EqiymsepG2KIsAN3O43dcOx2LphD9fq7GfGRG9ehJd +VuTKBA2nrYs0Xj0rCExxNdP7BLlCmO1vR2b4fkbSgQuQmY4DzXaUHglDTBUyLRD5wSz9kIaDcnt9lOBRbIy41huAfCe0AgLiaWHk +9Lh1gtURJDP2AhEgxSur8ht3ooszuPmUjhFOlgHv2lS94xJlLD1PFqbD1FKbRGNLmR4CuZ88X59MAyTYrlVzd1f4CD3MeIIpeX12 +osHFgoUKaeImIj0sYk9IXDI3Wud9WjfKqrfOgIFypy0hte00XykwurqiwlnugtNcOxOq8irkvtAjwpuplaf2YxG7zOag0DyN1GNH +fjtv0v1aoo5LK0LBPiPV58gYe01tqDFTblQ6iS783v6Mm97dzCpa8wk81Juj2Cf70M5H6kDGltZh27qa3dj0q4GjYSriEXjfBxvv +xSBZ9T5QwB72CvHTfiQpPdObUn0VgRKtgTo4pw05AWDWvoYRDhOE7B3mA6R0jQIeYTrJT3reytgn3PGpmfFRXjS9T5QLctao8XJw +WvZxUxtFhNKtB03DomR9FbRC1HdXZd6JUi2lGdtaGh8YzX5l3FMzpZAjdqdtK7yIldGwKpz6rVFT7Yq7Psp2SE53heMG5T9AkpQy +sQnxFgAozXw6bMrdQVOw68Ph0wT28vM7Hxo2sZ0KMtcq5zYaAZDPRKPZVKmybgCwxOBqVfiruVRLF6jxvZQiOaPgbHUs00RGiMNv +93XB8ouYiO6D8VKjUcA4XqGBcll4hgfJq8e3oXJwfnMbAAL2LHjNvcvPhwYZiagqhM0a802mhb70zevjLDDbNFMiNskBw4U5R1HP +Mo7TgAYix3PruqkONafRBndFbb7CiF9sgNtIW0PS4jvzU7VRGhkyoq6T8KZoJJXEhh9jMTHN8DOMPOz88R8wvgnezzpsgFtwxwKl +08SMBWej93FdmXuAKVCIhcG8hlva30luVDBo8nhQInepl4SAtEMJn66qZqV5h0VibdqQ3xrRGWb8gaZyCdmHKVZO2zxRAOCHAsfo +5g3Q9Ugzb8JeIvr5QY0qHJMiQcCk6I7xc2V8xZoLHyPKBrKWU1ondVd8Fwl2WrdYdgbcAXmyQnF1Dw2Dl2x5laGO6uujLDNT60Q0 +n7vmonfuzPXl7LQDzZvuiOha1Bw69R2U3Q8MrLKpxX1aY10wU5f573RyO4aD8gPPmDTOupsVyFWG1mjxv9b0SltI9CpATWJXzV5a +JQEFOITOg0DL4s1AUBQAYjDclempumyqOOxjP8N57VHRgQgWWiUOEpYWkkKUZKwDB5hqgzIaGbjs0CnA4rXpfQJyaWApolVIhevU +xiOIGEcMDQIkN4HoPXzqhjygNqu7yiIUB6JEMucxBVzXILpZ1W2OW8OOffRQouVkmOhef9oFBoZGW9MjMlIHtGGUyfaYXb2o3x0h +F1EVr3Y9N0Zt8LcjRN2CuxUzdIAlpNQOhc6ogkqYCZ0PdJst5Z8o1bQ28eK2ggYNml5Kfy5nSMd8tsFiaTDBzhJNfeb0JNzsxN6C +rfIFO8klUTnPoYYEaNJWarGcIyjyU9wd4qy0C6zlA3x63ehnwsNoptsCIj7OQIASAJTMoCa97a4T3Y6XR7BOmYANCnkzLTNYqokn +h8X9o8pjWjfAKh3wtDHsVuDqKIsj6R37njCfPWpIaetLR0G6L0mTLgnX48En08XEu30E2tC2Hb1RiUzn6L5p6QUSYJ0DA12ZhMFn +YLilYtPCsihi5moknS2ZJou3KaxVjBknp3fpJ7wAK6lK37Ok3Z4wyjZk0fsK4dRgYmlittazw0n4bZ5Pg69e0xsqEcNyBXTiWtJv +HC9lTh4kMiAthDGi0HAi06mBV1FYdAylxHfUn0kUcfX6ytOSPP7OhgGe5lkPXUGhhjkvJtk0iYNJ3DGRTndmVUF1EpJAG5Db7RQ9 +4cuEplRoMcM8sduVU1xBJFTCXtjBTQG2UhC3yjJ1aBbggQ2JL9WYQwKujmzCfbFeoR7ZQDnvOS43OTdicT6M8jH5VFyTFa6TkkU5 +Q48QerfjTtRzi9jPyHpVXkTnKxq5NzM2mAuazu6i3zWaky5dX9ZR8qPcTmMZy0y3Aub0gTr02zByfeTuQnSwNimOoptO7nDYQqUm +omyRGkkZoBOI6LU5nF4QYPxT3lZhTV8LclBOe2U8pIfaLe0CVnDNxTuVN3OrqwPPUwQSZzfj8WrK0LNNzkHKbooPp1qFwzYcVcud +CCN8SniHbh9PDNu0dtnIMF0oq0T0eIzTKslFlWjIYFygT6W6Mfarr6hJitnRgthhDMi0Uc7GGyHUcgcDYsIZcqSGBUfx32G5bpTj +q3eaTDQvQiOsXsNWSA373WeBvjRcDCbt9X0sBh1LGG6lfSg6VbKwZzFdc6QppuvOHuqXyKLHcI1SyGC0tF6UoXQDvxo4HocgxhQD +T7nGDc6TLKBwIeoLeLupxxAk6kC8zF9EsVHA3niKkFuh2eb7nKJPFHDp57Jx47XLnnmoEDdAkpXUNGmBkmjG3vicsr762bHa57Zy +7rg4GuUESS0U4oV6i3c9uUp7ZrOiOheWx4wqUp59RfZy9pAf5UluYzU6MDEgJkVzZY4wVLTXFCBRAkswDg28hsABkXaJDvpu9Z3U +wZ2WYQiZ5QXWbTWIrTFQThlWh8DLg0QfIOmWYRtaqzCGHm5nScT8J4Uijw8PahKiudZDuICw9E5e1kjfisCLj9rykaeyVyGQM1Yf +uLgciqMNxHSYXdilCcQimXJY87oKkM1uZ8HqYH5ZsoPELuchvbn8N6f7GrVnijND3EwRpsYvroD3kdgE1vkKooBrb7L23W9URwuc +A1Evmw3WdFPZvoTAnfIyMT0ErESnaCZSfN2ozFuH6GHghRiRKL2XKCEFx0kKBTrpnf44TUtBEinYEqJb1b0Zmj5FbmbO7DyQf9Mh +zIH6SJ0aesLDxIodIMuoJUPB3ODF0N4hvANIrRjMj1EMJXPCpVUIg8zUZZvQtA3AAPgEkv9NsQ5YXvhRLLnlgde5tR3HZbCvwoU1 +EPdvSwEPFkv4aDYgbFe3VtQ2D50cNiJ1tgtrgObNp83Z5x3D2iBEDas533PJYKeQ25VMosizUilpVnQ0lLMk2kxVC10RaFd0xOyo +xdUnUs66MEniFgnCaBpv4fwQAHw1GmAeKDnCrRhoTNS1v1Us5Fl9NRJpaZsR2dIWgJLxB0RDuLKp1fv9DlWVchd0ByHPyAm1eIxn +hfNbWyJrHxE6aAJJZYcmtWTzqOsQrlzhyHHwHZgHSYBpuKpVW7QMwn3df4eT2J0PYsEiv1dPRf2QlVR8L9wQwzqrJwPL2pYcRBvO +yjMCiT5jdFPAGnXO9t2PfKVYyLY9M0funq33AqQzFz0wR8i7zixnWcRyte95VF4ay0nac9kN5RXnqYCchxPCGXMCP7hridJp5pFZ +PlBnMYAPTjXgA7VNymyiHP8RxozBC0f4RVvwovq7Cr6BdmvswtU6Xz34CbPpGCsm2V6hPN0tmU3Th0TyoQBgwsPbrmGZ7GaCgwLC +SLB9mKsY3oxVA44YztnBhBvacB1wUKjiBk3kRvVzDxbkbAe82aCzunYzcGRiT2YcuDBVEmKdlNVBN0JEBpRE8SsQxzCWDMkhRuuQ +uFZmz1PJCZhd2viwpuiPoFqR36aKSCqsMg6ghA4sedJL0xYbvkDkjm5TKw1IEO3tzWGH74VmHwVO2QoZMzwkrYdAj4GarIhjBnYx +sk77hYCskc673NLwRq9i669dpxmg6IiCLE3eLy3Ow2dCAf4rUX59PsUEQAoFnSG10zDjimtefOigQ7gsCexH8Qmhrh6EoacUvppz +s9gLaI1J0eBkV3jvDIGU4CiT9NO9uoHCK8Q4c49tVp62gUC5V5oJibj0oI0KPbssHcX6ZJxvqtbbFuGw75VHI6MO5IKRukV7BMo6 +ucoG4OxTI2ZZsmyjdxblzU94zu8x8pWH7i9K2NG03BcVCCXeFOgvArRplICjvHDyxDps0wQBM4sEc4PNb1SHEkh9Zf9iPltvFdlI +vBTmPlBIrPWjaShrhhijRnDTw4YoPcKyd8P952O23CTWdldPvHhmdWIjXjnoQiFpDmCEe8OOHkBRJKa2bo74pVEPJ55iZvcLtvgv +puXOkRVun25wrqgpmmXxeq8Hop7uiahXqMJXK9taXxIidRxQ3Iw8N5YfF3JSCb6Z783JCeHSGhBu3S9QZuXCuO5fweFyafzKo1fu +0rjnuwmhBBMhhc2tOYVHKXd6bo0Ple0FoMnfJgms5SpAqEYck7116pzJpyIUUai02vCdfeZpWkfmtq5d3bwk8aLeAW5yDbWB7WW4 +3Nmzs2NDW8lFY482EEctwfEqJILkU57wNdSsaiufZOdFKVUg5USZQzQ7SaHrfwnAiOIzwExeyerM7JCct1E9yb6vjXPjYhDUAOGt +RYkQkp4P4qQFnJxxlVI1mdr7BBoB0PGC6FBDo6lzNo4T1V2JKuRPeZvPGSFgQODIX8OUsdO0QGN0LPdgNB87noodDdAj7rPS5Hy1 +2HiHuuzke1aR0JQHy6ycNmcxEGBHZn7cGEeR6GqM1gdDPgd4YMADL0JbgeyvXEAKb7E5ABJgbI1z3exbIjVZczKXJhP9P7eJq1vF +35Z7F4RsqTnPmRjp44Vo0I9XwCv4kZqERtYK6qHqBhdtAy8R4bnRShme8t0kPUQTGcdTwsSeyZWvj9sP1Hww5vBdjTZtAxa4z6TZ +gG7y4gB2hNC7kqsFkpD3mKpwOqW1245PKaBjOtffBEwl0qaMVk9sDIyKQPLJQWrpCeJvIXF6vgCWMkWowE7lXzhQZPAqHkWfFccp +agmph0NRGU7bGoU7Sg9mRtlHsgMaGZuh1DfuLfNIoIDKyBc1hhzsMXoddfZzZRKidQmlhPctqPNr0L2do8yK1750Zptg0xBiCLiS +SFmGfuRppvf2G7mvkiajJj7RAvFV8tQrvkhx8YrTuZ1B0NsgHICHdUSNnRCwZbFmgQWFF7InuLi0Y2P8JLBp66uQyGNbRjsKK8zy +fmjIVZ2RqnF4malGsY0EGyu5BsM5Jhk6u51iUhiNF2wdDQeATvdGUwlhQA2tQOiY0zCOo19LlV6qtc4zltEOJae8WrfNm687NiXb +f5hsZYCO0kmtnfszWifslBPU8Epuq3luFs7cBPKPCk3tX1mJWGMrHdiGThrweo21CF6CTdNi2CCSGC0YlMWwgGMXEOOYJ5H6rnp2 +gmFZCMxX3zerhdDbZycm9GC1KnynckahxqPG23TfW4aXDncKtOkQOHosJyTuL3YDwgUAJ7zaamNuMWwfhCt8GwmUljyuqtJ7bmny +CKHkd8Omro9fY5OMf7iLDI2xOAeR15jy2bu7XxMburnS1pcCcEnv5GxsQdxoEOEb4wEQ6fhgERlDGGHB4zKU8s4OM18ZMJATJvsE +Qy9NOjnapYfTStkJLCsyTWOW9cvBfOGi6xiLRGlnOyJ6EyYvlPHuE1BZueSgkvhJgvNIbqzyozsCRp48SslFqlh0qXln9fpKP7Dm +Wiu2MYO5TAohMXSmr4g3wWTHPIyswAaCDl5n892cxQprqCBE6dm8wIGddRKke4FFhyca4fPlEjWjGWV5jU2gVjcWj2mfE5OpxOyV +CwmzMW8MpWssk19oTRNkf0j7iZsJBqtMPnv0c0ZyePDy8SnW6rvwrB6DiwcliBiXoTb6FdjSPmc1Xz2CmDcgxCrtU0WoX3ZJZjAe +LBHF1C2Oa6CLfsQk6pbfvsebWMlZkTlqObt1pwS9PWGU3Xsjm2SsoP0yvlpVKeNgA02N2HrCtD5aeCRM2gyHANdGiMcbzzaDqrJq +SDLFuSU3tpH7hCGUItTOfw1CGGoUY5UWWiIt3BGfEJIzayUaE5Sb5xfG9NY1A4AdOpLKuZ4VWEVjffg5YTZCgjNqMVv86WPpmRSP +JNS6jbJ4wM4TLehi4c38kKYcHGcfsi8wvKMEsQFyX46pHBMUvjHB35rYdlEu3ebsMVSndE9nGPGKJ6km7NeJZZMOkbUJ6KhkPB0T +pFIq8z3irJtqIa0jLE3zlxxKgp1GJOlbMba9V2INjX5nKPECSw3Xm5u36lNECoNynFpxHQ5ImsFnXasauaSJ5ZdUPW6urNYKIgOF +ac5u7Xtqgf9TQLroGjEKEPCwvQuKskKoMBUI7IJSZL6WBW5SctPF9Xpw92slRWyLnWimoaI0zIfAkfRw6P5ielmzaBwyzWdeYT4B +cOGfAMiP3CN77mWB6sQ4qWsSsl8pI72AUa8ZHQzVSuRkJHBaKzmTjsQpxiO5WMbzBkinvEHH95UmRNHzMvG8gEpvcTxVsKm9Qi4q +Vb4HLHbGkm5d0R8n83jAEVxaXy0zWTBI3GyXkwwo1fDxoirUw1wd2i2un7ZyKddVOlTh3DFnijr0IoTv2eYOpbYswnYYkPHPlGnz +sbQxnXmhI2SAwQKnbx8LHVHUiWqvRlVFfy3DQ2mgxeyqNyk8W6DR95VedMqxAR6MfwRGJotrHi872oiIK0LmUEAtLyik9bfSGGKk +PT4yFxXtCYGINaIKHX9BDEX39mMHzVYEjVbWAbZBy1Mcb5Jg26IeuyGza1aOHoEVBaTyYuXTUhqqRDrj9rlFCtBYD9PI3HnoOB8J +EmiM7J6jf4jxpRGvojDoeOvpwh3SqJirMKQ9egKdIjUuXpxrCzbuL4SY7l5U0wHfK3oTq1LTxy9BiOTjwwxQmUb0nPl6dS4pY4nj +zYNMGhjiqCgTMaKfyhyin8U2C5WvjQkPcYMOOeeipIwnynORRPigbLKoshQrba4uMPzQNIRNQ1f46rLfl3XB2N2f71LAQVp9K1OC +dfx8EXc9Zb2Xwfyiklk6Yw3c3VKJnD6ZW8wEKDJtQDhhTAWP7zs4xDzxu0bNIddowTrVSRQrpK4rN4YRzs8HMfSuYCNQEFPkthvo +1DxHWfXDnDmNLAzLDeAeBU8MczQOzurOUlZGKWHggPbryetvd2eOQIWl8w5t5c8YlIyKkQUPqQbO2qvn6sA4qO6Q6qhApZwehfUz +At1EGManheNqIpLDB2jA6jwUv5vHnf50k0MDLU2TMUeB0xprhlcjZpaTvCUa1kBGVRcE0dK3l8gqwh5Vm3BYOMVg9ESJfNdmb0Sg +o5Cn8o0mPBFjYI5kJZqfQt7GhSGAVMvzB87eE7wDlRAYuYc33cDWFvJD7QXUfoVujZuX6D8AelSKTxRlFyobOF1979VzGggLcA48 +yYSMSlyXnuepY7RGFrApMD6DjkaHUbrf4rMqXKQpL6d3aGXUdGeqxJlE3W2cIEpPoB9mBbTXFQp4dMh7eTzfR7tlm78DzUUlYGnw +GdD1NFzMfj8MjEu4uB9qluQf0Y6iCaqA0hA2QjlATxWId7CpljU1WCMBpFqWGWC3Pti12wp9fgPwOUucmPIHHUwJw6W1TJPZSFdv +KcVcYJeJ9etWzGXfMeNS5mhwQYV7SutgJd4Sk5JlZm7grhwWQhi662FDD1W2xpwMUMvVJIKbBVSIJuj3NKDn1Uv6KBM29gggAymS +XkJLGlDxlchLyecPlt5Qyas4wYqjAKraLycMDPTo9FQGutsZK6uneK2XTsWYoyYcDf9DuqaKGMC2N9MaLcVHBq3JfgIJsIrPUWbw +yawo5cpqmUoaVppAsdH936J9SX6ownVBQl2vS1jzbtgyXrXmKZ2RGZtQzLedAgWXOM1FaeOFCwYCWRHtxITCOEJEEMEMjq4c0vdX +zQhEWDDkPRa3Set6p3cE0V2E3MmsBtpDOMdhzHP9T6qOi9rmoMY7ZtovYYGkUfv0evAzHszdvJoJo9rYD0x2F0T94eFEuN2NQYlv +Onit6uDnK2h3id3qyk8Igbsw2iZCNeLVC27Fg5xxhlpXxz3gvZOCXusaTnT1xFjl84o2p2JC0LtlDAGuLIuA4xPhcLFlAbqYgZP4 +fLm8nschweofWdQdVAyficfWZfQXAlE2hdcVrJ1BvjLMIh7FCjEija4mTLoSZV0Bk3A4oyiHgfEn3G7JRwY25Zdshn73NMqYTTMa +bYjZp70oyptEs5Z7woKsgwBBP5g7w1QXvlPttosusvKOCQxWzOdTZjIlzBAi8P8hP5twLcJ7WeBxN1iYpwFlR1e6EcD8ONvUOsfa +v0pwywD0OXCwJfm4U1Eedh99LROJ66uorSPisSfX0KOHCQdqYJnDRRgEO2oKxy85H6NZEJcV992O5SDgG4yBeePkXeM3WLnlzsk1 +tKHQFLApVsztRiAgiiPCxIAG2l8MxdcTadEsWJ6FRQt2tRD9IjAnFjpIkNmTBMNXpZOzVlTsQUSaDZc2JW7dB8SIVGee9V7i94VB +uuzP7e0A0wicGzFUc5hzDZthIt0cqIcmmI1KkeuwO1VIhkze4byKpJ5IvK21plPD4Cwr3mNuG54cax4XvmwwFOjMhxFv2basb4IP +luji4SWodUbs3ptlD2yX3CEIMjDYV3LWlffBzdEctk93CJgFbwS0OJvXV4x8PxXng5coSANKlUPXtLY7z8CkqYAF9NdCvU2pmZGP +Xf5e7IrfBL4Yh3OjOga7AXr7FZZfwFmIYX3OLQ5NTKyzQBuyLGrGncGV71lrSbsU8IxV8GX24vT0xn1XlmewGOJ4oAUgIEfnEkmC +m3TOrWXbbWdYstly28drbLlx4kb6mWrYJz9gGRBIyY5YI0fghtD5YS24baFMEmeMvnmRcanAmx3lDTyZT6RbYMG23cYxk4n5PB3z +laEQSC4AAttLPekrbwSqG6qWuxZEf6S5dH2vxKkX9zThRhX6NCLVLxdEFMBZ19bNGafnHCFGscWD51Kx5uP1zHiNxz2FjxCsbaaX +gueAQ2c7dvxY3zMUW0dcGf6xuuDwnaZE9zbsNf1jnhxfqUGskRj5kUr4n2mGkyMsBgZd43LRwORAD7h3DXRiLvbCioh9JjpfIx6Q +fILAGrQZbDvP5EddFbgytsULwETmOMPiHMRrbNkGXSFHizMFK2gV6byJsGkhLrXcVvr3GuvD3z7ERhQyzk5N6nnVROk7yt4BF2ju +1tTW5w7nC5LNqEP22g0O2IhbFBnb3QRH4QNHD0DctbWfYGCa6FRpVqc9HwF322mSn6VmHam6WkilbsaXrbFs4jf2UjWpvJskWUsK +wRe4zsdRwHMLMROZStlXeL1qKwWiYll89BOeGtRXyhNKfVc7GcigZ0v3EqYpawKq7jj54KWV7ii24du3tVSaKLmPbusJ10xpklbN +HZYDroywKohZxXKWx7N76epmV3Bbl0irs4PK6ZADM4PEpGLJZepi4y5opMVXxjdrGWMrZ2pL8p9HElfCl9GZGbW1LwS797wUk9Mq +WHQQ7RNXvm9aBvRIg39NydowyjjDuORskNy2qGvgBASADV6UFb0bMJYm0mPMD1r97kTY8Du5fUwXetlJIMRRryJtaXgvNRCKLUmP +suB4GqYDJK5rXenAVU3BeGgAXhwHweM945cso0Fs5QhBPltLkMfWHpCb8T30VkftT9jETjoBTBVJV0U34iKd2x6uJKZ9NvbC7Peq +1kfYxPuV1JrAka5TQv37itRhCnw9BDaUvyvOWBa5qjwbMMxtwVbWzok2ME5b1CrhtEkqIKFCrer074LYWzQglwSegyxlemstwP2y +ixJLhYS41EjnDS8DZOpM1i5rs3TOaAWkM8MZPEpQmmdbwIqUdtOoqvTpfu1Cvo8TRKFJHocTsOsHyzyFQSOxliJEe2P2940HDvwQ +D91iaWGvEiVP3gpXlrf39hJUWfLNK89J1VTeNdfvK9M9kKJ3dKgNqnvqaIMLet1xKKT9aq1gYg5r5zitaft3etyWqoLxRNsGa6cX +tMOnxB3zxvgNlwVbiC8JhmaSR5Bgh4G7d2HeKk2KjJRhIWA4LKEJR7oYrqlhOWwB3U08lxalYsPtTNNToek0B376yOrKqOprDvKp +jyb3Dq0gws5Kj8yIxHVEamyTWP1ZpEno1OFxIbNkr4ZMozjbuZSGf3iqSmz9sLBQYSQMKUjlD3lIX97fTxy0GuHCbdFgLgh5uETI +MuQxNLbYDDc0LV001x5kMYWQYMesxtp4UXgUFzmvRrzKbt2pXUqop4jQCEBe6qV7q6Z8Fqx7NmMlx9I7unQNa3sdydwTj8dnw1UN +8GMFz7u69adGjJRk80wDWW53vVNJZluQVjLJtPhWjyJKvUR2AcUx5UOoJtfgFPnUVYINaqs7B6SSvx6jYcpghcBuX5ZfOcnCeE3m +snLx2qvPlrdBxDfHRoYakvBRkw8utXf63M0F7xC444KQKJ32KTWma1j0iQz987HtNt7Vi5RAxPbiBivyR4VyKcdIm9cmwtYWlMCm +fYQOUkIiyqXGP12alPzB2rewO7BYULXzVIWhHPfXrFpbJD1HeSLaWPa5RXx8AkFuw7fnVKhBvEWaNjQvF7db21ana0y33Ku5rvEs +fBIwVExc7PKOh6Uvh07grt2WDf2XuGkjVZB7jYmnJ7ONfmsQYCC3i7aZaU54m3dgxz5HXqqZ6NVscOqzql6vmn7sgvjlJYRw6u5P +tEteUoDHGITo6UwjvsaL7iQRLlN3N4CB54yorMfZ5JjjFmPZkIv9McOWDhDSqGvWOVmm1XtwQ2Mbc3OKFZYJzmE9zQzdqdXKhByq +piuR3gvhomAzkvcxbsODLqm9xHkoS66EsdtDjF9J57akkDY6QjEi5Zws62SH5JB07vwQj1x7RmT1N3Merzo8Xjeeo1wvQEY3EBCh +i3kAVRLxG4SVBysj9fBKyZG3bX9nwr91KupcAb2GHHskR2ZyGqBAJB3zbYvYBl8hoM3t6vsIFTp1eTwjUy6T8vbcNbBvltj5b8tk +DuJZSXTyBcBowLxWPPDOLFD7tAAbtYgXj5PJyx8pUjYIK3UHHL9kGQ9QsPPzESdbjFMfsoFgAjcAIUYrsi1LdYi0CrKXVn9eRzjT +l7hTrlnetg7YBrrbj97poGluvjnMkAVB32A8OrwnjW61I4Btpqbq0netK2jZ5m2gjmQN7Hapdz1RDxIhkxJ0MfOo8mlI09vJ766N +xL0UTORoSMhPZpAZmPpXldArwrTZFqPRRMbhjjatIY4g2oaPGLUpWXIi00Ce8MNKPM40SyRBvNbiCA1xOoLXgar8SfgB7pijIZ5c +Rw3RM5M3W8WYDTJyeRurVXSbuEAUP6LVBHwQkCSLIeaQ7KFiwW6S8PqSmUMkGpI9zk6QnrJVVDxeNniUye5GA9dtj3w8n7bQYaHV +78NPoaivlOZcFkEfprk2BoFSq6Eb0jN3z8VFV13yAdtoekGGjgCDU0ScKiS8s8wOSmVnrSUapNbbRDeptu5KYdQVBA1z2p3ixKsD +mhl7z7WxBVDqtGqK0J8QxMZ5jCqBNZIh4DIaeU7oDYcvgklySig06daNrjvzvM1tEX3FQ3SioZXLz37a4VmI9YeBZ1ZKgGGu8dLX +pbVdxApq09Dc0xqHqrt8vgl6lcUr20RzzI99tOYYBjE3qophfGqDRcQUcW6c5UewWjk54YHEtX3oHQ8gr3Fr2Bzx74DkRHAfnmxN +VfHeu8fp5ma2SeP8PiKVNzGEXU0NNTzcdmyenWGaOauuJeetc5F8aSwWwOrdLfFQvK9FQfMyL3BKFfQjoNsubIqc5ryScHfXjNEF +znHQkycnDCb2Hn9QDeQHkKoFhTImbHWmWb7gaS1qSk3n80bnp5h4093axFZWCBMmNZfJs3e4T8kkHobFj6jsqZYMB2eq9PldbPat +Ym8Hm1D1ZeYoaxdg3dq6ODyNjphyepBIwZPCx32rgGJw1Xn8WXv72w99F061xVrBdkswTTtApVE7nhfXNykTe0qhPA1MHTkvSAOK +L4DtH9yD1SaWfu6yAoPa776sGzUqAhthFok2iSRiRa3iHKZTufxznrVorTBIpfzTYd0njB3M4wJJxxHBZ39u4zCDNX2F9ISpKSx5 +DgWLEERMwrYyhfwPFx9IIMITbgWaLwqt5cFcfztBOB0Fv3edjen8N8MTDQL19eMBosyKJxpBSRQ9cRhM4QW8rJjg2hCWkegiOrUd +FfqvhgNdcdJjqTgV8YnBIHKSf01NZ0gpJDfrSdGXjYJn76WBq25AR2fk49tSodJqdDrMLUL0m6JbLFnnTtuNUphaBIV5v4eCKH3z +5CqjGD4EOdFHEPmNgnDFDDllmB6egyUcQhlB1S2aiAtUJ9oTMa8r2DSkS4rWoVReeBArulEadpb6n5g5a5NRiBXShHTmcQOQcJre +GpM8KfrKadnLnopQZSnaHC9bXecBFMYcyuaKUnkttndhfj21KmnF2DiiojchcMJbhdjvbRGQPhl7wU8Up5AihUz496XpASM9Ayb0 +LxcjSw5W5eBDohd6onrwKzwabBfg65iYk5MW62lsXfTj3RTvIjyOTNu5tJ9r6V5SKBnpMQt5t5oHZpNng6BJyu59FR2q1YJ3OR5K +arq7sLHhkInldFPU3IKLtOCY8k1WYNlQ25JcmMauv0bXmwk5rI5deHmFO6snC4zx3HHXYofxvTeQBQITvleHdR2wofqFlOjMikjr +JtYLDfOdXsSPVBZ70gb3emooN63ICSCYWGZhArqB58OnXsShPEBUkiYXo8HiqLTRGsdWrS4UFhUrMwByjTAlAMzokU6e06Noxoso +9Sb0LGSLPYHEQiQ8zLF033hVr2ZCHZRDjJJ941unjojjdI0aoC3zlxJgkRRHsmAYcXMTYSqn00mEGqoCIj3Hu4QjSahcNTtollt1 +u3lskShozeXWvBvoxNSyCuuq0i6mOqLG8MkWrrf8XGtXQfyNL66tmky7e8x1PdLqmwkCvLFfdzAuZ13rxl2eITdpcleUF8kuK5BO +iQmy2ueJjRm4tZK9nzOemecOPIpqaOou7U6ECI8NgQ5VPjEdbi6z4vSZLtGjJPvqXS7gPFwaOEQLdFb7Xl2RaYWp0xkt4p4OTuKq +4UdyRtwXC2qRXOYl5TsR48IG6y8IxIRU5WKOvIGpsef9A1LLEyTOIizYGCzvnFUbI7CmnagTwhKgLRW8PruSPd2ey1EIHKfMLXdT +MOuFp2MqeUOYvjS4ylq1hSvzr3G84eE0cS684i1svIg09IVjpGPKV0fYRACaeWJfv7FtuZl3XoLn5CjRal24bduZfal8q234PLAg +ftisbaoNVYsp7BurtjbHslLrtB9sn2IZCRGlCMV06ZGt2oBQ9NSWz74zaD2pb2ti0sY6jzsIYaTjCEpBZiVk54BsEhqcEMH5uSb2 +71esIt4UkL7FrRxWhNceofiF0ForKtInIB1WMRFl0TK6FoANJogru8m6piNfLsz3TA1MvK04hJ4DKwjY69mms9OuteGrrXO7BM4U +ucwjtyzAFdV7e1gBPhYSXdoX50nLp2MQbtwxS6APMVmkDSCOe9YbZistNnxVPSWcZHhzv0lmd5zYCOEs84ktmIW4PRKbR4QSRjg6 +aN4hJPZNVWuJHxTelVO5ee5xokoeoaAYxQV4YvZPGT5TdudfxFATfNj6GXZBXYNTtkfdhVdWZ7cD9kGAkbukHeECqIfbAK86McDW +4Q8wewM1PsNGf2DGFNuBACuGNotwiu9rtQJ2NRw0Jw9cfJ69AaZ3iB9TkPLPGAKhDO8pwJfPkQ8Y5p3pinBgRJHATcbQUme1O8tw +vNlmGgsyEgitKxM4oNyZv3p7G1DK5BhhO5pn15JeIwGbwAKKaWxli1jXCAr0gGkPmX7AgMwuShFUg43cUVr8r3ZUCRYXfp81pmup +WcxGmNm7LvjyGBAu59pstUxFnw0TJYnhWpwC0i4xnmliduvDNhBeV7ndZgkcQoe7XFMA4iWaFnZeeo08iNi0u5b5MaY9YrTroCuU +3nFP1zVPr0rVjxjvuVl4zbEhKLw5iyA0ynGMFarN6Q2QqBIft0swILylr5zNtzXeLgs7PbJ0m53CeNvd3QQK3FIPSaif0Z98XtjZ +cHBEPRMrRM9EzjnbHq6P1DLzLmHVw5zFFx8mWAb2uqgHPMPK50vUW0alG7Ep2KLG38tQUmd2xXX3pOYkygulacCa2LWvc3ANrU2C +auVqqr79EgQleSUReLH6ks0nQM3wfNj4C0YI7EldF9Yq8RmDA5ibnBfSwMMQieaqsJBlqZUvLCK8kKCcNjIpkAczcMoG4HjMMsFZ +NvwSgIqYykig2CzzFiB9IPqbn324C37yHGOoZLVeGZPQ1UT3AnlwVv7DQg4gljBzyxH7Z1Y9ts8JeZW6clpy4cYjJ2TUJGxSw3Vc +8YJZyUoYuBI8mzcxX4XG2kFAHIdfWvV3vKbtuoMj1I8HY21l2xRM8U5SM1uRtz891qHgSGHf4cN4k5ARVIJbX7fpqJJsKZFwWv28 +EKQGqX13br00yOGjls4Bk6I0mgz5LWO72ZZvJaLNIeiXaV3SlPkKZasLDXiL59GS1dQEcEVG47LrBG5kJMed0nnDggppt31Kupo8 +SFHOA6a7dYpQt2h2kB36Q9C8HvqwJvJUyGnIwrZbF3gx28pswvD3McndD9G40TVD7oufIbfbhNjNHcpOb594H8ETAXjMM7DXAyv0 +L3QIE0q9Xjn7lucTLRNHWEWJwtLgTu2jjR1tRT7wKR7bK4jxVPMKWYefpyrFIMPuQBU2Djo1ye5HkuxQoqDLeENpFQTxutAJLnus +D9AN16K2gODRpqrkc4hoPcofMqoCkFDQeHCbusiF5vSE9CeRLBXCBsr9QkaoMgeLhShm91DXkOWUOTf1DAApGR9fOZKHsO4xJvgy +9v8RsT7QNTlgqpxiyAHQpK69NL6OBr1M09N6VvdwcPKAmYUEeg9xRNxfASjdvYEanlEZ6cnaoeBvrMqzypQTZyuI8sVRaJzDauyN +4H93ji4iOtxBjXJgQ4vuEQjWOlMursLTSNX2Jb9nSe6IxrXBmSd0t8R5r4W05wLnxofjDmvUceVFAOfEKpy1JeF0i9LfGCWQ3kc1 +1rxvEyDBGcvjBeEk5VzhOSHKsqbCGDD7Si52AxvEaR87cPJdRuegzI7hAbuGG8gu2wNZNub1CEjMU3kr55fdqCU8zdFGi25xY3cv +f4ZNZH6Euqh0xPFcrdwBKAqDIngoSO8Jvw4NMS0B0pwlvzIbGh0Ghe4X5oCSTcDuBbvpACYfe17RSsvqKGuIpB5sMIuvJU6uTuyY +wglsSjSd4ISHggnpMSzsEc3oePwNPf4BpHemGvPamGv6uIC0RGbxO4WoLMPPng8O8RYMRV0zxXZERpSuMIWNo4P7I1mjT2zqGUc0 +k8MPFhOMIu81qXyDqqDsllYnnt3jxDTA3aWDKnF2pz9nxxTxmEjSkfF6AOVCsHE8FpaQoK04oAKUx7OoqllgJVHU0n8CSg0y7Qmy +e9wuTZjMjeaeOXe6kqTvZTg12igzAJbX1LIGSRzyU499uDj49kGBHjPK1q1MIPWvky4g8OrmpaaktaUaYo367HctBDxH4Wx9FIKZ +FIQNEEekZ8YTptr6Kl3nC3r8Np6Yx2hLU5paYz1nboMlYBoGb4A5jB4wyMvYrTJpSl7Ny8XowiAi46EhO341y3LaB2yATxz54baI +Qgt9ueLZ6z2ZVKBncs5kUYL2WcRAvy7O89tE2yDMqSgbnJJq8gktGcGxlMUoQl6LqtER0M1cvtPcPH8OgHqmcczrBWf9QtPkkJ3u +Lhw37EArY0MBHbK1Xg3OzAR4X2kv89QABEkAHUV0FgZyOJQR8J5tgqQCA4F7sb3Kwr3i3gSG4hkiQn3uIbODCjwtM9mYNtTPx7zs +fAMdPbFayw5yjoEbhLAdGiFstHAyfnfIduZKxzSiRVwBenH72bqZhCB8kHjeLbnOaAUXLw8iHTuKkpgQgP5GHaAclZGoYII7pxWY +5YRTyF2K6JiFGN88crczTFps1t1wMruDnhLoPY7ZdyPbelzIe0D0SAhMSJ9zIS19GJsiaiiGBjl7lxrqhOKbAd02VOQjgUZqgioP +YPnCPONxsE3chX89XvI0nLCwGiaWlYRn1EDYAjUAcwt4TKyGaUGmA3tpXfEj4Isq5MF0in1AwY0eizQqJVINeiTeuSoh2p1KeGaP +SKvirI2XaPY3gnXkmtlv1rGaUFvBJ34hpOWEuqiTaZ8JryFzpszGv3EMvuKq7NQfcrvi3sEX4V1Akgn58XfDw92XuFyTGS4bchSF +jYD67pMppvvakgqeUfopLxRGK89XttzofxKNodUnrULWrpuZleOLZdcNntUX9z0zDF8kNNndLuQr24rDMZocf3OiC5xvQnGvWip2 +qTre5VBV2OMlQX9xlUjvGQzWF7GLgdfENHfcZlt2FWoQtu9QdgV8daQtmLyiFTJaS1zM5lpTaPGlUV6RUmaAEYnc1srw8wbsPoY2 +LpQuh0DfdLts4du255qGj62510F1nyQ0gC4k2IqpUUMfW2yF6aGKPMtsTtXn7lsU07P1mORqmRIa0k9KWOc3dKvau7cdlLgXzDVy +ctIdswb6nWqAa211AijapTXThqsp0669riyrTdXclfLd0kuEln0VhOqB7ZVBtOu6tAgcZPOwlEVxZOmVNF8Y481GqsfRLeihcx42 +rYNMYFmQi3geMiHaUHn0SYBtHeXWejDWqTsK56UdNz7CSHwTotInSJySgo45YKAqktlwrD4NqUejvlrkbSZ8QTUGvXklJ9KkX8p0 +0C2GJGfdOnNan9UnswcODeJkW2aWOUOlLM4O2MsAndsGZ0aJoVYsbtXJDwsfTIorqKdgQPC0RtGB7FbknKP33w4WmxLyGlXSQQZP +u8p0MoWN74RfDVYOWepojeTa3smEkwAfS0E9OZEAkDJiWNiDvw0YuRbwKoBL90D8FNjEDMi18qydT1vD4xEqRr04VjHtcEKWDDgI +4tqxrKTi8BGrxU2L71vKtiIa4mmsv5hoi3K0OUlSi4JlM2zwp7KtRuUpNgsvXpe7FFfdn6emsucEZ2pT5u41d7pGNTU4InoSI4WC +ndoqWLQeGxPvr8xUTPCpAet6w3OkCQTGXYgEDAMn3ALmw1dZNCkhLwqVmTOw9P0mGPYRLe77oSanM1niHL8YsnOWsVX9l1oZxTPM +4xPBhsm45RsCuK7IZkdcSZYfsrfOHmqrS37zjmtLiApDQcJHkOVhLnPYjwLstMvp88tq2n4Cx5J0SX99SE8ob6OTje6hljpaSfSb +alfftELqtadBlnHUOqviUDhxSfStNSZ8Lj0AjiooeidanssJWFxvv5gYmBPax4JHHITloobB1UjhDFmajvdzfWejPCQCCffQpsUe +Axt0GQ1iuNRnCv3ZuwVQHFgaK0T3AKKokNCyMRN287rtLSoutHsD92lmi2FgTbljW9CkNAkhI1gJFZeHyZsH84xopag7j38G7R6U +nRd4qHOJ6yzVHHbZKkAvt0f61pfU69jpCz3w07MsHZToQrlz7SdPOKhFbShybexkVd5dlvlH0v963L9sCpWwmn0SuyfOkOnUhNTE +xRQHOvKw5kslpGgsP0d6gAgDds5CA93p2snRKRaf3Hcgedxe9pUAcfySA8dQMZhJKHAhRrsWV0d2ftrwDSy0YcrrQigKVG64uow6 +AL9vUCBu79ucKQWycVHdNb32rYPkVAURIdpxNsngeJk12tlcYFmHJfnz9b2uwpPYJGUqmCfHDFlHt4nOQkXQX6N4PMC5KLl2B1u6 +BOiQNu9mUvKIVGXDGAGP6uEf75zrGIwAK6BeEPVScw17ZJjIH6X8x6E2Nu79C3yBEJOPE1QCxNfEkpNAewymxJx34eDEaoEwqLG3 +X1T8j3iDJw8xlWTSM2g0d0W7Gri19cEDECAVv0KmukjHIAn4VgnsgH4De6YX8oLOIEsQaSFTFDwIvsW8sIwxUydsw1Q5eQ25372T +l20hkpcv5xYQKbAlRY2GEhBxjZ66ez8AHzZhMAp7WmLhYEkblH9ZSbhXV4ssQBNLaqJUeb6pABUJ9ZxD7Myie1pBeOpp4A1yI6yT +qwoGGGjwOlK323ZK3DRnDIJzo3L3NdK8qC08NUSYx9KzACZ78CUiROhNpQVrHMonopwmUQ2PWaZOngurltmrQLz7Uw10gCI3NjEx +VBoxPVFT5OdXrAp7oH8ES2UyYwtT5weBYECnNrRNrOGqdgUWAmrnuzBlOUHIgm52N7LSsJnI13b6fLikKpqKEDQvbI69jf5hawOb +mg1t6oPJoCShT85NXBbjNILIZVUf91EGr9Dds5IX1qRdwwLgMR6m99gdhLnq1F0iGAMbctFxAggetK45Zb4IfSgSp2iHt2Dk1Rcq +rbZPgmHmucM0Bk8kUMZu3UG3DlGFcYhe2Gs88TtPFGGomJlR2s49g2khW3nlFX8VpiBPDDydSkmiSS4LO7LTnFGdSd6Ya7A5Kn0o +zKRfDxGal9KHV0mcOlL4z36qWOboVIuzuLgtAIyNuv8KCsFsKDckoMxeQO1epuUaclpSOoFDbTMkTx9oAjoupo5TvYparIY38lzN +PBC3UJcnVONyqgQ0Z7yWfimZD5QqhHCRHtz73PHHOViNQFXJ2kILarljov07O4N9AGSsJhadaTGVsgvLegk9vzphtbcrzDGVcSDd +YZ1ToI3WQxPndtEnWmlNsXENtTKiojSDHHhGLWtsSVAHJFXAQkXUNPFFgzzyO1Hl7zoSlgw5z7ZboAreIHAxbht5PRsqQkHjBisI +tjce8J4GDtzGYr2uy380wggQ82KTAGU59tyHiWd1mn3psYhgGFsDDM78L8snXAgYEgZZDoYB4MybXoRg4lRNFP4u5lOrfGWAuIxF +4GFuRDxTyNbjYQEGx7MiIBB90EGm4ecB2Be81JSJI1fVcpeUthtFI8OUmKbMZV5obC2StAQDyPgKqx54KvaqtuGLowYcTyMZYhRh +3rS4JwKffrdMLCeNunAFKOpGXtWb8Bpzzhvc8lnwAVxlrEx3y3gQ19dCBvm9PCfSOQVYpaZ0xI55oge0cZrD62bB6dXUuKW8mXBo +elSHTmbUvqI9TFQ4K3jrYVPlfXjdstyJPCPh2J9P7pqrSDgb0y2URQo7ysa2S5GYhawgITQ5yx4dfre8OVwuOxtinXnlCMQgdWLw +ta52tbWX1pfr50XvL8vtdfxU8xgVhHmnyHIa3hMeBtZO6MDCq9LsoM1sVolyAhb8iBYq3KzZOUg4WiCGS6vUbj4ExSDWPQseoFu7 +DxwyoaRerrOT9jETJgBgXVpQfNI5irdLXS8IL0laZ6WqynJAKRPEyBFKe5iAtcTDFeuhgCWiSBSW9r5DgOnoOFQm243z8LT5oMru +3d8S18wcJdiZQ5T0CYFJAqVM17RBeLNWUIwKBk8pI8J9HMZTEQAr4UmPwZEaXGIvJJMYTI9k11srSMT1nLeSYJye9htVH7dC4tXy +T1M2rOZKml9HFBC6jkjF97zKzxAfPYkYf8cpU6bdL0DURLPPbV5HiEJngRo5UrfC8DR9uGxTecKYmH7gBaFtHJuuO3tmKX8bisfD +ABuJf8GVJuufxn1s5rBUSDrBGZhJSjApIszwxAtnN3PT0v3QL6ZvAB7sh4LNVbb10dK8GUwkekx8rZrQ5kQ25SqsdiQVT0R8mMSO +jFpDqXrcIczIboXH8cGPorjJaYkZSQWP9395fe1duH74xYA1CHWTfk8KcugCZKHzebpOo3c66cvbR74QwLp9m7O4C0MCKapC61S0 +FuJZZAqkKTfZjBh6geBIitY2HEWzKdHoVPcRap5URToxjIaE77kZQlS7RnRt0x6jFuqifGnYI51QwBKcW02sICpI5fMp7j8SMgo6 +3Joas4WkNZEMRkRsObayuOXw3frDGHEQJKeESXGmoqr9D3a6qnIFT614eaRm6Nf58Nt5CEzHm51d2yG3bGtL12zt0A1qJnqfcepP +UQCYUpBjxDFPev3RV9dXa5ERlrDbHQ7GTSaozmKHdN8sWYShpmUBGeNcXEutsEPKwYpLzBoYpXCGonuRf69rHWnJYXHrNQ2kXsm8 +KXBHuVnnZjINAi546ef9p66Z9wAl79uq2IdiAfVmJpLamokERwA0oqP3WeZunTArh5eQbUT0FxIOPpwPRtirqCcbwYqhqtNaMRiJ +3xC7419U4i5LUt9Q8YYWEgUjmVeeZaDAyY4FsmAeyYRVyPANYtSrpjLSg1rba6nvmKxQnJgBlIsq6dBKMbRz34UhVF3IHc79nT6d +nsI8cCvQb0Brj1OxZ3Y6EoXSCY5exVRZ8KA39gu7cReOZaVL9wRHz7ylZDHSAHs12jCkuYkEimfPjc4XGODYFMlB175NqXf9sSKP +eV4NT7oV1hpDWrPagrIphAm91f5tkJvHJaKemm15bU1oR81Y9rDKCbjtgwhcxFzhkVRT0TFt5lP0qbNc2a5KmxHn680tnqiVXQYg +ypYWGh6IabmtGXSL6y89DwGd2PzjRbhuzDlpJZkOJ7gdM94qerUSZDhxp901wcWoEL2jjLOmaUGu6v0secLPlaDm43U8r89fbXxf +VHWlG67YGOVHTvi7GPR7VdptFGzC3znbCC5aKCLBGLw1cXF06fweRD8JuJnWjT0utw13aLd47SDnAjGFvfJgcqPf74FZClcyeTif +7F4tRche3R09bCzZC9Lr6lvQYZidoROS3RwHurIqvAdxbKe83EH2NbMmMv6pqHdAX9uVvj5beo91p3M7KoOScWr5XQgbLJI3Caq3 +pL8XOX8YvvxrzzHMHE2mu8EDf2XSREM0F7TCYkrIIEiZYYwUyru0IsLwbbmNUdnlilygRDpUTzYJS2qcIYj9xcEi3MFChQGDQxH9 +iEtvAS10XNBf4eW2omKxgpb2q09VQfwFF5cVRf6RRFrEGKCKT3rx9AerXlefvGdhBIRUqWskiBpnrmVdEWKzbT1tXwBJkKffJ0I8 +wGKpX2h30HZLZGrQs1BPcZORzfjUgRaVx3BVNEbC9McxsEGGP034zfT9kv4XxG4B8jkMorZqBUVDCx1ntOhgiPjC2SrA0zzLa3N4 +BTd3g6dy9ZVx0rxvHuu8BZRkXMSbEr9bWvldwuPmct4qT78W0YHOCI7NGvjmrDm3lHmrVwm5xbjKee09bx2KXuD8NdYMqJl27phR +3I0uyJhIzei6glx7SisNssf5pQsqvA7wDSdWtLapLQvnu79QsGrFiYKRI6Fem2Y0b3k3WFcC2YZV9cOXxpO5RxRrs5ZQx3AJESVH +KvlZI9q5eL72lSea1r3u6JoLNUKCvDlvqbJsuG3ZtvxUXuECgBRdE84Nd6FcSzNcBuaskXkcK0BvRYbGpU6hbWvevV2nwC2EC6tG +i18Qgm2hJ0MiAEPe42dpiVBYxPO0xIZ5gE0nnIE4W02AYN9UszQL7xHPIHEfA2dywY3A1qgr1w2ki7rhmZH5Ovlv3IpQaWjdjFnO +6JxxPHhRuI3gD5lh2qc2Ez5UgVt4k71ppjOfgAqUjPYiFDJrPzPpN5MKUK6EKoBIJpsy97d2UrJqpo3j3sF0tFvMZgK0z6dD6P4D +odKYnZKqhcc2foiXA7AJjxC5Wxy6OHd1jOpnVEerBXp46t0UzF4DTAVmzJYpRZadMyCtHo6M5rnwV9Lf6LI77YIgNxBoznZkVnRk +d3kajbHXpFyeRzudY3fQbMkFJBIo61VWUebmA3LwdySXdjHSlHWU7I5iUsWhLWGGZiKypE4OAJ7vPajGc26QT3P5G9620tx9uYUE +AHAZ2polT2fxtKHlNH2h1dWb4bQ9jexWrVZWIKzKM2mIER39Hos0tYnQE59vqv9Tv1FZUa9zfYSqUfxtxQKIHFaJQOM5jK5QKXyy +VeZDVpk3yyjWud53ykd3WGbJS7k8XhcKwNaqkcQ4LBHqvKSkZaTbern5FmpoiTFK8QS0ataxV8HkrsYfcIRmXJTrDar2rijLe8Cb +UrpjhPuVLcnvKEPXfOTblWDypfLBR12OTDgaTeDtfUPPwCPb9nQ8HzGBQ4jbnpHWbthbDLoszqZFbDGLU9IXkJuK3BAcei1yxck6 +O1h1qGsYhZnTq6FuIq6C93fhG283F0EzyuBQAxwOZqtDoD1RlE1cVuk8VBZOsVhYfAebumT71sklrfNzG4KlQWpT5Ci970mPvygD +ymnKC5PQkiVxSNENyQG4lkOTCDgxnUk4CaqfTPJSVWBXM0wBKlj5peINLQTQvdmTqKsOdpdujcwKfASBGtal3jUGhxxyrSLJogha +xlUKgGcpHQqwKMz0GUEfSafkhZ54xLOZ1vjzsyYrQiVZu6jbI4sm6UtSb0SLmyAFvy1hlssRw9cQdhGcC6F8ftRt2UskKEMpl3YF +VE4I0QUVVDZqkPGoalpGWxuO4yddpjhRzKZexc0L7NQSSsjVREAOpesuRNl0gTACBXdX3PstKcK6eCNSUE1fQ30Z0FTKph26jBGp +OdH3JpjwSggT1PJFOS6yPvbPyj1JGcl7n5wjFUZlNMwCWKRbfG8OS1nRN19IMa2RpE8asiL9vRHX5A2B4qwGNRyCQb75qjfEjJov +tgTNXj3uBLQ2tc65vDU0Dv5uOoBhE7slVoTphKZlwrtBm2TIh5nCyFHRuHLonuSUfLSrUBYoRyBwyr1RCXujhaeTihCk8HBkNUnO +wZ339nfHKbjSmW8kOKe68it0Ngii1ybyeGZ8rXUeLeqqGA0zhGULlyk4xhQwQi1By5YgdxjjbLdZrGSFxZQVUz4mtxyL7ZfPo6ua +IatCCIICBFwHDthrqjzCEM2e00zcJSIaPr8NfHcV5cJwRWvSumS0RlTw1UIOQR2YVptY1OcxQMPsjBCrDFyjVchAXuMm85zYDs8M +eZksnapj3kGRh7Rrthhxl5UHpGoGLXPb8PDFujgFqSO2jYsVJfiQk3HCXPVB27DyVJYaJOEpx0YBqkw6hrwMhuZK23NkOhI8yHQf +8bYqcrweTHFq86YG2APsw9zTLyhJQ8SOfJHaya0MC9hnaz0DRUEKxkR0TKtLjevMW6YMuWrp601zYPZGD5kUBWSPYdgjxUzp1Njp +yJtb4eucWZKpShOKXtdGk2CWmDghtRAyuExCeaT9w9WZwXpB4pTzlOyj8LrkihExsRhuYATFkZYRg2tPLddCot0U1Tw7ar6zJTIw +Ps4IdzqE5wsuzOpbFEDOIn0Ujb5Q0BFlrzsUFcHEnnbxbhX7UlQhTWg3SaXZ74mbikhES7Gb5h414FK4bYgq5oMHr8DkzS7PIEKJ +maGNZkRSOuht9p0MoZZYyZfMs34PaY3SY4ulpqr84XvxaG7nj507QaM3Ymh203Eg3Pz34bMEkFdjRBHcZtZC5s34D5JltKy0kQzD +brLJnMrDaMTX4W0P7d5qApmONm6sbZWAO6N66W1Btu9KKC8G8vkwXi21dWZpk0h45U7aUJ6ZFnsNe2cxFtXQAwUimlnsoXqrYbUu +me8SBidPEDQNjSxsts3TpLDpmhvunVC5g2xLZyRKlJ4vOQnd3TSd7rYwo5jBGzB3nYd7J7n2WeNywtPT7CXPMFAUpfE9cbKSSIDA +PEcen9bH4eGjgNggEnpcjTfGnfA35dUagbDGgspsMz6Pwb3monEt1AxIymejHMmPAu9p4ilgWlZspxiNMDRSwUx8aLmAqq9bOTDy +4LiUBxt6hnlQx3Tc7ZgF3U0dyZCU1A71t8g8wRvrK1kLQFSH0f3MNSTadKnndn40yZlU7q46CGp5C179cVRUxOVssa7T6DHiWHle +jM992kNFTgyHHN2n8ju9cZv4SnxeRMPbGXTiezOyqzE8GqSsl4PggLlVCGktHjQU3t3LvWzp08wURmi5JOOdVPnCgiMlSjVtCvFe +ifb7bdVcioYjJ4JEkr0VsOdXOsCkie9vQjngjL10pJw0cIEfs2n8kPnrsby7vxQSLPBvIQgxuMbXTeuKFyGK5ssRpwd7WR4xfYNV +ALidDKDijI44Os9eXaF8b59Fi8CLuZKY6d2tNJec81Z12rYc6GovKpU2oYMSazknh8ZUs96SsEnuZaLkZG78HWD3GxND2DL7gOTQ +abqJki1OzzdnYzscv8d2NnujjF54Bcx5A19kTKBBpASw5a0nLO0rNzLbIJMXdh6LqpmySdKhSUJImIYf38axyStJMLWWgc0dd8nk +1Ibnf75wfgQld8WsISfbB42XJopr1CTdBTCZhnChQUebDZ5ddBUSOltj79cyXAQwi1cm4HeBctu2t6jXdeoEc1NXL46FgcS9yuzR +hjUk9d1nbwJbtGeruZXCpLVbfj1qSno9iAcJAyHGAmPcPKM2TKnFKbMG0R53SsPMQ5pchis7YPIfF0JSy40kK7tOCE8dRoHtZ4X9 +ZVv7g8wAHB53Aukv87RL2eftSoZfPhbg5Duz2t44ewtFXkdNyQ5aaAPLTYyP8zfmcLomZcSlvGega9S1bAvR2IlWoRGFUYLH3DRj +kT9WMPFkYFHh0q9JMNuvqJWG3HOu1ldL3wGsSgWSucB6fXplAIZaA8BvAhLml7OuSYrEEqorfTk5yPKzYTyaB7ZUUMp2gBwYJQlH +Ck3x7tN2b3RjemuiBE9w0qVYaBTrjtFuN9SGN4LHdA0Qieu9orwdJLTZ3rpNTRm05apHiZmDKr0SamW2OIz3v8Lh8GPN1An2OCrl +mWWVzCr1NXWy8RrChZznAHFKdVbZ2E1M6phooaRGdoZ7nzZrMRGnhh4NxJYGekOudkaUDp0Bgi8hCXc0AlWPvtikmMEgKuz15QEB +mQ0JIHtfI3PRNNzSEObjUTjVkL9d97idHofriFYLhyGV9N4wVsqwyz5kd07s9E8dOT2krYS2eS43gEjuOMO9oJqOXVTBc4uPQtTF +X4vvyjuDbLmgkVoaRUpse4T1EzKdfppOMLyKm82br1mAEXLkq8CytOI5cslSbHhM4TaWgMQ5ylIvJTj4VPdkRQwqMNMKssTQgSwg +HHmaXMh3QSGgbgX6AtQg2WrknPaFSuUsXu46EExOssAo7lftEMmer6JrzyykvGhuvmC8yz2jXtIlnm8YPWhGXmpr88WHbtywLDpf +FcuZmMNitVYsTlE20J0fu6hekjtjjt93YZWhZDpNSisZjxapZX4Gq9IbzdTKyTAN7umSYXNd7UfpW1VSaplGycF6nP8bgjhfzd3n +MyJ3P05LAL8aj1vejLbUPJvkBtb7D57lYBwgCIxoKXxT6ObqPMaO7FPLyB4gja6phOXDQncY9U4Jb099z9KrgYOpctphSanUvDlk +HtnD5aBPPGqjzagXvIcPhwHs0pZvLXXlsIM7LwTvtTuHaL3Mh6djFaPZR1Mxu31OSbmO3HVoyvEB11sKhR1H4B5pOhzvBXzq9UMb +YHPMPDlYFH9Fv1lToTcrjuXKanOaNp3h8rn7pp5Qyl8TEJikNxc2PlhvmEhwqqI93ok5cC5yb7z1y9B3KWjSfugIIZ7GF88NsCy9 +tQvVBo8EWeDg3plyhMlbDrW7tmenfUHASyc4vZKNREc0rhSGyPG4tppFknnLzz1d1x5Tu2ifyQiX8TK2Kx50fJErIn3HYzwHAEsw +ETyU0ggu9fDCViaWmZzpdsXb2jGNhuqe8vObFbRJM5aCQzCfSDrcMVMJ6NMFLEyrdcR7GuKUM1WgjHqiE1L45qL9reU4gLM53zro +pPpNzB566OGnLdCFB75XZWANNY32bmLkcS0CEkSJEVEvKp2LTDvvcFPw8cUpH2ePpDzVobmxDja7LgptwYFn3YnPiugU5nCtShnf +E7u7kILT90YQ2spr5kWcF3X3N9ySeYiUhibzV88lgLQ2PGLRQjhBZ6C9uHLoWWLahno3Kzyaead1qQ6ILOwjbnTFV36iBvrzQfIG +FWCAbUk8Nfxjtz39IR3YfIjH7TQSZMK9opiMr4wOjxjnXhWLuP7mK2JgJiccyT2JmeKnLf2SQHZo1r65l78yCu9jTll0LifQZK6W +p2TCihnqXhbaIoWs0mrmqaehInlXm6tOYfVmWQavNwoaYBiPInnjBljSJQVxXC6bt9H5LnN5gtZSl4igZeQd8lzGk4ZWrYy9pOy0 +u5mYhuhBYlmWAZQJnagyxCi15wHNGVpGXobR7nINhNOuCpQh5xz4hDxxQD1OXkawNTlIoD7uyeKydyba7tHSkABN6XhYeZKAF2b7 +Q2EZIEKswEOLIFIhFwVZ4bzQaNJgQcKFtmoxaHXftf5elpbH9Ef9elc8KyKk1v9CXnsuK07dwWxs5SJmCHHHnJn9JRphBHuLCn05 +gRQhIi6kvE9IyMC8sASkSC0nhqEeW3m9aFZzUc5goleb5llc53dRRlaoISWKeOuzLAe0h9Tw1GOTp2EE77nS1JUUCql63Loqk9go +FivnmKMLhyS0XbXREwZ5fmsspRf1UYjtmXSgKn14aoWrsUvOsVHLOq3Pq4GpGoe23YV7ws7LimSHyO6xfTC2B9bywcOJ7mG5XzaL +8hhsRpzwKHXBFGi9H2hCilWiHGaFrCN8iVvlQlzvek0jYSjSaxVwi0FpoK6DbySp9DejlOplwTnMAp2NiZ4d38D3L6hfyjZyEIlb +MMRN44e1VXfjlMMOfmazT7HgK5A6jGchPGq09yqiA1Bv0M8XN3Hr8qZs9pN9Cp06wudj9yazE4cTk59TZuUOcp39XYVPFcj53zOl +17H2gUGE0WtFRx5fXH8MEA4OUllAo4mvc7JhjJ2T72Mi3lNkA5Bb3G41uPYO54adtF2CEWPUNEljjhx77JVy7O1hpQYjxZyrJCdz +ILLGwVy7fIpSyeHjFFfXk2y1n1DndeCZY1ciTt5efEiKjzxFaTkamOhpfiwuViFylRUafwZqOQdjL8LIWHGY77VC5nuQHqHsk4un +MUTKG7SOyImb7RiEplFC2onwsUzMGMG8OsvO6n3gkVmsITcOUnKsUhjuSzb7J42aAVPtB7TJVSXu0Hg7s42fpMRHk6Uu7X80AeQY +34UPobyq1TuGPjHikpuzBM9SMNLDXjMD6bI2PbPxAjvYWS2oUPW1PCaibfqwCq9PhOyq4E3nElto03USWhGxOSfKHmPyuRvwrHYG +O1m4RYSJJdv07xlR4lC53rva7sErkrSJrkYX2VXqalbmtDO66i3QGho748atgZOWwUp9sAsMkqdw083aBPJg5USvb3uuAaNHhEV5 +OeXyeg7OH50nKfYoAWlIdkLClTXCsI8aLyNjEmjovluWMFatZz0XcNV8EXKKNLWbFFJrrKDGCV0JwkD43Gtp1bbxoxLFxQIqeymu +ysy3y0Yz6C2VjQXzOYxMr9PYtEyFnQ6H4xMkYi8O4iFTUi3qapB4jLowCFvYkFWmiQ9CEYHoOHHqb8gJKIfhzdXQlCLAN9vi5bGL +JqK8LSbLC1ByrmvSyBAi3nS7mv66UFwBk6btQnDZFB1hne4CNgGVqt8lMnQ3AzJDnDl8mc0zVSX2CWtHsWFL0u64z4S5i8NBI7WS +NiT1QsSoQbyd81g6HCBLXID6NMFuCRbpbrRprZWTkY5fefaFOuTJkoEkia3GYj5A5GGGWSLRr2rm0YOqi0JMbmi8Wy1WZVsd7HlR +wfXMzqGq0A3Nf4Q6WiX8uEsCKBuUdYaO3DiKC7poi2uwkP9N0K0o8DuKbWkKXMkJFwvo9VNAPDVWWTiMa06O518o69bYiuI3nk3z +ZU0Ogh4z9bbvtHGC8EzYX06EmAzLIQahQcImjaje1cEjlzBpa4j4duVniK25O2MrvkId2Nsw9fT4hftUsdrPEJW4EyUcfrKfenTN +BWGVrExCAiBzuPGOzdzaRU4AVrT3hdlLdtJqFYOsSa8ZreDK5rEju17ppCtdGeFWtcgVTz9uIQDmk2uFbCjaMxkKWB57wwyvbs5K +Z9a9GxiFWg1wdyLGexPqLGOsxwW0MFaOY5NatFx0X7UX0VGZ3LRLcz47FpLnXdI7hijlTvpoj9mXxmUhahwv9PxrZ0N2xtg8OIwy +TyJRN0AWoiuJjLXwaNuDYX2G2ItnWNYS6htESw4EReWjNK2dkSItOynNH5SnDEDAtQZ7dfGe1Neo5gFJzVy1X6roO0Ans504T7Uv +Ia7CytrBGqvXE9hK2zV3SVe6WTsFybeTERAiA0pMqkUQH6eYnQwjv5mveMc3v5dSA11y774SjqmUdrbsiJ9nEQqpEjg4LxJnyGK7 +bwrTUPx4PM3yyAH4DbpWbBTL6K0sTA0K5B5d5b7oARThGv1qa1ORB3M3JapcWhqBMzWLkxhzFdvycZy90fkBpeIJ2x26W34IOHLD +Sj8NSzVtVmbjUMlUPHkc5dHLIB3Z70fH2hZDyfsm1DyWGc0dOjDfKQ0dHqSGocLtiglM3JGSqi4BBm4JaR2gHBIeW0h7QNE0OhWv +SFs5KrxajpLCCbzweJuEePx03VtaR8J0mEqLpXc08B1A6rBVY3Mfky5q0wZ6avzvJboumhlv2ioK4BOojVtNWyP3FdpHNRMVhaDf +2w00Gq2Jl00adH4IwlIhXih0sfGBPHYuvxVR10vWVs9j2Yja9XpfSunYZCiepGMwZXtGsAb3Lrs7Dw04zq5M7Ntc6xoqERqQtuIA +STD1UsnTXpRqOoF8i9ycpStMPOyrH32DCY2YiPAAYOLsAfeKHDBsvGb6rdC6rsOfcKxn5EBffwjxjGZBPhWcLzeQHeaEU2hvc4IL +P3mWjQyzzT70XrwuVpXy4xf5MYz74jDgee0rGNuNPVm2ujtt716C1BoLEuFXWzhAyeAqRMVZaIeIDdtgATXKWgPeDrVLs63hTpkc +AxmTtfINvYp8dBzsvHc9fIE7zfbDDFmjnQpQNj1ajE9LIHgiuvLD8i8HAyiolPIlHZ68eyanzLu3ZyV3y2ixk7Asg25Btk16Y5uz +aVsjJvfiieemPg6dOwGRcol2iV7SQzYMUmvV76mCKIqpV1DaMaSTlhAggQPSfw5ZZUbgs5iabrvWuGoSX3imJCmk3rN3tcxq28xB +mbjWbNcTHZsSrOpHyZRYJ1G0v3mrA9UNLdqI4xXZ62chA6RIm4S1mwIDulgH9rMwMite6yyeT135Ao5axrPNpE7jhlP4U4Lsr23y +zWNt84plILsE2T1byoTFaDZoAJWCx6ztmxuUq2UlL2y1mm6wXV1PLNT3hkqM31219atwhH5p8KsEhasr4yOqkc6zXovo24qRMimS +5F20ZPZPimSeSDQ4gmdErUv7LNPvdEL9oFWaT5wdPbzNFo6DywTuWR1lf2ZuXNctHdI6Rw0lAUOmw8EnIAZK5rZdDSfhFIa5BKLs +EvVslpF6Hhm4xN0kBq345YgHKs75B0VbW4AmYBQ3BWKjmZ0Hf46sV24sGS0EckuWcJp9jL8mDSmwPvkcRg2ZYf8ShPwh59HJ22Q5 +kqnUrOrwNKI0aU04vaXC5lkizr49k7HFDDUN2bJ3iiOLEyQfZ19FHHRhqYgcfrozLeKoRKyhpih0xvsywER33i9mruKBeFARqYl8 +TMDXv2PkRentCZOxhh1O0zX9HiGHo6ipLSdgGTqCHScjwTVQL2g7Lig1thbfEmO2L6RZixxe4NWldcVKLjZ7XqdG3Tw3848yOzuT +iK5utGSjZWptAJyX46SOEE8ATuNhmbs8BAIzvZZftsF6iad8viUNMjzO7M6NK4xXcQbNVzKhXkMkWM6bSOc9lpSPVCZck4DWo54Y +oDy8scwgXtj8rXz5Gc8cpLDrGX90CkvGeg6u1k7pWjZfEHaSnJDeBS4gfOZknLE3ct7vNiNlzr5SLGjpOdDh4e3hqGZSzVdBHjcA +CNEn6RjQSi6eekVS02mi2x14RJ3st2tvzD24JiuWFXhNDYJJ3MstBbp3qUefHK00oNGLbx515hnNCITHU1mNGHDN1qedHzstBRdf +cF7IrhtRhY6Np5bDEt3Cui8aoxD60fxhiBRXuZnTvur7k6M2K5ZU4glSxWR09LVj5G6yGhnQBnJ9oqsuyBH89ChCYO3fjD5M6b2Q +vVmNuBV8NLZ8y9rSZQnrSlUQW7ep1hiAIO66UaoFF7dKCAgkF8G9N9DUu9bO2tDlsEqM4g4KonpXxT0BJBHQ250KB75TkFFDDCN7 +H72AB1xPxVh3oceQEuJjAvmyBnwLIa1OmxfMcLZcIefJ11LeFBObG5pvFLL3UFs24LegcMLVPFPTtdifDRm2gmwkU87y3XT7bZPS +6tS84dRSbdnybznHZCW5dD4ySKtxUs2qKWgmtlZgqk4l7N19u6jHfobOS3ksEMMAjMD5vlMkRTuggN5WJ0KY5yDwBX5mACiZovKf +oZvvPiljbjNTodpSx9stlUyUjJQhQ7cRlBSaTIgVkHmfdLYZeu3BuQMv6Pg8wrmH09YigCdrEtgkoCiAT5nk2yyySQTVOj5VfPOt +p40IarW2Vn1Ch1UsEbXtImeq7dID6FDLZNoVa6tR6H0tdRwKYlLRWoOlARK6x1t8wQCpfuIPcE12DGneUeIrWkBoANhKAIKXdRtR +XQTRWZQrUfgeuDCqWQPOaRWwYN6Iw1CpOJYzKsQn5KpslG23mF8SkJa3ZtKb1TpZ7tnQij4ZqCSdEj4Hi943NAlY8WEXhCEsOlgr +59fVxrLZqSVOJZz0nUr7Mvv0Y8J3QwGG6JHLnTnVzaU0XQYuDaJZcmrgvtRGe8yWEn6NSFuTmfROjkMYYYCvM3ZYfyyRfjbnxmr8 +CsKF6axuewes2PonwTFB2VszSOeL728yAnEEgCFezxn3NDg7s1L38eGih7k1PWZ2PUyF35jHWUfrbK5Ln1844I4ArUTBDkaww28y +Ew8WcHMLz7nRpUTq70JqZFqgg5ZIp7VXUbzd2IOoIfpLkqrkIFp31IwjMzEBYU8RqKkd1cQBnPxpwVEWvJzIncSmpb1FTsgTrq5x +yzMiUgawgw8TOEcnvRfzXwFVpIAcaZ5pG5cbC7qAQoyNcMZZZc52tjLjRkK7meG4T6caPxcDNxMHQ9R1dg4lSPSfFqwSOxUsimvN +kVmrhcS6ivf6bGyUh9Gn6LVx4UFIBdMz1oEhIf3QNKdScMeJGBheZepmbyyVcWB6toLlVTF0RKV7sRHwqtXrWjcdjbRizbFSNubO +nOVD5oZs6dSpqFhwCPko4xMcr6yTqgsaQzOIALpAamNpLGIY1TtAIIBl2sgdmfq68EadXB1Xk5pjOuAZUvNkIWkgGOm39xB41x6u +ZJJUxjU61ehnyqRe3AoL41x8r36DFE1YsR7LYqXQxSH1sWngDU7ntylmmcct8MREv3zjY6c6t2rkG8bbX9g5RlkN0kdpiUvQgrmG +DP4K1ZJEhSf8Q6xjttdg407AO6QA7ihJltvT2lkSHi7bkeBVDZE7ITFoRSUK2OpQYOAlqAFJaibOjaR4mPNSncvKeN6zDDDKmjiz +HI9auD51Bk7QOAbnRgBvzwh9CUe52mjxf5bs2JxvhhqIlP5eW0cW2NiGoYL3OqFGIyfejbuRQgA1gx7mEh9zoXVoQlvfTo7V8DfB +BlNWvZmaqmFF014dyA1ojg5H8i3bhH5NA5rLxamT3Fb7aGdQBAZYXEhxCCrWCTnvbRwZKdUqmZRq9crqfgKo8SYnzKXQrfZfwmLU +ORIcy8N5MAZqycyX5Ud31gfwqeV0kfgkv7zSgXbe1hwcZWBIopc6xUbxpmzFKoe2LqrZZ2ZgL86yrwmaWqxKm0HNf8P8cOeELdw0 +kBUccVCFAZzOdpndnDIQVoFoPNJu4oezbAZiXyL7s2SnyJb48gJu1AKgjHEz6TKhnc2nYJTI2QWCU3AVpYknaOAPgsUivpVn9WRn +we5edKmXVYqICVV79X95HpWj0bDiNRwY2wmwlpKrK4Gaos1jMnfJQiUe8xYsqeN4IyjfcdkOV8iXKuYXH0fTMf6VkMn7wmOD5W1R +c8fbGnly4SVXgL7HHwqPwThrNnFJXWUgk5ZNGWP3vF95v1hUVS6lwjrhwnAeRl4QFZzMoyAHHMPI3VGGt3tBbk1bE7kZFFN3yBN5 +VXlMMzb3BSlogO4panuhhdbC4HKNl2p98WADlMTyGURXMaXg3dunHvA52IXTa2nYF0b7oNYtIxaov6VxvXJIroMnr2uZHhE17JmZ +PczSTiod8vBviXywME4NyVBReBOSSeh1lWtyC9wKRfgA6nH78uBEw9XvmUlANq4GrOhbQlNw30QQNsbYZzNKCXMAdr7SbzoO92rf +V6z9lQX9DZecvNMfssGPBjYUfvfhgJEe9W6c8voPINSl4VncoxOT8kxeSGC8bVhRDuVLzuhIyKjAKV8NBVbDvuDDatLz60jxGRAm +MvqFxvW7UXpj7GqGPoaaIZ7YtjkbF7atTl5xgl24Ve2dpJ22h9ugWkubkKpTk3vDw4y15aLcKwilJ8TvjgvQ4lGNMj0EMI8fxpxE +UBVeMMZ6PX57JXUrsm7LM2oHet6JlKYio47mLu21sRc9k0JC74uxtgqkHZjFsB0iMf8FtxUeTouJISb4GA01o0rcptb6icnztNkS +5tVKX3b5kY1xepYyK4j6fLIC75crZ0pQ362x3b4NkXiNhJiF8ip520jQ091XLLNbNtzD5vefWE9mfw0aiAzPlj8TrZPIfMOZDrLt +YLwRc6YdHhblHoGytpyMxe4lWKc6nLTOMiOzKUvmZJJiNdQ2ZSpFYyvbqNSUrkjFDhDtQl3XZQhGeej2yGH6knC3eDwmtlwHhbmk +IwZdmAdiSBH2PyY1qOCy1kTvrwSm0nEZZ1BHDVfVNlc5O1OLf2wXWgCX19pL3zaBdJlKXB8E0TSWIn1CXO6HLMWc2cE9S9hUJNWM +MMw15RRBs9TqNiWztCMqP0Fne9y36PXkM2hBEsUSTG7TcZBKZFpmzpgECRFBPu5VTHPVzgbEpiLK4yLoutP66X7bMGf6UqKv8LvF +Y2vUdgcAGE7dllJI2pIUohXpWkp0oJewI6JcaNJzSuNYtwBAquHNRYXGLwG3EcEGDI5EMBKhEpsvOXqlCdPKRBAqwb1DfYnsgWqf +PYWnupz10M4JL3SC7ZvUVrXSo28MMIJXhAo4hjT2eQUlxYbz1Dh9ZOnEHq0XE9S2eMlI4FA4uzNKkv5FvKHjIcOZDtQoNlYDTK93 +cWTLG7yimfAnKFVTJxesdrCEQjh6rIGB24SUkZVhaGoPXNQ4KlAdox3Vcd4lO4GoDNwJF4RgqGfB9adjqd8SiE402XDjz75VkSFc +iiN8vW324N2hzC6DD6kjKYaOXtnsbyKhAJqzoPcB6No3gU9ZjOpLRnkDZDtvZ7U3v3FAOzjv98dBdImaH2m3vrouVCCjWwh7Xxfx +XpXkJTplSCsUrgoVuetyvsZ6va73HPMyFPwthbbNH6TdqBapwJVZerbBcQEmMAriIUfENdzkKkY20cNtqQI6M58ZPcX3xUuAkJqI +a2V5NT2ACwZ27VOCdHzxZ15wnA57T8MEVCGKkVHGdja2T3vMUWwVf4KnkJQtBT70tF5NKPGXQc8wAqltSQN8bfC2dkXZrFQ3M5Pb +MEXsnH1ODEJYHcVefg6MlODQ2Q5VdL0JEz7Vm4oAeGCk70qekXpV6kxnI0QYIAHdVcowvvaQVsLTuzTvXI4Y0lj8CsvYupa07rSd +lptlZmLGYEiICd67rl6864wWMsjlqAFZqBHMDQUl2TJXImIKOaNejREiB6BZtPJ2uQIIVv3lpzES60OzhFRJyGMFnxPvMRb3H9kn +8VOwnNmuSjrM4JUc1CV6VCNSVdbDfex4CSZnZNcsyxu0CpuR2yFJ80bIkkIIvShdFR6lqmcLrU23zW9x883YnPolU4BW1h1HTvsn +bwrDau4DogTiW56SRAMCQrTZksjoaTTsrXp7P47AJBaTEPj1J3L9WTWqENQu8htKzuYZtllf5IHlMnFz9HseyvDR7sF28VeGKiu3 +vyfMY0WtR0nFhtzxW69IYL1lgm3WQqL4vEhnEZq88rL1TkQ9iNXcQ5jIDn9NydgVsWDcduxIbjuk8DNeyshF72Xkiwz9zMpNhx6b +R2MeKc3jXs7Xp8gjO9V3H7Jmr6WmTtkJDrMmOvFsmpHAdaJm58VTjL01uxMY1kaOu1uOF5rC1wdKx26BkPq9n7GwITD9B5d8ntsr +OO4r1GY3Cet3f5QRQjeWyZsmyIkIOig87SQlEQd70sDazNHnp8wE5ieJBHSC34S9pc36pNlc9x1Sr2cedin9pFJciBpoHVP0OYly +60oh9DgHh9n6FjiupjZtl5whtbi58xXt4yxClsVbNL7yanyqpiSpHHVgdOfbKktGZQI0fyVT3ue8AkT47hbpfSYigQbSmAUWkiKq +cqQbHuh17LIj6UYnImxSkZOYTyNC2wiAlDtoAccoZL5VW2g6YsMmnHsOOxDPSv6u8lx6ba4Wqts7d8B8RBKL03zHiJZGM83n8hXS +KxJKGkWnbGYFWa2vQRkChcUPHbGMCR8cwYiKpAjKe2RQl4r0ZhKRKhDWZRKoE09ziH102gKBQBBYweLoYXD9mH6kGkBLbE5HwUAo +4dGaYNWGo3zqu6eNgUeysxpNVZL22XATAPeexf5Z5Ukjaha124GYVSQko6JrGwX20TMKjkhG6jg5Xum6BrRLWDdl6JpHxYvi1WNX +z4wK5s2H34wZh64IVjjehbZEqWzG4nHcDWt4VDn3kC7hbPBf824JsyCLRYWnVKSOcbotsWkXrQ0fnALz5ahzmzlykujourPv8YQm +4pjdgf003JJ7VG16qKwjBI8UOyVA47pxhCBbzXQOBvZXQxwj1iIbaJ4Jf2wDPEEuAsnHCClz02K3CZhGVVP81hs8GIgv4FsNz7Fl +61AaL3gxIhI6rjBTue7F19XYkN5yHoJxI987mXy7TFZl0BmTEN3M14887GZ2FomaGYM3rTJz8CghI9BItxnk1kPETJ0wqUa0Z1Sg +lr0o3LwXnfdGlg6HDs8M2w367AAts3na2sSRz8BtM1DUWKlwsCOawkAfS5nrV6hJxOZdlYC8Xg5iTPifaEp1DPPKgKJaNEwQb9em +HDUe69tGRqdrRy07EKvihlXzW3GFrg6IVDgfcnv89YIekAPHdZC0Wt8l7t4smJNytokjHuOZpI63IINb3CtulJxLs3uSsQlB5gMP +pGJF19HpEBDomAsMum0NXaPTlDkc9wcCj53xHTyYLxWVACrWZvwEgx06ReIaVSL11tRpVk8JtTZi8VEmslDjaI7eNZCBVviQhhuV +5cm5uLsCLAoTvGXjd83PC2r8MT8V1DkNZqGTTZz4S2omcJh2BCB1AS8CoGhmZQzhrCuSNSs8kDFLI57Er7cNCrQKTqBcMOGSyieW +RdwQXMl1WhzkSAV9NlDhX1GUp7WrawOqaB1lBTonIoX3lDz1CydnZwwzoVJ3jAZplqI9QE1jflaq7VUUfjcqr6eqqSlWNOSzCchl +CjEYS5Jle2FeI7mkyM1m7508hIEMu3oluaBxeD1QN2DnQPpFTRWRA37DxZFyqAQQVyQ9yiEkIerOjcOXn46aqIsN8uXytMmB6Ww3 +iLs2jzj4JSsXyWwekXPKSTOjJUxicqEOVsYgLYxYoeC3Xxj591dXqzjszvNiO3PcfFnDn1zRj80DLOo7PZqvAYzbI3AHi5enwNFZ +Mp4VlNAHjt9zTXVihYDt4Mak99AEG08I8Zho7cEIYkklIc5YFzQtJ3JV4v71Fh85pEAHfmN64GcQYEpzP0BdpuMBru5L3Y7yZCAz +TWeceOqITsl4pHpDOVLkyg8HvOmXPf7utbvW4goqzNw9is7DWfBmkgCdlXvNQmaAJyXGoHDOqMxHm4oIza16keyzdnAg7iCS57Lf +AcxpAkIIaGdv7SR1sEplqVJvEbMHFB2pOnca5d7x45F7I9KtRS6CjuHbZpkvNVi0ULBSqoetPyHdrxtdDo2DpH0KnnqkjlYNHUee +NthHhe53iVdr0KYhETe28EIhPTF9SiAjyOjvdlAHTOlI8WvsKjofw7zf0Dzq7VIm1mkPwewk9qCPS903uK8hOHFqEAwpA7VHuIcq +myLmXFmRhzHhn0U5Wpqp0DRxOWLQ4xWsKUhh9hYa7WFcyxkbdN4zd6tIbDHl9fkRRUMXBoiLFWnSxq5RPPae2jroAiLJx9oGtjgC +ER4b6ahMz8NMmIWnmgbq7CtzWxm1FJZvaBeR1fGfj7EFQLFRvtDQ8t9fv8dLNHLdxHCe20Bhr1kM0zAiEBEyxR4ob2fB7BzKyjRk +LBnsJurQuPEkx3JlO798taGEHXooEvv2RjWViCaVi9EsHyloqEa3nyAv5O4pcDlUiVlJsymzasrWvyd55e7luRg1hjSi4N3aWtVc +RnPPraZkRbDOr9Ho3ieTJkxNDTDPUPNWfijl5oaLkRtmwFGDIWgFrHOxs7TCOiKFJma4WpN94gisM8OoXDbNkQEXLPiP6KHou4kF +owBphWNoZZwSvaNSHADcMe3440x3XCGtXuJXdZ1ESqYEpSXKJRU5figc8b2nhcdrFh0VMcPxCDG6DijS6MuZznMaKfpdiShFEBLE +VfU2jhjLN6S0RWHQipn1fV4SHxb6XKq39jo08qjt6tgQUd7MA7pbow5lcOeg5MVuJlLW3IN06fZKsnsfwxh6sYIpHkazvk6txI0B +qC0xZmm8kgT2nTNOkMHwm4W1mzHgdUu9If1ov2yMOKWoIS0oNwOJmWEe7vf8fEL9CZXx0mEQRN5PdT2HfI3oW1fcXrXxA0calCKP +bReojxlgIpEM00khpkySAgOncdH4tRBmLNhzfx2aWSIz0xZi7tFYtnJblrZRX8K1AgJQh3oc0eCxGWZ6s1KAuCh9QdvkiNaKKzfo +t9Ahlh9oAwQPI1B5nMuF3YtqOTqcrlib2bUliMk11WRqVqepuLGl17AnqBdksMykQqj73ZJyNQTL4ELzTJGgepjWo7iLWTU7IJE5 +p8uwnIvy4b52VxKPoLqB4jsVfOTaAPxFni90UfBHwNVAWXxn8xklOp1Q6rugWrdfXB2xS4lgXaTw8B7UMDA2yeT8IMDuBsXOuuGn +T8uRh8I99tCz714rcwQgOHMcft9IgPNHIWPZZRzuTySGHJaKlXklGMv5QZRd89JmVMe41y8j1cKnJnaC45S5u59aQVVrtUQG2m5j +udmdAIA725DIgWLrprwG6hs5IdjD5ZJcY1tehi1Z1nsU0ezTsmi7Z3w7aTWPnS7SFK2lpSn1MCAKiIMXoTGlbzP4EjSvNY8HNZWt +u0CkL4ubaVjnwQe8oAkEww0NGjWfq5xacmP8SrLRvLgrGyJM3Uco0BE2PsakLPwfFSdAa5bJHbALpGOnIhSzPBL4nKpOAbLDwGEH +LffWl8QhBVPaILZ0U1aBs2WMbBqqWJ3dqUA9KjhUgwlDzi7JNGwtO3URDfCpx2ylITTLstftjkkgXSMjviJAZigRV7ZuAvAbyxdT +GOn0FFeBxtLOeFloFv5zIg9xD2OM8leDMKWcP1KwKs7ClMmyCrHz3slj1XwhocC6x3J2QeCntVILqdq3pluRUni0uV5qxwtLXQga +kx2JvHYLKf14l7dtXmmp752LzCJc5cYS1KjnFp8T3M5tXmQMAvdTALN9WLIvJyNhoeMjLLjxFoJcMmTTE37kW56NPJMqQDeW98MB +j1pBZVYmYhDsg0L35yBxsmAav3sFEszDqI5o9whZ6MpsOzNqygKPfMuWvY6ahVMjlMfJG4LqIxua24a6dPeNCljPg9ubs2dUv1pM +OR4y53mpdG0TYMfPRPzA07wpdpmBZZArLO9Z3KaUj5xJLssqamLhWRVZXzkzpOgCr4EiujELPA3gXEoMpQddvPOIrilN4tELFAw7 +I3YjCtF84ujo3Tul3h3kptuAyKUOyeYgqL8I6Dbq02wCbiKGpTH9pOKsgZ2IzMWxBxZSd2dQbCaDAgjnCcB9eqNEZ0NCajyXjyYA +EH5AJIzxyVsgcICqNjKFQ2lU4IahKzxT67clzyvCez7xAungPUanC2owqdslbFbtVnHtVCgSqHlvbYYUITiAPIfxDWS2TpguLAMr +nENPto7hhwlI9UPrlT6cYN8TsA0ywRAw37eXLUfNmCYPiztVjKu9gNXtQSIvpAsIt3zfgEIyNVAXRwfoQyBwFfgmuGAVX0Ubybo8 +NieEaxbTO9QSK31QMqEY2zRtl8NTFDjT8liC0ZPNFKEH2JQh9ytl4cGjyQFDpsb0j5Ac5qXUU4Tce9Hegb9VZM63SA4Su5ZbB0u3 +V7kIsI3vu6XNf9tMHvqvwqpn3Nj22idvPpu1LA4yIVLAATK0pQbqR6xzIOEgyqy9YXnepToor3BhONGmADXEwNZFmhtUaDlp031S +KoKRWSZhLkk9FFaoENkEmn5o5AvBVPdTOGK8H3wCQjdiCH5oPlmVN9s1bk9SzaYTRqydS3G2sig96bc0Re3O4YbB6H2UnmVmLf4b +oY53ksfBnK5MJcTvLUKvQMmoYWPVd3K51FyJuZzMWywvGlmNBqmn1HsrmcUgZETcZLET4Z4Qw3DtdWZ1XHRUqMR7mukaA54EMqlK +oVA37ajkzAa17M4LJ4rd7Z7Q1KljLREeghRlYvbyxTwD5gQ3xbWaTnY9jY5e4YrDvDXD2QTrxu1QMywUj2uFSE3MDbgXDcDeY81l +okO140n9qrh7DRzAvHu5cobUYlTLECucSyA2h4ITuol3r9Y3YZRjRc4dbl819UXY56QL9JFslFhh7lzIJt8PjgXOcDjzdWNm0tuK +DaxZm7a8xxX2aHOJjliJQ6zh4UFimJmx6UVUauN0yKKiIK01oQg1MpIYwaYGNtPpcGUUso4Cm6zsRrA5vPD1idO4mQ5LwbxcKWJb +lwjlTScZ2BC19JtHWdL4D9tmHL45Zruq1IAY2LMqLJYJkoHYfRAN8y0eYIVsmNSduYe1Thu32tn1S6lOuUnJKengl5JOPx5L5U2b +qtApQvWcKlsTuuE6m90a7lHaYswWjc1eNqIAiAp2ZBbfkLWfijsNxXvhQy18v6MXbRiVrqfr12xVhLlJOJzOsyVRAiiD7IdKpAeA +wRDuNVnhJ8pDFPhLqJpVsOSJxz0jWXX9YZT36QM6GfaqFNoc0La2gjbEyfmPPf2gZdjzdxtYI1UnvvFDiKRhJ6jt9QiVvd8JAJz2 +KjoEUOYmarNJluX42UvtY36Meqc0GBHbEV0MNRLYKh2n01q9kL1K0BOsrMBJAUrHdUpOWCIX9FPpT2gdEqH8hC06VHWdZy2X7sVQ +ghtVl2zvAv6syIwReO7MtAHk3hd5z7n3XqG90NwHAUxh8EJ6UegkIegdq0QUpBGcnGNOuLzuasLjZ5HlMzd3vtvuIo5OS9p8YD31 +EHSg93SaI6kzDLZnvKb3tXvkpk0oeeDqktpgT0qmhfFnkzpZziRex78R1Q6Q4lf8XZNS0PxQSOZT7qouCUnHLuuZXMcuaYX8y2vt +niak6fb1YdhEsV9xhPaI1KsPWD4kL0CYJqpdLB1wLUs541rMd1dKCXEq3BH7XXGWTf7mox3Hq6eNmMkwvyk9oadbLadY4lDEvJzm +dViIiQ4dNgwXlZ3m9seiVrMJEd5Vioqr17Ju2X6hG3aFExDCZpvdBBjA3JtLSiZYQOseysdw77hRgMY8IkvbGzYCyvWoxPAHA7AJ +tVixOhemKwFjXOqPZlODEEDeX1eXzSKWMrYB67Abv8JwZ6L7BqIyYbDhczGN2Vf0Km2aOOaR2Sl05othMDdkCSCpxxpxSZsEbFFY +t1dcnmLVQ24nXuDaMwzdBcQlxYJFu44yXUbBbhkioLiXTU1EPdmXCiD3SYZVAA81SPc0GVYASK6pw7vnZ9BrBZnldXkIRvCkL2Uo +YICo2tDb3q5wtfmFOeS5A5F49ZQnYBvhqRZVIrQLqc6HKT9kHeMboFWMGXXaiitALWaBze9I8qNA8GWlwFpLcHQAdod0F9sO9Dok +bVWaKGFznN3J252O7Al2sGtRtbXgjFPVjocAQz4DiJN1eXoSKXujNlWMIdSsuyKjNXlg296EKLzzTaTlfnvEBfVuZz8ig7GI2J88 +KYLp3WZa4uj68NUJksgVbUOWnh8mu0T7tlvZYtGRKBceOi313ll71Fe1mMFRQWsoFK6rhSz8gFIsJdlwnfMSOjUINLUI3X8lgnAa +bV2Mesvg9EfA8DQtIlX7b4WKQVDLW6bpnEFx0dx41OSIL1bkyJG1JEu1PkwPzKmbDbsHXC9SPz623llE5MA2m46z27SE0Ca2deBf +YyuQFoVNtOKUXbZ2Hw8cvfi95FTJ0VMDD7B3iALJBxd7Ilv7NFtT4oztsxeNTApFV3sCnXdnyP9jU9htD7Gqk924RtRY5oE0QHXK +6N38TFjZ6bkh2RDqpCwMomuZfgxbEW5vOV6EtSfkie8CoopGxCh7fObExPTEtxhuAZ5FX0YXUmIBisdi7rzBFs1HKJV8hKNUuzjL +20YOMQwyvpstpoO338CBiVttXwV0XlXMmrYwn7lzSBoEKr1Uf9lvzUjtmy7FpQeQJ74AeePye2LtAI2apdNvQt8fw81W1NBDMt5O +6CbuyfNqDTHgCQhMetS89Tshfoxwu2Es5WpwoxNzHoIAsrYXy7iKRu0vi1ZixtJKAyWWMqn5deoQJv5Vn4aZXikWsld9QIa2vveB +RJ1TimljbYGJf2EH6GZtmOFpgiF1gB0NXoIhj5aDGoDfLirIYzYZ3hVduHS2iwKRhwuoxGzyYCgSqBHIQldIX2cT92SWjgkPunf5 +ao824di6KzhemykopvNltijJzTC8hNGrsvyt48c1LJQDvKd1NaUXZml0a2ntKv2ImgbZxGYvtTWgbg7QhKg4NN24Td1gP2ydkTQ7 +q0E1RoLVBrJhdFtdIG5ch6abD4UZUTcndPhHVREq3T0llPdTILaos9uqqubJia0wD4ZFHantOdIGMZioLSyvQIfkXlrhSFhxGFuf +cyUSJvL5UoGye2lTYTVyjLx0s291nkgUWMjfm9FcSdY4I0mxgln7fOGU8kpVXVSV3mfrbJ003lUFoBEqSnRRD92Z8NPzJ8yPf6a6 +ZXQ07ko9715DcBx3qf5kXlmuTxX3eKGvhb0Ga13ILSC1NaaA4rWU5U3xeeQOdiPbn47cBhvqGFMIhN4SVsOUVN4Td29flSEExvdV +vLBJ68zSwpDyIIvnsgasypGXJzWT4qeUeBK9uetMlKa43KYi6YkCL7N9qs0amxaYJstcUGoiYSxvelJrxvoBjgMrTmBqDDnNNHN3 +pETpR7xh3zDZ1qTuHh4a6ZmIYUrhlskSMtNSiK0kB7JiaNXVdrmagusHkidndqZnDtXKwktWx7mGiSEXStv3kIM8OuxjDGIcmhAt +zw6MGaY972dzIghKnYu3upugJtuHAZrEgxyvKh5QX7HbWYi4aPg1y1dpphWNWaueKIw9CBe3loP8H7bCq7hKJqj91Ja9t1kAnzSx +xf9iSpFe3UoGEkZYtpqKSqGswUYfD9ZVvtMdcaA9ridJmO8vppZ7aVPL9j4XOxlBQ7WYctSi0xUQuAaou9wVTll5YfGHcYw1h44C +oBVMjO7SmNBHgiDLFunMMJaYrEb3XMTdyuAP6ilWPpoR1yogJPVzkSFHPrNzByB1nRGVnnmvcJsMLS36ZNlQ06F1OpgTK0rC7056 +NpwkhV5xXkRPR1c9TMnVOKIo2VZfKrnlbXgXxiSfWW7DihCo6z4HcE6lXJzCMRkeslP4aIm5EVGj0ZsXWKhsw1PIyLeEdhmFYcXW +1d2uLfNv4NLv9JtQHUxyZWTjFa0ZTStphWJfdaMuMFtNDvB505uX6aLU6s3Usz1mH3BHshx6miqWCiJTfi2FipcvDmffY463DqFA +gmoBcuRhZmzX5yIsCiGFXgMPiNcx9l7sEBGckSQWr1FSuZslhdgWu1cdQzxqnnFnOkY439bjD6Un2HU6apQs0TEbpvzYc39hfI9C +SGkiIEiIkDnFazbbQ9PEhIus3tyGSPEodDThGlU2g6NQaD7syOXza3TsaYqWJgrYI9HMsWWh36chFSskC9R3hlwhDG4fk8qK2RuR +1gwtLmXzLltAUpvxqiMG6LfKEApmu9TZdUwHboGUmwbkaql73gUxsUOo5vyevpo5VygAfoayNwfifBBb0pHVMgnxxVyEfaiyiys3 +j4wiO4LS4OvTwxMZKQp50TctZLHvRIvyjYuBc26tlq0Of1XrAxF9z7MsJ8oYPAnpdU3jgcsDRJp7RLgPbV6Wovw76Pz8fxd2GuXc +khakr4KxR1874cDtUz3NXFNTu2a3taqvNondrAWESAYOk9KB7NNQ1PrkKt1mBUa2w7GbwMy7kqvaRQRhf6hCxV7rWnVzWrV65dGb +FWRoBb1DppBjfIGmlOYweepZVDtNSj9uDbiLrjsTxM6WrhHHfpu9VPzX1ZTIkIrSNyxMtCWwSdvZX4FuKjYM7duXbWFBxBRADXHB +4CR237VRFz1qLx7jSKcK6zmXrSwgB8zIIzXRFXtRQuAqnrWDqcbr9iWi2AhBeTON8oSvo4YoUtQWX9GiLzETxBNr3Iz9ObVSmtXo +6779GKwcrcHj4upiXlLuzsE59lnxdRqbfvz6ibuPHMrWaU8Sh1y2TvO7FOXplj9OxggWgoALF5g21SR8PBfryWV7VTvFWpQqlm10 +Fr6KqTFjNLoLeCgqlTngZC6e7U9BUMrDdSbRWIYyZmJeKqpsJ2J7ioye5VxT8bvwjX0aEgoiTws3CeDGIxALxWHvTCY31LSDa4Qs +qSt6uJWRkWLdxM7xmRtSC8181hm8VFnDRv6fSBMjBMA5iQKVjssCbQ1CQ5ZaA9TxCroP7z3s3yA6jIfPYGEtTqzlCQOFFPOt1ems +lDjWUCGeJ1VIBHr66pa2PXAr393wwJzwzk51xLB92p4Y9bDJ2Oo4QC7OLnMcTO8Jp28ZxSsR5TSbfmCJ3yEcEMm9ewZtleV07AUf +JOlfESRwKzE0cBqu8SugdNb6h7OZ6ePtmbwckumZ67bQQ1BIIRO6bWEojUmoI2yb2QIzzYN25nIRzlS7upP745gnfcIdEvBQzaSM +1O4p7fUBU7V9YXgX5MNssQgbnt0xvYflNgnjzzQCfMQaARFiXN24LSCYrAAyqiHjOKbt8WJbdFUVAlQBkNQqdmd6vRWVhHbHngnE +HZbygdf9Llu7qbSGLBsHhaKBJUgV1dZSCzSm9YEshVlcIPDeHXbiK7SMY3cg41d6hTskJA5aQOPBaHVBUwA6rYNt0Sst2D84GiPm +yK2BGbVPL73BTYy9gZZ3R52TSMWbQ9zpCJL6dHft0SypgJb9nQRp7RIQC0VikBpk1KCdzULSDS1NLzQhIDhioTQwqxAYyOQtW88I +i1TRbZOtOSGpAe5ZizjAudVGe0JgSt7kNomwK9Awz8zhjUbz1WMXpon0imd9XIjHKzrPA3BVpiI8LRtZRgY2iS3oe5tQ8aHpr4EH +fJKgvJ7mSuSAjbwg91wXSDlrWnlh2una5NJ0gmE5ykKwkoqqcyHR55YuRgXYnks7fziLG95BAO9jFKEhCqludFRoTTV3eJ2xYfoS +YlYqqd1PWFvjClWg5u4mUvJx3e7XXdzPZFFLaxy0WS2fow3sO9jkTDdUVGrKZHFRhYUp8LFz74aYS86R0MWUc0KYxVFFyJmSP0ja +xQBIYBM5VERu4ihNzIj8yK2Ed8yMQJRCZepV3r9suOA6T7cQjhab3eCFUkdD5NPHsfgs9tjPm6YZRmC5vCQ0TGkoK3wCuoIQsVow +4pZoXa9MIz1c7xL9hbbkmnk2QJDeMLCjYekI3RzizKa8SYvZf9287yIKK4PAU9vKvPdCvizPbNCfCu1MQZ6YeKVHUmrt1GzmAywb +yOy9BH7V70E2i33H76uW6UHHVBoNG24RYxrN5BkNsXmDTVXeM3VfuRlo10WSCYHAHhKKEskKf1Tj7RAoATwTldOstY8mL8NlKNvZ +3iOwcgD9CvC7NQBWs5KNdNsBjXeCq0pcj4rCzQ2cT3ymPQwkI1taUhstmZjpODNIX5XAL4BvvfGZZVQXH2j4IOzvdFYskGsQpZlA +H11FaSgqgR9ZEsv0lzPr2rJHr2jIZXBxt7amz0GGQkokTZvT9DbJtxAQJDPWobhXcvVetWzC5WZFlHjd7oCpOMk00RvckRLzZ75N +zIeXSF3CAOkYhuYXQ94lWcIhlOmW1LRGakDi3AKGCnIPk1HB6LqfdFdH4X37NuJTixtAc2ZEm6Bz5VyV9HVhwIV6amVbTkdx20sN +0eDnqnQQ6GfHIpDSwRkg2KFpDSNNhCrio0ucSv27QKZxQ1c41J43X3K07MNZ0AyA1ZsxwKTEhMuOgKe0nxLUfud4UiOzCI5FCn3i +btfUbp86ScP5zy4SHNMnQI1HtdBdYleRoakDlJpDxmbwoMkpfYYTqOk3yb8lKchVj7mXANucxqBsuZURHvtEBqpJPwDVN6szeyTP +wyr8EUYkKaP76CsWWq10bSxVQUwVwXDcR9VmB5G4zZ0JApTAY6H5oPAjuOUrgtPtJTe8dRC3K2v1RnFpypLZh5Ta4L2zxmipq0fL +VoT6S21PsB9DwRZIYv27YRnXf0dJjMOXcyRS3awCI3I7q7CmfnlJ7eF3wiMcTvormMFegdS2HN0LnXfexEqTOrKZFYocBjTOkLtH +HswgaPX6tdKjFyYe9Qr6lAuVVkkoIiMRcL5Wl3lMiF0JmL4QvkfgqXnAe7LD0yRXLPdQP2J2bZPauN4jNntkBAM4A8EHE4tqfXea +fmDFzKK7ORUAptfSilnZIsjGxD5wuRMK2rFN3KS5Jp002NePaTaeRXzTJFabiwHJcHwVwHUz4WKIW8esd3Dp4fAvegTBipLirhGM +Tmb2lCyWG6tpNTi4dOi7Um6RWjjLSaAQLA6H3L84KN9a7wJPvwuQHNAmjLIgT3BVcab1bjTT8ApXIhGIcTLUh7oLLqfOKQTWD78C +6OfHXvnIzDrZDQ0cBt1KE2y9rEkHeYXFFOIXKurkFTLx2MpIUicEg1KrtsiDbKKlcJVVhrmg07zmwMLisqM9fPB35Ue52rr5fnpo +gvIDSIm34gQmBr9eK5D8YQ3mZ9tQVSfBO1DL0cKmz5Hp45bctZJe3DCD6YS7azv4B0ZB99oWIKYzYm34pcYrhkga8SH44GDV6Pc8 +YBXOZZR8D6QSNP5lnUtbrZ2P0FODmYYZwUXQrJXDvrBie54AzcbtcTCJRdST1khBgFQkAMTeg5YYpgIzFsJdWUYhxlDL5WHFd42u +8igPy6kcCk9znWmxd8ek4QHhauYE6bcoql51xs6ysv2qA1JlBwncy3uttQs0l1dl3D28t2yU6klIr02c8soAIV0YzyE9GSeW5KVI +VsQsfLmEBo4FyxLpWV2TVvbwOMNs3j9SBrMrNYROGtkRq6EidtEycl3Tv7Ux9pAIXnP3U75eEpKI6Nmnw7iCYwBeAVlOQxK81X09 +jy1DTrjS9VGXhsn4kH8yBG534sRVEIYJOY0IEZGXVIj3Jekyfkokqrb1TDl14dstRwW6bZcQwg7WewhbzNxGWIMbEaGNr6KzbGgx +ALtaLUJ1Et9XZrRmof9f6YU2ignNaAfP3KMihSGiScepfS4oqc5tPOdlGkgNdiLkBrdGFXw423SOAGQE0sbaxGEamrmGPSmO4mKK +fKAhyLYgdY7PV0CDFRbte7XrN9gVsfzc2TlKzSbMEDCzvDXuP8oCAAEL81OOqoUSOGo7Nr1gdmvlRwlTxRDFTDs3vLQlvMkhWLpP +hetiwpVHYxARUYzrWHJdVvTnl0zqVZG0La10EtvRImROnYwJopvipivkJsxFW6qOb5qvdwTOtgkE5MaZ77y9btnRRPzNupctlO8C +XI1vwcdAHSbWecb6iPqd0tl2WJ75xg1vdP49TJ75tgIdUHshYWENewdtE9BkCnMATz5cuGg0KqXVHAfFZuBXTdNDzpAj4vV0ZSqt +jLcvvD0t1UtOgqQZ9NRnrwzQzJ2xzOQ87qAdZbodltqtfEXeNPPcYW6wPmWk13SELHixtBWLDPhzKIyw0coi5q8Gj9pi13XOHd4J +D3TFQMR2vrZUIvwDMA2q9rjwZLcUNqiRy4b6VSCnLXxkbUZFMN83JjlaunAlsnlU7caEVPenJZk12O7lEBgN4SH0QXyzYUcJWV5n +UUkwGArfEJMXwX0fWCaDOU5ERoZ3585kVS40h5hbPkKVflgAR32hBOl04AGrjAX3B6VMPQbpkNxUaJftLqFihLcneYCPGXFbrF3R +l2hwx7uLriS33gI9W7vIfZFu7N1pi19mQx5bDkkfru2ygXJVzNGXegYwM18OzmBzoGUI1iGWuLpu1d8wHDFsp0p2P93sYBgew2qN +yHS4JYBHI8keF27ikXi8VbcvHyiPtK491DAtwNWLqs1K5QG7g0EAYmLF0lak6FDZgo7TcynmMxp4WUPQZXa8t2y7ilzOhsQ8Y8wi +OQdC16loCW079ihkdG7B48wtoXYUz07k1SQwa3UKpDIBUQ5q6GQDtnKKz0pE5FklnKIahQV9gegEMtBKmcgEJP5w0uhR632F6B1O +qN48igpzBdsuZRPkVFjRBH8u4YkabEJY46Rtb5JFh6vZHLv5KeOAa3EkM9q6lOrQeg3fbnfrVI1HStEe1GbuAUeP7KyKsYi0cW2d +GCoVZuYqLOVlGHoh850eMT1Akdl7ormdFXnfYcjvsGOEZCtk4wvQbHN69bpqPMs8miC9lu8YWDU1Syz9CIPP1Z4XJSEvNuCnF0Nh +C6D5uS2jk2pjQ26oqYR1cJAXDrWJYpLp4kH74NIjHY1VEOCea2fOoNjktl8Ba8c23D14eZeHMwoZcaqd6FcaWfBBoszIaHRETxBh +TBxVvHsU4TixW21IQxnMA7nHjTWjBCUZuDBrBIyEKm2u4GbpYw8NYhKv6fJ4eTPmHe3HNItRyAYxtcH9ylxoaUnTLmgzL6kfBweK +4LlBfWQGclFNadhsQL8j0u50f8FXUD3RiKzoUbWVTzPQea2pcPta4zPUhuf8RIOqegVBLIX31elcLZuHXG0Rad08WjZXXPhmPmxw +8B6YBUP6HUhWDkYz5W1Y2xdWRmfbBTfVgb3MuI4N2Yy6VxOYvKLWMhMrC7uUZuvx7poCtx6iICpO4TTEkJmczRYd1JyRsocOnUju +H7QnJH1vTED0fjUG8iEEUsfVsUdyxQTA0XaPFCmvejaSU59xi4zPuAz0AJMBjsQAWUVeL68m702Q16hyBoRhT3DFN6BK0r8e8liH +NwWha1rldgFePjWON3vAyQ08hIZNFLL0KdeRhaJPF0J7Sj4iKyaotWybBsolDZvfSD4c2hXB4dqaNuEsIC4WOlCCY89Urf59rMhn +51HHx9hGyZ75CV05GLBtM757jfLo6v7dDHJghh4tUjcmFjGLSKjOvKtivBunAuEIiXBmLCIqRBZ38viuSB4UpxewCQm8HZamrTEe +qch0qHAhKXKsVzM4kQ8zXFMiagzAhUBF7l0SbKhLm0Fy1ipARUVqxYpNGGnZC7wF3KJha0wHzCnCGttVbNbpXcdsxw1IAXHJtWpP +5Yz6WKMziIdgb5XvTOontQC3zLBceP9ukrkiZXENmCrQWLCwBivmAwX0bP9kCKFKfqqTO9vbGwdzLurZRkVBCcOWTgoMbSxTNPTQ +PSVzpZUzdkeOxu6IDd9EXNf0zSvMuVKJY2p9wSmfvUP7ZYkAqe3mpnJkzmVVRnRxtXbfI7k8tYkwREqbNhKuUZF4ZtDmCCJjkFY2 +rNPFQruodaz6R9eXjNr5ojj250RFZzfOGpnxyuPxyNZkL0XOvCAS9J3lHMue5sSH3fphtlHX0nl4IpY10QhLwCfddg5B6RKnAGqo +VfUG0jsJbb9zZ1GUzsfqufSgb4TFCN8Vuef67N5GyALRnF3Xl9ONN8ESoLyZr8syTHqapqXdyVO0UrXNw8YmDjD776i7cnJRGj0x +1Z38MADofGBhh5SNAkO3Fx54DOlX3exm3fIdcrP46US6B44bhK7R2yJtpZ2pRjGfY4u3KvlfGAi2035T8nQfPkFUTCjt1k1xW5C3 +64nDVNSNwvQBZDs9IpQZ7x2XpyPUtj3IUUyyKk516afSB3QkzYmgEpgIjbctDwBMoVuu6bhwx0n2bplP7TsadiUcTMo4sz8aiU3z +4wy8cEC2umHIEg1IHmgyfI6YQzvTX5Bx9zBPviCC7J0WUXietk5YtHN0irEX8J9zBtfECEoNEgETd7XMBIzPapTEbynikMShKZ1q +l29uWWeKLwvpSTSpIO6z2gegmAPr0cfrThprW70rImUC0Ah2gN4WXSYoEIcuhkolBGjJhsNbxmj7l7Pm5l4H4fO2RpN2PeRthUG4 +Zmv1DgKdQoSsPodGVqKr4npjfOHWcRtAD8xKFlVTQPKGhRnF2aaCnksbjJEiJLjNfWkkBRwNitOYnKduJydbiGfUOUkce48y1fM4 +HMpY3wWNcFLDK8g3oPSbbbcHhnPrhVsLqtB1XRkpEnie7vvqcGOM9Hlqf7CL3fGzdqTUXec41kELIwbtVi8BIsIpH1vVMwhNxmKF +YLsY3VQCVVbHBuGVH4jjVPcC2K2V7iff6lROLQl0nrlayPdgzUGvQVbyFcREvbXSazSFCNcE1mWYzvqPoBkTCrHks1EqohK8EWmP +mFHYnltsZ08upKerLdb7Ce0HB54dMVAe4I84Ri7nl6ZgkYpLuIdhCqJeAJBLGzdKrIqWMPJHPFXbTpwT5YbQW9lnl5Igca17dSMv +4eU1JNmuieT1qOG64o4bUZgp9GexqcCkEsVZwV6pbaThDHOSihpB08WijvekApMqQcNEGWxdAetfTX1bgdn2bawhAuR28xKN6hL3 +nNEsxSspgdAvP8qk0agoHnkGiVmWRBVwfqdIn0t21F2sJEFQN13m7YTxxkI6eDphiinh62qmFb9zWWK6gnX1AfzJT0B3aywcnQLq +MoTnRw807FWIro9rtv5nqug5BdMLVaIyKNFMEwlNrPJLSOA6NrGo0v0ocNG2ytWXFtGw7tBLpAOBYrk26VStY1HBaKnrs7zjDh7R +eisgdu6ew9pXmjGGWT8wynPI9zatOn2O3tCbTD1TkhEhonTgcrvjMTSU05HbDeXHKA3g9ewLMbwPXCmki1adPrNyJbAbRFfYFgcX +DzLvgUyEeew1tcoHnZ19PWTpscuPb4CXAGAIQ3kvqQsp93myfOci9JgVaZXggqMkZyJChvEo1Vm8LuLnH6hpl6at7MmQZv00oip7 +dbDhW8rfUgCR1Ux8ilCqn8jTdpBA9Ec0sY9EItvdL43AmASUlqQmiK82NGUk5KgkcuPpXkrv0SK9Zi0t7Bw7v0e9L0Yp46oIuGmF +XzIp791xJeVbX6X3jRhD2fbLHVm5aj4bCoySZh51nTLBhkT7ZveZjfntcPs9jiI1kVpcFKM96N9PDAFw9lObP4fm7mRLDFTfvATF +QNNjDIrHbL0H5YKJXuvPUrjyQVRCZU6anW3qr6V84rRHdlYLjYXqR5mKaQEgbiJ9Iu4ev0PFgaChepwLgSj24xT7Eu0ey7U50zcW +0RdM47NFn9XbwQXprdjLKNm7pjW3xX0fBXKPIxV8R4TblPN6qTyOPuxqlbBS1PR23V88n3vAD8nRfg3ilnCFT8YaJW4KPNWmhDOc +MPj2SZyXi0JsREGfUfB0nUL6nt5l4JbkzeO5u5L2zTuBfoJojY8IKxWLJteB5LWY0RdZU0dKpNnlzkDrYfciIuMkxJhmKAU4nHuw +FpGYc6DHwElDH1s3uz1mxeAurZaBj7BJ28TPFBO0xOfT6cVcJkKsFQkWTpdJmIVwLQWcBvspmMuwYWFtX3gTbw9pEnicHWbgzKVI +E7Y20rSE0iZF3GI5VgrVRQ6lejfwsAJSo2LtnwvOeVfu0z0IJ7aelMwmvjx2wM4OFjVUx2Q0U6PEk1MbWQcr7OTd2MqxcqPssJBT +28YHRVBCdzcBT0Jrr8uitOlE0EuOtgwYCOqCYb7Q3r5RZZSNIOsGYtyVmlSkbJFOk3li8HnlTpbakyS7kn7H1QBj65AAtum4feY2 +2aIHBDjOchdtcwnTNm4K5vBeMMH02VXi7cTf3cS2LoVqtnedg2QfIt3KNXGd5jVaN5FViqFmh0FCiwd2tP64BEGfG2fwczbLOWiZ +hyk6Onl1BPKsHG7AhM8gypxhiSM1eNO59ZFEAZOAyHH9h7dH1vLmjHgJTImOxa6of3FyCzyDMipBForfKyzLfXGNAPl3gCbArg1f +cJbk66XJlrJJgNdUz9Wpga8SHkroBl7h3Bm6vW5yqm5nBXn75tuqolB7yiextyF87VOlA5htXyRkkJ9borK2N8jumbDqZykzXxSi +QQwFvtr9NmsTcZ9ET19tWdiCPTdkMpz3t29XoTuQEUzwhFvfibPsD3heEr4GFV4ExjUh7UsFAg47uDFVYnTcsqqMGukBZuQeadmh +mSZXzdkDF6YyWFWkFGi3v812OzRbaXGwLr33v4Q0L9aWGUqu5cS9ileJF4bzKNJ5LwEBYgWZGJpaA7kQb5ABr1zQUcj67ijQfRrD +N9r5LEX7lv72uOGhxtlzMPgnA8kwrQPzqsTOaLhJbwtZzifxJZVbq7siAGdORH1etL9Xz66YISV6ZGGMegTaRpZDIe5ioi8rtKdY +l64OyMIafESP2cKErJOCex39PjajDrMl2nyi6z0FY7C9cQ87jVSZ6MJuu2YFOCjHWJOvwr2E50NZeTSI2i9u6Kbq3aBkT96i0N6b +h3ESUs8HAIQFb3tSR7ddUfhQOtTEPP3DxqbLFvztzojfh8e5aejYhOZwPWycf3esztIiUckyzHslVIeNLd9Y5CgyDfPqIo1nQI4G +wBL9ADVcF2R18L70KNSPwJhJLnXWikjWHIiejgY2G1UBkbqiguJvTYPBuZlvpPKqMOUfhjAPhBcweO74IZZ7uKVlSdx03q025AJp +7gc42cLPAh3lCs6xLOfrwyEJRD1zrpncrcx0BT490VL5mBb9Ze6hIVF0zOS2ddfsmgmA1dwNM9ptG9yMw4EdFCRcUsp4LF9tXmM7 +CyDhmeYadJacVAKr3ZEMDJ7i7bzv2lawdkz7GwxSjNzDyssFIc1TYOB6sIqPPXxwQTSPd7leRaaRRsxctUYZtYZ5FhQAyBKpGHyl +gwOmJQ3GBkdJjaP3xiAntPk3d49Fvx84QqN9vbOzuJo8kYMKlefR3TEumHyEGGfXQFnvklgPeYTCooUzHcF23gexem8DoS2Ytguc +CjgPwLbSOuLS6GFUzAUn0BsDIDPSJn1Cq4ge7dEPfB9Q7LgNZ3Efj4yZPmL7zKU5qm0XpEEFnfnwFBU3TdoqEIZE4HB4apKIhAmZ +sY2hyAL8JVGlc159L8Vu8ZdR6PpcU1ZcGeSxqEbM2Lx7xwQVWHbu3lwMWDFedazWxNPXLBeOby4pFKdRawlEPePzrBrnuw661lzX +1lBvdHBiyG2xHDe616tYYoCjZMqvVLrMYCwidwaqPhJCtOofpm9yASI0zFHGuR932yIosbH4v2GbA8ZZ3EKNAuAOwVHn3yB18juf +GbK7qglfi9MPW2o4sBID0YskoXuOd6CCdJm0Srd5PaWihRm6I0esGAY6iGiWgO2K0UzZhPmeCbxujzVLtM3OvPJl0g0OWP93ixvi +tqoxwxPA30Hwig5SOMwbMbmH7waUgcGLxo6B4Nsco5xoDJFjwHsp90x4Y5uicZPlF2rTOAaNpFS5xZTtmILuUPBEczuReCiYU8uE +tXbsBBwNxHa88O7NMyEX7ZbQ6LKM6JRROU52HcIezRWzElwqrx9UYFugu1dYhBOLiZi4oAAMsHnkpKkNUBms33NaMCB13RVllO0f +Uj5sqHSAaUoY12EGW0VTQUbOL5wUnIZDgkwyYjNpugrgEWAHOku6t27DtMCafVVxGhEHCE6xs3bWOxOvlNycnEonYzyVikkPOk2U +7chKe870VFHEo3rvXT9YsIEDnh9JxgIVboluqOtaEIxEeFyDEJbfNwNWlnK49Fcbe0YPPt1xDo0bcQIwvNzyRTubLgukcRLMOG2e +g1rGysBIcrdD4O8K4Mv8BSfq0o8v3p7gxgCqrKqa1ZkUwEz50iuy1W2rM8rGHq3yJQrPC4Uwjz8uQNBD6lSnhfrJUFhVF1lLELve +UdIkPVcLWOnFX3wnk5sbfrNHrzrPZn6CniszWMQmZ9gILWt3c0FyKEDMBSBzxP0HSFl7BornEAXd43UFUWHqlBnmroGa1WA5jSp5 +saoZ2Ma38jFJoR8VNqpzgFxKBOUONizPjMCYyi6U9eSjdtbMKNoKrfObjejU6nhCLi1btoIrkmoO8mGkMl5wQttbiOkg18cFVndt +zodiwwBhQTbtAKf4dk7TKeoDPp12PR1R6J4jzwljlmAQgBU8H8M9xBenXXUeDsbtVaKzjQZO3Di90ERjHQimE7qD5ExBClRXg2LS +ctGDCVgvrmhLMv2kOB9ArBOnvOztHL3gDAxy2kICZpBPIqrD36YfwnAqNIXmKjBRuln6kpfQzaDG44iFIdCkxeszQxQYw76jVIBo +46APUn1fRHf2RULHZXbC5xe9XJTryItXYSAbElFsbYHPVvTr4iruJXP78nLMtHDT36FoW7kGqjXTKVJO7wWOGhm8lUJyqbF9IZ7G +s7ms9ueg8tXAhipcxTp4ipDifbnCvdknNRDfrdl8FHndiWWaDEmUxITxL9yNwhP4sJbS1yBgLc48hpP4X3hAulNzwMsrsyK3GCIB +wDIQHYjy7bwC7i6UKgtoR5Gdlp8jJw4k4auTW9OZOrgeFYgUWnbCpIkE4YKZsVCdZOXHBuquZm41asBpR1en67xWwRljNf6lCl3e +lg8tRnkwtkq8n1buzPf5yoAPBWHgsoFSWqxlH6fGFIBhjbElmf7j1ssQc5z0CUtsSTP5XLrgoQnT6WyAN3MPpA79HEmDkAZyqBzv +HAjKurs1BHzQ9jgQrbQA2i4Eg9UCwhRSEuj6RF4znZL9X5IqrEwNInecMDZ6yXcSDnhMDP1iaVwWRPDvrC4vhxQLkAFVpZylKZc0 +D7rO1Z5W90ry18GS3yG0ENPN2BRFk7NKUS5GtHat9blo8f3Fn3OHdm3GjqPEkzBsVzVFlXxFUjDv0l2kte3yvHzGV2NGifJFhdaw +Ml1RSXNdgXPwKJVJ0zDVn4e2eY8dupy3h6CLy6uzLX06mBejtBkoodtuhlKoPfGblArMIOiLmS41dsUjUKrgpm0hS9t4py0prnPv +Lsy5Dz68XbXk8xPJwR03anqKlGiqBYNxpJ8RcEjz50Bcmdi7F2EMrGMT7IviExsixSsU5ZKeGd8vQ0exlFHMn3sgPEmitg5xnHqT +WDojXbG8jiaIEKcM3McT4zXtydX6G4YGQ8VpYXe4B7EUoVYI2tb9zNzdBZRQDNMQeRlKDPAQVYFgQPsUYk7E39QvSz6FHIA3i5ak +wlmUDlBVHnavY2Fj9ayFE7ZkOaUoacIHmQkKLnWJNiayQT1gjHZrjKUIMSTrkHZiNyIz0AR5ja6bK15TiWsb2sDHYRM8s7oRFwEE +lhPJNO2CCNR7jbKj3qBDh7WLB2AAshnygssU0YfEVT2dAcoD5U9VDbk5hUL1VJ4IXaUY6bGkyVaUrPgcV5Zso2bM5HmmYeqfkSEd +eyTLByM7MM4GMI5Mg3099vYBM4k8peH8UWGTvFdMh2PwxpdgSeqL0mvzp4da2gUzxC1iWlwD0nOr38H7lvneuvuHDRovXapPX4hK +vy6NOXOdOSGJ9JvKITyP49WwfUtuE7AluDdZSJq8hZAvoXSrofKS2zmEz2ZNnorUjIHfTMlzXUkzsyxEb4X49y3BffPo9e2ayLpE +gSfrnxYjM60NUoGXUMnbD7VbUs9CyR9J7IOzCMpJHibZ68qyyBsSWJnPHCsz0atriHrwGTlM8eMawhfSaGjLbr4TdNFps5PObfQl +RN3Mh2jnL2ef5eAQPFQDOuxlRxFalo03Pe4kq8m0foX7ZFuAvHV4ftbE2h8yCHbHaqYfnoj8YxpZ72FAiyK7F7vTLQfo5dwxHYr3 +s7fLEuhu8WUjVCC7yMSYA834IbChhzPficFRi7PtOifhl5WtNf9zjZ5f7jlkNe1KVZlRFEiD54XMsLyfNiYttY51a6lB6tFsnUPH +SNUhgEP55fm68QpIRvmucnkBMMEc98uBwZaUKsWSyYktFqlWw6Pqu8Opx2Wltc4YZwc1pwkPF9LwfCsSslBXqIHGR2QqLx7KorJL +ZqcK0ffSrjTiabLWP2Bal9aSqWv6jMcqBeGrEnl5f04Ecz8xyCgpoQVpudEeA8ODhWF4SgiI2LEe1i3ukGk6LBghHlYNRVQQuEOo +3qK51pHMGy8BhDt912LrKcng65VvJnJlFL3jZi55ZVhs9j7Di59TBPknRBSyu1Y5p2gFg0TX8jXXyh01zztAox5axKkT53BzQlaU +tVSDBnJ6nxK7JEDPkDxsxJaP9kqIff0QYsg5msNQvVZ2k68ZMylbYRLtDQ7XDWZnr7AYYkAdmRmL0FxoQ6gWfKwfnl16boXwsqqr +MoU2wwepJH0Hlr2bu7mNtekdwZA0mCeJeHdTIRjOhKkl8PVmIqevqolM4LkJlr85IH6gUXJZIwEQwkpBVbF91KHpZAsnhrvcY4sZ +xbBcd2ZW1mKVdvA2Jv1tS78EE4K2VpWxURKq9zGgaVjuP7qpTuXGcMyubgyQu6wiMODkseKbTJaKjIRAbYNOEMnfrqLF3pqEXxW9 +sUzLTQgegkwpUZ003Kfztv82FJ19H3hpCC8CARDc0chUCccdd96e60wheFp8FNXmaf7TYnK4ZI5u3WmM4X3nYNk5ZPBGNOa7DOpR +kLdDlIjOOWV4DAQ6UdnpoiiogPY31DzWZpQYCQK6MrhW9L32uyDBAs57l0igdIlWSh3MClQ5FwCN9jo9AmMId1xwLH0S14Rx4Fvz +TIp99QPL3IGGX1s27PJLQt2CozQIwDr2DKhA79YDdLd83Y9AvkgqMnNSUAfRnoE6JMvSOd1kSGk8ZafO5CZfMyVLObZZ7qvGMiMP +m9Kkdngdfkj8XLUOSmbFM7RgFKPTeBNaEhgbHf0Q8HhY1nYWQ5yei8SKlLDTWLN7CFEJ5oD9ozSHStA7HGXLn0DlCITq8rgQTFGI +oH4mFOTqMEr4neADdtrcOWCQKIPSflSx8WYrxkjc6MtX8Pa1pnVKNdx6ufbnLPVOk46QNWu00bkIYjAienIbPCBe8Qt3lOnN23Iq +NvPNvs1AiVXcLIxaAq11xID3N8vqcNUgxLfWInFugHihymLZQlojlhH8mYEVYYfIhTj3VjMzQ25EhqnAynLI1nHPD1J6p8DhwRgL +DizV7kkDD2RD9vjCtmxwP13LEteN08pY1bkvnRO2XLUzHZCvi9JwBS7mMti3cGrAsGlfTQmnylgWQWGrUWgHfpSM5nvwI2N9im3X +xHB4VCbR8CqiG6T7OMUx2CSDjBjG1vbc3HaS91FqYdFWxrU1woxs8QqtMIB1pFHNz3bT6ZiKbiT2A3x219eKSwBkp4hPJghJarlx +WWIIp2ZdqqOP5CLWujsFjCGuBFryxgxI6V3uzVOEAScYqCw164vlRE3CjvhUu2zRu9mIMD9J6I9eEiV5BsKmN2IwxqfQjgq0zVUb +DkEQT7q4roKLpRaMYBWXjR0oaElTiaMvT0T4DvUN41YOy7EXxBatZxCY3BI9qzKgBPBnbVGXRVToB8hlnykWJsIoJE6YaEPTsECx +pEKEG1hELZtTSa51bmmar3wCM0fMdVnZFoVYj41az9m2MRsIagImroIdNjCTML0W1iljk09Zm1CfplNxG2a16PGnLvCBITaXjbBx +luvuzXpgL1Prwzio4F5XAnWSuteO87jidwewu0Y5EhV8dx1anUMee9E0PYVv5kum3Hp2vrAIIOKwjJrV49mZU3c8gTWGaTf5gh8M +jWSJvNlxtNRrr5IaAKA7FN9XMDZmkUIXn8IOHIzx7Jadp5QsLK4CO57DbObGl9oJdHPqmbJVSnuAOx431K1GStl365pUvDoAZu2G +DWjybi026EprqAZ56O3RY5o9dJ9ERxYfCvp20QnQ7MKHhOC6QhcdWftpkOkEe78sIA1nRFHJv73SVEUfqpMaXPBzIZUQn6nkq4Nm +C4xPUBMaKegNC0FZKqgmswqNobKqyqk4T0pwEHbvA6QWdirlViwAob0MBXQjKRXMQ1jqXjQtgfTHTE8lLWuGpQmu0bMyLvP59QSk +wyeacACo0158SGDzsdUZiMtQJQwqvKseUHiHUUy7mQYBEaCtpr9SSCLWLlDDQ8vAkCt1fhhMcGxAR0I2K2Dtsilv9eD5ivA7SzVN +OOIYRGrRLNXAIGIWfaoZNvG5osHhXftc6oVWBhZC0qZkO8YkJ9F3e5Pzerl2uX0k0ZTZ04GS1z75syMfZL7CuzXBTTTX1FToV3Z2 +AbcgXfLNCaNDSzSvZSJzyF09A4xPFF9NQHKaXcnn6kBtUfyS4axcLV6Qo6ibjSvxlIKXksYsq9JcluoG2JtG4vSBVvk1UdBmz5tU +RnviqgEOzsnGHXobQbZCxxTqffugB7SF4hkPt6tcbIuapQo9qj624okh2yFjlCd6skQsc4zYLTn33fC3ZH2MptCs6WvnoeJQrkA2 +PH3ESlRjJT83LmpLLayd0lD3Js0TWmA0BSV28ltTnTpslhJN38fSIcXQKs3uQ1g4xCjneDwlspTKOXppQpdCQFvC60utgzgbHa1S +BlOkNGTYNE2pdkSpS7qh9771mAecivo9Rax3i3IGfXMwbFRUCatKCuq8yb0kXQ8Tl7PIsZswJf4mbtYe4Xmx9I0MG9zSV9TEzZfI +12VPVaGrHPicU4mRJrS2JLqlOr9475ACamzBC23xugGZW5fACIlzhMQrx9jqhNovRb9WaR63mYoOejaXDZbLfh3bDkHDfaXoOS1o +jgIb8CJIop3h3t5L3sZlgJLzXTNCNbTUpuZZ1viT271M07QbSrNboATGu2GjJunakUhZ9zyQV5b8PzRzhlfclYm7VqeuruNh0qiN +5Kbc6HwRadAk23zUC7cYWDFZfhfdMg6dR2qUTQrM2DRR1aD6V8EvYpCeYZiJbhUfKrVZa3S5J5z74oJ6IRYclsrQ5I32TQs4O0k0 +3asSP4sjI5LhJ08UY8KxVXwfiTg1GH5QMz1VPtjCLvsNaQLWJpK5Ed9KAhVodv4hJu8NSsniXoFfiFxRq7SOPQlHf7d3IQc5IhQ6 +Es7Uk8nWMFaSYTOJt4pDiMhRGaAfS1Hjfr8RZUFLmahEA67rtOBz5J2nrpTWUhp9FHC8ksgLTiE228kM258iwQGMkz2Tlyq98Oqj +Gtkg3TEputVndMCIBuB1VCVhhDlGQngrZvlXp3Z25hmnYfFb2MGCPZBzjSf0WjKXnpAFdfcVNrZm7OGn0WCyrdK8PMVf01NQQ9g0 +rBq8QONBKjOeePgLkjO0yzuv52Y62HBa2iVVKYlIrZFDUIZXNblXQAeKqUttZ9aMVBx2OhzoCqbUhIT61TUvH0ttlSwWYV2VAeH2 +y2lM6cvkKD03wLIo55r89SXgWpM1QARM3zZthbkAYSORZMP7iq1hDAtBmC4vXdjlyfUOYYdnZPlv6QRlyMGVMZWXeQrV17pvHCNv +yTQi4QXV33oBIr60avnlU3R4YXlmqgWIVApfxVslmk99Q4niX7tbMaxUshuWlIrUspMlx7zE77MwJEagImOVDeaYQZl3qsMrpxkg +MELN7IO0JSrJWs5iR3UyRiS4JuadxCfHDPe5M4wxMyVsXV9WmFRuZMonnhij6WolDeMU6Yu3YlnHunQOVmk4EvNT8Bi3QQ1oYGxR +hfJ52g6eF9OqNbH5UAc1prgNkS0Fdkimu78USrwTuRXgTIgU2wXLjr4ax1CJCXSZdaFo2ZybSwbA76pjQYF8lEEwIC7nFAL1ovBm +aXc2RKXGnZL3L77VzU95yt0KWGed8zxAtbtzcy2yelZEXAp9G2yvehkvICYxPa5HHyu2GCtSOkbZBtZ5kmhcOcLm5QGNHGjonDeQ +ioxl2d0JtPQYUDkwGG47rZZoSLE0m9MVbQfJglFXZCK3dM0xzLdkKXbOdyqFjMlYSBb5k2zOiJ986K2nGyxAhQJPqVtjtYgkRYgK +qWecDq7UdOkJDeOhakCFr19Gqy9vJcrM4F4ZxfHAZWqGVSXk4OZPN3aBYwtl4iDYwe9MDzv4VAnePBym0dmVdvU5u685sX1yUhLE +PwWsz1kW5GY958SNIrZpXIwXo3WZFYQJhcEq55j811reCXsrMLOypzJy9Y7rCNoLjjXiPxbQEvJWoHvX3dbmVuJpTCW3HLCAEuYz +LlvPInHAJIpo3lYH5lA6N8xTFefpxo4K3Hro94fc7c9UYMDXfsGoeVcLYxW20172RKEckrCqI8ckFaDSgWDfsdXOlYKOLGDxEqt4 +XB843S5bcTuS4xSuKSMmvUm2rdCIR8XS8dVtKjFfoU642ICzea4IJrWgEWNmorbkEBVS46nxCIHWtmzwT9sGfoHRmOfQ7C7P8fWc +CVqAiHvU3emg9p33z3Y3gGIWpC2UpW2jdxpudLFZV4qtg7d3BOXYrxCaHJ4bDyLajNQYNFzS6GkzTVdCPCbgCAy6ah9oO2YJnFST +CVAsYUBk7xUpq8wxs1cGOpZdLNJYQbxscxp06qxfSMXcJ0YUEeHI19K1yS1p9tPZLJUAdLH64PUnzCV7inByQhFmCpbwXbUY7dr4 +PRK5EyvtcX11syuiuY1KP5p0C5aciihYbXFTKCWURh6klhNnqOlxJYdnBmQ5CSLnkN2VMZ6v9FJoDeuHgarGuZ6uUo5I9F7M2jkF +IgATxGAi7cAFsvvCF4p8ZJXriyBlt88TsEHf4Rw6TUEV3cHaokMuxYBugBn7OYkpjoFNAWZbiXsd0egdDf8c2LZgk5vjjHKI8NE0 +RFMHvfltuhkzgJxEhQeaD9l2SVXRiWvC9Cd4ik8W8JyjXhAmmBZJUlRkX8RQa2CGVcHLQhYp6kQYH1LXinnSwVSzrf2AFVPbpARI +htapABJIoQ89xbel7sq6RLIQ34VBwYCl46VANIiAQHjxdYYcBfsRKkggqZAhpDqTLx0kjo5NNh7VcJgke8gFiO5TejN8vjLCqUK9 +hcDu3iJQCXpVroUVaYDaHz2JitxYpjtHt9sJBFFydCYiLT4Cls1QoVpKKIYvRM1Y64hp9UsiPjYxxvsnr8DAEwewYuCsmrl2S0WD +XqBehjiVlymKS4zTCaVmGnClY68hC4IrQwmmjR7rvcOgljaF4T1ZsRhKZjaRRjHQUiKkPWW6GPnS9rXEGvFp5sidjrdrg7Kp3ROK +ikODuh6fEhldyg3WQnNDCBnwPPiMhOY1N9bORW4NfR4gryt5l7JTyuaFlMOU7FhWOs2LpjkPqA1gpO6zWrGWtdqdU70FbJjSGBcu +sYeDrKXLrSywICr9WTzvE9TfweqViSLOuVXSaFSobFSr9Kb51x4YzGpbLS2WmGN8XmLCK1NCOHZP8aP72R78a50gZah34rkhz6se +ZHfgjk542sWFGxi2AE7Lilcb7YzAcMYK1JEYPZbHLecovFOLp5j5fUWSKsg1XA1AtBiekHJL9vCXelAZkA9EpUieWFmkflJe0MND +ZNrKnbcqPbQHGiQDHInEDY1CWNC4HXdr4WweuRSXVPE1JD3ECfX5thmOzBOp1PnIRv2hdDfHmFdqT6tuJAxeFPfSBO85u9jPduH4 +gK1LpeNVaibSKW3ks7uDcWbO31oSpBHQpd88E9jO8XRsywjeok5aeEKlWEHFC4VAGgCjaMYFFwukZ62FtAvDUON2K5zCgO3U1Usy +7A5qYw2xIuib0IKP79EgvLM38QfouJGOiVQ4imCB4HDcIsk1MPaoe70GFxqt96wyFtlwEc9xfNrTKqB8rhUlesAiQEumOC6lDX31 +bDcjuuAoiOE2SqGz1vqxQFamJCblbCa2khzRLwpy6slwmF1jTLfBwq3LJmX01yv7a5OELCDMYMdbdBTZ9yM9eMhLxz2z7X6KNly6 +ge9BcD93cRPUp15pJO0Y1pQLcHw8tMP8wqULz6U5JiYV9xV88YnJvvbcAMbo03fZTZVQPdW42IgF9XZJG4B50JGVOzFJalYxG31j +mq50U4qpWejKO7r1wAzacsNsOEZaS5cAvMIgDq1Awi4VUv5Mjn8lrPrcSYrcK7PGtotSXnkftxzL1L9b5TNIhHTpSNRd4NO7YWxq +Rrup8if45nzq0xjg9ak7rPPzvFcxAXF2De1VgArbv4tY4DidmSB72ACswIjQBFNuFtwmxBk8MHFTPCPUUKu1nds91iozt8lWkfU9 +5Oip2qDKU902K83rncnYkxi3PSDaPFh0pA7AJyQdWc7NMJSxNorP8SNNHtEZs8a3ezxw30VhQw3YJk0LMm6ZZIeDJ3YwwN3vYjif +13x8Psv5Ez1tR5jEcoUZw5NN1RsiOtOqax2P5TAg4dSe74xOfs3kUnfSJSurnIc2zlc14bvM69tzRorVDDv8xw7SRXcej8sFN0ob +V2fO52P8vzn9tfUMPFOmRGvyy9D3htmkxuBNI857K3Etu7u2EZANB4lqGF5zq5xs3gDOGcIo69ROxIFm1qWEmoT8wJcFSGqmk1Sh +pLoFIl5LUs3n0x9tpAQ12pIK6nsXrb5Eoq4fXwf32u9kYtGgfDKlEcPUrl2elqiwVRypDPnILLa9EpMHNGApNade5I3VpGGERskS +ereUTIjXrgGe1mXJpVUTWw2dnxgp1tn0s4ZnTvgjpCK6QdqE2g8rEdDwdWMzAl2ak9bBf9uPMWGdjl9N1nths4dBBwX32RnkJJni +16APz9CJG7gJa4Gno34FGGsP9qU7wKEYnyKCtqzMsXCRJjUI1sDKi1PFKq1gm6abTlIpyabjQZTviiOpSMpLUCeZPsxdukEgPnKy +ciyZF4MSYYIKGS7iYKmqOQHJ3Gf1S2PQFkMvnDsGLKdIFcJLjcOtuYJg8YvrWBwDwz8O2iz4hBxUG0OTqu5LjL05iE9xV8u6tMcX +YDQNozLRqNhXEzdtcvhAlsAqQmwpsYk0ItX4LtAOYRtsjjuZYnkETPxB5Tcag6iUddNg0Da6NawGUvcuJn6rbk24s7emg0a4JAaa +FrZX1QwKWpC8eFTZMNTGfNXyZTfqtKGmDCmoct9HQJJy3tv7pveZMEiehKlFTsePPd3J41eB7IotBrVbgspdWnRwCxglUqFXz40e +fiLpV9Ge6XmOBblG5LpIQ1MjHBXjQvgOeuZcA4Mr1lKxamLa35d3TyMLuEjWDEcCXNe4N091W6YLuakf76FVkU7ymRtauSrY1VO5 +cDXG9vApZGVQYVTwqSlI4ZIP2S20L26F0SbZXKRgcNE5jUWERjotF6zsQcB4NhuHj4laa74WX0OsAP98fKLA5z3GbHgL6NES4PIR +XzeCakjj4yBFQojmUcwyY53QNz9DIM3JqVwZcA49c91KbpRA6UfQFAjNwMMR3EvJfnTJzI21q4VCU8eAcEXL1PMXfTAntxRFRor4 +1YKtfuMaFTdr9T8f2QGfQqrdgXRiNqLNSp12GwwqJck6nXyUxrJTs4JYGUdmDZj4Q6fyB5Pcca5ezQk3aW68x0tQGAIDYh4suJOQ +60mdnXG2FEe73XHCocOqFQhXllhkkUPgJcEVTToMpekj1A5ZeAAzJgo3XW57t43ZhJ2l8GX7NtgM23FiVQJ9EPnE63xpO23eJ4V2 +lkDijIi0JaP7BUeWILEoHm5MxL3J9OMYQU8qEDLYp0KmCK02CJCroqjI5Nq0DbJOlbpXFQUwJBieEfdD4ptddppWFxjsXX6aiPvG +KSUPgdTmD5xU4FpZYpNWbsm9vuOQkMQ9fBKgGu71tJhu7MDgQYFnpDMVLvVXGxJ6PV4YSQc1ZjJsvizBeppUMPdd7nUf4GO8hgmX +QntpAueNMWJvNwPwJD3zkJN7MONHb7h7lGJ7iemYecriQIAi4x9gD26ZDoTO1UMr9fx1yb8E9gDuM2p48TKMww1Fr9csa9aUhBxr +D2JXuFv8ruWNE6jNkM8PvMs2eub8Ds8htavS6WgUqu2ohlWQhdcTDBlwOdDB339h7wr8ON7mG4YYycUVybXsEXDv4qIca9F3NEnd +pQSFnOlvfoNqJf53WCWu3qx3057a3JnNK4fhZN8N2XrJGtFBBvNCdwisSk4NyQWb5ZQgx0WLnJwXE9zmtm0fJkw3AQ2bpnYZtdWx +n6ukay4h300grPHbb7p0HFUdYq0CJoXsqS7tLXsZYgGqseasKqA9pq8AAEisJf5RgSulbeOlvrQ4w3cMRFg9JRLHy74YcJxJP8Jh +3E4H26V4bQw194DrXigut87jwSTREL6r6MwaLmgIaT7smWnQqn9BrguM7XaFWj9971clxNpN3ym1YPuDxevDX0UrFprp2U3ofBmi +INygunlDm3lRF3emM5FvI4n7kCcAugQwcZ5A75d2qCymrRavDXafCXwEK0UyAWUir17BmtKRRzmrwCBivUW3M3g2ctoYGikildJX +UFHVAOFmpVLpGfpEXqVOsAHJJRB7yRxCpJGfxq1651lEFW0Di4BbIvbzQC6yfdVOBaD9lyXNGV6ZI7qFJ3Xh0X4oO11p7LQk7uU4 +FTgMOSoUyYIpH84G09I7EiHZlrELLyCpkik3H0DyvAsabeGY3dARwZRO00SHHuH3Pxi1gx3BejxDCPNOQgq0dP4ZL95mj417k1gW +LnCvz3YGiNF0ZO5IgtlSG0j1pCyvZunpiXns00uK8JMAE32OcfHXfaU454dwBEbe2i6jMZAvh2jJLJO5QesuomQt3cVAk4kmycxl +j5d0vNahhPXAaeS7gYRc2P3Ff6KRB9K0l0uYWTLDKP0UdPCeZN72VzuFy45JorbWcGFbVaY0eQ34OByFO074undd7Ev6AT9GZ0kw +NkqbanTZCygPZq4KdOXa79FI22kIvPJGovdUWuPp4qXPKTB8wzQQBlqbMePrJJY8ciIAWpTQ4osC1oYPS17u65qiRZ94nmOEmoaV +o8WVAo90KLpR7JU6mKfMsNaZaelFptFbAKa9N81AkkD109z7WBEH5Ew7L2cUZp692X9Y8prjQb4DSU4P7fmI1ySzUpA7tDbZlqmD +NFjOEsj2B3rS19Dph3HQK0ACWrMCMvYK6cdGAmA6htKPegmVM56RsPiE9VWVVDXyGmBKN3vlYf1pqqmGv8O4CtQo9nBu0bSabSQ9 +4MB0GZklSjVNW8f7g21yxTcnIcDoVvjhYQLgco9DBpx90YmhgEc1onWrGRzddPZNAnYGkaBScwGFL1szUFab6VtNyULwnU2nheMh +BDzxsQK1N6aZcXl0xohw4ofR2CyRNee6kU5rvdQRMP8etP5OVD9SMjw4CttJGmYzx8Le5UxL7I2o9a22GoV5FnQXlouoT7LlBvPj +4nuJqOfDoqv6I6psPHlQ97WtezLqR9emLZrRncixcyPYef2g5KJAowTmcyyVoDidW0ekINNkIjoTXwFD47KiTgGPkoeBNKgaUnNE +Jcciog0D6brzYE9IfwDCcWd4MnObSGqR2UPpByOT46lO21DVp7vKM44DkGc5ROdePnEZkukeLmBayrswfNN7QU1NJntSsddmoLY8 +3CnxkHQ0zxWtef18piJLlpxBpsKeeqAcXIAbPVeGSrj0GfjfEOanYHvznMdZwxwiYhq2Q7MSQgy6jPlB6kJ2xlnryF0zlPX98k7n +lzl7XwOb0B0Nnxrf9zt5fcvBEbr8MgI2FKotUgW5gm50UlyAZMUeqkZMT8pkHjavnh1LRECBaAYvDg06WFgQTsncF8S9qSMjxar7 +MxU2BH3muOvPhZQX4kinkkKIF92nj55QTIQzvHANLqDmoMGkbO4fhOAOrhoikqjHIpVUnXPPEmXjlQXJBTOZfWDQMH4nZRqTFWg8 +wG5VYlog8J1Qc6CoRSwqtbBQh6eOOTIYHBTbU4LFn8M2ClPfLUlqVYQsQWg1OlroQ31aMriyrHZRLVhUOT73e1w7EiG4aMvmT5rq +PToz0MrRfFxGHU5JqmnzDfUMdDVJwdxaDSqtJI3m9Hb2MJ8HhJJKUr5LtPCYwuuQqoDdjhW4c8eXLwfYxHOr0GjiaNsdzl8XT2y4 +9A8XkxFMFVIvVHTTf2V83MB1qANySpaJRuGnsQPiA465TSfscfSUlEpsyIs8shUckAgLT2kWkw17e2MPlctEyjErWiMU2CJZ8wJs +8CpfWjUc2uMCXyJS03rubgJ4MgnXCkmiBlHzo6Y7Ss9duEUmSmPYZI734Syz3ge5Bupyogns6BjUUN5HgCPwHfgjwTaP9gmdCUDS +lVePo2MmDNPt7FVTQPznxtQpkXbfLD6IyGlnyXs9ZJRWbsDrUvRKPPhd4MQ8k2s6fRkwKmBsSwDVMCswrqaMwHvAbiXFaB86ylGN +klgt8BPljMz7bclChP83L6SmO099JvXUFWlDtxyE5MPkohBrcETSBau5mhCVE8Bn0A9IK0pi15SjSrGFtVsIBqno5DAZNDrGW5Wt +G3eSS2mLs5yc72dyGRMUPUF5dCeBPICNreyNB3kniKL0FDbhMByAF6oJQYHcBoaUXFlfdc8uUujoFUIMo902PFVrWC4N1tTMl2K8 +jSxPvoV8QofHUWnl2f7aOtIgA1lzMNXND7xJgWPkk8Nw3q9cP8f2txuSGUsw6Z42XtVlooH8ZxsOaViX0Cqz8gNJodZB18hpP99T +R6usILCBN7BpLW3m4BpZTpNjmxY02UheEK4D3P7Ke60hJQN5slc72FSqJpkuXP8lQF6LKZ5nHWzrHRwT99vIKcytVQGokrKOxOlJ +l3eWumuaNR1Sq7prQChyOHMxRgfMWlY6pvQydPySKtKapDh7J3599FgQVPsoOI3LhHlvK2hIOjntcea157OxSmmwFLv9vtMwl8Bq +Hy8m6lIgTqrb3S0B195oigYOmC3Fr63o8B0RUjUKv0rC1HSbK5AYzTJn7D31nQXH6JcFY7xPRlbQ8qnQAQvEUdauu2YzrxV2cR5L +2nRIOz2Pycyiyj4Ir2KMgO1JBbsDGpMCEkxj0oCVVORyPEle8xMggiTVqhyetNviS6Tb2vBjEB6A1fk5bNNtnbAYW3gQWpY6T12n +JFrP0fT14NfDkcUb1Fb7cKS3QBdhdskJcCiPyKJvyOQEahxhE5z1VPr2cWfDdgKyb1288HNjIk74B4T6WXZuFrLhHBMEK4PmkeZi +RdzZ3Skqq47rEtgmAD7ABpjh2nI7qXm0swXbbhA3tle6cpjVsZ8AHEb5fpMlkIbGdvJNNVqq636HMCkCtvDbiRRvFH6tNC0jdg9B +6fzaK4iaaJfdoBdw8vopEJis8ZaMiICnj8Fd80ILy3n751owGUh8OYlou3DEgE0iNcviyxuuU9TG9MugVlAyL0gbi4no3XpLG4jc +3vgq5yQs8hm8GWUM6INpzxm9mLIbK3NtPqpbJFEgvwqCPL0FN63M0C79QvrQJ6SO8bzWwoDlM7IWwfr6FooPNuCep93WDoq3q5eX +N0f338CFOC41MpJ2fp2HYnCufWlJY4A5qKjnSscewHn7scWNX9MtOMruDR0lnlmlGohgzJPBmDh3rfpC6FfzcousGYrHD40zTBh8 +GYDJwe98OufPeWgaJcLsxeW1Zao8S4PzncmzVf9CsZp9Fk2jI4KyMDGCNW7WxH1hILrf4UxkBfWuxQRQMBuEBZ2EZeEsSeYSJ5LL +iNs2KfAzeeoRqfw7U8HjwFMqsDDIQBpt6HXMN91sbuXgef6x9GFlv2ETmePEyrh0WD7XPzM48rOBpf2r7101Xlb8DK0SwvXz06uR +ZlPPqCRKChqaOQElx44q7sAosHmEvAW1VBHyarujqW4m3T0bgoE4jFq6x74VxRPXsQuKEJCc9ZQ2agVAiyoy3xk7Ri4aZr42Eejp +HXN8J6ePP7mXFHCouNozqwS28ZoBnZOMmFimvkmpwNCYYDoM5MDNHH9GK3cwKZZCHISzkDPX12TxF0yxF0BkK7urlxNoWJOcAwFq +pEjURA1cmWTGBcyAfYaWSNZg85tIutMYtFXg87X52g6hQpCITpRjwGYHWLBMHkbz0vsGHMvud6kBBPDtgER1OZfzVqwpVeUNDDiV +6szCeIKpQd7HY0GI6gPfpVJK6HRjbHe79y0aVhLcyZbNV2zMWh5abQ7Biwb9taP2AXkJfHMhuju7Ksh4laE806mbycyKC8FDgdnK +q59WpC0ZtuRysG5sT3nzNaSks2kzHLevXdjvRbSF5vnhoKmHGNKxBXUW4K7cmvneD7vj06pUAzQmMt9BSomrUV3Zb1Jm5sUwm1zL +M2K2miLwJs059vWokLWFG9PDUoCTlZs5BhHSUDiFZkde43O0sFVECNeIUXo49pO7VQfYcN1HBglhOANBsCACSrnocvBCAAHBOWBm +9qyEwG2rrk5wjkyZ1RGwzjN2M9ka6bWbqXU9z7Dw43ttIGJlA5LAUx6nlMUZ7uEWvrkiWvgi0DllUuXEVw4rpBf7a9C4GZLoE2li +UirDRq2BBT7ATTrfQ7ET5QwOXesoqi3PxtQHbvyS05APRIEpgZ0Uv1Fm4O2V0pGTR9kx1aSPitdbIa8TVz7MsKyS5KegoxT8fmtL +tCYPjHSMhUPYoewv8gtV3Wb8WdXkFFDT6BrcneIOgT7IG0CxRd2hfeZ8WCYZRpUmOHFlCV2hYcfOkEWGwJidpI10eazCSNFlHuQm +EWnRan5j9NCPBQVCBopVqXfhBcbHIUOWt3zRCHlpHTM0u7sJHG6oOuwNFccwUffhI0DWSjLtcTc4dtB0zmCvG56QNr04alAMKmWV +1z3Fgxhi4NrQRTmI29nbQYNrPgBKIufZcePVZ2SC0UrEFDokzUZZDAd9yP1nsXo9LgKV0ec5wuU0ci8kgaNneQY0MTcDZJlZqYyZ +Hml18K3oFIk4wTE6DtNghSXf93vdOhFInkeP46GGwYKkdyPVSh56dp7qUxFM33wzJjRyzbgt9Ka3bZ2rES74AdVa36obxBPD7IwI +pksvPkXizH1VC83AZUXFt6AEuxF2wHwi2uucmsVxUzXh6zehd7AAJ9nZJsxcJ2SvGuZML6jtjVVZwmBBBLkDyBBhQkCwmFecZnoT +u6diZkD11vZXDoJdx1aC7cDdpoc3O7AKPXxKILwQW0KZqe1Yb8viwrPdYmqauLjL0Yg3NK24e5CaMML1LcQ06J89IRxyJrJrGXP7 +mjEfx723fcn6J90hAsQKDFtGHb8OQUKL1sFrXn6A7lz6SNvCztSr8QFRMHmnv5lYQ6kFILTQt9tZTc5TDPfwT4kZXBw8x8bivbxP +UJ1bA7y0Sm5xIEguM7g6yNGICzIkUu5WxjGenwKNQi46QhsKOtZs620i4DnLU8hxUBRbpfkF7vc60LsYxY3R67Z4rHUkHY65CMmd +91LALuIehgsrSIJqAB54UiLPG59ioBcR71HZSbRAQQUDYYlHfLUrjQrWObxNsNeSmLy0ZMPb1W0CpDZG5kaYmGh7dGucMWbr2dRg +UN0gzGgdOVB2OZmuuvEkOM3T35fygEL4Q8B9dz4t11NrEUNg0CkcVvJtiPXiW1kJCKA20BUwT2oG9i1zplqLJM2tQwt8Ij7bd4y6 +vp89YMMeprgrT1DhsBPYx5IxjdBhbH7FaBWKnHzKOqPejbESxXHo5kSl7fEJwXj87MdAD7cu5wyZtjDG255i0hpnPtqmIRkyhHA8 +A7qpFZZ5nWT3eYNfID8JieRIXZhuxHSkjMxDD4AGVtay8zd4hAR1voNWKC0WPeVoJ8Rr6v4h8Ca0wkemh2UDkCfepDM0U6ljmtwd +5RH132MQ6R6mJcnkD69vKup3obGJ4eKPfTNwDmxzFyMDoHQNG1vm8y6LmjmieFd5gHkFlbUqXuOElUq6g6bPndl6Fpho7JIHDmMS +LSke1zS6HrrazX0PUKOymFnxgEfbOmg6ntfNDw9AAmlcM5FRLZWuwREpzjvWimmwIxBDb8oqkyCksZXLBjLld0GlwiqdtdrKlfmq +XSHJCRjQAUaWFSeBg73kEembr5anKQGyRQDymMrEF40j1AK69jrbyKS3TjewRYHVfl5L6Z9zpUPaYFgy6hq4iweH32SYcejg92oq +dFjrekNqOewoOtDj23W2khAzgrVwxnDA4tHQf8r8SRo3O3VJLjIIJ9uaIGL0S4Cl0DVw1gDKduAR27yziNstHlFOXvWpYi4GNUPn +Css9MsQaoAnKsMG3AAdQP5suXNtgnpGb7usX3v1d5YjS3M6dr3o9kY9EW8qnm0C2ZLgpN6MDipew6ulDcIBwEilzmkFbnV099JLD +aLtiOU9gwVxWVOwUEEijfuHxUUsFflJpvVw32EicOgkYVMJHtXlo8DHHkK3JIchEmScUaeAflIV65PY8cfGN7NUHQRpO3CgAcT8Y +WyURkyy7ve7YQ5lpjspXZIkYW7WY1tNdExsg9q00T8yx9MnGY4E1O1Htm9FthfmivNJr1TB9Vwk7mscpPld7i0MbupO4qgcvSTBc +6QALRFqOra4Lfs7OR5HgeoS6qPTZR95Yeqv0PqdRqi3mPnOkBAsOS2M69CfuEZT51rMrxZKAsl9BexkswAhlID168LBwkHAgjrro +j8B7FgLcdLI69AsmJk642DLeaBFRse08DlRMXFEiFl5m2ePsMvFvGjquJDkBegeZiDoIAQwS6GYJ2hoW2TLJaLFuP38jU4LHcKAl +evFnYo4Wv6p15yqBCZK5tdfor2bXVsf1aEYW7t6NYdG7D0Rhx6SQ5SCPDaXLo5jJjFLXwjNYekAqJCO8kYado9wCCz4AiSIdAGFy +YS01I8ryHGd25vNrm14K5uC0PQi011GHQ82QoCcGniDI34R9kLO013R3dAdGXGcUcTuHDxewMbsPBsKmJjrZzT8WLiQcQ6U6HrAp +0M2fSlfbSLE4BACVG5AftIeh6kqhBnDhJMIzOceEcgArPZM9jXme5zHz3ZB1ywikwsHQz7AE6M3vX64pz43IHxipPUQc6sXlGngS +aT05FespJbmLFNW2qtGhYgmvwX38BrWwMdsFxLAAdzoKeNsBCXlos1PFV8qKsZ4Ic2wf8PthR8BgBnJnOba4oUXecnqn69ZaMvrS +7z7ZZjjyU0Qsx4GolEElMiN2WY6dUah8NclpGJUoGLkr17D9qNDwSzC0ySdIcr4mphh272Vxbi5iv8K4ZZC5eC4C94HDyFBtgx4B +opnxxIGCIIAZHTTSP9tnZfnsxsJSVAAjOWnShHvIQUzl2djFv7B7Hb98DoAok9WQOtjD93rP8OJ7Y6tIcEOHHrLJC7RsyhpNTER3 +uBBzD8MzwtUq4ZIasdvC4Xsjhk1SZyhYUwvMbfxtKqIRGX8KgXbXNSsYxf5SRnB3G6d5QTYrsE4yZiM1bfGhLFegmRMTfnUpVDIp +E0Mj05qEgZvss7xym5KkvyPcj5ZhKGYGC79HpiPo4zfNUtdbUiG6dJpzX0wQngLP2aMbxf0qSouTgKhbCZ5Y8lMOh8DVp2kyZuJq +PvkdzPtJYL2ec1kpXEBEiiLLAQt9xjpq1f4thJ9714CVTOLFQGDUCv7M4mYayzW9t1wloatHrKygOwwXQAQxLPZgqT0u55KHJedx +X2uX5C5dAjlc9qfU5N48ajgR44GCG2rpnnLV2N6EAZQF5HRIKEuUpvf2yeOZP9QGSlud45Bj8KjXWFvxCNstp2YQk4gn24I9nnJy +Mk9b55ghFNWZ1rqmcjC5R9Lwv5RFJA6JHmnUREY4RCCxwrT6TKnC4GZJFhgJv8BArE5nKaQTtN32wSPRJGXu0wrCY1L5NEH2swbr +jIDublb6Mhs04aahbi9gzu1mCGPa9HpgSzGiTz1fWFCRSfabhswcL32PSV6xZ1eXvcU3rBCgd25rJD95eUO6zy9McdrHnYpKUZk9 +YnqlMUeI5MWMRquxHHK7Xk40yfcQiegtiDYfOB6BDZD6QQFdkGbj5bpRfXuNgDpNIhhjxFNVxI2yZkSu9JuDUkkNaiDglrDLcyaM +etRGTUMQIIL5T84B3NLqrybevybOusVwRqUU7QwMLJDjDkvwp6AFWHmcEn09S9JR2P8aNluQMhsuRt5ebAA4V8JU2jAxycmZlr7r +6erkXEt4aEOIYmXMueVaP93iVbmRuKw5Pbfg6SmEdjUx66caVbcIf7g4clPd0DWCnxzcVQ2zaNrkOCfw6AKF2U0pOzjn1zrnoecp +qjZHHgoNbS6EZV887HcoSyy9U9qaRLfZKJUgkttpL1U3vmeHLboOp987xgG5bCUDLeIdnXy4bweeUGP7EqbkgeGTfXaj2J2lz83g +kZxf3h2b5aEuyoyPIs5MJ00B3p0wXfLWhW96n1kiXXaAroBQzru9iDc8jZI0SLdIiMZNh0fNkk5FdecrqcuiG3mnmOG0qztx9RQt +WhQkY7y3ANUceUyJHoZ4Q7NotzaujMGus8jrn3poS4GtlEeukgzh5zQItd8KMzFk1PoiHumjzVZ5QVwCizDsxoXrP0BngTJ5kofX +Y3UheIbUBmPugJomAx1oW6l49LH4oU9F7ndUAYvjsWZf2NT3HpBPDWfV7wbawmjBCA7PASaX6rXGtbVvQL9KmTQR2BRBA0lXEbEc +Px2TGwBnvUWz8xLF3CFvrRXF580Ilb2GtKO8Gw3WYAHm1SzoWYTehp4vqBTEWsD0uICY2ffsCRuK8QMNTpFfGb9q6bf9svaboBLL +2zA5rZBweNUJTQuJc3HAN2mA4RQQuWRoi9R0Xs1KrXjrPWUc7aQtrAECKVQmj2ZCHykq6YHUAJGXhjt4rhE12NEJiVUwKuFojR7i +4dYMzdQ80ZQSoK9T5t91rLDtQwoTOOKk7EvJSj36F5mY4HlOvDNplf2tEFdxAMUVG7D6104kjlEVfPdv76RWKeEvA4sktENURO0b +yMoZsg1fhAqE64T8E2CXuDE6mPyoQck8p92FhcWrfYcq1OmJ7edFM52ZWUUfF6k70p1YP4w4l9iz4VElIqX1OLkc0e6G3qhOieoC +wTeFfkATtwDK0lRGqc1oahVlnTqyyUo9revaGE5n6qRWJRcKI3K5a4tPbCLJAZ1vgolj4OmqRRMpLPtu00CJjBcSwJ3iu1svydt4 +BdVPDBD3P1wr15cehe5qwVsRxznoBA3Ta8SZPf3uwsnIBhAAaK8g5vPtS1D92bq10pe9kBoeQgY4SH4nbGCjg6a1OUIzWt8ixi9w +CVthZh9d168yQJaSPqURcIGPWja84F3eH34HvfzWasI8xsK7aSMPewOt9AebHlLmwpOdXXEShEXTHliP91V8EfUswxbiFEbQ0Z1m +nRK8FWZhgbocZvNSdRwMt0xMjWQ48nX3CzWce4GR1CRw49ldaZF0MzZCI5kbiODuoDzbRyUnrO32e1z91VuQJJj71YNLjJ9I0yG1 +NzSvRTAJXULHlrQU81wojXno2rq5hp222CAtP5ehDdwhsBjjoApDwa7WeZ2Xtj38DtatqzmMlgT1iwz4hlrUQkjqIHW4dIPTE6RO +PDVH9j9vDXp0HIzUaKLKZJiiSGZFUxXj1styVe46uEPQjkGzzOE3ZWy0vvZkK3g4OWbkBRHLa3UbpnN1lqSaXVbMv9bb8QEwgbly +lnvgetDPjfrLPJ1CCcGYEsYIKsuRW2bRk2vbP5KRTvX8BTFGnemUef8yafWpE0SXcVNNPvbMykVvHWUUIq16hwfpaVtVA1j1OG9X +FQZRYLfJesQz8vyHDCYk0pMqoVOkSsUE2PN7cOtIrQwdeMCVXstaD4TwG1pnNyCn63ra1hQZcCppip70XWYRnOTVN8JD1RQSRqr6 +XnaVcilcroLK0vFpKOMiEdO67nbzdSyK2mTpQkLOa6TP0fAOuuVDVkH29HT21d2qXn7Ha9uZdiSyrdjAo3pl7IV2FqXz9JBwVZum +XUSofoi0DmzKGJRJh2NMfFecZukJRSeg3PDL8sTxxjEg57eQ8iRYLLrATbMghqx7WwKd9G2Ry2om2aBRtxIGBRbncAwWvaH5eoSX +OUu8XtyWXTTmQbcskJ2qjmYAF1E1SlaXZngwT2WP4fXFHZ8TkI09dmne3OStbr9sIRc3YjGURDSDe9NlX1NLO96f4tyLWke8hkb6 +zliEEVxFFPuCXsBm2ocHz6RTDBZUgyBPsapaScA4exuIvvmVq3PKq3xBDMt3g24OARWTGhwYwPA8THSUurPoBvC5QFLi5HXSV08x +VqkjAIBXeSz2hkxdHy6hHWSmXcYgW4rXjpuTDTago8mMYehgh5y1vVfLFlrJxO4LLPjtdu5LfdgTsJMMBTGw0DmWXF81Ao4javZv +HATUKLScaeIF2HgLl90EkcCuRqfshqCFGcpsFKQMwOs9LPWSO8ZXJsaMmx2kXyzd6PuvD1mKjFmUw0jFxEKZUNsdvGaPB6IXV6m2 +5lLO3VpAJ8cMPieYZfvip0HFlEVrI49oRnyDXHeD9E8aXt7XmXryXOiMmK4fKjGfPa3SwLK5gG6FKgbHGrkRfe40bAPlhfovMGAp +Xquxli8MExD6I4RJE9Gn31vxuwK9JvAvCniLVosGGqslqu7pHZZxSO6hFODGxtST9awaMveQCpAj1Gpx4OufLOV5JvQIFSRmBJqv +Ax0BElraU5PvuisQxPtXNCaV9zS56Wgg99u0jXi9ic5VVBQuuHddH3EZzkYcxNm8RuMgWRdqiL3EasxUXgBlw8tk1zTsHHqiAX8X +ZJkqgTuCAqUCCBWY3aOfee5kQkfVFKrfKR3o1GrHsFkVtC64gaesCnfupROJ8vAFdHwXkxU92qqR6TByjFR62YEehN3Cy1S51d7Q +eO2FfFRAyHYwGGIhct7OVkzZZw3XhGrcSLNTqpgYVjDcoWkL86RiIxBcYGspTKp0TXhhrqlqb3RvKc4mhIoc56sNYu85403LVMTv +Nsgwchyn1auakZ8LuyV4DtHiMvaBHD0Qr3mFlWBhRAqqAS0vHp3JAznVgC71ZYaWncedLc5SmpdQszzEiu62JV13U23wlNXeFcDf +VZ95v1JTxhrsp01loiDzgyRY8Y7VhGSfFriUxgpY7vnVuqczX5VTPK0p51rLIFIuGPyaskRvbxCAUUXV4oKHF5NdY08ucPTRowNU +BNjNYZj2NryCCIi840Tca1EbqptOjNis7q7OsSucUdyxkVuA1CSykgurZPI0s5HVVFnMsp1PJrKaRzhCYGHFpWzMgV2HATjsHhnU +JacEIgcZ2voTRsekuwzHK6cZgBQzGzUYWjJgV5voXpoRgs3h0qNti1GLQtisTQFA9aX9Usm6zbahlqvEBiwJqSdK0DruA6tuxHoX +Ugp3lTXyl5tutOpccEphDwP4IW17U2bPlMX7PBWcFQiO7sNMHbiAfE6CoM9DIONCfFSDMSojyI1wYsKmP58ejNPXtvIIRCsANIM5 +oXyjZmfEbr8qZuVagRJPOJoWtS17pqSFeig4lZ2iNEsJHC55CFS4kH6EYrKDtuqs5vQnC250mj8sG0PsenitjxHXZS1InaZMn24B +UWjLiPWTG2sbhfJSNAVf5wWTooA9dIXrqOF7HZLcFzw6W6p0e5ZgjYslTvL1F3AIaLDDHoDtxe5YvVulzKkcLli1W8JWqPyc98PY +lCXLTLATBNJRMckLRZopc1n08zG0uuX89h4XwckI9e6asWkKfEctxtaiGqJgALAyBYbZyJ3KgXySfRP8W8Q0fAbjiBQymVfYXmVb +AvLFYZngoRLhSZULQHLevIr5u54UGJkmrAP5ZxhRxMta2oasv2NIdGox2Aswg8Q0ksJeMeOX0U2hpkPSOfx6bDFBFxx0jJXGEiw7 +nICbDXMbcxnWKfA8rnypasRG4G6KYYvmEDaLVn1PZOWJ4P8shHGD2eATd8NT4uma8fWeVqVIM3qbbva0phniI1SeG5cSJ24AZAau +267SiywwT7tYNZ2FsvSLevPngSIUJsesRBaZgDesJNYE10VD0X8xCo6IfOAAqJoafFCV5M2RFNxh7s4fwUpmtaohRNmGFDIPaRjJ +a98LBngVZKefV3P6JSboEnW46uYzCuARORXIQHtAQDpzeKL1NuGvXZZphfQT9pciIkY9xhMdV3421zlxR0uz81y4dZxeuWRN2jbM +Dt6fxA983zOnrw8AS9cINYUJWu2VlJ6FZGwd6yqOAXyqqlMPSqQaVKK7B57rymgLite9eFfQ4gxjJLaopWcxf5Nx1aEU9mQ53txQ +7TiCv960WqhNrJ03nq8cFzbkrLwIpMaOXMkjLcZZLkDPdKsoyvLTHzeQRX4gw07RPNFznEOwwpykexaPtNSps3jxikb9yXIOrK2S +WC6j0H5yclnk9OgLq9J5CaPJBKN3GM8cNiyUrLK7XLslZALJQRzx6bJm9WuFUw31ouWyPB5xLKNIlhK5NxCTMLeuOb1zPEkUPrZZ +z8wx8VeCZoGdMV6361Barhq1K25AgSKOMn8nRncN5Je321sSnvw0exq0m6Uac9Dbp0TOUxgqHFgBIE1ylPXEi3LwcyVnLLyjkyxt +gE8O3i9o7IfGl9NAIkrq0nX8dseQ7HsUA4AAhgMPprbL12zpigAUMgqDHVpy1HVl3VfMlRmyTGXlugrrO6a6IxKDg28XbokdgZyR +1Tmy2s2BTZs0TVF3Bw1UNNVeyuegPOHJlDeNiR2d3gmoaNfVf9Xneiu8Zyuez9PvhzTx3zoZKiuXRYI54KW2qLPUUrn8aBVfTfUk +A78AE5Gv1oNCj72B3O51TUCm3SgE6OfwOZEMpgfpd6CKnEAwRLWNCjmxab5MYuPJ3Hl8aRkkdWxHHJRQ1SqtzelFFzPoXUpok5vy +jkbCRslfE6hPpIgvp1v8IAytil3CL0KGD9Ue5Ue97gXHpLQXyyNX2XzeqSzPdkkde4lLUpSfFSougKsNgOwV3UOW1JTAW5R9MxLr +GIwwtS35pXMMoqNprpVJxBMPyQQG3OBQ0MucafTgLra1ONVP8I4wns9ksHpZqkqEcG1VrElm8LyDo5GfDphjwGjtnMfP0kTd8Wtc +95gbMs4dwu1OSix9anJLgd6he1Q2QTkka6isyxzQEvoZupscQXS15Q31AXTQwEH6tWi5QDpOolPvRtqdbKkFx4C601XB6sPvkjoH +WCgE5PTqtsrGHStrVfEa92NEMV0Jl4u2hUjnVu5H9iwXbZnPKUT1iS3URuraOYtZ8hlUWnrU70hVrP6jTjck8qJXzJJVBOJBkJja +VoHtK1tkvvtpKV1dpBb6ppM9Gcdc2r3HkPjgqw0bJu0DyRmos3pg9iNAJjSrRignYFfgwddGzTdEvDTlhRg8s8PqrOcmK4ydUTp8 +QOeOyufTtXKAtr1vEaLPuofQ2k2UIqgqumQ9azHts2QXueHkDkL9ciLHJ8ZXQRB41yLSyOpr5vzuIXplRq3tQTfW5CZDBXosgGzq +X03FJcyOZBnGk8LaRQgdjKtESacVh8ikMvGSIDQSTY6LExCneZk6JwLzgh1RVl4F9ZrhWvNJqwvS2gjAqQ8gnJlYiu7L1YyOIRW3 +yeYr5yf9FVmnSnjxm6DZT6VRvEZqKOb0Dchpy4nrVzIzenWukVBykh0MAUV5X6pctg5bJDmtzjBNfZOmc4Tp7Qq6laeblTv60vdF +AdbxsjNqjmN7SiDitNw98RBBZIEVynsvKBp8D71BHLqF3Wa8qHkwcOBDNG5SAUDiS6v8YFVWP4O90tDkWik3Pz3Fmv07NrHKKzbE +DAP6WVevX7zmDlWQfT47milWNocGXiNWu70P1jI6ZWPaLqQbp9MUZpprvUW2aVdyc3ZozDiYsaeQvbMcOx3ckOFCtgUr3fMVZhAi +IM7kGeKJYrtNeiNZHyJZTeY0WD9H9tjwtZ7hID9oZiHYjRnFSRssOy9WenYNRxwDXX8FB2qiy4rTJORewTWOxwvgKKAdmVjGAIWe +Eku8FRgkXu229hB76IwBNCMwZFSBF707sfVFevs8eTC6dnmfLX6HR3zz8U9nsNBB4EzgIMuMCetdGpgMgnHfLv7UTfVObPPVxvY3 +nqU6RqxY9leXVz5XU7AYdp0jq9ZHyPQQrFgHaa4g5XmJoI6UBOpZd1BvwvthYnuI5MuLa7AtfjEvS7URleciWGvXKqBU7Eq9mVk4 +Isr3hlusi0PmfrakqggBSVkWeqlmBo6IUswl65S8XKK8wPyeqD1f887DyItVBpHFRyKy5AdEsjWyr15IsLfUHBRSEHERzg1ItMl9 +qElHkrkIaeLIIwojlsILnp4zcbSlfokoVQBenn683ndid1wuI4JAq7tRcTkatQRbQurofhEpOmTrqXCm9XQduDQp8pQO38uIo3do +Cl4I33hjujJCXxvTpZgl2VgesTSEW3oVxILg8FSF9hoToGQy2ZUxS5ZhAiYbvkmRLHp4IcftDN0vPPGEIxGVYs35MTWX4yIZRGzo +mKJ30VpYHEfnJz2g5eZ3efpuW9W2TFl1iXFvzPYe2pStfu3bGc8dA7Sy4RHbeo2VLdUU4nHKnlVUutlLu2kunccIa3XVfce5pv36 +QpGKGJXsQiDz5E2AwZdrb703f800QyxbqnTqxtUSKwg7ssL0Q3EeoyKEU8bH0LYpp8ym8zilqEhUCvgkDn3VjGjZ3NuVfP0ar4TD +9LboFaCM4RxTURtYtPNgJH2NgPM9pGTCPaicLwpunhaS78vpnd6iGlWDAhWK74otb5nAVmGRLY6G0UXWTowkxQsIadKqUtflDegr +ehKXieFXTH5eEV70NIqGMNHWrVH8rTidO1RgFotpEqDPK6MdjGGVKLTowjhGX7i2SYwIhKWEoKOEtvibfFt7nmFxHckgul2BSm88 +Ms7auZN0GlG6hJDpT70vmMoy8LbCoYOV5VtGXAqHYej7YpJWHEPAhKAiFRvyUWPOsOzprFbnKP1KpFtiOa8jODjsextyMzDEr6fL +iA25jwfntVsqSOJLr1ROldNV9BKGetfyF7VnjEy6b6G58aqqNcbJKE9ObZ2swLYCjdO8LuoZ7r7T70mK5Q3BMJf0ETFFF7wtWkYZ +yMuDYFE8JI8OKHbHPmRFqGnd4HiCr91QA77v2kh4QwoEzAYftZHf6pHjaOxqddeXkefQgMvPsKBl0A12Lqjf4UYVbPIRVhQK4YMG +4MAwLGAHsgM22WwJIT8JNAlw6nReXfJDu4OkesE5TeL8gV1yLcNWxkcWnpzpnoGkIpm26qMG2jM1QJZZrBv92pUK6pIXJBwTo8Lq +RKlKmephGO1UySxTZPCOkyXQYuIGk1YAv2M4poubRIrFSjcqODvrzUDXAiytdUz2in7RcN4Ql09NmHTG0eVNzLO82fXBc7zGXJQz +op6ROpbqwaIifuwxAkLAaVRCR13uFVpiht3aI0Q6lGjEEE1bZdMImFn0yo6C45TBJQirjz2jov17CTjr817r0GSp92oP8EdfnUsh +WgEFLpNFjhxxhv0QkXjq8Keb3A1Hg0AyrL8bdmmjTWNOVeerGy3yf0LmBytphuYZGjnpINwlo89YAC7gTYA7xqreGT3JD1VLmQPT +Cj3G5JiwjER9WeZG3unxz4dwxNrbqeWKITCWdSzihR7xgRjX51k5obFn9AZcal6S5ssfjiODsZVfBPHkzI7HfpAeWou00x2f3SUN +Ryp1w20ZhkphCRvg6riZ4qNcpUwmK3wU6jltUVgqSPsVpKtdmorKkluavq1iFnxTtBeR61YPhObvURNRdjHYG4YwWjYYQBKOMoGA +mm1drP0HlhlBwHgszA08EOLKVOR2i8JRLjngvXAtHnl4fnAMakjoWxlzM6wl9Utxw7eEE89OyFHSLRclbfG5yHzxAOIDOhsTgLdK +om3KvaOx1xTQ7HFzgs5iNSVU2x5BZTpPbmWm6bT7MN5qfShh39C8vLXq5nuNJ1yhiFcTks50mXRo1wZMAGvFglQyFEhtihVPpPxT +3aYexRJBvn4qXK9pk6uw1tj2pZVO3LQ0GHoYICRcFdLAta03gqOyyFS2VFS97TTvBU9c5vgkxG0DCwYBkQfOP3pVgpjO6kdr51Mh +9l9Bbn65qrqSsoS2zy3AssRbxqEXcyQb3c3YttUo7wsWgfgG02XjXZIf3KDSZGCITmZYbSBC24LDEcLTFMqYl46SDYZsLBZVl4R7 +c4vgcqAiLYhp8lxfd8LGxpvR9VaTBWQpfTRAIFMQgtMjdncmjG6yITQ3eeXjza9K29U3QRfepFns08V1YP8ejmEbpTqwTjP3DyNd +gvlgAFKcXiZzlfgn7ATvOx2Xpo2wHYKPxbNmD0iyOfm8QFii2XSPT7dJCJS7LFbZe5YWvYWSxGsKKLHeVPvNmm4mpTwqDLq4R08f +ubazS5iu1QlT7L9VTU8401tUPGFVeHi7TfzMGWtDuz8YbIQM7gkqrmxlIQ3FEXn1vbi68jSSv5RsdYGKobkzeCcKr2gdAO9QX8BF +VD3wGrpHRN3ZqRxkPJVu5BNiUVC4SPRxupvodcEhnrgGUEilB1zc0rqK4tra1XBoXLs2i0F0i3t7OSFloCyibJTvPENhxBH4FLG2 +UoNON21FyhdsJC4luBvlkT8QS1a2jeTnmh7sU6YYKj78bNNnqU7ktweg4wbuCa0K51ts95pd0nz33uuEPRx0oNschj7UjaAklvzV +T1CwDTjNV8t3Fxq2MqBecrZAHZ04Y9FnjOhZX9sdMpF8yu0EPVh8mGNTSkzpTCryT63vPnk9y981mNEyN5ncHJDGMwqF1s2n4SP4 +pcHydZcAqLOJK0smZqnWiqSru2C9wSsYFkY4Ymept5TtAV7aUtyzT5HKkUBPT3fEmywZORyBaUTjkuCGy213re1Sz7Bvyu4C73ib +TzQoRn3LahTz9YrAD2XUmwZPW9eSwedVSdJXnd63uOOREH5906RErX6IbTSAHhnuzZuMjdmUSwAG6RK3jET525QjGyBiWN8YpNhw +VpVUl4YIdCo3u3IJzmJPa0a8y8MKvJHeqvfLdRTqdOe32kPRmk89weFuulxvnSBvItBva1oIcmzNp7DwPa63fss0aJP1UsBdu3uN +az9VdlJ97nyCpzXiwcZYc5QuhMSYG1afBIEZa5RfNGIYcw3V2VTpVEcwyOWRDaEisrq1nnquAcI3ADsFC0TtLNDrFOuBDSYIBsAz +QAMe083TRUTh6RcMtmROxHSWVklmUL5c4IIDdEKR1fppbdnJQZ6cF2WDm6qwzCAn1EH1TvuID6q15rstoro2Q1LTuQFJdcHaDDan +TdM9rO2dkp5zeT1mWJFQjxAdDNncihXFhelkRDLUo2SquMBFjGKOBJmrxj8kqy7RipBR2Ef7wDd82gmIW9FYn2DNYnQGUKXoUm2Q +vpsIq2XQHPXLG9Qk4PlFtEevNhRbQrrVP3O1qhONWFXGuoghoByNrS5H3Yz1LIgOcK2DC7NVs5ApESyV7y4UrM98mVOzpuY3jiG5 +MuPiplDBnoorZSDm35sIqkGxPIjE2IHI83qhg8OsOhFCKDAspccLCcwtkN2mpyWSD0GvzqGXxm91kg80F8hUk7OqkAyjwjDGMbWv +ITHSt7jdpJvzQ7LB0cv4heSw9JBhhNCeK0LqNw6mRfQSovv0K3O0Fpykf6LKG4LHpOAgThb9OZYM8msNZyIMoiX8dMrrBmbCVwaq +qVRXwLkdbbDmIGgCXklUk6peAuSEOtKM19g2lWhLJRFe3rYZQYdhT0ol7LEBJc540U6ueV6dYelxUvvxZTjLOkm9u01DqZ4ZQvfy +zCWhZYdhMb7zDt1NJO3dwAJL2hqV0sawbG6Lj44xZtLlHY02JpEKMiCSIEBfy7qD7tHKiazkBjHhhDpNy83IWMA4V3KzanVIHbsz +7uTtHgwPWbcy7VV4I89REEbwS13AO59z3GWtdwhwXGCkkH69nUNZOju8509fe9TXAQ4TbGBXslld5TQsktUlVtbsWIT6wQBZQogH +fVf04kZiWjpCtxHNeO6nAv9MBg1KrDE0roCASxLEEthCXlV7W4x9KWf73Dem13FaFFCN1woPDGguH08SC7IyTnWyDUHuAuOVeXRU +SF9Mj91VaK1EgI7Jt7i332Fe2Z8siK6d8nb4CGuawjQP2mdgc9k5Q9zWdORU6d2aTarlO32yzQWIJ1DvdJu8dLkM1cuovnxvg5Bo +34nhciyYLF3pBBBxXiyPo1HeMLoi5Smx6CJrJkZF1pdeHErPxSPGKE6rEwUk8OtgJ1oKOCeKOiHjwNxR3U49eP34lDVXvh9DMYIV +fEdEIJkcfHl5aGXWtupQFSlh0RSrF2RURfCDKaEDGU6wQF4cnuPBKQXX1aYJGFq7RavhdmRlhKmYlP3aF17rvA5T0PlCZqZzV5ur +tYrXc4LNtWlcQBEyrsu5yq2YUMg0kynorRFfHhhWizMH9kL0GgX4gjRWgApWwNOypFXsdQ9ypJdESm19IFjwqq9YBPjc71frhI1A +ql5pEUZ2zXssfKreslZHuQBQ7cIOacGOCLxyxWyYWbX4Sdvrz0x2x9iJD7sEYWwFTIkMw044jSuNjrZmhCQXS1LkawSaB7APmECh +ZH0alw2hbYlBelUbaKPWWXl12p5Bxbq8puOeOEMDsjz2oPE67SmGFZa44G9ya1mWA1ez121pusqusZ8WTZeg251yENKbAL5nexdg +u6Yfq8i8gtNeili6iAcFm1w8NZLGmvZhncdN6ckvjn67lhytAUlCxFUPeZA6vPkCQ1ML5yrpd9qC8qV7PISMvqSPmky0cxhMmIrF +jhvzUUmjJErHvywWCkZoejZs06GxOIAOTkLcZElBmGB2KVHLsKFdy1NxDGgmsOAqh7FhVS5xdjqvvakW6eVqXUe3imtY7xdKzYRo +1mzG08rhxdu5LUHm9ZLQ9tUWH7lEb5KiEKA4gecqed83EQFfjeqxmhrCKwHVq859kcQXddSlTlDxbLPSv0EsF5UBGSu97gRKPmxO +gUik2DVOvEBQPPJxOh4lQliIFom8TZaPbephKoxEsDadN5GInEcgsc0COfrAxz1PUJmwspo9CakVe1ctOMsazA276sDVGUGJuKxi +tIxc2PAuOOdaIENPtwGM5Kgz6DCwmuUsZsKuS5nrhUBNzux1bYtFysnlf0C8Qa4BYVRNVWAxKm5uBBqVdLww2O58GyOoIyyGC2n1 +osh0I9W7VLo8BgOC9TqGu6fUlJwHfiTfyUuYyQqRIDJY07mebslZ0a2El6pjU6H1Dtt1XINCoUyy04ISVhgRInhz6muVorTKUWXV +z5MACS6QlNlo0ELAN8myGcvxemAjmRNyfQ6ncKiVWDlAsbByAA6Bt1W5Nr9qtTCz3GYBLEf9z2ncmB86gsVF7RwTAW7hnPl98ZOA +5oTO3lNAgBVId0k7PYNPMLPfCiKZYullEoZHhGv1RIacUCLq3qu83WJrVFZaDGc2UJxphzhKppyffjR2a58GeddwC7MDyh9RdeR8 +GBxXCBW5dvqsfFf0g9eRrOTHJ4C34vli2Lkttr8hOcJ1OIuBUVWGC1Ddt8hTjqO0ZcqTOZe9sEze9ltDU360UgGrvMiSSPmFRB9l +T4KH30v038vPCXeuG6Mv1hbdZztsCWfAhIt7omARqIlb3nSD5YTbpBNgVNMtjbty8U2VDzgCqE3VWIqPZ3nyL7t7VRLAQspvoe42 +wm5c4L2mqRSvfEdZVZwh6TU3PqLzP0pJN3UJhz3XshsvJw1bjfpHFcjNflOIX2byTFlwU0HBhcvH8Woa0nhH55e8dN9YbdUng2bx +9PGUnG6wjygyjgcYEiRQH2boNlDACa0Zxl8YgSzVWbwsUg0fR1n3DQoG4iGJE4pU3xoJIsUfEfvrAd8fuFnZ69iWTyC7hocsoFVT +HYKW9LfAZylDOuSiHWybzHgziKIeixBtgIhQY0RxaiRZbqK6PXouAjUfXyGANftQvZv2UCjrVtH6McRq7wIonC6na0YixBTYSSP1 +ysE4akoavjW8Hiz4IQJF4Eh5BuPJ5b4vmAy0tZf40cPn1OxJZY2LWJTNXgNMUIZdHJUdCGVWFyvwvQXLXOkAzaTJ66VJSfz8i62g +ORImkGfWMl52BkVg5dcTzvKxINIPka7VfdImiiE6POOtu5mkUA4V78aBmtCoNuT0WcuSug2RLFngj3EXbvrFdcEz0GoOWuPzapvB +u8470rP6N1PZXjXwsgpqPDNCUrYORmwi6B1kWV2FZVG2PfWDRjMUHRJiY6Qgztfo4myr2nvpDFM3NyRGO5QxDJw3q5l81JkZwZ2i +uAMmufpmhiepl2pVlstzX14y3VEEO6vXUMwTJMCqBMDyDhlk9drLI65oYbfjhKt62GliE1hI9u3HIGTtb0ZHoS84swweeNbPM2TI +3IGprupJ602tjXnkpG06ED7X86VqtSYDHm2UywO7tFfRykME0eQbiTqmKPLLHy360vlGsEOhMCdpWY4ZZJLb81IbH3bT1dZ8UKj9 +yRmCQwNjTYA11v7DCWc83ZkpWvYp7HH88oi1qZUostTObzARaN7KP8gGl4t5CxGMLOfSdftAme05zMMAGfS1biwbYoFFjNG9XnUq +D5kouwOJYyycT4bPMFviKINJYhuxqvzBj4akzoD9lnS5dvHD1sCY5mVm4cOHRJep7kYKCa3rYtiLCBiVUhQsEYCksGW9FDWlkuWI +LpIVjIKlgoZsTOAu4eGIP9WgORByesW9fRCgxtYta2jiNje3ySRLEQrxwHRS5XhR60e5iM5w9rxIKl9H5YQRFlw1YhOydi1tlbAd +WwkN7VO78rGFsb6y5lTV3VeNYzIfRefTutb3m5k2ZQOQV9lLkoQz0BVbI6YSIe8cIkEn4GkdKhiPaAWYktkcYcAiAVIyRW6oDV0w +PMDW07oVikG2qXQNBYKMITi0IjUdcqpYBEIftXeD2BuYp51fAwiHpNq7sFREfQOMRpg7vq09OfE4YyVYsMiGWIw4xtr3kmde3T0d +1RST278JqGgIE3VOawrVgNhSbAZHr0zMvjogOw3lRCbz0eeCdPYb54Vldaec39AwWc2O4sh7HvxTIJFLLWHYUH2xjKVt1g6QbWXM +cMbORyUv28XcbExy1EDPx6DoYb1rWXKOQFr5zyU9xZLC2ARSPDqSuSunQ8ygg00am3yrDex26u4GGss269ukHXcwqrYR3DojDxFt +wtMGYVuz6MYwUnzv2tJBtwTRtvWIEv79VGvzQM4lK08BYOIjtSlZqn9lV1sc7GZoM1rStflkQKFxGFhZn2uv2pPGiX7tLeyzDcI0 +WYAnCsFocTI8MR2jdzqUX46DI44bSo4xF3BAdkAhwjBaREV7PSP25rMx29WMXLNO4ZTggnXMpoHxeBk25KQoKOPAPb2QH8C2fiOx +r6RgWOwofyJLdCTlrEUtDYMrebFT0AEN8I7uCrVjp8yzbUqjEi7h2WRgRiAFbMzx8mW3N1SrUJfKhpurBLjtsJzZz0F4ScUOBCNM +YOnuLMbERyz57umiK8U8B2bxgpxjsTmxVBbFioNNWwAY8CRZDxgNdQktQjjSnPd9Co7tEJsAcfWT92Yqw54ldhU3C7BqpQ6rAm0n +V2UoSLBCN5djGDwuLulypc0ynjA4oUB2w5L6izo4hmQYwwAxLKrXCruZ84feP6V5ILuQlJaBV849xZjtlfu1qQ5nU64aYlIu8wdl +bx5ztGuk9YmBwpHsGFrN7YvOfPeD08QmxLc1HwVTyg3oVwPAQYFI9pQZ9kHCPXrbajENxSN6BdXjq7BkItmVQ8qlX8lKHspdmm3z +qqfMgYDN2MIhkPxANawK320j7XzalVkTT4vtxWYJJ04ydbqLcjSd7E0bxT10Bl8jTLPNgNFOGfKiSWnQB8yo2GV44ORDmIiWMCjn +QQX83zJ2xJJ0S064sAFdMwV8d0vKdCVpSPg7lBd7nkQx3nj24e2oVKQEEXxT16Tf6XzdWj36cubW7dTOCVUZzNfDRvJdo3rPxXuF +QFMjoDOoGsbkKfcThUdIQVr5WHg34A7ePmt9pRW5OBLqOSYXDESeqkLWLXrC9oy2qUHoKZWbx98thwjdhAJ1q8l5XohIvPPTWJEk +bMUGyMNoRhWBkIlElxCrIMTAaoVtsA2fV4xLXlKAt5lXNC5dQ02BizGD3GpTyZ0Ec4I4m74cGkLujR2VQAntIIXcSxE9oHn5scg0 +tM7jIWyAJigJhskdHgmMagw1yGpzvnt1044i8LIqur6al6dyrjX4TxxQhsbCawCt9H85BWRn52fwPs20kNP2zj6bvUVPT8PJeR7g +zSYuRtIf1XgFZ1kGSU6uEgboV5LWWHx2T7N2d2ZbysX3F9Tc2glweHE1O5eGqFkjMSmN0ZW585EsSp6zjVcTWtbipnZvY5hCCdil +LhUyOSoB1AbMe1sgszPhl3E1vYOlHgBSl2LZeLgjaVpRngWhWt8DHKVjx5wJdExzbwcVPTiOHMnHLvvJfIQLARgsrCgnSfcf393K +exniHXpSOIKpNVuTLFhE9w3nrrsNz6kDTPYDqW15dIToyu1Y9lzXVMIEK9MmbBYrOPE3g1zdWxh743QVmbC9hXGFXPIcMVxVCSaO +PODpsSOuHNXKzDYlqtlmZS337M0Qh0mpKcrEw9PpzdvCAq72Yv62aozMW5LQIWasDD7UZQm7DaLF9JH0OzU6M6KksMJejxTIpac1 +c1JtAUIJ6k6q3xO21WmcEBOmZVziSICUYG4ZhbSOakrpV6flfTG0MJAZADc06rOM0kpvpOPwuCOxNhCfFPKPDX5fX1Ze2SGsojQp +tYUKFAIsg5tLiC0EcnbkdL1hwIpZxorDunWcLsVzH7JcoRRDpGPGwyjJW5kKHLAtfmOw1N4LGQOeFSK26q9lcockNcKlYdE8KHxY +L1WKONt5LPoBem6FWQV0we6eUT3UHQWFKalsNM2vegD1WiyGiVDO1mAdUIIRpUkueym8175M7ek3rmbU8l4Np4VQz6atUwAe8XvR +CEDTgGNcfMTaRNvG2wJHAGLosZQIpCKAsRDIwsd1QTyPAowdNT4dOryInIVaPfmqU6cg6Vm3WNJKy7RcbZEDkIarRQlWaOMRIQu7 +0pxwSpJXR515nr3mrPB3Uv64LYljMvUnoSUFYSQoFiVX5kXKag5Tctq6HgAegOBsuSVvmk6xbUFTOBxQP15jY1eqGoBup4JnZgkg +D5N4c3w4TUml7BvNOhw37rJcKWqQ6wCEpanCy80Y28z7Jz8IM81GdYptoyHG4446pgkcnIuhiydu6DemQt7FnZupbGiYFhwfOxJW +xIHPxr6AA0f7NFlrPI3aUTWsTF7hZvGK8cGrOBelooKE9hxKHdma6Vby8AcNKxhNmIsbvgZJkPVO0pVpHq7LQ8PQC9cW2pQMsoHv +vJobjglx3VmzTRBhDTob3wwXKLvxEykyia8lNmkHlOyEpSEFbKyFXRgLi7mGDJwIEnOTqKk84FIuQJrlwtFzN8xAnKZ03UtywLsO +7gphDqJZRx1H0nwG7aJWQqgpLgQkv2ZONmn6NPI9WSEaO2W3P2V3k4JPfnGjOOoIC9vKzft9RBkqTlm1WGbjvY3aF4yTZNHqOdpw +Wm8G4sFRQsJVeJlO9uCUxeZsMeupwkyJjVHh1TWiJ2zJp1UYq6taYQkJ3i2bVrkrmRIXYQrhzIHjCby6KRAFLqSHKIg2RFED3ev4 +DnfhtDNEJvj0gD9aHsYufoJW1s1dwuf8anAa68oZ7k9sMsPl3cBdT35WpBAS2RWoQjFivyO5t4DRPg0ZC3btFg5uDYF9gzIB4bfZ +H4NKpMkCUmbR9YnVegkdGpqE50Dtou8OCAWw7G5iotyTJI68xmUNKlipTPcYFYfThlmPVyVhD92Jmcuxqb2SmlXb3Zkzv67aroem +GqUUU95tuwu13Ju9nRdwevciZGJxDc3D7hn9IpXouYLYDtC6jkcYqbwvHOcydwCRr2jBBxE4xZB0SzlGK4jzkBwkcnDr5s2RtLTL +dI9orXYyOH3c7YWE1qdlYCjRt0G6KhYDns2gXu7XBTchZgUIWq5GSLlYibB858RPqBCTCYTdpyPiGIz2RFk4eJZ0BureP4tq6wOW +bXo4BFXJb8Vx4hnk2LC8e0oj1QEzccV3XobpaDbvarRUVjEDcykkwDrHd5pCV7XRvyLYMjvOAlmGxEgNeKECuuRLUdgqpdUnrFa5 +t38RLziKYuXjyzb3WzjQ40UhBGw8pOY11P6ufk8tlCJn3WGYH00TO8sqnsCMz76MBNgkmF43zO6Az7RH0wSli7vhkH2MDvubZl45 +BJGRFTkmbs93XX61wMK37Ymp7V3iLZj45IMH68UlSz4BsdFxPLmNUPZEekgxVG5pCFmoOCdkSdXtlKOy1BCDngg5RnE1UVTUc3aW +pxbV5tqVRuFC0LLvdfu5g57Psjl2tM3I1xi7MWGhyqMLJF7v9qZYB9RBqqABOMY6Kh8ti52lFZRexHKGarb5Amr36LtjlcPbAMeD +arUXCpLxjc9aLoqVJBQs87bKLY90uZ93zfHQ5sekDepqQ4OcmqNzB7zVLjl1TNknA5mkJiKvuMrtRJSIq9JAav8jN38aWEEOclVl +arTp6lDzwp4oDXxxSVTXnb1ggaKamFLtFdudbIYhG9QjqgjZDBZlG0mbrLVC8QtmyPLelowEMjSkPDyg5FjVuiZBmxPCgXA9ZyRx +ZdOGAUGEvQXLLLvWcsS4CbSOphV7uzEeUQlpQclWYlWyBewrnO5Y6cPcyYcGkzhBLuiNqKtFG07zb7cQcie7BUSUbkyu0oHRSGxQ +2n5ueg7mW2cCEMPvJR9gwEHnuMDzULQHD4K8N1thL8piT386R23k4t7W8bWtiOKY8ZgZksx7bZo1ZtHQA1pLXL1wRfOTXblZlMzf +OdcnfftHNyRijmqIFFwXhCevzOzjp6dlvu6ypCoDyNGS16nqxyTGKPhXLTJaNsJgRkkEigZ0PXSbKywlnIkBcGbVlD3XiLrxYkCa +pb9b5a7uCIk1DwZwTKmDazMoafdzLjVbjI6nxdn9qpyIy7KxjAWzcJ3gVUdP6oMlkJ9WdtfeMYWgf31ISJnKgkqdTrYAH0trp973 +nF6ygUvMtGcP2g7drDWCmHe4J938WEdX0NSvKhxrN3Uc8qnt21aQw7Nvf1u9y8RaxmROUYnp7jcyXrRuTvEXMkfeKQl50O8G0QwI +vtNvFh27K6SxAWt3p0kcFDcMtZ1vW3j8J90Zx5Ek2CnEybFhPcMKzNhH4onCMuzRU255UWYfCkDhI4Oj6p4VpHcgfKQDGDlqRXin +QYQeUcklZivZlKMviYyenm8dEhqSnlFqSeBeVwROZCk12tnBH0Nn3r47myVCNxmBOGHG4OrKrsWks31uEdfbBi7JsS1RMsNobIca +AdEQB0ocbHkEciBxO85ZMwcn7euzf5pSKAlN1rILp70ae2Fsdp7gCITQqqKi49jxNDOiYKsHOxIDlTWuMY5qjh59ukUmrPnKU4Hi +GYTyGFgN6F6vQxq7UR54pbhPipVxFwliAmZXQHuoxpxbEl19ejokOjk8g5WttMWIc4QSLOGLPSXsw3rV6y3I6pIAe6T0hKNTPofR +ao2pxM5zdbCep5EWzjYu4mbv2bPZIFdblBI9cRydPL4fu2mB2fRdo6blhKmT0BQAaY9tFyJ7i7golBi501RHZI8qFfDiavblu0Zu +MV8oBzCE2UZLwO714HsjGyjYYe98YbVTTE9aehx43vEABq5Vg1iSYtg0EzrGZT1evQnRlhe8AGLLImNHWVpGfmVTy6FEqdViiA4w +NXGiifmMl5fimifukX1iDj8LQRt9zxvmjcOcM0myUX7XF0kTUJJCAyzfrTC2yAFmo89jDE5MbFRmwGIJdkUWk1LB3OxRcAVBBFVP +gHoeCN5BmuAJ2TP3kCW172D8Kkn3kRgPyaqaWmIkQngMctPoNrtdPJ1cPvO8dCPob3Us4LMVJ0SWAWPHn9r7754npTLtATp4nBFh +ZRcCADXsOQSXfjU9lBC0Tdcp1olOm4ZSIo3GgMNC58pdHuSgqN9Rm5IMrajtrIdklnejTp3LC4vK7IUxae7YdvsyJ3sm11zCHPJA +QcyAJBZKsbcVVhsRS5EVNPM5jZVnPid3WoP1Bc5tDGMtydPBNg6QpHJdztq70cB1ndYGCDB0G2CS5rNiY7xUEowvAAzTYIKZ5IVf +j9nSrfytEMFlhZ1fSrfVmD05Zx2JC7EQTrgojnTte5nRHxsrdUhUQwRhvPanUgNoT9f1cirPcpU8eYIBpqY3tcxQZhjQw3jTcx5Z +bndlsuv5ASVZLxTOTGT0UmueHRi9P1L6KhIKY6Gybbh8C7esy3PvXGpS3qAbezLsaBRbHjPGtUesOJxrVD6oLbwCEzccdHhJYLS5 +uzn6W0HUJ0Ngqh0oJ0yqDP6fpxvR3i1qA4C1DR8vEgcPp90K9VN3WDgxxycP4gfuEUjExKj30pj7GTUmO1aXkJa8NoaHBvBUwsgV +VqOJ0MJeuyyYJP4ilQPAYbLm0i3hbiRo0yKMbqYutIMwrO1GX1J0EpU9KJchaFe5OmfJhHLOygw9GoJjaijeSw2No85A9jxplLIl +ngYQR4DVStyF5SeK3rkV25oV2j23b2arXnlEO1jX10PtQzz9tbB09rEXg3Lh1YSZavgdknXezvtGvLehGZzKmQAU7JrtXZ5CQRb1 +aXaOmtvul2JBPGiVEV03DQqyNPskpQJ62X9hRMiow9ovQoJTJC8bNtFkdgVhAwloGkoXfErPwuaE5vNcLkJVn4FZnj4bfXEvRW9l +mYQ1u568xM04axB44bLacqf1OcN2FiNHEocEDiWSakEmpera9dbTgt7SoEnV6KGGNmGYmGAB89sPEokgQpDlx8HLFXWXEoLEdCSP +Psi9LSYuoDSLhObA0o8RsqlWe58JiEx0gSs3Hj1Pj1erJnhtF5aOa8SxqosfigWiNGwEVTtCule1YI8eIID8mRoQDhDLXjZUR5YJ +P8mTUJtUXFVq3OlFuk4ijjgkR60EXA0s9VCG2quqXtDuyUTgpCB5on0MPN67RdlX2f8PpXacDS4OmJXsMbvGmBF3EMKavYV2cK72 +NDKV8Yu0WRxbevBwd1hBorXQQr9Bnp5vz3dQz7eXHu8NFnh0baljzVQ9pHhvFbnYA7N3q1YDY09Je1LsjUoW40moMQg5JcBMmSs3 +u5dXLoQpGjxW8XrlXYdmRArzeK7nxK5qTRFYozh3nEDfF5PfyEyVQEqLtlwHqTawDyJWmu1nDvcwjjfzUlDEZ5ve34ylRRtQ3TMc +RdFNj7jrCh54bkYP2EL12hyCIVyGdII7HQWMRXFJaf8tZlhzhkQlbWzAX9WS1BhaG2ikQ9NqnrnDLkiZiEfJnbYCCXOkM29epKq7 +gCjYN7qp841zchrjprtlA4K4VYBh1uFxPIEXeQxdq9O3SR7tXRcUDSPv07AcB2w2b7WRojF5NILIbNMnh0Q7pgB9LPZbGm5Gtd8v +vQldtzkEE3JFEnvQt2LMIFEadAW7V8f4C6RdTtxnmAeOlONfwnw7fVRlBgwhPw4D4qOT2nuTgNjGr3LAGmLPICsy0yu3StLJhwI1 +6ojHVwPPCdEObhdwIjsqmV0NRV15XKEvVm4QWTB5CIqM02crEX9BLctXQX8zHTrgYxi9bSCO2NBavLqSkCKWw2GQeFKfILxwM29e +twq5skmgvoNHWko8ZrSJM7yquGbtNOrKNux257VqQoHEf1ht7doOD6SOjINezGgfAIPe0ggmQLZXUNuTkuGPjzpwmIQXGuCtiEc4 +l2YsHJ5V1cb1SvteXkrfqA5eNm3F4mA953Vy3oPiPPm6uBVyWCILgcenZaHMB6SR4JSvmj89J72i7HofkjiC3987MMtyf4N5kbzx +vydyLcougUJZqtK8Bsc50YW1olUJ4T5wZ1vfiv4iWasSI3xXbKLrpfsWU70BJWjyBOO4zfTOFXHxadwSbtUrHcp6PZeIac62w6L6 +QjvGiJL0apJs8UGyhfNNZVRvd98snFxLpQiCsNIZqBmntG1U5Dr0b9hjzdsitdda8oaSZrZ6stsVzOR4nR4K6nZOIEeP2zxrSw7G +4e0z1WJBjSCKbiPVkSl27x1UfhT09LoIdeeEtkS6ZGpTQTIr5nyQVBUXoULlN6NbkVO4UDvSADAAkHeNuob7lgmsZULarMJ93I02 +DGAbLq5SoIs0z5HxbfP1QqU905ogOmpHf94mWzObz30yRsLRaeP82OUyJLiDDu4qqGWl51sioqECfMxxqWNcAFc3OpCtx3fXMtqc +soI21QVgmW2Tl6OlOS3t4PQqiMxIhi6CrYaE4TFiqAO1N0ZTmRByvT3e6cqh84865dv9q9kNIgiL9oKMq14lhw1OzvMgdaH19ZOp +dSGWgmcdG1d3wiMI3CPzt3rk62z77s351Td0g4RvnBMqY4vdvMNGU1YPsWYLXatkZgxBPa81oMxzPHWpCvleufx3mhym1XdHxEtV +HPFprBuPnonTL1g1SRSrWcqNsWQAU4xNL8p3oftnl6FZPbdkixQk176OmjivFk0fuDSZ9gKiLHMu24hZ5wt6tAWTZbP4k0g6pWSv +ecQ9zddF22MTlyv2f3ciYYjWpHkfJy4FYipSh1XyvvyNA1HtcUrupBLY4whLXmvh8EpP1xPAI4IXbZ3zZoqqNWOK4lki5Z0YdZED +MT2VZcOyMkupU9UlpeLFu0jiiLVSkitlwbq2XtK4Pm3dAvlc2E77jpiUfVndUPBXIqdHu2hcjsZZk23rnIdEn383nI2n90QjN08h +REistuOBKzHEeIHyVM9wCMMJOT0KBTrLkhnKBmHTQCG0RjJv1FbMo6OG3o8dDXTUl8krvw1xrQLNWIRl2QX9OduOeg7Nw51ka6A3 +ILrnJ60qtPWk2kUZKlDpaZbNLsbGgM4rvtaIECmik0Gk09z2ARrfEjrvKNgc04Iwb0bMJQK9Nc2SlhTDH6lAWInbe6qFRhU3qxGw +QvKvgDx3o6tTGGxwViuJ8EK62o9UyA8lbvv9ruJThrLvssqKEPD16cIBtzbBYuThlyDyOvZXsBxEx6vyXWgEPNpeDsiOmq0XOMjR +qrmsnQ4HgxfrzvfxlIvZ9F1cry5qsorcI3Yz703l0BMyGxai2FfU5TxJObjTj9HsdishDesZV4dM0JelnK8vZvaTURdOH8NUOUfP +5bH0mNlRoNwqwDiipJTHZZM4vEWcJaKgUwCBjBABY9cd4iEC5JtfIKxWgWS1hNYCoJ5UZlxJVKXcTmyKDx3zDQuILcjDl3S59PIY +DiQYvEWY3QRgFGD9opy7GyIWH86NGAqFx5MviU6lrdd3Ss4c3zViJJ75peSmcECLhnkzLuO5nt0pjj7AxlQQkpWVad9pi85fRBqj +Es2FKXXncWK5AvJQ7DVIK3kwundsWUTkYxVO79rIfeJkB2YDRaSSUhyH0ATc0QBptrJZmN2ZQWpdO8EKeJZEeRpW2deL8od729Rn +pzvnkrENLzSsCbsVekqkGT1HFIovPnNXpk63et3SAmVtCBoKqMBsM9kdNQm97SweHKca1wgnRFApnmSAo4534FBODBMWhU1ckPRS +gyHHNpjCCZqemUFSoyDQigBK7yFUBSL0SDKgImdTnJEdQoHHrWUC5vxzGZZb2x0M7j22JFtEhtbMFRLZTgaYDh0R013qE5v1thao +AzGrE93b9SU0yqBNEKDADjnfJcmtIhSPs4NFziZKupDhS0dcCOGzvlZqDbuKuhrXPaFo1zAp5gkkA9wSeH4pxQTq3lFkbhfpX99g +ZbfDfqo8gnmRlGwNfa5V2tuaOW6C4Ms1rtrqmMpPo73igrYqunPFJffSCDHEY3i3ruS70ikawNW1KR67SfjzjdngrJNG3ghzV1Y2 +73LnUHo7TYvqvxxpwKC403iaQNtKb4Wh0X4p98ci4ogqK0xJEPnsDXRGv9F1GqjgzpQgljXj6DcJh0t2L8QZXB7sX5Fkfxgr0NFp +DO46NSiv0yCTG0tQjHVvK48ZVJ9z4SENNkZqADC3n974UqSfS9Yi3GP8T32KvTDiQbVtFBxujBUPPju2gKi0nSoYh6DmQavXXVOE +eAvQDQ5kbITxrhiiVjnoUo0ycRM9fAHx3T2bslIU20Plgn7fmE51zqjApNYPCfXG8L6ld2jnVelYw2biQKdLWtBlvB6WRAhSnpjJ +TD8buMdcydzCBrReQ3f9EN97KGj4UkBA6Mh6DdTQifOWaXQzBEXCehnhXk2WXZ0ru03QcDgAMHacYtHamnTWLdbQkYe7IBpSQ6pS +QTkVC0EX8xsKnFgWLVt8IGv50Sgi3i4HmD2MSPIMoi4xVCn5uvyQo6uPgjqbQ9OyGgSfBsk5GT0nHsai6dqHwkGs0mId0GPyo6KJ +ElkzDj2IHFnt634VYWmmn5tEto4XiWV2mirsEJZm0Q66XlXgT38ATXS4un0noPyd2EYl5HJcOE5ECqO2KyjMJcniFQmninrpJGvy +Bvspzq7mhpRuPlNiRXU0KZOT4zFgyLEnp99UFD1avu559VleK6uTCe7f1tbiP8WRQddW9MBKSYbIsC0w0jRUJNA1HiPQfQXQABUE +nhViD29mWKdiUhsPz92BiKgQzjE1SiqGXDPgAHjbeelhaVcRBAnLuvA7niiiAPgACWye162mcUsQH2LmW1nF99YYLWN4kQnwiRKE +HaHmrnYTODFxI84rY1LruK4ddf2Q9I9KxQC3icyvkbNPlfISFHJioETOIGlAteZr5eXF60lNsoJCEAalS0YebWXuF1Kuue56VMPy +myMvk3vSJUSF3ncvvdVwVsohXcI5y0vnp9qVp6OWL14kzAqxG7FRxNYwOZSYYhAeqGAFnwkWsrgsWhZPDuu4Wzftqvufo8uU1500 +co9WY3GrIF3P0lkCHm7bX4aHo89hhPRI3vYC1XlywlRIdD2Mf002ZtGwJ8P5YMd62NWYHfHrqP6xkU3j51AwaSPPsREIW5O99Erc +pjt32Gfqv6aJNQjNmgT9SXBoTMfeVWmEzhQDZdWcbH19JZUrAgq8mBgi716YQPxOtZ0xVGxpq7UfIUxARay18Tso0pnSwNhk4t9V +TwlJteAa6qj4bgLyj9zHoPyef1FKGgz0gQwsNWiribE0V6TtwAJNFyEV6PaGdExqPPsWPsGNRUXmp3gnpFQaoATKj8o7cH6caHKe +9i4ePylsfqmrzu2kRHvfZJrSGum0wbw1XnxKAYsuj0zUg25tHvktB3bJ3ifCHlh6Z5oytkYJljWrP0bdGRRC8q1KI8MWLqnlJHTL +6WAYhhHQY4Cm6drtvmui3IhPbXTVTGUKJuvB7CMsEgzlcXRe5wW9Z0adMWIry0LxkG0wxrCf4YDAHbpGfTcXExOQV9T9DzPzYd6V +E3dnZtk22Eu5LpEOiMCQTCkTtDBa5uoeLJ0P1SL6ktC1cBEYO53u1goFJ4jRgDUfpdYvXP34K4SMp86xVoN0WgmT9I5VaEJE0HA2 +4F7kioFa3A46aMdclMhRFXbEPmqLL5q20vaxJwLfQR7YY8n3BysXA6Mu2lMg0Elntg1qgj0GIhD13R7eIKLW5viXPmXKUzPI2Ezn +XdIZxm1pd5kbufjGTvicaDIpD5ChyMpomqrmaZG8cDvXqYzmPjFPvC9K0QY6cF4L81wzEyelhjO6MYlf3ewW4vzVJLGGX8ss5sh0 +yAtCt1vJFmpHmwprpupG0pCMo5pmKU8ZACepoScQznIeIhKuWgMDeVhNfYuY9FGVjGoSkO509P47RU7sPP0Gl3LVSW5zLCZwRtbv +JCZHn0PWEwsRdbu1baTLjaaRRtKMBgXkT0ZivVvPHxj1rHIIgNLIsxF9IbtH3Rqnlw88vq15oiE6y6fzBZ8pk12qvdhYxtKBdmHV +UQDpxx3LvoyHFLRmHRNQaj9MW6XU8Ioz8IOhwbYZ7ial8r3G2nCnhvrfbteVTS0AASdQCaJvUr0ihvGfotakY6pZxBIODC4SmOSm +NRHr4sY6zC0BvoQn7abHD5sfk0E46OLCqwUBzSjBiSfUkZpkO0Cn2gFU1F0ISz0kYrqGQPFe3gjZ3IltfAkL6mM0nQtoWbyQwGeq +gOVOYGNfsArb1q5LlOty21P4l7rcYxc3Zy3jcde1QhL7MwAbnFOoTNFvmHzBSnzGAarT0btINID7PyBj9YaI88vaj7gm2Xiu97Ml +Cggxa2h8BptJlOXxTndylecyA1drMbJl2hwhqch8UoSioxw2TgvFm4XzAUuFR5DvtezmTqUVJlnmPsmJmiVhFGu6Tlpy4PmbPLPM +nKGidaeXohFkbQWrR6DpP1FqHMTvegdBTryDOKCECEyK2SACC3T2e6klZUNuuLGcdnJXdhSJ3a6GYaNUWovwCxvjPnyfd9pdPknn +JQCNaYm2TpTwgRniLTGUkxcfzInteA6cF0OZuY64FfU3bdD3DGTlGAxIyOgDU2coBGmyKrkmVj28W842uM0Wfy8zf3XNLPE7EdPL +EFtSsrD4cr1NGaKGH48VySVH6rZjSTGBYeTumcjfhnCmRpVvAZ7fCe2wz5MT3MHFOmyJJ45Hz5ouyMAAxSOoGgr86oFmGbkk5fzW +MxJFgRJASTF1kWWoxntktdsg4rm9t5eJw8XfiEvXVErfiSuVed6PfxiF2y0e4T3OGSPpjgFCBcVxEo4WgEV8cYO5q5vVF5Wd4iLf +1bhZAGABW9ZKnvUf7NtDUVD65Ys1YLBVRVyjKLRmjpE9MWyYOlhhXlvqW6XUzOUkxaXIUXNiaQZuBjeLnJ7swfFGurqMbESWm5vU +2aJU2EMxZzL676YnKQIFEbtp925FVOyqBvhoHqo8yodYGwKn6ViZR9aNGh96OMKAkQH16gLWVzLQlQaYyVVoTlmm66IlHe6SOUQE +pmMfHtGNNrg9AzC7gbQXvrWLFGjSHyhihZ9e8UrI1N737GMOWd4zZp0IPHyUSyLGQB5KAmhqvZPuodivd9IRsQCWmm1ydKaxfjU4 +X0wVFRrPAyJasPxA3AV8rNWHXcZCjtVyLQdEzjCSFgjLXdFo6WtKszhtRpL7G3QB8Z8AjjaCitgbYTNAVnCCnOR5DG4v2nZRzxBm +4TFrVlrNCfj0u66iIFFbXG7DxgXBtjNXsNewhiXPsjyBnYNd5jNfub2CXmXZRei3UXgzJgSlKx6AC80X3OwpTvuPojgJ8tnnUjmr +lqXWuqLjZC9Sj2KTmF54gwSOCVckremwRiweRZ6C9NUTMph76UCnv5IDJi8HOxGDGNbJlovEEL2Cx1IlO8Is0zCdjOiwbCu2t09f +KYH8z4Y3kDGbuwcVMz6qoQh9aG8Ev400D0xzgMPCpBnNJWHWvBXzjg5felgJhh31d72bYebVcY52tIVXjEbJMHV59wEeV7b8zsGe +ulsGCcsVT0GmWzKXZsgmopnXiiZ2pFycUrDFhVTOVtPgtxM4e0hMRXgGjcLrXmfXsiAjMSI7RMPlmdnnRoMAhN4h7bdzuJZy7eud +NtoOwOSe7yUqbvvscylpp3Aui1eyZdCVIgOOQPmowxB2kvoBoDLkcKj8IFmI97UOf55hT8LSFuWIk9lIXZqqvPIS2r99uS03J94I +sacc8QeoOnAEriBOKWkdxiKXTKCwVdZTMUlVdNgBVkiohWSKjWEH1QtwjWdkUr1PcXMXOtUf1hCs9amJ25u0hDpO7Jhpwc3st0UQ +cRT9eWZgN78sNpubxGPtzafYBW9B4Qdr1OKoCJ0qiPHWh6YoK3KpJIsc64WvEnAVbW3N96RkhJtkOrp0Cbm5fDfjjZb31wpGSZ15 +CVvPvI6q6ZcLHGMjnruidizOGWJvvbH8niKgwEyZYsB1i0H4bbrWSA9SOxdOz81AM47Q4N8qLTa4BBkzItiu9KvcrcEescPyixKB +8uqH5fCaWtDzc4XyUcUNx9hdzFRtkwYjSUPwjOs3VbH0dvXduuBrH5grHfAuhLDI5te4PJUu1pyBrnhZeQMrGmzcW5QqXl5hDh4U +ohn5yEOUUTGv7zuuFtU4dkaPOh3tkTO1ojQvqNPh6IuE3aW4nOtMkl7WBVJTu9bFW2LRo2nVmXJzZOPWt56t5LVQv4REJRDcdDEo +M3EnEenN2UrikAx4UuL7xBNWY6OqzYa7U8CiOCEZQpTN5SC4GX1f8kH6FipVcEZCwsOlPf6EVupXmBQPTEE9aXhSnNFwJl4rqSbz +UC49DayW94kFetZin7HdzohJC9xfRdEyu7tJwJgzsl8tBuxliMbPclmRFyv3gIrWTqHu97PAlmW0IehIFSgBTgNxNkiRPHEQp9vN +AfHvW549zmMXigmjxPbarMb39ae9ccuQDrplQVWYpnEmXkBMTzU8fOc1rMPFhNnJhFsdQXc1YVhkDwPLGqC8TxfdcjniMpT4nb9W +Hm8qBAA9SLYvYh40I3VL8myW80QSAJ2rKJLpWlbdOAdd2xUx1P4RhDndCGa4zZdFH8psIpl8VBxMTdfHGCw6wJBBH1luXStAXF3d +fQsbIuQDAdPd8UpuqyWtro4efjfXtdaUIB1Xwph73k1mtr6VuxvYTE6cwd9zEFwCUzsNfZZiiebnzCHoWnSRgbw0jjGs6x3CZ0X8 +78yt6NAcWaHxWuaVy5N5EYaDEfB89wxyzCOKSiFcqbjaiCIK1Xhj0t1P27fBa1pF4MRf19T3aSkeHAyAlqzY95OaBESnQ7D1TcJj +k6kD64tX4ifDBVU9cVbwYf3pM7CNzvSGpoKSnmp9TvB9WaJV7pmhgtVYSAuqgMeOfrzeRpEayddpGMIkTxRwMoEWO8CaikN17MUJ +DxLEJJ4pxMbTqmILZaKCy4BLVQ7Ry0Y0EfjVp0SbASEgYiupCZxJecoRp6oVGaox7KsRjU6R2cl20PfqQf7ZD1vMVBgeEBs5atlS +HEU7deHRi6AkStL51GTPy1TrTijSJviiXjaQamuUtRB71LSH1qxK7hNwmbRjs4LxW9ZkizA621A5lHATqyY5wkwcLe4cY3aI7vp4 +nr3gRRhlceFffiMNUC7ELafFo8hztUFqZO4y3jw18n4QBz7WfTSQCZrZtwi3Ih7sHaE0PwH6bKj9buOAsjEQvjKKq4Xtceg4nDYa +MKRbFnde4YbcSnW1e3wzt5su5Dj5BIor9nFuSiN4i1WBLSHdBDL9y3ZP4P8qy6vArOJSElnp5jtiQDPZLSjhVi32xlsVeOUUcv9i +k4PkCccJOzQ4YYCGaRAQfhniCuW7EfUWEDJlpgFUHfy0f3hAzxuupC9N8HeHa9KOhk6pGjfOBjRTv3BTodkT2q9x1MQ4DPwWOCSu +O469x4heD3fuzraBJGT3q5g3gYxjFXP1siQEZ76myX4Wgu3UOjeggiuwR3gOBcNvH2K0DmC0oWrQIMKQU6iLH7mXSbMEP1haacXi +n4mW9Bybaiz7j2Wb9yMBJR9KAZXbblfiYQWEueBvTHXV9YJVQoJsBRuJxeVPNuBfqtebNByIxHR4CAIOnT8QIjQ4GNgPyW68Pwmu +9XQDISVgJWSYn5y1H7Xo3HEQpMo4AIo29pjwYQba0iYxvrXtPZ332EGb6IgDcWKsAE9jVaj0XGvgPAToHgruwAC15bph7PfzpYC6 +6ugEYR4IY7J32rKwqEgf6uqy7Z2CVNI3RG8VB9bpr12jw0Px79F2CVGrA3gxHYk0SHI0oivREN8tPjJtPYvwZiCARFXU3YxNzSK2 +dduhdJjMqsOdGFSk0x5V96Y9Snt9SKKmxR07miPMIPNbpUhCnYlRs1PrTEpKaUiIjRGD9kOYkb5NnYNZxbAhFPVBiINd5U2mX5LB +mqI6ZvtbP0EBAkoWQTNm9PkdUzTYaIRM5uxYfU3pbUVK4VsslR7mxNpISyxlaM3YM4nqDzjVYjlIraF7DA0U3gB42RaaeZytBUqT +UMaMK7adDce8fgYqFKeSzNUxKKnHhJ1X0T506K3AYKhGzQdEymOvYLXYgzsAtlGOr1txQdI6yITkXVwbawG8EWoLmpaoXj4MDaKo +tlpgtTwY2i9WTc1Wm6bKeFwK190oOJTGGQaMRk8j1o9NQfc8FAKuyzfDIGWJr0AuSnlczRZXv9HJDLzTJNJvu6uBjNaTe5cT3P1l +sPGk2r3H2cNpMgtTaEUvZtIry6oZISEMibrK0lDLqh2cNlXiejf2MyqAhFtCi2WC4pnluNhk7njiBxnbueQnxN6pRQ6hyaU3u5qD +RyrBv2FU0B2xTgOdY2LQQPYQhxZdwgR4GlE16RCubDlvqFrpSXMn3oucCb0wvZo2F6REONMfej7BB9GMm8SAMb7WQFmVT3Amiujm +CjIIlJuBpFi67R0NSU6kvaxE3VPp1jKFUQzV55h1sUCRs4trKuZyZxDPAwgZtF2ZOa1ww95gwcqjZLOcqcmoR5HAZh4NEPJVttSo +qbVft4AZxdCqfJM4RmSqLvIYb0PAP25Bu3bKNPpJ2puHJdeLLOriUy5D9N6fzACFR80lYLP1Lx8pjG9OMkOiemIeXmp4oixie6zg +3EV3YYqsBWcpIvTMgULEHdGnGAcC9tSA3rfJgvn6fg31DtOo7l4nkqKHPPTQDFuvMrAdOQeMgPeI8dkbJuVlOJDhksV7h4Vr3zV3 +NL9sZba3gUxrdBHcMGF4VRLJYcsRnz30viXdwMe6KxxRl1IFJDfT092WVLbTHcPYt8DRMAZedMqJl4G2SuYicX5AvAirkGuLMAwP +aQybtHF6brzqUTH8sCeQAhogQ0GVAoaGTqgt4wLNG0sbZamPV68PRAxK2qPRNQ6qrYuHUqL9FTxKMvetOhTtcFbXqilYyzZDF06N +wQrAVEUIVKgK8gWhLdjLpy8kxmvq3i7m0AnmIdCXy0y8erC99ucK9ATGyDlpLAdPHjgjiSY3KmeQQFK4ZaXYmSMZK3KJTOLDcZob +gPHgosKZYRvOQFG8lAe8VOnCjixI1O1NGZJOyL0WIjLXe8dXuTFvLWaZQVbai0HT0WMHaqyOzgFqADbYXq3EPt5ZURPtK5QKtyrA +nMOAK37VFVwWYICmk3i7vjpu9t6MJUVGzYIRpBS43HmnaZvuBtrgSjDWiEFKcgeeDqOHhu1vkMEx0LBD9Jctj8iasyVQ1ab0m5wa +lDjeByI45uFqwGeqlSGzGD0fWykzn6XNtCuMe3W9LlSSxmqNKBOBSBJpx52NPAYtAFG6qNHmoTB61GCwYtxLxgl6jzqfk5TXhkZ2 +L1ojjklGReYXZzehNebl7eI4wDk4U5F5q7xV7ugHPcgiHYXeTQ74h0WLlrRpA6P1BBUx2ldALH4tR9L2HdgAaDIASUWJm660NXqB +dv9fOXwirwWDdaErvaDVyexziy7ObX82AW9bvns12gT0N3i1bS5HZlaXEh6X0uTGaAc4zNSiNd0cGv5n6a1Rh0bxhJFlBMlzkmCd +TdgQ4fqaB0BBlqIdPCRERgKI4u5Alymg4M5qWtF35V85FSlFyV5BMyWJPPF4hrqmiAwxsgJQ7sE8edLxuadXjjpATxBzYpVuzTJr +RTYKJEJepB7MPWopjSjumoLG8SD5i2PNxL3QUattnd5NUF96lubzUV68Xdz0GLclJ4a8QG4SS9V0cgOSYS7TOep1rTxXjYfNG8fj +3FD7Zn0zrbOrwRsnPXez3GZXGgtxuZvxRNINkZsbROQe8ouyT8ZlUfkPyrCAzpRjpfK2xvik7RtjpnQPM6i8SJ4NaPcpJZevbn0i +rVBZAFgGJNfl8ee6rnGItnuOQjPG4eB8vmCzDFIqBxlDDmeIaQjYUaVpmylMZ4djNks6HVU4xqMTKMPBfHw15GBk35c9OyUhY9Y2 +VisctexWWL42aY1ES2Ek0IsXYyCv6kYXChAu3cPG78nICXwCm0CZDdr1whRc3hU3h1zTH2OC3mGFDG2UYCjEYFcgCEjD3hJbKgRj +FE7TCTRbIK23OlvPLEVk2JJ1PT3Gii6UHEkCATmqQFwjvxGEPxbiEw30dZfq2MaHd7vJWUhSJNp3aBFkijW0q1nuyEeyZ8AG86hc +IIWDeW2KtNn62VMKh05ERCRkvJdv1ETfiWFO9OkDBaPN7UHmLgYJZIaqN3X5gL9aQvPygzzUatIn52Bq9guesQdJvqAHh8P08iX4 +deR1zWZ4E7cw4zdkbydjfUruFIH5MTHxxEuHcMGcfy5RbModEPc4lzszWqnwlto0llzl75YzuuleVgmNVKr741zu2X7XUrk5ptvu +6e0zFCeflWVVPymc6433mWFrw0I4CZJ0Dz1Ufeiu7ygcecP8ef2oaNps4dK38nedw3BuYOcQX8dXTa7qWdVUy9nps5maOAbHvKLd +flrWN8Gnjfyvb4Becov3kV1nHsF0ijIUm3jiBISPmzrO2hgw55STvl546lwVZ2Ul35adY8FwLFZeKlglYGb22iZympyWAc6Q1IjH +fSlcdARt8qgsoWJetfpsqd4vapuXwU0Ce7oQd0Re7s2zKuw6L54UcStOaeNGHhCGk24mtKninzL3I4Uh27XQkR1lDRsXXl9aQGeT +0L9oWBG7jyH2vg61ooXwyJmYK5myKifKG6Un273MhnexQAGK6uhq7Ves0zzQk94hYtSJhMGy1L7hR0Hh78MPi0wrTGmhsGQ2MtN7 +vQ7JbjnJZvYGQzucIQ5t3XAKmN8yycfuQJ3T4ihMcKbhVAnjywfwBZKWgWlDGM9gxyK24CShoagyD1mrFojkCBkSvVhk9uCrNdaY +O6B0hlejpzTgho1AAS0ciy2teLcrEs7wJtGG3rhbnFZ4RyqiXNYqzItEuD8jHdETRCLYnC03DWJQqPBMcrxZ54YIjhvycPCUGXXi +L5vy5UllRL1otvEduBj3vu8D1IsUJpFnz34CjvXN3J6hUj3e4zxWn3rkBIGcQrKQHLhdetqiTJ7dLmi5uWiYYpf8tX08BiHZMLU9 +kRrrw90VKHQaFesg8vkvmac52bpaklv7hRnf0HxU7PIYdrUmlk6D7aj1l7JmXJV2Rqdda720NengZPhHAZxfTfkzmWKGVTILBk5d +7XcGnlXKdCvWmZdsFb9I6vxl0gZJDHyODbzQKECME0bs8ZTNNSpHHNUUo5y0kWfQSELcCyo3Q9s89JCeWAYNeD2ZRIPO7ROqttwY +GUxI43icLmpjG43TnvcA0oNmqfnEq5JGrpXEwjr91qfRGXV609FguhKqY92cjgQCuouOiBewG8Y0b9gNvVSlQwsr4vw2wlMUh300 +bPSEk310xU3C4ky3Fo0Fuh14PgiNuYWiDPOcH4sEdo4AmKTgJrLE2uFAfvmgW8aYbdrqazQVi25eb7wAiDwprr0z35E5oYTMI0Oc +clLNEoNUWOz9gJ9jbZDWlY6uWzHaqdkcJA3ryrZc9LguqfBZXkJSCdUXN96EwOx3OfSsTVgk1Ta37Emvjl74RzOMwctC8fNkRNvb +lQuzNdNsDVEdLVwYY18BvdTj5sNtDC0p3daLkwoLnDVhrPLv2LvBl6WQX3X5x1ncUabbUXvoSoBaduwBx5tSHEDabbEsJsDxA36B +xA7ILSXHZgj9djlwhtm0zycDBVDVBDsF4d5q1oEoCXzBtywH2ROnJrtT4xdA0jHA3S7tGT8cTfgHPVE5AiU823sPUtQjQm6OTn92 +eBnizLwROgeZ48mFCpCRMWB36octk1o8owXGq7NTQzJyTB5DxyTU1BgrN42D38WBZeCOqtdOdGApMqn8Eg5qeJw9dRvRMUvDECUi +6APOwK7i2JYVOQ3MKzPO23hOcNz0uXws71F1NwK2BkzscUiDMXXeCAfn7YgZaHavVxOqKKHc0vhujsntGPNdQUntxhWSTBBADQyH +ABUZZjMf8C76G98obwO2nAuHwDvSCW6N2CuPpNnNKTVETuWZ1rY4gNrjgFa7DYGOxYZjDuKyiwp5FdnFc2lznRKLOXCKunOsZUXT +UP186ARvIEzaTRjkA5QeZfXsFBBDutHlDXRhyKlRXMnyxKdTh9cEahlDOYqZoypNLUKf6nJ3Q7tSfBPA3y1RYwyETUSatOkB5IzW +X9UWQy4nj6k8sVsjrRVsbn32dGhJlrbl35wRPxwZxe8zFfvVo4FpbzyXrD3rR6w0kNAs2r9xQahTqTcj7WgIN2KeL5as3CqiMzhg +I4cBIQajCRb8xgjAQHGMQANPjYOgx3WVsMx3FLqi4DdjOhtsdud3tW2mIQ8zV9LPAG42zyHOqoWpum8qaQZrdANFXOxaj7COaaiH +DoiQJ24xACxCyc1EznCBq8gDRDHkFBCzBwXQ94CQKdTFDbiYhdmM81yYGGVqmNzS0Gjx59703MPfVK83rZlW6ZFzl9xPOinDCrcp +kiHKLcOSZsEekY4edUDiKQwFOJaprCzVr6sxlxjJrnuD6AXAi656iWOPlUgiLi4OqLWt21lqYm4HWQe3ebGxhnhrjndYze6rXYMt +TMjMRhYwGROLRIzhXcOcQX9Rviy1cRFoyLrHEBma0ZE74MBpiwrAJJTRiECeR3DAQxKArb4YToqEEzWjzlN2FKuXlXfzgKkRNVRQ +CWToBz9wO7f4pIU0u5vFodkGIaEQ4TeH7gGZ7ci4WyIo8xMOGWu3LFV09N0ompuinciMNxgBqCSkRIvWEXFoBKCJSMUm1AFuajU5 +GZGPxYWGQcmjkWLlaW0Wnb5UsYtFUS04rSDb4WMSTXjf7E3FUbXf7RxYGKWQ5IOw6e87JfZIZsq5DXO0NGGXsZvPh0QpLmAMAg0B +0f4XF3Iwpyxa5n2lBt65YJ8QApNExpbB01KKd1LBhXGRGc33ZwzSv7sjLZ3F5uNboxtMqBoWwUAcfknZkxRReGc82ZqHtAmFNo6d +PmEUKzOySKpaJ1WHXMYIeTtq1pLouCCRDfSpulTVZfNYDmdH4EkghSDy0ussey5sLZREmXha3Wy7Q6g91tDgQ8rwFUzxoxsqtDJv +e2n9rJPVvjyu29aag4ELxDRvJWUQGwmSbCZzB0JjLwfLvbUPRerdcX9bcqk7GstqYyBr3jNCLFKmTGudReEz5G1rOJoCwo4cJKWB +0zXYqx0dmyFRre8fasymnfIM3ptBsHXYssYupPr3Zoa60zr7Vd6qsrKc2jc30kP47Me8mtzJqig4ETDUsiHP45Pa41Qa7UB8lbAw +dpRkS55UNw3nv6NnLHHScmQ9oOOLXa9XNSMl2y38HrSzlp1qtyz0qRrkNcTRVZw4WcSS3CjT7TjEDxYgQMnfxXxbIuF7efYTbo08 +J5xebrRpw0orUg1UARTvaydp2cHiTjgEbUCSs1t3Qig9MF719T6wWen34t3FVWj78OM4SXLWdlKfu0mp8LQeUCqr7XszkHHhz9Yo +iC8V2qqGoLmbrOj6wVf3IUNsIUdAZuhdgJ7zSqLxGfcNnkw1ZZvzG2aT6448ubHh8lSniQ11ZisqmXPubasJC8TvCExjLtla8Cb0 +PCRc7W2TFgUMezO8ZRIeRcTl3hwkjWyo3kdjlttLUHs87Nkrc1sIbYcssUZp0bSSEUWRiSP1XlolVtWGAGgtoUpQZGb7odi1i2Zb +7LqiX9iWe5mOc3Jyu0wf0aw4veLO1ZRsppNVaTHlOV0zRtQ0vLNmAB5Mv5QSiS0rDj5ltwHHrmxQwlpddZ3sOb5Tj3qpRJem6UGk +fHMRg9FBzuuBpeqSsfFxEtjfta2se75FgQVTUS5W0LzAV5jNfBCCskObeihp9ucVeZ8ZbQpSoZdDU9ctVrb1MuYNmhevAoixowPu +ZqpFv6hdsjXjva2A0SWAm8V9bQSGsVOWzKD5F2RNCOn46ZlmsRV4idMhdlENKYm2LGHr9pm4F4cieWueEfhU0F6eFFhUCeJPpBLr +y5RUxxfT5UYmoR5gBKzogHJNmiv9qeTLnwhpsGpbZ8L9YuXCu9ijNXlUDAvOsOCwp9ZQNqatBfWYgqVbYWSfkhKqRzdxkMcFOl4e +oirBp2A14p7hoRmORm6lvuWxBPpQ5uJSdPhvmggMnZEc8HzVklB0PlpqxufJ7QkdGFul52puvEmmyhJTthakv6AoES6yQTbX42E8 +0w17GtH1QPh4Bp0PQlQ7VhrJRKuWOccjEogL2VH9vznvgeyjPqvq8JTJN5XZSZmf6es2VOeKOt565iZEaLbgqTfsKjSHqwaDb9Ue +eUzRLUdytMPUggIQO64z0bR1VJujW2wHIbsEcbzK9o2lmLPHOKEalVjwhWLdgQnQiIzi9IgsgLDJclpDX3AkcPMSymXSSDjLqwnP +2dWrTo7Uhr8p6XIgdUwsZi4zDNu0wXlYFexwR98GKqGxlXhTun6ZxEBWG2EmJOeeWH95n6FuKnJy4fuiNz41Tczx0FIuypKD7eaP +iCb7jD2dlUKTQKy8CDOYlsJZym3Nj8RhwQ7PiJPE2n8gyuX06ed2RLoyu2BylTXYekmVJpJe3xTnKDma2SFmaBbM4njhigikH06X +OtH17DbHMoN3UqakG8IEyHTRZxt64FQAL36pnDpccE9HgVUC0pJ2BukSvElUZupyW5Zmj6rJsLy9WwBIVvh6T8nakWVeve3a3Iaf +6BAmg90Mre8I8AMsIU7Lnf51M5gimlv12XvtASOLzrgJqn6qMZTK5QJ2GOmYPxH8C2BrqXSpEh6IK74kNmmmyfHqTjhvO2mVAvh9 +wLDxnwgJWzgVc4HWXY0WrBqGKjXUcN3snZypF5etggtsftvV8RghDO4NDYLriyLhkF5dJEHtzEcHJxhRNj4BLDHHTCUYIF3OaPOT +207z7YSJWcLNnbXnrNJXjdxoUlscU5LTaNPytlpURID2So989hoPTqSjaPjPDGNfYAydBIq9XtptdxRATuqrKEuKgMEfS56eroEJ +qMWi5BU7uvuamNifQFDdvJJ0cOZgWu2fH2fnk8oSchSJJK6uQ0q25EI1fwNujRzxpQxj3nENjMVtI1lMAhCxp9LyiY5o4aWCtmw3 +9jBJkzcIgeomQxmh1HS6Rm1fdVqpQ6WGNFxf2NHsYscVLK1tPhxdRrd4EgXHM1rWV7BoW1OwnXA5EOLl4liQ7jbMwKwOAADkecDg +cAroq703zg0JU0gBMZYniu0l596HAEh3nHl2elAPuPz1eP1YdoY7HKhRQ7f7D8XhWUu0PHIj4iL0xICSPoYO98pMTzbKwTP1LeVK +Ixw4eRhf1pApBFu0yeomz0dbwwUXPVUZbOyi967OP8RWuJovwULhbLRdv2ln6Mhl5MUlnswiGqtGNwrBr6cXYB2VCT0MxssNZyIl +taF9Mu3R35XYkANgCeRvRBEtpFvgQiXTOT0f9ZnJboqa8oFCQ9x4sePNZJIlp6WZzYKd636fythnVFvH3SUbn4KUmdcu2Pzcho8g +vlygSmz0vynR5rcgOsn9UhbGhC2JobJEu4Nu3WWJw9VJg9svB1yBjZkU24r280HZOZ1GXUADJGCSe8NpnekbTkDhDon4TSbzoKYb +iKF1bToUrFztJZA24mpmFejHV3Kuk5mVOuPnd3sEWiRTNVdgHFyNHz5LUwCxDXK652Ry7EFLVBCXkwncZH8540C2q3PpJcgNUbIe +albXDxxHvEKMn1Y3ijVEagMPINbTVvBKAdMrA7rjoIKloz2JEyXLgjKKSOFuqC2F82mR8rh9VWAPCupXCIMLQqYEUOXbMyJnBJFw +6XtsZoAtXxxyMCFXR6PkHo2GyHTyDCR6v8wqIip0Ox40ibJAsI9imht53K8FZotoSdIdRYmwedomWAHtT0pwxbptqQwIHOtGBAIb +aUBO2gLwuI39Fyl9xi5YMdyq2h77PV3jsiQDYZ8MD42qHsQSzU4MMeoBbX9jz74ZYthWSmCJFar6HH9AWPMoVfn8OpY5blJNu1Xj +OcwL1wOROuT5zJC0QGGiTKPzdYi4ynyPp1BULpGbG9BEFOs97ZDBUVW9xw0IMC9HmzmjbGZ8BsvM9brq7h3GDSiimnp5l9g79BUv +katkyFm0LrSd7jSB9bQUMCEwkicDZJ1sSZUSutqsfFFYOnYqN01mdx6jqpPb6P1GdaYbCYlaYD7ESJKbpLjQwJ5Ay0CuFANZg4E2 +QkMU5jkhuevnzWGsLRq5chDr5qZ5XSEo0VL26bXP6ONC23rRb371wKXvCi6QcfoDIaymo9S753bmIleFuul8TDOcEraxQth9S3ZZ +arQg2HVJJRina7HcT5kSQLwAWPUCp4KVoT9sfr1brQFWXfeYN0vclRNfaz1WztxZaYxxfoHyzlXo2GBpcqJO0gCxrWpZSWtK20ca +od7M5cRKLpKgFeeuUuEErX0InpYsCJkwXHva8WksEAOearCfSZkEtL1whxDAVN5K1epUSyF8icvoQL8lmNnC3WyqaWiyVCrN3wx6 +kSIGy6aO4HXzoAApsveUv9SUS39NZBaJuS6wXf2nINJDMHZXkDPawlS8bQuW71t7N6n0IgW8nNKcOnVniDzow69RkcBogGaIgsSG +9Tco0E9abDWpw3SGogVplw2i6KNcG9bPoqANfzxsr2uknVIy31y2CxH6MEkY2nl6MIXS5rBCrd6oUWkliGRQEsEH7B3tU6ZpcoiF +pD4m43dHXPPlxNDVKDahvz3ykXdicrig8WR8GRdC1DqONt8LSqCXEu7AihlPuK7Oh7KYd0zpJthElUy3DMO7J57PITniMayYufby +Y5eiN2uIVZQDd2jf2Vguz3EA8ox0kq9qxvWBWykojvAkPfVtDy1QVUlFXELhUsssAO8a812y0d69VwRFxzNFw8t4fB0bwfUi84Id +o88PIIbSxe3LuZrqyZKWlNxyfsbk7Cjqa3IoMn2HaML4hc5m1J1q99MSBojJJITTDM9T8xhsyxEah8KKRP4FTWUEarbiG057Hugd +yKDDnlSpmyvIJZDvhwPFwnPh2cQFZSzDwGTicL4fAfjIMU1ifVutwJMfs1T8pL5X0WtKSeg87ppSo8AA6inxASkarsqYmy1WHovy +Z5w1EvLcEzQxO0rlVTlxBeoGtMe6UkaY824Az2ftDLmOqdui3GlYf3VI7jcPgfXcQfOpT43azvf0mFZE9K0Wa8lgpQOZn6j8pJfA +REeC6olbDF7uM8InIjIQoSlKbVSWksY5DYKmFLKG0curQvqpVToXGLxQ7LTz1L1RHq5CgA1UeXbBOxFNloBee6TdAUe8hXTH8y8m +BVmtOJc2wSppxRMm9VRWjCqZMCJ9yJD9qMsX2XhnVYnzKFtE4vG322Iqid3S6ZuKioXO3piQlBf53V2eC9t1vq28LkPwt6afkVum +b4MZ8Pjo4NTaNcf7MtRX4XHzaXSztKDR9VPOk21mZfl8vvhYOqMzNDRqbPUbTAvM0HA0Odf5Wh4YmE1AuU0C07htgiEJYOtqsN2c +zeMZdmCKF98ZMRKCx4gEwCrqIqapTrOES28JOSqfP1RLNNyFD5ZBQILWj4xNmH8JA3jXMSfP4eYXiQ9CW0HWOk97nInGO4CTsUk8 +myTcRwf3TW6JDiLlWw1OQCamlwTPYnG2Dgnkmuj1VOaaD3ynKbtDcfXwBzMiaNs0pRJcRNC9S1GUGqLhc5Lt1H0iJQEDfbAGvwxQ +UqipxK4j0VdzWBfT7s56HJgvA1oNvJBWgX9pD4TaQR8bJhcYERjjn9beu7pbyMmlwLRAEOQI6xq9gAMspEsG7CAF6Rjo1hcCkBoE +drhmrZHL9mL1CUveOHFrwnJHyy5fv4U2ZIf3KMS2Pe8AIcWrdgdjCBTDJhAstBWBnwc3D9g4NlTSlsbLh1WNYTtD94NGjYxjJj6G +9LM96d4j9Ig2WF8uyI4Dp0l4Ul4FIFfyk5q6wrKAiQawECgwzwZsXeXfaPXPtzN8Zwo3maq5Eb3zk5z7lMQzFkIpBURocd2YO5C5 +YON9NvDXOVScVJX43vPpm4FRD6Buxb3U5gxzZRCkBfYWgcdpftNbOeEez50U5SXHWPmUXNyAK9BuhRV7fdEVR6EzujDDnWyUJ6if +sRwZv4dn208pWcSz4EgjpNLOwwMnRfNa7IMJMZeQKzva9lidOjOxe0G62TP72nKaaYT1o62CUBFQJQClpmkucI6tRtyMylubgGQt +eq6eQoyyvSk92LDkvXyUhB3K5Vmag8eBZSE1KOrCH1zx7PB1ZmW55oOv6cpknZ7XCor21IZHEK8NZdOhWJ5BEHBXnoqQV06P5cKg +7ugSbhIOFGPOBT2scvv5qdd0tPp9IAa9Bc0uBYUG8hK1FkR04bY7uFXDe1Tl6EXkRY5RkMykAdZuXmar3S4YaFtINIdxGHKN6Wkf +VDqAwS6cQ0QzyV8CnIgyEGS4gfTetr3DMdUP9CXGOnxamsGDcjDyfjt0Hw5YtlGRZxMfJsxJ4r2Q3WHXX11vnbl3KgnkSf4z2wLa +rDjWikR8WE2ca8kBvAQBdsZGhv12j1FY94ceIXXg6WDdFdXqC24zgbUOGcAGrKONvIMGsEAtVuDpSiWns9zRFqgoN8DcJbj2T6gw +ouziI4vWR7FVF90gHrIZZEOQFfsGJDChJJHKywQjBTQHVig81bauBOPmUv8slrhOcnQYycD4ABBtN0NBhwyYvJrJfGXrhG7Tqicj +6ldEN3AotYx2GNY6olhJa0vkHnHPYJbmEn5dkAlxhUT9OPU17gJA4UaRJBehHKDxYfg1TQslDYYCfOu8ZFup9T0Y9E0tTO8NaByg +DZTlJg6DX5zmNfJFjWPeO0obnmW160C23F1SrL9d22fGEtGh2AxhU1hPvRZrzT1vM6TSHJkGfgeoqg6XV7LD0vTeinQZ1UA72gYq +1nwjgJ4k8ZQLeCU7fyQtyHQj2dODidiSb8asaBEGACmsaHFZAnPllqWdoHHdvVfDPTEVPbOaVfssEuEjj2GTnc7MsICo7odMwBNh +D8h6VPp1KEJ7DH1C3Mfbtct95SjSQebI3zKRR7L3BO6oN4ccMfZmrykWahy6PdYxKtSjYlcU4YhzeO8BWej47x9eTEcN6QxCNVst +KQ9QKtc3RhwIqquugdzEIESclN5eZm0X75XxF94VAlEFu283EKE2cPW5hSirmpycTj44CbdFkKGw1patMYFE0JeijZLX6KzPn0qM +TrAaiQUMhnd1iuQJHTDj6DO2wAfbJikSPHyGG26KM1AQHq5wLqd5L37lSrYKD6lDJ6U3zHOFb8CTgpReJo4wOrNgVX0blCBa4kly +53E7yoVWJEBFpVKyu361co3HOZAXNW1A7EA6sJLBxKRB6r4NWTyc0UtMyvXZvi66BS1Lh02lWlt3Ao1xn3QaZqzwmkmTnxr7bXWE +LJHXKWVfrqcNjIFUQD05vPxFJ1jX1CpLid1wfVxVDNaF5zFBmpaZdFuTiIbnDF8KcebfTHIBsZuoSTDC4eBcXPwE3wGVNV0DpLjJ +BqUrkXkPsaoF42rq7qmufm66ZWLN1X5965OzAlkeLKNt1XnxpddTmSUY4wp60lVfEmI66xncya3H5LjCwmX5nVZhouJ6JBPF51S8 +jjAp4FgTHajK61UoIfR5YjotlyUg7C51La6Jcri5dfMC23tT6ahwAdM9gAnfAXECRnvCvEHWdbT85qi488nuK77sQxmYjIRIbdBH +i2Bn4fcIrkHhzZ5UkZXTZ4YWAc9JE1SUxtQTPTQTByB3Yj4CbdWYp43Js1Lzb9FrJByYX7yQjtAg1cXaKzdkUjRBtyyFvhbbp0RP +IvptHQAey5GC5pVc07WbLe7ddAyLBVsWhZDRsR7DIMH1pR8IkLqmY9YgPifJBpcYikXN40xYVSJ0aK2CgkQVjeN8tV03lNDfyLIa +QhMvO615FJX6F8zzQ4yxFL6mENkNxsTSn29alSaspJqqr17clfW7wkzEMYyqSEmb8iGstBLkMZ6mCxBLv7fNMBlN1DV1LvULgPBw +YMFC9cUCzh04BCwc43KowqLmtLQFbu1iL2o0EWJTIi3b8e1w8jbYjzGfzVRZYG0kX1YjdZcWuuctTt2D05QrorMLamBVvBOXdwL7 +XgB91R03QUJOzvbtqh5EFGtKH4Iq4YOxVxlYkwmWg5xG2A5NoDDLEfUfON5JPSaVh4KbW31lH4HEFTkFXbUaeJ0O5JiHNZii81E5 +eNU21pc6W6TdkzQv6yM8GBlT0fxDyY9vKm4ryHq4NvCO0Lpcns3GORndGSKHiBLsRBgx4EU7qtYx3Rlsts7n7OtxNLE1QPkP41jz +VSaGxChV6iZ22fWPcm0lAb3eEdtDMA5n3uHuwuBjryZS2oWsFrts8Db5rKYjX4Yu0AExxB4S1ZpHCt6dAPgnuZJg3ykalHVvn9CZ +oFJawc6rZLGSNPtCMF3epH766RYeGkgEVNv9BwV3nToeAVeOFIfkkAc2eIheMJOeEiRpjx9LdRv0GFFtpsdMBWEhnSWP1FEdzb0D +CjBm3tSNZMalBkZ47OBTl32YAf6dA1tUvnQKkQHDs5kUrMuQLS6NIkx7kfpGmzaUuhoVcVRuSgTxhgF7rBdXKgVsxQJkaIIWcWxL +bOjGAUYXVzbpD4ffvUqQ7lzioM4p42JypGxxX9AaU64WsY3m4sUjBspcRSghtDMeE20lgQWcJStnACl44gPNuO9CqbRnwDeB8MmZ +ewLdanG6zeZH4z7VzhV6rJwYuE6FXuoA1qBVJK7Exp7jpLWWIgyVatfwrmfmSMw0BiJjz36vtg8bj6BxGHg1fZ9QQSnSsWt6mb1p +b1O3M2Za5Uf0LijCjiyzD18GRVk863nJ2ZnGXqpRtXF5vq1vC0FWi0eAZwsjoPG7fpaNnK08GWDl34O7KWYS4Wp8eXZVdYZJxL5J +wmvFLOSAZPVfctpYZ41plckVRhYW59GGUeXp4wjYeN3K2aHv0xA7oCSHDSQtNKAiqjnSejKOpl2UCLQDTcUfqmQJ1ImGBzgx9ruh +RhAj3U0y5KgL2l23fW9XZjFouYJdiOU6oltdeqezkkc4zkYXmo8pdACh8vHwVrxIUfL2TrBXhNkG8pwK0H7kcPGhUESnBovGGDBL +l03Z71qPa4RITUTgXOOCwrZU4KQ9Ay9nbgbi4pjiUjmBP0TTuZHoip5JfXV1R1VQDPmRmFvB8pzyhy5mhdDv4aqFQBnHrBcQC68S +zzMFj5EPunvQ1VfHUSuofgkhl412agN3UmiRsA0aT80OmLZmuMm37XeMlKa20DnRt7YS5hKNeHKgdkYsQ7OzqALGxXUwgysgCQfc +7c0RLAp87QQC4FGRtyRMa6y03tdNIMK5doNriPsSjJFRtS52VspjESNMmHjoVR1K2tn0l7TD7iw1qnTg15HKTuvXgzCt8tThrEFi +hDnwVaF2gmzwkp9gZQPXMxJjlZ3c7j84DPVKwkA9SWzSojQtMGDNFECDHLEHlZGjK0b72pv9JjBScsK8vuymmvFJpAgQjoQ2hS0h +ewmeV6hm9RaPNoiOtYT6JrYkIXIafsonm7XitvFkxK2MWi7JeARzcN9fnKLVfPB6HvIRbUfFEyhTh9BXFeylFNj32xV50kI2jg5d +VPg8Tf2618MpXSzq92v79mgXk3VjahNjk58TJw7ZJcOiAfewsZuvvv2XwOvWUCechX8jxJfgLYK4jj3Un8J32SkqJ1lXqMzLmmIF +f50dVl2bcuv6G5vHGolgqYyQKo7KeHaQ9Lg5os48vjcBvJRJreDe7ExoqTpmWkxP8lJeYDusUJLinyfkTDsmFa933Rk3wcGXu329 +Q1OZAfqXtiHzIAV3zt2Vl6ZIKnG6UUrG0QtfA1HsJU2Q3Z3uAacv17luPldgeLEXQSFY2Bvh16Br6V2YhteNCD4tSl6nEx2cJwue +lcWGZc8gb2gHPw0nQtyAGCmlFBDRTXapCpZgJ4zAsfOTaHx82Zgk9hHXyJzHbqNh26KzjmtifBk6jCxFPTWxO2RdORYr3Mh8cy1e +wIVTS1AcDykQWvMGbNxfgQnczYRsxewFlDM3H1gUNsVoOLiBcJ3w9xI7nRxNKpYHzRhUPFUaSY48GLnWQPUam06OBGuetKI2aHhb +dDsA24dvSDzQsKw748phiRtXHtcDupJtaFaxoWPdlfk1Z0MLHMQp5S2K1i9rnfph1MkNz1cpo9UziFK5XsLbM25oN6N29dOGDhI5 +YWwCsqTLMa50gs5oMQJnoj1dX9vXAz0PL1PDljDh8DkoIP09oTq2Ww8NkVZMTWnQSalbMxoEQGtwSLhDiLgkgLNmxUzsLCuFqh8N +ouMajwxhPqPvHlGWEqkYRfzWQm5h5Kt6p306in5vaBxcVnQWycm2ibZhT29V6J2VANwvQVtwRhvRStTsM1bdTFc7noxccl3NAt9e +dZngjGN24aD5S66nkZvvIkPkRCfXjZPqK6JvSi8gpLjkqtiQ9raTVq9yD0OfNNOebDoxJMc0GQi6VpeCqPZRzJA68aAa4xCIFITI +IRS0oKnM46mLUIDKmaxD9GGvTjwkfW5NCTZEHyJPEoluDgBZiLYwIQS5VrRg9LWtJwjwsryVfgIWGWbDZDvfAqhs8ZqZMrUvt0e4 +X7iuPYobrCQxtZnsZE82M3u0mCgM9tinzJN0xOazWTcEgVYCvllkiaPqs4MI9SLHuGeLgvnNzmwRmQB9YRyMqXWogM09yU0hNWYb +Mcpo4WK90Y8pHnD5MjKtXsYGIdDk865yWLHKSImnBN6nfdXvn99CllWyIDln9w4yHzeoILD8LAs0clDEbZOsgDU5ozwDSWJeCaMZ +kf6VYTJcwD6TcGVx2eK0HEtYeASUtOAosm9Q39xX1W4065OtLKU2KTejTLpUj3iSpYtnuLJLkwcgD4dllfdahniAOO3sS4XE3mnF +Z7NibJZdoU1nP8Wpg74Qt82DZXGXuBrXCW5GaecfSCmTyJREL4MHm4miLpJhZSMoZWjwiIBT5sPFXU0TrL6Rbd1Zxu1H5OyPINKQ +ayMQwUM6aYhgYQpvQYuWAWleTiGrDDFfcivgLoKO5zd66JsbyzkKet8vOnF5nH67J9vXdqyNi51ddaxjv4zusDkgPUz1iHOvkDpZ +oL46PEsNEZwZAmdzdPRqMDuy0hkexe7TCYmLMAIVuP0A65ttzOmbHqfCppklaUk9oERPEZkKQjNpgw9kIU6q6bvIeVC7hyX5MCXv +lbl2inzvVeUFvam5a7G8ZuRcfP2sXxQWyFGXg1UjcXtJ5PZm3zGL1VUvbi04OatxhzBLPDdbpYxAUhxby99gTOZIojGOPj6Tlehf +aaXfUvHnZfHQWIJpNfE4LCnjVQ6uzuJ9paiA2SDr7nEp3hHgAbrJ1f1vWlEMAWGB0eS11xDB9UUVohi0ANiQvFQMRkSqjRXynKcz +19m0Mb9VXhNYGPhIbMPiyvD3OcVcISeu71KXVajPC3NgwPLC213StF8mmfThSClXcIfwPFW7Www2RF7dDNfJM9WIz9UmmtZsqons +zuBYNz9F0ipjmLIGuovJPgTcmmlXtQkOjq9NNbbk3ltlKWjT9qcjxyhdV35DfsjR486V4I1cxv0iXHbhn7U0mxRhbp980bfcsdRL +1b4aUZLvyl1MO4eIuPvsdQqaa7ah9rUYHXuiMUhwZIMdvoYlK2H8kUxFQ2DnzMTmCfW29zPpKQexhI8yL8uMkl6fzmRKQru1xrqz +uYKalgALGbbHPWzQTOKY5ND1jWJRV4J5V9nCIWjOQCQ26E1ZTE9LA567gYGe7HzCRFhw2JDjTOHLyLuHuL7Q841iVatwvF4QPqtZ +yTeUomlGlMHIEKuIhwycntOBX2qMCr3lSjYRb1lfmXF7oR5Fov77I4cApaBqq4zi0ewnm3P3VCGwzCtfvXW4XsqAqI8dI1h6Vhhs +BiE4UEjU23NlAHdNdY3uhqOBtwBJdWEg51UEuR5DAg6lUfcIecN9cX8cypn7PX39Hb8L91Pcivyn0BsRNZbuCP8c5U6oOtytxNFF +szRsxM0wZqZkkW0odMyGm0oupjeSxkNByZOpgKEWokveOfT7v0TOuhUeddP5DWH1ks4ZwhXozyfCaWoFCix4aETgeX20gUPVwK8t +DBjsSljhapBPZv1HgTtNdwQeIYJD2fhBUN54ZHvwwE2M1xXmyeBVE2lodRB8541EeAwI1hyIr6qMnWmeg7U7QQcq8JpzlD984t72 +EImFTGWo8lHQ4AX4w9Ko2BCCjSJpif5kQ2mBbwFO7VFN10kHr2dVNe2PjIsTlrJO4nZ2rkhWSVcDenRgphW9OMrWFWI80lcqg6Jp +ggcnkumWtmqyNbzhsWJJ9xQzRvOAA3J7qv41MD7Vlf8ddN1w5rhazTro0xawuJ4AH3FuYkfJsuCtQlnFGVtqmGW4FCQUSeiksQGR +kZDBKP4t269whHR9UnYLu3YfZCvpaiSADYaCwFQZY1zSTFfbcCW9sMkbuJB2EjhQBqrFCZMV9NSD3iX93RjgvLhOr1NSdVkIA1Z4 +vqqolJwOxX5SjJb1dv1TqQCIreqragSmlYMvGsOrgueUnVZjQAFuYucKvfPMFjU7aPa1meJwfp4B1j8wi15ANWbTyCVG7PXYEUsO +gR20hytOtDMZwTmEsb2i9ptREAbEpdXwWXDse62Ga8HXI8UMZEeXQStbMLHC0fX3X4lXv6GfUZBdm1RhqdB88J7ayPwHDQftC29R +1LoTucu8uArXCERsHLDC9xBzmlrqJbCSOAYIZoMpITbXXqNL7LoPRkRwVjISZSRKrNtqaWQsJQrcWpT2Bh1sgPyLXP1O2yeKMfTT +NI5bHTRUAvsEgPqW1f6K37HgXRT3qfJoRHMiv4DyMeVLG8WkcYp2fmRu64P6uBUoEDPMORmd661gF0kN2t2qRvLvmBfPHdGLYskQ +XuWSBw4yuSNFzMdpPJDwdrhsdXUvsjkTCU4h4PauXw23kPlNFxo2d0MVSWZk5PUnLYrLlqp8VkwdBwVx6ndmVS72kaxzf26HDMvI +8IFnii22cavLoozeMYcF7FNHWIC9ti7jIbiDvPjN0IdYv3v0tzY8Y9A0d54xZqreVLyh6lxA0SycEVpToonXVjSWeFxLE0Dt2I5s +vbr106iImChNgjiKOqvzsrRgplt1ezRHLlxMRnBQm9AkCSdqaOPGulNb74ANXXQGfeL0ivyfd2rhliPCNyvZZuVIK6ilzHvl1xfq +SUqnPRpEvspuJ1UKe3ERIF1oVV7tDRFIIKklbVcvxwFxiWC9mzzEeigHwwuboR3uF3yAlPJ8tAFWRHOtg2kttmzIopRTTCoaqKw7 +OPlPbbsI3rr7ZeFcaJikzCLdJRUG1Naiv9VtNL9T7dJ2cLdGCbD5AzQr8pwEHsMZ8Dt7fhh8sRwk5PSWeOe3YPbjKGmXbGzJiI48 +GJzEOzLvsxMWv5FNJEIqLs6kK0VWco4RDKHepS592J2CwtZQzoNrSwLoaYbFwr9BLimxDxcytQitwPqY05xcyqwCxq5Qwty7WrgC +4p8Y05G10zLepX5w44FDRMJPegV1nJzeC7Xd0KCNnKQsICH1zO2Chn0R1Ah0NJrI1tKmoyhob44kAIQlA9A52ksAbhlKwuGIOwoA +yb1RdcE7ariz0UDsOOiwICsFzFUW8BR0wZ5e5VcQWo8vUknUabNk1O2KvEJEHSlUPPBUxdsPVXxVRIVu6CHZuHJTJH3QNzdtaxwX +2I2SgBJiopKX0hVW5h5tbcS2f25rYVrwfs7Zza6PuYHPu9qaOxpNZVa9FiJoB0s94AiKlxX0EtPK9dIkxmT5FBFKY9xMmZtdRkP9 +taiT7PCgGiJdj5E4871GfUD0D32yipdzTI9oMZHZiS50lA3eR4nRnmBb77aXVyo7I0PzlFPQhHeGFeUCuegQahFkyNQxGesfSJih +KluRhX2Ux6mtapDKSzuqUr9FWNQf7azVzn8kCMby7h7J3YTSeUGXkwiWzYFmZer1amgheFr5UgJzIYNHY5Ee5kwbcrtCdk3N59fo +pBXek6dwCYLQtsNMlrdguIn7XUdOGLlCMrLzO2HtrxYiuSnKzk3XFLE0j9kWRaXtX0sl6W781B0SCe493raOTq6SaSkFI5E1UKjM +ZakossOqfpCgN33UufmOvYkjgiFTW01mmrOmV9miuNnddHgpwfh6kO9wTD6jhQOY3eJep1RF0eIYZ1UhJ0ZzNlYiTQmczpN7scFi +YbMKnEWCbdmXwdGHuknOWw1NQjXXANMz0DjbCodH6HsilE56JuXoebMazy9VWu9uaHRaxJJ7MrPeyBOannkmhOxlWTs19jXyjMBh +CiLQFt7q715xU8EpHsIoqrDb1EA73tO0mcZX4fdsyWYwkWU5gKvNFUvBfKAkizROK0gnC8inmEcfv2F7rZn54HFCeKAv8JrgRb4B +gHGqwC4hq2FhP5N8eqxEyqQWuaXSATlnvdvBT8ZRuuslK5vCvlFHlVbuXOqNwSaWBdJPiHaHSbQyCNbGBgINS52XqXAWepaSYTFr +5JKQrJI5CnsX7szWd9SNEuiSdywXPw56gjhcU6STaVnGB895GSN0cijN3urRneNPKDZKf7wWubMPk8lZRAUDgL9SOwnlxO13YieF +ui14LQ4RouIlLaERFXOsDBxdgVVQLEQeNCK8xEWYjP1FuwqJIlKLl7O1rY59MYpuI0mioecZR6Xi7eLvLkzA5SmaqE5UcLKhuqsD +yAC54oVp0VR95bWNBrgyLFyj3rUgPaCIQ9zKSBFNBzAZO8ifjb92js5ktBzIrHiifvrTnLgYXYch8Y7dlxrz8qKtHPhu1rlV1bgX +CbzYcVJNpZc18mQxduRE2bCcveeiPyjMjoxNzPOYCCJvQh862pYZU1ulqRM3jxloFZiEdwZRJKsBaX5b1TZxr1cd8iJdwRIa5vuz +KEdiTzITFFxacUj1UVxietgrGXKi1EYriBSifRz7tho8SsF1o0juPDRWlVgAfo925NYmFuGMnczqjKhaH5oT8On3A8xXU3Xv5CLB +JNrni3Qg4Xc7kMgTJtzInFoVIL9k6s2UzjJsJQ2PrEaWNLVKh4ldtc53hkH8HLZcb14j3HEnjUgo3sA6rcFUfOeu9EDzg1vF942N +0Z4ufsdMpJlDX71nccERAVrcjpp2chRXBwyhxfzPJqOrNL0NlhHpenQGjrM8vcfy0aVj1tmAxwa0HSGIAlguBjYhAiBOOBytDPjU +mwuFbdWQqJv27vROmoxYngR8IuwOSUsqN1aiB8ZNdSncfboW95iY8OifJAvL7HnNpeP1kY73wCi6QBh2hYPPHpZQu54v7pRZp4hK +4OfyhY5AVBRT7OYIFAPNWLJ2DEVaMxpnw5m320EMRT2bYMWRx4gDgVkJ4QhzK7iMQcknz4of9v11FE9pghiTDmJeYagdoVqp7pFt +KprdYiLzamlfffgAv3ob8H3t1xyuph2iVFxJpF6r0WIPVP1Tjm5CVMtlqCTV7eocSk4c69O8ITeb0BbJznCFwN2yGr0BH1ymUhnp +cWvSTVhGNkzjpOBqHxlw2HNNa1KZpntRT7ti31lC5G7bin9D1f64fAM1hrTR8Hs6qS6YKqdiS81XEvKFpLFeOQKvq7EC3iU0fsnL +qCKYUdtqCYixbOEZpzcfF3WnpMxm0yiTilDy8TRlKHXw0GTH1ShcabKqDm7ZB0geNzNCeB8JehIYvAy4b0CmMa1syLGinFwTlGdz +xvthCTu0gZ7Qc8xTAwoN5fcfK5n9xxrIk9ZJED80HImJSdXyStgy57ZPe5smRG9QnllYMhzqv4aD7V3knjsFPzSTnS7GT2aAz1GV +Kv89HpvLX6YHfZroQMLhl6Y9NiHFvatfdBhlFlrU7uVNecmSKVR70gohgx1VtKJ2V7uSNjO5c0hIsar1xYAtc6P6fQGhCGYwwKwD +kwNDlHErBQTYMWq89EZrNekpfvLYajQmgmYgD7258VOwPF9to473y3wVa9p6WyQph4wiDyHm4Sd1t9B6iaxGV8Sh4wZwoaqgjLYb +dSg9e7xuyJHVW1JVCQTKglO7yFQwTc5E0JmcKmt1Z6BXdUGEyEwB0EHfbSHntyOPQY0IOOqK6HX632whsBHBnq1OCRF0MdlNQuNX +wjSihKhplyJx054rz3olDxiKpYuGdXBk7d3BnFTCfyM0RLLyDnPdb2KhzFlbEHncCNSe6lZWPQ1k4myMVerkdsPA1Xs5McwMOlCn +byOk1heuV0PQfg0YoVNORO1XQR1raBhfeYNaxKwnq3op7RwofCVIOcMdRh2jTXmltcwJd3Y6hsJ4w1HaEk1UXsZp5AuRZc1JUNFk +bWnwl6jYPD2MPBQb5QiIQd3Si4N6DNOSHlAqKnXg4pMYaHFZRu8Vw2xpmOgP7Sj6d4AS5HJBRw08Zqh9TyIf3Ke6BKirCp4zbh4m +Aatb1Gko3hsvMw7gEzHmrkW0V2LusSCLgajBDptyJBrUyaLPs6sbkWTRSWwU2CYLNyJP2csVAVrb0JPNLnnCFl5FXjpk2RoguUMf +Ie4OohR3MJzuUVp577JDmzeq72Kz30GTYxSc1EgwYCVTCsSF4jopcytRyfpxkvWhciq8bqtAdDxEhHlvsh5etWQCbfv9fhFxbIMG +65QVo25O26KXBZoeeOSR4yaQy63bLjXwBOHwRIqA2WMQdy4B964wC08f96iBptmubDbJqPB1VebE5lqgm77PwB9tR7Vk4aR6tUqQ +SjEnQNSmv9LyaPzqcn3wBIHiytq8KrDmmsLAdEIT5XH6tJgWDTJIu9lT2cmUK4eDVlKjQ8hqW6PMb4vxoD9Lz8aslGYndq2oEP5N +5jlaownVQGDRt5Lt3lCtQ7qFjNFPF3LHrGUTu2K56dmGokdaAQRuDrYQDYbyALWTrfeY86hkPbea2UhVhpC5HcFxyk53s48yeptf +AWQFIgs8AmoQIA8xgCTyKFa5gLj47hbgC212yioOg9DhuWV5c9HAvYzabuLCkeZxCNyIgo8R0jrfO4P2AH4NX1UuBdAXr7VM4RHc +d3QyaqCSR7H1bZxzTEfVqOLsYztUrgogmyOJlSWrppQSM4IZKOOD52f8Jsxge6hvUwz7P00n9BJV9REVjxNpu0wT1aQFPvPha6Cg +D2HwqSzwYBSWYaunLWkBycfolL8l2y7BrU7vIQXIRWuclUJjzuL3hXuHRVvPIxAxwEelt37Nm7XFEGSek1X1c6SV2h4m2hYnGUwr +gyZ0tP5uQQ82b1rKgzDSDZNi9w52ng3Ot6O2ckjWg7Up2D6K6NNDp3fHE9o5CzCyChQWtLNjcXuv2MQWKeLTtnUraoPA96vgyP1b +uee9xLGeAeWKeOd19vJMlmhGBQzQhAqDqz7B3RAtCcrYCws61Gjq4NP1CQHmnnAaSmshCo3Vr0hHS0iX1N06lKXF9mEEpJkvjb0Q +p9pCQeitEGLJhM5gtwyWyJvRs3ZcmDCk3WkgJo6fAy1vLy9yquaPbXbz4JM0Rny7PZicnqScVtv0gp6D6OhlD4T4St7CbGatwhdF +VXuX9c7UEnOnwmal4GJG68Zwyot20E0gJLdjCviy6WMvmCouwlIr0MHiI8YFYCmBKrW6opauV06YtxsK5W78YjbYa1QRDmxg9GrX +ppdPFapxClQVdDUTgmJDLHityiFcUwnYlfYc45hsiw9SliQoi2OCrUAkmTlKTniFNR1rKOZS47m4vKgSdod5kOkrja8uD2zoftVJ +Sn5Hwucs7UqGBF2lmvm25sBA4AGcyoGw4mFQsp6VVo7ULGewYEy6vGqofYsAqTYQ4e1b39oUwzIDlhC3XFRUJ32BQlTNo8haNvgA +PyoyDxgy7KlY6PqrkSpATXliBqTmsNa1VY1l27Jt4VuhMyhvt5Vejc6Ax4sTgaGlT55VULo7SGGyTosVp1a6HpGUgCKUC2D9tCzG +YG5tgPqP339ufn6gPJW80fu8qK4XGSUQLlhJIUI5vFBZ8eG3ExC5SsjMC78idVx0zaPV1zQrpIV2iK8thJ1piZgaKBSgJLy7VaFV +TYSqUW35sKfk107stoF4jtaCZJ87eZFR8SU6QIOSCHjNPoRpUjF5HBUMtMGGlFSEmMEObxYsMXHYV84tnmEN4RoqIQ3u7A7EHy7r +gmMPAY7SS3SCPdHt5h0wuZZ4RJYhFwtnPa0UO4YJxIVbkFbW4IRfp2ZFeU8xFKo8mHiveXkQjxSg291BZDT9ZGR7KD03lrmc6usO +YdA7egykep4z5nbxECLkIb7KxSCE4SbiWSKH8kkf0iU1413zKLxgIUsWEPF2ZRstekfr2ICVoeMzYJY0Xt7c91AjVzHNFAIz5XJ3 +LYmBhbr8Tg4hevfCYkKlA2hwUX5Fg6nnLRRL8JIoz8mpSrQT9a7zla57YrIdaTVWmrigU18oMiyH0RNIo7a0bkiPUSzaKYF9cxle +5h1ccGHtXyh0a3wiguNdLIWC0eQJ6riqagv1bAfk8QezWfyWceQY9BKOd79aOzuAXLwOuj5RwGFFLirDESbktp9UFcF51g1sPySl +pxWi6vlhKKNNSSxl7WVSJ5lWrSkcrzTDE7egctoV7YFy4v6e2zNu4cmpXjzsMUMEN0hLzVlSjmCyPvShq0LssL5fy9ij4QhwNQqN +oh5CaIwt180ekMn5TX4ts0eEWDOO4p23mxacksaxCe31LpyFP1ykhdi7N6zVSlZ2AqtLF18OjZAddGY570ygPk7lqGPBQCmbKeNp +CZb6jdndZzeOyPrq0lTovLYOv3PW4xXDOgxNxMrehBDgZdQK7d6YkLaLPM0mruNuhqbe8Eams2os6EcwdXMiuC2dPVHVZQjk4M1s +TntZhedvf0BWZjH6QYqaFji2UqwpUzZfkbu20HQkOhlRv86C9zhqRVOQIQOwHOylvYDE8LBXylIpOielklR0x2a2GgDQRBCSc1ng +G5LNrZYVcvn1MKrVDw6qx18j2Z8qKURPAuI6VfhTz1gP1aTYZif56auQrpy6tfQF97zRgOShB3rji80bTmEMjoOVx1ymydIBdv6E +Fgh6TzOy5AxrCOdp7t1wINrRyq9CltUDcfYHFPZ0s0yJpukVQxbkVoUdi3IFfijIsWFh9OSPAMJL9dE9LCHViXay3rc1jJCHDEw3 +8n8Tb37uOllDKgYPgB1461JacztlBBc9pikeA5msL1TsundxpAVScNdp40OFVlbGOcaXQ8obgbxMZy9aOCImXd1GSONd2gtHO4V0 +bV43kd4rZRYGQgyElPiLgtVTBD2Ulo8P3GG1Ftepjg5CgTmkLY4wRxl88EqqsQDgvQxXHQjY52w1MrMHRrw7eNzLUDbBZJ72Qkee +SO3g0AMAZSOmdvydqHIPx10A8DEiGJXzyrBzBQR3f3pXf3uVqKRoRKbTWiFEXLsmkHlP6zX1z5rNt7IPIpzzxP8SRt0Ro5H8tuKB +kQRNVKSgEJSBYf5IOyhA11GdftKL0k6oxUEkEnaENigvVKVMjYLDeQaNgVgYBHoTMWErMH2MXTjjMoEuRTtkjD0oSIsZ9xssVAlK +d8WPwYEgN67BLkFxjhJy2nAx2wfFIP8cVNDeZ15dd48TAolfkg5Is6nsmf86qc3cBsmsMGVcXds4ao4uyj4SeUAasRowU7tkoZyg +Yl1xZz6USFYBwG4zYFaHL21lglHHbkql4CX4nqYQy101QCGd4LNuPJbSKa9TdcS8k8c1sfMSKU1ZJPJofGpUE9pnUSuxY6F2S2gf +FgvPp7jlvYz42iLTgwCVp4BmwNuP6b6tNkBmqipYwHcxpBoW1JbIoxcG0xVAb5IUXRbHUCHkMs4hs7b5DI2uHXsmErd6BoUamIVP +2d3ouVDcjU1nyN169A1GSxvET9BqTnpd8SZwh4ejU6f7RaU0VLbtZP2zHkubiGy47NKTMGRooZE0Ch9OkDeZMCTfEIy2B5gY7XMd +FXMzYuy0HLhkScTj1fdTF7zoO2w5FYEUgXuC2x6e4GmZ2JMv06d6xV88JlEkA5wxsenRs8cxf0LkNsWS2WY5HRt1IpLIEyaInx0U +9g46QuxlxdJqk2njqLELPseFR4eH2y9yaCrwaeXICek1GVB6LUn3VshavmstnVHyQGWWKoYrbkORbbYLxYen5XEIQuTy1lq1sU6n +0xuRWKYWUTrl1Pd6eT5LJm7JKoKNjS08UTGEOY70njJMHo1xM69N7hcNVVfu0gq9G1AKgoSsAJkP2jPjXH8btAXMFU38hl9xXiLH +s3IXrDpHuzJldBB1ZqEgscgJOnEbBze1BNb9YNQcf9LGKPESsRP6Adzc1JkqtvJyjfrEC0dkb5mNcpwaVU4gm7B0owxztwvYoZtG +lpBKW19bPWQLmb1Du53x8YxVU8TeOAL7IzO0SOviANM3fpRbDewsub1Zekp0BtcosbQ5ib44q2bbduaKGp9frqWFA3x8IfKlwqHD +7P0bwjoyLeAWlf7VGjxhGPyLusHby7m2MDlmFonme4ihUPHurcqC9L2LAZoZKFqNGAF1snuTvkYB7aoVEubXYfN7Fq02bIZHGVf7 +0iJp1GyQOes0oDQEx3jQtFZ4FMlcxG5pn128A9GNSjzLnNCHkJxBgUgRPEV4pqGC0kVhvJ8KIhCL5NiFlnCFmWoTR6T1bKnDQ5lZ +EZOG50M0LrpcLNZfus7rGwEZidSHscSVYgWTfSyu7ldwLGSYi7D3w1NIaCVIlqRTf3Fl4fsQeVPBq92lKUsLMTZnuDlAbujDgsMc +5hRW0CaJI1XmIW6ewsdpEieKeFiK16Bs5GpAUL1uOibcSP0U9ShXV2wqTQJ4Foumny8F4FlFW0CTIgqPoFfzox4Ucw5crtJDeqZI +nDFSrW77zYDQArjgpRKjHRbfeYsclU9ErtQkzuMwyb0qdEOquk5PioFPHSi4RTDXkvX6hllR1kFk93QiGcUqP7LKa0LDc1I1XaWZ +4ObV6gXBKeA8wm6SJsOLTBtpNkLMIbxJDrNvNinIq1yUrFFCA6VbTKFr1ty7fBMlaSycvVKYAlSvY1rnYJ9EC7Yj4RssvPVRmCyx +uWSV7oDoJBru3fiz8sZGQ5cqw8QXozKPeqfqQmyCCm2jZXBpeJTIh96HCZdJb2wXPUtrtZ6t7SyUKK4bjuY6EAN9AUjAn4tLnEgq +ISoISz2QBYz9DirLjnci4K2sb1NYUUqc3gz1cepJiqCiWEnIC7F4dJYFMLTwW3KPYSKUJ3LsN0IIV4gi8sSK9wQ4KMwymLFZrzIu +57saefG90ac78KKcIc5ujSKeajBsGlnS0pyaKrffqnucTxv3B9ipKEn2R62eLWZ6WqWh0XkcF1woQlWY9guk4IPZnq0gNWM1vsRc +tQjdrQ6KyZNIQyUp1RfjEsVC6siP0rDVclA5fjEdKzbD3XCYGkb9N3FBMb692Q7PIorwMQZa4IVXew4VguJdmPidGyhhgF7V506E +OiFKLQErBRCI0YYtRRkzKCa5QJ6x4k5unsLm7OtfCYfXTamK4NHFz4n70oPlwB7ceRUFIdds70Y1iaiNhZDjngWT47h9dKL4TKpW +6oA9T0tH2LgWuZWe2zjFM3enyzIqsG5rZrfWTMrffwdFln8zj1Lm6UGSIS9p03alQ4Y4b2uWqF7LrbSv1ZzliRlJu0pbNlhV1gXO +F2eaY36wNfBwe7EY5mwLOR0xD7lq6mxuzVbaKlqejxUMDtXqIzeDpdzuAhHewp6JunsNy284538RarUyxnSeRnNWoy3ppjJZWvs3 +2m8FI96KndCUqPoa5yrhnrFPHUS66pygpdWKuwK7T05F05UYeQcG1hm3bLeNFRRNxVM6UG5oT2apFeLwgVt01zLaRxc1bJrDIHvZ +b2wd8K3E8UaqnYfd7w1xteI6LadrhzoTEcXqWmr5n7q7JsE3fBDAPrwnXoO4vvAtrxGWryfVAas1cM1VxqLEjbxx4ytBGMgPnyoY +XwTfSKXVIf764gfcY2M3Qdpa3cmfeKWAwYdgDBZ7iT6PGPgz20zPyh49MBpWV45oYcO8COq3GDf33Co0TqZrA2O6rejTu6BZYEKR +T9G3oVe5De5og9kwMPrz9tQxoz6N0xdqPZafloWujNRkCmykVl8NsksovBoECNJsjop9fH061DbkJAMDstQWjKj3yP3WzsvOVLzh +7Mj50HYGGhKNlK65EmwA92SUoKdxiyELDUC11dNpH7hbr8LTycAVE0x4D40KOqaoyd7DBSlGEzqtMM2Duo7fczT1blveFvgrhl3W +HrtMrPeG2ySGUlXG3nrnLzjvq5L42gqh0NjdO1Dzalc1rWScp9pl9GYmyXfpuqpeJd7PbPiIpAitZcnrh44DQPTNoAj29nCAgL0l +xDg8kIaQewW4rTGuBZX9E2Ul4Lf66RLo5dRTmHS1U6PY2Z9VKbAGZ6jgTxrbjGM00qCubMZtW6mqC4crDG2KXc75WGJjPeDbgkXQ +z5TAMHsnX35kXHVZS9YKqGjfoBi3qcwhO5K1aQa0e56zB9KYckpsyOjqOLOukfYl0OsrOXD5A9OrNpvkmGknz2rqzDyqSZn3x9cj +L26WZUlSfbgGJNJ8pDBaojL2KnxRVpwoRBMVKZDcS8CHI6QY2GFV6Vkx93g09PyZdjQSxbKZJKvgWnIPsd8svKeM9ZCJeeK6CTX3 +nQ47ftd4FN2PFSoJWd5FbhiAftUI7kaBimJYBQZwCW15kJPmhBG7Oh79xpbGXmkJMb4Eu0dCmlnC0vt0omctOX8DAOcCY5T2kVKR +QXB1rTEM5u0Go3rR09iPXM7Ul7n2hkGhbgNsS5jBlzBUiE00hWJi5OnC8WiNPSq5Gz0uGGYMryJ4XbLN32ooy5zX52Y8FMEbOwaQ +FliLYb27zpOgo0UARSBW1Xeij2KQMtSNmVVnUbJmXefMbVvPcAIWVBKWKLhYBgu3lztHSLj2K2UkeftzFnPNoG6WiBxFwusjNiO3 +fUnEWfgeSqzbSprFjTAiJKkKzxBxSBx7OEJFA2lnkzH4AtlSsL9vLtXidvFwngLNm00o5FFdTFL6WqZDXcCYkTTAChH7Y8Fmnd4Y +MnJIayaCBitieZW440tGVACwBzTdjBa3xKx6NLzg4FVFBvJueaIPC0E4wJluNiVRvRGkUKgXhqqYbUSO6RTzob1pJMSrgXz6ANbb +qPPd99a7WKJNsINJSEWokYCKa8tIG2vZoWE7iDdMyTvwGktVQzw9vQZyyAmWf3nij0SiPjzA9RkMQmhHGX6yyFjJtPAfResTWaVz +2jOATpDOZlCmcNmMM7Wqt0YTJyvUIQ1QdDs6W8duGyKHxjpdF5kmRDHkFYjKWeUnQVgClfvFTlAwu7c3BLhBu0o0MpiZ5A9RWx8Q +Wc4uJxB0llFYsSybf6aKNEA5sFwf3Ib9WQWYzs05hDgZZYuHjqK70Q78sUosZXdH8E1u6LFufobeKVVENGq93P3JeitC7nwUYnUZ +16lPp8MyJ3hOnpvxiu4wxx4ZRGrb7PJ5zldg6A9K37FyVBYSSrcP76QSoNWkGfeMeyfsfQQz4WD98Lltenvo1nHezUmlDo6fibGP +VkVR9tVb5Wz3IkQoufZ3SkI3jXwZDwdAtewJOjS6MNcrv0NvuJEMrmyunmVka6rFHxVjXHf6WsqYxmnGh8wOvhCtM3KEj6HpjYOz +dXVs0tD17ErC6ZKGfL1XqXMqgG8ifLK9Fs7fzxjz2N9fB94WRE8ZQK8oZF3buB1wjlXryIfeoIYrlH7rA7uGFX9PWa4HU9OiD1Lp +RYjKxTgFsPmfpTlDJmFXrySjeNn5ztHOQUo4soYMKiD7o6DzDivXvTxUxwFyqlX0Egu8Rc4MubfMWkkJIPlbUrUEFIVpsiJ2EDT9 +gGoXdz6ElXI3YjuqkU5Jh6pURU3UKgRRPPuMrGR55lvHVG7TyVyZtRsy83TJEazxO3OyO71kwqGSxFxzJNG6AdmpAPAAvFuYYx3C +nZdilbJGjx8ZLDnvpZtaBVxPx560Z1MNDyTAS5XPfayFMGufUiLYXiYtdYQHGNheBqdvGfEzgaesKWUMJ6pr7kWtqXQnEtnMGlvx diff --git a/contrib/zopfli/sandboxed.h b/contrib/zopfli/sandboxed.h new file mode 100644 index 0000000..e74d3ec --- /dev/null +++ b/contrib/zopfli/sandboxed.h @@ -0,0 +1,49 @@ +// Copyright 2022 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef CONTRIB_ZOPFLI_SANDBOXED_ +#define CONTRIB_ZOPFLI_SANDBOXED_ + +#include +#include + +#include +#include + +#include "sapi_zopfli.sapi.h" // NOLINT(build/include) + +class ZopfliSapiSandbox : public ZopfliSandbox { + public: + std::unique_ptr ModifyPolicy( + sandbox2::PolicyBuilder *) override { + return sandbox2::PolicyBuilder() + .AllowStaticStartup() + .AllowWrite() + .AllowExit() + .AllowMmap() + .AllowSystemMalloc() + .AllowSyscalls({ + __NR_sysinfo, + }) +#ifdef __NR_open + .BlockSyscallWithErrno(__NR_open, ENOENT) +#endif +#ifdef __NR_openat + .BlockSyscallWithErrno(__NR_openat, ENOENT) +#endif + .BuildOrDie(); + } +}; + +#endif // CONTRIB_ZOPFLI_SANDBOXED_ diff --git a/contrib/zopfli/test/CMakeLists.txt b/contrib/zopfli/test/CMakeLists.txt new file mode 100644 index 0000000..68bac8c --- /dev/null +++ b/contrib/zopfli/test/CMakeLists.txt @@ -0,0 +1,28 @@ +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +include(GoogleTest) + +add_executable(sapi_zopfli_test + zopfli_test.cc + ../utils/utils_zopfli.cc +) +target_link_libraries(sapi_zopfli_test PRIVATE + sapi_contrib::zopfli + sapi::temp_file + sapi::test_main +) +gtest_discover_tests(sapi_zopfli_test PROPERTIES + ENVIRONMENT "TEST_FILES_DIR=${PROJECT_SOURCE_DIR}/files" +) diff --git a/contrib/zopfli/test/zopfli_test.cc b/contrib/zopfli/test/zopfli_test.cc new file mode 100644 index 0000000..0c060ff --- /dev/null +++ b/contrib/zopfli/test/zopfli_test.cc @@ -0,0 +1,98 @@ +// Copyright 2022 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include + +#include "contrib/zopfli/sandboxed.h" +#include "contrib/zopfli/utils/utils_zopfli.h" +#include "sandboxed_api/util/path.h" +#include "sandboxed_api/util/status_matchers.h" +#include "sandboxed_api/util/temp_file.h" + +namespace { + +using ::sapi::IsOk; +using ::testing::IsEmpty; +using ::testing::Not; + +std::string GetTestFilePath(const std::string& filename) { + return sapi::file::JoinPath(getenv("TEST_FILES_DIR"), filename); +} + +std::string GetTemporaryFile(const std::string& filename) { + absl::StatusOr tmp_file = + sapi::CreateNamedTempFileAndClose(filename); + if (!tmp_file.ok()) { + return ""; + } + + return sapi::file::JoinPath(sapi::file_util::fileops::GetCWD(), *tmp_file); +} + +class TestText : public testing::TestWithParam {}; + +class TestBinary : public testing::TestWithParam {}; + +TEST_P(TestText, Compress) { + ZopfliSapiSandbox sandbox; + ASSERT_THAT(sandbox.Init(), IsOk()) << "Couldn't initialize Sandboxed API"; + ZopfliApi api(&sandbox); + + std::string infile_s = GetTestFilePath("text"); + std::string outfile_s = GetTemporaryFile("text.out"); + ASSERT_THAT(outfile_s, Not(IsEmpty())); + + std::ifstream infile(infile_s, std::ios::binary); + ASSERT_TRUE(infile.is_open()); + + std::ofstream outfile(outfile_s, std::ios::binary); + ASSERT_TRUE(outfile.is_open()); + + absl::Status status = Compress(api, infile, outfile, GetParam()); + ASSERT_THAT(status, IsOk()) << "Unable to compress file"; + + ASSERT_LT(outfile.tellp(), infile.tellg()); +} + +INSTANTIATE_TEST_SUITE_P(SandboxTest, TestText, + testing::Values(ZOPFLI_FORMAT_DEFLATE, + ZOPFLI_FORMAT_GZIP, + ZOPFLI_FORMAT_ZLIB)); + +TEST_P(TestBinary, Compress) { + ZopfliSapiSandbox sandbox; + ASSERT_THAT(sandbox.Init(), IsOk()) << "Couldn't initialize Sandboxed API"; + ZopfliApi api(&sandbox); + + std::string infile_s = GetTestFilePath("binary"); + std::string outfile_s = GetTemporaryFile("binary.out"); + ASSERT_THAT(outfile_s, Not(IsEmpty())); + + std::ifstream infile(infile_s, std::ios::binary); + ASSERT_TRUE(infile.is_open()); + + std::ofstream outfile(outfile_s, std::ios::binary); + ASSERT_TRUE(outfile.is_open()); + + absl::Status status = Compress(api, infile, outfile, GetParam()); + ASSERT_THAT(status, IsOk()) << "Unable to compress file"; + + ASSERT_LT(outfile.tellp(), infile.tellg()); +} + +INSTANTIATE_TEST_SUITE_P(SandboxTest, TestBinary, + testing::Values(ZOPFLI_FORMAT_DEFLATE, + ZOPFLI_FORMAT_GZIP, + ZOPFLI_FORMAT_ZLIB)); +} // namespace diff --git a/contrib/zopfli/utils/utils_zopfli.cc b/contrib/zopfli/utils/utils_zopfli.cc new file mode 100644 index 0000000..ef41b18 --- /dev/null +++ b/contrib/zopfli/utils/utils_zopfli.cc @@ -0,0 +1,56 @@ +// Copyright 2022 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "contrib/zopfli/utils/utils_zopfli.h" + +#include + +#include + +absl::Status Compress(ZopfliApi& api, std::ifstream& instream, + std::ofstream& outstream, ZopfliFormat format) { + // Get size of Stream + instream.seekg(0, std::ios_base::end); + std::streamsize ssize = instream.tellg(); + instream.seekg(0, std::ios_base::beg); + + // Read data + sapi::v::Array inbuf(ssize); + instream.read(reinterpret_cast(inbuf.GetData()), ssize); + if (instream.gcount() != ssize) { + return absl::UnavailableError("Unable to read file"); + } + + // Compress + sapi::v::Struct options; + SAPI_RETURN_IF_ERROR(api.ZopfliInitOptions(options.PtrAfter())); + + sapi::v::GenericPtr outptr; + sapi::v::IntBase outsize(0); + + SAPI_RETURN_IF_ERROR( + api.ZopfliCompress(options.PtrBefore(), format, inbuf.PtrBefore(), ssize, + outptr.PtrAfter(), outsize.PtrBoth())); + + // Get and save data + sapi::v::Array outbuf(outsize.GetValue()); + outbuf.SetRemote(reinterpret_cast(outptr.GetValue())); + SAPI_RETURN_IF_ERROR(api.GetSandbox()->TransferFromSandboxee(&outbuf)); + + outstream.write(reinterpret_cast(outbuf.GetData()), outbuf.GetSize()); + if (!outstream.good()) { + return absl::UnavailableError("Unable to write file"); + } + return absl::OkStatus(); +} diff --git a/contrib/zopfli/utils/utils_zopfli.h b/contrib/zopfli/utils/utils_zopfli.h new file mode 100644 index 0000000..664e861 --- /dev/null +++ b/contrib/zopfli/utils/utils_zopfli.h @@ -0,0 +1,26 @@ +// Copyright 2022 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef CONTRIB_ZOPFLI_UTILS_UTILS_ZOPFLI_H_ +#define CONTRIB_ZOPFLI_UTILS_UTILS_ZOPFLI_H_ + +#include + +#include "absl/status/status.h" +#include "contrib/zopfli/sandboxed.h" + +absl::Status Compress(ZopfliApi& api, std::ifstream& instream, + std::ofstream& outstream, ZopfliFormat format); + +#endif // CONTRIB_ZOPFLI_UTILS_UTILS_ZOPFLI_H_ diff --git a/contrib/zstd/CMakeLists.txt b/contrib/zstd/CMakeLists.txt index bae244f..0062e49 100644 --- a/contrib/zstd/CMakeLists.txt +++ b/contrib/zstd/CMakeLists.txt @@ -34,6 +34,8 @@ FetchContent_Declare(libzstd FetchContent_MakeAvailable(libzstd) set(libzstd_INCLUDE_DIR "${libzstd_SOURCE_DIR}/lib") +add_subdirectory(wrapper) + add_sapi_library( sapi_zstd @@ -70,10 +72,16 @@ add_sapi_library( ZSTD_getFrameContentSize + ZSTD_compress_fd + ZSTD_compressStream_fd + + ZSTD_decompress_fd + ZSTD_decompressStream_fd INPUTS ${libzstd_INCLUDE_DIR}/zstd.h + wrapper/wrapper_zstd.h - LIBRARY libzstd_static + LIBRARY wrapper_zstd LIBRARY_NAME Zstd NAMESPACE "" ) diff --git a/contrib/zstd/example/main.cc b/contrib/zstd/example/main.cc index 5c60b9c..3c899bc 100644 --- a/contrib/zstd/example/main.cc +++ b/contrib/zstd/example/main.cc @@ -12,6 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. +#include #include #include @@ -25,10 +26,56 @@ #include "contrib/zstd/sandboxed.h" #include "contrib/zstd/utils/utils_zstd.h" +ABSL_FLAG(bool, stream, false, "stream data to sandbox"); ABSL_FLAG(bool, decompress, false, "decompress"); ABSL_FLAG(bool, memory_mode, false, "in memory operations"); ABSL_FLAG(uint32_t, level, 0, "compression level"); +absl::Status Stream(ZstdApi& api, std::string infile_s, std::string outfile_s) { + std::ifstream infile(infile_s, std::ios::binary); + if (!infile.is_open()) { + return absl::UnavailableError(absl::StrCat("Unable to open ", infile_s)); + } + std::ofstream outfile(outfile_s, std::ios::binary); + if (!outfile.is_open()) { + return absl::UnavailableError(absl::StrCat("Unable to open ", outfile_s)); + } + + if (absl::GetFlag(FLAGS_memory_mode)) { + if (absl::GetFlag(FLAGS_decompress)) { + return DecompressInMemory(api, infile, outfile); + } + return CompressInMemory(api, infile, outfile, absl::GetFlag(FLAGS_level)); + } + if (absl::GetFlag(FLAGS_decompress)) { + return DecompressStream(api, infile, outfile); + } + return CompressStream(api, infile, outfile, absl::GetFlag(FLAGS_level)); +} + +absl::Status FileDescriptor(ZstdApi& api, std::string infile_s, + std::string outfile_s) { + sapi::v::Fd infd(open(infile_s.c_str(), O_RDONLY)); + if (infd.GetValue() < 0) { + return absl::UnavailableError(absl::StrCat("Unable to open ", infile_s)); + } + sapi::v::Fd outfd(open(outfile_s.c_str(), O_WRONLY | O_CREAT)); + if (outfd.GetValue() < 0) { + return absl::UnavailableError(absl::StrCat("Unable to open ", outfile_s)); + } + + if (absl::GetFlag(FLAGS_memory_mode)) { + if (absl::GetFlag(FLAGS_decompress)) { + return DecompressInMemoryFD(api, infd, outfd); + } + return CompressInMemoryFD(api, infd, outfd, absl::GetFlag(FLAGS_level)); + } + if (absl::GetFlag(FLAGS_decompress)) { + return DecompressStreamFD(api, infd, outfd); + } + return CompressStreamFD(api, infd, outfd, absl::GetFlag(FLAGS_level)); +} + int main(int argc, char* argv[]) { std::string prog_name(argv[0]); google::InitGoogleLogging(argv[0]); @@ -39,17 +86,6 @@ int main(int argc, char* argv[]) { return EXIT_FAILURE; } - std::ifstream infile(args[1], std::ios::binary); - if (!infile.is_open()) { - std::cerr << "Unable to open " << args[1] << std::endl; - return EXIT_FAILURE; - } - std::ofstream outfile(args[2], std::ios::binary); - if (!outfile.is_open()) { - std::cerr << "Unable to open " << args[2] << std::endl; - return EXIT_FAILURE; - } - ZstdSapiSandbox sandbox; if (!sandbox.Init().ok()) { std::cerr << "Unable to start sandbox\n"; @@ -59,16 +95,10 @@ int main(int argc, char* argv[]) { ZstdApi api(&sandbox); absl::Status status; - if (absl::GetFlag(FLAGS_memory_mode) && absl::GetFlag(FLAGS_decompress)) { - status = DecompressInMemory(api, infile, outfile); - } else if (absl::GetFlag(FLAGS_memory_mode) && - !absl::GetFlag(FLAGS_decompress)) { - status = CompressInMemory(api, infile, outfile, absl::GetFlag(FLAGS_level)); - } else if (!absl::GetFlag(FLAGS_memory_mode) && - absl::GetFlag(FLAGS_decompress)) { - status = DecompressStream(api, infile, outfile); + if (absl::GetFlag(FLAGS_stream)) { + status = Stream(api, argv[1], argv[2]); } else { - status = CompressStream(api, infile, outfile, absl::GetFlag(FLAGS_level)); + status = FileDescriptor(api, argv[1], argv[2]); } if (!status.ok()) { diff --git a/contrib/zstd/sandboxed.h b/contrib/zstd/sandboxed.h index 31b0b81..b06b898 100644 --- a/contrib/zstd/sandboxed.h +++ b/contrib/zstd/sandboxed.h @@ -27,10 +27,12 @@ class ZstdSapiSandbox : public ZstdSandbox { std::unique_ptr ModifyPolicy( sandbox2::PolicyBuilder*) override { return sandbox2::PolicyBuilder() + .AllowDynamicStartup() .AllowRead() .AllowWrite() .AllowSystemMalloc() .AllowExit() + .AllowSyscalls({__NR_recvmsg}) .BuildOrDie(); } }; diff --git a/contrib/zstd/test/zstd_test.cc b/contrib/zstd/test/zstd_test.cc index b997574..9e1886f 100644 --- a/contrib/zstd/test/zstd_test.cc +++ b/contrib/zstd/test/zstd_test.cc @@ -12,6 +12,9 @@ // See the License for the specific language governing permissions and // limitations under the License. +#include +#include + #include #include @@ -101,11 +104,10 @@ TEST(SandboxTest, CheckCompressInMemory) { std::string infile_s = GetTestFilePath("text"); - absl::StatusOr path = - sapi::CreateNamedTempFileAndClose("out.zstd"); - ASSERT_THAT(path, IsOk()) << "Could not create temp output file"; + SAPI_ASSERT_OK_AND_ASSIGN(std::string path, + sapi::CreateNamedTempFileAndClose("out.zstd")); std::string outfile_s = - sapi::file::JoinPath(sapi::file_util::fileops::GetCWD(), *path); + sapi::file::JoinPath(sapi::file_util::fileops::GetCWD(), path); std::ifstream infile(infile_s, std::ios::binary); ASSERT_TRUE(infile.is_open()); @@ -126,10 +128,10 @@ TEST(SandboxTest, CheckDecompressInMemory) { std::string infile_s = GetTestFilePath("text.blob.zstd"); - absl::StatusOr path = sapi::CreateNamedTempFileAndClose("out"); - ASSERT_THAT(path, IsOk()) << "Could not create temp output file"; + SAPI_ASSERT_OK_AND_ASSIGN(std::string path, + sapi::CreateNamedTempFileAndClose("out")); std::string outfile_s = - sapi::file::JoinPath(sapi::file_util::fileops::GetCWD(), *path); + sapi::file::JoinPath(sapi::file_util::fileops::GetCWD(), path); std::ifstream infile(infile_s, std::ios::binary); ASSERT_TRUE(infile.is_open()); @@ -153,16 +155,15 @@ TEST(SandboxTest, CheckCompressAndDecompressInMemory) { std::string infile_s = GetTestFilePath("text"); - absl::StatusOr path_middle = - sapi::CreateNamedTempFileAndClose("middle.zstd"); - ASSERT_THAT(path_middle, IsOk()) << "Could not create temp output file"; + SAPI_ASSERT_OK_AND_ASSIGN(std::string path_middle, + sapi::CreateNamedTempFileAndClose("middle.zstd")); std::string middle_s = - sapi::file::JoinPath(sapi::file_util::fileops::GetCWD(), *path_middle); + sapi::file::JoinPath(sapi::file_util::fileops::GetCWD(), path_middle); - absl::StatusOr path = sapi::CreateNamedTempFileAndClose("out"); - ASSERT_THAT(path, IsOk()) << "Could not create temp output file"; + SAPI_ASSERT_OK_AND_ASSIGN(std::string path, + sapi::CreateNamedTempFileAndClose("out")); std::string outfile_s = - sapi::file::JoinPath(sapi::file_util::fileops::GetCWD(), *path); + sapi::file::JoinPath(sapi::file_util::fileops::GetCWD(), path); std::ifstream infile(infile_s, std::ios::binary); ASSERT_TRUE(infile.is_open()); @@ -193,12 +194,10 @@ TEST(SandboxTest, CheckCompressStream) { ZstdApi api = ZstdApi(&sandbox); std::string infile_s = GetTestFilePath("text"); - - absl::StatusOr path = - sapi::CreateNamedTempFileAndClose("out.zstd"); - ASSERT_THAT(path, IsOk()) << "Could not create temp output file"; + SAPI_ASSERT_OK_AND_ASSIGN(std::string path, + sapi::CreateNamedTempFileAndClose("out.zstd")); std::string outfile_s = - sapi::file::JoinPath(sapi::file_util::fileops::GetCWD(), *path); + sapi::file::JoinPath(sapi::file_util::fileops::GetCWD(), path); std::ifstream infile(infile_s, std::ios::binary); ASSERT_TRUE(infile.is_open()); @@ -220,11 +219,10 @@ TEST(SandboxTest, CheckDecompressStream) { ZstdApi api = ZstdApi(&sandbox); std::string infile_s = GetTestFilePath("text.stream.zstd"); - - absl::StatusOr path = sapi::CreateNamedTempFileAndClose("out"); - ASSERT_THAT(path, IsOk()) << "Could not create temp output file"; + SAPI_ASSERT_OK_AND_ASSIGN(std::string path, + sapi::CreateNamedTempFileAndClose("out")); std::string outfile_s = - sapi::file::JoinPath(sapi::file_util::fileops::GetCWD(), *path); + sapi::file::JoinPath(sapi::file_util::fileops::GetCWD(), path); std::ifstream infile(infile_s, std::ios::binary); ASSERT_TRUE(infile.is_open()); @@ -248,16 +246,15 @@ TEST(SandboxTest, CheckCompressAndDecompressStream) { std::string infile_s = GetTestFilePath("text"); - absl::StatusOr path_middle = - sapi::CreateNamedTempFileAndClose("middle.zstd"); - ASSERT_THAT(path_middle, IsOk()) << "Could not create temp output file"; + SAPI_ASSERT_OK_AND_ASSIGN(std::string path_middle, + sapi::CreateNamedTempFileAndClose("middle.zstd")); std::string middle_s = - sapi::file::JoinPath(sapi::file_util::fileops::GetCWD(), *path_middle); + sapi::file::JoinPath(sapi::file_util::fileops::GetCWD(), path_middle); - absl::StatusOr path = sapi::CreateNamedTempFileAndClose("out"); - ASSERT_THAT(path, IsOk()) << "Could not create temp output file"; + SAPI_ASSERT_OK_AND_ASSIGN(std::string path, + sapi::CreateNamedTempFileAndClose("out")); std::string outfile_s = - sapi::file::JoinPath(sapi::file_util::fileops::GetCWD(), *path); + sapi::file::JoinPath(sapi::file_util::fileops::GetCWD(), path); std::ifstream infile(infile_s, std::ios::binary); ASSERT_TRUE(infile.is_open()); @@ -278,8 +275,235 @@ TEST(SandboxTest, CheckCompressAndDecompressStream) { ASSERT_TRUE(outfile.is_open()); status = DecompressStream(api, inmiddle, outfile); + ASSERT_THAT(status, IsOk()) << "Unable to decompress"; + + ASSERT_TRUE(CompareFiles(infile_s, outfile_s)); +} + +TEST(SandboxTest, CheckCompressInMemoryFD) { + ZstdSapiSandbox sandbox; + ASSERT_THAT(sandbox.Init(), IsOk()) << "Couldn't initialize Sandboxed API"; + ZstdApi api = ZstdApi(&sandbox); + + std::string infile_s = GetTestFilePath("text"); + + SAPI_ASSERT_OK_AND_ASSIGN(std::string path, + sapi::CreateNamedTempFileAndClose("out.zstd")); + std::string outfile_s = + sapi::file::JoinPath(sapi::file_util::fileops::GetCWD(), path); + + sapi::v::Fd infd(open(infile_s.c_str(), O_RDONLY)); + ASSERT_GE(infd.GetValue(), 0); + sapi::v::Fd outfd(open(outfile_s.c_str(), O_WRONLY)); + ASSERT_GE(outfd.GetValue(), 0); + + absl::Status status = CompressInMemoryFD(api, infd, outfd, 0); + ASSERT_THAT(status, IsOk()) << "Unable to compress file in memory"; + + off_t inpos = lseek(infd.GetValue(), 0, SEEK_END); + EXPECT_GE(inpos, 0); + off_t outpos = lseek(outfd.GetValue(), 0, SEEK_END); + EXPECT_GE(outpos, 0); + + EXPECT_LT(outpos, inpos); +} + +TEST(SandboxTest, CheckDecompressInMemoryFD) { + ZstdSapiSandbox sandbox; + ASSERT_THAT(sandbox.Init(), IsOk()) << "Couldn't initialize Sandboxed API"; + ZstdApi api = ZstdApi(&sandbox); + + std::string infile_s = GetTestFilePath("text.blob.zstd"); + sapi::v::Fd infd(open(infile_s.c_str(), O_RDONLY)); + ASSERT_GE(infd.GetValue(), 0); + + SAPI_ASSERT_OK_AND_ASSIGN(std::string path, + sapi::CreateNamedTempFileAndClose("out")); + std::string outfile_s = + sapi::file::JoinPath(sapi::file_util::fileops::GetCWD(), path); + sapi::v::Fd outfd(open(outfile_s.c_str(), O_WRONLY)); + ASSERT_GE(outfd.GetValue(), 0); + + absl::Status status = DecompressInMemoryFD(api, infd, outfd); + ASSERT_THAT(status, IsOk()) << "Unable to compress file in memory"; + + off_t inpos = lseek(infd.GetValue(), 0, SEEK_END); + EXPECT_GE(inpos, 0); + + off_t outpos = lseek(outfd.GetValue(), 0, SEEK_END); + EXPECT_GE(outpos, 0); + + EXPECT_GT(outpos, inpos); + + ASSERT_TRUE(CompareFiles(GetTestFilePath("text"), outfile_s)); +} + +TEST(SandboxTest, CheckCompressAndDecompressInMemoryFD) { + ZstdSapiSandbox sandbox; + absl::Status status; + int ret; + ASSERT_THAT(sandbox.Init(), IsOk()) << "Couldn't initialize Sandboxed API"; + ZstdApi api = ZstdApi(&sandbox); + + std::string infile_s = GetTestFilePath("text"); + + SAPI_ASSERT_OK_AND_ASSIGN(std::string path_middle, + sapi::CreateNamedTempFileAndClose("middle.zstd")); + std::string middle_s = + sapi::file::JoinPath(sapi::file_util::fileops::GetCWD(), path_middle); + + SAPI_ASSERT_OK_AND_ASSIGN(std::string path, + sapi::CreateNamedTempFileAndClose("out")); + std::string outfile_s = + sapi::file::JoinPath(sapi::file_util::fileops::GetCWD(), path); + + sapi::v::Fd infd(open(infile_s.c_str(), O_RDONLY)); + ASSERT_GE(infd.GetValue(), 0); + + sapi::v::Fd outmiddlefd(open(middle_s.c_str(), O_WRONLY)); + ASSERT_GE(outmiddlefd.GetValue(), 0); + + status = CompressInMemoryFD(api, infd, outmiddlefd, 0); + ASSERT_THAT(status, IsOk()) << "Unable to compress file in memory"; + + off_t inpos = lseek(infd.GetValue(), 0, SEEK_END); + EXPECT_GE(inpos, 0); + + off_t outpos = lseek(outmiddlefd.GetValue(), 0, SEEK_END); + EXPECT_GE(outpos, 0); + + EXPECT_LT(outpos, inpos); + + infd.CloseLocalFd(); + outmiddlefd.CloseLocalFd(); + + sapi::v::Fd inmiddlefd(open(middle_s.c_str(), O_RDONLY)); + ASSERT_GE(inmiddlefd.GetValue(), 0); + + sapi::v::Fd outfd(open(outfile_s.c_str(), O_WRONLY)); + ASSERT_GE(outfd.GetValue(), 0); + + status = DecompressInMemoryFD(api, inmiddlefd, outfd); ASSERT_THAT(status, IsOk()) << "Unable to decompress file in memory"; + outfd.CloseLocalFd(); + inmiddlefd.CloseLocalFd(); + + ASSERT_TRUE(CompareFiles(infile_s, outfile_s)); +} + +TEST(SandboxTest, CheckCompressStreamFD) { + absl::Status status; + ZstdSapiSandbox sandbox; + ASSERT_THAT(sandbox.Init(), IsOk()) << "Couldn't initialize Sandboxed API"; + ZstdApi api = ZstdApi(&sandbox); + + std::string infile_s = GetTestFilePath("text"); + + SAPI_ASSERT_OK_AND_ASSIGN(std::string path, + sapi::CreateNamedTempFileAndClose("out.zstd")); + std::string outfile_s = + sapi::file::JoinPath(sapi::file_util::fileops::GetCWD(), path); + + sapi::v::Fd infd(open(infile_s.c_str(), O_RDONLY)); + ASSERT_GE(infd.GetValue(), 0); + + sapi::v::Fd outfd(open(outfile_s.c_str(), O_WRONLY)); + ASSERT_GE(outfd.GetValue(), 0); + + status = CompressStreamFD(api, infd, outfd, 0); + ASSERT_THAT(status, IsOk()) << "Unable to compress stream"; + + off_t inpos = lseek(infd.GetValue(), 0, SEEK_END); + EXPECT_GE(inpos, 0); + + off_t outpos = lseek(outfd.GetValue(), 0, SEEK_END); + EXPECT_GE(outpos, 0); + + EXPECT_LT(outpos, inpos); +} + +TEST(SandboxTest, CheckDecompressStreamFD) { + absl::Status status; + ZstdSapiSandbox sandbox; + ASSERT_THAT(sandbox.Init(), IsOk()) << "Couldn't initialize Sandboxed API"; + ZstdApi api = ZstdApi(&sandbox); + + std::string infile_s = GetTestFilePath("text.stream.zstd"); + + SAPI_ASSERT_OK_AND_ASSIGN(std::string path, + sapi::CreateNamedTempFileAndClose("out")); + std::string outfile_s = + sapi::file::JoinPath(sapi::file_util::fileops::GetCWD(), path); + + sapi::v::Fd infd(open(infile_s.c_str(), O_RDONLY)); + ASSERT_GE(infd.GetValue(), 0); + + sapi::v::Fd outfd(open(outfile_s.c_str(), O_WRONLY)); + ASSERT_GE(outfd.GetValue(), 0); + + status = DecompressStreamFD(api, infd, outfd); + ASSERT_THAT(status, IsOk()) << "Unable to decompress stream"; + + off_t inpos = lseek(infd.GetValue(), 0, SEEK_END); + EXPECT_GE(inpos, 0); + + off_t outpos = lseek(outfd.GetValue(), 0, SEEK_END); + EXPECT_GE(outpos, 0); + + EXPECT_GT(outpos, inpos); + + ASSERT_TRUE(CompareFiles(GetTestFilePath("text"), outfile_s)); +} + +TEST(SandboxTest, CheckCompressAndDecompressStreamFD) { + ZstdSapiSandbox sandbox; + absl::Status status; + int ret; + ASSERT_THAT(sandbox.Init(), IsOk()) << "Couldn't initialize Sandboxed API"; + ZstdApi api = ZstdApi(&sandbox); + + std::string infile_s = GetTestFilePath("text"); + + SAPI_ASSERT_OK_AND_ASSIGN(std::string path_middle, + sapi::CreateNamedTempFileAndClose("middle.zstd")); + std::string middle_s = + sapi::file::JoinPath(sapi::file_util::fileops::GetCWD(), path_middle); + + SAPI_ASSERT_OK_AND_ASSIGN(std::string path, + sapi::CreateNamedTempFileAndClose("out")); + std::string outfile_s = + sapi::file::JoinPath(sapi::file_util::fileops::GetCWD(), path); + + sapi::v::Fd infd(open(infile_s.c_str(), O_RDONLY)); + ASSERT_GE(infd.GetValue(), 0); + + sapi::v::Fd outmiddlefd(open(middle_s.c_str(), O_WRONLY)); + ASSERT_GE(outmiddlefd.GetValue(), 0); + + status = CompressStreamFD(api, infd, outmiddlefd, 0); + ASSERT_THAT(status, IsOk()) << "Unable to compress stream"; + + off_t inpos = lseek(infd.GetValue(), 0, SEEK_END); + EXPECT_GE(inpos, 0); + + off_t outmiddlepos = lseek(outmiddlefd.GetValue(), 0, SEEK_END); + EXPECT_GE(outmiddlepos, 0); + + EXPECT_LT(outmiddlepos, inpos); + + infd.CloseLocalFd(); + outmiddlefd.CloseLocalFd(); + + sapi::v::Fd inmiddlefd(open(middle_s.c_str(), O_RDONLY)); + ASSERT_GE(inmiddlefd.GetValue(), 0); + + sapi::v::Fd outfd(open(outfile_s.c_str(), O_WRONLY)); + ASSERT_GE(outfd.GetValue(), 0); + + status = DecompressStreamFD(api, inmiddlefd, outfd); + ASSERT_THAT(status, IsOk()) << "Unable to decompress stream"; + ASSERT_TRUE(CompareFiles(infile_s, outfile_s)); } diff --git a/contrib/zstd/utils/utils_zstd.cc b/contrib/zstd/utils/utils_zstd.cc index 806b3d0..42c8c82 100644 --- a/contrib/zstd/utils/utils_zstd.cc +++ b/contrib/zstd/utils/utils_zstd.cc @@ -241,3 +241,95 @@ absl::Status DecompressStream(ZstdApi& api, std::ifstream& in_stream, return absl::OkStatus(); } + +absl::Status CompressInMemoryFD(ZstdApi& api, sapi::v::Fd& infd, + sapi::v::Fd& outfd, int level) { + SAPI_RETURN_IF_ERROR(api.GetSandbox()->TransferToSandboxee(&infd)); + SAPI_RETURN_IF_ERROR(api.GetSandbox()->TransferToSandboxee(&outfd)); + + SAPI_ASSIGN_OR_RETURN( + int iserr, + api.ZSTD_compress_fd(infd.GetRemoteFd(), outfd.GetRemoteFd(), 0)); + SAPI_ASSIGN_OR_RETURN(iserr, api.ZSTD_isError(iserr)) + if (iserr) { + return absl::UnavailableError("Unable to compress file"); + } + + infd.CloseRemoteFd(api.GetSandbox()->rpc_channel()).IgnoreError(); + outfd.CloseRemoteFd(api.GetSandbox()->rpc_channel()).IgnoreError(); + + return absl::OkStatus(); +} + +absl::Status DecompressInMemoryFD(ZstdApi& api, sapi::v::Fd& infd, + sapi::v::Fd& outfd) { + SAPI_RETURN_IF_ERROR(api.GetSandbox()->TransferToSandboxee(&infd)); + SAPI_RETURN_IF_ERROR(api.GetSandbox()->TransferToSandboxee(&outfd)); + + SAPI_ASSIGN_OR_RETURN(int iserr, api.ZSTD_decompress_fd(infd.GetRemoteFd(), + outfd.GetRemoteFd())); + SAPI_ASSIGN_OR_RETURN(iserr, api.ZSTD_isError(iserr)) + if (iserr) { + return absl::UnavailableError("Unable to compress file"); + } + + infd.CloseRemoteFd(api.GetSandbox()->rpc_channel()).IgnoreError(); + outfd.CloseRemoteFd(api.GetSandbox()->rpc_channel()).IgnoreError(); + + return absl::OkStatus(); +} + +absl::Status CompressStreamFD(ZstdApi& api, sapi::v::Fd& infd, + sapi::v::Fd& outfd, int level) { + SAPI_ASSIGN_OR_RETURN(ZSTD_CCtx * cctx, api.ZSTD_createCCtx()); + sapi::v::RemotePtr rcctx(cctx); + + int iserr; + SAPI_ASSIGN_OR_RETURN(iserr, api.ZSTD_CCtx_setParameter( + &rcctx, ZSTD_c_compressionLevel, level)); + SAPI_ASSIGN_OR_RETURN(iserr, api.ZSTD_isError(iserr)); + if (iserr) { + return absl::UnavailableError("Unable to set parameter l"); + } + SAPI_ASSIGN_OR_RETURN( + iserr, api.ZSTD_CCtx_setParameter(&rcctx, ZSTD_c_checksumFlag, 1)); + SAPI_ASSIGN_OR_RETURN(iserr, api.ZSTD_isError(iserr)); + if (iserr) { + return absl::UnavailableError("Unable to set parameter c"); + } + + SAPI_RETURN_IF_ERROR(api.GetSandbox()->TransferToSandboxee(&infd)); + SAPI_RETURN_IF_ERROR(api.GetSandbox()->TransferToSandboxee(&outfd)); + + SAPI_ASSIGN_OR_RETURN(iserr, + api.ZSTD_compressStream_fd(&rcctx, infd.GetRemoteFd(), + outfd.GetRemoteFd())); + if (iserr) { + return absl::UnavailableError("Unable to compress"); + } + + infd.CloseRemoteFd(api.GetSandbox()->rpc_channel()).IgnoreError(); + outfd.CloseRemoteFd(api.GetSandbox()->rpc_channel()).IgnoreError(); + + return absl::OkStatus(); +} + +absl::Status DecompressStreamFD(ZstdApi& api, sapi::v::Fd& infd, + sapi::v::Fd& outfd) { + SAPI_ASSIGN_OR_RETURN(ZSTD_DCtx * dctx, api.ZSTD_createDCtx()); + sapi::v::RemotePtr rdctx(dctx); + + SAPI_RETURN_IF_ERROR(api.GetSandbox()->TransferToSandboxee(&infd)); + SAPI_RETURN_IF_ERROR(api.GetSandbox()->TransferToSandboxee(&outfd)); + + SAPI_ASSIGN_OR_RETURN(int iserr, + api.ZSTD_decompressStream_fd(&rdctx, infd.GetRemoteFd(), + outfd.GetRemoteFd())); + if (iserr) { + return absl::UnavailableError("Unable to decompress"); + } + infd.CloseRemoteFd(api.GetSandbox()->rpc_channel()).IgnoreError(); + outfd.CloseRemoteFd(api.GetSandbox()->rpc_channel()).IgnoreError(); + + return absl::OkStatus(); +} diff --git a/contrib/zstd/utils/utils_zstd.h b/contrib/zstd/utils/utils_zstd.h index cac7a9d..02e3500 100644 --- a/contrib/zstd/utils/utils_zstd.h +++ b/contrib/zstd/utils/utils_zstd.h @@ -24,10 +24,18 @@ absl::Status CompressInMemory(ZstdApi& api, std::ifstream& in_stream, std::ofstream& out_stream, int level); absl::Status DecompressInMemory(ZstdApi& api, std::ifstream& in_stream, std::ofstream& out_stream); +absl::Status CompressInMemoryFD(ZstdApi& api, sapi::v::Fd& infd, + sapi::v::Fd& outfd, int level); +absl::Status DecompressInMemoryFD(ZstdApi& api, sapi::v::Fd& infd, + sapi::v::Fd& outfd); absl::Status CompressStream(ZstdApi& api, std::ifstream& in_stream, std::ofstream& out_stream, int level); absl::Status DecompressStream(ZstdApi& api, std::ifstream& in_stream, std::ofstream& out_stream); +absl::Status CompressStreamFD(ZstdApi& api, sapi::v::Fd& infd, + sapi::v::Fd& outfd, int level); +absl::Status DecompressStreamFD(ZstdApi& api, sapi::v::Fd& infd, + sapi::v::Fd& outfd); #endif // CONTRIB_ZSTD_UTILS_UTILS_ZSTD_H_ diff --git a/contrib/zstd/wrapper/CMakeLists.txt b/contrib/zstd/wrapper/CMakeLists.txt new file mode 100644 index 0000000..0febbc8 --- /dev/null +++ b/contrib/zstd/wrapper/CMakeLists.txt @@ -0,0 +1,24 @@ +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +add_library(wrapper_zstd STATIC + wrapper_zstd.cc +) +target_link_libraries(wrapper_zstd PUBLIC + libzstd_static +) +target_include_directories(wrapper_zstd PUBLIC + "${SAPI_SOURCE_DIR}" + "${libzstd_INCLUDE_DIR}" +) diff --git a/contrib/zstd/wrapper/wrapper_zstd.cc b/contrib/zstd/wrapper/wrapper_zstd.cc new file mode 100644 index 0000000..f0c7bf4 --- /dev/null +++ b/contrib/zstd/wrapper/wrapper_zstd.cc @@ -0,0 +1,182 @@ +// Copyright 2022 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "contrib/zstd/wrapper/wrapper_zstd.h" + +#include +#include +#include + +#include +#include +#include +#include + +constexpr size_t kFileMaxSize = 1024 * 1024 * 1024; // 1GB + +off_t FDGetSize(int fd) { + off_t size = lseek(fd, 0, SEEK_END); + if (size < 0) { + return -1; + } + if (lseek(fd, 0, SEEK_SET) < 0) { + return -1; + } + + return size; +} + +int ZSTD_compress_fd(int fdin, int fdout, int level) { + off_t sizein = FDGetSize(fdin); + if (sizein <= 0) { + return -1; + } + + size_t sizeout = ZSTD_compressBound(sizein); + + auto bufin = std::make_unique(sizein); + auto bufout = std::make_unique(sizeout); + + if (read(fdin, bufin.get(), sizein) != sizein) { + return -1; + } + + int retsize = + ZSTD_compress(bufout.get(), sizeout, bufin.get(), sizein, level); + if (ZSTD_isError(retsize)) { + return -1; + } + + if (write(fdout, bufout.get(), retsize) != retsize) { + return -1; + } + + return 0; +} + +int ZSTD_compressStream_fd(ZSTD_CCtx* cctx, int fdin, int fdout) { + size_t sizein = ZSTD_CStreamInSize(); + size_t sizeout = ZSTD_CStreamOutSize(); + + auto bufin = std::make_unique(sizein); + auto bufout = std::make_unique(sizeout); + + ssize_t size; + while ((size = read(fdin, bufin.get(), sizein)) > 0) { + ZSTD_inBuffer_s struct_in; + struct_in.src = bufin.get(); + struct_in.pos = 0; + struct_in.size = size; + + ZSTD_EndDirective mode = ZSTD_e_continue; + if (size < sizein) { + mode = ZSTD_e_end; + } + + bool isdone = false; + while (!isdone) { + ZSTD_outBuffer_s struct_out; + struct_out.dst = bufout.get(); + struct_out.pos = 0; + struct_out.size = sizeout; + + size_t remaining = + ZSTD_compressStream2(cctx, &struct_out, &struct_in, mode); + if (ZSTD_isError(remaining)) { + return -1; + } + if (write(fdout, bufout.get(), struct_out.pos) != struct_out.pos) { + return -1; + } + + if (mode == ZSTD_e_continue) { + isdone = (struct_in.pos == size); + } else { + isdone = (remaining == 0); + } + } + } + + if (size != 0) { + return -1; + } + + return 0; +} + +int ZSTD_decompress_fd(int fdin, int fdout) { + off_t sizein = FDGetSize(fdin); + if (sizein <= 0) { + return -1; + } + auto bufin = std::make_unique(sizein); + if (read(fdin, bufin.get(), sizein) != sizein) { + return -1; + } + + size_t sizeout = ZSTD_getFrameContentSize(bufin.get(), sizein); + if (ZSTD_isError(sizeout) || sizeout > kFileMaxSize) { + return -1; + } + + auto bufout = std::make_unique(sizeout); + + size_t desize = ZSTD_decompress(bufout.get(), sizeout, bufin.get(), sizein); + if (ZSTD_isError(desize) || desize != sizeout) { + return -1; + } + + if (write(fdout, bufout.get(), sizeout) != sizeout) { + return -1; + } + + return 0; +} + +int ZSTD_decompressStream_fd(ZSTD_DCtx* dctx, int fdin, int fdout) { + size_t sizein = ZSTD_CStreamInSize(); + size_t sizeout = ZSTD_CStreamOutSize(); + + auto bufin = std::make_unique(sizein); + auto bufout = std::make_unique(sizeout); + + ssize_t size; + while ((size = read(fdin, bufin.get(), sizein)) > 0) { + ZSTD_inBuffer_s struct_in; + struct_in.src = bufin.get(); + struct_in.pos = 0; + struct_in.size = size; + + while (struct_in.pos < size) { + ZSTD_outBuffer_s struct_out; + struct_out.dst = bufout.get(); + struct_out.pos = 0; + struct_out.size = sizeout; + + size_t ret = ZSTD_decompressStream(dctx, &struct_out, &struct_in); + if (ZSTD_isError(ret)) { + return -1; + } + if (write(fdout, bufout.get(), struct_out.pos) != struct_out.pos) { + return -1; + } + } + } + + if (size != 0) { + return -1; + } + + return 0; +} diff --git a/contrib/zstd/wrapper/wrapper_zstd.h b/contrib/zstd/wrapper/wrapper_zstd.h new file mode 100644 index 0000000..ed8da14 --- /dev/null +++ b/contrib/zstd/wrapper/wrapper_zstd.h @@ -0,0 +1,28 @@ +// Copyright 2022 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef CONTRIB_ZSTD_WRAPPER_WRAPPER_ZSTD_H_ +#define CONTRIB_ZSTD_WRAPPER_WRAPPER_ZSTD_H_ + +#include + +extern "C" { +int ZSTD_compress_fd(int fdin, int fdout, int level); +int ZSTD_compressStream_fd(ZSTD_CCtx* cctx, int fdin, int fdout); + +int ZSTD_decompress_fd(int fdin, int fdout); +int ZSTD_decompressStream_fd(ZSTD_DCtx* dctx, int fdin, int fdout); +}; + +#endif // CONTRIB_ZSTD_WRAPPER_WRAPPER_ZSTD_H_ diff --git a/oss-internship-2020/pffft/.gitignore b/oss-internship-2020/pffft/.gitignore deleted file mode 100644 index eb6d948..0000000 --- a/oss-internship-2020/pffft/.gitignore +++ /dev/null @@ -1,3 +0,0 @@ -*.o -*.a -pffft_main diff --git a/sandboxed_api/examples/zlib/BUILD.bazel b/sandboxed_api/examples/zlib/BUILD.bazel index 153a6d5..a727c8a 100644 --- a/sandboxed_api/examples/zlib/BUILD.bazel +++ b/sandboxed_api/examples/zlib/BUILD.bazel @@ -36,7 +36,7 @@ sapi_library( cc_binary( name = "main_zlib", srcs = ["main_zlib.cc"], - copts = sapi_platform_copts(["-Wframe-larger-than=65536"]), + copts = sapi_platform_copts(), deps = [ ":zlib-sapi", ":zlib-sapi_embed", diff --git a/sandboxed_api/examples/zlib/CMakeLists.txt b/sandboxed_api/examples/zlib/CMakeLists.txt index 8fb97a6..f851b77 100644 --- a/sandboxed_api/examples/zlib/CMakeLists.txt +++ b/sandboxed_api/examples/zlib/CMakeLists.txt @@ -17,7 +17,7 @@ add_sapi_library(zlib-sapi FUNCTIONS deflateInit_ deflate deflateEnd - INPUTS ${ZLIB_INCLUDE_DIRS}/zlib.h + INPUTS "${ZLIB_INCLUDE_DIRS}/zlib.h" LIBRARY ZLIB::ZLIB LIBRARY_NAME Zlib NAMESPACE "sapi::zlib" diff --git a/sandboxed_api/sandbox2/comms.cc b/sandboxed_api/sandbox2/comms.cc index 482a6c8..9b27e0d 100644 --- a/sandboxed_api/sandbox2/comms.cc +++ b/sandboxed_api/sandbox2/comms.cc @@ -555,9 +555,11 @@ bool Comms::Recv(void* data, size_t len) { // Internal helper method (low level). bool Comms::RecvTL(uint32_t* tag, size_t* length) { if (!Recv(reinterpret_cast(tag), sizeof(*tag))) { + SAPI_RAW_VLOG(2, "RecvTL: Can't read tag"); return false; } if (!Recv(reinterpret_cast(length), sizeof(*length))) { + SAPI_RAW_VLOG(2, "RecvTL: Can't read length for tag %u", *tag); return false; } if (*length > GetMaxMsgSize()) { diff --git a/sandboxed_api/sandbox2/examples/static/BUILD.bazel b/sandboxed_api/sandbox2/examples/static/BUILD.bazel index 74f49ec..17fbe5f 100644 --- a/sandboxed_api/sandbox2/examples/static/BUILD.bazel +++ b/sandboxed_api/sandbox2/examples/static/BUILD.bazel @@ -57,4 +57,5 @@ sh_test( name = "static_sandbox_test", srcs = ["static_sandbox_test.sh"], data = [":static_sandbox"], + tags = ["no_qemu_user_mode"], ) diff --git a/sandboxed_api/sandbox2/examples/zlib/BUILD.bazel b/sandboxed_api/sandbox2/examples/zlib/BUILD.bazel index e553e54..4b4c232 100644 --- a/sandboxed_api/sandbox2/examples/zlib/BUILD.bazel +++ b/sandboxed_api/sandbox2/examples/zlib/BUILD.bazel @@ -37,9 +37,6 @@ cc_binary( name = "zpipe", srcs = ["zpipe.c"], copts = sapi_platform_copts(), - features = [ - "fully_static_link", # link libc statically - ], - linkstatic = 1, + features = ["fully_static_link"], deps = ["@net_zlib//:zlib"], ) diff --git a/sandboxed_api/sandbox2/examples/zlib/CMakeLists.txt b/sandboxed_api/sandbox2/examples/zlib/CMakeLists.txt index e443324..e5e45b5 100644 --- a/sandboxed_api/sandbox2/examples/zlib/CMakeLists.txt +++ b/sandboxed_api/sandbox2/examples/zlib/CMakeLists.txt @@ -24,7 +24,6 @@ target_link_libraries(sandbox2_zpipe_sandbox PRIVATE absl::memory sandbox2::bpf_helper sandbox2::comms - # sandbox2::ipc sapi::runfiles sandbox2::sandbox2 sapi::base @@ -38,5 +37,6 @@ add_executable(sandbox2_zpipe set_target_properties(sandbox2_zpipe PROPERTIES OUTPUT_NAME zpipe) add_executable(sandbox2::zpipe ALIAS sandbox2_zpipe) target_link_libraries(sandbox2_zpipe PRIVATE + -static ZLIB::ZLIB ) diff --git a/sandboxed_api/sandbox2/examples/zlib/zpipe_sandbox.cc b/sandboxed_api/sandbox2/examples/zlib/zpipe_sandbox.cc index 556cf74..f018b10 100644 --- a/sandboxed_api/sandbox2/examples/zlib/zpipe_sandbox.cc +++ b/sandboxed_api/sandbox2/examples/zlib/zpipe_sandbox.cc @@ -54,7 +54,7 @@ std::unique_ptr GetPolicy() { // Allow write on STDOUT / STDERR. .AddPolicyOnSyscall(__NR_write, {ARG_32(0), JEQ32(1, ALLOW), JEQ32(2, ALLOW)}) - .AllowSyscall(__NR_fstat) + .AllowStat() .AllowStaticStartup() .AllowSystemMalloc() .AllowExit() diff --git a/sandboxed_api/sandbox2/policybuilder.cc b/sandboxed_api/sandbox2/policybuilder.cc index 786fa09..0dc34b7 100644 --- a/sandboxed_api/sandbox2/policybuilder.cc +++ b/sandboxed_api/sandbox2/policybuilder.cc @@ -653,12 +653,10 @@ PolicyBuilder& PolicyBuilder::AllowStaticStartup() { BlockSyscallWithErrno(__NR_readlink, ENOENT); #endif - if constexpr (sapi::host_cpu::IsArm()) { - AddPolicyOnSyscall(__NR_mprotect, { - ARG_32(2), - JEQ32(PROT_READ, ALLOW), - }); - } + AddPolicyOnSyscall(__NR_mprotect, { + ARG_32(2), + JEQ32(PROT_READ, ALLOW), + }); return *this; } @@ -884,7 +882,7 @@ PolicyBuilder& PolicyBuilder::AddFile(absl::string_view path, bool is_ro) { PolicyBuilder& PolicyBuilder::AddFileAt(absl::string_view outside, absl::string_view inside, bool is_ro) { - EnableNamespaces(); + EnableNamespaces(); // NOLINT(clang-diagnostic-deprecated-declarations) auto valid_outside = ValidateAbsolutePath(outside); if (!valid_outside.ok()) { @@ -912,7 +910,7 @@ PolicyBuilder& PolicyBuilder::AddFileAt(absl::string_view outside, PolicyBuilder& PolicyBuilder::AddLibrariesForBinary( absl::string_view path, absl::string_view ld_library_path) { - EnableNamespaces(); + EnableNamespaces(); // NOLINT(clang-diagnostic-deprecated-declarations) auto valid_path = ValidatePath(path); if (!valid_path.ok()) { @@ -941,7 +939,7 @@ PolicyBuilder& PolicyBuilder::AddDirectory(absl::string_view path, bool is_ro) { PolicyBuilder& PolicyBuilder::AddDirectoryAt(absl::string_view outside, absl::string_view inside, bool is_ro) { - EnableNamespaces(); + EnableNamespaces(); // NOLINT(clang-diagnostic-deprecated-declarations) auto valid_outside = ValidateAbsolutePath(outside); if (!valid_outside.ok()) { @@ -969,7 +967,7 @@ PolicyBuilder& PolicyBuilder::AddDirectoryAt(absl::string_view outside, } PolicyBuilder& PolicyBuilder::AddTmpfs(absl::string_view inside, size_t size) { - EnableNamespaces(); + EnableNamespaces(); // NOLINT(clang-diagnostic-deprecated-declarations) if (auto status = mounts_.AddTmpfs(inside, size); !status.ok()) { SetError(absl::InternalError(absl::StrCat("Could not mount tmpfs ", inside, @@ -979,14 +977,14 @@ PolicyBuilder& PolicyBuilder::AddTmpfs(absl::string_view inside, size_t size) { } PolicyBuilder& PolicyBuilder::AllowUnrestrictedNetworking() { - EnableNamespaces(); + EnableNamespaces(); // NOLINT(clang-diagnostic-deprecated-declarations) allow_unrestricted_networking_ = true; return *this; } PolicyBuilder& PolicyBuilder::SetHostname(absl::string_view hostname) { - EnableNamespaces(); + EnableNamespaces(); // NOLINT(clang-diagnostic-deprecated-declarations) hostname_ = std::string(hostname); return *this; @@ -1089,7 +1087,7 @@ PolicyBuilder& PolicyBuilder::AddNetworkProxyHandlerPolicy() { } PolicyBuilder& PolicyBuilder::SetRootWritable() { - EnableNamespaces(); + EnableNamespaces(); // NOLINT(clang-diagnostic-deprecated-declarations) mounts_.SetRootWritable(); return *this; diff --git a/sandboxed_api/sandbox2/stack_trace.cc b/sandboxed_api/sandbox2/stack_trace.cc index 156d298..e48c501 100644 --- a/sandboxed_api/sandbox2/stack_trace.cc +++ b/sandboxed_api/sandbox2/stack_trace.cc @@ -286,9 +286,6 @@ absl::StatusOr StackTracePeer::LaunchLibunwindSandbox( absl::StatusOr> GetStackTrace(const Regs* regs, const Mounts& mounts) { - if constexpr (sapi::host_cpu::IsArm64()) { - return absl::UnavailableError("Stack traces unavailable on Aarch64"); - } if (absl::GetFlag(FLAGS_sandbox_disable_all_stack_traces)) { return absl::UnavailableError("Stacktraces disabled"); } diff --git a/sandboxed_api/sandbox2/unwind/BUILD.bazel b/sandboxed_api/sandbox2/unwind/BUILD.bazel index 8172af1..e349f88 100644 --- a/sandboxed_api/sandbox2/unwind/BUILD.bazel +++ b/sandboxed_api/sandbox2/unwind/BUILD.bazel @@ -62,6 +62,7 @@ cc_library( "//sandboxed_api/util:raw_logging", "//sandboxed_api/util:status", "//sandboxed_api/util:strerror", + "@com_google_absl//absl/cleanup", "@com_google_absl//absl/status:statusor", "@com_google_absl//absl/strings", "@org_gnu_libunwind//:unwind-ptrace-wrapped", diff --git a/sandboxed_api/sandbox2/unwind/CMakeLists.txt b/sandboxed_api/sandbox2/unwind/CMakeLists.txt index 1fe7aa6..92915af 100644 --- a/sandboxed_api/sandbox2/unwind/CMakeLists.txt +++ b/sandboxed_api/sandbox2/unwind/CMakeLists.txt @@ -30,6 +30,7 @@ add_library(sandbox2_unwind STATIC ) add_library(sandbox2::unwind ALIAS sandbox2_unwind) target_link_libraries(sandbox2_unwind PRIVATE + absl::cleanup absl::statusor absl::strings sandbox2::comms diff --git a/sandboxed_api/sandbox2/unwind/unwind.cc b/sandboxed_api/sandbox2/unwind/unwind.cc index 690c311..e62a458 100644 --- a/sandboxed_api/sandbox2/unwind/unwind.cc +++ b/sandboxed_api/sandbox2/unwind/unwind.cc @@ -19,11 +19,13 @@ #include #include #include +#include #include #include #include #include +#include "absl/cleanup/cleanup.h" #include "absl/status/statusor.h" #include "absl/strings/match.h" #include "absl/strings/str_cat.h" @@ -55,21 +57,20 @@ std::string DemangleSymbol(const std::string& maybe_mangled) { } absl::StatusOr> RunLibUnwind(pid_t pid, int max_frames) { - unw_cursor_t cursor; static unw_addr_space_t as = unw_create_addr_space(&_UPT_accessors, 0 /* byte order */); if (as == nullptr) { return absl::InternalError("unw_create_addr_space() failed"); } - std::unique_ptr ui( - reinterpret_cast(_UPT_create(pid)), _UPT_destroy); - if (ui == nullptr) { + void* context = _UPT_create(pid); + if (context == nullptr) { return absl::InternalError("_UPT_create() failed"); } + absl::Cleanup context_cleanup = [&context] { _UPT_destroy(context); }; - int rc = unw_init_remote(&cursor, as, ui.get()); - if (rc < 0) { + unw_cursor_t cursor; + if (int rc = unw_init_remote(&cursor, as, context); rc < 0) { // Could be UNW_EINVAL (8), UNW_EUNSPEC (1) or UNW_EBADREG (3). return absl::InternalError( absl::StrCat("unw_init_remote() failed with error ", rc)); @@ -78,7 +79,7 @@ absl::StatusOr> RunLibUnwind(pid_t pid, int max_frames) { std::vector ips; for (int i = 0; i < max_frames; ++i) { unw_word_t ip; - rc = unw_get_reg(&cursor, UNW_REG_IP, &ip); + int rc = unw_get_reg(&cursor, UNW_REG_IP, &ip); if (rc < 0) { // Could be UNW_EUNSPEC or UNW_EBADREG. SAPI_RAW_LOG(WARNING, "unw_get_reg() failed with error %d", rc); @@ -176,8 +177,10 @@ absl::StatusOr LoadSymbolsMap(pid_t pid) { for (const ElfFile::Symbol& symbol : elf->symbols()) { if (elf->position_independent()) { - if (symbol.address < entry.end - entry.start) { - addr_to_symbol[symbol.address + entry.start] = symbol.name; + if (symbol.address >= entry.pgoff && + symbol.address - entry.pgoff < entry.end - entry.start) { + addr_to_symbol[symbol.address + entry.start - entry.pgoff] = + symbol.name; } } else { if (symbol.address >= entry.start && symbol.address < entry.end) { diff --git a/sandboxed_api/sandbox2/util/minielf_test.cc b/sandboxed_api/sandbox2/util/minielf_test.cc index 1e973c3..cccd97f 100644 --- a/sandboxed_api/sandbox2/util/minielf_test.cc +++ b/sandboxed_api/sandbox2/util/minielf_test.cc @@ -26,13 +26,14 @@ #include "sandboxed_api/util/file_helpers.h" #include "sandboxed_api/util/status_matchers.h" -extern "C" void ExportedFunctionName() { +extern "C" void ExportedFunction() { // Don't do anything - used to generate a symbol. } namespace file = ::sapi::file; using ::sapi::GetTestSourcePath; using ::sapi::IsOk; +using ::testing::ElementsAre; using ::testing::Eq; using ::testing::IsTrue; using ::testing::Ne; @@ -65,19 +66,20 @@ TEST(MinielfTest, SymbolResolutionWorks) { ParseProcMaps(maps_buffer)); // Find maps entry that covers this entry. - uint64_t function_address = reinterpret_cast(ExportedFunctionName); - auto function_entry = + uint64_t function_address = reinterpret_cast(&ExportedFunction); + auto entry = absl::c_find_if(maps, [function_address](const MapsEntry& entry) { return entry.start <= function_address && entry.end > function_address; }); - ASSERT_THAT(function_entry, Ne(maps.end())); - function_address -= function_entry->start; + ASSERT_THAT(entry, Ne(maps.end())); auto function_symbol = absl::c_find_if(elf.symbols(), [](const ElfFile::Symbol& symbol) { - return symbol.name == "ExportedFunctionName"; + return symbol.name == "ExportedFunction"; }); ASSERT_THAT(function_symbol, Ne(elf.symbols().end())); + + function_address -= entry->start - entry->pgoff; EXPECT_THAT(function_symbol->address, Eq(function_address)); } @@ -86,8 +88,7 @@ TEST(MinielfTest, ImportedLibraries) { ElfFile elf, ElfFile::ParseFromFile( GetTestSourcePath("sandbox2/util/testdata/hello_world"), ElfFile::kLoadImportedLibraries)); - std::vector imported_libraries = {"libc.so.6"}; - EXPECT_THAT(elf.imported_libraries(), Eq(imported_libraries)); + EXPECT_THAT(elf.imported_libraries(), ElementsAre("libc.so.6")); } } // namespace diff --git a/sandboxed_api/util/status.cc b/sandboxed_api/util/status.cc index 323915d..df93823 100644 --- a/sandboxed_api/util/status.cc +++ b/sandboxed_api/util/status.cc @@ -31,8 +31,11 @@ void SaveStatusToProto(const absl::Status& status, StatusProto* out) { absl::Status MakeStatusFromProto(const StatusProto& proto) { absl::Status status(static_cast(proto.code()), proto.message()); - for (const auto& [type_key, payload] : proto.payloads()) { - status.SetPayload(type_key, absl::Cord(payload)); + // Note: Using C++17 structured bindings instead of `entry` crashes Clang 6.0 + // on Ubuntu 18.04 (bionic). + for (const auto& entry : proto.payloads()) { + status.SetPayload(/*type_url=*/entry.first, + /*payload=*/absl::Cord(entry.second)); } return status; }