From 662064512ba08facc0999038818f424f50f6bdb6 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Mon, 15 Apr 2024 14:54:21 +0200 Subject: [PATCH 01/54] update version, add python 3.12.x to wheel-check from testpypi --- .github/workflows/wheels.yml | 4 ++++ setup.py | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml index 39f5b87..2f5b852 100644 --- a/.github/workflows/wheels.yml +++ b/.github/workflows/wheels.yml @@ -21,6 +21,7 @@ jobs: os: [windows-latest, ubuntu-latest, macos-latest] steps: - uses: actions/checkout@v3 + ############################# LINUX WHEELS ############################# # In case of Linux we need to install compiler and build tools before building the wheels # We further only build the manylinux wheels, but not the musllinux wheels - name: Build wheels (Linux) @@ -34,6 +35,7 @@ jobs: package-dir: . output-dir: dist if: matrix.os == 'ubuntu-latest' + ############################# MACOS WHEELS ############################# # Building on macOS requires an installation of gcc since the default clang compiler # lacks certain features required for building the package - name: Build wheels (macOS) @@ -46,6 +48,7 @@ jobs: package-dir: . output-dir: dist if: matrix.os == 'macos-latest' + ############################# WINDOWS WHEELS ############################# # Set up the Visual Studio environment on Windows (required, so that CMake finds the compiler) - uses: ilammy/msvc-dev-cmd@v1 if: matrix.os == 'windows-latest' @@ -113,6 +116,7 @@ jobs: 3.9.x, 3.10.x, 3.11.x, + 3.12.x, pypy3.7, pypy3.8, pypy3.9, diff --git a/setup.py b/setup.py index 0bba93f..41a8a63 100644 --- a/setup.py +++ b/setup.py @@ -165,7 +165,7 @@ def build_extension(self, ext): # -------------------------------------------------------------------------------- setup( name="polyhedral_gravity", - version="2.2", + version="3.0", author="Jonas Schuhmacher", author_email="jonas.schuhmacher@tum.de", description="Package to compute full gravity tensor of a given constant density polyhedron for arbitrary points", From 82b66dde96b85af25a3c34e6828b2b174baf9952 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Mon, 15 Apr 2024 15:15:13 +0200 Subject: [PATCH 02/54] write the current code style to a clang format file --- .clang-format | 66 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 66 insertions(+) create mode 100644 .clang-format diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..4ffb425 --- /dev/null +++ b/.clang-format @@ -0,0 +1,66 @@ +# Generated from CLion C/C++ Code Style settings +BasedOnStyle: LLVM +AccessModifierOffset: -4 +AlignAfterOpenBracket: Align +AlignConsecutiveAssignments: None +AlignOperands: Align +AllowAllArgumentsOnNextLine: false +AllowAllConstructorInitializersOnNextLine: false +AllowAllParametersOfDeclarationOnNextLine: false +AllowShortBlocksOnASingleLine: Always +AllowShortCaseLabelsOnASingleLine: false +AllowShortFunctionsOnASingleLine: None +AllowShortIfStatementsOnASingleLine: Always +AllowShortLambdasOnASingleLine: All +AllowShortLoopsOnASingleLine: true +AlwaysBreakAfterReturnType: None +AlwaysBreakTemplateDeclarations: Yes +BreakBeforeBraces: Custom +BraceWrapping: + AfterCaseLabel: false + AfterClass: false + AfterControlStatement: Never + AfterEnum: false + AfterFunction: false + AfterNamespace: false + AfterUnion: false + BeforeCatch: false + BeforeElse: false + IndentBraces: false + SplitEmptyFunction: false + SplitEmptyRecord: true +BreakBeforeBinaryOperators: None +BreakBeforeTernaryOperators: true +BreakConstructorInitializers: BeforeColon +BreakInheritanceList: BeforeColon +ColumnLimit: 0 +CompactNamespaces: false +ContinuationIndentWidth: 8 +IndentCaseLabels: true +IndentPPDirectives: None +IndentWidth: 4 +KeepEmptyLinesAtTheStartOfBlocks: true +MaxEmptyLinesToKeep: 2 +NamespaceIndentation: All +ObjCSpaceAfterProperty: false +ObjCSpaceBeforeProtocolList: true +PointerAlignment: Right +ReflowComments: false +SpaceAfterCStyleCast: true +SpaceAfterLogicalNot: false +SpaceAfterTemplateKeyword: false +SpaceBeforeAssignmentOperators: true +SpaceBeforeCpp11BracedList: false +SpaceBeforeCtorInitializerColon: true +SpaceBeforeInheritanceColon: true +SpaceBeforeParens: ControlStatements +SpaceBeforeRangeBasedForLoopColon: false +SpaceInEmptyParentheses: false +SpacesBeforeTrailingComments: 0 +SpacesInAngles: false +SpacesInCStyleCastParentheses: false +SpacesInContainerLiterals: false +SpacesInParentheses: false +SpacesInSquareBrackets: false +TabWidth: 4 +UseTab: Never From f6f7e33ffb8b7687056315aa2adf9045a61079ce Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Mon, 15 Apr 2024 15:41:35 +0200 Subject: [PATCH 03/54] move ray generation into the detail method --- .../calculation/MeshChecking.cpp | 35 ++++++++++--------- .../calculation/MeshChecking.h | 5 ++- 2 files changed, 20 insertions(+), 20 deletions(-) diff --git a/src/polyhedralGravity/calculation/MeshChecking.cpp b/src/polyhedralGravity/calculation/MeshChecking.cpp index 38ac5f3..5f93f29 100644 --- a/src/polyhedralGravity/calculation/MeshChecking.cpp +++ b/src/polyhedralGravity/calculation/MeshChecking.cpp @@ -3,25 +3,13 @@ namespace polyhedralGravity::MeshChecking { bool checkNormalsOutwardPointing(const Polyhedron &polyhedron) { - using namespace util; auto it = transformPolyhedron(polyhedron); // All normals have to point outwards (intersect the polyhedron even times) return thrust::transform_reduce( thrust::device, it.first, it.second, [&polyhedron](const Array3Triplet &face) { - // The centroid of the triangular face - const Array3 centroid = (face[0] + face[1] + face[2]) / 3.0; - - // The normal of the plane calculated with two segments of the triangle - const Array3 segmentVector1 = face[1] - face[0]; - const Array3 segmentVector2 = face[2] - face[1]; - const Array3 normal = util::normal(segmentVector1, segmentVector2); - - // The origin of the array has a slight offset in direction of the normal - const Array3 rayOrigin = centroid + (normal * EPSILON); - // If the ray intersects the polyhedron an even number of times then the normal points outwards - const size_t intersects = detail::countRayPolyhedronIntersections(rayOrigin, normal, polyhedron); + const size_t intersects = detail::countRayPolyhedronIntersections(face, polyhedron); return intersects % 2 == 0; }, true, thrust::logical_and()); } @@ -37,12 +25,25 @@ namespace polyhedralGravity::MeshChecking { } size_t - detail::countRayPolyhedronIntersections(const Array3 &rayOrigin, const Array3 &rayVector, const Polyhedron &polyhedron) { + detail::countRayPolyhedronIntersections(const Array3Triplet& face, const Polyhedron &polyhedron) { + using namespace util; + // The centroid of the triangular face + const Array3 centroid = (face[0] + face[1] + face[2]) / 3.0; + + // The normal of the plane calculated with two segments of the triangle + // The normal is the rayVector starting at the rayOrigin + const Array3 segmentVector1 = face[1] - face[0]; + const Array3 segmentVector2 = face[2] - face[1]; + const Array3 rayVector = util::normal(segmentVector1, segmentVector2); + + // The origin of the array has a slight offset in direction of the normal + const Array3 rayOrigin = centroid + (rayVector * EPSILON); + + // Count every triangular face which is intersected by the ray auto it = transformPolyhedron(polyhedron); std::set intersections{}; - // Count every triangular face which is intersected by the ray - std::for_each(it.first, it.second, [&rayOrigin, &rayVector, &intersections](const Array3Triplet &triangle) { - const auto intersection = rayIntersectsTriangle(rayOrigin, rayVector, triangle); + std::for_each(it.first, it.second, [&rayOrigin, &rayVector, &intersections](const Array3Triplet &otherFace) { + const std::unique_ptr intersection = rayIntersectsTriangle(rayOrigin, rayVector, otherFace); if (intersection != nullptr) { intersections.insert(*intersection); } diff --git a/src/polyhedralGravity/calculation/MeshChecking.h b/src/polyhedralGravity/calculation/MeshChecking.h index baac125..bbc4591 100644 --- a/src/polyhedralGravity/calculation/MeshChecking.h +++ b/src/polyhedralGravity/calculation/MeshChecking.h @@ -36,13 +36,12 @@ namespace polyhedralGravity::MeshChecking { /** * Calculates how often a vector starting at a specific origin intersects a polyhedron's mesh's triangles. - * @param rayOrigin the origin of the ray - * @param rayVector the vector describing the ray + * @param face the vector describing the ray * @param polyhedron the polyhedron consisting of vertices and triangular faces * @return true if the ray intersects the triangle */ size_t - countRayPolyhedronIntersections(const Array3 &rayOrigin, const Array3 &rayVector, const Polyhedron &polyhedron); + countRayPolyhedronIntersections(const Array3Triplet& face, const Polyhedron &polyhedron); /** * Calculates how often a vector starting at a specific origin intersects a triangular face. From 8389f550c1bce5ed7593149eea964a9886e928ea Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Mon, 15 Apr 2024 17:26:17 +0200 Subject: [PATCH 04/54] Implement normals orientation check in MeshChecking Modified the MeshChecking functionality to include an orientation check for both outward and inward facing normals. Also included a method to determine the majority vertex ordering of a polyhedron and which vertices violate this ordering. The new checks are implemented in the test suite and reflected in the main application. --- src/main.cpp | 2 +- .../calculation/MeshChecking.cpp | 44 +++- .../calculation/MeshChecking.h | 17 +- .../model/GravityModelData.h | 15 ++ .../PolyhedralGravityPython.cpp | 4 +- test/calculation/MeshCheckingTest.cpp | 246 ++++++++++-------- 6 files changed, 218 insertions(+), 110 deletions(-) diff --git a/src/main.cpp b/src/main.cpp index 42ef01a..7b0fe5c 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -30,7 +30,7 @@ int main(int argc, char *argv[]) { if (!MeshChecking::checkTrianglesNotDegenerated(poly)) { throw std::runtime_error{ "At least on triangle in the mesh is degenerated and its surface area equals zero!"}; - } else if (!MeshChecking::checkNormalsOutwardPointing(poly)) { + } else if (!MeshChecking::checkPlaneUnitNormalOrientation(poly, NormalOrientation::OUTWARDS)) { throw std::runtime_error{ "The plane unit normals are not pointing outwards! Please check the order " "of the vertices in the polyhedral input source!"}; diff --git a/src/polyhedralGravity/calculation/MeshChecking.cpp b/src/polyhedralGravity/calculation/MeshChecking.cpp index 5f93f29..d07a35e 100644 --- a/src/polyhedralGravity/calculation/MeshChecking.cpp +++ b/src/polyhedralGravity/calculation/MeshChecking.cpp @@ -2,18 +2,54 @@ namespace polyhedralGravity::MeshChecking { - bool checkNormalsOutwardPointing(const Polyhedron &polyhedron) { + bool checkPlaneUnitNormalOrientation(const Polyhedron &polyhedron, const NormalOrientation &normalOrientation) { auto it = transformPolyhedron(polyhedron); // All normals have to point outwards (intersect the polyhedron even times) return thrust::transform_reduce( thrust::device, - it.first, it.second, [&polyhedron](const Array3Triplet &face) { + it.first, it.second, [&polyhedron, &normalOrientation](const Array3Triplet &face) { // If the ray intersects the polyhedron an even number of times then the normal points outwards + // If the ray intersects the polyhedron odd number if times the normal points inwards const size_t intersects = detail::countRayPolyhedronIntersections(face, polyhedron); - return intersects % 2 == 0; + return (intersects % 2 == 0) == (normalOrientation == NormalOrientation::OUTWARDS); }, true, thrust::logical_and()); } + std::pair> getPlaneUnitNormalOrientation(const Polyhedron &polyhedron) { + // 1. Step: Find all indices of normals which vioate the constraint outwards pointing + auto indexIterator = thrust::make_counting_iterator(0); + size_t numberOfFaces = polyhedron.countFaces(); + std::set violatingOutwards{}; + thrust::copy_if( + thrust::device, + indexIterator, + indexIterator + numberOfFaces, + std::inserter(violatingOutwards, violatingOutwards.end()), + [&polyhedron](const size_t index) { + // If the ray intersects the polyhedron odd number if times the normal points inwards + // Hence, violating the OUTWARDS constraint + const size_t intersects = detail::countRayPolyhedronIntersections(polyhedron.getFace(index), polyhedron); + return intersects % 2 != 0; + }); + // 2. Step: If we have more than n/2 violations, the majority is inwards pointing --> Build complemntary set! + if (violatingOutwards.size() > numberOfFaces / 2) { + std::set fullSet{}; + std::copy_n(indexIterator, numberOfFaces, std::inserter(fullSet, fullSet.end())); + std::set violatingInwards{}; + std::set_difference( + fullSet.begin(), fullSet.end(), + violatingOutwards.begin(), violatingOutwards.end(), + std::inserter(violatingInwards, violatingInwards.end()) + ); + // 3a. Step: Return the inwards pointing as major orientation and + // the violating faces, i.e. which have outwards pointing normals + return std::make_pair(NormalOrientation::INWWARDS, violatingInwards); + } + // 3b. Step: Return the outwards pointing as major orientation + // and the violating faces, i.e. which have inwards pointing normals + return std::make_pair(NormalOrientation::OUTWARDS, violatingOutwards); + } + bool checkTrianglesNotDegenerated(const Polyhedron &polyhedron) { auto it = transformPolyhedron(polyhedron); // All triangles surface area needs to be greater than zero @@ -25,7 +61,7 @@ namespace polyhedralGravity::MeshChecking { } size_t - detail::countRayPolyhedronIntersections(const Array3Triplet& face, const Polyhedron &polyhedron) { + detail::countRayPolyhedronIntersections(const Array3Triplet &face, const Polyhedron &polyhedron) { using namespace util; // The centroid of the triangular face const Array3 centroid = (face[0] + face[1] + face[2]) / 3.0; diff --git a/src/polyhedralGravity/calculation/MeshChecking.h b/src/polyhedralGravity/calculation/MeshChecking.h index bbc4591..87d5ee3 100644 --- a/src/polyhedralGravity/calculation/MeshChecking.h +++ b/src/polyhedralGravity/calculation/MeshChecking.h @@ -2,8 +2,11 @@ #include #include +#include +#include "thrust/copy.h" #include "thrust/transform_reduce.h" #include "thrust/execution_policy.h" +#include "thrust/iterator/counting_iterator.h" #include "polyhedralGravity/model/Polyhedron.h" #include "polyhedralGravity/model/GravityModelData.h" #include "polyhedralGravity/util/UtilityContainer.h" @@ -15,13 +18,25 @@ namespace polyhedralGravity::MeshChecking { /** * Checks if the vertices are in such a order that the unit normals of each plane point outwards the polyhedron * @param polyhedron the polyhedron consisting of vertices and triangular faces + * @param normalOrientation * @return true if all the unit normals are pointing outwards * * @note This has quadratic complexity @f$O(n^2)@f$! For bigger problem sizes, K-D trees/ Octrees could improve * the complexity to determine the intersections * (see https://stackoverflow.com/questions/45603469/how-to-calculate-the-normals-of-a-box) */ - bool checkNormalsOutwardPointing(const Polyhedron &polyhedron); + bool checkPlaneUnitNormalOrientation(const Polyhedron &polyhedron, const NormalOrientation& normalOrientation = NormalOrientation::OUTWARDS); + + /** + * This method determines the majority vertex ordering of a polyhedron and the set of faces which + * violate the majority constraint and need to be adpated. + * Hence, if the set is empty, all faces obey to the returned ordering/ plane unit normal orientation. + * + * @param polyhedron the polyhedron consisting of vertices and triangular faces + * @return a pair consisting of majority ordering (OUTWARDS or INWARDS pointing normals) + * and a set of face indices which violate the constraint + */ + std::pair> getPlaneUnitNormalOrientation(const Polyhedron &polyhedron); /** * Checks if no triangle is degenerated by checking the surface area being greater than zero. diff --git a/src/polyhedralGravity/model/GravityModelData.h b/src/polyhedralGravity/model/GravityModelData.h index 105d644..c41bfd8 100644 --- a/src/polyhedralGravity/model/GravityModelData.h +++ b/src/polyhedralGravity/model/GravityModelData.h @@ -49,6 +49,21 @@ namespace polyhedralGravity { */ using GravityModelResult = std::tuple; + /** + * The orientation of the plane unit normals of the polyhedron. + * We use this property as the concret definition of the vertices ordering depends on the + * utilized cooridnate system. + * However, the normal alignement is independent. Tsoulis et al. equations require the + * normals to point outwards of the polyhedron. If the opposite hold, the result is + * inverted. + */ + enum class NormalOrientation: char { + /** Outwards pointing plane unit normals*/ + OUTWARDS, + /** Inwards pointing plane unit normals */ + INWWARDS + }; + /** * Contains the 3D distances l1_pq and l2_pq between P and the endpoints of segment pq and * the 1D distances s1_pq and s2_pq between P'' and the segment endpoints. diff --git a/src/polyhedralGravityPython/PolyhedralGravityPython.cpp b/src/polyhedralGravityPython/PolyhedralGravityPython.cpp index c7c6600..8b18459 100644 --- a/src/polyhedralGravityPython/PolyhedralGravityPython.cpp +++ b/src/polyhedralGravityPython/PolyhedralGravityPython.cpp @@ -128,7 +128,7 @@ PYBIND11_MODULE(polyhedral_gravity, m) { utility.def("check_mesh", [](const std::vector &vertices, const std::vector &faces) { Polyhedron poly{vertices, faces}; - return MeshChecking::checkTrianglesNotDegenerated(poly) && MeshChecking::checkNormalsOutwardPointing(poly); + return MeshChecking::checkTrianglesNotDegenerated(poly) && MeshChecking::checkPlaneUnitNormalOrientation(poly); }, R"mydelimiter( Checks if no triangles of the polyhedral mesh are degenerated by checking that their surface area is greater zero. @@ -145,7 +145,7 @@ PYBIND11_MODULE(polyhedral_gravity, m) { utility.def("check_mesh", [](const std::vector &filenames) { TetgenAdapter tetgen{filenames}; Polyhedron poly = tetgen.getPolyhedron(); - return MeshChecking::checkTrianglesNotDegenerated(poly) && MeshChecking::checkNormalsOutwardPointing(poly); + return MeshChecking::checkTrianglesNotDegenerated(poly) && MeshChecking::checkPlaneUnitNormalOrientation(poly); }, R"mydelimiter( Checks if no triangles of the polyhedral mesh are degenerated by checking that their surface area is greater zero. diff --git a/test/calculation/MeshCheckingTest.cpp b/test/calculation/MeshCheckingTest.cpp index daa13dd..04d2149 100644 --- a/test/calculation/MeshCheckingTest.cpp +++ b/test/calculation/MeshCheckingTest.cpp @@ -14,97 +14,91 @@ class MeshCheckingTest : public ::testing::Test { protected: + const std::vector _cubeVertices{ + {-1.0, -1.0, -1.0}, + {1.0, -1.0, -1.0}, + {1.0, 1.0, -1.0}, + {-1.0, 1.0, -1.0}, + {-1.0, -1.0, 1.0}, + {1.0, -1.0, 1.0}, + {1.0, 1.0, 1.0}, + {-1.0, 1.0, 1.0} + }; + + const polyhedralGravity::Polyhedron _cubeOutwardNormals{_cubeVertices, + { + {1, 3, 2}, + {0, 3, 1}, + {0, 1, 5}, + {0, 5, 4}, + {0, 7, 3}, + {0, 4, 7}, + {1, 2, 6}, + {1, 6, 5}, + {2, 3, 6}, + {3, 7, 6}, + {4, 5, 6}, + {4, 6, 7}} + }; - const polyhedralGravity::Polyhedron _correctCube{{ - {-1.0, -1.0, -1.0}, - {1.0, -1.0, -1.0}, - {1.0, 1.0, -1.0}, - {-1.0, 1.0, -1.0}, - {-1.0, -1.0, 1.0}, - {1.0, -1.0, 1.0}, - {1.0, 1.0, 1.0}, - {-1.0, 1.0, 1.0}}, - { - {1, 3, 2}, - {0, 3, 1}, - {0, 1, 5}, - {0, 5, 4}, - {0, 7, 3}, - {0, 4, 7}, - {1, 2, 6}, - {1, 6, 5}, - {2, 3, 6}, - {3, 7, 6}, - {4, 5, 6}, - {4, 6, 7}} + const polyhedralGravity::Polyhedron _cubeInwardNormals{_cubeVertices, + { + {3, 1, 2}, + {3, 0, 1}, + {1, 0, 5}, + {5, 0, 4}, + {7, 0, 3}, + {4, 0, 7}, + {2, 1, 6}, + {6, 1, 5}, + {3, 2, 6}, + {7, 3, 6}, + {5, 4, 6}, + {6, 4, 7}} }; - const polyhedralGravity::Polyhedron _wrongCube{{ - {-1.0, -1.0, -1.0}, - {1.0, -1.0, -1.0}, - {1.0, 1.0, -1.0}, - {-1.0, 1.0, -1.0}, - {-1.0, -1.0, 1.0}, - {1.0, -1.0, 1.0}, - {1.0, 1.0, 1.0}, - {-1.0, 1.0, 1.0}}, - { - {3, 1, 2}, - {3, 0, 1}, - {1, 0, 5}, - {5, 0, 4}, - {7, 0, 3}, - {4, 0, 7}, - {2, 1, 6}, - {6, 1, 5}, - {3, 2, 6}, - {7, 3, 6}, - {5, 4, 6}, - {6, 4, 7}} + const polyhedralGravity::Polyhedron _cubeMajorOutwardNormals{_cubeVertices, + { + {3, 1, 2}, + {0, 3, 1}, + {0, 1, 5}, + {0, 5, 4}, + {7, 0, 3}, + {0, 4, 7}, + {1, 2, 6}, + {1, 6, 5}, + {2, 3, 6}, + {3, 7, 6}, + {4, 5, 6}, + {4, 6, 7}} }; - const polyhedralGravity::Polyhedron _wrongCube2{{ - {-1.0, -1.0, -1.0}, - {1.0, -1.0, -1.0}, - {1.0, 1.0, -1.0}, - {-1.0, 1.0, -1.0}, - {-1.0, -1.0, 1.0}, - {1.0, -1.0, 1.0}, - {1.0, 1.0, 1.0}, - {-1.0, 1.0, 1.0}}, - { - {3, 1, 2}, - {0, 3, 1}, - {0, 1, 5}, - {0, 5, 4}, - {0, 7, 3}, - {0, 4, 7}, - {1, 2, 6}, - {1, 6, 5}, - {2, 3, 6}, - {3, 7, 6}, - {4, 5, 6}, - {4, 6, 7}} + const polyhedralGravity::Polyhedron _cubeMajorInwardNormals{_cubeVertices, + { + {3, 1, 2}, + {3, 0, 1}, + {1, 0, 5}, + {5, 0, 4}, + {7, 0, 3}, + {4, 0, 7}, + {2, 1, 6}, + {6, 1, 5}, + {3, 2, 6}, + {3, 7, 6}, + {4, 5, 6}, + {4, 6, 7}} }; - const polyhedralGravity::Polyhedron _degeneratedCube{{ - {-1.0, -1.0, -1.0}, - {1.0, -1.0, -1.0}, - {1.0, 1.0, -1.0}, - {-1.0, 1.0, -1.0}, - {-1.0, -1.0, 1.0}, - {1.0, -1.0, 1.0}, - {1.0, 1.0, 1.0}, - {-1.0, 1.0, 1.0}}, + const polyhedralGravity::Polyhedron _degeneratedCube{_cubeVertices, { - {1, 3, 2}, - {0, 3, 1}, - {0, 1, 5}, - {0, 5, 4}, - {7, 7, 3}, - {0, 4, 7}, - {1, 2, 6}, - {1, 6, 5}, + {1, 3, 2}, + {0, 3, 1}, + {0, 1, 5}, + {0, 5, 4}, + {7, 7, 3}, + {0, 4, 7}, + {1, 2, 6}, + {1, 6, 5}, {2, 3, 6}, {3, 7, 6}, {4, 5, 6}, @@ -161,28 +155,60 @@ class MeshCheckingTest : public ::testing::Test { }}; }; -TEST_F(MeshCheckingTest, CorrectCube) { +TEST_F(MeshCheckingTest, CubeOutwardNormals) { + using namespace polyhedralGravity; using namespace testing; // All normals are pointing outwards - ASSERT_TRUE(polyhedralGravity::MeshChecking::checkNormalsOutwardPointing(_correctCube)) - << "The vertices of the cube are correctly sorted, however the Sanity Check came to the wrong conclusion!"; - ASSERT_TRUE(polyhedralGravity::MeshChecking::checkTrianglesNotDegenerated(_correctCube)); + ASSERT_TRUE(MeshChecking::checkPlaneUnitNormalOrientation(_cubeOutwardNormals, NormalOrientation::OUTWARDS)); + ASSERT_FALSE(MeshChecking::checkPlaneUnitNormalOrientation(_cubeOutwardNormals, NormalOrientation::INWWARDS)); + + const auto &[actualOrientation, actualViolatingFaces] = MeshChecking::getPlaneUnitNormalOrientation(_cubeOutwardNormals); + ASSERT_EQ(actualOrientation, NormalOrientation::OUTWARDS); + ASSERT_EQ(actualViolatingFaces, std::set{}); + + ASSERT_TRUE(MeshChecking::checkTrianglesNotDegenerated(_cubeOutwardNormals)); } -TEST_F(MeshCheckingTest, WrongCube) { +TEST_F(MeshCheckingTest, CubeInwardNormals) { + using namespace polyhedralGravity; using namespace testing; // All normals are pointing inwards (reversed order) - ASSERT_FALSE(polyhedralGravity::MeshChecking::checkNormalsOutwardPointing(_wrongCube)) - << "The vertices of the cube are incorrectly sorted, however the Sanity Check failed to notice that!"; - ASSERT_TRUE(polyhedralGravity::MeshChecking::checkTrianglesNotDegenerated(_wrongCube)); + ASSERT_FALSE(MeshChecking::checkPlaneUnitNormalOrientation(_cubeInwardNormals, NormalOrientation::OUTWARDS)); + ASSERT_TRUE(MeshChecking::checkPlaneUnitNormalOrientation(_cubeInwardNormals, NormalOrientation::INWWARDS)); + + const auto &[actualOrientation, actualViolatingFaces] = MeshChecking::getPlaneUnitNormalOrientation(_cubeInwardNormals); + ASSERT_EQ(actualOrientation, NormalOrientation::INWWARDS); + ASSERT_EQ(actualViolatingFaces, std::set{}); + + ASSERT_TRUE(MeshChecking::checkTrianglesNotDegenerated(_cubeInwardNormals)); } -TEST_F(MeshCheckingTest, WrongCube2) { +TEST_F(MeshCheckingTest, CubeMajorOutwardNormals) { + using namespace polyhedralGravity; using namespace testing; - // All normals are pointing outwards expect one which points inwards (and has a reversed order) - ASSERT_FALSE(polyhedralGravity::MeshChecking::checkNormalsOutwardPointing(_wrongCube2)) - << "The vertices of the cube are incorrectly sorted, however the Sanity Check failed to notice that!"; - ASSERT_TRUE(polyhedralGravity::MeshChecking::checkTrianglesNotDegenerated(_wrongCube2)); + // All normals are pointing outwards expect two which points inwards (at indices 0 and 4) + ASSERT_FALSE(MeshChecking::checkPlaneUnitNormalOrientation(_cubeMajorOutwardNormals, NormalOrientation::INWWARDS)); + ASSERT_FALSE(MeshChecking::checkPlaneUnitNormalOrientation(_cubeMajorOutwardNormals, NormalOrientation::OUTWARDS)); + + const auto &[actualOrientation, actualViolatingFaces] = MeshChecking::getPlaneUnitNormalOrientation(_cubeMajorOutwardNormals); + ASSERT_EQ(actualOrientation, NormalOrientation::OUTWARDS); + ASSERT_EQ(actualViolatingFaces, std::set({0, 4})); + + ASSERT_TRUE(MeshChecking::checkTrianglesNotDegenerated(_cubeMajorOutwardNormals)); +} + +TEST_F(MeshCheckingTest, CubeMajorInwardNormals) { + using namespace polyhedralGravity; + using namespace testing; + // All normals are pointing outwards expect three which points inwards (at indices 9, 10, 11) + ASSERT_FALSE(MeshChecking::checkPlaneUnitNormalOrientation(_cubeMajorInwardNormals, NormalOrientation::INWWARDS)); + ASSERT_FALSE(MeshChecking::checkPlaneUnitNormalOrientation(_cubeMajorInwardNormals, NormalOrientation::OUTWARDS)); + + const auto &[actualOrientation, actualViolatingFaces] = MeshChecking::getPlaneUnitNormalOrientation(_cubeMajorInwardNormals); + ASSERT_EQ(actualOrientation, NormalOrientation::INWWARDS); + ASSERT_EQ(actualViolatingFaces, std::set({9, 10, 11})); + + ASSERT_TRUE(MeshChecking::checkTrianglesNotDegenerated(_cubeMajorInwardNormals)); } TEST_F(MeshCheckingTest, DegeneratedCube) { @@ -192,19 +218,31 @@ TEST_F(MeshCheckingTest, DegeneratedCube) { } TEST_F(MeshCheckingTest, CorrectPrism) { + using namespace polyhedralGravity; using namespace testing; // All normals are pointing outwards - ASSERT_TRUE(polyhedralGravity::MeshChecking::checkNormalsOutwardPointing(_correctPrism)) + ASSERT_TRUE(polyhedralGravity::MeshChecking::checkPlaneUnitNormalOrientation(_correctPrism)) << "The vertices of the prism are correctly sorted, however the Sanity Check came to the wrong conclusion!"; - ASSERT_TRUE(polyhedralGravity::MeshChecking::checkTrianglesNotDegenerated(_correctPrism)); + + const auto &[actualOrientation, actualViolatingFaces] = MeshChecking::getPlaneUnitNormalOrientation(_correctPrism); + ASSERT_EQ(actualOrientation, NormalOrientation::OUTWARDS); + ASSERT_EQ(actualViolatingFaces, std::set{}); + + ASSERT_TRUE(MeshChecking::checkTrianglesNotDegenerated(_correctPrism)); } TEST_F(MeshCheckingTest, WrongPrism) { + using namespace polyhedralGravity; using namespace testing; // All normals are pointing inwards (reversed order) - ASSERT_FALSE(polyhedralGravity::MeshChecking::checkNormalsOutwardPointing(_wrongPrism)) + ASSERT_FALSE(MeshChecking::checkPlaneUnitNormalOrientation(_wrongPrism)) << "The vertices of the prism are incorrectly sorted, however the Sanity Check failed to notice that!"; - ASSERT_TRUE(polyhedralGravity::MeshChecking::checkTrianglesNotDegenerated(_wrongPrism)); + + const auto &[actualOrientation, actualViolatingFaces] = MeshChecking::getPlaneUnitNormalOrientation(_wrongPrism); + ASSERT_EQ(actualOrientation, NormalOrientation::INWWARDS); + ASSERT_EQ(actualViolatingFaces, std::set{}); + + ASSERT_TRUE(MeshChecking::checkTrianglesNotDegenerated(_wrongPrism)); } TEST_F(MeshCheckingTest, CorrectBigPolyhedron) { @@ -214,8 +252,12 @@ TEST_F(MeshCheckingTest, CorrectBigPolyhedron) { Polyhedron polyhedron{ TetgenAdapter{ {"resources/GravityModelBigTest.node", "resources/GravityModelBigTest.face"}}.getPolyhedron()}; - ASSERT_TRUE(polyhedralGravity::MeshChecking::checkNormalsOutwardPointing(polyhedron)) + ASSERT_TRUE(MeshChecking::checkPlaneUnitNormalOrientation(polyhedron)) << "The vertices of the polyhedron are correctly sorted, however the Sanity Check came to the wrong conclusion!"; - ASSERT_TRUE(polyhedralGravity::MeshChecking::checkTrianglesNotDegenerated(polyhedron)); + ASSERT_TRUE(MeshChecking::checkTrianglesNotDegenerated(polyhedron)); + + const auto &[actualOrientation, actualViolatingFaces] = MeshChecking::getPlaneUnitNormalOrientation(polyhedron); + ASSERT_EQ(actualOrientation, NormalOrientation::OUTWARDS); + ASSERT_EQ(actualViolatingFaces, std::set{}); } From af9ae9f454422d5785c3a8ab157a1b0067fa8da6 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Mon, 15 Apr 2024 20:00:56 +0200 Subject: [PATCH 05/54] update GitHub actions --- .github/workflows/build-and-test.yml | 49 ++++++++++++---------------- 1 file changed, 21 insertions(+), 28 deletions(-) diff --git a/.github/workflows/build-and-test.yml b/.github/workflows/build-and-test.yml index 548883e..cd1800a 100644 --- a/.github/workflows/build-and-test.yml +++ b/.github/workflows/build-and-test.yml @@ -10,28 +10,40 @@ on: # A workflow run is made up of one or more jobs that can run sequentially or in parallel jobs: - # Build & Test on Linux - build-and-test-linux: - runs-on: ubuntu-latest + + build-and-test-cpp: + name: Build & Test on ${{ matrix.os }} + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [windows-latest, ubuntu-latest, macos-latest] steps: - uses: actions/checkout@v3 + - uses: ilammy/msvc-dev-cmd@v1 + if: matrix.os == 'windows-latest' - name: Build run: | mkdir build cd build cmake -DCMAKE_BUILD_TYPE=Release .. - cmake --build . + cmake --build . --config Release - name: Test run: cd build/test && ./polyhedralGravity_test + if: matrix.os == 'ubuntu-latest' # Install the python interface by building from source and run pytest - pytest-linux: - runs-on: ubuntu-latest + build-and-test-python: + name: Build & Test on ${{ matrix.os }} + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [windows-latest, ubuntu-latest, macos-latest] steps: - uses: actions/checkout@v3 - - name: Install Ninja Build - run: | - sudo apt-get install ninja-build -y + - uses: ilammy/msvc-dev-cmd@v1 + if: matrix.os == 'windows-latest' - name: Install Conda environment from environment.yml uses: mamba-org/provision-with-micromamba@main with: @@ -44,22 +56,3 @@ jobs: pip install . -vv --no-build-isolation pytest -n 3 - - # Builds the polyhedral gravity python interface the interface - # No testing on Windows since it takes too long - # Enables the long paths feature on Windows (newer thrust versions require this) - build-windows: - runs-on: windows-latest - steps: - - uses: actions/checkout@v3 - - uses: ilammy/msvc-dev-cmd@v1 - - name: Build - run: | - New-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\FileSystem" -Name "LongPathsEnabled" -Value 1 -PropertyType DWORD -Force - git config --system core.longpaths true - mkdir build - cd build - cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_POLYHEDRAL_PYTHON_INTERFACE=ON .. - cmake --build . --config Release - - From 7547dd3a43b4ae4fd417b745b073ebc1f3ab83f6 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Mon, 15 Apr 2024 20:06:50 +0200 Subject: [PATCH 06/54] improve syntax of GitHub action --- .github/workflows/build-and-test.yml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.github/workflows/build-and-test.yml b/.github/workflows/build-and-test.yml index cd1800a..500dbc5 100644 --- a/.github/workflows/build-and-test.yml +++ b/.github/workflows/build-and-test.yml @@ -11,8 +11,9 @@ on: # A workflow run is made up of one or more jobs that can run sequentially or in parallel jobs: + # Build the C++ library & test that it is working using GoogleTest build-and-test-cpp: - name: Build & Test on ${{ matrix.os }} + name: C/C++ Library on ${{ matrix.os }} runs-on: ${{ matrix.os }} strategy: fail-fast: false @@ -30,11 +31,10 @@ jobs: cmake --build . --config Release - name: Test run: cd build/test && ./polyhedralGravity_test - if: matrix.os == 'ubuntu-latest' - # Install the python interface by building from source and run pytest + # Install the python interface & test that it is working using pytest build-and-test-python: - name: Build & Test on ${{ matrix.os }} + name: Python Interface on ${{ matrix.os }} runs-on: ${{ matrix.os }} strategy: fail-fast: false From 0dd39d1dcca487569efc9d8907712481694cccf4 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Mon, 15 Apr 2024 20:34:16 +0200 Subject: [PATCH 07/54] fix windows test workflow --- .github/workflows/build-and-test.yml | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/.github/workflows/build-and-test.yml b/.github/workflows/build-and-test.yml index 500dbc5..59f0e61 100644 --- a/.github/workflows/build-and-test.yml +++ b/.github/workflows/build-and-test.yml @@ -29,8 +29,12 @@ jobs: cd build cmake -DCMAKE_BUILD_TYPE=Release .. cmake --build . --config Release - - name: Test + - name: Test (Linux & macOS) run: cd build/test && ./polyhedralGravity_test + if: matrix.os != 'windows-latest' + - name: Test (Windows) + run: cd build/test && .\polyhedralGravity_test.exe + if: matrix.os == 'windows-latest' # Install the python interface & test that it is working using pytest build-and-test-python: From 26c1decfa24a0b8a9a8f39088a44f3126c6198c0 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Mon, 15 Apr 2024 22:15:40 +0200 Subject: [PATCH 08/54] add new check parameter to the C++ implementation --- src/main.cpp | 17 +--- .../calculation/GravityEvaluable.cpp | 31 ++++++- .../calculation/GravityEvaluable.h | 89 +++++++++++++------ .../calculation/GravityModel.cpp | 18 ++-- .../calculation/GravityModel.h | 10 ++- .../model/GravityModelData.h | 24 +++++ src/polyhedralGravity/model/Polyhedron.h | 9 +- src/polyhedralGravity/util/UtilityContainer.h | 39 ++++++-- .../PolyhedralGravityPython.cpp | 18 ++-- 9 files changed, 182 insertions(+), 73 deletions(-) diff --git a/src/main.cpp b/src/main.cpp index 7b0fe5c..0baa213 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -24,24 +24,9 @@ int main(int argc, char *argv[]) { auto outputFileName = config->getOutputFileName(); bool checkPolyhedralInput = config->getMeshInputCheckStatus(); - // Checking that the vertices are correctly set-up in the input if activated - if (checkPolyhedralInput) { - SPDLOG_LOGGER_INFO(PolyhedralGravityLogger::DEFAULT_LOGGER.getLogger(), "Checking mesh..."); - if (!MeshChecking::checkTrianglesNotDegenerated(poly)) { - throw std::runtime_error{ - "At least on triangle in the mesh is degenerated and its surface area equals zero!"}; - } else if (!MeshChecking::checkPlaneUnitNormalOrientation(poly, NormalOrientation::OUTWARDS)) { - throw std::runtime_error{ - "The plane unit normals are not pointing outwards! Please check the order " - "of the vertices in the polyhedral input source!"}; - } else { - SPDLOG_LOGGER_INFO(PolyhedralGravityLogger::DEFAULT_LOGGER.getLogger(), "The mesh is fine."); - } - } - SPDLOG_LOGGER_INFO(PolyhedralGravityLogger::DEFAULT_LOGGER.getLogger(), "The calculation started..."); auto start = std::chrono::high_resolution_clock::now(); - auto result = GravityModel::evaluate(poly, density, computationPoints); + auto result = GravityModel::evaluate(poly, density, computationPoints, true, NormalOrientation::OUTWARDS, checkPolyhedralInput); auto end = std::chrono::high_resolution_clock::now(); auto duration = end - start; auto ms = std::chrono::duration_cast(duration); diff --git a/src/polyhedralGravity/calculation/GravityEvaluable.cpp b/src/polyhedralGravity/calculation/GravityEvaluable.cpp index 5b4e769..947d70b 100644 --- a/src/polyhedralGravity/calculation/GravityEvaluable.cpp +++ b/src/polyhedralGravity/calculation/GravityEvaluable.cpp @@ -3,6 +3,32 @@ namespace polyhedralGravity { + void GravityEvaluable::runMeshCeck(const std::optional &flag) const { + if (flag.has_value() && !flag.value()) { + // Explcitly disabled check + return; + } + if (!flag.has_value()) { + // Implcitly enabled check, print a warning about the runtime cost + SPDLOG_LOGGER_WARN(PolyhedralGravityLogger::DEFAULT_LOGGER.getLogger(), + "The mesh check is enabled and analyzes the polyhedron for degnerated faces & " + "that all plane unit normals point in the specified direction. This checks requires " + "a quadratic runtime cost which is most of the time not desirable. " + "Please explcity enable or disable this by setting 'check' to true orfalse"); + } + // Implictly or explcity enabled checking + if (!MeshChecking::checkTrianglesNotDegenerated(_polyhedron)) { + throw std::runtime_error{"At least on triangle in the mesh is degenerated and its surface area equals zero!"}; + } + if (!MeshChecking::checkPlaneUnitNormalOrientation(_polyhedron, _orientation)) { + std::stringstream sstream{}; + sstream << "The plane unit normals are not pointing in the specified direction '" << _orientation << "'! Please check the order " + "of the vertices in the polyhedral input source! You can use utility.plane_normal_orientation(..) " + "in Python or MeshChecking::getPlaneUnitNormalOrientation in C++ for a detailed explaination!"; + throw std::runtime_error{sstream.str()}; + } + } + void GravityEvaluable::prepare() const { using namespace GravityModel::detail; // Initialize the vectors and allocate the required memory @@ -94,6 +120,7 @@ namespace polyhedralGravity { } // Explicit template instantiation of the multipoint evaluate method + template std::vector GravityEvaluable::evaluate(const std::vector &computationPoints) const; @@ -238,9 +265,9 @@ namespace polyhedralGravity { return ss.str(); } - std::tuple, std::vector, std::vector> + std::tuple, std::vector, std::vector> GravityEvaluable::getState() const { - return std::make_tuple(_polyhedron, _density, _segmentVectors, _planeUnitNormals, _segmentUnitNormals); + return std::make_tuple(_polyhedron, _density, _orientation, _segmentVectors, _planeUnitNormals, _segmentUnitNormals); } } diff --git a/src/polyhedralGravity/calculation/GravityEvaluable.h b/src/polyhedralGravity/calculation/GravityEvaluable.h index 38335e5..fe35566 100644 --- a/src/polyhedralGravity/calculation/GravityEvaluable.h +++ b/src/polyhedralGravity/calculation/GravityEvaluable.h @@ -3,12 +3,15 @@ #include #include #include +#include #include #include "thrust/transform.h" #include "thrust/execution_policy.h" #include "polyhedralGravity/calculation/GravityModelDetail.h" +#include "polyhedralGravity/calculation/MeshChecking.h" +#include "polyhedralGravity/util/UtilityContainer.h" #include "polyhedralGravity/input/TetgenAdapter.h" #include "polyhedralGravity/model/GravityModelData.h" #include "polyhedralGravity/model/Polyhedron.h" @@ -30,6 +33,9 @@ namespace polyhedralGravity { /** The constant density of the polyhedron (the unit must match to the mesh, e.g., mesh in @f$[m]@f$ requires density in @f$[kg/m^3]@f$) */ const double _density; + /** The orientation of the normals of the polyhedron, either outwards or inwards pointing the polyhedral source */ + const NormalOrientation _orientation; + /** Cache for the segment vectors (segments between vertices of a polyhedral face) */ mutable std::vector _segmentVectors; @@ -39,33 +45,44 @@ namespace polyhedralGravity { /** Cache for the segment unit normals (unit normals of each the polyhedral faces' segments) */ mutable std::vector _segmentUnitNormals; - public: - /** * Instantiates a GravityEvaluable with a given constant density polyhedron. - * @param polyhedron the polyhedron + * @param polyhedralSource the polyhedron as polyhedron, vertices and faces, or a list of files * @param density the constant density (the unit must match to the mesh, * e.g., mesh in @f$[m]@f$ requires density in @f$[kg/m^3]@f$) + * @param orientation the orientation of the plane unit normals of the polyhedron (either pointing outwards or inwards the polyhedron) + * (default: OUTWARDS as this is the original assumption of Tsoulis et al.'s formulation) + * @param check if true, the polyhedral mesh will be checked for degenerated triangular surfaces and + * that the orientation of the normals are outwards pointing/ pointing to as specified by the parameter orientation + * The latter check requires @f$O(n^2)$@f operations! + * By default the check is enabled and will inform the user about inconstencies and the quadratic runtime. + * Explcitly enableing silence the @f$O(n^2)$@f warning, but produces an exception in case of inconstency + * Explcity disableing silences everythign and avoids the @f$O(n^2)$@f runtime cost. * * @note This is a separate constructor since the polyhedron as a class it not exposed to the user via * the Python Interface. Thus, this constructor is only available via the C++ interface. + * + * @warning The input check requires @f$O(n^2)$@f operations and is enabled by default. Disable it when "you know your mesh"! + * + * @throws If inputCheck is true (or not set) and the orientation does not match with the polyhedral match a argument exception */ - GravityEvaluable(const Polyhedron &polyhedron, double density) : _polyhedron{polyhedron}, _density{density} { - this->prepare(); - } - - /** - * Instantiates a GravityEvaluable with a given constant density polyhedron. - * @param polyhedralSource the vertices & faces of the polyhedron as tuple or the filenames of the files - * @param density the constant density (the unit must match to the mesh, - * e.g., mesh in @f$[m]@f$ requires density in @f$[kg/m^3]@f$) - */ - GravityEvaluable(const PolyhedralSource &polyhedralSource, double density) : _polyhedron{ - std::holds_alternative, std::vector>>(polyhedralSource) - ? Polyhedron{std::get, std::vector>>(polyhedralSource)} - : TetgenAdapter(std::get>(polyhedralSource)).getPolyhedron()}, - _density{density} { + GravityEvaluable( + const PolyhedralSource &polyhedralSource, + double density, + const NormalOrientation &orientation = NormalOrientation::OUTWARDS, + const std::optional check = std::nullopt + ) : + _polyhedron{ + std::visit(util::overloaded{ + [](const Polyhedron &arg) { return arg; }, + [](const PolyhedralFileSource &arg) { return TetgenAdapter{arg}.getPolyhedron(); }, + [](const PolyhedralDataSource &arg) { return Polyhedron{arg}; } + }, polyhedralSource) + }, + _density{density}, + _orientation{orientation} { + this->runMeshCeck(check); this->prepare(); } @@ -75,18 +92,26 @@ namespace polyhedralGravity { * @param polyhedron the polyhedron * @param density the constant density (the unit must match to the mesh, * e.g., mesh in @f$[m]@f$ requires density in @f$[kg/m^3]@f$) + * @param orientation the orientation of the plane unit normals of the polyhedron (either pointing outwards or inwards the polyhedron) + * (default: OUTWARDS as this is the original assumption of Tsoulis et al.'s formulation) * @param segmentVectors the segment vectors * @param planeUnitNormals the plane unit normals * @param segmentUnitNormals the segment unit normals */ - GravityEvaluable(const Polyhedron &polyhedron, double density, const std::vector &segmentVectors, + GravityEvaluable(const Polyhedron &polyhedron, + double density, + const NormalOrientation &orientation, + const std::vector &segmentVectors, const std::vector &planeUnitNormals, - const std::vector &segmentUnitNormals) : _polyhedron{polyhedron}, - _density{density}, - _segmentVectors{segmentVectors}, - _planeUnitNormals{planeUnitNormals}, - _segmentUnitNormals{ - segmentUnitNormals} {} + const std::vector &segmentUnitNormals) : + _polyhedron{polyhedron}, + _density{density}, + _orientation{orientation}, + _segmentVectors{segmentVectors}, + _planeUnitNormals{planeUnitNormals}, + _segmentUnitNormals{ + segmentUnitNormals} { + } /** * Evaluates the polyhedrale gravity model for a given constant density polyhedron at computation @@ -124,10 +149,20 @@ namespace polyhedralGravity { * * @return tuple of polyhedron, density, segmentVectors, planeUnitNormals and segmentUnitNormals */ - std::tuple, std::vector, std::vector> + std::tuple, std::vector, std::vector> getState() const; private: + /** + * Runs the Mesh Sanity Check depending on the flag. + * If nullopt, the check is run and the user is informed about a potential unwanted @f$O(n^2)$@f runtime cost + * If true, the check is run, but no runtime cost warning is printed + * if false, the check is disabled and nothing at all is done + * @param flag to determine if what is done + * + * @throws std::runtime_error in case of wrong mesh properties + */ + void runMeshCeck(const std::optional &flag) const; /** * Prepares the polyhedron for the evaluation by calculating the segment vectors, the plane unit normals @@ -169,4 +204,4 @@ namespace polyhedralGravity { }; -} // namespace polyhedralGravity \ No newline at end of file +}// namespace polyhedralGravity \ No newline at end of file diff --git a/src/polyhedralGravity/calculation/GravityModel.cpp b/src/polyhedralGravity/calculation/GravityModel.cpp index e95735e..aab5203 100644 --- a/src/polyhedralGravity/calculation/GravityModel.cpp +++ b/src/polyhedralGravity/calculation/GravityModel.cpp @@ -3,20 +3,22 @@ namespace polyhedralGravity::GravityModel { GravityModelResult evaluate( - const PolyhedronOrSource &polyhedron, - double density, const Array3 &computationPoint, bool parallel) { + const PolyhedralSource &polyhedron, + double density, const Array3 &computationPoint, bool parallel, const NormalOrientation &orientation, + const std::optional check) { return std::get( - std::visit([¶llel, &density, &computationPoint](const auto &polyhedron) { - GravityEvaluable evaluable{polyhedron, density}; + std::visit([&](const auto &polyhedron) { + GravityEvaluable evaluable{polyhedron, density, orientation, check}; return evaluable(computationPoint, parallel); }, polyhedron)); } std::vector - evaluate(const PolyhedronOrSource &polyhedron, double density, const std::vector &computationPoints, - bool parallel) { - return std::get>(std::visit([¶llel, &density, &computationPoints](const auto &polyhedron) { - GravityEvaluable evaluable{polyhedron, density}; + evaluate(const PolyhedralSource &polyhedron, double density, const std::vector &computationPoints, + bool parallel, const NormalOrientation &orientation, + const std::optional check) { + return std::get>(std::visit([&](const auto &polyhedron) { + GravityEvaluable evaluable{polyhedron, density, orientation, check}; return evaluable(computationPoints, parallel); }, polyhedron)); } diff --git a/src/polyhedralGravity/calculation/GravityModel.h b/src/polyhedralGravity/calculation/GravityModel.h index 5936380..a3300a3 100644 --- a/src/polyhedralGravity/calculation/GravityModel.h +++ b/src/polyhedralGravity/calculation/GravityModel.h @@ -29,7 +29,9 @@ namespace polyhedralGravity::GravityModel { * @return the GravityModelResult containing the potential, the acceleration and the change of acceleration * at computation Point P */ - GravityModelResult evaluate(const PolyhedronOrSource &polyhedron, double density, const Array3 &computationPoint, bool parallel = true); + GravityModelResult evaluate(const PolyhedralSource &polyhedron, double density, const Array3 &computationPoint, + bool parallel = true, const NormalOrientation &orientation = NormalOrientation::OUTWARDS, + const std::optional check = std::nullopt); /** * Evaluates the polyhedral gravity model for a given constant density polyhedron at multiple computation @@ -43,6 +45,8 @@ namespace polyhedralGravity::GravityModel { * foreach computation Point P */ std::vector - evaluate(const PolyhedronOrSource &polyhedron, double density, const std::vector &computationPoints, bool parallel = true); + evaluate(const PolyhedralSource &polyhedron, double density, const std::vector &computationPoints, + bool parallel = true, const NormalOrientation &orientation = NormalOrientation::OUTWARDS, + const std::optional check = std::nullopt); -} +} \ No newline at end of file diff --git a/src/polyhedralGravity/model/GravityModelData.h b/src/polyhedralGravity/model/GravityModelData.h index c41bfd8..1f80812 100644 --- a/src/polyhedralGravity/model/GravityModelData.h +++ b/src/polyhedralGravity/model/GravityModelData.h @@ -64,6 +64,30 @@ namespace polyhedralGravity { INWWARDS }; + + /** + * Overloaded insertion operator to output the string representation of a NormalOrientation enum value. + * + * @param os The output stream to write the string representation to. + * @param orientation The NormalOrientation enum value to output. + * @return The output stream after writing the string representation. + */ + inline std::ostream& operator<<(std::ostream& os, const NormalOrientation& orientation) { + switch (orientation) { + case NormalOrientation::OUTWARDS: + os << "OUTWARDS"; + break; + case NormalOrientation::INWWARDS: + os << "INWARDS"; + break; + default: + os << "Unknown"; + break; + } + return os; + } + + /** * Contains the 3D distances l1_pq and l2_pq between P and the endpoints of segment pq and * the 1D distances s1_pq and s2_pq between P'' and the segment endpoints. diff --git a/src/polyhedralGravity/model/Polyhedron.h b/src/polyhedralGravity/model/Polyhedron.h index e9d21cf..f5b4f26 100644 --- a/src/polyhedralGravity/model/Polyhedron.h +++ b/src/polyhedralGravity/model/Polyhedron.h @@ -20,13 +20,16 @@ namespace polyhedralGravity { * Variant of possible polyhedron sources (composed of members, read from file), but not the polyhedron itself * @example Utilized in the Python interface which does not expose the Polyhedron class */ - using PolyhedralSource = std::variant, std::vector>, std::vector>; + using PolyhedralFileSource = std::vector; + + + using PolyhedralDataSource = std::tuple, std::vector>; /** * Variant of possible polyhedral sources (direct, composed of members, read from file), including the polyhedron * @example Utilized in the C++ implementation of the polyhedral-gravity model */ - using PolyhedronOrSource = std::variant, std::vector>, std::vector>; + using PolyhedralSource = std::variant; /** * Data structure containing the model data of one polyhedron. This includes nodes, edges (faces) and elements. @@ -87,7 +90,7 @@ namespace polyhedralGravity { * @note ASSERTS PRE-CONDITION that the in the indexing in the faces vector starts with zero! * @throws runtime_error if no face contains the node zero indicating mathematical index */ - explicit Polyhedron(std::tuple, std::vector> data) + explicit Polyhedron(const PolyhedralDataSource &data) : Polyhedron(std::get>(data), std::get>(data)) {} diff --git a/src/polyhedralGravity/util/UtilityContainer.h b/src/polyhedralGravity/util/UtilityContainer.h index 9468dd9..e6a98ed 100644 --- a/src/polyhedralGravity/util/UtilityContainer.h +++ b/src/polyhedralGravity/util/UtilityContainer.h @@ -15,7 +15,8 @@ namespace polyhedralGravity::util { * Alias for two-dimensional array with size M and N. * M is the major size. */ - template using Matrix = std::array, M>; + template + using Matrix = std::array, M>; /** * Applies a binary function to elements of two containers piece by piece. The objects must @@ -131,10 +132,10 @@ namespace polyhedralGravity::util { * @return a Container * TODO This method causes issues with the MVSC 19.31.31107.0? Although it is never used... */ -// template -// Container operator-(const Container &lhs, const Scalar &scalar) { -// return applyBinaryFunction(lhs, scalar, std::minus<>()); -// } + // template + // Container operator-(const Container &lhs, const Scalar &scalar) { + // return applyBinaryFunction(lhs, scalar, std::minus<>()); + // } /** * Applies the Operation to a Container and a Scalar. @@ -327,6 +328,34 @@ namespace polyhedralGravity::util { return std::abs(x - y) > maxExponentDifference; } + /** + * A utility struct that creates an overload set out of all the function objects it inherits from. + * It allows a lambda function to be used with std::visit in a variant. + * The lambda function needs to be able to handle all types contained in the variant, + * and this struct allows it to do so by inheriting the function-call operator from each type. + * @tparam Ts A template parameter pack representing all types for which the struct should be able to handle. + * + * @ref https://en.cppreference.com/w/cpp/utility/variant/visit + */ + template + struct overloaded : Ts... { + using Ts::operator()...; + }; + + /** + * This function template provides deduction guides for the overloaded struct. + * It deduces the template arguments for overloaded based on its constructor arguments + * thus saving you from explicitly mentioning them while instantiation. + * @tparam Ts A template parameter pack representing all types that will be passed to the overloaded struct. + * @param Ts Variable numbers of parameters to pass to the overloaded struct. + * @return This doesn't return a value, but rather assists in the creation of an overloaded object. + * The type of the object will be overloaded. + * + * @ref https://en.cppreference.com/w/cpp/utility/variant/visit + */ + template + overloaded(Ts...) -> overloaded; + namespace detail { /** diff --git a/src/polyhedralGravityPython/PolyhedralGravityPython.cpp b/src/polyhedralGravityPython/PolyhedralGravityPython.cpp index 8b18459..c2144bc 100644 --- a/src/polyhedralGravityPython/PolyhedralGravityPython.cpp +++ b/src/polyhedralGravityPython/PolyhedralGravityPython.cpp @@ -19,7 +19,7 @@ namespace py = pybind11; PYBIND11_MODULE(polyhedral_gravity, m) { using namespace polyhedralGravity; m.doc() = "Computes the full gravity tensor for a given constant density polyhedron which consists of some " - "vertices and triangular faces at a given computation points"; + "vertices and triangular faces at a given computation points"; m.def("evaluate", [](const PolyhedralSource &polyhedralSource, double density, const std::variant> &computationPoints, @@ -86,26 +86,26 @@ PYBIND11_MODULE(polyhedral_gravity, m) { )mydelimiter", py::arg("computation_points"), py::arg("parallel") = true) .def(py::pickle( [](const GravityEvaluable &evaluable) { - const auto&[polyhedron, density, segmentVectors, planeUnitNormals, segmentUnitNormals] = + const auto &[polyhedron, density, orientation, segmentVectors, planeUnitNormals, segmentUnitNormals] = evaluable.getState(); - return py::make_tuple(polyhedron.getVertices(), polyhedron.getFaces(), density, segmentVectors, + return py::make_tuple(polyhedron.getVertices(), polyhedron.getFaces(), density, orientation, segmentVectors, planeUnitNormals, segmentUnitNormals); }, [](const py::tuple &tuple) { - constexpr size_t tupleSize = 6; + constexpr size_t tupleSize = 7; if (tuple.size() != tupleSize) { throw std::runtime_error("Invalid state!"); } - Polyhedron polyhedron { - tuple[0].cast>(), tuple[1].cast>() + Polyhedron polyhedron{ + tuple[0].cast>(), tuple[1].cast>() }; GravityEvaluable evaluable{ - polyhedron, tuple[2].cast(), tuple[3].cast>(), - tuple[4].cast>(), tuple[5].cast>() + polyhedron, tuple[2].cast(), tuple[3].cast(), tuple[4].cast>(), + tuple[5].cast>(), tuple[6].cast>() }; return evaluable; } - )); + )); py::module_ utility = m.def_submodule("utility", "This submodule contains useful utility functions like parsing meshes " From f424980f48f944fce3995597199dd12cedb39768 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Mon, 15 Apr 2024 22:15:49 +0200 Subject: [PATCH 09/54] fix Windows Test CI --- .github/workflows/build-and-test.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/build-and-test.yml b/.github/workflows/build-and-test.yml index 59f0e61..3fd7721 100644 --- a/.github/workflows/build-and-test.yml +++ b/.github/workflows/build-and-test.yml @@ -33,7 +33,7 @@ jobs: run: cd build/test && ./polyhedralGravity_test if: matrix.os != 'windows-latest' - name: Test (Windows) - run: cd build/test && .\polyhedralGravity_test.exe + run: cd build/test/Release && .\polyhedralGravity_test.exe if: matrix.os == 'windows-latest' # Install the python interface & test that it is working using pytest From 54300a4925911c9e19d264c1b9d003c0ba18156f Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Mon, 15 Apr 2024 22:22:26 +0200 Subject: [PATCH 10/54] disable windows test --- .github/workflows/build-and-test.yml | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/.github/workflows/build-and-test.yml b/.github/workflows/build-and-test.yml index 3fd7721..2317027 100644 --- a/.github/workflows/build-and-test.yml +++ b/.github/workflows/build-and-test.yml @@ -32,9 +32,10 @@ jobs: - name: Test (Linux & macOS) run: cd build/test && ./polyhedralGravity_test if: matrix.os != 'windows-latest' - - name: Test (Windows) - run: cd build/test/Release && .\polyhedralGravity_test.exe - if: matrix.os == 'windows-latest' +# Problems with resources (test file) location leads to test failure +# - name: Test (Windows) +# run: cd build/test/Release && .\polyhedralGravity_test.exe +# if: matrix.os == 'windows-latest' # Install the python interface & test that it is working using pytest build-and-test-python: From c3fb33230ddf848ab4bc705d4037313b7de11627 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Tue, 16 Apr 2024 01:58:55 +0200 Subject: [PATCH 11/54] dissolve model & calculation distinction - merge the components --- src/main.cpp | 4 ++-- .../{calculation => model}/GravityEvaluable.cpp | 0 .../{calculation => model}/GravityEvaluable.h | 8 ++++---- .../{calculation => model}/GravityModel.cpp | 0 .../{calculation => model}/GravityModel.h | 2 +- .../{calculation => model}/GravityModelDetail.cpp | 0 .../{calculation => model}/GravityModelDetail.h | 6 +++--- .../{calculation => model}/MeshChecking.cpp | 0 .../{calculation => model}/MeshChecking.h | 6 +++--- .../{calculation => model}/PolyhedronTransform.h | 0 src/polyhedralGravityPython/PolyhedralGravityPython.cpp | 6 +++--- test/{calculation => model}/GravityModelBigTest.cpp | 2 +- test/{calculation => model}/GravityModelCubeTest.cpp | 2 +- test/{calculation => model}/GravityModelTest.cpp | 2 +- test/{calculation => model}/GravityModelVectorUtility.cpp | 0 test/{calculation => model}/GravityModelVectorUtility.h | 2 +- test/{calculation => model}/MeshCheckingTest.cpp | 2 +- 17 files changed, 21 insertions(+), 21 deletions(-) rename src/polyhedralGravity/{calculation => model}/GravityEvaluable.cpp (100%) rename src/polyhedralGravity/{calculation => model}/GravityEvaluable.h (97%) rename src/polyhedralGravity/{calculation => model}/GravityModel.cpp (100%) rename src/polyhedralGravity/{calculation => model}/GravityModel.h (97%) rename src/polyhedralGravity/{calculation => model}/GravityModelDetail.cpp (100%) rename src/polyhedralGravity/{calculation => model}/GravityModelDetail.h (98%) rename src/polyhedralGravity/{calculation => model}/MeshChecking.cpp (100%) rename src/polyhedralGravity/{calculation => model}/MeshChecking.h (95%) rename src/polyhedralGravity/{calculation => model}/PolyhedronTransform.h (100%) rename test/{calculation => model}/GravityModelBigTest.cpp (99%) rename test/{calculation => model}/GravityModelCubeTest.cpp (98%) rename test/{calculation => model}/GravityModelTest.cpp (99%) rename test/{calculation => model}/GravityModelVectorUtility.cpp (100%) rename test/{calculation => model}/GravityModelVectorUtility.h (99%) rename test/{calculation => model}/MeshCheckingTest.cpp (99%) diff --git a/src/main.cpp b/src/main.cpp index 0baa213..c71543a 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -1,8 +1,8 @@ #include #include "polyhedralGravity/input/ConfigSource.h" #include "polyhedralGravity/input/YAMLConfigReader.h" -#include "polyhedralGravity/calculation/GravityModel.h" -#include "polyhedralGravity/calculation/MeshChecking.h" +#include "polyhedralGravity/model/GravityModel.h" +#include "polyhedralGravity/model/MeshChecking.h" #include "polyhedralGravity/output/Logging.h" #include "polyhedralGravity/output/CSVWriter.h" diff --git a/src/polyhedralGravity/calculation/GravityEvaluable.cpp b/src/polyhedralGravity/model/GravityEvaluable.cpp similarity index 100% rename from src/polyhedralGravity/calculation/GravityEvaluable.cpp rename to src/polyhedralGravity/model/GravityEvaluable.cpp diff --git a/src/polyhedralGravity/calculation/GravityEvaluable.h b/src/polyhedralGravity/model/GravityEvaluable.h similarity index 97% rename from src/polyhedralGravity/calculation/GravityEvaluable.h rename to src/polyhedralGravity/model/GravityEvaluable.h index fe35566..25917f8 100644 --- a/src/polyhedralGravity/calculation/GravityEvaluable.h +++ b/src/polyhedralGravity/model/GravityEvaluable.h @@ -9,12 +9,12 @@ #include "thrust/transform.h" #include "thrust/execution_policy.h" -#include "polyhedralGravity/calculation/GravityModelDetail.h" -#include "polyhedralGravity/calculation/MeshChecking.h" +#include "GravityModelDetail.h" +#include "MeshChecking.h" #include "polyhedralGravity/util/UtilityContainer.h" #include "polyhedralGravity/input/TetgenAdapter.h" -#include "polyhedralGravity/model/GravityModelData.h" -#include "polyhedralGravity/model/Polyhedron.h" +#include "GravityModelData.h" +#include "Polyhedron.h" namespace polyhedralGravity { diff --git a/src/polyhedralGravity/calculation/GravityModel.cpp b/src/polyhedralGravity/model/GravityModel.cpp similarity index 100% rename from src/polyhedralGravity/calculation/GravityModel.cpp rename to src/polyhedralGravity/model/GravityModel.cpp diff --git a/src/polyhedralGravity/calculation/GravityModel.h b/src/polyhedralGravity/model/GravityModel.h similarity index 97% rename from src/polyhedralGravity/calculation/GravityModel.h rename to src/polyhedralGravity/model/GravityModel.h index a3300a3..d41a58f 100644 --- a/src/polyhedralGravity/calculation/GravityModel.h +++ b/src/polyhedralGravity/model/GravityModel.h @@ -6,7 +6,7 @@ #include #include -#include "polyhedralGravity/calculation/GravityEvaluable.h" +#include "polyhedralGravity/model/GravityEvaluable.h" #include "polyhedralGravity/model/GravityModelData.h" #include "polyhedralGravity/model/Polyhedron.h" diff --git a/src/polyhedralGravity/calculation/GravityModelDetail.cpp b/src/polyhedralGravity/model/GravityModelDetail.cpp similarity index 100% rename from src/polyhedralGravity/calculation/GravityModelDetail.cpp rename to src/polyhedralGravity/model/GravityModelDetail.cpp diff --git a/src/polyhedralGravity/calculation/GravityModelDetail.h b/src/polyhedralGravity/model/GravityModelDetail.h similarity index 98% rename from src/polyhedralGravity/calculation/GravityModelDetail.h rename to src/polyhedralGravity/model/GravityModelDetail.h index b7dc354..e49acdd 100644 --- a/src/polyhedralGravity/calculation/GravityModelDetail.h +++ b/src/polyhedralGravity/model/GravityModelDetail.h @@ -15,10 +15,10 @@ #include "thrust/execution_policy.h" #include "xsimd/xsimd.hpp" -#include "polyhedralGravity/calculation/PolyhedronTransform.h" +#include "PolyhedronTransform.h" +#include "Polyhedron.h" +#include "GravityModelData.h" #include "polyhedralGravity/input/TetgenAdapter.h" -#include "polyhedralGravity/model/Polyhedron.h" -#include "polyhedralGravity/model/GravityModelData.h" #include "polyhedralGravity/util/UtilityConstants.h" #include "polyhedralGravity/util/UtilityContainer.h" #include "polyhedralGravity/util/UtilityThrust.h" diff --git a/src/polyhedralGravity/calculation/MeshChecking.cpp b/src/polyhedralGravity/model/MeshChecking.cpp similarity index 100% rename from src/polyhedralGravity/calculation/MeshChecking.cpp rename to src/polyhedralGravity/model/MeshChecking.cpp diff --git a/src/polyhedralGravity/calculation/MeshChecking.h b/src/polyhedralGravity/model/MeshChecking.h similarity index 95% rename from src/polyhedralGravity/calculation/MeshChecking.h rename to src/polyhedralGravity/model/MeshChecking.h index 87d5ee3..ee992dd 100644 --- a/src/polyhedralGravity/calculation/MeshChecking.h +++ b/src/polyhedralGravity/model/MeshChecking.h @@ -7,11 +7,11 @@ #include "thrust/transform_reduce.h" #include "thrust/execution_policy.h" #include "thrust/iterator/counting_iterator.h" -#include "polyhedralGravity/model/Polyhedron.h" -#include "polyhedralGravity/model/GravityModelData.h" +#include "Polyhedron.h" +#include "GravityModelData.h" #include "polyhedralGravity/util/UtilityContainer.h" #include "polyhedralGravity/util/UtilityConstants.h" -#include "polyhedralGravity/calculation/PolyhedronTransform.h" +#include "polyhedralGravity/model/PolyhedronTransform.h" namespace polyhedralGravity::MeshChecking { diff --git a/src/polyhedralGravity/calculation/PolyhedronTransform.h b/src/polyhedralGravity/model/PolyhedronTransform.h similarity index 100% rename from src/polyhedralGravity/calculation/PolyhedronTransform.h rename to src/polyhedralGravity/model/PolyhedronTransform.h diff --git a/src/polyhedralGravityPython/PolyhedralGravityPython.cpp b/src/polyhedralGravityPython/PolyhedralGravityPython.cpp index c2144bc..bde8b31 100644 --- a/src/polyhedralGravityPython/PolyhedralGravityPython.cpp +++ b/src/polyhedralGravityPython/PolyhedralGravityPython.cpp @@ -8,9 +8,9 @@ #include "polyhedralGravity/model/Polyhedron.h" #include "polyhedralGravity/model/GravityModelData.h" -#include "polyhedralGravity/calculation/GravityModel.h" -#include "polyhedralGravity/calculation/GravityEvaluable.h" -#include "polyhedralGravity/calculation/MeshChecking.h" +#include "polyhedralGravity/model/GravityModel.h" +#include "polyhedralGravity/model/GravityEvaluable.h" +#include "polyhedralGravity/model/MeshChecking.h" #include "polyhedralGravity/input/TetgenAdapter.h" diff --git a/test/calculation/GravityModelBigTest.cpp b/test/model/GravityModelBigTest.cpp similarity index 99% rename from test/calculation/GravityModelBigTest.cpp rename to test/model/GravityModelBigTest.cpp index e8ab66f..bf35768 100644 --- a/test/calculation/GravityModelBigTest.cpp +++ b/test/model/GravityModelBigTest.cpp @@ -8,7 +8,7 @@ #include #include #include "polyhedralGravity/input/TetgenAdapter.h" -#include "polyhedralGravity/calculation/GravityModel.h" +#include "polyhedralGravity/model/GravityModel.h" #include "polyhedralGravity/model/Polyhedron.h" #include "GravityModelVectorUtility.h" diff --git a/test/calculation/GravityModelCubeTest.cpp b/test/model/GravityModelCubeTest.cpp similarity index 98% rename from test/calculation/GravityModelCubeTest.cpp rename to test/model/GravityModelCubeTest.cpp index f977e91..b562418 100644 --- a/test/calculation/GravityModelCubeTest.cpp +++ b/test/model/GravityModelCubeTest.cpp @@ -9,7 +9,7 @@ #include #include #include -#include "polyhedralGravity/calculation/GravityModel.h" +#include "polyhedralGravity/model/GravityModel.h" #include "polyhedralGravity/model/Polyhedron.h" diff --git a/test/calculation/GravityModelTest.cpp b/test/model/GravityModelTest.cpp similarity index 99% rename from test/calculation/GravityModelTest.cpp rename to test/model/GravityModelTest.cpp index 1b728df..81008a8 100644 --- a/test/calculation/GravityModelTest.cpp +++ b/test/model/GravityModelTest.cpp @@ -4,7 +4,7 @@ #include #include #include -#include "polyhedralGravity/calculation/GravityModel.h" +#include "polyhedralGravity/model/GravityModel.h" #include "polyhedralGravity/model/Polyhedron.h" #include "GravityModelVectorUtility.h" diff --git a/test/calculation/GravityModelVectorUtility.cpp b/test/model/GravityModelVectorUtility.cpp similarity index 100% rename from test/calculation/GravityModelVectorUtility.cpp rename to test/model/GravityModelVectorUtility.cpp diff --git a/test/calculation/GravityModelVectorUtility.h b/test/model/GravityModelVectorUtility.h similarity index 99% rename from test/calculation/GravityModelVectorUtility.h rename to test/model/GravityModelVectorUtility.h index a2d651b..cd6a458 100644 --- a/test/calculation/GravityModelVectorUtility.h +++ b/test/model/GravityModelVectorUtility.h @@ -16,7 +16,7 @@ #include "thrust/transform_reduce.h" #include "thrust/execution_policy.h" #include "polyhedralGravity/util/UtilityThrust.h" -#include "polyhedralGravity/calculation/GravityModel.h" +#include "polyhedralGravity/model/GravityModel.h" /** * Contains additional utility for working with the values of the polyhedrale Gravity Model. diff --git a/test/calculation/MeshCheckingTest.cpp b/test/model/MeshCheckingTest.cpp similarity index 99% rename from test/calculation/MeshCheckingTest.cpp rename to test/model/MeshCheckingTest.cpp index 04d2149..5aca1b0 100644 --- a/test/calculation/MeshCheckingTest.cpp +++ b/test/model/MeshCheckingTest.cpp @@ -3,7 +3,7 @@ #include #include #include -#include "polyhedralGravity/calculation/MeshChecking.h" +#include "polyhedralGravity/model/MeshChecking.h" #include "polyhedralGravity/model/Polyhedron.h" #include "polyhedralGravity/input/TetgenAdapter.h" From 4173c2786c4ce001fa42ecca2e11340a949f666d Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Tue, 16 Apr 2024 18:17:02 +0200 Subject: [PATCH 12/54] refactor the Polyhedron Class Changes: - add orientation from GravityEvaluable - add density from GravityEvaluable - add mesh checking from MeshChecking - propagate changes inside C++ library/ executable Rational: All these methods/ functions were previously requiring to hand over a polyhedron. As instance methods, the argument is implicit (this) and we group mesh related utility into "the mesh container" and de-couple it from the gravity model. --- src/main.cpp | 7 +- src/polyhedralGravity/input/DataSource.h | 3 +- src/polyhedralGravity/input/TetgenAdapter.cpp | 4 +- src/polyhedralGravity/input/TetgenAdapter.h | 4 +- .../input/YAMLConfigReader.h | 2 +- .../model/GravityEvaluable.cpp | 46 +--- .../model/GravityEvaluable.h | 78 +----- src/polyhedralGravity/model/GravityModel.cpp | 23 +- src/polyhedralGravity/model/GravityModel.h | 15 +- .../model/GravityModelData.h | 32 +++ .../model/GravityModelDetail.h | 1 - src/polyhedralGravity/model/MeshChecking.cpp | 123 --------- src/polyhedralGravity/model/MeshChecking.h | 76 ------ src/polyhedralGravity/model/Polyhedron.cpp | 230 +++++++++++++++++ src/polyhedralGravity/model/Polyhedron.h | 241 +++++++++++++----- .../model/PolyhedronTransform.h | 29 --- src/polyhedralGravity/util/UtilityContainer.h | 33 ++- .../PolyhedralGravityPython.cpp | 1 - 18 files changed, 506 insertions(+), 442 deletions(-) delete mode 100644 src/polyhedralGravity/model/MeshChecking.cpp delete mode 100644 src/polyhedralGravity/model/MeshChecking.h create mode 100644 src/polyhedralGravity/model/Polyhedron.cpp delete mode 100644 src/polyhedralGravity/model/PolyhedronTransform.h diff --git a/src/main.cpp b/src/main.cpp index c71543a..ce860e9 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -2,7 +2,6 @@ #include "polyhedralGravity/input/ConfigSource.h" #include "polyhedralGravity/input/YAMLConfigReader.h" #include "polyhedralGravity/model/GravityModel.h" -#include "polyhedralGravity/model/MeshChecking.h" #include "polyhedralGravity/output/Logging.h" #include "polyhedralGravity/output/CSVWriter.h" @@ -16,9 +15,8 @@ int main(int argc, char *argv[]) { } try { - std::shared_ptr config = std::make_shared(argv[1]); - auto poly = config->getDataSource()->getPolyhedron(); + auto polyhedralSource = config->getDataSource()->getPolyhedron(); auto density = config->getDensity(); auto computationPoints = config->getPointsOfInterest(); auto outputFileName = config->getOutputFileName(); @@ -26,7 +24,8 @@ int main(int argc, char *argv[]) { SPDLOG_LOGGER_INFO(PolyhedralGravityLogger::DEFAULT_LOGGER.getLogger(), "The calculation started..."); auto start = std::chrono::high_resolution_clock::now(); - auto result = GravityModel::evaluate(poly, density, computationPoints, true, NormalOrientation::OUTWARDS, checkPolyhedralInput); + Polyhedron polyhedron{polyhedralSource, density}; + auto result = GravityModel::evaluate(polyhedron, computationPoints, true); auto end = std::chrono::high_resolution_clock::now(); auto duration = end - start; auto ms = std::chrono::duration_cast(duration); diff --git a/src/polyhedralGravity/input/DataSource.h b/src/polyhedralGravity/input/DataSource.h index 78793ba..e3232e7 100644 --- a/src/polyhedralGravity/input/DataSource.h +++ b/src/polyhedralGravity/input/DataSource.h @@ -1,5 +1,6 @@ #pragma once +#include #include "polyhedralGravity/model/Polyhedron.h" namespace polyhedralGravity { @@ -20,7 +21,7 @@ namespace polyhedralGravity { * Returns a Polyhedron from the underlying source. * @return a polyhedron */ - virtual Polyhedron getPolyhedron() = 0; + virtual std::tuple, std::vector> getPolyhedron() = 0; }; diff --git a/src/polyhedralGravity/input/TetgenAdapter.cpp b/src/polyhedralGravity/input/TetgenAdapter.cpp index 16d62db..895e282 100644 --- a/src/polyhedralGravity/input/TetgenAdapter.cpp +++ b/src/polyhedralGravity/input/TetgenAdapter.cpp @@ -2,7 +2,7 @@ namespace polyhedralGravity { - Polyhedron TetgenAdapter::getPolyhedron() { + std::tuple, std::vector> TetgenAdapter::getPolyhedron() { //1. Step: Read in from files for (const auto &fileName: _fileNames) { size_t pos = fileName.find_last_of('.'); @@ -12,7 +12,7 @@ namespace polyhedralGravity { } //2. Convert tetgenio to Polyhedron - return {_vertices, _faces}; + return std::make_tuple(_vertices, _faces); } void TetgenAdapter::readNode(const std::string &filename) { diff --git a/src/polyhedralGravity/input/TetgenAdapter.h b/src/polyhedralGravity/input/TetgenAdapter.h index 4443268..19a6d36 100644 --- a/src/polyhedralGravity/input/TetgenAdapter.h +++ b/src/polyhedralGravity/input/TetgenAdapter.h @@ -22,7 +22,7 @@ namespace polyhedralGravity { * * The Adapter further keeps en eye on the already read in files in order to give feedback if data is in conflict. */ - class TetgenAdapter : public DataSource { + class TetgenAdapter final : public DataSource { /** * The default exception message @@ -72,7 +72,7 @@ namespace polyhedralGravity { * converted to a Polyhedron. * @return a Polyhedron */ - Polyhedron getPolyhedron() override; + std::tuple, std::vector> getPolyhedron() override; /** * Reads nodes from a .node file diff --git a/src/polyhedralGravity/input/YAMLConfigReader.h b/src/polyhedralGravity/input/YAMLConfigReader.h index 4faa1dc..c25619d 100644 --- a/src/polyhedralGravity/input/YAMLConfigReader.h +++ b/src/polyhedralGravity/input/YAMLConfigReader.h @@ -13,7 +13,7 @@ namespace polyhedralGravity { * The YAMLConfigReader serves as Interface between yaml-cpp and the Polyhedral Gravity Model and * reads in the input from an yaml configuration file. */ - class YAMLConfigReader : public ConfigSource { + class YAMLConfigReader final : public ConfigSource { /* * The following static variables contain the names of the YAML nodes. diff --git a/src/polyhedralGravity/model/GravityEvaluable.cpp b/src/polyhedralGravity/model/GravityEvaluable.cpp index 947d70b..23523e0 100644 --- a/src/polyhedralGravity/model/GravityEvaluable.cpp +++ b/src/polyhedralGravity/model/GravityEvaluable.cpp @@ -3,32 +3,6 @@ namespace polyhedralGravity { - void GravityEvaluable::runMeshCeck(const std::optional &flag) const { - if (flag.has_value() && !flag.value()) { - // Explcitly disabled check - return; - } - if (!flag.has_value()) { - // Implcitly enabled check, print a warning about the runtime cost - SPDLOG_LOGGER_WARN(PolyhedralGravityLogger::DEFAULT_LOGGER.getLogger(), - "The mesh check is enabled and analyzes the polyhedron for degnerated faces & " - "that all plane unit normals point in the specified direction. This checks requires " - "a quadratic runtime cost which is most of the time not desirable. " - "Please explcity enable or disable this by setting 'check' to true orfalse"); - } - // Implictly or explcity enabled checking - if (!MeshChecking::checkTrianglesNotDegenerated(_polyhedron)) { - throw std::runtime_error{"At least on triangle in the mesh is degenerated and its surface area equals zero!"}; - } - if (!MeshChecking::checkPlaneUnitNormalOrientation(_polyhedron, _orientation)) { - std::stringstream sstream{}; - sstream << "The plane unit normals are not pointing in the specified direction '" << _orientation << "'! Please check the order " - "of the vertices in the polyhedral input source! You can use utility.plane_normal_orientation(..) " - "in Python or MeshChecking::getPlaneUnitNormalOrientation in C++ for a detailed explaination!"; - throw std::runtime_error{sstream.str()}; - } - } - void GravityEvaluable::prepare() const { using namespace GravityModel::detail; // Initialize the vectors and allocate the required memory @@ -65,11 +39,9 @@ namespace polyhedralGravity { /* * Calculate V and Vx, Vy, Vz and Vxx, Vyy, Vzz, Vxy, Vxz, Vyz */ - auto polyhedronIterator = transformPolyhedron(_polyhedron, computationPoint); - auto zip1 = util::zip(polyhedronIterator.first, _segmentVectors.begin(), _planeUnitNormals.begin(), - _segmentUnitNormals.begin()); - auto zip2 = util::zip(polyhedronIterator.second, _segmentVectors.end(), _planeUnitNormals.end(), - _segmentUnitNormals.end()); + const auto &[polyBegin, polyEnd] = _polyhedron.transformIterator(computationPoint); + auto zip1 = util::zip(polyBegin, _segmentVectors.begin(), _planeUnitNormals.begin(), _segmentUnitNormals.begin()); + auto zip2 = util::zip(polyEnd, _segmentVectors.end(), _planeUnitNormals.end(), _segmentUnitNormals.end()); SPDLOG_LOGGER_DEBUG(PolyhedralGravityLogger::DEFAULT_LOGGER.getLogger(), "Starting to iterate over the planes..."); @@ -88,7 +60,7 @@ namespace polyhedralGravity { "Finished the sums. Applying final prefix and eliminating rounding errors."); //9. Step: Compute prefix consisting of GRAVITATIONAL_CONSTANT * density - const double prefix = util::GRAVITATIONAL_CONSTANT * _density; + const double prefix = util::GRAVITATIONAL_CONSTANT * _polyhedron.getDensity() * _polyhedron.getOrientationFactor(); //10. Step: Final expressions after application of the prefix (and a division by 2 for the potential) potential = (potential * prefix) / 2.0; @@ -259,15 +231,15 @@ namespace polyhedralGravity { } std::string GravityEvaluable::toString() const { - std::stringstream ss; - ss << ""; - return ss.str(); + return sstream.str(); } - std::tuple, std::vector, std::vector> + std::tuple, std::vector, std::vector> GravityEvaluable::getState() const { - return std::make_tuple(_polyhedron, _density, _orientation, _segmentVectors, _planeUnitNormals, _segmentUnitNormals); + return std::make_tuple(_polyhedron, _segmentVectors, _planeUnitNormals, _segmentUnitNormals); } } diff --git a/src/polyhedralGravity/model/GravityEvaluable.h b/src/polyhedralGravity/model/GravityEvaluable.h index 25917f8..b05e46e 100644 --- a/src/polyhedralGravity/model/GravityEvaluable.h +++ b/src/polyhedralGravity/model/GravityEvaluable.h @@ -10,7 +10,6 @@ #include "thrust/execution_policy.h" #include "GravityModelDetail.h" -#include "MeshChecking.h" #include "polyhedralGravity/util/UtilityContainer.h" #include "polyhedralGravity/input/TetgenAdapter.h" #include "GravityModelData.h" @@ -30,59 +29,25 @@ namespace polyhedralGravity { /** The constant density polyhedron consisting of vertices and triangular faces */ const Polyhedron _polyhedron; - /** The constant density of the polyhedron (the unit must match to the mesh, e.g., mesh in @f$[m]@f$ requires density in @f$[kg/m^3]@f$) */ - const double _density; - - /** The orientation of the normals of the polyhedron, either outwards or inwards pointing the polyhedral source */ - const NormalOrientation _orientation; - /** Cache for the segment vectors (segments between vertices of a polyhedral face) */ - mutable std::vector _segmentVectors; + mutable std::vector _segmentVectors{}; /** Cache for the plane unit normals (unit normals of the polyhedral faces) */ - mutable std::vector _planeUnitNormals; + mutable std::vector _planeUnitNormals{}; /** Cache for the segment unit normals (unit normals of each the polyhedral faces' segments) */ - mutable std::vector _segmentUnitNormals; + mutable std::vector _segmentUnitNormals{}; public: /** * Instantiates a GravityEvaluable with a given constant density polyhedron. - * @param polyhedralSource the polyhedron as polyhedron, vertices and faces, or a list of files - * @param density the constant density (the unit must match to the mesh, - * e.g., mesh in @f$[m]@f$ requires density in @f$[kg/m^3]@f$) - * @param orientation the orientation of the plane unit normals of the polyhedron (either pointing outwards or inwards the polyhedron) - * (default: OUTWARDS as this is the original assumption of Tsoulis et al.'s formulation) - * @param check if true, the polyhedral mesh will be checked for degenerated triangular surfaces and - * that the orientation of the normals are outwards pointing/ pointing to as specified by the parameter orientation - * The latter check requires @f$O(n^2)$@f operations! - * By default the check is enabled and will inform the user about inconstencies and the quadratic runtime. - * Explcitly enableing silence the @f$O(n^2)$@f warning, but produces an exception in case of inconstency - * Explcity disableing silences everythign and avoids the @f$O(n^2)$@f runtime cost. - * - * @note This is a separate constructor since the polyhedron as a class it not exposed to the user via - * the Python Interface. Thus, this constructor is only available via the C++ interface. - * - * @warning The input check requires @f$O(n^2)$@f operations and is enabled by default. Disable it when "you know your mesh"! + * In contrast to the {@link GravityModel::evaluate}, this evaluate method on the {@link GravityEvaluable} + * caches intermediate results and input data and subsequent evaluations will be faster. * - * @throws If inputCheck is true (or not set) and the orientation does not match with the polyhedral match a argument exception + * @param polyhedron the constant density polyhedron */ - GravityEvaluable( - const PolyhedralSource &polyhedralSource, - double density, - const NormalOrientation &orientation = NormalOrientation::OUTWARDS, - const std::optional check = std::nullopt - ) : - _polyhedron{ - std::visit(util::overloaded{ - [](const Polyhedron &arg) { return arg; }, - [](const PolyhedralFileSource &arg) { return TetgenAdapter{arg}.getPolyhedron(); }, - [](const PolyhedralDataSource &arg) { return Polyhedron{arg}; } - }, polyhedralSource) - }, - _density{density}, - _orientation{orientation} { - this->runMeshCeck(check); + explicit GravityEvaluable(const Polyhedron &polyhedron) : + _polyhedron{polyhedron} { this->prepare(); } @@ -90,23 +55,15 @@ namespace polyhedralGravity { * Instantiates a GravityEvaluable with a given constant density polyhedron and caches. * This is for restoring a GravityEvaluable from a previous state. * @param polyhedron the polyhedron - * @param density the constant density (the unit must match to the mesh, - * e.g., mesh in @f$[m]@f$ requires density in @f$[kg/m^3]@f$) - * @param orientation the orientation of the plane unit normals of the polyhedron (either pointing outwards or inwards the polyhedron) - * (default: OUTWARDS as this is the original assumption of Tsoulis et al.'s formulation) * @param segmentVectors the segment vectors * @param planeUnitNormals the plane unit normals * @param segmentUnitNormals the segment unit normals */ GravityEvaluable(const Polyhedron &polyhedron, - double density, - const NormalOrientation &orientation, const std::vector &segmentVectors, const std::vector &planeUnitNormals, const std::vector &segmentUnitNormals) : _polyhedron{polyhedron}, - _density{density}, - _orientation{orientation}, _segmentVectors{segmentVectors}, _planeUnitNormals{planeUnitNormals}, _segmentUnitNormals{ @@ -142,27 +99,16 @@ namespace polyhedralGravity { * Returns a string representation of the GravityEvaluable. * @return string representation of the GravityEvaluable */ - std::string toString() const; + [[nodiscard]] std::string toString() const; /** * Returns the polyhedron, the density and the internal caches. * * @return tuple of polyhedron, density, segmentVectors, planeUnitNormals and segmentUnitNormals */ - std::tuple, std::vector, std::vector> - getState() const; + std::tuple, std::vector, std::vector> getState() const; private: - /** - * Runs the Mesh Sanity Check depending on the flag. - * If nullopt, the check is run and the user is informed about a potential unwanted @f$O(n^2)$@f runtime cost - * If true, the check is run, but no runtime cost warning is printed - * if false, the check is disabled and nothing at all is done - * @param flag to determine if what is done - * - * @throws std::runtime_error in case of wrong mesh properties - */ - void runMeshCeck(const std::optional &flag) const; /** * Prepares the polyhedron for the evaluation by calculating the segment vectors, the plane unit normals @@ -180,7 +126,7 @@ namespace polyhedralGravity { * at computation Point P */ template - GravityModelResult evaluate(const Array3 &computationPoint) const; + [[nodiscard]] GravityModelResult evaluate(const Array3 &computationPoint) const; /** @@ -191,7 +137,7 @@ namespace polyhedralGravity { * @return vector of GravityModelResults containing the potential, the acceleration and the change of acceleration */ template - std::vector evaluate(const std::vector &computationPoints) const; + [[nodiscard]] std::vector evaluate(const std::vector &computationPoints) const; /** * Evaluates the polyhedrale gravity model for a given constant density polyhedron at computation a certain face. diff --git a/src/polyhedralGravity/model/GravityModel.cpp b/src/polyhedralGravity/model/GravityModel.cpp index aab5203..545e585 100644 --- a/src/polyhedralGravity/model/GravityModel.cpp +++ b/src/polyhedralGravity/model/GravityModel.cpp @@ -2,25 +2,14 @@ namespace polyhedralGravity::GravityModel { - GravityModelResult evaluate( - const PolyhedralSource &polyhedron, - double density, const Array3 &computationPoint, bool parallel, const NormalOrientation &orientation, - const std::optional check) { - return std::get( - std::visit([&](const auto &polyhedron) { - GravityEvaluable evaluable{polyhedron, density, orientation, check}; - return evaluable(computationPoint, parallel); - }, polyhedron)); + GravityModelResult evaluate(const Polyhedron &polyhedron, const Array3 &computationPoint, bool parallel) { + GravityEvaluable evaluable{polyhedron}; + return std::get(evaluable(computationPoint, parallel)); } - std::vector - evaluate(const PolyhedralSource &polyhedron, double density, const std::vector &computationPoints, - bool parallel, const NormalOrientation &orientation, - const std::optional check) { - return std::get>(std::visit([&](const auto &polyhedron) { - GravityEvaluable evaluable{polyhedron, density, orientation, check}; - return evaluable(computationPoints, parallel); - }, polyhedron)); + std::vector evaluate(const Polyhedron &polyhedron, const std::vector &computationPoints, bool parallel) { + GravityEvaluable evaluable{polyhedron}; + return std::get>(evaluable(computationPoints, parallel)); } } diff --git a/src/polyhedralGravity/model/GravityModel.h b/src/polyhedralGravity/model/GravityModel.h index d41a58f..df3fb20 100644 --- a/src/polyhedralGravity/model/GravityModel.h +++ b/src/polyhedralGravity/model/GravityModel.h @@ -1,10 +1,7 @@ #pragma once -#include #include #include -#include -#include #include "polyhedralGravity/model/GravityEvaluable.h" #include "polyhedralGravity/model/GravityModelData.h" @@ -22,31 +19,23 @@ namespace polyhedralGravity::GravityModel { * Evaluates the polyhedrale gravity model for a given constant density polyhedron at computation * point P. * @param polyhedron the polyhedron consisting of vertices and triangular faces - * @param density the constant density (the unit must match to the mesh, - * e.g., mesh in @f$[m]@f$ requires density in @f$[kg/m^3]@f$) * @param computationPoint the computation Point P * @param parallel whether to evaluate in parallel or serial * @return the GravityModelResult containing the potential, the acceleration and the change of acceleration * at computation Point P */ - GravityModelResult evaluate(const PolyhedralSource &polyhedron, double density, const Array3 &computationPoint, - bool parallel = true, const NormalOrientation &orientation = NormalOrientation::OUTWARDS, - const std::optional check = std::nullopt); + GravityModelResult evaluate(const Polyhedron &polyhedron, const Array3 &computationPoint, bool parallel = true); /** * Evaluates the polyhedral gravity model for a given constant density polyhedron at multiple computation * points. * @param polyhedron the polyhedron consisting of vertices and triangular faces - * @param density the constant density (the unit must match to the mesh, - * e.g., mesh in @f$[m]@f$ requires density in @f$[kg/m^3]@f$) * @param computationPoints vector of computation points * @param parallel whether to evaluate in parallel or serial * @return the GravityModelResult containing the potential, the acceleration and the change of acceleration * foreach computation Point P */ std::vector - evaluate(const PolyhedralSource &polyhedron, double density, const std::vector &computationPoints, - bool parallel = true, const NormalOrientation &orientation = NormalOrientation::OUTWARDS, - const std::optional check = std::nullopt); + evaluate(const Polyhedron &polyhedron, const std::vector &computationPoints, bool parallel = true); } \ No newline at end of file diff --git a/src/polyhedralGravity/model/GravityModelData.h b/src/polyhedralGravity/model/GravityModelData.h index 1f80812..798574e 100644 --- a/src/polyhedralGravity/model/GravityModelData.h +++ b/src/polyhedralGravity/model/GravityModelData.h @@ -87,6 +87,38 @@ namespace polyhedralGravity { return os; } + /** + * The three mode the poylhedron class takes in + * the constructor in order to determine what initilaization checks to conduct. + * This enum is exclusivly utilized in the constrcutor of a {@link Polyhedron} and its private method + * {@link runIntegrityMeasures} + */ + enum class PolyhedronIntegrity: char { + /** + * All activities regarding MeshChecking are disabled. + * @note No runtime overhead! + */ + DISABLE, + /** + * Only verification of the NormalOrientation. + * A misalignment (e.g. specified OUTWARDS, but is not) leads to a runtime_error. + * @note Runtime Cost @f$O(n^2)$@f + */ + VERIFY, + /** + * Like VERIFY, but also informs the user about the option in any case on the runtime costs. + * This is the implicit default option. + * @note Runtime Cost: @f$O(n^2)$@f and output to stdout in every case! + */ + AUTOMATIC, + /** + * Verification and Autmatioc Healing of the NormalOrientation. + * A misalignemt does not lead to a runtime_error, but to an internal correction. Cost: @f$O(n^2)$@f + * @note Runtime Cost: @f$O(n^2)$@f and a modification of the mesh input! + */ + HEAL, + }; + /** * Contains the 3D distances l1_pq and l2_pq between P and the endpoints of segment pq and diff --git a/src/polyhedralGravity/model/GravityModelDetail.h b/src/polyhedralGravity/model/GravityModelDetail.h index e49acdd..8336afd 100644 --- a/src/polyhedralGravity/model/GravityModelDetail.h +++ b/src/polyhedralGravity/model/GravityModelDetail.h @@ -15,7 +15,6 @@ #include "thrust/execution_policy.h" #include "xsimd/xsimd.hpp" -#include "PolyhedronTransform.h" #include "Polyhedron.h" #include "GravityModelData.h" #include "polyhedralGravity/input/TetgenAdapter.h" diff --git a/src/polyhedralGravity/model/MeshChecking.cpp b/src/polyhedralGravity/model/MeshChecking.cpp deleted file mode 100644 index d07a35e..0000000 --- a/src/polyhedralGravity/model/MeshChecking.cpp +++ /dev/null @@ -1,123 +0,0 @@ -#include "MeshChecking.h" - -namespace polyhedralGravity::MeshChecking { - - bool checkPlaneUnitNormalOrientation(const Polyhedron &polyhedron, const NormalOrientation &normalOrientation) { - auto it = transformPolyhedron(polyhedron); - // All normals have to point outwards (intersect the polyhedron even times) - return thrust::transform_reduce( - thrust::device, - it.first, it.second, [&polyhedron, &normalOrientation](const Array3Triplet &face) { - // If the ray intersects the polyhedron an even number of times then the normal points outwards - // If the ray intersects the polyhedron odd number if times the normal points inwards - const size_t intersects = detail::countRayPolyhedronIntersections(face, polyhedron); - return (intersects % 2 == 0) == (normalOrientation == NormalOrientation::OUTWARDS); - }, true, thrust::logical_and()); - } - - std::pair> getPlaneUnitNormalOrientation(const Polyhedron &polyhedron) { - // 1. Step: Find all indices of normals which vioate the constraint outwards pointing - auto indexIterator = thrust::make_counting_iterator(0); - size_t numberOfFaces = polyhedron.countFaces(); - std::set violatingOutwards{}; - thrust::copy_if( - thrust::device, - indexIterator, - indexIterator + numberOfFaces, - std::inserter(violatingOutwards, violatingOutwards.end()), - [&polyhedron](const size_t index) { - // If the ray intersects the polyhedron odd number if times the normal points inwards - // Hence, violating the OUTWARDS constraint - const size_t intersects = detail::countRayPolyhedronIntersections(polyhedron.getFace(index), polyhedron); - return intersects % 2 != 0; - }); - // 2. Step: If we have more than n/2 violations, the majority is inwards pointing --> Build complemntary set! - if (violatingOutwards.size() > numberOfFaces / 2) { - std::set fullSet{}; - std::copy_n(indexIterator, numberOfFaces, std::inserter(fullSet, fullSet.end())); - std::set violatingInwards{}; - std::set_difference( - fullSet.begin(), fullSet.end(), - violatingOutwards.begin(), violatingOutwards.end(), - std::inserter(violatingInwards, violatingInwards.end()) - ); - // 3a. Step: Return the inwards pointing as major orientation and - // the violating faces, i.e. which have outwards pointing normals - return std::make_pair(NormalOrientation::INWWARDS, violatingInwards); - } - // 3b. Step: Return the outwards pointing as major orientation - // and the violating faces, i.e. which have inwards pointing normals - return std::make_pair(NormalOrientation::OUTWARDS, violatingOutwards); - } - - bool checkTrianglesNotDegenerated(const Polyhedron &polyhedron) { - auto it = transformPolyhedron(polyhedron); - // All triangles surface area needs to be greater than zero - return thrust::transform_reduce( - thrust::device, - it.first, it.second, [](const Array3Triplet &face) { - return util::surfaceArea(face) > 0.0; - }, true, thrust::logical_and()); - } - - size_t - detail::countRayPolyhedronIntersections(const Array3Triplet &face, const Polyhedron &polyhedron) { - using namespace util; - // The centroid of the triangular face - const Array3 centroid = (face[0] + face[1] + face[2]) / 3.0; - - // The normal of the plane calculated with two segments of the triangle - // The normal is the rayVector starting at the rayOrigin - const Array3 segmentVector1 = face[1] - face[0]; - const Array3 segmentVector2 = face[2] - face[1]; - const Array3 rayVector = util::normal(segmentVector1, segmentVector2); - - // The origin of the array has a slight offset in direction of the normal - const Array3 rayOrigin = centroid + (rayVector * EPSILON); - - // Count every triangular face which is intersected by the ray - auto it = transformPolyhedron(polyhedron); - std::set intersections{}; - std::for_each(it.first, it.second, [&rayOrigin, &rayVector, &intersections](const Array3Triplet &otherFace) { - const std::unique_ptr intersection = rayIntersectsTriangle(rayOrigin, rayVector, otherFace); - if (intersection != nullptr) { - intersections.insert(*intersection); - } - }); - return intersections.size(); - } - - std::unique_ptr - detail::rayIntersectsTriangle(const Array3 &rayOrigin, const Array3 &rayVector, const Array3Triplet &triangle) { - // Adapted Möller–Trumbore intersection algorithm - // see https://en.wikipedia.org/wiki/Möller–Trumbore_intersection_algorithm - using namespace util; - const Array3 edge1 = triangle[1] - triangle[0]; - const Array3 edge2 = triangle[2] - triangle[0]; - const Array3 h = cross(rayVector, edge2); - const double a = dot(edge1, h); - if (a > -EPSILON && a < EPSILON) { - return nullptr; - } - - const double f = 1.0 / a; - const Array3 s = rayOrigin - triangle[0]; - const double u = f * dot(s, h); - if (u < 0.0 || u > 1.0) { - return nullptr; - } - - const Array3 q = cross(s, edge1); - const double v = f * dot(rayVector, q); - if (v < 0.0 || u + v > 1.0) { - return nullptr; - } - - const double t = f * dot(edge2, q); - if (t > EPSILON) { - return std::make_unique(rayOrigin + rayVector * t); - } else { - return nullptr; - } - } -} \ No newline at end of file diff --git a/src/polyhedralGravity/model/MeshChecking.h b/src/polyhedralGravity/model/MeshChecking.h deleted file mode 100644 index ee992dd..0000000 --- a/src/polyhedralGravity/model/MeshChecking.h +++ /dev/null @@ -1,76 +0,0 @@ -#pragma once - -#include -#include -#include -#include "thrust/copy.h" -#include "thrust/transform_reduce.h" -#include "thrust/execution_policy.h" -#include "thrust/iterator/counting_iterator.h" -#include "Polyhedron.h" -#include "GravityModelData.h" -#include "polyhedralGravity/util/UtilityContainer.h" -#include "polyhedralGravity/util/UtilityConstants.h" -#include "polyhedralGravity/model/PolyhedronTransform.h" - -namespace polyhedralGravity::MeshChecking { - - /** - * Checks if the vertices are in such a order that the unit normals of each plane point outwards the polyhedron - * @param polyhedron the polyhedron consisting of vertices and triangular faces - * @param normalOrientation - * @return true if all the unit normals are pointing outwards - * - * @note This has quadratic complexity @f$O(n^2)@f$! For bigger problem sizes, K-D trees/ Octrees could improve - * the complexity to determine the intersections - * (see https://stackoverflow.com/questions/45603469/how-to-calculate-the-normals-of-a-box) - */ - bool checkPlaneUnitNormalOrientation(const Polyhedron &polyhedron, const NormalOrientation& normalOrientation = NormalOrientation::OUTWARDS); - - /** - * This method determines the majority vertex ordering of a polyhedron and the set of faces which - * violate the majority constraint and need to be adpated. - * Hence, if the set is empty, all faces obey to the returned ordering/ plane unit normal orientation. - * - * @param polyhedron the polyhedron consisting of vertices and triangular faces - * @return a pair consisting of majority ordering (OUTWARDS or INWARDS pointing normals) - * and a set of face indices which violate the constraint - */ - std::pair> getPlaneUnitNormalOrientation(const Polyhedron &polyhedron); - - /** - * Checks if no triangle is degenerated by checking the surface area being greater than zero. - * E.g. two points are the same or all three are collinear. - * @param polyhedron the polyhedron consisting of vertices and triangular faces - * @return true if triangles are fine and none of them is degenerate - */ - bool checkTrianglesNotDegenerated(const Polyhedron &polyhedron); - - - namespace detail { - - /** - * Calculates how often a vector starting at a specific origin intersects a polyhedron's mesh's triangles. - * @param face the vector describing the ray - * @param polyhedron the polyhedron consisting of vertices and triangular faces - * @return true if the ray intersects the triangle - */ - size_t - countRayPolyhedronIntersections(const Array3Triplet& face, const Polyhedron &polyhedron); - - /** - * Calculates how often a vector starting at a specific origin intersects a triangular face. - * Uses the Möller–Trumbore intersection algorithm. - * @param rayOrigin the origin of the ray - * @param rayVector the vector describing the ray - * @param triangle a triangular face - * @return intersection point or null - * - * @related Adapted from https://en.wikipedia.org/wiki/Möller–Trumbore_intersection_algorithm - */ - std::unique_ptr - rayIntersectsTriangle(const Array3 &rayOrigin, const Array3 &rayVector, const Array3Triplet &triangle); - - } - -} diff --git a/src/polyhedralGravity/model/Polyhedron.cpp b/src/polyhedralGravity/model/Polyhedron.cpp new file mode 100644 index 0000000..707cda6 --- /dev/null +++ b/src/polyhedralGravity/model/Polyhedron.cpp @@ -0,0 +1,230 @@ +#include "Polyhedron.h" + +#include "polyhedralGravity/input/TetgenAdapter.h" + + +namespace polyhedralGravity { + + Polyhedron::Polyhedron(const std::vector &vertices, + const std::vector &faces, double density, const NormalOrientation &orientation, const PolyhedronIntegrity &integrity) + : _vertices{vertices}, + _faces{faces}, + _density{density}, + _orientation{orientation} { + //Checks that the node with index zero is actually used + if (_faces.end() == std::find_if(_faces.begin(), _faces.end(), [&](auto &face) { + return face[0] == 0 || face[1] == 0 || face[2] == 0; + })) { + throw std::invalid_argument("The node with index zero (0) was never used in any face! This is " + "no valid polyhedron. Probable issue: Started numbering the vertices of " + "the polyhedron at one (1)."); + } + this->runIntegrityMeasures(integrity); + } + + Polyhedron::Polyhedron(const PolyhedralSource &polyhedralSource, double density, const NormalOrientation &orientation, const PolyhedronIntegrity &integrity) + : Polyhedron{std::get>(polyhedralSource), std::get>(polyhedralSource), density, orientation, integrity} {} + + Polyhedron::Polyhedron(const PolyhedralFiles &polyhedralFiles, double density, const NormalOrientation &orientation, const PolyhedronIntegrity &integrity) + : Polyhedron{TetgenAdapter{polyhedralFiles}.getPolyhedron(), density, orientation, integrity} {} + + const std::vector &Polyhedron::getVertices() const { + return _vertices; + } + + const Array3 &Polyhedron::getVertex(size_t index) const { + return _vertices[index]; + } + + size_t Polyhedron::countVertices() const { + return _vertices.size(); + } + + const std::vector &Polyhedron::getFaces() const { + return _faces; + } + + const IndexArray3 &Polyhedron::getFace(size_t index) const { + return _faces[index]; + } + + Array3Triplet Polyhedron::getResolvedFace(size_t index) const { + return {_vertices[_faces[index][0]], _vertices[_faces[index][1]], _vertices[_faces[index][2]]}; + } + + size_t Polyhedron::countFaces() const { + return _faces.size(); + } + + double Polyhedron::getDensity() const { + return _density; + } + + double Polyhedron::getOrientationFactor() const { + return _orientation == NormalOrientation::OUTWARDS ? 1.0 : -1.0; + } + + std::string Polyhedron::toString() const { + std::stringstream sstream; + sstream << ""; + return sstream.str(); + } + + + void Polyhedron::runIntegrityMeasures(const PolyhedronIntegrity &integrity) { + using util::operator<<; + switch (integrity) { + case PolyhedronIntegrity::DISABLE: + return; + case PolyhedronIntegrity::AUTOMATIC: + SPDLOG_LOGGER_WARN(PolyhedralGravityLogger::DEFAULT_LOGGER.getLogger(), + "The mesh check is enabled and analyzes the polyhedron for degnerated faces & " + "that all plane unit normals point in the specified direction. This checks requires " + "a quadratic runtime cost which is most of the time not desirable. " + "Please explcity enable or disable this by setting 'check' to true orfalse"); + // NO BREAK! AUTOMATIC implies VERIFY, but with a info mesage to explcitly set the option + case PolyhedronIntegrity::VERIFY: + // NO BREAK! VERIFY terminates earlier, but does in the beginning the same as HEAL + case PolyhedronIntegrity::HEAL: + if (!this->checkTrianglesNotDegenerated()) { + throw std::invalid_argument{"At least on triangle in the mesh is degenerated and its surface area equals zero!"}; + } + const auto &[actualOrientation, violatingIndices] = this->checkPlaneUnitNormalOrientation(); + if (actualOrientation != _orientation || !violatingIndices.empty()) { + std::stringstream sstream{}; + sstream << "The plane unit normals are not all pointing in the specified direction " << _orientation << '\n'; + if (violatingIndices.empty()) { + sstream << "Instead all plane unit normals are pointing " + << actualOrientation + << ". You can either reconstruct the reconstruct the polyhedron with the ortientation set to " << actualOrientation + << ". Alternativly, you can reconstruct with the integrity check set to HEAL"; + } else { + sstream << "The actual majority orientation is " << actualOrientation + << ". You can either:\n 1) Fix the ordering of the following faces:\n" + << violatingIndices << '\n' + << "2) Or you reconstruct the polyhedron using the integrity check set to HEAL."; + } + if (integrity == PolyhedronIntegrity::VERIFY) { + throw std::invalid_argument(sstream.str()); + } else { + this->healPlaneUnitNormalOrientation(actualOrientation, violatingIndices); + } + } + } + } + + bool Polyhedron::checkTrianglesNotDegenerated() const { + const auto &[begin, end] = this->transformIterator(); + // All triangles surface area needs to be greater than zero + return thrust::transform_reduce( + thrust::device, + begin, end, [](const Array3Triplet &face) { + return util::surfaceArea(face) > 0.0; + }, true, thrust::logical_and()); + } + + std::pair> Polyhedron::checkPlaneUnitNormalOrientation() const { + // 1. Step: Find all indices of normals which vioate the constraint outwards pointing + auto indexIterator = thrust::make_counting_iterator(0); + size_t numberOfFaces = this->countFaces(); + std::set violatingOutwards{}; + thrust::copy_if( + thrust::device, + indexIterator, + indexIterator + numberOfFaces, + std::inserter(violatingOutwards, violatingOutwards.end()), + [this](const size_t index) { + // If the ray intersects the polyhedron odd number if times the normal points inwards + // Hence, violating the OUTWARDS constraint + const size_t intersects = countRayPolyhedronIntersections(this->getResolvedFace(index)); + return intersects % 2 != 0; + }); + // 2. Step: If we have more than n/2 violations, the majority is inwards pointing --> Build complemntary set! + if (violatingOutwards.size() > numberOfFaces / 2) { + std::set fullSet{}; + std::copy_n(indexIterator, numberOfFaces, std::inserter(fullSet, fullSet.end())); + std::set violatingInwards{}; + std::set_difference( + fullSet.begin(), fullSet.end(), + violatingOutwards.begin(), violatingOutwards.end(), + std::inserter(violatingInwards, violatingInwards.end()) + ); + // 3a. Step: Return the inwards pointing as major orientation and + // the violating faces, i.e. which have outwards pointing normals + return std::make_pair(NormalOrientation::INWWARDS, violatingInwards); + } + // 3b. Step: Return the outwards pointing as major orientation + // and the violating faces, i.e. which have inwards pointing normals + return std::make_pair(NormalOrientation::OUTWARDS, violatingOutwards); + } + + void Polyhedron::healPlaneUnitNormalOrientation(const NormalOrientation &actualOrientation, const std::set &violatingIndices) { + // Assign the majority plane unit normal orientation + _orientation = actualOrientation; + // Fix the vioalting faces by exchaning the vertex ordering (exchaning index 0 with index 1 in the face) + std::for_each(violatingIndices.cbegin(), violatingIndices.cend(), [this](size_t i) { + std::swap(this->_faces[i][0], this->_faces[i][1]); + }); + } + + size_t Polyhedron::countRayPolyhedronIntersections(const Array3Triplet &face) const { + using namespace util; + // The centroid of the triangular face + const Array3 centroid = (face[0] + face[1] + face[2]) / 3.0; + + // The normal of the plane calculated with two segments of the triangle + // The normal is the rayVector starting at the rayOrigin + const Array3 segmentVector1 = face[1] - face[0]; + const Array3 segmentVector2 = face[2] - face[1]; + const Array3 rayVector = normal(segmentVector1, segmentVector2); + + // The origin of the array has a slight offset in direction of the normal + const Array3 rayOrigin = centroid + (rayVector * EPSILON); + + // Count every triangular face which is intersected by the ray + const auto &[begin, end] = this->transformIterator(); + std::set intersections{}; + std::for_each(begin, end, [&rayOrigin, &rayVector, &intersections](const Array3Triplet &otherFace) { + const std::unique_ptr intersection = rayIntersectsTriangle(rayOrigin, rayVector, otherFace); + if (intersection != nullptr) { + intersections.insert(*intersection); + } + }); + return intersections.size(); + } + + std::unique_ptr Polyhedron::rayIntersectsTriangle(const Array3 &rayOrigin, const Array3 &rayVector, const Array3Triplet &triangle) { + // Adapted Möller–Trumbore intersection algorithm + // see https://en.wikipedia.org/wiki/Möller–Trumbore_intersection_algorithm + using namespace util; + const Array3 edge1 = triangle[1] - triangle[0]; + const Array3 edge2 = triangle[2] - triangle[0]; + const Array3 h = cross(rayVector, edge2); + const double a = dot(edge1, h); + if (a > -EPSILON && a < EPSILON) { + return nullptr; + } + + const double f = 1.0 / a; + const Array3 s = rayOrigin - triangle[0]; + const double u = f * dot(s, h); + if (u < 0.0 || u > 1.0) { + return nullptr; + } + + const Array3 q = cross(s, edge1); + const double v = f * dot(rayVector, q); + if (v < 0.0 || u + v > 1.0) { + return nullptr; + } + + const double t = f * dot(edge2, q); + if (t > EPSILON) { + return std::make_unique(rayOrigin + rayVector * t); + } else { + return nullptr; + } + } + +} \ No newline at end of file diff --git a/src/polyhedralGravity/model/Polyhedron.h b/src/polyhedralGravity/model/Polyhedron.h index f5b4f26..7dc98d8 100644 --- a/src/polyhedralGravity/model/Polyhedron.h +++ b/src/polyhedralGravity/model/Polyhedron.h @@ -3,33 +3,34 @@ #include #include #include +#include #include #include #include #include #include #include +#include +#include "thrust/copy.h" +#include "polyhedralGravity/output/Logging.h" +#include "thrust/transform_reduce.h" +#include "thrust/execution_policy.h" +#include "thrust/iterator/counting_iterator.h" #include "polyhedralGravity/model/GravityModelData.h" +#include "thrust/iterator/transform_iterator.h" +#include "polyhedralGravity/util/UtilityContainer.h" +#include "polyhedralGravity/util/UtilityConstants.h" namespace polyhedralGravity { /* Forward declaration of Polyhedron */ class Polyhedron; - /** - * Variant of possible polyhedron sources (composed of members, read from file), but not the polyhedron itself - * @example Utilized in the Python interface which does not expose the Polyhedron class - */ - using PolyhedralFileSource = std::vector; - + /** A polyhedron defined by a set of filenames, as available in {@link TetgenAdapter} */ + using PolyhedralFiles = std::vector; - using PolyhedralDataSource = std::tuple, std::vector>; - - /** - * Variant of possible polyhedral sources (direct, composed of members, read from file), including the polyhedron - * @example Utilized in the C++ implementation of the polyhedral-gravity model - */ - using PolyhedralSource = std::variant; + /** A polyhedron defined by a set of vertices and face indices */ + using PolyhedralSource = std::tuple, std::vector>; /** * Data structure containing the model data of one polyhedron. This includes nodes, edges (faces) and elements. @@ -40,6 +41,8 @@ namespace polyhedralGravity { /** * A vector containing the vertices of the polyhedron. * Each node is an array of size three containing the xyz coordinates. + * The mesh must be scaled in the same units as the density is given + * (the unit must match to the mesh, e.g., mesh in @f$[m]@f$ requires density in @f$[kg/m^3]@f$) */ const std::vector _vertices; @@ -50,49 +53,74 @@ namespace polyhedralGravity { * two nodes. * @example face consisting of {1, 2, 3} --> segments: {1, 2}, {2, 3}, {3, 1} */ - const std::vector _faces; + std::vector _faces; + /** The constant density of the polyhedron (the unit must match to the mesh, e.g., mesh in @f$[m]@f$ requires density in @f$[kg/m^3]@f$) */ + double _density; + + /** + * An optional variable representing the orientation of the polyhedron. + * This variable holds an instance of the NormalOrientation enumeration class, + * which indicates whether the plane unit normals are pointing outwards or inwards. + * To set the orientation of the polyhedron, assign a valid `NormalOrientation` value to this variable. + * If the value is not set, the orientation is considered to be unspecified. + */ + NormalOrientation _orientation; public: /** - * Generates an empty polyhedron. + * Generates a polyhedron from nodes and faces. + * @param vertices a vector of nodes + * @param faces a vector of faces containing the formation of faces off vertices + * @param density the density of the polyhedron (it must match the unit of the mesh, e.g., mesh in @f$[m]@f$ requires density in @f$[kg/m^3]@f$) + * @param orientation specify if the plane unit normals point outwards or inwards (defaults: to OUTWARDS) + * @param integrity specify if the mesh input is checked/ healed to fulfill the constraints of Tsoulis' algorithm (see {@link PolyhedronIntegrity}) + * + * @note ASSERTS PRE-CONDITION that the in the indexing in the faces vector starts with zero! + * @throws std::invalid_argument if no face contains the node zero indicating mathematical index + * @throws std::invalid_argument dpending on the {@param integrity} flag */ - Polyhedron() - : _vertices{}, - _faces{} {} + Polyhedron( + const std::vector &vertices, + const std::vector &faces, + double density, + const NormalOrientation &orientation = NormalOrientation::OUTWARDS, + const PolyhedronIntegrity &integrity = PolyhedronIntegrity::AUTOMATIC + ); /** * Generates a polyhedron from nodes and faces. - * @param nodes vector containing the nodes - * @param faces vector containing the triangle faces. + * @param polyhedralSource a tuple of vector containing the nodes and trianglular faces. + * @param density the density of the polyhedron (it must match the unit of the mesh, e.g., mesh in @f$[m]@f$ requires density in @f$[kg/m^3]@f$) + * @param orientation specify if the plane unit normals point outwards or inwards (defaults: to OUTWARDS) + * @param integrity specify if the mesh input is checked/ healed to fulfill the constraints of Tsoulis' algorithm (see {@link PolyhedronIntegrity}) * * @note ASSERTS PRE-CONDITION that the in the indexing in the faces vector starts with zero! - * @throws runtime_error if no face contains the node zero indicating mathematical index - */ - Polyhedron(std::vector nodes, std::vector faces) - : _vertices{std::move(nodes)}, - _faces{std::move(faces)} { - //Checks that the node with index zero is actually used - if (_faces.end() == std::find_if(_faces.begin(), _faces.end(), [&](auto &face) { - return face[0] == 0 || face[1] == 0 || face[2] == 0; - })) { - throw std::runtime_error("The node with index zero (0) was never used in any face! This is " - "no valid polyhedron. Probable issue: Started numbering the vertices of " - "the polyhedron at one (1)."); - } - } + * @throws std::invalid_argument if no face contains the node zero indicating mathematical index + * @throws std::invalid_argument dpending on the {@param integrity} flag + */ + Polyhedron( + const PolyhedralSource& polyhedralSource, + double density, + const NormalOrientation &orientation = NormalOrientation::OUTWARDS, + const PolyhedronIntegrity &integrity = PolyhedronIntegrity::AUTOMATIC + ); /** - * Creates a polyhedron from a tuple of nodes and faces. - * @param data tuple of nodes and faces + * Generates a polyhedron from nodes and faces. + * @param polyhedralSource a list of files (see {@link TetgenAdapter} or + * @param density the density of the polyhedron (it must match the unit of the mesh, e.g., mesh in @f$[m]@f$ requires density in @f$[kg/m^3]@f$) + * @param orientation specify if the plane unit normals point outwards or inwards (defaults: to OUTWARDS) + * @param integrity specify if the mesh input is checked/ healed to fulfill the constraints of Tsoulis' algorithm (see {@link PolyhedronIntegrity}) * * @note ASSERTS PRE-CONDITION that the in the indexing in the faces vector starts with zero! - * @throws runtime_error if no face contains the node zero indicating mathematical index + * @throws std::invalid_argument if no face contains the node zero indicating mathematical index + * @throws std::invalid_argument dpending on the {@param integrity} flag */ - explicit Polyhedron(const PolyhedralDataSource &data) - : Polyhedron(std::get>(data), std::get>(data)) {} - + Polyhedron(const PolyhedralFiles &polyhedralFiles, double density, + const NormalOrientation &orientation = NormalOrientation::OUTWARDS, + const PolyhedronIntegrity &integrity = PolyhedronIntegrity::AUTOMATIC); /** * Default destructor @@ -103,52 +131,143 @@ namespace polyhedralGravity { * Returns the vertices of this polyhedron * @return vector of cartesian coordinates */ - [[nodiscard]] const std::vector &getVertices() const { - return _vertices; - } + [[nodiscard]] const std::vector &getVertices() const; /** * Returns the vertex at a specific index * @param index size_t * @return cartesian coordinates of the vertex at index */ - [[nodiscard]] const Array3 &getVertex(size_t index) const { - return _vertices[index]; - } + [[nodiscard]] const Array3 &getVertex(size_t index) const; /** * The number of points (nodes) that make up the polyhedron. * @return a size_t */ - [[nodiscard]] size_t countVertices() const { - return _vertices.size(); - } + [[nodiscard]] size_t countVertices() const; /** - * Returns the number of faces (triangles) that make up the polyhedral. - * @return a size_t + * Returns the triangular faces of this polyhedron + * @return vector of triangular faces, where each element size_t references a vertex in the vertices vector */ - [[nodiscard]] size_t countFaces() const { - return _faces.size(); - } + [[nodiscard]] const std::vector &getFaces() const; /** - * Returns the triangular faces of this polyhedron - * @return vector of triangular faces, where each element size_t references a vertex in the vertices vector + * Returns the indices of the vertices making up the face at the given index. + * @param index size_t + * @return triplet of the vertic'es indices forming the face */ - [[nodiscard]] const std::vector &getFaces() const { - return _faces; - } + [[nodiscard]] const IndexArray3 &getFace(size_t index) const; /** * Returns the resolved face with its concrete cartesian coordinates at the given index. * @param index size_t * @return triplet of vertices' cartesian coordinates */ - [[nodiscard]] Array3Triplet getFace(size_t index) const { - return {_vertices[_faces[index][0]], _vertices[_faces[index][1]], _vertices[_faces[index][2]]}; + [[nodiscard]] Array3Triplet getResolvedFace(size_t index) const; + + /** + * Returns the number of faces (triangles) that make up the polyhedral. + * @return a size_t + */ + [[nodiscard]] size_t countFaces() const; + + /** + * Returns the constant density of this polyhedron. + * @return the constant density a double + */ + [[nodiscard]] double getDensity() const; + + /** + * Retruns the plane unit normal orientation factor. + * If the unit normals are outwards pointing, it is 1.0 as Tsoulis inteneded. + * If the unit normals are inwards pointing, it is -1.0 (reversed). + * @return 1.0 or -1.0 depending on plane unit orientation + */ + [[nodiscard]] double getOrientationFactor() const; + + /** + * Returns a string representation of the Polyhedron. + * Mainly used for the representation method in the Python interface. + * + * @return string representation of the Polyhedron + */ + [[nodiscard]] std::string toString() const; + + /** + * An iterator transforming the polyhedron's coordinates on demand by a given offset. + * This function returns a pair of transform iterators (first = begin(), second = end()). + * @param offset the offset to apply + * @return pair of transform iterators + */ + [[nodiscard]] inline auto transformIterator(const Array3 &offset = {0.0, 0.0, 0.0}) const { + //The offset must be captured by value to ensure its lifetime! + const auto lambdaOffsetApplication = [this, offset](const IndexArray3 &face) -> Array3Triplet { + using namespace util; + return {this->getVertex(face[0]) - offset, this->getVertex(face[1]) - offset, + this->getVertex(face[2]) - offset}; + }; + auto first = thrust::make_transform_iterator(this->getFaces().begin(), lambdaOffsetApplication); + auto last = thrust::make_transform_iterator(this->getFaces().end(), lambdaOffsetApplication); + return std::make_pair(first, last); } + private: + /** + * Checks the integrity of the polyhedron depending on the integrity flag. + * + * @param integrity the behavior depends on the value, see {@link PolyhedronIntegrity} + * + * @throws std::invalid_argument dpending on the {@param integrity} flag + */ + void runIntegrityMeasures(const PolyhedronIntegrity &integrity); + + + /** + * Checks if no triangle is degenerated by checking the surface area being greater than zero. + * E.g. two points are the same or all three are collinear. + * @return true if triangles are fine and none of them is degenerate + */ + [[nodiscard]] bool checkTrianglesNotDegenerated() const; + + /** + * This method determines the majority vertex ordering of a polyhedron and the set of faces which + * violate the majority constraint and need to be adpated. + * Hence, if the set is empty, all faces obey to the returned ordering/ plane unit normal orientation. + * + * @return a pair consisting of majority ordering (OUTWARDS or INWARDS pointing normals) + * and a set of face indices which violate the constraint + */ + [[nodiscard]] std::pair> checkPlaneUnitNormalOrientation() const; + + /** + * Fixes the orientation of the plane unit normals for a given set of violating face indices. + * + * @param actualOrientation The desired plane unit normal orientation. + * @param violatingIndices A set of indices representing the faces with violating orientations. + */ + void healPlaneUnitNormalOrientation(const NormalOrientation &actualOrientation, const std::set &violatingIndices); + + /** + * Calculates how often a vector starting at a specific origin intersects a polyhedron's mesh's triangles. + * @param face the vector describing the ray + * @return true if the ray intersects the triangle + */ + [[nodiscard]] size_t countRayPolyhedronIntersections(const Array3Triplet &face) const; + + /** + * Calculates how often a vector starting at a specific origin intersects a triangular face. + * Uses the Möller–Trumbore intersection algorithm. + * @param rayOrigin the origin of the ray + * @param rayVector the vector describing the ray + * @param triangle a triangular face + * @return intersection point or null + * + * @related Adapted from https://en.wikipedia.org/wiki/Möller–Trumbore_intersection_algorithm + */ + static std::unique_ptr rayIntersectsTriangle(const Array3 &rayOrigin, const Array3 &rayVector, const Array3Triplet &triangle); + + }; } diff --git a/src/polyhedralGravity/model/PolyhedronTransform.h b/src/polyhedralGravity/model/PolyhedronTransform.h deleted file mode 100644 index f289272..0000000 --- a/src/polyhedralGravity/model/PolyhedronTransform.h +++ /dev/null @@ -1,29 +0,0 @@ -#pragma once - -#include - -#include "polyhedralGravity/model/Polyhedron.h" -#include "polyhedralGravity/model/GravityModelData.h" -#include "thrust/iterator/transform_iterator.h" - -namespace polyhedralGravity { - - /** - * An iterator transforming the polyhedron's coordinates on demand by a given offset. - * This function returns a pair of transform iterators (first = begin(), second = end()). - * @param polyhedron reference to the polyhedron - * @param offset the offset to apply - * @return pair of transform iterators - */ - inline auto transformPolyhedron(const Polyhedron &polyhedron, const Array3 &offset = {0.0, 0.0, 0.0}) { - //The offset is captured by value to ensure its lifetime! - const auto lambdaOffsetApplication = [&polyhedron, offset](const IndexArray3 &face) -> Array3Triplet { - using namespace util; - return {polyhedron.getVertex(face[0]) - offset, polyhedron.getVertex(face[1]) - offset, - polyhedron.getVertex(face[2]) - offset}; - }; - auto first = thrust::make_transform_iterator(polyhedron.getFaces().begin(), lambdaOffsetApplication); - auto last = thrust::make_transform_iterator(polyhedron.getFaces().end(), lambdaOffsetApplication); - return std::make_pair(first, last); - } -} \ No newline at end of file diff --git a/src/polyhedralGravity/util/UtilityContainer.h b/src/polyhedralGravity/util/UtilityContainer.h index e6a98ed..8554eb3 100644 --- a/src/polyhedralGravity/util/UtilityContainer.h +++ b/src/polyhedralGravity/util/UtilityContainer.h @@ -1,6 +1,7 @@ #pragma once #include +#include #include #include #include @@ -395,14 +396,30 @@ namespace polyhedralGravity::util { */ template std::ostream &operator<<(std::ostream &os, const std::array &array) { - os << "["; - auto it = array.begin(); - auto end = array.end() - 1; - while (it != end) { - os << *it << " "; - ++it; - } - os << *it << "]"; + os.operator<<('['); + os.operator<<(' '); + std::for_each(array.cbegin(), array.cend(), [&os](const auto& arg) { + os << arg << ' '; + }); + os.operator<<(']'); + return os; + } + + /** + * Operator << for a set. + * @tparam T type of the set, must have an << operator overload + * @param os the ostream + * @param set the set itself + * @return ostream + */ + template + std::ostream &operator<<(std::ostream &os, const std::set &set) { + os.operator<<('['); + os.operator<<(' '); + std::for_each(set.cbegin(), set.cend(), [&os](const auto& arg) { + os << arg << ' '; + }); + os.operator<<(']'); return os; } diff --git a/src/polyhedralGravityPython/PolyhedralGravityPython.cpp b/src/polyhedralGravityPython/PolyhedralGravityPython.cpp index bde8b31..b9ec10e 100644 --- a/src/polyhedralGravityPython/PolyhedralGravityPython.cpp +++ b/src/polyhedralGravityPython/PolyhedralGravityPython.cpp @@ -10,7 +10,6 @@ #include "polyhedralGravity/model/GravityModelData.h" #include "polyhedralGravity/model/GravityModel.h" #include "polyhedralGravity/model/GravityEvaluable.h" -#include "polyhedralGravity/model/MeshChecking.h" #include "polyhedralGravity/input/TetgenAdapter.h" From 6522ca7a4c9bfc37f8bea6f53d1c53bffc2aed00 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Tue, 16 Apr 2024 18:20:33 +0200 Subject: [PATCH 13/54] move polyhedron related enums into Polyhedron.h --- .../model/GravityModelData.h | 70 ------------------- src/polyhedralGravity/model/Polyhedron.h | 70 +++++++++++++++++++ 2 files changed, 70 insertions(+), 70 deletions(-) diff --git a/src/polyhedralGravity/model/GravityModelData.h b/src/polyhedralGravity/model/GravityModelData.h index 798574e..0f61aaa 100644 --- a/src/polyhedralGravity/model/GravityModelData.h +++ b/src/polyhedralGravity/model/GravityModelData.h @@ -49,76 +49,6 @@ namespace polyhedralGravity { */ using GravityModelResult = std::tuple; - /** - * The orientation of the plane unit normals of the polyhedron. - * We use this property as the concret definition of the vertices ordering depends on the - * utilized cooridnate system. - * However, the normal alignement is independent. Tsoulis et al. equations require the - * normals to point outwards of the polyhedron. If the opposite hold, the result is - * inverted. - */ - enum class NormalOrientation: char { - /** Outwards pointing plane unit normals*/ - OUTWARDS, - /** Inwards pointing plane unit normals */ - INWWARDS - }; - - - /** - * Overloaded insertion operator to output the string representation of a NormalOrientation enum value. - * - * @param os The output stream to write the string representation to. - * @param orientation The NormalOrientation enum value to output. - * @return The output stream after writing the string representation. - */ - inline std::ostream& operator<<(std::ostream& os, const NormalOrientation& orientation) { - switch (orientation) { - case NormalOrientation::OUTWARDS: - os << "OUTWARDS"; - break; - case NormalOrientation::INWWARDS: - os << "INWARDS"; - break; - default: - os << "Unknown"; - break; - } - return os; - } - - /** - * The three mode the poylhedron class takes in - * the constructor in order to determine what initilaization checks to conduct. - * This enum is exclusivly utilized in the constrcutor of a {@link Polyhedron} and its private method - * {@link runIntegrityMeasures} - */ - enum class PolyhedronIntegrity: char { - /** - * All activities regarding MeshChecking are disabled. - * @note No runtime overhead! - */ - DISABLE, - /** - * Only verification of the NormalOrientation. - * A misalignment (e.g. specified OUTWARDS, but is not) leads to a runtime_error. - * @note Runtime Cost @f$O(n^2)$@f - */ - VERIFY, - /** - * Like VERIFY, but also informs the user about the option in any case on the runtime costs. - * This is the implicit default option. - * @note Runtime Cost: @f$O(n^2)$@f and output to stdout in every case! - */ - AUTOMATIC, - /** - * Verification and Autmatioc Healing of the NormalOrientation. - * A misalignemt does not lead to a runtime_error, but to an internal correction. Cost: @f$O(n^2)$@f - * @note Runtime Cost: @f$O(n^2)$@f and a modification of the mesh input! - */ - HEAL, - }; - /** * Contains the 3D distances l1_pq and l2_pq between P and the endpoints of segment pq and diff --git a/src/polyhedralGravity/model/Polyhedron.h b/src/polyhedralGravity/model/Polyhedron.h index 7dc98d8..15ab0c8 100644 --- a/src/polyhedralGravity/model/Polyhedron.h +++ b/src/polyhedralGravity/model/Polyhedron.h @@ -32,6 +32,76 @@ namespace polyhedralGravity { /** A polyhedron defined by a set of vertices and face indices */ using PolyhedralSource = std::tuple, std::vector>; + /** + * The orientation of the plane unit normals of the polyhedron. + * We use this property as the concret definition of the vertices ordering depends on the + * utilized cooridnate system. + * However, the normal alignement is independent. Tsoulis et al. equations require the + * normals to point outwards of the polyhedron. If the opposite hold, the result is + * inverted. + */ + enum class NormalOrientation: char { + /** Outwards pointing plane unit normals*/ + OUTWARDS, + /** Inwards pointing plane unit normals */ + INWWARDS + }; + + + /** + * Overloaded insertion operator to output the string representation of a NormalOrientation enum value. + * + * @param os The output stream to write the string representation to. + * @param orientation The NormalOrientation enum value to output. + * @return The output stream after writing the string representation. + */ + inline std::ostream& operator<<(std::ostream& os, const NormalOrientation& orientation) { + switch (orientation) { + case NormalOrientation::OUTWARDS: + os << "OUTWARDS"; + break; + case NormalOrientation::INWWARDS: + os << "INWARDS"; + break; + default: + os << "Unknown"; + break; + } + return os; + } + + /** + * The three mode the poylhedron class takes in + * the constructor in order to determine what initilaization checks to conduct. + * This enum is exclusivly utilized in the constrcutor of a {@link Polyhedron} and its private method + * {@link runIntegrityMeasures} + */ + enum class PolyhedronIntegrity: char { + /** + * All activities regarding MeshChecking are disabled. + * @note No runtime overhead! + */ + DISABLE, + /** + * Only verification of the NormalOrientation. + * A misalignment (e.g. specified OUTWARDS, but is not) leads to a runtime_error. + * @note Runtime Cost @f$O(n^2)$@f + */ + VERIFY, + /** + * Like VERIFY, but also informs the user about the option in any case on the runtime costs. + * This is the implicit default option. + * @note Runtime Cost: @f$O(n^2)$@f and output to stdout in every case! + */ + AUTOMATIC, + /** + * Verification and Autmatioc Healing of the NormalOrientation. + * A misalignemt does not lead to a runtime_error, but to an internal correction. Cost: @f$O(n^2)$@f + * @note Runtime Cost: @f$O(n^2)$@f and a modification of the mesh input! + */ + HEAL, + }; + /** * Data structure containing the model data of one polyhedron. This includes nodes, edges (faces) and elements. * The index always starts with zero! From 35a56d258d2f44f4bd9d53df1f0c9514f5b345db Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Tue, 16 Apr 2024 21:42:19 +0200 Subject: [PATCH 14/54] adapt test cases --- src/main.cpp | 2 +- src/polyhedralGravity/input/DataSource.h | 2 +- src/polyhedralGravity/input/TetgenAdapter.cpp | 2 +- src/polyhedralGravity/input/TetgenAdapter.h | 2 +- .../model/GravityEvaluable.cpp | 2 +- src/polyhedralGravity/model/Polyhedron.cpp | 83 ++--- src/polyhedralGravity/model/Polyhedron.h | 32 +- .../PolyhedralGravityPython.cpp | 4 +- test/input/TetgenAdapterTest.cpp | 42 +-- test/model/GravityModelBigTest.cpp | 9 +- test/model/GravityModelCubeTest.cpp | 59 ++-- test/model/GravityModelTest.cpp | 235 ++++++------- test/model/GravityModelVectorUtility.cpp | 14 +- test/model/MeshCheckingTest.cpp | 263 --------------- test/model/PolyhedronTest.cpp | 312 ++++++++++++++++++ 15 files changed, 567 insertions(+), 496 deletions(-) delete mode 100644 test/model/MeshCheckingTest.cpp create mode 100644 test/model/PolyhedronTest.cpp diff --git a/src/main.cpp b/src/main.cpp index ce860e9..4d173af 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -16,7 +16,7 @@ int main(int argc, char *argv[]) { try { std::shared_ptr config = std::make_shared(argv[1]); - auto polyhedralSource = config->getDataSource()->getPolyhedron(); + auto polyhedralSource = config->getDataSource()->getPolyhedralSource(); auto density = config->getDensity(); auto computationPoints = config->getPointsOfInterest(); auto outputFileName = config->getOutputFileName(); diff --git a/src/polyhedralGravity/input/DataSource.h b/src/polyhedralGravity/input/DataSource.h index e3232e7..d01d8c0 100644 --- a/src/polyhedralGravity/input/DataSource.h +++ b/src/polyhedralGravity/input/DataSource.h @@ -21,7 +21,7 @@ namespace polyhedralGravity { * Returns a Polyhedron from the underlying source. * @return a polyhedron */ - virtual std::tuple, std::vector> getPolyhedron() = 0; + virtual std::tuple, std::vector> getPolyhedralSource() = 0; }; diff --git a/src/polyhedralGravity/input/TetgenAdapter.cpp b/src/polyhedralGravity/input/TetgenAdapter.cpp index 895e282..cc8a003 100644 --- a/src/polyhedralGravity/input/TetgenAdapter.cpp +++ b/src/polyhedralGravity/input/TetgenAdapter.cpp @@ -2,7 +2,7 @@ namespace polyhedralGravity { - std::tuple, std::vector> TetgenAdapter::getPolyhedron() { + std::tuple, std::vector> TetgenAdapter::getPolyhedralSource() { //1. Step: Read in from files for (const auto &fileName: _fileNames) { size_t pos = fileName.find_last_of('.'); diff --git a/src/polyhedralGravity/input/TetgenAdapter.h b/src/polyhedralGravity/input/TetgenAdapter.h index 19a6d36..a088e61 100644 --- a/src/polyhedralGravity/input/TetgenAdapter.h +++ b/src/polyhedralGravity/input/TetgenAdapter.h @@ -72,7 +72,7 @@ namespace polyhedralGravity { * converted to a Polyhedron. * @return a Polyhedron */ - std::tuple, std::vector> getPolyhedron() override; + std::tuple, std::vector> getPolyhedralSource() override; /** * Reads nodes from a .node file diff --git a/src/polyhedralGravity/model/GravityEvaluable.cpp b/src/polyhedralGravity/model/GravityEvaluable.cpp index 23523e0..946ab7a 100644 --- a/src/polyhedralGravity/model/GravityEvaluable.cpp +++ b/src/polyhedralGravity/model/GravityEvaluable.cpp @@ -35,7 +35,7 @@ namespace polyhedralGravity { using namespace util; SPDLOG_LOGGER_DEBUG(PolyhedralGravityLogger::DEFAULT_LOGGER.getLogger(), "Evaluation for computation point P = [{}, {}, {}] started, given density = {} kg/m^3", - computationPoint[0], computationPoint[1], computationPoint[2], _density); + computationPoint[0], computationPoint[1], computationPoint[2], _polyhedron.getDensity()); /* * Calculate V and Vx, Vy, Vz and Vxx, Vyy, Vzz, Vxy, Vxz, Vyz */ diff --git a/src/polyhedralGravity/model/Polyhedron.cpp b/src/polyhedralGravity/model/Polyhedron.cpp index 707cda6..86b9cac 100644 --- a/src/polyhedralGravity/model/Polyhedron.cpp +++ b/src/polyhedralGravity/model/Polyhedron.cpp @@ -26,7 +26,7 @@ namespace polyhedralGravity { : Polyhedron{std::get>(polyhedralSource), std::get>(polyhedralSource), density, orientation, integrity} {} Polyhedron::Polyhedron(const PolyhedralFiles &polyhedralFiles, double density, const NormalOrientation &orientation, const PolyhedronIntegrity &integrity) - : Polyhedron{TetgenAdapter{polyhedralFiles}.getPolyhedron(), density, orientation, integrity} {} + : Polyhedron{TetgenAdapter{polyhedralFiles}.getPolyhedralSource(), density, orientation, integrity} {} const std::vector &Polyhedron::getVertices() const { return _vertices; @@ -60,6 +60,14 @@ namespace polyhedralGravity { return _density; } + void Polyhedron::setDensity(double density) { + _density = density; + } + + NormalOrientation Polyhedron::getOrientation() const { + return _orientation; + } + double Polyhedron::getOrientationFactor() const { return _orientation == NormalOrientation::OUTWARDS ? 1.0 : -1.0; } @@ -72,6 +80,41 @@ namespace polyhedralGravity { } + std::pair> Polyhedron::checkPlaneUnitNormalOrientation() const { + // 1. Step: Find all indices of normals which vioate the constraint outwards pointing + auto indexIterator = thrust::make_counting_iterator(0); + size_t numberOfFaces = this->countFaces(); + std::set violatingOutwards{}; + thrust::copy_if( + thrust::device, + indexIterator, + indexIterator + numberOfFaces, + std::inserter(violatingOutwards, violatingOutwards.end()), + [this](const size_t index) { + // If the ray intersects the polyhedron odd number if times the normal points inwards + // Hence, violating the OUTWARDS constraint + const size_t intersects = countRayPolyhedronIntersections(this->getResolvedFace(index)); + return intersects % 2 != 0; + }); + // 2. Step: If we have more than n/2 violations, the majority is inwards pointing --> Build complemntary set! + if (violatingOutwards.size() > numberOfFaces / 2) { + std::set fullSet{}; + std::copy_n(indexIterator, numberOfFaces, std::inserter(fullSet, fullSet.end())); + std::set violatingInwards{}; + std::set_difference( + fullSet.begin(), fullSet.end(), + violatingOutwards.begin(), violatingOutwards.end(), + std::inserter(violatingInwards, violatingInwards.end()) + ); + // 3a. Step: Return the inwards pointing as major orientation and + // the violating faces, i.e. which have outwards pointing normals + return std::make_pair(NormalOrientation::INWWARDS, violatingInwards); + } + // 3b. Step: Return the outwards pointing as major orientation + // and the violating faces, i.e. which have inwards pointing normals + return std::make_pair(NormalOrientation::OUTWARDS, violatingOutwards); + } + void Polyhedron::runIntegrityMeasures(const PolyhedronIntegrity &integrity) { using util::operator<<; switch (integrity) { @@ -105,7 +148,8 @@ namespace polyhedralGravity { << violatingIndices << '\n' << "2) Or you reconstruct the polyhedron using the integrity check set to HEAL."; } - if (integrity == PolyhedronIntegrity::VERIFY) { + // In case of HEAL, don't throw but repair + if (integrity != PolyhedronIntegrity::HEAL) { throw std::invalid_argument(sstream.str()); } else { this->healPlaneUnitNormalOrientation(actualOrientation, violatingIndices); @@ -124,41 +168,6 @@ namespace polyhedralGravity { }, true, thrust::logical_and()); } - std::pair> Polyhedron::checkPlaneUnitNormalOrientation() const { - // 1. Step: Find all indices of normals which vioate the constraint outwards pointing - auto indexIterator = thrust::make_counting_iterator(0); - size_t numberOfFaces = this->countFaces(); - std::set violatingOutwards{}; - thrust::copy_if( - thrust::device, - indexIterator, - indexIterator + numberOfFaces, - std::inserter(violatingOutwards, violatingOutwards.end()), - [this](const size_t index) { - // If the ray intersects the polyhedron odd number if times the normal points inwards - // Hence, violating the OUTWARDS constraint - const size_t intersects = countRayPolyhedronIntersections(this->getResolvedFace(index)); - return intersects % 2 != 0; - }); - // 2. Step: If we have more than n/2 violations, the majority is inwards pointing --> Build complemntary set! - if (violatingOutwards.size() > numberOfFaces / 2) { - std::set fullSet{}; - std::copy_n(indexIterator, numberOfFaces, std::inserter(fullSet, fullSet.end())); - std::set violatingInwards{}; - std::set_difference( - fullSet.begin(), fullSet.end(), - violatingOutwards.begin(), violatingOutwards.end(), - std::inserter(violatingInwards, violatingInwards.end()) - ); - // 3a. Step: Return the inwards pointing as major orientation and - // the violating faces, i.e. which have outwards pointing normals - return std::make_pair(NormalOrientation::INWWARDS, violatingInwards); - } - // 3b. Step: Return the outwards pointing as major orientation - // and the violating faces, i.e. which have inwards pointing normals - return std::make_pair(NormalOrientation::OUTWARDS, violatingOutwards); - } - void Polyhedron::healPlaneUnitNormalOrientation(const NormalOrientation &actualOrientation, const std::set &violatingIndices) { // Assign the majority plane unit normal orientation _orientation = actualOrientation; diff --git a/src/polyhedralGravity/model/Polyhedron.h b/src/polyhedralGravity/model/Polyhedron.h index 15ab0c8..1a6590c 100644 --- a/src/polyhedralGravity/model/Polyhedron.h +++ b/src/polyhedralGravity/model/Polyhedron.h @@ -248,6 +248,18 @@ namespace polyhedralGravity { */ [[nodiscard]] double getDensity() const; + /** + * Sets the density to a new value. The density's unit must match to the scaling of the mesh. + * @param density the new constant density of the polyhedron + */ + void setDensity(double density); + + /** + * Returns the orientation of the plane unit normals of this polyhedron + * @return OUTWARDS or INWARDS + */ + [[nodiscard]] NormalOrientation getOrientation() const; + /** * Retruns the plane unit normal orientation factor. * If the unit normals are outwards pointing, it is 1.0 as Tsoulis inteneded. @@ -282,6 +294,16 @@ namespace polyhedralGravity { return std::make_pair(first, last); } + /** + * This method determines the majority vertex ordering of a polyhedron and the set of faces which + * violate the majority constraint and need to be adpated. + * Hence, if the set is empty, all faces obey to the returned ordering/ plane unit normal orientation. + * + * @return a pair consisting of majority ordering (OUTWARDS or INWARDS pointing normals) + * and a set of face indices which violate the constraint + */ + [[nodiscard]] std::pair> checkPlaneUnitNormalOrientation() const; + private: /** * Checks the integrity of the polyhedron depending on the integrity flag. @@ -300,16 +322,6 @@ namespace polyhedralGravity { */ [[nodiscard]] bool checkTrianglesNotDegenerated() const; - /** - * This method determines the majority vertex ordering of a polyhedron and the set of faces which - * violate the majority constraint and need to be adpated. - * Hence, if the set is empty, all faces obey to the returned ordering/ plane unit normal orientation. - * - * @return a pair consisting of majority ordering (OUTWARDS or INWARDS pointing normals) - * and a set of face indices which violate the constraint - */ - [[nodiscard]] std::pair> checkPlaneUnitNormalOrientation() const; - /** * Fixes the orientation of the plane unit normals for a given set of violating face indices. * diff --git a/src/polyhedralGravityPython/PolyhedralGravityPython.cpp b/src/polyhedralGravityPython/PolyhedralGravityPython.cpp index b9ec10e..0545901 100644 --- a/src/polyhedralGravityPython/PolyhedralGravityPython.cpp +++ b/src/polyhedralGravityPython/PolyhedralGravityPython.cpp @@ -113,7 +113,7 @@ PYBIND11_MODULE(polyhedral_gravity, m) { utility.def("read", [](const std::vector &filenames) { TetgenAdapter tetgen{filenames}; - auto polyhedron = tetgen.getPolyhedron(); + auto polyhedron = tetgen.getPolyhedralSource(); return std::make_tuple(polyhedron.getVertices(), polyhedron.getFaces()); }, R"mydelimiter( Reads a polyhedron from a mesh file. The vertices and faces are read from input @@ -143,7 +143,7 @@ PYBIND11_MODULE(polyhedral_gravity, m) { utility.def("check_mesh", [](const std::vector &filenames) { TetgenAdapter tetgen{filenames}; - Polyhedron poly = tetgen.getPolyhedron(); + Polyhedron poly = tetgen.getPolyhedralSource(); return MeshChecking::checkTrianglesNotDegenerated(poly) && MeshChecking::checkPlaneUnitNormalOrientation(poly); }, R"mydelimiter( Checks if no triangles of the polyhedral mesh are degenerated by checking that their surface area diff --git a/test/input/TetgenAdapterTest.cpp b/test/input/TetgenAdapterTest.cpp index cba98e0..0459b6a 100644 --- a/test/input/TetgenAdapterTest.cpp +++ b/test/input/TetgenAdapterTest.cpp @@ -9,7 +9,7 @@ class TetgenAdapterTest : public ::testing::Test { protected: - std::vector> _expectedNodes = { + std::vector> _expectedVertices = { {-20, 0, 25}, {0, 0, 25}, {0, 10, 25}, @@ -47,9 +47,9 @@ TEST_F(TetgenAdapterTest, readSimpleNode) { }; TetgenAdapter tetgenAdapter{simpleFiles}; - auto actualPolyhedron = tetgenAdapter.getPolyhedron(); + const auto&[actualVertices, actualFaces] = tetgenAdapter.getPolyhedralSource(); - ASSERT_THAT(actualPolyhedron.getVertices(), ContainerEq(_expectedNodes)); + ASSERT_THAT(actualVertices, ContainerEq(_expectedVertices)); } @@ -63,9 +63,9 @@ TEST_F(TetgenAdapterTest, readSimpleFace) { }; TetgenAdapter tetgenAdapter{simpleFiles}; - auto actualPolyhedron = tetgenAdapter.getPolyhedron(); + const auto&[actualVertices, actualFaces] = tetgenAdapter.getPolyhedralSource(); - ASSERT_THAT(actualPolyhedron.getFaces(), ContainerEq(_expectedFaces)); + ASSERT_THAT(actualFaces, ContainerEq(_expectedFaces)); } TEST_F(TetgenAdapterTest, readSimpleMesh) { @@ -75,12 +75,12 @@ TEST_F(TetgenAdapterTest, readSimpleMesh) { std::vector simpleFiles{"resources/TetgenAdapterTestReadSimple.mesh"}; TetgenAdapter tetgenAdapter{simpleFiles}; - auto actualPolyhedron = tetgenAdapter.getPolyhedron(); + const auto&[actualVertices, actualFaces] = tetgenAdapter.getPolyhedralSource(); - for (const auto &actualVertice: actualPolyhedron.getVertices()) { - ASSERT_THAT(_expectedNodes, Contains(actualVertice)); + for (const auto &actualVertice: actualVertices) { + ASSERT_THAT(_expectedVertices, Contains(actualVertice)); } - ASSERT_EQ(_expectedFaces.size(), actualPolyhedron.countFaces()); + ASSERT_EQ(_expectedFaces.size(), actualFaces.size()); } TEST_F(TetgenAdapterTest, readSimpleOff) { @@ -90,12 +90,12 @@ TEST_F(TetgenAdapterTest, readSimpleOff) { std::vector simpleFiles{"resources/TetgenAdapterTestReadSimple.off"}; TetgenAdapter tetgenAdapter{simpleFiles}; - auto actualPolyhedron = tetgenAdapter.getPolyhedron(); + const auto&[actualVertices, actualFaces] = tetgenAdapter.getPolyhedralSource(); - for (const auto &actualVertice: actualPolyhedron.getVertices()) { - ASSERT_THAT(_expectedNodes, Contains(actualVertice)); + for (const auto &actualVertice: actualVertices) { + ASSERT_THAT(_expectedVertices, Contains(actualVertice)); } - ASSERT_EQ(_expectedFaces.size(), actualPolyhedron.countFaces()); + ASSERT_EQ(_expectedFaces.size(), actualFaces.size()); } TEST_F(TetgenAdapterTest, readSimplePly) { @@ -105,12 +105,12 @@ TEST_F(TetgenAdapterTest, readSimplePly) { std::vector simpleFiles{"resources/TetgenAdapterTestReadSimple.ply"}; TetgenAdapter tetgenAdapter{simpleFiles}; - auto actualPolyhedron = tetgenAdapter.getPolyhedron(); + const auto&[actualVertices, actualFaces] = tetgenAdapter.getPolyhedralSource(); - for (const auto &actualVertice: actualPolyhedron.getVertices()) { - ASSERT_THAT(_expectedNodes, Contains(actualVertice)); + for (const auto &actualVertice: actualVertices) { + ASSERT_THAT(_expectedVertices, Contains(actualVertice)); } - ASSERT_EQ(_expectedFaces.size(), actualPolyhedron.countFaces()); + ASSERT_EQ(_expectedFaces.size(), actualFaces.size()); } TEST_F(TetgenAdapterTest, readSimpleStl) { @@ -120,10 +120,10 @@ TEST_F(TetgenAdapterTest, readSimpleStl) { std::vector simpleFiles{"resources/TetgenAdapterTestReadSimple.stl"}; TetgenAdapter tetgenAdapter{simpleFiles}; - auto actualPolyhedron = tetgenAdapter.getPolyhedron(); + const auto&[actualVertices, actualFaces] = tetgenAdapter.getPolyhedralSource(); - for (const auto &actualVertice: actualPolyhedron.getVertices()) { - ASSERT_THAT(_expectedNodes, Contains(actualVertice)); + for (const auto &actualVertice: actualVertices) { + ASSERT_THAT(_expectedVertices, Contains(actualVertice)); } - ASSERT_EQ(_expectedFaces.size(), actualPolyhedron.countFaces()); + ASSERT_EQ(_expectedFaces.size(), actualFaces.size()); } \ No newline at end of file diff --git a/test/model/GravityModelBigTest.cpp b/test/model/GravityModelBigTest.cpp index bf35768..4de0482 100644 --- a/test/model/GravityModelBigTest.cpp +++ b/test/model/GravityModelBigTest.cpp @@ -6,8 +6,6 @@ #include #include #include -#include -#include "polyhedralGravity/input/TetgenAdapter.h" #include "polyhedralGravity/model/GravityModel.h" #include "polyhedralGravity/model/Polyhedron.h" @@ -35,8 +33,11 @@ class GravityModelBigTest : public ::testing::Test { static constexpr size_t LOCAL_TEST_COUNT_NODES_PER_FACE = 3; polyhedralGravity::Polyhedron _polyhedron{ - polyhedralGravity::TetgenAdapter{ - {"resources/GravityModelBigTest.node", "resources/GravityModelBigTest.face"}}.getPolyhedron()}; + std::vector{"resources/GravityModelBigTest.node", "resources/GravityModelBigTest.face"}, + 1.0, + polyhedralGravity::NormalOrientation::OUTWARDS, + polyhedralGravity::PolyhedronIntegrity::DISABLE + }; std::array _computationPoint{0.0, 0.0, 0.0}; diff --git a/test/model/GravityModelCubeTest.cpp b/test/model/GravityModelCubeTest.cpp index b562418..536357f 100644 --- a/test/model/GravityModelCubeTest.cpp +++ b/test/model/GravityModelCubeTest.cpp @@ -8,7 +8,6 @@ #include #include #include -#include #include "polyhedralGravity/model/GravityModel.h" #include "polyhedralGravity/model/Polyhedron.h" @@ -20,37 +19,38 @@ class GravityModelCubeTest : public ::testing::TestWithParam, double, double, std::array>> { protected: - /** * Small epsilon since we compare to ground truth */ static constexpr double LOCAL_TEST_EPSILON = 1e-20; - const polyhedralGravity::Polyhedron _cube{{ - {-1.0, -1.0, -1.0}, - {1.0, -1.0, -1.0}, - {1.0, 1.0, -1.0}, - {-1.0, 1.0, -1.0}, - {-1.0, -1.0, 1.0}, - {1.0, -1.0, 1.0}, - {1.0, 1.0, 1.0}, - {-1.0, 1.0, 1.0}}, - { - {1, 3, 2}, - {0, 3, 1}, - {0, 1, 5}, - {0, 5, 4}, - {0, 7, 3}, - {0, 4, 7}, - {1, 2, 6}, - {1, 6, 5}, - {2, 3, 6}, - {3, 7, 6}, - {4, 5, 6}, - {4, 6, 7}} + polyhedralGravity::Polyhedron _cube{std::vector{ + {-1.0, -1.0, -1.0}, + {1.0, -1.0, -1.0}, + {1.0, 1.0, -1.0}, + {-1.0, 1.0, -1.0}, + {-1.0, -1.0, 1.0}, + {1.0, -1.0, 1.0}, + {1.0, 1.0, 1.0}, + {-1.0, 1.0, 1.0}}, + std::vector{ + {1, 3, 2}, + {0, 3, 1}, + {0, 1, 5}, + {0, 5, 4}, + {0, 7, 3}, + {0, 4, 7}, + {1, 2, 6}, + {1, 6, 5}, + {2, 3, 6}, + {3, 7, 6}, + {4, 5, 6}, + {4, 6, 7}}, + 1.0, + polyhedralGravity::NormalOrientation::OUTWARDS, + polyhedralGravity::PolyhedronIntegrity::DISABLE }; public: - [[nodiscard]] static std::vector, double, double, std::array>> readCubePoints(const std::string &filename) { std::vector, double, double, std::array>> result{}; @@ -76,8 +76,6 @@ class GravityModelCubeTest : } - - }; TEST_P(GravityModelCubeTest, CubePoints) { @@ -90,7 +88,8 @@ TEST_P(GravityModelCubeTest, CubePoints) { double expectedPotential = std::get<2>(testData); std::array expectedAcceleration = std::get<3>(testData); - const auto[actualPotential, actualAcceleration, x] = GravityModel::evaluate(_cube, density, computationPoint); + _cube.setDensity(density); + const auto [actualPotential, actualAcceleration, x] = GravityModel::evaluate(_cube, computationPoint); ASSERT_NEAR(actualPotential, expectedPotential, LOCAL_TEST_EPSILON); ASSERT_THAT(actualAcceleration, Pointwise(DoubleNear(LOCAL_TEST_EPSILON), expectedAcceleration)); @@ -98,8 +97,8 @@ TEST_P(GravityModelCubeTest, CubePoints) { INSTANTIATE_TEST_SUITE_P(CubeGravityModelTest01, GravityModelCubeTest, ::testing::ValuesIn( - GravityModelCubeTest::readCubePoints("resources/analytic_cube_solution_density1.txt"))); + GravityModelCubeTest::readCubePoints("resources/analytic_cube_solution_density1.txt"))); INSTANTIATE_TEST_SUITE_P(CubeGravityModelTest42, GravityModelCubeTest, ::testing::ValuesIn( - GravityModelCubeTest::readCubePoints("resources/analytic_cube_solution_density42.txt"))); + GravityModelCubeTest::readCubePoints("resources/analytic_cube_solution_density42.txt"))); diff --git a/test/model/GravityModelTest.cpp b/test/model/GravityModelTest.cpp index 81008a8..418369a 100644 --- a/test/model/GravityModelTest.cpp +++ b/test/model/GravityModelTest.cpp @@ -16,7 +16,6 @@ class GravityModelTest : public ::testing::Test { protected: - /** * Relative big epsilon due to deviations between FORTRAN implementation and C++ implementation */ @@ -24,31 +23,34 @@ class GravityModelTest : public ::testing::Test { //New polyhedron with given vertices and faces //this is the base example from Tsoulis - polyhedralGravity::Polyhedron _polyhedron{ - { - {-20, 0, 25}, - {0, 0, 25}, - {0, 10, 25}, - {-20, 10, 25}, - {-20, 0, 15}, - {0, 0, 15}, - {0, 10, 15}, - {-20, 10, 15} - }, - { - {0, 1, 3}, - {1, 2, 3}, - {0, 4, 5}, - {0, 5, 1}, - {0, 7, 4}, - {0, 3, 7}, - {1, 5, 6}, - {1, 6, 2}, - {3, 6, 7}, - {2, 6, 3}, - {4, 6, 5}, - {4, 7, 6} - } + polyhedralGravity::Polyhedron _polyhedron { + std::vector{ + {-20, 0, 25}, + {0, 0, 25}, + {0, 10, 25}, + {-20, 10, 25}, + {-20, 0, 15}, + {0, 0, 15}, + {0, 10, 15}, + {-20, 10, 15} + }, + std::vector{ + {0, 1, 3}, + {1, 2, 3}, + {0, 4, 5}, + {0, 5, 1}, + {0, 7, 4}, + {0, 3, 7}, + {1, 5, 6}, + {1, 6, 2}, + {3, 6, 7}, + {2, 6, 3}, + {4, 6, 5}, + {4, 7, 6} + }, + 1.0, + polyhedralGravity::NormalOrientation::OUTWARDS, + polyhedralGravity::PolyhedronIntegrity::DISABLE }; std::array _computationPoint{0.0, 0.0, 0.0}; @@ -69,18 +71,18 @@ class GravityModelTest : public ::testing::Test { }; std::vector> expectedPlaneUnitNormals{ - {0.0, -0.0, 1.0}, - {0.0, -0.0, 1.0}, - {0.0, -1.0, 0.0}, - {0.0, -1.0, 0.0}, + {0.0, -0.0, 1.0}, + {0.0, -0.0, 1.0}, + {0.0, -1.0, 0.0}, + {0.0, -1.0, 0.0}, {-1.0, -0.0, -0.0}, - {-1.0, 0.0, 0.0}, - {1.0, -0.0, 0.0}, - {1.0, -0.0, 0.0}, - {0.0, 1.0, 0.0}, - {0.0, 1.0, 0.0}, - {0.0, 0.0, -1.0}, - {0.0, 0.0, -1.0} + {-1.0, 0.0, 0.0}, + {1.0, -0.0, 0.0}, + {1.0, -0.0, 0.0}, + {0.0, 1.0, 0.0}, + {0.0, 1.0, 0.0}, + {0.0, 0.0, -1.0}, + {0.0, 0.0, -1.0} }; std::vector, 3>> expectedSegmentUnitNormals{ @@ -113,18 +115,18 @@ class GravityModelTest : public ::testing::Test { std::vector expectedPlaneNormalOrientations{1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, -1.0, -1.0}; std::vector expectedHessianPlanes{ - {0.0, 0.0, 200.0, -5000.0}, - {0.0, -0.0, 200.0, -5000.0}, - {0.0, -200.0, 0.0, 0.0}, - {0.0, -200.0, 0.0, 0.0}, - {-100.0, 0.0, 0.0, -2000.0}, - {-100.0, 0.0, 0.0, -2000.0}, - {100.0, 0.0, 0.0, -0.0}, - {100.0, -0.0, 0.0, 0.0}, - {0.0, 200.0, 0.0, -2000.0}, - {0.0, 200.0, 0.0, -2000.0}, - {0.0, 0.0, -200.0, 3000.0}, - {0.0, 0.0, -200.0, 3000.0} + {0.0, 0.0, 200.0, -5000.0}, + {0.0, -0.0, 200.0, -5000.0}, + {0.0, -200.0, 0.0, 0.0}, + {0.0, -200.0, 0.0, 0.0}, + {-100.0, 0.0, 0.0, -2000.0}, + {-100.0, 0.0, 0.0, -2000.0}, + {100.0, 0.0, 0.0, -0.0}, + {100.0, -0.0, 0.0, 0.0}, + {0.0, 200.0, 0.0, -2000.0}, + {0.0, 200.0, 0.0, -2000.0}, + {0.0, 0.0, -200.0, 3000.0}, + {0.0, 0.0, -200.0, 3000.0} }; std::vector expectedPlaneDistances{25.0, @@ -141,33 +143,33 @@ class GravityModelTest : public ::testing::Test { 15.0}; std::vector> expectedOrthogonalProjectionPointsOnPlane{ - {0.0, 0.0, 25.0}, - {0.0, 0.0, 25.0}, - {0.0, 0.0, 0.0}, - {0.0, 0.0, 0.0}, - {-20.0, 0.0, 0.0}, - {-20.0, 0.0, 0.0}, - {0.0, 0.0, 0.0}, - {0.0, 0.0, 0.0}, - {0.0, 10.0, 0.0}, - {0.0, 10.0, 0.0}, - {0.0, 0.0, 15.0}, - {0.0, 0.0, 15.0} + {0.0, 0.0, 25.0}, + {0.0, 0.0, 25.0}, + {0.0, 0.0, 0.0}, + {0.0, 0.0, 0.0}, + {-20.0, 0.0, 0.0}, + {-20.0, 0.0, 0.0}, + {0.0, 0.0, 0.0}, + {0.0, 0.0, 0.0}, + {0.0, 10.0, 0.0}, + {0.0, 10.0, 0.0}, + {0.0, 0.0, 15.0}, + {0.0, 0.0, 15.0} }; std::vector> expectedSegmentNormalOrientations{ - {0.0, 0.0, 1.0}, - {0.0, 1.0, 0.0}, - {1.0, -1.0, 1.0}, - {-1.0, 0.0, 1.0}, - {1.0, -1.0, 0.0}, - {1.0, 1.0, -1.0}, - {0.0, -1.0, 1.0}, - {-1.0, 1.0, 1.0}, - {1.0, -1.0, 1.0}, - {0.0, -1.0, 1.0}, - {1.0, 0.0, 0.0}, - {1.0, 1.0, -1.0} + {0.0, 0.0, 1.0}, + {0.0, 1.0, 0.0}, + {1.0, -1.0, 1.0}, + {-1.0, 0.0, 1.0}, + {1.0, -1.0, 0.0}, + {1.0, 1.0, -1.0}, + {0.0, -1.0, 1.0}, + {-1.0, 1.0, 1.0}, + {1.0, -1.0, 1.0}, + {0.0, -1.0, 1.0}, + {1.0, 0.0, 0.0}, + {1.0, 1.0, -1.0} }; std::vector, 3>> expectedOrthogonalProjectionPointsOnSegment{ @@ -186,18 +188,18 @@ class GravityModelTest : public ::testing::Test { }; std::vector> expectedSegmentDistances{ - {0.0, 0.0, 20.0}, - {0.0, 10.0, 0.0}, - {20.0, 15.0, 13.416407864998739}, - {13.416407864998739, 0.0, 25.0}, - {17.67766952966369, 15.0, 0.0}, - {25.0, 10.0, 17.67766952966369}, - {0.0, 15.0, 17.67766952966369}, - {17.67766952966369, 10.0, 25.0}, - {13.416407864998739, 15.0, 20.0}, - {0.0, 13.416407864998739, 25.0}, - {8.94427190999916, 0.0, 0.0}, - {20.0, 10.0, 8.94427190999916} + {0.0, 0.0, 20.0}, + {0.0, 10.0, 0.0}, + {20.0, 15.0, 13.416407864998739}, + {13.416407864998739, 0.0, 25.0}, + {17.67766952966369, 15.0, 0.0}, + {25.0, 10.0, 17.67766952966369}, + {0.0, 15.0, 17.67766952966369}, + {17.67766952966369, 10.0, 25.0}, + {13.416407864998739, 15.0, 20.0}, + {0.0, 13.416407864998739, 25.0}, + {8.94427190999916, 0.0, 0.0}, + {20.0, 10.0, 8.94427190999916} }; std::vector, 3>> expected3DDistancesPerSegmentEndpoint{ @@ -254,33 +256,33 @@ class GravityModelTest : public ::testing::Test { std::vector> expectedDistancesPerSegmentEndpoint; std::vector> expectedTranscendentalLN{ - {0.0, 0.0, 0.30747952872839945}, - {0.0, 0.687362255356451, 0.0}, - {0.3544458320893136, 1.0986122886681098, 1.0345679811316213}, - {1.034567981131622, 0.5108256237659907, 0.7326682560454109}, - {0.4894110007366263, 0.3900353197707153, 0.3544458320893134}, + {0.0, 0.0, 0.30747952872839945}, + {0.0, 0.687362255356451, 0.0}, + {0.3544458320893136, 1.0986122886681098, 1.0345679811316213}, + {1.034567981131622, 0.5108256237659907, 0.7326682560454109}, + {0.4894110007366263, 0.3900353197707153, 0.3544458320893134}, {0.3074795287283993, 0.33382573681901684, 0.4894110007366262}, - {-0.510825623765990, 0.6251451172504167, 0.6826834766703017}, - {0.6826834766703017, 0.4524679290839864, 0.3900353197707153}, - {0.9286653985398196, 0.9566555518497877, 0.33382573681901667}, - {0.4524679290839866, 0.928665398539819, 0.6873622553564511}, - {1.1518034938098078, 0.0, 0.0}, - {0.3900353197707153, 0.9566555518497877, 1.1518034938098078} + {-0.510825623765990, 0.6251451172504167, 0.6826834766703017}, + {0.6826834766703017, 0.4524679290839864, 0.3900353197707153}, + {0.9286653985398196, 0.9566555518497877, 0.33382573681901667}, + {0.4524679290839866, 0.928665398539819, 0.6873622553564511}, + {1.1518034938098078, 0.0, 0.0}, + {0.3900353197707153, 0.9566555518497877, 1.1518034938098078} }; std::vector> expectedTranscendentalAN{ - {0.0, 0.0, 0.3567333885140938}, - {0.0, 0.9799235766494776, 0.0}, - {0.0, 0.0, 0.0}, - {0.0, 0.0, 0.0}, - {0.4109023045514107, 0.45979025757734426, 0.0}, - {0.23413936163132537, 0.1405746311094993, 0.4109023045514107}, - {0.0, 0.0, 0.0}, - {0.0, 0.0, 0.0}, - {0.3029908626228055, 0.45979025757734426, 0.08507626483651975}, - {0.0, 0.3029908626228055, 0.23413936163132537}, - {1.2703024256629791, 0.0, 0.0}, - {0.27165712367757405, 0.8393489455399783, 1.2703024256629791} + {0.0, 0.0, 0.3567333885140938}, + {0.0, 0.9799235766494776, 0.0}, + {0.0, 0.0, 0.0}, + {0.0, 0.0, 0.0}, + {0.4109023045514107, 0.45979025757734426, 0.0}, + {0.23413936163132537, 0.1405746311094993, 0.4109023045514107}, + {0.0, 0.0, 0.0}, + {0.0, 0.0, 0.0}, + {0.3029908626228055, 0.45979025757734426, 0.08507626483651975}, + {0.0, 0.3029908626228055, 0.23413936163132537}, + {1.2703024256629791, 0.0, 0.0}, + {0.27165712367757405, 0.8393489455399783, 1.2703024256629791} }; std::vector> expectedTranscendentalExpressions; @@ -291,10 +293,10 @@ class GravityModelTest : public ::testing::Test { std::array{-0.0, -0.0, -0.46364760900080615}), std::make_pair(-27.67871794485226, std::array{-0.0, -0.0, -1.1071487177940904}), - std::make_pair(0.0, std::array{-0.0, 0.0, -0.0}), - std::make_pair(0.0, std::array{-0.0, 0.0, -0.0}), - std::make_pair(0.0, std::array{0.0, 0.0, 0.0}), - std::make_pair(0.0, std::array{0.0, -0.0, -0.0}), + std::make_pair(0.0, std::array{-0.0, 0.0, -0.0}), + std::make_pair(0.0, std::array{-0.0, 0.0, -0.0}), + std::make_pair(0.0, std::array{0.0, 0.0, 0.0}), + std::make_pair(0.0, std::array{0.0, -0.0, -0.0}), std::make_pair(0.0, std::array{-0.0, -0.0, -0.0}), std::make_pair(0.0, std::array{-0.0, -0.0, -0.0}), std::make_pair(0.0, std::array{-0.0, -0.0, -0.0}), @@ -310,10 +312,10 @@ class GravityModelTest : public ::testing::Test { std::vector> expectedBetaSingularityTerms{ {-0.0, -0.0, -0.46364760900080615}, {-0.0, -0.0, -1.1071487177940904}, - {-0.0, 0.0, -0.0}, - {-0.0, 0.0, -0.0}, - {0.0, 0.0, 0.0}, - {0.0, -0.0, -0.0}, + {-0.0, 0.0, -0.0}, + {-0.0, 0.0, -0.0}, + {0.0, 0.0, 0.0}, + {0.0, -0.0, -0.0}, {-0.0, -0.0, -0.0}, {-0.0, -0.0, -0.0}, {-0.0, -0.0, -0.0}, @@ -323,7 +325,6 @@ class GravityModelTest : public ::testing::Test { }; public: - GravityModelTest() : ::testing::Test() { expectedDistancesPerSegmentEndpoint.resize(expected3DDistancesPerSegmentEndpoint.size()); expectedTranscendentalExpressions.resize(expectedTranscendentalLN.size()); diff --git a/test/model/GravityModelVectorUtility.cpp b/test/model/GravityModelVectorUtility.cpp index b48a9bf..cd9071e 100644 --- a/test/model/GravityModelVectorUtility.cpp +++ b/test/model/GravityModelVectorUtility.cpp @@ -44,7 +44,7 @@ namespace polyhedralGravity { GravityModel::calculatePlaneNormalOrientations(const Array3 &computationPoint, const Polyhedron &polyhedron, const std::vector &planeUnitNormals) { std::vector planeNormalOrientations(planeUnitNormals.size(), 0.0); - auto transformedPolyhedronIt = transformPolyhedron(polyhedron, computationPoint); + auto transformedPolyhedronIt = polyhedron.transformIterator(computationPoint); //Calculate sigma_p for every plane given as input: N_p and vertex0 of every face std::transform(planeUnitNormals.cbegin(), planeUnitNormals.cend(), transformedPolyhedronIt.first, planeNormalOrientations.begin(), @@ -58,7 +58,7 @@ namespace polyhedralGravity { std::vector GravityModel::calculateFacesToHessianPlanes(const Array3 &computationPoint, const Polyhedron &polyhedron) { std::vector hessianPlanes{polyhedron.countFaces()}; - auto transformedPolyhedronIt = transformPolyhedron(polyhedron, computationPoint); + auto transformedPolyhedronIt = polyhedron.transformIterator(computationPoint); //Calculate for each face/ plane/ triangle (here) the Hessian Plane std::transform(transformedPolyhedronIt.first, transformedPolyhedronIt.second, hessianPlanes.begin(), [](const Array3Triplet &face) -> HessianPlane { @@ -106,7 +106,7 @@ namespace polyhedralGravity { const std::vector &orthogonalProjectionPointsOnPlane) { std::vector segmentNormalOrientations{segmentUnitNormals.size()}; - auto transformedPolyhedronIt = transformPolyhedron(polyhedron, computationPoint); + auto transformedPolyhedronIt = polyhedron.transformIterator(computationPoint); auto first = util::zip(transformedPolyhedronIt.first, orthogonalProjectionPointsOnPlane.begin(), segmentUnitNormals.begin()); auto last = util::zip(transformedPolyhedronIt.second, @@ -132,7 +132,7 @@ namespace polyhedralGravity { std::vector orthogonalProjectionPointsOnSegments{orthogonalProjectionPointsOnPlane.size()}; //Zip the three required arguments together: P' for every plane, sigma_pq for every segment, the faces - auto transformedPolyhedronIt = transformPolyhedron(polyhedron, computationPoint); + auto transformedPolyhedronIt = polyhedron.transformIterator(computationPoint); auto first = util::zip(orthogonalProjectionPointsOnPlane.begin(), segmentNormalOrientation.begin(), transformedPolyhedronIt.first); auto last = util::zip(orthogonalProjectionPointsOnPlane.end(), segmentNormalOrientation.end(), @@ -172,7 +172,7 @@ namespace polyhedralGravity { std::vector> distances{segmentVectors.size()}; //Zip the three required arguments together: G_ij for every segment, P'' for every segment - auto transformedPolyhedronIt = transformPolyhedron(polyhedron, computationPoint); + auto transformedPolyhedronIt = polyhedron.transformIterator(computationPoint); auto first = util::zip(segmentVectors.begin(), orthogonalProjectionPointsOnSegment.begin(), transformedPolyhedronIt.first); auto last = util::zip(segmentVectors.end(), orthogonalProjectionPointsOnSegment.end(), @@ -199,7 +199,7 @@ namespace polyhedralGravity { std::vector> transcendentalExpressions{distances.size()}; //Zip iterator consisting of 3D and 1D distances l1/l2 and s1/2 | h_p | h_pq | sigma_pq | P'_p | faces - auto transformedPolyhedronIt = transformPolyhedron(polyhedron, computationPoint); + auto transformedPolyhedronIt = polyhedron.transformIterator(computationPoint); auto first = util::zip(distances.begin(), planeDistances.begin(), segmentDistances.begin(), segmentNormalOrientation.begin(), orthogonalProjectionPointsOnPlane.begin(), transformedPolyhedronIt.first); @@ -238,7 +238,7 @@ namespace polyhedralGravity { std::vector> singularities{planeDistances.size()}; //Zip iterator consisting of G_ij vectors | sigma_pq | faces | P' | h_p | sigma_p | N_i - auto transformedPolyhedronIt = transformPolyhedron(polyhedron, computationPoint); + auto transformedPolyhedronIt = polyhedron.transformIterator(computationPoint); auto first = util::zip(segmentVectors.begin(), segmentNormalOrientation.begin(), orthogonalProjectionPointsOnPlane.begin(), planeUnitNormals.begin(), planeDistances.begin(), planeNormalOrientations.begin(), transformedPolyhedronIt.first); diff --git a/test/model/MeshCheckingTest.cpp b/test/model/MeshCheckingTest.cpp deleted file mode 100644 index 5aca1b0..0000000 --- a/test/model/MeshCheckingTest.cpp +++ /dev/null @@ -1,263 +0,0 @@ -#include "gtest/gtest.h" - -#include -#include -#include -#include "polyhedralGravity/model/MeshChecking.h" -#include "polyhedralGravity/model/Polyhedron.h" -#include "polyhedralGravity/input/TetgenAdapter.h" - - -/** - * Contains Tests if the sanity checks works - */ -class MeshCheckingTest : public ::testing::Test { - -protected: - const std::vector _cubeVertices{ - {-1.0, -1.0, -1.0}, - {1.0, -1.0, -1.0}, - {1.0, 1.0, -1.0}, - {-1.0, 1.0, -1.0}, - {-1.0, -1.0, 1.0}, - {1.0, -1.0, 1.0}, - {1.0, 1.0, 1.0}, - {-1.0, 1.0, 1.0} - }; - - const polyhedralGravity::Polyhedron _cubeOutwardNormals{_cubeVertices, - { - {1, 3, 2}, - {0, 3, 1}, - {0, 1, 5}, - {0, 5, 4}, - {0, 7, 3}, - {0, 4, 7}, - {1, 2, 6}, - {1, 6, 5}, - {2, 3, 6}, - {3, 7, 6}, - {4, 5, 6}, - {4, 6, 7}} - }; - - const polyhedralGravity::Polyhedron _cubeInwardNormals{_cubeVertices, - { - {3, 1, 2}, - {3, 0, 1}, - {1, 0, 5}, - {5, 0, 4}, - {7, 0, 3}, - {4, 0, 7}, - {2, 1, 6}, - {6, 1, 5}, - {3, 2, 6}, - {7, 3, 6}, - {5, 4, 6}, - {6, 4, 7}} - }; - - const polyhedralGravity::Polyhedron _cubeMajorOutwardNormals{_cubeVertices, - { - {3, 1, 2}, - {0, 3, 1}, - {0, 1, 5}, - {0, 5, 4}, - {7, 0, 3}, - {0, 4, 7}, - {1, 2, 6}, - {1, 6, 5}, - {2, 3, 6}, - {3, 7, 6}, - {4, 5, 6}, - {4, 6, 7}} - }; - - const polyhedralGravity::Polyhedron _cubeMajorInwardNormals{_cubeVertices, - { - {3, 1, 2}, - {3, 0, 1}, - {1, 0, 5}, - {5, 0, 4}, - {7, 0, 3}, - {4, 0, 7}, - {2, 1, 6}, - {6, 1, 5}, - {3, 2, 6}, - {3, 7, 6}, - {4, 5, 6}, - {4, 6, 7}} - }; - - const polyhedralGravity::Polyhedron _degeneratedCube{_cubeVertices, - { - {1, 3, 2}, - {0, 3, 1}, - {0, 1, 5}, - {0, 5, 4}, - {7, 7, 3}, - {0, 4, 7}, - {1, 2, 6}, - {1, 6, 5}, - {2, 3, 6}, - {3, 7, 6}, - {4, 5, 6}, - {4, 6, 7}} - }; - - - const polyhedralGravity::Polyhedron _correctPrism{{ - {-20.0, 0.0, 25.0}, - {0.0, 0.0, 25.0}, - {0.0, 10.0, 25.0}, - {-20.0, 10.0, 25.0}, - {-20.0, 0.0, 15.0}, - {0.0, 0.0, 15.0}, - {0.0, 10.0, 15.0}, - {-20.0, 10.0, 15.0}}, - { - {0, 4, 5}, - {0, 5, 1}, - {0, 1, 3}, - {1, 2, 3}, - {1, 5, 6}, - {1, 6, 2}, - {0, 7, 4}, - {0, 3, 7}, - {4, 7, 5}, - {5, 7, 6}, - {2, 7, 3}, - {2, 6, 7} - }}; - - const polyhedralGravity::Polyhedron _wrongPrism{{ - {-20.0, 0.0, 25.0}, - {0.0, 0.0, 25.0}, - {0.0, 10.0, 25.0}, - {-20.0, 10.0, 25.0}, - {-20.0, 0.0, 15.0}, - {0.0, 0.0, 15.0}, - {0.0, 10.0, 15.0}, - {-20.0, 10.0, 15.0}}, - { - {4, 0, 5}, - {5, 0, 1}, - {1, 0, 3}, - {2, 1, 3}, - {5, 1, 6}, - {6, 1, 2}, - {7, 0, 4}, - {3, 0, 7}, - {7, 4, 5}, - {7, 5, 6}, - {7, 2, 3}, - {6, 2, 7} - }}; -}; - -TEST_F(MeshCheckingTest, CubeOutwardNormals) { - using namespace polyhedralGravity; - using namespace testing; - // All normals are pointing outwards - ASSERT_TRUE(MeshChecking::checkPlaneUnitNormalOrientation(_cubeOutwardNormals, NormalOrientation::OUTWARDS)); - ASSERT_FALSE(MeshChecking::checkPlaneUnitNormalOrientation(_cubeOutwardNormals, NormalOrientation::INWWARDS)); - - const auto &[actualOrientation, actualViolatingFaces] = MeshChecking::getPlaneUnitNormalOrientation(_cubeOutwardNormals); - ASSERT_EQ(actualOrientation, NormalOrientation::OUTWARDS); - ASSERT_EQ(actualViolatingFaces, std::set{}); - - ASSERT_TRUE(MeshChecking::checkTrianglesNotDegenerated(_cubeOutwardNormals)); -} - -TEST_F(MeshCheckingTest, CubeInwardNormals) { - using namespace polyhedralGravity; - using namespace testing; - // All normals are pointing inwards (reversed order) - ASSERT_FALSE(MeshChecking::checkPlaneUnitNormalOrientation(_cubeInwardNormals, NormalOrientation::OUTWARDS)); - ASSERT_TRUE(MeshChecking::checkPlaneUnitNormalOrientation(_cubeInwardNormals, NormalOrientation::INWWARDS)); - - const auto &[actualOrientation, actualViolatingFaces] = MeshChecking::getPlaneUnitNormalOrientation(_cubeInwardNormals); - ASSERT_EQ(actualOrientation, NormalOrientation::INWWARDS); - ASSERT_EQ(actualViolatingFaces, std::set{}); - - ASSERT_TRUE(MeshChecking::checkTrianglesNotDegenerated(_cubeInwardNormals)); -} - -TEST_F(MeshCheckingTest, CubeMajorOutwardNormals) { - using namespace polyhedralGravity; - using namespace testing; - // All normals are pointing outwards expect two which points inwards (at indices 0 and 4) - ASSERT_FALSE(MeshChecking::checkPlaneUnitNormalOrientation(_cubeMajorOutwardNormals, NormalOrientation::INWWARDS)); - ASSERT_FALSE(MeshChecking::checkPlaneUnitNormalOrientation(_cubeMajorOutwardNormals, NormalOrientation::OUTWARDS)); - - const auto &[actualOrientation, actualViolatingFaces] = MeshChecking::getPlaneUnitNormalOrientation(_cubeMajorOutwardNormals); - ASSERT_EQ(actualOrientation, NormalOrientation::OUTWARDS); - ASSERT_EQ(actualViolatingFaces, std::set({0, 4})); - - ASSERT_TRUE(MeshChecking::checkTrianglesNotDegenerated(_cubeMajorOutwardNormals)); -} - -TEST_F(MeshCheckingTest, CubeMajorInwardNormals) { - using namespace polyhedralGravity; - using namespace testing; - // All normals are pointing outwards expect three which points inwards (at indices 9, 10, 11) - ASSERT_FALSE(MeshChecking::checkPlaneUnitNormalOrientation(_cubeMajorInwardNormals, NormalOrientation::INWWARDS)); - ASSERT_FALSE(MeshChecking::checkPlaneUnitNormalOrientation(_cubeMajorInwardNormals, NormalOrientation::OUTWARDS)); - - const auto &[actualOrientation, actualViolatingFaces] = MeshChecking::getPlaneUnitNormalOrientation(_cubeMajorInwardNormals); - ASSERT_EQ(actualOrientation, NormalOrientation::INWWARDS); - ASSERT_EQ(actualViolatingFaces, std::set({9, 10, 11})); - - ASSERT_TRUE(MeshChecking::checkTrianglesNotDegenerated(_cubeMajorInwardNormals)); -} - -TEST_F(MeshCheckingTest, DegeneratedCube) { - using namespace testing; - // One surface has the same point twice as vertex - ASSERT_FALSE(polyhedralGravity::MeshChecking::checkTrianglesNotDegenerated(_degeneratedCube)); -} - -TEST_F(MeshCheckingTest, CorrectPrism) { - using namespace polyhedralGravity; - using namespace testing; - // All normals are pointing outwards - ASSERT_TRUE(polyhedralGravity::MeshChecking::checkPlaneUnitNormalOrientation(_correctPrism)) - << "The vertices of the prism are correctly sorted, however the Sanity Check came to the wrong conclusion!"; - - const auto &[actualOrientation, actualViolatingFaces] = MeshChecking::getPlaneUnitNormalOrientation(_correctPrism); - ASSERT_EQ(actualOrientation, NormalOrientation::OUTWARDS); - ASSERT_EQ(actualViolatingFaces, std::set{}); - - ASSERT_TRUE(MeshChecking::checkTrianglesNotDegenerated(_correctPrism)); -} - -TEST_F(MeshCheckingTest, WrongPrism) { - using namespace polyhedralGravity; - using namespace testing; - // All normals are pointing inwards (reversed order) - ASSERT_FALSE(MeshChecking::checkPlaneUnitNormalOrientation(_wrongPrism)) - << "The vertices of the prism are incorrectly sorted, however the Sanity Check failed to notice that!"; - - const auto &[actualOrientation, actualViolatingFaces] = MeshChecking::getPlaneUnitNormalOrientation(_wrongPrism); - ASSERT_EQ(actualOrientation, NormalOrientation::INWWARDS); - ASSERT_EQ(actualViolatingFaces, std::set{}); - - ASSERT_TRUE(MeshChecking::checkTrianglesNotDegenerated(_wrongPrism)); -} - -TEST_F(MeshCheckingTest, CorrectBigPolyhedron) { - using namespace testing; - using namespace polyhedralGravity; - // All normals are pointing outwards, extensive Eros example - Polyhedron polyhedron{ - TetgenAdapter{ - {"resources/GravityModelBigTest.node", "resources/GravityModelBigTest.face"}}.getPolyhedron()}; - ASSERT_TRUE(MeshChecking::checkPlaneUnitNormalOrientation(polyhedron)) - << "The vertices of the polyhedron are correctly sorted, however the Sanity Check came to the wrong conclusion!"; - ASSERT_TRUE(MeshChecking::checkTrianglesNotDegenerated(polyhedron)); - - const auto &[actualOrientation, actualViolatingFaces] = MeshChecking::getPlaneUnitNormalOrientation(polyhedron); - ASSERT_EQ(actualOrientation, NormalOrientation::OUTWARDS); - ASSERT_EQ(actualViolatingFaces, std::set{}); -} - diff --git a/test/model/PolyhedronTest.cpp b/test/model/PolyhedronTest.cpp new file mode 100644 index 0000000..1cd1b5a --- /dev/null +++ b/test/model/PolyhedronTest.cpp @@ -0,0 +1,312 @@ +#include "gtest/gtest.h" +#include "gmock/gmock.h" + +#include +#include "polyhedralGravity/model/Polyhedron.h" + + +/** + * Contains Tests if the mesh sanity checks of the Polyhedron work + * Parameterization not possible since the patterns what and where the error exactly is varies leading + * to different assertions being required in the single test case. + */ +class PolyhedronTest : public ::testing::Test { + +protected: + const std::vector _cubeVertices{ + {-1.0, -1.0, -1.0}, + {1.0, -1.0, -1.0}, + {1.0, 1.0, -1.0}, + {-1.0, 1.0, -1.0}, + {-1.0, -1.0, 1.0}, + {1.0, -1.0, 1.0}, + {1.0, 1.0, 1.0}, + {-1.0, 1.0, 1.0} + }; + + const std::vector _facesOutwards{ + {1, 3, 2}, + {0, 3, 1}, + {0, 1, 5}, + {0, 5, 4}, + {0, 7, 3}, + {0, 4, 7}, + {1, 2, 6}, + {1, 6, 5}, + {2, 3, 6}, + {3, 7, 6}, + {4, 5, 6}, + {4, 6, 7} + }; + + + const std::vector _facesInwards{ + {3, 1, 2}, + {3, 0, 1}, + {1, 0, 5}, + {5, 0, 4}, + {7, 0, 3}, + {4, 0, 7}, + {2, 1, 6}, + {6, 1, 5}, + {3, 2, 6}, + {7, 3, 6}, + {5, 4, 6}, + {6, 4, 7} + }; + + const std::vector _facesOutwardsMajority{ + {3, 1, 2}, + {0, 3, 1}, + {0, 1, 5}, + {0, 5, 4}, + {7, 0, 3}, + {0, 4, 7}, + {1, 2, 6}, + {1, 6, 5}, + {2, 3, 6}, + {3, 7, 6}, + {4, 5, 6}, + {4, 6, 7} + }; + + const std::vector _facesInwardsMajority{ + {3, 1, 2}, + {3, 0, 1}, + {1, 0, 5}, + {5, 0, 4}, + {7, 0, 3}, + {4, 0, 7}, + {2, 1, 6}, + {6, 1, 5}, + {3, 2, 6}, + {3, 7, 6}, + {4, 5, 6}, + {4, 6, 7} + }; + + const std::vector _degeneratedFaces{ + {1, 3, 2}, + {0, 3, 1}, + {0, 1, 5}, + {0, 5, 4}, + {7, 7, 3}, + {0, 4, 7}, + {1, 2, 6}, + {1, 6, 5}, + {2, 3, 6}, + {3, 7, 6}, + {4, 5, 6}, + {4, 6, 7} + }; + + + const std::vector _prismVertices{ + {-20.0, 0.0, 25.0}, + {0.0, 0.0, 25.0}, + {0.0, 10.0, 25.0}, + {-20.0, 10.0, 25.0}, + {-20.0, 0.0, 15.0}, + {0.0, 0.0, 15.0}, + {0.0, 10.0, 15.0}, + {-20.0, 10.0, 15.0} + }; + + const std::vector _prismOutwards{ + {0, 4, 5}, + {0, 5, 1}, + {0, 1, 3}, + {1, 2, 3}, + {1, 5, 6}, + {1, 6, 2}, + {0, 7, 4}, + {0, 3, 7}, + {4, 7, 5}, + {5, 7, 6}, + {2, 7, 3}, + {2, 6, 7} + }; + + const std::vector _prismInwards{ + + {4, 0, 5}, + {5, 0, 1}, + {1, 0, 3}, + {2, 1, 3}, + {5, 1, 6}, + {6, 1, 2}, + {7, 0, 4}, + {3, 0, 7}, + {7, 4, 5}, + {7, 5, 6}, + {7, 2, 3}, + {6, 2, 7} + }; +}; + +TEST_F(PolyhedronTest, CubeOutwardNormals) { + using namespace polyhedralGravity; + using namespace testing; + // Correct Set-Up, No-throw for all options + EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesOutwards, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::DISABLE)); + EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesOutwards, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::AUTOMATIC)); + EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesOutwards, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::VERIFY)); + EXPECT_NO_THROW(Polyhedron (_cubeVertices, _facesOutwards, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::HEAL)); + + // Wrong Set-Up, Throws in case of AUTOMATIC and VERIFY, DISABLE and HEAL do not throw but respectivley ignore or repair + EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesOutwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::DISABLE)); + EXPECT_THROW(Polyhedron(_cubeVertices, _facesOutwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::AUTOMATIC), std::invalid_argument); + EXPECT_THROW(Polyhedron(_cubeVertices, _facesOutwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::VERIFY), std::invalid_argument); + EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesOutwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::HEAL)); + + // Checking that the healing leads to the correct result (More than n/2 normals (actuall all) are outwards. Hence, only change of the Orientation) + Polyhedron healedPolyhedron(_cubeVertices, _facesOutwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::HEAL); + EXPECT_EQ(healedPolyhedron.getOrientation(), NormalOrientation::OUTWARDS); + EXPECT_THAT(healedPolyhedron.getFaces(), ContainerEq(_facesOutwards)); +} + +TEST_F(PolyhedronTest, CubeInwardsNormals) { + using namespace polyhedralGravity; + using namespace testing; + // Correct Set-Up, No-throw for all options + EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesInwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::DISABLE)); + EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesInwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::AUTOMATIC)); + EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesInwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::VERIFY)); + EXPECT_NO_THROW(Polyhedron (_cubeVertices, _facesInwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::HEAL)); + + // Wrong Set-Up, Throws in case of AUTOMATIC and VERIFY, DISABLE and HEAL do not throw but respectivley ignore or repair + EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesInwards, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::DISABLE)); + EXPECT_THROW(Polyhedron(_cubeVertices, _facesInwards, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::AUTOMATIC), std::invalid_argument); + EXPECT_THROW(Polyhedron(_cubeVertices, _facesInwards, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::VERIFY), std::invalid_argument); + EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesInwards, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::HEAL)); + + // Checking that checkPlaneUnitNormalOrientation() returns the correct set of indices & majority orientation + Polyhedron intenionalDisabledCheckingPolyhedron(_cubeVertices, _facesOutwardsMajority, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::DISABLE); + const auto &[majorityOrientation, violatingIndices] = intenionalDisabledCheckingPolyhedron.checkPlaneUnitNormalOrientation(); + EXPECT_EQ(majorityOrientation, NormalOrientation::OUTWARDS); + EXPECT_THAT(violatingIndices, ContainerEq(std::set({0, 4}))); + + // Checking that the healing leads to the correct result (More than n/2 normals (actuall all) are outwards. Hence, only change of the Orientation) + Polyhedron healedPolyhedron(_cubeVertices, _facesInwards, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::HEAL); + EXPECT_EQ(healedPolyhedron.getOrientation(), NormalOrientation::INWWARDS); + EXPECT_THAT(healedPolyhedron.getFaces(), ContainerEq(_facesInwards)); +} + +TEST_F(PolyhedronTest, CubeOutwardNormalsMajor) { + using namespace polyhedralGravity; + using namespace testing; + // The majority is correct. However, 2 faces have inward pointing normals (Index 0 and 4) --> Will throw but not in the healing scenario + EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesOutwardsMajority, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::DISABLE)); + EXPECT_THROW(Polyhedron(_cubeVertices, _facesOutwardsMajority, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::AUTOMATIC), std::invalid_argument); + EXPECT_THROW(Polyhedron(_cubeVertices, _facesOutwardsMajority, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::VERIFY), std::invalid_argument); + EXPECT_NO_THROW(Polyhedron (_cubeVertices, _facesOutwardsMajority, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::HEAL)); + + // Wrong Set-Up, Throws in case of AUTOMATIC and VERIFY, DISABLE and HEAL do not throw but respectivley ignore or repair + EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesOutwardsMajority, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::DISABLE)); + EXPECT_THROW(Polyhedron(_cubeVertices, _facesOutwardsMajority, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::AUTOMATIC), std::invalid_argument); + EXPECT_THROW(Polyhedron(_cubeVertices, _facesOutwardsMajority, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::VERIFY), std::invalid_argument); + EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesOutwardsMajority, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::HEAL)); + + // Checking that checkPlaneUnitNormalOrientation() returns the correct set of indices & majority orientation + Polyhedron intenionalDisabledCheckingPolyhedron(_cubeVertices, _facesOutwardsMajority, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::DISABLE); + const auto &[majorityOrientation, violatingIndices] = intenionalDisabledCheckingPolyhedron.checkPlaneUnitNormalOrientation(); + EXPECT_EQ(majorityOrientation, NormalOrientation::OUTWARDS); + EXPECT_THAT(violatingIndices, ContainerEq(std::set({0, 4}))); + + // Checking that the healing leads to the correct result (More than n/2 normals are outwards. Here orientation & faces' vertex ordering changes) + Polyhedron healedPolyhedron(_cubeVertices, _facesOutwardsMajority, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::HEAL); + EXPECT_EQ(healedPolyhedron.getOrientation(), NormalOrientation::OUTWARDS); + EXPECT_THAT(healedPolyhedron.getFaces(), ContainerEq(_facesOutwards)); +} + +TEST_F(PolyhedronTest, CubeOutwardInwardsMajor) { + using namespace polyhedralGravity; + using namespace testing; + // The majority is correct. However, 2 faces have inward pointing normals (Index 9, 10, and 11) --> Will throw but not in the healing scenario + EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesInwardsMajority, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::DISABLE)); + EXPECT_THROW(Polyhedron(_cubeVertices, _facesInwardsMajority, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::AUTOMATIC), std::invalid_argument); + EXPECT_THROW(Polyhedron(_cubeVertices, _facesInwardsMajority, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::VERIFY), std::invalid_argument); + EXPECT_NO_THROW(Polyhedron (_cubeVertices, _facesInwardsMajority, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::HEAL)); + + // Wrong Set-Up, Throws in case of AUTOMATIC and VERIFY, DISABLE and HEAL do not throw but respectivley ignore or repair + EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesInwardsMajority, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::DISABLE)); + EXPECT_THROW(Polyhedron(_cubeVertices, _facesInwardsMajority, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::AUTOMATIC), std::invalid_argument); + EXPECT_THROW(Polyhedron(_cubeVertices, _facesInwardsMajority, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::VERIFY), std::invalid_argument); + EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesInwardsMajority, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::HEAL)); + + // Checking that checkPlaneUnitNormalOrientation() returns the correct set of indices & majority orientation + Polyhedron intenionalDisabledCheckingPolyhedron(_cubeVertices, _facesInwardsMajority, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::DISABLE); + const auto &[majorityOrientation, violatingIndices] = intenionalDisabledCheckingPolyhedron.checkPlaneUnitNormalOrientation(); + EXPECT_EQ(majorityOrientation, NormalOrientation::INWWARDS); + EXPECT_THAT(violatingIndices, ContainerEq(std::set({9, 10, 11}))); + + // Checking that the healing leads to the correct result (More than n/2 normals are outwards. Here orientation & faces' vertex ordering changes) + Polyhedron healedPolyhedron(_cubeVertices, _facesInwardsMajority, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::HEAL); + EXPECT_EQ(healedPolyhedron.getOrientation(), NormalOrientation::INWWARDS); + EXPECT_THAT(healedPolyhedron.getFaces(), ContainerEq(_facesInwards)); +} + +TEST_F(PolyhedronTest, CubeDegenerated) { + using namespace polyhedralGravity; + using namespace testing; + // A degenarted mesh is not repaired, throw always expect DISABLE is checked + for (auto orientation: std::set({NormalOrientation::INWWARDS, NormalOrientation::OUTWARDS})) { + EXPECT_NO_THROW(Polyhedron(_cubeVertices, _degeneratedFaces, 1.0, orientation, PolyhedronIntegrity::DISABLE)); + EXPECT_THROW(Polyhedron(_cubeVertices, _degeneratedFaces, 1.0, orientation, PolyhedronIntegrity::AUTOMATIC), std::invalid_argument); + EXPECT_THROW(Polyhedron(_cubeVertices, _degeneratedFaces, 1.0, orientation, PolyhedronIntegrity::VERIFY), std::invalid_argument); + EXPECT_THROW(Polyhedron(_cubeVertices, _degeneratedFaces, 1.0, orientation, PolyhedronIntegrity::HEAL), std::invalid_argument); + } +} + +TEST_F(PolyhedronTest, PrsimOutwards) { + using namespace polyhedralGravity; + using namespace testing; + // Correct Set-Up, No-throw for all options + EXPECT_NO_THROW(Polyhedron(_prismVertices, _prismOutwards, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::DISABLE)); + EXPECT_NO_THROW(Polyhedron(_prismVertices, _prismOutwards, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::AUTOMATIC)); + EXPECT_NO_THROW(Polyhedron(_prismVertices, _prismOutwards, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::VERIFY)); + EXPECT_NO_THROW(Polyhedron (_prismVertices, _prismOutwards, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::HEAL)); + + // Wrong Set-Up, Throws in case of AUTOMATIC and VERIFY, DISABLE and HEAL do not throw but respectivley ignore or repair + EXPECT_NO_THROW(Polyhedron(_prismVertices, _prismOutwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::DISABLE)); + EXPECT_THROW(Polyhedron(_prismVertices, _prismOutwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::AUTOMATIC), std::invalid_argument); + EXPECT_THROW(Polyhedron(_prismVertices, _prismOutwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::VERIFY), std::invalid_argument); + EXPECT_NO_THROW(Polyhedron(_prismVertices, _prismOutwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::HEAL)); + + // Checking that the healing leads to the correct result (More than n/2 normals (actuall all) are outwards. Hence, only change of the Orientation) + Polyhedron healedPolyhedron(_prismVertices, _prismOutwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::HEAL); + EXPECT_EQ(healedPolyhedron.getOrientation(), NormalOrientation::OUTWARDS); + EXPECT_THAT(healedPolyhedron.getFaces(), ContainerEq(_prismOutwards)); +} + +TEST_F(PolyhedronTest, PrsimInwards) { + using namespace polyhedralGravity; + using namespace testing; + // Correct Set-Up, No-throw for all options + EXPECT_NO_THROW(Polyhedron(_prismVertices, _prismInwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::DISABLE)); + EXPECT_NO_THROW(Polyhedron(_prismVertices, _prismInwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::AUTOMATIC)); + EXPECT_NO_THROW(Polyhedron(_prismVertices, _prismInwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::VERIFY)); + EXPECT_NO_THROW(Polyhedron (_prismVertices, _prismInwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::HEAL)); + + // Wrong Set-Up, Throws in case of AUTOMATIC and VERIFY, DISABLE and HEAL do not throw but respectivley ignore or repair + EXPECT_NO_THROW(Polyhedron(_prismVertices, _prismInwards, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::DISABLE)); + EXPECT_THROW(Polyhedron(_prismVertices, _prismInwards, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::AUTOMATIC), std::invalid_argument); + EXPECT_THROW(Polyhedron(_prismVertices, _prismInwards, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::VERIFY), std::invalid_argument); + EXPECT_NO_THROW(Polyhedron(_prismVertices, _prismInwards, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::HEAL)); + + // Checking that the healing leads to the correct result (More than n/2 normals (actuall all) are outwards. Hence, only change of the Orientation) + Polyhedron healedPolyhedron(_prismVertices, _prismInwards, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::HEAL); + EXPECT_EQ(healedPolyhedron.getOrientation(), NormalOrientation::INWWARDS); + EXPECT_THAT(healedPolyhedron.getFaces(), ContainerEq(_prismInwards)); +} + +TEST_F(PolyhedronTest, CorrectBigPolyhedron) { + using namespace testing; + using namespace polyhedralGravity; + // All normals are pointing outwards, extensive Eros example + ASSERT_NO_THROW(Polyhedron( + std::vector({"resources/GravityModelBigTest.node", "resources/GravityModelBigTest.face"}), + 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::VERIFY) + ); +} + From 5287673ca971cf25b9a86bf6b18762aabb00ae5b Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Tue, 16 Apr 2024 21:48:33 +0200 Subject: [PATCH 15/54] small note --- test/model/GravityModelBigTest.cpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/test/model/GravityModelBigTest.cpp b/test/model/GravityModelBigTest.cpp index 4de0482..e80285d 100644 --- a/test/model/GravityModelBigTest.cpp +++ b/test/model/GravityModelBigTest.cpp @@ -19,6 +19,10 @@ * The values which are used to check the C++ implementation are calculated by the * Tsoulis reference implementation in FORTRAN and saved in the files in test/resources. * + * This test case might fail locally using a different architecture/ compiler than the CI! + * This is okay - A fix would be to check container element verbosly in a loop with an epsilon. + * However, the ContainerEq() - as currentl used - matcher makes the test a lot more readbale. + * */ class GravityModelBigTest : public ::testing::Test { From e1a22763d75fb1c996b8c2b96df49d93dbe18ed1 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Tue, 16 Apr 2024 23:08:43 +0200 Subject: [PATCH 16/54] new Python interface - part 1 --- src/polyhedralGravity/model/Polyhedron.h | 6 +- .../PolyhedralGravityPython.cpp | 384 ++++++++++++------ 2 files changed, 256 insertions(+), 134 deletions(-) diff --git a/src/polyhedralGravity/model/Polyhedron.h b/src/polyhedralGravity/model/Polyhedron.h index 1a6590c..dc0b029 100644 --- a/src/polyhedralGravity/model/Polyhedron.h +++ b/src/polyhedralGravity/model/Polyhedron.h @@ -38,10 +38,10 @@ namespace polyhedralGravity { * utilized cooridnate system. * However, the normal alignement is independent. Tsoulis et al. equations require the * normals to point outwards of the polyhedron. If the opposite hold, the result is - * inverted. + * negated. */ enum class NormalOrientation: char { - /** Outwards pointing plane unit normals*/ + /** Outwards pointing plane unit normals */ OUTWARDS, /** Inwards pointing plane unit normals */ INWWARDS @@ -96,7 +96,7 @@ namespace polyhedralGravity { AUTOMATIC, /** * Verification and Autmatioc Healing of the NormalOrientation. - * A misalignemt does not lead to a runtime_error, but to an internal correction. Cost: @f$O(n^2)$@f + * A misalignemt does not lead to a runtime_error, but to an internal correction. * @note Runtime Cost: @f$O(n^2)$@f and a modification of the mesh input! */ HEAL, diff --git a/src/polyhedralGravityPython/PolyhedralGravityPython.cpp b/src/polyhedralGravityPython/PolyhedralGravityPython.cpp index 0545901..b85a6dd 100644 --- a/src/polyhedralGravityPython/PolyhedralGravityPython.cpp +++ b/src/polyhedralGravityPython/PolyhedralGravityPython.cpp @@ -20,141 +20,263 @@ PYBIND11_MODULE(polyhedral_gravity, m) { m.doc() = "Computes the full gravity tensor for a given constant density polyhedron which consists of some " "vertices and triangular faces at a given computation points"; - m.def("evaluate", [](const PolyhedralSource &polyhedralSource, double density, - const std::variant> &computationPoints, - bool parallel) -> std::variant> { - using namespace polyhedralGravity; - if (std::holds_alternative(computationPoints)) { - return std::visit([&density, &computationPoints, parallel](const auto &source) { - using namespace polyhedralGravity; - return GravityModel::evaluate(source, density, std::get(computationPoints), parallel); - }, polyhedralSource); - } else { - return std::visit([&density, &computationPoints, parallel](const auto &source) { - using namespace polyhedralGravity; - return GravityModel::evaluate(source, density, std::get>(computationPoints), - parallel); - }, polyhedralSource); - } - }, R"mydelimiter( - Evaluates the polyhedral gravity model for a given constant density polyhedron at a given computation point. - - Args: - polyhedral_source: The vertices & faces of the polyhedron as tuple or - the filenames of the files containing the vertices & faces as list of strings - density: The constant density of the polyhedron in [kg/m^3] - computation_points: The computation points as tuple or list of points - parallel: If true, the computation is done in parallel (default: true) - - Returns: - Either a tuple of potential, acceleration and second derivatives at the computation points or - if multiple computation points are given, the result is a list of tuples - )mydelimiter", py::arg("polyhedral_source"), py::arg("density"), py::arg("computation_points"), - py::arg("parallel") = true); - - pybind11::class_(m, "GravityEvaluable", R"mydelimiter( - A class to evaluate the polyhedral gravity model for a given constant density polyhedron at a given computation point. - It provides a __call__ method to evaluate the polyhedral gravity model for computation points while - also caching the polyhedron data over the lifetime of the object. - )mydelimiter") - .def(pybind11::init(), - R"mydelimiter( - Creates a new GravityEvaluable for a given constant density polyhedron. - It provides a __call__ method to evaluate the polyhedral gravity model for computation points while - also caching the polyhedron data over the lifetime of the object. - - Args: - polyhedral_source: The vertices & faces of the polyhedron as tuple or - the filenames of the files containing the vertices & faces as list of strings - density: The constant density of the polyhedron in [kg/m^3] - )mydelimiter", - pybind11::arg("polyhedral_source"), - pybind11::arg("density")) - .def("__repr__", &GravityEvaluable::toString) - .def("__call__", &GravityEvaluable::operator(), - R"mydelimiter( - Evaluates the polyhedral gravity model for a given constant density polyhedron at a given computation point. - - Args: - computation_points: The computation points as tuple or list of points - parallel: If true, the computation is done in parallel (default: true) - - Returns: - Either a tuple of potential, acceleration and second derivatives at the computation points or - if multiple computation points are given, the result is a list of tuples - )mydelimiter", py::arg("computation_points"), py::arg("parallel") = true) - .def(py::pickle( - [](const GravityEvaluable &evaluable) { - const auto &[polyhedron, density, orientation, segmentVectors, planeUnitNormals, segmentUnitNormals] = - evaluable.getState(); - return py::make_tuple(polyhedron.getVertices(), polyhedron.getFaces(), density, orientation, segmentVectors, - planeUnitNormals, segmentUnitNormals); - }, - [](const py::tuple &tuple) { - constexpr size_t tupleSize = 7; - if (tuple.size() != tupleSize) { - throw std::runtime_error("Invalid state!"); - } - Polyhedron polyhedron{ - tuple[0].cast>(), tuple[1].cast>() - }; - GravityEvaluable evaluable{ - polyhedron, tuple[2].cast(), tuple[3].cast(), tuple[4].cast>(), - tuple[5].cast>(), tuple[6].cast>() - }; - return evaluable; - } - )); - - py::module_ utility = m.def_submodule("utility", - "This submodule contains useful utility functions like parsing meshes " - "or checking if the polyhedron's mesh plane unit normals point outwards " - "like it is required by the polyhedral-gravity model."); - - utility.def("read", [](const std::vector &filenames) { - TetgenAdapter tetgen{filenames}; - auto polyhedron = tetgen.getPolyhedralSource(); - return std::make_tuple(polyhedron.getVertices(), polyhedron.getFaces()); - }, R"mydelimiter( - Reads a polyhedron from a mesh file. The vertices and faces are read from input - files (either .node/.face, mesh, .ply, .off, .stl). File-Order matters in case of the first option! - - Args: - input_files (List[str]): list of input files. - Returns: - tuple of vertices (N, 3) (floats) and faces (N, 3) (ints). - )mydelimiter", py::arg("input_files")); - - utility.def("check_mesh", [](const std::vector &vertices, const std::vector &faces) { - Polyhedron poly{vertices, faces}; - return MeshChecking::checkTrianglesNotDegenerated(poly) && MeshChecking::checkPlaneUnitNormalOrientation(poly); - }, R"mydelimiter( - Checks if no triangles of the polyhedral mesh are degenerated by checking that their surface area - is greater zero. - Further, Checks if all the polyhedron's plane unit normals are pointing outwards. + py::enum_(m, "NormalOrientation", R"mydelimiter( + The orientation of the plane unit normals of the polyhedron. + Tsoulis et al. equations require the normals to point outwards of the polyhedron. + If the opposite hold, the result is negated. + The implementation can handle both cases. + )mydelimiter") + .value("OUTWARDS", NormalOrientation::OUTWARDS, "Outwards pointing plane unit normals") + .value("INWARDS", NormalOrientation::INWWARDS, "Inwards pointing plane unit normals"); + + py::enum_(m, "PolyhedronIntegrity", R"mydelimiter( + The pointing direction of the normals of a Polyhedron. + They can either point outwards or inwards the polyhedron. + )mydelimiter") + .value("DISABLE", PolyhedronIntegrity::DISABLE, + "All activities regarding MeshChecking are disabled. No runtime overhead!") + .value("VERIFY", PolyhedronIntegrity::VERIFY, + "Only verification of the NormalOrientation. " + "A misalignment (e.g. specified OUTWARDS, but is not) leads to a runtime_error. Runtime Cost O(n^2)") + .value("AUTOMATIC", PolyhedronIntegrity::AUTOMATIC, + "Like VERIFY, but also informs the user about the option in any case on the runtime costs. " + "This is the implicit default option. Runtime Cost: O(n^2) and output to stdout in every case!" ) + .value("HEAL", PolyhedronIntegrity::HEAL, + "Verification and Autmatioc Healing of the NormalOrientation. " + "A misalignemt does not lead to a runtime_error, but to an internal correction of vertices ordering. Runtime Cost: @f$O(n^2)$@f"); + + py::class_(m, "Polyhedron", R"mydelimiter( + A constant density Polyhedron stores the mesh data consisting of vertices and triangular faces. + The density and the coordinate system in which vertices and faces are defined need to have the same scale/ units. + Tsoulis et al.'s polyhedral gravity model requires that the plane unit normals of every face are pointing outwards + of the polyhedron. Otherwise the results are negated. + The class by default enforces this constraints and offers utility to (automatically) make the input data obey to this constraint. + )mydelimiter") + .def(py::init(), + R"mydelimiter( + Creates a new Polyhedron from vertices and faces and a constant density. + If the integrity_check is not set to DISABLE, the mesh integrity is checked + (so that it fits the specification of the polyhedral model by Tsoulis et al.) Args: - vertices (2-D array-like): (N, 3) array of vertex coordinates (floats). - faces (2-D array-like): (N, 3) array of faces, vertex-indices (ints). - Returns: - True if no triangle is degenerate and the polyhedron's plane unit normals are all pointing outwards. - )mydelimiter", py::arg("vertices"), py::arg("faces")); + polyhedral_source: The vertices & faces of the polyhedron as pair of (N, 3)-arrays + density: The constant density of the polyhedron, it must match the mesh's units, e.g. mesh in [m] then density in [kg/m^3] + normal_orientation: The pointing direction of the mesh's plane unit normals, i.e., either OUTWARDS or INWARDS of the polyhedron + (default: OUTWARDS) + integrity_check: Conducts an Integrity Check (degenerated faces/ vertex ordering) depending on the values. Options + - AUTOMATIC (Default): Prints to stdout and throws ValueError if normal_orientation is wrong/ inconsisten + - VERIFY: Like AUTOMATIC, but does not print to stdout + - DISABLE: Recommened, when you know the mesh to avoid to pay O(n^2) runtime. Disables ALL checks + - HEAL: Automatically fixes the normal_orientation and vertex ordering to the correct values + Raises: + ValueError if `integrity_check` is set to AUTOMATIC or VERIFY and the mesh is inconsistent + Note: + The integrity_check is automatically enabled to avoid wrong results due to the wrong vertex ordering. + The check requires O(n^2) operations. You want to turn this off, when you know you mesh! + )mydelimiter", + py::arg("polyhedral_source"), + py::arg("density"), + py::arg("normal_orientation") = NormalOrientation::OUTWARDS, + py::arg("integrity_check") = PolyhedronIntegrity::AUTOMATIC + ) + .def(py::init(), + R"mydelimiter( + Creates a new Polyhedron from vertices and faces and a constant density. + If the integrity_check is not set to DISABLE, the mesh integrity is checked + (so that it fits the specification of the polyhedral model by Tsoulis et al.) - utility.def("check_mesh", [](const std::vector &filenames) { - TetgenAdapter tetgen{filenames}; - Polyhedron poly = tetgen.getPolyhedralSource(); - return MeshChecking::checkTrianglesNotDegenerated(poly) && MeshChecking::checkPlaneUnitNormalOrientation(poly); - }, R"mydelimiter( - Checks if no triangles of the polyhedral mesh are degenerated by checking that their surface area - is greater zero. - Further, Checks if all the polyhedron's plane unit normals are pointing outwards. - Reads a polyhedron from a mesh file. The vertices and faces are read from input - files (either .node/.face, mesh, .ply, .off, .stl). File-Order matters in case of the first option! + Args: + polyhedral_source: The filenames of the files containing the vertices & faces as list of strings + density: The constant density of the polyhedron, it must match the mesh's units, e.g. mesh in [m] then density in [kg/m^3] + normal_orientation: The pointing direction of the mesh's plane unit normals, i.e., either OUTWARDS or INWARDS of the polyhedron + (default: OUTWARDS) + integrity_check: Conducts an Integrity Check (degenerated faces/ vertex ordering) depending on the values. Options + - AUTOMATIC (Default): Prints to stdout and throws ValueError if normal_orientation is wrong/ inconsisten + - VERIFY: Like AUTOMATIC, but does not print to stdout + - DISABLE: Recommened, when you know the mesh to avoid to pay O(n^2) runtime. Disables ALL checks + - HEAL: Automatically fixes the normal_orientation and vertex ordering to the correct values + Raises: + ValueError if `integrity_check` is set to AUTOMATIC or VERIFY and the mesh is inconsistent + + Note: + The integrity_check is automatically enabled to avoid wrong results due to the wrong vertex ordering. + The check requires O(n^2) operations. You want to turn this off, when you know you mesh! + )mydelimiter", + py::arg("polyhedral_source"), + py::arg("density"), + py::arg("normal_orientation") = NormalOrientation::OUTWARDS, + py::arg("integrity_check") = PolyhedronIntegrity::AUTOMATIC + ) + .def("check_normal_orientation", &Polyhedron::checkPlaneUnitNormalOrientation, R"mydelimiter( + Returns a tuple consisting of majority plane unit normal orientation, + i.e. the direction in which at least more than half of the plane unit normals point, + and the indices of the faces violating this orientation, i.e. the faces whose plane unit normals point in the other direction. + The set of incides vioalting the property is empty if the mesh has a clear ordering. + The set contains values if the mesh is incosistent. + + Returns: + Tuple consisting consisting of majority plane unit normal orientation and the indices of the faces violating this orientation. + + Note: + This utility is mainly for diagnostics and debugging purposes. If the polyhedron is constrcuted with `integrity_check` + set to AUTOMATIC or VERIFY, the construction fails anyways. + If set to HEAL, this method should return an empty set (but maybe a different ordering than initially specified) + Only if set to DISABLE, then this method might actually return a set with faulty indices. + Hence, if you want to know your mesh error. Construct the polyhedron with `integrity_check=DISABLE` and call this method. + )mydelimiter") + .def("__getitem__", &Polyhedron::getResolvedFace, R"mydelimiter( + Returns the the three cooridnates of the vertices making the face at the requested index. Args: - input_files (List[str]): list of input files. + index: The index of the face + Returns: - True if no triangle is degenerate and the polyhedron's plane unit normals are all pointing outwards. - )mydelimiter", py::arg("input_files")); -} + The resolved face (so the vertices as coordinates) as (3, 3)-array + + Raises: + IndexError if face index is out-of-bounds + )mydelimiter", py::arg("index")) + .def_property_readonly("vertices", &Polyhedron::getVertices, "The vertices (type: floats) of the polyhedron as (N, 3)-array") + .def_property_readonly("faces", &Polyhedron::getFace, "The faces (type: int) of the polyhedron as (M, 3) array") + .def_property("density", &Polyhedron::getDensity, &Polyhedron::setDensity, "The density (mutable) of the polyhedron") + .def_property_readonly("normal_orientation", &Polyhedron::getOrientation, "The plane unit normal orientation of the polyhedron"); + +// py::class_(m, "GravityEvaluable", R"mydelimiter( +// A class to evaluate the polyhedral gravity model for a given constant density polyhedron at a given computation point. +// It provides a __call__ method to evaluate the polyhedral gravity model for computation points while +// also caching the polyhedron data over the lifetime of the object. +// )mydelimiter") +// .def(py::init(), +// R"mydelimiter( +// Creates a new GravityEvaluable for a given constant density polyhedron. +// It provides a __call__ method to evaluate the polyhedral gravity model for computation points while +// also caching the polyhedron data over the lifetime of the object. +// +// Args: +// polyhedral_source: The vertices & faces of the polyhedron as tuple or +// the filenames of the files containing the vertices & faces as list of strings +// density: The constant density of the polyhedron in [kg/m^3] +// )mydelimiter", +// py::arg("polyhedral_source"), +// py::arg("density")) +// .def("__repr__", &GravityEvaluable::toString) +// .def("__call__", &GravityEvaluable::operator(), +// R"mydelimiter( +// Evaluates the polyhedral gravity model for a given constant density polyhedron at a given computation point. +// +// Args: +// computation_points: The computation points as tuple or list of points +// parallel: If true, the computation is done in parallel (default: true) +// +// Returns: +// Either a tuple of potential, acceleration and second derivatives at the computation points or +// if multiple computation points are given, the result is a list of tuples +// )mydelimiter", py::arg("computation_points"), py::arg("parallel") = true) +// .def(py::pickle( +// [](const GravityEvaluable &evaluable) { +// const auto &[polyhedron, density, orientation, segmentVectors, planeUnitNormals, segmentUnitNormals] = +// evaluable.getState(); +// return py::make_tuple(polyhedron.getVertices(), polyhedron.getFaces(), density, orientation, segmentVectors, +// planeUnitNormals, segmentUnitNormals); +// }, +// [](const py::tuple &tuple) { +// constexpr size_t tupleSize = 7; +// if (tuple.size() != tupleSize) { +// throw std::runtime_error("Invalid state!"); +// } +// Polyhedron polyhedron{ +// tuple[0].cast>(), tuple[1].cast>() +// }; +// GravityEvaluable evaluable{ +// polyhedron, tuple[2].cast(), tuple[3].cast(), tuple[4].cast>(), +// tuple[5].cast>(), tuple[6].cast>() +// }; +// return evaluable; +// } +// )); +// +// m.def("evaluate", [](const PolyhedralSource &polyhedralSource, double density, +// const std::variant> &computationPoints, +// bool parallel) -> std::variant> { +// using namespace polyhedralGravity; +// if (std::holds_alternative(computationPoints)) { +// return std::visit([&density, &computationPoints, parallel](const auto &source) { +// using namespace polyhedralGravity; +// return GravityModel::evaluate(source, density, std::get(computationPoints), parallel); +// }, polyhedralSource); +// } else { +// return std::visit([&density, &computationPoints, parallel](const auto &source) { +// using namespace polyhedralGravity; +// return GravityModel::evaluate(source, density, std::get>(computationPoints), +// parallel); +// }, polyhedralSource); +// } +// }, R"mydelimiter( +// Evaluates the polyhedral gravity model for a given constant density polyhedron at a given computation point. +// +// Args: +// polyhedral_source: The vertices & faces of the polyhedron as tuple or +// the filenames of the files containing the vertices & faces as list of strings +// density: The constant density of the polyhedron in [kg/m^3] +// computation_points: The computation points as tuple or list of points +// parallel: If true, the computation is done in parallel (default: true) +// +// Returns: +// Either a tuple of potential, acceleration and second derivatives at the computation points or +// if multiple computation points are given, the result is a list of tuples +// )mydelimiter", py::arg("polyhedral_source"), py::arg("density"), py::arg("computation_points"), +// py::arg("parallel") = true); +// +// py::module_ utility = m.def_submodule("utility", +// "This submodule contains useful utility functions like parsing meshes " +// "or checking if the polyhedron's mesh plane unit normals point outwards " +// "like it is required by the polyhedral-gravity model."); +// +// utility.def("read", [](const std::vector &filenames) { +// TetgenAdapter tetgen{filenames}; +// auto polyhedron = tetgen.getPolyhedralSource(); +// return std::make_tuple(polyhedron.getVertices(), polyhedron.getFaces()); +// }, R"mydelimiter( +// Reads a polyhedron from a mesh file. The vertices and faces are read from input +// files (either .node/.face, mesh, .ply, .off, .stl). File-Order matters in case of the first option! +// +// Args: +// input_files (List[str]): list of input files. +// Returns: +// tuple of vertices (N, 3) (floats) and faces (N, 3) (ints). +// )mydelimiter", py::arg("input_files")); +// +// utility.def("check_mesh", [](const std::vector &vertices, const std::vector &faces) { +// Polyhedron poly{vertices, faces}; +// return MeshChecking::checkTrianglesNotDegenerated(poly) && MeshChecking::checkPlaneUnitNormalOrientation(poly); +// }, R"mydelimiter( +// Checks if no triangles of the polyhedral mesh are degenerated by checking that their surface area +// is greater zero. +// Further, Checks if all the polyhedron's plane unit normals are pointing outwards. +// +// Args: +// vertices (2-D array-like): (N, 3) array of vertex coordinates (floats). +// faces (2-D array-like): (N, 3) array of faces, vertex-indices (ints). +// Returns: +// True if no triangle is degenerate and the polyhedron's plane unit normals are all pointing outwards. +// )mydelimiter", py::arg("vertices"), py::arg("faces")); +// +// +// utility.def("check_mesh", [](const std::vector &filenames) { +// TetgenAdapter tetgen{filenames}; +// Polyhedron poly = tetgen.getPolyhedralSource(); +// return MeshChecking::checkTrianglesNotDegenerated(poly) && MeshChecking::checkPlaneUnitNormalOrientation(poly); +// }, R"mydelimiter( +// Checks if no triangles of the polyhedral mesh are degenerated by checking that their surface area +// is greater zero. +// Further, Checks if all the polyhedron's plane unit normals are pointing outwards. +// Reads a polyhedron from a mesh file. The vertices and faces are read from input +// files (either .node/.face, mesh, .ply, .off, .stl). File-Order matters in case of the first option! +// +// Args: +// input_files (List[str]): list of input files. +// Returns: +// True if no triangle is degenerate and the polyhedron's plane unit normals are all pointing outwards. +// )mydelimiter", py::arg("input_files")); +} \ No newline at end of file From 3bb7843deb0df3842a1560911b78df428fa01789 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Tue, 16 Apr 2024 23:25:22 +0200 Subject: [PATCH 17/54] new Python interface - part 2 --- src/polyhedralGravity/model/Polyhedron.cpp | 3 + src/polyhedralGravity/model/Polyhedron.h | 6 + .../PolyhedralGravityPython.cpp | 417 ++++++++---------- 3 files changed, 191 insertions(+), 235 deletions(-) diff --git a/src/polyhedralGravity/model/Polyhedron.cpp b/src/polyhedralGravity/model/Polyhedron.cpp index 86b9cac..01e44de 100644 --- a/src/polyhedralGravity/model/Polyhedron.cpp +++ b/src/polyhedralGravity/model/Polyhedron.cpp @@ -79,6 +79,9 @@ namespace polyhedralGravity { return sstream.str(); } + std::tuple, std::vector, double, NormalOrientation> Polyhedron::getState() const { + return std::make_tuple(_vertices, _faces, _density, _orientation); + } std::pair> Polyhedron::checkPlaneUnitNormalOrientation() const { // 1. Step: Find all indices of normals which vioate the constraint outwards pointing diff --git a/src/polyhedralGravity/model/Polyhedron.h b/src/polyhedralGravity/model/Polyhedron.h index dc0b029..396bcc9 100644 --- a/src/polyhedralGravity/model/Polyhedron.h +++ b/src/polyhedralGravity/model/Polyhedron.h @@ -276,6 +276,12 @@ namespace polyhedralGravity { */ [[nodiscard]] std::string toString() const; + /** + * Returns the internal data strcuture of Python pickle support. + * @return tuple of vertices, faces, density and normal orientation + */ + [[nodiscard]] std::tuple, std::vector, double, NormalOrientation> getState() const; + /** * An iterator transforming the polyhedron's coordinates on demand by a given offset. * This function returns a pair of transform iterators (first = begin(), second = end()). diff --git a/src/polyhedralGravityPython/PolyhedralGravityPython.cpp b/src/polyhedralGravityPython/PolyhedralGravityPython.cpp index b85a6dd..0e0fd5b 100644 --- a/src/polyhedralGravityPython/PolyhedralGravityPython.cpp +++ b/src/polyhedralGravityPython/PolyhedralGravityPython.cpp @@ -18,32 +18,32 @@ namespace py = pybind11; PYBIND11_MODULE(polyhedral_gravity, m) { using namespace polyhedralGravity; m.doc() = "Computes the full gravity tensor for a given constant density polyhedron which consists of some " - "vertices and triangular faces at a given computation points"; + "vertices and triangular faces at a given computation points accoring to the geodetic convention"; py::enum_(m, "NormalOrientation", R"mydelimiter( - The orientation of the plane unit normals of the polyhedron. - Tsoulis et al. equations require the normals to point outwards of the polyhedron. - If the opposite hold, the result is negated. - The implementation can handle both cases. + The orientation of the plane unit normals of the polyhedron. + Tsoulis et al. equations require the normals to point outwards of the polyhedron. + If the opposite hold, the result is negated. + The implementation can handle both cases. )mydelimiter") - .value("OUTWARDS", NormalOrientation::OUTWARDS, "Outwards pointing plane unit normals") - .value("INWARDS", NormalOrientation::INWWARDS, "Inwards pointing plane unit normals"); + .value("OUTWARDS", NormalOrientation::OUTWARDS, "Outwards pointing plane unit normals") + .value("INWARDS", NormalOrientation::INWWARDS, "Inwards pointing plane unit normals"); py::enum_(m, "PolyhedronIntegrity", R"mydelimiter( - The pointing direction of the normals of a Polyhedron. - They can either point outwards or inwards the polyhedron. + The pointing direction of the normals of a Polyhedron. + They can either point outwards or inwards the polyhedron. )mydelimiter") - .value("DISABLE", PolyhedronIntegrity::DISABLE, - "All activities regarding MeshChecking are disabled. No runtime overhead!") - .value("VERIFY", PolyhedronIntegrity::VERIFY, - "Only verification of the NormalOrientation. " - "A misalignment (e.g. specified OUTWARDS, but is not) leads to a runtime_error. Runtime Cost O(n^2)") - .value("AUTOMATIC", PolyhedronIntegrity::AUTOMATIC, - "Like VERIFY, but also informs the user about the option in any case on the runtime costs. " - "This is the implicit default option. Runtime Cost: O(n^2) and output to stdout in every case!" ) - .value("HEAL", PolyhedronIntegrity::HEAL, - "Verification and Autmatioc Healing of the NormalOrientation. " - "A misalignemt does not lead to a runtime_error, but to an internal correction of vertices ordering. Runtime Cost: @f$O(n^2)$@f"); + .value("DISABLE", PolyhedronIntegrity::DISABLE, + "All activities regarding MeshChecking are disabled. No runtime overhead!") + .value("VERIFY", PolyhedronIntegrity::VERIFY, + "Only verification of the NormalOrientation. " + "A misalignment (e.g. specified OUTWARDS, but is not) leads to a runtime_error. Runtime Cost O(n^2)") + .value("AUTOMATIC", PolyhedronIntegrity::AUTOMATIC, + "Like VERIFY, but also informs the user about the option in any case on the runtime costs. " + "This is the implicit default option. Runtime Cost: O(n^2) and output to stdout in every case!") + .value("HEAL", PolyhedronIntegrity::HEAL, + "Verification and Autmatioc Healing of the NormalOrientation. " + "A misalignemt does not lead to a runtime_error, but to an internal correction of vertices ordering. Runtime Cost: @f$O(n^2)$@f"); py::class_(m, "Polyhedron", R"mydelimiter( A constant density Polyhedron stores the mesh data consisting of vertices and triangular faces. @@ -51,232 +51,179 @@ PYBIND11_MODULE(polyhedral_gravity, m) { Tsoulis et al.'s polyhedral gravity model requires that the plane unit normals of every face are pointing outwards of the polyhedron. Otherwise the results are negated. The class by default enforces this constraints and offers utility to (automatically) make the input data obey to this constraint. - )mydelimiter") - .def(py::init(), - R"mydelimiter( - Creates a new Polyhedron from vertices and faces and a constant density. - If the integrity_check is not set to DISABLE, the mesh integrity is checked - (so that it fits the specification of the polyhedral model by Tsoulis et al.) - - Args: - polyhedral_source: The vertices & faces of the polyhedron as pair of (N, 3)-arrays - density: The constant density of the polyhedron, it must match the mesh's units, e.g. mesh in [m] then density in [kg/m^3] - normal_orientation: The pointing direction of the mesh's plane unit normals, i.e., either OUTWARDS or INWARDS of the polyhedron - (default: OUTWARDS) - integrity_check: Conducts an Integrity Check (degenerated faces/ vertex ordering) depending on the values. Options - - AUTOMATIC (Default): Prints to stdout and throws ValueError if normal_orientation is wrong/ inconsisten - - VERIFY: Like AUTOMATIC, but does not print to stdout - - DISABLE: Recommened, when you know the mesh to avoid to pay O(n^2) runtime. Disables ALL checks - - HEAL: Automatically fixes the normal_orientation and vertex ordering to the correct values - Raises: - ValueError if `integrity_check` is set to AUTOMATIC or VERIFY and the mesh is inconsistent - - Note: - The integrity_check is automatically enabled to avoid wrong results due to the wrong vertex ordering. - The check requires O(n^2) operations. You want to turn this off, when you know you mesh! + )mydelimiter") + .def(py::init(), R"mydelimiter( + Creates a new Polyhedron from vertices and faces and a constant density. + If the integrity_check is not set to DISABLE, the mesh integrity is checked + (so that it fits the specification of the polyhedral model by Tsoulis et al.) + + Args: + polyhedral_source: The vertices & faces of the polyhedron as pair of (N, 3)-arrays + density: The constant density of the polyhedron, it must match the mesh's units, e.g. mesh in [m] then density in [kg/m^3] + normal_orientation: The pointing direction of the mesh's plane unit normals, i.e., either OUTWARDS or INWARDS of the polyhedron + (default: OUTWARDS) + integrity_check: Conducts an Integrity Check (degenerated faces/ vertex ordering) depending on the values. Options + - AUTOMATIC (Default): Prints to stdout and throws ValueError if normal_orientation is wrong/ inconsisten + - VERIFY: Like AUTOMATIC, but does not print to stdout + - DISABLE: Recommened, when you know the mesh to avoid to pay O(n^2) runtime. Disables ALL checks + - HEAL: Automatically fixes the normal_orientation and vertex ordering to the correct values + Raises: + ValueError if `integrity_check` is set to AUTOMATIC or VERIFY and the mesh is inconsistent + + Note: + The integrity_check is automatically enabled to avoid wrong results due to the wrong vertex ordering. + The check requires O(n^2) operations. You want to turn this off, when you know you mesh! )mydelimiter", - py::arg("polyhedral_source"), - py::arg("density"), - py::arg("normal_orientation") = NormalOrientation::OUTWARDS, - py::arg("integrity_check") = PolyhedronIntegrity::AUTOMATIC - ) - .def(py::init(), - R"mydelimiter( - Creates a new Polyhedron from vertices and faces and a constant density. - If the integrity_check is not set to DISABLE, the mesh integrity is checked - (so that it fits the specification of the polyhedral model by Tsoulis et al.) - - Args: - polyhedral_source: The filenames of the files containing the vertices & faces as list of strings - density: The constant density of the polyhedron, it must match the mesh's units, e.g. mesh in [m] then density in [kg/m^3] - normal_orientation: The pointing direction of the mesh's plane unit normals, i.e., either OUTWARDS or INWARDS of the polyhedron - (default: OUTWARDS) - integrity_check: Conducts an Integrity Check (degenerated faces/ vertex ordering) depending on the values. Options - - AUTOMATIC (Default): Prints to stdout and throws ValueError if normal_orientation is wrong/ inconsisten - - VERIFY: Like AUTOMATIC, but does not print to stdout - - DISABLE: Recommened, when you know the mesh to avoid to pay O(n^2) runtime. Disables ALL checks - - HEAL: Automatically fixes the normal_orientation and vertex ordering to the correct values - Raises: - ValueError if `integrity_check` is set to AUTOMATIC or VERIFY and the mesh is inconsistent - - Note: - The integrity_check is automatically enabled to avoid wrong results due to the wrong vertex ordering. - The check requires O(n^2) operations. You want to turn this off, when you know you mesh! + py::arg("polyhedral_source"), + py::arg("density"), + py::arg("normal_orientation") = NormalOrientation::OUTWARDS, + py::arg("integrity_check") = PolyhedronIntegrity::AUTOMATIC + ) + .def(py::init(), R"mydelimiter( + Creates a new Polyhedron from vertices and faces and a constant density. + If the integrity_check is not set to DISABLE, the mesh integrity is checked + (so that it fits the specification of the polyhedral model by Tsoulis et al.) + + Args: + polyhedral_source: The filenames of the files containing the vertices & faces as list of strings + density: The constant density of the polyhedron, it must match the mesh's units, e.g. mesh in [m] then density in [kg/m^3] + normal_orientation: The pointing direction of the mesh's plane unit normals, i.e., either OUTWARDS or INWARDS of the polyhedron + (default: OUTWARDS) + integrity_check: Conducts an Integrity Check (degenerated faces/ vertex ordering) depending on the values. Options + - AUTOMATIC (Default): Prints to stdout and throws ValueError if normal_orientation is wrong/ inconsisten + - VERIFY: Like AUTOMATIC, but does not print to stdout + - DISABLE: Recommened, when you know the mesh to avoid to pay O(n^2) runtime. Disables ALL checks + - HEAL: Automatically fixes the normal_orientation and vertex ordering to the correct values + Raises: + ValueError if `integrity_check` is set to AUTOMATIC or VERIFY and the mesh is inconsistent + + Note: + The integrity_check is automatically enabled to avoid wrong results due to the wrong vertex ordering. + The check requires O(n^2) operations. You want to turn this off, when you know you mesh! )mydelimiter", - py::arg("polyhedral_source"), - py::arg("density"), - py::arg("normal_orientation") = NormalOrientation::OUTWARDS, - py::arg("integrity_check") = PolyhedronIntegrity::AUTOMATIC - ) + py::arg("polyhedral_source"), + py::arg("density"), + py::arg("normal_orientation") = NormalOrientation::OUTWARDS, + py::arg("integrity_check") = PolyhedronIntegrity::AUTOMATIC + ) .def("check_normal_orientation", &Polyhedron::checkPlaneUnitNormalOrientation, R"mydelimiter( - Returns a tuple consisting of majority plane unit normal orientation, - i.e. the direction in which at least more than half of the plane unit normals point, - and the indices of the faces violating this orientation, i.e. the faces whose plane unit normals point in the other direction. - The set of incides vioalting the property is empty if the mesh has a clear ordering. - The set contains values if the mesh is incosistent. - - Returns: - Tuple consisting consisting of majority plane unit normal orientation and the indices of the faces violating this orientation. - - Note: - This utility is mainly for diagnostics and debugging purposes. If the polyhedron is constrcuted with `integrity_check` - set to AUTOMATIC or VERIFY, the construction fails anyways. - If set to HEAL, this method should return an empty set (but maybe a different ordering than initially specified) - Only if set to DISABLE, then this method might actually return a set with faulty indices. - Hence, if you want to know your mesh error. Construct the polyhedron with `integrity_check=DISABLE` and call this method. + Returns a tuple consisting of majority plane unit normal orientation, + i.e. the direction in which at least more than half of the plane unit normals point, + and the indices of the faces violating this orientation, i.e. the faces whose plane unit normals point in the other direction. + The set of incides vioalting the property is empty if the mesh has a clear ordering. + The set contains values if the mesh is incosistent. + + Returns: + Tuple consisting consisting of majority plane unit normal orientation and the indices of the faces violating this orientation. + + Note: + This utility is mainly for diagnostics and debugging purposes. If the polyhedron is constrcuted with `integrity_check` + set to AUTOMATIC or VERIFY, the construction fails anyways. + If set to HEAL, this method should return an empty set (but maybe a different ordering than initially specified) + Only if set to DISABLE, then this method might actually return a set with faulty indices. + Hence, if you want to know your mesh error. Construct the polyhedron with `integrity_check=DISABLE` and call this method. )mydelimiter") .def("__getitem__", &Polyhedron::getResolvedFace, R"mydelimiter( - Returns the the three cooridnates of the vertices making the face at the requested index. + Returns the the three cooridnates of the vertices making the face at the requested index. - Args: - index: The index of the face + Args: + index: The index of the face - Returns: - The resolved face (so the vertices as coordinates) as (3, 3)-array + Returns: + The resolved face (so the vertices as coordinates) as (3, 3)-array - Raises: - IndexError if face index is out-of-bounds + Raises: + IndexError if face index is out-of-bounds )mydelimiter", py::arg("index")) + .def("__repr__", &Polyhedron::toString, "Returns a string representation of this polyhedron") .def_property_readonly("vertices", &Polyhedron::getVertices, "The vertices (type: floats) of the polyhedron as (N, 3)-array") .def_property_readonly("faces", &Polyhedron::getFace, "The faces (type: int) of the polyhedron as (M, 3) array") .def_property("density", &Polyhedron::getDensity, &Polyhedron::setDensity, "The density (mutable) of the polyhedron") - .def_property_readonly("normal_orientation", &Polyhedron::getOrientation, "The plane unit normal orientation of the polyhedron"); + .def_property_readonly("normal_orientation", &Polyhedron::getOrientation, "The plane unit normal orientation of the polyhedron") + .def(py::pickle( + [](const Polyhedron &polyhedron) { + const auto &[vertices, faces, density, orientation] = polyhedron.getState(); + return py::make_tuple(vertices, faces, density, orientation); + }, + [](const py::tuple &tuple) { + constexpr size_t tupleSize = 4; + if (tuple.size() != tupleSize) { + throw std::runtime_error("Invalid state!"); + } + Polyhedron polyhedron{ + tuple[0].cast>(), tuple[1].cast>(), + tuple[2].cast(), tuple[3].cast() + }; + return polyhedron; + } + )); + + py::class_(m, "GravityEvaluable", R"mydelimiter( + A class to evaluate the polyhedral gravity model for a given constant density polyhedron at a given computation point. + It provides a __call__ method to evaluate the polyhedral gravity model for computation points while + also caching the polyhedron & intermediate results over the lifetime of the object. + )mydelimiter") + .def(py::init(),R"mydelimiter( + Creates a new GravityEvaluable for a given constant density polyhedron. + It provides a __call__ method to evaluate the polyhedral gravity model for computation points while + also caching the polyhedron & intermediate results over the lifetime of the object. + + Args: + polyhedron: The polyhedron for which to evaluate the gravity model + )mydelimiter", py::arg("polyhedron")) + .def("__repr__", &GravityEvaluable::toString, "Returns a string representation of this GravityEvaluable") + .def("__call__", &GravityEvaluable::operator(), + R"mydelimiter( + Evaluates the polyhedral gravity model for a given constant density polyhedron at a given computation point. + + Args: + computation_points: The computation points as tuple or list of points + parallel: If true, the computation is done in parallel (default: true) + + Returns: + Either a tuple of potential, acceleration and second derivatives at the computation points or + if multiple computation points are given, the result is a list of tuples + )mydelimiter", py::arg("computation_points"), py::arg("parallel") = true) + .def(py::pickle( + [](const GravityEvaluable &evaluable) { + const auto &[polyhedron, segmentVectors, planeUnitNormals, segmentUnitNormals] = evaluable.getState(); + return py::make_tuple(polyhedron, segmentVectors, planeUnitNormals, segmentUnitNormals); + }, + [](const py::tuple &tuple) { + constexpr size_t tupleSize = 4; + if (tuple.size() != tupleSize) { + throw std::runtime_error("Invalid state!"); + } + GravityEvaluable evaluable{ + tuple[0].cast(), tuple[1].cast>(), + tuple[2].cast>(), tuple[3].cast>() + }; + return evaluable; + } + )); + + m.def("evaluate", [](const Polyhedron &polyhedron, + const std::variant> &computationPoints, + bool parallel) -> std::variant> { + return std::visit(util::overloaded{ + [&](const Array3 &point) { + return std::variant>(GravityModel::evaluate(polyhedron, point, parallel)); + }, + [&](const std::vector &points) { + return std::variant>(GravityModel::evaluate(polyhedron, points, parallel)); + } + }, computationPoints); + }, R"mydelimiter( + Evaluates the polyhedral gravity model for a given constant density polyhedron at a given computation point. + + Args: + polyhedron: The polyhedron for which to evaluate the gravity model + computation_points: The computation points as tuple or list of points + parallel: If true, the computation is done in parallel (default: true) + + Returns: + Either a tuple of potential, acceleration and second derivatives at the computation points or + if multiple computation points are given, the result is a list of tuples + )mydelimiter", py::arg("polyhedron"), py::arg("computation_points"), py::arg("parallel") = true); -// py::class_(m, "GravityEvaluable", R"mydelimiter( -// A class to evaluate the polyhedral gravity model for a given constant density polyhedron at a given computation point. -// It provides a __call__ method to evaluate the polyhedral gravity model for computation points while -// also caching the polyhedron data over the lifetime of the object. -// )mydelimiter") -// .def(py::init(), -// R"mydelimiter( -// Creates a new GravityEvaluable for a given constant density polyhedron. -// It provides a __call__ method to evaluate the polyhedral gravity model for computation points while -// also caching the polyhedron data over the lifetime of the object. -// -// Args: -// polyhedral_source: The vertices & faces of the polyhedron as tuple or -// the filenames of the files containing the vertices & faces as list of strings -// density: The constant density of the polyhedron in [kg/m^3] -// )mydelimiter", -// py::arg("polyhedral_source"), -// py::arg("density")) -// .def("__repr__", &GravityEvaluable::toString) -// .def("__call__", &GravityEvaluable::operator(), -// R"mydelimiter( -// Evaluates the polyhedral gravity model for a given constant density polyhedron at a given computation point. -// -// Args: -// computation_points: The computation points as tuple or list of points -// parallel: If true, the computation is done in parallel (default: true) -// -// Returns: -// Either a tuple of potential, acceleration and second derivatives at the computation points or -// if multiple computation points are given, the result is a list of tuples -// )mydelimiter", py::arg("computation_points"), py::arg("parallel") = true) -// .def(py::pickle( -// [](const GravityEvaluable &evaluable) { -// const auto &[polyhedron, density, orientation, segmentVectors, planeUnitNormals, segmentUnitNormals] = -// evaluable.getState(); -// return py::make_tuple(polyhedron.getVertices(), polyhedron.getFaces(), density, orientation, segmentVectors, -// planeUnitNormals, segmentUnitNormals); -// }, -// [](const py::tuple &tuple) { -// constexpr size_t tupleSize = 7; -// if (tuple.size() != tupleSize) { -// throw std::runtime_error("Invalid state!"); -// } -// Polyhedron polyhedron{ -// tuple[0].cast>(), tuple[1].cast>() -// }; -// GravityEvaluable evaluable{ -// polyhedron, tuple[2].cast(), tuple[3].cast(), tuple[4].cast>(), -// tuple[5].cast>(), tuple[6].cast>() -// }; -// return evaluable; -// } -// )); -// -// m.def("evaluate", [](const PolyhedralSource &polyhedralSource, double density, -// const std::variant> &computationPoints, -// bool parallel) -> std::variant> { -// using namespace polyhedralGravity; -// if (std::holds_alternative(computationPoints)) { -// return std::visit([&density, &computationPoints, parallel](const auto &source) { -// using namespace polyhedralGravity; -// return GravityModel::evaluate(source, density, std::get(computationPoints), parallel); -// }, polyhedralSource); -// } else { -// return std::visit([&density, &computationPoints, parallel](const auto &source) { -// using namespace polyhedralGravity; -// return GravityModel::evaluate(source, density, std::get>(computationPoints), -// parallel); -// }, polyhedralSource); -// } -// }, R"mydelimiter( -// Evaluates the polyhedral gravity model for a given constant density polyhedron at a given computation point. -// -// Args: -// polyhedral_source: The vertices & faces of the polyhedron as tuple or -// the filenames of the files containing the vertices & faces as list of strings -// density: The constant density of the polyhedron in [kg/m^3] -// computation_points: The computation points as tuple or list of points -// parallel: If true, the computation is done in parallel (default: true) -// -// Returns: -// Either a tuple of potential, acceleration and second derivatives at the computation points or -// if multiple computation points are given, the result is a list of tuples -// )mydelimiter", py::arg("polyhedral_source"), py::arg("density"), py::arg("computation_points"), -// py::arg("parallel") = true); -// -// py::module_ utility = m.def_submodule("utility", -// "This submodule contains useful utility functions like parsing meshes " -// "or checking if the polyhedron's mesh plane unit normals point outwards " -// "like it is required by the polyhedral-gravity model."); -// -// utility.def("read", [](const std::vector &filenames) { -// TetgenAdapter tetgen{filenames}; -// auto polyhedron = tetgen.getPolyhedralSource(); -// return std::make_tuple(polyhedron.getVertices(), polyhedron.getFaces()); -// }, R"mydelimiter( -// Reads a polyhedron from a mesh file. The vertices and faces are read from input -// files (either .node/.face, mesh, .ply, .off, .stl). File-Order matters in case of the first option! -// -// Args: -// input_files (List[str]): list of input files. -// Returns: -// tuple of vertices (N, 3) (floats) and faces (N, 3) (ints). -// )mydelimiter", py::arg("input_files")); -// -// utility.def("check_mesh", [](const std::vector &vertices, const std::vector &faces) { -// Polyhedron poly{vertices, faces}; -// return MeshChecking::checkTrianglesNotDegenerated(poly) && MeshChecking::checkPlaneUnitNormalOrientation(poly); -// }, R"mydelimiter( -// Checks if no triangles of the polyhedral mesh are degenerated by checking that their surface area -// is greater zero. -// Further, Checks if all the polyhedron's plane unit normals are pointing outwards. -// -// Args: -// vertices (2-D array-like): (N, 3) array of vertex coordinates (floats). -// faces (2-D array-like): (N, 3) array of faces, vertex-indices (ints). -// Returns: -// True if no triangle is degenerate and the polyhedron's plane unit normals are all pointing outwards. -// )mydelimiter", py::arg("vertices"), py::arg("faces")); -// -// -// utility.def("check_mesh", [](const std::vector &filenames) { -// TetgenAdapter tetgen{filenames}; -// Polyhedron poly = tetgen.getPolyhedralSource(); -// return MeshChecking::checkTrianglesNotDegenerated(poly) && MeshChecking::checkPlaneUnitNormalOrientation(poly); -// }, R"mydelimiter( -// Checks if no triangles of the polyhedral mesh are degenerated by checking that their surface area -// is greater zero. -// Further, Checks if all the polyhedron's plane unit normals are pointing outwards. -// Reads a polyhedron from a mesh file. The vertices and faces are read from input -// files (either .node/.face, mesh, .ply, .off, .stl). File-Order matters in case of the first option! -// -// Args: -// input_files (List[str]): list of input files. -// Returns: -// True if no triangle is degenerate and the polyhedron's plane unit normals are all pointing outwards. -// )mydelimiter", py::arg("input_files")); } \ No newline at end of file From 27f83edb238ff609227459d746f56a4601e42f91 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Tue, 16 Apr 2024 23:44:33 +0200 Subject: [PATCH 18/54] finalize the tests for the new Python interface --- .../PolyhedralGravityPython.cpp | 1 - test/python/test_polyhedral_gravity.py | 27 +++++++++++++------ 2 files changed, 19 insertions(+), 9 deletions(-) diff --git a/src/polyhedralGravityPython/PolyhedralGravityPython.cpp b/src/polyhedralGravityPython/PolyhedralGravityPython.cpp index 0e0fd5b..53abbe8 100644 --- a/src/polyhedralGravityPython/PolyhedralGravityPython.cpp +++ b/src/polyhedralGravityPython/PolyhedralGravityPython.cpp @@ -10,7 +10,6 @@ #include "polyhedralGravity/model/GravityModelData.h" #include "polyhedralGravity/model/GravityModel.h" #include "polyhedralGravity/model/GravityEvaluable.h" -#include "polyhedralGravity/input/TetgenAdapter.h" namespace py = pybind11; diff --git a/test/python/test_polyhedral_gravity.py b/test/python/test_polyhedral_gravity.py index bb7ec94..0265b86 100644 --- a/test/python/test_polyhedral_gravity.py +++ b/test/python/test_polyhedral_gravity.py @@ -1,5 +1,5 @@ from typing import Tuple, List, Union -import polyhedral_gravity +from polyhedral_gravity import Polyhedron, GravityEvaluable, evaluate, PolyhedronIntegrity, NormalOrientation import numpy as np import pickle import pytest @@ -59,11 +59,16 @@ def test_polyhedral_gravity( is callable with file/ array inputs. """ points, expected_potential, expected_acceleration = reference_solution - sol = polyhedral_gravity.evaluate( + polyhedron = Polyhedron( polyhedral_source=polyhedral_source, density=DENSITY, + normal_orientation=NormalOrientation.OUTWARDS, + integrity_check=PolyhedronIntegrity.VERIFY, + ) + sol = evaluate( + polyhedron=polyhedron, computation_points=points, - parallel=True + parallel=True, ) potential = np.array([result[0] for result in sol]) acceleration = np.array([result[1] for result in sol]) @@ -82,13 +87,16 @@ def test_polyhedral_gravity_evaluable( is instantiable with file/ array inputs. """ points, expected_potential, expected_acceleration = reference_solution - evaluable = polyhedral_gravity.GravityEvaluable( + polyhedron = Polyhedron( polyhedral_source=polyhedral_source, density=DENSITY, + normal_orientation=NormalOrientation.OUTWARDS, + integrity_check=PolyhedronIntegrity.VERIFY, ) + evaluable = GravityEvaluable(polyhedron=polyhedron) sol = evaluable( computation_points=points, - parallel=True + parallel=True, ) potential = np.array([result[0] for result in sol]) acceleration = np.array([result[1] for result in sol]) @@ -109,10 +117,13 @@ def test_polyhedral_evaluable_pickle( pickled and unpicked as well). """ points, expected_potential, expected_acceleration = reference_solution - initial_evaluable = polyhedral_gravity.GravityEvaluable( + polyhedron = Polyhedron( polyhedral_source=polyhedral_source, - density=DENSITY + density=DENSITY, + normal_orientation=NormalOrientation.OUTWARDS, + integrity_check=PolyhedronIntegrity.DISABLE, ) + initial_evaluable = GravityEvaluable(polyhedron=polyhedron) pickle_output = tmp_path.joinpath("evaluable.pk") with open(pickle_output, "wb") as f: pickle.dump(initial_evaluable, f, pickle.HIGHEST_PROTOCOL) @@ -122,7 +133,7 @@ def test_polyhedral_evaluable_pickle( sol = read_evaluable( computation_points=points, - parallel=True + parallel=True, ) potential = np.array([result[0] for result in sol]) acceleration = np.array([result[1] for result in sol]) From ebf5c8a24afc12aac84bd2452b52f494039864aa Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Wed, 17 Apr 2024 00:23:01 +0200 Subject: [PATCH 19/54] fix missing init --- src/polyhedralGravity/model/Polyhedron.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/polyhedralGravity/model/Polyhedron.cpp b/src/polyhedralGravity/model/Polyhedron.cpp index 01e44de..6ab287a 100644 --- a/src/polyhedralGravity/model/Polyhedron.cpp +++ b/src/polyhedralGravity/model/Polyhedron.cpp @@ -73,7 +73,7 @@ namespace polyhedralGravity { } std::string Polyhedron::toString() const { - std::stringstream sstream; + std::stringstream sstream{}; sstream << ""; return sstream.str(); From 1738c1662274fad54d9e2500182e9ff65d4375a5 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Wed, 17 Apr 2024 00:26:19 +0200 Subject: [PATCH 20/54] fix missing include --- src/polyhedralGravity/model/Polyhedron.h | 1 + 1 file changed, 1 insertion(+) diff --git a/src/polyhedralGravity/model/Polyhedron.h b/src/polyhedralGravity/model/Polyhedron.h index 396bcc9..d6e130c 100644 --- a/src/polyhedralGravity/model/Polyhedron.h +++ b/src/polyhedralGravity/model/Polyhedron.h @@ -10,6 +10,7 @@ #include #include #include +#include #include #include "thrust/copy.h" #include "polyhedralGravity/output/Logging.h" From 125bdacf42a601a26c41c7ee3b953190a4bb82d2 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Wed, 17 Apr 2024 15:26:03 +0200 Subject: [PATCH 21/54] make it possible to build the docs from source locally without CMake --- docs/conf.py | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/docs/conf.py b/docs/conf.py index cadb0cc..05b8341 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -30,9 +30,14 @@ def configure_doxyfile(input_dir, output_dir): file.write(filedata) -# Check if we're running on Read the Docs' servers or in the GitHub Actions Workflow +# If you bild the docs locally, but not via CMake, first set the environment variable BUILD_DOCS_CLI breathe_projects = {} -if os.environ.get("READTHEDOCS", None) is not None or os.environ.get("GITHUB_PAGES_BUILD", None) is not None: +if any([ + os.environ.get("READTHEDOCS", None), + os.environ.get("GITHUB_PAGES_BUILD", None), + os.environ.get("BUILD_DOCS_CLI", None)] +): + # These lines assume that we are in //docs/ folder input_dir = "../src" output_dir = "build" configure_doxyfile(input_dir, output_dir) @@ -50,7 +55,7 @@ def configure_doxyfile(input_dir, output_dir): # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. -extensions = ["breathe"] +extensions = ["breathe", "sphinx.ext.napoleon", "sphinx.ext.autodoc"] # Add any paths that contain templates here, relative to this directory. templates_path = ["_templates"] From f7cb46163447afa4c3bb5aa243a24c0ee498671b Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Wed, 17 Apr 2024 19:34:38 +0200 Subject: [PATCH 22/54] update documentation, make the Python docs autogenerated, add new pytests for the Polyhedron class --- .github/workflows/docs.yml | 3 + docs/api/calculation.rst | 42 ---- docs/api/model.rst | 49 +++- docs/api/python.rst | 135 ++--------- docs/index.rst | 1 - docs/quickstart/overview.rst | 11 +- docs/requirements.txt | 2 +- src/main.cpp | 4 +- src/polyhedralGravity/model/Polyhedron.cpp | 6 +- src/polyhedralGravity/model/Polyhedron.h | 45 ++-- .../PolyhedralGravityPython.cpp | 226 ++++++++++++------ test/model/PolyhedronTest.cpp | 70 +++--- ...edral_gravity.py => test_gravity_model.py} | 68 ++++-- test/python/test_polyhedron.py | 88 +++++++ 14 files changed, 437 insertions(+), 313 deletions(-) delete mode 100644 docs/api/calculation.rst rename test/python/{test_polyhedral_gravity.py => test_gravity_model.py} (58%) create mode 100644 test/python/test_polyhedron.py diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index 3a21df2..9eff77a 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -25,6 +25,9 @@ jobs: - uses: actions/checkout@v3 with: lfs: true + - name: Install polyhedral-gravity from recent source for sphinx.ext.autodoc + shell: bash -l {0} + run: pip install . -vv --no-build-isolation - id: deployment uses: sphinx-notes/pages@v3 with: diff --git a/docs/api/calculation.rst b/docs/api/calculation.rst deleted file mode 100644 index d436430..0000000 --- a/docs/api/calculation.rst +++ /dev/null @@ -1,42 +0,0 @@ -Calculation -=========== - -Overview --------- - -The calculation is the heart of the Polyhedral Gravity Model -since it contains the important function :code:`evaluate(..)` -used evaluation of the polyhedral gravity model at computation -point(s) P. - -Additionally, the class :code:`GravityEvaluable` is provided as a way to -perform the evaluation of the polyhedral gravity model repeatedly -without the need to re-initialize the polyhedron and the gravity model as -some caching is performed. It is recommended to use this feature when evaluating the model repeatedly on a small number of points as the overhead of setting up the models is larger than the computational cost. - -Further, it implements the `Möller–Trumbore intersection algorithm `__ -capable of checking if the plane unit normals of the polyhedron are pointing outwards. - -GravityEvaluable ----------------- - -.. doxygenclass:: polyhedralGravity::GravityEvaluable - - -GravityModel ------------- - -.. doxygennamespace:: polyhedralGravity::GravityModel - - -.. _mesh-checking-cpp: - -MeshChecking ------------- - -.. doxygennamespace:: polyhedralGravity::MeshChecking - -Other ------ - -.. doxygenfunction:: polyhedralGravity::transformPolyhedron diff --git a/docs/api/model.rst b/docs/api/model.rst index 821adc9..2813775 100644 --- a/docs/api/model.rst +++ b/docs/api/model.rst @@ -4,18 +4,53 @@ Model Overview -------- -The Model contains two types of data containers. First, there -is the class :code:`Polyhedron` which consists of a vector -vertices and a vector of triangular faces. Second, there -are Utility Container whose single purpose is improving -code readability in providing named access to their -members. +The model is the heart of the Polyhedral Gravity Model +since it contains the the two major classes: + +* :cpp:class:`polyhedralGravity::Polyhedron` +* :cpp:class:`polyhedralGravity::GravityEvaluable` + +The class :cpp:class:`polyhedralGravity::Polyhedron` stores the mesh and density +information and governs the compliance with Tsoulis et al.’s gravity model’s preconditions +It ensures that all plane unit normals of a constructed Polyhedron are consistently +pointing :cpp:enumerator:`polyhedralGravity::NormalOrientation::OUTWARDS` or +:cpp:enumerator:`polyhedralGravity::NormalOrientation::INWARDS`. +Depending on the value of :cpp:enum:`polyhedralGravity::PolyhedronIntegrity`, these +constraints are either enforced by modifying input mesh data or by throwing +an :cpp:class:`std::invalid_argument` exception. +For this purpose, it uses the `Möller–Trumbore intersection algorithm `__. + + +The class :cpp:class:`polyhedralGravity::GravityEvaluable` is provides as a way to +perform the evaluation of the polyhedral gravity model repeatedly +without the need to re-initialize the polyhedron and the gravity model as +caching is performed. +It takes a :cpp:class:`polyhedralGravity::Polyhedron` and provides an +:cpp:func:`polyhedralGravity::GravityEvaluable::operator()` to evaluate the +model at computation point(s) :math:`P` optionally using parallelization. +A :cpp:func:`polyhedralGravity::GravityModel::evaluate` summarizes the +functionality :cpp:class:`polyhedralGravity::GravityEvaluable`, but does not +provide any caching throughout multiple calls. + Polyhedron ---------- .. doxygenclass:: polyhedralGravity::Polyhedron +.. doxygenenum:: polyhedralGravity::NormalOrientation + +.. doxygenenum:: polyhedralGravity::PolyhedronIntegrity + + +GravityModel +------------ + +.. doxygenclass:: polyhedralGravity::GravityEvaluable + +.. doxygennamespace:: polyhedralGravity::GravityModel + + Named Tuple ----------- @@ -23,4 +58,4 @@ Named Tuple .. doxygenstruct:: polyhedralGravity::TranscendentalExpression -.. doxygenstruct:: polyhedralGravity::HessianPlane +.. doxygenstruct:: polyhedralGravity::HessianPlane \ No newline at end of file diff --git a/docs/api/python.rst b/docs/api/python.rst index 640e439..043fd9f 100644 --- a/docs/api/python.rst +++ b/docs/api/python.rst @@ -1,125 +1,38 @@ -Python API -========== +Python API - polyhedral_gravity +=============================== -polyhedral_gravity ------------------- +Module Overview +--------------- -Computes the full gravity tensor for a given constant density polyhedron which consists of some -vertices and triangular faces at given computation points +.. automodule:: polyhedral_gravity -.. py:module:: polyhedral_gravity +Polyhedron +---------- - .. py:function:: evaluate(polyhedral_source, density, computation_points, parallel=True) +.. autoclass:: polyhedral_gravity.Polyhedron + :members: + :special-members: __init__, __getitem__, __repr__ - Evaluates the polyhedral gravity model for a given constant density polyhedron at a given computation point. +Enums to specify MeshChecks +~~~~~~~~~~~~~~~~~~~~~~~~~~~ - :param Union[Tuple[List[List[float[3]]], List[List[int[3]]]], List[str]] polyhedral_source: - The vertices & faces of the polyhedron as tuple or - the filenames of the files containing the vertices & faces as list of strings - Supports numpy arrays! - Supported are .node/.face, mesh, .ply, .off, .stl files. - :param float density: - The constant density of the polyhedron in :math:`\frac{kg}{m^3}` - :param List[float[3]] computation_points: - The cartesian computation points as tuple or list of points - :param bool parallel: - If true, the computation is done in parallel (default: true) +.. autoclass:: polyhedral_gravity.NormalOrientation - :rtype: Union[Tuple[float, List[float[3]], List[float[6]]], List[Tuple[float, List[float[3]], List[float[6]]]]] - :return: - Either a tuple of potential :math:`V`, acceleration (:math:`V_x, V_y, V_z`) - and second derivatives (:math:`V_{xx}, V_{yy}, V_{zz}, V_{xy}, V_{xz}, V_{yz}`) - at the computation points or if multiple computation points are given, the result is a list of tuples +.. autoclass:: polyhedral_gravity.PolyhedronIntegrity - .. py:class:: GravityEvaluable +GravityModel +------------ - A class to evaluate the polyhedral gravity model for a given constant density polyhedron at a given computation point. - It provides a :code:`__call__` method to evaluate the polyhedral gravity model for computation points while - also caching the polyhedron data over the lifetime of the object. +Single Function +~~~~~~~~~~~~~~~ - .. py:method:: __init__(polyhedral_source, density) +.. autofunction:: polyhedral_gravity.evaluate - :param Union[Tuple[List[List[float[3]]], List[List[int[3]]]], List[str]] polyhedral_source: - The vertices & faces as (N, 3) array-like of the polyhedron as tuple or - the filenames of the files containing the vertices & faces as list of strings - Supports numpy arrays! - Supported are .node/.face, mesh, .ply, .off, .stl files. - :param float density: - The constant density of the polyhedron in :math:`\frac{kg}{m^3}` - .. py:method:: __call__(computation_points, parallel=True) - - Evaluates the polyhedral gravity model for a given constant density polyhedron at a given computation point. - - :param List[float[3]] computation_points: - The cartesian computation point - :param bool parallel: - If true, the computation is done in parallel (default: true) - - :rtype: Tuple[float, List[float[3]], List[float[6]]] - :return: - A tuple of potential :math:`V`, acceleration (:math:`V_x, V_y, V_z`) - and second derivatives (:math:`V_{xx}, V_{yy}, V_{zz}, V_{xy}, V_{xz}, V_{yz}`) - at the computation point. - - .. py:method:: __repr__() - - Returns a string representation of the polyhedral gravity evaluable. - - :rtype: str - :return: A string representation of the polyhedron - - -.. _mesh-checking-python: - -utility -~~~~~~~ - -.. py:module:: polyhedral_gravity.utility - -This submodule contains useful utility functions like parsing meshes -or checking if the polyhedron's mesh plane unit normals point outwards -like it is required by the polyhedral-gravity model. - -.. py:function:: read(input_files) - :noindex: - - Reads a polyhedron from a mesh file. The vertices and faces are read from input - files (either .node/.face, mesh, .ply, .off, .stl). File-Order matters in case of the first option! - - :param List[str] input_files: polyhedral source files - :return: tuple of vertices (N, 3) (floats) and faces (N, 3) (ints) - :rtype: Tuple[List[List[float[3]]], List[List[int[3]]]] - -.. py:function:: check_mesh(vertices, faces) - :noindex: - - Checks if no triangles of the polyhedral mesh are degenerated by checking that their surface area - is greater zero. - Further, Checks if all the polyhedron's plane unit normals are pointing outwards. - - :param List[List[float[3]]] vertices: vertices of the polyhedron - :param List[List[int[3]]] faces: faces of the polyhedron - :return: True if no triangle is degenerate and the polyhedron's plane unit normals are all pointing outwards. - :rtype: Bool - - .. note:: - This method has quadratic runtime complexity :math:`O(n^2)` - -.. py:function:: check_mesh(input_files) - :noindex: - - Checks if no triangles of the polyhedral mesh are degenerate by checking that their surface area - is greater zero. - Further, Checks if all the polyhedron's plane unit normals are pointing outwards. - Reads a polyhedron from a mesh file. The vertices and faces are read from input - files (either .node/.face, mesh, .ply, .off, .stl). File-Order matters in case of the first option! - - :param List[str] input_files: polyhedral source files - :return: True if no triangle is degenerate and the polyhedron's plane unit normals are all pointing outwards. - :rtype: Bool - - .. note:: - This method has quadratic runtime complexity :math:`O(n^2)`. +Cached Evaluation +~~~~~~~~~~~~~~~~~ +.. autoclass:: polyhedral_gravity.GravityEvaluable + :members: + :special-members: __init__, __call__, __repr__ \ No newline at end of file diff --git a/docs/index.rst b/docs/index.rst index 70a964c..6f86206 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -66,7 +66,6 @@ And for more details, refer to the **Python API** or **C++ API**. :maxdepth: 2 api/model - api/calculation api/input api/output api/util diff --git a/docs/quickstart/overview.rst b/docs/quickstart/overview.rst index 8b978b9..afcb532 100644 --- a/docs/quickstart/overview.rst +++ b/docs/quickstart/overview.rst @@ -32,12 +32,11 @@ mesh files. .. note:: - The plane unit normals of every face of the polyhedral mesh must point **outwards** - of the polyhedron! - You can check this property via :ref:`mesh-checking-cpp` in C++ or - via the :ref:`mesh-checking-python` submodule in Python. - If the vertex order of the faces is inverted, i.e. the plane unit normals point - inwards, then the sign of the output will be inverted. + The plane unit normals of every face of the polyhedral mesh must point + consistently **outwards** or **inwards** the polyhedron! + This property is automatically enforced by the class :code:`Polyhedron` in + both C++ library and Python interface as long as not explicit set to :code:`DISABLE`. + Setting this to off, is recommend for advanced users and when you "know your mesh". Gravity Model Output diff --git a/docs/requirements.txt b/docs/requirements.txt index 4aa9922..43f9e87 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -1,2 +1,2 @@ breathe -sphinx-book-theme +sphinx-book-theme \ No newline at end of file diff --git a/src/main.cpp b/src/main.cpp index 4d173af..4692e2c 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -20,11 +20,11 @@ int main(int argc, char *argv[]) { auto density = config->getDensity(); auto computationPoints = config->getPointsOfInterest(); auto outputFileName = config->getOutputFileName(); - bool checkPolyhedralInput = config->getMeshInputCheckStatus(); + PolyhedronIntegrity checkPolyhedralInput = config->getMeshInputCheckStatus() ? PolyhedronIntegrity::HEAL : PolyhedronIntegrity::DISABLE; SPDLOG_LOGGER_INFO(PolyhedralGravityLogger::DEFAULT_LOGGER.getLogger(), "The calculation started..."); auto start = std::chrono::high_resolution_clock::now(); - Polyhedron polyhedron{polyhedralSource, density}; + Polyhedron polyhedron{polyhedralSource, density, NormalOrientation::OUTWARDS, checkPolyhedralInput}; auto result = GravityModel::evaluate(polyhedron, computationPoints, true); auto end = std::chrono::high_resolution_clock::now(); auto duration = end - start; diff --git a/src/polyhedralGravity/model/Polyhedron.cpp b/src/polyhedralGravity/model/Polyhedron.cpp index 6ab287a..dda0482 100644 --- a/src/polyhedralGravity/model/Polyhedron.cpp +++ b/src/polyhedralGravity/model/Polyhedron.cpp @@ -28,6 +28,10 @@ namespace polyhedralGravity { Polyhedron::Polyhedron(const PolyhedralFiles &polyhedralFiles, double density, const NormalOrientation &orientation, const PolyhedronIntegrity &integrity) : Polyhedron{TetgenAdapter{polyhedralFiles}.getPolyhedralSource(), density, orientation, integrity} {} + Polyhedron::Polyhedron(const std::variant &polyhedralSource, double density, const NormalOrientation &orientation, const PolyhedronIntegrity &integrity) + : Polyhedron{std::holds_alternative(polyhedralSource) ? std::get(polyhedralSource) : TetgenAdapter{std::get(polyhedralSource)}.getPolyhedralSource(), + density, orientation, integrity} {} + const std::vector &Polyhedron::getVertices() const { return _vertices; } @@ -111,7 +115,7 @@ namespace polyhedralGravity { ); // 3a. Step: Return the inwards pointing as major orientation and // the violating faces, i.e. which have outwards pointing normals - return std::make_pair(NormalOrientation::INWWARDS, violatingInwards); + return std::make_pair(NormalOrientation::INWARDS, violatingInwards); } // 3b. Step: Return the outwards pointing as major orientation // and the violating faces, i.e. which have inwards pointing normals diff --git a/src/polyhedralGravity/model/Polyhedron.h b/src/polyhedralGravity/model/Polyhedron.h index d6e130c..9f773b1 100644 --- a/src/polyhedralGravity/model/Polyhedron.h +++ b/src/polyhedralGravity/model/Polyhedron.h @@ -45,7 +45,7 @@ namespace polyhedralGravity { /** Outwards pointing plane unit normals */ OUTWARDS, /** Inwards pointing plane unit normals */ - INWWARDS + INWARDS }; @@ -56,17 +56,17 @@ namespace polyhedralGravity { * @param orientation The NormalOrientation enum value to output. * @return The output stream after writing the string representation. */ - inline std::ostream& operator<<(std::ostream& os, const NormalOrientation& orientation) { + inline std::ostream &operator<<(std::ostream &os, const NormalOrientation &orientation) { switch (orientation) { case NormalOrientation::OUTWARDS: os << "OUTWARDS"; - break; - case NormalOrientation::INWWARDS: + break; + case NormalOrientation::INWARDS: os << "INWARDS"; - break; + break; default: os << "Unknown"; - break; + break; } return os; } @@ -139,7 +139,6 @@ namespace polyhedralGravity { NormalOrientation _orientation; public: - /** * Generates a polyhedron from nodes and faces. * @param vertices a vector of nodes @@ -153,12 +152,12 @@ namespace polyhedralGravity { * @throws std::invalid_argument dpending on the {@param integrity} flag */ Polyhedron( - const std::vector &vertices, - const std::vector &faces, - double density, - const NormalOrientation &orientation = NormalOrientation::OUTWARDS, - const PolyhedronIntegrity &integrity = PolyhedronIntegrity::AUTOMATIC - ); + const std::vector &vertices, + const std::vector &faces, + double density, + const NormalOrientation &orientation = NormalOrientation::OUTWARDS, + const PolyhedronIntegrity &integrity = PolyhedronIntegrity::AUTOMATIC + ); /** * Generates a polyhedron from nodes and faces. @@ -172,7 +171,7 @@ namespace polyhedralGravity { * @throws std::invalid_argument dpending on the {@param integrity} flag */ Polyhedron( - const PolyhedralSource& polyhedralSource, + const PolyhedralSource &polyhedralSource, double density, const NormalOrientation &orientation = NormalOrientation::OUTWARDS, const PolyhedronIntegrity &integrity = PolyhedronIntegrity::AUTOMATIC @@ -180,7 +179,7 @@ namespace polyhedralGravity { /** * Generates a polyhedron from nodes and faces. - * @param polyhedralSource a list of files (see {@link TetgenAdapter} or + * @param polyhedralFiles a list of files (see {@link TetgenAdapter} * @param density the density of the polyhedron (it must match the unit of the mesh, e.g., mesh in @f$[m]@f$ requires density in @f$[kg/m^3]@f$) * @param orientation specify if the plane unit normals point outwards or inwards (defaults: to OUTWARDS) * @param integrity specify if the mesh input is checked/ healed to fulfill the constraints of Tsoulis' algorithm (see {@link PolyhedronIntegrity}) @@ -193,6 +192,22 @@ namespace polyhedralGravity { const NormalOrientation &orientation = NormalOrientation::OUTWARDS, const PolyhedronIntegrity &integrity = PolyhedronIntegrity::AUTOMATIC); + /** + * Generates a polyhedron from nodes and faces. + * This constructor using a variant is maninly utilized from the Python Interface. + * @param polyhedralSource a list of files (see {@link TetgenAdapter} or a tuple of vector containing the nodes and trianglular faces. + * @param density the density of the polyhedron (it must match the unit of the mesh, e.g., mesh in @f$[m]@f$ requires density in @f$[kg/m^3]@f$) + * @param orientation specify if the plane unit normals point outwards or inwards (defaults: to OUTWARDS) + * @param integrity specify if the mesh input is checked/ healed to fulfill the constraints of Tsoulis' algorithm (see {@link PolyhedronIntegrity}) + * + * @note ASSERTS PRE-CONDITION that the in the indexing in the faces vector starts with zero! + * @throws std::invalid_argument if no face contains the node zero indicating mathematical index + * @throws std::invalid_argument dpending on the {@param integrity} flag + */ + Polyhedron(const std::variant &polyhedralSource, double density, + const NormalOrientation &orientation = NormalOrientation::OUTWARDS, + const PolyhedronIntegrity &integrity = PolyhedronIntegrity::AUTOMATIC); + /** * Default destructor */ diff --git a/src/polyhedralGravityPython/PolyhedralGravityPython.cpp b/src/polyhedralGravityPython/PolyhedralGravityPython.cpp index 53abbe8..28c9556 100644 --- a/src/polyhedralGravityPython/PolyhedralGravityPython.cpp +++ b/src/polyhedralGravityPython/PolyhedralGravityPython.cpp @@ -16,33 +16,118 @@ namespace py = pybind11; PYBIND11_MODULE(polyhedral_gravity, m) { using namespace polyhedralGravity; - m.doc() = "Computes the full gravity tensor for a given constant density polyhedron which consists of some " - "vertices and triangular faces at a given computation points accoring to the geodetic convention"; + m.doc() = R"mydelimiter( + The evaluation of the polyhedral gravity model requires the following parameters: + + +------------------------------------------------------------------------------+ + | Name | + +==============================================================================+ + | Polyhedral Mesh (either as vertices & faces or as polyhedral source files) | + +------------------------------------------------------------------------------+ + | Constant Density :math:`\rho` | + +------------------------------------------------------------------------------+ + + In the Python Interface, you define these parameters as :py:class:`polyhedral_gravity.Polyhedron` + + .. code-block:: python + + from polyhedral_gravity import Polyhedron, GravityEvaluable, evaluate, PolyhedronIntegrity, NormalOrientation + + polyhedron = Polyhedron( + polyhedral_source=(vertices, faces), # (N,3) and (M,3) array-like + density=density, # Density of the Polyhedron, Unit must match to the mesh's scale + normal_orientation=NormalOrientation.OUTWARDS, # Possible values OUTWARDS (default) or INWARDS + integrity_check=PolyhedronIntegrity.VERIFY, # Possible values AUTOMATIC (default), VERIFY, HEAL, DISABLE + ) + + .. note:: + + *Tsoulis et al.*'s formulation requires that the normals point :code:`OUTWARDS`. + The implementation **can handle both cases and also can automatically determine the property** if initiall set wrong. + Using :code:`AUTOMATIC` (default for first-time-user) or :code:`VERIFY` raises a :code:`ValueError` if the :py:class:`polyhedral_gravity.NormalOrientation` is wrong. + Using :code:`HEAL` will re-order the vertex sorting to fix errors. + Using :code:`DISABLE` will turn this check off and avoid :math:`O(n^2)` runtime complexcity of this check! Highly recommened, when you "know your mesh"! + + + + The polyhedron's mesh's units must match with the constant density! + For example, if the mesh is in :math:`[m]`, then the constant density should be in :math:`[\frac{kg}{m^3}]`. + + Afterwards one can use :py:func:`polyhedral_gravity.evaluate` the gravity at a single point *P* via: + + .. code-block:: python + + potential, acceleration, tensor = evaluate( + polyhedron=polyhedron, + computation_points=P, + parallel=True, + ) + + or via use the cached approach :py:class:`polyhedral_gravity.GravityEvaluable` (desriable for subsequent evaluations using the same :py:class:`polyhedral_gravity.Polyhedron`) + + .. code-block:: python + + evaluable = GravityEvaluable(polyhedron=polyhedron) + potential, acceleration, tensor = evaluable( + computation_points=P, + parallel=True, + ) + + .. note:: + + If :code:`P` would be an array of points, the return value would be a :code:`List[Tuple[potential, acceleration, tensor]]`! + + The calculation outputs the following parameters for every Computation Point *P*. + The units of the respective output depend on the units of the input parameters (mesh and density)! + + Hence, if e.g. your mesh is in :math:`km`, the density must match. Further, the output units will match the input units. + + +------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------+-----------------------------------------------------------------+ + | Name | If mesh :math:`[m]` and density :math:`[\frac{kg}{m^3}]` | Comment | + +================================================================================================+============================================================================+=================================================================+ + | :math:`V` | :math:`\frac{m^2}{s^2}` or :math:`\frac{J}{kg}` | The potential or also called specific energy | + +------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------+-----------------------------------------------------------------+ + | :math:`V_x`, :math:`V_y`, :math:`V_z` | :math:`\frac{m}{s^2}` |The gravitational acceleration in the three cartesian directions | + +------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------+-----------------------------------------------------------------+ + | :math:`V_{xx}`, :math:`V_{yy}`, :math:`V_{zz}`, :math:`V_{xy}`, :math:`V_{xz}`, :math:`V_{yz}` | :math:`\frac{1}{s^2}` |The spatial rate of change of the gravitational acceleration | + +------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------+-----------------------------------------------------------------+ + + This model's output obeys to the geodesy and geophysics sign conventions. + Hence, the potential :math:`V` for a polyhedron with a mass :math:`m > 0` is defined as **positive**. + + The accelerations :math:`V_x`, :math:`V_y`, :math:`V_z` are defined as + + .. math:: + + \textbf{g} = + \nabla V = \left( \frac{\partial V}{\partial x}, \frac{\partial V}{\partial y}, \frac{\partial V}{\partial z} \right) + + Accordingly, the second derivative tensor is defined as the derivative of :math:`\textbf{g}`. + )mydelimiter"; py::enum_(m, "NormalOrientation", R"mydelimiter( The orientation of the plane unit normals of the polyhedron. - Tsoulis et al. equations require the normals to point outwards of the polyhedron. + *Tsoulis et al.* equations require the normals to point outwards of the polyhedron. If the opposite hold, the result is negated. The implementation can handle both cases. )mydelimiter") - .value("OUTWARDS", NormalOrientation::OUTWARDS, "Outwards pointing plane unit normals") - .value("INWARDS", NormalOrientation::INWWARDS, "Inwards pointing plane unit normals"); + .value("OUTWARDS", NormalOrientation::OUTWARDS, "Outwards pointing plane unit normals") + .value("INWARDS", NormalOrientation::INWARDS, "Inwards pointing plane unit normals"); py::enum_(m, "PolyhedronIntegrity", R"mydelimiter( The pointing direction of the normals of a Polyhedron. They can either point outwards or inwards the polyhedron. )mydelimiter") - .value("DISABLE", PolyhedronIntegrity::DISABLE, - "All activities regarding MeshChecking are disabled. No runtime overhead!") - .value("VERIFY", PolyhedronIntegrity::VERIFY, - "Only verification of the NormalOrientation. " - "A misalignment (e.g. specified OUTWARDS, but is not) leads to a runtime_error. Runtime Cost O(n^2)") - .value("AUTOMATIC", PolyhedronIntegrity::AUTOMATIC, - "Like VERIFY, but also informs the user about the option in any case on the runtime costs. " - "This is the implicit default option. Runtime Cost: O(n^2) and output to stdout in every case!") - .value("HEAL", PolyhedronIntegrity::HEAL, - "Verification and Autmatioc Healing of the NormalOrientation. " - "A misalignemt does not lead to a runtime_error, but to an internal correction of vertices ordering. Runtime Cost: @f$O(n^2)$@f"); + .value("DISABLE", PolyhedronIntegrity::DISABLE, + "All activities regarding MeshChecking are disabled. No runtime overhead!") + .value("VERIFY", PolyhedronIntegrity::VERIFY, + "Only verification of the NormalOrientation. " + "A misalignment (e.g. specified OUTWARDS, but is not) leads to a runtime_error. Runtime Cost :math:`O(n^2)`") + .value("AUTOMATIC", PolyhedronIntegrity::AUTOMATIC, + "Like :code:`VERIFY`, but also informs the user about the option in any case on the runtime costs. " + "This is the implicit default option. Runtime Cost: :math:`O(n^2)` and output to stdout in every case!") + .value("HEAL", PolyhedronIntegrity::HEAL, + "Verification and Autmatioc Healing of the NormalOrientation. " + "A misalignemt does not lead to a runtime_error, but to an internal correction of vertices ordering. Runtime Cost: :math:`O(n^2)`"); py::class_(m, "Polyhedron", R"mydelimiter( A constant density Polyhedron stores the mesh data consisting of vertices and triangular faces. @@ -51,54 +136,32 @@ PYBIND11_MODULE(polyhedral_gravity, m) { of the polyhedron. Otherwise the results are negated. The class by default enforces this constraints and offers utility to (automatically) make the input data obey to this constraint. )mydelimiter") - .def(py::init(), R"mydelimiter( + .def(py::init &, double, const NormalOrientation &, const PolyhedronIntegrity &>(), R"mydelimiter( Creates a new Polyhedron from vertices and faces and a constant density. If the integrity_check is not set to DISABLE, the mesh integrity is checked - (so that it fits the specification of the polyhedral model by Tsoulis et al.) + (so that it fits the specification of the polyhedral model by *Tsoulis et al.*) Args: - polyhedral_source: The vertices & faces of the polyhedron as pair of (N, 3)-arrays - density: The constant density of the polyhedron, it must match the mesh's units, e.g. mesh in [m] then density in [kg/m^3] - normal_orientation: The pointing direction of the mesh's plane unit normals, i.e., either OUTWARDS or INWARDS of the polyhedron - (default: OUTWARDS) - integrity_check: Conducts an Integrity Check (degenerated faces/ vertex ordering) depending on the values. Options - - AUTOMATIC (Default): Prints to stdout and throws ValueError if normal_orientation is wrong/ inconsisten - - VERIFY: Like AUTOMATIC, but does not print to stdout - - DISABLE: Recommened, when you know the mesh to avoid to pay O(n^2) runtime. Disables ALL checks - - HEAL: Automatically fixes the normal_orientation and vertex ordering to the correct values - Raises: - ValueError if `integrity_check` is set to AUTOMATIC or VERIFY and the mesh is inconsistent + polyhedral_source: The vertices (:math:`(N, 3)`-array-like) and faces (:math:`(M, 3)`-array-like) of the polyhedron as pair or + The filenames of the files containing the vertices & faces as list of strings + density: The constant density of the polyhedron, it must match the mesh's units, e.g. mesh in :math`[m]` then density in :math:`[kg/m^3]` + normal_orientation: The pointing direction of the mesh's plane unit normals, i.e., either :code:`OUTWARDS` or :code:`INWARDS` of the polyhedron. + One of :py:class:`polyhedral_gravity.NormalOrientation`. + (default: :code:`OUTWARDS`) + integrity_check: Conducts an Integrity Check (degenerated faces/ vertex ordering) depending on the values. One of :py:class:`polyhedral_gravity.PolyhedronIntegrity`: - Note: - The integrity_check is automatically enabled to avoid wrong results due to the wrong vertex ordering. - The check requires O(n^2) operations. You want to turn this off, when you know you mesh! - )mydelimiter", - py::arg("polyhedral_source"), - py::arg("density"), - py::arg("normal_orientation") = NormalOrientation::OUTWARDS, - py::arg("integrity_check") = PolyhedronIntegrity::AUTOMATIC - ) - .def(py::init(), R"mydelimiter( - Creates a new Polyhedron from vertices and faces and a constant density. - If the integrity_check is not set to DISABLE, the mesh integrity is checked - (so that it fits the specification of the polyhedral model by Tsoulis et al.) + * :code:`AUTOMATIC` (Default): Prints to stdout and throws ValueError if normal_orientation is wrong/ inconsisten + * :coce:`VERIFY`: Like :code:`AUTOMATIC`, but does not print to stdout + * :code:`DISABLE`: Recommened, when you know the mesh to avoid to pay :math:`O(n^2)` runtime. Disables ALL checks + * :code`HEAL`: Automatically fixes the normal_orientation and vertex ordering to the correct values - Args: - polyhedral_source: The filenames of the files containing the vertices & faces as list of strings - density: The constant density of the polyhedron, it must match the mesh's units, e.g. mesh in [m] then density in [kg/m^3] - normal_orientation: The pointing direction of the mesh's plane unit normals, i.e., either OUTWARDS or INWARDS of the polyhedron - (default: OUTWARDS) - integrity_check: Conducts an Integrity Check (degenerated faces/ vertex ordering) depending on the values. Options - - AUTOMATIC (Default): Prints to stdout and throws ValueError if normal_orientation is wrong/ inconsisten - - VERIFY: Like AUTOMATIC, but does not print to stdout - - DISABLE: Recommened, when you know the mesh to avoid to pay O(n^2) runtime. Disables ALL checks - - HEAL: Automatically fixes the normal_orientation and vertex ordering to the correct values Raises: - ValueError if `integrity_check` is set to AUTOMATIC or VERIFY and the mesh is inconsistent + ValueError: If the faces array does not contain a reference to vertex 0 indicating an index start at 1 + ValueError: If :code:`integrity_check` is set to :code:`AUTOMATIC` or :code:`VERIFY` and the mesh is inconsistent Note: - The integrity_check is automatically enabled to avoid wrong results due to the wrong vertex ordering. - The check requires O(n^2) operations. You want to turn this off, when you know you mesh! + The :code:`integrity_check` is automatically enabled to avoid wrong results due to the wrong vertex ordering. + The check requires :math:`O(n^2)` operations. You want to turn this off, when you know you mesh! )mydelimiter", py::arg("polyhedral_source"), py::arg("density"), @@ -117,28 +180,39 @@ PYBIND11_MODULE(polyhedral_gravity, m) { Note: This utility is mainly for diagnostics and debugging purposes. If the polyhedron is constrcuted with `integrity_check` - set to AUTOMATIC or VERIFY, the construction fails anyways. - If set to HEAL, this method should return an empty set (but maybe a different ordering than initially specified) - Only if set to DISABLE, then this method might actually return a set with faulty indices. - Hence, if you want to know your mesh error. Construct the polyhedron with `integrity_check=DISABLE` and call this method. + set to :code:`AUTOMATIC` or :code:`VERIFY`, the construction fails anyways. + If set to code:`HEAL`, this method should return an empty set (but maybe a different ordering than initially specified) + Only if set to coe:`DISABLE`, then this method might actually return a set with faulty indices. + Hence, if you want to know your mesh error. Construct the polyhedron with :code:`integrity_check=DISABLE` and call this method. )mydelimiter") .def("__getitem__", &Polyhedron::getResolvedFace, R"mydelimiter( Returns the the three cooridnates of the vertices making the face at the requested index. + This does not return the face as list of vertex indices, but resolved with the actual coordinates. Args: index: The index of the face Returns: - The resolved face (so the vertices as coordinates) as (3, 3)-array + :math:´(3, 3)`-array-like: The resolved face Raises: IndexError if face index is out-of-bounds )mydelimiter", py::arg("index")) - .def("__repr__", &Polyhedron::toString, "Returns a string representation of this polyhedron") - .def_property_readonly("vertices", &Polyhedron::getVertices, "The vertices (type: floats) of the polyhedron as (N, 3)-array") - .def_property_readonly("faces", &Polyhedron::getFace, "The faces (type: int) of the polyhedron as (M, 3) array") - .def_property("density", &Polyhedron::getDensity, &Polyhedron::setDensity, "The density (mutable) of the polyhedron") - .def_property_readonly("normal_orientation", &Polyhedron::getOrientation, "The plane unit normal orientation of the polyhedron") + .def("__repr__", &Polyhedron::toString, R"mydelimiter( + :py:class:`str`: A string representation of this polyhedron + )mydelimiter") + .def_property_readonly("vertices", &Polyhedron::getVertices, R"mydelimiter( + (N, 3)-array-like of :py:class:`float`: The vertices of the polyhedron (Read-Only) + )mydelimiter") + .def_property_readonly("faces", &Polyhedron::getFaces, R"mydelimiter( + (M, 3)-array-like of :py:class:`int`: The faces of the polyhedron (Read-Only) + )mydelimiter") + .def_property("density", &Polyhedron::getDensity, &Polyhedron::setDensity, R"mydelimiter( + :py:class:`float`: The density of the polyhedron (Read/ Write) + )mydelimiter") + .def_property_readonly("normal_orientation", &Polyhedron::getOrientation, R"mydelimiter( + :py:class:`polyhedral_gravity.NormalOrientation`: The orientation of the plane unit normals (Read-Only) + )mydelimiter") .def(py::pickle( [](const Polyhedron &polyhedron) { const auto &[vertices, faces, density, orientation] = polyhedron.getState(); @@ -159,29 +233,32 @@ PYBIND11_MODULE(polyhedral_gravity, m) { py::class_(m, "GravityEvaluable", R"mydelimiter( A class to evaluate the polyhedral gravity model for a given constant density polyhedron at a given computation point. - It provides a __call__ method to evaluate the polyhedral gravity model for computation points while + It provides a :py:meth:`poylhedral_gravity.GravityEvaluable.__call__` method to evaluate the polyhedral gravity model for computation points while also caching the polyhedron & intermediate results over the lifetime of the object. )mydelimiter") .def(py::init(),R"mydelimiter( Creates a new GravityEvaluable for a given constant density polyhedron. - It provides a __call__ method to evaluate the polyhedral gravity model for computation points while + It provides a :py:meth:`poylhedral_gravity.GravityEvaluable.__call__` method to evaluate the polyhedral gravity model for computation points while also caching the polyhedron & intermediate results over the lifetime of the object. Args: polyhedron: The polyhedron for which to evaluate the gravity model )mydelimiter", py::arg("polyhedron")) - .def("__repr__", &GravityEvaluable::toString, "Returns a string representation of this GravityEvaluable") + .def("__repr__", &GravityEvaluable::toString,R"mydelimiter( + :py:class:`str`: A string representation of this GravityEvaluable + )mydelimiter") .def("__call__", &GravityEvaluable::operator(), R"mydelimiter( Evaluates the polyhedral gravity model for a given constant density polyhedron at a given computation point. Args: computation_points: The computation points as tuple or list of points - parallel: If true, the computation is done in parallel (default: true) + parallel: If :code:`True`, the computation is done in parallel (default: :code:`True`) Returns: - Either a tuple of potential, acceleration and second derivatives at the computation points or - if multiple computation points are given, the result is a list of tuples + Either a tuple of potential :math:`V`, acceleration :math:`[V_x, V_y, V_z]` + and second derivatives :math:`[V_{xx}, V_{yy}, V_{zz}, V_{xy},V_{xz}, V_{yz}]` at the computation points or + if multiple computation points are given a list of these tuples )mydelimiter", py::arg("computation_points"), py::arg("parallel") = true) .def(py::pickle( [](const GravityEvaluable &evaluable) { @@ -218,11 +295,12 @@ PYBIND11_MODULE(polyhedral_gravity, m) { Args: polyhedron: The polyhedron for which to evaluate the gravity model computation_points: The computation points as tuple or list of points - parallel: If true, the computation is done in parallel (default: true) + parallel: If :code:`True`, the computation is done in parallel (default: :code:`True`) Returns: - Either a tuple of potential, acceleration and second derivatives at the computation points or - if multiple computation points are given, the result is a list of tuples + Either a tuple of potential :math:`V`, acceleration :math:`[V_x, V_y, V_z]` + and second derivatives :math:`[V_{xx}, V_{yy}, V_{zz}, V_{xy},V_{xz}, V_{yz}]` at the computation points or + if multiple computation points are given a list of these tuples )mydelimiter", py::arg("polyhedron"), py::arg("computation_points"), py::arg("parallel") = true); } \ No newline at end of file diff --git a/test/model/PolyhedronTest.cpp b/test/model/PolyhedronTest.cpp index 1cd1b5a..496d801 100644 --- a/test/model/PolyhedronTest.cpp +++ b/test/model/PolyhedronTest.cpp @@ -154,13 +154,13 @@ TEST_F(PolyhedronTest, CubeOutwardNormals) { EXPECT_NO_THROW(Polyhedron (_cubeVertices, _facesOutwards, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::HEAL)); // Wrong Set-Up, Throws in case of AUTOMATIC and VERIFY, DISABLE and HEAL do not throw but respectivley ignore or repair - EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesOutwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::DISABLE)); - EXPECT_THROW(Polyhedron(_cubeVertices, _facesOutwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::AUTOMATIC), std::invalid_argument); - EXPECT_THROW(Polyhedron(_cubeVertices, _facesOutwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::VERIFY), std::invalid_argument); - EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesOutwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::HEAL)); + EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesOutwards, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::DISABLE)); + EXPECT_THROW(Polyhedron(_cubeVertices, _facesOutwards, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::AUTOMATIC), std::invalid_argument); + EXPECT_THROW(Polyhedron(_cubeVertices, _facesOutwards, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::VERIFY), std::invalid_argument); + EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesOutwards, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::HEAL)); // Checking that the healing leads to the correct result (More than n/2 normals (actuall all) are outwards. Hence, only change of the Orientation) - Polyhedron healedPolyhedron(_cubeVertices, _facesOutwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::HEAL); + Polyhedron healedPolyhedron(_cubeVertices, _facesOutwards, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::HEAL); EXPECT_EQ(healedPolyhedron.getOrientation(), NormalOrientation::OUTWARDS); EXPECT_THAT(healedPolyhedron.getFaces(), ContainerEq(_facesOutwards)); } @@ -169,10 +169,10 @@ TEST_F(PolyhedronTest, CubeInwardsNormals) { using namespace polyhedralGravity; using namespace testing; // Correct Set-Up, No-throw for all options - EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesInwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::DISABLE)); - EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesInwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::AUTOMATIC)); - EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesInwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::VERIFY)); - EXPECT_NO_THROW(Polyhedron (_cubeVertices, _facesInwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::HEAL)); + EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesInwards, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::DISABLE)); + EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesInwards, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::AUTOMATIC)); + EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesInwards, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::VERIFY)); + EXPECT_NO_THROW(Polyhedron (_cubeVertices, _facesInwards, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::HEAL)); // Wrong Set-Up, Throws in case of AUTOMATIC and VERIFY, DISABLE and HEAL do not throw but respectivley ignore or repair EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesInwards, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::DISABLE)); @@ -181,14 +181,14 @@ TEST_F(PolyhedronTest, CubeInwardsNormals) { EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesInwards, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::HEAL)); // Checking that checkPlaneUnitNormalOrientation() returns the correct set of indices & majority orientation - Polyhedron intenionalDisabledCheckingPolyhedron(_cubeVertices, _facesOutwardsMajority, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::DISABLE); + Polyhedron intenionalDisabledCheckingPolyhedron(_cubeVertices, _facesOutwardsMajority, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::DISABLE); const auto &[majorityOrientation, violatingIndices] = intenionalDisabledCheckingPolyhedron.checkPlaneUnitNormalOrientation(); EXPECT_EQ(majorityOrientation, NormalOrientation::OUTWARDS); EXPECT_THAT(violatingIndices, ContainerEq(std::set({0, 4}))); // Checking that the healing leads to the correct result (More than n/2 normals (actuall all) are outwards. Hence, only change of the Orientation) Polyhedron healedPolyhedron(_cubeVertices, _facesInwards, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::HEAL); - EXPECT_EQ(healedPolyhedron.getOrientation(), NormalOrientation::INWWARDS); + EXPECT_EQ(healedPolyhedron.getOrientation(), NormalOrientation::INWARDS); EXPECT_THAT(healedPolyhedron.getFaces(), ContainerEq(_facesInwards)); } @@ -202,19 +202,19 @@ TEST_F(PolyhedronTest, CubeOutwardNormalsMajor) { EXPECT_NO_THROW(Polyhedron (_cubeVertices, _facesOutwardsMajority, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::HEAL)); // Wrong Set-Up, Throws in case of AUTOMATIC and VERIFY, DISABLE and HEAL do not throw but respectivley ignore or repair - EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesOutwardsMajority, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::DISABLE)); - EXPECT_THROW(Polyhedron(_cubeVertices, _facesOutwardsMajority, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::AUTOMATIC), std::invalid_argument); - EXPECT_THROW(Polyhedron(_cubeVertices, _facesOutwardsMajority, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::VERIFY), std::invalid_argument); - EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesOutwardsMajority, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::HEAL)); + EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesOutwardsMajority, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::DISABLE)); + EXPECT_THROW(Polyhedron(_cubeVertices, _facesOutwardsMajority, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::AUTOMATIC), std::invalid_argument); + EXPECT_THROW(Polyhedron(_cubeVertices, _facesOutwardsMajority, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::VERIFY), std::invalid_argument); + EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesOutwardsMajority, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::HEAL)); // Checking that checkPlaneUnitNormalOrientation() returns the correct set of indices & majority orientation - Polyhedron intenionalDisabledCheckingPolyhedron(_cubeVertices, _facesOutwardsMajority, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::DISABLE); + Polyhedron intenionalDisabledCheckingPolyhedron(_cubeVertices, _facesOutwardsMajority, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::DISABLE); const auto &[majorityOrientation, violatingIndices] = intenionalDisabledCheckingPolyhedron.checkPlaneUnitNormalOrientation(); EXPECT_EQ(majorityOrientation, NormalOrientation::OUTWARDS); EXPECT_THAT(violatingIndices, ContainerEq(std::set({0, 4}))); // Checking that the healing leads to the correct result (More than n/2 normals are outwards. Here orientation & faces' vertex ordering changes) - Polyhedron healedPolyhedron(_cubeVertices, _facesOutwardsMajority, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::HEAL); + Polyhedron healedPolyhedron(_cubeVertices, _facesOutwardsMajority, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::HEAL); EXPECT_EQ(healedPolyhedron.getOrientation(), NormalOrientation::OUTWARDS); EXPECT_THAT(healedPolyhedron.getFaces(), ContainerEq(_facesOutwards)); } @@ -223,10 +223,10 @@ TEST_F(PolyhedronTest, CubeOutwardInwardsMajor) { using namespace polyhedralGravity; using namespace testing; // The majority is correct. However, 2 faces have inward pointing normals (Index 9, 10, and 11) --> Will throw but not in the healing scenario - EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesInwardsMajority, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::DISABLE)); - EXPECT_THROW(Polyhedron(_cubeVertices, _facesInwardsMajority, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::AUTOMATIC), std::invalid_argument); - EXPECT_THROW(Polyhedron(_cubeVertices, _facesInwardsMajority, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::VERIFY), std::invalid_argument); - EXPECT_NO_THROW(Polyhedron (_cubeVertices, _facesInwardsMajority, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::HEAL)); + EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesInwardsMajority, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::DISABLE)); + EXPECT_THROW(Polyhedron(_cubeVertices, _facesInwardsMajority, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::AUTOMATIC), std::invalid_argument); + EXPECT_THROW(Polyhedron(_cubeVertices, _facesInwardsMajority, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::VERIFY), std::invalid_argument); + EXPECT_NO_THROW(Polyhedron (_cubeVertices, _facesInwardsMajority, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::HEAL)); // Wrong Set-Up, Throws in case of AUTOMATIC and VERIFY, DISABLE and HEAL do not throw but respectivley ignore or repair EXPECT_NO_THROW(Polyhedron(_cubeVertices, _facesInwardsMajority, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::DISABLE)); @@ -237,12 +237,12 @@ TEST_F(PolyhedronTest, CubeOutwardInwardsMajor) { // Checking that checkPlaneUnitNormalOrientation() returns the correct set of indices & majority orientation Polyhedron intenionalDisabledCheckingPolyhedron(_cubeVertices, _facesInwardsMajority, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::DISABLE); const auto &[majorityOrientation, violatingIndices] = intenionalDisabledCheckingPolyhedron.checkPlaneUnitNormalOrientation(); - EXPECT_EQ(majorityOrientation, NormalOrientation::INWWARDS); + EXPECT_EQ(majorityOrientation, NormalOrientation::INWARDS); EXPECT_THAT(violatingIndices, ContainerEq(std::set({9, 10, 11}))); // Checking that the healing leads to the correct result (More than n/2 normals are outwards. Here orientation & faces' vertex ordering changes) - Polyhedron healedPolyhedron(_cubeVertices, _facesInwardsMajority, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::HEAL); - EXPECT_EQ(healedPolyhedron.getOrientation(), NormalOrientation::INWWARDS); + Polyhedron healedPolyhedron(_cubeVertices, _facesInwardsMajority, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::HEAL); + EXPECT_EQ(healedPolyhedron.getOrientation(), NormalOrientation::INWARDS); EXPECT_THAT(healedPolyhedron.getFaces(), ContainerEq(_facesInwards)); } @@ -250,7 +250,7 @@ TEST_F(PolyhedronTest, CubeDegenerated) { using namespace polyhedralGravity; using namespace testing; // A degenarted mesh is not repaired, throw always expect DISABLE is checked - for (auto orientation: std::set({NormalOrientation::INWWARDS, NormalOrientation::OUTWARDS})) { + for (auto orientation: std::set({NormalOrientation::INWARDS, NormalOrientation::OUTWARDS})) { EXPECT_NO_THROW(Polyhedron(_cubeVertices, _degeneratedFaces, 1.0, orientation, PolyhedronIntegrity::DISABLE)); EXPECT_THROW(Polyhedron(_cubeVertices, _degeneratedFaces, 1.0, orientation, PolyhedronIntegrity::AUTOMATIC), std::invalid_argument); EXPECT_THROW(Polyhedron(_cubeVertices, _degeneratedFaces, 1.0, orientation, PolyhedronIntegrity::VERIFY), std::invalid_argument); @@ -268,13 +268,13 @@ TEST_F(PolyhedronTest, PrsimOutwards) { EXPECT_NO_THROW(Polyhedron (_prismVertices, _prismOutwards, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::HEAL)); // Wrong Set-Up, Throws in case of AUTOMATIC and VERIFY, DISABLE and HEAL do not throw but respectivley ignore or repair - EXPECT_NO_THROW(Polyhedron(_prismVertices, _prismOutwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::DISABLE)); - EXPECT_THROW(Polyhedron(_prismVertices, _prismOutwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::AUTOMATIC), std::invalid_argument); - EXPECT_THROW(Polyhedron(_prismVertices, _prismOutwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::VERIFY), std::invalid_argument); - EXPECT_NO_THROW(Polyhedron(_prismVertices, _prismOutwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::HEAL)); + EXPECT_NO_THROW(Polyhedron(_prismVertices, _prismOutwards, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::DISABLE)); + EXPECT_THROW(Polyhedron(_prismVertices, _prismOutwards, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::AUTOMATIC), std::invalid_argument); + EXPECT_THROW(Polyhedron(_prismVertices, _prismOutwards, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::VERIFY), std::invalid_argument); + EXPECT_NO_THROW(Polyhedron(_prismVertices, _prismOutwards, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::HEAL)); // Checking that the healing leads to the correct result (More than n/2 normals (actuall all) are outwards. Hence, only change of the Orientation) - Polyhedron healedPolyhedron(_prismVertices, _prismOutwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::HEAL); + Polyhedron healedPolyhedron(_prismVertices, _prismOutwards, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::HEAL); EXPECT_EQ(healedPolyhedron.getOrientation(), NormalOrientation::OUTWARDS); EXPECT_THAT(healedPolyhedron.getFaces(), ContainerEq(_prismOutwards)); } @@ -283,10 +283,10 @@ TEST_F(PolyhedronTest, PrsimInwards) { using namespace polyhedralGravity; using namespace testing; // Correct Set-Up, No-throw for all options - EXPECT_NO_THROW(Polyhedron(_prismVertices, _prismInwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::DISABLE)); - EXPECT_NO_THROW(Polyhedron(_prismVertices, _prismInwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::AUTOMATIC)); - EXPECT_NO_THROW(Polyhedron(_prismVertices, _prismInwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::VERIFY)); - EXPECT_NO_THROW(Polyhedron (_prismVertices, _prismInwards, 1.0, NormalOrientation::INWWARDS, PolyhedronIntegrity::HEAL)); + EXPECT_NO_THROW(Polyhedron(_prismVertices, _prismInwards, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::DISABLE)); + EXPECT_NO_THROW(Polyhedron(_prismVertices, _prismInwards, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::AUTOMATIC)); + EXPECT_NO_THROW(Polyhedron(_prismVertices, _prismInwards, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::VERIFY)); + EXPECT_NO_THROW(Polyhedron (_prismVertices, _prismInwards, 1.0, NormalOrientation::INWARDS, PolyhedronIntegrity::HEAL)); // Wrong Set-Up, Throws in case of AUTOMATIC and VERIFY, DISABLE and HEAL do not throw but respectivley ignore or repair EXPECT_NO_THROW(Polyhedron(_prismVertices, _prismInwards, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::DISABLE)); @@ -296,7 +296,7 @@ TEST_F(PolyhedronTest, PrsimInwards) { // Checking that the healing leads to the correct result (More than n/2 normals (actuall all) are outwards. Hence, only change of the Orientation) Polyhedron healedPolyhedron(_prismVertices, _prismInwards, 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::HEAL); - EXPECT_EQ(healedPolyhedron.getOrientation(), NormalOrientation::INWWARDS); + EXPECT_EQ(healedPolyhedron.getOrientation(), NormalOrientation::INWARDS); EXPECT_THAT(healedPolyhedron.getFaces(), ContainerEq(_prismInwards)); } diff --git a/test/python/test_polyhedral_gravity.py b/test/python/test_gravity_model.py similarity index 58% rename from test/python/test_polyhedral_gravity.py rename to test/python/test_gravity_model.py index 0265b86..18ca604 100644 --- a/test/python/test_polyhedral_gravity.py +++ b/test/python/test_gravity_model.py @@ -4,6 +4,7 @@ import pickle import pytest from pathlib import Path +from functools import lru_cache CUBE_VERTICES = np.array([ [-1, -1, -1], @@ -31,16 +32,18 @@ [4, 6, 7] ]) +CUBE_FACES_INVERTED = CUBE_FACES[:, [1, 0, 2]] + DENSITY = 1.0 CUBE_VERTICES_FILE = Path("test/resources/cube.node") CUBE_FACE_FILE = Path("test/resources/cube.face") -@pytest.fixture(scope="session") -def reference_solution() -> Tuple[np.ndarray, np.ndarray, np.ndarray]: +@lru_cache(maxsize=10) +def reference_solution(density: int) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: """Reads the cube reference solution from a file and returns it as a tuple""" - reference_file_path = Path("test/resources/analytic_cube_solution_density1.txt") + reference_file_path = Path(f"test/resources/analytic_cube_solution_density{int(density)}.txt") reference = np.loadtxt(reference_file_path, skiprows=1) points = reference[:, :3] expected_potential = reference[:, 3].flatten() @@ -49,20 +52,30 @@ def reference_solution() -> Tuple[np.ndarray, np.ndarray, np.ndarray]: @pytest.mark.parametrize( - "polyhedral_source", [(CUBE_VERTICES, CUBE_FACES), [str(CUBE_VERTICES_FILE), str(CUBE_FACE_FILE)]], - ids=["with_arrays", "with_file_input"] + "polyhedral_source,normal_orientation,density", [ + ((CUBE_VERTICES, CUBE_FACES), NormalOrientation.OUTWARDS, 1.0), + ((CUBE_VERTICES, CUBE_FACES_INVERTED), NormalOrientation.INWARDS, 1.0), + ([str(CUBE_VERTICES_FILE), str(CUBE_FACE_FILE)], NormalOrientation.OUTWARDS, 1.0), + ((CUBE_VERTICES, CUBE_FACES), NormalOrientation.OUTWARDS, 42.0), + ((CUBE_VERTICES, CUBE_FACES_INVERTED), NormalOrientation.INWARDS, 42.0), + ([str(CUBE_VERTICES_FILE), str(CUBE_FACE_FILE)], NormalOrientation.OUTWARDS, 42.0) + ], + ids=["with_arrays_outwards01", "with_arrays_inwards01", "with_file_input01", + "with_arrays_outwards42", "with_arrays_inwards42", "with_file_input42"] ) def test_polyhedral_gravity( polyhedral_source: Union[Tuple[np.ndarray, np.ndarray], List[str]], - reference_solution: Tuple[np.ndarray, np.ndarray, np.ndarray]) -> None: + normal_orientation: NormalOrientation, + density: float +) -> None: """Checks that the evaluate function the correct results and is callable with file/ array inputs. """ - points, expected_potential, expected_acceleration = reference_solution + points, expected_potential, expected_acceleration = reference_solution(density) polyhedron = Polyhedron( polyhedral_source=polyhedral_source, density=DENSITY, - normal_orientation=NormalOrientation.OUTWARDS, + normal_orientation=normal_orientation, integrity_check=PolyhedronIntegrity.VERIFY, ) sol = evaluate( @@ -77,20 +90,30 @@ def test_polyhedral_gravity( @pytest.mark.parametrize( - "polyhedral_source", [(CUBE_VERTICES, CUBE_FACES), [str(CUBE_VERTICES_FILE), str(CUBE_FACE_FILE)]], - ids=["with_arrays", "with_file_input"] + "polyhedral_source,normal_orientation,density", [ + ((CUBE_VERTICES, CUBE_FACES), NormalOrientation.OUTWARDS, 1.0), + ((CUBE_VERTICES, CUBE_FACES_INVERTED), NormalOrientation.INWARDS, 1.0), + ([str(CUBE_VERTICES_FILE), str(CUBE_FACE_FILE)], NormalOrientation.OUTWARDS, 1.0), + ((CUBE_VERTICES, CUBE_FACES), NormalOrientation.OUTWARDS, 42.0), + ((CUBE_VERTICES, CUBE_FACES_INVERTED), NormalOrientation.INWARDS, 42.0), + ([str(CUBE_VERTICES_FILE), str(CUBE_FACE_FILE)], NormalOrientation.OUTWARDS, 42.0) + ], + ids=["with_arrays_outwards01", "with_arrays_inwards01", "with_file_input01", + "with_arrays_outwards42", "with_arrays_inwards42", "with_file_input42"] ) def test_polyhedral_gravity_evaluable( polyhedral_source: Union[Tuple[np.ndarray, np.ndarray], List[str]], - reference_solution: Tuple[np.ndarray, np.ndarray, np.ndarray]) -> None: + normal_orientation: NormalOrientation, + density: float +) -> None: """Checks that the evaluable produces the correct results and is instantiable with file/ array inputs. """ - points, expected_potential, expected_acceleration = reference_solution + points, expected_potential, expected_acceleration = reference_solution(density) polyhedron = Polyhedron( polyhedral_source=polyhedral_source, density=DENSITY, - normal_orientation=NormalOrientation.OUTWARDS, + normal_orientation=normal_orientation, integrity_check=PolyhedronIntegrity.VERIFY, ) evaluable = GravityEvaluable(polyhedron=polyhedron) @@ -105,22 +128,31 @@ def test_polyhedral_gravity_evaluable( @pytest.mark.parametrize( - "polyhedral_source", [(CUBE_VERTICES, CUBE_FACES), [str(CUBE_VERTICES_FILE), str(CUBE_FACE_FILE)]], - ids=["with_arrays", "with_file_input"] + "polyhedral_source,normal_orientation,density", [ + ((CUBE_VERTICES, CUBE_FACES), NormalOrientation.OUTWARDS, 1.0), + ((CUBE_VERTICES, CUBE_FACES_INVERTED), NormalOrientation.INWARDS, 1.0), + ([str(CUBE_VERTICES_FILE), str(CUBE_FACE_FILE)], NormalOrientation.OUTWARDS, 1.0), + ((CUBE_VERTICES, CUBE_FACES), NormalOrientation.OUTWARDS, 42.0), + ((CUBE_VERTICES, CUBE_FACES_INVERTED), NormalOrientation.INWARDS, 42.0), + ([str(CUBE_VERTICES_FILE), str(CUBE_FACE_FILE)], NormalOrientation.OUTWARDS, 42.0) + ], + ids=["with_arrays_outwards01", "with_arrays_inwards01", "with_file_input01", + "with_arrays_outwards42", "with_arrays_inwards42", "with_file_input42"] ) def test_polyhedral_evaluable_pickle( polyhedral_source: Union[Tuple[np.ndarray, np.ndarray], List[str]], - reference_solution: Tuple[np.ndarray, np.ndarray, np.ndarray], + normal_orientation: NormalOrientation, + density: float, tmp_path: Path,) -> None: """Tests that the evaluable can be pickled and unpicked and that the results are still correct afterward (i.e. that the internal cache is correctly pickled and unpicked as well). """ - points, expected_potential, expected_acceleration = reference_solution + points, expected_potential, expected_acceleration = reference_solution(density) polyhedron = Polyhedron( polyhedral_source=polyhedral_source, density=DENSITY, - normal_orientation=NormalOrientation.OUTWARDS, + normal_orientation=normal_orientation, integrity_check=PolyhedronIntegrity.DISABLE, ) initial_evaluable = GravityEvaluable(polyhedron=polyhedron) diff --git a/test/python/test_polyhedron.py b/test/python/test_polyhedron.py new file mode 100644 index 0000000..d4c963f --- /dev/null +++ b/test/python/test_polyhedron.py @@ -0,0 +1,88 @@ +from typing import Tuple, List, Union +from polyhedral_gravity import Polyhedron, GravityEvaluable, evaluate, PolyhedronIntegrity, NormalOrientation +import numpy as np +import pickle +import pytest +from pathlib import Path + +CUBE_VERTICES = np.array([ + [-1, -1, -1], + [1, -1, -1], + [1, 1, -1], + [-1, 1, -1], + [-1, -1, 1], + [1, -1, 1], + [1, 1, 1], + [-1, 1, 1] +]) + +CUBE_FACES_OUTWARDS = np.array([ + [1, 3, 2], + [0, 3, 1], + [0, 1, 5], + [0, 5, 4], + [0, 7, 3], + [0, 4, 7], + [1, 2, 6], + [1, 6, 5], + [2, 3, 6], + [3, 7, 6], + [4, 5, 6], + [4, 6, 7] +]) + +CUBE_FACES_INWARDS = CUBE_FACES_OUTWARDS[:, [1, 0, 2]] +CUBE_FACES_OUTWARDS_MAJOR = CUBE_FACES_OUTWARDS.copy() +CUBE_FACES_OUTWARDS_MAJOR[0] = CUBE_FACES_OUTWARDS_MAJOR[0, [1, 0, 2]] + + +CUBE_FACES_INWARDS_MAJOR = CUBE_FACES_INWARDS.copy() +CUBE_FACES_INWARDS_MAJOR[2] = CUBE_FACES_INWARDS_MAJOR[2, [1, 0, 2]] +CUBE_FACES_INWARDS_MAJOR[3] = CUBE_FACES_INWARDS_MAJOR[3, [1, 0, 2]] +CUBE_FACES_INWARDS_MAJOR[5] = CUBE_FACES_INWARDS_MAJOR[5, [1, 0, 2]] + +DENSITY = 1.0 + +CUBE_VERTICES_FILE = Path("test/resources/cube.node") +CUBE_FACE_FILE = Path("test/resources/cube.face") + +@pytest.mark.parametrize( + "polyhedral_source,normal_orientation,violating_faces,expected_healed", [ + ((CUBE_VERTICES, CUBE_FACES_OUTWARDS), NormalOrientation.OUTWARDS, [], CUBE_FACES_OUTWARDS), + ((CUBE_VERTICES, CUBE_FACES_INWARDS), NormalOrientation.INWARDS, [], CUBE_FACES_INWARDS), + ((CUBE_VERTICES, CUBE_FACES_OUTWARDS_MAJOR), NormalOrientation.OUTWARDS, [0], CUBE_FACES_OUTWARDS), + ((CUBE_VERTICES, CUBE_FACES_INWARDS_MAJOR), NormalOrientation.INWARDS, [2, 3, 5], CUBE_FACES_INWARDS), + ], + ids=["CubeOutwards", "CubeInwards", "CubeOutwardsMajor", "CubeInwardsMajor"] +) +def test_polyhedron( + polyhedral_source: Tuple[np.ndarray, np.ndarray], + normal_orientation: NormalOrientation, + violating_faces: List[int], + expected_healed: np.ndarray, +) -> None: + inverse_orientation = NormalOrientation.OUTWARDS if NormalOrientation.INWARDS == normal_orientation else NormalOrientation.INWARDS + + # The wrong orientation always leads to an error + with pytest.raises(ValueError): + Polyhedron(polyhedral_source, DENSITY, inverse_orientation, PolyhedronIntegrity.AUTOMATIC) + Polyhedron(polyhedral_source, DENSITY, inverse_orientation, PolyhedronIntegrity.VERIFY) + # At least one error will raise, no error won't raises + if len(violating_faces) == 0: + Polyhedron(polyhedral_source, DENSITY, normal_orientation, PolyhedronIntegrity.AUTOMATIC) + Polyhedron(polyhedral_source, DENSITY, normal_orientation, PolyhedronIntegrity.VERIFY) + else: + with pytest.raises(ValueError): + Polyhedron(polyhedral_source, DENSITY, normal_orientation, PolyhedronIntegrity.AUTOMATIC) + Polyhedron(polyhedral_source, DENSITY, normal_orientation, PolyhedronIntegrity.VERIFY) + + # The healed version obeys to the majority ordering, Hence majority OUTWARDS --> only OUTWARDS + polyhedron_heal = Polyhedron(polyhedral_source, DENSITY, normal_orientation, PolyhedronIntegrity.HEAL) + healed_faces = np.array(polyhedron_heal.faces) + np.testing.assert_array_almost_equal(healed_faces, expected_healed) + + # If disabled, there should not be any change - the only way to create an invalid polyhedron + polyhedron_non_modified = Polyhedron(polyhedral_source, DENSITY, normal_orientation, PolyhedronIntegrity.DISABLE) + non_modified_faces = np.array(polyhedron_non_modified.faces) + np.testing.assert_array_almost_equal(non_modified_faces, polyhedral_source[1]) + From 7a94a6d3e1f58fc03961165876bb7bf078796571 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Wed, 17 Apr 2024 19:39:03 +0200 Subject: [PATCH 23/54] update gitignore --- .gitignore | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index 3fe54c9..faa3a36 100644 --- a/.gitignore +++ b/.gitignore @@ -2,4 +2,5 @@ cmake-build-* build polyhedral_gravity.egg-info -dist \ No newline at end of file +dist +docs/Doxyfile \ No newline at end of file From 7e2fb55dfcc947cb7c029edf6041f924c57421be Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Wed, 17 Apr 2024 22:50:23 +0200 Subject: [PATCH 24/54] update examples and documentation --- README.md | 95 +++++++----- docs/background/mesh_integrity.rst | 76 +++++++++ docs/index.rst | 1 + docs/quickstart/examples_cpp.rst | 43 ++++-- docs/quickstart/examples_python.rst | 146 ++++++++++-------- docs/quickstart/overview.rst | 3 +- .../input/YAMLConfigReader.cpp | 2 +- .../input/YAMLConfigReader.h | 2 +- src/polyhedralGravity/model/Polyhedron.cpp | 17 +- src/polyhedralGravity/model/Polyhedron.h | 8 +- .../PolyhedralGravityPython.cpp | 18 +-- 11 files changed, 265 insertions(+), 146 deletions(-) create mode 100644 docs/background/mesh_integrity.rst diff --git a/README.md b/README.md index ed40b38..f3e9509 100644 --- a/README.md +++ b/README.md @@ -60,8 +60,8 @@ which is strongly based on the former implementation in FORTRAN. > [!NOTE] > The [GitHub Pages](https://esa.github.io/polyhedral-gravity-model) of this project -contain the full extensive documentation. -It also covers the content of the `polyhedral_gravity.utility` module to check the mesh sanity. +contain the full extensive documentation of C++ Library and the Python Interface +as well as background on the gravity model and advanced settings not detailed here! ## Input & Output (C++ and Python) @@ -77,14 +77,6 @@ The evaluation of the polyhedral gravity model requires the following parameters The mesh and the constants density's unit must match. Have a look the documentation to view the [supported mesh files](https://esa.github.io/polyhedral-gravity-model/supported_input.html). -> [!IMPORTANT] -> The plane unit normals of every face of the polyhedral mesh must point **outwards** -of the polyhedron! -You can check this property via [MeshChecking](https://esa.github.io/polyhedral-gravity-model/api/calculation.html#meshchecking) in C++ or -via the [utility](https://esa.github.io/polyhedral-gravity-model/api/python.html#module-polyhedral_gravity.utility) submodule in Python. -If the vertex order of the faces is inverted, i.e. the plane unit normals point -inwards, then the sign of the output will be inverted. - ### Output The calculation outputs the following parameters for every Computation Point *P*. @@ -111,31 +103,43 @@ around a cube: ```python import numpy as np -import polyhedral_gravity +from polyhedral_gravity import Polyhedron, GravityEvaluable, evaluate, PolyhedronIntegrity, NormalOrientation # We define the cube as a polyhedron with 8 vertices and 12 triangular faces -# The polyhedron's (here: cube) normals need to point outwards (see below for checking this) +# The polyhedron's normals point outwards (see below for checking this) # The density is set to 1.0 cube_vertices = np.array( - [[-1, -1, -1], [1, -1, -1], [1, 1, -1], [-1, 1, -1], - [-1, -1, 1], [1, -1, 1], [1, 1, 1], [-1, 1, 1]] + [[-1, -1, -1], [1, -1, -1], [1, 1, -1], [-1, 1, -1], + [-1, -1, 1], [1, -1, 1], [1, 1, 1], [-1, 1, 1]] ) cube_faces = np.array( - [[1, 3, 2], [0, 3, 1], [0, 1, 5], [0, 5, 4], [0, 7, 3], [0, 4, 7], - [1, 2, 6], [1, 6, 5], [2, 3, 6], [3, 7, 6], [4, 5, 6], [4, 6, 7]] + [[1, 3, 2], [0, 3, 1], [0, 1, 5], [0, 5, 4], [0, 7, 3], [0, 4, 7], + [1, 2, 6], [1, 6, 5], [2, 3, 6], [3, 7, 6], [4, 5, 6], [4, 6, 7]] ) cube_density = 1.0 computation_point = np.array([0, 0, 0]) ``` -The simplest way to compute the gravity is to use the `evaluate` function: +We first, define a constant density Polyhedron from `vertices` and `faces` ```python -potential, acceleration, tensor = polyhedral_gravity.evaluate( - polyhedral_source=(cube_vertices, cube_faces), - density=cube_density, - computation_points=computation_point, - parallel=True +cube_polyhedron = Polyhedron( + polyhedral_source=(cube_vertices, cube_faces), + density=cube_density, +) +``` + +In case you want to hand over the polyhedron via a supported file format, +just replace the `polyhedral_source` argument with *a list of strings*, +where each string is the path to a supported file format. + +Continuing, the simplest way to compute the gravity is to use the `evaluate` function: + +```python +potential, acceleration, tensor = evaluate( + polyhedron=cube_polyhedron, + computation_points=computation_point, + parallel=True, ) ``` @@ -145,31 +149,35 @@ evaluations. This is especially useful if you want to compute the gravity for multiple computation points, but don't know the "future points" in advance. ```python -evaluable = polyhedral_gravity.GravityEvaluable( - polyhedral_source=(cube_vertices, cube_faces), - density=cube_density +evaluable = GravityEvaluable(polyhedron=cube_polyhedron) +potential, acceleration, tensor = evaluable( + computation_points=computation_point, + parallel=True, ) -potential, acceleration, tensor = evaluable(computation_point, parallel=True) ``` -In case you want to hand over the polyhedron via a supported file format, -just replace the `polyhedral_source` argument with *a list of strings*, -where each string is the path to a supported file format. Note that the `computation_point` could also be (N, 3)-shaped array. In this case, the return value of `evaluate(..)` or an `GravityEvaluable` will be a list of triplets comprising potential, acceleration, and tensor. -The gravity model requires that the polyhedron's plane unit normals point outwards -the polyhedron. In case you are unsure, you can check for this property by using the `utility` module beforehand. -The method also verifies that all triangles are actually triangles with a non-zero -surface area. +The gravity model requires that all the polyhedron's plane unit normals consistently +point outwards or inwards the polyhedron. You can specify this via the `normal_orientation`. +This property is - by default - checked when constructing the `Polyhedron`! So, don't worry, it +is impossible if not **explicitly** disabled to create an invalid `Polyhedron`. +You can disable/ enable this setting via the optional `integrity_check` flag and can even +automatically repair the ordering via `HEAL`. +As advanced user/ when you "know the mesh", +you want to disable this check (via `DISABLE`) due to the additional runtime overhead! ```python -print("Valid Mesh?", polyhedral_gravity.utility.check_mesh(cube_vertices, cube_faces)) +cube_polyhedron = Polyhedron( + polyhedral_source=(cube_vertices, cube_faces), + density=cube_density, + normal_orientation=NormalOrientation.INWARDS, # OUTWARDS (default) or INWARDS + integrity_check=PolyhedronIntegrity.VERIFY, # AUTOMATIC (default) == VERIFY, DISABLE or HEAL +) ``` -If the method returns `False`, then you need to revise the vertex-ordering. - > [!TIP] > More examples and plots are depicted in the [jupyter notebook](script/polyhedral-gravity.ipynb). @@ -184,9 +192,11 @@ It works analogously to the Python example above. // Defining the input like above in the Python example std::vector> vertices = ... std::vector> faces = ... -// The polyhedron is defined by its vertices and faces -Polyhedron polyhedron{vertices, faces}; double density = 1.0; +// The constant density polyhedron is defined by its vertices & faces +// It also supports the hand-over of NormalOrientation and PolyhedronIntegrity as optional arguments +// as above described for the Python Interface +Polyhedron polyhedron{vertices, faces, density}; std::vector> points = ... std::array point = points[0]; bool parallel = true; @@ -196,19 +206,19 @@ The C++ library provides also two ways to compute the gravity. Via the free function `evaluate`... ```cpp -const auto[pot, acc, tensor] = GravityModel::evaluate(polyhedron, density, point); +const auto[pot, acc, tensor] = GravityModel::evaluate(polyhedron, point, parallel); ``` ... or via the `GravityEvaluable` class. ```cpp // Instantiation of the GravityEvaluable object -GravityEvaluable evaluable{polyhedron, density}; +GravityEvaluable evaluable{polyhedron}; // From now, we can evaluate the gravity model for any point with const auto[potential, acceleration, tensor] = evaluable(point, parallel); // or for multiple points with -const auto results = evaluable(points); +const auto results = evaluable(points, parallel); ``` Similarly to Python, the C++ implementation also provides mesh checking capabilities. @@ -342,7 +352,8 @@ gravityModel: density: 2670.0 # constant density, units must match with the mesh (see section below) points: # Location of the computation point(s) P - [ 0, 0, 0 ] # Here it is situated at the origin - check_mesh: true # Fully optional, enables input checking (not given: false) + check_mesh: true # Fully optional, enables mesh autodetect+repair of + # the polyhedron's vertex ordering (not given: true) output: filename: "gravity_result.csv" # The name of the output file diff --git a/docs/background/mesh_integrity.rst b/docs/background/mesh_integrity.rst new file mode 100644 index 0000000..f68562d --- /dev/null +++ b/docs/background/mesh_integrity.rst @@ -0,0 +1,76 @@ +.. _mesh-integrity-check: + +Mesh Integrity & Explanation +============================ + +The polyhedral gravity model by *Tsoulis et al.* is defined using +a polyhedron with :code:`OUTWARDS` pointing plane unit normals. +The results are negated if the plane unit normals are :code:`INWARDS` pointing. + +This property correlates to the sorting order of the vertices in the faces. +In the context of most programs, one uses here the terminology *clockwise* +and *anti-clockwise* ordering of vertices in the definition of the faces. +The classification also depends on the coordinate system's definition (right- or left-handed). + +To be more illustrative and independent of the concrete coordinate system, we stick +to the orientation of the normals: :code:`OUTWARDS` and :code:`INWARDS` pointing. + +For example, given you have the following cube: + +.. code-block:: python + + import numpy as np + + CUBE_VERTICES = np.array( + [[-1, -1, -1], [1, -1, -1], [1, 1, -1], [-1, 1, -1], + [-1, -1, 1], [1, -1, 1], [1, 1, 1], [-1, 1, 1]] + ) + CUBE_FACES_OUTWARDS = np.array( + [[1, 3, 2], [0, 3, 1], [0, 1, 5], [0, 5, 4], [0, 7, 3], [0, 4, 7], + [1, 2, 6], [1, 6, 5], [2, 3, 6], [3, 7, 6], [4, 5, 6], [4, 6, 7]] + ) + cube_inwards = Polyhedron( + polyhedral_source=(CUBE_VERTICES, CUBE_FACES_OUTWARDS), + normal_orientation=NormalOrientation.OUTWARDS, + ) + +Its plane unit normals are pointing :code:`OUTWARDS`. However, if you simply invert the order like +in the following, they will point :code:`INWARDS`: + +.. code-block:: python + + CUBE_FACES_INWARDS = CUBE_FACES_OUTWARDS[:, [1, 0, 2]] + cube_outwards = Polyhedron( + polyhedral_source=(CUBE_VERTICES, CUBE_FACES_OUTWARDS), + normal_orientation=NormalOrientation.INWARDS, + ) + +And then, there is still the possibility that one can define a polyhedron by hand +with mixed orientations! This would lead to entirely different (wrong) results. + +So, what can we do? + +The :code:`Polyhedron` class checks the pointing direction of every single +normal. This way, the `Polyhedron` ensures correct results even if a mistake occurs during the definition. + +Since we are in 3D and might have concave and convex polyhedrons, +the viable option is the `Möller–Trumbore intersection algorithm `__. +It checks the amount of intersections the plane unit normal has with the polyhedron. +If its an even number, the normals is :code:`OUTWARDS` pointing, otherwise :code:`INWARDS`. +In the *current implementation*, we implement a naiv version +which takes :math:`O(n^2)` operations - which can get quite expensive for polyhedrons with many faces. + +To make this as straightforward to use as possible, we provide four options +for the construction of a polyhedron in the form of the enum :code:`PolyhedronIntegrity`: + ++-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------+----------------+ +| :code:`PolyhedronIntegrity` | Meaning | Invalid Polyhedron Possible| Overhead | ++=============================+=========================================================================================================================================================================================================================+============================+================+ +| :code:`AUTOMATIC` (default) | Throws an Exception if the :code:`NormalOrientation` is different or inconsistent than specified AND Prints a short-version of the above explaination to :code:`stdout` informing the user about :math:`O(n^2)` runtime | NO | :math:`O(n^2)` | ++-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------+----------------+ +| :code:`VERIFY` | Throws an Exception if the :code:`NormalOrientation` is different or inconsistent than specified | NO | :math:`O(n^2)` | ++-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------+----------------+ +| :code:`HEAL` | Modifies the specified :code:`NormalOrientation` and the faces array to a consistent polyhedron if is different or inconsistent | NO | :math:`O(n^2)` | ++-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------+----------------+ +| :code:`DISABLE` | Disables all checks | YES | None | ++-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------+----------------+ diff --git a/docs/index.rst b/docs/index.rst index 6f86206..1daead0 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -53,6 +53,7 @@ And for more details, refer to the **Python API** or **C++ API**. background/rational background/approach + background/mesh_integrity background/evaluable_vs_evaluate .. toctree:: diff --git a/docs/quickstart/examples_cpp.rst b/docs/quickstart/examples_cpp.rst index 8541b92..40b9135 100644 --- a/docs/quickstart/examples_cpp.rst +++ b/docs/quickstart/examples_cpp.rst @@ -42,7 +42,8 @@ Further one must specify the name of the .csv output file. density: 2670.0 # constant density, units must match with the mesh (see section below) points: # Location of the computation point(s) P - [ 0, 0, 0 ] # Here it is situated at the origin - check_mesh: true # Fully optional, enables input checking (not given: false) + check_mesh: true # Fully optional, enables mesh autodetect+repair of + # the polyhedron's vertex ordering (not given: true) output: filename: "gravity_result.csv" # The name of the output file @@ -64,26 +65,29 @@ Individual Function (without caching) **Example 1:** Evaluating the gravity model for a given polyhedron defined from within source code for a specific point and density. -Further, we disable the parallelization using the optional fourth parameter (which defaults to true). +Further, we disable the parallelization using the optional fourth parameter (which defaults to true) +and we check the if the plane unit normals are actually outwards pointing +(costing :math:`O(n^2)`). .. code-block:: cpp // Defining every input parameter in the source code std::vector> vertices = ... std::vector> faces = ... - Polyhedron polyhedron{vertices, faces}; double density = ... std::array point = ... // Returns either a single of vector of results // Here, we only have one point. Thus we get a single result - const auto[pot, acc, tensor] = GravityModel::evaluate(polyhedron, density, point, false); + Polyhedron polyhedron{vertices, faces, density, PolyhedronIntegrity::VERIFY}; + const auto[pot, acc, tensor] = GravityModel::evaluate(polyhedron, point, false); **Example 2:** Evaluating the gravity model for a given polyhedron in some source files for a specific point and density. Further, we explicitly enable the parallelization using the optional fourth parameter -(which defaults to true). +(which defaults to true). We disable the :math:`O(n^2)` check if the +plane unit normals are actually outwards pointing. .. code-block:: cpp @@ -95,7 +99,8 @@ Further, we explicitly enable the parallelization using the optional fourth para // Returns either a single of vector of results // Here, we only have one point. Thus we get a single result - const auto[pot, acc, tensor] = GravityModel::evaluate(files, density, point, true); + Polyhedron polyhedron{files, density, NormalOrientation::OUTWARDS, PolyhedronIntegrity::DISABLE}; + const auto[pot, acc, tensor] = GravityModel::evaluate(polyhedron, point, true); **Example 3:** Evaluating the gravity model for a given configuration @@ -105,19 +110,22 @@ from a .yaml file. // Reading the configuration from a yaml file std::shared_ptr config = std::make_shared("config.yaml"); - Polyhedron poly = config->getDataSource()->getPolyhedron(); + auto polyhedralSource = config->getDataSource()->getPolyhedralSource(); double density = config->getDensity(); + PolyhedronIntegrity checkPolyhedralInput = config->getMeshInputCheckStatus() ? PolyhedronIntegrity::HEAL : PolyhedronIntegrity::DISABLE; // This time, we use multiple points std::vector> points = config->getPointsOfInterest(); // Returns either a single of vector of results // Here, we have multiple point. Thus we get a vector of results! - const results = GravityModel::evaluate(poly, density, points); + Polyhedron polyhedron{polyhedralSource, density, NormalOrientation::OUTWARDS, checkPolyhedralInput}; + const results = GravityModel::evaluate(polyhedron, points); -**Example 4:** A guard statement checks that the plane unit -normals are pointing outwards and no triangle is degenerated. -Only use this statement if one needs clarification -about the vertices' ordering due to its quadratic complexity! +**Example 4:** If our :code:`Polyhedron` contains any inconsistencies in the definition, e.g., +some plane unit normals point outwards and some point inwards, +the :code:`HEAL` option will fix the :code:`NormalOrientation` and any inconsistencies +related to it. It won't throw an exception. +The result will always be fine. .. code-block:: cpp @@ -127,10 +135,8 @@ about the vertices' ordering due to its quadratic complexity! double density = config->getDensity(); std::array point = config->getPointsOfInterest()[0]; - // Guard statement - if (MeshChecking::checkTrianglesNotDegenerated(poly) && MeshChecking::checkNormalsOutwardPointing(poly)) { - GravityResult result = GravityModel::evaluate(poly, density, point); - } + Polyhedron polyhedron{files, density, NormalOrientation::OUTWARDS, PolyhedronIntegrity::HEAL}; + GravityResult result = GravityModel::evaluate(poly, density, point); GravityEvaluable (with caching) @@ -147,11 +153,14 @@ defined from within source code for a specific point and density. std::vector> faces = ... Polyhedron polyhedron{vertices, faces}; double density = ... + Polyhedron polyhedron{vertices, faces, density, NormalOrientation::OUTWARDS, PolyhedronIntegrity::DISABLE}; + + // Our computation points std::array point = ... std::vector> points = ... // Instantiation of the GravityEvaluable object - GravityEvaluable evaluable{polyhedron, density}; + GravityEvaluable evaluable{polyhedron}; // From now, we can evaluate the gravity model for any point with const auto[pot, acc, tensor] = evaluable(point); diff --git a/docs/quickstart/examples_python.rst b/docs/quickstart/examples_python.rst index d2d738a..959c7e1 100644 --- a/docs/quickstart/examples_python.rst +++ b/docs/quickstart/examples_python.rst @@ -7,7 +7,7 @@ Details about mesh and input units can be found in :ref:`quick-start-io`. The use of the Python interface is pretty straight-forward since there is only one method: :code:`evaluate(..)` or the alternative -class :code:`GravityEvaluable` caching the polyhedron. +class :code:`GravityEvaluable` caching the :code:`Polyhedron` and intermediate results. Have a look at :ref:`evaluable-vs-eval` for further details about the difference. If you strive for maximal performance, use the the class :code:`GravityEvaluable`. @@ -16,50 +16,19 @@ The polyhedral source can either be a tuple of vertices and faces, or a list of polyhedral mesh files (see :ref:`supported-polyhedron-source-files`). The method calls follow the same pattern as the C++ interface. - -.. code-block:: python - - import polyhedral_gravity as model - - ############################################# - # Free function call - ############################################# - # Define the polyhedral_source which is either (vertices, faces) or a list of files - # Define the density (a float) - # Define the computation_points which is either a single point or a list of points - # Define if the computation is parallel or not (the default is parallel, which corresponds to True) - results = model.evaluate( - polyhedral_source=polyhedral_source, - density=density, - computation_points=computation_points, - parallel=True - ) - - ############################################# - # With the evaluable class - # This allows multiple evaluations on the same polyhedron - # without the overhead of setting up the normals etc. - ############################################# - # Parameters are the same as for the free function call - evaluable = model.GravityEvaluable( - polyhedral_source=polyhedral_source, - density=density - ) - results = evaluable( - computation_points=computation_points, - parallel=True - ) +You always define a :code:`Polyhedron` and then evaluate the polyhedral +gravity model using either the :code:`GravityEvaluable` or :code:`evaluate(..)`. Free function ------------- -**Example 1:** Evaluating the gravity model for a given polyhedron -defined from within source code for a specific point and density. +**Example 1:** Evaluating the gravity model for a given constant density +polyhedron defined from within source code for a single point. .. code-block:: python - import polyhedral_gravity as model + from polyhedral_gravity import Polyhedron, evaluate # Defining every input parameter in the source code vertices = ... # (N-3)-array-like of type float @@ -67,20 +36,24 @@ defined from within source code for a specific point and density. density = ... # float computation_point = ... # (3)-array-like - # Evaluate the gravity model + # Create a constant density polyhedron & Evaluate the gravity model # Notice that the third argument could also be a list of points # Returns a tuple of potential, acceleration and tensor # If computation_point would be a (N,3)-array, the output would be list of triplets! - potential, acceleration, tensor = model.evaluate((vertices, faces), density, computation_point, parallel=True) + polyhedron = Polyhedron((vertices, faces), density) + potential, acceleration, tensor = evaluate(polyhedron, computation_point, parallel=True) -**Example 2a:** Evaluating the gravity model for a given polyhedron -in some source files for several points and density. +**Example 2a:** Evaluating the gravity model for a given constant density polyhedron +in some source files for several points. Of course, you can also use keyword arguments for the parameters. +We also check that the polyhedron's plane unit normals are actually +outwards pointing. This will raise a ValueError if at least on +plane unit normal is inwards pointing. .. code-block:: python - import polyhedral_gravity as model + from polyhedral_gravity import Polyhedron, evaluate, PolyhedronIntegrity, NormalOrientation # Reading the vertices and files from a .node and .face file file_vertices = '___.node' # str, path to file @@ -91,20 +64,28 @@ Of course, you can also use keyword arguments for the parameters. # Evaluate the gravity model # Notice that the last argument could also be a list of points # Returns a list of tuple of potential, acceleration and tensor - results = model.evaluate( + polyhedron = Polyhedron( polyhedral_source=[file_vertices, file_nodes], density=density, + normal_orientation=NormalOrientation.OUTWARDS, + integrity_check=PolyhedronIntegrity.VERIFY, + ) + results = evaluate( + polyhedron=polyhedron, computation_points=computation_points, - parallel=True + parallel=True, ) -**Example 2b:** Evaluating the gravity model for a given polyhedron -in some source files for a specific point and density. +**Example 2b:** Evaluating the gravity model for a given constant density polyhedron +in some source files for a specific point. +We also check that the polyhedron's plane unit normals are actually +outwards pointing. We don't specify this here, as :code:`OUTWARDS` is the default. +It will raise a ValueError if at least on plane unit normal is inwards pointing. .. code-block:: python - import polyhedral_gravity as model + from polyhedral_gravity import Polyhedron, evaluate, PolyhedronIntegrity # Reading the vertices and files from a single .mesh file file = '___.mesh' # str, path to file @@ -115,21 +96,24 @@ in some source files for a specific point and density. # Notice that the last argument could also be a list of points # Returns a tuple of potential, acceleration and tensor # If computation_point would be a (N,3)-array, the output would be list of triplets! - potential, acceleration, tensor = model.evaluate([mesh], density, computation_point) + polyhedron = Polyhedron( + polyhedral_source=[file], + density=density, + integrity_check=PolyhedronIntegrity.VERIFY, + ) + potential, acceleration, tensor = evaluate(polyhedron, computation_point) For example 2a and 2b, refer to :ref:`supported-polyhedron-source-files` to view the available options for polyhedral input. -**Example 3:** A guard statement checks that the plane unit -normals are pointing outwards and no triangular surface is degenerated. -Only use this statement if one needs clarification -about the vertices' ordering due to its quadratic complexity! +**Example 3a:** Here explicitly disable the security check. +We **won't get an exception** if the plane unit normals are not +oriented as specified, **but we also don't pay for the check with quadratic runtime complexity!** .. code-block:: python - import polyhedral_gravity as model - import polyhedral_gravity.utility as mesh_sanity + from polyhedral_gravity import Polyhedron, evaluate, PolyhedronIntegrity, NormalOrientation # Defining every input parameter in the source code vertices = ... # (N-3)-array-like of type float @@ -137,15 +121,44 @@ about the vertices' ordering due to its quadratic complexity! density = ... # float computation_point = ... # (3)-array-like + # Evaluate the gravity model + # Returns a tuple of potential, acceleration and tensor + # If computation_point would be a (N,3)-array, the output would be list of triplets! + polyhedron = Polyhedron( + polyhedral_source=(vertices, faces), + density=density, + normal_orientation=NormalOrientation.OUTWARDS, + integrity_check=PolyhedronIntegrity.DISABLE, + ) + potential, acceleration, tensor = evaluate(polyhedron, computation_point) - # Additional guard statement to check that the plane normals - # are outwards pointing - if mesh_sanity.check_mesh(vertices, faces): - # Evaluate the gravity model - # Returns a tuple of potential, acceleration and tensor - # If computation_point would be a (N,3)-array, the output would be list of triplets! - potential, acceleration, tensor = model.evaluate((vertices, faces), density, computation_point) +**Example 3b:** Here we use the :code:`HEAL` option. +This guarantees a valid polyhedron. But the ordering of the faces array and +the normal_orientation might differ. +And we also need to pay the additional quadratic runtime for the checking algorithmus. + +.. code-block:: python + + from polyhedral_gravity import Polyhedron, evaluate, PolyhedronIntegrity, NormalOrientation + + # Defining every input parameter in the source code + vertices = ... # (N-3)-array-like of type float + faces = ... # (N-3)-array-like of type int + density = ... # float + computation_point = ... # (3)-array-like + + # Actually, the normal_orientation doesn't matter! We could the argument + # as HEAL guarantees a valid polyhedron + # but the polyhedron might different properties polyhedron.faces + # and polyhedron.normal_orientation than specified + polyhedron = Polyhedron( + polyhedral_source=(vertices, faces), + density=density, + normal_orientation=NormalOrientation.OUTWARDS, + integrity_check=PolyhedronIntegrity.HEAL, + ) + potential, acceleration, tensor = evaluate(polyhedron, computation_point) GravityEvaluable @@ -161,7 +174,7 @@ Have a look at the example below to see how to use the :code:`GravityEvaluable` .. code-block:: python - import polyhedral_gravity as model + from polyhedral_gravity import Polyhedron, GravityEvaluable, evaluate, PolyhedronIntegrity # Defining every input parameter in the source code vertices = ... # (N-3)-array-like of type float @@ -169,8 +182,15 @@ Have a look at the example below to see how to use the :code:`GravityEvaluable` density = ... # float computation_points = ... # (N,3)-array-like + # Definition of the Polyhedron in previous examples + polyhedron = Polyhedron( + polyhedral_source=(vertices, faces), + density=density, + integrity_check=PolyhedronIntegrity.HEAL, + ) + # Create the evaluable object - evaluable = model.GravityEvaluable(polyhedral_source, density) + evaluable = GravityEvaluable(polyhedron, density) for point in computation_points: # Evaluate the gravity model for single points (3)-array-like diff --git a/docs/quickstart/overview.rst b/docs/quickstart/overview.rst index afcb532..3a85b0d 100644 --- a/docs/quickstart/overview.rst +++ b/docs/quickstart/overview.rst @@ -36,7 +36,8 @@ mesh files. consistently **outwards** or **inwards** the polyhedron! This property is automatically enforced by the class :code:`Polyhedron` in both C++ library and Python interface as long as not explicit set to :code:`DISABLE`. - Setting this to off, is recommend for advanced users and when you "know your mesh". + Setting this to :code:`DISABLE`, is recommended for advanced users or when you "know your mesh". + For details, refer to the APIs or :ref:`mesh-integrity-check`. Gravity Model Output diff --git a/src/polyhedralGravity/input/YAMLConfigReader.cpp b/src/polyhedralGravity/input/YAMLConfigReader.cpp index ed3b95c..827c080 100644 --- a/src/polyhedralGravity/input/YAMLConfigReader.cpp +++ b/src/polyhedralGravity/input/YAMLConfigReader.cpp @@ -39,7 +39,7 @@ namespace polyhedralGravity { if (_file[ROOT][INPUT] && _file[ROOT][INPUT][INPUT_CHECK]) { return _file[ROOT][INPUT][INPUT_CHECK].as(); } else { - return false; + return true; } } diff --git a/src/polyhedralGravity/input/YAMLConfigReader.h b/src/polyhedralGravity/input/YAMLConfigReader.h index c25619d..8120735 100644 --- a/src/polyhedralGravity/input/YAMLConfigReader.h +++ b/src/polyhedralGravity/input/YAMLConfigReader.h @@ -81,7 +81,7 @@ namespace polyhedralGravity { /** * Reads the enablement of the input sanity check from the yaml file. - * @return true if explicitly enabled, otherwise per-default false + * @return true or false if explicitly enabled, otherwise per-default true */ bool getMeshInputCheckStatus() override; diff --git a/src/polyhedralGravity/model/Polyhedron.cpp b/src/polyhedralGravity/model/Polyhedron.cpp index dda0482..1d3aefa 100644 --- a/src/polyhedralGravity/model/Polyhedron.cpp +++ b/src/polyhedralGravity/model/Polyhedron.cpp @@ -78,8 +78,8 @@ namespace polyhedralGravity { std::string Polyhedron::toString() const { std::stringstream sstream{}; - sstream << ""; + sstream << ""; return sstream.str(); } @@ -98,7 +98,7 @@ namespace polyhedralGravity { indexIterator + numberOfFaces, std::inserter(violatingOutwards, violatingOutwards.end()), [this](const size_t index) { - // If the ray intersects the polyhedron odd number if times the normal points inwards + // If the ray intersects the polyhedron odd number of times the normal points inwards // Hence, violating the OUTWARDS constraint const size_t intersects = countRayPolyhedronIntersections(this->getResolvedFace(index)); return intersects % 2 != 0; @@ -132,7 +132,8 @@ namespace polyhedralGravity { "The mesh check is enabled and analyzes the polyhedron for degnerated faces & " "that all plane unit normals point in the specified direction. This checks requires " "a quadratic runtime cost which is most of the time not desirable. " - "Please explcity enable or disable this by setting 'check' to true orfalse"); + "Please explcity set the inetgrity_check to either VERIFY, HEAL or DISABLE." + "You can find further details in the documentation!"); // NO BREAK! AUTOMATIC implies VERIFY, but with a info mesage to explcitly set the option case PolyhedronIntegrity::VERIFY: // NO BREAK! VERIFY terminates earlier, but does in the beginning the same as HEAL @@ -147,13 +148,13 @@ namespace polyhedralGravity { if (violatingIndices.empty()) { sstream << "Instead all plane unit normals are pointing " << actualOrientation - << ". You can either reconstruct the reconstruct the polyhedron with the ortientation set to " << actualOrientation - << ". Alternativly, you can reconstruct with the integrity check set to HEAL"; + << ". You can either reconstruct the polyhedron with the ortientation set to " << actualOrientation + << ". Alternativly, you can reconstruct with the inetgrity_check set to HEAL"; } else { - sstream << "The actual majority orientation is " << actualOrientation + sstream << "The actual majority orientation of the polyhedron's normals is " << actualOrientation << ". You can either:\n 1) Fix the ordering of the following faces:\n" << violatingIndices << '\n' - << "2) Or you reconstruct the polyhedron using the integrity check set to HEAL."; + << "2) Or you reconstruct the polyhedron using the inetgrity_check set to HEAL."; } // In case of HEAL, don't throw but repair if (integrity != PolyhedronIntegrity::HEAL) { diff --git a/src/polyhedralGravity/model/Polyhedron.h b/src/polyhedralGravity/model/Polyhedron.h index 9f773b1..22bbe42 100644 --- a/src/polyhedralGravity/model/Polyhedron.h +++ b/src/polyhedralGravity/model/Polyhedron.h @@ -80,25 +80,25 @@ namespace polyhedralGravity { enum class PolyhedronIntegrity: char { /** * All activities regarding MeshChecking are disabled. - * @note No runtime overhead! + * No runtime overhead! */ DISABLE, /** * Only verification of the NormalOrientation. * A misalignment (e.g. specified OUTWARDS, but is not) leads to a runtime_error. - * @note Runtime Cost @f$O(n^2)$@f + * Runtime Cost O(n^2) */ VERIFY, /** * Like VERIFY, but also informs the user about the option in any case on the runtime costs. * This is the implicit default option. - * @note Runtime Cost: @f$O(n^2)$@f and output to stdout in every case! + * Runtime Cost: O(n^2) and output to stdout in every case! */ AUTOMATIC, /** * Verification and Autmatioc Healing of the NormalOrientation. * A misalignemt does not lead to a runtime_error, but to an internal correction. - * @note Runtime Cost: @f$O(n^2)$@f and a modification of the mesh input! + * Runtime Cost: O(n^2) and a modification of the mesh input! */ HEAL, }; diff --git a/src/polyhedralGravityPython/PolyhedralGravityPython.cpp b/src/polyhedralGravityPython/PolyhedralGravityPython.cpp index 28c9556..06fbef9 100644 --- a/src/polyhedralGravityPython/PolyhedralGravityPython.cpp +++ b/src/polyhedralGravityPython/PolyhedralGravityPython.cpp @@ -144,14 +144,14 @@ PYBIND11_MODULE(polyhedral_gravity, m) { Args: polyhedral_source: The vertices (:math:`(N, 3)`-array-like) and faces (:math:`(M, 3)`-array-like) of the polyhedron as pair or The filenames of the files containing the vertices & faces as list of strings - density: The constant density of the polyhedron, it must match the mesh's units, e.g. mesh in :math`[m]` then density in :math:`[kg/m^3]` + density: The constant density of the polyhedron, it must match the mesh's units, e.g. mesh in :math:`[m]` then density in :math:`[kg/m^3]` normal_orientation: The pointing direction of the mesh's plane unit normals, i.e., either :code:`OUTWARDS` or :code:`INWARDS` of the polyhedron. One of :py:class:`polyhedral_gravity.NormalOrientation`. (default: :code:`OUTWARDS`) integrity_check: Conducts an Integrity Check (degenerated faces/ vertex ordering) depending on the values. One of :py:class:`polyhedral_gravity.PolyhedronIntegrity`: * :code:`AUTOMATIC` (Default): Prints to stdout and throws ValueError if normal_orientation is wrong/ inconsisten - * :coce:`VERIFY`: Like :code:`AUTOMATIC`, but does not print to stdout + * :code:`VERIFY`: Like :code:`AUTOMATIC`, but does not print to stdout * :code:`DISABLE`: Recommened, when you know the mesh to avoid to pay :math:`O(n^2)` runtime. Disables ALL checks * :code`HEAL`: Automatically fixes the normal_orientation and vertex ordering to the correct values @@ -181,8 +181,8 @@ PYBIND11_MODULE(polyhedral_gravity, m) { Note: This utility is mainly for diagnostics and debugging purposes. If the polyhedron is constrcuted with `integrity_check` set to :code:`AUTOMATIC` or :code:`VERIFY`, the construction fails anyways. - If set to code:`HEAL`, this method should return an empty set (but maybe a different ordering than initially specified) - Only if set to coe:`DISABLE`, then this method might actually return a set with faulty indices. + If set to :code:`HEAL`, this method should return an empty set (but maybe a different ordering than initially specified) + Only if set to code:`DISABLE`, then this method might actually return a set with faulty indices. Hence, if you want to know your mesh error. Construct the polyhedron with :code:`integrity_check=DISABLE` and call this method. )mydelimiter") .def("__getitem__", &Polyhedron::getResolvedFace, R"mydelimiter( @@ -193,7 +193,7 @@ PYBIND11_MODULE(polyhedral_gravity, m) { index: The index of the face Returns: - :math:´(3, 3)`-array-like: The resolved face + :math:`(3, 3)`-array-like: The resolved face Raises: IndexError if face index is out-of-bounds @@ -256,9 +256,9 @@ PYBIND11_MODULE(polyhedral_gravity, m) { parallel: If :code:`True`, the computation is done in parallel (default: :code:`True`) Returns: - Either a tuple of potential :math:`V`, acceleration :math:`[V_x, V_y, V_z]` + Either a triplet of potential :math:`V`, acceleration :math:`[V_x, V_y, V_z]` and second derivatives :math:`[V_{xx}, V_{yy}, V_{zz}, V_{xy},V_{xz}, V_{yz}]` at the computation points or - if multiple computation points are given a list of these tuples + if multiple computation points are given a list of these triplets )mydelimiter", py::arg("computation_points"), py::arg("parallel") = true) .def(py::pickle( [](const GravityEvaluable &evaluable) { @@ -298,9 +298,9 @@ PYBIND11_MODULE(polyhedral_gravity, m) { parallel: If :code:`True`, the computation is done in parallel (default: :code:`True`) Returns: - Either a tuple of potential :math:`V`, acceleration :math:`[V_x, V_y, V_z]` + Either a triplet of potential :math:`V`, acceleration :math:`[V_x, V_y, V_z]` and second derivatives :math:`[V_{xx}, V_{yy}, V_{zz}, V_{xy},V_{xz}, V_{yz}]` at the computation points or - if multiple computation points are given a list of these tuples + if multiple computation points are given a list of these triplets )mydelimiter", py::arg("polyhedron"), py::arg("computation_points"), py::arg("parallel") = true); } \ No newline at end of file From 8bd1a4a91c96a20b8fa9cc25ae4dc5f732a790e1 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Wed, 17 Apr 2024 23:17:26 +0200 Subject: [PATCH 25/54] update jupyter notebook and everything else --- script/cube_plots.py | 10 +- script/eros_plots.py | 14 +- script/polyhedral-gravity.ipynb | 84 +++++---- script/time.py | 177 +++++++++--------- script/torus_plots.py | 14 +- .../PolyhedralGravityPython.cpp | 2 +- 6 files changed, 171 insertions(+), 130 deletions(-) diff --git a/script/cube_plots.py b/script/cube_plots.py index 2a59606..e899d70 100644 --- a/script/cube_plots.py +++ b/script/cube_plots.py @@ -1,5 +1,5 @@ import numpy as np -import polyhedral_gravity as gravity_model +from polyhedral_gravity import evaluate, Polyhedron, PolyhedronIntegrity import mesh_plotting @@ -32,6 +32,12 @@ DENSITY = 1.0 VALUES = np.arange(-2, 2.01, 0.01) +cube = Polyhedron( + polyhedral_source=(cube_vertices, cube_faces), + density=DENSITY, + integrity_check=PolyhedronIntegrity.DISABLE, +) + ######################################################################################################################## # Triangulation ######################################################################################################################## @@ -43,7 +49,7 @@ # Plot of the potential and Acceleration in XY Plane (Z = 0) ######################################################################################################################## computation_points = np.array(np.meshgrid(VALUES, VALUES, [0])).T.reshape(-1, 3) -gravity_results = gravity_model.evaluate(cube_vertices, cube_faces, DENSITY, computation_points) +gravity_results = evaluate(cube, computation_points) potentials = -1 * np.array([i[0] for i in gravity_results]) potentials = potentials.reshape((len(VALUES), len(VALUES))) diff --git a/script/eros_plots.py b/script/eros_plots.py index 7088237..70c1e9c 100644 --- a/script/eros_plots.py +++ b/script/eros_plots.py @@ -1,5 +1,5 @@ import numpy as np -import polyhedral_gravity as gravity_model +from polyhedral_gravity import Polyhedron, evaluate, PolyhedronIntegrity import mesh_plotting import mesh_utility @@ -11,6 +11,12 @@ DENSITY = 1.0 VALUES = np.arange(-2, 2.01, 0.01) +eros = Polyhedron( + polyhedral_source=(vertices, faces), + density=DENSITY, + integrity_check=PolyhedronIntegrity.DISABLE, +) + ######################################################################################################################## # Triangulation ######################################################################################################################## @@ -22,7 +28,7 @@ # Plot of the potential and Acceleration in XY Plane (Z = 0) ######################################################################################################################## computation_points = np.array(np.meshgrid(VALUES, VALUES, [0])).T.reshape(-1, 3) -gravity_results = gravity_model.evaluate(vertices, faces, DENSITY, computation_points) +gravity_results = evaluate(eros, computation_points) potentials = -1 * np.array([i[0] for i in gravity_results]) potentials = potentials.reshape((len(VALUES), len(VALUES))) @@ -47,7 +53,7 @@ # Plot of the potential and Acceleration in XZ Plane (Y = 0) ######################################################################################################################## computation_points = np.array(np.meshgrid(VALUES, [0], VALUES)).T.reshape(-1, 3) -gravity_results = gravity_model.evaluate(vertices, faces, DENSITY, computation_points) +gravity_results = evaluate(eros, computation_points) potentials = -1 * np.array([i[0] for i in gravity_results]) potentials = potentials.reshape((len(VALUES), len(VALUES))) @@ -75,7 +81,7 @@ # Plot of the potential and Acceleration in YZ Plane (X = 0) ######################################################################################################################## computation_points = np.array(np.meshgrid([0], VALUES, VALUES)).T.reshape(-1, 3) -gravity_results = gravity_model.evaluate(vertices, faces, DENSITY, computation_points) +gravity_results = evaluate(eros, computation_points) potentials = -1 * np.array([i[0] for i in gravity_results]) potentials = potentials.reshape((len(VALUES), len(VALUES))) diff --git a/script/polyhedral-gravity.ipynb b/script/polyhedral-gravity.ipynb index 22780f9..d4616a5 100644 --- a/script/polyhedral-gravity.ipynb +++ b/script/polyhedral-gravity.ipynb @@ -47,8 +47,7 @@ "import matplotlib.pyplot as plt\n", "import matplotlib.patches as patches\n", "from matplotlib import cm\n", - "import polyhedral_gravity as gravity_model\n", - "import polyhedral_gravity.utility as gravity_util\n", + "from polyhedral_gravity import Polyhedron, evaluate, PolyhedronIntegrity, NormalOrientation, GravityEvaluable\n", "\n", "# These two scripts provide some utility for plotting and the analytical solution\n", "# They reside in the same directory as this notebook\n", @@ -72,9 +71,11 @@ "\n", "Next, we start with an easy example evaluating the gravity tensor for points of a cubic polyhedron consisting of $12$ triangular faces, centered at the origin $(0, 0, 0)$ and with edges of $2m$.\n", "Therefor, we first declare the vertices and the connectivity of this polyhedron.\n", + "Further, we define the density of the cube as $\\rho = 1 \\frac{kg}{m^3}$.\n", "\n", - "**Important!:** The vertices in the faces need to be sorted, so that the plane normals will point outwards of the polyhedron!\n", - "The Python interface provides an `utility` submodule which offers the capabilities to check for this constraint. However, one shall notice that the procedure is computationally expensive in $O(N^2)$ using the Möller–Trumbore intersection algorithm.\n" + "**Important!:** The vertices in the faces need to be sorted, so that the plane normals will point consistently outwards/ inwards the polyhedron!\n", + "By default the the `Polyhedron` class will check that and even assure the property!\n", + "For the cube, we use the guranteed version using `HEAL`. This might modify the order of the vertices in the faces, but gurantees that the normals point outwards/ inwards consistently.\n" ] }, { @@ -90,7 +91,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Plane normals point outwards: True\n" + "\n" ] } ], @@ -124,9 +125,13 @@ " [4, 6, 7],\n", " ]\n", ")\n", - "\n", - "outwards_pointing_normals = gravity_util.check_mesh(cube_vertices, cube_faces)\n", - "print(f\"Plane normals point outwards: {outwards_pointing_normals}\")" + "density = 1.0 # [kg/m^3]\n", + "cube_polyhedron = Polyhedron(\n", + " polyhedral_source=(cube_vertices, cube_faces),\n", + " density=density,\n", + " integrity_check=PolyhedronIntegrity.HEAL,\n", + ")\n", + "print(cube_polyhedron)" ] }, { @@ -137,7 +142,7 @@ } }, "source": [ - "Next we define the wished computation point $(1, 0, 0)$ and the density in $\\frac{kg}{m^3}$\n" + "Next we define the wished computation point $(1, 0, 0)$\n" ] }, { @@ -150,8 +155,7 @@ }, "outputs": [], "source": [ - "computation_point = [1, 0, 0] # [m]\n", - "density = 1.0 # [kg/m^3]" + "computation_point = [1, 0, 0] # [m]" ] }, { @@ -184,15 +188,14 @@ "text": [ "=============Gravity Model Solution=============\n", "Potential: 4.786301362419239e-10 m^2/s^2\n", - "Acceleration [Vx, Vy, Vz]: [3.466493366453959e-10, 5.927969226604545e-26, 0.0] m/s^2\n", + "Acceleration [Vx, Vy, Vz]: [-3.466493366453959e-10, -5.927969226604545e-26, -0.0] m/s^2\n", "Second derivative tensor [Vxx, Vyy, Vzz, Vxy, Vxz, Vyz]: [-5.375692682923615e-11, -1.8280085506392544e-10, -1.8280085506392544e-10, 0.0, 0.0, 8.891953839906818e-26] 1/s^2\n" ] } ], "source": [ - "potential, acceleration, tensor = gravity_model.evaluate(\n", - " polyhedral_source=(cube_vertices, cube_faces),\n", - " density=density,\n", + "potential, acceleration, tensor = evaluate(\n", + " polyhedron=cube_polyhedron,\n", " computation_points=computation_point,\n", " parallel=True,\n", ")\n", @@ -233,7 +236,7 @@ "text": [ "=============Analytical Solutions=============\n", "Analytical Potential: 4.78630136241924E-10 m^2/s^2\n", - "Analytical Acceleration [Vx, Vy, Vz]: [3.46649336645396e-10 0 0] m/s^2\n", + "Analytical Acceleration [Vx, Vy, Vz]: [-3.46649336645396e-10 0 0] m/s^2\n", "=================Differences==================\n", "Difference Potential: 2.06795153138257E-25\n", "Difference Acceleration: [1.55096364853693e-25 5.92796922660455e-26 0]\n" @@ -320,9 +323,8 @@ "Y = VALUES\n", "\n", "computation_points = np.array(np.meshgrid(X, Y, [0])).T.reshape(-1, 3)\n", - "gravity_results = gravity_model.evaluate(\n", - " polyhedral_source=(cube_vertices, cube_faces),\n", - " density=density,\n", + "gravity_results = evaluate(\n", + " polyhedron=cube_polyhedron,\n", " computation_points=computation_points,\n", ")" ] @@ -404,7 +406,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -420,9 +422,8 @@ "Y = VALUES\n", "\n", "computation_points = np.array(np.meshgrid(X, Y, [0])).T.reshape(-1, 3)\n", - "gravity_results = gravity_model.evaluate(\n", - " polyhedral_source=(cube_vertices, cube_faces),\n", - " density=density,\n", + "gravity_results = evaluate(\n", + " polyhedron=cube_polyhedron,\n", " computation_points=computation_points,\n", ")\n", "\n", @@ -453,7 +454,8 @@ "\n", "**Important Note:** The employed mesh of Eros here is unitless! Thus, units are not a concern here. Its just a demonstration of the interface.\n", "\n", - "Further, we also make use of the `Evaluable` class, which allows us to efficiently evaluate the gravity tensor for multiple computation points at once, even with interruptions in between. Certain computed properties are cached and reused.\n" + "Further, we also make use of the `GravityEvaluable` class, which allows us to efficiently evaluate the gravity tensor for multiple computation points at once, even with interruptions in between. Certain computed properties are cached and reused.\n", + "We also know this mesh and that all normals are `OUTWARDS` pointing. So we don't need the mesh check and `DISABLE` it.\n" ] }, { @@ -469,25 +471,31 @@ "name": "stdout", "output_type": "stream", "text": [ - "Potential: 1.641219381390107e-07\n", - "Acceleration [Vx, Vy, Vz]: [2.410422444002989e-09, 3.9101840968470284e-08, 9.039023451764005e-09]\n", - "Second derivative tensor [Vxx, Vyy, Vzz, Vxy, Vxz, Vyz]: [-1.224392128772979e-07, -1.1414944948899626e-06, -9.754414135835843e-07, -3.86381487022689e-08, 1.354813459901532e-08, -2.6597490639550824e-08]\n" + "Potential: 1.6412193813901074e-07\n", + "Acceleration [Vx, Vy, Vz]: [-2.4104224440030084e-09, -3.9101840968470165e-08, -9.039023451764005e-09]\n", + "Second derivative tensor [Vxx, Vyy, Vzz, Vxy, Vxz, Vyz]: [-1.2243921287729791e-07, -1.1414944948899626e-06, -9.754414135835843e-07, -3.86381487022689e-08, 1.3548134599015306e-08, -2.6597490639550815e-08]\n" ] } ], "source": [ "eros_vertices_path = \"mesh/Eros.node\"\n", "eros_faces_path = \"mesh/Eros.face\"\n", - "\n", "density = 2670.0\n", + "\n", + "eros_polyhedron = Polyhedron(\n", + " polyhedral_source=[eros_vertices_path, eros_faces_path],\n", + " density=density,\n", + " normal_orientation=NormalOrientation.OUTWARDS,\n", + " integrity_check=PolyhedronIntegrity.DISABLE,\n", + ")\n", + "\n", + "\n", "computation_point = np.array([0, 0, 0]) # m\n", "\n", "# The differende betweeen array input & file input lies in the types\n", "# Array Mesh Input ==> tuple of arrays/ lists\n", "# File Mesh Input ==> list of string file paths\n", - "evaluable_eros = gravity_model.GravityEvaluable(\n", - " polyhedral_source=[eros_vertices_path, eros_faces_path], density=density\n", - ")\n", + "evaluable_eros = GravityEvaluable(eros_polyhedron)\n", "\n", "# Call the evaluable object with the computation point(s) and optionally disable/ enable parallelization\n", "potential, acceleration, tensor = evaluable_eros(computation_points=computation_point, parallel=True)\n", @@ -602,7 +610,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeAAAAHWCAYAAACv91olAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOxdd3RVxdc9AZJA6L1I7yC996JUAQFpogIioKJSBUWK0hEEBKUj7UfvRYr03lvoLXRSCCG95713vj/290i7c+5DIqHMXisLzZzcO/femTlTzt7HiZmZNDQ0NDQ0NF4qUiR3BTQ0NDQ0NN5GaAesoaGhoaGRDNAOWENDQ0NDIxmgHbCGhoaGhkYyQDtgDQ0NDQ2NZIB2wBoaGhoaGskA7YA1NDQ0NDSSAdoBa2hoaGhoJAO0A9bQ0NDQ0EgGaAesoaGhoaGRDNAOWENDQ0NDIxmgHfBrij/++IOcnJyoTJkyyV0VIiJavHgxOTk50b1795Ll/seOHaORI0dSYGBgorLkrFtyv5fkwsiRI8nJyemVuXdyfgdV20zutrF69Wp69913KU2aNOTk5ETu7u7JUo//EqGhodS/f3/KkycPpU6dmipUqECrVq1K7mo9g3bArykWLlxIRERXrlyhkydPJnNtkh/Hjh2jUaNGGTrgFi1a0PHjxyl37twvvV7JeW+NWCTnd1C1zeSs05MnT6hLly5UpEgR+ueff+j48eNUvHjxl16P/xofffQRLVmyhH755RfasWMHVa1alTp37kwrVqxI7qoREVGq5K6AxvPjzJkzdOHCBWrRogVt27aNFixYQNWrV0/uaiUpwsPDyc3NLUmulT17dsqePXuSXOt1urdGLBz5DknZ5hxBcraNmzdvUkxMDH322WdUv379JLnmy35/Zti+fTvt3r2bVqxYQZ07dyYiooYNG9L9+/dp8ODB1KlTJ0qZMmWy1lGvgF9DLFiwgIiIfv31V6pVqxatWrWKwsPDE9ldv36dOnfuTDlz5iRXV1fKnz8/de3alaKiop7L5tatW/TJJ59Qjhw5yNXVlUqVKkUzZ850qK6O/K19y/DcuXPUvn17ypw5MxUpUoSIiDw8PKh79+5UrFgxcnNzo3feeYdatWpFly5divf3gwcPJiKiQoUKkZOTEzk5OdGBAweISL3Vd+TIEXr//fcpffr05ObmRrVq1aJt27YZ1u3KlSvUuXNnypgxI+XMmZO++OILCgoKMn3+hPd+0et5e3tTunTp6OOPP473+61bt5KzszMNGzZM+beOvMt/89zbtm2jChUqkKurKxUqVIgmT55s+hx2fPTRR5Q3b95Ev7dYLFShQgVq3Lix+PeO3lv1HYzaHJHjbd6s/0htM7na5eeff0516tQhIqJOnTqRk5MTNWjQ4F/dX/X+EuLatWvPnj3hT8aMGem/yIq7ceNGSpcuHXXo0CHe77t3705eXl6vxM6hXgG/ZoiIiKCVK1dS1apVqUyZMvTFF19Qz549ae3atdStW7dndhcuXKA6depQtmzZaPTo0VSsWDHy9vamLVu2UHR0NLm6ujpkc/XqVapVqxblz5+fpkyZQrly5aKdO3dS3759yc/Pj3755RdlXZ/3bz/66CP6+OOP6euvv6awsDAiIvLy8qKsWbPSr7/+StmzZyd/f39asmQJVa9enc6fP08lSpSgnj17kr+/P/3555+0YcOGZ1t6pUuXVtbt4MGD1LhxYypXrhwtWLCAXF1dadasWdSqVStauXIlderUKZ59u3btqFOnTtSjRw+6dOkS/fTTT0QUexTwvPi318udOzf98MMPzwb2ypUr04EDB6hDhw7Uu3dvGjdunPJvHXmXz1vPvXv3UuvWralmzZq0atUqslqtNGnSJHr8+LFD76FevXq0ceNGun//PhUoUODZ76dOnUrXr1+ntWvXKv/2Re9NZNzmHG23jvQfqW0anf2+jHY5YsQIqlatGn377bc0fvx4atiwIWXIkOFf3d/o/RkhT548dPz48Xi/27NnD40YMYK++OKLRGf2zExWq1V5vbhIlcrYjV2+fJlKlSqVqLxcuXLPymvVquXQPf4zsMZrhf/9739MRDxnzhxmZg4JCeF06dJx3bp149m99957nClTJvb19VVeyxGbpk2bct68eTkoKCje77/77jtOnTo1+/v7MzPzokWLmIj47t27z/23v/zyCxMR//zzz6bPb7FYODo6mosVK8YDBgx49vvffvst0f3tMKpbjRo1OEeOHBwSEhLv2mXKlOG8efOyzWaLV7dJkybFu+Y333zDqVOnfmanQsJ7v+j1mJnDwsI4T548/P777/OpU6c4ffr03L17d4f+Ni5U7/J56lm9enXOkycPR0REPLMJDg7mLFmysCPDy9mzZ5mIeMWKFc9+d+fOHXZzc+PRo0eLf/s891Z9B6M252i7daT/MKvbZnK2y/379zMR8dq1a+P9/nnv70ifNcLGjRvZ1dWVBw0aJNbPkR+jPs/MXKxYMW7atGmi33t5eTER8fjx4/9V3ZMSegv6NcOCBQsoTZo0z7Yg7Vsshw8fplu3bhERzmIOHjxIHTt2VJ4xOWITGRlJe/fupbZt25KbmxtZLJZnPx988AFFRkbSiRMnkuxv27Vrl+g6FouFxo8fT6VLlyYXFxdKlSoVubi40K1bt+jatWsOv7e4CAsLo5MnT1L79u0pXbp0z36fMmVK6tKlCz169Ihu3LgR728+/PDDeP9frlw5ioyMJF9f339Vhxe5npubG40dO5b27t1LDRs2pObNm9P8+fNNo47/zbuU6hkWFkanT5+mjz76iFKnTv3MJn369NSqVSvT5yAiqlChAmXIkIGOHj367He9e/emfPny0Y8//qj8u6S4N1HiNudou3Wk/zwvkrtd/pv7G/VZMyxdupQ6dOhAw4cPp99++83QpnLlynT69GmHfvLkyaO8l9QnkitKPy70FvRrBA8PDzp06BC1a9eOmPlZVGX79u1p0aJFtHDhQpowYQIFBASQ1Wo1PFuzwxGbp0+fksVioT///JP+/PNPQxs/P78k+1ujaNCBAwfSzJkz6ccff6T69etT5syZKUWKFNSzZ0+KiIhQ1l1CQEAAMbPh/eyd+enTp/F+nzVr1nj/7+rqSkT0r+vwotezR6w6OTnR4sWLHQom+TfvUqpnTEwM2Ww2ypUrV6K/M/qdEVKkSEG1atWiY8eOERHR8uXLaefOnbR//35ycXFR/l1AQMAL35socZtztN060n+eF8ndLv/N/Z83gnvGjBnUv39/mjZtGn333XdKu3Tp0lGFChUcuqZqCzpr1qyJ6ktE5O/vT0REWbJkcej6/yW0A36NsHDhQmJmWrduHa1bty5R+ZIlS2js2LGUJUsWSpkyJT169Eh5LUdsMmfO/Gz2++233xraFCpUKMn+1mhGumzZMuratSuNHz8+3u/9/PwoU6ZMyrpLsDseb2/vRGVeXl5ERJQtW7Z/de2XAXd3d2rZsiXVrl2bjh49SgsXLlS+47hI6neZOXNmcnJyIh8fn0RlRr9ToV69ejRixAh68OABDRw4kLp16xYvKOi/vHfCNudou3VzczPtP8+L5G6X/+b+z7OKHDduHI0cOZIWLlxIXbt2FW0PHjxIDRs2dOi6d+/epYIFCyb6fdmyZWnlypVksVjiOWl70OGroKGgHfBrAqvVSkuWLKEiRYrQX3/9lah869atNGXKFNqxYwe1bNmS6tevT2vXrqVx48YZdto0adKY2ri5uVHDhg3p/PnzVK5cOXFFkpR/GxdOTk7PZvV2bNu2jTw9Palo0aLPfvc8M/+0adNS9erVacOGDTR58mRKkyYNERHZbDZatmwZ5c2b95XlRN64cYOaNm1KNWvWpM2bN1OHDh1o5MiR9Nlnn1HGjBnFv3X0XTqKtGnTUrVq1WjDhg3022+/PdsKDgkJob///tvh69SrV4+sViu1bNmSrFarQ1HUSXXvhHiedmvWf+xwtG0md7v8L+8/ePBg+vPPP2nt2rXUpk0bU3v7FrQjUG1Bt23blubPn0/r16+PFzy2ZMkSypMnzytB3dQO+DXBjh07yMvLiyZOnGi4OihTpgzNmDGDFixYQC1btqSpU6dSnTp1qHr16jRkyBAqWrQoPX78mLZs2UJz586l9OnTO2Qzffp0qlOnDtWtW5d69+5NBQsWpJCQEPLw8KC///6b9u3bp6zzi/ytHS1btqTFixdTyZIlqVy5cnT27Fn67bffEm39lS1b9tk9u3XrRs7OzlSiRAlKnz694XUnTJhAjRs3poYNG9KgQYPIxcWFZs2aRZcvX6aVK1e+EudDCXHv3j1q1KgRlShRgtavX0/Ozs7066+/UpkyZWj8+PE0ceJE8e8dfZfPgzFjxlCzZs2ocePG9P3335PVaqWJEydS2rRpn231maFq1aqUJk0aunTpEi1cuNDhVV5S3NsIjrZbR/oPkbptGiG52+V/cf/+/fvT9OnTacyYMZQrV654sR+5c+eOF/1uR/r06alKlSov9CzNmzenxo0bU+/evSk4OJiKFi1KK1eupH/++YeWLVuW7BxgItJR0K8L2rRpwy4uLmLE5ccff8ypUqViHx8fZma+evUqd+jQgbNmzcouLi6cP39+/vzzzzkyMvLZ3zhic/fuXf7iiy/4nXfeYWdnZ86ePTvXqlWLx44d+8zGKKLT0b+1R1Q+efIk0TMFBARwjx49OEeOHOzm5sZ16tThw4cPc/369bl+/frxbH/66SfOkycPp0iRgomI9+/fL9bt8OHD/N5773HatGk5TZo0XKNGDf7777/j2ajqprpmQqiib5/3el5eXlykSBGuVKlSoujcXr16saurq2ldnuddPk89t2zZwuXKlXvWfn799ddnf+8IYmJiOE+ePFy3bt3njuR29N6Ofgc7HGm3zI71H2bjtpmc7VIVBf2i908Im83GGTJkUEYw//777+LfvyhCQkK4b9++nCtXLnZxceFy5crxypUr/9N7Pg+cmP8DBrSGhoaGg5g8eTINGzaM3N3dqVSpUsldHQ2Nlwa9Ba2hofHSER4eThcuXKDTp0/TsGHDaNy4cdr5arx10A5YQ0PjpWPXrl3Utm1bypUrFw0dOpQGDRqU3FXS0Hjp0FvQGhoaGhoayQCthKWhoaGhoZEM0A5YQ0NDQ0MjGaAdsIaGhoaGRjJAB2ElEWw2G3l5eVH69OlfSREHDQ0NDY3/HsxMISEhlCdPHkqRQl7jagecRPDy8qJ8+fIldzU0NDQ0NF4BPHz40FRlTjvgJIJddu7hw4fPkltraGhoaLxdCA4Opnz58illcONCO+Akgn3bOUOGDNoBa2hoaLzlcOQoUgdhaWhoaGhoJAO0A9bQ0NDQ0EgGaAesoaGhoaGRDNAOWENDQ0NDIxmgHbCGhoaGhkYyQDtgDQ0NDQ2NZIB2wBoaGhoaGskA7YA1NDQ0NDSSAdoBa2hoaGhoJANeOwd86NAhatWqFeXJk4ecnJxo06ZNpn9z8OBBqly5MqVOnZoKFy5Mc+bMSWSzfv16Kl26NLm6ulLp0qVp48aN/0HtNTQ0NDQ0gNfOAYeFhVH58uVpxowZDtnfvXuXPvjgA6pbty6dP3+ehg4dSn379qX169c/szl+/Dh16tSJunTpQhcuXKAuXbpQx44d6eTJk//VY2hoaGhovOVwYmZO7kr8Wzg5OdHGjRupTZs2Spsff/yRtmzZQteuXXv2u6+//pouXLhAx48fJyKiTp06UXBwMO3YseOZTbNmzShz5sy0cuVKh+oSHBxMGTNmpKCgIK0FnUxgJjKTX30TbV6lupjhVavrm/j+X/QbabwYnscXvHYr4OfF8ePHqUmTJvF+17RpUzpz5gzFxMSINseOHVNeNyoqioKDg+P9vCgiI4nMdr5v3yY6eFC22bOHKM58wxAzZhCFh6vLbTaikSPlawQHE40eLdtcvEg0a5Zss2YN0bZtss3IkUSXL6vLbTaijz4i+v9PaojgYNhIuHKF6MsvZZvVq4kmTpRthg8n2rJFXc6Muly5oraJiiIqX15+pocPierWleuyZw9R9+6yzbRpRJMnyzY9ehD9849sU6cO0Z076vLISKJ338WzqXDtGlHTpvJ9Nm0iGjBAthk/nmjRItmma1ei06dlm/feI/LzU5dHRRHVr09ksaht3N2JvvlGvs+GDeiXEiZOJDpwQLb59lsiLy/Zpnt3+RuEhRH164d2qoK7O9GCBfJ9tm0jOnxYtpk3j8jbW7aZPl3uB8xEM2fK1wgIMB9fL18munRJtklKvPEO2MfHh3LmzBnvdzlz5iSLxUJ+/9+rVDY+Pj7K606YMIEyZsz47CcpcgGnTk2UJ49sU7AgkaurbFOjBlFEhGzz4YdyJ02RgqhJE6LQULVNhgxEVavK9ylblih/ftmmRQuiVCZ5uT7/HIO3CilSYOCR5kEZMhB16CDfp3Rponr1ZJsPP8R3kNC9O1GmTOpyJyeiLl2IcudW27i6EvXpQ+TiorbJl4+oWze5LvXqETVoINu0aEFUpYps07Qp2paErl2JChVSl6dJg4FdasMlShB16iTfp0QJovbtZZtSpYhat5Zt3nvP/Lm7diXKlk1dnjo10RdfyG3Y1RU2EtKlI+rcWbYpUsR8wtWwoTyOMKMNS9/gyRNMuKSVdGQkkbD5SER4N2ZtpnBhuR/YbEQVKhA5O6ttnj7Ft5Tw5Il537ZYiIoXl22SEm/8FnTx4sWpe/fu9NNPPz373dGjR6lOnTrk7e1NuXLlIhcXF1qyZAl1jtP6ly9fTj169KBIxagfFRVFUXGmkPYckHoL+tXGq7QVaO95ko3NhsmFhJdlY7USpUwpXyOpbMzqYrPhvb2Md/cqbVNrvPp4ni3oNz4fcK5cuRKtZH19fSlVqlSUNWtW0SbhqjguXF1dydVsKarxysGRAe5l2ThyDTPn8DJtzJxmUtqY1eVlvpeX9a2183378MZvQdesWZN2794d73e7du2iKlWqkPP/72mobGrVqvXS6qmhoaGh8XbhtVsBh4aGkoeHx7P/v3v3Lrm7u1OWLFkof/789NNPP5Gnpyf973//IyJEPM+YMYMGDhxIvXr1ouPHj9OCBQviRTf369eP6tWrRxMnTqTWrVvT5s2bac+ePXTkyJGX/nwaGhoaGm8J+DXD/v37mYgS/XTr1o2Zmbt168b169eP9zcHDhzgihUrsouLCxcsWJBnz56d6Lpr167lEiVKsLOzM5csWZLXr1//XPUKCgpiIuKgoKB/+2gaGhoaGq85nscXvNZBWK8SNA9YQ0NDQ0PzgN9wODJlMrOx2cyvYbWa20jcPHs9JL6h/T4SxYgI5WbUKl9f8+d++FAut1iI7t+XbUJCiB49km28vGTuqM0GvmxAgNomOhq8ROndhIcTnTkj1+XpU/CxJdy7B465hEuX8I5VYEZdgoLUNuHh4I9KzxQQgPpK3/LxY6Jbt+T63r0r15cInGOzdnX1qtwXoqLw/qT6BgeDBiMhKEh+d0T4ltHRso2/v3k/CAmRy5nN30tMjPl9JG60HY6MM46MV0kxLr5saAf8CiEkxFzgwd2d6P+Pt5VYutSc/N6/vzw4xcSAZyk1WF9fok8/le9z+DDR0KGyzR9/EC1fLtv07El04YK6PDoavOWwMLXN48dErVrJ9zlzBnxiCcuXmwsmjB1LtHOnutzJCfzdBw/UNlYrUbNmcqSur685v/TkSYhSSFi9mmjVKtlm4kSiEyfU5U5O+E7+/mqblCmJWraUn8nLi6h3bzkqeP9+c+GQBQsg8iLhxx/NhTg6diQSJAHIYkHbkyaaV6+CVyv1p7VriaZOlesyahTR9u2yzaefEsUJkzHEe+/JHP8nT8DxlRzf4cMQnJEwbx4ERiQMHmw++fvyS3lCEBND9N138vu9fx9jjYSdO83HziTFf74h/pYgqc6A790zt/HwkMutVuabN2Wb0FDmu3fN6xIQINucOcNss8k2x4/L5RYL89Gjsk1AAPP587LNxYvMPj6yzY4dcjkz899/y+UWC/PWrbLN48fMR47INgcOMD95ItusXSuXMzOvXi2XWyzm13nwwLy+W7cyBwe/WF0csbFamdetk22uX2e+cEG22b4d7VyCI6EemzbJ5TYb85Ytss3Vq+b99sAB5vBw2WbXLvP+tm+fXB4TY97f7txh9vSUbc6fZ46MlG3OnjWvr9l3jIlhvnFDtvH1ZX76VLa5f585Olq2uXfPvL5m0GfAyQB9Bqzxb/A66Qy/rXXR0Hge6DNgDY3XBC9LwOFVEpN43eqiofFfQTtgDQ0NDQ2NZIB2wBoaGhoaGskA7YA1NDQ0NDSSAdoBa2hoaGhoJAO0A37FYEayd4QgHxFhLn7x+LF5Xe7elcstFggZSAgMJLpxw/w+0r2YwT+V6hwdDc6nRPwPCiJaskSui4cHOLESDh0yT0y/fLnML42OBpdYejd+fuDeSoIeHh5Eo0fL/Mdjx8x5y+vXE61bJ9v8+SfR0aPqcouFaMwY+Zl8fcFJlkQprl0jmjRJ/pbHjhH99Zdc340biXbskG3mz5f55UREU6bIubMDA4nmzpXFLe7cQfuURCcuXgS/WcLhw+b9adcu1MnMRqqL1Yp3LOHpUwiQSPDxkXnhRESenuaCPmaCKkTmIibMEIKREB39csU6tAN+heDnB1K6hGPHMBBKWLSIaNs2dTkz0U8/yR05IgLCAZIj9/Q0r+/Zs0S//y7bbN5MtGmTbDNnjqzmxIz7PH2qtomOJpo2Tb5PWJi5k/b2JkqQPCsRrl7FjwouLiD9SwNCpkxwMunTq23Sp8f7k6J5LRbzwdTLy1wM4eJF2cmkSkW0dSsSy6uQOTPaZ5YsahsnJ7xfKcG9pyfR9etyfc+eNVef+vtvuZwIwjZp0qjLnZzggN3c1DaenriXlIrx0CHUWcKyZeZOb8oUebLKTDRkCNS5VLh3j2jcONkxHjqECYyEv/4i2rdPtvn5Z/lbMkNsRqpvUBDEOiThkLNnzYVO1qwxn7QlKV6McqxhR1IJcQQHmxPB/f3Nr+PrK5dbrcze3rJNSIg5uf3OHVxLwvXrcjkz86VLcnlUFPPly7LNo0fm4gHHjpnX5dAhudxmY96/X7YJDmY+eVK2OX/e/Dv9849czmwuLmKzmds8fsx8+rRss28fc1iYbLN9u1zuiI3Vav7cHh7mwhb796PdSNizRy5nNhe2sFiYDx+Wba5fN//WJ0/iWhJOnZLLmSF+ISEsjPnWLdnm3j1zEZObN83Hqjt35HJmiMBIiIw0H4f8/SHYYWZjhqTIpaOFOJIBWohDQ0NDQ0MLcWhoaGhoaLzi0A5YQ0NDQ0MjGaAdsIaGhoaGRjJAO2ANDQ0NDY1kgHbAGhoaGhoayQDtgF8hxMSYi1/4+clJ3ImILl0iCgiQbbZvlzlzFgvEJCR4exOtWCHbHDlCtGWLbLNkCdHBg+ry6GiiESNkXq2vL9Fnn8lJxi9dQnJ1CRs3En3zjWwzYQI4kirYbETduoGzqUJwMFGzZjJH8uZNolq1ZH7u/v1ElSrJAi7z5hG1bq0uJyL6/nuiQYPU5cxErVrhWiqEhRFVq0a0d6/a5sYNourViW7dUtvs2kVUrx6up8JffxF9/LEsmjBkCNHIkepyIlxj1Sp1OTNR3bpEZ86obe7fJ2rZElxfFY4cIerenSgyUm2zfj04sdIzzZhh3ud+/pno1CnZZsAA9F8VwsPR5ySe+q1bRP/7n1zfU6fMOej798vvjgiceUmYhQgiJRKsViJ3d9kmIMAx0Y+kgnbArxCePCGaPl1u0Ldvo9FLuHAB4gwqWK0g0UsdIyICzkhSsbHZzFWj3NzkuhBBuOHQIXW5iwsEDCSyfrZsGLAlAYLChc1FDCpVMp8EVasmD14pUhCVKycrlmXIQJQ9uyyyUbQoBsC8edU2FSvi/bi4qG0qVZLvQ0RUqhRRrlzqcicnogIFiIoUUdukTUuUOjVR2bJqmyJF8F6k6xQqBMGOtGnVNhkzEpUoIQuQpExJVKGCupwI77dKFXW5kxPEaEqXVtu4ueE6efKobSIjIT6SOrXa5u5douLF5Wc6f56oZEl1OREU2AoUUJdHR+M6khjK9etwRJIAydGj6HNSfbdsMVefWrZMFtmwWIgWLJAXFffvE61cKQuH7Ntn7qTXrzdXRktSvDjtWIM56YQ4rFZzYQszcQFm5vBwc5vgYPO6BAbKNgEBzNHRso2ZOAYziP8SbDZz4YWgIIhxSLh40Vw84Nw5uZzZXLQiKspcEMHDg9nHR7YxE3hgdkw45OBB2SYggPnCBdnm+HGIIkgwu48jNjab+XPfvm3ero4fN+9Lx4/L5czmgiqRkWhXEm7dgrCNBEfa5tWrcjkzBDIkBAUxP3ki23h6mouCmAn5MJvfhxltT0JEhLnIhiPjnSPjptl9HIEW4kgGaCEODQ0NDQ0txKGhoaGhofGKQztgDQ0NDQ2NZIB2wBoaGhoaGskA7YA1NDQ0NDSSAdoBayjhSHieIzYS39gOs4TczHJuYiLQW6Qk40Tm/Gir1ZwHGBZmbuPra34vLy+Z5sUM2pSUaDwmBnxhifIUFAT+rfStvL2JHj5Ul1utoMlI+ZYjIog8POS6hIbiOtK3DA4GrURqE/7+qLPUtry9zZO0P3gg18ViAUdVuk9YGFFgoHyf0FD5vRCBrmPWD8LDzfucWT8hMr8PkXlfcqRf6xBfGdoBv0Lw8zNP9H76NNHx47LN3LkYwFSIiiLq318WBfD2hnCAhP37ifr2lW2mTCH69Vd1uc1G1LWrLFoRFAS+68mTapsbN8BjlRKwb9wo80+JiEaNguCECswQ/Pj+e7VNZCRRw4ZEM2eqbTw9id59VxatOH6cqFgxWXhl2TJcR+Jijh2LZ5JsevUi+u47dXmKFESNGhFNnqy2iY5GXdavV9vcuAGu68WLapstW4jKlJG5ob//jncsDfDffUf0+efqciKi5s1lURUicGo3blSXP3gADvDly2qbXbvA35UmZTNm4B1Ljq9fP/xIaNqUaPFi2ebdd4nOnVOX+/qCH+3np7Y5dgx9QRLIWLlSbjNERH/+SfTPP7LNqFEyh5+ZaPRoeUwLD8fYKLWZO3fAb35Z0A74FYLVSnTihNyg06UzJ5MXL44Or4KLC1H58vLgnyMHHJqkWFSlClZE0my6QwesilRIkYKod2+s4lTImBGDjnSdEiUwGHh5qW1atsTAI83c+/aVBQqcnIiGD5cFClKnhoPOlElt8847RJ98gn9VqFkToh/SpKFjRyhLSQIP3brhOhI6dSKqX19d7uRE9OGHGNxVyJgRqlEffKC2qVABkylJ/KJGDVwja1a1TdmyRF98AbENFYoVkycVdpuvv1aXp0qF7/Dhh2qbDBmIWrTApEEFZ2e088yZ1TaRkUTDhsnPFBODybOE9OmJ2rdXlwcE4BtIIiWXLhF17gyBGxXc3Yk+/RTvSLqO1B6IoHBXubK6PCgIOx6SUMzFi3huSZBm716inDnlieiBA/I1khwvTjvWYE46IQ5HYEbWZzYXIGB2jHRuJrwQEwOivAQzoj0zs6+vuY2Z8EJ0tLkQx/375s/kiNiBmfCCxWIubOHpyezlJduYCX4wM586ZW5jJiYRHMx85Ypsc/asuZiB2X0csbHZzJ/77l1mPz/Z5tw5877i7i6XM5t/69BQcyGZ27fNBWtu3TKvy9275jYPH8rlAQHmfdbs3TKbi/Qw491IsFrN25Qj45Qj450j42ZSQAtxJAO0EIeGhoaGhhbi0NDQ0NDQeMWhHbCGhoaGhkYy4LV0wLNmzaJChQpR6tSpqXLlynRYiEr6/PPPycnJKdHPu++++8xm8eLFhjaRUkidhoaGhobGC+C1c8CrV6+m/v3707Bhw+j8+fNUt25dat68OT1QcDWmT59O3t7ez34ePnxIWbJkoQ4dOsSzy5AhQzw7b29vSi2FlmpoaGhoaLwAXjsHPHXqVOrRowf17NmTSpUqRdOmTaN8+fLR7NmzDe0zZsxIuXLlevZz5swZCggIoO4JSK5OTk7x7HJJMe/JDLOwOTMCPZFjZH0puT0R6DwST5AIIgUSNYgI5RJvmQgJ0aUcvFYr+KdSEvfAQKJFi+T7XL4s51uOiUFy8A0b1DbBwbiGRPPy9iaaNUvOyXzrFtFvv8n80pMnwWOV3vHmzUTjx6u/OTP4kYouRERoC5MnE23apLZ5+BD3OXFCbXP5Mq5z9ara5vhx8HwfPVLbbN9ONG8eUUiI2mbpUqI1a2Ta2R9/EB05oi4PCgI/9/Zttc3du/jekqjK5ctEO3bIYhznzuHdSf33+HGZjkeE3NpSXYjAdZXog1ar3O6I8G7MxGYCA83Ho7Aw8zEtOlouJ3Js3HvlQo7/85jsJERUVBSnTJmSN2zYEO/3ffv25Xr16jl0jZYtW3Ljxo3j/W7RokWcMmVKzp8/P7/zzjvcokULPmeSFDYyMpKDgoKe/Tx8+PCFaUinTjFPmybbzJvHvGKFutxqZf7kE5nGERTEXKaMTP05d465UCE5J+jMmcz166vLbTbmzz5j7tlTbRMezly+PPOkSWqb+/eZs2Rh3rxZbXPgALOTE/P162qb6dNhI1EWevdmLlFCXW6zMb//PnPbtmqbyEjmwoWZhw5V2/j4MLu5MS9dqrY5dYqZSM5PvGQJniksTG0zZAjqI+HDD/Gjgs3GXKQI808/qW2Cg5mdnZmXLVPbnDuHZzp/Xm2zdClzmjQyzWXIEHwn6Vu2aiV/J2a8l2HD1OUREajv8uVqm3Pn8A3OnFHbLFvGnDGjnEN36FDm0qXl3LZt2zK3aSM/d8mSzKNGqcujo5lTpWLeskVtc/06s6urnIN782bmokXlPMeTJjF/9JFMAfryS7n/MzM3bSrniI6OZq5dm/npU7WNtzdz587ymHbiBPPUqXJdzPA8NKTXagXs5+dHVquVcubMGe/3OXPmJB8fH9O/9/b2ph07dlDPnj3j/b5kyZK0ePFi2rJlC61cuZJSp05NtWvXpluCCsWECRMoY8aMz37y5cv37x4qDsqVg9CGdPTcvj1mnqqZXIoUUIS5dEl9jQwZsPo6dEhtU7EiBCdOn1bbfPklCPSq2baTE1YP0qwzTRqitWuJpM+XPz/R8uVQqVGhfn0oPnl6qm369IEilLSynzSJqFAhdbmTE95dxoxqG1dXXEcS9MiZE/XJm1dtU7Uq0fvvExUtqrbp1ImoTh0iNze1zRdfQExCQufORA0aqMudnIjatoVylArp0xO99x5EKVQoV46oVi0IwahQvToEXKR3XL480bffor2rUKIE0eDB6nIiCHoMGKAuT50ailsff6y2yZCBqEcPWUzC2RltwmxjbckSWeQlfXqs/KXnLlmS6Kef1OUPHkDYRlJ8u3IFdZFEYG7dQt9Nl05tExCA/qISv7BY8J379FFf49EjiHnUrq22OXMGIiZSnztzBu9FEjq5dw994aXhxXz9y4WnpycTER87dize78eOHcslpGXL/2P8+PGcNWtWjjJhflutVi5fvjz36dNHafNfrIBfNpJK0MNMYCA83Pw6jpD6nzyRy202c2GLp0+xUpPgiCDCtWvmdTETtvDzMxcOkVaKdphs1jAzRDQkhIbKuwfMEBYxE0VwpC5mNjabuYjJ3bvYyZFw6ZJ5XRwRXTF7L4GBzI8fyzZ375r3gQcPzOtiJkZjs5mL2gQGmtfFrI8wyyt1O8zGBqvVfBx6WQIaSYU3VogjOjqa3NzcaO3atdS2bdtnv+/Xrx+5u7vTwYMHlX/LzFS8eHFq2bIl/f7776b36tWrFz169Ih27NjhUN20EIeGhoaGxhsrxOHi4kKVK1em3QkyFuzevZtq1aol/u3BgwfJw8ODevToYXofZiZ3d3fKnTv3C9VXQ0NDQ0NDBUFG+9XEwIEDqUuXLlSlShWqWbMmzZs3jx48eEBf/7+i+k8//USenp70vwShrAsWLKDq1atTGQPF9FGjRlGNGjWoWLFiFBwcTH/88Qe5u7vTTCmdjYaGhoaGxgvgtXPAnTp1oqdPn9Lo0aPJ29ubypQpQ9u3b6cCBQoQEQKtEnKCg4KCaP369TR9+nTDawYGBtKXX35JPj4+lDFjRqpYsSIdOnSIqpmlkNHQ0NDQ0PiXeK3OgF9l6DPgVwPMcroxs3Ii8EalKNOXbeNInZPK5k1CUrQF/e41nhdv7Bnw2wAz9cuYGCSWluDtLYsPEMkJ0e31OHBAtrl7V847TITcxVKybZsN4hh79qht/P1BFTlzRm1z9ixoMhINaelS5KtVEfZjYoiGDpVpNP7+oCl88YXa5vp1UHp+/lltc/AgaCszZqhtVq8GlUZKcD9+PGgnp04ZlzMjKf277xI9eWJsExUFqk29eup38/AhqGkJGHzxcPQoUenSEA9RYc0a5M1dvVptM3067iUlRh8wAPWVkrS3bUvUrp26v8TEIE/yoEFqqtzt26C/zJ+vvs+BA0SNGsn9ZfVqUJkkAZLZs5G/WKLkjR9P9Ouv8jjxww8QipGWVn37El27pi4PCQENURLsuX2baOVKdTkR0YUL6JsSLl6U+y0R3puZeJAk3GJHYKBczmw+BicltAN+hbBpk8yHI0Ln+vNPdXlMDJKH//232sbTE45I6oD79xO1bi1zZpctQ31VHT0mhmjKFFlhyc8PNgni6hLZLF8uc5sjIoi2bTPvhEePqtWTnJ2xSrlwQf33WbJAlUcaMIoVI3r6VH535cphAJP4u+++S3TzJtE776htihYlunGDqFQp43InJ6ICBaA2lCOHsY2rK54rY0Y1RzJvXjgy1TWIwM318JC5zUWLgmMaR4o9ETJnxnUkrrCzM/jw/3/yZIioKPB4Ve/YxQWT1axZ1avT7NmhVibxd11cMKGSYjaDg2GTJ4/a5to1TDKzZVPb7NsHZySp5C5dijaheqaAAEz8pMnAxYuYCJ0/r7bZvx/cW0mFbelSoiFDZOc5dCiUz1Rgxli0ebPaJjCQqEIFWbHs4kWMe1Jd1q83H4OTFP8pIeotwvNwv1Sw2Zj37ZM5eDExzOvWyWouQUHMK1fK97pzh3n9etnmwAHmPXvk+s6cyXzzptomKor5u+9k/qivL3PfvnJdzpxhHjNGtlmwgHntWtnmiy/k5OmRkcwJhNIS4cED5o8/lm127GAePVq2GTmS+Z9/ZJsWLWR1n+ho5rp15WvcuQMFIAlr1pgrAP3wg6xGxMzcvLnMz7VYmM1E627cYO7RQ7ZZtox57lzZpn9/cx5169Zyf7PZmBs1krmoFy8yDxwo32fhQubVq2Wb77835xx/9pmsPBUTg28t1dcRxb1Fi5gPHZJtJkww5y7//LOs0hYUxPz773J9r15l3r5dvs+hQ+ac7p07wb2XsGMHxoAXwRvLA36V8aaeASfFmSkztjZTCSF/4eHyapAIs9xMmWQbX195lRYejtVy1qxqmzt3iAoXlu9z8yZR8eKyzdWr2JJVISgIP/nzq20uXsRqWcKFC/JqkYjI3R0rBBUiIrDNLD3T5cvY7pa+oyN1MXsmZrw7aZV87x5Wp2nTqm2uXVPvDNjhyHf08JDVyPz9sXMgKXc9eECUL5/cl7y85BUykXn7joqCupT0XkJCoKglISJCVuQiwg6Xs7O6HCKe5mPDm3Y2/jy+QDvgJMKb6oA1NDQ0NByHDsLS0NDQ0NB4xaEdsIaGhoaGRjJAO2ANDQ0NDY1kgHbAGi8EM74xkWPJtCXKDhGCS4KC1OXMoJRI14mKQgCQxaK28fVVc2rtuHFD5jYyI3G6lNDcagVvVKKChIWBdnLzpvo+3t7gWt+/b2wTEwNqxsmTeDYjhIaCGnT+vPr9+fvjma9eVX/zx49B85IoWl5eoOMEB6ttPD2JjhyR+e43b+JbqtqWzYaAsHv31NzmkBB8Iz8/NZXuyRN8b6kuXl7gxEsJ4b288K0kPH5szlN98sScD+vvb5543qy/OcKHtVjM76MjjEzwYgHXGnYkBQ0pPFymyDAjxZ1Z6rNVq5BIXIWwMObx4+XQ/+vX5UTlNhsSp48YobYJCgIFSaIP3bzJXLUq8+zZapvNm5kzZVInELfZkMw8VSo17SQqChQZJyc1FcHXl7lUKeZ06dR1uXSJOVs25jJl5PqmSYOE8CpMm8acMiWoMir064c40hkz1DYffACbXbuMy2025uLFYXP3rrFNSAieOV06vCcjXL+Od1e+vLouW7bgPp06qW0mT2ZOkUJuN199hW/5v/+pbRo0YE6dGgnUVXjnHXwrVYrK4GA8U7ly6v5y9ixs2rdX95fVq/FMo0ap6zJ2LOq7Zo3aplcv5uzZQRNSoUkT5nffldNulirF3Lat+pmio3GfsWPVz3TvHnORIjJN7tAhUPbu31fbrF7NPHy4PB4tXKju23YsWmROM1q2DGk1VbDZzGl/UVHmqUbN8Dy+QK+AXyGsXUvUq5d61sgMAr2ksBQcDAL9vHlqmzt3kCRbUp86d47ojz/USkPMWFnNmqVehaROjVXrli3q++TKBbvjx9U2VapAnOHKFeNyJyckpnd1BZXGCC4uRL17o96qlXT27FCNklbIZcogObhE0WjZEhSa7NnVNj16gFJVsKDapndvPJtEpbErU1WsaFzu5ET06aegt6hEK9KlI2rWDCIFLi7GNiVKQGCkeXN1XRo2BC2lTRu1Tf36WJ1KCe6rVQMlrV07tU358njHklx7iRJIOq8SyEifHgIkX3yhFrbIlQttxv4tjJAxI97b55+r6+LqinpIKmtRUaCKVamitnnyhKhJE/Uz2ftlixbqZ7p3D32gTh31M50/jx0YqX0eOoT6SKIgmzaZ7zr98QdEPVQ7CGFhRD/9JO9M3bwJRbPr19U227bBRtplmD6daMwYx3b2kgQv5us17EiKFTAz88OH5mTxU6dksrjVipmetMINDsZKTYKHB/O2bbLNjh3Mx4+ry202CFI8eaK2CQ1l7t3bvC4//CDbbN4sr6SZIZggJYS3WJjr15ev4eMDAQcJ+/cz//ijbDN+PPPGjbJN69byaicmhrlWLfkad+/Kq1JmCJhMnizbDB5sLsTRrJksxBETY/5+r1zBKljCokVYOUn49lvmy5dlmxYtZKGImBjmpk3la5w4AcEJCdOno69I+OYbc2GLzp3VuxTMEG359lv5Gjt2YJdMwp9/4jtIGDuWOTBQXR4TwzxxIsYjFR49Yt6wQb7P2bPmq9/Dh5n9/WWbo0dlQSCbTR4bHIUW4kgGvM08YEfI9FarWuaQCOdNrq7ydYKCZLEDInOhguhonJFJ0oK3bxMVKSLf5/p1iFJIuHwZK2YVQkKwgpBEP9zdsdqT3sv58+oVsKM24eHYPShRQm3zsoQ4bDa8X0nE5M4drAKlnQhHhDhu3JCfmchciMPXF8IXkvjFw4cQ4pDg7S3LWRKhvUg7K2FhWI1LAhlhYXJdidBPVLshdpj16TdRZMMRaCGOZMDb7IA1NDQ0NAAtxKGhoaGhofGKQztgDQ0NDQ2NZIB2wBoaBtD8Rg0Njf8a2gG/gXDEOTgijiEJXxAhCENF+7Hj6VM5j6/NBtEFSdgiIIBowQIEJKlw7RroWSoaQlQU0a5dRF9/rRaK8PUFzevjj9UiBDduEH3/PVHXruq6HD+OawwcqLbZvh3UnzFjjMuZkQS+ZUvUSfVM48YRdeigTnDv44N8rF27guphhCtXkKC9d291juhDh0CRGzQI38MImzcTffYZEsaraBxLloBetGqVcTkRaCmffkq0c6dxOTNoKf36qakpAQFE/fsTjR2rFjK5dg3faO5ctUjJ4cNEgwcjwX1EhLHN33+jPidOqPveypVEv/wi58793/+Q61t1HyL0g7Vr5T4+dy6EV1RgJlq4UO674eFoo5IYh58f0a1b6nIiiIuYCXqYiY8QmYuPEL1E6lBS4sWDrjWYk4aGdOkS88GDss3s2TJR3GJh/uQTiEqocOUKc506aiqTzcb866/IM6uiMgUEML//PoQgVLhwgTljRjm366JFEG9Q0ThsNuavv4bNvHnGNmFhzDVrwkZF9Xj8mDl3btioKA137jCnTQsbFTXl9GkIM+TKpX6mTZtwjTp11DbTpsGme3e1TZ8+sJkwQW1jF+JQUTlsNuZixeTnDg2FcIirK8RgjHDtGq5RsqS6LvbnbttWbTNhAmyGDlXbdOsGm6VL1TbVq8PmzBnjcpsNbS91anVf8PbGNfLnhziFEQ4cgE39+uq+MHcubKR2/v335t/yww9hI1GESpfGt1IJkNhseOb8+UFpNIL9uevXV3/v48dh8+23sgAJEfOKFer6Tp6MviKNWQMGMLdrJ9PXevQANUpVF5uNuUsXmToVFYU+pfrWzKBxqcYZR6GFOF5TuLsTDRumlomzWEC/GDRIPQP28cFsUbWyIgL9JTKSaNEi43InJ4gc3L6NFYARMmaE+MWhQ7inEcqUwYpz2zb17PTjj4lat8YqWFWXceOIypZVSzu6uWH1kDmzelafIwfR8uXITapa2RcqRDRxIv5b9X6rVCH68kuZxvHhh0S1ahHlzKm26dULdBKJgtSvH55fojJ9+WVsvYzg5ETUpQtRtmxq2lTatBAXqVtXTeuxC3G0bKmuS8OGoKW0b6+2qV8f/376qdqmRg2iDBmIPvpIbVOxIkQ4Klc2LrcLmHTtqqbt5MyJ5x0yRE3bsefnHTdOTanJkgViJmPHquubOjVoVdKuCDN2Bzp2VNuEhmK1Xb26cXlwMPr2tGlEefMa29y6BRGSadPU3/vcOXzvoUPVz71/P1HjxhA7UWHTJrQHFa0vJgYr+lq18A6NcP8+VuMS/Wr3boyffn5qm5kzMaapxisiohEjsGPnyA5hkuDFfL2GHUklxBEdbU4o9/WVZ4vMzO7uMuncamXevVu+RkAA899/yzYXL5rLuy1ejNWwCtHREF6QZqbe3sxffinfZ98+iH5IGDmSeedOdbnVCpnDkBC1jZ8f83vvyfc5dAjCChJ+/ZV5+XLZpnVrrMxViIlhrlRJFl25c0delTJj1fXrr7LNwIHmOzTvvy+3zehoeWeAGXKiX38t28yZw7xkiWzTo4e5rGDjxrJMYkgIxDok7NnDPG6cbDN2LFbTEj7/3Fxm9qOPsMulwo0bkH6UsHSpWrrUjvHj1StoO0aOlEVBAgKYFyyQr3H5snoXw44TJ8zFiU6flsc7ZsipSoiJgcjOi+J5fIF2wEmEpHLAbyokNRx7udSZmdGhzSCpRjFj8FJpIttx+7Z6a84OleZ0XJw+LZcHB5sr/Jw8af7uJCUyOyTNZGY4GjPlo/PnzQc5s8GUGcpGEmJicBwj4cYN2XEym1+D2fyZmc0H7kePzNuLWZtjNnd4zOYOIjDQvL1Ik0s7zPois/l93lZoJaxkgBbi0NDQ0NDQQhwaGhoaGhqvOLQD1tDQ0NDQSAZoB6zxn0NKVE6E6E8p4bndJixMLrdY5OjFyEjcR+IL+vjARjqYuXrVPEry5En5GsxIXi8hKoro9GnZJiRE5lkTITLUw0O28fKSOapESGOn4gDb4eEh81iJwKWWvgGzeX2jotR8bjtCQ+X62lNTSm2PGTxVqQ3bbOYJ7i0Wcy5rVJR5XzFrm0RoE2Yw+0b2/mRmow8wXwzaAb9CSCoBDX9/udxmwyAowc9PLdxgx4EDoPaoEB5ONGoUSP8q3LoFGsOaNcblFgvR+vWg2WzfbmwTEQHxhzp1iPbuNbYJDobYxIcfqp2ary/RV18Rde4MupcR7t0DhahbN/VAd/kyaDb9+xuXE0Gso0ULoilT1DabNuHd/PWXcXlMDPKXdu4MKocRnjwhGj4c+Yf37TO2uXKF6LvvIMShcub79kFko18/tWjFqlWgMw0frh68//wT9KG5c43LiUCzqVFD/UxRUUSffIK8uLt3G9vcuYO8xG3bqkVeDh5EfuNu3Yju3jW2WbaMqF49vB8Vfe2330CTGzdO/dyDByMb0ooV6n7eowdspH7XogX6wpkzxuXMRFWrok2oRDICAohq1kS9Vc905w7udeiQui7nz+O9PHigtjl6FIIy0uTj6FF1rm87Ll0yF/Tw8TEfQ80m+kTmk6CkhHbArxCWLAGfVQVmcARVAykROl2ZMlilqTBhAniEjx8bl4eFge/ZubO60V+6BJvx49WNfvlyopEj1QOpxQJ1oG3b4MyNEBMDJahz55DGzghWK5SgTp5U84CtVigr7d0LZ2yE6GjUY8sW9TMFB0PxaPVqNRf4wQPwDf/5x7icCM8TFAQnoMKJE/hGqoHU2Rk2V66oB5Zs2fDMhw6BW2uE/Pkxudm+nahAAWObHDkwUB49quZjpkyJut68qU5Z6O+Pd3j/vnE5EZzh06fqQdvVFfe4ehUcXNUzHT4MpSzVM+XOjYnQuXPqVIHp06Ot372rToVps2Fi9vix/NxPnuC5VLxaDw+kJJRWpxcvYoKnuk9gICbXu3er0wnevo20kfPmqSf0585BOe6HH9QTzX37iGbNwhig2tFYvRpcddUEmwiT0GrV1Cp2zEQ9exI1aqRu51FR4KHbefxG8PPD5ESljEaEd9ep00tc2f/nMdlvCV6UhmSzQVmmVSvmW7eMbUJCmKdMAdcyONjYxsuLedAgXEfFDb15k7l9e6jCqHDiBHOFClD5UWHjRuasWZmPHTMut9lQX1dXKMwYISYG/McCBdT3CQ6G8tGHH6pt7t9nzplT5kAeOcKcMiXz+vVqG7uq0e3baptvvmHOkEFdbrMx16oFPrEKYWHM2bODW6vCrVuoy7JlapsNG2Aj8V1//hn1lShEH34I5TMVbDZ8o3791DZ+flAJk/i5+/ejvhJFaOpU1FelRsYM1aNq1dTlzMxly4JfrkJkJHOKFHIbP30a9T15Um0zbx7q++SJ2qZ3b+by5eVvUKMGnktC6tR4Pypcv45nkjj+K1cyZ8umHmeYmYcMYa5YUdYkaNaMuXNnNWXJaoUi17hx6rHIywv9QFL/2reP+d13wa1XYdo0tOHLl9U2ffrg594943KLhfnjj8GBfhE2qeYBJwOSkgcsCVIwo2GrHLAdfn7mfL9z52RSf0wM89at8jW8vDBxkLB7t3wdmw2TBokr6e/P3KaNfJ/jx+UBlxmDwaJFcl0aNpTFL/z8MDmRcOAA86efyjZjx0JQQkLz5rKzio5mLlFC5mRevy5LhjLDaY4ZI9t8+y3z3r2yTe3aMl87PJy5alX5GseOmX/H33+HwIuEzp3NhThq1VJLsjJDAKZVK/kaGzaYi5gMHowJoIS2bWXBCauVuWlT+VsfOmRelylTzLnjgwfLdYmKYh4xwrzdbdsm3+foUXP+8/Hj5mOiGVfbapUnSMxoB9J46Ci0A04GaCEOGY6Q9qUVDzMUwMyuI83q7fWQVLmYmT08MPBK2L9fLmc2Vxrz92c+dUq22bfPfPAxuw+zueP09zcXFzl2zLwuhw+b1+XoUbk8MhKTQwkXLpiLX5gJoTCbi4JYrVB7k3DrlnldzCYCzGh3EqKjzYVmHj+WVdGYIdZhBjORE6vV/D5vK7QQRzJAC3FoaGhoaGghDg0NDQ0NjVccr6UDnjVrFhUqVIhSp05NlStXpsOqlD1EdODAAXJyckr0cz1ByN369eupdOnS5OrqSqVLl6aNGzf+14+hoaGhofEW47VzwKtXr6b+/fvTsGHD6Pz581S3bl1q3rw5PZDIaER048YN8vb2fvZTrFixZ2XHjx+nTp06UZcuXejChQvUpUsX6tixI52Uslq/BYiJkcuZ1ZxQOywWNd2JCJQLX19ZZOP8edBAJGGAlStBIZAOVMaPN+c/9+mj5gDb0bGj/ExESNMm0UlsNvBLJQQEyCn5iPA8ffrINocOgfMpYe1avEMJM2ao01Pa8fPP5u/vm2/kd2OxII2lhEeP5JSbROD/qjjUduzcSbR1q2yzahXoTBLmz5efmxmcbTNhkN9/V/c7ZpTNm6e+hsUCqo70TJGRoCtJ3NuQEFCmJFGPgAD8SH0uKMhcpCQiwpz288YelP7nJ9JJjGrVqvHXCXKVlSxZkocMGWJov3//fiYiDhBCMzt27MjNmjWL97umTZvyxx9/7HC9kiIIKzjYPArv9m05+CEmxjw94K1bSG4tYf58JBFXISAAqdwGDFDbnDzJXLQo848/qm2WLEFE8S+/qG3mzmWuVw+RrypMn87csqVM2Rkzhvmzz9TpCC0WPM9336mDc8LCEF07fDioT0bw8wOlZ9IkdWDZvXugaEj1dXdnzpJFHUFuteLvy5ZVB2IFBDCPGsXcpImaLubhwdyzJygwquxMJ06AdtK/vzpl3tatzGXKIOm8im6zdClzxowyFWzcOOZ33lE/U0gI6lu9ujrL07VroNp99JE6QnbPHuZGjRDdrQq6W7oU6R7HjVMHJk2ZAorWihXqvjl0KJ5b9Q2Y8f5z51ZnaIqJQZR5hQpqKs29e6hv48bq73TqFHOpUswdO6oDsnbswDN98406wGz1auYcOUCLUn3vRYuYixWTgw1nz8azS0PnrFnMa9eqy5kRjW4WpGbG/GB+8ZSEb2wUdFRUFKdMmZI3bNgQ7/d9+/blevXqGf6N3QEXLFiQc+XKxe+99x7v27cvnk2+fPl4agJy3dSpUzl//vzKukRGRnJQUNCzn4cPH74wD7hrV5nH6uPDnCmTzFucMwe8RdWgHRWFXLZOTupI0+vXwe91cVFTBObOxTUyZmQODTV+np9+Ql0KFDAemGw28PKIQAcxgsUCOg8Rc6dO6mdq2hQ2P/xgbBMUBB4mETq8ETw9mXPlgo1q8L90CVxMIuYHD4xttm1DuZubekD+4w/YSFzWvn1h07272sb+3CpuqM3GXLCg/EyBgczOzrBRDT5nzqA8Vy51JPrixbBp1Ehd38GDYSPxn5s3h83ChWqbfPlgoxrYg4JQnjq1mk5z7BhsChdWO5B582Aj0bj694eNNBlt0gQ2Ut+1P5MqYj0sLPaZVFHVZ8/CJndu9aRi9WrYlCmjdsDjx8OmQQP1JPLLL2HTtq3aSTdrBpuePY3fsc2Gekh89/BwPE+mTGqWg7c3c/r0oBCqIvUvXsSYNnOmcTkz+ki2bOaOXMIb64A9PT2ZiPhoAh7DuHHjuHjx4oZ/c/36dZ43bx6fPXuWjx07xr1792YnJyc+GCezuLOzMy9PkBl9+fLl7OLioqzLL7/8wkSU6OffOmCrFdzRPn3Us/rISOZ16zBzvXHD2CY4mHnGDIh1qDqXjw94t02bqh3EjRtYUfbura7zgQMYvCQu64IFGDBUvEOrFc+cKpWa2xwaiiTuJUuq7/PwIZzDJ5+obY4cgUjB5Mlqm1mzMBhIydN79YKNamCy2cB1LV1afY2QEAwon3+utrlyBfeZMUNts2KFuVDEDz9g4JGoMk2aMFeurC63WiF08uWXaptHj1CXefPUNlu3wkai/4wezZw2rcxjb9MGKz1pN6hAAQz8Kjx9irrMmqW22bnT/P1OmGAuxNGhA1au0uqrUCG5PQQEoC5//KG22b0bYjOSaMWvv6KvqHZw7PWtXVv+BkWKYHxQPZOfH77jvHnq73TgAL6TRJObNg0reklko3dvTFgfPTIuj4nBBH7qVDVP/ckTTHZXrTKnlUl44x3wsQT7OGPHjuUSJUo4fJ2WLVtyqzjsemdnZ16xYkU8m2XLlrGrq6vyGkm9An5emG2jOCLW8fixOSfwwAE5OXdoKLarJZw7J29522wYFCTSflAQlIIkrvCJE3AkEkaNwgCvgtXKXLOmzFX19oZ6j4StW7GSk/Djj9imllCvniyaEBaGwVTi5549K6tyMcMJSbsvzHAO27fLNmXLyo4oMBCqRpLj3L1bXvUz4zhBcvTMmEBKIibMmCRJg+316+bfceFCbFFL6NlTdorMmGRK4hePH8MRSVz4VauYf/tNvs/AgeYc6c8+k7eE79+HkIz0HXftMue579hhPk6dPi3fx2Ix3zaOjDTXEEgqXvMb64D/zRa0EcaOHcsl4yyn/s0WdEJoIQ4ZjijMSLJ3zFix+PrKNmZqQxaLuTrPpUs4f5UgqWkxozMvWCDbPHqkPo+2Y80a89l4gs0bw7qYqZV5epqrI/3zj6waxcz8999yObO5Ew8KMhfrOHrUXOltzx7zupgJlISHq3ek7Dh3zvgYJi7M3i0ztvkl+PurV3h2eHiYOxJPT7ncZjOfmJsJsrzNeKOFOKpXr06VK1emWbNmPftd6dKlqXXr1jRhwgSHrtG+fXvy9/enff+f1aBTp04UEhJC2+Ok22nevDllypSJVpqFhv4/tBDHmwVmtWi+I+VEiHROYcIzMLNx5D4vy8aRa2hovO14Hl+gyKnx6mLgwIHUpUsXqlKlCtWsWZPmzZtHDx48oK//n7fw008/kaenJ/3v/9MKTZs2jQoWLEjvvvsuRUdH07Jly2j9+vW0fv36Z9fs168f1atXjyZOnEitW7emzZs30549e+jIkSPJ8owayQ8zR+OIIzJzvo7YOHKfl2Wjna+GRtLiteMBd+rUiaZNm0ajR4+mChUq0KFDh2j79u1U4P9zjnl7e8fjBEdHR9OgQYOoXLlyVLduXTpy5Aht27aNPopDsKxVqxatWrWKFi1aROXKlaPFixfT6tWrqXr16i/9+TQSwyx5OBGRu7s5V3DNGvMk47NnmydOnzrVPC/zb7+ZJ52fPl2+RkSEnJ6SCDxMVZ5kO7y8kKpRwt27cpo2InCOfXxkmytXzBPCX7hg/h3c3eXyyEhzTndQkJyrlggp6p48kW28vdUpLO3w9DTPV+vlZZ5r9skT83Zs9n6JzDn8RG8wt/Z1wn++If6W4FU6A3YkmEDKWMOMsy8pw4jFgoARKZPJ0aOgDUhndT/+iPNWKUDi/ffNzwTr1zc/z2vWzPxcsEkT5jgB8oaoW9c8ccG775pnecmeXQ5wi4hAgJWEa9cQnCZh2zY5OpwZPGqJi80MTqjZefP775ufZebLJ7cJO+1EwoULCFCTsH498xdfyDaTJiGYSMLXX5s/d7Nm5vEHpUur+bvM6FM5c8rnyUFBzHnyyDEVnp6g9qjGAZsNZ8VScFl0NJgQErUqOBi6BBKX3dMT59ZSxPW9ewiiksYtX1/zFIFmCSReFp7HF7x2K+A3GVevqhNOE2HGumCBPLu9cYOoXz959TVlCtGnn6pnwP7+RBUrEg0apL7Gvn1E1atD1UgFT0+idu2IevdW29SsSdSrF9GIEWqbPn2Ihg8nWrxYbfPtt0QzZxLt36+2ad8eik+XL6tt3nsPz3bvntqmUiWsKKXVYPHiUPAKCjIut1qREP7cOfWqyGbDaly1imPGqis0VK3CFBaGOkREIBG7Eby98c1DQtT3un4d6kk+PrA1wqlTWCneuqV+pgMHUN9bt9TPtGYNUfr0aqUmf3+izZtho3qm69fxHdOlw/MZ4ehRohMniNKmVa9wt23DN0qXTv1Mq1ZhVZ89u3E5EVTEAgNxLyOEhxP99BNRkSLqvnvrFtEPPxDVr6/eQTh4EP22WTN1/161Cn2qQQN1fWfNIvriC7RjFX77jahNG3nH6PffiWrVItq9W20zbRpRqVKyzdixqK+q7RERDR6M9yxh0iTs9qjATLRlizx+JilewoTgrcCLroAjIqAa1aaNena7bx94gN9+a1xus2HGT6TOCerpCf4eEVR+jLBqVazYhGpVuW4duLtEan7eunUQeEiVSh29vGIFOKoZM6rFEP76C9xGiQc8aRLqkkDQ7BmsVry3lCmhdGWE0FCsClxc1LSpu3exunB1Vb+bPXuwSnF1VT/3jBkQDpAC7fv0QX1btFDbvP8+BFFUamMWC1aTROqk5z4+uAaRetfjwAGUZ8igXrXPmAGbmjXV9bWLNyQQs4uHmjVlfq7VindHpE5/eOcOyl1c1IpQmzbFCsWo2t7o0bCR6G0dOpgLcZQqJQtxWCwod3JSc9AvXIBN+vRqQYpVq2LFRVR0sJEjYVO7tprWZxe/6dBB/W7s3+nbb413sKxWKJoRQZTHaIUbGMicLh34+aNHG9t4eGAccXVlXrnSuC5Hj+LdFSyojvJetw516dJFvdr+/XfYmKkJSnhjaUivMpJiC9rDA4OOippis4FXN2SIeps0Opp5yxaQzlVKV8HB2HKsXl3tIB4+RFL0qlXVE4LTpyHe0K2b+plWrMCAMX26cbld/pFIvYUXEoLOniKFesC4cwfqXeXKqeuyaxfu06uX2mbCBNhIFCL7gKuSbbRamUuUwKRC1dH9/DDJUU0YmEFdIcKAqcLs2bDZsUNt8/XXGJwkjmmNGpAMVCEqCt9R2sq+dg11kSRDly+XHSczJFBdXGRaWoMGcGrSNmuGDOCzqnDjhuP1lY4lBgyA6pnK0TOD41u6tNqZMcPBfPqputzugKX6zpuHfiIJyfTsia1uaVu4bFkctaj6W1AQJocDB6qPjw4cgBCHtH3/22/osxJf+JNPmHv0UCvPRUZCqWzqVPU2tacnxqkNG9QTSA8PSIYeP+5Y/nIVtANOBrxKZ8B2mHFvLRZZNIEZjVI6y7RYoIQl8QY9POQVDzMctORoAgPh7CVFon37zM9M+/aF5KcKUVFwnqrVIjNWiSlTyufoCxZg8iKhe3dMplSw2bDql2bjT54wp0kjn6nu3m1el3Hj5BUcM3ZnJD1emw3nu1J7efQIK05pgFu/HmpvEgYPlh0RM5yexOGNiYGWsSQEcfw4HJGEyZOxwpPQurU5/7lgQbV8JDNiJWrXlvv1lCnmZ/mtW8ua1FFRkIaVhrJt22RFOWbsIqkmqcxoL8uXy5ziiAi17KYdoaHyxMZ+r5cF7YCTAa+iA36VEBVlPqtUbavZ4ecnDxzM2EGQxCLCw6GGJWH3buwiSOjTR+7UkZFqXWo7zpyRHT0zVghmAXNmQUTR0ebO6uJFTGAkLFliLn5hpk7FbC5Q4uUlr+iZ8X2kFT0z6ms28P7vf3K5r6/5duSOHRCJkbBqlXld1q2Ty69fV0vQ2rF/v/nEW5rEMmPnwex5zIQ6mF9sFfk6440W4nhVoYU4Xg1gk07m10ZFEbm6ytcJDUXgjQrBwURmn9kRG7P7hIcTubnJ13DkeWJiiJyd1eXMCDJKJSgDWK1EKVPK90kK8RFHbF6m+AjRiwuUaBGTtwfP4wt0FLTGGwF7RLKTk/HAbbUiKpZIdlarV2OwlJzi+vXqaFY7du6Ur0GESGrJhlkdwWuHzWbOPyWSnS8R3pvkfInMnS9R0oiPOGLzMsVHkkKgRDtfDSNoB6zxn8HMMYSFgRIhwdeX6IMPZFpAcDCoQRKFK0UKos8/J3r8WL7f2LHmCeXHjiW6f1+26dcPdZfw4YcyhcNmA9VLwqNHoKVIOHiQqG1b2WbpUqJffpFtxo3DBEXCV1+BtiPhgw/kxPQ2G1HduvI17t0DlU7C4cNEQ4bINitWmFNXJk8m2rBBthk0iOjYMdmma1c1/cqODz8kevpUXc5M1KSJ3LdsNqLWrWW6os1G9OWXsiCKXSzGTNRDovXFvZZGYmgH/JrBTEmHyNzJ+PnJnSYsDM5DUhqaPRuDoIrnGhNDVLUq0cWL6s6XMiXRmDHghqqQIweeeeNGtU2GDESNG4Pjq4KTE1GLFuB1SqhVi+j4cdmmdGlwtiXkz2+uwpQtmzzYpkxpzkd0cTFX5SIyHwDDw80VwHx9ze91+7b5vdzdiVKnVpeHhGBiIcHHR353RJhImamoXblivjo9fdp8x2P/fpkHzEz0zz9EefOqbYKCiM6cIcqSRW1z4wa+g/T+jh/HpFTa9di9G/1X2vXYtQu7ParrMBMdOkT08cfqcSkqCmNA06bqduHlhb4iye5fv26uNubtLXN8ifBezNrny5wsaAf8CmHePFncwdOT6LPP5NXD7Nlo7KGhxuUhIVhVde6sHpwOHCCqUQOrJtWAmyULnF6bNsYzZGdnCH60a0c0cKBxB02dmmj+fKya/v5b3fDHjCH6+WfZoX35Jd6f5CBatQLJXupgNWuar2QcccD58hE9fCjbZMuGyZAEZ2f5mezlKkdttcLBMKtXOxERKEuZUu2Eg4Jwn1Sp1IPgkyexuxCqAdnHB/eTxEeuXSPKlAkTQSMEBsK5Zs+urot9UM+dW/3+7t+HTb586vrcvUvk4UFUuLC63Xh4wJkVLmxcHh0NR5UzJ1GaNMY2vr44tqhRQz0huH0bE8jGjY3LieDs1q0jiqO0mwhHj6Lf9eqlttmwAf1u+HC1zcSJRN99R/Tnn+rjiV694KAHDlQ/12ef4ZlUbZgZ96lQAe/ICDYbdrgaNUL7MILVStSpE8YJFaKjifr2xVj7UvCfh4S9JXjRKOgnT8CZK11azc2dOxchRnXqGKeoCwuDMAMRc9u2xlGIhw+DekEEaUEjnD/PnC0bbFQRtjduxJLsVfmA796NFSBQpal78IC5ShXwVFVJ2j09kXw9Wzb1u/H0RELz+vWNy5lBZ8iaVR2dbE/bV6wYRCWMEBgI0YtatUCXMcLVq8ytWuFbqJ5p2zbIVb7/vjqyeOpUcIm7dFE/U5cu4KCq6EwREWhTWbOCM2yEmzeZM2eGjYqfu2ED7pMtmzoqe/RoCCZUraqO+O3UCTxVSSKyZElwpFV5bYOCwBNOl04dLX3kCKhiWbOq5R9nzIBNmTLqyPlevVDfTp3U9a1ZExxeVXS9zYa+nS2bOur96lXUpXBhdSrMFStgU6uWOgJ8yBDUt2tXNTWnVSv0yQkT1M9UtCjesUqsJyICz5wunZoxYBdDSZtWLQF7+DBs0qRR6x+sXg0bNzeIpxjBLqCRNau6TQwaFDt+Gsl9Wq3MnTvDRqVb4Ai0FOVriGzZsHU8axbR2bPGNl9+iZnZV19heygh3NywtXT2LFGZMsbnVnXqYNa/di1WAEZbshUqYGvu55+xovbwSGxTvDjR1q2Qbhw92njlVKAA0dChRBkzEs2da/xMuXJB9pJZvT3s7IyVjp8fJP+M4O2NVc/Bg+qz4CNHsG25Z49xuZMTArVu3VJLHGbIgB2CY8fUgUIFCuBee/cSFSxobFO0KN6xj486EKtAAaw8pSjowoXxvKVKGZenTk1UsiSeu1EjY5tixYiyZsXz1KxpbNOwIb5xtWpYnRrhvfewG/LBB+rVTu3aWK1IZ9LVq+NenTsbl2fIgDpnyqReDVaogPvUrIn3aISyZbEqatdOHZhXogSuI503582L63Ttalzu5IT+7eaGHSMjZM6Ma5QsSVS+vLGNqyts3n8f38sIMTGo70cfqbeXfX3xDlWr5MhI7DCUKYMzaSOcOIFv1KULvrcRli1D254/H3U2wrhxOPY5dgxn2wkRGko0ahRkOu/exdl2Qly+jH67ahWOLpo1S2xz+jSOa06fxm6E0ZHCmTN4lkePsAp+Kfj3fl4jLl5XHrBK6caO0FA5Ob3Nhhnwrl1qmwcPIOWnWonYbCD1SxKGXl5YmapWRczMixdj9nrnjvo+jRtjNa2Cjw8Un8aMUdts3Yr7SO/lhx+wQyChbl15JRgRgRXwihVqm0uXUBcvL7XNokUQF5HQpw/UhiTUqiVzeKOisNqRxBcuXMAqRRJfmD8f30nCF18wDx8u25QqhZ0GFfz9sWKXxC/+/hsrconT+sMP5kkfatZkXrhQXR4ZidWt9O62bYOMrJR0oG9fCLxIKFKEefNmdfnFi+hrkrLXiBEQzpGUyD7+GLsrKjx4gD4rvdu7d8158BLvPzmghTiSAa+rA35ZsFrlDs0MRy4JPTx4YD7ofvedrH50/768Tc2MrbmZM9XlNhtzxYqyUtC9e8wtW8r3WbzYXLjiiy/U2rb2unToIF/D1xfKURJ27MDEQsK4cebiF5KyFzPawbBhss3Vq3KGHWY46du3ZZvhw81FKcwUrG7dMhcOmT/fXERm2DBztSYz4ZY9e9TbtHZMnGieNWjiRLn8yBE4PglmGa+io1+d7EQvG1qIIxmghTj+GyQU1oiISBzIcv8+tlgrVcIWnLc3opDjwt8f2ZQGDsT2WY0axvf7+WdQVy5cUG/HLlmCgBqjrS47Dh7EvxJF6PJlbK+XKKG2uXkT261SpO6jR3J0LRG2HXPkUJdHROAeUnStI8IiYWHmEcNmNvYsT6qAJSLHBEqSwsZiwbavxB1/WXUxavsJER2NrVYJjgiqaPx7aCEOjdcCJ0+aRwGPHRv//NhoALpzJzZ1orNzYudLhNR1v/6KgV3lfIkQJe3jo3a+RER//UWUJ49c76FDZVoKEaJDzcQ67GemKkRFmXN8797FOZqES5eI/vc/2ebIETndIxFoK0YxA3Exe7Y6St+OiRPl8vBwpLGTcP+++TOdOYNvrkKqVIjQP3xYbePmhme6eFG2GTVK5o+7uSF1pyrlnr3td+igjhC3O982bcB4MILd+X71lcy6ICJatMic2vPggTmFTcMY2gFr/CuYDaDLlsncXSIEM/XpI9t07ozBWOL/1a8PGoiUw9fZGbxkM4pRuXLyQEqEoB4zIY6sWc15qmnTqgdSO1KlksUSbDZzykRIiDq3rh137iB/sYSjR0ERkrBmjTkPfcYMmc8eGSlTRYiw6pccJxEmFUeOyDZHjoBjKmHHDlCsJKxZI38nIuzASBOumBgER6qC3IhQDzNe8v37eKb06dU2jx6B0iPtigQFEQ0bJtfHHvBl9p4nT8bOkwQp1++bCu2AXyEkhcjG/fsYeFSIjASPWHJE8+djy1IlhnD1KrZ7b99WDzo1akAN6uRJ9X2+/x6z63Xr1DZFiyKCUhVFTYTt6a5dzVc777+PyGQJjjpgM5GNrFnNV/eOOmAzJSIzIYmYGHOZSUf0pB3ZAnXExmwL2pGtbn9/RA5LePLEfBfCy8t8N+PBA+Ndlbi4fZuoSBF1eVgY3o0qepkIIhvFi8synNLxiR27d8tcYSJMGDp2lO+1YAEixKX3vGgR3p8qytlen/nz1ZH60dGYMFSqpF5t372L/vTnn+r7XLsGBoOkiOftbb5DoxIX+i+gHfArgqgodAh3d7XN1q2Q6FMpVNls2J5q0kQtp3j4MOgXbdqoV4xRUaCCNG5sbFO6NNGECeh0vXsby+sVLQpaQMeOkCY0WoGlShV7LiupLI0YAVEPqWPZHbC0XeuoA5YmMESOqVw5sgJ2czN3wM7O5nKBZrBYzLWgHXHAkZHyGTGz+TkmM76RakLAbO6AmTGJlBwDM9qUmTqVtzfEOiQbyQEzw7FGRoJup7K5cQMUIwnu7qBPSTh+3NwB79plTOmJW59Vq3AEYgSrFX1xxgxMoo0QHIzJy6hRRFOnGts8eYIjiR49IGFq9H78/NB3mzcnmjmTqFChxDYBAXieGjVQN6M2HxgIilKNGmqxDn9/XKdjR/Wk1tcXdLodO4zLkxraAb8iuHMHzrF+/dgAnoQ4dQor3Pr1jZWY7t1Dw/LxgfM0EvIvWRJbU0+eoMEabSV37Yogo+vXoVJj5ABat0ZD/esvogEDjOtbqxacZ61aRL/9ZmxTsiQ6eadO4AQaoWBByEhOnQoOnxEKF0Yg0qFD6q2ssmXx/gIC1LsNZctiBSztRti3oFXnXjZbrMqVSpXHzw+rwAcPMJgZwd0dK5QjR9SOdtMmfHPVgBEeTrRwIXZOVAPTlSsYIE+exPamETZuxJHBwoVqjevffsNKcNw49USob1/USfWtLRbw3X181DsaN2/i78+fV5/NbtmC7dwdO9Rb9L//jj4lbR8PHgxFs02bjMuJ4Mjc3Ii2bzcuv3sXMQopUqh57Dt2YNudWb3L9ddf4MqnTauu72+/YfyQAvt69UK7VK1I79yBoypfXs1jP3SIqEoVBCKqJicrVhC1b0/UoIG6PhMnou0VKKDW/+7bF6tWZqzIE+74WK04qrp1CxNEI953WBjGkMuX0V+MFhbe3qjrpUvgFb+U8OT/PCb7LUFS0ZCePGE+fVrNr4uKYj53DpQdlY2nJxR35swx5thZLFCgGTQIqk5GNn5+UIMpV06t8HPyZKyqjhGFxWZj/uMPcEOdnY3pNDYbOLdE4FsawWoFjYaI+csvjW38/Zk//5w5Z07mlSuNbS5cYK5WDc+kyne6fDkUd1Rcyuho5nbtwGUdP97Y5uZNcIDTpWM+dMjYZtMm5lSpYBMVZWwzYQKeuUkT43Jm5s8+kxXLmMF7JmI+eNC43M7fTZ1aTQO7eRPXqFJFfZ81a2DTu7faZsgQ2Pz1l9qmcWPYnD9vXG61MmfKhHdnpGgUt76VK6vvs3QpbHr1Utt89x1sVCpizFD+IlLT36KioPSWNq2axnXgAK5RurSaOjV6NGw6dlTXpWFDWeXKakV5ihRqStPOnbDJkUNNR7L3x2bN1FoCFStCTWvaNOOx6tEjtLk6ddTvbsMGKNxNnIix0QgzZoD/vH+/muq1YQP49I8eGZczg351/ry6PzoKzQNOBrzOPGApUbjNBsEJSTjh7FlwGFUN99495g8+UHMuY2IgBEGkTjh+7BgGsBo11PW0y8ipOLw+Phi4iYylPJnhGIngZFUYOBA2a9aoberUgbCCanCKjITIhiQ4cf067jNlitpm1SrYXLigthk6lDl7dpkT26IF5EtVsNmY8+VjnjRJbePri7ocOKC22bkTkzF/f7XNmDFwRFK7/OADWXDCZoO8puQ4r15Ffc+dU9vMnYs2o3L0zJgE1a2rLmdmzp9f5mJ7eKAu69apbWbOhENTCc0wMzdtCmlNVX8NDcV9vv9efY05c+AYT55U29SoAf65qs+7uzMXLy6/26lTmTdulL/z6dPmXG7p75MDz+MLTEIzNN4GSEE8Tk5qaTw7KlXCj2rLpkABnF/v3WucmDxVKqI//sD2744dCESxw56wvmZN0EE6dkycrP3CBXBl583Dtq1Rsoo7dxB4Nn480TffqM877fXIl0/9vMHBuH+ZMmqbUqWwzaw6D3V1JapXD2fOKpQogS16KaCmaVOct5ctK9v4+srcz8aN5fNSJydIWXbooLbJnh1SfnXqqG1q18bxhXR+W68e6iq1y1q15JSFTk6Qz/zkE7VN8eKIC6hYUW1TrhxRz55y0FjJkmiXEkqXRqyDCnnyoB4SpSxrVmzHStHNadIgYPH8eZwnJ+QEh4XhPuPGYas7W7bE7eLBA7AYqlUzvkd4OK4hJWGIjIQkrhT13a+fed7nKlXkcqLXO9eyPgPWSDKYOfJGjWJttm7FGVFc9OoVX3PX1xcDoD1rU8OGyFubMDp76lSc96VLh4hqo2CuFCkw6Hz5JQZ4Vcd3cYG+reSAU6ZEkFqxYmobqzX+RMIIISHmUboWi/xeM2VCfaS0e1WqmPM9K1UyDwhr21Z9pm1Ht24yZSdtWrQDiTdatap5JHXTpubP9NVXoE6pkDIlAoRUMRdEmGQVKwa+sAqtWuFMUaIzjR1LNGmScVwGEZ535ky0TVWAUPHiiLeQJn7ffotApBYtjM/hmdHvXF3Rzo3oQ1274qyVCCkCEwZZpUyJutqdb3Q06Epx71e9emLnm3CCbuZ83wboV6CR5DhyxDyK8N13iX78MXE0cbZssf+dIwcG65kzY3/XrFli59izJygTRFhpGHGLCxbErPzJE5ljWqgQomJbtlTbZM6Mconaky6drJRFhOeTnDgR0j6aRTD7+cnqR9HRjiVN37pVLr9+3Tyf8qpV5lzhCRNkXjezOmjPjlSpiObMkW0CA+XgKSLsjKgCz4jwHU+ckFNLliuHiZ80qahcGcFG0oqwbFkEbKm+d8WK+NZSm2nUCMFI+fMbR6znzIkVe2gogg1r1UpsEzdg6s8/MSGKC1fX+JPCOXPQjyWHGh6O3QZVAN/bCu2ANZ4LNhu2aSVKULZsRF9/LVN+ChUiGjmSqHt3mTr0889QPIrLzUu4IqxTBx3bTs+K68TjokED8wjRQoWwmpFWr2b8UyIMUmbc2xQpzCUBrVZzByzReogw2JrJQ4aEyFubRFghmyl3JQVXOCzMXLbRkfoGBMgiEkRwaKr2YoePDxyXBE9PWQ40Oho/Up3v3jWm4cTFzZvmOytnzphv3e7dCzaF1LYuXMB7lo4UAgOxsldFtdvx3Xc4ypKEP+7dw6RV2s0heknRyS8J2gG/QjDjjQYGyjxhIqw+pG23U6fQqY4fNy4/cABbU0+fGtfHZkNHqVNHzSMuWRLntd27ywo5X3wBxyCR6/PmBc1jyhS1jZMTthLtq2AVGjbE80koXFjNobYjc2bzrVgXFzWv+XngiIiGGRxxnPazdrPrmDlyRxxwTIw88IeHm9/HEbGOwEDzyZIjDvjxY6TNVIEZfSVLFrXNw4fysQYR2l3hwrLNrVvmuyanTydetSbEtm3YppYwezYm0tIRyPjx2LKWhEoWLMDkeNIktc2lS+if3bsbt5+gINALP/kEdCwjHD2KnRVp/PPwwCRccuJeXubHG0kF7YBfEdy+je2g9evVNmPHwvGptgHv3EGQS+PGRP/8Y2yzaxe2f5s1M75O7doIIKpYEQE3q1bFL0+VCmdCgwbhvGrPHqjhJES5cshH/MkncPpGvFonJyjkTJkib1sOGYJOLG1fde2Ksy3J6dWvb65lXKiQufZt5szGgV5x4eqaNPq4ZiIaFov5KtoRx/kyHbBRIN7z3ic42LEVsCMOWFKnIjJfAfv74xrSM92/r85LbIcjDtiRFbCZA2bG+NC8udomOJho82ZMxlW4dw9nxEOGqO9z/jzyha9ZY9yO9+zBJL1FCxwNdeqU2GbnTgS5Va6Msat798Q2J09iTHv3XWz1G+H8eYxvLVuqFzJnz+LdjR9vXJ7U0A74FcHjxxi0v/kG4hUJHZbFgpVrhgyIIjVaNaZPD8cXHY1E2kYN8YcfYBMcjECLXbvilzs7I5FA375wVp9/bqzh+sknWOV26YJZspF8Y5UqcODt20MxyyjJfc6cEETo2hX1NjobzJYNwVMTJqhnrjlzIvBDOscsUAD3UAXCEL16DthsBRweLqtTRURgdZY2rXpy4umJH1dXdQDV+fOxKwOVVN/+/Sg7f179nXbtgqM6dcq4PDISKxRnZ3VQ08OHEKJJmVItsnH1KupLpBY6uXwZz+vkpK7vzZvylmhkJAbzd95Ri7cEBKBNSQ44KippHLDFgvdWurTa5sIFRF2rAgDDwhAF/eGH6l0GLy+in37Cj5GN1Uo0fDgc6sKFeD8J8eQJHGunTlh4GEX7e3hgB2zXLowRw4Yl7g/nz8P5hoZiIjR2bOLrHDiACbifH/q40SRx3TrY2NXYzLS9kwQvgRb1ViApecDR0XLu0IgI8GVV+TajopCofe1a49ygVivztWtI1N6/P/LsJoS3N8rbt0dybiNC/q1byHmbIgVz2bLGibGjopCYm4i5a1f1M3XpAu7s6tXG5cHBELfo21fNC9y+nblRI3BjVejenXnWLDnfaZYsap4wM3jP772nrkdQELi7w4ercyCfOgUO8MiR6oTjs2ZB8OOXX9R1adeOOX165Oo1QmQkOMAZMzL/73/GNrdvx4ozeHgY22zfDpvcudXPPWkSbFq0UNe3UyfYDB2qtilUSOZZ2/nGROo8vFu3ojxbNjVXdfhw2DRsqK5L48bgcw8caFxutYJvnCED8jsb4dw5cNgLFlSLi8yYARGZDz5Qi6GMH497qYRmoqNRz6pV1YITe/eiz37/vTpv8Pffg/P9v/8Zc2ytVowJuXOr77NrF95tqVJq3nKPHrB5913mixcTlwcHY1ypVw9iHvfuJbbx94eg0Ny5uIZR24yOhnDRpUvGY5T9me7de3ERDmYtxJEseJ2FOMwQFWXspO148ABO4o8/jMtPn4ZQQYoUED8wun6HDuiMnToZX+PsWeZcuWBz7VricpstViCjTRvja9y+jYGDCEpgRli8GIN2o0bG5RYL80cfYSAcM8bY5sEDCBmkSoVnN8KePajHO++ohQRmzoRNhw7G5cyxSk2qiQsz8/vvQ8BB5ejtIhsqkRNmDIYpU2LCpsLZs6iLytEzM8+bZy4c8sUXULlSiZgwY2CX6vv0Ke7z3XdqG7uTXrRIbfPjj7C5dEltU7OmLNYRHo62X62a+hr//IP7SOIi9m8tqZ5lyACbvXuNy+3PXLCg2tG3aQOb0aONy+0CJjlzqt/Lxx8zp0kDx2jUvo8fx0RhwwZjJT5mTAZ9fIzLXmU8jy/QW9AapnBxkQNI8uVDRPO33xqXV6mCbcW1a7G1ZXT9hQuxVb1tm/E2dKVK2NIiQnKHhHBywvZ6njzqbdTChaFfTaQ+7yxSBNtUqnPVlCmxRRcQoN7my5cPW2FubmqRh7p1seVbpIj67NBOY5KSBTRqhC05Kdq3QQPUR7V17OQEG+k+6dND2KF2bbWNPcq1QQO5vu+8I3NZ69RBHIIUCV2lipx9KEuWWH1wFapXxz2k4KkqVRBgpMqtS4T3kj177JZ3QqRJA7GUa9fUHF+7LnNYmHo7vFgxtNu2bdXb3TlygCNtb+cJYW9r8+ap+4C3N1IMDhtmXH7iBNrKgQPG39G+5X72LI6OjNr3O+/g3LZtWzV9qUgR8+jz1x3aAWskGSQeoJMTOvXIkbEZceIiXToEagwdGktfiomJP6h9+y0oSXHz1lqtREuW4Jo5c+Icx+jMb8kSnFmPG4cB12jwuX4dKRLr1pXP0Ox0JyMOpR05c8IhqRy5iwvOBCtVUl+jcGFcR6KU2J2rNFA1bIj3LQVZ1a5tnq+1QgVZtCJlSgys0hl6oUIYoKW2UqWKOhWmHaVKmdvUrKl2ikSILahaVU7xWaUK7KTgvooV0f6kwLFmzTBRUgXU5cuH/nH4sHpCVqwY4i3atVNH6ebOTfTrrwiUNIoGTpEC7IPGjXGWbhS7kS0b+ov9GyV8di8vJGNQZXeKjIRzViV7IMLzvs4KVkmF19IBz5o1iwoVKkSpU6emypUr02FVShQi2rBhAzVu3JiyZ89OGTJkoJo1a9LOBGlhFi9eTE5OTol+IiW1AA1D3L6NAUDF7XV2Rsdr3z5xpLaTE4I66tXD/x88CGnDuJ+hX79YlR4iDBKLFsUmZ69Z03jmniMHBAOyZkWEo9FgWbw4nMd338kOuEQJODWJmlK8OCIyJRQtKq8EiTC4Syu0jBlRLq2Aq1bFICpFBJs9DxEmFKqUe3Zkz26e1lASDSHC85hFL1ev7piNWaR08eKyTYECmLhI7/eTTxAAJH2nfv3kcicnov795RX7u+9iRRkYqM5hPGAAJkpz5hgHPuXOTTR5Mv77t98QhZwQc+bETtbc3WMDk+z4/nu0XTuYEQltFyvJnds4MPDxY1ktzA6z/NdvEl47B7x69Wrq378/DRs2jM6fP09169al5s2b0wNFgtZDhw5R48aNafv27XT27Flq2LAhtWrVis7HXUYRUYYMGcjb2zveT2opvPQNhSSKERaG7UGJypMtG2be7dqpo0+JsBL96ivja9kHxEaNcL/Bg+OXx82H6uQEfuFPP8VGLRpRGRo3xmzf2xvKWUYRoClSYMWTPbusv1ygQPxJgBFy5gRtQkLevObUH2dnc6cXHm4uOOHsLK86AwPNZTFDQ825tzEx5g7WbOUTHe1YbmIzsY6ICMeoVZIDdnJCO5a+gZubea7kmBhzvnFMjOyA8+cHFa98efU7bNsWOzSursapBMuXx8QlKAi7RV98kdjGXgebDayMH36If7+EzzllCsQ/pCOMO3cwsVZFvxPBkS9ejEmntOMQFfXmOOnXzgFPnTqVevToQT179qRSpUrRtGnTKF++fDR79mxD+2nTptEPP/xAVatWpWLFitH48eOpWLFi9Pfff8ezc3Jyoly5csX7edkwE9k4elSdD5cIA8Xdu9hqNUJMDLaWIiKMt6csFmyJTpiAM6+IiPgNPW1alPXpo9b8zZgR/MHy5bEatW/XJkSpUli1dusmE+cnT8a2nCQpWK0aVgdGfGQ7UqUCnWH5cmyVqqg9tWtDpESijBQoYK6b7OZmTmOwWMydVVCQudMz48Q6Ijbx5Im5AzZzREQYHM2cpxkcuUZ4uLkDdoTbbKf2SQgKkic4jgidOPINHj2SHTAR4h+kYwsi9P8PP5RtFi7EJFJ6rsWLUd6mjdrGnsd49Wp1n7pwAWfS48aBSmQEHx/QK5csAZUwbr+IiYFzjooimjULW99GY8aJEziS2rpVfaxw7hwmAVL/9fCQx9mkxGvlgKOjo+ns2bPUpEmTeL9v0qQJHTt2zKFr2Gw2CgkJoSwJ9oNCQ0OpQIEClDdvXmrZsmWiFXJCREVFUXBwcLyfF8GuXTh7HDFCPbvr1w9bhaNGGQdh7NiBbbcPPzTmEoeEYMVZtCjOm/r1i2+TKhWSint7w0EOGYJOGncLuG5dNOJSpTAQ/PUXCPlxubUpUuCsd/x4rGLtE4KEs9ry5cH/69wZM2ij506dGlziPn2gN6sKPhk/Hvy/8HB1EEu3brHnxSrUri2rdxHBAd+/L9ukSWMuqRcd7ZgDlpyezYbVibS6TUoHbOaszJynIzKCjjrgpBAXcUTS0uy5zVSwiBz7Bo6oZTnqgFu1Mi6z2TDxmznTWDOdCGf0vr5Ev/wCvQGj1baHB7aTv/ySaONGYzGTixdxjNSyZWyQZVxERhJduYLYj6pVMVbs3Rt/5R4ZibFqzhw43pMniXbvjh/oZ7NhTGzZEkcKs2YlDjhkxu9r1kSQ2vz5ievLjPGsQgUcQ70MycvXygH7+fmR1WqlnAkiTnLmzEk+DmqHTZkyhcLCwqhjnPxhJUuWpMWLF9OWLVto5cqVlDp1aqpduzbdunVLeZ0JEyZQxowZn/3kM+s5JmDG1urhwzhjSRh1GRYGx1m+PFZxn36aeAX60UfYOs2WDbPNDz6ILyeZJQtmtf36oYP98QdmnXHvlScPfn/0KDqWvTPHnTG6uMA5HzoEm3r1cK+Ec5DWrdFZfvgBPwMGJH7uqlWhpvPRR9gOM3JsJUtCTefTT9WqO8WKQU2nTx/UyQhlymBg/+MPdaR0tWqYDEgO1u6ApQ7q5ibrZRM55oDNBn9HnKIjztXMxmYzX43bbLHOU/VubDZz5S5HHLAjetGOOGCz3QObDc8iTXDsSlgSHHXA0grY39/cAc+fD+eoSiX46BFRkyZwVCrd6a1bMZHv0kUdaT54MJzgrFnGsQ537mAs6toVO2IJo7KZ4bybN4cQz549EP+J+55DQ9Gnt26FY/znH0yg454/h4XhyGnkSIx17dphERFXrCQ4GJN8eyrHChUSb71HRGCMmjYNMR5Fi+L+/zleAi0qyeDp6clExMeOHYv3+7Fjx3KJEiVM/37FihXs5ubGu3fvFu2sViuXL1+e+/Tpo7SJjIzkoKCgZz8PHz58pXjAFgvzkyf4SQibDWIGp05BrGPXrsQ2/v4QQhg+nPnDD5F03OjR3N0h8kAE0QIjIvvFixCLIGLesSNxeXg47kHE3LOn8fPs2MHs5oZk7k+fJi6PyyXu29f4Ghcvgu9KxHzlirHN3Lmoa/nyxuVWK/OIERAhUCWn9/Zm/vln5l69jDnLzBBaadMGyetVPEhmCHGohC8sFgiyVKig5hJ7ezNPnoz3qhIF2b8fPO1OnYzFDpjxXvLkgWiFij86fDjeXceO6voMHAhRil9/NS4PC2P+5BMIMGzdamxz4QLEPlq2NBZwYEZ7qVGD+dtv1fznDRvQHpYsUdd33TrmvHnV9wkMZP7rL3DDVe/X1xdCKRMmQBTCCFu3or6//64W2GnfHu1//Hjjcmb0xTRpmJcuNS4/fBjtP2tWtejK55/DpmVLY0Ga+/fBa3Z2xrMboVUrXKNSJWYvr8TlU6fGiqmsWJG43N8f/PWqVcELnz7d+L0cPIgx7Phx5ocPjQWMQkPRZlXfOKnxxgpxREVFccqUKXnDhg3xft+3b1+uV6+e+LerVq3iNGnS8FZVr06Anj17crNmzRyu25ssxGGHqgGHhkIpacAA5t9+S2zn7w8lm1Kl4Lj8/BJf49w55gYNIPZgpG5ktUL4IkUK5jlzjOtx+zZz/vwQRlDhhx/Q6Y8eNS5/+BCOvnp19TX698c1fv/duDwoiNnVFTaqgXvGDAyCFSqoVbdGj8Zgqnpem425XDkod6lEUAICUA8nJ0y4jHDrFmxy5VLX9+RJ2Hz4oXE5M8RAiJgHD1bbfPUVbObOVdtUrAib48eNy4ODIXLi7KyeDBw8iGsUKaK+z/jxsOnYUW3TpAlsJk40Lo+JQXtJkYJ52zZjm2PHIISSNSvaqBEWLsR96tRR1+WLL2SRDWY44AYN1JO6Zcvw3g4eNC632dCHundXq/ENG4Z2qxJT+ftv5hIlIGpjNOHYv5+5eXMovXl6Gl8jNFQ98XzV8cYKcbi4uFDlypVp9+7d8X6/e/duqiWQMleuXEmff/45rVixglqYpQAhImYmd3d3yi2F9b2FUEVepk2LrSR7koaEdpkzY9v7yhUEaxixxipWJNq3DwkcEiaAIMLW1PDh2Krat8+4HoULg38YEKA+Rx87Fue8Ki3nvHmRp1gKTunTB89YtqxxeYYM2JLPnl1NRapXD1tmxYurkxcEBGBrTLVd7uSEZ/b3V9OmMmXCFn66dOpt4SJFcDyROze0ho1QsSLqKXFv338f/9avr7YpVw7/SkFCtWsjHkG1jZo+PZ5Xxecmwt86O8v8aDvdTaIz1a6N96xqD6lS4Rglc2b1vew84VKl1PSh8uXxr+pclgjfp1EjtcgGEbbl//pLvWX+4AGCpuzPnhB37uCoZ8EC46AqqzVWRMP+LY3qeeUKYi6MeM+1a2ObuHdv9ftIm9b8qOKNwH8/H0harFq1ip2dnXnBggV89epV7t+/P6dNm5bv/f/e2ZAhQ7hLly7P7FesWMGpUqXimTNnsre397OfwMDAZzYjR47kf/75h2/fvs3nz5/n7t27c6pUqfjkyZMO1+ttWAG/LJjNfB8/lm3u3k0sYRd3Vf7wIfPOnYn/LjQUW/ZhYVgpG8HTE1rTrVurZfIsFuaSJdWymvb6pEzJvGCB2mbjRnklyIztZTc3bAuq0K0bto8lmw8+YK5SRb0CZsY29SefqMuZsQJTbWMzM585AxlPCStWQA5UQteu2J6UUKIEc+/e6vLISEg3zpunttm7F3Kha9eqbYYMYS5TBt9LhSpVsKW6bJlxeUQEc4ECaA+qlfTMmdiJePhQra9sl9W02Yx3rIykYONC0kDXcAxv7AqYiKhTp040bdo0Gj16NFWoUIEOHTpE27dvpwL/zxvx9vaOxwmeO3cuWSwW+vbbbyl37tzPfvr16/fMJjAwkL788ksqVaoUNWnShDw9PenQoUNUTTUF13hhSNmE7DPfixcRvJIQOXLE2nh5QVAgLgoWTLwaadcuNuVh3rzGPN8FC7BCdnOLlb1MCCcnlI0apU4unjIlnq9pU+Ny+3UyZYrPaU6IOnWw2pM2YurUwcpUCiRq0AABX9JqcPhwrI7iBrgkRJs25sFcefLIPN+MGdWrHjvKlze/T5Uq5un93ntPFhdxdUWwkbTbUb06riHVp2ZNfAOpPs2bIyhPJbySOjXR9OlgBah2RDp2xMp+2jQ1La9bN/y7fz8ieRMirjpVTAzRjBnxuf9G95ayh2m8IF7ChOCtwJu+ArZacSZ544ZsN3kyROMlEfWQEGS8+eMPOQBp3jzm0qXlRBARERC5X7hQrteSJVjlSXjyBGfUZhlRChdGcJOEmjVlAX9mrOAuX5ZtihaVnz8qCmfAquAeZryjrFnl+/j74+xPwtSpaoF+O8qXl1fanp7IfiPh2jU50QIz86ZNWNlLGDMG7VFCx47GgYFxUaOGOmiPGe++YEHj4EA7goOxqlcFWDHjzDV7dnkVarUicEx1dmpHvXqIy5Dw88/IQibB3R33k3Y1YmKQ3UraSWDGzpWU+MKO4GB1YovXAW/0CvhNRWAgeLwStmzBGanqLM/bGyvCefOMFa0uXADPLiYG9KCESptjxhB99hnOZ+xnqPbzx5gYzI5btsRZ35o1xmo1X32FFUPlylhVGSUASJcONKcdO6CRq8rp2qsXtKEbNADn0Oi5U6fGqmHkSBDsVe/ms89AvUqY/zgusmXDakYlZGJHnTqyeAgRVkN2aT4VMmc2F/RwcZHPwlxc8K1VGsNEWI2rVut23LplnujdEb6rGdKkMadnxcTIz0OEs3HVStGOsDDHuMJmNC4/P3kFnCIF2rl0lhwUhPYlqWVduAAKjPRchw+DciftIhw4gPdjT+aREFFROMNdtsw4rzgRqInXruGsfvFi49V9SAjGm0aNIAD08cfxy202jBFhYdhZqlgRfSJuH7WL1TCD1vj552iHcXXJ49IbHz7E+Na+ffy+Y7ViTCMCRVAl47BnD8YJiWJ07hzR3Lnq8qSEdsCvCNasQeBOq1bg8SVEZCS2l9q1gxO8cyexzZ9/guP21VfYfktIYw4IgLJUvnyQY6xSJX5moYEDce05c9DhvvkGwh+rV2O7btAgOMKhQ5HZqHBhSEDeuQNusl36b9gwbB/HxCAI6bffQMi/dCn2XrlzI/PRRx9hG3b1atQ/oQP99FPwdps0wb9GIhl582Iw+fhj1M1IwjtFCgSJff+9etAhIureHaIBCeL84qFOHdRDEvEvWBACJRLSpjXnGlqtsgOOiVErENnh42Ou82yW6J3IMb6rGRzhR1ssL88BOyLE4e8vTzy8vc233i9fVgftEeE7HjwoB7CdO4d+9sknaps//iD6+WeIaKjq07s3xpIFC4xFXsLDweH/4AOMBUZBX4cPY0u8Zk1wbJcvj/8ebTaMMaNHI2Du8WM4xREjYuu1axfGqnHj0PZ+/hnjjYcHJvkxMdCVb9cO/P9y5VB++TKubefQnzuHMaR7d1ynadPEgZ4PHxJ16ICjpxYtwEFOiMePY8fFAQNkKd0kw0tYkb8VeNEt6I0bwbXt3RtbQ76+8csjI8HPa94cnMMePYx5fKNGYYuvXDnmWrWYjSjPJ0+CxkGEf0eOTLyF6eeHxNx2rl6PHom3hby9wW8sVAj5WytWTLxV9egRqCdp02Ib1N09cX1u3gTvk0hNuZk/H+XlyxsHYHl7Y0uXiHn5cuNr/P03eKpp0hhv2dpsePcS3SYqCrlO06VT52W9fx9bmzVqGHOsmUH9ad8e9BYjWpb9XkWL4tlUFLCnT/H+JWzfzty5s2wzYgSoYhI6djQOXosLsy1om808COvkSdB/JMyciW1PCT16gMcroUIFBO2pEBUlB4SFhSFQSzrecHdn/vpr5p9+UnOSZ8wAZapPH3Ue5K++Ap2sXz/10U2lSmi/Ko66jw+ukSaNOthr0iRco3hx4+MPPz9wo4lAyUvYNq3WWMpUrlzM168nLh85EvUgQs7lhNTDM2fwbexj1G+/4fgr7r0iI8E9t1P+nJyQZzshzp8HL7laNRxpdemS+P09fYpguk8+Acf8gw+MNRQcwRvLA36V8bqdAVutcEIRETiTNeL8nT4NMY6FC3Feu3GjsSP4+29E2aZKhcFq37745deuMVeujKjfLFmQuD0ugoIwuGTJAo5iAp0VZsY1GzZER5s50/iZVqxAYvS6dY3LY2IwySHCsxnh3j04CImPaR+gZswwLrdamYsVg40q6vTQIZSnS6fmWw4axJw6NQYEI9hs4Gvmzs38v/8Z29y+jUndJ5+ohRc8PRGxLZ0Z7tkDbvScOerz5hMnwPVesUI9YbBY8I1UTiYyEt+6RQv1WWhUFM52x4xROyJ/f0yUtm1Tn+nv34+z21271PX9+msknl+1yrg8KAiR1O+8w7xli7GNnUOdPr16sjV3LmykM9lPPwXf+MgR43KLBY61Xj31+509Gw5LdRYbHIyJcpMmxjEMNhsmp8WLY/KdcLJltaIvlyuHCdCcOfEFSiwWCJK0bQtxmB9/TMxPDw/H+16yBPX86y9jbYCEzx4eLp+xvyxoB5wMeN0c8H8BqxWzxuvXjQe08HAM0itXGjud6GgMhqNGqQffI0fgTFSz04cPocilCpqxWpm//FJe7W3bJgcKRUZitaJSG2KGc3ZxUTsrqxWriObN1dfYtAmD8qhRapu2bWGzebNxeVAQylOkUAdzjRmDQfn999XOyr4DUbu2ui6//w6b995T23z3HSZqKvGLmBgE/aRPrw7qOXECK6sCBRJP5uLWN00aONjISGOboUNR3w4d1PW1K7Ql0P6Jh/z5mXPkUA/+Pj64xrBh6mssX45nNlKNsqN1azkI7tYtTHSlIah7d/Xkk5l5/XpMxFQTkvv3QYtTlUdEvN4BVEkB7YCTAdoBv1xIUb9WK7a+VbDZ1EpAdvz5p1y+cSNW/iqEhGAlImHQIPVWof0azs5qxSFmTCSyZJEjt4sXV6+imbHaIJJ5y5cvw0aaMHh4wEZyEmvWwGbcOLVNmzbYTlQ5o5gYrDpz5VI7AntdJOe6cydsNm1S24wbhxWw1N4++ID5l1/U5VYroptVq19mrJ7NIrZHj5b571euJD66igubTY7U1kga6ChojTceUpBOihTGycjtcHJSKwHZ8c03cnnr1lD0USFdOgR9qRATg4CShg3VNilTEtWqJQfv1KqF6FspqUPlygjwUaFYMQTjSAnFSpWKVctSoUgR1EN6piZN8P7tqllGaNAA11Hdy66SZc8EZYTChcF7FvKpPHt3a9aobapVQzDSzJlqmypVEJWrescpUiD4MWNGRCAboWxZWQWLCIFIUkBe6dJytLaT04tHsWskLbQD1ngrYBZ5SwQaiJ1apZLy278fP05OatrJ8eOQ3qxcWX2vR48QQS5ltrHZkE9Ziq4tXRoUNgnNm8vRy8WKIdpcipROkQJCHJKYBxEcgFEieDvc3BBRL72b2rXN8w5XqoQE9So4OeE6JUuqbdKlQxS+lKWoalU8j4oqR4Rvffo0mAEqdOmCqF9VPtyCBTHpuH8fUqhGsE86bTZE6Zuly1M5e41XB9oBayQpHAndDwxEyj8zzJplTMmKiy1bQC1SaT8TgepToQLoCxL++INo0iTZxmIBX1pCsWIyX5sIzuPRI9m5urmZD6IpUpinNKxfX+a6pk+PFb0ZV7hwYVk1isi83MkJzyVRp7JlM6dN1ahhnrz+vffkFTsRdkqkCUPGjOCPS7sQWbKAwyrtqjg5YaWtytNrx/TpMp+YCDS5adNkm2vXMEmRclLHxGASaJbb+v59Y9qj0fU0ng/aAb8iuH4duS7txPSEsNmQpGDOHPWg7OWFnzFjjB3hmTPYkrPZIF5x+3ZsGTP+bv168FftzuP4cXBRjxzBoNe/P+oR14YoVlryiy+w6hg8GIOS/XniSko+fAiRjapVMZiEh0PkIWEO5NSpsVU5cCCu7+6e+JkaNcK1338fz2YkkJEuHbYQW7VC3VWDyaRJIPnPmqXm+L7/Pt7xqlXGMplEcCBZs2JVpOL5pkyJ1eLjx2pH7eQEB2u1GpcT4W8lJ06E92omNhEWZu6AzcQmiFBfaeLh5GRe34gIc/6ulCDBjuBg8xX7gweyAyYCf10lIWmH5IBtNnyDf/5RO+DoaPBZV60CN9YIERFES5dCdGbmTOP3GByM7e5WrcC/V0lLzp0Lvqynp/E7unABfX74cOwkXLmS2GbbNvTvLVtiecNxERAQy/1/8AB179Ejtv9ZLPEFN5jRtw4ejOX7R0QkFs+JicGkIG7f8vHBWEKE9x03D3rcv1u2DEIlqnGWGd/JbCKeZHgJZ9JvBV40COuXXxAQUqgQoj8TBtXcvw/KChGiRGfPThzd+dFHCMghwr+//ho/InHcOHB1s2WLpQ19/TUClmJiQDXq1g0RwDlyIJq4ZMlYofkLFxBd2qMHbHLnRmTmhAngvA4bhgjM27eRv7NRIwSwfPIJokk//xz0EGYEhJw4gd/lzo1gmXffTUw3CA4G1++dd2BnlH/UZgONI3NmRMbGybMRz2b4cLybr74y/gZ+fogEJlJHON+4gfdBBK6iEY4exXtzc1NLcu7aBcpOnTrqKN0jR/Dc8+cblzNDlP+dd9S5aK1WRK2aZdacMweUEAk9eyKISkK5cjIP2GpF25Rw7hwoZxIWLQIHVUK/frL0YUgIUvedO6e2OXsWAVRSZO+QIYiKVwWNhYWhPVSqpM4PffMmKGdVq6rlXnftQrurVUsdZDhlCmxatTJO1WizIc8vERKOGAWxXbuGZ06XDu/Y3mftiIoCXzl1aoxFrVohkM0eqGa1os1my4ao+cKFkRjjq6/AgPDxAZWwUCH0pQ4dwPnNkgV2LVsiMv/HH0GJKlIEgXlVqiDwLnt28M2PHQNVqnt3MA6yZ8ffZ84cv70HB+O92HOBZ8uGaPG4iI4Glc+uR+DqqqbtmUFHQScDXtQBr1uHqNiZM0EDMMrmM3gwGtsvv4Cba8QxXbkSTqRbNzicDRsSd7LAQDjicuXQUL/9FvSduAgNhcCA3elnzowBOG4UZWAghD5GjowV9siRA5MDO80oKAiDdqZMKM+dOzFl5skTOCMi2CUUe7DZUEc72d7IOZ46BcoJEUQnjMQBlizBhMDFJfHz2rFoEZ7l00+Ny5kxsEvUn5gYvFsidH4j3LoFapCUr3b6dFxDEnn44ANcp18/4/LgYAwqBQuquaxnz2IQ/OortfP084NwyK5dat5yWBgGxmvX1NHJFy6gLakiu8PDMZGrUcOYD86MQbdNG1CwVHSz5cvRpjp2VItfDBgAgZhu3dT1ff998NcHDTIuZ8YEiEidDenp09hJsUrD+Z9/YNO4sTrietCg2Chzo/pGR8PJZMmCdmxks3gxrlGqFCb6CW3sEzonJ4wRCbXKHz3CBMAu0JMw9/P164j+t5eXLRv/mb28MIYVK4b3misXxjsPj9h25eUF0ZKmTVGeKxd46Ddvxqcn+vmB+tarFxx9oUKJxTqYMVGeOROThsaNMS4mhK8v89atcNS9eqE/qLjUZtAOOBnwJtKQgoIgTKFaodlx5w5mj9u2QXTAwyP+3/j6Ip1b3J+4jjwiAg5082asxEaPTsxZtVgw8M6bhw5itGqxWOC8O3VSr9QCAzGr//579fPs3o0BQiXyEBOD1f3s2eprHDmCAUjlrJjRySVaz+PHmAxMmKC2sTtpleIWM1ZVTk7qScetW7hGxozqQeePP8CrLV1aTXn6+WfY1KyprkvnzrhXnz5qG/tk7J9/jMuDgjDpSJNGzXk9fNickzxjBmwkTnj37qCCSckISpVCe1A5cS8v3EdS5Zo5E5M2afioXBkOVIUVKzBxVO2GeHtj92rfPuO6Wq2x6RATrnrtuHIF/dDbW6a+xcSgr9l314wQHQ2HaZYC0cfHMYENm808lenLgHbAyYA30QG/zjDrsB4e6gGTGYOMJIrw9ClW1BJUW912nDplvo3asiWciQoeHhBwkAbDQYNkR2SXh/zmG7XN2bPmjvPoUeNVUVysXAkbSdKyTx/zDE/ly8u5iUND4aRVq35mKGFlyKDepWDG7o7Zd6xdW86WdOcOjlok/P67eoLEjDoaycrGhbT1zyy3d42kw/P4AhMZdw2N1xNS1hkicFYlmAXdZMkCaomEiRPl8qpVEREswR6spkKRIghSkyKh69UDXUkFJyfco1cvtU25cgiMsuebNUL16ggsa9lSbdOsGQK5pKQDjRohME/ietepI0cUp00LPnHbtmqbd9+F+L6UjKFoUWTokfDTT/L7zZAB0c0SvvlG/obp0+O9SJBoWUTmwW8aLx/aAWto/EuYDWhmXFYiOAEJrVqZ30fFG7WjTh01r9mOL76QxUtSpYIzkyYMduGQokXVNpkyIWuV9Ez168emrVPZdexoPomaNk124tmzE/3wg3yNDh3MaV4tWsjljmSQMruHxpsJTUPS0PgPYCaSYLEYUyXiwtMTNDAJV68iX6uEK1eQptEMI0bI5blyEe3bJ9v4+8tpGomINm1S00CIsGIcNkx20tWrI7+shIIFZSEOIqyU27dXl7u4gL4ybpx8HWakwDP77kapMjXeXmgHrPFaIy4nWjX4xcRA0MPOx1Rh1So4vSdP1DZTp0IJy4iTbMe8echjmjAnaVysX4+co1evqm3u3kUi87iJxxMiJAQOTUJUlLlTjIoy37ZnNs/Ba7OZr+YiI+V7hYWZ5+h98AB5rSVcvmycSD4ujh6VedZWK5K4nzyptgkMBG/1++/VNg8f4ltXqaK+35Mn4Mh26aJWbouMxLOvWROr2pYQNhs4uP7+anEMZnkSpPFyoB3wK4LDh0Gc9/U1LrdaQZ4fORId0AgBARCj+PZbYwfh7Y0BmxlJ6VevjnVgFgs6v79//AHi998xuPj5gfyu6tQzZ4K8v2oViO43b8Z3duvWoZyIaPt2OJaNG2FntYJ8f+BArH1EBM4uhw/HqsvTE+8n4b2HDkVS8L/+wgB48WLiutkTfH/3HbZ0jQY3qxWE/+rVifr2NXi5hIGNGUm9Z89W23h4oF7LlxvbMBOdOkW0YgXer8pm82a0i59+Ut9ryxaoHqnqExpKdPYsvtupU8Y2AQEQcHB1hdiGEaxWfJM0adQTHWY4BckBx8TIW8tWK9ph1qxqRxUYCJGTggXVTujmTaKtW6FgpXJm+/YRzZ8Pp6gSTFmyBMnta9RQq0r99RecZtu2aoe3dClR3bpqKUoiohkzYqUvVVv9P/+M9jdjhnGdbTac5X/1Fc7tjcYBPz8IZ6xbR/TJJ7hWQuzbhxiGW7eIVq7EM8bF/fvYMfHzw3fy8cG97N/j9m1MVnfvTnztyEj09ZEjMaapEBiIMaJfP7RfFaKiiHbsgPiPpBz34AHRlCmy9ndwML75kCFqmyTFSwgKeyvwolHQdm6pszPymN65E7/80iVEbNq5sM2bQ8giLqpXjxXiIAJxfdGi2ND8tm3BE8yUCfxHOzexb19EsFaqBC5dliyxohaZM8Mue/bYFHDZsuH32bODZF+hAv7bzhcuXRocwrx58f/Fi+Pv7CIC48YhmX2XLrhnlixI6UYEDuGePaizuzt4eR98EHv90qWZDxyIfWabDXzRzz9HeZo0xrlx/fzwbPaMPkZRw2vWgJuo4vjabIh8Tp8e/GgjoQNmUJDc3MBlVWHfPtyne3e1zezZsJEy7dgTn8+da1xus8XmJlblq334EO0udWrQyIywahXEW8qUUdNcxo3Dt2zbVk3h+uwz3GvAAPUzFS+OdzxlinF5aCi+U/r06qTyFy7gmdOmVUcHb9gAm4IF1VSY336DTZMm6mf66ivYfPmlOtK4bt1Y8Quj64SGQnTCnqDeyObQodgk9nPmJC63WkHRs/eD8+cT2+zfj+9IhPFi1ar41LNz5/Cs9rGoYkVcc8UK0Ik2bUL/cXLCT44cqHfJkui78+fHilnYRYMKFUL/z5cPY0euXLHlGTNiDClXDtHkTZtCtOfdd2O1BVKlYi5aFG2vShWI1zRqBB2Eb7+N1SpInRrfMn9+8H3t2LsX1Li49yxTJv57efgQ41Hq1LBxcZEj2yVoGlIy4EUd8ObNGHAOHVKr7kyahBymGzeqlXAOHEBD+vNPDKZGHF6bDZ3qq69iBT0SdnirNVYZ6rPP4AwuXoxvFx0NOs6dO+jMH30EXur587FO32oFZ7BhQzjf774D1zDuBMNiAX+xQgUM3gMGJHYE06fDob33Hqg5CZ3JwYNwwi1boi5Tp8ava0gIBuuffsJg+NlnxvzE27dx/1Kl1AIOd+5gsDBS5bJj714MNqpBmxkTHykBe1QUBhPpPnbqj7u72mbwYAwokppTyZIYJFUOxNMT96lfX32NzZth8913apsxY2CzfLnapl07DO4SraZwYZmrHRCA+3z9tfoau3eb5/odPRoORqKkvfce1KBUfNfAQCgrSbzxP//E5FJFObMLqvTqZazAZrOhbduFJrZsSZwz+/hx9LNevdDGZ82K/72fPEE/GzIEfalDh/h8fZsNnPGVK8Gjb9DAWCzF0xN9/KOP0Hb9/cFvDgmBs4+KgqP//nvw+p8+xbe+fBmLij17Yse4P/7ABPz+ffy/hwfsTp/G2Ga1Yqz4+Wc4b29vvKuEfPbHj1Hvnj3xro3aeUQExpFRo8CX/recYu2AkwFvIg/YUd6g1SrbvioE+biIjJQFAIKDme/eVZfbRT8kbNsmO5GwMHR2CfPmySIbNhuENiTBj6NH468IjNCnjyxOwgwnPWuWujwoCKuV/fvVNseOYZUhcW8nT8YqTMKHH0JIQwWbDY4zoaBLXBw/jvtIbfenn+R8wcxwVNLkZudO9UrdXtdVq2Qu9/37xhKrdlit8mQvufA2co+fxxc4MZvF7Wk4guDgYMqYMSMFBQVRBjPle423BmbJEswCkmJicBYm5Xk9fVrmClutSJX38cdqm7//hih/tWpqm/79cbYtJW1o3x6xBaq8tTExOJ+0C+cb4ehRZIrq1EltM3ky0ddfI9GGCrNmyXmdb93Cu5EipS9exFmqCsw4n5SoRlarnMdX483C8/gC7YCTCNoBa7zKMJsIRERgIiDZeHkR5ckj3+f+ffPI48eP5SxFdqqONDExm7gQacenkTx4Hl+ghTg0NN4CmIl5mNGLiMydL5G58yUyTxFo5lgdtdHOV+NVh6YhaWhoJBlCQmRerd3GEaESCXZKmARHRC9UNKbnqQuReV00NIygHbBGksBsIPuvByhHrq/ietrh5we+sQRPT+Pk5HFhs+FcVkJ4ePxk5Ebw9sbZrQoxMbjPpElqZ/P0KbiPffqon+38eaJ27cCRvnXL2GbnTpwzf/SRWtRj3TrwZX/8Ud0e5s4lKlUKMpGqbzZ2LFbbKh41EdGgQZC83L5dbdOvH7i30nseMgR60Cr+LhH4sJMny2182TLwZaV2eO4czscleHubt52wMHMVNel5XhaYjevBjL744AEESt5q/McBYW8NXjQKetMmRKEeOmQcMWyxIGL2q6+Qt9IogjcqChGo9vB/Ve7RmBiE2Q8ahAhNo2vZbAjdf+89cJQ3bEhMa7DZEM16+zboP5UrM/fuDe7x7duwsVpBCfnhB1CRhg1D/k97ujObDeH/ixcjsnX6dNAMIiORxtDPD7bHjuEef/0Vn4d69CiiWS9dQl3//DM+dYIZtI05c5BDtlev2LrFRXg48t1myAAuoyp6s107cF1PnTIuZ47N5qPKbmOxgOudJo06sjUmBu8jRQp1OkirFZQrKe2h1QpKlbOzOrtQeDg4tZkyqaPVb9zAfYoXNy5nZl6/HjZNm6ptJk6ETe/eaps+fWAzZozapmNH2EhR2Q0bwmb+fLVNhQqwmTTJuNxmA+XJycmYX86MaHZ7Dl1VCkVPT9ikSKHul2fOwOadd0D5M6rLsmUo79vXuA3euRNLRzp4MHE+34cPEVnfti2octHRsdHToaHgsE+fzty1K6g9CZ9h2jR8n+bNQUOKG/0dFob+XbMm+Ljp0qEO9r5ktYKvbtcWsH9jX9/Ez7l7N/Ovv2KcqlfPmPfMjL/dsQO6Au3aIR+xym7jRox5Eyca28TEgNI0YQL4+RKzQIKmISUDXtQB9++PBpkiBTpHQiGOixfji2zUrJlYiKN8+fgk93feQWezd7D33kPjz5YtVojDxQWO59Yt8BDt4hmZM4OwnyZNrGBHmTK4RqVKsYIeefPi/0uUgF369OCuFiwIGkiWLPjvwoVjr1OsGMjw9vvkzBmb1Nwu1jF2LAb7okXxt3YhDyJc948/0EEGDWJu1oy5WrVY4r6LC8QM7IPDmTOwy5kT5SlTIgl7XAcZGQkHbb/H++8n/gYhIaCcZM6MwcWIbhMdjUGmYkWIBaioIdeuYfBXCWgwg3qSJw942iqcOweOqYT58yFsIKFbN+bWrWWbokXlxPR+fnBCixapbewCJEYiEXZMm4aJkIqHzQwBkgoVZHpb5crIP6yaTEVFYWIyYoT6GidOoL1Mnqy+zpgxaA/DhxvXOSwMAhJubmhjcYVk7Fi1Krav5cmTmL526lR8MYnWreNPJJ88wTuxC3WkTw9usn3SYLWiHeTLF3uNnDkhpFG3LmwuXYKwRfr0KE+XDn2tdGn0ex8fOOgWLVCeKRP6c7ly6BfDh2MyvHAh7pM1KyZ/uXKhjw4bhknayZPgGadNi9zdBQqgbXXpAq60uzueZ9y4WAGeHDkwRjRsiEXI4sWYuM+ejfvbBYrs9Y0rXnPiBPqi/d24uSWm5Xl5oQ+4uMSKkBhN1B2BdsDJgBd1wHv3Qm3Gz09tM28euI9ScvCzZyHWcfKkzAscM4Z56dL4KzAvLzgZ+99ZLOg0hw9j4NyyBY359m2sfOMOSH//jc55+jTI8k+fxh8cd+5EQvLISHSchAPnwYMQIlHxNi9exMz+8GHjmamXF1bZGzaAjJ8Q4eFYHW/ejGsl5KHabMw3b2Kld/MmflRiJzYb7nfokPod22z4BhKXODKSefVqdTkzFJ0kXi0zBj4JEREYWCX88w9y0kro3x/PLKFGDdlxBgVhsiTh77/xrSX06yfnSWbGKk3qjhcuYNdJ4qpOmiTfJzAQg33CVVxc7NmDXR9VjurQUPSPy5dxPaP6BAai31+4gG+gqpOnJ9r4mDHGSm02G/rosGHGgh7M+Lv58zEpiI7GNc+cic9TdnePndzfvYv2M21abPuIiIDwhf16hw/HrqztE73z52N3ZTw9MT4MHIiJRrZs2PUKD2eeOROT0KAg1GPFCuwExH2mY8egRBYYiH5rxL+/f595/HiIhKg41wEBcO79+v17DrPmAScDNA1J47+CGYUoKgo6zhL8/IiyZVOXWyw4jytUSG1z7hw4sakE7sShQ9DwlnD4MM5mVbh7F1mKJL7xpUvQeZZw9678PP7+yE0svVszbWuN/wZRUfgur+O71zzgZIB2wBoaGhoaz+MLdBS0hoaGhoZGMuC1dMCzZs2iQoUKUerUqaly5cp0WEq8SkQHDx6kypUrU+rUqalw4cI0Z86cRDbr16+n0qVLk6urK5UuXZo2btz4X1VfQ0NDQ0Pj+Rzww1eAtLV69Wrq378/DRs2jM6fP09169al5s2b0wNFkty7d+/SBx98QHXr1qXz58/T0KFDqW/fvrR+/fpnNsePH6dOnTpRly5d6MKFC9SlSxfq2LEjnZSycGtoaGhoaLwAnusMOG3atDRw4EAaMmQIpU2b9r+slxLVq1enSpUq0ew4GchLlSpFbdq0oQkTJiSy//HHH2nLli107dq1Z7/7+uuv6cKFC3T8+HEiIurUqRMFBwfTjh07ntk0a9aMMmfOTCtXrnSoXq/TGbBZUI8dwcEIhjGT9Hv4kOjCBaLcuSGgkCNH4r85eRLiATlyILFAjhzx5Q8fPAA5P3t2oixZEv+9Pam6KlG5xpsFR9qoI1rPMTFEzs6yjSNBbI5oTztiYxeneNWCi2w2ojNnUC83N/T7DBmI0qePtdm/H4F4GTLgJ3fu+AF3t24RDRyIgL7s2YkKF0byjrjPGhGBxB8pU+L3zs5EZcoQ5c378p71v8Zz+YLnCa8+evQoV6tWjXPnzs0LFy78FwHaL4aoqChOmTIlb0iQwLNv375cr149w7+pW7cu9+3bN97vNmzYwKlSpeLo/4+Bz5cvH0+dOjWezdSpUzl//vzKukRGRnJQUNCzn4cPH74QDWnpUnXeXWbQdnr2RAj/+PGgBSWk0litIKzb8+4uXAi6QNxwepsNdIbSpcF17dcPlIOESdYDAvB7Z2fwcZs3B40gLgUoKAj0oUmTYjm4qVPH5+A+eQIKRvfusfzDokWZ165FXWw2UI+mT48tT5MGZHk7RcFqBY3BxQXcxMKFQYmJ+/z+/siX+u674Pz17h2fRmSzITdso0bgS44cCQ5twm/w4Yfgus6bB2pDwnf31VfIpbp8OShLRjSk//0PlIybNxOX2XH8OPOaNTLZ/+ZNY85oXDx8mDh3ckKcOyfnC2ZGurxLl2SbP/5QCx3Y0bevnAKQGUIxEt3OZoP4gtSVnj5FYnYjqo0dN24kFotIiEOHwC2VKCdLl0LwRKKujBsHPqqRsEpMDPpr377MRYok5pc+fQrhiUmTwFtu1y5+u4iORl8eMgQ0nsaN0X7i4tgxtN0GDUAF++GH+M/09ClyAdsFV4oVA6834TUKFozthwmFRywW9Bs7n/bTTxNf49EjjD9E0AZYuDDx+z9+HGOAnW+7Zk1isZlHj8AtLloUfOUSJWLFe+yw2UBdGjAAwiy1axtz0O/cAW3pl1+YP/kE4h4J+21YGOo1bx6ERjp1ktOVSvjPecBLlizhvHnzcoUKFXi/GUkxCeHp6clExEePHo33+3HjxnFxhURPsWLFeNy4cfF+d/ToUSYi9vr/LNvOzs68PEGG8OXLl7OLi4uyLr/88gsTUaKff+uAf/4ZDbJgQfx3wkHs9u1YIYlcueDkEg7wdesyFyoUS8T/9tv4g+qAASDOFyoEnl2KFBDhOHIEjXniRCRcz5ULRPrGjeH0ypZFR9qxA+o0HTuiY+TJA1L+iBEQ6ejRA4pev/8OpafChSHK0b49BqhcucBjtivXfPghrlGqFEjw2bOjU9+9C77f4MEYULJlg5BB3rwYOOzOOzwcjr18edjkyYMO3adP/IFh7NhY4RAiiGRs3hx/gDp0COIgRBAIGDDA2JHYhQxq1cIAZcTt/PJL1PWbb9QOa+lSdPIlS9RcYnd3DBoS7/vBA/AaJc63vz+4tRLu3jXn1a5dm3gQTIjffzfnT44fL5c/fgxOuIT168H5VsFmAx9+3Tr1u7l3D+1u6lTj/MQ2G75x69ZwfEb8Zi8vTMqqVEH7Tcj7ttnAh23RAhPLFCnAw42LgAC8t2LF0LYyZIDwR1w8fow26eqKa+TKheeLi0uXMCmxi2Q0bIj+av8eNhvaXaZMzLlzo41+/TU4vPbJRWAgnFTevOiXFStiXIjbBvftQ98eMADiGM2bY0IaFobyqCj0waVLIbiRKxf6xKlTsXUJDcUkuU4djAM5c6Lvb9wY6/giIjBuuLlBrCNbNiwaRo+Ofc9RUeAJ584dK9JTvjzUAu2IjISCXvHisRP8Hj3iv7uICIxx5cvHLiSknNUSXooQR3h4OI8YMYLd3Ny4TZs2fOvWrX97KYdhd8DHjh2L9/uxY8dyiRIlDP+mWLFiPD5Bjz9y5AgTEXv/v2KDs7Mzr1ixIp7NsmXL2FWQGErqFfC5cxBckAbSFSvgOFSSgszohHPnGq8MgoNjBTDmzk08sB87hnrYZ6yhoRi4bTZ0nrZtQfDftg0DT1x4eqLzNGkCYYgtW+ILYoSFxa5ovvwSg/CePbErBpsNIgN2HDoEmcFTp2Jnxzt2xH92+wzYwwPvbf16Y+GLBw8wyO3YgQmCkYOwWJivXMHzJZSyjIvly81Xij4+r2cicrM6O5Lw3RH5Pqn92svN6mJ2H/vuysuG9I7Cw9EGE+42xf3bXbtkec0HDyAeYhfmSAibDavACxewojOS4Xz0CPd5/BiTt5YtE8umnjgR2yd/+gkO96+/Yst9fVEeEwMH/umncKIDBsR/HmbUdc4cTFLKlcNOin0ssO9SBQdD+KNDB6hexV19P3iA+kZFQXp2/PjEUp1hYcy//YbreXgYi/FYLBgvFi1S72bYbNh1UkmTOoKX4oDDwsL48OHD3L9/f06RIgW7urrywIEDOfjfThscwKu0BZ0QL6qEpaGhofGqwmZTa5LbERJifhxy/jyOxxJO4OMiLEyeBL/qeB5f8FxR0HPmzKEePXpQuXLlKGPGjNSoUSM6evQoffvttzRr1ixyd3en0qVL05kzZ57nsg7DxcWFKleuTLt37473+927d1OtWrUM/6ZmzZqJ7Hft2kVVqlQh5/+PzlDZqK6poaGh8TbByck8UC1dOqJq1WSbChWI/vwTAVwquLkhEPOtwPN49rx583L79u158uTJfOTIEY40mBKNGzeO3zVTfn8BrFq1ip2dnXnBggV89epV7t+/P6dNm5bv/f9+zJAhQ7hLly7P7O/cucNubm48YMAAvnr1Ki9YsICdnZ153bp1z2yOHj3KKVOm5F9//ZWvXbvGv/76K6dKlYpPJMx2IECvgDU0NDQ0kjUZg4+PD6dIkSKpLxsPM2fO5AIFCrCLiwtXqlSJDx48+KysW7duXL9+/Xj2Bw4c4IoVK7KLiwsXLFiQZ8+eneiaa9eu5RIlSrCzszOXLFmS169f/1x10g5YQ0NDQyNZkzEwMx06dIjq16+flJd95fE68YA1NDTeHDjCmX70CMk4VDzlwECivXuJatYEl9/oHgsWgLdbtSpRyZJEKRIcYIaHE504QVS8ONE77zimNfAm4nl8gZDX5N/BycnprXO+LwOOimc4YhcZiY4kiRgwE128iHOfdOnwkzZtYlEDi4Vo6lSioKDY3336KVHp0vHtDh8m+vprorAwCB8MGED0/fexdbh/n2jYMGSoCQrCWdHEibgvEUQ6Fi4kevyYyNcXwgFjxsQOFjYbMuQ8eABhkIcPiTp2JKpYMX49wsKIbt7ET4YMRM2bGz/7o0dEV68Svf++OvvPkyf4N3t29XsMCYkvZmAEmy3xYKbxZiAyEt9WEt44dowoUyY4LqO29vAh0eLFROXLE1WpkthBMhONGoU2XaMGnGj58vHvabMhk1W2bES1axO99178tp8pEzJmvfMOUYECKP/9d6KMGVHu5ETUpg36w8WLOKPdsSP+ma+bG5G3N1HTphg3KlUiWraMKH/++PW9c4dozhzUJVcuopw5iRo0iH/GbLMReXrid3F/3jin/l8vx98WvOgW9MKFEIn47jtwZRNGCUZHgwNXrRrI+sOHI6l7XFgs4J4WLAhO8CefIM9oXNhsoBGlSgVeXalS4JrGPc632Zhv3YpNvE0ECkHCCMebN8HXtPPr8uUDJSEuLl1C7tGiRcG/y5cvfk5Zmw3Ugq++AvfOyQm84rg0E4sFdS5cGPepXDkxBSMyEgnIicBdXro08TueOzf2eZo2TUzVun4dNKqsWVGXXbvil0dFgQr21Vd4b82bJ6Yz2Gygco0eDUGE7dsT14MZAiUzZoCPqCL8R0SA+hGX05gQMTGgVUhiEzExEEyREBkp5y5mBvUkYR7nhDhwwNxm3z65PDpazq/LjLp6eKipRhYL3tuhQ2rK0uXL4JCuWWMcdRsVBQ7s8OH4VleuJLY5fJj5gw8g7jJqVGK+dVQUuMZFiqC9DBiQWLzi7l20bVdX8G6N+M1r1jCnTIm2++GHiSOSY2LAK7dzWBNyjZnRp+182X79jN/L77/H6hEk5Mozo92WLYs+0qABaIIJ8c8/4NKnS4f2bSRIs28fxh87Lz8hDYoZ7yFr1tg+u2RJYpuzZ8F3LlUK77hr18R19vGBcE/bttA5eO+9xJzu0FA8+3ffQSimUyc1VckMyXoG/LbiRR3w7NlwPq1bxwpjxEVICEjvROjIRqIJXbqgIRKB4J5QI2XFCogFVKiAhl26NAYp+73OngWfL29e8PU6dYLdvHkY0OwD+aBBUKZ5912o80yZAqdkf3QPD4hflCkDYvuECVCjmTcvVsjhzh04qWLFIGoxZw4EEeI6vQcPMDkoUIC5WTMIlHTvHl/8wssLv8+bF+IfefOCzxwXT57AJk8ecAy7dEnMRQ0MhON3c8OPkZMIDUXnJYLqjl14IC6uXsXfE+F5jBAaylyyJOyuXjW2sdkwYFSsKHNehw3DYCph4UIM4BI2bcJ3k7Brlzm3dvt2cwe8ebNczgxlKAn2AVOCuzveoQo2G/Off4K/qlLU8vdH2yMCN9YIBw9C4IYI10sIqxV9hgjtb9OmxDaenuiPKVJgIplQpY0Z3zBNGowDAwcmVhOLjsbzvvceJrqzZyduO1eugGvbqRP6744die8zbhw4xLVr41oJVdR8fTEZ37gR403HjnDucXHyJCZjf/4JZ/7xx/F5/syYRFeqBDGQfPnw3Fu3xm8/Xl4Y77Jnh6hPnTq4Ztx26OODccv+fsuWTezQvb2hJOjkhImBEc/30SOIg6RKhQnRv+WRawecDHhRB3z/vrnM38aNxh0zLi5dUg+UgYGxTmPjxsSd88YNiFk8eYL/9/SMvzL47jus0qdPjy+nZ3dm27czV62KFfHPPxuvGAIDITNYuDBs4nbcuHUeMQIdbsSI2NVuRER8m0uXMBgNHx5L6L9/P/E9mzbFRMHHh3nvXmOxhIULMUhu3Bh/hR4X3t6wadnSWBXJ/gw//ojOLnXggweNZfPiwt/fXELSZlPXJS4cEdF4E+HIIGok2hAXFgtEIqR3aN8x8vRU20yZgpW0akfjyRPseCxfDgUpI+zZg4nuiBFwbAknDlFReJ7bt+FkS5dOvFNmXz0fPYodtWbNjCeCNhucfpEiWMkavaeYGOws5c8P5T0jkZGoKPSvEiXQd+JOkMPDIcIRE4O+16wZbBLW459/8P6PHcP4Y4Tdu+Hkb91STwLd3ZkXL5a/5e3bjk0SVUjWIKy3FW9DEJbZ+fLly0TR0Th3VdkxIzFDtWryuaePD86IVOev9mtFRTkmgJ+UZ0dmovuhoTh/MxPcT+p6aSQvoqPNv3lSnveHh5snJzlxgqhsWcRvqOqzciVR1qxEzZoZ20RGEv3xB9GNGwjEMkJYGNG0aSi/eDE2diMurFaiDRuItm9HPIeq7TuS1OJVxvP4Au2AkwhvgwPW0NDQkPC6O8+kwPP4Ah17qaGhoaGRJHjbne/zQjtgDQ0NjVcYZnuUAQHIsyth507k91bh4kWimTNxLRVOncLRkEbSQTtgjZeChw+Jdu0imjUL/N/Fi+MPLDYb+IGbNhGNHk303XdET58mvo6PD9H69UQ//IAzKSM8ekQ0bx7up8KFC0RLl6oHN4sF9wkLU1/DxwcDlwR3d7k8KgrcSQl2vrGEkBC53GyAJkKieDNYrXL5m3SgZfYszHL7ICLy8EBMgAqRkTgPDQxU26xYgT7h5WVc7uZG9MEHRAMHqvtEmjRIet+zJxxpwmcrV47o+HFwjD/9lOjgwcTXyJMH8R0NGqAfGzljf3+idevUddVIgH8f66URF6+CFKXN5li0q58fIhp9fPDz+LEx32/HDnDxli1DdKZRLtht20ABaNwYlJm//jKOPJ0/P5bP16dP4ihFf//YfKj58iXmDlqtoDpJnMB162LzebZokfgejx8jz2q5cuAp3riR+BohIYiyLFAAadiMEB4OqkbevOr8uCEhqO+wYcblzHj3devKnFd3d7wvCYsWmXNrBw+Wy8PCmKdNk23On09M8UqI1avNI4/NKEb37hnzQuPi8GH5PgEB6mh2O1atMs75bMeDB0hsL32f4cPRThJye+3w9UW7/v57UO+MMGcOKGm9euEdJ4TFwlyzJnjA7dolpvMwo504O6PtDxtm/G5++AHlefMaP3dgICKriVAnI+zbh3o4Oamjuf/4I5ZL/OWXiSO1bTZQEj/9FOk/1641psBdvoy0pqdOob5GvNzwcFz/VYry1zSkZMCLOuBFi8Cpa9CAuW/fxBy/sDDw9vLmBc+tc+fEg1R0NAZ0V1ck3a5VKzGNxWIBhcHuyAoWTDwgWq3gENsT2L/zTmJOsc2GztihQ2wC8G3bEtts345nKlsWAhqTJ8cfHCwW0C5KlIATL1IkschGVBQ4n++8g2TlRvlSw8LAjXRygoM1yor58CF4gkTx843GrUuvXigvXNiY53vhQuwgNWZM4nJm8LgLF0ZdjHK2MuO72HmNKri7g4ctJac/dgzCIxKFbd063EvCuHEQjJDw6aegk0ioUEHtaJjxLUuWlAfMEycgIiNh1CiIZEioVAkDvQrnzoETOn26mrbSpw9sfv45Nnd1XAQGIuG8qyucjdGEbNUqtJdUqeBQEsJmgwAMESg4Rmn/bt6Ek06XTk1FnDABfNk6dYwpQ5GR4PbWqwfBCiMBmKNHMaEoVgx5d42+0+TJ+Pu8eaEtYITx4/E8RYsmFuexP3PcccioXUVHg+Nut2nWLHF9goNRF7sASZkyiUVV7GNDkSL4KVkycX+Jjsb7q1cPokMff/zvnbp2wMmAF3XAO3eic40caew8bDasMNOkgTiFkfLRxIlwdM7OzEOHJnYgdiWcBg1wrz594s9Oo6PRUAsUgGJMy5aYccdt0D4+zL/+ig5avz5Wx337xp/BRkVhhVqmDIj8//yD+seddVutWC2VLg1ln3Pn8ExxFcBsNigLlSjB/NlncKBGK739+8E97tuXeeVKYy7wyZPofKNHY6A0grs7nGu1asaDBjNm5fny4T2qvpNdTahFC+NrBASgoxOpE39fuBCrAqRSsXr0CIM/kXFdmLECy54dz6XC48fM6dOr68uMd5oyJVZRKly5grpI/OYTJ2Czd6/aZudO2Bw5orZZuhQ2ksDIsGGwkRz1++/DpnNn4xXWkyeY9BGhbRnB7mCrVTMW9LDZmNu0wSSoZ0/j+zx4gPdfogScl9EKdu5c8FPz5cOqMSEsFojpzJzJXKiQcW7ep09jHVulSsYTRKsVE4kWLdA3E/LMbTaMLbduMVevjomZERd9zBh8wypVoBaWkI/MDF50vXqoS926sWNFXCxZgglOpUoYAxOq+zFjEp8hA/ql0aTWZsNkIWtW2BkJkNhsaFc5c2Lc+7fQDjgZ8KIOODhYvY1lx86d8pYZM8QpjBo6MzpoQAAammorccmSWDEBT8/4ncG+ehk0KP4M0m4TFITZcYECEAE4cybx9W02iH2ULYtOaSSZZ3+Oxo0h56hSIAoMxDZv6dKYuRvB7hALFIh1ZEbKUrt2YUa/Z0+sEElC3LiB6+zciYHOCE+fYnKydKl6qzUqCpOTrl3VK1ebDTsG5curnevp0xhoCxQwLmdGHQoXxrVU2LsX9enQQW2zbx8GylGj1DaHD2MwlpziqVNYYRlJGNpx9iwmJtI29NmzmEypZDzt9/rkE1loY/t27CwZKcvZ8euv2Bn59VfjcpsN/WboUPXA7eWFiU737pgAGznhsDA4viZNsAIz2oFhxmS3bFncT7VyP3QIDl/asVi6FM58zx7jcqsVinbFi6sFYWJisGgoXBjKV6rrLFmCdtqvX+IVvq9vrNhGvXrGfeL0afzdmTPquty5A4evOhZixjcwkqmNi4AAjD//FtoBJwNehTPglwHp3G3vXqhlxVXJSoj797GVZHaWOHAgZqzS/U6cwConrjRlQsTEYNVmpNATFytXMl+8KNt4eKi1ne0IDze3sdkg9We2xeXhoZZItMPPT1ZfYsZgr5pUxK3Tv9W+fVVhtZq/Y5vNfOJrfy+OqGqZqZLZbGpHZYfdqUkTh5AQaBYb6Ubb8fAhlOlUuyzMOHMuWhQTZxV27YKjXrxYbXP8OBz10KFynefO/fcSj68LtBJWMkALcWhoaLxM2EduSU0tMhJsgnfeUds8fUq0ezfRxx+rbR48IBoxAuyCuFmL4iI0lGj/fqJWrczr/iZDK2ElA7QD1tDQSGpYLHCiRtKOdpw8ify89tSBCREWRjR9OlHv3kSZMxvbaFnUpINWwtJ4bcEMju7UqWr+a2AgNGcvXVJfY+9eor//Vt/H25to9mw115OZaP58WZjg9m2ibdvU5cxEf/2lLicCX9KIcxkXmzfL5RERWHlI2LnTnNe6e7dcHhVFdPq0bHPzJjjdEvz85PKYGDgeCWZ8ZLNyIvN7SPxdInCvzZ5l5068NxXOnaP/a+/K43yq3vA7g7E39mXsW3aFZI0WSSWUaEGUVFoVJVJUP3uRSoVsISSkyJZdM2NfBoPBDMPMYPZ9vt/53vf3x9M12z3v/WIyQ+f5fOZT5rxz77nnnnves7zP89LMmer6FiwITvysWer6lisHB/zVV9b3Kl4c7752baLJk6054cxEo0YRrVolt50k5qFx7dAOWCNXwAxnYiUo4HRioJkxg6hfPzjX7M4gLQ1CAtWqEd19N8Thsye6X7eOqHdvJPHeupWoSZOc91m0CInABwwg6tQpZ12SkiBqUK8eEo9bzfovXkSy8rVr1SuGrVuRUKJuXXV7fPwx6qxCYiJRt25EBQqobfbvJ/rf/9TlREQTJhAdO6Yud7mIhg+XxR7OniUaN06+z4oVsrgJEd5xYKBsM3KkXH78ONGaNbLNN9/Ijv7oUaL16+VrfPqp7FC2bSOaMkU9cSlRguiZZ4h+/119jcRE9GfVBKl5c4jStGihtnnzTaJXXyW66y60S/b61KlD9NRTRO++i+udPZvzGkOHQiZyxAiiL7/MeQ1PT6L+/bEN3aAB3mNycs7rrF6NpA2LFqlFSPbvh6iH5Mj1vus/+JfPo/8zyA9BWC4XIicjI0FRCQrKyYlzuUA9OHAA0Y+//KIm9v/0E/ihr70Gakn24ImYGOTPbNuW2dsbFAurqMzNmzOSiQ8aZB0YExgIugIRxA2sMGUKyuvXtw5OOnIkg7tslXM1LS2Dt9yunXUwyPbtzKVLw8aKqsAMkYKCBRF0YgUzJaFEgUlPR/5TooxUitkRH48AmfbtrcuZETFaqBDaRoVFi3Cfo0fVNm+8AbqShLZt5Ujp1FTkxf3xR7XN6dPgR0viFnPmIBJYwuOPy3SnsDD0hex5ajNjxAhQh1RRs8nJoOs9/bQ6Ev2bb9C2Awda84TT09FPiHLmsjZh0q68vdXR4U89lfFtWH0/4eGgz9SooY6s/+EHpOZs1UodLDZ2LO5z//05c2Yzo2/375+Re9cqIjk5Gd9X6dJgQ1gFioWGgub44ovIW3zgQE52QkICIs8XLEDApVWdHY6MNISRkdbftMuF/pCUdHMCwHQUdB7gRh3w0qX4AMuXR6h+dgfjdIIH5+GR8TFn75BRUfgAMytOZadppKVlJBgnwiCUveM7HOj4ps3HH+f86J1OfBhVqmRcJ3vndjjASaxaFR9kv345HXRaGugk1aqBF/zVVzmvk5yMSUCLFoiytJowxMVhcOnbF5xOK0REQOykRYucwiImAgPxTI0bWw906engaRYuDDqWFc6fx/MSqSNef/8dA1ThwupI3WHDcI1HHrEuNwzwrCVREIcDFBEiRLNa4fJl8MuJck7YTOzbh/J69azLmcFNNSdZKnz5JWwkKsgbb8DGSh3JxH33weGoPjenE99K48Zq57l6Ne5z993qCcFzz8HmySetBTJiYyGQUbSoWnlr9mw48gEDrB2AYWBC0bw5HLoVjh/Ht1G9upredugQePM1a1qrvDkc+JbGj1c74dRU0MSeeIK5Tx/rCUNCAibBlSsjz7YVre/KFUweiXA9q4l5cDCehwjv0yoK/9ChDK57+fLWk9XNmzHxI1ILlSxZgrKCBXG97IwHw8B7qlQJE4v+/a/fWWsHnAe4UQd84gQ4tlIi6MGD4RxUNJdNm8AbrVjR2sYwoBL1+ONYHVip8ixahI/iySdBaF+8OGt5Who6at264DyuWpVz9WUKaDRsCD5jcDDoR9k/VD8/8E9ffFE98AcGos5vvYXBwcpZhYbiuceOxb2tuKFXroA7+f33akpObCzqvHq1evCPiwP3dscO9YoyKorZxwcKVCoa0YULeJcStePwYTy7akXpcOD93HdfzveUuS4ffgjOtYrvGRSEVd4zz6g55Nu3o42feUZN+5oxA4IekgN+7jms2N94Q23Trh1sJBnPu+6CApiKm8uM76BUKTVV5/JlTHqbNcsqAJMZK1eiPr17qwfkr77CM7/2mnV5aip4rJ07q3nUcXGoT6NG8so+IADfp2oCyYz+W7NmTjnXzJgwATtOVk7YMOAw33oLuy9W34u54uzXDzZW+gSnTkEC9emn4fCtVstnzuCZe/bE92klgHP2LCZ+d9+N3QQrJ3zmDCZbPj5YwFjh1Clcw8dHTUs8ehQTIYm6ZQftgPMAN+qADcOe83nqlPU2V2YcOSJv76WkQHFKJRd44AAcJrO1U/z1VwyipvPJPigdO4ZVWbt2agGNhASoVtWtK+sCz5+P1fOqVWqbgwcx2EiOLCYGq15J69jlwpaYJDTBjEmQxHVkBodZch7M2DGwu9cHH8hby+a9rKQ5M2PwYLVkoIknnrDnpzZpYi8EU6qUvHJITIRjlDjHR4/CRiVEwYxVT7lyMgd8xw6on0nb0EFBEClR7Q6kpqKu7dtby5cy43lTU7FF//336nvFxWXopatw4QK+CyulKxMHD2LHSNK6XrUKE0VpF8F0wpJwxbRpWO2qnLlhQOyjWjXrCb05YV69OmPimh0mD3vnTnVfvnwZR2fHj6v7V3w8JiYS9zslRVZhY8b7Vi0I3IF2wHmA/HAGnB+wbx8GD9VHcvYstkSHD5cH2DfegBO3kpU0sWsXPnzpg0pJgVyenW7wJ59gFi59vBs3wglZbUWaOHsWkwapGyQkYPtOmii5XDhOsEtK0LSpvNJhxiCrWtmaaNhQfRZtomxZ63NBE2lp2MKTkJrK/Oijsg0zVjF2W4CzZ8vOgxk7MZIDZoYojJ14ytmzOBKQEBaGM2WpX4eFYVKgUlIz71WzplynffvQ9yVBmxUr8K1JwjgTJ9o74ZUrcS+V2hwzJt5WR0yZER9vvV19u0E74DyAdsDuIT3dXnGKGbN8abBnxqBx/LhsYxjq7brMA7yfn/VZYeYB5dy5nBJ12Z1xbGzWgcpKszs1NavOsdV9Xa6MwVXa9fD3x3NIM/Y9e+SJDDO2SO2c9KlT9s4+Pd1+l+Z2VkJy59nCwzPsVA7p+HE46bNn1XKb/v7M774rTxqXL8cWu+QYTScsDV27d6s1yTWyQjvgPIB2wLkLOwlBX1/ZGRw5Yi3abuLyZWyvqWAYWBVLxwJ+fuptSWYMekOGqMuZ8RzSmR+z+mzRxJEj8rMwM7/0kvwsycnYhpZw8iSkRiXs2CFrQTMjIMbOUdlNrOykNePj7e9hN1FQnQubOHVKdlppaegfUj2mTpWPYSIisMshbTdv347gNtWENToa57WSE/7jD7lcw31ciy/QPGCNmwrDUAsKMBP5+iJp+LZt1uVbtxI99BDRsGHgP2ZHfDz4xPfdR9SypfV9tm8HN7NcOetyp5PoxReJtmxRKxAdOQKucM2a1uVE4AEfOKAuT0gA91LiAf/5JziXEsaMIQoNVZdfuoRrHD+utlm+HOIlEndz5kxwPCXMmEF08KC6nJlo/HiikBC1TVAQlJskfPaZLJRx6BDR0qXyNd5+m8jhUJfPm4d2UaFkSaIOHax5t0REXl7gTT/zjJqD/dhjRF26gOtrxautWBH9uGNHojfeQJ/JjvvuI1qwAFzinTtzlpcujT52//0Qp7Hi4HbrBtGZdetkjq47Aica14CbMCH4T+B2XwFLs3jDwIpFdR6VnIzk3a+8guxFVjPtP/9EFDgRbKxgpn3z8LA+Q7t4EasFIgQnWWHqVGZPT+bixa23hxMTcUZJhLSPVjh1CkFCROqzs2XLUN6zp3U5MyJnpZR6yck4w/P0VLe/SQ/q00d9nzFj1DlXTbRtC5tjx9R1KV0adBvVtml4OGgeXbuq72PWd9Eitc306ThLlnZB7rlHDqrbuhVBWtJK+b77EIGvatsNG9D2EmWqTRucjauOOTZuzMi7rQpKNKlkAwZYt+3BgyivU0e9Kl+yBDZVq6p5wJMmZVB+/Pysbfr2RYT5kiXWdUlORj1nzVLTuxwOBGtK58oul/X3dztAr4BvQbhcmAFHRmI1k31mzgwJubAwrGR8fXPKzhkG5BuPHIEKkJVajcNBdOIEFHWmTyf66KOccnouF2buU6ZAuerhhyExmB1r10KBp2JFCLDXqpXTJjKSqFUrzLB9fXHN7Cs+ZqJz5yDt2KABlLKyIy2NaOVKrFxffRWzfas2TEzEyvi993KWE6GsfHmiJ5+ERF92MENsvlQprLStkJCA+jRoYK2UZRhYFRUvDtUuK1y6RHThAmxU4vZ//43/FimiXqlt3Yq/Vyk6uVxEp0/jeVSrzvBwrObq10ffsMKhQ2i7unWt+wIRlLJKlEC5ahU1bx7+6+dnXU6EVVhEBJG/v3U5M9HJk+gnTqe1jcuFvvfuu+r71KiB+kyZYl3eujXuNWiQWg60e3ckM5g61XpF/uCDRNWrE8XFEZUpY32NIUOwir140br87ruhltW4MRTArPD00/jGihRRK5G99RaSMkgqVV9+iX7y3HNQRsv+HosWharWG28QVa6M/88+DhUqhL+rWJHokUcgo5l9B8DTE9KZHTtCkWzXLusx7/vviT78kOjXXzFGWPWr334j+vln7DapdkX8/KCZHRamfvagIHyTVlKd/xpuwoTgP4EbXQGbM+VixTC7zD4rNwxwOU3FHCtqzqlT4GGapHWroInISMzGiRCJe/BgTpuUlIx7Va1qTepPSclIeF6lSgZ1KTOSkxHtXKcO6mNFfUpKQl7cDh3AU7Ui0cfHg0P52msZSl/ZERUFHuCCBWqqzPnzeJ6jR9U0rH37QAM5cUJNlVm8GInKpejSUaMgMGKV8NxEt26gZ6hWNYaBSOiAAHVdoqMRoSqt9LZtw/muRNn56iuslKWdjhdegMKYamVqGNiBOHxYzlNburSa756WhnapWRPv0gphYfgGatdWR8Bv3IjVeocO6v4wahRWyePGqVf1ffqAN6pK+Xj0KPjn9euro5/37sUZfZcu1m3ncODdPPeceueGGWf4zZurdzKSkjAGVK+uzm+8ZAl2XCSe8IwZ2GFo3lydEnHSJOwOdO6sXumOHInxoW5daxvDgHqeKaBhFZzpcGSogHl4WMd1xMVl7CIQWXPiL1wA3YwI79wqBWVAQIZq2euvWz+TO9BBWHmAG3XA0dEg+6u2j5gxILVsqR74o6PBd23eXB31OnQotggbN7a2OXUKg/6gQSDPZ3dUhgFaQp062FL+/HPrgBlfX2wpv/kmBg4rEv6pU4jQHDZMHUBy5Qrq8fHHaueQnAyepkSedzhgM2eO2iY9Hff64w/ZpmFDmUaSlgZHLwXxxMZim1Xiw54+jfckYds2OCwJ8+eDdy1hxAiZw8rM/PDDiIaVUK6cHL1++bKspsWMSeH996vLExPhYLt3V9uEhyMCWJLOjIhA26iU05jhGKdMQRCbhHfewbelgmEw9+gBZ69CUhK+X9XEgxm0tJo1Zc723r2YlElJ5X//Xe2E09PxnmbOhPO0moCnp4Nb/r//wWlZqdOlp0OIZ8QIvPPMkf8mnE68x27dMKGymoCbTrhxY+ZOnayfJzUVgh+VK6snd0lJsOnZUz2WxMVBYOhGIr61A84D5MYZsF3kb3y8zEFlxkcn8RANA05NpQWbnp5B3lfZjBqV8aFYdeTp0/HBSWo9q1bBSUmCA+fOwdlNn662MT/g996TV28jR4KnKNn88IN8ZsuMQUca+JlxVv3007LNTz9BP1jCrFn2jvOrr+xFP8aORZSshAED5IGfGRxoaYKYkmIvsnHiBHjZEgICcE4pITQUCkoSEhIgKyhNCFJTsYMjcaBTU+GIrHaLTCQmos9L0crR0Zi4SoP7uXNYwUoTHZMDLLEANmyA8IVEP/vtN9hIPOnVq1Ef1fk1M9SrqlWz1rE2237nTnUEfVISJqQHD6pX0w4H4hOkXZz0dHsxGZfLnu9uKoFdL7QDzgPc7kFY14LTp+UAix9/tB/Mjx3D4KCSWGTO2MLq21eevKxfD0dupa9t4tIlTAgybxk7HFk/xPR0DPr79mX8zop/26lThuyjarfiiSeY165FvVWUm2efxSCZ+X7ZMXAggoSkAXLgQHs61EMP4X4SypeHrKUKZ89i90Va5f39N4LcpN2BwEAEhUlwubCVbTdpffhh+9XMmDHqBCAmfvkF25zSBG7HDqwGpQnw7t1YeV66hP5kVf+dO2EjtdGqVdhhkvjfixahv0o2K1fiO1MdyTDjnb3yirqcGY7ejrf/X4F2wHkA7YDdx5Ur9hGQ779vr07k64vtdKsV14YNGRlWGjXKuUV2/nzWLevXX8+qK+xyYcaeecBdujQrV3bZMkR7Zsbx4zgPNKVFH3ssZ91iYzNWinPnYuWdHYaBs8fLl3Eep0Lz5nAgX3yhtunYEWemkmOoVg2rMxXS0nCNhg3VNjt34szVx0dts3492kRakYeH208GgoIwOVOttqOi8O4PHrQ+xzR3gpjhDK0mMJknY4aBLdnMk7Y9e3KulCZOzBA0OXLEett12jTYuVzod1bn9zNnYiJnGGqu8eTJ2KqXdhy++MK6D2bGhg32imIa7uO2dcDR0dHcr18/vuOOO/iOO+7gfv36cYxqn5SZHQ4Hf/DBB9ykSRMuVqwYV65cmfv3788Xs0VUdOrUiYkoy88zzzxzTXXTDvjm4fDhDGpI9hWEYWBwq1AhY7DM7uxPnIDDySyAERWVMZAZBs7zsm+VxsdnBPQcPw4qU/Ytr7i4jPPuIUOst0mTkrBaiorCmenUqTltnE6skGfORFCIynkuWgTHKZ1RmoEu0pFArVqwUa264uOxuvPwUNNPwsPhNIjkCVavXvKKKikJcQjS6nb4cPmMc8cOtJ2EXr3ke7z0knzWv3w5jhpUx0IOB/phdu1nw8iY2I0ahS1wq61rc/fkgw9yTvTM60yejKBEf3/1s5gTkNtZgSw/4bZ1wF27duUmTZqwr68v+/r6cpMmTbibEIESGxvLnTt35mXLlvGJEyfYz8+PW7duzS1btsxi16lTJx48eDCHh4df/Ym1k8nJBu2A3YN0huN0YlWjEsaPicGZaOHC1lu7CQkZ+X5fftn6Gvv3YyuVSL3tNn58RspHK8THZ3CWVRmRzByvzZpZlzMjqpsIgSxWSErCapJIvZVtptRr00Z9HzP9pCploRkYVbYsVvlWOHcOk4WCBdXnnIGBGbmUVXKjp07BiauCaZjRB4hkB9u+vRwxvGoVdhlUkwVm9ANp52D0aNiozlovXUI9H35YrTLWt29GalCrSOvAQJQXLWqdCYgZ29ZESJGnWm8sXozdB0lBbM4cdY5rEwEB9uef2pHLuC0d8PHjx5mI2D/TXpGfnx8TEZ+QDhOzYc+ePUxEfC5TdEKnTp34HVUOKzdxOzvg6GjZcV65ghWpahsrOhpZTrp2tU4ukJyM8lq14LCsBqq4uIzVVb9+1vdJS8OqpkQJ9UBz8iRyhzZubD2QpKZiYC9RQh1VfeIERPfLl7emMzDDSd1xB9L3WcHhgOOtW1ed8ej0aaSFvO8+daJ287xw6FB1rtk//8SZu9V2KDNWTosXYztU9Z7T0kA9+fRT9SrZ4YA28eTJ6uCfefOwKmzRwrqcOWPCoMqMk5qKSZgUYDV7dkYuaxXq1MGEQhXwZE4EatZU05AaNsSEwuoYgRmr5EKFQGdSOekuXXAPVT0MA2n0iCCPavWeHQ7s6hQqhGe2WpVfugSa4yOPqCc3O3dicrlwoZqatXQpJnOqlH7MOHe303y/cMH+DP9WdPa3pRCHn58feXt7U+vWra/+rk2bNuTt7U2+vr5uXycuLo48PDyoVKlSWX6/ePFiKleuHDVu3JiGDx9OCVaab5mQlpZG8fHxWX5uBElJEEHYvh1CBIaR0+bSJZDJf/kFxPPsNi4XxCzWrCH64guib7/NaZOWRrRvH2QFBw8mGj06pzRkQgLR779DzKJFC6KxY3OKRaSmQnygY0cQ7iMjc4pSMMOmcmWi11/H/apWzflcR48SDR9OFBxM9N13RAUL5rRJTARJvlkzopEjLZuQtm+HCMGuXRBAsMLChUR9++L5PDxylnt5oY2XLyfq3dv6GpUrE50/D8nFsmWtbQyD6N57IRFohUKFcP8BA9RiEXXq4H2NG0d0zz3WNu3bQ4Tjiy+sn8fDA/UtXx62VvD0RPsWLw4hByt4eUEco2pVXE/1TCdPErVpA/EJKwwcCCGWjRutRRVcLoi6NGkCoQwrBAQQ1auH8sOHrW2ioiA+EhSEvmqFOnVkEZOGDfEsbduqn/n114kefxxtaIVHHoHE5+7d+DatsGQJ+knfvtaSlR4eEJ/p2xdSoFbtVqgQ+pFhQFjFyyunTYUKkN/csAFSq1FROW06dMA3378//hscnNPm6achkVqtGt6nlfBH06Z4j82bYwyIiMhpExsLMZuXX4ZEppUAxo4dRD17QiDkwAFrEY1duyDWsWKFWqzDz49o9myI28TE5Cwnwri4bh2eJznZ2ibXcRMmBLmCcePGcT0LAmG9evV4/Pjxbl0jJSWFW7ZsyX379s3y+1mzZvGmTZs4ICCAlyxZwjVr1uTOnTuL1xozZkyOc2O6gRXwqVOY4d55p1oOcOhQ2DRvbh1KHx6OfKxECLyx2kU/dAizYCLmxx+3nilHRCAimAjBMFaz1MwrUpWcn8mpK1FCfeYXE4PrDBqklqCMjobAw5w56hR+UVFYRUhndmfOYJUgBZxs2wYusDTznjkTOXYlvPMOBA0kPPSQnOLNMMBrlLZRr1wBf1LC1q1YSUuYOhV0JQnPPYdzaQl16sgro/h4nHlK8PeX5SzNHLTvvqu2iY4Gv1ziNkdFYfWpOvIwBTLsktufOYPvRepXa9ZgFSsFTH3+Ob4Xq77ndOI7fPJJdcR2fDzeT9OmavnMqCisgKtXV8cEhIbiOKJ6dWt+LzO2zgsXxretGq98fZkLFIBghyoxypo12EEgUudJnjMnQ2RjwgRrm//9L8PGigdsBlUSIUjSaqcnOTnjCCtzQOa14pbaglY5ssw/e/fu5XHjxvGdd96Z4+/r1q3LE1RvJRMcDgf36NGDmzdvbtsw+/btYyLi/cJonpqaynFxcVd/QkNDb8gBu1yIDJWOnoOCEPQhBbi89hoI/6qtxPXrMfB362btfA0DZ0mvvorByWrA2LsXg/7IkejUVtc5fBgdfcwYbMdaBRFduIAt53HjMpKaZ0dSEs777D6IZ59Vn6Wa6N4dW5MSOndWE/lNtG6t1tJlxrPUrCnzDVNSsIUtUTcuXEAbStizB+9TwqpV6vNsE59/rt4KN/HAA/IEJzUV58TS5OXgQfn8lxmDtaRtzQx61oABss3y5fY2CxdC4UvCN9/YC3GMHm3P2X7xRXlLPD0d7/Lbb9U28fE4PlmxQm1z/jz635Yt1uVJSXgPUj5hf39Q6SSbr75C+1WrpqZ6TZqEyXe1amp1rsmTccxSv746oG3SJMQpSHm9//c/CBWpaFeGgUmmNClzuXAdK7U9d3FLOeArV65wYGCg+JOSksJz5sxhb2/vHH/v7e3NcyWVeYbz7dmzJzdr1owj3WhZwzC4UKFCvFQVkWKBm3UGbBcgcemSfdLrsDBZ0CMlBfdRnVmFhmacV1mtjtPT4TRVQSXMCBapXVtOxedwYJVuJ7Lx88/gjUrPvW4d6DzSmZO/PyYEks3Ro+rzYxP79+OMWMKWLfb0kNWrseqU6rNsGQLOpH4xd66s0sQMfq+dElajRuqzUGashOxENpYvx26H1P9++QU7DHacW7v0iefP209gEhIQrCVNapOT4UAkUYvERMQwSIFjsbGwkXjd4eFYeVopQpk4dSpDUlWFQ4dQZ8lm927YSPXx94eNVXCX+X727lXvCLlceNeHD6slQQ0Dzy2lyzQTvtjBKsYkO+zGxxvFLeWA3YUZhLU7U6SCv7+/bRCW6XwbN27Ml1X7l9kQEBDARMTbr0GP7HYOwroe2AVPrF4t83xdLqxMXnhBdkChoRiMJDWftDQMxNKqlRkD+rJlGf+2SoT+7rsZHNaEBOuZ8ujRGVtlqoH0o48QgXvxojrAyuT3SnSaiRPhXE3hDytMnWrPq33rLXX2JxPlysmCHytX4n2ptnSZEWE+fry83T17NqKHpQHX11ee5CQl4adKFeut4bS0jAG/b19M4rIj8w7GlCnMb7yRtTz79uyyZdglMPt+bGzOidHGjQiIkyYgmzahv0pHD2vX4rhK2vZevx6TXEmIY+dOeVXJDD60XbCURgZuyyCshg0bUteuXWnw4MHk7+9P/v7+NHjwYOrWrRvVr1//ql2DBg1o1apVRESUnp5OTz/9NO3bt48WL15MLpeLIiIiKCIighz/pN44c+YMffbZZ7Rv3z4KCQmhP//8k3r37k3Nmzen9qqoFQ1bWAUEZUb37sinq0JyMgJ+fvxRHeBiGAgC+eQTZOnJXmbiq68QTNOmTcbvLl5EwIaJQ4cQsNOrF/4dE0P0+edZr+lwEC1bhgAVImSXscq+smoVsi2dOJHzGia2bEG2pZEj1Vlw9u9HzuIJE6zLiRAkc+wYMmCpEBND9NdfyMijQmwsnk0FM+ONVJeTJ4nuuAPtrcLp02gzKc9uXByCq6T8xQEBcg7kM2fQd1q3ts5h7HAQffAB/r9fPwTwZMebbxJFR+P/X3sNWXcyZw5buJBozpyMf/fujX7366/4t8uFXMCZA3oefhjBcGPG4N/R0Rn3MNG5MwKdXn1VnVXqsceIXniB6OuvlU1AjzyCulhl7DLRoUNGO6hQo4b6G9S4QdyECUGuISoqivv27cslS5bkkiVLct++fXMIcRARz/tnXzM4OFh5rrz1nwiE8+fPc8eOHblMmTLs5eXFderU4bfffpujpGmjBfQK+ObBDPKJibFO0rB3b0a+WcMAFSizGtLZs1g9ZN52nDYN+szMWB098EDOIJ+//srQeDYpKtlVjE6dAjXF5cI2/COP5Kx/fDy2Pf38cA3VNryPD85CPT3VZ8UPPshcpIisK21mk9m0SW3TqhXuo9qKPX8etB9J5WrgQJzvSkFhHTuC5mJxmnQVP/+Munz6qdrmhRfkhA2//466qlaIKSlokw0bsEq1WpF27ZpVaSr79ruZgzdz8FBQUNat1tatwdHOvPkWH59BcXM6UZ6dsuN0IiArNBTPYJX9LLNmcWLijekXa+Qebsst6PwO7YDtIXGJmTGIrFypLk9Lw6AsaQ3Pm4foTFXU6smT2LLOpsVyFYaBwZ2I+euvretw5kxG2sfs29ROJ1IzfvtthkiD1TX278e5NRGcv1U9Zs1i9vKSRUPMuqqehxln30Ryu5nR86pAmYMH4eiJ1FHO/ftnRL2qtlh//TVDrEO1xTpsGMpVHGqXCxOYIkXUE4bp03ENVSS605mRSlMlbvHqq7B56SXrI5WgIJSXLavemv/4Y9i0bau+z8svQ1VNSkzSqROU1ayORZjR3k88IW/bX7mCbXLpeCgqyl4m9lbk5t5M3JZb0Br/DuyST6elYXtWBWYkTl+yRG1z4QLRiBHqrUmnE/zfOnXAEbXCvn3gwv7vf0QvvZSz3OUCx/HFF5FYvl69nDYOB5J/X7ig5sRGRoKTXaIEUa1aOcu9vNAmVaoQNWqUkzdbsCBRzZpIol62LNFdd1lfo3FjoldewTa0Fd/Vw4Po2WfxPB9/bF1XIqJJk1DPUaOsy5mJ3nmHqHZttIsVYmKIevQAZzPzFmtmFC2KrdH27dV81lGjiLp2xbarFe+TiOipp4hatsR2tyox+quvou369rUuP3kSHNT69a23l4mwPV2sGPifVpz6AgWwNVu0KLazrWC2WdOmObnyROivL7+MPtCggfU1Hn4Y2+CVKoGXbIVevdDnRo8mOnvW2mbgQCSnb93aemu+cGFw5Js3J5o40bq+5coRLV0KjvzRo9b3KVkSR0PffovvxQrh4fjWTp60LifCscrKlfi2VQgPV/cTE0lJ6m342wI3YULwn8CNroDj4hCgMWNG1kCgzDhzBrPkjz+2DhpxOrGy+u470C/MbdjMSElBEvNRozArt7pXbCyu36cPAm+sgpcuXsSK6s47saKxinAMD2d+/nmoDdWpY01FSkxEdhwi0J9UHEhTtrF//5zlJr7+Giujzz5T2/Tvj4Cj33+3Lk9PhzrVvn1qlavQUGgVSyuFlSvVHGoTH3wgU06YQc+wyqVswswKJK1KDhyQt2uZsY0qSTsyg2YjRa0zY+teiqo1DLwjKeL1zBlwZiXMnIk8sypERoJ2tnmz2ubcOWyrq3S2k5Jw7NCxo/oahoF6jBplXW5yie+9V01vS0tDgFfVqhmpQLMjPh4r7cqV1Vz40FDsQBQrpqYg7duH78jLS01l+vXXDAUw1ap8wgTwd598Ur36HzgQ9R092jqC3OFA23buDK6v1Q7BpUvou2+8ASaD1S7a6dP41iZPRkCjVZTziRMIVvzpJ/y/1fdy5Aiea80aOROVHfQWdB7gRh1wcjJI7U88oR4QTEL6iy9an/ekpWErkgiDglUnW7Mmg7Cuykizcyck7YiQsNwKp09nbCX+9pu1TUQEojk9PdUDYVgYzkxr1lSLUpw/D4f30UfqwT0oCANYcLCaf7tnD+ojiSGsXAnqk4QvvoDzlDBokFoMwUS7drJzNQxwhaWt+/Bwe6rNhg1yYnpmDDx2dPpeveQIZ2ZQaIT8KBwWBj6nhL/+shcOmT0bCRkkjBxpfYyQGU8/bX2+asIwELUs8Z+jo7GVLVG0Dh4EBUk18TAMxBW0a6c+y927F/2uf3/1hOvddzGhlaLMH30U35Pq2zYMTM49PdUOOC0NtDQidb7u2Fj0B2k8unAhQ5v91VetJ6wBARlHPh9+aH2drVtx9FS4sHoSs3QpnqlnT3X7TZuGicUff1iXuwPtgPMAuXEG7Ocnc9SSkrBCllZVGzbgI1R1sMREBJdIg9f06Vi5qlZEDgec5vjxavGB48exkpwxQ+2ITOf744/qM86EBKyGFixQP5MZyLJkifqZDANBUXYiGx06yKsmZkxypOTshoHJgMR6S07GwCMFzly8aO9cd++2PmfOjEWLoPMs4b33MMGT0LatWvWIGeeQ5cvL1/jzz4xANhVmz7ZfjdspYTHjuVXqaiZ+/tleiOPHH+1tpkyxz5k7bJj8XIaBXSdJ2M/hQB9VCcqkp2M3rUkT9U7a2bNwfHXqqHeC/v4bq+gaNTBpt8L27diNq1ZNPTHbsgUOr3ZtdUDcpk2IUxg2zLqcGbSru++W+9+qVdDKlrBkiTqxiYnt228soE074DxAfgnCSk+3D5K4eNGe15eYKE8GzCBxVUcNCLCXLezaVR7009Oxjaja3jPx+ecQrJCwbBlUhqS22b0bMp+SzcmTiOK12/K1E6TYsUOWW2TGZKpXL9nm11/tVZqmTbPn+Pbvrx6MTVSvLiu1BQbaP/eECfaKZaNGYRIoqYQtWGDv8PbsgbOyQkoK3mFsLHOlSjnvZRgZO1HJyVjhWuUVzny9WrUycgFbISEBjkgS2YiMhNOTJngXLsDpSTam7OrevWqbkyfxTlUCGcwZW7cquFy4jnQNk5MtQXXckxlS+5vID5HgOgjrP4wCBew5uD4+9ry+4sWtkyKYKFMm435WaNIEXEUJK1ZYB1SZiIoiuvNONZeWCALtc+YQzZihtklNRYDQ1Kly23z5JRJQSDZLlhA9/7xs8+efEOiXsGsXApqYrYOEiBAo06SJOhiGCEkhqlfP4Ola4coVmQvqjo1hIElH9qQcmXH6NPjYVgkFTBw+jIAlVSAXEbjNV66AR62C04kEByrExKD8xAnrIJ7QUKK5c4m8vREwt2NH1nIPD6Jhw/C3RYuin37/fc57mO+uSBHw0T/6SF2nEiWIpk9HkJkqAK1sWdznhRfUSSSqVAHHeeBAdd+pXZto0SKiy5fV9bnzTnw/1aqpberXJ5o2TV3u6YnrSNcoVgw/EipWlMuJEMhmB9V4lF+hHbBGnsHuo6xQgWjKFHmyULs2oi0l57FuHaKNmzXL+F32QTkkBNHcffpklGfPFsMMB/zcc/j3gQPW91u7FpMPpxOZqaywaxdEEH79VR15fPQooqW//FL9bKGhGIQ3bVLbXLlCtGePetAnwkCtqqt5jbJlER2rwunTcGiLFqltDh+G8921S21z9izR+vWyEMehQ9aZekwEBkKkonRp60hbZjjYsDCIpvyj3ZMFW7Zg0kZENGQIJnqZneLlyxlOmggCLSdPoh+ZOHYs6+SoWzc4q8zOPHtffPRRRJNL4ipdukBcRfo2Ona0nwSrsnlp3BxoB6xxyyHzgFWqFKgXmXH2bFZn8+SToDmZSErKqmBkXvPbbzPSuE2dmpOeEh0NGkjduqBZvPNOzrolJ2Ol2Lw5VKOsKFyGQbR3L5zrsGHWalpEcMDh4USrV1uXE2EFvH070alTapvLl7Eql1ad0dFYEaoQGYldkY0b1TZnzqAeqhSBKSm4zoIFcEwqnD4N2plks28f0giq1LACA6Fs1r699e4AMxS3hgyBKluVKjltKlWCStSmTUhH+OKLmKiZqFMH/WrcOPy7QAG888yqWklJuH5mNayvv876zlesyEkLmjwZ6SxNBAXlrF+5cln/rVoNa+RfaAescdOg2lIzERYmr2qcTqLPPsNqTIWNG5EXNftWlPnv+HisLpKSspbXqoX8pUTgSg4fnpNLXLYsnIfTCa6rFcexWDGsXI4cwda51QrFwwOOefp0OBCVA544keiHH9AuKjz3HLZPrQZoEw89hG1hFd+VCCuzK1fUvMzGjbHNeuiQmpf58cfg3apWbunpRIMGYWUrOdcOHdBGqhVwTAx2J8qUybl1bMLMURsRAV52djCjT5w6hTzbVjmmK1fGlvvp07D//POsfN+CBbFF+/HHGUcg3brBeZowt7e7ds3IO1ylCvLXmmjUiKhdO+TpVcHfH/m0pW/o228xMZGwYYM1R9gEs7xtbdrc1tzcmwjtgG9jSOeCRHAgkp4uEQZ2aeBOTSWaN0/+8I8cgcPKvHrIDIcDg1bnzjiftkJgIBKjHzyIrensYMZZ1aOPEnXqZH2NmBgII+zahQHPCtu2EQ0YgHM/VRL2UaOQ2Ns8B88OpxMrq/R0tQNOS8tYcSYkWF8nKgor7YgI9erG3x/3UDlgZqJffsH/q95jQkKGkIpKdGX/frzHK1ewKrfCunVw0tl3IEyULAmHVK4ctqpVmDcPZ4Kffmpd7u2NVefTT0PYwwr9+0P7e/x4a2dRrhx2FlRiKUSYAA0ejHelOvO/5x70E1OL3MMjq62XF1ayO3diV8WqLg0bYqv88ceJZs60vk+PHtCebt9ePUnt2BHfyLhx6uOGS5eIWrVSf68eHviOPvpI3S+J8A1s2aJ2xE4n0axZ6uMVIowdO3fKzjwxUb6GeZ1bdkJwE4LC/hO40SjopCTQHV5/Xc2rPXECdAcVH9PlQkj/iBGg3FgJaCQkIHK2b1+IaFgR5KOikJqubVuk3rOKYAwNRbRquXLQO1YR23v1wnxZRVf6+2/UQyX9yIzo5DJlYLNunbWNvz8EHojUPMB9+2BTooQ6wvbIEfCbu3SxLjcMtGvduurI4vR0CFZ0765+l4YBcYFPPlFHzhoGNJpXrFBLEKakoG1UafDS05l37YKYQXa9YROJiaCLDRmCPqayGTIEuXFV0aiGATqYn59aitIw0L5SFL470dTu0JD69pX5nC4XopulDKXHjslR7zExzD/8wNyvn/oaX3+NHN1ffaW2ee019MvZs9X36tkT/XvYMHX7mbKjgwertQJ8fMCHfe896+8gPJy5aFFEh//4o/V19uzBfTp2VIt+/Pwz5EJfeUUtkTl6NL6lCROsxS8MAyIbXbvim7LimCcm4lt75RVE8lt9K+HhYEp88gm+BysEB6Pdvv4aGaCuF5qGlAfIDRpS27boIKoP8MABCGT88IP6GkOGgEiu0lQOD2e+4w5cZ8cOa5vZs/FxFSmiHthNtZySJdUUhL//hgpWmTLqlGiBgRkKPyonc+QIeLWtW6tpBr6++JAlgYzVq0FLUX2AzHBEL70kp3l7/32o7khO5Mkn7cn8TZqoJwvMoIGVLStTK4KCmFu0kO+zapV9YvoxY5C2UEL37szbtsk2Pj5yGr2ICEy4JPz5p1oH2sQ338jJ7ZlRrhKJMPHSS9aKcZnRsSOEHlRITQV1SKU/bhj4RqpUUX8HJ06gbRs2VAuvLF8O/v5DD6n73syZ6FcvvqgeRyZOhIOVeLfvv4/ve9AgNR1x4EDY9OplPeEyDOS8JoL4h9X37XBAJYwIEwyrCUFcHPjwROoUphcuoO81bKgW2gkIwOTPTIRhha1bMUnXDvgWQ244YJXIvQnDkLl/zFjhLl4s2yxcKOeYDQ2FA5k1S23zySfM77yjvk5aGlYOP/6ovk5oKMQAVq9WD+xRUVBOWr9eLWyRlIQPdNs29aBj5gRW5d5lxkBTp44saO90YjIgSdUlJ0PiUDWhYIYwfrVqMp84IAArSglr19o7q+nT7Z3Vyy+rhRtMtGwp5112ODBhkODvr95dMPHdd1A8kjBhAhyJhHnz1DsvJlassM+VvHixvc2338oZqZjxzdjV59VX1e/KMPDTowd2wqyQkICfDh3UE/WYGOwq3XWXWg3ryhVMRhs0UCuFhYVh1dmokXpX5Nw57JBJzx0UhPpmSvWeA0ePQtlMmvTu2ycryzFj/LTTSXCHkyxBO+A8QH4R4nAH7iTXjouz76hOp2xjpupT2YSEYCUt4fPP7SUShw61H9imT5e3CZnhgHr0kG3WrLGXqlyzxl5KccUKbJFK+Okn7GhI+Oore+c6bJhaOcnEY4/JOwPM2JKUJhUhIcxNm8rXWLrUXkDjgw/kXR5mbF3a6Whv3szcrZtsY6aGlERnUlOxupImyCkpELWQVJYSE7FSlsQ6YmNhozouYMZ3VaOGLI8ZFgbHKAmnXLigduQmQkPlLfr0dFkwhdk+uxKzLF9q4lbJwqSFODREuJNc+4477AU9ChaUbUyahMqmRg1kgpEwahQyKUno3FlOFM+M6M/x42WbyZPtk5PPmwcBBAmrVyNoRsK2bepgMRMHD+akWGXHqVPWmZ8y4/x564xLmXHxojUVx4TTiaCyokXVNqGhsiADEQLxqleXbYKD7YVDLl2SBT/S0xHgo8ouRARudMmSyHbk65uz3IxyL1wY4ivz56uvVaQIRFykfli8OKL4hw9X23h7I2uYKhiLKCOrUXYaUmZUroyAOinYrUoVuS5ERFWrylzhAgWIChWSr1G8uFxOpM4UlRl249GtCO2ANfI1PD3tP7zHH5dFPTw8II4hOQcPD6gLqaKjTbRunUFXUkWaulwZSlgqitGZM3DAly6p73XsGBywKnqcCBSZ6tXhZFW4eFFW0yJCdHN24ZHMuHQJvNg9e9Q2589jIJUUrEJC4GAlKkxICNHy5XJ9T56UqUxnziAKNzxcHSH7/vuIMO/WDf0jO/z9MwROXnkF18sejZ6Zvzt4MAREzp3LapP5Wfv1w4RREkXp2ZPom2/U5USI8LabyNg5Ro28h3bAGrcd7OhXDoe1w7r77oz/X7vWepB8/32siFJT1fKXc+ZgdbJ2LVZhVli7FivXt99W13PtWqw+Jk1S2/zxBxS5Dh5U2+zYAfEHKffzsWOyjGLVqkRffIGVlwqPPYb6Sk66c2fUR6K2nT1L9NtvWcUrrGxUSmREeJ6wMEzMVJOcS5ewau3WDY4zO0qUgMOMiMC7qlkTOxeZsWIFdkWIcK+NG3PuJHz+eQZ/19OTaOjQrDx1hyMnLSj7pDMxUQtt3I7QDljjpsDlsl+FnTghDzIpKUQ//yxf46+/wJdUIS0N/FHJGfn6Yutb0pV9+215ZRoZCdEJaRWyalVW1aTsKFiQaMwYmattGHCMUl0CAuAYJLGOhQvBbZba/8cfZadXvDhWrhInvHp11COzXGN29OuHVaOfn3W5wwHlrpMn1cIh5uq4enW1znBqKvjPwcHWEyVvb4hS9O2L/rtkCdH992e1qVULq+PNm/Hvhg1zaqhfvoyjFtXE0MsLTlmSE01PRz2yC8hkxqFDspgHEfqCxO8lsufdEunJQG5BO+B8CHc6t/QhEmFwUQ1OJs6elQf39HSsRKTrhIdDMEE6j9u4EeIWKoeWnIxz3mnT1OfTx49D0EBynDNnQnFItY2ckoLtvV271OemJ05gi7lqVfV95swhmj2bqHx563JmCHFcuqR2wImJkLJ0uawVtYiwql20SFb+mjMHKz3JAZta0qqtYcPAlmdiovo6YWGYMBw8qO6ff/yBvrJ3r7oupviIyrm6XBD9KFlSbRMaijP2xx7D9roVHnsMW/wTJqjr+8ADWK36+CDmITvuuAP98fx5PFP58jn7Z61a+E6efVbdvs2bQwpUpZ5GBHGMxx8nWrbMurxUKfSD9u1zbnGbaNoUSSNGjlTfx5RuNScMVvD3h5CJ9N3PmYMJmXSUMH++WpaUCN/Jb79lKIRZweVC20tCG2lp8lEOEb59qa5EeTOp0A44nyA9Hco7XbqoheqDg4neegvnPyrH+eefGAzatbPOXJOUhLOsDh3wsVqpPV26BDWd2rUh0G+VhSQkhOj11zEAFStmHURx+DDRI4/gp3dvawf8118YOCZPtt6OZcbHfs89ONfr3dvaZvRootdewzlvw4bWNu+/j63G1q2tHb3Tie3C6Gi1g46PzzifVAXBBAfDYRUponbAR45ghVW+vHpSERKCLd2SJa3LidBvSpRQl6emoh61aqkd+blzkFhs2VIdtHT+PFSWOnRQS2NWqIB2e+AB9YA5fDgUxF57zbrcwwMSna1aQSfbCnXq4B6NG6POVmjZEnaRkeqJ39y5aDtVkJC3N/pncjL6nxVq1cKk7+67s8pUZkaLFgheS0hQv4P770f/mzhRPano0QPf1GOPWb+DAgXw7U+ciOtZKZZVq4akJJ074/u1ilF4/HH0z/r1cXRh5biefRa7RHfdRfT779bvu317fGvdu1sfS3h4YOyoWhXfvpWeeYECmIjdeSeCKK2eqXBhBLc99BDGNqv6FigA2da+fYm2bs1ZToTvvlcvTIxVam+5jpsQlf2fQG7QkN5+G2R7FRISwMvbvl1ts2wZ1KmOHrUud7mYO3cGX/PCBWubffuglFOtmjWNwTBAAyFCfayI74YB+hARBDSsKASGAc4nkZwbd9kyCAc8/7zaZuVK5GN98021zfffQxFKIuJ//DHUcFavVtsMGAD6j0QV6dgRamUq6ophgLYSEqIWDkhIAEVGJczADF7jfffJYh2LFkFpSaJxfPgheJ+SjTtUpSpVZNpJVBRy4krYvh2iHxJmz4YohYTPPmP+4gvZ5o03wFWX8NhjagEIlwtt37Ah8+HD1jYpKRDR8fFBLm4rREdDWa56dVAArRASAtGKu+5S95mDB5lLlUL/U9ENN2+GWE/btuhjVli6FN/lPfdk0AmzY/p02Nx1l5o7O3IkbNq1U1OiXnoJNjNmWJcbBoQ8ypRRt01qKlTj3nnHupwZfa9lS3n8PHsW46P0zdlB84DzALnhgCUuogmJ12dCpchjIinJWsoyM+bPh6ylCmfPQnjgr7/UNp9/DoWlzZuty9PT8fH+8otaaejSJXAe/fzUJPvoaNgcPaoW64iLg4DGmTPqdk5IwCApEfHNBO6Sk4mIwL0kvvXJk3h2Cdu3Y/CXYDpXCZ99Zs/3tJNtZGZu3lzmuRoGBn8JJ09ioJSwdq09R3rOHFnJiRk8amlCxgyRCTuRjSVLIGMoYdYseyGOiRPted3Dh8vPlZgIlatPPrEuNwzwjJ94Qi1UYhh47k6d1KI96enoNw8+qFa6S03FM3/0kXrilpjI/PTTsshGTAwmxRKfOCJCPcExcf68/RjqzvDszjgs30M74JuOW0mIwx24Q3pXzcKv5TpWOtOZkZpqL3/o5yfr7DJjdv3ee7LN1Kn2A+QPP9gLScycCU3vG63PlCnMY8fKNh9+CFlGCQMGqKVJTXTsaK8iVLGiLMQRFYVdCAm+vvJuBzNWX6++Ktu4owW9Y4e9EEdMDCZU0mQpORk2ksRmcjJW/5JCWmIidpWkSUx8PCaTkkRpTAwEYyRHERUl7+IwY+Kq0uxmzlDekuCOs3JnnLidoIU4NG4Y7pDezdy5N3Idib9LhPMdO8GKNm2sc/NmxpAhshAHEc6+JCoOEc5k33hDtomLQ8CNhNOncQ4nISAAZ6ESjh/HWaiEM2dwHiohNFTmlaan2wtxXL6sjjg2ERVlnwQ+MVE+1yZCv7LLgFOjhhycRoTYhRo1ZFpU0aLIsiVFrBctiqj3H39U2xQvjlgHKWCoZEnQtGrXluv82285o60zo0wZnL1KKF3aOk7ERPbMTlaQ6mDCnXHivwo3mk9D49aHh4c82BAh0MMOTz9tb/P++/Y2U6fiv8zqQW7+fERmulzqQKJffsHfOxzqgW7NGnv1sx075MHUw4No+3ZEu6tUiypVQp5bw1Dfr1o1TJgkFCpkH7F67Jg9rc3PDwFNqjb290dw1cMPI9jKKi1heDgCFQcPxqQpOzK/m/fftxe/ePZZuZzIXmBD4/aBXgFr3HawWxk5HPYDvF2eZJdL5sQSgU6jihg2sWCBuszDAxHSkgRi4cJwHqrk9USI5p0yRa5HpUqyjGKBAmgzSaGqVCk4RkkJ6667IDAiUT5at7Zvt5gYRCCrkJaGKOqXX1Y7al9foh9+ALPgxRetbYYOBXOgbVtQc7IjODgjl3KJEtaTPD8/mT5H5F7UrV2f1bj1oB2wRq7AzulJqkYmJN1eIgy6koADESgRkkRhWhooMJLIxsGDoGFJ+OQTedsyORmCEtLKc/ducJ8lTJ6cVe4wO5hRF2nCEB4ONa24OLXN6tVYKUuYOVMW2WDGhMJKV9nE6dOggkltt2YNbKQV7qFDmHiocPYsVr9166p3PhISiD7+GO+oTBlrm5AQeUejUiVsPUuTsZgYmQNMhLb94w91ORFEWaKj1eUOR8ZkQIUrV2TZUiJQt+w4sdKzaLgP7YDzGQzDXokmPt5+xiypBBFhNr1mjTwoR0URffutLO24fz8GMRUMA6IVkpxiTAxWFyr+MxEGuJYtZdH2GTOw4rHiARNlqGCFham3fUNCwLOUzjJ/+w3nyRUqqG1GjMBKUDX4p6cTvfpqhkShFUJDoXIlDbp//IF3IDngr77C4CwpYX39NVFgoNrpJSVBFERywP7+4HL+/bfa5pdf8F9JCGLNGjjH7dutyxMT4YA3bVKvlE1O6eTJat3l+HhsqY8era5LkSJE338Pfr0VSpTA1n3Pnuqz3UaN8J4GDVI7tubNiZ56Sj5nLlwY3NrgYOtyLy/sULz6qvqbLVuW6Mkn1YIfROibXbrIOxn+/hD8kFS1Vq8mWrlSnpz/9hv6nYT162WxDsNAfaRJg8NhHw+QlGQvcJTb0A44n4AZxPYWLdSrxagofOgPP2yt3EMErdp774XggZUTMaULa9eGrVW2lPBwBDVVr44ByMqJnDxJ1KcPztA6d7Z2aHv34rzv9dch+mGF9euJmjTBANenT85yZjjwdu1QVyuxA8PAKuXNNyHQYLW6TUsDyX7NGnVgU1QURBVM7V8rnDyZkQ1JpYS1aRPqTKR2wLNmYeCRJjdffgkHrXLAhoEJEpHaAcfFYRD08FA74CNH8FweHvivFf74A30hOFg9adixA/1SpdREhAG7aFF14oe0NASMNWigHtwvXcI76N1bPYH09oai2eDB6oQY1atDbOK++9SDd+XKcLLSRKlqVUyas+tEZ75PsWJ4DytXWtu0bZshN2mlS00EQZsTJ/BNqdTG+vRB3+rY0bpPeHrCAT/7LNELL1g7tkqV8Ex33YWdIKtJWYcOeN/16xP99JN1+3XpgnGkVStIZFo54hYtMF499RQmVVYoUQKxA6+/bq245+mJI5hatfA9WN3Hy4vou+9wL9UuWpEiOIro3l1emOQqbkJU9n8CuUFDWroUIhgquFzMgwaBg6uCmdxayuH5/ffgdKrI5k4nCPjt2qnpGRs2gDz/xBPW5WlpzP37w+all6xtUlOZX3gBNu+/b22TkoJnJmKeNMnaJikJ1KAiRdSiCklJENioVElNz0hJQZ3vvhuJ463gdIKb2707ko1bweVibtIEeYpVAhkOB3OFCswLFliXM4PSUquWmiPtcoFq88gjEHpQ2cyeDZEXFbXF5QIlasYMNY/aMEAf2rJFpiJVq4a+p6KvJCSAIy3RW/btY37oIXU5MwRrBg+WbaZOBQ9dwrBhagEIZvBG+/SR81bv3g2BDF9ftc2UKfb0op49wUNXCV+kpzPfeSdz5cpqm4QE5jvuAGUsONjaJjQUQjuVKjGfOGFtc+gQvrnKlZmPH7e2MceA5s3V9KuffoLNuHHqsWTyZPDHVSIlzPiWBgxQlxsGvl2JeuV0YpxQ8ZqZQQP73/9uLPew5gHnAW4WD9idjuGOioskNsGMQValpmVi7Vr1x8mMD+qdd2RhkNmz8QGqBibDAJdz5Ur1gJKQAAWh/fvVA0FEBAa30FB18u/wcNjEx6v5kefP415Op/pdBAYyN25sXWbC1xciBxJWrZLVv5jhPEaMkG0++ACKYxJ697YXZ7n7bnnyx8xcurTcRy9fZq5XT77G/v32bbNpE+osYc0aewGN1auZn3lGtlm+3N5m3jw4AAnTpzO//LK6PCUFvG9JPOTcOTgj6Z3v2gVn9csvapuFC6ECJjmjsWPBe1c5TsOAIIg0BrhcmLxIfGGHwz3xIGnix5w7ugS5Ae2A8wC3mxBHbkESOHAX7nw00oqfGU5akqBjZj52TF6RMjOvX2+vKjV7tr2Axuefq5WKTHzwgb3IxiuvqNWMTDz5pKxqxgy50MBA2aZyZVk4xeFgLl9evkZIiL0C2P79zA88INvs3cv88MOyzalTkB6UEB0NAQ2pjyUlYbdCcgDJyfLK1LS57z5Z/CIxkfnLL+U6JySgHSXcqJoTs3vf3c1waLcarsUXaB6wxr8KO/6pO3BHFMRO3KFECZyLSWjUCD8SzOQSEl5+2T6K9MMP7fMWDx9uL3QwbJg6KYSJESPUiQJMjB6NfLcSPv1UFk5xuew50F5eEDyRUKyYTDEiQjCeXcBMzZo4B5W41qVLIwAqMlJ9pl+sGMT+zfNrKxQtijNRVTR1ZhsJxYsjR7GEEiXshUrcEciwgzvfnTs2Gmp4MNsRSPIPYmJi6O2336bff/+diIi6d+9O33zzDZUSQmMHDhxIC7KRLVu3bk3+mU7i09LSaPjw4bRkyRJKSUmhhx56iL777juqKuWky4b4+Hjy9vamuLg4ukMVIaWhkUeQnNC12EgiG0QIJLIb/M0MTRKSktRZiohkQRATCQlyRipJvMSEO22ioZEZ1+ILbqko6Oeff54OHTpE69evp/Xr19OhQ4eovxU7Phu6du1K4eHhV3/+zMYpGDp0KK1atYqWLl1Ku3btosTEROrWrRu5VPwFjVsauZFv2TAgvSjBKr1aduzfL5c7HDKvlggRsVLOYCLk8pXATPTzz7LNmTPqVG4mfvzRXnTiiy/k8vBwWdKRCKkE7fisY8fKylSHD6vpRSYWLbJX3LJb1UZHy3QdIvfoL7fOUknDbfzrG+K5hOPHjzMRsX+m8FQ/Pz8mIj6hCuVj5gEDBnCPHj2U5bGxsVyoUCFeunTp1d9dvHiRPT09ef369W7X7798BiylwjMhCdmb17A71woJsbdZskQOxkhOZh4/Xr7GgQPMX38t24wdK2d4SU3FeZ+EgABkipEwdSrztGmyjRQFzYwMTtWqyed1mzfbZ14aNQrRrBJatVJHbTMjCKtoUXUaPGZkeGrbVr5Pnz5IHamCYeA+e/aobTZtQlSx1F+GD1dnHjLRoQPepQqxsXhHUrafNWvsz/LnzkUQoYRVq+S4C5fLPulGQoL8fpjdC/T8r54P35bJGPz8/Mjb25tat2599Xdt2rQhb29v8rVZImzbto0qVKhAd955Jw0ePJguZ1q67N+/n5xOJ3Xp0uXq73x8fKhJkybiddPS0ig+Pj7LT24gLEzmUTJDDEES2XA4sOKRZt1RUVDfkRRtjh7FakU182aGcMDXX6uvkZICfrOksnThArjN0ipg2zbYVK6srsukSZAWVG0rpqaCA6nioBKh7e2EOP78E+ehqjNDIqhTSQIDhgHBBOmZIyNx9hgTo7bZuRMcS1USdyK0SWionATg66/BB1YhPZ1o3jyod6kQFITVuIoPS4R+kJJCtGWL2uavvyDfKK1w9+8nmjNHLc8YEYH7SIpmcXHYpTC51FYoUADXkHYqihYFx1w1BHh74+9fe039Ld19N8RoJIGM8uUhxKHiahNBBa5XLzX32dOTaOJEiLOo6lKsGHi50so+Jgac5QsX1DZ790LeVNoR2bAB6nXS6v6PP2SpVSLIm0rftWGgz0m7GWlp4CLf1J2GmzAhyBWMGzeO61nwF+rVq8fjhSXN0qVLec2aNRwQEMC///4733XXXdy4cWNO/ScUcfHixezl5ZXj7x5++GF+Rcg7N2bMGCaiHD83sgJ+7z1Eo6pml8nJKO/TRz27PHgQHMDRo9X3+f57rA5++sm6PCkJNAZPT6T6s8KxY0hhV7iwmr+3bRsoJ5Urq1cZv/4K6kqbNtblhoHVaIECzP36Wdu4XKA7ETF/+qm1TWoqVnhEzD//bG0THY3E6kSIxLXC6dPgLBKpVwlbtyLheZUq1uXMeAdESP6twhtvwObtt63LDQOrbCLQRayQkoL+QATOsBXOnsW7JkIaOyv8/jvKK1ZU970xY2Bz//3qZ3rqKbSNKoexYaDPFCmC1b8VoqOZixVDxPXatdY2u3Yxe3kx16mjprjMmYP6tmqlzrM9ahRsHn1UvYJ97jnY9O+vbpvWreX+aRiItC5QQM05jo3FeypXDlHgVjhyBPdp1ky9W7RyJWx69EBbWmHSJLyn995Tj0cvv8xcogR2aKyirg0DfaF6debffrO+RkoKuO6tWqkpbhcugNv84ovqd+Dvz1y8OPIyq7BoEdpOyis8ejQi591Z4atwS62Ax44dSx4eHuLPvn/07zwsoiGY2fL3Jp555hl6/PHHqUmTJvTEE0/QunXr6NSpU7R27VqxXnbXHTlyJMXFxV39CbVT73cDr78OKTlVgErRoogynTVLHRhSvz6icCV5yFatMNvu18+6vFgx2PTrp85cc+edWD0PGULk42Ntk5IC+bc337RelSYlQRkoJkatlHX5MtrE5cLM3gphYRnKQA8+qLaJjEQ9Wra0tomMxJlh6dLq9H0OB8obNFAHCZUpg59MmzU5cNddsGne3LqcGapedeqo65KWBjWo9u3VkdBJSZBA7N1bHRxVqBBUkd59V60A1KQJ2nbUKPWK5sUXkdpv7FjrciJkgSpfXp320eWCnnTz5lCxskLBgkSLF0OBrWtXa5s6dXCvJ59Uq5q1aYMI8T59rBXhiBA536cP0fPPq8+T27bFtaRwlHvvRWS3qn96eGSovaki+r290XeTk+X3VKMGVskq5bPHHkMA24YNavWpl17Ct7J1q3pl+f77eF9JSdaBeR4eRJ9/jv82aWJ9jSJFkCikbl11FH6VKtiFePRR9Tto3RrKcQ88YF1OhBX79OlqqVoi9N3p0+2DBHMN1+/ncwdXrlzhwMBA8SclJYXnzJnD3t7eOf7e29ub586de033rFu3Lk/8h4S5efNmJiKOzjYVbNasGX9id/iTCbfaGbA7/FyJ88mMVe2lS7LN0aMyRzcxEQnspWbbsQN8WKk+n32G8y/VStvphKCHv7/62SMjmRs1Ugt+MGPl37ixesXEDJGN++6TzxbXrsVqUDonmz9fvVI0MXEiOMUS3noL15LQsydUriQ0by4nk2dmLltW5qCafFkJwcG4lwR3uMI7dtifa2/ciJWghNWrmXv1UpcbBmIPJLGO1FSszl54YlHdggAAQapJREFUQW0THs78xRdQYlLh4EEI10jn7GvXgouuUjVjRl22b5f73++/y7xmZpx92531SvVgxt9L3GjT5lbBbSnEYQZh7c4U+eLv728bhJUdkZGRXLhwYV7wj+KCGYS1bNmyqzZhYWE6COs/CjsBA8PAQCkhOtpeRezUKTlAiBmOXHUEYGLVKvV2pInvvrOvz0cfyapIzMx9+9oH53TsKJcnJUG2UUJEhL0DvnABcp8SrlxhbtBAtomPh+SqhORke9nLlBQESdnZ2CmJSQprGrcGrsUX3FI84EcffZTCwsJo5syZRET0yiuvUI0aNeiPTHm8GjRoQBMmTKAnn3ySEhMTaezYsdSrVy+qXLkyhYSE0KhRo+j8+fMUGBhIJUuWJCKiIUOG0Jo1a2j+/PlUpkwZGj58OEVFRdH+/fupgJS3LhM0D1hD4+aBGYE1dp+ny2Vvo6GRm7gWX3BLKWEtXryY3n777asRy927d6dvs4Uwnjx5kuL+OSApUKAABQQE0E8//USxsbFUuXJleuCBB2jZsmVXnS8R0bRp06hgwYLUp0+fq0Ic8+fPd9v5amhouI/cEgWx+zyZtfPVyN+4pVbA+Rl6BXzrwJ3B3U7RyeVCQJZKmpAIQV12MpGhoUi1JtXj/Hmkj1Th2DEElkgKVfv2IXWkCswQ/GjfXm1z8SLoLfXrq23WrUNglNS+v/2GtJoqJCQgp7AqwIoI1JSHHpKlMVetQhCWCklJoF61bau2OXyYqHFjuS+EhNjLeMbFqQO9iBDQKImGEGlVrlsFt60SlsbNhzvTMztNYyI5qTwRBnaJ20xEdOCAnJeVWZ1v1UR8PPKXSvDzU+dkNTF2rMzhdTjsNX1PnCCaNk22mT3bXi3ro49kVa7kZORllbB7N3i1En76CY5RwhdfEJ0+rS5PSkK7SGpkvr6IhJawdSvRkiWyzaefyknYY2PRLlJdDh9GlK6EyZOJAgJkm7fflr+T8HCZT0+EZ7bjw/71l/yNEOE7kmAYMr+XCH1K0hAgsi8n0upe2gHnI7hc+ICkzp+cDHk8KWF0RATEBaQP4MgRe5GN1atlkQKHA+IXktOLikLyb0lc5OhR0AcynQrkwK+/Eg0dqqYHMIMWsXGj+hpJSUgEIA2EZ84gIbdK8IMIq68JE0BHUmHMGKxMVTAMoldeUQsmEIGe9fHH1knITezdi/cUFqa2mTsXDlbqD99+C2ejAjOu4+entrl0CSIcf/2lttmyhSg4GCtyFXbswCpZ0rY5dEidfN2sb1AQRCdUiI1F+y1apLYhwmRLcnxeXqAqSe8yJATCK6r6VqsG8Zb589XXqFWLqFMnNXWICLsHDz8si1L89hsSfahETDw9iUaOJFq6VH0NLy+ip5+Wnfnly+jjkgDM3r2Y4EiThnXrUGfJWa9YQXTwoLqcmeiXX2TBGpcLuybSe8x1/MsBYf8Z5EYU9CefIP+rKgrS6QShX0p1d/48RAxUYhPMKPP0VEspGgbS3BUtqs6vGxkJ8ryPj5pCsGsXhBtUIhvMiBwtWlQtsmEYoNkQqZ87PZ35pZdgs2iRtU1yMnLMEqmfOzIS0oREaoGCoCBmb2/QbVTYvh0iBlJ07ezZuM+LL6pt3n0XNpMmqW26dIHN779blzscSARPpBakCA9nLlQIoiqqKPAdO3ANKfL4229hI1F2Xn0VNh99pLZp3x42KuqUYUC8hYj577+tbS5fRnmhQuro7l27YOPjo47uXrAANq1bqyVXP/kENv36qb/dfv1gM2GCdTkz+ounp1qIwzCYK1WCEEwmRd4siI2FmMedd6pzbB8+nCGYoqIRmmIdAwao6X+TJ+NeX32lfqbBg/G9qCL1TbGOpk3V1L6UFObatfGtqNr34kWIdUhynnv2QKxDkvNculR+1+5ApyO8RTF6NGaCqnOeggUhSlGpkvoa1aphBdKundqme3cI7997r3W5hwcENu65R70SLFsWM/rkZKLCha1t7r0XZ4qq8z5mnF2WLw+SvBVSUrBSKVyY6IknrG3Ons1YvalSDh45ghVRwYJqUYCAAKw6y5dXr26DgjBTVok7EGEHokgRogoVrMuZ8VylS6vPkJ1OlFWrhvtZITYWoguNG6tXixcu4D1Uq4ZtTqt6h4ej3YoXh73VeaZhQDykdWvsIFi981q10F86dLCuCxFSOf78s1rgxTAguBIVpT5rjo9H39uzRy1aER+fscMgnZv27Im2SUuzTvFXtCi+pU6dsINidaRXtiyEaerVw3Wsdmlq1EB/YFbHFzRpglVcSIh11ilTrGPVKuwg3Htvzmfz9saZ9v792GmwEnFp2pSoWTNcX9U2jz8Ou1at1OfsgwZhN0hKzzliBJ61aVPrcg8P7FKEhanPyIsUwe5L3brq+vr4YPdFSifaqhV2paQkd888Q9Sly00M3rt+P6+RGf9VHrCdoIfLZU+yj4yU+beGgVm7xI+MjISgvYSdO5n/+kuu66xZslh9fDzkBCWxjpAQ5hEjZBEDf3/mDz6AEIkKv/6KhAOSiP+UKZBslN7DkCEQipDwxBNqqUoTLVrYC3FUqmQv41e6tFx+5Qpz3bqyTVAQJAMlHDhgz0vetQu7CCoYBvOGDZCbVCElBTsQkoDGpUsQ9FDtVDAzBwYyr1+PZ5Pqu2ePLPKybZu9gEZQkP23q9oFygypHib+a7zm25YHnJ+ho6A18gp20bGGgR8pkjcpCed6UiRuRASiuqXrnDyJ1aBUnwMHiFq0UJe7XFjhSVKeDgd2PVq1km2CgrBDoILTiZ0EKbGGy4XnkaLMNTRMXIsv0A44l6AdsIaGhoaGpiFpaGhoaGjkc2gHrKFhAYkbSoTtTbu9I3foDHb86PR0CHpIcCcR19mz9jYnTsjlERFEV67INhJFxoQdr9nhsL/OoUNqGo0JiVZlQsqtS4RntuOz2r1DIjknLhH6m96L/O9BO+D/MNz54KUE1iYkviYRBjBJKIIITiQhQbaxE4EwDCR8l3DpEiI3JWzYYD94jxkjl6em2tscP07044+yzezZ4ElLeO892UmkphINGyZf48ABeyGOxYshkiHhk09kJ+10Er31lnyNgweRclPCn3+C/yzh449lcRdmmZtLhDPkL7+U7zNnjsxBJbIXbiEiGj9eLj95kmjnTtnGz0/mABMhetxugqlKZWjC5bKfjCUnqyP4TfzXxTq0A85HiI6GuIDUsUNCIAIhzaj37iX63//UH5mpGDV1qvoaDgeEOpYtU9vExICKIAlOnD6NvK1S4M6WLci3akUDMfHtt0TffacuT08nGjhQrktMDCgGVrmJTRw9ClEFiarwyy9QhZICjT76iOjUKXW5YWDwv1Ehjv37IVISHq62WbAA4hYSZsyQV53MEImQJkFxcVAQ27xZbePvDychrTx37YIIhCSYEhBgrxwVGCirWCUkEG3fDmqfCoYB5ynVt1AhiM1I7/LSJeTYVTkTT0/UQ3qmWrVAm5KccPHiRPfdJ++KnDwJuk1ystrmxx8xzqjGkAIFoCL2++/qaxQsiDzUkkpYWBjoYtJEadcu1EWawKxcCWU0yeEvWIC2k8RbZs603wnKVfzLEdn/GeQGDWnpUlBcVDAM5oEDZbJ5XBxI6yqiPjPoOCVKIKWbCh9/jLytKkpJWhooHvfeq6YZnD8PIY5nn1XfZ906kPlVwgyGgTIidbq3tDTmp5+GjYpKk5AAQRAikPatEBEB0YqiRdXPFBiItmvaVP1MmzfbC1LMnAmbDz9U25hCHPPmqW0efVQWpEhPZ65TBzaqvMyRkRBvKVdO/dz79uEa7dur67JwIWxeekltM3KkvSDFk0/CRiVIwYy8zUTIj2sFl4vZywvvMiLC2iYkBNeoUUPdz8132aGDmrZjiqoMHKiur/nc48apbZ55BgIuS5eqbVq1gpiEqp+7XBCJqVoVuautEBkJwY927dTiF/v3o77vvKPuE8uWwWblSnV9x4/H9yKJX7z0EuqiotuZYh2jR6uvkZyMPiFR6S5cAHVNGqL37GEeNOjGqFNaiOMWxTPPyFtDHh5EP/wgr+DuuAPbYVLwXYcOmOVVqaK2GTUKK0GV9KOXFyT8zp9XrwSrVQOBXlrZ3n8/JCR797Yu9/AgevFFbJFKhP9u3bDiVCUcSEgAPSYuTi0uEhKC523SRP1Me/ditV2xonU5M2QfvbzUbedyYaVesqR6xp6cnEH7UcmOmquGatXUUpSBgRApKFgQuxFWwhUBARnJHMLDYZ8dpqjDHXdgd8SqD6ak4PqSpGipUhB2KF7cupwZ76dSJfX2pMOBujCrd4siIiBU4XKhj1q9r5gYCERUrgypVCvhD8OAiEb58mhjq52REiXw3Glp2MUqUyanjY8PRD3OnMFKzur569fH7yMirIU4iEDNSk9HO1rB05PoqadwLysRDiLUdcgQiK+oxC+aN8d3+fLL6m+hZ0+i6dOJHnvMupwIuzwdOsg7Sp98gudRUeA8PLAjohK2IcLz+vvLfa9KFRyhSONnq1ZELVvexKQX1+/nNTLjvyrEkVuwm3G6Iw2XnGxvExUll6elybN1ZogcBAaqy9PTUS4lX4+PhzyfanXGjHr4+soz9sOHIa0piV9s3gxxEUnsZMkSiDNI72HaNLm+zFjp2b2HN96Qy1NSmIcOlW0uX4YEpAqGwXzuHPPXX6ttnE7Ic/7yi9omMZH5xAm8BxWuXMF1VJKXzBBuOX9eFlU5c8a+7ewENpjd+w7sRDg0rh9aiCMPoHnAGhoaGhqaB6yhoaGhoZHPoR2whoaGhoZGHkA7YA0NC9jxJN3hL9olRiey5z47nfaCHnYcayI5X7AJO0GPy5ftuazuCH6cPi2XG4b9dYKD7d+RlIPahETfIsL7kehQRO4JrrjDp7d7Ho3bD9oB36KwO7m3I8ATuecgVBG4me9j5wCiouzVgg4dsh+Atm6Vy1NTIdAgISjInhO7ZImcRJzZXjQhMZFo0iTZ5tAhmWdNRPT993A2EoYPl8tTUxHVblcXKRk8Edplzx7Z5qOPZIdkGERDh8rXOH4czy1h3Tr7d/3ZZ/ZiEe+8I39Lly4hXZ6E336zFyiZNg1R1xK++EKuS3w8OOgSAgLsJzi7d9src7mjImY3SXI47J85MdH+u7ebABG5N97lx2gn7YDzEQIDiT74QHZ6W7diwFV1OMNAvtX//U99jdRUOIcFC9Q20dEgyO/dq7Y5exbCFtJq0NcXFCEV3YEIdKaxY9XZZgwD7bJunfoaKSlEPXrIH3xYGOprRRMxsXs3qBMS5WHuXHsVpuHD5RWYy5WRT1mF6Gi0i/RMe/cSLVwoq5H99JP9pOP77+3VnH76CaIIKiQloV2kidKhQ0Rr18pt4+eHZ5L61dGjoMBIOHZMVrFihpDEr7+qbdLTMdkKDFTbFCqEfNbSO4iPJ+rXT3Y2O3Zg0qDCHXcQjRwpi19UqYLcxZJ6WloaxHEkidOdO/H9S85v2jS8A5Vj8/KCUM/atepreHggP7nk8IODiQYMQK5qFTZtgvKcNHbOmwdlOWk34ssv5frmOv71mOz/CHKDhnTsmCw+wAxRhl271OUOB4jtISFqm4sXIagg5aJdtQriAypaimEwv/46c+/e6mskJDA3a8Y8fLjaJjAQggkzZqhtfvoJhP9169R1GTIENqdOWdskJkKIw9NTnZ/4/Hnks61RQ12XQ4cgWvHgg2qbtWtRl1deUdt88w1spkxR27z9Nmx++01t07UrbFSiC+npyK3r4aGmKsXGMhcrxlyzpvo+AQG4j5Q7d8UK2Lz+utpmwgTYTJ2qthk4EDZS7twOHWBz9KjapmJFiFaoqDtJSbhGrVrqtjGfWxLiWL0aNv37q+vy1VewGTNGbWO+b0l45Ykn8Ex796ptGjdmbtBALbzicDCXLAnxGhW97+JF9Jnp09X32bWLuXBhUOFUWLAA4hfx8WqbMWMwRkgUuDfeQDurYBjML7ygFtlhxhgwbJhMwTp3DuPNjUALcdyiaNQIPxIGDpTLCxWCjJxEJPfxIdq2TZaH7NkTwheq63h4QB5SWp2VKIEtS2kbsEEDzNYlsY5nnwXR/r771HX5+GOi2rWJ6ta1tileHDP2DRuIChe2tqlYkWjcOAg3qFChAkQMpBV9pUpYjVevbl3ODOGB9u3VogBpaahz06bqc+LLl7EqqluX6OJF675z9CieKz0dIhBWuXH//hsrp/R0tZDEvn2wiYuDnVXfOXMGzyVJZ0ZHo/2lI4nUVLRvSIh1OTN2EKpUwZar1TOlpqL9SpWCiEuXLtZ1qVwZ30NAgHVu4fR0SEDeeSfauFq1nDZFi0L0o3lz7GgUK5bTxscHAhkPPqjO39yyJXZOVKI0RCjr1UstOEOEVXSlStaiK0QYI375BTmZCxSwtvHxgbCFdJ927SB+o+rnRBDzkQR9iIg+/FAuJ8JKW1VXIrTn/PnyuFe8OLb5JVSvTtS/v2yTm9A84FyC5gH/t6AaRDNDpWaUGSpnlhlOp1olyKyL0ykr/Lhc+FHZuFwZ26OqeyUmYqD09FQ/V1QUUenSaBur9mGG0pNKjYwI9bhyRVYbczrh7FSKUOnp+PH0VD9zSkpGuepdpqTgmaV3rVIGywyXS3YgRO71KY38j2vxBXoFrKFxHXBnoLRzvkT2zpdIdr5mXewcQIECsgOwKyeSdylMqFZdJjw8ZOdLhHZTOV/zGl5e8jMXLGjftkWLyuXu2ti1PZF92xJp5/tfhA7C0tDQ0NDQyANoB6yhoaGhoZEH0A5Y4z8Hu6gHZntuYnq6/X3c4S/aCVukptpfx45jTWTPhyWSc7Ka17ATlJCoIu7aMNvbhIfbvyOJy23CLnm9edYswa7cvI4d7J5HR+vcftAOOJ+B2X5wT0uz/xglTqIJiQdIhAHh4kX7+9ipCQUG2hP/pSTjRAhiWb9etomKItq4UbbZs8deZOCbb2RiP7O9OEN0tH3CeF9fezGJr7+2dyQffiiXJycj5ZuEgwfBH5ewZAnR/v2yzejR8rtmJho2TL7G2bNEM2bINps22feHiRPtRWKGD5cdX3KyzM0lAn93wwbZZtYs++9k2jT7b3/mTLn83Dl7UZB9++zbxd/fvi523xGzvShIYqIcNU8EpoWd0IadohyRe8JD7kyscxPaAecjHDmC3LfSgLByJdGIEeqADcOACIf0ocbE4D6S0zt9GpQJaYXm54d8vqpIVCKi5cuJ3nhDHczCjPpKoiAOB0QMTpxQ28TEED38sBzsEhRE9Pjjch7kjRuJJk+WA5+mTrUXtnjrLdlxOp1Er70mO6vLl9E20grXz49ozhx5hbVggSygQQQhDjvnunCh3GdSU4lWrJDb5vhx9AlJGtPfH6If0mB49CjRV1/J9T1+3J52sm4dcs2qkJaGaxw5orYpVAjfk7SadjqR71t6T8ePyyphHh4QgZkzR21TtSpoStJ7Kl0aFDhJySoiAt+K5Bx//x1KYqpdEQ8P9N9vv1UvGIoXB03pjz/U92EGjezQIbVNUBAoWtJOz+rVmKxK/eqrr9D3bha0A85HqFqV6L335KjKunWJ3nxTXe7piUTcr7yitilVCtzGHj3UNoULE7VtC/6jCpcugS+scq4uFz4a6T7R0UTbtxM9+qja5vhxos2bkUBcheXLweVs0cK63HT0LheS3FshMREfqBSBe/YsVlYSD3jDBvAspSjcb79FfaXt5TFjMLOXHPCYMZh0qRyaywV1n6Ag9SoiLo5o8WLwZVU4cQIrJ2lg/+svtKGkWLZpE97FihVqGz8/PI+0mxEQgGsdO6a2CQnBSlo1KDPDaY4cqZ4IORxot9deU0+Mvbywuv3gA7WjKVMGbTd3rrq+NWqAw+/np7Zp1Aj9WDW5K1CAqEkTTCJVzr52bfTNVavU93n4YShQSZPe557D7pa0+nz+eXkF6+GByYvEAy5TBhNwKcK+RQuMIZLKXe/e4C5L3+Urr4B7f7OgecC5hP8qD9gd7qIdB5IZA51KIIMIK/EiReTrhIVBQEAFpxMr+4YN1TYREfi5+261jalbrXL2RHBGJUoQtWljXZ6WBidUty5EHKwQHAwn1LYtUbNmOcvT07HdeOAA5Pxq185pExeHCUFwMNHgwdYDVGgoVjMJCdiStRqgjh7FgF22LNHrr1vXd9cu2LRpoxaTWLsWW8fdu2OQt8LPP0Ni89lniVq3trb5+musznr3tn6f5oSrQgWiJ56w7hcpKURTpkAAo2NHopIlc9pERGCF/PDDRPXrqwVI/PyIHntM7QCOH4eT7thRvbsSGIj+LU16g4OxgpV2nS5fRj0kRxMfDxEXCWlp8jdJ5N63/V+jV12LL9AOOJfwX3XAGhoaGhoZuBZfoLegNTQ0NDQ08gC3lAOOiYmh/v37k7e3N3l7e1P//v0p1iaEzsPDw/JnypQpV23uv//+HOXPPvvsv/w0GhoaGhr/ZdxSUpTPP/88Xbhwgdb/wz945ZVXqH///vSHEEIXni32f926dTRo0CDq1atXlt8PHjyYPsvENyjqjgadhoaGhobGdeKWccCBgYG0fv168vf3p9b/RGbMnj2b2rZtSydPnqT69etb/l2lSpWy/Hv16tX0wAMPUO1sESvFihXLYatxe8IuMMQd4Xy7BAlEoOXYZXlJSgIVQ4WEBJRLutIxMQjMkRAZqY7+JkKbXLki50G+cgX3kYJ7wsPttZ7dsYmIQEYfqS5ly8rtcuUKUfny8n3caTu7gCVVBqTM0AkbNKxwy2xB+/n5kbe391XnS0TUpk0b8vb2Jl875vk/uHTpEq1du5YGDRqUo2zx4sVUrlw5aty4MQ0fPpwSbJjdaWlpFB8fn+UnN5CQYK82FBFhL8QhJTwnQhSvHUk+IUHmChLhGnaCHtu22QtbSDxAIjgqKRE5EaJRpWTwRLiP3TNlOp2whNNJNGmSbBMWZi+asGGDvQDJ5Mn2QgV2QhyJiUSffy7b7NsnJ6YnQnSynfjC6NEytYqZ6P335WtcuID0cxK2bbMXMZk2TeYbE6Ht7PrmyJHyNY4elbnERKB5BQXJNl99Za+qNX26/O3HxYECJ+HIEURlS9i5U05uTwT6oJ161549crnDQXTypGxz5Yr9NxAWZi+i4Y4ympRe9d/ALeOAIyIiqILF9LxChQoUYaeh9w8WLFhAJUuWpKeeeirL7/v27UtLliyhbdu20ccff0wrVqzIYZMdEyZMuHoW7e3tTdWsEoVeIw4fBsVDWlktXAgKhmoWzEz07ruyI0pJIercWe7UZ8+CTiLRHTZsgLiAip/HDGf29dfqmb3TSfTyyxBfUCEhARw/SRQkNJTooYfkVd7evUR9+1rndDWxZIk9EX/MGFmYgRl8QmkAS00Fn1sS4rhwARxeSeBh2zYIbUiD8ty59upIM2fCCUtYvFgW2UhLw+AvTSpOnYIjtxPiWLDgxoU4Tpywn0xt2SK/b4cDIiWSIylYEN+tpHTl6QnKlKTGdOkSOLHSu9y4kWjCBHW5tzfRqFEyx7dGDaIHHpCFV7y8iDp0kHNjnz4NOlliotpm6VLUR/VMXl7gT0uThlKlkJs8IEBtQwSKl7RuOnmSaMAAuX1/+cVehS03kecOeOzYscpAKfNn3z8jg4eF12Fmy99bYe7cudS3b18qkm1fcPDgwdS5c2dq0qQJPfvss/Trr7/SX3/9RQcEZYKRI0dSXFzc1Z/Q0NBreGprNG0KGUTpcXr1AldTBQ8PDAZ9+6ptihaFvJ6UbLtqVQxeErG9SRNcR1VfDw98xEOGyPVt25aoWze1jcuFpOtt26ptYmOJ6tUDV1OF06dxDdVWoGHACd11l/oa8fFw5JITDwrCalzaft61CwIbkgNetQp1khzw4sUZ+XOt4HIRLVuGCZVq4ImLg3iGNKk4eRKiF5JIxJYtcFibN6ttNm9G+69erbbZtw8rkU2b1DYnTuA9SCu5CxdwH0nIJC5OVt1KTcWEWHLSBQrguSVpzFKl0HekHYSaNdGPJfnX9u1RLjnyp57CM6vet7c3JgPS9v0992CSLolf9OgBjrWUpnLQIDhpaUwbOxYCGSoUKoRJUL16ahsfH0w0rbjcJjp2JBo/Xq7LoEFEL7ygLs9t5DkPODIykiJt9jBr1qxJP//8M7333ns5op5LlSpF06ZNoxdffFG8xs6dO6ljx4506NAhuksaYQlOvXDhwrRw4UJ65pln3HoOzQPOe7hzPmYY9nl609Ptc8nanekZBlaEUiyf04nrqM6AmTNW/apBzunEoF28uPocMjERjqZiRevnMp28w6GW6XQ6sWotXly9y5CSgqOPatXUz5SQAMdYq5Z6ghIbi2OWunXV7+HSJTih6tXV7zw0FG0iOZHz53FOrHpPDgfqXKaM+j7Jyain1B9SUyFqIfVPd+IK9Dlx/se1+II8D8IqV64clZP2Df9B27ZtKS4ujvbs2UP3/iMdtHv3boqLi6N20vTpH8yZM4datmxp63yJiI4dO0ZOp5Mq20WKaOQruDPo2DlfInvnS2QfUOPpaZ/MvVAhecD18JBXF+Y17AKNSpSQr+PpaX+NQoWwdSmhaFGiBg1km5IlZSUyIqwWpaMPIlku1IQ7p0LVq8vlXl6yAyeyD8Aisg/GI7J3vkT2zpdIO99bCXm+Be0uGjZsSF27dqXBgweTv78/+fv70+DBg6lbt25ZIqAbNGhAq7IdgMTHx9Py5cvp5ZdfznHdM2fO0GeffUb79u2jkJAQ+vPPP6l3797UvHlzat++/b/+XBoaGhoa/03cMg6YCJHKTZs2pS5dulCXLl2oWbNmtHDhwiw2J0+epLhs0S9Lly4lZqbnnnsuxzW9vLxo8+bN9Mgjj1D9+vXp7bffpi5dutBff/1FBdyZbmpoaGhoaFwH8vwM+HaBPgPW0NDQ0NBa0Bq3JdyZKrpjY5fcW8rZakLiupqw43Qy2ycSt+M/EslRviakPKlmXeyStF++bN92dknn3bWxYxZGRdnzPu2emci9trPjwyYn2/Nh3UkG706/s2v/3PpGNG4OtAPOZ5DytpqQ6CJE+HsptyuRPSWCCFQaO9GKrVtlHiAzaDDSR+9wgH8rISJC5jYSgT9qx3f9/nt5QDXT2ElISrIX4jh1ClxWCcuXy0nGiUDRkAZvZqIRI+RrxMaCfiHBz4/ot99km0WL7LmYuSHEER4O/rOEXbtkKhMRci6HhMg2o0fbC9/YtW9oKPqVhNWrQZuS8O23MuWMCP1Omni4XPb86KAgmSpGBJGN4GDZ5s8/5W/ftJEmJy6XvXhOTIy9cEhwsH3bnThh/65Pnry5ExTtgPMRzpyBIIJ09LxihX2HHT5c7oxOJ3KXShJ8ly5B/EKKJN28GaIUUoTtlCnIjauKzDQMov79ZZWauDiiLl3k+xw/jmeSInXXryf66CP5ub/5Rk4ETwShE0lpzOUieuklmeObkIDrSKvkM2eIvvtOVhpbv95e+Wj2bHtFIneFOLZtU5e7I8Rx+jSEOCSu6+7d4N1KK8KAAHtHc+qU/UTp77+JZs2SbebMAcdZBQ8PiElIk9XChZHfWBLMS0mBsI3kYI8dI3r7bbWTKFgQE78fflBfo3Zt3EfidFetSnTfffJ36XKBv2/3nqQJV4ECRPPnYzKqQqlS0BI4c0ZtU6ECNBKkyV+BAkRvvCE72KAgonnz1OW5jTynIWlkoE4dSA9K6NXLfutt4kSZJlOoEAZuyaFVrIjVpESN6NQJg7KEl1+Wt1k9PbHilOrr7Y0VkSQc0qABFIJUPFYiJLX//HOZptG8uUwrSU9Hknip7RISiLp2lUVBIiOJnn5a1oGOjoaoguSk4+PxHhIT1XVyODCgqpCejsFJqktUFPSbpd2ZoCC0jbSte+4cFMuCgtTvKjkZ7yEoiKhRI2ubIkUw6EZFqWlClSvj2SVed7Nm8vfkdMLJSJOpwoWJnntOHvyrVSMaOBC7GapjwXbt0CZSfV94AfeT8OmnRC1aqMsLFoSTuftutU3t2pgESXSvhx5CH5fGiEGD7Ol406fLAhoeHlhJS/2zeHEo80ltU68ediqk7//xx2/uClgHYeUSdBCWhoaGhoYOwtLQ0NDQ0Mjn0A5YQ0NDQ0MjD6AdsIaGhoaGRh5AO2ANDQ0NDY08gHbAGvkC7oQC2okdENlHiBuGvY07oglSbmITEuWECBHFdjZ23EYi9wQn7IQtDMPeJjzcnqMu0YuuxUbKF0yEKHI7Tqc7CdhzQ6wjJcW+LnZ8WfM6drC7D7P9O3LnO9KhuTcH2gHnIzCDMyt9IA6HnCeVCMR1ia9JBD6mlJCbCHxjKSE3Mzh80qDgdNqLFERHg2sp4dgxe6GIlSvdE4qQBpf0dNhIiIy0p4vt2+cePzcoSLYZMUIeUA0DHFQJV66AmiZh2zaiNWtkm59+sm/fUaPshTikfNZEcJx2/N3du2XuKBH4vSdOyDajR9srlg0bJveZ6GhQ4CRs2SLnCyYCF9tO/GLcOHny5+EBbr5U34gIoh9/lO+za5fMEybC93bhgmyzeLHcvswQeJHGvMREorVr5fucPWsvUHTggP0k09fXvj/kJrQDzkeIiABPUkqZ5+9vP1P+6Sd1zlYidPZx4+QE1/HxRFOnykIchw5lJFhXYf58e+nBESNkLmFaGlG/fjKXNTwcPMs6ddQ227ZBpEC61zffyAphzBDQiIlR2zgcRK+8IgsUREVBFERaGQUEIMm4tApetYrojz/U5UQQZbCbbM2eba/U9PPP8sQuNRVCMdu3q21OnyZaulSe2O3ejUFZcuSmEIfkaE6ftneMBw4Qff21bLN8uay6xQylsaNH1TZFixINHiyvpj09IeAi7dBcuYJ+I+Hvv2V+fuXK4AoHBqptGjeGQI7E4a9cmWjoUHuVO0kUxMMDAhtSnylRApNDSSq1Zk1MYKS2q1HDXp2uSBG5LrkNzQPOJdxqPODcSl7vToJwu+T1zBi8JcJ+cjLuIxHtw8KIfHzU5YaBmXLdumqbxETM6qW8thcuYBKkmsAYBga3okUhaGAFhwOr5GrV1JOchATsQnTogITwqrps2wYhCNV7OHAAg1zv3upn+vNP/P0jj6jru3w5nvmfdNw5EBmJgbJtW7UISUgIlLLuv1/93MePo86PP65WLdu9G8/+xBPqvrVxI/pLx47qvr5qFZzNnXdalxNhJ6NLF3WO4vh4KI09+KD6e4mIQPs0aaK+z8WL+BakiWZYGEQnvL3VNhERECmRvt3YWPucy8nJsiiNuTMjff/ujA/ujEXu2OQXXIsv0A44l3CrOWANDQ0NjdyHFuLQ0NDQ0NDI59AOWENDQ0NDIw+gHbCGhoaGhkYeQDtgDQ0NDQ2NPIB2wBoi7EL0mO1tckNAg8g9EQI7EY3kZPv62IljEMk0JBN2Ihqpqch1LMGOwkXknrBFaKhc7nLZczpDQ+1FHkJC7Ovijo2Ub5kIEcV2fE275yGyF/wgsueOpqXZ95mYGPvvxJ1+544AjN034HTa18Wd7zG3BD3+y2HA2gHnIyQng6cmdcjLl8GjlBAYCFqJhM2b5QTszODVSUpB6enI5SvVNzbWXlTh9Gn7pOh//WUvZDBtmjzoMoO3KNEzkpMhJiEhONg+GfyGDfbv4Msv7R3ju+/K7et0ygnPidAmX3wh26xfjzpLmDfPXuxg5EiZp27yqCVcugRerYS9e+1zUS9YYM9/HjMGfVTC0KGys0lKsu8zBw7Yc1Ddqe+4cfbqXR98IE9W09JQX6lfHTxoP86sXCmPIUQYQ+wmiNOmyROLtDTw86V3EBpK9Ouv8n327MGPhPXr3Zsg5ha0A85H8PQER1XiuyUmEjVsKF/n4kWiu+5SlzNDgUmySUvD6qxCBbVNeDhI8pJD279f5jUSYeCXBDQMA1xMKcF9XByUsmrUUNsEBoIHLGHtWvuVyKxZ8jtiRpJxCYmJECmRhA6CglAfabW9aZO9cMCiRbJIBBFENqTBnxkD7q5dapvkZLzLHTvUNqdOgZ8rvYc9eyAuIq1wjx/HhEByIiEhcAASTp1C+0jYtk1+bpcL/VOa/BUuDEEKaXVaqhTRjBnyMxUrZu8YHQ4I9qhQogQmvZJUZ9Om6HuSI2/aFBN5CXfeCcEeCdWq2bddiRLyxK5aNbSt5KSbNbOXFW3USBbQyW1oHnAuQfOA/33YkfFvprhIejpRwYJyXdLTZdUtlws/kkhJairqoroOMyYf3t7qZ09Ph8OXhBeSk1GXkiXV94mNhbhIkSLq+5h1UbWN04lJh7e3uo3T0lCfUqXUz5SSgvuVKKG2SUhA20riLQkJELaw2xWRBCnS01EHqc+kp6Nc6p/u9Dt3+u/tJmxxq0ELceQBtAPW0NDQ0NBCHBoaGhoaGvkc2gFraGhoaGjkAbQD1tDQ0NDQyANoB6yhoaGhoZEH0A74FkRukdtzQyDDHVK/nTAAkXtJsCXKDhHqamdjJ45BJOcdNWEnzsBsz3+MjbUX4nCHk3jmjL3N6dNyucNhf6/Tp+2FOE6etK+LOzanTsnlly/b83dPn7bvm8HB9nWxEwVxuewFPS5ftm87d/qdO/3Xrl0cDjnXMpF736M737WdeA6R/RhjGO4JAtkhP4Ybawecj5CUZC+YcPYs0Y8/yjbbttknaZ85U+aGpqcTDR8uc+/i4iACIdEZgoPtRRV27QInVsKcOUR+fupyU2RDqq/TSfTGG/J9IiPtE54fOiQnGSeCSITEHSUi+vxzmYvJTPT66/LAkZKC9yQhKMheOOT338EpljB3LgQaJHz4IShPKjATvfWWfI3wcAhOSDhwADxgCcuXy5xkIqLPPrNXG3v7bZkbmpZG9M478jVOnyaaMkW2WbnSXmxm8mS8TwnDh8sTuwIFiAYPlh3fuXPonxLWrUOdJfzwg32f+fxzebLKDHERyeFfvgzBH+lb2bsXWgESfvuN6PBh2SY3oR1wPkKxYkR9+8o2FSsS9egh29Srh4TnElq3BpFehYIFiZ56Ss0LJQIf1K4uBQoQPfaYbOPpSdSpk7qcGfdq1kxt43AQ+fgQlS+vtomJka9BRHT+vCxQQoTB1E4M5cIFvCsVnE44T2kX4soV9AlJJSgoSM3LNXHsmL1NcLA8eSHC6ktyVk4nVnnSajssDH1CWu2FhmIFJjmIlBS8KwlFiuDZJZQpYy9S4u0t7w4YBrjE0sqzdGlMTKT33bix/a5J69b2Nu3ayeItBQrARnJo9etD3EKqb7t2ROXKyXXp2hXtJ+Gpp9A+Un379pX7sDkuSouBe+4hat5crsuDD0IM6WZB84BzCZoHrKGhoaGhecAaGhoaGhr5HNoBa2hoaGho5AFuKQc8btw4ateuHRUrVoxKScK2mcDMNHbsWPLx8aGiRYvS/fffT8eyHQylpaXRW2+9ReXKlaPixYtT9+7d6YI7ucw0NDQ0NDSuE7eUA3Y4HNS7d28aMmSI238zefJkmjp1Kn377be0d+9eqlSpEj388MOUkImvMnToUFq1ahUtXbqUdu3aRYmJidStWzdy2fEGNDQ0NDQ0rhO3ZBDW/PnzaejQoRRrQ3hjZvLx8aGhQ4fSiBEjiAir3YoVK9KkSZPo1Vdfpbi4OCpfvjwtXLiQnnnmGSIiCgsLo2rVqtGff/5JjzzyiFt10kFYGhoaGho6COsfBAcHU0REBHXp0uXq7woXLkydOnUiX19fIiLav38/OZ3OLDY+Pj7UpEmTqzZWSEtLo/j4+Cw/uQE7UjqRe+T23BC/cDrtr2MnJEFkn4OTCPxbCcwyZ5YIIhx2ryE01L4u7ogz2IlfpKfb5x6+cMG+vnY0GiKigAB7myNH5PKkJHvxi6NH7XOl2nE+iezzw7pjEx5u3x+OHrUXm3GnfQMD7W3sxEXCwuy/t+Bge7EIO+qVeS8J6en231tMjP1YJFGdTLgzPki8cSK8Q7txKC3Nvu1yQxQkt3FbO+CIf+SKKmYjZFasWPFqWUREBHl5eVHpbES0zDZWmDBhAnl7e1/9qVat2g3XNy0NRHsJZ87YCxCsXUu0datsM26cPIAZBtFrr8k5bxMS7EUgjh8n+vJL2ea33+wJ8mPHyg7N5SJ6/nk5n2pCAoQtJJw9C3EGCX/9hQT2Er7+2p7QP2qUPBCa70BCbCxECiS4IxyyYgXRli2yzdy5RPv2yTYjR8p8WMOAGIo0WF68SPS//8n3OXiQaNYs2eaPP4jWrJFtJk2yVwl75x2Zi52eTvTqq/IzRUTgfUvYvt3+254xQxakISIaMUKeaBYsSPTSSzLvOyUFfU96pj177PvVTz8R7dwp23z+uTxp8PQkeu89efLndNoL6Jw8SbRwoWyzZo17E8RcA+cxxowZw0Qk/uzduzfL38ybN4+9vb1tr/33338zEXFYWFiW37/88sv8yCOPMDPz4sWL2cvLK8ffdu7cmV999VXltVNTUzkuLu7qT2hoKBMRx8XFufHUaqSny+WGwex0yjYuF7PDIdskJdnXJTbWvi6XLsk2aWnMERGyTXQ0c2SkbBMczJyQINclWzfJAaeTedcu+7r8/bdsc/Ik88GDss2OHcynT6vLDYN55Uq5bRITmefOld9leDjzvHlyXY4eZf71V9lm82bmrVtlm8WLcS0VDIP5u++YL1xQ28TFMX/zDZ5NhZAQ5tmzcT0VDh9mXrFCru/mzcy+vrLNypXMZ87INosWoV+o4HAwL1vGnJqqtomIYN6yRX6m4GDmgAC5LkeP2n9zBw7YjxF29zEM5qAg2SYxkTkqSraJi2NOSZFtYmPldmF2b7xKS7O3sWsXu/HXHcTFxbntC/L8DDgyMpIibfZDatasSUUyyaC4ewZ89uxZqlOnDh04cICaZ5JA6dGjB5UqVYoWLFhAW7ZsoYceeoiio6OzrILvuusu6tmzJ3366aduPYc+A9bQ0NDQuBZfIGww3hyUK1eOytnpmV0natWqRZUqVaJNmzZddcAOh4O2b99OkyZNIiKili1bUqFChWjTpk3Up08fIiIKDw+no0eP0mS7/WANDQ0NDY3rRJ474GvB+fPnKTo6ms6fP08ul4sO/bNZX7duXSpRogQRETVo0IAmTJhATz75JHl4eNDQoUNp/PjxVK9ePapXrx6NHz+eihUrRs8//zwREXl7e9OgQYNo2LBhVLZsWSpTpgwNHz6cmjZtSp07d86rR9XQ0NDQuM1xSzngTz75hBYsWHD13+aqduvWrXT/P9kHTp48SXGZQu8++OADSklJoddff51iYmKodevWtHHjRiqZKcvAtGnTqGDBgtSnTx9KSUmhhx56iObPn08FpIgeDQ0NDQ2NG0CenwHfLtBnwBoaGhoamgesoaGhoaGRz6EdsIaGhoaGRh5AO2ANDQ0NDY08gHbAGhoaGhoaeQDtgDU0NDQ0NPIA2gFraGhoaGjkAbQD1tDQ0NDQyANoB6yhoaGhoZEH0A5YQ0NDQ0MjD3BLSVHmZ5iCYvF2GdY1NDQ0NG5bmD7AHZFJ7YBzCQkJCUREVK1atTyuiYaGhoZGXiMhIYG8vb1FG60FnUswDIPCwsKoZMmS5OHhcd3XiY+Pp2rVqlFoaOgtoSmt6/vvQtf334Wu77+L/2J9mZkSEhLIx8eHPD3lU169As4leHp6UtWqVXPtenfcccct0WFN6Pr+u9D1/Xeh6/vv4r9WX7uVrwkdhKWhoaGhoZEH0A5YQ0NDQ0MjD6AdcD5D4cKFacyYMVS4cOG8ropb0PX9d6Hr++9C1/ffha6vDB2EpaGhoaGhkQfQK2ANDQ0NDY08gHbAGhoaGhoaeQDtgDU0NDQ0NPIA2gFraGhoaGjkAbQDvskYN24ctWvXjooVK0alSpVy62+YmcaOHUs+Pj5UtGhRuv/+++nYsWNZbNLS0uitt96icuXKUfHixal79+504cKFG65vTEwM9e/fn7y9vcnb25v69+9PsbGx4t94eHhY/kyZMuWqzf3335+j/Nlnn82T+g4cODBHXdq0aZPFJr+0r9PppBEjRlDTpk2pePHi5OPjQy+88AKFhYVlscut9v3uu++oVq1aVKRIEWrZsiXt3LlTtN++fTu1bNmSihQpQrVr16Yffvghh82KFSuoUaNGVLhwYWrUqBGtWrXqmuuVG/VduXIlPfzww1S+fHm64447qG3btrRhw4YsNvPnz7fsy6mpqTe9vtu2bbOsy4kTJ7LY5Zf2tfquPDw8qHHjxldt/s323bFjBz3xxBPk4+NDHh4e9Ntvv9n+zU3vv6xxU/HJJ5/w1KlT+b333mNvb2+3/mbixIlcsmRJXrFiBQcEBPAzzzzDlStX5vj4+Ks2r732GlepUoU3bdrEBw4c4AceeIDvuusuTk9Pv6H6du3alZs0acK+vr7s6+vLTZo04W7duol/Ex4enuVn7ty57OHhwWfOnLlq06lTJx48eHAWu9jY2Buq6/XWd8CAAdy1a9csdYmKispik1/aNzY2ljt37szLli3jEydOsJ+fH7du3ZpbtmyZxS432nfp0qVcqFAhnj17Nh8/fpzfeecdLl68OJ87d87S/uzZs1ysWDF+5513+Pjx4zx79mwuVKgQ//rrr1dtfH19uUCBAjx+/HgODAzk8ePHc8GCBdnf3/+a6pYb9X3nnXd40qRJvGfPHj516hSPHDmSCxUqxAcOHLhqM2/ePL7jjjty9OncwLXWd+vWrUxEfPLkySx1ydwH81P7xsbGZqlnaGgolylThseMGXPV5t9s3z///JM/+ugjXrFiBRMRr1q1SrTPi/6rHXAeYd68eW45YMMwuFKlSjxx4sSrv0tNTWVvb2/+4YcfmBkdvVChQrx06dKrNhcvXmRPT09ev379ddfx+PHjTERZOpefnx8TEZ84ccLt6/To0YMffPDBLL/r1KkTv/POO9ddNytcb30HDBjAPXr0UJbn9/bds2cPE1GWgTA32vfee+/l1157LcvvGjRowB9++KGl/QcffMANGjTI8rtXX32V27Rpc/Xfffr04a5du2axeeSRR/jZZ5+9obpeT32t0KhRI/7000+v/tvd7/R6cK31NR1wTEyM8pr5uX1XrVrFHh4eHBIScvV3/2b7ZoY7Djgv+q/egs7nCA4OpoiICOrSpcvV3xUuXJg6depEvr6+RES0f/9+cjqdWWx8fHyoSZMmV22uB35+fuTt7U2tW7e++rs2bdqQt7e329e9dOkSrV27lgYNGpSjbPHixVSuXDlq3LgxDR8+/GpGqbyo77Zt26hChQp055130uDBg+ny5ctXy/Jz+xIRxcXFkYeHR44jjRtpX4fDQfv378/yzEREXbp0UdbNz88vh/0jjzxC+/btI6fTKdrcSDteb32zwzAMSkhIoDJlymT5fWJiItWoUYOqVq1K3bp1o4MHD95QXW+0vs2bN6fKlSvTQw89RFu3bs1Slp/bd86cOdS5c2eqUaNGlt//G+17PciL/quTMeRzREREEBFRxYoVs/y+YsWKdO7cuas2Xl5eVLp06Rw25t9f770rVKiQ4/cVKlRw+7oLFiygkiVL0lNPPZXl93379qVatWpRpUqV6OjRozRy5Eg6fPgwbdq06abX99FHH6XevXtTjRo1KDg4mD7++GN68MEHaf/+/VS4cOF83b6pqan04Ycf0vPPP59FPP5G2zcyMpJcLpdlv1PVLSIiwtI+PT2dIiMjqXLlykqbG2nH661vdnz55ZeUlJREffr0ufq7Bg0a0Pz586lp06YUHx9P06dPp/bt29Phw4epXr16N7W+lStXplmzZlHLli0pLS2NFi5cSA899BBt27aNOnbsSETqd5DX7RseHk7r1q2jn3/+Ocvv/632vR7kRf/VDjgXMHbsWPr0009Fm71799I999xz3ffInuKQmW3THqps3K2v1X3dvbeJuXPnUt++falIkSJZfj948OCr/9+kSROqV68e3XPPPXTgwAFq0aLFTa3vM888k6Uu99xzD9WoUYPWrl2bY+LgznVvVvs6nU569tlnyTAM+u6777KUXUv7SrjWfmdln/3319OX3cX1XnvJkiU0duxYWr16dZZJUZs2bbIE5LVv355atGhB33zzDX399dc3tb7169en+vXrX/1327ZtKTQ0lL744ourDvhar/lv1jcz5s+fT6VKlaKePXtm+f2/3b7Xipvdf7UDzgW8+eabthGmNWvWvK5rV6pUiYgwO6tcufLV31++fPnqTKxSpUrkcDgoJiYmyyrt8uXL1K5du+uu75EjR+jSpUs5yq5cuZJjFmiFnTt30smTJ2nZsmW2ti1atKBChQpRUFBQDgdxs+pronLlylSjRg0KCgoiovzZvk6nk/r06UPBwcG0ZcsW29RpUvtaoVy5clSgQIEcM/vM/S47KlWqZGlfsGBBKlu2rGhzLe8nt+prYtmyZTRo0CBavnw5de7cWbT19PSkVq1aXe0beVHfzGjTpg0tWrTo6r/zY/syM82dO5f69+9PXl5eom1ute/1IE/673WdHGvcMK41CGvSpElXf5eWlmYZhLVs2bKrNmFhYbkWJLR79+6rv/P393c7SGjAgAE5onNVCAgIYCLi7du351l9TURGRnLhwoV5wYIFzJz/2tfhcHDPnj25cePGfPnyZbfudT3te++99/KQIUOy/K5hw4ZiEFbDhg2z/O61117LEcTy6KOPZrHp2rVrrgUJXUt9mZl//vlnLlKkiG2AjgnDMPiee+7hF1988UaqyszXV9/s6NWrFz/wwANX/53f2pc5I3gsICDA9h652b6ZQW4GYd3s/qsd8E3GuXPn+ODBg/zpp59yiRIl+ODBg3zw4EFOSEi4alO/fn1euXLl1X9PnDiRvb29eeXKlRwQEMDPPfecJQ2patWq/Ndff/GBAwf4wQcfzDWaTLNmzdjPz4/9/Py4adOmOWgy2evLzBwXF8fFihXj77//Psc1T58+zZ9++inv3buXg4ODee3atdygQQNu3rz5Ta9vQkICDxs2jH19fTk4OJi3bt3Kbdu25SpVquTL9nU6ndy9e3euWrUqHzp0KAt1Iy0tjZlzr31N2smcOXP4+PHjPHToUC5evPjVKNYPP/yQ+/fvf9XepHG8++67fPz4cZ4zZ04OGsfff//NBQoU4IkTJ3JgYCBPnDgx12ky7tb3559/5oIFC/KMGTOUdK2xY8fy+vXr+cyZM3zw4EF+8cUXuWDBglkmTTervtOmTeNVq1bxqVOn+OjRo/zhhx8yEfGKFSuu2uSn9jXRr18/bt26teU1/832TUhIuDq+EhFPnTqVDx48eJUtkB/6r3bANxkDBgxgIsrxs3Xr1qs2RMTz5s27+m/DMHjMmDFcqVIlLly4MHfs2DHHbDIlJYXffPNNLlOmDBctWpS7devG58+fv+H6RkVFcd++fblkyZJcsmRJ7tu3bw4aRPb6MjPPnDmTixYtask9PX/+PHfs2JHLlCnDXl5eXKdOHX777bdzcG9vRn2Tk5O5S5cuXL58eS5UqBBXr16dBwwYkKPt8kv7BgcHW/afzH0oN9t3xowZXKNGDfby8uIWLVpkWUEPGDCAO3XqlMV+27Zt3Lx5c/by8uKaNWtaTsCWL1/O9evX50KFCnGDBg2yOJAbxbXUt1OnTpbtOGDAgKs2Q4cO5erVq7OXlxeXL1+eu3Tpwr6+vnlS30mTJnGdOnW4SJEiXLp0ae7QoQOvXbs2xzXzS/syY/eoaNGiPGvWLMvr/Zvta668Ve83P/RfnY5QQ0NDQ0MjD6B5wBoaGhoaGnkA7YA1NDQ0NDTyANoBa2hoaGho5AG0A9bQ0NDQ0MgDaAesoaGhoaGRB9AOWENDQ0NDIw+gHbCGhoaGhkYeQDtgDQ0NDQ2NPIB2wBoaGhoaGnkA7YA1NDQ0NDTyANoBa2hoaGho5AG0A9bQ0LghLFmyhIoUKUIXL168+ruXX36ZmjVrRnFxcXlYMw2N/A2djEFDQ+OGwMx0991303333Ufffvstffrpp/Tjjz+Sv78/ValSJa+rp6GRb1EwryugoaFxa8PDw4PGjRtHTz/9NPn4+ND06dNp586d2vlqaNhAr4A1NDRyBS1atKBjx47Rxo0bqVOnTnldHQ2NfA99BqyhoXHD2LBhA504cYJcLhdVrFgxr6ujoXFLQK+ANTQ0bggHDhyg+++/n2bMmEFLly6lYsWK0fLly/O6Whoa+R76DFhDQ+O6ERISQo8//jh9+OGH1L9/f2rUqBG1atWK9u/fTy1btszr6mlo5GvoFbCGhsZ1ITo6mtq3b08dO3akmTNnXv19jx49KC0tjdavX5+HtdPQyP/QDlhDQ0NDQyMPoIOwNDQ0NDQ08gDaAWtoaGhoaOQBtAPW0NDQ0NDIA2gHrKGhoaGhkQfQDlhDQ0NDQyMPoB2whoaGhoZGHkA7YA0NDQ0NjTyAdsAaGhoaGhp5AO2ANTQ0NDQ08gDaAWtoaGhoaOQBtAPW0NDQ0NDIA/wfoCof6PjWx6wAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -631,7 +639,8 @@ "\n", "All good thrings come in threes, so let's try another example.\n", "\n", - "Here, we use some additional utility to read in the vertices and triangles from the `.pk` file since this file format is not directly supported through the python interface. Additionally, we can plot the Torus, since we have the \"raw\" vertices and faces directly in Python.\n" + "Here, we use some additional utility to read in the vertices and triangles from the `.pk` file since this file format is not directly supported through the python interface. Additionally, we can plot the Torus, since we have the \"raw\" vertices and faces directly in Python.\n", + "Agian, we know this mesh and that all normals are `OUTWARDS` pointing. So we don't need the mesh check and `DISABLE` it.\n" ] }, { @@ -666,7 +675,12 @@ "\n", "torus_vertices, torus_faces = mesh_utility.read_pk_file(\"mesh/torus_lp.pk\")\n", "density = 1.0\n", - "torus_evaluable = gravity_model.GravityEvaluable(polyhedral_source=(torus_vertices, torus_faces), density=density)\n", + "torus_polyhedron = Polyhedron(\n", + " (torus_vertices, torus_faces), density, NormalOrientation.OUTWARDS, PolyhedronIntegrity.DISABLE\n", + ")\n", + "\n", + "\n", + "torus_evaluable = GravityEvaluable(torus_polyhedron)\n", "\n", "mesh_plotting.plot_triangulation(torus_vertices, torus_faces, \"Triangulation of a Torus\")" ] @@ -752,7 +766,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/script/time.py b/script/time.py index db56e47..912b703 100755 --- a/script/time.py +++ b/script/time.py @@ -1,91 +1,100 @@ #!python3 -import polyhedral_gravity +from polyhedral_gravity import evaluate, Polyhedron, PolyhedronIntegrity, GravityEvaluable import numpy as np import matplotlib.pyplot as plt import mesh_utility import timeit import pickle -vertices, faces = mesh_utility.read_pk_file("/Users/schuhmaj/Programming/polyhedral-gravity-model/script/mesh/Eros.pk") -vertices, faces = np.array(vertices), np.array(faces) - -# Generate 1000 random cartesian points -N = 1000 -computation_points = np.random.uniform(-2, 2, (N, 3)) - -DENSITY = 1.0 - -######################################################################################################################## -# OLD -######################################################################################################################## -start_time = timeit.default_timer() -for i in range(N): - polyhedral_gravity.evaluate((vertices, faces), DENSITY, computation_points[i]) -end_time = timeit.default_timer() - -delta = (end_time - start_time) / N * 1e6 -# Print the time in milliseconds -print("######## Old Single-Point ########") -print(f"--> {N} times 1 point with old interface") -print(f"--> Time taken: {delta:.3f} microseconds per point") - -start_time = timeit.default_timer() -polyhedral_gravity.evaluate((vertices, faces), DENSITY, computation_points) -end_time = timeit.default_timer() - -delta = (end_time - start_time) / N * 1e6 -# Print the time in milliseconds -print("######## Old Multi-Point ########") -print("--> 1 time N points with old interface") -print(f"--> Time taken: {delta:.3f} microseconds per point") - -######################################################################################################################## -# NEW -######################################################################################################################## -evaluable = polyhedral_gravity.GravityEvaluable((vertices, faces), DENSITY) - -start_time = timeit.default_timer() -for i in range(N): - evaluable(computation_points[i]) -end_time = timeit.default_timer() - -delta = (end_time - start_time) / N * 1e6 -# Print the time in milliseconds -print("######## GravityEvaluable (Single-Point) #########") -print(f"--> {N} times 1 point with GravityEvaluable") -print(f"--> Time taken: {delta:.3f} microseconds per point") - -evaluable = polyhedral_gravity.GravityEvaluable((vertices, faces), DENSITY) - -start_time = timeit.default_timer() -evaluable(computation_points) -end_time = timeit.default_timer() - -delta = (end_time - start_time) / N * 1e6 -# Print the time in milliseconds -print("######## GravityEvaluable (Multi-Point) ########") -print(f"--> 1 time {N} points with GravityEvaluable") -print(f"--> Time taken: {delta:.3f} microseconds per point") - - -######################################################################################################################## -# PICKLE SUPPORT -######################################################################################################################## - - -with open("evaluable.pk", "wb") as f: - pickle.dump(evaluable, f, pickle.HIGHEST_PROTOCOL) - -with open("evaluable.pk", "rb") as f: - evaluable2 = pickle.load(f) - - -start_time = timeit.default_timer() -evaluable2(computation_points) -end_time = timeit.default_timer() - -delta = (end_time - start_time) / N * 1e6 -# Print the time in milliseconds -print("######## Pickle ########") -print(f"--> 1 time {N} points with GravityEvaluable") -print(f"--> Time taken: {delta:.3f} microseconds per point") + +def main(): + vertices, faces = mesh_utility.read_pk_file("/Users/schuhmaj/Programming/polyhedral-gravity-model/script/mesh/Eros.pk") + vertices, faces = np.array(vertices), np.array(faces) + polyhedron = Polyhedron( + polyhedral_source=(vertices, faces), + density=1.0, + integrity_check=PolyhedronIntegrity.DISABLE, + ) + + # Generate 1000 random cartesian points + N = 1000 + computation_points = np.random.uniform(-2, 2, (N, 3)) + + ######################################################################################################################## + # OLD + ######################################################################################################################## + start_time = timeit.default_timer() + for i in range(N): + evaluate(polyhedron, computation_points[i]) + end_time = timeit.default_timer() + + delta = (end_time - start_time) / N * 1e6 + # Print the time in milliseconds + print("######## Old Single-Point ########") + print(f"--> {N} times 1 point with old interface") + print(f"--> Time taken: {delta:.3f} microseconds per point") + + start_time = timeit.default_timer() + evaluate(polyhedron, computation_points) + end_time = timeit.default_timer() + + delta = (end_time - start_time) / N * 1e6 + # Print the time in milliseconds + print("######## Old Multi-Point ########") + print("--> 1 time N points with old interface") + print(f"--> Time taken: {delta:.3f} microseconds per point") + + ######################################################################################################################## + # NEW + ######################################################################################################################## + evaluable = GravityEvaluable(polyhedron) + + start_time = timeit.default_timer() + for i in range(N): + evaluable(computation_points[i]) + end_time = timeit.default_timer() + + delta = (end_time - start_time) / N * 1e6 + # Print the time in milliseconds + print("######## GravityEvaluable (Single-Point) #########") + print(f"--> {N} times 1 point with GravityEvaluable") + print(f"--> Time taken: {delta:.3f} microseconds per point") + + evaluable = GravityEvaluable(polyhedron) + + start_time = timeit.default_timer() + evaluable(computation_points) + end_time = timeit.default_timer() + + delta = (end_time - start_time) / N * 1e6 + # Print the time in milliseconds + print("######## GravityEvaluable (Multi-Point) ########") + print(f"--> 1 time {N} points with GravityEvaluable") + print(f"--> Time taken: {delta:.3f} microseconds per point") + + + ######################################################################################################################## + # PICKLE SUPPORT + ######################################################################################################################## + + + with open("evaluable.pk", "wb") as f: + pickle.dump(evaluable, f, pickle.HIGHEST_PROTOCOL) + + with open("evaluable.pk", "rb") as f: + evaluable2 = pickle.load(f) + + + start_time = timeit.default_timer() + evaluable2(computation_points) + end_time = timeit.default_timer() + + delta = (end_time - start_time) / N * 1e6 + # Print the time in milliseconds + print("######## Pickle ########") + print(f"--> 1 time {N} points with GravityEvaluable") + print(f"--> Time taken: {delta:.3f} microseconds per point") + + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/script/torus_plots.py b/script/torus_plots.py index 6917dd1..18ad970 100644 --- a/script/torus_plots.py +++ b/script/torus_plots.py @@ -1,5 +1,5 @@ import numpy as np -import polyhedral_gravity as gravity_model +from polyhedral_gravity import Polyhedron, evaluate, PolyhedronIntegrity import mesh_plotting import mesh_utility @@ -11,6 +11,12 @@ DENSITY = 1.0 VALUES = np.arange(-2, 2.01, 0.01) +torus = Polyhedron( + polyhedral_source=(vertices, faces), + density=DENSITY, + integrity_check=PolyhedronIntegrity.DISABLE, +) + ######################################################################################################################## # Triangulation ######################################################################################################################## @@ -22,7 +28,7 @@ # Plot of the potential and Acceleration in XY Plane (Z = 0) ######################################################################################################################## computation_points = np.array(np.meshgrid(VALUES, VALUES, [0])).T.reshape(-1, 3) -gravity_results = gravity_model.evaluate(vertices, faces, DENSITY, computation_points) +gravity_results = evaluate(torus, computation_points) potentials = -1 * np.array([i[0] for i in gravity_results]) potentials = potentials.reshape((len(VALUES), len(VALUES))) @@ -48,7 +54,7 @@ # Plot of the potential and Acceleration in XZ Plane (Y = 0) ######################################################################################################################## computation_points = np.array(np.meshgrid(VALUES, [0], VALUES)).T.reshape(-1, 3) -gravity_results = gravity_model.evaluate(vertices, faces, DENSITY, computation_points) +gravity_results = evaluate(torus, computation_points) potentials = -1 * np.array([i[0] for i in gravity_results]) potentials = potentials.reshape((len(VALUES), len(VALUES))) @@ -76,7 +82,7 @@ # Plot of the potential and Acceleration in YZ Plane (X = 0) ######################################################################################################################## computation_points = np.array(np.meshgrid([0], VALUES, VALUES)).T.reshape(-1, 3) -gravity_results = gravity_model.evaluate(vertices, faces, DENSITY, computation_points) +gravity_results = evaluate(torus, computation_points) potentials = -1 * np.array([i[0] for i in gravity_results]) potentials = potentials.reshape((len(VALUES), len(VALUES))) diff --git a/src/polyhedralGravityPython/PolyhedralGravityPython.cpp b/src/polyhedralGravityPython/PolyhedralGravityPython.cpp index 06fbef9..75a785c 100644 --- a/src/polyhedralGravityPython/PolyhedralGravityPython.cpp +++ b/src/polyhedralGravityPython/PolyhedralGravityPython.cpp @@ -225,7 +225,7 @@ PYBIND11_MODULE(polyhedral_gravity, m) { } Polyhedron polyhedron{ tuple[0].cast>(), tuple[1].cast>(), - tuple[2].cast(), tuple[3].cast() + tuple[2].cast(), tuple[3].cast(), PolyhedronIntegrity::DISABLE }; return polyhedron; } From e19d7ef12ba498a2a53ec06160e111c7e9e6b177 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Thu, 18 Apr 2024 15:29:17 +0200 Subject: [PATCH 26/54] add new test case for Polyhedron Normal Orientation Detection --- test/model/PolyhedronBigTest.cpp | 88 ++++++++++++++++++++++++++++++++ 1 file changed, 88 insertions(+) create mode 100644 test/model/PolyhedronBigTest.cpp diff --git a/test/model/PolyhedronBigTest.cpp b/test/model/PolyhedronBigTest.cpp new file mode 100644 index 0000000..929310b --- /dev/null +++ b/test/model/PolyhedronBigTest.cpp @@ -0,0 +1,88 @@ +#include "gtest/gtest.h" +#include "gmock/gmock.h" + +#include +#include +#include +#include +#include +#include +#include +#include "polyhedralGravity/model/Polyhedron.h" + + +/** + * Cheks that the detection of wrong faces works as intended. + */ +class PolyhedronBigTest : public ::testing::TestWithParam> { + +protected: + + const static inline polyhedralGravity::PolyhedralFiles FILENAMES{"resources/GravityModelBigTest.node", "resources/GravityModelBigTest.face"}; + + const static inline polyhedralGravity::Polyhedron CORRECT_POLYHEDRON{ + FILENAMES, 1.0, + polyhedralGravity::NormalOrientation::OUTWARDS, polyhedralGravity::PolyhedronIntegrity::DISABLE + }; + + static constexpr size_t FACES_COUNT = 14744; + static constexpr size_t SET_SIZE = 100; + static constexpr size_t SET_NUMBER = 10; + static constexpr size_t SEED = 42; + + /** + * Creates a polyhedron violating the OUTWARDS pointing normals constraint for the given face indices. + * @param violatinIndices the indices of the faces where the polyhedron's plane unit normals shall point INWARDS + * @return invalid polyhedron + */ + polyhedralGravity::Polyhedron createViolatingPolyhedron(const std::set &violatinIndices) { + using namespace polyhedralGravity; + std::vector violatingFaces = CORRECT_POLYHEDRON.getFaces(); + for (const size_t index: violatinIndices) { + std::swap(violatingFaces[index][0], violatingFaces[index][1]); + } + return { + CORRECT_POLYHEDRON.getVertices(), violatingFaces, + 1.0, NormalOrientation::OUTWARDS, PolyhedronIntegrity::DISABLE + }; + } + +public: + + // Function to generate a half sized set + static std::vector> generateIndices() { + std::vector> indexSets{}; + indexSets.reserve(SET_NUMBER); + + std::mt19937 engine{SEED}; + std::uniform_int_distribution dist{0, PolyhedronBigTest::FACES_COUNT - 1}; + + for (size_t i = 0; i < SET_NUMBER; ++i) { + std::set generatedSet; + thrust::generate_n(std::inserter(generatedSet, generatedSet.end()), SET_SIZE, [&dist, &engine]() {return dist(engine);}); + indexSets.push_back(generatedSet); + } + return indexSets; + } + +}; + + +TEST_P(PolyhedronBigTest, BigPolyhedronFindWrongVertices) { + using namespace testing; + using namespace polyhedralGravity; + + const std::set expectedViolatingIndices = GetParam(); + ASSERT_EQ(expectedViolatingIndices.size(), SET_SIZE); + + Polyhedron invalidPolyhedron = createViolatingPolyhedron(expectedViolatingIndices); + const auto&[actualOrientation, actualViolatingIndices] = invalidPolyhedron.checkPlaneUnitNormalOrientation(); + + // The orientation changes if violatingIndcies > len(faces)/2 --> So ensure that the size of the test-parameter is smaller than len(faces)/2 + ASSERT_EQ(actualOrientation, NormalOrientation::OUTWARDS); + ASSERT_THAT(actualViolatingIndices, ContainerEq(expectedViolatingIndices)); +} + +INSTANTIATE_TEST_SUITE_P(NormalOrientationViolationTest, PolyhedronBigTest, ::testing::ValuesIn(PolyhedronBigTest::generateIndices())); + + From 7886dc6ca8940211e920a60d7ddd092f2830d56e Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Thu, 18 Apr 2024 16:34:00 +0200 Subject: [PATCH 27/54] faster by 10x new checkPlaneUnitNormalOrientation routine using vector --- src/polyhedralGravity/model/Polyhedron.cpp | 55 ++++++++++++---------- src/polyhedralGravity/model/Polyhedron.h | 1 + test/model/PolyhedronBigTest.cpp | 15 +++++- 3 files changed, 45 insertions(+), 26 deletions(-) diff --git a/src/polyhedralGravity/model/Polyhedron.cpp b/src/polyhedralGravity/model/Polyhedron.cpp index 1d3aefa..ba3ee58 100644 --- a/src/polyhedralGravity/model/Polyhedron.cpp +++ b/src/polyhedralGravity/model/Polyhedron.cpp @@ -89,37 +89,42 @@ namespace polyhedralGravity { std::pair> Polyhedron::checkPlaneUnitNormalOrientation() const { // 1. Step: Find all indices of normals which vioate the constraint outwards pointing - auto indexIterator = thrust::make_counting_iterator(0); - size_t numberOfFaces = this->countFaces(); - std::set violatingOutwards{}; - thrust::copy_if( - thrust::device, - indexIterator, - indexIterator + numberOfFaces, - std::inserter(violatingOutwards, violatingOutwards.end()), - [this](const size_t index) { + const auto&[polyBegin, polyEnd] = this->transformIterator(); + const size_t n = this->countFaces(); + // Vector contains TRUE if the corrspeonding index VIOLATES the OUTWARDS cirteria + // Vector contains FALSE if the cooresponding index FULFILLS the OUTWARDS criteria + thrust::device_vector violatingBoolOutwards(n, false); + thrust::transform( + thrust::device, + polyBegin, + polyEnd, + violatingBoolOutwards.begin(), + [&](const auto &face) { // If the ray intersects the polyhedron odd number of times the normal points inwards // Hence, violating the OUTWARDS constraint - const size_t intersects = countRayPolyhedronIntersections(this->getResolvedFace(index)); + const size_t intersects = this->countRayPolyhedronIntersections(face); return intersects % 2 != 0; }); - // 2. Step: If we have more than n/2 violations, the majority is inwards pointing --> Build complemntary set! - if (violatingOutwards.size() > numberOfFaces / 2) { - std::set fullSet{}; - std::copy_n(indexIterator, numberOfFaces, std::inserter(fullSet, fullSet.end())); - std::set violatingInwards{}; - std::set_difference( - fullSet.begin(), fullSet.end(), - violatingOutwards.begin(), violatingOutwards.end(), - std::inserter(violatingInwards, violatingInwards.end()) - ); - // 3a. Step: Return the inwards pointing as major orientation and + const size_t numberOfOutwardsViolations = std::count(violatingBoolOutwards.cbegin(), violatingBoolOutwards.cend(), true); + // 2. Step: Create a set with only the indices violating the constraint + std::set violatingIndices{}; + auto countingIterator = thrust::make_counting_iterator(0); + + if (numberOfOutwardsViolations <= n / 2) { + std::copy_if(countingIterator, countingIterator + n, std::inserter(violatingIndices, violatingIndices.end()), [&violatingBoolOutwards](const size_t &index) { + return violatingBoolOutwards[index]; + }); + // 3a. Step: Return the outwards pointing as major orientation + // and the violating faces, i.e. which have inwards pointing normals + return std::make_pair(NormalOrientation::OUTWARDS, violatingIndices); + } else { + std::copy_if(countingIterator, countingIterator + n, std::inserter(violatingIndices, violatingIndices.end()), [&violatingBoolOutwards](const size_t &index) { + return !violatingBoolOutwards[index]; + }); + // 3b. Step: Return the inwards pointing as major orientation and // the violating faces, i.e. which have outwards pointing normals - return std::make_pair(NormalOrientation::INWARDS, violatingInwards); + return std::make_pair(NormalOrientation::INWARDS, violatingIndices); } - // 3b. Step: Return the outwards pointing as major orientation - // and the violating faces, i.e. which have inwards pointing normals - return std::make_pair(NormalOrientation::OUTWARDS, violatingOutwards); } void Polyhedron::runIntegrityMeasures(const PolyhedronIntegrity &integrity) { diff --git a/src/polyhedralGravity/model/Polyhedron.h b/src/polyhedralGravity/model/Polyhedron.h index 22bbe42..c80ed30 100644 --- a/src/polyhedralGravity/model/Polyhedron.h +++ b/src/polyhedralGravity/model/Polyhedron.h @@ -13,6 +13,7 @@ #include #include #include "thrust/copy.h" +#include "thrust/device_vector.h" #include "polyhedralGravity/output/Logging.h" #include "thrust/transform_reduce.h" #include "thrust/execution_policy.h" diff --git a/test/model/PolyhedronBigTest.cpp b/test/model/PolyhedronBigTest.cpp index 929310b..b6a7988 100644 --- a/test/model/PolyhedronBigTest.cpp +++ b/test/model/PolyhedronBigTest.cpp @@ -2,15 +2,16 @@ #include "gmock/gmock.h" #include +#include #include #include #include #include #include #include +#include #include "polyhedralGravity/model/Polyhedron.h" - /** * Cheks that the detection of wrong faces works as intended. */ @@ -60,6 +61,9 @@ class PolyhedronBigTest : public ::testing::TestWithParam> { for (size_t i = 0; i < SET_NUMBER; ++i) { std::set generatedSet; thrust::generate_n(std::inserter(generatedSet, generatedSet.end()), SET_SIZE, [&dist, &engine]() {return dist(engine);}); + while(generatedSet.size() < SET_SIZE) { + generatedSet.insert(dist(engine)); + } indexSets.push_back(generatedSet); } return indexSets; @@ -76,8 +80,17 @@ TEST_P(PolyhedronBigTest, BigPolyhedronFindWrongVertices) { ASSERT_EQ(expectedViolatingIndices.size(), SET_SIZE); Polyhedron invalidPolyhedron = createViolatingPolyhedron(expectedViolatingIndices); + + auto start = std::chrono::high_resolution_clock::now(); + const auto&[actualOrientation, actualViolatingIndices] = invalidPolyhedron.checkPlaneUnitNormalOrientation(); + auto end = std::chrono::high_resolution_clock::now(); + auto dur = end - start; + auto ms = std::chrono::duration_cast(dur); + std::cout << "Measured time: " << ms.count() << " microseconds "; + + // The orientation changes if violatingIndcies > len(faces)/2 --> So ensure that the size of the test-parameter is smaller than len(faces)/2 ASSERT_EQ(actualOrientation, NormalOrientation::OUTWARDS); ASSERT_THAT(actualViolatingIndices, ContainerEq(expectedViolatingIndices)); From 0554f40d36f4995e89754ed98b73ad1a322c6a9f Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Thu, 18 Apr 2024 17:02:36 +0200 Subject: [PATCH 28/54] update setup.py --- setup.py | 30 +++++++++++++++++++++++------- 1 file changed, 23 insertions(+), 7 deletions(-) diff --git a/setup.py b/setup.py index 41a8a63..c45820b 100644 --- a/setup.py +++ b/setup.py @@ -168,13 +168,10 @@ def build_extension(self, ext): version="3.0", author="Jonas Schuhmacher", author_email="jonas.schuhmacher@tum.de", - description="Package to compute full gravity tensor of a given constant density polyhedron for arbitrary points", - long_description=""" - The package polyhedral_gravity provides a simple to use interface for the evaluation of the full gravity - tensor of a constant density polyhedron at given computation points according to the geodetic convention. - It is based on a fast, parallelized backbone in C++ capable of evaluating the gravity at thousands of - computation points in the fraction of a second. - """, + description="Package to compute full gravity tensor of a given constant density polyhedron for arbitrary points " + "according to the geodetic convention", + long_description=open("README.md").read(), + long_description_content_type="text/markdown", ext_modules=[CMakeExtension("polyhedral_gravity")], cmdclass={"build_ext": CMakeBuild}, license="GPLv3", @@ -182,5 +179,24 @@ def build_extension(self, ext): zip_safe=False, python_requires=">=3.6", include_package_data=True, + project_urls={ + "Homepage": "https://github.com/esa/polyhedral-gravity-model", + "Source": "https://github.com/esa/polyhedral-gravity-model", + "Documentation": "https://esa.github.io/polyhedral-gravity-model/", + "Repository": "https://github.com/esa/polyhedral-gravity-model.git", + "Issues": "https://github.com/esa/polyhedral-gravity-model/issues", + "Changelog": "https://github.com/esa/polyhedral-gravity-model/releases", + }, + classifiers=[ + "Development Status :: 5 - Production/Stable", + "License :: OSI Approved :: GNU General Public License v3 (GPLv3)", + "Programming Language :: C++", + "Programming Language :: Python", + "Operating System :: Microsoft :: Windows", + "Operating System :: MacOS", + "Operating System :: POSIX :: Linux", + "Intended Audience :: Science/Research", + "Topic :: Scientific/Engineering :: Physics", + ], ) # -------------------------------------------------------------------------------- From f2cadb83fd8c8b2859dba08fe4fe29196df86a00 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Thu, 18 Apr 2024 17:25:08 +0200 Subject: [PATCH 29/54] last fixes - release ready --- README.md | 4 ++-- setup.py | 11 ++++++++++- 2 files changed, 12 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index f3e9509..90096b7 100644 --- a/README.md +++ b/README.md @@ -75,7 +75,7 @@ The evaluation of the polyhedral gravity model requires the following parameters | Constant Density $\rho$ | The mesh and the constants density's unit must match. -Have a look the documentation to view the [supported mesh files](https://esa.github.io/polyhedral-gravity-model/supported_input.html). +Have a look the documentation to view the [supported mesh files](https://esa.github.io/polyhedral-gravity-model/quickstart/supported_input.html). ### Output @@ -337,7 +337,7 @@ found in this repository in the folder `/example-config/`. The configuration should look similar to the given example below. It is required to specify the source-files of the polyhedron's mesh (more info -about the supported file in the [previous paragraph](#supported-polyhedron-source-files-python-c)), the density +about the supported file in the [documentation](https://esa.github.io/polyhedral-gravity-model/quickstart/supported_input.html)), the density of the polyhedron, and the wished computation points where the gravity tensor shall be computed. Further one must specify the name of the .csv output file. diff --git a/setup.py b/setup.py index c45820b..a702f1a 100644 --- a/setup.py +++ b/setup.py @@ -160,6 +160,15 @@ def build_extension(self, ext): # ----------------------------------------------------------------------------------------- +picture_in_readme = '''

+ +
+ + Mesh of (433) Eros with 739 vertices and 1474 faces + +

''' + + # -------------------------------------------------------------------------------- # Modify these entries to customize the package metadata of the polyhedral gravity # -------------------------------------------------------------------------------- @@ -170,7 +179,7 @@ def build_extension(self, ext): author_email="jonas.schuhmacher@tum.de", description="Package to compute full gravity tensor of a given constant density polyhedron for arbitrary points " "according to the geodetic convention", - long_description=open("README.md").read(), + long_description=open("README.md").read().replace(picture_in_readme, ''), long_description_content_type="text/markdown", ext_modules=[CMakeExtension("polyhedral_gravity")], cmdclass={"build_ext": CMakeBuild}, From 7e0f3f4a5a084316fe224e1867f759608149bbcc Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Thu, 18 Apr 2024 17:29:50 +0200 Subject: [PATCH 30/54] remove repository url --- setup.py | 1 - 1 file changed, 1 deletion(-) diff --git a/setup.py b/setup.py index a702f1a..5da7822 100644 --- a/setup.py +++ b/setup.py @@ -192,7 +192,6 @@ def build_extension(self, ext): "Homepage": "https://github.com/esa/polyhedral-gravity-model", "Source": "https://github.com/esa/polyhedral-gravity-model", "Documentation": "https://esa.github.io/polyhedral-gravity-model/", - "Repository": "https://github.com/esa/polyhedral-gravity-model.git", "Issues": "https://github.com/esa/polyhedral-gravity-model/issues", "Changelog": "https://github.com/esa/polyhedral-gravity-model/releases", }, From 2d05f029ed6919ee355a365fb8378c3ab6c1ad91 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Thu, 18 Apr 2024 17:46:30 +0200 Subject: [PATCH 31/54] fix spelling --- docs/background/mesh_integrity.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/background/mesh_integrity.rst b/docs/background/mesh_integrity.rst index f68562d..a624473 100644 --- a/docs/background/mesh_integrity.rst +++ b/docs/background/mesh_integrity.rst @@ -70,7 +70,7 @@ for the construction of a polyhedron in the form of the enum :code:`PolyhedronIn +-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------+----------------+ | :code:`VERIFY` | Throws an Exception if the :code:`NormalOrientation` is different or inconsistent than specified | NO | :math:`O(n^2)` | +-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------+----------------+ -| :code:`HEAL` | Modifies the specified :code:`NormalOrientation` and the faces array to a consistent polyhedron if is different or inconsistent | NO | :math:`O(n^2)` | +| :code:`HEAL` | Modifies the specified :code:`NormalOrientation` and the faces array to a consistent polyhedron if they are inconsistent | NO | :math:`O(n^2)` | +-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------+----------------+ | :code:`DISABLE` | Disables all checks | YES | None | +-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------+----------------+ From 5b9f1e524d622f5bf24ed6aad71aeffd707ff2c6 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Thu, 18 Apr 2024 19:16:42 +0200 Subject: [PATCH 32/54] rc3 --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 5da7822..6080fcc 100644 --- a/setup.py +++ b/setup.py @@ -174,7 +174,7 @@ def build_extension(self, ext): # -------------------------------------------------------------------------------- setup( name="polyhedral_gravity", - version="3.0", + version="3.0rc3", author="Jonas Schuhmacher", author_email="jonas.schuhmacher@tum.de", description="Package to compute full gravity tensor of a given constant density polyhedron for arbitrary points " From 15083a540919ca9a6b718f7988f08107875f71d9 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Thu, 18 Apr 2024 19:25:13 +0200 Subject: [PATCH 33/54] fix setup.py --- setup.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 6080fcc..977cd9a 100644 --- a/setup.py +++ b/setup.py @@ -47,7 +47,8 @@ def get_cmake_generator(): If not, returns "Ninja" if ninja build is installed. Otherwise, none is returned. """ - if (os_env_generator := os.environ.get("CMAKE_GENERATOR")) is not None: + os_env_generator = os.environ.get("CMAKE_GENERATOR", None) + if os_env_generator is not None: return os_env_generator elif is_ninja_installed(): return "Ninja" From 871a1cc8eab41cd7e12c4342c022fa1372f96d27 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Thu, 18 Apr 2024 21:07:28 +0200 Subject: [PATCH 34/54] update cibuildhweel to fix Windows issue --- .github/workflows/wheels.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml index 2f5b852..2d435e4 100644 --- a/.github/workflows/wheels.yml +++ b/.github/workflows/wheels.yml @@ -25,7 +25,7 @@ jobs: # In case of Linux we need to install compiler and build tools before building the wheels # We further only build the manylinux wheels, but not the musllinux wheels - name: Build wheels (Linux) - uses: pypa/cibuildwheel@v2.15.0 + uses: pypa/cibuildwheel@v2.17.0 env: CIBW_BEFORE_BUILD: yum makecache && yum install -y gcc-c++ cmake && pip install ninja CIBW_BUILD: "*manylinux*" From c8f416479edf7f0d7693280b19619a9083d48edc Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Fri, 19 Apr 2024 00:16:35 +0200 Subject: [PATCH 35/54] update cibuildhweel to fix Windows issue --- .github/workflows/wheels.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml index 2d435e4..7e87267 100644 --- a/.github/workflows/wheels.yml +++ b/.github/workflows/wheels.yml @@ -39,7 +39,7 @@ jobs: # Building on macOS requires an installation of gcc since the default clang compiler # lacks certain features required for building the package - name: Build wheels (macOS) - uses: pypa/cibuildwheel@v2.15.0 + uses: pypa/cibuildwheel@v2.17.0 env: CIBW_BEFORE_BUILD: brew install ninja gcc@12 CIBW_ENVIRONMENT: "CC=gcc-12 CXX=g++-12" @@ -53,7 +53,7 @@ jobs: - uses: ilammy/msvc-dev-cmd@v1 if: matrix.os == 'windows-latest' - name: Build wheels (Windows) - uses: pypa/cibuildwheel@v2.15.0 + uses: pypa/cibuildwheel@v2.17.0 env: CIBW_BEFORE_BUILD: choco install -y ninja cmake CIBW_ARCHS_WINDOWS: "auto64" From d333d3179a6260e41b411c8d7f1912b302db932b Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Fri, 19 Apr 2024 00:23:20 +0200 Subject: [PATCH 36/54] version 3.0 - remove release candidate status --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 977cd9a..aaa5f30 100644 --- a/setup.py +++ b/setup.py @@ -175,7 +175,7 @@ def build_extension(self, ext): # -------------------------------------------------------------------------------- setup( name="polyhedral_gravity", - version="3.0rc3", + version="3.0", author="Jonas Schuhmacher", author_email="jonas.schuhmacher@tum.de", description="Package to compute full gravity tensor of a given constant density polyhedron for arbitrary points " From 95198395f6bc8072b2e9d40277650023c94bd504 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Fri, 19 Apr 2024 17:51:50 +0200 Subject: [PATCH 37/54] arm images in the pipeline [skip ci] --- .github/workflows/wheels.yml | 3 ++- setup.py | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml index 7e87267..5844787 100644 --- a/.github/workflows/wheels.yml +++ b/.github/workflows/wheels.yml @@ -29,7 +29,7 @@ jobs: env: CIBW_BEFORE_BUILD: yum makecache && yum install -y gcc-c++ cmake && pip install ninja CIBW_BUILD: "*manylinux*" - CIBW_ARCHS_LINUX: "auto64" + CIBW_ARCHS_LINUX: "x86_64 aarch64" CIBW_TEST_COMMAND: 'python -c "import polyhedral_gravity"' with: package-dir: . @@ -43,6 +43,7 @@ jobs: env: CIBW_BEFORE_BUILD: brew install ninja gcc@12 CIBW_ENVIRONMENT: "CC=gcc-12 CXX=g++-12" + CIBW_ARCHS_MACOS: "x86_64 arm64" CIBW_TEST_COMMAND: 'python -c "import polyhedral_gravity"' with: package-dir: . diff --git a/setup.py b/setup.py index aaa5f30..0e35bdb 100644 --- a/setup.py +++ b/setup.py @@ -175,7 +175,7 @@ def build_extension(self, ext): # -------------------------------------------------------------------------------- setup( name="polyhedral_gravity", - version="3.0", + version="3.0rc4", author="Jonas Schuhmacher", author_email="jonas.schuhmacher@tum.de", description="Package to compute full gravity tensor of a given constant density polyhedron for arbitrary points " From 1b7b84d86d6705bc69ae738f5f9839175bb22135 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Fri, 19 Apr 2024 18:18:21 +0200 Subject: [PATCH 38/54] retry with different compiler - macOS arm [skip ci] --- .github/workflows/wheels.yml | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml index 5844787..725aabd 100644 --- a/.github/workflows/wheels.yml +++ b/.github/workflows/wheels.yml @@ -38,12 +38,22 @@ jobs: ############################# MACOS WHEELS ############################# # Building on macOS requires an installation of gcc since the default clang compiler # lacks certain features required for building the package - - name: Build wheels (macOS) + - name: Build wheels (macOS ARM) + uses: pypa/cibuildwheel@v2.17.0 + env: + CIBW_BEFORE_BUILD: brew install ninja + CIBW_ARCHS_MACOS: "arm64" + CIBW_TEST_COMMAND: 'python -c "import polyhedral_gravity"' + with: + package-dir: . + output-dir: dist + if: matrix.os == 'macos-latest' + - name: Build wheels (macOS x86_64) uses: pypa/cibuildwheel@v2.17.0 env: CIBW_BEFORE_BUILD: brew install ninja gcc@12 CIBW_ENVIRONMENT: "CC=gcc-12 CXX=g++-12" - CIBW_ARCHS_MACOS: "x86_64 arm64" + CIBW_ARCHS_MACOS: "x86_64" CIBW_TEST_COMMAND: 'python -c "import polyhedral_gravity"' with: package-dir: . From a0647d6b2ca63b2a94b73e7f14ca90ae0fe63b69 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Fri, 19 Apr 2024 18:19:40 +0200 Subject: [PATCH 39/54] remove "install check" [skip ci] --- .github/workflows/wheels.yml | 39 ++---------------------------------- 1 file changed, 2 insertions(+), 37 deletions(-) diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml index 725aabd..2b6b534 100644 --- a/.github/workflows/wheels.yml +++ b/.github/workflows/wheels.yml @@ -108,45 +108,10 @@ jobs: with: repository-url: https://test.pypi.org/legacy/ - # 3. Check if the package can be installed from testpypi - # Notice, that this is more of an installation test since the - # import check has already been done in the build_wheels job - check_testpypi: - needs: [upload_testpypi] - name: Test import on ${{ matrix.os }} with ${{ matrix.py }} - runs-on: ${{ matrix.os }} - if: always() - strategy: - fail-fast: false - matrix: - os: [windows-latest, ubuntu-latest, macos-latest] - py: - [ - 3.7.x, - 3.8.x, - 3.9.x, - 3.10.x, - 3.11.x, - 3.12.x, - pypy3.7, - pypy3.8, - pypy3.9, - pypy3.10, - ] - steps: - - uses: actions/checkout@v3 - - uses: actions/setup-python@v4 - with: - python-version: ${{ matrix.py }} - - name: Install package from testpypi - run: pip install --index-url https://test.pypi.org/simple/ polyhedral-gravity - - name: Check import - run: python -c "import polyhedral_gravity" - - # 4. Upload the wheels to the actually Python Package Index + # 3. Upload the wheels to the actually Python Package Index # using trusted publishing upload_pypi: - needs: [build_wheels, make_sdist, check_testpypi] + needs: [build_wheels, make_sdist, upload_testpypi] environment: name: pypi url: https://pypi.org/p/polyhedral-gravity From 927b2033d36d30e326d5dcadd133f7ebd6a98edf Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Sat, 20 Apr 2024 01:25:16 +0200 Subject: [PATCH 40/54] include arm64 for macOS in PyPi pipeline - aarch64 not working due to failure in x86 pipeline, dedicated aarch64 not available in GitHub runners at the moment - arm64 working with Apple Clang compiler instead of gnu --- .github/workflows/wheels.yml | 2 +- setup.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml index 2b6b534..eef7ba1 100644 --- a/.github/workflows/wheels.yml +++ b/.github/workflows/wheels.yml @@ -29,7 +29,7 @@ jobs: env: CIBW_BEFORE_BUILD: yum makecache && yum install -y gcc-c++ cmake && pip install ninja CIBW_BUILD: "*manylinux*" - CIBW_ARCHS_LINUX: "x86_64 aarch64" + CIBW_ARCHS_LINUX: "auto64" CIBW_TEST_COMMAND: 'python -c "import polyhedral_gravity"' with: package-dir: . diff --git a/setup.py b/setup.py index 0e35bdb..aaa5f30 100644 --- a/setup.py +++ b/setup.py @@ -175,7 +175,7 @@ def build_extension(self, ext): # -------------------------------------------------------------------------------- setup( name="polyhedral_gravity", - version="3.0rc4", + version="3.0", author="Jonas Schuhmacher", author_email="jonas.schuhmacher@tum.de", description="Package to compute full gravity tensor of a given constant density polyhedron for arbitrary points " From de561970af20b30dffc2a24a2c4eb150d4dd3b6d Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Sun, 21 Apr 2024 18:48:04 +0200 Subject: [PATCH 41/54] update runtime measurements and add a plot --- docs/background/evaluable_vs_evaluate.rst | 32 ++++----- docs/background/rational.rst | 2 +- docs/conf.py | 2 +- docs/figures/runtime_measurements.png | 3 + script/time.py | 83 ++++++++++++----------- 5 files changed, 65 insertions(+), 57 deletions(-) create mode 100644 docs/figures/runtime_measurements.png diff --git a/docs/background/evaluable_vs_evaluate.rst b/docs/background/evaluable_vs_evaluate.rst index 100acd2..9611d18 100644 --- a/docs/background/evaluable_vs_evaluate.rst +++ b/docs/background/evaluable_vs_evaluate.rst @@ -7,27 +7,25 @@ The :code:`GravityEvaluable` was introduced with version :code:`v2.0`. Hence, the `project report `__ does not contain any further details. This sections closes the knowledge gap and presents a runtime comparison. -Below is a comparison of the performance of the standalone free function and the evaluable class. -The benchmark was conducted with a M1 Pro 10-Core CPU (ARM64) using the TBB backend. +Below is a comparison of the performance of the standalone free function and the evaluable class, as of :code:`v3.0`. +The benchmark was conducted with a M1 Pro 10-Core CPU (ARM64) using the *TBB backend*. The calculation consisted each of 1000 points for the mesh of Eros (24235 vertices and 14744 faces). -The results are shown in the table below (the lower the better/ faster). +The points are either handed over one-by-one as :math:`(3)`-arrays or as one :math:`(1000, 3)`-array. +The former user case appears when the latter locations are unknown beforehand - like in a trajectory propagation scenario. +The results are shown in the plot below (the lower the better/ faster). + Basically, as soon as you have more than one point to evaluate, the evaluable class is faster and thus recommended. This result comes from the fact that the polyhedral data is cached on the C++ side and thus does not need to be converted from Python to C++ for every call. Further, the evaluable class also caches the normals and the volume of the polyhedron, which is not the case for the standalone function. +As of :code:`v3.0`, the evaluate free function is nearly as good as the :code:`GravityEvaluable` if all points are +known beforehand, since the :code:`Polyhedron` class and its construction are now separated from the +evaluation of the gravity model. -+----------------------------------------+-------------------------------+ -| Test | Time Per Point (microseconds) | -+========================================+===============================+ -| Free Function (1000 times 1 point) | 7765.073 | -+----------------------------------------+-------------------------------+ -| Free Function (1 time 1000 points) | 275.917 | -+----------------------------------------+-------------------------------+ -| GravityEvaluable (1000 times 1 Point) | 313.408 | -+----------------------------------------+-------------------------------+ -| GravityEvaluable (1 time 1000 Points) | 253.031 | -+----------------------------------------+-------------------------------+ +.. image:: /../_static/runtime_measurements.png + :align: center + :width: 100% + :alt: Runtime Measurements for the mesh of (433) Eros in :code:`v3.0` -As takeaway, one should always use the :code:`GravityEvaluable` due to its caching -properties. The free function should only be used for few points/ quickly trying -out something. \ No newline at end of file +If the scenario is yet to be determined, use the :code:`GravityEvaluable` due to its caching +properties. If you know all points "beforehand", the approach does not matter! \ No newline at end of file diff --git a/docs/background/rational.rst b/docs/background/rational.rst index 92a3a6d..175a28b 100644 --- a/docs/background/rational.rst +++ b/docs/background/rational.rst @@ -6,7 +6,7 @@ The Rational .. image:: /../_static/eros_010.png :align: center - :width: 400 + :width: 75% :alt: Downscaled mesh of (433) Eros to 10% of its original vertices and faces. Downscaled mesh of (433) Eros to 10% of its original vertices and faces. diff --git a/docs/conf.py b/docs/conf.py index 05b8341..ac67a83 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -75,7 +75,7 @@ def configure_doxyfile(input_dir, output_dir): # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". -html_static_path = ["_static", "figures/eros_010.png"] +html_static_path = ["_static", "figures/eros_010.png", "figures/runtime_measurements.png"] # Breathe Configuration breathe_default_project = "polyhedral-gravity-model" diff --git a/docs/figures/runtime_measurements.png b/docs/figures/runtime_measurements.png new file mode 100644 index 0000000..d91c365 --- /dev/null +++ b/docs/figures/runtime_measurements.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:52ad95f6696e14aa33a1a18e41e1e52d64ddd9a6a95694d40b9fe688f95a5719 +size 82140 diff --git a/script/time.py b/script/time.py index 912b703..cbfa3c7 100755 --- a/script/time.py +++ b/script/time.py @@ -5,10 +5,17 @@ import mesh_utility import timeit import pickle +from typing import Dict -def main(): - vertices, faces = mesh_utility.read_pk_file("/Users/schuhmaj/Programming/polyhedral-gravity-model/script/mesh/Eros.pk") +def run_time_measurements(sample_size: int = 1000) -> Dict[str, float]: + """Returns the RuntimeMeasurements for the four configurations as mapping. + + Returns: + a mapping from configuration name to runtime per point in microseconds + """ + results = dict() + vertices, faces = mesh_utility.read_pk_file("./mesh/Eros.pk") vertices, faces = np.array(vertices), np.array(faces) polyhedron = Polyhedron( polyhedral_source=(vertices, faces), @@ -17,48 +24,44 @@ def main(): ) # Generate 1000 random cartesian points - N = 1000 - computation_points = np.random.uniform(-2, 2, (N, 3)) + computation_points = np.random.uniform(-2, 2, (sample_size, 3)) - ######################################################################################################################## - # OLD - ######################################################################################################################## start_time = timeit.default_timer() - for i in range(N): + for i in range(sample_size): evaluate(polyhedron, computation_points[i]) end_time = timeit.default_timer() - delta = (end_time - start_time) / N * 1e6 + delta = (end_time - start_time) / sample_size * 1e6 # Print the time in milliseconds print("######## Old Single-Point ########") - print(f"--> {N} times 1 point with old interface") + print(f"--> {sample_size} times 1 point with old interface") print(f"--> Time taken: {delta:.3f} microseconds per point") + results[f"evaluate \n ${sample_size} \\times 1$ point"] = delta start_time = timeit.default_timer() evaluate(polyhedron, computation_points) end_time = timeit.default_timer() - delta = (end_time - start_time) / N * 1e6 + delta = (end_time - start_time) / sample_size * 1e6 # Print the time in milliseconds print("######## Old Multi-Point ########") - print("--> 1 time N points with old interface") + print(f"--> 1 time {sample_size} points with old interface") print(f"--> Time taken: {delta:.3f} microseconds per point") + results[f"evaluate \n $1 \\times {sample_size}$ points"] = delta - ######################################################################################################################## - # NEW - ######################################################################################################################## evaluable = GravityEvaluable(polyhedron) start_time = timeit.default_timer() - for i in range(N): + for i in range(sample_size): evaluable(computation_points[i]) end_time = timeit.default_timer() - delta = (end_time - start_time) / N * 1e6 + delta = (end_time - start_time) / sample_size * 1e6 # Print the time in milliseconds print("######## GravityEvaluable (Single-Point) #########") - print(f"--> {N} times 1 point with GravityEvaluable") + print(f"--> {sample_size} times 1 point with GravityEvaluable") print(f"--> Time taken: {delta:.3f} microseconds per point") + results[f"GravityEvaluable \n ${sample_size} \\times 1$ point"] = delta evaluable = GravityEvaluable(polyhedron) @@ -66,35 +69,39 @@ def main(): evaluable(computation_points) end_time = timeit.default_timer() - delta = (end_time - start_time) / N * 1e6 + delta = (end_time - start_time) / sample_size * 1e6 # Print the time in milliseconds print("######## GravityEvaluable (Multi-Point) ########") - print(f"--> 1 time {N} points with GravityEvaluable") + print(f"--> 1 time {sample_size} points with GravityEvaluable") print(f"--> Time taken: {delta:.3f} microseconds per point") + results[f"GravityEvaluable \n $1 \\times {sample_size}$ points"] = delta + return results - ######################################################################################################################## - # PICKLE SUPPORT - ######################################################################################################################## - +def create_plot(runtime_results: Dict[str, float], sample_size: int = 1000) -> None: + """Creates a bar chart plot with given runtime results dictionary""" + # Legend for X-axis + configurations = list(runtime_results.keys()) + # Figure of runtime measurements per call (in microseconds) + runtime_per_call = list(runtime_results.values()) - with open("evaluable.pk", "wb") as f: - pickle.dump(evaluable, f, pickle.HIGHEST_PROTOCOL) + # Create a numpy range equal to configurations list length + x_pos = np.arange(len(configurations)) - with open("evaluable.pk", "rb") as f: - evaluable2 = pickle.load(f) + fig, ax = plt.subplots(figsize=(7, 4)) + # Now, use the cmap to pick colors for each bar + ax.bar(x_pos, runtime_per_call, align='center', color=["darkorange", "gold", "navy", "blue"]) + ax.grid(True) + ax.set_xticks(x_pos) + ax.set_xticklabels(configurations) + ax.set_ylabel('Runtime per Point $[\mu s]$') + ax.set_title(f'Runtime Measurements (Sample Size = ${sample_size}$) of the Python Interface v3.0') - start_time = timeit.default_timer() - evaluable2(computation_points) - end_time = timeit.default_timer() - - delta = (end_time - start_time) / N * 1e6 - # Print the time in milliseconds - print("######## Pickle ########") - print(f"--> 1 time {N} points with GravityEvaluable") - print(f"--> Time taken: {delta:.3f} microseconds per point") + # Save the figure + plt.savefig("runtime_measurements.png", dpi=300) if __name__ == '__main__': - main() \ No newline at end of file + results = run_time_measurements() + create_plot(results) \ No newline at end of file From 79766050542b3d4bcb1cfbf6f4b2d628e83158a5 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Sun, 21 Apr 2024 18:55:59 +0200 Subject: [PATCH 42/54] removed Windows Test --- .github/workflows/build-and-test.yml | 4 ---- 1 file changed, 4 deletions(-) diff --git a/.github/workflows/build-and-test.yml b/.github/workflows/build-and-test.yml index 2317027..90f8701 100644 --- a/.github/workflows/build-and-test.yml +++ b/.github/workflows/build-and-test.yml @@ -32,10 +32,6 @@ jobs: - name: Test (Linux & macOS) run: cd build/test && ./polyhedralGravity_test if: matrix.os != 'windows-latest' -# Problems with resources (test file) location leads to test failure -# - name: Test (Windows) -# run: cd build/test/Release && .\polyhedralGravity_test.exe -# if: matrix.os == 'windows-latest' # Install the python interface & test that it is working using pytest build-and-test-python: From c3d97452787a42f2d2677acd8ba96fd2a4bdcda0 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Sun, 21 Apr 2024 19:01:04 +0200 Subject: [PATCH 43/54] Update README.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Pablo Gómez --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 90096b7..6904bad 100644 --- a/README.md +++ b/README.md @@ -60,7 +60,7 @@ which is strongly based on the former implementation in FORTRAN. > [!NOTE] > The [GitHub Pages](https://esa.github.io/polyhedral-gravity-model) of this project -contain the full extensive documentation of C++ Library and the Python Interface +contain the full extensive documentation of the C++ Library and Python Interface as well as background on the gravity model and advanced settings not detailed here! ## Input & Output (C++ and Python) From 5cf516ff0bbfc1ca413930860e1f2e5ae0a6004f Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Sun, 21 Apr 2024 19:01:32 +0200 Subject: [PATCH 44/54] Update README.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Pablo Gómez --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 6904bad..76bbf1f 100644 --- a/README.md +++ b/README.md @@ -61,7 +61,7 @@ which is strongly based on the former implementation in FORTRAN. > [!NOTE] > The [GitHub Pages](https://esa.github.io/polyhedral-gravity-model) of this project contain the full extensive documentation of the C++ Library and Python Interface -as well as background on the gravity model and advanced settings not detailed here! +as well as background on the gravity model and advanced settings not detailed here. ## Input & Output (C++ and Python) From 1ec4effc0af8384969c89c9c8ceebccddb21dc58 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Sun, 21 Apr 2024 19:01:54 +0200 Subject: [PATCH 45/54] Update README.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Pablo Gómez --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 76bbf1f..f791a01 100644 --- a/README.md +++ b/README.md @@ -120,7 +120,7 @@ cube_density = 1.0 computation_point = np.array([0, 0, 0]) ``` -We first, define a constant density Polyhedron from `vertices` and `faces` +We first define a constant density Polyhedron from `vertices` and `faces` ```python cube_polyhedron = Polyhedron( From 1aadac840cf5ce3eda8a39bca127215202b1c8c5 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Sun, 21 Apr 2024 19:05:53 +0200 Subject: [PATCH 46/54] Apply suggestions from code review MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Pablo Gómez --- README.md | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index f791a01..8d734ea 100644 --- a/README.md +++ b/README.md @@ -129,7 +129,7 @@ cube_polyhedron = Polyhedron( ) ``` -In case you want to hand over the polyhedron via a supported file format, +In case you want to hand over the polyhedron via a [supported file format](https://esa.github.io/polyhedral-gravity-model/quickstart/supported_input.html), just replace the `polyhedral_source` argument with *a list of strings*, where each string is the path to a supported file format. @@ -149,14 +149,15 @@ evaluations. This is especially useful if you want to compute the gravity for multiple computation points, but don't know the "future points" in advance. ```python -evaluable = GravityEvaluable(polyhedron=cube_polyhedron) +evaluable = GravityEvaluable(polyhedron=cube_polyhedron) # stores intermediate computation steps potential, acceleration, tensor = evaluable( computation_points=computation_point, parallel=True, ) +# Any future evaluable call after this one will be faster ``` -Note that the `computation_point` could also be (N, 3)-shaped array. +Note that the `computation_point` could also be (N, 3)-shaped array to compute multiple points at once. In this case, the return value of `evaluate(..)` or an `GravityEvaluable` will be a list of triplets comprising potential, acceleration, and tensor. @@ -166,8 +167,8 @@ This property is - by default - checked when constructing the `Polyhedron`! So, is impossible if not **explicitly** disabled to create an invalid `Polyhedron`. You can disable/ enable this setting via the optional `integrity_check` flag and can even automatically repair the ordering via `HEAL`. -As advanced user/ when you "know the mesh", -you want to disable this check (via `DISABLE`) due to the additional runtime overhead! +If you are confident that your mesh is defined correctly (e.g. checked once with the integrity check) +you can disable this check (via `DISABLE`) to avoid the additional runtime overhead of the check. ```python cube_polyhedron = Polyhedron( From 876b7df29c3e7918c758eb1a637b06a694280343 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Sun, 21 Apr 2024 19:09:00 +0200 Subject: [PATCH 47/54] add example for mesh files --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 8d734ea..92c14c1 100644 --- a/README.md +++ b/README.md @@ -131,7 +131,7 @@ cube_polyhedron = Polyhedron( In case you want to hand over the polyhedron via a [supported file format](https://esa.github.io/polyhedral-gravity-model/quickstart/supported_input.html), just replace the `polyhedral_source` argument with *a list of strings*, -where each string is the path to a supported file format. +where each string is the path to a supported file format, e.g. `polyhedral_source=["eros.node","eros.face"]` or `polyhedral_source=["eros.mesh"]`. Continuing, the simplest way to compute the gravity is to use the `evaluate` function: From a0c136385cfecf14a41ef73846f844e6c9d51755 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Sun, 21 Apr 2024 19:10:52 +0200 Subject: [PATCH 48/54] Update README.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Pablo Gómez --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 92c14c1..1d8432a 100644 --- a/README.md +++ b/README.md @@ -175,7 +175,7 @@ cube_polyhedron = Polyhedron( polyhedral_source=(cube_vertices, cube_faces), density=cube_density, normal_orientation=NormalOrientation.INWARDS, # OUTWARDS (default) or INWARDS - integrity_check=PolyhedronIntegrity.VERIFY, # AUTOMATIC (default) == VERIFY, DISABLE or HEAL + integrity_check=PolyhedronIntegrity.VERIFY, # VERIFY (default), DISABLE or HEAL ) ``` From e9c32f44ad25a6e6eb0662da2ddbc7adece5c1c3 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Sun, 21 Apr 2024 19:13:53 +0200 Subject: [PATCH 49/54] Apply suggestions from code review MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Pablo Gómez --- docs/conf.py | 2 +- src/polyhedralGravity/model/Polyhedron.cpp | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/conf.py b/docs/conf.py index ac67a83..5772225 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -30,7 +30,7 @@ def configure_doxyfile(input_dir, output_dir): file.write(filedata) -# If you bild the docs locally, but not via CMake, first set the environment variable BUILD_DOCS_CLI +# If you build the docs locally, but not via CMake, first set the environment variable BUILD_DOCS_CLI breathe_projects = {} if any([ os.environ.get("READTHEDOCS", None), diff --git a/src/polyhedralGravity/model/Polyhedron.cpp b/src/polyhedralGravity/model/Polyhedron.cpp index ba3ee58..a6780da 100644 --- a/src/polyhedralGravity/model/Polyhedron.cpp +++ b/src/polyhedralGravity/model/Polyhedron.cpp @@ -137,7 +137,7 @@ namespace polyhedralGravity { "The mesh check is enabled and analyzes the polyhedron for degnerated faces & " "that all plane unit normals point in the specified direction. This checks requires " "a quadratic runtime cost which is most of the time not desirable. " - "Please explcity set the inetgrity_check to either VERIFY, HEAL or DISABLE." + "Please explicitly set the integrity_check to either VERIFY, HEAL or DISABLE." "You can find further details in the documentation!"); // NO BREAK! AUTOMATIC implies VERIFY, but with a info mesage to explcitly set the option case PolyhedronIntegrity::VERIFY: @@ -153,13 +153,13 @@ namespace polyhedralGravity { if (violatingIndices.empty()) { sstream << "Instead all plane unit normals are pointing " << actualOrientation - << ". You can either reconstruct the polyhedron with the ortientation set to " << actualOrientation + << ". You can either reconstruct the polyhedron with the orientation set to " << actualOrientation << ". Alternativly, you can reconstruct with the inetgrity_check set to HEAL"; } else { sstream << "The actual majority orientation of the polyhedron's normals is " << actualOrientation << ". You can either:\n 1) Fix the ordering of the following faces:\n" << violatingIndices << '\n' - << "2) Or you reconstruct the polyhedron using the inetgrity_check set to HEAL."; + << "2) Or you reconstruct the polyhedron using the integrity_check set to HEAL."; } // In case of HEAL, don't throw but repair if (integrity != PolyhedronIntegrity::HEAL) { From d212ab0fe52a442606c1b458b945b4c4f98b83b4 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Sun, 21 Apr 2024 19:16:00 +0200 Subject: [PATCH 50/54] spelling --- docs/background/mesh_integrity.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/background/mesh_integrity.rst b/docs/background/mesh_integrity.rst index a624473..dd9dda9 100644 --- a/docs/background/mesh_integrity.rst +++ b/docs/background/mesh_integrity.rst @@ -66,7 +66,7 @@ for the construction of a polyhedron in the form of the enum :code:`PolyhedronIn +-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------+----------------+ | :code:`PolyhedronIntegrity` | Meaning | Invalid Polyhedron Possible| Overhead | +=============================+=========================================================================================================================================================================================================================+============================+================+ -| :code:`AUTOMATIC` (default) | Throws an Exception if the :code:`NormalOrientation` is different or inconsistent than specified AND Prints a short-version of the above explaination to :code:`stdout` informing the user about :math:`O(n^2)` runtime | NO | :math:`O(n^2)` | +| :code:`AUTOMATIC` (default) | Throws an Exception if the :code:`NormalOrientation` is different or inconsistent than specified AND Prints a short-version of the above explanation to :code:`stdout` informing the user about :math:`O(n^2)` runtime | NO | :math:`O(n^2)` | +-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------+----------------+ | :code:`VERIFY` | Throws an Exception if the :code:`NormalOrientation` is different or inconsistent than specified | NO | :math:`O(n^2)` | +-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------+----------------+ From 0d4ab9a5e92ff28992e276c219dd14c4c9259a35 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Sun, 21 Apr 2024 20:10:25 +0200 Subject: [PATCH 51/54] remove -1 acc multiplication --- script/cube_plots.py | 1 - script/eros_plots.py | 3 --- script/polyhedral-gravity.ipynb | 14 +++++--------- script/torus_plots.py | 3 --- 4 files changed, 5 insertions(+), 16 deletions(-) diff --git a/script/cube_plots.py b/script/cube_plots.py index e899d70..6d5a848 100644 --- a/script/cube_plots.py +++ b/script/cube_plots.py @@ -64,7 +64,6 @@ # We just want a slice of x, y values for z = 0 accelerations = np.array([i[1][:] for i in gravity_results]) acc_xy = np.delete(accelerations, 2, 1) -acc_xy = -1 * acc_xy mesh_plotting.plot_quiver(X, Y, acc_xy, "Acceleration in $x$ and $y$ direction for $z=0$", "../figures/cube/cube_field.png", plot_rectangle=True) diff --git a/script/eros_plots.py b/script/eros_plots.py index 70c1e9c..b256360 100644 --- a/script/eros_plots.py +++ b/script/eros_plots.py @@ -44,7 +44,6 @@ # We just want a slice of x, y values for z = 0 accelerations = np.array([i[1][:] for i in gravity_results]) acc_xy = np.delete(accelerations, 2, 1) -acc_xy = -1 * acc_xy mesh_plotting.plot_quiver(X, Y, acc_xy, "Acceleration in $x$ and $y$ direction for $z=0$", "../figures/eros/eros_field_xy.png", vertices=vertices, coordinate=2) @@ -71,7 +70,6 @@ # We just want a slice of x, y values for z = 0 accelerations = np.array([i[1][:] for i in gravity_results]) acc_xy = np.delete(accelerations, 1, 1) -acc_xy = -1 * acc_xy mesh_plotting.plot_quiver(X, Z, acc_xy, "Acceleration in $x$ and $z$ direction for $y=0$", "../figures/eros/eros_field_xz.png", labels=('$x$', '$z$'), @@ -99,7 +97,6 @@ # We just want a slice of x, y values for z = 0 accelerations = np.array([i[1][:] for i in gravity_results]) acc_xy = np.delete(accelerations, 0, 1) -acc_xy = -1 * acc_xy mesh_plotting.plot_quiver(Y, Z, acc_xy, "Acceleration in $y$ and $z$ direction for $x=0$", "../figures/eros/eros_field_yz.png", labels=('$y$', '$z$'), diff --git a/script/polyhedral-gravity.ipynb b/script/polyhedral-gravity.ipynb index d4616a5..403169c 100644 --- a/script/polyhedral-gravity.ipynb +++ b/script/polyhedral-gravity.ipynb @@ -406,7 +406,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdcAAAHWCAYAAAAl2MNkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOxdd3hVtRv+WlbL3nvvPWQjQ0BAUBwMNxsURBERRUAU2W4URIZMEUT2XrL3KBvKKLQFOikt3eOO7/fH6+He9iY5l59XoJr3efqgzdckJyfJl+TkfT8vZmbS0NDQ0NDQ8Bi8H3UFNDQ0NDQ0/m3QzlVDQ0NDQ8PD0M5VQ0NDQ0PDw9DOVUNDQ0NDw8PQzlVDQ0NDQ8PD0M5VQ0NDQ0PDw9DOVUNDQ0NDw8PQzlVDQ0NDQ8PD0M5VQ0NDQ0PDw9DOVUNDQ0NDw8PQzlVDQ0NDQ8PD0M71McSPP/5IXl5eVLt27UddFSIiWrRoEXl5eVFQUNAjKf/w4cM0fvx4unfvnkvao6zbo26XR4Xx48eTl5fXY1P2o3wPsr75qPvGihUrqFatWuTr60teXl505syZR1KPfxIJCQk0fPhwKlmyJPn4+FD9+vXp999/f9TVug/tXB9DLFiwgIiILl68SMeOHXvEtXn0OHz4MH3xxRdC5/rss8/SkSNHqESJEg+9Xo+ybA0HHuV7kPXNR1mnO3fuUK9evahSpUq0bds2OnLkCFWtWvWh1+OfRrdu3Wjx4sX0+eef09atW6lx48b02muv0bJlyx511YiIKOujroBGepw8eZLOnj1Lzz77LG3evJnmz59PTZs2fdTV8iiSkpIoZ86cHsmrSJEiVKRIEY/klZnK1nDAnffgyT7nDh5l37h69SpZLBZ68803qU2bNh7J82G3nxm2bNlCO3fupGXLltFrr71GRERt27al4OBg+uijj+iVV16hLFmyPNI66p3rY4b58+cTEdG0adOoRYsW9Pvvv1NSUpKL3eXLl+m1116jYsWKUY4cOahs2bLUu3dvSk1NfSCba9eu0euvv05FixalHDlyUI0aNeinn35yq67u/K1xjHfq1Cnq0aMHFShQgCpVqkRERAEBAdSvXz+qUqUK5cyZk0qVKkVdu3al8+fPp/v7jz76iIiIKlSoQF5eXuTl5UV79+4lIvnx28GDB6l9+/aUJ08eypkzJ7Vo0YI2b94srNvFixfptddeo3z58lGxYsWof//+FBsba/r8Gcv+u/mFhYVR7ty56dVXX033+02bNlG2bNlo7Nix0r91py3/n+fevHkz1a9fn3LkyEEVKlSgb775xvQ5DHTr1o1Kly7t8nur1Ur169enDh06KP/e3bJl70HU54jc7/Nm40fVNx9Vv+zbty+1bNmSiIheeeUV8vLyoqeeeur/Kl/Wfhnh7+9//9kz/uTLl4/+iaima9eupdy5c1PPnj3T/b5fv34UGhr6WJz46Z3rY4Tk5GRavnw5NW7cmGrXrk39+/engQMH0sqVK6lPnz737c6ePUstW7akwoUL04QJE6hKlSoUFhZGGzZsoLS0NMqRI4dbNpcuXaIWLVpQ2bJl6dtvv6XixYvT9u3badiwYRQVFUWff/65tK4P+rfdunWjV199lQYPHkyJiYlERBQaGkqFChWiadOmUZEiRSg6OpoWL15MTZs2pdOnT1O1atVo4MCBFB0dTTNmzKA1a9bcP2arWbOmtG779u2jDh06UN26dWn+/PmUI0cOmjVrFnXt2pWWL19Or7zySjr77t270yuvvEIDBgyg8+fP0+jRo4nIcTz/oPh/8ytRogR9/PHH9yfthg0b0t69e6lnz540ZMgQmjx5svRv3WnLB63nrl276IUXXqDmzZvT77//Tjabjb766iuKiIhwqx1at25Na9eupeDgYCpXrtz933/33Xd0+fJlWrlypfRv/27ZROI+526/dWf8qPqm6Fvrw+iX48aNoyZNmtDQoUNpypQp1LZtW8qbN+//Vb6o/UQoWbIkHTlyJN3v/vzzTxo3bhz179/f5Rs5M5PNZpPm54ysWcUu6sKFC1SjRg2X9Lp1695Pb9GihVtl/GNgjccGS5YsYSLi2bNnMzNzfHw8586dm1u1apXOrl27dpw/f36OjIyU5uWOTadOnbh06dIcGxub7vfvvvsu+/j4cHR0NDMzL1y4kImIAwMDH/hvP//8cyYi/uyzz0yf32q1clpaGlepUoU/+OCD+7//+uuvXco3IKpbs2bNuGjRohwfH58u79q1a3Pp0qXZbrenq9tXX32VLs933nmHfXx87tvJkLHsv5sfM3NiYiKXLFmS27dvz8ePH+c8efJwv3793PpbZ8ja8kHq2bRpUy5ZsiQnJyfft4mLi+OCBQuyO1OHn58fExEvW7bs/u9u3LjBOXPm5AkTJij/9kHKlr0HUZ9zt9+6M36Y5X3zUfbLPXv2MBHxypUr0/3+Qct3Z8yKsHbtWs6RIwePHDlSWT93fkRjnpm5SpUq3KlTJ5ffh4aGMhHxlClT/q+6exL6WPgxwvz588nX1/f+saBx7HHgwAG6du0aEeHbx759++jll1+WftNxxyYlJYV27dpFL730EuXMmZOsVuv9ny5dulBKSgodPXrUY3/bvXt3l3ysVitNmTKFatasSdmzZ6esWbNS9uzZ6dq1a+Tv7+92uzkjMTGRjh07Rj169KDcuXPf/32WLFmoV69edPv2bbpy5Uq6v3n++efT/X/dunUpJSWFIiMj/686/J38cubMSZMmTaJdu3ZR27ZtqXPnzjRv3jzT27n/T1uq6pmYmEgnTpygbt26kY+Pz32bPHnyUNeuXU2fg4iofv36lDdvXjp06ND93w0ZMoTKlClDo0aNkv6dJ8omcu1z7vZbd8bPg+JR98v/p3zRmDXDr7/+Sj179qRPP/2Uvv76a6FNw4YN6cSJE279lCxZUlqWakw8qtvsztDHwo8JAgICaP/+/dS9e3di5vu3D3v06EELFy6kBQsW0NSpUykmJoZsNpvwW5YBd2zu3r1LVquVZsyYQTNmzBDaREVFeexvRbcmR4wYQT/99BONGjWK2rRpQwUKFCBvb28aOHAgJScnS+uuQkxMDDGzsDxjoN69ezfd7wsVKpTu/3PkyEFE9H/X4e/mZ9zs9PLyokWLFrl1MeP/aUtVPS0WC9ntdipevLjL34l+J4K3tze1aNGCDh8+TEREv/32G23fvp327NlD2bNnl/5dTEzM3y6byLXPudtv3Rk/D4pH3S//n/If9KbzzJkzafjw4TR9+nR69913pXa5c+em+vXru5Wn7Fi4UKFCLvUlIoqOjiYiooIFC7qV/z8J7VwfEyxYsICYmVatWkWrVq1ySV+8eDFNmjSJChYsSFmyZKHbt29L83LHpkCBAvdXrUOHDhXaVKhQwWN/K1pJLl26lHr37k1TpkxJ9/uoqCjKnz+/tO4qGE4lLCzMJS00NJSIiAoXLvx/5f0wcObMGXruuefoySefpEOHDtGCBQukbewMT7dlgQIFyMvLi8LDw13SRL+ToXXr1jRu3Di6efMmjRgxgvr06ZPugs0/WXbGPuduv82ZM6fp+HlQPOp++f+U/yC7v8mTJ9P48eNpwYIF1Lt3b6Xtvn37qG3btm7lGxgYSOXLl3f5fZ06dWj58uVktVrTOWDjAt/joBGgnetjAJvNRosXL6ZKlSrRL7/84pK+adMm+vbbb2nr1q303HPPUZs2bWjlypU0efJk4YD09fU1tcmZMye1bduWTp8+TXXr1lXuJDz5t87w8vK6vxo3sHnzZgoJCaHKlSvf/92DrNhz5cpFTZs2pTVr1tA333xDvr6+RERkt9tp6dKlVLp06ceW83flyhXq1KkTNW/enNavX089e/ak8ePH05tvvkn58uVT/q27bekucuXKRU2aNKE1a9bQ119/ff94Nj4+njZu3Oh2Pq1btyabzUbPPfcc2Ww2t24be6rsjHiQfms2fgy42zcfdb/8J8v/6KOPaMaMGbRy5Up68cUXTe2NY2F3IDsWfumll2jevHm0evXqdBexFi9eTCVLlnws6IvauT4G2Lp1K4WGhtKXX34pXNXXrl2bZs6cSfPnz6fnnnuOvvvuO2rZsiU1bdqUPvnkE6pcuTJFRETQhg0baM6cOZQnTx63bH744Qdq2bIltWrVioYMGULly5en+Ph4CggIoI0bN9Lu3buldf47f2vgueeeo0WLFlH16tWpbt265OfnR19//bXLcVydOnXul9mnTx/Kli0bVatWjfLkySPMd+rUqdShQwdq27YtjRw5krJnz06zZs2iCxcu0PLlyx+L7zEZERQURE8//TRVq1aNVq9eTdmyZaNp06ZR7dq1acqUKfTll18q/97dtnwQTJw4kZ555hnq0KEDffjhh2Sz2ejLL7+kXLly3T9+M0Pjxo3J19eXzp8/TwsWLHB7d+aJskVwt9+6M36I5H1ThEfdL/+J8ocPH04//PADTZw4kYoXL57urkWJEiXS3RI3kCdPHmrUqNHfepbOnTtThw4daMiQIRQXF0eVK1em5cuX07Zt22jp0qWPnONKRPq28OOAF198kbNnz668mfjqq69y1qxZOTw8nJmZL126xD179uRChQpx9uzZuWzZsty3b19OSUm5/zfu2AQGBnL//v25VKlSnC1bNi5SpAi3aNGCJ02adN9GdPPR3b81bh7euXPH5ZliYmJ4wIABXLRoUc6ZMye3bNmSDxw4wG3atOE2bdqksx09ejSXLFmSvb29mYh4z549yrodOHCA27Vrx7ly5WJfX19u1qwZb9y4MZ2NrG6yPDNCdkv1QfMLDQ3lSpUq8RNPPOFyi3XQoEGcI0cO07o8SFs+SD03bNjAdevWvd9/pk2bdv/v3YHFYuGSJUtyq1atHvjGs7tlu/seDLjTb5ndGz/M4r75KPul7Lbw3y0/I+x2O+fNm1d60/f7779X/v3fRXx8PA8bNoyLFy/O2bNn57p16/Ly5cv/0TIfBF7M/wDDV0NDQ4OIvvnmGxo7diydOXOGatSo8airo6Hx0KCPhTU0NDyKpKQkOnv2LJ04cYLGjh1LkydP1o5V4z8H7Vw1NDQ8ih07dtBLL71ExYsXpzFjxtDIkSMfdZU0NB469LGwhoaGhoaGh6EVmjQ0NDQ0NDwM7Vw1NDQ0NDQ8DO1cNTQ0NDQ0PAx9ockN2O12Cg0NpTx58jyWAgQaGhoaGg8HzEzx8fFUsmRJ8vaW70+1c3UDoaGhVKZMmUddDQ0NDQ2NxwS3bt1SKqBp5+oGDKmzW7du3Q88rKGhoaHx30NcXByVKVNGKr9qQDtXN2AcBefNm1c7Vw0NDQ0N00+E+kKThoaGhoaGh6Gdq4aGhoaGhoehnauGhoaGhoaHoZ2rhoaGhoaGh6Gdq4aGhoaGhoehnauGhoaGhoaHoZ2rhoaGhoaGh6Gdq4aGhoaGhoehnauGhoaGhoaHkamc69SpU6lx48aUJ08eKlq0KL344ot05coV07/bt28fNWzYkHx8fKhixYo0e/bsh1BbDQ0NDY3/KjKVc923bx8NHTqUjh49Sjt37iSr1UodO3akxMRE6d8EBgZSly5dqFWrVnT69GkaM2YMDRs2jFavXv0Qa66hoaGh8V9CpnKu27Zto759+1KtWrWoXr16tHDhQrp58yb5+flJ/2b27NlUtmxZmj59OtWoUYMGDhxI/fv3p2+++eYh1vy/C2ZzG7vd3MZiMbdJSVGnp6XhR4XYWPP63LljXpewMHObW7fMbQIDzW0CAtTp8fFEoaHm5aSmqm0uXzavizs2bhw2mT4Ts3nbWCzm7+HePaKkJLWNO+/73j1zm4QEcxuzPkzk3lgw68PujEuNv4dM5VwzIjY2loiIChYsKLU5cuQIdezYMd3vOnXqRCdPniSLpJempqZSXFxcup+/C2aigwfVnToxkejoUXU+166ZT04HDhBFRKht1qxRTyrMRL/8QmSzyW3u3iVavFhdzrFjRH/+qbZZvpzo0iW1zTffEEVGqm0++UTtILy8iN59V/0OgoJQlgrbthFt2KC2mTmT6OJFtc2YMeaT8rvvqifKu3eJPvtMncfp00QLFqhttmwh2rpVbfPDD+h/KowYoZ7809Jgo8LNm0Rffqm22bWLaO1atc3PPxNduKC2GT2aSDW87Xai995T5xEXh3epwvXraD8V9u0jWrdObbNokXqsMBNNmqR20mlp5n08Otp8bF+/bj62jx0junpVbbN1q3oustthoxq3KSlEhw6py4mONp9nPIlM61yZmUaMGEEtW7ak2rVrS+3Cw8OpWLFi6X5XrFgxslqtFBUVJfybqVOnUr58+e7/eCKWq5cXHOcff8htcuUimjFD7WDLlyfq2VO9EylThqh1a3WHtdmInn9e7jy9vNAR339fnkehQkSzZ+NHhnr1iLp1I9q7V25TsSJRmzbq3UqOHEQdOhDFxMhtQkKIevWSP1O2bESbNxN9/708jwIFMFHu3y+3yZ6daOBAtbNPTCR6+221Y7x6FROhDBYLJpU1a+Q2ly+jTwUHy21OnCCaN0+9UNq7l2jZMnk6M9GmTfiR4eZN1PfkSbnN+vVEO3eqF0E//EB0/ry6LuPGqXf+0dFE48er+8uhQ+i7qsXA9OnqSZsZfUG1u42NJeralcjXV25z7hzRCy8QlSsnt1mxgmjIEKIaNeQ248djoZQzpzjdZiN6/XX14jsxkahdO8xHMoSHEzVpQlStmtzm5EmiN94gqlRJbrNsGZy4rL5EGCOXL2NOEoGZaNAgIkXccrJaMTcULy638TQybci5d999l86dO0cHDx40tc0YGoj/WgLJQgaNHj2aRjgtr434fX8Xw4cTZTVp8QUL4EhkyJaN6MgRdccvXx4OWtVhX3gBDi1LFrnNiBFEZhH25s6FM5fB1xeTQtOmcpuGDYm++ko9CNu3J6pcGc5PhjffRPuoMHgwUf368vSCBYlee40od265TeHCRC++iOPWokXFNpUrY3Fz5w5RhrVdOhsiDHxRv4iMJGrRQu3Eo6KImjXDaYZsYk5NxTu6do2oenXXdGbY2O3Y1WTP7moTGEhUsiTKk+HCBbzLmzeJmjcX24SGYsEVEEBUq5Zrus2GnWDu3KiXaIiGhWGSzJdPXpfgYCwwVf07Pp7o2Wfliw5movz5iTp1kueRkoJnVY01Ly9M/qp+V6kSFrIqZ/X000Tffit+PwZ69cJzy5AlC9HkyeqFVq5cRAsXElWpIrcpXhwnZKqx37AhduOqd/Dqq0RdusjTiYg+/dT8ROqXX9TzZtasWNiZzb+ehBdz5jt9f++992jdunW0f/9+qlChgtK2devW1KBBA/rB6Uxm7dq19PLLL1NSUhJlM5uNCc41X758FBsbq+O5amhkIsgctIbG/wt3/UGmOhZmZnr33XdpzZo1tHv3blPHSkTUvHlz2rlzZ7rf7dixgxo1auSWY9XQ0Mi80I5V41EhUznXoUOH0tKlS2nZsmWUJ08eCg8Pp/DwcEpOTr5vM3r0aOrdu/f9/x88eDAFBwfTiBEjyN/fnxYsWEDz58+nkSNHPopH0NDQ0ND4DyBTOdeff/6ZYmNj6amnnqISJUrc/1mxYsV9m7CwMLp58+b9/69QoQJt2bKF9u7dS/Xr16eJEyfSjz/+SN27d38Uj6ChoaGh8R9Apvzm+rChv7lqPM4w+65ojHAzG7Mj1MfNRkPjUeBf+c1Vw3MwW1LZbOY2ZqIDRLjWb4boaHMbMzEAZnBUzcoJD1fbXL1qTvY/dgw3fFXYvVudTmTOKyXCDUcVLBZzmxs31PQYIqI9e8zbeOVKcwGD339XpxOp6WhEeJerVqltUlPN2+/OHdCQVLhyBRQuFQ4fNh8Lp06p04mI/P3NbcyEMZjN+7DFgpvQKiQlmQtNuDO+VbeODfxXt2/auT4k2O1E8+erRQPu3QPxXaUidOYMqC2qDrtqlZqnSQTqi0pNx8sL1AAVf+/ePaKhQ9WE9WPHiKZOVdf311/NJ9yJE5GXqr5Dhqi5j76+oNCo+L8xMeAtqup7+jTRtGnq+q5cqeanEhFNmWIuCPDee+qJ8sYN5KOqr5+fmotMBFEGs3ewZAmEUGSw28ERVtF1IiOJxo5Vl3PgAMpS4ZdfzEUDPvtMveCy20GRUfWHe/fQH1S76MuXzZ9pyxbzdzB9unpRZrejj6sWAwkJ4MGr6C+3bmHcqnihfn7mfXzDBsxFqvr+9BPmLBmSk0ENUs2LkZFE331nzhk3W9gdPmzeZzwJ7VwfEry9wYVTrbbz5wdHUDWB1asHLqxK9eSpp8DnVBHoGzYk6t1bvjr19oZIhEoIoVgxcCc//VReTsuWGKQqhaBWrcB3O3xYblO9OtFzz6knyzx5QNb/S7jLBb6+4D/26iV/psKFMWGo1HR8fEDWVzl7qxXqSqpJIyqK6IMP5I4xOhoToaouV65gd7Zvn9zGzw8Tj6ouZiISSUlwwBs3ym2OHMH7US3sFi6Eso9KxODrr9ULv6QkCAvcvi23OXsWHGxZXyCCsMaBA+pTiKFD1XWNjyd66SU1x/LsWaJXXlFzQtesQV9Q6OHQ5MkQXKhbV5xutxMNGID3LOPdpqSA4166tLycu3eJOndWc9OvXIFAhIoDvH07FKVU/N7Fi+E88+eX2/zwA3i1ssWA3Y62eeIJeR6pqVjcNGwot/E0Mq2IRGbEq6+af0eaPFm9ovTygsqQigxduDB2V6oB3749Vskqm/feA1FfVZ8FC1CeDNmzoxzZhECEwbd+vXowd+hAVLMmBDJk6N8fz6MSF/j4Yzhz2XsoUgS7g3bt5HmUKkX0zjuwlaFuXUxwsbHyieOJJzDhxsWJ63znDlHHjngm2TfIhAQ8j8pxZs8ONR1/f7G4Q2oqxEKyZMHEWqiQq82lS0SNG6sd0e3bsFEt6lJTseC6fl0srmEIcyQnywUtDIGIUqXk5SQnQxlMJe5QogScnqwvpKURPfOMuj95e8Mpqlh9tWtD/EEk4GGgc2fY1Kwpt3n7baKqVeVleXtD1lC1GPDxMZcbLFQIC7aSJeU21arh1ETUVwx07qwea0TYBJgdP0+apN61entj0aaap3LkgCN/mN/x9YUmN6AvNGloaGhoEOkLTRoaGhoaGo8M2rlqaGhoaGh4GNq5amhoaGhoeBjauWpoOMGdGwjucPvMgrIT4dKNGcx4wszqeKREuLxiVp+YGPNnd4ePrLrMZMCdwOLuhFB2h0PtieDjzObvXN9c0cgI7VwfEtwZfO7YmIkXEJlPKMzukczNxBTCw80n7atXzcnqZgIHROp4sER45u3b1TYGbUWF7dtxk1WFxYtxq1aF774zb5uJE83f+eefq9Pv3EFgdhVOnTIPLL5uHSg7KkyfruY9EyHOqtn7HjdOnZ6ailvzKoSHE82apbY5c8Y8qP3mzaDKqDBnjvp2LRH46SowEy1dqraxWMCHVSE+3ny8REaC0qdCUJD5PKHijBtQcZoNmM01RshDFex2zyxwHuYiSDvXhwSbjWj0aDWXMyoKFA8Vh/XkSVz9V3XqpUuJvvxS3mG9vECwX7pU3tl8fUEdOnBAXk7WrKCsqIKch4ZCuMGMY/nee+qFw9y56snUx4foo4+I/vxTblOiBOJ3mgVlf/FF9cIiJgZ8QtVAPXcO4g4qrFkDpyZDYiIcmqo/XL0KHqBqF+znZz7579tH9Ntvapt169STf3w8qFkXL8ptTp4Ev1S1W/z1V/PF1KRJ6kWQIcCh6nexsaC3qHDhAuIaq+Inr14NgRgVvvhCzUW2WsEbVTnFu3cR01WFS5fAc1fR47Ztg3iGj484nRlj7Ztv5HmkpBB98olaHSwyEpzya9fU9X3tNXX/3bUL71JGtbHZMJdNny7PIykJC16zBbgnoZ3rQ0LWrJjYVUdZRYqA86k6EmvWDBOTatJ4/XWinTvV+fTpA5UbmRPx8gLHUrUDK1wYXMPJk+WOplUr7BZVHb9LF+y+li+X27RqhQGmEm6oUQMB02VCE3nz4rleflm+mi5RAhNqv37yZ8qdG5OKytkzo13OnZPbxMdj4pZNLGFhmDg++0yex5UrmMQWL5bbnDqFiV0lv7dvH4QmZLuD4GCi8+fVIhLr1+NZVI5xzhws+mTKVDYbRCSuXJG3/40bWGyp5BqXLYMYi2rX9OGHarWjpCTwYL295RP7hQtEfftC5ECGdevgXKtWldt8/TVUvRo0EKfb7VBMu3RJLsqQkoJFX9mycn7v3bvgcaucdGAgThdefVVuYyjFqWwOH0Z/UIk7HDsGYRwZF5wZC7IePeQcVW9viI68+aa8HF9fzHUdO8ptPA0tIvEQ0bKluc1bb5nbzJihJkPnzEm0Y4eaVF2/PmxEJH0DAwfCoanKmjWLqGBBuU2WLBhk5crJ86hRA7JkIoEDA506waZJE7nNW28RDRumFpqYMAECD3nyiNNLlMDJgGpHU64cJubOneU2jRpBDCF3brnNk08SVa6MUwiRek90NBZktWphkvL1dbWxWLDwkO1CiCCC0Lo1Fh01arimR0RAFCBHDuwyRGIHly8jj5w54QBF8npJSZgoZbtSmw0LnDZtcORYr56rza1beJ6bN+EIRDuwqCioDJUtK3/m0qUxIcsmbZsNi7q0NLkoAzOcjEoyr0YNoh9/VI+Rrl2xs61WTW4zdCjGUZ064nRvb5xQ9OolF5Dx8cExt0pEolAhLAhUi46KFXEiUrCg3KZZM+Sj2tG/+CLaWIV+/dSfEby8IPyial8vL5xkqGCc1j1MaBEJN6BFJDT+CbgTzUZHhpFDR9fReBTQIhIaGo85zCZ97RTUcKd9dBtqPCpo56qhoaGhoeFhaOeqoaGhoaHhYWjnqvHYg9mcn2YmBEBkzlUkck8EwSyoOBFutJrBneDZqliYRLh9rqK+EOH2p1mdT50yb5+DB83fgypcogEVHc2AGR+ZyLxtmM3b2Go154QmJ5v3i7g4cw66O/3PnX6sb8lkDmjn+pCQlmY+cOLizAn4ERHmg0sV85QIZaiCdBPhRqaKX0kEmomKykAETp3ZxDR/vprQzgzOqIpEHhNjLjzg56eOK0sEzqIq5i4RboeePq22+fRTcHxVePddNb8vJQU2qvcdEIDA9yqcOAHalQqbNqlpNkSIh2nm0D76SE0BS03FDXQVQkLMxTOOHDF/puXL1bxnIrTdlStqm/ffV1PobDbcVFcFKE9IIBo1Sl1OWBjCzqlw5Yp5UPtjx9wTSzETQtmxQz0f2e1qahwR5jyz9k1KUt9wJgL10Ez0wh3lL3cWOJ6Cdq4PCVmzgoOm4iMyI26piugcEQFKhEpNZ88eouefl5Psvb1BoXn7bbkYRaFCuCY/aZKc51quHK7kL1smdwB584LnphqEcXF4Jpmj9vbGtf9XXpEPsKJF4aTHj5fXpWZNkOdVakUlS4K7p1p8+PiAK6tyIrGxmHBVjvH8eQSSlyEiAjSQTZvkNteuof2Dg+U2p06BF6raWZmJSFitEJBQOeCrV4mOHlXvXtesQX0iI+U233+v3o0zQ8AgPFxuExcHupRqMj13Dv1F5RR/+w2iF2Yxgs+elV+eSk1FbFlVfwkJgfiDjCJGhAVFixZElSrJbRYvBkWsVi1xusWCtvviC3ks1rt3MQY2b5bT+S5dAqVKJciyc6ect0uE97hwofq57XYsrAcPlseeTk0FBU/FO793D2NWJeThcbCGKWJjY5mIODY29m/lExDAfOSI2mbzZubLl9U206cz37olT7damQcOZI6Pl9sEBzO/9BKzxSK3WbaMuU8f5uRkuc3bbzO/8w5zaqo43W5nrlmTefhwZptNbBMYyOztzTxtmrycX37B4fCyZXKb115j9vFhPnRIblOkCHPJkszXr4vTz51DOfXrM8te9/ffw+aVV/B8InTtCpuFC+V18fVlzpED/UKEo0eRR61aeKciTJkCm/fek5fToQNs1q4Vp6emoi5ZszJHRYlt9u1DHo0aycv5/HPYfPyx3KZVK9hs3SpOv3uXOXduZi8veb/bsgV5PPmkvJwPPoDNuHHi9LQ0vGMi5j17xDaXLzPnyoW+KXvPq1YxZ8mCNpbBeEey/m2zMffqBZsTJ8Q2iYnMrVszFygg7wuRkcx16mBcyxAUxFypEvNPP8lt/P2Zy5ZlvnhRbnPsGHOLFmhHGXbtwntQYfNm5kWL1DYLFjBfuqS2+fln5qQkebrNpp47HgTu+gMtIvEQUamSetVJZE66JsIxlQpZsmCnoqIhlC1LtGqVWmiiZ0+HQo0MX3+tXm17eRHt3o2dpaw+5ctjF1GzpjyfZ57BkWTdunKbQYOgeNSokdzmyy9RXsWK4vSyZYlGjoQkm4zCVr48ditvvy3nUTZuDNWeNm3EedjtWLFXry7fUd67h/7QqBF2sSVLutr4+ECMonp15Cl6V9WrQzRAJj4QFARRBmbsgEU7moQESF1Wr44jUpF4QIUKEMUoXVpcTnw86pojh1wZ7PZt9LnISAhKVKniapMjB0RFSpUS52G3E7Vti2+pMiGElBQIRGzYIN8RlSsH2cgjR+R9t3t3qIvJ2pYI47VMGbSPCN7e+NTQvr28f+fMCaWny5flO+0iRYiOH0cbylCuHE6BVEes1avDRjWumzTBCZlMgIMI/eWpp+TpROjfZp+5+vVTpxNhZ6uCtzfG9MOEFpFwA1pEQuNB4Y5ABJEWkfg78JSIhG5njQeBu/5A71w1NP4BeEIgQk/4aniqDXU7a/wT0BeaNDQ0NDQ0PAztXDU0/gG487HFjHZFZM6dtFrN80lNNa+PO4HbPWVjFruTyL1g8+7ENnanjfWHMY1/Atq5avyjMJvcmM35a0lJ5hNyWJg5j/jSJfOAy+4IJaioMQaWLTO3mTdPnZ6cbM7lvHFDHVOTCHSeI0fUNitXmgtfzJqlppMQgTdq1n5ff61OZ0aoQxWsVvMYtQkJ5u/hzh1QRlQIClKHDiTCRSOzQPIXL5qPBzNBCyL3hE7MxhSRewsPjf8f2rk+JCQmmg+cmzfV/D8icATNJrjt29WDKzUVsRhVjiYoCIIKqoly+3bcBFZhxgzUWQYvL9zOVQW+zp4dHDVVgHiLheill9Q7p6Ag3ChWTSpHjoADqMLq1Wq+MhGe24xTN3as2qFFRoKHqQrcfv06eICq93T6tJoDSIS6mjmi1avVjshiwc1ZlSrS7duor2qxtH8/0ZIl6rosXGjevl98oRZCYcaN7+houU1qKm7Nq77LRkaCVy4Lb0eENhk6VH3zfv9+hERUYdUq9YKLmeinn9TiGVYr+OsqsZmkJKKpU9XzyN27RIsWqet78yaCnatw+bK50ISfnzpMHjNsVOPAZjMXxvEktHN9SMiVC6o9H34otylWDJSTGTPkNgUL4qr8unVym7Q0UH5kwg05coD0Xq8eRAhEKF8eE2WHDnLpvCefRMzM/v3l6igtWxI1bapWWKpenahhQ/kOLGtWUBGaNpVP3GXLQpThmWfki4/69TEpDxsmH4QVKmBSVk3uhQrh6r9qN5MlC4JoyyYEZkzq770nr0tkJCg4338vLycgAMGkVZPpqVPYmaoWboaIhKouR4+qRSR27sQCSOX05s3DAkglEjFlChYNsv6SmAgFJ9XznD+PdlMttpYsgaCIKqbx8OFoX5ngQnIyaEypqXJayvXroNmUKCEvZ8sW0ItkVBxDpaxnT9CMREhIIHrjDaLRo1GeCNeuIV7un3/K6Wi7dxPVro1xJIsT/NtvoEnJ2sU4fahXTx7H1m5H7OQePeR1SUsD3emHH+TUoIQEUIOOH5cvgkJCUA93VJw8Bs/Qav/d8JSIREwM89Wrahs/P+awMLXN+vVqG7sdhPWYGHVd3npLLv7AzLx7N/OQIeq6jB7NPGaMnGTPzNymDYQFZITz8HDmnDmRj4wgv3QpSPZffikv6803YfPrr+J0u525cGHmvHmZd+wQ2/j5IY+SJeXE9cmTYdOmjZy43ro1hBDGjhWnp6Qgj9y5IYogwqZNsClbFgIBIgwbBpuuXcXpzBChyJ4dbSfC7dsQSsienfnkSbHNwoUQmShZUv6O+vXDM7/6qjg9LQ0CBkQQBRHh5Em0CRGETkT49luIb1SrJk632SCkQMT87rtim9BQR102bBDbbN3qqEtKitjms8+Q/tRT4nSLhfmNN2AzZYrYJjYWfYmI+fRpsc3t28wNGjCXKCEXYwkKYq5dm7l3b3E6M8RnatRg/u03uU1gIHO9eswhIXKbM2fwnlXj/uBBvCsVdu2Sj0UDa9cyR0SobbZulbcLM+opE+h4ULjrD7RzdQOecq6PG1QDw0iXTaQGVKooBmSqP84ICFDXJyoKA1pls3u3uc38+XJ1IGbm6GioyuzaJbfZsIF5wgTmCxfkNr/9xjxggFxlKDERKjnvvy+v7/nzzF98gcWC7D34+TF37oxFmygfu535wAHmJk2YExLEedy5wzxrFhY39+6JbcLDmV9+GYo6snceE8NcpozcKaamMm/bxty/v3yRmZqKBcmsWfLJ3WqFM5O9R7sd/WngQObt28U2zMzr1jFPnIg2lOHbb+UqT0Z9f/wRPzJER2NxuH+/3ObuXdioxtu9e/LFjwGrlfnGDbVNQoJadY3ZPN0oywxmc0xmhLv+QItIuAEtIqGhoaGhQeS+P9DfXDU0NDQ0NDyMTOdc9+/fT127dqWSJUuSl5cXrVPd7CGivXv3kpeXl8vP5cuXH06FNTQ0NDT+c8h0zjUxMZHq1atHM2fOfKC/u3LlCoWFhd3/qSJSBNf4V8OdDyDuCBOoYnsaMIuVyWweCzchQR1WjQjpKioJEW4Um9X53DnzZzejOhCpaVcGzp41tzGLN0ykpm8ZMGtjIvN3ReTeO3en7+iPcP8dZDrn2rlzZ5o0aRJ169btgf6uaNGiVLx48fs/WVRBHDXcIpi7Q1RXcVONPG7dUtsEB5tPkocOmTuiZcvM6/PNN+Y84tGjzZ992DA1j9hqhY0K4eHmnNuLF9XULSLwJ5cvV9usXm0eWPynn8yd3ujRapEDZqJ33lE7maQkRDdSISLCPKD65ctE06erbY4eJVq6VG2zfbs6xjIR4tSaBZJ3p/+tXWs+9g4fVqczyyl2zjZmdXFH4IVZi1HIkOmc6/+LBg0aUIkSJah9+/a0Z88epW1qairFxcWl+/m7uHcPHEGVrNuFC5jgVJ110yZMCLLJiRnhq1RE/thYcG5VTu3cOaJRo9QT5R9/EE2erB6A06ZBwED2TD4+CCq+apU8j+LFwe07cEBuU7gwUfPmajJ6tmzg/6kmlcREBLZWvafgYKJ331U7iCNH1CpDaWmYkFW80Tt3wAtVfcG4fh0cQBXB/swZOEZVfffvVwdLt9sRPFtV39BQcF0PHZLb7NkD56ASVJk/Hzaq+o4frxbgYAYXWdUuCQlEb76pDpZ+4wZClRUuLLc5eJDo9dfV4SR/+41ozBiEhZPVd8oUPLtMaMJiAS9682Z5ObGxqMvp03KbW7fAzVUpSl24gIDpqgXigQMIvSjjljIjpN/ChfI8LBYsbmScfCK8p19+Udf3zh20saq+N2+aLyA9iodyd/kfAhHxWlkE6L9w+fJlnjt3Lvv5+fHhw4d5yJAh7OXlxfv27ZP+zeeff85E5PLzd6k4Y8YwP/us/Hq6zcbcrh3z4MHyPKKimIsVk3PmmBGQ3dtbzWX79lvmbNnkgaKZwRUsWFBOOUlOBu+xenVw40S4eBH8vVat5Nzc2bNhM2CAnC7y+uvgWc6YIaeclC6N+sqCpd+4gXLq1gX9RIQlS2Dz+uty3tygQbCZPVuczgwuYbZsct7i3bsODqssqP369bB54QV5OR9/DJuvvpLbtGwJG1m7pKQgyHzOnPK6HDmCPFq0kJfz7bewGTlSbtOtm3ng9jJlYCPjNvr7I0B55crychYtQh59+8ptBg6Ezbx54vTERPA9iRA4XYSLF5nz5wd/WoZff8V4lAUxt1qZ33kH5Xz/vdgmPNwRaF5GHTp8mLl8eYwBGS/3t9+Y8+RhfuYZeX1/+AHtK5tj7HZHvztwQP5Mr7yCusioeKmp6E+tWsnHWkICnumTT+T1jYxEUHsZX5kZc1ihQszXr8tt3IUOlv4XqlWrRtWcJEKaN29Ot27dom+++YZat24t/JvRo0fTCKdzqbi4OCpTpszfrssXX2AnKFvpeXtDNUbF9ilUCCtXmeoJEVGzZpA3fOYZuc277+L4rVkzuc3kyURz5hBVrSpO9/HByjUiAopOItSsSfTii1CeKV5cbPPqqzjiK1JEHri6Rw88U2go1HAyKsd4eUFNauFCyK01a+a6AyhfHkHbg4JwnCoKZF6lCna4ISFY4Zcr52pTtCgUtwICsPIWKfOULIkd7q1bUIbKiNRUBBUvVgxHeA0auNrcu4fdUO7c6DcFCrjaeHvj91mziuOS2u3YdZUrJ1c0unbN0Q+uXIFaVkaEhuJdli4tD5bu64sfWf9NTobCWOXK8tODgAAodhUujPdUtKirzc2bCJQu200y42g/b155f4qJwXMUKiRXIbp2DTuhXLnE9SDCMXlyMlHjxuL0lBQoVjHLbQIDcRpFRPT002KbuDiMs0qVxH2FCOpiOXJg5yp77qeeghrSBx+I0406tGkDuUYRvLygFOXtDQU2EbJkwSeC55+Xqzhlzw4VrTx55Lv1XLnwSUP2zESYN/z81HNirVrYjcvmoH8Ef9+PPzqQGztXESZNmsTVq1d32/7fKiLhDsxI4DLVJWeolKIMBAaqy0pMZD52zFxE4vRptc3+/VBEkq2U793DDmDZMnkeQUHMK1Yw790rt7lzBztc2W49JQViC6pdaVoaxBS++UZuY7Mxd+jAfPas3ObePaz+VVi0iHn4cLXNCy8wKw582GrFTkWF1ashIqHCgAHMGzfK35HNhpMBlYDJsWNQZ5LtxJnRtlu2yE8xmLEL9/eX96m7d5kXLGA+d06ex61b6CuqdxQWxrx8uXtjQAWbTS7iYeDePc+M63+jQIQ7+E+ISHh5edHatWvpxRdffKC/69GjB0VHR9NuM9X5v6BFJDQeZ9jtakF4ZlygkmnfEjkiCqlskpOx25B9o2SGTc6c6vrKdvsZ89JBzDUeR7jrDzLdsXBCQgIFBATc///AwEA6c+YMFSxYkMqWLUujR4+mkJAQWvKX8vr06dOpfPnyVKtWLUpLS6OlS5fS6tWrafXq1Y/qETQ0PAqVYyWCkzJzZmbpRDjyNSvHzLG6W5Z2rBqZHZnOuZ48eZLaOoWFML6N9unThxYtWkRhYWF00+kqYlpaGo0cOZJCQkLI19eXatWqRZs3b6YuXbo89LpraBhwZ2dms6lvshK5twtMTZV/gzOQkiL/9uhpG3fq485zudM+eges8aiQ6ag4Tz31FDECDqT7WfRXYMFFixbR3r1779t//PHHFBAQQMnJyRQdHU0HDhzQjjWTwZ0PFyrqjAEzXh+Re/EezQKPp6YS7dihtgkLM6cFXLpkHrP00CGERFNh82Y1nYcIdIjQULXNrFlqagsR0bffmgek//ZbdToR6EVmmD1bnc5M9Ouv5jabNqlt7HbHhSOVjdOBmrQsd8RF3OnLmfdj3n8Hmc65aqjhDqFbFajagDuqNWZEdavVnPB++7Z5wPXdu4mc1ktC/PKLmgdLhODPZpPk6NHqOK1EEH9QcSyzZyfq108dbzQtDTxMVbzRu3cRSF71Tm/cwK1uFU6dMg+WvmePudDEqlXqRYPNRvTzz2oFpnv3UF+VqtSVK3hXKuzbB06oCitWyGMEG5gxw7xvffEFbqPKwAzRCxXH2m6HeIYsNjIRduvDhuEWvwwpKeDDqvpEUhLi96qQmGi+KEtIMF9wJSSYC024IzbzbxSi0M71IeHOHQyK06flq85jx2CjmrjnzYPqjIxQzUz0/vuYeGSDNCEB9JhVq+S7jKAgCC7s3i2v7969RM8+K3dGWbOCWvTqq3CiIpQqBTrPO+/Id0VNm+JK/xdfyOvbrBnq+9cBhhA1a4JmoJpMS5Qg6thRLa2XIwdI+LL6enmBzD9ggLztLBaUMXGivJyoKEyAv/8ut7lxg2jdOgQHl+HMGbSLKnD7vn1qpSJ3gqXv3w8K0/79cptFi9AvVQ542jQ4X5mAid2ORYdqARgTg3FgXNQS4dw5oo8+Un8nXr2aaMIEUKtkmDQJO+2aNcXpVitR3754jzKbmBiizp1BEcufX2wTEEDUogWeW3YcfugQqF8yKUZmjPtatcR0KiK02c8/I6h6vnxim7g4zFUDBsiP+ENCiD75BHQbGS5dwoJCdorDjGcaNkwuemOxEG3dCmER2cYhIQELjsWL5XXxOP7pa8v/BniKirNwIegMqqC+/fsj6LTsmntSEnOdOswjRsjzuHqV2deXedIkuc2yZSCBz5kjtzHEEmRsJ4sFAauzZlULN2TJAgL3qVNim4ULUU6FCvIA5UYg9PbtxTFH7XbmUqVgM368uP0uX0Z6rlzy2JqzZsGmVi05RaNnT4dAgew9FSkCEYn588XphrhGgQKI2yqCIa5Ru7Y8vuZrr8FGRW8pXRqB0H/+WZx+4waCnGfPLhcMWbQI77FECXkcz7ffRj7du4vTbTYIeBAxf/ed2CYwkDlfPtjIglv//rtD9EKG4cORh0wsISmJuXlz2EybJrbx98d7JGI+elRss2QJBCJy5hSPa6uVuU8f5NGliziP27chxEIkDy6+aRPEH2QB1e12jHcvL+bixSHQkBE2G2IVE6EPi2C1OoK7y/pLWhrEbrJkkfeXpCQIcFSsCAqRCHFxEFF59VVxOjMEKAoWlNeFGdS4IkXUcXlPnWKuXx+xdf8udLB0D8KTPFeZApGBpCRzmxs3zDlmx4/LVVqY8fe//ioehAbu3IGjUnHe1qyBeorKpl8/KLrI6pycDLWdoUPleezYwVy0KOojw+DBcNA7dojT7XYE2S5bFgNbhH37mJ9+Wu2spk/HxLxli9zmyy+hpCVzijduICh4z57yxdbhw8y9emHxIXNoR4/imW/dEqdbLJiYGzaUcz7Dw5m//pp59Gg5JzksjPn556EaJeOXRkdDrUim1pWWhuDlzz4rX0SlpDCPGoX3HBAgf6a6dZnnzsV/ixAUxFypEvjIItjtzDNnYiGwfr3Yhhl94fXX5dzR0FColL31ljyPOXMwsU+dKrfp3BmO6MoVcXpyMhayjRrJx1FQEJz055/LyzlzhrlxY/wrw4kTeGbVmL54UR0gnhn9YNcutc2lS3IFJwPXr5vPdyqusgGzedVdaOfqQfyXRSTMYLfLJ34D7jTbjRvqdKsVg0xVVmQkc0iIelJISIDzlTkIiwVpX34pz8NuZ962Dbs5Fd5+Wz2JxcUx16ypnjgWL4YYggrPPqsWd0hKwm5GhV9/ZX7vPbWNmYhEWppaBpAZ8ntDhpiXo5qUExPh0FTttmYN8/vvq8sZPhwLGBlSUrAwtNnkZV25AvEHmZNnhnhEUJB6cg8KQv9VITXVXL4vMRGLJRXcGY9mY/q/jP+EiMTDghaR0PinYEYVSUvDt2sVlzUmBlJ/KlpKYCDk8WS4dw+Xq0qUkNsEB0NyUPatzrgxK5PLJMK3r+RkuYA9Eb7n5cihpuu4Q/nRNByNfwLu+gPtXN2Adq4aGhoaGkTu+wN9W1hD4y+4s8xMTTW3i401D5wdHm5OiQoMNLfx9ze3OX3anDt59Kg5P/XQIfNnV4WbM6AKL2bALDYqkZr6YsAsVjCRebB5IvfoJHqbouEM7Vw1Hinc4bfdu2duc+GCOp3ZnPOYkkI0c6baJj4e1AsVIiLUFBsiOM4vv1TbnD9vHgj9yBF1vEwiBPpeu1Zt88cf4Lqq8PPP5k5v4kQ57YrIQRVT8XttNqK331Y7q5QUxDZVIS4OlB0VoqOJxo1T29y9S/TVV+b5LFhgXh8zTndKirkYhc2GvFTQQcwfPbRzfYxgNhiYzVfQyclqEjoRiOFmNn5+6gmQGRxAMxGEmTPVO6vDhzFxqXZWv/8OUQHVbnD+fNjI2tDLCzbffCPPw9cXDmTOHLlNoULgYf7xh9wmTx44YBWf1maDzaVLcpvoaDgrVZDoGzdQHxWf88wZ80XDvn1qNSOrFVxClZpReDiCpavEPI4fx85VtRhatQp2Mp4rEXilZiIIY8ZgESMDM3iaqnLS0oi6dVP3z9hYok6d1N93IyIQ7k1lExwMbmlWhShtQAA436rv61euEH34oTydCIpdZupV/v5q8QzDxkz57Pp187nNHdGaTCdG8RAuV2V6eOK28K1b4GrOmCG/zbp7N4JJL1wop2d8/TXzyy/jNqToBqPNhiDFffsiP5HNvXvgoL37rjxU1vnz4DSOHg0engiLF+MW6jffyGkeQ4YwlysHPqDoBqLdztygAUKI7d4tziMmBrzdZs3A4RXhwAFHYHERD5YZ3EoicIRl7WvwRlU3gatWBc/y+HFxelwc8ihZUk4R2LPHEXxcVhcj+LiKovT667BZsEBuU60abGQ3l+/dA1czd275jdb9+5FH48bycqZPh83gwXKbXr1gM3euON1mA6+XiPnkSbFNRAQ4n15e8lutBw8i/Ykn5HWZORPlDBokTrfbQclS8cHj4/EOVfW9dg00Gx8fOTVrxw5wwZs0kdfl55/Bp5XdHk9MZB4zBvzqpUvFNrdvI0h8jhzyAPCnTzP36IEwhSKOqs3GvHUrc6dOzF27iueY5GTUoXVrOd8+OhrvoFkzULRECA1lnjwZ/HYZxcugtfXtK+fUXrgAju9XX/39UHnu+gO9c31IKF2a6K23oEwjEyRv2xZKQxcvym+HjhiBG5f+/uJVsLc3jhJ378bKXmSTLx/Rjz9CEm/XLnE5tWujvlOnyo8U33wTgZdHjpRL5332GXZevXtDji4jvLyww/D3J+rVS6yBmz8/0Wuv4bvguHHinXCLFlDR2bRJLtHXrh3+3bFDfvRWvz7a8MAB+Uq5QgXsemTyj7ly4TZsrlzynZPN5gjeHhIitrFaEeQ8b175zrR4cSgMye5VpKQQ1aiB9ynbHQQGQpWqbVsoc4kQG4u2qVMH0nkiFCqEwO4VK6qfp2JF+Q4jLAxlNGokl4+8dQsB1evUkX8yiItD+5cuLU632bDjKlBArkIUGYkfX1+iMmXENv7+qE+OHFA9EmH7dpwwPPmk+IZzfDxUjO7eRRByEU6eRN9PSoJsZkYwQ7N5yhQ88yuvuNokJGDM/vILUZ8+4uDicXEY96tW4ZRHpF4VHw+Z0MOHMYeI5hjjZMZiIRo1SvxMOXMSffcd+l3HjmKbvHlR348/xniR5bN1K055ZGpbWbPic8X77z/EG+R/z4f/N+BJnqsZf8xul69uDURHq1WemEHAN1uhHTig5uelpECxSMUbPX0aIhIqMYpx47BblHFLrVYIFPTtK2+f48exi+jWTV7OjBnMvXszT5woTrfZcCpQtizUd0Q4fx68xdat5e137RrqKtt9MTvEBWQ718RE7Aafflqeh8XC/NFHeC4Z7HaoSakCZAcHQ9VLhdmz8R5VMOO52u0QkVBh507silQYNgw7cVX/rVABwhay/nL2LAQXZDsZZubPPkNfkfFLbTaIMhw+LOeOHj8OrvLBg/Jyhg5F28rEKpKS8DzjxoHvKsKVKxAuUXGR9+5lfukljFmVTdu24IPLcOYM84cfqts/JAQqbyrcvCkXAjEQFKSeg5gRkN4MZnMms+e4u1pEwoPQIhJqmDn6hARzRy9zvM6wWtUDxG7HkazZYNy3T37UbeQzapSa9H/qlLm4w7vvMq9cKU+3WKA6pXIAa9bg6FeFnj1xTCdDWhqOHFVYtoz5nXfUNmbONTnZXKxi0SJzcYenn5bLDTLD0VWooM7j66/hrFR48km1KENgIKQAVdiyhXnzZrXN2rXqd8yMBZDZGDHr/8wYi2aORvYJJ2M+GmJoEQkPQvNcNf4fuBNvNCYGR5MyJCTARnYsSYSj9MKF8SPDtm3qSze3b+NCUqNG8jwOHMBRYtGi4nSLBUfuzz4rzyM4GEebNWrIbU6dQrosOLvFgnwqV5bnYbXisl2ePHIbd96PhkZGaBEJD0I7V40HgacCobsTVDwxUa6YZCA2Vv5d0YCZkyfC7eWCBf9+Pu7Ux53ncqd9dEB1DU9Di0hoaDghMdGc5H/rlrkgw9mz5qID+/eruZ5ERFu2mPMZ16wxF0pYvtw8wPuiReoQekQIPG5WZ1WoQwPTppkHVJ8wQU0dIkJ4QbP3NW2aOp3InCdMRLRsmbmNGQeYyPx9Eskvg2n8+6Cdq8Y/BjPFHyIcRarAjIlNNdHGx2PiV3HcjFuQqkk9NZWoe3e1g7VYzHmPaWm43azi5SYkoD6q54qIwC1JFQICcENUhdOnwd9VYe9ecyezbh0WBTLYbIjfe+SI3CYujmjuXPGtcAMhIeCxqviT/v5qXjMR0YkTal4zEY66zWz27jUP3n74MOKJqnDmjLm4SFAQ2lCF6GhzMY+UFDV/lwht91jxQv9l0M71IcGdnVNEhNrGbsdORmVz9y6oPCqb06fNFY1WrEA+MiQlEX3+uVoE4fJlkPT9/eU2e/cSvfyynNbi5QW6UNeucppInjyQ3evYEQIZIpQogW95zzwjn3QqVUI+KgdboQIEFwYNkrdxvnxEBw+qJ1ubDYuG+fPlNtHRRBs2qFV9AgMR5PzGDbnNmTMoRyYcYrXiuVXB0oODoRilCpa+ezcWS/v2yW1+/RULC5VzMERFVAIQH32EdyRTKkpLQ99TLaaiorAIUh0/X7mCxVSpUnKbw4fxPVtEbTGwaRNRy5ZEdevKbX7/nahePXngA2a0X/36RMWKiW2MBc4zz8hpKRYL8vnwQ/lxeFoa0W+/gZIjQ0oK5gnZ2CXCd++NG9UL1qQkLIRUSEwkunnT3Mbs1CQp6SEuKB7C5apMD0/cFg4Lw+3E3r3lN2OPHmWuUgVUBBn9Zc4cUEk+/VQuytC7N+KjTpkivvWXmAhqRu3aIP6LbileuwZRgSZNmH/5RWyzciXI8+3a4UakqKz33gOZv1s3McneZoOIRJYsEB+IiHC1iYgAAd/XV04C37wZdSlUCBQjET791CGEILtR/PTTsHnvPXE5djsEDHx8ED5NBH9/5FG8uFy4YfFi2DRsKA/g/O67sHn9dflN0hYtUBcZ/Sg1FcHHCxcGxUiE48eZ8+aFaIhMVGTOHNBsKlaU065GjEDA9WefFafb7QgYnj07KEYiREWhX2bNiqDosvqWLIm2kYUqXLIE70kVAm/UKHUQ86QkR3+QxREOCGAuUwY2shvbq1ZB2MHLSxy71GqF2AoRqD+idx0UBAoNEUQgRNi2DeOaCM+fEcnJoOmUL493IIodGx6OeLDFi0MsRTRXBQejbxYoIO+bN25AMCRPHjk16No15hdfRD6y2+GXLjF37AiRGRll6sQJ5jZtkJds3ty5E2IVMkGLB4Gm4ngQnqLiBAZCSUSFTZugiqTCyJHM06bJ05OTmZs2VfPdrlzBxDNzptxm4UJMCD/9JLfp0QODefp0cXpMDIKGe3nJFZi2b0cedevKFx5DhkBVRlaOxQIlolKlwK8T4fBhTD4vvCB3VlOmMLdsCecnw6RJKCcsTJweEYF8mjaV53HqFLiPn30mtzl7lvmZZ9T0l+vXmQsWlHMFk5KgBtW+vfyZ4+KgsjVhgpzqkZKCdtuzRz6BWa2YKGXDxG7HYqN1a3Xs0unTMQZU3N3nn0cMWhn/NC0NNKcNG+R5HDwI7qgsoDozFmSvv47Fowg2GwKhd+4s5zRfvIgF8fPPy8uZOBH1lcURTkiA4/X1lSsrbdiAcVa3rvg92mxY5BLJ5yGjHC8vOXfXZsNYK19eroZmtWKRpFoYJifDRjXW7t7FO7p0SW4THAxVOhV17to1LBr+rjoTs3auHsXD5rmaccxsNrVoA7N54GVmDHoV7HYMWBXJOyICk7KKW7dkCX5Uk+7ixXA0sskyIAA7lmbN5IMoIAALApkAhNWKOrRowfzHH+I8LBZIpVWooH6mTz9V8yjtdqz8ZXKNzNglNmwoT2dG26oWUswQSxDtQgyEhWEyVGHePCzaVHBHRKJAAXUemzdDYlKFt95SCxTY7dhZxcXJbfbuZe7QQV3O4MEQz5AhKQk7ZNkiihmnF88+Kx8jViucw8qVckd0/DhOmm7dkvf/X35h/vhjdfsvWIDxum2b3GbvXvQpFe82MNB8hxcWxnzokNomKMicUytbkDjDHYGIh8nL1c7Vg9AiEmqYrQY9sVp8kLxkR4UG/P3VExAzjgxlR7rMmFzq1lXXZ8IErJZlsNuhu6yavP/8U73jYcZngDVr5Ok2G450VXVdsYL57bfV5Zg514QE7OhVmDvX3Im3bKlu+2vXoI2twscfy085mLGzLVFCfiTPzLxxI3O/fupyRo2SH6Uzw0HPmaNue4tFvUtnxt97ahy5k48nx+y/DVpEwoPQPFcNEaxWdQST2Fikqy7M+PlBMEF2+SQhARefunYVpzPjAlHBgvLLMsy4JPThh/L6XriAn1dfldd13jzoM1eqJE5PTIRm9ejR8jwOHcJlmbZt1eW8+aZcRCIyEper2reX53H5MtpEJnhBhMtvJUvK04nM37HGfw+a56qh8YBwhzrkzHGVTbrG7cl8+eSO9fhxOL2GDeWOddcuOBiZYyXCLdQnn1TfQl29muiDD9RO4vx53IpVIWdOtVJUrlwQ5lfd0H3ySThHFU1p0CCI3ctudRYtCse6a5f8nVWvDrszZ+S0KcOxhoTIb1IbbeZOKEci9/qQxn8D2rlqZHrIoqc4488/zQNML1yo5l8SES1ebC4osHatmsJAhLinixerbfbsgQCECrt3gzKhwrZtcLAqrFuHyCIq/PabOlYrEcQoTp+Wpxu7aBV9w25HBBgZrYoITmz4cJwOyGCxEPXvr3Z4VivoOLJIVUZ9+vZVKz0xg8OakCC3IcL7UtWZCJF+VDxqjcwB7Vw1/i+4KxBhxtvdsUOd1+3bRF9+qd41BAQgVJdKkCJbNoTzU6kZlS1L1KaNmgNcpgzRSy+pOcD58oFjqVJFstuxm1TVOTqaaOxYNXcvMBAiEqqdoFmwdGaoSql4romJcAwqnmtQEJzv/v1ym2PHwDdW8VzXr8c7UPFc58+HjUoo4Ztv4OhVffCzz1AflXP9+GOEO5RJLTLjPa1YIZd1ZEZ4tdGj1dKP69ej72TPLrc5c8ZceSo01FxoIjHRfMFps5nz8zXE0M71ISE4GI5C1VGPH5fH9iTCanb9evWK/uZNTJKqSXvrVuyaZDs+mw0SdQsXymOARkbCof3yizymZkAAUZMm+IYmWtF7e8PZVa9ONGeOOH5q6dLYTVaujHxETqR5c7RvzZog0IvauGVLiAY0aUK0ebO4vk2bQt7vqafku6+KFbHz6NIFsUdFyJ8fk9bLL8vJ83Y72u3dd8XpRHAcERFYXMgQGIhdoChWLhHa68IFCB2cOiW2CQhAf9m4Uf4ud+7Es2zcKO/DhsKTSkTCcPJnz4rTjR0gkVwYIy4OO1siuRTl5cuQUCSSHy9v2wblpfz55fWdMQNxUmUxapkRY3nqVPRDEZKSEKv4ww+JXnhBbBMRgRisL76IfiNCUBDyadQIfVSEK1eIBg7EQrJcObHNhQtE772HckSfLZjR/0eMwCmDSGiCGfcFjLiuItjtEIf46iv5Ishmw7y3fLm8X1kssFEJTaSlIeatat5LTcWCw0x602N4KNerMjk8cVs4Lo65VSvm0qXlV/KvXsUNxtq15VflN24Ewb5VK/kV9TFjwGV7/nkxZSc1lfmpp8Ble+MNsc2tW+DdZcmCG5MpKa42W7einBw5QE0RXYf/6CPYFC7MfOSIa7rVCjoKETidoucODkYZXl5yYYHffkMejRrJb98OGoQ8JkyQX91/4gkQ32Wk9nv38A4bNEAbibB1K9Lfekt+G3XWLNj89JOcVjV9OvrD4cPidGbQdMqXl1NxIiPBp33+eXlszUuXIEzw4YfyUHynToErO326nArl5weKjIwTareD01yxopx/mpjI/OOPKGvLFvkzDRnC3L27/D3dugUKTOfOcgrYpUvgCL/yiry+S5eCpz14sNgmIQF1yZ2bef58sc3Nm4i56+Ul56j+/jvSS5US84jj49EmRLgdLsK+feDBEqHeGWG1QhyFiDlXLnF/uH4dY4AI/4rG/bFjzJUqOcRWRDh5En2XCCIaIhw6hFvshQrJ22XbNtS1aVM59er33yGkMmSI/JbzTz/BRsWpdReaiuNBeIqKk5Bg/nL9/dXBsZnhSL7/Xp5uqDSpxB/u3gX38ccf5Tb79sHRTJ4stxk1CgNaRn5PTsbEUrSoXNHo5Enw/MqVwyQuwsiR4BOqFgyffIJnWrdOnMeRIxjoNWrIxSquXIFClopCc+cOOKznz4vTU1NBF6laVT7Y7XY42GHD5OUwQ6RD5mSMfIoUUXMBDeEGFaZPVz8zszkVhxk8VxWN48QJOAkVpk1T9zlm5CFarBmIj0efS0uT12f9enl/MtC/P96TTNErPh4CEadPyxcmq1Zh0bdxozg9LQ1KUKNGycfjkSNY1LVvLw6obrdjIVu9OhTTZDzvZs3gzH7+WVxOair6bZ486MMiJCZCSa5VK7mgyL17WDxOmSJOZ8bCs3Vr9eLxzh1sAFQxmiMiIMKh4rreuaMWC3kQaOfqQTyOPFcz0nRamrzjG5DtvJwhU2lxLmfrVvEK18Dp0yDHi6QNDQQFgeB+9qw4PT4ezzx4MKTMRLDb4RzLlFGLNwwbpnZqUVHYQYSEyG1+/pm5b195OjPEKlQOIDgYOwCVM/ruO5wKqNCypbzdmPE8FSuq85g/H/KFKpg5V5sNO0EV1q6V77wM9O4t3/0ygxdauLC6z61bhyDyKnTvzrx6tTw9NBT9QCW4MG6cOvh7aCicor+/3ObDD5n79FFzWV9/HX1JJspgt0NoIiFB7HwNXL4M0QpVn0tOhlKcClevygUvDNy+bc6XNQsiz/z4BW7XztWDeBydq4YcV6+qB2RSEnbCMqk/ZsgBqpSRkpIw8YaGym1mz8ZRlQq1a6vVlY4exU5EBXcUjcxEJFaulGvWGjBzrnFxWNioMHMmPluoYKY4dfo0dLpVGDSIedEiefrduzjCVjnoMWPUu/nUVAiJqHZVx45BNUyFGzfU9dB4vOCuP9D0aI1/HapUUaf7+hJ9/bXaZvhwXLjKCLsdv/f1xa3Y4sVdbZKSwAl9+WX5RZg7d4iKFMFtVdlFjuBgogYNiGrXltfz8mUIO4jqasAQXEhIQAQhEeLiUB8VcuaUc3KJcGGkShV18HFfXwRTVwUxr1wZfy8Lhm61EvXrh0sy3t7i27eNGhF17ozLK4mJrpeWsmTBpT4jf+OdOWPEiPR1NN69gezZcUlMRdFp0gQ/KlSooE7XyJzIdLeF9+/fT127dqWSJUuSl5cXrVu3zvRv9u3bRw0bNiQfHx+qWLEizZ49+5+vqMZjA5vNPG4sUfpYpVmyiB3E9OmOG8sVK4ptJk+GsypQgKhDB3FZU6fitnHPnvJQZd98gwDuP/wgr/MPP0BAomdPuc3MmQh/J3OsRFBOeu01eToRHJGPjzy9cGFQlVRc4f79QWNS0ZSWL8ezBweL0xs1Al1l0iT5je233oKIxNdfi4PA58uHEIVEuF1/7pyrTaFCDqd84oT4FrSzY42Olt+cdYaKEaDx70Gmc66JiYlUr149mqki7jkhMDCQunTpQq1ataLTp0/TmDFjaNiwYbTajFWv8VjAjEyfkEC0YIH6en2WLKC8mIk//Pab+Y7W3x95qShVd+6o470SgeI0dKjaJiyM6JNP1PW5ft08WPqZM0Q//aS22b9fLUZhs4HCpOK5JiVBrELFc42KgvNUcTBv3QINTBWjNiAANBkVz9Wg46jid16+TDR4sJqOc+MG0XPPISawDBERoMfIuLBE2Im/8w5oJSpcvw7KnRm00MRjjod0TP2PgIh4rermAzN//PHHXL169XS/e/vtt7lZs2Zul/Nf++bqzgWCyEi1nd3OvH+/+hZraChuRqsiYyxZgu+WqgshH3yA24t//CH/rjhjBrO3tzzGLTO+BxIhOo8sn2nTYKO6BWnQj1Qh/958EzYrV8ptjPidsvi0zLhl7e0tv9lpsYCCkCuXnAIWEoJySpeWt83hw7Bp3lxel+XLYaOKevPll7BRhVU06CKq9nvpJdjILt7YbLhQRoRvtCIkJuKbN5GcvnXnDvqWl5f8u+itW7ilniuXPDpOYCC+JefNKx8TERGIk5orFygxIqSl4ft6t24I5yiC3Y73pfrmzIxvvbJ+YyA62jwC1+N24eifhv7m+heOHDlCHY3zn7/QqVMnmj9/PlksFsomkGZJTU2lVCf2f5yZjIkbOHMGx1zVq+M4MWOxzERr1uCbTu3asMn4LScxkejnn5HWoAFR+fKux5IXL0JIoXFjEMlLl3aty/z5OAZr3ZqoVStXcfPUVKzmc+bEsWbbtjjidEZSEr7jNWoE7dsOHYhy53ake3nBpnhxrPp79iTq1Cn9sWKJEhCjKFmS6Pnn8R2tc+f037XeeAP1rVGD6JlnQOivWTN9XcaMgc3LLxPN/PgmvfNylEu7vFaNaBETbZlE1L6A+DvY0wWJGhDR+cVEQXXF38IaeRM9QUS31hPFNHFtFyKiaolEzbIT3d1JlNZArLZTKZaohQ9R0kEiriA+Xm7ARKk+RMmHiEjwrdNmI2qeg6hWKaLIbUSVW7jahN4ker06+tet9UT5BN9vw/yI+tTB7i1ko1g/OPkQUY+KRJVy479Fovq5rxK1y09U305EEsGKcneJnvQlKhsltrFaYfNMUaKcl8U29+4RVU0g6lKcyOs0EQl2lLeCiWqmEOXIR5TjIhEJdq8B5/Aecmcnyn+DiATiLJf2ExW5RVS1+F/5ZAAz0d7fiHJeIXqzMVFWwfGyxUo0/wsi20miD7oS+VxytYmKInr3HaKj1wvTgGFlXb7VM+N4/8svcay8fr3rbjsiAnKZCxfiM4hIqCMoiGjlSqI//kCfE50yXL2KE4qNG4nq1XP9LMEMIYo//4S+84ABUC1zhs2GOebAAdTj88+hgOaMtDSkHTsGFbKRI13nxeRk5HPqFEQxunRxrW9cHOa9ixcxJ4nGbUwMTimCglBX1ecNj+EhOft/BOTGzrVKlSo8OQNp7tChQ0xEHCq56vn5558zEbn8/J2dq8UCzlzWrPJYq3fuQFAhd2458f3ECXAJixaVX8ufNw+r8bJlxcRrm82xc6pUSVxWVBRW40TMNWuKxRAOHWLOnh02sluVEycivVAh8SrZYsFuiAirdhGuXsXuq3BhxFoVYfJk5o7Vgzk5S05kpn/0Tyb8SfLKyVGnXOPP2e0Io+flJRe9MIRfiMScTrsd1CEijEdRmLuICNC2iMC9FdH5jBMKIuapU8V1+fVXpPv44ARLhEWLYFOtmvzkYPZs2Lz8spxa+O23sFGFGBw3jjlfPnOetjvQO1cneGXYFjCz8PcGRo8eTSNGjLj//3FxcVRGFQ7EDWTNCqnAQYPktzILF4Z+6/79RLJIRo0awebChfQ7RWcMHIhvkNmziy+xeHvjO2VcHHaVorIKFYJM4pNPQrRctENr0QI7xunTsfIWYcwYfGMqWBCXajLq12bNCtm8r76CfuuoUa5yf1WqEM2dizo98wzqnvGi0PDhRO89GUU+TyXRd08spfdm1XBZBdvtWPW/9RbqLQs3tnQpJAUN+TwR+vfH7l52EzQ6GheENm0myiYZZVu3YtU+fry8nM8+wwnD00/LbTp1wrdOWX8IDCQa/wXR4kXyPH7/Hav7IUPkNiNGIBTcE0/Ibdq0Idq7V35b+Nw5vEvVlYk5c3Bq0quX3KZPX6JPx8pvhsfEEL3+Oi6pyeqyYQN2RKr2HzYMkoTt2onTw8Nx4vL773LN4FmzIFk6cSJcUsab3efOE30yiuiHIf5UZfyb5MtRROTY5qWmYt4ID8f3alG4vps3sWt77z2UJZJQvHmT6NdfcTo0YoTrTpIIO8UqVfDt+I8/xJrLbdqgDzRvjvEqQpcusPv4Y5yOifDCC3jH06aJb90TYQxFRxN99JE8qtOQIditZtw9O2PUKKIePdTRozyOv+/HHx2IzHeurVq14mEZFAPWrFnDWbNm5TQzlYW/kFm/uZp9C0lONv+eovrWaUCmTGPAaDaZKhIzOKcpKZDQU+HcOYWogp8fMxFP7ObH3bvLv5suXozdsuz7mKFSc+KEvB7r1jF36qSu63PPqcn4UVHMJUuq39Ps2fimrMLTT4NPKUNsrDn/dOFCtRgCsznP1Wo1F5FYuZJ5wAC1zSuvqFWpkpNxiqHiKf/6q3k5bdtCuESGCxfQD1TlvPEG8w8/yNP37sU3W9nUce4c3s2RI3y//2YcBDdugJetmq4sFkcfUNU3KUleF2eYjelr19TlMLtXTmb8XuuuP8h0t4UfFM2bN6edO3em+92OHTuoUaNGwu+t/yaouI9E+O6gir5BhG/EZihVSp1u7Ixlwa+J8H05Rw71roiIqE4dh7C7DGNG45atbMfSqxdW57JbrdmzYyc9YgR2GiJ07Ypv6CIKh4HevdVh5QoVwndzPz+5TYsWREeOyNOJ8A36kuA7noG8efG9XnVrNm9edfQdd6Di0RoICTHvL5cuuX5Xd8apU7hzoOKXbt4s/j5nIDgY399kuyoi0IEycl2dceIE6qLa7c+Ygd2i7CSqShXUtVkzeR4VKuAWu2q6yprVcYqiahdfX3ldnGH2jipXVpdD5F45ZnNUZkame7SEhAQ6c+YMnfnrLn9gYCCdOXOGbt68SUQ40u3du/d9+8GDB1NwcDCNGDGC/P39acGCBTR//nwaOXLko6i+xkOAtzeOz2Xw8sLFD9lRHxEuWP38s9xBe3sT/fijeoLp2hVHhSIHbfzu5ZflnE+bDU4mKkoeUs5igY2KW5qSgktrqri32bO7F35Mhbg4+dG0gZAQ1EW2aLHZQEEqVUr+zP7++FyhqlN0tOPTgaiskBAcNaom92bNsECSoW5dHC2rnN7KlYi2JIOPDxaMGv9CPKSdtMewZ88eJnK9bNSnTx9mZu7Tpw+3adMm3d/s3buXGzRowNmzZ+fy5cvzzzLVagky67Hwfw6SYzV3jp5iY9XH1kY+ssACzpAJtDtj4UJz3dUff8TRm8rum29waU31jF9+iWM+lc3EiWpNWmZcClHpyVoszOPHq+UAk5LwXLILLMz4PLBihZyOwow22btXTrMx4O+vFoZnRn3NNLTdffdmervMCg1hSf/VeLzwrz0Wfuqpp4iZXX4WLVpERESLFi2ivXv3pvubNm3a0KlTpyg1NZUCAwNp8ODBD7/iGg+MlBRxjFdnbNmiDlxOBPm/Tz5RCw74+uJy1/nzchtvb+SzbZu6vAULcBSowvbt2BmrcPgwjhVlu2ciXAJbuFC9A9u/H7QKlc3u3biIpMKOHWqBiCxZiFatUh9j58iBZ1LttL29cREuIkJuk5KCSz6qIPFJSbjEIrsIY9g8/7z6yDw1FRdrgoLkNnY7LuYsWSK3ISI6eNBcGCQlBRfUVHGbieSxdzUeD2Q656rx92BcolchLk4e5NvAuXPyQOpEmLSWLIGSjqy8PXuIPv0UTkR0vJc9O272vvoqjtdEAdfr1IEyTt26cGoi1KuH27+VKuE7mshhZ8uG73iNG+Mmq6zOTZviuDfjrWdnVKuG28Rbt8ptChQg+uADBHiWwWZD+6gm9YgIfINWHelevkz03XfyI1SrFbeW/1qfSss5flyt0HT6tCMwuwwbN+Jd+PvLbebOxVG56hh74kTko3KuQ4di4VWwoDjdakWA8kOH5HcL4uLw7XblStx+FSEkBEfQY8fKJSQvXoQTb9UK/2ZcMNntjnbr0AELHdFt9suXIa/ZtCnaW4SoKKhtjRqFb+0ipKRg/O3eLU436nThgnqcE0GRzGxOUS1e/rX45zfRmR+eOBY+eBDHanPmiI/EbDYoBH3yCcKZibiwd+8yDx2Km4OzZ4uVjY4cYe7alXn4cOa5c11t7HaoC7VsCV7pvHmuoeASEnATtmFD5rffRiirjEem167hpmv16riVuX27a13WroV6UJky4PhGRbnW5Z134O4LFBDHuo2NRRlEzI0bi28gbt8O/l+z7PJjtcuXEfjdx0eueHThAv68aFH5TeHdu2FTtapc3WbhQtg0a+b6zAaMgPYvvii/sW2oEA0fLk5nBkfQ1xdcPxGSk8GtzpNHHqD85Em0Te7cuJkqwvz54DSXLCm/JTpyJMpSxWt9/nk8kyzIdnw8c/36sJk7V2xz/ToCxBPJj3P37XNwPmXH1MuXQw1JFYP2+++RR4MG4nSbDaH6iJifeUZsk5aGMHpEeH4R7HbmL15A/+1Vy0+oBrVxI/o5EUIRZsS9e8jfywvv8swZV5v16xFlKUcOBEPPOJ4SEjA/dO6MSEqiAORnz4JX/uKL4NKL4jTv3498Xn4ZMVsvXnS1OXAAPNlevTCvicLP7d8PVbQBA3ADXIS9e/Hp4733xOUwM+/ahU8oEyfK9QHchQ4550F4wrna7fjWVLiwXLYsORlxGwsVkkuk3byJ4OOFC8upJDt3YtIoVkw8EdrtzF98gUFavLg4n4QE5qeegk2TJuLJ5+JF1JWIecIE8Te9OXOQXq4c8549rukWCyYlX19MDCIKwJUrkOarWBELFBElYfx45pn9MTnt+lr8zer99xGDtWtXuUP74APmevUQ4FqE5GRMpqVLyx3nqVNwnl26iNOZmXfswIShCnq/axfaXvVdcf9+BEuXfU+9dw/fL7t0kVM5wsKYJ03ChCmLr3nnDqg4mzfL+2ZCAvqlzEHb7Qgw36QJ86VLcpt58xC3VxWj9s03mb/6Sr7AsdnggI3v1iJcvAj5yNmz5eV8+y2kBmfMEKdbLAgaPmSIPBi3Eei8d2+xCEpsLMZ9nzrov6GbXPvvpUtY7NaqBfpPxvFot0P+s2xZ5mzZxBSwxEQIURBBPEb0ffjGDfR/ItRX1K/27oUD9/YWO1Zmh4hEyZJyOp9h07Gj3OHNn4+yvvhCvgCaMweLx61bxenMWIzUrKn+ju8utHP1IDx5ocksQLndLl5xOiMmBjsoFY4dU+vWMmNy+uUXebqxg12/Xm7j5wdnM3WqvPNPmoT6vvCC2JHHxjJv24ade8WK4oF2+TIcRZ8+mGQyBjK3WpmtxzE5vVbNj996y9VRpKVhsnjrLbmDtdmgCFW6tDzgut2OFfCgQeJ0I5/q1dWO8exZTGQqfP65WseYGTsQVfzT0FDURYW5c6GJrIIZz9WIG6vC5s3Mr76qtnnrLealS+XpNhtziRJi1TADf/4J/q8KvXphYpYhJMQRs1fWtz/6CPnY7WJHZDjWI0fEi5sjR+Dgx41jthwTn7wsWIDTn1WroKokWgDNng0t5UuX5AvDtWuxu/vpJ+aAALHNmTNY3PTuLV+837qFvi9zrMw4LXjjDbUzS0xE31Zx7W02cMpVsFjAF1YhNtY93q070M7Vg/g33xaWDSADKuF9A2Zk8geBbOfkjG3bJAPyr9uWqUf8eMQI5t9/F/+94WD795eXsXo1AmHL6pOcjKPho0fleSxahGMxFRo0UDvgo0exM1Lh7bfVzshux9Gn6rawJ4KluyNWMWMG89ixapsGDdSLhePH8VlDhTffVLfJjRs4TVEFKX/tNfXJwtq1EP5PSBCn37zpcKwi2O3M3bs7CVlIbgsfO6a+Xc2MzzaeHIdmebkzL5jNLZkVWv5Qwy2oblISuSdwbUYmfxCognEb6NRJnZ49OwT+ZfD2xk1dWSxQIqJu3SAFJ7uI4eODW68XL8p5jK+/jss5CQly/mffvkRr1xLVry9Ob9QIF3diY+Xyeo0b47LRG2+I0728cDkmJEQsyk+EC1aq29TuICZGLJPpjOvX1bzO5GSEnKtcWW6zdSsk/GRIS8Ot3Dlz5DZ//okLZbIQccnJRLlyIbygDAUK4KJTrlzi9NKlcUlJ1uZeXrhdbQazYOtEaoGW/wdmY9qdecFsbvm3w4vZ7J6XRlxcHOXLl49iY2MprzuyIxqPBqdOETVsCMkjM6mnhwRmNZUmLQ03lVU2d+7I9aiJQMlISpJrJRMh+kjVqvJJOCYGqkUyJ0+E26nlyslv3yYl4Xapyhlcvw7lHtnz2GywqVpVnkdKCtpNNRTT0szVx8zezUPHY9h/NVzhrj/QVBwNDXKPKpCYaK5SZAQHMCCbvA0qSvbschtDFlHlWA8fRugxlWPduxd0JNXu5tQp2KgQHa0OKp4zJ3Z8qsD1lSoR3b4t52hmyQLHevMmdrAi+PjAscbFYVcvguFYbTaEUBPBud1v35bX2YA7kSeZ/6O0Ew0XaOeq8dgiJkbtzJKTidatMyfbr1qF+JeqSf/cOUTwiI6W23h7E3Xvjh2eyuadd7CDU2H8eGjTqvD992rOKBHR7Nk4AlVhwQL3bI4eVdvMm6fWQSbCUbnZs0+cqG5DIkQ5Ur0LZohIqI6ymaH7K3PShs1nnxHt26e2WbTIXPRj/35IKqp2w7dvQydYJZBhsaJvmL37e/fMF3sajw7auf7LoCLVE+G4zIz0ffMm0ZUrsBWBGWLjR47IdyC3bxNNmQLt1Zs3XctjhljDoEH4LnnqlKvzS0tDWKunnyYaNw7f2px3Bb6+ELsoUwbi5p99Jq5Lp04QYC9dmujDD8U7mfr1HUITX30Fx50Rvr4oq149hP6SoVo1iAWo1IxKlYI4gWxXRYSd4Kuvqp1MUhIciGrhEBRENGGCPJ0Ik/m8efJ0iwXKVCoRiYgILGKOHZPbnDuHb8wqYYwtW2CTlCS3mTcPIdFk36GJEKB73jy5QITViv43cSLCtYkQHQ395379iHr2FNtcuABhkTZtEEZNJBCxYgXCJZYti/8vVsw1nx078O9TbVCvGjXSp4eEIFTigAHQk541y/Xb6J07aL8vvsA3+IAA13KSkyFe8ssvyE80F9jtRDduEG3aJM7DQHQ0+o5q3jHmHBWYzeeuTIeHcr0qk8MTt4X//BP0jzffZA4MdE23WEDvaNcOtxRFlJ3QUBC3n3wSdAYRJ/TPPyEs0KgRc48ergGR7XaQsvPkwU3HF15wpZwkJoJzmiULaALDhrne/Lt2zUHkL11aHLpr1Spw7oiYO3RwvWFos+HGLhG4bJs3u+Zx+7YjeHP37uJbwgsW/FVGIdy2tJ905QkeOwaBA19fOdXp0iVw93x9EQhehDNnHMGmZWHetm2DTZkyoBCJYPB/a9YUi4EwM3/4oUN4QEYF6dIFNjIRCWZwH4nkGrt37yI9Z045XWHXLtjUry8v56uvYNOvn9yme3fYyMK0JSU53veuXWKbs2chBkKEMSHC4sV4l7lzqyliROCOimCzgbpCJBfGsFgcfbhrV7GN3Q7erpGP6NZ2VBTzxG7ov93K+7kIuzCDP507N/IZM0Zcl86dkZ47t7gPHzgAMRCDv56RzmSxgGaTMydsPvjAtb7nzmEOKlQI72HNGtdyfviBuU0bjIEqVcTjYN480KWqVUOYQVHfW7gQz9SgAfOsWeJ3uWABxkinTnJZ5jlzMB8OHizXGXAXmorjQXiKirNrFyYn2YRgt0NFpHx5OYcvPh4TVOnScuL15cvo0MWKyakkf/wBlZa8ecU2FgvoKkRy7unt25iYcuUCNUKkhLNxI5xV+fKYhDI6EsPBNmkCTuG0aa5qUEFBmJR69QL9Ze1a10E2YwbzoRmYnAY19BPSW6ZOxaAvXVrO3R0+HM7h+efl/Lt+/Zhr1JAL9CckYKKtUEH+jvbuBXleRX+ZORPtsmiRnNbw+ecQbpBRgqxWcBbr1JELz587BzWonj3li4EdO6CQ9d57curJxo1YtMkEF9LSQOavUwfPJEJUFNR6OnaUO9d796B+1bmzvH+HhUHAYPBgcTozJuWWLcExFcFqxeTfsyfzsmViG4PH2r8/BDIyIj4efM/WrcEHz8jPTktDnyxVinn2W+i/EVvTe4i7dyGAUrYsxCo++ECsmtSlC+aXMmXEjnXzZvTbMmXw3KLpbNkytJu3NxYfImc2fz7mjgIF5ApZP/6IuaN5c7HaHDO4uVmyYBEpo/4sWICFwurV4nRmOM4aNdSxp7/7Du/RE2xK7Vw9CE/yXN3hcZpF1rDb1eo1zBiQZkIThw/LVWWMcr78Ur4YMMrZtAkrYtkOYc8e7FpnzhQ7G5sNZPPQUEyGIulBY0I/cQK8T9EEbj+JyenPr/y4UiUM2ozlMGOHWqsW1GoyOi2LBXaDBskdbFoa8ihdWq4QlJaGyXTkSHG61Yq+ULq0XFjEZsOk0r27OJ3ZwZUU7foNJCdDxUkVXWfpUkhRqmDGc01JwYJOhYUL5dKHBtq1g3OQ1TcwEAs+m01uM2oUFh6ySTsqCm0fECBXrhozBhOy3S4XgDB4rKLFj9HPRo1y9CtnXL0Kp/DGG3/1AQHP1WoF3/qzzzB2EhLEz/zxxxB1sNnkfXLzZnCEjx+XL5CuXMHCZMkScTozxvzKlXKpQWaMm88+M480JRO8MGC1ihctzkhIMJc0TEoyj0LlLrRz9SD+zSISmRF2u1pEgv38ODlZfmzLjAE5caJ8YrXZsEsQHXcbWLFCLRIRF4cdu0wOkBkKNe+/L09PSYFEpUqNaNYsOHIVqlZVL5J27MCxmQpmzvXWLXxqUOHDD9Vyg8nJ2InL3gszdlSy3SYzjv1KlJDLUzJj9zdhgjz9xg04tbg4uU2/fnKBCGb0HZW6mUsflYhIqIQuNB4+3PUHmufqBjTPNZPgEfAEzfiUERHiyysG4uIQxaRiRbnNvn14LJkQRUgILqCpgr+vWoULNzJaT0gIosO8/LI6jyZNcClHhLt3censzTfleezYgUtjlSqJ0xMSiHbuJHrpJXkeZ88SFS6MS2Ei2GwQ96hbV57HvXug9KjEENzhynoUmueaKeCuP9DO1Q1o55pJoCcnjcwM3X8zBbSIhIaGh+HOMtRiMbdjlsfZdIY7wbCjosxtVJxKAyopyAe1cSdesIpmQwRahjtyjO60kTttraIyGXAnFrKGhgHtXDUeW9y7p57Mbt0iOnBAPaHb7QgcffKkmnC/bRvR77+LA6kbuHYN4g8qpR6bjWjwYHWAaS8v8G7NnN5nn5kLZEyZkl4RSoSvvza3+e4787LcsfnhB3O1o6+/NnfUX35pns+MGTgiVuG339RB64mQruL4EkG7efJktc2NG6i3qn9ERxOtWUN05ozcJjUVCl579qjVnlJTzRcpGo8O2rk+JnBnRZyUhMlfZRsURBQZiYEnQnw8lHiuXYMDEDmc06chEnHiBJR0MgoqpKVBFH3hQqLt24nOn3edUE6dguj5tGmY4A4eTD9RpKZC0KFrV6L33sPEfeNG+jwuXYI4RN26RC++SLR4cfr0UqUgNlCyJL5Hjhrl+ize3hCKf/ppokKFQPIXCTe0a4dJv1QpovffR9kZUbUq/rZSJaIffxS3sY8PxCbq1oU4vAz58hG1aKEm6GfNSvTss3hnMiQkQOBANQkHB8sFNgycOAExDxU2bICogAwpKRAmUDmOkBAEVVCJCpw8iUWMTFSfCO/9/ffVAv/ffkvUqxdRy5bi9ORk9L3nnoOghwhXr0I8olkziJFkFIiwWNC/27VDvyhWzFXzmBkLgQYN8K14xQrx92BjodCiBdFTTxHlyYP+ayA6GoIhbdviu3efPq71WbcObdenD1GHDpC+dEZ4OEQmZs8mGjsWYhPOC0pm9JejR7EImDnTVbnLbsfc4e+P+wBr1ohPB1JSsBg7fx4/ItjtmDtu3VKfVBh2ZopUj9XJwkO4XJXp4Ynbwhs34sZm6dJiDlpqKkJx5cvHXLSomAwdFgYxhixZwDETxTA8dswh7pArl6tgghGMOkcO2OTL5xpzMTkZNyGNgzCDjuCMGzfAVySCUITomdascZDRu3Z1vS6flgbKCxG4sKtWuVInrl5FYGci5mefFfM5p0+HCEX7ArhteWu9a+Pt24dnzpMH3DkRkd/fH/XImlV+K/b6dTxv1qzMW7aIbc6dc7S/jA5lCE0ULSqnVf30kyOYtOz2rCFyMH26OJ0ZQe+9veUxL+129IPixeXc3itX1EIJzOCuEiGwtQwDBsBmwwZxemIiYs8SicVWmNHXfHzwrkTv0W53BAWvWVOcR1oaeNNG+4qQkgL+rzEGRLDbkSYbJ8zgtnbr5hCRyHj712pF3+9dG/33xbJ+LmMyIQFUtmLFkM/Ika7PHhaGoOtEzAULivvwwYNoNyKIPGS8UW2zQcTGGPvjx7uWc+kS+rZRzvbtruWMG+fIo1EjcNUzYvBgjFsicOpFtJ2hQzGH+PrilrmofQcPxnxYo4Zc/KVfP9wgf/llOe/WXWgqjgfhKSpOcDA6v0hswcCuXZgMZSoiNhuUcOrUAZlehJgYTApVqsgpHH5+EDmoXFkcK9JuZ/75Z3Tshg3F3Ln4eEwajRuD4C5aEJw6hTIGDULnzigMYLfjed5+GyT4ypVdJ97ISFBNli5FcPFWrVx5natXM4dvweTUpbgfv/yyK1927Vrk3bkzAkuLhCZmz4bYROnScg7e++9DIUsWcJ0ZaVWqQDFLhIQETAY1asgd5/btaLM335S/x48/xgQ3dqyc09m2LRYVMuGGGzdQTtWq4CSLMHcuJva6deXcxZEjof4jE8aIicECqXBhCBGIcPYsJuMiReTUIT8/LAbathWnM4MCU7GinOZks+EdNWsGQRURjhyB4MJLL7mqmDGDptOjBxa8773nOq4N0YxSpRAX9vvv01N7kpIwxqpUQbucnIv+G7PLMZBiYuCoSpZEu/72G5ysMywWOI+SJWH79NPieLivv47+9txzWOSI+m7fvnieIkXkwg0jR2L+qV9fTjP75hs44CFD5FSiJUsgECET6GBmXr4cXGEV13XxYnCFZfMhM/Mvv6D9VTGN3YV2rh6EJ3mu7hCZZRO2M2SSec7lmAlNREereXrMSFfV2WaDqk9amrzjGqIYd+/KFVKMCfvSJfEOy6iD3Q6H9dNPgkz+4gmmHfXjJUugQiMiy9vtcLQVK7q2kd2O57h6FY5ExMlMSXEEXJdJE8bGwnmXKeMqQWng7l04zq++Eqffu4fdW+nScocWFYXdxcSJ4nQjn5Il5Qu25GQsOt54Q56Hzebguarec9Wq6kDan3+O55VNhBYLHH1wsHxSnjsXqlOyMZCYiNOOkyflC9mJE+Fck5LE5Zw6hXd35Ig4PTUVDubTT7GoEbXJgAFwaBlVmQzMng2neOHCX78Q8Fzv3EEZxgJYNhY3bnT0EVlfCQrC34eHy/Mx5h6V2hEzTsTMBHG2blWnJyWJFwHOSEgwL8ed+dJTAhLM2rl6FFpEIpNAQsKXwUy1JSGBhRqvBmw2tcgEM3bYssmVGRPdzz+r8/j2W/GxmgF/fyhpqTBunFy5x8jj00/VeYwfLz9aZoZDzKiKlRHffitW4DIQFsY8erQ6jzlz1DuZsDC1UAUzTiVUGrMxMXK5SAOyY2sDZupELnjA/qvxaKBFJDwIzXPNJNA8QY3MDN1/MwU0z1VDQ0NDQ+MRQTtXDY2HDHfPityxcydYtjtxMt0RUfCUjbuxO915NnfaSJ/NaTwKaOeq8ViCGfxO1cR47RpO0m7cAAdQNGEnJoITeeGCWiBi40YEN5cFiCfCad3KlXIOMRH4mz/8oC7LZiOaOlUckN0ZX39tbjNjhrmQwOzZ5vnMm2duM3++eVkLF6p5uUQINB8errbZvBn6wCrs2+fK48yIkyfB/VTB359o0SK1TVAQgpOrFg9hYURLl8rFL5jBQT9wgOjwYXE6EfqQvz/RkSPq9rZYtIjE44ysj7oC/xXcvYtJOS0NJPOCBdOnJydjUNps+ClWDIRzZ9y+7ZiUmInKlCEqXtyRzgzx9ZQUkM+9vSEI7yy0HhUFNaLs2YmyZcNPixbp67NrF9G5cw5h81KliDp2dKTHx4Ogn5JClDMnfl55BfUxsH07RAly5QIZvnFjor5907fH++9jEsmXD8/x44+OZ/bygmjB0KF4jvz54bS6dnXkUbgw0UcfEa1fj/8f3pro+wztnisX8mrUCJNRgwawzyj63rQp2iEsjKh1a6LRo/GvMxo0wO+HDCHq3ZtowACiWrXS2xQpgmeqWpVo4kSI2GfJkt4ma1ai2Fi0ybJlcoH5uDgIF2zciDYSISwM9Vi2zFVQwMClS0STJqkVhvbvRz3ffltus2IFUenSEF0QwW5Hv2jQAM8mQkwM0QcfiJ2Lc31fe00tsLFpE4IM3LolTrfZsDj54gtXcRIDt29DcOHXX8XCF6mpcMy//EK0ezfKzJYtvY3FQjRhAoQULl0i+vxzceCCOXOIPvkEqmNPPom+nREBAURViKjTM0RXc+Fvmjd3pKelQRTj4EHkY/SfnDkdNitWQGwlNhYLy48/RlsafePOHahIxcZCgKRAAfQN5/G/fj36cGIinHfbtunfeVQUVK1SUvBjs6FehQo5bPz8IBhisaDehQpB1MKoBzMWD6mp6Dd2O1G1aq5BIc6cQR5eXvipU8c1mMKVK/j7LFnQFqVLu7ZtYCDSs2fH/OvcZv8YHsr1qkwOT9wW3ruXuVo1XAYUBYG22XBrNE8e2IjCpcXFIeamQc4W8TSvXAGHU2WzYQPEC4iYCxVyvYmaloabo97esHn5ZQRGd8bt2+AZGmIJM2a4krO3bAFfjgjc3T/+SH+DMjUVt0uJwHcbONCV6nH5MigPOXOCSztqVPo4knY7+GtZszK/Vg23LRcN83O5obtvH7iR+fKB7C+6CXrtGurr7Q2enihGZ0gI2owI/DoRQkMd4hnz5oltDFGGHDkQG1OEHTtg06CB/NbyDz/AZtIkcTozAnlny+ZE+RCgbl3QaGQ0m+hoiJe89ZY8jw0b1O3CDD4zkTwW6N27oNFkyyavy9KlqEudOuL0xETwRlWiFzExCORNJOflJiWBB0skj0F77RooX0Tgcme8fZ6cjJvLlSphnHTtmp5aYrNBaKRvX+anC6L/vlzZL13Q+pQU3G7u2hWcZiLwmp375927mD+M+pYujRjLGev6xRcQXCBifvFFV6rSkSOID2z0zR9/dH2mzZsdY6ByZbGwy8SJjjmoWzexcEOfPg4RmsmTxePNEPooVQpxo0V4+WXYtG7N6drNGV26QLBiyBD1LXF3oKk4HoSnqDgpKaAiqOIz3r6Ngazidu3dC36lLECw1YpymjaVd6TISHT6F14Qi0gwQ+2kWjVM3CLem9XKPG0auHrDhokFE0JDUdf16zEIvv/e1WbDBhDKf/kFqjF9+6ZPT0qC6MCtWyivZk0ISThPvkePMicdxOQ0vbcflynD3KkTgmEbOHcOLIclS5BH586uPNfjx6Hg9NprEKwQKb6sXYvnLVOG+ddfxW03diyeRRZwnRnpZcogaL0I8fFYbJUv76qiZWD1akwa7drJHfCbb2LyGTxYTD2yWqF4lD27PP7osmWOSU5GX+rQATajRonTL13CAolITnNZvRoLrQoVxOk2G/q2jw/Ue0Sw2/H+SpbEuxLh8GE4oObNXReOzBg3zz2H8dGrlyutJjkZjqp0aQSAnzQpvXOw2yEgUbYsnMilSxBEcLaZNQvvtl07CHwk7Ef/TT7koOIYQiI9emCcXLoEdS9n3L4NmyFD8FyjRrkqL1mtzE8+CZ7x+PHgiYve4/DhSGveXM6TnzUL7TtokHwOWrcOjnfJEnl/Wb2a+Ykn1PSu1atRjkogYv160LNUAhHbtsnH2YNCO1cP4nHkucrUeJyhCrDNjE4vc6wGYmPNyzLj81mtD0biVgXKZkZeQo6hE0/QasXEJBuUNhvkGVVcxj//xMpdVsegIOZXXhGLJsTFYSIdPNh1MjQQFATn/dJL8jqcPQvFnYwylgauX8ek/cor8jwOHIDsniyPuDgsKLp0kQcHDwiAs/ntN/HCz26HaEOLFligyNCvHyZvmbBGYCAUmlTiJgMGwGnKduLnz2NhFRws70svv4wFmWzxuWoVAtnbbOI8YmIQcF0VkH3ePDUX9vDhDO0g4Lneu2c+jpnNx4wzzMaz3W4+pt3Z/ZnNLXFx5vV2Z5572NA8Vw9C81wzCTIpT5BZ/r2UCN+0Mn63zfj3xjcnGaxWfOuVwW53fNf6OzCrq92O+v6dutps+A6vqqtZmz6WyKT9978Gd/2BvtCkofGIYeYEVI7I+HszG5WzIkoffeXvwKwe7pRjVlezMogyoWPV+NchU1JxZs2aRRUqVCAfHx9q2LAhHThwQGq7d+9e8vLycvm5fPnyQ6yxhoaGhsZ/CZnOua5YsYKGDx9OY8eOpdOnT1OrVq2oc+fOdPPmTeXfXblyhcLCwu7/VKlS5SHVWENDQ0Pjv4ZM51y/++47GjBgAA0cOJBq1KhB06dPpzJlytDPP/+s/LuiRYtS8eLF7/9kcedsSeORwW4Hhy4pCXy8uDhXkYOAAPBxz5zB56rr113zuXMHHM7z58FrTEx0FaZgBvf31CmUJcOJE+AYqoQmQkLAS1UpEKWmEv3xh7kC0apV5jabNqkDpRPh2cxs/vzT3GbXLnOb3bvN1Zf8/IgiItQ2/v4QCVHhxg2IRKhw6xbqpEJYGIRGVLdPwsIgICITbWBG//rzTwRYzwibDdzugAD0oyNHXMszxDcuX0bg9PPnwWd1LiM2FnaJiRgPqr6o8WiRqZxrWloa+fn5UUdnRQMi6tixIx1WsdKJqEGDBlSiRAlq37497dmzR2mbmppKcXFx6X7+DpgxoDZuBMFbdCIdH4/0X38lmjkTk0tGXLgAJZkZM6Dwc+FC+nS7HZP2d99BwGDUKNfJJyQEpPHRo4mGDweh39mhMGMSeecdiBO8+SbRb7+lzyMyEuIOL75I9OyzRD17QiHJOY9ly0CAb9QIogKLF6fPIyiIqHNniGUUKULUrFl652m34zkLFYIIRb58rpOk3U707rvIv2FDtF1GFC7suB9SpgxRlSpwuM7w8kLaCy+grHLl4EQzonZtCAEULIi6L1vmalOqFNHq1SDDjx4tnmhz5MCCoF49vHPZpH7lCsQ7QkPF6URYXAwapHZ6hw+jT6iwYYO5ktG8eWhLGZiJxo1DH5MhPp7o1VfRBjJcukT09NNEJUvKbVasQP+qXFmcHh0NgZG6dfHOM8JigUPt2hVCK2XKuH6njY4mGjaMqGZNvNe0NFfxAZsNoiJ58iCPlSuJKlVyLW/WLPTFKlWI+veHeINzeXY7xgQR0etvQNRk0yaIoDjX+bXXIIKQOzfEKC5dSl/Oxo0op2hRiClMn55+gZaURPT88xgPjRuLhThWrCB65hm0TbduREuWpO+jCQlEb71F1KcP/h050vWdb9+OOWLkSPSJpUvT91Fmou+/J/r0U6Jp0zDWM855zBDw+OYbCGqsWCFWPvvtN/TNP/4gOn7cNZ0IC9UVK4h27MBC6aHgodxd9hBCQkKYiPhQBvLh5MmTuWrVqsK/uXz5Ms+dO5f9/Pz48OHDPGTIEPby8uJ9+/ZJy/n888+ZiFx+/g4V59o1UC68vUEaF2HHDvAvvb2Z9+93TU9LY54+nTlvXtzYF3EwIyJAdzAI3BmJ5MwQqHjiCaQXLOhals0G4nv+/LCpW9e1zlFR4KMaZPP27V0pJwcPIjhzliwQrejRA3EnnZ9n8mTwK0uXBudz0KD0NleugBxeqhREDmrWRLDmPXtAdbHZwLvLm5f5866gMvSu48cTJ4JmY1CADF5jvXrgP773HhgPzhShmzdR31y5wAncvNmVQnT3LupABJ6lKF5sXBxixRKBNyiiIcXEOAQBRo8W2wQHg8NauDAEOUQwhCb69pXTFqZNg8iGiiLz/PNoGxlXMC0NAhzjxsnz2LkTdVGF4TOEA2QUjAsX0FdkAhEJCaDiGOImIgQFIQA5EYLJixAcjH5AJA/Xd+KE4z1++61relQU82efIR9vb/y383tMSADPs1078FmLFsV7MqhMsbGg/PTrh/7dpw76b796fvd55eHhoEl1746/b9EC423aNEcbhoeDU/v007DJkwdj1jm0X1wchGEaNgSP2MuL+d1301Ov7HbwtytVwjMXLcr8+++ufXPoUMcc1LatWLjBeEdZs+IdiPiw3brBpkQJ8KhFY6BHD9i0aiWnkvXogfYfMkQe4/eFFzDefvzxwWhLIvwrea6Gcz2cgQ08adIkrlatmtv5PPfcc9xVJt3CzCkpKRwbG3v/59atWx7jue7bJ1YiMWCxgJSu4oVGRIAMruKAHT6MQM0yvprVyjxzJvOECXIuaHg4JsPTp+UxSXftgvjDgQNiMnhKCviCsbEgwTs7TgP+/lgohIdD3Sdj4G+bzaFqde0aFhjPPJN+wAYHO0QkLi2Fc23WDJODgTt3oAx05w4GWcOGEAJwRlQU6rhzJyaOF15wre+tW6jj8OGYfEUBuY8exd+WKycXZvj2W0xk3brJ33e7dlh8yNRpoqMdE9TBg2KbmTMdijyyiaVePWZfX7wjEXbtwgTWsKE43W4HT1al0HToEBYKOXKI061WTO5EUJUSISkJfNts2bD4EeHsWSykqlQRc0TtduaOHTE+nntOvKD4+WeIIGzYwPzJJ+IySpRAmtFvnZGSAofauzfazmbD2HdGx44QY1i69C+n8BfP1XbCwXOdOxeqVhs2wFnfvOnqzPz9IRyxfz/mjyVLXN+zxcL89dcYo1u2iBfmzOB+Bwejb8v4tceOQZFt8WJ5v71+HQsClSrY+vVYKMu41cxYqP32m3o+PHJELnhh4NQp9/jC7uBfyXNNS0ujnDlz0sqVK+mll166//v333+fzpw5Q/v27XMrn8mTJ9PSpUvJX3T2KkBm5bna7ebUB3dsMg1n8P/gCaaluWqVOuPu3fSaqQaMNgkKIipfXvy3SUn4VpwlC46+MyIlBVq7ISE4Phfh8GHUr2ZNuR7q/PlE1avjmFCEEydQTtOmco3io0fRF5o2FVNd7tyBPmv+/DiKzdhnmPGsZ8/iqL9aNXldgoLwKUGEpCQI8tvt+OQgyyMhgahVKzFtJzkZ3zbz5sURvwgXLkAXOjlZ3K7h4WgrX19x/7fZcMSdP784fyLzvuWCTMRzNZsTDK+isnFn7nkc4a4/yFTOlYioadOm1LBhQ5o1a9b939WsWZNeeOEFmjp1qlt59OjRg6Kjo2m32U2Hv5BZnet/DploctLQcIHuv5kC/1oRiREjRlCvXr2oUaNG1Lx5c5o7dy7dvHmTBg8eTEREo0ePppCQEFqyZAkREU2fPp3Kly9PtWrVorS0NFq6dCmtXr2aVq9e/SgfQ0NDQ0PjX4xM51xfeeUVunv3Lk2YMIHCwsKodu3atGXLFir31/lPWFhYOs5rWloajRw5kkJCQsjX15dq1apFmzdvpi5dujyqR9DQ0NDQ+Jcj0x0LPwroY+FMAn2sppGZoftvpsC/9lhY4/GDmRh7cjKEE0SXP1JTwSeMicGlHOcLDsnJ+H10NH4qV3ZwH5nBzzPSoqOJKsUSNciQf0SEIwi91Yp/GzXCRRUDVisu9OTOjUsw+fLh34yBsc+cwQWNSpVgK8LNm+AB168v18hNSiI6fRrB2WUXPpiJjh3DBSPVpZCzZ8GXVcHfn6hGDbVNQICcM2rg+nUxh9MZ164hH1WdQ0PB35RdriJCQO7UVNeg9s6IicH7rV5dbRMQIA/ebpR17hyCgovqbbejzgEBeK/O/ZgZ7zM2Fhe6YmPBYa1aNX0e166hrlmzYpxky4bA385jJjWVKAdB9CRrCvjUJUqkb6djx1DHggVRTv786fOIiIDARMGC6MMZLwzZbGiTAgXk49UscIKGm/DM5eR/N/5uyDm7HSGyPv8cFANROK2YGFAzhg0DNUMULP3YMeaPPmJ+4w1QNDLmY7HginyfPgi5Vb++6/X/GzcQ8PqZZxCE+6mn0seXtdsRO/Xppx2c0J9/Tp9HcDBCnFWvDmpFxYrp+WVG4PeyZRF3kwhxXJ3jml644AhWTcTcuDF+Z9Ai4uMRE9X4+2zZUK+gIMe1/H37QA0x8hjbGVSGuzsdVIakJNAlsmSBTaVKaMeM9Ivdu0GtIAIHcOtW1/aPjESMXCLmYsXEsWltNlA8cufGO5AFXR8zBu02fjzeiQjffQd+nyoO5cyZ4EmqQoR9/z36hQpffCHnXxsYOlReVwPPPaeORRwbi3etoqMdPcpcu7Y4lB8znvXLL9F+InpFWhroVD17gqspioV74QJ4kbVqgYIkor3fuYPx4eODPiFqQ5sNcYGNPvjqq3hGZ0RHo76GTZUq4GkbsFrB4fzjE/TfBuTH2bIxjxjheL6UFPQDgxtKBC6wcwzl2FjQcIz0HDnQv5zHd1gYxjUReOxPP52e2mO3Izaqry945w0aIESgM+0vKQnjoFIl0N1efz193GRm0H2qVAFfvFs35h9+cI13268feLsvvYR3cfp0+jzsdlCCunbFnPX112Je+ejRoDyNGSOnZ332GfP772M8mvVhM/wrea6PCp6I5xobC05p/vzigczMfPUqOmr27GIRCbsdnbZ+fQwcg/vpjKQkdMICBeTBr4OCEADaywtOYulS13K2bsXgzZIFg+iHH9LbJCTgeXLlAh+weHFXgYELFzDx+PpiMVC4MDh7BqxWcGSLFUOg7SZNmIsUgaCB4UCDg9EmtWoxDxwIAYdSpUAcDw7G5LZkCRz5rx9gcnq2hB9XqoQg4cYkdvo0HPHzz8NhlSiBRYqzOENEBLiHFSqgjM6dXcntiYngr+bIAbvp012dSVoa87PPYgJr3x4B4zMiLQ0TCxEmcJFDSkkBT5YICzMR1y88HPzTevXAvxVh0ya869WrxenMmMTq1ZNzp+12tHHGfuAMQ0RCVo/UVLSHipI+bx4WUn36iNNv3nSIeHz1ldhm927kQZSe5+z8LGvWwGlmzSrmEJ87h/6TLx/s1qxJn37rFkQZKlbEItHHB3U33lFsLLjQLVqgr/XqBd7rmDEYo3Y7Jvz27ZkLFUIe376B/juynd99Z/XLL8ijcGE4wiFDsGCYO9fxrnbuhGhEiRLomyVLYpFjCFEwgx9evjzq27gxRCC++ir9AiY5GXnUq4fnadxYPFdVr46+kCUL6hMe7mrTti3GSMmSaBfRYqpTJ0f/P3rUNZ0ZXNls2SB4IYsP27Mn6v3TT+kX8M544QW0465dDxZbWgTtXD0ITwZLj4lRr+yZEexZ1kmYHYG+VSISMTGOYM8ynDkjFzhgRv4LF8KRyvIJC8PqWRVgeedODC6rVTxA4uIcE0FSkjiAufPuIzoaTtGZfJ6YyJx8yBFsOjQUzsT5BMBiwcKCGe2zciXzH3+kL8dmA8HeYsECY/x417oY7XLlCvM772BHmxGJiUj79ls4aBGCgrCgGDRIPuAXL8Zkdv68OJ0Zu6UJE+TpV65A4EE2gTHjVODjj8XPwgyhjPffFzsrA/v2YTdy7Zo4PS4OilwffSTPIywMix/RyYGBsWPhYGX97fhxOJdBg8TpVisUhL79FgIFIsydC8fm5yc+OThzBs8SGAgRlowCKsnJcK4nTjjGTsYd9Pz5yPv+zlIQLP3ECZRljPXISFfRhYgI7ByNPiRS4kpLczjBkyfl7zkpCX1/xQr5mLfZmLdvFyszGbBacfKimut27YKqm8rZHTtmvtO8dMk8uHto6N93qgb+lSISjwr6QlMmwWN2IcQdkrxMpMKAzQZBA9W3x8TE9Bq0onp4IhC6p2DWLmlpqGvGb97OuHULWr4yJCfjcFQmvOFOPR46HrP+qyGGvtCkofGI4c7ErXKsRLh0onKsRGrH6m49HibM6uOOqpHKsRKlv7D2/9ZDQ+PvQHcvDQ0NDQ0ND0M7Vw0NDQ0NDQ9DO1cNDQ0NDQ0PQ39zfQRwJ6KExaL+9pSWhksbMiI+MwjlXl6IUiJCQgLRjRsIAi76/pSaShQcjO9+IvEAqxUXS4KCxBFKjPQbNyD+kFHIIC0N+QcGIsJI9+6u9QsKQnpgIAJFG9FlmEH+N9Ju3CDqWJioYYY6xsRARCIyEu0RH48g8M51TU0FyT852fFTpQqCaDvjyhW8Fx8fBPv29UVgameEhqLepUrJv4UmJiISjii6jAFmPJOZaENoqDqoOBHaKWM9M+LePXWEFyKIJJjd53Mnn8REPLfqu2hKCsQZChZU29y9a37ZKyTEVdTBgN2OvhEe7irqkJICcZLUVMdP2bIQYDDATLR7N/719cUFqkKFYOeMs2chAFG0KH6KFUPEHud+aLdjt/PHH0R5IogqVEDEJR8fh82WLYhQVL480kuVSl/n4GCiI0eQVqECxovzXMNMtHUr6lChAto341x0/TrGTcWKrkHdjXqeOIE6FC0qnstCQzFWSpeWi1VcvYpv56p+EBWF9lTNl+5EH3okkb08czn5342/S8Wx2UDd6NoVxOoVK1xt7t5l/uAD8N0KFBBTZA4eRB6VK4NjlpGukJoK+k2DBgiYTJSerM6M6/Ndu4KXagRCd75Sb7WCL1a+PLiRRODzXbnisLl2DSIUhjBD9eqgmxg2FgtoDrlyOQjtH33EvG6dg2x+7Bhzo0aO9EaNcHV/2zZwGe/eBYk+Z06k58oFrtvPP4PyERmJQNP16zvyeLsxqAzrP/fjo0fBNQwPh/hB1qywqVwZbbRzp4Ogb7fjnTiLSMyYgXo449o1kOaN8oYMcaVDJSWBl2uQ9F95JT2J3yjv00/BoWzf3hETNCN+/hlc48mTXUn6BpYuBRdQRYv47TeIGKioCHPnymN8GpgwQRy71hn9+qnTQ0LAAZbRPKxW5kWLmFu2FItIpKVBKKBXLwhNiIJjb9qEetSuDZ7lpUuuNocPo49nywbOpygYfVAQ+KVG0O/Jk9O/77Q0jMkOHRx9ont3R7+x2fBefv0V/G7DpnJlUMCsVpSxZQvEDcY/7xCRyJ4df3PtGsbVmjXMkyahvxj51K2LeSIxETzu335DXzL6evbsGHcJCeiXR46A/uM87po2dYg3pKSAHjN+vCO9YEHUzYgPa7OhfRs0QHru3OCGX7yYvu1mzXLUoXp15qlTXemFXbvCpkwZcMpFFKKnn8Y4adwYzyKagtu1A3+3Sxe0q6ift2+PZx0wQE4Vcxea5+pBeILnarNBNaZNGznfMC4ODqZsWXDbRLh2DYMud26xjSEA0bo1bERlxcWBQF68OOx27nS1uXgRJPocOaAatXx5+nSrFQ61Vi1MLm+95UrqDwnBgqFwYTi0Xr2Y+/ZNX9dNm9DpBw+GUELPnpg0jMEcGYkJo21bTLoffwwOY4UKWDjY7WjXFi2YD/6Iyenr1/y4QwcIQRiBrq9dg6N7+21MUi+8gPRXX3XUJzYW9a1TB/WpUgWEemdHYLHAyeTMiTqVLu06edvtmEy8vCCKMW+e+D2NHYvJpVo18YRgt6PNiMQLMmbUrV498GVlikZ37kBoQiQ6YuCXXzABqXjRrVphgSSDnx8mYxlsNkyoKge8axeed9EicXpqKuqRLZtYxYwZztdQ0RI5VosFk3Xu3HB0IptPPoFjbtQIzuHkyfTpa9bg3bZvj8VbpUrpF7uXL6PfP/EE+twvv8AhzZqFvp2SgvQ6ddAvv/iCeeeX6L9fvep3X4jj1VdRh969sUD68UeIoaxb53hXc+agTd5+GyIftWtDFCQkxFGfkycxTt9/HwHa69RBn3JeLMTGYlx88gkcWv/+ELZxht0OB9WhA5zijBlijunYsWjfZ54RC+IwI5/cuREw3bmuzujfH+Nj/nzXRaqBfv3Qrw4ckC8gBwzAYj04WJz+INDO1YPwpIgEs1r8gRmDTzZRGggPNxejOHxYLUaRnOwqOZYR16+LV4sGbDbzlWBEhHxgMGNAREWp8xDJnmXMw3LMlYSfsa3j483zdVYYkpHtjx9H3uHhjoVARmzYAJEB0a7UqPPYsa6nC85ITHSVjsuIY8cgZKCCbOdrIClJ/hwGLBZzIr7ZEElKYr59W23z55/qMRIaCmclQ2IinEjG3ZQzAgMhMiLbiYeF4XnPnhWPs/h4xxiNinIdr1Zr+t/Z7a59z+UZBSISGZGYaP4OzMbS7dvqRVRKikNsRYaLF9VzS2qq8jGYGW0rkq90RlCQuq7MrqIaIpjNuQ8CLSLhQWgRiUyCTEjCNw7gNOfSs3jsBCLcQSbsv/9FaBEJDY1MgMdJOenfhEznWDX+ddBdUENDQ0NDw8PQzlVDQ0NDQ8PD0M5VQ0NDQ0PDw9DfXB8ywsMR6URGfLdaiS5dAlm/fHmxzd27uPNQrhxRtWriPPz9cT/iySchViCqx+nTIHv37+/63S85mej8edg0aULUoEH6dJuNKCCA6MwZiDO8954rWT0kBOlnzxK9+CJRrVrp87hzB2lnzxLlzk309tvp0+/dQ9qZMxB5mDYNdgZiY4nOnUP6mTNEw1sT1cnwnKmpqKe/P9Hly7joMm5c+rrabKhrUJDj5/XXXdstPByCA1FRqHu+fETPPONa53v3HKIDaWlEdeumJ7knJ0OQIVcuiA6Ivg8yg8ivElEggtCCKvKL0QY5cqhtrFZXEZB/ysZmw3tQRb2x21FvlcCA1QqRCJmQisWC9LQ0iB044+ZNjKPs2dE2OXIQlSiRvu6xsUSrV0OAo0gR/FuqlGt7L1oE23LlMGbLl3cV0vD3J5o1C0Iq1avj3+LFXceMFxH9+CNR0WeI6teHmImzCMOGDUSHDiGtXj2IYzjX+c4doi+/RJ+rXx9lZRRYmDMH5davDwGZjM9z6RLRtm2OMkTBJebNQ3s0aIDnzjh/XL1KtH8/0mvXFve/VaswBp54Qi50s2kThCZq1pT3l0OHMFZleRARXbiAtjQbBx6F5y4o/3vhCRGJefPACyMSx/eMjASny8cHNhmDMzNDPMFZNCGj0ERKCmJIGsILROCAOuPCBXBbnQntztxFiwUBwA0RCiJwyJzrfPEiiNtGetmy4M7NnYt0Q8wif36HTfv24LgaXNgDB8DNM9LLlQMJfNAgcP5u3ABXL29epPv4OIKdv/MOuKbTpjnI7ETMnYs5gk2//z7K+vVXcHBz5ICNEXT67beRvm0b2m32bDwHETih3buDd7typeMa//Hj6dvu2WcRqN2ZznHnDp7TsKlRw5UraLXiGb29YVOzppgStHAhAmM3aSLnRm/ZAo7vrFlyisbevWgzkeCCga1bEWRchXnz1BQxq5V59Gh1Hjt2oH1k9Irbt5H+3HNiCozNBl5k1apoF1Eg+hUrIF5ABK5yRkqI1co8c6bjHRUvjji1zu134gT6hyEikTMngpsbtI+AAIh8vPsueKVGXt26gd4WGQlu5pgx4Ko2buywqVYN/NCZM5HngAEIHN6zkkNEwscH88HXXyOP3r0x5ipUcOTTsCGedc8eCCy89hrGlPHsefIwf/ghaFqXLoGe1L07BBeMPJo3d/CFIyLA7372WUd6rlwQzzCodGlp4JVWruywadHClXPfv78j3dcX81JGOp6zIEaDBmIRE2O85ciBto6JcbVp2RI2FSu6vkcDjRqBG92lS3pBnP8HmufqQXiK5xoczDxunJi0zoxOsX8/8xtvOIKHZ0RiIvOCBRBekNkEBoIIXr68ONCwzYZJ7sUXIRSRcfJnBv/su+9AoF+9WsyHPXECE+HAgSDuZ5ycExLgcJs2xXOtXesqRnHmDBzqN99gcK1YgXINDl18PBxf//7g0+7dC1WiL7+Ek7fbweft1Yv51npMTkdn+fHChRCLMIJhR0RgIpsyBZPJsmVI//JLR11SU1Hfdu3gdL/5Bk7YebDa7eCvVq8O5/7222J1pD17MIk++ywcvAgHDmDB1a2bOJ0ZTq9aNTWX+IcfICSgwoQJal7i7dtqkQlmvEMVLzExEapZKuzbh74nQ3IyFlAip2lg8mQskGTD8fhxOMU+fVy5pczo/337YjE1ZIh4wv72Wyyunn0W/TujyMG2bXDyixahv/bsCd6mgYAALA5nzMAC6MIFCDRs2IDyExPhEKdPR5sdOcIcthn9d9Ewv/tc1fnzoZi2bh2EIHbswJg9etTRLw8cQL/dsgV1ePZZ/I0z/zMwEHXduRPqYH36uCoixcdjvOzYASGX6dNd28Zux8J/4EDmHj0w5kXObNs2OODPP5fzmkeNgvNcvlzeNz/4AGVlFPFwxhdfYBxHRMhtpk/HQlk1BtyF5rl6EI8rz9Vmk+t2EuFYjUh9FOJOoG2LRZ2HmbYnM/JR1dWMl+iWNqgbPEF38rFYcNSmsrNaoT3rfEydEampOG7OqFHsjJgYHDdn1F12RnS0+fFwpuR1SmD2LPHx6I+qPnfoED6JqODvr253Ive0ki0W9RE30cPrv8ZsbtZ3VUf3FgvGquodpKSk1zzOCHcC3rujVW02xz0KaJ7rfwBmnc6d7wvuBNo2y8dMNNvLy7yuZo7BU1xQd/IxmyiJMDmpHCsR2k3lWIkgjO4sBC+CmWMl+vc4ViLzZ8mTxzwPM8dKZO5YicwdK5F7/eVh9V93yjH7Ju7O86gcK5F7Ae/d2ac8bo71QfAvGpIaGhoaGhqPB7Rz1dDQ0NDQ8DC0c9XQ0NDQ0PAwtHPV0NDQ0NDwMPSFpoeIiAiifftAqq5Z0zXdbodww969RE8/7Sq6QIQbdgcPwubNN0EWdwYz0ZUrSD9wgGjqVKKyZdPbxMcTHT6MumTNSjRhgmse/v5I37+faOxY1NkZ0dGox759uLwwdWr6dIsFlx7374fdDz8QVaiQvoyAAKTv34/nGDEi/YWMyEg8w/79RDduEP3+e/oLWMZzGHnM6EdUX9Cm/v64PXr4MC4Pffed68WPO3eIjh8nOnECwhmzZrkKfaSkEF286BCtaNoU7yBjeTdvokx/f9wGHj/e9WJGbCxRcDAEK2JiiHr1cr3IY7XitmpMDAj7Zhef/mm4deP1ISAgAJfFChRAf8hYp8uXiY4dg7hBuXJEpUu7XtI5cQICETVqOIQdMl6wSUkhevddjJ/69fFTpoxreTNn4qJvkyb4qVPHtbwbN4gGDUKfadECP84X1ZiJUlOIfIjok0+Iyr1E1Lo15gmjPGaideuI5s9HWps2uFTsXFZsLARQ6tVDeosWrhfAvvqK6Pp1pLdujfZxRlAQ0YcfErVsifT69V3774QJGH+tW8MuY9+8eZNo1CiiVq1QTo0arv37xx+Jbt0ieuop5CESA/n2W8wvbdpgDhJddvvlF5Tfpg3GiQi//46+0KiRexe2PIK/z/r59+Pv8lytVvAQixcH2dngXjojIgJcToMAnpEPygxOWcOGDuL14sXp05OSmMePR8BqIgTrnjkzvc3Zswhg7OXlIHhPnepIT0sDx88QvCCCGMTIkQ6bc+fARcya1ZFH/vyOwOPJycizfHmHKEOBAqhXkyaw2bMHhO4sWWCTLx/yKFQIRPlz58BxM9osVy4IKhQogCDVFSpAGKFZM8ezPlsCPMHWuf24eHEICPTuDZK+IYphlFO4MHh4r7wCPu4334BPSoQ65c+P+jduDG6c3Q7u3jPPONqlUCGQ30+ccLTN9evgvhqiFYUKub6D+HiQ6g2RjYYNXd+13Q4RCeP5z51ztTH6RNWqEAiQ4dIl5pdeUnP8AgPlQa0NfP21PKi1UeelS9V5rF4NoQlZfNp79/CO+/UT80+ZHSIdXbuK+b979zreUcuWrvxrqxXiCYZN9eoQyHCOZ/vhh+g/2bI53uMnnyDOKzPEQ2rXRp/MnRs22bKB+7lvH7jUdeowly6N91ykiGO81KkDbmatWhBPKVgQNh0LO0Qk8uRBG7Rrh7FYsCB+SpRw1LtNG/C1p0xhLlXKMcaMOaRkSXBJo6OZN21CX8qf31HfLFmYO3d2iDcYAd7z53fMD6VKgVdsiIckJqIMX1/H2O7UyVWoo3RpRx5FiuB5MwZVdxaiaN4cfN2MqFfPMce8+66YZ20IdJQvj/YQ8W6NefOZZ+T6AO5Ci0h4EJ4SkbBYQOIWCTsYiI5GIOjAQLnNxYsIsi2zSU0FWb13b/kEFRICJ/r99+LOaLNhknjrLZDARcGG79wBWf2HH5BHxsnbbmc+eNAxKGw2VyWiiAjmH390iA9YLKizoeBjsTBv345Fg1HPtDSoIhkKPlevIj1yGyYn+0k/Tk6GSo5BLE9IgJjDwoWOPCIjmW/eTF/fAwdQ35QU1EOk5nLtGvOIEXiX16+LhQoiIkCg//BDuSDCvXtwshMnitOZIQTw3XfqQOZ376r7lJGPGcyCcLsDszwSE80DV5sF2d63DwHVZbh3D0IKu3bJ63PyJHPHjlAwE6lFBQfjHX70ERaxGZWpoqKYb91CP9m4EQsPZxGDxETkEReHOiQkIK9Tp/D/Fgv63r17Tu3xV7D07VP97juiO3fQv4w6njqFhatzMPOEBEcQdasVfW7nzvTtnJbmUEj69VeM2fDw9M9ks8EuOhoLxD17XNvGKOOnn9AvZX07OhqLgy1b5H130SKMW5GIjYE5c1Bf0Rgz8PvvmGdUQdU3b8b78AS0iIQH8biKSGhkwGMYbNodcYfH5bj13wJ3hBQeS9GNx7D/arhCi0hoaDwGcGcC147Vs3CnPR87x6rxr4PuYhoaGhoaGh5GpnSus2bNogoVKpCPjw81bNiQDhw4oLTft28fNWzYkHx8fKhixYo0e/bsh1RTDQ0NDY3/Ih7Iud66deufqofbWLFiBQ0fPpzGjh1Lp0+fplatWlHnzp3p5s2bQvvAwEDq0qULtWrVik6fPk1jxoyhYcOG0erVqx9yzTU0NDQ0/it4IOdavXp1GjduHCUmJv5T9THFd999RwMGDKCBAwdSjRo1aPr06VSmTBn6+eefhfazZ8+msmXL0vTp06lGjRo0cOBA6t+/P33zzTcPueaeh81mnp6crLYxe5V2OwJy/508PFGPpCTURQa73bwMd8ohckS88URe7tionkvjweFOe5r1JyMfs75P5N47TklBv/q7SEx0XNgSwWJxRMNS5aFCcrL53PIw8iAyz+NxxgNdaNq5cyd98MEHNH/+fJo8eTL169fvn6qXEGlpaeTn50effPJJut937NiRDh8+LPybI0eOUMeOHdP9rlOnTjR//nyyWCyUTcAoTk1NpVSnHhoXF/e3656aSrRnD9GmTSB5t2jhahMWRrR5M9HGjUQff+wa2cNux0XCjRvxM2MGyNfOiIsj2r4d5ezcSfTnn+kFKwyBiI0bYVO4MNH33xOVL++wSUzE323aRLRlC0QXGjQgqlrVkcfly456FCwI0nn+/A5Ri7g4oh07kL5zJ9Hs2UjPnp2oWTPXZ2nRguiVVxx1aNKE6O5d1GHTJpDSZ8xI/6ylS0N0Y+NG1HPRMKKOhEuXCQmwMYj6mzbBrmRJovfec+SRMyeI5TExRNu2wW7fPhD1fX1h07IlLsDYbERHjjjq3K0bUceOEA1wJtFfv+4oz2YDyb1SpfR1N8rbuBGCCAsXuvaHtDSIY2zdSvTpp2IRCWYIWhDhHckQFkZUooQ8PS4OQgGqKEkREURFiqgvA4WGoo1liIlBu8qiqjATrV8P8YFChcQ2K1YgTF/XruKoQwEBRK+9RtSlC2waNXKt87p1RB99RPTss7Bp3x59wcD586jre+9BRKJrV9gawiI3b0JsgYho1Sq8p65dHeXdu0d04YIjv4QEiEi0awebNm0g9uKM3FeJniCivn2Jqr4Ku9TU9A7+9GkIshhltW4NIYaQEKTb7UQDBqAvPPcc6lykCARZLl+GzaJFeD4jj/r1cQksMRFj8t49osGD0befew7/GpdibTYIsvz0E8o18qhVK/1Fsj17iAYOJOrQAenOeRj4+GOIfRh5NGjgehmtXz88f9eueJ9Firi+72HD0He7dkW/EYlEjB2L/tS1K1GVKq7p/wQeyLm2aNGCjh07RkuWLKGxY8fSjz/+SN9//z099dRT/1D10iMqKopsNhsVK1Ys3e+LFStG4eHhwr8JDw8X2lutVoqKiqISghln6tSp9MUXX3is3jYbFEKWLYNyUqtWrjaRkXAe69cTXbqETpUR+/cTzZ2LyfbePTgfZyQnE82bB+WZo0fR4a5cSe9cz52DosymTZigqlXDYDGcq8VCtHgx0R9/QFnJZiNaupQoKsrhXC9cQF03bcKkXa0aHHC9enCuKSlwTqtWwRl5e+P/vbzgIJo1c32WLFkcEwQR0aRJREuWEG3YgGcoVgxlGLDbUedz5xz13LIFznXpUqIb+WFXtiwmjc2b4Rxq1EifT5kyUOeZM4dozRoo9/j4EDkfhDRrhgG7dSuc4I4dmCz37kVbfP65w/EFBBBNnw6nefMm6rhvX3rnmpCQvrzWrV3ftd2O97h0Kf5+6FCxcz1yBAuXunXlzjUoCO0/caI4nQiTtq8vFjUybN9O1KkT3oUMy5ZhoSW7sXvxIt5nnz7i0Gc2GxZ7Fy5g0hQxHY4cgXMMCCAaPtx14XLvHhYc16/DZuBAOE9nLF+OhcDChbAJDSXq398xMa9ZgzaJiEAfCwjAzwcfYJFy/DjeDRH+9uxZtLNRXsGC6fsZEcbQb7/B5uJFLAKdlY8q3oNzPXeeaGsE7FJS0jvXhASiwED0n4AAzBtG/zYQHY2+c+0abN9/H21u1Cc4GO1z4wZsBg/GQj4qCjbMyHfJEqTfukU0ZAjGRVoabK5dwzxltPE774BFZGDxYqie/for0oODYWMsWIng7P38UMeAAKK333bdLAQHY64ICEB933/fNQTjmTMYRwEBeIaePV37359/4j0FBKBfVa9O/zz+XyJtUlISjxs3jnPmzMkvvvgiXxNJpXgYISEhTER8+PDhdL+fNGkSV6tWTfg3VapU4SlTpqT73cGDB5mIOMyQW8mAlJQUjo2Nvf9z69Ytj4hIMINUHhmptrl+HcINMqSlgeCtEg6IjARJ25nY7gybDcpCf/whzyM6GoonsnKMPFasUNdj8WKHsk1GGM+ybZs8j6tXoaAjI4nfvQvVq5CNIOGLVAhsNqjmGGIVMoSFQcRDJr7BDDL+tm1qRSO7HapKS5aoywsNVQsiMEMkIKOIwX8Zd++qxSoiI6HKpBLeCAiACprqPdts6HdmU9uOHebl3bnDvGCBq3BDOvwlInF2kZ+0r586xbxunasYi4GUFOa5c9WCCZs2QSxFJuYRFoYxq5qnVq9mPnpUPibDwzH/qPLYvBljSKbWxYxxZib+cOKEQ1BGhhs3PCOSwvwQFJoSExP5wIEDPHz4cPb29uYcOXLwiBEjOM4dKZj/E6mpqZwlSxZes2ZNut8PGzaMW7duLfybVq1a8bBhw9L9bs2aNZw1a1ZOU40GJ3hKoUnjH4af3LlqaDz20P03U8Bdf/BAF5pmz55NAwYMoLp161K+fPno6aefpkOHDtHQoUNp1qxZdObMGapZsyadPHnS81tsIsqePTs1bNiQdu7cme73O3fupBaij5hE1Lx5cxf7HTt2UKNGjYTfWzU0NDQ0NP4uHuib6+TJk6lZs2bUp08fatasGTVq1Ihy5MhxP71///40ZcoU6tu3L11w/prvQYwYMYJ69epFjRo1oubNm9PcuXPp5s2bNHjwYCIiGj16NIWEhNCSJUuIiGjw4ME0c+ZMGjFiBA0aNIiOHDlC8+fPp+XLl/8j9dPQ0NDQ0Hgg5+oOz3XAgAE0bty4/7tCZnjllVfo7t27NGHCBAoLC6PatWvTli1bqFy5ckREFBYWlo7zWqFCBdqyZQt98MEH9NNPP1HJkiXpxx9/pO7du/9jddTQ0NDQ+G/D49rCRYsWpd27d3s623R455136J133hGmLVq0yOV3bdq0oVOnTv2jddLQ0NDQ0DDgcflDLy8vatOmjaez/VchLc083YxaGxGBq+4yMINDFhsrt0lIgI0K/v64li9DSgqu06tw5Yq6HklJrpw/ZzCDuqAiz0dFqcsgAonf4PqpcOaM+TsKClLXmQjvaMcOtU1kJKhEKkhYZunwbxKiMHuWyEi1uIDVCgqXKp/4eNDezMrau9e8L1y+bN73EhNBJXEHqjqFhIBqJIPNBuqQaqxcuKAWx7h3D+NNhZMnHVxyEWJjMS+o6uHnh3Grgr+/ufhGRkqiCGbv8B/BQ7pglanhidvCN24gqHHt2oj/mBFG/NS330YwYhE9IzYWV+Q7dkSg4z17XG2uXGH+7DMEIs6RA3k6Iy0NV/Ffe405Z07mJ590pcEYsV4bNEDA4w8+SE+3sdlAPejfnzlvXuZWrRBDcsYMh014OGJGNm6M4M2ffso8fDjzxx8j3WpFzMk+fRC8uUcPxKgdNgzBsGNiEK928mTmmjUREHzKFATaHjoUsWp37kQsx65d8ayLhuG25fTefjx4MPMbbyDO5vnzCPZerBiCJY8bh5itb7zB/N57jradPRtBlQsUQOzNvn0R0N2gLNhsiC37/PMIEt2tG8rOeLnz0iXmgQNRpxo1mH/+2fU9RUSgTjlzIiC2CPHxqGvRovKYl6mpzGPGILamDGlpCFatineZmJg+6LsIx47JKSDMoDqYBVzftQs/qrq2b+8I4C3Cxx8jiHbGIOgGDh1CcO26dUEZyfjcNhvea7Zs6FezZ7sG8h47FmOkalUEGf/ss/T0uBUrmLt3Zx4yhLlnT7zHvn1Rtt3OfPo0+seAAXjPkyahn7dpg5jCQUH4+3790Oc//dTRf58p6scffwwq1+jR6EsffOCID5w9O/527VpQb5YvR9zlkSPxnkuUwDwzbZojXvGJE6jrqFHMzz2HuvTuDRqR0b9DQzEuPvkEZdSvj/Hj/Nxpaczvv8/81FN45tdfB6UmI/FizBjkUa0a84QJoD5lxCuvIID8c8/hGUR0mq5dMW7ffx/9T0SnefZZzDPTp8vjy3bpgjlmzZq/T2tz1x/okHMPATYbSNdxcUS5c4tXUdHRWNmmpMBGJL9nELrtdqj6ZMwnORkryvBwCDdYLK5qJQEBWNlGR8PG2zu96onFgtW6v79Daq1IEYgxGPD3h82NG6iD1QpxBkMtJyUFJP9DhyCkYLEQ5ckDsn/hwrA5dIho7VqsXhMS8DclSkCQIm9eqOPMn49yrl1DHbJkQT3y5IGazvHjRAcOYOeXmopnIiIqXYaoaC3kk5QEUYdDh7CTjI1FHapUgShDiRJ4zhkzoCpz7Rr+pmxZqEYZbcMM0Yw//gBxngiKL2+8QVS5cvr2nTsX5HdDzei559K/g4QEkOyjooiaNoVyVcb4okZ5djtRjx543yKcOAGhimrVxOlE2GW3a4d+KFNXSkhILzYigpmknZcXRDlUqFYNOyerVSwiYbFAwezSJdQnf35xHhYL3nuZMunbnwjPWLUqUbly6D958xI9/XR6m549iXbvhqjB3r14rkGDHOOlVy+8yz170Df378fzGyISLVtCzCAyEmIpSUlEhw+jXsnJCMc6dCj6cUwM+p4xPg3BlH79HKdU8fFE1r/6b0Qkxk90NFHz5hBnMGxCQ/E3hw6h/VJSiGrXRp5xcejfiYmw3bMH+b31FlHx4hAriYuD4EVSEtp42za0T9OmaItmzTB/WCzYEZ49i3HyxhsOVa0GDfB7ux0iMidOQC3NUGcjwv9brWjX4GC0TcmS6UUkvLzQ3snJGHeXL7uGsU1Nxd/ExmLeMcatM2w2KL/duYM8ihd3FZHw9sbvwsLwU6GCa7/yNHSwdDfg6WDp7gTHTk2VT6hEGGCJiWLVHgNhYei8hkPLCKuV6OpV9aQaFoZ/ZdJ5qano9PXri9OZMUnlzStX9rl7F05YpjCUnAxH2rw5BpHoOc6eJSoRdopKdpUHm757F0e5EtYWEWHCuHYNjlPWbkadIiMxgasQH4+FgLMSj8ajhzvvJSUFTrFsWfV4PX8ezkQ1FsPD4Rjr1hUvKojofrD0O9v8qEgncbB0f3/8feXK4jrFx6OP168vL+fMGSyEZVOZsRAoV07+3BcuYAEjGo9EWDimpjrkIkW4ehULQ1keRl1UimBE5nMlkXtzrrtw1x9o5+oGPO1cNf4h/DU5yZyrhsZjDd1/MwXc9QeZMp6rhoaGhobG4wztXDU0NDQ0NDwM7Vw1NDQ0NDQ8DO1cNTT+Qbhzo8Fi+efr8V+DO4HJ9W0TjX8S2rk+ZEREmBOnT55UCzekpSE+rMomJAQxUWVkcWbECV2xQp5HfDzRrFlqsYqzZxH7UobkZNBOEhMd5WbEpUu4qm/Aak1vl5wMWoozUlPxY+DkSVdyfWJieoJ5WBioO87pGRU9k5IQ45PZcRM6IywWxHsNDMSNRxGZ3mYDvWf+fFARRLBaicaNSx87NiOSkoimTUv/rBlx/bojcLcMoaHqdIvFM0IUqnoSoe+a9f9du9SO79gxdZ+7dw9UG1X8kDNnEKNUJpZw/TryMQKLZ8SdO2hTZtxDOnIkfXpysoM2R4T2Xb/eQWUyaCwialN8fPr/dn4v16+jPGdYLI72YkasWmO8GXBuz9278fwyJCSgTzrXIyPWrgUdSPaeEhOJvvxSPUdt2gTKkWohtHUr5gcVjhxRC2sQYRyraGT/CP4enfa/gb8rImGzQfCgRw+QplevdrWJj0fsyIYNEXVqwwZXmxs3QPAuUgQ2a9emT7fbIT7RrRtEJrJlY/7114zPwjxzJoQZiEA4dxZ/YGa+cIH5nXdANPf2BiH9008d6ampIH23bIk8KlQA2f6NNxw2gYEgrBcqBDGFJ59kLleO+YknkG6xgNDdrh3yaNwYPyVK4G9iYvC8H30EUY2yZUE2r18fogpFi6KNfv2VuWlT1PPzriDh96jox4UKMZcsCTGACxcgeJE9O9q3RQuUU6IEiP9G+3/1FfLNl4+5enXUo2VLR7xJux1tXq0a6lyoEIQ2zp1L336nTjE3auSwmT/f9V0GBaEeRMy1armmMyMWZtOmsJHFfI2ORn26dZPHq4yMZC5TBuIgMuzfDwECFT79VE7SZ0YbduumzmPiRIiAyBAQgHf51VfidLsdggBeXq791sD27WizrFkhgpBRRMJigVCFYTNmjKuIxKefov/kyYP69O+fXkxh5Uq0e+HCGB9EzE8/jTipzMxnzuC9FigAu86dkVflysyzZjHfugWBkYIFmUuXxnse2Q79t4WPH7/9NvpV9+7M+fNjjLVqBVEFIubmzRHDODUVYhH582MMtmuHOuXPzzxihEO8YcsWlFW7tqO+Tz6JcZyaCpsbNyDY8MQTGCt58kBUwt/f8dxpaRjHZcsij/r1ET82o7iIIR6TLRuEJg4edO2fzZohj9Kl0fdE/bN1a9i0bo26pqS42jz1FERD+veXC020aIE6T5igHgfuQItIPEbw8oKAwssvg19WurSrjbc3Ua1aRH37EtWpI+Z2ZclC1KQJ/vXzIypaNH16WhoI123bgnx/+jTydMa9e+Bvdu0KDlru3EQDBzrSrVasyMuVg/jB6dNEX3wBewPBwcinVi2smnPlwmrZ4IWmpTkI9fXrY5X84YeoV758sDlxAjsLHx/Uo3x57LRLlUJ+kZFEv/6KnWGePFgJjxgBu5Il0Qa//AJ5wchIrO4rVULeM2cSFeoAnt//2rvu8CqKr31CL2KQGkBApFuQLkUF5SeCCoiKUkRAioiIoKgoSlGRonQUUHpHKVKkCgSktwChl1BCCiQhvd+75/vj/dab5O6ZvcqlBOd9njxo5mR3dnZmzszsed8TGAgRidOncd28eYmmT8d7KFAA9klJRJMmoU6lSxNdvQohiKeeysyN++MPyOpVroz2feMN1CkjLlxAvevUAbnf1xcE/IxISMDJQ8uW2GHddx+er2BBlw0zCP59+hCNH09UrZp7fyDCLmbWLIgASDy+kBDYqXi7fn5EX3whlxMRde8u852J8Bzffqu+xpdfQpAhLc2a31ixIk53Nm/GqUPRopnLmfE+33/fJTyQtW0eeIDoxx/RzvHxuNYLL7jKc+UiGjYM7zpPHvTlWbOI3n3XxQ395huigQOJXn0V94yPx30HDsTYfP11/KSk4O/i4/FMv/yCMdS0KbigzOC47tyJehBhN5aQgHeSLx/+NiSEKHYbEW1FXw4IQD8eMoTot98gRHH1KsbZ5s0YW9u2of6ffkr0yScuEYVXXsE4uXEDfbZLF/S18HD8fPgh6li2LMbyiRPgmFeogNOYbduIevcmeuIJtOWpUyjLmxe8+WPHcM3y5fF3uXJhF55RzGP8eNc1atdG26SlZeaj1qsHrm3t2hChsRLXeeIJ3Lt2bdTXavf51FPo/3XqyH385Zdxb/OetwOa5+oB7mWeq/n2VQTrrOpBWWEq/0jXYHYfWFkRG+tyvFaIicHfZ1R4yVru2H+Yir0g8wSZcSRZrJg9odzp1MIPGp7Bk74SG4v+a6ocWYEPHSafunXIuf8Q5axnzXONiIDDkwQikpNRF5UwQ0qKuh6SelZG2M0J3hRtuNvgqT/QO9f/ODwZAKpBRGQ/sfj42CuoqBwrkbUMnlu5Ymdm1iOj1KMK2rFqeApP+opd/yZyjUXV9ez6r7T4zAiVYyWyd6xE9nPCvepY/wl0QJOGhoaGhoaXoZ2rhoaGhoaGl6Gdq4aGhoaGhpehnes9DGZ77qIn4Ww65M0dhmHftomJ7nzDrDhxwj7Z89Wr6nKr9IRZcTe9Q7u6ePI8dm2yc6c9r1HFwTRx27mR2QR279CT/uYNXvXdDO1cbyMMA6RplShDbCzR99/jXwmnTyPMPTpafZ8XXpCvEx0NusHXX8uT+6FDRG++CUqB1WSWlgaRhMmTUScrQn5QEFG/frhfQIArx6QJpxM5UjduRMTv7t0g7mccnMHBRNOmuWgNW7finqY4g9MJikJcHP4/NJRo3TqiH34A2d3E3r34fXw8BDR++AH0iow4dw7Uo7NnQaR/9133iSI4mOill4jWrEHeTzO/a0ZcuQKKwCefoI2scPIk8qz26CFPRmvXEjVubC1mYeLTT0ElkuB0gjaiEprYvh30CdWE98MPeIcSgoKI+veXyw0DFKfp02WbmBiiJk2QNk3CN9+AGpacbF2+axdoUj16WD+P04l+3b49qENWbT9mDO4zdCjRxInu19myBTSsP/5Av/rhh8xKW6GhoLwsWIBnMQyisWNdfdQwiAYNgmDJvn2u3xNlFjb57TeiRYtAZ0tJQb9cuDCz8IIp5HLmDH7/zTd4FxkRGQkK0OXLyD87a5Y79cXpRD+4epXonXesxTOIQMUZPx5tJAlNnDuHd7Rpk9y3p03D3CCJrBBhLpg6VX7XRBjj27apHfrGjfZCK17HzdFp/xvwhojEnDnMlSuDEL1smbtNVBQEEwoVgs2KFe42+/Yxt2mDcisRibQ05tmzIYBg2mQVrAgLY/70UwhEmCIHS5Zkttmxg7lFC9c1qlfPLISQlAQCf9myKC9QAKTx8eNdNqdPM3fpAjELHx+Q05s0YR4yBOXp6cwLFrjq6uuL67VoAfJ7aipI7b16gYheuDDEM6pUYX7lFRD/z5xBu1apAqJ/x+og4b9R6RC/+SaI6bt3oy6vvYb7FC/O7OcHIYKhQ5m3bXM905AhIL7nyMFcowbzgAHMa9dmFiFYtAh1JWJ+9ln8f1YC/c6dEKMggmhFWJj7uzxxwmVTuTJzeLi7zYULeO4SJaz7DDPzuXNo/379mJOTrW127UI7X7hgXc7MPH06BDdUeOst5oAAuTwqCu9ChYkTIV4gYd8+CBO89pp1eUICc4cOLmEHK8yc6eq73bq5i0gYBgQJfHxg8+abzImJmW1OnmQeNgzCC6ZAREYRiatXIQbx2msQbTDFQHbsQHl0NOrRuzdEGYoVY86XD/9OnAjBjenTmT/8ENcuXZq5RQn03zo+h7hTJ9RhyRLmd9+FgETx4hBwIIIYxaxZGPPbtmGs1auH+ubNi3H39tvo+8wQgnjjDQhIFCiAa5Qrh2cw+01UFIRaHn7Y1X5t2jDv3+96bqeTuXlziGMQ4d+hQ/G3GdGypesadepgHsr6Hho3RnnOnMydO0PsJStMoZoSJZi//RYiOJJN3bqYEyURiRw58K7PnXMv/yfw1B9onqsH8AbP1enEyun0aRDlrUQBoqOxMj1zBoTorAIQ6ekuyb0zZ4j+9z+QrE2YO7tz5/Bz9ixRx46ZbWJiUHbhApKYp6Rg92qG1jud2IFeuOD6eeMNCECYuHoVBPigIPwYBnaAZgi/wwEBhPPnUX7xIgQKGjZ0XSMggOjPP1F28SJR1aqZd5HR0djlnD2L8ogI7DrLlkW5YWDVn/EaU945TO1GZea5njmDHUNICI4BS5XCKj8j3SA1FTbHj2OFnJIC6bYaNTK3/7p1RMuXg8qQNy9u8dZbmW2CgrDTKV4cYiFlyhA980xmKlJiInY6ZctCFKR6dXf6BTN2eJUrYycn0SNWrMD7NQU0rLBlC/qTis60axcI9ip+5K5dSDSvolls25a5r1hh/Xo8kynikRWGAZGNpk0h9GCF69exA3vqKff3RIR+fvAghEEefxwiAhkRFITdYEgIfkqVIurbN/N7iIrCKZLZJ+67j+jzzzMLFTBj/Bw4ABpMwYJEvXqhnTJi506inj0h/FKiBMbCBx9AlMFEnP9huv/ZOvRK2UOUXL02VayInZ05VzBjt7h4MYQVKlRAW7/8suudBAURvf02+l6FChB2aN/eJVDCjNOU8HCUP/wwUYMG6IMm9u3DScjDD7t+GjVy1dUwiAYPxrUqVsTPI49AiMTE4cMQU6lYEXWoWBH3y9iPx4/H2KtcGT+VKrn3iWnT0CerVkVydiuO+uLFeDdVq+IeGdvUxOrVGJPVqqmT2nsCnSzdi7iXRSTuJTj2H6ZcT+pk0xrZE8bBw5Sjnu6/dzt0snSN/xw8Ib9raNytsBNm0Mhe0K9TQ0NDQ0PDy9DOVUNDQ0NDw8vQzlVD4y6Hjopwh24Tjbsd2rnepbCbPNLS7AnuISH2RO3wcHV5YqI9qd9OKMHptK/rrZosVYmYma15wCZfkVkWKzAFCM6eldt43z7wC6VrGAZSo2VNfp0RZ8+Cd6t6B8uXq3mwN24gqlqVyPzKFUSRS0hJQeS4xK0mQrsFBqptzp9Hu0hwOIiWLnXnaWZEYCAidCUkJoJ/un69bHP0KJ5HEpK4fBlRwjduZOavmkhIcD2nw+Hef6W+lRGqvnkz8GTuUMHhsB/zN26oy51Oe5GOkBD7eUHFbzVx1y60bo7x89/AzfJcTYSHgzsZHCzbHDiAhMhSUmqHg3nuXObHH5dtIiOZBw4Edy4oyNrm4EHw69q2ZQ4MtL7PjBng1U2c6OLvZURoKHPPnuCoffcduINZsWkTEjuvWsX8+efgxGVEfDzzV18xT5iAv//gA+YXXsjMVdu3D7zWEyeQUL5bNySgPnEC5YmJSMIdvQU8wYUfg+darhzzuHGwMQzmefPQdsuXM/foAV5t//6Z6/PHH+AHfvcdEsr/73/uvLmNG5mfeALvqVIl5itX3J972TJwAMuUYV661L2cmXn0aPDzmjWTE52//jpshg61tklPBwewXDm5X+3ahWuMHGldzsz83nvgIltxcpnBLy1QABxkCWPH4j4SjzAqCu/tySfla0yYgGt89511+dWrLm70nj3WNvv3g69crJh1YmyHA23+0ENIdh8TY/0sDz7I3KkT+mNcXOZyf3/wpV99Fdzy1q0zcz2vX2cuVQoczBEjmA8fBqf14kWUGwZzxYpoiwEDmH/9lTl8HfrvoV8O/X2dDz4An3rwYPTNXbswFjLWZ9Uq9MWRI1GvDh2Yt2zJXN8rV5C0fPJk5kGDmPv0QR2ztkvfvuDPPvooeOhZuanMSEDfqROe+eRJ93JmjLWyZZGcPD7e2mbIENxn1Sq5/w8fDm7qmTPW5cwYR9984/6OMuLHH5Hg3up5/ik89QfauXqAm3WuhoFJvVQpa2EHZpDO+/QB0ZmIecMGd5v9+0GwN8nZf/6ZuTw9nfmHH5jvv1+2CQpibt/eVV6xIgZ+xrr+8Qc6vWnTpQvzIdd454QEdPqCBVFeujQ6d0abEycg1GBeo3VrTJymCIHDAZK9n5/rGt2743cnT6Iely9jQjCJ5vXqYYJauhSThdPJPH8+JkEfH+ZnfTE5Te52iNesYY6IcD3z88+7xCrat8f7yCjckJaGBQkRrvXZZ9YTx+zZzLlywe7DD/EcWbFpEyZ3IuZ27fBesmLvXlynWDE4rKwiBsxYVPj4gPx/9qx7OTPz5s1w4mvXWpczQ2ijQQPre5j44guXwIeEli3d+1NGxMXhfWYVFMiI9evhxCUkJGCxVqOGdbm5uCxXDsIKVpPyrl1wnj4+zM89Z/2Ojh51CbY8/bR121y86BqzNWu6O+qUFIi91K8Pm7JlISBiwunEmB0+3GVToADEVhwO/AQGQkyiSxfmV8qh/9aiQ/zaa8znz0NMZd8+/E27dq76lCyJhabDAee1ZQvGYEbxhlatXCISCQkQWPj0U5cQxf33wzGZIhKpqXCKnTu7rlG3Lhx2RkydinnDHJfvvuu+KBs2zHWNkiUhVpF1HGScHxo1shYoeekl130GDnQXbGF2je1y5Zh//929nBmCFTly4HrShsNTaBEJL8KbPNe4OBy7FCliXZ6eThQWBtGBkiXdyw0D5PawMIgClCuXuZwZBPrwcPyULg1yddbya9dwbBMZCRK6KR7AjN9HRLh+HnwwMyk+KgqiDZGR+ImJIere3ZVL0jBAmr92DcdHUVH4+6ZNXdc4dQo2N27geC1fPqIhQ1x0hIQEohkzcHR04waO2MaMAaHdrOfixZA1u3EDP4NbHqYXv8rME7x8mei771zt/sADEHnImPfS4YCIxMmTRPffj9ybr77qTjXcvBnScyYxvlo1olq1MtuY96tTB+IRVau6k96Tk4m++oro6aeJWra0Fm5gJhoxAhKW9eq5l5uYOpWoRQuQ5yXMn4/7ZBQ/yIolSyBXZ4oNWGHxYqLXXlMLTcyeDREDVU7S2bOJ2raVRS2YISDy/POu950VKSl49oYNIYJghStXID9YtSrqnRUJCZAu3LGDqFAhooEDM7+r2Fii/ftxlH3+PPrJ8OGZ620YEDq4dAl9LDEREpB16mS+15YtRD/9hHbJlQvj4b33MrdT6p7DlLdRHepd7xBFla9Nfn6oU/nyLpuJE3Gs/sADmEOaNiVq1sxVfuwYxo1ZXrIk2toUMXE4IN6QKxfKixYleuwxoocecl1jzx4cvRctij5TtGhmoZP0dPSXwoUhzFC8OO5z332uawQGQsbRFM0oUSJzHllmjKfChSE+UbKke85nZohzFC0KkQ9JdOT0aVz/gQdkgZOQENzDG3Q9LSLhRWgRiWyCw4cxq90DJHxzVNolnWbOfjZ34n7ZAvdQ/72X4ak/0LR7DY27EJ46DE/s7jabO3E/DY3bDR0trKGhoaGh4WVkK+caHR1NnTt3Jl9fX/L19aXOnTtTTEyM8m+6du1KPj4+mX4aSB9pNDQ0NDQ0vIBs5Vw7duxIR44coQ0bNtCGDRvoyJEj1LlzZ9u/a9GiBYWFhf39s27duttQWw0Ne5jxkhKSkux5fNeuqW3seMhE3k1c7UkSeRWY8Uyq8qQk+2voaBKNO4ls41xPnTpFGzZsoBkzZlDDhg2pYcOG9Msvv9DatWvpjCqzMhHlzZuX/Pz8/v4pIoXq3gYYhj1xOibGfmI4e9b+PnZriBs3kJxchX371OIDDocrSbpU5+Bg1EeaFJldhHynE5HIWZGR+J6cjEhDK+K+iZgYiBFkFVcwr5OUhEjSNWvc7xUZiWutWYMIZqv6HjuGdHavv25NqE9MRJqrgQMRWWmFfftw/ddek9vuyy8RNSsJTTgciDp+9VXU2wqLFiF94aRJsnDBa68hcfvOndblW7YgTVy3btbOkxmJx+vWRXSyFU6eRD2ffNK63Okk8vdHZOrEidY2REjd9tJL1v2ECKnm2rVDmkOrdmVGPfbsQdo6K0ybhuj0tDS866w4fx7J0M3E5lnb3jCQaD0gwFWHrOINixcjGlm1GDl9Gj/SNYjQ18LCXP8viXiYY88cj1ZgRpmUKN1EQACirSUwQ8hDNY+dPg0hDxWCg+2FJDyZL2+VYIcSN8f4uX2YOXMm+/r6uv3e19eXZ82aJf5dly5d2NfXl4sXL86VK1fmHj168LVr15T3SklJ4djY2L9/goODvSIisX07+G4Syd7hYJ42jblCBdkmMhKE/+LFkQDZCgEB4I0VLWrNHTMMcB+LFwefdft2d5uYGPBu8+ZFcmQrIYRDh5AIulEj8OF++CFzudMJ0rqfH/P774MbN2BAZpuQECQ/79EDxHQ/P/BQM2LFCohdTJ2KZM7FiyOJs0n+j4qCsMSxOeAJdq91iEuVAl/PfP70dBDxv/wSfFo/PyT/3rs3c7uMGgXeXI0aEJDYutX9uYcPxzsqWxY8Wyuu5bvvgsfasaM1h9IwkDyeCHWyukZqKt4hEUjwVjh2zJVM2hTVyIpx41xCFBKaNAEHM6uwgInQUFyjY0f5Gt9+C5vVq63Lo6LQZj4+1s9rGHhHRGh7K0RGujijw4ZZ24SEuHiYa9ZY2+zahbrkzYs2zIrwcPSf6tXRtufPZy6PjYVow4MPoj898khmoYPUVOZJkzA+atTAO2jTBiIxJiZMAP+ydGnwXDeNQv/dPPrQ3+3z22/4+4oVISjx448QrsgoIHPwILirtWujL9WpAw5sxja+cQN802bNMN4aNXLncRsGnuP115kLF4bYRFKSe9u0bo3xXras/K4/+ID5vvvAZb1wwdpmwAC0/5Ah1vdhhvBM+fLQBpCEJj79FHOU1P+ZwSUfMADtcLO450QkRowYwZUrV3b7feXKlfk7Sc6FmZcsWcJr167lwMBAXr16NT/xxBP86KOPckpKivg3Q4cOZSJy+7kZEYlFi6C0UrMmFH6yIi4OL792bQwkq0n9yBEMjocfhoPJauN0Mk+Zgs74wAPouFnvdfUqBnm+fJh8ypTJPKEaBhypKe5ABEGF1FSXTUIC88cfuwQvihWDEEXGzn/iBJSZzGv065dZycgwoADl6+sSs/j1V4hpmAgLcykUEcFBb9wI8r6JZcswaRAxt6uIyenonEOZhAPCwpibNoWNnx+EKrK+SqcTak2miISV0AczFj9mfcaMsbZZudIlWDFihPWksG4dbJo2hUiAFVasgIP+/ntZWWbmTDy/amL5+msoBVmJWZjo0oX5k0/kcmZMqFYqXCZiYjApWzkrEzt2oN9IghaGAQdRuLA8mV66BOfw8MPWNsnJUFgqUgSLRysRiUuXXH3i0UetJ/eoKDhXItwro+iIicRETOzmONi/393m6FEsHokgLvLjj5nrHRWF+WFwS5eIRNu2mR3o5ctYXNaujesULgxBE/M6hgFBikGDXP3z2WczLwrS05n/+gvKVGZdhg/PPLbj410LHHNcbt6c+XkuX8aiwrRp2xbzSkb8+KNL/KF4cYybjH3YMOB4CxbE4uW556yd/RtvYI6qVg2O1uo9deyI9/T00xhXVujUCWpYb71lraj2T5BtRCSGDRtGw4cPV9ocOHCANm3aRHPnznU7Aq5cuTJ1796dBg0a5NH9wsLCqHz58rRkyRJ69dVXLW1SU1MpNcNZaFxcHJUtWzZb8lxVPEBmHPnmypWZXM2M46e0NJQzgyhuIjERR0/p6a6fcuVAxDf//uhRHEOZusKFCxPVrOm6xuXLOJYzDNeR8euvu8Qd0tOJZs3CcZtp06ZN5musW0f022+u8lfKH6bXRmTmCUZE4Og1JcVFrH//ffx3xuedOBF/Vq0aRAfq1HEXZtixg2jKFByPNmtmLRARFobjwjZtcPSYUazChGHgeLVDB4hESO/n44+J3nyTqH5963IiiBq88QaOUiWMGkXUsaO74EhGjBlD1LUryPgSRo6E8IEk/kAEzd/+/SHGIWHYMKI+feR7MeNItXNnosqVrW0cDlynZUuixo2tbUzhkSeeQBtZ4exZiFrcfz/R55+7lycl4ah8yxZcb+zYzEIbTifRrl34RHD6NMQKhg1DP8qIzZuJtm/HuLlxA8Ifb7+d+d3HbD1MhZvVoa9ePETBxWtTkSKokzn2mHFcHREBsRUfH3wyyNg/AgKIjh9HeY4cEHZ48UWXAERSEoQzcuZ0CVpUqJBZsObSJYyX3LlRnjs3RBzMuqam4jny5sVPnjzu4gzJya6/t4KnPO67EdlGRCIyMpIipY9F/4+HHnqIFi1aRB999JFbdHDhwoVp/Pjx1K1bN4/vWblyZerRowd99tlnHtlrEYlsgltMwvdEsMDpVKsTEWHhkDOnfXLs5GRr55wRiYlqVSUifBvLqJ5zp20cDvxkVOzJCvP7vN2zedJGqanu6j9Z4XS6HJYKt1S0QotIZAtkGxGJYsWKUTGVLtv/o2HDhhQbG0v79++n+v+/VNu3bx/FxsZSo4zafDaIioqi4OBgKlWq1L+us8Z/E55MqnaOlQgrek9g5zSI7J0Pkb2zu902WU9KrODj49mzedJGdo6VyLP3RpQ9d1oadwbZJlq4evXq1KJFC+rZsyft3buX9u7dSz179qSXX36ZqmYQz61WrRqtXLmSiIgSEhJo4MCBtGfPHrp06RL5+/tTq1atqFixYtS2bds79SgaGhoaGvc4so1zJSJauHAhPf7449S8eXNq3rw51ahRg+Znifs/c+YMxf5/IsWcOXNSYGAgtWnThqpUqUJdunShKlWq0J49e6iQ+YFQQ0NDQ0PDy8hWzrVIkSK0YMECiouLo7i4OFqwYAEVzhJdwczUtWtXIiLKnz8/bdy4ka5fv05paWl0+fJlmjNnDpUtW/b2V17jtsNOSMDhUHPoHA5kVlFBlfibCFk9MnIQs9YvMRF8R1Udfv1VTriemorsRzNmyNdITSWaORNBZFZwOnH9qVPlaxAhwEzFSwwLQ/J3FY97wQIkZZe409euEf3yi5pbvXgx7iVxFyMiwDFWvfuNG9VJw0ND7d+9xLM1oeKBEmmRi3sd2cq53guQJtqMOHpUXe5wYPJQ4do1RLaqBvD27RAYkCZDpxORplFRshMKCUHU7sWLsqrO+vWox969REeOuJcnJyPaMi2NaNUqaxGC8HD8GxsLR9KpU+Znczpdk+3160SjRyOVVsb7OZ2IckxNRUqz6tXdRSRSU/Es+/YhCvPHH93rcv06Yk969SIaMACRlVmxaRPR8uWIGJYc43ffQRAhIMC6nBlRvh9/LH9b9PeHoMLhw7Ly0aefEn32mbXwBhECh1q0IJo8GfW2wvz5RN98Q9Sjh/V9mIl++AFRvlLwf1AQHGPr1rJIQVISxB+6dLEuJ4Lj69wZohhWcDqJ+vXDuzl3ztrm998hNPHLL9b9/8gRoqeeIvrzT6Jt29zLr12D6MbAgXCiWXVsmBEJ/uabrj4YFZXZplcvRDGvXYsgNyts2kTUuzfEXkyxlaz9LSEBEcrms0rzx7JliL7fv18WHDlyBNefMUOeO8LDMf9I/ZYI1xg8GGn4JFy8iEht1RwVFGQ/H166BCEJFa5d864KmUe4OcbPfwM3myydGVy7iRPB6cqYnDwjbtwAH65QIZkrePw4koYXLIj/tsLSpRAfyJULHLusSE4GT9XHhzl/fuv6BAWB4O7jA27onj3uNr//Di5h0aLMlSq5825TUsBvzZMH5Y0aIVl2Rpw6xfz447hXqVIguGe0MQxw5mrWZH7zTdSlZ0/w9UyOX1gYeHIrvgRP8EW/QzxoUGbuZ0oKkk137oykym+/7c4NdTqZO3TAvapUsU5YbxhIuFyoEHi3GTmCGa/zxBPYNy9b5l7ODH7k/ffjHa1aZW1z4gSu8cADmcUuMmLmTNjUrGmdSJoZHFYicKAlPPggeNFWXE5m9COVuAMzRCqIIJhghZQU5qpVYSP179Wr0ecKF7YudzohokLE3KKFtU1iIoQOiMD7tEJ6ukvEY+5ca5uAAObKlTHWsnI9mcFN//hjl6DIjh2Zy9PScO3q1ZHEvEGDzDzMlBT0j1atICTxfQf036WfuUQkoqOZf/4Z46NSJfT92rUz81djYiDgUbUquJx+fuCqZuQ1OxzMffviPpUr499t29yf6d13wZvOnRv93EpUpGdPCI7kzo1k61Y84nfewXssX9492XrG6xDhPlkT0Zvo1w9jZMgQ67HGDMEKPz+Zm87M3KsX5h9pzvwnuOdEJO4kvOFcV67EQOzXz5rwn5iIAfLuu3CwVupLJ08yd+0K0nTHjtak61mzMJBffhliEUeOZLaJiMBk26ABSNevvALVm4xYvx7E+sqV4fiyKi8lJWGCy5sXE3+1au7E7NOnMeGbh7Mffuj+PHPnYpASgWh++XLm8pgYOETzGqNHu5PIt2xxiUh0r4XJybH/UCab2Fg4XyIsBCRlq48/dolIWDlWZuaffoLNffcxL1xobbNggcvhbdqktundWxZUmDoVC5MVK6zLmSEQUaKEe9tlRK9eWJBZTYImnn8ek50Ew8CiZOJE2ebaNfSJrAuojNi2Dc+dUc0oK0aOhI3ULklJrgWOJIyxdy8EEEqVsraJjYUDyp8fz5WcbG1jOunSpd3HCTMcaKtWLmEHq8nb6WT+4gvY5Mpl7cyvXWNe+LFLROKNN9yFTs6fZ65VC9e5/36oN2WEYTB/951rvDz9NHNwcGab0FCMNbOff/WVe/uMGYM+dd99eO6sQjQREVhkPfIIxDU6dXJvm0WLINLRuDHmmoULMwtnGAb6bqtWeJcdO2JBnxVjx7rmu5Ej0d5ZMWkS+m7v3pgPrDBlCkRivvwyszjHv0G2EZHIDtA818wwj19VdIqLF10k9kKFQDTPiKgoiEj4+oLAf//9IKqb3EdmaPJGRMCmcGGiSpWgkWviwAEc295/P2zq+BymV77JzBNMTCQaNAhHz1WrgtzfqBFR0aKZ6zN7No66/vc/WSDi9GkIUHTsiOM+K9pJaipI+927E7VvL3NZ33wT12nTRm7DXr1g16yZbPPhh7BRsdE++giCBRkFOLKif38cP2YVP8iIvn1xrYcfVtf5yy/VghVdu+LouHx563JmorfewlGnJCKRno7rfPQRqKFWiI/H8fBrrxG9/LK1TVgYhC+qV4etFY4fxzFpcjJEHLL2C1No4s8/IUrx009EpUtntgkIcOlRnzkDEZGsdbq6+jA92KYOTXz7EJ3IW5tKlMAReYECKE9LwxF1bCyOQWNi8NmhUiXXNSIiIFIRG4ufPHmInnkmc50NA3VOSEAblSiB8WMFU2hGxUn+ryHbiEhkB2jnmk1wEyR8w7AXdfBEICE2FhORilvpdGIS9PNTX+vyZdkBmQgKUjs7IgQhVayotjl/PvMk/W9tLlyA4o+qLSMjwfWVJnQiOLKYGCy4JBgGvvnbxSeGhBCVKaO2iYwksqPbp6SAD2vHU/akL1lCi0hkC2QbEQkNjbsBnkyGnggkqByGiZw57R0rkb1jJbJ3rET2jpXI3ml6auPJvTzQjKH8+e0FInLksHesRPaO1dM6ebp7+1eOVeOeg+4GGhoaGhoaXoZ2rhoaNwG7jypWNJ2sf2+VDzYjrlxR0wgSE3Fkq8KxY2reZWysnDPWRECAnCuUCNc/eFB9jdOn1c+bno68rypcv26fLN2uTe3eC5HmoWrcHLRzvYfhCa/LLhGxw2E/yXh7EvLkfnZ84dRUohUr5GulpoILGxIi32PKFPBhJezdi6wkqns0bQo7CQsWIJBIgtOJgCaV81y1CkE5KnTpom6zgAD7awwfrk6ife0a0bvvqq8xYQKSaEuIjgY/VNV3hw6FKIaEixeJ6tWTeb9EaI9Fi+Ty7duJ2raVhSbS0hBIphLVmDULnFIJJ05YJ2LPCE/6umnnTdhdT+LlZoTd3GJmw7pXoZ3rbcaePery9HSkUVN1utBQEPZVNtu2IbpTsjEMTKYDBshKN9evI6Jx4UJ5otq6FeICI0cSBQe7lzudRF99hd3Ie+/BPiuuXMFk9uefiLT9/nt3mwMHMKHNnYsUYkOHZi6Pi3NNhLNnI8p0+fLMO5wbNxClvHkzImfPnnUPPDp/Hs/RuTP+3iqad/NmRIe+8QbRt99ai7kvWoS2feIJogYN3MuZkQ5t8GBcwwqHD0NA4pFHiKpUsbaZPx9CCK+/LjukcePwTFJ096VLqG/OnGgTK/z1F4J+Nm2S+0JQEN7lggXW5fHxCHZasoRowwZrm6JF8e4++EAWOhgwAE56wgTr8goVIKwxaJCsfjV6NMrnzbPeKT/9NNKwvf46RFCyOtk8eRCF3LQphEisnGiZMuhHvXqh32VdIIWGwkG/8AJS2lmNVXOh0K0bopavXnV3tk4n+vNXX0HgYeFC62t98AEWi4sWYTxZYc4ciMK88w7elxX8/ZEKb/p0eX45cQLCJCoBiEuXkHZRJTQRFGQvhhMUZK+Udv485rPbiptj/Pw34A2ea2wsiNW5cskE+rNnwUf08clMEs+ItWuRlNnHxzrpr8OBBMg5ciBRcVaeGzM4aS1buviaVgTuAwdAjDeTLmflhhkG8+TJuEfu3Ei0nVWAIC7OxQGsXBn2cXGZbQ4eBAHc1xek/lWrMvMxDQPPU7Ik+Ijt26NuGXH1KnONGswjXgNP8PsOh/jSpcw2iYkuzl2tWsy7d7s/c1oaSPjFi+N5rPiRaWkg8xcoACELK8TFQXigUCHmQ4esbUyBiAoVrIU+mMENJIIgxbVr1jZmgvcXX5QTqtevD5upU63LExPRX3LkkPmy69fjGo88Yl3OzDxgAGz69rUuT08HJ5oIQidWOHDAxX2WklrPmgU+rZ+fdbnJoVQJTaSlQXyAiPmjj6xtnE70t1y5wKW0wsmTEIkoWhTczqxITmb+5huIdFSuzDx/vvs9fv8dfbNDVfTfGX0OZeKEJiUh2XiVKui75cq582nDwiC0UKYMc758EEnJKroQEMDcrRvaLl8+5l9/da/vhg3MDRuiXR57jPnCBXebpUvRv4mYu3e35ggPH47yfPmQ1N0Kn3wCm0qVZGEdk3vepo01z5gZ/S1nTrxziffcsyfGtSTY8k+gRSS8CG841+3bMfiWLbOewFJT0QlnzIDAgJVNUBCI1JMmYYLJ6kCYoVIyaBDzqFGYTLM66fh45k8/hQjEl18yjx/v7oD37MFk3aEDJu9ffslMAE9NxT1q1MDk9c47zIGBma9x6RKcQokSzHXr4l5ZJ//ff8dE6uODSffs2czlaWkQzTBJ8YMHuz9vYCAmLiLmjtUwOWX1aOnpENUggsOzEvFgxuRkEvSt1GuYXSISlSvLAhG//OJSnpGc4uTJsPn668xtmxHDh2Nil+7DjPdYuLD1IsrESy9BvUeaeJjhINq0kcuTkzGhfvaZbHP2LJ5pxgzZZtUq2Ehkf2aXY5QWmA4H6kqE/myF4GAIoRQoICv7rFwJp1isGNSSsiIlBf0/d25MzFkXhszoo926oS6+vtZj0jDgwE0RiYwqTRmxebRLRKJXL/f3FRHh6uu+vu6KaMwQorn/ftg0bcocFZW5/Nw5jNmqVdE2WfufYTBPmMD8xhvMTz2FxX7WhejFixjPPXviPXz4obs62Jo1mKsGDsQYXr3ava6//457DR/O/Pnn1uIO69YxT58OMYmZM62FUDZtYp4zBwsQSclsyxYsJubPt1ad+ifQztWL8IZz/a8hMtJ6RWsiJQUd/tw5efLbtAkDZvNmLCyyTjaXL2Ni++QTDMB9U92dq2HAKXfsCKd34YK1M9u5Eyv26dPdlXFMxMdDdWnqVGulGBPPPQcnLDlNZubXX4esnQpvv41JQ4Vu3ZgXL1bbdO2KiUyFDh3UTpyZuW1btJMKL7yA0wgJhgHlIOn0hhnvuUEDeRHEjN12gwbuCmQZceMGHERWWcKMCA1Fna12cSbOn0f7DBsm2xw5gp1wmzbWDiA5GQu2IUNwP6ud2tXV6L9z+h3inj3hULIuSGNj8bfLlsExZXWezGjjqCgMA+lUxLSLiLBeWGjI0M7Vi9DONZvgkLVzVTk5E9KRU0ZcvSrr95pISJDlFTPWaft2+/tZ6dlmxR9/2NusWWPfBqtWycfKGa+jklBkxvGxalHFzLxvn6xhbOLcObVEIjN2IAEBapukJOb9+9U2Tqd8fJ8RZ8/at2NSkn0fMe/pBov+q3H3QcsfehFaoSmbQCvc/GswWwdm3QobDQG6/2YLeOoPdLSwhsZdDrvlryeUBikiPOM17GzS0+3pXXYUDWZ1vlezLnbQWwKNux3auWrcs7CbgO1C8w8dUosRXLum5sESIY+qKun21q3utKKseP55a5qTiXXr1FxZIlBGTp2Sy/fsIXrlFfU13ngDFCQJ584hB6oKvXsjl6qEyEj7Tdvw4URLl8rlUVF4FtX7nzwZOVIlXLsGqokK27erE64nJNiLXehFwr0L7VyzKTxZ3av4Y0TYZUjJpE1cumR/H4mPaMJUw1GR+s1J5tQpmV9n2v3+uzVf1kRaGnjAHTrI15gwAY5AIrrv3YsJWnp+hwMcRdVObcMGcHdV2rYjRiApu4RTp8CHfPBB2WbLFqJateRyZigjqXR/IyKQHeVmUKwYrqNC5crga6qukZQkJ5gnInrySfBTJRQtir6/fr1sU706UZ8+8m79vvvAr1y+XL7G0qXgwUoOdtUqooYNZe7w8ePIWCNxTonw7kaNksVOTBw96hpnksNOTESZJ+pUdmP68mX7OUi1mDNhN0eZXIHsCO1cbyPS0rDTUR2/hYYiZZeq4/r7E/XoIXc6ZkzaXbrI14mJIWrZEkIT0jHdwYNwQJ07y07o+++JOnUC0d1qlxcfD0L/yJFI42blrHbtAqm/Rw/YZiXbM0Ms4dAh7MDGjSMqUiSzzeXLrjq+8QaEAcaPz2xz7Bgm/zfegErQzp3u4vB//QXH2q4dxDysdlEmib5sWUzQWcEMx9qvH9HUqRBnyIqLFzFxR0VBOMMKhw6B1N+5s/wd89gxOFcpLZ3TiWcqWVLO5hIRAWdWvLjsKGJi8G9ysjw5FygAu9BQ63Jmosceg1NRLeqeew4LqKAg6/L//Q/PvWGDvLj54guMAWmn/b//wcFOnIgdaFYULIj3078/0Y4d1kITU6YgAcPrr2MXnHWMdOpENGQI3s2yZRhPGcfso48Sffop0ut16eI6ScloYxgQOnnySZxw7NsHNa2sWLIEYiNz56Lfpaa623z9NVGTJuiz0uJkzBgISDRtKqtPLV6M+nbuLPeXrVvx3KpF0OHDqI9K7vLMGYxXlXTnsWMY6yonfPgwxsFtxW0Jr8rm8Ea08OXLEChQBQP6+0MswcfHOlLSMMBxzZkTfDmr5MJJSaCdEIEsbmVz6RI4gERIFn36tLvN+vUuonizZu40GMMA19VcWy5b5n6N6GjQJYggZGDFY9u5E0IWPj5Ihp410tQwwJXLkwfcvJUr3SM2Q0ORGLtjdURbnljg3sCJiRBA8PMDHUKiS5QrB97jnj3u5cxI4H7//eA9SiIHJ0/ieWrWtG5/ZlA/fHyQpDwiwtrmiy9g8/bbMvXnhRcg/qCiiRQtCi6sROY/dQr9qXBhOfr2l18gCPDggzJftk8f9M3Wra3L09JAU8qRA/xKK1y9CvECVcL6XbsgvuHjY01FYUZkc8GCzOXLW5czgzeZIwcEVazgdCL5eK5c4HJKNu+8g3E0Zoy1zdmzLs735Mnu5ampoN00L4b+O62Xe/+NjEQdChXC+8zKK2cGdempp1wc66wUG8MAbStHDthMm+Z+jaQkJEInwlixovLs3g3uLxFsraZFU1CEiHnoUOso64EDXbxyiftrXuexx2Tec+/esHnzTZn33KkT+ubo0fZR8XbQVBwvwhvO9cwZ/Fy/bj05paeDnnH0KJyF1WQaGgrKxP79mNitbPz9IVbx119wolltUlPhoH/+GVSP8+fdbU6dAmdv3DhMUmfOuKsmTZrE3K4dBs6vv7o7kYgIOOWmTTEpzJ7t7jh37sTAqlaNuXNnTJpZ8dVXLvGHjz92HxgREa6FwgvFZSqDOQCLF5d5mGPHwqZ8eVl9ado02DRoIA92UyCiY0eZw/vNN7AZPdq6nJn5/fdhI008zOBV5s0L6ooEc2JPTLQudzrxHurWla8RGoq6dOok22zf7ppMJfz8M2zmzZNtTNUpiZ/qdDI3bw4bafESGelSg5KoMfv3oz8ULGj9ngwD7zt/fuYiRaz5oOnpcAA5cmBxcuOGdX1NEYm8eWXu6aKBLhGJ7793Lz9zhrlOHSwqSpRwp3ylp2Mx8PzzzA88YO1gAwOxCOjYEeNmyhT3a+zYAS53377Mr73mvtCPiYFYw/z5GJ+jRrnPadHRLj7u999b86NjYlCfdeuw0LFqu5gYLP63bcNiy8pJx8WBv75vn0zfio/HnHn0KK55M9DO1YvQPNd/jqQkNSfQMODkVE16+jQm48BA651mUhIWAQMHYkcbtdnaua5cCWnFOXPklW1MDHbG48erSfUNGsB5qNSOXnnFeiGQEZ06YVJWtVHnzlDTUqF9e7UzY4YDtpqsM+K55yCgoUK9emrBCsOARJ+Ke5uaitMBlbBDbCxzqVLuMpcZce0adlYqEYnLl7HTlqT1mLEoqVhRXZ9Tp5hr12ZeskS2OXkSIhsqBasTJyB40qyZ9ULHsR/9d+lnh7hjR7kdY2KYN27EaYLEOzYMPJt0umLCbpxquEM7Vy9CO9dsAoGELx0dZsT58/Yr2shI6911RjidkKa0w/jx9sdTo0aplaCYsVOxE2349lt7YYNvv7WW98t6r+hotc3338vH3CamTrWf9BcvVis0MUP+z04x6vhx+XjZxLVrOKFRITXV/jrMOFa3e6/p6cKiUotIZAtoEQkvQotIZBNkIxK+J2ILDoecycZEaqp7Zp+sSEpCsJEKiYkI4lEhIQFRtDd7ndRUPJdVoJcJZgTL2D2bJ22UbYQtslH//S9Di0hoaNwk7PJRRkbaUySWLLG+jjnZ79tHtHq19d+aTqN/f5mykDcv0gtmjYzOiAIFiLp2VXNlT51ClKkKn3+uToZ+5QpR9+7qa4wZg/pKjjUxERQqHx/Zsf76qytlnZVjTUsDF9bcNlg51sOH1enQmNXlRIhUthPe0PjvQjtXjWwHO4UfIoTwX74sl+/di1yqEq5dI6pRQ83b/PRTOXcpEXJafvWVTIEhgpiBitcbHg5aSqFCso2/vz3ncNMm8D8lhIUhUbkKwcFqUYR8+eC0VEhLUydcL1gQ1BeT+iNBleg8Tx4sWI4ckW0uXcJiQUJKCtGrr6od7KhRoM1JCAnBYsOKFmNi61Z7B+1Jf9e4+6Cd610ITwaTakImwqpapQxEBK6lRHA3sXy5uj7p6VD3UTmhM2dwjW3bZJvoaHA+v/jCmjtnOo+DByGYoBK3WLkSPEaJJ7l3L7hzrVpZlzudRB07YidXvLi1ze7deO4BA+R6jBoFBywdW8bFgaPatq18jY0bkUxbdax54AB4xhJM8Q7V0XB0NNEDD8jlnuCBB+wddMWK8nsxUbcuTkYlPP88xDlUC4quXcERlmAKhFhxRonAf/7hB3BCpfsMGEC0dq188lCqFN59u3bWfZoZvNRnnlH3588+I/rwQyxspLps3AhRC2b5HYSE4ITi7Fn5OsnJmFtUnFDDwILOTjBk0yZ7AQi7vkBkP9cxeyaqc9txW74AZ3N4K6ApNBSUEImewQwKyGuvqaMAf/gBORmlwImkJOQvff552ebMGURSNmokRwsuWABuWP361jYOB6JVS5VCJKnVva5cwX1q10Y0pVWU7cKFqGvZsqCoZA3icTiQt3TYMPAb//zT/RqHDzNfXomAkO61DlkGzPj7g79atqzMYz14ELkq33jD+pkNA4E2NWvKWWsiIhA9Wq6cHHl84wbynvboYV3OjPf45puIdpaQng5utBQFbRhI79a4sXwNZqQvGzJEbdOmjX02n8KF1dGne/fiXatsvvkGuUBVEdlPPQUqTVKSdXlEBPrltWvyvebOBZ3s6lXrcsMAB3b2bJnicfIk+ndAgHs+YmaMiV69mFu1QkSyVfDZvHm4xobv0H+dBzIHNCUlgc5WvTpyn65d636N06fxjlu1wni1Cjzbvh198tFHEc1uhU2bYFOwoJzTeN06ULcef1wOXlu/HjZ9+shz0NatzKVLM69YYV3OjADCWrXUVLP9+5lffVWmmjEjveXYsd6JjNbRwl6EN5zrwYPg3T3yCDhZVliwAEmQH3uMOSTEvdzpxCDLnRvOyirpb3Q08mXmygXRCiubwEBMyDlzwrlaiTssXAjuXo4ccPZZJzGnk7l7dwQ3+vjAPiuiovC8RMyVKlmnddu5EwIRRMwTJ1o0CoPeQASHZjVpREczP/wwc5NCmJwc+92jLVNSwF8tUkR2rPHxEJDw85MTKp8/D85tgwZymrrff8d9One25u4xQ0TBzw+OXFps9eiBCWruXOtyZiyiSpSQaRvXruEd16kj003MXLYtWsjp8pYtw+T++uty5PGsWei/AwZYlxsG84gR4JYOH25tEx8PZ1SpkkwNunQJQhUVK8p85OPHmWvUgIOV6nvwIOqr4veuXo33rUokP348uLCSw3I6kVM3Xz4sjK1w7hzzW4+g/8583zpaeNkyjLX777d29rGxcHim8ItVpPns2S5xB6u6JCSAm04EB2s1VnbswPxBhDa2crAzZ+I9E0Fkw2qzMHs2+m6OHLC3wrRpuFfx4nLqwPHj8Z6ffJI5LMza5uuvsYDp1evm89d66g/0sfBtwiOPQObrxAmihx92LzcMyIVFR+ObVOnS7jZxcTiqTErCsZnVkWVYGNG0aTgK3LvX3cYwcBTzxx+I/ty1C8dXGREejiMff3+i2FhIt2WVCVyzBn+3YQPq3LFj5vLkZByJNmmCv9+71/2b34ULkFFr3Zpo1iwcn2XF0qUIgmnYEHJyObL0WGYcAQYFuY49rYJlpk7FN9j775cl25YtQ5BS0aJoAyts3Ypjqpw53eti4swZSEGmphL5+lrbREe77pEnj2wTFyffhwjv+/p1+Xtq8eI4CgwMhK6vFapWxRH3kSNElSpZ2zz4IK4TFiZHA+fOjf4iHUv6+OBbZkSEHNB03324xvnz8nfmMmVwxHnhgnydkiXxDsLC5O+35rfww4fl76JOJ/qLv7/15xHDwN+mp0Oi00qO0ekkKlwYZSNGWNfn4YdxHE5E9NNP1p9QypQh6tkT37ZfecU9yK1gQcirfvUV3kHfvu7Hsm+/jfc8bhxkH7MeaRcsiD5++jTRpEmuMZERTz+Ndr14Ed+crY5/33kHcQshIZCHtPr81LUrbK5fJ6pSxfp7/rvvYpycP4+xa4X+/SG56e8vj6WvvkLMwI8/3sbI8Zvz4f8NaJ7rP4cnxy+XL6t5nElJWN1Kx3bMWPF2746jYpOEn5UnGBODU4MJE9Sr1meewfGzdNTIjGPw1q3VNt26YeegulfXrszPPqtOPv7mm5A3VLXliy9iN6lCo0ZoIxWqVoXAgQSnE7uMUaNkm4QESFn+/LNsEx4OlaLly2Wbc+dw8mJ1/G8iIAAnL/v2yTa7duE6VlKBJrZvR32OH1fb+PrKyl7MqEfFilBQk3DqFI4vBw0SDP6f57rks0P82mvyLszhQJ1U7cOMEyk7frMWkPjn8NQf2DDENDT+HTxZHZYrpy7Pnx+rWxW6dMEqmYiIhEjVGzdAeVFRlG/cIProI6I2bWQbZgTkDBum5lYWLEi0YoWao5kvHyJeVVzP++9HwgNVW5YpQzRwoFxOBIH6jz5S2zRujLaUkCMHkiq8/LJsU7AgAsUaN5ZtSpaE4Hu1arJNpUrYsZQsKdvUrEn0ySfq99CoERJCqIKsnnkGQvTnz0NIX7LZsQO7/zp1rG3q10dw1MaN8r2qVUOA4LFj2PFKJxJvvkH0Zm05kDBnTtTJDllPpKyQLfi/2RW3ydlna+idazbBLVa4cTozr/QTEqxX/hl3C4cPW9uY33QDAhAUY4VLl/Dv2LFycM/p09ihqYJCjh1DEgDpGzEz89Kl9hKJffuqd4HXryPJgEqhaOFCBPBI35kdDuzsrl2Tv1fv3YvgtKQk2FlhyRK0u2FYfz+PicmsDW21w8v6u5sVfLeFVmjKFrgnv7mOGDGCGjVqRAUKFKDChQt79DfMTMOGDaPSpUtT/vz5qWnTpnTixIlbW1GNOw47CsC2bWoebGgo8rVmvE6OHJlX+r16gfaTFeY3yRMnsEuzgvktfOxYmfdZvjy+T06aJO/QqlYl2rxZTWl4/HGi2bPdv5tnRIEC9qIJwcHq5PFE+Har+kZ88SK+oUnfxnLmBD0lXz6ZGhQcjG/0+fPLOWjHj8fz+PhYxybs3YtvkiasviO3aJGZEpT1ufbvJ/r4Y+v7m1i6VCdM/68iWznXtLQ0ateuHb333nse/82YMWNo3LhxNGXKFDpw4AD5+fnR888/T/F25CkNIvKMP+bNycHuWoZhz809Fkj02mvytYKDEdihUmAaPBhHfdKx2eXLyBX60kvyNebPx1GrdA2nE3zN5s3la+zdi2AuFU6eRMCchPR0/Kh4rnFxaqEKT1CokD0n0QxGUuGRRxBQI6FRIzhxFV56CUF7Ev73Pyx+wsJkm549ka9YQo0aSIiuEqvYt099JH/woMyDNWEY6vy3Jm73ONRQI1s51+HDh9OAAQPo8ccf98iemWnChAk0ePBgevXVV+mxxx6juXPnUlJSEi1SSbzcQkjJnTMiNlZd7nCopeyIMIGpiOlEUP5RTXTMRO+9pxajCAvD7ktKSk0ECcDDh4mmT7cuNwyIMsydK8vnhYdjB/DGG4i4lOpLRDToM0QqWzk1pxPJqYcNk7/7HTqE+nzwgfxM48cTvf++/F3V6cS3vE6d5Gvs34+dp+oQZvfum3eu4eFI6q1CfLz6m7QnyJtXTqRuwlPnqkqgXbo0nJFKxODFF9XONWdOovbtiRYulG3at8fiRjoVyJcPQiH9+8vOaORIvOcVK6zLa9dGpHe7dvLccOECmASrV+NdWt3r4kUkmQ8OlsdiVBTGzq+/ynNMejpOQr7+2rqcCPf/9lu0jcpmwQJZttPErl32jtxuHiOyv4/TefsXBPd0QNPFixcpPDycmmfYGuTNm5eaNGlCu3fvpnfffdfy71JTUyk1Q2x+nN2b8xD79hENGgT6ijQp//QTAl127LA+XktPx1FjVBQGgRXCwoiefZaoQgU5wGLLFhx7Pv00dk9WGDwYof3nz8M+K5KTEQB04ACe66mn3G2OHUPAUcGCRDNnWt/n++8ReFK1KgZ+VjgcoOsYBp5r1Ch3mx07iELWEHUgoonvnaLKecgtwOnkSQzmBnmI3qnpXk4E2sFPnxFNf5coz3H38tRUOJBTC4m+WWZ9DWaiA/uIXi5NVDqciARaz+EZRN2esL6GiYiNRJ0/km0cDqJiV4jKRhBRlLVN9DGiJoXU98l3kqiyQ23zcAzRfWeJSBDv9yGimgaR84AcqFUxlqjgGfV9nrmPKGQbEdWQbTpUJTq5AFQvK9RiovvPE0VvkY+Xe9VFH+dnrRdieYjo61eIfvscDtRqzL5WgWhDHNG2sURPPOFOicpLRCu+xCK1WjLRA4UzBxrlIKKpPYm+G0k0uc8p+oj+P9FAhmtUrowx2qoVTgf69cPJS0ZUqIDfNWyIPnrsmHtAU548OPUZOhSBaStWuM8xEREIJrt4EZ8lrAIKjx7FNSZNwniqWtXd5tgxzFPPPIP5zuqTxMGDOEH47DMsdq2waxdOoRYsgK0Vtm7F6cCaNURly1rbbNhANG8efuySQXgNt+ULsJcxe/Zs9vX1tbXbtWsXExGHZFFk6NmzJzdv3lz8u6FDhzIRuf3crIjEiy+C6iEFlkybBgGIfv2s05+lpjJ36QIllgEDrFOEhYVB0aRxY+QCtbLZswciB40bI9DF6rF+/BE0hsaNkS80a3CJYUDFKEcO1HnOHPdrREeDnuDjA9qJlcrKvn24DxHEIqyCRkaNQnnRotZpyAwDog5l6TKn5SngYsnrH/2TzX4SqACv/emyZR83xVQeeACUpqy4cMGVIP5//3MfS4bBPGkSVJGIkEIwK65fh4pcmTIQq7FS5Nq6FXSzsmWZH3rIWoRm61aIqDz0EJK2W1Hutm1j7tABAjDffutezgy60ZtvQqxCSvm3fj2Utlq2ZL540drm999h07+/fYpGO2SblHPDhg2j4cOHK20OHDhAdU2GNRHNmTOH+vfvTzE26t67d++mxo0bU2hoKJXKsIzr2bMnBQcH0wYztUYWWO1cy5Yte0tTzplvQRUan5aGwBZVwEhkJIQLVGLxgYGgO0gBLomJIJg/9ZR8VHj4ML6LtWhBVKSIezkziOr58mHlaXUsGR+PsqeewrfJ8uXdbc6exWr8jTewYq9e3d1m5UqIrDdqRDThoytUr0Kkm82+fUTv9SEq+yBEKaxW21u3Eg38hKhcWYhOWFEZli8nGvEdUZXKRDNmWKdg+/FHopmziOrXw39b7eK+/JJo3XqiNq2xC7BC1654V336yMflzZrhiG/ECGgQZ0V8PFGTpkQ5fIjmzSd6xKL9Tp4keqszUZ7cWOFbHVOvW0f05VdExYsRrV9v3QenT8dJR61aaBsrmM/9ShuiIUPcy5mJunXDd/MP+uK/syI5GcIEYeFE349BG2RFWBhOZhISiRYttP4EEBiIdnU4ify3Wff1rVtB+cmXD8etVuNz6VKi0WOIypTG7ikrnE6c2kyfjnG3dKn1My1eTDR2bjFKL1WOTpxwH8NpaRB1mDCB6KGHrE95nE6IOsyeDUrUhx+625ifYVaswPNbUZCYsUPduxcnT1YBaMz4FhwRoaZfXbmCZ1FRgyIicMKgolalpOA9qMB86+lFHqcgvTkffvOIiIjgU6dOKX+Ssyw1PN25XrhwgYmIDx8+nOn3rVu35rffftvjOmoqzq1BfLw9vWHHDnWy8/R0EPN//11NiH/nHWgbqxKif/wxpCcl8j4z88CBWLFbyVOa6NsX0oZWuwsTnTvDRqKbMGPFX7asWrCifn0IQKjEKB56CDt7CenpEH9o3Vq2iYqCaINKC/nsWeyIvvxSttm1CzaTJ8s2q1fDZskS2WbuXNhs3Srb/PgjbI4ckW3GjYNNUJBsM2ECbFT9YtYsnOJY7eJMbNoEeU2VYEVkJPNHH0E8RYJhMO/eLdOQTFidWmncPLKNiESxYsWoWLFit+TaFSpUID8/P9q8eTPVqlWLiBBxvH37dho9evQtuaeG57BLvE2Eb8IqOBzYCahWvE4nVtbdutmfDPj7q1OzRUZi52YlT2kiPh7fzVUiCDly4Pu6KhNNkSIIiFFRaCpUQPCOSoyiZk3s9CTkyoX2eestdV0aN5YzCRHh22D9+mqBg4YNUZ+aNWWbl19GeYUKss1bb+Gbn6r9evfGblB10tO/P05pVIdgH36I6PDz5+XAsG7dEI29f78sRPL88xCaOHZMFqwoWhQBggkJcn18fOyD3IhuPvpb4yZxm5y9V3D58mUOCAjg4cOH83333ccBAQEcEBDA8RlSglStWpVXZGDUjxo1in19fXnFihUcGBjIHTp04FKlSnHcP1jW6Z3rfwOqHaKJy+6fw9xgCoybIgZWMIX2Y2Jkm4ULsbO3+s5sYsYM7Bilb03MzD/9BFk+lRzjiBFylh8TH3wgJ51gRlaS995TS+6dOIFvfaqhtG0bROqljCtxcXgP27fL7yMuDjvy06fljCpmu9+4oc66woz3EBystmH2rA9pZG/ck1lxunTpwkTugUbbMuRGIiKeneFMxTAMHjp0KPv5+XHevHn5mWee4UCVzIwFtHO992CqH0kICLDXbu3RQ30MuGMHc8eO6mu0bo3jQisYBlL2Vasm/73Tyfz55+pj1vR0ZBVROdfly6GupEKrVuqUc5GRCE5RYdQopJRToUIFHKmrFibt2uG/JZsXXlDXNSgIWtIqTJmC9GoSUlMRIKT6HJGaqv6EoJH9cE8qNM2ZM4cYC4JMP02bNv3bhpmpa4b4cR8fHxo2bBiFhYVRSkoKbd++nR577LHbX/m7EJ6EstnxFonsebmpqfb3YnZlF1Hh4EFk0ZDgdIKSoBKaMGkNEu+NGcFTqqO5gwcRJKXij86bB+6hhJQUiCFIR98+Pgg8adRIvkaOHAhIko4ZiXB07uOjpiAkJdnzXFXHq0Q4hlS1GRF4rlLGIROPPILMQtIRfoMGaDdV8MoLL6h5rg89hCCaU6dkm8qVrWlfJnLnJvrtNwhJSNi6FcfEqn5tZpZR4c8/1UITRAhEJLIfa1IGoIywG9MpKZ6N6f8yspVzvRegEhEnwoSvkuUjgnNRyd0RYVCrxB+IwC1T3SshAd/qDh6UbfbuRaSuaiIbPBjftmbPti5PSiL6/HNEHltFQBKBr7tpE+4lPdfJkxCPSE62Tp0WF4f279UL8nlWzsIwIK6RIwe4tRK+/x6C+dLknpxMtHat+lvn9u1wFKoISDvnSgSlIZWIRGgonJoK8fE3/40uTx77xdGDDxJdvaq2sRORKFIEdVUJqdgpNPn4YBE2f75s8/zz+Ba7f798jXHjwNNMS7NerLVogef59ltZ6OCNNxC1e+KE/NzLl0NoYskSLJayghlR0xMm4JutFZxOROd36SIrPjkcRMOHw05KHMAMm6lTrctNmzFj1IsXZnwTVy3gmbGItYMnQhN2c6/Xccv30PcAvHUsPG8ekodLEbJOJ44a69SRj5piYsBjfeop2ebIESRUbtZMtvnlF0RAvvCCtSi8YeDojYi5eXPrI8WoKOZy5WDz7rvWz+XvD55r3rxyknKTv9eihTUfzuFAu+XMybxxo/U1TpwAD7ZOHXz7s8KYMUi4LiXqZkbEcJUqsnZ6ejrz4MF4bkl8/vhxHH926CDf5/Bh5j59wG2WcOECEnlLwv7MODYuXlx+z0lJzFu24EhXQmoq6jtypHwdpxMJw7dvl/uvYaAuUvsz4/tw3bqIFJcwZw6+70oJ65mRQm/WLPWRa+XKzGvXyt9Bg4OZy5dHdLKEefOQkN6Kx23irbeYX3sNfEsrxMTgqLtePfm5//gDkcQtW1qXO52IHvfxkVP67duHcZY/v/U3eIcD/FQi5oYNrSPML1xAakEi5mHD5PvkzAl++o4d1jZHjuAaDz8sfzsPCIDN66/LfWrPHkRhT5liXc6MWIFixZDQQcKqVcxPPGEfYe0J7slvrncK3nCux4+DxrFggRwiv2gRJvfffrOeoFJTcY2BA+UAleBgTKSffYZOZ+WstmzBQB88GCH9VoNs9Gjmxx/HAAsMdJ90DQOT7SOPYFK+csX9GnFxoIFUr848caI17SQwEIO0enXQD6wc1qxZGISPPioTyd99Fzb168uUiSefhM1771kPZocDlJQ8eZjnz7e+xoULuEbJkq7ApaxYuRI2NWvKdRk6FDZt28pO+tVXMbF88YV1OTPapHBh5qlTrctv3MCio1w55jVrrG38/SEsUKWKHDz188945ho1ZGc1ZAhzcwzarQAARydJREFUgQKyIzcMTO758oGuZIWEBAiOFCyI75lWuHABz507tzy5b9kCIQQiebzNmIH6St+JDQO0GCLmV16R6/vcc7D56itrm9OnmR98EDa//mptM28e2oUIeV+zIj4e+Xbz5sW7spofzp9H386XD47Yaszu3w9aWv78GLdZ4XBg3nj7bSzQrahOiYnIwtSpE/qMVaBXZCTmug4dEFdgNVddvYp8zB06IKDOamF34QIC8jp2RKCbFU6dQl/p00eOgQgIAO1q5Eh1DmlPoJ2rF5GdApo8SYtl9xgOR+Z0XFa4elVOp2ZiwwbsdFS7oc8+w0JBqndSEpJ9z54tczkjI6E4NXq0nJotOBir/kGD5OscPYrJ7bPP5Dpv2gSbr7+2LmdGXYkwKUgYPhw2K1fKNuYuQ3LizMxNm2IxoIpkLVcO7SM5xaQkOKpHH5Wf2+SwqnbAGzbA5sMPZZupU2EzcaJsY55kSIsBZkzIRDJn1OlEwBKRHL2clIQFZJEi8n2uX2euVAl2Ei5dgoP+3/9kmzNnsIB8803Z5tw55iZN4CQkXLmCfjFmjGxz7Rq4xv7+sk10NE5NoqNlm4QEOFfVGE9JsQ8OTE9Xn2Ywu6dzvJuhnasXkZ2ca3aCJ4MpIsKe3rBjByYvFWbOlHcNJqZNw45SVa+pU7HyV9lMmIBJVGXzzTeQj1Th449x5KhCt27YtavQujWkMFVo1Mh6J5MRVaowT58ul6enY3e7fLlsEx+PHZEqkvfaNeysVGILly5hh6aK1j57Fjaqif3UKWZfX/W7OncOJzAqm6tXcRqkEvOIi8OOUCW/53Ti1EQ6zTDhCS0ouzir7IZsIyKh8d+FJzJlnuiL2AlNEBF16KAWYyAiatrUWhYxIypWRPCJqu4lSkAGUGVTvDhEEFQoU8Zavi4jqlRB9hYVatdGEIsKTZoQdeyotmndGgIPEnLlwjVU7+O++yCn98QTsk2JEhCAeOgh2aZ8eYi1q0QkKldGdhdVlHO1apCoTEiQA7oqVYIoSGysnMGoTBlIH8bHyzaFCiGoTxX1myOHWszDxIMP2tvcahlADTXuuLZwdoDHWpIaGuSZvml6ulr/mQgTvpnEW7pedDRscueWba5fRySvr69sc/EiHJUq/d3x43A0UnSzYSDiVZURMi0N0csqx5mWhme30qw2wQzqiZ3Kl8MBh2VHI7odmrQa9wY89QeaiqPxn0N6uj1nMCBAnfjb6QQdx2ppak7S69fLVA/TsbZvL9MI7rsPVIYXX5Tr8cADSPc3d65sU6IEdtwStYIIIu0DBsjlROBjSrQUIuzsJOk/E1OmqOtKRFS3LuhZEgICiNq2VTvWr79GsgEp0UV6OhIjmPQZK8caGGgtxJ8RBw6o60rk4p9q/Legnet/GKrJ1oQdmZxZzWUjgvOwm2DCw8FblM5R0tIwIS5cKHMpDQMc2HfeURPYR40CT09CSgp4fio+5tq10CFW7XamTcNuUUJ0NPLQSjkoiSCWUKWKXE4EbqTqODshAbtNlf5yXNzNJ0svVEi9ICHCcaZdsvSqVdU816pVwf9VJb8uV04t7pA7N3brUmJxIrTXxx+rx8nMmUSTJ8vliYlENWpgty7h8GHws4nkZzp6FIsKlSO/dg38alUSeacT2azsYDemHQ77Me3J/HIvQzvX2whmiH+rEBODFbMKBw/a20yapL6X0wknFBAg21y+DCK9agKaN4+oeXM4CQn9+oFIL93r+nXcp3Fj2aEtWIBvfjNmyBPQ55+DkN+kibXTCw1Fu8yYgUnTCrt2EU2cCEK+VXo7IhDwx43DNz8rJCej7Q4cgIiAZLN5MxJAS6L7ZmowT0QkpLoSwZnZfaPzhnPNlcta4CAjPHGudiISBQrgWPn0abkvtGiB9HnJyfJ1OndGv4p0z1BIRGjTSpUgKiKJtphJw9ets170FSwIAZX338dYscKjjxJt20b0wQc47bBCTAx266++KosuTJ0KURIphSER4gX+9z8sDCX07QsRDmmhxIxTjP795WswI6WgaoHDTDR6tLo/MOMdqRy104lxooInc6/XcVvCq7I5vBUt/Omn4KhJ0a/JyQjFr15d5mJdvoxUZY0ayZGJ69eDH/niizLFZfBg0BQ6drSOKkxPR6J0IlADrGyuXkWkpUlfsbqXmT4sd26khbPCBx/ARkr35nS6kkBLNJmLF12JpHftsr7PzJmwef55OdVbp06g7KgEFapWxXNLEa8XLkBMoXFjcBytMHcu6Bs9esh0iCFD0F8mTJDr8uGHqIvE/42JAUm/Xj25XQ4dAi+yXTu5vhs2QKCjTx+Z2vLbb6jL2LHW5U4n8/ffQ7hBEs+IjESy7rp1Id5vhZMn8Q7r1ZMFNnbuBLdUlWpv3jzwmiWxj6Qk5l69ELk8bpy1zYULqIePD6hpVtiwAdcoUsR6zDoc4KcSQYzCChcvMlesCBspYnvePJTnyoVIaavnad0aNo88Yj3HBAWBemTywaW6lCwJm99+s7Y5fx4cYl9fOdlDYCDarV49eU40UxR+8IF1OTPmGB8f5qVLZZtZsyA0oUqC4Sk0FceL8IZzPX8eWU6sxBZMbNiAHJaSMo3TCX7g8uUyVzUyEhSONWvkkP9duzCpb94s80LHjYMKzs6d1hO7YYBK0rOnnC8zMRFOsXdveYCdPw/BgH79ZPWU33/HhDFokEyrGDYMNqNHywuKV18FJ3ThQutyZtBN7rtPdkQpKRjIpUrJ79JUnqlRQ34H5kTYtq1cl08/hc2QIbLNCy+oxQmY4aCJZEcUEYHyQoXk9t26FTa1asn3mTgRNl26yDY9esBGcsCG4RL7kBIaxMW5JncpZ+6pU3jXxYvLdTEXfs89J9uMHq2e3J1OULOIZOWk2FiojxHJ/eriRSyYc+eWFY0OHsSio3JleWG9aRPekUTzcjjgEGvXlrmyyclQpKpbF2IcVoiJgZNv2VLOTBQeDnGHvn3lpBFBQczjx0PQwwqGgX47diye3wpOJxaIklANM6hNe/a4Mk3dDLRz9SLuNZ6rJ/w3FRePGZOwKok5M/iBKh4iMxynKo2ZYWC3quI8Op0g8KvEFlJTsVPcuVO2iYkBB1OaAJmxIyhQQB7ozNjRFiwo7wKZMch9fdXtM3IknLhKKrB3b5x0qCaMli0hhanCI48wd+0ql6elob4qRx8eDlm8mTNlG3PhIU3azJAsJFKngTPlO1V80G+/hRNW4aOPsCOXYBhYQKrEM0wH27OnbJOeDiejUttKT0f7qqT+HA5kQFKlB3Q6mRcvlhcezHiunTvV/cYwPOPT2s0V5rXuFWjn6kXca841O8Ew7Fea8fGyxJ2JS5fUTpyZ+cABtWNlRhq6VavUNqtXy/KJJhYvVjshZuwMZs1S24werd6JMyMlnUoJihlO2i7FXvv2aCMVWra0z43auDFOWCQYBo4KVY7T4cBOT4W0NOwYVUhNxacAu+t89JHaxulUO0UTkoRfRkiSmVnvp3Fn4Kk/0DxXD6B5rv8NeMJ1TE1Vp24jIoqKIipaVG1z+TIiWlX3O3UKkcJSwBMRgsRq1FDb7NlDVK+eOlp4xw4ElKmu4+9P9Mwzas6ov78cUGZi506ip56Sy4kQDFavntrmxAl1qj0iRKqrOLVEnr0vT9675sr+N+CpP9DO1QNo56qhoaGhQaRFJDQ0RNjRRYjs80PGxSFnrgobNqipTkQQbrATTBg2TH2NoUNB5ZDATFSnjpr7u3Yt8pKq0K0b8vdKSEwkql9ffY0lS5Dn0+4+Fy7I5eHhkEdUYc0adT5XIuQ+VVF1PHnHCQlqXimRZ/1N496Ddq73KFQEexOqJMUmwsPV5UlJ9qT0LVvUkyUR0erVINNLiI7GxD5njmxz/jwm1WnTZJuoKCQwl5xRSgr4sE89JZPkDQMqQ8uWyfchgkqQSgkqOBj1LVBAttm+3T4Bub+/WmM3Joboxg31kWVEhP19oqPVz5M/v/17zpfPM4GCEyfk8mLFkDxcVRfzHamwe7faAaenQ+c3IUEeT/PmYVGiGkuvvYb3GBVlXZ6cjPucOydf5/p1CKioFjdxcegLhw7JNsnJ0ElWzQ/M9otCIvu5IS3NXkjCk3kqu0I719uIpCQ1eZsIjsputTxvnlqGjhkEb7uB2LIl0b59ss2ePSClqwQrRo0iathQJtkbBtEnn0AYQJp4g4Lg8Nq2lR3avHlEzz6LQS/twHr1gjCGtHuKjMTzXL2K74JWWLyY6JVXQKQ3dX2zYsgQCAf07WtdTgTB/YgIuS5HjkA+sWVLeYLZtg194ckn5Ulqzx70mfLlrctTUtDnHnxQbtvwcEze990HRyzZMKNc2u3FxuJZLl60Lnc6oRd89arsPFNTId6wa5faCT/+ONFPP8n1ffZZODTJwTITdeqEa0g2RYtCTKFjR3ksvfMO3lGrVnK/7N8fiROkk4F8+aAY1aAB0aZN1jaGAdGSVq3g7K2wahXRc88RjRxpXc5MNHgwnnvRImsbItTz+efVCmVDhxK9+abaOX71lfqUghnPpJqnDAP3kt4zERZBM2eqT2aSk+3nXq/jNgRXZXt4I1rY4QCn8cknZYGIqChw2F55RY4GPHwYVJD33pPD22fMAOdz+HDZpmtXENt//NG6PCUFFI8iRSB4YIXz55G8uXx5mUy+aBEoE7Vry/QLM9F569bg+2WFYYAv6+ODRPFWnLnQUJQXKIBIXCv89hvuU7asTJPp1w82zZrJFIM6ddTJsVNSUJ4nDwQ9rGDyRv38ZL7st9/CRiUY8tJLeG4ph6phIFl63rzyezxzBtfIk0dulzlzQLMpVUquy/vv4zqtW8t1qV8fz/Ttt9Y2166B7K+i62zahL5LJIsPjBiB+kq8XKfTJajw/vvWNmFhLuGGRYusbbZtcyU5l/ie33yD8nLlrMdjbCyoPkRyisEjRyCyQgQaUlYYBpKTlyyJd2CVcD0hAVSfggUxZq3GUWwsaEU5c8q5Z6OjMUepchZHRkIQJ1cucFCtEB6OHMLly8v81AsXMEZeflmeEw8eBIVOlTJx/XrY2EXEewJNxfEivOFcQ0Mxian4XocPg1QtwTBA81BxzxIT4VwlIQpmkLKnTFEnSl68GFQQVS7Mjz5CYnBpsZCayty8OYQxpIEREgLHqUqMvW0bc4UKyNsqYfJkKMscOybb9O6NwaxqvyZNmBs2VFN7ihfHxCw5GVOUoX9/+Rrbt8NGWtwwuxKLqziNfftiIlT1m+eeg4OVFguGgUm5Xj35GteuYdJWCUTs2IH6qhJ5T58Om7VrZZv+/WFjtdAy0aIFHKyElBT0q7p1ZZvQULzLt9+WbczF7KhRss2aNXAiq1fLNtOmQTVNoik5nXDChQvL7yklBcIiqvcUE4MFYvfusk1YGJS2VNShoCCMFxU17cQJLHYl0QtmOL6JE+Xxbxi4h7QIZcY48/dX52xOTcWCVVIPY8ZCbO/em+fcaufqRWieqzsMQ50YmhkOyi7p89mz9snQN2yw57H+8AMmFhW6d5dXyMx4pmbN1IuOpCTmmjXVwg4XL2LHJKnSMIPA36iRmq+4dCl2piqMG6cWf2BmHjAA6lYqtGuHSVCFhg1lSUJmPEv58pjAJCQkQIwiJES2CQmBSpakHsYMUZHy5dX13bkTdVZh/XpZctDEihXy7tbEsmXYLauwcqV8epCxPn/9pbbZscOeC3v8uP34VHGNTajewX8V2rl6Edq53v2wW406nfZOPCnJfsKJiJCP/0wEBalX2czYEdnpnPr7y5KFJlavtr/XggUQ0VBh6lRZftLE2LH2i5zvvpNPMjLa2L0vSR4xI6ZOtbexE9hgZt640d5GOtrMCE/UjFQnQSbuJTWjexFaRMKL0DxXDW/DE8EBw7BP8u1wqMUhiBC1mSeP2iYlRU6C7m0bT+rjyXN50j5a2EHD29A8Vw2NuxieTPh2joPI3gER2TsyInuH6E0bT+rjyXN50j7asWrcKWjnqnFXwBO+m7c4cZ5c58YNdfm1a+CpqrBtG+wkMBP98IOaQnDoEOhBKkyYoOaFGgZyl6qwbRvRlClqm6FDiY4dk8vT0ojat7e/z88/q22+/57o7Fm5PClJnbOUCPXcuFFt8+efci5XIrSbijNKhHdn11eYb2/fvZe5o9kJ2rlmQ3hykK8i2JtQccfM+9gpFQUH2wsH/PabzIM18cUX6oTrV64Q9ekDJSEJc+fiOqrk7osWgTcqqepcvAhxCCnJORHR8eNwigsXquvbq5fMCY2Ph2jGr7/Ku6vkZCThvnxZvo/DgXpIOz1mPOuBA/I1iPAOVfchIjp6VN1ncueWeZomkpLAP1X14fPn0TaSslH+/HDQkZEy/zc2Fu9I5fhWryZaulReJDmd4F7v2gVeuBV27iRq0wbPJGHUKKLvviPavFm2ef99LBgkDmtqKjijqkVFSgoWWqtXyzZpaUS//CJznonAG921Sy43YTc3MOM9qJCWZj+fZdsPl7flC3A2h7cCmoKD7bOlrF8vc0ZNfPklws4lpKeDF6YKo798GdSVwEDZZskSJB9XZZN55x1Edp4/b12elgZ+X+HC1tw7ZnD4iJDcWgrg+e47V+5NKSr4qadg8/331kEh0dGuXKy7d1tfY+lSXKN5c5li0K0b8m6qeMRVqoD+8scf1uWBgeBzNmokBzZNmoRcrJ07yxSDPn1AFZk0ybrc4WB+9llQmZYvt7Y5fBhJxZ9+Wk6lt3QpksS3bi3XZeJE0GM+/9y6PDUV/aVcObm+Z88iEXq1anIf37QJfffhh+Vo6xkzwD99/XXr8qQkRFkXLIhIcyucPg3aS+7c8jhZuxbXKFvWutzhQLQ2kZyS7upVF3dayl60fj2eJ29e6/5vGMxff63OT+t0ImqcSH5mhwMpHnPlYj561NqGGe+4WjV1urkvvsBYUeG999RBZ4aBa6gyLSUnI4e1qi7R0Z4FwHkCT/2B3rneJqSkEHXvjhW5tNq+coVo4EDsIqTV2ubN2KmodoKjR2MHJsmTMRO99x5RiRLysWViIpSVGjeG7J0VTpwgmj8fSi1SxpAFC3CPfv2QBcYKkycTFS5MNGIEUbVq1vWdPx8qRCNGEPn6uttERUHOrn59KNBY7Qb37sW1mjYlqltXfiYioubNIbNnhdBQHL09/bS867x+Hf/WrGldnjs3dl5paURVq1rbFC6Me+XPL6tF5ciB3aBUnjMn3uXFi0SVKlnbVK8O5atjx+QsMxUqEJ05g74g3StXLuy2pVOTPHnQ969cISpZ0tqmYkU88+nTcjabxx8nCgvD7l/67lqhAsacdHKQPz/6WmKirO1cuTJR2bLYyYWGWts0aIB6Bgdb79Jy5oS0YdGi8olKmTJQccqTB3KYVmjWDDapqdaymz4+0Ft+4w0oRp086W6TIwfKGzXCrt6qbXLkgOJapUpEn39uXZf0dCI/P+zmx461tjGvvWqVrDgXH4/x+NlncvveuIH3062b3K8iI9F3Bw60LifC+5k/H0pvtw3e8eX3Nryxc42Ls6cohITY88pOnlRzI9PT7YnSISHMe/ao77Nzpz39YOZMNZ3E4cCKUrXzjYyEEoyK93jwINStVBzV+fORb1RFtxk8mLlHDzX/7/XX5Z2Xiccft8/dmSePOu/rhQsQfzh8WLZZtw67IhWncdw47ARVfOJevbArVaFJE7XwgNMJpRyVQEREBHY8quc+cAA7JxV9aOFCXEc1Fr7+GjsnFbp0gZKQBKcTu3oVBzg+Hu979mzZJiSE+aGH1GPqxAmcQqioXrt3M9eooR7f69eDk6zCb78xDxsmlxsG87x5as5yejqUoM6elW1SUnAd1Y4xIQE8dRViYtTiL8xoNztub3i4mlvODBW8m4XmuXoRmuf67+AJXy8x0d7u6lV7m4MH7W1WrrS3mTTJ3ubzz9U2aWk47lLhyhWo26iwfz+ciAq//65WeWKGRN2SJWqbr76yT+Tdo4d8tG+iVSv1IogZx5aqBU56un2S84QEWZ7PREQEjs1VCA5WOyJm8JanT1fbnDsnfwIwcf68+qiVGXxkleIRM5yMnUCE5tPeOmieqxehea7/HXjCi0xPx7GuBIcDR1iqbDdmQIl0xEqEo+58+dQ2V6/i+FpFgTl3DkfqKgrMiRM4HlbRWwIDiR57TN0+gYE4tlXh5EkkclDh3Dkcy6oQHIxjWxWuX8fnDxXi44kKFVLb2L1zIs2p/a9AJ0v3IrRz1dDQ0NAgukdFJEaMGEGNGjWiAgUKUOHChT36m65du5KPj0+mnwYNGtzaimpoaGho/KeRrZxrWloatWvXjt57771/9HctWrSgsLCwv3/WrVt3i2qo8W/hCdctNVVtI0U1Z0RysvpeTieOdaUoU7MuYWFqriARcq2qrpOWBg6wCocPE/31l9pm1ix17s30dOTWVGHvXnA+VfjxR7W4g9OpjtgkQh5bO1GMJUsQmSzBMJBPV4XQUAhWqHD6NFFIiNpGFblvIiFB5uSaYFb3BSLP+q/dGDDvpXHnka2c6/Dhw2nAgAH0uN1HnSzImzcv+fn5/f1TpEiRW1TDmwdiKdU2nghExMfb24SFqctTUjABqXDokL1AxNy5EF6QwEz0wQdq8YcTJ0DWP3hQtpk4EZQFlRjCW2+BPiHRoc6fh4BEr17yNWbMQALt33+X39XYsUSvvirTPCIi4PBmzpQnzN278UxHjuBdWGHbNtAqoqOt62IYEBVYtUoWzjAd0b59LgpRVly8SLRhAyg70jOFh+N5pHedmoq+sngxrmOFuDgsShYskMVJkpPRLtOmWZczg/7Vv78s9OF0gtLy0Uey8AUzUbt2oJpJ7R8WBrqValGxejWES5YskW2+/15NeyMCDU21r0hPxwJo1iy1zZQp6kVFerq6b5s2KlUwItciVIWUFPv5zJP57q5UpboNwVVex+zZs9nX19cj2y5durCvry8XL16cK1euzD169OBrNuk/UlJSODY29u+f4OBgr0QL79vHPH682mbiRDnZNzMi/N56S50PMy4OiZVV0Z+HDiF5sCQawAyaR/786gjRl16C0ISUezMxEeXly8uh9Dt3YklRr56c7m3oUNi8/LIc+t+4MWx69bKmM8THI6dmzpwyDWH1alyjTBn5mT78EDYtWsh0kcceg2CFRF25fh3XyJsX/cIKS5bApnx5OfrTTDSvipytUgXPLSW2DgnBNaQk28ygxxCBTiJRRXr1gk379tblTifoM0Ry9O2FC2gTFV1n1iy8wzJlrMuZkaNVlXw8NhaiGEQyzWb3bgh0qBKhjx6N8sqVrcuTkyFIQiRHkJ8+jXYlkoU+du5kLlQIFCWJTrJ6Nd5h/frW5czoA0QQeJAwbJg6Wb1hIGds0aJyZLjDgXywzZrJUclOJ+hS334r18UwmNu0UedydjhA1VPlsI6JQdpAuyhrT3BPU3H+iXNdsmQJr127lgMDA3n16tX8xBNP8KOPPsopCkLU0KFDmYjcfm7GucbEQGlk7ly5s504wfzqq+rE4b/9holUpb40aBAm3dOnrcsNA47h88/lDhkTg8ln/HiZO3boEJRpli6Vn2naNOZHHlFzAN95B+pKqrRojz2G55bUgWJjMfEMHizXZft2OBmVIszYseCWHjgg27RvD26pajBXqgRuqTSYY2MxganyhG7ZApuZM2WbMWNgo+LLvvkmJmZVurhKlaASJOHGDTg0SWWIGSnyiNRKOOPGwWb/ftnmrbfwniTursOB/lCzpnyNsDDkjVVxd3fuxH1U9TWdkdQfDAOLipw5ZR57QgL4tKrE7RcvYrypKFw7djCXKCEvBgyDec4c9N/jx61tUlKwUC1VSl6wRUTgmZo1k+ty8iQc2mefyTbbtjE3bSovGNLTmRctgkqZxKdNTAQ97qWX5LEfFQW1tH795LEfHMz80UfqseQpso1zlRxZxp8DWXr2P3GuWREaGsq5c+fm5dIb51uzc/WEU+ZJYmI7/pph2OckjY21J1NfuGCffHznTrnDm1i8WE3sTk6GA1etKM+dkyUNTfzxh7282YQJGMwq9O1rT3p/8UX1jp+Z+dFH5Z0vM567VCl1Gx87Bieiapvly5lbtlTXZdQo+2Tf3bvbn6o0aYLdkQSnE4stVQ7aGzfg6FViHydOQK5RhXXrIJOowrRp9jzXL79UP7dhYPGnOilKT4cspEoYIzERC1rVWIiMxE5OheBge+7z2bP2vObAQPs+fPCg/VwSEKAWvWBWjwNmz+Ysw7DPx+x02u9MvcHtzTbONSIigk+dOqX8Sc5yDngzzpWZuVKlSjxq1CiP7bWIxJ2FJ0c5dk6e2V7hhdleJIHZXt2K2d5BO53Mv/6qtgkLgxNR4cgRLHJU2LjRPjH7ggX27TNliv3ibuxY+wlswgR1ObO9MIZh4HhYBafTXqc7LY35zz/VNsnJcCIqJCbKR8cZbeymkKQke2fljaNNjX+Pe1pEYs6cOdS/f3+KsUvrYoGoqCgqU6YM/fzzz/T222979Dea56pxK2AnOmCOTJWN0wn9WhU8STzuiUiCt2w8qY8nz+WJaIMWdtDwNu5JnuuVK1foyJEjdOXKFXI6nXTkyBE6cuQIJWTI01StWjVauXIlERElJCTQwIEDac+ePXTp0iXy9/enVq1aUbFixaht27Z36jE0NIjIftL38bG3sXNARJ4lHrdziN608aQ+njyXJ05TO1aNOwUPuvndgyFDhtDcuXP//v9atWoREdG2bduoadOmRER05swZiv3/9BQ5c+akwMBAmjdvHsXExFCpUqXo2WefpaVLl1IhO70zDQ0NDQ2Nf4lstXOdM2cOMb4TZ/oxHSsRETNT165diYgof/78tHHjRrp+/TqlpaXR5cuXac6cOVTWTpBU47bD7uOEKe6ggpTQOiPCwtT3SkuDUILEgyWCpm1oqLo+kZHq9ILp6eCdqpJsp6WBD6riCBsG+JNRUdblzOASTpkiX4MIdd24UW2zcKE6QTYz0ciR6mucOwfOreod/PknRCRU3MUFC9SCCrGx4E1LyceJwMu9fFmdUD0sDBxfFZKS8FwqOBwyh9iEJ/3XE85n9vvQd4/iFn/7vSfgzYAmu2AEu5RJqI+9jV1wimHYB7lcv24fUbh5sxz2b2LKFKTBk5Ceztyxo5pOsmsX8wsvqOk6n3+OjCtXr8o2DRviR4rsPHcO3N7mzeUEzePGIUF8r15yBGObNriOFJ2ckACe5mOPyYnbly1DQvC2beX3+fnn4BsOG2YdSGQYSLtWurTMnz5+HFSoxo3l9/Trr6CKvPKKHDw2fjyeecgQ6/KEBOZOnUD7kSgRAQGgMNWoIachW7UKlBRVUvDhw5mLFEGiciuEhiLCt2hRORJ4zx7UtXBhOcho6VLwxaXUdunpSNzu54d/rZCayvzzz8wVKzKrKPiTJsm8XRNTpoArLyEtDf1XleItNRU8ZNVclZwM6pUKqanqlHVmfewihePi7IPkPJk3vRUIppOl34X47TeiL79U23z6qXqX4XQSvfgiVu4SwsKQ4WTLFtlmwwZkL7FKqmxi3Dii555Tq6wMGULUti2RFFsWHQ31ms8/l1Vutm4lWrQIqjvSTu+PP7Czmj1bXplv347diqTilJwMFaLgYDlDzMWLLpm68uWtbaKisCMqWxZJtyWblBSiBx+0Ls+fHyo5169bJ4gnQraboCDcy89Pvk5UFL5jWn1f9PHB34eGEpUubX2NKlWwQw4IkJOlP/QQdpNRUXKWHsNA20k7+oIFUZfz5+W6VKuGXeCxY0QPP2xtU64cdv1WycmJkNnngQfUO1I/P7RZVBROEaxQtSr6Y0yM3L8ffBA7aElNKlcu1CM8nOjoUWsbwyBauxbXkFTKQkKgvrRwoay0dfIk0bBhRL/8Yl1OBJnLgQOJfv5Ztvn1V6J334VKk4QffiBq3lyW3WQm6tcPKmXSmDYMJG8fPFi+T1oa0csvY36QkJBA9NRTasnM69ehvCapi90SeMeX39vwxs41IYH5u+/UVI+zZ7HiDg2VbVatApUhPl62GTECYhUSb9bhgILN+vXyijAyErw81W5y924oJl25IttMngyeoKrp3nkHfEPVyrJuXXnlz4wdZJEisqoMM4QL/PzUq+np07GbVPFPe/cG11VFmXjySeZPPpHLmZFQfd48ufzUKQgYqJLWL1oE3qikbMXM/Omn4N2qVv/Nm+P0QIKZLH30aNkmJAQKQRs3yjYbN+KZwsNlmzFjwAFW4a231Pze9HTmWrXUie+vX2cuWVJNiTp0CIpRqj5j7l5V7TtsmDphfVoadvUffijbREWBa6zqM2fOILl7YKBs4+8PAQ6JVmUY6FeqRPPmDnjwYNkmJgZKUEuXyjaXL4ODreJGBwRAAEISQTEMjPsxY+R3kJoKWtaKFfJ9PEW24blmB9xNPFdPSNB2PLm0NHub2Fj7e4WE2NvY8UYNQ602ZdbFLpH3sWPqo2dmJBa3O8KeONGer/jJJ/YiHF26yDKNJtq0UbdfVBRzhw7qa+zbp1bJYcZxsCR9aGLECHtObffu6kmQGUf3qoWf0wkHoUJcHI5sVbh4EcfyKuzbp5bWY4YoxoIFapsZM+y5zSNHqpOcGwYW16r37XTaKwilpmJRrEJioj0vNzYW41eFyEj741Y7oRlmz45s7eYj5rsnufs9zXO93dA813sDhqFOBk6EYyhVUnEiz5JrR0biWFeFkBCiMmXkcsMgunIFR7ISYmJwLFmypGxz5QqOSVV1PnkSyclVVJqjR4lq1FDTW44dg40KJ07Ix88mzpzBsawKFy8SVaigtrFrYyLP3lVCAtF998nlzDheVvUdT3jLGnc/dLJ0L0I7Vw0NDQ0NontUREJDQ0NDQyM7QDtXDQ0NDQ0NL0M7V41bDk8+PNglO05Pt7+OJwniIyLU90pLw7c81b0uXAAFQXWdo0fx/VG6jmEgSfeRI/I1zpyBoEJQkHyvI0eIli8H5UmyCQgAdUuiIURGIkH5jh0yveX6daKVK/Ft1qQqZUVMDOgiV65Yl6emom3XrgUdxwppaaCL+Psj4bkVzATwO3ZYlxOhjrt2ybQss75Hjsj1JUK7ShQaE0lJ6msQgY4SGam28aT/eitxuP4YeBtwG4Krsj28FS2cnm4fORcdbR8Vd/WqfXTd0aPq66Sn22cDOX3anii+fLl9tO+wYepI3qQkUFtUdIfNm5FfUiUi8cknoJSoUlzVr49UZVJEcFAQqBevvCLTh376Cfk7+/SR30Pr1sgvO3myXJfcuSFiIEXpbt3qStwuCWN8+ilsmjeX33fNmriXFDkbFoa8pqrE7bNn43lKl5YpU2+/DSqOJHSQkoLE70Sgillh1y4IdKjoOiNGgMZUq5Z1udOJnLtEyG1shago0KWI5D5+5AhEJAoVsi5nBgWkZEnmdu1km99+g80vv8j1/eUXpOsLDra2SUuDQESbNvJ9mNE3R46Uyw0DlBXVuE5JQV9RZZqKj1fnRWbGXGYXwR8fj/SWKly/bj9vSknbM8Iuo5On0CISdyHGj7cXkXjnHaz+JSQnEzVuDFEFCadPE9Wvr5bNW7iQqF07kNsljB1L9MEH8oqameirr4hGjZJX1NevE33zDdHixfKKevNmiFqsXy/XZfNmogMHZLI+EXYqly7JEa9paUSHDhHly0dUqpS1zdWr2GHVr08kxSrExuLZ27WTo4+dTqLChUGSl1CwIEQTWrSwLjeFIzp2lCNeK1fGv336yFGotWqh7bt1k+9TqRJEMerVs7Z58UU80/PPy6L6r7+Odnn6aevyvHmJ2rfHf9eubW3TqBHqW6gQUYkS1jZ9+qDtpAjpHDnQb4lkwYsiRVBfIrlf1qiBqOb4eLl/16yJuqpkIcuVQ7SxJNiSIweEN4KDIXIiYf9+SEdKYzYigmjuXKJZs+SdaVAQRGoySLS7ITCQ6LvvIKspYeNGorffJjp1SraZPh0iEpJ4DDNR//5EAwbI1zAM9P+JE2Wb1FTMiaqTjOho9CvpNOSWwDu+/N6GN3auKSnMK1diBSrhyhUk/VbtOP/6y55zt2ABdp0SnE5w7lQSiRERIOCrOIu7d+M6qiTvM2Yg76bqmT76yD7/aatW2I1LSE3FTkYlwHH8OPMzz6iTLi9ciJ2Xqr6ffWafsLplS/t8reXLY3ck4cYNZl9fNafW35+5enX1ScakScyvvaauS8+ezEOHqm0aNFDnR01NhZCHqu8FBTEXLKjuM+vWMdeura7L998zd+2qtunWDfllJTgczI0a4VREwo0bzA89hN2ThFOn8A5U2LzZnrv7yy/yTpsZffKLL9Q7xuRknCCopE2vX8fOXrWTO3uWuV8/dX337EHfUtV3zRq1qIjDgVMR1WlTYiLmERVvPDLSPnfvpUvMO3aobTyBFpHwIu4mEYnbBU8I26oJ0oQnRzF22qJOp3xcZiIiQq36wwwBBDvSu7+/vfjD8uX2OqWzZ6vLmT1LCK5yDswQApgzR22zc6dauYoZCzI7HdgffrDXtZY0jjPCbmFiGOqjTWYskKZMUdtcu6ZWB2LGM//1l9pm3z715whmfGKxGw92i2Jme71vZnuRE8PwbEypFpnM6ON2n5/uFmGH2wktIuFFaJ6rxj+FJ0m6PRG1sEsszgwblfhDairEDVT1SU6WdZK9bZOSgqN5FTwR8/Ak6bonbawTqmv8E3jqD7JVPlcNjewCTyZru0mfyN55+PjYJyjPm9f+PnYO0Zs2do6VyN6xEnmWdN2TNtaOVeNWQAc0aWhoaGhoeBnauWpoaGhoaHgZ2rlq3HJ48lVfyvloIjX17hGRuHwZtAmVzalTEKhXYetW0KYkXLmCnLyhoXL7HDkCcYfoaPk6u3bB5vp16/LoaAha+PvLuUKDgkAD+esvuS6XLoHiERhoXe50ol1Wr5ZzbyYl4ZnWr5cFLZxOtIuKtuJwEO3eraajJSRAYENFR4uNlZ8n43VCQtQ2Dgdyx9pdx66Pp6aqy4nsxxKRFpG4Lbgt4VXZHN6KFo6JUROzmRGVaBfFd+CAmtLDjFRaqki/uDjm+fPV19i1i3ntWrXNjBkQO1Chd29ZnIAZ7dKoEdLGSVi1irlxYzXhfMAACE2o8svWqoU8tVJuyMuXIZbQrZvcfjNnQizh++/l+3ToAMrJqlWyTdGizCVKIAenFY4cgcjB44+D5mKF77+HTe/e8n1eeAE2S5ZYl6emMufPD2EMKeLaFLSQhBuYkduTCMIWEkzhBomeER4OEYmcOeVnXrYMghfNmsn3GTIE95Gijh0OUGOIMJ6sEBGBti9SRL7P0aPMDz4IaouELVvwrn/+WbaZPx99ISjIutzpRP5UVU7Y1FTmUaOQG1mC0wkRjpUrZRvDwFhS0Y/i4+1T6IWFqe/DDBbAwYNqm3Pn1On8mEH/8iRFpjegRSTuQgwdCmK1BMMAMVslpnDjBoQJVJJse/YQ9etHFBYm28yYgbrExck2EyeCSC4R6A2DaMQIom3b5JXw1atE8+bJOxUil8SfStrtr78QiapKm7Z/P1Hx4kSlS1uXOxzYyTz/vHwdcxfTpYscDJOQgBRlnTrJdSGCAMFLL8nlhQpBiKJKFetyU+jik0/kAJ+qVRGQ07+/fJ86dSDI0LatdXmePBBv+N//ZGGGp54i8vUlatVKvk/Hjvi3aVPZ5t13XXWyQsmSaNeHH5afuW1bourVZSEQIghN3H+/nCYuZ061eAER3vFbb2GMSP378ceJnnwS/VxCrVp4rrNnZZvHH4fEZ0CAdXmOHBD72LNHHte5cmF3PH++XN/YWJxkqAQiLl3CmFy0SLY5c4Zo0iSMOQkHDhC9/756jlm+HH1Xqi8z0YQJELWQ4HBgvvvtN9kmMRFiLap5yOvwji+/t+GNnWt6uj2P8Pp1ez7nqVP2Ul9//aXe/RoGdrYqrmZiIkjZqtXgyZNqAj4z7qMSSmBmnjDBswTlKo6qw4EE5aod/YULzP37q+/z++/2/MnvvrNPLN61q31i9ueeUwtEOJ3YKare0+nTkGpUYflyCIKo8PXXzPPmqW3at5d3eSZq11ZzYRMT1btfZuxUWrVS26xbhz6hwvjx9hzgPn3Uz+R0QlpSJb8XH8/ctq36PleuML//vtrm4EFwiVVYvRo/Kkyfrp5rnE7cR8XnTkqS5RpNREZCJEKFS5eYDx9W2xw9as9R37tXzSM2DPsE8Wlp6Fs3C81z9SI0z/Xfw1t8Tzveo7nrVdnExGA3o7pXWBh2CKo6e5Kk+/RpSBuqcPQo0RNPqG0OHJAlCYnw3EePqm2uXEEbq5KuHzyIXbDqZMDfn+iZZ9Ttt20b0bPPyuVEkKl75hm1za5dkLSTwIw6q547PR27RVVi9vh47OYefFC2CQ9HvylQQLYJC1PvpIlw6lSkiNomMVGWbDThCQdY83tvHXSydC9CO1cNDQ0NDSKdLF1DQ0NDQ+OOQTtXDQ0NDQ0NL0M7Vw0NDQ0NDS9DO1eNm4InX+xVog0m0tPV5UlJ9veKjbW/l0qQwazHmTPq61y5QnT+vLo+p0/biw9s26a+zrVryHMbGirbnDgBgQhJcIEIdInVq2URidRUorVrIcwg0SauXiX6/XcEGkm4dAkUDylvKRHaZeVKOf9pSgoCtFatkqlZaWmgZqloIMywUeUbTUqCEEVkpGwTHU10+LBcbtqoqDhEeC5JoMNEXJy9AERSkrqcyH4sEdmPEx2J4wXcfGDyvQ9viUhcuqTON8rMvH+/PWF6+XJ7qs2kSWoaTUgI8+TJ6vusWcO8aJH6OiNH2udRbN1aLTRx7RryYapEJH79lbluXXXqrw8+gNCE6jU9+ihym0r0lpAQCESoiPjz58NG9dzduzPff786B22FCswPPyxTjC5dgsiBKg/onDmwUQladOkCG4msbxjM5cpB6ECiMp0/j2u0aSPfZ8YM2EyYINt07Agb6V2npaEuKuGGwEDmPHnUOWpNoQ8VreqDD1AXKc1baipzkybMJUvK1wgPR77Xjh1lm8OH8TwqEYnVqyGeoaKKTJ4MUQsJTicoVx9+KNskJzMPHKimKCUkgEomCVowQ4Sld2+1UE1oqDrfKzOohap8r8yYE+1ojFu2yKIjJvbuVZd7Ci0icRfihx/Uq+30dKJhw+RVPRFk9yZNknchRETr1oE2odrN/PILdk0qObXZs9WSbQ4H0YIFavrGhQvYPUjCDkSQASxZkqhcOdlm716i2rWJypaVbQICQPqXAvgMAzuM/v0hImCFiAjUpU8f+T4pKaCAtGkj2+TMSfTmm0Q1asg2vr5En32Gf61QqhToFEOGyNeoWhXP27OnbFOnDlHdurJwg48PhB/atZMz7FSsCOEGlYjEq6/i71VUnHffReac6tWty3PnJvrwQzWN6bHHiF57TU2f6dwZ95Dalghtf//9cl/IkwdtrxojJUsS9e2LUwYJNWsSvfACKFwSmjTBu1TJNf7vf9hlS1KLOXKAvrRunbzzzJsXgiKrV8v3yZEDbaISmoiLA81p2zbZJiyMaM4c9VwVFEQ0erR6Jx0QACEJCYaBU5fZs2Wb1FTMmyrJTK/DO7783oY3dq5Op33i8IQEe1nDiAj7BMYq+T8TdmTq9HSIRKgQEmIv/nDokL3oxcaNapI+s/0O2jBAnlchLIx54UK1jb8/844dapvZs+3b75tvmKOj1Tb9+9snXe/TR11+44ZabpAZMpYzZqhtZs2yf+5Bg9CGKnTvru6fhgEbFeLimD/6SG1z5gzkAFXYtMle5GDqVPt3OXiwutwwmL/9Vm2TnMz8449qm4gISDuqcPYsdnIq7N2L0yAVtm61n0fsdnpOp71QSkqK/XwUE6M+bWKGwI5dfe3GG7O9/Kwn0CISXoTmud79uF3JyYk8I/EnJalFB4ggYKDa9RNB+KJwYbWNnTiB+b1aJU4QGYlrqNrn+nXselSIiIAE5c3aeCK44Enb2LWxYeB9qnLMpqVhR63qXzpx+38HWkTCi9DOVUNDQ0ODSItIaGhoaGho3DFkG+d66dIl6t69O1WoUIHy589PFStWpKFDh1KaKpUKETEzDRs2jEqXLk358+enpk2b0gm7RJsaGhoaGho3gWzjXE+fPk2GYdD06dPpxIkTNH78eJo2bRp98cUXyr8bM2YMjRs3jqZMmUIHDhwgPz8/ev755ynek8zaGhoaGhoa/wY3Hzt15zBmzBiuUKGCWG4YBvv5+fGoUaP+/l1KSgr7+vrytGnTPL6Pt3iu2Q12yYeZ7aNdme0joJntE8THxtpHC0ZG2kcdX7ig5sOlpSHCWZXe6tIlNSeXGdzJw4fVbbhxI6I/pTaMigKnWZWG8ORJRJiqElvv2wcbiT9tGLjPmjVy21y7hmTru3bJ9wkKQjS2xBs167toEfPVq9blDgfznj3MS5fKbZeYiKjuPXvk+6SnIyL21CnZJjmZ+c8/1Wn/oqKYd++Wy5kRNa/ihDIjktUu0vr6dfuxokq7aMJuLDHb38fptB//nswP9yL+EzzX2NhYKqIIKbx48SKFh4dT8+bN//5d3rx5qUmTJrR7927x71JTUykuLi7Tjzdw+LA6YTIRVHBCQ9U2Y8ciYbeEtDQk2Fbx806dIvr8c7UizLx5an4ZEdHAgeC6SmAmevpp8G4lXLlCVKkSeLcSVq9GQunoaNnmyy+REFmlUPPSS+rE4tHR4IPOmiXb7N8Pzu2ePbLNtGmoi4r/+Mkn4GNK0aE5c4LPOX68fI0LF4hef51I0Z1p2TKi9u3ld+3jQzRmDNEXX8hR0Pnzo66LF6vr0qmTmqu5eDGSqkvc0pw5wT/98ku5XVJTwTGeMUO+z86dRM2aIWWfhB9/BHdUOsRiBoe1fXv5GsnJ6FNffSXbXL1KVLky0Zo1ss3eveCCBwXJNnPnguOrCkH98kui3r3lcqcTnOiff5ZtkpKQkP7oUdkmIgKcZ9VXubNniT7+WC4nwnPPm6e22bxZPdaI0K9iYtQ2S5feXuWpbOtcL1y4QJMnT6beip4UHh5OREQlS5bM9PuSJUv+XWaFkSNHkq+v798/ZVXKBR6CGQ5C5RSTkkCGVjmHs2chJKFyiuvWgdwuTWBEkKCrU0dts327OqdmejqctEo04OxZTBr168s2f/1F9PbbECqQcOQIFgMPPCDbXL5MNGqULIRgDizVRBgdTdSgAVHXrrJNejpRly5EDRvKNnny4D5+frJNkSJE338v0zN8fSEk8dln8jWqVSOqUkUt7lC3LibLLMMgE5o2hdOTUKgQbF5+WbZ59lk8b9Omsk337kTly6vbZeBAWWSCCH3go4/UgiJNm8IBq6g6fftCuEHqLz4+RCNHYmEhIX9+LHZV6+8HH0RfUEkkPvkkxsDp07LN668jj7Bq8d2jBxy05ERy5sR9VGIKBQpAEGT9etnmgQeIatUi2rRJtilRAhSvK1dkm+LF7ee8fPnUohcmfWn5ctnG4UD7qxahXsdt2kmLGDp0KBOR8ufAgQOZ/iYkJIQrVarE3W3Y6Lt27WIi4tAsmoM9evTgF154Qfy7lJQUjo2N/fsnODj4po+FDcP+GMXu2JNZfVxpwu5olNmeTG0Y9kdQcXE4WlMhNNT+6Pj8eXU5sz1ZnVmW9zORlIQjXxXOnLEXxti+Hc+uwsqV9s+9eLG6nJl53jx1eXq6WsqOGUeWf/6pttmwgfniRbXN7Nn2fctOyIOZ+Zdf1OVOp/0zxcaijVU4d85ecMHf315udO1adTmzffsaBvPOnWqb9HTmI0fUNnFx9v0zLMx+fKs+NZhQfWow4ckxtSdzjZ10YXq6d+ZPbxxlZxsRicjISIpUKWcT0UMPPUT5/p/lHRoaSs8++yw9+eSTNGfOHMqhYGUHBQVRxYoV6fDhw1SrVq2/f9+mTRsqXLgwzZ0716M6ap6rxq2AJ4IB3hDHgIKu2sbpVJ9ieNPGEzEFbwkuaFEGDW/DU39goyly61GsWDEqVqyYR7YhISH07LPPUp06dWj27NlKx0pEVKFCBfLz86PNmzf/7VzT0tJo+/btNHr06Juuu4bGzcCTSd8TGzsn5ONjfx07h+hNG7v6emrjrfbT0LgVyDbfXENDQ6lp06ZUtmxZ+uGHHygiIoLCw8Pdvp1Wq1aNVq5cSUREPj4+1L9/f/ruu+9o5cqVdPz4ceratSsVKFCAOqo+MGloaGhoaNwE7vjO1VNs2rSJzp8/T+fPn6cHs6TDyHiyfebMGYrNkA7m008/peTkZOrTpw9FR0fTk08+SZs2baJCdqKuGhoaGhoa/xJ3/JtrdoD+5qqhoaGhQaS1hTU0NDQ0NO4YtHPV0NDQ0NDwMrRz1dDQ0NDQ8DK0c9XQ0NDQ0PAytHPV0NDQ0NDwMrRz1dDQ0NDQ8DK0c9XQ0NDQ0PAytHPV0NDQ0NDwMrRz1dDQ0NDQ8DKyjfzhnYQpYuWtpOkaGhoaGtkTph+wEzfUztUDxMfHExF5JWm6hoaGhkb2R3x8PPn6+orlWlvYAxiGQaGhoVSoUCHyuYkcVnFxcVS2bFkKDg7OFhrFur63Frq+txa6vrcW/9X6MjPFx8dT6dKllWlP9c7VA+TIkcMtE8/N4P77788WndGEru+tha7vrYWu763Ff7G+qh2rCR3QpKGhoaGh4WVo56qhoaGhoeFlaOd6G5E3b14aOnQo5c2b905XxSPo+t5a6PreWuj63lro+qqhA5o0NDQ0NDS8DL1z1dDQ0NDQ8DK0c9XQ0NDQ0PAytHPV0NDQ0NDwMrRz1dDQ0NDQ8DK0c71FuHTpEnXv3p0qVKhA+fPnp4oVK9LQoUMpLS1N+XfMTMOGDaPSpUtT/vz5qWnTpnTixInbUucRI0ZQo0aNqECBAlS4cGGP/qZr167k4+OT6adBgwa3tqL/j39T3zvZvtHR0dS5c2fy9fUlX19f6ty5M8XExCj/5na3708//UQVKlSgfPnyUZ06deivv/5S2m/fvp3q1KlD+fLlo4cffpimTZt2y+pmhX9SX39/f7e29PHxodOnT9/yeu7YsYNatWpFpUuXJh8fH/r9999t/+ZOtu0/re+dbFsiopEjR1K9evWoUKFCVKJECXrllVfozJkztn93K9tYO9dbhNOnT5NhGDR9+nQ6ceIEjR8/nqZNm0ZffPGF8u/GjBlD48aNoylTptCBAwfIz8+Pnn/++b/1jW8l0tLSqF27dvTee+/9o79r0aIFhYWF/f2zbt26W1TDzPg39b2T7duxY0c6cuQIbdiwgTZs2EBHjhyhzp072/7d7WrfpUuXUv/+/Wnw4MEUEBBATz/9NLVs2ZKuXLliaX/x4kV68cUX6emnn6aAgAD64osvqF+/frR8+fJbUr+bra+JM2fOZGrPypUr3/K6JiYm0hNPPEFTpkzxyP5Ot+0/ra+JO9G2RHCS77//Pu3du5c2b95MDoeDmjdvTomJieLf3PI2Zo3bhjFjxnCFChXEcsMw2M/Pj0eNGvX371JSUtjX15enTZt2O6rIzMyzZ89mX19fj2y7dOnCbdq0uaX1sYOn9b2T7Xvy5EkmIt67d+/fv9uzZw8TEZ8+fVr8u9vZvvXr1+fevXtn+l21atV40KBBlvaffvopV6tWLdPv3n33XW7QoMEtq2NG/NP6btu2jYmIo6Ojb0PtZBARr1y5Umlzp9s2Izyp793StiauX7/ORMTbt28XbW51G+ud621EbGwsFSlSRCy/ePEihYeHU/Pmzf/+Xd68ealJkya0e/fu21HFfwV/f38qUaIEValShXr27EnXr1+/01WyxJ1s3z179pCvry89+eSTf/+uQYMG5Ovra3vv29G+aWlpdOjQoUxtQ0TUvHlzsX579uxxs3/hhRfo4MGDlJ6e7vU6ZsS/qa+JWrVqUalSpahZs2a0bdu2W1nNf4072bY3g7ulbWNjY4mIlPPtrW5j7VxvEy5cuECTJ0+m3r17izbh4eFERFSyZMlMvy9ZsuTfZXcbWrZsSQsXLqStW7fS2LFj6cCBA/Tcc89Ramrqna6aG+5k+4aHh1OJEiXcfl+iRAnlvW9X+0ZGRpLT6fxHbRMeHm5p73A4KDIy0qv1y4p/U99SpUrRzz//TMuXL6cVK1ZQ1apVqVmzZrRjx45bWtd/gzvZtv8Gd1PbMjN99NFH9NRTT9Fjjz0m2t3qNtbO9R9i2LBhlh/uM/4cPHgw09+EhoZSixYtqF27dtSjRw/be2RNa8fM/zrV3b+p7z/Bm2++SS+99BI99thj1KpVK1q/fj2dPXuW/vjjj7uyvkR3rn2t7mF3b2+3rx3+adtY2Vv9/lbhn9S3atWq1LNnT6pduzY1bNiQfvrpJ3rppZfohx9+uB1V/ce40237T3A3tW3fvn3p2LFjtHjxYlvbW9nGOuXcP0Tfvn2pffv2SpuHHnro7/8ODQ2lZ599lho2bEg///yz8u/8/PyICCuqUqVK/f3769evu62wblV9bxalSpWi8uXL07lz5/7V39/K+t7J9j127Bhdu3bNrSwiIuIf3ftm21dCsWLFKGfOnG67PlXb+Pn5WdrnypWLihYt6tX6ZcW/qa8VGjRoQAsWLPB29W4ad7JtvYU70bYffPABrV69mnbs2GGbJvRWt7F2rv8QxYoVo2LFinlkGxISQs8++yzVqVOHZs+erUysS0RUoUIF8vPzo82bN1OtWrWICN+Wtm/fTqNHj77l9fUGoqKiKDg4OJPz+ie4lfW9k+3bsGFDio2Npf3791P9+vWJiGjfvn0UGxtLjRo18vh+N9u+EvLkyUN16tShzZs3U9u2bf/+/ebNm6lNmzaWf9OwYUNas2ZNpt9t2rSJ6tatS7lz5/Zq/bxRXysEBAR4vS29gTvZtt7C7WxbZqYPPviAVq5cSf7+/lShQgXbv7nlbeyVsCgNN4SEhHClSpX4ueee46tXr3JYWNjfPxlRtWpVXrFixd//P2rUKPb19eUVK1ZwYGAgd+jQgUuVKsVxcXG3vM6XL1/mgIAAHj58ON93330cEBDAAQEBHB8fb1nf+Ph4/vjjj3n37t188eJF3rZtGzds2JDLlClzV9aX+c62b4sWLbhGjRq8Z88e3rNnDz/++OP88ssvZ7K5k+27ZMkSzp07N8+cOZNPnjzJ/fv354IFC/KlS5eYmXnQoEHcuXPnv+2DgoK4QIECPGDAAD558iTPnDmTc+fOzcuWLfN63bxR3/Hjx/PKlSv57NmzfPz4cR40aBATES9fvvyW1zU+Pv7v/klEPG7cOA4ICODLly9b1vVOt+0/re+dbFtm5vfee499fX3Z398/01yblJT0t83tbmPtXG8RZs+ezURk+ZMRRMSzZ8/++/8Nw+ChQ4eyn58f582bl5955hkODAy8LXXu0qWLZX23bdtmWd+kpCRu3rw5Fy9enHPnzs3lypXjLl268JUrV+7K+jLf2faNioriTp06caFChbhQoULcqVMnN+rCnW7fH3/8kcuXL8958uTh2rVrZ6IydOnShZs0aZLJ3t/fn2vVqsV58uThhx56iKdOnXrL6naz9R09ejRXrFiR8+XLxw888AA/9dRT/Mcff9yWeppUlaw/Xbp0sawr851t239a3zvZtswszrUZx/7tbmOdck5DQ0NDQ8PL0NHCGhoaGhoaXoZ2rhoaGhoaGl6Gdq4aGhoaGhpehnauGhoaGhoaXoZ2rhoaGhoaGl6Gdq4aGhoaGhpehnauGhoaGhoaXoZ2rhoaGhoaGl6Gdq4aGhoaGhpehnauGhoaGhoaXoZ2rhoaGhoaGl6Gdq4aGhoiFi9eTPny5aOQkJC/f9ejRw+qUaMGxcbG3sGaaWjc3dDC/RoaGiKYmWrWrElPP/00TZkyhYYPH04zZsygvXv3UpkyZe509TQ07lroZOkaGhoifHx8aMSIEfT6669T6dKlaeLEifTXX39px6qhYQO9c9XQ0LBF7dq16cSJE7Rp0yZq0qTJna6OhsZdD/3NVUNDQ4mNGzfS6dOnyel0UsmSJe90dTQ0sgX0zlVDQ0PE4cOHqWnTpvTjjz/SkiVLqECBAvTbb7/d6WppaNz10N9cNTQ0LHHp0iV66aWXaNCgQdS5c2d65JFHqF69enTo0CGqU6fOna6ehsZdDb1z1dDQcMONGzeocePG9Mwzz9D06dP//n2bNm0oNTWVNmzYcAdrp6Fx90M7Vw0NDQ0NDS9DBzRpaGhoaGh4Gdq5amhoaGhoeBnauWpoaGhoaHgZ2rlqaGhoaGh4Gdq5amhoaGhoeBnauWpoaGhoaHgZ2rlqaGhoaGh4Gdq5amhoaGhoeBnauWpoaGhoaHgZ2rlqaGhoaGh4Gdq5amhoaGhoeBn/Bx7u+7hgyC9bAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -429,7 +429,6 @@ "\n", "accelerations = np.array([i[1][:] for i in gravity_results])\n", "acc_xy = np.delete(accelerations, 2, 1)\n", - "acc_xy = -1 * acc_xy\n", "\n", "X = computation_points[:, 0].reshape(len(VALUES), -1)\n", "Y = computation_points[:, 1].reshape(len(VALUES), -1)\n", @@ -472,8 +471,8 @@ "output_type": "stream", "text": [ "Potential: 1.6412193813901074e-07\n", - "Acceleration [Vx, Vy, Vz]: [-2.4104224440030084e-09, -3.9101840968470165e-08, -9.039023451764005e-09]\n", - "Second derivative tensor [Vxx, Vyy, Vzz, Vxy, Vxz, Vyz]: [-1.2243921287729791e-07, -1.1414944948899626e-06, -9.754414135835843e-07, -3.86381487022689e-08, 1.3548134599015306e-08, -2.6597490639550815e-08]\n" + "Acceleration [Vx, Vy, Vz]: [-2.4104224440030084e-09, -3.9101840968470205e-08, -9.039023451764084e-09]\n", + "Second derivative tensor [Vxx, Vyy, Vzz, Vxy, Vxz, Vyz]: [-1.2243921287729794e-07, -1.1414944948899624e-06, -9.75441413583584e-07, -3.8638148702268895e-08, 1.354813459901531e-08, -2.6597490639550805e-08]\n" ] } ], @@ -610,7 +609,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -622,7 +621,6 @@ "source": [ "accelerations = np.array([i[1][:] for i in gravity_results])\n", "acc_xy = np.delete(accelerations, 2, 1)\n", - "acc_xy = -1 * acc_xy\n", "\n", "mesh_plotting.plot_quiver(X, Y, acc_xy, \"Acceleration in $x$ and $y$ direction for $z=0$\")" ] @@ -766,7 +764,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABG8AAAOtCAYAAAA/1EjAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAB7CAAAewgFu0HU+AAEAAElEQVR4nOyddXQUVxvGn5W4uxMjSkJCiOHu7i5B2lKlVIC2eFugAhVairsWKMXdJYSQhAhxD3H3TXZ3vj/S7JdAdpO9syEB7u+cPWeTnblzZ/bunZln3vd5OQzDMKBQKBQKhUKhUCgUCoVCobRLuG3dAQqFQqFQKBQKhUKhUCgUinSoeEOhUCgUCoVCoVAoFAqF0o6h4g2FQqFQKBQKhUKhUCgUSjuGijcUCoVCoVAoFAqFQqFQKO0YKt5QKBQKhUKhUCgUCoVCobRjqHhDoVAoFAqFQqFQKBQKhdKOoeINhUKhUCgUCoVCoVAoFEo7hoo3FAqFQqFQKBQKhUKhUCjtGCreUCgUCoVCoVAoFAqFQqG0Y6h4Q6FQKBQKhUKhUCgUCoXSjqHiDYVCoVAoFAqFQqFQKBRKO4aKNxQKhUKhUCgUCoVCoVAo7Rgq3lAoFAqFQqFQKBQKhUKhtGOoeEOhUCgUCoVCoVAoFAqF0o6h4g2FQqFQKBQKhUKhUCgUSjuGijcUCoVCoVAoFAqFQqFQKO0YKt5QKBQKhUKhUCgUCoVCobRjqHhDoVAoFAqFQqFQKBQKhdKOoeINhUKhUCgUCoVCoVAoFEo7hoo3FAqFQqFQKBQKhUKhUCjtGCreUCgUCoVCoVAoFAqFQqG0Y6h4046xsbEBh8MBh8NBSkpKW3fnteBtPWZv636/zbyt33lL9vttPTYkvM3HqrCwEGvXroWfnx/09PTA4/Ekx2Lv3r1t3T1KOyclJUUyXl589e3bt62799ZDzxWvJ/Q7kc7bfGza87737dtX6rmgNfraZuLN1KlTG+3cpk2b2qorFAqFQqFQ3iJSUlLg6emJVatWISgoCMXFxRCLxW3dLQoLampqcODAAQwfPhzW1tZQVVWFmZkZunfvjp9++gn5+flt3UUAL1/od+jQAQKBoEXrLlu2TLLe3LlzW7ejFAqFQml38NtioyUlJfj3338b/W/fvn1YsmRJW3SH0k6xsbFBamoqACA5ORk2NjZt2yEKhUJpx9A5s+W8++67SE9PBwCoqalh4MCBsLCwAI/HAwC4uLi0ZfcochITE4Pp06cjNDS00f+zs7ORnZ2Nhw8f4scff8SePXswfPhwhW9fS0sLs2fPlvzt4ODQ4nXT09Oxbds2fPzxxwrvF4VCobwttNU10Lhx4+Dm5ib5e//+/SgrK2u17bWJeHP8+HFUV1c3+l94eDjCwsLg6enZFl2iUCgUCoXyFpCdnY0rV64AAFRUVPD06VO5brYp7YuMjAwMGDAAmZmZAAAOh4PevXujY8eOyM3NxbVr11BVVYXc3FyMHTsWFy9exIABAxTaB319fWzZsoV4/fXr12PBggVQV1dXYK8oFAqF0tp88sknjf4+d+7cmyfe7Nu3T/JeVVVVIuTs27ePijcUVrS3PMhXxdu63xRKU9DfQ8t5G49VSEiI5H2vXr2ocPOaM2PGDIlwY21tjTNnzqBz586Sz/Pz8zF16lRcv34dtbW1mDx5MhITE6Grq9tGPX6Z7OxsbNmyBV9++WVbd+Wt4m2c/9o79DuhNAUdF//nlXveJCYm4v79+3Ub53KxceNGyWeHDx+GUCh81V2iUCgUCoXyllBUVCR5b2Zm1oY9obDlwoULuHPnDgBAWVkZZ8+ebSTcAIChoSH+/fdf2NnZAagzqv7hhx9eeV+bws/PT/J+48aNKC0tbcPeUCgUCqW988rFm4ZRN3379sV7770HfX19AEBubi4uXrz4qrtEoVAoFArlLaG2tlbynsulRTdfZ/744w/J+zlz5sDd3b3J5TQ0NLB27VrJ39u2bWsXDwtnzZoFJycnAHWi0ubNm9u4RxQKhUJpz7zSqxaGYXDgwAHJ37NmzYKysjImT54s+V9DcaellJaW4vfff8eoUaNgY2MDTU1NqKiowNzcHAMGDMCaNWsQFRX1StsqKCjAzz//jEGDBsHKygqqqqrQ1dWFq6srPvjgAwQHB8u9ny1BEdttWAWhnqdPn+KTTz6Bm5sb9PX1weFwMHbs2JfWTU1NxdatWzFt2jS4ublBR0cHSkpKMDAwQOfOnbFo0SIEBgZK3XbD0pv1plMAYGtr22QJtlu3bjVan6SUXGBgID788EN06tQJenp6UFVVhaWlJYYOHYotW7agoqKi2TaaOmaxsbFYvHgxXFxcoKmpCW1tbXh4eGD58uUKr3rRkv1u6z7u2LFDsn0dHR0UFhbKXD4+Ph5GRkaSdT7//HPibbMdly/SmsdSJBJh586d6N+/P4yNjaGmpgY7OztMmTIFV69elWu/W8Lq1asl+9JwLm6OkydPStbr0qUL60o9itxv0t9DS+e5ehQ9z5Ocf171nPm6zpe3bt2SbDMgIEDy/3379r10jFavXi21ndbaf3nHXnMEBgZKLV0q66WiotJI3GrPlJeX4/r165K/G36vTTFx4kRoaWkBqBNK6iN22hIej9dovG3atKnZc6O8vK6/WWm86nMF0PT+P3nyBAsXLoSjoyM0NDSgra2NXr16Yf/+/WAY5qU2rl+/jgkTJsDe3h6qqqowNTXFuHHjcPfuXbn6rKjzTmt9p+np6VizZg169+4NExMTqKioQEtLC7a2tvD19UVAQACOHDkitb22OCe15vFQ9PWnomh47dBSY9+2vNeQtm2210AA+zH7ymFeITdv3mQAMAAYNTU1prS0lGEYhrl//77k/8rKykxBQUGL29y6dSujp6cnWV/W6+LFi6+krS1btjA6Ojoy1+dwOMy8efMYgUAgtR1ra2vJ8snJyc0eC0Vtt+HyDMMwq1atYng83kttjRkzptF6n3/+OcPhcFp0/KZNm8ZUVFS8tO3k5OQWrV//unnzJvExKy8vZ6ZMmdLsNszMzJgLFy7IbOvFY7Z161ZGRUVFapsGBgbM48ePZbYpDy3Z77buo1AoZJycnCTtL1u2TOqy2dnZjJ2dnWTZ6dOnM2KxmGi7ihiXL9JaxzIjI4Pp2rWrzD4uWLCAEQgEcs8P0rh8+bKkHWtr6xatU1VVxdja2krWu3XrFvH2GUbx+03ye2jpPFePoubbekjPP69qznzd58uG1x/NvVatWvVK91/esdcStm3bJte4qH95enoSb/NV03Du0tDQYGpra5tdZ9CgQZJ1vv76a1bbb/jba+ncyTAM06dPH8l6W7duZcRiMePu7i7539KlS6Wuu3TpUslyc+bMkbmd1/032xRtca5oav+/++67Jn+z9a/Zs2dLrlnKy8uZUaNGSV2Ww+EwmzZtatH+K/K80xrf6V9//cWoqam1aK7p0aNHk220xTmptY6Hoq8/FXXdxzBk81db3mtI2zbbayBFjFmS48SGV2pY3DCqZuzYsZInIN27d0fHjh2RkJCAmpoaHD16FO+//36z7X388cf4/fffJX/zeDz4+PjAwcEBqqqqyMvLQ1hYmEShe7HCVWu09emnn+KXX36R/G1gYAB/f3+Ym5ujuroaoaGhiIyMBMMw2L17NzIzM3H+/HnWoduttd0ff/wRa9asAQDY29vD19cX6urqSElJgZKSUqNl09PTwTAMOBwOnJyc4OTkBAMDAygpKaGgoAChoaFITEwEABw5cgQlJSU4d+5cI3VWW1sbH3zwAYDGpdZmz54tGS8NsbCwkP9gAaisrET//v0RFBQk+Z+5uTl69eoFTU1NJCQk4N69exCJRMjKysLo0aNx5MgRTJw4sdm29+7di0WLFgEAnJyc4O3tDTU1NcTExOD+/ftgGAYFBQUYNWoUoqOj28Q0sS36yOPxsG7dOkl0x++//44lS5bAyMio0XLl5eUYMWIEkpKSAAADBw7E3r17G40TeVDEuJSFoo5lYWEhBgwYgNjYWMn/HBwc4OvrCyUlJYSFhSEsLAw7d+6EpqYm0bFoCj8/P3A4HDAMg9TUVOTm5sLY2FjmOj///DOSk5MB1D3N7tOnD/H222q/GyLPPAcofr5lc/55FXPmmzBfWlhYSI5TTEyMJGLD2dn5pcpDvr6+r2z/5R17LcXY2Fiyv7KoqqrCvn37IBKJAABdu3Yl3uarJjo6WvLe3d0dfH7zl7ReXl6S6IyG67clHA4H69atk0Ra/f777/j0009hYmJC3Oab8Jt9kfZwrgCArVu34uuvvwZQ93txd3cHwzC4e/eu5Lpl//79cHJywrJlyzBhwgRcvnwZysrK6NmzJ+zs7FBaWorr16+joKAADMNgyZIl8PHxQc+ePaVutzXvLxTxnZ4+fRrvvfee5G9tbW1069YNlpaW4PP5KCkpQVxcHCIjI1FTU9OSQy2V1hzfijoeQOtff7Z3XsVcweYa6FWOWYWicDlIChUVFYyWlpZEiTp//nyjz1evXi35zM/Pr9n2tm7d2kgNmzx5MpOent7kshEREczHH3/MXL58uVXb2rVrl6QNTU1NZuvWrU0q3zdu3GAsLCwky27cuLHJbbVUuVP0dhseCz6fz+jo6DD//PPPS8tVV1c3+vuHH35g9uzZw+Tl5Unt6507d5iOHTtK2j9w4IDUZUmUy5aus2jRIslyPB6P2bRpEyMSiRotExcX1+gJj7a2NpOUlNRkew2PmYqKCmNkZNRkdNbt27cZbW1tybJr1qxp0X41h7xqeFv0kWEYRiwWM97e3pK2P//880af19bWMkOHDpV83qVLF0mEHimKHpcM0zrHcs6cOZLlVFVVmYMHD760zNWrVxlDQ0MGAKOkpKQwZb9Tp06Sts6dOydz2YyMDEZDQ0PST7bbbo39lvf3IM88p+j5VpHnstaaM9+0+XLPnj2SNpuLXmCY1t1/ecaeoqmsrGQGDBgg6YunpyeTn5/fonXPnz/PfPDBBwp9BQYGytX/ht/LlClTWrTOH3/8IVnH1dVVru29iKIib+rx8fGR/P+TTz5pct2WRt68ab9Zhmm7cwXDNN5/ZWVlxsLCgrl//36jZYRCIfP5559LltPV1ZXc2/Tt25dJTU1ttHxxcTHTr18/yfJ9+/aVun1Fn3de3CdFfKceHh6SZT788EOpUSRlZWXM8ePHpUaYtcU5qTWOB8O0j/siabyKyBtFzhWKjKSrR1Fjlm0/5OWViTcHDhyQ7IixsfFL4a2JiYmNvvDo6GipbRUWFjYSgt577z3ifimqrdLSUkZXV1cykdy+fVvm8s+ePWNUVVUZoC5krKkB05IvvzW22/B74HA4zbYpL8nJyZI++Pr6Sl2utW5EEhISGC6XK1nut99+k9peYWEhY2NjI1k2ICCgyeVenKyePn0qtc0tW7ZIlnV2dm7RfjUHyYT6qvtYz5UrVyRtq6mpMVlZWZLPAgICJJ/Z2toy2dnZCt22LFo6LhlG8ccyJiamUZtNXZTWc//+/UbjVxEnhwULFkjaWrlypcxlZ8yYIVn2q6++YrXd1tpveX8PLZ3nFD3fKvJcxjCtM2e+ifOlPOJNa+9/a5xjW0JFRUWjG0cvLy+5UtZXrVrVaD8U8dqzZ49c+zB58mTJuh9//HGL1jl58qRkHVNTU7m29yKKFm8uXbrU6HfRlIjbEvHmTfzNtuW5gmEa77+amhrz7NmzJpcTiUSMi4tLo+U7derEVFVVNbl8Wloaw+fzJXNBZmbmS8u0xnX+i/vE9jstKyuTfG5lZUWc5s4wbXNOYpi2HeOteV8ka5vyzl9tea+haPFGkWOWTT9IeGXizcCBAyU7Iu2JQo8ePSTLLF++XGpbGzZsaDTg2DydUlRbv/zyi6Sd+fPnt2idd999V7LOyZMnX/q8JV9+a2y34Q9v8uTJLWpTXoYNGyY5WZWUlDS5TGuJNw0vfjp37tzsD/bYsWONJqLi4uKXlml4zD766COZ7ZWWljY6WUvbf3mQd0Jtiz42pH///i/NB998843kf0ZGRkxcXJxCt9kSWjIuGUbxx/KLL76QtOfv799sP2fNmtWiC9OW0vCp3tChQ6Uu9+DBA0n+tpmZGVNWVsZqu6213/L+Hlo6zyl6vlXkuYxhWmfOfBPnS3nEm9be/9Y6x8qivLyc6du3r6QPXbt2ZQoLC+Vqoz2IN8OHD5es29InohcuXJCso6mpKdf2XkTR4g3DMEyvXr0kn73zzjsvrdsS8eZN/M225bmCYRrv/6effipz2ytXrmy0/JkzZ2Qu37t3b8myZ8+efenz1rjOf3Gf2H6nz58/l7TF1jerLc5JDNP2Y7y17ouk8SrEG0UeR0WLN4ocs2z6QcIrqTaVkZGBGzduSP6eOXNmk8vNmjVL8v7AgQNSq5dcunRJ8n7hwoVQUVEh7pui2rpw4YLk/dSpU1u0Tv/+/SXv79271y6329I2XyQtLQ0nTpzA999/jy+//BIfffQRPvzwQ8mr3i+DYRg8ffqUaBukNByLAQEBzeaWjhs3TlLOXiAQ4OHDhzKXnzRpkszPtbS0YG9vD6Bu/9PS0lrSbYXS1n1cv3695P22bduwZs0afPvttwDqSrqeP38eDg4OCt0m0DrjUhHH8ubNm5L3DedBacyePbtFfWsp3bp1k7x//Phxk8swDINPPvlEUkVjw4YNrH0F2nq/62npPKfo+VaR57LW4m2fL1t7/0nPsaRUVFRg+PDhkoobPj4+uHbtGvT09ORqZ/Xq1WDqHgAq7DV37ly5+tDQ+0lZWblF6zT8jVVVVcm1vVdB/XkQAPbs2SPxUJGHN/E3217OFQAwYcIEmZ+7ublJ3qupqWHYsGEtXr7+GqQhr+L+gu13amRkBDU1NQBAREREq1Zya+3xDbTOGG/P90WtRXs+v7/KMatoXolhcUMhxtnZGd7e3k0uN3nyZHzyyScQCAQSwWfgwIEvLffo0SPJ+379+rHqm6LaajgZ7N+/H6dPn252nYyMDMn79PT0drldec0LHz58iGXLluHu3btNlkpsildZeo1hGISFhUn+7tGjR7PrKCkpwdfXV3KjFRISgqFDh0pd3t3dvdk2DQwMJO9LSkqaXV7RtHUffX19MW7cOPzzzz+orq6WlErl8/n4+++/4ePjo9Dttea4ZHssGYZBeHi45G8/P79m2/P19ZWYDCsCZ2dn6Orqori4GAUFBUhKSoKdnV2jZfbu3SsRdnx8fFp0AS2L9rDf9bR0nlP0fKvIc1lr8LbPl69i/1+lQXB5eTmGDRsmuZnz9fXFlStXoKOj88r6oEhUVVUl71tqJikQCCTv6y/c2xO9e/fGoEGDcPXqVdTW1mLNmjWNin00x5v4m21P5woA6NSpk8zPGwqhjo6OzRppN1y+tLT0pc9fxf0F2+9USUkJ48aNw+HDhyESiTBw4EBMnDhRUtCg4bpseBXjG1DsGG/v90WtSXs+v7+qMdsavBLxZv/+/ZL3si749fT0MHLkSJw8eRJAXXWqF8Wb0tLSRk9LXrzBkAdFtVVeXi5xtwbqxCp5KSoqapfbfbESkCx2796NBQsWyH2ybLgPrU1JSQlqa2slf1tbW7doPRsbG8n75ibVllwIN6wi0rA/r4r20MfvvvsOZ86ckVQ5AYCdO3c2+5RKXlp7XLI9liUlJY1uPDp06NBse9ra2tDR0UFxcXGL+tgcHA4H/v7+kouboKCgRvNhWVkZvvrqK8myv/76K+tqCO1hv+tpyTyn6PlWkeey1uJtny9fxf7Lc45lQ1lZGYYNG4b79+8DAPz9/XH58mVoa2u/ku23Bg0j/1oaRdNwudasSMSGb7/9VlIR6+DBg1i2bBlcXFxatO7r8Jt99OhRs/PnrFmzJCJNezpXAM3vf0OxpiXHquHyLx6rV3V/oYh5ePPmzQgJCUFMTAxqa2tx5MgRHDlyBBwOB87OzujVqxcGDx6MESNGNBJe5eFVjG9Aceel1+G+qDVpz+d34NWM2dag1dOmHj16hJiYGAB1F/0zZsyQuXxDcefUqVMvDeAX/2Zz8lVUW4pQCoVCYbvcbkufTEVHR+Pdd9+VTFCdO3fGb7/9hsePHyM3NxdVVVWNwqPnzJkjWVdaelxrUF5e3uhvDQ2NFq3XcLnmJtXXocRfe+hjSEhIo+/e09Oz0bhQBK9iXLI9li+OSXV19Rat19Kx21JkpU6tW7cO2dnZAIDp06c3WpaU9rLfQMvmOUXPt4o8l7UWb/t8+Sr2/1VEf5SWlmLIkCES4aZbt26vvXADNH5im5OT06J16ucxAJJUivaGr68vRo8eDaDuPLRq1aoWr/s6/Gajo6Pxxx9/yHw1LOPens4VgHz7r4iHHGxpyf2FIuZhY2NjPH78GKtXr4a5ubnk/wzDIDo6Gtu3b8fEiRNhbm6ODRs2NHpw11JexfgGFHM8Xpf7otakPZ/fgVczZluDVo+8aRjuyTBMI/WzOSorK3HixAkEBARI/vdizfby8nLii15FtfXi5FFcXPxKwpDbartNsXnzZskJYvjw4Th9+nQjNfVF2kpVfvH7raioaNHkX1FRIXn/4rihyM/Vq1cREBDQ6GlEWFgYrl271mSqJCmvw7h8cUxWVlbKPSYVQUNBJigoSPI+ISEBv/76K4C6i+YNGzYoZHvtZb9biqLnW0Wey1qLt32+fBP2v164CQwMBFCXZnDx4kXW/bpw4UIjLw5F0DDaoiU4OTlJ3qemprZonYaeCs7Ozi3v3Ctm3bp1OHv2LBiGwYkTJxAWFgZPT89m13sTxuyLvG7nCkXSnq7zW4KmpiZWrVqFFStWICQkBHfu3MHdu3dx7949ScRLUVERli9fjsDAQPzzzz9y3eC/TuP7dbj+lJc3RVRqSGuP2dagVcWbmpoaHDt2jFUb+/fvbyTeaGtrQ01NTRL6mpycDFNTU6K2FdWWrq4uVFRUJLnU8fHxUn19FElbbbcprl+/Lnm/bt06mRMU0PILLUWjo6MDJSUlSWheWloajI2Nm12vYX8NDQ1brX9vA6GhoZgwYYLkO/Dy8kJISAgAYPny5QoVb16HcamjowNlZWVJWHhaWlqzqRSlpaUKzw328/MDl8uFWCxGSEgIRCIReDwelixZIunb0qVLYWlpqZDttZf9bimKnm8VeS5rLd72+fJ13/+SkhIMHjxYIsb27NkTFy9eVIhIGBQUhD/++IN1Ow3x9vaWS7xpmEoUEREBoVDYrL9I/bnmxfXbG507d8akSZNw/PhxMAyDFStW4OzZs82u9zqM2blz58plTv26nSsUSXu6zpcHLpcLb29veHt7Y8mSJRCLxXj48CF++ukniWfPv//+i5MnT2LixIktbvd1GN/1tPfrz4b9aWn2x5vwm5JGa43ZVulrazZ+9uxZFBYWAqgbJH5+fi16NTTwu337NlJSUhq12/Dk3tB1nARFteXr6yt5f/nyZVZ9eh22+yKZmZmS982ZuZWUlDQyn5NGayibHA6n0dOrBw8eNLuOUChsFIng5eWl8H69LSQnJ2PYsGGSJwyfffYZrl27JnmSFBwcLPG8UgStMS4VDYfDQefOnSV/1z8hl0VQUJDCjRi1tbXh6uoKoO7JZlRUFK5cuSK5YbCyssIXX3yhsO21l/2WB0XPt4o8lwGKnzPf9vnydd7/4uJiDBo0SNKX3r1749KlS+0uuosN3bt3l1SPqqioQHBwsMzlBQJBo3mmYUWe9sjatWvB4/EAAOfOnWtkcC6N13nMSuN1PFcokvZync8GLpeLHj164NSpUxgyZIjk/2fOnJGrnddpfLf368+GEUhFRUXN/l7S0tKaNNRuTyjyGkhRY7Y1aFXxpmHK1MiRIxEYGNiiV3BwsKRMMMMwLxl0NTQ03bFjR6PqAfKiqLZGjhwpef/XX381KmHZmrTVdl+Ey/3/UKqsrJS57M6dO1tkStXQHEqRJlYNL9j27dvX7IR15swZFBQUSPqkCL+Pt5H8/HwMGTJE4k0wdepU/Pjjj9DT08OSJUsky33zzTcKyyttjXHZGjSsNHTw4MFml5en+og8NBzbDx48wOLFiyV///DDDwr352gv+91SFD3fKvJcBrTOnPm2z5ev4/4XFRVh4MCBEu+qvn374sKFCwr1AGkPpcI1NTUxYMAAyd979+6VuXxDH0U9PT307t1b3t1+pTg5OWHmzJmSv7/55psWrfc6jtnmeN3OFYqkvVznKwIOh4MRI0ZI/m6pV1VDXpfx3d6vP7W1tSW+X5WVlYiLi5O5/PHjx19Ft1jRGtdAihiziqbVxJu8vDxcvHhR8ndzRsUv0nD5htWqAGDhwoWSp0epqamNbjDkRVFtvfvuu9DV1QVQV6Lv/fffl6skHOnNaltt90UaVkr5999/pS4XHx+PNWvWtKjNhmaEz58/J+/cCyxcuFAyqYaEhGD79u1Sly0pKcGXX34p+XvatGntOt+4vVJRUYERI0YgPj4eQN2F2L59+yQq+aeffir5vmNiYhR24dUa47I1mDdvnuR9YGAgDh06JHXZBw8e4PDhw63Sj4YXNStWrJCYRvbo0QNTp05V+Pbay363FEXPt4o8lwGtM2e+7fPl67b/hYWFGDhwIJ48eQKgbq49f/58q5m3tjXvv/++5P2ePXsQFRXV5HKVlZVYuXKl5O9333232RSr9sCqVask6Q3Xrl3D7du3m13ndRuzLeF1O1cokvZynS+LsrKyRhXBZNHQd4qk2t7rMr5fh+vPhlFdssTvjIwMrF+//hX0iB3yXAO9yjGrcJhWYvPmzQwABgCjra3NVFVVybV+fHy8ZH0AzL179xp9/scffzT6fPLkyUx6enqTbUVGRjIff/wxc/ny5SY/V1Rbe/bsadTOiBEjmOjo6CbbEYvFzIMHD5gPPviAUVdXZ8rKyl5axtraWtJWcnJyk+20xnYbttVSli1bJllHT0+PuXTp0kvLXLt2jTE3N2cAMBoaGpLl9+zZ02Sb7733nmSZRYsWtagfLT1mixYtkizH5/OZLVu2MCKRqNEyCQkJjK+vb6NxnJSU1GR78h6zPn36SJa/efNmi9aRRUv2u636WFtbywwfPlzSlru7O1NcXPzSchs2bJAsY2VlxVRXVxNvs57WGJcM0zrHctasWZJlVFVVmYMHDzbZV0NDQwYAo6Sk1KKxLg/R0dGN9g0Aw+FwmODgYIW03xStsd+t8XuoR9HzrSLPZa01Z75p82XD73DOnDnNLt/W+99S8vPzGU9PT0nbAwYMYCorKxW6jfZIr169JPtsY2PDhIeHN/o8Pz+fGTRokGQZfX19pqioiPV2k5OTJW1aW1u3eL2G43nr1q3NLt/wd93wJWvstvWYVfRvlmHa7lzBMPLt/82bNyXL9unTp9nlV61aJVl+1apVTS6j6POOvPvEMLK/05s3bzKmpqbMypUrmcjIyCbXFwqFzMGDBxkVFRVJO4cOHXppubY4JzGM4sd4a1x/tnS8tpT9+/dL2lNWVmZOnDjx0jIPHz5k7OzsGA6H06LfVGvNFS3Zd3mugRQ5Zkn6yoZWE28aXkAEBAQQtdHwR7dw4cKXPm/44wXA8Hg8xt/fn5k9ezbzzjvvMOPGjWNsbGwkn//zzz9St6WotlasWNGoHQ6Hw7i7uzPTpk1j3n33XWbmzJlMv379GF1d3UbLsRFvFL1dkgvLnJwcxsjIqNG6Xl5ezMyZM5lZs2YxnTp1kvx/yJAhjU7C0iapq1evNmrPz8+PWbRoEfPZZ59JXgkJCUTHrKKigvHx8WnUvqWlJTN16lRmwYIFTL9+/Rgej9fo5PD3339Lba+tL2zas3gTEBAgacfKyorJyMhocrny8nLG2NhYsuymTZuIt1lPa4xLhmmdY5mfn8907NixUdsODg7MrFmzmLlz5zJdunSR/H/x4sWtcnIQi8WMnp5eoz6Qzt8tpTX2uzXFG4ZR7HzLMIo7/7TWnPmmzZfyijdtvf8tZf78+Y3G0Lx585gPPvigRa/CwkKF9uVVkp6ezpiZmUn2ncvlMv369WPmz5/PjB49mlFXV2/03Vy7dk0h231V4k1GRgajqqraaNw0N3bbesy2hnjTVucKhml78YZhFH/eUeR32nCfATAmJibM0KFDmblz5zILFixgRo4c2eg3CoDp1avXS4ILw7TNOUnRx4NhWuf6U9HXfbW1tYyHh8dLfZw3bx4zZ86cRr+p1atXt+m9Rku2Lc81kCLHLElf2dAq4s3Tp08b7SzpifK3336TtKGjo9Nk9M4vv/zCaGtrv3RSe/HF4XCkPq1UdFvHjh2TKKktefn6+jYZZSDvl6+o7cr7w6vnwYMHkice0l5jx45liouLmTlz5jQ7STEMw8ycOVNmey/+0OU5ZmVlZczkyZObPU5mZmbMhQsXZLbVWpNVS2mv4s3XX38taUNPT4+JioqSufymTZskyxsaGjKlpaVE221Ia4zL1jqWaWlpjU6WTb0CAgIYgUDQaieHYcOGSdrV0tJisrKyFNa2NBS9360t3jCM4ubbehR1/mmtOfNNmi/lFW8Ypm33v6W8eBHe0peamhojFAoV2pdXTXR0dKOHhk29jIyMmHPnzilsm69KvGEYhlm8ePFL+9Pc2H2TfrP1tMW5gmHah3jDMIo97yjyOw0MDGT4fH6L+zVx4kSp13dtcU5S9PGoR9HXn61x3ZeUlMTY2dlJ7R+Hw2G+/vprRiwWt3vxhmFafg2kyDFL2ldSWkW8WbJkSaMfTUtUqqbIyclpdGCPHDnS5HL5+fnMTz/9xAwaNIixsLBgVFRUGBUVFcbCwoIZOHAgs27dOiYuLq5F21RUW9XV1czevXuZadOmMR07dmR0dHQYHo/HaGtrMy4uLsz48eOZzZs3M7GxsVLbIPnyFbFdeX94DcnJyWGWL1/OuLm5Merq6oy6ujpjb2/PTJ48mTlz5oxkuZbeJIvFYubIkSPMyJEjGUtLy5eePrERb+p58OABs2jRIsbFxYXR0dFhlJWVGXNzc2bw4MHMb7/9xpSXlzfbRltf2LRH8ebPP/+UrK+iosLcuXOn2XWqqqoaXZg0dyHTUhQ9LlvzWNbW1jLbt29n+vTpwxgYGDAqKiqMjY0NM2HChEYXIK11cujXr5+k3Q0bNiis3eZQ5H6/CvGGYRQz3zZEEeef1p4z34T5kkS8qact9r8l1NTUMMrKyi2+EG348vb2Vlg/2hKBQMDs27ePGTp0KGNlZcUoKyszxsbGjL+/P7Nx40YmLy9Podt7leJNTk5Oo7QKecbum/CbbcirPlcwTPsRbxhGcecdRX+nhYWFzPHjx5mPP/6Y6dWrF2Nubs6oqKgwfD6f0dfXZ3x8fJiPPvqIefTokczttMU5iWFab4wr8vqzta77ysvLmfXr1zM+Pj6Mjo4Oo6qqytjZ2TFz5sxhAgMD5dp+ax3Hlu67PNdAihqzpH0lhcMwDAMKhUKhvPXcvHlTUsnBzs4Oz549k5TipVAoFMr/SUlJga2tLQDA2toaKSkpbdshCoVCobQ5NjY2SE1NBQAkJyfDxsZGoe23aqlwCoVCobweMAzTqCrDzz//TIUbCoVCoVAoFAqlnUDFGwqFQqHgzz//RHBwMABg6NChGDt2bNt2iEKhUF4TUlNTweFwJK++ffu2dZcoFAqF8gro27dvo/m/PuqmtaDiDYVCobzlXLp0CZ999hkAQFNTE3/88Ucb94hCoVAoFAqFQqE0hN/WHaBQKBTKq+Xx48c4duwYampqEBERgVu3bkk+++2332BnZ9d2naNQKJTXAG1tbXzwwQdNfubg4PCKe0OhUCiUtmDcuHFwc3Nr8jNtbW2Fb48aFlMoFMpbxtKlS/HDDz+89P9ly5Zh/fr1bdAjCoVCoVAoFAqFIgsaeUOhUChvGSEhIQAAHo8Hc3NzeHh44KOPPsLgwYPbuGcUCoVCoVAoFAqlKWjkDYVCoVAoFAqFQqFQKBRKO4YaFlMoFAqFQqFQKBQKhUKhtGOoeEOhUCgUCoVCoVAoFAqF0o6h4g2FQqFQKBQKhUKhUCgUSjuGijcUCoVCoVAoFAqFQqFQKO0YKt5QKBQKhUKhUCgUCoVCobRjqHhDoVAoFAqFQqFQKBQKhdKO4bd1BygURVBdXY2IiAgAgJGREfh8OrQpFAqFQqFQKJS3EaFQiLy8PACAu7s7VFVV27hHFAp76B0u5Y0gIiICvr6+bd0NCoVCoVAoFAqF0o4ICgqCj49PW3eDQmENTZuiUCgUCoVCoVAoFAqFQmnH0MgbyhuBkZGR5H1QUBDMzMyaXE4sZrD23DMk5Jbhjxle0FFTJtrew6QCLD8Zjh8mesDXVp+ojfLqWrx38AncLHSwdKgzOBwOUTu77yXjbHgmds/1gZ462f6kFFRg/t7HWDWqE3o7GjW/QhOIxQyWHA+Dpgof68a6Ee/Ptehs/HgpFocX+sNAU4WojbLqWkzbHogP+nXEMPemx0JQciGWnwrH0Xf8YaRFFkorEIowY8cjTPfvgPFdLInaAIDtd5IQklqErTO9mjxuDMNg9u4gjHA3w1TfDsTbOfY4DZcis7F7ro/U7+eDQyHwsdXD3O62xNu5GJGF/Q9TcHihP/E4qK4VYfivd/DnjK5wNtMm7sv356OhrsLD4oGOxG2EpRdh+ckIXPikF/H+AMDErQ/w2WBHdLM3JG5j971kpBRUYO0YN+I2skuqMP7PB7j1RT8o88mf4XxwKATD3Ewx0sOcuI3z4Vm4EJGFP2Z4SV3myxNP4W2th8k+TY99hmHQbf0N/Pthd5hoqzW5zM2YXOx/mII9AdIjNNeciUIHA3UE9CAf+4+SC/DT5Tj8/V434jYAYMRvd7F+vDs6W+oSt7HlRjzKBUIsG+ZC3EZibjkW7H+Mq5/2AZ/X9FjZdTcZyfnl+HacO/F2nhdVYer2h7j4SS9oqioRt7NwfzCGuplighf5fHwyJAPnw7Owey75U/qiCgHG/PEAewN8YGekSdzOlyeewlJPDR8PIJ+/rkfn4Jdrcfj7ve5QVeIRtVFWXYtJfz3EV8NdiK8RAODbc89QWl2LHyZ6ELdRf+4+uMAPZjpN/96bo1IgxKxdQZjgZYHp/tbEffnlWhxC0oqwfZY38bENzyjGx0dCsXmKJ7p00CNqo6pGiHcPPoGLmTaWsbie3HU3GWeePsfOOd7E10UxWaX48HAIFg90JD43VNWI8OnxMCjzuPhhYmfiY5uVlSWJym94n0ChvM5Q8YbyRtDQ48bMzAyWltIv3P561wLvHwrBV1eycGiBHzRV5P8ZTLK0BF/LACtPR+HIO9Zws9Ah6vehxaYY+8d9XEquxcLedkRtrJhigWxRCL6/lYv9832hJOUCWxaWlsDPAVr46lQEeng4wtpAg6gvW981xrBf7+JhDjDZm+ziea6lJYLzuPj9URF2zO5KfBGyYbYqlp+KwITeHtDXeFnUsrS0xM0MEXaFlmLL9I5E2wCANdNV8NWpCMwdZAJtwpuOL8aboNcPN5FUpYo+Ui6Ml09UwtenI/HhKDPiC5n3jEyxP/wGMmrU0c3eoMllPhjJx8p/o7B0gjnRWAKAmcZm+O1RIXLFmuhqTXYxCgAjurkjKI+DgT7kN2Jje/Lx3YVoWFhYEI8lY1NzfHHhOSqVdOFkqkXcF183B2TWasicn5pvg4+H1+NZtWFmzkBZJx58LUNYGqgTt2NplQuulg6rvlgUcsFNqZHZhrZBDrQN9aQuIxIz4GsbwtLSCibaTd9waOdzoGNYLbuvmtmwsjRgtT9BuYCVlSWrNioEQpRwteHn5kAsYAPA89rnGOxuyqovt5+nwqeTA2yspYvGMWUZGOHjymo711KT0d3DEc4dyYWzzOIqxJcr40D/LjBkcdyun07BnEFerPbn35sJ6N7ZEb27OBO3EZdThif5XGye113quG4OkZjB/mMJ+Gxcd3S0JRcp1l+MhrujHab18ySeR4NTCnEnU4wrn/aDpR7ZvFNZI8SmQ3H4ZnJP+HSyIWoDAJafCoetjRU+H+8PLpfwQdOzHFxKrsXZj4bC1pDsmim3rBpr9sfgq0k9MYrwgYlYzOCDwyEwMjHH5gA/YkH+xJMMnIitxInFI4jPc8n5FVh6KRpLxnXDO73tidqorhVh4f5gqOsZY1+AL9SUya53XoR6YVLeFGjaFOWtg8/j4vfpXaCtysf8vY9RXSsiamdcF0t8NKAj5u4JQmpBBVEbFrpq2D3HB79ci8OlyGyiNjgcDn6c6IGiyhp8dz6aqA0AGNnZHOO9LLHoYAjxMTHSUsHPkz2w5kwUEvPKifuybowbwtKLcSrkOXEbQ93M4GOjj2/PPZO6zIoRLrgdm4e78XnE2xnsagIHE038cSOBuA0tVSW839ceP16OgVjMNLnMIFcTGGup4NCjNOLtaKjwMcvfGtvvJEpdZoCLCZT5XFwkHI8AoKbMw1hPCxx7TN5XABjlYYZzTzOlHpOW0NPBENkl1azGozKfCx9bfTxIzCduAwA8rXQRll7Eqg1HE00k5pVDKBITt8HjcmCuq4aMokpWfdFXV0ZBRQ2rNlT5PFTXyt4XHo8DMSN9DNR/JuueUiAUQ0VJ9iVPhUAIDQIxvyG5ZQIYa5ELBwCQWlAJLRV+k6KzPERnlcKVRdQaADxJKYK3DAG2ulaEJ2lFUsXglnI9Jhf9nU1YtXE+PAvd7A1YCTfRWaWIyynDKBbRZLUiMQ48TMXc7jbEbQDA1luJGO9lSSzcAMDp0OeoEYkx2duKuI30wkrse5CCr0e4EAs3QpEY35yOxAf9OhILNwDw4+VYmOuoYYYfuRB17VkOzoVn4adJHsTCTWZxFT4/8RTfjXMjFm5qRWJ8eDgU/nYGCOhhQ9QGAPxyPR6RmSXYOrMrsXBzPyEfK05H4q+ZXYmFm5zSasza9QgTvS2JhZu6YxKCsmohds/1UZhwQ6G8SVDxhvJWosLnYdusrhCJGSw6+AQ1QrIboXd622OspwVm7w5CXpmAqA13Sx1snuKJz46H4Wl6MVEbGip87JjtjX/DnrO6Yf5quAtUlbhYfSaKuI0+jkaY7tcBHx8JhUBIJgLpaShjw3h3rD4bhcziKuK+rB3jhqvPcnAnrmlxxlhbFZ8NdsSK05HEghWHw8GKka7Y+yCFWMQDgNndbJBXJsClqKZFEw6Hg8UDHbH1ViKqasj6CgBzutvgQWIBYrPLmvycx+VgTncb7LmfTLwNAJjiY4WzT7NQVl1L3EbPjkao/O/mkBR1ZT56dDTEtehc4jYAoLu9AR4kFrBqw7ODLsLSi8HIECKaoz4qLrWQnfBiqaeGjCLy3xYA6Gsoo4iteKPEa/a3x+NwIJQh4NWLN1wZN5Y1QjFU+LJvBMoFQqJIzIbklgpgTJhuUE9qQQWsDdVZpejlllWjoKIGziwixQAgOLUIXjLEm9C0YuioKcGO8AYWqDvuj5IKMcDZmLgNADgXnomRnZtOk20px4PTMdzdjDiKEgAuR2VDmc9FPxb7k15YifMRWXivD1lELlA35n+5HofFAxxZpUduuBSDUZ3NiSOMAWDfw1TUisRY2It8f56kFuJoUDo2THAnFl3yywVYdioca8d0IhaRhCIxPjkaisGuJhjjaUHUBgBsvBiD0qparB/vTvxbP/s0E3vuJWPXHB9isTcmuxTvHXyCb8e6oUdHspTe4soazN4VhO72Blg2lCzaTCgSY/HRMGQWV2NfgC/ruZhCeVOh4g3lrUVdmY/dAT7IKxfg02NhEBE+3f9quAs8rXQRsDcI5QIhURuDO5ni00GOWLA/GM8JxQorfXX8McMLq888w5PUQqI2lPlcbJnuhSvPcvB3cDpRGwDwxRBncDjAj5diidsY6GqCoZ1MsfRkOPHNrqmOKr4c6oSvT0egsqbp72ZWNxtoqvLx123p0SjN0clcB+O6WGD9hRjiNlSVePh4gAN+vhIrNapioIsxTHVUcOhRKvF2jLRUMN7LAtvvJEldZrK3JeJzyhHKQjRxs9BBR2NNnH2aRdyGMp+LYW5mOBOWSdwGAAxwMcb16BxWbfSwN0RgUgHxPAEArmbaKBcIkV5ILprwuBx0NNJEfE7T4ltLqRNvWEbeaCijkKV4o6bMbVa84XM5EImkH/f66UGWeCMQiqHSzA1suUAITVW2kTfVMNZmF3mTXFABG8LU1XqeZZbCxkCDVSRRblk10osqZYo3gUkF6GZnwEpouhefD0t9NdiwEIBSCyrwLKsUQzqZErchEIrwT+hzTGERpQIAe++nYHY3a/AIBQYA2HYnEUM7mRKnMAN1QpQyj4uxXcgFhiephbgZk4vPhzgRt5FTWo3NV+OwbowbsYhUXSvClyfC8clAB2IPIYZhsPxUBPxsDTCWhejyy7V4FFfWYvXoTsRtnH2aiePB6fhrZleoK5P9RsMzirH0ZDh+meoJRxMykTa7pBoBex5jYS87TOhKliZYWSPEvL2PYW2gju/HkQlRYjGDL0+EIy6nDAfm+0JHnVw8pVDedKh4007Jzc3FuXPnsHLlSgwbNgyGhobgcDjgcDiYO3duq2zz6NGjGDJkCMzMzKCqqgobGxvMmjULgYGBLW6joKAAq1atgoeHB3R0dKCtrQ0PDw+sWrUKBQXsnlq3BtqqStgX4IvUwgpsvBRNlJ7B5dalLempK+Pbc8+Io3jm97TFkE4m+Ox4GEoJoxW62xti2TBnvHcwhDhixVxXDb9O9cSqM1F4lllC1IYyn4vfpnbBkaA03Iolj3hYMcoVibnlrFKFZvhZw1hLFb9ei2/ycx6Xg+/GuuOv24lIySePnFky2BH3EvIRmEQ+zid7W6FWxOBUaNPpYhwOB4sHOOKv2+yibxb0ssPZ8Exkl1Q3+bmWqhImdrXEnvspxNsA6qJv2KZOjfYwx4WILFZpQgOcTRCSVsxKaHA11wYHQBThbwKoE+hczLQRqoDUqdhs8jQwALDUU1dI5A3btCkVfvORN1wuB6IWpE3JulcWCEXNizfVikmbMmKRtgMAqfmVrMWb6KwyuJixi7p5klIEJxMtmVEoD5MKWKdM3YjJUUDUTRZ6ORhBl9C0HwCuPsuBrpoScRECAIjIKMGzrFJMYiEA5ZZV4+/gDCzqS5Z6AtSJHb/fiMeSQU7EIlJdgYdovNfHnlXq1rfno9Hf2RjdCaM6AGDLjQSoK/OxoCe5J9LfwRl4ml6Mb1kUVLgXn4/d95OxZboXsegSm12KZSfDsXmKJ7FgmVNajUUHQ7B4oAMGuJClG5YLhFj+Tzh6ORjio/5kvn+1IjG+Px8NJR4Xv03rItXUXBYMw2DDxWgk5pfj0AI/Vj5fFMrbABVv2ikmJiYYNWoU1q1bh0uXLrWq8FFdXY1Ro0Zh2rRpuHLlCrKzsyEQCJCamoqDBw+iR48eWLduXbPtPH78GO7u7li7di3Cw8NRWlqKsrIyhIeHY+3atejcuTOCg4NbbT9IMdBUwa7Z3rgUmYO1554RRXko87nYOsMLUZkl+OLEUyIRiMPhYPWoTjDQUMGHh0OJb1Znd7PGxK4WeO/gE+JUoF4ORlgyyBGLj5ILSXZGmvh2nBu23EggTinTVlXCDxM743JkNnFKEpfLwYbx7ghMKkBERtM33h5WupjU1Qrb7yQRR/kYa6ni/X722H4nkTg6Q4nHxZJBjvjrViIEUr67AS7GMNNRYxV9Y2+kiT6ORjJTo+Z2t8GlyGypAk9LGO1pjticMjzLLCVuw9dWHzwuh1XKkqmOKlzNtHEzhlxI5HE58LdTQOqUlS6eppMLQADgYKKFuFx2kTcWuu0pbUr2XMfncmT+puo/knVDJqhtPm2qQiCEFkvxJq9MwDryJqWgAtYsjKQB4JkC/G6CU4tkGo5X14oQllYMfzty8UYsZnAjJo+138258CwFpExlYJK3Fasoor0PUjDByxI6auSRA7vvJaNnR0O4sPj+jj1Og4GGCoa5kUciXY7KRn6ZgFWq08PEfEQ+L8E3I8grnkU9L8Gj5AJsnNCZSBwAgLSCSvwb9hw/TuwMPcL0orwyATZeisGa0Z2IfWFKq2vx/iF2okt1rQjv/FdVjfS7qRWJ8f6hEPA4HHzHIlrm87+fIiStmLjaFsPUVYA9H5GNP6d7wZiFSEihvC1Q8eY1wMrKCoMHD2619ufPn49z584BAPr164fTp08jKCgIu3btgr29PcRiMVauXImdO3dKbeP58+cYNWoUsrKywOfz8eWXX+LOnTu4c+cOvvzyS/D5fGRmZmLkyJF4/pzchLYlkAgnJjpqOLTADxcjs7D5ahzRdjVVlbAnwBdh6cX4/gKZcTCfx8WGCe7ILa3GyjNRREJCvTcKn8vB8lMRxGLEvB62MNVVwxd/PyVuY6ynBcx11fDZ32SCFgD0dDCCrZEGvvg7nFgUcTDRQh9HI3z1T4RUUeyzwY648iwb5yPI03wCutsiIbccJ0MyiNsY7WEOIy0VHAlqOmKFw+Hg8yGO2HU3SWoqWEt4r48drkfnShXnbAw1MNXHSmo/WoK2qhLmdrPB+QjytCcel4MZfh1YmwWP7GyGyOfsRJPejoasorMAoEsHXWSXshNNnEy0UFjOTjSx0FNDcRW7NvQ1lIlTRetRVeKiRiSGWCxdwOFyIPO3L/pvXVkBBjVCMZT40hcQicQQCMWsI2/KqmtZe96UVNWyFm8KygVwMWUn3mSVVMHHRnoUSlhaMdwtdWDDoq+RmSWwNVSHtw15VbrE3DLoqvExyJVcAHpeXIUaoQgTvMjTafLLBYjLKcOc7uRmuiWVtTgfkYUPCSMhgDoR8rfrCfhyqBOxN0x1rQjfno/G50MciU1jBUIRvj4diZl+HYhvymtFYnx5Mhzd7Azgak42nkViBp8eD0NHY030cSKL8BKLGXx6LAw2hhqYSJheJBYz+Oz4U1jqqWNeTzLRhWHq0ov4PC6+HOpEJLowDIMVpyORW1qNzVM8iapK1osuYenF2DePLM2JYRj8eDkWFyOycWShPyxYGFlTKG8TVLxpp6xcuRJnz55FdnY20tLSsG3btlbZzu3bt3H48GEAwKhRo3D16lWMGTMGPj4+mDdvHgIDA9GhQ12J0C+//BLFxcVNtvP1118jJ6fOU+Lw4cPYuHEjevXqhV69emHjxo2SbeTk5GDFihWtsi/1/CCjYo8srPTVcWiBHw4+SsM2Qv8TQ00V7J/ni9Nhz2VW9JGFlqoSds/1wbVnOdh5l8w0VoXPw18zu+JhYgFxG1wuB79M8URERglxGxwOB9+Oc0NSXjl23SM3wF02zBk5ZdWsTHTf79cRFTVC7H2Q0uTnuurK+HqEC9aefUZssqumzMPSoS748XIs8U0tl8vBgl522HIzQao409vBCEbaqjgYSB5909VaHzrqSjgiIyVtqJsp9j9MIY7gAoABriY48DCVVRt9nIxxKDCNVRs9OhrieHA6sYk2APjaGuDfsEzi1EgA6Gypi2vRuazacDTRwuOUQlZtWOqpISG3nFUb+upKyC+vYdWGKp8LkZhBjQxPm+Yib+q1ZVm3MdVCEVRk3KRU1oogFDPQUCGvblIhECK/vAZGmuSpO1U1IsRkl8HWkMzXo76NwKQCuFqQizdVNSJcicqRGXlzPzEfVnpqrCJVrkXnwkRblegGsp6z4VnQVlOCFguT4RPBGdBQ5sNUR424jSOP0qCrroSOxuTpavsfpsBcRw1dOpCLWXvuJ8PaQB19HI2I29h1Lxn6GsoY40EuZu28mwwVPg9zWFTd2n4nCTVCMT5gIWb9dTsRRZU1WDaMPPpn6+1EpBdV4vtx5ClXW28nIia7FL9O9SROZfvzViKepBbhr5ldm40klMYfNxNwKzYPewJ8iH8zW24k4HxEFg7M84MRYXW9LTcScDw4HYcW+qEDS7FaGhUsHy5QKO0RKt60U9asWYORI0fCxIRdKHFz/PDDDwAAHo+HP//8Ezxe45OBoaEhNm7cCAAoKirCrl27XmojJycHBw8eBAAMGTIEkyZNemmZSZMmYciQIQCA/fv3S4Se1uBxchFWnokkihbpaKyF/fN8seVmAvGNsbWBBvYG+OK36wk4RRiBYa6rhl0sS4gba6ti26yu2HQ1DrelVFtqDn0NZfw5s66NxylkJsjaqkr4bVoX/Hw1VmraUnOoK/Px8yQP/HwlDgmE6SKqSjysH+eOTVfjkC6lUs9YTwvYG2li89Wm/XFawnB3U9gYqOOvW+QGyANdjGGppy7Vc6YuusoB226zi755p7cd9txPkXrz3c3eAMZaqjgtxYOnJXhb68FQSwWXpVTRagkeljrQ01DGrVjyku6dzLWhraaER0lk4xgAHIw1oaHCw9OMYuI2bA00oMrnSq321RIs9dSgxOMihUV1M1NtVXA5HFZpcXoadRftxZXkETxq//lGCGSkTvF43BalTclKqagRiqEqI4KgXmzVVCEXAPLKBFDmcYnTMgAgtbACGso8GLIQgGJzyqCtpgRTFikITzOKoa+hDEs96WJGoKL8blzI/W4YhsHZp5kY2Zm8tLdYzODvJ+msfGpqRWIcCExlVfK5skaIPQ9S8EE/cqGipLIW2+4k4fPBZFEZQJ3nzp83E/DNCBfiyJ30wkpsuZGAb8d2Ik51Ssgtx5YbCfhhYmdioSLyeQl+vxGPX6Z4EkcQBacUYsuNBPwx3YtY7LgTl4c/biZg64yuxL5MlyKz8efNBOyY7U0smPwTmoFtt5OwJ8AHZoRC5cHAVOy4m4T983yJRZcdd5Kw634yDi7wgz2hAXVzlFbXYvHR0FZpm0JpS6h48xZTXl6O69evAwAGDRoES8umQ0HHjx8Pbe26J3inTp166fMzZ85AJKp7mh0QECB1e/VGyyKRCGfOnGHTdZlsmdEFt2LzsIow7cjNQgd75vpg/YVo/BNKJr64Wejgr5ld8fU/kcSGvYooIe5hpYvvxrnho8MhSCZM9/C00sXy4c744FAIsXeNVwc9fNTfAR8fDSV+EuJto4/Z3ayx5PhTYj8gPzsDjPE0xzenmxb3OBwO1o11w+GgVGJj2vrS4TvvJRFX8+FwOPhyiBO23U5ESWXTUUD9nIxhqa+OAw/Jo28GuZhAXZmHM0+bTmvicDiY19MGu+8nE6fOcTgcTPWxwtEg8uplHA4HozzMcDacPP2Kw+FggIsxrrGoOsXhcNDN3hAPEsh9b7hcDjysdBHGwrSYy+XAwUQTcSwqTvF5XJjpqrKqOKXM50JLhc/KtLjeJ6FaRkRUS0uFy7pXFTRTKrxCIIS6Mo9VhaDcMgGMtFRYRaKk5FfC2kCDVRvR//ndsGnjSWoRvG30pLZRVSNCWHoxutmRm9Bml1QjOqsMfRzJxZuY7DJkFlezEoAeJhWgulbEqo2LkdlQU+ahL4t9ORqUDnNdVfRyID+mO+4mwd1Ch5U58OarcejlYAQ/Fl5Ga84+wygPM3S1JjN/FokZLD0Zjhl+HYijkKprRfj0WBje79sRnS11idooqqjBx0dC8eVQJ+JS6emFlfj4aCjWjnEjbuNZZik+Ox6Gnyd7EqePPUjMx1enIvHHDC9iP6ULEVn4/kI0ds31IW7jwMMU/HYjHgfm+cGZZWqnNIorazBz5yPW1QMplPYIFW/eYoKCgiAQ1N2M9+nTR+pyysrK8Pf3l6xTW9v4ZvLu3buS97LaafjZvXv3iPrcEsx01HBkoT+uR+dizVkyA2JvG31sm+WNFaejcIPwZq+ngyE2TuyMDw6FEIsv9SXE5+8LJr7JGu9liSk+Vli4P5g4HWiWvzX87Qzw8RFyI+W6ihUqWH0mimh9APh0kCOqakTYyiKqZdkwFzzLKpUqWHQ01sT8nrb45nQksU9PZ0tdjHA3x0YWpdK7dzSEu6UOtklJv5NE39whj76pT9HaIcOoeYynBfLKBKyMesd7WeJJahErv5jRHha4Hp3DKgx6oIsJrkfnEgtRANDd3oC1/04XK12EEs4J9TgYayEuh2XFKV0FVJzSZFcunMflQInHkZkSx+NxJAJNU/y/2hR5qfAyhVSaqoYh4RPxelILKmBjyNKsOFMBZsUphTJvvINTC2GspQorffI0o5uxuehipQt9FpFK58IzMcDFmLjyDwAce5yOcV0sWKVu7bmfjDndbIgjVWqEYuy4m4QP+nYkFt3yywXYfT8Znw0mL+sdnVWKUyHPsWyYM3Eb16NzEJxayCpNaf/DFOSXC1jty8ZLMdBQ4eN9wqpdDMPgixPh6GShg7mEqV/VtSIsOvQEIzubEXvl5JUJsHB/MBb1tcdQQgPquJwyvHvgCdaM6YTehOl0DxPz8dnxp9gyvYtMLyxZnA59jl+vx2NvgC/cLcmErOYorKjB9B2PYKKtig0TOrfKNiiUtoSKN28x0dH/N9V1dpZ9oq7/XCgUIj6+cUpJfTs6OjowNZV+YjEzM5NE8DTcdmtgpa+Oo+/44+qzHKw7F010s9bTwRC/TfXEB4dDcTeeLF1jtIc5vh7hinf2ByMpj+xGa35PW4zrUhctQlr5aelQZ5jrqOLHy7HElbDWj3dHXrkAfxIKJzwuB79M6YKr0TlShZPmUFXiYdNkT/xxK4E4MkZHTQmrR3XC2rPPpFbK+bCfA/LKBDj6mDxa5MuhTrgenYMnqeRpOp8PdsKe+ynILWs6taWvoxE66KtjP4vom/FeFiioEOCWlNQ6VSUeZvhZs/IbMtRUwUBXYxwPJj+eTqZasNbXwNVn5JEz/nYGKKqsQQyLlKXu9gYITStmVaq9LvKmmHh9AHAy1UQci/0A6tKvMorZV5xiI94AdWOsSoZ4w+fKjrypn95lije1skuFVwhErCtN5ZYKYMxSvEkpUESZ8FJWlYrEYqYu8kaG301gUgH87PRZRfdcj85Ff5YpU3VVpshTpkoqa3EpKhtTfMhTpsLSixGXXYaJ3mQ350DdTa2aMg9DOpFXh9p6KxH+dgYyfYpkwTAMvjsfjVn+1sQlrKtqRFh1JgpfDnEmFuXSCyvx0+VYrB/vTpzqdC8+H8cfp2PzFE/itK29D1IQnVWKHyd2JjYG3nQ1Dko8LlaO7ETUB4FQhPUXo+Fjo0+cTpdbWo0v/n6K9/rYYzJhamB4RjEW7g/GjxM7E1eG+zfsOb76JwJbpnsRj9HmyCsTYOr2h7A11MCfM7yI0+0olPYMFW/eYtLT/38jJS1lqh4rq/9P+A3Xa/h3c200bOfFNpojIyND5isr6+UKQVb66jiy0B8XI7Ow8VIskYDT38UE68e7470DTxBM6Pky3a8DxnpZYPbuIKk34bLgcDhYOtQZDAN8cCgEtQSRL3weF79N64I7cXnYfI2smpaGCh9bZ3ph7/1kXCeMRjLVUcVPEz2w/XaiVN+Z5nC31MGiPvbYeiuR2Hx2uLspunTQxR83E5r8XE2Zh7VjOuHHyzHILydLFTPRVsV7feyx9lw0cQRPlw566OlgiD9vyo6+2X4niTgiRVWJh7ndbbD9dpLUZWZ1s8aduHxWkTNTfDrg7ycZxJFbQF3pcVLhD6jb114OhrjGQgDqoK8OIy0VPEklT3vytNJFcn4FSqrIxFhAMeXCrfTVWaVNAYC+umLEG1nlwnkcjszf0P8jb6RvQyAUQ1nGhXy5oJZ15E1euQLEm/wKVuKNWMzUpU0RplYAQEJeOWpFjMw2HiYWoBuLtJrqWhHuJ+SjvzO5eBPxvAQF5TXo60RuzHs67DnczLVZmQzve5CCiV0toU3ohyISM/jrdiIW9bEnjtzJKqnCoUep+GywI9H6AHArNg9RmSX4qL8DcRvb7yTCQFMFUwnFMIZhsOVGPEZ7mqO7PVnqV0llLXbdS8LXI1xgSyhChWcUY9+DFPw61ZPYo+ZwUBr+CcnAn9O9oCxDOJYGwzD4+p9IJOaWY/14MqPkCoEQAXsfw95YkzgCKSG3HHP3PMbigY4Y6UEmlF6KzMaykxHYOrMr/FnMG7LILqnCjJ2BcDXTxq9TyapoUSivA3Rkv8WUlf3/wl9TU7ZhmIbG/0+A5eWNI0jq22mujYbtvNhGc1hZWcl8+fr6NrleB4O6CJzQtCJsuBhDJOCM7WKBr0a4IGDvY+JSw0uHOMPXRh9zdz8mSl3i87jYMr0L8soExF4+uurK2DHbG3vvp+B8OFk5bAdjLawe44Ylx58Siy8DXU3QpYMePj4aSiREAcCivh2RnF+BX6+RGQtzOBysG+OGI0FpeJDQdApMf2cTDOlkivUXYoi2AQALe9nBSFMZ/4aRG/5+PtgJMVmlSC9sWjjp42gEF1MtVuXJZ/pbIzyjGOFSjHhNtFUxzN1UaqWultCzoyGUeVzcZGE6PLKzGe7G57EyyB3oYoJrMWQ+VEC97w271CkDTRVY6qlJPd4twdFEC6kFlayqZ1nqqbFPm1JI5A1XdtoUl9uM502d342smxuBUHbkTV3aFLuntHWRN+zKhKcWVLAqE55eVIkakZiVCWhwShE8rHSk3vxUCIQIzyhhdRP2MKkA+hrKcDIhF03OhWdhsKuJxDeJhGOP04mjEYC6qIbzEVmYzaKi0vWYHNSKxBjjSV7Z6XBQGkZ5mKOTOVkqSq1IjN33k7F0qDNR2WcASMorx94HKfh+rBuxCHU8OB234/KxnEXa1op/I8HhcDDNtwPR+qXVtfjwcCim+HSAN2F6UGhaEb49F43fp3vBTJcstXDH3STcjc/D9tneEmN3eRCKxPjwcAh01JSwYTxZ9FBWSRVm73qEqT5WWNCLrLz5zdhcfHosDL9N68KqAposnhdXYcr2QPR3NsHPk8mjrSiU1wE6ut9iqqv/HwWirCz7yYKKyv+fJlZVNb7Yr2+nuTYatvNiG62JtYEGNkzojNNhz4kjcGb4WeOj/h0xa9cjxBOYhHK5HGyc2BlGWip498ATohsuLVUl7Jrrg6ssSog7mGhh8xRPfHniKZ5llhK1MdrDHGM8zbHo0BPi0s1fj3BBpUBELL4o87n4ebIHdt9PRkgaWQSEma4avhjihOX/REjdj48HOOBSZBYeJZH5vagp8zDKo877htSXxslUC2a6avjtetNRQhwOBwt722Hz1Tji6BtddWXM7maN7XekR98s6GmLS5HZxKl7PC4H83rY4Ooz8qpT1gYaGORqghssxJf+zsYoLBcgu5S8ylJ3ewMEEUbi1eNppYewtGLi9c11VKGmxENSHnk0lKWeOp63secNAKjyec2IN5AdeSNmZKZMAf953ijJSpsSsqo0BdR53hhrk0feVNeKkFlSTZyyAtT53TgYaxE96a+nLmVKtt+NqY4qrPTJRabglEIMdDEmTrsSixkk5ZVjFGEkAFBXiUhfQ4k4mgAADj9Kw1gPc2KxjGEY/HotHgt62RF/Z2kFldh2Ownv9ia7uQaAo0FpeF5chQmEviwMw2DVmSiM9jBHJ0JT3pzSanx7Phrfj3eDthpZtMu/Yc9xLyEfGya4E6c6LT8VARtDDeLjmV8uwPuHQvDZYEdigfNGTA5+uRaPHbO9YUJQNY5hGKz4NwqZxdX4a1ZXorFVVFGDWbuC0MfJCF8MIfMeepCQjw8OheDHSZ0xyLV1quemF1ZiyraH6NnREF8OcWJlOk+hvA5Q8eYtRlX1/yeEmhrZF9/1xsYAoKbW+ClCfTvNtdGwnRfbaI709HSZr6CgIJnr2xpq4MhCf5wKycBPV8gEnHd622OWvzVm7nqEtAL5o06UeFz8OcMLFQIhlhx/SpRKY6Grht0sS4gPdDXBor72WLg/mPim6+sRLuBxuVh77hnR+qpKPPw2rQt23UvGQ0IjXGdTbXwywBGfH39K7D8yq5sN9NSV8ev1pkUkc101fDLQAd+cjpRaTrs5RnuYw1RHVaYw0hyLBzrg36eZSMhtOmKtj6MRbAw1sO9hCvE2pvtZ40pUjtSIKndLXZjrquLvYPIIn6HuZvgn9Dmr8tRdrfVZ9cFAUwVGWiq4xUIA6mZvgPD0YmIhCwD8bfVZpT1xOBwMdDFGopQx0RIs9VRhoadKHAEHAFZ66lDisbtY7mSuLbMUuI6aEgxklM4WMwx8m3lCbqWnDg2ZT685sDNi5zWjq6YEc8Lyu0DdTUh3ewNWqVdJ+eXo2ZFdWkJMdil8baUfz4eJhaxSlRiGwenQTPRh0UZoehEepxShB4uqSseD02GmowZNwnS5GqEYBx+lYVhnM+I+3InPR1ZJNavon1+ux2FkZzPi1K+SqlpsuhqHr4e7EKeaXIjIRnRWGZYQGgzXpwgNcDYm9lTJLK7CitOR+H6cO3EE3JGgdAQlF2LTZA+i6CGhSIyPDoeiq7Ue5ve0JepDXE4ZPjkSho0TOhNXydp6OxE3YnKwJ8CHKJ2vPt2qo5Emvh1LJoQFpxRi4f5grBvjxsqXShbJ+RWYvO0hBrma4FsWEV8UyusEFW/eYrS0/n+iby6NqaLi/093X0yPqm+nJalQ9e20JMWqIZaWljJfZmbNXzzZGWni8EJ/HA/OwOarZL4vnw5yxAh3c8zYGYisEvmfWGuo8LF7rg+eZZZi7TmySliKKCH+Qb+O8LTSxfuHnhDduKnwefhzhhcuRGThFGG6jpOpFr4a4YJPj4VJNQ5ujnd620FXXQk/XCZLbeJxOdgwwR177idLjUQK6GELLoeDXffIop04HA5WjnLFtttJRGMGqIs4mdTVEpuuNl29isPh4NOBjthxJwnlhNE3VvrqGOJmip13pYtMAT1ssfdBsswbbVlY6Kqhu70hTjwhNy4e2dkMj1MKkcMicmagqwmuRZOLN2Y6arDUU0dQEnn0jbOZFh4mFrCqfKXC5yE6myyCDgBMtNUQklrMSkxT4XMRncXOeyezuBpl1dLHbXWtGJky+ihmgCfNROA9yyqV+UQ2u7SaODqunvuJBdDTII/eSSmoRGFFDSsT4NC0YpiwEJDyygR4llUKDytdqcs8TCqAF2H5ZgCIyylHYUUNsacJAJx9moWhnUyJo1Wqa0U4Hfock1kYFV+IyIKWKh99HMhFqD9vJmBeDxtiY96E3DKcC8/C4gHkXjd/3EyAq7k2sf9QuUCIteei8PUIZ+iokY3/c+FZCE0rwspRZMa+YjGDL048xZBOpsQVmWKyS/Ht+Wf4dYonDDXJBNQfL8eioEKAjRPI0pQKK2owf99jBPS0JY4q+zfsOf68mYjdc31gTpCyVSMU472DT6CmxMMvUz2JIlnCM4oxf18wvhrhQhzN1RzxOWWYvO0hRnuaY+VIV1bzJoXyOkHFm7eYhgbDGRmyb8AbGgw3NC9u2E5zbTRs58U2XhUdjTVxZKEfDgel4xcC414Oh4MVI10wysMcs3YFoYDAzNZAUwX75/kiOquUOBqjvoT4h4dD8JzAcJTD4eDHSZ1RXFmLbwmjZyx01fDLFE98czoSMYQ3kDP9OqCzpQ6+PBlOdBPL43Lw82RPHHucTuxB4myqjfk9bbH8VHiTooQSj4tvx7nh9xvxxOauXh30MMjVBD+yKB3+8QAH3IjJRURG075LvRwMYWuogX0sfGne7W2H48EZUsW0oW6mEIoYYsNqAJjqY4VjwenEJs4m2qrwttEj9m0C6nxv7iXkEaf9AfjP94a8fHoncx0UV9ay8pxxNGVXLpzH5cBMVxXpLEyLFeF5o9KM5w2Xy4FIJNuwmNds2pRI5o1+uaCWVdpUjVCMwooaVp43bM2KAfZlwp+kFsHRWEvqTXhZdS0in7Pzu7kek4MeHQ2JvWpEYgbnI7JYpUxdjsqGoZaKzIpazbHnQQrmdLMmftr/JLUQUZmlmNXNhrgPm67GYVJXS3Qg9ElKLajAvgcp+Ho4+c3vr9fiYGOggbGEnj2FFTVYfSYKq0d3Iq5QtfdBCtIKK7FqNJn4U1kjxAeHQrCglx26E0ZzXYzIwuGgNPw1syuR+XmNUIxFB5/AzVwHiweQmUY/Si7Ahosx2DK9C5H/kVjMYOnJcOioKmH77K5Ev9FnmaWYtSsIS4c6YYaftdzrt4TorFJM3R6Iab4dsGyoMxVuKG8VVLx5i3F1dZW8j4mRHblQ/zmfz0fHjo3LFda3U1JSguxs6ak8WVlZKC2tu8l3cXEh6rMi6GishSML/XDgYSp+k5IuIwsOh4PPBjvByVQLs3cHEaVOWOmrY9WoTthyMwF/E5ZPnt/TFiPczTBvbzBRH9SV+dgx2xuphZU48ois1HRfJ2Ms6GWH789HExkxczgcbJzQGREZJTgYSNYHW0MNLB3qjC/+DieOOvmovwNKqmqlCh8+NvoY4W6G1WfIhC4AWDrMGRcjs4lLRJtoq2JONxv8dEVG9M0gR+y4Sx5942ahAy9rXRyQ8l0o8biY1c0au1mUDR/gYoJKgQgPCX2EAGC0hwWrqlMOxpow1lLFfSlm1S2hu70hK9NiVSUenM208JSVabEmkQdXQyx11VkJSPoayihkYSAN1Febkl0qXCRD3GUYRmalKQAQ1IqbLRWuycKwOL9cAA4HMJSR3tUcKQUVsDYk95EprqxBZkk1S/GmEF4yBI3glCJY6qkRPdGv50Z0LgawKBEelFwIsZiBvx2ZmSxQlzI12duK+KYvNK0IibnlrKIK/ryZiBn+HYijVSKfl+BGTC6r6lAbL8VgrKcFcXWymOxSHAhMxbqxZNWQAGDN2Sh4WethJGH6WXxOGX68HItNkz2JU+C+PRcNA00VfNyfrBx3Qm4Z9txPwc+TPGBH4H9U5xkUCWNtFfxMmLKVkFuGd/Y/wacDHdHXSf7fF8MwWH02Ck/Ti7F6TCdoEaRbJeSWYdauR3intx2mt5JwE5lZgmnbAzGvpy2WDHKkwg3lrYOKN28xPj4+EpPh27dvS12upqYGgYGBL61TT8+ePSXvZbXT8LMePXoQ9VlROJho4fBCfzxKLsCWG/ILODwuB5sne8JEWxXz9jwmCrd3NdfGtlldsfLfKNyIkT+SgcPh4PMhTjDVUSUuIW6lr453e9eVsyYthf7JAAdwORwsJYye0dNQxi9TPXAwMBWx2WQ3orP8reFgrIm/bjVdUrs5VJV4+H68O36+Eis1umb5cBcEpxbiKmGZaQtdNSzoZYt1hOlyAPBeH3uEpBZJNVDu2dEQ9kaarKJv3ultj30PUqTeTE/z6YCw9GJEZZJVXlPmczGxqyWOBKUR93GYmymiMkuIvKeAut/OABdjXGMRQeRvp4/YnDKi6Lt6PK10WZkWO5poIbWwktjzCWBfcUpfQxlFFTWs0r9UlXioklEqnMvlyEzVEzNomWGxjFLhZdVC4hs/oC7dyEBDmVWVk9SCStiyiLx5llUKC1014mpBABCcWiQzGuVhUgH8bcmjbgorahCaXox+BDeX9ZwLz8Qwd1PiY51eWImg5EKM9yKv7rT3v/LgJDe4QF3kwL2EfGJfFKAu6maGnzVMdciivR6nFOJ2bB5xeXGGYbDidCTmdLOBI2HVsFuxubgZk4tvCcWfGqEYv1yPx8JetvAhrAx1KiQDj1MK8esUsipF5QIh3j3wBN42uhjciSxla++DFFx9lovlw1ygTlBZKq9MgLl7HmOWvzVxKuCv1+NxOSob++f7EqWNpeRXYPqOR5ju1wEf9CMTwZojNK0I07cH4oshTq22DQqlvUPFm7cYLS0tDBgwAABw7do1qWlPp06dkkTMjBs37qXPR48eDS63bijt2bNH6vb27t0LAOByuRg9ejSbrisEJ1MtrBjpil33kvHnraYr+chCmV9nQKzE4xJXkOpub4ifJnngo8OhRFWTFFFCvJu9AZYPd8Z7B0OQWSz/TVxd6pIHQtOKsft+itzrA4C/nSEGuZrioyMhRKksXC4H68Z2wr4HKbgVS+Zl0t3eELO6WWPF6cgmj6O+hjJWjHDBjjtJxN4Y7/WxR0llLS5HkZlN62koY2FvO/woxXSbw+Fg8UAH7LibRBQJBQC9HQxhpKWCE0+ang/0NJQxrosl9hJ+1wAw2ccKV6JyiNNt9DSU0cvBCGfDyaNvBrrU+d6Qpm8ZaKrAyUQLgSx8bzwsdVlF3hhrqUBLhY/EPDamxerE6YBA3e9CKGZQKsOzpjnUmkmb4nM5zZQKZ9DcfV9zaVMVAiFRqkM9uWUCGLEsE55SUAFrFuJNdFYZXFhE3VTXihD5vATeNtLFm8CkAnSzJxdvbsXmwsVMi1hwEIrEuBiZjVEsDFD/fpKBPo7GxCluuaXVuBiZjTksyoNvvZWISd6WxH148p+Iv6ivPdH6YjGD3feS8V4fexgTVDMC6kQPbTUlfEyY4lNaXYtlJyOwerQrUUUlAPjlWhyS8irwIWH0UWJeOVacjsRXw12ISnozDIMv/n4Kc101fDaYrLz5nbg8/HApFttndyWKaKusEWL+vsfwsdEnFuIOPEzBnvspODDfD5Z68kf/PS+uwoydjzDawxxLBpH7L8nicUohZu8KwmeDnTDDv3WieiiU1wEq3rzB7N27FxwOBxwOB6tXr25ymc8//xwAIBQK8cEHH0AkanwBnZ+fj6VLlwIAdHV1sWDBgpfaMDU1xYwZMwAAly9fxokTJ15a5u+//8bly5cBALNmzYKpKdnTCUXjbKqNQwv8sf1OEv66LX/UhqoSDzvmeKOsWoiPDodCSBD9MqKzGb4Y4oR5ex9LrSYkC0WUEJ/lb42BLsZ49wBZ+W8DTRVsme6Fny7HkkfwDHSAhgof352PJlrfSl8DK0a6YunJcJRUkgkX7/WxR8TzEpyT4qcyroslhGKx1LLdzaGhwsc7feyw7lw0sd/KvJ62YBjgVmxek5/37GiIAc7GOEyYCsfhcLCwlx2uPsuRGu0wr4cNLkZmI6+MzOjW3kgTnla6+Cf0OdH6ADDKwwxnwsjFG19bfVTXihDxnCyCCGCfOtWlgy4inpcQV3vicDhwMtVCHIvUKbaRN5oqfCjxOKx8b1SVeKiWIX7zOJxmSoVDZpoBwzCoETaTNlUjhJYqG/GmmlWVKIFQhMziKtiwSJuq87shi4AAgPCMEuioKaODlBLgpQrxu8nFAMJqQgDwILEASjwOcZSFSMzgRHA6prAwKj72OB097A1gS1jSPSW/AhlFlXi3N5nwAgB/3IzHxwMdiI11zzzNRFhaEXHkT0llLb6/EIOJXpbEouf6CzHoaKyJcV3IUs8epxRiz/0U/DLFk8i4urpWhA8OhWCGvzX6EZo1b7uThPCMEvw2tQuRsW9iXjk+PByC78e7EZmA11e3UlfmEZskn3maiQ0XY7B7rg9RBFVOaTWm7whEP2cjfD3CpVXSmB4k5GPu7iAsH+7CSjSlUN4EqHjTTrl37x727t0reTUURBISEhp9Vh/RQkL//v0xdepUAMCZM2cwaNAgnDlzBsHBwdizZw/8/f2RllaX3rBhwwbo6TV9cvnuu+9gZFRXcWHatGlYtmwZ7t27h3v37mHZsmWYPn06AMDIyAjffvstcX9bA1dzbRxa4Ie/bidiB4GBsKYKH3sDfJBWWIkvToQTPcmf28MW0307YM7uIKLKLxa6atg1x5u4hDiHw8GaMZ2gzOdiGWH6U1drPXw51AkfHg5FPkEqiRKPi9+mdsHpsOfEkSmTvC3RyVwHq89GEa2vq66MlaM6Yc3ZKBQ34ePB5XLw7di66lSkN8wTvSyhp6Eks6qTLDRV+BjmZoofL8c2OdY4HA7GdbHEn7fIo29GeZghLqcMV581/T04mGihm70BjgSRV42a3c0a9+LzidNtBrmaQpnPIf4elHhc9HE0wk0WJcO72xsQl7oHADtDTShxucTpgkDddxHLUrx5zkK84XA4rE2LVZV4EMhIm+JxORCKpX8uZhiZaVNCMQMxU2eMLI3yapaRN6UCVuJNRlEVlHhcmLCI3onOKiX2LgGA4NRCeFvrSb35epxcCGsDDeKomVqhGPfi81n53QQmFWCspwWxSfCDhHw4m2mjH2GZcoFQhAOBKZjHIt1p+90kWBtowEqKSNYcDxLyEZxShKk+HYjWr6oRYeOlGCwd5gJ1wjH/45UYdLLQIa7s9CAxH2fCnmP9eLIy1OUCIZYcD8Nngx3hZEomWH53PhoqSjx8Tlje/H5CPn67Ho+/ZnaFHoHRckllLRbsC8YMf2siAYthGKw5+wxphZXYNtObSMC6E5eHpSfC8ccML3QlMO/OL6/GjJ2P4GOjj7WjyX2PZHE7Lg8L9gdjzRg3TPcjG/MUypsEFW/aKTt37kRAQIDk9cUXX0g+u3//fqPPAgICWG1r9+7dGD58OADg5s2bGDNmDHx8fDBv3jwkJiaCy+Vi1apVePfdd6W2YWVlhbNnz8LU1BRCoRAbN25Er1690KtXL2zcuBFCoRCmpqY4e/ZsoypX7YVO5jo4ON8PW24mEN1U66or48B8P1TViLDy36bTbprjiyFO6GZvgM/+foqSKvlvujtb6mITixLiKnwets70QmBSIXYQCgtzu9ugq40ePjkaSlRO2kpfHd+Nc8fSk+FEZbU5HA42jHfHzdhcXIokq0Y0qrMZ3Cx0sP5C0yberubamOVvjW+kpFc1B5fLwcqRnbD1ViJyCctdz/S3RlFlDS5I2cceHQ3gaKJJnNqkzOdhXg9bbLuTJHUfp/t2wIHAVNQIyaJGBriYIDi1EKGEBs6aKnx00NdgFX0zpJMJsVAI1EXvaKspIbOYLO2Iy+VgmLspK/Gmk5k2Sgnmi3os9NRQLRQRf48AoKeuzMr7R5XPlenbw2vG84ZhINOwWPDfvsnyvCkXsPO8yS8XwIiFeJNeWAl3Sx1iUUJQK4K6Mg8upuTiTWZxFXo5SK+08zS9GCPcyUxlAeBxaiGMNJXhRlAFB6jzNzkYmIohhIIBABwNToejiRaxX8758CxoqiqhB2GZ85zSapx8kkGc7sQwDH68Eot3+9gTGx3vupcEYy0VjCas1hWeUYwTTzKwdnQnopv1yhohlp2MwOdDnIgFrHVnn8FSVx3zepCJaBcjsnA67Dm2TOtCJHo8L67CR0dCsXpUJ7hbyj+ea0VifHA4BPZGGviCUDzacScJl6KysSfAh8jnKiS1ED9ejsWGCe5EBsfFlTWYtesx+jgaYuOEzsRzlyyuR+dg0cEnWD/eHRNbqeQ4hfK6QcUbCtTU1HD+/HkcOnQIgwYNgrGxMZSVlWFlZYXp06fj3r17UtOuGuLn54eIiAh88803cHNzg6amJjQ1NeHu7o5vvvkGkZGR8PPza/X9uSIlWqA53CzqBJzfrsdj9z3504+MtFSwYpQrbsbmYcPFGLlv7DkcDtaPd4eemhIW7g8mSqsZ0skUSwY74icZxruyMNZSxfbZXfHLtXjci286LUcW9dWjskqqiUqxA8BoD3MMdDHBp8fCiAQgY21VrB3jhq//iSSKAOJwOPh2rBvOhmdKjapYPMgRaQWVOBlClvbja6uPPk5G+PEyWelwVSUePhnggE1X4ppM1avzvqmrPEVSiQwApvpaISG3HMGpTXsx9XE0gpYKH+cjyMQTNWUexnpa4BiL6J1RHuY48zSTOHqnl4MR4nLL8ZzA6wkAtNWUwACsfG+MtFQQyKLylq2hBu7Gk6dumWqroqSyFjmEQmJ9G9LKy7cELVU+xDK+QyUuB2oyStaKGLHMEsPVtSLoayhDScbNBYcDVuJNTmk1TLTJxZvEvAroq5NXqkrKr0BMdhnxzbBYzOBceJbMyJ3rMblwMJG/kk49N6Jz0dVan/gm7258HrRUldDFSpdo/aKKGlx9loNJ3mQ3gQzDYM/9FMztbkO8D7vuJaO3oxGxwe+NmFykFVRiLmHqSG5ZNbbeSsQ3I12J9kEkZvDN6Ui809seNoRpYz9fiYORlgrmEJZIvxyVjQuRWfiJsCpTemElvjwZjh8mdCb6vVTXivD+wScY0smU2Bz4j5sJyCsX4JepXYj24Vx4Ji5GZmH3HG8ij5r4nDLM2xeMiV0tMIagxHtZdS3m7A6ClZ4alg1zIUoZa45rz3Lw4eFQ/DzJg6iPAFgZ6VMo7RUq3rRT9u7dC4ZhWvxqirlz50o+b4n4Mn36dFy5cgU5OTkQCARIS0vDoUOH0K1btxb329DQEOvWrUNERATKyspQVlaG8PBwrFu3DgYG5Hny8rD+QrRUs9XmcLfUwYH5frgVm4u9BOWQLXTVcHCBH06GPMcfN+X3RVHicfHDpM6oEYqx+CiZeDGvhy2sDdQxn7CEeGdLXfw0yQPvHwpBEoERqqYKH3/N7Io7cXm4GUtWzWfN6E7IKRVgK4GRNFAXPeNvZ4Bv/iGLjrHUU8eSQY746p+IJkU0TRU+Vo1yxfoL0U2mV7WE5cNccDY8E5GEnisTulqCAXAypOmx3t3eAM6m2sTRN1qqSpjhZ41tt5uOwuJyOZjbwwa776UQXyBN8bHC2fBM4tLmfZ2MUFRRg6cZZMdQV10ZPjZ6uM6i6lR3ewM8YJE65WGpS1w+HgAcTbWQUVSFCsJjyOdxYaarysr3RktNCYWEPlMAwONyZc5VHC5HZjSimIHMz2uEYhRW1EBVigAkEjPIKRVAk5XnDTvD4tSCCuKbYaDO78bFTItYVEjKL0dVjQidpETFlFTWIjqrFN1Y+N3ciMlFfxYpU+fCszCysxlxasbpsOfwsNSBPUEpZwAISStGSn4FxnuRiT/FlTU4FJiK91mYDP98JQ6L+toTp/j9fDkOfZyMiD2DjgSloaiyhngfQtKKcOhRKnGkRl6ZAMtPRWDdGDdYEJj71gjF+OqfCIz1tMAwwiiy789Ho4O+OlaPdiVa/2BgKvY/TMXO2V2JBOPHKYX44u9wfDzAEe6WunKv/7y4CrN3B2F2NxvM6S5/5FJljRDz9j6Grroyfp/eBUosKuxJ48zTTHx8JARbZ3oRf09iMYOfCB+QUSjtGSreUN44fpzggVX/RuJgIJlhq4eVLj4d5Iifr8bhwMMUude3NdTAoQV+2HkvGXsIBCB1ZT52z/VBXG4ZVp2RX3zgcDhYPaoTqxLiw93NMM23AxbuDybyTXE00UJAD1t8euwpUQSQhgofv03zxKmQ53giJfJDFhwOB+vGuuFZVikuRJBFYgX0sIWWKh+/SyklP9TNFO6WOviB8OLASl8dAT1ssZawdLgSj4tPBzni12vxTQpM9ZWndt5NIkrDA4CAHja4E58n1Uh7gpclUgoqiL4joC7azc5IA+eekkXvqCrxMLiTKc4Srg/8v+oUKfW+N6QClmcHXSTklRP7ExlqqkBfQxnxBGbn9Vjqsqw4pa6EIkIRE/jPsLgZzxuRjOPLNON5UyMUQ5nHlXqzWPFf9bi29LxJKaiEtQELs+KsUlaVpoJTiuBhpSs1heRRcgFsDTWIKxMl51cgo6gKPTuSpRtV14pwJSobowhTfRiGwbHH6ZjsTW5UvPdBCiZ5WxFHaO17kAoPK110ITCmBYCLkdkorKjBTMJKO88yS3E67DmWDiWripRfLsAPl2KwdrSbVCFUFtW1Iiw7EY6P+jugo7H8AhrDMNh8NQ4DnI0xxpNsHPx0JRY1QjG+HuFCtP6xx2k4H5GF5cNdZKZhSuNBYj6+Ox+Nv2Z2hZW+/GJtYl45Fu4PxoqRrkQmywXlAsza9aguunmg/BW6qmtFWLAvGHwuF9tmdSU6Bs1x4kkGlp0Mx9ZZ3kTpXEBdWtriY2EISiG7NqFQ2jNUvKG8cXjb6mPfPF9svBiDXQTpTwDQpYMe9gb44odLsThEULXHyVQL+wJ8selKHI4/lj8tRF9DGfvn+eLqsxxsuSF/9IkiSoh/OdQZlnrqWHw0jMiEeWwXC4xwN8P7h0KIyqi7W+himm8HfHI0lCiCSF9DGStHumL5qXAiE2gety6N7XFyEWKyS1/6nMPhYO1oN0Q9L0EoQZl3AHi/rz2S8sqJTKYBYKS7GbTVlHD4UVqTn3ezN4CzGXn0jYm2KsZ4mEv1gdJQ4WOqjxV2E4iU9Uzx6YCjBL+RekZ7muNceCZRlBpQ570TmFhAHP3jba2PvDIB0grJxA9jLVWY66ghgjB6CAAcjDXbtOKUvoYKCsrZiDdcVMlIE+VxOBCKZJUKh0zxRtBcpan/vnsNZbKbcrGYQX65gLjsM/Bf5A2rMuGlcGUj3qQWwVuGYWlgUiGrKlM3YnLhb29ALJDdis2FkZYKOhEaMkc8L0F6YSWGEz7Fzy6pxuXIbMzuRiacVAiE2PMgGe/37Ui0vkjMYNPVWHw0oCORcMIwDL49/wxzutsQl6PfdTcJPTsaEldm+vNmAuyMNPBObzui9Y8+Tsf1mBziikY3YnJwKDAV68e7Ex3D8IxirD7zDL9P60JU0ju1oALvHwrB6tGu8LWVP/Ipr0yAuXuCMM23A5Fxb7lAiIC9j+Fqpo3VBH5FNUIxFh18AoFQjJ1zvImOYXMcCUrDqn8jsXO2N/o4kpmKV9WI8M7+YCTklmPbLC8F95BCaXuoeEN5I/G20cfBBXX+NSTpS0Bd9aQ9AT5YfyEGR4KavjmWhYeVLnbM8cbqs1E4Fy5/ZIClnjr2zfPFjrtJOEqwfbYlxHlcDn6b2gVJ+RXYdJXMv2blqLqw4m/PkZX/nt/TFnZGmviaMP1poKsJBrmaYilhBa1O5jroYq2LZScjmhQHOhioY6CLCb7+J5KoTLyWqhK+GeGCLTcTiAQuLpeDL4Y44XxEVpNpM/XRN3vuJ6OEMDLind52+Cf0OXKllAWf3c0G157lEvvGjPYwR0x2aZMCWUvoYW8AoYhBUDKZ74ytoQas9NVwN05+jyegzrunSwddVqlTnla6xMbNQF2kWxwL02NLPXV24o2mMuvIG4Es8YbHkemJIxYz4Mq4mhEIRc1WmlJX5hH7NhRW1kAoZogNi2tFYmQUVRFH3jAMwzry5klqEbxtpIs3D5MK0M2ejXiTgwGEN/0AcPZpFkZ5mBOnTB17nI5RHubE4tGhR6no5WBInNp2JCgN1vrq6NGR7Bhe/M9bjDRy6Hp0Dnhc4IN+ZOLR45RC7HuYiq8II1aeZZZi+90kfNjfgSjNJiW/At+ee4afJnlAl8AbKqukCp8df4p1Y91gR5A2V1hRg0UHQ/DJQAd0J4geK62uxfx9wZjgZYkpBFXCqmpEWLA/GF2s9IgMjgVCEd49EAwdNSVsmuwp91xXKxThoyMhKKiowZ4AH1ZRitLY/zAF35+Pxp4AX6JjDNSlz87e/QgVAhGOvusPfQ3yaEgKpb1CxRvKG4uHlS6OLPTH7nvJ+PlKLNHNu7eNPvYE+OC789FEETT+dgb4Y4YX9j1IwQ0CXw1nU23smO2NteeeSS3bLAsLXTXsnuNDXEJcR10JO2Z3xb4HKUQClAqfhz+me+FseCb+DZPf3JfL5eDnSR54mJhP7GO0cpQr4nLKiKM7Fg9wRGFFjdQ0vHf62KFaKML+h2RpeqM8LCBmQBwd08/JCAzDSDXZ7m5vCH87A+x5QNa+g4kWRnuY45QUbx0rfXUMdDXGP6Fk34+OmhKGu5vhGOH3w+dxMdzdDGfYpE65sk2dMmTne2Olw9r3Jo5F2pSFnhrLtCllFLAqFc6VnTbF4UAoI7JK1IK0qdasNJVXJoCWCh9qymRPojOKqsDjcGCmI//TfADIKqlGaVUtccnk/HIBUgoq4CUlnae4sgYx2aXwsyUTHsqqaxGUXIj+hOJNhUCI6zE5GNmZLFWmqkaEM2GZxOay1bVCXIrMxtweNkTrC4Qi3IzJxUf9HYjEpxqhGBsvx+KDfh2JhI9akRjfX4zBIFdTogpVtSIxvvknEh/270hkjisUibH0ZDjm97SFm4X8lZmEIjGWHA/DJG8r9HKQPxpDKBLjk6NhGOBiQuRXJBIz+PhIKDpb6uBdgqih+vUtdNWwfJj8KWsiMYOPj4ZClc/Fj5Pk9woSiRl8808kygUi/DWzq9zVtURiBp///RRKPC72z/OFtipZlTNZ7LybhB8vx2LffF+iqCQAyC2txtTtgdBWVcL++a3TTwqlPUDFG8objau5No6+44+ozFKsJ6gABQA+NvrYNccba85G4e9g+W8w+zkZY253W3x4JFRq9SJZ+NkZYNNkD/x0JQ7BKfJHF7hb6mDzFE98/vdTRBCY43Y01sLmKZ5YeiIcUZnyr2+lr47Nkz3x1akIxBOkdhhpqeCnSR5YfSaKyEBZR00JGyd0xnfno5FOkNqipszDd+Pc8OPlWGQ2EV2iwudh3Rg3bLoaR1Sxh8flYMVIF2y5kUBUHYvL5eKLIc7YfidJqnnynO422HUvmdj7ZmJXS/x5M1FqatHc7jbYfjsJlTVkqUfTfTsgIqOEqMIaAIzyMENsdimRvxNQ53tzMzaXOPWqe0cDPEzMJ/e9sdJDWHox8fqOxppEv6162KdNKbOqNqXK56FaRuQZn8uRmbrJtCBtStYNC1vxJrdMACMWlaZSCipgpa9GHPkTnVUKOyNN4jSGkNQidDTSlBrREJhUiI5GmsSRRXfj8/+LcCOLLLoTlwdHYy1icepKVDZ6OxoRV6k6F54NLgfEfj3/hDxHTpmAWLw6HpwOFT6PuOLO4Udp4ACY5it/xAcA7HuQAqFYjAU9ydKddtxNRmWNEB/1l99jBQC23kpESVUtsVfPbzcSUFAuwNoxnYjW/+lKLLJKqvDjJA8i8W3Dxbprj9+nd5G7RD3DMPj9RhzSCiuxfZa33B4zDFNXHSy5oBx75sofMSMWM1h2MhyRmaVYPboTUdRTc+y9n4zfbyTg8AJ/qQJyc6QXVmLytofo0dEAf83q2iopXRRKe4GKN5Q3HgcTLawc6YpzTzOx6kwUkX+Ln50Bds7xwb9hz3GSIAJkRGczrBndCQv3BxM9YR/qZoaZ/taYvy+Y6CZtcCdTLB/mjIA9j4mesA90NcH7/Tri5ytxKCAQGPo5GyOghy3eO/iEyFukr5Mxpvl2wMdHQ4nSi3o7GmGMpzk+//sp0fffy8EIgzuZYOW/Tadv9ehoiP7Oxlh77pncbQN1kRvd7A2I09O62RvAs4Mu/pJSGaqbvQE6mWtLjc5pDl9bfdgaaUqNjvGx0YeVvjpOEZZO72qth8KKGlyOIvP+8bbWR1ZJNe4Rlsz26qAHe0MNhKSRpV55WOqiIwsBxd1CBzVCMbKKycp1O5poIaukmlics9RTQ3ZpNVHqH1An3hSyEG9UlHgyhTsuV3bkjZhhIOueSiAUNet5w6rSVGk1K7Pi1PwK2LKoNBWVyc7vJi6nDD3spQsTsdmlGNzJhLj9h0n5GEsoPADAqdDnGMCiStWRx2nwtNIluvGuKw+ejFndbIjWF4kZ/HU7EYv62BNVV6quFeH3G/FYMsiRSNwrqazFL9fi8PUIF6KoneySavxyLR7rxrrJHbEBAEl55fjtejx+mOhB7DPzx60E/DKlC1Fk24OEfOy4k4Qt072gTuBpdTkqGwcepmLbLLLKUMcfpyE2pww75/gQRYLsupeMg4Hp2DG7K3TU5V//5ytxuBWbi1+nekFfQz7hhWEYrD4bhUfJhTi0wB+GmopNQWIYBpuuxmHrrUQcWegHd0v5o7KAurLnE/96gL5OxvhqGNk4p1BeJ+gIp7wV2Bhq4Ni73XArNg/LTzXtX9Ic3ewN8H7fjljxbyRRisgkbyt8PtgRc3YHITpLfn+PWf7WmNPNGrN3ByGrRP6n5NP9OmComwlxCfFFfeygqsTFIsIKVp8OcoSnlS7WniUzUP5iaF2e96YrZALHV8NdkFlSRZw+9M0IV4SkFeOilPSzb0a64E5sHu4Qeqd8NdwFJ59kEHu/fDHECfsepCBXSvTP4oGO2H0vGSUEJZ05HA7e7W2H3feSm/zuORwO5vWwxZ77yUTiGIfDwRQfK+LUKS6Xg1Ee5sSpUzwuB1YG6rgeTfbdKfO5UObzcJ8wdUpNmQdzHVWEZRQTra+noQxvaz1i8chUWxU+1npE8woA6GsowdVMG9U1ZJFTaspcmdVnlHlcdJThU8EBZH4uFjNwMJH+eY2QIY7qAOrSctwJ0kHqKayoQWeCkr/1xOWUwZMwqgQAbsbmwU3GjdPFyGypJcSbQyRmcCE8Gz6EqRCl1bW4HZtHXGUq9b9qeOO8yMSjJ6lFSCusxHjC9S9EZKFWxGA0YXWkg4GpMNBQwdBOpkTrb7kZDzcLHfQjrNrz7flnGOBijO4yxD1piMUMlp4Mx1RfK3SVYYYtjaoaET49FoYP+3UkurHPK6vG2nPP8M1IFyI/qMS8cqw4HYnNkz3Q0Vj++eFxSiFWnXmG93rbE4mzFyKysPlqHHbP9UYHgspUu+8l49CjVByY7yt3WXWGYbD+YgyuPcvB4YV+MNUhN2OX1v7GS7E4EpSGgwv84Eo4v4SlF2PStoeY6tMBq0a5EgmkFMrrBhVvKG8NVvrqOP5uNzxOLcRnx8OInjJ372iI7bO88fU/kUQeLnN72OKd3naYtSuIKAXo00GO6OtkhDm7g+S+CWdbQpzL5eKnSR4oqxZi7Vn5I0x4XA6WD3fB7bg87CMQUFT4PPw2tQuuPMvGbQKBREOFj58memDb7UQk5sp/k6uvoYwVI12w6kxUkxEOxlqq+HyIE1b+G0mU/mNjqIHZ3ayxjrB0eGdLXZhqq2Dw5jtNpk/52xnAzUIHuwgrQw3pZAo+j4Pz4VlNfj7SwwwlVULcTSCLfpnQ1RLBKUVILaggWn+0hzmuRGWjilBAqCsZLr8vVT3d7Q3YmRZ30GPle6OixCUuF87ncZFRXIWMIrLIHz11ZQSlFKKYMPJHlc/DY1klXTl1pbClUStmkCJj3FTUiJBTIj1isLBCgGICUbOepPwKEGbcAQDCn5dAj+Cpej2Rz0tgT1B6GaiL7IjIKJFaaaqgXIC4nDLiSlNPM4ohYhjilKUrUTnoaKxJZDILAH8HZ6C/szFx1MCeBymY6mNFFLXBMAz+vJWId3rbEUUDVAiE+PNWIj4f4kh0U5paUIH9D1OJqzPdi8/H7dg8fD2czKT44KNUZJVU43MCg10A2Ho7AdYGGnivj73c64rFDJYcfwpXM21MJ0gXqxAI8d6BJxjXxQKDCISz9MJKvHfgCb4a4UJkvvsktRCf//0Uv07tQiTs/hOagZ+vxGJPgC+R8LT5WjxOhz7H4YX+RD5HsmAYBuvOReN06HMce8cfDiZkwvn9hHzM3PkInwxwwKeDHInNzCmU1w0q3lDeKkx1VHHsnW6IzirDR0dCUSOUX8Dp6WCIv2Z2xfJTEThL8KT//b72mNjVEjN3PpK7Qg+Hw8G6MW7ooK+BBfsfyy0SsC0hrq7Mx/ZZXXE+IktqeWpZGGqq4I/pXth4KRYhBOW17Yw0sahvR3x2PAx5ZfKnb/nZGWC8lyWW/B1OJN6N9bSAr60+tt1ObPLzmf7W0FJVIhKnAODD/g6IzirDdULz3M6WOiiuqkWvH24iMOllIWHxQAfsIYy+4XE58LfVx5LjYUjIeflGWoXPwwy/DsSpWYaaKhjgYozjBL5SANDJXBvG2qq4GUt27Ho7GiGtoBIp+WTiUXd7AwQmFRD75nSx0mUl3jgYayGWVcUpctNiPo8LHTUlFFTI/5sE6qpN1QjFUqO2+FzZ1aaYZgyLBbVimdWmKmpELD1vWKZNFVQSl28uFwiRUlBJnDYV+bwE2mp8qZWuHiUXwtFES+6Ui3puROeir6OR3F4f9ZwLzySOuhGJGZx4koEphEbFWSVVuBqVg9ndbIjWvxWXh7yyauLt77mfDBsDdeKomQ0XYzDeywLOpvKPDUGtCOvOPcOSwY4w1pY/6iKjqBKnQp5jw3h3ospEd+LysOtuMlaOdCUaO9vuJCG1oBKrx8hfEpthGHx5IhyGmir4Yoj8wlOFQIiF+4Mx3N0Ms/zlLy2fnF+BBfuCsXyYMwa6yp+ueDMmF1+disRfs7oSReT9eSsBBwNTcWiBH3F1NWmIxQxW/BuJy1HZOP5uN2JR9lJkNhbuD8baMZ0Q0MNWoX2kUNo7VLyhvHUYaangyDv+SC+qxKKDT4hC/Xs7GuHPGV5YejJcaiSCNDgcDpYOdUJ/F2MsOxEutQSzNPg8Ln6f1gViBvjoSKjcIkTDEuI77jbtkSILK311/DnDC+vOPcNjAgNlbxt9fDbYER8cCiHyyZjU1RL+dgbE/jWLBzqgvLoW2+7Iv+8cDgfLhjpj74MUPGpCHOFxOfh+nBs2X41DMoEIoKOmhE8HOuLEkwwiYdHxv4v0smohZu58hI2XYhpFWPnZGcDdUge77sm/7wDQpYMexAww9Nd7uN5ElMoM/w54mFSABMIIkCk+Vvg7OINIWONw/kudCiNLndJU4cPPTp84+qY+rYTE1BsAPDvoIiKjhNh3xslUC/EEEWX1sC0XbqChjKIKwsib/7wwBFLGPK8ZzxuRGDJv0JrzvCmrZl9typjQsFgoEiO9sBI2hOJNbHYpDDVViM2Eg1OL0NVaT+rxe5hYQBx1AwDXY3LR34XML6eoogb3E/IxsrMZ0fp34vPAgEFvggpFQF3KUh8nI2Kj5T9vJiCghy2R10tJZd056vPBTkQRBY9TChGdXYZPBznKvS4A7LyXDGNtZSLxgWEYLD8VAScTLfQkOPbFlTX44sRTfDPSlUg8eJJaiN+ux+P3aV2IfGZ23k1GSFoRkcGwWMxg8bEwGGgqY+UoV7m3XVAuwNw9QZjsbYVZBKJhcEohPjwcgh8ndSaqzLX3QTLuxOXh4Hw/4ogYaYjEdePibnw+jr3rjw5SBOPmOB2agSXHw/Db1C5E1cMolNcdKt5Q3kr0NZRxaIE/tNWUsGD/Y6JUi75Oxvhjuhe+OPEUFyPkF3DWjnaDma4qZu8KklolSBpqyjzsmuONnJJqojLo9SXEf70WT1RC3N/OAF8Nd8aig0+arMDUHPN72sLTShefHA2VO1KBw+Hgu3HuSMwrx26CFCBVJR5+nuyJ32/EE3kPWemrY/FAByz/J6JJ82R3S11M8raSam7cHNN8rZCUX44DUkqTy0KJx4ESr+5CXyiuKx8+ess9pBX8P6Ji8UBHPEwqkHvMAXXCIZdT1/a7B57gl2txjfbRWEsVIzubYe8DsuibXg5G4HM5uBlL5j0z2sMcN2JziTydgLrUKdKoJx6XA3878tQpeyNNcDlAXA6Z8OVookm8LlAXeSNvJGBD9DSUiSNv1P67uZUWScjjcmTOE2KGgax7rOaqTVUIhETRAfXklglgrEXmCZFZXA0OBzDXJVv/WWYpXM3JzYrPPs2Euwy/icAkcvEms7gK8Tll6EMonlyKyoaruQ6xeHL8cTomdrUkityorhXh8KM0BHS3Idp2UHIBYrLKMKub/OIHABwITMGQTqZEKTdiMYO1Z59hopcF0bhML6zElhsJWDzQiejYnXiSgbicMnw1Qv50K4Zh8PU/kXC30MFUgoil4soafHwkDJ8PcYIHQdTJg8T8OhPdmV2JUu1+uhKL+Jwy/DHdS+5UuUqBEAv2BcPNQoeoslZsdhnWnI3CV8NdMLKz/NFqhx+l4efLcVg2zIXVnNIUQpG47oFfaiGOvdONOBVrx50krDsXjb0BPkRRSRTKmwAVbyhvLTpqSlg31g01IgZz9gQRVUHq52yMLdO7YO+DFFyMkO+JP5fLwffj3GFtoI45ex7LvX1ddWX8NcsLp8My8cu1eLnWBf5fQvxgYCqeEqRrzPS3xiBXE7xzIFhu8YvD4eCHiZ2RUVSF367L33cdNSX8OrULfr4Sh0iC8ueeVrpY2MsOS44/JYpwmdfDFurKPPxxs+n0qc+HOCE6qwzn5RT1gDqB5JsRrvj1Wpzc5Zf5XG6jiiQCoRhxOeUYtPk2Tv9nsu1rqw9lPhe7CNKbBEIRlP+7IBWK6/wc5u8LRkWDsRvQ3QYxWWUoJoiq4nE5mORthWOP5U/JA4COxproaKSJK1Fk0TMDXIzxOKWQKK0MYOd7w+Ny0NmSPHWqo7EW8soExCW76yJvyNKmAHblwuujYqSVC+c3I940lzaVVlgpsxJXuUAILcJqUwzDILdUQJw2lVxQASs9deK0omdZZXAxI3tCfismB1GZpUgvbvp7zysTICGvHP52ZGbDN2Jy0dVaj6hKDvBfyhRh1E1BuQDXo3MxqStZytLlqGzYGWqgmz2ZcPXXrUS838+eKPIjv1yAP28lYrofWWnv02HPUVAuwIJeZKW915x9htEe5kQmw7ll1Vh37hm+HesOHTX59/3fsEwEJhVg/fjOxOlOLmZamNfDRu5tZxZX4aPDoVgx0pUo3ehceCYOBKZi5xwfuUtqi8QMPj0eBjsjDfw8yUNuj6P0wkrM3v0IA1xMMIMgWupUSAa+O/8MuwN8WJmfN0WtSIxPjoUhPL0YRxf6E5kfMwyDHy/H4K/bidg3zxe+tuTRgBTK6w4VbyhvNZoqfOwL8IUKn4tZux4Rldrt72zynxAQLnepYz6Pi9+mdYG2Kh/z98rvYWOuq45983yx90EKDhJEagzuZIq+TkaYvy9Y7hs3DoeDNaPd4GiihW/+iZA7ykRLVQlbZ3phx90k3CbwKelqrYf3+9rj4yOhjcSDlvJRfwcAwO835BeP+DwuNozvjO13Epus8KOjpoRvRrhg7dlnKCOIAuntaISu1nr45Zp8lbWUeBy8eMknEjMQCMX44kQ4PjwcgrLqWiwe6Ig991Pkjr6prhWj4QZqhGLci8/H8F/vSoyG3S11weVwcIzQu2ZSV0vklQmQXUJmnjvKwwz34skidyz11NHRWBO34siib7rbG+JxciGRIAjUpU6RCKlA3Zgz01FFHGHFqTrPG/LIG3118nLhXC4HynyuVBGYy2ku8kZ62hTDMDj5JAOPkgqlzlHlAiE0CMoQ169bVSsijrxJLaiQ6jfTEp5lkZUJT8wrxzsHQgAAlYKmj3tgUgGcTbXlvhGt50ZMLvo7k/m15JVV42l6CUYQijfnw7Mwtos5UdoNwzDYdjsJ47wsiFKWojJL8CCpAJO8yYSjrbcS0c3OAF4dyCo0/XApFkuHOROla117loPg1EIsHSZ/5AcArDwdhT5OxhhEEBXxvLgKK/6NxPrx7kRpgPsepCDieQl+nOgh9/cmEIqw+kwUBrgYY5qv/N9baFoRlp0Ix9YZXjIr50nju/PRiM8pxzcjXOX+3vLLBZi16xGGdjLFJwMc5N72+fAsfHM6Ettne8PHhkyolYZAKML7h0KQnFeBnXN9iPyTRGIGX5+OxD8hz3H8vW5wY1HZj0J5E6DiDeWtR02Zhx2zvaGvrowZOwOJnh4PdDXBr1M9sfhoGK4+k++pvwqfh22zukLMMFh08IncN36OJlrYNccb31+IJkqBmt/TlriEuDKfi+XDXPAgqQDbCTxknE21sX68O1aeiSJK2Xi/X0cYaanguwvRcq+rzOdi02QP7LibRBTt4Gahg1n+1lh2KqJJ750xnuawN9LEpqtkpc2/HuGKo4/TkSCHjwmfxwWkXLTWihhcicrBwE23ocTjwtNKV27Po+paEcQvDM8akRgZRZUY9utdSZn0eT1tsP9hKpF/i6W+OnTVlXEyJEPudQFgZGdznAvPQkE5WQrPeC8LhBKYaQN1qUvG2ioIJyz57cnWtNhEC3GEfkOWemrIKqkm9tzR11RGIUEqXj2qfG6dONgEfC632bQpaQ+qb8XmobJGBJGYwS0p6Xjl1eRpU3llAijzudBWI1s/JZ/crFgkZhCbLb94U1JZi1k7H6Hmv+86SIp32dP0YnQjjLqpqhGhukZELN5cjMyGu4U2zHTkK3EM1IkvBx+lEqd7PU4pwvPiKmI/ja23EjHF24oo7SarpAqHHqViyWAyr5odd5NgoqOKUQRpM1U1Iqw+G4WlQ52JDKovRGQhKKUQqwm8XsRiBp8ff4rhbmYYTFDdKeJ5MfY+SMFv07pAj6Dva88+Q0FFDdaOlt/gOLO4Cu8ceIIlg52IPH523UvGv2HPsTfAV+6+l1XXYs7uIHS21MWqUfL3/dqzHHz+91P8Md0LPQhS9GRRXSvCeweeIKe0GocX+hGNqRqhGJ8cDUVgUgH+XtQd9oQGxxTKmwQVbygU1PmgbJ3ZFVZ66pi6PZCoktHgTqbYPMUTHx8JbdLMVRbqynzsmuuDvHIBPj0WJrcPjLeNPn6Z4oklx8MQlCyfiTDbEuJGWirYPssbv16Pxy2CCJoxnhbobm+A9w+FyC1c8bgc/DLFE4GJBUSVv1zMtPFRfwesPhNFVN7700GOyCmtxqGgl9N8OBwO1o11w5GgNKLUro7Gmpjm2wHfnm+5MMXnvhx505AakRi5pQKM//M+PCx1sPd+ilxipaBW1GTVHxEDVNaIMG/vY/x1KwED/zMovSKnkFnPVB8rHHucTmRIbaWvDg8rXVwgEDIBwNfWACdDnsv9OwDqvnM3c23cIyyX7mmlCyU+hyiFEwC8rXVRQDB3AYCptir01ZWRWUIWfcMm8gaoE9GlpU3xeByIZET2iRk0mTYlEjNYfTYKDAAGkBrJVlFDnjZVnzJFWqa2XCBER2My8SYlvwJeHfRgK0d0iVAkxoL9j5FX/v/vKrdUgNzSlyPdbsTmohuhAHI/IR8ZxVVEUQgAcO5pFoa6kUXdhKUXI6u4GsMI19/7IJm4PHhyfgWuPMvBwt5kKUtbbiRggLOJxABdHnJKq/HX7USsGOFCVFr8j5sJMNRUwRSCiKGiihqs/DcSq0a5woBAtDr0KA0CoQgrCISfcoEQHx0OxSRvK6LIkb+D03EhIgu/TvWEqpzfeWVNXWWpAc7GCCBI1boUmYWfr8Ri5xxvuQ18q2tFeGf/ExhoquAnglSru/F5+OhIKDZN9kA/QpFVGlU1IizYF4ySqlocXOBHFL1Xf2xTCirw97vdYKErv5BLobyJUPGG8sZRn74hL8r8uipOzmZamLL9IbIJbmKGupli02QPfHg4FDdj5BMytFWVsH+eH+JyyrD2XJTcN66DO5lixUhXLNj3WO6SwWxLiLtb6mD9eHd8fCQUSXnyP/lfNaoThCIxvjv/TO51zXTVsHSYM776JwLphfJ7drzb2w7aqnz8dDlW7nXVlfn4bpw79txPbnK8dDTWxPyetvjmdCREBGLAJwMcEJpW3GJRrCUGicp8LnTVleFjow8vaz25om8EQrFMYVEoZrDpWjw+PByKGX4dsIfAUBoABriYoEIgbLLceUsY7WGOs4RVpzpb6EBViUdUSQ0AenQ0Iva9MdFWRUF5DXHkjqmOGgKTybbN53GhzOcis5gsXc1QUxkV1WSiEwDYGmpIFW+5qDN0lvYb4nIAkyaqPf0TmtEo/S4qs7TJqCoVJR40ScWbcgHMCTwc6glOLSQ274zKKkWFQCiXX86as1EIzyhpJE6qKfNeir7JKa1GSn4FsbfE9f9SpkhEraySKoSkFWGYu/wRGABwPDgdozzNoUaQCve8uArXnuViJoFvCABsu52IUZ3Nib7TtIJKnHiSQVwh6ucrsejnbAxvAgEjKa8cO+8l4duxbkTCz+834tHPyRijCcq6x2aX4fsL0fhquIvcVd8YhsFXpyJgpa+ORX3s5d525PMSrPw3Cr9N6yL3dyYWM/j876fQUOFj7Rg3ucd6SFoRlhx/il+meKKLnClyIjGDxUfDUC0U4a+ZXjIN2ZviUVIB1l+IwYYJ7hjmTiZySqNCIMTcPUGoEYmxf74fke9TSWUtPv/7KaprRTiy0J9IEKRQ3lSoeEN543jvwBOiSAeg7gZm02RPDHIxwfQdgUQGnsPczfDjpM54/1CI3JEo+hrKOLjAD0/Ti7H23DO5RZRpvh0wv6cdAvYGyd13tiXEx3haYJpfByzcL3/6laoSD1tndMU/oc9xhiCCZkgnU4zxNMcnR+Uvnc7ncbFqdCccepTWZPnv5ujjaARPS12sOhPV5Ocf9nOAoaYyjj6W3wNGT0MZnwxwwPcXolErJSqhIXye9ItHFT4Xmip8fDnECQ+W9UdfZ2MsHuiAfQ9SWhwxUVkjQnMjUigS41JUNgy1VBCVWYqIDPl/i8p8LiZ0tSQ6ZgAw3N0MIWlFRJXQuFwOBjgb49ozUt8bA4SlFRNVsAPqom+eppPNX44mWqwrTpH63uiqKyOrieiNllJUUSv1mPF5XCTklkPaL7tWJEZ+eeMxXF0rwvoLMY3Kj4sZpkmD9NT8CmgQRFkAQG5pNVGaBlB3A8amTHh0Vilc5EiZOhqUhqOP018qyV5dK3pJcAxMKoCruTaR2TDDMLgRk4MBLmRP88+HZ8HXVp/IR6iyRoizT7OIokcA4MDDVPRzJisPnl1SjVOhz7GoL1nUzS/X4zCyszlRtFLU8xKceZqJZQRVihiGwaarcXinlx2Rn8jNmFz8/SQDnxGUNRcIRVh8LAzzetoQiU7Hg9PxILEAmyZ7yi06FVXU4L2DT/Bh/45EZbV/vR6P8IwS/DWzq9ziSUp+BRbsC8aXQ5zkThNjGAY/XY7F8+JK7JnrI3eEWEhaEebvC8bsbtYY42kh17rNUVpdi0+OhkKJx8W+AF+5xTigbk6dsv0heFwO9s3zhRaB+FPP5Sj5i0ZQKO0dKt5Q3jhm+HXAtO2BeJBIlrrA43KwdKgzenQ0wuS/HiIlX/5InpGdzbFxYmf8fCVObjNeE21V/D7NCxcjs7CZwC/l4wEdMa6LBebsDpLbv8dCVw275njj12vxuPZM/rSTL4c4w1JPHYuPyp/61cFAHZsme+KrUxFy+bzU880IV5QLhPiVoHqVvZEmvhjihM9PPCUyP/5qhAseJRc26TmkpszDdL8O2HgpBvkEPiyzulnDREu1RUIGn/vylM7ncsDlAO/3scejrwZgfi87iSFiV2v5om9kHRul/7bT28EIJxd1x2RvK0zwsiSOvpnsbYVLUdlEHlRGWirwtzPA+XCyC7cBLia4HpNDVOrd2kAdRloqeJJK5pvjYaWLsHSydR2MNVFYUUM0zgB2Faf0NZRRWEFWpQsAVJW4MkuFA5A6p4jFeMnzZv/DlJfSz8QMcCcuH4kvRAeWC4RENxlAnecNeZnwKogZwEKPLB1AnjLhQcmF+OZ0JGpFLx9DMQPcjW98vgxMKiBOmYrKLEV5tRB+hFE758KzMIogggMALkRkw0JXDZ0t5RchqmpEOPo4DXO72xJte8fdJPRzMkJHY/mrf8XnluF8eBYWD5TfcJZhGPxwOQYf93cgEp3OR2QhMKkQCwhSvcqqa/H1PxH4ergLURWhzVfjweUAnwyQP9ooLqcMa84+wy9TPOU2OBaJGXxyLAyuZtp4v6/8ETvnwjOx614yds3xkdvLpbCiBhsuxWBcFwvM7SH/WPvxcizOPM3EtlnecqcjRT4vwdzdQfhyqBOm+pJVM5NGvZeWujIfO+d4E0W+pRVUYuJfD+Fqro3Nkz2JTLeBut/E1luJ+OGS/BHVFEp7h4o3lDeOmd1ssGKUKxbsCyYy8AXqnr6v/R97XxUYxdl/fWYl7u7u7iHBHYq7O8Xa0pYadaNQpYYUd3d3LcTd3d096/NdLOmfkt1knuG9+NruuWpJnt3Z2ZnN/s5zZIo3JvhZYvauaIWNQv1hsr8VVgx2xNpjSXiST0Yk2Rpp4djKcByNLcOuR4rrqJWBoihsGO0OVzNdrDgUT6wA8LMxwG/zA7H+RDJx8w2XQ+G3eYEobujEjgcFRGsBefDzogh7rDmaREyiaPC5+G1eIPb+WczKbrM00gFW+prYzCL82ERHHZ9M8MLnlzMUqo5GeJgjwtmY1WPzuRwsHeiArXfy+q2w5j+nvFHjUuBzKSyOsIeNoSYczXQUhrK+PcoN8SVNjNQ3XQquJQrywXlqkDXubhiKg8vD/qqYXTrQAVfTqxXmafQHFzMd+Nvo42JKJfFaQH7/sVFxAcAgFxPUtApQwCL8l6IoRDgbsyaPXya0WFudBxtDzZdqnKpkqbwx0lZDc5eIVU4RILcudfdD3kiUkTcvVIW3dovxy938XgoTQJ7n/fxnk1RGo0skZW+bamdfE17a2AUbQ01GdkdFyGbYNFXe1IXlB+OVnr+e33m+fS6mqIl14O/9nDoMcTMlViP0HEdmVSvGsQitBYDT8eWYHWrLyq51KaUSFnoarKrRmzpFuJ1Zg3XDXIjXAsAvd/KxLNKBFflyN7sO6ZVtWBhBbvXqEErw9dUsfDLBk5W95bubOXAw0cacUHKlU1xxEw5FleCXOQHE10q3SIrXjiVh+UBHDHIlD9r95W4eKpq68NNs8maq9IpWHIwqwa9zA+BuQUbUCcRSvHo4ARSAj1g0eu39swgn48txZEUYrAgzYHJr2rFoXyxeH+GCxREOxM/dF5o6RZi3JwZmehr4YZYfK9Ilt6YdM/+IwkhPM/w405/IDvo8pDIan1/OxP6nxdg+P4jVY6igwv/PUJE3KvwrMTvE9q8A31PxvcNkmYCiKHz0iifmhtpi7u4YZFW1ET/G1ABrfDPNB6uOJCCKMMTUxUwXh5eHYfuDAuIacC6Hwi9zA8DjcvD68SRiK9FID3NsGOPOqkJcX5OPPYtDcDCqhFWI8Duj3WCio4ZN18htYx4WevjoFQ+8fSqFuAabw6Hw4yx/XEqpwqM88qrpGUHWcDHTwQ9Kdno+n+SNWxk1rIilER5m8LHWx2/91JrzuHL1Ao9DYWawDZ5+MAKfTfLG68NdsfV2rsIQ3iB7Q2ip8Ri1hXWJ/49Q0+BxoKXGxWgvc7ia6eC76X5weqEJwtlUB9MCrHGBJQEzJ9QOJ+PKWSlgxvpYILemHcUslHOaalwMcjHB3Wz21im2uTe+1vovVZXuZq6LfJbWqZexTRlpq0Eqo9HOMvdGk89V2jbVr/LmBfJmx4MCpb8rkdG4lFKFunb5+e0UyY+XbdtUXbsAZgrydpiguLGTtWWqoUOIunYhPPohbzqFEizeH6uUGOuBJp+L+BK54qumVYDSxk6EOrJrmrr3EhXhV9OqEelswsqKVlTfgZTyFkwLJLeC0DSNpwUNWDHIkRXxczCqBI6m2vC3NSBem1HZins5taxUGCKJDJuvZ+Pt0W6syJdf7uTB0UQbUwLIlU4xRY04n1SJb6f7EZ+zdoEYG06n4L2x7nA1J1cqfXE5EwZafFZKpXvZtbiXXYc/FgUTW3Lq2gR/BRSP9CSrQ5fJaLx9KgU0TePnOQHgEpIT5xIr8OvdfBxaFtbrb21/KKrvwIK9sVga6YhVQ8iVRn2hvl2Iubuj4WiijR0LgqDOIyduksqaMXtXNBYOsMdnE71Y5S4BclJvzdFERBU24sK6yH4/H1VQ4Z8IFXmjwr8WY7wtsH9pKDZdy8bOh4WsBkCKorBhjDuWD3LEvD0xxEoUAJgWaIOvp/jg1cMJiCYc6Hys9XFgWSi2XM/GhWSy6mQNvrwCvbKlGx9dSCd+/S9TIe5ipoPvZ/rhg3NpxPlDPC4Hv80NRFxxEzFpBQALB9jDx1ofX7AIXrY10sLHEzzxwdk0tHaTvWaKovDNVF+cTaxAYmnvsFsrA028OcoVn1zMIG7VoigKn0zwwtGY0j4DoT0tdbFsoCMevDsMm6f7wUxPLmOfHmQNDkXhbKLia+itUa44HF3Sb722QCwDBbktaeN4DyR8Mgq/zw9ES7cY95QEdE/ws8TuR0Ws2rwm+FrCUJvPqrpbX5OPoe6muJnB3jp1l7A1rgcRzsZIr2wlvm8AOYngZq7L3jplroNclsoba0NNVLSws01pqXGhxuOgsZOdZasv2xSvX/IGf33Zr2kVYP/TYoWqmx5wOBT2/im38/Uo/Nhn3rC3TZU2dMKBsGGmB9nVbbA31urX7rXlRjZKGrr6tbGKpNK//j5FFzXAx1qfFRlQ3y5ERmUrhrmzI29uZrC3TF1Nq8KCAXasKoljiprwZ0EDq+fuEEpwKKoEa1gOxVvv5GFhuD0r29Gx2FJwORTmsVC+5NS04UhMKb5mEbbbLZJi47k0vDPGnbglCZBXczsYa2NppAPx2mupVUivbMFv8wKJ1RnFDZ1461QK1g5zghshaSQQS/HqkUREuhhjDYtw5C03spFd3Ya9S0KJlSl3s2rxycUM7FoUDF9CS2B5UxcW7I3FzGAbrB/JThmmDDWt8nwaL0s9/Do3gJWK8HFePRbtjcWG0W5YP9KVdXNfY4cQ8/fGoLVLjLNrIlgHwaugwv/vUJE3KvyrMcDJGCdeHYA/8+ux+UY2a0n/a8NdsH6kKxbujUWCgsG8P8wItsEXk72x8lA8sfIi2N4IuxaF4OMLGbiVSWYD09fk49DyMDwtaMRPt8nyc162QnykpzleG+6C1UcSiTM4zPQ0sGW6HzZfzyG2kFAUhe+m+yKrqg3HYslVV3NDbeFuoYstLCxODibaWD/SFRvPpUOoIGB42UBHcCkKe5+QB0K7W+hiZrANNl/PUfo7Zroa+HSiVy/pPY/LwYYxbvj1br7CATnIzhChDkbY3U/2zYqBDvh9fiCiN47A0oGO0FLjQZ3HxbKBjtj9WLG9b7CrfBedjQpLU40LZ1MdnE4gIy57MNXfCmcTK1gRtyM8TMGlwCo/xlJfE/ZGWogvZtdYFWBrgGSW1ik3M11WNk8AsDXUQnWLgFipB8jvO+Nn1ik20OArrwrvUdX0rbyR//cPt3JAoe8v/yKJDIejS9AuEKNTKIGWGvcvdQ8p6juExHkbPShp7II9S+VNVhUzy9TSSAe8OdIVwfaGUOdxwONQCi0qUhnwOF+uOIwpbGKddxNd2IBRnmaszklxQyfKmrowikXQsUQqw9GYMgx1Iw+eBeT14PPC7FjZPU7ElsHRRBsRzuTnLLG0GbFFjVjDInelpUuEX+7m4+MJnsQkhkxG45MLGVg60IGV8uWXu3kw1FZjRb7czapBemUrfpjlR6ywKG7oxAfn07FhtBss9clsQ10iCdYcScScEFtM8idTZ9E0jQ/OpYFLAZun+RITDIeiSnAuqRIHl4URk4txxU1Yf1Je6R3pQmYRq2rpwuvHkzDW2wIfjCMPlO4LlS3dmLM7GsF2hvhpdgArm9P19Gp8dikD30zzxRIW11IPyhq7sPRAHNzNdXF4RRiranIVVPinQEXeqPCvh4+1Pr6Z5osb6TV472waq8EEkCtRPpnohdePJrHKs5gVYovPJ3lj5aEExBEOdYNcTfDr3AD8ejcPf+aTWXrM9TRwaHkYjsWW4lBUCdHal60QXzfMGYF2Blh3NIlYbRLmaIS3R7vitWNJxKG1Rjrq+GKKNzZfzybO/6AoCt9O98WTggZisgwAVg52BI/L+Wtn/3nwuRx8M80H2+4XsKo13zDaDbHFjXhKaMEDgFd8LOVtZkrUTG+NcsWR6NI+yYqxPpaY6GfV60va/HA7ZFe3I0mBQoaiKCwb6IADT0tYkSjzwuxwObWqV/gsEwz3NENViwDZ1eRkhoW+JgQSGR7mklvoAGCcjwXrqvMQB0M0dbAjQdwt5I1TMhn555yFvgZkNI3adnbqGUMtNTSyPG4NHhcCZW1TTJQ3FIWi+g6cT6qEiMFnvFRG43hsGdoF7MOKhRIpWrrErG1TpY2dcDBhtztc2tgJT4v+yRsXM128NdoN59ZGIuurcbj8+iCM8TSHnZEmjLXVQEFumaIooLC+Ax1CCQobOjCQcEjswfX0GvhYkYcFA8DV1CoE2xuxGrwe5taDy6FYtQaVN3XhQU49q3pwoUSKPX8WYd0wZ1aD8U+3c7FsoCNMWFQh/36/AH42+hjGgrA6l1SBypZurB9BbjtKLW/G4/x6fD/Dj5j0rGsX4P1z6Vg7zJmYfBFKpHj9eBLmhNpilBd5Q9MH59JhoMXHRhZZMzseFiK+uAl/LAomJvhuZ9bgu5s52LM4BA4mZGRtdnUrVh1OwKcTvYgrvevaBVi4Nw7B9ob4fJLX/5S4KW3sxPKD8RjkYoLvWFwHAHAirgzvnknFZ5O8MJWF1bEHqeUtmL7zKcIcjbF5mi/rkGMVVPinQEXeqPCfgKOJNs6tjURGZSvWHE1iZeEAgDmhtnhnrDtWHkogrgEHgNmhtvh4gic+upCO+BIyAme0lwVWDXHGmiOJSCBc62Km81cNOGkDz/MV4ooIib5AURS+n+mHDqEEX11VXKXdF14d7ARvKz28fTqFWDUV6WyCZQMdsP5EMvH7bWmgiXfHuOPjC+n9WoleBJ/Lwfcz/LDncaHCwNsQByPMCrHBH4RB1ABgrKOO9SNc8fXVLOI2Lw6Hwnvj3LHjYaFCIiTQzhBhjkbYwyD75kXoafAxL8wWux8pXjs90AaVLd2IZaFE8bHWh6OJNq6lkSt3tNR4GO1lzjq4eJSnOe5msbNOeVvp92rwIVl7Lb2a+D0GACcTbdA0jXoWJAqfy8EIDzNUsbRO+droKwy1ZgIzPXWlO7ccDgV3C12l6j8+R676oSHPh4pwMkagnQG8LPXgbKoNDT4Hhlp8GGrxoaPOgzqPA5kMiC5shEAsgzfDxqYX0dAuxABHIxhrkw/eMhkNDT6XtfImobQZnpZkigkuh4KXlR6EUhkWhNsj8dPRiP5wJH6Y5YeFA+wRZGeIksZOJJe1IOhZ6DgJhBIp/syvxwiWFeFX0qowyZ9sQO3BqYRyzAy2YTVEHo0pxSgvM1gTBsACwLnEShho8TGKMP8EAKIKGpBR2YpXWbQ8FTd04mhMKT6ZQD6Ut3aJcTG5Ep9P8iLOehJJZPjgXDrGe1sQK3ZomsbGc+kY5GLCqqJ6y/Wcv9pASbH/aQnii5uwbX4QsULkdmYNdjwowJ4lIcQWydTyFrx9KgVbZ/v/FeTPFGWNXVi8Px5vjnTFPMJmqKZOERbujUWArQGra6QvFDd0Yu7uGIzxMsemqT6s8ml2PizE5uvZOLA0FCM8yO+dHtzPqcX8PTFYM9QZn75EVo4KKvyToCJvVPjPwFxPA6dXR6C5S4TF++NY5VEAcgXNtzP8sPZoEm6zUGbMC7PDykGOWH4gXmE2Sl+YGmiNjyZ4YtnBeOIsmSA7Qywf5IB3z6QSK4esDTSxf0ko7uXU4UY6GfmjpcbD7sXBuJ5eg2OxZBk2FEXhh1n+KG7oxDYW7VVvjXKDBp/LquVpSoAVQuyN8MnFDGLFiK+NPqYH2eKj8+kKSac3R7rhWno1q+tnSaQDzHTVcT6J3Eo0zM0Uzqba2KeEhHtrlBsO96O+UYZlAx1xP7dOYUCwphoX88LsWNeGzw21xYm4/qvSFWGyvxWupFaxUv2M9DTDn/n1Ci1w/WGAkxHyatuJyT8Af2Ux5NeRK4a01Hkw1FZj3TjVJpCgvIldaHG3SIqqVnZrRVJZn9ddYV0HlL2FArEULd1iOJvKSeoTqwbgwrqBuP7mYNx7ZxiMtdXxx8JgJH82BhlfjkXupvEo3PIKDi4PQ2u3CA0s1UK17UIUNXSyIgyq2wTIrGqFLYtcBoFYisL6TnhZkytcaJpGUmkzQhzkg6SFvgYm+lnh6yk+OLc2ErnV7fC11melRoorboKuBp+RnetF5Na0P7NMkQ9yde0CPMytw6xg8tyXLpEEJ+LY1YNLpDLselyItcOciYdGmqbxw+1crBriBH1N8myhQ1HFmPPM4kuK72/JSZAxXuTnesfDAlAUhbXDybNTjseVIbu6DV9P8SFeezOjBucSK7BtXhBxM1VsUSN+vJWLHQuDiO182VVt2HA6FT/N9oc3oaKsrLELKw7F45OJXhjnw0I1sy8Wk/yssHSgA9Ha1m4xFu2L/St78H9JaBTUtWP2rmhMDrDChtFuxKQQTdPYciMbe/8swolXByCcpT0TkCt3Xj+ejO9n+mPlYHICVAUV/qlQkTcq/Kegr8XH0RXh0FLjYs6umL8aR0gx2d8KP88JwJsnU3CVhSJgbpgd3h/vgaX74xVaTfrCgnB7vDHCBYv3x6GAcLgb4WGOL6d4Y/WRROL2LF8bfSwbKCd/SIObbQy1sHNBEE7ElSGumMxKoq/Jx84FwfjjUSGxZYz/LPz4QlIl7hAqKCiKwqZpPogrbmKl3HhnjBsqW7pxKqE36WCkrYYPx3vgyytZ6BKR2YHUeBwsGGCPb2/kEBOQFEXh3THuSCxtUmhFC7A1wAAnI1Yki5WBJib6WmKPktycxRH2eJBTz8ouNjnAGtnVbcipIW98G+xmgnaBmPg+AwAvSz3oa/IRU0SuGDLWUYe7hR6rtVwOBR9rfaSUtRCvBQBXM7l1ig1sDF6ucYrU4tgDDR63T4Ucl0NBosQKJrdNKX9skVQGdSVS+g6hlLVtqq6Nfd5NaUMnrA01WdVp59d2QEedBysWAbfFDZ1oF0rgo4T4iS5qZJXdAgD3suswwtOM1S7/1bQqjPQwZ9X6dSGpEqEORqyCcy8mV8HGUAuhDuRKox513CQ/8pDjR3n1oGk56U2KmKJGnE2sxBusLE8tOJdUga+m+IDDIbv2cmva8cejQvww0484mLa4oRObr2Xjx1n+0NciI6sqmrvw/tlUbJnhS/we17YJ8NrxZHw0wRNBdmTvcUOHEOtPJuPtUa7E5EtLlwhLD8Zhkr8VsWqmtVuMJfvjEWxviE8meBLdTx1CCZYeiIOlvgZ+mUMe6NwXsqvbMGdXDOaF2WHjOA/i+1wqo/Hh+XRcTa3GmTURSj+D+gNN09h6Oxff3sjBwWVhmODHTq2nggr/VKjIGxX+c9BUk7cwuZvrYNYf0ShrJK8SBuSZFjsWBOH9s2k4p6TFpy8sGmCP98a5Y8n+OOJQ3lVDnLEw3A4L9sairJFsGJ4dYos1Q52x5EAc8SA91tsCb492Y1UhHu5kjDkhtlh7NAmVLWTDoZeVHr6Y7I0t13OILR12xlrYNM0H759NJa5fNtFRxzfTfPDZpUzUtpGt1VbnYdNUH2y+no06BWtnBdvCQl8Dv97ru/5bEcZ4mcPVXAfbWaiRwp2MQVGUUtvWhtFuOPS0hJX65tUhTrieXo16BaSolYEmRnubE+cuAXICb4KvJU7Fk6tv1HlcjPexxJVU8tYpiqLkrVMsrVPyynB21qlAWwOkVrSwWutuocM6tFheF87ONmWkrYamTnaKRg0+F91KqsIBOXkjUyK9ebEq/EUIxVKoKyFJOgRi1jXh9e0CmL1EWDHbmvCs6lZ4WuqyIkkSSpvhZ62vtM43urARA1jshtM0jXs5tRjJoiKcpmlcTavGRBZDGE3TOJVQjjks2pZomsbBqGIsHejASkFwN7sWa4c5swoL/v5mLib6WRJfezIZjU3XsrBuuDMxcSiV0fjkYgZWD3Emzl6RSGV4/2wqlg10JB66JVIZ3j6VgjmhdsRZSmKpDG+cSMZEfytMJCTJRBIZPjqfjsn+llgYTkagCCVSrDmSCA9LPSwfREawCcRSvHo4Aa5mOvhkghf52kMJsNTXIFbNdIukWHEwHjrqPGybT65Q6gsZla2YtycGywY6sFLcCCVSvHEiCfElTTi7NoK46rwHYqkMX1zJxLmkSpxdE4EwRyNWj6OCCv9kqMgbFf6T4HM52Do7QC5JPRDPakcfAIZ7mGHP4hB8dikDp+LJm40WR8j/EC7aF4s0wkHt7dFueMXXEgv2xRCTEuuGOWOCryWW7I8jtnW8TIX4oggHjPWxwOojCegmzMaYHWKLQFt9vH48mTj8eEqANUZ4mOPzyxnEOSLjfCwxwsMMG8+lEVtvhnuYwcVUB8N/fNiLKONwKGya6oODT0tYhSp/OtELh6JKiMk7AHh3jDsORZcovG58bQwQ5mSMXSwyeTwt9RDmYIgj0YrtcSsGOiKjspVV+PCcUFtcSK5klVc1OcAKV9OqWYWVj/Iyx73sWla2q0hn47/ql0kRYGuAZJbKGzdzXdZ14TaGWsTkag/k5M3/vioc6FHeKH4PaBp9kzcSmVLyplMkha4GW/LmJWrCGztZkzfZ1e3wsmS3a51Y0oxgJSqT8qYu1LYJEMIi76awvgN1bUJEOpMHHWdWtaGuTYDhLIifxNJm1LcLMdabLMAWkBNVFnoamMyiHvxBbh2iC5swI8iGeO2NjBp5JgmLgOQLyZVo7hRjOQvFzvG4MrQJxFjLotlq/9NitAsleHMkudpnx8NCdAoleH+cO/naBwXQ1eDhs4lkJAgAbLqWhZo2Ad4nVInQtLyJSySV4YeZfkRrZTIa755JhVhK45c5gUSWSolUhtePJ0NG09g+P4hI3SQQS7H+ZDJoALsXhfxPQ3tTylswf08M1g1zxuss1F6dQgk+OJuGxg4RzqyJJA6q7kGHUILlB+NR0tCF8+siWbWkqaDCvwEq8kaF/yw4HArvjHHD9CBrzP4jmjhAuAcDXUxwYFkodj8uZmU3WTbQEW8+qyFPr2CeY0NRFD6b6IXBrqb49CJZsG7P8O9pqYflhxKIrDsvWyH+xSRvaPK5+IAFGfLpJG8IxDJsuUGeYfPlZC9UNHezCgr+YpI3sqrbWFVWT/K3QqdIiqE/PMDWO7l/G1A9LfWwOMKeVa6Ot5U+pvhbszoXvjb6GOFhht/vK1b9vDXKFUdjylDPonVoSaQjDseUKrymAu0M0C2WslKqhTkaIdTeCLczyVUwPUoCNu1PA5yM0NotRlY1OcEb5miE0qYuVLPIgfG3NUBebTs6WRBdrma6KKjtYEU4yZU3L0HedLFX3vRH3igjXqU0DWXzFU3TEEllSneh2wUSaKuzG3Tq2oWsm6ZKGjthz8LmAzyrCWcZspxY1owQe8W71dFFjfC3NWClRLqXXYeBLibQVCM/l1dSqzDay5zVwHk9vQbLBzqyWrv/aQl8bfSJ19I0je0PCrFyMPnzSmU0tt7JxesjXIjXdokk+OFWLj4Y70G8tqFDiB9u5uCLyd7Ea0saOvHznXx8P8OPeG1qeTOuplXj5zkBxGsf5tZh9+MifDaR/JjPJ1XgcmoV/lhI3g6170kxHufXY89ichLku1s5SKtoxd4lIUT3gkwmw8bz6aho7sK+JaFEa8VSGV4/ngQuRWH/UrK1/SGxtAnLDsRhw2g3rBrCrs5+wd5Y1LULsW9pKHFNeg/q2gSYsysaALBtfiDM9diR5iqo8G+AirxR4T8NiqLw+ghXvD/OA0v2x+F+Djt7RJijMX6a7Y9f7uZj50NycmDlYCe8McIV644nEgURUxSFr6f4QI3PJQ5h5nIobJ3jDy0+F5uuZhORMC9TIa7G42DHgmAklDRhF2GzkQafi50Lg3A2sYI4a0hHg49vp/th2/0C4vwTfS0+fpzlj613comtZkH2huBQ8lyOPx4VYcj3D/52nb01yg3lTV04l1RJ9LgA8M5YN/yZ38CKlNgw2h1nEitQqsA26GdjgEhnduqbSGdj2Bhq4owCoouiKCwf5IiDUSXE7WEURSHEwRCnEsgVblwOhVkhNriUQn6O1XlcjPG2QCyL7BpdDT58rfURVUD+/ljqa8BERx3phMHkAOBkqo1OkQTVhIo8QK68qWrpZtV0Zaj1csobYR+2KV4f5E1ftimxlAZNQ6lNqFMogY46eWAsICdvWGfesLRN0TSN7Oo24qYpQD5IFdZ3KG29iSlsRATLANHk8haM8CCvrKZpGg/z6lm1D3UIJTgZX4bRLIJ3yxq78DiPXT14XHET8mvbsYDQigMAF5PlVfazQ8htXnseF8PSQAOTWNjLtlzPQaSzCYa7k6mbZM/IptkhNghxILOodIukePtUKqYEWBJbrWrbBNhwOhVfTvGBixmZxSarqg2fXMzAr3MDYWtERpA+yKnD1jt52L0ohJggOBJTilPx5Ti4LJS4+v3bm7lo6xbj0PIwokwgiVSGt06moKpFgO9m+LHO71KE6MJGLN4Xh48neGIpC6VXbZsAs3dFw1xPHfuXhrI+toK6dkzbEQUPCz3sXxoKXQ12n9cqqPBvgYq8UUEFAAsH2OOHmf547VgyLiSTqwIAuc3h+Kvh2PNnEX6+k0e86/3qECcsH+iIhftikVnFfGDjcij8PDsA5noaWH4gnkhFo87jYteiICSXNRMrYZ6vECfNMTHVVcfuxSH47V4+HuSQVa7bG2vjp1n+2HguHYX1ZKGsvjb6eHu0K948mUxs+RrsaooRHuZ4/2waEfFgrqeOnl8XSWSoaxdi9ZFELN4Xi/KmLmir8/D5JC/selSIFsKwVzNdDawb7syqOtzFTAdT/K3wy11l6hs3HI0tJQ71pigKq4Y4Y++TIoU2pfE+lugUSvAwj+x9B4DpQTaIL25mZRUb5WmOW5m1rJqjBrqYsCJ+AGCctzlyWdgyKYpCgK0BsZ0SkJOcDibarBqnLPQ1IJHRrMLcjXXU0Mwy80aTz4Wgj/emL+UNTUOpPaHn/VbnK8m8EUqgw1p5wy7zhqZplDR2wsGEXHlT0dwNgUQKVzNy8ia1ogWBtgYKd79pmkabQIyBLGxPLV0i3MmqxQgWtqfk8hZUt3Qj0oWcNLqeVg0HY21WwaeHo0sw2tuclYVj+8NCLI5wIB4iRRIZfrmXh7dGuhHnkdS2CbDrcSGr2ueEkibcyKjGZ5PIrUfH48qQXNaC98aSW5623MiGkbYa1gwla6aSymi8eTIZw9xMMTOYzJbW2iXGmqOJWDvUGUPdyMjE/Np2rD+RjG9n+MHf1oBo7b3sGlxOqcLexSHEeS5/PCrE+aQKfPiKJxFhJJPReP9sGvJq23F0ZThxEHRfeJxXjxWH4vHFZG/MZNHiVtrYiZl/RMHfxgDb5wextnHFlzRhxs5oTA+yxo+zyIOyVVDh3wjVXaCCCs8wwc8SexaH4NOLmdj/hF2lsbeVPk6uGoDjcWX49mYOMYGzbKAjVg1xwsK9scgmsGnI1SxB4HEprD6SSJQLoqephkPLwxBX3ITvbuYSHa+1gSb2Lw3Fr/fycTODLBDWx1ofW6b7Yv3JZGISZoy3BRaE22Ht0UTitqaVg5zgYKyNTy6QW5U+nuCJ8uYuHI4uYbxG0Q6cWEojqrARI356iF/u5GGYmykcTbXw3S2y8w8Aywc6orVbjMsp5I1Yb45yxfX0auTW9B7yfW30McjFBLsfkamjAOAVHwvQNHBTQRW6Go+DxRH22P+khPhxTXXVMcLDDKcVNHj1hyA7A+hp8vE4jzxAeLi7KTKq2ohDqwHAx9oAV9OqWVmYQhwMkVRK3pIFAENdTVHBovJbjceBu7kuKllYpwy11NAhlLAiyNT53D5zsLhUH8obmXLblPBZPpbSwGKhhPWOcH27EKYsMm9q24RwNNGGDYua8NyadozxsmAVRhpT1ARnJYNlWVMXHuXVI8DOgPhxH+XVw81cF1YG5K/namo1xnpbKFVG9YVTCeWYHUKeOdMplOBUQjmWE1YwA/Lg1vjiJixjsfZ0QjnUeVxMDSRXGf10OxcjPMyUqqaUQSyV4eMLGXh/nDusDMiIqqqWbnx7IwffTPOFDiFR9TC3DueTKrF1dgBR7gsA/H4/H3VtQnw9laxSXCaj8dapZLiZ6+A1wirz5k4RPr2YgaUDHYgzkNIqWrD+RAqWRjoQq5NOx5dj+/0CHFwWBkeCEGmapvHxxQwkl7fg2Mpw1nYkRbifU4s1RxOxZbovZrFQiGVXt2HmH9EY522B72f6sW68up5ejSX74/DBOA+8M8adVUC7Cir8G6Eib1T414FNoGkPBrma4NjKcPx+Px+/3ctnNXC5mevi1KoBuJxShS+vZBE/xrphLlgxyBEL9sYqHKqVQYPPxd4loWgTSPDGiWQiG5SZngYOLw/D6YRyYuLK11of383ww4bT5BXiUwKssWqwE947k0qshHlvrDsMtNTwMSEJw+FQ+Gm2P54WNBBblXTUefhxlj++v5WLIoaEE5/LgZ6CQFSJjIZYSmPno0IM/fEhRnlY4GJyJbGlS4PPxacTvbD5ehZxPoqNoRbmhdlh6x3FpNFbo9xwLLaMWIXB43KwYpAjdj0qUvjezAuzQ3xJEytlyJwwW5xJLCcOH6YoCpP8rVjVvhvrqCPQ1gD3CVViABBsb4iGDhFKWaiFfKz0kUqQg/U8dDV4SGHZVqWrwWOVe2OoyYeNoSaaWNSFa/G5faogPCz0oOwu11TjwkRH8fAilEjhb6MPvpIBUovPhSGLwUcmo9EpkMBMl3xtSWMn2rolrHaj0ytblaqI+kNiSTNClIQVRxc2ItDWkFVexv2cOlYtUzIZjWvpVZjEIjC4oK4d6ZWtrIiQ88mVcDDWJq6OBoAdDwswJ9QWxoS2GIFYit/v52PDaDdiMiOjshVxxU2sAn8PPi2BlKYxP4zMHkbTND66kI7xPhYYQqhgae4U4f2zafhsohdxtXdMUSN2PSrCtvlBxNlL2x8UoLihEz/NDiBqaRJJZFh7LBGmeup4e5Qb0XOWN3Vh+cEEvDXKjbiy+lZmDT6/nIndi0OI1GM0TeOrq1n4M78ex1aGw+x/mP9yM6MGrx1Lxo+z/FlZGRNLmzBnVzSWRjrgo1fIas6fx+HoEnxxORO/zwvEfBb2RBVU+DdDRd6o8K/DmyeT0cxieOiBv60BzqyJxP2cWnx8kbydCACcTHVwenUE7uXU4vPLmcT5Hq+PcMXSSAfM3xNDNODqqPNwaFkoypu68N6ZVKLndTLVwf6lofjpdi7xgDvG2wIbWFaIrxvuAj1NPt46mUJ0rnlcDrbNC0RRfQexEsNMVwM/zvLH55cyUNxAVhU/wMkYc0Jt8e6ZVMbH29cXfaFEhto2IT6+mA5zPXVsPJdOTEyM8TKHg4k2q7yldcOckVvTrrCu3sdaH2O8zVlVdM8JtUV5cxeiFeTxGOuoY2qANauA7yGupuBQFB7m1hOvneRnhbtZtcRqLUDeOsWmMlxTjYsgewNEsWid8rXRR02bgJXix9Vc9yXqwrVY1YXzeBy0CySsrFNqPA6y+7CXFTd2QqykZa5dIEGLkqBkkYRGdk07OBzFX3eKGzuVqnL6QmOnCB0iKSvlTSlLyxQg39X2siQPKxZJZEitaEGwkrDimKJGDHAir92VSGV4mFuPEZ7k5E18SRPEUhqRzuSWqTMJFRjrbQEDLTLyjKZpHHxajKWR5PXghfUduJtdh1VDnIjWAcCxmFKEORhhHGErFk3Lq8HH+VjCzogsI6mmVYBf7ubJc/EIr/GLKZXIrGojrrruIX0CbA0wi1AV1dghxJsnk/HRBE/iQO77ObU4k1iOnQuDoa/JXCVE0zQ+v5yJ1m4JvptBVs3d2iXGsoPxeMXXAisHk2XCRBc24q2TKfhlbgAiCK5/mqbx4+083EivwfGVA4jVVH3hSmoVNpxOwe/zAvGKL3mu0sPcOnx3Ixfvj3PHa8NdWBE3MhmNTVez8OvdfOxZEoyRnuR5Vs+D6SabCir8k6Aib1T418FAi48Zf0SxysXogYuZDnYsCEZsUSPeOJHEygZga6SF06sjUNLQiXfPpBIP5OtHumLhAHvM3xNDNIQZaKnhyIpwpFW04ue7ZNk7AbYG2L4gCB+cTcOTfDJ7SU+F+PKD8cTByb/ODURJQyd+uk1mGzLT08CHr3jii8tZxNkgwz3MMCfUDl9cziSuHn9/rAdausTY8yczS5EFw52xunYhukQSHFJSta0MPe1h+54UEw/dZnoaeMXXEj/cylH481cHO2H7gwLUERIIWmo8LI6wx7U0xXa6ZYMccCG5klilIQ8ftsVJFoSSp6UurA01cTebXEEzytMMTwoaiCvuASDS2QRRheR2LV0NPlzNdBQSa/3B3UIX+XUdxMQxILdDvlTjFAvyvL+2KQ6FPqrClQcWCyXSPsmZDqGEVbtSXbsA+pp8VuqZksYu2LOsCc9iSd5kVLVCS40LZ9Pez0vTNKKLGjGABYmSVNYCHoeCv40B8doraVUY72NBbKsQS2U4l1SBOSwsHU8KGtDaLcZEf/Lh9EhUCVYOciQemDuFEux4WIhpQdZE5AAA3MmqRX5tB9YNJ2/6+fpaFkZ7mRORA4DcDvjllSx8PcWHOEflQnIl4kuasGW6L3HF9tdXszDCwwwLCZUWpY2deOtkCt4Z4w5PwnvjcHQp7mTVYO+SEGipMf8cEEqkWHUkAQ7GWvh8kjfRa82obMWqwwn4YrIXccX9tvsFSC1vxrFXw4lVTX3haloVNp5Lw44FQRjFIgD8SmoV1h5NwqIIeywc4MDqGARiKd44mYy72bU4vy4S/jbkyrjn8SC3DqsOJ7zUY6igwv+PUJE3KvzrsHmaH4a6mWL6zqfENp7nYWWgiTNrIlHZIsDyg/HoYFHZa6mviR9n+yOjqhVvnkwhrtV+a5Qr5ofZYcmBOBTUMt9BMNVVx5GVYTifVIlvb5Bl7wxzN8OmqT5YczQRGZUtjNf1VIhb6msSV4jra/Kxe3EIjsSU4gqh6meAkzHWj3TF2qNJaOkiGxo/GO+ODqGYmDTSVOPix9n++OVuHnIYZBPZ9dN4wedSGOlhjkfvDcf3M/zw85081BA2BfnZGGC8rwVxbhEArB7ijPSKVjwt6E0w+FjrY4irKf5gkX2zaIADziZWKLT/eVjoYbK/FU7FkbdHzQq2waO8OmJFCkVRmOxvxSofyNlUB5b6Gnii4Bz1h0hnY0QXNrKyYQbYGrAibxyMtSGSyFDZQk7CvHxdODl5o8nn9tM2xYFUyfmT0VA6PIkksj7zVDoE7DJvXq5pqhMOLAav1m4xKpq7iQdUQG6ZCrY3VHieShq70NwlZmUjupdTi2HuZsRWIIlUhhvpNZjoR26Zup9TB3Uel5Vi53JKJVYNcSbO2Klq6cbx+HLMIAzQBYADT4thb6xF3PQkksiw5UYO3h7tBj3CzJnHefV4nFuPjyZ4Eq0DgC8uZ2KgswnG+ZARC+VNnTj4tATfzfAjtpXtfVKEhNJmbBxPZrXpFkmx+kgiZgTbENt8/syvx7c3crBrUTCsCQi5nqBggViK3+YFEl37JQ2d+PF2LtYNd8GcUDKSas/jIux/WoxPJnopza5ig5NxZfjgbBr2LQ3FMMJrFACOxZZi47k07FwYxMoCCchVTIv3x6GyuRvn1kayJrcBORm9/0kxXjuWhPfHe7B+HBVU+P8VKvJGhX8duBwKn0/yxtphLpi/JwZ3WFgdemCkrYbjK8PBoSjM3xODxg7yGlwzXQ2cXBWB4oZOrD1KpuKhKApvj3bDogEOmLc3hijY19pAC0dXhuNcUiW2PyggOuYZwTb4YJw7VhxMIFIwvUyFuIuZDn6dG4APzqUR1aUDwJqhTvC01MOG02RWMXUeF9/P9MfRmFI8ziOz4QTZGeKtUW74+EJGv0SVlYGmwswNHoeCsbYadi8KwR+LgmGqq45IFxOM9DTD19eyiI4HkCuC7mXXIrGUrNZaX4uP1UOd8cOtXIXv2ZujXHE8rpRYfWOqq47pQTbYraQSfrSXBQ5FlxKTmrZGWpgeZIMLSeTNcJP9rfA4r56Y6KMoCiM9zXEvm/zzxM/GAN1iKfIICNgeBNgaIqWshXidGo8DR5aNUzaGWqxIH0AeWszGtqrB50IklSm1InI4FKTSvqrCFT+uUCLrU3nTyTKwuL5NyKppCgCKG9gpb3Kq22Cpr8EqoyehtEmpZUqed2PASkV0L7sOI1lYpqKLGsHlUAhzJLdq3c2qxfJBDsQqlpKGTlxKqcaUAPIBc8+fRRjlaUY8NLd2ibHrcRHeZRG4ejSmFHwuhbmhZAojoUSKzy9n4p0xbjAjtPXdyarB08IGfDHZm2idTEbj3TNp8LbWI7a6JJU14+c7+dg2P4jY8vTh+TToafDx0StkJFVRfQdeO5aETVN9lN4XyrD9QQGSypqxd0kokVqnrk2ARftj4WKqjTVDyax3R6JL8Nv9fBxZEQ4PC3LyVhkOR5dg07VsHFgWhgFOZGQoTdPY/qAA393IwaHlYayIHwCoaO7CjD+ioKfBx4lXBxATf89DLJXh44sZ2PGwEEdXhmOMFxkBqYIK/wSoyBsV/rVYMcgRP832x5snk4nagV6EtjoPe5eEwNZQC7N2RbMaaoy01XDi1QGo7xDi1cOJRNYLiqKwZqgTZgTZYN7uGKKMFkcTbRxdGYa9T4qJ80UWDrDHBD8rLN4fiwYC0kpXg4/9S0NRUNuBfYTPOcLDHK+PcMHqI4lEz0lR8hDigroO7HxElvvibKqDzyZ5YcPpVKLnBIBlAx3QKZJg2/2+yTFzPfW/VVxSlNwGYqarjvPrIjH8hbDPjyd44nFePR7lktl7LPQ1sHqIM766mk1sl1k20AEVzV0KLUXeVvoY6mZKfG4B4NXBjriSVoXq1t73zQgPM6jxOLiR0buVqj8McTXFifhy4tfpYKKNoW4muMXiOUd5muNpYQOkhGSTGo+DUAcjVtapAFsDpFe2ssrecjPXZUUYWRtqorK5m5Xlykibj0YW5I1YKv9MrFFwnQByorMv5Y1S25RYOXkjk9HoFElZ26bY1oTLlTfk5E1WdRsr1Q1N00gs7SOsuKiR2FoDyBVEpY2dGOxKXi9+J7sWC8LtiBU7dW0CXEypxDgfctvT4ehSjPOxIKpjBuRZLCfjyrFuGFmDESAnfXyt9RHpQnaOWrpE+PVePj6e4EVsK9v9qAhaalwsHEAWUtzaJcbHF9LxzVQfYlXZ3idFqGkTEGfktHaJ8cbxZGwY7YYAwnruQ1EliCpsxLYFgUQV0q1dYqw8lIB54XbESqrjsWU4HleGA0vDiM5Rj7IkzMEYHxPWvZ9OKMd3N3NxcFkYUbBxf9j7ZxF+uJWLwyvCiElUmqax+Xo2DjwtwclVEcQtWz3IrGrF9B1RGOBkhF2LglkFpvegtUuMpQfikFTajEuvD2SlJFRBhX8CVOSNCv9qjPOxxJEV4TgcVYofbuawGkYAuULjt3mBiHAyxtL9cax2s/W1+Di6IgzdIgmWHYwjagaiKAofjHPHtEBrzNsdgxICAsfDQg8Hl4Vh6+08omBfiqLwyQRP+NoYYNkBMtuYlYEmPp3ohZ9v5+Em4ZC8dqgzguwNsfFcGlEWjb4mHzsWBGHb/QJEEVpbZofYItzJCO+dSSVSC6nzuPhptj92PS5Eeh+tQOZ6GgDVs4YDR2NtXFg3EAF2Bvjxdl6v3zfT1cBnE72w+XoOcXvaqiFOqGsTEIdOa6nx8PpwF/x4K1fhffLmSDeciCsjtio5mepgmJspDjwt6fUzLofC0kgHVsHFo73M0S6QIKaYPAg4zNEYV5Rk8fSFEHtDdIukSCNUhgHAEDcTFNaThWMDgJu5DqQymkh1939r2YUWWxloQCSVoZ6F0tBQm53y5uqz61WZSpDLUV4VTvepvJEqDWvtfBZcraOgDa4/1LULWbW81HcI0SWS9mulVAS2YcWljV1o65bAV8HgR9M0qlq6McCRnLy5l12L0V7m0CW09IgkMlxKrsIgV7IWIwA4m1SBAU7GRDYXQJ5tdCahHEtZVHwfjCpBiIMh8eDc0CHE/qfFeGcMeUvUb/cKEGBrgKGETU/lTV14mFuPTVN8iEmfTdey4GWlTxxWm13dhq138rB1dgAREUrTND44lwZ3C12sGEQW+Btf0oTvbuZi58IgInWRRCrDp5fSEWhngPfHkllqHuTWYdO1LPw6NxAuZswVWN0iKVYcioeNoRa+m0GWBXQppRJfXM7EnsUhxDXxfWH7gwJse1CA4ysHEJMcYokUH5xLw42MGpxdE0EcLt2DP/Pr8eWVLCyNdMDXU3yIidznUdzQifUnk6CrzsfZtZHEnw8qqPBPgoq8UeFfj2B7Q+xZEoxr6dV440Qy6ypxLofCpqk+mBZojdm7opFMWOkMyFUph5aHgcuhsOxgPFq7mQ85FEVh43gPTPSzxLw9MShtZD4IBtgaYM+SEHxxOVNpgKwicDgUfpzlBz1NHubtjiayzfja6OPnOQF453QKUfYQRVH4foYfOoVSfHU1k/E6QJ7P8vkkL6w/mUyUGUNRFDZP80VebYdCkqEveFvp47VhLthwOkXptWWup4FukRR8LoU3R7ni1ttD4G9rgC8meeNhbh0eKKignh5kA3U+h7hBSlONi49e8cTF5EricN154XboEEoUEj9eVnoY5mbGqtFq9VAnHI8tUxhkPSvEBvm1HcT3kxqPgxlB1qyasCb6WyKmqJG4Ap3P4yDS2QT3WAQehzkY41JyJXFwOY/LwUR/S2RWkRNGrubarJSC6jwuzPXUWeXeGLMILJZIZdj37L47nVChkCDkciilgcUymu4780aJHaiHkNYmsD70oI6lbaq0sQuW+hqsdpjbBRJ4sxiUksqaMcLDVKEtqrC+ExmVrQi0NyB+3Ae59QghtJwAwJOCeuio8xBkR/acNE3jTEIF5hDaiADgfFIFHE21EUio7mgXiHEoqgSvDSdX3ex8WIgBTsbEQ3dRfQfSKlrwMcu8GjcLHQQSPufjvHrcyKjB5mlk5IJQIsXbp1Lw6mAn4td5JKYUKeUt+HGWP5EFrratG59czMDG8R7ElqdN17KRU9OOLyZ7E5EFGZWteON4Mr6b4UekUhFLZXjteBI4HArb5gcSEWo3M2qw8Vw6di4MZqWMUwSaprH1Th72PSnG8ZUD4GtDRkgKxFK8fiIZHUIJzq6JhIMJu2yac4kVWHU4EfPCbLGOZTNVD6IKGzB1+1O4W+hh+4IgVjZYFVT4J0FF3qjwn4CjiQ7OrxuI6tZuLNwby7pKnKIorBvugjdHumLh3ljinBRArnDYtyQUzqbaWLg3juhYKIrCxxM8Mc7HAvN2x6C8iXkezQAnY2xfEIT3zqYSHbc6j4s/FgYjs6oNYZvv4a2TyUgqa2akUBnjbYG3WVSI9wQC30ivwbFYsualOaG2mOxvhc8u959F8zz0Nfn4bV4AfriVS5y5s3aYM7TUuPj5Tm8VDQA4mWpj+SBH3N0wFOuGufwl8TbT08CH4z3xycWMXkqsHrJw1+NC4jrzCb6WaOkWK82aUQZ1HhdvjXJV+vrfHOWKk/FlxGHKwfZGcLfQxYnY3uHEuhp8zAy2ISbNAPl7fSOjhji/xlJfE0H2hrjOQn0zysscd1nk3nhZ6YHDoZBZ1X/A9Ysw1FJDXDE5WexmrouU8hZWlquBzibE7zMgJyq1CImJm5k1aBf83/X//c3ezWcGmnxAyWcOn8uBhhJ1jURGw1RHcUZMh1ACT0tdVju+2upcVru75U1drHJexFIZ7uXUwYOF8ia+pAl2Smxa0UWNCLY3JA7w7RBKEFPUyCrv5mpqNSb4WRIPbHHFTWjuEmE0YRuOTEbjYFQJq3rwY7FlcDHTQTjhe1bd0o1radV4Z4wb0ToA2HIjB+4WunAz1yVadyerFkllzcSKkk6hBB+eT8fG8R7ETVpbb+eBz+Vg/UhXonWZVa3Ycj0Hv80LhBFBhpNYKsPrx5MRZGuAxRFktrDjsWW4lFKJvYtDidRilS3dWHYwHq+PcCEK5JXJaHxwNg3VrQLsXRJClCn1ILcOR2JK8OvcAGL1lTLQNI1dj4pwPLYMJ1cNIFbMdAglWH4wHrVtQmye5gsLfXLlIU3T2HY/H19cycTeJSGYFkgeAP48TsaVYcXBBHz0igc+esXzpdQ7KqjwT4GKvFHhPwMjbTUcf3WAPER1ZxSRcuVFLBvoiG+m+WL1kURcTSNvrtHgc/HlZB9YGWhg3p4Y4nyXzyZ6YYy3BebtiSEiRYa7m+HXuQFYfSQB0YXM7Sa6Gvy/Qh4vplRhzq5oDP3hAfY/KeqXfOqpEF9xMIGoQtzaQBM7FwZj09VsxBUzD+ClKArvjfVAWWOXwiGwLwTbG2HtMGdsvp6NLhFzmxiPy8FPs/1xOLoUCSW9j1WDz8WnE70UhpTODbWFtYEmtiogfvxsDDAr2BafXcogsnNxOPLq8F2PCxVmzfSFWSG2+GSi4twCT0s9zAuzw34WNqdVQ5yw/2mxQivc0kgH3MyoISYLXMx04Wetj4vJlcTHM9nfithaBgBD3UxRUNdBRJwCcjJugJMRogjuux68TOMUTYP4WAE56VHaRP4ZqaPOQzoB+UnTNH69mw/hs+tCIqNxMaWql92rWyyFSElgcbdYqlSV0yWS/PXYL6JDIEFDBzsiP66kCQZa5MHBhfUd0GQRDFxU3wkeh4I9C7tVwrOmKUWIKWpEBGFQKQA8ya+HnZEWcfCyQCzF7axaTGLRMnU6oQJTA6yJiabH+fVo6xZjgh+ZHahbJMGBp8VYN4xcGbDtQQHCHI3gbUWmbIgqbEB0YSPeHk1G+nSLpPjiciY+GOdBHGj9/c0c2BhqYn4YWftRTFEjDkeX4uc5/kSZMx1CCb64nIkNY9yIiczN17PRLpDgM8J67piiRnx9NQt/LAwmqthu7RZj2YE4jPU2x+ohzEOGaZrGb/fzkVjWjEPLQ4nawqIKGvDasSTMDbXDGMIq8b6O5+ur2TjwtBinVw8gJgabO0VYsCcGHIrCsZXhrD77JFIZPrqQgaMxZTi9OgIDCXOgnodURmPT1Sx8ezMHB5aFEjd3qaDCPxkq8kaF/xQ0+Fxsnx+EkR5mmL4jCkksrE89mBpojR0LgvD+2TQciSFThwBy28e2+UFwM9fFnF3RRFkiFEXh80lemB5kjbm7yQic0V4W+HKKD149nEA0EM4IsgWfK/+yJJbSKGvqxve3chHyzV2sPpyApwUNCrNSeirELfQ1iCvEwxyN8MlET6w9mkhk/9BU42LnwmCcjCvHzQwydcVrw13A5VD46gpZ25OLmS7eGeOGd86kEhE/HA6FzdN9cSy2VKG97N2x7siubsdVQpVIsL0hRnma4wcW1eF9YXaILQ5FlRATLaM9zeFnY4Dr6b0JEwcTbQxxM8FRFvfRnFBbnIwvJ67hHu9jgbSKVmJiQ1+TjzBHI1atU5HOJqxDi3Nr2oiuK0BOKjqZsmucsmZZF25IaJuKKWpCSS8incZXV/9+/8kzbxR/dtC0PARcEUQSGdSUDJadQil0WUjsaZqW26b0yG1TJY3smqayq9vgYaFL3LDU0iVCQX2HQvKGpmnEsgwrvptdR9wqBAAPc+thrKMGH2uyXf92gRjX06tZWaYORpVgfrg9MelzLqkSbma6GOFBpi4qa+zCmcQKrB9JZrWSD6TZeG24C0wIG3e2PciHmZ46ZoeQnZ/4kiacTqjAdzP8iK6tNoEYv93Lxwfj3OFixpwIoGkan1xIhxqPg+UDyXJuLqVU4lxiBVGwbZtAjE8upGPe7hh8NtET4QREpUgiw5ojibAx1MIXhGTRjoeFOB1fjsPLw4gyeRJKmvDq4QR8NcWHde32i5DJaHx6KQO3Mmtwek0EnAgb06pbuzFrVzSsDDSxb2kIq4D3LpEEq48kIrG0CefXRbIKXu9Bh1CCVYcTcD+3DhfXDSRuyVJBhX86VOSNCv85cDgUPpnohTdGuGDh3lji4f55DPcww+HlYfjhZg5+vZtPPEDyuRz8PCcAQXaGmL0rmoiEoSgKb49ywzB3U8zbE4MqAnJjdogt3hnjhiX745BTw8zGoaipRCCWV/veya7FsgPxGLDlHn6/n9+LiHq+QnzL9Wyi87Qg3B7jfCyw+kgCUYaLo4k2fpjlh/fOpBHZjrgcCt/N8MONjBqifCBArsgKdTDCD4SKHxczHawd6oKN59N7kVv6mnx8MsETX1/NIlIuAcAH4z1wPaOaKHOoP3ha6mGkpxl2PCSrn+dwKIzwMMOOh4UK3/+VgxxxNrGcOJNqgp8lKpu7kdZHYLQiGOuoY6CLCTEpBkBeGa4gp6g/RDobI76kCUIJ2Wu01NeAiY46MirJLVdu5rrIryMPO7Z51jhFCmNtNTR3iRjf47/dz4fkBUWNVCavr44t+j+Vkpy8UfwY8sBiJW1TEhnU+Yq/6nQIJawGkTaBXM3DLvOmEw4EO/89YNs0lVTWDAdjbYVkQH5dBzqFUvjZGBA9pkxG40FOHTGpAQBX0qowyc+KWMlyJbUaruY6xOegqL4DdW0CLCBUlUikMux6XIiZITbEhNmv9/Ix0c+SiNQA5Lk8rd1iLCMMVS6o68C+J8X4eooP0bEKRBJ8cDYNb492Jc4u+eJyJnhcCosjyI71TGIFnhQ04Oc5AUQWl5yaNnx0Ph2/zA1gRH6WNnbi04sZCPn6Do7GloHDoTAvnLnNiqZpfHU1E1pqXPw+jyyr5kRcGXY9KsS+paFERG1qeQuWHYjHRxM8MZOwBUsZpDIaH55Px+O8BpxaPYCYOC5u6MTMndEItjPE7/MCiQlQAGjoEGDBnlh0iiQ4syaS2Jr3PMqbujB3dzSEEhkurB3IOnNHBRX+yVCRNyr8Z7F0oCN+nhOAHQ8LsP8JuQ2kByEORji9JgKnE8qw9U4ecaNVD1kw2NUEc3aRBRFTFIWvJvtgkIucwCGxyCwb6IhXBzti4d44RuSGBp+rtJVARgMiqQx17UJsu1+AiC338PULO+e6GnzsWxKCJwUN2PMnWRbL55O8ocXn4YNzaUTEzzgfS8wNs8Xao2T17FYGmvhuhh8+PJ9GRKhxORTeGOGC0wkVeJJPprBYO8wZHEru4X4RUwKs4GKmg60Kmqn6grWBJl4d7ISvrmYRE4t9Yf1IV5yKLye2ZE0LtEZTpxgPc3tnLoU7GUNfU43YAqWlxsOSSHucTSQPLmZrnRrlaYaYoka0E5JpLmY60NXgI6WshWgdRVHPrFNscm902ClvDDSJrv0eGGqrQSyl0c6gnS6vth1xxU1QdGVKZTQ+v5z513XL60N5I6OhlAwQ9qG8kZM35MNIfbsAmnwucTAmTdMobehiNXBkV7exanXpyzIVXdiIEAdDpW1cypBa0QKxVIYQwoDaLpEE97PrMNGfvOb7UV4dccYJIK8HdzXXhTlhPsfVtGpQoDCBsHmpoK4dV9Oq8NZIMttTl0iCH27lYuN4D6JsFJqm8fnlDMwNtSNuw/rlXj78bPSJFTDX06txL7sO388gCxrOr23Hl5cz8fOcACI1Smu3GGuOJGLlYCeM8FCu9qJpGjFFjViyPw7Df3yIk/Flf1ktxxBmM/18Jw8PcuqxZYYvEcF7M6MaX1/Nwt4loUREY3Z1Gxbvj8Nbo92wgIBk6gsSqQzvnkmVq6tWR8DGkIw0zqpqw6w/ojDRzxLfzvAlbi8D5OTP9B3RCHYwxKHlYdDXJGumex6Jpc2YtuMpRrib4cCyUOhrsX8sFVT4J0NF3qjwn8ZYbwt8NcUX2x8U4KsrWayCPQF5HffJVRG4klqFt0+nEFVcA3JVwtdTfDDexwJzdsWgkGCnnMOh8M1UH0Q4GWPe7hgiO8trw10wI9gaC/bEMLIljfW2gIaSXeweCCUycJ4Nmy/C2lALP87yx69384kqxNV4HOxYGISSxk7iYNv3x3lAV4OHTy6S5caM87HARH8rvHUyhaghyN5YGx++4on3z6YSKWXUeBx8Mdkbm6/n9CLwKIrCV1N8kF/bjvSKFsaPCQBrhjqjvKmLlcJEGTws9DDK0xw7HpA1T2nwuVgaaY9dj3uvoygKywc5YP/TYmKiaay3Jc4nVfYKfe4PY7zNweNQyK8lU7TYG2vDwVgbj/PICDqKohDpbMwu98aOXe6Nq7kucmvIyRsbQ01UtnQTvxe66jzwOBSjIPbtDwqgbPSjARQ1dOJ6uvxzor+2KeVV4TKlu8WdQgl01MkHgLo2IUx11YnVI02dIrQLJbAnVN7QNI2sKnbKm4TSZqUkS0xRIyvLwf2cOgxzNyMe5h7k1GG4uyncCfM2cmva8TC3HqO9yPI/2gVieT14pAPROpmMxo6HBVg91In4Nf58Jx8zg22IclUAYNejItgYamIiYS7PzYwatHVLsIEwGDmjshUHo0qwdpgL0WusaxPgowvp+GaaD1FgrUAsxevHk7Ek0gGDCSriZTIa75xOgaOJNt5UEooskshwPqkCo7Y+wqJ9sfgzvx4yWm7vBgANPgeDCEJ/T8WX4WBUCQ4uCyUimaIKGrDhdCp+mxtIlOVTUNeBhXtjsWqIE3FlujKIpTK8eSoFGZWtOLl6AHG4cFxxE2bvisL6Ea748BVPVm1QSWXNmL7jKcb7WuCj8Z6sVDs9uJhciUX7YvHGCFdsGONOlLGkggr/NqiufhX+8wiwNcCFdQPxMLcOrx1LYl0lbmukhTNrIpFf24FXDycQ51P0NEktH+SAObujGduZgGe5KdN8EeZohPl7Yhjn51AUhY3jPDDcwwwL9sT0WwU+xM0EYonyYY4CoM7jYP/SUKV+bT8bA2xlUSFuoqOOb6b64MfbuQqrtZWBz5VnCz3KqyOulf50ghdau8X47T6ZRWhBuB2czXTwNWFuTqiDEWYEW+PjC72JJhczHQTaGeKTS5lEJKO2Og/vjXXH7sdFrK9tRVg/0hWnE8qJ7HoAsHCAPdIqWpGmgISaEmCN+nYhMbnhY60He2NtYpubrgYf1gaauJLGnEjswbRAazzKY2edii1mQd7YGBArdgC5baqovpO4otzaQAsCsQyNhM18FEUxyr2pbRPgalq1UkIGkA9lX1/Ngkgie2abUvy7NKDUNiWSyJQqSzqEEuiwUN7UtbOrCS9p7IKZrjq0CKvJ69uFaOoSwcOCjPQQSWRILW9RaHmVSmXysGIWeTcZla0YxyJI9VJKFdwt9IgHwdMJ5XjF15J41/5cYgVczHURqEQxqgz3curQ0iXGjCAy60pmVSvu5dTi9RFkWTfVLd3Y82cRPpnoRXRu2gVifH45EysGORIF4oqlMrx3Ng1rhjrDneCaomka751NwzA3U0wkDJz+8koWdDV42EAYxLzvaTEaOkT4ZU5gL5VPU6cIv93LR+g3d/Hh+XQU1ndCLKXx4seEWEoj1IEZmfIorx5fXM7C7sUhcCUgGdMrWrH6SCK+muKDUQRtaKWNndh8PRvzw+1Y1dErglAixVdXslBU34mTqwYQEVAAcD+nFksPxOGjV7ywmJD47MHtzBos3BuLt0a54cPxnsTWwx7IZDR+up2LTy9mYMeCICxheTwqqPBvgoq8UUEFAHbGWji3NhKNnULM2xODRoL2p+dhqquOk6sHQCCWYuHeWOIKY4qisGqIM5ZGOmDu7hikE+R4cDgUvp3uhyB7Q8xjQMQ8/5xfT/HBaC8LLNkf1+cxO5vqKP0CzaHkTTNn1kRgSD+7XGNZVoj72hjg2xl+WH8yGYX1zNVJ5noa+G1eIHY9KiKqAddU4+L3+YHY87iIuPHquxl+uJlZg7tZZMG274/zQH5dO84n9bYPvT7CBU2dQpxQYK3qCzOCbKDG5WDfS9gDX4S7hS5GeZkTZ98YaKlhTqgtdimoMdfgc7Eg3J7YxkhRFOaG2eJkPNl5AYDJAVa4klpFrDAJdzLC7axaYlIkwtkYqeUtxOSun60BdDR4qGkjI8vsjLRAUUApYTCzphoXxtpqrHJvjLTkuTd9Yd+TInAZDKrNXSIcjy0Fl8NRTt70qbyRQr0P8oZN5k1du4BVWLE874bcMpVZ3QZHY21i0ierug0DnIzgZNI7oDS3th2GWmrwIbRiVbV043F+AyJdyEifNoEYD/PqiS1TIokMF5IriYN4ZTIah6JLsYxw2KNpGtsfFGDlYEci+xIgr81eEG4PS32yTI8fb+dhdoitUluyMvx8Jx9Optp/NUEyxR8PCyGT0Vg3jIwsOBpTirzadnw5xYdo3ZWUKlxPr8avhNkxD3Pr8POdPHwz1aeXRSaqsAFh39zF9gcFaO0WK22UA+SqVhcGIb2ZVa14/VgSvp3hS6RIK6zrwNIDcVg/0pUoq6aypRvz98TC0ViLmNRSBoFYijVHEpFe2YLjK8NhTBh8fSmlEq8dS8b3M/0wP5xdg9ORmFK8dSoFW2cHvBTZ0i2S4vUTSbiYUonz6yIxzJ08Y0sFFf6NUJE3KqjwDIbaajiyIhxWBpqYvjOKKOT2eehp8HFoeRiMddQxZxeZjakHr49wxevDXTB/bwwSS5nnXHCe5eeM8TTHvD0xqG9nRkJxOBQ+GOcOWyMtLDkQjw4l9hOKojDcw7SX1YGi5JkUJ1aFMw6/ZFshPtnfCgsH2OPVQwlo7Wa+LtLZBDNDbLD2WCJau5iv87DQw8bxHvjhVg4RGWdloInPJ3lj4/l0RhaSHuhp8PHlZB9supbVi0TU4HPx1WQffH8zh/F7C8jf3/fHuWPHgwLGpB4TvDnSFReSK1HZQkYMrBjkiDtZtShr7L1uUYQ9/sxvIL7/pvhbI72iBSmEDXIjPMxQ3y4kDgMOsDUEh6KI7k8AsDPShomuOhEZCOCvfJXUcrJgZi6HwlhvCxTXk3+eeVjqooYw1wgADLX5aOpUfo91CiU4HF0K0XPEF4f6v88RTT4HWmpcaKlxIaNpbHtQAF5ftimZ8sybvpQ3nUIJdDRYkDdtQuLdbABo7BDBz5YslwQA8mraEeFMVqkMyJtreByOwl3vmKIm2BppQY3QynA/pw7B9obEVcF3MmvhYqoDZ8Kmm7vZtdDV4GGAE9nrf5Rfjw6hBK8QZtZEFzWiuKET8wlzRxJLmyGUSLF2mDPRuvSKVlxLr8LKwWR2mezqNhyLLcXXU3yI1Dr5te3Y/rAA38/0I8o6KqzvwJYbOfhplj+RAqq0sRM/3cnF1tn+sCYIqi1v6sKbJ1PwzTQfeCvI8vGw0GOsGgqwMehX+VHV0o3lB+OxZpgzpgRYMz7OmlYB1h5LkmcIElSJ17YJMH9PDIa5mxIrrpShWyTFykMJaOkW4/CKcOLK+MPRJfjofDr+WBRMrKwC5ITpdzdzsPV2Lo6sCMM4H/Y157VtAszZHY36diEurhtIpIJSQYV/O1TkjQoqPAcNPhe/zw3EOG8LzNkVjcRSsgHr+cfZuSAIfjb6mPkHOyJo5WAnvD/WHUv2xyGmiLnNgsuh8N44D/ha62P+nhg0MFQR8bgc/D4/EHoaPKw8FK/UYjPS0/xvO5JqXAqOxtqIdDbBlhs5jJt0XqZC/N0x7rDU18CwHx4gp5r50L12qDNczXTxzpkUomDpxRH2MNZWx8Zz6UQKjRlB1giwNcCnlzIYrwHkeTthjkbYdC2718+Ge5jJz/X13j/rC+FOxhjqboofb//vqsPdzHUxwdeSOPvGxlAL47wtsO9Jb/WNuZ4Gxvta4FBUCdFj6mvxocbjYs5u5qQlIL9Xx3iZ43IqWVAy91l7FqvWKScTRLPJvbFll3vDoeQqDFLoa/KJFTuAXKHXV5izlKYx2tMcE/0sMTfUFssHOmDtMGcE2xlguIcZPprghS8ne+O7GX7YsSAYB5eFwVxPHZpK8raMdNSgp6mYhJnkb4UxSiw+alwOzFnYn5o7RbAyICdv0itbYUhIevSsszIgb6hKKGlGsALLFCAnKdhYpu7n1GEk25YpFtXHpxPKMSvYhni4Pfi0BAvD7YnDmM8nVmJJhD1xGPXWO7kIsDUkqvimaRqbrmVh+UBHojBZmYzGJxczsHSgA9FQK5XReP9cGhZHOMBfQSadMoilMvx0OxfzwuwQ6WLCeJ1QIs+5Ge5hRlQrLxBLsfpIIqYEWGFaoGIli5G2Gs6vi8RYbwulgeSA3MY92LXvY24TiPH2qRSM8DDHOgLyraVLhEX7YhFoa4DXhjNf19ghxIK9sQh1MCIm35ShUyjBsoNxEElkOLIinMhGR9M0fruXj59u5+HwinAMJcgH6oFIIsO3N3NwNa0KZ9dGItienGzuQUZlKz48nw5XMx0cZaEeUkGFfztU5I0K/zr0SILZgsOh8OErnnhvrDsW7YvD9XR2Qa88Lgffz/TDK76W+PJyJpFdpweLIhzw2UQvrDgYj8d5vRt6lIHLofDT7AB4WelhPoENTJ3Hxa5FwZBIaaw9mqgweHmgswkEzwgadR4Hvjb6uPT6QGxfEIR2gQTvnE5lfP57KsQlUho/3MphTIxwORQ+n+SF5i4xxv36Jxbti0VsUWO/6zkcCltn+yOnpl2hbUcZKIrC5um+SC5vxok45rk58nU+6BBIcIWw1ejLyT64m1WLRwre988meeFWZg0RqQcAH473xOXUKlbXojK8OtgJZxMrGAVeP4/1I12V7oovG+iIq2lVaO0msx3qaPAglMjwym9/ooSAMJ3kb4WradXEnxujPM2IbXEAEOnCMrTY1pBV7o2ruS7rxqmqFnZKrbo+CDQ9DT5+nx+EbfOD8O0MP3w2yRvvjfWAq7kuPCx0sWiAPWaF2GKSvxVGe5nDx1ofLV1itHQrVgTWtwvRKVRMGg9wMlYYng4AZU1dgNLIZOWobO1mRcKwtU1lV7fB05Js55mm6Wdhxb2HKJmMRlxxE3FYcbdIiqcFDRhJ2NzT3CnC04IG4jDe6tZuPC1owMxgMstUQV07oosaiW0faRUtuJZeTWz1iCpsQFpFK14dzFx5AQC3MmtRWN9BrNY5m1SB6pZurB+hOMBXGQ5GlaC5U4S3R5FZdLbdL0BhXQfeHeNOtO67G/KNgo3jPRivoWkaH1/IgKYaF59M8Orzd9V5XPw6NwAbRruCp0RZQ0PeCKoMIokM644mwVxPHV9P8WZMpHSJJFh2MB6OJtr4ZhpzAqalS4SF++LgYaGL72b4sc6CeR5tAjEW748Dh6JwcHkoEfEok9H4/X4BjsSU4tTqAUqb6fp7/mUH4xBV0IDzayOJ1XXP42ZGNebsikaogxF+mOn3UiHHANBFWGKgggr/BKjIGxX+dbibXYs1RxOJm2dexKwQW/w2NxDvnUnF3j+LWFUtUxSFj17xRISzvAmKzW777FBbbJ7ui9VHEvFIQcWyMnA5FH6a5Q93Cz0s2Bvbb4BoD7TUeNi/LBT1HUK8fSqlV86EvhYf7ua6oChgqJspjr86ALoafGir87B/aSgyKlvx9TXm1dS6Gnz8NNsfF5OrsPdP5lknbhZ6f8m3/8xvwMJ9sRj7y2NcTavqM4fEQEsNOxYE4bd7+UTvh5G2Gn6eHYBN17KQTzAIm+lqYFaILT69lIG6duaDsIW+Bt4f74Gvr2b1+gJiZaCJt0a54ZOLGUTNZrZGWlga6Yiv/4fV4a7muhjjbYHtD8iyb1zMdBCuZHgMsDWAq7kOziRUkB3Ms5dU3y7EpG1PGJNUg1xNIBBLkUBogRrsaoqK5m6i/CVAnnuTWdVKnIkVaGeAtIoW4lY8N3Nd5NeSHSMgv84q2GTeaKsRWQV7oMHnolukmITh9lkVTrOgYIBOEUvbVLsQ5nrkypuSxi7ipqlukRTFDZ3ETVNlTV1o7RbBz6a35SSrug1SGU2cd/O0oAHmehrEw9nNzBp4W+nD1ojstZ9NqMAgFxPippzDUSVYGG4HU0JV1Y4HhZgfbke000/TNH68lYvVQ5yIqotFEhm23MjGhtHu0CVQSbR0ifDtjRx8NsmLKK+prLELd7Jq8O10P2iqMR+Ik8uasetxIbbOCSBadyerFmcSyrFtfiDRAH4stgyP8uqxY0EQI9UURVFYM8wFUwOsQKE3FSuV0QrvAUD+3n14Ph3NXSJsnu7HOI9HJJFh7dEkqPM4+I0gx6ddIMaS/XGwMdTEz3MCwP0fEDetXWIs2hsLnWffv0hysSTPgqsvJFXg7OoIeFiQt9lVt3Zj9h/R4HM5OLU6AqYs7KTA/2VNvXM6FVvnBGDtMGdwOC83ohY3dGLl4fiXegwVVPj/ESryRoV/HfYuCUGHUIIZO6OIwnAVYZSXOU6sGoA/HhXii8tkLT/PY/VQZ3w6yQsrDsXjViZ5s82UAGtsmxeINUcTiJRAPC4HP8/2h7OpDubviWE8UOlp8HFoWRhya9ux8VxaL0XCqsFOWDXYCX8sDP7bFzMTHXUcXh6OK6nV+OMRc2WLlYEm9i0JxS9384gqxAc9J+EWS2nk1XbgndOpGLDlHvY/KVKa3eNnY4BPJnrijRPJRBkwkS4mWBrpgDdOJBM1N03ws8RgV1N8SGi7WhBmBwdjbfxyL7/Xz5YOdIA6j4OT8aWMHw8AXhvujML6DlbXoTKsH+GCs4kVL32/PY/5YfY4GFVCdM89n4HUIZB/BjzJ77/Om8/lYLyvJbF1SludhwhnY9zLJlPfmOnKB+CYIjJbppu5LmjIq2XJ1umgqKGDyJoIyJU3pIoqADDU6r9tShE0+Ny/VH0voq/MG9DyvBxSdAgkxPYYAKhvExIHFrd0idDaLSYmb3Jr26GnyYcFIVmUWNoMH2t9haG7MUWNCHM0Iq7BvpdTh5GeZsQ2jyup5JYpmYxGTHEjFhCqZ9oEYpxLqiTKLQHkap37uXXE2TMPc+tR0tiFZQPJ1h2OLoEGj4vZIWSNVr/fL4CfjT7GErR90TSNjefT4GKmgwEEVrkukQQbTqfizZFu8LZintVU2dKNd8+k4pvpvrAnUJollTXjm2vZ2D4/kIgcvZRSiVuZtdi9KAimuurgc//v+nQ101EaPP3rvXzEFDVi/1LmahWZjMa7Z1LR0CHEnsUhjEOtu0QSfHYpEwZaatg2P/B/UnXd1CnCe2dTYaqrgd2Lg4kCtgViKdYeS0JGZStOrY6AvQm5IjC3ph3Td0TB38YAexeHsAp/B+T2unfOpOJoTClOrY4guraV4X5OLSZve4IIZ+Y2PxVU+KdARd6o8K+DgZYaDi0PQ4iDIaZse4qEEna5NT3ws5FXiT8paMCao4lKd4b7w+wQW/wyJwBvn0rB6QSyymoAGOllju0LgvDumVRcSGauSOBxOfhlbgAcTbSxYG8sYwLHWEcdx1aGo65diM3Xs/9GOkwPtsGHryiuf7Qz1sLBZaHY8aAAZxOZH6evjT5+JqwQH+Bk1CsHQyiRoaFDhO9v5SJ0011svp6tsDp9fpgdhria4P2zaUSNQW+PdoMGn4tvb+QwXgMAX032RlplK9E56QmSPhxd0ktFwudy8OVkb3x7IxflBLkkuhp8vDvGHZuvM88n6g+u5roY522B7YTZN31hnI8FpDIadxkSIwKxFILnVEg05NfC0gNxuJzSPykzLdAaOTXtxATHKC9z3M0mz70Z6GKC6ML+iaXnweVQ8LXWR0o5mULI1lALXA6F0kay7C1rQ01UsiDkjLT7b5tSBA0eFwKx4vPP5XAglSqvCmeTGyGvCicbOLpEErQLJcSBxcUNnTDRUSNSWQByy5SXJXm9ttwypSTvprAREYSWKZqmcT+nFiM9mGeXAEBtWzdomsYEX7KBLKaoETnV7RjiRmbROptQAXcLXaJMFwDY+bAI0wKsiZqiZDIaP97OxbphzkSDa/OziuuPJ3gSEWip5S04HV+GLyaRBdyejC9HSUMnPhjH3L4EAJuvZ8NURx2rCIJ4xVIZ1p9Ixiu+FphMQNjVtwvx7fUcbBzvoVSRqQgp5S348Hw6fpsfiNHelrj51hB4W+lDnccBl4LSvJszCeXY96QYB5aFMiaKaJrGV1ezkFbRgoPLwhjfywKxFK8eTkBtmwB/LAx6aSsQID9f8/fEQFudix0LyB6zXSDGsgPxaOwQ4vTqCJixUBFGFzZi1h9RmBtqh29n+BITwT1o7BBiwZ5YFNZ14NJrA+GjIJyaBDKZPL/njePJ+GaaL94gtBaqoMI/ASryRoV/JfhcDjZN9cVbo1yxaF8czrAgS56HrZG8Sry1W4y5BCHAL2KMtwX2Lw3F11eysOsR+aA7wsMcuxeF4JMLGThJUBfN58rlvaEOhliyn3mFubmeBjZN9cGVtCr8fCeP8fP5WOtj16JgfHoxAw8IAl3HEFaIB9oZQqxkoBOIZegWS3EwqgSR397H+pPJfyPeKIrCpmk+EEik+OEW8xBfPpeD3+YG4lxiBZHiwlBbDd/N8MVXV7KI1Ayu5rpYNcQZG8/3JplCHIwwyc8KX17JZPx4gNwSGGBrgCPRZKqdvrB+pAvOJf3v1Dd8LgeLIpjXhte3CxVaZyQyGhtOy62PfSHIzhDlTV3EWTQjPcwgk9HENqEIZ2M8ZZN7Y2eAZMLcGw6HgouZDvIIrVM2BlpoE0j6DB9WBENtNTQTNLr1QFONg24lijYet4+2KZpmp7xhURVe1yYEn0vBkMAiAwCljV1EKoQeyPNuyO0MiSXNCkNDJVIZq7ybzKpWuJnpIsyRLIj0ZkYtpDRgQViffSqhHNMCrYkCh+X14CVYSqiCqWzpxpW0KqweSpZZczOzBg0dQiwcQNZMdTCqBCM9zTGEIBhW+iykeMVgJzgoqH5XhppWATZfy8Y3032JiMMHuXW4lFyFn2b7E9l7fr+Xj3aBGJ9N9Ga8RiKV4Y0TSTDX18DiCObnsqZVgFWHE7BhtBuGP6uRNtJWw+nVEZjoZwkpDYQqyLt5kt+Azy5lYtfCYLgRBD7velSE5LJmHFkRztiSJ7dYJUIglmHP4hBoEtialKG2TYC5u6PhbqGLH2b6E90jjR1CzN8TCz6Pg6Mrw4msfj24nFqF5Qfj8clEL7w5ypV14HJebRumbH8Kc30NnGJJIj2PdoEYq48m4kxiOc6siSQiD1VQ4Z8EFXmjwr8aiyIcsG9JCLbcyMGvd/NZ254AuaLnyIow2Btp4sNzacQ5Fz0Y4GSME6sGYM+fRdh8PRsyJTkOyjDI1QQHloXhs0sZGPXTQ8QVNzF6XXwuBx9P8IK5viYW7YtjXJdta6SFYyvDcTS2jIhwinQxwU+z/LHpWjaSCeqbSSrEPSx0wenni4NIIgMFIKawsZfVSUuNh2+m+eJYbBmRjcjOWAubpvlg+4MChaoeZRjhYY5XfC3xwdneVrS+8NpwZ3SJpDjwtKTXzz4Y74GE0mbcJjh+LofC3DBb/Ho3nzUR+SJczHQx3oc8+6YvzAu1Q2pFCzKr+s+uaegQKv0SK3lWYfpNH1lMXA6FiX5WuJxCFixtZaCJbrEUD/PI1DfhjkbQUeeilrCKO5Bl45SbGXlosZ4mDzrqPGLrlKEWn3XmjVAJeSPPvFGivKHR7+eAInQKpdAlzLypa5fXhJMOLCWNncSWKQDIqiInb4QSKURSmcLw0cyqNgTaGcCLMO/mXnY9dDR4xO1NbCxTrV1i3MyowZxQsqDih3l1EIilGE9YUbzncRFGe5nDiSDLRyKVyXf4R7gS2VUK6zvwx6NColYjADgeW4o2gRhrhjJf1yEQYeYfTzHCw/QvcoMJmjpFeP9sGj6b5EWUU/Q4rx7nkiuxbV4QUT7Odzdz0NwpxnczfBnfV90iuZplmLspVgz6O1mnxuPgx1n+OL4yHCNeaEbLrm7D2qOJ2Dzdh6g560hMKXY+KsR3M/0YnxPJMxVSQ4cIB5aFsrYVPY+qlm7M2RWNQDtDbJ0dQKR4qWrpxuxd0bA31sLexSFE+TiAXHm0+3EhTsWXYefCIMwOIbs/n8eD3DrM2BGNpZH2+H1uINE9pAgFdR14/2waBGIprrw+iPjzTQUV/klQkTcq/OsR6WKCc2sjcDm1EisOxfdLCPQFdR4XP88OgKu5LmbsjEI8S0uWj7U+zqyJRElDJ7FtBwDCHI0wI9gGBfWdmLM7Gv5f3saGUym4l13bZxaLGo+D7fODYK6njsX7Y/+WEdIXXMx0cXh5GLY9KMCxWOZqjVf8LLFwgB2WH4xnTHY9XyH+9qmUPm0sPC4HHv20sKjzOPCz0cett4bAULt3Q4yzqQ6+n+mHd8+kEtlKpgRYw9FEGxtOk9WOfzLRE8UNnUTnUZ3HxbfT/fDz3bxeFikjbTV8ON4DX17JQpeIeUh3pLMJIpyNsZVAUdUf1o90RV5tB8qayOw5ymCorYZpgTY4qIC0ehENHaI+d4jFUhqHokux/mSy0mtqsr8VbmfWEOUZAcAoT3PczSIjbwy01CCjgWjC3Bt/WwM0d4qIA9m9rPTQQFChDsjvRXnjFCl5I7dNkbZ39WWb6ivzhk1gsUxGs1PetAuIg3ABufKGtGlKJqOhqcaFlxVZ05Q6j4sH7w5TeJwxRY1Q43GJw1Lv5dQS1T0D8mExpbyFmEy5nFoJLys9ohpsADjwrB6cJE+koUOIk/FlWEtAisiPsQraajziAXbL9RzMCrEhem0NHUL8cCsXX0z2ZjTk0jSNy6lVCN50DxXNAqwkaMGiaRo/38lDkJ0BZgYzz+Opaxdgw+kUvDnCFW4WzF/b1bQqnIwvxx+LghmTCTRN492zqdDgc/D1VMVNTxRFIdLF5G/kRnVrN768nIl1w52VVpArO8Zvr2dj/9IQxqG+UhmNd86koqSxE4eXhxFVdytDeVMXZu+KRqSLCb6f4Ud0DxfVy8mNcCdj/Do3kJiElcpofHklC7sfF+PD8Z4YRkAGPg+apnHgaTHWHU3Cpmk+WDnY+aUbt25n1mDa9qewN9bCgaWhMGDRBKiCCv8kqMgbFf4TcDTRwYXXBoKmgek7oohqhF8El8vB++M88N5YdyzZH4eraWQ79f93TNr4eqoP0ivbsPZYEvHA+PEEL3ApCjQtl/9fTKnEa8eT4PfFbSw/EIeLyZUK1TVqPA62LwiCsY46luyPY0xm+Vjr4+CyUGy+lo2LycyDXZcNdMTcMDss3hfHWKXSUyFOy2h8dimzz5Dfgc4mSmtC+VwKs0NscHp1hELipgev+FpiVrAtXj2cgA4Ccu/LKT6obO4mqh3X1eDj+5m+uJVZS3QdhjkaYUqANT6+mNHrfMwKtoWFvgZ+VRBs3Bc+esUT5xIrkFPTRrROGZxNdWBrqIkd/8Psm+UDHXAptapfhVB9uxD9ZUGLJDJcSa3G1tuKCSs/G30Y6ajhYS4ZETPK0xyP8uqJmr8AOYH2tIAs98ZSXxMcDoW0CrK6d0cTbcQWk5PNIfYGqG8jI32MtPnwtNRDC2HVuwafA5mSN5HXR9sUG3SJpDDTVYcOgUIAkEvzlbXX9IWmTiFcCFuaKpq7EV3YCBdTMhKjL0QXNSKCILQWAOraBMisasMwd+Y2HwC4llaNCGdjmBC0NwFyyxQpKVJQ147Y4ibMIww4PpNQjgm+VkRZG2KpDL/czce8cDuiITiqoAGxRY3EVd1brucg0tmEkXoms6oVU7Y/xTunUyB8pjr1IggbPp9UiRsZ1dg8jbkKRiqj8dbJFAxyMcEsggDmvNp2fHA2DVtnyzP5mOL3ewVIKWvBzhcKE/pCT86LvbE2kXrpz/x6vHcmDdvmBym0ISqCTEbjw/NpyKhsxZEV4X1+92CK4oZOzN4VjVGe5vhmqg8R4ZFR2YpZf0QjwNYA30z1ISZuBWIp1h1LxOP8elxYF8k6l0YsleGTixnY/qAQx14NJw4VfxEyGY2tt3Ox4XQqvpvph43jyTKkVFDhnwrVVa7CfwZ6GnzsXxqK4e6mmLrjKaIIh6YXsSDcHtvnB2HjuXTselTIqnrZXE8Dp1dHoKlThMUERAoA6KjzMMLz/77MyWh5zotIKsP93Hp8eD4dgV/fxowdT3E4ugTVz9kz1Hlc7FwYBAMtPpbsj2OcaRFsb4Rdi0Lw0YV0IpvO+2PdEeFsTEQW6Wrw8fU0X9zNrsWePvJKgu0Nle60vjvGDV9PZRamt3G8B0obO+H/5R2ciCtjNIjrqPPw69xA/HYvn8jKMtDFFC5mOnj3TCqRlW/jeA9kV7f1Is84HAqbpvrg4NMS5NYwt8Y4mGhjcYQ9Nl3N/p9Vh78x0hXnkyuJQpT7gqu5Lga5mOBSP6HDDR1CSJQM9xTkCiw9DR7WDHXCkkgHxb9HUZjsb4Urqcwb3QDAx1oP2upcxBaTZdhEOhsjqrCR+NwH2BogmTC02M1cF8UNncQEE8WhUEQYdKylxkN+bQdaCHNvNPhcpWpAHpcDibLAYha2qU6RBHXtQmLlTUljV78koSKkV7bBxogs9yWrug0uZjrEu+TKIJbKEF/cRBxWfD+nDv42+sQkzJW0KkzyI7NMZVa1orCuExP9LInWnYwrxyQ/i7MlowABAABJREFUK6JjbBeIseNhIXHj05mECvC5FKYFMh8+pTIam65l4/URLkRV5HHFTbiZUY3PJnn1+Xs9VqfJ254io7L1ryw4Qy0+42G9vKkLX1zOxPcz/YiOcceDAlS3CrCJgPBpE4ix5kgilg10xGgv5oqu6+nVeJBXhz2Lgxm/12KpDOuOJcFMTwObpilW6ihCSnkL1h5NwpbpvhjuwUxpQtM0frqdi5iiJhxbOYCVSu9F5Ne2Yf2JZEz2t8LnhGHVMUWNmLc7BquHOuHdse7Eds/mThEW7I1FY4cI59ZEEtnonkdrlxhLD8QhsbQZl14fiCA7xWHqjB+vW4yVhxNwObUK59dF4hVfss8LFVT4J0NF3qjwnwKXQ+HjCV746BVPrDiUgCMxLxfYOtzDDCdXDcDeJ8X49FIGsf0JAPS1+Di6IhxaalzM3RWDegJrw+wQW6gr+WLfLZZCRgOJZS345lo2Irbc/9suvzqPiz8WBkNXg4+lB+KV1mq/iEGuJvhlTgC23snDk7x6RmsoisKW6b6w1NfAqsMJjFVG1gaa2L8kFL/ezcfNDMUDdaCdwd9CTnkcCvqafEz2t8SllGrG7WBqPA6mBlhDStP45EI6Bmy5h0NRxf0eq7+tAd4c5Yr1J5KJgl3fH+eOhg4h9j1hrtrR1+Rj01Rv7HxU2CtTxNNSD4sj7PHF5b6VSi/i9RGuyKpuw32CYOm+4Gyqgwm+lth2/3+XfbMw3A5/PCrqk3iobRP0Cq+mKDlxE+lsjG3zg5D46WhsHO8JC33lwYiT/K1wN7uW8f0gfx4KozzNcY+wdSrUwQh17QKUERJdgSxCi60NNMHncogbp6wMNFHVwjzXCZCfD0NtPnFosaYaV2lgMbcP2xQN8sDidoEEmnwu8U5tXZsQZoQDWWu3GE2dItgbkdmm2IYVK0N6ZSv4PA48CGwtQE9FOJllqqShE9nVbcS1v6fjyzHBz5IoXLe1W4zjsaVYNtCB6LmOxpTB3ZwshFkgluL3+/l4e7QbkYLhXFIF2oVipcSxIoilMnx6MQNvjHSFlYFi4k8ileFQVDEGfXcfF5MrIZXReP42Me/js+55SGU03jmdiskBVhhB0CgWV9yEHQ8L8fu8QKK67Y3n0mBjpIW3RzNXIWVUtuK9M6lYN8yFsZqIpml8fCEdDR0ibCeo6C6oa8eyA3HYMNoNUxmSdDRNY8uNHNzMrMGxleF9/p1hipyaNszdHYvRXubYON6DiHy5m1X7LFjYE6uGkNkCATmZN2NnFEx11HF0JXsFUXFDJ6btfApNPhdn10bCWsm1zBR5te2Yuv0paJrGpdcHEYVOq6DCvwEq8kaF/yRmh9ji8Iow/HInD59ezIDoJSqTfaz1cWFdJGKLmrDqSCKR7aYHmmpc7FkcAjdzHcz6I4qxamGomymjL5A0gFAHw14Blhp8LnYvCoajsTZWH0lgnKMxxtsCa4Y6Y/XRRMZV7Hyu3K4lEMuw4XQKY8VJT4X4htOpCivEjXXU/xqm1HkcOJvq4NZbQ/DjrABoq3Px3tlUxmTGKC8L8LkUpLR8J3PL9RyEfXMXux8X9pkns2qwE+yMtPDZJeatT1pqPPw02x9b7+QRBcmO8bKAnZEWNl3L7vWzt0a5QSCREtWR62vy8fZoN3xzLZtYlaEMb4xwwYWUSpQ1/m/UN8PczaCrzsO1dOUWxZ5cFg4lJ+JMddQxyc8SLmY6OLoyHKO9zBl9cXcz14WjiTbuZDFXlgFy69SdrFoi4kxTjQs1Hgdvn0wheq5AO0MklTYRPRfbxilrA01UE2beAPLcG6atdj2QBxb3lXmj+GdslDCdLPJuAHm2B9Nq4R6UNnbCUItP3OwiJ2/+h5apwkaEOxoRWS4EYime5DdgpCdZxsW19GoMcTUles0CsRTpla2YSxhUfCahHF5W+kR2DoFYin1PirFuuDPjgZimaaw+kgguh8IrPsx3+juFEvxwKxcbx3kSBbMeiiqBi5kOlitpz4oubMSorY+w+XoOukTykOoXYcdQKbH3zyLUtQvw8QRPxsfX1CnC+hPJ2Djeg+jc73xUiKZOEX6dE8CYAKtrF+DVwwl4bYQLkVLn9/sF+DO/AQeWhjImBKtauvDa8WQsCLfH8kGKz70i/Hw3HxeTK7FvSShrhcrzyKhsxbzdMVga6YD1I8lanS4kV+CNE8nYOtsfc0LJrIQ9zz1tRxSGuJli+4Ig1oHC0YWN+PxyBkZ5mmPXohDGBJ8y3M2qxfQdUZjkZ4l9S0Khr/nyWUIqqPBPg4q8UeE/i1AHI1x6fSBaukRYeiCeeNB4HjaGWji7NhKmOuqYtycWde1kO9WAnNzYOjsAw9zNMH1nFHKq+88hUeNxMMHXEn3NpGpcDjwtdHF4ebjCP8AafC42TfMBACw7EM+YwJkaaI2PJnhi2cF4ZFQyy9/QUuNh/9JQVDR3Y+vtXMbD5xhvC2zoo0K8Z+d0tJc5Lr0+EBb6GlDjcbBjQTCSSpuxk2FLlreV3t+sGQKJDG0CCbbezkPoN/fw+/18hbYvDofC1tn+eJRXjwvJzImTYHsjLIl0wDunU/sMZn4eFEXhqyk+uJVZgyf5f7f+aavzsHqIE7bcyCG6nueF2kJDjYvzScyPvS84merASl8DY395hDqCNi5l4HAoLIl0wP4nJUqvmTaBBFwOhdGe5jiwNBSxH43ED7P80dAhJM56mRtqixjCIOEIZ2M0dYqQS9joJBTLkFTegksEOVLOJjpo7BTjUFQJ0XNZGWgQZ+xYsQgsBuTkTRNh45QmX7nyhseh+rRNkdoBOoQS4qYpQK68MdUjU96UNHbBgSDTowfZNf9b5U1MUSOxZSq6qBFG2mpwJ9zdzq5uw5QAMsvUrcwatHSLFbZkKYNURuNwdCmWEqpuziRWwERHjXELU7tAjJWHEvAorx52RlpEBNj+p8WwM9LCK77MVUjVrd34+U4eFg6w72Wbq27txspD8Vi0LxYljV0QKiHdORQY1dNnVbXhl7v5+HlOAFFo8BeXM+Fvq09U7/1nfj22PyjAJxO8GCs5BGIpVh1OxAAnY6Jg6XOJFdjzuAgHloUyVsE0dYqwaF8cBrua4J0xzFVBOx4W4GhMKY6tDGd1r7+IlPIWzN8Tg7XDnPHGSFeitQeeFuPTi5nYszgE4whIxh48yK3Don2xWD/SBZ9P8iLOyOnBqfgyLD8Yjwk+lvjoFU/WjwPI7/Pvb+bgrZPJ+G1eADaMcX/poGMVVPinQkXeqPCfho2hFr6d4QcddR6mbn+Kgjqywet56Gvy8fVUH7iY6WDa9ihWj8XhUPh8khfWDHXC3N3RjFQtM4NtwKUU38p8LgUXM20ce3VAn9WdGnwu9i4OBZdDYfnBeMatRQvC7fHGCBcs3h/H+PUaaath+/xAnEmsIKqV7qtCfPkgR2yZ5ovf5/29ctJUVx27F4dg2/0C3M+p7fc5LPU1oKXe+zwJJDJ0CiXYdr8A4d/cw4+3cnuRI2Z6Gvhxlh8ORZWimKBG/u1RbhBKpEQhv1YGmnh3jBs+upDeyxY21tsC/jb6+O5mLuPH43E52DjOA5uvZ7OqeFYEf1sDdItlGPbjQ/yZz8xe1xdmBtugpLETiaWKs15+mROA+I9HYdfiEAx0MQGHQ0Gdx8X0IBucii8neq4RHuY4n1RBdC40+FzMCLZBTCHz3Ju6NsFfVqB3zqQitojZ2sxqOVm66Vo2UbZQemUrTsaXEWVr6WnyUNUqQCNhpTyHQ6OI4D4A5IHFymyOXC6nb9sU0TPhWdMU2W4yTdMobeyEMWGbya8KWuL6Q7tAjPKm7v8ZeSOSyJBQ0owIZ+b1yACQXNaMiX6WRORYXm077mTVYgSh1er0s6Bikud6kFMHkURGZM+SSGXY9agQa4cxU92klrdg1E+PcP9ZkPkQV+bnsLq1G7seFeKziWRZJZuuZmO0l7nCcOkj0aW4m12n9H7ogTqP069FRSCW4u1TKXh1iBMCCXJI9j0pRl5tG76b4cf4dVU0d2H9iWR8OdmbsVKHpml8eD4dALBlOvNMnejCBnx1NQs7FwYzbojqFEqw7GA83C108eF4T8bPdeBpMXY9KsKRFWHEDWnPQyyV4Ul+A2bueIpp259iw2g3IrsTTdP4/X4+ziRU4MiKMAwiuE57cCq+DOuOJuHLKT5YHOFATIoDcqLlm2tZ2HIjB/uXhmJOGLny53m0dImw7GA8bmbW4OLrg4hsfSqo8G+EirxR4T8PbXUe/lgYjIl+Vpi2IwoPCJtmnocaj4Ots/0xPcgaM3ZGI4bhMPY8KIrCikFOeGesBxbvj+uXdAh1MFIqRdXkc3FoeRgjqaqmGhf7loaAooAVBxMYZ8WsGuKMheF2WLA3lvGAYmukjUPLw7DrcRFOxZcxWtNTIW5nrIlvrmb9TakSZGeIeeF2Cr9o+Fjr49sZfnjzZAoK6voeJimK6jMPQiiRoVssxZ4/ixC2+R5upP89h2eEhzkCbPXx1qkUxhYkDT4XP80KwM5HBYwVTACwKMIBRtpqvRqmKIrCl5N9cDG5EkllzENth7iZItjekLixShl65PpdIimWHYjHtzeyWWVC9UBbnYc5IbbY/7RY4c9tjbRgpGAnd06oLa6nVytsXlMGO2MteFvp40YGmXXKz0YfF1OYt8+lVrRC8xnZKJHRWHYwnhEJGlXQ+NeaxftjGZGtMhmNxg4RZDTw3hnmVsL0cvk1ufF8GqPf70FCSQsORZcSWbs0+FwIJFKFa/h9Zd7QIM686RBIoM1QZdCDE3FlEElpovsqoaQJhfWdaOoUEV3/OTXtMNVVJw4JVob0yhZ4WurCzZx54xVN0zibUIFIF7Ih8GpqFUZ6mhFZJMqbuhBX3ITpQWQNNAejSrAogqwe/EpaFbgcChP6CTmVyWjsfFiAGTujUPeszY7HoYhykn64lYuRnubwtzVgvOZxXj0e59XjIyUWpnfHuOOLSV5Q43GUNi0C8r8Flv0oTnY/LoI6n4M3RrgwPr6U8hb8eDsXm6f7Ma5lFoilWHs0Sd7sSNAk9sejIsQUNWL34mDG1p3cmnasOpKILyd5MyYwhBIp1hxNhI46Fz8T2LlOxJVh6+08HFoeBm+CVq8edIukuJlRg9efNYUuORCHhLIWGGmrYakSu5wiyJ5VeR+NKcXPc/yJiDjg/yriv7mWjQPLQjHZn0w114MOoQSrDifgXk4dLq4bSNxs9yKyq9swedtTqPM4uPTaQLiYkTX2qaDCvxEq8kYFFSBXvLw71h2bpvrgtWNJ2PtnEev2HYqi8M4Yd3z0igeWHYjvtyVHGRYNsMf3M/3w2rHkPq04HA6FGcHW4HP/78sGj0PB1lATrmY6ePdMGuOA4B5bk1RGY+XheMbr3h7thld8LTF/bwxqWpnZZDwt9bBncQi+vJKFu1n9q2IAuUJk6+wApFa04nOCYN7J/lZYOMAeqw4nKG2z6UGIvRG4/UyCMpqGthoXdsa9fe0bx3tCJKWx9Y7iOmpF8LXRx7phztj5qBBChvlLXA6Fb2f44mBUMTKr/k762Blr4bXhzvj4AlmI9scTvHAiruylFGjPo+f7r0RG48DTEszYGcW4Ll4RlkQ64G5WHSoJbDxu5rrwstLDpVSy+3CyvxUuE64Z4WGG9MpWxrbJlLLmv5GQArEU83b3b7t8Ply6slmAN0+m9HsvpFe2/kV+3M+pw5kEZmqks8+sdPey6xgrg3Jq2uREp0iKy6nMySwNPhc0DYU2EC6HUnots/mk7hSR2aZaukR/5UzdZvh51SmUYN2xpL/+P5qAzM+taYcnYbBwX3ha0AhLfU2infSs6ja0dosxwIl5oC9N07iSVk3cMnUmoRxD3cxgpss8Tyi/th3xJU1EGTlyQqYQq4c490nC1LULMGd3NH65mw+JjP7rGuNxKcaDfVpFC66nV+P9cR6Mj08okeLzy5l4Z4yb0nPB4VBYOtAR9zYMRaCdAdSUvA6xVKY06BgAogobsPNhAX6e48+Y/GrtFuONE0l4e5QbUWPQ55cyweVQ/bZmPY+HuXXY9agQexaHML4uatsEWHYgDssHOmIqQyJQKqOx4XQqWrvF2LUohHH9+MXkSmy6moX9y0IRQEDOtXaJcT6pAkv2x8Hvy1t461QyrqVVo1sshVRGg8sBPnyFefaQWCrDO2dS8TC3DmfXRMKdodLo+fUfnEvDmYRynF0biQGE1soeVDR3YebOKAglMlxYO/Cl7WOXU6swc2cUZgbbYNezcg0VVFBBRd6ooMLfMCXAGsdfHYDdj4vwwbk0xoO0IswJtcMfi4Lx8YUM7HhYwIoMmuhnhd2Lg/HJhQzsf6JYcQAA0wJt/mqY4HEomOtp4Py6gTi4PAydQgmRFUpLjYcDy0IhksjwKsNmKIqi8OkEL0Q4GeONE0mMLRYDnIzx0yx/rD+ZrNQO8yJ0NfjYtzQUd7JqsfdP5efkRbw7xh1u5rrYcj27z7BkXxt9qPOVfzSq8zjwtzXA3Q1DFe60afC5+H1eAA5Hl/TKpOkLa4e5oLSxEz/fYa588bDQw4pBjvjwfHqv1/TqECcIJVIcimbeqOZipoN5YXb4RkEYMiko/D2HRCiRIbOqDSN/eoRHDFvKXoStkRaGe5jicHQJ0bq5obY4EVdOdA9O8LNEQkkzEdlkoqMOfxt93GfYOhVT3Pg3NYmMBpq7RFiwR7mapkMoQd5z5JpIKsOjvHrseNi3BfF2Zs1fZJpYSuOTi5ko7MfWVN8uRNyzvCAZDbx5MoWRIu9wVAkoyEmVzy5lMm5h61EhKQot5vdlm6JBbJtqF5AFFn95JesvUimmqJERQff55Uy0PCOLaVo+7DFFZlUbUQhsf4gubMQAwl3we9l1GOxqyniYBeTHXdcmYFytDMiH5zOJFZhDGFR8MKoEk/2tiGqt7+fUwtpAEzOClQ/2j/LqMfKnR0gpb+lFJFKg+lS79ICm5dXgKwY5ErXr7H5UBE0+FwsH9J8jY2ukhdOrI7BqiCMooNdxiaW0UvKmTSDGu6dT8dErnnA2ZUYSyi1MaXA21cGrg50YrQHk6pS72bXYuTCI8bWUU9OG148n47sZfozvgw6hBMsOxCPC2QRvjWKWE0PTND6/nIHsqjYcWBrKWC12La0aW2/nYveiEIQ69E9u1rUJcCSmFDN2RiHw69v4+EIGHuXVQyylIRDLXiCgKYz1ZmYNEoilWHMkEdnVbTi9JoI4KLlTKMHKQwlIq2jF+XUDWTc3pZQ1Y+r2pwi2N8SBZaHE4ezPQyKRYfP1bHx8IR2/zQvE+pGuqnwbFVR4DiryRgUVXkCArQEuvz4IOTXtzyomybIensdQN1OcWj0Ah6JKsPVOHivbyGBXUxxdGY7f7+fjJyUhv56WurDS1wBFAcbaaji3NhKmuurQ1eDj0PIw0DSweF8c4yFKW52HA8vCoKXGxYZTKYwIHA6HwpbpfnA21cHi/XGMczXG+1riw/EeWHGImWUEkDfg7FsSgl/u5uEmQ2sLl0Ph+1l+iCtpwg+3lOfBeFvpK329PA6FlYMccWpVRJ8Dg4uZLj6d6IV1xxORXMq8jWvr7AAciiphTGQBwBsjXGGqq46jL9Teq/O42DTFBz/fyWOshgKAN0e64mFuPebtjvmftU/1QCKj0SGUYMXBeGy+zs5GtSzSEZmVbYzJSEBOgpY1diKjsv8Q8B6Y62lAU42LhXtjiUifUV7muMuAvJHJaGRW9T4eiYxGaVMXVh1OVHh+4ouboP5CgKlIIsPPd/LxsA/L55W06r9VqUtkMrx6KKFPgvpKauXfwlKbu0T4/lZOn6+rUyjBuaTKv4aRbrEUP91mpkJT53EQ7miELnHv91aDz4GtoeJB1MpAo89ML0XgUBTjJp6YokZcSa36iyBV43FwPqlvIuZ+Ti0upVT+dQ/RAG5m1DAOJs+uboP7/0h5IxBLkVjWTBxWfC+7lqhliqZpvHYsEbZGWkTtNE8KGiCR0Rjubsp4TXOXCE8LGoiqt2maxvaHhYhwNlZIIogkMnx1JRMrDsajXSD52/3yPJgMkrcya1FU34G1w5jbkcqburDjYSE2TfNhbM0SSWW4mVmL14Y5Y5CrSS8FrqGSIfqLS5lwMddlRBL14FhsGRJLm/HTLH/Gw3RqeQt+uJWL3+cHwlKfGYnV2CHEioMJeHWwE8b6MMsykkhleO1YEgy1+UTZOL/czcPdrDocXhHGmAS8l12Ld8+k4sspPhjI0JY1fWcUvricicTSZshoKA1mB4ChriaMVCZtAjEW749Da7cYp1ZHEKnWALm67O1TKZDIZDizJoJ1tfmllEos3BuLDaPdsGmqD5GF8UU0dYqw+IDcgn/ptYEYSZibpYIK/wWoyBsV/nWIJ2yWUQQLfQ2cXDUA3SIppmx7imwGzU/K4G2lj/NrB+J2Zg1ePcy8jvt5BNoZ4syaCJxNrMAPt3J7qSwoisKCcHsYa6vh7NrIv/0RlhMxodBW52Hh3ljGLUQ66jz8OMsf1W0CrDmayEiFxOXIm5DM9TSw/ABztc+iCAcsGmCPFYcSGNcS+9kYYOucALxzOkVhhbgi6GnwsWdxCI7Fliq1s9kbafX68sHlUOBQcivNe+M8GMnm54baQiSRYdrOaHx9NZNR+K2buS7eGuWKd8+kMs4c0uBzsWKQI76/mdOriSvSxQSzQ2zwy13m4cWG2mrQUuMiuqgRo39+RJTD8zdQlFI1hERG41BUCabtiEJ1K1mTUbiTEZo6Rf0Oz89DW52HSf5WOMkwX+l55Nd14NNLGYwJnGFupribXYu8mr6JyOLGTqXkmEgiQ3xJEz6+2Pt5nxQ0KBwqJTIaa48mobihs9fPypu6el0bMhqobOnGpqtZSo/xeGwZBM+pYIQSGY5ElyK5j8yXSylVf8ufEUlkOBJTijwGLVw8LgfJZS0KlTc0DaWZVZXN3Uobd5ShurWbETkpEEux4XTK31Q/ArEMh6OVN581dYrw1smUXu+TREYjmkGgtUxGI7emnXHQan9ILmuBgSYfzqbMbQzxxY1IrWhlrKChaRqfXMhAaVM3sQrqdHw5ZgTZEGXJnE2ogKmuOpE6KaaoCUX1nZgf3puwKGvswoTf/sSx2LI+g4ApqrfC5UWIJDJsuZGNDaPdGSs5aJrG7sdFmBFsTWRH+v1eATT5XLw12g0HlobilzmB0NXggcuhYKyjppDEuJhcifu5dfhhJvOw4ayqNnxzLRu/zAlkTHI0dgix9mgi3hjugkiGQdkiiQxrjiYiwM4A60cyI75omsanlzJQ0yrAzoXBvdq5lOHg02JEFTbi8Iow2BgyI3L/zK//q4KbRF324yz/fu3YgJykZpIJ1NAhxLzdMdBS4+LIinDiyuzC+g5M3xEFY201HFgaxsqSJJPR2Ho7F59cyMDvC4IwP9yeVcBxDzIqWzHp9yfQ11TDD7P84WT68vk2bOMPVFDh/2eoyBsV/nV472wqdj4sfOkPbS01HrbND8LcUFvM+iMatzPJwkufh7WhJs6sjYRIKsOc3dGs6pNdzHRxZnUEHuXV440TSb3IlFVDnPDkgxEKZbMafC52Lw6GmZ4G5u2JZWxr6lHuNHeJsfZo7+dUBHlFdxB4XAqrjzAjfQBgw2g3jPO2wJIDcYzDZcd6W+DtPirEFcHZVAe/zQ3Eh+fTkV7Rm5jgcKi/heKp8zhwMdXBkRVhuJ1Vyzifh6IoTPWXS/MPPC3BgC338POdXHT0Q96tHOwEA00elh+Mg6yfNpEeRDqbYIKfJT5VMOyvGeaMa+k1RFYlx2dDXmljF6Zuf4ofb+X+z1U4QokM2dVtGLVVbk9gCoqisHyQIw48LWZ8fgBgXpgd7ufUESl2eh7/VHw5Np5PZ/R8as92vmf+EdVnVXZqeUuf6gShRIYLSZX444Wa+4e5dUptf0KJFIv3x/a6xm5n1igcaIQSGU7EleNedu9ruqCuHUUKiCCpjMb6E8kK72uaprH3SdHfCJ+ef//gbBqjz2R1PkfhrjSvz7YpctuUvG2q/8H69/sFaOzo/T7WtwuRrOC6pWka751NVfgaxFIZI+tUaVMXpDIaTgRkS1/Y+6QILmY6jAer5k4Rlh6IByAnvPuDTEZj4/l0nHqWo0RCwjR1ilDe3IVZITaM10hlNA5Fl2AZQaArIK9zXhJhr5BQOZ9cgfy6DkYkIKef83g4ugQaPC5mE7ymO1m1uJJWhQ2j3Rmvyaxqxd4nRfhuhh94XA4oisIEP0s8fm84xvtYINzx70qr1m4x3j6VgrdOpWBJhAPM9ZgpLTqFEnxxJROrhzoxDqCVSGVYfzIZgXaGjGvcaZrGJxfTIRDL8ONMf8bX646HhbifU4cDy0IZXa+AXC3yw61cfPiKJ2OrUGxRI1YfScTmab4Y30/Y9YsY4GSM/UtD/6aMUgSaRr+kUGVLN944ngQvSz3sXhRCrDpMKGnCjJ1RmBJghc3TfRmTXc+jWyTFGyeScSGlEufWRWK4O3MiSxHOJ1Vg9q5ozA+3w44FQURh58rQKZTgi8uZL/04Kqjw/xtU5I0K/zrsXBiMozGlWHM0kbFNSBkoisIbI13x4yw/vH0qBdsfsMuuAeRfgg8sDYO7uR6m7YhitBP9ImyMtHB4eRgqmrux4mDC34Y0DofqcxhU53GxY0EQnE218caJZMYEkp4GH4eXh6GhQ4hVhxPQweCcavC52LskFG0CCd44nszIKkBRFN4b6w47Iy3GWTuAvEJ8rLc5VhxKQGs3M1XRcA8zvDHCFauOJKC+vTeRFWJvCAryqvXpQda4/MZADHQxxebpvthwOgVljcyIomAHQ/C5FGTPQlj/eFSE8M33sPtRodLXx+VQWDfMBdFFTQj95i6iCpnl5nz0iifSK1txNe3vDVhmuhp4b6w7PruUwficGmj+X4OIREZjz59FGPfLY2QpsPm8DHjP6rxJiaFJ/pZo7RbjzwLmmUJ+NvrQ0+DjejozErZLJEHnM/WTWErjQnIl3j2T2i+Bk1/XCQpAm0CCObuilX4GJZY296uuEkll+O5mLu5kyY+5tUuMovrehEoPZDRQ2ybE68eS/nacV9KqehEqPZDIaLx5MqVXts+5xErwOL2/ItAA6tqF+OVu72ymlPIWhfeGjJZnoVx54dpUBE0+V+F1yuNQSkkrmqaJd3w7hZJ+B4T82nbselSocKCX0XJl0ou4mFyJP/MUq6NkNHAzs3/rVHpFC5xNeysA2SCprBn3susYKxrbBWLM2R2NTpEUFKBQyfU8ZDI5WXUxufIvcq2KIFD8fFIFNHhcOBPsst/LroVURmOMF3NLxcOcOsQVNSpt8HlzpCuOrAiDm7mu0gDgHvD6GMCbO0V4lFePjyd4MCaxukVSfHklCxvHeShszFMEsVSG98+mYdVgJ3hZ/V2hZaithm3zg/DbvEAAclJ39+NCRGy5hwvPyEMSu9SnlzKgyefijRHMcmQA4MfbeahtE+I7AnXP/qcleJhbjz2LmRMSl1Iq8bSgAfuXhvYZzvw8HubWYeO5dGxfEMRY5ZRc1owVhxLw+SQvTA0ka0TrwSBXE+xeFKJUucWh5BtSfX2PK6jrwMydUXA208G3M/yIiZcb6dVYvD8O745xx3tjPVgpZera5GHede0CXHyJnBxAfh1/eSUTX17Jwo4FQXhtuMtLqXd6kFPThknbnqBBAfGuggr/dKjIGxX+dfC01MPVNwah65nliQ1J8iLG+Vji9JoIHIspxVsMM2AUQY3HwY+z/DAz2AYzd0YxHsyfh7GOOo6/OgA0aCzYE9Pn7v6L4HM5+HVuIJxNtTF7VzTjL9n6mnwcWR6OmMJG+HxxG28cT8af+fV9ZpboqPNwaFkoypq68B6DoReQ79j+Pi8IEpkMb55M7jNYuAfyamxvBNka4HWGRBEArBnqhBAHI6w7ltiLPAiyNwSfx8EPM/2wZbrfX/kIk/2tMC3QGuuOJzK6BlzNdXuF9nYKJfjpTh4GbL6HozElComLwW7y7IfGThEW74vDon2x/YbLGmip4bNJ3vjySmYva9yCcHvoa/Kx42GhktV/x4sSbKFEhuKGTkze9gQ/38ljRsb18TMNHgdG2mr4dKIXYj4ciTBH5m02gJyInB9ujwNKasMVHg9FYU6oLU7HM2tZKm/q/tuXbJFEhmvp1XjzVN/XZV5t+1+2odLGTizYG6uQpIktblLaksTnUlDnccDnUgixN/xL0h5b3NhvlohIIsOTggb89qzyvaVLhDQFCrPnIa/xTfzrdclkNE4nlEOk5H0WSmTY87ioV8vZgacloJW8KpFUhs8uZvSrPNPgcxWqVrgcSul1R4NFVXg/5I3sWQONTAlZL5XRuJJa9TclV1VLNz68kK70vPWsi+rDOkXTND67lImyZjI7oSKUNXZh0b5YAEC3EvLueXSLpFi4NxYlzwgbNR4HuX38/ZTKaLx9OgVX06r/RnA1dYoYEbI0Lb/OZrMIKl44wJ4xOZJU1oxlh+Khq8lXSo5QFIXBrqa49dZgbJsfCHtjLShzR3EVkJo9+PVePrgcCkPcmCsRtj3Ih5meOmYTVGjvflwEkUSG1/qo+JbJaFxKqcSgbx/gp9t56Hr2OaTG5cBEhxlJdDaxAg9z6/H9TD/GLVs3M6pxLKYUuxYFM1ZQPMitw0+3c7F7cQjj7JWYokZsPPf/2HvL6DauhWt4j8DMzMzMGGZmZmZqU0w5bdM2TdM0zMzMzDHFzIyxY2aWLWm+H4pdg+DI7vt8vfd6r5W10mZmNBrSnH02JGDlQEvimu7od1VYey4av051xiBCtUji+xosPB6OT0faYqa3CdE6ojDYTgezfYVvg81kYJqnaLVWfEE1ZhwKxTRPI/w40Yn4fLThRHAOPrkSh92z3KUi7zoi8X0NJuwNhrWOMs4u85UqLLwryus5mHf0LUKzKnB7XSDx+RAHmqZxKeIdpuwPwTgXg3YCsw99+G9CH3nTh/9KqCvK4ORiH4x10cfkfcG4I0VdrSg4Gqji1rp+KKhqwsxDoSiRIgS2IyiKwkfDbfD1OAcsPRkptgZcFJRkBZXehurymH4wRKqZTiaDwg8TnAR5KIdCiVUkqgpsbBxmA0Awk7/0ZCRctz7BZ1fjEJJVLnRAq6Ygg9NLfRBXUIMf7pBVe8vLMHF8kTeyyhqIs0ZYTAa2jLVHWR2HuEKcoihsn+qCxhYevrvd+XPGuxggYsswTHLv/iL11VgHsBgM/HBHdFZIG6x0lIQOYjhcPqqbWvHj3RQE/vYc16MLOh0/OTYTah+CJrkfBnsj/nyNr24kiCXrxrvow9lQFb/c7xwqy2RQ+GmSEw6/zkK2BBIIgNCmCPrDvhx8lYXRf71BarH0KhwmJSAlvh5nj9Avh2Cun2mPJNsAMM/PBCFZFSJzUIRhsrshYguqJRJhgCAnpuu+cbh8PE4qwdrz0SKJy/iCmvbmtxYejdTiOiw+Ed7JZsTh8jqdByaDgtyHhjMTDQWsGmiJU0t8kPjDyE7VrUGZ5WJtiPJsJpgMQZVx4YcsoRdppRIbXrh8Ggnva9obqyJyK1HbLJ5kabNPtREq1Y0tuJ9QBHG8XlMrDzsfi89fkmMzhGbesJjilDeCFiBpUM/hibVNXYh4h/SSOojjjykK7YHpfD6N9RdiwBURctsGSdap48G5qG5qRVMLj5iIFobqxhbMPhKGRo7geimpaxar9Grh8rHkZARSi+vQ8uE78Pg00kTkvXF5fGy4EIOHicXdG5koMvVNbH41CqubMcaZLJQWAM6E5CI0qwKzfSQPommaxpnQXEw/GAqaBhwNJGcIURSFEY56OLbQCyYa8tBRlu0WEC4quySrrB4Xwt/hKylqnjNL63EsKAc/TXIiDgHOLK3H3ueZ+G2ai8h7OzizHCP+fI3PrsajrJ7T6RwZqpNVxmeW1uO7W4nYOcOV2GKVWVqPT6/E4/fprsRqqszSOhx7k4Ntk52IK7czS+uw4nQkvp/ggIE2ZEHXGSV1WHIyAp+NssNENzL1THpJHbZcT8CGodZShWOLwtE32bgZ8x6fjLDppsCRYTIQIMKWFpJVjrlH3mLNIEtsHmErlTqFz6fx871k7HmeibPLfDFMCsVaRzxMLMa3txKxMMAMO6aLvvZIEJdfjc+uxkFbWRbX1wTAVLP3FtHGFi42X47D748ELWAfD7eRmuDqQx/+E9BH3vwH4N27d/jkk09gb28PRUVFaGhowMfHBzt27EBjI9nAWxhevnwJiqKk+jNo0CCh2zIzMyNa38zMrMf7Ky2YDAqbR9hi1yx3bLmRgD3PM3r1MgwA2sqyOL/cF34WmpiwNwjxBdU93tYML2McXuCJC+H52PMsXWo7liyLiT2zPeBroYlpB0KkGsQyGBR+nuSE4Q66mHEolGgwCwCzfEzaZ7hbePwPzTIFWHQ8Au5bH+OrGwkIz6nspLLRUZbD2WW+yCitx68PUom+p5qCDE4t8cHzlFL89YysOrsnFeLyMkwcXuCF/MomnO1ggWAwKJFVlzIsBvbN9cDDxCJcixJPvCnJskS2fQACMqCsjoMvrydg0O8v2me8AcCogwScx6fb63QDfn32wcrRfSBGURR+nOSEu/GF3YJRXYzUMMPLGN/ekkxuqcqzRc46c7h8ZJfVY9zuIOx+KrpBreO7pRyLAXUFtiCAkqbhb6nVqxc/QHBdjXPWx6mQXOJ11BVlMNJRj0h9866yUahajMPl40VqKVaejRL6PEnpQmq1cPmIya/GqrN/t0dllta3kwJmmgpY6G+GA3M9McXdAKOc9LB5hC38LLo34rxMK2tfT4bFgNyHQaWqPAtTPQzx/QQH3N/QH8lbR2H7NFcAwJ24IpHNJkwGBQUZJlgMClwe3R72fjkyHzy++GclDSC3ohEHPqi5rkYViLWTAIJjdyo0Dxli1BzyIpQ3LIaEzBsp39EbOFwoyQknb0prm/Hj3WSJ+SfNrfz26+9m7HtE5VWJDbsFxFun4vKr8cv9FACCezkit2fh+xwuDwuPh6O0rrldByXDZCBBRPg4j09j7bloRL+r6vSduXwacUJUW1weH2vPR+NpSonQYyTLYuJdpeR3k/PheRjvagAFGTJ1xoOEInxzOwkMBiXRXtTcysPGi7H48W5yO+mnSPg5ALD7WSb8LLQQ8sUQ/DjREVpKMpBlMdDK44scEP5yPxXTvYxgTWgjaaupnuVtQqwc4fNp/HI/BXN8TYRaflKKajHrcCgWnQhHZpnwDB9rHcmkSnVDC1acjsQ8f1NiRUQ9h4uVZwTrjCJsiapqaMHSU5FwNVYVOlkiDCW1TVh4PAILA8yIlTAFVY2YfywcC/zNiEmY7LJ6zDnyFkPsdbBMimp0Udj/MhN7nmfi3DJfrBtijd+nubQTOEwGhfGuBkLVZI+TirHsVCS+Ge8g9X5wuDx8cT0eUXlVuL46AO5ShGG3gaZp7H+Zic2XY7FygCVWD7LslbXpSmQ+Zh0Og5+FFvbMdie+/8UhvaQOH12KxfvqJtzb0B/9CFvA+tCH/0T0kTf/cty7dw8uLi74448/kJqaisbGRlRVVSEiIgKffvopPDw8kJ2d/X+2P7a25GF6/xYMd9DF7XWBuBtXiLlH36K0rmeKmTbIspj4YrQdlvW3wKzDYb1S9fS31sYPExxx7m0+vriWIDW5xPxAwkz1NMJHl2IRK6YFpisoisK34xwwxcMQMw+FIU1COw4AaCjKwKPLzBiPLyByapu5uBiRj7lHw+Dx0xN8dyuxvQXKUE0eP092xrXo99j3IpNo/wzV5HFqiQ+OB+UIzZYQtY60FeKGavLYMNQa2+6lICxbchNM2zq7Zrnjm1uJEhUoJLOPNASDuo5KDyshL9gtXD6aW/nY+SQd/X57gXvxRd2IGCN1BXw83AYngnO6Wbs2j7BFanFdt1ycrlCSZQnNO2kDnxYM7HY+zcCxINFEGZdPQ12BjS1j7BG2ZSg2DrPBZA8j7H1Odg1IwuJAc1yNKiAOuAYELWDXogsk2jpyKxrQLGIZDpePoIxyLOtStc3h8oTWsnO4fIRkVuCjy7Hg82lYaivh5GJvRH8zHC8/HYxvxztgsJ0OBtnpIihDuJWSx6dRWN0EZVkW+llpYcMQKxxf5I3vxjvAQV8Vf8xww0xvE9jqKbcPLjlcHoIyy8Gg0E7SUBD83VxLESsHWOCXKc64tS4QKT+Owumlvmhu5eFeQlE3xQkFQXi3HIsBCgKyRFWejbI6DmiaxrGgHJG5Oh3Bp2lsFdNwJSsi84b5gWASBpqmpQ8sbuZCSVY4gXg2LA/NrXwoyDAhz2aIbYlJeF+DdxWN8DRVx+bhNhjnog87PeVOdhF5NrNTjkoLl4/gLnlNNY2tWHYqspO66BlB5XxX0DSNjy7FIbW4rlvujrCWMD6fxubLsXidUSZ0oN/1d6GVx8fKs1F4mSZ8+TZIIm9uxhbgSuR7uBpJJi1omsbe5xlYfyEGACRm0uRXNmLc7iA8SipuVxEBEGtn64jU4lo8SirG+qHWYDEZmOFtguAvhuCrMfbQVJKFjkp3q8itmAKEZpZh0wd1KgnuxhchvaQeH48gX+d0aC7yq5qweXjndYpqmrDhQgzG7QlCeE6lyJpzFoMSW0HfyuPjQvg7eP70BPlVjfhkBNk7H03T+P1hKsw0FYnXaf1AAtrqKmMzQVBzYXUTfridCN9tz6Esy8LHw8mOW0U9Bz/eTcZwR118NIwstye/shFzj77FNE8jbBxKnvUjDDRNY9fTdBx9k4MLy/3gYqQGAJjsYYSfJzu1P5enenZXA12LKsDGi7HYOcNNKlsdIHimLDgWjrSSehxZ4AUzLenVLRwuD5uvxOF0SB4urfQnrm4XhhYuH9/cTMTP91NwZIEXVgyw+Efyba5E5mPSvmDY66vg3DJfYpVYH/rwn4re0519+H+GuLg4zJgxA42NjVBSUsKXX36JwYMHo6mpCRcvXsSRI0eQlpaGsWPHIiIiAkpK0tXqeXt7IyEhQeJy69atw6tXrwAACxcuFLvsxIkT8dNPP4n8dxkZMp/1Pw1zLSXcWBuIL68nYNzuIOyf6wEvM+lyNjqCoigsH2ABKx0lbLgQg4ySOmwaZkMse+4Ie30V3FgbgMUnIrD0VCT2zXGXqraRogQKI20lWcw7Fo6D8zyJZx3aQoLl2EzMOhyKM0t9JVavTvE0QnJRrdAMBR6fBg9AdWMrzoTl4ezbd4j5djhU5Ngw11LE2WU+mHU4DIqyLKKmEFs9ZRxd6I1dT9OhqSRQTUhCW4X4R5dioa/qB1cCGbaPuQa+HmePNeeicXtdIFFt6EAbbawbbIWf76Vg/1wPkefM2UgV0e+qRNov2EwK41308eMkp04zUJbaSpBhUp0GH21oU+x8dCkW+18qYfs0l04ztwsDzHArrhB7n2fik5F/vxSryrPxzTh7XIrMx0BbbZHNHEqyLDAYAES4LNhMChQorBpkgQX+ZkKXGeGgBx1lWUzxMOqU07J2sBWG7nyFdUOspAopFQZnI1WMctLDrbj3IvejK/wtNCEvw8Tz1BKMchLdGCJJycbh8hGWXYElJyNwfJE3ZFlM5JQ3gEFRQnNS2ixXW24k4JcpwvMWAiw1seliDCobWropC5gMCnHfjYCCDLPTC6+Gkgx+f5QGHp/upgigaWCMkx4M1ORho6sMa10lWGor4URwLhLeV+OzUXZCv3dzKx/ybCa0lWVhqCYPcy1FJBfVwl5fGVM9jGCgJrCTtM0SJ76vQVFNM9hMAcFCQzBIpChB4Lmhujw0lWSgqywHLSVZuIgZsItS3rCZlMQKZ2nA5QvIGWFYPcgKg+10UFrHQWltM0pqOUgvqUNIVjk0FGVR2dDSnt3Dp4HHycVY1t8C67sM8iJyK7DpYiy+GG2Pd5WNSCupQ2ZJPQqqG5HfgdygaRobL8agpqm1XSnD49N4mFiEb8Y5SPW9djxKw9OUkm7kZNv1unKgZafP/e52Eh4IsT61oayeg8YWLhRkWGjh8rHyTCRCsirEEjccLg95Yuy416IK8MnVOACArhAipCNauHx8cjUODxOL288/V4wq7FV6GVafjQKHy+9msyMNRt/5OB2zfUxg2EH9KMtiYkGAGRZ0UW3QNI3zb9/hq5uJcDRQgRZhBkhdUyv+eJyGr8faEzck5Vc24vdHaTiywAsKXSx/v9xPxW2CiSQZFgPmQgbxXB4fN2IEDUwVDS3g0cAwOx3i0OzDr7PxNKUUd9b3I7aq/HAnCZUNLTiywEvkuxOfT+NNZjmOvclGUGZ5++/o1olORAP/eg4Xi09GwERDAd+PdyRap6imCXOOhmGkox4+HyWdRakraJrG74/ScDmyABdX+HUL953pbYIWLh/nw991U1IdC8rBvfgiHF3ohUAr6ZQk76ubsOh4OEw1FXCih+qWinoOVn24l26tC+wVKVJa14w1Z6PR2MLDnXX9hLaiSovGFi6+uZmEF2mlODjPEwMI7XN96MN/OvrIm38xNm3ahMbGRrBYLDx+/Bj+/v7t/zZkyBBYW1vjs88+Q2pqKnbu3Ilvv/1Wqu0rKirCyclJ7DLV1dUICwsDAFhZWSEgIEDs8mpqahK3+f8XFGRY2DXTDadCcjH/WDg+H2WLhQFmvfphHmyng+trArD0VCTSS+qxc6Zrj34k9VXlcWWVP9aci8aMQ2E4scibOLSvDQsCzKAsz8Ly05HYMd0VY13IqiwpisKGodaQYzOw+lwUds9yFyutHeGgh29uJkrcLoOisGe2e6cXUzs9FZxc7IN5R99CUZZFNJPkY66BhQFm+OhSLE4t8YE3Aek20lEPHw+3wbLTkbixJoCIjJnra4rkwlqsOB2Fq6v9ic7jyoGWCM2uwGdX47F/rofQa8lWVxmybGa3vAmKAuRYTPwxwxVjhNSOmmgqgMVkoIUnJqeCx0dSYS0uReRj68S/B8QsJgO/TnHBlAPBGO9q0GmmdbyLPi5FvMPOx+n4foKj0O0qybJE1uGyGBRGOurh67EOYq9RBwOVbi0oAGCsoYCpHobY8ywDu2b1PkxwhIMufrqXgjk+JkQBpgwGhRmexrgUkS+WvCHJgqIAhOdUIqe8AXZ6KkgrroMMiwGuiGwRDpeP6zHvoSzHwldjuw/KtZRkYaOrjNCsCqH3r7CMFmsdZVAQyMbt9Tsfbzk2U+gxttFVwrVo4ZY/J0NVpP44qlsw8pYbCVCRYwslvW10lXFhuR+U5VhQU2BDXUEGCjJMrD4bDW9zDSztR17prCzHQrOQ48dkUFCSE062tGX9kIKmaVQ0tIgkXOVlmN2egVF5lYgvqMHrzwYDEBAB5fUclNQ2w0IECVlR3wJ1RRmMdzUQuz/HgnIQml3RTRlSWNOM/MpG4oHOlch8HH6TLVJ1EfOuutN/73ichksRooOpAYHKJaOkHq7GaniSXIIXaWUSjzWfBjJKhSs5D77Kwo5HaaBpQXaMuDaYyoYWLD4RLsjh6UC8tPJotPL4nYgFPp/G7ucZ2Ps8UyTJR6K8iS+oxpuMcrz6bJDEZUtrm/HR5dh2i+oECee5I3Y9y4C1rjLxOjRN48vrCZjgZoAAIQP5X6c6Q47NxI2YApHnHxCoITsqMHh8Grfj3uO3B2moamxpJ+VYDIq4/jkksxy7nmbg0ko/4rasM6G5eJBQjFvrAoU+1yobWnA5Ih/Hg3NQ3dSKVi6/ndiUYzPgZSbZ/sPh8rDidCRU5dnYOcON6BlRWteMuUfeItBSC9+Oc+g1cfPzvRTciS/EpZV+Iicr5vubYX6HyQeaprHzSTrOhuXh5GIfogmojkgurMXik+EYaq+LrRMciYO9OyK9pA5LT0XAxVANO6a7Sl1H3hHR76qw+mwU/C008csUl15tqw0ZJXVYcy4a6goyuL+hv9Tvy33ow38y+mxT/1JERETg5cuXAIClS5d2Im7asHnzZtjbC4Lxdu3ahdbW3tViC8OlS5fA4QiqlOfPn/+Pb///GhRFYVGgOc4s9cH+l1n46FJsp7aQnsBaVxm31gaiuqkFUw+E4r0U4cEdoSzHxvFF3nAyUMHk/cE9CoSd7G6E/XM98OnVOJwNy5Nq3RUDLLFqoCUWHAvHWzH2IW1lWThLUOewGBT2zfXAaCGkhJuxGo4s8ML3t5Nwj6A6GEA7WbD0ZASRvQv4UCHuoItfH6SilrAy/rvxjlCSY+HTq/FE2TxMBoW/ZrkjNr8ax4NzhS5jravcLTtFhklBns3EH9NdhBI3gCC4VlyrEZMhGFj9MMER34/vTsI4GKhgUYA5vrge32k7DAYDP05yxsWId0gUkYEh7GWaxaCgKMvE6aU+2DvHo1cvS2sGWeF+YrFUOU2iMPxD+OKT5BLidaZ5GiHxfY3IUFWaplEiwl4pz2aAQQlUMr9OdUHMtyNgpycgTdK7DDKFoYXLx5E3ObgYLtwKGGilhSApKtCZDAouRmrdBubiYKOrjNzyBpH7KqzRylBNXuSzTYbFgL+lJpwMVWGkrgBFWRYoioK6ogyqpGjDAwTXmTC7GovBQIWIgb5ABUM+yGps4YGmQdyEAwCltZxOdhkZFgMGavJwN1Hv1s7WhpzyRolBnLH51fj1QapQJYsci4kXaWTWqeDMcnx5PUHswL2mqRVFH4KsT4fkYv+LLImEBpNBtT9zxzjr4fqaAMz1NYGqPBsyTAZEjQtzu1SM0zSNH+8m44/Hae3kCoMhqJ0XhszSeoz+6zWSi2qFHpu6DoHaNU2tWHgiHAdeZolVZ4k7Nm3Y8TgdCwJMoaMs+vlG0zRuxhRg0I6XCM+uBJ8WXLekqpuUolqce5uHz0aSqzquRBUgs7QeX4oIQ1aQYWH7NBccmu8JFTkWZETkT7Vw+bDQUvxA2hRiwPYX+OJaAoprmzsdZwYl3l7VhsLqJqy7EIPvJzi024EkITizHNvup+LQfM9OEys0TSMqrxJrz0XD++en2PUsHaV1HLR0IG4AwM9CU6LKmcenseliLBpaeDg4z5MoGL+yoQXzj4bD1VgNP0927pGSug18Po2/nmXgQWIxLq/0J1aZ8vmCtrkrkQW4vNJfauImKKMcMw+FYoG/GX6e5NQj4uZ1eimm7g/BZDdD7Jnt3iuy5UZ0AeYeeYuVAyzx50y3f4S4uR5dgEn7gjHCURfnl/v2ETd9+J9DH3nzL8XNmzfb/7548WKhyzAYDCxYsAAAUFVV1U72/JM4ffo0AAHp8d9A3rTBy0wDdzf0Q2F1M6bsD0FuRYPklcRAXVEGZ5b6wt1EDV9ci0dUXs+CJtlMBrZPc8FsHxNMPxDaoyrxwXY6OL3EB9sfpmLPswypgpDn+priq7H2WHIyQmT2BgBM9TSCPFv444PFoHBgnqdYi5O/pSb2zRGQTC9SyQYnc3xNsKSfORYeDydqMqEoCt+Nd0BdMxdrz0UT5QnJsBjYP9cDse+qiWu1NRRlsG+uB3Y8SkOkkIBRKx2lTi/FLAaFlQMt8fEwG/x0L0VkXouJhoJIa4IsiwF7fRU8/mgAFgaYiXzJ3DjUGhX1Ld2IPEttJSzrZ4GvbiYKJYiU5Vhou2xkWYJa2T9nuMLJQAWv0suEfpY0EKhvjLDnOVkYtTiwmAwsDDDFCRHkmTDoq8nD2UgNV0UETpfXt3Qa6Ml9IGyUZFlY4G+GqK+H4/xyP0xyN+xEAMQV1IgcPLIYFGSYDCjKMDHB1UDkQCfQSlPq+97dRE1onokoGKrJg81kIKec/LlnpC4vVasdAGgoslHZKB15Iycm80YUmcmnaZEB28LQ8MHyJK5tqitK6zjQUZauFjevogFmmqJVM4KcmwiR10xTKw/3EyQT3BkfZsklhSXLs5mI/UDyqSqw2+uwRT3LAYF6oS2Em6IoeJioY+tEJ0R/MxynlvjA11wTDErwnOh4Doprmtt/e1p5fGy8GIszYXmd7qtWHo2S2u4kaXBmOcbvCUJZHUco4UJBkFkECOqGR+56jbBs8VYuQLJtKjynEtF5VVg1wFLkMuX1HCw9FYnPrsajsYWH1g/HXIbFgKKIDKWO4PNpfHNT0NhDGmxcWtuMn+4m4+fJThItVkPsdPHik0Gw0++uegQEeVchWRUYtOMFPr0Sh/fVTUKPWwuP383i0xUcLg+rz0VjhIMucXBwbnkD1pyLxtaJju0qPoH1LA+DdrzEzENheJBYBB6fFpqhJc9mYKidaEVQcysP16Pz4fTdQwRllOHEIm+i+7ymqRVf3UiArZ4yfpeiFl0Y+HwaW24k4Hr0e1xa4UfUpMTn0wjLLsegHS/wOr0UV1f7E18fbbgRU4DlpyPxw0RHrB1sJbVqiKZpnAzOwadX4vHTZCd8PMK2xwQWh8vDl9cTsP1hKo4v8sKSfua9zrdpauHht4cp+PFuMvbN9cCnI+16RE71oQ//6ei76v+lePPmDQCBtcnT01PkcgMHDmz/e1BQ0D+6D1lZWQgJCQEA9O/fH+bm5NL3/wToKMvh3HJfjHbSw4Q9QXgqxcy9MLCZDPw8yQnD7HUx72g4rkRKbrQRhjYb09ZJjthwIaZH2/Ey08DlVf44E5aHH+4kC23NEYVZPib4abITVpyJxPNU4cdkpKOeyDDXIXY6Yl+u2jDYTgfbp7ng4Kss4qDgjUOtMcReBwuOh6OaYFDIZjGxd467VBXiWkqyODTfEwdeZuEV4ay3h4k6Ph9li7Xno1Fe33kmWVWeDVV5NpgMCpqKMriwwg+bR9hiaX9z2Omr4IvrwlU+Gooy3WYL296jRjvp4dbafhIDCOVlmNg22Rm/P0rrNvBeN8QKlQ0cXBCiAFGSZaGplQcZFgPrhlgh6PMhGO9miG/HO+JUSC5xvbw4rB1siYeJxcgUYa+QBjO9TJDwvkakkkgYZngJrFPC7o38KsH3Y1CAnZ4yPhtpi7Avh2K8qwGaWnlQF2ENSO/SotRW/62uwMbiQDOcX+6L+O9HYvdsd6GWMgDwMdfE+6omFFSRH2N3E3XEfAgHJwGDQcFGV6nb/oqDoZo83ldJR96oK0ivvBFF3rAYojNv+LR0mTf1HC5kWQziPA8AKKlthrYYNYYw5FY0wEzEwI2maay/GI2aJvHKz8jcKrEV3wBw4FUWOFy+RHUBh8dDZJ6A5JvoZoiXnw7Gm8+HYMsYe/iYa4CiBNd8x0PJp9EePN8RTAYFf0tNKMqysG6wNQ7N98Q4FwPIsRiQYTHQzOWjulFQeb7oRLggPFjIb0ZXNde5sDwsPB6OplaeyJwwFpNqV1MyKQqmGgrg0xCpAmqDuKwcmqZxIjgHS/qZi7y/HyYWYdDvL/Emo6xbFhlNk5GB16ILUFjdhA1DyEJwaZrG1zcTMdhOB0PtySue31c1YraPMWRZjE6V1K08Pj66FIv8SuGkTRu0lWQlfp/vbyeDpmmR9tuuqGlqxZJTEVje3xzTO1im6zhc/HwvBe8qGsHl0yLPOyCwnvpbdraN0TSN2PxqfH41Hm5bH2PzlXg0tfKxfIAFkY2rnsPFohPh4HD52DHdtVeEAI9P45OrcQjPqcSllX4wEmN5rGlqxd34Qmy4EAOXHx5j1uG3eFfZhPMr/Iis3m2gaRr7XmTi6JscHJrvgSkeZK1dHdHK4+ObW4nY+yIT++d5ElepC0NJbTNmHQ5DUmENrq0J7Ha+eoLM0npM2heMuIIa3NvQj7gBrQ99+G9EH3nzL0VKiqAu1MrKCiyW6B9QO7u/Ayfb1vmn0Ka6ASQHFbfh9evXcHFxgaKiIhQUFGBubo6ZM2fi5s2bUldh/1+AzWRg4zAb/DzZGRsvxuCPx2lirSqSQFEUFgaY4cgCL/x0LwXb7qf0eHuT3Y3w1yx3bL2bjL+eSqegAQT5MtdWByDmXRW+vZUoVZPVZHcj7JjuirXnYvAwsfvMr66KXLd8DTaTws4ZLsgorccX1+OJCKNxLgaY6mmE5aciEUsw+KQoCj9OdIKFliKWnoqUOKgBelYh7mSoit+nuWDd+RhicmFhgBm8zDSw8WJMt3PuY66BwbbaeL55UHtmD0VR+H2aCyLzqnBRSHU1RVHQ7xAQKMtiwFJbCVsnOOJ5ailxa1o/ay2McNTtVhEux2Zi6wQnbH+YirIu1gUbXWV8PNwGQZ8Pxvoh1u02GkcDVUx0NcQvD3r/rDFSV8A8P1NcCO8ZydkRqgpsGKnLYdrBEFQSkgVD7XXA4fIQLETlYqWjhK0THfHq08F4uGkAlvSzgI6KHMa76uN+QpHQevSmFh5K6zjtCgQXI1VsHm6Deb4mGGijja/GOsDLTEPijK6SLAtuxmoIySQjNAGBFTGrrB41TeTWWWtdZbGV3V1hqC6Pkrpm4tBXQEBAkp6PNgjIm+6fIU55AxoiM5qEoZ7DhYIYtYkw9Ex50yiSYD0WlIOw7EqJz2UWk0Jotngl1m9TXXBtdQA2DLGCh4ka2Eyq04C9DTw+2vNZ2mCoJo/5/ma4vNIfgZaamOltgoluBlCWZYHNpMBkUMgsE25vrGlqxau0Mkz2MMQgWx3snu2O2O9GYO9sdywKMEULj4dpB0MQkVslkijo2M7219N0fH0rUaKCiMWg2m1T6ooyuLTSH7fWBmKInS6YDOHfHRCvvAnOrEBYdgWW9TPr9m/VjS1YfTYK6y/EoJ7DFaoGomlaYk7a5ch3+OxqPD4fbUus+rqfUISovCp8J8QaKwxt2TjeZprYNtkZTz8eCHt9Fch2IPaEBap3hSTL1OWIfDxKKsaBeZ5CbZZdweXxsf5CDEw1FLB6kFWnf1ORY+Pm2kBoKsmIPHdtUJZjw1JbcE+V13Nw5HUWBmx/gWkHQnAtugDNrXzQtICAnO9nJnG/mlp4WHoyAooyLOyf60FkrxKFVh4fmy7FIqGgBhdX+EFfVb7Tv9M0jYySOhx8lYUJe4PgvvUxPr0Sjztxhe0B6GOd9WCoRk7ccHl8fH0zEadCcrF9mgsG2EhPatQ0tmLxiQhE5lbh5tpAeJpKXyfehsjcSozbEwRLbSVcXukPAzV5yStJwM2Y95i4NwiD7XRwarEPDKQ4Pn3ow38j+sibfyGam5tRXi54WTMyEs+gq6urQ1FR8EOWn9/7QVBHnD17FgAgLy+PadOmEa2Tk5ODhIQENDY2oqmpCbm5ubh8+TImT56M/v374/379z3al4KCArF/iorIslNEYbyrAW6sDcS9+CIsOhEu9WxxV/Sz1sLNtYF4mlKCZaciUEeYudIVgVZauLLKHxcj3uHTq/FSV4kbayjgyAIvRL+rxvLTZGRHG8Y462PPbHd8fDkOt2K7n7ep7obtcns2k8KRBV6Y4mGMC8v9EJ5Tia9uJhARODO8jPHxCBssPB5OlPPDZFDYPdsdDAr45UGK0IF0V7RViP/6IAUzD4V2IyuEYbSzPub7m2L56SiiQTFFUfhtqguKa5qx60l6p387ssALRxd6Q1Whs+RdU0kWO2e44se7yUJJItMPAz8Wg8KqgZa4v7E/FgSYYbiDHj6/lkBM6H091gHR76rwtEv18GA7HQRYauGX+53JGHkZJjYMtRaa+7B5pA3eZJSLzUUixZJ+5jgblicViSAKltpKaG7lY9jOV0TbYzMZmOpphEtCiDMVOTYW+Jt1C4oVWEQohAr57iwmhQX+pvhtqguivxmO2+v6YfkAS0zxNMKLtDKi67QNwx10EZ5Dfny1lWVhpC6P+IJq4nUEyhvyzCEdZTkwKUpoFbooqCvKoEpq2xRDqPImp7wePD6NivrOny+Yda/CsxRy5eT58HeoauJKRUSV1nGEVkSLQnMrD0U1zTAVYZu6l1CEFi4fcmxGp4F1V7Rw+XiSLF4ByGYy4GGijnVDrHF9TSASfxiJCa4G8DFTh7OhKpgMCrIsBpgMCukldUJ/R+qaWxGeU4VVAy2wa5Y74r4bgUsr/bGivwX8LTSFPmseJRXDVk+5U3uRHJuJEY56WDnQEtMOhiG9RHwOVEelormWIrQUZcUeD0DwrO36m+pkqIojC7zw9OOBcDdRA4BuuS+iSCGaprHjcRqWD7CAinxnpcar9DIM/P0lnqWUSgwCFpWhVFrXjBWnI/HZ1QTQEISsk6CyoQU/30/Bz5OdiIOAr0QVICa/GtumOIOiKBhrKODm2kBsGGoFBgUs62cObzMNsceYxaDgJiZrJaGgBleiCvDXTLdOjVzisO1+Koqqm7B7trtQAttaVxn3N/aHmZaiWAIl0EoTz1JKsfB4OHx+foo/nqQjv6oJXD7d6fza6imLVFC1gcPlYcWZSNA0cHgBGQklCi1cPtadj0ZGSR0urvCDzoeJl+ZWHl6klmLL9QR4//wUo3a9wZ9P0hFfUAM+LbBGtu01i0FhST8L4s9sbOFi1dkohOdU4sbawE6Nk6TILW/A5APBkGUxcHU1WbmDMNA0jTNheZh/LBwbhljh92kuvTqegODYfXk9Ht/fScKeOe74YrSdVGrJPvThvxV9d8G/EHV1fw88SOq/28ib+vreh3+24c2bN8jOzgYATJ48GSoqwiX+bZCRkcGECROwd+9evHz5EjExMXjx4gW2bdsGY2OBPDY4OBjDhw9HTQ25taENxsbGYv/4+PhI/yW7wEZXGTfXBUKezcS4PUFIKJB+PzvCXEsRN9YEgkcDU/aHIK+HuTp2eiq4sSYQSYW1WHJSeiJIR0UOF1f6obGFh3nH3hLZjdowzEEXB+d54vvbSbjRpZ1mlLM+mlv5YDMpHF3o3S5j1VOVw4UVfgjJqsDXtxKJCJzFgeZY3t8c846GE+VwyLGZOLLAC2+zK/HVjUQiEsPFSA0uRmp4m1MJ321PseZsFKLfVYldd/MIW5hrKWLDhe5qGmFQkmXhwFwPvEgrJc7y6W+tjfn+plh/IbbboNXDWA1mmoKX74+G27S/uHw73gEZJXXEqhUNRRn8MMERW24kdCOivh3vgEdJxQjPJstp0lGWw+pBlth6N7lXKjVAQKpN8zTCX896n32j/CE0trKhBeP3BuElgeVthpcxHieXEJO1TAaFsS76uCOkkpfNZGDrRCdMcjeEmsLfgwY3I4ESos2uQgI3YzW8yiiXSm03zF4XiVI8s6x1lZEuhWWNyaCgryaHgmpyO5eGggwqG6R7XsmJqAo/8yG3ae/zzllUrzPK0cKj8Ty1jOhZ09TCw80YARlNkifThtLaZrEhtl3xrrIRijJMaIsIsb2xJhCRXw/DkQVe2DzCBmOd9aEqzwYFwSBOQYYJBvWhijypWKprQZbFREpxHRYEmOHO+n5I+mEkTizyxqqBluhvrSX0vn2TUQ4TTYX2fA4GQ5Bv8/loOxya7yU0r+JOXKHQtiQOl4cJe4JRUNUoMSS4ukPm1wQ3Q4RtGYq9czzgYaIGJoMSmWXUMbC4I0w0FFBe34Jvxtpjjq8pZJh/k2Oi9uVFWikKqhqxqEsNOADse56JuuZWicHOPD7drXqez6dx7m0eBm5/iWcffg/YTAryMmTV4D/eTYaDvqrY/LiOeFfRiK13krF9mksnsofJoLB2sDVefjIYqwdb4exSX3w83EakykWGxRCpvKlqaMGqs1EYbKeN/oTVzBfD3+F6TAGOLvQS2fAGCH5bbq0NhKeJmtD4cRaDwvOUUqw9H41X6WXg0xCq0pNhMjDaSfwxa+XxsfZcDGqbuTi2yKtHLaFtaG7lYdXZKBRWN+PCcj9odrjnJ+8PxvLTkbgY8Q7l9S3g0bRIFZqOsiw8PhCPklBRz8HsI29R28zF1VUBxCRaR4RmVWDS/mAMtdPB4QVeUgW4d0RzCxefX4vHX08zcHqpD+b7967FFQCyygQ2qbTiOtzb0B9D7Mgtg33ow387+sibfyGam/+eWZSRkTzbIisr+KFoaupZy5EwnDlzpv3vbaHI4hAeHo5bt25h7dq1GDhwINzc3DBo0CB8+eWXSEpKwogRIwAIrF0//PDDP7af/zRU5Ng4NN8T8/xMMeNQKC4LmZWXBqrybBxf6IX+1tqYuC+4x2oFPVU5XFnlD4qiMP1gaHtjCClU5Ng4vcQH6goymHkoTGhIpCgMsNHGwXme+OZWEs6E5rb/f0M1eSwIMMWJRT4Y2OUlTl9VHheW++FNRhm+vU1GrqwdbIWpnoaYd/QtUWOXmoIMTi7xxpuMMvzZRekiCpuG27QPiB4mFWPGwVAM//M1LkfmiwxJ3TXLDflVjdj+KJXoM2z0VLCsvwU2XYpFfiXZQHfzcFuwmRR+fdD5MzYOs8bLTwfDqUu7l6o8G79NdcHP95KJ82fGuejDTk+522cYqMnji9F2+PJGPLESYWk/c1Q3toqsm5YGawdb4UlyiVT5K8LQMfi5uZWPZacicTwoR+y1Z6mtBDcjNdyIIVcEjnc1wMPEYnC4ZCo2BoPCEDsdqTK13EzUUNfcigwp2riM1BUQIQVBZKOjjMYWrtDrXhTs9FRQWitZtdYGjQ/KG2mIB3khtqnimmY8TxUEZZ99m9duGaRpGtvuCVRjTS08PEwqlrj9w6+z0MoV7M++F5nE+1YmpW3qfVUjBtvpiB3EaCnJor+1NlYMsMS+uQLC4utx9ri9rh9+muSExYHm8DBRg7Ici6gpqQ1VDS1IK66Fn4UmAAEhFmClhU9H2uLEYh+hM+JPU0owTIpMlbI6DkKzKjDOtXtbngyTgXVDLGGkJg8WgxJrFeRw+Z0aH5kMCsMddHF9TSDuru8HfRU5MBlUe34UILD9iJrEeJRUDE4rDwsCzPD9BEe83TIUKwdYQEGGCWEFTHw+jT8ep2P1ICuhA/izy3zx9VgHKMgwxapVaHRuL8soqcPEfcHYeicZTa28dsJMTZ5MQfMitRRPU0rw82QnooEwj0/j48uxmORuILLi20RTASpybDA+hOZ/M84BTAYFdpcDw+HyYSeEvOHxaWy4GAMnQxWsHig61Lkj3mZX4Ic7yTgw15MouFeOzYSCDBNmWgqQ6aKy4PIFxIekYGo+TWOwmNw9Hp/GpkuxKKxuwunFPmIJJUloauFh650kVDW24Owy325qn89G2n3YJ/HbkWUxMNfPlOhc55Y3YOqBEBipy+P0Ep9uil4SXIrIx5YbCfhilB2+GuvQ44DmwuomzDsajtomLu6u79duC+8N7icUYuLeYAyw0callf49Iqb60If/ZvSRN/9CyMn9PbvX0iJ5Rritylte/p95wHE4HFy5cgUAYGBggGHDhklcR01NTeS/KSsr4/Lly9DUFLxIHj58mOh7dUR+fr7YP+Hh4VJtTxwoisLqQZY4utALt2Lf44tr8VINcLqCxWTg2/EO+HqsPVadjcK5t9JVeLdBSZaFYwu94GashtVno5FcKF2VuBybiYPzPOBspIqpB0KkaprxtdDEqSU+2P4oDUffZLf//x8mOKGftfAwOgM1AYHzMq0M3xOEBVMUhS9G2WGQrTbmHX1LZG3SV5XH6aU+OB2W1z4zLw5epurtEmU+LXgZzCytx7e3EuHx4xP8dC+5G+GiIsfGkQVeOP/2nVD7mDBMcjfEeFd9rD0fTTTIl2ExsHuWO1KKavG8g/1D3IvcABttTPYwxCdX44gUBxRF4edJzrgV+x7hOZ1VNrN8TMBmMnA0KFvE2p0hx2Ziyxh7/P4orb31pacwUJPHDC/jXqtvutbBc/k0fn2Qis+vJYi1G870NsaVyHziQby7sRqU5dh4k07eCDXMXhdPU0qIP0OWxYS3mQaCpagMb2ucIv0MAzU51DfzkF1G/hxQlWdL1cynrsCGs6GKVFk8qvIsaCl1HgAdeJXZSYHx11PBtfI8tbT9OcajaWx/mCr2Xiipbca+F1ngfThGuRUNiCZo6Wrl8SHLYkBbmWzgDQAZpfVE2SIdkVxUC2dDNTgYqGCKhxG+GeeA62sC8fLTwVJlcbzNqYSVjhJxdTWPT+NFaimG2ZPnZdxPKIKHiXq3XA+gLfvNHK8/G4wrq/wxyc0AMiyGUDUFgwLK64S/D+RXNoIPIHzLUHw8zAZaSjKQZTHQwuULVd7QNI0DL7OwfIBFu0pRXVEGH4+wRcRXw3BqSXeF7qOkYlTUt2Cur/C2JBkWA0v6mSP0i6GY7WMidpCrICsI297+MBWj/3qDpMKabkSDGsFAu665FVtuJODrsfbQVSFTex16nYWKhhZsEVEl3hVldRzseZ6Jr0bbYYCNdjeiRFhW084naXhf3YQd012JSIb8ykasPheNb8Y5wN9SU+LyNE1j650k5FU24cbqQGwaZt1JHaStJAMLbUWRNehtkGcz4STCQsTnC54TGSV1OLO0Z8RHGxo4XCw5GYGMknoBiSLffVuD7XTwx3RXiVk+rTw+phIEDce+q8Kco2EYZq+LPbPcpbYm8fg0fr6XjF8epGDbZCfM8iFrCROGsOwKjN8TBGs9Jfw1263Xld3NrTxsuZGAH+4kY9csV2wZY99nk+pDH4Sg7674F0JZ+e8ZDxIrVEOD4OWVxGJFglu3bqG6uhoAMHfuXDCZvfOtAoCqqipmzZoFQLC/kZGRUq1vZGQk9o++/t+zf1UN5DPD4hBopYXt012RUlSLGYdCidQg4jDN0xiH5nvhj8fp+O5WolQZGG1gMxn4ZYozRjvrYeahULyWsraZxWTg92kuGOOsj+kHQ6Rq5/E0Vcf5ZX7Y+yITewgH2kbqCriw3A/PU0ux+7nk0OW2QGI3YzVsvZNEZPGy0lHGsYXe+OV+Ch5IsEEoyrJgo9N9RrG5lY/GFh5Oh+Ri4O8vMP/YW7xO/9uGYamthN2z3fHl9QRiO9034xwACKTvJDDTUsRMb2N8cjUepYTKqC9H26O4phknQnKJljfRVMCmYdb48np8J1KJzWTgp0lO2Ps8k1gtNMZZDwGWmjj4iqxSXRzWDLbE0+QSpBX3XH0jbDDXwuPjVux7zDocKvJaGu2kh4YWLlFgNiC4Rse7GuC2EOuUKPSz1kJRTTOypCBKAq20ECxFaLGDvgrqOVy8Izx/FEXBSkcJGVJYpwzV5FEgReOUoiwLyYV1qGokJ28oikJWh4DcinoOzr991648aeXRuBSRj4KqRmy7n9LJzlJY04wnYrJvtt1PAY2/n0E8vmCwLwnl9RwUSdk2lVvRSKQ0aENFPQcltRzY6UtXDywMYdkV8LeQPFhuQ/S7KlAUBXcT8qDS23GFGO/W3TLVEW3b/GOGGw7N84CltiIc9FXApKh2soDNZIgMXz8Vmot5fqbQVJLFioGWeLtlGPbMdoenqbrQINTgzAoUVDViprdxt39TlGXBQrvzOxKPT2Pnk3SsG2IlcRCsqsDG9xMcsW6wJbQ/BOt2HI4zKQpReVUYvOMljgXliGxNIiHUfnmQCkttJczw6v49hCG5sAZ7nmXiz5luRPYfPp/GR5di4W+picX9zHF0gRe+HmvfrsAxUpfvNGgurWvG5H3BOPAyC4fmeRIpVeo5XPz2IBXjXfQxRwQx1hXHgnJwL6EYJxZ5Q01RBmsGW+HPma5gMwXHerCdDm5+yHYRp4IaZKsttOKapml8cysRj5KKcWapbyd7k7Soa27FwuPhoCjg1FLx6p2J7ob4dpxDN4VTR3iZaUgkP54ml2Du0bdYN9gaX49zkLrGu57DxYrTkXiWUoobvWiBamtmW3wiAptH2OKXKS6QZfVunJBT3oDJ+0OQVFiLa6sDMMyezCrYhz78L6KPvPkXQk5ODlpagodqQYF4W0JVVVU7edOWLdNbdGyZIrFMkcLBwaH97z0NLibB/GPhCBHSINMTGKrJ4/IqfzgZqmLc7jcIyujddn3MNXBrbSDCsiux6EREJ6sHKSiKwsoBlvhxkhNWnonCZSmrxCmKwpYx9lje3wLf3Ezo1j4iDs5Gqriw3A+nQnPx+6NUoll+Yw0FnFvmi0vh+fjxborEdRgMCtunOoPD5WPhiYj2FgZx8DRVx+5Z7th8JU5i7fggW23RbSQ8wQt3UEY5Fp+MwOKTEe3/NthWBxuHWuOvZ+lEqiBZFhP75njgTlxRe8aGJEzxMMIAay18fJlMTaMoy8KO6a449CoLWYSD8CWB5pBjM7HvRedBq5eZBsa7GOCHO0lE26EoCkv7meNoULZUtdbCoK8qj5nexvjrGZn9TRhEXSccLh8JBTUY/debTqRAGxRkWehvrS3VfTTeRR/FNU2d7B7ioCDDQqCVFp5KEaobaKmFt9kVxCSvHJsJB30VYhIKAGx1laWyqxmpy0t1rimKkrpxqmvmzZE3Od2apCgK+ORyHPIrOxNJLVw+tj8U/lxKfF+Du/FFnexHfBp4kVomkZgvreVAQ0FGqlngvIoGmIkIKxaGlKI6GGvIQ6UXFo42hGZVECkd2vA0pQSDbXWIrRPvqxpRXNOMMRJyRTridlwRBtjo4P7G/nj88QAsDDCFihwLHC4fFUKuj4ySOkTmVmFWByKGyaAwwlEPV1YFYKpnd5XCgVeZWBRgTpxfcieuEE2tPGKSpLqxBSdD8vD7dFecW+YLKx2lv0kEClhwLBxFNc1ibT26EkKvQ7MqcDPmPX75EDgsCc2tPGy8GIuPhlmLDRnuiAOvspBf1YhtHyxZFEVhQYAZbq3tBwNVOXh8IPHeVTTi86vx8N/2HDH51TDTUoS1rmRykcenseliDKqbWtsnMSThXnwR/nySjuOLvDoFxY93NcS5ZX5QlGVhuIMelOXYuLDCD56m6kKVXPIfArO7gqZp/Hg3BS/TynBuuR+xokkYahpbMe9YOBRlWTi+yJvoelsQYCYyh0eOzcA8P1Ox6597m4cNF2Pw+3RXYjKsIwqqGjHtQAg4XD5urAnsFDIuDZpbedh8OQ4HXmbh7DLfHu1LV9yNL8SEPUEIsNTElZX+PQ5N7gqapv8Ra3cf+vBvQx958y+Fvb1A+pqZmQkuV/QAITX17/yKtnV6g9LSUjx69AgA4OHhAScnp15vsw3/V1XhS/qbY9mpSOx8kt4jdUtXyLKY2DbZGV+Oscfy05HY9yKTaGAtCsYaCri2JgBybCYm7Q9GphS5Fh0xyd0QxxZ54ae7ydj5JF3q47tyoCVm+5hi6akIPCbIimiDvb4KLq7wx9WoAvx0TzIZAwAmmoq4sMIPDxKLBLPfEtZhs5jYM8cdKnIsLDsVQWRbG+agi+/GO2D56UikFIm2lAVYaYElQXYNShCOuCjQrNP/XjHAAgoyLKw+G0WUD2OsoYBdM93w1Y0E4kHyj5Oc8K6yEUfekFmYfMw1MMXDCB9fiSe63llMBn6d4oLDr7O6tTJ9MdoOL9NKMedwGNH3czFSw1hnA/z2MI1oX8VhzSArPEspJWocE4ZGjuhrpIVHo6S2GeN2BwklYGd6G+N2bCEaCIhCAHAwUEFFQwuepZCFUgMfrFNS5N44GKiAwaCQKIU90s1YDTHvqomXt5ayccpQXV5qBaK6ooxU7X0dq8JrmlpxIjin22C4lUcjLKdSaIhsfmUTXnQJq6ZpGl/dEN7OxmRQOBGcI3afSus40JayJjy3XDrlTUpRLez1xBcDkKCinoOM0jr4mktB3iSXSGWZuhNfBAttRWLlQk1TK+4nFLUrYiy1lfDVWAdEfTMcZ5f6IkAI0XQyJBfjXQ2IPyMuvxox76qxwF/8ILgNrTw+HiQU4aPhNsSWtD3PM+FipIpBtjrwtdDEo00DsG2yMxRkmOB1aTsSBgYFsaRBUwsPX1yPxycjbLs13YnC9odpUJBlYXE/c6LlI3Irsfd5JvbO9uimFnEwUMHLTwdjUaApVp+NwuAdL3E9pgA8mgZFQWigszD8/igN2WUN2DfHAywCwjMytxKfXo3D7tnucDFS6/bvPuYaiP5mOIZ/aOlq5fFR09gCKx2lbnavZi4P/YVYuf94nI57CYU4v9y3VxkqVQ0tmHM0DNpKMlI1VF2OyMeT5BIMtdMRqhoS1UBG0zR+f5SK7Q/TcGqJD8Y4d8+YkoTod1WYtC8YXmbqOLG4e+slKfIrGzH1QAjeVTbi7vp+vaoUBwRE0Dc3E7HlegJ2zHDFN+McelXV3hHl9RwsOxWJk8G5/8j2+tCHfxP6yJt/Kfr16wdAYDGKiooSudyrV6/a/x4YGNjrzz1//nw7WfRPqm4AIDn5b/uIgYF4uXVvMMXdCNfXBOBefCHmHH0rdbivKMzwMsaVVf44//YdVp6N6paxIQ2UZFk4PN8To5z0MHl/MFEzjjAEWGrh6uoAXIsqwOYrcVJV3wLADG9j/DnTDZsuxUqlPLDSUcLllf54lFSMnU/SicgsU01FXFjuhztxRfj1gWTVjiyLiUPzPcHl0VhzLprou830NsHHw22w6Hi4SPuPl6m62JlRFoOCmjwbN9YEdgt+bKsDb+by8B1hEPNgOx0sDjTHxosxqCe4ZpTl2Phrlht2Pc0grn7eNMwa9c2tOPSajPBxNlLFPF9TfHm984BWXVEGmkqyCMmuwOAdLxGZK7mB6rNRtniWUoKoPLK2KlHQUxW0WB0ksLEIg7CGoo4QNJPwsPhkOJpaOi/rbKgKE01F3CNsH2qzTglrnRKFofbayK9qREU9ma2TyaDgZyFd7o2biRpipFDe2OgqS1XTbqyugKLqZqlIcQ1FtnTKG9bfVeGnJJAqwtDC4+O3B2mdrutHSSVIKaoTamNp4fFxLuydWBVVaV1ze/UvCZpbeSisaYKZtOSNfu/Jm7DsStjqqUisSW5Dbnk9lGVZQge8onA7thAT3QzJl48rhL2+SrcGIzaTgX7WWt1IhJqmVlyPfk9MFgDAgZdZmO1jQvy9r0cXIL20HhOFtGUJQ255A86G5eGrsX9PkjEYFKZ6GiHq6+HYNsUJuiria87ZTAY0lUTv366nafAyVcdCwu8dnFmOixHv8OcMVyJVWFVDCzZciMFno2zhbNQ9EyYqrwpLTkZgyv5QPEkuAY+m25VqLAYllFjpiuvRBTj/Ng9HF3oRkQTZZfVYfjoSX462w1Axgdltg/rmVh6Wn46EprIc7q7vh4UBpp3sSHZ6yu1tf608Pp6nlsDrpyc4/DoL55b5SUWodkV5PQezj4TBREMB++d6EluFjrzOxo93k3FisQ+OLPDCSEe99uuExaAwwdVAKAnUwuVj85U43IwpxLXV/j0KA74TV4h5R99i3WAr/DjRqccZMsGZ5dhwMQbuJmo4v9xPquehMOSWN2DawRDEF1Tj3ob+xI1qJHiRWopRu15Djs3E2WW9b6LtQx/+begjb/6lmDRpUvvfT5w4IXQZPp/fbnFSU1PD4MGDe/25bdtjsViYM2dOr7fXhpqaGly6dAkAoKCgAC8vr39s28Jgp6eCO+v7wVRDAWP+eoNnUtgVxMHJUBV31/cDh8vHRxdje5XRwWBQ+HyUHbZOdMT2h2k4HpTdI3WSja4ybqwJQHpJHRadCJcqHBQARjrq4dhCb/x4JxmHpMgvMdVUxMUVfrgdV4jPrsUT1UabaQkUODdj32P7ozSJ31dBhoXji71RWteMjy7HEn3GogAzjHTSw8IT4UIHjaJybwBBjauZpiIebBwABwPhAyl5GSYOzffCk+QSnH37TuL+AMBHw21gpa2Ez68Ln/3vCncTdawfaoUNF2KIbGNybCb+mOGGPc8zxKqOOuLjETb4ZKRtN2n+QGtBc9j76ibMOhyGzZdjxWYP6arIYdVAS2y9k9wrRRoAzPYxwcOkYqnDuAGIVWfJshhgMiiMcdbH9dWBkO9S6UtRFGZ6GeGSFO1y410N8DKtjPh+01WRh66KHF6kkedUDbPXRZ4UweJuxupIKawlbsKy0VVGXmUjcSC7nqoc+DSNEgLbYBvUFWRQSZBd1YY25U0Dh4tDr7MlNssIQ055A15/UFhxPhCt4qqeadC4LkZeX1orXdNUQVUjZFkMqdZJLqoV+cyRBuklde0KBRI8Sy2DsjwbSoR2rczSemSW1WOEI/lnXI7IF5pDIwpXIvPhYKDSrWVP9D7VobqpBUsJ1SctXD52P8vExqHWRMoQAPj1QSqmeBjBTog6Sl6GiTk+pnj16WCsHGABloiKcyaDgoai8Gsi5l0VToXmYfUgSyL7Wk1jKz65EoctY+y7ZfkIA03T+PRqHJwMVTuRYjRN41V6GSbuDcLMQ6EIySoXqiLi8WmhDVQdEZVXha9uJGLfXA+ifSqv52Db/RTM8DLGfH8zictzeXxsvBgDDpePg/M8IMtm4quxDtg8wra91WyMkx4icyvxxbV4uP3wGMtORaK8vgXTPI1hpdPzXMjS2mZ8fSMRNrrK2DPbnUgh0qaaOfAqC+eX+8HPQhMMBoWdM1zhZ6HZTuAICw2ua27FkpMRSCuuw401AbAS8c4iCnw+jZ2P03DwVSb2z/HAokDzHtV30zSNI6+zsexUJOb4muCnSc69VsfcTyjC9IMhGGCtjSurAohVZpLQ3MrDt7cSsf5CDL4YbY+9c9yhStju1oc+/Cehj7z5l8LHxwf9+/cHABw7dgyhoaHdlvnjjz+QkiKoSd24cSPY7M4vXydPnmz3M3///fcSPzMpKQkxMTEAgNGjR0NbW1vCGgI8fPhQbE15XV0dZsyYgYoKQRbJ0qVL2+vN/19CQYaF36e74rvxjth4MRZ/PUuXWpkiDOqKMjixyBsuRmqYsj9YquBSYZjsboSfJjvhwKtsfHk9oUf7qKMih0sr/KGmIIO156Kltjb4W2riwgo/HH6djV8IbE1tMFJXwOWV/oh5V4VNl2LFtvq0wVxLEeeX++FaVAF2PJZM4KjIsXFqsQ/Siuvw5fV4iQQBRVH4brwj7PSUseRkhNAZdWG5NywGBSVZFvbPc5cYHGioJo8D8zyx7V6KxIwdQPDS/t0ER0TmVuIUYbjwqgGWMFCTx3e3yDJo3IzVsLy/BT6+TKbAUpBhtVcJd4Semnx7pS6XT+NOfBH6/fYCN6ILRJ6r5f0tUFbHwU3CNi5R0FWRwyxvE6mzb1q4fJGWBSVZFpb1N0foF0Owb66H0BlnQGBDTHhfg0zC7CBLbSVY6ypJZTmU1jrlbqKOW3GFxOSKmaYCfCw0kEpI4OmqyEJZlkVs3WQzGdBTkcN7KUKLNaXMvJGXETT2nHubR0TWCoNAfSNQ950MzkW1hGyx5lY+DrzMFvlsKauXjrzJLW+EqYYicaAoh8tDZmk9HP4B5c29hCI4SUECPU8VWDlIcTe+EINttYmzeZIKa5BZWo9xLmR2Dx6fxunQPGL1CQAceZ0DY3UFoSHGwnApMh8KMkyMJ1TdvM2uwJuMMnw83EbscnJsJj4eYYsLy/2gJMsSmq2mKUQZxOHy8NnVeKwfYk08SP/2diLs9JRFtmR1xdmwPNQ2c/H7NJf2QXx8QTWG7XyF5aciEVdQIzJkGRBM1oizCL2vbsLKM5H4fJQt+ltLfndsauFh2alIyLGZ+HyUncTlBdbHRGSXNeBEl5yZVQMtsWmYNfg0jWNBOZh9JAxXowrQ0MIDnwYoCNSpPUVhdRNmHAqFshwLf850IyL8eHwaX99MxI3o97i80r/T7w6LycCh+Z5wNFCBnqoc3LtkFZXUNuOLa/FgMihcWukvtcqlqYWH9RdicCP2Pf6c6Y5BUtzfHdHYwsWGi7E4FpSDCyv8MN2zd7maHC4P391KxOfX4vHjJGd8NsruH7NJJRXWYPmpSCS8r8G9Df0wzdOoR2RVH/rwn4A+8uZfjL/++gvy8vLgcrkYMWIEfvnlF4SFheHFixdYuXIlPvvsMwCAjY0NNm/e3OvPO3XqVPvfFy5cSLzer7/+CiMjIyxfvhynTp1CUFAQYmNj8fLlS/zyyy9wdHTE48ePAQC2trZERNI/iUnuhrizvh9CMisw9UAIcqWYyRYFJoPCxmHW2D3bHV/fSMDWO8lExIUoeJio4/a6QCQW1mDe0bfE1oqOUJRlYfcsN5hqKmDyvmCpmqQAgaro6uoA3I0vwpfXE4itEboqcri00h8ZJXVYR1iNbamthPPL/XApIr9T9bgoaCrJ4uxSX4RmV2Dvi0yJhA+TQWHnDDfIshhYey6627npmnvDZlKY42OC0U56WH8+lsgS522mgW/HO2DNuWiiEFctJVnsm+OB3x6mEdUTMxgU/pzphpLaZuKK8vVDBC+oe573vHZbS0mm0wtVC5ePeg4Xn19LwPSDoUIr5uVlmPh8tB22P0wjDvEVhdWDLPEqvQxJheTXb8esGgptCioFuBqpYtNwa3w60k7iC7CaggxGOepJpb6ZIGXr1FB7HbzOKCMmYyy1FaEqzybOsaEoCkyKQrQUyw+z15XqmWikriBVaLG6tIHFLCaaWrjY9yILzb0g2zNK6/AwsRh/Pk0nUu+U1XPwRoRFTVrlTW5FA8y0yGeTM0vq4WqsBiP1nmdxAAJ7V3ZZPXHeTW1zK8JzKsXaVTqCpmlByxQh6QEIVDdjXfSJGooA4FV6Kay0lUSGu3ZFcU0zbsS+x8qBFkTLN7fysO95JjYNsyFSuPD5NH6+n4I1g62Ic49OhuZisK029s5xh4YCu11hweXT0BBC3ux7ngk2k4EVA8i+w+24QrxOL8NvHYgYcYgvqMa2+6n4fJRtu6UIEOQj5ZY3Er27eInJN2ngtGL5qUgMd9AjIt14fBqbLsWAzaSwY7orEcm5/VEagjLLcXqpT/t3KK5pxqFXWRi84yX+fJIBFkWhuomLVl5n5ZCNnnKPbT75lY2YeTgU/pZa+G2qC9E108IVKIRCsytwZXWAUMWPHJuJ88v9cH1NQKdzmFFSh8n7giEvw8KRBZ5QkiUL325DaW0zZh0ORWldM26uCYQNQcC0MLyraMSU/SEoqW3GnfX9iMOwxW1v+sFQxORX4976/hglRdi5OPD5AmXQtAOhCLTWwpWV/r2yxvWhD/8J6CNv/sVwd3fHpUuXoKKigvr6emzZsgX+/v4YMmQIDh8+DEBA3Ny7d69TvXhPwOfzcf78eQCAuro6xo0bJ9X6lZWVOHr0KBYtWoT+/fvD3d0dgwcPxpYtW5CfLxgMDRgwAM+ePYOGhvS+3d7CXEsRp5f6wMtMHeP3BBEPhiVhqL0ubq/rh5Cscsw5EkZc8SwM+qryuLIyANrKspi4L7hHwa2sD5XPS/qZY9bhsG7BnZJgrqWI62sCUNPUitXnookHmVpKsri4wg+F1c1YdSaKaD0rHSVcXOGHQ6+zseupZKWFnqoczi31xbmwPPz5RPLycmwmjiz0QlFNM7641tmu1DH3hsWg8NUYe2yd5IStE52gpyqHdedjiMir2T4mGOusjxWno9BIYG/yMtPA5hE2WHcummhAq6sih0UBZvj6RiLeVUgeMMuwGNg5wxVH3mRL1TrUEZqKskIHBC08PmLyqzF85yvseprejaSb4GoAZyNVnAnL69HntkFXRQ6zfUzw11NyAqrNWsaggAE22jiz1BcvPhmERYFmOBf2jtjONcvbGDdjC8EhvO7HuRogNKsC5YRkq4O+CtTk2URqLUBArgRaaUnVnudmrCbVuZdlM6ULRTZRRUUDObmspSQrlYJGjs0AjxbknijIMDv9Ebsei9FpWT4NHH6TDTV5GaEqCCaDgiyLAfkPy/P4tMjgYgUZBvSlCDnNq2iQyqKRXFQL5geVbG8Qll0Je30V4kDSN+nlMNdSJLYtJBfVorimGUPtyMie5lYebsYWSmWZOhGcCzcTNeJsjuPBORhko02sWDn/9h3UFNjE5NCDhCJU1JNbst5klOF1Whm+GueAUU76ePP5EMz3MwWLQaGFy+9G3iQX1uLwm2xsn+ZC9J2Laprw3a1E/DLFBToE1fW1za1Ydz4G64dawdO087vXYDtdXF8TAA1FGbE11vJsJjxEkDd8Po1Pr8TD0VAFWyc6El3DP91LRkZJPQ7P9yIK/D36JhuXIvJxeqkP9FXlUdvciqn7gxHw6zP8+TQdOeUNgnweIc8ZWRYDkyRU2otCbnkDZh4KxRBbHWyb7EREMjW18PDDnSTkVjTgykp/seHIcmxmp3P4NlswwTjNyxi/T3OBjJT124nvazBxXzCsdJRxdlnPq9BfpZdh/N4g+Flo4twyX6nD2rviYWIRxu55Aw8TdVxZ5Q8TKVr4xKG4phnzj7/FmbA8nF3mi1UDLYltkH3ow38ypKN0+/B/jvHjxyM+Ph5//fUX7t27h4KCAsjIyMDKygrTp0/HunXroKDQ+wfhs2fP2uu7Z86cKZWtaceOHXj27BlCQ0ORlpaG8vJyVFdXQ0FBAQYGBvD19cXs2bMxYsSI/19ljLIsJr4b74gASy18ejUOwZnl+H6CI3GtqCiYaSnixppAbLmRgLF7grB/rkePguUAgYJh7xx37H6WiWkHQvHnTDep8gsAwYBv1UCB5WbN2Wh8O94Bs4V4qkVBV0UOv0xxxpKTEVh4PBxHFnoRSeTVFGRwbrkvFp+IwNJTETiywEvisbXSUcb55X6YfTgMDIrChqHipc0mmoo4t9wXMw6FQVGWhZUDLcUuryLHxqklPpiyPwS/P0rDZx/k2YqyLNjoKiOnvAGH5nli8AdZMYvJwN457ph+MBTf3k7Cz5OcJF6z3453wFc3EvDp1TjsneMhcfml/cwRlVeFjRdjcHKxj8SZvGEOupjiYYj1F2NwdZW/xBd8e30VrB9ije9vJ+HiCj/iNow2aCrJgC9C2dQ2CD/wMgtXIguwa5Zb+7VOURRWD7LE3CNvMd7FgNjCIAyrB1piwO8vkPi+hij3Qk9VDl+PtccIB71OL4ZjnQ2w7X4qXqWXtZ9jcfCz0ISBmhyep5ZiNEGrh6GaPNyM1fAgoYgos4GiKAxz0MWzlFIMsiWTsvtbauJSRD5ItZVuJmpSkdM2ukpCG7hEQZbFRIYUDVVqCmyhai1R0FCUwbXV/sgrbwSLxWjPsmAxKPxwJwnD7XWhqyIHiqLA+HArXArPx0Q3Q9joKYNP06BpGjQNmGgqwNHg7+unlSfI0hm35w02DbOBuZYi6jk81Ddz0cDhiiQxInKrsIDg/LYht6IRo53IW2FSiupgr9+7CRjgQ0W4ECukKDxLKcEQQiIGAO7EFWG4g263zChReJJcAl9zDbGqjY7ILK3H25xK7JzhRrR8TWMrzoXl4cwyX6Llm1p42P8yi3gg3tzKw8/3U/DFaDui5yiHy8O3t5KweYRN+6BcUZaFr8c5YKa3MS5HFkC/gyWXy+Pj82vxWNrPnOg510aUTPU0IlIu0DSNL68nwFRTAasGCP+tdDVWw+OPBmDlmSgkvK8RqlJr5fHhLGL/dj1NR2JhLW6tDSQin44F5eB2bCFurAkkCpe+GiVoaTq52BuWH3J0ZFkMNHP5YDKo9mY6UWjl8YVWh0tCZmk95h4NwwRXA2wZY0/07lrT2IolpyLAZlA4v8wPKvLkrU534wvx6ZV4fDfeQWgGjiQ8SirGx5disW6INVYNtOhxvs3J4Fz8/jgNP050wlRPI6m30RGcVh5+eZCKa1EF+G2aS4+askThQUIRvriegOEOujg030tqhVIf+vCfjD6K8j8Apqam2LlzJ9LS0tDQ0ICqqipERETgs88+E0vcLFq06MNLLC3RqjR8+PD2ZQ8cOCDV/nl5eeHzzz/HzZs3kZKSgrKyMrS2tqKmpgYpKSk4efIkRo4c+a/xnw530MX9Df2RU96ACXt7pnDpCnkZJnbOcMX6IVZYcCwcF8LzelyNTlECS9b2aS7YdDGmx0HGE1wNcHKxN359kIrfH0lud+oINQUZnF3mC3kZJmYdCkMZYUCpihwbp5f4gMen8d2tJNQR2I9sdAUEzsmQXOx7kSlxeSsdZZxe4oO9LzJx7q1klYeuihxOL/VBbH41TnaYWf99mgvure/XbVCvLMfGsUXeeJJcgqNvJLfdsJkMfD7KDrH5NThAEPhMURS2T3NBQVUTsb3pyzH24LTyiBRHALBygAWUZVnY8Uj6Cm8tJdn2hhFR4HD5KKppwm8PUjv9fw8TdYx01MX2h6ki1iSDjooc5viYYheh+obNZGBZf4tuM3oyLAbm+5niOGFrEYNBYbi9Li5KY51yM0BUnmQbXBuG2uviWUoJ8f0YYKmJuPxqouBqAHAzUkNuRSNxPbetrjLSpGicMlKXR4EUmTcaCjKokiKwmMVkwNNUA1M8jTDB1QBjnPUx0lEPQ+11UdfMxRRPI6wYaInlAyywtJ/gTzOXD08zdQx30MVIRz2MctLHaGf9TsQNILhO1BRkUNPEhaOBKjxNNTDQRhtjXfQxw9sY/kIqq/l8GmVSVoXnVjTATIrZ5eSimn8krPhtdoXQHCth4PFpvEgrJa4Ip2kaQZllGO9CrmK4GPEOnqbqxL/9p0NzMc5Zn/hYnwnLhZOhKjxMyMihM6G5MFCTI54QORaUAy1lWYwj/M5HXmdDns3EPL/udeXWusr4aqx9J2XAkTc5aGzhtttdJeFUaC5yKxqwUcIkRxsuhOcjPKcSf850E0tWaX5QzgZaib52ujaFAYImoxPBuTi60IuIiHmYWIQ/Hqfh6EIvIvXF0+QSfHMzCRuGWndqupJlMXF5pT+cDFTFtnsBgJ6KXDvpQ4q04jrMOhyK6Z7GxMRNaV0zZh4OhbqCDE4u8ZGKuDn6JhufX43H/rkeUhM3NE3jeFA2vrqRgD9muGH1IMsevWs3cLhYez4a12Pe4+IKv14TN/mVjZh79C3yKxtxd0O/f4y4aeBw8dnVOHxxPQHbJjtjx3TXPuKmD/9z6CNv+vA/CQM1eVxY7ocxTnqYsj8EVyPze0y2tIGiKCzwN8PZZb44/DoHmy7F9ir/Y4yzPi6t9MONmPf46FIssYWpI3wtNHFtdQBuxRbi82vxxC00gCDQ9sgCL1jrKmH6wRCR1dtdoSjLwvGF3iiubca8Y+GokRAWCgheDM8t88XRN9nY/1IygeNkqIoTi7zx/a1ETN0fLHHfLLWV8OlIW/z+KA134wUZJS5GarAW4Qc3VJPHsYVe2PU0HY8IAmk1lWRxeIEn9j3PxPNUyYG0ynJsHJjngbNheURV0HJsJvbMdsfJkFyEECzPYjLw3QRHnHv7DuE50lV4aynJiLW5MBkCq9nqgZY4K2TG+7NRdniUVEKU6yMOqwZZICK3EklSZjd1xRxfE4TnVCKdkKCY5mmMkKxy4tDv0U76uBtfhELC5f0sNFDT1IpkwlBhI3UFGKrLI4LwPKorysBMUwGxhDXz1rrKKKhq6pQbJGl/pAlE11CSQWU9OXkjDkwGJfTa5NM0GIQDFpqm0cDhEr/wVzW2gMuniSwqgCDv4n1VE0y1yHIXaJr+oLzpHXlTUtuM3IoG+FiQqT5jPtyf7oTER0x+NfIrG4krxfMrGxGRU4UpHmSDwNrmVlyNKiAOKm5u5eFEcC5WDxKvvmxDPYeLM2F5+GRE94Y9YSita8b+F5n4eqwDkUonv7IR+15k4afJTkTWjayyegRnlmP7NBciVU9GSR22P0zDzhluRPlBqcW1+OleMv6a6QYtAvtManEdwrIrsXGoFWRZjE5tWRbait1UNfEF1fj8Wjz+mu1GlKsS/a4SH1+Ow66ZbkTXXHhOJTZcjMEfM1wRaNX9mlOUZeHCCj+4m6iJJHDYDEqqfCZAEHz79c0ELPA3E9rGKAz5lYI8FwcDFRyc50GsduXx+Nh6JwkHX2Xhwgo/InVoR3C4PHx6NR6HX+fg5GKfHufI5JQ3YPL+YFQ3tuLkYm+iSnhxeJxUjLG738BeXwX75nr8Yxk0Me+qsOxUJN5VNuLBxv4YSxiC3oc+/Lehj7zpw/8sWEwGPh5hi6MLvHDgVRbWnY+RumZbGDxN1XFppR+KapoxeV+IVJaBrnAyVMOxRd7Iq2zErMM9y9Sx0lHCjTWBqOdwsfA4GZnSBjaTgT9nuGGQrQ6mHgghrkZXkGXh6EIvaCvJYvaRMKJ8F3t9lQ/EVzZRZbmXmQYG2+ki6l01Bmx/gXF73uBC+DuR59DdRB1753jg0yvxRASIi5Eads50w8eXYhFHMBB2NFDFr1NdsPFiLFF7j52eCr4e64B158nawax1lbFljD0+uhxLdDytdJTwyUhbfHIljnhgDgjUU6LGKjJMBtyM1fHoowH4dJRwK4GBmjxWDLDA1jvJvSJEdZTlMMfHGH8S5CGJg5aSLCa4GuBEcC7R8nqqcoIK00gy9Y22siz8LTVxL76IaHlZFhMzvI3xJp3cqhRgqSl97g1haLGWkgzUFdjEjVNG6vIorG4izrHRUJRBHYcrFXEsCkwGJbRVjKYh8prtiuZWPvg0iMmbsnoOlGVZxFahgqpGsJgM6BMGpBbWNKOew+1xsGgbQrMq4GSoStwCFZFTielexkQBrIBAZTHSUQ+yhAPTK5H5GGSrTayiuRpZAFs9ZbgSBqNeicyHjoocBtqQtWKeCsmFlrIsMfn055MM9LPWgo85GRn2w50kTHQzIFIB8fk0vrgWD2tdpW45NMLQwuVj06VYLAwwI9qfxhYu1p6LxrL+FggQQnx0RXVjC1afi8KaQZb4aLgt7m3oDwM1ecgwGaAg+K3tiJLaZiw/HYlNw6yJbHe55Q1Yey4G345zILIwJRfWYumpCHw91kGsYkOOzcSpJT5wEGU5pICRUhAacfnVmHPkLYbZ60q0cLchrbgOUw+EYLCtDnZMcyXOXGlu5WHdhRgUVjfh+upAqQmTyoYWzD8ajvSSOtxaF0hkuxOG56klmLA3CANttHF6iU+Pc3IAwXX6491kbL4ch58nO+PHSU5S27aFgcvjY/ezDMw58hYjHHVxfplfr2zZfejDfzr6yJs+/M8jwEoLl1b6o57Dxdjdb3oc9NoROspyOLfMF/2ttTBhb5BUdcLCtnVhuR8stBUxYW8wEgqkVyJoK8u2y0unHgyRqi2GwaDw3XgHzPMzxYxDoYghtIjIspg4MM8D5lqK7e0HkuBooIqzS32x/2UWzhEE334zzgEUABpA4vtabL2TBI8fn2DZqQg8TS7p1qIx2E4HWyc6YuWZKKI2o5GOevhyjD3WnI0iIljGuxpgvp8pVpyOJCICJ7kbYpSTHtaeiyaq957rawI3YzV8djWeiBhZHGAGfVU5/PIgReKybWAwKCjJdR7YyrAYYDIoTHTTx9VV/hJl6CsHWqC4plmqJiZhWNLPAsGZFYgnVJGIwuJAc9yIKSC2Es30NsaVyAJigmK8i3StU04GqrifSEb2AEA/Ky1iZQ8gyLEgfY5RFAVrKaxT+qry4PJpovsZANQ/NMNIqusmAZOihIZP8/g0sVWgjiPYD0VC8qa0lgNtFfIBTV5FI0w1FIhrwlMKa2GhJb6GmQQJ72uILVMAcDO2EK6EA0Yen8a9+CJiFQOPT+NKVAFxUDGfT+N0aC4WEapuuDw+7sYXYf0QMotIbXMrDr/OxubhZEqKtOI6XI8uwBej7Yn252VqKaLyqogqrwHgTFgeimub8elIW6Lldz1NB5+GxKryNmx/mApHA1UiexWPT2PjxVjY6qpgzSArAALi/+GmARhgowUa6ERINbfysOJ0JPpba2N5f8ntWJUNLVh8MgJjnfWJLEHvKhqx8EQ4Vg6wwByCGvT04npkltbDyUClmwJHns2EG+E1HpVXiXnH3mLDUGuJWXptiH5XhZmHQzHX1xTfjSdTaAECsmz+sbcorm3GtikuUgf4ZpTUYeK+IGgpy+DSCn/o9qBJi8+nsftZBtadj8FPk5zw1ViHXoX9FlQ1YsahUIRmVeD2+n5SK55EIf/DxOWt2Pe4ssofiwPNiY9zH/rw34o+8qYPfYBgdv7EIm8s8DfF7MNhOPw6i7ihRhTYTAa+HueAX6Y44+PLcfj9UapUrSsdIcdm4o/prlgcaIaZh0OJZ/k7QkGGhUPzveBvoYnJ+0OkIoGoD2HC34xzwLxjb/EilazFis1k4K9ZbnAyUMWsQ2EoqpE8AHUyVMW5Zb7Y/igVx4LEZ5UYayh0qtdtauWDx6fxLKUUa89Hw33rE3x9MwFx+dXtZMd0L2OsHmyJRSciiKxgc31NMMhWB0tORBBl+GweYQszLUVsuBBDdL6/G++IVh4f2+5LJlgoisJvU13Ap2mcJcj7YTAEVaw3ot/jdXqZxOXboC4vGHBTEFikpnkY4eA8DzxILEExgfpLQYaFz0fb4tcHqWhq6bniQltZFvP9ybNvRMHBQAVuxmq4RKimGWyngxYen8jSBghmd9OK64hVdoPtdJBUWIsSQiWdj7kmHiQWE5NPbsZqyC6rJ1Y+2eoqI4OQvJFhMaCnIkece8NmMqAix0LFP2CdYjKFK2/4NE2sIGng8CDDYkBGQlZGG0rrONCWYjY6t6JBKptAclFtry1TAPA0pQR+hCqR/MpGZJXVo78NmQolPKcSPD5NHIb8JqMMPD5NrIp5lV6GhhYeccjzvYQiFNY0YYQDmarieFAObHWVxWa6dMS2+ymY42sCcwLrW2MLF1/dTMTXY+2Jcl/yKxux/WEqfp3iQlSWEJFbiRPBudg1043omr0eXYDbcUXYMsae6J7462k63lU2YufMzpXdSrIC2/T+uR7tdhyapvHbg1SwmAz8PFlymH9zKw/LT0fCTk+gGpWE0jpBe9A4F32sHWwlcfmUolrMP/4WG4fZ4Na6fhjppNdO4DAoYJSTHtFAPyy7AguPR+CzUXZStYr9ej8FHw2zwcZh1sTkcX5lI6YeCIG6ggzOL/MTWh0vDq/SyzDlQAgmuRli72wPYkVgR9Q1t2Ll2ShcicrH1VUBmOhmKPU2OuJpcgnG7g6Cg4EKrq8JILpvJIGmaVyPLsCYvwT2q7vr+/dYXdSHPvy3oY+86UMfPoDBoLBigCXOL/fF6dA8LDkVgQrCCmBxGOdigBtrAvAgsRiLToT3eJsURWHlQEvsme2Oz6/F488n6VITTEwGha0THbG8vzlmHwkjJmHaMM3TCL9Nc8Gac9G4GUPWaMNiMrBjuit8LTQx41AoEWHiZKiK00t8setpusj63jaMddHvVnNKQxCqW8/h4mJ4PqYeCEHgb8+x/0UmeHwaqwdaYqyzPhYcl3w+KIrCDxMcoacqh7UEFeJMBoVds9yQX9WIgwT2Lzk2Ewfmen546Zas3lBTkMGKARbYdi+VKGzbWEMBX411wOfX4oltgZpKMqAgmIG9viYA26Y4Y7iDHkY46GLrnWSibUx0NYSOihxxWLAorBhggdCsil4r4lb0t8CZ0NxuaixhYDMZmOZphEuEwcWq8mwMsNHGHUL1jYaiDDxM1PAshez+01aWhbWOMnHFuL2eCoprm5FHUC8PCBqnSG1TgMA69V6a0GJF6UKLRYFJicq8IbdN1TdzoSxFwGVpXTN0pJjZzqtolCqsuKqxBR4masTLC0NhdRMKqprgTUjevEgrhY+5BrHF6m58IcY46xPPzF+OzMc0TyPi5W/FvseqARZE5ARN0zjwMgsrBpDVAtc0tuLYmxx8PMKGaID9Or0MsfnVxKHAe59nQkdFFpPdJWf70DSNLTcSMN7VQGiOS1fUNbXikytx2DzCRmhgcFdkldXjm5uJ+GOGK/RUJV+zT5NLcCwoBwfneQq9FiiKwhhn/XaL4b4XmXiSUoyD8zwgK6HGms+n8fHlWNA0LTEwGRCoo7ZcT4CHiTq+Gesg8VxlltZj/rG3WNbPHMv6Wwh+d2e4YZK7IWSYDLCYDKKQ3KCMciw9GYFvxzlgvpCgaWG4n1CEFaejMNvXhDijCRBUeU85EIJAKy0cmOcpNfFyOjQXq85E4ceJTtg8wrZHCpTM0nosOREBFoPCnXX9ehWU3srj4+f7yfjzaTq2TnTEtsnO/4hNqqapFRsuxuLneynYNcsNP05y6hFJ1Yc+/Leij7zpQx+6wN1EHfc29IeCDBOj/3pDPGASB2tdZdxaGwg9FTnMOhzWKxvIUHtdXFsdgGcpJfj8WrzUocgUJSCpfp3qjLXno3GWwJ7UEeNcDHB4gSe+upEgkVhpA4NBYdtkJwy108W3t5KQXSZ5oOhqrIYzS32x80k6TofmilxOkoeey6fB5dMoqm7GgVdZqGtuBUVR+HacAxwMVPDl9QSJmTBtFeKltc349naSREWDihwbRxd44eDLTKLaZhNNBfwxww1bricgs1SyAsLPQhPL+ptjw4UYoiDr2T7GsNZV7tYOJQpzfU3wwwRHPNw0oJMXf8tYewRnlhORfgwGhR8mOODQqywixZUoaCnJYoG/KXb1MvtmoK0OGAwKDxPJLIwzvIzxNKUE5fVk6pgJbgLrFKnaZai9Lp6mSA63boO/pSZCssieRXIyTDgYqBITXjZ6ysR5VgBgraNE3EAHCMibCkLVkDiICiympQgsrudwiS1TAFBWx4GOFE1TrTw+7AgG2m14kVoKcynbcLoiLFuQd0MSZAsAT1NKMYQwHLWVx8eDxGKMIwwHrajn4GlyKWZ4kVmmssrqcT+xGOPdyGwWL9PLUF7PwXTCNpwjb7LhbKRKZCnj8WmcCMnBpyNtoaYgWRGRWVqPY0E5+GkSWfX4lagCpJfUYctYMjvWj/eS4WakhiWBktUgza08rDsfg3l+phhsK/nc5pY34KPLsfh1qgsRMfQwsRgHXmbh8HxvaBOEd//yIAXJhbU4utBb4oC+uZWHZaciwfzQxCjpWOZVNGDu0TDM9DbGug5NXQwGhV+nOGO2jzFkmQyh7XEd8SK1FCvOROKnyU6YQWjxuxj+Dp9cicPeOe5EhF0bXqWXYdbhMCztZ44fJjgSKwUBgU3wm5uJeJxUgrPLfDDJvWdKmcdJxZi8Lxhe5hrYO8eD6BoXhcLqJsw8FIo36eXYPcut1+qdNoRlV2D5qUjUN7fi4aYBGGpP1gzXhz78L6GPvOlDH4RAVZ6NfXM88NFwa2y8EIOdj9MkKi4kQVmOje3TXDDV0wgzD4XhUsS7Hm/LVk8Zp5b4IK+yEdMOhEqVh9GGcS4GOLXEB38+Scfe5xlSqXj6W2vj7DJf7H6WgZ2P04gGrBQlyM6x01fCzMNhRO0/bsZqOLXEB78/TMMZESSTm5GaxJdDJgNQU2DjxprA9hcWBoPCzhmuaOXxsfpctERFhrQV4hbaStg9xwNfXk8gsqgNd9DFPD9TrDobTRQwvHGoNZRkWfjpnmQlDEVR+G2KM16ll+FJsmTCYKqnMRYEmHV7wdRSksVno+zw7e1EIjuUm7E6Btnq4PeH0leWd8SKARYIz6lsb8jpCZgMCgv9zYgJR3MtRQy00cbNGDI1zTB7HbyvakJKERkJMsxeF8GZ5cTkq7Shxe5S5N5Y6yijsKYZtQS2QEDQrpZFQMC2wdFQtVfNe20w0VAQ+qwx1VQgVt5wWnlwNiKX3zdwuJ2smZIQnFkOPVWy5es5XORWNMKhl7ap0KwKYktTA4eLsKwK4kFRSFYF2EwK3mZkqp5bse8xwVUfZoTWidMhuRjrrE/c5nXgZRYWB5oTzfBXNrTgRHAOcVbMlch8ZJc1EBFPNE3j21uJmONr0q2SXhhKa5vx091k/DzJmUjx9CipGA8Si/H5aDsiYujneymQYzPwCUGOTmMLFzsep2GmtzFRNklSYQ02X47FzpluREqNUyG5uBb9HicX+0i0BXF5fKw7L7AY75rl3q3VqisKq5sw58hbjHU2wCcjun9XiqLw/QRHhG4ZKlYd9CSpGNvup+D3aa7EJMzBV1n4+X4KTizylopUuB1biFVnovDzZCesGihdlXdNUysWn4xAeE4lfp3qTBRw3RV8Po2dj9Pw0aVY/DbNBZ+PspOKPOqKF6mlGLP7DWz1lHFzbSAsdXoXtg4Iwo5/e5iKxSciMMnDEMcXeROHnfehD/9r6CNv+vBfh95WfreBoijM9jHFqaU+uJ9YjDlH3vZKQdC2zVUDLXFsoRe2P0zDF9fie1QBDggGUGeX+sLFSBUT9gYjijBIuCO8zTRwZZU/LkcWYOOlWKkaYdxN1HFllT+uRBXg65uJRPkuFEXhs5F2mOdrilmHw4hCgz1M1HFyiTd+e5CK82+7E14MBoVh9roQ9SrCYlDQUpTF7XX9YKXTeYZblsXE7tnuKK/j4POr8RIJLGkrxAfb6mDDUGusOBNJpFT4ZIQNjNTlsfOJZEKMxWTgr1nuuBVbSLQv+mry2DzCBl9eTyBqqxKFOT4m0FSUxb4XkivdAeCL0XZ4kFjcK9uTppIsFvib9Tr7Zoa3MdKK64j3ZYyzPi5G5BM9UxRkWBjuoEtUFQ8AltqK0FeVQ1AGGSHja6GJnPIGFNeQKYFcjcmVNxqKMtBSkiXOvTFSlyfOvAEEhElhtfRNeV1RXMtBK6/7ucgqayAeEFU3taKsllw1lFveCFV5MkVLK4+PgqommBLaplKLaqGlJNvrQUpYTgX8CCvCgzLLYaQhT5xL8SChCONcDIgIBJqmcSE8n6jhCPi7Hpw0qDgqrxLJhbWYR2hvuRjxDr4Wmt3akoShnsPFH0/S8cUoOyL71u24QmSW1hMRQzRNY//LTAxz0MUwB8mD/tK6Znx5PQE/TXIiatV5kFCEW7HvsZuA/KBpGl9cS0BpHYcoYLmsjoPlpyKxZrAVRhI0RT1JLsaliHwcWeAlkcCjaRpfXk9AfmUjji/0lmiNKalpxpwjYRhoq41vxtmLvOcpihLbJncvvggbLsbi05G2RHXTNE3j1wepOPI6GxeW+8GXkCilaUEo8Fc34nFisbfU6pTc8gZM2R8MNpOBa2sCYKQuXbAxICB/lp2OxO24QlxfE0hkJROFVh4fvz5Ixbrz0fh+vCN+mUJWcy8JWWX1mHogBC/TynB7XSDm+JhIRXD1oQ//a+gjb/rwX4fNl2N7VKktCnZ6Kri9LhBmWgoY89cbPJPC6iAKAVZauLO+H1KK6zDjUKhU7U8dIcNi4Jcpzlg72BLzjr7F9egCqbdhoS3INcmvbMT8o+GoliKbwkpHGVdXByA0uwLb7icTkT8URWHjMGusGGCBOUfeEg0wPU01cHKxN7bdT8G1qO45JKOc9CDLFv4401WRxe31/WCsIfzFR1mOjZNLvBGRV4nfHkq2FbVViO97kYm4fMmE2coBFvAx18Dqs1ESG6VYTAa2T3PB7bginBVCVHWFsYYCtk12xufX4omIxcnuhvAwUcM3txIlLisKDAaFnyY54WhQNlFOioGaPJYPsMDWO5LtZuKwYoAFOFweontAUrZBRY6N6V7GxOqbUU56KK1tRjSh4me8KznZQ1EC0pHUOqUqz4azoSpCs8nIHjdjdSQX1hITsja6SkgvIa0LV0C+FM8sDUVZVDb0Pj+MyYDIwGJS21QdhwtFWfIBR2ldM7EqpLC6CRQF4hrblKLaXmVOAIKWl8LqZmJlzPOUUgwltExxuDw8TCRvmYrJr0ZxTTNx8PDVyALYSFEPfuBlNub6mRCRaWV1HOx9non1QyQH3wLAoVdZMNVQaA/nFYfa5lb8dC8FX49zILKq3UsoEoQIj5ZMlrSRK4FWWkSD/fzKRnx2LR7bp7mI/I3riBPBuXibU4F9czwkEj0cLg8rz0TCy0wDawZJbmCKy6/GpouxWD/EEp6mkivTf32QipCsCpxa4gNVBfHHsaKegyUnIzDMXhc/TZQcliwKN2Pe49Orcdg/14OotpzHF+QU3YkrxJVV/sShuVweH19eT8D5t+9wZXWAVE1wgMA+NGl/MAbZ6uDIAi+xZJQoZJTUYdK+YNA0jVvr+hHZ40ShqKYJsw8LchJvrevXY+tWR9A0jXNv8zB+TxD8LTVxc20ArHV7r+LpiNQiybmAfejDfxr6yJs+/NdBSY6Nkbte436C9I1MoqAgw8L2aa74foIjNl6MxdY7yUTVzuJgoCaPyyv94GyoivF7gvAmg7wNqCMoisLiQHMcmu+J728n4dcH0rdaaSnJ4sJyP6gpsDHlQAhRqHAbDNXkcWWlPyJyKrH0ZCSR5QcAVg20xKZh1ph/9C0icislLu9l9jeBc7lLkGx/a61uM/IyTAZU5VnQVpaVOKOnoyyH00t8cTWqAEffZEvcl5GOepjgaoBlpyVXiLc1RDVzefjudqLEgb2Oshz2znbHtnspiCMgtsa7GmC4vS4+uhQr8bxTFIWfJzsjNKuCOFxXGJwMVTHHxxR/EFrmVg20wPvqpl5VhwtCftWx61nv1DcLA8zwIKGYSMEix2ZisrshLoSTBRcPsNFGbVMrot9VEy0/3FEXZXUtxJZFf0sthGSS5d6YaSpAXoaJVEIbl42uMpGVERAobwqrm4ifM5qKMr1Se7WByWCAL+R64/NpYttUg5SZN6V1HOgQVoXnVjTCWEOB2JKQXFT7j1imXIxUib4Tn0+juLYZQ+zILB+v08uhLM+GK6HN7HJEPia4GRCFi/L5NE5JUQ+eXlKHNxllWEqQ/wIILC4BlppwN5FMIhTVNOHomxx8NVa0mqMjdj5Oh42uEsYTqDYqG1rw3a0k/DDBEVoEJOD58HdILqzFTxOdJC7bwuXj65sJWOBvhlEEhFl4TiV+f5SG/XM9Jaq92lQxPD6N7dNcJB6XdxWNWHoqAh+PsMVoZ8lk36FXWbgaVYCzy3wlhivXNLZi/rFwmGkr4gtCG5kwXI7Mx1c3EnBovicGExCYHC4Pn1yJRUFVE66s8ocFYTZVA4eL5acjEfOuGjfWBsBOT7p7/HJEPhafiMDno+zwzTiHHlmcHiQUYfHJCIx30cexhd7E6kFheJlWijVno2GhrYibawO7KZh7gop6DpafjsLuZxk4PN8LW8bYSwzBlgYcLg9/PE7DyrNR/9g2+9CHfwv6yJs+/Ndh60Qn/DjJCV9eT8CmizHEDTskmOhmiLvr+yE8twJTD4Qgl7AaWBRkWUz8PNkZW8bYY+udZOx7ntnjivIBNtq4sTYQj5KKselSLFGtdUfIyzBxYJ4nBlhrY/L+YCLioA2aSrI4v8IfNGjMOfqWeKC2ONAcX46xx6Lj4US1zF5mGtg31xM/3EnC1ai/VUYKMix4m/39ki7DZMBGTwnPNw+CuoIMlpyIkJi5Ya6liBOLvbHraQZRyPDSfuYY4aBLVCEux2bi8HwvPEkuIVLU+FpoYuMwa6w5F01UD/39BEeoybNx6JVkK5O2six+muSEb24lorSu5wq1j4ZbI/F9DW4SHCsFGRY+H2WH33pZHb68vwWicit7ZBFsg7mWIvpbaxEHdc/0NsG9+CKiPBhZFhOjnPSIiTEPE3VEv6tCLGGAeYClJiLzqoiVPa5S5N5IQ97oq8qDy6eJrx/1f4q8oUQpb0A8E9/A4UJZjoy8aeBw0djCI64Kzy1vgJlUNeF1sNfv3UxzWHYlcd5NYmENot9VwctMMqEBAHfiCjHOxYDo2DZwuLgTV4iZhMGvL9NL0SRFPfjBl1lYGGBK1PxVXNOMc2/z8BFh1s3vj9IwzEGXiOhJfC84hj9McCQ6Lj/cSYKnqTpR4HNOeQO23UvBjumuEpUogv1ORVldC5G6qKS2GWvORWPLGDsiVczRN9koq+PgyAIvidaY6sYWLDoZjnEuBkRV21ej8rH3eSZOLfGRaN+ra27FghPhMFCTx66ZbsQNZl1x7m0ett5JxrFF3uhvLbnCvrGFi2WnIpFV1oC/ZrkTq+nK6jiYdTgMza18XF7lD33C/CtAoPLZ+zwD2+6n4NgiL8z2MSFet+M2tj9MxWdX4/H9BEd83MNWKkCgHvr9USrWnovGwgBTbJ/m+o+0Pr1MK8WKM1FgMyk83DgA/azJbJakSCiowYQ9wXiWUooj873+0W33oQ//BvSRN334r8Q4FwM8/mgAqhpbMWrXayJigBRmWoq4tjoAgVaamH04jGigLwnTvYzx50w3XIh4h5Vno4iDQ7vCUlsJN9cEQobJwNQDIXhHWBXcBiZDEPa3epAV5hwJIwq3bYOSLAvHF3nDQFUO0w+GEIcoz/E1wY+TnPD7ozQ8J7CQ+Flo4uhCb3x3K7GTTWyciwFkWQzIshhwN1HD5ZX+0FSSxYF5nmAyKKw8EyXRQuJipIb9cz3wxbUEhEi4ZtoqxHUJK8QN1ORxcJ4n7scXETWYrRxgAQcDFXx8OVYioacoy8K6IdbY8zyLyOIzxlkfA6y18eW1hB5bmZTl2PhyjD1+upuCmkbJ1+skN0Noq8jhCIGySRTUFWWwKNCs181TS/qZ415CEZoIQnQdDFRgratETMhMcDXEvYQiIlUKm8nAIFttYiump6k6SmqakF9Jdm+5SUHe2OqR26ZkWAzoq8gR5978U8obFoMh9F4Q2KbItlHXzIWiDBl5U1rHgQyTATWCgTQA5FY0EOfd8Pg00opr4dhL21RWaR36EWbMPEspxUAbbYl2GQBoauHhaUoJccvUvYQiGGsowJnQVnIiOBfz/EyJ8mXyKxtxN6EIc33Jsm72vcjEEDsdoiDhxPc1uJ9QhM8Ign75fBpf30zEAGttWBGEtD5NLsGL1FL8NEmyzaeVy8MnV+Iww9uYaDD7LKUEF8LzsXeOu0RypYXLx5pz0Rhgo0WUF/QspQR/Ps3AZyPtJJJlza08LD8dCSttJXwzzkHith8nFeOvpxk4vMBLogWpqYWHpScjoSLHwt45kvN8ROFEcA5+vZ+Kk4u9iexL1Y0tmHf0Lbg8GueX+0kMXW5Ddlk9phwIhrmWIk4ukU7t0sDhYuWZKFyPfo8bawMQYCk9oVHd2ILFJyPwMKkYN9YGYlgvmpqKa5ox58hbPE4qwc21gZgkRbOWKDS38vD97SSsPReNub7G2D/XA+qEx5YEHC4POx6lYfqhEIx10cetdYGw6YVVrA99+Leij7zpw38tdFXkcHKxN9YOtsLy05H4/VFqj8OBu0KWxcQXo+2xdZITvrudhM+vSl/Z3RVOhqq4u74fWrh8TNgTJFV1b0eoKrDx21RnBFhqYeK+oB5VnS/tZ44d011xMiRXbE13V8iymNg7xwM+5pqYdiCEKBMFAKZ4GGFZf3OsPR9DVOXsb6mJwwu88PXNRNyMEZBnw+x1weHyEWCpidNLfaDwYYAmx2bi2CJv1DZzsZ6AZBlgo42/ZrkRtaWwmAzs+1Ah/h1BhbiXmQYmuBlgzbloiTlHFEVhx3RXZJU14MCrLIn74mSoio+H22DjxRgi8m/rREfEv6/BtSjpc5LaMNpJD06GqvjtkeSsIAaDwnfj7BGeU0EcuisMy/pZIOZdNaLyJFvtRCHAUhMKMkxiG9dMb2NciiCzTvlbaoKmQXzfDbPXxbMUydXrgICkczJUI26d8jJVI1JuAYL8qrI6DvHyRuoKxFldGv8QecMQkXlD0yDOvJHGNlVa2wxtZVliVU9eRSOx8ianrB40DamUOl2RX9mIpKJauJmoES3/PLUUQ+3J8m6ep5ZCT1WO2NZ1OSIfM72NiY5VZmkdSuuaiZUFR95kY6SjHkwJjlVBVSMuR+Zj0zCyIOHDr7OxMMCMKC/mYkQ+yus5WDtYstKlpqkVX91MwDfjHIjUQvtfZkNZlkUUIlxU04TNV+Lw82QnIivPT/eS0dTCw7bJzhLPT1pxHTZejMX2aS4SW9n4fBqfXIlDK4/GX7PcJdp73mZXYNOlWHw11kFijXdzKw8rzkSCooDD8yWrf0TheFA2Tobk4swyX6Lg6tLaZsw8FAZNJVmcWOxNnDUTlVeJb24mYqyzAXbNdJPKAvS+uglTD4SgsYWLG2sCYa4lvS0ppagWE/YGQ4bJwK1eWptep5dh7O43MNFUwK11gf9IDk1qcS0m7g1GbH417m3ojykeZM8KUsTnV2PmoTC8SCvFjTWB2DDUusdkXx/68G9H35Xdh/9qUBSFeX6muLehP3LKGzB29xvEE1oUSDDcQRf3N/RHdnk9JuwNRmpx78LR1BRkcGKRoJVgyv7gHqt6WEwGvp/giE9H2mHxiQhcCJe+lny0sz4+Hm6DP5+k4+d7ycR2LiaDwrbJTpjiYYTpB0OI7VfjXAzw1yw3fHQplmhQHWilJfBK30jArdj30FOVw/U1ATiywKvbi5OSLAunFnvjXWUjPiVolRrhqEcsk26rEH+cXIJjQZKDcGf7mGCMsx5WnI6SSPipyrOxf64H9r3IJFKPLe1nDjNNRXxzU3K2jpqCDP6Y7oIdj9N6VDUPCO6vrRMdcSP6PZHix8NUAxqKsthOQPaIgrqiDBYF9K55qu25cDwol0h5NMHVABkl9UguktyOxmRQGOeij9uxZMTQQFttZJbWE+dM+VtqIiSLjBhyMlTDy/QyImWUqjwbw+x1iAlXI3V5FBAqgDQUZVDV2NpjS2gbRClveDRNnAvR0EJumyqt40BLiiaogqpG4orspKJaeJmq99gGAgCh2RVwNVJrJ6rFoaS2GclFtRhoQ0be3I0nt0xlltYj/n0NJhG26ZwKyYOjgSpRy1ZZHQeXI/OxeqDkwFwA2PMsE6Oc9GBDMOB8mlKK4MwyrB0kmYypqOfgt4ep+GGCI5F1ZNu9FNjqqWCap2TFQmx+NQ68ysQnI20lkhRcHh8bLsRgpIMeUaDx9egC5FU04tB8T4nbrmxowbLTEVjazxzjXCTn1ux8ko74ghocXegl8ZgkFdZg2elIfDvOQWIodAuXj7XnolHP4eLYIsktVKKw+1kG9jzPxL45HnAjCMXOq2jA1IMhcDZSxYG5HsSE0cPEYsw/Fo7hjnpSZfLQNI07ce8xfvcbeJiqEwU3C8PtuEJMOxCCaZ5GODzfkyhEWxi4PD52PErDqrNR+GK0HXZMdyV6togDn0/jWFAOJu8LwUhHXVxZ5U/8jCQBh8vD9oepmHE4FBNc9XFzbSDse5kj1oc+/NvRR9704X8C5lqK2D3LHZPdDTHjUCh2P8uQqMAghYGaPC4s98MYJz1M2R+Cc2/zetWqw2BQ+Gi4DfbMccc3NxPxw50ktPZwX+f4muD4Im9sf5iK728nSf2dPU3VcX1NIJ4kl2D9hRhi5RJFUfhkpC3WDbHGtvspxHXIIxz1cHC+J764Fo8rkZKVDv2stXBwnie+vJ6Ae/GF8DARPRhSU5DB6aU+iM2vxje3JJMb0qCtQvzPJ2QV4t+Oc4SSHAufXo2XuB9Ohqr4brwD9r3IlKhYYTAo/DHDFUEZ5bgeLZn4G2Cjg4E2OviMYD9EwVRTEWsGWeKrG4lE19fno+3wIKFYqkylrljW3xwx76oRSRB0LQqT3Q1RWteMUAIiRFmOjWmeRrhEGFw83lUfDxKLiELNVeTY8DHXILZOBXwgb0jOl4aiDEw0FIgzdVp4NFIJc2/s9JWJ7Z3qCmyoyrNR09Q79Q2DQYlsmyKdxK1rJlfe1HNa4UiYScPj08gpb4CJBhnpm1pcR6T2EIewrAriFpsXqaVwN1YjsoDUc7h4nlpKFMgLCAiCeb4mRBaImqZWXIsuwOIAsuDhE8E58LfQJGrlyi1vwI3Y99g41Frisq08Pn65n4JNw2ygQmBv+fVBKnzMNTCUwIoSmlWOpykl2DZZsl2qsYWLjy7FYsNQa6Imo11PM1Dd2IrvJzhKXDapsAZf30zE4kDJyqIWLh+rzkbB2VCV6PidCcvDw6RinFjkDS0JmVB5FQ1YeDwCqwdZYpYEtZWgpSkeoICTi3161LJE0zR2PErD6dBcXFjhR3RcUwprMe1gKEY46GH7VBdiUvV0aC4+vhyLnTPcJIZv8/g0kgprcCI4B0tORsDm6wdYfyEW41wN8PMkJ6mVIm1ky1c3ErB7tjs2DLXucb5NaW0zProch4dJxbi5NhDTvciyq8ShpLYZC0+E40RwDs4s9cHHI2z/UTVMXH41xu0OwuuMMtxcG4gl/Sz61DZ9+J9A31Xeh/8ZsJgMrBtijaurAnAnrhDTDoYiu4xslplk2x+PsMXRBV7Y9TQD687H9HqgMsROF3fW90NYdiXWn4/pcf25v6Umbq3th+DMciw+GUE0C98R5h8yfgprmjDv6FtiWwUgUILM8jbG8tORxO1fA220cXShF76/nUQUKjvARhv753rgp3spuBcv/jN0lOVwdpkvUopqsfNJ+j9K4LgYqWHXLHf8eDdZorpLhsXA/rkeiH1Xjf0vJVuiZngZw0BNHusvREsk8nSU5bBjuiu+u51EFKj99Th75JQ3EAUpi8KKgYIa75MhuRKXNVSTx7L+5th6N7nHx19NQQaLA83w55OeZ9/IsZmY7WOC48G5RMtPdDPAjZj3RASmh4k6VOXZCCYkLQWV4WTWKTcTNdRzWokVMm7GasREmY2OEtIJ7Zpq8jJIKiRTGirKslDP4aJSymdPVxiqyYHVZXBC0zRcDdWIJfgsBgUVQuVNXkUT8XYLq5tA04CxOhkhk1zYu5pwmqYRll0h0X7ShmeppRhCaJl6mlwMcy1FIrtEK4+Py5H5RO09AHAlMh/2+ioSLTmAoJL7TGge1hDYlADgREgulgSaEVmJzr99BwaDIrJuReRW4l5CEb4bLznTpYHDxSdX4vHxcBsYEVwLP99LgbaSLFYOkKwsCsoow/HgHOyb6yFRjVLd2IJVZ6OwaqAlBtmKPzc0TePbW4lo4HCxY7qrRALgWUoJtt1LwS9TnGEpwZ5TWtuMecfeYqKbgUT1FJ9P49Or8Uh4X4Pfp7n2qCGJpmn88iAVlyPzcXGFP1HTU1ReJdZfiMGSQDN8PdaeiADh82n88iAFfz5Jx5mlvkLVRBwuD5G5ldj/IhMzD4XC8duHmLg3GL89TMXz1FK08mioybOJw687orKhBQtPhCOlqBa31gYSkYqiEJRRjjG730BNno3b6wKJVGuS8CipGKvORkFbSRb3N/YnsqyRormVh98epmLm4VDB7/KaQKkbvfrQh/9k9JE3ffifg5OhKu6s7ydogNgThDOhZNYJEgRYaeHBxv5gMoDpB8MQQ2AlEQdTTUVcXx0APRVZjN0ThPCcnikNTDQVcH1NAGRZTGy6FCM1aaX5oUpcS0kWUw6EIK+CvGVrsocR9s11xydX4nDuLVnDT4ClFk4t8cFvD1OJrEiDbHWwbbIzPrkShwcSSCJDNXn8McMNF8Lzse+F5HYmaTDcQRcL/c2w9FSkxApxLSVZHJrviX0vMiWqLiiKwo8TnVDXzMX2h5ItR4PtdDDdywgbLsZIVH8oy7GxfZoLfr2fItV57QhZFhM/TXTCn0/SUVgt2f6zaqClIIRUAtkmDksCzdDQwuvxPQEA8/1N8Tq9jOh7e5qqQ0dFjiiTiaIoTHQzxA1C2+Mwe128zakgbrTyNtMgtk5JE1psoyddXThpYDFFUf9IaHF5fUs3qyFNA7EF1WASkyzNxFaA0rpm6BDUOwOCsGIjdXniGfuUotpeyfvfVTairJ4DD4KGpOZWHoIyyjGEkGC5H19MPPP+PLUUsiwmAgkCVnl8GqdD87A40Ixo22fD8mCnrwxvgoFfRkkdLoS/Iwo1rmlqxa6n6dgyxk7i+Wrl8fH1jUSsH2JNRMZsf5gKI3V5IlLoRWopbscW4o8ZrhJtf6V1zfj+dhJ+muQkcXDN59PYdCkWtrrKWEdAfJ0Ny8Oz1FIcXegl8d6IL6jGhgsx2DHdVeJ5qWlqxYLj4fA21cBXY8TXsNM0ja9uJiAuvxpnl/kShwR33cYPd5JxN64Ql1f6E+W+vEovw4Jj4VgYYIrVg6yISBQOl4ePLsfifkIRrq0O6NTeFZdfjR2P0jB+TxAcv32EOUfe4q9nGXibU4lmLh9cPo3mVsFvMptJ4csxdlITN4nvazB+TxBU5Nj4a7Y7cYV5V/D4NHY+SceKM5H4bKQdtk507LVNqoHDxRfX4vHplTgs7WeOnTPdoNJDG5cwxOZXY/yeIARllOPW2n5YN6Qv26YP/3vou+L78D8JOTYT34xzwNEFXjjwMgubLsb2KkS1I7SUZLFrpjumeRpi9pEwHHqV1ausB3kZJr6b4IgNQ62x8Hg4jgfl9IhsUpZj49B8T9joKmPSvmC8ySiTan05NhP75npgiJ0OpuwPQZwU2UFD7HQFZMyDVPxyPwWtElqfAEG477llvrgeXYCDBIG9g+10sHeOOz6+HCdxgG2upYizy3xwNCgHJ4Ilk0PSYFl/8gpxJ0NV/DbVBZsuxiJTwqC5rcr9Yng+HiZKJj2+GG0HUw0FomamQCstTPU0wqdX4olakoQhwErQZLLtvmRySVGWhc9G2eHXBz0PEVdXlMUAa61eNU/pq8pjpJMekWKIoijM8jYmzo8a46yPJ8klREHmJpoK8LPQJLJwAQJykzS0uK0unOSZ0VYXTrKskboCCqubiK8XDUUZVNT3jrxhUhR4XT6O/2FfSd0C9RwulAiVN2V1HKJcFgDIrWgkCtQFgPJ6DkrrOLDrRRNKWHYF3I3VifJAInIroa8mB1uCGfWaxla8TC/DMEKVzuWIfEz3MiJSKzxPLUULl4+RjuIzTwAB4fQ0uQRrCPJoAODPp+mY4WVEZEXb9yITDgYqGCxBkQIAF8PzoaMiS1SBHZ5TiStRBfhtqovE41FRz8GnV+Px7XgHifvM49P46FIsnAxVMdldcs7NrmcZyC1vwB8z3CTux6v0Mvz1LAOH53tKrLXOr2zEkpOR2DjMGmMlWOqaW3n48no8bHSV8ds08cejjXQJyizHueW+xIRpR/D5NLbcSMTTlBJcWkmWq3I3vhCrzkRh2xRnzPc3I/qcmqYWLDoegeyyBlxfHdiNOPnyegL2v8xEwvsacPk0Wnh8cERMoMgwGUS5RR1xI6YAMw6FYo6vCfbP9eiRrQwQkIHzj73F3fhCXF8TgBmEYePiEJdfjXF7gpBT3oAHmwYQ5SaRorlV0CS1/FQkJrkb4saaANj2NUn14X8UfeRNH/6nEWClhYcfDYCmkgxG7npNXAcsCQwGhRUDLHFhuR/OhOVhyakIVNRzerw9iqIw388UZ5f54tDrLGy8GNujdismg8KXY+zx3XhHrDgdhZPB0hFBTAaFb8Y54LNRtph1KJQo36UN3mYauLTSH4deZ8P2m4dYeToSN2Pei52NdzFSw+/TXHDkdTZ2Pk6TuK9D7XWxe7Y7ProUi8cS9s1OTwUnF/vgj8fpuEyQr0MKaSvEx7saYO1gK6w+F42aJvFkj7mWIrZPc8GnV+MlWqJkWUxsHGaNkyG5RGHHX4y2Q0ldc6/IrGX9LfA6vQwvUiVbgKa4G0JDUYZIWSUKS/tZIKGgBm970KjWhiWBZrgSWSCRaAMEOTkx76r/P/bOMryNc93aayQzMzMzs+Mwc+IwM3NSSNu0aZK2adowMzMnDrNjZoqZmZktab4fjnvSxJoZye453+7WfV3nx+kejcYzI0XvmvWsxci5Zq0tD11lacbjUHa6ioxcPUBn7k1YdjUj4cRWRwENrR2M6sXNNeRQ09yBSgYii7aSFHgkiTKG45ydocU9FG/YBLi8v3+euk4B04VHYxvzqvCKhjZoMBRv8iqbYMSwJjylpB4GKjJCB4sCQGhWFbwYjky9SC6Dr6kqo3P0LLkUVtryjISosvpWBGZUMArlBYBzITmY7W3I6En5zagCNLdz0c+C3tGTVFSH16nlWD2QPquloLoZ50Ny8f1IG9rzUVLXgp1PUrCivxltpXlLOxdf34rHhiEWtMIBSZLYcj8JbobKjM7d0beZKK5txQ4GbVGvUspw+n02js12pR07yixvxKorMfhhlA2caRxcdc0dmH8uEiPstLDYz4RyWw6Xh1VXYlDR0Ibf/R0orzdJktj1LA1Pk0pxZZEXrYDUHdyPI0wxeTW4sdSbkYB3NSIfX99KwJGZLowFlJK6Fsw+HQFdZWlcW+LVrbB7kEF1O9A5Oj3b24hxKHIHl4efH37A1gfJODLTBSsHMHMJdUdIZiVG7g+ChrwkHq7q0+ORIy6PxOE3mZh6IhST3fRwZbEXdBkWPjAhNr8Gow68R2BGBS4v8sTKAWY9CnoXIeI/HdHdL+K/HgUpcfw4xhY7J9rjx/tJWHM1VuBcGH44Gyjj0Ro/yEqIYcT+94yflvPD1VAZAav9UN7QigmHQ4TO7PF31cOlRZ449CYT391NYhSs+ilT3Q2wb1qnSCLIYt9aWwEj7bTAI4FnyWXYfCcBrttfYMied9j7Ih1xBbVfuJRsdBRxfakXrkUW4LcnqbQCzhAbTeyb5oS11+LwMpl6HMlJXwkn53Tm69Dl5QhCV4V4WR2zCvHFfU2gryKDtddiaRfkI+y1McVNH8svx9C6Vsw05PHDKBusvx5HO7IiIyGG3ZMdsft5Oq0LiB/q8pL4ergVfnyQhJZ26mNjsQj8OMYGZ4NzUCak601RRhzz+xj3qHnK2UAZjnqKjK6/qpwkhtho4kYUfb06QRAY66jDWBAebK2J16nljEKf7XQVYa0tj2QGmTNS4mxYayswCi2WlRSDnrI0Mhhcf3E2C9qKzEenemNsik0Q+Pz0dDlvmLRNkSTZ6bxhWhXe0AYNhd533iQX1zOu4O4OkiTR0MqBDwPxhiRJvEopx0CGmRgP44sxmmFQ8e2YQniZqDIaJ0ovbUBUbg2mudOPY3VweTj2LhsrBpiBxaL/mbr3RTpmeRpCk0El986nqRjnpMMob2hHQAqG2moxyhXa+zL9YxYXvUPnZlQhSuta8etEejEmIqcah99k4dAMZ9r7NreqCeuvx+HXifa0C/La5nYsOh+J2V6GGE/j5mnjdNZ2G6nK4Kcx1KIXj0fim9uJKKxpwam59E1Rh15n4mZUIa4s9hQqwJvD5WHDjTi8Ti3HuQXujFoij77Nwq+PU3B+gQfjrKbU0npMOBwCG20F7Jxozzf03FRdDifnuH2RzfU5XC6JuT70I35Ap1Nv1qlwhGZV4cEqX9oMI77vySNxIjALiy5EYeNQC+yd6sQ4vJ0fhTXNmH4iDLejC3FzqQ9W9Ddj3PxHR2sHF789TsH0k2Hwd9XDneU+sBC5bUSIEIk3IkR0McJeG8/W90VDaweG7QsUeKyIH4rS4jg0wxlrB5tj4bko7Hme1qOmK3V5SVxa6Il+luoYdziYVqDgh6uhMu6v6oP4glrMPi1YEDEADLPVwuVFnjj0OhPbA5hXia8fYvHXiENLBw8kgIzyRhx9m4XJx0Lg8PNzrLwcg/txRX8dk5mGPG4s9UZAfDF+evCB9r2G2Wph71RHrL4aS5sn422qisMzXLDpZjwjxwhT5KXEcWY+swpxNovAvmlOyK9uxh/P0mj3/e0IK8hIsPHj/STabad76MPZQIlRo5SbkQpWDTTFdwybo7pjhocBVGQlGeUJuRupoJ+FOv58Tv8382OhrzGSiusQ1gP3zRR3fRx9l8XIyTLVXR+3ogsZNcCNcdTBu7QKWkcV0CkkirEIROfR52SxWQTkJMURms1MDO5jpsYovBoALDXlkcZQvNNVlkZhDbOKc+VeGJsSY33pvOm6pZmsF9o4PHB5JKOxqQ4uD9VN7YxHOPKqmmCkxjCsuId5N7lVzXifWcmo/ji9rBHVTe3wZtBKVdXYhtCsKoxiMO5AkiRuRhViCsNsnLMhOZjpaQBVmmYioFNAEmMTGElTKQ0AMfk1CM2uwrL+9IG/0Xk1qGlqx8ahlrTbBqZXIDCjAptHWtFuG1dQiwuhufhjkgPtwjW/qhnbApKxZpA5ba5LdVM71lyNxXcjrWCrQx3w3NzOwdILUVjkZ0LrJOng8rDySgzMNeWxieZckCSJXx+lQIxN4MB0Z0rHQ2dYcAoicqtwYYEHrfPnbHAO7scX4/IiT6FyWzq4PKy5Fou00gZcX+pN69rpaqE6HZSNa0u8GGUpAZ1OlcnHOkeVfptoT+v68DVTw9YxthBnd38vsAhgkLUGI5dRfEEt1l6NhaaCFO6s8GEsEH9OZWMb5p6JwIvkMtxa5oPpHgY9HpO6H1eElZdjYKYph4A1fRiFkDMl5qPbJiy7Cg9X9cGK/iK3jQgRXYg+CSJEfIKGvBTOzHPH2sHmWHYxGj/ep3cQMIEgCMz0NMTdlT6IzKvB/LMRKKlj9sS6O8TYLHw30ho7J9rjj+dp2PU0VaisEl0ladxa7g0VWQlMPBqCNIZNM104GyjjzgofvE4txwoGThAAMNeUh7nGl09P2rk8dHA7n4w/SizBt7cT4bLjBcYfDkJrBxdGarK4vtQbb9MqsPlOIu3fO9xOG3umOOK3Jyl4k0Ytygyw0sCfkx3x/d1EhOcILwJ8TleF+KWwPLygGeNSkBLHyTluuByeh/s0QbfibBYOzXBGQU0z7cgXQRDYOdEBSUV1jBqlFvYxQXVzO44HZtNu2x0sFoFfxtvhVFA2o0akdYMt8DChGElFdUK9n6KMOBb4Gvco+2akvTbaOnh4zUC862OmBilxFt7S3FNA55ibpZY8njEYh2KzCAy00sBLASvDmWCqLsfoeIHOCvAihm4aPWVpRuNYQJfzRvjRUaDzHH2umXE/qjdMFiINrZ2jprKS9KMKlY1tIAhAVY4+OJXHI5FXzdx508HlwaEHC53QrCo46ysxGrl4lVoGXzM1Rts+SSqFo74So5GHiJxq1DS3Y6gtvaOnrrkD92KL4c9gRIjHI3H0bRaW9TNltFjb8zwd832NaOuqSZLE9oBkeBqr0jp0Wju4+PF+EjYNtaQV71o7OPjxfmegMV07F4fLw/obcZjookvrnuDxSGy6GQ9nAyXM8qJ2aJAkic13EqEoI4HlDESs7QHJqGpsx76p9Jk4fz5Pw6vUcuyd6kQbZnvsXTbuxhbj4gJPaNCc44uhudjzIh17pjgKlV3SxuFi+aUY5FU1/1WmQAWXR+Lb24mIzqvBzWU+tGJYF/fjirDwfBR+HG2DNYPMGQseU9z1+WZMsQgCS2mat4DO0cFpJ8LQz1Id+6fRn39+hGZVYeT+91CWlcDZ+R49arkDOlvg1l6Lxc8Pk7F6oDl+nWDf46DjLlo7uPj1cQpmnAzDJFd93F7uw6j1ToSI/yZE4o0IEZ9BEJ31oY/X+uFDcT3mn4tg3NZCh5WWAk7PdYOOkgxG7H8vtGumi1EOOjg8wxnPPpRi7pkIocYSZCTEcHiGC2Z46mPS0RBap8rndDViVTa2YcbJMEbZPnN9jCAtTpMh0MGFOIsFeSlxSH7MG9BXkcGNpd6IzKvGxhtxtO6QEfbaWDfYAisvx+BdOrWTapSDNjYOtcSic1G9dr2Bztye70ZYY931ONoKcVN1ORyY7ozNdxKRWEgtZmgrSmNFfzNsffCBdnxGWVYCe6Y64rfHKbRtQlLibOyZ4oiDrzMYjeV0h52uIqZ7GOCHe4m0bh99FRks8O1ZdfiCPsb4UFzPOPD3c8TZLMz2NmQ0AshiEZjpYYArDKvVxzrq4AHD0alB1pp4xTAjx8dMFRE51YwcQE4GSkgqrme0rZmGHGIZ3v8marKMsoIAQEVWssdV4exunDeCBBY3tXEgwWZBUoxeyCivb4OKjASjfJaS+ha4GChBj4Ho0drBxbMPZT2y/wtSEf4mtZxxy1RAAvORqbuxRZjnY8ToXF6Pyoe9niKjBfOLlDLUt3Zgogt9Dkl4ThXiC2uxxI9+IfwwoQSlda1Y3Jd+rOlEYDZkJcVoRRMAOPImCwpS4ljSlzoHBgCOvctCbXM7No+wpt32bEgO0ssasNPfgVYwOBeSi7DsKhya4Ux7v14My8OjhBKcmutGOzJzNSIfl8LycW6+O62IdT0yH0feZOLcfHfazJ8bUQX4/Wkazs33gIOeEuW23dHawcWSC9GoaGzDlUVeUKZxMLVxuFh1JQYx+TXYO9UJxgzCjEmSxLF3Wfj+bhKOzXZl3L4GdDqmZp0OBwESrobKkPjMgWOsJgsXAyW+r2/n8PDj/ST88jgFJ+e4YUlfU6FcMjweiYOvMrDgXCTWDDLHgWlOQgccdxGRU40R+96jprkDT9f5YbCN8BXlnxOdV42Zp8KQUFiHh6v6YHl/ZgKuCBH/bYg+FSJE8MFQVRY3lnpjmK0mpp0IxZ4X6YwWP3TISIjh90kO+HmsLdZdj8O2h8loY9C+xA8zDXncX9UHCtJiGH3gPeKFEB5YLAKL/Uzxm789Vl+NxfF3WQItpJVlJXBpkSe0laSx+U4icmhGNEY7aoND45wRZ7NgpS2Pk3Pc/vbDRUtRCteXeKOisQ0lDLJSRjvoYKe/A5ZfiqYdhfN31cOGoRaYdzYCqaXCCRfdMdROC+sGWzCqEB9gqYE1g8yx9GIUKmmEMD9zdSzta4qVV2JoF9E+pmqY72uENVdjaR1SDnpKWOJngo034wXOQ+piwxAL5FQ24R6DuuwVA8yQXdHEOLD3cxSlxbGwjzEuhTGrou+OGR4GiMmvQUoJ/XUf56yLoMxKFNNcS6DzXg/PqUI5g2BfP3M1FNa2IItBlpWFhjykxdm0giAAGKvKQkqMhdQSemeduQbzxikNBSl8YCjwaSpIQolmjIIOOUmxL8ZSeDwSGvKSYLK0aWrn/K3Wl4qqxjY46jN7Op9X1Yyi2hZIMnC3ZJQ1QlaCDR1FwRt1gM5FZWh2FbwYjEHVNLUjJr+WkXhTXt+KqNwajLSnF2/qWztwL64IQ23ox5o4XB7Oh+Rhvo8R7bYkSeLI2yws9jOhFYVIksSup2lYPcAMijLU91VrBxe/P0nFpmGWtA6BvKomHH2bhR3j7WhHoJKL63HifTY2j7SiFU0SCmtx6E0m9k11ps2Bic2vwcnAHBye4Uw7ehSRU41dT9NwZKYrrcDSweXhVnQhjs12pc0pepNWjm0Pk3FitivMunHKfsqrlDLsepqGk3PdYKdL/Zm5H1eErQ8+4NRcN8afxU9pbudg4flINLVxcGmhB+21b2rjYOG5KBTXtuDGUm9oMfjccXkk/niWhtNBObi2xAv9LNQZH19meQPGHw6GmpwEbizzxbn57tBSlEbX7SEpxsKKAfzFmPKGVsw8FYao3Bo8XNUHfczpA7u7o6qxDXPPRuBWTCFuLvPGLC/DHo1JdXB5+ONZKuaeicAiP2Ocm0cv6DGlpZ2LHQHJmHUqAkNttHBpoYfIbSNCBAUi8UaECArYLALzfU1we7kPniWVwv9oCKNRECaMc9JFwOo+iMitgv/REMaZFN0hJ9npnpnna4RpJ8JwNSJfKBfDaAcdXF/ijbPBudh0M0EgUUlKnI2D05xhoi6LiUeCEZ1XzXdbBSlxDLXR4vu0XIxFQF9ZGhcXenZr91eXl8TlRV6MAw7HOurg1wn2WHoxmrZ5ab6vMRb1McasUxG0IpQgCFIhvrSvCdyMVLDtYTKteLJ6oBn0lKXxzW36TJt1gy1gra2A35/Q13mvGmgOAsDB18KFActLiePH0Ta4H1dMGwAuJymGr4ZZ4NcnKUILmfN9jPE+o0Jo942yrAQmOOviXHAu7bY6StLoY6aGW9H0wcXaitLoa6GOJwyEKVlJMfiYqjJyv7FYBLxMVRGSSf/3slhEZ2U4A6HHTEMOTW0clNXTO+j0lWVQWMss80ZeShxRufy/E5jQzuWh+TPhkSQ7g4WZPKFtaOUwPt7S+jYw1S3zqpphxDSsuKQONjoKQi+ksiubUN/SwSjv5l16Bay05BktWJ8klWCskw6j0N+A+BKYa8gzGr/oalsbwuAJfWhWFfKqmjDdw4B227fpFciuaMQMBu6YM8E5UJYVx0SaYF6SJHHgVQbGO+vSti91cHn46lY8FvuZ0DqKWtq5WHc9DqsGmNHmgtQ1d2DVlVgs8jOGoz71MZTVt2LF5Rh8N8qakRAizmbh7nIf2qyXpKI6rL4Si53+9vCkEQlDs6qw+mosfvd3oBUUnyaV4tvbiTg6y5WR+Pg5jW0cbLmfBB4POL/Ag7atrba5HTNPhYNHkri8mN6hA3QKfcsvRSMypxp3lvvQilGfEphegQlHQjDWUQeHprtAWoINeSlxXF7kCWnxTtFQUoyFUfbdZ0rF5NdgzMEg6CpJ4/ZyH6ECnAEgMqcaIw+8h4KUOAJW9xHob+iOnMqmj67sctxb6Yv5vsa043ZMicrtPNaovBo8XO2LpQzHJUWI+G9G9AkR8a/jSnieUPkvVNjqKOL+Kl94mahizMEgnA3OYRzQS4WRmixuL/eBp7EqRh8Mos06oYIgOuvJT89zw+7nafjmdgKjDJrPsddTxINVvniXXg7LH57C/2gwTgZmIza/hlZIYLEIfDvCGuuHWGD26Qg8SeTf4DPT0wBifJpE5KXEcG2pF+1TR0EY76yLHePtsPhCFEJoBJyVA8zg76qLWafCaZ0yTBGkQpwgCPzub4/cqib8/PAD5X5ZLAL7pjohNr8WZ2mEB3E2C+sGm+NmdCFep1ILBBJiLOye4oiT77OFcnMBnVkyPBLY9YxeLJrkqg95SXHav4EfijLiWNjHBHtfpgs9fjXPxxj34ooYjf5NdTfA9cgCRt8DAyw1BBqdisylDy0GBMu9cdJXQlx+Le12UuJsGKrKMgot1lOWRnFtK6NwaxVZCVQ1tQt9bYCPY1Pcv7+e91fmDf3rG1uZ14SXN7RCnUG4LtDZ8mPIuCa8oUdhxaFZVXAxUGaWd5NShkEMR6YexJfAhUaw6OJ6VAGmMGiNAv6nHpzJguxBfDGW9DWhHechSRK7n6dheX9T2jGQysY2HHmThe9H2tAuOJ8nl+FtWgU2DbWgPdYTgdlo5/CwaqAZ7ba/P02FsowEltHknJAkia9vx8NKSx4L+1CPd7VzeFhxOQb9LNQxy5Ne7OqC7hwU1bZgwblIrBxgRht8nFRUhyUXorB1jC3t+MybtHKsvx6HA9OdBXKydFHf2oE5p8NRXt+G0wxGvsrqWzHleCg0FSRxZp47o3Gh6qZ2zDgZhprmdpyc6yaQeHIhNBdLL0Zj2zhbbBpm+bfzrK8ig3Pz3cFmEZjnY9Rt7fyt6ALMPROBpX1NsXeqE607qzt4Hyu7N92Kx6oBZjg0w5lW4KKCJElci8jH2muxcDNSwb2VvkLlE3VHSzsX2wOSMft0BKZ7dGbb0Dm8hKGR4VivCBH/SYjEGxH/Ou7GFmPi0ZBeHXsBOhc13420xrn57jgdlIPZZ8IZjU3QISnGxpbRNtg/zQnH32Vj850ENLdzhN6fj6kaAlb7obCmBcsuRaOgmtmT5k/RUJDCuXnuAIDovFrsepqKKcdDYfPjU4w++B6/P03Fm9Ryvi06c7yNsH+aMzbdjMep99ndLti8TFShIP33H1QEAUiJsyAlzkJ8gXABtlRMdNHDtnGdAk4oRW07QRD4drgV+luqY9apcFQ09CxotYuuCvHyevoKcWkJMRyd5YqnSaW040CqcpI4NMMFfzxLo20rMlSV7fyBeTOBdpTHWlsBqweaY+PNeKGEQIIgsG2sLW7HFNLmCLFZBH4YbY3DrzOFPt/z+xghtaQeoUI2T1lqycPdSAVXI+jzbAZZa6CNw0MwxX3UxUh7bSQU1jJqZhpspYFXKWWM2t98TNUQnV/D6No46ikhroCZKGShKceoLlz7o6OjlMFImKqsBNo4PDT3IACeTRB/BRR30aWdsRioN03tHMgzaJoCgAoBasLzKgVw3vSwJpxp3g2Hy0NkbjWjivCi2hbEF9RiBIN2p7TSBqSW1GOsI30jVUpJPeIKahnVg8cV1OJBfDGmu9MLEc8+lKK8vg1zvI1ot937Ih3epqq056y5nYNtD5Px9XBL2kaszPIGHHqdiV2THGjHu96mlSMksxJ7JjvSClgXQvMQX1CHPyY70jqzjrzNRGsHF79MsOtxa1AXdS3tWHYxGoNtNLGsH3WGT05lE+adjcDKgWa0Ql5oViW+vpmAPyY7MHJgfU5tcztmnQqHonRnqL8MbWV6I6afCIOjnhIOz3BhJHTmVzVj0tEQaCpI4eJCTyjJ0Lt0AKCD0xluvf9lBi4t8sAE5+5Dud2MVPB4jR9WDPi72NfG4WLznUT89jgVp+e6Y0EfY6GuZ3VTO+afi8T1yAIcmu6C2d5GPbovqpvasfRiNHa/SMemoZbYMtqG0XlkQlRep9smNr8GD1f3wZK+pr1WL94FSZJ4kliC6SfDenW/IkT8/4BIvBHxr+PiQg/4mKpi/OFg7HmR3qM8me7wNFHFk7V+0FWSxqLzUbgTU9Cjp8ldDLLWxOm5bsiqaMLYQ8E9Ep+0FKVwbr4HDFRkMOZQEG1Yb3fY6SnB7+O8dQePRAeXBIdHIqmoHicDs7H8cgwcf34Ov99f4+tb8bgbW/i3wOQhNpq4stgLx95l4eeHyV+4oViszgYuyU+eQkmKsXBnuS9+GmOHNVdjcZOmSUkYJrnq4aextvj9aRrCKRb5BEFg+zg7OOkrYeH5SNQKEQbdHfJS4jg9j1mFuK6SNI7MdMEvj1IQkUM9cuJqqIxNwyyx9losrXNkoose+pqrYePNeFrnyNK+JrDXVcS+F8K1ORmpyWJ5PzN8fzeR1qHhY6qGCS66OPaOvma8OxSkxLHIzwT7XmT0IPzYCDH5tbQuM3E2C5Nc9XAtkv4eVZGVgI+pGh7G83eidaGtJA1rbQW8TacPLjZSlYGPqSpiGThqnAyUOkduGDyJtNCUZ9Q8J8ZmQVtRCoUM2qkUpcXBZhFChap3wWYTX3yPkH8FFtP/+G9s49A+se+ivKENGvKCOG+YhaCm9KAmnCRJlNW3wtOEvuI4Oq8GHVwSDgxGJh4lFMPbVJVRjff1yAKMtNdm5Iq8GVWACc66jBbCR95kYoaHAe1oC5dHYvfzdKweaEa7mEwvbcDr1HJsHkFf933wdSY0FSQx2ZVaiODySHx9KwGzvAxoR6uqm9rx1a0ELPIzgSFNSG5SUR12PknFgenOtBXit6MLcS4kF8dmMRMmmNDO4WH5pRhYaslj21hbyoV/WX0rZp8Ox0QXPVo3UVRuNRZfiMb3o6wxmkEF/ed0umHCoaUghWOzXWn/3pSSekw6GobxzrrYNcmBkeMrobAWE48Go5+lOmOxBwDqWjqw8HwUyuvbcG+lL1wNqT+Xllryf9t3WX0rpp0Iw4fiOjxc3Qcexsyqyz8nMrcaI/e/h4wEu1cquwPTKzB8XyAA4Nm6vugrhFOqO1raufj54QesvxaHmZ4GuLnMB2YaglfE01FQ3YyF56Pw/b0kLO9H74wTIeI/DZF4I+Jfh5Q4G98Mt8KtZT54lVKGUQeCaN0IgiIvJY5dkxyxYag5fnmUilVXYhk9KadDW0kaVxZ5YqS9NiYeCcHl8DyhF6ESYixsG2eHH0fbYPmlaBx8lSHwqNfKAWYQZ3/5I47DI/962l9Q04KbUYXYcD0eu57+fTzGUV8Jd1f4IjCjAssuRaO57e+Oosluen+FQIuzCVxY4AkbHQUMt9PC6XlunYGJgVkCHTMTprjpY5q7Phaej0IkRQ4Hi0Xgj0kOsNNVxLxzkWhsE94R9SldFeJ3YgrxjKZC3NNEFd+PssbyS9G0I1wLfI3Qz0Id62/QizLbxtsht6oJZ2galsTYLKwcYIbzoXmU54qKZf1N0NzOxUUGgcILfI1xKSyfUXBwd8zzNUJaWYPQ2Tf9LTSQU9mEJ0n0QstUd328+FDGaMxKkNapwdaaeJlML94QBAEVWQnaHCcAUJOThK6SNKMROAtNeaQzzPbqrAundxSxWASUZcRR1RPxhvhSvPkf5w396xtbOYzbVsob2qDOQLwhSfJj5g39iEVhTQtaOrgw1xRuwZJV0YjEojpGeTevU8sxwEqDUTZFQEIJxjBYWLdxuLgbW4gpDJp3qpvacTk8D3MZuGMyyhrwLr0Ci/zoG5sexBehuZ2LqQwcOr88TsEIOy2YqFOf78zyRpwJysH28Xa05+t8SC6qm9qxYYgl5XYkSeK7O4lw1lfCZDfqivSG1g6suhKDlQNMaRfwSUV12HI/CQemOUNfhZnbiw6SJPHtnQTUt3bg57G2lIJHXXMH5pyOgKexKq0ollBYi/nnIrF5pBXG0+QNdUdFQxumnQiFsbosDs90oXU5RedVY+rxUMz3NcLqgWaMnCdvUssx/UQYlvUzxU9jbBlnueRVNWHikWCwWQT+mOwgcD5NVG41Rh8Mgqm6HG4s9YYOg6a6z+HxSBx9m4U5pyOwrJ8Jjsx0gUIPxqRaO7jY9jAZyy9FY8MQCxyf7UorJDIlIqcaw/cHIqGwDucWeGCRn0mvu206uDwce5eFYfsCoSYngVcb+mEkw/Y8ESL+kxCJNyL+tdjpKuLeSl/4u+hh1qlw7HiUjKZeWnx3MdhaC8/W90U7l4eh+wLxJo1ZzS8VYmwWNgyxwKm5btj/MgOrrsTyHU9iwkQXPdxa5oPrkflw2f4ch95kILGwjlGLkKexCqMfJQQBqMpJ4KthX/6g1VeRwZ3lPpAWZ2POmYi/NSjpKcvASV8JBAEcnen6tx+uPqZquLrEC8ffZeO3Jym94m76lGkeBvhupDXmn42kDFcWY7Pw0xgbyEuJYdH5SKHGh7rDQU8JawdbYAODCvFZXoYYaquFpRej0EIxdkIQBL4ZYYX8qiYcekPtXlGQEse+qc7Y/TwdSUXUI2pmGnLYONQCG2/EC/UZkhRjY9s4W+x+no4ymhEbIzVZzPE2xI5HwlWHK0iJY1EfY6Gzb1gsAnO9DXEmKIf29cZqsnA2UEJAAr3QM9RWE9kVjcgsp3e0DLHRxLv0CkafUR9TNYQwGN0CAC8TFcTl0wvZFpryyChrYCT26inLMHLeAJ0OpJ6I3GKs7sSbrswbBmNTbczFm8qGNkZtKhUNbWjlcBl9T6aVNsBOV5FRvXZ3hGZVwdVQmdHrX6WWM8q7ya1sQkpJPYbZ0o9MvUoph4K0OLwYOH+uRebDxUAFVgxcRkffZmGiix5tsHIHl4d9LzOwdrB5t7khn/I2rRxxBbVYM8iccjuSJPHj/SRM9zCgDR7Or2rG+ZAc7PR3oM0kuR1ThKi8Gvw20Z7y3iRJEr88SoGesgyW96d2CdQ2t2PZpWisHGDWa24IANj7MgPh2dU4M9ed0pnW3MbB4gtR0FeRxu/+1H9XSkk95pyJwLrBFpjpSR8q/Tmlda2YeiIUtjqK2D/VibbN621aOeacjsDXw62wcgAz4eZGZAF+uJeEnf4OjITDLsKzqzD+cDD6WWjg1Fx3gXJlSJLExbA8zD4dgTUDzfDHJAeh3FPVjW1YeD4SVyLycG2JF+b5Cjdu1UVaaWdLVnReNQLW+GGah0GvjOM1t3Ow9cEHzD0Tgdlehrix1BumNGKqMMTkV2PMwaBOV9p8D+ya5MgooFqEiP9EROKNiH814mwWlvc3xaM1fVDX3IGhewOFGiGiQk1OEidmu+KrYZZYfSUW391N7BWRyMdUDY/X+qGxjYNRH+eDhcVGRwF3V/qiroWDP5+lY/yRYFj/+BSDdr/FN7cTcD0yH8nF9V9UoRMEgVUDzP422tQd4mwWLi3y5Gu7V5KRwK5JDtBWksbEIyF/q0LeNs4OZ+a6dRt4aKeriJvLvBEQX4Jvb9OP3QjKDE8DfDvCCvPORCKG4vxKirFxfLYrOrgkVlyOEbo++3OG2Wph/RBmFeI/j7WFlBibtlVKQUoch2e64OjbLFpHhquhMlb0N8Waq7FoaqMWCBf4GkNLUQo7GTRVdYefuTr6W6pje0Ay7barBpojpaQBr1KEE0Pn+RohvayRcZjv50xy00d2RRNiGIwjzfQ0wMUweoecvJQ4Blpp4EEcvfvGVkcBcpJiCM+hP35vU1XEF9YxcoVZaSkgvpDe0WSkKgMrLXlGzUx6ytICiTc9cd6wWAQ43Yg3TB/gNjAUb0iS7My8YeC8yatqhoGKDKMFWGJRHUxoxmeoCMuuhpcxfd5NXlUT8qqaGNUMP0osgZ+5Om3lMtBZ8zzPhz5Lg8Pl4WJoHub7GtHus6C6GQGJJbQZKwDwIK4YekrStK1RHC4Pvz5OwZpB5rQjWw/ii5FR3ogNNCHFJEli890E+Jqr0zYlFVQ34+cHH7Brkj3tKNr1yAKEZldh9xRHSicCl0dizbU42GgrYDnNqJIg3IgswLngHJyb7w4NiqaxDi4Pq67GQk9ZGodmuFC6czLLGzH7dDgW+5nQBi93R1FtC7Y++ABXA2X8ySAr6GF8MZZfisFOfwfMYtA+RpIk9rxIx45Hydg9xRFjGOQ3dXEjqgDzzkbiq2FW+HGMjUDukdaOznyb/S8zcH6Bh9C5NNF51Zh7NhLyUuIIWO0HRwZOPH7weCTOBOXg61vxGGytiVvLfWDcg++oTwnPrsKI/e+RVFSHR2v6/CNum7rmDmy+k4iZJyMwzd0Aj9b4CT1+JkLEfwoi8UbEfwUm6nL43d8By/ubYtXlGGy4HtcrY05dEASBKW76eLLWD5nljRh54H2vjGqpyUni7Dx3zPE2xNe3EnDiXZbQLVfq8lL4epglCKLzhyCXRyKrogk3Iguw9UEyxh4KgvWWpxi2NxDf303ErehCZFU0YrSDDuXCRIxF4NAMF1hpUT9hlRJnY/9UJ4y014b/0ZC/RnDsdBUxwIp/iKGJuhxuL/dBTH4NvrolXIMWFbO8DPHVcEvMPRNBGaorIyGGM/PcUVbfivU34nqt0WxhH2MMs6WvEJcQY+HoLFdUNrbhdFA25T5tdRSxdawN1l6LpXW6rBhgBjdDZWwLSKHcjsUi8OckR9yJKcT7DOEE0C2jbRCeU42QLOrXK0qLY/0QC/zyOEUooUxeShyrBpjidkyhUO4bOUkxTHHXpx0pA4Chtloor2+lFP+66Bqd4vGo/yaCIDDIWoOReKWrJA19ZWlE0mQiAR8bpwpqac+JpDgbjW0cZJTRj06ZqsuincvsM6kqK4ma5p45bz7//uPxmOXdAJ3OGyaZN7XNHTDXlIOaHP2T25yqJugwqOIG0OO8G6Zhxa9Ty+FhrMLIEfAwvhhjHOlHC4prW/A6tRwj7Oi3fZ5cBjaLwCAGYckn32djuK0WbWZQawcXfz5Pw1QPA9rF/I2oQrRzeJhNs5Cvb2nHL49S8MMoa9pxk+uRBciuaKIdFeLySGy4EYexTjoYSPHvGtDpdtgWkIxfJ9jTVrTvfZGOwupm7J7i2Gs1zYHpFfjpwQccn+0Gc03+TT88HolvbiWguLYFP421pfw9kFfVhJmnwjDN3QArBwieN1JQ3Yypx0OhIiuO3/3taRf7l8Pz8O3tBByZ5cJIhOng8vD1rQTciirAreU+jCvLuTwSvz1OwS+PUnB6rhtmCNDwBXR+fqYeD0U7h4cAIfNtSJLEicAszDoVgQnOutg/zalHjZzl9a2Ydy4Sp4Ny8P0oG2waZknrcGJCczsHe56nY/65SMzxNsL1pd60o4uCQpIk7scVYdCetyiubcGzdX0xz7f7Ji8RIv5tiO5yEf81sFgEZnkZ4vmGvqhv7cDgPe/wML64V8dx9FVkcHWxF2Z6GmDznUT8+Sy1xy4NFquzAvyPSQ64EJaH+eci/zZ6JAhzfIwg/dkPLxJASwcXHF5nIHFaWQOuhOfjuzuJGLonEK0cLhb2Mebrvhlhr8W4QaKzStwKm4ZaYuapMMw5HY600gbaa6ClKIWby7zR2sHBvLMRlCKHMMzxNsLGIRaYfTqcMhNEUVocFxZ4IK20AZvvJPRKXTxBENg6xhZaDCrE1eUlsXmENfa8yMBbmhG9KW766GehgVVXYr5wVH0Km0Vg3RALPE0qxWOKancAMFCVweaR1vj6VgKj4NvP0VSQwqoBZvjuThKtCDfdXR/ibIJRTk53TPMwwOvUcgRnCue+medjhBcfymgb5aTE2ZjgrItrEfTBxQMs1SHGJpBUTO9+GWytiZcpZYy+n7wZjk7Z6iiiprmd1uUFAOaa8ozqwjXkpRCTV0u7HQAoy4gL/d0FdLrKPs9g4JE8uBsxq7hmswioMhBkKhrbkFvZBDkG4kdeVROM1JgtTJJL6mGjI5x4k1HeiKZ2Dhz0lGi3fZ1aTiscAJ1ZMwpSYozGq25FF6KPmRrtaBMAnA3OwVxvI9qFd0VDG25EFWB5f3onyZXwfChKi2O0PbV41NDagT0v0rB5pDXtQm7/qwwMsNKgbc4qrWvFL49T8OsEe1pB7ERgNiob2/H9KGvK7ZrbOVh5JQaL+hjD14zaIfXsQynOheTi+GzXHlU/f0pycT1WXo7BbxPtKQVBkiTx6+MUROXV4MICD0qxoKi2GXPORGC0gw42Mqhb/5ycyiZMOR6Kwdaa+GWCPVgs/tePJEmcD8nBrqdpOL/AAwMs6e/h0vpWzDsbgcSiOtxd6QsLCsHqU5raOPjpQRKeJ5fh7gof+NBcr88Jy67CmINBsNFRwG/+9ow+Q59T29yOxReicD4kD1eXeAndStXF8w+lGL7/PVRkxPFkXe+5VUKzqjB833t8KK7DozV+WNjHuNfdNrmVTZh9OgI7HqVg61hbnJvvDgMGmWMiRPxbEIk3Iv7r0FaUxsk5btg61hZbH3zA4gtRKKnreeV3F+yPYsuBaU54lVqBCUeCkc5gEUSHk4EyHq3xg5ykGEbuf48QBiGlnyMrKUYpxHRBojPHZt0QcyhIiWOWl+EXThNJMRY8jFTwOqUMu56mCiRkzPIyxGh7bQRmVGL4vkA4bH2OpReicDUiH/lVzd0uWJVkJLB7ihMkxdiYfjKsR4vA7pjna4z1gy2w62kqEgv5Z8Coykni0kJPhGZXCZ3L8jlibBYOMawQt9dTxK8T7LHmaixyKpv4bkcQBHaMt0N9Cwd/PkujfH8dJWnsnGiPb28n0C7sZ3oawExDDtse0o8/8Xu9rKQYjr+jdg+JsVn4YZQN9r9MF8olJy8ljsV+JkJn3+iryKC/pTouhNKLR1PdDRCQUEIrKkpJiMFBVwkPGQQXe5uqoqqxHakl9N8dPqaqjEbEpCXYsNKSR3wBdcYRAFhqyjNy3uipyKCkroVSIOxCRU4S1Y3CO29aOVyU1P3dScYjgVgGIcwAUFTbyujJcnk9s7BiAMhlGFZc19KBwpoWoZ03YdlVcDNUoRUkGts4CM+uZiTIBCSUQFlWAgrS1IIWj0fiZnQBpjKo/E4qqkNSUT2jUOMLIbmY7KpPe06a2zk48jYTG4da0rpOjr7Ngqm6HIbSPFBIKanH5fB8LPajXgSTJIkf7iVisLUmBtCc06SiOlyPzMfeKY6QkaB2eP10/wNUZCVoM3myKhpxKTQPv/s7ULpjBKGkrgW7nqZiWX9T2iDho++ycC+uGBcXelCOVZXXt2LmyXCMdtDGD6OsBRYWMssbMOV4KMY66uCnMTa01+S3J6k4+DoL15d4wc2oe+GBw+UhNr8GB19nYMied/D69RWSiupwc5k3rdOpi+LaFkw6ForC6hbcXeEjkIOEJEmcDc7B/LOR2DjUEr9NpK+W746Y/BqMOhAEgMCjNX0YBZbzo7mdg813ErHxZjx+GmODfdOcexRy3EVTGwc/3k/CwvORmO9rhJNz3Hpt/KqLNg4XB15lYPj+QJioy+LVxn4Y7aDTK9k8IkT8JyESb0T8V0IQBMY46uDlhn5QkBbHuEPBuBye1ytOii6stBVwb6UP+lqoY9yhYJx6n93j/StKi+PQDGesG9yZk7L7eZrAOTALfI1Bt5aVYBPwNlHFqo+2ZxVZCYx31oXYxx/OYiwCxmqyuLDQA/dX+eFxYgmWXooWqI3pN38HSImxQKIzi+JZchm2PUxG/z/fwG3HS6y/Hod7sUUo/2TsR0ZCDCfnuMFETQ6Tj4UyarkRhAV9jDHASgOzTodThvhqKUrhyiIv5FQ2Ya+QFdqf01UhHphRgUs0bpPxzrqY6q6PxReiKAUDaQk2jsxywfXIAlqnzgh7bYxy0Ma6a7GUI2EEQeB3fweU1bfiZTJ1U1Z3iLFZ+GWCPY6+y0QuhfgEAH0t1OFmpIJzIfTjS90xx9sQWRWNCBJC6AQ674erEfmUIdFAZ6aUuaYcozapMU46CEgoof0ukBJnY4yjNl6lltHu08tEFSkl9YxErs7RKWahxUzqwrUUpMAiCJTUUo/nAYCqrETPqsJZrG7bpnp7bKq8oZVRWDHQ6bxhUhOeWlIPLQUpodtbmI5MBWdWYIClOoxoFk4kSSIgoZhRfXNYdhWa27iM3DznQnIx0UWXNkOnrqUDZ0NyGbUQnQvJha6yDAZbU4snhTXNOBOcgy2jqRf/PB6JH+4lYZ6PMcw0qAWRB/HFiCuoxY+jbSi3a+3gYv31OExw1oMTTYX4nZhCvEwpw4FpzpQjYI1tHCy7GA0bHQWM6qXWnPrWDsw/GwltJSmsoHE8XYvIx9G3WTi/wJ3yHq9qbMPMU+FwMVTGxiGWAi+mU0vrMfV4GKa76+PbEVaUr+dwefjmdgIeJ5bg1jLvvwVikySJ7IpGXAzNxdwzEbDb+gxTjodi/8sMZHxszzs+y42xeymuoBbjDgfDSV8RJ+e6Maq876K1g4uNN+Jx9G0WLi3yFHjMquvvOfU+GzNPhn8URFwFOobPSSisxegDQcgqb8STtX4Y5yR4A1h3hGRVYvj+QKSWNuDxGj/M9zXutdG+LkKzqrD8YjSefSjFtSXe2DbOrldEJxEi/hMRiTci/qtRlpXAnilO2DPFCUfeZGHayTBkVzCryGWCpFhnbfnFhR64EJqHGafCUFjTM8GBIAjM8DTA3ZU+eJJUihknw2lHOz5FWVYCMzwNIMHnRyOL6HSXHJjh/LcfUUv7mvwl+shLieHCAg9IibNhpiGHeyt90dzOwaSjIYwFFUkxNub4GP0lCAGd41s8Eqhqase92CJsvpsIz19fwXfnK3x/NxFppQ2QEGNh31Qn9DVXw6RjIYwWmIKwyM8EKweYYtbpcHwo5i/g6KvI4LuR1rgUno/j73qnzlxXSRqHp7tg55NUPE2iFka+GW4FbUUprL9OXQtuqi6HXybYYc3VWORXUV+bLaNtUN3UjkOvqZuqdJSkMc5JF9/eSRLKFeOkrwR/Fz38SOMyAoDvR1rh2LtsZAjhXuty3+x7mSGU+8bTWAV+5mp4mFBEu+00dwNcj6QfnepjpobWDi6j2nU3QxW8ZJB7oy4vCQc9JURRtKZ10ZV7Q4eFphwyKxpps53YLAI6StIoYPC91tPAYjaBLwKLSZJkLN50VoXTP/muEKQmvLIZRmr0zpvOvBvhnBM8Hg/h2dWMWp5epZQzar5KLW1AcW0rBtEIIgBwPaoAE5x1aV0/lY2tiMmrwTwfI9p9XgzNha2OAlwNqYWOupYOHH+XjU1DLWhFgX0vMzDPxwh2utStUbdiClFS24I1g6gzWaoa2/Dzw2T8PNaOtrlm19M0yEqKYeUAakEkq6IRW+4lYc8UJ8rxGZIk8fWteKjLS3bb4igMHVweVlyKgaaCFLaPs6M8n0+TSrEtIBkn57hRtnDVNXdg9ukIWGjKY5e/g8CL9qSiOkw/EYZ5PkbYMJRa+GnjcLHqSixi82txa5kPjNRkUdHQhvtxRVh3LRau219i8J53+PVxCt6lV6C1g4cOLvnXd4apuiy8GAigQGcW1IyTnRXiv06wFygLpqC6Gf5HQ5BX3YyA1X1o7/HuqGvuwIYbcbgVXYjLiz2xyM9EaIcJl0fi8JtMbLmfBH9XPVxd4gU95Z6PGTW1cbDlXhIWnY/CQl9jXFvsRSsaC0pVYxs23IjDovOR8DFTw70Vvj1yHokQ8W9AJN6IEAGgj7kanq/vCxttBYw6EIQjbzMZjQEwxc1IBU/W+sFYTRYj9r3HrWjhglQ/xUpLAQ9W+cJYTRZLLkThRTL9E/oulvUz/atitzuOzHT54qmGuaY8XI2UIcYicGGB598s1EoyEjg33wMexioYdziY0cIUAGZ7GfI9DhJASzsXJDrHHS6H5yPoY1Aui0Vg61hbTPcwwJTjoZRV38KwpK8plvY1xaxT4Ugp4Z9PYq4pjwsLPHDoTSatW4YpDvpK2DvVCRtvxFHm74ixWTg03QUZ5Q3Y95La/TPKQQcTnHWx4ko0ZdaMjIQY9k9zxtF3mYiiuYb+Lrpw0lfClvtJlNvx4+thVvhQVIfHidQilamGPKZ7GOCXx9SByvyY62OE7IpGvM8Q3H1DEAT6WajjRCB9bfgYR21klDVSCn5AZzPbSHttRi6dAVYaSCyqQ3kDvavFUU+R0d/opK+ExKI62u+3rifteVXU7igA0FeRZiRK99h5w2Z98X3BIztHPJnQ2MaBnCT909pyhuJNdVM7Gto4MGAgliT3IKw4o7wJ0uIs2NOIEjweiTdpFRjIQJAJSCjGIGsN2vGeuuYOPE0qZTQydTW8ADpKUrTjPc3tHJwJzmUUaHv6fTastOTRhyZnJCa/Bo8TSzDPh7rdqLa5HTufpOLHMTa0f/sfz9Iwyl4bI+2pa9SDMys7x6WmOlE6aVo7uPj5wQfM8jKkHcE6+T4bcfm1ODid2p3DFJIksflOImqa23F4JnVbVGhWFS6F5WHfVCfKQN/GNg7mno2AjpIU7d/eHXEFtdj5JBXL+pliNc34WGMbBwvORaKkvhU3lnpDS1EK92KL4P7LS3x7OwH344pR3dwOHgm0dHz53SYlzsLCPvSNZiRJYv/LDHx3JxGHZjhjoYDZMiGZldhyLwnOBkq4utiLctSMH3EFtRh54D3qWzi4utgTLjROLiqKalsw/WQYbkUXYttYO6wcYNYrGTQhmZVYeTkG6WUNeLLWD/N62W3D45G4HpmPQXveobGVg+cb+mGRnwnERYHEIkSIxBsRIrqQlRTD1rG2uLTIE3diijD+cDDl6Iww+/9togP2T3fC5fA8rLgcg6oe5rbISIjh90mdLVobrsdh64MPaOPQN79oKUphvLMuxD/7x1aMRcDNUBlf3Ur4W513F7v8HXBtiRfs9b5cRIizWdg2zg4bhlhgzukIXI/Mpz0OfRUZeDIIypMUY2GEnRYWfFI7ShAE1g22wMahFlh8IRqBvVwBv7y/KRb5mWDmqXCklvIXcOx0FXF2njt+e5yCu7GFvfLeQ221sGGoJRaej6JcFCvKiOPkHDecCc6lFe++G2UNNotFW9Vtp6uITUMtsfZaHOoomoEIgsCvE+0QnFmJgAR6IaK7Y/9upDW2BXygHbdbN9gcsfm1tKNf3SEnKYbFfU2wT8jsmzGOOqhpaqcVRuSlxDHaQRuvGThlxjrq4HFiCa2A0umoUcSbVPp9+pqp0VbDA51OLHcjFdocLjaLgJm6HKO8Lj0lGRRU07v/VOQketTyJ8a3Kpzh2FQ7B7IMnTcaCvTiTW5VMzQVJGlFAABIKWkQOqw4LLsKxupykKDJy0gqrkNrOxfufDJAuugcmSphNDL1IL7o41ggtSDTweXhYlge5vvSV0Nfi+gUefxoqsyrm9pxOigHXw2jdmSQJIkdAclY7GdCGwb7x7M02OsqYpgttSDzMrkMT5JKsXqgGeV71zV3YOONeHw3ypo242PHo2S0c3nYROOkCcmsxN4XGTg6y5W2apwp+19lIDSrCmfmuUOOYnQwqagOSy5EYayTDoZSnKOWdi4WnouEvJQYDs1wEbjlJyq3GrNPhWOglTqW0lSf1zS1Y+apcADA5UWef7mg/Mw7A7TbOTzQfbOTJDDWifp+b+3gYu21ONyIKsDN5d6MxgT/Z/8kTgZmY+H5KIyw08KO8fYCnxOS7Kztnn4iDHO8DXFyjhuUZYW//vfjijB8XyBM1WXxaE2fHlWKd9HYxsEP9xKx+EIUBtto4upiL0Zjo4KQXtaAqSc6x93+mOSIE3PcoKsk3avvIULEfzIi8UaEiM9wNVTGozV9MMhKA5OOheD3p6m9Wk890EoTp+a4gSSBYfsC8SqFuWOGH6McdPBwdR9E59XA/2gIZZBtF6sHmuHTpaOkGAszPA1wZbEXBltrYvyhYDxN+nv7kJGaLN9wwC5meRni9Dw3PEoowbaHH2gzeRb5mVAGKEuwCVhrK2DfNKduf0TP8TbCL+PtsPRiNO7H0Y+3CMLKAWaY72OEmSfDKRexbkYqODbbFd/dScKzD4LnwHTHAl8jjLTXwoJzkZTNThaa8jg5xw0uBkqU+5MUY+PwDGc8SiyhFZkW+Bqjv6U6vr+XRCl4aMhLYcd4e2y5l8TIHfI5E110YaQqi300uUFKMhJYO8gcOx6lCJzxBHTeIzmVTXgnhMAnJc7GTC9DnGVQG759vB1WDaR3E7gbqUBSjM0oi2ewtSZeJNOLN54mqsipbKKthmexCPBIktHolJuRMgpr6EUZPWVmzhsVWQk0tHEYCczdwSYIcD+rWe8Ub+hfS5Lkx7EpZpk36gwWzUzzbjhcHsRYgE0PwoqZVBq/SilHXwt12hGPxKI6VDW2o7+lOu0+AxJKMMebunIbAJ4klUJagk3b+tPO4eHk+2ys7E8tigDA8XdZGO+sS/tvzqPEEhTWtGBpP2pnRXxBLW7HFOLnsbbUgkxLB76/l4gfRlnTOie23E+CjY4CZnhQZ5o8SijBg7hi/DHJkfL6FNe2YNXVWGwda9Mri20AuBlVgDNBOTg7350yqDensglzz0Rg1UAzysDp1g4ullyMAgngxGw3yurw7gjLrsK8s5H4ZoQVFtC4YUrrWvHD/SRoKUh+ITypykni+hIvWvFUjEVgvJMu5We/vKEV889GoI3Dxf1VvrDSYv5ZbW7nYM21OJwOysHVJV6YSnMvdEddSweWX4rByffZuLTIA0v7mQrtZKlv7cD6jw/z/pzsiN8mOjASmOkIyazEsL2ByCxvxJO1fTHLy7BX3TYt7VwcfJWBsYeC4KSvhBcb+jFuMhUh4r8JkXgjQkQ3SIqxsWGoJe6t9O18QnQ6HOHZwlUOd4eqnCSOznLBdyOtse56HL69nSBQ2G93GKnJ4vZyH3gaq2LMwSBaIcNQVRZDrDXBZhEQYxGw1JLHltE2EGOz8O0IK/wx2QFf3UzAziepAi+YfUzVsH28HQIzKrHwfBSl+NDfUoPvjyoWAWgoSOH8fA/KloYR9tofxZNEnA/JFehY6Vg9yBxzvA3x2+MUytwVP3N17JvmhHXX4vA+o+cuIIIg8ONoG+gqSWPlZeq6b29TVUZPaPWUZbB3qhN+uJtEKUaxWJ2uprDsatyMphZ6Rjloo4+5Or67Qy30dAdBENg+3g7PPpQimaY+e7Z354jdlQh6R9fnyEmKYf1gCxx/ly2U+2aWlwGCs6q6daN9ipQ4m5HFnsUiMNpBGw/j6B1Lg601EZRZQSsgK0qLw05XEaEMWqec9JUQl19Lu522ojSjJidDNVl0cOnPq/LHsM2aJsFr5oFON9DnGTwkw8DiNg4PHB7JULxpYzTuUNnYDjcGeRY5lU1IKW0Q6gk1j0ciPKeakXjzJq0cAxm2TA2x0aRddH8orkNCYR0GWzMIKv5YD063mLsXWwQZCTat86WsvhXnQ3MxzZ16IdzawcXOJ6nYNMyScoHK5ZE4E5yDlQPMaHM5fnucAkstBUxy1aPc7n5sEYIyK7HT357yc59f1Yxv7yRg1yRHyjyi1g4ull+KxjBbLUyl+buZEpJZiZ8efMCx2a6U1dhl9a2YfToc/q56lE6YDi4Pq67EQk2uU0yRlhBMuAnKqMTCc5H4cbQNZnlRi4K5lU2YdCwE0mIsHJ7h0u1vAENVWVxa5Mk3ww/oHMGe48P/vVJK6jH+UDA0FaSwf5oz1Bj8W8rlkUgva8Bvj1Pgu/M1yupb8XC1cE1QCYW1GH3wPdo4XDxe4wdXQ+FruyNzqzFi33tUNrbh6bq+tJ8zJjS2cfD93U63zbJ+JriyyKvXq7nfppVj6L53SCmtx+3lPvh+lA2jcHkRIv4bEYk3IkRQYKWlgGtLvDHMVgvzz0Xiu7uJlEKEIBAEgYkueni6ri/yqpoxYn8g46wYfkiIsbBltA32T3PCTw8+4Kub8Whu5y8KrR1sDh6PhKykGE7NdfvbE8Hhdtq4u9IXL1PKMOdMhMDV3IaqsrizwgcsAphwOJivG4jNIjDP14iv+2asgzYUpOn/Ee9noY6Lizyx50U69rwQbkSGH2sHW8BeTwnTT4Yjs5z/An6YrRZ+m2iP4++ye3wtgc5cm4MzXFDZ2I4faVwwTBlgqYH5vsZYfikaTRSCobq8JHZPccTPDz7QhnhvG2uL+MJa3IkR3PlkoSmP0Y46+OFeImXwsjibhe9HWmPvi3TUNQv+GfR31UNqab1Q7hsNeSmMttfuVWFwvLMuPhTX0YoyFppyUJOTZDQS5WOqhpAsJrk3yoycN5ZackhnEAiuoyjF6H4XZ7PQz0Id1RTjeFSwWcQXTXlcHo/R09/Gtg5YaMpBlsFiU0FKDBry9K0uH4rrGC0wkkvqYamlIFTWRHp5A1rauXDoZlT1U8rrW/GhuJ7WTUOSJDLKGjCOZoQEAG5GFWKUgzZtO098QS3SShswyY1a7OgSUJYxcBUcep2J/hYa3Y7ofsq5kFwoSInD34X6va9G5CM2vxaL/aidHsGZlXgYX4xfJ1AH+hbXtmD/qwz8McmBspmsncPDqqsx8HfRw3A76oX0tocfYKwui61jqZutmJJcXI+lF6Oxa5IDfEz5j6jVNXdgzukIeJmoYvMIK77bcXkk1l+PQ3FtC7aOsWUkhH7Km7RyLLkYhR0T7DCFJkMpubgek46FYoSdFv6Y7EiZp+Oor4Q/pziA39UyVZfjG7r8MrkMk4+FYoanAfZOdepW0CRJEiV1LXiSWIJfH6dg7KEgWP/4FMP2BeJ4YDY4PBKXF3kyysn6fL8XQnKx7GI0ZngY4vRcd9pgbH50cHnY/SwVvz5KwYI+xjg/34NxHToVwR/dNtkVTXi6ri9mMxBoBaG8vhUrr8Rg9dVYLOlrioPTXSgDskWIECESb0SIoIXNIrDIzwRP1/ZFXlUThu4JxEsBwoHp0FWSxuVFnpjnY4w5pyOw80kq2no4pjXIWhNP1vohr6oZSy5E8w3dtdZWwOqBZjg3373bH6BmGnK4v9IXyrISGHMwCDF59BXDn6IgJY5Tc90xyFoT4w8HI4hPbsg0dwNwPntyL8FmYfdkR9yKKcIP95IYuX9cDJRxc5k3bkQW4Mf7H3q1+n39YHNM99DH9JNhlA6M8c66GPFx3Kk3MpPkJMVwZp4biutacDwwu8f7A4D1QyygoySNvTQiVz8LdUz3MMCaa7GUoy7KshL4bYId7scVC9R81sWageYoq2/DjSjqtqaBVhqw1VHEgdcZAr+HrKQYlvQ1Fbp5ar6vMW5FF6KupXfEW1sdBbRxeHhNk2dDEAQGW2syap3yMVVFCEPnTWZFI2XNPNAprOVUNtGOOemryKC8oY3ReGlBTTMqG4TL+mKzCLRzPx+bAqOxqaY2LrIrmiBJ4zZp7eAirqAO6gyqwnOrmmHI4Al0ckm98CNTWVVwM1KmHYV6m1YBBz1FWgdeTH4tYvJrKRfzQOd5uBtbxCio+FxILia56tFW9z5JKgFAYqwjtXBUUN2M61EF2DDUgnK7ysY2HH6diR9GWVMKY5WNbdj1NBU/j7WldBs1t3Pw7Z0EfD3cirKNh8cj8dWteLgZKWMQjSvp96ep4JEkNo/kL4oAnbXczz6U4ethVpQuU6aU1LVgwblILOtvSplt1NLOxcLzkdBXkcHOifwdRDweiW9uJyC1tAEXF3rQVsF/zovkMqy4FIPf/R0wwZlaaIvKrca0E6GY72uE70Za07oZi2tbcOh1JtyNlCHO/vu2UuIsLOrzZQ4TSZI4EZiFNddisWuSA1YNNP/rfepbOxCcWYlDrzMw+3Q4nLa9gM9vr7HhZjxOB+UgobCuM2fnY1j6ufnuArVRdb3HyisxOPI2C/unOWN5f+HHpDodSqF4nlyOXyfaYWGfnocHN7R24Lu7iTjwKgPL+pvi8iJPRi12TOHySFwIzcWg3e/AIgi82tgPs70MeyVMWYSIfzsi8UbEv440inDZnmCgKoNLCz2xYagFNtyIw6orMQK7UfjBYhFY2McYD1b5IqOsAZOOhVCG5DJBW1EaVxZ7wtdMFROPhOBSWF63i9YNQy3hTNFmICsphkPTO1sXfnuSgsvh3e+HH2wWge9GWuOHUdZYfCEKF0Jzv9hGXV4SA601/lqEibEIHJ3lggkueri70heRudVYcpHaKdKFhaY8bi33RnBmJdZci0U7p3dawwiCwIYhFpjsqofpJ6gr5Wd6GmL1QDPMPh0uVMX152grSuOrYVY49DoTjxNL6F9AA5tFYM8URzyIL8ZFmpasr4ZbgiSBP5+lUW432EYLmgqS+OZ2gsDiiLQEG1vH2mLn01TKNiKCIPDDKGtE5FQxynX6nDnehsivbsZbIdw39nqKsNVRwA0GdeBMIAgCYx118IDB6NQwOy1klTfQipFuRsooq29FQTV1/oy6vCR0FKWRUEgtLuoqSUNSjEV7rtXlJCEpxmKUj6MmKyl045QYi/jiHPAYjk01tnEgJyVGuxCsaGgDm0VARYb+CXh+VROMGIxCpZQ0wEbImvCwbGYjUx9K6jCGQQBxQEIxhtlq0oapvkgug6qsBO1YWHlDKx4llmAOTT04SZI48iYL0z0MaQW0/a8yMMpem3LMBwAuhOTBx0wVPjRNVDufpMLbVJW24enPZ+nQUpDCbJpxnnMhucivbsaPY2wpt3uRXIYbkQU4NL37kZ8u4gpq8fPDZByc4QydXghmrW/twPyzkRhgpY4V/alHoH59nAwWi8ChGfxbrUiSxI8PkhCVW40rizwFDlF+nFCMo28zsXeqE8bQCHdv08ox90wEvhpuhZUD6HORUkrqMeFIMNyMVHBlsRcW+Zn8/d4mgdGO2n97TTuHh29uJ+B0UA6uLfHCSPv/+d9DMivhuPU5FpyLxIHXmXifUYm6lo6/2i8/H9vsrLsXbMwpqagOYw4GobGNi0dr+sCdQWlDd5AkiRuRBRh9MAguBkq4v8oX1to9d628z6jA8H3vkVvZhD8nO2J2L2fbJBXVYeKRYJx6n4PDM11wcLozpXtNhAgRf0ck3oj417HkYjS2PvjQa0/IP4UgCExx08fLjf3AI0kM3vMOD+OLem1Ex1xTHkdnuaK/pQYmHA7B8XdZX/xYEAQxNgvL+5vh9Dw3HHiVgZVXYoQ6LwTR6T7aONQSe1+k46tbCQKHOE9208fFhR448CoDu5+nfZHhssDXGGwWAXF2Z9ZL1xNNXSVp3Fzmg5Z2LqaeCGUUjKunLIMby7yRV9WMn+4nUY6OCQJBEPhqmCUmuuhh+skwykXtkr6mmO1liJmnwpFfRR/mSoedriL2T3PCppvxiMkXzAHVHeryUjg0wwW/PU6lHKGRFGPjwHRnXAnPpx052jLGBlnljbgcLnguzRAbTbgZquA3mkpwK20F2Osp4VchqsM73TcmQrtvlvQ1wauUMqFCk7tjrJMOXqeV045iuhooI6WkAUk0NeQyEmJw1ldmNjploEQ7OkUQBCy05JFGMzrFYhHQU5ZGAcPQYmFFb3Y3bVMkw7appjYuZBmEdpY3tEJNToJ2sVLX3IGa5g5G2Q8pQtaEd+bdVMHblFq8aeNwcSuqEJ4m1ItAHo/E40RmLVM3ogow2U2fdvH8ML4Yw221YKouR7nd2/QKlNW3UgbhAkBmeSMexBdj3WDq6uj0sgYcD8zCN8OpHS2RudV4nFhCK7RE51XjQ3Eddvo7UF779LIG/PEsDXumOFGODRXVNGP/q3T8MtGeMmOnqrENKy5FY/0Qc1o3FBPaOTysuBQDTQUpbB/Hf/SLxyPx9a0ERObW4CP9PlUAAQAASURBVCRF6DBJkvj1cQrepFbgshDV1/fjirDpVgJWDjClHRt7GF+M5Zdi8Ju/A62ABnSO9Ew5ForZXob4ZbwdxNgsfD3MEsNsNSEpxoIYi4C/q97fspBqmtqx7noskkvqcX9lHzjoKf1tn84GyjBWkwWHR9I++JFgs7B+MLU7rIu6lg6EZlZgyrEQ+B8JxhQ3fZyb5y50m1hNUzuWX4rBH8/TcHimC34aQ+0qY0JDawc230nA8ksxWDGg9902TW0c7Aj4gDVXY9HXQh3P1/dFXwv60HRhySxvxPrrsf/Y/kWI+L9CJN6I+NdxfoEHsioaMWj3W9yKLuzV0ZkuNOSlcGSmK3ZOdMDxd9mYezaSUdsKEyTEWNg41BKXF3viakQ+pp8Io32SToePqRqerPVDczsXow68R6yQi38vE1UErPZDdkUj/I+GCHxcbkYquLvCF2/TKzDndMTfaoO9TFRgpCqLeT5GXzzFVZQWx/kFHrDQkMeEwyGM3CxqcpK4ssgTuVXNmHEyvEcVxZ9CEAS+GW6JcU66mH4iDHlV/AWc9UMsMNpBBzNOhaG0TvA2ps8ZZK2Jr4dZYvH5qB7fEwDgYayC9UPMsfJyDOX5MVWXw09jbLHxRjwqKEZeFKTEsWuSI357nCKUYLV1rA0eJZbQ5qdsGGKBsKwqhDDIgfmcOd6GKKhuxts0wd03Ayw1UFDTgpe90BAHAGYa8jBTl8PzD9T7kxBjoZ+lOqNxzcE2GojMoc+fcdZXQiyD0GJLTXlGdeH6KjIoZHBPqspJCO286S6wmPdxdIGOxrYORhkdFQ1tjLIr8qqboCIrQTsqVNnYhoqGNlgJId6klXXWi9vrUj9Nj8ypgbyUOO1oVmRuNTq4JHxoxKDCmmaEZVfB30WXcrt2Dg9H32ZjIs12AHDkTSYW9DGmDbjd+zId/i56tOHOvz5OwQxPA5hQiEYcLg9b7iVh1UAzyqrhNg4X39xORH9LDUoRqp3Dw7prcZjna0RZx87h8rD2WhwcdJUoR8Q4XB5WX42Fs4EybRYPE0iSxLd3ElDT3I7DM10onTS/PE5BdF4NLtCMQO19mYH7ccW4vMhT4LrmW9GF+O5OIo7NcsUga2rh5kp4Pi6H5+PILBfasTqgM/h60fko/DTW9m8jTwRBYPdkJzjoKYLDIzHH2+iv12SWN2L8kWDISorhxlLvbmvlpSXYOL/Ag7IBswtNRckv2tV4PBI5lU14nFiCP5+lYebJMLhsfwHHn59j+qkIROTW4OsRna4iYd0sQRmVGL4/EFySxNO1fujXCwJIYHoFhu0NREF1C56u88NMT0NG4ftMefahFIP3vENCUT2Oz3bFxqGWPRab+FHX0oFtD5Mx6sB76IkqxkX8CxGJNyL+dRipyuLCAg9sH2eHPc/TMPl4KD7QPLEWluF2Wri82As6ilIYtjcQZ4NzeuSU+RQXA2U8XusHCy05jNj/Htcj83vk8FGVk8SZue6Y622EGSfDcexdllDClpaiFK4t8YaboTJGHwzCmzT6LI5P0VeRwbXFXlCQFsO4w8F/CTEEQeDpur74flT3YY0SYizsnuIIfxdd+B8NQRiDbA95aXGcne8OLQUpTD4eipI6wfNYuoMgCGweYYXRDtrYFpDMV6ggCAJbRlvD11QNM0+F9cqY3TxfY4xx1MG8sxFCBfd+zmI/E9jqKGD9jTjK+2Gymx7GOepg003q7fqYq8HfVQ+bbsYLfH/pKctg9UBz/HA3ibJdS01OEqsGmmFbQLLAnzcZCTEs7WuCfS8FD7UWY7Mw18cQZ4JyBXodFWOddPAgnlnr1AsGuTdO+sp4m15J+7c56SuhvrWddjsLTXmklVIHVgOAvrIMChiMTanKSaKqUXjx5nPnDY+h86axjQtZSfrFQnlDGyMLP9O8m5SSehioyAgc7goA4dlVYBEEbZ7Gq9QyDLBSp11sBSSUYLidFmX4KwDciipEPwt1WpfF48QSKEiJoa859eIxIqcaqSUNmE1TOZ5cUoeo3GqsGWRGud279ArE5tdi7SBqd865kFx0cHlYRFNHfeh1JqTEWVjs92U2yqfse5kOALRui70v01Hf2oEto6mDh/94loaKhjb8PsmhVxbKe19mIDy7+otK7c858jYL9+OKcXGhB+W9fuRNJhIKa3F5kSdtQ9fnXIvIx0/3k3Byrhulu4IkSRx5m4mdT1KwcagFbdV81/Y/3EvC8dmu3TaCSYixcHa+Bw5Od4alVufo3fuMCkw8EozRDtr4naY6W19FBsdnu0KMQlyRFGNh3SALpJc34GJYHr65lYBhewNhteUpBu1+i00343HsXRaCs6r+JlZ7GKlgIc39yI82Dhc7Aj5g74t0rB1kgROzXYV27nRR39KBb28nYOXlGKweZI6LCz0o854Epai2BYvOR+Hb2wnYMMQC15d4wZxmHFJYuDwSl8PzMODPt0gva8CDVX2wcRi1M0+EiP9EROKNiH8lBEFghL02Xm7sB09jFfgfDcFP95NQK2TLCRWK0uLY6e+Ak3PccDY4F5OOMXOGMEFGQgw7xtvj0Axn7H6ejsUXohiNDfGDxSKwuK8Jri7xwuXwPGy6GS+UoCAhxsLP4+ywdawNVl6Owf6XGQIt1GUlxXB0pivGO+lg4pEQvPkY2koXVkcQBDYMtcT3o6yxPSAZ92Lp242kxNk4PNMFbobKmHQ0lLbumSkEQeD7UdYwVJHB9JP83VEEQeDXifaw0VHEz700zrdltA2M1WSx7FJ0jzN9CILAH5MdkVPZhMNvMim3WzPYHJnlTThL07r07QgrlDW04kxwjsDHs7CPMYzUZHAplDqLZ56vEZrbubhJE3LcHbO9DVHZ2I73fAK0qZjqZoDEorpeCaMGgDGOOgjJrEQVzeewv6U60ssaUEQTCO2kr4SmNg7Sy6jvcztdRcTk1dLm1FhqMXXeSDNyg6nKSqCqSTgRU1KMBVP1vy8iCQDWDPJkmto4kKNxyQAfnTcMFkR5lczybvKqmuHNILOmOxhXhKeW0y56OVweniSVYLS9NuV2PB6J58mlmOlJLbSQJImzwTmY60PfPnPkbSZmexvSupR2P0vHGAcdaCvyf1rO4fLwy6NkrB1kDiWKXKLSuhacDsrB9nF2lPk+ycX1OPk+G7v8qRuNInOqcDY4F/umOVHu731GBc4G5+LwDBdKl9HzD6W4Ep6PY7NdhRL2PudGZAHi8mtwdr47ZcvQtYh8HHuXhQsLPCjdTWeDc3A8MBtfD7MSeLF9ITQXvzxKwdn5HpSjYCRJYueTVJwJysG1Jd6Ubiagc3G+92U6zgXn4vpSL0pRSE5S7K98nYtheVhyIRpbx9riq2FWjBwvfubqWDnAlG8YuowEG2McdTD7VDh+fvAB16MKkFbWgHYuDzwSaG7nfiE0s1kEto6lHt/jR3pZA8YfDkF4Tg1+n2SPGZ4GPRb83qVXYNjed+CRJJ6u74vpHj3fZxccLg8nA7MxdM87KMuI49XG/ozGMIUlIqcKow8G4URgNn73d8DFhR5/CXciRPzbEIk3Iv7VyEiI4evhVni0xg9tHB4G73n3j41S+Zip4dm6vnA3UsGYQ0HY/zKj18Jy+1tq4Pn6vtBUkMLoA+/xNKm0R/tz0lfCozV+kBJnY8T+90KNnwDABGc93F7ugzuxhfjhXpJAThAWq1OI+WWiPVZeicHJwGzGToip7gb4ZoQVttxLwuE3mbSvY7MI/DbRHuOcdDD5WCgSCmsZHycVnc4aGwyx0cS0E2F8R+fYLAK7JzuguZ2L+WcjGAUvU8FmEdg/zRkNbR3YK4SD5HMUpcVxZKYLjr7L4tsI1rXdgelO+PNZGqV4ISMhhj8nO2L383RklgsmZEqIsTDf1xh/Pk+jbK6SFGNj8wgr/Pk8jbY1qbvjm+djhD+fpwl87hRlxOHvqiuUMNUdukrScNJXog2iVpKRgLuRMl7RjGxJiLHgbqxCWy0uJc6GtbYCYmlybyw05cAiOgN/qeh03tCLN5oKkrSjM/whkFLy9/uJwyORQSNUAZ0LRTN1erGF6dhUZVMbI+dNTF4NtJUED+MkSRIROdXwpAkzza5oRHFtK3xpQnvDc6oBEPCkEYNCsqpQ3tCOPubU+4stqEV2RRP8u3E+fMqH4jqEZVdhQTeNP58Sk1+D0OwqLKMI2AWA61EF6OCSmEWTibLjUQp8acKMOVwevr4dj8V+JrDR4T9y1tDagZ8DkrFltDVliHJ5QyvWX4/D1rG2lIJHZnkDNt6Iw/7pTrRZQUwITK/ATw8+YFk/U8rje5pUgm0ByTg9153y770WkY/dz9Nxbj71dt1x6n02/niWhvMLPeBBce9yeSS+vZ2IgIQS3FzmQ/s+Le1cLLsUjceJpbiz3IdRnTSHy8PWB51OlQsLPTCRpk7+U7IqGvEgrgjailJfiHVSYiysHGAGCTEWfp/kwGh/bALwM1MT+HySJInzIbkYfzgYAyzVcXu5D8w0eiZK1Ld24JtbCVh1OQZrB1vgd38HgUfiqIgvqMXYQ8G4FpmP0/Pc8cdkR6gIWYFOR0F1M1ZcjsaCc5GY5KqL5+v7YoiN5j8mEokQ8f8DIvFGxH8Fpupy+G2i/T8+SiUtwcZ3I61xY6k3niSVYOWVGKHzZT5HSUYCv0ywx/ejbPD1rXhsvBFPG3RKhYKUOH6ZYIcNQyyw6EIUdj9PEyqI1VpbAQ9W9kFZfSvGHApCcrFgLVljHXVwdbEXTgVlfwxCZiZs9LVQx7WlXrgQmovv7ibSHjtBEPh6uBVW9DfFjJPhQgtW3e33pzE2GGilgeknw/g6IyTEOh1AUuJsLLkYJXDg8+fISorh1Bw33IstwpG3WT3aFwDY6ihi2zg7WieWq6EKlvc3xZprsZRB0O5GKpjrY4hDb7IEvq+8TFQxzE4L2wOSKbcbbqcFE3U5of7+mV4GKK5tEXjsDwDm+RgjIKGkRy64T5nqro+QTPoxQKaV4b6mqoxCi50NlGi/n9TlpdDQyqF13xiqykCcRf+TQlFaArH5taiursabN29w/vwj3LjxCI2N9ALM+TfxyK9uhtG3j/76bzNPhSO7sulv/607fr6bhDPBubTv0djGgY4y/UImpbgB+gzGC5KFDCvOLG9EUzvni0DVz3mdWg5PExXI0rg3QrIqMc1dn9bdeD2qAP4uurSjWueCczHZTZ/WNXI7uhDTPQygRuNm+vNZGub7GlFu19DagT3P07F5hBWl+yU4sxJv0yrwNc3IxMn3OWjt4GHVQOoxre0ByVCQEsc0dwO+23B5JNZdi0MfMzVMphC0Glo7sORiNGZ7G2GgFXXNOBOSi+ux8nIMfp1oRylUhWVXYcONeByY5kwpqtyLLcL2gGScnutG2ULZHSfeZeFeXBEuL/KEC8Vr2zhcrLoSg+j8Gtxa7g1jmpGs6qZ2zDgVhrrmDtxa5g09BiG69a0dWHA+CiFZlbi/0pfW1fMpL5LLMP5QMIbZ6eDpur7QUZTCpx8HgkVgukfnvTDQShPzfIzoM3IIAl8Nt2R8DECnGDj/XCSOv8vCmXnu+Ho49X3PhDdp5Ri2NxAl9a14ur4vpvWi26a+tQNb7iVh7plwjHHUxuO1foycg8LQ1MbBn8/SMGTvO8hJiuH1pv5Y2MeEstVNhIh/CyLxRsR/DfxGqf6JVioHPSU8XN0H7kbKmH4yDNsDknut8Wicky6ere+L8oZWjNj3HqEMsl/4QRCdP0LurvDF06RSTD8ZRul24IeijDhOznHDZFc9TDoWgjsxhQK93lFfCQ9W9UFjGwfzzkQyHuWy1VHE3RW+iM2vxcLzUbTuAABY5GeCn8fa4sjbTDzphdptoPM8bhtni77m6ph+gv85lBJn4+QcNzS3d/54pcp1YYKWojROz3XH0bdZeMggN4WOSa56GO9MHz66coAZ1OQk8fMDanFl3WALJBXV4dg7wcWV70ZaIzizklJcIYjOZrK3aRWUwdHd0Zl9YypU85SZhhy8TVRxOUzwVq3uGGClgRcpZbQjUYOtNRGWVUXrNPI1U0N4djWtaNYp3tTSHp+VNn3jlL6KDGILarH3STJOvEjFvoAE7LgTi++uhmHdhVCsOBOIOcdeYf+TaBTWtMBlVyiWPWvGwRTgRAxQXkd//ez0v3QpdEkHdM/UmQ5qvU0txXd3EjHm+0c4+uY93+0Kapppm1jaOTxkVTTCWktw8SYspxquhsq0i7U3aeUYRFOBzeHycCU8n7bZpba5Hc8+lGKyG/XZLKtvxdOkUsyhybDJrmjEpfB8LPA1otwuJLMSiUV1WOJH7bo58iYT5ppyGGLDX/Ro43Cx5X4SNgyxoMzsya5oxIFXGfjd34FywffsQymeJJXiz8mOlOM2R95koqSuFTsm2PNdDJMkia9uJkBXSRobhwq2kO+OkroWLDgXiaX9TDDBmf81Syqqw7KLUdg50R6DKc7d06QSbL6TiGOzXWkdWp+z/2UGjgVmY+dEe0rBsbG1A4vOR6G4tgU3lnpTjsgBQF5VE/yPhkBbUQoXFnpQjsp1kV/VjOUXoyEjwcbt5T6MG5N4PBJ7X6Rj3bVY/OZvj29HWEFeSvxjgHHnPSIpxsJ8H6O/iaXfjLCCuaYc34wcNgH0MVNj5Bbq4lVKGUbsew95KXE8Wde3xyJIXUsHvroZjzVXYrFusDnOz3fvNbcNSZJ4GF+MQbvfIbeqCfdW9sHy/mb/iJDC45G4G1uIgbvfIiy7CjeX+mDXJEdR1biI/ypE4o2I/zo+HaXKrmz6x1qpxNksLOlrioDVfogvqMWwfYGUIymCoK0ojfPzPbCkrwkWno/EjoDkHjk5LLXk8WBVH5iqy2Hkgfd4waDV5nNYLAKrB5nj6CxXbAtIxpZ7SQKNjWkqSGHfVCdoKEhh3KFgxg4eHSVp3FjmDS6PxJRjoSirp3dD+LvqYZ6PMTbejMfViN5ZgBMEge3j7OBrpobpJ/m3S8lKiuHcPA8U17Zi4434Hgdc2+go4OB0Z3xzOwHRefQtQ70Bm0Vg31QnPP1QikcJ/AUwKXE29kxxxKE3mQI7stTkJPH1cCv8dP8D5b1tp6sIW2157HqaJtD+AWCWlyGKa1vwOlVw982CPsa4HJ7H2ClGhZqcJLxNVWkFOCM1WQy21qAdibLRVgCbTSCBJpfHWV8ZycX1aONQf3dYaSkgu4JaXJGXEscUF22kFFWjoL4JzRwS0hIS0FWShZWWLLwdFDDSRR5feasic8cIZGwfirSdoxC1cxRe7hwFE116F8KqYR7I3TkKuTtH/fXfMj/+/0Gf/Lfu+Px1/Hix3BmuAOzZgJUkfxeIl6ECjjyIRkB0Iv/3rGyEs74y9Bg4eT4nPLsKnsbUC7aGlg40tnIwgEa8Cc2ugoQYC26G1E6K+3HFsNNRoB3LuByWBz9zNdoQ2+PvsjHWUQf6Kvy3I0kSfzxPw9K+JpStRwXVzXieXIYto2wonQKn3udAUoxNKyy9SC7DdA8DuFKck4qGNmy+k4gd4+2gQ7HQDc+uwpOkUhya4UzpRDr2LhuJRXXYP82Z1gFFR31rB+afjcQAK3WsHMDfOZRT2YS5ZyKwYoAZxjrxF+bfpJZj/fV4HJjuDD+aAOpPIUkSfz5Lw8WwXFxd7AU7XSW+29Y2t2Ph+SioyErg8mIv2lGa+IJa+B8NwQBLDRya7sKonSgytxrjjwTDQkseh6Y7Q55BzhXQeT4XX4jCvbgi3F7hg9EO/9N4ZagqiyMzXSD2se3u8xFAcTYL+6c68985QeCrYczEupZ2Lr6/m4Bj77Lww2hrHJjmBEVpZn8DP7qapMob2vBsfV9Mde89t01eVRPmno3Ezw+TsWW0DS4s8BA43Jopcfk18D8Wgl1P0/D9KBvcXOYNez3mgpgIEf8aSBEi/gUUFBSQAEgAZEFBAePX8Xg88nFCMen960ty1eVoMqmo9h85Pi6XR14IySFtf3xKbroRR9Y2tffavjPLG8ixB9+TQ/a8JT8U1fV4f/fjiki7H5+SfzxNJVs7OELtI7+qiRx1IJAcfziILKltEei1PB6PPPQ6g7TZ8oR8kljC+HVtHVxyw/U4sv8fb8i00npGrwnPriLtfnpKHn6TQfJ4PIGOkx9cLo/85lY8ueBsBFlax/9vr2hoJQf8+Yb85lZ8r7z3+ZAc0nnbczKvsqnH+2LKk8Ri0v6np2RBFfV77n6eRg7b+45s6+AKtH8ul0eOPRRE7n6WSrldaV0LabPlCRmRUyXQ/kmSJE8GZpGjD7wX+BrweDxy/tlw8kZkvsDv2R03owrIEfsCabfb+SSFXHctlna7ZRejyIOv0im34fF45OzTYWR0bjXldo/ii8gVl6LID4WCn99/K1mFJeS2m+/J6fufkOklld1uExBfTI47FCTwvnk8Hum6/QUZltX9frt4klhCDvzzDe3+vrkVT259kES73cj9geS1iDzKbVraOeS8M+FkYHo55XZFNc2k+fePyYyyBsrtXiaXki7bnpONrR2U2628HE1uvBFHuU1+VRNpveUJGZXL7D7lcvl/5nk8HrngbAS58nI05XdDVWMb6fnLS/JccDblewVlVJDWW56QiYU9/43R1sElZ54MI+ecDic7OPy/U0vrWkjfna/IXx8nU+4vOLOCnHw0hHwQVyTQcfB4PPLXR8mk+44XtNe5rK6FHLrnHbnofCTZ0k7/u+J1Shlps+UJeTIwi/Hx3IoqIK1+eEJeDM1l/BqSJMn00nqy/x9vyLlnwil/m51+n03ue5H2xX9PKakjB/z5hpx2PIQ02fyINPwm4K//M/42gJx9OozRcSQW1pID/3xD+h8JJvNp/k1lQm1zO7nxRhxp++MT8m5MQa/9xiHJznvw4Kt00uqHJ+T3dxPI2ube+037OaV1LeT667HkjBOh5J7naWRzG/PfpcKuDUSI+P8ZkfNGxH81XaNUzzf0hb6KzD82SsViEZjtbYRn6/uisrENg/a867WRHVN1Odxa7oMJzrqYciwEh99kCpVd08VYRx0ErOmDDyX18D8agpxKwcZRgM4RilvLfGCmLofRB98jPIf5aBdBEFg5wAy7pzhh4404HHrNbKxFQoyFPyc7YIanPvyPhjDKtPEwVsG1JV44E9TZjtEb7isWi8CvE+yhJi+J6SfCUM7HCaQmJ4nLizwRlFmJ/a8EH935nDneRhjvpIt553qnQpwJw+20McfbCGuvxVLec6sGmIHNInDgVYZA+2exCPwy3g4n3mcjm6IlTFNBCsv6mWLbw2SBr+FMT0OU1LXiFYMsmU8hCAIDrTRxLiS3x9cOAIbZaiKzohGZ5dTZL4OtNfE6tZz2Mz7IWpPWLUMQBCTF2AjOqEBOOX+XjrepKtLL6vGGJiz5vwkTXS1smdQHh2b5wFyre4dMRHYlEgpq0f+3p1hxLhhXQjIRkVaC6jpqF1peVRO0FaXgqK9Eud3bNPqWqQ4uD08/lGK0A3XLVFJRHXIqmzDqE8dBdwQklKCgpgV9aAKST77PxiArDZhp8A/k5fFI/Pk8Hcv7m1Jm9kTn1eB1ajk20YwabQtIxmgHbbgaMss3oRqDuhZZgA/F9dgx3o5yDGrTzXg46SthjrcR330V1bZg9dVYbB1rCzvdnjkFSJLE7udpqGlux+GZLnwbsuqaOzDndAR8TFXx7XD+2T/RedVYciEak1x1/2pnYnoc2wKS8SC+GNeXelNe5/yqZkw6FgpbXQUcnUnvoLkemY9TQTn4fZIDFvnR12rzeCR+f5qKnx9+wMk5brRh1p/yNKkEPz34gFH22jg9153S/bWgjzHWflITT5IkbkQWYOKREIx20MGlRV5Y1Mf4b/k3BEHQZi9xeSSOvcvC5GOhGO+ki2tLvBiPevHjdWoZhu59h6rGNrzY0A/jnfV6zW0TkVONdddjEZBQgsuLPbFjvH2P3UHd0drBxeE3mRj451t0cEnsmuyI9UMsehB4L0LEvwOReCNCBAA5SfH/lVEqXSVpnJnnji2jrXE+JBdLLkTyXdwLgjibheX9zXB5sRduxxRiyvFQ5AohunRhqCqL47Nc4WmsijEHgxhVcn+OlDgbuyY54PuR1ph3JlKgNimgM4z25jIfXI0owJprcYzGwgiCwGI/U2wZbYOF56NwN5Y+e8dWRxG3l3vjWXIpNt2K73EODfA/Ao6zgTKmnQzjG2yrrSiNyws9cSu6APteCiZsdMf3o6xhoib3sUK8Z4HITFk5wAx1rRwceM2/ZlxCjIXdUxxxOihH4ABvO11FTHXTx7F3WZT3z+K+JqhqbMNdAe9VaQk2lvUzwb5Xgrd2TXTRRUF1MyJyej6uJi8ljoGWGnhAMzrlrK8EcTaByFzq8+hprIIH8cW0+TgjbNVxJTwPRyhq4pVlJfFiwwCsHGxNua//RlRU+OfZbB5lg2tLXDHaThv1zVxcDc/F3hdp+Pp2EtZficRPd+Ow92kyLgZnIr209q/XxRfWgcUiKBe5JEnibVoF7chUcGYlpMXZcNanHpm6EVWAUfbalGM/5Mfmm7k+RpQLwarGNlyLKMCK/tRBwE+TSqGjKEW52CZJEtsDkrGkrwm0FPnnWrxKKUNETjW+oRAqmJJb2YQdAcn4Y7IDZcbK6aAcpJU24PdJDnzPR2sHF78+SsFwOy1McdPv8bHtf5WBh/HFOD3Xne+1amnnYsH5SBioyuBXigyepKI6zDsbiW+GW2IKRRjz5/B4JLbcT8LzD2W4voQ6cDittAGTjoVgoJUG/pxEXcdOkp2ZM788SsHqgWZ/G13iR3M7B8svR+NxYgnurPClbUnrgssj8cezVGy6mYDZXobYNMxSoFG25nYONt6Mx65nqTgx2w0bhliAzeocj7LUkocYiwCLAHxMVSkFu+LaFsw8FYarEfm4stgTqweZU56j7iBJEuUNrYjJr8HZoBwM2xeIddfi8NUwK5yZ506bK8SUmqZ2fHUzHvPORsBZvzPXkSqYWlhIksTTpBIM3vMOjxNLcHa+Bw5Od+7VRiwRIv6TIcjeeGQoQsT/MYWFhdDX7/xhVFBQAD095pWQn9P5D0cptgckQ0dJGtvG2Qlc78iEqsY2bAtIxuvUcnw/0hpT3fV75clISzsXvz9Nxc2oAnw3yhozetgm8CqlDJtuxmOQtSa2jbOFjAR1u0h3xBfUYvmlaDgZKGHXJEfahpJPqWxsw7KL0VCVk8C2cXbQpAih/JT3GRVYcSkGS/qaYNVAM9pzUF7fijlnIqCrJI1D050hLcAx8oPLI/HVzXgkFNXh6mIvvhXEGWUNmHI8FCv6m2FxX/onjVQ0t3Ow+U4ixFkE/pjs+L9SmZlSUo+JR0JwfgF1PeyRt5m4FV2Ixx9r6plS39KBwXve4YfRNhhL8XT4flwRfn2cgjeb+gt0n3bV0M7xNsQga8EaYH57nIK8qmYcm+0q0Ou640liCXY9S8Prjf0or9s3txIgKymGH8fYUO5v8J532DTUAsPt+LsuuDwSIEmwWISoXvV/ifyKWuRVtaCsthnVrRxUN7TD21wT/T4KMUfeZKK5nYtNFDkZKSX1mHQ0BDE/DqEMBv3qZjwUpMWxZTT/e6WNw8WIfYH4Y7IjpWslOq8a885GImzzIEqnzO7naYgrqMXFhZ58t+FweRi6LxAL+xhjpid/8eZBfDF+eZRM+Zlu7eDC/0gwFvQxoa0up4PD5WH+uUi4Gihj3RALvtvFFdRi+okwXF5M3az07e0EpJXW4+pib0j10DFwM6oA2wKScWuZDyy1us8l6uDysORCFJraubiwwIPv92xaaQOmnQjF8v6mWNKXOij6c8rqW7Hycgz2TXOCHkXjWmx+DeadjcQCX2OsGUT9b3AHl4fv7yYiKKMS5xZ4UFaed1Fc24y11+LAIggcm+UKZYZ11HXNHVhzLRYF1c04PtuVsta9O9LLGrDicgxUZSVwYLrzF79JSutaMXjPOzS1cfBwdR++4k1AQjG+u5OIEXba+HGMDd/PFI9HoryhDYU1zSisaUFRbQtyK5uQXdmEopoWVDa2gcMjwf6YySPGIhD0zUBKsVMQSJLErehC/Po4Ba6Gytg61pbyuveElJJ6bHuYjIzyBnw1zBKTXOkb8qjozbWBCBH/vyBy3ogQ8RmftlJ5GKtg4tFg7Hqa2uujVKpyktg/zRn7pzlh/6sMzDgZ3iO3TBfSEmxsHWuLY7NdcfBVJhac65m7Z5C1Jh6v9UN+dTPGHAxCSolgwbNAZ5vUw9V9UNfSgXGHgmhHQz5FTU4Slxd7QkNeCmMPBSG+oJbR6/zM1XFjmTcuh+fj29uJtI4aDQUpXF/iDSUZccw5G9Er15v9UUCx1VHAjJNhfFu0zDXlcXGhJw68zsCV8J4FKMtIiHU2NWVV9UqFOBOstRXwzXBLrLsWSzmytcTPBOpykjj5Plug/StIi+OH0TbYHpCMegonyVhHHegoSePYO8H2Ly3BRl8Ldex9Kbj7Zo6PEV6nlqOgulmg13XHACsNVDS0IamI+jM2xEYTL1JKaY91sqsuzofk4peAJCQW1Xa7DZtFgM1miYSb/0UM1JVgqqWEIY4GWNLfEt+Osf9LuAGAsrpmxOdX4U5UDtJLasDjffndFZ5TBX9XPUrhpp3Dw7MPpRhFMzL1MrkcPBK0T9HPBudiqps+pXDT0NqBcyG5lCG6AHA3tggcLknpRmnt4OL3J6n4epgVpRh75E0mxMTYmMCgKY+OY++yUFzbgmX9+QsadS0dWH01BuuHmFOes2sR+XiRXIYjs1x7LNwEZVTix/sfcHyWK1/hhscj8cPdJIixWTg1142vcJNT2YSZp8Ix18dIYOEG6BxTvbnMm3IBH5xZidmnI7BusDnWDjan/H5pauNg0fkoJBTW4c4KX0bCTUJhLcYfDoGLgTIuLvRkLNykltZj7OEgiLMJ3FvlK7BwczemEOMPB2O4rRYuL/Ls9mGSlqIUTs5xw9J+Jt0KNw2tHdhwPQ6XwvLwu78Dfp/kwPcz9TSpBOY/PIHXb68w81Q4vrubiP0vM3AzuhDReTUorW8F56NDnMsjQRDApYUevSbcZJY3YtqJMOx5kY6d/g44OcftHxFuqpvasfVBEmaeDIO9niJeb+qPqe4GPQ72FiHi34hIvBEhgg+ftlJVNLb9Y6NUA6008Xx9X5hpdDY9nQjM6lFmTRd+5up4tq4vFKTFMWxfIJ5/KBV6X9qK0ri62AujHXQw8UgIrkXmC7zIVZWTxIUFnhhmq4Xxh4MFyvyRFGNj2zhbLOpjguknw2hHS7qw1lbA3ZU+iC9kViWuKCOOHePtIS8ljmkn+I87CQKbRWD3ZEdYaStg5slwVPERcOx0FXF2njt+eZSM+3GCj6l9iqaCVK9WiDNhro8RrLUV8O2dBL73hhibhd8m2uPo2yyEZwtWcT/GQRsWmnLY8zyd7zYEQWDLaBucDMxGUY1gYspMTwOU1bfhpYDZN7pK0hhso4ELobkCva47pMTZmOVliJcp1J/VPuZq0FWSQWppA9rb28Hl830x2VUfw6w1oKMgARUGFbtdVDW24Yd7ib2S5SOiey6F5eEin3tmlrcR1OUl8DChFBuux2HY7teYfDgQMbn/85l5lVIOE5pWl7DsKtjpKsKZJjvnVnQBJrlSZ2KU1LXg+YcyymwXALgTU4gBlhrwpHDgtXN42P8qA+sGm0OcYkTkTHAOlGXFKUWZnMomnHifjR3j7CgzbJiQWFiHQ28ysW+qM1/hgyRJbL6TAFN1OSzqw98lGV9Qi58fJuPgDOcej62klNRj+aVo/DLBDj58soZIksSORykIy6nCLxPsoMCnZamwphkzT4bB31UXaweZC31MVPfK06RSfH0rATvG22G+rzHf7QCgvKEVU0+EgsPj4eYyb0aiw+PEEkw7EYZFfsb4doQVJMSYLWUCEorhfyQEE531cGK2G99z1B0t7VxsuhmPKxH5ODrLFZuGWVKON3mbquLbEV+OmUbnVWPkgfcoa2jFvqnOGGFPLay6GCj/laHTxuGhuZ2Ldj7f92wWgYFWGvAyZTY6RkVrBxd7nqdh9MH3sNNVxIsN/TDMVqvXRf4OLg9ngnLQ/483KKhuwa3lPvhupLVA10aEiP82ROKNCBE0mKrLYZe/A7aPs8Oe52mYcjxU4NpjOuSlxLF9vB3OL/DAtcgCTDgSglQhHC6foygjjv3TnPHrBHtsvpOI9dfjhHaUsFkE1g+xwJl57rgSno8Vl2ME3hebReDr4Vb4c7Ijvr6VgF8fp6CDYTYLQRBY3NcEh2e44Ps7idj9PI2RkKatKI2by7xBkiS+vZ1AWyUuLcHG8dmusNKSx+Rjociv6rmjQozNwt4pjjDTlMOmmwmobmrvdjs3IxUcm+2KzXcSeyS2Af/7FeIEQWDXJAdE59XgakQB3+1M1OXw1TBLbLoVjyYaMe3z/W8fZ4drkflIoqjAdjFQxkxPA+ymEHm6Q0qcjWX9TLFPCPfNAl9jXIssEOjv4YePqSquRRZQVshLibMBksTyi1FYfy0WCYXd59+oyElinp8p5ve1gK4AT0tlJcVwJTwfpb2QxyWie54klcJWp/txCnNNBeyZ5oazC7xxf3U/XFjkiXm+xtD7JMRUnAVE5VTip3tJqG7s/joFJBTDSkuBcsFVVt+KoMxKTHShHie4HJaPvhbqMFDlfx+1dnBx8HUWxjnpUL7n9ch8SIuzMY6iurqioQ1vUsvxwygbvqIMSZL46cEHTHHT73FlcGsHF+uux2LVADPKfd2IKkBlYzt2T3bke1xVjW1Yfika64eYw6eHC+mSuhbMPxuJxX1NKK/RkbdZeJhQjIsLOl2q3VFa14pvbydgiI0mvh1u9Y+47W5FF2LDjTj8NMYG42mcUNkVjZh4JATmGvI4O8+DttabJEkcfJWBr28lYP80Zyzpa8rob+BweTjyJhOb7yRi/zRnrB1sLpDQl1negHGHg5Bf1YyD013Qz4J5lfqnx7DnRTpmnYrAXG8jXFzgyUio0lCQwo7xdpBgkINDANg6xlbgY/uc9xkVGLYvEPnVzbi1zAdbRtsINOrOlHfpFRi+LxBXIvJxcIYLTs9zh4k6/+BrESJEdCISb0SIYEB3o1RbH3zo9VEqdyMVPF7jh+F2ne6UP56lMgrqpWOEvTYer/VDdVM7hu8LRDCDJiZ+eJuq4uw8d7R2cDFy/3vECBhAC3SGEd9f5YuimhbMPhPBd5yoOwZYaeDOCh/cjyvGissxaG6nXzDLS4njzFw3SIuzMeFwMNJKGyi3F2ezsHuyIwZZacL/WIhQo2KfI8ZmYd9UJyhJi2PmqXDU8BFw/MzVsW+qE9Zdj0NQRkWP3nOAlQY2j7DC4gvRyKvq+UgeHapyktg71Qk7HnXOrPNjrrcRdJWk8evjFIH2b6Iuh8V+Jvj+XhKlcDe/jzGeJJUijuGIXRczPQ1Q3tCGF8mCtSq5GirDSFWWUVhyXUsHZROaj6kquDyStqHt4Axn7PS3xXwfE9jwGaMQFilxNozVZHvlvhfxJRUNbcitamIU9slms6CtLI9RTvrQUPgfB8cPo2zhbaKKrPJ6fH83AcFpf3cycrg8vEguwwh7Lcr9340tgpeJKnQowkBbO7i4EpGP+b5GlPu6GV0INTkJDKQIUW5p5+Lg68y/Al75sedFOlRkJeBl0n2TF9ApgCUX12EjTQsVE3Y+SYWitDiW9eM/RpRcXI+tD5KxYYgFVOW6zy/jcHlYcy0WTgZKWMygKYmK+pZ2zD8bib4Walg9kP8Y2tWIfBx/l4ULCzz4imuVjW2YeSoMBioy+GmM7T8i3JwNzsHWBx9waq4bhtpS33fRedWYfCwEMzwNsGeKI617prWDi/XX43A1Ih83lnpjiA2zbLKapnbMOxuJhwnFuLfSF4MZvq6LOzGFGHcoGIOsNXFlMTPB5XPyqpow6VgoniSW4PZyHyzyMxFIPJrgrAtPExWIU7xGUoyFRX4mPWqpKm9oxZqrsVhxKQYL+xhj9xSnHrejdUd2RSMWnovE6isxmO1liCdr/YQSxESI+G9FJN6I+NfRG2IHPz4dpcqqaPxHRqmkxNlYOcAMd1b4IjC9EiMPvEdkbs+dE5oKUjg33x0rB5hhyYUozD0TgcD0clQ3tQs1AnV6rjvm+xph5slwHHuXJfA5MFGXw65JDlCTk8ToA0ECiUDmmvK4v9IXtS3t8D8aikIGIzLiYp3tV9M8DDDpWAitgMViEdgy2hrzfIww9Xhor1wDcTYLuyY7wFBFBrNOh6O2uXsBZ6itFn73d8CmmwmI6uH7zv5YIT7/XOT/SoW4r5kaVg0ww+orsXw/iywWgT8mOeJ+XDHepQsmUK0cYIaapnZcjeSfDaSrJI1FfsbYHpAs0L0tJc7G8n6m2PdSsOr2zpYzY5wOyub7OUgpqcdXN+PhtuMFZpwK5zsaKcZmYYKzLt6nV6C1tRVlVd0LKOryUvAy1YSbmTokJZmPRDHFWlsBKSXUIqcI4YjOq4alpjxlLTEdJhpymOljgguLvNDXTA1XIwvxw+34v+7buIJaWGjKUwpEJEniZlTnyBQVT5NK4W2iCh9T/kIKh8vD8XdZWN6f2g1xMSwXGgqSGG7Hf3GfWlqPOzGF3Y6ddNHUxsG2h8nYPMK6xzXF7zMqcDOqAHumOPEdhWlq42DV1Rgs7WdCKSjtfpGOsvo27JrUs7D4Di4P667Hw1FPCb9QNEY9TSrB9oBknJrrDmvt7osVapvbMft0BGx0FLF9vH2Px8s+hyRJ7HuZjv2vMnBpkSet2+jZh9KPeTgWWNGfvkygU3gKR05VM+6t8mVcIPGhuA5jDgVBTlIMN5f5wFQAV0dLOxdf34rH9oBkHJrpgm+GWwnVAnUjqgCjDgTB6WPunzDlFwRB4M/JjmCzKcQbcRZWUQh8VPB4JC6F5WHw7nfgkiRebuyHOd5GvZ43U9/agYOvMzBi/3voKEnj7VcDMM/XmHJ0UoQIEV8i+sSI+Ncx7UQY7scV9Xo2zaeYqsvhwgIPbB9nhwuhuZhxKgwfivmPcgiDjY4C7q7wwTR3fcw5HYEt95Joa3/pIAgCs7wMEbDGD0EZFZhzJhIu21/A5sdnGLT7LZZciMLu52m4HV2I6LxqVDW28V3EslgEFvmZ4NoSL1wOz8O8c5ECOWiAzvGMg9OdsbivCWaeDMfFsDzGi2ZlWQlcXOgJLxMVLDgXyWg0iCAIrBlkjp/G2GLR+SjcjqauEicIAisHmOGbEVaYeyYCb9IEy0PpDnE2CwemO0NHSRqzTofzFVTGOOpg9SAzzD8XSTkmxISuCvEdj5LRzul5nhIdi/uaQFKMhZ1PUvluo68ig+9HWeObWwkCOdikxNn4eZwtdj1No7zflvUzRUF1MwISmGcrAcAMTwNUNrbhuYDum2F2Wmho5eLdJ26pdg4PD+OLMebge4w+GIS7sUXo4JKQYLMoFwKjHXRwLjgHA3e9wtWQHIGOo7dwMVBGlgDB4t3R0NoB352vGbnjqNh8JxE3oviP4jHhXXoFFp2P7NE+AGDInnfIrujZeYnJr0F/y9550sxisTDd2wQ7JjpgqN3/ZFK8Ti1DQmENvr4RjeeJhaitb/nitXEFtSivb8MwGpfExbA8uBkpUy6yHyYUg0UQGEWR4dHO4eFEYA42DrXkuy+SJPHLoxTM8jKkrKA+8CoDBioymOjSs5Di2uZ2bLoZjx9G28CI4v1+vP8BGvKSWD2Qf07Ms6RSROfV4Ngs1x6NmZAkie/vJqK4tgU/jLbmu7gNyarEhhvxODDNmW/LX0NrB+aeiYCesjT2THHs9QU5j0diW0AyroR3OmKcaPKVLobmYv31OOyd6oTZNPlJQGcr1qYb8dBVksb1JV58R8I+535cESYfC8V0DwMcneUi0PXILG/A+MPByKpowqM1fhhgyd9Jxo/a5nasvByDB3FFODjDGVvH2grUsPg5cQW1MFSWQXcfG0kxFraMEm60KaWkHv7HQnA8MAsHpjvj8AwXxo2eTOHySFyLyMeAP94iubge91f5Yvt4O6gwDJkWluZ2Ds4G/9/8+ylCxD+JSLwR8a9jiZ8Jdj5JxfgjwQgTMBRVELpGqa4t8YKzgTL8j4b0+iiVGJuFJX1N8WStHzLLGzF0byBepwq2qOwOYzVZHJ/tiq7fAS0dXGRVNOF5chmOvs3ClvtJmHEyHK47XsJ6y1MM+PMtFp+PREJh7Rf7ctRXwqM1fpCXEsOI/e8pR0K6gyAILOxjjPMLPLD/ZQY23Uxg7J4SZ7Pw42gbzPIyxKxTEbhFI8Z0MclVD6fmumHrww848IreZTHT0xB7pjhh/bVY3Ilh9h5USIixcHiGC7QUpDD7TDjfe2ampyFWDzTDnDMRyCgT3gXBZhHYP80RKSX1+O7uPx9E2yVQ3YouxKsU/vfrNHd9WGrJ4+eHHwTa/wBLDYx20MZvj/mLQ7KSYtg0zBI7nwg2eiglzsby/qbYL6D7RlKMjVleBjgXnIvSulb8+SwNbjteYNPNeCQW1YPLI/9qBZGRpP4R76CniGV9jXFukRtWjeh5hoEwGKvLIq6bz7sgyEmKoaKxDaV1PcvOqW/p4OtSY0pVYxsaWnsmItU2tyOjvBFq8t2PzDAlMreGb2OQsCjJSKKv5f+MhKwZZIHfJthDQoyF+3FF+O5+EsYeDMTJtxl/bXMruhCjHXUoF5VppQ1IKqrDRGf+7hwej8TRt1lY1s+UUpSUEGPh7gof9KcYkXibXoHEojqsoRBJ0krrkVBYi+3j7Xo8/rM9IAVDrDUxzZ1/69Xt6EK8TSvH/mnOfMWPzPJGbLoZjwW+RjDT6Flux6HXmXifUYlz8/nnwCQWdgYibxtnx3cUqLmdg4XnoqAoI4FDM5x73eHA4fLw08MPeJVSjlvLfChbokiSxO9PU7H7RTouLvSgFQwB4E1qOSYdDYGTgRL2T3NiJH5wuDxsD0jGlntJODzTBSsH0Dt7PuV+XBE23YxHf0t1XFviRTlOyI+QzEoM3/ce7Vwe9k9zFkr86aK6qR1rrsbim9sJWNbfBN4mqn8bnyIAGKjIwJ8ms+pzmts52PciHZOOhsDbRBXP1/VD/x4cJz/Cs6sw5mAQjrzNwq8T7XFkpgustAR3HwlCB5eHi6G56LvrLYIyhI8IECHi/1dE4o2Ifx0jHbTxZlN/DLPVwqLzUVh8IQpZPXxSSoWMhBi++YdHqYzUZHFlsSfWDjLH2mtx2BGQzLe1iCmDbbTgbqSMz3/WcHgkmtu5aPvo0Gjl8JBT2YQXKeV825oUpMRxaLozNgy2wA/3kvDnszSBG7M8jFXwaE0f5FU1YeKREMZBwQRBYI63EU7OccP2gGT89jiFMuy1C18zNdxc5o2rEfn45nYCbXDycDstHJrhih/vf8DpoJ4/zZEQY+HwTBeoyUlizpkIvhXYS/qaYpanAWadDu9ReLKspDhOz3NHcGYlDr/JFHo/TDFUlcX28bb46lYC36p6giDwu78DQjKrKEWe7lg5wAxPk0ooW6smuehBSUZc4Os13cMAO/35jyp0B0mSsNKSR2BGBXx2vsLJ99mob+X89Tn6FHmaJ6QEQWDtUGtY6GhCTKz3gyKZYKutgJzKph65ZgiCgLaiVI/FGwkxVo8dY41tHMhL9exc5lU1Q0VWokdNKK0dXCQV1cHVgH8bU28gJc7GeBd9/DbJBYdne+Lb4eZYN8gMDR+vZweXh/CcatqRqasR+RjloE054vUypQy1zR3wd6V3weiryPD9XHG4PPzyKAXrBpnzfT+SJLHl/gfY6Sr2WAC7H1eEN2nlWDvYgu8xZZY34sf7Sdg9xZGvI6GxjYNll6Ix08sQw+2o24PouBNTiBOB2Tgzz51vvkp2RSPmnY3EZFc9vtevtYOLJReiQRDA8VmulJXywtDG4WLF5RjkVTbh1jJvyiDrdg4PG27E42F8MW4v94GrIfW9T5IkTgflYOWVGPwy0R7rKK7Pp1Q2tGL26QgEZVTi4eo+AokmrR1cbL6TgJ8efMDqgebYPJK/44kfbRwufn2cgkUXorB6kBlOznHjm43EhKdJJRi69x1aO7h4vr4vJrjoY+/Uv4/2sVkEfp0o2Cjcy+QyDNkTiKDMStxd6Yuvh1tBuodV9p9TWNOMlVdisOBcJEY7auP5+r7/SFvVp/B4JO7HFWHwnnc4F5KLHePtcGqu2z/2fiJE/F8hEm9E/Cvpyo15+1V/aClIYeT+99hyLwmVfFo5eoNPR6l2/wOtVARBYJqHAV6u74v86iYM2RuIe7FFPXJRbB3LrF5VUoyFqe76lLPsBEFguqcBjs5yxbMPpZh2IgxFtV9a9anQVJDClcVe8DBWwZb7iXiTynxMqY+5Gu6u8MGLlDIsuRDFaMTMSksBd1f4orWDhwXn6V/Tx1wNlxd54tDrDPz5LK3HDhZJMTaOznKBsow4Nt9O5Lvd+iEWGGWvg5mnw3q0EO6qED/2Lvt/pUJ8grMe+lmoY8ONeL5ippaiFL4ZbolvbvNv4eoOHSVprB1sjh/uJaGDj1DYmVtkg6NvswSqfZcSZ8NBT4nx9gCQWtqAZZdiQJIAj0S3ok0XCj3M6PjfQF1eEqqyEkilCfemQ0tBqsetVRLsnos3Da2cHjem5FU3w6AHgaAAkFRUB0VpCeir9Kw+WlAM1JUw0EYHG4Z25siklTSgrZ2DqMwSFPIJF29p5+JOTCFmeBjw3S9Jkjj8NguL/Ux6LBBcjSwAj0dippch323uxRUhr6oJawdb9Oi9imtbsOVeEn6baA91Pk6q1g4uVl2JwSxvQ76uBJIk8c2tBGgqSGLT0J4dU0hmJb6/m4Qjs1z45teU1nUKFJPd9LGITyByO4eHzXcS0dTOwel57r2+MG9q63T0lDW04cB0Z2hQjNk0tHbgu7uJSC9rwJ0V9LkzHVwevrubhKNvs3B5kSfGOuowOqbEwjr4HwuFibos7qzwgaEq/xG4z8muaMT4j0UGj9b4YZA1dagxSZKoamxDRE41rkXkY8ejZAzfFwirH57iWVIJHqzqg5mehkILFdVN7Vh1JQbf3knEltE2OD7b9a9xMU0FKWwfZwsJMRbEPlaDuxsxE4JL6lqw9GIUNt6Mx5pBZrix1JvSLSUMTW0c7HmehiF7AiEtzsabTf2xor9Zj0bG6CBJEkEZFRhzKAg7n6RiZX8zPFvXF8Pt/lmxSISI/ytE4o2IfzVqcpLYPt4Oj9b4oaWDiwF/vMXhN5n/WKhx1yjVq4394P6xlWr/y/ReHaXSVJTGiTnu+GW8HXY8SsGCc5ECiyRd2OgoYJS9NsQpgvAIACqyEvhpjA2jfVpqyePBqj4w15TDyP3v8UzAymsJMRa2jrXFBGddrLwSg70v0hm7mEzU5XB3hS/auTz4H2Xm3tFSlMIvEzrt95OPhdKKI476Sri5zAe3Ywrx/b0kRi4fKiTF2Dg2yxXfj/p/7J11WFR5//5fM0O3AoqEhZSigIABCHZ3d3esuet26a7rrt25dne3UoKKgKIiIiglikpJ18zvD5Z9XGWYAp/9Pj9e1+Wll5wz58CcGeZzn/t939LDOQWC0vBkj4YmjNh2S+Fsoff51BXiP/dpQkJaLlsCnkndpq+LBc3r1uC7kw8Veuxxng0QCgQVOmtaNTSmU+Pa7LoZp9BjK4pDHQO+69lYrkyJGjofz/rfT8z4JI1g8iIQCP4KLVZNgK5jqMXLSnDeFCjo5PuQrPximVXEsoh/m0P9ChwG8hAan45rPaNPuqgoT2R2MDdgdAtL7san88WxcD4/FMo232hCY1IQi0t/1ucfvMTMUAvXetJDj4Ni36KpVircq8K7vCJWXonm6wocD5l5Rfxy7jHf92yikhAnFkv4/Oh9ujqaVTi+s+zyE6xN9VhQQZvVtoDnhCeks2aoi8KBtu8TnZLFlL2h/NynCW1syh8ry8gtZPSft/FsZMzCruWfU3GJmLmH7vH6XT47x7ao9IrnzNwiRm6/jVgiYd/ElhiV815Wxut3+QzefIuM3EIOTWktM68mM7c0n+deYganZnriIkcbG5SOtQ3ZEszwFnVZ3NcRXQW+59P3k+m97ibetqYcmtIai/fGpAqLxcS8zuLSo1ds9I3ls4PhdFnpT+PvL+G6+Cqjt9/mpzORbAt4TtSrLIQCAceneao0Nnfx4Us6rfCjqETMlbk+9HG2+Oi9YoCrJW5/vSa/l+NzWXGJmO2Bz+m0wh9dDTWuzfdhiHvdSg2ulkhKXS8dlvsRl5rLwcmtWDbIqUJhrzIIT0hn2NZbfHn8AX2dLbixoC2D3a1Uei1WU82/neqru5r/L2hUS49lg5zYMtqdiw9f0X6ZL8fDKne06X3KRqnOzvIiIimjSkapujWtw9V53pjoadJlpT+7g+OUevyvuttX+HWRUMD6Ec3R0ZD/A5G2hogl/ZuxuK8jCw7f58fTjyiQMZb0IX1dLDk2zYOT914wYVeI3JkXhtrq7BjrjmcjE8btvCNX7pG+ljrbx7jhZGlEvw03iXpV8YK1US09jk3z4PazVGYdCFP4e/sQLXWRzNl6gaDUHu1evybzDt1TSRBsZ1+LLz9Rhbi+ljprhrmw+urTcjOToPR7+6VfU4KfpSrkCFIXCVncz5E1155W2Dg2p6MN2wKfV6oTrjwmeDVg80jXj0YRP8RY7+MFz+XIV+y/Lb1B679B4zoGKv/Mav9rxqaK0FN1bCotl7oK3NEvj1LxRr5FaWUQ9zaHdst8P3KniYQCJrW3Y+t4T9YMdaV53Rokp+WwOSCGa49LQ75vPUtlZKuKHQQbfZ/RuqGJyiLBuutPaW9nSgcH6aMuKy4/waGOAd1l1J/LYmdQHAlpuXzfS3qe1LmIlxwOSeSr7vZSxaTg2FRWXIlm40hXlcZjUt7l88OpR4z3bMAgt/Kzd/IKSxi/M4R6xrr8KqV9SiyW8MWxCKJTslg7vLlKbWbl8TornyFbgjHR0+TPse4VPucxr7PptyEIhzr6bJQjwPnZ22z6b7yJjoYaR6f+U0SRRlGJmB9PP2LRuUg2j3Jlik/FTWfvk19UwjcnHvDdyYesGuL8kWgoFktwXXyFLisDSgOWr0Zz+l4yT1KyyPvr5l9+sfjvf6sJBfzUpzHGSuZhpWYXMGN/GHuC4/mhdxM2jXSV6ggTCASsG96cfRNbYlmjYjH5fmIGfdbfZN+teLaMcmXFEGdMVLhWyyMiKYOBm4JZcj6Kr7rbs3qoM04ygqtVJeZ1FlP23GXEttu41avJ+dltmOTdsEodPtVU82+hWryp5v8rWlsbc+qvGd/ll6PpvT6QoNiqCzRrVEufbWPcWdTHkRWXnzBoc3CltlIZ6WjwxyAnNo10ZWvAMwZvDiZGwYaYOobajPdsgKZa+W8HTcwNaFhBC0dF9HIy5+xnXoQlpNN/Q5DC2UMOdQw4PdMLkVBAr3WBcv/s1ERCfujVhGltrRm3I4QDd2QvitVFQn4b0JThLeoyaGOwzKA7cyNtjkz14EV6Hl8cjZCaB1SZiIQCfu7jiJpIyLgdd8hR4Zij36sQVzUMVhbOVkZ82c2eWQfCpf6cTPU1WdzXke9OPVRoxMm9fk26N63Dz2cipW5Tz1iX0a3rsficYtXhytCxcW0WdLZFJCj9QF8e5X14bmNjyuG7iZ+kDUxeGpsbEKmq88agcpw3lTE2pXrmjWrOG4lEQljCpxVvjoUlYW9mUGF+h0kNXYa1bsj3/V1Y3NuRdnZmvMzIJTE1G3cL6XfO7ydmEJaQzliP+iqdY0JqLruC4xnn1UDq4vvhi0wO3U3kp95NVHItPU3J4o9LT1gx2FmqoJCQmsuXxyP4fWAzqYvj5IxcZu4P4/tejVVaqOYUFDN+ZwhWxtrM6Vh+SHNRiZhp+0JREwlZO6x8h49EIuHbUw8Ji09n38SWld7kk5Sey+BNwTjUMWDDiOYVLpJD49MYuCmIfi4WLB/kJDM7Jij2Lf3WBzGguSWbR7nK5Zx5k1XAiK23uf08jTMzvaS6lcoj7m0Onx0I+2tMyqvcwGehUMAgV0vURAJyC0tkvv+Y6msyxF0599m5iJd0XulPSYmEVUNd6O1kLvMar6mrQcsKKuvf5Rfx/amHfHXiAZ0a1+bCnDZ4NKq4wl1RXr/LZ8GR+wzZfAtPa2OuLyjfKVSZJGfksfBoBD3WBFJLXwvfBW1Z0MVOpRyyaqr5v0a1eFPN/3cIhQL6ulhwbb4PPZqaM2V3KBN2hqjU5lMRZaNUV+f70LJBzSpppfKyMeHSHG+crIz47uRD1l57KjUHpDxmtG/00QcsoQAaGOtgrKdBl1X++EW/kbJ3xdQz1uXoVA+8GpkwadddToQr1tZkqK3OllFuDHGzYtCmYJn13u8z0NWKHePc+f1iFD+efiQzRFkgEDCrgw0/9WnCpN13ZbZX1dTVYP+kVuQXlTB86y2FMluURUNNyIYRzdFUEzF5z12VRgC/6eGAh7Uxs/aHV7loMKpVPSxraPP9KemjUd2b1sHbxpSvjinWiPVVN3tuP0+rMPR4Znsbol5lce2x6nXv0rj5OJFl5+7jGxqNoaYQc0MtPpxIVBcJMCon86ZF/ZroaqpVSh19ZdG4jgFRL7NUGg00M9TmVTk11YpQGZk32fnFMoOiZRGfmks9FcSbhLRc3uUV08TcUKXzkBexWMKx0CSZocTvU8vYEDU1EdoaamiJBPxxKZqv9gdzwD+WtMx/iucnwl8wpnV9aqgoFCy9GEUfZ3OpPxexWMK3Jx8y0ashDWVkplREYbGYOYfuMdazvtSckMJiMbMOhNHPxUJq+HBBcQnzD99nkJslwyrIA5JFcYmYGfvDMNJRZ3Ef6W6ab08+JOVdAdvGuJUrmkgkEhafe4zfkzfsm9Sq0kdVikvEjPnzDt62pjLFmEuPXjFq+x3md7ZjQRfplfBlHLiTwISdd/mmuwPT2zWSa+z0XmIGvdYGUsdIi+PTPLBSIIfqXMRLeq0NpG5NXZnOlYXd7LEw0kbWKWmqCfmmh+IBx2+zC5i+L5TvTj3kpz5N2DiyuVS3jbxIJBLORiTTcbkfsW+yWTfMhTkdbSs1sLqguISNvrG0X+5HXlEJV+Z5M6+znULubEVJyy7g1/OPab/cl9yiEi7N8WZRX8cqH8uqppp/I9XiTTX/31JWCez7eVusaurww+lHfHPiAW+yVGtxkoaOhhpfVGErlY6GGt/1bMzCbvac/esDirQxlQ8x0FJnfmfbf7hvREIBW0a7sX2MO3M72jJjXxjfnXyoVPuMhpqQr7o78G1PB34+E8n8w/cVco0IhQJmtrdh40hXFp2LZOWVJ3Iv5lo1NObUDC+CYt8ybmcImbmyRbP+zUurxH8684jtAc8qFBJ0NdVYM8wFqxo6DNwUpHT+kCJoqYvYOsaNnIISZh0IV0ioex+RUMBX3RxIyy3kmyquEBcKBawY7MyNqNecDH8hdbuf+zQh4kWm3LXvAMZ6mnzbw4EdN5+TV1i+mGWorc7cjjb8ev5xpQlVEokEv4iXrL/6mJm7AvjzZjzv8gvp0cKCmwvbkpCeR4mEfwg4IoGg3HGGsju9gU+VE0nf51FyZqW4qRqY6OJc14i4t8qP1tUx1KKmjmoLkho66iq7Zgy11cvNGpKX3IJi6hnrqBRYHJGUSc9mdT6Ztf/O8zQMddTxsZPflVCGkY4GOyd5MNHLnNoGWtx8lsK8g2F8vjOAtZev8fhFOvvvJDDaQ3q4sDzcjUvjxpPXzK8gV+bU/Rek5RQyo10jmY8XnpAu9Xf4+htPaWiiy9wKwo7/uBRFUYmEr7tLzyD7+UwkOYUlzFEhNLmsNetlRj4bR7qiUY7zVSKRsOhcJM/fZLNrvLtUd8GKK9GcjUhm/6SWco0bKYqaSMi2Me781LtJhTkpe27Fl44YDXFmVAWh0wAlYgmLz0ay9GIUO8a5M7iCqvb3OXQngW9PPmBimwasGuIsdxhzflFJqRPleATLBzvxbc/GaMp4HWqqidg8ylWmoGRVU4fuCrSMlQksnVf6A3B5rjc9m8l228giITWXsTtC+PH0I77u7sDeCS1VEjs/RCKRcOnRK6bvC+PM/WS2j3Fj/fDmMke3VCG3sJj1N2LwWeZLdn4RR6d6sHaYC/WVdINXU83/AtXiTTX/32Osp8mPvZuwuK8jb7MLaLfMl3XXn0pdBKrK+61UFx+9qvRRKmcrI87M8qKbYx0Gbw7m1/OP5fpeRrSs9/fiRlNNyMKu9tjU1v+75er8Z22IevWOHmsCCU9IV+rc2tvX5sJsb5LSc+m1LlDhPA0fW1POzPTietRrhmwJ5mWmfEJJXWMdjk3zQEMkpN+GmzyTY3zLs5EJx6Z6sD3wOZ8fjahQINFUE7FmmAutGxozcGMQMVLaWyoTPU01do1rQWJaLguO3FfaHaGrqcb2Me4EPH3LBt/YSj7Lf1LbQIs/Bjrx3cmHUsOkjXQ0WDqgKSuvRpNcQY7Nhwxobkl2QUmFNejDWtRFJBSw91a8wuf+IVlZefRfF8Cyq494lZ6NZ8Na/NbXkZ8HuDPWxxltbW1GNa/Fox860d/VEo2/7soWiSUYSmmb6uNswaGQJNJVdHB9f+qRwkHh5aEmEpJbUKzS6FQdQy38n75RySFWLJaoPHr1+FWWSqJJQnoukcnvVMqLuP08tdLHWSri8N1EPKxNFHYEvI+HQyPm9HRh9aiWDGphhpYePIwTs+Pmc9o0NKaOofJigVgsYdG5x0z1sZZaw52WU8hPZyL5oVdjmQv1zNwipuwJJaAcATQ0Po0t/s+Z2d6mXKEE4HpUCgfuJLJuuIvUa+XI3UTOP3gpc3RIFhv9YrkelcKOcdJFmQ2+sZyNeMmyQc5Sw343+saw/3YC+ya2UqhhSVEamOhKFRckEgkrLj/h0J0E9kxoUWEINJRWq0/efZfrT15zcronrSoY/ymjsFjMNycesPTSE77q5sDENg3lFjviU3MYuCmI+4kZnPusDZ1lnN/72NTW5+tu9lIFHHWRgB96NZY7/PdNVgELjtzn+1OPWNTHkQ0jXFXOoCksFrP+RgxdVvljbqTNtXlt6etSueNLT15lMXL7bb4+/oAO9rU4PdOzwrEtVSkqEbPnVjw+f/hyJTKFzaNc+bV/MxwtPo1rsZpq/s1UizfVVPMXDU312DzKjT/HunMlMoV2yyo/ZLiMslGqNUOd/x6l+uHUw0obpdJQEzK7ow1nZnpxNy6Nrqv9ZWb7aKgJ/24uaGJuwHjPBv/4el1jHQ5Obs0QdyuGbb3F8stPlHJ8mBmW1oH3djKn+5oAmv5wiXmH7vFn4HNuxryV2aRkVVOHI1M9aGSqR6+1gQTHyg4khtLg3C2j3ejUuDZ9198s9wP+h9ia6XNihieRye8YvzOkwipxkVDA4r6ODHKzYuCmYKUFLkUw1FFnz4SWPEjK5NuTD5V2zpgZarF9rBsbfWOrvEK8Y+Pa9GtuwayD0h1D7e1r096+FguPy+8GEv71898W+ExqtpKaqNTevvraU6WdKRKJhOCoZL4/GYK1iSYnZ7dj0SB3hrWxw9TE6B/bLhrsjq62Br8PaMa8zrYIBKV3nKWN79Q30aWZpSGnVXwOfGxN8Y+unCwvVXNvTPQ0URMKSFGhLvzfEFhcOjIlfQErD6HxGTT/RHk32QXFXHj4igHN5R+ZqgiRSEQPFwcWDWzD5smdaFJbm7jUN/y05ByhoaFKPeaZiGRev8tnkpTKa4DfL0bhVq+GzPpmgEXnImlsbkA/F4t//H9OQTFzD91nfmdb7MzKr0Z+mZnH/MP3WdS3iVS3wsMXmXx/6hFrhrmo5DY4de8FG27E8udYd6lB9ftvJ7DJL5bd41tQV8qo3raAZ1x48IrdE1qo1HCkCkUlYuYfuc+xsBesHOKMa72Ka6uT0nMZuDGIgmIxJ6Z5yuWgSHmXz7Ctt4hIyuTMLC88FchuufDgJT3XBuJevyZHpio2YgWl18WlR68w0FL7KMNMKIBmlkZy5e1IJBJO30+m80o/9LXUuTLXmx7N5HfrSCMkLo1Ju+9y+l4yeye2YEn/ppUaVJ2eU8h3Jx/Se10gDmYGXF/QluEt61VZm5NYXPpz6rjCj503n7OojyMnpnvgYV25eT3VVPN/mWrxpppqPqBFg5qcmO7J1z0cWHklmp5rA7kZUzWhxu+PUj17m1Ppo1Q2tfU5MtWDsR71mbTrLt/LEIi6OZrxWftGrBvevNw7SSKhgKk+1pyY7smVyBQWHLmvVFaQSChgTkdbWtSvQVZBMcfDX7D0YhQTdoXgtvgqjj9cos+6QL4/9ZADdxIIjU//h3CipS7i94HNmN/ZjvE7Q9jiHyvXIl8kFPBVdwe+79mY3y9GsTs4TuZ+tQ20ODy1NcK/qsQrcvsIBALmdbJldgcbRm2/I5dApCqm+prsndiSsPh01lx7qrSA08TckDXDnP+qEK9a4enr7g7kF5aw8kq01G0WdrXn2Zsc9inQwORoYchQ97p8f0q6kNXWrhbOVkZsVNBl9DYjm0O3nrLgYAh/3nyOsYE+k9vZIBLJvvsuEJS+bn7r7whQYcPXAFdLjoUplgv1Id62pgQ8fSMz40keVG2cEgoF1FYxtFhDJKSwUqrCVRFvclTKu8kuKObJq3c0l7P+WFUuPnxFPWMdGpsbVMnj93U2x8MSrmXCgiOvmPfnObYdOCf3/vlFJSy9EMUXXe2kOmrCEtI5dS+ZHypohSrjxpPXXHr4iiX9P86OWXwuEgsj7Y9uSJRRXCLm2xMPGehqRT+X8sWu9JxCpu4NZWb7RgqF437IrdhUvjz2gHXDXaRm/Fx48JLF5yLZPsYdhzrlP3/7bsez+upTFvdz/GQZSh+SXVDMhF13iXqZxYnpHtjULl8YKyMsIZ3vTj7ErX4Ndoxzl0tkuBuXRs+1gdQ31uWInC1UUJrLsuzSE74+8YA/Bjbjh15NpDqupHEu4iVdVwVgVVOXEzM8P3JaCQUCvu8pu6r7dVY+U/eG8tPpR/zSryk/9m6iUjsZlF6PC49GMObPO7SzM+XsZ14yhTNFKCopdde1XebLi4w8zs9uw7c9G0t1jaqKRCIh4Okbeq0LZMn5x8xo24hLc7zp6mhWpQHI1VTzf5Fq8eb/AAkJCSxYsAAHBwd0dXWpWbMmLVq0YNmyZeTmyj9WUB4//vgjAoFArj++vr4yHy81NZUffvgBJycnDA0NMTAwwMnJiR9++IHUVPkcEv8GhEIBvZ3MuTbfh74u5sw7fI/p+0KJrqJQ4/dHqSq7lUokFDDOswEX53hTVCym0wo/qSMVAoGAeZ3tZNZWO9Qx4NRMT+oYaNF73U22Bz5XSnBaP8L177tZBcVi8otKF2jZBcXcT8pkT3A8P5+JZPjWWzT98TJui68QGp/297kOa1GXA5NbsfNmHDP2h8nd+DTQzYofezdhzbWnfHvyoUwHkZ6mGtvGuOFsZUS/9UE8luFEGOfZgF/6OfLNiYecrWInC5Q2X20a1Zy9txNYe1362JAs2tvXZmFXeybvvit1rKky0FIXsXa4C7uC4qQeR19Lnd8HNmPJ+ccKncu8zrZEp2RzJuKl1G1+7d+UaW2t5Xq8w7efsfj0A74+HkFoXAbN6xnzW/9mfNvHBVszxT4sD3Gvx/CWVtxLkv7a7tGsDk9eZakUoN7UwhCRUMB9OTOvKqIyGqfMjVSrC9dUF1KggvNGIpH8FVis/MIjPjVXqgNCHu4nZmBmoIWZ4acJ2FQ0qFhRDA0NWTSsB/6/9WBECygUwE0F7nEcvJOAnZk+fZwsyv16cYmY704+ZHpba5luiXf5RXx17AHf9HD4aIzramRK6ejRYCepoy1rrj0lLjWHuZ3Kb3sqEUuYfegeDnUMmOYj3/tGecS8zuKr4xEs6tuEtnblV6IHxbxl3uH7rBnqQosG5b+/HAtN4tdzj9kxzp1mlkZKn48qvM7KZ+iWYMRiCYemyA5JPnXvBSO33cbbxoRFfRxljvJJJBL23Ipn1PY7zGrfiGWDmsk9ppaQmsugTcH4Rb/h5AxPqcHT0sguKGb+4ft8feIBS/o35Y9BTtQ31mX1UGfU/wowUxMK8LEzrbBpTCKRcOreCzqv9EdDTcSVeT50b6qa20YiKQ0h77DCjzfZBVya481YzwYqjUZ+iH/0G4Zvvc2eW/GsGurMn2Pdsa7E7JwPCU9IZ9jWW6y4Ek1fZwtuLGjLYHerKnP3VFPN/3WqLhq8mkrh3LlzjBgxgsz3Wh5yc3MJCQkhJCSEbdu2cf78eRo2lG47/lSEhITQp08fXr7856IpIiKCiIgItm3bxqlTp3Bzc/svnaHiaKmLmOxtzQBXS9Zdj6HX2kD6N7dgbidbqTPoylI2SuVjZ8q66zEM2hTM6Nb1mNa2UaXc7bCqqcOv/ZtyIvwFC49FcOreC37s3UTp70NTTcSX3R1o71Cb+Ufuce1xCn8MclIoMNFUX5OxnvXZExxf7uJMAuS9l5WRXyTG6gO7elnGz2cHw+mzLpAto1yxrlXxHUAA13o1OTnDk0m7Qxm9/Q4bRjSvsDVFXSRkSf+mrL8Rw+BNwWwY2bzCO7B9nC0w0lZn+r4w0vOKZAY4qkoDEz32TmjJkC3B6GqqMcGr/LvMshjjUZ/nb3P4/vRDVg91qbI7bba19bmxoG2FH/o9G5kwwNWSBUfvc3BSK7lyBQy01Pm2hwOLzkbS1s603DwJea/Rr46E8fhVFh3sajHSsy5tbMvPEXj9Ll/u1ouJXg3puiqAb3sUlNssYqClTucmZhwNS+KrbtJDUytCJBTgZWOKX/Rble/G2pkZ8Da7gNdZ+Uq/V5gZapMsZz5VeWiIRCqNTeUXiSkWS1Qam0pIy1Vp4RUWn/7JRqaS0nO5G5/G6mHOn+R4E/v3ACDl9Wv27z/H8OE9Ktz+dVY+f1x6wo5xLaS+pvfeiie3sITJPrI/2/x67jE2tfUY8kHo7dvsAr48HsHPfZpIfc0Hxbxla8BzTszwkNqWs9E3lqS0XE7O9JQ72+RDXmflM3ZHCH2dLRjoWn4474OkTKbsCWVRX8dy66uh1A3y3amHbB3thpuUxqyq5tmbbMbsuINr3Rr8PtCpQkeLWCxh1dVodtyMY8OI5lJFq/fJLyp1zZy894Jd41tIFbHK4+LDV3x+9D4DmlvyVXd7hVuWQuPTmXvoHpY1tLk4p80/xMAODrXp39yS42FJiCXwTQWh1q+z8vn2xEPCEtL5rX9TuQWkohIxaTmFvMkq4E12QenfWQW8ycrnfmImD15kYqClxi/9mla6K+X52xx+ORfJ7edpfNXNnkFuVpUqCn1IzOss/rj0hICnbxnv2YDJPg2rK7+rqUYOqmXNfzH3799n8ODBZGZmoqenxy+//EJQUBDXrl1j0qRJADx58oQePXqQnS07gFUWDx48qPCPu7u71H1fvHhBr169ePnyJWpqanzxxRf4+/vj7+/PF198gZqaGsnJyfTs2ZMXL6Q3zfxbMdbV5IdeTbg4x5uM3CLa/eHL6qtPlWpekkXZKNXZWV48Sn5H+2W+HLmbWCmjVAKBgP7NLbk6zwehQECnFf4cvpuoUstQiwY1uTDbG6saOnRd5c/xsCSFHm96W9kNIlB6p2vtcJdyF8nGeprsHt+S/s0t6bP+JhceSHddvI9lDR2OTm2NgbYafTfclBk0LBCUtl793LcJa6/FcPhuYoXb+9jVYveEFiy79ESlkSZ5sTPTZ9e4Fqy6Es2hEPnHjT7ku56N0VQTMm1vaJVWiMsjeHzZzZ6Ud/nsCIqT+3F7O5ljU0uvwrGsigiNecWS0/d4k13ImiHOzOrsgLedZbkflMMT0um8yl/u9rSGpnq0bFiTg3ekPz8DmltwMvyFShXdPram+EWrPranp6lGfWNdlUan6hiq5rzRUFPNeZNVUDpyqadCVXhcag71VGiaCktI/2QjUyfDX+DVyKTSbzBUhEQiof/mEL6OgPpfnuPiXekOwJVXomljYyp1Uf46K5/ll6P5sXcTmYvvgKdvOBvx8qNxKYlEwlfHH9CiQU36Opfv7nmTVcDsQ/f4tqcD9mbljyddjUxhZ9BzNo10VXphmVtYzISdd3GrV4P5nctvqHr2JptF5yKZ3dFGqmPq6l+jyuuHN1co96UyCU9IZ+CmYLo3rcOKwc4VCjf5RSXMOhjOiXsvODbdQy7hJjkjjyGbg4l5nc2ZWV5yCzeFxWJ+OvOIz4/eZ+mAZnJdO+9TXCxm1dVoRmy7xchWddk7oWW5Ydw/9mqCmYEW/V0sys1GkkgknAhPYtCmYLTURVye6yNVuMnMLeKzA+H0XX8Tr6XXafLDRWy+uUDLX6/Rf0MQM/aF8ePpR6y+Gs3OoHjCEzOQAGc/86Jb0zqVJty8yy/i1/OP6brKn9oGWvj+lWtTVcJNckYeC49G0GNNILX0S4+3oItdtXBTTTVyUi3e/IuZM2cOubm5qKmpcfnyZb7++mtat25N+/bt2bJlC7///jsAUVFRrFixQuXjOTo6VvhHV1d6sNw333xDSkoKAPv372fp0qW0adOGNm3asHTpUvbv3w9ASkoK3333ncrn+t+igYkuG0e6smt8C248eU3bP3w5HJKo0iJLGg3/GqVa3NeRlVeiGbgpiIcvKmeUykRPk3XDm7N8kBMrLkczavsdlcZk9DTVWDqwGSsHO/Pr+cdM2xtGmpyNOTV1NZjg1eAfNeUfoqkmZHTrerSr4MOfSChgRrtGLBvkzBdHI1hy4bFcmR+6mmpsHOFKr2bm9NsQxI0nr2Xu08/FktkdG7H4bCQrr0RXKMq41qvJoSmt2Hsrnp/ORFZJAPb7OFkZ/VVzHql0+LDor1rvjNwivj1ZtRXistDRUGPZICeWXXoiNYj4QwQCAT/3cSQoJpVIJcYPQ+IzEAiFzO9iR91aFedJOFsZUc9Yl3235W+wGt26PvvvJEi9PtvYmCKRQKAKWVveNiY8SMpQubkKVB+dqmOoRXKGqoHFyrdVZecXo6kmVDjzooyiEjHJGfnUU7KeViyWEJbwacKKJRIJx8JeMKAKR6bKw+/JG+rXKW2fqQX8evRJudtFvXrHxYev+LKbvdTHWnI+Ci8bE3xsK86WycovYumFKBZ2s/8oQLhYLMG2th6/9P04AwdKn5N5h+/RokFNhreoW+7jx73NYe7he/zQqwm2UoKOZVFcImbW/nB0NUUsHdis3HN5lZnPqO13aF63BhOlhDcHPH3DrAPhrBjsRDt72SJIVVAmHs3uYMNX3RwqdCG9fpfPkM3BpGTmc3K6J7Yy8nAAgmNT6bU2EIc6Bmwe7Sp3k1liWi6DNgUREpfG2VleCjvkElJzGbS5dBz66FQPJntbS/3etDVEXJzjzZL+TT/62ut3+UzaHcov56L4rmdj1gxzqbBdTiiE61GvuZeYQVJ6HjkF/3mPKywRk1tYQm5hCYUlpb9/RUIBW0a5Ym5UOdXcJWIJh0ISaL/Ml4ikDE5M9+SXfk1VzuORRlp2Ib+ef0z75b7kFpVwaY43i/o6yu1araaaakqpFm/+pYSEhPydMTNhwgRat2790Tbz58/HwaHUtrlq1SqKiiqnqUhRUlJS2Lt3LwBdunRh0KBBH20zaNAgunTpAsDu3bv/Fnr+r+JWvyYnpnvwfa/GrL3xlJn7w/CvhLvcH1I2SnV1vg+tGhozYGNQaehwbuU81x0b1+byPG/qGeswcFMQ2wOeqSREdWxcm0tzvJEgYcGR+1yPku95nuJtjbSbSAKgvrEuX8o5QtLV0YyTMz25/vg1o/+8Q6qM9ioozTha0MWOxX0dmXvwHntuyQ4y9mxkytFpHhwNTWLBkYgKHSr2ZgYcm+aB75PXzDt8T6mWLkVo2dCYDSOa88XRCK49Vu61pqupxvaxbvhFv2GjX9VWiMvCvX5NRraqy+KzkXLv06iWHu3tTfn25EOFBbOpHez5smczHMxlL7YFAgGftW/EFv/nctdht7evRX1jXXylCIUioYABzS3xk0NIlEYtAy1sa+urJACV4WCmT+xr6SHLsqhjqMWrd8qPTWmqqRZYXBpWrPxd3RfpeYgEAsyUXGQ8e5uNkbY6jaWEz1Ym9xMzAQkd5WhnqiwkEgnLr0TjY2tK3G89mNwIRkiZ2ly0NwCL/CKpLUO3n6XyJCWL73rKfr9fejEKE31NRpQjvqiLhHzexV7qKOxm/2fEp+aWG3AMpW6ZKXtCGexmRS8nc5nnUh4SiYSfzkSSkJbL5pFu5TpBMnILGf3nbbwambCwq125j3P7WSqrrz5lSX9HuqmYmaIs+27HM+tAOAs62zHGo36F20YmZ9Jn/U2sa+mxb1JLmWKARCJhe+Bzxu8MYX5nO34b0Exu18zVyBT6rr+Jk5URR6d6KFSXLpFIOHI3sbT10tKIVUNc5Kqi1tVU+0cei0Qi4XhYEp1W+qOrKeLKXG+5Xn/6Wur81Fu+IGU1oYA2NiZyta7Jw924NPqsD2Tt9RgW93XkwKRWVRZunltYzPobMbRddoPX7/I5OtWDtcNc5Goaq6aaaj6mWrz5l3Ly5Mm//z1u3LhytxEKhYwePRqA9PR0uQKFq4LTp09TUlK6aJF2rgBjx44FoKSkhNOnT1fZ+Xx/6iHP5LxDrwoCgYCezcy5Oq9UWJl1IJzRf94h6pVq4Z7lUTZKdX52G56/zaH9cl9OhFVOK5WBljq/9GvKhhGlgbf9N9xU6Xsw1tNk00hXujmaMfvAPb46HiFzpMRQR52p3tblu28EUFNXnTdyiDBlWJvqcXKGJzV0NOi5NpB7iRly7dfH2YLd41uw5loMXx57IHNkyLa2PsenexD1qrRK/F0FVeJlFefRKdlM2n2XvELlnQTy0NauFisGOzHv8H1uPVNuAV/HUJvtY9zZcCOWcxUEAH8K5ne24/eBTgrtM6uDDSnvCjiqYnuTLNrb16J1w5ocvSvfcUozaUz482ac1G36upiz73ZChdeULDo1rl0po1NNzA0JT1S+gczcSJuCIuXFF001IXUM5M/S+pCcgmIclHROQGnTVBNzA0RK5p2EJWRgqq+ptPNHEY6EJtKygbHc4a7LLj3hySvVgvivRKZgqq/BqFb1AZg4sQdTppSfe3PzLaSL+fszw/sUlYj57tRD+jiZy3QXBMW+5XjYC37u7ahwDk1oXBqrr0WzdphLuaMaEomEL489wFBHvUKHkCy2Bjzj4qNXUpuVcguLGb8zhPrGuvzSz1HqWOaEXXcZ5GZJXylNWFWJRCJh+eUn/H7xCbvGt5ApHl1+9IpBm4KZ6mPN8kFOMkWYvMIS5hy6xxb/WPZNasnwluW7oD6ksFjMorORzD10j1/7NeXnPo5yX/NQKprN3B/O0otRrBnmzM99HKW2nlVEyrt8Ju66y6/no/h9YDNWD3WpMDvvQ/o3t8DR3ABZE0pCoYBf+33s9lGUFxl5zNwfxvR9YXRzrMPVeaVjXVXR6FRUImbPrXh8/vDlcmQKm0a5smqofAJZZSCRSAiNq9rmzGqq+W9QLd78SwkICABAV1cXV1dXqdv5+Pj8/e/AwMAqP6/yKDtX+Of5fMinOlctdRFdVwcw//D9Km3MKUNTTcQYj/r4fd4W21p69Fl3k4VHI0h5p/yYgDTKWql+6efI4btJlTpK5Va/Jhdmt8GjkQl9199k+eUnFCg5qiAQCBjkZsWFOaViU7fVAdyNS6twnwltGny0OFIXCVg+yIn6Jnp0Xx0gtSWrPHQ11Vg33IXxng0YtuUW+28nyDX+08zKiNMzPYl8+Y6R227LdO7UNtDi0JTWiIQCBsuoEjfV1+TglFZIJBLmHblXaQ4qaXRrWoef+zRh4q5QwhKU+xDjaGHI6qHOfH70vtKPURloqYvKDfitCB0NNb7r2ZjfLkSRkav6+JA0BAIB3ZvWYb1vjNwZQUPdrbgbny41Z8nOzADb2vqcV0E0a21tjH/0G5XH3pqYG/D8bY7SGV9mhlo8fZ0ttzPpQ9RFQp7KyKOqiHf5RWSqIIIlpOViJEetsTTCEz5NWHFBcQln7ifL3TKVkJrLFv9nKoWSi8USVlyJxtvGVK7F78mhFrwAbL+5yIOofzr6dgXFIZHAeBlh67mFxXx57AGfd7FTuAEsI7eQb04+4NseDlKbgnYGxXH7eSrrhzdXOvfj/MOX7LuVwJ9j3D8a6YLShe30fWFoqAlZM8yl3Gadhy8yGfPnHT7vYscQd/lEjcqkqETM50cjOB72gmPTWleYPyORSNjkF8vcQ/dYPtiJMR71ZQoCCak59N8YRHJGHmdmecmdCZWYlsugzcEEx6ZyZpYXXRzNFPq+gmLf0nVVAHlFJVyc4017e8XdLGWtT51W+GGgrc7Ved50aaLYeUDp744/BjkhQPrPSlNNyPxOtjJbQCsir7CElVei6bjcDw01IWdmeTGjXSOFBC95EYslnL6fTMcVfuy8+ZxFfRw5Od0DD+tPk9NUVjs+eHMwC4/f/yTHrKaaT0m1ePMv5fHjxwA0atQINTXpIYv29v+5K1S2j7J06tQJY2NjNDQ0qFWrFm3btuW3334jPb3iBVvZcQ0NDTEzk/7Lq06dOhgYGFTKuVbE190duDLXG4COK/348lgESelVL+IY6Wjwbc/GXJ7rTXZhMe2W+bLiSrTcQabyIhAI6OpYh+1j3WjV0JiBmypvlEpLXcTCrvYcnerBjSev6bEm8O9qbmWwrKHD/omtGN26HqO232HpxSipgpC+ljoz2jX6232jqSakr4sF/ZtbsqR/Uxb3dWTB4fv8ePqR3ItAgUDAJO+G/DnWnfMPXrLwaIRc+9Yx1ObwlNaY6mvSZ/1NmXem9TTV2D7GDZe6RvRdf7PCnBUDLXU2j3KjqFjC4M3BVSLyvU8fZws+72LHuB0hMivOpdHBoTafd7H7q0Jc+fGZ/wZdmtSmU+ParLhcfgZH5R3HDF1NNY7L6fIx1tOkR9M67AmWnpUzoLkFx1RwDbnVq0l2QTFRKjorTPU1MdbV4PFL5R7HRFcTDZGQl0qGFmupWBX+Lr9YpbDi+NRchcYxPiQsPoPmdY2U3l9erj9+TQ1dDVzlFIp2B8fRuUltlerLzz98SWZeEUOl5MZ8iLOzM9E/d2KsLjS1/0/tdsq7fE7fT+ZnOWqkf78YRS19Tca0rq/QuUokEr44GoGFkQ4jWpbf/hcSl8bvF5+wYURzhcXi9x9j/qH7fN+rMU0tP3YZiMWlY8VvsgrYOtqt3AV0dEoWo7bfZka7RjLHlKqC7IJiJuy6y6Pkdxyf7kGjChocC4vFfHE0gh03n3NoSmu5mpX8o98wbmcIHtbG7JvYSu5w7SuRKfRcG0hTCwOOT/dQaPSmoKiEJecfM3HXXWa0b8T2MW6YKJHv8ioznxn7wtjkF8vywc6sHOKMkY78bpsPqWOoJVUYE/z1dVmCpjQkklIhpf1yX/yi37B/UktWDHamdhXkzEgkEvyj39BrXSBLzj9mRttGXJrjXemtWBUd/3pUCv02BDHrQDg+tqacmO5Z5cetpppPTbV48y8kPz+ft29LxxwsLSu+g1ajRo2/g4QTEytuvpHF1atXSUtLo6ioiDdv3uDn58dXX31Fw4YNOXXqlNT9yo4r61wBrKyslDrXpKSkCv98WE9ez1iX5YOduDi7DflFJXRY7se3Jx/wMkP53AV5qWesy/rhzdkzoSU3Y97SdpkvR+8myhWeqwhlo1TnPvvPKNXhSmqlcrQw5OR0Twa6WjJy2x1+OPWQLCXvXAuFAia2acipmZ74R7+hzzrpY1ljPeqjLhIioPRu/aI+jn9/rZeTOec+a0NYQjr9NwQpNBrX2tqYPwY1I/p1NoM2Bcsl5mlriFg33IVBrlYM2BgkMztGTSTk135NmejVkLE7QirMQNJSF7FpZHOaWhoyYGMQz99WrSAyxqM+k70bMmr7baVHCsd5NmCoe13mHLpHZt5/J19LGQQCAZPaNOTGkzfEp1bdOKVQKGBGO2s2+MbK/Vof1boex8JekC1F4O3tbMH9xEzilRTMNNSEtG5orHIel0AgoLG5odKhxUKhADNDLZKVfP9VtSq8NPNGBfEmLRcrJZum3uUXEf0665M0TR0LS6K/S/mtaB+SU1DMobuJjFVBGCgRS1h5JZqZ7RW7g6+hocF33/1zrGr79ce8TcnExlD676/0nEIGbrzJzqB4fh/YTOFxqd3B8UQkZZY6Hcr5Gb1+l8+S84/5qrs9rvWUq+GOfVM6FvttT4dy80kkEglrrz/l4YtMdo5rUW4W07M32QzfepsxHvWZ4mP90dermpR3eUzYGUKJWMzhKa0qXOin5RQyctttol5lcXqml8yRGIlEwgbfGKbuDWV620Z817OxXOOEhcViFv81JrW4ryOL+zZV6JqLeZ1Fvw03eZGRx+mZnoxqVU9hQaEsI6fTSj+01EUcmdKaTlIq3eXlelQKnVb4U1BUgonexwKQSChg+WAnpRxgD5IyGbQpmF/ORfJFVzuOT/PApYreh8IT0hm+9TbbAp7Tx9mcGwvaMtjdqlxHWWUjFku49jiFXusC+eJoBN0czbi5sD0z29uolHVWTTX/VqrFm38hWVn/ubupp/dxFeGHlIk3ytaFN23alO+++44zZ84QGhrKrVu32LVrF507dwYgIyODAQMGcOHChQrPtyrP1crKqsI/LVq0KHe/hqZ6rBrqwtlZXmQXFNNzXSA/nn7E6yp2OwC41qvB0amt+aWvI2tvxNB9TQA3nryu9Oae90epVlViK5WaSMhUH2vOz25DfFouQ7fckquJSRq2tfU5Md2Tjg61WXQmks1+sR+FI+tqqvFZh0aoi4RsK+eOZF1jHY5O9cCzkTG9192U2+UApW6aQ1Na0czSkF5rAwl4KntBKxAImN3RhqUDmvHZgXA2+8VW+PyVOX2+7u7AlD2hFVaJq4mE/DGwGd2b1mFQJY6/SWN6W2sGuloxctttpZ1oczraYKitzox9YVUeulyZvMvOo24NdYqKKtcF9yG9mpUGm56JkK/ly8XKiPomOpwIf1Hu12vqatDO3pRjYeV/XR68bU3xl+Nal0XjOgYq1YWbG6kg3qgJKRZLlA5Tz8ovUulDfEJqrtI14RGJmZgbald5o8rb7AL8ot/Qv3n5tdgfciL8BXVr6sjt0imPU/deUFAsZpCrldKPUUYLvVReFsHElbdJS/un27O4RMzOm8/x+O06d+Mz0BAJyq1proiHLzL57UKU1AagsjEma1M9RrUq35Uji7fZBYzbEcJQ97pSnT3rrsew73YCO8a5l+vsSUzLZcS22wx0tWR2BxulzkMVYt9kM2BjMI3NDdgxtnxxqYyY11n0XX8TE30NDk9pLdPNkV1QzPR9Yey7lcDhKa3lbkRLSs9lxLZb3PxrTEqRAGmJRMKe4Dh6r7tJG1tTVgx2rtBFJI2XmXmM2xnCH5eesHKwMyuGOGOkQLbNh7zKzGfa3lDmHrrPzPaNODLVg9VDXVB7T5DUEAnp42yusJD4OiufL47eZ8mFx7RqaMz1+W3p52KpsNgpDzGvs5m6J5ThW2/TvJ4Ra4e7MNnbukrGsT6kRCzhbEQy3dcEsO56DP1cLAn4oj1TfKzRVcFpWU01/3aqxZt/Ifn5/xEWNDRk/3LQ1Cz9AJCXp/gH4zlz5hAREcHPP/9Mz549ad68OS1btmT06NFcunSJTZs2AaXhghMnTiz3GGXnW9Xnqgo2tfVZNcSFfRNb8iozH+8/brD4bCRvsuQPwVUGgUBA5yZmXJnrw1D3usw9dI9R2+/wSIn6YlnH6er4n1aq+Yfv8/3JB5UyStXARJc/x7gzslU9PjsQzpyD4XLXgH+IhpqQBV3smNfZjgN3Ehi25RaJaf8UEiZ6NcT387bYSKkW1VAT8k2PxqwZ5syaa0/55vgDuUfTNNVE/NKvKV93d2Dy7lA2+MbIJab1aFaHQ1Nac/t5GguORMjMAurrYsH2sW4sPhvJigqqxAUCAV93d2Bim4YM23KLW89S5fo+lEEgELCwqx3tHWoxctttXmcpLmCqiYSsHd6c1JxCvj/18L9aIS4PEfFvWHLuAet9n9K1cR0amRlV6fHUREKmt7Vm3fUYuRxwAoGA0a3qsydYervZgOaWHFchnNzb1pSQ5+lK59WU0djcQKna9TLMDbWVHpsqG6VU1n2TrYLzRiKRkJCWSz0Fs1XKCPtEeTen7yXjUreGXA4hiUTC7uA4uXJJpFFUImb1tafM7mCjUBDzhQcveVGOiNexY0f296mJmh7M2n2blaeCSElJIfDpW9ov92PJhSjy/hp5VbS2O7uguDSkta211PGUX849JqewhJ/7lB8cLIu8whIm7rqLk5URX3QpvzVq7614tgY8Y/eEFtSt+fG4z8vMPH4++4guTcxY2NXuk4yavM/duDQGbAyil5M538twxPhHv+H7U4/o7WTOumHNZeYdPXuTTb/1N8nKL+bMLNkOnTKuRqbQY00grRoac2K6Bw0UGJN6k1XAhF132eAby7YxbnzVzUHh0HCJRMLhkEQ6r/THWFeTK3N96KiC26ZELOHPwOd0XFHq3rk234dhLeoiFArwbGRC5ya10RCVPu8aakK+7dFY7scuKC5hk18s7Zf5kV1QzNIBzVjQxa5KhIyXmXksPBpBjzUBmOhr4Pd5Wz7vYq9Sfpa8FJeIORn+gi6r/Pnl3GOGt6zLgcmtmODVQKnQ6Wqq+b9GtXjzL0RL6z93LwoLZS+SCwpKBQhtbcXDzIyMjCr8+pQpU5g4cSIAycnJHD9+/KNtys63Ks81MTGxwj937tyR63HszQzYNMqVo1M9iEvNwfv3Gyy58FhpMUJeNNSEjPdqgN+CdjQ2N6D/hiAWHLlfYbitMpSNUm0Y6cLz1NxKG6USCgUMa1GXq/N8yC0soeMKP07de6H04t21Xg3Oz26DrZke3VYHcCjkP2HCQqFArmC+9va1OTCpFbFvs+m1LlAhV8AgNyuOTG3NvlsJTN0bKtdImKOFIb/1b0rMX5Z2WcKfh7UJR6d5cCw0iflH7le48JzqY823PR0YvzNEoVBmRREIBPzc25HmdWswavsd0pW47vU01fhzrBvXHr9mi/+zKjhL1RCLxdx/lsKS0/fYcCMWDSHM6+LAKK9Gn+T4/ZtbkltYwkU5n8deTuakvCvg9vPys6Xa2tUit7CEOzICv6VR31gHM0MtlYXBJuYGRL3KUnr8s46KzhtQXrzJyi9GX8kFzJusAvKKSpQemwpLSP8keTfHw5MYIKfrJjg2lTdZBfRWsgIb4HhYEiKBgH4u8h0TSh0U8w7fl+p8bd26NXvmtKeVfQ2C49PptO4uY3fcISEt9x+ZR/UVrIP+9sQDzI20md6u/PeAU/decDwsiU0jZYsQ5VEiljD7YDgaIiHLBpU/znUu4iW/nn/Mn2PdsTf7uJL5TVYBI7bexlhXk+97Nv7kws3Fh68Y/ecd5neyZWFX+wqPvzs4jil7QhnoasmCLnYyHR1XI1Pos/4m7R1qsXOce7nOpw8pG5Oac+gei/o6Mr+znUJujutRKXRb7Y+2hoiLs72VCstNTs9l7I4Qll95wuqhziwf7FRua5i8RCRl0Gd9IHtuxbN5lCsrhzh/lLnzU29HREIhIqGAH3o1lqu5SiKRcCUyhc4r/TkZ/oKto93YMMJV6fesisjIKeTX849pt8yX3KISLs3xZnHfplXuLIRSwfjI3UQ6rvBj2eUnjPdsgO/nbRnduv4ncfpUU82/hWrx5l+Ivv5/7irJM16Uk1OahyDP2JIyTJky5e9/+/n5ffT1svOtynO1tLSs8E+dOrID8t7H0cKQbWPcOTC5FVEvs2iz9DrLLz+p0kYaKK3E/rq7A1fn+VBYLKb9Mj/WXX8qNfNCWaxN9atklKq2gRabR7myuK8ji85GMmHXXaUXZDoaaizu25R1w11YfjmaSbvvKuyEqmOkzb6JrejtZM6AjUEVOhg+xNHCkLOzvMgtLGH55Wi59qlloMWhya2wrKH9VzBxxYJR6aiYB09eZTFu550Ka5+HuNdlxWBntgc8q3DcSlWEQgG/D2xGq4Y1GbvjjlLXXlmF+JprT7nw4L9bIf4+YrGY388/Zq3vM9TV1JjTxZb53ZrSxKLqnQ9laKiVjhuuu/4UsVi22KCtIWKcR30uPSxf7NFQE9LXyZxrUcqNLAoEArxtTfCPVq4uvoz6xroIBQKl85nMjbRJVtF5U1BOvbQ8ZBUoPzYVn5aLmYGWUosDsVhCeEJGlefdRKdkkZZTKLPGuYydQXEMbVFX6QVPYXEJG31jmd3RRqFMiyXno+jetE6FuRvFAjUyiw0IfSUguxiKP7jxoCYUKOS+OH0/mYCnb1k1xLncqveoV+/4+vgDVg91UTqU+veLUcS8yWbLaNdyq7EDn75lwZH7rBvuglv9j50/6X/lxjhZGfFLv6ZVMt5SEbuC4ph3+B6rhjgzqoIQ6OISMd+fesjqq0/ZO7EF/ZtXPPYkFktYe+0pP555xJL+Tfmqm4Nc10tSei6DNwf/PSaliMiYU1DEdycfMvvAPb7q5sC6YS4KCy4SiYRDIQkM2nwLCyNtLs/1UaqRqoys/CJ+PP2IpRej6GBfmwuz2+DZqHwxyVRfk1/7OeJjaypXa1x0Shaj/7zDwmMRTPG25txnbWhtbaz0uUojt7CY9Tdi6LM+kJjX2Ryd6sHaYS4KBUYrS2GxmKN3E2m3zJf1N2KY0a4RNxa0ZXjLujKr6Kup5n+RavHmX4iWlhYmJqVv7ElJFWd6pKen/y2IlIUBVzaNG//HtvnixcfZC2VBxbLOFf4TVFxV56oozlZG7Brfgt0TWvAmq4A2S2+w8kp0lQeyWtXUYc0wFw5MbkXsmxza/nGDvbfiKzXU+P1RqtbWlddKVVaLfHWeDzV1Nei80p/DIcq7e9ra1eLSHG801UV0XeUvdRErDZFQwJyOtuwY5866GzFM3xcm9/dYQ1eDneNa8EXX8m3u5aGlLmLVEGeGt6zL4M3BMp0ytQy0ODylNeoiIbP2h1codnV1NGNOJ9u/M4GqCjWRkK+7O2Cgrc6EnSFKVTg3tTRk5RBn5h+5z73EjMo/SQUpKRGz+lIkLzNz+LF3ExZ0d8S+jnKho+WhyNjRkL+CGm88kS9rpl9zC/bdTpDaPNavuQX7b8UrPfrU3r4WT1NUa5wSCQV0dTST2bwmDasaOugqaWlXEwmxra0nc1xRGtrqImrqKifepGTm49VIucXQ87fZmBlo4VBH8YwNRTgWmoRbvRoYyCFQJaXnkpKVz0gpmSzycOhuErUNtOjZTP5F9e1nqfhFv2GhlPdasVjC4ZAEPH+7zp5b8ZSIJZT3K0VDTYhlDfmdu21ta7FjnHu5zoDMvCKm7AllYpuGtLOvJfdjfkiPZnXYObZFuY1D9xMzmLo3lF/7O5YrAGTmFTHqz9s0NNXlj4HNyhWYqgqxWMKSC49ZdTWavRNb0rmCqut3+UWM2xnCrWepnJzhKTOHJTOviIm773IsLIntY9zkvlau/DUm1cTcQOExqYcvMumzPojsgiLOfdaGAa7yhXe/z4uMPEb/eYeVV56yuK8jv/ZvqvQokEQi4fyDl3Rc4ceTV1n83MeRuZ1sZYqm/Zpb8udY9wrPPSO3kN8vRtF7XSC2tfX/FjMq+/opKhGz51Y8Pn/4cjkyhSUDmvHnWHe5x95UIb+ohN3BcbT94wYb/WL5oqsdV+f5MMjNSqkA52qq+V+h+ur/l+Lg4ABATEwMxcXSP7BHRUV9tE9lI8vJUCbuZGZm8uqV9IXsy5cvefeu1KlQVeeqLK71avLbgGZsHeNG8LNU2iy9XiWOmA9xtjJixWAnfunXlO2Bz+m6OoBrj1MqNUtER0ONz7vYc/69VqrT916oPEplpKPBskFObBjhwp5b8QzZEkzMa+VCs2voarBumAvf92rMvtvxzD98v0KXSnm0amjM+c9K28W6rwkgNL7iivsyREIBOhqKjVQIBAJmtGvEskFOzDt0j/U3Ks7O0dVUY9toNxrV0qXfhoodOx7WJhyY3Iot/s9YcuFxleXKaKqJ2DzKlRKxhGl7Q5UaSencxIx5nWz56ngEiWn/vQrxG5EvWHg0nKSMfMZ7NsLS5OOxBFWISMqg0wp/8grlEw+01EX0bFaHtdfly1SqZ6yLZyNj9t9OKPfrjhaGWNbQUXqkzr1+TW49T/soX0pRdDRERCjp4DMz1MIv+o3S13NCWi6FxcrtG/smBy115camol9ng5IjLGEJGRhoq6FRhXeHi0vEnAh/wQA5Q4P33IqnjoE2FgoIIO+TX1TC+usxjPGoL/dCsbhEzA+nH/F5Fzup4xWT99zly+MPeJdfXGEtfEFRCYJi+a9jQx11mlkaffT/YrGE+Yfv0dBEV+Vg4GaWRtQtJxMp9k0243aGMLeTLf1cPnZRZBcUM3bHHWrpa5WG1X7CBWlBcQmLzkZy+VEKx6Z5VOgOi0/Nof+GINSEAo5N85A5jhOdkkWfdYFIJBJOzfTCrpwxsQ8pLBaz5Pxj5v3VJvVLP/nbpMRiCZv9Yhm4KYhezcz5Y6BTuc9HRUgkEg7eSaDrSn/qGGpxaa63SoJeYlou43eG8O3Jhyzsas/+SS2xVjBkuzyKS8SlgsYyXyJfvuPsrDZ817NxpWfNiMWlFeMdV/ix8+ZzFvVx5OR0D6XGzxQlr7CE7YHP8f79BvtvJ/B1Dwcuz/Wht5OFQq+RJ6+y+On0oyo802qq+e9QLd78S/Hy8gJKx4xCQ0Olbvf+GJOnp2eVnEtkZOTf/zY3//juSdm5fng+H/IpzlVVWjU05tDkVmwa6cqNJ29os/Q6G31jVQ77rAiBQECXJmZcnuvNqFb1+PxoBCO23a709qGGf7VS/drfkWWXn1TaKJW3bS0OTm5FUwsjeq4NYN31p0o1EQkEAvo4W7B0YDNeZ+XTbVUAwbGK5XQY62myfYw74zzrM3N/GFv8YiulOl0aXR3NODLVg3234/n13OMKHSxqotLwwdGt6zNkc3CF9c2OFoYcmdqas/dfsvBYRKXXzJeho6HGn+PceZNdwNxD95Rq85ng1YDW1sZM3BWqsOCmKk+TM1h0IoKjoS9oZmnIT72b4VTOWIKqNLUwxFRfk20B8mf8jGhZj7jUHG7GyHcNj25dn/13EsoV0QQCAf2bW3AsVLnWKX0tdZrXNSIwRrXRqSbmhko3TpkbaZNbWKK0q1FTTURBkbKZN0XoKRlYnJiWS10lsyPCEzOqrJq3jMCYtwgE4CVlDON98gpLOHgnkbGe9ZU+3v7bCdTQ1aBrBS6NDzkQkkh+UQlDW0gXmEa2qoe+lrrMQNkSCRwMjuOHQ+d4+1b563lrQCy5hSWsHOJcJWNKyRl5jNp2m8ltGjDBq8FHXy8NOA5BV0ONDSOaKxykqwqZeUWM/TOE0IR0Dk1uVWFzV0hcGn3X38TbxpRtY9xljh+ei3hJv/U36e1swfYx7nKJCmVjUi8y8jitYJtUckYeI7bdZv+dBPZPaqXwKB/8x22z+tpT1g534feBTkqLIUUlYjb6xtJllT+1DbS4Pt+H/s0VdwCVR+DTt3RfE8DOoDhWDnZm57gWNKpVuXEJEokE3yev6bUukCXnHzOjbSMuzfGmq6NZlecw5RQUs9kvlja/X+dEeBKL+jpy/rM29GxmrpCj6G5cGhN2htB7XSCa6tXL3Gr+96i+qv+l9O3b9+9/79ixo9xtxGIxu3fvBkqDh9u1a1cl57J58+a//+3j4/PR13v37o1QWHopSTtXgJ07dwIgFArp3bt35Z5kJSIQCPBoZMLRqa1ZPdSFi49e4f176ViTMuMl8qIuEjLGoz6+n7elmaURAzcFMe/wPV4qmSlTHqVCUR0uzvGu1FEqXU01vu/VmAOTWnH6fjJt/7jBV8cj8I9+w9OULLkCgcuoY6jNrnEtmOLTkAm7Qlh0NlKhn7tQKGBim4ZsGunKntvxjN0ZwtvsqmsVa2xuwOkZXoQlZjBky60Ka+jLHDuL+zmWVomHSM+2aWiqx7FpHoQnZDB9X1iVXXsGWursGteCJylZfHksQmGxSyAQ8HU3B8wMtZi5P7zKhKYPCX/+htVXn6CtIeD7Xk0Y7dkIPRWqWytCIBDwTQ8HNvnFyp3LpKupxgTPBqy9/lSu7X1sTdFWF0l11/RzseD281SlM6ba2JgS+FQ18aaxuQGPkjOVcs/oaaphqK1OUrryocWFSl5bWSq0TanUNBVf9WHFx8Je0NfFQq7Fzal7L6hjqEVLKY1LssgrLGGDbyxzO9rILXhk5Bay/PITvuvZuMJ8irZ2tfD/vB1dHc3+UZdcHj2cjQh+BFPWf1wrLg++T16z+loM3/RwKHfUSVXScwoZ/ecdfOxMmeJj/dHXC4pLWHwuErEYtox2/aRhq8kZeQzeFIyWupCDk1tVGDR75G4ik3ff5ctu9nzfq3GF11jJXyNYXx6LYOUQZ+Z1spXrGrn86BU91gTiaGHAskFOCo1JnYt4SddV/ljV1ObcZ20UzpaSSCQcD0ui60p/zA21uTTXm7Z2yrtt7v4ldJ0IT2LX+Bb8NqBZpVxfcW9zmLT7LtP2hTLYzYqLs1VzBUkjPCGdYVtvsTXgOX2dLbixoC2D/xoBrkqy8otYfyOGARuDuPDwFb8PbMaZmV50aWIm9/uMRCLhelQKgzYFMW5HCLZm+gQsbMeX3f5dLv9qqqkMqsWbfyktWrSgTZs2AGzfvp3g4OCPtlm+fDmPHz8GYPbs2air//NOwc6dOxEIBAgEAn788ceP9n/w4AExMTEVnsfmzZvZvn07AGZmZvTr1++jbczMzBgxYgQAly5d4ujRox9tc+TIES5dugTAqFGjMDOT/67df4vSoE9TTk734PeBzfCPfkOb32+w8+bzKhVxDLTU+bKbPVfn+aAuFNBjTQC/X4xSSACRxfujVHGV2ErlUrcGZ2e1wVBbnQN3Ehnz5x26rg6g6Y+Xsfv2Ah6/XaP/hpvMORjOistP2H87gRtRr4l69e4f7iahUMDo1vU5M8uLu/Hp9FobqLBLyMnKiHOftUFfS41uqwMIUtF1UBEm+pp/2aJ16b3uJg+SKj7XPs4W/DnWncXnIllx+YnUxbCZoRZHprbmTXYB43aEVOo18D7GeprsndCSW89T+flspMKLczWRkHXDXUjJzOeH04+qtEJcIpFw5VESW/2e4VLXkAU9mlLbqOpDE93r18TLxoRVV+ULtwYY7VGfyOR33JHSJPU+QqGAUa3qsSc4vtyv1zLQwsPahBPhyrlv2tiYEBjzVil3VRl2tfXJzCviVQUCZUWYG2krLT5pqgkpUPJ9Nyu/GAMVxBtlWluyC4qJTsmqUufNu/wiLj96xUAZwbFQ+rrZGaRaPfieW3GYG2nRSYGq5FVXn+JkaUR7ORabhjrqrBnqwtYxbtTU1SjXjaKvpcaE9q34pVctMvNg3eW7Cn0PiWm5zD5YOprTxLzycztyCooZuzOERqZ6LO7b9KOfdVGJmBn7wnmY/I7tY90UHtlVhahX7+i/IYjm9YzYOlr6scViCb9diGLR2UjWDW/OEPe6FT5uek4hM/eHcTUyhRMzPCvMzimjsFjMorORzD98n8V9HVncV/4xqay8IuYfvsc3Jx+wdEAzfh/ohJ6CbXJJ6bmM2n6HTX6xrB3mwtKBzeTKjCqPjNxCvjoewajtdxjibsXZWW1wrwQHaFZ+EWuuPaXran9M9TXxXdCWiW0aVrpLK+Z1FlP23GXEttu41avJxpHNmeTdsMpFxczcIlZdjcbzt+v4PnnNdz0bc2K6B+3ta8v9HlVUIuZEeBKzDoSz8NgDOjjU5uZX7VnY1Z5a+lXfgFVNNf8NqsWbfzGrV69GW1ub4uJiOnfuzJIlS7h16xY3btxgypQpfPHFFwDY2toyf/58hR8/NDQUe3t7OnXqxIoVK7hy5QphYWHcuXOH3bt307lzZ6ZOnQqASCRi8+bN6OqWv0j65ZdfMDU1BWDYsGF8+eWXBAYGEhgYyJdffsnw4cMBMDU1ZfHixcr8OP5rCAQC2tvX/rtl6WBIIm3/8GXPrXilAzTlwbKGDksHOrFzfAtC49NLjxkcp9RIkjQamuqxa5w7v/RryuqrT/8apcpQ6TE11IScmOGJkY46Evh7sVhQLCY5I5+whAxO3ktmg28si85FMmN/GN1XBzB+Z8hHj2Vtqsexqa3p5WTOwE1BrL8Ro5Czw0BLnXXDXJjb0ZaJu++y4vKTKnOGaKqJWD7IifFe9RmyJZizEckVbt/a2phj0zw4FvaC+YelV4kb6Wiwb2JLGpjoMmzrrSpzEZkZarFvQisS03JZcfmJwvvra6mzfawblx6lsD3weRWcIUQmpPH9yfucuPuCzs3qMM7btkqOI42FXe05GppEzGv5QnsNtdUZ41FfbvfNIDdLIl5k8Phl+aNJA1wtORaWpJQ41szSCIlEwgMVRiW1NURYm+rx6IVyo1MWKtaFK+O8KS4Rk1dUolTbVG5hMW+yCpQam4pIzMDMQIvaVVihey7iJXZm+tjUlh2IfOd5Gi8z8+nrLH+19/tkFxSzye8ZczvZyr2wevIqiwN3EvhOwerrdna18P28Lb2dzD9y4dQ2KK1WtmncjIltBHzWtbXcj5tfVMKUPaH0cTaX2ZSkDIXFYqbuDUVXQ8TqYR+3WxWXiJlz6B7JGXnsHtdC6QY0ZQiKecugTcGMaFmXX/s1leqmyCkoZureUC49esWJGZ5SW5HKeJScSa91gdTQ1eDkDE+5xngS03IZtDmY4NhUhcekQuPT6L42ADWRkIuzveVuWCtDIpGw91Y8XVcFYFVTm6PTPGirpItFIpFwIjyJDsv9eJmZz+W53oxuXV9lcUUslnD4biLtlvnx7G02x6Z58Gu/phh/UCuuKskZeXxx9D491gRSS18L38/bsqCLndIilryk5RTyx6UoPJde587zNDaPcuPwlNZ4NjKR+30ir7CEnTef0/YPX1ZdfYpnI2MCvmjHVB/rKj//aqr5b/PpJP9qFMbFxYVDhw4xcuRI3r17x9dff/3RNra2tpw7d+4f9eKKUFJSwtWrV7l69arUbYyNjdm+fXuFo05WVlacOXOGvn378urVK5YuXcrSpUv/sY2ZmRknT578u53q/xpl2TSdHGpz8dErVl6JZpNvLLPaN2KAq2WVpd83szTi4ORWXHv8ml8vPGZHUBxfdXOgo0OtSplBLm2lMsPb1oT1N2JYcj6KhqZ6LOhsp3DFZhmaaiJWDHZiyp5QikrKX2gWiyUU/xUAqy4SMNm7YbnbqYmEfNbBhnZ2tdjoG8PATcGsGOxU4Zz+h9/f8JZ1aV7PiBn7wrj1LI3Vw5ypY6hcYKesY032tsbaVI85B+8RnZLNnA7SRwxsautzYoYHcw7eY/bBcH4b0KzcWXsdDbXSBqUj9xm4MYg9E1oq5QaQRV1jHb7sZs/gzcHoa6sz2ftjy39FWNbQYfsYN4ZtvUU9Y12F7tBXxIOENK48SuHpm3fY19ZjTic7jPUq//mTRUNTPYa6W/HbhSi2jXGXa5/xXg3wWnqde4kZOFsZVbitkY4GfZws2B0cz5L+TT/6eufGtfnm+APuKZGlIhIK8LIxISD6jczzqIjG5gZEvnxHRyWeWwsjbV4o7bxRLvOmLHRe0TvzAIlpeehqiDBWYhwvPDEDl3pVm3dzLDSJAXKKELuC4xjqboW2ko1fu4LiqGesQ1tbU7m2l0gk/Hz2ESNb1VMql8NAS51lg5zo52LBnIP3yMwvorBYjFVNHXIKihm+NYjCXAm+8SGsHNcabe2K3w8kEgnfnHiItoaIb3s0rnBbZSgRS5h3+B4ZuUUcmNzqoxExsVjCF8ciiH6VxcHJrZT+3aoMp8Jf8OXxB/zcpwmD3KTnDr3MzGPCzrsYaqtzYrqHzJGfU/de8NXxB8xo14hpPtZyjbhceviKz4/ep4+zBd/0cJDb3VFUImbt9Ri2+j9jfmdbxns2UDirKDEtl4XHIoh7m8OGEc3xlvNaLo9nb7L57tRDnqZks6ivI90qKRPmblwaP52JJC2nkEV9mlRJ1kx6TiEbfGPYcyuezo3NuDTH+5NUfr/JKmBbwDP23IrHrX5Ndo5zx01Bh1JGbiG7g+PZGVTqAvy6uwNdHc0+aUtbNdX8t6l23vzL6dWrFxEREcydOxdbW1t0dHQwMjLCzc2NpUuXEh4eTqNGjZR67O7du7N9+3YmTpyIq6srlpaWaGtro6Wlhbm5Od26dWP16tU8e/aMPn36yHy8li1b8uDBA7799lscHR3R09NDT0+Ppk2b8u233/Lw4UNatmyp1Ln+mxAKS6uyL87x5ouudmzxf/Z3g1NVuToEAgEdG9fm0hxvxnk24MtjEQzdcov7ifI1KslD2SjVor6OxKfl0m65r0oV4O3ta9OigbHM/AINkYAO9rXLrVF9n6aWhqwY4kzzujXouTaQPcFxCjkQ7M0MODPLi3rGOgzfeptrj1Pk3ldROjjU5th0D06EJzFjf1iF10UtfS22jnajoFjMoE1BUhe3GmpCVg1xxsfWlIGbgpSubJaFTW19do9vydrrMVLbjyrCycqI5YOcmHMwvFICsWNfv2PR+ccgEDOzXSNmd2nyXxFuyvisgw23n6XJHaZdU1eDES3rcvCOfD/L8V4NcJGSk6KlLqKHUx2uRip37baxMSVA1dybOgYqhRYnZyg3cqWs8yYrv/ivRjnFRYuykSllFk9h8em4qCCSySIuNYeE1Fx6y+FaeJGey9XI14xspVw9+Lv8IoJi3zKvo/yum0uPUoh6mcVnKjY5eTYywffztgxoXuoYamiix09nHmFmpMfK3g1wbWIqU7gB2Hs7Ab/oN1USDiyRSPjx9CMik9+xc5z7R0KhRCLh21MPCYtPZ9/ElpXuoKjovDb5xXIkNJFNo1wrFG7uJ2bQe91Nmlkasmt8+bXnZRSXlI48fXfyIetHNGdGu0YyhZTCYjE/n4lkd3Acv/ZvyqK+jnILN3Fvcxi0KZiLD19ybJoHE9s0VEi4EYsl7AmOo+sqf+qb6HJprrfSwk1+UQmrrkbTfU0ANrX0uTbfh+5N66gssCRn5PHZgXBG/3mHLk1qc22+D90q4XHfJ7ewmHXXnzJ5z12iU7I5OtWDNcNcqly4SXmXz09nHjHnUDgxr7PZP6kVu8e3UEi4eZmRx+KzkXj8dp3bz1NZPdSZMzO96NGsTrVwU83/dwgkVRlOUE01n4ikpCSsrEo/mCQmJn5Sd09xiZizES9ZdTUagUDA7A429HJSLB1fUbLyi9jkF8u9hAxM9TVZ0MUOyxqV58SQSCRcepTCorOR1DLQZFEfRxwtFM8HiHubQ8cVfhRXIADpaojw/6KdQh9og2Lf8vmRCBqa6vLHQCfMDBUbTTgXUdriNMTdioVd7aus6SMtp5Az95MZ41Ff5rZldbpXIlP4c6y71J+3RCJh9bWn7LgZx59j3XCtV/ntSlDaMjL2zzv82r8pfZQYtdh7K57mdWvQ2Fz52u74N+9YefkJ9Uz1mdvZXunHqWy2+sfyMPkdKwfL11Tz+l0+3n/c4Ng0D5VzNu48T2XynlBuf92hwgDY8khMy+WLoxFsHeOmlBMFICD6DVsDnrF7guJC/NmIZLYFPOfkDMXbBgdvDmZYC6tyK5cr4lFyJsO33ub+D50VPub2gGfcfp7GltFuCu0nkUgYvzOEzzrYVFnmzfLLT3iaks2mUa4yt/39YhTv8otY3PdjN5c8rL76lJuxbzk0uZVci8n8ohJm7Auji6MZgysQDBTlfmIGD15k8selJ1yc00Zu92R4QjrDt95m5zh3WjY0rrTzKUMikbDmWgwDXC0++j1c6kAqreQ+MrU15kafRnguEUv46cwjLjx8xY4Kfp+UneOQzbfo3KQ2E7waVPgcv80uYOb+MNJzitg8ylWuhX9iWi4z94dRLJawfnhzucUCiaR0fOjnM5EMcrPiy272CuewJKTmsvbGU4JiUlk6oBleNspXXQfFvGXt9Rjyior5uY9juRX0ipJbUMzWgOds9o+laxMzvuhqr/DnGVkUlYg5eCeB1ddisKyhzcKu9rS2rvzXwYe8yMhjk29s6QiYXS1mtLemqYWRQo8R8zqbzX6x3HqWiqOFIVN9rHFSQBT/b64Nqqmmqqh23lTzP8fZ+8lS80OqAjWRkL4uFlyZ58M0H2uWXX5C55V+nLmfXGU11fpa6nzexZ4/BjkhEgrpuMKP3y5EVVpVc9ko1dV5PnhamzBwUxDfnnxARm6hQo9T30SXiW0aoClFHBEJBfzcp4nCdyI9rE24MKcNtfS16LzSj1P3XijkwunRrA5nZnlx61kqAzcFEZ+ao9Dx5aWmroZcwg2UXkeL+zoy3qsBQ7fc4saT1+VuJxAImNPRlgWdbRm9/Y7U7VTFvX5NNox05ctjD7iihNNjZKt6Sgs3YrGYQ7efs/xSFDV1NZjqo5y7UB4kEgkXH75UKL9qVOv6hDxP44yMXKMyahloMdS9LuuuVxwQLw/u9Wuir6XGjSjpVfPSsKqpQ8q7fG7J6Roqj8bmBvg/fatU5beFkTZ5SoYONzDWBSXeTnMKSpQeE4tPy6WhqeJ3peNTc7kZk6qScFkRJWIJx0KTGOgqeyGSX1TCgTsJdHdULBukjMzcIrYFPmOeAlk32wOf8+pdvtwjXfJiqq/JqXsv+K1/U7mFm6NnLzF9byjf92pcJcINlL4nz+5oU65ws8nvGRcevOLApFafTLjJLyph2t5Qbsa85fg0D5k3XgQCAfsmtWRim4YVPscRSRn0XhuIsZ4mx6d7yCXCXHr0ih5rAmhmacSxafLtA5CWU8C0vaEsuxzNhpGu/Ni7iULCjVgsYVdQHF1X+6Onqcalud5KCzdvswuYe+gek/eE0qlxbY5Maa2ycCORSDhzP5muq/25n5TB3oktWTHEuVKFG7FYwql7L+i4wo+dQXEs7uvIiekeVS7cJKbl8tXxCNot8yU9t5BTMz3ZNMpVIeEmPCGdKXvu0n1NACKhgJ3jW7BxpKtCwk011fyvUi3eVPM/x+5b8Xj/foOt/s+qrJ2nPNRFQga7W3F9flsmeDVkyfnHdFsdwIUHL6tMxDE30mb5YCeOTvUgIikDn7/asCor1FhbQ8SCLnZcmO1NYloeXVb5c0TBVqrPOtigW85dfpEA9DXVOBySSNxbxcUTAy11lg924veBTvx0JpJ5h++TniO/uNTARJfj0z1Kx7DWBHLmvnwL8apEIBAw1ceaX/s3ZfreMA5UMGozqnV9lgxoxvS9YZx/8LJKzsfH1pSVQ5z47EA4N6uwret9XrzN4psT97gdm0YfZ3O+7+uEtpIuEXkoEUtYez2Gjb6xcu+jpS7i8652/H7xidzNc1N9rLke9VrlcTeBQEB/F0uOhyUptb+XjQkBTxUXfsow1tPEzEBLaqhyRZgbafPkVZZSQe+pOQVkFRTL3vAD3uUVkaJkO1ZCWi4WSiy4wxPTaWxuoLAzSl6CY1MpLJHgYyd79OP0/WRM9TWVXrBtC3xGUwtDWskpfLzKzGf9jRh+7N2kUt2nZZkyDUx0FQqpXRBYTHt7U4a6V54DSF7WXo/hz8Bn7JvYkrpK1s0rSlpOIcO33iI9t5Bj0zzkzkaTldl35G4i3518yKjW9Vg3zKXc3+nvU9YmteDwfYXHpAKevqHrqgBq6WtxcXYbfBQccYpPzfmr8voZ20a78UOvJko5DcViCQfuJNBhuR95hSVcmefNeK8GqKv4un6QlMngzcEsOhvJ7A62bBvtpnDNeUVIJBL8ot/Qa10gv12IYkbbRlya410l+Tnv8/xtNguO3KfDCj/yi8Sc/6wN64Y3x95MPhG77LyHbglm5Lbb1DPWxf/zdvw2oBnWcmYcVlPN/w9UBxZX8z/HwUmteJylzia/WNZcf8qoVvUY61n/k9UGaqgJGd6yLgNcLTgUksgPpx+xKziOCV4NKy1k+EMcLQzZN7Elvk/e8Ov5x+wKjmdhV3u6NJG/crEiGpjosnOcO75PXvPtyUfsu53Aoj6ONLWUPQKio6HGoj6OzD107x+ZFSKRkENTWrHvdgLdVgcwp6MNE7waSG3BkEZXRzNc69VgzfWndF7lz+8DmtFOzvYITTURP/Zugoe1MZ8fjSAo9i3f92yidKhnZdHbyZza+ppM3hPKq8x85nS0Kfd57O1kjrGuOpN23eX1u3zGejao9HPp6liHnIIS1l1/iraGqFI/ZH5IalYeyy8/wcxQk8962qOlWfWhnmoiIUv6N2Xw5mB6OZnL/SGxj5MF2wOfszMojqk+soOdzQy1GOhqybobMawd5qLSOfdvbkGnFbGk5RRSU8EwXa9GJvx2MUql4zcxL829kXdBX4apnibqIgEpmQUKL2Y11IRKOSqzCoqUbh9JSM2lrrHizpvwhAypuUWVwZHQRPq5mMtccEskEnbejGOsR8WjMNJIzynkz8Dn7BzfQu59ll6MooND7UqpSn6fLf7PeJWZz3Y5g8LL+NEexvRrVqWL1vLY4h/LjpvPOTi5NdZKBDYrQ0JqLmN33MHOTJ+VQ5wrpeq5qETM4rORnLqfzNphLrSxkS2kJKblMvNAOMUlYs7M8pLbbZNfVMLvF59wKCSBb3s2Zqi7lULPm1gsYXdwHL9fesKA5pb8OdZdpsgkjSevsvjmxANeZuazYrATHRzkD2iXSCTkFpaQlV/Mu/wisvKLeJdfTNTLd1yPes2DF5lM8GrAznEtlD4/aYQnpLPs8hNSswsZ0NySUa3rVXnl99OULNbdiOF+Ygbu9WtyWcEA5OISMRcfvWLDjVhS3uUzzrM+m0e6fdJQ72qq+b9EtXhTzf8cQmFpK1TnxrVLawj9n9Fm6Q36N7dksncDGph8mg9SmmoiRreuz2A3K06El7YyrDXSYm4nW9ramlb6h0mBQEA7+1q0sTHh8N0kvj/1kFPhL5js07BSchdKH782V+eZsNE3hkGbgxjQ3JLPu9jJbKXo3tSM7YEG3EvMQCwBTTUhX3a1x87MgJ/7ONLbyZyFxyI4G/GS3wY0VTgXxFRfk597N6GphSGzDoTTy8mcb3s4yP3BqHMTM5pYGDL7QDhj/rzD4n6O2MpRv1uVtGxYWiVeGvR3j98HNiv3Tr5nI1P2TmrFuB0hpOUWMVeK0KMKA1wtyS4oYtyOEA5OboVDncofB3mYmMYW/1jMDTWZ08kBDY1P9+upmaURw1rU5ZsTDzgwSb5cD6FQwNfdHZiyO5TBblZyiSjT2lrTfrkfsW+yVbqTWM9Yl2aWhpyNSGZ06/oK7dva2piE1FxeZOQp5SqB/zROKYpQKMDMUIsXGXmKizciIQVKiDfZ+cXoayl+LZWIJSSl51FPiVa3sIR0pijY1CYv7/KLuPjwFadnesncNiQunRcZefR1kb+K+X22BDyjeb0acgsxofHpXHz4imvzfZQ6njQeJGWy5tpTDk5upfBid+zYHpV6LvKwOziOdddj2D+pFXZmn+b3yIOkDMbtDKG3kwXf9nBQuImpPF5n5TNzXzjZBcWcmekll4vn8qNX7AmOx8nSkK+7y98mFfXqHXMO3kNTTcjZz9rQQMEQ3bi3OXxxLIKXmXlsG+OGh7VyI1J5hSVsD3zGuhsxjGldn9kdbdCR8rvo9L1kDt9NJDOviHf5ReQUFJNbWEJeUQllU9xqQgEioYCiEjFiCehoiLg8x6fSnVgxr7P449ITAp6+ZbxnAyZ5N8BQW/GWPEV4/PId667HcPVxCgNcLRVuwcwvKuFIaBJb/Z8hlkiY1b4RfZwtqlxsqqaa/+tUizfV/M8iEAho2dCYlg2NiXr1js1+z5iw8y52ZvoKh56pgpa6iGEt6tLX2YI9t+KYf/g+9Yx1mNfJFq9GJpW+0FYTlTp/ejnVYWvAc0Zsu017+1os7GpfKfXS2hoi5nW2o39zS34884h2y3xZ2NWewW5WUj8wCgQCfhvQjO6rA5AgwdpUj9HvZcG41a/Juc/asP5GDAM2BjHOswGzO9go9EtcIBAw2M2K1g2NWXDkPt1WB7BisJPcjQYWRtocnNyKrQHP6bv+Jt/3bMwQBe/8VTaNaumxYrAzE3aFMHr7HbaMKv9uVPO6NTgytTWjt98hPaew0kcWAMZ4NCC7oIRR229zeEpruavaZVFUVMye4OfcjU+nmaUBo1taf1Lhpoz5ne3otMKPo6FJFbayvI+HtQktGtRkzbWn/Ni7icztLWvo0M/ZgvU3Ylgx2Fml8+3f3JJDdxMVFm/0tdRxtjIi8OkbhrjXVerYTcwNuPpYuaylOobaJCtRF66pJlJKvHmXX4yeEuLNq3f5FIvFCueU5BWW8PhlVpU5b85FvMTOTF8uUWBn0HOGultJXXxWxNvsAnYFxbFvonzB1GKxhJ/PPGKqj3WlZrvkFhYz+2A4M9s3+j+Rd3EoJIE/Lj5h14QWSoX8K8P1qBRm7gvjmx6NGaFko9iHhCWkM21vKK0bGrOkfzOZbtTCYjFLL0ZxOCSRJQOa0rOZfIKhWCxhR1Acyy49YWKbBnzWwUamo+zD/XcFx3HpUQoOZvrsUMFtcyPqNd+dekhjcwNOTPeUeZMiLaeAm7FvqShur1gs+buwQU0o4Oo8n0p9fSRn5LH66lNO3nvBYDcrfBe0pZaBYi7zrPwieqwJJKegGIEAhALBe38LEL73fyKBgOyCYtJyCkEgYUSLetxY0Fah7ykzr4i9t+LZcfM5JnqazO9sS4+mdRR2XVdTzf+vVL9Sqvn/AnszA1YOcWbPxJaYG2kzbOsthm4JxvfJa4WCblVBW0PEZG9rAr5oR6fGtZl1IJwhm2/JXTmsKPpa6szrZMv1+W3R0RDRcYUfv5yLJDO3cnKA6pvosmOsO0sHNGPt9Rj6bwziQVKG1O1ta+szomVdhAIBq4c6fyQuaKmLmN/ZjhPTPQmKeUu31QHcjUtT+LysaupwYFIrRreux6jtd/jtQpTcGRtqIiHT2lqzZZQbyy5H89nBe580N6k8TPU1OTi5FfpaagzYFERiWm6529nW1ufotNbcjHnL7IPhVRLaPb2tNQNcLRm57bbUSnNFyMsvYsm5h0Qmv2Ns63pMbWePzn/JKq2nqcZPvZvwy/nHpGYXyL3fV93tOXAngedy5jZNb2fN2YiXKodk92hah8cv3xHzOlvhfUtzb5TPMGpcx5CY11lKXWMWRsqJN8qOTWUXKOe8iU/NwdxIW+EmugcvMjHW1VDa1SSLI3cTGSRHUHFyRp5K9eBb/J/RqqGx3K7NY2FJvM0uZIpPQ6WOJ41FZyMx0deUazTxQyor+01eToa/4OczkWwbU7kZJhWx/3YCM/aF8/sgp0oTbg7eSWDE1ttM9rZm5RBnmcJNUnougzcHExybyulZXnILN68y8xmz4w47bj5n94QWzO9sp5BwE/c2h6FbbrHjZhyzOzTipz6OSgk3Ke/ymb4vlNkHw5nW1ppNI1zlcpeOaFUPczmDszVEQn7u06TShJv0nEJ+Pf+Y9st9ySsq4dIcbxb1dVRYuIHS331CAaTmFPI2u5DXWQWkvCvgZWY+yRl5JKXnkZCWS3xqLs/e5vA6qwCJBI5O8eCnPo5yf08p7/JZcv4xnr9dxy/6DX8McuLC7Db0cbaoFm6qqUYBql8t1fx/hYWRNt/1bEzQl+3xtDZh/uFSh8bJ8BcUf6IPerqaakxv24iAL9rhZWPC5D13+eLofUKUECrkwcxQi98HOnFyhidRr7Lw/uMG2wKeKRUa+iECgYDOTUpbqdrYmDD30D2+PvFAanDwV90dODXDE5sKRpIc6hhwfLonE70aMGr7bb4+8UDhFi2hUMDENg05PdOTwJg3DN4UTOTLTLn397Ix4cLsNmTkFtJjTSARFYhSnwIdDTU2j3KjdUNj+m0I4kFS+d+LZQ0dDk9tTVxqDhN2hZCjRMBrRQgEAr7sak87+1qM3HabN1nyixzlseFGNFn5RXzd3YEWjeTPFKgqOjcxo0X9mvxy7rHc+zSqpc8AV0tWXH4i1/b1jHUZ2bJuhWHU8mCoo05Hh1pcevhK4X3b2JhyM+at0kHqVjW10VITEZ2iePiyuZEWyZmfTrzJyi9CT4nspITUXOopMdoQlpCOS12jKnHsPXuTTXxaLr2cZC+OD9xJoK2dqVJuy9dZ+dx+lsqcjjZybZ+VX8T2wOd800P+MRl5uPjwFeciXrJyyMdivyyCY1PptjrgkzVPXn70iq9PPGDzKLcqa7V6H4lEwvLLT1h6MYpd41vILZhUREFxCb9deMyKK9H8OdZdZm04wJXIFHqsCcTRwoDj0z3kHne6+PAlXVf741BHn/Oz2yiUkSQWS9ge+JzuawJobG7AxTltaK3EmFSJWMLOm8/puNwPDZGQa/PbMqJlPblHztRFQn7t3xR1UcXbqwkFNLM0ZFgL5ZyO75NbWMz6GzHMPhjOk1dZHJ3qwZphLgplzHyIQCDg8y72UltBP0QkFHB4aiuc5RQon7/N4avjEYzafodnb3PYNb4Fh6e0pp1d1WRAVlPN/zrV4k01/19ipKPBrA423PyyPSNa1WPFlWh8/vBl3614cgsrd8ErDX0tdT7rYEPgwvbUranDuB0hjNp+m7CE9Co5nkMdA/ZMaMmaYS4cDU1i/M67nIt4WSnOI22NUtfMtjHuvMzIo/1yXw7cSfhocailLpLLSi4SChjRqh6X5/qQmJZLpxV+XH6k+CLVprY+J6Z70rNZHfpvCGKjbywlci5YTfU12TWuBUNbWDFk8y22BTz7ZC6t8iirVZ/s3YChW4K5HlV+fbeJniYHJrWiRCypUEhTFoFAwKI+jjSzNGTU9tsqOblaNDRhdkd7ahp8miYWefipTxMuPXpFcKz8zpQ5HWwIiU/n9jP5XHQjW9Xjz5txUl1U8jLAxZJ9t+MVFmGcLA2ppa+pVG4NlF4DDkrm3pgbafMi4+P2J1mvS001oVKCc5aSmTcJabnUVUL4iH2dXWUjU0dDk2jd0Fhmxlh+UQkH7yQy3ku5APPNfs8w1deUuw55/Y1YTPU06eZoptTxyiPlXT67gp7zS7+mCruYXmTkMXN/GBO8GijsnFKGq5EpfHksgg0jmitdR60IhcVi5h+5z/GwFxyb1poWDVQPh055l8/QLbe4GZPKcTnqpItKxPxyLpK5h+6xqK8ji/s2lUu4yyko5ouj9/niaASL+jjydffGCgWKP3+bw5AtwewOjmPHWHd+7N1EqbHAB0mZ9F1/k13B8Wwc6cqqoS6Y6msq/Dg+tqa0qF+zQnFRKBSwcoizSkJFUYmYPbfi8fnDlyuRKUzzsWbX+MobzevmaCbX96/xV16haz3Z11xEUgbT94XSZZU/hcUS1g9zYetoN1zrfRpXWjXV/K9SLd5U8/81WuoiRrWqx/X5PnzTw4H9d+Lx/O06K69El870fgIMtdWZ2d6GwIXtShfE224zbsedKnN7+Niacu6zNgxsbsFPZx7Rf2MQofGV4/qpb6LLn2Pd+X2gE+tvxNB5pT/fnHjAjajXhCekE5+aQ2ZekdwiiFVNHXaPb8HnXez5/GgE0/eF8jpLsdpfdZGQSd7WHJjUisN3ExmyOVjukRWhUMD0to3YO7EFO27GMefQvU92XZSHQCBgsrc1Swc2Y87BexwOSSx3O30tdf4c40ZRsZhBm4N5qYTToSKEQgHLBjlhWUOHr088UFrwbGNXG0uT/24w9IfUMdTmmx4OfHX8gdw14LUMtBjRoi6/nn8sl5DS0FSP7o5mbPCNUelcve1MKSgWc+u5YqOXaiIh9U108YtWvjK8VYOaco9s5ReVEPc2h+DYVOJTc3mVmce3Jx8yavttOiz3pdmPl2j09XkuVFB5r6spUirHSU0goIYSo3gFxWKFg7klEgm+0W9wsar8xUmJWMLxsBcMkGNk6vS9ZGrqatBSiUX963f57Lsdz5yOtnJtH5+aw86g53zZ3b7S7qKLxRLmH76PuZG2XC6j98kvKmHqnlA6NzFTyOlQUqKcE9Uv+g2zDoTza/+mtLWTr+VQFbLyi5iwK4Qnr7I4Md2DRrVUf/+8G5dGz7WBWJvqcWRqayxrVCxavsjI44ujEQTGpHJmlhe95XyOwhPS6b4mgIS0XC7O8VbouZVIJGwLeEaPNQE4WhhyYXYbpRxOWflF/Hj6IV+feEA7+1pcmN1GZcGtr4uFVPFZU03IN90dlM4bFIslnL6fTMcVfuy8+ZxFfRw5Md2D1o0qVyQUCgV83sWuQveNhkiAZyNjJraRLgpLJBICn75lxLZbDNl8CzMDbW4saMvywU7YfKLw7mqq+V+nOrC4mmooXcx0b1qHbo5m3IxJZbN/LFv8nzHE3YoJXg0qJehXFkY6GnzexZ7xng1Kj735Fl42JszpaKNw+5IsREIB/Zpb0sXRjK3+zxm1/Q4+tqYs7Gqvkv0WSgWGTo1r08bGhCGbg9l3O4H9txNQFwkoEkuQSEAoKB0FMtBWp4aOOsa6GtQy0MJUTwMHc8N/fBgUCAQMdLXEx9aUn848otMKf77p4cAgV0uFFgsudWtw/rM2/HbhMd1XB/BNj8YMayFfILFrvZqc/6wNv1+KovvqAFYPdf4k1nhp9GxmTh1DLSbsusuztzl80cXuI6u3loYaa4c355sTDxi4MZg9E1pUWsgwlIpi64a7MGVPKFP3hrFttNsnucv9PhFJGWwLeK7UWEVFDHGvy8GQRDbciGFeZzu59pnYpiH7bidwJiKZPs4WMref2d6G7msCmN62kdLvL+oiIb2dzTke9kLhdhVvW1NO3UtmRrtGSh3bqqYOR+4mVbjNyivRbA14Rm5hCUJBaeiwBAn5RWKiUz4WfppVEEgrEAjIzFPc5ZWYnoeXreILnTvP0xS+Q5yUnkd6TmGVBOvejHlLiURCGxmLNomkNAB2rGd9pcSUjX6xeNuYyn1H/5dzj+nnYlmpv6P+vPmc+LQcNo5srtB+EomEn85EYm2qy4+9G8u93/O3mWy+/pQ5He0wqyn/AjMo9i3T9oby24CmdHWso9C5KkPKu3wWn41EIBBwaEpr9FSsmZZIJOy9Fc+v56P4urs9I1vVk3nNXHucwvwj9+naxIzj0zxk5uFAaRX0Bt9YNvjGMKejLZPaNFT4/VogEJCeW8jOcS2UchpJJBIuPnzFj2ce0cBEl5VDnFQWvuJTc/jl3GOCn6XS2romofEZ/xjTEwkFNK5jwCglsogkEgn+T9/y+8Uo0nIKmdvRlv7Nqy4bRiKRoF1Om2UZAgHU0NVg9VCXcq+RErGEy5Gldd+J6bmM9ajPumHNqSFHC2NVkVNQzPGwin9HVVPN/0WqnTfVVPMeAoEALxsT9kxoyZGprUnNKaTDCj9mHwwnMlm5EQNFMdbT5KvuDvh90RarGjoM3BjMwmP3efJK8XwJWehoqDG7ow2+C9pipKNOl1X+/HTmUaWM2mipizg+3RPLGtpIgMISyd+tDGJJaZBockYej5Lf4f/0LUdDk9jk94xtAc/KfTxTfU3WDW/O8kFOrLgczcJjEQqHvmpriPipjyObRrmy5tpTxu8M4fU7+Zw8hjrqLO7ryPR21ozdEcLqq0/lHsGqClzr1eTYNA/OPUhm9qF75Y6UiIQClvRvSm9ncwZtCpaalaMsWuoi1g13IS2ngAVH7iudoaIsDUx0efAik3XXVXOwfIhIKODXfk3ZEvCMp3LmumhriFjQxY7fLz6Ry7HTqJYe3RzN2OAbq9K5DmhuyYUHLxV2P3nbmBIWn062krlITcwNiXz5rsLnvLG5wd8/C7EE8opKyC8qP4PEpa5RheMxGiIlM28KitFXMPNGIpEQl5qjcOZNWEI6jc0NqqTq9mhoEv1dZC/e7jxPIzkjj75yCIgfkvIunwN3EuR23dyMeUtwbCrzO8u3vTw8Ss5k+eVoVg1xQV+BcRqAvbfiufo4ha+6O6BZwUL0Q+rW0ENNImDVpSiS0+R7vYfEpTFp111+6t1ELrFWVaJTsui3/iZaaiK2j3FTWbjJLyrhi6MRrL4Ww67xLRjVumKxr6hEzK/nHzP74D1+6t2E3wbIbqACSEwrDRU+de8FR6d6MNXHWmmh/fMu9koJN4lpuUzYdZdvTj5kYVd7DkxqpZJwk11QzG8Xouiyyh9jPU1uLGjL5lFuaHzw2hQKYNVQZ4Vr28MT0pm2N4z5h+/R19mCGwvaMtjdqkqEG7FYwoUHL+mxJpCvTz6kR7M65bpv1IQC/hzr/tGIW0FxCQfuJNBxhR/H7ibRz8WCoC/bM6ej7X9NuIl7m8PPZyJpteQaJ++9+K+cQzXVVCXV4k011UjB0cKQtcNcuDrXBwMtdWbuD2PMn7cJin37SbJPaulr8X2vxtxY0BYtNRG91wUyc3+YUu0yMo9loMWS/s04PdOL529z8PnjBnuD4+UeG5GGSChgyyg31OT88CISluapVETHxrW5PLcN6iIB3VYHsMU/VuGw6TY2plya442htjp91t/kfESyXPsJBAJGt67P0WmtOXXvBSO23SJFTvGnKrA21ePEdE8S0nIZte0OGbkfi24CgYCFXe2Z6mPN8K23CFIgy0Ue9LXU2TmuBRFJGfx8NvKT5gLpa6mzYURzNvvHEvBU+RGg8nC0MGRky3p8feKB3KJUfxcLjHTU2XEzTq7tZ7VvxLGwJJLSlc++aWJugGUNHS4pmAllVVMHq5o6SrfdNaqlR2GxmIQKcnu6NDGjrV0tmYGeWupCRras+O60ptJtU0UKV4Vn5BaRlV9MPWPFXIjhCRlV0jKUmVfEpUev5BqZ2hkUx1B3K7kW1h+y0TeWtra1aGwue1ysuETMz2cimd3RBhM9xbNCyiOvsITZB+8xxaehwq6nkLg0fj0fxcYRzamtYOOOSCRiXo/GaKmr8fPJ+5wPe17h9vcSMxi/I4SvezgwyM1KoWMpw61nqQzcGMRANyt+H9RMoUam8kjOyGP41ls8fZ3N2VleMgWR5Iw8hmwOxj/6DadmesolVkkkEo6FJtF9dSAejUw4O6vNJ6tOL6OoRMwmv1i6rPKnlr4m1+f70L+5Yo7d9xGLJRy5m0i7Zb6EJ6RzbJoHS/o3xURPEwMtdb7u/p/QX82/smEUeQ+JeZ3FlD13GbHtNo1q6XFtXlsmeTesEjG45K9xrK6r/fnpTCSD3SwJXNiOpQOaYaD9T4GmtCnL8R/uuqz8Ijb5xdJm6Q3+DHzOzHaN2DjKlfFeDZTKIFIVsVjCjSevGbvjDp1X+vMmu4Cd49zZNa7FJz+XaqqpaqrFm2qqkUFdYx0W9XXk8JTWOFkaMW1vGH3X3+T8g5efxHlhZqjFT30cub6gLQba6nRfE8DcQ/fkriZWBDszfXaOa8GGEc05GJJAh+V+nLr3QiVHRWNzA8Z71ZfZZKAhEtLXxUKukQMDbQ1+6deMXeNbcDAkkb4bbvIoWTFXiaGOOquGuvBT7yZ8ffIhcw6Gyz2W0cTckDOzvDA30qbb6gBuPHmt0LErExM9TQ5OaoWhjjr9N0qvEp/k3ZAfejdhws67XHwoPVtE2XPYM6El5x+8ZG0lu2Bk4VDHgB97N2H2wXuVnu0zt5MtyRn5HAktP1voQ4RCAd/0cGDDjRi56sYb1dKnaxPV3DcCgYD+zS04Hqb4HUZvGxP8lcy90VATYlNbT2Zo8W/9m6ImrPi1LxZDVxlhtxpqQgqVaARUJrA4LjUHEz0Nhd0NZU1Tlc25iJfYm+lj+1dLX2ZuEeEJ6R8JpS8y8rj2WLl68FeZpa6b2XI2TB24k0BRiZjRresrfCxpLLnwGAMtNWYqOMr3KjOfaXvD+LqHA24KtBa9T009bX4c6EJbOxNO3n/JweCn5W4XmfyO0dtvM7eTLSNkCI6Vwen7yYzbEcI3PRyY18lW5VyhW89S6bU2kFYNjTk0pRVmhhULXTeiXtN9TQB2ZvqcnOGJtRyjt5m5Rcw8EM6v5x+zaqgz8zrZKiUmqkJ4fDq91gZyPCyJXeNb8NuAZjKDvisiLCGNvhtusurqU37q3YSDk1t9NCo4xL0uFkbaCACb2nqM85QvMDw5I48vjt6nx5pAaulr4bugLQu62GGoRFaXLIpLxBwPS6LTSj+WXohidOv6+H3RlrGeDdBSF6EuEjKvk+3fn9c01IR0cazNUPdSkfJNVgG/X4zC47frXH70il/7NeXSHG8GuFqqLCoqQ2ZeadPd1L2hfHE0AidLIwIXtmPtMBdc69WsbrOq5n+SavGmmmrkxERfk3md7Qj6sj19nC345dxjOiz3Zd9t1R0q8mBhpM2v/ZpybZ4PGiIhXVb58/mR+ySkqtZYUx5eNqacmunF3E62LDkfRb8NN+Vu0imPeZ3sqCHjg5OaSMA33R0Uelz3+qVZNO3sajFgYxBLL0Yp/Fx0bmLG5TneZOQV0XWVP4FP5XOm6GqqsWKwM990d2DmvjBWXH7yyWppP0RbQ8Smka5425jSb8NNqWHXA10tWTPMhU1+zzikYlX1h1jV1GH3hBZsC3jGwUp+bFkMdrOio0MtZuwLo0iJBb40dDXV+LlPE349H8VbOcQYAA9rE1o2rMmqq+Uv/j7ksw6NOBaqmvumr4sFwbGpvMpUzAXmbWuKvwqOpSbmBjJF01oGWvzQq7HUPCShALo2NUNXhlCioSakQMHXl0QiITtf8bEpZZqm8otKiEx+VyXOm6OhiQx8z3Vz8dFL+m0IKm1IvP2fhsQ9wfG0s1euHnxn0HM6ONSSK6Q5M7eIFVei+banQ6XlXF17nMKJsBesGuKi0HhIQXEJU/eG0t7elJEtVa9iHuppz2BXC25EveHmk4/dbKb6mnzTw0HpJi95kUgkbPGP5atjEWwY2Zwh7qp9bxKJhD8DnzNuRwjzO9vxRVf7CkfLikrEbLgRw6wD4fzYqwlL+jeTywESHJtK19X+5BYUc3GONx0caqt03oqSkVvIV8cfMHL7bQa6WnJ2lmI15B/yMjOP2QfD+erYAzrY1+LafB+6N61TrihQNqasq6nGmqEuMsel0nMK+eVcJO2X+5JfJObyXG8W9XWkloLOMXkoLBZzKCSBGfvDWXX1KVO9rfH9vC0jW9X76DoY0NwSPU01BEAdQy2WDmhGYloeKy4/wWvpdR6/fMf2Me4cm+ZBx8a1FR4LqwyiU7L45sQDWi+5xvkHL+ntbM7Nhe2Z28m2Sn5+1VTzb6JavKmmGgXR1VRjvFcDfD9vy+yONuwJjsdr6XW2+MeqVJssL1Y1dVg6sBmX53hTIpEwZe9dvjoeodLirzxEwtKg4BsL2tKpcW0m7LrLpN13iX2j+NiWlrqIFUOcpI5PCYAxrespNSOtpV5aU35yhidBsal0XeXPLQVHQWoZaLFjrDsz2zdiyp67/Hj6EXmF8olAA1wtOT3Li8evshi0ObhKxDR5EAkF/NCrMVN9rPn9YhRXI8uvEu/UuDZfdrVj8fnHbPJTLW/lQ+zNDNg+1o0t/rHceVa541my+LmPI7mFJfx2IapSH7eDQ208rI1ZdOaR3Pt82c2BmNfZxMiRl9Oolj4jWtZjs3/5WU/yUNtAi1YNa3K+gram8mjV0JjkjDyFs6PKaGJuKFcW2BB3KxzNDcrNulATChkmx8JUQyRSWBzNLxJTLJYoPDYV9zaX+gqOTEUkZVJDVwPLGorVWsvi2Zts4lJz/tHMo6Ohhra6iIS0XBadjcR10VW+O/mA0/dfMNZDcVEhOSOPnUFxzO4gn+tm3Y2ndHOsQ7tKald6k1XAjpvP+alPE+oqmDP04+lHSCQSfu7jqPBd9uISMZ8dCOd+YsY//r9js3p42tRmd9BzTt2N+0cTlam+pspCiixKxKXBy1v8n3NwcmuVf855hSXMPXSPTX6x7J3YkuEyRK6XmXkM23KLU/eSOTXTk74ussekCovFLLnwmAm7Qpje1po/x7orVb2tLBKJhBPhSXRY7kdyRh4XZnszsU1DpcXFvMISVl99SoflfggFAnaNb8nsjrYyBayWDY25932nCssBcguLWXf9KZN23yU6JZtj0zxYM8xF4TFNeSgoLmHvrXjaLfNls/8zujrW5vp8Hwa7W0l1ymioCZnbyQZNdSFfd7dn4bEHdFzhx9vsQk7O8GTHX6HRn9rVUlwi5uLDVwzbcoteawMpLBZzeEprjk3zoGcz809emFBNNf8tqq/0aqpREnWRkH4ullyY3YY/BjkR+zobj9+usfhsZKWPb5RHfRNdVgx2Zt2w5uQUlNB+uR/fnnxQ6cfW1hAxs70NNxa0pbaBJt1XB7DobKTcToQyPKxN6OVk/lGon0AAxnoa7Lz5nC+O3pdr3KQ87M0MOD7Ng9Gt67PyajRfHY9QqJ1GIBAwomU9zn3WhoikDHqsDfjoQ700rE31WDvMBWdLQ3qsDeBcROWOJcmLQCBgYpuGDG9Zj88OhrMnOK7c7VpZm3Bwciu2BTzj1/OPKzWnppauOjV1RDxJ+TQB32VoqYvYONKVwyGJXKjksbDvezYmMT1PbldWo1p62NTWY4mcQtLQFlYcDklU6bU7yM2KA3cSFHoudTXVcKtXk0Al3TeNzQ14JId4IxAIWDHYmfK0W30tNbkqrTWUyLzJKih9/Ss6/hSflqOwiBCWkE7zukaVvqA5FpZEq4bG/xj5MNBWL1W8KRWo8opK2H8nkeSMfNZef4pf9BuFRl03+MbQwaE2dmayXTcxr7PYHRzPOCXbrD5EIpHw+dH7GOlo0E8OkeB9Dt9N4PKjFDaOdFU4F0QikfDNiYdEp2TRwPTjRfMoz4Z0dDDn0qNkVlx4RHGxcsHeipJfVMKs/WEkpOVyYroHTS1Vy4lJTMtlwMYgktLzODvLS2aW0I0nr+m+OgBrUz25x6RiX2fRf8NNAp++5fRMT5nhx5XNszfZjNx+myXno/i5jyM7x7kr/PotQyKRcDaitJr7elQKeya0ZOUQZ5njZe8jzTlWWCxmT3Ac3r/7cvXxaz7vYseu8S0qvU0USq+jHTef4/O7L7uD4/iymz1X5vrQz8VSprNNIpHQ0EQPZ6sazD54j5o66lyb78Ov/ZvK5cyrbNJyCtl5Mw6fP3xZdDYSb1tTgr/qwB+DnD55jlI11fwbqK4Kr6YaFREIBLSzq0U7u1oMbVGXzX7P8PnDl17NzJnq0xCb2qrVUcrCupYea4a5EJ2SxeqrT2n7hy/DWtRlelvrSrWPmuprsrhvU8Z6NGB3cBxt//BlWltrJng1kPuD8w+9GnP1cco/sitEAgFbR7thoqfJorORtFvmy4IudoxoWU/hVgqRUMB4rwZ0alybr088oNMKP37u4ygzT+N96pvocnhKazb7P2PCrhBuLGgrV+uJlnppk1VraxMWHosgMOYtP/RqXCVhg7Lo3rQOtQ00mbjrLknpeSzsav+RtbmJuSFHp3owcvtt0nIKS7NJVJxZj3mdyZqLT3C2MGRYi/oqPZYyNDDRZcUQJ344/QgHMwOVa+/LqGOkTR9nC749+YCLc7zlek5nd7Ch7R++3Ix5i6eMemfb2vp0dKjNRt9YfpYR2C2Nzo3N+ObEQx68yKSZpZHc+3VwqMWNJ28Y0aq+wse0N9OnvrEOr9/ly3yvqW+iy7xOdqy6Gv33+JOGmpBhLazkst0rk3mTnV+MpppQ6h3Z0Pg0vjgagWUNHezM9Glgoks9Yx1i32TjJeM5+5DY19kyn2dFEYslnAxP5sfeTf7x/wZaah+JM2X5a0GxqdyNS8dYT4NJbRoy0M3yo4aY93mRkceRu0mcneUl1zn9cu4xQ92tKu332q6gOJ6mZHN+dhuFFvyh8en8ci6KraPdMK+gpUwaa67F4P/0Dcene5T78xEIBAxqVQ+X+gasv/KUVZejmN+tSZWKEmk5hUzYFfL370RV23oCn75l1oEwejmZ820P6aOLUOpqWHElml1BcSzq60j/5rLDsSUSCXtvJ7Dk/GNmtmukktNFGQqKS9joG8smv1iGuFmxcaRrhde6LB6+yOTnM5E8T83hy6729HOxkPneJJFIKCwRU1j8158SMUXFEgpLSij46//yC0u49uQ1lx+loKEm5Jd+jnRuXLtKrqWcgiL2305ks/8zaulr8mPvxnRubCbXe6xYLOHK4xQ2+sby7E02Yzzqs264S6UFkivKg6RMdgXHceZ+Mt2b1uH7Xo3pYF+ryurSq6nm/woCyaesBqmmmioiKSkJK6vSQLXbEdG0aCqf/buqiH2TzbaAZxwPe0EbGxOm+FirNHetCI9fvmPV1Wj8ot8wsmU9pvhYV4l9OTg2lV/PPyY1u4AFXezo6yz7gw7AmfvJzD98j8ISCRoiIT2d6rBisPPfX/d98pofTz/6K2/EUeHWkTJKbdQv+PlsJK0aGPNznyYKi1lZ+UUK19UCJKXnMvvgPbLzi1k33KXKBTxpPH+bw9gdd3C0MGT5IKdyRYeUd/mM3n4Hq5o6rBvuopLYtOjUPQTAVz2bIhKpLlq9zMyjjqHiC7Ofzjzi9rM0jk/3qDTxrEQsof+Gm3jbmjK/s51c+2z2i+XkvWTOzvKSKURGvXpHn3U38fu8nUJ3ed/ni6P30f5LRJSXyOR3DNwURPj3nRSqVy6j3TJffujVmLZyjHYUl4jpujrg78Y8oQCuz28rl8h2Jy6Nrf7P2DraTe5ze5CUybLLT9g1vvzGkZjXWXRc4f/3uWiqi0AiIa9IjEggoLahJvWNdbEz06ehiS5eNqY0KOdcJRIJ7r9cY+PI5pX6Ph8cm8qM/WHc+qrDPxbFsW+y6bzSX2ZgvvD/sXfW0VGd7de+ZiYOSQjEHZIQYkASIAIhwd21eJHiUqi7U6VQoBRpgeJOcYfgREiQEHch7p6R7480FIjMTAj0/fXLtRarlDlzzpmZY89+7ntvwT/m6vXxwZEHFJWLWfuaq9z9uRKZyZI9Ifi/3atJYoAj0gsZtf4m22d2UyoCOrOwnKFrr7PAz4YZCprCPs3RkFQ+/ushB+d5Y28s/9ocl5nPT2cjGeRoxFB3a6W3pwiJOSXM2BqIg4k2q8Z3fqHrVrVfThz+UVmMdDVjvJxErPSCcpbsCSG/rJJfJ7spFKOdXVzBuwfv8+hxIT+N74S3TdMKl/K4GZvNjluJJOWW8s0oF4WCDuojq6iCn85FEv64kO62+izoZdtgtd6pB495c18oYokMSR1DKIGgelJKIACp7B9h9bsxLoxxk1/50hiKK8T8eSuBoyGptFRXYYGfLX0cDBUSiCrFUo6GpvJXaCpxWSXM6tGWid0sXziOvjFUiqWcfviY7TcTiEgvYrSbGdO9rBv9DPX02CA5ORlzc/miZDPN/K/TLN4085/g6Qu09aI/6dOlA1O9rPGx1f9XzNRqyCwsZ+vNBHbeSqSfkxGDnE3o08HwlezTw9QCVl+IoqxKgrOZLnN72tC6CR64n0YqlXH8fhrfnY4gq7gC81aatDfWpqW6CtoaqrRQF6GlpoKGqggtteo/Gqoi1l6MJiytEA1VITfe61NrvyrEEjZfjWP95ViGdDThvUEdGj37k11cwRfHH3E5MpMPBzswoavFKynprpJI+fl8FNtuJvDFCCfGvEBE6YuQU1zB7D+DUPk7tr2uQVdBaRUztweiIhSweXoXpWcvox7nsedWAnF55Xw6zIF2hq1eeL/LqyT4fH+ZdwbYKx3HWymWMmHTLToY67BytMsL70sNYWkFjNlwk+OLeij0MFleJaHvKn+W9LGTO4ACmLcjGGNdjVqVFopyJy6HeTuDufNBX4VnwGUyGR7fXGT1hM54N6JyZOHuuziZ6rDAT7GEoLC0AoatvY5UVt12dWqJj0LvC07MY+Guu9z+oI/C+3YjJpuPjj7k8lt+9S7T8/vLDcadw5MOJaZ4WvHlyNrCWHJuKb1+vMLDzwc0aaXd2wfu0UJdpdbxkFVUQdevLzT4XhWhgBbqKuyc5VFv601ybil9VvlzakmPJwP2KokUoUBQS2ysEd4mdbNsErPe8ioJI9bdoJ+jEW8NUEwMhepz+7XNt7Fqo8VP4zopfU29HJnJ4t0h/DGjq1KC0ekHaWy/EUcXq1bM7WmHdoummxAJTc5n1rZARrqa8eFghxd6PiitFPP2wfuEJObx21R3uVV4mUXlDFx9jT4dDPl8hJNCMc+XIzJ5++A9PNq24ZtRLi8lFak+coor+PpkOGfD0lnevz3TvawbLYZUiqVsuxnP2osxdLfV5/3BikV7J+eW4vvDZRTtTBQAq8Z3YpQC1UzKUlBWxbYbCfxxIx5bw5Ys6WNHTzt9hc6L4goxewOS2HItHi11EfN62jCis2m1iP2KySgoY1dAMrvvJNFSXcQ0L2u5VYOK0CzeNPNfpLltqpn/HAfne3IlRcqK/aG0VFdhiqcV49wtXukDRg2GOhq8O7ADC/xsOBCcwodHHvCdpipv9GzHyM5mL7XE2NlMly3TuxKSlMfqC9H4fHeJ17u3ZbZP2xeKzHwaoVDAiM5mDHAyxmvlReJzSol/yrBXJKyegRIKBQgEgieDIKlMhozq9p66BCV1lWqfnZGuZnx1Ipw394XSp4MhUzytlH5Q02+pzi+vuXIpIoOPjjzkYkS1iNNULTX1oSoS8s7ADnjZtGHtxWj8o7L5ZpRzoyp5XoQ2LdXZM8eTpXtDGLPh5t9+AM9+dl0tVXbO8uCrk4+oqJKCEoUf9xMy2XQ9DsMW6nw+3BFrg6bpQddQFbF6Qmdmbw/CrJWmUsKCmoqQdZPcGPrLNbq11WOUa9M8sDmZ6jLFw4oPjjxg3xtezwyyZDIZZ8MyMNfTfNKHr6Eq4r1BHfji+COGdjR5ZmCUmFPC6gvRTPKwfFKtsaSPHaM33Gh0y2NX69a01FDhUkSmwq2CAoEA3/YGXInKapR442iimO9NDU6muoxzt2BfUDIjnzLhlYd6I9qmisqr5M4ej3UzZ/2VmAaTrGSArqYqy/u1r/P1u0l5OJnqNKlwU1Yp4fTDdHbP8aj1mrzoczUVIeatNNk526PBlqL1l2MY5Gz8TKXFu4fuczsul29GOT9TTbU7IAmpTMZUr6aJx/7uTAQaaiKFo8lr+OJEGBViCd+MclFauLmfks/i3SGsHO2ilHADMNDZBAttVbbeTuCnM494Z7ATWpovfh89/yiDZXtDWNHf/oVFsYTsEubuCEavhSrHFvdQaMLDUFuDTVPdFYpYL6+S8M2pcA7fTeWz4U6McTN7ZRMSUqmM/UHJrDwdgWe71lxY4duoqkyovlZfDM/k61PhqKsI2TjNXanKIYvWWkz2sGJfYLLca5KaSMDwzmZNLtzklVTyx414tt1IwMlMhw2T3fCyaaPQ75FTXMH2mwlsv5WItX4LPhvuRP9/ITVKJpMRnJjHtpsJpBeUo62hwo/jOtLTzuBfnXRtppn/dZobB5v5z2Gko8mK/vbcfK8Pb/Zrz+mH6XisvMB7h+7zSE6s7ctCW0OVmd3bcu3dXrzh047f/GPx+b46oaqo/OUmVLla6rF9Zjf+nNWN0OR8fL67zM/no5Qy85WHhqqIs8t6ovnc4EUihUqJrNpUs1JC6d9/yquktNJS5as6ZrGfxlxPi9+mujO7R1v+vJXIsHU3CErIbdQ+9u5gxLnlvjia6DBozTV+849F3ISx0vXhY2fA+snu5JdWMuSX6/XGeL9MNFRF/DrZnVGuZoxcf4OQpLxay2iqifh6lItSLXbxGflsvBxFBwMtPhrRqcmEmxq62+rz+Qgn5u0MJiZTfnLT05i10mTVhM58dOQh0QqkPinKm/3ak5pXxoHg5Cf/lpRTysRNt5m3M5jdz8WkD3ExwVxPk43+1WlSeSWVfHz0IX1+8uev0NRnTLEdTXXoaWfAb/6NS54SCgWMcTPn0N0Upd7nZ2+If2TjTIudTHUUSpx6mk+HOQAoFavdKMPicrFcoWNIJxO58fKqIgGrJ3aut1UoODEP1yaOCD/3KB0jHXVc6jDk1FAV1Zvcp64ipKu1HscW92hQuEnOLeVwSCpLnkuYSs4tJS2/jDl/BjF5823is0ueRIN/PMSx3oQaZbgSmcn+wGTWTOis1Pr2BSZx6kE6vzXCoDgxp4SZ2wJZ1tfumeQuRREIBDhbG/D+ICfKxBJ+vRSNVPpi9499gUks3RvCj+M6vbBwczkyk+HrrtPDTp+dszyUqlRVRLipqZh7mFrAqSU+jHV/dZWkURlFTNh0i7WXYvhpXCc2Tu3SaOEmKqOIaX8E8PbBe8zq0ZYTi3s0quVraV+7f0ry6kEgqJ48+mJE4yop6yK7uIJvT4fT47tLhCbn8/uMrux9wwtvW/nVNim5pXz610N6fHeZ0JQCfpviztEF3gx0VswTp6kor5KwPzCZIb9c5/VtgRjpaPDjuE5sfb0bfvavpjK9mWb+L9Ms3jTzn0VNRciIzmYcmu/NofneCATw0dGHjNlwk79CU6kQKxYF3ZSoq4gY39WCC2/68uUIZ848TMf720t8dyaCzMLyl7ptd6vW7JztwZbpXbgdl4PPd5dYezGaoiYScQx1NPh+bEdURfJvvOoqQj4e4oimAiXaAL72hpxe5sPQjiZM+yOA5ftDySpSPpWqpboKb/Zrz87Z3TgQlMzIX28Q9goEPQNtdba/3o2J3SyYsPE2W67FNWnCkyKIhAIW97FjcR87pmy5w7mw9BdaX2VlJb/7x9BCXYVFAzoiFL6c28n4LhZM87JmxtZApX/zXvaGzOhuzfxddympaJq0mBovpm9ORZBeUMa6S9H0WXWF4MRqQSw179nEKIFAwEdDHdlyNZbvT0fg9e1F9gclI5bKEAkFlD4XSb+kjx2nHz4mq6hx14Mxbub4R2YpldrWw1afmKxi0vKVT7tyMtUlIaeEYiW+Xy11VazbaFGhhHiqJlJevCmuEMutvLExaIll6/qTadRUhIx0NWswrvluUh5ujfTmqo/Dd1MZ3UCrpZZabfFCVSRgXBdz/pzpIfdz7wlIYnwXi1ppQjWifpVExu34XPqt8mfmtgBcTHXxszdo5Kf5h+ziCrbeSODT4U5KVT+GJufz2bFHrJvkirmecklC2cUVTPsjgJGdzZjt007ZXX4GfV0tlvTrQFhaPoeDExsl4EilMr49HcGvl2PZ/npXBrmYNHp/pFIZay9Gs3DXXb4c6czHQx2b1FNFKpWx6WosYzfcYkJXC/bP9Wp0kpOylFVKWHUukuHrruNqqcf55T3p62jUqHXll1ay+kIUw9Zex9awJVfe6tWoSt4a9FuqM7dnO9QbqJ4WCQT8NtVdoVY0eWQWlvPliUf4fHeZ/NIqdsz2YMcsD4UqyCLSC3lzXyi9frqCRCrjwDwv/pzZTeFKnaYiJa+UlafD8Vx5kd+vxzPF04o7H/Th46GOL70Suplm/ks0izfN/H+Bk6kuK0d3ZOuMbgxyNubn81F0//YSP5yNaNSA5UURCgX0dzLm0Hxvfp/elaj0ImZsDeT9ww+Izy55qdv2aNeGvW948tsUd27F5TB07XU2XIltksHtsE6m9OlgVCsO/HnM9TSVjoVVVxGxsJct55f7Ul4lofePV/jjenyjqmfcrVpzaqkPve0NGbPhJt+diaC86uWKeUKhgAV+tuyc7cHWGwnM2h5EbknlS91mXbzevS0/je/Msn2hbLsR36h1PEzI4N0DIWQXV7KgjxNXIjO5FJHRxHv6Dyv6t8fNUo/ZfwZRVqnc7/Rm3/bot1RjZRNGovd1NKKrtR79fr7K2ksxVElkiP82QEgveFZ0kUplJOWUIpbBb1djKa+SPmnRkUhllD133Dmb6eJipsuW6437bSxaa9HJQpczDxUX53S1VHG1aMXVqGerb8oqJdyMzaa0sv5rg4G2OgYt1Yl4rFz1jZGOBo8LFBeoVP9um1LmN6yuvJHfpjjG3bzeQZiepiqfDat/5ry0Ukz44yLcLFspvF/yyCwsJyQpj5ENXCNbPCfOqAgFfDjYga9Gusg1x07ILmHL9Xhm1VHtUVT+z28tkVYf18FJ+dxNymN/ULJSEeTPI5PJeOvAPVqoixjrpvj1P6uogm9PhbOif3ulqyRKK8XM2haIi5kuHwx2UHaXgWrj9wNB/1TambVuyVBXC07cf8zXxx9QpkT1bIVYwtJ9oZx68Jitr3ela9s2jdonqG4L/OJEGPuCkjkwz4sRnZW7p8rjcUEZU36/w87bSeya48Fsn3avLOnncmQm/Vf7k5xXxuH53flgsEOjRBCxRFqdjvnjFUKT8ji5uAefDnN64Tb60koxAqhXUFZXEbKsr51SyX91kZZfxid/PcTnb2+u/XO9+HZMR4WqFgMTcpm5LZAR626gpSbiwnJfvhrl8krjtWUyGTdisvnkr4f0/tGfpJxSfpvizpllPkzysGwSYauZZv5/o1m8aeb/K3S1VJnt045LK/z4aXxnItOL8f3hMm/8GcSNmOxXXg0hEAjo1rY1v8/oys8TOlMpljJg9VXm7wwm9Kl2ipexXW9bfXbN9uDLkc6cDUun5/eX2Xw1TunB8fN8O8YFzTpmhWsQCQV8OcK50aWxZq00+XWyO79OcWPnnUTGbbzFnbgcpdejriJieX97ji7szs3YHAatucbtRqxHWdyt9Di1xAc1kZBBa65yOzb7pW/zeQY6G7Nztge/XIrhqxOPlBqQhSWm8cvFMHRVxPz8mivWRtqUVIhZuCuEsw8fv5T9FQgE/DCuI2oiAW/uC1Vqf1VEQtZMdOVadDZ7A5Plv0EOBaVVvH3wHpcjsygqF9fySskp+afi5WZsNgNWX+WdQ/epEEtrGVxKZVBah2g6z8+GnbcSyWukuDehqyV7ApPkL/gUvu0NuBKZRXx2CVtvxDPut5s4f3aWSZvvcDcxv8H3Opoq53sDYKKrQXqB4sJ5jSBcJVH8ty+ukN82BTCso2mdrVMqQgHrJ7vVEkqe5n5KAW1aqGHWiLjq+jh2L41OFq0aXOfTn0tdRcjm6V0UTl765VI0wzuZ1pmcVZ+IX1Ip4ZO/whiw+irBiY1rXd12M4Go9CJWjlK8Uq9KImXhrruYtNKsU2xqCPHf79VUE/HT+E6NuuckZJfw2qbbxGQVP/PvY7pY8v3ojpRUivn5XARiBSp580srmboloLplbYE37Z6relKGmMxiRq6/QUxmMX8t6o6TadMOyE/ef8zA1dcwa6XJqaU+SrU4vggZheUs3HWXpXtCmOdrw0/jOuFoqtOodV2PzmbwL9fYdiOBVeOr23JsXzD5sVIsZcetBHp+f4Wr0dlM9bKqJfyqCAU4mOgwX0ET97pIzi3l/cMP8PvxCjnFlRxd2J3N07rUaz5eg1Qq48KjDMZsuMnMrYF0MNbm2ru9+HqUi0JmzE1FcYWYHbcS6PfzVRbvCaGVpipX3vZjwxR3PNu92oqfZpr5r9EseTbz/yVCYbVJp297A5JzS9kdkMTiPSF0a9saj7atGeP+4i73ymJvrM1P4zuxon97/rgez+TNt3Ex12Wurw1+7Q1eys1OIBDQs70BPnb6XInMYtX5KDZdi2OBnw2vdbNslAFnKy011kysNpoVPzdaFQAt1EVs8I9Fr4UaDiaNeyiDai+ZM0t7si8wiZnbAunnaMQHgx2UNnrtYKzD4fnebLuZwIr99+jTwZC3Btq/1N9fV0uVDVPc2HErka9PhdPHwYjFve3kzpg3JW6WehxZ4M2MrYGk5pfx8wT58bRZWdmsOvMIY10tPhrTDRWV6lvIkI6maGuosnD3XYoqJIx1b/pEB3UVEZumdmHJ3hBWnY9SKqHGSEeDb0a7MHt7EJ3MWzVqMCCTyTh+/zEfHXlAeZW03pjm/NIqMgvLeXP/Pe7E5dQ6B56nqI7BspulHq6Wemy9mVCvSW5DDHAy4qOjD4hIL6SDccOftbxKwu24HMLTC7kQnsG5R+moqQgpr/pHzLAzaniQ6WSqQ2S6cuKNsa6mUpU3NebulRKpwkbvReVVtFEgFchavwXW+i2Iy/qn6lFdRcg0Lyu5fiCR6UUMcDJq0uvzkZBUpntbN7hMjWiop6XK7jmeCl9LY7OKOXH/MRfe9K3z9ecrwZ7fZkxmMRM23mawiwmrJ3RWWBAJf1zI92eqY9uVqXr46sQjiirEShsUy2QyPjsWhpqKkNUTXVFXUf5elphTwmubbzOskwnvDexQ63VDvZYs6dOe785E8OetOGb61G++nJxbyvStAdgatGTNRNcGJzjkcS4snRX77zHZ04q3B9g36X2juELMZ8fCOP8og5WjXRj8Ai1dyiCRythxK4GfzkXR28GQiyv8lPJfe5qE7BK+OhnOnfgclvaxY5qX9QuHQ9Qka/50Lgo1FSFfj3Kmv6MRlRIppx48pqL4H6FdVSRk/WS3Rv0u8dkl7LydyI7biQx2NubkYsWSDaskUo6FpnHobgrRmcXM6tGWra93feXPsXFZxfx5K5FDwSm0NWjBfF8bhnQ0aVIz92aa+f+d5sqbZv6/x6K1Fu8O7MDN93rT39GIv0LT8PzmIh8cqR78vGpMW2ny0VBHbr7XBx87A94+cI9Ba65x8l6aXGPNxiIQCOjVwZBji7rz9Uhn9gel4PvDZXbcSmiUN5CfvSGj3Wq3IgiFArbO6Iq9kTYj19/gnYP3arWZKIOaipCpXtZcWOFLlVRG75/82XItTunvSSQUMKtHW/a84UF8Tgn9Vvm/sCeMPAQCAdO8rfluTCeO3Utj0ubbL/RdNAarNi04NN+brKIKPjjyoEGflJKSEr76KwBJWQUfjXB9ItzU0LO9ARunuPPpXw/ZfUe5qg9F0WuhxpcjnNl1J5FddxKVem93W33m+rZj0e67Svmz1DBrWyAr9odSWC5uMGFELJURm1VMUEIuitSI1Lcvi3rbsvVGPIWNMDTX1lBloJMxh4LrNi4uqRDz560EJm66hctnZ5m7I5izYemIpTKkMp4Rblqqq2AoZxDlbKrLvRTlvKOs22ghVGIwXnMtqVCivbFKIkNHgcobgHFPtU4JANNWGgoJhNeis7FowDNHWaIyiojJLGaQnLSwnOIK1FWEnF3WUykR/JeL0Yx2NavTt6RCLJFb2SQDhAIBhUp4pZVXSViyJ4Q5Pm2VSnk6EJTMX/fS2DTVXWmxY/WFaC5GZPLZcCd0NZUfwCbnlvLaptsMcjbhg8EO9QpHpq21GedugX9UFtce1V15eD8ln1G/3qCnnQEbpij/WWqQSmWsOhfJ8v33+G5sR94b1KFJhZuQpDyGrLlGWn4ZZ5b5vDLh5mFqAaN+vcG2mwlsmOLOmomujRJuisqr+OlcJANWX8VAW53Lb/kx26fdCwk3MpmMK5GZDF17ne9OR7Coty1nlvowwMkYgUCAukp1omDNtUNVJOD7sS5KV+LFZBaxbG8IA1ZfRUUo4Oyynqye6CpXuCmtFLP1Rjx+P1xh7aVoxrqbc+2dXszztXllwo1EKsM/KpNpfwQwcM018ksr+XNWN/5a2J0x7ubNwk0zzTQxzeJNM838jYaqiNFu5hxd2J19b3hRJZYyYt0Nxv92i+P30pQ2y3xRdLVUWdjLluvv9ma6tzU/nIvE74crbL0R36AHxYsgEFR78Zxc3IPPhjlxKzaHXj9cYfedJKU//6fDHGn11AyrmkjAaDcz3K1a89FQR86/6UtppYReP15h1bnIRg2oazDR1WT9JDc2TnVnb2AyQ35pXAuUZesW/DmzG28P6MDbB++zcNfdRhkjK4OjqQ4nFvfAorUWg9ZcfaneMXXRuoUaO2d1o1IsZcyGmyTU4blUVlbG27uDyClT5e3R3dDUrPvB1NtWn+0zu7HlWhw7biW8lP211m/Bpmld+OpEOFciM5V67+Ledpi00uCDww+UbpHsaNEKmQzk+XGLhAIMtDW4sNwXFzPdBg0tAUor6hYjPNq2poOxNjtuKSdS1TDW3YIjIWl1ekLdjsvhk7/CuB2XS5VERoVYSn16lJ1RS7kVD46mOkRlFCl1jWilpcbdOlLP6qMmXUleJdPTZBdX0EJB8WaIi+mT/RcJBfw62V1utYZMJiMkKQ/3JjQrPhKSSj9Howa9ejILyymvlHBsUXelKg2jM4o48zCdRb3rbud42u+mLlRFArTURHw/1oWtr3dVuOrm65PhaGuo1Eq2aoj7Kfl88lcYa19zVVoc2xOQxNYb8Wyf2a1RqUTJuaV8cTyM/k7GfDy0fuGmhu7tjRjRyZw/AxL47VLEM6+df5TOsr2hzPO14bPhTs+ILan5ZWy5pliyXEFpFbO2B3L8/mMOL/BuUmFFLJHy8/koJm2+w5ye7dg5y6PRaU7KUlhexbQ/AvCzN+TMsp70sFM++UkqlbE/MJleP/qTXlDO4QXerBztolTiVl3cTcrj3UP3WbYvlNFuZlx6y4/xXSxq+f6McjXHWEcDoQAGOhkzrJPi3kPhjwtZuOsug3+5jqaaiAtv+vL+YIc6WxqfJq+k2oC5+7eXOHw3lQ8GO3BxhR+j3V6dWFJQWsXmq3H0+vEKX554hLtlK26825vVE11xtdT7n2iNUjalsplm/i/QLN4000wduJjr8sO4Ttx+vw99HQ354Wwk3b+7xJZrca+8OkJDVcRr3Sy5uMKPDwY7cPhuKt7fXmLV+SilEmWUQSgUMMjFhHWT3Hh/sAO/X4+j909X2B+YrLBBcAt1FdZPcvsn0lYg4O2nZrIt22ixbpIbu+Z4cDM2B78frrDrTuILxXd3t9Xn9FIfxrlbMHt7EEv2hCj9ewkEAsa6m3NhuS8IoO8qfw4EJb9UPyQtNRV+HNeJT4Y5smRPKF+dePRKxUINNRV+mehKfydjRv16o5anhaamJn07mvLjOBecLBtOnOli3Zqfxnfih7ORbLoa+1L2t6t1a74d48Li3SGEK2GUKxIKWD3BlVtxObUiveWxrG97zizrSUeLVg3O5KqJhGQVVWDRWovD871Z0b89qiIB9Y1zS+oRYgUCAYt727HlWtwzYm1JhZhNV2Ppt8q/QcNrL5s2qIoEXI2uHQHex8GIOT5t5c5ICwXgroDXhYWeFhoqIqKVeFA20dUgQ4mEPRWREJFQoNR5oahhMVRfj2rE5jf72SlUzZKUW0pheVWT+Y1IpTL+CklltBwz390BSfRob4C9nJa451l9MZpxXczrTWsqLKtCVM+AS1VU3Wrs/3YvRroqHhN9/lEGR0NSWTPRVWGz2+ziCubtCGZZXzt87JRLuLoYnsGXJx6xZXpX2jfC3yQ5t5SJm25joqvJp8McFfqcAoGA0V0sebu/PWGphey6EYNMVp3StGxvKO8Osq+VchWcmMeIdTeIzSqW6+GVV1LJ8PXXEQgEHF3YvVGfqz4Sc0oYt/EWpx485tB8b6Z4Wr3SqGYdDVWuvtOL5f3aN0p0CEzIZfj666y5GM0XI5z4fmzHFz4fYzKLmLsjiClb7mCup8nVd3ox26ddvfsnEgr4cqQz7Y20+Wa0i0LbeJhawBt/BjFy/Q3atFTj8lt+rBzdUW6SV2p+GZ8fD6P7d5cITMhl7WtuHFvUnSEdTV5Z23X440LeP3wfj5UXOP8og3cG2nN6aU+W9m3f6Fa3pqSgtIodtxIYtvY6s7YH/du700wzTU6z500zzTSAXgs13uhpw+we7fCPymJ/UDLfn4mkr6MhUz2t8WzX+pXNLoiEAoZ0NGGwizG3YnPY4B/LpquxjO9iwRyfdk1aul+DUChgWCdTBruYcPxeGmsuRvPR0Qfoaqpi1aYFKiIBQkH1H4GAv/9e/TArFFS/31xPk4ScUhb42mCoXXuW2M1SjwPzvDgbls63pyPwj8xiYjcLetkbNuq7VRUJmdOzHcM7m/Ld6QgmbLzJZE8rXu/eFlUlkjIMtNVZP8mN848y+OjoA47dS+Prkc5YvkTTv1Gu5nS20GPR7ruM/e0mv0zsjLV+400tlUEoFPDBYAcs9DT58WwU07ysnomwHe2h+Ky5q6Ueu+d4MuX3O1SKpSzqrfh7FWVEZzOSckqZuS2Qowu7Y6RgBYKBtjprJnZm1rYgOlu0UupB39awJYfne/NXaCqf/BVGhVhay7BYIIDMv2O+hUIBb/S0wbe9IQt2BZOSV1Zr+YYMwn3s9LFsrcXuO0mMdTdn6414Nl+LRyqVUS6WUlBWResWanW+VyQUMMrVjEPBqfTuUDte94PBDuQUV3LyweNa+1SDhqoIJzP5AoFQKMDhb9NiRb9PY10NsosrqRBLFPYjURMJG2xZe57icjHaciKzn8aqjRYlFYXM81XMaDQ4MQ8nU90mm+m+HZ9DhVjaoGBRKZay604S34/pqNS6I9ILufAogytv+9W7TGG5GBWRAIn4HzFBTSREXVXI92M6Kh1pnVFYzs7bCXwxwknh+1ONQbGrlR5v9FQu1jskKY8le0L4cVwnpdqzaqgRbvo4GPL5cCel7z/tTVvzmoc1v1+P4VpcPneT8tnzhmetxKFDwSl8dPQh7w60Z7q3tdzttNJS5f1BHejvaNxkwopMJuNgcAqfH3/EWHdz3hvU4V9rb5EXa18XqfllfHs6govhGSzws2lQXFGUtPwyVl+I4q/QNMZ3seDK2351PrPURc/2BvRsr5jQeDYsnaV7Q5jUzYqr7/RS6N4VnVHEb/5xPC4oo5WWKnvrOK5eJlUSKefCMth+K4H7KfmM7GzGofneTW6U3Vgk0upUq/1ByZx7lIGzqQ6TPCzpPMgMx1/+7b1rppmmpVm8aaYZBRAKqz1henUwJCmnlJ13Epm/KxhDbXWmeloxys28UQ8gjaEmKcrbVp+wtAI2+scxfuMtulnrMaenzUuJgRQJBYx0NWNoRxOGr7vBo8eFZBUrloQjAHrZG/CGb/0P4gKBgIHOJvTuYMiu24ms2H8PBxMdPhjs0OjPY6SjwaoJnbkVm8Onxx6yPyiFL4Y74W2rXFl2P0cjPNq15qezkYzfeJvZPm15vXvblzbL1Va/BYcXePPt6QiW7g1llk87hncyfSnbqoupXtYY62iwbF8oH+26y4V3vdHTU74txNlMlz1zPJmy5Q6VEhlv9rVrcqFzUW9bEnOrBZz9c70aTAV6Gm8bfeb72fDViUdsmtZF4eoMqD5WR7qa06uDEd+diWB/YDISqeyJv41YIqvVamdvrM3ppT35+UIUm6/GPbN8QwaxAoGAqV5WrLkQzfdnIhEI/jGqFfBPK1F9jHE3Z9DfHgSttJ4VeQQCAd+P7UheaSU3Y3PqFHAqxVIcTRQ7/xxNdHikROKUfkt1REIBmYUVCg/sVUXKVt5U0VLBtimoPma7tW2t8Ll9NymvSVN4jtxNZVgn0wZF5jNh6WipifBVcKBYw6+XY5nvZ9NgO0xhWdUzPk2qIgH9HI34aqQzevWIhPUhlcpYsf8eBtrqjHJT3MD85/NRtFRX4YexHZW6XsRlFTNrexBvD7BvVEvRiwo3NXi3NyQ5r4TgpAL+WtT9yfctlcoIf1zIZ8fDiHhcyKZp7gpXFdXcH5uK/NJKPjjygID4PNZOcqWXvWGTrftlU1ohZuPVODZdjWOQszGXVvhhrKtcSMHz5JVU8uuVGHbcTqS/ozFnl/XEWk7b0ovg296Aa+/0VqhKJTgxjw1XYrkWncVoNzO+HOGEjWHTVV7JI7u4gj13kjgXlk5BuZgpnpZsmupe637yb5GQXcLB4BRCk/OJzChitJsZp5b0wPbv7yglpW7ft2aa+b9Mc9tUM80oiWUbLT4Y7MDt9/swx6cdB4JT8PzmIp/89VCptoGmwMlUl19ec2XfXE9aaakx7rdbTP39zkuLPVcRCflrUXc6GGuj6KNtKy1VNkxxR0tN/iBKTUXE6z3aceXtXriY6zL2t5ss3x9KWr7ikcLP42XThpNLfJjY1YI3dgSzcPddHisRUQzVpd2fj3Bm9cTO7LydyJgNN4lMf3m/tbqKiE+HObGotx2f/PWQdw/ef2k+R3XRz8mYvW94IQFmfXez0etxMNFh7xue7AlI4rszkU1+TAoEAr4Z5YKOhiofHnlQbwJUXSzqZYummgrvN8L/BkBXU5VvRrlwZEF1G4P6U2lImXX4JKmpCHl3YAf2z/PCWFfjifBSn89Icm4p7x26z3uHHpCSV0al5NkqHxnIrSSzMWiJg7E2p+uJcFcRCdkwxR0nUx3U6jDzkQHtDBQbxDiZ6hCWprhpsUgowFBbXanWKTUVkVJm5EUKRoXXkJhTSlslKt3uJubjZtVK4eUboqxSwqWITEa5Ntwy5R+ZyQxva6UqMB6mFnDuUTqTulk2uFxBaSWVYikCqq/bv01xZ/1kN6WFG4At1+NIzC3hixFOCr/nSEgKu+4k8ckwR4XuFzXUGK6P62KucFz60zSVcFPDBI+2fDHShcScUlaeesRrm27h+OkZhqy9TmBCHgfneyvdDtZU3IzNZtCaa1SKZZxd5vN/RriRyWT8FZrKmN9ucic+l91zPFg1ofMLCTellWI2+cfi+8NlojKKOTjPm19ec32pwg1UVzQ2JNzIZDIuR2QyfuMtpv8RgI1hC66904uVozu+MuEmNDmfN/eF4v3tJQISclnatz2XV/jyRk+bf124KakQcyAomfEbb9H/56vEZBYz26ctt97rzfuDHJ4IN80081+lufKmmWYaiYaqiHFdLBjXxYLQ5Hz+vJnAjD8CsGzdgmleVvRzNFK4x/9FsWzdgs9HOLO0b3u230xg4e67WOhpMde3HYOcm7YXWlUkZMv0LvRbdbXBqgGoTohZ0V/5XnZdTVXeH+TAFA8rfjwXSe+frjCze1vm+9koVSXx9D7P/ruC5ZtT4fT9yZ/FfeyY2V2+78fTeLZrw5llPVl9IZoR66/zRk8bFvayaVQMrSL0czTi1BIflu4NYfi6G6yb5Co3+rkp2Hf9Ed52xoR+O4S7ibmsvxzNPF/bRh1Hdkba7HvDk0mbq1uoFDEAVQY1FSG/TXFn1vZAvjzxiM+GKzZYFAoFfDemI4N/ucauO0lM8bRq1PZdzHU5tdSHPQGJfHkinAqxFP+oLD4Y7FDn8m6Welxc4cuXJx6xJyCZ/NJnK9hiMotZfSGK0w/TEQoaNuhV5Pd4zcOSvQHJvNat7s+noSpi+8xujPr1Jok5Jc+kDVm21lK41dDJVJdHaWFIpTKFhQVjXQ3l4sKVqLyRyWQUV4iVqohMyCnBSo7nRA0lFWIi0gubrPLmQngGRroadDSvv9LpYWoBpx6k88kwxQURgFXno5jiYSXX3Pj4/WqRr7+TEd+P7dSolKaa/Vx1PordczwVvl4/TC3gwyMP2TDFHSslWlNLKsTM3BZIB2Nt3h1QO85bHk0l3ISlFZCSV0ZAfC7Xo7OJzixCJBQglsieqWYa526utFdRU1AhlvDj2Uh23UniyxHOjHYz+58wlFWE+yn5fHH8Ecl5pbw7sAMjO5u9UPtYlUTK3sBkfrkYjVkrTTZP74JH2zZNuMeNQyyRcv5RBmsuRpNdXMnMHtZsntal0eehslSIJZy8/5jtNxOIySxmrLs5p5b4YGv4alq3G0ImkxGYkMeBoGROPniMZWstxnWxYMNkN9q8oDF1M838X6NZvGmmmSags0UrOk/oTG5JJfsCk/nqZDifH3/EJA9LJnazULhv+kVp3UKNN/u1Z65vO/YHJrPyVATfn4lknm+7Jk0hMNfT4ucJnVi8J6TBaFltDRXGd2l4trchLFprsWaiK/dT8vnqZDhjf7vF5G4WvOZhpZR/TQ2GOhqsnujKnbgcPj0WRnBiLtO92iqVcKGhWh0NOrSjCe8eus+pB4/5bkzHJk2ceRrTVprsmeNZHfH7600+HOLApG6WL+3BOzgumaN3k6iQlTPNqDX6LdU5FJxKRmEFHwx2aNQx1M6gJfvmejJ7exA/nBXyVn/7JjXF1NVSZdX4zoz69QZt9Vsw3dtaofc97X/jaqmc/83TiIQCpnhaM9DZhBHrrhOXVUx5laTe70pLTYWVozvSTr8lX58KJ/xx4ROD3FnbA0nKKUUGyAvFVpUXfQUMcjLhk7/CiMksrvchXFuj2kNh+NrrZBRVPKlg6tSAkPA8dkYtqZLISMwtxURXg4j0IsLSCriXnI9+S3XeGVh7YG2so5xpsZqK4p43JZUSZDIUFg8qxVJS88qwVlA4eJBSgImuBqZKRgLXx9GQVAb9HT9cH3/eSmCUm5lSg7m7SXncjsvh+7ENe+RUiCXcTylgXBdzfhjbSeH1P09ppZgle0JY6Gf7jLCVXVxBal4ZnSxa1XpPbkklc3cEs6i3rVLtYFUSKQt23UVHU4WvR7kofU1Jzi3l46MPGy3cVIqlfHz0AWfCMigoq0JDVUiVRPbk/JE+d28UCmBp36b3/5JHVEYRS/aEoCoScnxxD2wM/v3BuCJkFpXzw5lIjt9PY3aPdmz366Zwa2xdSKUyTj54zE/nIqtNhkc4M8DJ6F8XscoqJRwITmbT1TiMdTSY4mnF2FcYsf24oIyDQSlsu5mArpYq072sGe1m1qiJspexb4fvpnI7Nof7qQWM7GzK/rleOJnq/Ou/WzPN/Fs0t00100wT0rqFGvP9bLj6Ti++GulMcGIePb69zOI9IQQm5L7UxKKn0VJTYUb3tlx5248V/dtzOzaX7t9eYu3F6Foz/Y1loLMJ47pY1BuFLACGdzJVaIApj47mrdj3hifvDrRn261EBqy+yvlHGY3+Pj3ateHE4h70tDNg/s5gFuwKVro1y9lMl6MLuzPGzZwpW+6w+kIUJS8Qd94QKiIhy/vbs2V6F9ZciGbR7hAKyqqafDs5Obn8evohTqatmebjBoBlmxYcmu9FdEYxr22+3eiEM6s2Ldg6oysn7j/mgyMP5CasKItlGy02TevCd2cilIpb97bRZ56vDYt2h7xQXD1U+7hcfac3jqa6rLsUI3f5OT3bMatHW1ae/ideePvr3bDW15IbMQ4oVNmnq6VKPwcjDt1tuPdfv6U6++d5PWkzEkCdA+3nKSit4mZsNttvJqDfUo2xG27i8MkZxv92i69OPGJ/UAoP62mnUrbyRlUkVLjypvjvdjRFK2+Sc0vR1lDBWEHj6+CkPDpbNI1gm1NcwdXoLEY20DKVV1LJX6FpTPNSrkLs5/NRTPe2lhub/Pv1eFq3UOPb0coZIT/Plyceod9SnQW9njV93no9nhHrb7DuUvQz122xRMqi3XfpZKHLfF+bZ96TW1LJH9fj62yHlMlkvH/4AZlFFfw2xV2pCkr4p+LGWr9FoytuhAI49yjjybW4vEpab+umUAC9OxjWm/T1MpDJZGy9Ec+IdTfo3cGQQ/O9/08INxViCRuuxNL7R39KKsWcf9OXtwbYN1q4kclkXI3KYvj663xzKpwFfracXdaTgc4Ni6Uvm4LSKtZejKb7d5fYG5DMuwM7sPcNT6Z4Wr104UYmk3E7LocFu4Lx/f4K91IKWPOaKxeX+zLd2/pfFW4qxBJO3E9j+h8B9Pz+MgHxuUzxtOLOB334fIQzzma6zcJNM/9fI5C9qtFkM828RFJSUrCwsAAgKSnpyd//F0jILmHn7UQOBKfQ0UyXgS7GjOxs9kIzSMoik8nwj8pio38c91LymdjVklk+bTF7wVnj8ioJg3+5RkJ2Cc8/s7ZUV0FdRYBF6xYs79ceHzv9Jrnh1pQ8rz4fhY1hSz4c7KDQILM+MovK+fZ0BGceprOoty2ze7RTeiAQn13ClyceEZlexDejXZQ2E1WGnOIK3jl0n9IKCW8PtG+yto3krBy+PnoPoUjAZyM6Y9jm2fWWV0lYsf8eYWkFbH29q1LeIE/zuKCMyZvv4Gqpx/djOza58fPxe2m8f/gB++d64WiqWHuCRCpj2h93aNOiuhLnRY/TsLQCxmy4ybFFPeTG+uaXVtLz+8usm+T2JK2krFLCWwfucf5RRoOVJhFfDlToIf9yRCbvH37Ajfd6y/2+ozKKGLzmGmKpjH1veOLRrnY7QWmlmGV7QwlOyiOnuBINVSHIoLwOYUVTVcTHQx2Z5FG7Am/bzXjCUgv5YdyzlR5F5VWcvP+Y8ioJVRIZlRIplWIpJx88pp2+FkY6mpRVSagQS6iokpJZWE58TilaaiJaqqugraGCikhIfHYxwzqaoqOpSkt1FXQ0VNHWUKG7nT46zw1OLkdk8vWpcC4s95X7fQLM2haIl02bWhHQjeHPWwkcv5fGgXne9S6z0T+WSxGZ7JvrVeu1Mw/TuRGTxaLeds8k1wTE5zJzWyDX3unVoG9NRmE5vX+8wh8zutb5eyvK6QePeffQfU4v61nr3jJmw02CE/NQUxHiY6fPLxNdaaGuwtcnH+EflcWRBd1r3RO33Yjns+OP8G1vwG9T3NFU++dYX3UukkN3Uzm8wFvhpLkaaoSbfo5GCseBP49YLOXzE4849eAxZVUSShtIjYNqc/F9c71eWoXm82QWlvPWwfvEZhazanynF/pdXxUymYzzjzLYF5RMWn45nw5zxPMF9/tecj5bb8RzOTKLhb1smOZl/a+latXwuKCM36/FsycgiY7mrZjnZ0PPJno+kkdppZijIWn8eSuBxwXlTOxqwRRPq5eSVqoMMpmMsLRCDgQlczQ0DT0tVcZ1sWC0m1mDJuvyeHpskJycjLm54ubpzTTzv0qzeNPMf4KnL9BeH+5nch9XRrmaNVlJe1NQUlHFifuP+fNWIkk5pYxxN2eql9Urnwm7l5zPxquxXAjPZKiLCXN9bbA3brzBW1xWMYPWXHvGTFVdRcjXo1wY5GzM9lsJbLoah61BS97s1x5vmzZN8pBSVF7Fb/6x/H49ngFOxrzV3/6FHkACE3L5+OhDKsVSPhvupHDsZw1SqYy9gcmsPBVOP0cjPh7q2CijT0W39ceNeH46F8WSPnbM7dnuhdqQSkoq+PBQACDg8xEu6OrW3S4jlcpYdT6SMw8z+G5s41vFMgvLmbzlDg4mOqwa36nJvaHWXYpm150kpSLEs4oqGLTmGsv7ta9TaFCWb06FE5KUx743vOT+NpuuxnL4bionl/g8EVdkMhl/3krkyxOP6vW9ifl6kELfnVgixevbS6wa30kho9QzDx8zb+ddzizzqdNjqVIspe8qf5JzS5H3ACEArr3bq86Kg79CU9lxK5GD858VLR6mFjB07XXUVIQIqP4upLK6/X8EgIOJNlEZxfV+TypCASpCAQKBgLIqCWtfc2XYcwluW2/EcyMmhy3Tu8j5RNX74/7VBbZM79Ik4umoX28w1t2cyR51V9VIpDJ8f7jMB4Md6kxS+uxYGNtvJiASCpjsacni3na0aaHGxE238WjXhuX92je4/eX7Q6kQS1k/ya3RnyG9oJx3D91jjJs5wzs/W0Eklcpw/PQM5VXV9wg1kRBjXQ2meVnxy8Voji3qUadJ7OQtt7kRk4O6ihAbgxbsnO1J6xZq7LqTyPdnIjk030tpc9KknFJe2/xiwk15lYRle0MQCgR8MMSB9IJyJm663aA/VQdjbc4s66n0thrDxfAM3jl4nx52+nwxwvndKYqVAAEAAElEQVSVeaa8CJHpRXxxIoyIx0W8O7ADY9zNX0jYj80q5qdzkVyOyGJRb1umeFr9699DTGYxewOS+PN2Ir3sDZjna4NrE6bVNURiTgk7biWyPygZMz0tZnhbMbyT2TOC6L9BbkklR0NSuRKZSVBiHkNcTBjf1YIuVnpN8pzYLN4081+kuW2qmf8cc3q2JTAhF98fLjNlyx2OhKS80qSe+mihrsqErpacWNyDbTO7kV9ayaA115iy5Q5nw9IRK5Gi8iJ0smjFr5PdObusJxpqIoavu84HRx5wJy6nUW1I7Qxa8u1ol2fao1q3UGNkZ1NaqKuwwM+Wa+/0ws++ukVpwqbb3I7LeeHPoa2hytsDOnBphR8qQiH9fvbn1ysxjW4n6mrdmhOLezDNy4qFu+8yb0cwKXmlCr9fKBQwycOS88t9KSwX03eVP8fupb2UVjmhUMBsn3ZPkpymbw2oFU+tDFuvRyBQUePLUW71Cjc1231rQAemelkx9fc7nKknxUgehjoa7HnDs9qLYW+IUglCirCwly3eNvrM2h6o8LlvoK3OLxM7s+N2Ao+USE2qj2V97UjLL+fg3WS5y07zsqa4Qsyx0NQn/yYQCJjubc3+eV7oaanW2X6o6OBGRSRkZGdTDgUrFps60NmErtZ6hCTl1/m6moqQP2Z0VahCzaSVRr2tIsY6dbdNOZvp4mXTBvHfCVuVElm9A2OhUMDXo1wa9MASS2WUi6WUVUmw0NNkkLNxrWUSc0qxVtCsOCGnlOJyMU4KVnY1uK7sEsJSCxnSQLz15YhMxBIZ/RyN6ny9JnpeLJWxJyAZ75WXWLwnhNisImb1aDh9KTQpj6Sc0noNthVBKpWxfH8oBtoatYQbgPickmfa3SolUlLySvn6ZDizfNrWKdxUSaQEJeQBUCGWEp1ZzNC119h7J4mvT4azZXqXRgk3Ezfdor9T44Wb/NJKpv5+h6ziSr4e5YK5nhZdrFuz8rl74NOoqwhZ+HcbWXmVmLjMYqW3qwillWLeP3yfZftC+WqkM2smuv7rgoU88koq+eSvhwxfdx0HYx0uveXH+K4WjRZu0gvKef/wfQavuYaelhr+b/uxsJftv/o9hCTlMXdHEIN/uUZBWRWnlvRg49QuL124kUqrK65nbguk7yp/iivEbJnelVNLejChq+W/JtyIJVIuRWQwf2cwnt9c5MzDdMa4mxP4YV9+GNeJrtatm9uimmmmAZrFm2b+c/RzNGbb69248W5verbXZ8OVWLp+dYG3D9wjID6nyb02lEUgEOBupcfqia7cfK83XjZt+PxYGD2/v8zv1+LIbqSniLK01W/BN6NcuP5ub0x1NZjzZxCjfr3JmYfpSn9Ho9zMGeJigpqKEPW/I5GfrgjQ1lBlUW87rr/Xm+42+sz5M4jZ2wMJTMh94c9h2kqTn8Z34uA8b4L+Fu3+uB6vsDfG06iIhMzo3pZLK/ww19Ok3yp/1l+OoUIszzr2H4x1Ndg8zZ3PRzjxxfEwZm8PeqGo84boZNGKk0t60EpLjUFrrnEtOkvpdVx9mMy9lGKmeLZFW1uxwet0b2tWT+jM8v33+P16vNLbhGqPlT1zPEnMKWX+zrtKfcfyEAgErBztgqmuJp8dC1M4QtzbVp+BTsZN4n+jpabCylEurDwVIVdY01AV8cFgB74/G0n5cwlubpZ6nF/ui4uZ7jM+OCKBQKkH3DHu5pwJS6eoXDFx08/ekMsRmfW+bmvYkh/GdmzQ00okENC/HsEBqs+VzKLyOq83Hw+RP7gWAN3atsbVUo/XPCzqjDt/GlVRtdBTV7VSQk4JVgpGBN9NzMPZTEeplLkrkZn0XeXPukvRz4jCR0NT8bM3aDB+d/utBKZ4WtYrUEmeEogrxVIqJVJO3n9MfqmYLdfiKKznN5dKZXx6LIwedvov1EK75XocKXll9Sa9hSbl12pVkcqqo+jXXoxh9YWoWsdAaHI+T+veVRIZ6QXlfHD0Acv62tHVurVS+1gj3AxwNuaToY0TblLyShn72y30tNTYNdvjmcrKcV2q20/q8qpqoa7yRDA8djeVDRfDKSlvGu+5GkKT8xnyy3Vis0o4vdSHQQ2Igf8LVEmkbLsRj9+PV0jJK+PUUh8+GurYaJGloLSKb09H0OvHKxSWizmzrCdfj3KRm7D2spDJZFyJzGTipltM2XIHCz0t/N/244dxnV56lHVheRVbb8TTd5U/K/aH4myqw7V3evPtmI50a/vvCSOxWcV8ezoC728v8cHhh7QzaMHZN3uyf54XI16xlUAzzfxfprltqpn/BA2VRspkMh6mFnIwOJn47BLic0oY42bOGDfzf73PtwaxRMrlyEy230wgICGPwc7GTPWyxs2y1Su70RZXiNkbkMSWa/FoqYl4o2c7RrmZKTxAKa0U0//nqwD4v92rwZmzgtIq9gcls+ZiNK6WrVjWt32TeAHIZDKuRGWx8lR1ZPO7Azsw6AVMCYMTc/n4aBhlVRI+G+6ktJdNXkklX50MJy2/jMEdTZjczbJJU5ZqkMlk7A9K5vPjj5jubc3yfu0VSuMKjH7MlqsxeNnpM6On8jPvocn5zNoWyPDOpnw0xLFRs6UFpVW8vi2A9kbafDbcqUn9CApKqxi14Qa97A35eKijQu+RSGVM/yMAvRZq/NIE/jcLdgWjKhKyZqJrg8tJpTJGrL/BQGfjJ7P0TyOWSPnuTARbbyQglsoQCQTErhys1L4MXXuN6d7WjHOX7wkWllbA+N9uEfJJ/wYrbD44/IBDd1OeaZusQV1FyOZpXeptQSyvktDh4zMEftgXA+3ahrrzdwZz4VEGVfWIb6oiAbtme9KtbWuSc0vx/eFyLe+tGkRCAZ7t2rBrtkedr/f68QpfjHBSqK3swyMP0FQV8ZGCxxRUt6It2h2CSCigSiLFyVSXid0s2HItjncHdmCgc92D7ZjMYj488oB1k9zq/I4A3j14n31BdVd4qasIEQkFLPCz4fXubZ8ZIB0ISmb1hWguLPdt9Cz8w9QCxv52k91zPOttIfvgyAP2BiTV+9uoqwjxateGtZNcnxil/nQukt/8Y+tMM1RXEbJpWheFr8dJOaW8ffAeTqa6fDzUoVHn9KO0QmZsDWCAkzGfDXeq81onkcqYsuUOwYm5VP693xoqQpb1bc88v2oz5oqKKr49HYZUKuDN/va0avli4oJYImXDlVh+vRLL0r52zPFp1+Q+Yk3NjZjsalFdJuPjoY70sjds9Lpqkpp+PBtJR/NWvDPQno7mrZpuZ5WkSizldFg6G67EklFYzuve1kz1smpQnG0qojOK2H4rgcN3U7E31ma6lzWDXIyVEpmbmhr/srNh6dyIzaGfoxHju1jQw1b/lRynzW1TzfwXaRZvmvlPoOgFulIs5VJEJgeDU/CPysTVUo+x7uYMdjFROJXkZRObVczO24kcDE7BsrUWUz2tGNH51fUmV4qlHLuXxkb/WPLLqpjZvS2TPS1rGXzWRXpBOeVVkjrL4Osir6SSLdfj2HYjgS7WrXmzX3s6v4D5cA1iiZSDwSn8dD4KCz1NPhzi2GhxSCyRsutOEj+ei8Tbpg0fD3VUOjHkWlQW7x95gKmuJivHuLw0n6PojCKW7QvFrJUm7w92oG0Dv0NQfBa/XY7BrrWAVto6TO5uS0sN5R8wk3JKmbG1WnxZPbFzo8SXwrIqXt8WiKaqiM3TujTpsZ6YU8KoX2/yZr/2TPVULKknq6iCwb9cY2kfO6Yo+J76yCgsp+9P/qyf7CbXR+lmbDZz/wzmytt+tKknHejMw3Tm7wxGBiR8O0Spfdl5O5FjoWnsn1fb9PZ5ZDIZHt9cZPWEznjb6te7XIVYwoh1N4jJrO05oyoS8OCzAQ0eE52/OMfOWR44m9Vu10vMKaHPT/71tkw5muhwckmPJ4Px6X8EcDUqq04fHpFQwPk3e9KujnNPLJHS4eMzXH7LTyFBf9CaayzubVun/0x9PEipNrF+2oBaXUVIhViKj50+k7pZ0quDYa3v6rNjYRSUVfHzhM71rnvF/lAO3U2t9/WabamJhOyY7UFni1YUlVfR60d/Ph/uxJCOjavSKKuUMHTtNUZ0NmNJn/ojsPuu8idGTquQmkiIgbY6RxZ4Y6ijwaDVVwlPL6p3eRWhgG9HuzC2S8NCZGJOCa9tus2wTqa8N6hDo4SbGzHZzNsRzDw/Gxb42TS4jsLyKgavucbj/DIksurPFfhhX3S1/rl/ZheW8dvlaAorJHw63JkWjUz2Scop5c39oeSXVrJmomud59D/EvHZJXx98hEB8bm8O7AD47taKDTJUBdiiZT9QSmsuRiFsY4Gbw+wp4cCwuvLorxKwoHgFDZfjcVIR4NhnUwZ527x0p/bxBIpFyMy2XErgfjsUjzbtWG6t9W/KmBJpTJux+dwMCiF0w/TsTFswXRPa/o5Gb0SEetpmsWbZv6LNLdNNfP/FWoqQgY6G7Nlehduvd+HgU7GbL+ZQNevLvDmvlBuxmT/621VNgYt+XSYE3c+6MNkDyu23UzA45sLfHniEQk5L6dX/mnUVISMdTfn7LKefDvahUsRGczcGsjKU+Gky4n1NdbVUFi4AdBrocbbAzpw7d3eOJjoMGnzbWZuC+RByot5jqiIhEzsZsmVt/zo2d6Aqb/fYeHuuyRklzRqXdO9rbn8lh86Gqr0W3WVdZeilWrz8WlvwNllPXE202XoL9dZfzmmyX1eAOyMtDk4zwszPU2G/nKNXXcS6/TcqawUs+tWAl0sdEksFhGcXIC4EW1mUB3RfWi+N9nFFczbEdyoKHEdTVW2z+xGpUTKjK0BTRq5btWmBZumurPyVDj+UYq1lVX737jy9clwHqa+2LFopKPBOwPt+ejow1otUc/jbaNP17atWdtAzPhAZ2O2vd4VISi9b4NdTAhNzicxR/55IBAIGOxiTEhSXoPLqauI2DK9S53VOW6WenLFPGMdjXqvK1ZtWjDW3Ry1OgZ4aipCVvRv/8xAep6vDSp1tE6pqwiZ4mlZp3ADkJZfjkAAJrryqyCKK8REphcqbVRs2kqjVnJYTbXStehs3twfSucvzrFif+iTdtLiCjEHg1PkxoMr2hZooK2OkU61KLj2Ugy2hi0Y7FLb/0dRvjkVTistNRb42dS7THmVhLgsBe5bguo47ZJKCYXlVURk1C/cQLW/z3uHH7DmQlS9yyRklzBx022GdDRptHBz6sFjZm8P4tPhTizsZSt3HToaquyc5YG6qgihAMa6mz8j3ADo62jy3hBHVEUCtt+IVXqfoHriY+jaaziZ6nBisc//tHBTVF7FylPhDFx9FSMdDS6/5cdkT6tGCTcymYxTDx7T/+erbL4WxydDnTiyoPu/JtwUlFWx/nIMPb67xK7biazob8+eOZ5M87J+qcJNbkklG67E4vvDFT4/FoaXjT5/LezOT+M7/WvCTUpeKWsuROP742UW7Q6hlZYahxd4c2KxD+O6Wrxy4aaZZv6rNIs3zfx/i35LdWb2aMvJJT4cXuBNmxZqbL4WR4/vLvHD2QjFHjhfIlpqKkzysOT0Uh9+n9GVonIxA36+yvQ/ArjwKEPhB/bGIhQK6ONgxIF53rw3qAPx2SX0/OEy7xy8R0xmww/WNUilMsqrJBSUVpFXUn+Pf+sWarw3qANX3+mFrWFLxm+8xSdHH77wwLmFugrL+rbnylt+WLfRYsDqq3x+PKzBfakP/Zbq/DCuEztne3DqQTqLd4dwJbJ+T5C69uWTYY7snuPBX6GpDF93g/sp+Urvhzw01VT4dJgTG6d2Yd2lGGZuCySz6NnB8Y5bsagKYbqPHR3NW1EpFfIoo/HHu14LNXbO9sBMT5PRG24S3wiRrKW6Cttf74aqSMi0PwLq9eloDDWGoot23SUivVCh93jZtGGBnw0Ld9994X2Z5GFF6xZqrL0ULXfZ9wZ1YE9AUoNCo6+9IdO7W7P+cv0iT120bqGGn72B3CqNGjzatuFoaJrc5cz1tFg/2Q2Vp8rgNVSrhXJ5GOtq8LiwflF4eb/2yOqopTHW0ajVbuHZrjWmdcTKqoqELO9nX+82EnJKsNDTUii560FKPr7tDTBWQOh5mtYt1Br0ByqvklJeJeXw3VQmbb5NSYWYI3dTaGfQQm41okROAbWqSMBYd3NOLfXBRFeTuKxitt9M4NNhTo1uC7wYnsHRkFRWT+jc4PcW/rgQFWHdrwsF1RU0zmY6bJjshv/bvWir34LbsTl1esfUfr+Azdfi6xR7a4SbYZ1M+WCw8q1SMpmMjf6xvHfoPpunuTPWXfEZe2v9FmyZ3gVNVRFzerajoLSKWdsCCYj/x+NNRUWFid0seZBWSHhqwwJpXei1UOOvRT34YoTzv54YVB8SqYy9AUn0+vEK91LyObqwO1+Pcqm3qlAeN2KyGbH+Bp8dC2O2TzvOvdmTIR1NXkorsjwyCstZeSqc7t9ewj8qix/GduL0Uh9GdDZr8vTEp3mYWsDbB+7htfIiV6Oy+HioA1ff6cXCXrbo19NW+TIpr5JwNCSV2dsD6fXjFe6n5PPhYAduv9+HT4Y54mDy4qbuzTTTzLM0t00185+gqUojxRIpV6OzOBicwoVHmTib6TDG3ZyhHU3/J1IbMovK2RuQzO47SaiIBEz2sGJCVwtav6RI6ueJySxm89U4Dt1NRigQ0rqlGi3URNWJMGIpVRIpVRIZVRIpYoms1qDi/Js9sTOSb9aXWVTOtpsJ/HE9Hr/2hizrZ1dnZLGyRKYXsfJ0OMGJeSzqZct0b+tGtfmIJVJ230nkx3NReLarbqVSxj+pUlztU7DBP4apnla82bc9Wi+hba+gtIpPjj3kalQWK0e7MNDZhIdJOay/EsN0Tys821cPrvcEJPHF8Ues6N+eWT3aNnpAJ5XK+PZMBAeDU9g8rUujWtXKqyTM2xlMXkklf870qDVr/SKsuRDN/qBkjiz0xlBb/uBbKpUxfWsA2hoqrJ/k9kL+N4/SChm94QZ/LeyBvXHD58B7h+5TWF7Fr5Pd610mLb8Mvx+vcGpJD6UMMM+FpfPFiUdcfbuX3EFPYXkVbl+c58rbfgq1Cn53JoLfr8VTKZEiFMCF5b71VrvU8O3pcPS01JjrW3/1xrenI9h6I/5JpYq6ipBvx7gwyrX2dX5vQBKfHQ97EkutriLk46EOTPG0rnf9+4OSuJ9SwFcjXeR+xnWXoglPL2pUrLbXyot1pms9jZpIyO8zutDDVp9+P19lnq+NXOFgwc5gTj1Mr/XvKkIBaipCVk/oTH+nf4S017cGYK6nxZcjnZX+DFB9fX734H2GdTJhtFvDbUtbb8Tz7emIZzyRVIQCZDLobteGpX3scLd61ny4IY+cGoGwrX4LZvVoy7BOprWMTuOzS5i46RYjO5s1quJGIpXxxfEwTj1MZ+uMro2uahFLpMRllzDnzyDsDLX5eUKnJ54+Nfx2OZK0/HI+H9nxP5WwExCfw+fHH1FQVsVHQxwY4NR477kHKQX8cjGaO/E5zPezZYb3y61qaYj47BJ23Epg150keravjvtuCr++hqgUSzn1II1DwakEJeYx2s2MaV7Wcu8jLwuZTMa9lAL2ByVz/F4ahtrqzPBuywAno3/NILo+mtummvkv0izeNPOf4GVcoPNLKzl+L42Dd1MJf1xIP0cjxrmb08NW/6XOrChClUTKhUcZ/HkrkbtJeQzpaMI0L+sm8YtRhJjMIgavufbElFERzPU0FRowPk1GYTkbrsSyJyCJvg5GLO1rR3sFxB95XI/O5ptT4RSUVfHOQHuGdTRt1OxddnEF35+J4Pi9xyzws2FOz3ZKiUHRGUX8eiWGu0n5rBzl0qC3yItw/F4aHx19iIuZDupCGR5WrXmjz7OVCHeT8pi/M5hBzsa8O9DhhR6Ot99M4LszEawa31mh6ovnqRBLWLQ7hLT8MnbM8mgycVImk7Fi/z2S80rZ/no3hQSznOIK5u+8y/DOpi/sf7PyVDhBiXkcmOvV4PGWUViO3w9X2DXHo8H2nHcP3kcslfHT+E4K70OlWIrnyov8OtkNz3Zt5C4/YeMthnVS7LNLpDLGb7xJcGI+LdREPPx8gNwB2+oLUSTnljX4GQrKqvBaeZHSyuq2szYt1bj9fp862y7KqyS4fXn+ybJWbbS4uNy3wWv2lyceIZHK6k1LepqZ2wLpbqsvN4K7LsZuuElQYv1VFuoqQnbM8qBb29bcjMlm4e673Hq/j9xryhs7gjgXllFrXe2NtNk41R3Tp5Kk/CMzWbI3hCtv9XomLUlRZDIZM7YGoqupyi+vNWzCDTBvRzBnwqqFJTWRAIkMhnY0YXFv23pFR89vLpL+XDWWhqoQmQxGdjZjqpdVvYJKXFYxr22+zShXc94daK+0YFBeJWHp3hCiM4vZ/nq3Fwo1uBCewdI9IczyaceyPnZ1nvOVYglv7w9FgIyFvdtj1wSTFP8mKXmlrDwdQVZhBb72Bszq0bbRJvRxWcX8dC6KSxGZLOljy6RuVk0q5ivDg5QCfvOP5Xx4BjO7WzPGzVyhiagXIaOwnN13ktgdkEQLNRFzfW0Y7GLyr00kZhVVcCQkhQNBKaQXlDO0kynjupjjavHqgjWUJS4hCZu21feuZvGmmf8KzeJNM/8JXra6HpNZxMHgVKIzirifWsAoVzPGuJn/azMfTxOdUcSO24lcDM/ESEed17pZMqyTaZOm9tRFfHYJg1ZfpVwBrxQNFSFfjHRmvBxzyfpIyy/j1ysx7A9KYaCTMUv62GFr+GKmv1KpjCMhqfx4LhIDbXU+GuJAt7byB7N1EZyYxyd/PaS4Qsxnw52USs+QSGX8eSuBH89GMrRjdYn/y3hATS8o50BwEtatNBjc2aLOpIfMonLeP/SA1PwyNk51x6qN4v5Fz3MuLJ1l+0J5e4A9r3dXfqBbJZGydE8IQqGAT4c51Zu0oywVYgkr9t9DLJHx62Q3hUS7wIRcpv0ewJ43PF9IIC2tFLN0bwi97Y14zcOywWXXX4ohJquIVePrT7yKzy5hwM/+XFyhmNFuDZ8dC6O4QsyP4+SLPr/5xxKUkMuW6V0VWnd2cQVdv7qAWStNrr/XW+7yewOSOHH/MTvrSYGqYaN/LN+ejgDg02GOzGjgmPrmVDibrsYhEMDOWR50lyOKzt4eSA9b/QbXCdXChduX5/ljRldclfS8AXj74D0OBKXU+neBADRVReye88/xNXdHEO0MWvLuwA5y1zt7eyAXwv9p4VQRCpjra8Obfe2eEa0qxBIGrr7GPF8bJnRt3LV4+80ENl2N49RSH4UGkXYfnqJKIkNNVO079EZPmwZbzlLzy+j+7SWguq1KKBA0WGXzNDGZRSzZG4Jve0PeGaC8cJNXUsnsP4MA2DKtS6PELai+pq++EMXWGwmsntiZvg5GDW+3uII/bsTyOL+Mb8d0RuVfTAdqLKWVYn7zj2Pz1TgGuRjz7sAOGDWyCiO9oJw1F6M5fDeFMe7mLOltp3SbYlMgk8m4GZvDb/6xBCfmMbGrJbN92j4jhr6MbQYn5rHtZgLnwjLobtuG6d7W9LQz+Ffaw6okUi6FZ3AkJI2LERl0tW7NuC7mDHQy+Z9t16uSSLkZm8PJ+2kcv/mQiJ+nAM3iTTP/HZrFm2b+E7yq0kiJVMb1mGwOBadwNiyd9kbajHEzY3hns1fWulQfReVVHA1J5c9biWQVVzChiwVTPK1eahz6pYgM3vgzuN40mBpaaaoS8GHfBiOHFSElr5T1l2M4fDeV17pZMsPbWimD5Loor5Lw+/V4zjxMx0hHg/cGdWiUMCSRytgdkMQPZyLo42DE8n7tlfruU/JK+fDIQx49LuSL4U4MUiLJpimpkkj55lQ4h4JTWD2xM707NDzwaIiQpDxmbw9ipKsZHw52UPrhUyyRsuLAPR6kFrB7tmeTPcDnlVQyesNN+jsa8f5gxSLSN12NZfvNRE4u6fFCxouXIzJZujeECyt8G2zdKq4Q4/v9ZVaOdnmm5eV5Pjj8ABWRgC9GKN4C8zC1gAkbbxH4UV+01BquPopIL2TU+puEfNJPYUH4nYP3yC2pVEjwuRyZydcnw7mw3LfB5cqrJDh9ehaZTEbY5wMbHDjUCADmeppcf1e+gNR3lT8fDnGQK7rGZRUzcM01Hn42oFHXsnWXovnlYswzxsVCQbUf1v65Xk/8IVLzy/D74TKX31KsXW3aH3e4GpWNUFBt/v3rZDe8bWoLVr/5x3I0JJUTi3s0qno0KqOIEetusPX1rgpVbZ28/5iFu+8y2tWMT4c7KST2LNodzIn76agIBYxxM2+wyuZpYjKrK26meFiypI+d0sJNcm4p07cGYGfYkjUTXRs9+VFQWsXSfSEk5pSyaaq7wtUZFZVi3j1wj/7ORgzu9H9ngCmTyTh2L41vT0dgrKvBp8OcGi1wF5RWscE/lu03E+jtYMiKfu3ltl2+DCRSGefC0tngH0tSbikzvK2Z7mXdaDFPEcqrJBwLTWPbzQSS80qfPL+96PNNY4lML+JAUDJHQlLRUBUxw9uagc7GL/V58kUQS6Tcjsvl5IM0zjxMR01FyGAXE7oayBjiVd0O2yzeNPNf4X8jG7mZZv6PIBIK8G1vgG97AwrLqzh1/zGH7qbwzakIenUwYKy7OX72ho2Ov3wRtDVUmeplzRRPK27H5bLjdgJ9fvKnu20bpnlZ49u+6WduencwYlFvW369EktlPRU46ipC5vvZvLBwA9XGqCtHd2S+ry3rLkfTf/VVRnQyZXFvOyzbNO6hQkNVxMJetkzoasGaC9EM+eUa47tYsLSvHfpKGCuKhAKmelox2NmY36/H0/9vv4q5voq1UpnrabHt9a4cDU3lgyMPOBqayhcjnBs9e9lYVEXCJw/gi3aHMMenHUvrKfmXh6ulHocXeDP3z2A++ushnwx1VGpQpCISsmp8Z94/fJ8Jm26xe44nZk0w66nXQo0/ZnRl1K83sGrTgkn1VMHklVTSSksVgUDAHJ92BMTnsWL/PTZP69Loc6lXB0N87Az46kR4g20nLdVVWNbXjm/PRNCrQ/3XlCmeVozecIPFve0Urk5yMtXBorUWZ8PS6/SNeRp7I21aaakSEJ8rN+q8hr4ORvx4LlKhZU1060+behoNVREebfXIKa6UO+Nr1kqTluoi5vZsJ3e9EqmMpJxSrBWoMrublI+LmW6jr2VmepqoiAT83dGFSADamqocnOf9jGB8NCSViV0tFRJuACIfVxvId7NuzfrJbnUawmYWlrPuUgybp3VplHBTIZawZE8Ir3e3Vki4iUwv4p2D99g01b1B8fFpHqQUcOFRJn0cDPllomuDVTZPE5NZxMRNd5jY1aJRws3D1AK+ORWOj60+nwxzqrMqUREi04t4Y0cQtgYtObqwu1LtLepqKvTs0IaL4Rn0cjBGU46o+r/A/ZR8Pj/+iJS8Ut4f5MDwTo1rPy6rlLA/KJmfzkXSyaIV++Z6/iuJSRXiavPdK5FZhCbnM8enHRO7WcgVuF+E5NxSdt5OZF9QMt1t9JniacVIV9OXus36KCit4ti9VA4EpxCVUcRAJ2PWvuaKZ7s2/0rVjzwkUhl34nI48eAxD1MLeFxQzhAXEzZN64K7pR5CoYCUlNqVjs0083+d5sqbZv4T/NumZAnZJRy+m0J4eiF3E/MZ3tmUMW7mOJnq/Ku9wOkF5ewOSGJPQBJ6WqqMczdnXJemjWyUSmXM3B7IzdicegWc0a5mzPezafIe8fjsEtZejObEg8eMcTNjYS9bhQc89RGTWcx3ZyK4FZvDfD8bZnZv26jy4JCkPD75K4yCsio+G+6oVAVLTnEFX5x4xKWITD4b7shoV/N/5TgKf1zIvJ3BtNNvweoJro1u58otrmDOjmBAfjuCVCqr9aAolcr45NhDLkdksXuOxwu1cz1NQHwu0/8IYONU91rCxMn7aSzbF8r6SW5PBp8FpVUMWXuNyR5WzG8gHlkeGYXl9P3Jn3WT3fBtQBCpkkgZ8PNVZvZo26DnzMxtgdgbayvUYlPD9psJnA1LZ/ccT7nLvn/4ARqq1aKeIqTml9Hz+8uEfT5ArliXX1pJ5y/O8/DzAbSUM1hffzmG2MxiVk3oLHcfun59gc3TusitAqjZ1/AvBsoVZT448oAWaiI+HOIod/t1ERCfy5Qtd6iUSBEJBLRuqcahed7PCM/lVRK8v73ELxNd6WEn3wOrQiyh02fncLNqxa7ZnvVeJ5bvD6WiSsr6ycobLQN8ffIRt+NyOTTfW+73VFBaxfD11xnR2Yzl/dortP7k3FJG/XqTuT3bMUcB0a2G6IwiXtt8h0ndLHizX3ulr5OXIzNZvDuEpX1tmd2jXaOvsyfvP+adg/ca9LeRh1gs4aOjD3A20WFKd8W/g1dNZmE5P56N5FZcDiNdzZjna6Ow0PY0VRIp+4OSWXMhmg7G2sz1tZHb4vgyKK4QszcgiS3X4mmpocJCPxuGdDRVWKT9/FgY5x5loKOpgq6mKnpaarRuoYaelhq6mqroaKqgo6GKjqYqOhqqtFQXEZtdzN6AZK5GZdPX0ZBpXtZ4tG39yu/zEqmMmzHZHAhO4UxYOk6mOoxzt2BoJxN0NP79kI7nkUhlBCbkcuJ+dYUNCBjsYsywTia4WbauJbz+22ODZpp5GfzvS/vNNPN/AGv9Fizvb49UKuNOfC4Hg1MYv/EWlq21GOtuzojOZk3m2aEMxroaLO/XnkW9bLkcmcHv1xL48VwUwzuZMs3LGhfzxqVoPI1QKGDdJDcGrr5KWn7ZMwkhaipCRnQyRSgQMGTtdXra6TPX14YuVnpN8pDSVr8FqyZ0ZkEvW365GE3vn/wZ38Wchb1sMakjMlgRbA1bsnlaF+7E5fD1qXB23k5kRX97RnU2RaTEjLWrpR5HF3Znb2ASb+67R1drPT4Z6qRQhVCbluqsmejK1ahM3jv0gP2BKawc7dKoEvK9d+IRS2VM8VJ+MOBgosOxRT1Yvi+UYeuus3GKGw6myh8zrVuqs2u2B2/uC2XMhptse71bnd9DcGIus7YFcWiBNzZPfVahUMCXI5z5SiWcCRtvs2uOxzOvN5ZubVvzzWhnFu6+y8F53tgbayOTydhwJZZV56OQSGX4R2U9EW90tapbUiZsvI2bZSs8FKhAqAsjHQ3eGWjPR0cfcG6Zb73ioKpIyDsDO/DR0QeMdDWrV9xY2MuG6X8EMs/XRuHZ/kEuxnx18hGp+WVyq5n87A1Yp0DMeQ2muhpoa6gQkV4kVzzR1VRFQ1VIekG53HZFVZGACol8jy2obiOVJwYBJGaXYNZK85mB2o2YLK5H5+BmpYebZasnlSx3E/NY2sdOoe3XhZme5pOWKSNddQ7N9651nTr14DGttFTpbqvYsbUvMBnLNlrsnFW/cBOSlMfpB+mcX96zUft9PTqbXXeSOL64h9wBrUQqY+m+EGwNWrJMwe8qt6SS6X8EMKyTCbN9FPfHisooYtLm20zxtGJZ39oi0QdHHlAplvLD2LqTnPYGJPH58Ud8P7YjwzqZKrzdp5FIpPxwLpJdt5P4+blUL2XZ6B9Le6OW3IjLxsO2DXZGL35/bkpqWox/vRyDn70he+Z4Yt6INhqpVMaph4/56VwUAuCz4U4Mcm58GlUNwYm5fPJXGCKhADWREHVVYfV/VUSoqwrRUBGhoVr9d1WRgOJyMYEJuSTnlmJjqM0XI5zo62CktPDWpqUaGYXlpOY/OxcuEghQEQkQCQQgAKlMRqVYilRW3S65wM+WL0c6N/pZ5UVIyC7hYHAKh+6mIJbKmOppxak+yiUXviqkUilBifmcvJ/GqYfpSKUyBrkYs/Y1N7q1rS3YNNPMf51m8aaZZpoQoVCAl00bvGza8MUIJ848TOdgcArfnYnAx86AMW5m9HEweulmws+jpiJkgJMJA5xMiEgv5M9biUzYdIv2RtpM87JisIvJC+1TS3UV/pzZjcG/XHsS0QvVD2lvD7DHUEeD5f3bs/VGAjO3BmJn1JI3etrQ31H5B6W6sDVsyS+vuRKVUcSaC9HM+CMQL5s2LPCzaXR0pUe7Nhxd0J3j99PYE5DE1htxvD/IUaHZ8BpEwuo490HOJvxwNoIBq6/yRs92zPNtp1BZfM/2hpxb7suPZyMZ8st1FvW25Y2e7RRuy9t5I4absTnM8bFVeJ+fR1dTlc3TuvDrlRje2BnM8n7t5bba1IWGqoj1k9z4+lQ4o369we8zuj4zsI/LKmba7wGUVUn481YCnw9/1sNFIBDw0RAH1FWE1QLObI8mMQwf5WpOQnYpM7cFcmCeJz+di+L4vcdPfJyuRmU9s3xH81Z8MLgDi/eEcHKJT6NF2UkeVhy6m8raS9G800DFzAAnIzZfqzYCfbOeKgZ3q9Y4meqw41YCi3orNmA21NbAx86AI3dT5L6nu00bFu8JISG7RCEPBoFAgJOpDmFpBXLFG4FAgLGOhoLijZAqBQzSqyRSyquk6GjIP8cSckqxek5IvJ9SwMarsairiCirkmCorU5ni1aUVIjRUhMhlkgb1Xpk9Pex0lJdxF8Le9R57Gy/lch0L2uFBrLlVRLWXYrhixFO9V5HpVIZnx0LY65vu0ZVJeaVVLL1RjwfDnFQSDD9zT+W4goxv0/vqtC1vbRCzLwdwXQw0ebjIY4KD+Aj06uFm2le1iztW/v4zS+tZH9gMgIBGOto8NaAf9L1ZDIZP5+PYvutRLa93rXRImxeSSVL9obQUl2FIwu7v7CJfmhSLjZGLenatjVrLkYzu3tbOls1bt+aEplMxtmwDL4+9QhtdVX+mNH47+x6dDbfnYkgs6icZX3bM87dvMnSO7U1VAlLK1TqPUIBbH+9Gz3s9BstHr3WzZLVF2qL2xKZDIm4dnODqkjAsUXdcTB5teJcSYWYUw8ecyA4hdCkfHp3MOSrkc74tjf41xNUn0cqlXE3KY8T9x9z+sFjdLVU6WLdmjUTOtOtbev/uf1tpplXSbN400wzL4kW6iqMcTdnjLs5ybmlHAlJ5UhIKh8ceciwTiaMdbegk7nuKy+T7WCswzejXHhvUAcOB6ew7nIMX50MZ0JXCyZ1s8CideNaUtoZtGT9JDfm7qg2MFYRChjR2fSJeFJjBrywlw17A5L57FgY35+J4I2e7RjpatYkglZ7I23WT3Yj4nEhP1+IoucPl5niYcVcX5tGDbKFQgEjOpsxwMmYP28lMH9XMO5Werw/yEEp4aB1CzVWju7IhK6WfH8mgrOP0nmrnz19HeW3UrVUV+Gz4U4M72zKe4fuc/xeGt+N6UgnOYPia+GPq4Wbnja4Wr/YAEAoFLCotx1OZros2xtKaFI+Hw5xVNr7QygU8PFQR0xbaTJ5823WTHSlr6MR2cUVvLbpNmVVEqQyOBCUwvuDHGodEwKBgLcH2KOuImLlqXDeGmCvkJmpPJb1tSMhu5iha69TUiF5xlA2Oa+MnOKKZ3xEpnhaEZNZzCd/PWTdJLdGzfyJhAK+GeXCqF9vMLyzKR3qiQgWCAR8MLgDU38PYLKHZb1i5MJetizbF8rMHm0V9ksY42bOj+ciWdjLtsHrUEsNVbpa63ElMpMZ+opVRni2bUNsZolCyxrpaNSKhq4LNRUhVQpU3hSXiwFoqYB4k1FYjo3Bs9c8Lxt9RMIoyqqqzWkyiyo49ygDATBrexACQfV1tLttG9ytWtPLXrHBT1x2CUIBHFnQvc7rUWhyPjEZRYx2M5O7LoCdtxMx0FZnQAPVHgfvppBdXMncnsq3+clkMj448gChUMCkbg2nowGceZjOhiuxHFngrVAFmFgiZcneEIx1Nfh+bEeFhfzwxwW88WcwM7ytWVxPdc/B4BRURALKq6RsvBqLRWtNJnS1pFIs5f3DD7gdl8Oh+V6NrjQISytg7o5gnEx1+H5sR7RfsMXkr9BU8solCAQiZvawRXY1hp23E2lr0BJdrVdftVtD+ONCvjj+iKiMIt4eYM+4LnUnFcrjfko+352O4EFqAQt62TLD27rJJ7HaG2nTw1afm7HZyMlQAKpT2U4s6VHvtVdR2rRUZ7CLCScfPEYiZ8OqIgH75nq9MuFGJpMRlJjHgaBkTt5/jEVrLcZ1sWBDPd5Y/yYymYyQ5HxO3HvMqQePKRdLGOhkzI/jO+HZtjWq/wdT2Jpp5mXQLF0208wrwKK1Fkv62LF5Whd+n94FiVTG1C136LvKn1+vxChk2NnU6GioMqN7Wy4u92Xta64Ul4vp/ZM/s7cH4h+VhVSRp5/n6ONgxAI/G9REQmQyWNCrdsWHtoYqc3q24+o7vVjQy5ar0Vn0+O4y6y/HUFBa1RQfjQ4mOmyc2oWD87xJyCmh5/eXWXk6nNySykatT0NVxBs9bbj6di/a6bdk+LrrvHfoPpkKDDifprNFK3bM8mCapzVvHbzHzG2BJGQrNsB1s9TjxGIfhriYMGHTLb488YjSSnGdy1ZViTl+P40etvq4Wjedh0Ave0OOL+pBYEIer22+TYaSn7+GWT3a8uO4TizZG8Lv1+OYvPkOOSWVTx64pTIZJ+8/rvO9AoGApX3t8GjXmslb7nAvOb+Rn+YfUvLKCE7KJ6+kiornKjs0VUUExOfW2oe3B3YgMqOINRcVbyd6HkdTHeb4tGWTf1yD55u7VWt62hnw65XYepfxsdPHtJUGewOSFd5+HwdDcooruJuUJ3fZXvaGXI7MkrtcDZZttAhWYL0A9sbaZBdXyF2uhZoIfQVE2KIKMZ7tWqOpwOAwIr2wVkWKcz1eZTJALJVRJZHxILWAzVfjmPNnECEKHoNHQ1IZ5GJSr/fXn7cSGONurpAQUFxRxYYrMSxvwOel8O8Ewo+GOjTKt+tAUApBiXl8O9pF7iRDTGYRbx24x4/jOirkbSaTyfj4r4ck5Zby5QhnhQfyj9IKmbwloEHhRiaT8fv1+CdVoFUSGR8eecjpB2nM3BZIZEYhRxZ4N1q4ORqSyrjfbvFaN0s2THZ/IeGmtFLM2wfu8dmxMOb52vDuoOr0u9d7tENVJOCQEudzU5JTXMGqc1GMXH8DF3NdLr/tx8RulkoLN7FZxSzYFcyEjbfxttXn2ju9medr89Kqj9/sZ4dQgQkxVZGAVeM7vbBwU8Nsn7bI26qKUMCq8Z1xs9Rrkm02xOOCMtZfjvn7mS6I1i3U2DfXi9NLfZjVo+3/jHAjk8m4n5zP1ycf0eO7y7y+NZDiiiq+G9uRwA/78u2YjvjYGTQLN8008xTN4k0z/zm+PxPOzZhsxAp6I7xKBAIBXaxbs3J0RwI/6suSPnbcjsvF5/tLTP39Dn+FpFJWE0XyCvepu60+X450xv/tXnQw1mHF/lB6/3SFLdfilBZUlvVtT3fbNvR2MGiwzF5NRchYd3PWvebG92Nd8I/Kwvvbi3x14hFp+WUv+rEAcDbTZcv0rux9w5PI9CJ8vrvEj2cjyS9tnIij10KNT4Y5cnZZTwrLq/D78Qo/n4+ipKJuEaUuREIBkzwsubzCDxNdDQauucpP5yIV+t3VVIQs7mPHicU+3EvJZ8Guu1yOyKy13LF7KUgFQka6yZ8tVxbLNlocXuCNdZsWDPnlOnfichq1nkEuJmx7vStrL8YQk1n8TNx8eZWULdfjGnz/fD9blvSxY8rvdwhOzG1w2YYIScpj8C/XeFxQRl3ySYVYwvWY7Fr/3lJdhQ2T3dlyLa5Wa5UyLOhly534XPYEJjW43DsD7TkSkkpMZlGdrwsEAhb42nAxPKNe4/Dn0VAVMayTKQeDU+Uu62dvyO24HIWvT06mukQ8LlToOqypJiIlr1TucgKBgMRs+csVlVcRkV6kUFVjYh1JUyoiIa4KxB2riIRM7GpBV+vWcpeVSmX8FZrGqM51V9XkFFdw8v5jpnnVb0z9NH/eSqSrdRt6d6g/3nztxWhkMhjYCB+WhOwSPj8exo/jOskd6BWWVz2phBnobKLQ+tdcjOZyRBbbXu+msBF6WFoBk7fcZrZPW2b51O/hdSs2h5ziZ6/xYqmMBbtDUBEK2PeGV6PaaaskUj4/Hsanx8L4dbIbC3vZvlDb78PUApbvv0dibimnlvrQ1/Gf30koFDKhqyUhqflkFjTN/VARqiRSfr8ej9+PV4jNKub0Uh8+GOygtHnt44Iy3j98n0FrrtFKS40rb/uxsJdto03vFcXdqjUOJg0LMuoqQqZ4WjG8nnOxMQgFAnQ066/0U1MRsqSPXaO9lRShQizhxP00pv8RQM/vLxMQn8uK/u2580Ef3hvkgLPZq6/0rguZTMb9lHxWngqvFmy2BVBYVsVXo5wJ/LAv34/thG97g38ltbWZZv4v0Nw21cx/kiV7Q5HKZPR3NGKQiwneNm3+524EGqoiRnQ2Y0RnM9ILyjkSksqxe2l8dPQhQzqaMMbdvMmMfRXFtJUmbw2wZ3EfW848TGfHrUR+PBfJiE5mTPWyUqhFRSgU8MeMrnLLh59evncHI3p3MOJuUh6b/OPw+/EKQzuaMLenTZP4mnSyaMW217sRnJjH6gtRLN4TgpulHjN7tFUqzrUGa/0W/DrZneDEXL4+Gc791Hz6Oxor1b+v10KNr0e5MKGrBZ/8Fcbhu6l8MsyR/o5Gcn9zW8OW7H/Dk72BKSzZG4JvewM+GeaIobYGaXlFXIvKYqCjMVovKS1CQ1XEj+M6svNOEjO2BvLWAHtmdlfMp6MGmUzGweBUSislSOoIPYzKKOZRWiGOpvU/iM/q0RY1FSHT/whky/QuCkUYP01NolSVpP5jVSqr7XtTg72xNl+McGbZvlBOLunRKONJLTUVvhrpzJK9IfRzNMJQu+5BZTuDlgzvZMp3ZyLZPK1LncsMcDLmp/NRHA1JZXxXC4W2P8bdnOm/B/DpsOoY9/IqCRfDM9l5O4FKiYxD870BsDFogaGOOrfjcujVgGBQQ1v9FggFAuKyS2gvpxLDWEeDGzHyRUBVkfCZlrb6KCoXK2RWLJPJSMgpwVq/theMn70Bocn5tSqx/tkXAR2MtflypHOdrz9PUGIepZXieuPW9wUl08VaT6FqkMLyKjb6x7Fukmu951xMZjF/3krkr0Xdlb6HVEmkLNsXyrguFg2moUG1KLV8XyiWbbTq9WR6nr0BSfxxPZ4D87wxlWOWXcPD1AKm/H6Heb42zPNtuAXs9+vxiKW1fzeZrLo1raCsSul0pKyiChbuvkthWRXHF/VQyHi+PqRSGVuux/Hz+Wjm+9mwwM+mzvtGZ6s2GN9/zKarsXw0TLHj7EW4HJHJlycfIRIIWD/Jrd5jtSHySyvZcCWW7bcS6OtgxNllPWmrgE9WUyGWSOlh14aHqQV1ivGqIgGOJjp8ONjhhbdVKZZy+uFjtt9MICK9iO42+vhHZ9USz9VVhAx0NmZx78Z7z9WHTCYjLK2QA0HJHA1Nq04V7WLBt2Nc/hUj5Pqo2c8T9x9z8kEa+SVV9HM04suRTnS31Ue9ubKmmWYUplm8aeY/xzsDHTAxNSM4MY9TDx7z7sH7lFaK6edozNCOJnjbtvmfu1EY62ow388Gmawd91MKOBicwuztQbTSUmW0qzmj3cywaESqQ2NRV/lHWApLK2Dn7UQ+PvoQgQCmeVkzyMW4we9Q8HfKgrK4Werx21R34rKK2XwtnuHrrjPKzYxRnc3o1gQxmu5WeuyY5UFAfA4/n49m64145vi0Y0Z360aVvrtbtebQfG9OP0jnu7MRbL0Rz/uDHPCzN1B4Xzuat+LwfG8OBCfz/uEHXInMZLZPO7nmoEKhkEkelvR1MOTzE49Ysf8ejiY6ZOQX07qFBgM6vdxITIFAwFRPKxxNdPjo6AOiMor4dJijwn4r6y/HcDQktd7BuADYfiuB78Z0bHA9Uz2tUBcJmbktkI1T3fGxU2zAkZRTysLdIQotW5fvTQ1j3c0JjM9l0e4Q9r7h2SiRuFcHQ3q2N+DLE+Gsfc213uWW9LHD74fLBCbk1lntIRIJme9ny/rLMYxxN1eoxcHVohX62mpsuhpHal4Zx+6lIZPJKBdLafeUF4xAIMCvvSGXIzMVEm9EQgEOJtqEpRXIFW9MdDUUasFTFQkVqioqLhcrdD5nFlVQIZbWaeTrZaPPqvNRdb5PIAAdzWrjVkV/78N3UxjS0aROnyixRMr16Gxm9lDMT+iP6/HYG1f7e9SFTCbjixOPmNjVolFtIWsvxVBaKea9QfKj59dcjCY6s5hjC3sodLxdDM/gixOP2Dqjq8LC/MPUAiZvucMCPxvmyhFuMgvLuRKZVa/nSXGFmNc23+b44h4KV5PcTcpj3aVojHU02PZ6V4WvcXWRXlDOigOhJOeWsWuOh9wWmrm+NnxzOpxvTobx3iAHhMKmn4SKySziyxPhhCbns7xfeyZ7WCptCFtaKWbPnSRWX4yms0UrDsz1bpI0S0Upq5SwPyiZzdfiQCajdQs1cupok9bWUGXz9C4vZHibXlDO7juJ7A5IRltDhameVmx93RwNVSFdvrrwzDVKTVRt3v7D2E5NOhGXU1zB0dA0DgQlk5RTwtguFmyZ3uWVT/g1hEwm49HjQq5FZ7E3IJmsogr6ORrxyVAnfOz0X3lwRzPN/FcQyGR1THk208z/MVJSUrCwqJ5pTk5Oxtz8n4GrVCojNCWfMw/TScgu4WZsDn0cDBnkbIKfvcH/7A2kQlw9A34oOIWr0Vm4W+kxxs2cQc7GtHxJFRUNkV9ayeG7qey8nUhBWRUTu1kwycMKs1aaVIglFJRVUVhWRX5pFQVP/7esirzSSrKLKsgtqcSjbRuW91dshjazqJyDQSn85h+LjWFL5jZhQhXAzdhsfj4fRXRmMW/0bMd0L2ulZ2RrqBRL2XUnkTUXo3Ey1eH9v8uUlaGgtIr1l6PZfiuR17u3ZXFvW4X351pUFitPRzDY2YjZPu3QeIEBhrJkFpazeE8IBWVV/DbFXW4i0ZG7Kbxz6H6DFS9QXWp+9+N+ClVRHA1J5YMjD1g3yZXeHeQbQctkMq5EZrHxaiwB8bmIhIJ690dTVcSq8Z0Y5FJ3S0h5lYRRv96ku00bPhrqKHfbdZFZWE6fVf6sm+TWYLXDLxejuRyZyeH53nU+pFdJpPj9cIUPBjswpGPDLSyPC8o4FJzCpqtxFJWLEQkFz7Sv9bDVZ+dsjyf/fykig8+OPcL/bT+FBggfH32IuopQ7ncSkpTHnD+DCfqob4PL+Udl8dWJR5xf7tvgckdCUthzJ5n987waXO5OXA7L99/jxnu9a70mlkhx/PRsnWKRmkjIkYXeOJkqdn5XiCX0//kqP0/ohJtlbdHtbFg6nx8L4+o7veQOKvNLK/H57jJbpnepN/HnwqMM3j54j8tv+dFKS02hfawhKCGXqb8HcHiBt9z2k3Nh6by5L5TDC7orJMTcTcpj6pY7/Diu/nPpeR6kVFfcLOply5ye9bdK1bDmQjS/Xompt2IKqn8/F3Nd9szxbNB0XSaTsTsgia9OhPNW//bM7NH2hQbGZ8PSeffQfXp3MOTz4U4KTxik5JTw/bkIOhhrs6CXYvdORcgvqeSXS9HsupPEa90sWdbXTunjpUoiZW9gMr9cjMajbWsmdbPEux5R8WWQX1rJjluJbL2ZgLFO9STYIGdjTj54zDsH7z9zHKiKBByY5y03Aa8uZDIZQQl5bLuZwPlHGfjY6TPN2xofW/1nnke+PxPB79fjqRBLEQnAWFeTU0t8mqRdTCyR4h+VxYGgFC5FZNLZshXj3M0Z7GLS6OeWpkYmkxGZUcTJ+485ef8x6YXlDHI2oZ+j0b/yvN3Q2KCZZv6v8r9xtjfTzEtEKBTgZqmHm6UeMpmMh6mFnH74mO/ORLB8fyi97A0Z5GJML3vD/5kbIFRXvwx2MWGwiwlZRRX8FZrKyQeP+fRYGAOdjRnrZo5nuzZNJmTIo5WWGjN7tGWGtzU3YrP581Yi3b+99MwyIqEAVaHgyT5JZTLEEtmTAaFQAB1MFG+DMtTWYEEvW6Z5W7M3IKnJE6q8bfTxateGGzE5/HQ+ki3X4pnn244pHlZoKXksqKkIeb17W0a7mfPrlRjG/naTwS4mvNXfXuHWAF0tVT4Y4shIV3M+PfaQ3j9VD8KHdzKVO2hwtWzFqaU+Su1zU2Goo8HO2R58ezqC4euus3pi53oFlOiMIlYcuKdQGohQAMdC05jkId+7Z6SrGaoiIb9diaVSLGOgc8M+HwKBgF4dDOnVwZCE7BK23oxnf2AKMmTPxN3DP7439Q04NVRF/DrZjeFrr+NupafwwPRpDHU0eGdgBz46+oBzy3zrNZid7dOWHbcTOfMwvc7tqIqEvNGzHesvxzDYxbjWcVNeJeHMw3R23k7kblIeqiLhkwGO+Lkf5fnWEK92+qQXlhOXXaJQbLSTqQ5HQ+X76RjrapBTUkGVRNpgJYuqSKBw2pS2AklTiXXEhNdQ43tz5zmzahWhgJ/Gd1JYuAH+rgSR4WpRd5XFjluJTPa0UqgaYNPVODpbtqpXuKkQS/jy5CNW9LdXeiBeVF7F5qtxvNW/vVzhJiazmNUXovlhXEeFhJvYrGJWnYvinYH2Cp8f91PyeX1rAIt72zK7AY+bGiRSGdtvJTQo3ABUSqTcTcrjs+NhfDPKpc5lyqskfPpXGBcjMtj6elelWzKfprRSzJcnwjlxP42vR7kwXEnfE/M2LZjubc22G/EUlVWiranc7/o8YomUPQFJrDofxUBnY04s7qGQyfTTSKUyTjx4zE/nIhEJBXw5wokBTrWvNy+LxwVl/H4tnt0BSXQyb8XqCZ3xeSrue4iLCV+dDCerqNoIXVUk4MsRzkoLN6WVYo6GpPHnrQQMtNVxMNHhwnLfetvmpnlZs9G/2q9NQ03E7jkeLyzcxGQWcSAohcMhqagIBYxxM+e9QR3kTpK8SqIyiqpbou6nkZZfTm8HQ94eYI+fvWGjzNKbaaaZ+vnfGak208wrQCAQ4GKui4u5Lm8PsCcyo4hTD9JZcyGaFfvvMcjZGF97A/o4GClt0PcyMdBWZ7ZPO2b7tCMsrbqtavGeEDRURYx2M2O0m/kr6ysXCgX42BngY2fA4bsprNh/70lvuUQqk+t1M8NbsdaAp2mprsJsn3ZM87Lm2L00NvrH8tP5KF7vbs1kD6tG+dbUIBAI6GGnT3fbNlyJymL9pRj2B6XwWjdLJntYKi0Q6Wqq8v4gB6Z6WvHj2UiGrr3OpG4WzPW1UXim1dFUh/1zvTh2L42vT4az604Snw93qndAJZVK+e70I7q302dgp6YzYVQGVZGQj4c60tFcl8W7Q5jTsx1LetvVEhdNWmmypLcdFyIyeJRW+Hf8c93HTY1x8WvdLBQaFAzpaIKKSMCyvaFIpJ3kVp7UYK3fgs+HO/PuwA4cDUmtbiHKL0MilSGVVfveXI6sbQz9NG31W/DTuE58fSocBxOdRj1YT+5myaHgFNZeiuadgXW3rGipqbC8X3u+OxNBX0ejOsWO8V0s+OViNFeisuhl/2yL029XYln9VEJWfQNdNZEQs+dER001EcM7mXIlMksh8cbZTJdvToUjk8ka/P0MWqojoLqN6fltPr9PirRNFZaLFYoJT8gpwapN/b/T87436ipCZnhbK206+ldoKiM7m9X5HcRkFhGQkMuaiZ3lrie7uIJtNxPY9VQ11PP8fj0eLTUVXlMg2vt5Pj0WRkmlhNe7N3yNLiqvYu6OIPo7GTPYRf53kVFYzrTfAxje2ZTpCl7/Q5Pzmfr7Hd4b2IHJnoqZOF+OyGzQPF5NRVgdGSYAd0s9etrVXSGSml/G/J3BCAUCji9unJdVDQ9TC1h3OYac4gpOL/Wps0VPEVwt9DiskcKRkBSmecsXsurjWnQWX554hFgi46fxnehlb6i0V9nV6Gy+PxNBbkkly/raMcZNca+3FyUms4iN/rHcisvF2VSX3XM86xRkVERClvS25auT4QAM62TKRCXOiYTsEnbcTmR/UDIWelq83t2a4Z3M5AoRxroa9OpgwOXILP6Y3pU9AUloqqpgpKOOkY4Ghn//t7WWWoMTb4XlVRy/l8aBoBQi0wsZ7GLCT+M60d1Wv1FR7S+DmMxqwSY6o4iLEZn07mDI8n729Opg8EKthc0000zDNJ9dzfx/i0AgoIOxDh2MdVjerz0xmUVcjcpi09V43j34gB52+gx0Nqa/o5HSM5gvEydTXZxMdflgsANXIrM4FJzCgJ+v4mKuyxg3c4Z0NEb3BWfmFGW0mzm6mqrM3RFca9a+Ltyt9F5IZKpJqBrtasblyEw2+lcn/XQ0b8XM7m0x1lU+QaQGgUBAL3tD/NobcDE8k1Xno9joH8vCXrZM6GqhtIhjrqfF6omuPEjN5+uT4ez+4QpL+9gxycNSIZ8MgUDAiM5m9HEwYu3FaEauv8HErhYs69ceveeOx4uP0ikoraR7PYORV8mIzmbYG2szd0cwD1IKWDWh8zPiWkt1FZb1a8+yfu0pqRATkJDLtahsLkZkkJRT+sQ0t+Zois8u4X5KAZ0UnDEd4GRcnQSz+y5iqZQRSiSKaKmpMMnDite6WRKYkMfma3FcDM9AKoO0/HIyCsowamAg19/ZmFvxOSzYdZfDC7yVPmaEQgErR7sw448ARnQ2xb4ev5Jx7uZsuRbHnoAkpnlZ13pdU03EzB5t2XA5tpZ4M6dnO27EZnM/paDBCgUVkQCTOs4nZ1MdLoRnMksBfxY7o5Z0MNYmOa8Uy9b1n/cqIiEG2uqkF5Q1KN5UGxbLv84UVyheedOxAV+Op31vVEUCulq35t16RLX6KCir4kJ4Jsv72df5+o5biQx1MVEouve3K7F4tWuDaz0+Ken5ZRy5m8LXozoqPcA7cT+NSxGZnFnas8FBpVQqY8X+e9Xm9v3r/kxPU1hexYytgXi0a807A+QvD9VtdNP+CKj2X1FQuAFqtUupCAWoCAVUSWU4mejQx8GQHnb6dDRvVe81+GZsNot2hzDAyZjPhjs22h9PIpWx+Vocqy9EscDPtl5TYkURCoX0dzLkSHAa47uIlW6Ljc8u4euTj7gTn8vSPnZM87JusGWsLu4l57PydDgR6UUs9LNlqpfVK2uDuZuUx29XYrkSlcWozmZsn9kVG4OGq4XGdbHgh7ORmLbS5OtR8g2fJVIZ/lGZbL+ZyK3YHAY6G7Pt9a64WSrnI/P5CGfeyCvD1bIVr28LpEIsRf3v77pKIqVKIkMoqJ7o0ddWx0RXEws9TYy0NYjLLqaiSsKlyCzsjbUZ527O8E6KJ7K9bGKzip+0RMXnlNDL3oBhnUz5fmyn/6nK9Waa+S/T7HnTzH+Cpu5rTcgu4fTDdE4/fMyjtEK8bNowyNmE/k5G6CvwkP2qySup5Pj9NC6EZ3AnLof+TiaMcTPDx87glczSbL0Rz8pT4Q0OrNRVhKyb5EY/R/l+JMoQnJjLRv84rkRlMaKTKXN92ymU2CIPmUzG2bAMVl+IoqCsigW9bBnfxbxRD/MymYyL4ZmsPB2OVAbvDuzAACf5qVJPE5NZzJZrcZwNS2dFf3te62aJSChAJpPx6dF7OJjo8pqnclVN8ioiXoSCsire3BdKbnElK8c442Aiv80kp7iCW3E5XInMwj8qi+yiCmSAsY46t97vo9S+Xo3KYt7OYL4Y4cxY98ZfDzIKy1l3KZodt5MY4GTExql1Jz3VUCmWMmHTLToYa7NydMNmy/Xx/ZkI7sTncmCuV70D6QuPMth1J5FfXnOts6KrsLyK7isv8fuMrnRr+6zPSoVYwvydwdyIyalXwNFUFfL79K61/CsSskvo//NVQj7pp9DD+qA111jax1ZuhPTCXXcZ0dmU/g3EWoc/LmTiptvc+7R/g+v66OgDWqqryjXcnb8zmLHu5vRxqPuaJJZIsf/4DBKpDLNWmpxe5qN0Rea+wCR23k7i+OIetV4rrhDj+c1Fds72kNvOkZ5fxuw/g/h2TMd6vbTe3BeKRCrll9fclNrHtPwyBq6+yvdjO8r9ndZejGZ/cDLHF/WQO6lRIZbw+tZAVEVCtkzvopBofTcpj+l/BLCiX3tmyKkAeporUZnM+CMQqDY7b2fQgj4dDOlhZ0BX69ZyKyZkMhm77yTx1clwPh3mqFSVxvOk5ZexfH8o6QXlrJ7o2iiPlfr28b1D9+hg2ILXe9op9J6CsirWXoxmx+1Exrqbs7xfe4WEwqeJzijih7ORBCbkMt3Lmpk+bV9JZbJMJsM/KosNV2KrTas9rZSepAlLK8BEV5PWLeo/VvNLKzkQlEJQYi4hSflM9rDitW4WjYqTf56Pjjxgb2CyQpNbNfS2N+DdQQ5NkrTZFMRnl3Dyfhon7j8mLrsE3/YGDO1oQh8HI4X86P5Nmj1vmvkv8r991jXTzL+EtX4L5vvZMN/PhuTcUs6GpXMwOJmvTz3CzUKPfk5GDHQybpKbe1Og10KNaV7WTPOyJjqjiIN3U3jn4H0EgmovkLFu5kr3tCvD693bEpdVwv6g5HoHgyJhdbRuU+Nu1ZpN01oTk1nM5qtxDP7lOj3tDJjn244udSTyKIpAIHhSeXX6YTqrL0Tx25VYFvWyZWwXc6VShQQCAX3/NuzbF5TMR0cfsuVaHB8McZCbNlKDrWFLVo52oY+DEV+dfMTuO0ms6N+eyNQcCsvF9HZo2OPlee7E5bD6QjTfjen4QrG39aGrqcqWaV3YfC2OsRtu8d3Yjgzt2HCLRZuW6gztaPpkueTcUjZejeXw3RTeP/yAL0c6K/y992xvwJZpXZjzZxASqZQJXRs3GDPS0eDLkS7VfkYbbrInIKnBlhS1v0XKob9co6t1a0a7Kf+wuKi3Lcd+vsrewOR6/X76OBiy6Wocm6/GsbyOCggdDVXm+rXjSEhKLfFGXUXEpqldeOvAPU49TK+zFalCLK1zkGSt3wIzPU1uxuYoJMQ6meoQllYoVxSokkhJzitrcBlVkRDTVvKvuRVVUiz0Gh5cymQyrkVns7Rv/YNgFZGQFmoiCsvF/DmrW6MGrEdD0hjpWnf115G7KbQzaKHQ4P5X/1jM9TTrFW6CEnI5G5bOhXrMnHffSaS0UsLM7m2fEQQlUhnL94cy0NlY7m90KSKDDf6xHJznLVe4qanQKa4Qs2eOYilswYl5zPgjgLcG2DPd21ru8jWEpRXw5p5QDFqq8fFQR3q2N1CqWrakQsw7h+5zPzmfPXM86WzZSuH3Ps/xe2l8eOQBg5xN+H161yatRhAIBIzvYs4fV+OxMXxMzw7y20LjsooJTy/k6MLucn2Mnic1v4zV56M4di+NCV0tOPtmTwy1X/4zj1gi5fTDdH69EktmYTmvd7dm09Qujao+acibKiytgB23EjkamkpHs1bM8LZi3SS3RiUG1sfEbpbsCUxWaFmhAD4f7sTUOqopXzWJOSWcfFBdYaOrqYqWmoi5vu3o62DUqGTOZppppuloFm+aaUYOFq21nvjNpOWXcS4snRP3H/P58Ue4WbZikLMJA52NFTalfdnYGWnz/iAH3u5vz/WYbA7dTWXI2us4GGszxt2cYR1N0GvR9NVDnw13Iim3lFtxObUGg6oiAf+PvfMOi+Jc3/C9S7MgIL13QZSioIiiYu8mxpYYNcY0Y3pPTK8nvceYaIqJmthLYu+gAkqRKkV6770sbJnfH6selV1YYDGe/Liv61zHKzPMDsvMN/M93/s+j6eVIZM+P81ET0vuG+1MsLuZVqs+3C0N+XihL89N8+CXc9ms/DUKT+sBPDHJnfGDLLps7CwWi5jtq/wb708o4kBCMd+HZvDkpEHMH27XqVJ4XR0xS0c5cecwO9aHZrJ0w3nuCXRgxWhnjTxSRCIRU4dYMd7DnJ3RBXx5PB03s748Mcm93XYeVQy1M8bd0pCZX4fx0ozBLA9y0rr5tVgsYlWIG64Whjy3PY7EwlpenOap8XfmYNqP9+f58PhEd1b+GsVDv0Xz/VJ/jSdEY9zN+XVlIA9sjEIqF1jWiRaMm3G1MOTHZQHc/2sU9gP7thtJbmfSly/vHsbjW2IZamvc6RXUfvq6vHenN09vvciUIZYqJ0wikYg1swaz9KfzLAtyUikk3zPSkbEfn2RZkFObSYyujpgvFg/DuG8yf17IbxPZrhBQu8I9wdOCU2llGos3Zy5XdLiftQZx4fo6Yi6XNnR4rKrG1g4rLSobW2lokeFo2r5waWfShwnWRhp5/NxMcW0zUTlVfL1kWJttgiDwW0Quj3YQfQ3KSfS2qHz+eqJt9Q4oBZi3/05mdYib2ufQ5sg8UkrqOJhYzNql/td8XDacyaK4VsLPK0a2ew7ZFY08vTWOD+f7MMS2YxHgg4MpJBXWsnP1GI3u15jcKu7/JYoXZ3iqbAVUR2h6OY9vieWxiW6sDnHr9DMlu6KRVZuiMetvwJ7Hg7tcWVsvkfLWX8mcTC3TqIKpqwQ4m1NS28K2qEIsjPrgZdu++D/ccSBbHgrq1GdUNrTw/elMNkfmMtPbmmPPqjfo1SYSqZwd0fmsP5OFl7UR9wY6sGhE51uW26NVpuBIcgm/R+SQVFjHvOF27Hms88KWpnjbGeMwsC85lU3t7qenI+K5qR7/qHCTX9V0TbBJLalj3CALHgh2YcoQq275Cv4T5FY2cjK1jL/Dk/7pU+mlF63T2zbVy7+Cf6I0sqxewpHkUg4nFXM+qwpvO2Nmelsz08emwwnBraa2WcqBhGIOJhYTk1vFBE9LFvjbE+JpodVVpqZWGfPWniOrvPGGMmEdsYgLr06mWSrnj/N5bIvKx7ifHstGObEgwL5HXgzqJFL+PJ/Hpshc+ujpKBOqhtl1us//ZmRyBX/FF/H1icuIgKcmD+IOP9su+RmU1kn4MTSLLedzWRLoyJOT3DtV0i6XK5ArBPS78XIbnlnBSzsTsDPpyycLfds1cO0OmeUNrNoUg7VRH75dMpyB7ZSxq6JOImX15hhqm6X8cv/ITq0Ax+RW8+7fycwbbtehGWtH7LlYwJt7k9m5ekyHosznR9M4kFjMX0+M7VJ5+eNbYtERi/hmyXC1+zy2JQbjvvp8OF91as7bfyVT3tDC2ntVt9IIgsDXJy6z9lTGDVHpffV0SHlvhsqfCUsv55VdCZx7ZVKHk+UL2VU8+Wcs519tPwb8+9MZpBTX8207v2tJrYSgD0+Q9Z9Z7QqNi3+IYMkoB+4arv45EJNbxWNb2j8vQRAY/t4xfr1/pFqfmfb4MTSTsxkVbHqwrcFweEYF3568zK8rAzucnK7ZnUBji1ztdbD1Qh5rT2dw7NkQtcca+tZhGlvk6IpF6OuK+WyRH46m/Vj4Qzh/PhzU7u/XIJFy70/nGeViymuz2499B9hyPpcvjqax+7FgjcaTi3nVLP/5PC9fMXrXlG1Rebz91yU+WuDTKW+rqxy/VMqz2+NYEujIS9M1F5VvJia3ih9CM2luVfD5Yj+sbkFF7o+n0ihtaOXNuarv+67Q0CJj47lsfgjNItDFlBemeWok1HWX2iYpmyJz+PWcMtFp9QQ3ZvvYaNUEuaxOwl8JRawPzaKvvg7Lg5xYFOBwS7xkvjyWxtpTmWpbp/R1xdwX5MTrczq+t7RNQXUTx5JL2RtXyKXiOoLdzZntY8O0Ida3jc+OJrTKFETnVHEytYyTaWXkVzUxysUMP1M5Ly0IBnrbpnr599Ar3vTyr+Cf7mutamzl2KUSDiaWkFpch4WRATO9bZjpbY1rF1Zse5Ks8gZ2xxayO7aAVrnS0HWBv73WXtLK6iXM/PoM1Y2tKATQEcEMbxvWLv3v5LFFJudgYjGbInJJKa5n3nA7lgc5MqQT8bua0iKTs/diIT+GZdHUIufBsS7cE+jQ7dJfmVzBnouFfHPyMno6Yp6ePIg5vrZd8hi6XFrPx4dTicyqYvUENx4Idrml8ZqNLTI+PpzKzpgCXpquXPnuiQj6hhYZz2+PI7mojh+WBahtAVFHq0zBK7sTaJDIeGmGZ6e8jeKvpNc8McmdR8Z3XO3QHl8eS+NScR0f3OXTrogkVwgs//k8DgP78tEC305XBZTWSZjyeShrl/oz3kN1pU92RSMzvgrjwFNjVX4fhTXNTPzsNIefHtfuWPTruWw+OJBybYJhP7AvZ1+epHJfiVTO8HePse+JYDw6aMesl0jxefsoUa9NwWKAemFyd2wBWy/ks/3R0Wr3qWxoIeD946S+N6NdwWPm12d4fqoHU9qpDNoVU8C26Hy2r1L/eVnlDcz4+gxJb0/vkui7ZH0kS0c5MkdFOtWjm2JwNu/foS9PbmUjU78M49DT41RW/9Q2S5n42Wn+c5cPM7xVt07WNLUy7N1jN/w3PR0RFoYGLAiw5/l2jIcFQWD15lh0dUR8dfewDifUey8W8vreJLY+MgpvO5N29wVlu9f9v0bx9h1DNfamEgSBdacz2XI+l88WDWO0W+divBUKga9OXObnM1katXOqQyZX8O3JDNaHZfHc1EE8EOyCzi1KXSquaeS9/Zd4dJwLvk7dM6pvkcnZEpnH2lMZTPS0YPFIxzatlj1BSa2EX85lsyUyFx97Yx4NcSPEw0JrFbmCIBCTW81vEbkcSSphlo81dw63I6QblbiaIpHKOXaplB0xBSQU1FDTJFW5n4GumNk+Nny+2O+WxawX1jRzKLGY/QnFJBXWsmiEA8MdTJg29PYK5+iIsnoJp9PKOZVaxqWiOpqlciZ6WjJxsNKY3NBA9x+fG/TSS0/QK9708q/gdhqga5ukHE8p5VBSMWHpFbha9GeGtzWzfGwYZGl4yx7QHaFQCERkVbIrpoBDSSW4mPdnQYA9d/rZYt7OJEsT0krquXPtWSRSBbpiEdsfHa3W2yWpUNl3XlDTTItUzvLRTsz0tul2hczNKBQCx1JK+SE0k4yyBpYHOXF/sHO3e/ilcsWVeOcM+urr8PxUD6YPte7Sy2FkViUfHkyhpE7C81M9WRBgf0tjQcMzK3h5VwI2xn35dIEvTj0QP69QCKwLzWTtqQw+nN/5FXNBEPjiWDq/R+SyfnkAo1w1n7glFday7OfzPDzOlccnunf21G84h2e3xZFd2cTWh4PaFdrK6yXcu+E894126lJJ/KaIHDacyebos+PVChZv7UuisEbCTytUmym/sCMeHZGIjxe2b6C8O7aAF3cmIFcIDLU14sBT49Tu+9BvUYx0NmWVBm0/Ez49xdt3DGXCTclX1xOeUcEruxMJe2mi2n3qJFJ83z5K4tvT2hVfx358ks8W+RHUzrXxxdE0SuokfLLQT+0+O2MK+PNCHrtWj1G7jzpSS+qYt/Yc0a9PbVN1VVTTzIRPT3Pi+RAcOqjSfG57HGKRiM8WqT7Pd/5O5nJpA5seDFT7bInJrebeDZFt/MhEgMUAA9YtCyDASfX4vPZUBn+cVxout2f6CsoY6kd+j+HH5QFqxcbricqpYuWvUcr2v1GaVdxI5Qpe3Z3IuYwKNj4Q2KF4eDPVjS08tz2e7IpGflw+osumsHmVTTy97SINEhlf3zP8llSo3MzXR1NpaJXy2pyuVd/IFQK7Ywv46vhlBvTR5aUZnp2ODu8KmeUN7Iop4Kez2Uz0tODRELcuVbapQyKVsy+ukN/Cc8mvbmLxCAeWBzlp1JrcHQRBIL6glp0x+fwVV4S5oQELR9gzf7g9r+5J4FRqOddPuAx0xYxxM2PDfSN6PGq9uLaZg4klHEgoIqGgliBXM+b42jBtqHWH9/XtgkIhkFBYy8nUMk6llpFcVIuvvQmTBlsyabAlQ22N2ly7t9PcoJdetEWveNPLv4LbdYCul0g5mVrGocQSTqeXYWvSl3tGOhLsbsYQm7YPmn+KhhYZBxOL+SuuiISCGgJdzFgYYM+kwZZdFlHOXC5nxS8XcDHvz/HnQjr8XWubpOyIyWdzZC4NLXKWBDqwJNBR615CgiAQlVPNj6GZROdWM9fXhgfGunS7QqpVpmB7dD5Hkkooq2/hmSmDuiTiCILAgcRiPjmcRl89Ma/M9GKC542rkbF5Vdga9+V8ViXjBllgqsUEtMYWGWtPZfBbeA7PT/Pk/jE9U4VzKq2Mb09cxs/BhFdneXW6fW/rhTze+fsSHy/05Q4VlQ3quFRUx7Kfz7NitHO7ZrUd0SKTs+yn85gbGrD2Xv92v6PzWZXc/2sU21YF4Wtv0qnPkSsEFqwLZ6y7GS9MV12lUdHQwoRPT/OLimQpUCaVzfrmDKEvTrjmdaKOY5dKefj3aGyM+xCxZrLa/XZE5xORWckXdw/r8Hd4fEssQ2yN2hXMMssbmPn1GdLem6F2rJBI5Qx+4zAxr09pt71w2LtH2fLQqHbNSp/68yKe1gPaPadX9yTSX19Ho1ahm/noUCqFNc0q28A+O5JGakm9WrHtKlf/bieeUy3ypJfWMffbc+x/cmy7hvTbo/N5a18yzVK5yu26YhGrJ7jx9ORBN0wiT6eV8diWWLavGt1hlVxSYS33rI/kvXlD221Xu8pV4ebVWV5qTblvprFFxmNbYimtk/DbA4Gdbk9KKa7j8S2xBLqYsmaWV5fadQVBYFdsIW//lcwCfzvWzPK6ZXHZN1NQ1cBHh1J4bcZQbDrhSSMIAkcvlfLZkTQkMjnPT/XkDj/bHq9Gicuv4YfTmZxMK2PZKEfuHeWEu6X2KpPzqprYEpnLtuh8rAb0YcUYZ+YNt6VfJ2PVO0tZvYQ9sYXsjCmguFbCXD8bFgY44O9ocm0sO5layurNsdcEVH0dMd52RvzxcFCPXT+ldRIOJBRxIrWM81lVBLqYKv37hlp3OnHsn6K2WUpEZgVHL5USmlaOVK5gvIcFkwZbEuJh0eHvcbvODXrppTv0ije9/Cv4Xxigm1plnE4r52xGOXsvKldlZvpYM8vbBl9749tGyMmvamJXbAG7YgtokMiutVV523VebDqaXMLA/vqM7ETqk0IhcCajgk0ROYSmlzNpsNLgeIybdg2OAdJL6/kxNIu/E4qY5GnJoxPcuh3r2iKTsy0qn7WnMjDtb8AzUwYxbUjnYsFBKQbtii3gsyNpuJj358XpnoxyNUMQBB7bFI2XdX8uldbz5pyh2A7UfmteRGYlL+9KwHKAAZ8s9O2R9r/cykZWbYrBuK8ea5f6d9os9HRaGU/8cZEnJrmzaryrxt9xWkk9S3+K5N5AR56d6tHl66qqsZW7vj/HTG+bDttfrrZ5HHhyXKe9BFKKa1nxSxSbHxqlttLg2xOXCUsvZ/ujo1X+Pqs3x2Bj3Jc353YsRLy2J5HQtHLOvqK6bQqU48TEz04T++bUDlOY1p7KILW4jm/V+O6AcmI+9K0jxL4xVe1KsFwh4PbqQSLXTFZrpiwIAu6vHeL0CxParWq587uzPDLejdm+6o1lH90Uw4IAO6YO6VySm0IhMPbjk7w3z7tNDHmLTE7wRyf58u5h7ZpeAzz550UMDXRV+hkJgsD9v0YR4DSQpya3L0J+eDCFDWeyaC+t2EBXjJuFIT/fPwIb477kVjYy99uzvHNnx2JMXmUT89eF8/A4F40qsS5kV/HAxihem+3VbnLb9ZTVS3hgYxQmffVZt8y/022v++IKWbM7kUdD3HhionuXhIraJimv7knkfHYlny70Y+Jg9ZVkt4qXdlzExkifZ6cP1Wj/5KJaXtuTREF1M09PdufukY5ar3K9HkEQCLtcwQ+nM0koqOHeUY48MNalQxFZUxQKgbMZFfwekUNBdTOuFv25b7Qzo1xMe/SdqkUm50RKGTtjCkgrqcPZvD+LAhyYPtRaZSWmTK4g4P3j1DZL0dMR4WzWn92PjdF6clNZvYRDiSUcSCgmJq+akc4DWeBvzwRPy3bbVm8XBEEgo6xB6V2TWkZMbjWDbQYQ7GbOpMGWBDgN7FSV0v/C3KCXXjpLb9pUL73cIvrp6zLLx4ZZPja8OWcoYenlHEoqYdlP5zHqq3eltcqa4Q4De3wFrD0cTPvxzBQPnpo0iKicKnbGFHDP+gjsB/ZjQYAd84bZaRyRPm1o5yY9oEwoCvGwIMTDgvyqJracz+OJP2IZ5WpKkIsZ8wPsuxTZqwoPqwF8vtiP56d58MvZbJZuiMTbTtl7f3O1i6YY6Opw32hnFo9w4M8Leby+N4lvT17mmckeTPbSvCRdX1fMkkBH5vrZ8vOZbB78LZopXpbo6YBcEJjgaU1kTg2F1S09It6MdjPj8DPj+ORwGrO/OctzUz14YKyLVtu4nK68wL60M4G5357lh2UB+HVCPJvgacnWR4JYuTGKguom3p47VKMXO0/rAWx9JIglG84jVQi8NN2zS39r0/76/Hr/SO76Phwns37tTkRXjXclOqeK53fEsX75iDb3eFJhLVHZVawc29ZQ2cvGmHnD7Xh1dyLbV41WOT48MNaZQ0klHEoqYZZPW0HisQnu3L0+gicmuXdYJr9mlhe7Ywu5VFSnth3EwbQfLub9OXe5gpkqPu96vO2M2BHdflxufwNdBvTRpaRWovb8dMQidMQildHmV2mWypErhA4NohWCgFM71QoNLTKOXirhnTs1mxRfz4WcKpqlcpWtQ4cSSzDqo0ewW/s+JakldZTVSXhlsep2qaOXSkksrG3XzPoql4rr2hVuQCmMpZbUEZ9fi1EfPR75PYaFAe2bPoPSh+i+X85zh58tj4x37fBczmdV8uBv0bw+24t7NBRuMssbWPHLBQKdTflogW+nxAapXMGHB1PZGZPP2nv9uyy4RGRWsj4sCxA4/Mz4LqdSaZv7g1346ng63524zOOT3Dscx/R1xEwdYsXKYOcerUiRyRUcTCrhh9OZlNZJuH+MM+uW+WvNU6VeImVXTAG/R+ZS1yxlSaAj783z1poopApBEEgsrGVnTAH74ooY2E+PhQH2vDfPG7sOKoR1dcQsHmHPT2ezsRhgwNZHgrQm3JTXt3A4WdkSFZ1Tjb/TQOb42fDd0uG3JNq9u0ikciIyKzmVphRsyutbCHY3Z46fLZ8v9sN+4O0VANJLL/80vZU3vfwr+F9W11tkcsIzKjmYWMzRS6UEOA3EYWBfZnjbEOhieks9T9TR1CrjcFIJu2MLSSupw8fehIUB9kz2ssRAt/2SX5lcQVl9CyV1EkprJZTUSahrlvHQOBeNI58lUjlHk0v45VwO6aX13DXcjvtGO3fZr0AdtU1SNp/P5ddz2Zj1N2BViCtz/Wy7lcglkcrZHJnLD6GZ2Jr05cXpnox1N++0WFDV2EpEZgV6OiLGuJph2FefHdH5vLEviQX+9rw43bPHzAajcqp4aWcCJv30+HShn1ZL3UH5UvzTmWy+OJbOO3cMZfFIh079fEF1Eyt/jcLJrB9f3zNc4+sqs7yBZ7fGMd7Dguendb0CJzKrkpW/RrHhvhGMHaR+Ul7T1Mqcb8+yLMjpWkS0IAhsiczj7b+TAUh5b4bK662pVcbUL8J4YpK7WpHozwt5/BiaybHnQlQe49XdCVgM6MOzUz06/J2e3RaHaX993mgnAeU/B1OoaWpt1zcGlJOLkR8c79Cr5r6fz/PAWJd2vXHu+PYsX9w9TO01WFrbzGN/xPLnw0Hoqxmbrhr4tnc+4RkVvLAjnvB2WsfUsWZ3ArpiMe/N826z7a7vz3GHn22HqWerNkVjY9yXt+9oKx5JpHKmfhnK4xPcNRJARn94guJa1THsYpEydn6qlxVrZg3G0bQfT/xxkcrGFjY9OKrdsa+xRca9GyJxMO3HN/cM73DR4ao58RtzvLh7pGbCTXROJQ/9HsO9gY682EmRtby+hcf/iKWuWcqPywO6lKQnlSv44lg6v4XnsGaWF0sDHRCLb40psabkVzbw6dEUpnvZMrsLqVvaRCKVsyOmgGPJJWRVNPLIeFcWBThozYA/o6ye3yNy2RVTwCCrAawY48QsH5sO30O6Q1m9hL0XlW1RRTUS5vjasDDAngCngZ26HnMqGnl660W+XxbQodjTEZUNSsHm2KVSIrMq8bUzYZaPMu30VqSddZfCmmZOppZxOrWMplY5eVVN17xrRruZaa2V7H95btBLL+roFW96+Vdw/QD9+9Fo7hjr2yPx0z2NVK7gfFYlBxJLOJpcgkikrF6Z6W1NkKuZVmO9u0pBdZOyvzu2gJomKXN8rbE27oO1UR/K6lsprGkmr7KJ4tpmyhtaqGuWAcqyfB2xCJlcgVQhEPO6+vaI9kgsqOX3iBz+ii/Cz8GE5UFOzPC21up3I5HK2R1byKm0MpILa3lwnCv3jHTQWBRQRVOrjD/O57EhLAtrk748M2UQE7SQrJFd0cg7fycTl1fNq7OG9JjJcXOrnM+PprHlfB6vzBzM0lGOWjdZPJdRwRN/xDLbV1md1pkV9tpmKe/9fYnLZfVsWDFC4xXHnIoG7t1wnune1rw5Z0iX/x67Ygp4++9kdq8e067/SEJBDXf/GMnGlSPxtjPmxZ3xHL9URqtcae594KlxakXJEymlPLc9nuPPhagsgZfJFcz4+gz3jXbiPhXmyJFZlTzyezThayZ3WJlyLqOCp/68SOSrk9XeW+EZFTyzLY7zr07u8HsL/OA4393r326KzfKfzzPLx6bdCibft4+wbdVovGxUVwRllDUw59szpL43U+0x4vNrePC3KKJfn6p2n+9OXialpF5txLo6WmRyRr5/nF9XBrYxAU4qrGXxjxFEvjq53erBxALlfqEvTlBZ5fjdycscTi5h3+NjO7zXZXIFHq8falN5IwJ0dUQEOA3kjTlDrvkD/Raew6aIXLauCmq3ukQqV/Dwb9FYGffh3TuHdjh5jsyq5KHfonn/Lm/maSgwHE4qYcOZLO4cZqvyem6P2LxqVm+OIcjVjA/n+3SpyiT7ymRbKhf45p5h7d7XXaFOIiWpsJYxHVRhacLm8Cwyy+t56872hdSeorZZyuZI5cKHuaEBj4a4MtvHBj0tiCpyhcCJlFKOJpfyV0IRc3xtWDHauVNVmp1FIr3aFpVPfnUT1kZ9WRhgr7Yt6lZQ1djKkWRlS1RkViV+DibM9lGmmtpo2RtQ28jkCmLzaq6ZDWeUNxDgNJBJgy2Z6GmJh1XPhHn0ije9/BvpFW96+Vdw/QA97s3tFEr74+9ocqX9RulC/0+2InUFmVxBVE41h5KKOZxUQqtcwVQvK2b72jDGzbxH+9Q14WoM54+hmRxLKQNAJAJNRpSx7uZsfmhUtz6/urGVnTEFbIrMpVkq5+FxrtzhZ6vWC6MryBUCR5NL+CE0k5zKJpYHObFijHO3esebWmVsisjlx7AsHE378cyUQd2ORxUEgdC0ct76O5l++rq8OWdIp+NzNSU2t5qXdibQV1+HTxf5MthauykrBdVNPPFHLHYm/XhjzpBO/T1bZHJe2plATG41G1eO1DhKPL+qiXvWRzJpsCXv3DFU5VhRUN1EUmEtM7zVtwhtCMvit4gc9jwW3O41sikih43h2TS3KqhoaKVVrmwD6qevw/vzvJnvr/4Fc/XmGAx0xXx1j+p2mWOXSnllVwKnX5zQpqpEEJTmx9OHWnfoTXLVt+XdO73VRm63yhQMf/co2x8d3a45MMADG6MY627OAyrawq7y4o54bEz68lw7lUEj3j/GzytGqp24Xcyr5pFNMUS9NkXtMfbFFSpX79tJkXpgYxTB7uY82M75quJwUgn/OZhC6IsT2tzTcoXA5bL6Du+Zlb9eYJDVAF6d5dVmW3FtM5M/D+X3BwIZoYGXWHZFI5M/P32DeKOvI8bFoj9vzx16wzgRll7Oqk0xbH0kqN2JsSAIvLAjgUvFdWxbFdRhG2tEZiUP/RbFW3cMZfEIzarqfo/I4aNDqXx59zCmd6L9VhAE/jifx7bofOYNs2NlsHOnx1ZBENgRXcA7fydzT6AjL83w1GplhyAI/BVfxPsHUhjmYML65QHdnriW1DTy9r5LPD7JFR+Hnhn7VX7udXHf3nbGPDrBTSuLEqB8xm+NUoYYKASBZUGO3D3CAfMeagUSBIGEAmVb1F/x/22LusvfvkuVMvUSKYYGut36LqoaWjiWUsr+hGIiMivxsTdm9pX2e22HOWibqsZWQtPLiMuvYe/FInTEIiZ4WDBxsCXjB1l02vutK/SKN738G+kVb3r5V3DzAC02NCM0vZzQtHLOZVSgrytmvIcFEz0tCHY3/59x2r+KQiEQm1fNwcQScisbuZBTxVQvK2Z4WzPew+IfS7u4yu/hObz9d3KHvgoAfXTFfHXPsHYnwZ1BoRAIvVzOkSttXVOGWLI8yJkgV+0ZFgqCQGRWFT+GZRKRWcnCAHseHufarejRxhYZmyJzWa9FEadFJufXczl8dzKD8R7mrJnp1WEUcVeQSOV8c+Iyv5zL5tEQNx6b4K5VMVHSKuP1fcmcTivju3v92418vhlBEPj8aLryu+1ElHhBdRP3bjhPsLsZH8zzuUHAKahuYt7ac9Q2S7n45jS1VSuCIPD01jjyqprY+oj6FJHdMfm8sDOhzf0iFsH9Y5x5c656n5WSWglTvghl3TJ/lYa3giBw94+RjHI15flpnm22H79Uypo9iZx5aWKH48b3pzJIKqzl+2UBavdZtSkaX3uTDqPXPz+aRlGNhM/VeLhc3aesrqXdSPMxH57gmyXD1QoXZy6X89ZfyZx8foLaY3xz4jI5FY1qk7IEQcD/vWP8fP9I/DsZYfzSznjcLQ15ZHzHxr2qiMmt5r6fzxP20kSVz6mn/ryIWIRa8e5mjl8q5ZFN0SgEZfWjmaE+b84ZwvSh1jeMNXmVTdyx9iyvzx7CwoD2JzifHkll78Ui9jw2pkP/s6vCzdt3DGWRBsKNIAh8ciSNPy/k8fOKEQQ4/ffvvOV8LsFu5mrHXYlUzpv7kjiZWsZ3S/wJ6oKA/V9T4io+X+xHiAaR550hs7yBN/clkV7awOuzvbjDz1Zrz6lvjqUgF+DZaW1FP22TVdbAj2FZ7IkrZIKHBY9OcOv0vaKOpMJafgtXVtcOdzTh/jHOTPGy6rE47dLaZvbGFV1Li+pqW9T1pJfWM+3LMPR1xdga98HVwhBPqwG4mPfHyawfzub9sRxgoPL4NU2tHE0uZX9iMZll9ZgbGjDH15aZPta3tf+LIAgkF9VxKrWMU2llxBfU4mUzgDv97AhwHoifvckttwHoFW96+TfSa1jcy78SW5O+LAl0ZEmgI1K5got5NYSml3HsUinPbIvD2874minuMAeTHnsp0BZisYgRzqaMcDZFEATiC2o5lFjM+wdSqNwWxyQvK2Z5WxPiadHjsZiquG+MM1KFwEeHUpDK21dwdMQiJg1WvZLfFcRiERM9laW3j090Z/P5XB7bEoO5oQHLRzsx39++wxaRjhCJRIx2M2O0mxkpxXWsD8ti2pdhLB5pz6IAhy6Vb/c30OXREDeWBznxe0Quz26Lw8vGiIfGuTDRU3Nj4+sx0NXh0RA35vvb8dmRNKZ+GcpDY11ZPcGtWy1fN9NHT4eXZgxmprcNL+6M53BSCZ8u9MPHvv3qC42Pr6/Lpwt92XI+j5W/RvH8NA8eHOui0XciEol4YbondgP7cv+vURpHidsP7Me2VUEsWR/Jy7sS+GiBLzpiEcW1zSz4PpzqJin6OiJOpJRyp5q2D5FIxCcLfVn203me3x7Pt0tu9AGRSOW8sTeJvXGFKoVOhaCcvLeHtXEfXpjmwet7kzjyzPg2AoxIJGLNrMEs/ek8y4Kc2vgfTBpsiVl/fXbGFLAsyKndz5rhbc1Xxy9T09Sq1k9poqclO2MKOhRvhtoacexSabv7WBn1IaGgtt199HTF1yqVVFEvkTGgg2s9p7KxXf+TnMomGlvkDFVj1qyO2mYpe+OKOPjUuE793PV8eSyd+4OdVQo3F7KrOJFSyol2hKmb2XohD4UAhga6vDbbi0UB9m2ed02tMh7ZFM28YXYdCje/hefwx/k8dq7uWLgJz6zg4d+iNRZuWmUKXtmVwIWcKnatHoPbdQl3meUNvLYnCfuBfTn8zPg2Y3phTTOrN8cgFon4+8mxXTKujcyq5MfQTMQiOPLMOK0u8kikctaeymDDmSzuGenIumUBWjPev8qEwdasD82gvknCgH49U51yMa+aH0IzOZ1Wxt0jHTn41FiNKxzbo1Wm4ERqKT+dyeZSUR13+dvx1xNjte5rd5WraVE7ovMprZdg2s+Axye6a60tysW8P/30dWhqlZNT2UROZROh6WUY6OqgEAQkUgV6OiKsjfrgYmGIrXEfimqalQtF2VUMsTFilo8NH8zz7pEFGG3RIJFyLqOCU2nlnEoro0EiY9wgC+4e6cC6ZQH/E/47vfTyv0avePM/QF5eHt988w0HDhwgLy8PAwMD3N3dWbx4MY899hj9+nV9YK+rq+PgwYOcOHGCmJgYsrKyaGpqwtjYmKFDhzJnzhweeughTExM2j2Os7Mzubm5HX6ek5MTOTk5XT7frqCnIybQxfSa18Kb9S2cuVxOWHo5j2yKQSpXMG6Q+bUWK2223fQEIpGIYQ4mDHMw4ZWZg0kuqlNOno+m8ez2OKZ4WTF1iBWTvay6LVp0hgfHulDT1MqPoVlqJ1diEUz3tu6xli8H036smenFs1M82J9QzKaIHD4+lMp8f3uWBznhoYUXQS8bI768exjPT/NgZ0wBSzZE4muvTKjqSuVMfwNdVk9w477RTuyKLeDFHQnYmvTliUnuTPWy6lK7n+WAPnyy0I9lQU688/cldsTk89osL+b42mq1fdDH3pi/nhjLutOZLPoxnAeCXXhq8iCtVIKJRCKWBTkxxNaIxzbHEpdfw8cLfDUWoZYEOmJt3Icn/7hIYXUzj4Z0HCVuY9yXbatGs2RDJC/uiOeF6Z7MXxdORWMrcoVAs0Jge3SBWvEGlMLWj8sDuOv7cD49msbLM5QR4rmVjTywMYqC6uZ2Bc70sgYEQWj3XJePdqaxVY5MTanbcMeBTPC04Kvj6Xw4/8YqFrFYxOoJbnx2NI17Rjq0K1y7WhjibWfE3/FFLFfjORLiYcGu2AKqG1sZ2I6H1VBbYzLKGmiRydW2oNgY96FEjbHuVfR0xO2mTdVLpB2muORWNrVbURGbW423nVGnW2UOJxXjaTWgy4bekVmVxOfX8N29qqtqCqqbeH6ap8bPqJqmVs5nV+HvaMIfD6uuBBMEgZd3JWLUR4/XZrdfsXEwsZiPD6ey+aFRNwgrqgjPqODh36N5507vDgUhUP7dVm+Opbqpld2PjWnjWfXdyQx0xSLK6lp48s9Yflkx8to9Ep5RwRN/XmSGtzVvzR3S6b+bVK7gy2PpbAzPYc0VPy9tmhKfTCnlrb+TMe1vwM5Hx+Btpx2R+2Z8HQZiatiHDw6ksHqSR5cMmlUhCAKh6eX8EJpJYkEtSwIdOf3iRK0kO5XVSdhyPo8/LuRh1EeXe0c58sv9I3vEs/BqZciO6Hz2xRdh3FePhf72zA/oWltUe+jpiJnpbc2ei/8V6uUKaGqVX9tHKhfIr24mv7r52n97arI7/5nve1sLNtkVjde8ay5kVzHc0QRvO2O+WDyMkc6m/3hLfy+9/NvpbZu6zTlw4ABLly6ltlb1aqSnpycHDx7E1bXjiM6bOXToEHfddRctLS3t7mdlZcWff/7JxIkT1e7zT4s3XS2NVCgEkopqCU0rJzS9nOSiOtwtDRntZkaIhwUjnAf2aIqBNhEEgctlDZxOK2NXTCHZlY2MH2TBLB9rJntZ3RIDZ0EQeHNfMtuj82lRMcESAfamfXE1N2RBgD3Thlj1eMtXfH4NmyJzya5oRE9HxPIgZ6YNtdKawXFNUyubI3PZGJ6DuaEyoWqOb9cTqppaZfx5IZ/1YZnYm/QlwHkgr85Sn/jTEYIg8HdCMTuj86ltlvLm3CE3tCJoi9SSOl7amYCdSV8eGufaxqy1O1Q0tPDEH7FUNbbyw7IAXDuYOF5PUmEtD2yMYlGAPc9O9dCoyq6sXsIDv14gu6KJFpniBpFERywi9vWpHfbrZ5Y3MP/7cF6b5cV8fzsC3j9OXbOUjh64IuDMyxO7XR6fXdHINycu8/kivzaCnUyuYNLnoTw/zaNdIQqUrSrbo/LZ98RYtfvM+CqMxye6M7edCidBEPB75yhbHgpSW6GVVFjL0p/OE//WNLXHmfX1GZ6d6sFUNT48P53JIia3mnXttHqNeP8YP60YyTA1FXOfH01T+rpMH6z2GKpYsj6SKUOsOu2TA8rv58GN0fg5mPD0lEGd/nlVx3v8j1haZQo23DdCrRi4ISyLn89m8/eTY9v1abqaqPbdvcOZ7NV+5WREZgUP/hbNuxoKNyV1zTy0MZqB/fVZtyygzaJDSa2E4I9PIr9yH+rrinlqkjuPT3Rnw5ksvjx2mbfvGKJxgtX1XDUlbpUp+GbJcDy0aEpcWNPMu38n09wqZ7q3NUtGOva49155XTM/n80mr7KJtcu656Ujkys4kFjMD6FZlNVJWBnszPIg5257lVz1y/stIpcjSSWMcTdjxRhnQgZZ9Mj3U9nQwp4raVF5VU3M8rFhUYA9gS7aa61WxZnL5Tz0W7TKd6Gb6aevw19PBGuliknbtMoUXMiuUgo2aWUUVjczytWUiZ7KdKjutI/3NL1tU738G+kVb25j4uPjGTNmDE1NTRgaGrJmzRomTpxIc3MzW7duZcOGDQAMHjyYqKgoDA07t9q3efNmli9fjlgsZurUqcyYMQM/Pz9MTEwoKChgy5YtbNu2DYB+/fpx7tw5hg0bpvJYV8WbO++8k/fff1/tZ+rr6+Ph0XFMbWfR1gBd3dRCRGbVNTGntlnKGDczQjyVLVbaWsm6FWSUNXA4qZhDSSWkl9Yz1t2cmd42TB1i1e4KeXdRKASe2nqRY5dK27y0OJr248+HR7E3rohdsQWU17cwx9eWhQF2+Dt2vb9cE6obW9kenc/m87m0yhTX2uq0VdYrkcrZFVvAhrAsWmWKbidUtUjlHEspJdDZtMP2BE1obpWz4UwWP4RmMtnLipdneGq9f14qk/Pz2Ry+PnGZJYGOvDDdQ2ttfDK5gk+OpLEzOp+PF/qpnbyroqC6idWbY7EYYMC3SzqOEq9oaOGOb89SpKIKpK+ejsZx5hGZlTywMYqfVoxArhD48FAKGWUN7Vbe9NXT4et7hjGtEyatXWHL+Vx2RRewc/WYdidMtc1SAj84zoF22iM+PpxKaZ2ELxYPa/czX96ZwChXU7WGzBUNLYx4/zip781QK+reufYcq8a7MstHtWfWl8fSKapp5tNFqr116iVSfN4+StybU9W2gs38+gxPTHRntq/mvlzFtc2M+/gU4WsmaZx0dj1nLpfzwo54jj07HqO+3R+fd0Tn8/HhVA4/M15tatTZy8rqmD8fCVIrZF3llV0JDHMw6TCa/OzlCh7bEsP7d3lzh1/HqVIZZfWs+CWKub42PD/dU6Xo/c7fyWyJzLuholP3ivnppeI61i0L6HTrak+aEkvlCn45m803Jy4z08eGV2YObje5S9vI5XIe/T2Gxya4Mtyl80lWza1ytkfnsT26gDqJlEfGubJohEO3F1qaW2T8nVDMxvAc8qubWDzCgeVBTj0y+ZfKFYSmlbMjJp/y+hZ0dcQsCrBnlo+NVluI20MmV+D3zlEar6u2uRmxSNnSuKuDlMJbTWmdhNNpZcTl1fBXfBGGfXSZNNiSCZ6WjHU3v2XfYXfpFW96+TfSK97cxkycOJHTp0+jq6tLWFgYo0ePvmH7p59+yksvvQTAO++8w5tvvtmp42/bto1Tp07x6quv4uio+oXs22+/5amnngJg0qRJnDhxQuV+V8WbFStWsHHjxk6dhzboiQFaEATSSxsITS/jdFo5UTlV2Jn05c5htvg5mBDkavaP+Mt0hdzKRg4llXAosZiU4nomDrYkxMOCaUOteuSlUipX8ODGKM5nV10TcProinlumsc1I09BELiYX8OuK8kO5oYGLPC3467hdtj1oCmfXCEQml7G7xG5hGdUMnWIFctHOzFKS6tw1ydUGfXVw8fOmPuDnbs0oesJSmolfHIklYOJxTw8zpVHQ7TrhwPKqpOXdyZQVt/CRwt8tBKFe5VjySU8uz2e5aOdeF7DShpQihCPboqhvkXKL/ePVPv3qGpsZf735yioblbbljTCaSA720kqup6dMQXsuVjAO3cMxc3CkHMZlXx0OIW0knpkcqFNJY6eWMRjE914dmpbs2FtIpHKmP7VGd6YPURtmtRVnvgjFvuB/XhlpupKlAvZVazerEx4ak8Iem//JVplCt6b561yu0IhsGpzDB8v8MVUjcC86Idwlo5yYt5w1cLAe/svIQjw5lzV1WrJhbW8fyCFPx8JUrm9sUWGz9tHOPfKpE61hfwYmsnZjAo2Pdj5FD1BEJj3fTjTh1rx2IT2vYM0IbeykdnfnOXbJcOZONhS5T75VU28tDOB+f62LBrRccVKR618oBSgVm2K6TAx7SrROVU8+Fs0y4IceWGap8rj1zZJGfmf4ypb5XREIvY8NgbfTgo3NU2trNmdSHRuNZ8t0q4p8fmsSt7YlwTA+/N8rrVr32o+2p+EpYkBD4zVvIqrurGV3yNy+S0iB2ujPjw5yZ2pQ7pvFJxf1cTmyFz+ii/CcoABi0c6MG+YXY8IAOml9eyIzmfPxSL0dUQsCLBnYYD9LV94q5NIOX6plO9OZZBV3qhyH7FI2Ta9+zYQbuQKgfiCGk6llnEytYzUknr87I2vRXkPsTXq0cW1nqJXvOnl30iveHObEhUVRWBgIACrVq3ihx9+aLOPQqHA29ublJQUBg4cSGlpKXp62m+NGTlyJNHR0YjFYsrKyjAza5vg8G8Ub26msUVGRGYl57MrOZxcQmltC4EupkqvHE8LBlka/k883AqqmzicVMKhpBLi82sY6WzKLB9rpg+11kqFx1UkUjlL1keSXFRLq1xALILIVyernDRLpHKOp5SyM6aAyoYWjPrqscDfnhne1j0qkOVWNrLlfB7bo/MJdjMjyNWMu7RgcAxXE6oq2XAmm7MZFdw1zI6Hx7t22Q9D28Tn1/Du/kvKSdyMwcwfbqfVknWFQuD3iBw+PZLGHcPsWDNrsNYMOjPKGnh0cwyWAwz4ZslwjQXIq4ao57Or2LhyZJsX5pqmVuavCye/qqnd6hixCC68NkXjz/30SCp/xRex57FgzA0NrqWXfXI4laSi2jYizrhB5l0SATrL+rBMDiWVsHv1mHbHrlNpZbyyK4HwVyarTAuRyRUMf+8Ymx8c1W4FxJ6LBWyKyGX3Y8FdPucXdsQz1t1crXjz9l/JWBkZsFqNCHIgoZj1YZlq28DCMyt4fns8EWsmd+q8ZnwVxsPjXFmgQZvQzZxIKeWlnQmEvTSx2xNamVzBizsTGNhPX62A1dwqZ8G6cAKcBqoV0m5GIlX+zJqZXowd1FaMDUsv59HNMXxwlzd3De/4OzicVMJz2+NYM8uL5e0YZ39z4jJrT2WobD3REYtwNuvH/ifHaWwyG55RwfqwLHTE8MlCP62ZElc0tPDhwVQOJxXz9JRBrAx20Vprblc4kljI4eRiPlkwDD299q+pguomfjqTzbaofPydTFg13o1xg8y79T4jCALnMirZGJ5DWHo5k70suW+0dlMgr1Lb1MpfV1qDU0vqmeFtzcIAe8a4md/SdKOrgs3BxGLC0itwszTE39GEHdEFbXwAbwfhprZJSmR2JUeSSjidXo5cIRDiYcGkwZaM97BQK6D/L9Er3vTyb+R/o2zg/yF79+699u+VK1eq3EcsFnPfffexZs0aqqurOX36NFOnTtX6uUyYMIHo6GgUCgXZ2dkqxZv/D/Q30GXKECumDLHi1VleyvSAtDJC08v5/FgaA/vpE+JhweTBlgS6mt0Sj5muYD+wHw+Nc+Whca6U1Eo4nFTM3wnFvP33JfwdTZjpbcNMb2tsumHg19Aio6immV/uH8HiHyPJKG9gtKuZ2mqHPno6zPG1ZY6vLaV1EvZeLOSH0Eze2JvETB9lbGegs6nW++GdzPrz6iwvnpvqwf6EIn6PyOWjqwbHo5265X+gTKgyZ7SbOeml9WwIy2LWN2cYP8icR8a7MdK5Z9vEOsLPwYSdj45mf0IxP53J4o/zubwy00trK8VisYj7g12Y7GXFK7sTmPZFGP+5y5tJHfhlaIK7pSF7Hw/m5Z0JzP32LN8v9We4BjG1+rpiPl/sx5fH0lmwLpwfl49g9JU44asR2zkVjR1G3hvoijmUWKzWxPdmnp/qSW5lE4/8Hn3NOHa0mxl7Hg8mKkcp4lzMq7lW6ROXX6PRcbvLvaOcWHsqk8isqmvfgyrGuZsjCHA2o5wQj7aVHLo6YsZ7WHAqraxd8WaorTEpxfXIFUKXJ1UVDS00tsrUbi+tk2A/UP3Y1VHS1MW8mk5HHqeW1JFT2ch07863ugmCwBfH0rWWCPfdlXj3v59ULU4JgsCa3Qn009fhjTmae2mdTisnraSelRsvsHFlIMHu/xVwrgo3/7nLR62odj2/R+Tw0aFUvrx7GNPbaQ9sbpWzPixLrWeIXCFQUN3MizuVyW7tjactMjmfHUljy/k8Xp3lxb2BDu2aEtc2SdkRk99hyp1CIbAzpoD/HLzEKFczjj0Xgq2WzG9rm6R8H5rBEBujDr2pbmaipxVHkkqJzKpknKfqMfdSUS3rw7I4mFjC1KFWbFsVhK+9SbfOuaFFxu7YAn4Lz6G6ScqSQAfevXOo1r6Tq8gVAuGZFeyILqC0TkKLTMHikQ7M8bW9pe9eqgSb2T7WvDrLC1cLQ2RyBXvjim4Qb64KN7e6VepqNflVs+GYvGqmeFniamHIj8sDGP4/kLyqKRKpnIt5NRy5kPVPn0ovvWidXvHmNuXMmTMA9O/fn4AA9caLISEh1/599uzZHhFvrjc01mYCw/8yIpEIF/P+uJi7cH+wCxKpnKgcpVfOnrgiHt0Si7+jybUEq6G2Rj1uVNgVrI37cH+w8ncoq5dwNLmUQ0nFbI7MxbifHrO8bZjpY63SG0UilZNb2UR2RQPZFU1cLqsnraSe/Kom6iTKydX2VaPZ+kgQy3++wCMhbhqdk5VRH1aFuPHIeFeSCuvYFVvA6s0x9DfQZb6/PQv87bReAt1HT4eFAQ4sDHAgPr+G3yNymfvtWYY7mmjF4NjDagCfLvLjheme/Houhwd/i8LNwpAnJrkz0dPylq4OXo9IJGKuny1Th1jx89lsHtgYxbhB5rwyc7DWvmMH035sfnAU26Pz+eVcNvsTinlz7hC1fiMAoenlhKaVq60cAKVPwHf3Dufns9ncu+E8r872Ytkoxw4FMZFIxHPTlH4/D2yM4sP5ygmnIMBkL0uqGlupbmpFLBKpTU1rlirYGpWvsXgjFov4bJEf926I5IUd8Xxzz38jxEc6m7Lj0TFczKvm0yNphGdWUi+RUVDVhH0PJ44YGuiyYrQT35/OaFe80dURszzIiT2xhSrFG1BGhm+KzOWZKeo9zVzN+6MQBLIrGrpszNlR2lRDi4wBfdS/2uRWNuJkpv57vZhXTZBr5xYojiSXsGyUU5cq9o4kl1DR0NJhbLsmxOQqY5x3rR6j1p/kl3M5RGRV8veTYzuVCrMntuCauLjy1yg2rhzJGHdzQtPLWb05hg/n+3QoMAiCwCdH0vjzQh6bHgzs0Dh9e3QesnZi4QFaZAqOJpfyW3gO9werNopOL63n6a1x6IjhryfGalT9+Pbfyey5WIhJPz0WBqj2t0oqrOX1vUlUNrbw9T3+hHhqp/2quVXOr+HZ/HA6Ez8HE+5oxwhcHfr6unha9+fM5fIbxBtBEIjIrOSHsCxkcgWuFv05+uz4bvvOZJY3sOV8LrtjC3E07cdjE5SeUdoOJMitbGRnTAG7YgpolQvM97fjiYlueFgbafVz2uN6waa6SUpTq/wGweZ6dHXEzPaxZmdMAQrhinCjrxRutGmOrY7mVjkRWRVXBJtyKhtbGOtuzh3DbPnynmFaT9n6p5BI5cTmVROZVcX5rEou5tdg0lcPb2P1Qn8vvfyv0ts2dZtiYWFBRUUFfn5+xMXFqd2vuroaU1PlC9CiRYvYvn271s/Fz8+PhIQEdHV1qaysxMio7UPyatuUi4sLhoaGZGZmIggCVlZWBAYGsmTJEu68884eqzS43UojC2uaCbsyAT2XUYG+rnJlOsTDgnGDzLVWqt1TVDa0cOSKkBORWckQmwHo6IgY2M+AqsZWcisbqW6SoisWoa8rRq4Q2qyOGuiKiX9rmlZe3lplCk6mlrErtoCqxhZ0RGIWBNgxy8emw1jgrlLV2MqO6wyOHxmvTJHShsFxvUTKtqh8tkXlI5HJeSDYhcUj/mturIm/RE9QVi/hi6Pp7LlYyIoxzjw+0V2rq5gltRJe25NIfEEt78/zZoaKSoXqxlZCPj1FvUTGlodGMca9Y7+c81mVPP7HRSZ6WvDund4at1CEpZfz8eEUZvnY8tgEN0Qi0bU42UOJxeyNK6SktgVdHVGb61skgnMvT+rUinJlQwvzvj/HnX52vDBdtafN+axK7v/1AtOGWPH1En+Nj91VqhpbCf7oZIer7uml9cz99ixRr09R2f5WXt/CqP8cJ+q1Ke2Ob3euPccDwc6driS4yuN/xOJnb3zNO0vV8R8Z56rWbHjxjxEsHuGgMgVJEAQC3j/OhvtGaJyWplAIjP34JO/N8+4whelm5AqBmV+HsSzIifs0FALV0dAiY9bXZ1gW5Kj2uwnPrODBjdFseXhUp6qLmlvl+L1z9AYxU19H6WH2zYnLGgk3rTIFXxxLY39CMb89ENhh1LhUrmD0hyeoaGjt8Px0xSIEAaJfn3KDGb8gCPwWnsPHh9NYGezMM1M8NBKszmdVsvSn88gUAgP66HL2pUk3JCzVS6R8cSydPy/k8dBYVx6f6K7xmNMeMrmC7dEFfH0iHSujPrw8Y/ANFU6dJbWwik8Pp/HWnd7YDOzPseQSvg/NpKC6mfuCnLhvjHO3PO/kCoGTqWX8HpHD+ewqZvvYsGK0E8M6WbnWEU2tMg4mlrAjOp+LeTVMHGzBogAHQjwtbllrWm3zfwWbM5f/W2Ez08caN4v2RZjwjAru3xiFTK6gv74uO1ePwdO654Sb/KomTqcpvWtqm6WUN7QwydOSiYMtCXI16/GEz1uBRConNreayCyllUFKST199XQIcjW79j9ns34UFhbeVnODXnrRBr3izW2IRCKhb1/lhGD27Nns37+/3f0NDQ1pbGwkKCiIiIgIrZ7LgQMHmDNnTofnoklUeHBwMNu2bcPOrvMv7QUFBe1uLy4uvuYRdLsN0FK5got5NYSmK1usqhulmBnqX6nKsWDYbV6qWtXYyuGkIl7fm9xhO8lVRMBMb2u+byeut6tUNrTwV7wyrSqjrIHpQ3u2v12uEAhLL2dnbD7HksuYOsSKZUFOWundl8oVHEoq4aczWejpiPG1N2aYgzHnMyt5Z57PP+aZcKmojg8OXiKluJ5npwxiSaCj1q5RQRDYF1fE238nE+xuzjt3DL1hAvH4lliOXSqlVa7AyawfJ54L0eizS+skfHI4leSiOn5YFqDxSvKloloe2BjNBE8L3pvn3eY7zyir51BiCbsvFpJb2YiejviakPPUJHeem9Y5Y+GMsnrmfx/OG3OGsGiE6hX9oppmZn9zhtdnD+mSh0pneffvSxTVNPPD8vbv17nfnmXpKEe1iUOLfwjnvjHOzPFVXynw6p5EDA10eXWWV5fO9dltcbhbGvL4RNWeNpM/P81bc4cyXo0J7aj/HGftvf6McG5b9ZFb2cjUL8JIfGeaxslD57MqeXRzDBdem9Lp+3VfXCEfH0rl1IsTup109MKOeIpqmtn84CiVVZ6FNc3M/fYsL073ZEkHiVE3cyixmGe3xyGRtq2CeXqye4fm2g0tMlZvjqGqsZVf7h+pkQC+92Ihz++IvxYPfhU9sQhdHTHNUjmm/fUZ5mBCoIspAU4DGXnd37SsXsKLOxLIKGvgi8V+jNKwmqpFJmfiZ6EU1TQDylbL+cPt+GiBL4IgsD+hmPf2X8LNwpD35nlrxcNMEAQOJZXw2ZE0AF6Y7slMb+tuP18EQWDdyQzOZFaQWd5IXz0xD493Y76/Xbe85K4mN26KzEUmF1gW5MjdIx3bjZrvyrnH5FazI7qAwtomKupbWRhgz7zhdrcsuUsp2JRwMLGEM5crcLc0ZLavDbN8bHDpRKXSVU8wQYBdPSDcSOUKYnKrr5kNZ1c0MsJ54DWzYff/ET/G9mhuvVpZU0lkViXx+bWY9tcnyNX0ilhjipNZ/za/5+22sNtLL9qgV7y5DSkvL8fSUlmafvfdd7N169Z297eysqKsrAxvb28SExO1dh5VVVX4+/uTm5uLjo4OUVFRDB8+XOW+Hh4eeHl5MW3aNLy9vTE2NqampoaIiAjWrVtHfn4+AF5eXkRERGBsbNypc+nMg+d2H6DL6iSczaggNL2csPRyZAqBcYPMCfGwYLyHRacSTm4lZfUS7vjuHKV1EjoaNfroifn6nuHt+hlog9SSOnbFFLDnYhG6YhF3+duxwN+uyy0ZHZFX2cSWC7lsj8rH3NCA5aOduGu4XberfwRBIDavmt/Dc4jOqWb1BBeWjXbV0ll3/ZxOpJTxn4MpDLYewMIR9kz0tNTaS2BZvYQ39yZzIaeKt+8YylxfG06klLF6S8w1s2ADXTFvzPFiWZCzRseUyhV8dCiV7dH5fLF4mMZx4sW1zaz8NQpLoz58v9RfbftLXmUTh5KK2RlTwOWyBnTEIuLenNrpv394RgUP/hbNr/ePIEhNEtfptDIe2xLL3seDe7y8vri2mZBPT3OwnThwgN/Cc9ifUMSOR1UnbX1+NI3cyia+WaL6OQHKiPKDicVseUh12lNHvLwzASvjPjw3VXV7VuAHx/lheYDKypKmVhlD3jxC1GtTVE40d8cWsCkylz2dMFReszsRHbEyWagzyOQKnvzzIiEeFh3Gb3fEgYRiXt2TyOFnxql8fjS3yrh7fSRDbY35cH7nzhPgod+iOZ5SqnKbvo6Y3x4IVNt2V1YnYeXGKEz767NuWYBGrWVSmZyhbx2hVS6gKxahEAT66ungbWfMKBdThjma4GNnolYsOJpcwm8RuZj20+P9u3w6VT34xbE0fgy90WdHVyziu3uHs+V8HinFdbw+ewh3DrPVylh4LqOCzZG5xORW8cwUTxaNsNeqaC8IAhdzqiiqb2Gmt023FjiSCmvZFJHLvvhChjmYsGK0s1bSqK6npFbCrlhlW1RFQwt3DrNjYYA9vvbGt0SAuLnCZuJgC3ztTTot2NzMqbQyHAb201pgQUVDC6Fp5ZxKLSP0cjkGumImeFoyabAlYweZay0c4J+iqVVGbG4NkVmVFNU083eCMpH0qlAT5GqGo2m/Dq+JXvGml38jveLNbUh+fv616O7ly5fz+++/t7u/o6Mj+fn5uLm5kZGRoZVzkMvlzJkzh8OHDwPw1ltv8fbbb6vdv6amBhMTE5Xb6uvrWbhwIUePHgXg2Wef5YsvvujU+fybxJvrkSsEkgprlR4f6eXE5dfgbmHILB9rRjibMsJ5YLdXZLVJeX0L89edo7hGojZGGZSrlQlaapnSBJlcwZnLFeyMLaCivgWJTMFCfzvm+tm2663SVSRSOQcSitkUmUt6aT13DbfjvtHO3V5R2xWdT2pJHa/NGaqlM+0+UrmCPy/k8eWxdIbYGvHarCEMsdWev8CBhGLe3JfECKeBRGRVXvNLukp/fR3CX5l8Q9tCR+xPKOKVXYncN9qJ5zSME6+TSHlscyxVja38urLj6oD0kjqe3R6Pvq5y8trZl+W9Fwv44EAqfz4SpPaF/rMjaRxKKuavJ8b2SKzu9by+V1kR88pM9RUx1Y2tjPrPCbUeGbF51az8NYrYN6aqnSTG5dUo/UQeaz/hqr3zHNBHj5dnqI4tH/LmYf56IlilCJVaUseC78NJeme6ys9+c28Shn10eUnNsW+mRSZn5PvH+XXlyA79W25mR3Q+357M4MTzId2arBfXNjPjqzN8ON+HWT5tW8UEQeD5HfFI5Qo+W+TX6edJU6sMv3eOtpu+pq8j5vcHA9t4BWWWN7DilwsEOpvy0QJfjVqWKhtaeHxLDNG5NUwabMkdw2zxszfBfmDfDq+XxhYZ7+2/xIHEYt6f593p1rzM8gamfxmm8tlmoCtmgb8dL8/00koraUJBDZ8cTiOhoIbVE9y5b7Qj/Q1uvwl3q0zBoaRifo/I5VJRHSuDnbljmC2Dtegx0yKTcyKljO3R+ZzLqCDI1YzFIxyYOsTqlrxDXPWwOZBQfEOFzWwfm257AWkLhULZznsytYyTaWUkFdbibWvEdG9rgt3M8bEzvi19FTWlsUVGTG4157MricyqIj6/BssBBgS5mTHGzZxAZ1McTDseA26mV7zp5d9Ir3hzG3I7VN6sWrWK9evXA8p2qX379qGj0/WHaG1tLW5ublRWVtK/f3+qqqrQ19d8Uv2/3DbVGWqbpIRdLudsRgWn08qoa5Yxxs2MEE9li5W2jXq7Qnl9CwvWhVNc26z2hd5ygAFLRzkxy8f6lsdg1jZJ2Z9YxK6YApIK65jsZckCf/se649PLKjl94gcLuRUYTWgD0uDHJnpbdMpM9CrfHjgEg6mfVk22oX8qiYcetiwtjPUNktZeyqD38JzuMPPlheme2rF/weUrXkL14WTVdHYZpuBrpi7Rzrw7p2aRRpfJaOsnlWbYrAy6qNxnLhUrmDN7kTOZVTw68qRHU5QJFI5j22JpbKhhd8fGNUpgQng48OpHEgoZs9jY1T6xMgVAk9vvcjAfvq8e+fQHl15zq5oZPpXYZx8PkSlQflVVm2KxtNqgMp2MblCYMT7x/hpxQi1YoZEqqyqCHtpYpfMMt/5OxkdkYjXVSQlyeQK3F87ROSayVgbt702T6SU8ntELr89EKjy2HO+PcOjIW7ttn1dz5HkEt4/cImwFyd26m8jlSuY9Plpnpns0a22OIVC4KVdCRjoivngLtUVNRvPZbP2dCb7nxzbpfv1QEIxz+9Q3TJ1PTcLODG51Tz4WxT3Bjry4nRPjb6fhIIaVm+Oxc/BmE8W+nXKAPpiXjXPbovDyqgPny/2a/caVoUgCMz/PpyEwhpUeSTr6Yh4a+4QjasA1ZFZ3sDnR9M4lVrO/cHOPDrerdPjRkdIpPJuix4ltRL+OJ/LHxfyMTTQYfloZxYG2GvVAy2psJadMQXkVDSSXdnIogB75vvbaz2ZShX1EiknU8v4K76IM+ldb4lSRX5VE6/tTcTDcgBDbI3wsjHCzcKw0+8E9RIpZy8rzYZPp5cjaZUzzsOciZ6WTPC01Gqb2q2msUVGdG4157Mqyatq4nBSCVZGfW6orNFEsO2IXvGml38jvWlTtyEDBvx3stvQ0NDh/o2NygmPoaF2yjHXrFlzTbgZO3YsO3bs6JZwA2BsbMw999zD2rVraWxsJDo6mjFjVJfeq+L/y4Br3E+PuX62zPWzRRAE0krrCU0r53BSCe/tv4SdSV9CPCyYNNiKkS4Du9W33lUsBhiw+7ExLFgXTlFNWwGnj66YO4fZklJcx/enM3Aw7ccsb2tm+tgw2HpAj5c+G/fTY+koJ5aOciKzvIHdsQW8uS+JVrmCO/zsWBhgxxDbzrXttYePvTGfLvKjpqmVnTEFfHX8Mu/tv8TdIx1YEuio8SSiuUVGcW0TdwyzQSKVs3pzDOYDDHhyknunV/V7AuO+erw6y4vlQU58fDiViZ+d5uFxrqwKce32dRhfUEN+dZPKbS0yBVvO53HfaOdOlZy7Ww5g3xNjr8WJr13q36FJq56OmE8X+vLtyQwWrYvgpxUj2vXK6KOnw7pl/jy+5SJLf45k0wOjbjBM7YgXp3mSV9nEI5ti2PLQqDYTLh2xiDfnDmH2N2fxsB7Aci0kEqnDxbw/U4dYsSEsi3faEcoW+Nvzzt+XeGaKR5uVXh2xiPEeFpxOK1d7zfbR08HdwpDkwtouiTcDDPRokclVbmtskeNjZ4ShgernVWZ5A/3VbGtqlZFSXN8pI999cYXc6WfX6TFtR3QBejpijWK12+Ons1lcyK7i4NPjVG6PzKrk48NpbHowsMtC667Ygg6FGwCFIPDqnkROPj+BI8klPLstjjUzB2ucyLY9Op+39iXz9JRBrBrvqvF3KpMrWHsqk3WhGTwzxYOHx7l2qTVoZ0wBycV1KoUbAKlc4IMDqczwtumS50pxbTNfH7/M7ouFLAqw5/SLE7Qmfl+ltknK7xE5/Bqew6/3j8TPwaRTPy8IAheyq/g9Ipdjl0oZN8iczxb5Mn6QhdaqOqoaW9kXV8j2aKVoM9vXhtUT3Ah06b6HXEfUS6ScSCljf0IxYenluFkactdwO16fPaTbgs316IhFhKVXcPZyBX30dGiVKVAIAnYD++JrZ4KvvTFeNkYMthmA5YD/XgOCIJBZ3sip1DJOpZVRVi8BREwabMnX9wxjpLPpP+aD110aWmRE51QRmVVFZFYlSYW12Jj0YZSLGdOHWPPyjMG31WJVL73czvSKN7chffr0wdzcnIqKig4rTqqrq6+JN1fV5e7w8ccf89FHHwHg7+/P/v37r5knd5chQ/67UlpYWKiVY6qipqmVf4PUIxKJGGxtxGBrI1aFuNHYIiMis5Kwy+X8HpHNw79HE+hiqjQ+9rRg0C00pTM3NGD3aqWAU3iTgCMXBJ6b6klffR0aW2ScSivjUGIJ878Px9q4DzO9rZnpbY23Xc/3sLtZGPLi9ME8P9WTiKxKdsUU8MHBFCoblOaHdw6z09rqlUk/fR4a58oDwS6EZ1ayKTKHiZ+dJsTDgmVBTh2+AJ9MLUahgKF2ysnjbw8E8vPZbFb8EoW3nRFPTxpEkJvZP2486GDaj+/u9Sc2r5oPDqSwIzqfZ6d6MN/fvkuTpjqJlOe2xbXblgECb+xN4s9HOueTcn2c+GdH0pjhbc3yIKd2v0ORSMRTkwfhZNZPoxVgA10dvl/qz1N/xvLGviTeuWOoxmlyYrGIzxf7sWRDJC/tTODre4a1OTfLAX34dslwVv4axTB7E3zstSc83szqEDcW/hDOk5MHqZ2gTvC05JXdiURmVapMApvoaclPZ7N4vh0j56G2RiQX1TGtC55YAgJ1EqnKbXUSKclFdWpbzHIqm9RWLyYU1GJuqI+NiooddZ91PKWMg0+pj0ZXhUQq59uTl1kzy6tb/iPJRbV8eewyWx4epbJCpaimmce3xPLabC+V5sya0Ngi48zlcrXb++rp0CKTE+hiynx/e6Zd8ZiKyKzki8XDVKbJ3UyrTMFHh1IIu1zBhvtGMHaQ5ulKuZWNPLMtjnqJjJ2PjsHbrmv3RmVDC2/9ldxuBD2AXKHg3b8vtevpdDPVja18fzqD02nlDLYx4sgz47UqFACU1jXz85lstpzPw9vOmC/vHoZvF8eJ705l4GVjxPHnQnA0085kWiZXEHa5nB3RBZxIKcPPwZiVY5yZ5WvTqeqqrtDQIuNEirIl6nR6Oa7m/ZntY8OaWYM7TDzrKrYmfXE07UdeVRNNrf8VmvOrmsmvauZ4SilikYhmqRxDAx0G9NFDLAKxSERpfQujXc2YPtSaSYMt/2cFjXqJlOjcaqKyqziXUUFSUR12Jn0Z5WLK8iAnRrmadro6rpdeelHSK97cpnh5eXHmzBkyMjKQyWTo6qr+U6Wmpt7wM93h+++/55VXXrl2rCNHjnTaWLg9blWH3syvzzDYLZ+RLqaMdFYmUNiZdL/88p+mv4EuU4ZYMWWIFYIgkFPZRGiaMsHq82NpDOz33wSrMe7mWi1vVoWZoQG7VAg4IR6W12JT+xvoMsfXljm+tjS3yglNL+dQUjHv7L9ESa2EWT42zPC2Zpi9SY/2a4vFIoLdzQl2N6ehRcahxGJ2xRbw8eFUxg2yYIG/PZO9LLXSXy8Wixg7yJyxg8wpqmlm64U8XtyZgKt5f8Z7WLBohP0Nq21XOZFawWj3/1Z5mBka8NKMwawa78bG8Bz+c0h5r6+e4Mb0odY9kqzVGfwdB7Lz0dEcTynlvf0p/Hw2m1dnealN+VHHW/uSaWxVXUlxFbkConOrOJVaxsTBlp06vkgk4qFxrvjam/D4H7HE5lbzn/k+aquFvjyWjlyh4IXpmvmegNLj6dslw3lmezz3bjjPlodHabw630dPhw33jWDe2nN8eSxdZTtSkKsZT05257E/Ytj/xDitt1lcxdvOmCBXM349l82Lan5/fV0xy4Oc2BdXpFK8Ge9hwfM74imrk2CpprJgiK0RkVlVXTpHfR0xrTLVz5KGFhmGBrpqx/rcykbmqmmJis2rxt9xoMbPieOXSpnpbd1pc/StF/Iw6qPHHBX+NJrS3Crn6a1xrApxVVkpdLVyb+oQK5aO6roZ8snUsjbm9H31dGiVKxh1RbCZ6mXV5np8+w7NPLtK6ySs3hxDq1zBr/eP1HiiKggCO6IL2BVbgI+tEa/OHtKtsfutv5JvMChWR6tc4GBiMcuCnAh0aV8Qa2yR8fPZbDaEZTHcaSBf3T2MoV0Ul9SRXdHI+rAsdscWcNdwO35/cFS7EffhGeUo5ArGeqo2cheJRGx6cJTWzi+zvIEd0QWkldSRUlzPggA7XpqhffHqZhpbZJxMLeNcRgV7LhbibNaf2b42vDRjsNYMgztiprc1v5zNRqrCP+n6a62hRU5Di5x+ejp8s2QYwe4WWomdv9XUS6RE5/w3DSqpqA77gX0JcjFjZbAzI13MulRp2UsvvbSlV7y5TRk7dixnzpyhsbGRmJgYRo1S/UANDQ299u/gYM0TMm5m06ZNPPHEEwC4urpy/PhxzM01XwHThEuXLl37t62tZp4CXeHgU2MpkvUnKruKjeG5vLgjAYsBBoxwNiXI1RR/x4F4Wg34nzZ3E4lEuJj3x8XchfuDXZBI5UTlVBGaVs4Xx9L5/nQmffTEV8QcS4baGvXI72tmaMDux4JZsC6cguomdMQi7lLTCtBXX4cZ3tbM8LZGIpVz9nIFB5OKWfHLBQwNdJnhbc1MbxsCnAb2qDBhaKDLohEOLBrhQH5VE3svFvLpkVTW7E5grp8tC/ztGe5oohWxz9akL89N8+SJie4cTy3jzwt5fH38MpO9LLl3lCPBbuaIxSKaW6RUNrQwflBb4cO4nx5PTxnEw+Nd2Hohn/f3X+LTI2k8PM6V+f52t8wUWhUikYipQ6wZ72HBpohcnvgjluGOA3l1lpdG5s0RmZXsuahZFZ5ULvDa3kRCX5zYpdLxQBdTDjw1lif+uMhda8NZt8wf15tWXg8nFbP2lNL0/b4xzipFNnXo6erw9d3DeH5HPPesj+SPh0apFS9uxtzQgF/vH8n8deE4mfVX6YPy6Hg3YnKqeWFnPOuXB/SYGP3YBHce3BjFqhA3tSbMU4dYsfjHCN6cO6RNlYtpf3187Y05nV7OYjVR6ENtjfnlbHaXzk9PV4xUTW9LvUTWbvJXToX6ypuLeTWMdNa8ZWpnTAGTOikkNrfKWXs6k/fuHNqt8fjDQykY9dHlCRVx6YKgrFITiUS8002fpM+OpCFTKBOfBJQi4gJ/OyZ7WXV7cSAqp4rHtsQS4mHB+/O8NR7HqhpbWbM7gdi8Gj5b5EdIJ8Xim9kZnc/+hGKV2/R0ROiKxYhESn+hVrkCmUJgX1yhWvGmRSbnj/N5rD2VgaNpPzasGNHGyLm7JBTU8ENoJsdTypjja8NfT4zVaLzNKq8nr7xZrXijDeolUg4kFLM9Op+kojqmDrFiZbAzwe4WPfpcb2qVcSq1nAOJRZxMVSY7zfKxZv8TYxmk5WhuTZgyxIpfznU8xumKRYwbZM4PywNuq3CKjqiTSInOqSKluJ6jySUkFdXhMLAvo1zMuD/YmVEuZrfEu6iXXv4/0mtYfJty4cKFa4LNqlWr+OGHH9rso1Ao8Pb2JiUlBRMTE8rKytDT6/wL1e7du1m8eDFyuRx7e3vOnDmDs7Nzd3+FG7jesLhfv35UVVVhYKA9s7X2TMmaWmXE5dUQlVNNXlUjh5JK0BGLGOE0kBHOpgS6mOJjZ/yPToK1TUF1E2cuVxCaVs65jAr0dcWMv1KVM26QucZtHZpS3djKgnXh5Fc3Ef/WtE55oLTKFIRnVnAosYSjl0rQ1REzfagVM71tGOViqtUYUnVcjereGVNIYXUTBdXNLAiwZ95wO62vFuVWNrI1Kp8d0fl42RjhbmmIvlhEdmUjPywb0eGkTipX8FdcET+GZVLdJOWBYBeWBjneFtGgNU2tfHMigy3nc5nvb8ezUz3aFUCSi2r5/lQmuZWNFNVKqG5qBQEM9MSIRSKkckWbdqr7Rjt12rz4eqRyBZ8eSePP83l8usjvWmtHVnkDM78+Q4tMgb6umPtGO/H67LamuB0hVwi8uDOeuLwa/ng4SKVxrjrOXq7g48MpvDZrCEEqopdrmlqZ/c1ZVoxx4pHxbp0+N01ZuC6cSV6WPDahrTgAyvtl5tdneHicq0qh6ZsTl0krqWPt0gCVP1/bLMXvnaPEvjEV0054BAH8fDabqOwqflje9tgnU0v55HAah58Z32Zbi0zO4DcOE/7KpDZx2oIgMPKD4/ywLECjFqOSWgljPz7JuVcmdcq3ZH1oJvvii9j/5NguiyqnUst48s+LHHxqnMq2lpTiOlb+GsXex4M7de3dzNHkEh7ZFIO9SV+en+7BZC8rrYwxgiDwe0QuHx1K5dVZg1nWQRvj9YSml/PCjnj8HU34cL5vp6+d61EoBLZH57NmdyIC0N9AB/P+Bpga6mM5wAAb4z5I5QIWAwwYbG2EuaE+pv31MetvgFHfttVdcoXAnouFfHksHUMDXV6Y7skUL0utiayCIHAuo5J1oRnE5tZwT6ADD41z7dTzKamgms+PpPHZ3cMwM9Se345CIRCZXcnO6AIOJZXgZtmfxSMcuKOH0h6v0tQiIzS9nP2JxZxMKcPGpM+VSl8bPG5xUMLNlNdLCP7oFK3qTJRQVjHO9rHh04W+t+Q9pzvUNkuveNZUcj67iqTCWhxN+zF1iDVDbY0Y5WraZly9Heg1LO7l30iveHMbM378eM6cOYOuri5hYWGMHj36hu2ffvopL730EqA6ynvjxo2sXLlS7XaAo0ePMnfuXFpbW7G0tCQsLAxPT/VeBao4fPgwISEhar1xbo4Kf/LJJ/nmm2869Rkd0ZkBWiZXkFJcz4WcKqJzqojKqaKuWYafg7GyOsfFlGGOA3u87ehWIZUruJhXQ2i6ssXqUlEd3rbGTPKyZKy7OcMcTLTy4lDT1EpKcT2jVUw6NUUmV3A+u4qw9HJ2xRaiEASmDbFihrc1Y9zMu5Tg1FkkUjnHLpWyK7aAs5crCHQxZYG/PTO8rbUa13xVtDp2qRTjvnqMH2ShcsKuDoVC4FRaGetOZ5JWUs8j4125e6SDxtUePUlORSMfHUrlzOVynpvmwb2BThqVgsvkCkrrWyioaqKwppnC6mZyKhvJrmgkv6qJ8oZWAN6b583SQMduVS8cSizmpZ0J3BvkyOMT3Jj77Tnyq5u4WuWuryvmwquTuzT5kCsE1uxO4Hx2FX8+HNSpFcitF/L46HAqu1ePaVMZBBCXX8OS9ZFsejCwy14mHXEqtYwXd8Zz9uVJakXtDWFZnEor44+H2/oQJRTU8MDGaCLWTFJbJTXuk5P85y4fxqmoNmuPTZG5nE4t4+f7R7bZti+ukE0Ruexc3dYMP6OsgdnfnCHl3Rltrpu8yiYmf3GaxLenayTibwjL4nR6GVse0tyDqbFFxvzvw1kzazATPDtXsXOVioYWZnwVxiszvVjYTkpVU6usWybiR5NLeHprHF/erZlvjaZIpHJe3Z3ImYwKfljmr7ERu0Qq58ODKeyKLeTNuUNYFGDfLVEkuaiW1/cmUVbXwptzhzBtiFWb4xXXNjP581BsjPtw7NkQtWONIAgcvVTKX/FFxOfX8NxUD+4cZqe1KhO5QuBQUjG7Ywu5mFfNijHOrBjt3Clj9KtI5Qq+OppKcZ2EZyYPwtG8ewJHflUTu2MLSSis4WJeDfOG2bFohD1eNtqLEb8ZiVTO6bRyDiQWU1zbTGVDK3N8bZjta4OnVc8HIqhDEAQuFddxKrWMk6llxBfUYmGoT0ldi8r99XXELAty5I05Q27Llv7aZilR2VUkFNZwMrWMS0V1OJv1Z9SVJKhRLmbdEodvFb3iTS//RnrFm9uYixcvEhwcTHNzM4aGhrz66qtMnDiR5uZmtm7dei0RysPDg+jo6BtSqqBj8SYyMpLJkyfT1NSEnp4eGzduxNfXt91zsre3x8TE5Ib/NmHCBBITE5k/fz5jx47Fzc0NQ0NDampqiIiIYN26deTn5wPg6elJeHg4pqbanXR0Z4C+6h8TlVNFVHYVl8saiC+owdNqACOdTRlxxTfn31ICWl7fQnimMn4yLL0cmUJg3CBzQjwsGO9hodXVk5qmVoz76nXp5USuEIjOqeJQUgmHk0poapUxZYgVs7xtGDvI/JZUSpXVSdgbV8iumELyq5uY4W3NQn97glzNtNKG1iKVszeukLuG23dLmIrJqWZdaAZhlyu4a5gdD493vWW9/e0RlVPFhjNZJBXU8tKMwdzhZ9ut702hEDidVsob+5SR6p8s8OuWqWZmeQOrfo9GIlNQVieh9boqHwNdMavGu6r0oNH0XF/bm8TZjHL+fDioU+aMHx5K4UhSCbsfC1ZZXbDlfC47ovP5ecVIrVfRgXJMfPKPiwS7m7NEjWdKWb2E4I9OcvrFtpHfCoVA4H+Os/Zef7VpXas3x+DnYMKjIZ2rINoWlcf+hGKV3hybI3M5kVLKryvbRoGfSCnl48OpHH02pM22AwlFHL9Uxpf3DNPoHGZ/c4YVY5zVtoWpYu2pDI5dKmXPY2O6NB4KgsBre5Jolcv5dKFfj034jiSX8MzWOL6+Z1iXDKXVkV/VxJrdiUikcr5f6q+xyJxYUMOz2+Mx6qPLl3cPU9v2pgl1za18cewyW6PyeHCsC09MHKRSVFYoBBb+EE5CQS06YhGfLfJjrl/bVu/wzAo+OZxGQXUzT0925+6RjlpbYJBI5eyMKWDDmSxkcoEnJ7lzxzDbbif7KRQK3tuXiLlRHx6f3PmxrblVzuHkYnZEFxCVU0WIhwV3j3QgxMOyxxZXJFI5YelKweb4pVLMBxgwx9eGWd42DLE1+sfEj8YWGWczKjidVsap1HLqJVLGDjJn0mBllHdEZiVrdifSLL3R001PR8TTkwfx+ET320a4qW2Scj5bWVUTmVVJSnEdzub9meVtwyArQ4JczbSejnYr6BVvevk30ut5cxszfPhwtm3bxrJly6irq+PVV19ts4+HhwcHDhxoI9xowuHDh2lqUsbzSqVSli5d2uHP/Prrr9x///1t/ntVVRU//fQTP/30k9qfHT9+PH/88YfWhZvu8l//mP7XXsbL6iXE5FQTlVPNT2eyeXZbHDbGfRnpPJBgd3P8HExwtzD8n/TNsRhgwJ3D7LhzmB1yhUBSYS2h6eVsjy7g1T1JuFsYEuJpweTBlgxzNNGoD1sQBPKrmkkuqiWxsJaY3GpSiuuok8jYuHJkl1aadcQiRrmaMcrVjDfnDCGuoIZDicW8/Xcy1Y2t3OVvR7CbORM8LXvM4M/SqA+PjHfj4XGuJBfVsSu2gPVnsnhxZwLzhtsy39++W4kV5zMqCM8oZ1E7q+iaEOA8kJ+cR5JRVs/6sCxmfXOGEA8LHg1x/Udjxkc6mxLgOJC/4ov4+HAqv4bn8EY30m/EYhGTvKwJdDXno0MpzPg6jJeme3LfaOcu3YtuFoYsGuHAx4dTudlXskWm4Kez2TwS4talRBSxWMQH87x5669k3vn7Em/MHqKx0PTy9MHkVTaxalM0mx8a1eYevDfQkfCMSp7ZFsfGlYFa95IQiURM87bm40OpLBxhr7J6xnJAH8YNsmBPbAFPTBp0wzaxWESIhyWn0srVijcjnU1JL63v9Lnp6YjVpgLVS2QYqmntyW0naepCdpXGJtAZZfVklDV0qiKlTiJlfVgW3907vMuTtS3n8ziZWsbhZ8b1nHCTVMKz2+P4Zslwpg7Rni/KmcvlPPnnRZYGOvL0FA+NJvlyhcCPYZmcTCnjDj9bHpvg1uUKUUEQlGPQoVSGOw5k/5Pj2hW314dlklxUh0whIFMIfHAghRne1tfug4SCGj49kkZcfg2PhrixMti526LKVWqbpGw+n8uv57IxNzTgmSmDmONrq7WIaLFYzAxvG7ZcyEEqlaGn1/F5/7etuID98cVYG/dh0Qh7vrpnWKd8wTpDi0xOeEYlf8UXcexSKab99Znta8O2VaMZ+g8KNtkVyijvM5fLuZBdhZVRHyZ4WvLZIj9Gugy8YawO8bBAIrtRuNEVi3hrzlCWjXa61ad+AzVNrUTlVBGReUWsKanD1bw/Qa5mPBrixigX09uiireXXnppS694c5szd+5cEhIS+Prrrzlw4AAFBQXo6+vj7u7OokWLeOKJJ+jX75+N2/vss884ceIEERERpKWlUVFRQU1NDf369cPW1pZRo0axZMkSpk2bdtusMnSE5YA+zPSxYeaVRJCGFqVvzoWcKqJzq3lzXzIGeuJrvjkjnQfiY2dyS9p6tImOWISfgwl+DiY8NXkQtU1SzmZUEJpexidH0rhUVMcYNzNCPJV+OU5m/ZHJFWSUN5BcWHdFqFFWK7XKFPTR06FVpjR1vMpQ2+4nbIjFIvwdB+J/xQw3sbCWQ4nFfHIkjee2xzPB04KZPjZMGmzZI9GjIpEIbztjvO2MkcoVhKaVs/tiATO/OsMQWyMWBNgz19em0y02l0rr8bQ0RCzWznXjbjmATxb68fw0T345l839v0ThaT2AVSFuTPK0QOcf6KsXi0XMG27H9KHW/HQmixW/XGDCYEtemTG4yzGohga6vD/Ph1neNrz99yXOZlTw+uwhOHcyxSQ2r5pPj6S1EW6uolAIbI7I5dEJXfOXEYtFvHPHEN4/kMLd6yP48+Egjc5RLBbxxeJh3LMhkld2JfLF4hsrLUQiER8t8OGO787x7cnLPDOlc3HVmjDL25rPj6bxd3wR8/1Vi4sL/O357GiayhXkCZ4WrD2VwSszVadWuZj3Z/P53E6fl347hsUNLVIG9FF9/8/0sSZYRToWQGxeDQ+Pd9Xo8/deLGJKJ/1ffjmbjafVAMaq+fyOyChr4D8HU/hpxYge8xA5nFTMNycy+PqeYVoTbgRBYF1oJt+dzODdO73bbfW6nvyqJp7fHk9FQwtf3j0MPweTLp9DRlk9b+xNJqO8gddne3GHn2277yFJhbV8djT9hmdYdVMr26LyCHI15/OjaZxOK2fFGGe+XTJca3+P4lpl3PefF5Rx358u8mOCh0WPvDP5O5uy9UIesblVjHLveGHljX1J/BVXxB3DbNn00Cj87I175LxaZQrOZpSzP6GYY8mljHAeiIfVAP58OAhvu39GsGmRybmQXcWp1HJOpZVRWN3MKFdTJnpa8ubcIbiYqxcBB/bXx9NqAKklSpFaVyziy7v9mOunOtShJ6lubL1WVXM+u4rUkjo8LA0JdDHjsYluBLqY9pgQ10svvWiX3rapXv4V3OrSSKlcQXJR3TXPnOicahpaZPg5mFyLJ/d3GnhbmMh2FUEQSCutJzStnND0cqJyqlAIAnIFiEVgoKtDi0yuduIL4Gren5MvTOjxczyUWMKhpGJyKpsYP8iCmd7WTPay7FGzRFCuXu1PUMaOJxfWMWmwJQsC7AnxsOhQyBMEgWe3XWTGUCtm+PTMy1ydRMqf5/PYH19Ei1zBQ2NduXO47T+aalFaJ+GzI2n8nVDEijHOPD7BHaMO/KUEQWBHTAGzfWza+A41tkj59Eg626PzeW6qByuDXTSqRKlsaGHql2FUNba2u59RH10uvDalW216giDw4aFU9sUV8ufDQSq9bFRRVi/hrrXhLBphr1KgSSmuY8G6cNYvH8HYQdpNBwT480Iev5zN5sgz41VWNkmkcgI/OM4v949ghPONFTa1TVL83z/GmZcmqmw5LauTMOrDEyS9Pb1TXlInU0rZG1fIN0v822z75HAqffR0eGryIBU/qZrmVjk+bx/h1AsTOhQTBUFg3CeneHPOEI1bimqaWhn38akupw61yhTMX3eOYDdz1szy6vTPa8KhxGKe2x7Pt0uGM0VLwk1Di4wXd8STUFDLj8sD8NYgJlsQlKa/b+1L5o5htrw226vLFS1NrTK+OZHBxvBs7g104tmpg9pNIgPltTDli1CKapvbRKTr64jQ1xFx53B7npo8SGstJJdL6/kxLIuimmYG9NHl0RA3hquIf9c2nx9Opo+uDo9PUS2uXk9JrQSTfno90qrcKlNwLrOCAwnFHE0uwdBAl9m+Nsz2te0xkagjSmolRGZVcDCxhHMZFQzoo8fEwZZM9LQg2N28U+PVtycv8+WxdHTFYtbfF9Blv6vOUtXYSmxuNWczKojMqiSttJ5BloaMcjEjyNWMQBdTLAZov+X2dqO3baqXfyO9lTe99NIF9HTEDHMwYZiDCQ+Nc0UQBLIqGonOqSKpqI63/komv6qJwdZGjHS+Wp1j+j9h8HYVkUjEYGsjBlsbsSrEjcYWGc9uu8jRS2UoBNr0cd+Mno6I6Vr0TOjoHJ+d6kFGWQOHk4r55Vw2v0XkMLCfPjO9rZk21LpbySTqMOmnz7IgJ5YFOZFV3sCei4VsjcrjxZ3xzPKxYd4wO0Y4DVQ58U0uqKaspplgt+5F3baHUR89VoW4cX+wM/viilgflsVnR9N4YKwL9476ZxKqrIz68OkiP1aMcebH0EwmfX6a56Z6cvdIB7Wiy5HkUl7amcDFvGo+nH+jL1d/Az3evmMoM7yteXlXAoeSSvhkoW+77WxyhcAjm2Kol0g7PN9WmYLtUfncN8a5U7/n9YhEItbMHIyOWMTd6yP58+FRuFt23OpqOaAPv9w/koXrwnE268+84TeKfF42Rrx9x1Ce3nqRA0+N0/r4Mt/fjq+Op3M8pVSlWNFHT4f7RjuxN66ojXhj3E8Pf0cTQtPLWRLY1jfH0qgPZv0NSC2p61Rrn0gkIq2kQeW2kloJrhadq75KLKxlYH997Ad27PUVm1eNm3n/Tk3ANpzJwtfBuMtx0V8cS0ehgOemab+6Cv4r3Hx373Ame2lHuMksb2DVphisjfrw95NjNRp7a5paeW1PEpFZlXx1z7Aun4sgCBxJLuW9/ZewNu7D7tXBDLHVzED3rb+SqWhoaSPcAMgUAveNdub1OZ1PoFNFVE4VP4ZmEna5gvnD7Xj3zqEajQnawsfOhMNJxSgUig4rP7U9rkjlCiIyKzlzWdmu3U9fh1k+Nmx8IJDhDia3XLCRKwTi8muumQ2nldYzwcMCf6eBPDPFAy+brhshz/S2ZlNELt8v9e8xg3lQLkacz67ifFYlkVlVpJfVM22IFdZGfXhq8iACXUwx7wF/tNuZmqZWzmdX/tOn0UsvWqe38qaXfwW3o7peVichKqdaWZmTW8WlojrsBvZlpJMpYweZ42NnjLul4f9MK9lVDiQU8cy2uDYRzjejrytm84OjCHT5ZzxXcisaOZxcwqGkEpIKawl0MWWmtzXTh1r3aC+3QiEQk1fNvrhCDiQU009fl7l+tswbbstg6/9OIjaezSS/upk35nY99ror53YytYwfwzJJKa5n6ShHVga7/GOi4tWklv8cTKGvng5vzhnCmJtaS1pkcsZ9fIqy+hZ0xSJ+fzCQMW6qq0yaWmV8diSdPy/k8dxUDx4Yq7oKJ7moljnfnL1WHdWixkPlKmaG+kSumdxt3wlBEPjyWDp/XMhjy0NBeFprNlk7c7mcl3cl8NXdw1XeTy/siCe3spE/Hg7SmjfGVTaEZbE/sZi9aox2Y/OqWfHLBaJUVCetPZVBfH4N6+8bofLYK365wKTBlqzohDB2LqOCN/Ymqazoe+i3aMa6m3F/sIvGx/sxNJOY3Gq153g9r+9NRK6AD+f7aHTsyoYWxn9yit8fHEWAU+erKSIyK3nwtyj+eiK4Ryb2BxOLeV7Lws2xSyU8ty2epUFOvDjdU6MquLOXK3h+RxzetsZ8tMC3yxUBuZWN/HQmiwOJJbwyczAL/e019sI6dqmUx7bEtPtc66unQ+SayRr7I92MQiFwPKWUH8OySC+pZ2mQEw8EO/8j3iINjS28uDueVeNcGObccwsIV5HJFURmVXEgsYjDSSXo64pZGuhI8CBzhjuoXuDoSaobWwi7XMGpVGUKp4DSo2bSYEvGD7LoUprXraSioYULV9qgIrMquVzWgKfVgCtJUKYEupj2iJn97UpDi4ykwloSC2qJL6ghsbCW3MomLMUNRH14D3D7zA166aW79Io3vfwruB3Fm5upl0i5mFdDdE4VOZWNHL1USl89HQKcTAl0UVbneNsa/0/45oRnVLByYxStMgXqBhCxCJ6ePIhJg60Yamv0j5o7F9U0czhJ2VoVm1eDv6MJdw23I8TTsk1SjjZplSk4c7mcvXFFHLtUgrNZf+4absdYd3N+OHWZ0W5m3Dta84lmvUTKuYxKpnhZdjvePSa3ih9DszidXs7iAHtWjHFmkNWtW/m9nhaZnN/Cc/j2RAZBbma8OssLlyveMN+fzuDr45evCSwWhgacfnFCu6Xr0TlVvLgzAZN+eny60FflxLe2SUrSFYPt6JwqEgpqKatvoY+uGIEbBR0R8P5d3iwdpR2Tya+PX+a3iBy2PDRK41jdzZG5fH40jT2PBbfxzWlulXPX9+eYNNiSl2Z03AbRGRpaZAR/dJJ1S/3bCGugFKQmfx7Ks1M92iTyJBfVsviHCGLfnKqyVe+Tw6lUNLTwyUI/jc/nQnYVz26L49wrk9psu2d9BIsCHFjQCQPwVZuiGe44sMPUK6lcQeAHx/lhWYBaE+ab+e7kZWJyq1WmX3VEbZOUmV+HsXqCG8tHO3f65zviQEIxL+yIZ+3S4Uwa3H3hRq5QCpOh6eWsnuCGlZEBBro67bZLSaRyPjmcRnxBDQv87VkS6NClxQyJVM4PoZn8GJrFohH2PDfVo1Mts2V1EiZ9HkpDi6zd/Qx0xSwPcup09U2LTM7hpBK+PZlBvUTKA8HKyseO2rh6mg8PJOJo2p+lozXze+osMrmCC9lV7E8s5nBSCTpiEbN9lLHeAY63VrC52mJ9MrWMU6ll6IpF1DTLmDTYgomelgx3HKh143dtUl7fokyDylIKNhnlDUwbYoWNcd9rbVA9UV18OyKRykkuqiOxoIaEglrSSupJLa3HwtAAH3tj/OyN8bE3wdfOmMbqstt+btBLL52lV7zp5V/B/4J4czOtMgVJRbVXfHOqic6polkqZ5iDCeMGWeBjZ8xwR5N//AVPHUmFtdy7IZLGFhmqFisHWw/Axbw/Zy9XoK8rVsaRe1owbpDFP1q+W1Yn4cilUuLza9h7sZChdsbM9LZmprd1t2JoO6KxRcbRSyVczKvhcmkDgqDgu3v9Me+ESWBiQS2Pbo5BrhBYEujIkkCHbq/aZpY3sDumgJ/OZjPW3ZxVIW6MdB74j1SEVTS08OWxdHbGFLA8yIl7Rzky8+szNwgp+rpi5g+346MFvu0cSfmC9+WxdA4llbAk0JGHx7l0KHjVNktJLqolqbCW6Jxq4gtqKK1rAZRiZOSayVpbJV97KoOIzApememlkR8IwPv7L3EytYzdj41pMzlVxp7H8PLMwVpNCgL48lg6MbnVbH6obTw3KH+XC9lV/PbAjSKFIAjc/2sUD49zYeygtqv7BxKK+f50BgeeGqfxucTl1/DI79FceG1Km22zvznD05MHaexHIwgCgf85wdp7/TusEDyRUsobe5M4+/IkjSadZfUSQj45zbZVQfjam2h0Ptef1zt/X6KqoZWvlwzT+r34d3whL+1M5Pul/kwc3H0PjpqmVp7eGkd+VRM/Lg/AfmA/Rn94AkRw6vkJKqsYLhXV8cy2i/TV1+XLxX4a+0DdzKnUMt76Kxnjvnq8P8+70+bGCoXA3esjiM6tVtkudTO6YhFnX56kUbXiVc+xX85l42jaj0UBDv+459j17IrOJTyjnE8WDUdHRzvnJFcIXMhWVtgkFNRSVCNhlo81s31sGOFseksFkuZWOecyKjiZVsbp1DKqm6QEu1+N8rZQ6cV1u1BWL7musqaKzPIGBlsbEeRqqhRrnE1v++ogbdAqU3C5tJ74gloSCmqIL6glvbQe4756+Nob42tnjK+9CT52RlgZt/17/i/ODXrppSN6xZte/hX8GwZohUIgq6KBC9nV5FQ2ciipmMLqZrxsjBh5xTNnpPPA2yq+MbeykcU/RlDZ0HpDOkdfPR3enDuEJYGOSOUK4vJrrhkfJxfVMtTWmPEeypjvYQ4mWm/10JSqxlaOXVK2Vp3LqMDdcgCzvK2Z6WPdY/4DrVI5AgJikQi9LrzEyxUCp9PK2BSZS3hGJVOGWLIsyInRrmbdmuSV1UnYGJ7Dpshc3C0NWTXejalDrP6R1cjUkjre35/C5dJ6KhpbuDlcqKP2qeuJzavmxR3xGBro8slCP41bla5SL5ESmVnJl8fTKW9o5bslwzWuvOiIH0Mz+f50JpseDNRogi9XCDy6WenV8/sDo9pU6f0dX8RrexI58NS4Lid5qaKmqZWC6ma1IlNRTTPjPznFuVcmtTFyfXlnAgP66KqsVsipaGTql6EkvzND44rD5KJalv50nrg3p7XZFvLpKT6c76PRdQFQUN3Eil8vsP+JcfTVb/9efPLPi9gP7MvLGlY2vf1XMkU1zRq1Y93M7tgCPjiQwuFnxmvdVPTv+CI2hufw+AQ3JmmhVepSUR2rNkfjaWXEF3f7YdRHj+9OXubbkxkIAozzMOen+0ZcG5vkCoGfzmTx5fF0HhnvxpOT3Ls0/hdUN/Hu35eIzKrkxRmDuTfQsdNjlSAIPLAxilNp5e3uJxaBWCRCJFKe/7IgJ969U327a2mdhF/OZfNHZN61tL/Jgy3/0epTVdQ0Snh3XxJD7Yx4MKTrnkpyhUB0ThUHEos5mFiCIAjM9LHmDj9bApxurWCTX9XEydQyonOrOZJcgrVRHyYNtmTiYEtGuZj2iOmyNiirl1yrqonMqqSmSYqVUR+CXM0IclW2QfV0AMM/jVwhkFneQHy+su0pvqCWlOI6RjoPRBDA195EKdjYG2Nn0lej951/w9ygl15uple86eVfwb91gC6plVxJs1JW56SW1GE/sB8jnU0Z7WrKMMeBuFn0/0d9c8rqJSxZH0l+VROtV0pwxCI48/IklS1JFQ0tnL1cwam0MuLyaqhqbCXYXVmVM97DokfbmNqjtlnKiZRSDiWVEJpeTrC7Gd62xszwtmaIjfZiSr88mopULvDSzO4nx+RVNrHlQi7bo/Ix7a/PstFOzB9uj3EH6U3t0dAiY+uFPH4+m01fPR0eHu/KXcPtbvlLb3JhLXO/O6s2zUyT9qmrSKRyvj5xmV/PZfPERHdWhbh1esIoCAKbz+fxnwMpPDfVg4fGuWjlmvjpTBZfn7jM7w8EapQy09Qq4+4fI/GwGsBni3zbnMOb+5KIy69hx6Ojb+kK/7KfzjNukLJy63oOJxXz2dF0jj8X0uZnFAqBezec5825QzQ2lb1cWs+8tedIfndGm23+7x3j9wcCNa5k+iu+iA1hWfz95Nh292tokTHi/WPse3ysRuJfcW0zEz49zd7HgzVui7tKflUTs74+0y3TXnX8FV/EyzsT+H6ZPxO1kHqz92Ihr+5JZHWIG49PdEcsFlHV2MqYD08guVItp68j5j/zvVkY4EBhTTPPbYujpE7Cl3cPw78LqUqtMgU/n8ni21MZzPKx4ZWZg7tUyXkhu4pPDqcSl19DfwMdBlkOoJ++Dvq6Yvro6WBw5f/76IrR19NBT0esTJzSFRPgZKrSwyijrJ71YVnsjSsixMOCVeNde9SkVhtczK3ktd2JfHnPcDxtNLtvQHnvRudWczCxmIOJxcgUAjO8rZnjY0Ogi2m323o1RSpXEJVTxem0ck6mlpFb2chIZ1Nm+dgQ5Gr2j78fqaO0TnKDZ01WRSNe1kb/b8QaQRDIqWwioaCGpMJa4vNrSSqqRRDA287omlDjY2eMs1n/Lguf/9a5QS//v+kVb3r5V/D/ZYCuk0iJza0mOqeamLwqYnNr6G+gywgnZTz5SBdThtoa3fJKljqJlBU/X+BScR0tMgV2Jn1VelLcjEIhkFxUR2i60jQwNq8GV/P+hHhYEOJpwUjnf2alrLFFxtmMcv6KL+ZUahnmhgbM9LZmhrc1fvYmXX6RUCgUrPjlAq9M92Cog/Ze6iVSOYeSiglNq+BIcgnzhtuydJSTxpNYVbTKFPwdX8SPYZnYGPcl0MWUZaOcumzW2RkEQeCu78NJKKhRK95o2j51PfH5Nby4Mx49HTGfLfLr9MQalG07j22OwdfemE8X+WmlrXHjuWw+P5rOxgdGapS8VFonYd7acywd5cgTk26MxW6RyVn8QwS+9ia8N+/WmWHvuVjAutOZHHlm/A2TpXqJlOHvHlMbxb34hwgWjrBn8QgHjT4nt7KRqV+Ekf7BzDbbPF47xNFnx7fxBFLHO38nI1cI7VZRAOyKKWDDmSwOPzNeo+O+tieRmmYpa+9tG2feHjK5gnvWR+JlY6T1v92+uEJe2ZXIumX+3Y4rlsoV/OdgCrtjC/nqnmE3CEFv7Uviz6h8Wq9rdTTQFfPKjMF8cTyd2T42vDFnSKfilq9yLqOCN/YlMdTWiBWjnbskjKQU1/HJ4VSicqp5eJwrD45zwbAL53I90TlVbI3K56+4Qu4abs/D411xt+xaG9g/wdt74hEEeGe+5t5TCoXArG/OMNxxIHN8bRh1CwWb8noJp9PKOZVWxpn0Cgz0dJjoqTQbHjvI/LZsNb+5ssZigAF1zbL/F2KNIAgU1jRfMROuJbGwhsSCWiRSBV62Rox2NcXNwhBfexPcLQ21Wqn1/2Vu0Mv/L3rFm17+Ffx/HaBbZHKSCuv+65uTW0WLVMFwRxMmDbbE03oAwx0HdvvlVBMkUjmPb4nlRGoZDwS78Obczkeq1jZLCc+oIDRd2WLlatEffR3xFTHHEmezfrd8FU0ilROWXs7hpBKOpZRiaKDL9KHWTB9qxUjnzr2wZpbU8snRdL5Y5Ef/vj3zopZcVMvmyDz2XixksM0Alo1yYravTadEsJJaCUeTS1g+WmnQG5ZezrrQTBILarkn0JEHxrr0aIXU4aQSnvrzIq0390vdhK5YxO8PBKo00lVHi0zOtycy+OlsFs9P82TFaOdOm4RXNbby6eFUzudU8cOyADy0YPS8OTKXjw6l8sv9IzVKaEspruOZrXHsemxMm/s7v6qJOd+e5b153txxk4lwT9HUKmPk+8f585G2Hi/3rI9gto+NSuPdt/9KVv7/HUM1+pyimiYmfx5K8jvTb4g4bm6VMffbs2x9ZDTmGrYa3bn2HCvHOLeJYL+Z5T+fJ9jdvENTY1B+91O+COXAU2M73Xr5zYnL7IsrZP+THbdxdYZ9cYWs2Z3IumUBhHh0L1movL6Fd/5OJreqie+WDL/BJyy/qomJn52+oYUWlIbf/fR1+GLxMKZ7a+ZHdD0ltRLeO3CJsLRynp3qwX2jnTotFORVNrExPJst5/NYFuTEYxPcupXGoyo5amWwE1ZGt6+PylXqJVIaW+TXfHsOxRYQll3BhwuGdeo4giDckuexQiGQWFirNBtOKyOtpA5fexPGuisFm386EEEVVw2Gr3rWZF3zrFGKNSOdBzKw/78zDaqsXkJCfi0JhbVU1LdwJLmEmmYpHlYDrpgJG+Nnb4KH1YAeD+j4/zo36OXfTc/P6HrppZcew0BXhwCngQQ4DWRViPIlJ7O8gaicarIrGtgYnkNxrYQhNkaMcFZW54xw6hnfnD56Oqy/bwRrr5SzdwXjvnrM9LFhpo8NgiBwubSesMsVnEgt4z8HU7E27sN4D3NCPCwZ7WZ2S0SpPno6TBtqzbSh1rTKFIRnVnA4qYSPDqdSWN3M1CHKipzRrmYdvohcLm/AcoBejwk3AENtjflwvg9rZg1md0wB60Izef/AJRaPcODeUY4amTJ/d/Iym8/nUd8i5fGJgwjxtCTE05K4/BrWh2Uy8dPTzPa14ZHxrl2qXmmPFpmcN/cldSjcAMgUAk9tvUjoixM1Xsk30NXhhemezPC25oMDyuqBTxf6dqpKybS/Pu/f5cNXx9O5a+05/jPfhzuHtS8AdMSyICd0xSJW/nqBDStGdOjb4mVjxKGnx6mctDiY9uOLxX48vTWOobZGuHXRDLYz9NPXZfloJ/bFFbURbyZ6WnI6rVyleDPU1ojt0fkaf46+rg7NUgUyBehfd7s1tMjJKG9kQF/NrgOJVM6lolqGO5q0u19ZnQSZXGCur2Zj2rcnLzPLx6bTws3FvGq+P53BzkfHaFW4udra9MOyAMZ3U7iJzatm9eYYglzN2PZwEP1uuuc+OpSq8ucEQCoXyCivZzqaizdSuYKN53L46ng6U4ZYceL5kE4/u8rqJXx3MoNtUfnM9bPh5PMh2A1UVoDJFQJhl8uZ4GGhsQjRIpOz92IhP4Zl0dgi48GxLmxcOfK2rPa4HplcwdmMCnbHFnL0UgkPjXXlhemeAHjYG/JXchGVtU2YGWvuldWTwk29RMqZyxWcTC3jdFo5LVI54z0suG+0MxM8uxZ6oFAoE6dczPtrvaL3ZrFGrhDoq6dDkKsZL033/NdW1lQ3tpJYqDQTTiioJaGgltJ6ibKSxs6YAOeBLAiwZ6it0W3rN9RLL/9r9Fbe9PKv4Hp1feI7OwnwcmeorRFD7YzxsjG6JZP825Xi2mair6RZXfXNcTDtR7CbOb72xoxwNu2xvnC5QqCwuhn7gX27vTLW1CrjfFYVoenlhKWXk1/dxPSh1njbGRPiYcFg6wG3tCpHJlcQlaM0RTySXEJDi4wpXlZMH2pNiIeFygnYqzvjGNjfgBe14HejKYIgEJlVxebIXAprmjDuq8/yICcmDrZUWZ7c1CrD/91jSGQKdMUivljsxx03CRM5FY1sOJPFrtgCAl3MWB3iSlA3DZOvsvdiIc9si6Ovvg4iQBCU15FMoVDbQuVrZ8xfHfiWqKJVpmDtqQx+DMvkkXGuPDFpUKdXAk+mlvLstnjuGm7Hq7O8ur2SuCM6ny3nc3l+mifjVCQ0dYYPD6UQnVPFpgdH0U+/58fAyKxKVm+O4fyrU274HtJL67nju7PEvTmtzQt8SnEdC9eFk/j2dI3GiNpmKX7vHCXpnek3jOvZFY1M/yqM9PfbtlOpIia3ikd+jyH69SntXre/nM3mSHIJ21aN7vCYORWNTPsqjKPPaN66Bco2zdnfnOGeQEeNqns0Zc/FAl7bk8SPywO6dS0JgsAfF/J4f38KL073ZGWwc5vvLLmolju+O4dc3U2KslJu7+PBGgml57MqeXNfMnJB4N07h2psQn2VOomU9aFZ/HJOmaL3wnTPNhVyHxy4xIYz2Wx5aBTBHVTv1Ta38sf5fH49l41RXz1WjXflzmF2PV450B0EQeBScR17YguJzaumoLqJu/ztWeBv3+a7eGFrDFOGWDHD95+pTBAEgczyRk6llpFeVs+e2EKczfsrzYY9LRnhPLDb7eDZFY1M/Ow0YhG4WRgy2s2Mkc6m+DsNxNa4T6eeXzeLNZnlDTd41oz8F6ZBNbTISLzS9hRfUEtiQS399XVobJVfMxL2tTdhqK3RbSNm9lbe9PJvpFe86eVfwfUD9G9HoylTGJJcVEtyUR1l9S04m/VjqK0x3nZGDLYxYqitEZadiGj+N1En+T/2zjK8jSttw7ckMzMzxXHAcZjTYNM2bcqQtl9hi1ve7rZbbnfL3S3jlpmZgg1zYjtOzMxsi1kz3w/ZipMYZIzj6r4uXwbNSCNLOjPnOe/7PCayquTk1SnZUthEdrUcDxcZ02KtpbzT4/yZGOk7ILNTo1ngcK2cfeVWkSW7Wo7eJLDuzoX9Tvnpi6pWLfsqWll7pJHdpS14ujqxKMVqerwgOWhEV7lEUSSnRsHa3AbWHmmwGpamhLByYigLU0II8HRBEETOe2Urj62exJS4oUkr6i+NCj1f7K/ms32VOEmlXD47hkumRx/TPvD5vioe+zkXvcla+eIsk/DZ9bOZ0Y2/RIvawEe7KthR0oLRInDjwkTOmBg2KO8DvclCZlU7ar0ZtcH6per4Wa41IteaUOhMKPUmlDozDUo9RrPA4nHBPLgqbUBVJrl1Cv7xdQ4WQeS5iyb3O9q5uk3LTZ8cxNVJymuXTyW8m8jS/vB9Zg0P/HCE1y8fnD+J2SJw0ycH8fNw4T8X2e9nMVAEQWThc5t58Kw0VnZpjxFFkfnPbObJ8yed0LZjsghMeGQd6+5cSLwdgofOaGH8w2vJemj5MZOjnBo517y/n4MPLbfrWN/ZXsaeslbeuWpGr9utfnUHl86M4bKZMX3e579+zsVJJuH+M/vXMvrkb/lUtWp47fJpQ+b38F1mDd8erOHm05KYn9w/4aMrepOFR37MZVNBI6+umcrsHpLWLn5zFwcq23sUWAEkEoj0c2fj3xb1uArfrDLY2sf+ujiJa+fF90sg0ZssfLy7kte2lDAu1Jt7z0jt1hj550N13PVlNmZBZEacP1/fNLfb+2tQ6Hl/Zzmf7a1ifnIQF0yNYskoTI7qSr1Cxw9ZdXyfVUNNu46VE8I4b2okcxICexybX1yXj0SEO1aO3MKC3mRhT1krmwua2FzYTINSz9zEQJamhnDauJAhTcwD6yLAhEfW2s5tUom1ElNvsuDj7kxGjB9zEwOZGmO9Bur6Hu0q1lS2atlR0jKmDYb1JgsF9UqyqzsqamoVlDarCfV2O0aomRjpS8AoFqkc4o2DsYhDvHEwJuhtgG5WGcirV5Jbp6C6TcvesjbKWzUEebkyIcKHtHAfJkT4MiHCh5gAj1F9UTYcGM0CR+oUHKxotyZbVbajNphJj/Jl8bgQUsO9mRYT0K1RrcZgJrOqnX1lbWwpaia/XmmLVDV0GFY6SSXk/uv0YU2+MZoFDla227xyihpVTI7yZWFyMIvGBZEe5T9icaWiKFLcpGZDXiO/H64nv0HF1Bg/FiQF8dX+Sv74xxJcRjAFqDtMFoFN+Y18tLuSA5XtnDUpnCtmx5IR7cvS57dR3qI5ZnsPFxk/3za/R2FEazTz1f5q3t5ejkQC182P5+IZ0SNS7QFWD5oXNxbx5f5q1syK4Y6lyf2+kDZZBN7cUsprW0q4dl48ty9N7leZt95kbffalN/EK5dl9MuHpzs6k4FeuzyDJakDTx1qVOo586Xt3LsylYtn2GcKPBie31BEfr2St4+LyP5iX5XNg+t4zn5lBzcuSmDV5L79eSyCSOL9v7H3/qXHxJLvKmnh/u8Ps+Ufi+06zr9+epAJEb7csjipx23KmtWsfHE7+x9Y1qdRd0mTirNe3sHGvy3q16Rz7ZF67vkmh7V3LiRiiHykvj1Yw0M/HuHt/5veZ0VJb9TJddz8yUEkEglvXNGzKLmjuIWr3993gtdNd8gkEi6fHXOCSbTZIvDJnkr+u6GIBclBPHDmeFt7kz2YLQLfZtbwyZ5KLALce0YqC5ODuq2mKGhQcs6rO22myjKphB+Pqwg6PjnqpkUJdpmJnyxUehNrjzTwfVYt+8rbmJsUxPkZkayYEGrXOLzpSA2/5DTywpppw3qcdXKdrfV4Z0kr/h7OLE4NYUlqCHMTg4a0ZbA7Ln97DztLW3u83c1JiiCCWRDwcXPG3UWGp6sTpTbPmgBmxwcyK2HsiDVGs0BRo4pDNXKbqXBRo4rkEC/CfN2syU+RVsFmOFruhxOHeONgLOIQbxyMCfo7QKsNZgrqlVZRp1ZJbr2CogY1Lk5STp8QirebM2kdws5ImKqNJkRRpLxFw4GKdo7UKdhR3EJ5q4bkEC+mxQZgEQRUOjNFTSrKWjS4yqRYBBFTDxfuEyJ8+PX2BSP6HBqVerYVNbO7rJVN+Y1IJBLmJwVZjY9Tgkf0AqRBoWdTQSN5tQqcZBIeWz1pxB7bHkqaVHyyp4pvD9aQGubNwaoTV8+lEms09693LOjVa8BsEfjtSANvbS2lVq7j/2bH8n9z4wbkTzAQihpV/PuXPA7XKrjvjFTOnxrV71L7ggYl//g6hzBfV/56WpJd8d1d+XJ/FT8dqrMa3C5MHJQY/GtOPX//+hAvX5bB8rSBCzg7ilu44eMDfHvz3CH3KDqeylYNy57fyp77ltptCPvPb3Pw93Th3pWpdm2fcN+vbP3H4mNEkrVHGnh1czG/3GbfWDPnqU389+L0Xttxnt9QRGGDkreunN7jNp3c8lkmfu7OPHGe/Z/vBoWelS9t4/FzJ9olXNnDNwdreKRDuBmMgLi7tIW/fZnNaamhPHpOWo/ie2e1VU277oTbJNAhgIroTQJOMgkRvu6snBjGfWcerfDIrGrnwe+PoDNZePScCf0yVRZFkbVHGnhufSEWQeSfK1M5fUJYj587hdbEihe30qQ00DnMyaSwLDWUt/5vOgcr23hzaxlbi5o5d0oENyxMHLXJUSaLwPbiZr7PqqOyVYNFEDkvI5Jz0iP6fY6Tq/Tc930Od69IJims/xHuPWG2CGRWydlc2MTmgiaKm9SclxFJYrAXS1JDSAn1GtF253e2l/Gf9YW26pu+8HF34j8Xpo+ZyhqLIFLSpCanRk5lm5btxS3k1ytxdZJ2RHP72UyFI/3cR2XMen9wiDcOxiIO8cbBmGAoBmiTRaCkSU1Ro5LsagV5dVZxR2+ykBziba3SibC2XI0PHz09vSNBi9rAwUqrb857Oyt69TXoipNUwnUL4vnnCHq8HI9FEDlUI2drobUqJ6dGTkqoN4vGWYWc6bEBIyLOmS3CiEWpDgSNwczl7+whu1rR7e3OMgmJwV58/9d5fa6OiqLIrtJW3tpWxt6yVq6bH8+F06PtaosZLKIosqWwmdc2lyDXmXhoVVq/E3bMFoH3d1bw/IYi/m9OLHctT+lXFc6RWgU3fXKQ1DAf/ntxOr7uAx8r1h5p4K4vs3nhknRWThyYETjASxuL+SG7lp9unTfsY9dFb+7izEnhXDMv3q7tP95dwaaCJj64ZqZd24978Hd+v2MBCV0qwb45aG0T+vyG2X3uX6/QceEbu1l754Ie/xeiKHLaf7bwz5WpnNGHAXt+vZJzX9vJln+cZnfLnCCI/N97+wjxceX5i6fYtU9ffH2gmkd/yh2UcCOKIu/usEbXP3n+JM7rI4nr1s8y+SWnHgnWtigRCPF2JT7Ik/HhVrPshCBP4oM9CfV2O0ZUadMYeeb3An46VMdfT0vkhkUJ/arQ3FXSwjNrC6hT6LljaTKXzIjuVay1CCJXvLOXA5XtmI4zRJdKYG5iINnVCtbMiuHaefG2NKbRhCiKZFfL+SGrlp9z6nFzkrI6I5LV6RGkDlKYve/bLBanhrJiwuCExDaNkS2F1laobUXNyKQSTksJZnFqCAuTg/usYhtOjtQqOPe1nX1WiTlJJVw5O5YHV6UNadWu2SKgMVhG5H8gCCKVbdouZsJyjtQqAZgY6cPC5GBiAj2YHOVH7BitOneINw7GIn9eF1cHDo7DWSZlfLhVmFk9xTrAi6JIdZuO3DoFefVKthe3sC63gT1lbcQGelhNkSN8raJOuM8pV1JqL0Ferh3x2GHcsSyF6z86wP7ytj4vgJxlUrtij4cTmVTC1Bh/psb4c9fyFNo1RnZ0xJHf8UU2cQEe+Ho42/xy7Elj6i+CIHDXlwe5cnYcMxMGZ0I7XBjNgu3CrjtMFpGyFg03f3qQd6+a0esFrUQiYV5SEPOSgsirU/LujjJOf2Ebi1ODuWFhItNih25lt7vHXpwawvzkID7eXcltn2UyLdafB85Ks3sF3Ukm5fqFCZw2Lpi/f5PDmS9v57kLJ9vdNjEx0pdfbpvPXV9mc86rO3jzimkDrnhZOTEMJ2kGt32ehUWAs+xMPTqeW5ckcaCyjX9+e5hX12QM64rqBVOj+GRvpd3izYQIX17eVGJ39LCLk/SENDKV3oSXm32XNFlVcnzcnXsVsbKr5bRpjCxO7dtz6IUNRVw2M6ZfXkfv7Synsk3DG1dMtXuf3vjqQDWP/ZRrV1JZT2iNZu75JoeDle18fsNspkT79bitQmvioR+PsKWwmQXJQVw9N474IE+iAzz6rHYTBJHvMmt4/Ld8pscGsP6uhf1qNTtco+DZdQVkV8u5+bRErp4bZ1dr0HPrCsisOlG4ARBE0JsEdv5zyaDE1uGislXDD1l1/JBdS4vawFmTwnn98qnMjAsYskl3jJ87mWWt/RZvBEEkt05pi/JW6Ex4uspYMi6Ea6+ZweQovxFrW+6JJqWePeVt7Cpt6XPxyUkq4ZGz07pNxxssXx2o4f7vDxMf5MnS8VYxa0ZcwKDbxURRpE6hJ6daTk6tgpImFXvK2jCYBMaHezM5yo+Lpkfz+Ll+JAZ7juqFJAcOHPSOQ7xx4KAXJBIJMYEexAR6HLP62qI2kFenJLfO6qXz7cEayls1BHpafXRmJQQQE2A1SR5rKxperk58+pdZPPV7Ph/sqsBk6flCSGeysLmgGaNZZHqc/4i1z/SGv6cLZ6dHcHZ6hC2NY3txC78faeBfv+QR6eduE3JmJwTaHUHdG98drMQFKZOihk+0GCxfHajGSSrpVZAzmgV2lrTw2M+5J3hW9ERahA//vXgKd68Yx/s7y7nqvX2khnlzw8IElo0PHbbPhrNMyrXz4zkvI5IXNxZx1svbuWxmDHcus98PJznUm29vmsO7O8q54p19rJkVw99XjLPrQtvPw4V3r5rBq5tLuOCNXfx79UQumDawVb9laaG8fvlUnvwtD4sgnJD+ZQ8yqYQXL5nCWS/v4KPdlVw1N25Ax2IPZ04O55GfcilsUNllVJ4a7k2LxkCj0mBXtYOLTIrJfOz7VK03422neJNZ2c7UPiLCf8yu44yJYX1WXB2uUbC9uIWt95xm12ODtVLnv+uL+PgvM4ekCuqr/dU89nMu71w1gzmJAzNDr2jRcOPHB/H3dObn2+b3OlbvKm3h7q8OMS7Mmz/+vqhf5v+HaxQ8+MNh3Fxk/PeidJaOt78dsKxZzSd7K/l8bzVXzY3jlcsy7P4s/3a4jne2l/c6vmVXyzF3I+ycLNo0Rn7NqeP7rFrAuohyz+njWJwaMiyxy/OTg3l9SwkHSpuZntj7IoNSb2JHcQubC5rYUtSM3mhhQUoQa2bFsCg5mNCTXLXUqNTbkqD2lrVS0aohLcKHWfGBpIZ7k1+vOmEfqcR63vjf/03vd7WmvcQFeuAsk1DeouGDnRV8vLsSsyAyKdKX5WkhzE8KZmKkb59iV7PKYE19qrZW1ByuVdCuNZEc4kV6lB+LUkK4bUkyqWE+f6q2fwcO/gw42qYcjAlGQ2mkxmAmv8NHp6JFw76KNooa1DjLJIzvSLjqrNJJDvUaVgPfkeK7zBru/TanRwEnwNOZMyaGc6CinaImFfGBnsyIC2B6nD8z4gKIDfQYVT3VGoOZ3aWtbCu2tljVy/WsnhJBYogXC5ODGR/e/zjyogYFj/yYy00LE1g03prAYzBb+OVQPcvGh57UEvJOBEFk9lObaFIZ7N7nrElhvLpmar//H0q9ic/2VvH+znI8XZ24fkEC502JxG2YjSqLG1X8+9d8cmrk3Lk0mctnxeDcj89gSZOae745RJvGyLMdHgj2Yq3yyuLMSeE8cnbP/iF9sa2omZs+Ocjj507k/KkDG+P2V7RxxxdZvHH5NNJ7qawYLI//koezTMq9Z9jnY7Ps+a3cd0aqXZP5v3y4n1sXH+tH9MofxZgtInctT+lz/wve2MWamTE9imlmi8D1Hx3g+gUJfbYfXfP+PpJDvbn/TPtaQ/UmC6tf3cnpE0L524pxdu3TG1/ur+KXQ/XcsiSpxySovvijoJE7v8jmkhnR3LsytcdVeYPZwqt/lPDujnLuO3M8V8yKsfvzr9CaeG59Ad8crOGGhYn89bREuwWIBoWelzYV811mDZfOjObmRUn9amkqalRx9is7bCb6PeHqJOX6BQn8/fTBvy4DRW+ysCm/ie+zatla1ER6lB/nZkRy1qTwEYmefn9bMZsKmvjwurnHCAiiKFLYqGJXSSvr8xo4UNFOQrAni8dZk6GGIsp7MDQorGJNYYOStbmNVLZqmBDhy+yEAGbFBzIjPsBWUfXO9jL+s64QfZf3g5NUgq+7M59eP4vUsOHzBVPoTKQ/tr7b21ydpAiiiJNMyuz4AJaOD2VBchC+7s4cqVXaDIVzauTEBHjQrDZYzYQ70p/Swn2H3fD5VGM0zA0cOBhqHOKNgzHBaB2gjWaB0ma1rUInt05Jfp2S+GBPTBaxS9qV1U/nVPTRyaxq5+r39qE1Wo5Z1ZQAF06P4rkLrRHFcq2Rg5Xt7K+weufk1Cjw9XBm1aRwogM8mBEXwPhw71FVzlvRomFfeSvr8xrZVdqKl6sTC5KDWZgSxILkYLsiMu/6IhNXmZSnL5pi+1tlq4ZbPsuksEHF7IRAzkmPYNG44JMWX7+1qJmr39tnM/CUAM5OUpwkEpCAIIqYLaLt9ZVg9bZICfXiytmxnJsR2e/3rtEs8GN2LV/ur6ZOoWPNzBiumB07rKaQnX44n+2rpLxF228/HIsg8v7OctblNjAhwpd7Vo6zO1Grpl3LXz/NJD7Ik3+cPo6ofiTpdGVnSQs3fHSAR86ZwMXTB5Ye9fb2Mj7YWcGvt88ftv/3tqJm7v76ELv/ucSuz/QdX2SRGOzF7UuT+9x24bObeeaCycdUmdz33WECPV36nHgbzQITH13H2uM8c7qypbCJe7/NYdc/l/a6Ap5Z2c6V7+5l2z2L7TZn/u/6QvLqlbx5xbRBT3a/2FfF47/m8+5V05k1AOFGEERe2VzM/7aW8dQFkzknved2mYIGJXd+kU1cx/u3p+S57h7jm8wanv69gEmRvjx2zgTi7PS+kmuNvLG1lA93VbBsfCh/W57S42vWEwqdicX/2UKbxmjX9h4uMg48uGzEkvLA+j/aX9HGd5m1/Ha4nmBvV87NiOTcKZHEBA5tXHZfmM0WFjyziUfOmcDKSZFsK2rm9yP1bClsRq41MTcxkMXjglk0DFHe/aFOrrNGd5e2sbe8lao2LRMjfVmQFMS0OH+mxwXg08M56XjfGxcnKXGBHnzyl1kj0vo++8lNNCj1/donyt+d9A6hZlKULxMjfPBxP/UNlIebwtIKUpOs7bujaW7gwMFgcLRNOXAwjLg4HfXRuXBaVx8dLbkdhsg7Slp4a1spjUpDR6uVVcyZFOlLargPId6uo6o65Ximxviz9s6FXPnuXqrbdbb4VXcXGXO6TCj8PFxYOj7UtrKuN1lsJnrbi5t5YWMRgiAyNdaf6bEBzIjzZ0qM34heRB9PXJAncUGeXDwjBqNZ4EBlG9uKWnhraxl3fZnNpEhfFqUEMy8piKmx3a88ujpJOT3tWN+M2EBPfrltAdVtWtblNrC3rJV/fneYKdF+nD4hlNMnhA2L905PmMwCaRE+BHi6EOztSpCXK/4eLvh7OOPn4YKfh7Ptd18PZ1ydZOhNFn4+VMcneyp5+vcCzs2I5PJZsaRF2Ldq6eIk5aLp0Vw4LYothc28ta2U1zaXcsmMaP4yP35YJgZd/XA+2VPJ7Z9nMTXGz24/HJlUwnULEliaGsK93x5m5YvbTxAReiLK34Ovb5rD47/kcfYrO3jx0owBlebPSwrinatmcN2H+7EIIpfNjOn3fVw3P569ZW3c/dUh3v6/6cPSujYvKQiZRML2khYWj+vbN2ZChA8HK9vtum9nmeQEzxu1wUysHRPdvHolHi6yXs2zf8yu45z0iD5bF57fUMStS5LsFm62FjXz3o5yfr19waCFm8/3VfHEr/m8d/WMAfmKKXQm/vZlNjKphG//OrfHagNBsBoYP7+hiOsWxHP70mS7jz2vTsnDPx6hTq7jyfMmcfqEULvOZVqjmfd3VvDm1lIyYvz55qa5x8R420tOjZw1b+9BbbAA1uoKUQRLL2uWepOFL/ZVc+18+/yaBkNxo4rvsmr5MauWxBAvEoO9+OS6WUyO8j1p53wnJxnnZURTK7emhx2obMfd2YlnL5zMjLiAYWnXsodauY69Za0UNqj4/UgDtXIdEyN9mR0fwCNnT2BanH+PYs3xjA/3wUlmbRF2dZIyJyGQ16+YOmLXGhkxfvx+pKHP7SQSCPNx439XTGPSMFZJjgVa1QZKmtSUNKut3zu+qqtrTvahOXAw5DgqbxyMCUZr5U1/ON5Hp7ZdR3aNnEBPF9IifG2izmj10dEazdz2WRY7SlowmAWkEtjy98V2rxxaBJGiRhUHKtrYV9HO/vI2WtQGThsXQlygB9PjrIKOvROl4aZJpWd7UQuHauT8mlOPwSwwOyHQVpUTF+iB0WTmxo/387eV45gc2fsEv0mlZ2NeE+tyG9hV2kJCkBenTwhlxYQwJkT4jGoBL6dGzid7KqmT69GZLFw+K4YzJ4X3+0I/p0bO/7aVsT63kRUTQrlxYSKTovo/abOXdo2RFzcW8cX+6n774QiCyEe7K3huXSHnT43in2ek2u2P9M3BGh7+8Qg3LkzktiVJA/os7ytv49oP9nPvGalcOTu23/srtCbOemU7V8yO5aZFif3e3x6e/r2AmnYtr67p25R3Z0kL936bw457l/S57coXt/H3FeNY1iU+/er397FsfChX9PG/eG9HOduLm3m/h2QrrdHM9Mc38tWNc3oVDPaWtXLdhwfYfu9iu94zrWoDK1/azj9WjOPiGQOrmOrks71VPPlbPu9fM4MZcf0XbgoalNz48UESg7144ZIpPRr01sl13P3VIWrlOl64JN1uw26wLlKseXsvU2L8uG1Jkl0TY5NF4OsD1by8qZgwX3fuWTmu3+bLoiiyrbiFt7aWkl0tZ0q0H+PDvQnzccdgtmAwCxjNAjqTBZ3RYv1usqA3CRhMFvRmC+dlRPGXYRJvmlUGfjpUx/dZNRQ3qlmWFsr5GZEsTAk+qW1HXflwZwm1bRruPzv9pB1DdZuWveVt7ClrZW95K3VyPZMifTl9Qiip4T5Mj/UfVKXy5W/vYWdpK9fMi+PBs4Y2Uao7LIJIWbOaQzUKfsquZXtxC71NvpxlEq6YHcsDZ44fVdXIJxNRFKlX6G3CTHGTmtImNS1qPWUtWsJ93UjqEEGTQ71ICvbCwyRncmoScOrODRw4OB6HeONgTDAWxJvu0BjMFDRYBZ1OYaewQYWzTMLytFB83Z1HlY+OIIj8d0MRr28pwcfNmeyHlw9YdBBFkVq5jkM1cnaWtHKgoo3iJjXxQZ7MjAuwiTkxASffN0cQjhof7yhpJrtaTrCXKzPj/Nlf2cYfdy/u1zEq9Sa2FDazLreBLQVNJId4MTU2gBUTQpke6z9qL+YUWhPfZtbw6d5KWjVGLpwaxZpZMf1udahu0/LujnK+3F/NzHh/rp4bx2njQobtdS5uVPH4r/lkV8u5a1kyl8+OtXsiVdWq5Z5vD1HdpuPZCyczz86I5rw6JTd/epD4IE9evGTKgNqXDla2cfV7+7l7RQpX25ns1JWcGjmXvLWHD6+dOSypcCVNKs58eQf771/Wp7eTXGtkyr82cOjhFX1uu/rVHdy0KPEYE/kL39jFlXNiWd2HmfNtn2eREuLFbT20Z/2YXcsrf5Sw4a6FPb7fRFHkkv/tYW5iIHcu69tjRxRFbvj4IDKJhDeu6L9PVFc6K90+uGYG0wcg3Px0qI77vs3hugUJ3LE0uUfh8MfsWh784QhnTgznobPT8BqAcbtFEO2aFAuCyM85dTy/oQhnmZR/rkxl6fj+fd7NFoH1eY288kcJTUo9V8+N48o5w9uGaS86o4XNhY18daCGnSUtTI3x5/ypkZwxKdzuapGRZEdBA99k1fDCpdNG5NwqiiI17Tp2l7Wyt8NkuFGpZ3KUL7MSApmdEMi0WP8BvQd7YndpK/VyHecP0ES+NzqfT2dlcadXjUUUmRjhS1ygBz9k13Vrni3Bapr834snc3Z6/43ph4rMqna+OVjDirRQ5iYGjajpsUUQqWrTdgg0KuRaE3vLWilt1qA1mokJ8CApxIukEO8OscaTxGDPbtvIxurcwMGfG4d442BM8GcaoE0Wq49OcaOarCq5LcZcb7KQFOJ9jI/O+HAffIYh9rQzpWlLYRMb8pq4ZXESy7usgv+aU0ej0jDkpeedvjn7Kto4UNFOTo0cfw8XlqaGkBLm3eGb43PSY0k1BjPZ1XKKGlT4ujtx/rSBr7TrTRb2lbfy2+EGNuQ1IgJLU0NYMSGMBclBJ62MvTdEUWRveRuf7q1i3ZEGpsf5c8XsWJanhfZrdbldY+SH7Fpe21xCgKcL1y9I4JwpEcMmUm4ubOLxX/JIDPHispkxdrX7gHXy+em+Kp75vYCz0yO474xUuz53Cp2Ju7/KpqBBxZtXTBtQa0hWVTt3fJHNdfPj+b8BJEh9vLuCVzeX8OvtC4YlDW71qzu4eEY0l8/quzpo3tN/8NyFk/s0Ce5OqDn9hW3ce8Y4lqT2bnh8/UcHuHZuHHN6eIxrP9jP1Bg/bl3Ss/fOjuIWbvksk+33LrZr8v35vipe3FjE2jsWDsp09uM9lTz7ewHvD0C4MVsEnv69gC8PVPPiJVN6NIZWaE08u66A34808NT5kzh9QtiAj7cvOj2onl1XiEJr5K7lKZw/Napf47fWaOar/dW8s6OccF83zkmP4KLp0Sd9XBQEkT1lrXyXVcvaIw0sSA5iYqQvq6dEDNjvaqRQagzc+WUmD581nrhQvyG/f1G0Ts73lLWyt8xaXdNpvrsoJZgp0X5Mi/UfkqTHkaBFbbCKNB3JT20aI0fqlIwL9SY92o/0KF8mR/mREuqFk0yKzmgh7ZG1HD/7cpFJCfRy4YNrZtqV0jecfH2gmnu/zcFZJkUCLEoJZlV6BKeNCx4yb0aD2UJ5s4aSjuvZkmZrJU1ZswaA+CBPkkK9yIj2I9THWlUTH+TZr8/2n2lu4ODPg0O8cTAm+LMP0J0rPbl1ii6tV0q0RjN+Hi7HtFylRQzMR0euNbK9uIUN+Y1sKWhCa7Qg64iWfv7i9D5XvIcDvclCdrWcA5VWMedgRTsi1p7yzlSrjGj/k5bAsCGvjlh/T1LCh6b1xyKIZFa1sz63gXW5jTSrDCxKCWbFhFAWpwbj7zE6Wsq60qI28NWBaj7bW0VSiBcTI3y5dGZ0vyYwepOFH7Jq+d/2MtR6M9fMi2fNrJge2z26wyKINKn0hPu697qdyWzhk71VvLixmIwYPx48azxJIfZdSFe3aXl5UzE7S1p46oLJdnnaCILIG1tLefWPEp46fyLnZvR/7DpU3c7/vbefv56WyI39bIESRZHbv8imXWPkw2tnDrnw+dHuCn7IquW7v87rc9tHfsolKdiTK+fE9brdmrf3cF5GJBd1MWye9/QfvHjplF7biJqUemY9tYmcR1Z0OwFp0xiZ9eRG/rj7tB49l0RR5Pw3drFsfCi3LE7q8zmVNas5+5UdvHXldOYn968FqCsf767gtyMN/H1FSr/al8D6Gbz1s0zaNEbeunJ6j34/u0pauPvrQyxIDuLvp48bVgP1AxVtPLu2kJJmNbcsTuLyWTH9mpS1aYx8uKuCj3ZXEOHnbq3Emhh20qsSCxtUfJdVw0/ZdRjNAmenR3D+1EgmRZ48H5uBcMvH+zh9QgjnTI0b9H2JokhFq5bs6na2Fjazt6Mlekq0H7MTApkVH8jU2JPrb2cvSp2JI3UKcmoUHKqWk1OjoFauIyHIsyP1yY+MGD/Gh/v0+n5e+Oxmqtq0tt9dnaTMig/g1cunjopqrKyqdi55a88x3mLuzjKMFoHpsf6snhLJsrQQu8YItcFMaUeb01E/GhVVbVoCvVwI93EnKdTLWk0T7EVyqDfR/u5D8ln+s88NHIxNHOKNgzGBY4Dunla1wWaM3OmlU96isfnozEkIIMrfapIcF+h5TAm9IIgcrlWwuaCJtbkNFDaqcOswqu06aMgkEtbdtdAuw9fhxiKIFDaoOFDZxv4uvjlnp0cQ5OXC9LgApseOnG/O3788yMqJoSybMDyl2YWNKtbnNrK1qJncOgXTO1qrVqSF9StKdyQQBJEdpS18sruSzYVNzE8KYs2sWBaPC7b7Ik0QRP4oaOJ/28rIrVNw6cwYrpkXZ5cQ9L+tpfx3QxE/3jrPrihYudbIixuL+XxfFZfNjOGOpcl2VU2IosgX+6t58td8zpgUxgNnpdklMu0qaebOLw+xeFwIj62e0O/KgSO1Cq54dy/XL0iwS1Toitpg5qr39rIiLazf4k9ftGuMzHpyE2vv7DndqZOXNhZT3qLmxUszet3uqvf2sWJC6DHVPJMfXceXN85hfHjPr+3aIw28sKGIdXct7Pb2j3dX8EN2Hd/ePLfH+9hc0MTfvz7EtnsW91kZYLIIXPDGLmbGBfDgqrRet+2Nj3ZX8NzaQj64dibTYv373qEL2dVyXt5UjJuzlOcuTO/2mPUmC/9ZV8hn+6r6HQHeXwoalHy4s4KfDtVx3YIErlsQ36+V/Oo2Le9sL+OrAzVMi/XnpkWJzEsKPKnCSJNSz+9HGvhyfzWlzWpWTAjjvIwIFiSPHh+b/vLvH7NxkUm5d9Xkfu8riiKlzRprGlRZG3vLWpFrTSxPCyEx2IvZCYFkxJy8RRV70Zss5NYpyeloezpUIwdAa7RYk5+ifUmP8mNipG+/FhIA7voym++zagGrkfZtS5K4bUnPbYwjjUpvYtKj3Ueag1XI0ZstjAv15tyMSE6fEIavuzPFjapjTIOdZRL+KGjG38OZ5BBvEkOsIk1yx/dwX7dh/ew65gYOxiIO8cbBmMAxQNtPVx+dBoWe7cUtFDaocJJJGB/ug7erjOImNS1qIxZBRCqV2BKkusNZJqHg32ec9Fal7uisSDpUI2dX6bG+OTNirZU5M+MDhsU3p6FVzaO/5vLI2RMI9x9+Yau6TcuGvEbW5TZwoLKdiR3mjivSwkaFsNaVBoWeL/dX88X+KgAumRHNpTNi+iU4ZVW18/b2MpqVBsL93LlhYUKPbUcmi8DMJzYi15oI8XZl3V0L7fbCKGlS8cSv+WRWyblzWTJX2OmHUyvXcd93hylqUPHk+RP7bOcBqFfo+OunmRjNAm9cPq3fMcF5dUqueHcvV82J445lfUdud6WgQcn5r+/irSunsSC5/ylYvfHoT0fw83Dp0x9mY14jz6wtYMPfFvW63fUfHWBeYqDN50cQBBY8u5kvbpjTa0rZU7/no9SZeOr87iekd3+VzbRYf9b00OIliiJnv7qDc6dEct2ChF6PEeC1zcXsr2jnrSunDbjV78NdFfxnfSEfXjuTqTH9E26+2FfFYz/n8bflKfxlfhxS6Ynv2/x6JXd9mY2Lk5QXLplizz/z0QABAABJREFUdwR4f6lu0/LChiJ+PVzPjQsT+L+5cf1q08utU/DV/mo+31fNigmh3LQocUBthkOF2mBmfW4D32fVsru0lQumRjItLoAzJoYNWVvJyeTbveVsKWnhlctn9LmtKIoUN6nJqmpnW3ELe8vaUOlNTI3xZ1ZCALPiA8mI8TvprWy9YbIIFDaoKGhQcrCynUPVCooaVfi4O9sqaiZH+jIpyodQn96rN+3hkz2VPPzjEdycZbx++VROs7NFdySZ8th65DpTv/Y53jQ4JcSbhGDPkxY04ZgbOBiLjP4aRQcOHAwpnq5OTIsNsJXe37PSeuFS0qQmr07Jp3sqqZXrj+7QjaleV+KDPEelcAPWaOjoAA+iAzxYNTkCONY354v91dz//WFiAzxJCfPqiCgPYHy496BLdvMa2vFwdhoR4QYgOsCDa+fHc+38eFrVBjblW5OrXtxYTLS/OxdOi2J+UjATI09+clWYrxt3LEvmlsWJbCls5tO9lby2uYRLZ0SzdHwoC5OD+1yBzIjx5/XLp1HZouHdneVc9OZupsb6ccPCRBYmBx3zHH/JqUNrtFaMtWmNXPfRAb64frZdr3FSiDfvXzOTLYVNPP5rPr/l1PPXxUksTu39YjvSz50Pr5nB1wdquOOLbJanhfLIqgm9mvGG+7rz5Q1zePK3fM5+dQcvXJJul+jTSVqED59fP5vL39mDRRC4a3mK3a91apgPj54zgTu/yObX2xcMaeXWvKRgHv0pl9v7WFmeEOlDabMandHS66q8p4sMk+XouKQzCdTK9X22G2RVyrmwB4PS6jYtPx2q44Gzeq6QqVfocZFJ+0y0Amsa2Kt/lPLjrfMGLNy8v9Ma0f3RtTPJ6IdwYzBbePSnXNblNvLuVdO79RASBJF3dpTxwoZirl8Qz239iADvD80qA69tLuHzfVWcnR7BprsX2d0yKYoiu0tbeWNrKfsr2rhwWhQb/raQ2MCeY96HE5NFYEdxC99n1bI+r4G4QE/Oy4jk2Qsn99mOeaqRHO7Nr4frEAThBNHPIojk1yvZW97GvvJW9le0ozNaWD0lgtRQb66aE0d6tO9JD1Doia7JT4dr5ByqsfoGusqknDkpHD9PZ25dksSkSF+i/N2H5Xy5KCWYBcnB/Hv1xH6L9COBRRCJ8HOzS7yRSGBmXAAvXpJOuN/oey4OHIw1HJU3DsYEXdX1v7+/ifTUROKDPIkL8iTcx23UlKKeKmRXy7nuw/3ItaZuExG6siglmGcumEyoT/99dEYDepOFwzWKDhPkNg5UtmMRRKbG+DM9zp8ZcQFMifbrt3nip7sqKGtV8tDZ/S87H0o0BjNbi5rZXNDE70ca8HV35vQJYaycGMa0WP9RI7xVt2n5+VAd7++qwNVJymUzY7hoepTdvhvtGiMf76nkw10VBHu7cv2CBM5Oj8BZJmHxf7ZQ0Xqsv8ClM6J5bPXEfh2jySLwXWYNT/1ewOQoPx46azzJoX374TQo9Nz//WEO1yr4+db5dgkjP2bXcv93h/nL/HjuWJbSr9eppEnFZW/v5cJpUdxz+rh+fS7/8fUhyls0fH7D7CGbzJssArOf3MQrl2X0akYsiiLTHt/Iu1dN71WsuPOLLJJDvW3tYQ0KPbOf2kTJE2f0KMiZLAKTHl3HL7fN79bD6NU/ismskvPe1X1XGvSFUm/ijBe3c92CeK4ZQAoYWCPNX9jYf+GmXqHjpk8yQRR544ppRPidKCrUyXU8/kseR+qUvHDJlH63YtmDUm/i7W1lvLujnPlJVg+dFDs+K2CdOK490sBb20qpbNVy1ZxYrpobd1JW70VRJLtaztojDXxzsAZnmZTVGRGcOyWy1xa90UKr2sCOkhZq2nX9aqc0GExc/e4enjhvIqEB3uTVKTlY1c6+8jb2V7QhijA9zp9Z8YHMSghgYoTviCYS2YsoilS2asmpVVDUoGJfRRu5tUeTnyZFWVufJkX5En9c6/ifAYPZQkWLluIm1THx22UtGvw9nGlUGnrc10kqwdVZykuXZLAszf5FhuHGYLZQ3aajslVDVn4p/7jA6rfmqLxxMFZwiDcOxgRdxZs73tlAK95UtGqobdfhLJMSF+hJXJAH8UGexAZ4EB9sda0fiHHvnwW51sgtn2Wyv6K9x7YpmURCapg3eQ1KAjxcSOswRe40SD7eR+dUQBBEippU7K9ot4o5Fe00KPWcMSGUYB83pne0W4X69D4Bf2V9Hs4yCTctHT9CR943BrOFXSWtrD3SwIb8RqQSWJ5mFXLmJASOiotvk0VgY14jn+2rYm9ZG8vSQrh8VixzEgLtei/pTRa+y6zlne1laI0WVqSF8vn+qmMqNcDa7vfU+ZO4cABJYHKtkZc2FfPZ3ioumRHNnctSCOjDD0cURXaWtPbLn6OwQcXNnxwk0t+dFy6Z0q82k9JmNde8v48LpkVz+5Ikux9TZ7Rw3us7WZQSzH1nDt17918/5yHXGXn+4im9bnflu3tZMSGMK3upbrnnm0OE+brzt+XWNqySJhXnvLqTvH+t7HGfwzUK1ryzh0MPrzjhfSSKIstf2MZtS5KGxHj9zi+yaNOa+PCaGQM6v7y7o5wXNxbx8V9mMSXaz+79dpe2cutnmSxPC+XRc7r3Tfoxu5aHfjjCpTNjuH1p8pDGL3dS2qzmwjd2kRLqzb1npNrd7qUzmvk2s5a3t5dhtoj8ZX48l8yIPimpQ+UtGn7IquXH7Fpa1UaumBPLguQgZsfbNw6dLAxmCwcr29le3ML24mby6pSkRfiwJDXU9nmxlzX/24WLk5R2rZk6uY6ZHe1Ps+IDSYs4+amOxyOKInUKva2a5nBHVLfOZGF8uE9H25O1BSo5xOukm1uPJBqD2ZZSWtKspl5ujTKvbNPi5iS1edF0NQ3eXtTMU78XoDNZTrg/VycpkyJ9ee3yqX1eCw0HWqOZylYtla0a6uR6ipvUVLZqqGzVUqfQ4SKTEhvoQZBEzed3rQIc4o2DsYNDvHEwJuipr7VTga9o0VDeoqFOrqOwUUVFi4Y6hR4PFxmxgZ7EB3kQF+hJfJAnCcGexAZ6Eujp8qcXdgRB5PUtJby4sbjbChxnmYRvbppLcqgX+fUq8jpiy3PrlBQ0qHCSSkiP8iMpxJOJkb5MiPAlOdRr1JZT90StXEdmZTv7K6xGyIUNSiL93ZkeG8C0WGuFTkqI9zEX9Xd/eZBp0f6smdu3N8bJwGwR2F/RzrrcBtYeaSAl1ItAL1dOnxDGopTgUWEmWdGi4fP9VXxzoAZvNyf+Mj+eMyeF27UCLwgiG/Mb+ee3ObRpuy/97nz/pvdjgtyVkiY1T/6Wz4GKNu5YlsKVs2OHXABT6U08/Vs+24pbeGXN1H5N5stb1Kx5ey8rJ4bx8Ko0u8ez0mY1q1/dyQuXTGH5EK2o5tYpuOjN3ex/YFmvk/G+fGkAHvj+MD7uzty7MhWw+h/d+PFB9j2wrMd9PtpdwYa8Rj7+y6wTbjtSq+Dit3Zz4MFlg068+TG7lsd+zmPtHQsIGcCk5r0dZfx6uIGHV6X1631Z0mRNtXr47DQumxlzwu0KrYkHfzxiTUIb5ghwQRDZW97G7IQAu95zcq2RT/ZU8uHuSsaFenHhtGjOmhw+4ma/LWoDvxyq4/vsOvLrlJw2LpjzMiJZnBoyav1arObAavaXt7M+r4E9ZW34uDuxIDmYBclBzEsK6pfo25V6uY7qNi0xQZ6EnYQJel80qfQdAo1VpBGB7cUtJId4HfWpifJlXJj3KXfNMVDaNUaKm9RUt2nJrVNazYMbVdQp9Ph7OHcINN4kh3iSEOxFSqh3j6bBe8tauer9fehNRxfvJIBMKuHvK1K4YWHisAqZCq3Juggr11LapKGiVUtVm/V7s8qAt6sTsUEeJAV7EeHnTlygJ7GBHsQGWhdmpVKJw/PGwZjEId44GBMMZIDWmyxUtmopb9FQ0aqxCTyerjL+KGjG29WJuI7Wq/hAjy4/e9qVOjOW2FPWyo0fH0RjMB8j4kgkkP+vld1e2JosAqXNagrrVeTUKmwx5lqjhaQQL1ts+YQIH8aH+/Q7reFkotKbyKqSc6DSWp2TXS1nUqS1bHxylC9OiBwob+GJC6cQF2Rfq8DJRBBEcmrkrM21Gh7XK3QsSgnm9AlhLE0N7dWnZSQwmC2sz21kS2ETP+fUc/qEMNbMjOlzcphXp+TsV3dg6aH1TwL4eTiz7q6Fg4pF3lrUzOO/5GERRB45O42FKcFDKvyKosg7263+Jw+cNZ7L+5EGVNWq5bK397B0fAiPnTPB7v1+PlTHA98f5tfbF/RqAtwfVr64jesWJPToOwPw06E63tlexk+3zu9xm8d+zkUmkdgSnLYVNfPYz7lsuvu0Hvd55McjBHi6cEc3pslP/JpHi9rIC5dMsfu5dEdNu5YzXtrO8xcPTPR6Z3sZL28q5pPrZjE5yq/f+1e3abt9rTojwFPDvHnmwsnDGgHeH2rlOt7dXs4X+6uYHOXLTYsSWTTEn52+0BrNrM9t5PfD9WwqaGJqrD/nTonkzElhdpuajzRtGiM7SlrYXtTMjpIW2jRGzsuIJCnEiwXJwaSEeo25had2jZHDtVaRJqdGweFaBQ1KfUdEt1WkSY/yZXy476hYeBhORFGkUWmwtTp1bXdq1RgJ9XFlSWoIrk4yWzVNcohXv9sOW9UGpj2+0fa7i5OUQE8X/nfldCZFDd4sXBRFWtQGqtq0VLRYq2gq27RUdFTUyLUmAjxdWJQShChCbEcFfWygtYI+wI4FVod442As4hBvHIwJhnqA1hjMHYKOlopWq6hT0SHyKHQmvF2diA60ijrxQV62lqy4IM8+TTNPVZpUem786CB59UoMHW1UUf7u7Lh3id330Zn+lFunPKZKJ8LXjWa1kbRwq5jT2X51qvjomC0CBQ1KsqoV5FTL8XSRcVqyP6elDb4FY6TpTA5Ze6SBdbkNFDWqmJ0QyKrJ4SweFzKgaoKuqA1myps1A774K21W8/neKr7JrCHA04U1M2O4cFpUtxOtWz7NZG1uQ4/iDYCzVMK4cG++u3neoKpmzBaBz/ZV8dbWMhKCPXloVZrdHh/2sqeslVs/y2JhShBPnDvJ7klKdZtVwFmUYjXItHe19Knf8ilv0fDKmowhWbl+Z3sZG/Mb+eKGOT1uU9as5s4vs/nxlnk9fvaf+i0fncnCvzo8i347XM9b28r48ZZ5Pd7vouc289g5E05IdbEIInOf3sSzF6azKGXgKVsWQeSy/+0hMcSLp86f1O/9/7etlNc2l/LJX2YNycQIrAsUz60r5PN9Vdx/Zv9Ev+GksEHFW1tL+SWnnqXjQ7hxUWK/KsoAGpV67vvuME+fP6nfY5LZIrC9pIUfs2pZl9tIdIA7l8+MZWlaiN1myiOJwWwhs1LOtuJmWytUapgPC1KCWJgczLRY/1FbGTQQVHoTR2qtEd05tdb2p6o2LRMjfYgN9CQ9ypdJkX5MjPQZE8le/aVZZWDmkxuJCbBWnSR1aXlKDPEa0mvQCQ+vRWO04CyTcNakCJ44b2K/2hgFQaRBqaeiVUNV61FhprPlyd/TBZNFsAozHVUzsYEexAZ4EhPoMehFPYd442As4hBvHIwJRnKAVupM1oqdjmqdihYNZR3CjlxrItDThdPGBQMSaztWkKetJetk9O4PJWaLwH/WF/LO9nLMgshZk8J57fKpg77fVrWB/HoVuXUKcuuU5NYpKGvR2Hx0pkT72ap1RnO6VVfe3VaEu5OMNXMTT/ahDIrqNi3rchsobFDxXVYtk6N8WZEWxvK00AFFkL+8sZgXNhXxwsXpnJsx8M+p3mRh7ZEGPttbxaEaOWdOCufyWTFMi/VHIpFQJ9ex4JnNWOw4xUklcE56BC9emjHg4+lEoTXx8h/FfLKnkounR3PX8r79cPpDo1LPrZ9lotKbefOKacQF2Ze8UyvXsebtPcxJCOTJ8ybZJeAYzBYuenM3U6L9bELJYGhWGZj79Cb+uPu0QVXz/Hd9IS1qg6216sv9Vfx8qJ5PrjuxJQqs48v0JzaS/dCKE6rIdpW0cPsXWey5b+mgPDDe2V7GlqJm/nfltH63Xr21tZTXt5Ty6XWzhiz+Or9eyRO/5qHSm3nhkikkDFMEuL2Iosi+8jY+3l3JhvxGzp8axQ0LE4i38/3blVa1gdWv7aS2Xce9Z6Ry06K+x1hRFDlUo+CHrFp+yanDSSpl9ZQIVk+JZHy496gQtToRRZHCRhU7ilvYXtzCvvI2psb4EebrzsKUwbVCjTZ0Rgt59QqKm9TsLWsjp0ZOWYuGMB83W+vTpEhfJkf5jtpKqJFGFEUMZmFEBLtVr2ynpEnNcxemc3Z6RLfbmC0CtXKdTZDpKtB4uTpxqEZ+XFuTR4dY40lMgMewVko5xBsHYxGHeONgTDBaBmi51kh5i4ZauY6iRrWtWqe8RYNKbybE29XWepUYYj1xdYo7p9LK2eaCJm79PJN/rBjH1QNMU+kLrdFMQYOK3DolNe1a9pS2UtCgQiqRkBruba3QCbeaI48L8x51/7+7PtvP7MQgLpk1PP+fk0GL2sCm/EbW5zayvaSFKH93VqSFsWJCKFOi/OwSBJY9v5WSJjVOUgn/Xj2Ry2ad6M/RX4obVXy2r4qiRhVNSgNrZsVQ0qTmy/3VfaaldWVmnD/vXD1jSFYuy5rVPPFrPvsr2rh9aTL/NyduyPxwTBaBp38v4KsD1fz3onRW2OlfUq/QsebtvUyL9eeZCybbJYJWt2k56+XtPHHepB4v3vvDg98fJsLPnb/2I/nmeF7eVExFq8ZmfvzO9jIOVrbzxhXTut1+Y14jT/2e321b1XeZNVS0avtt5tqVnBo5F7+1m69unNPvdqc3t5by5lZrxc1QCDddI8BvX5rEdQsSRtw7pisWQWRDXgNvbi2jtFnNraclcd60yAG3bim0Js57YyfVbVpMFpG4QA+2/GNxj9uXt2j4KbuWnw/V0ag0cMakMM7NiGRWfOCgFgHy65VsL27mhoVDI843KvXsKG5hR4n1S2MwMys+gPkd3jXJIad+K5TBbKGgo436cEf7U1GjigBPF5aOD7UJNpOifEdNa9+fneJGFV5uTvh7uFDT3tHe1GYVZ7RGCwcq2qhp1yGRQLT/UWEmNtDDJs5EBbifNM+h0TI3cOBgKHGINw7GBKN9gBZFkTaNsUPI0XZU66htbVlao4VwX7eOVCyrgXJyiDfRAe5EB3iMSrM9jcGMq5N0RBMbzBaBshaNzT8nt+NLbTCzbHwoHi6yY1qvTuZK3VkvbOLFy6aRHOZ30o5hONEYzGwramZ9XiOb8huJ9HNnSow/KyaEMjcxsNv3bL1Cx9yn/qDzpOMsk3DvylSuWzA0ps56k4Vfcur5bG8lWdVyJICbswwPFxkuTjLcnaW4OsvwcJbh7mL9u6eLE27OMvLrlbRpjLRqjKyZFcPVc+O6jVnuL9uLm/n3L3mYLCL3n5nKsvGhQzYJ+yXH6g8zJyGIu1ek2PVZbFTqufztPSxODeWfZ6TaNYHdkNfIXV9m8+Ot80gcZAXHrzn1PLeugM1/P23A/4fNBU00KvVc2mHM+872Mlo1Bu5d2X061nPrCmhUGvjPRekDPu6e0BrNrHp5BxdMi+pXFDPAG1tKeWvb0Ak3tXIdd3+VTb1Cz/MXD08EuL3oTRa+z6rl7W3W1LfrFsRz6cyYQaVbqfQmLnpzN2XNaowd6XEyqYTfbl/AuLCjLYrNKgO/5NTxQxfj4QunRbEwJXhIRP5dJS1c++F+DGaB7IdXDKi1Q2Mws7e8le3FLRyuVZBZ2c7kKD+byfDUGP9Rkf43UEwWgaJGldVQuFZBTZuW3WWteLg4WQWayKOGwj0Z5o5F6uS6Uft8NYajCU6VbVpa1QaO1CqpbNVQr9Tj6iQlNqBDmAnyJCHIk6gOwSbCz31UVkSP9rmBAwcDwSHeOBgTnMoDtCiKNKsMNuPkTnHHSSZhY34jRrNAhJ878UHW1qvOFqy4IE+i/NxxPokXeG0aIxvyGmhQ6Ls1Ah0JOuNBC+qVHK49KurUynVE+rmTFuFDWrgPk6J8SQ3zJtLPfdgvnHQGMzOe3MC/zplIerQfCcGn/qppb5gsAgcr260R5HmNyLVGThsXwvK0UBaPC7G1qny8u4Inf8tH1yW9wlkm4falydy2JHlIj6mgQcnne6v4LquWSD931syK4dyMyD6rag5WtvH2tnL+KGjirMnh3LgwgdRwn0Edi9ki8Pn+ajblNWIRRR48K+2YyeZgKG5UcfOnmYR4u/LyZRl2tVM0KfVc/s5eUsN9eOHidLtEnyd/y2dbUTPf/3XeoMrc9SYLM5/YyHtXz2B6XMCA76cr//4lD1GEh89O6/b2NW/vYdXkCNYMQZXX8dz33WFKm9R8fsPsfk1e/retlJ+y63jmwslMiBi8cPNjdi0P/nCEsyaF89CqtJPWoqvQmfh0byXv76zA38OZGxYmck56xKCFCJ3RwiX/201BvdIm3AC4yKRcMy+O25cmsz6vgR+y6thV2kJGzPAYD/+UXcvfvjqEWRBxd5bxwiXprJwY3ud+ZotATq3CWl1T3EJmVTuR/u7MTwpiQXIQsxIC8R/FbUFGswWXHhaRzBaB0mYNOTXyDlNhq5+dq0zKhEgfJkf5MTXGn7RwH6IDhv/8O1ppVhmY8cRGgr1cOW9qJOekRzAhwmdE/x+dCU51Ch0ljeqjLU5txyY4xQZ6MjHCh0BPV5tYE+J9angQduVUnhs4cNATDvHGwZhgrA7QgiDSqNJT3qyxeeyUd1TrVLVq8XCV4e/hQlzHybWruDNcKyEtagPrcxv5NrOGrKp2pFIJ/u4u7H+w55jek4FCayK33irm5NUp0RjNbMxvwsvVibRwH1vSVVqED4nBXkPaWiCKIs/8lkdFm568egUqvZmMGH8yov3IiPEnPdp3zBotiqJIXr2S9bmNbMhrpKhRxayEAJaPD+X7rFoO1ShO2MdZJuG6BQncc/q4Ib841BrNHdU4VayaHG53lU95i4b3d5Tz6+F60iJ8uGFhAvOTggZ1fAqdiVc2FfPxnkoumh7FXctS+p0A0h1qg5l/fpvDgYp2Xrt8ql0VFy1qA1e8s5fEYC9evHRKn+9/k0Xgsv/tISHYk2cvHFwFywPfH0YQxV7jwPvDvd/kEOrr1m3rk0UQmfzoOr65eS7jBynCHc/63Abu/voQv9+xoF9Gt69tLuGd7WV8ct2sQQs3XSPAnz5/kt0tdENNvULH+zsryK1TYLKI3LQogdNSQoYkSlhvsnDlu3s5VKPAaBZOuN3VSYoEkdhAL1ZnRHBOesSwGA+/va2MZ9YW2FoxpRK4aHo0z1xw4vtYFEUqW7VsL2mhpEnFd5m1yKQS5iVaK2sWJAcNWYrbcPPprhLKmjU8tLr7z/2eslau/WA/EyOsLU+dlTVxgZ7DGiV9qmGyCKQ8+DuiaD3niSIEerlwwdQozk6PIDVs8N5LoijSrDZ0VNBoqerqQdOmtfkyzogPwN1ZdoIHjb+H8ykn0PTGWJ0bOPhz4xBvHIwJ/owDtNkiUK/Q2zx1jiZiaalu0yKVSFiSGoJFFI8RdeKDPPud4tSk0rMut5FvD9aQUyPH1Ul6TPXE9Fh/vrl57nA8zSFFb7JQ3Ki2tl11JF3l1ysxCyLjQr2ZmxhIpL87aeE+pIb7DKrE3/aYRgt5DUqyquRkVbWTVSWnTqEjOcSLjGh/MmKsq5KJIV6jsux4sFS3admY38iG3AZ2lbX1uJ2LTMplM6N5tB9x1v1FEMR+TyZa1QY+3lPJR7srCfF25YaFCZydHjEosa+sWc2TvxWwt7yV25ckc9XcwfvhiKLI+zsreG5dIfeuHMdVc+P6/D+2aYxc/s5eYgLceeWyqX0eQ71Cx1kv7+CfK8dx8YyBV7FkVrVz1bv72P/gsiFpY/nrpwfJiPbn+oUnCnP59UoufGMXOY+ePqSfryaVnpUvbufhVWmcm2F/qtyrfxTz3s4KPr1u1qDFpJ0lLfxnfSH+Hi48c8Fkgr1H3sS2uFHFW9vK+OlQHYvHBXPTokQyYoauXctkEbj2g/3sK2+zpRwej1QCT18wmYunRw/Z43ZFEET+9Usen+6txGQ59pI52NuV/Q9YFy4UWhM7S60mw9uLm2lU6pkeG8CytBBmxAUwIcL3lBzjNx6q4fe8Bv572fRub+9M8zsVn9tIM/OJjTSpDMf8zUUmxSKKhHq7csE0q5DTW1KhIIjUK/VUtnRGa2uoPM6LZmacP0gkxyQ4xQVaE5zGaiJqd/wZ5wYOxj4O8cbBmMAxQB+LySJQ066juk1LSZO6S0uW1UzZuuJi7VkeF+bd0ZZljT3vXHlpVOpZe6SBbw7WkFunOEGw6cqVs2P497n9j8cdDQiCSEWrhrx6JSWNarJr5OTWKWlRG4gL9LRV6aRF+JAW5kPIEMSXNyn1ZFXLbYKOzmShtEnN5Cg/psT4MSXa+hU6yFju0cRPh+q455tD6Ht4DwG4OFkTYJ45f/KoW7HVmyx8c7CGd7aXYTALXDMvjktnxgzqQnhHcQv//iUPg9nC/WeOZ3na4P1wDlS0cctnmcyKD+TpCyb1mXwk1xq54t29hPm48drlU/v019pW1MxTvxfwwiXppIYNTHwQRZGlz2/lzmUpnDMEJshXvruXsyaF2zxwuvLp3kp+zanns+tnD/pxOhFFkavf34+vuzMvX2Z/QtnLm4r5YFcFn10/a8D/Ozg2AvyRsydw8fSoEV8t31/RxltbS9le3ML5UyO5bkHCoP2QjsciiNz8yUG2FjX3KNwAyKRwfkYUzw2Dp5HRLHD7F1lsLmjq9hgkEvjLvDj2V8o5XCMnOcSb+clBzE8OYlZ8QL+Tx0Yj+bUtvLC+hP9eNAlvr/6ngzk4yoVv7OJAZXuPt7vIpFgEkTBfN2bF+5Me7QdIukRtawj0dOFApbXtzuZB0yHMjESC06mEY27gYCziEG8cjAkcA7T96E0Wqtu01njzFg1VrRpKmq3CTpPKgI+bEzqTBZNFRCqBvsJ63Jyl/HNl6rClTp0smlR6W3x5Xp2SvHol/h4uVLRoGN8h6IwP9yYt3JeEYM9BVWKYLQJFjWoO1cjJrpKTXS2nqElFmI8bU6L9mBkfQFq4DxMjfU/ZuPkbPzrAurzGPreTSSQsTg3mzSumjagZtr1Y03MaeXt7GaVNKtbMiuWK2bEDNjc2WwS+PFDN8+sLmZcUzM2nJQ66IqNZZeC2zzPxdHHi/rPG9zmpVmhNXPneXgI9XXjjiml9VsM8v6GIX3Lq+OnW+QOuTnttcwn7ytv48NqZA9q/K+e+tpPrFsSzavKJQtBDPxwhws+Nm08beLrV8Xyyp5LfDtfzxhXT7DarfWljMR/uHrxwk1en5M4vszr8VkY2AlwQRDYXNvH6llKKGlRcMSeWa+bGETIMIrMgiFz7wX62FTf3eQ4CcHeRkf3w8iE191fpTVzz/n4O1yp6FY/mJQZy/tQo5icHjSnBvROj0cidnx/k2rlJTE8OPtmHc0pz/3eH+Wxfld3bu8gkzE8OtrY2BXgQG+RJjL8H0QEep7Sh9UjhmBs4GIs4xBsHYwLHAD00qA1mKlo0PL+hkM0FzdgzOLg6SXnlsoyT5rUwkmj0ZgqbVOTXW3108uuVFDSosAgi48N9mB0fwJLxwXi6OpES7I3zIFpC1AYzOTVWIadBoWd9biNNKj0pod6kR/kxOdqX9Cg/xoV5n9QoYHswmgUmP7oOfS8ToOPxcXPi3jNSWT4+dFgmh0NBVlU7b24tZXNBM2dNDuf6BQmkRQxsYq7QGnl1cwkf7a7k/KlR3L0ixS7z4Z4wWwRe3lTM+zsrePbCyZwxqXdTVYXOxP+9u5eJkb48tCqtVwHHIohc+e5eAr1cefnSKQOq+qhX6Fj47GZ23Ltk0BPeZc9v5aFVaSxKOXFiufS/W7j/zPEsHR86qMfopLBBxbmv7eSDa2YwKyHQrn1e2FDEJ3sq+ez62QM2qrYIIm9vL+PFjUXcuDCRW5ckjdjn3mC28ENWLW9tKyPAw4UVE0K5bGbMsPh2aQxm1uc18NRvBSe0l/SGm5OUly7L4PQhOg81KfVc+vYeWyR5byxMCeKja2cNyeOOVu79+iAL4v1YNX1ootH/DIiiSLvWRGWrhqo2qwfN7rIW9pS29XltJZNKuHNpMn9dnORoRxsEjrmBg7GIQ7xxMCZwDNBDT1mzmr9+mkl5i6bXVUeAUG8XpFLpMVHn8UFexAd5jNqo86Gis+2qqFFFdbuOtAD4YG8DDy6LIzZm8C0hXWlQ6DlUI+dQtZxDNXJyqhUYLQITI32ZkxhIUrAXk6J8iR9lRpHbi5u57sMDJ7yP3JylSACdScDNSUpskCcTInxwdZIiCCKlzRqyquVMjPRlRVooy8eHkhw6+pK7yls0vLO9jG8za5gRFzAoc+PyFg1P/pbPntJWbluaxFVz4wb1+Vl7pIF/fH2IS2dGc+/K1F6rmVR6E1e/vx93Zxlv/9/0Xkvvm1UGznp5O7ctTebK2bEDOrZ/fptDUojXoKPiZz+5qVujZrnWSMa/N3DggWVDYgxtMFtY/epOlqSGcM/KVLv2eX1zCd9l1vDa5dMGLNxUt2m5++tDNCn1vHDJlCH1lOkNpd7EZ3ureG9HOT7uztywMIFzp0QO+Yq/ySKwo7iF77Nq2ZDXSGygB4tTg/FxdcbZSUp1u5ayZg3VbVqaVAa0RgtOUgkuTlJEUcRgFhBEWJIawntXzxjUsRjNAl8dqOLRn/JsxsR94eYk5fBjp496EX0wPPXLIYK9PLjutKFNBTzVEQSRBqXeFrFd3a6lokuohMpgJsjLhZgAq/eMk0zCj1l1GC3dX1O5OkmJ8HPj9cunDbnB+p8Rx9zAwVjk1Ky/d+DAwbCTEOzFz7fN5+VNxbyxpRSLIHa7WiSVwPe3zKOmXW9Nw2rVkFkp57vMWipaNRjNAguSgxFE8RhxJy7Qk+gAj1P+glcqlZAQ7GVrX/gjpxInCUMu3Fgroop44KzxttVlQRApa9FwqFrOkToFH+yqsEW0TozsSP2IslboRPmfvIjWrUXNtpQYd2cZcUEeTIzwZXy4D8mhXiSHePdoot2iNvBHfhPr8xrZWdJCnVzH8rRQlqeFMS3Wf1SsSsYHefLEeZP42/IUPt5TyR1fZBPi7cr1C+M5Jz2yX+/x+CBP3v6/6ewssfrhfLq3ivvPHM+KAfrhrJwYRkqoFzd/ksmhmr28uiaDEO/uK1283Zz58NqZXPv+fq75YB/vXT2jR8+OYG9XXrksg6vf3096lC+To/z6fWyzEgJ4Y0spf5kfP+j3po/biceZXS0nJsBjSIQbgOfWFuIsk3LnshNTrY5HFEVe2FjMZ3sr+ey62aQMQLgRRZFvM2t4Z0c5GdH+vH/1jBFpm2xQ6Hl/Zzmf7q1ifLg3T543iSWpQ5Mc1YkoimRWyfkxu5bCBhVVbVrOmRLBd3/tOxVMbTBT266jVq6ltl1HdbuO8mY1kf79b10UResYur2omR0lLewubUUUofNs5yKTIJVIeq0aFEQ4VC1nelxAvx//VMHPy5U2jf5kH8ZJwWQRqG3XUdNubTfvFGoqWrVUtWkxWwTCfd2JC/IgJdSbSVG+rJocTmyHD03X1tLiRmvyWHc4SSVcPTeOv61IGdMLXg4cOBgcjsobB2MCh7o+vGRVtfPXTzNp0xhPqJ6I8HVj131Lu92vM+q8qlVLafNR0+SKjpQEiyAS5e9OXKAnkyJ9CfJysUWeR/q5j0rPk754a30Ru8vq+OCm04b0fj/eU8kjPx7B3VnGS5dmsCyt+zYQk0WgqFFFTo2CnBoFh2vlFNSrmJNobfHojHGdFOVHhK/biAg61W3Wi9zkUC+CvQZu+Kw1mtle3MKGvEb+KGgCYGlqCMvTQlmQHDxqTBo7zY3/KGgkv17FNfPiBtRmYhFEvtxfzX/XFzIvKZCbFiUNuC1LazRz/3eH2VnaymtrpjIzvueJptZo5toP9iMI8N41M3r1tXl9Swmf7a3i19sW4OvRv+enNZqZ8fhGPr9h9oDEn754fkMR1W1aXrhkyqDva0dxCzd+fICfbpvfp4eQKIo8v6GIz/dV8/n1s0juJTmmJ9o1Rh744TD7ytt49sLJLEkdmrav3ihpUvH1gRre31XBopRgblqUwLTYoRUkSpvV/JhVyw/Zdci1Rs6cFM7q9AhmJQSOWLWgXGtkZ0kr24ubaVIZ2FHSwqz4ABYkB7EgOdgW2aw2mMmtVXC4VsHBynayq+XUK/Qd0eTYBB0nqYSbT0vk7hXjRuT4RwJRFBHEowlSX+4t41C1nCcvnHqSj2x40JvM1LTrbFUzla1H05tq2nVIJbA0NRSD2XJCelOUv7vdYoveZCH1obXH/M3VSYqfhzOvXz51yD9vf3YccwMHYxGHeONgTNB1gP5icyYTkhMI8XEl0NN1VKzMjwW0RjOP/JTLD1m1x3gAzEsK4tPr+t/vbxFE6hXWi6XyFjV1Cj2FDSqriXKbFokEov09iOuIOU8J9epIxfIkws991L6uW/PrePinAjxcnUgM8WJihA8pYd6MC/MZlFjy4A+H+XRPFSLgLJNw0fRoHu7Dm6QTvclCYYOKnFoFh2vk5NQoKG5S4+fuzKQoXyZH+toqdcJ8B2a8O9JYBJGDle1syGtgQ14jDUo9qyZHMDMugCXjQwblFzOUx9hpblzUoOKyWTFcPTeu3+bGSr2JD3dW8NqWEs7LiORvy8cNKBZaFEU+3lPJU78V8MBZ47l8VkyP70ed0cL1Hx1AZ7LwwTUzehSeBEHkLx/ux91Fxmtrpvb7/f2Prw/h4SLjsdUT+/18+uLKd/eyPC2U/5sTN6j7adcYWfnSNu5YmsKaWb1HpIuiyH/XF/HF/mq+uGEWSSH9F262FTXz968PMTnKl6cvmDzs7+UDFW28ubWMbcXNnDslgusXJAxIcOqJRqWenw/V8WN2HYWNKpamhrB6SiSLU4NHpMLAZBHIqpKzvbiZbcUtHK6RkxLqbRNrZsYH2B1ZrzaYyatTklMjP0bQmZcYyKdDmGg2kmiNZtu5N6tabvVyq1fx4qVTbF5RW/Lq+CG7jhfXdB8XfiqgNpit/jOtWio6qmc6q2jqFXp8PZwJ83GzmgN3FWgCPIb0miPjX+tp15oAq/B34bQoHj47bUwkk40WDGYLzSoDR4rKOGO2NQnVId44GCs4xBsHY4Ku4s2Ch79CKfNFrjUhk0oI8nIh1MeNEG9Xgr1dO352I9TH1fY90Msh8tjLHwWN3PFFNnqTBbMg8pf58Tx4VtqQPobZIlAn11Peaq3SsfruWNhd2kp1uw6ZREJ0gFXIOdqK5Ul8oCdhvm4n3e+lUaHjSIehcZ1cx97yNspbNHi6OjEu1JvUcKuYkxrmTUqot12JNee+tpPsarntd1cnKeG+brz9f9MHNNHSGS3k1Ss5Umut0ClssJovB3q5kB7lR3q0H+lRfkyK8rU7UedkIYoiJU1qdpW28n1WLYdrFWRE+3W0V4WOaCJPTxysbON/28oGZW5c2arhqd8K2FHSwq1Lkrhm3sD8cA5WtvHA90dIDPbimQsn91hZozdZBRyV3sxHf5nZYyx6u8bI9R8dYOXEsH771+wpa+XmTw6y9/5lQ+qlIggi6f9az2fXzWZSlO+A70cURf76aSZmQeR/V07rVZwSRZH/rC/kqwM1fH79bJJC+ve+05ssPP17AV8fqOahVWlcMiN62CrjBEFkU0ETb261JkddPjuWa+bFDVlakkpvYl1uIz9m16I2mHFzknFuRgQrJ4YP+3giiiIVrVq2FzeTX6/i50N1uDlLmZ9kFWsWJAcNqQm62mDGIoinxDhZ066zGe13fq9o1eDn7szytFC83ZwZH25NUkwO8bZ9JnPrWnllfQkvXpqOm9voNJAHa1VVV2Gms4rGx82JzYXNeLs5EdchzHSKNHGBnsQFehDkZfXuG27OeWUHR+oU+Lg789KlGd0arTs4EVEUUerMNKn0NKsMNKkMNKsMNlGu8/cmlQGFzoRUAt4WJTnPrQEc4o2DsYNDvHEwJuiuNFJvstgG8ial3vpdZaBRqadRaR38G5V62rXWQT7Iy5UQH1cyov0xCwLBxwk8Id5uBHm5nJKtPENNq9rAXV9ls62ohSfPm9TnavRQYrIIHeXNVlGnslVDeauWihYNbk5SKtu0thWz+CBP68VZkAfxQZ6Eep88YUdvslDSpKawQUVho4qCBhWFDUoalQaWpIYgiCLjwrwZF2oVdJJCvI5ZDZ786DqUevMx9ymVWMvaH1k1gctn91xFYS8ag9km5mTXyMmpkVPdpiMhyJPJUb7MTghkXJg3aRE+o7onv0mpZ2N+E+vzGthV0kp0gDvL08JYnhZKRrTviFyg90RXc+MzJoZz/tTIfpsb7ypt4d+/5KMxmLn/zFROnxDW79e+VW3g9i+yaFDoefOKaT0KgHqThZs/Ocj0uABuWdxz3HZWVTtr3t7LJ9fN7FfpvyCILHxuMw+elcbKiUOXWFfcqOLsV3dw+NHBGcl+m1nD1weqeW3N1F69c0RR5Nl1hXx7sIbPb5jdZ2vV8RypVXDnl9l4uznxwsVTiAvyHPAx94bJIvB9Zi1vbStFbTBz7bx4LpsV06Mw1x+MZoFtRc38kG01Hk4I9uK8jAjOTo8gfJgr+hRaEztLW9he3Mz24haalAZmxPtzeloY0+L8GR/mM+Jjf71CN+zPuyeUehNFDSryG1QU1CspbFBR2aahXWMiKcSL1DBvUsN9rEJNmDfB3r23szY3t/LQbyU8uCqZqMCT19ojiiItaqPNc6ayVUNdu46SZjUVrVoUOhOBni4nVM/EBXoQE+iJv4fzSTe8f2ljEcVNap44d1K/W03HIiaLQIvaQJPScIwo0ynSyKQScmoUNKsNGM0C7s4yQnxcbQuyUX7u+Hq4EOzlSrCPK8Ed1/IBHi401Nc52qYcjDkc4o2DMcFg+loNZgstaiONSj1NSgNKnZGqNp319w6Bp1lloFVjRCKBQE9XUsO8cZZJbMJOsI8bod6uhPhYfw/ycj3ljXj7QhRF/ihoYnpswKi5ADGahY60B+uFnfW7VeSpleuYEOGD2WI1To4N8iC+o2onLtCzR8Pc4aZdY6SoSWUVdTq/GlVoDGbigjwZF+pNfLAHr28u6/E+XGRS5iUF8sIlU/DzcBnS42tVG8ipVXCoWk6j0sDaI/VoDBbGR/iQEe3HlI6v2ECPk35R3B1qg5ltRc1syGsku6odjdHC0vFWn5y5iUF2t0sMNa1qA99n1fL6llJCvF25YWECZ6dH2D1uWASRrw9U85/1hSQGe/FKL0bEvd3H8xsK+WBnBU9fMJmz07s32TaaBZykkj4nv+/tKOd/28r49fb5/TIJfn5DEfn1St7+v6Fryfgxu5Zthc38dxB+N5WtGs56eQevrsngtHEhPW4niiKvbS7lqwNVvH/NzH4JNxZB5M2tJfyYXcfZkyO4+bTEYV0gMJoFrvlgH6unRLJ6SsSgRVir8XA732fV8mtOPR4uTqyeEsG5GZGkDGHr1fFYW6Ha2V7UzPaSVnJq5CSFeNkqa2bFB540DyyzReA/6wt5c2sZ3/11LlOHMR3MbBGoaNVQ2qzhcI2CggYl+fUqauU6QrxdrQJNmDfjwrxJDfMhMcRzQK+5KIpc+sY2nr0gg9jQ4U1B6kxw6qyaadcYOVyrsIk1WqOFMB83YgI9rKJMgIetAjcm0GNIhEgHg0MURdQGM41Kg1WY6VhEbVYbaFYaaO4QawK8XNhd2opEAgEeLgR3CDIh3m4d312J8HPH38PZ+ruPW68ebMfj8LxxMBZxiDcOxgQjMUAbzUKXk5CORpXRWtGjNNCosn5vUhlo1RiYHOlLTbuOkI52ra4VPMHeboT4uBLm40qQl9uQx66OJGaLwPbiFtblNnDfGeNHjYjTHQazhZo2ndUwudM4uVVDRYuWOoUONycZsYEezIwLwMPVyZaIFRfkSUgfq5JDjShaL14LGlQUNag4VC3n9yMN3aZ9deIik+DlZjU9nJ0QOKzHVtWmJbtaTlaV3OqRUKfE01XGnMRAxoX6kBFjbbsabW0EJrOF/ZXtrM9tZENeI+1aIwuTg1kxIZQlqSFDLnzZg85osSYKbS/DYBb6bW6s0pv4dG8Vf5kfP2DBeENeI3/7KpsLp0Vx3xnjBzwmdbYYaYwWPrh6ht2VDpWtGpY9v5U99y0dsmSo+77LwcfdmfvOGD+g/c0WgYve2k16lB+PnjOhx+1EUeTptQX8kFXL59fP7leLXnWblru+zKZNa+SFi6eQHu03oGM9GRQ3qvghu5Yfs+tsVQ7nTolkeqz/sFS4iKJIZUcr1LZiayqUq5OUlRPCyIj1Z35SEGG+J7+dp16h48aPD1LYoEIU4aFV47lykJ5LYH3+zWoDBfVWgT+/wVpNU9ykRiqBZeND8XCRkdrRjjsuzHvIPkudLHt2I29eOZWk8MFX3nQmOFV1Lra0aKlqOzbBKbIjzCAj2g9vN2fb+ywmwGPUmNP/2TBbBFo1RppVBto0RuoVOmvFTGfljPpoxYzeJBAX6IFZEG1VMl1FGasY40qwlxuBXi7DsuDpEG8cjEUc4o2DMcFoGqC7loB2Vu5Yy0D1NCqtJ7ZGpYFgLxfy6lUEeLocc2IL7SgHDfN1J9jbxXayO1kVAt1R0aLhy/3VfL6vCp3JgsEssOnuRf1uFRgt6E0WqtqsF5F1ch2FjWprWXaLhjqFHndnq7ATH+TJuDBvwn3dbCXZna1Yb28uYPGEMJJC/Ib8+D7fV8W/fs5DZ7LYtX1qqDd/W5FCcqg30f7Dn9plMFvIq1OSV69kb1kbWdXt1LTrSAz2IiPaj4wYfzJi/EgJ9R413lKiKJJfr2JDXiPr8xoobFAxPc6fs9MjWJgcTHSAx4geT/fmxrFE+I3McVS2arjpk0w8XGS8tiZjwMbVSr2Js1/ZwUXTorh1SbLd+/39q0NMjvYdtLlwJ6e/sI27lqcMuBXrhQ1F/H6knp9und/j2CuKIk/9XsBP2XV8fsNs4u1sdRJFka8P1vCvn/M4LyOS+88cf0pMRhsUVuPhH7JrKWlSs2x8KKunRHDauJBhWYRQaI3sLmtlW7G1HapRYWB6nL+tuiYtfORboXpjc2ETt36WicEkYBasl9aXTI/mmQsn9+t+NAYzRY1WkaagoxqzUamjvFVLbICHtb027GhFTWyg54iMq4//nIPRaOKx8+03Jq9q1ZLfoOwwCbaGEVS2aqmVW73rkkK8CPN1Oya9KS7QmjY5mha2GpV66uQ6pkT7jcoK08GiMZiPaVfqrEbv2sbUrNLTqjEiiuDv4cycxECUOvMxYszxlTM+bk4n9f81muYGDhwMFQ7xxsGY4FQcoDtXMJq6CDpNKr2tvBTgSK2SZrXBZoYY0rFSEertRrCPK/GBnni5ORHi7Wa7bbgSC3RGC78drufD3RUcqVXgJJVitByNDT/86Ip+RyGfCuhNFqrbtB3+OlratEZyauS2ip3ZCYF4OIFgtvDAmckkRfbcXjFQHv0plw93VfRaeSOTShBFEYlEQoCHM4FerpQ1a0ACCUGepEf5EenvTnKIF8mhXsQGeg5ra1+L2kB2lZys6nayquQcqpYjAisnhBHq62YTdQaSmmQPDQo924qbuWhalF0Xj7VyHRtyG9hS1MyO4haSQrxYkRbK8rQwJkb6jOgFaKe5sVJnItzXnesGYG48EHRGC4//mseeslYeP3eSLV6+v+TWKbjozd28c9V05iYG2bXPF/uq+GRvJb/ctmBAj9kVld7E5MfWs+e+pQMy4D1Y2cYV7+zj25vn9vh/F0WRJ3/L55ecej6/frbdHjVtGiP3fZdDZpWcZy+czOJe2rFGA0q9iU15jXx9sIZ95W3MTghk9ZQIVk4MG/Lx3mwRyK6Ws624hR3FzSj1ZiRgFWtSgpgVHzAqE3lMFoFnfi/gg10VNtGmk3Fh3qy7c2G3+1lbnqxpizk1CptQU9WmJcDThXGhne1OVn+alFCvk/r8m+RqHvwuh0umR7F0sn0+d//+JY9dpa3EBngQ21HNav3ZkzAft1Ej5vfFSxuLeWFjERF+blw1J44LpkWNikTD3rAIIm0a4wkGv80qAxKJ1Wer8+9aowVnmcTqG+Ntbf0P9XHrUh3jaqskD/JyHVXCWm+cinMDBw76wiHeOBgTjOUBuusJuFPo6azqAZHDtUrbaonJIuLl6mQzcwv1cSPYy6XjpOt2TIWPj3vfKyKiKHKoRsGneyr56VAdEgnoTcIJ2znLJBQ9fsaYXJHqDYPZQm27jnaNgQhfd8L9h6dK4oI3dnGwsv2Ev7s5WQW0cF93zk4P5/QJYaRH+dlWo80Wgep2HcWNKmratRyuVVLcpKKkSY3ZIhIf5ElyqBdJId5WUSfEi/jggXki9IVFEClusraAHay0CjolzWoi/dytlTnRfmTE+A2ZGfKrfxTzn/VFLE8L5aVLp/Rr0qPQmdhS2MT6vEa2diSULBtvTa6anRA4YheuXc2NZ8QFcMPChH6bG/cXURT5bF8Vj/+Sz53LkrlhYcKAHu/zfVW8taWUL2+aY5eAotSbmPH4Rn66dT7jwgbnlbKzpIV7vslh5z+X9Htfld7EmS9v56o5cT0mZ4miyOO/5vPb4Xq+uGE2sYH2CTebC5u455scpsX48+T5kwjwHPk2PXswmC1sLmjmx+xaNhU0sXJCGJOjfDk7PWLI0qg6qWzVWCtriprZXdqKs1NnKpQ1GWo0tEL1Rq1cxw0fHaCkSY3BfOK50cVJSv5jp9OqNdpangoaVBQ0KCluUiMBlqSG4OHiZGt3Sg33Jtjr5Hiw9cV/fskht0nN+9fOPdmHMqJ8vKeSJ37NQ28ScHOSYrKILEgJ4qo5cSxMCR5REUprMNOi7l6UaVLpEUXIq1fSqjFiEUR83JxOaFmKDfLA08XpmL/5jQIz56FmLM8NHPx5cYg3DsYEjgHaavIn15mOEXda1QbqFXrbSd1a1WNAZ7Lg6iQl2NuVmfEBaA0W2wk8xMcVNycZmwub2F3WSqvaCHDCimJXgr1d2f/AspF6qn86Mv61nnatCQB3Zxl6s4XxYT6snhLBiglhdrdrdCIIIrVyHcVNKoob1RQ3qSnp8E44VKMgPsiTlFAvUkKt6VfJod7EBXoMefuVQmcip6bDO6eqnaxqOYnBXgiiyNSOVqupMf6E+7r1+6Ly8rf3sLO0FRcnKVF+7nx47cwBtUIZzBb2lLWxIa+BjXlNJIV44u/pyvK0UE4bFzwi5pitagMf76nko92VAzI3HgiHquX89dNMJkb68NxF6f1+nqIo8tCPRyhuVPPpdbPseu/c/nkWYb5u3H/mwHxqOnn1j2IKGlS8umZqv/e9+6tDNCr1fHTtzG5bckRR5N+/5LP2SD2f2ync6IwWnvwtn8zKdq6eF8eFdlaDjSSCILK3vI0fs2v57XA9vh7OnNthapwUMnTGwwqdid2lrWwvbqZZZWBzodX0fkFKEAuTg0ddK1RvbMpv5LbPszCahV7PjwlBnpS3aogJ8GBcqHeHSONDarg3cSPU8jRUFNbLueDNXRx57MyTfSgjytojDfztq2y0xqOtyxKs4py7i4zLZsZw2YwYYgIHtoBjEURaNQZau7QrdfWRaVYZaOkQaGICPShsUNkSUoO7fA/2cSPUy5Wgzt9HWcv9SOOYGzgYizjEGwdjAscAbT+dKQCdqzXtWiO17bqjseoqPbl1SuQdYoE9JId48evtC06ZUtpTCYPZwrgH1+IklTArIZBz0sNZkho6LO1Gotgh6jSqKWy0miUXdQg8oggz4v0J8nK1lfKPC/MhYgDCSm+PX9GiIavDDDmzqp2CBhVBXi5kRPszNdbaajUhwqfXShpRFJn46Do0BuuFtkwqwc1Zytv/Z38bT0/3m1OjYGN+I+tzGylrUTM7IZAVaaEsSwsd9ljg482Nb1mcxOopEcPWrtimMXLHF1nUtOt484pp/a6I0RjMrH5tJysnhPH308f1uf3Womb+/vUhdv9zyaCEwms/2M+8pCD+Mj++X/v9driej3dX8sIlU7qt+BBFkZc3FfP1wWo+u26OXRO1Q9Vy7voym0AvF/57UToxdlbpjBT59UrWHqnn6wM16M0CqyaHs3pKJFNjhsbbw2wROFQjZ1uR1bemUxxekBzEopRgZo7SVqjeMFkEHv8lj0/2VmHpRbQBq5H831eM44o5safc8+yO/Lp2Xt5QxKtXTEcm+/OIAgcr21nz9p5uq6vAKuKYLQLp0X5cPTeO0yeE4eokRak326pimtUG2jVG24JapyhjNf81IIgwI9afNq3RVhFz1EPm6M9Bnq4EeLqcMiLnycQxN3AwFnGINw7GBI4BeujZUdzC377Kpl1rxGTpfZjwcXNCqTfbzJc7e6M7W7dsLVzejpWggXC4RkFiiOdJu/i3CCLVbVpKmlTk2Ur/lZS3aPB0dTrGm2F5WtiQtjpojWYO1yjI7KjOya5ux2AWiQ30sPnmTI3xJzrA3TbZrGzVsPg/Wzh+XuUklXD/meO5Zl7ckExMq1q1rM9rYENeIwcq20kL9+Gc9AjmJweRGuY9bNUVnebGn+2rJKtSzmWzYrhmXtywiEcWQeSljUW8u6OcJ8+fxOopkf3av7hRxbmv7eTVy6f26e9iEUTmPr2Jpy8YuBeMKIpM/fcG3r16Rr8imusVOla+uJ2nz5/EGZPCu73fx37Os/7fr5/VZ8WN2SLw2uZS3thawu1Lk7lxYeKoqbColev4MbuWH7PqqGrTcsXsGOYkBrIgOXhIqrmqWrVsK25mf3kbfxQ24SSVMD85mAVJQcxPDiLCb3hFzqFGqTdZx7x6JfkNKr45UI2xj3NiJ84yCbcuTuKOZSnDfJQjQ01TG/9eW8yTZyURGDh8qYajjeo2LQuf3dyr79zxOEvBJICrk9RWGZMQ7IWbs5Rgr2PFmWBvVwI9XRzXRkOMY27gYCziEG8cjAkcA/TwoDdZeGljMW9vL0MQxRMmw51cMSuG25YmW2PTO9K1Ok2YmzvatdycpBysktvMlzvj0zvFngg/NwI8XWxiT4i32ymRwPJnRm+yUNKkprBBRWFHOspdy1OYMoyRx53VQZ1iTmaVnLw6BT5uzmTEWMUcndHMuzsquk3ncpFJOXNSGM9cOHlIvX3aNUb+KGjicK2Crw5UE+jlwvLxYSxPC2VGnP+wJX51mhtvLmxm1aTwYTM3/qOgkSd+zee0ccHcu7J/ceLfZ1mTlX69fUGfE/enfs+ntl03oJYngIoWNee/sYvd9y21+/UVBJEr3t1LpJ87z12UfsLtoijy6E+5bMxv4osbZvfZflfeouGuL7NRG8y8eMkUJkb6Dui5DCVyrZHfDjfwQ1YtmVXtzEsK4tyMCFakheHpOjhRWKk/2gq1vbiFOrmOabH+nD4hjOmxAUyIODVaoSyCSEWrhoJ6Ffn1SgoarBWoByrbCfVxtcZwh3uj1Zspb9WQX69CrjPhJJX0WJEBVk+b966eMYLPZPhQqVTc830efzs9ieTQsSPeiKKIUmemWa0/Mfq6o41pZ2lrn/cjwVrpedakMO5YlkKwtyteric3cenPjGNu4GAs4hBvHIwJHAP08FLUqOJvX2VT3HiiKaOLTMqdy5P562lJfd5Pp/ny0QjKoylbJotIQYOK5g7xxyyIeLs5dRFzXEkO9cbVSXpMNc9wJmw5ODXQmyzk1imtvjkdok6dQt/j9q5OUhKCPfngmplDbsDaeTy7SltYn9vIxvwmzILAknEhLE8LZWFK8KAny91R1qzm3R3lw2puXNWq4eZPM3FxkvL65VP7Velz33c5FDSo+PKGOb0KP8WNKla9soN9DyzD173/7WDfZdbw8e5Kvr9lnt37/G9bKZ/ureLX2xfgddxrI4oiD/+Yy+bCJj6/vnfhRhRFPt9XzRO/5nHR9Gj+eUbqSV1J15ssbMpvYkNeA78dbiAtwodzp0Rw1uSIQbddtmuMfLi7gh3FLWRVy22tUAuSg5gVHzgs7/GhpF1jpLhJxZFaq0jTmfQEkBJ6NOFpQrg3KWE+3ZpLi6JIcZOaTfmN/Ha4niN1StycZCeIxmE+buy5f+mIPK+R4JaP93LV7CRmJo9+8cZkEWjpaE86VpQ5VqSJDnBnT1kb7s6yE3xkQnzcCPZy5YEfDvdahewsk7BsfCj/Wj1x2FIUHfQPx9zAwVjEId44GBM4BujhRxBEvthfxb9/ycciiLaYcA8XGY+dM4GLpkcP6WO1a400qbpU8ij1GM0ChY0qm/Fyp+jj7epEsI8rEb7uBHg6d4g7bh2pW9bvoT5uJ0zMHIxNlvxnC2Utml63kUrAy9WJD6+dSUY/2mv6iyCIZFXL2ZDXyIa8BgQR4oM8WZ4WytLxIYR4D6141Glu/PHuSsaH+3DBtEhWTR46c2O9ycLDPx5hU34Tr1yWwdwk+zyE9CYL572+i3mJgTy4Kq3Xbe/8Mos5CYFcMsO+OOKuPPTDEZxlUh4+u/fH6CS3TsGFb+zm0+tnndBmJQgiD/90hK1FzXx+/WyiekmTa1YZuP/7w8i1Rm5fmsyC5OB+H/tQYBFEdpe28kN2LWuPNBDs7coVs2JYMj6038bmvaHQmXjg+8MsTA4e1a1QJotAeYuG/Hol+fXWds+CehUNSj0z4gLwcXNifLi1oiY1zGdQxuwKrYmtxc2sO9LAlsImjBYBUbSa/ef/a+WYqSS969P9rJ4axWnjT2wvHAmO9+1rUxupV+pt6UtHk5cMtGmMRPm7ozNajvOQ6Zq+2fHdxw1PF1mPgvfsJzfRoDxxUcDVSYqfhzP/uSj9pH3uHXSPY27gYCziEG8cjAkcA/TI0aTS89APR/ijoAmTRcTdWcabV05jUcrIX7SIoohca6KxI2GrWWWgQamnyda6dbS6x2gW8HCRsTA5iDatydaaFerjahN5Qn1cCfZ2w8fN/jLn538+jJOrlNtXTBjmZ+vAHnRGC2mPrKU/Z7aZcQGcPzWSqbH+JAV7DWuLR1mzmvV5jWzIayS7Ws7kKF+Wp4WyIi2UxGCvIauU0RrNfJdZazM3vnZePJfOjB4yc+Mv91fx6E953LY0iZsXJdp13OUtGi5/Zw//OmcCy9LCetzuw10V/HSojm9v7n8c8apXtnPTokRWTY7oc1ud0cLZr+5g1eRw7jzOk0QQrGlZ24qb+eKGOUT2Ik5syGvkn9/mMDsxkCfOnYifx8hGgIuiyJFaJT9k1/LzoTpE4OzJEZybEcGkSN8/TctGi9pgbXeqV5HfoEShNbG9uAWZVMK4MG/Gh/swvkOkGRfmPaDKLnuxCCLZ1XI25jVyoLKN966eMWzG4iPNPV8eYF5SIKun9c8QvC/MFoE2jdEmyjSp9GgMFipaNcdEYjep9OhNAi5OUoK9XMmI8cNoFjoqZToXbY6KNIFeLkMiXq96eTtH6pS236USkEok3LAwgduXJjv8akYhjrmBg7GIYxnagQMH/SLE2423rpzOlsIm7vkmhyaVgZCTVCIskUjw93TB39OF1J7ngrZ+9iaVnma1gQbF0XatnFoFTfl6W5WP3iQQ5uOGs5PkqCdPVxNmn6Mrdv4eLjQqdEQHjuxkzUHP5NTIcZFJe04FkUmRSKyTq6QQL3zdnEkI8eT7rFoe+zkPJ6mEKTF+LEwOJinUi4xovyGdjCcEe3HTIi9uWpRIs8rAHwVWIeeljcVE+LlbhZwJoWRE+w/K4NbDxYkrZsdy2cwYNuQ18r9tpby8qXjIzI0vmRFDWrgvN396kKwqOf+9uO848fggTx48K427vjrEL7d592j6e056BE/8mk95i6Zf1SJao5n8epXdlVRP/Z6Pj5sTty4+tuVTEERe2FjEtqJmvrxxTo9VJWqDmX//nMdvR+r59+qJrJ4SMaJCSWWrhh+yalmf10hlq5bTJ4Tx34vTmZMQOGweS6MBg9lCWbO6o5JGZauqaVEbiA30sLY8hflw5kRfHlqVRkyAx4h77sikEqbF+jMtdviq+k4WHi4yFDqjXdt2Vsl0TVzqWhmjNZgpb9Uek7jk5+Fsa1tKCfXGzVnG1Bj/49qZ3PBxH1kvmTBfN5t44+okZVyYN89fnE5SSP9S+E4Ffsyu5bl1hfxlfjwXTY92VC07cDCKcHwaHThwMCBOGxfC1n8s5vcj9aSEju6LF4lEgq+HM74eziT3cqyiKKIymGlQ6GnpUrnTpDRQ2KBie3EzzSoDoT5u7CptxdvNCSkiz0ycPILPxkFvZFXLj/ndWSZBKpFgEUQmRPqwZFwIcxKDSI/2PcHQ1mwRKGhQkVXVTnGTms/2VVHRahUQMqL9yYjxY2qMPymhXkMyOQ72duWSGTFcMiMGrdHMtqIWNhc0cuNHBwFYOj6E5WlhLEgOGvCqrkwqYeXEMFZODLOZGy96bgtnTQzj+kUJpIUP3Ex3UpQvv9w2n7u+zOba9/fz73MnMj68d7PkMyeFs6+8jVs+y+Sbm+Z2+7z8PV1YnBrMd5k13L2i74jxTg7XKAj0dCHCjrQziyCiN1l44ZIpx7yWgiDywA+H2VXayhe9CDcHK9u568tsIvzcWHvnwl4rc4aSFrWBXw7V8UN2Hbl1ChalhHDb0iROSwkZcyv/oijSpOqopulMe6pXUdqsJjHYCx93J1LDfFg5MYw7l6UwLszbMckcAZoUWgwmCyVNKlrVRlrURlrUBlrVBpo7fm5RWxd1thY1W6tkZNIToq+j/N2J8HXnXA9nq6+MtytBXi5DaiQ/lET6uSMB3F1kPHJ2GhdNiz4ljLgHglJnokGh55m1BTzzewGXzozhL/Pj+zRrd+DAwfDjaJtyMCboWhpZXFZBYlzMn6ZU/FTAYLbQqjaOWl+EgaA3WWhWGahsVjO/S6xxdZuWTfmNx1TohPq4jbmJ1Wjl+g8PsDG/EalUwoQIHxaPC2FuYiDp0X4Deg3aNEayq9vJrJSTVd1OdpUcEVg2PpQof3cyYqyiTpDX0FWfmS0CByvbbe1VTSo9C5KDWZEWytLxod2ap/aHsmY1X+2v5oPdFUNibiwIIu/sKOOljcU8ft5EzsvovTTdaBa46K3dTIr04fFzJ3W7zfrcBh77OY/t9yy2e4L0xpZSDlXLefPKaf1+DmB9Hvd9d5i95a18fsPsbquTjGYLr/xRwjvby/nb8hT+Mj9+2CdwGoOZ9XkN/JBVx86SFqbG+LM6I4IzJ4bjP8j3wmhBb7JQ3Kgmv0FJfr0SudbIlsJm5DoT8YGeVl+aDhPh1DBvovzdT+o5PquqHXcXGalhQ5/sdjIQOnzs7BkjH/g2m02FLcQEeFIr1xHk5UKQl6v1y9uFQE9XgrxdCfV2JdDL5aRUyQwHG/MaWZfbwD/PSCVwCMf70ch3mTU8+MMRtEar+baLTIpZEFiYHMzNpyUyMz7glHg9q6uriYmJsf3saJtyMBZwiDcOxgRdxZvImz/A3d+a6OLV9cvN+t3HzQlPVyfb7d5uTni5Ottu93KV4eXmbNtvMK0Lf3Za1AY+3l3B+zsr8HZzZuc/l5zsQxp2DtcoeGlTkc1U2dlJQnWbDm83J5vPTrCtFcv6e5ivK4GeVqHH1935lLgoGq0crlGgNpjJiBmYWNMXFkGkuElFXp2S3aWtZFXLKW1WE+3vwdSOqPKpMf6khnsPic+CKIoUNarZkNfAhrxGjtQpOSc9grRwH5anhRI3CBNa6+ezko92VxDm684NC+MHZW68pbCJO7/MZtXkcB5aldbrCnp1m5ZVr+zgX6snsHpK5Am3G80Cs5/axKtrMpibaJ8p8g0fHWBarD83Lkrs97ELgsg/v8thf0U7n18/m7BuqndKmtT8/etDBHi68I/Tx/VZZTQYTBaB7cXN/JJTz/rcBiL9PFidEcE56RG9GiePdkRRpE6uO9ru1FFRU96iwdvNmdQOb5r0KF8Sgr1ICfUeVUa/Cq2Jf/2Sy7eZtZwxMYw3rhiYUDhSWASRVnVHBanKYG0XVhpsPnGdlaUtagP/NyfOLqNvQRAwmgXcHCmPY5b1uQ3c+WW2TbzpRCqxVnNGB3hwy2lJrEoPH/JKKYsgojGa0RjMqPVmtEYLKr0ZtcH6pTEc+7NEIqFBoev4mwWN4ei+ipYGql+/GnCINw7GDg7xxsGYoKt4k1NQgk9QmHUg7zLgqw1m6wlAb7IN8Mf8vWP7xBBPdpW22gxPPVxkJwhAMQEeGC3CCX/3sglCzni6ymy3ebs64+Ys/dNMyvPqlLy1rZRfcupxkkowmAUi/dz/FOLN8VgsAu06U5dYUr3NeLHTfNHfw4XtxS3oTJZuy8s7q3eCvTpTMayrnEOVIDTSGMwWTn9hGxfPiOb6BQmn7PPoRKE1kV0jJ7Oynaxqa1S5ySIwPymIxGCvDkHHj5AhiCVvUOjZVNDIutxGdpe22JKrlqeFMTnSd0BVIDqjhW8za4bE3Li6TctfP81EKpXw+uVTe20n2pTfyB1fZPPDLfNICvE64fZHf8pFpTfz34vT+3xcURSZ+eQmXlszlZnxAf06Zosgcu+3OWRWtvNZN8KNKIp8tLuSZ9YWcMXsWO5ekTIsrR2iKJJZ1c4PWXX8ergeNycpZ0+J4NwpkcMqFA0XGoOZwkYVBV1SnvIblHi6WBdNOqto0jrSnsJ83EbtOVIURX7OqefB7w+jNwkYLQLpUb78eOv8k3I8ZotAi9poM+RX6kxUtmlp7hBjGruIMoIIgZ4uBHm5dFSEdiQwdni4hfocXVRwVIg6ANhV0sJfPjxwQux9V9ycpbjIpFw9N45LZ0bj4eKESm+2CS+d19Vag6VH4cXfw4X8BiWazm305mMe08NFxoQIH1rVxo5F16PX450LsP6eLrjIpEf/5mZdhPV0dULZ3MisyVYzeod442Cs4BBvHIwJhtpRXhBEtCZLh/hjsp6QDBbbz0azNRVBbewiEHURinzcnClqVKE2mG3GqZ3RxJ3CzsRIX1rURrxtJyTnDqGnywnIxVoF5Okqw9u1QxBycxqVPeEWQWRTfiOvbynlcK0CCdaI1E7GhXqz7q6FJ+8ATwE6jR27CjxNKgMtKj2NXQSfVo0RiQQCPFxsIk9auA9SqcRm6Ng1CtVzlPlAVLdpWfjsZlycpIT7uvHCJVOGNa57pBEEkdJmFZlVcrKr5WRWyilqUhHh627zzcmI8WNChC8uTgMXrlR6E1uLmlmf28jmwibcnWUsSwvl0hnRTI7y6/f9WQTRZm6sM1pYmBLM1QMwN9abLDz2cx7rcht4+dIM5if3XDnz1O/5bClo5odb5p1QYXGkVsHFb+1m/wPL+nwPV7dpufnTg3x1wxw8+vF+twgi93yTQ1ZVO5/fMJvQ4wS2RqWef3yTQ2mTmv9clM6cxEC779teihtV/JBdy4/Zdaj0Zs6cFM65UyKYERdwSnhqCIJIdbvWFsXdqjayvbiZyjYt/h4ujA/3ZnyYj02sSQrxOqVEguo2Lf/45hCZlXKMlqNG6BG+buy6b+mQPpbJItCi7qyQsY77Kp2JylatTahpUhlo1RgQO0SZYG9XpsX6YzQLhPocTVvq2ro7Gq8ZHJxcDGbrNa7mOHFFZTBT0qTitc2lWIT+TRElEvBysV6/ero64evujLuzDM8OMaXz+tazo+rd390ZZycZ3m6dYozMJsp4uAy+8t2RNuVgLDK6rugdOBglSKUSm7oPg1stN5qFY1YbOoUeg9lCu9Z0jOjTqNBTesx21iqhzt87T6TOMuvxTYv1p6Zdd+yKQ5cTp5erDH8PF1ycpHi6HF2p8OhYvfB0dcLDWTaoCYJKb+LrA9W8ubUMhc7UY8qPl5tjuOmLzvdcXwk7nRf4zR2tWU0qA3qThdJmNSVNaqvwo7Qma5ksIp4uMkJ83BgX6o1MJrG1b3Vt3bKmZ41My1az2oCLkzURqrJVy0Vv7uai6VHcd+b4PhOLTgWkUgnJoT4kh/pwyQxrv71Kb+JQtYLMqna2Fzfz8h/FpIX7oDdZOsQcf6bG+vVLKPF2c2bV5AhWTY7AaBbYV97GhrwGqtt0AxJvupobZ1a28VaHufGqyeFcvyDB7uoPN2cZT50/iakxftzw8QEeOGs8l8+K7Xbbf6wYR027jup27QnG5xMifFiSGsL6vIY+fXSyquVIkPRLuAH46VAtWdXtfHHD7BMqo347XM/93x9mybgQXr1zwZC+NxsUen46VMvWwmYOVLaxbHwYD69KY9G44FE90TaaBQ7VyK3mwR0tT4UNKowWgaQQb8aHeTM1xo/laaGkhnsT7OU6aqtp+sJsEXh7eznPbyhEFI9djABo15rsvi+jWbBVXjYqDdYKmY7x2yKK5NUpaVLpadVYU5wCPV1sFTKxAR6E+LgyMcqXkI4qzBBva/XlYMRfB6ceoijSojYee03ZUe1iXWQ0I5VIqFPoOtqHLKg6RJmu+4T7upFfrwKs437XynFPVxk+bs4Idgg3MqmEhCBP/nF6CvOTg3F3lp2yn3cHDk4VHJU3DsYEY01dr27T8uX+ai6dGW3zNxBFEYNZOKbKR2s0n9gLrD/a96s2mHGWSahp13Vsf/TvnSJLQpAnjUo9Hl1O3B4uR8tSPV1kRPq7Y7KIx1QFKbQGfjpUT1aVHKkEjJbeh5LTxgXzwTUzh/1/N5LodDq+3V/GFQsnnOxD6RZRFJFrTbbUrBaVkQal3tau1bV9S20wMynKl1aVgeCOFq1jo1ldbYkgwYOcNKw90sDfvjq2n95FJsXdxTrpP2Ni2Ji/ABRFkbIWDdlVcjKr2smqklPQoCTUx81WnTMl2peJEb4n1VuirFnNuzvK+TazhhlxAdy4MJF5SYF2vz65dQokSEiLGFjbz/+2lbKlsJnPrp/d63aP/ZyLRRD51+qJ/bp/URRR6sz4ehwVZpQ6E4/+nMum/CaePG8SZ00OH9CxH49CZ2LtkXp+yKpjf0UbsxMCWT0lgtMnhOHjfmqIlnKtkRUvbLMaCNsqarxJCPIaU0LCoWo5d36ZTZ1c1+OCBED2w8tR6c00KjvFmI7vKgONSj2eLk7sq2ijraNaMsiroyqmiwgTHeCBr7uzrWrmVG6JdTC8iKJIyoO/AxzTOtR1AS8mwAOjWbAt4Hm5OnfTbnTU29HV6cSW/kalnllPburxOFydpAR4uvD4uRNZkhoyas/XY21u4MABOMQbB2OEsTJAH6lV8OofJWzIa0RA5K0rprFiQtiwPJbJInT0IpvQGi0d4o/F1q+s6WL+1ikAaYzWv6n1JoobVagMPfdDH09CkAcz4wNP9Ag6zi+o0yPI01U2JHHMw0llbS2LXsmm4umzTvahDBqt0dzFl8cq7nS2bR39rifc153DtQr8PJxtJfldTZhDfVwJ9Or06nHDx+3ElJGPd1fw5G8F3fbTO8skzIwP5JkLJp3SxqwDQWMwk1OjIKsj3aqmXUtps5q0CF8yov2YGutPRrTfSUnaOd7c+KZFCZw5KXzYJ5lNSj3znvmDLf9Y3Kt/zrmv7eTquXGcm3Gi+XF/2FPWyj++OcTMuAD+cXpqt8bF/UFnNLOlsJkfsmvZXNBMarg3q6dEcvbk8CHxQHIwtKgNZp76LZ8v9lcjCCJ9XSAHe7vQpjEd267a2bbk7Ua4r5tVsPFxJdDTZdSf0xyMbhQ6E8+tK+DSGTFMjPQdtsdRG8xMfGTdCX93kUmRyST8fXkKV86JG/WC7ViZGzhw0JVR38fw3HPPceedd+LsfGqsSjlw0F9EUWRnSSsvbiwiq1oOiFhEcHeR4TqMvgDOMim+HtJjVpz7y56yVh74/jA17b2vTgIEd7TpqAxmatt1tmqhzlJftcFMoKcLufVKm1m0u7PM5gPk5eZEdIAHJrNwgvjjbROBnPF1c8Ld5ago5O3W/crSUBDoa18KzqmAh4sTcUFOfaYXmS0CrRrjMYbLnT8frGzHbBEobFTTpNKjNwm4OklPMF+ubNViMHcv/JksInvLWlnyn63cvcIaxfxnmfB4ujoxJzHQ5qsiiiLVbboOMaedd7aXkVenxN/ThYxoa7LVjDh/JkT4DnsiT5CXK3ctT+GmRYl8k1nDb4frefr3gkGZG9tDiI8b85OC+D6zhluXJHe7jd5kIbdOQUaM34Afx2C28Pz6Ij7eU8m9K1O5cnbsgNtJLYLInrJWfsiqJa9eidpgZvWUSO5ZmUpi8InGzA5GBlEUUehMtnYlW7VMZwuTQs/+yna7789FJuWp8yezZFzIKeFN5ODUp7pNy6d7qvh8XzUZ0X7csSyZ+UlBQ35943HctWen98zFM6L4+4px+Hm4DOnjOXDgwH5GvXhz77338tZbb/Hss89y/vnnn+zDceBgyDBbBH470sBLG4uoatNithy3yidaS1NHM7MTAtlw1yK+zazh8V/z0Zss3Yo4MgnMiAvgbyvG9XmfoijaKoFUx5hBm9AZBeQ6o81UT6EzUSvXodZbf1frzUT6u5NZ2Y7KYDWWBnCSSo4RfLw7f3Zz7igrPhoX7+3qhJ+HM67OsmO27SxP7mqgt7WgdOj+macITjIpoT5uJxi7Ho8oikcNmI+p3rFOmnprp7d6S4g8/XsBL20q5uq5cZw2LsQmAI02A+bhQiKREBPoQUyghy1OW2e0cKROYU22qpKzpbCJA5XtjA/3JiPa6puTEe1PbKDHsAiW7i4yrpwdy5qZMWzIa+CtbWW8vKmYNbNiBmRubA8XTIviv+uLuGVxUrfPKbdOibebMzEBA6vUKmhQcucX2TjLpPx06/xuk6/6QhRFjtQq+SG7lp8P1SGIIqsmR/DEeZOYHOmDVDq6x/JTGUEQadUYj7aCKg1ojWbKWjS2KsLGjqpCo1nAw0Vma1sK8nYl1NuNSZG+hKSGkB7tx97yNnLrFLjIpOh7WZRwkkkwmgWHcONgxHBzliKTSjALIgcr27n2g/3EBHhwx7IUzpwYNmQLHVKpBBcnKUazYK2GjQvgsdUTBzQ2OnDgYGgZ9VfAMpmMsrIyLrroIubPn88LL7zA1KlTT/ZhORjF3PPNIQJDm3FzkuLqLMXVSYarU8d3ZyleLk7IZJKjf3OS4uYs69hWevT3zv067mOwrvedaI1mvtpfzaubS1DpzT1WrAiiOOrFG7Ce5C+aHs2Zk8J5fXMJ/9teBiKYuszOZTKp3RNuiURiSyMIHWQ6rsFssSYp6M2oDFZzaFUXcz9buoLeTHW71uYlFOTlypE6xTFm0p14uFjTEFJCvDhY2Ta4AxzDSCQSvN3+n73zDm+rPPvwfY62ZUnee8fZe++EsPeeZbRQOmjLKG1pSwfQ0vLR0jI6aSlldEBpwwwQdgYJkL2c4STeWx7a+5zvjyPJ8kpsx3Yco/u6fEk685UlnfO+v/d5fo8Gk15DSbdog501/Z/ddvtD/GdLNa/urKfF4cMfUgZfy0rT6HAHOqN6zF3TtzJMOpIMGlRjLGrHoFUxvyiF+UVKOWxZlqm3eaNizrObqrinfjcmvYbZ+UksLkllSo6ZmflJQyp6KebG2Zw7LZutlW38ZZDmxv3hzMmZ3Lt6D9urO5hb2LMq2Y7qduYUJA1YrJIkmb9trOC37x7iy8uKueOM8QNOA6i0unh1Zz2v7qqjyeblnGlZPHLVTJaMS/3cRIwNFxFj9ogpe3O4/LXbH6TC6opG0LQ4fYQkGbNeHa2wNC3XjF6jYl5RcnRZpAJT4jF+B5eHu5etTh+v7Kjj2c1V1Hd4gJ6GxZIs02z3Dtv7jxOnOzq1ilA4NFlGiVQ90uLiey/t4udvlPGtVeO4el7BkERiJoUrRT142TSWj08/4eOdKLIsE5QU70dfeKLQF5TwB2OfS/iCIXwBCX9Ior62/mQ3O06cIWfUize7d+/m7rvvZu3atWzcuJEFCxZw44038otf/IKcnJyT3bw4o5C5hckYU8z4AhLe8EVcqYKkVORRCQLtnkCXi3/kYu8LhihKNbK71talJCgo0RuKmKNiRq6FqjZ3VOyJCEOR9QlaFWpR7CL+6NQir++qp7zZCbKSGnUsJFkmEG6bVjU8aT9DiVGn5nvnTuL6RYU8+EYZ75Q1EQp7BqgESNSNfAUV5f+uIsV4YiG+vZWOd/uD7KtNpbyxY2ga+zmi2e7rc51WJRKUJKbkmPni4iIumJFNQtiwNzbtoc3pp8HuiQ7sDjQ4WH+oJTrz7vAFKUxJwBeUoh4U6d0qbEWMmE/lqi2CIJCbZCA3ycBFM5V7opJGZGdHdTt17R6e/riCRruXiVnmLqXKS9KMQ3JdmVeUwryiFI6EzY0v/cPHXDEnj/OnZw/I3Lgv9BoVF87M4X/ba/sQbzoGXGre5g7wtX9spb7Dyz9uXcDcwpR+79vi8PHG7npe3VlPICSRbTFw91kTOHNy5ilVAvtk4Q2EohEx3U1+mx0+dGqR7VXttLk7Ky9Ff7smHTlJBpaPT+9RLW8o//epiTq+vLyEW5YVs6fOxj8/rebVnXXh9it9A39QotnR97UsTpyhRqcW6c2p1BeUaHH4eOjNA/xq7SFuXVbEl5YUk3wCfZ83bl9GStinKVIwwx+Son1lf7T/rIgpnesk/KFQ5/NIHzv6vPN1kkFDdZsnvG+o1+0zzXrKmx34glKP965ViZRmJNLs8KJVKf1vnVpEG+6bh+ytg37/ceKMVk4Zw+I333yT73znOxw8eBBBEEhISOCee+7hu9/9LgbD0Idpxzm1GA5TMkmSu9yovIHYG0rkdc91EcU/kkLkCyjrvYEgb+1rxB/s/08u06yjKTzQjQpFGlX4JiVSnGqk1eXvsTw2qijDpMMTCMXc0FTRG1vk9VlTMk/4/9WdHdXt/OjlvRxucSJJMr++asZxy/3G+Xww84F3sHm6ltmNRLxdMz+fa+fn94jWGSgef6iL6XJkgNgSM0hMTtCw+WgrsgwpRm1nZa0YE+bcJD3JCdro7P2pmrLVaPOyo7o9Wtlqd52NBK2KWflJLClJZXI4OmcoymFbnT5e3FLDUxuOkm0x8NUVJVww48TMjbdVtXPz3z/jsx+d2WOQ/vePK5hflDIgA8+QJPO3jUe5fmFhvz5Tpy/I2r2NvLqrnk2HrcwtTOaSWbmcPz0r7v+AIqw6fMGuv7MuAo3yPMWoZUtlOypRiDH5VYTVTHOnyW9qolIqOzVRO2oqL3kDIdbua+TZTZXsrOkA4MIZOTxx3eyT27A4Y5rYiJMmu5czfrPuuPuIghKZk5ds4PLZuUgyXSJWNCqRNpe/s98aK8JEBRNnFxGlOwtLUthfb+8mmKiifVVtTJ9Vp+qcyIwuV4skJWgJSXKP/bvsqxbQqnueQ6sSj5uyGDcsjjMWOWXEG4BQKMQf/vAHfvazn9HW1oYgCOTk5PDQQw9xww03nOzmDRvV1dU88cQTrFmzhurqanQ6HaWlpVx99dV84xvfICFhaCqyvPDCC/z9739n9+7dtLe3k5WVxfLly/nmN7/JokXHLtMaobW1lSeeeIJXXnmFyspKZFmmuLiYSy+9lDvuuIPU1NQhaWt3TpULtCzLfHCgmQdeL6PJ7j2uye/au5aTlqjrJUJIeR4MyXgCoR7LY2dEDBoVzQ6vsj7UKS5FQk0lGV795tJhe7+v727gkbUHefSaWb3Omsf5fBGSZEp/9CayDHq1iD8ksXx8OjctLmTlhPQRTzUJhCTaXP4uA82WmBQNtUpkV01HNGXLqFV1ijtmHflJBiwJ2mgUQGRdcoJmVEfL+YMS+xvsbKtqY0+dja1V7dS2exifkdjpnVOQTGl64qA9PTz+EP/dXstTG44SCErcsqyYa+YPztxYlmVe2VnHedOyRzS6ZXdtB0+uP8p7ZU2UpCdyyawcLp6ZQ84xKl+NJSRJps2t/D7a3T7qOsKCqN0bU5nOFzUoL80wKtFupq6pSrHpjBlmPSkJ2lPaK6amzc2LW2ooTE3gqnn5J7s5I47TGyBxmEzKRyORyJPukdrebv2uLhN5sek9gRAalUhrWDCJbhfePzLZl5ukZ3+jI3r8yLpIxp5eLeAdwASgWhQ4e0oGlgRdTKS4iEmvQRCIEVI6bQK0KhVatYBeo+pdUFGr0KiEUX1/i3CqjA3ixBkIp5R4E6G9vZ377ruPP//5zwSDQQRBYO7cuTz66KMsXTo8g9CTxZo1a7j++uux2Wy9rp84cSJvvvkmJSUlgz6H1+vlqquu4o033uh1vSiK3H///fzkJz855nG2bNnCJZdcQkNDQ6/rc3JyePXVV5k3b96g29oXp9oFOiTJrN5eyy/f3I/b37vJL8DWH59JWqJuhFs38oQkmY8ONjMzP+lz8X5PZbyBEG0u/6AHr05fkOn3rSU7Sc8XFxdx+Zw80k2j/zPvXqkmIvQ4vQGq2jzKYDYc0eP0BdGolMiCdLOeWXlJBCUpKuzEpnukJY6e8sHNDi87qjvYUd3B9up2dtd2oBFFLpyRTbpZz+yCJGbnJw040iQkyVFz48NNTr6wsIBbl5ecEp/75iOtbChv4dLZuUzINJ3s5gwbkiTz+PvlYfGyM1rG6vQRlGRMejVLS1PpcAd6fIc7hUs9Zr36lBjUxTkxLvvDBv7whbnkJA/N5OFgaXf52d9oj05YxablRJ5rVIISZRLolvYTfi6KYHMHu4gu/m6TZbMLFCPrCKJAjLihCBpZFj1ufxB9NI0+xlNRLaLXiFRY3UzJNpGo13SJpo4cw6gLp9xreooqOrUKlQDT7n/nmP8TJaJFw08unML507JPaZH0RDnVxgZx4vSHU1K8ibB///6oHw4ouf9XXnklDz/8MEVFRSe3cUPArl27WLJkCW63m8TERH74wx+yatUqPB4PL7zwAn/9618BmDRpElu2bCExcXBpBtdffz3/+te/AFi1ahV33nknOTk57Nmzh1/+8pccOaJU1PnrX//Krbfe2usx6urqmDt3Lk1NTajVau6++24uvPBCAN544w1++9vfEgwGyczMZNu2beTm5g6qrX1xql6gvYEQf/+4kifeL0cKz+zEsuf+s4etBO9oIBiSeG1XPY+8c5D6Di8PXT6d6xYUnOxmxTkGL22t4Z7/7ubCGdl875xJFKQOvPPeaPOSadaN2UGe2x+MRiS0OHzYvQGq29xR0Sci8rS5/AgCpCRoybLoSU2MiU4IRyhEyqtnmHQYtCObshUISRxsdFDWYGfzkVZ2VLdT1eamOM0Y9c2ZnZ/MxCxTvw3dI+bG3z1n4pgWQ05FfvTyHiwGTZfvXiR9cLhL0feHT4628sT75Xzn7InxKM6TzIWPf8h3zprEqinZJ7Udmw5b+cHqPTFRI50ehBEPlGyLHqcvGBVDYtN2IqJKb2k5PbbVdKYEDUZwf3VnHXe+sBOTXs03ThvHjYuLjmme3Rfjfvhm1LQ4lkj7v3f2RK5bWDBq0g1PJqfq2CBOnGNxSos3Ed5++23uvvtuDhw4gCAIaLVa7rrrLu69915MplO3c7hq1So++ugj1Go169evZ/HixV3W//rXv+aee+4B4IEHHuCnP/3pgM+xbt06TjvtNAAuuugiXn75ZVSqzk6a1Wpl7ty5VFdXk5yczNGjR0lKSupxnC996Us8++yzAPznP//hqquu6rL+pZde4uqrrwbg5ptv5umnnx5wW4/FqX6BtrkD/O6Dcp7ZVIkgKBUEAA49eN4pa6R6LPxBidXba3n0vUN0uAPh9C6R+y+eyjXz4+LNaOb5zZX8fM1+ZElGAi6fk8vdZ00YlhLRY52+qulERJ+WmDSuOYVJ7K93kN7dfDkS9ZCoeIakm3RYDMOXstXq9LGzpjM6Z1dNB0admtKMxKiYM7sgidR4BF2cIWJXTQcPriljR3UHMvDQ5dO5+nOYqjSa+Mozn3DB9FwunRv/HPrL67vq+f7/duP2Kx6EKlHgq8tLuHlZMRZD/yfpJv74rS4TfVqVCAJ8fWUJX1sx7pT1ZRsOTvWxQZw4vTEmxBtQ/HAee+wx7r33XgKBAIIgkJ6ezs9+9jO+8pWvnHIzvFu2bGHBggUAfO1rX+PPf/5zj20kSWLatGns37+f5ORkmpqa0GgGFqVxwQUX8Oabb6JSqaisrOz1wvbCCy9w3XXXAfDII4/wne98p8v6pqYmcnNzCYVCnHPOObz99tu9nuvcc89l7dq1qFQq6urqyMwcOpPcsXKBru/w8PDbB3h9Vz2yDEcfOv+U++4eC18wxEtba3jsvfIeZdITtCoeuHjq59I/4FTi7x9X8PDbB6IVV7QqEUmWuX5RAbefPj6e9jYMSJJMm8tPizPWcFkReqL+PA4fkiRT0+5BqxY7zZcTO9Nb8pL1JCVoo6kukUoiJ0JIkilvcrC9uiNqiHzU6qIgJSEanTOnQInOic8ExxkIBxsd/PLN/Xx82Ioky0iycp/4yYVT4hGaJ5nvvLiVVRMzuHBW/HPoL2/uaeC7L+3C7Q9Fl+nUIoIAtywt5ivLS/pVHWrafWtx+oKow9GO18zP59tnTYjfe3thrIwN4sSJ5ZSVZ2VZZt++fWzZsoWtW7eyZcsWdu/eHfXAkWWZ5uZmbrvtNv74xz/y+9//nmXLlp3sZvebV155Jfr85ptv7nUbURS56aab+OEPf0h7ezsfffQRZ511Vr/P4XQ6ef/99wE466yz+ryoXX755ZjNZux2O6tXr+4h3rz22muEQqFjthWU6Jy1a9cSCoV47bXX+MpXvtLvtn5eyEky8Pi1s/nGaaV8fNg6ZoQbbyDEvz6t5ncflOPxh/D24fEjjpH3O5YJSbJSxiKMP6R8lv/+rIZ/f1rDLcuKuW3lOCwJYzfdb6QRRYE0k440k47Jx8lScHav+BMWdyqtLmrb3OyqtdHs8NLuDiAKkGLUxfiX6PjqihJKM/ofsaoSBSZlm5mUbeYLC5WBnM0dYEeNUtXq3bImfr32IJOyTAiCEI3OmVOYRIZJfyL/ljhjlEqri4ffPsA7ZU2ATCjmdiHLEJTGxJzjKY1GVEcjhOP0j94ySyMTWH/bWMFTGyq4cXEhX1857ph+YBqVgACcOTmTH54/icJU4zC1OE6cOKORU0a8KS8vj4o0W7ZsYefOnbjd7uj62AAiQRCYPHkyGRkZrFu3jt27d7Ny5Uq+/vWv89vf/hadbvSr0xs2bADAaDQyd+7cPrdbuXJl9PnGjRsHJN589tln+Hy+HsfpjlarZdGiRbzzzjt89tlnBAKBLhE+kbYe7zjd2zpc4s2tz27BmFKNKCjfBZUgIIqKMCAIAhqVUkNREAREQVkeWS8KAhkmXdiLQlmvEoWu2wpg1qtx+aU+1+s1KoKSHG2DKAioYtogCmDUqfEFpS77RbZVBlVaXt9VBwioxJ7rRUFArRKQ5c79ETrfR+f7B2L2EQQQiPmf0O1/Edkm9jUgiD2PHbsPyKhEsUtb3f4g/9hcxe8/PKxUYjhOdS1xDE7MN9m9fP0f21CLyueoUSn/o8hrtSiSk2Sg1eVDLQqoVaLyKIqoVUJ0mV4tRr+/GpWIRqWs14af6zUioiCgDee9a1Vij+calRCuFCEOulpESJLprcseKSX6948reGZTBbetHMeXl5cMKqc/zuBJ1KlJTE88bql1XzCE1envIfRoVSfubWJJ0HDaxAxOm5gBKJFDR1qcihlyTTuPvnuIQ80OciyGaGTO7IIkpuZYxmSaaJz+Ud/h4TfvHOSVnfUIhIXiHsiEQse+j4wGIuWdA0GJkCwTkpTX0ceQTFCSCEkyIUkiKBFeLxGSiK4LhsVyXzDyWiIYUo4TiGwTktGoReyeQHidRECSCYYkAuHzCAi4/aHo/v6QRDAkKW0MKcvOn57NLcuK+/X+LAlqAqHjbxenk2NNTkVEnOc3V/HspkounJHNzUuLyUkyhKPO5PB3Reabq0rJTTYwPiMRX7hqoCTLSBJI4bFQUFIqiUqSErEWOUbkObJMMLy9HLM8JMnhPiX4Q3KP9bHH06lF3P5Ql+PKMeeUZZlQt/PK3dqUlKCh1eknFDmPRHR7Obxvol5Nhzug7BtuY+x6i0FDq8sfXR+7v7OteUQ+2zhxRpJR36s+66yz2Lp1K3a7Pbqse6ZXamoqCxYsYNGiRSxatIiFCxdiNpsBJf3onnvuYd26dfz5z39mx44dvPvuuxiNo1up3r9/PwClpaWo1X1/TJMmTeqxz0DP0f04fZ3nnXfeIRgMUl5ezpQpU3ocx2KxkJWV1ecxsrOzoxE8A23rQLhuQQEpGdmdF3Ep5qYRvZmEL/y93NgMGhVJCZqY5eGbUMwNQ60SEQSlUxYMyj1uKDqNCpcvGD2vsk7ucnPJMuupbff0vLHFtEWnFsPHoesNNPy6ICWBo1ZXz32lzu3HZRg52OgEut6AZZRZTLNeTZtbufHFHiOyHmBhcUqXSgu9fr4WHQ0236A/N7c/xF/XH+WRtYcQRRTRLSwkKYKQIlrIyFERTBUrVoXFpYKUBOo6PNF9xF62STJocPqCiDHbxIpwZr0Gtz8UFaIi26mEztdmg4aXPz3CzUsLuXzh+D7fV6JOza3LSrp0uiOd9GC4463TiFgMykxmpFMeDMn4gxKukNJBFwRw+ZTOtz+odMgDIYlAUNk+y6znSIsTf7hShj/UWTXDH5KQZZiRZ2F3bWflOm1YxFGEHZFUoxZvUIqKS4p4pGwTEZ4c3kA02qY3Ip3Qx94r5/H3y5mea2bZ+HRF2AsLjlq1iM0dIMWoRRUWsVRRMUt51KlFZFn5XNQq5f+vFkVEEeVRICp09bZ/7HemxzpB+FxX4ADQqVXkJhnIHYGS16IoMD7TxPhME1fPV0LYHd4Au2ps7KhuZ0N5Cx8ebObTijam5ZiZXZAcFXSyLfoxE4H4eUYKX/eCoZ5iRk27m7+sO8r7+5sQBKEP0UYhKMkcaHTw1p6G6P6BkNRDHJEkCX/M9TYYs00wJGHSa7A6feFrrhRzrM7XaYla6tq9XUSSYMx126RX0+LwdWlDQOocZEPf987Y62uGSUeHJ9Dj+hV5XZhqpNHm7XFdjn2dbTHQ7vYron94mSZ8fdRrNGjVAmmJuqjgr1YpkwJaVedEQWlG/4te+AIS6rDO++GBZuo6PF3Wa0QRv9IRifYlIn0S5bWMQaPC5Q+G+x2dwkNsvwx6Cg8RAUBG6b+0uwM9Bu1yTF/JYlDT5gp0OYYkdW6foFHhCPfXYkWBTiFBpjDFyBGrM9q22D5dRKAwatV0ePzR/SLbRL4PmWZdl5Sp3ojcW1/ZWc8rO+u7rBMESE7QKn2XcL9GFe4jiWLkucDMPAtlDfYe/SdB6OxXpSVqlejLbpNykeeZFh1Wh7/X9ZF+UrbFgNXpi5no67o+tn/V2wSl8v0TSdSrlT5YdN/O/YXIZGhI6nLs2P6aVhSRkHtMbgoCtDVr6d3IIU6cU5dRL95E0noiqNVqZsyYERVqFi1aRGlpaZ/7z58/nw8//JCnnnqKb37zm3z66ac88sgj3HfffcPd9EHj9XqxWq0Ax83PTE5Oxmg04nK5qKmpGdB5Yrc/3nkiOaOR/WLFm8hx+pNLmp+fz759+wbc1tra2mOujy1PfsbkTPLycgZ0/Dg9kWWZjYet/PadQ3x5aTH/uHVhN5Eo3JGK6ahEOmURgay8ycFT6yvYdNSqzKQeI8parxE5Z2oWi8el9Zjh6dJJ6m0mKaYjplEJePyhrtt020ctingCobAoF3ss5bVWLYY74xCQZKSgFF0XEfI8/hB7mn3c/fKhY4o3Rp2aC2ac3IockTb7gooo5AuFCISUWeFAWOQJhKToDGxk1jYySIkVnj440Mwe7IR6jb/pdl7AG5BodwcIheTooK3F4WXj4VZSjVpK0o0k6tTKgEuWo+fJSTJQ2eqKdnyVAVnnAE2tEnD5QuF9lFnGzpls5fOeX5TMlsr2XtsmCMoAqjjNSF27JywSiWGRSIiKRgXJCTTavT0EoFghqSA1ocvgqjcx6ZeXTY+LEDGY9BqWjU9j2fg0QPmOVra62V7Vzo6adv740WEONDpIS9QypyCZxeNSuWlx0clt9CCJfG8luWfUReT73FV86PweI4OvizjRXQRWfoe+YIiQRBchIvKoUQk4faHOdaFuUSCSRHKClka7t9v6rseS5BhxI9Sz3eMzEtlbb+vlHMrvE2BSViIHGp19/7PkY19XgiGZ3XU29jc6Yn6LPaMaDRqVcq2PEXiVR6VqUIJWRYZJh6pbhGPnsZRjyNApkogiKpWApptw0j1KMvb60WNZWHg+1a8FKpWAiPIedtZ0sKdOmRSITK5aDBpsnkB0gA2RqN/OgXWWRU+zw9c5sKfr4F8ID/DlcCRIl2jgcASxICj36z4FBEEgQasixajrMbCPvNaoRCToIjJ0n/DRqUVWSRldJ3PEmMjqGKEkduJIFd1W4N2yRh59t/yYd05NOJr68jm5fOO0ceQkJXSJZo4zMGpr46l9ccYeo168ycnJ6SLUzJs3D71+4Hnyt956K/X19dx///28+OKLo1q8cTgc0ef9Kf8dEW+czmN0iE7wPLGRSt3PEzlOf9va2zGOR6x4FGf42VrZxs/fKKOswY4kQXW7e1Bmo7lJBk6bmEGl1cUj7xzkrT2NCELvngWiIDAuI5EFxSlD8RZGhCfXHz3ZTegXQjjipdOcdvB+NHUdHt7b30RfPVB9OFXrW6tKuX5RYa+VL/67rZYtle20u/3sqA4wLdfCt8+awIrxaUPWQZUjQpDcu/gTkpUBpj8UigqD0QFpZJ9QzIA7PGDtfN15fLUo4PKHCIUFr66DdDkcORXveB8LQVCEtOI0I1fMVSYC3P4gu2tt7KjuoNk++Ki+7nx82Mobu+t7iCCxYkaiTk2ry9/jexNZn20xUNXq6iGUxAqJM3ItbKlq71OPUIlKlElPYbBT/JuWa6G8ydmnKKgWRTLMOmzhyA2V0CkcqMJRGBaDBm8g1EXA0Kq7pm9aDBqSErRdhIcexxOUa0hE3Igcv1PIELudv2s7I4NQjbqrmBEIhVi9vY7H3ivH5gl0MbLvjkYlcsH0bL65qu9JuzjDj1oU8IWjRL591oST3JpTgw3l1j6Fm4hoc8WcPO46cwJZlrgfWJw4cXpn1Is3x4u4GAgXX3wx999/P5WVlUN2zOHA6/VGn2u1x3eej3j4eDye42w5+PPE+gR1P0/kOMPZ1jgjw55aG794s4ytle3RSBqdWjxmGHt/KEoz8vsvzOFws4NfvX2Q9w80092IEpSw2Tijm0hKXXf0ahGjTs2dZ4zn6vn56DV9e6dE0rB8QeV4O2s6+MqzW8lLNvDtsyZw/vRsVOKJfRcEQUCjFk5Apho7yOGICSXKKhT1vPAHFU8MJbUuhD+obLNiQvrJbjIACVo1i0pSWVSSisMbYNNhK0tK0074uHqNUo0rEnXRPdpKJQro1SKSTBcRpHuUhxK91VUE6fE8HHURPYeqc70I4RTcz/d1TyWq+cLCQq6el88buxt45J2DtDh8vYo4MvIJ34/inDghWUmNinPiiAJcOCOH75w9gbzkhJPdnDhx4oxyRr14M5SYTEoFjYhJ72glNrLI7/cfd/vI+zEYBuZdMJDzxP7Pup9Hr9fjdruHta3HS7NqaGiIllaPM3AONTl46M39bCjvLMkaIRKVMBSUZpj4y03zONBo5+G3DrC+3BrNg4dTMyzYfLIbMMIEJbmL75hOLZKcoOXbZ43nstl5/TKc1fWyjT8kcdTq4rsv7eLBNWXccfp4rpibd0wRaLQQSUvzhz2IImlp/mhaWmeamj+cnqYIJp3L1KKAzROIHsMfcwxlmYROI9Lm8kf39Qe7nifVqKWqzR19Hbt/hEgqmSDQaWodNbRWHtfeteKExbMTRZJkyhrsfFrRytp9TWyvaqck3cgbty9HqxYp+sEaAA4/eM4xfeF6Y25hCnMLT50Iv88LapXIpbNzuXhmDu+UNfHIOwepbnV3+f7Kcrza1GhAJUBIHv3G0aOL3r+3alFgZ00H+xsc5CYZTsl+UJw4cUaOz5V4k5OTw5NPPsmOHTtOdlOOSURkgv6lF7lcLqB/aUuDPU/kHL2dx2Qy4Xa7h7Wt/fHTiTNwKq0ufrX2AGv3NQG9V/eQUdI/hpJJWWb+fvMC9tbZ+L+3DvDJ0VZ8AYmhHi9GhKGgJCFJXR8jqTEhSe5cF+N5U5x2fFPzFBG+cnrh0DZ6lBPxD9KqRbLMer5z9gQunJEzoMH+sVLwfEGJJruPn79RxsNvH+DrK8dxw+JCjFp1F38efzBWBOkaRRLZDmRcvpCyXS/b+EMSKkHA7g10ETxiz5Fs1FDX7ulcFjGJjjn3jDxLr946neJI2By0m1ASaxZdlGrE6vR1EVEi2xp1KrQqFSa9mqJUuXMblYgmfHxle5VSjSy22lh0G+VPJQroNWJMCt3ooc3lZ0N5C+sOtbD+kBWPP8iVc/O4ZFYOv7lqJvkpnbPS503LZFqOpd/CzY9f2YPDG2RuoWKGPCnLNCr+B95ACK1K/NwbaMciigLnTsvinKmZrC+38sjag+xvsMcYwMZFg5NNKGwmD7BmdwMNNk/n9Sam+mG0emKM6b1KVHyD1KpuaXWqmDS9SJSaEIlWGwNeQX10o/whmQqri2/+aztFqQn86IIpQ5pCHCdOnLHF50q8MRgMw1aeeijR6/WkpaVhtVqPmzbW3t4eFUQG6gsTK4jU1tYyb968PreNjXzpfp68vDyampr6leIWOU7cw2boiBUoevP26PRg6CxDetTq5G8bjrK9ugOAY01khsIz4C9trTmGH4hSFt0TkLqac4bNLUOyTKJOTVs3DwlJlknQqphdkESl1cXLO+p4ZlNlVFSJFVgi3hAefyjqTxJ7/sjfzHwLWyrau5hkdqcoNYHKVnf0dXc/iRl5Fv5566Lj/u+3//KCgXxUo5bI5xEISgRlOWperESAdJoZR6JI8pINXDIzh8k5ZkKSzP+214a376xs5fKH+hRZXP4g3uPUmfWGS8v/au1BfrX2YI/1CRqRoEQXAUSjEtFFnqsFJmSYqOvw9BpdEtnWrFeTlKDpIpjEbmPQiNFBR2/niZRg7358tTi4UuyfJ0KSzK6adtYdsvLRoRb21HYwKcvMyonp/P4Ls5lTkNxnJFcwJDMzP6nf57poRg6bj7byblkTv377ICFZZlZ+kiLmFCYzOz+JpITjp/4ONd/853Y+PNiM2aDB0stfaqKWRJ06ZplWeUxQXhu1qjH7PRMEgZUT0lk5IZ3PKtp45J2DfFbRdsz7VX8ISTL7G+xMzTGP2f/dsCMDgvLbrGx1sbfOFha3lYhAs15DU9gAu3uVrogB/tQcM9urO6J9l0Avk0R6jYg30CnWdU9NnJFr4WCTo4uvUuw2oiBQmKqYzkfTF2NSIUVBwGxQ4wtIXSsfhkWjiJiUlqjF7g1G0x8j1Z1UYmelJ21MhcSIsXGkupMoCtR3eBCBvqRHf1DiUJOTW/6+hXSTlqvn5bNiQnrXapciXSomRt5DbNsVo2Sxy/8gbnocJ87Y4XMl3pxKTJ48mQ0bNnD48GGCwWCfs4sHDhzoss9AiK0YFXucY51HrVb3qO41ZcoUtm3bhs1mo7Gxsc9y4Q0NDdGS7wNt60CobHXh0Th6mFB2FRPo1YA0JMWYj8bu2+0YOrWIwxfoaYIa/tNpRByeoLI8bIza3Tg1J0lPpdXdWVmkF0FCr1Zh9wZ6r7gjy0zJNrOzpuOY/48ZuRb2Ndg7OzyCgMsf7HcHWJKV/+krO+tivCFEVJGSzeHjJurU+INSj9kzjUaFShQw6TXoNaoenaJoB0MUSNCoCUpSl9LQKpHo+TqX9TTvFIWux+ryKHR/TdRcc7hnvAMhieqYVJbYUt6RSBABGacvFLOsW2pNSEKWZTwBJU0mGI4QiVaIkmQyTDqqWt09yufGmqkWpyWwv8ER3SdSNjfyXUhJ0NDmDkTbrgmXm438aVUC0/Ms6DUqPjzYwsYjrejCQklsJEiSQUMw1BkhkqBVk2ToFFlanD42lluRjhPRJQowNcfMN04rZU5hcpcoEo0qLo6cijTbvaw7pETXbCi3MjnbRLpJz42LClkxfi4Z5uMbdTp9Qd7d38wvL5/R7/MuLEllYUkqoAzey5sdbKtqZ1tVO6/vqifNpMPmDkTFnLmFyZSkGYf9O/bEdbNpd/vpcAewewLYPAE6wo82TwCHN8iRZlf0dYfHj80dwOFTSiyrRYHl49OoanVjNmhISugUfpIMmvAyLckJGkz6mHUJmlMiJTHCguIU/vO1xZTV20kxDk5ka3f5eWFLNX/bWIHV6WfDPau6RHPF6T8SoAqHkgyleXT3ymzBXu5jXftbnfey2D5YrMk8KGm53Y8TregmgD/QNRq3e79PlhVxJdbsPlL9MrKfRiXiDvetIsujzyXlGAj0GYETISTLNNp9/O7Dw/x3W234+EQnu2zuQPScnSXJO/fvqzw9dAo/eSkGmu2+aF8o1vdLJQoUpSVQ3+Ht0k/rLm5Fqiz21udShUWy7sJS920sCRo8/lC0j6cSRVQCqML9M7UooNOEK4516891P2YX4S383NoysOIoceKcCsTFm1HKsmXL2LBhAy6Xi23btrFw4cJet1u3bl30+dKlSwd0jvnz56PVavH7/axbt44f/OAHvW7n9/v55JNPuuzTva3PP/98tD3XXHPNkLd1IHzx6c8wJGV0DtC7Xcx1agHoeTOKnaVpCN+QehMpVKJASoIGpz/U5Uai1YrRG5JeoyLDRA/RIPZ8CRoVS0vlHu2LlhMVO0uUxs4SxRpsRl73do4Wh4+PDjZzw8ICVKqunXRZVko+/3rtQY60OAmGejehBWUAvXJCBj84b9KwfWZjmUablwue2BCOzFBFU1yikR5qkdL0RBps3qhYEhsBolELaFUqErRqErRqNCol3FwbfoyIJgatiEzPijWx5XMjFWIi1WLUYmdUSaSaTGxKz3ANXLdXt/P85ir66sVqVAJTss389KKpzC1MHpY2xBkZ/EGJbVXtUcHmYKOdmflJrJyQzpeXFTMjL2nA/jr7G+ykm3Skm3TH37gXVKLApCwzk7LMXL9QSXu0Or3sqLaxraqd/26t5Sev7CVBq2JOQaeYMyPPQoJ2aLtNRp0ao05N3gC/5iFJxukN0uHxY48RfDrcyqPdE6DJ7uNQkzNcwSlEk92HzRPA6QsCSupjRMyZmmPG6Q12ieqx9BCDtNEIof54Ww0HU3IG7jK2u7aDpzZW8ObuBtQqIRrJkaA9dcSr0UYoJKMaBsNiURTQDvOEysni3bImdtd14Pb3HXWqU4ukJer47jkTuGhGTr9TOyO+a6EYMSfUTaSKiE1KJUQJCfqMYJZlmUBMtHbkMZJeHgwpE53uQKjnBGZY3JIkmWC36OlASEYKSlFxLCBJNNl8x5zotBg0tDh84XR3urVJJt2kp67D3WXfyP6+juYh+vTixBk9xMWbUcqll17KQw89BMDf//73XsUbSZJ47rnnAEhKSmLVqlUDOofJZOKMM87grbfe4r333qO2trZXb5nVq1dHI2Yuu+yyHusvvvhibrvtNiRJ4u9//3uf4s0zzzwDgCiKXHzxxQNq60BY971Vn2uPHLs3wGPvHeLpjZUEJZlLZuWSlNC1kyoIAmdMzuT0SRlsOtLKI2sPsqfO1sOsGJTIG2mIDIvHCpGqWV9aUnTc6jf5KQkc+Pl5I9SyUwOtSuy1fLJOLZKbZOCnF01h5YT0eGTNKUpNm5t1h1rYfMTKukNWDFoVKyek843TxrGsNI3kQUZORCirV1JehpK0RD1nTdFz1pRMQBGdyhrsbKtqZ3tVO//ZWkN9h4fJ2WbmFChiztzCZHKSBma+P1SoRGXW2pIw8HpqgZAUjfKJ/Ln9QaxOJaqnwxOgtt3Dvno7NnfnNhkmHbvrbAAYNKqosBMRdLIterQqsYcAFPtn1qvRqIdfNPEFQ6zZ3cCT645ypMWJDNEBXQSzIV6L7kQYDZ5RpxLHqpKmVYvkWPR875xJnDsta8CCthCZyDvRRo4xamtryX/8ZLciTpyhJf47H6UsWLCA5cuXs2HDBv72t7/xxS9+kcWLF3fZ5je/+Q379+8H4M4770Sj6doReeaZZ7j55psBuO+++7j//vt7nOe73/0ub731FsFgkG9+85usXr26S5SG1Wrl+9//PqAIRLfeemuPY2RlZXH99dfz/PPPs3btWv773/9y5ZVXdtnmpZdeYu3atQDceOONfaZWxRk8/qDE85sr+e27h6JhxECXfPHuCILA0tI0lpamsa2qjUfeOcRnFW0gy8RmtAS61/T+nNLu8vPrdw7y4pYaZFlmdkHykJQu/ryhVYtdBEGdWiQpQcOPLpjChdOz4+atpxgef4hPKlpZd7CF9YdaqG5zM68omZUTMvjmqlImZw+tt8i+ehtTsoe3zptWLTIrP4lZ+Ul8eVkxsixT1+GJijlPrj/C/gYHGSadEplTkMz8omQmZZuPacg9GtCoRFITdaQmDjxyyRcMKWKOu6v4Y/ME8AaU6J4Kq6tH+pfNo5iCLyhOpqzeERV9kmLFnYRItI8as17bU/gxaI47qK3r8PDcpkr++Wk1wZDim9UbkQjDOIMjKMvE/30Do7dJMK1KpDA1gXvOncQZkzLi9744ceIcl7h4M4p5/PHHWbp0KR6Ph7PPPpt7772XVatW4fF4eOGFF/jLX/4CwIQJE/jOd74zqHOcfvrpXHvttbzwwgu89tprnHXWWdx1113k5OSwZ88efvGLX1BdXQ3A//3f/5Gc3Hts9y9+8QvefvttWlpauO6669i6dSsXXnghAG+88Qa/+c1vAEhPT+fBBx8cVFvj9I4kyazZ08DP3ygLh8d3dlZFgeMaw0aYW5jCv7+yiL11Nh599xAfHWxBEIiaDH6e8QclnttcyW/eORTNMVeJ4AqnH8QZGBqVqHhDqUV0GpF7zpnINfML4oOpUwRZljnS4uSzijbe2tvIpxVtpCfqOG1iOj84bxKLx6Vi0g9fVENZg53bVg6dz0Z/EASBvOQE8pITuGRWLqD8/nfVdrC9qp0N5S28U9bIzpoOZuQpRsjzwpWtTjTSaDShU6vIMKnIMB3fm6g73kCIDrcfmyfY6eHj9kfTvGyeAIfs3i5pYJHlETNbk07NguIUGmzeLild/mCIDw+20OEOIAjHNuEHMMZTpk6IkKykzcTpP0pks4wAqFUCEzJN3HPupHhlqThx4gyIuHgzipk9ezYvvvgiN9xwA3a7nXvvvbfHNhMmTGDNmjVdyn4PlKeffhq73c6bb77Jhx9+yIcffthlvSiK/OQnP+FrX/tan8fIz8/n9ddf59JLL6WxsZGHH36Yhx9+uMs2WVlZvPLKK5/rlKahZvORVu57bS+VrYohbndUooA32D/xJsK0XAt/+9J8Djc7eOy9ctbsaaBvR5yeBEIS3kAIbyDyqDz3hUK4feHXQQmvP4Q32LneEwhx5dw8xqUPrIz8cCLLMu/vb+anr+6l1eXvIoyFJCVFLc7ASUnQkpNs4Lr5+dyyrHjIfUSGC18wRLPdR5PdS5PdR6Pdi8Wg4cq5Y/+a5vAG+Phwa7iMdwtWp4+zp2axamIG9188dUTMfUG5vhxqdA7K+2SoMerULBmXxpJxSvSdJMkctTrZWqkYIf/izf1UWF0UpxmVyJziFGbnJzEuPfFzOcOu16jIshjIsgxsv4hZe6eJc4A2V1dxp6zehs0TQIZeUzK74wtKfP35bV0ifnqr+GXWqzEbNHFhuRtSSCnMEKf/iILitzSnIInvnTOJRSUpcdEmTpw4A+bU6DF/jrnooovYvXs3jz/+OGvWrKG2thatVktpaSlXXXUV3/rWt0hIOLFqCQaDgTVr1vCvf/2LZ555hl27dtHR0UFmZibLly/nW9/6Vo+Urd5YuHAhe/bs4fHHH+eVV16hsrISgOLiYi655BLuuusuUlNTT6itcRQONTm4/7V9fFbR1iWHvzuiIOAIG1R6AyE8/hC+YKywIuEPhXD7u4styusss55LZuUgCvDNf23HFyvKhI8TOaZGVKoIxbZHFJQOu16jYnquhZp2N3q1Cr1GRK9RYQiv02lEDBrVqIrwOdBo58cv72VXbUevJUwBOtxx8WYwWBI0fPz90092M6KEJJlWl48mmyLMNNq9NIcFGpc/yOFmJ012L+3uACpRIMOkI8OsJ9OkY17R2DRUliSZsgZ71Gh4e1U7hakJrJyQwS8vn87C4pSTUq3ocLMTjUqgcBRWCRJFgdIME6UZJq5dUABAm8vPjmpFzNl8pJWfvroXnVrFnILOMuUz85Iw6uLdsb4QBCFq2J5t6dtjyOMP8cePDvPndUeQZY55b0wxaplXlBwVf8rt3m5pYEHGpRujVXuMWlVU3OkUedSY9Z2vuzyPrNNrMOrGXjn3kCSjFePRSwPh9EkZrL1rBROzBj/ZGidOnDiCLMedSOOc+tTW1pKfnw9ATU3NqI7ukWUZX1ARPbwxQoonLJr4wlEoERHFE17vC0esvLy9lhanv9/nK0gxUN3mAUAQ6CKe6DUqMs16fMFQj+XKn/I6PVFHICRh0KrQqxWxJbqNWsSgVaFTixg0avQaEV1YmDkVyzlbnT4efvsAq7fXIfdi4BzLrPwkfn3FdMZnnfwogKHA5glg0qnHTFSALMvYvUGaw4JMUzRqRvlL0Kr55GgrzQ4fIUkmOUFDpllPpllPlllPpllHbrKBVKNOWW7RkWrUDdhM8lShzeVnQ3lLOLpGKeNt0KhYOTGdFePTR0VZ5Vd31rH+UAu/uXrWyW7KoAiEJPaHjZC3VrWzrbKdFqePydkm5hYks7AklRl5FnKTDKfctXO0UNPm5r7X9rGhvKVP4X35+DSe/3LvVTxj8cZE/HQ3eXZ4g0qJd6+yzu5VRJ/Ic4c3yPyiZLZXd2DSR4QeNSZdp7hj0mtIN2vRiGL4tRpT9DHyXIVeM7rEvTv+vY0vLylhZrwa4IB46M395CYZ+MLCgrjh8whwKo0N4sTpL6PrbhAnzklCkuTOSJKIaBITpRIRWpRHCVmWsbkD4WWSsm+MGGPQqKi3ecLH6CrORAyEFxSl8FllG1qV2BmJEhZHIq9NejUqUYhGqOg1KhK0KgQBBI6f16/XiNx15gTOmJSJTiOiU4ufqwGBLxjC6Q3i9IX/Yp4HQ0q0hdMbxOEL4vIF2VdnY1+Do9/HP9Tk4Dv/2cFrd6wcxncxcpz72HoCIYkvLCjgqnn5o2Kw3hdef5Bmhz8sysT+KelMTTYPHWFvDYNGRZZFEWMi4syC4lTykvRcv7CATLOedJPupESSnEyCIYldtbZodM2e2g4mZ5tZOSGdP3xhNnMKk0ddusiuGhuJp3CUikYlMiMviRl5Sdy8tBiA+rAR8raqdp7bXMmWynbSErVKZE5BMvOKUpiSbT5p5blPNfJTEnj6S/P5+LCVH/xvN80OX5eUV4C0fpo1x05yDJSQJOPwBHD4gmGBJ4jDG8DuVQQeh1dZ3tihXLccPmWZ8qds5w9KTMw0UdHqwtxd2NEpz80GDTkWPQhCdJtIulesGDSUv+VQSCZBe+y+xI7qdnRqlSJUGTQkasfOxMBg+d/2WtrdAZ7aWMEvLpvG8vHpJ7tJceLEOcU4dXtAceL0wR8/PIwuydYlDcgTE8XiD4Rwxwg03qDUxS9mbmEy++ptXQSTSBRKZFm2RY8nEIqm/iQnaDBY9OEUIBWJWhUatYheHRZkNCK66HMlWkVJFVIPeBb//ounYvcG+Pen1fx53ZHoe+gNURBI0KoGVU52NPPqzjr21tlw+pSOrissyDi8QVz+ICIC9TZPdNZVLQok6tUk6jr/JmaZ6AhHmhh1Sji+UauizR2g0eZFFOB4WVwmnQotYyd1SqsWabB5eXL9UX7/4WGm5Vq4aXER503LGrG0jmBIwur0dYuSiU1nUsSZSVkmtlW1k2HSkWnRk2lSxJlJ2SZWTkgny6KPrjPp1J8r0fJYNNm9UbFmf4Oddpef5ePTuWlRIcsnzB2UEe3x8IavlUNBWYONy2bnDsmxjsXP3yhjQmYiV83NH/YBZ06SgZwkAxfNzAHA7Q+yq8bG9up2Nh1p5XcfHMYbCDEzL4mVE9OZkGliTkHSoKpFnSj/+rSaDo+fkjQjxWmJFKYmjFrRc2lpGh989zSe31zFr9YeQJLAH66cmDoCJtIqUSDJqCXpBM7lC4aiQk+ssBMRfiLLmh1eKlvdPZbbPQGCkoxeIyIgdIvoUcdE+6hZUprGqokZx22T1+tDkiR02mOLQT96eS+17W4cviCyrET+mnRhccmgYVKWCYc32E1oiohPymuLQY1Rp4mKUnrNqT0B5faHCEky1W1ubnlmC4tKUnng4qmUjCKvvzhx4oxu4uJNnDGHwxsgQRBINWq7pAEZuosw4SiXiLgS9V85BaJTzHoNX1s5jpuXFvPG7noef7+chg4vgZDUw1rY089qU6cSDm+QQEgmLVFHYaqRRJ3S6UsMCzFGrRqzQXmeqFMP6DO97+Jp1Hd4eGZTJf/4pApJlvsst+4PyqhHWTj7iZBt0VPV6o7OUu+utfHjV/Zw7+o9nDs9iy8sKGBBUcqgBrOyLGP3BGm0e2lxeKm3eXtNZ2px+JSSwIIQjpJRomVykgzMLkgmy6Ijw6Qnw6wjzaj73M/kHg9fMMS2yvaoYFPe7GRWfhIrxqfz1eUlTMu1DFsamDcQ4ncflPPmnkbe/faKE04TkGWZsno7Pzp/Sr/3qW518+NX9/KXG+cOSGSYX5TCg2vK+Oen1dx30VTmjmB6SIJWzeJxqSwep3jEKUbILrZXtVPZ6uL/3trPUauL4lSjUqY8XNlqpIyQ9zc4eHNPAxUtLtyBEDkWAyXpRorTjIzPNJGfbKAkLZHcZMNJTzHUqERuWVbMJbNy+MWb+3l1Zz2yLJN0ikxo6NQq0k0q0gdpkyKH7192TwCHT4nmiRWAHDFCj9vXv76CyyeDIGLUHvt/+OadywHl++vyB6MRRxExyhsMYXX4lPP7grQ4fBxtcUXFJ7s3QIZJx86ajug9WC0KXcSn7CR9VJQy90g3Ux4tBg2JOlV0mUFzcjyIlM+i838cCMlsPtLK2Y+u54ZFhXz7rAlYDKfG9zJOnDgnj7jnTZwxwec9r1WWZTaUW3ni/XJ21HQASsi2QaPipxdN4bqweWacgeHxh1i9o5Y/fXSEZruvhziWqFMxJ8fAc18bG2lT33tpFy9tq+11nSiAShRJStBw/YICrpibF02r8gZC0YiYVpePunYPjTYvTQ4fTTYvTQ5FmPEGJIxaFcvGp2H3BJXoGLMu7C+jj4o1GSZ9PEXkBKhqdbH5aCvvlTWx6UgrJr2alRPSWTkhg2WlaSMSibe9up17/rsbvUbk11fOZHL2iftC1ba7Wfnrj9j3wDn9FmKCIYmrntzMrPwk7rto6oDO5w2E+Ov6o/xp3RHOnZrF98+bNKj0meGg3eVnR017NN1qZ00HWpXI3LCYMxJGyLIsKwNuq4uK8J/NE2BrZRvVbW4AClISKE5LjIo7yl8CGSb9SRlA767t4OdvlHHbaeM4fVLmiJ9/LFDR2MGv3jvM766dhVo9MpMXgZDUa9SR26/4DnUXouwx4lRhqpHNR1qjE1mRSNzY1LN0kw6tSuwh/ES2SwpHAEUniQaRAubxh5j807d7XadTi2hUIj84byLXzo/74QwVn/exQZyxSVy8iTMmiF+gO9lbZ+OPHx5m7b4mZGR+cuGUqLfCaMTjD/HkuiPMKkjitH6EbJ8MZFlm42Erf/roCJ8ebUMUlVkzrUpgabGJv9+6/GQ3cUh47L1D/P6Dw8es0hKLLmxW3eEOoA5XYZqaY0atEruIMVlmPRlmPVkW/SntVzJacfuDfHK0lXUHleiaug4Pi0pSWVqaxmkT05mYaRqxgbLHH+KRdw7yr0+ruf2MUr66vGTIBiJr9zXy6LuHePuuFUiSzF0v7uRnl0wlKeHYaSkVVhcXPLGBp26ax5LStAGft77Dw0NvHeCD/U186/Tx3LKsCJ16dKUKRYyQd9fY+KSile1V7TQ5Oo2QIxE6I2WEHAxJ1HV4FGGnRRF2KltdHG1xkWbScrjJSXG6knpVnGYMp2EZKUozxqMPRjl7azp4cv1hfnf9vJPdlAERCEmKx103cUeJ/Ang8CgRQLEiUOR5bpKBLZVtuPyKACQIKBG/uk6xZ1x6Iu5AKBoJbNKpo+naJr2GkCTxzX/tOGYbdWqRbIueX1w2naWDuFbF6Up8bBBnLBIXb+KMCeIX6J7UdXh4fnMl503LZmZ+0sluTq+8V9bED1fvwer0cc38fP7vihknu0nH5WiLk6c2HOW/2+oIShKnjbPw0EXjycw8tWZxJUmmxemjwealocNDg83LpxWtvFfWTOg4twUBxR/n2vn5XDUvn0yznlSjNp7CNELIskx5k5OPDjWz7lALWyraybLow9E16Swel3pSSk9vPtLKD1bvJi1Rx8NXzKA0o38+DrIs90tQePTdQ9S0ufntNbOQZZniH77Jxz84ndykvstHR3h+cyV/+ugIb397BWb94MSBT4+2cv/rZWhUArevKuXMKZmjOsU21gh5e3U7++rtpCfqOG96FnnJCcwtTD4pRsjeQIiqVjcVVmcXcafC6qLV5WdSlolEnVqJ0kk3nhL+Op8nPjvSzIvb6vjN1bNPdlNGnJAkh/31AlGfvYjA4w2EaHcHooUR7N7O5w5vEFmW2Vtv7/e5EnUqrp2fj8Wg7SICxaaGRYSi+O+id+JjgzhjkfgUaJw4Y5TcJAM/OG/yyW5Gr9S0ubn35T18crQ1aircaPee5FYpyLKMyxek3R2gzeWnze2nzemn3e2n1eWn3eXHGwgxLdeMHAyw6bANrX50VWWSZZlWl5+GDi/1Nk9UnLE6fVS1ummwKWlMQUkmLVFLtsVAlkWPXiMiihDqw/pAEEAlCNywqJB7zp1IgjZ+CxkpbO4AGw9bWXeomfWHrBSmJmDUqTl7Sha/uHQ6RWnGk9Y2hzfAk+uO8vTHFXzvnInctLhoQF4nf/zoCC5fkHvOnXTM7coa7CwsTgFAEAREQREh+8MNiwp5p6yJB14r4zdXz+yy7qWtNbj9Ib64pOiYx1hYksobty/j5R113PO/3cz4NImfXjSFcaPUbLQvI+R9dTY+Pqyk2XoDIWbmJynpVuEInZRhNvPVa1RMzDIxMaunkYvNHVAidKxOKqzuXv11itOMzClMIsmgjYo7uUmGeKrJCOEMyOhVn0+xQCUKWAyaQUWH7arp4OonN/eofNadyKXTrNfgD0pUtLqiEUNOnyIStbn8OHzBaLENrUqMpnhNy7HQ6vJ1Cj0xok9iWPRJMqhJ0HYVgwaTChYnTpyRJ97zjhMnzojhC4b480dH+P2Hh5FluqTnWB2+YTmnJMnYvQFaXX7aXH5s7gDNDh9tLl9UjImsaws/n5xlYk+djRSjluQELSlG5S/ZqCXdpCPVqGXFhHSSE7R8/dktSNLIDRpkWabdHaDB5qGhw0uD3UujzUNIktlZ06FE0ti8+IMSSQkaciwGcpL0ZFsMTM42s2x8GtkWAzkWAxnmruWxy+rtvL23sdfz6tQiuUkGHrt2FjPykkbo3Y4cVqePsno7+xuUP6vTzz9uXXjS2iNJMnvqOst476zpoDQ9kZUT03nkqpnMK0o+4dnWg40O1h1q5qsrxg36GB8dbObe1XuYnmfh7TtXUJA6MCFzV00Hv/ugnP98bfFxt/UHJabkdHrnqEWRUD/FG0EQ+NWVMzjn0fW8vTeTc6dlRdeNy0jki09/hiDATYuLjnkclShw5dw8zpycwaPvHuL8xzdw0+JCbj9j/KAjekaKWCPkW1eUhI2QnWyramdrZTu/fGs/FVYXy0rTyDLrFSPkomRK0kbGCBnAkqBhZkJSj2jR7v46LQ4vm4608s9Pq6L+OvkpCdH0q3HpiRSmGilJN5Jh0o14hJTdG+D9/U2s3l5HSZqRBy6ZNqLnH06c3gC6eKTHgHH6gojH+B5q1SLJCRq+tmIcV83Lw9SP64kvGFJEnZg0L7c/RIcngDOaEhak1eWnstUVFYBMejUHGx3R1xBOBdMqQk5hqhF/SOrqAaTragadnKBBr1F3MYtOHOKS9HHixOlJXLyJEyfOiLDuUAvf/+9u2t3+aLRNLG1uf7+OE5Jk2t1hocUZEV18UQHGEwhR2+aJCjHtbj8hSUarFkk1apmea8ETCJFq1JJi1DE+08SCsECTmhh+NGox6zX9GrAsLk5kS1Ub5yafeORDSJJpdSrGvw02L41hIabZ7qWuwxNd7g9KWAwasi2Kj0y2RU9peiKXz8kjx2IgO0lPjsWAQTuwDnaWRd/js1GJSoTDnWeM5ysrSk75jllIkqmwOilvdrKrxsb+BjtlDXZaHD4KUxOYkm1mcraZC2eY+53OM1Q0O7xsOGRl3aEWGmweDjY6WDY+javn5fH7L8wm23L89KDjEQxJvFvWxLObK9lR3cHFM3MIhKQBf64dbj8/f2M/7+xr5N4LJnPt/PwB/6+cviB3vrCDO8+YcFxB0OYOsO5QC49fOyu6TBTptz8TQLbFwM8vnca9L+9hbmEy6Sal1PacgmSevWUBX/zbZwjAjccRcACSErQ8cMk0rltYwAOvlXH6Ix9xz7mTuHJO3pALHe0u/7AMikRRoDTDRGmGiWvmK6b2bS4/e2o7+KSijdU76rjvtX3oNSrmFISjcwpTmJlvGfGoO0EQyAh7Zy0qSe2yLhiSqO/whqN1FHFn42Erv//wMHUdHgwaFUWpsSlYnf46ycfxSxoIHW4/75Ypgs1nlW1oVSKeQGjUi3oDxeMPEQ+6HDgOb4Dul0i1KCDLMKcwidtOG8dpEzIGdP3QqVXoElWkJeoG3a5QuBpYbAqYyxfEFlOi3ukLhEvS+3B4laplmSYdO2s7ottEhHS9RowKPClGLXq1qtdUL7NeQ5JRg0Gj6hEldKqXhI8TZziJX37jxIkzrNR3ePjxK3vZUN7Sq2gTocMVYGO5lVaXr0sUTJsz8txHXnIC68tbkGUwalWkJGpJiUbG6EhN1FKUmsD8opSwOKMl1agjJVGLUTs85UFTEhMI9aMcuz8o0ezoFGSaYgQanVrk04q2aCpTqlEbFWWyLHpK0o0sKU3rItYMx+ApOUGDShSinTCtWmRajpnfXj3rpKblDBanL8iBsDizv8FOWb2dg00OZBnOm56FQaPijMkZ3H56KROzTP2a6RxKAiGJbVXtrA9H1+xvsDM918LKCel8aUkhM/KShiwVxOr08eKWGv7xSRWiIHDj4kL+dP1ckgeRIrN2XyM/fmUv03LMrP32CnL64TnTG/e/to9si4GvrSg57rb7GmzkJhm6mBOrRRFpgLZ9F8/MYUd1Bz9/Yx+PXzs7ek2YU5DMs19WBBwEgRsXFfbreJOyzPzrKwt5a28jv1izn39+UsXPLpnKzPyhKy3+xAflvL6rnotm5nD57Dym5ZqHbWCTYtSycmIGK8Pm8f6gRFmDXfHNqWrn+U+qsDr9LBuXRnG6MVrdarDfgaFArRIpSE2gIDWB0yZ2XecNhKhuc3M0YppsdfHp0TaOWl0UpSZwpMUZFnM6K2IVpRopSkvo1zW2zeXnnX2NrN5ey9aqdnRqVbSqkUcKoVEJvaaHnco4vcF4yuwgUHxvlOd6tUhIlrl8Th63LitmfObJ+46oRAGzXhMWGQf3O46UpI8IO7Gl6COeP/ZwhFB9hydqEp1m1LGnzqas8wW6lISPpIFNzDRh9wYx67umeSWGq38lJWgwatWdFcQiUUDx72icMUr8mx0nTpwhQ5ZlPIEQrU4/VoeXR98rZ+NhK7IMxxtiuQMhfvzKblIT9dHolxSjlpI0YzgiRkeaUctDl09XZnNGSdi2TiNi9wair5vtXlbvqIv6zPiCIfbVO7A6fYgCZIarLmWFH2fmWyhISeDaBQVkh0tnn6xKNoIgkGTQ0OEJoFOLPHDxVK6cmzfqZ8BkWabe5o2mPZU3O9hdY6OqzU26ScfkbDNTss3csqyYqTlmilKNJ80fo6bNzcbyFj482MKmI63oNSIrJqTz1RUlLB+fPuR+I3tqO/j7pkre2N3AgqIUHrh4KmdMzhyQJ02EVqeP+17bx4ZyK/ddNIXLZucO+rvxxu563tvfxFt3Lu/XTHNZvb1HuXFRgOAxBOHeEASBO88Yz9mPreelbbVcPS8/um5OQTLP3LKALz2tRODc0E8BRxAEzp+ezaqJGfxl/RG+9tw2lo5P5/vnTiRjCEqL/+SCKZw1OZPVO+q49i+byUkycNmcXC6dlTvsoolWLTIrP4lZ+Ul8eVkxsixT2+5he7Ui5jy5/gj7GxxkmnTRilbzClOYnG0aFR40eo2KCZkmJvQyOLZ7/FS2uqPROoeaHKzd10hFiwuHL8i4dCOZZj1F3aph6dUiHx5sYfX2WnbWdHQVbLoJ+RqVeEoK38fCFQhi1B9/+GDzBLA6fWSa41UGAVy+IJ5AiLRELV9dXsI18wuwJIyNqCxBEDBoVRi0KjLMx9++L/xBCadPEXliy8F3RgEpj+3uANVtHhxepa9SaXVH1zn9nSKZztc+NG8wTpxRRPxqGidOnD4JhiQ6PAHaYzxh2tydPjGRR7UocrDRTqvLjy8oIQpgNqjpcAcHdL7V31g27GaZQ41BLeKNmf33BiT21NnIsehZWJJKTjRaxkBaonZUDGiOxeyCZFQiPHjp9GhayWjCFwxxuNkZFmoclDXY2N/gwOkLUpJmZEqOmak5Fq6am8/kbPNJfw8ef4hPKlqj0TXVrW7mFCZz5qQM7jhjPFOyzUOeZuMLhlizu4FnN1dxpNnBNfMLePOOZZRmDG52V5ZlXttVz4tbajDrNbx79woyTIMXJeo6PNy7eg+/unJGv1PByhrsXfxuQJkxHmjkDUCyUcuvrpjB7f/eweKSVPJTOn165hYm88wt8/nS01uA/gs4AAatijvPnMAVc/N46M0DnP6bddx+eik3Ly0+oYpOoiiwpDSNJaVp/PySabxT1sjq7XU8+u4h5hWmcPX8PM6akjUiA2RBEMhPSSA/JYFLZuUCyqB0V00H26ra+ehgC7999xAz8ixIEtHInNkFScct6d5fWp0+tlS28fGRVkIhmV9ePn1QxzEbtMzI0/ZI2YsYvldaldLmR60utla289LWWo60OOjuN9tdsIklEJIoGWPijccfIrMfouRnFW1881/b8QclEnVqMsw6ZdIinP6WZdaRl5xASqKWTLOeDJPulE/LPRbnTsumMNXIignpgxLPPw9o1SIpau0J9QOlmDSw8qNVnPbY0LUvTpzRQLxUeJwxQbwc4PGRZRm7NxgVYdrDQow/GKKm3RMWaAK0uzvX2TwBZBlm5VtocfhJTVQMfFPD5r0pxk6PmGRjT78YXzDE23sbeXpjBXvr7IgifaZOqUSBtXctH/QA82Txqzd2odequePsqSe7KWOONpc/mu4U8aY53OxkUUkq/qDE5GwTU3IUj5oJmaZREY0lyzKHm51Ro+FPK9pIT9Rx2sR0VkxIZ8m41GFLz6rv8PCvT6v592fVWBI0fHFxEZfPyT2h8zXZvfzo5b3srGnn55dM47zp2SfUxlBI4rqnPmVcupGHLp/R7/3OfWw9d505oYvR8Fm/Xcevr5rJrG7mtv3lh6v3cLTFyb+/sqiHgLatqo2H3zrIxbNyBiTgxLLpiJUHXisjEJL4yUVTWBVORRoqmu1eXttVz64aG+/ub+TsKVlcPieXZaVpJ1UkliTlN7CtWjFC3l7dTmWri9L0ROYWJkcjdIpTExDF47ezye7lk6OtbDrSyobyFuo7vBg0KryBEBMyTaz99ooReFcKkiTz1MYKfvPOQfwhif70oJ/50nym5ChC8miPYuwP97+6hwXFKZw/I/e428qyjM0ToNHupcnuoymcMqy8VipM7q610eJUChakGhUhR/nTkZ9sINmoI9OsI8OkLE81ak/Zqkg2d4BnNlXwpSXFYybqZjQTHxvEGYvEI2/ixDlF8QVDndEwMX/tMUa9rU4/bn+IBpu307hXJZJs1ESrKI3PSESSIctiYGqORRFhErQkGzXRakuDHRTr1CoumZXLJbNyOdzs5B+fVPGfrTVI4fzoWDQqgTZXoI8jjV70WjX+QFwDPxFCkkxlq0up9FRvZ3+jg7J6O412L3nJhmja09lTs5iaYyYv2TCqBkE2T4BNhxWj4fWHWkhK0JBh1rNqYgb3XzyVkjTjsLVXlmU+OdrGc5sreX9/MysmpPP4tbNZWpp6QueUZZmXttby4JoyzpicybvfXjkof5zu/PGjI1gMan5y4ZR+7xOJtpraLfLG7g30u9pUb/z4gsmc9/gGnv64gluXd/XdmVuYwj3nTuRLf9+CKAh8YWHBgI+/ZFwaa+5Yxr8+q+auF3YyrzCZn1w4ZcjSaDLM+mi7DzTaeXl7Hd//325CElwyK4fLZucyNWf4/HH6QhQFJmSZmJBl4roFyv/N6vSxvaqdbdXt/GdLDY+/dwiXL8i8ohTmhFOtZuRZ0GtU1LS5+bSijY8PW/n4sJUWhw99WKyJfNqeQAiVCMvGp434e/vqihIun5PLt1/cyacVbdFyzb2hFgV+9Mpe6jo8GLUqCsN+OoqvTqfHTlqidlRd046FJxDCpO9fn0AQBJIStCQlaJmU1fd2wZCE1emPijrNYYGn1eln89E2mu0+mhxeOtwB1KJAuklHhllPpknHpGwTOrWKDJOui/BjMWhG3f90W3Ubj75Xzt82VvDQ5TM4f3rWqGtjnDhxRjdx8SZOnFGALMu4/CHanP6oYa/NE6DF4es07o0++mh3KSZwC4tTONDo6BH5kmzUUhyupBGJlomUuh4u497jUZqRyP0XT+UH503i7b2NPLXxKPsbHIhAQJIRBYE21/CUCx9ODGoRm/fUE526c+e/d1Bv80S9O4bLp8HlC3Cg0UFZg6PTRLjRQUiWmZhpYnK2iVWT0vnaihImZZuxGIZudnL19lre2dfEnMIkpuZYmJpjHlQqhyTJ7K23se6gEl2zo6aDkjQjKyek8/CVM5hflDLsUUAuX5BXdtbx78+qsXuCnDc9i/e/s7JLCtBgqW1388PVezjU5ODRa2ZxxuTMIWgxbK9u5w8fHea/X18yIMPT8iYnBq2KvOSuKVb9NSzuq5qWUafmN1fP5Ka/fcbKCek9TEPnFaXw95vnc/PflRSqwQg4apXITYuLuHBGDr999yA/WL2bWfnJfOv00iFNc5qUZeaH55u559xJbD7SyuodtVz95GbykxO4dn4+503PJsty4v47gyUtUcfZU7M4e6oygvcFQuxrsLM9XKb86Y2VtLt8SGF/NLUodKkk1ltqklalYn7R0BlDD4S0RB3P3bKAF7bUcN+r+wjJEqFeNJxJWSbeuGM53kCIqrC/TmWrYpy8rUqJSCpKNVJWb6cwLOp0miYbw/fx0SVC+PwSSYahTW9Wq0TFC+4431FvIESLw0dTJJLH7sXtD1Le5GBjuZUmh5dmuw+nL4hWLZJp1pGXFE7NMimiTqZZH03hyjTrMY6gH0+jzYdBo8LuDfLtF3fywpYUHr5ixkk1/I4TJ86pRVy8iRNnGJAkGbs30Cm69FLSWqsSKWuwR0UZf1BCLQokhwWYbIueBJ2aVKOWvGQDM/MsMQKNjhSjFotBjfYkmdsOFr1GxaWzc7l0di7lTQ6e21zFf7fV4vaHTs3IG50af7vnZDfjhLF7A2ypbGdPnY2fv1FGuknHOVOzOHNyJguKBy5GyLJMQ4yJcKTiU4ZJz1GrMxpN86UlRUzJMVOSNvwmwk12L++UNfLhwWYEQfEnSjVqmZpjZm5hMtNyLUzLtZDRS3pDi8PHhnJFrGl3+9lR3cGy0jSunJvHE9fNHrHOd4XVxfObq3hpWw35yQl8aUkRF87IJmEIBiCSJPHPT6v5v7cOcNHMHH7/hTlDJp45vAHuemEn3z5zAtNyLQPat6zBzpTsnhEkonh8w+In3i+n2eHlwUt790WZX5TCTUsK+fZ/dvLyN5b2EHnmxwg4gkA0kmSgpBi1PHjpdPbV2XjgdaW0+A/Pn8SlswZv+twbKlFg2fg0lo1P48FLg6zd18iWinZ++asPWFicymWzczl3WtaIDlh7Q6dRMacgmTkFydy6XLleHGl28uXntlLd6u5XCXhPIMScwpMj3oASVXLdggIWl6Ry2z+3cbTFha9bFE6k0pReo2JilqnXylMuX4CqVo8i6rR2VsSqbHXR7PCRZNBQlJZAQUpE0OkUeYbKR6i/+P0BWpxeTMaT8/3Ra1RRz6Vj4fQFaQ4LPJEqj012H7vrbDTvb6LJ7qPR7o368Swfn0aHO6CIOxZ9WOjpKvYMRSGBJruXQFjl84ckNh9pZdUjH/HD8yZx4+KiuBdOnDhxjkvc8ybOmGC481pDkky7u1OI6fD4sDq6RcQ4O59nW/TsqbOhVYvRqkmdFZSUktbZFmXGJ7aktdmgHlUzbCOFNxDi3bKmk15ydjA8t/4wP33zIJX/d8HJbsoJ8fh7h/j9h4e7eBKpRAF12BR2flEK503P5rQJ6T06zr5giPImJ/sb7BxqcrCnTjERdngDjEtPZHK24kszJcfMpCxTv8wuh4OyejsX/35jrwNDrUpAJYpKSoBOzfjMRAxaFSadmpp2D/sb7EwLl/FeOSGdWflDV8b7eEiSzLpDLTy7uZJNh1s5d1oWX1xSyJyC5CG7XlRYXdzz312Y9BpuWVo85Okod/9nJ012L8/fsnDAfhU/f2MfBo2K754zqcvyVY98xIOXTmNpad9t/fRoK1//xzY++9GZfZqh+oIh7nphJ5Ozzdxxxvhet/msoo1bntnCjy+YzLWDFHAiyLLM67sb+OWa/eQk6Xng4mlMzxuYoDVQmuxeXt1Zx+rtdVS1ujl3muKPs2Rc2qgaMMqyzJPrjvDIO4eOK+BYDBo2fH9VuMTxySUYkvjdB4f5w4eHCUkyMqBTi9x91gS+tnLcoI/r8gWpanVRYXVT2dpZ7ryy1YXV6Sc5QUNRmpEFRSkYdWpF3AmnZg2Xt9a4H67h0IPnolKdWhNH3Yn48TTZfVidPuo7PF0iepocikdPi9NHSJIpTEnAoFUpFSMjwk5Y6MmyKIbLaYm6Y17fvvOfnfxve12P5Tq1SEm6kceumT3mSsufTOKeN3HGIvHImzifSwIhKeoN0ym+KClKCEqYfqvLT2t4WUfYuDdBqyLFqGVilglJkqNCzPRcS5fy1ikJWlJNupOWonSqodeouGhmzkltgzcQoq7DgwCUpCf2e78FJUnD1qaRZGqOBbUoEgh1pieEJDnqKbLpSCs7qjv46St7MenVpBi1TMuxcLjFyeFmJwaNisnZZuYWJXPprFzuPX/0mAhHmJxtIkGrhKx3xx+SIfzeHb4g26s7AMhN0nPPuZNYVppGauLIVq6yuQO8tK2GF7fU0OEJcP3CAn51xYwhKT8dISTJPL2xgt++e4hr5ufzvXMmDnlUxmu76vngQDNv37liUEaje+rsXUp6RxAFjut5M78oBYNGxYbyFk6f1Hv6l06t4lunl3LFnzaxIizMdWdBcQpPf2k+tzyjpFCdiIAjCAIXz8zhzMkZ/OmjI1z15CYunZXLd8+ZSNowfccyzXq+umIcX10xjrJ6Oy/vqOXu/+xCFODqeflcMCObSVknUON3iBAEga+fVsrELDO3/XMb/qBEXx+xTi0y64F3mJBpila1mleYQn7KyHtiqVUi3z5rAqdPyuC2f2yj1eUHoPgE00+NOjVTcixMyekp7tm9AaqsbipaXbQ4vOyts/PBgWYqW110uAOkJWq7pF8VpxopSE2gKM14Qil7IZlTXriBrn48E+lbMAlJMq0uH402JSWrMcaTZ1etLSz4eClJN7KrxkaGSRdNAYsIPVkW5bG82dnrOXxBiYONDi54YgNfXVHCHWeMH1X3zjhx4owe4uJNnDHHJ0dbUbcIUX+Y2LSldrcfq9OHzaMM3kw6NSmJ2i7CS3FaInMKkklNjElRSlTWx2+mpy7+oESDzUNNm5vadg817eHH8Otmhw+dWuT6hYX89KL+m6kWpicB0NrhJDWp/6LPaGNyjhnvMUreQqfvhN0bxOkLsmpSBhfNymFK9ugzEe4NQRA4bWIGr++q53ghpypB4M4zSrn9jPEj/r72N9h5bnMVr+yoY2qOme+cPYHTJ2WeULnp3jjU5OB7/92NwxPguS8vYH5RypAeHxT/nB+9vIdHrpo5KM8VWZbZX6+kTXVHLYrHFW9EUeCiWTm8urO+T/EGFPHy9tPHc/d/drLm9uUYtD2v9QuKU/jbF+fx4JoyBEHgmvk9BaWBkKBV852zJ3LV3HweXKOkUt1z7kSumV8wrCWTp+SYmZIzhe+fO4mPj7SysbyFS//wMSVpiVw+J5eLZ+WcUCn4oWDVpAzeuH0ZN/ztM9qcfvzdDGUMGpE7zhjP2VMy2VbVzraqdp7bXMX3/7cbi0HLvIiYU5TMlBzzkKS89IeZ+Um8/53TeOD1fbywpYbSjOG7J5j1GqbnWXqN2upw+6P+OhVWN4eaHKzd10iF1YXDGyQtUUdxWoJioBwWdIrTjOSnJBwzksnqcJOoHbvlvHtDJQpkmPTH/U14/EFaHIrpcoNNieJptPnYXWvjnbKmcOqWt8/9JRkkWeavG47y3221PHHtLBaNG1lD7jhx4ox+4mlTccYEsaGRi3/8H3Jzc8OpSrrOtKRERYhJNmpIS9SRnKAd8sHQWMPpCw6pqeZwEpJkGm1eatrdPQSa2jY3jXYvKlFgcrYZs15DfoqBvOQE8pKVx/wUA+mJAy/lKkkSdzy3iVyLnh9eNm+Y3t3w4vAG2N9g5/qnPu2zlHsEjUpg5YR0Hr1m1rCF5Q8Xcrhj/Ou1B4/5PtWiwC8um8Y1808sPWYgBEIS7+xr4tnNleyu7eCSmbncuLhwwP4w/T3Xnz86wh8+OswXlxTx7TMnDIswHQxJfOGvnzIuI5GHLu/dc+Z4VLe6OeO3H7HvgXN7XK/Pe3wD3zlrAmdOObah8v4GO5f/cRNbf3zmMaOKgiGJq5/czIy8JO6/eGqf231yxMqXn93KfRdN5eoTFHBi+fhwC/e9VoYA3HfR1BGtpOT0BXlrTwMv76hjS2UbS8alcfmcXM6ektWrkDVS2NwBbn1uC7trbV38ZNSiwOu3L2NyN1HPGwixu9bGtqp2tle1s6eugzZ3gJl5lmhVqzkFSSMSRdds9w5plNxQIMsyHe4AFa0uqlpdVIbTsSpb3SQZNKw71EJygoaCVCMzci38/NJpXfb/+8Zydtc4ePS6OSfpHZzaTP3p27j8x54kiSU5QUNJeiJZMSbL+SkJJCdoo348J9u/ajQTT5uKMxaJ/+LjjDn+87XF8Qv0CeINhPjV2wd4ZlMlH373NApTh6fy0ECQJKWUqCLOeKgNP0YEmvoOD3MLk6lt90SFmcIUI0vHpZGfoog0mWb9kPs7iKLIhTNS+cemGsprGhifnz2kxx9KZFmmNuzfsr/BQVmD4k1T3eYm3aQjUaem3d27abQAqFUCPzp/Ml9cUjTqo2wixJbxXneohWBIOqZwo1EJ/PH6uZx1HEFgqGi2e3lxaw3//KQatUrgpsWF/OXGucNmRLqv3sb3XtpNSJJ58auLmdlLitBQ8cePjmAyqPnJhZMHfYyyBhvjM0y9Cu3dKxL1xaQsE/kpBt7b38Qls3L73E6tEvnN1bO44IkNnDUls08vnUXj0vjbl+bz5WcUE+OreknpGgxLS9N5687lPLupktv+sY2lpWn86ILJQ1JB7Hgk6tRcNS+fq+blU9/h4ZWddfzug8P86OW9XDwzhwtnZrOoOHVQaW8ngiVBw7+/soifvVHGvz+rjv521aLAhMyeqS56jYoFxSksKFaiyGRZ5mi4stP2qnYefvsAR1qcFKcamVOYzNLSVKblWBiXnjjk7220CTegRB8mhytPzinoafZscweobnNT1ebC001kaHN42F1n59ypI3NtHGv4gqHjCjd6jYg/KDG3MJml49KYX5yM1envjOKps7Gv3s6Omnaa7D78QQmTTk2GubNMem6SgdREbdRwOcM0dIbLceLEOfnExZs4ceJ0YXt1O7f/awdWpw+1SuSo1TUi4o0sy7S5/NS0dwozte3u6OsmmxdvIESaSUd+OGImPyWBuYXJ0edZFv2wphv0xblzJvOnDyr547oKHr1hdIg33kCniXBZgx27J8B7+5tw+0OMS09kSrjC0g2LCpmcbSYtUcd9r+7l+U+qenhMaFUiSQkanvriPGbkJZ2U99NfJElmT52NdYdaWB8u4z0u3ciK8en8KlzG+6LfbezhPSAKysDvuVsWMG8Y0odikWWZHTUdPLepkjf3NnLprBwevHQaqyZlDJt5rC8Y4nfvH+apjUe5+6wJfGlJ8bBGHm6raudPHx3hpa8v7ndZ8Ga7l+c2V/GdsydExcGyejtTcnr3YinNSETsx1sQBIFLZuXyyo66Y4o3oHiU/PD8yXz3pV28fdeKPqttLSpJ5akvzufWZ7cgCAJXzh2aCQONSuTW5SVcMiuXX689wNmPrucry4u57bTSEYuAyUky8I3TSrlt5biwj0oTt/9rR7hSYA6Xzc4b1nSg7qhVIj+7ZBpTc8z86OW9BCWZqbmWfv1WBEFgXHoi49ITo75JHW4/26uVVKuPD7fyw9V70KlVzClIYl5RCnMKkpmZbxlQOfuxgiVBw/SE3lOxXthSi0mn5cyp/fen+8+WGv75aVWn706akZK0xGE1VB6tNNt9CNAjZVcd/h5nWfTcuKiQy2bn9kv4i0RRNTliTJZtXmXC4khrtNpWxHA5xaglw6SIPNNyzIiiQIZZT6apU/hJS9SOmBF/nDhxBsfn784UJ06cXolE2zy3uSpaLcOgUVE7hGWwbe5AOFKmq99MTbsS+fHx4ValNHo4UiY/OYGzp5iV0qDJBrItegyjtENdlJlKRUvvZoTDTbPDy8EGB/vC5bjL6u0ctbowalVMyVEqPS0bn8oty4oZn5nY5wzc1FwLeo0Kd8zsoFYtsmRcKo9fO3vIykYPNc12L+vLraw/1ILdE2B7dTvLxqdx1bzey3ifOy2LynVHuszim/RqXvza4l5n84cKbyDE67vqeW5zFRVWF1fOzeOtO5czbgAG2YNhe3U79/x3N3qNyOrblvYphgwVDm+Au17cwd1nDaws+Nv7Gvmssq1LVFdZg50lffg+VLe58QWkXtd15+KZOTz23iGsDh9ppmOnzNywsIB3y5p44PV9/PbqWX1ut3hcp4ADDJmAA5Bu0vGrK2dy/cJC7nttH//dVsuPL5zCedOyRizqTRCEqKfKN1aVsv5QC6t31HH+ExuYnGXistm5XDQzZ8SMvK+ZX8C49ERueWYLqyamD/o4SQlaTp+UGfVAeujy6ZTV22O8cyppdfqZkmNmYXEKM/OTmFeYMijPprHEoWYHV8/NQzWAwf2y8WkYdWoqrE6OWl2sP9RChdVFuztAWqKOkjQjk7NNZFkMSgn0NCNFqcYx6S/YZPeiU4t4w+l/eo2IgMCls3O4dn4BM/IsA/ptx0ZRTcrqe7uQJNPq9MVU0fLi9gc50uxib50tWk7d6vQjCpCWqIg5OUl6UhN14bLpnSXTM816UhK0Ix6FFydOHIXROQqKEyfOiLKtqp07/q1E28SmIfiCIWra3P0+jtMX7BI1ExFobJ4AZQ12HN4gFoMmKszkpxhYMSFdSXNKSiAvxXDKznbmpvtRi8Pb9mBI4qjVRVm9PRpRs7/BgdXpY9XEDPQakcnZZi6akcPkHDM5Fv2AOoNTss0EQl19Je45ZyJfXlY8qtKk/EGJrVVt4egaKwcb7UzPS2LlhHRWjE87bhnv0yZm8OS6o4CMRqWYUf7n64vJHaYy9bXtbv7xSTUvbqkmLVHHTUuKuGx27rD7SXn8IX7zzkH++Wk1t59RyleXl4zIrOpPX91HUaqRLy8rHtB+b+1p5LxpXUchZfV2bl1e0uv2KkE4rmFxhPyUBM6cnMmbe+q5acmx2yUIAr+6Ygbfe2kXb+9p4NzpfUfTLR6Xyl+/OI+vPLsVAbhiCAUcUAxwV9+2hJd31PHc5kqe3VTJ/RdP7eH1MtxoVCJnTM7kjMmZ2DwB3tzTwMvb6/jFm/tZNTGDS2blcMbkzGEfdM8rSmHTD89AO4TfY41KZGZ+EjPzk7hlWTGyLFPX4WFbVTuHmhz86aMj7G/YQbbFEDVBnluYzKQs86gqsz78CCToBibg5yQZeojn0GmofKTZSVWbm331Nt7YXU+l1YXLHyLHoqc4XRFypmSbybLoKUozkp+ccMp6FTbZffiCEqKgVMG7cXEhZ47Ab0YVjrDJMOuZTt9iuj8oYXUqAk+j3UuLQ3le3eZma1VbtIy6zRNALQqsmJBOm8sfFXYyzfpoZE8kZcti0IyqvkOcOGOBU3OUFCdOnCGht2ibWCQZjsZEk7h8Qeo6PD0iZ1SiwMeHrbS7AyTq1FET4LxkAwtLUslLUtKa8lIMx6xkcSpz4fQJuLxD1wmzeQJhbxo7DR1eNh21cqjJiUoQmJhlYkqOmbOnZnHXmeOZmGUeEiFgfGYiIUkRNMwGDU/dNI/ZvfginAwqrS7Wl7ewu9bGm3saSNSpWTEhndtOG8fy0jSSjf33iJmZp6RcqGWB0oxE/nnrIlIGsH9/kGWZjw+38uzmShptXnKTDPzh+jksLkkdkc7s5iOt/GD1btISdbx++7IRS3N5dWcd6w618Padywc0M9vq9LGlso3fXjMzuqzN6Sc/JYHJWb1HQ6nE/os3AEvGpfLqzuOLN6CkMFw5L497X9nL3KIU0o8RrbNkXBp/vWkeP3plL6IgcNmcY6dmDRRRFLhibh5nT83k9x8c5tI/fMw18/O5+6wJg/JGentvA1sq27l1eTHZloELlhaDhusWFHDdggJq2tys3dfIr9ce5Ier93DBjBwun5PLvMLkYfueD7foKQhC+P6leA1975xJOH1BdlZ3sLWqjXfLmvjV2weRZZnZBcmcNiGdidkmZhcknzIG/wNFlmV8/iCJuqERTpIStMwu0Pa4v8iyTIvTR0WLUinrqNVFebOTZzdXUtnqJiTJ5CUbKErtTMMqSjNSkmYkJ8kwqsW0WQVJ/OTCKZw/PXtURnFp1WKfYlss3kCIZruPFqeXBpsi6DTbvZQ3OdhYbqXJoZRUd/qCjEs34g9J4egdfYw3T9iLx6Qj06LHpFPHRZ44cfpJvNpUnDFB3FF+4MRG28RW8eiORa+mMM1IbbuHNpefBK0q6jkTEWmK0ozhKgiG+EzLAJEkmZo2N/sb7ZQ1OKJRNXUdHrIteiZnm5mZZ6E0w8TkbBOFqcZh7aCe89h6Mkw6fnfd7GEzze0PTl+QzUdaWR82Gm60eZlXlMx507KYV5TCpCzTCX3Pbv/Xdtrcfv5607whjfZy+oKs3l7Ls5sqaXcHuG5BPl9YWEBu0vCbzkbO/+d1h3l6YyXfO2ciNy0uGrEBTU2bm/Mf38Bvr5k1YMPnFz6r5sWtNbz8jaXRZZsOW7nnf7vZ+P3Te93nhqc+5eKZOf2u+NTq9LHooff54Dun9csEWJZlvvWvHfiCEn+9ae5xv28by6189fmt/OKyaVw2e/juQUdanPzs9TJ213bw3XMmcu38ggF9xmX1dp54v5wPDjZzycwcvrayhNKME0sXlGWZ7dUdvLyjltd3NWAxaLhsdi6Xz8kdFYb3Q01IkjnY6GBbVRv7G+ysO2SlweZhUpaZ+UXJzC1KYV5h8nEHwqcKTreXr/9zO0/eMA+j4eTcFyRJpsHupaLFRUWri0qrSymHbnXh9AXpcAfITzFQnJYYTcGKCDyZJv2oSfOxuQM4/cFhi/QcLTh9QZrsipDT7PBGI3ea7F6aHYrgk5qoY1tVOwaNShF0IlE7ps40rWyLnvRw6tZA79XxsUGcsUhcvIkzJohfoPuHwxvgSLOT+17bx+5aW49Im97QqUUeu2ZWNJImKSEuzgwWjz/EwSZH1Jdmf4OdA40OJmebcPlCTM42MznbxJRsxadmINEkQ4U3EEKnFkf8M5YkmQONdj461MK6gy1sr24nLzmBFePTWDkxnUUlqUMqskiSPKSd+cPNTp7fXMn/ttcxLt3IF5cUcf707BH1blh3qIV7V++hMDWB/7tiOgUpIzdoDgRDfOGpT5mYZeLBSwdeFvyLT3/G0tJUvrpiXHTZUxuO8llFG3+5aV6v+9z09GecNy2L6xb0v6T7zX//jHlFKXxzVWm/tm9z+TnnsfXcc87EflWVigg4v7xsOpfOHtoInFhkWeaDA8387I0yjFo1D1wylfkDNNo+0uLkL+uO8vLOOk4LR7ENRaSdLxjiwwMtrN5ey0cHW5ieZ+GKObmcPz37pArCw02jzcvWqja2VireOWUNdjJNOs6aksW4DCPzi1KYkGka1dEhfVHVbOOu/+zif98YWETdSBEMSdS2e7qIOhVWJXqnrt3DvKIU7J5ANFKnONUYTctKS9SO6P3u/97az1MbKvjxBadW5cbhQJZlHL5g1Fy5q8CjPDdoRD6raMcf6llZK8OsI8eiJy2x05cn3aSL3nfjY4M4Y5GxGd8ZJ87nlIjnTG24hLbDG2RfvY3adg+17R5sngD6GMO8/uALSqyalDEmDQSHC1mWabb7KGu0U9HiYnt1O/sb7FRYXVgMGsVEOMvMFxYWMDnbTEmaEd0o+f+O5OdsdfrYUK741mwob8HrD3HapAwunJnDr6+cSUHq8EWrDMUAJCTJvL+/iTV7GnhrbyMXTs/mH7cuZNYwlt/uDZs7wM/XlLF2byP3XjCZa+fnj/iA4A8fHSFRp+ZH508Z8L42d4BNR6w8eOm0LsuPVWkK+l8qPJZLZuXyp4+O9Fu8STFqefiK6dz5750sHpcaTaXpi2Xj03jyxrl87fltCALHrW41WARB4IzJmSwbn8bfNlbww9V7mJZj5gfnTe53Ssa49EQevnIG3z5rAn/beJQbnvqU6XkWvnlaKcvGpw36O6RTqzh3WhbnTsui3eVn7b5GXtxaw/2vlXHG5Awum53LaRMzTlnvkr7Isui5cEYOF85QqjG5fEF21nRwoMHOu2VNPPzWAURRYG5hMvOLUphflMKMPMspcW9t6HATDIVGpXADSkWyorAww8Su63zBEDWtbipa3VRYnVRY3ayurqXS6qbR7sWkU1OUZmRWfhLJRi3FaQlK9E6qEUvC0Kd576u3E5RkfvnWAd7c28jvrptN5igsKz8SCIKAWa/BrNccM/qvt8paEcFnT52N8uZ6msM+PUFJJilBQ6ZJjzFoG8F3EyfOyBCPvIkzJvi8qOtuf5C6cHWm2nYPLQ4fh5udYXHG3cNzZmJWIskJ2mjUTH5yAmaDGl9Q4qODzby4pYb15Va0KgFPH1VbVKLA2rtWjGhp2FOdkh+sYU5hMm1ufzTlKRJNk2nWfW5n2vxBie3V7aw/1ML68hbK6u1MzbGwYkIaK8anM6cw+aSUeh8obS4/L26p4R+fVCHJMl9bUcKFM3NIG6GqO7Gs3dfIj1/Zy7QcM7+4bPpJSdPYVtXGDU99xv9uWzKoSlb/21bL0x9XsOaO5V2Wn/vYer5z9sQ+U7BufXYry0pT+dLS/hsju3xB5j34Hqu/sWRApr8/XL2bCquLf926qF8D2PWHWvj6P7bx0OXTh03AiaXR5uGhtw7wXlkT31hVyq3Li/usKtcXHW4/z2+uYuNhKw5vkK+fNo7zp2UNmcn10RYnL++oY/X2Otz+IBfPzOHyOXkDrrJzqhIMSRxodLClUonO+ayyDZs7wPQ8C4tKlBLlcwuTR2V00mNvl/HG3gbW3n36KRk51Bduf5BKq5vKVhc1bW7Km53RqJ02l58Uo1aJ1kk1MiXHRLbFEH1t0A5OdFv6fx9Q16FU8dSIAhq1yCNXzeT8Yxijx+kfkiTT5vZH07XKyiv41sWLgLE9Nojz+SIu3sQZE4wV8cYXDFEXjpKxOn2UNzujpsC17W6sTj8GjUqpzpScwJRsExaDVhFmwuW1B+o5Y/MEWLu3kRe2VLOzpgOtqmtkjkGr4k/Xz+G0iRnD8ZbHJN/424f8+vrlGPXx4MaqVlfYt8aK3RvgaIuLFePTWDEhnWXj006K4DFY9tbZeGZTJa/vqmdOQTJfXKJUCxmJCk7daXX6uO+1fWwot3LfRVO4bHbuSRkA270Bzn98A19aUtRnVajjcd+re8lPSeiyvzcQYup9a1l/z6o+vSG+9vxWFhSl8OUBnveOf+8gJ8nAD86b1O99nL4g5z2+ni8tKe53Fa11h1q47R/b+L8rZnDxzJwBtXGwbKls475X9+HyB/nJBVM4Y3LGgL8XHn+Il7bV8OS6o6hEga+uKOHKuXlDFiEiSTJbKttYvb2ONXsayDDruHZ+PhfMyBnzPiCxyLJMdZubbVXtfFbRxmeVbVRYXYzPSIxG5swrSj5utNdI8MyGI7yyq54jLW7OmppJhknP9FwL03Mt5KcYxqT4ZnMHomlYR60uXL4gn1Uon5HTF+xSEas4zUhJupGStETykg193hNCkszEH7/VI2JQoxI4b1o2v7hsGqYxWtThZDBWxgZx4sQSF2/ijAlOlQt0ICTRaPNS0+amrsNNdVtnxaaadjdNdh9alUhesoG5RUoUQsQcOCLOpBqHLz+7ye7l9V31vLClhqMtTtQqEUmSuf/iqdywqHBYzhlnbOH0Bdl02Mr68hY2lFup7/AwrzCFFRPSWT4+jSnZ5lEbet8b/qDEO/saefrjCg40Orh8Ti43LS5iQuaJGbwOFlmWeW1XPf/ZUoNJr+Znl04jw3TyQu7vemEHrS4/z968YFCfq9MXZM7P3+XNO5Z3ie7bU2vjhr99ys6fntXn9e4b/9jGrIKkLj45/eGDA038+OW9bPz+6QNq82cVbTz+3iHuv3gq4/v5+X90sJnv/2839104lfNnjMzMekiSeWFLNY+sPciMvCR+etEUxqUPPHIyEJJYs7uBP310hFaXn1uWFXHDosIhrRjoDYR4f38TL22t4eMjrcwrTOGyObmcNy3rczmIbXX62FrVzpaKNrZUtbOvzkaGScf5M7IpSEk4qSXKI5FDe+ts7KrtYE+djYONDmblJ6EWRabmmJmWa2FqjpmS9MQxFaETS2xFrEiUztHwoyQpglxBagIlaUZK0hMVYSdN8djxBUKs+NVHvfoNatUiFr2GP1w/hwXFA/OvitM7p8rYIE6cgRAXb+KMCUbLBVqSZJocXuo7PFS1uqlpi6Q4Kc8b7V4EICfJwJQcExZ916iZ/JQERMAXkk76bNvRFiev7Kjjv9truf308QMyBY3z+UGSZPbW29hQbuVIi5PXdtZTkJLAignprJiQxsLiVIxDVD7XGwiNmD9Eo83Lvz6t4l+f1TCvKJmFxSlcMTfvpJa6b7J7+dHLe9lZ087PLpl20sPsX95Ry8/f2M/bdy4nY5CeDa/vqud3H5TzzrdXdln+4pZqXtlRz7+/uqjPfe/49w4mZ5u57bSBiTeBkMS1f/mEe86ZyMKS1AHt+9Cb+9l0pJXV31jS7xS/dYea+frz2/n1VTOifigjQYfbz6PvHuLFrTXccfp4blxcOChBRJZlPjzYzJ8+OsKBBge3nTaOK+flDblo2Ozw8trOelZvr+Oo1ck5U7O4fE4ey0rTxqwQcDzcfqVEeeQau6O6A4DZBUlKZE5hMrMKkobUzH0g+IIhDjYqVRL31dvZW29jf4MdgMnZZqbmmJmVn8SETBMTMk2nhL/PiRAMSdR3eDlidVLR4uKoNZyG1eKi3ualND2RI1Ynxxp5qUWBm5cW8b1zJo05X6iRZrSMDeLEGUri4k2cMcFIXaBlWcbq9IUjZTxdUppq2tzUd3gJSBKrJmbg9AbJC6c35ccINFlmfZ8hte/sa+Tu/+xiSraZ/3x98bC8h77eV7PDx9HoTJIzOpt09pSsAaUXjCWCIYkjLS721tnYW29jUUkq50zN6nP7nXvKeHmfnQeu7XvAORZosHnYUG5lQ7mVjeUtBCWZpePSOGtKJguKU/pVhrm/HGlx8ubuBtbsaaAo1cifb5w7ZMfujizLfFbRxnObq3i3rIkVE9K4aXERy0rTTmq0kCzLvLS1lp+vKePMyZn89MIpJ6USWSzVrW4ueGIDj107izMmD6wseCzf/Od2xmUkcvdZE7os/+Wb+wlJMj+5sG8D5G+/uJNx6Ua+dfr4AZ/3x6/sQZLhl5cNrDKWNxDikt9/zLnTsvh2tzYfiw8PNPONf27nkatmcsEIReBE2N9g45dvHuBAo4MfnDuJy2bnDvr7vKWijb+sP8L6citXzM3jq8tLFJPYIeZAo52Xt9fx8o46AL6wsIBzpmYNyKdoLBIKV+XbWtnO1qp2tla20ezwsWJ8GkVpRuYVKqlWQ2mA22pz8Y/Pavna8iL0+uOnuYYkmQqrk1+vPUiz3ce4dCPv7m/G5QtSmpHIlBwzU7LNTM2xMCXHjMUwcoK42x/E7gn229R7qM/9uw8O87cNFfhDxy4aIQpgNmj46YVTuHBGTlzEGSRx8SbOWCRuyBAnTjfaXT7qOrzRaJmasDATqdjkCYTITzGQlqiLCjMz8rKjhsA5SYYB32hdviA/fXUvr+2qJxCSOdLiHJb3ZvMEwvnbkVkhF9WtLg63uPAEQuRYDJSkK/nby0rTuHFxEZOyTk56yEjjC4Qob3ayr97Gnjobe+uUUt4qUWBKthIOnnKcAXNLYx17m/wcPnyY0tL+VbM5FXD7g3x6tJWPD7eyvryFIy0uZuZZWD4+nS8tKWJmnmVIfV9iBZujVhcrJ6Tz9ZXjOGPy8Pguuf1BXtlRz3ObK2mwebl2fj7vf2flkIpQg6Wmzc29L++hvMnJ49fO4vRJgxdK+svxyqgHgiG++9IuLp2de0LCjTcQ4sODzXzr9J6/lR3V7VxznNLcKlHgOGOgPrlkVi5feW4r9180dUDXa71GxW+vmckVf9rEGZMzmJGX1K/9Vk3K4A/Xz+ab/9yBKMB5Ixg1NTnbwnO3LGDNngZ+sWY///y0ivsvntrvtscyvziF+cUpHGx08OS6I5z92HrOnpLJ11eOY1quZcjaPCnLzA/PN3PPuZP4+LCVl7fXcvkfN1GUZuSKOblcPCvnpKYLnixUosDUHAtTcyx8cUkRAHUdHnbXdLD5aCt/+PAwBxrtZFsMzCtKZl5hMnMLU5iYNfgS5Xsb2jncbOuXcBNpY2mGie3VHbQ5fRh1atbfc1q4+qUSofPJ0Vae3lhBvc1LfoqBZaVpZFsMTM1RRJ3hMvb/28YKnni/nIevmMHlc0Z2IJ+gVePyBQn046IlydDhDnD3f3bx3Zd2kZ+SQHGa0jebkGkiL9lAUaqRnCTD5zYqLU6czytx8SbO5w63P0hNW2e0TCSCpiYcQTM528yhJkdUjMlPSWDVpIzwcwO5SQmDrjLQGzuq27ntH9tpc/sJhJRAuFaXf9ApIr5giOpWN0etLprsXvbW2aJ52Vann9Rw9YTiNCNTcsxcODOb4tREClMTxnxIcwRvIMT+Bjt76+3sC0fVlDc5sRg0jEtPZFqumZuXFjE1x0JxmrHfnaOlS5fyXPmnVHm9nMrSTUiS2VtnY+NhpYT39qoOMi06zp+Wzd1nTWDxuLQhny090uLko4MtvLS1podgM1zeF5VWF89/UsWhJgetTj+3LC3mopk5/fp9l9Xb+ayidUCVjgaCJMn8e0s1v1yzn4tn5fCH6+ccM2UrJMlD0onfVtXGT17Zx+pvLOnzevC7D49g0Kr40QWTT+hc6w61kGHS9RCIJUlmf4ODqccRA9SiQEganHoztyAZo1bN+kMtnNlHNau+mJpj4fbTx/PtF3ey5o7l/b5unj4pk99/YTbf+tcOBAHOnTY8As7/vXWAqTlmLpyRHR0AC4LAhTNyOH1SBn/+6AhXP7mZS2fl8t1zJg7KNHxilonfXjMrXGa8giv/vIkFxanctnIci0pShmzgrRKFcApmOj/3BXl7byOrt9fy8NsHWFqaxuVz8jh7Subn5t7VG7lJBnKTDFFB0OENsLOmg62V7azd18T/vXUAURA4Y3IGRWlG5hYmMys/qd/X1bpWPy12P6GQhKqfIn2r00eLwwfAZxWtnP/4Rp778gLOmZrVJXq1zeWnrN7O/kY7e+tsvLarnqMtTpIStEwNR+hMyTEzNdtCcXr/78V9saWijUBI5vv/282mI608eOm0Ef3u7G+w9+p3A6BViUiyTGqilktn5XLhjBymZJtodIT9dVqV9KtdNR38Zf1RqtvcqESBwhhhpzhcLr04zUiG6fNb2TJOnLFMPG0qzpggNjSy/GglYmJqVIzp9J3x0BpOeUrQqqJiTF6MIXDEHNg8AmG8wZDEE++X88ePjhCS5C43dLUo8MYdy5iU1XuIuCTJ1Ns8VFrdHLU6Y9KdXNS2u9GpVRSnGVlUkoJRpw5XQkikONWIJeHzZQLp9AUpq7dz1Orks4o29tXZOdyiCDURg8VpORam5ZrJTzYgiicWQXLnPz5lXnYaN54xMB+Ok011m5uN5VY2Hm7h48OtyLLMknFpLBufxvLxaRSmDn1qRPcIm2vm5TG3MGVYBRtJkvnoUDPPbqpi85FWzp2WxU2LC5lbmNyvju6umg5+90E5Gw9b+cKCQn5y4eQh7yAfbXHyg//tIUGn4ivLS1hamtbntrIs88KWGl7aWsN/v77khNK7ypscXPnnzXz3nInc2IdB+ZbKNm7622cDLrXdG99+cSeZZn2PtMyqVhdn/XY9ex8455hRMfe+vIfkBA3fO2dwaZ2/evsA1W1ufv+FOQPeNxiSuOrJzczOT+anF/Wd2tUb75U1cfu/d/DoNbM4d1rfaZiDZc3uBn7y6l4WFKXw80unkW7qKc7UtLn5+RtlbD7ayt1nTeCGRYX99vDpjVanj2c3VfK/7XXkpRi4ZWkxZ03OHLZ0w7oOD6/sqGP19lqa7D6uX1jAqkkZLChKGdQ5vYEQbS4/2Rb9mBvwBkMSB5scbKtqj/7Vd3iYmGVmbmEScwuTmVuQ0mfVqA2Hmnn47QPUtnuZVZDEkpJUpuVZmJmX1Kef2fv7m/jWv3bgCYQAJQ1Iqxb5wxfmHDdaz+MPcaDRHo3SKau3kaBVs7Omg0nZpmjK1dQcMxOzBuajM/fBd2l1+gHQqZXiEE9/af6w3N96Y/6D79Hi9EVfa1UiIVkmw6Tj8tm5XDAjh8nZpn59BwMhidp2TzjN3U2F1Uml1U2F1YXZoKaq1R2thNUp6iRQnJZIcsLAqpKeqsTTpuKMReLiTZwxQewFOve2Z0hIySAvuaffTEScSRnGik39oarVxdf/sY2jLS58wZ4zxwlaFb+5aiZLxqVFje8qwulOR1tcVLa6CIZkitIUwak4LTFcplKpaJBlHnsd0P5gcwfYV69E0uypU6JqKlpdZJh0nDEpgzSTnmlhwWa4OulT7l3DqklJ/OGmpUN+7KGk3eVn05FWNh628vFhKwKQadazfLwi2EzPHdpUqAiHm528uaeBN2NSoi6Ynj2sgg0o5q0vba3l+U+q8AZCXL+wkOsW5PfbaHdLZRu/++AwWyvbuGFRIbcuLx7ytI1gSOJvGyt47L1yrpmfz/fOmXhMs2dvIMRPXtnLhwebeeK62SwZ17fIczwabB4u/+Mmrpqbx91nT+x1G5tHKQv+5WXF3NLPctl94Q9KzH3wXf7x5YXMzE/qsu6tPQ38/sPDrLlj+TGP8dNX92LQqvjheYOLADrY6OCSP2xk64/PInEQptoVVhcXPLGBp744b8D/+3fLmvjuS7v47dUzTyj1rC+sTh/3vbqPTUesPHDJNC6KicKJZf2hFl7YUsPhZgf3XzSVJccQCvuDwxvgxS01/HXDURJ1ar6+chyXzModNs8OWZbZVdPBa7vqeXlHHQlaNZfPyeWy2bmUhCts+YIhmmw+6m0eGmweGmxeats9VFpd1HV4sDp9uHyKyPDG7cuGNP1rtNJk93YRc/bV21g6Lg2tWmR2QTKzC5KYmmOOXpODIYn9DQ62VLZR3eZi7b4mmuxeJmaZmVOQxOyCZOYUJFGcZkQQBH799gGeXH+0R0lstSjwrdNLueP08QMS2YIhiaNWV9gY2UZZgyLsOLxBxqUbmZKtGCOPzzQxNcdMUkLPFGebO8DMn73TZZlKAI1a5LFrZg+LkBqLPygx8cdvoVYJhCSZ3CQDl8/J44IZ2YzPSBzS/og3EKK6zR3tL0bKnVdaXTQ7fEzLUSqWFcVG7KQqAs9IehANN3HxJs5YJC7exBkTxF6gt5eVM3PiuFFZjliWZf6ztYafvrqPoCT16dcgAEVpCVRY3aQl6sIlJ42dETRpRgpSEj7XJnZWp4+9dTalwkWdjeo2N/vq7eQlG6KRNFPDZUtH0huh6AdrAKj8vwtG7Jz9wRsIsbWyPSrW7Ku3MSHTxNLSNJaVprGgOGXIqkJ1JyLY7Khu5+MjrZw2IZ0LZmRz+qThFWwA9tXbWLO7gac/rmBGbhI3LSnknKlZ/YoykGWZzUdaeeKDcvbW2fnikkK+vKzkuN5Hg+Fgo4N7/rsLhzfIr66cwbyiY5eKrW51c9s/t6FTi/zx+rknZMBpcwe46slNzC1M5peXTe91ECHLMne+sBObJ8AzN88/4YHGxvIWfvvuIf5325Iex/rNOwdptHn59VUzj3mM+1/bh0Yl8KMLBhb5Esu5j63nqytKBu1/8fzmKtYfauE318wccCWySHTC49fO4uxjGKGfCGt2N/DTV/cy/xhROIGQxLObKnn8vXKWjU/jRxdMPuFqh75giFd31PPndUfwBELcuryEa+fnD9s1BpTB8bpDLazeXsu7+xqRAFEQCEpyNPJDFASCIblXw1izXs32n5w1LKL1aMcbCLG3zsb26nZ2VHewo7qDK+bk8r1z+45qa7B52FHdwfaqdnbUKKXDE7QqZucncajJSV2Hp9f9dGqRpaWpPHHdnEGJphFkWabB5lUidOpsHGhSypjXtnvITTIwOZJyFU6/qm13c/Pft+DtZcJMLQrcsKiQH10w+YQi0I6FNxDiy89uYVFxKudNz6Y0I3FYznM8nL4g1a2dYk7ksbLVTZvLT0o4tX5eYTImvZqisLBTnGYc1t/vcBAXb+KMReLiTZwxwWi/QEuSzI6aDr730i4qW11I/fjVrRifxu++MGdMzYIMBlmWabL7wibCNiWyps5Oo91LcZoxmvo0I9fC5GzzSa/C848NB3n+k0peum0F5kTDSWuHJMmUNdjZeNjKxnIrkixTYXWxtFRJg1o8LnVYRa3yJgdrwhE2Va1uTpuYzqWzclk+Ib3fHXaPP0RZgx2zXo3FoMFs0PQrRN4flHh7XyPPbapkX72dGxcXcNnsvH6n+ciyzEeHWvjLuqPUdri5ck4+X1pSNCwph/6gxJ8+OsKf1h3mS0uKuevM8cd9jx8eaOauF3dy2exc7j1/8gmJuN5AiBv/9ikWg5Y/3zCnz4Hr6u21/GLNft6+a0WvAsBA+f5/d2PUqXtNOfryM1tYWpp23Oie339QjizD7WcMvNpUhD99dIRPjrby7C0LBrW/LMvc9PRnZJr1PHIcsak31u5r5K4XdvK762YP2Hunv7Q6ffz0tX18fNjKzy6eykUzc3oV35odXn719kHW7G7gaytL+PrKcSfsBxKSZN7Z18if1h2hus3NzUuKuXFx4bAIoLG0Or2c9/hGmh2+428MaESBGxcX8tOLpg5ru04lfIEQugF8/v6gRFmDna2Vbfzyzf3H7Ofo1CKZZj3Pf3nBkKcs2dyBcGSOjbJ6O2UNdsqbnRSmJFDR6uqzTLdOLTIuPZGnvjiPnKSTd+8+mdjcASrCkToNNg/7GxxUtiqR3w5vkAyTTonWSTVSmpkYjvw2jlrPxNE+NogTZzDExZs4Y4LRcoG2eQJUWF3UtbvZ3+CgwuriSIuTylYX3sDAjDUnZppY++0Vw9TS0Yksy9S0edhbbwuX51Zm1PKSDXgCIablWJiaa2FajjKjNtxRG4MhFArxg5e2kZ2o5e4LZ43oues7PGwst7LhsJVNh634ghKLSlJYVprG8vHplKQbhzWd7lCTgzW7FcGmus3NqokZnB+OsBnMDOv/ttXynZd2oRaFaPi9WhRI0KpI1Kkx6TUkJWhIMWpJNWoJSDIHGuzU27wkaFXcuKiQq+bm91t0kSSZd/c38fsPDlPX4eHW5cXcuLAQ0zAJqHtqbfzyzf20u/386soZx63+E5JkHn+/nL9tOMovL5/OJbNyT+j8wZDEbf/cTpvLzz9vXdhn57uq1cUFT2zkd9fNZtWkE6/4FQxJzP/Fe/zlpnnM7yXCaPFD7/PoNbNYVJJ6zOM89NZ+vP4QD1wybdBtqWv38JXnt/DszQsHLUo12Dyc8+h6Hrlq5qAiaN7e28i3X9zJ778we1hSqCK8uaeBF7ZUo1erePCyaX2Ktzuq27n/tX1YnX5+cuFkzpmadcLXDVmW2XSkldd31fHqzgauXZDPrctLyB3GQbIvGOKGpz5lR3VHj/Sd7qhEgTduX/a5L0U+FBxqcnDe4xsI9WOWSi0K/PzSqVy3oHePraHCGwjxlWe3suGw9ZjbiYJSUe5PN8xl5YT0YW3TqYQsy7S5/FFvxcpWFx3uADuqO6hsVaqVZpv1FKd3RukojwnkpxhPWpT4aBkbxIkzlJxa8W9x4owCfIEQNe1KLvFRqytcctsZreaUlqhl1cQMREFgep6FS2blUJJupCDFSF2Hh7f3NvC/7XUcbXGiVYt9ijo17e4RfmedvPBZNdur2/nVlQOfSe4vIUmJBNkXrvQUybv3BEJMyDQxLcfCWZMzuOvM8UzOMg9pha/hRKVScdOScTz6XjkHGzqYmJ00bOdyeAN8crSNjeUt7KmzsavWxqz8JJaVpvHFxYXMzE8athBwUDp0B5scvLmnkTW765FlpQrNHWeM5/RJGSccYn3mlEw0KiFahQ0gKMnYvUHs3iDYvD32UYnw15vmcdqEjH6nToYkmbf2NvD7Dw7T5vLz1RUl/8/eWYZHcbZt+NyNu7sSN0ISAiS4aykUqBeq1P1tv751dxcq1KEClOLumiBxJ+7uulmb78cmKRLZJBvgpTmPo0eBnZ2ZtZnnuZ77vi5uG+eKoe7Q3CIlMgWfH8zi55N5/Ge2D3dGjuhzcFvXIuX17alklDex6eEJ+F6U0NRfBEHg433nqGpq55e7x/Qo3MgUSp7dmMSy0c4aEW4AzuTVoq0lZrSrxSWP1bZIKWuQqDWJ1hKJ+pyU94WThQHGejrsTCodcHKYg5kBbywK4vlNyYS5WfQ7vWlukD2CMIrH/oznq9tChywOfv5IByI8rHhlawqzPz3G69cHcn03VTihrhZsfngCG2OLeXVrKjuSynhihjfedgP/zolEIiZ4WTPBy5rbxrnx7dEcpn10hOtHOfLgFA+8bAf3fe4OPW0tfr1nLDd+G01WRRNSRc/fFRcLg2HhphuUSqHfLejxhXXoaolpUyr63FauFHh+UwpfHcpitJsVoR3+Of4OJuhpa+6er6+jRX5tS5/bKQVolSq486czeNgYsTTMWdV2dZnbr682RCIRVsZ6WBnrXdLSKwgClU3tKlGnWpWKdSavlg0xRZjo6xBfWIezhWFHxY7q/+7WKo9GJ3ODf2Wb4jDDDIbhypthrgk0ra53turkVjWTW93Skeak+nN1czsKhYC7tRGeNsYXetH0I82puK61I/a0hPTyRvS1xbRdJOTEvTxryMvLz0ciU/Dfv5PYkVSGAKS/MVcjKyZyhZKsyuYLPGrSyhpRKAX8HEyZ6GmFs6UhQY5m+Ngba3TQdqV4/q84AhzNWD5Bc6lTCqVAUnE9x7NUrVBxhXW4WBoy0cuaaX62hLtb9Nt3o78IgirGeXeKKiWqtL6N6X62zB/pwDQfW4z0NSt4PLsxkc1xJWpN0g11tdj31GS1/TrkCiXbk0r56lA2bVIFD0315MZwlyEt/44tqOXZjUkY62nzwbLgHhPlziepuJ6HfosjyMmUD5cFY2ow+GvCp/sz2RBTxMYHI3Hq5f36eN85EovrWb08XGPvy8tbUhAQeGvxyEsei8qu5qeTefxw55g+9/PJvnNUNbfz7pLgQZ3P76cL2BhbzOaHB24yLggCj/wRh0Ip8O0dowdUqbI7uYz//JXIqtvCNCaU9Xasl7emEOZq0WsVTkOrjM8PZvH76QLuiHDjiZneGrvG5FY1s/pYLpviS5jqY8NDUz0J7UbQGywNbTJu+PokhTWtPV5HQpzNWDHenblB9kMm2v6v8cnuFAJcLJgb1L8Kv2f+SmRjbHG3jxnoaCGRKbAz1Weyj6oi1N/BhNJ6CQlF9cQXqvxz2mUKAh3NCHY2J8TVnFAXc5wtuk/DUgeJTIH/K3t6bJnqOje5AntTfRzNDfB3MKGuRdWClVfdgrWxHnMC7TDtSKoMdDTDzdLwqvRXvFpQKgXKGiUqUafLW0e18FlU24qdiR662lrn+eoYdv3Z0dxg0NHww5U3w1yLDN+hhvlX0yRRtTl1VtHkVjUjBg5kVNImU+BsYaBKcrI2YpqfLfdaG6vSnEz00BrkaoGzhSH3TfLgvkkeVDRK2Jtazqa4YpKKG9DTVg1w8qqbsTTq3bhUUxTUtHD3L2cpqWtDrhTQ0RKRWdHU7+SNdrmCzPLmrtan2hYphzIq0RaLVPGeTqbcOtaVICczPG2MrtlVFyMdMZVNg6+eKqpt5XRuDQczKlWpUCIRE7ysuCHMiY9vGoWLZe9ChSAI7E0tx9JID3drQ2yM9fo9ABYElX+OKiWqnPIGCdP9bXlmti9TfW2GdLJz78QRbIor6XM7XS0xf66MUEu4kcqVbIor5usjOfjbm7ByksqwVh2hMreqmXd3Z3D7OFem+qo/wW6Vyvlw7znWnSniiZne3DdxRJ/f/c4Y8De2p/HkTG/un+yhkba3304V8EtUPn/1Idycyavlh+N5bHlkgsaEG6VS9X389OaQbh9PLW1ErOZr1BKLkfdSTaEu84MceG1bKgU1LQP23xCJRLy1eCSzPz3GprgSlo7u/yRh3kgHlAI8+kcc3y4fzSTvoWvbmDfSgXEeVry6LZVZn6iqcBaFXFqFY2aowysLA7hlrAuvbUtl+kdH+L+5fiwLcx70pNXDxpj3lgbz5EwffjyRyx0/nGZOoD2LQ52Y5G2tsRZPMwMdNjwQyaKvTlLRKLlEwBGLYLqfHd8dzeWlLSnMC3JgaZgTER5W/+qJ+W+nC3jYUAu5wqFf9+nTeTVdf+4URKyMdJnkbcNkH2siPawvMVj3sjVhckebkiAI5NW0kFikMk7+/lgu6WWNmBvqEOKiSsIKdTEn2NkMYzWFxKyKZrTFF1Zx6miJECFCLIYJXtbMCbBniq8Ndt0kEDa3y8koaySnqpm4gnq+O5rLufImdLREFxgj+9ub4mNvjL7O8PQKQCwW4WRugJO5ARMuSrKTK5SU1LeRX9PaJe4czKgkr7qF4ro2tMQi3CwNGe9phZ6OVkcaliEe1sbYmfZ/HDPMMNcKw5U3w1wT9KauyxRKijoiE4vqWsmsaOoSa6qa2rEw1OlKcPKwMcLXzgQXS0NcLa+MAVtNczv70yrYl1bB8/P8BlWqri770yp4/M94pApFVwKWoa4Wry4M4OYxrj0+r02qIL3DGDClpJHkkgYyK5ow1NUiyMmsy0g4wNEUdyujf9VA+L3tSaQU1/PbQ/3zLWqUyIjOqeF4VhUnsqoprmtjnIcV40ZYMtnHhpFOZv1ajWqVygl6dS9aHQNXPW0xjuYGeNsa42dvwggbI0ZYX1o1JggCScUN7EopY3dyObUt7cwJtGdWgB1TfGwvaxvbwi9PkFzS0OPj2mIRX90Wytwgh173I5Ep2BBTxLdHctDX1eLRaV5cP8pRrYlJbYuULw5m8eeZQm4Md+bJmT5qt8dEZVfz3KYk7E31eX9pcFeEcV/nqqkY8PPZk1LO0xsSWHPP2F4TrTpjwVdOGjHgdqLuiMmv5b41McS8OLPb9/2p9Qm4WRny5EyfPvf11aEscqta+KQHIag/3PfrWUY5mw/K/BhUCVJPrk9gz5OTB+znsjelnKc2JPD17WH9EggHyp6UMl7akkKkpxUvLwjAtpvJK/wjBL+5Ix1rEz1evz6QkIti3gdDQ6uMv2IL+fpILg5m+jw01ZN5QQ6DXn3vpLS+jeu/OkFti/QCM90ID0vW3R+JIAikljayKa6ErQkl6GmLuSHMiSVhzniq8Zu91rjnp9MIIhExBXVEelgxM8CWMFdLPHvxThMEAf+X92Cgq8UEL2um+NgQ6Wk16PSyzjSs+ML6rgodZwsDGiVyQlzMCXU1J8TFAi9b426/L+vOFPLC5uSuhbER1kbMDbJnmp8toS7mA1pEkimU5FQ1k1rS2GWQXNEgoaiuDS9bYwI6Uq4CHc0IcDAdEsP7axWpXElxXSv5NS2UNUhIL2skv7qVvOoWShva0NfWws3KsGvc7naez461sW7X93O48maYa5Fh8WaYa4LzL9BfbDtFo9iko9WphcLaVsRikcod39YYF0uDjnYnVUXNlU4nupLIFUre35PBzyfzL1mNFAG3jHXpakloaZeTXqYSaJJLGkgtaSS7qpkJnlYgEhHkaMrIDsFmMOXN1wJKpcDmuALe25XB2Vfm9rl9dmUzO5JKOZ5VTUJRPe5WhkzytmGStzXjPKwGFacKcOO3UZzNr7vk37XFInS1xciVAlK5EiNdLUz0dZDKFWhriWmTKpgZYMe8IHsm+9hcdjGzvlXKhpgitiWUklLa2O02ulpinp7lzYNTvXrcT6tUzh+nC/nuWC5WRro8Ot1L7Ulhu1zBr1H5fHkomzHulrww309tf45GiYwP9mRwLLOaeyeOYHmEm1oCpiZjwM/nTF4td/18hs9u7j2aWhAEHvsznpZ2OT/dNfhY8PN5c0cajW2yHmPA53x6jP/M9lHL+PebIzlklDfy+S2hgz6vbYmlfH4gkwNPTxn0631hczJKpcA7N4wcsGC9PbGU5/5OumzGqbUtUlYdzmZjbHGPVTidtEkVfHs0h9XHcrkjwpX7J3tqJIHs/P2vP1vI98fz0NES8cAUT5aEOWmknTavuoVFX52gqV2OIIC+jpj3lwZfYv4tUyg5llnFprgS9qdXsGCkA2Gu5iwc5Yi54b9nzKBUqgSt49lVpJQ0cDC9ElMDHcZ7WnX8Z31J9WebVIG+jnjIxwDl9W0kFDcQX1RHQmE9ScUNaIlFBDubdVXnjHKxwMZEj6OZVaw7U8hMfzsm+VgPmX+NIAgU17V1iDmNqrSr0gZKGyQ4WxgQ4GBKhIclLpaqpEwHM/1/9VhpIEhkCopqW7uMkysaJKR1pGKVNUgw1tPG3doQdysjLIQm3rpjKjAs3gxz7TAs3gxzTXC+eHPD+9sI9BmBh41Rl0Cjid7Za42qpnYeWBtDamkj7fLuTZNtTfQY72lFSqmqXNjaWE8l0HTEcwc5mQ0PPjqobJJwMrua41nVVDZKaGiTE2BvzDtLR/X53duRVMqelHIme9sw0dta4zGlf54p5I3tabTJ+jaQBNASwbtLg1gU4nxF/IdSShpYE53PtsRSgp3MuW2cK69uS6WhTXbBdnraYq4PceSDpcHdfgebJDL+jivmi4PZOFsY8Og0L2b626k1oRYEgZ3JZby/JwNjPR1eWuB/Sdl3bxzKqOCFTSl42RrzzpIgXC3Va8c5cq6S//6dzJxAO15cENBvz6mD6RUcPld5iZ/MufImbvw2iufn+3Pr2J6r6QA2xhbz3u50dj+hmVjwTgRBYMnXUTw2w6tbU16JTEHgq3s5+uxUtVbqVx/LIbG4gVW3hQ363NqkCka/tZ8ND0T2u1X0Yprb5cz97Bj3TRxc1dLWhBKe35TMt3eM7mopGWo6q3BCXCx454agHqtwQNXS+c2RbLYnlvHETG/uHO+uUYN0mULJ9sRSvjmSQ0ObjPsmjeC2cW6DFrMzyhtZ8nUUrVIFetpiEl6Z3WslYUOrjD2p5WyIKSK5uIHpfrYsCXNiqq/tFUvRuVK0yxXEF9YTlVNDdE418YX12JvpM97TisneNowZYdlt29HlQK5QklnR3CXmVDW1czSrCidzg47qHAtCXMwJdDS97AsRtS3SrirlsgYJJ7KqyalqxsxA58IKHUdTPKyv3XbyoaZNqiC/5h/j5ORzuXz74BxgWLwZ5tphWLwZ5ppguDSyf3S2LrS0yy/oAb8YEfDoNE9CXC0Y6WTW60D+30abVMHpvBpOZldT3iBhZ3IZgY5mTPK2ZqqvDaGuFkOa9NQfalukhL+1n748f0UilWC35ZEJOJgNXYRvd0jlSnanlLEmuoC00kYWhzqxItKtKwHmswOZfHMkp0to1NUSEepqwW/3jbvkfW5olfFzVB4/n8xnvJcVN4e7MMXHRm2RMa6wjrVRBZzMqeaZOb4sDXNWW/yta5Hyxo40DqRX8NICf24Kd1HruJ0x4D8cz+WjZaOYH9x7C1h3HEir4LE/4/nkplHMG/nP80vqW7n5u1PcONqFJ2b23haUX93Cgi+O89UQmOYmFtVz+/eniHlpFvrdTJaTixu4/YdTJL46W6337McTeZzNq+Xb5aM1cn5PrU/A2liXFxcEDHpfp3JruOeXs2x7dCJetgNvuekUcFYvD2eit2Za5/qitkXKa9tSOZpZ1WcVDsCJrGpe254KwGsLAzV+nkqlwMGMSr4+ko2hjhahrhbcPcEdq36mep1PfGEdN393igXBDj36L3VHXnULm+OK+TuuhDaZgutHObI0zJkgJ9N/5SJGS7ucmII6onKqqWiUsC2hFHdrIyI9VFU5ER6Wg/qcBktDm4yk4noSOtutiuppksgIcDAlxMWc+yZ59OkbN1RIZAoyyptIK1WJOmlljWSUNWFvqo+pgTYBHWJOoKMpfvYmw0baA2B4bjDMtciweDPMNcHwBVo96lqkPPd3IvvTKlHnh68tFrHj8YlqJeJc6yiUAsklDZzIquJEdjVxBfXYmOh1iTVjR1hd1mSw/nLDqpPEF9X3+Li2WISNiR6bH56gsTYddShraGNbYinfH8vDWE+L5ZHuLBvtjJnBhf4AlU0SIt89hEIpoNVhgrjj8YkXJN/UNLfzw4k81kYXMNLJjMdmeBHpYaX2pKqotpX39mRwOKOSlZNGcP9kD4z01Pcp2JVcxitbUwhxMeftG0aqvQJd1yLlifUJFNa08O3y0QP6ve1LLeeJdQl8evOoC7x/6lulLPs2mtkBdjw7x7fX90KmUHL7D6cJcDDltesD+30OffHe7gzKGtp6bHNaf7aQzfElrIHpS5EAAQAASURBVLs/stf9LP/xNI9M8yKrsokzuXV8edvg26YAjmdVsepwNr/fF6GRSs23d6ZxJr+Ovx+MHNRK+ub4Yl7cnML3K8L7Vf11PgfTKxjtZtGvlp89KeW8tCVZrSocmULJmugCPtufyQQva15c4K/xSbEgCJzKreGbo7mcyavh5nAXVk72GLCfSnZlE+aGuv2OdgeVoHQmv5ZNccXsSi5nso8NQU6mLA5x0njl5P8SDW0yzuTVEp1TQ1RONZkVTfjYmRDpaUXECEsiPKwwu4JtZ4IgUFTbRnxRHfGF9dw3acSg/Xg0iUIpkFfdTFpZk0rQ6Wi9qm2V4mFtpBJ0HEwJdjbF1950QN/dfxPDc4NhrkWGxZthrgmGL9CXUtkkIbW0kdQOj5qUkkZK6tu6HheL6LMSw1BXizcWBbFsAMkp/+sIgkBedQsns1WR3AfTKxGJRIz3tGKClzWTvK1xtTS8qldbZQol0Tk17E4pIya/jqzK5m630xaLsDXVY9NDl0e4EQSB03m1rInOZ39aBdP9bbk13JXJPja9tjQ9uDaWvanlmOhrs+uJSV2D7spGCauP5fL76ULGjrDkselevZrxXkxDm4xVh7P5NSqf60c58swc336V/lc0tvHq1jRO59Xw2vWBXD+q90qF8+mMAQ90NOWjm0YNKIZ5T0o5T61P4LNbQphznldMm1TB7T+cwsZEj69vH92nIPHh3gwSi+r54c4xGm8rEASBaR8d4b/z/Ho0ln51awpaYjGvLOy98mXaR0d4a3EQudUtHM6o5Ke7+o4VVwe5Qsm4dw7y5a2hjB+gSHI+EpmChV+e4PpRjoM2Qv47tpiXt6bw811jGOdh1a/ndsaYp5Q0snpF/8TBuhYpr25LJbagjmfm+LK4jyqc6uZ2PtiTwfbEMlZO9uDByR4YDrLNqTtSShr45mgO+1MruC7YgQeneuJzGcz9u6NNquBgRgUbYoqJyq5m7AhLloQ5MzfIftAtXv/r1DS3c7pDzDlX0URMfi2BjmZEeloR6WnFGHfLf/171BeCIFDZ1N4l5qSWNtIkkXEiuwY7U70LWq4CHU1xsRiOL+9keG4wzLXIsHgzzDXBv/kCLQgC5Y0SUkoaSSlRxXOnlDZQ0yxVpWfZmzLSyZQgRzMCHc0wNdAmo7yJo5lV7E0tJ6m4AR0tETKFsitpqhOxCG6PcOPNRUFX5sVdZqqa2onKqeZEVjUns6upbpYS7m7BrI6UjaB+Jj1JZQr2p5Uzw9cGff3Ls9oolSs5mVPN7uQy9qVVoKctZl6QA5Geljz4WxwXX/G1xSLsTPXZ9PD4IfcqaGmXszm+hDXR+VQ0tnPLGBduH+eGq5V6K5/xhXXc/sNp/lwZwSgXc0rq21h3ppDVx3KZ7GPDY9O9CHY2V/t8ZAolv58q4PODWQQ4mvLCfH8CHdX3OxEEgU1xJXyy/xzjPa15bp5fv1ZC150p5PXtaTw+w5sHpwwsBnxPShlPrU/k81suNCGWK5Q8sDaWJomcNfeO7VOMOZVbw90/n2XLIxPwtdf8JDi9TOUzEvfyrB79RZ5cF88UHxtuCOv9+j3hvUN8dksI2ZXN7Ekp59d7xmrsPF/dmoJEpuT9ZcEa2V9KSQPLvo1i44PjB+2lsz2xlOc2JvLjXWOJ9OyfgKNUCnx5KJvVx3L4YNkoFvSzLe9gegXP/Z2kVhUOQEJRPd8eySGltJ4X5wcwN8h+SITuvOoWVh/LZVNcMZO8bXh0updGE7D6S2WjhK0JpfwdV0xBTStzAu1YEubMBC/rYd89oKJRQnROjaoyJ7ea0noJwc5mjPe0ItLDmtFu5hgMtwepRaNERkZZE2mlDSpz5LJGMiua0NPWYpK3NXam+gR0xJh72xlfEf+6K82/eW4wzLXLsHgzzDXBv+UC3ZlkkFLSQGFdK1HZNaSUNFDXKsXTxrjLRDjIUXXDNlFjFb9NquBUXg2HMyo5kF5BWb0EfR2tLnPbAAdTdj0x6YLntLTLSSyup7CmlVv6MD+9mlH169dyLFMl1mRWNBHoaMYEL2smeFkR7mY5qEhshULBk3/Gctd4D0Z7DJ1fRbtcwcnsanYklbE/rQITPW3mjXRg/kh7Ql0sulbhrv/qBEnF/0Rua4tF2Jvps+mh8UPqZ5Rb1cya6AL+ji3GzdqQFRHuLBzlOKD3VqZQUlrfxteHc9icUMIsf1seme5FgEP/RJf9aRV8e1RlhPriAn+m+dr2a3JZWt/GC5uTSS1t5K3FQRdUvPSFRKbgzR1p7EkpH1SVx67kMp75K5EvbgllZsA/BsCCIPDc30kkFjWw4cHIS1rQLqahVcbcz4/x4BRP7hzvPqBz6YtP9meSVdHEN3d070+jVAoEv76PDQ9EEuDYe2VI+FsH+PHOcM5VNLEtoZTf7hunsfOMK6zjzp/OcPbFmRqrPvriYBbbE0vZ/tjEQe/zr5giXtuWyo93jSGinxU4oPJFemp9ArdHuPHsHN9+CQqdVThHM6t47foAFoc49fqbUSoFNsYV88GeDHztTXh1YeCQVcdUNEr4+WQef8UU4WVrwsPTvJjsbX1FKyPTShvZHF/MloRSAhxM8bU34YZQpy4fr2GguK61S8yJzq3BylgXQ11tIj1UlTmhrub/StFhoEjlSrIrm8muaiKhsKHLS6dNqsDL1rirQifAwfRfEV/+b5kbDPPvYli8Geaa4Fq8QCuVAvk1LaRc0PrUQKtUgbedCZN9rHEyNyDQ0Qx/B82Z2ZXUt3E8s4p9aRVE59SgryNm40PjiS+sJ65Q1Sd+rrwRO1N9xrhb8vktIVd169D5yBRKEovqOZGtEmviC+vxsjUmxMWcyT42RHpYaTw6fuQru3h/6Ujmj3LR6H4lMgVHzlWxJ6WMA+mVjPe0wt3aiPkjHRjlbNbtZ7ImOp93dqUjkSnR6RBu/n54/JDEpiqUAocyKlkTnc+5sibGe1uzItKNUBfzAX9fsiubWHU4h53JZVwX7MDDU736bQabXNzAWzvTyK5s5r/z/Fgc6tQvY2mlUuDPs4W8tyuDuUH2vLQgoF8D4KLaVh78LRYvW2P+O89vwMbQO5PK+PNMAfdMHHFJctPH+87xd2wxm9TwLxIEgUf/iKdNpuDHO8OH7Lc8+9OjPDLN65JI5k4Ka1qZ8ckRUl+f22eCT/Bre1l3fyTpZY38FVvUp0dOfxAEgSkfHuGF+f7MDVJfkOsNuULJLd+fYpqvLY9M6znSXl02nC3i9e2p/DSAFiqAnKpm7l8Tg6O5AV/eGtrv6Ov+eOGAqkLg8wNZ/HaqgNFuFswfaY+HjTHmBrqYGepgbqCDoa6WRr57Da0y1p7K56eT+TiY6fPQVE/mBtqjFFTXf5lCiVShRKYQkMkv+nvH4wYdpsiaQq5Qciq3ho2xxexJLWeEtTFLQp1YFOJ4VYYAPL8hjto2BV/cHnZZhRNBEMivbiE6t5boXJWg0ySREe5u0WF+bEWws9lVEwTwv0Lnol9qR2x5Z4y5gY4WUoWSQEdTAhz+abu6lhJEr8W5wTDDDIs3w1wT/K9foOUKJbnVLR1tT42klDZQVNNKTasUf3sTAp3MCHI0w9femMKaVhaFOA1ZT3OjREZiUT1xBfWUN7axI6mMdrmSkU5mhLmq4jZDXc0vexrRQBAEgczyZk7kqMSa07k16OtoMd7LmoleqjSMoU6amPrBIWzNdNnwwMRB76tVKudwRhW7Uso4nFGJrYmeqsImyEGttJOKRgkR7x5ESyTCwdyATQ+N12gUNKhW59fHFLE2ugCFUuCOCFduHuM6qOOklTay6nA2+9MrWBrmxINTPHGzUi96u5PS+jY+2nuOXSll3D1hBA9N9ey3v0xBTQv//TuZwtpW3lkykin9jG8+nFHJk+sTWBTiyEsDiAHvZHtiKc/9ncSq28OY5nthItTa6Hw+3p/Jxgcj8bLtu8phQ0wRH+w5x54nJw2Z+WVOVTPzPjtO7Msze6wG3JNSxhcHsy+p8usO/5f3sP2xiaSWNvD7qUI2PKg58QZU4ld2ZXOPVUIDIbuyieu/Ojkgz5ruWHemkLd2pvPTXWMYO0J9f6dOmiQynt6QSEZ5I6uXh/e7GqS/VTgAWRVNzP/8OLIO03GxiK60Q7EIDHW1MdHXxlRfBwsjHSwNdbEx0WNRqBNh/RRT2qQKNsQU8dHeczS1y7vdRiwCsUh1HiKRCJFIJTqLRSLS35g7JPfY5nY5e1LK2RRXzJm8WsZ7WbMk1InZgXZXRZqQIAiMeH4XYhGM97TCUFebGf62TPO1vexCkyAIZFc2dwk50bk1+DuYoqslVrVZeVoR6Ni/VuZh/qG2RaoyRC77x0snp6oZUwMdAhxMGTfCElcrQwIczPC0+d+ML/9fnxsMM0x3XPk7xTDD/MuQypXkVDWTXNxRTVPaQHpZIyJEBDiaEuRoyo2jnRnpZIanrXHXKlNVUzv3/nqWpOIGPGyMGaWBvn6lUiC7qpn4wjriCuqJL1KZ2jqZGxDmakGkpxU3j3ElwMF0wBPNy01JfRsnOyprTmbX4G1njK6WmIle1jwz2xc/e5PLaub3/tKRfLwvg+KaZpyt+h8Z3CSRcSijkpPZ1WxLLMXR3IAFIx145MHx+DuY9GuFzM5UnyBHMxraZPytYeEmubiBX6Pz2Z5YSqirOS8t8GdWgN2gBnyJRfWsOpxNWmkjM/xtOfzMVJz6meTS3C7n2yM5/Hgij9mBdhx4ekq/00UUSoH1Z4t4a2caS8Oc+f7O8H6ZbCo7YsC/P57LOzeMZHFo99Un6tAZHf317WFMvUi42ZVcxu6Ucn68c4xawk1edQuvb0tl1e1hQ5pasi+1nEne1r22caaVNqotIEgVSvS0xYhFIuRKZd9P6CeLQhyZ/8UJGiWyARlId4eXrQnPzvHlP38lsufJyYM2ab1lrCtKAe755Sw/3z2GMf0w6AYw0dfhuztG88OJPG7+Lpq3bxjJwlGOaj/fwkiXL24NZU9KOe/tTudoRhUvXOffaxWft50JWx+dwIIvT6BQCijOe0wpqH6rze1yyhokFzzP196k3+KNga4Wd45357pge6Z8eJTmbgQcpQDKrvVL1f91tUTcFO4yZPcIYz1tlo12ZtloZ0rr29iSUMKqw9n8dqoAd2sjloQ5ETHC6ooZzv58MAUtIOON2WRXt3Eoo5L1Z4t4YXMKgY6mTPezZZa/Hf4OpkN+jiKRCG87E7ztTFgR6Y5SKZBR3qiqzMmp4avD2QCMG2FJpKc1kR5Wl/3+/r+MpZEuE72tmej9T9uuRKbgXHkTqaWNlDe0sTa6gPSyJhSCgJ+9SYc5sqot38/eFKNhs+lhhrnsDFfeDHNNcLWq6503wpTShq6qmnPlTYxyMUMsEhHkZMZIJzOCnEwZYW3c4wpScnEDd/58hiaJDC2RiP/O8+OuCSP6fT71rVLii+qJL6wnvrCO7Ipm6tqkBDubE9ZRURPqaj4kbTSdVDZJeH1bGi9fF6CRZKOGVhnRudWcyK4mKruGgtpWRjmbMdHLmgle1oS6Wlx24amlXc7RzCpiCur4/VQB0/1seX/pSEwN1GtPqG+Vsi+tgj0p5ZzIqsbDxogbw52Z5G2Dt63xoEqaK5skGOhoqeWH1BftcgW7k8vZmlDC2fw6Foc6siLSfdC+Fmfza/nyUDYx+bXcPs6V+yZ59NtMWa5Qsi2xlHd2ZTDC2pAXFwQMyMg0u7KJ/9uYRLtcycvXBfTbZ6S+VcoT6xIoGEQMeCdb4kt4YXMy394xmskXVf1E59Rwzy9n+eq2UGb42/Wwh3+QKZQs//E0/g6mvLpQ87Hg53PdF8e5d+KIXo2I7/v1LJGe1tw7sffrmkIp4PnCLk49P4P4wjq+PZrD1kcHX9V2MQu+OM6d4925KVxz7Y5KpcAdP57G1dKQ95ZqxhD599MFvLsrg1/vGctot4G1+hxMr+DJ9QncNtaV/5vr1+9KhvOrcF6/PpBFfSRSfbj3HN8fz0Uq71t4c7cy5MDTUwYlAudVtzDv82NIZH0fT0ss4tj/Teu3SDwYBEEgtbSBjbElbEssxUBHixtCnVgS5oSHTf8F/4FyrriKd7cmMTPIjjumXBhSUNPczpFzVRzKqCSzoomGNhkz/G2Z7mfHBC+rK1I1pFCq3rfOqpyzebWY6GsT6mpBRIdnzmDvl8Oo3uf8mpau6py0MlX7VU2LlHA3C2w7jJE7RZ2hHD/2l6t1bjDMMINhWLwZ5prgarhAt0rlpJc1klLSSE5lM2fya8mqbMZEX5sgxw4j4Y7UJ1dL9aMcN8UV89zfScgVAp0/1nlB9n2W9MsVSjLKmzrEmjoSCuvJrW5hhLURoS7mHUKNBb72Jpethzy7solbVp+iplnKG4uDWB7h1u99SGQKYgvquqpr2mQKBAEmeFkz0cuacR6WGhEm+ktDq4wD6RXsSS3nWGYVThYGLA5xYm6QvVpiRlVTO3tTy9mTUs6p3BoCHE2ZG2TP3ED7yzqAV4eyhjb+OF3In2cKMdXXYXmkG0vCnDBTU5zqDkEQiMqp4ctDWaSUNHLneDfuneiB5QA8iI6cq+SdXenoaIl4dJr3gJJuZAolq4/l8tWhbO6IcOXpWb79NlhOKWngwd9iCXAYeAx4J5viinlpSwrfLR/NJO8LhZv0skZu+i6alxcEcNMY9cSGD/ZkkFBYz093az4W/HyKaluZ9tERYl6a2au3yvh3D/LxTSF9pii1tsu57YfT/HhnOIlFDWyKL+ar28I0fdr8dqqAuII6Prk5RKP7LalvY+5nx/j8lpBLvIoGysaYIt7cmcZPdw1cwBmsDw7844UT6mrB2zcE9TiJa5crmPnxUYrr2uhtAKotFvHbfeMGZMx8MQfTK3hgbSxyZc9H1BaLmB/swBe3hA76eANFplBy9FwVf8cVczC9kkAnU5aEObMw2GFAn0l/+P5oOpnF9Xx4e+9tiFK5krP5tRxMr+RgRgXlDRLGe1ox3d+OGX62OF5G4et8ZAolKcUNRHW0WcUU1GKsp90l5ER6WDHC2mhYzNEQlY2S88Qc1f/zqluwNtbrEnKCnc3wtTPB3croilREXQ1zg2GG0TTD4s0w1wSX+wLdKJGRVnp+NLeqV9jKSJcgJzPGjbBkhLUxQU6mOJkbDGiwIFcoeWtnOr+fLujyBejExkSPsy/OvODfKhslF1TVAKSWNhLSIdSEuVowysV8QJNhTXAmr5a7fj6DRKZAKcA0Xxt+vrvviF+FUiCttLHLZPhsfi0WhroqscZb5Vsz1BHXPVHRKGF/WgV7U8uJzqnBz8GEuYH2zA2yV6ttpaCmhf1pFexLLSershkPG2PmBdkzJ9B+yL14+osgCJzOq2VNdD4H0iqZ7GPDikg3JnpZD2pQJggCh89V8tWhbHKqWrh34gjujHQfUApGRnkjb+9MJ6m4gcdneLM8wk3tqquWdjllDW2U1EvYm1rG0YwqDPW0+WBZ8IDMS9efLWRTXAlTfW0HHAPeycbYYl7ZmsL3K8KZcFEyVVFtK0u/iWJFpBuPTvdWa3+dVTpbH50wZOk/nXx/LJdjWVWsvbfnRKi6Fimhb+4n8ZXZfX7uDW0yRr2+j5TX53A6t4YP955jz5OTNX3alDdImPj+IaL+O13jXh9/xxbz7u4M9j01WWPX47XR+Xyw5xy/3ju23y1GnQzWBwdUPhqvbkvlWB9VOHGFddz4bTSKHsQUHS0R0/1s+W55eL/PoSc+3JvBD8fzaO+h4kcsgn1PTVbr2n05qG+VsiOpjL/jipHKlbhaGrI0zJkpvjZDsuDy/IYYgh2MuXWSn9rPEQSB3OoWDqZXcDC9ktiCOuaNtMfN0ojp/raEOJtfsTamdrmCxKLOypxq4grrsTDUYWGwI952xkR6WONiObDx2TDd09wuJ6PsH0FHIlOwK7kcbS0R/h0JV53GyD52JkO6cADD4s0w1ybD4s0w1wRDeYGua5GSWqoyEU4uaaBFIudIZhUOZvoEOv7T9hTkZIatiZ5GBgJ1LVJWro0hubihx4Hmz3eFk1vdSnxHAlRpQxs+tiZdrU+jXMzxtjW5Ksz8tieW8vSGhAtEKANdLVJem3PJ+QmCQH5NKyezq0ksqmdfWgVKQSDSw4qJ3taM97TG0+bKrZ7lVDWzL7WCfWnl6IhVA+g5QfbMDrBTW3BZG51PVE4NB9IriPS0ZnaAHTP9bbG/Ck2gW9rlbE8s5eeTeZQ3tnPLGBfuiHAbtLikVArsS6vgq8NZ2BjrMXaEFcsj3QbkBVLZJOGTfZlsji/hjgg3HpvudcEqtUIpUNEoobS+jZL6NsoaJBTVtpJX3UJJXRuVTe20yRRoiUQICCgFGGFlyJ6nJvc7bUUiU/Dq1lQOpFcMKga8k79iitgcX8Kj07wu2Vdti5Rl30Qx0dua168PVOs3Ud8qZd7nx3loqicrIt0HdW6gWoUvqGnBuwcRaMnXJ1k62pnbx/VcZReVXc2zG5M4+d/pfR6vqqmdMW8f4Nxbc4nOqeHtnensf3rKgM+/N25dfYoZ/rbcN8lDo/sVBIEH1sairSVi1W1hGruW/RqVz0f7zrH23nEDahEE1e/yq8PZfHc0h/eWBvfLB+d89qSU8dKWFEJdLXhrURB23bTIvrI1hfVni7q9x4lFsPHBSMLc+m/G3BNKpcDtP5wmtqAWqeLSoa+ZvjYTvK15eKoXQU5mGjuuJsitaubvuGI2x5XQLldyfYgjS8OcCXTs26heHSQSCY//GcfKiZ6M8R54RVhDq4wT2aq0yiPnqtDREjHV15YZfrZM7MP3aqiRyBTEFdYRV1DH0cwqEorqsTXR/6cyx9NKo+1yBTUt7Ekp575JHlfFOOxKIVOofB7TShsvaL1qbpfjaWNEqKsFXjbGXRHmmkz8HBZvhrkWGRZvhrkm0NQFuqqpnbTSRpJL6juiuRspqW/DxdLggtanQEezITP4zChvZMWPZ6hrlV5ScXM+fvYmOJkbdLU/BTubXdGBUXcIgsB3x3L5eN+5S16LjpaIvx8aT7CzOVVN7UTl/GMyXNXUzmg3C8Z7WTHBy5pgJ7MrlnSgVAoklTSwN7WcfanlFNW1McnLmtmBdkz3s1Pb9LemScLaqAIeme7FkaxqBEFJhKe1xgxRNU1edQtrowv4K7YIFwtD7ps0gnlBDv1uHboYhVJgZ3IZqw5lU98m5YHJntw61nVA+21tl/PDiTy+O5rDZB8bnpvrh7v1pSlUj/0Zx/bEMvS0xWiJRSiUQo+iKIChrhZnXpzZbyGpqLaVh36PRUdLzNe3hw06ka0zEvqHO8dc0k7UKpVz6/encTLX58tbw9SaHAiCwCN/xNEuU/KDhmLBtyaU8NmBLA79Z8ol+6tolDD+vUOcen5Gr7+Tn07kkl7WxIc3jurzeCX1bUx47xB5787nZHYNr2xL4dB/pg72ZXTL+rOF/HaqkO2Pad5Tp7q5ncWrTvLCfH/mj3TQ2H5/PpnHJ/sz+e3ecYMytT+YXsGqwzmMcbcYkA8OqMTFt3emEV9Yx+MzfC6pwmmVypnywRGqmtsveJ6utphRzmaklDTywBQPHpziqbEV+vpWKbM/PUZVczvnj361xSK+vSOMkzk1rDtTxNgRljwyzWtASV5DiVIpqGLH44rZk1LeVY2zKNRxUF4jB9NL2Hy2mM9uG422tmb8a+QKJbEFdRzKqORAegWFta1EeFgxO9CeKd42uFpd2erSVqmc2IK6Ls+cpOIGnMwNmBtkj7+DCZEe1oPy5ftgTwZfH8lhso81394x+qpIE7taEASB0gYJaSUNXWJOaqlqvO1opq8SchzNOrx0THC2MBzQ/WpYvBnmWmT4SjLMvxJBEChvlKhiubtanxqoaGxndoAdejpahLlasCLSnUBH0yHvNe9kV3IpT6xLuMDfpju0xCKm+dry3Dz1y5svNwqlwCtbU/grprhHEeqDPRlUN0vJrGgiwNGUCV7WvLtkJGPcLQctEgwGqVzJqY6++U3xxbRJFczwt+OZ2b5M9rEZUMKCmYEOebVNxBRUMytAM14XmkapFDiaWcWv0flEZdcwJ8ieX+4eQ5irRbcDp79iinhnVzoiRIjFnbG7IsRiEVoiOv6v+rsIqGxqp7Vdjq2pPg9N9WTZaOcBTcqUSoFN8SV8tPccER6W/HLP2F7Tdm4d48ru5PJeBZtOdLXFvLkoqN/CzeFzlTy5bvAx4J2sO1PImzvS+PGuMZd4fsgUSt7ZlYGBjphPbgpRe2L9V0wxZ/Lq2PPkJI1Ve/wSlc/yCLdu97c3tZxwN4s+Bc6Ukka1K7lkciW6WmJEItV3rqe2G00wN8iBl7ekklPVjKeGfaesjfV4dWEA/9mQSJirhUbM2wHunjACpQDLfzzNb/eNI9jZfED7meFvxwhrI+5fG0taWeOAfHAsjXT5+KaQriqcncllF3jhGOpq8+nNIdz185kLvGgsDHVYe+840ssaeW1bKhtji3lpQQBzAu0G/b01N9Tll7vHsmjVia77kggIdjZjZoA9MwPseXSaFz+dzOPeX87i52DCw9O8mOpjc1W014jFIsZ7WTPey5o3F8nZ3RE7vu5sIW5WRiwb7cwMf9t+VwzmlDfhaGGgMeEGQFtLzDgPK8Z5WPH8fH/yq1s4lFFJSnE9b2xPxd1K1Vo109+OUBfzy75AY6irzSRvmy4PseZ2OTH5taSVNfLLyXz+syERV0tDIj2tiPBQ/defFu3D5yoBOJVTy+JVJ/ntvnFqC2wyhRJtseiq+M4NBSKRCCdzA5zMDZgVaN/17w2tsg4hp4G0skb2pZZjYahDSmljh5Bj1lWh421nfNn8GocZ5mpiuPJmmGuC3tR1QRAormsjtbSBnKoWzuTVklraQG2LFC9bY4IczQh0MiOow2DtclavKJUCeTUtxBfW882RLHKqWtV+boiLOVsemTCEZzdwJDIFD/0WS1ROTa8TZjtTPV5dGEikh5VGS2UHQpNExpFzHeXeGZUY62tzU7gLY9wtGedhqZFBwid70zHS1+aBKep5k1wuGtqk/BVTzNpTBbRKFdw+zpXbxrr26fURW1DHsm+iehUaL8bL1ojdT0we8PsZlVPN2zvTqW+V8X9zfVkY7KiWp8IzfyWyLbG014QbEeDnYMLOxyap7dOgyRjwTv44Xcg7u9L58c5wxl0k3AiCwDN/JZFa2sD6+yPV9gbKrWpm4Zcn+PqO0Uy5KKlqoCQV13PL6lOcemFGtxVkt64+xZxAuz6T8eZ+doynZvkw57xBfE9kVjRxw6qTpL4xlzN5tTy1PkGtdquB8sDaGHztTXl6ls+Q7P8/GxKpbJKw5p6xGp2o/XA8ly8PZfPbveMY6TzwFqAmiYz/bEgkfRA+OPCPF87xLJUXzvWj/qnCeXJdAruSS5EqBHS0xHxzexgzOwRupVLgr9giPthzjgBHVTKal+3ghbTOIACZQkBXS8xPd425IDIZVN52v50q4MfjediZ6vP4DG9mBdhdlS0wRbWtbIkv4e+4YupaZVw/ypGlo50Z5Wym1vfq+Y3xjHYzZ9mY/qdYDoRGiYwTWdUcSFe1VykFgak+Nszwt2Oyjw1mBle+IrVJIuNsfi2nOqLJU0sbcLcyYpyHJeM9rRg3wqrHe2SrVE7Qq3vp1CS1xSLMDHX4474IfO379lT64Xgu3x3LZYy7BaPdLAl3syDA0fRfKVZIZAqyK5tVgs55BskyhYC3nTH+9iYEOZkR4GiGv4PJBWP44cqbYa5FhsWbYa4Jzr9An0w8R7VgTGpHNU1KSSMt7XJ87EwIcTXHz96EwI6L/OUuY21olZFQXE9WRRPHs6pJKKpHIlMQ7GyGka42RXWtVDW109wuR09bizaZosd96WqLSX9j7lU3kKxtkXL796fIqmzuNdkDVAOalNfnDLlpXU90Gg7vS6sgOqcaD2tjZgfaMTvAniAnzXgJnM/uhGIOZ1XzwY0hGt3vQEkva2RNdAFb4ouZ7G3DglGOzA2071fVyNKvo4grrOtTwBEB3nbGbH9sYr9XhQGyK5t5b3c6p3NreWS6F3eNd+/X96ZRImPqB4epbZX1uI22WNXKp267SX2rlPd3ZxCdWzPoGPBOOqOff757TLfVRB/syWBrQimbHh6v9iqwVK7kzp/O4O9gyisLAwZ9jp08vSEBI11t3lwcdMljNc3tjHvnICeem95rVUm7XEHgK3s5/MxUtapvUkoaWP7jaeJfmU1sQS2P/B7PqRdmDOp19Mbu5DLe35PB4WemDskqeKNExtxPj/HQNK8Bpe/1xprofL45ksP3K8IH5eGiKR8c+McLJ8zVgrc6qnAaWmVM/vAwjW0yIjys+GPluEve64Y2GZ/uz+TPM4WsiFT5WpkOIt0O4MXNyfxxphAvG2P2PTW5x8+3TapgQ0wR+9MrKK1v45GpXiwKcbxirby9IQgCsQV1bIwtZkdSGfZm+iwNc+aGUKcef4cV9c28ujWF/5vth4eD+eU9YVTVcwlFdRxMr+RQRiXFta2EuFow1deG6X62V03aYkObjLN5tcQV1HEsu4q00kbcrY1UnjkeVozzsOyqrDmWWcX9a2KQnLdYIBaBrpaY1SvCmdyHgC6RKUgsqiemoI6Y/FpiC+qQKQRCXMwJd7cg3N2SUBdzTK8CketKoFQKFNa2klbWSGZFE4lF9aSVNVLR2I6blaHKGNnBFFutZm6ZpkojHBZvhrlWGBZvhrkmOF+8cX9sDcE+IzqqaVQeNZfD1f5i5AolmRXNxBfVdSVA5Va34GZpyOxAe5wtDAh1scDP4cKobkEQKKptIzq3mmOZ1ZzMqaaxTXaJmKMtFrHj8YkamTBqgqLaVnYml/LBnnOo28mgpy3m57vGDNrUVV0EQSCnqpm9qRXsT6ugpqUdB1MDZgfaMSvADjerS/1SNEVLu5zfovM4lVvHd8vD0NW5Ml2rMoWSvanlrIkqIKmknsUhTiyPdCPQcWCTu+icGlb8dLpXfyZQ+cjse2oyzhb98zmobpLw+cFsNsQUcfMYF56Y4Y3VAP2mDmdUct+amG5bbXS1RMwb6cDnasYEd8aA+zuY8vGNozQyiF57qoAPdquEm/BuhJtfTubx+cEsNj40vl9tPO/tziChsI5f7hmrsetgdXM74987xK7HJ3abzrPuTCFHs6r45vbRve4npaSBW78/RdKrs9USR+IK63jot1hOvzCThKJ6Vq6JuSR5T5NIZArGvHWAtfcN3AS4L6Kyq7lvTQy7Hp/UrWfTYFh9LIevj+Tw+33jBvwb7+RgegVPrk/gtrGuA/bBAZXA/8rWFE5kV/PODSOZF2TP3tQKHv8zjj1PTu51sn6uvIl3dqVT2Sjh3kkeLAl1GnCakUyh5KHfYlkR6d7nZBpUIuiW+BJWHclGKQg8PNWLJWFOAxKjLwdtUgX70srZGFtMTlUzPrbG3DzGlRn+dhcI9PuTi9mXWsGHt/T+W71cFNe1ciijkoPplUTn1OBkYcAMP1um+9syxl0zVbCaoKFVxpn8Wk7l1nAqt4b0skZGdIg5VU3tHMqo7HYBS1ss4s1FQdw6zlXtYymVAlmVzcQU1BKbX0d6eSOZFc142xozxt2yS9DRpOFyJ0cyKtHWEl9SmXY1Ut3cfkF1Tlx6NiffvAkYFm+GuXYYFm+GuSY4X7zJzS9ghJv6N0VNUdkkIaGwnviiehIK60gsbkAsEjHKxYxQFwvC3MwZ5Wze74lnZ/pSdE4NR85VEp1bQ2u7AiUC794wklvGXv7XCqqV9VO5tZzIriYqp5qSujYCHU2pbGpHrlBS0yJFSyxCWyzusYJIRyzivskePDd36Lx7Olf19nUINiX1bUzytmF2gB3T/W2wNh66mHGlUuBMfi2b4ooprZdQ1yrlhfl+TPDSTNtKf6hslPDHmUL+OF2Ivo4WyyPcuDHcedB+ToIgsPCrE6SUNPa4jbZYxPd3hjPN11bt/UpkCn4+mc/e1HKsjHV5fp7/oNol6lulvLkjnaOZldS1yi4RcPS0xZx4brpaBtTrzxby2rY0HpvhxYOTPTUShbsmOp9tCaU8P9+P0d0k7OxIKuW5jUn8dt+4fkWXR+VUc+8vMWx7dEKPiVAD4cuDWZzJr+0xAvzOn84wwcuK+yd79rqfDTFF/B1bzPoHItU67qncGp75K5ETz00npaSBFT+dIe7lWf0+//7w3u4M9LTFPDVErVMAr21LJam4nr8eHK/xaspvjuSw+lgOv98XQYDj4MT+nKpm7l8TQ4iLOS9fFzCo68fu5DI+3p+Jh7URb90QhJGutlp+YoIgsCu5nLd3pmFnps/r1wcO2NtnIMgVSnYklfHV4Wxa2uU8MNmDW8a6XrEKUnUorW9jU1wxG2KKaW6Xs3LSCFZEumOkp80XB9Jplyp5dn7glT7NS2hpl3Miu5pD6ZUcOleJRKpgsq8N84PsGe9pfcXbrc/nfDFn3ZlCWqQ9V07raIm4a7w7z8/zH/D9o7JR0lGZU0dMQS2ppY3Ymugx2s2CMe6WjHG3wNfedNDXk1mfHCW7spnn5vnxwGSP/ykfnuG2qWGuRYbFm2GuCS73BbpdriCttFFVUVOkqqopqW/D29aYUBcLwt0tCHY2x8vWWOMDcVX1iMq7Z7ynlcZXanuiVSrnbH5dRyJUNXnVLYywNiTCw5qJXtaMGWF5gclru1xBRlkTScX1nM2vI7ZA9R7pdaz4dXrheNsaazzqVyJTcCq3hj0p5RxIr0SuVDLDT1VdM9nHesjb5fKqWtgcX8ym+BJa2uUsCnHihlAngp3NaJcr+DUqjxvDnLE0GdpocEEQiCmoY01UPrGFdfjYmXBnpDtTfGw0IjiAShR5Z2c6G2KLu31cT1vMvRNH8H9qCnSCILAtUVXBZW6ow4vz/QddmbUnpZyXt6YQ5GjK/83146bvommSyC84x6dn+fDAlN6FhvNjwL+4NZQJGqoY++VkHh/vz+TXe8YS1o0wE5Vdzb2/xvD17WFM81NfAKtvlTL3s+M8Ms2T5RqIBe9EplAy8f1DvL14ZJc3yfk0tMkIf2s/B5+e2meizGvbUhGJ4NWF6k0cj2dV8f2xXNZ0GNo++1ciOx6fNKDXoS4ns6t5Yl0Cp56fPmStMm1SBQu+PM6y0c48PNVL4/tfdTibH47n8sfKiAH71nTSJJHxytYUYgrqBuWDAxdW4VzshdMXrVK5qi3seC6LQ5x4do7vgKvyBoJSKbA3tZwvD2VT2dTOEzO8uCHMud9m55cTpVLgdF4thzIqeG6uHyW1zbyyNYX7J3sxwUf9a8uVQKkUSClt4EB6JTH5tZzOqyXUxbzL9Njb1viqEBaa2+WMfG0vfc2uOmPUv7w1VCPCX6tUTkJhR6tVQR1tUjnpZU2EupoT7qaqzglxMe9X4EKbVEHgq3tQCqqWr3kj7flgWfBVW212McPizTDXIsPizTDXBEN5gRYEgZL6to7Wp3rqWqXsTCrDSE+LUFcLQl06orpdzK7a2OeBIFcoSSxu6BJr4grrsDXRZ6KXNRO8rRnvadXvuPTmdjnJxQ0kFddzOq+WxKJ62uVKkl9Tr2WiNxpaZRw6V8G+1AqOZlZhY6LHLH87ZgbYEe5mMeT+BLUtUnYklbI5vgR9bTFmBrosCXNiqq/tBSXqcrmCd3enY2KgzZMzh6biqFUqZ0t8KWui8ymtb+OmcBduj3BlhLXmvAOqm9v54Xgea6PzGeVsRmFdG8V1bRdso6MlYpSzOesfiFRLxDybX8tbO9OpaJDwzBzfQbVEdJ7jq9tSOZFVzasLA7gh1AmRSMTu5DIeXxff1erlaK7PkWem9er10xkDri0W880dg48B7+SnE3l8eiCTNfeM7baiJq2skZu/jeaVhQHcGO6i9n4FQeDh3+OQKZR8v0IzseCd7E0tZ/WxXDb08Lluiivmh+N57Hqib1Hl5u+iWTramZvUfG0H0yv4cO859jw5+QLz4qFEoRSIfPcgH904Sq32moGSUFTPfb+eZe29Y/F3GFyLU3d8dSiLn07m8+dK9UxTe0OpFPjyUDarj+Xw/rJgrgseuA8OqKpwXtqSQri7BW8tHqlWBVwnhTWtvLkzjdO5NTw9y4c7Itwuqx+NIAgcyqjkmyM5ZFc1c++EEawY735VmO72hkym4PVtiZjq6/Ds/KCrQvjoD+UNEg6fU7VXnciuwtpYr6O9yo4ID0uNCAxtUgVSuVJtY3hQpUw99FssElnf6YagWjx4b8lIpvjaYqnBSiKFUuBceRMxBbWq6pz8Wiqa2glwMCXc3YJx7paEuln06p0WnVPDXT+f6Vps09MW42VrzK/3jO33+O9KMCzeDHMtcvUuDwwzzBWiVaoSGOKL6okrqCO+qJ7aFikBDqaEupozzdeGJ2Z442Zl+D832OkNQVD1VHeKNRKZgtTSRsZ7WnN9iCMfLAvG1XJwr9lYT5tITysiPa26qhzkCuWA91lc18r+NFU71Jm8WvwcTJjlb8/jM7zxszcZ8s9HIlNwIL2CLfElHM2sIsTFnGWjnVkw0qHHdgJtbS1uDnfh84PZtEhkGGlQ8MutambtqQI2xhbjYmHIXePdWRTipNHY9cpGCd8dy+WP04VEeFiy5t5xjHazYH9aBY/8EXdBmpOxnjbfLR/dp3CTX93Ce7szOJ5VxQNTPFk5yWNQ59xZvfPatlQiPKzY//TkCyJa5410YHJcMcfOVYEI3r5hZK/CzYmsKh77M57rgh156Tp/ja06/nA8ly8OZrH23u79VIpqW7nzx9M8M8e3X8INqNqRYgrq2POE5mLBO/n+WC7zgux7/Fx3p5QzL6jv5ChBENDTERPYj8oNqVzZ9VlpiUUoLsP6k5ZYxMJRjmxJKOlTvFEohQFXW4a4mLMi0p2n1iey9dEJGl/dfnS6N0oBbvv+FH+uHIfPIPzSxGIRT8z0JsjJlCfXJ5Bc0sD/zRm4D868kQ6MHWHJK9tSmf3pUV5fFMTCYAe1vruuVoZ8vyKcI+cqeWN7GtE5Ndw5wZ3xnpfHo0MkEjHD347pfraczK7hi0NZrD6Wy10T3LlnwoirqrXnfBKK6mmVCvx3ns//5FjG3kyfW8e6cutYVyQyBdE5NRzMqOD5v5PwsDHCSE+bGX52TPWzUTui+2Le253O1oRS1j8QqbbgeTK7GnkvHnA6WiK0xCIkMiVGelroaon56nA2T/+ViK+dSVcs+TgPSywG0ZaoJRapYrUdTVnRUXlZUt/WZYC8LbGUh/+Iw8nCgDFulox2V7VbedkYdy2anM2vvaCCqF2uJLOiiTmfHWPtPeMG3YY5zDDD9J/hypthrgkGqq4LgkBedUtH+5PKWFgmV9IgkRHmakGoq6qqJsjRTKMT4KuF0vq2LrHmZE4NTRIZY0dYMcHTigle1gQ4mGqsvUYTCIJAWlkj+9MqyKpoYm9qBeM8LJkdYM/MALshMeu7GIVS4HReDZvjStidUo6tqR5LQp1YFOKkVlpOJ4/9HsO8kfbMDx7cSpBcoeRQRiUbY4s5klnFvCB7VkS6EeZqodEBeWl9G98ezWH92SKm+Njw2HTvCyKIBUFg2kdHyK9Rxd1ri0Wsuz+iW+PdTupbpXxxMIsT2dWMdrPgqZk+fcaT90V5QxsvbUkhoaieNxYFMX+kQ7fbVTW1M/XDw4S4mPP7yohut1Eqha6J2IfLglkwyOqC8+kUbn67b1y3fh01ze0s+zaaKT42vLowoF+fZWcs+Dd3jNZ4pUhKSQM3fhvNqRdmdFtZ0NIuJ+zN/ezswcj4fIpqW5n20RFS35ijtlCxNaGEtdEFbHxoPAU1Lcz85ChZb88f0GvpD8nFDdyyOprYl2f12OLw/p4MdMQinp7tO+DjSOVKlnxzkkneNkPmBfb1kWw2x5Xw9e1hGvFB6vTBcTQ34MtbQwfto7UruYyXt6Qwf6QDj8/w7lcVjlSu5LfTBXyyL5MpPja8sMD/stwXLuZ0bg1fHc4mrqCOOyLcuG+SR79ex+ViMGLj1YogCKSXNXVU5VSQWNxAkKNpl8AW6KhekqQgCIx9+yDVze0Y6Grxx8oItUzLZ3Z4xHRioKPVJToHOZky3tOKMDdLQpzNL6joqWlu53SeKpY8vrCOcxVNeNuaqBa8PKwY62Gp8eruRomM+MJ6YvNrOZtfR0JRPbraYka7WTDazYIdSaWklzVd8jyRCHTEYr68LZQ5gX0L9VeK4cqbYa5FhsWbYa4J1L1AN7TKSCyu7xJrVCtPCkY6mXW1P4W6muN4BQZ7l4OGVhnRudWcyK6moKaVqJwaRjmbMcHLmgle1oS6ml91vcxyhZIz+bVdhsP1rVKm+NowO8Ceab62/SpnHiidg8EtCSVsSyjF38EEd2sjbgh1YqST2YBEkm8OZ9Emk/H07IFFN1c1tbP+rMqAGOD+KZ4sGOmg8QlCUW0rqw5ncyq3hkAnMx6d5tWjx8XOpDKe3pCAADw725eVkz263U4qV7ImOp8vD2UT7GzGi/P98RukD4cgCGyIKeKtnencOsaFh6Z69bnifa68CRsTvW5L1etbpTy5PoH86ha+uWP0oH1Czmf1sRxWHc7ht3vHXSCAddLSLue270/hbGnIl7eE9ktAlcqV3P3zGfwcTHn5Os3FgnfyzF+J6GqLeeeGkd0+viOplM8OZHFADR+rvanlfLo/kz1PTlb7+H/FFLE5voQ/VkZQVNvK5A8Pk/fuArWfP1AEQWDGJ0d5epZPjy1CUTnVPPRbHFH/nd4vX4mLyaxoYtFXJ1l779hexc/B8Mn+TP44Xci6+yMGZQTeSZNExtMbEjlX3sR3ywf/e6lpbuf9PRnsT6vgjUVBXKdmFU4nlY0S3tudwe6Uch6e6snKyR5XxFA4rrCOVYeySSyu5/pRjqyc7KGxlsu++CumiPFe1t2KVzK5god/jyXU1YLxXtaMcjb/n6y+UYea5nYOn6viUEYFxzKrMdLTYmGwIxEeqkWqnhbmsiqamPv58S5zez1tMb/cPZZIT6sej6VQCvi8uBulIOBiaci4EZaMHWFJqKsFHtZG/bqWVzZJOJ1bS3RuDadyasivaSHIyYxIDysiPK0Y42aBsYbFHJlCSVppIzEFdZzJrWZfWiW9TRK1xSIen+HNY9O9rsrvz7B4M8y1yLB4M8w1QXcXaIVSIKuyibgClaFwfJGqqkYAVUVNh1jj72Daa8vE/zISmYKY/DpO5qiqa1JKGvCyNWa8pzVTfWwY7W6BiQZv/nnVLZgb6Ay6TLylXU5UTjW7k8s5mFGJjpaYWQG2zA6wJ9LT6rINwkvq29iaUMLW+FIKa1uZE2jHolAnJnpZDzqu9FSuyiPh57si1B7QCYLA2fw61p4qYG9KOeM8LFkR6c40XxuNezzkVjWz6nAO25NKWTDSgYeneva5Sq9QCkz98DA+dib8cKfKZ0WuUNIqU9DarqC5XcaRjCrWni5AX1uLFxb4M0UDlSFFta08vymZnKpm3rlhZL9Mfbvj/Bjwj24cpVHviu+P5bAtsZR3lwQT5HSpcCNTKLn31xjkCiU/3z2m32Lqe7sziCuoY+19YzUuxNZ0xINvf2wiPj18Fx75Iw4PayP+o0b1yaf7Mymqa+WTm0LUPoc/TheyN7WcX+8ZS1lDG5HvHiL3nfmXpULw8wNZJJc08MOd4d0+LggCi1ad5IZQJ+6eMGJQx/r+WC6/nS5g1+OTehWCGtpkA/p+CoLAJ/szWXe2iHX3R/Qrer4nlEqBb47m8OeZQv47z2/QPjjwTxXOGHdL3lwc1G9xOraglle3pdLQJuPlBQHMCrC7IpPM1NIGVh3O5kB6JUtCnXhoqiduVkMXNlBU28qkDw7jbGHAzscnXfIdaWqTcccPpwlyNiOrspnqpnaWjnZmSZjTZROXJDIFcqVwWQ2epXIlZzvahv6OK6a8QcJ4Tyumd1TlnC90fXMkm88OZHX5vYCq5enbO0Yzw/9So/ZOsiubsDcz0PjrKm+QcCq3huicGk7l1WBjrIdCEIj0ULWih7tZarRCPL2skYVfnug27vx8tMUiZvnb8uktmjFe1iTD4s0w1yLD4s0w1wTnX6BfWHuYvDZ9EovqARjlYt4h1lgQ4mr+P2GyNlAUSoGUkgZO59VwNLOKs/l1WBnpdlTWWDHB03rQbSk9EZVdzV0/n2VJmBPvLQ3u9/MrmyQcTK9kf1oFJ7Krme5rg7u1MbMC7Ah1Mb9s7VsNrTL2pJbxd1wJcQV1TPCy5oZQJ2YF2A1qNf1iCqtbuPPnM3x7Rxi+apiTbjhbxE8n884zIHZjxBAkjWVWNPHVoWz2pJazOMSRh6d69Zhodiavlh+O59LcLqe5XU5ru5wWqQKJTEG7XIlUrux24PfukpHcONp50IKTUimw9lQBH+zJ4PoQJ56f7zfosvINZ4t4dVsqj0734qEpmokB7+TrI9msPpbL2nvGMrKbVimlUuCZvxLJKG9i/QMR/RZWo3Kque/XGLY+otlY8E5WHc7mZHY1f/TQZiaRKbhldTRv3zCSQMe+v9Mr18QwboQl903qvkKrO345mcfJnBq+XxFOZZOEsW8fJOvteYMWU9Uhv7qFWZ8e5eyLM3tsDdqZVMY7u9I58uzUQZ2TQilw6/en8LEz5q3F3Vc5KZUCsz87xgOTPfrtiQQqAeejfef4K6aYdfdH4KEBAQfgQFoFT61P4PYIN56d4zvotpya5nZe2ZbK4YxK/OxNuHWsCy6WRjhbGGBvqt/ndUShVFXlfbj3HIGOpry6MKDPlr6hIruyia8P57AjuYx5QfY8Ms2rRyF0MLyzK51fovIRBBjpZMq6+yN7XKSSyBTsT6tgY2wxUTnVRHpas2y0M7MD7IZ0Mr43tZzH/4xnup8t1wU7Mt3P9rK2pwuCQG51CwfTKziYXklMQR3etsbM8Ldlup8dr2xJIbWs8ZLnaYtFfHzjKBaFOl22c+2OkrpWTuXWEpVTw6ncGiqbJIS4mHdV5oS5Wgzq81sbnc87u9JpU9N4WUdLxDOzfBjrYUWgo9lVsSg6LN4Mcy0yLN4Mc01w/gX6gW/2MjnUj1BXc3zsTK65fu7z6fTsOZmtaoWKzqlBAMZ7WjHJ25pIT2s8rI2GfKXxUEYFD6yNRaYQMDfUIf7lWWodM6eqmf1pFexLLSexuIFRzmbMCrBnVoCdRkr51UUiU3A4o5ItCSUczqhi/kh7RrmYc12wo0bbkARBIKGonjXRBZQ3SPC1N+bZ2b5qmRZ/eTALO1N9Fo5yHJIBbmpJA18eyubwuUqWjXbmwSmefXr47Est5/61sWofQwS8vzSYm8b0f6J5MblVzTz3dxLljRLeXxI86DhxiUzOa9vS2JdWwZcajAHvpDOq+ff7Ino0eXx3dzq7ksv4+6Hx/TbYrGuRMu/z4zwy3YvlEW6aOOULkCuUTPrgMK9dH9ijx8G+1HLe2pnO0WenqvX7n/DeIT5c1r/PbvWxHBKLG1h1Wxi1LVLC3txPxptzL9uK7+N/xjPZx4Zlo7ufBCiUKu+n/8z2YVHI4CZ3RbWtzPv8OKtuD+uxQu1EVjUr18Sw/oGIbr2T+kIQBN7fc47N8cWsuz+yT0G4pV3OV4ezeWKGd6/veacPjpOFIV/cEjJoHxyAx/+MY1tiGaBqYZHKlSACS0NdHM0NGGFjhIe1Ec4WhjhbGFwi7jS0yvjhRC6rj+WwItKdx2d4a7TytD8U1rTy7bEcNsYWM83XhkemeQ3o8+sOiUxB+FsHaG6XA6r3ak6QPZ/fHNLn77K8QcLm+BL+ii2iqqmdhaMcWRrmpHEPtU6yKprYnlTGjsRSyhslzPS347pgB6b42lz2Fu6GVhlHs6o4lF7B2fw6SurbetxWWyzi1YUBLO8wAr7SCIJAUW0b0bmqcWB0bg0OZvro62gR6WFNpKcVIS7m/RJUHlwby57U8h4fN9ARI1UI6GqJcTTXx0RfGysjXWIL62mTKghxMSfc3ZJwN3PC3CyvSPrasHgzzLXIsHgzzDXBv+kCXdkk4Wx+LYczqojKrqa6RUq4mwUTvKyZ6GVNkJPZZRWsdiaV8sS6hK4KC22xiM0PT+jWy0OpFIgvqmd/WgUpJfWcya9jgqcVswPtmeFvO+BEiIGgVAqcyqthS7zKeNjKSJdFIU4sCnHU2Ap0J21SBbtSyvg1Kp/cqhaWjXbmjgjXK7b6ez7xhXV8dSgbiVyJj50xD0z2xN5Mvc9BEASu/+oEKSWNvfbFg2pVbm6gPV/eFjao85UrlPx+uoD395zj5jEuPDvHF0PdwVVEFdW28vDvcXjZGvPsHF+Ne159eTCLn6Py+f2+cT16gfx0Io8D6RW8tTio398/QRB46Lc45EqB71eMHpJJ1q7kMt7emc6x/5vW4/Xl6fUJ2Jjo8fx8/z7319AqY9Qb+4h/eVa/2ix/PJFLYU0rry8Kor5Vyi2rT/HXA5GYXKaJwS8n89iVUs6GByJ73GbtqQL+OF3IrscnDvqzWHemkB9O5LHxgUjMe3ifvj2aw5qofLY/NhGrAVSWCoLAe7sz2JpQyrr7I3qstAPV53bPr2cRAT/cGd6rKNMkkfHU+kQyK5pYvWI0foNIt+o8z5mfHCWnqqXHbXTEInS0xSgFgXaZkhBXczY/POGCbc6VN/H69lQyK5p5bq4vS8Ocr5gxf3mDhNXHckkvb0RHS8yj07wYO2JwPkeb4op5YVMykvPafXS1xTw81ZMnZ/qotY/OhYaNscWklTbSKJFxU7gLN4Q5Dcl9ujOMYEdSGdsTS2lolTEn0J4FwfZM9La5LJV157MxtogXN6dc0DJ1MTpaIp6c6c0j07wv45mpR+fCXnRnm1VuDc3tcsLdLIn0VKVZBTub9fq+hr25n9oWadffDXS0aJcrMDXQYdwISyZ62zBuxIXpVKAaW+VWNxOTX0dGeRNHzlVSUNuKr50Jo91UiVaj3SxwtjAY8oXFf9PcYJh/D8PizVVOa2srq1at4q+//iI7OxupVIqLiwsLFizg8ccfx9XVdVD7l8vlHD58mH379nHq1CkyMjKor6/HyMgIDw8Ppk+fzkMPPYSnp2ev+7nrrrv49ddf1TpmXl4e7u7ugzrvi7mWL9DN7XJO59ZwoiMVKruymVkBdoywNmailzXh7oMrjR0MG2OL+O/fyRe0xuhqiXlgikeX54VEpiAqp5r9aRUcSK9EKlcy3c+W+SPtifS0vqz97p3GwzuSStkUV4JMoWThKEcWhTgS4qJ5w8bsymb+OF3Ixtgi7M30uWu8O9eHOF3W19wTp3Jr+OpQNvGFddwR6cZ9EweWhpJQVM+yb6L67Iu3NNTh8LPTBrX6llHeyP9tTKK5Xc5HNwYT5jp4M9cj5yp5cn0CCzUcA97J5wey+DU6nz9Wjutx8ro1oYQXNiXzx8oIRqmRZnIx684U8vH+TPY8MWlAk3d1eHZjIv72ptwzsXsvF6lcyei39rPmnrGEulr0ub/onBr+syGBqOdn9Os8PtmfSUWDhPeXBdPcLifo1b0kvjr7ku9VS7uc/9uYxCc3j9LoZ1rV1E7kuwc5+n/TekwxksgUTHjvEJ/cHDJoTydBEHjsz3jEIhFf3Bra4zaP/BFHfauMNfeMHVA7oiAIfLj3HKfzavnkplG9+rFIZAoe/zOe3OoWfr1nbK9pTkqlwJeHsll9LIf3lwUP2gdH3esNqO5F79wQxLJuWsoEQWBPiqpSzNpEj9evD1QrSWioqGlu56eTeayJKsDPwYRHpnkxxcdmQPekuZ8dI6P80oQgHS0RHy4LZnFo/8ZHEpmCvanlbIgp4kxeLVN8bLkp3JlpfrZDIqoIgkBicQNHzlWy7kwRErmCuYH2LBzlyLgRlhr3d+uOlWti2J9W0ed2WiIRd0a68XI/EwEvN4IgkF3ZfIGYI5UrmehtTairBZEeVhcs/HVWNQLYm+ozwcuK8Z7WjB1hOSDRpbJJQlxBHWfz64gpqCO1pAFrYz1Gu1sw2duaQEcz/OxNNP7ZXstzg2H+vQyLN1cxOTk5LFiwgHPnznX7uJmZGX/88Qfz5w8sJrWqqgp/f39qamp63U5XV5cPPviAJ554osdthsUbzSGVK0koqudEdjVR2dUkFNXjbGHQVVkT6WmlkRL0wbImKp83dqR1O4h2sTDgqVk+7E+r4GhmFRaGuswKsGN2oB1j3C0v+ypap/HwlvgSimrbuH2cCxO8bTRiPHwxUrmSfWnl/H6qkNjCOuYH2XN7hBvhbkNTdt4fBEHgeFY1Xx3KJr28kbvHu3P3hBGDNph+cG0sB9MrkPUwodIWi/jprjEDjq2WypV8cySHb45mc/eEEX22bKhD56Tyu2M5vLU4iCVhmr9mfLo/k99OFfDHygh87buvsupse/nmjjCm+vbfaDmnqpnrvzzBt8tHM8lbs7HgnaSVNrLkm5Ocen5Gj9eeI+cqeX5TMiefm65WFcOvUXkcy6rmxzvH9Otc3t+TQbNEzpuLg5DIFPi9vIe4l2ddkhimUAp4v7iLY/83DWeL3tv/+suKn84Q6WHFQ1N7XtT44mAWGeWNfH376EEfr7JRwuzPjvHW4qAexY/mdjk3rDrJND9bXlCj8qk7BEHgrZ3p7E4uY939kbha9fy+KZQCr2xN4UB6Bb/eM7bPqpr9aRW8syudBSMdeGqWz6CqQx/9I469qeXIFD0PX3XEIsZ6WPLbveN6ve62SRV8dyyH747mcl2wA/831++KRno3SmSsjS7gxxN5OJkb8Mg0T2YH2KtdGZRS0sDiVSd7FLd0tET8fl/EgKt7impb2RhbzMbYYtrlCpaEOXNTuPOQVZEqlQKxhXXsSCxlZ3I5IDAvyIGFoxwJd7MYkoopmULJyFf3XlC51Bf2Zno8P8+fqT6XJwFzsCiVAucqmrparE7nqlrux42wJMLDiggPSxpa5fjYmwzJ76FNqiChqJ6Y/Fpyqpo5mF6JUhAIdbUg3F1VnRPiYj5on8FraW4wzDCdDIs3VynNzc2MGTOGjIwMAFauXMktt9yCgYEBhw8f5t1336W5uRlDQ0Oio6MJDu6/Qez5F7WQkBAWLVrEuHHjsLOzo6Ghgd27d/Pll18ikUgA+O6777j//vu73VeneOPo6MjevXt7Pa6vry86Opq9uf0vX6A7b6KdvjVn8moZ426BmYEuE72sGe9lpfHJx2D55kg2n+zP7HXwHOZqxmQfVUKUv4PJZRcuGlpl7EwuY0uCynh4orc1i0M0bzzcSUldK3+eKWLd2SIMdbW4fZwry0Y7q1UJUVzXQmppA3MCB5/O0h1KpcDRzCo+O5BJYW0r903yYHmk26DNfTs5mFbOfWtiu22d0tMWszjUifcHYGINkFzcwLMbEwH4cNmobtvx1EEiU5Be1khKSQPHsqo4lF6Jsb42f66M7NGDZqAIgsDXh7PZmljKV7eF9WhImlLSwK2rT/H6osABiUdSuZJ7fz2Lr50JLw1BLHgnz21MQiyGd5f0/Bn+9+8k9HW0eO36QLX2+cxfiTiY6auVSnU+b+5IQxDglYUByBRKvF/czZkXZ3TbyjHm7QOsXj5arUqg/rAprpjVx3J7jTiva5Ey4b2DrHsgUiNeJjuTynhxSzL7npzco+l8blUzi1ad5N0lIwdc4SIIAm/sSGNfagXr7o/o1fdKEAS+OpTN6uO5rF4e3muEMqgqEe9fG4PzIH1wyhskTP7gMFJFz5NrAx0tDj8zVe0W0OK6Vt7dlUFdq5SpvjbcNX7EFTVcbZMq+PNMIauP5WKsr80TM7yZF2TfZ2XCU+sT2J5Y2mtlkqGuFjsemzio9mClUuBkTjUbYopJL2vARE+Hm8e4sCDYYch8hBRKgdO5NWxPKmN3Shn6HfeWOYH2Gq2cjcqp5u6fz17SMiUWgZ6OFnKFErlCwM5UH197Y7TFYgx0tMipbiGroonRbhYdpse2eNoYX/FFG3VQKAXSyxq7xJwzebVoa4lYHOKEu5UhkZ7W+NgN3WtRKAUyK5qIya8lpqCOmPw6yhslBDiYMtXXBj97U8LdLbDrZ+DG//LcYJhhemJYvLlKee2113j99dcB+OCDD3j22WcveDw6OprJkycjl8uZNm0ahw4d6vcxSkpKuPvuu3njjTeIiOg+PeT06dNMmzaNtrY2zMzMKCoqwsTk0olIp3jj5uZGfn5+v89lsPyvXaCLaluJyqnmRHYN0TnVtEoVjBthqaqu8bbG1+7yix3qoEonyWT1sZxehRs9bTHPz/PjrkHG5fYXiUzBofRKtiWVcCi9Cn9HU24IceS6UY5DkjImVyg5fK6KP04XcDKnhgUjHbihI0q8PyuCWRUNvLsrg2/vGI2ujuaEJYVSYGdyGV8fzkZHLGJRqBO3jXMdtEdMJ6X1bXy07xy7kssIdjIjsbjhkgGvnakeh/4ztd+CmUSm4LMDWfwSlcfDU714cIqn2pOp84WauMJ6YgvqKKprRVssBoSu7+4fK8cx3lOzxsSdEcx/niniz5Vj8bbrXhgqqGlh6TdRrJzkwQNTem9L7Yl3d6cTm1/H7yvH9bs1qFUqV+t7UNciJfK9g2x5ZEKP1RVyhZKx7xzkm9vDGOfR+wS+k/mfH+fxGV7MDXLo13m/vCUFIz1t/jvPD6VSwOOFXUQ/P73beOMFXxzn8RnePRosD5Tmdjnhb+1n6yMTe6yoAnhtWypVze2sGqTPUyeP/xlPc7ucH+8M7/H+cCCtgrd3patS7AboMSMIAq9tS2V/Wjmf3xrKGPfeP9P1Zwt5bVsaH97Yd1tUo0TG0+sTyKxoHpQPzqf7M/n2aE63niTaYhHvLgnixvD+t5VH5VTz+rY0ZAolL18XwDS//lfDaZJ2uYLNcSXsTC6joKaVB6d4snS0U7e/9/pWKeFvHeizpUwsAlsTfXY9MemSirWBUN8qZVtiKRtiisipbGFBsAM3hbswxn3oqk1lCiXROTVsSyxlb2o5ZgY6LAh2YGGwI4GOpoM67ps70vj5ZB66WmIkciWm+tp42RoT4mKOv4MpfvameNsZd1v9WVrfxsGMSg6lV9AmU1DeIGG6nx0z/G0Z4255VSQwqYNcoSS5pIGEwnoOnaskJr8OQ10tIjpiySM9rYY8DKO0vo2Ygjpyq5rZl1pBRnkjThYGhLtZEu5uQbibJd62xr2Otf7X5gbDDKMOw+LNVYhMJsPW1pb6+nr8/f1JSUlBLL70gv/ggw/y3XffARATE8Po0YMvz+6OZ555ho8//hiATZs2ccMNN1yyzbB40zt1LVKiO3xrzuTWUtbQRoCjKeM9VWLNKOf+pQBcCQRB4MXNyaw/W0Qvuk0XYa7mbLrIKHIo6FyN25Lwj/HwbeNcmRVgPyRR2qBa+V13tpD1Z4sAuGWMKzePcVF7lfdilEqBR347w8wAB5YOYMJxMTKFki3xJXxzRDW5eXCqJzeOdtaYN1Jzu5xvj+Tw44k85gTa8cwcX0wNdBj/7qGuhBNQTaL+vD+CMe79K9GPLajl68PZVDdL+WDZqF4nyJ0cPlfJtoRS4grrKKpVCTVaYhFtMkW328/0t+WHfrbs9EVn9PKGmGL+XBnRY2JadXM7y76JYrqfHS9f5z+gAXBUdjX3rYlh26MT+t2yIJEpmPHxUb68LZSwPqpSvjmSw5FzlazvxaA3Kqeax/+M5/QLM9Vqh5HKlQS+uoeDT0/ttTWnO/77dxK2pvo8PUtlvOrx/M4eW6Pu+vkMM/zthiR969E/4nCxNOS5uX49blNU28qMj4+y/+nJvXrIqEt9q5Q5nx3jqZk+3DK25+vE5wcy2RxfwtZHJw7YY+p8c2BvW2PumuDO3ED7HisJD2VU8N3RXOYG2XN3H6K9Uinw+cEsfjiey4c3jmL+yP4JeKCqTJnw/qELDFUBtMQijPW0GeduwdtLggfU8iFXKPmzw0cq1MWcl68L0LiJ/UDOaUdSGasOZ9MkkXP/ZA9uHet6QfLg6mM5fLI/E4ma0c4WhjocfHoylsaaMyBOLW3gr5hiNseXYGmky43hziwNc+53xUR/aJcrOJZZzY6kUvanVWBnqs91warWqoHEsJ/OrSGtrBFfexP87E0HLHC1SuWczK7hUIYqirxNqmCyjw3T/WyZ6mszZP5kQ4FUriSpuL6rMie2oA4zAx3mBNoR6GhGpKcVrpaGQyrmNElkxBfWd1Tm1BJfWI+OlojRbhZEeloxytmcUS7mF4xzrva5wTDDDIQr75o5zCUcOXKE+vp6AO68885uhRtQCSad4s2mTZuGTLyZNm1al3iTk5MzJMe41pDIFJzNr+0yGU4rbcTHzoQJXta8sMCPcDdLTK9AbOJAqG2Rciijkg/3ZFDR1K728xKK6mlokw1JPGRnMsXWhFK2JZQiVyq5LtiRtfeOY5Sz2ZAMIBQKJcezq/n9dCFHzlUy0cuaNxcFMdXXZtAme20yBQrE7EguG5R4I5Ep+Cu2mG+P5HSliywOddKYr49coWR9TBGf7s/Ew9qYdfdfaLD7f3N8eXtXOu1yJXraYu6IcOuXcNMqlfPh3nOsO1PEkzO9uXfiCLXf2x2JpWyJL+lq3ZIqlNC9boOWWMTTs/rXrtMXgiDwwd5z/B1bzLr7I/DsYbLX0i7n+U3JjHQ256UFAxNu6lqkPLUhgRfm+w/Ia+KXqHwsjHQI6aOdR65Q8tupAl6+rncPlajsGm4Z46q2j0l2ZTN62lo4W/Q/1UsqV6Kr9c9xtMViFD1UGtia6FHVj2tWf1gc4sSr21J5drZvjyu/LpaGzB9pzw/H83hzcdCgj2luqMv7S4N59I94JnhZ99jS9Nh0bxKK6nl6fQLfrwgfkC+ISCTim9vDmP3ZcbIqm3ljexovb0khzNWCG8OdmRNof0Hb03Q/OywMdbnnl7OUN0p4bo5fj8cVi0U8NcuHQEdT/rMhkZSSBv4z27dfPjgGulq8ujCAZzcmqSLDO9DVErNu5ThWHclh1qdHef36QK4f5div35m2lpjlke5cF+zIpwcymf/FcVZEuvPYdK8rFi2uraVqEbp+lCP70sr56nA2qw5nc++kESyPcMNIV5sfT+RdINxoiUXoiEWIxSIEQSVyiESirt9LXauMiR8c4a7x7twe4dar8bS6BDqaEXi9Gf+d58f+tAo2xBSxNjoffwczbgp3YbqfrcYXqvS0tZgVYMesADvapAoOn6tkR1IpC788wbgRVoS7W3BdsIPaAtw4Dyu1Kwh7w1BXu+u8lEqB1NJGDmZU8Gt0Pv/3dxKz/O0Y6WzGDH/bq7bauhNdbbEq9tvdksdmeCORqTxrUkoa2BRXwstbU7Ax1iPC04rIjuocTbf7m+jrMNnHpss7T6ZQkl7WSGxBHWfza/n+eB71rVKCnMwId7Mg3N0SR+2huf4PM8yVZFi8uQo5fvx415+nTJnS43bh4eEYGRnR0tLCiRMnhux82tv/ufj1JCT92+ksMY3KqaGgpoUtCaVYG+ky0dualZM8iPS0uqwx2IMlr7qZA2mV7E+rILawjkBHVd+xXCkgCAKpZU0UVLfQLleir6OFIAiXmPvpaWtxNLOK60dpzseluK6VncllbIwpoqRewpxAe95bOpKJXtZDlkBR2SThrxiVQaO2WMScQHteuS6gVy8IdWlsk7Kmw5xypr8dKyd5DHhfNc3tzPv8OJZGujw3z48FIx00FhkvCALHMqt4a2c6cqXA2zeMZHaA3SWDzdvGufLdsVxK6tuwM9Xn2TnqCyRR2dU8tykJe1N9dj7efz+G1xcFcTqvltL6NnrrGhCLVKaMmvK5KahpYWdSKZ8fzEauVLL/qSk9nrtUruTB32LREYv46LbQAU2qBUHgv5uSCHY25/Zx/Rf66lqkrDqczbd3jO7z+AfSK1QVGP52PW6jVApsiCni45tGqX0O8UV1eNsZDej1tyuUF0z+xGJ6bBOxNdGnqknS72Oow2QfG1wsDYgrrCO8F4Hy/smeLPnmJE/O9NbISvtUX1sWhTjy6rZUfuhBmBGLRXx2cyjXrzrBF4ey1I6Hvhgfe1OcLQwormvrak+KKagjtbSB5zclM3aEJctGuzA70A5TfR1CXS34+6HxrPjpDFWN7by/LLhX4Xh2oD2bHzHi/jWxFNW18taikf0ye71+lCPfHs0ho6wJAZVw8+aiQPwdzfjqtjB2J5fx8tYUdiaV8dYNQf2+B1sY6fLGoiBuG+fK69vSuOHrKFZOGsGNo12uWLS4WCxibpADcwLtOZJZxapD2Xx7JIeHpnjiZG6Aq6UhlkZ6WBvrYmWki6mBDuaGuiQW1VLZ1M5/ZvthbqCDqYEOulpiTuZUsza6gGkfHmHZaCcWBDsy3tNq0EKCvo4WC0c5snCUIyV1rWyMLeGtnWm8uDmZJWFO3BTugvcAqmL6wkBXi/kjHZg/0oFmiYwD6RXsSCrnq0PZeNsZc12wI9cFO2jk/t0fxGIRI53NGOlsxpMzfahslBCVU8PO5DK+OpSNpZEu0/1sme5vS6SH1RVLEFUXfR2tDmNjK+6b5EGbVEFsQR3RudX8eaaQ5zcl42CuT6SHFRO9bRjrbjngyuSe0NESE+xsTrCzOXdPGIEgCBTVthFTUMvZ/Do+3neO9Ox8jR5zmGGuBobbpq5CbrzxRjZu3AhAXV0d5ubmPW47atQokpKSsLGxobKyckjO54knnuCLL74AYOfOnd2mW3W2TRkbGxMSEkJycjJtbW1YWloSHBzMwoULueeeezA0HNgNs7i4uNfHy8rKGDt2LHB5SiMFQSCnqkXlW5NVTXRuDWKRiEgPK6b42hDhYYW71dCWkGoSpVIgobie/WkV7E+rwMJQB0NdbWYG2DHT37ZbPwlBEChvlJBZ0UxWRROppY2kljZQUNOKVK5EJIKFoxz5/Jbu423Vpa5Fys7kMrYmlJBQVM9EL2uWhjkz3d9WY94tF6NUCkTl1PDHmQIOpFUyzsOS28a6MsPfFl0NxA6XNbTx88l81p0pJNLDitsj3JjkbT3o78vp3BrGuFtqdGKRVtrIO7vSqWlp5+ZwF26PcOt1QnYoo4KVa2LZ8vAEtcyFmyQy3t2dwdb4Ev5vrh/LI9wGfP7ZlU0s+OJEtz4YnWiLRax/IJLRbj23C7XLFXxxMIsHp3h2u9KeW9XMzuQyNsWVUFDTgiCAANw8xpn3l3YvYiiVAk9vSCCrspl190cMeAX/zzOFfLo/kz1PTh5QOf9bO9LIrGxmzT1j+9z2ltXRTPax4eGpXj1uE5Nfy72/xhDz0ky1KrwUSoGRr+1FV0tMwquz+3XuAPeviWG8p1WXn1bQq3vZ9PD4btsjfo3K51hmFT/epdn2uE5e3JwMwNs3jOx1uxU/nSHE2Yyn+2nO3BPNEhm3rD7F4lAn7utF8M0ob2Tp11F8cWsoM3oR4Hrjk33n+PZoDtIeemUNdMRIFQIRHlbcONqZ64IdqG2VcvfPZ7E00uWbO0Zj3IffVaNExls70jmdV8P3K8L71erSGR0OMK6bdKnaFimvbUvlaGYVr18fyKKQ/lXhdCIIAgfSK3ltWypWxrq8ujCw12vI5UIQVG3DXx3OJqGogbvGu3PvxEsTBN/anoK/gxlLu4lNB1Ui47aEEr4/noeVkS4rxruzJNRJo+b+SqVAdG4NG2KK2JNSToCjKTeFu3DdEJocd9LQJmNfajk7ksqIyqkm0NGMhaMcWTDSHvtuxjeXE4lMwancGg5lVHIwvZLaFikTva2Z4WfLND8b7Eyv7PkNhJZ2OWfzazmdW8Op3FoSi+txtzLqqsyJ8LC6LKluqVm5BPmoPOWG26aGuVYYFm+uQiIiIjh9+jRGRkY0Nzf3uu11113Hzp07AZBIJOjpafZiWFZWhq+vL01NTVhbW1NYWIiBwaU3EnWiwp2cnNiwYQPjx4/v93n0Z7A1VBfoikYJJ7OrSS1tZGdSGbWtUsa6q0yGJ3hZEehoprFKh8uBRKYgOqeGfWnlHEivpF2mYLqfLbMC7JnsYz3gwZQgCJQ1SMisaMLWRH9AFQ4SmYID6RVsiS/lWGYVgU6mLA5xYkGww5AYD3dS09zOX7HF/HmmkGaJnBvDXbh1rItG/CpANZlafSyXHUllTPO14f7JHox2G1hk61BT0Sjho73n2J5Uyp2R7jw8zUvtFriGVplaK+id8dIeNka8tyRYI6uhO5NKeXJ9QreG2iJglIs5Wx7p2YupoU3G/WtikMgU/HTXmK5qiezKJnYklrEpvoSSula0tcQXiEQiERx7dlqPr+GdXensSSnn74fGD3jQmlPVzMIvT/DdAGPBi2pbmfnJUTY/PKHP32VGeSNv7kjjy1vDehWJ3tyRRkObjI9uVK/y5sO951h1OBttsYjMt+b1W6j7799JhLtbsmy06hp/y3fRvHZ9IH4Ol76e3SllbDhbxM939y1UDYQzebXcvzaGMy/M7LUVJCq7mod+jyPqv9M1NhmOya9l+Y9n2ProhF7Fjm2Jpby4OZltj04ckAfYufIm5n9xvMfWtIvZ+GAk4e6WNElkPPhbLI1tcn66a0yf33mlUuCzA5n8dDKfD5cFM68fPjiP/hHHwfTKXtOl9qSU89KWFEJczHhrcdCAJ+wSmYLVx3L59mgOcwLteW6un8YrCgbK2fxavjiYhb6OFt+vCO/69+Y2Kc9sTOT/Zvvi0YOBeicSmYLtiaX8Gp1PQU0rN4W7sCLSTWP3wE4aWmVsSyxhQ0wxlY0SJvnYDLnJcSd1LVL2pJazPbGUJokMA11tFo5yZH5Qz55OlwtBEMisaOZgRgVnc2s5ll1NoKMp0/1smeFnR6Cj6RWr+hoMjRIZZ/NqicqpITqnhozyRjxtjIn0tGKytw2j3SwuERw1wbDnzTDXIsNtU1chTU1NABgb9902YGT0zw21ublZo+KNIAg8+OCDXefz8ssvdyvcgEpciYiIYOHChYSFhWFnZ4dEIiE5OZkff/yRM2fOUFJSwuzZszl+/DihoYOrxrgcNEpknM6t5WSHb01OVTMjncyYN9Kej28axWg3i6u+tPVi6ltV/jVxBfVsii/GwlCXWQF2fH5zCGNGWA7KG0UQBEQiESKRCEdzAxz72T+vUApE59RwIL2CjbHF2JrosSjEiZcW+OM+RMbDoDrv6Nwa1p8t4lhmFX72pjwz25c5gfYa6c0XBFUVz+pjuZzKrWHpaGf2PDHpihtg9kRLu5zvjuXyw/FcpvvZsv+pKf0WVfoSbupbpby5I538mhaemOHNzWNcNDZgn+hlg4e1EecqLhW+tbXE/Gd2zy0kpfVt3PXzGVwsDPn57jEU17XxS1Q+m+NLKKuXoK0l6hJsFBdV9/jYmvT4Pv1wPJe/Y4sHJdxI5Ure2J7G7eNcByTcAHyyP5MFIx3UElR/jcrHydygV+FGEAT2pJTzxiL14sGPZVbx3dGcjudCcknDBZ5J6lBY23pBxUNWZXMvbVN6pJc19Wv//SHczQIjXW2OZVYxM6DnypZITytCXMzZnljaq9Fwv47tbsmd4915ekMCmx+e0OO1+/pRjiQX1/PA2hg2Pzyh3+KRj50xtiZ6lDX03n6moyXi2Tm+XS1kJvo6/HzXWJ7dmMiyb6L49Z6xvV7HxWIRT8/2JdDJjP9sSCS1tJGnZvmotSDy3tJgyhvaehVR5gbZM26EJasOZzPrk6O8vDCQG0c79/u6o6+jxeMzvFk22pn3dmcw4+MjPDzNi3snjrji44Ex7pasvXcckotM2ncklaIrFvcp3IDq9d0Y7sKy0c7EFdbx88l8Zn1yjEne1jw8zVNjiw1mhjosj3RneaQ76WUNrD9bzP1rY7AwHHqTYwsjXW4d68qtY12pbJKwO7mcrfElvL4tlUhPKxYGOzIn0L5fLXyaQiQS4WtvojLpn6qqHDtyrpKDGZX8eDwPA10tVXuVny0Tva2HrPpY05jq6zDD366rArC+Vcqp3FpO5dbwV2wR96+NwcfOhEhPK8Z7WjN2hOWQ+CUOM8y1wHDlzVWIp6cnubm5uLi4UFhY2Ou2K1asYO3atYDmVeW3336bl156CVCZFh84cKBHz5v6+voe27sEQeCll17inXfeASAsLIyYmJh+DZouR9uUVK4kvrCOE1lVnMypIbG4ATdLw47KGmsiPayuyM18sBTVtna1Q53Nr8XX3oQbwpyI9LAiwGFwkZqd/Hwyj7XRBex/ekq/qo8EQWXitzm+hO2JpSgFWBjswKIQR0a5mA/pClxti5S/O6ps6lqlLBvtzG1jXRmhIVFFplCyK7mM9WeLSCtrZEWEGyvGu6tdOSSRKS7rZEAuV7IxrpiP92fiamnIiwv8+0wiGgh7U1Ur4EGOpryzZGS3LXkDJbW0gYd+i8PTxojKpnbOlTddMLH3sTNm75OTu/1eZZQ3ctdPZ5nmZ8ubiwJpkykIeX0/iOiz6kBfWyUKrZx8aeT31oQSXtycwh8rxxHch0Fwb7y7O52Y/Dr+GEAsOEBKSQPLvo3iwNNT+jSSrG+VEvHuQf5+aDyBjj23viUV13Pb96eJfXlmn+dU3iBh5idHu9LIdLREPDLViydn9c+P5cZvo7gjwo1FIU4AjH37AKtXhBPSjQhUWNPK9I+P9Fjh81dMEdlVzTw/r3dD5t54f08GRbWtfNVHHPiOpFLe3ZXBkWenasxAvF2uYNFXJ5kdaN+VvtUdcoWSx/+Mx9JIlzcXB/X7uvrBngx+OJ6nMgHvBh0tEc/N9eu2hUupFPjmaDY/ncjnp7vGqCXWZVU0cf/aWNytDPnsllCNT+IOpFXw4pZkfO1NeXfJyEEZ9Z7Nr+W1bak0SeS8ujCA6X62V1W79J+n8zmcUckdkSO6jF77S3mDhD9OF+BtZ8JCDXrYXUy7XMH+tArWny3iVG4Nk71tuDHchRn+thr7zfRGSX0bu5LK2J5USkZZE5N9rFkS5swUHxuNto8NFKlcSUx+LQczKjmYXkFpg4TFIY6MdDJjmp+txg2CLyfVze2czq0lKkdlQ5Bf3dKVYhXpYcWYEZZ9tl92x3DlzTDXIsPizSCQy+Xo6Ax+UPHzzz9z1113df09MDCQtLQ07OzsKC8v7/W5N998Mxs2bACguroaK6vBO+QD/P777yxfvhxBEHB3dyc6Ohp7e/tB7XPWrFkcOHAAgBMnTjBhguZipAdygVYqBTLKmziZXa2K8M6rxUhPm1kBtoS6WjDBy1oj6QuXG5Ug0sD+tEr2pVWQVdHEOA9LZvnbMTPATuM3+D9PF/LKthQAfr1nLOM9rft8TmFNK1sTStiSUEJ5g4Q5QfYsDnFivKfVkBkPg+q9OZNXyx9nCtmdUk6Ii8r0dU6gvcaEkkaJjHVnCvnlZD7aWmIene7FdcEO/Voh25VYzJm8Gl5brL4J7GA4mlnF2zvScDQ34KYxLswLstf4BKSmuZ1Xt6VyPKuaVxcGcEOok0aPsTG2mFe2pvDQFE8emeZFdXM7sz49RkObDAA9bTFf3BrKnMBLr2NROdU8sDaW+yd58Oh0r67z+ju2mOf+TuqxsqMTsQhOPDf9kmqz41lV3L8mlu+Wjx7wxAnOjwWf2GP8eF88vykJKyM9nlHDRHr1sRwOpFWy4cGe48FBJVyU1LXxxa29V1LKFEqWfB1FelnjBe+lr50Je5+arN4L6GDRVyd4cIpnV1tN5LsH+eq20G4rAiQyBX4v7yH2pZndtkNsTyzlh+O5bH10Yq/HVCqFHlsVzpU3sWjVCWJemtXr5EKhFJj20RH+M9unS3jSBKklDSz48gSTvKz56rawHhcYaprbWfjlCe6eMIKVk/tnjJ5a2sCir052+zvQFot4Yb4/90zsPR78h+O5fLo/k1W3hzHV17bPYza0yXhqfQK5Vc2sXj4aH3vNGIyfv/93dqazM7mM5+f7cesY1wG3oyg6TLu/O5qDs4Uhry4MGBIz3oGQWFyHtkhEoJP5lT6VflFS38bGmGL+ii1CqRS4bpQjN4U7DyhdbyDkV7ewI6mU5JIGjmZWMcPPjoWjHJjqa3vFK6w6ya1q5lBGJQfSK4jJr8PL1ljVXuVvR4iL+f9UG//FVDRKOJWrarGqbJJwNLOakU7/iDnh7hZqjamGxZthrkWuvJQ8zCWYmKhuTn353QC0tLR0/VmdNit12LlzJ3fffTeCIGBnZ8f+/fsHLdwAPPDAA13izdGjRzUq3qhLUW0LJ7NrOJFdTXRODRKZgnEeVkz2seGF+f742BlfVatm6iJTKDmTV9tVYWOqr42HjTEPTvFgqo/tkFUMbY4r5uWtKciVAmIRbIwp7lG8qWluZ2dyGWfzatmTWs5kbxuemOnDLH87DHSHdjBU3yplU1wJ62OKKG+QsDTMmV2PT9ToQLCkvo2fT+Sx7mwRvvYmvLIwgFkB9gMaQPk7mPLengwebZZgbTx0fgoZ5Y28syuDxKJ6HpvuxfJItwFVdfSGIAhsTyrjtW2pjHG3YP/TkzWavNYuV/D69jR2JZfx7R3/iCS2pvr8cGc4t64+hVwpYGuqx6xuTFu3xpfw303JvLEokBsvMvNcOtq5I90puVcBx9fe5BLhJrm4gZe2pPD+suBBCTedseAvLvAfsHBzPKuKXcnlHHt2Wp/bKpQCa6IL+qxG6WyZ+j81xKD3d2eQWdF0yXuYWdFEbYu0X8bLUoVwwSq8llhEDwUh6OtoYaKvTWVTe7fijZ+9CecqmlAohR5/p1K5kgnvH2LrIxO6bQX1tTfB3cqIfanlLAnreWKgJRaxcrIH3x7N7Xd0dW8EOpmhoyXieHY1Ee8e5JnZPiyPdL+k5dPKWI9v7hjNLatPEehoynivvkX2TgIcTLE00qXyoth1kUhVzbYopO9qjPsmeWBrqs9Dv8Xx5uKgLs+injAz0OGHFeF8eiCTZzYm8vBUb+YGDX4ccv7+318WzIJgB57flMyOxDLeXxqMq1X/Fze0xCJuHevK/JEOfH4gi+u+PMFt41x5cqbPFW/9GOV85U2VB4KTuQFPzPTmselenMmv5c8zhSz44gQBjqbcHO7CgiE2OXa3NuLR6d6ASqDdkVTKe7szeOavJGYH2LFwlCMTvKw1HnveHzxsjPGwMea+SR40tMk4llnFoYxK7v31LGKRiKm+NswNtCfS0+qKRdwPFDtTfRaFOHUJ3SX1bUR3+OU8vymZyiYJo5zNGe9pRYSnFaEuFkM+jhxmmKuFYfFmEGhra5Oenj7o/Tg4XGjM5+zszOnTp2lpaem1HQlUSjKAjY2NRvxujhw5wrJly5DJZFhYWLBv3z68vHpOGukPAQEBXX8uKSnRyD77oq5FSlSOSqyJyqnGUEcLY31tJnhZc9d4d0a5mF+WctyhoLldztFzVexPK+dQRiX6OlrMDLDj7RuCiPCwRF9naH/eu5JLeXbjP1UJSgF2pZTxzpKRXStTrVI5+9Mq2BJfwonsakY5m7MoxInXFwUNKCmnPwiCQExBHX+eLmRnchnBzmY8Os2LWQF2Gl05Syyq54cTeexNKWeGvy2/3jN2UCkktc3trD1dhK62NhX1bUMi3lQ2Svhkfyab40tYHuHGF7eEYG6o+c+jslHCB3vPcTijkjcXBTF/pGYrekrq23j4t1gEYMdjEy+pKhvjbsl/5/nx1s50/jPL94KVdUEQWH0sl0MZlXy7fDRTehBYloW7IADP9yDg6OuIufGiiWhBTQt3/3KG+yd7cP0g2gyUSiXPbEwg2Nmc2wbolaJUCry3O4NHpnmqJeIeTK9ArhCYHdh7OlFmRRM2JnpM8e1dmDqQVsEvUfk9vHdaHM+q6lclilSuuGDCpC0WIVf2nC5mY6JHZVM7/t3437pbG6FUqnx0ejLz1dUW42ppyImsam4a031Sz+JQJ7YklPYq3gDcONqZz/ZncjyrelCC3sUEOZoRX1RPm0zBB3vPsfp4Lq8tDGTuRRV0o1zMee36AB79M57tj01Uu7JUJBKxONSJn0/mdRmBa4tFvDjfj9jCem7/4TR/rIzo85p+/ShHrIx0eXBtLBWNEh6e6tnr9UAsFvGf2b4EOpryzF+JpJY28NRMH40atk72sWHvU5N5b3c6cz8/xssL/LlpjOuARHczAx1eWRjArWNdeH17GtM+OsKzc3y5Kdzlf7oK4koiFou6Iqk7TY5/O13A69vTWBDscFlMjlUeNL48PcuHlJJGtiepTMBbZQpuHuPCFG8bxnlYDfoz7vQNHAhmBjpd0ewKpUB8YR0HMyrZFFfCI3/EMXaEJdP97JjhZzukHoJDhZO5ActGO7OsY0GlqLaN6FzVIuyGmCIUAnjaGBHpYd3lMXYlhbVhhhlKhsWbQeLn56fxfQYEBPD3338DkJGRQURERLfbyeVycnJU5o/+/gPv2e/kzJkzLFy4EIlEgrGxMbt37yY4OHjQ++3kcnXoncqtIStZ1Q6VVtqIj50JE7yseW1h4ID7Zq8WKhslHDlXxa6UMqKya3C1MmR2gB2/3jOWUc7mly2F4FBGBY//mdDthOxgegWGutpsSShhX2oFzhYGLA514o1FQRpJE+qLhlYZm+JVXjblDRKWhDmz/bGJ/Yqf7QulUuBgRiXfH89FRyzC286EA09PGdCqbdd5t8n46UQeJ7KqMdTT4ps7Rmu89L5VKmf1sVxWH8tlmq8t+56arPEUEVD91v+OK+GN7aksCXNm/9NTNC7WReVU88jvccwNcuDVhQE9CnL3ThyBh40Rk88z+VUoBd7ckcaOpDJ+uXsMQU69R5ovDXNmV3Iph89VX/KYVK5k/sh/BJqqpnZW/HSGxSFO3N+NB466xBfWce+vZ6ltkRH38qwBD+q3JZZS3ypjRaS7Wtv/Gp3P8sje4+ABdiWXY2mo22vpelFtK4+vi++xaqlNpmBfakW/xBuZQrhgUC4Wi3r1JLI10aPqooqRTnS0xHjaGnOuvLHXJKZJ3tYcz+5ZvLl+lCN7U8qpbJRg24vJqr6OFneOd+fbozkaFW/8HEyIL6oHoF2upKKxnSfWJeBtZ8ybi4Mu8K66eYwrCUUNPPRbLBseiFRbyL4u2IGfTuQBKuHm9esDuT3CjeUKJY+vi1cJOPeN6zMxZoKXNeseiOCun89S2SjhlYWBfU565wY54GFjzP1rYkgrbeTTW0Iw1WAlgbGeNm8tHsn1wY48szGRjXElvL80eMCVbt52Jqy9dyz70ip4a2cav58u4LWFgV1mzpeD/JoWXt+WwjgPa5aGOV+WWOah5nyT49TSBv6KKWblmhisjXW5KdyFG0Kdev39DRaRSMRIZzNGOpvx37l+xBXWcSK7msfXJQCq38jCUQ6Eulj0eyz2V0wRqw7nsOHBiEFXpmqJRYS7W3Z934pqW7vaq97fnYGLpQEz/O2Y7mdLuJvFkLaqDwUikQhXK0NcrVy5eYwrSqWS/JpWonNriMqpYe2pfJrb5YS7WeJnKr3SpzvMMBrnf3cWew0zceI//fdHjx7tUbyJiYnpapsabAtSUlISc+fOpbm5GX19fbZv3864ceMGtc+LSUtL6/qzo+PQmd69uyudGeH+rJzkwXhP6//pQYsgCORUNbMvrYJ9qRUklzQQ6mLO7AA7Xrku4IokFp3MVvmDdDchk8iUvLQlBT1tLRaFOLLxoUiNmSL3hiAIJBTV8/upAnYklxHgYMr9kz1ZMNJBo6W0bVIFG+OK+elEHq1SOXeOd+f2sW6DaktrlMj4+UQ+P5zIJdDRlP+b68s4D814V3WiUAr8HVvM7pQy6ttkrL137JBFlJfWt/HC5mRSSxv56MZRzO7GY2YwqAxQc/j6cDZvLg7qs9pBJBIx3e+fKhKJTMGT6xLIrGxi88Pj+xQUlUqBF7ckk1PVyn/n+vLRvswLvvsBjqZdKTfN7XLu+eUsIS7mvDB/YIJ6ZkUT/8/eWUdHda5v+5qJEkjwuJJAQoAQIBAIBHcvUKB4sUKBUuruSiltaSlQ3N2huAZIiBCBuLu7TTKyvz/ScJCMRID++uVaq4tzMnv27Jmt7/0+z31/ezacW9E5yAVBbeKTKipkctZcjOStYR00GqRHZRbjl5DPuunq0wDPP8jg9UHKxalKmYKFO/0fi1OvietR2So9ZWpa76PCUlXljSrxRp+sYuVJSR1NDYnIKGZkZ+XR1J7t27DLO1Hpdpq3aIKOtpiz99N5ta9q75fZvW3YeCOWkJSCehlYP0q7Ns3Q1xYjeeS3rpQrCEsr4uWN3gxybMunY50fCrVfjHdm2iYfPjv5gB8nu2h0fe5i0ZwWBjrkllTy9YTOvOJeVQmmrSXmt+ndWLEvkFlb77J3obvaKr5O5s05ttSDudt8+fZsGO+NdFJ7fHYwMeTksn6sPBhIz68vMayTKZO7W9LVqkWDCcO92rXmwpsD+PliJON+v8WKIQ4s9mxXp8GtSCRiRCdTBnRoy9Zb8ay9FIWxoR4fju74zFKUHmXLjVjk8qoEx0thmbQ3bsbSgfYNItYXlkn57Uo0cz0aPkJcUzqZN6fT+OZ8MMqJ65FZ7L2bxJqLkfRv35apPa0Y7PRsTY7Fjwgkywc5cDc+j9PBaczf4U8zPe1/hBxzOplr9vyz404CiXmlTN5wh+Ov99U42EATrFoZMNfDlrketpRUyLgVncPViEyW7wvEpnUTLFoYMKSjMQM6tH0mFbjPGrFY/LCFbKa7DYIgEJ1VUnXs+4WpX0Ejjfwfo9Gw+F9IZWUlxsbGFBYW0rFjR0JDQ2u8+C9ZsoRNmzYBVVUzPXv2rNPnRUVF0b9/fzIzM9HR0eHEiROMHj26Xt+hJoYOHcqVK1cA8PLyekykqi+PmpIlJSU9/N//F6kueb0UlsnFsEzSCsrxbN+GYc4mDHYyeaFilF9CHjM331WaOgJV5q33Ph32XB4CiiRSTgamsvduEqn55cz1sGFsV3OcGtjcMqtYwm7vRPb4JGJipM8iz3aM62per7LcYomUHbcT2HIrHkdTQ1YN7UAf+4YVbaAqnvm7v8MprZTx3ghHxro0nN/GowiCwAG/ZL47G86IzqZ8Osa5wb2WCsulvH0omMjMIjbM7KG2YuZJCsoqWbjTHwHYMsdNbZWAQiHw0fH7eMflcmBxb8yaN2Hf3UQ+OxmKTCGgryPmg5FOzOtrR6VMwYKdfggCbJvXs9bHRnJeGT9diOTs/XRAeOjjMrePDV9O6FyrdVWzxSuOIwEpnH3DU6OS/m/PhqElFvGBGr+buOwSRv7qRcCnQ5V6KXxy4j6H/FOoVCPe6GiJOLzEo8a0qJoY8ctN1rzclS6WVft+xmYfFvSzexhB+yRfnwlDrhD4YnzNceabbsQSlFzAhlk9lH6mTK6g21eX2L+4t9Jjbt/dJA76J3NymfqJlC9Ph5JVXMF6NQlVmnIxNIM3DwZRVimv8XXtf/b9zN7WrBragRYGuqQXljPu91u8OaQDs/rYaPQ5RwKS0RaLmdjt6UqpSpmCZfvukVEoYc8Cd43O/dySChbs9ENXW4vNc9w08oeRKwRcvrxAaYX8oXBnbKhHD5uW9LJrRTfrlnQ0M6y3d9e9pHzeOxKCvo6Y1ZO74mxev3tKemE53/8dwZXwTJYPbs/8frYN7i/2KEt2+zKvty292xsTnVnMhuuxnLmfzqjOpiwb5FCvStTq73L+n1bhhZ7t6tUq3FCk5JdxNCCVQ/7JVMjkTOpu+VxNjqHqPLgVk83p4HQuhmbgYtkCN9uWjOtqrvQ3Ty8sp+8PV1EIVeeqRcsmHFvqUaNPV0OiUAjcTy3gSnhVFHlERjE9bFoyxMmYIR2NsW/7f9MD8lEaDYsb+S/SKN78S/nss8/4+uuvAVi9ejXvvvvuY697e3vTv39/ZDIZAwYM4Pr160+tIyEhATu7qllAZcskJSXRr18/kpOT0dLS4sCBA0yZMqVW2+rj44ONjc1T3j3VCILAp59+yrfffgtA165dCQwMbNCbwv/1C7REKud2TA4XQzNJyS8jLL2IwU4mDHM2oX+HNrVKKnpWBCcXMHWTt9qZ9CY6Wnw5vpPSFoP6IggCwSmF7L+bxKngNBxNDZnhbl3rRCdNiMos5nhgKltvxeNh35qF/drR16F1vY7dYomUXd6JbPaKw6FtM1YN64CHff3WWRPPw4y4muS8Mj44FkJcdinfT+qiUZpMbQlPL2LJngDs2jTl12m19+hJzitj3nZfHIyb8dv0bmpn+hUKgQ+OheCXkM/+Rb0fVtcA7PVJ5PNToSgEAZ+PhtCmqR6rDgURm13CgcV9atWamVNSwW+Xo9nvm4QIkD5SRaKvI+aTMc7M6q3Z4PpRCsulDPjpGr9Oc9U43af3d1c4vKSPWlFs/bUYAhLz2TZP+YTByF9vEpFRjJ62GLEIyqU1Xzd0tcQsHWjPqmEdKKmQselGLG8O7aBUbOry+QWOLPXA0bRqIDTu91ssH+xQY4oYwB6fRGKyivlifM0C2PXILL48Hca1dwaq+MawaJc/3a1bsnRgzdVGBWWV9Pr2ChdW9VfZggVVx+L7R0P47qXO2Lapf/VkZEYxY9Z5aZSKZtnSgJvvVRlX+8Tl8tnJUH6Y3OWx1iplFEukKo1PK2UKXt8bQHZxBbsWuGskxpRVylixL5CU/HJ2zO+JWXP1PjzX/jFlffLr6uuIkSsEFP/4X7i3a42bTUu6W7esU8tuhUzOH1dj2OwVx2LPdiwb7FDva+jduFw+PxVKhUzBZ2OdGeTUsNdKSaWM7bdj8Y7NZ9urvR6rGkrKLWPjzViOBqQwoENblg92qFf116Mm/R1MmrHIsx3DO9XNpL8hUSgEvONyOeiXzPnQDDqZGTLD3YZRXcyea9u8RCrHKzqbE4FpXInIxLqVAeNczBnb1fyxa8QWrzjWXIxE8s81UkdLhGVLA44t9VA7wdCQpBeWczUii6vhWdyKycHESJ/BTm0Z0tEEd7vW/yc9ZP6vjw0aaaQmGsWbfynFxcW4ubkRFRUFwOLFi5k+fTpNmjTh2rVrfPfdd5SUlNCkSRPu3LmDq6vrU+tQJ97k5ubSp08foqOjAXjvvfeYPXu2yu1q2bIlFhaPz7p98cUX/PDDD4wcOZJhw4bh7OxMixYtqKioICQkhK1bt+Lr6wuAgYEB169fr3OVkDL+L16g80sruRqRxcWwDG5G5dDWUI9hziYM62iMm22rf1Uf8rXILBbu9FfpLfEo3axbcPz1hk0TKy6XciIolf2+ySTllTHB1ZwZ7tZ0Mq9d9YU6BEHgVkwOm73iuRuXy5w+NrzsZlVvz5ySChk77ySw7VY83axbMNfDln4ObRpctMkskrD2YhQngqrMiJcPdnhmVVAKhcAu7wR2+yTi3q41H45yeiapFscDU/j4+AMW92/HG4Pb19pPICytkFd3+DGyk6lGHhtyhcD7R0MISHxauKlm391E/BLy+WWaK79ciuJaZBZb5/bUuDKuSCJl041YNntV+YjUVKGiryNm+7xedarI+ul8BIHJBexd6K7RMbbFK45zDzI4utRD7bLjfr/F7D42THVTLdAWS6REZBQTllZEcErVDG+xRIpYJEJXW4xEKkchVCUWXVw1gIiMIqZs8ObBlyOUrrPDJ+e48Ob/BJKJ62+zuH87RnepefLgeGAK++8mK409zyiUsGL/PXbN70UTFeLvbu8EzodmsHdhzW3MUCXwdDZvzsqh7ZUuU82bBwIx1Nfh64lPi0rVArWm1UjllXI6fnZe5TJ62mKM9HX4fUY3ej/SlrntVjybbsZyekU/lV4bfgl5vLE/kGOve6gUWCpkcpbuDqC5gS5fTuikkTeNTK7g4+MP8IrOZuf8Xmq9vgRBYMBP10nKK1O5nFhU5WtUIVNw5e0B2NexzTg0rZD3joRg2bIJSwc6aLxflCGTK9jvm8Sai1G42bTk07HODWYiu+5yJKm5Zcz1tMPZvObtzCiUsNkrjn13k3Czbckbg9vT067ubbRFEikHfZPZfjsebS0xCzxtmdLdiqb/An/BwjIpfz9IY+/dJGKzShnjYsa0nla42Txbk+MnKa2QcTk8k9PB6dyMyqaDaTPGuZgzxsWM+Tv8iMp8PF1WR0uEdSsDji71eCGtTOWVcu7E5nAnNpezIemUVMjwbN+GIR1NGOjYtkHbup4l/xfHBo00oo5G8eZfTExMDKNHj34orjyJkZERe/fuZezYsTW+rk68uX79OoMGqY+OfZS5c+eyY8eOx/72xRdf8OWXX6p9r7W1Nfv27XsmEeH/Vy7QyXlleEVncyo4Df+EfDqaGTHc2YRhnUxwNDH8V5WoSqRyrkdmcSIwjfOhGUDVw7CulhipQlAp5IhFcOeDITUOemvL/ZRC9vkmcjIojb72rRnc0YTxXc0b/MGwQibnVFAaW2/Fk1VcwazeNszubVPvNrXq9qitt+Oxb9uMlUPa49m+dqJNSYWUyPQietiqHsTLFQKD1lzHxbI5741wqpeBsjric0p570gwGUUSVk92oY+SiPj6UCmT8+3ZcE4EpfHrdFcG1aGi52ZUNq/vvcf7Ix2Z1dtG7e8uVwi8dySEwKR89i/urdafYvPNODbeiOXIkj7YaTA4FASBzV5x/HY5GplCUFvJ5vfx0Fofg+mF5Yz/4xbb5/ais6V6cbP6uHl3hCPj1KRjJeeVMWjNdfw+HlrrWeEx67xYMsCeDiaGhKcX8SC1kHtJ+cgVAieX9+N6ZBZfnwnjytsDa3y/IAi0++hvvN4b9DBZbMqGO8zxsFWa6nU7JoePj9/nupKYdEEQ6Pb1JXbN76WyCiE+p5QRv9wk+PPhSn20zoak8/PFSK68PUDtcRaWVsSkDbe59f7gpwZCWcUS+q++xpElHkqroARBQKb4X2x61y8vUlgurXFZHS0R47qa89WEzk9VHgiCwJsHg0gvkLB3kbtSnxBBqGohvJdYwKElfVRW1UgqZSzZe4/Ccim75vfSSNAVBIFfLkWx0zuRLXPd6KnG3PdoQAofH7//mM9PTehpixnR2ZTfprnW6/5aKZXzl1ccf1yLYW4fW1Zp6COlivzSStZcjOTovRSWD3Jgfj+7elWPVkjlfHAkmGWD7XEwUX/e55ZUsP12AnfjcxGLRLwxpH29qkClcgV/30/nSngWN6KymeluzTwP22dqIlwbQtMKOeSXzImgNFo31eVlNysmd3+2Jsc1UVgu5WJoBqdD0olMLySzuGZTXR0tEbatm3JkiUeDtyDXBkEQCE0r4mpEVXvVg9RCXCyb/9NeZYKT6b/r2fVR/q+MDRpppDY0ijf/ckpLS1m/fj2HDx8mJiaGyspKrKysGD16NCtXrsTGRnk5/fMSbxITE/n777/x9vYmJCSErKwscnNz0dbWpk2bNnTv3p1x48YxY8YM9PWfzU3y33qBrr7pXQzN4GJYJrHZJUzqbkkncyOGdjTBXMOo1ueFXCHgG5/HicBU/n6QTksDXSa6mjOqiyn6Otqk5peTkl9GSn45cTmlJOaWklZQTkGZFET80yIhQiKV89HojkzvZc33f4fzznDHWg30SitknA7+Z7Ysu6SqyqaXzUOfi4Ykr6SC/X7J7LiTgKG+Ngv7tWNSd4t6P5hXGxFvvRWHo6khK4d0qFPLVYVUzrZb8ZwKTuXY631VVgdAVfvGs5ypkysEtv1jwDmtpxXvjnB8JjOsGYUSlu0NwNhIn49Gd6xT28ORgBQ+PfGA7yd1qdGn40nkCoHV5yO4FJ7JgUW91T7UnwhM5ZMTD9i/qLfGx2ZeaSX9frz6sOpEFU10tAj7asRTx8zvV6LpaGbEUOeafV7ePRyMRKbg91fUGw9DVULcR8fvc+v9wWpNPrd4xXE9Mps9C2tnaF8pU9D58wtcXNVfaZXBQb+qVkhl1S1SuYL2H5/D9+MhD6tEpm7y5pVeVrzUreZrflRmMRPX3ybsq5FKt23aJm8m97BUWUkkCAKLd/kzu4+t0qQoiVSO2zeX2bfIXaN2lLnbfOlq2Zy3hjs+9dp3f4cTmVHMzvm9anzvV6fDMNDV4p0RVe8ds86L0LSip5ZroiPmjxndlXoCQdUs+6QNd+jdrhWfj6vZGwiqKkYW7w6grFLGzvm9VLYQSaRyFu8OoLSiallN21X23k3k27Ph/DLNVWkrHFQdT+7fXSa/rGbBCqr8Q+zbNuPk8r71vp5XE51ZzLtHQigsl7J6iotakUkTwtKK+OzkA1ILyvl4TEfGdDGr02BYUilDR0uEllbtvmthuZSddxLYeiseB+NmvDGkPf1rOcHwKIIg4BOXxxavOLxichjnYs6i/nYN7kVXVyRSORfDMjnkl8zd+FwGdGjLtJ5WDHR8tibHNbHmQgQbb8QpbXnU1RJh16YZh5f2adCEtfqQVSzhekQ2VyIy8YrOwcWyOQ7GzRjiZEIf+9YNdq41BP/WsUEjjdSHRvGmkf8E/6YLtFSu4G5cHhfDMrgclkmRRMZAx7YMczZhoKOxRj4AzxNBEAhLL+JkUBqngtJwMjPEppUBE7pZ0M2qhUYPcFK5goxCCSn55aQWVAk8fexasfZyNHfj83h/pCNLBzqoXU9YWhH7fBM5EZiGdSsDZrhbM8HV/Jm04sTnlLLtVjxh6UXoaolZ6GnHIEfjesetF5ZJ2e2TwKabcTibGbFyaHv6tKu9aCMIAuceZPDb5ShaNtXl49Ed6dJA6TR1JTqzmHeOhFBcLuXHBhq41IR3bC4r9t9jkKMxX0/sXOuHQUEQWH8thk034tg4uwd9HdRXBckVAm8fCuJ+aiH7FrljYqRaWL0Zlc1ruwPYNLtHrWOfU/LLWLrnHlGZxSorbxxNDbnwZv/H/haRUcTE9bc5uazfQ9+XR4nMKGb8H7e4tErz6PrZW+/Sy7YVK4Zo0O5zMJBetq2Y4V47H57w9CKmbLjD/S9GKD3HfrscTWJeKWunutb4emmFjE6fXyDos/8Zos/Y7MOk7pZM6VHzNb+grBLXry4R+uUIpSLj5ycfoCUW89k4Z5Xf4cNjITTT0+bjMcqXe/tQMM2b6KhdF1TF3S/dc487Hwx+atvySyvpv/oaf81xq7Ft7kFqIVM23uHvNzxp17YZbx4I5ERQ2sPXdbXEOJsbkppfzsnl/dROFCTlljHuj1t8Md5ZqRAGVR410//ywbZ1lfeUquulRCpn0S5/JFI5O17tpbHIeyE0g+234hnb1Vyl39NfN2NZeynqoVfIkxjqa3NxVX+NfHRqg1whsP12PD9frBKw3xvpWG+/NUEQOB6Yynd/R9DeuBlfTuhUq1bdsgops7f6YqCnzSDHtkztaV1rf5diiZTdPols8YrHqmUT3hjSnsFOxvWqqojJKmHrrXiO3Uuhl10rFnm2q3Xl6bMkOa+Mk0Fp7PNNpFImMLm7BS+7WdU5Jj45rwzLlk00/n6D1lwnPqdU5TI6WiIcjJtx6LU+z+RZqD5UyOT4xOb+E0WeRV5pJX0d2jCkozGDnYyfS7KaKv5NY4NGGmkoGsWbRv4TvOgLdLFEyo2obC6GZpKUV0Z6YTlDO5owvJMpvdu1eqapEnUlOa+MU8FpnAhMJbWgnOHOJkzoZkE/hzb1nn2qLsU//yCDCpkCY0M9fD4cUuODfnmlnNMhaey/m0ShRIqbTUtmuNvQ1bJ5gz/gCYKAX0I+m73iuBGZzegupiz0bFfr1KKayC+tZNvteHbcTmC0ixkvdbN4zFuiNgQk5vHt2XCS88t5a1gHXu5h+UI9kKRyBZtuxFa1DHjYsmpo/VsGakIQBLZ4VVX1fDbOmek9rWp9DMjkCj47FcqV8Ex2vNqLjmbqZ3tlcgVvHw6uEg8X9VbZppRaUM6Xp0K5FJbJL9NcNaroqQm5QuD3q9H8cTVG6azrRFdzfn0ktluhEJiy8Q697FrzwSinGt8zf4cfNq0NVFZQPEpMVgmj13lx54On23eeJLNIgscPV/H+cLBKf5SaOBqQwn7fJI6o8NT58Nh9Whro8N7Imr9btRAT9tWIh4Pl2VvvMtbFjGk9rWt8jyAIOH56/jGfnCfZ75vEmRDlFT/VnA1J5/er0Zx/QlB7lJtR2Wy6EcuuBe5qvZUEQWDC+tu81M2ixojx369EczUyi2NLPWo8Dz4/+YC4nFJ2ze/F+msx/HYlGkGo8nn5flJnJrha8P7RENIKJOya30utMH0tMotle+9xeEkflV5iOSUVTPrzDqM6m/LhaNXJZOWVchbu8kMqF9jxak+NRQ7/hDwW7PRnTh8b3hrWocbvX1Ihw+2bSzWKNyJgx/xeDKilsFob4nNKef9ICOlF5fw4yQUPDURidRRLpPx2OZrdPonM7m3DyqHtNRqwHw9M4fi9JKb3suViWCY3IrN5fWCVUX1tr9VllTL2+iSx6WYcJkZ6vDWsQ70nNnJKKtjtnchun0R62rRkWCdTxtczsbEhkSsE7sTmcNAvmYthmXSxaM40NyvGuJhpLDqm5Jfhufoarw+0590RNV/DHiU2u4Rha2+orcCspqWBDqeX98OyDlWozwNBEIjKLOFKRCZXw7MITC7A2cyICa7m9LJrRWfz5vWeHKstL3ps0Egjz4IX7ybWSCP/R8ksknApLJNLYZl4x+Zi28aAYc4mLOhnRxeL53+T0oT80kouhmVwJCCFoOQC+jm0YflgB4Y5mzRoUtOai1Gce5Dx0IS1oEzK7dgcPNv/70E6KrOYfXeTOHovBYsWTaqqbLqa0/wZtPzI5Ar+fpDBFq844nNKmeFuzVcTOjXIjGxeaSVbvOLYeSeBbtYt2TqvJ73qaP4Yn1PK6vMR3IjKZnH/dizybPfCTR9D0wr59MQD9HW0OLC4T73NOpVRUiHjvSPBBCUVsH9x7zp9TlmljDf2B5KYW8ax1/tioUFbokyuYNWhYCIzlAs3UrmiSgy6k8Dd+DwEAYz0tess3ABoiUW8ObQqaWzWVl9kcsVjD/F62uKnhKeD/slkFlXwxpCaq9i8Y3Pxi89jzctdNd6OXd4JjHUx08iA8kJoBj1sWtZauAEISy9SG7ecWSSho5nyaoPq68mj4nJ1XLQyRCIRbZvpkVUkUSreOJoa8vPFYpXbBuBh35oV+++RVSxR+hv0dWjD24eDufPE9U7Ztr3W357v/g5nVm+bp0Tz+f3s2OmdwOXwLIbV0CL31nBHhvx8nfMPMrBp3RSpXKCXXSvWTe/20G/s07HOjPzViz13E5nTx1bl9gxyNGbpAHtWHQzi4OI+Sltd2zTTY+f8XkzecAez5vrMq0F4qqaJrhZb5vRk/g4/5u/wY/u8Xko9gx7FzbYVR5b0Ye42XzKLJHz3UpenBOxmetrM7WPLjjsJj1Ww6WiJ6GJuxLdnw7Bt7YZN64YxA34SuzZNObC4N3vuJvLblWjO3k/nw9Ed65VoZKivwydjnZna04rPT4YyaM0NPh3bkfFdzZUK2QqFAt+YHIZ1NGV0F3NGdTbjRlQ2ay5GsuVWHMsHt2eam5XGQomBrjaL+rdjdh8bDvgm8dnJUAz1I3ljSHtGdjKt07NNm2Z6rBrWgaUD7TkdnMaf12JYfT6CeX1tmdnL5oV6ukDV9dizfVs827eloKySk0Fp7LiTwBenQx+Kw92tVVciH/RLRksk4q+bcbRtpqfyvAA4HZSGtpa4RrP66m3S0xYjkwtUyhXkl1UlCA5zNmVcV3MGOxlrdC49L0QiEY6mhjiaGvL6QAfySiu5HplFcEoBv12OpomuFoOdqipy+rX/d6SoNtLI/0UaK28a+U/wPNR1QRCIySrhYlgmF8MyeZBaSHfrFgx3NmWYs0mDpUU0NOWVci6HZ3IyKJUbUdmM72pOV6sWjOliRutnkBiw/24Sn516gFT+v0uLCBjo2JYNs3pw7kE6e32SuJ9ayFiXqsQodQ9FdaVIIuV0UBp/Xo9FLIb5fe2Y6tYwKRi5JRX85RXHbu9E3GxbsXKIAz1s6iba5JVWsu5KVVz0pO4WrBra4YWbPFbI5Ky/GsNfDRiTq4yYrBJe2+2PaXN91k3vVqfjMrekgm/PhpNaUM5fs900GgzI5ApWHgwiJrOEvYvcnxIw4nNK2Xc3kQN+yVTKFA8HiCLgPQ1bAdXx/blwbsfkYNPKgIthmQ/PGwNdLdZN7/bQ1yanpIIhP9/gl2ldGez09EBeEAQmrr/N8E6mLBuk2XYVSaS8tP42v05z1agl75W/fBjeyaTGKhFN3jvB1ZzpvWqukAEY/ZsXK4e2V+p1kpxXRv+frhH33eiH14uFO/3p36GNSmFi4vrbLOhnp9SMuaRCRufPL2hkDj3hj1vM62ursrXoq9NhFJZL+XmqehFNrhAY/PN1Vg3tUKMYuON2PPt8kzi3sn+NlTxHA1JYczGSU8v7EphUwDBnk6eupd6xuSzY6cfZNzzVxpgrFALvHgkmu6SS7fN6qqweCkzK58fzEcztY8OoLqqNrssqZby6vaoq7MvxnTUedGYUSpi33RfzFk34Y0a3pwZ8WcUSPL6/+lDA09MWM7qLGasnd+H7c1VmwH/M6KZWSKsvSblV8e9JeWX8ONmFfu3rX4UjCAJn76ez/24SUoXA1xM6P9UqmVNczlaveLJKJHw2tvNjkx+CIHD+QQY/X4qiQiZn5ZAOvNTNotZR3hKpnEP+yWy4HkszPW1WDGnPmC5m9YoEVygErkZksdkrjvuphUx1s2JBP7s6eZs9Sx6kFnI8MJVj91Jo1VSXqW5WTOpu+dR1QqEQ6PntZXJLq8yHtcUifpnmqtIAvt+PV0kvlKCnLUYqVyCVCzTV1cK8RRPs2jSlvUkzbFo1xbq1ATatDTAx1Ccup4TTwemcDkkjo1DCkI4mTOpmjodDm39lhXc1lTIF/gl5XInI4kp4JmmFEjzsWzPEyZhBTsYPDegbmsbKm0b+izSKN438J3hWF2i5QuBeUj6XwjK5GJpBeqGE0V1M6dOuDYM7Gv9r4xJlcgV3YnM5EZTKhQcZmDTXZ6KrBRNczZ/ZLCTAtYgsFu3yr3EmXARYttRHT0ebGb2smdzd8pnNtqXkl7H9dgIH/ZJxNjNinoctIzqb1uths5rs4goO+iXz5/UY3O2qfEK6W7es07rKK+Vsux2PT1wuulpi3h/lVO9I8oYgMCmf946EoKstZvUUlwaPY3+Uc/fT2XY7HjfbVrw9rEOd2sMSckqZu92XTuZGrH3ZFX0NBoZSuYI3DwQRm13C3oXuDwUjiVTO+QcZbL8dz/3UQrTFYirlj8+MaotFnFzet96/y52YHBbu8ufU8r44GBtyOjiVd4+EIJULCILAlbcHPhxsv3UoiLIKORtn96hxXWdC0vj6TBjX3xmk8cB42614Toekcfx19QmAuSUVuH93Ba/3B9W6Yk0QBFy/usTuBaoTnXp9e5nNc9zoqqTqKi67hE9OPGDfov+1N31x6gFOJkZMd1cuCr2xPxA325YqBZ7+q6/x3Utd1A66f7oQQXqBhLXTXJUuE5JSwIzNd/H/ZKhGLStHA1I45J/MgcW9nxJeKmRyhvx8g1VDOzC5Bl8fQRCYusmbHjatlLbSQZWgFJicz+HX+qg9x4okUib+cZvRXcweGiIr41JYJisPBLJrfi/c1HhglUpkvLrDF11tLbbMddO4naewXMriXf5UyBRsm9eTVk9UBL19KIiT//j9OBg348Sy/xkUHw1I4ZMTD3h7eAcW9LN7pl4rCoXAPt8kfjgXwbiu5nw02qlBPEpKKmT8djmKXd6JzOtrywcjnR5+j3WXIkjMK+XD0R1pY1jzAFiuEDgZlMqvl6PR0RLx4aiODOlYey+bCpmcIwEp/HktFj0dMSsGOzDOxbzeLb0hKQVs9ornwoMMhjobs8izHd3qeE99Vkikci6EZnDIPxnf+DwGOhozzc2KgY5t0dYS4xWdzYKd/o9V0WiLRex4tZfSa8qmG7EIgHUrg6r/WhtobEosCALh6cWcDk7lSkQW6QUShncyZWxXswZpfX/WxGaXcDU8iysRmVTKFZRVyP/xyTHB1apFgzyrQaN408h/k0bxppH/BA15gZZI5XhF53ApLIMr4VkoBIHBTiYM72SC57+41FMQBEJSCjn3IJ0jAamIRTCuqzkTXS3obGH0zA0CQ1IKmLLB+6mBbjViEUzpYcmPk12e2bYEJRewxSuOi6GZDHU2ZkG/dvSwaZiHwKwiCRtvxLHPN5FRnc2Y52GrdJCpDplcwZGAFH65HIWpkT4fjOpYoynp80YilbP2UhS7vBNYMbg9i/u3e2YPgTK5gp8uRLLvbhI/vdyVkZ2VJ8uoIjApnwU7/Znc3YIPR3XUqKRfKlfw3d/heMfmsm9Rb1o11SUhp5QtXnEcDUxFEASlJqhQZYQa/NnwerVG5pdWMvK3m6wY3P4xU9aU/DJe33uPiPRiwr4agbaWmDuxOSzeFcClt2o2X62UKVix/x6DnYyVer88iaK64mNYBya4qm//OuCbxAG/ZE4sUy/0PElqQTn9V18j9MsRSgfsFTI5Tp+cx/ujwZgqMYuOyCji5Q3e3P9yxMO/Ldt3D1fLFizq307p539y4j7N9HRUihuLdvnjbteKhZ7K1wNVVSwrDwRy96MhSq9jgiAw5OcbvDW8A2NdVFekQNV51/eHq6yd5lqjR8upoFQOB6SwZa5bjbPr4elFvPTnbc6s6IeDcc3ir0QqZ8w6LyZ1t9SoMis6s5iX/rzDz1O7qkx9Atjjk1gVeb3UA/u2qo1eSypkzNvmSxNdLTbP0VzAkUjlvH0omPD0Ina82hPrRyYhYrNLGPrzDYya6HDhzf4PW8aqCUou4LXd/njYt+H7SV2eeRpOcl4ZHxwLIT67lB8mu9Ta0FwZERlFeMfmPqx8KyiV8MGxB7w3wpF2Svb7o0jlCg75J7P5ZhxGTXR4f6STRmbuT1IpU3DsXgrrr8fQTE+b+X3teKmbRb1FnOpJl/uphSgUAgs92zHM2aTBBvINRXJeGYcDUjjin4xUITC5uyX3Uwu4E5PLkwMqPW0xh5f00Sh9rq5UP/udDk7j7P10yqVyRnU2ZayLOb3btf7X/X5PUlBWyc3oHK6GZ3ItMhttsYiBjsYM6WiMZ/s29RJAG8WbRv6LNIo3jfwnqO8FOr+0kisRWQQk5nEiMI22hnoMczZhuLMJPWxavlCzWHUk5JRyMiiNk0GpZBVXMKu3Nf0c2tLH/vndtJNyyxjzuxclEtlTDy+P0rqpLr4fD23Q7ZIrBC6HZ7LFK46wtCKm9rTiVQ87jZN21JFeWM6mG3Ec8Euif/u2vDGkfZ0NjgVB4FJYJqsvRCKTK3h3hBOju5jWScy6n5SHga4Ye9MWddqWJ/FPzOPdwyE0b6LDT1NcaP8MK4BySip4Y38g2cUVbJzdQ+2ATxmXwjJ580Agbw93ZH4/zVp5qoWO5Lwy9ix0p1XTqoqbD4+FsN83WaN1jOlixvqZ3eu0zVB1HCzZE4BCgL9m93hq/8sVAsl5Zdi2aUqFTM6bB4LoYdNSqbCw804Ce3wSObfSU+Nr1bWILN47GsLt9wdr5IUxd5svHvateW2AvUbrf5Qr4Zns8Uli+6s9lS6TnFfGwDXXifpmlNLrw/2UQuZt9yXg02EP//bG/kA6mhmxdKDy7Vp3JZqEXOUpVgDrLkeRlFfGGhXLQJXI1O2rSxx/vW+NaV/V/HY5mvuphWyZ66ZyfdX8fiWaO7G57F/8tGmyXCEw6rebzOhlrdRH4+eLkaTkl7N2alel15OQlAKmbfLhyJI+dNLgGvb3/XTePxLCieV91Z6jq89HcCo4jWOve6j1RCqWSJm7zRejJjpsmt1D43YPhUJg7aUoTgSlsnFWj8euw+uvReNh30ZpxUZWkYQlewKQKQQ2zuqhNn2rvgiCwH7fZL77O5zJ3S15e0SHBo963u2dQEJ2MZ+O71Kr95VXytlxJ4EN12PoatWC90Y40cWy9vc0qVzBufvp/HwpCkGAZYPsmdTdst6Cf5FEygHfJLbfTkBPW8z8fnZM6WH5r5s4kysEbsXkcMA3iXMPMpQu10xPm1PL+9Kujve52qBQCAQk5XMmOI2z96u2aVZva/o6tKGHdct/pRfjo8jkCu4lFTw0PU7ILaV3u9YMcjRmaEeTWj/XNYo3jfwX+XddCRtp5DmSlFvGxbAMLoVl4p+Yj7OZEcM7mXDs9T44mT77SpX6kFNSwZngNE4EpRGaVshAR2PeHu7IkI7Gz3xW8UnySyuZ9pe3WuEGqmZdb0Rl1ejZUVvKKmUc+SfBRiJVML2nFVvm9mywKPbUgnI2XI/hsH8KQzoac2xpX7WGq6rwT8jjh3MRJOSWsnJIe6b3sq7XQ+6VB6mUyBV8Mq5FndcBVfHLq89HcDo4jeVD2jO3j+0zFf0Ck/J5fe89utu0ZPMctzr7D+3xSeS7v8P5+eWujOpiptF7KmUKlu+7R2pBOXsX9n7MkPXzcZ3IKq7gVnSOyvjuJjpaDHU2rtM2V3PQL5l7SQVceLN/jdcZLbHooYfWXzfiSMwt4/dXuj21HFQNhNddiebHyS61Epl33Elgpru1RsJNYbmUO7E5fD2hs8brf5TQtCKaN1G9nzOLJLRtpqfy2KuUy586Z7TFIhRq5qCMDfXwS8hTuYy9sSGXwrNULgOgp63FuK7mBCTmqRRvJria88e1aArKKh/Gmqtidh8bNtyIJTi54KmKPi2xiHdHOPHB0RBeVuLZtah/O4b8fIMzIelKfTZcLFvw9vAOfHjsPoeX9lErmozuYkZwSgGv7Q7gxLK+Ko143x3hSEahhPk7/DiwuI/KZQ31ddgxvxezt/qydM89NszqrpGAIxaLeHt4B5rpazP9Lx82zOr+0Mtm2SDVMffGRvrsX9ybz0+G8uGxEFYMbq+2zas+iEQiZrhbM8CxLesuRzHil5v82IBVOEVlFdyNzWVSd/WVXU/SRFeLpQPtmdHLmj9vxPDypjsM6WjCO8Md1XoiPYqOlpjxrhaM7mLGqeA0/rgaw7orMSwb5MCUHpZ1TpIy0tdhcX97Xu1rx9mQdDZ7xbH2UhSz3G2Y42FTJ8P0Z4GWWMSADm2Jyy7hakSW0vtGWaWMqZu8ObPC86mqsIZGLBbR07YVPW1b8dm4TtyNy+VyeCaLdvnTREeLMV3MGNvV/JmkeTYE2lpietm1opddKz4c1ZGk3DK8orM5H5rB9+fCsWndlCFOxgzpaEJ36xb/6onVRhp5VjQe9Y38f4MgCDxILWDtxUhG/nqTIWuvcyMqmzEuZni9N4jTK/qxYnB7Opr9O29qpRUyjt9LYdFOf3p/d4W/72fwspslfh8PZfMcN8a4mD134SYup4S+/5juaVLCVyFTsO1WQr0+M7NIwurzEfT5/ioH/ZJ5rb89F9705LUB9g0i3CTnlfHt2TAG/XSNgjIpp5b348+ZPeos3ERnFvPOoWDmbfelr0Mbrr87iNl9bOs9OzmqmwVJeWXci8us8zpuRecw4tebRGQUc+z1vszva/fMhBtBENh7N5EZm++yoJ8df7zSrU7CjSAIrD4fwZqLkeya30tj4aZCJuf1vfdIKyxn70L3p5J09HW0+Gu2G5O6W6CrYt9IpHL6OdR9ABabXcLXZ8JYO7XrU94dT5KQU8qf12P59qXOSh9SN9+Mw75tM4Z01FxQis0uwTsulxkqfGIe5WZUFp3Mm9e5mi0sTX3SVEaRBBM1A5sKmeKpAaGWWIRMrvrq09ZQj6yiCpXLOJoaEpVZjFyD3F5HE0MuhKo+72zbNKWTeXPO3k9Xuz6AFga6TO9pzV8342p8fWhHY2xaG7DtVnyNrxvp6/Dx6I58czaMkgqZ0s+Z62GLAPxyKVqj7Xp3uCMmRnq8ezgYVYXaIpGIHya70KKJLq/vvYdUSfvso9u7a34vckoqWLb3ntLEnZo+Z8kAe76a0InFuwI4EZiq0fugSnj7flIXhnQ0YfZWX/b7Jmn83rpi0aIJP0x2YcXg9ry+9x4fHguhWCKt93rP30/HqIk2A+sxEdLcQIcPR3Xk+juDMNLXZuSvN/n0xAMyCstrtR5tLTGTulty6a0BvDfSka234hj40zV2+yRSIZPXeft0tMRM7GbBmRX9+HNmd8LSi+j34zVWn4sgKlN9OtzzQBAEdj6RdvYkCgHyS6VM+8ubwrL673tN0RKL8HBow2fjOuH38VC+n9SF/DIps7fcpf9P1/jxfAShaYUqz+sXjXVrA2b2tmH3AncCPxvO28M6kFtaydI9AfT45jIrDwRyMiiV/LLKF72pjTTy3GisvGnkP02lTMHd+NyHkd6WLZtgYqTP0oH2DHQ0brAqjWeFVK7gVnQOJ4JSuRiaiVWrqkjtz8c7PzN3fnXIFQLXI7PYdzeJ65FZaGuJaWmgg1gkolgie+h5o6slQkssRiQChSAglQvIFQK3Y3JIKyivddl6eHoRW7yqDFY9HdqwcVYPerdr1WBCW2JuKX9ei+V4UCqjOptydqUn7TXwEVBGRqGEXy5FcTwolek9rbj69sAGTZByNGtFT5vWbPVKwEBfBydzzWeRC8ulfHc2nLP303l/lBMze1k/03JqiVTOL5eiOHovhe2v9qR3u7r5+1TKFLx/JJjiChlHlnjgYKxZGXqFTM7re+6RXVLB3gW9lRpla4lFfPdSF8yaN+G3y9HIa3iotWltoDaRSNX2/3gugld6WatNvxEEgU9PPmByDwuVrSBbbsWzZ6F7rc6D3d6JjO5sqvEM9qngdIbWQhx6krD0osd8fWoio1CCqZHq31UqF9DRevx7RmQUkV2sWpgxNtQnq1iichnb1gYIQEJuqdoWIc/2bVh9IQKJVK5SMH+pmwW+cXnMdFf93atZ4GnHoJ+uk5BT+lR6oUgk4r2RTiza6c+s3jY1xnhPcDVnv28Sv12O4uMxzjV+ho6WmLVTuzL+j9sM7WistvpEW0vM7690Z/pf3uzyTmCuh/L2RF1tMRtmdefljd78cC6CT8Z0VHlcNm+iw+757szc6sOXp0P5YnwnjUXtSd0tadNMj8W7/NlwPYavJ3amm3VLte8XiUTM6WNLe2NDlu27R1haEZ+Nc36mBq/VVTj9O7Th/aMhjPzVq16JVPcScrgWmc3MPjaIxfXfbtPm+nw/yYWFnu3Y45PIoDU3eLWvba0nRLTEIia4WjDWxZxzD9JZdyWaq+GZVea+Pa3qPLkkEonwsG+Dh30bYrKK2XEngXG/36J3u9Ys8mxHX4fWL2zCLTStiJR89WKXXBBIzC1j6C83uPRmf1qoEe4bGh0tMQMdjRnoaEyFrDM3o3I4HZzGyxu9GdihLQ4mhoxzMXum7dL1pZmeNqO6mDGqixkKhUBQSgFXw7PYcD2WtZeq/AOrTY/t2zb9V07CNtJIQ9DoedPIf4JH+1rDo+OIKdPjYmgm1yKzMNDVYmhHE4Z3MqV3u1b/6jhFqBq0BSYXcCIwlTMh6ehpixnf1ZwJrhZ0NDN8YTekzCIJh/yT2X83CbkgML2nNdN6Wj0lwkikcvLLKsktqSS/rJK80v/9l11cQUGZlE/HOWOhgXgjCAI3o7LZdjueu/F5TOpuyfy+dhoP2jUhPqeUP67GcDokjbEuZiwb5FBnDxaoEkY23ohlx+0EhnQ05p3hjs8sRl4mk/PzhftkFcn4eoILBhq0Z1wOy+TjE/dxNDXiu5c6qxUBw9OLKJbI6GVXtxaD5LwyluwJoKWBDmtedq1z2XiRRMrSPQEUlcvYOs9NY+FBIpWzdE8AeaWV7FrgrtFg5GZUNp+ffEBSfvljlRjaYhHz+9nx0eiOdfoOP5yL4FZMNkeW9EFfR/XcyengNL48HcaVtwco3eYPj92noKySDbNqTqCqiaJyKR4/XGX3gl4aJbqUVMjo8fUlzr7hWafzrkgixeWLiwR8MlRlBPy3Z8OolCn4UkVr1qWwTNZeiuLcSk+gat86f3YesUhE+NcjlQ7AM4skuH93hahvRqls5Rj7uxevD3RgtJpqLkEQ6P39FX6Z6oqHCsPX7GIJfb6/yvV3B2ostq86GISBrhbfvlSzj8ncbb44mhoqPQajMosZ9/stTi3vp7Kta4tXHLt9Evn7DU+NKuCq/XI2z3FTKzpkFJYzfbMPE7pasGpYB7XrLiir5NXtfpgY6fP7jG61ElL+uBrNmotRQJU5bC+7VgxzNsGzfVtsWxuovF8m55WxeHcAhvra/Dmz+3NJj6yqQKxKpBrvas5HozuqbDF7kqj0Qn67FMUApzZM7aWZz1dtCU4u+Kcqo4hlg+yZ08e2TsKLQiFwKSyDXy5Hk1dayZIB9sxwt26QCuHs4gp2+ySy2zsB0+ZNWORpx1gX8zq3atWVD4+FcNg/RWnCpq62GC2xCLlCeFid00RHzKt97XjZzapWbWrPgvJKOTeisjgZlMbViCzs2jRlXFdzxrqYPdNk0oYmtaCcqxFZXA3P5HZsLubN9RnsZEKXFjIm9e8KNHreNPLfoVG8aeQ/waPije3yXbRvZ/2P4bApXSya/+tN2qCqleF0cBonA1PJKa1kTBczJrha4G7X6oVtv0Ih4BWTw16fRK5FZjG5hyWDHY0Z7GT8THuNK2RyTgamseVW3MOHvpe6Wagc/NWWmKwS1l+L4ez9dCZ0NWfZIId6iSwSqZzd3on8cS2GTuZGfDDK6ZkmTFQjCAIrdnvTw641r3oqj/XNK61kw/UYDvol8+lYZ6b0sFQ5sFEoBLbdjufni1G8PbyD2hSemrgWmcWbB4KY6GrOx2Oc6/xgnV5Yzqvb/TBrrs8fM7rXqt1q3ZVorkZksWtBL40MQ6tjnr+Z2BmjJtos2X3vYTWZnraY7a/2xMO+9jPmd2JzWLjTn5PL+qqd3SySSBny8w0+GdNRaRJUTFYJY9Z5cW6lZ62MMHfcjscrJoetc5WbBz/K6eA01l2J5tJbAzT+jEfxjc/jjf2B+Hw0ROVyK/YH0tHMkNcHKk9C+vt+OptuxHJyeT+gyrD1s5OhAHwzsTMzlVT3yOQK2n9yjlvvD1YpGr99KBiLlk14SwPB4Z3DwbRppqcywQqqxBb3dq1Ufq9HicgoYvKGO1x/ZyBtaxAoH6QWMmXjHa69M1BpZPu3Z8MITinkYA3R49UoFALTN/vQwaQZ30zUzPD2sH+VAe/pFf3UilFRmcVM2XCHj8d01CgBLb+0khlb7mLXxoDfpmsu4AiCQI+vL5P3SNtEEx0xFTIFrZrqMsjRmEFOxvS1b1NjxV1ZpYx3j4QQlFTAptk96mxGX1uS88p4/2gIpZVyTrzuofGkzNenQ2nRRIsVQ1Ufd/VFEAS8onP44VwE+WWVrBragUnd65YopVAIXArPZN2VaDKLKlgyoB0z3K0bxIC4vFLO0XspbL0VT1mljHkedrzSy0ojn6mGoMfXl8gtrTr29HXEtDTQpW0zPcxa6GPZ0gBjQz2MjfQwNtSnraEerZvqEpxSwJGAFC6HZeFq3YKpblaM7myKQR393xqKkgoZl8MyOR2chld0Do6mhozrasboLmYvrNK7LpRVyrgdk8vViEzO+YQS/NMMoFG8aeS/Q6N408h/gkfFmzvBkfRxUf/w/W8gq0jCqeA0TgalEZlZzGBHY6b0sKRf+zbP3b/mse0qlnDYP4UDfkmUVyqY1tOS6T2tsWql+Q08Oa8MixZNaiU85ZdWsscnkZ3eibQw0GFhPzsmdrNo0N8iKrOYP65GE5FRTHfrlrw+0KFeyVRyhcCJwFSO3kshv0zKB6Oc6N++zXOtkPrwSAC+CYVceWfwU68JgsCZkHS+OBWKu10rPhvnjKmSQV816YXlvHM4mKS8Mn6d5koPm9pV3SgUAr9fjWHTzSq/lpe61e2BKbekgg03Yjnkm8yYrmZ8PUG594syJFI5UrlCo7jRhJxSJm+4w5IB9g+jp+8l5TN7y13KpHK0xSIefDmi1tV7+aWVjPrNi2WDHZitpn0I4POTD4jNLmX3gl5Kj6PXdvvT1lBP44E3VO2XIWtv8MYQB433ybK997Bv25S3hisXBlWx43Y8N6Nz2DZPtVg0daM303tZMam78u06EZjKvrtJHFrSB6lcQZ/vr5BTUjVwammgg/eHQ5ReK9y+ucTmOW4qq40234zDLyGPv+aoT4g6GZTKZq84zqzwVLncicBUNlyP5cKq/mrXWc2yvfewa9OUd0bU/Jsv33ePtoZ6fD6uU42vl1TIGPLzdT4Y5aRyPyfnlTHqNy/Wz+xeY0R5TXx8/H7V4HOJh9rrsk9cLq9u9+PPmd0Z5KS+7S6vtJIZm32wN27Gb9NcNT7XN16P5ZfLUTX6johFVV43Eqmc9ibNGOZsylQ3y8eqCgRB4M/rsay/FsPaqV0Z2VkzH636olAIpOSXa3z/eZCcy5/X4/h4jDMWrZ5PVYRCIXA6JI2fL0ahqy3mw1FODHYyrtP9TRAEroRnse5qNKn55Szu345ZvW3qbFr/5HZeichi++14EnJKGd7JlPl9Gy51UhnJeWVAla9WbZ9TcksqOBGUxmH/ZMqlcjzs2zDVzRJXqxYvvOWnsEzKhbAMTgenIZUrkMoFxrqYMaaLWYO2fz9rkpKSsbGpEo8bxZtG/is0et408p+jNgLDi6BYIuX8gwxOBqXhE5dLT9tWzOptzcjOZi/Ug0ehELgTm8M+3yQuh2Xh3q4VH43qyFBnk1r7AQQk5jNtkzefjXVmjoet2uXjc0rZeiuOIwEpdLduyU9TXBjQoW2DVhxFZBTx+5UYLoVnMqWHJVvnumFVjwdgQRC4HpnNj+cjKKmQ8f5IJ8Z0MXuuVVK5JRX8fjWG69EFvDHo6ahkQRBYeSCI2zE5fDG+E2NdzNQ+FJ4NSeej4/cZ7mzCxlk9NBI9HqWwTMqbBwOJyynl6FIPOpppbvRcWiHDNyGPm1HZXI3IIjG36sHYtrUB373UpU4PtPo6Who9VGcXVzB3uy+Tuls8FG4Aulu35OTyfkz/y5sOJoa1Fm4EQeCj4/fpbGHELA0Mgu//Myt75g1Ppd/XPyGPhJzSWqc/3YzOplgiU9sWVE1OsYSLYRmcXNavVp/zKGHpRThrcAy0bKqjtpWyUq5AR7vqNzkRmEqx5H/GvOWVcvb4JCqtEOtj35q8UtWmlk5mhuy5m6h2WwH6OrRh1cEgcksqVFYEDnM24cNj9wlPL9L4XJjV24bXdvuzdKB9jQPbd4Z3YOSvXszqbVNji2czPW0+GePMttvxDOloorTizKqVAZ+M6ch7R4I5v9KTlk3VVzZ+Ns6Z6X/58MmJB/w0xUXlOdm7XWtWT3Fh+b577F/cW20lYqumuuxd6M6MzXdZdSiYX6Z21UjAmeJmyU8XImt8TSFAubTKNDcqs4SozBigKh2rGpFIxLJBDnSxaM6yffcISi7k3RGOzzR1D6qSgWojLpwJzqCzudFzE26gahsnuFowqrMZB/yS+ONaDH9ej+X9kU61bqUViUQMdTZhSEdjrkdm88vlKC7/44kz18O2Vu1jNW3nMGcThjmbEJxcwGavOIauvcGQjsYs9GxHDxv1LaJ1oT7Pm62b6bGgnx3z+9oSklLIQf9k5mz1xayFPlPdrBq82rg2NDfQYaqbFVPdrMgplnA+NJMzIWl8ezYcN9uWjHUxZ1Rn0xe2fZryf6HqvpFGaktj5U0j/wkerbz5N6rrlTIF1yOzuByeyYnAVByMDZnYzZxxXc2Vlr4/L3JKKjgSkMIB3yTMmuvjYtWCV3pa17mFKKNQwohfb1JYLsXESI87Hwyp8SFYEAQCEvP562YcWcUV2LY2YKFnuwYvWw9NK+T3KzFci8xiqpsVSwfa19os+UkCk/L54Z/EixWD2zOzt/Vz9VISBIGj91L55mwYI5xNeWt4B0yUzIZdjcjE1aql2mSjYomUL06FcSUik+9e6qLxAP9RwtIKeW1PAI4mhvw81VWtGCmVKwhOLsArOofL4ZmEpxehqy1+aG4NVb4Bl98eUC8fInWUVMiY/pc3Dm2bsXaqa40PfAVllUjlQq3Nig/6JbHmYhTnV3qqfdCVyRVMWH+bsS5mLFXSZiMIAlM2etPPoY1GfiKP8up2X7pYttCoLUgilTN4zXXSCiVEfj0SPSUCmFSuUCnurjwQyOjOpoxQUc0gCAKOn57n3EpPlft5j08il8Mz2Tq3J/3+Sbl7lGZ62tz9aEiNgsfcbb4MdTZRWfmUVSxhxf5Ats5xo5kGouXo37xYMtCe8UqiuauZtdkHiVzOkSV91a4Tqn6PiX/eYZyLmVIx6qPj9yksk7J+Znel65i99S7tTQyVVuhUL/fZyQeUVshZO81Vo+3LKJQw9ncv3hzaQa0RNVRVNG26GcuxpX01EitySip45S8fnM2NWDvVVSMRZeFOP66EZ6lMPdTVEuNq3YI9C9yVtnDGZJWweLc/1q2q2rf+LaEGUZlF/Hopis/GOGP6AltYSitkbPGKZ7NXHO52rXhvpJNKbyVVKBQKvGJy+e1yFHE5pSzsZ8ccD1uN2ls1ISW/jB23Ezjgl0wHk2Ys8mzH8E6mz1yUqw/llXLOPUjnoF8ygUkFDHaqMnv2bN/mXxGLnVkk4e/76ZwOTiMkpZA+9q2Z4GrBsI4mSoMAXiT/9rFBI43UhcbKm0YaeUYoFAL+ifmcCErl7/vpNNPTZoKrOWfe6EcHk7rFTjcUgiDgHZvLXt8kLoVm4mbbkreHOzK8k0m9RAiJVM6cbXcp/SeqtqBMyuXwTEZ0Mn24jFwhcDE0g7+84ojJLGGGuzVfjOuEecuGFbGCkwv4/WoMt2Kymd7TmhvvDqqzWW41cdklrLkYyfXIbBb0s2PzXLcGe9DUlIScUj4+cZ+YrBJ+nOzy2G8LUFBUTjMDHbS1qy7vgzWIkvVPyOOPqzHIFALnV/av0+90NCCFH89HVKWU9LdXOuNVLJFyyD+Fy2GZBCTlUz3aqvaVkUgfb31wtW7xTIWbSpmCpXsCaGmgy+opXZVud108FOKyS/jqdBgbZvXQaIZyt08iZZVyXu2r3Ij0Ylgmibml7Jzfq1bbEp9Tyu2YXH6c7KJ22QqZnPk7/Ej7RxxJzi9Xalb84bH7tDduxmsDnq78ksoVnLufwaqhqsWigjIplTIFpmrK8aVyBbpaYs49SK+xikYqV7DtdjwrBrd/6jVjQz21qVRtm+kRk1lCdFaJRmbO/Tu0ITipQK14owD8EwrYdD2W1wY+/Ts9iUgkYkn/dnx1Joy5HrY1imNvDG7PwDXXuJ9SSBfLpwVvkUjEF+M7M/Z3L17uYaU0ql0kErFicHuG/3qTv++nayTamjbXZ/2M7szb7kdHMyO1VQ0LPe1ILShn3nZfji71qDEp61HaNNNj36LevLLZh69Oh/LZuE5qB9xzPWy5GZ2jNHJc558ql23zeqr03nIwbsaJZX2rvLrW3+av2T1eeAKPpFLGzxfCsWnV9IUKNwBN9bRZObRqwuKPqzGM/+MWY13MWTWsfa19UcRiMQM6tKV/+zbcjsnltytR/HUzjgX92jGvr229hTPLlgZ8MtaZN4a256BvMl+fCePH8xHM72fH5O6WDdKu1dA00dViUndLJnW3JCGnlMMBybx/NBiLlgZ42LdmqpvVCzUSNjHS59W+drza146U/DLOhqRzMzKbj47dp3+HNox1MWeos0m9qqgaaaQR1bx4GbeRRv5jRGYU8+P5CDxXX+O13f6IRbBljhte7w3i3RFOL1S4ySut5K+bsQz++QbL9wdi0aIJ59/0ZN+i3ozral4v4UYQBFYdDCIxt+xh8kKFTMHvV6OBKhO5nXcSGLTmOl+fCWNMFzPufDiYD0d3bFDhJii5gAU7/PjxfAQ2rQ24+e4gvhjfqV7CTVaRhDUXIhn1mxctDXS5/s5A3h7u+FyFG6lcwZ/XYxj1mxft2jTj0lsDnhJuAH69HMovZ+5pvM6fL0Yye6svg5zasmt+r1r/ThUyOZ+cuM/XZ8P46eWuLB3ooLJUOTCpgK/PhOEdl0ulTEGlXPFQuHkSfW0xC/vV3ihZUxQKgZ8uRj5MbGrIpJJKmYLV5yOZ3sua/hr4iWQUSvj5YhRfT+istM1LJlew+nwEK4e0r/XD8S7vBEZ2NlXrV1ApU7Bwpz/+CflAVbVCXHaJ0uV94nKVtgPFZpegoyXCWk1rQUaRBEM9bbWDqUqZAh0tEWsuRNbob1IhU/DntVgKy6VPvWZspEe2mrhwkUiEo6khERnFKperpq99G/5+kI66Aua2/wh3qy9Esu5KtEbrHt7JFH0dLU4FpdX4umlzfeZ62LL6QoTSdTgYN2Oehx2fnXyAooY0nGqMjfT5ZmJnPj5+X22kejXu7Vrz/ihHfrkUpfY9IpGIT8c6496uFasOBiL5p41JFW0N9di30J2Q1ELePRL8WOpbTfS1b0NzJddjEdCyqS77FrlrdN4Y6euweY4bY7qYMenPO1wMzVD7nmdFaYWU7/4OI6OwgoMBqXxwNITMIs320bOkTTM9vhjfictvDUAhCAz5+QZfnwkjt0S1QFoTIpGIfu3bcOi1Pmyc3YM7sTn0+/Eqay9FUVCmutVRE4z0dVjUvx033hvE+yOdOOyfQp/vr/D9uXDSC9XHfL8obNs05d0RTtx+fwhvDG5PbFYpQ9feYNomb47dS6G8Uv159CyxbGnAawPsWTejGxdX9cfVqgUbb8TS4+tLvL43gL/vp2t0rjfSSCO1o1EabaSRBiC9sJxTQWn4xudxOzaHoR1N+HJ8J/p3aPvcoyufRBAE7sbnse9uEtGZxRg10eHNoe0Z2dm0QVt9NlyP5UpE1lMznxHpxXx64j6ngtOxatWEt4d3YHQXs1r76KgjIDGfdVei8UvIY3ZvGxZ6tqt1i8uTFEuk/HUzjq234hnYoW2d45LrS1ByAR8cDUEhCOxZ2EulgfCIjq359UIYJ/38sTBsSWVeJh4eHk8tF5ddwpsHg6iUKTi+zAMn09qLiumF5Szdcw+5QuD08n4a9f/379CWJQPase12gtJZ8mp0tcUMc1ZfOVRXvj8XzoXQTI4u8WjwmcJfLkeRnF/Krxq2onx9JowhHY1VxjAf8k9BIcD0Xuq9cx6lpELGEf8Udi5QXa0jlStYvNsf3/i8h4KaSARxOaU1Lp+cV0ZGoURp5UVYWpXPizrfgYwiCSYaiIZSuYK80krSCpQPXhWCwKYbsbw38vE0HmNDfSLS1YsyTqZGRGoo3vS0a0VeaSWx2SU4GCuvzkj8x9RULgj8fjWassoqjyxVfjFaYhGLPNux6WYsk7pb1Ljs0gH2eK6+xp3YHKUJaCsGOzB07Q2OBaYypYfyloGxLuZcCM3kw6P32TLXTSN/qbl9bAlMKmD5vkD2LnRXeU3XEov4fFwnZm65y5sHglg/s7vaahpjI302zerBK5t9ePdIMD9N6ar0PWKxiDkeNvxxNaZGYW+muzXGNaR3qdred0Y44mxuxKqDQSzu344Vgx0Qi5/v/fyAbwKCAIde8yCjuIIfz0cwe+tdZve2Yaa7zQv39LBqZcAv01xZ5NmOLV5xDFxznSUD7Hm1r22t06REIhEe9m3wsG+DT1wuO+8k0H/1Neb0sWVBPzu1FVvq0NESM6qLGSM7m+KXkM9mrzgGrL7O6C6mz6Rlu6HQ0RYzyKkqNS2npOKhCfrnJ0MZ52rONDcrXCybv1CTY9s2TVk+uD3LB7cnOrOY0yHprLkQybuHgxnRyZRRXUzp36Htc20vb6SR/yqN4k0jjdSRwnIp5+6ncyIoFf+E/H96f835dbprrU1enwUFZZUcCUhhv28SuaWVTOluycoh7bF/BuLDtYgs1l6Kelhx8ygyhcDViGw2zOpOn3atG/wBwy8hj3VXormXmM8cD1vWTu1abxO9CpmcvT5V5owOxs3Ys9Cd7hq0UTQ0JRUy1lyI5F5SPmO6mPHaAHu1YmCfjnas+zuMHy9kYlSSSSVwupuEzBIZcdmlxGWXsMcnkdTCcub3tePt4Y51SvO6E5PDiv2BDHM24YvxnWq1jvdHOpGcV87l8MwaB1pQJdzMdLd5ZuLn5ptxHLuXytGlHrQ1aljTxTuxOey4ncDJ5X3R11X/u1yLzOJmdDZX3lYex11WKeOXy1F8Ob5TrYXP08Fp2LVpSjerFkqXkcoVLNkdgHds7mP7pEKmICqzZjHDJy4XF8vmSitmwtKKlLbrPEpmoURtyxRAhVROWHqx0kqt6u3dciueBf3sHrsOGBvqkaWmbQrAydSQo/dS1C4HVWbYvexacTMqR6V4k1bwv9l9qVxg260EyivlfDG+k8rr4aTuFqy9FMm1yKwa2x9bGOiyZIA9q89Hcvz1mq+tTfW0+WysM5+ceMAwZxOVrShfT+jE8F9uctg/hak9rZQuV41IJOL7SV2Y9Ocdvv87gs/GOatcXl9Hiy1z3Ji84Q5fnwnj83HOau8Hxkb67P+nhUqdgDPNzYpfLkU99jddLTFfjnfmxwuRVMoVvDPcsVb3oNFdzGjXtim/XIri9b2BrJna9bm1hCTmlOAXX8BCT1v0dLWxaa3NnzN7cDMqm49P3Od4YCrfT3Kps+dMQ+JsbsTaaa54x+byw/kIdt5J4M2hHZjqZlknr5be7VrTu13rh/f3fj9eZY6HLQufOK/rgkgkopddK3rZtSI+p5Ttt+N5eaM3Xa2as6CvHYOdjNH6F/jL1ESbZnos9GzHgn52BCYXcNg/mZlb7uJu1woPhza81M1Crb/ds6a9iSFvDTNk1dD2hKYVcT0yiy9OhVEkkTKikynjuprjYd+6wSfwGmnk/xcaDYsb+U/wvEzJJFI51yOzOB6YyrWIbJzMDJngasG4rma1mtV7VghClc/OvrtJ/H0/na6WLZjhbs3IzqbPLHo8JquEsb97PeVV8ihaIhHX3x3YoElgfvG5rL0UzYPUQub1tWV+3/rPzCkUAqeC01hzMZJmetq8P9KJgY5tX8iM1qWwTD47+QDrVgZ8+1JnlYNDqNr38TmlfHMmjKS8Mgx0xSgqJUTkSJEJVZG5ulpiJP8MzCd1M2fttG613i5BENh0M47fLkfz+TjnWleBVFMpU/DKZm9CUgqRyp++DYlFcOPdQc8kPe5EYCqfnHjAvkXuahNwaktBWSUjf/Xi9UH2zOljq3Z5iVTOsF9u8Fp/e5Xmr79fieZKRBbHX/eo1fEoCAJD195gxeD2TOxmUeMyMrmC1/fe40ZUdo1imrOZEX+vfDoS++1DwZg21+PdEU5PvQbwyl8+THA1V3uM/Ho5iuS8cn6e2lXlcsv23ePc/XTUdNCgqy1mRi9rvhj/P6PegMQ8Xt97j7sfDVX53pCUAuZs8yXw02Ea/c6bb8bhHZerNApdoRBo/8m5p9p+dLXFTHS14IdJXVRWT6y/FkNMVgm/KKngKquU0X/1db59qXONbZRQdQzM2eZLuzZN+VJNQtm1yCze2BfI3ys9NT73EnJKGf/HLb6e2JkJrjUfY4+SlFvGpA23WTLAXqkh85NkFUl4ZbMPXa1aqBRw5m7z5WZUNgKgLRaxeY4bg5yMickqZu42PzzsW/PdpC61Hjjml1ayfP89sosr2DzH7bn4jvz4dxh62lq8OfzpyPjySjm/XYkmJKWA7tYtWT7Y4Znd42uLIAicf5DxMAHs3RGOjOxsWq/76JOVtYv6t6NNAyYdFZRVsvduEreic8gskjz0xWmigfhezd24XK5GZDGrt81zTT0trZBy7n4Gh/xTCEouYJizCS+7WeLZvu2/xpxZEASCkgs4E5LOmZA0KmUKRnUxY6yLGe52rZ/ZdjYaFjfyX6RRvGnkP8GzvEArFAI+8bmcDEwjPqeEzOIKJrhaMMHV/JkaqdaGwjIpxwJTuBSWyYPUQib3sGRGL+tnbrRYWC5l1K83ySiSqBxQ6WqJeaWXldqBgzqqjZZ/vRJNRqGEia7mLOjXrt4pB4IgcCMqm/XXYkgrkPDWsA5M7GbxQh58MgolfHEqFO+4XD4e3ZGX3SzVPvR+dzac7XfikcqFKpFGW0ylTKF0n1i2bMKNdwfV6fuVVMhYvMufD0Y51Vv4uB6ZxeLdAUjlCp68E/Vu14oDi/vUa/01cTMqm9d2B7Bxdg8GaOBFUxsEQWDZvntIpAq2ath68tOFCG7H5HJsqYfSQXxuSQWv7QngvRG1j+f1is5m1cEgbn8wuMaSdblCYPm+e1yNyFJaBdVMT5sHX4546u99f7jKD5O74Nn+6d9REARcv7rE7gW91B4nHx4LoVVTXaUiUDU9v72s1nQYqjxOtMQi7n405OEsfXJeGQPXXCfqm1Eqj/vySjmdPj/PnQ+GaOT/FJ5exOQNdwj6bHiNVWJZRRJ6fXelxvfqaYsZ3smEX6a6Kq1OKCirpO8PV9mtovpv391EvKJz+GOG8lak+JxSRv12kyNL+tDZooXK7/ThsfvEZZewf1FvjdtyrkZksmCHP9N6WvLFeOW+TdWEpBTwyl8+/DjFhbEuqg2fq9FEwLkWmcXiXf4AfDuxM1N7/k84zCySMHebL2bN9Vk/s3ut23pkcgXfn4vgSEAKf8zoVuNx31Bcvp/KqZB0PhztjJkKI+DQtEI+OHqf0goZ30/qgnu71s9sm2qLTK7gkH8Kv16OwqxFEz4Y6UgfJe19mhKUXMC6K9F4x+byal9b5vW1bdCJs0qZgtPBaWz2iiOzSMKs3jbM7mOj0WeEpRXx+9VoroRnMdCxLfP62j6TamNVxGWXcDgghaMBKWiJRUzpYcnLPaxqFUn/rKkO8zgdnMa5B+mIRTDe1YJRnU3pZtWyQVsBG8WbRv6LNIo3jfwnaOgLtCAIhKUXcTIojVNBaUjlCsa6mDHB1YJu1i1eaG/xo9t4LymfvXeTOBuSTmeL5szzsGWYs8lzmYGTKwSmbLxDUFKBynjWanS1xfh9PLROCRKCIHArJod1V6KJyixhQT875nrUP40CqlKpfjwfQVh6Ee8Od2RyD8sXMoOpUAjsvZvI6vORDOlozCdjnTWaWSyrrBJTbsXkavQ5Oloi/prjxiBH4/pucr04dz+dtw8Hs2KwA3/djKOgXPpQwNHTFvPHjO5K/W4UCqFOD3j3UwqrEmwmdGJS94Z/iDvkn8zq85Gcf9NTo30Xk1XMiv2BrHm5K53MlfstfHEqlJT8MrbMrbm6QxULdvjRydyIt2qYvZcrBFYeCORSmPL2tWqCPx/+2PmWnFfGoDXXCflieI2D4NSCcvqvvkbolyPUnk+vbvdlsJMxs9VUKo373YvSCjkOxs3QFovQ1hKTkl9GUbkU93ZVZfg6WiK0xGKa6GixwNPuYYuLRCrH/bsrXHqrv9qB2OA11/lsnDMDNThHBEGg57dX+GNGN3rXMHAOSMxnxmYfpb+vnraY/h3a8ufM7kqrQb45E0ZyfhmbZrvV+HqlTPFPdZUDL7spb3fadCOWi6EZHF6iXCiEqjjotw8F0dO2FQs0rIwB6PTZeUor5TTT0+b1gfbM6mOj0tT9akQmy/YGsnN+L41FyWoBp3e71nw1ofNTAo5cITDwp2tM6WHJyhpSzgrLpby2259yqYJtc93q1IJzNCCFT08+YNXQDiz0tGvw54Ezwcmcv5/B2K4WjOyiXtiSyRXsuJPA2ktRTOxmwQejnGptpu8dm4tcIaj03Kor5ZVytt2Oxzs2B20tMe+NcNKonVIV91MKORyQzCH/ZKb3tGbpQHtMNGi91BRBELgTm8tmrzjuxOYyoas5Cz3badSillpQzh6fRPb7JmFiWGUsPrGbea3Fwvogkyu4EZXNQb9krkVmMa6rOf3bt32mVdh1QSZXcDc+l9PB6Zx7kEFTXS3GdjVnnIs5nS2M6n1uNYo3jfwXaRRvGvlP0FAX6OT8Uk4FpXMiMJXUgnKGO5swoZsF/Rza/Gv6cwvLpZwITGXf3STSCsuZ3N2SV3pZP9e+9+S8MmZtufvQiFMTdLREvD3MkSUaROVWU10Rs+5KNHE5pSzybMecPjYN4imUkFPKTxcjuRqeVRVvPcC+QcSguhCZUcyHx0LILqng24ldNEongiq/n3cOB2NsqEcTHS184vJU+oGIgK5WLWrdetPQbLsVz88XI1n3SjeGdDQhPL2Il9bfftjS1dJAB7+Ph9ZYjVBeKWfxbn/m9LGtlZlxYm4pkzfcYZFnuxpjretLfE4pY9d5sX5md40H/dP/8qGzRXM+HavcKyQxt5Thv9zk9Ip+dKhlJV1ibinD1t7E6/1BNQ5sPjp+nwO+SRq1IR1c3Pux+OxD/skc9Evm6NKnzbABLodlsPpCJBdXKffxqWbUrzd5a3gHhjnX3PZTzftHQjBprs9bw/43KN/jk8jViCylbUuP4vLFBfYv7q1SKAN4Y38grlYtmN9PeWT7o6w6GIR5C/0aK4dOBafxwdEQylQkw+hpi+ll14rNc9xqHFilF5Yz4KfrnFvpqbTa82RQKqvPR3L1nQFKTUHLK+UMXXuDlUPaq/W08Y3PY+42X06v6Ku2ZbOaL0+Fsv1OAlCVFAdVEd6qzOP33U1i2614NszuTnsNPyerSMLKA0GYtdCvsQJHrhBUVldVyOS8dSiYsLQidr7aq05VCSEpBby2O4De7Vrz/aQuDTYg9o/PZtPNOOa629HPqXYCe1JuGR+fuE9kRjFfTejMyM6qz6dHOR6YwmcnQunv2JZPxnTErHnDJUBWk19ayfprMey5m8iozma8NaxDvduLQtMK+f1KDNcis5jW04olA+wxb9Gw2x6dWczWW/EcD0xlZGdTJne3xLN9G7X3UIlUzsmgVHbcSSQ1v4wF/eyY1N3yubZUQdX5cjIojQN+SWT/Uzk+1c2qQcSRhqRSpuB2TA6ng9O4GJZJ62a6jHMxZ2xXMxxNDOu0rY3iTSP/Rf4do9FGGnmB5JdWstsnkSkb7rDqQDD+CXksH+yA/ydD+XV6NwY5Gr9w4UYQBAKT8vns5APcv7vMyaBUFnra4fvRUL4Y3+m5CTdByQUs23ePIT/fwKiJNsOcTVg60J65fWyY1M2C4c4m9HVojatVCxxNDLFuZUBbQz2MmmgjFokITC7Q6HMEQeBaRCYv/XmbVQeDGOpswq33B7NskEO9hZvs4go+PfGAEb/exEhfm2vvDOS9kU4vRLiRSOWsPh/BxPW3GejYlotvDtBIuJFI5Xx7Now5W32Z3duGA4v78Psr3Wmmr3pmryrxRb1J6LNCoRD45kwY66/FsHdRb4Z0rBJfOpoZsXVez6pqCrGIuX1saxRuyiplzN/hR4VUQR97zdsDcksqmLvNl7l9bFncv+Gjx6VyBWsuRPCym5VGwg3AsXupJOaWsWrY09UBj/LThUgmuJrXWrgB2OWdyPBOJkpnpDsYN8PESB8tsUilMbS2WET8E4lTkRnFDFchnoWmFWvcVpdRJMHUSP2Aq1KuQO+J7dQWi2o0Sq8JYyN9jUyL7ds2IySlQKN1Ani2b4NXVE6Nr6Xml6vdvgqZAq/oHNZfi6nxdbPmTRjnYs7mm3FK1zHOxRxDfW32+iQpXaaJrhafj3Pmh/MRaiOYe9m1YnYfG946FIxUhSD8KN1tWqKvU7V/JDIFEllVRUif76/wwdEQkmsQ+2e4WzOmqxmvbvfTOKbc2Eif36a7EpxcUGOMuLp2UD1tLX6f3o3BTsa8fTiIB6mFGn3uo7hYtuDk8r4k55Xx/pGQx0yp68Ol8CxcrFrUWrgBsG5twK75vXh/pBMfHAvhjX33yNIwVvylbpZceXsAulpihv58g003YtWmAdaWlk11+WSsM5ffGoBYJGLo2ht8eTq0TvHi1XQyb87G2T04ubwvuaWVDFpznY+P3yclX/OJJXW0NzHkh8ku3P5gMC4WzXnzYBCjfvPisH8yFTLloqy+jhbTelrz9xv92DzHjYIyKUN+vsHiXf7cic3hec2dGxvps6h/Oy6/NYDtr/aiUqZg+l/ejF53ix234xskjr0h0P0nVWvtNFf8PxnKh6M6Ep9bysT1t5m91ZffLkcTm13yojezkUZeOI2VN438J6itul5eKedyeCYng1K5EZVNF4vmTOxmwZguZvVOMmhIiiRSTgamsvduEqn55SzoZ8eIzqZ0NKtfyXFtkCsEbkZl8+f1GELTipjqZsWCfnbPZPZIEASuhGex7mo0qfnlrBzansndLZWm2dSGYomUA77J/HI5Cs/2bXh3hNMLif2u5nZMDh8dv0+LJjp8N6mL2mqAaoKS83n7UDDN9HX4+eWuj32HO7E5zNnqW+NgUVsson+HthpVKDwLJFI5bx8OJjS1kJ3ze9Vo+Hk0IIUPj9/n5ruDnvIbKamQMX+7H1piEVvnuWlcgl5WKeOVv3ywamXAuundnkm07k8XIrgclsmJZf00MrgsKKtk8M83+O6lzozsbKZ0ueDkAqb/5cPVdwbUeia8tEJG7++vsOPVniqj5QVBIDqrhL9D0jkelEpSbhkiEY9V42iJRSwZ0O5hZYkgCPT78Ro/TnZR2mbx2m5/eti0ZHF/1VVOEqkcp0/P4/vxELXtTMv23cPVsgWLHhHgDvsncyIolb0Le6t8L8CMzT5M7FY166yKC6EZ/HIpivNv9le7Tqia2R73+y3Ov9n/KdP0D46GcMAvucb36WmLkcoVtDc2ZHovKyZ1s1Tq3xWVWczY329x671BGCsR465GZPLO4RBuvjdIaSKSIAjM3+GHeYsmfPtSF5XfSyKVM/6PW4zpYs7Koe1VLgtVlV6D1lyvsZJLR0uEQoARziasHNrhsQkHQRB482AQcdmlHHytt8bntqYmxsoQBIG/bsbxx9UYNs7uQV+H2rcMVcoUfHHqARfDstg4qztutrXzpHqU3BIJq89F8O4IR9poIGaqIqekgo03Yjnol8zHozsyraeVxqL93bhcPjsZilwQ+Gp8Jzzq8LtoQkRGEavPR+Ibn8fi/u1Y0M+Wpnr1m0SJyizmj6sxnA/NYJGnHdPcrBvc70UilXPsXipbbsVRLJExz8OWme7WtDBQH5hQ3VK1924irQx0Wdzfnpe6WdTKGLkhKK2QcfZ+Oof8kglJLWRWb2sGORrT177NC4+ff5LSCilXwrM4E5LO9ahsHNo2Y2xXM8a5mKt9Dm2svGnkv0ijeNPIfwJNLtAyuQKf+DyO3UvhwoMMTJvrM9HVggmuFv8qMzdBEAhOKWTf3UROB6fjaGrIjF7WjO1q9lx7pssqZRwNSGHrrXj0dbQY39Wcme429TYHrglBELgUlsm6q1VGxK/1t2dmb+sG+b6VMgX77iby+9UYXK1a8PogB3rYPP/Y72pySyr49mw4F8MyeWd4B2b3sdVo0FEhk7PuSjR3YnMZ2tGE1/q3q7E65eszYezxSXzKY0NLLOLiqv4vxGS7oKySxbsCqJRXGfmqEkglUvlTLQjFEinztvvRREeLzXPcNH7QlcoVLN7lj0SqYMf8nkrbSeqDT1wur27348SyvhpXwH14LISMQgnb5vVUOqASBIEZm+/iat2C90eqNvKtid0+iRz0S+L08n4aD9oEQWDwmuu42bYiMLmAuOwSdLXFSKQKhjgZs/Uf4S8pt4wha68T/HnNfjcA/X68yo+TXdQOiJNyyxj8c5WRsLpBw6Jd/vS1b828vv9rZzoemMIB32QOvqbe3PrNA4G0NzFk2SAHlcsl5pYydO0Nwr4aqXHV5chfb7J8sMNT5rtTN3njG5/38P9ri0XIFQKG+trM72vHxG4W2LbRLLlowQ4/OpgaKj0eBEFg6iZv+jq04c0a/F6qScwtZcSvNzn0Wh+11VEPUguZsvEOh1/zoIulaoFZEAQ6fX5BZYuYtliEQJUh+Y+TXbD8x4y3QiZn7jZfmupqs2l2D43jpesr4AAcu5fCx8cf8OMUF8Z31cw8+VEEQWC3TyLf/x1RrwQ+qLuflzKuhGfyyYkH2LZuyveTumh8rEnlCnbeSeDXy9EMcjLm49EdNTLwrgt343L59XIUWcUVzOtrx/SeVvWudo7JKmHnnQQO+iczvqs5ywY5YKfhd9cUhULgWmQWm73iCE4u5GU3S+b3tcW2jfp77OJd/lyNyMKqVRPySqVM72nFTHdrrJ9DitmTxGaXcDQghUP+Kehpi6tMjt0sH56b/yaKJFIuhWZyJiSNWzE5OJs3Z5yLGWNczGqc4GgUbxr5L/L8RoKNNPICEASB+6mFnAhM43RIGp3MjbBv24yDr/Whk/m/q9+3WCLldHA6e3wSScorY2I3c44s7aNxRUZDkVUkYad3AnvvJmHevAkrh7ZnTBdzlW0Vj7LzTjxDOppodONXKAQuhmWy7ko02SUVvNa/HTPdbRpkFkqhEDgdUhX73URHi9VTXBjsZPzC9rkgCBy9l8q3Z8Nws23FxVX9Ne7Nf5BayDuHg9ESi/h5alecTJVXXr030pFrEVkk5JY+nAHX1RIxwdXihQg3qQXlrDoQiEWLJnw3yUXtvn1SuCkslzJnmy8tmuiwaXYPjb0lBEHg4+P3SS+UcGhJn2ci3BSWSXnrYBDvj3TUWLgJSMzjRGAaF1f1V3ksXo/KJjyjiI2ze9R6uwRB4HJYJvM8amemGpxSSE5pJd++1AVd7Soz4PMPMjh2LxXtRwaUPnG5dLVsoVS4KSyXkpJfrlGFYEaRBGNDPY0GrFK5At0n9qOWWPxU24wyjI30NWojsWppgI6WmLjsUo33a3Xr1JPiTWp+OSKqWgL0tMVM7GZBq6a6nH+QwZtqWuaeZMlAe+bv8OP1gfY1to+KRCLeG+nEq9v9mN3bRqlIatO6Ka/1t+fTEw849npflYJHZ4vmvD7QgbcOBXF6RT+V559IJKKjmREBiflKl5EpBERUeepkFEoe3if0tLXYNMuNCX/cYtgvN9i7wB1zDe4hxkb67F/Um1c2+/DukeA6CTiTulvSqqkuy/cFkl1cwQINvY6qEYlEzOlji4NxM5btvUd4ehGfjHWukwDR0FUPQzqa0MuuFT9diGTUb168ObQ9C/rZqRXHdLTELPRsx/iu5vx5PZaha2/w5tD2zPWwbfA2cvd2rdm3qDcXQjNZfSGCrV5xvDvCidFd6h4v7mDcjK8ndmZ+Pzv+vBbDiF9vMraLGcsGOzTYfVAsFjGkowlDOprwILWQzV5xfHT8AUb6Oizqb6e04jG1oJwr4VkoEJBIFayd2pUjASm8f/Q+hvrazz2lyr5tM94b6cSqYR24FpHFIf9k/lwTg7tda6b2tGL4cwrB0AQjfR0m97Bkcg9L8ksruRCawemQNI4HptJUV5txXc0Y1cWsQWPkG2nk30Zj5U0j/wmeVNflTVpyIjCNk0GpZBVXMLKzKRNdLehj3/qFxD+rIiSlgH13kzgVnMZwZxN6t2vNuK7mDdIqVBvC04vY4hXP6ZA0+jm0YaGnXa0fIA77J/PukRBGdTZlwyzlg06FQuBCaAZHA1IISS1kyQB7ZrhbN9gDgld0Nj+ciyCvtJK3hnVgUnfLF7rf43NK2XgjluuRWXw5XnMjSalcwfprMWy8Ectr/e1ZPthBowfnqMxixqzzQiqvurzraIm4/f5gpe0Wz4qwtCLmbfdlmLMJX47vpPFsejUFZZXM3upLW0M9/pzZvVbHx9qLkRy9l8qx1z0aNIWkGkEQWL4/kLIKmcoKmkeRyhWM+/0W4/6ZCVaGTK5g7O+3mNLDkoW1SPup5lZ0Div238P7gyHo10II/f7vcLKLK1g7zVXlcm8dDMKiZRPeriHBCqrEnVUHg/D+cIjazzwVnMb22/Ecf72v2mVnbPbhpW4WjyUqnQ1JZ7NXHCeWqX//Fq84AhLzVV6bqnnpz9vM87BlgquF2mWhKoL+g6Mh3P5g8GPHwozNPrRuqsvLblZ42LdGW0tMsURKz28vc3JZv1r5lQmCwIr9gbjbtVKZzLVghx/t2jbl4zHKjbAlUjnDfrnB0gEOzHBXXSkikyuYvOEOvexaqVwnwOrzEfx1M06pz4+ulogWBrrseLVXjYlDl8IyWLQrAICBHdqywNNOo1aO6gocN9tWfPdSlzpd74OTC5i/w48pPSx5f6RTnYSU5LwyFu3yp6WBLn/O7P5UG92LxD8hj/ePhmCgq80PkzVv1YWqNKrPTj5AJIKvJnSuMVmtIZDJFRwOSOGXS1GYNdfn/VFOeNQzXhyqKvw23Ijh6L1URnYyZflgB419xL7/O5wRnU3pbq2+YjetoJwddxLYfzcJB5NmLPZsx/BOpo8dj1+eDmWvTyKVcgEdLTHdrVuwb1FvMook7PZO5IBfVUrVvL62THR9/i1VUHU+Hb2XyiH/ZPJKK3nVw5ZhnUye+2SipmQXV3DuQTpngtO5l5RP73atGetiRpeWMjp3qGrdbay8aeS/QqN408h/gkfFm+FfHyO+XJ8Bjm2Z6GrBkI7G/5pZg2pKKmScDEplv28S8dmlTOhmwYxe1nS2eL43xuo0p8P+KVwJz+Sl7pYs6GdXJy+YyIxixv5eJRgoa9FRKATOPcjg96vR5JdV8uaQDrzU3aLB9k9ISgE/novgQVoRywbZM6eP7Qvd95UyBX/djGX9tVimulny9vAOGDXR7GE+MqOYtw8HIZUJ/Dy1a62PjW234vnxfAQCsKCvHe+Pqn3rTX24FZ3D0j0BLBloz+sD7Ws9i5hfWsmr231xtmjO5+Oca1U5Ux25fnRpH42TcmrLYf9kfjwfwfk3+2s8y7frTgLXIrPYNNtNZSXbEf9kzt5PZ+PsHnWqGFq40x8nU0PeGVGzuFITgiAw4KfrfDKmI8M7KRcXBUHA44errHm5q9KWqG234rkdk/OwzUoVm2/GcS9JM0Hl5Y13mNXb5jFB5fyDDNZfi+H0in5q338yKJVd3olKE7Ie5cNjITRvossHGp43Eqkcly8vqkyEepTl++5h1cqg1i1xF0Mz+PTkA26+N0jpsRGZXsyMrT6cWt4PCxXVfVfCM6taY6Z3o5UakSEmq4QvToWyfLCDyoH7hdAM3jwQRLn06dYpPW0x3axbsnFWd6X+IE+2XulqiWnZVIf5fe2Y6malUgzJKpbw/pEQWhro8tPLdWuhis8pZc62u/S2a/2wAq22lFbIeOtQEGHpRWyZ44ajikrJ541EKq9KfPJJZE4fG5YOdND4HimVK9h+O57fLkczzNmEj0Z3fGYTAtXx4htvxNLNuiXvj3RsEOEgJb+MjTdiOeSXzOQelszpY6uyQjAwKZ9Jf96huYEOV94aoLEnYrFEykG/ZLbfTkBLLGJ+X1tedrNCLgj0/ObyY23NetpiZrpb89m4TsD/Uqq2304gvVDC9J5WzOpt89xTqqDqfPRLyOdkUCrH7qXSrm1TpvW0YkJXi2fSQt8QpBeWczYkndMh6YRExJLwx1ygUbxp5L9DY9pUI/85xnY1x/fjIWye48YYF7N/lXBzP6WAD4/dx/3by+z3TWJGLxvufjyU717q8lyFG4lUziG/ZEb8epN3DgfTwcSQW+8P4vtJXeok3JRWVKUAyf6p9BABv1yKevi6QiFwJiSNkb/d5JuzYcxwt+bGu4N4pYGqbRJySlm+7x5TN3nj4dCam+8OYnF/+xe67wMS8xj7uxdnQtLZu8idLyd01ki4kckVbPGKY8L6W/Rv35ZTK/rW6diY52GLq1ULdLXELB30P9NYhUJg4/VoXttxF4lEsySS2nI8MIVFu/z5ckInlg1yqLVwk1dayYwtdzFt3oQvx3eqlYBx4UE6Z4LT2DrX7ZkJNwk5pXx5OoyfXu6qsXCTVlDOj+cjeG2AvcoBoUQq55fL0UxwtaiTcJOUW8bNqGxm9q6d70ZYehG5JRVq086S8srIKalQOQsdll5UY1VFTWQUSTT20qiUKdDVqnvaVFtDPY0TjZxMjYjMKNJoWahq9+tl2wqvqGyNln+pmwUnA1NRaLjt1QztaEIzPW1OBqUpXcbRzBBPhzb8+sg1uCaGdDRBV1uL1ecj1H6ug3EzBjsZ887hYEoqZEqX62rZAkkNwg3AWBcz9i50V2nsKhKJGPxI0lKlXEFmUQW/XIqi57eXWb7vHgGJ+TUm9Rgb6vPjZBeCUgp470iIxu10j2LXpilHl3pQVilj4S5/SlV8V2U01dNmw8wezHS3Yeomb66EZ9Z6Hc8KfR0t3h7uyP7Fvbkemc3o37we82RShY6WmMX97bn89gBkCoEhP99g2614ZBqmkdWGJrpaLBvkwM13B+Fo0oyvz4Tx5oHAGhPLaoNlSwO+mdiFG/+Iny/9eZvFu/yVJo6tvhCJSFT1jLN07z2NjylDfR0WerbjxrsDeWeEI0fvpeLxw1VW7r/31LIVMgW7fRI5di8F+F9K1bmVnmya3YOkvDKG/HyDL06F4h2b+9xSqqDqfOxl14pvX+qC78dDmN3bhuOBqfT87jJv7A/kdkxOra9hzxqz5k1Y6NmOk8v6cmCxei+0Rhr5v0ajeNPIf46Xullo5Pr/vCitkLHfN4nxf9zi27PhgMCBxX04s8KTGe7WSlNBngV5pZWsuxJNvx+vstkrjgX97Lj1/mBWDm1PGzVJL8oQBIF3DgeTXVJB9S1c9k+FTWx2CaeC0xjx602+OxvO7D62XH93YINVxOSUVPDZyarY76a6VbHfywa1f6EzQoXlUj4+fp9ZW3yZ2M2C0yv6aVRuDVXGgVM2enMnNpf9i3rz3kinOnu1iMUi/prjxtGlHhj944+RV1rJsn33OBWcTkJWDpsv3q3TupUhCAJ/Xo/hsxOh/DWnB5O6136WK7ekghmbfbBrY8DvM7rVyl8hIDGfVYeCmdfXrl6pL6qQyhX8fDGSKT0sGaRhLDhUlcqP7Gymtt1gt3cizZvo1Mk4FWC3TwLDOpnUOp3q3P0MBjmpr1L0iculm1VLlaX8oWlFONciEa+dhkai2jVEmmtridDV1kwcNDXSx7KFgUaDH0dTQyIyijVabzWe7dvgFV1zZPiT9O/QlnKpHL8EzQbO1YjFIl7rb8+mG7EqB01vDXPkVHAa0Zmqv8Pn45w5GZTGvSTlPjXVzPOwxaqlAd+cCVO6jImRHob6/7uniUWgryNmlrs1t2NyydcglnigozFNnjgOJTJF1X3lfjrTNnkzaM119vgkPCUkGRvpc2BRbwKT8vngaEidBpbGhvr8MNkFmVzBjM0+dYqyFotFLBlgz7cvdWHF/kA234x7roNudTiZGnHs9b7McLdm3nZfPj5+n2KJVKP3mjVvwh8zurNhVg/23E1k5YFA/Gt5HGtKy6a6fDzGmTUvd0VbS8zQtTf46nQYeaX1i7c2a96EL8Z34ua7g7BqZcDLG71ZsMOPoOSCh8sEJxfgF5+HQgCpXCA4uYB1V6Jr9TnaWmLGdzXn1PK+rJ/ZjdsxeU+FCUDV+t8/GkLwI58vEono3a41G2b14Oo7A2hhoMPSvQGM+s2L/b5JlKswBn8WGOrrML2XNcdf78uZFf0wMdLjjf2B9P/pGttuxZNaUP5ct0cTLFrWL7WtkUb+jTSKN4008owITSvk4+P3cf/uCru9E5nqZsXmuW58P8lFbWpHQxObXcxHx+/j8cMVfOPz+Onlrlx4sz/Teta/8mWvTxJXwrOofPKBRBCYveUuP56LYF5fW669O5DZvW0axDi2pELGr5ejGLD6GumFEs6s6MePU1xqPWBtSARB4O/76Qxde4OkvDLOv+nJ6wM186hRKAS2eMUxdt0t3Gxa8ufM7nTTUPBRRfMmOg89NQIS8xmzzou2hnoceK0Pr3k6ciWihHWnLtf7c6AqUv7bs+HsuJ3Agdd649ledQVHTeSUVDBj813sjZvx2/TaCTcxWSUs2OnHh6M7MkJF2099+e1yNFGZxbw/UvOWpCvhmfjE5fHRaNUtMoVlUv64FsMHo+rmtxGWVsi2W/HM7WNTq/cJgsDfD9IZpSK2vJrY7BIGOinft5UyBc2baGtceROcXIBRE83E1oJy6VPHhJZYRLFEs+qINoZ6eMflUqTB8o6mhhgb6lFQi0GiZ/u2eMflPn0trAEdLTFjXMw4oaKCRhkTuplTUiHjsoqKDuvWBkzracWai5Eq12XVyoDXB1aZF6urKhCLRfz0sgtnQ9K5GlHzZ4tEIrr8Uymoqy3GqpUB51b25+uJnelp14oV+wLVVmp42LdWWr0jF6omBxJyy/j6TDhu31wi4okKKWMjffYv7o1/Yj4fHrtfJwHHUF+H7a/2xLKVAVM2ete54mOsizn7F/XmUngG35wNRxAE5HIFRwKS2HQjhsxCzQa8giAo/U3qipZYxELPdpxb6Ul8TinDf7lZqyqhfu3bcO4NTzpbNGfONl/ePhRMTh2ELk2wbGnAmpe7cnJ5XxJySxmw+hp/XI2mrLL2lVGPYmykz6djnbn53iAcjJsxY7MPc7f5EpCYz08XIlE8IrhVyKo86G7HaCbQPopIJCK3pBJVRahSucDc7b41mqpbtjTgzaEd8P5gCPM8bNl5J4He31/h+3PhpOTX7tj842o0JwNTa/sVHqODiSEfj3HG+8MhfDLGmeCUAgb+dI0523w5G5JOhez5CkuNNPL/E43iTSONNCBllTIO+SUzYf1tpmzwRipXsGehO2ff6Mes3jY1JoQ8KwRBwDs2lwU7/Bj12y10tUQcW9qXPQvdGeRo3CCpFg9SC/nyTCiVNTyMy4Wqloid83sx071hRJtKmYIDvkkM/Okat6Jz2Dm/F5vnuNFeQ+PBZ0VqQTkLd/pzwDeJj0d3ZNf8XthoGPmZmFvK9L982O2TyM75vfhkrHODtnsJgsC2W/HM2nKXRZ7t+HJ8J4z0dZjUx4HRroZcD69g84WnS7lrg0QqZ+meAKIySzj2ukedvAmyiyt45S8fOpga8ts011oJN1lFEuZu82WmuzWze9dOuKgNPnG5bL0Vz7pXutNEwxj78ko5n50M5YNRTir9EgRBYPFuf9obN1PbulQT91MKmbD+NnKBh4NnTYnOKiE1v5yBjqo/VxAETgWl46oiXjo6q5jQ1CKsNIyZzSiSaGwoXSlXPFV5o/VP9LYmGOppo68jJluD1qmWBrpkFVcQqaZy5VGcTA1xb9eKIA2qWKCqSvRsSFqtBzp62lq4WLRgyZ4AYrKUb9/ywQ54RecQqGZ7Fg9oR2mFjD0+iWo/27KlAZ+Nc+b9o/fJVyJs9bKrqnob5NiWcys9sWvTFJFIxA+TupBTUsFPagQl8xZNMDbSrB2xm1VLrGvwAjH5J4XqbnwuH5+om4Cjp63F79O7MaBDWyZtuENYmuZtdI/S1aoFP7/syoPUAqIyill/LZobkVkk5JQy9JebHL+XorYq5+z9dMas86rzNqjCpnVT9i50Z9XQDqw6GMSK/YHkaNheqKejxdKBDlx6awBllTIGr7nOLu+EOrWsaYKTqRHb5vVk81w3LodnMeCn6+y9m4i0nq1bbQ31+HB0R7zeG0QncyPePRxU1RL0xNeQKQSW7AnQKLXuUQRBYN2V6Bqrbh6lRCJj3nY/pdeEJrpaTO/1v5aqxJwyBq+5wZLdAfjGq2+pyiut5NfL0bx9OBjv2NxafYea0NUWM7KzKb9N74bXe4Nxt2vF6gsR9P7uCl+eDn1KWG2kkUbqT6N400gjDUBERhGfnXzAnK132XY7nindLbj78RBWT+mKq1WL5xpPLZUrOBGYyrg/brFkTwCOpoZ4vTeIL8Z31ng2XBMKy6Us2OGn0m9CSyRiw/WYen+WQiFwOjiNYb/c4FJYJt9PcuHwkj7PrDVGU6r9aYavvUGrprr8Nr0bE7tZaLS/FQqBXd4JjPrNCyczQ86t9Hw46GkoiiRSlu27x5WITPYsdGd+v8ejoxcP78+EntbcjisgMqX2s4lQZSw8Y7NPVUveK64aRcQ/SXVSjLO5Eb9M7VqrVKpiiZS52/3o3a417yhJP2oICsukrDoYxIejnWqVELTuajQmRnpMeyQh6UlySyqYvOEOd+Pz6G5T+4qr8w8ymLzhzsN0seJa+nRcCc/klZ5WahPuEnLLyCutVLmNYWlFdDQz0kgcVigEMoskmGoq3sieFm+0xeKHXlvqEIlEGBvqk1WkWXVAbVunxGIRLZroclPD1qnu1i1p3kSHm1G1P/fcbFuiEGDkr15cDqu5WsLYUJ/5fe1YfT5S5aBOT1uLLyd0Zs3FSLKL1f82U3pY0tWyBZ+ceFDjel92s+LXaa5snNXjsTj5pnrabJzdg30+SZx/kK7yMwY6GqPqENLVEjOuqzm7F/RSGllv2ryqAufOP0lJdRFwxGIRn49zZp6HLdP+8q7zgNfESJ/RXcyIyCwkLquYlUM68P3krqyd6srJ4DTePhyssopkVGczxnU1Z/KGO+y8k9DgLVgikYipPa24/NYABEFg1lZfjgeqF5WqsWjRhA2zerDulW5suxXP+D9uadSKV1d6t2vN8dc9+Gp8J7bcjGPxLn/O3U+v9+/Supke7410wlRFFW95pZzFuwNq5fXjHZdLkgbVWzKFQHhGEcv3Bar8LtUtVRtnV7VU2bZpyldnwhj1mxcH/ZKUVmntu5uI1j8+YQt2+hGfU6rxd1CHaXN9lg1y4Po7A9kwqweF5VImrr/NhD9ucTQghSIN2/IaaaQR1TSKN400UkfKK+Uc9k/mpT9vM3H9bcoq5Xw8xplzKz2Z3cf2oc/I86KwTMrGG7F4/niNXy9HMc3NCu8PB/PeSKcGj0oWBIE3DwSSXyZF1bOSVCFwIiitXiaDt2NymLD+Nt+eDWfZQAc2ze7BMGeT5yqI1cSD1EIm/nmbvXeT2DzXjZ9e7qpxLGxKfhnL999j0404Ns9x46sJnZUOQOpKWFoR43+/RUmFnN9f6U4PJQPuuYO7YNdGn83Xo5BKa/dwlZxXxuSNd2hrqMceNUakysgqlvDa7gD62rdm7VTXWgk3lTIFS/YE0NZQjx8md3lmx4QgCHx4PARnM6NaVfZEZxaz/XY830zsolTMuBaRxaA117mXVABUtYzUZrv+vBbD8n33Hla/aYlEFJXXTrw5GZSGqwZtej5xubhat1BZGRaaprlZcV5ZJVK5oLFhsVQuPGVYrCWmVrP8xoZ6ZGkgUEDVLH/dfG80My0WiUS87Gb10Ki0NjTR1UIk+l8lwM8XI2sUJxYPaEd4RhG31LR6DOjQln4Obfj+XLhG2/39pC54x+VyKvjpti/zFk2Uitj2bZvx08suvHs4hNjsEpXbo6xaU1ssYsUQB36a4qL2emHWvAn7F/UmvVDC56dC6zS4F4lELBvkwKdjnFmw00+pWKYKXW0xozubci08i5FdzHEwqTpHhjmb8ONkF1Lyypm4/jYxWTX/JlpiEW8O7cDO+b3YeCOWRbsClFY+1QdjI33+mNGdN4e257u/I3h1h1+tvEwGOhpz/s3+jOxkyszNd/n81IN6+9MoQyQSMaqLGRdXDWCoswmfnQpl0oY7GhswKyMsrYi78XkoO1JkCoHw9CK1LYmP8sfVmIfiek2IqPLv0hKLEAS4FJbJ+D9uafTsZNnSgA9GOXH4NQ/mediy/XZVS9UP5yIe23dSuYKtt+IfVv9IpHJmbPahQAMfqtpQLSytneqK78dDmdrTir8fpNPr28u8dTAIn7jna7rcSCP/NRrFm0YaqSWRGcV8cSqUXt9dZrNXHBO6mnP3o6Gsebkr3axbPndRISm3jC9OhTJ5422uhmfx1YROXHl7ILP72Da4IFDN+msx3IjKrrFd6knEoqrqg9ryILWQ2VvvsnRPAGNczLj+7kCm9rSq1eD+WVBaIeObM2FM2XiHwY7GnFvpiYd9zZHJTyIIAgd8kxj5qxfWrQw4/6an0rjl+nDIL5kpG+8wqbslO+b1VBsDvGhwZ4pLK/jykJ/GAk5oWiGTNtyhn0Mb/pzZo06tXllFEl75ywe7tk35bFynWkX7KhQC3/0dTlG5jA0zu9eqzaq2HPZPwTc+nx+nuGh8fguCwB/XYpjlblOjmFFeKeeDoyEs2uX/0INFV1uscXthpUzBW4eC+fVy9GPVb9paIo2NR6EqGjkuu5TBHdWbL3vH5tJHjeFyrZKmCiU0b6Kj0bFTUiEjr7TyqTJ8LbFY47QpAGMjzROnOpoZ1rrsv59DG+6nFmo8sB7dxYwrEVkUltdOOK2UKdARVx3zMoXAXzfjmLfd96nZbSN9HZYNdOBIQIraypNPxzpzOyZHI/PZtoZ6fPtSZ44GpJBRWLsWkpGdzZjR25oluwOUpjn1bqfc92ZiN3NWDG6v8blo3qIJX07oxNWILL48HVbngePUnlb8ObM7bxwI5KBfUq3eWyaR8evlSMyN9BnxhLeUiZE++xa5M8jJmInrb9coiFXTy64V51Z6IhbBqN+88Imrf+tLTYzsbMblVQMwNtRjxC832eWdoHHlkr6OFiuGtOfiqv4oFAKDf77OvrtJzyyVSEdbzEx3G268O5DBjsbM3+HHwp1+RNWi5fFR1lyMQOWsFFX+N1u84rkWmaXROitlCqxbGdDBpBldLZvjYd+aoR2Nmehqzix3axYPaMfyQQ68N8KRryZ04pWeVrRsqsuQn2+wbO89ta2P8HhL1YaZPYjPKWHQT9dZuieAu3G5XAjNoOwRk2OFUOUzN3+Hn0Y+XXXBSF+Hme42bJ3bkxPL+tLCQJelewIYuOY666/F1Pra0UgjjcDzi7lppJH/w0ikcs6GpHMlIpMr4VmMcTFjx6s96f4CxJpqAhLz2OIVz5XwLEZ0NmXtVFdcVHhRNAQSqZzV58PZdrvKG0FbLEJHSwSIEB6dpxL+949CEDjqn0J+aSV/zXZT206RnFfKmotRXAjNYG4fW35/pdu/Jj3sakQW350Np4WBDqeX96uV105GoYQPjoUQnl7E7zO61SqpSFOq/FUecDUii79mu9GvvWbCkHlrIxYP6cD6q2F8ecyXj8Z1x8BAedn4regclu4JYOkge5YOsK/TOZBVJGH6Zh+6WbVk9RSXWgk3AD+cj8ArOpsDi/uobfepD3HZJXx5OpQ/Z/XQOBYc4Oi9VO7G5XL5rQFPvRaSUsCSPffILal4THgQUZXMo46Cskpe3e5HWHrRUwKquBYGvgDnHqTTr30btZWCgiDgE5fLK72UR5ALgkB4WhHOYzUTbzKLJJhpWHXz141Y4B9hssf/WtC0xaLHTEXVUZu2qaq48GIUCkFjjzBjI306mBhyOzaHsS7qE8McjJvhaGLI+QfpTOupebx71ez542aqPnG5jPrVi53ze+Fg3Ozha7P72DDgp2uce5DBGBflptTmLZowv68dn5x4wJkV/dQK5aM6m3EpNJP3joaw89WetboOvDvckdDUIn65HMXHozs+9d5WTXWxaW1AQm5V5YFYVNXe9dEYJ374O4IhTumM6qLeYLsay5YGHFjcm+l/+SAWifh07NOfqQkDHY3ZPq8nC3f5U1Am5bUB9mrfk15QxrrLkRjoavPaQIcaP1dbS8yHozriZtOKtw8F4Z+Qx8djOtYo5rYw0GXT7B7s8Unk1e1+LPS0443BDug0gK/cozQ30GH1lK6M72rBh8dDOBWUxg+TXR47tlRh1cqAryd2YaCjMZ+fCuWgXxLfTOzyzAIbDHS1WTGkPTPcrfn9agzjfr/FBFdzVg3roFGYgVwhcOxeCjeictCkE1OmEFi8y59rbw/AspVqj7sjSz00/RqPkZJfxvbbCczachdncyNeG2DPIEdjlfdLkUhEH/vW9LFvTUp+Gbt9Elm8OwCFIDzluSOVC4SmFfHB0RB+ntr1mT7POpkaVflljXLkclgWB/2T+fVyFP0c2jDT3Zr+HYyfaottpJFGnqZRvGmkERVEZxaz924Sx+6lYGykz4J+dnz3UpcXJibI5AouhmWy2SuOmMwSpvey4uo7A+rkM1IbJFI5B3yT2HgjjqZ6Wgx2MmZQh7ZVT9RClWyjUFT9Kwj886+AIEC5VMamG3FcicjidEgaE1wtavyM3JIKfr8aw5GAFCa6mnP17YGYt6hfelReaSUbb8Syckj7eg3ws4olfHk6DK+obL4Y34mJrhYaD+YEQeB4YCpfnAplqLMJF98c8EyizONzSlm6J4BmetqcfcNT41aUano4WPBZU12+PRvGuQeZTO5lW+NyZ0LS+OTEA76c0KlOUeAAt2Oyef/IfXrbt+bHybUXbrZ4xXEkIIWjSz1oa6i5oFJbKmUKfrkUxfRe1gyohYlwQVkl3/8dzjcTO9PsEVFEJlfwx7UY/rgag1whPFWWrxAEtZU38TmlD+OLK2sYYYigduLN/Qxma5BOFZ9TSkG5lG7WLZQuk5JfjkQmp4OGomZ6oWZmxTklFWy8EQeAf2I+yXllWP1jUqslFtXKe6KtoR6RGrZCtWvbFKlcQUp+OdatNb/G9u/QFq8ozcQb4P+xd9ZxUaX9+3/P0EiIkooIgqgoKIgoaXe79tqu3bW7bveuvXZ3d3cLEoqi0iIhrYSANBO/P0Z9DGJmgN3n+/x4v3ZfKsyZc8/MOWfOfd2fz3XRv1U9TgUlKybelIg/MVMtFktJyS6g9xpv1o5wpNub1DVNNRXmdrFl+ZVIujU3KbdKbby7FUcfJLLLN44vPBtVOI4f+zWn59932B8QzygFWgpVVYSsGtaSvmvvUr+2FuPdrT55TKemJuz2i0MA1NZW4+CkdjQ20cVMT4vZh4Iw1tOgdUP5fcIa1NHmwKS2DN/ij6qKgMU9myo1WW3bqC4HJ7Vj7I57ZBWU8GX3JmU+j1gsYfPtaAxqaTCnsy0aFVTDdrUz4fxsT6bvf8jQTX6sG+n07lh/H4FAwGhXS9pY1WHt9ShGbgtg9XDHSn9nloZHY0Muz/VixZWn9FnrzaLuTRnj2lDuasfOzUxwtzFkw81nDNnsy+DW5izq1rRavgdB5lvzU7/mjHe3ZNnlSEZvD6BLMxOmdbBBv5xku6OBCXx9IhiBALTVy78OS6RSikUSSsRSOq64zaZRrenU1LjKxQ9zA22+72PH7M6NOf4gke9PhaCppsIEDysGO5mjVcE4zQ20WdyzGV2bmjB0i1+pjykSSTj3JAVbEx2mdrCp0vGXhoaqCr0dzOjtYEZyVgHHHiSy424cXx0PZqBjfYa1afCvh1DUUMN/MzXiTQ01fERhiZiLISkcCIjnSWI2vezN2D6uDc4N/70qm9wiEccfJrLNOwaJBMa7WzJsQoNqT68qKBZz8F48m25Hv7khsqObnalCSVUz9j+kRCwTcn47F06PFqYfTFDzikRs94lly50Y2jWqw/FpbgoZwpaGSCxhn/9zVl59iotVXfKKRUqJNxKJlEP3E/jzYjjtbY24tqA9xrryiyIvXxfy7ckQguKzWDG0FV3tTBQegzxcCE5hu08sno0N+bJHU6VbiCzNjPhjiDOGeqVPVLd5x/D3tSg2jnJSOAo8PiOf88HJHAiIJ+FVAca66iz9zEHh1LMzj5NZdfUpBya1w8pQvkQvZVlxNZKol7ksG+yg0HZLL0dib65Pjxb/iSx/npHHtH0PiU7LLbPNRyIpv/LGLzqDibvvU1jKxP0tUilyG0MmZOYTnpJDNzmOS7+YDJwq9LvJxsZYV+7VU3nNildf+0/bpfCNCfofg2SfiYpQoFC6mbGuBvflaAsCWZy3tZEO4ak5Cok3no0N+erYE6RSqVzfGf1a1uOvixGkZBfIVSEAsglXaV4/Eqnsd9P3P2RKe2sWdLVFKBQwpLU5W+/IRM/yqqfUVYX80r85k/c8oI9Kq6myAAEAAElEQVRDvQpFYH0tNZYNacnkPYG42xgqdE4a6Wqy/nMnRm0LwL6+/icG9J62huy4G4uNsQ4HvmiL8ZtjpYudCYt7NeOL3YEcn+ZGIyP5KkFAlqx0YFI7hm/xQygQ8FWPsoWX8mhRX58jU10ZvS2A7IISfu3folQRel9ALDkFxSzq7lChcPOWBnW0OTrVld/Oh/HtqWDGu1nRsWnplZpNTfVYPqQVv5wLpdcab5Z+5vBOtKtKtNVV+b6PHX0czFh2OZJjDxJZ+pmD3FU0mmoqzO/WhEFO5vx4JpSOK27xdc+mDHYyr5Lky9JoWLcW60Y6EZyUxZ8XImi/7CYzO9ow2vXT9MuCYjFLLkUAsvP+h7521NFWRyAQIAAEAtm1B9l/736eU1jMvZhMvjr+BDN9LWZ3bkyXZlUv4uhrqTHBw4pR7RpyPjiZLXdiWXklktHtGjLa1bLCRYw9Ac9lYyqjSrFYLGH5lac0MtKpluOnLOrVlr1nMzva4BeTwZHABPqs9cGunh7DnBvQp2U9dKqxsraGGv4vUnNG1FDDG569fM2poCT2+sdjqKPOyLYN2TrG+V9t2UnJLmDX3TgO3IunSzNjvurRlB7NTavd9yW/WBYbu+VODG7WdfltQAulTILPPEriSljqO6O+nMIS9vvHM8HDihKxhEP3E1h9LQqLOlrsGNemStKW7j5L5+ezoYgkUtaOdFKoYuJ9ol68ZvGJYFKyC1kz3LHMm+eyOPs4mXU3n2FrosvVeV5ymxkrQrFIwp8Xwzn2IJHlQ1rSvQpuuoz0P518SaVS/r4WxT7/5xyY1Fbu9ry49DzOBydz7EESzzPyUBUK3lWLrB3upPBNu++zdL469oSNo5xo2UC+MSiLT1Q6e/2ec2amO5oKeEcFxb/i5MMkLs31fHe+nHiYyOITwYgk0nLNdcVSKRpliCM3wl/wxZ7AMkWbt0ikUrk9by6FpOJqXVeua9zjhKwK/W7i0vNwVOBzSc0uwLyUqoL3ScjM5+C9+HeCl0gi5UhgIvO7NcFQRwNVoUChVBtjXQ25Ul/e0saqjsKG620s65CRV0xMeh7WcggLxnqauFrX5cyjZLnacAAKSyRlGqqC7H3a5h3D44QsNoxyQk9TjQXdmvDLuVAGOtYvV4RzszakczNjfjsfxrqRThWOxd3GkCHODVhw5BFHprgq9P3UuqEBX/dsyvT9Dzk32+MDcdy1UV2+7N6EsW6Wn4jvo9s1JOlVAeN23ufEdDeFWhqtDN8KOP6oCGFhN+UEHGsjHY5Nc2P09gBmHwpi1dBWHwiXvk9TuBedyWSvRtRScKFFU02F3wbYcyooiZkHHjLRw4o5XWxLFYi01FX4c5ADbtaGLDjymEFO6Szu1UwpH7KKcLQwYNd4FzbcklXRjHWzZF4XW7n3ZWlYi13j23A5NJUVV55y7nEyX/dsVqVJmB9jX782+79oy+2nafx1MYKdd+NY2N2W/i3/U0G7827sOz8YiUTK0cBEjk5xles7qo9DfRb3smN/wHO+ORnMqqsaLOhqS8emxlUuTKmrChnoaM6AVvXxjc5gy50YNi+5wUDH+nzhaYWN8acLXxm5RVx4klKhsbtIImXmgSBOTHejRf3qaW0rC6FQgLuNIe42hmTnl3D6cRL7Ap7z89kwejuYMaKNBU4N/9nk1hpq+G+lprmwhv+vKSwRcyooiaGb/ei1xodikZQto1tzbX57JnpY/WvCTUhSNnMOBdF+6S2eZ+Szc1wbVg5tRR+HetUq3OQWidh4KxqPJTc5/ySFJZ85sHq4rPxe0S/N5KwCvjoe/EHCQpFIwsqrTzn2IIGuK2+z626szPRymlulhZuEzHym7n3A1L0PGOrcgEtzvJQSbgpLxKy8EknfdT44WtTm6nwvhYSbzLxiZux/yA+nQ5jXxZa1IxyrRbhJzipg2BY/AmIyOTvTo0qEm7K4EfGSW+EvODbNrULhJjotl7XXo+iw7CadVtxizfVnxKbnIZHyTripraVGGwU/79DkbKbsfcCvA1rQoRr8gt4nI7eI+Uce8X0fu1JvhsviWlgqgzb44tHYkIZ1/yOCHbqXgLgC4eYtmmVUrdSupU4jIx3UVATlRiiLxFK526YuhqTQs0XFviFSqZQbEWm0q0C8uR/3Sm4/DIDUnKIKK9mWXorg45erIhSwwycWkEWFK5I2ZaKvSZqcnjcgi0B+8FyxyGNNNRX6OJjJZfz7lgGt6nMyKEnuxxeUVPwZiyVSfJ6l8yBONv6eLUzJyi/Ba+lNsvPLF/i+7dWMc09S+GzD3TJNhd/n655NyS4oYfOdGPlewHuMcW2Iq3VdZh0I+qAFTlNNhekdbcqsmvyyexNaNqjNxN2B5cZsl4a1kQ4HJ7UlLDmH1dcVN9R/S73aWhyZ4kpmbjHPM2Sxy2KJlP3+sezxT6SbvSktG8qfIPcxAxzrc2K6O+eepDBu571yk5v6tqzH+dmePErMZuAG3zKTqyqLuqqQuV1sOTPTg4CYTIWNkwUCAT1amHFqhht29fQZuOEuP58NVchoXVEEAgEdmhhzfrYnC7rZsvzyU3qv9eH20zQyc4tYcyPqnR+MSCIlJCmb7W+uMfKgpa7CF56N8P6yI4Nb12fp5Uh6rfHmQnBKtRg1CwQysWP3BBfOzPRALJEybsc9Ju66j290+gem3AfuxaMqp4hULJbQf/1d/KLLT6erTvS11Rjjasm5WZ4cm+aKjoYqSy5H0HnlbTbdjpbbcL6GGv5XqRFvavj/kui0XH47F4brn9dZcz2KbnYmBCzuzDe9m9G2Ud1/Rd2XSKRcC3vBsM1+DN3sR20tNa7O92LT6NY4W9ap1jG9Lixh/c1neCy5wZWwVFYObcmpGe50bqZcJLdEImXmgYeUlOJFkVckYu2NZ0xpb83luV50V0IYep/8YhGbb0fTddVt9LRUubGwA194NlLK+M43Op3PtwXgG53BsalufNvbTqHErkshqXRbdRuRRMKVee0/aJupSm4/TaP3Gm+amOhyYrobltXcPiQViTHQAoGg9AlSYYmY1dee4rn0Bl1X3mbdzWfEZeS/a+F4H1WhgP6t6im0IpmQmce4nfeZ1tGawa2V89mRF6lUylfHn9C6oQHD2zSoeAMg7XUR0/Y9YNKeB0iBoc4fjvHQ5HYsH9ISIx0NNCo4LsuqvHGyMODqPC8OTXalm50pKoK3ZuEfIpZKyZIjuSglqwB1VSFd7SoWwqLT8nhdWEKrcvxuQLGkKZCZeJfXNhWRmsOFkFRKPpr8FIkk7LwbR26RCBUVASKJVO4EIWNdTV4XieSe7Dc11VU4Lly2nR5XQuWPlO7ewpS4jDzCU+RLt3o/NeZjNFSFqAoFDHSqz82FHd6Jz0KhgHq1tXj5ugivZTfLnXAb62miqSbkQXwWnktvcj28/NeiqabCyqGtWHsjitDkbLlew1veRo9n5Zew9LL88ctCoYDlQxzQVBUy59AjhbyPAGyMdVncqxl7/Z6z/uYzhbZ9n7o6GhyY1PadT8el4GT8ojMY72ZJ/1byXUPKo4mpLqdnulNLXZU+a7x5lJBV5mMt6mpzbKorXraG9F/nw5H78dUWy2xrosvxaW6MateQCbvu883JYLlbNgFqaajxdc+mnJ/tQUTKazqtuM3pR0nVGiOtIhQwyMmc6wvaM8ixPrMPBjF8q/8nAnCRSMLSyxEKp83J/GgacXqmOyPbWvDL2TB6rL7D2cfJConMitDEVJdlQ1pybJo7Tc10mbbvIX3X+XD6URLFIjE7fGIpkUjRUhOira6CtroKmmpC1FQEHwjj6qpCNNWESKVSRm0LYMb+h9yPy/xXY72b19Pnp37N2TPBhbldbLn7LB33v27wxe5AroSmlnqPWUMN/+vUtE3V8P8NRSIxV0NfsC/gOQ/js+jR3JQNn7emXaPqFUYqoqBYzPGHifhEpROU8IpxblZsGe1cbWZ+75NdUMKRwATW3XhGY2Md1o5wxMPGsNLvx1bvGEKTc0r19pAiqxrp3My4UlVEUqmUM4+T+etiBHZmehye7Kp0K82rvGL+uBDOheAU5ndrwljXhgqNLTu/hB/PhHAzMo2f+zWnf6t61XJMiSVSVl+PYpt3DL/0b1HtQsZbutjXQ4CEhnVKn5i/zCli/c3od8lHHws27yMQQL8yTKtLIzOvmFkHgxjm3IBpcraUVIa9/s8JTc7h4hzPCj9DiUTKwfvx/HYunBKxrI1FKOATg1GhUMAAx/r0tDdlr5/Mi6msyXdZlTcgm+S2bmhA69GteZFTyKTd94l8kYtAIGujeYs8MdWXQ1MBme9IRfjFZNC6oUG5ZsqZecWkZBcqJt7klG9Y/Nu58DI9GqRIOeD/nP6OsmNJIoVStKxPMNBWQ01FwMucIiwNK74FamamR1xGHgXF4grNQd/H09aQVdeeUiySyCUk62ioMsjJnNOPkmlmVvF7WFqMtgBZVPx4dysmeFiWWtXU2FiH2PQ8sgtKGLUtgIkeVizs3qRUnywbIx1CknPIzCtm6r4HeNka8edA+3feMx/TskFtpnewYf2NZ6wa3kru2HuQeapsHOVE//V3cWxQW+4kKQ1VFbaMdubL44/55VwYP/drrtC119ZEl31ftGXkVn9UhQK529Y+5v199rCvR0sLgyoNEtDVVGPjKCe2eccyYos/3/Ruxqi2FqW+VrU3yVVu1obsuhuLb3QGvw20rxbvEBWhgIkeVnRtZsLik0+Ytu8BE9yt6NxMfn83G2NdDkxqy5nHyfx2PpxD9xL4pX/zajWt1VRTYZJXIzxsDOm91rvUdlSxRMrUvQ+4NNdL4RY0TTUVxrhaMqxNA44EJvLnhXBWX49iVicb+jjUU9ikXx5M9TVZ1L0pMzracDQwkRVXnrLkYgROFga0qK9HXR0NdDVV0dVQk/2pKftTT1MNHU3VD8YUn5HPXv84Juy6j0Udbca6WdLXwQwtBRazqhJNNRX6taxHv5b1SMjM59iDRH4+G8Y3J0P4rHV9hrVuQCMFqj5rqOH/MjWVNzX8zxObnscfF8Jx/fMG54JT6NTUGL+vO7FmhCOu1v9OlQ3IzGyXX47E9a/rHAiIp6e9Kd5fdmJaB+tqF26y8otZefUpHktuEJKUzcZRThyd6opnY6NKvx9hyTksvxJZ/gQeWHnlqdL7CEnKZuhmP34/H86XPZqwdYyzUsKNLAkqkc4rb5OZV8yVN+1yigg3NyJe0HXVbXIKRVyZ58UAx/rVckxl5Bbx1fHHnHuczInpbv+YcPOWzvbmZb4ui7ra7JrQBnU53jddTTW5fVEKisVM3H2ferW1mNfVttrP1YjUHP68EMHfw1pV2DIZmfqavut8+OVsGAUl4ndCpUQKdWuV7r+hoSorrZ/saYWNcS3UVD6snhEIkPvYKxZJiEjN5fJcL/4cZI+tiS6qQtlK6qv8isWbiyGpcrVMAfjHZFTYMhWWnINFHe0KI8ffklck4nWhqMyo8PtxmfjHZJQZ2VtYImHDreh3q9nyrmoLBALqaqvxIke+0ntjXQ1qa6nx9IVi1TdNTHSppaGqkB9Pl2bGnHmUJFebxftinaaqEANtNQY41qNBbS0WdW9SZjua5nsClEgiZZdvHL3XeBObnvfJY98XaUrEUu48TcNr2U32+ceVOcZpHaxJzCpQ6vreyEiH5UNasi/guUItP/raanzfx46LIals9Va8bauZmR57J7Zlw61otimx/ceoCAXVkgApEAiY5NWIXePbsOZ6FH9ejKCgnAqs9rZGLBnsQHpuMX3WeBOcqFhFlCJY1NVm38S2DHSsz7zDj5h9MIiMXPnbEwUCAf1b1ef6gvY0NdOlz1ofNtx6JlfLXmXYeDu6TCFFIpUl4v11MULp59dQVWF0u4bcWtSRCe5WLL0USdeVtzgdlKRwpZi8aKurMtbNkpsLO/BDXzte5RezwyeO1OxC2lrVpYudCW0b1cWunh4N6mijr632yXtgUVebb3vb4b+4MyNcLDjg/5xOK26z/HIkqdn/bttSgzrazOtqy50vO7JqWEuSXhXw1YlgBm/05UhgQrUfMzXU8G9TI97U8D9JsUjC2cfJjNzqT/dVd0jOKmDdCEc2fu7EZC9r6ipgbljVRKTmsPDoYzyW3CQsJYcNI504P9uD/q3qK9XqowiZecUsuxyBx5KbPHieydYxzqwe7oibdeWrbUC2Gjx13wNEZc243lAslnL0QWKpE4byyMgtYvGJYAZv8qWNZR1uLuzAQEfl0iqeZ+QxZsc9/rgQwW8DWrBtrDP1FYhZzSks4esTT/jjfAQLuzdh+1hnuWKPlSEwLpPea3wAAadnutPUtPrMHZXFzdqQXePLF3BUhQIGyNkyJRJLmHngIWoqQlYObVUtK5XvU1giZs21KL7wtKJtOUJFQbGYPy6E0XuNN+EpOaWKlAbliK9Z+cVsvxvHL/1a4P1lJ/q2lK3CCgWgJpT//N/r/5yudiZYGtZioKM5V+Z5cXSqKz1bmNKkghXrtNdFBD5/JVdbn1QqJSAmA1fr8sWb0ORs7OSoGHlLak4h6qpCapfyXkmlUn4+E1qhIFNYIuZyaAogv3gjlUp5mVvMqmvyiQsCgYCmpnoKt08IBAI8GxviHZUm9zaejY0oFEm4J4dXTpFINmk3N9Dit4H2BHzThaWDW1IokryrqiqNjyu7ikQSol/m0n3VHQ5/1GLzcdJUiVhKYYmEX8+F03edT6mClux8bckev+fci5Xf8+ct3Zub4mBem6n7Hig0CTM30GbH2Dasuf6Mc0+SFd5vi/r67J3owurrUezxi1N4+1sRL1h6MYyNt56RLUfbYmVo26gu52d5EBT/ioEb7pb7PWqsq8meCS4MbdOAoZv92OYdU21tMAKBgMGtG3B1fnsKS8R0Wal4G5Sepho/9m3Oyenu3I/NpOvK21wKSamWMUek5nA+OOUDX76PKRLJkivvPqucB4y6qpCRbS24tagDszvZsvxqJF1X3eHYg8RqE3FUhDJvoRPT3dk1wYWCEjEdlt1izqEgQpLkE/Jqaagyql1DTs5wZ9nglkSk5uC19CYzDzwk8F9uqVIRCvBsbMS6kU5sGd2aPg5m7Lwbh8vv1/jq2BMePH/1r46vhhqqixrxpob/OdbdjML1z+ssvxKJl60Rvos7sW6kE25V0A6kLFKpFO+oNEZvD6D/uruoqQi5MNuDHePa/CPjSs8t4s+L4XgsuUFwUg67xrdh/xftKlxNV5QfToeQ8Cq/3BSUtwiAPy6Ey/W8xSWyvu2Oy2+RnlvE5blefNmjqVLx3yViCbvuxtLjb28s6mhzbX57etmbKfQZeEel0WPVHZJeFbB7QhuGOjeols9QKpUlxozefo8p7RuxbLBDlcTDV9cNjZuNITvHtynViwXkb5mSSqV8d0p2LG0d7VwtqSkf8+eFcJKyCpjdqXGZj7kV+ZL2y26y2/c5Iom01FL7Wuoq5VbPbLwdTasGtXGzMcRUX5OVQ1txea4nHo0NMdSRz9g6v1jEoXvxjHO3/ODnjhYGbBjVmh/6Ni93+ythqbRqUFsusfHZy1xyi0Q4VBAJHJaSQ3MF/W7M9DVLPW9uRr7k6YvcCq8jhSIJm+/ITEVFEvkmQA+ev0IihYCYTOIz5EuRamqmS3iK4r43rcz12ef3XG7DUjUVIX0czDglh3Hx9A42bBvjzJ1FHRnc2hx1VSFqKkImejZi8+3oMs/x0lqZxFKZUen3p0KZuDuQrDeVW0Zv0rw+pkgkITwlh16rvfnrYvgnLVw2xros6t6EBUcfkavEKviCrrYY62rw5fEnCl2r7M31WTvCkS+PPVFKOHIwr83uCS4suxTJgYB4ubd7mpLNplvRGNZSxz8mk4HrfYhTcGFCUYz1NDkwqR2ejQ3pt86HK+UIdkKhgOkdbNj3hQs778YxcXegQlUximKip8nm0a35faA9v54LY+LuQJKzChR6Drt6emwf24a5XW355mQI43fdf2cIXVX8cjaszLbM9xFJpMw48PDdeVEZ1FSEDHCqz40FHZjewZq1N6LotOI2R+4nVKt/S+uGBvzYtzlX5nmhr6XGkE1+jNjiz42IF3JdnwQCAR6NDdk2tg3X5rfHVE+T8bvu03edD8ceJJbaxvlPYlBLnXHuVlyY7cGhya6oqwoZt/MeI7b6/6vjqqGG6qBGvKnhf46UV4WsGeHIzQUdmNreWqEI0aqmsETM4fvxdFt1h1VXn+LcsA6+X3fiz0H2CqXYKMvL14WsvR6F55KbRL3IZf8XbdkzwQVny8pHcr9PiVjCl8cecyQwEakU1FQE74zxtNRk5ngaqjKDPJU3kzWRRMrtyLQKv/TvPE2j11of/GLSWTfSia1jnD9I8lGEh/Gv6LvWh0uhqeyd6MLvA+3R15JfDMkrEvHtyWCm7n3AjE427JngQn05yuOlUilJCt685hSWMHXfA3b4xLJ/UlvGu1tViUC02zeOmQeCKv08ZWFtpENTU91SE5H0NNVoWYEIAPD3tShuP01j9wSXf8T76Xr4C048TGLtCCfUSql+yy8WMWVvIJP2BPLydVG5LYHljTclu4DdvnF81aPpBz+3MdZlz4S2+HzVSa7xngxKwtxAG+eGBnI9/mMuBqfSU04zbb+YDJwb1qnQvyQ0WXGz4rLEowMB8ZSIJaipCFBXEaKpKkRdVYgA3l1X3l5b3pbwy1t5s//NpFwKLDz2WC5xQGZarFjlDcgqDLMLRcw5FCS3CDHAsT7ng1MqvC52bGpMFzuTT6rYhrdpQFxGPn5lmBFrqJV921csluATlU7H5bfwjU6nro46qmUIsRKp7Bq+824cHZbd+qQ9bJybJea1tfn9fFi5r6M0VFWErBnhyMPnrxRK/AHZ+/Jdbzsm7QlUKm3JycKAnePbcD44mSOBCRU+vqCohAMBcbhZ12GClw07xrXhs9bmDNxwV6GWOWVQUxHybW87lnzmwPwjj/nrYkS5VRytG9bhwmxPNFSF9FrjjV+0/AlRiiIQCOhlb8a1+e0x0Fan+6o77PN/jlgBgUIoFDDUuQE3FrSnXm0tuv8tu4+qCqEgKP4VvtFlt2V+TFZ+Cf3W3UUip0hcEWoqQoY4N+D6/PbM7dKYTbej6bj8FgfvxVNczvdLZbE0rMUv/Vvg+3Un3G3q8uWxYLr9fYdD9+Llfl8t6mrzXR9ZS9WwNhZsvPWMjstvsfJKpNztqNWFQCDA3lyfXwe04P63XRjnZvmvjqeGGqqDGsPiGv7n+H2QPebmhv/qGDJyi9jnH89e/zgMtNX5wtOK/q3q/yMVBAAvcgrZdDuag/fi8WxsxKHJ7ZQ28y0PqVTKpZBUll2OpFgkoYOtEd2bm6CproK6igoaqkI01IRoqMr+rq4qfPMz2b9lqQelvyfPM/L49Vw4AbEZzO1iyxjXhqWaaspDTmEJyy5FcuxBIjM72TBJiTQq/5gMFh17TD19LS7N9frElLYssvNL+OZkMM9e5nJxjqdcLUOhydlM3/+QhnVrcW62J3WqIGpcLJHy67kwzj5OZssYZ6WfJy49j9XXI+jUuA59naw++N3LnEJGbPXHxbIOC7s14Ys9ge9K0tVUBAyUww/oQEA8u3zjODrVFTN9+dvYlOVlTiGLjj3h1wEtsKhb+meakVss90SnvM9qzfUoujQzoUX90gUseY4NqVTKrrtxTPJqpJSY9yqvGP+YDJYMdpDr8TK/m/LF3oJiMTFpuTSvV7Ew95bcIlGZQt7q4Y68fF1EiVhCsUhCkUjCo4RXHAtMZEG3JrKfi2U/LygWsc07Vq5V67wiEeefpLz796P4LE4/SmKAY/n+UU1N9YhMjUAqlSr0nmfkylbqzwen0NRMlxkdy67qeotjg9rUqaXOrciX9JDTk+h9ammoMsa1IZtvx+Bm/en3oLqKEKGAUqvGQCbgFOdLGLlVZmYsrOD1FokkpOYU4hOVjpPFf8REoVDA8qEt6bHqDl2amShkYAtgqKPBhs+dGLk1APv6+uW2Mn7MyLYWJGXlM27nPU5Md6swjv5jnC3rMLNjYybuvo+GqpD+ZVQLSqVSttx5RrFIygSPRoCslWNGx8boaKgxelsAq4c70sVOsdeuKL3szWhiqsvUvQ94nJDF2pGOZS5a6WurseFzJ/YHxLP+ZhR+0enM7ty4UuEB5VFbW50VQ1ty+2k9tnvHcPZxMn995oCVAgmJtbXV+WOgPUOdG/DdqWBOPUrip37N6dik4qS8sjDV12RWJxsKS8QUlkjILxZRUCym4M2/C0ViikokFInEFIkkpOcWEZ+ZT591PnzXyw43m6q5x1RVETLIyZz+repz9nEya29EceZRMr0dzBjibK6Q6bciGNRSZ2anxnzh2Ygzj5LZ6h3DhZAUnBvWYVS7hnLdc9TSUGV0u4aMamuBf0wG231i8Vxyk+4tTBnnZomTRe1/NQxEU01FqWtoDTX8t1Mj3tRQQxXy7GUu231iORmUSBvLOiwf0pL2tpU3AZaXlOwCNt6K5vD9BDo2MebYVLcyJ4qVxT8mgz8vRpCSVcDcLrYMdTavkhvAvCIR624+Y+fdWAY61ufWwg5KexS9FZd+PBNKYxMdLs7xVDhWu6BYxNLLkRy+n8Ci7k0Y62opt8fOvdhM5h4KoqmZHgcmta1wO6lUyslHSXx7IoTpHayZ0dFGKT+fj8ktEjH7YBDxmfmcnO5epkhREU8Ss1h49DG2RrU4HpjA5fB0fh3ggEEtDdJfF/H5tgBaNzTgz0H2CIUCto9tw8Td9ykRS5FKoV+reuU+/7WwF2y5E822sc7YVmPSyFskEikLjj6mva0RAxzLbudqUEcb76868eeFcI49SEQskZbZ0mNSxkQxOi2XEw+TuDTXq1Jj9o3OICOvmH4ty38vy+Jq+Aua19OTy99JIpGSmFnAFx5W5T4uIjWHNpZ1MNGT/zx99jIXbY3SJya1NFSx+qglMqewBLFU+slEWCyR8uOZsDLFiPc5H5yCUAi8WWAuFkv47lQoHZoYl2tQbWNcCz0tNVmrlwK+WG+9ayRSWTWZiZ4mg1uXHx391rj1ZFCS0hOPsW6WuP91g/CUnE+Sq9RUhKgIBEjKqAQSCmRj6NjECCeL2hwIeF7mfjRUhRjrarB0cMtSPZHq19bix37N+ep4MFfmGSgsQjtaGPBN72bMPBjE+VkeZaZclcbCbk1Izirk9/Ph/DnIHm0FU3JcreuycVRrpu59gK6mKp2afnjcBcZmcjwwnkKxmAXdmqKj9eFrG+tmibGuBrMPBfFdbztGtrVQaP+KYm2kw6kZ7nx9Ipg+a3zYOMoJR4vSK/MEAgGj2jWkdUMDZh0Mwj8mk7+Ht6KeAse2orS3NaJ1QwOWX46k12pv5nRpzBcKhgO0alCb0zM8OBDwnG13YjhyP4Hv+9gpNW4zfS0WdGui0DYFxWJ2+sYyZd8DHC0M+KpHE4UE6/JQeZNI2LdlPa6EprLy6lM23HzGtA7WDG3ToNpEHE01FYa2acAQZ3PuRKWz5U40G249Y3BrcyZ6NJJLZBMIBLhaG+JqbcjzjDz2+D1n3I57WBnVYpybJb0dzKpt/DXU8P8jNW1TNdRQSaRSKb7P0vn6+BN6rfGmRCzh5HR39k5sS4cmxv+IcJP4Kp9vTwbTYdktMnKLOTXDnU2jW1eLcBOeksP4nfdYfjmSbnYm3FrUgZFtLSot3EgkUk48TKTj8lsExmVybKobfw5yUFq4ScoqYNKeQL49FcLXPZuyb2JbhYWbB89fMWijLwmZ+Zyb5cF4dyu5zXZXXn3K2B33mOzViO1jnSt8HQXFYhYefcK668/YOqY1szo3rhLhJiW7gCGb/CgSiTk+zU1p4cb3WTqfbw3g87YNWTfKmd8HO6KpImT9tXDEEinfnw7G1aoOSz5zeDduL1sjto1tg4pQgIG2OvblHI8Pnr9i9qEgvu7ZjDZV3NZXFtt9YonLyOOX/uV7xADoa6nx12cOHJ/mho2xTpm+Ph+bvL5lxZVIBrc2V2jFuTR2+cYxwqWB0lV8TxKzyhWq3ifqZS5RL3NpUb92uY8LTc6RtTUpcK1LyS7ETIHJeLFIUmrl3dtTRCSHerPHN+6DlKa3z/vz2fJbe2ppqKEiEBCpQOKUVColIuU/rVYlYilfHw/mVuTLCrcd0KoeNyPSyJIj8r00DHU0GNzanM23oz/5XXmfk5qKLIr+5HQ3to1tg42xbqlmrgJkFTxzu9hyfUGHcs2sP3Oqj5t1XdZcj1LKa2tUWws8bQyZvv8hJQq0kwgEAv4aZM+LnEJmHwySu63ufdrbGrF5dGvszD68bhUUl7DDOxpDXXW+79MC8zqln9M97c3YNd6Fvy6Gs/Lq02o3T62locqa4a2Y26UxI7cGsNs3rtx9NjPT48xMd6wMa9FrjTdXw15U6/h0NFT5qV9z9k504UhgAgM3+BKWrFg7oopQwGhXS/4e7oiWugpdV95m8+3oavWLeYuWugrTO9hwZ1FHmpjoMGiDL7+eCyMhUz7vLHlQEQroaW/G5blefNO7Gfv842m/9Ba7feOq1VdGIBDQ3taI/V+049hUN/KKxHRfdYfJewIVMiZuWLcW3/exw/+bzgxpbc66m89w/+uGrKUqW7HW8RpqqKF0asSbGmpQkmKRhBMPE+m9xofpBx5iqKPBnS87sHxIy09WO6uLhMx8vjnxhEEbfHldKOLsLA/Wf+5ULftPfJXP/COPGLjhLo2MdNgyxpkZHW0UXtEsjSeJWcw/8ohllyP5ro8dR6a4Ki08icQStvvEMudgELW11bk2vz2DnMqOuS6NwhIxf14MZ9S2AAa0qs/m0c40MtKRa9uEzHyGbvbjYnAKJ6a7MU4Or5qYtFwGbrhLfGYeBya1w6OxkdxjLY+QpGwGrL9LS3N9do13Ucjf530uhaTwxZ5AfurXnLFvesjr19FlklcjXuaWEJ+ejVQipmFdzU9SodrbGrFvYlv+GNSizPchOi2Xibvv83XPpnIlIFUFIUnZrLz6lNXDHRUygW7ZoDanZrhjVffTqG81oaDUFo3gxCwCYjKZ3bnitpnyeJ6eR16RiM+VXMXPKSzhyP1EOjWVr93ALzodZ0uDClsMFfW7AVlrZ1lCV2mUiCWljkMgEKAqFFRouhmTlluq6XCxWJZMGFCGR8xbmprpEpEqv3iTlFVA/kcxziKJlCl7H/AkMavcbRsZ6dDe1ojzwSnlPq48Jnk24m50BokfTSzVVYR8fBqqCAToaaqya3wbjk51w8G8NiBrAfxYFFMVCqhTS50vezRhWgfrCo8NgUDAD33tOPs4mdOPFE+BEggE/D7QHlN9Tf64KJ/B/Vs01FTYPMqZuIx8fj4bqpR44mVr9MFxKhZLWH4pHGN9deZ2a0adCkR5F6s6HJvmxrHABL4+HlxtyUJvEQgEDHexYO9EFzbcesbcw4/ILy7bNFpbXZUlgx34uV9z5h9+xE9nQt8lmVUXzpYy7532tkYM2niXFVciFd6nka4GK4e2Yse4Nhx/mEiv1d74V3AOVxUGtdT5trcd1xe0RyKR0mXlbX4+G1qlJtBCoYA+DvW4OMeTH/vacfBePF5Lb7LDJ7bazYFb1Ndn1bBW3P6yA1aGtRi/8z6DNvpyJSxVbhG0loYqo10tuTavPSuHtiIttwjPpbeYfTCIh/E1KVA11FAZasSbGmpQkOz8Ejbceobn0husvfGMEW0t8Pu6Mwu7N8FUr/o9OkDmO7Lo6GM6r7xNQYmEA5PasmaEY7W0mmTmFfPruTA6r7gNwLX57fm+j12V+LCkvS7iy2OPGbrZD3MDba7Na0+/lvWUrlYKTsxmwIa77Pd/zvyutiwf0lLhcT5JzKLvWh/8ojM4M9OdKe2t5Y6pvhCcQq/V3tjV0+PsLA+5RLTzT1Lot+4uXrZGHJjUTqEJbXncjHjB8C1+THC34s9B9kr7BR2+H8/8I49ZPdyRz1p/6A1ibaJPvdpazDz4mBb1tRnqVLp3iKt1XbralS7KvMwpZOyOe4xwsWCMq6VSY1SUt6150ztaf+DTIS+bb0ejpaGKz5ed6NLM5F0ij6qKgLqlJEYtuRTJMJcGlY6S3+P/HINa6tSrrVz11PXwF9gY68ht+O0fkylXIl1YSo5CMeEgq7wxVcDTqFgkKTOGXkUoqLDy5tD9hDLPY5FEyrwjj8udQDY11SM8Rf4qgZCk7FKro4pFEj7fGlBhGpG7TV2lxI63WBrWol2jOmy/+6Hhr5qK4J14o6EqxNxAi+VDHBAI+KTK5v3Iew1VIaZ6mmwf14bfBrRgw61oudN3DHU0+GOQPT+cDnlnMK0IWuoqLOrehOMPEjnzWLH3RF9bjZ3j2nAhOFVh8+OPEYnErL8WSW6xmBkdGsv9vWBrosuJ6e48Tszip7Nh5YopVYWzZR3OzfIkNbuQget9iUkr37y5f6v6nJvtwcP4VwzaUPHjK4ummgoLuzfh+DQ3bkS8pPcaH4KUMHhu26gu52d7MsTZnIm77jPv8CNevv5nTHPNDbT5sV9zTs9053lGPu2X3WLt9agq/XyFbypxLsz25Jf+LTj2IJFp+x6wzTuGguLqFXHM9LVY3KsZvos70dvejN2+cXRcfotdd2PJkzNFTigU4GVrxJ+DHLg8z4u6OuqM2X6PAevvcjIosdqFwhpq+F+kRrypoQY5eZ6Rx4+nQ3D96zq3ItP4bYA91+e3Z3S7hmip/zP9vNFpucw//Ihuf99BClye68WqYa2qJbkqv1jE+pvPaL/0JjFpuZya4c7Koa0wlyNdqSKKRRK2ecfQafktcgpEXJ3XnoXdm1BLU7kqntwiET+fDWXIZl86NzXhwhxPhQ0Fi0USVlyJZOhmP/q1rMeJaW40llMMyy0SseBN2sfyIS35bYB9hW0tsnaNUL4+8YQVQ1vyTa9mSgss7/M2XnzGgSBWDWvFlPbWSothm25H89v5cHaMa0PXj7xGikRiZhx4iHf0K0a3bUBUaj4zDj0i+ZX8JeSvC0sYt/M+LpZ1+LK7Yv4DleHXc2Fk5hUzrb21wtvGpuexxTuG3/q3wERfk42jWstSx2prUVAi+STu2ycqnSeJWUzxVHxf75NXJOLI/QQmfBQPrgiKpExJJFICYjPKbYkBWaVbREqOQt4PrwtKSM8tUsgjp1hUeuUNyKpBxOWkwIjEEg7fT6C4nKqHjNwi1t94Vubvm5npEaFAXHhwYnaprRxSIK9YxLAtfqS9Lnulvk/LegQlvKpUS8YXHo04fD/hA5FFTVVIYYmEOrXU+bV/c24t7MBAJ3NmdLRh2eXIDyqYVFWE1FJXQVUoYGp7a24t6kB7WyN6tDDFwVyfpZcj5R5L9+amdLEzUTj++y0N69Zi5dBWLD7+hKcKtK+BzLNqxzhnVl19ykUlq5nyikQsPPqI51mFTPawxkhfse9BU31NDk9uR9SL13y+LYBXSrbEKYKRrgb7v2hLhyZG9F93l0shZceJg+w9PjbVDddGdfnxTCgnHiZW+xib19Pn9Ax3Pm/bgM+3BfDTmVC5hYG3qKkImexlzbUF7SkSiem0/BaH7scr1SqnDE1N9dgxrg3bxzpzI/IlXktvsdf/eZW2cgmFAnq0MOX8bA9GtrXg1KMkPJfeYMud6GoXA3U11fjCsxG7x7vIBLeHSbj9dYOllyJ4qUC6lJVhLX7s2xz/bzozyMmctdfftFRdfarQ89RQw//vCKQ1tWs1/A+QmJhIgwYyI8iEhATMzctPD5EXqVTKg+ev2Oodg3dUOr3szRjj2vBdWfk/RdSL16y98YxLoakMcqzP9A42SnuXVIRILOFIYCJXQlN5VVDC1z2aVjiBU4RbkS/55VwYqkIBP/ZtjnslUxuuhMoMiS3qaPP7QHtsjOVrb3qf8JQc5h95DMCKIS0VagF5nJDF7ENB1NPXYtWwVnJVziS9KmDmwYcUlUjYOMpJ6ejzjxGJJfx0NpRLIS/YPtZZ6YQxqVTKssuRhCZns6h7009a2ApLxPx6LoyQpGx2T3ChtrY6IpGIH04HU0dTjYW9W1S4j2KRhIm77wOwfWwbhdO/lOVicApfHX/Cxblecpn2vo9UKmXMjntYvYlbfZ8ikZhTQUn0tDdD700bllQqZcD6u3RvYcr0DjaVGvcevziOBiZyZqa7UmJcXpEIp1+vcn62h1xib3hKDoM3+vLox27liopPX7ym/7q7hPzcXe5KhK+OPeFwYAK7x7vQvol8LYJ7/OK4HZnG9nFtPvmdw0+XOTLVlaampZ+318NfMH3/w3Ij3kEmAl2a61XqNeR+bAZDNvtzYbYHdnIIVUM3+XIvruxKAlWhACvDWpya4U4tjdJF6wm77uNkUZuZnZRvtxu+xQ8PG8N3z5H4Kh+fqHQGOH6YflhYIqbDslt816cZfRz+Y4Z9MTiF5vX0P/m+ic/Ip/vfdzgwqW2Zxrgfk11QQo+/7zCjow2j2jVU6vWsuBLJ+ScpnJ7prlC7I8gM0WcfCmLvxLa0bqh4xV1Uag6WdWuhVonUyMISMXMPPSLq5Wv2TGyr8DVIWS6FpLDo6BNGtrNgUdcmqFZwvb0R/oIFRx/TqakJv/RvXuYxWpXEpOXy9fFgkrML+HOQPZ5Ktg/7RKXz3algdDRV+bV/C7mPz6pAKpVyOfQFSy9HIJXCVz2b0N3OtMq9D6VSKTcjX7L6WhQJrwqY5NmIMa4N/5HPSSqVEhCbydY7MXg/S6dfy3pM8mxEE1PFFhElEil3otLY5RtHem4R1kY6jHOzrNLPq7rmBjXU8G9SU3lTQw2lIBJLOPckmQEbfBm/6z6WdWtxbX57lg9p+Y8KNxGpOcw48JAfToeio6nKjQXt+eszh2oRbmTJTCl0W3WHbd4xDG1jzqnpblUm3MSl5zHnUBCzDwYxul1Dzs/2rJRwk5yVz+Q9gXx5/AnzutpyaHI7hYWbErGENdejGLnVn54tTDg9w11u4UYikbLxVjTDtvgxrE0D9n3RVi7h5vbTND7f5o+DuT4nprtVmXDzurCEibsDuR/7ilMz3JQWbiQSKT+cDuVkUBI/9G3+iXBTUCxm0p5AIlJfs2dC23cpPaqqqgx3bkBcZj7bb0aUuw+pVMr3p0PIzCtm46jW/5hwk5JdwNcngvljkL1Sk6aLIamEp+SUmlKioarCsDYW74QbgMuhqaRkFzLerfy0poqQSGTx4OPdLZWeBNyMfIlFHW25q/T8YzJwtqxTYTVYaHI2Tc105RZuotNyOfogAYBjb/6Uh3Irb1SEiEox1n3LXr/nFQo3IEuuWnziSam/e/ZS1kYyYVdghaX+UqmUsAqqdEQSKc8z8pmw636ZPigDHGWpU5VZY5vS3ppd75mdmhtoM9zF4pPKQE01FWZ3bszKK08/GE9Pe7NSv28s6mozrYM1350KkdvHRV9LjWWDW/LnhfAK28bKYm4XW+obaLHw6GOF35cudiZ83bMpk/YEKrX/xqZ6lRJuQPY+r//ciXaN6vLZBl8iFfBRqgw9WphxaqY7CRkFjN5xr9yqL4BOzUy4OMeLpKx8+q71ITQ5u9rH2MhIh0OT2zHFqxHT9j1k0dHHZOeXKPw8Ho0NuTTXi252pozcGsDiE0/+kUonkHkO9WhhypW5XszoYM0Pp0IZsP4uvtHpVb6fTk1NODXDnRVDW3I5NBWPJTdYf/MZrwsUf88U3Xe7RnXZPq4NF2Z7oKYioN86H74+/gSfqHS5z0uhUECHJsbsGu/C6uGtMNBWZ/T2e/Rff5dTQUkUK2BQXkMN/z9RI97UUMN7vC4sYZt3DO2X3eKvixH0b1kPv8WdWdyrWbXGaH5MaHI2U/c+oP+6u9Stpc7yIQ78MdC+SlqWSsM/JoOBG3z5/nQoEz2tuDzPi172ynvPvE9ekYgllyLo/vcdGhhocXNhB8a7WyndIiSWSNnhE0u3Vd40MNDi+vz2DHVuoPBYn754zaANvpx9nMzuCS7M7mwrt4iQml3IqO0BHLofz6HJrkzvYFPh5FUskbLy6lOm7XvArE6N+blfC6UTgz4m8VU+gzf6IZFKOTrNVenjRCSWsPDoY7yj0jg61RXrj0ya84tFTNx9n8ISMbsnuKCv/eHKt0NDQ6Z4NSIoMYffTgcRVYZHyIorT4lLz2XnuDbo/AMrhfAmFvzIY7o0M/mgskBecotE/HI2jG96NZPL+FkklrDsciSzOjeudFvlnag0cgpF9HZQLjoaZMKTvC1TAH7RFbdMAYQl59BcAcFz3uFHvL23vxz6Qu4WCRWhAGPd0tusbE10EJcxYcjMK+ZOVBqqQgFaaipoq6ug/p7JtJ6WKlZv/GEGOdVnUBm+TZdCZUk8L18X8ksF6VQp2YUVvi4tNRVKxBJScwrJKypdDOrazITU7EJCkhRL5HmfDrZG1K2lwYmHSRU+doizORKplGMP5GuXmdK+EQXFYvb6lx0n/jEejQ0Z3NqchUcfK9XWoiIUsHq4IyFJOWy+E6Pw9mNcLZngbsm4nfcqnND7P0vjz/OhHLwXX6UGqypCAb8NaMEIFwuGbPLl/ptI+erG2kiHZUMcMNTVoO9aHx48L99jxlRfk/1ftGOAY30Gb/Rjj1/56VVVgfBNmtTleV6k5RbRZdVtLoUo3ur2Voy8PNeLFzlFdFpxi8P34ys0Nq8qVFWEDHZuwO1FHenW3JQpex4wdsc9hdO1KkIgENCxiTEnp7uxergjd6PT6bXGm7XXo8gprF4RB8DGWJc/Bzng/WVHTPQ0mHXwIT1Xe3PiYaJC4ou1kS4/9WuO3+JODGxVj9XXo3BfcoO/rz39xzyMaqjh/wr/zF1zDTX8l5OUVcDuu7GcfpxM/dpafNu7Gd3sTCodf60oTxKzWHP9GT7P0hjhYsHtRR2rzMC2NMJTclh6KYLAuFdM7WDNeHfLKkmPAtnq86lHSfx1MQKLOtocn+ZW6ejykKRsFp8IJrdIxJbRrRX2tQGZiLLlTgyrrz9lnJsVc7s0VkhEuRHxgvlHHtOpqTFbxjjLJT5k5BYx59AjkrMKODHdrcz2DmV4nJDFxN2BdG9uws/9mit9zBaJxMw+GERcej5Hprp+kpqUVyRiwi5Zm9Ou8S5llmfbNzRkfjc1jj5M5I+LEfw2wI76df4jAh26F89e/+ccn+aKcSUNfBVhi3cMSVkFbBnjrNT2a65HYVFXm4FyxmyfeJiESCJleJsGSu3vfXbejWNUOws0VJUTgQpLxNyMeMnMaW5yPV4ikVIkEssl3uQUiGhjKV+Z+4F7z4lMfc3b6ZNQKDP5HuJc8XuUXVBCXhkGnXHp+WVW3qiqCBjvboW+lhrGuhoY62lgrKvJVu8YzA20WNS9aYX7LhKJ8YuWJdlIpHAkMAHPxob0aFG6mBb8xqy44L1UGNU3psra6iq4Wdelq50JHo2Nyq0A01JXoUcLM04GJWFvrty1UyAQMKV9I9beeMawNg3KFZnVVITM79aEPy+Ef9JWVRoaqir8OqAFU/c+oJe9mdyG3F/3bMbQzX7s93/OmDfpdYpQp5Y6G0c5MWyzP44NatNWDlPt95newYbgpGym7HvA3okupZ5X5x8ncexBIo0MtbkSmsL92EyWDHaoEl8ykH0uc7o0xlBXnbE77rF6uOMnvmLvk5VfzO2nafRvJd/1pyzexonv8o1j1LYAvu7ZlDGuDctc/FARCpjduTFtreow59AjfKLSWTrY4V3FZXVRv7YWO8e14dSjJL4+EUxATCbTOlqXmuZXHhZ1tdk+1pmrYS/4+WwYh+8n8Ev/FpW+F5EXLXUVZnS0YaSLBetvPmPghrv0tjdjXldbGtSpusU4gUBmDOzZ2BDf6AxWX4tiq3cMEzys3l3/qhNjPU3mdW3C1PY2HH+YyNobz1hyKYLx7laMcLGQe/+6mmqMc7dijKslt6PS2HU3jg23ohnRpgEDncxppWRFcQ01/C9R43lTw/8Eyva1Pk7IYqt3DFdCX9DFzphJno3+0f7o98fx97Wn+MdkMqqdBZO8Gil8k6IICZn5rL4WJVulsTdjRkebKkmPektwYjY/nQ0l6VUBi3s1rVSCFMiEg5VXn7I/4DmTPRsxvaONUlUr0Wm5LDz6mOyCEpYPaalQ0lBhiZjfzodxPfwli3s2o18r+ao3HjzPZMb+IFpbGvDXIHuFfRrK41JICvv8n9OhiTETPSqOJC+L/GIRU/Y+IKeg5J2HzfvkFokYv/MeaipCto11llvg++N8MAUFJXzTxx4tTTX8o9P5/nQovw1oofCEqzIEJ2YzZLMvBye1U+r8fpqaw4RdgWwf10auvv7CEplp5lc9m1Z6svXsZS691njj81VHpa8JN8JfsMU7hoOT2sl1jIQmZzNssz+PfuharhgolUpp9ctV9kxwqbBNLzW7kPbLbn7SvtSygT6nZ3hUOKZllyN4lV/CHwPtP/md+183WDWsFS5WdSp8nresvBLJi5wilgx2qPCx3lFpfLE78IOxa6mpcGWeV6kTsOWXI9lw6xkaqioUicTY1dPD08aQYw8SOTPLAzMFUrbuPktnzqFH+H3dETUlxbsSsQSvpTf5sW9zelRQfSWRSOmz1odBTvX5wrORXM8/51AQhjoafN/HTu4xPXyeyefb7nFqhrvCXhlvOfEwkT8uhHNulqfCixwFxWKGbfGjtYUBP/S1++C8CE98xZob0Qxv14D2tia8fF3I96dCUFMRsmpYqyoTcN5yKSSFnXfjGOhYn+EuFqU+5kliFqO332NkWwsWdWuCUM42xfIIjMtk+v6HuFnX5Y9B9hVe11/lFbPo2GMEApjiZY2zpfznW2VIe13Iz2fD8I5K5/s+dnzmVF+p77r8YhHrbjzjXmwmLerrM7+b7Qdtrv8Eia/yWXn1KeefpPCFpxUTPRpV6b3XW6RSKX4xMhEnLCWH8e5WTHC3rHbR7S0SiZRr4S/Y5h0r+z5pY8F494Y0qKN4m3h0Wi5nHyez9U4MjU10Ge9uSc8WZnJVStd43tTwv0hN21QN/98hlki5FJLKkE2+jNzqj5GuBtfmt2fD563/ceEmMC6T0dsD+OZkMLamunh/1ZFve9tVm3DzNva7y8rbSKRSDk9pV2Wx3wDpuYV8ffwJQzb74tqoLjcWtqd/K+VutN5yNewFXVfeJjgxm3OzPJjfrYnCwo1YIuVAQDx91vjgZGHAhdmeCgk3Eak59F3rQ1hyDkemuMol3LxNfRq17R5T2zdi3QjHKhNupFIpm29Hs+DIY0a7WvKFZyOl3+Ps/GLGbL9HsUjC/kntPrm5e11YwpjtAWiqqbB9bBuFKrOmeFkjksKfl0JIy8olPiMPo1pqOJhVfTpaWeQXi9hw6xkzOtoodX5LpVK+PRVCLwczuSeZh+/H49jQgL5KtGd9+lwJjHezrNQ14eyTFFo1MJD7GPGPyaSNpUGFVVyJrwrILRJV+L5IpVK+PFZ6m0xwYrZciUrlRYWrqggQlZM2VRpGepq8kLMc/2rYi0+iyIvFEr7YHVhqa0ATU12Gu1iwZoQjT37qzrlZnnzVsxlmtbXwj8lQaJztGtXF2qgW3s+U98yQpfE04kpoaoVtL0KhgK96NOFa2Atey9l28U2vZhy+n4BPlPxjdGpYh/Hulsw/8khpb4uBjvXp2MSYmQceKpzso6WuwtbRrbka/oJ977V9hSVlsflONK0b6uPV2BgAY11NlnzmwLOXucw7/Ehujx956dHCjPldbfn9Qjjrbz4r9TNyMK/NielunH+SwuxDQe88jCqDs2Udzs32IOVNnHhsBT5ABrXU2TrGGddGhozefo/1N5/9I4lORrqarBvpxNLBDiy9FMGYHfeUSmHTVlflyx5N+eszB6JevqbzitucqqSnlKKYG2izcmgrTs1w51V+Ce2X3mT9zWdVnhglEAhwszbk8BRXto5xJjAuE48lN1lxOZLM3PL9jqoCoVBAt+amHJnqyv5J7cjMK6L3Wh9mHnjI44QshZ7L2kiHuV1s8fumM/1a1mPV1ae4L7nB6mtRFXo31VDD/yI14k0N/9+QVyRij18cnVbc4uezoXRpZoLv4s782Ld5tSU3lUVATAYjt/ozbud9WprXZu/Etizu2QxDHfmjcxXh/djv6LRcTk53Z+WwVlgosQpSGiViCdt9Yum37i55RSKuzJVFf5c20Q9JyubMo4r9F1KzC/nxdAgLjz5mbpe3hsSKT/rj0vMYvsWPXb6x7J7Qhu/72Mkt/kilUnb7xjFwvS89W5hyZIqrXKXOOYUlzDv8iNOPktg/qS3j3JWvivmYErGEb04Gs80nlkOTXeneXH4fk4/JyC1i7M572BjrsHuCyyctYDmFJXx3KgRdTTW2jnFW2Lulrq42X/W0Q10g5IczIagJpbjZ1KXoH7xZ/vVcOOm5RUrFggMcf5hEQmYBczrLl/jzurCE1defMdjJvNKr49kFJewPeK6UR89bikUSroW/UMjvxj8mg3ZyVEaFJufQ2FinwvPpQnAqfjEZnwggIBMWjssRSVwilpa50qoiFCg8iTTW1eBljnw3/pdDUz95frFESlxGHr+d/9T/pm/Levwx0J6udiYfnFOejQ3xfqqYCKMiFNCyQW1OBSUrtN3HDHFuwNXwF9wvJwHrLV62RkiksM07Vq7nNtHTZH5XW344HVKhmfP7zOnSGLFEyrqbZUe0l4dAIODXAS3IKxbz18XyTdJLw0Rfi5VDW1Gnlgb5xSI234piw41ntLIw4Iv2jT+4ZtfWVmf/F22JTH3Nl8eeVLlo0bZRXY5McWWXbxw/nw0r1ZvF2kiHk9PdSMoqYNS2ADKrwITXWFeT/V+0pX0TI74/FcyV0PLjxAUCARM8rDgyxZWjgQmM2RHwj3mSdG9uytX57TE30KLH33fYdTdWqc/BxliHfRPb8kMfO/64EM6Irf5EKRg/X1mamenxx0B7toxx5krYCzosu8WBgPgqFwZBJgAfmNSOnePbkJZbhOfSmyy5FFElx488tGpQm7+HO3J+lidGuhqM2OrP0M1+XAt7oZAHkZ6mGhM8rLixoANLP3PgQfwr3JfcYP7hRwoLQjXU8H+ZGvGmhv95UrMLWXIpAre/bnA/9hXzu9py58uOTGlvXe19wO8jlUrxfZbOsM1+fLEnEGfLOvh81ZGF3ZtUS9ksyExTDwTE02HZLa6EvWDLGGd2jXdRKAq7Iryj0ui52puD9+JZ8pkDa0c6lSmGFYnETN4byNzDj8q8WRJLZIJJl5W3yS4o4foCL4a2aaDwRFiW0BNLrzXeNK+nz6kZ7rhYyd+qk5FbxMTdgWy+Hc2u8W2Y362JXH4yYck59FvrQ2Z+CbvGuyhU4VMR2QUljN95n6D4LE7PcFfaBwNk58WwLf7UN9Dml/6fmidnF5QwelsAeUUiNo1y+uT38t6w19bR5OvezenvUI/zT17Q3ESH2trVI1J+zOXQVM49SWbVsFZKeQFl5Rfzx4VwfuxrJ3cE69Y7MdgY69BBzgjs8jhyPwE7M71Kfc53o9PR1VDFQc7nkEik3IvNlEu8CUvOrvBakpVfzNcnnlBShidNkUgilyFsUXmVN2/8ZBTBWFeDl3Ks2sak5Za5uvt27BVNeN/i2diIOwqksbxlkFN9roSlkiunuXNp6GioMqpdQ7bcia7wsQKBgC97NGGbdwwZcq7Sj3FtiIaaityCD8g8c1YObcWWO9FKT7401VTY+LkTRwITOP9EcWNbF6s69HYwY/PNKKJe5DK5fSPGeZQu9NbV0WD/pLYkvirgt3OlCyyVoZmZHiemuXH7aRqzDwWVKoTV1dHg4KR2GOtpMGjD3QqrZeRBVUXIN72aMdKlIfOPPGbJpYgKRQR7c33OzfbESEeDXqu9uf00rdLjkAd9LTX+HOTA1jHO7Lgbx9DNfjx7qbjwIhAI6NuyHtcXtKd5PX36rPXhzwvhchuoVxWu1nU5Nd2NX/o3Z5t3DN1W3eFicEq1VAO1sazDX585sGeiC6HJOXgsucGfF8PlPscrS4M62vzYtzl+X3emYxNjvjkZTJdVtzkQEK9QJZlQKKBjU2P2THDhwmxPdDRVWXo5kkEb7nLmcbLCVXg11PB/jRrxpob/WUKTs5l/+BFey24S9SKXzaNbs2ZEK/q3ql/lPevlIZVK8YlKY8gmP6btf4i7jSE+X3Viflfbaus/fhv7PfNAENu8Y/i5X/Mqjf0GiM/IZ9KeQKbvf8hIFwsuzvHEs3H5E9Ytd2LIyJWt9sw/8viTm9/wlBw+2+jLjruxbBzlxN/DHTHUUbxdJD4jnxFb/dnmE8v2sW34qV9zhdp9fJ+l02O1NxqqQi7O8ZLbn+XI/QQGb/JlkJM5u8a1oW4VVlIlZOYzeKMvqioCjk1zq1T6WXxGPkM2++JkUZs1wx0/qWjIzi9h9PYAjHQ1WP+5E1ofvXchSdl0WSFrZZMHVVVVerSyoE9LE44GJeAbKd9ktzK8yJG18P02oIXS6VtLL0fiYK5foU/IW9JeF7HNJ5avejStdKWVSCxhl28cEzwqFzN+KTiV7i1M5R7PkcB4cgtL5EqQCk3OoXm98kWhH8+EUlRS/s10Zl5xhck3xSJJmddtFaEQcTlR4aVhrKdJRl5RhZPUGxEvy/VWKBFLmXv4kVxtHE4WBuQXi4hQMB66qakeVoY6XAxWXJx4n/FulnhHpctVZeBsWQdX67qsv1mx2AMyAeC3Ac1Zd+OZQi0tdvX0mNWpMQuOPla6FcjSsBYrhrTkq+NP3kW6K4JEIqVEKmVK+0Y4WJTv42Ksq8maEY5cj3jJz2dDq3yS3aCONkenuvI8I5+JuwJLFew01VRYN8KJ7i1MGbjhLvdiFWvFK4teDmacmuHO1bAXjNlxj/QKJvU6GqqsGtaKr3o0Zfq+B/x5Mfwfmzi72Rhyea4XTha1+f5UCOtuRCm1b11NNb7vY8epGe48eP6KoZv9OP8k+R9tpZLFi5txZZ4XX3g24sczoQzY4Ftln+vHtG5Yhz0TXNj3ppLMY8lNfj8f9o+1IOlrqzGtgzU+X3Viegcb9vjF0XHZTVZfi1JYSLIx1uGX/i3YOMqJ3g71WH45Eo8lN1h7ParC47eGGv6vUiPe1PA/x91naYzc6s9nG33R1lDh0hxPto11pl2julXWuiIPUqmUm5EvGbTRl9mHHtGtuQk+X3VkdufG1Vrx837sd4cmRlye50VPe7Mqe+15RSKWXY6g29+3qVtLnZsLOzDBo+Lo78RX+ay5HkWRSIJEKovqPnQ/HpCZR/55MZyBG+7iblOXy3O9KhSCSkMikbLX/zk9V9+hsYkOl+d6KSRYFYsk/HEhnLmHH7Gomy0bPnf6JA67NAqKxSw6+pi/LkWwZbQzszs3rhJDybc8Tshi4Ia7uFrXZZucCVdl8ezla4Zs9qVLMxP+GuTwSfpMVn4xn2/3x0RPkw2ft/4kiSUiNYdR2wOY1amxwhUhA1pb0snWlAMBz9l+K4KCguop25ZIpCw8+pgOTYyVNgwOin/FyYdJ/NyvudznzrobUbjbGNK6YeWrra6Fy6Kpu5WTQFMRIrGEK2Gp9CwjFelj0l4X8cPpMMRSWapSRYQm59CiHJHHJyqd809SKK5gUiWRwqH7CeU+pkQsKVNEUabyxkhHA6kUMipoHTj/JIXCCsSnYpGESXtK9795H3VVIa6N6uIdpXiVwiDH+pwMqrjdtDyM9TQZ6FifLXJGbC/s3oT9Ac9JfCWfGNO6YR36tjTj5wqi1D9milcjdDRUWX45UqHt3qdbc1NGtWvItH0P5K6eyM4t4lHCK5knUw87GpvKdz2TRWi35WrYC/66GFHlE31DHQ0OTm4HwIgt/qSVUuUoFApY3LMZC7vZsuRiJGceV66t7i02xjqcnuGOQS11+q71ISi+fFFVIBAwxLkBp2d6cDsyja+OPVHKj0YZtNRV+La3HV/1bMbZxyn0Xesj94LCxzQz0+PIFFemeDXih9OhjNlxr0qqmhRBVUXIyLYW3FrUgW7NTJhz6BHjd94jPKVq48Xf4mRhwK7xLhya3I6YtDy8lt7k76v/XDS3uqqQwa3NuTjHkxXDWhL4PBP3JTf45mQw0WmKibB6mmpM9LDi5sIO/DHQnntxmbj9dYNfFLwW1VDD/wVqxJsa/uf440IEbtZ18f26M78NsKeRkU7FG1UhUqmUa2Ev6L/+LguPPKZ7c1O8v+zIZC/rKk0a+pjwlBzG77zHpN2BdLUz4faiDgx3saiyKiOpVMrpR0nMPPAQv+gMjk5x46/PHOT26fnmZDDv3+MWiST8ei6cM4+S6Pb3bQLjXnF6hgeLujdVKkkq8VU+35wMZtOtaDaPdua3AfZyt7qArD1i0Ma7+ESlc2BSO4a2sZBr0h6bnsfADXeJSc/j/GwPPBorHl9eHheCUxix1Z8F3WwrFQUOsoqZoZv9GdbGgh/62H0iML3KK2bk1gDq19Zi/UinTybLz17mMmpbABPdrZjkJV8SzccMbmvJ5+0aEpr6miWXw0jLKVD69ZTFjruxxKbn8XP/5kptLxJL+O5UCNM6WNOwrny+UPEZ+Ry6n8Ci7k2U2ufH7Lgbx2jXhpX6vO/FZqIiFMolJhUUixm9PYBisQQBEFbBhCEjt4jUnMJy26YO3HuOSCJFQ1WItroKmmWIL2KJlHOPk8utvCgWlS3eKON5o64qxEBbrVzfm9eFJTxOzCr3eYQCUFMREJH6mutvBLfy8GxsiLcCxr5v6d+qHvdiM0nJrtz5MsmrEacfJ/Mip+IJWlNTPXrZm/H3tSi5n//rns0IfJ4p13vxFlUVISuGtuRK2Aty5DRJLo2F3Wwx1NHg72tPKxRUAmPSmXv0EUsuRvDzuTCFqzYa1NFm/6R2nAhKUuj9kRcdDVV2jGuDo0VtRm0LKFMQGdXOkpmdbfjmRHCZZseKUktDlXUjHJnoYcXIrQHs9X9e4fPaGMv8eHQ1Vem1xlupFjZladWgNmdnedCjhSlDNvvy58Vwpaq4hEIB/VrV58aCDljWrUXP1XdYcSWySsyhFUFbXZUZnWw4P9uTRkY6DFh/l/lHHsktoipKywa12T6uDUenuvLidSFeS2/y89lQua4RVYHMXNmIvRPbcnK6O0UlEnqu9uaL3YHci81U6JhWEQro3MyEvRPbcn6WB5pq/9yCbQ01/FPURIXX8D/B+3GAz2LjsLZs+I+PQSKRciXsBWuuR/HydRFT2zdiZFsLhdp1lCEhM59VV59yPjiFUe0aVnnsN8gm/T+fDSU+M59v3sRkK1LJcyPiBVP2PvjE90IogNraaszv2oSRLhZKVatIpVIO3U/g9/PhDHSsz5c9migkkkmlUo4GJvLz2VBGtrVgYfcmn1SblMWFJyksvxJJp6bGfNWzaZW240mlUjbejmb9jWesHu5Il0pUYIAs2Wz8rvvM6mTDZK9PPR0y84r5fFsAlnW1WTPC8ZPX8jwjj6Gb/Rjc2pxF3ZtWaiwAJSUifjkXikAq5ds+LdCoovMkLFnWerd3oovSUbZ7fOPY6RvHpbmech8Lcw8FoaoiZPmQlkrt831CkrIZsskPv8WdKtVa+f2pEMRSaanx2u8jkUiZtCcQn2fpFIkkqKkI+KZXM8a7l92ydTvyJT+cCeX2oo5lPkYklvDidRGp2YWkZheSkl1AQEwGwUnZGNRS52VOEVn5JYjf3IbsnuBCe9vSK+4Wn3hCK4vaDHP+NEp5zsEgujU3obeCxs4zDzxkcGtzOjQxLvX3F4NlyT5vr1uaqkKkyIRnXQ1VGpvo4GhhgJ2ZHk1MdbEz06vwGhadlkvP1d48+bGbwiL16O0BuFkbMq2Dcubbb5m0J5BGRrVY3LNZhY+Nz8in66rbnJvlQWMT+QzjDwTEs+l2NJfmeKKtgIAuEksqJVaCLFa61xof5nWxZWTb0mO3QxJfseVODG2ta9OrhTnjdt6nsYkuywY7KFyhGvXiNcO2+DPJs1GlP5fSkEik/HIujPPBKewux68uLDmHCbvu097WiN8Gtqiy76J7sZnMOPCQgY71mdfFVi7T+kshKXx57Al9WtbjBwUCAt4ilUq59TSNDrZGCn8ekamv+fL4E3IKSvhrkL3cLc+lEZyYzXenQ8jILeKnvs0r/R2sLO/f441+c49nUE0+iSCzHFhzPYpbkWkMb9OAqR2sMdNXvk1bGV7kFLLLN479/s+xMqzFJK9G9GhuqvD1oSYqvIb/RWrEmxr+J/g3L9ASiZSLIans9YsjNiOPqe2tGeFioVT1iCJk5hWz3SeW7d4x9LI3Y15XW7mSkBQhI7eI5VeecjIokQnuVszoaKNQNQtAYYkYz6U3y+ynVhUK2DrWmY5lTKDKIzmr4J3PwV+fOZQ58SuL7IISvjkZTEBMJiuGtpR7+xKxhL8uRnAkMIEVQ1rSrRKJT6VRLJLw3algbj9NY/vYNrSor7xhLchMpRcdfcLcro0Z3ubTCU1GbhFfn3iCuooKfw9v9cmNf1JWAUM3+dGjhSnf9W5WZS146TkFrL4WSZFYwjQvK6xMKtduVFgiZuHRx1gb6TCvq61Sz/Eyp5A+a334e3gr3Kzlq6IKT8lm0AY/ri1oT/1KeBG9ZeHRR2ioqvB7BaJLeUgkUgZuuMvC7k0qbEH8/XwYe/yeU/Re2083OxO2jHEuc5v1N6OISctjxdBWCo1rm3cMgXGv2DS69btxZuQVk/a6iMYmOmVOOkdvD6CPgxnDSjl+h2/xY0jrBnzWWrHr/ujtAfSyN2OES+mT/L+vPmXtzWc0MNDCwbw2Dub62BrrMPPgQ45MdaOpqeLG71KplMl7Axnjaqlwa+jJoEQ23orm8lyvSp2DD55nMm7HfXwXd5JL6P7hdAh5RSK5P2uJRMq0fQ9oYqrL/G5VU4mmCL7R6XyxO5BjU90+ETuuhyZz9nEyLerrM9HLBoFAwIucQgZt8GWAYz2lhOnQ5GxGbg1gbpfG5QqeyiKVStlwK5pNt6PZOsa5TDPxlOwCxu+8/86rTK+KKn1f5BQw7/BjMvOK2TSqNZaGFVcjJr7KZ/bBIPKKxKwd6YitnMIfyNo3+63zeSeomegp5nsnlkjZeTeWlVefMqxNA+Z3tZXrOC9NPJRIZItDSy9H4NzQgB/62smV0pmUVYCxrkaVLuiEp+Sw9FIEgXGvmNbBmvHuVgonQCq6v7U3orge/pIhzuZM62BTJd9vipBXJOJIYALeUelEpr5mgocVw9o0kLt1vEa8qeF/kZq2qRpqUBKxRNZG1P3vO/x2PozPWptze1FHxrtbVatwk18sYt2NKNovvUlocjYnZ8hiv6tSuCkRS9h5N5aOy2+R9rqIS3O8+LJHU4WFG4C116PIKSi7FF4kkbLo6GPyi+VPeZBKpRy5n0D3VXcw09fk8jwvhYWbwLhMeq32Jr9IxKW5nnJvn5JdwPAt/vhGZ3B2pkeVCzfZ+SWM23mPkKQcTs/wqLRwczk0lcl7HvB1z6alCjfpuUWM3BqAroYaq0sRbl7kFPD5Vn86NjWqUuEGwFBPi6972lFfX4Nll6M4ej+2UmX/Sy5FkPiqgFmdbJR+jt/Oh+NiVUdu4Qbgr4uRTPS0qpIb27TXRfhHZzDOzbJSzxOU8IrY9DzaWZVffXQwIJ5dvnEfCDdAhQbCYcmvsTZWvCU1OasQs9r/mYwJhQKMdDWwq6dX7kSnRFy2YbGqUKhUZLCRjka5Jp1zujQm8tce3FrUkTUjHPnCsxFeTYyxNtZV2odCIBBQt5YGd5RI5+lmZ4KWuiohScr5eryldcM6dLUz4VhgxRHtALM62XAlNLVC/5O3CIUCZnSyYYt3zD/uGwLgZm3IFC9r/rjwn/aZrPxi/r4SzomgZLq3MPsgCtxET5PdE1zYHxDPbt84hffXvJ4+uye4sOVODEcDy/duUgaBQMCMjjZ826sZ43fe51JI6YbvZvpaHJ3qilAgYMhGP5KyqqYl1URPi90TXHC3MaTvOh+uhVXcEmduoM3hKa50bmbMgPV3OSRHotxbjHQ1uDTXC8Na6nRbdYezCvr5qAgFfOHZiItzPMkvEtNt1R1uRrwsd5ujgQm0+/P6J217QqGAkW0tuLGgA2b6Wgza4Mva61GlJoG9JT23iK4rb/PL2VCFxl0Rzcz02DnehS1jnIl6+Zr2y25y8F71xIu/3d+Gz1tzZqYHWfkldFx+i2WXIv4xTyOQtfCNd7diy+jWfNOrGWceJeH653X+vBhOavY/09ZVQw3/bdSINzXUoCAisYSTQYl0XXWbpZciGe9uxa1FHRji3KBaRZsSsYT9Ac9pv+wWV8Nfvov9bmZW8ervi5xCfj0XJteXvF90Or1Xe7PX/zlrRzqxbayzXCttpRGbnsfmOzGfTAw/5nWhSG6zytTsQsbvus+Kq5GsGeHI0sEtFVphFIklrLz6lKn7HjDZqxE7xrWR27fHOyqN3mt8sDaqxcnpbkq/L2URn5HPoI130VJT4ehUV0z1FU/aep9TQUnMO/yI1cNbMcDxU+PetNdFjNjij62pLksHO3yy6pieW8SY7ffp0cKUX/q1qBbD71pa6szp1pyhTvW58zSdTdcjkUjkuxndH/CcQRvuEp+Rj3dUGkfuJygdCw4yg90bES/5vo+d3Nv4Rqfz8PkrJlbRivvBe/FYGenI3aJSFheDU+nW3BS1ctq+fKLS+f50SKkx3hl5xbwsx/MgJDmbFhUkTZVGSnYB9ZQowS8RS8v8XFWEAkrkPGbex0ivfPFGIBCUus9mZnqEpygeT/wWz8ZGSvne1NJQw9qwFqceVd6ctkcLUzbdiS53EvoWI11NxrpZseSS/Oa8Dua1GdzanB/PVH0ikzzM7GSDvpYq92IzZFVDV8JJf13Mt72b0dPh02uhjbEO28e2YcmlCC4okerVqoEsue+nM6GcDJJPFFOU4S4WrB7eivlHHnEgIL7Ux+hqqrF9rDOtLQ34bMNdQpKyqmTfaipCvu9jx5+D7JlzKIjllyMrFEzVVIR82aMpW0Y7s/zKU34/Hy63p5G+lhorh7Xir0H2/HA6hNkHg8jKV8zgvmHdWvz1mT1zuzRm9qEg5h4KIrMUg/IXOYX8cDqUV/klrCjjPqROLXV+HdCCLWOcuRSaSo+/vcsUYH85F0axSMLBewk8TshSaMzy4Gpdl5VDW/Fzv+ZsvRNDt7/vcCkktdrOsyamuqwb6cS5WR4kZRfSeeVtvj7+hPiMf07EUVUR0vtNGtr2sW3eGSzPP/yIsOTqMXSuoYb/VmrEmxpqkJMSsYSjgQl0WXmblVefMsWrETcXdmBkWwu5fTGUQSqVciE4hW6r7rDdO5ZfFIz9lkplyTvbfWLLvOEDWV/11L0PmLznAWPdLLk0R/Fqlo/3+/XxJ0jkuKEoEslikUOTy15RlkqlnHiYyJfHHlOnljpX5ranY1PFWq0SMvMZtsWfC8Ep7J3YlrFulnIJEhKJlNXXopiyV1bBsnRwyyoX6h48f8U3p4LxsjViyxhnpaqc3md/wHO+PRnM5tGtS60Oevm6kBFb/bGrp8eqoS0/maRm5RczalsATUx1WdS96SdeHq8LSwiMy6zUGN+nQ4v6zOncmIgXr9l08yklJRVXYnk/TScoPouuq24zff8Dvu3dDCslBbUikZgfTocwv6ut3GX6UqmUJZcimdrBuko8CIpFEvb6P2dCJYUgqVTWytmznIjzpy9e88We+2WmNGmpqfCwjEqL7IISnmfkyxUn/jHJ2R9W3shLiViCukrp56qaiuKGxSCrvFEmWcXOTK9SCTDuNnV5+uJ1ueJYWQx0qs/pR8mVXm3v0swEHQ1VTgfJJwRNbt+IiNTXColOC7s1ISQpm8uhpVeKVCcqQgGrhzviZWtMLQ1VetrX48f+LahnUPb1oXVDA9YMd2TBkcf4xyge09zGqg6bRrfm25MhXAqpHsPebs1N2TXehb8uhrPlTnSpE3ZVFSG/D2jBjI42DNvsr5B5dEX0cajHqRnuXAhJYdzOe6WKIR/j0diQC7M9iHqZS+813jxSQNDoaW/G5Xle5BWJ6P73HYUr1gQCAcPaWHBtfnvyisV0XXmbs4//EwUulUr58tgTRBIJYomUfQHxRL0oW5h1sjDgzEwPxrlZMuPAQ6bvf/CBiXhgXCYXnqQgkkgRS6XMPfyoWuLTBQLBu/dmoocV358OYdBGXwKUOG7lxdZEl7+HteLiHE+KRBK6rLrNoqOPeZ7xz1XXCQQCXKzqsHWMM5fmeqKlrsKgjXeZdyiIW5Ev/xWhuIYa/mlqxJsaaqiAYpGEQ/fimbH/IetvPmNmp8bcWNCBYW0sykw/qSr8ojOYtu8BP50JZZJnI6Viv888SiYgRjbJ/utSBK8+utnKLxax8kokXVfdRk9LlRsLO/B5u4aVfm27feMIiM38JHJYgMz4U1tdBU01ISpvXouKUMDDMlo1Xr4uZNKeB/xxIYLRrg1ZObSVXBHe73PmcTK91njT1FSXszM95KpYApm30NzDQZwMSuTYVDeGOjdQaL/ycPZxMqO3B9CtmQk/9m3+SXy3omy+Hc1fFyPYPcGlVF+NlzmFjNjij319fVYO/bRSJaewhDE77tGwrjYrhrb8ZDyFJWIm73nAptvRlRrnx9iY1mZ6R2uepuXy7Ykn3HtW/qTj6cvX7wxkc4vE3IxMIztfubSaLbdj0FRTYYyr/Gbnl0JSSc4qYLy7pVL7/JgLwSnoaKhWSjQFCEnKIbugBHeb0lu/0l4XMXKrf7nR1sUiCYFxpZ+PYck51NPXpK6cFWvvk5JVQD0l2suKRWW3TakIBYhKqR6qCGM9zXIrb8qiWSXFm9ra6tib18bnmeLVN27WhqgIUWrb9xEKBUzxsmbznWgkcghfeppqTO9gzZJLEXI9HmSv8+ueTfnlbJhCbbFVxfvXNTdro3Kr0N7Sxc6EH/vaMWlPIJGpin/Gno2NWDPckXmHH1fYqqMsLlZ1ODylHSceJvHTmdBSPw+BQMBoV0uWDm7JrINB7PWLq7L9NzbR5fQMd3Q0VOm71ocnFSSygexc2zmuDZ+3bcjwLX5svi3fcQdgrKvJtrHOzOtiy7R9D1hxJVLh48lET5Mto1vzc//msvupPQ9IzS7kQnAqvtHp/6k+lEr5+kRwuSKAilDAWDdLbizogKaqCl1W3Gbz7WgKikUsPPr4nZAslcp8+bZ5xyo0VkVQUxHyeduG3F7Ugc5NjZm4O5AJu+4TocSxKy/WRjqsGtaKS3M8kUih66o7LDjy+B9vkWxkpMPvA+25+1UnmtfXZ8GRx/T425ujgQlyVRTWUMP/VWrEmxpqKIMikZh9/s/puPwWW71j6ONgxrX57Rnc2rxKTehKIyw5h3E77zF5TyAuVnW5tUhW4aPofjNyi/j2VAjFb1Z+RBIpSy5FALIVpzOPk+m84jbez9I5PNmVpYNbYqSr+ITsfaRSKSeDEvnpbBggi+Q109fEwVyfHs1NmehhxYJuTfhzkD07x7lwZb4XwT914+lvPRntavnJc51+lES3VXfQVlfh6jwvutop5jGTWyS7ofrhdAjLh7Tk94H2cpv8PYx/Re813uhoqHFmlke5scjKIJVKWXcjisUnglk/0okxlfQ5kT3fMzbfieHgpHalpi29zClk+FZ/WprXZvmQT4WZvCIRE3bep04t9VJTp8QSKXMPPaKgRMzq4Y6VGm9pNKlXhz8HtMTWRIedd5+z584ziku5UZdKpSS+Knjv33A7Mo2OK27hG63YxDY+I58Nt6L5fWALuVuuRGIJyy5HMqdz4ypJlJNKZSabY10bKpW69j4XQ1Lo2NS41OqwwhJZJHhWfsknwur7iKVSfKNLX8UNTc7GTomWqWKRhLTcIiXbpsrxvFERIlKmbUpHg5dKiDdNTXVlbWVKVO28xdNGuchwFaGAAa3qczIoSel9v6W/Yz1yi0Rcl1NkGONqSWZeMecVaCsa7GSOWW0t1t54puwwFUZmXP6ItdejlFqJH+5iITMf3nVfqbjkLnYmLB/SkhkHHip8LZKXZmb6bB3jjHdUOrMPBZU5We3tYMbeiS6suhbFb+fC5BZMKkJXU40NnzvxhacVo7ff40BAxZ42QqGAqe2tOTipHXv9nzNu1325xVOBQMBwFwsuzPHEPyaD3mt85PZgev85+jjU49r89uhpqtJ/rQ8Ljj76oG1ULJWlTMlTLWakq8HKYa3YMa4NJx4mMWiDL0lZBbz/LhSJJKy8GlntPjHa6qrM7NSYO192xLJuLRYcecyCI4+rzPeoNBoZ6bBiaEuuzPVCKIBhm/xYeOQx0Wm51bbP0qiro8EXno24+3UnxrlbsvF2NB5LbrL+5jOyCxRrtauhhv8LVG+GcQ01/B+ksETM4fsJbLwVjZ6WKl/3bEove7NKV0PIQ0JmPiuvPuXCm0jIVUNbVaod45uTwRS/d1NXLJJw9EEiHjaG7PF7TmxGHot7NmVAq/qVnjCCLE76u1MhRKa+Zulge3q3MKOWkokX6blFfH8qhIDYTP4caE9PezOFnyM4MYtZB4Mw09fi0hwvuT1kpFIpu33jWHIpkgXdbJnoYVXlfi/FIgmLTwTjG53OkSmulRaGpFIpv54LJzAuk8OT29LY5NPnS80uZN7hIBwbGLB0sEOpFTWT9gSiripk06jWn7QDSqVSvj0ZzLO0XI5Oca10a1dZaGmq8UUHWxyevWS3XyyqakJGujb64DEvXxd9UjlSLJaQmVfMmO33GOtmyZc9Ko59l0ql/HAmhAGO9XG0kD/t6khgIlJgWJuqqcR6GJ9FTFoegytZ2SWVSrkUksrC7qWn/Dx7mUtMWh5CgQB1VUG51TdPX7ymWCT5pAovJCmbFvUVP15f5BSiIhAoJRCXiKXlGBYLymz/Kg/jN543UqlUofO7loYqDetoE57yGmNd5XypPBsbMuNAEBKJVOFr70Cn+gxYf5fcIpHcqSuloaGqwgR3KzbdjqarHDHImmoqzO3SmBVXIunRwlSuxQShUMAv/ZszaIMvnzmZY6OEybUiFJeI+eFkMAVFJfjHZiC5LmVOF8WT5ya4WxGR8prxO+9zZKqrwu9zbwczCt5UKO6e0IbWDcs3DleGBnW0OTrVlfG77jNxVyCbRrcudZytG9bhxDQ3xu+6T+KrAlYNa1UlKUUCgYDx7lY0NdVj1sGHBMW/4tcBLSpsKXa0MODCHE++ORFMz9XerBrWUu7ktYZ1a3FositbvWMYuTWASZ5WzOrcWKGFLYNa6qwc1orhW/zwj/m09bdYLOG7UyF0aFK6AP4xbRvVZcc4Z9ovu1XqdUgqhYVHH3Nocrtq8Y17nzq11Pmhr927e8nOK24xul1DpneovnhxS8NaLBvSkucZeWy8FU3P1d70bGHKrE422BhXzrtNETTVVBjhYsEw5wbcjHzJVu8Y/j79z4nGNdTwT1FTeVNDDW8oKBaz3ScWr6UyB/8f+tpxaY4XfVvWq3bhJjOvmF/OhtFl5W0EAri+oD3f9bGr1JftldBUbkS8pPijdgKxRMqXx5/QykKfmws7MMjJvNLCTYlYwvqbz+jxtzcN62pzbUF7hjpbKC3cXHiSTLdVd2Sv402rmCJIJFI23opm3M77jGxrwb4v2sot3OQWiZh5MIiNt6PZO9GFLzwbVfkNV1Z+MaO3BxD5IodTM9wrLdyIJVK+Ph7M1fBU1n/uVKpwI0vJ8sPGRLdU4aZIJGbqvgcUiyRsHeNc6k3rssuR3Hmaxp4JLtV2I/g+LjbGfN6uIcuvPGXq3vs8ev6fVexnL3Ip67AVSaTs839Oz9XePHtZvrGsWCLFvr4+X/WQP9K4oFjM39eesrBbkyqrwtt5N5YhzvJHoJbF0xe5JGcX0KFJ6ZOhFvX1Cf65G/sntWVmRxscLWqj9sZLRu0jTxmBAMJKaQ8KSc5Ryqw4KasAEz1Npa6ndWqpfTK+t+hrqSFU4hw10tWgSCSR20T1fSrbOuVoYUBBsYiIVMWNj5ua6mFlqMNFJYx1P2ZEWwuepr6W27/qszffF0cUSFVqXk+fxT2byuV/piwSiYRLTxKZtPseya/yWT64FT/1bc5W71il3ieBQMAfg+ypU0udWQceKuUxNLi1OV/1bMrkPYFVZhz8MXV1NDg4qR0CAYzY4k96bumVLJaGtTgxzY2MvCJGbC37ccrgal2Xc7M8iU7L5bONvnIZ2eppqrF2hCOLutsyZe8DNt56Jrc3jMqbCp7j09y4EvaCgRvulutTUxq3Il+W2RYKshCFDTfln/j/dj6csi5BIomUoPgsTj+qfLWcvDSoo82qYa04Ps2Npy9y8Vp2kw23nlFQXH3tRDKDaAeuz2+Ptroqvdb4MPPAQ54q+NlUFqFQQOdmJhya7MqGz1v/o/uuoYZ/ghrx5r+c/Px8li1bhouLC3Xq1EFHR4dmzZqxcOFC4uPLNp+Vl1u3biEQCOT6/6effqrw+UQiEZs3b8bLywsjIyO0tLSwsbFh6tSphIWFVXq81UF+sYgtd6IZvsWPkw8T+XVACy7M9qSXvVmVVKNUtO+dd2Npv/QmcRl5nJrhzsqhrTA3qFzsd3ZBCYuOPSk1RQZkYouDee1KTxRBZrQ7cqs/18JesO8LF34bYF9q+tN275gKb+pe5RUz62AQhwMT+alfczZ87iR3EtRbUrMLGbU9gEP349k+rg2Tvazlniw+ffGafut8yMov5vxsz1LbjipLXEYegzb4oqupxpEprnKb45ZFsUjC7ENBPIh/xdEpbqVGxidnyeLN21rV5edSPHVKxBIWHn2ClpoKO8a3KbWiZpt3DAfvxbNnYlulPEuUpZ21CdcWdMS0lgYqwv+Myzc6vdy2nyKRhLj0PHr87c25cqJmVVWELOjWhNra8otRh+7H49TQgF72VRMTn5JVwNWwF4x1k99vpyyuhqXS3tao3FYuDVUV2ljWYXbnxpyc7s7xqW40MNBiegfrd2KOuqosfvtjH6r8YhF1a6krZVacklWAlaFy17bEV4Vl+nAVlUjIV2JSoquhio66CmmvFS+td7Gqo5Th8FvUVWXpKRVFspfFIMeqaZ3S01Tj83YN2Sinf5WqipBF3ZtwPfyFQhPBce5W2FYyQa0sXmTl8cf5MK6EvMDL1ohdX7RDS0uNxia6rBjakkXHnhCphEimpiJkwygnkrIKlE7NGt2uIXO7NmH09ntKjUEeammosn1sG6wMazF4o2+ZLToGtdTZO7EtDepo8+2JYJ69rLr2FlN9TQ5NdqWNZR36rvORy+/nrZnw6RnunH6UzNDNfgq1F9nV0+P0THfcbQzpt+4u231i5WoLyy0SseDI43Kr9YpEEjbejibxVcXj8Y1O52rYizLvt+BtNU+owolZleVtjP3mUa25FJJKh+XVGy8OMuHoz0H23FzYgdraavRd68OM/Q+r1YenLOT1Nqyhhv9L1Ig3/8VER0fj5OTEl19+yf3793n16hV5eXlERESwYsUKHBwcuHDhwr89zHdkZGTg4eHB1KlT8fb2Jj09ncLCQqKjo9m8eTNOTk7s2LHj3x7mO3KLRGy49QyPJTc5/ySF2Z0bc2amO92bm1a7aPN+7Pe5JylsG+vMjnFtquyL5sfToRSUY+hXIpbyw+nQSq3C5BSW8P2pEEZtC6BDE2MOT3EtszTcLzqDX8+HM3XfgzJTYa6GvaDrqjsUFItYNtiBfi3rKVzxciU0lZ6r72Cqr8n52Z60alBb7m1PP0pi4Pq79LE3Y8+EtgqLRvIQGJfJiC3+9HYwY/Po1pX2SikskVXLxKXncXhyu1Kri5LeCDeujery5yD7T45tsUTKgiOPiXrxmj8HlS68nX6UyN/Xotg13qXa2x4+RigUUEdHg58GOWD/3ueZW1SxYaWaihANVWGVVs69yitm5dWnjHFtWGUVWfsCntOzhSkN61Y+ev7s42T6OChWqRaUkIWVkQ7zujbh5HR3Qn7uzv4v2jKvqy2tG37YShaekkN0Wq5SMfYpOYXUqaXceVUilqAqLMvzRqDUZEQgEGCgo66UabG5gbZSnjXv07yevtJJTP1ampFTUEJyFXhajHezJPFVvtzVCz2am5KeW8wu37hK77sy5OSXsO32M347H46aAL7r35yJXjYf+FZ1b27KtPaN+PlsKNkFildY6WmqsXO8C1fCXrDVO0apcY5u15BxblZ8vi2g2kxd1VWF/D2sFR2aGPPFnvuElZHcqKmmwuphLbEx0eGzjb5KpWqVN4af+jXnl/7NmXngIauuPpVLTGlsoiurQDXTo9cab84/kb9SSkNVhcU9m7F7ggs778bw5fEnFfq8/HE+XK7vD6kUfjgdWu5jikWSN2lV8qRqivnpzL+ziOlmY8jpGe780Kc55x4n03O1d7XGiwPUr63FbwNkIk5dHXV+ORPG1L0PaqK9a6ihktSIN/+l5Obm0qdPHyIjIwGYNGkS169fx9fXl99//x0dHR2ys7MZMmQIT548qZJ97tixg+Dg4DL/nz59epnbisViBg0aREBAAACDBg3i4sWLBAQEsGbNGoyNjSkqKmLy5Mlcvny5SsarLDmFJay7EYXHkhtcDXvByqEtOTXDnc7NTBCWMTmoKj6I/faJ5df+LTg21ZW2jeSL/ZYH76g0zj1J/qRd6mPy3ohXiiKVSrkYnEKXFbeJSc/l4hxPZnS0KXNVXCKR8t2pYACi03LZcufDG+DsghLmH3nE/COPWNyzKVvHOGOsYDVKQbGY704Fs+DIY37q15yVQ1vJXVVUWCLmm5PB7PCJZd3nTszv1qRa2uROP0pi9PZ7TO9ow4Iq2EdukYjxO++TU1DCgUntSk3+SXyVz/AtfrjbGPLHwE+FG4lEFucempzNvi/allp9ciPiBX9eiGTLaCdaKiCGVTeltfO8RV1FiLqKkIkeVvh901kpv6Sy2HDrGU4WBrhZl57kpCiFJWIOBMRXSYpZTFousen5dGhirNB2/jEZtGv0H+H1bWXOrE6NP/nMQ5JyaF5PXynhKjmrQKmYcHgTFa5a+j5VhcpFhYMsySZNiRYSu3p6xKTnUViivADuZWvEvbhMpUR0E30tDGqpc6acqjL5n0sTxwYGbL4jnzghEAj4qkdTNt56pnS6W2UpEYlZdS2cZxm5jG7XkC97N6dOrdKPrWkdbNBQFbLgyCOlDHvr19Zi57g2rL4WpZCw8D6zO9vwWev6fL7VX65qDmUQCgX82NeOwU4NGLbFv8zYaKFQyKLuTVncsynjd97nVBVUcL1P/1b1OT7djYfxr5i0N1CuahNNNRV+H2jP0s8cWHziCYtPBCt0XrhY1eHCbC9UBAJ6/H2Hk0GJpQoTz17mcvBevFzXC5FEyq3Il9wtJ9ntZFAiia8KUFcRUtEVsUQsC2BQNO68qhAIBPR2MGPXBBfGulny3SlZvPi9WPlaJpWlXm0tfunfgpXDWmGqr8mgjXfftBKWLjDWUEMN5VNjWPxfyvLly4mIkKUCLV26lEWLFr37naurKx07dsTLy4v8/Hzmzp3LjRs3Kr1PKysrWrRoodS2e/fu5c4dmUfJ9OnTWb9+/bvfubi40LNnT1q3bk1OTg6zZs0iLCwMVdV/9vDLypetFO7wiaWJqS7rRjjhblO32g3k3uIbnc6SS5GkZBUwr6stQ1qby51sIy95RSLmHHok5yqQhI23ohnWpoHcbVrJWQX8cDqEh/FZfNe7GQMd61f4/h1/mPguFeht8kKXZsY0NtHlVuRLvj4ejK2pLlfmeWGmRApNREoOsw4GoaupyoU5nqW2DZVFQmY+0/c/RCiA9Z87VbpdrTSkUilrbzxj650YNo5yUnhiXRpZ+cXMOPAQFaGA7eNcSq3gScjMZ8RWfzo0MeKXfi0+EW6kUik/ngnlXlwmR6a4llppFBiXycwDQSwb3BI3m8rFV1c1pa1gqwhkN6ifta7PvK62SpvJlkVSVgF7/Z9zYpp7lT3nmUfJGOtq4mpdeQH3Ykgqno0N0VXAa0oikRIQm8kkr0YVPxhZ0pQyZsUAKVmFtC/Di6ciROUZFqsIy21ZKA8jHQ2l2p/q6WtSS12FqBe52Jsr7v8DYFlXG2NdDQJiM5S6Lgx0rM/m2zFM8aq8L9ckr0b0XO3Ngm62cl2H3W0McTCvzaY70XzVo2ml9q0MZx8lIRZL+a6nHTpa5bc8CoUC/h7mSN91Pmy49YyZnRorvL8W9fVZM8KRLXdiMNXXUNiAWCAQ8HWPphQWixm5NYCjUyvfMlvWfiZ5NUJXU5Xxu+6zalgrujcvvb1zuIsF9WprMWP/QxIy85nZyabK7oeamuqx/nMnFhx5TJ+1Pmwa1ZoW9Ss+T3ram2Fvrs+cQ4/ov96HtSOcaGIqX7udnpYaSwY70MXOhK+PP+Fq2At+H2D/gT+buYEWK4a2JPFVAQmv8nmekU9yVgHpuUUUlkhQEQpQf3OdKSwRI5HCuJ33CPy2M/ran35HdmxizJLP7MnMKyEjt4iXr4t4kVNIRm4RWQUl5BSK3pnCCwW8e74T090VqgyuStRUhIxq15CBjvXZ4RPLhF33aWtVhy97NJX7vVYGU31NfurXnOkdrNl0O4bBm3zxsDFkdufGOJjXrrb91lDD/xo14s1/ISUlJaxevRqAZs2asWDBgk8e4+rqysSJE9m8eTM3b97kwYMHtG797xlzLVu2DAADA4N3f38fGxsbFi9ezOLFi4mKiuL06dN89tln/8jYXuUVs+NuLLvuxtGxqTGbRzvTrlGdf0y0CUvOYc2NKO4+S2dqe2smuFtVSdLDx0ilUgZv8iUz78NVLjWhABUVwTtDT4lUikgsRSSR/X8zMo3R7cr32hBLpBwOjOf3c+H0tJdFpteRw7A2v1jEb+fDKXov0UYskTJ13wOcLQ04/ySV73o3Y1ibBgp/Hm8TodbceMZ4N0umdbBWSAy7EfGCeYcf079VPb7t3azCVCJlKBKJWXw8GP+YDI5Oc6WpaeXb4tJeFzF6ewCOFrX5sW/zUo2FEzLzmLL3AZ2aGvNzv+afvLdSqZQ/LoRzI+Ilh6e0K3USEZGaw8TdgXzTqxm9FWzDqUqevXzNrcg0vvD8j7hQWCImPffD41wogE5Njfm2tx2WhpVvPyqNVVef0qO5aZVFxkulUnbcjWWcu2WVXI8uhqQwzs1KoW2iXuZSWCLGXo6JFcgqb2Z1slFmeCRlFSgl0EqlUorFkjLPb1WhgAIlK2CMdDWUqrwRCATY1dMjLCVbafFGIBDg2diIO0/TlRJvujc35duTIYSnvK70MWltpEPHJkZs947luz52cm2zqHsThm/xZ5ybZbUIER9TJBKjKhCgoiKkv6M5XexMKhRu3qKvrcbGUU4M2eSHg3ltvGwVFxE7NzMhOauASXsecGKam8LXGYFAwI99m5Nf/ITPtwVweHLpFZNVwXAXCwxqqTPv8CN+6GPHcBeLUh/nZWvEkamuTNh1n/jMfP4YZF9lJux6mmpsHtWaTXeiGbLJj5/62TGsTenjeB9zA20OT27H39eiGLD+Lr8NbMEgORaK3tLVzgRHCy8Wnwim2993WDrYgY5vzi9NNRUGOZmXul1ukYjU7AKSswpJyS4gJbuQe7GZBMZl0nONN8sGt8Ld5sOKS2M9zQpfU2GJmFf5xWTkFpOYmc/xh0mM2OLPAMf6fNm9yT9i/l8atTRUmdW5MSPbWrDu5jP6rfOhb8t6zOtqS/1q9LUz1tPkh752TO3QiK13Yhi22Z92jeowt4vtf1V1bw01/LdSI978F3Lr1i2ysrIAGDt2bJmtPOPGjWPz5s0AnDhx4l8Tb6Kiot6ZEQ8bNgxt7dKrF8aNG8fixYsB2XirW7zJyC1im08se3zjcGpowPZxbXCxqnoD2rJ4G9V4MSSFmR1t+HOgfbV9SYen5PDTmVAiU19joK2GnZkedXU0qKujTm0tdfS1VNHTUkNfS+3dn/paauhpqqGpVv6NWkhSNotPBKMiFLBldGvc5Yz0BNhwM/qTtgKJFKLT8tBSU+HSXE+lql0ycotYdOwJESk5bBrVWqHPVSSWsOraU3bdjeOPQfb0b1Vf4f3Lw6u8Yqbse0BhiZhTM9wVbgUrjaSsAkZvC8DBXJ9f+rco9SY7ITOf4VsC6NeqHl92b1LqDe+qq085/SiZI1NcS33/EzLzGbP9HhM9rBhVgbBXnRSWiJl5IOiTiW1cxn+qblSFAiwMNLGorYG5nhqaZbTWVJaI1BzOPk7m2vz2VfacAbGZpOYUMqAKjsGEzHwiU1/TtVnFkc/v4xedjrNlHbkmbEUiMU9fvJZrBb00UrILqadE29TbFoey0qZUVQSIipSsvNHV+OB4UgRZ4lTlTGjb2xqy4spTpbatpaFKjxamnAxKxK6efIJLeUxtb82obQHM6tQYfe2Kq7daNqhNx6ZGrLkexe8D7Su9//Lwj3rJH5ciaF6/9rtrn14plRDl0byePr/2b8HsQ0Gcm+Wh1HfPaFdLnmfkM37XfU5Mc1P4O10oFPDXZw7MPfyI0dsDODCpnUJm6YrQvbkpO8e1YdKeQNJzi5jRsfTKmmZmepya4c74nfcZv/M+Gz53Qk9LuaTIjxEKBUzvYENL89rMOhhEUHwWP/UrfdHhfVRVhCzs3gSPxnWZe+gx18Nf8OcgB/TlHJehjgZbRrfm6INEZh0IerdIU57PnI6GKjbGup/EW0skUvYFPGfynkD6ONTjm97N5B4HyAQjM30tzPS1aFFfnx72ZsRn5PPT2VA6rbjFVz2aMtS5QbV7LZZFXR0NfuzbnAnuVqy4EsmXxx5jZ6ZXrfHiIGtZ/ba3HVPaW7PVO4ZvTwZTV0eDOV0a42RhUPET1FDD/6fUeN78F+Lt7f3u7+3blz1RcHZ2plYt2cqPj49PtY+rLOQdr6mpKba2tkD1jjcjt4g/L4TjufQmYck57JnYlr0T2/5jwk1GbhE/nw2ly8rbCAUCrs1vz8xOjavlS/BVXjHfnQpmwPq7tGpQm8c/diPoh27sn9SONSMc+bFvc+Z0acw4dysGOZnjaGFAUPwrGhvrYKKniZa6SpmrWXlFIn47F8bgTb50bGLEocntFBJuUrIL2Hwn+oOqm/eJSH1NTkHFpoEfc+dpGj1We6OpJuTiHC+FPldZ1co9Loe+4NQM92oTbmLT85h1MAgDbTUOTW5XJcJNbHoeQzf50c66LiuHtip1sh2fkc+wzX50a25SpnCz5U40NyPSODCpbakrx+m5ssqeni1Mla6wqCp+Ox+GppoKC7rZfvDzff7PAZkXxZ4JLtxY1IlVw51QEQrxi64eP4FllyIZ2dZCoba8ith5N5bhbSyqpBLvYkgKrtaGck2638c/JvMDv5vyeJqai7a6CuYGiq/K5haJyC4ooZ4SlTdvW6LUy6y8ESqdnmKsq6GUYTHIJr2VNd90tTYkJj2PlGzljIcHONbn9KNkpT1/3sfRwoAW9fXZF/Bc7m0WdGvCsQeJ1WbECxAUm8ZO3zgGtKzHk4SsT3zTFOGz1ub0cTBj+v6HSvsVfdOrGU1MdJm8N1Cp51ARClg5tCWtG9Zh3M77cpnnKkvbRnU5PMWVPX7P+elMaJmePyZ6mhyZ6krDutoM2eRboemvorjbGHJulgfhqa8Zskn+VKl2jQw5N9uD/GIxvVZ78zBe/nQ2gUDAUOcGXJzjydPU18w+GKTQ9m8RCgWMcbXk8jwvUnMK6bryNjfCXyj8PO9jUVeb7WOdWTq4JWtvRDHz4MN/3QOmQR1t/h7uyDe9mv1j8eIgE9remk7b1dNj9LYARm8PIDCuer14aqjh/yo14s1/IeHh4e/+3rRp2b3kqqqqWFtbf7KNsnzzzTeYm5ujrq6OgYEBjo6OzJs3j6dPy18VlHe87/8+ISGBvLzqudn7bKMvz17mcmBSO3ZPcPkkLaW6yC8WsfZ6FO2X3SI+I5/TM91ZMbRltfioiMQSjj1IoMPyWyS9KuDiHE8W92pWpteFRCLl4L14Oq24xb3YzApjdW9GvKTbqjs8Ssji7EwP5ndrUuFK2cf8fr78Y1IskTLjwMN3/eAVUSQS8/v5MKbte8Cibk1YP9JJoYnq/bhMpu17gImeJqdnuNO4mmJr78VmMnCDTEzb+HnlE6VAVvUxZJMfvR3M+H3Ap/41AM8z8hi2xY8eLcz4oY9dqcLNDp9Y1t+M5q/B9p+sLgK8Lixh7I57OJjLWrL+qdbC0rgYnMKZR8msHeH4gVCVnV/C5ZBUerYwweerjri9KWM30NXi2372DGxd9ZVCjxOyCIjNZGbHqhOzEjLzuRmRxmjXqhnvheBUerVQLLpc5neTQTs5DdNDkrNpUV85s+KUrAI01YTUVlBcAlnMLlBu25RIWc+bSog3dmZ6hKfmVCqxRV9LjZbm+ng/VS65yt26LlJknmpVwdQO1uy8Gyu3KGFtpMNAx/qsvRFVJft/H7+oVL49GcR3Z0Jxb1yXCV42rBnhyPqbzyr1er/vY4dQIODXc8ol/wiFAlYNa0WxWMqiY0+UMkFWUxHybe9m6GqqMmHX/WqdIDcz0+P4NDcCYjL58Uxomd+5Ohqq/NyvOc6WdRiw/m6Viwn1amtxZEo7WjbQZ/ahIG7LadxrqKPBjrFtGOdmyedbA9h0O1qh97xBHW0OTW6Hi1UdRm71Z/nlSLnvO97H3ECbXePb8FWPJvx+IZwZ+x8qfe0AmbjU1c6EK/Pa08hQh8GbfPnxdIhSqWhVSWnx4oeqOV4cZBVAX/Vois9XnXAw12fczvt8vs2/2g2Va6jh/xo14s1/IQkJCQDUqlWL2rVrl/vYBg1kCSVpaWkUFSn/JQLg5+dHUlISJSUlZGVl8ejRI/7++2+aNWvGTz/9VOYN6tvxApibl95L/PF4pVIpiYmJco8tMTGx3P9TUv6TALFpVGu2j2vzj5nBlYglHAtMwGvpLW5EvmT7WGe2j2tTJf4mpeEXnUGftT5s845l1dCW7BzvQiOjsuObQ5KyGbTRl/U3n7F8cEu2jW1DrTKSmF6+LmTGgYfMORTEjI42HJniqpTI8SQxi0shqeWaiEqRGSCvvlZxy0BMWi6DNvjiF5PBmVkeDFXAI0cqlbL1Tgxjtt+jX6t6rBrWsszXX1lOBiUydsc9vuzelIXdm1RJGfTjhCyGb/FnrGtDFvdsWurrjkvPY9hmf3rbm/F9n2alPuZAQDyrrj5lzwQXmtf7tO2lsETMV8ef0MiwFsuHtPzXSrhBJmx8dfwJf33m8EGli1Qq5dtTwbSor8+Gz1t/8jrf/7dEIuHr44/ZeCOChLTKVUfY19fn1Ay3KvWnOBmUROdmxlXiLZD0Kp+QpGy62inWMhX1UtYCJa/fzfOMPFoqaSz58nURHWyNlRJ+SkRi2lgaUFZHnL62mtKVjSa6mpgqWRnX2ESH2lpq7wzZlcWrsZFSFQEgE7T6t6zHySpKDOpga4ShjganH8mfYrWoexO+7dWsSvYP8Cj2JX+dC2a/fzxWdWqxbYwzY9xkC1XWxros7tmUhUcek1Oo3CRXQ1WF9f+PvbOObuNat/iWzJzEsYMOmdkxxY6dOMzMzMzcMLZhZmZmdmwnMcbMzMzMJDjvD9W9aWrNiNLb1+vfWlmv7/ro6EgajWb2+b69Z/REdE4FngZl0T+gGRRkpXB9jjXCs8pwwi1BpDnkZaRwdbY1QICl90PQwP55Ao5WG0XcX9QL4VnlWHCbf7WPtBQTv44zwSLH7ph6xQ9fxKww+RE5aSn8Os4Uc+y6Yfn9EJz9kiSQEMNk8oyYHy+xw8OATMy9FSiUcCIlxcSSvtp4tcIBn+MKMOHSNyQVCN/yyDPE18LjJfYAAxh8yhMvQppPthIUJTlpbBqqj49r+iC1uAYDT3iIPack+D5e/LJnCoae9oJLzM+NFweA1kqy2DzUAD6/9IdVl9ZYeDsI06768U1Pa6GF/zVaxJt/IFVVvB8UZWX+N+RNNLVNAbx4cVHo0KEDVq5ciUePHiEgIAAhISF49eoVFixYABkZGXC5XOzbtw87duygXK8gaxZ1vVpaWpT/bG1t/xhr0OHniCY/QgjB+8hcDD7piach2fhtvAleLu8t0djv78kuq8XKB6FYfDcY43t2wttVjhhA4W9RUcfCnjfRfzj6u613wiA+N3dcLsGDgAysfRQOBoDPG50wo1cXkW7gCSHY8Spa4MSri54pfHf4CCF4EpSJyVf80F9fEy+W94Y2hVD1I5X1LCy7H4Lbvul4tMQOc+wlYwzb3DpPuSVi9+sYXJlthRm96E0ZBSEwrRTzbgVizQBdrB6o2+za04p5FTdNPf3NjXkRko3fPsTi5nybZg0BOVyCdY/DkVtejyOTzPjGvv8dsDhcrHkchtHmHTHih4jvD5F5iM+vwtFJ5rSf48PALGSU1MI7qQi/vo/BYz/RWy2YTEazlUqiUtvIxnXvVMxz6CaR+Vxi8jHStIPQ4pJvCu9iWFCDUr/UUhh0EO19yCqtFbk9hM0FgtLLIMvHVLyBxRW57aitihw8EotE2omXk5aCoqw0ZWy9IPTR08CnmHyRW5/G9+yEtKIa1DaK337DYDCwsr8OLrgnCbwenr+a+MJmdU09jnyIxnn3VMjJMLFhqD4WOemhQ+s/n/Nn2XWFTjsV7H0TI/JzdWqtiC3DDLDnbYzIFSYaKnK4Nc8G9/wy8DxYdBHoxjxrVNSxsPphGFg/sbqhrYocHi2xAwDMuOaPEj5G3QwGA0udtHF0kjlWPwrDPb90gZ+jqp6FzBL6lqjxlp3wfFlvPA/JxqK7wQJHzptrtcL7NY5QU5DB8DPe8BOyAsuwgyrerHKAo44Gxpz/hhs+aSJVTmmoyOHCDEscmWiGI5/iMfdWkNgR8D00lHF3gS32jTHBMZcETL3ij/h88c4t4tIUL+62wQnzHLrjwPtYzL0ViKC/oaWplaIsNgzRh88vA9BXty2W3AvBlCt+8E0u/q8LWy208N+kRbz5B1Jfz4stlZWl30mUk/vPBVNdnfAXrzY2NsjIyMD58+cxbdo02NrawtLSEuPGjcONGzfg4+MDNTXeruzhw4cRHh7Od72CrFnc9f5T8E0uxtgL33DgfSyWOWnj4aJeGGrc/qcIA/UsDk5/TsTgk16Ql5HC141OWOqkzfcGmxCCt+G5GHjCEylFNfiwpg82DdXn66uRWFCFKVf8cNE9BUv69sD5GZZiRSy/Dstp9mKYyQAUZKSgICMFJgNgAGijJAvTTmrN7jhW1LJ4MdUuiTg1xQKbhuoLlQgVk1uB0ed8UM/i4v1qx59WidXA5mDD0wg8D8nG8+W9RUoxaQ73hELMuxWI3aONscCx+QSh1KJqzLkZgPE9O2Mrn6qcD5F52PUmGtfmWMOm21+9TQgh2Pk6CslF1bg1z0YibV7icNItEXWNHOz6IfEmu6wW215GYeswfWioUN8oZpXWwiUmHyv66eDh0j6Y1qszPJOKcMktBo2N/92SdAB4EZoDrTaKsG3m8xCFT9EFsBbB08s/tUTgiHI2h4v4vMpmq7YEIbeiHu3VRDuvNLK5kGYy+IrJ0lKit021VZYFg8HzehIFww4qiBNTvDHvrAYulyBKRBHBqKMqahrZcI2RTJXEMJP24HB5Pkp/F3ml1TjkHIeyqgbsH2uE9UON0UOz+WONwWDg2CQzfIkvxMco0dfooNMWqwboYPmDEIHFgx/R0VTBtTnWOOgcD+8k0fy2VORlcGe+DTJLa7HxaYRE/Iv4oSwnjRvzrNGljSIm0XjPjDTrgHsLbXHSLREHP8YJJHI4R+djzAUf+KXQV0kYdVTFu1WOYAAYfd4HMbmCHf+q8jI4N70nto/Qx6I7wTj6KV4o0UtOWgpbhxvg7kJb3PZNw6wbASJ7/Aw1bg+3DU7oqCaPYae9cdcvXSQxqIkmseTzRidYdGmFsee/4YRrAqpErDKTFDJSTMy26wqXtX1h3bUN5t8KwqI7QUjIF8+wXRDUFGWwor8uvH/pD0edtlj+IBRTrvjBO6moRcRp4X+SFvFGDNhsNhgMhtj/bt++/ad55eV5F7iNjY3NPOuf+b5VSkFB+PJ7JSUlyMjw9yCwtbXFhQsXAPBu8pr++3ua1gvQr1nU9WZlZVH+CwwMFHgucYjJrcCcm4FYej8Ew006wGNTf0yz7SJURLWgEELwMTIPA094wj2+EA8X98KJKeaU5reJBVWYdtUfT4IzsXeMEe4ttOVbqVLP4uC4SwLGnPeBZdfWcNvQF/0NhI+r/Z6o7ApseBaBpp9TJVkp6GgoYZChJpb07YFdo4xwdY4V3Df1Q+JvwxG6azDernKEVdc/33gGppVi+Bkv1LE4+LSuj9CCyNOgLEy+7IeJlp1xa57NT0tMKKtpxOzrgUgtqsarlb2h314y1Rkfo/Kw4n4ojkw0w/iezZsqJxdWY9pVf0yz6YJfhjVvTuwWW4BNzyJwYYblH94wP3LcNQGeCUW4u8D2vxZZ2oR3UhGisitwfkbPP3kscbgEG55GYJR5RwwyovZ1IYRg+6sodG6tgD6/Hzf9jbSwoE93JBfXYeuLMDwLSBLo/Poz4HIJbn9Lw3yH7hIRewsr6xGaWYahxsK1TPH8bkphL2ClYGpxDZgMBrqLGMOeV16HjqKKNxwuZXWQNJMhUKVfs4+VYkJdSQ6FYpgWiyveSEsx4ajbFl4CeoD8CIPBwPienfFSQq1TMlJMLO7THZc8Un76zVFZZT0ufYnEgXcxUJBlYtNIQ3RUp6+ebacqj4PjTbH9VRQKK+tpx/NjuZM29NupYMPTcJFvunv1UMeuUYZYcT9U5EqJVoqyuL+oF2JyK7D9ZRS43J9XgSMnLYWz03qir25bTLzkS7lmq65t8GqFA9xiC7D/fSytF9IUay1sHWaABbeD8DAgk3YtaooyuDbHGpOtOmPyZT+8CBGsnZ7BYGCCpRZer3TAl7hCTLvqL3Tli023NnBe2xedWylg49NwvAwVrVVJTUEGhyea4cpsK1z3TsP6p+FILhStEr4JZTlpbB9hiHerHZFVWouBJzzxNiJXqPWJIyLxQ0leGmsG6sJzcz9otVHEmPM+2PwsArkSNrhuDlV5GawZqAufX/rDSU8Dqx+FYeIlX3gmtog4LfyPQVoQGRaLRcCz7hDr361bt/40b69evQgAoqSkRLuGkSNH/jFPfX39T3udampqBADR1dX9y9+nTp36xxqKiooo51q5cuUfY+Pj4yW2xqysrD/mzcrKkti8TWQUV5M1D0OI/s6P5LcPsaSspkHiz/E9cXkVZNoVPzLvVgB5GpRJOBwu5fjqehY5+CGW6O/8SA68iyFV9SzK8d+SiojT0a9k9DlvEpVdLvZ6G1gccsI1gejv/EjWPAwlIRklpLKuUeh5WGzePAY7ncktn1TC5VK/7h+pa2STfW+jid3Bz8Q7kfpYFJfUomoy4eI3sv5xGKltYEts3qdBmcRwlzP5EpfPd0xSQSWx/tWNHP0Ux/c98kwoJPaHPhPnqFy+81z3TiUW+1xIUkGV2OsWl8LKemJ1wI08Ccz8y98ueSQTp6NfSTXNcU0IIc+Cs4jtb26kvPavx19tbQO555NMVtzxJWvv+ZMH3+JISkEJYbMl9/nR4ZFQSKwOuJJ6lmSe845vGply2Vfox8XkVBCjXc6kkc0RaPyLkCwy4eI3oZ+niVnX/cnDgAyRHhubW0FM93zi+/eHARlk9o0AUZdGhp/2Ip+i80R6rFdiIelz5KvIz93Eo4AMsd7fnLJaor3tAymoqBN7LYQQUtvAJj33uxKvxEKJzNcc5bWNJLukiux5Hkzco0T73V73OIzMvRkg9G/Fn9ZR00j6HPlKzn1JFHkOQgg57ZZI7A9+JvlifAZ55XVkyZ0gsudNtFivSRC4XC45+zmRmO75RAJSSyjHllbXk6mXfcn4Cz6kuIr+WtM/pZj03O9K9ryJJiwBzzEeCYXEfJ8LOfwxVqjzY10jm2x7GUlM93yi/L2jwjUmn1gdcCXL7weT0mrRr+9qGljk6Kd4YrDTmZz/miTw+ZUKLpdLXodlE+tf3cj0q34kqaBSoMed/5pEFt0JIunF1WKvgR8ZxTVk7aNQor/zIzn4N1wbf09VPYtccE8iFvtcyJwb/uRrXMFfvjM/+96ghRb+G/x36+P/nyMtLS2RlKcOHf7s69C5c2cEBASgpqYG5eXllKbFTWbBGhoaf2pJkiTS0tLQ09NDUFAQcnL+urP3vUlxdnY22rZtfocf+M96GQwGrbnxP4GS6gac+5qMR4GZmGvfDV829pOIwSg/ymsbcdItEU+DszDHvhtWD9DhmyAF8KoMnKPzceB9LDq3VsDrlQ6URsmlNQ349X0cXGLysXGIPub27gYpMY1p4/IqsfFpBLiE4MXy3iK3VWSV1mDdkwhU1rHwckVvGArpXZReXIPlD0KhKCuFF8t7o+NP/JwC00qx5F4wplpr4ZdhBhIz9739LQ3HXRNxfa41ems3/z1KKqjC9GsBmG6rhQ2D9Zqt3vBPLcGy+yE4MtEMw0w6NDMLr73tpGsCHiy2g46m4D5CPwMul2DD03DYa6tjsvWfzwsxuRU4/TkRjxbb0RpNF1U14MD7WBybZAY1hb9+bxQUZDHLQRvjLTrhTWQOQtNL8TG6CDbdNbF2sL5EXxM/bn1Lw4xeXYVqAaTiY1TeX7yBBMEvtQQ23dsI7HcTk1sJ446i+4nlltehg4iVNywOl9KHSYrJAEeMSgVNVfEqbzJLa1FVz6I8V9PRV08DO17zkmaaO3bp6NhKATbd2uBtRC4W9ekh8jqaUJCVwlz7brjkkYI+upJpBf2Ro5/iYdpJDXsnWok8x94xxhj2u2nsJGstkeZQU5TBpVmWmHTJD+ZarUR+vWsG6iCztBYL7wThyRJ7kYzx26vJY+coI0y54gdFWSlsGUad4CkODAYDqwfqQl1ZDifcErDIsQdf0/PWSnK4vcAWG59GYOIlX9yab0tZhderhzrerHTAojvBmHcrSKB0SCc9Dbxf7YjtL6Mw5Yo/Ls20FOh3XF5GCgfHm8JBuy02P4/Et+QS7BhpKFRC5mCjdujZpS+2vYzCkNNeODrJDP31ha9EVpSVxuah+hhkqIlfXkTifWQejk0yg4mApvDNwWAwMNaiE/obaOK0WxJGnfPBvN7dsWagDmWb81QbLWSX1WLoaS8scOiOlf11JB7W0EWdFy8enVOBoy4JWHY/FE56Gpjv0E3ohFJhUZaTxop+Ophr3w2vQnOw6VkEOrdWwJqBuhhgIJo5fgst/L/gv60etfBXdu3a9YdS7Ofnx3cci8UiSkpKBADp27fvT12TtbU1AUAUFRX/8rcbN278sd5Hjx5RzqOnp0cAkC5dukh0fZJW16vrWeTM50RivPsTWXg7kMTnCbbTISpsDpfc9Usn5vtcyNybASSlkL4SIrWomsy67k+sDriS58FZlLt0XC6XPA/OIhb7XMiOl5Ekp6xW7DWz2Bxy1TOFGO1yJsdd4kkDS/QdpjfhOcT6Vzfy6/sYkapYnKNyicmeT+TAuxiJ7HRR8So0mxjsdCYP/EWrIuDH+a9JxGyvCwnNKOU7Jj6vklgdcCUnXBP4ft4hGaXEePenZitYmvBMKCS2v7r91F11YbjkkUwcj3whFT9Ua9U1ssngkx7kpGuCQPOseBBCVjwIEeq5v4QlkZmXPcgjz1hSXV0j1GOFJbmwiuju+EgKKiVTHVFYWU+0t30Qaad/4e0gctkjWeDxUy77Uh5TVHC5XGK4y5kk5It2Hg1OLyF2Bz/z/fvL0CwyWYTqoya2PIsgJ1xErwS1/tWNBKVRVy4IwqATHuRjpGiVA4QQ8iQok4w44yX2OpoorW4ghrucSXhmmcTm/J5vSUXEePcnsauF/JKLiNEuZ5JWJF6FwZOgTOJw6AvJKRX9PNDA4pBpV/zIgluBhE1TMUtFcmEVsTrgKnY1kKA4R+USg53OtN9xDodLDn6IJRb7XEhwOv0xX1XPIgtvB5L+x9wFuq4hhHfe3/oigvTc70p8koSroM0sqSFjzvuQoac8SbIIFaVcLpc8Ccokxrs/kW0vIwWq9uRHA4tDTrnxKpIPfYwjdY2SqbaMyakgEy9+I/YHeZW1dBVakVnlZOLFb8T2NzfyKjT7p1Z0fUsqIqPOepNev30mjwMzBK66kgQ1DSxy1TOFWB1wJSPPehGX6DySmZnZUnnTwr+OFs+bfyCOjo5//LenpyffccHBwaipqQEAODg4/LT1sNlsJCby4pw7duz4l78Lut78/Pw/5vmZ6xUHFoeLe37pcDrmAc/EItyab4Prc20k5mXSHP6pJRh51hs3vFNxcoo5btNEf9ezODjpmoD5twLRva0Svmzsh4lWnfnuMqQV12DWjQAcdYnHoQmmODDOROyqlKSCKky45IsnwVl4vMQOG4foi5RQVN3AxqZnEdj9Jhq/jTPBjpFGfI2Vm4PF4eLX97HY/CwSRyeaYecoI4ErCYSFEIIzn5Ow63W0RBOlCCG45JGCmz5peLzEDj27tG52XHx+JWZc88csu658K26icyow72YgtgzTxxSb5nehQzLKsOx+CHaPNvppO+rCEJZZhjOfk3BuuiVUf6hcOPopAQqy0lg1QId2HteYfHxLLsbe0cZCPf8ACx1Mt+4Gn/QKrH8YhCNvvyA9PV2oOQTljm86Rpp2EMsQ/HtcY/NhodUK7YSMuuZwCQLTSmAnoN8NIQSxeZUwErHyprKOjdpGjsiVNw1s6sobaSZTLJNXcSpvAMn43gC86hsvEU1vAWC4SXskF1YjUYQI5OZorSSLaTZdcNkzRSLz/Uhvnbbop6+Bgx/Fq2C2026LydZa2PRMPLPfKdZaGGLcDisehomUPgYAstJMXJ5thYzSWux/FyOyF4e2hjLuL+qF6z5puOGTJtIcwjDMpANuzrPBgfexlF5HTCYD20YYYsMQfcy+EYgPkdSG0cpy0rgy2xpDjNthx6togXyd5GWkcGiCGbYOM8CiO8G46JEs8Puo1UYRz5fZY5RpB4y98A3PgrOE+gwYDAamWGvBeW0fJBdUY8RZb4RkiJasJCvNxLpBeniz0hF+qSUYccYbgWnipzQZdVTF06X2WD9YD+e+JmPhnWCkFdfwHW/aWQ3Pltlj+whDHHaOx6TLfojKFs0cnY6mePGdowxx0SMFw854w/VviBcHeFVPi/v2gPeWARjfszN2vI7GnJt/jx9mCy38nbSIN/9A+vXr90fC0507d/ie9L43Oh4/fvxPW8/jx49RWcm7MHVycvrL3/X09GBoaAgAePr0KWprmzeN+7vWKwpcLoFzdB4Gn/TEHb8MHBxvgufL7JtN55EUOeV12PYyEovvBGFcz05wWd8XAwyoTUe/xBVg8ClPeCYV49x0S+wfa8K3xL6RzcX5r0kYccYb2hrKcNvghGEmHcQqJeVwCa54pmDM+W+w11bH+9WOMO3cSqS5IrLKMeqsN3LK6vBpbV8MMaY2ov2R/Ip6TL/qD5/kYrxd7YjhIrSOCEoDm4ONTyPwNDhLoolSXC7BrjfRuOeXjmfL7Pm2isXnVWLmNX/M7d0N6wbpNTsmsaAKs28EYNUAHcyx78Z3zILbQdg63AAjzf4qxP7dVNazsOZxGNYN0v1LGlh1AxveSUU4PdWCVpCrrGdh15to7BppRJtE1Rwjrbri+BQLWHdVRWx6PdY9icHlL6LHEDcHIQQZJbWYL6F4cABwjsoX6bhPyK+EVhtFgdugskrrUM/iQK+daCJ2TnktlOWkRW4rYnG4UKJoD5BmMiBO56KmihwKxDC9Neyggtg88QWTvnoa8EoUPQZXRV4Gg43a4WWoZIyLAWBRn+5IKapGarHwBqwvfXww9dJnfIjgH6O9c6QR3GIL4J9Kn05ExS/DDFBS04jr3qlizbNlmAHYXC5++xAr8hxqCjK4Nc8GUTkVuOuXIfI8Bu1VcXeBLU67JdKa//qnluCiR7LIzwUA9trqeLzUDjd80vDrB+p0qdl2XXF+Rk/88iIS17xSKY9ZKSYDW4cbYopNZyy7H4Jb39IEOsan2Gjh2TJ7PAzIxNJ7IagUMHFJRoqJVQN1cX5GTxx2jseGpxGobmAL9NgmtNoo4tESO8yw7YKDH+Nx3CVBZEFPv70KXi7vjRm9uuCYSzx2vo4SOz2KyWRgsrUWHizqhU6tFDD8jBdOuibwNZRuar36stEJ9j3UMf2qH/a+jRE5ZY9ubaPMOuLzBifMte+K7a+iMOmyH4L/hnhxgNfyudCxO7y39Mcos593XdhCC/81/iv1Pi3Q8n3r1NGjR//yd19fXyItLU0AECcnp2bnSEtL+2OO5saUlpYSd3d3ynUEBASQVq1aEQCEwWCQoKCgZsd93zq1cuXKv/w9OTmZqKqqEgBEW1ubsFiil6I2hzhtUz5JRWT0OW8y67o/eRKY+dPLPOsa2eS0WyIx2OlM1j8JI/nl9CXjWaU1ZNGdIGK214U88M+gNTAOSishg096kKGnPEkIRRuOMDQZ9PY75k6C00Wfk8PhkkseyUR/50dywT1JpNJyn6QiYnfwM9n0NFxipcj8KKtpIAtuB5DR57wl1u5CCK/tbP3jMOJ09CvJoijTj8mpIBb7XMhN71S+Y1IKq4jVATdy2o1/iX1WaQ3p9dtngVuQfjZcLpesfBBCZt8I4Hs80x3nTRz7FEfm3wqUSDk4m80mN928iWukZNviJE1JdQMZccaLZJcJ3+Jx1TOFzL8VKPB456hcsuxusNDP08SX2Hwy+pzo7TxuMflk2Gn+j3eNyRerXcglOo+MOuct8uM/ROaSRXcEfz/5UdfAIoNOeJDE/AqR5/BIKCCzrvkL/N0RhA1PwskvzyOEesz6X94TvV/ek7En3pMV94Ioz/NXPJPJ4JMeYre8hmSUEoOdzmK3OWeW1BCzvS7kdVi2WPOEZZYRw13OIpthNxGYVkKMdjmTl6H8r23i8yqJ5X5XcspN/PN7enE16Xv0K1n3OIz2M4nMKidTLvuSPW+iBfotD8koJVYH3MjWFxECt1qXVjeQOTcCSL9j7iQuV7iAhYKKOjL9qh/pd8xd5HCG2NwKMvSUJxl51oskitj62UR6cTWZftWP2B38TL7GFYg11/dEZpWTMed9iMPhL8Qthn/YQRMZJdVkyd0gYrL7E7nmlfJT282r61nktFsiMdrlTLa9iBT7PRSGFsPiFv6NtIg3/1AqKyv/8IcBQJYsWUK+fv1K/Pz8yMGDB4mysjIBQBQUFEhYWFizc9CJN01/NzMzI7t37yZv3rwhgYGBJCQkhLx69YosWLCAyMjI/DHH5s2b+a6XzWYTBweHP8ZOnDiRfPr0iQQEBJBz584RTU1NAoAwmUzy8eNHCb1L/0GUE3RUdjmZdd2fmO75RC55JP90EYDL5ZIPkbmk96EvZPQ5b4FElXoWm5z/mkQMdzmTzc/CaVMeymsbyVHnOKK/gyeMSOIHmcPhkhveqcRwlzPZ+zZarGSl/Io6MuOaH+l79CsJ+8FHoSlRgepz4HB46RiGu5zJy5Cf/0OcVlRN+h9zJ9teREo0UaqexSZL7gaRISc9KQWhqOxyYr7PhZz/msR3TEZxNXE6+pUc+sg/eaq4qp70P+ZOdr6K+ukJJoLyKCCDzL8VQAorxUvJ80spJoa7nEnGT0zU+CfyMCCDjD3vI9Jj598KJFc9UwQef/RTHNn8LFyk5yKEkAf+4qVBfYzMJWMoxJWvcQVkyElPkecPyywjVgfcRH58Yn4l0d/5USyPkybm3Agg1ymEWjpYbA6xOiC8VwgVSQWVRHfHR5JHs9HwY2rb7t3vST2LTXof+kKeB/M/XzeyOWTQCQ9yzUvwY5IfR5zjyIgzXmJ5sBFCyJe4fGIkhk9TE85RecRIAr5B3olFZNoVX0pPpIR8nieaJAT6wsp6Mvy0F5lzw5/W9yWrtIYMPOFBFt4OJDUN9BtzOWW1ZORZLzL5sq9AyVWE8HwBT39OIH2OfBVaVGNzuOTcF96G2U0RUiwJ4f1mH/oYRwx2OpPr3qliiaNcLpc8DswgJns+kbWPQkmJGOlW38PhcMkD/wxivs+FLLwdSDJL6IV978QiMvikBxlw3J14JPxcD7yiynqy50000dvxkWx+Fk5yy8X3XqSjRbxp4d9Ii3jzDyYpKYno6uryjRhXVVUl79694/t4QcUbun9SUlJk7969tD94RUVFxMbGhu88srKy5OrVq+K+Lc0izAk6o7iGrH74e7Thx1hSXiN8pLWwNEV/99zvQk64xgv0w++bXEz6H3Mnw0570RoDcrlc8j4il1j/6kZmXfcn6WIaNzaRUVxDVj0MIU5HvxK/lGKx5nKNySe9fvtMdr2OajbK3DuxiHT95T1Z/ySs2ceXVjeQuTcDSN+jX0l0jvjx5nQEpZUQi30u5Nf3MRK5KWuipoFFZl33J2POeVPGakZllxOzvS7kojt/U9nc8lrieOQLOfYpnu/3s6qeRUaf8yYrHoRI9HWIQ1JBJTHc5Uw8xbxYrGtkk37H3CVy0/f/jVnX/YUSYJpgsTnEePcnoXah59wIIHd804R+riaOu8STLc+Eq9z4ntdh2WTSJf4x2l6JhWTAcXeR588tryXdtr4XWexmsTlEb8dHkiSCQeqP3PBOFUvoIoSQ/e9iyPrHYWKv5XuW3A0i+9/FNPu31Kw8csY5jCy48Jlk5P/1t+plaBbpfegLpTD/LZlnXixOzDYhvJvsoac8xTKgbuK4Szzpf8ydVNaJd41wzSuFWB1wE+hmmorPsfnEYKczZcVGogQFnIq6RrLleQQZe96HNj67vKaRTL3iK3CFam0Dm6y4H0IcDn8hcXmCV5p9jSsgZntdyJ430UILdIFpPOPzhbeDRI4DD0wrIY5HvpDpV/1ItpjBD/kVdWTRnSDSc78reROeI7GNlZLqBrLlWQRPrPJOpY1dZ7E55JZPKjHdwwvoENf4m4704uq/7Rq8Rbxp4d9Ii+fNPxgdHR2EhYXhyJEjsLa2RqtWraCoqAh9fX2sX78ekZGRGDVqlMjzd+zYEc+ePcOGDRvg6OiI7t27Q0VFBTIyMmjbti0cHBywY8cOJCcnY8+ePbReKW3btoWvry8uXrwIR0dHqKurQ15eHj169MDixYsRGhqKxYsXi7xecSmqqsfetzEYfMoT8jJMfN3YD9uGG9LGV4pDeW0jjrvEY+z5bzDuqAK9diq46pVK2WecX1GPVQ9DseZxGGbbd8W7VQ6w6srfeye7rBYL7wRj95to7BhhiLsLbNGVIsJTEAghuO+fgeFnvKCmIIP3qx0FNjf9kXoWB7teR2PDk3BsG2GA/WNNoNxMXOVRl3gAwLuIXDwL/rNHQlhmGUae9Ya8tBTerXYUOY5cUN6E52DOzUBsHKKPHSONxI5Tb6KynoU5NwLRwObi/qJeaKUo2+y4qOwKzLwegJX9tbG8n3azY4qqGjDzWgAcddpi45DmDYzrWWysvB8CVXkZnJxiLrHXIQ71LA5WPQzDHPtuYnsHnfuaBFV5acx36C6h1QmOX1IeknPL/vbnBYDSmkb4pZRguKlwPlEAEJ1bCSYDfP2VmkPcmPC8inq0F9GsGOD5d1H5HkkxGWCLYVTbVpnnkySq/4O0FBMG7VUQKwHTYid9DfinlqCusXnvCkGYaNkZztH5Qvt8ULFqgC6+xhf8yXckPKMQvzzwx553sUgtqkVvXUUoMP+67rHmnaCmIIO7ful85++t3Rb9DTRx5nOiWOuUk5bCySkWuOqViqgc8UxZ1w3SQ8dWCvjlRaRYhqsLHbtjhGl7zL8dhIo60b1OBhq2w/HJ5lj5MBS+ycXNjtFtp4JHi+3wICATJ90SxVq3qrwM9o0xRntVeUy+4ofc8jq+Y9UUZXBngS16tFXChIu+SC6k9oBSkJXC+Rk9MdlKC5Mu+cI9vlCgNfU30MS7VY4ITCvF9Gv+yK8Q3KvKplsbOK/tg3aqchh5VjTzYN4cfaHVWhHDTnvhTViOyO9xO1V5XJ1thQNjTbD/XQwW3w1GHsV7LChtlGRxZJIZ7i+yxduIXAw95QVPCqNoaSkm5jl0h/umftBUlcewM144/zVJoPNHYFop7vsL5+vUVV0JZ6f3xPNlvRGbW4k+R7/iimcKX7+eFlpo4Qf+u9pRCy1IBip1vaqeRU65JZCe+13J6ochYpdBC0JT9LfFPhey4UkYSSqoIh8ic4nu9o9EZ9sHsvzeX/0jGtkccs0rhRjv/kTWPAqljU9l/T7e6PeWKlF3kn4ku6yWzLzmT+wPfibeieKV3sflVZDBJz3IuAs+lLuO/inFRGf7B9L1l/ek6y/vic72DyQ2t4JwuVxy+1saMdjpTK55pfz0lh8ul9eWZbL7E3GPl1w/OiG83bA1j0LJ3JsBlC1Y4ZllxHTPJ8pqkpLqBjLkpCdZ9ziMbzUNm8Mly+8HkxX3Q5qtdPpvset1FBl73kfslr7Y3Aqiv/MjickR3R9EHPY98ycrb/n+V9rQHgVkkDEitkxddE8mi+40713WHAUVdaTb1vdiRebOvOZPHgeK7iH0wD+DzKGoRglMKyG9D30ReX5CCLE64PaXVk5h+OV5BDnsHCfWGgjhnYMcj3whX8U8/ww77UWeBokW7c6P73fkU/PLyeJrPmTrA38SlErf5uWZUEjM9rpQ7rLnldcR870uxF/MKk9CCLnunUIGnvAQux26uKqeDDzuQe77pYs1D4vNIfNvBZLpV/3Ebul6FpxFjHY5U1bkJhVUEqsDbuSEa4LY5yg2h0u2vogk9gc/k6QC6usnLpdLjrvEE7O9LgJX67rG8FrLzn9NEnitdY1ssvFpOLE64Ep8k4U7XrhcLrnlk0oMdjqTs58TRa5IdY3JJ9Ou+JFl94LFbn0qrW4gB97HEJPdnwTyNRQUNod3DWWy5xNZdi+Y5AhQLRSdU05W3A8mNr+6kefBWXzXUtfIJta/upFuv7wXqy3QK7GQjDjjRcac8yZPAjMlWiHcUnnTwr+RlsqbFv61NLK5uOuXjn7H3OGTVIyrs61wdrqlyIkpghKQWoJR53xw3TsVxyeb4/hkc2ioyGHbyyg0crhgcQlcYwvgm/KfnbPAtFKMPueDx0FZuDrHCmem9YQmRfxvZHY5xl38hoeBmbgxzwZHJ5mjtVLzVRyCQgjB06AsDDvlhY6t5PFpfV846rYVea47vukYf8EXw4zb49lSe2i1UeQ7/phLAtic/+xecbgE828FYs2jUFz0SMbdhbZY1KeHWElZdDSyudj0LBIPAzPxdJk9+ulrSmzugsp6TL3iBxaHiyuzrPjGoUdkl2PWjQCsHaSHRX16NDumoo6FOTcD0ENDCccmmTVbTUMIwe430YjPr8KBcc1XOv03cInJx6uwHJyb3lOsSHcOl2Dri0gscOgucny1uKweYoqwvCqMPv0VB96E4UVgKsorm0/akzQfovIwUoSqGwDwSy2BvRBVdNG5FejRVglKYhxDuRV1aK+mIPLjG9kcyqhwXuWNaEkwTbRTFS9xyqijKmJzxa+8YTAYcNLTgGeC6JHhADDRspNEU6cAQIqwcc87GXtehWHMeR8wZKRxaEYvWHenr3zrq6cB005qlIlI7dXksdRJG3vexoDNEe/znGvfDUpy0jjhmiDWPOrKcjg2yQy/fohDkBhpOdJSTJyb3hMVdSyxIsQBYJJVZ2wdYYh5t4IQzae6SEdTBY+X9IJnQiHOfkkS6/mkmAwcHG+CiVadMfmyH8Iy+VccMhgMbByij+0jDDD/VhA+ROTSzj/YqD2eLrPHA/8MrHsSLlAFhryMFI5NMsOGwfpYcDuINvHqxzXOc+iOZ8vs8TIsB7OuB4j03R9s1A7nZ/QEh0sw9LSXwNVDzdFaSRY7Rxrh3IyeuOCejBnX/ZFOEf8tKFJMBub27oavG/tBQVYKg0964rJnCmVylnFHNZyfYYldo4xw3DUBEy/7IiKr/C/jrnqmoLKOBTCANY/CRE7j6qOrgXerHLHUSRvn3ZMx7LQX3GIL/pZ48RZa+P9Ii3jTwr8OLpfgbUQuBp/yxD2/DByaYIZny+xh/RNjvwEgt7wOqx6GYsHtIIwx7wjX9X0x0LAdGAwGfvsQh7rvLkjYXIItzyORV1GHjU8jMO9WIMZadMLHNX3QW5u/YFLTwMb+d7E48D4WAw3awXltH5Hbmb4nv6IOC24H4YRbAs5O74mjk8yhKmKsb0l1AxbfDcZlzxTcnm+DDUP0IU1xox6aWYbwrHJ8/zPNJUB+ZQOCM8rxfrXjT41sB3jtbVueRyKlqAqvVzoI1VJCR1ZpLSZf9oOFViucndYTcjLNCzehmWWYdT0AO0YYYqFj8zdD1Q1szLsViHYq8jgzrSff9/XU5yR8iSvEvYW90EZMUU9S5JTXYcvzSBwcb0op5AnCbd90VNazsWagroRW9x+KqhoQkkHfDtVaVRFfNg7A1mEmaKMoBd+UEmx7FYlD7yPxJTIL1dWiCwFUlDW1TJkIH4HK4nARnF4Ke23BzxkxOZVitSkSQpBfUY8OYrRNsTgEshTnEBkm80/iryi0U5VHoTjiTQdVibRNAYCTnia8KNocBGGsRScEZ5Qiu0w8QbG4ohavQzKw720EfvsQh5i8CnRXk8WDxXa4MreXUHNtHW6AO37pyKFoDVng2A0NbC4eBVJHY9MhLcXEicnmuO+fKVJ7zPf07Noa20YYYOWDUBRViR6trCQnjRtzrRGeXY7zX8WL9Z5t1xVrBuhi9o0AJOQ336Kko6mCE1PMcc8/EydcxWuhahJl1gzUxazrAZRtOAAw1aYLrsy2wuFP8bjgnkz73MYd1fBmlSOyy+ow9YqfQGIKg8HAjF5d8HiJHV6FZWPTM+EiwU06qeHdakd0UJPHiDPecE8QXnxRV5bDldlW2DJUH6sfhWH7qyjUiNGu2E9fEy7r+0K/nQqGn/HGVa8UsYVMANBQkcPJKRa4Nd8Wr0JzMOKsN74l8/8MGQwGRpt3xJeNTuij0xZTr/ph87OIP47/vIo6nHdPQQObC0KA/Mp6nP2SJPL6mEwGRph2wOcNTphl1xVbX0Ri8t8YL95CC/+faBFvWvjXMf92IA59jMPKfjpwXtsHg43a/dSKjbpGDs59ScKgk56QlWLi66Z+WN5PG3LSvJv0kIxSvAzN/suuRH5FPaZf9UdNAxtuG5ywvJ825e7yl7gCDDnlhejcChyaYIb1g/X+eA5RIYTgVVg2lt0PRStFGbiuc0J/g79WnDSyufBLKaGdzyepGGPOf0NbZTl8WtsXvQQQlo65JIDL58KupKYRb8Lpd+7EIaOkBhMu+qK6gY0Hi3qhHUXFk7AkF1Zh0mVfDDDQxJGJZnzFlpCMMsy9EYjNQ/UxzbZLs2NqG9hYfCcISrLSuDDTku+xcsc3HXf90nFvoS06tRK92kGSsNgcrH8cjmHG7THavKNYc2WX1eKiexIOTTCFPB8hTBwuuCfjsmeKQGPlZaXhaNgOKweb4fg0ayzo3RXKcjJ4F52PdU/DcNpNvF3/5nCNzYdxR1WRBLCY3ErISTOhL0T1YXRuhVh+N5X1bNQ2csQSbxo5XMpzo7SUeJ43QFPljeg35gYdVFFU1SDWzX0T9trqyCqrRWaJ6MKLhooc+uhq4JWI1Tffkorwy7Mw7HwTBf/UYnRqJY8Ng3RweIoV5g0whlkX4TcNTDqpYahxe1xy5y9cyElLYfdoIxx3TURpTaNIa29CR1MZm4bqY9OzCLFuqAGeWGLXQx2rH4WKdTPdXk0BxyaZ46pXKt6Ei1cZtbhvD8zr3R173kYjjU+VBq8Cxw5PgrNw3DVB7GqG+Q7dcXCCKZbdC4FzVB7l2L56Grgy2xr3/DKw7WUUWDTvm4aKHB4u7gW9dioYc96n2WqP5jDXaoV7C3uhoLIBY8/70PrtfI+ynDROTrXA9hGGWPUgFAc/xqFBSO8VBoOBydZacF7bB8mF1Rhx1lugDQCqNe0ba4K7C23xOCgLEy75Ik5CwrBt9zZ4v8YR02y0cNkzFWsehVGK1oqy0tgwRB9u651Q3cDGgOMeuOqVgj1vYkC+23JrYHNx2TNF7HXKSjMxt3c3eG7pDwedtph7MxCL7wYjqUDwz7SFFv7ttIg3LfzrGGzYDu6b+mGKjRZlxYe4EELwKToPQ097ITKnAvcW9sLJqRZ/uvlvZHOx/klEszcWbC5Bdlkddo82orzJLqisx4oHIVj/JBxrBurg8WI76Ggqi73+oqoGLL0Xgt8+xGF5P22cmtqTr3nzXb90TL/mD5eY/Gb/3sjm4tDHOCy9F4w1A3VwaIKpQEbQ0TkVCEorBb/7rkY2F4ed42kvhES9IA1OL8X4i77ob6CJK7OtoCRHvebEgiq+Zeo/Ep1TgSlX/DHVWgt7RhuByccsODi9FPNuBmLLcAPMse/W7JgGNgdL74egQysFXJ1jxVe0eBOeg6Of4nFzng10f3J7oDCc+5qMtiqy2DPGSKx5CCHY/ioao807SaTi7Eeyy2rxKDATm4boC/1YBoMBG90OWD3YEMen9ISDTluEZpZLfI3B6aWYbK0l0mMttFrhy8Z+fI/F5uBwCUw6iV55U1BRD0edtlARsZIPAOSkmZTij4wUE6ZirBEAdDSUwRGj9UpZThr99DSQkC/+TZaynDR+G28KORnxfr+m22ghJKMMXCGFrdC0IjzwT0fX1vL4ZYg+Dk+2wqK++tDrLFob7fdsGqKH1+G5iKd4n/rra8K6a2uxW54AYH7vbuigJo+DH+PEmofBYODQBFOUVDfiuKt4psqGHVRxfqYltr6IErsqaM1AHVh2aY2Z1/z5VlnpaCrj0WI7PA3OxjEX8QWcsRadcG2OFTY/j8Ttb2mUY406quLVyt4IzyrHwjvBqKqnNmyWk5bC0UlmWNynB6Zf88frsGyB1qSuLIc7C2wxzKQ9xl3wxftI4TZ9Jlp1xtvVjsguq8WUK360wikhBFmlfx6j1UYRjxbbYWavLph1PQBnvySK3EoE8MyRP67pgz66bTH+4jdc8UxBA1t8U18ZKSYW9emB45PNQQAMOOGJGz5plKKkVhtFXJplhSuzrfApKh+usQVg/VDtyCUEax6FSaRSSFlOGusH68Fjc390UJPHyHM+OPopHnkV4hs6t9DC/3daxJsW/nXMsu/2U3bkvychvwozrwdgx6torOyvjSuzrGDVtfVfxl32SKYt/93xKqrZ/53LJbjnn4FBJzwhzWTiy8Z+mGrTRagbL368j8zFkFOekJFmwnW9E4Ya8/fPqG5g4/RnXjns+ifhf0l3SC2qxsRLvvBOKsabVY6YatNF4Eqn4xRVN02wuQSL7wajhE8STGlNI+bcDEQoRR9+czQlSq0frIddo+gTpYLSSzHpkq9AFUjB6bwkjKV9e2DDEH2+70dgWinm3QrC1hEGmG3XtdkxLA4XKx+EoaqejX1jjKEo27z3iGdiEba+iMKFmZaw7PLXY/G/hX9qCa55p2H1AF2+axeUN+G5iMurxPrBekI9rrKeJdANy9kvSRhu0h767cUTvqSlpRGcXSXR9juAd6y/CsuFkxgpXcK00ZXXNuJzXKFYlTc5FXXIF6MdCeC9bqqUHikmA4FiltcryUkjWkzPGiU5aUSKmXDUxBRrLbGrAJ30NRGdWwlvPslETXC5XHjH5+OaexK2PA3FNa9U2HZvjeUDDdC9fSux1vAjWm2UMMVaC0ec4ynH7RplhBeh2QKL5fxgMhk4Ptkcb8JzaVt96FCSk8alWVa4758BVz4bGYLipKeBXaOMsOReMFKLqkWeh8FgYPNQfQw2aocZ1wL4pi/paCrj8RI7PA/JxpFP4gs4jroauLfQFqe/JOEETUVPBzUFPFtmD0IIJl/2o70BZzAYWNSnBy7OtMTLMN6GhCACpBSTgc1DDXByijm2vYzCgfextNU+36OtoYyTUyxgodUKI895UwpAd3zT0feoOxJ/qAiRYjKwpK82Xq3sjZjcSoy/+E2sqhF5GSlsHmqAl8t7421ELkae9RGrqud72qnK49z0nrgy2woPAzIw6pwPra9Trx7qqOAjwHEJkFlaiyteglWuCoKGihz2jzWB67q+yK+sR//jHjjsHI+KWtFT21po4f87LeJNCy0IQUUtC3vfxmDMeR8YdlDF1038BZW04hqcc09GA8XOC5tL4JNcDI8feq0T8quw4HYQrnql4NyMnjg7vSc0VOTEXn9pTSNWPgzFrtfRODDOBBdmWNLezN3wTv3jAqiRzcWKByHgcAnP4Dg4C6PP+cCuRxu8WtlbqIqg+HzeTYUgm8JlNY3Y8iLyL/97bG4lxpz3gbKctMCtIIQQnPuShJ2vonFhpiVf0eR7XGLyMfdmIH4ZboDFfZs3Em7CO6kIx10TsHW4AZY6NR/zDfCMrRfcDsKOkYaY2av5NXC4BOuehCO3vA535tvyrV4IyyzDVa8UHJpgIlGjZXEpq2nEuse8iHhxhYzSmkbsfx+L/WOMoaYgeBUHIQRL74bgrh91nGlKUTVeh+di3SDhhKHmKK5ugFtMAd8WuO+pEiI6+FN0Pkw7q4ntGSQoMbmV6NxagW+kvSCI63cD8ARMKoNraSZD7N3edmryyBMidrg5jDupii02SBJZaSam2Wj9EeVbUF6H5AKeUJBbXgOX6BycdonD6ocheBiciVo2F/0NNLF/nAnmOer8tHbjVQN0EJxeRimEd2urhAUO3bH3rXjmvgCvamDHSENsfR6B8lrxW7GOTDTDxmcRYhvKzujVBVNttDD/dhDfzQlBYDAY2DPaGHY92mDmdX++kffaGsp/+MMc/hQv9vvas0trPF9mj+ch2dj+Khocih9zFXkZ3JxnA/POrTD+gq9A5t799DWxZ7QxnKPzseResMB+NkOM2+PtKkd8Sy7GzGsBKKwS/HstLyOFfWNNcHyyOXa8isa2l5Goa/xztUtMbgV++xgHBgN8RUiD9qo4O70n+uhqYMz5b7junSp0Bdz3GHVUw5uVDpho2Rmzrgdg37sYsVsBm3DQaQvntX0x1qIT5t4MxManEXzbP58EZSK7jL/41sDm4vTnJKSIIUg2R7e2Sjg5xQJPl9ojMrscfY+546pXS7x4C/+btIg3LbQgABwuwYOADPQ77o7U4hp8WOOIXaOM+N5EEkKw8Wk45cVMEywOwS8vIlHP4qCexcHRT/EYe8EHNt1bw3Wdk8Ruxj/HFmDIKU+w2Fy4rnfCKDN675GymkZc8kj5Q4Bicwlicitx6nMiVj0Kw9FPCbg4ywo7RhoJ7b9z7FNCs+8PkwEoyEhBmsmAFJOBHhpKmGDZCdNs/nwj/CEyD5Mv+2KqtRYuzrQUKA2nkc3FlueRePR7olR/Ad7bhwGZWP8kHKemWvAVWZr4FJ2PJXdDMM1Gi3Jsk3Cze5QRpvO5wedyCTY/j0BifhXuLbTl24aWXMgT+gYZtsO4np1pX8/fBSEEm59HwrSzmkACGR2/vo+FVdfWGGYiXMqSW2wBEguqMN6yE+W4U26JmGjZGd3aKomzTADAs+BsWHdrje40c2WW1GDz8zA8D0oX6EYqOKNUoO+tpIjOqYCJGGbFAJAnEfGGUHreyEgxwSUQ6HzLjw5q8igQU7wx7aSG6BzJeFNIilm9uqCoqg4zrvpi68tIuMbk4YZ3Mva+jYV3YgnAABY69sC56dZYO1gfw806Q0NN/O8AFW2UZLGsnzatgLCyvw7UFGTE9oYBgGk2Wuijp4H972PFnmukWQfM6NUFh53jxb55/GWoAUw6qmHJvRCx5mIyGTg0wQzGHdUw63oAX5Gqh4YyHi+xh0dCIU5/Fs/EGOB56rxY3htB6aVY+SCU8jXISDFxeKIpZtt3xcqHIfAUwCBYW0MZr1c4oIHNxYSL3wT2gereVgkvV/RGx1bymHU9AEFp9BWz3zPUuD0+ru2DxIJqjL3g80eFTU0DG4vvhoDNJeASwCOxCDG5zQu2ctJS2DrcAHcX2uKOXzpmXg+gNOumQ1qKieX9tPFhjSNiciox9LQXvJPEqyZrQlaaN7fbBifUNLAx5JQnHgRk/OmcWlHHwsGP8ZQbkgDv2mXtozCxxCp+mHVuhQeLeuHc9J54E56LAcc98Cw4S6xzfwst/H+jRbxpoQUaAtNKsf5JOK56peLYJHPcmW8DHU3qKo+bPmkIyyynrCqRYTKgICMFRVkpFFQ24KRrIoae9sK3lBK8XO6Alf11+UZKC0NFLQvrn4Tj7Nck7BhpiCuzrQSu4rngkYwfX0IDm4vzX5NR08DGp3V9RGrh+BKbjy+/x2rKSTPBZPD+r3FHVcyy64oD40zwbrUj4g8Mw9eN/XBiigUGG7UDwLswOOYSj60vInF6Wk+sHqgr0A5xeW0jZt8IQAObK1CiFCEEZz4n4bBzHO4ssKVsLQOAV2HZ2PA0HGemWVCKKL7JxVh0NxgHx5tiik3z3iWEEOx8E43QjDI8WNQL6srNf1655XWYfSMQs+y6Yr4D/7hecRNnROGuXwZicitwdKKZ2Dv4nolFcIstwIGxJkLN1cjm4uDHOKwfrEeZnhaTW4HPcQVYM1BHrHUCvOPzcVAmZvSir7rRaqOI6Vad4Z1UhIMfohGTWQYWi/9u6onJ5phjL74QJijRuZUw6SRexVReuXgx4QDPsFhGiv/nLv3734RpkfiR9qryqGpgC5VW8yMmHdWQWVr7jyrpb99KATtHGGKmbReMNmuHrLJqJORXYfUAHfw6wQzrhhjCspv6T/WHa44FDt2RV14H52j+7UdKctIYY9ERBz/Gi/W5AP9JS/oSV8jXu00YNg3RR1F1A3a+jhZLAGEyGTgxxRwqclL49X2sWDe8Ur/P1aWNIubeDOTrL9O9rRIuz7TCk6BsHPwYJ7aA07GVAp4ttUd+ZT3m3eL/vADvc1jZXwcbButh2f1QgVLF1BRlcGueDRx02mLsBR+BWpcBntnuqakWmO/QHXNuBuGmTxrla62qZ/2pta5TKwU8WWKHwUbtMO7CNzwOzMS2l5Eorm7AH9MQgsM0LYA23drAeW1fdFVXxLDTXngRki3We97j9wqqpU7aWH4/FJufRUjsnNOplQIuz7bC2ek9cdUrFWMv+PwRDX/CNUGgcyyHAPH5Vbjjmy6RNf0Ig8FAXz1evPgvww1w9msSRp3zxpe4lnjxFv43EM+AoIUW/sXkltfhkHM8vsYVYNUAHRybbEZbXUIIL6b8wIf/mCMyGYCyvDRaKciitaIMNFXk0F5NAW2V5dBGWRayUgy8j8jDg4AMbBlmgFl2XWn9VwTFPaEQW19EwqiDKq7NsRbKQ6Ggsh53fNP/YkrXRFxepUjeQn4pJVjzJBzyMkxMtdGCbTd1GHdURZc2irR+PpX1LKx/HI6Uomq8XNFbYFPe9OIaLLgdBB1NZRyeaErrvcLhEux+E40vcYV4tqw3rQfKPf8MHP4Yh6uzreGoy9/U0yepGEvuBePAWBOM7dl8JQiXy8WB93HwTCjC02X20OTzmZXV8MSo/gaa2EDhAfMtuRhL7gbDbYMTOv5N6VOxuZU47ByP2/Nt0FrMqPLaRjZ2vIrCluEGaC9kBcddv3TISUthGh+RrImTromY1asrOogpMgCAb0oJquvZGGJELfY9DsyEvbY6nIw6oouGMk64JuHUl0TIyDDRWkEGeprKcNDVgG77/1S+MBgMShFD0sTkVGACTcUSHfmV9c36gQkDi03dNiXD5P1NnMQpNQUZyMswkV9RL7IhfGslWXRqpYCY3Ar01hHf3FdSaLVRxunPyVBWkIZJRzXM790VSvLifS/FRUFWCusH6+GYSwIGG7Xj+/mOMe+I+/4ZuOCejF+GGYj1nO1U5bF/rDF2vIqCddfWfEVxQZCRYuLCDEuMPOuNJ0FZArVI8kNeRgonplhg/EVfHHXhtdyKs65zM3piyd0QbHoWgVNTLZr9vev+uwAw/Zo/uATYOdJQLJG9tZIsHi7uhWX3Q7H1RRT2jjGm3CQabd4JmiryWHIvBFmltdg0RJ/y919aiok9o41h0F4FC24HYftIQ4EqOhkMBqbbdoFeO2WseBCK0MwyHJlo9pdKXS6XYMWDUPgkFcNjcz90VVf643k3DzWAfY+22P8uBslF1X/alOMQ3jVNRFY5zLVa8V2Hspw0Dk80wyDDdtj6MhL+qcXYNsJIKA+y72EyGZht1xUDDDSx41UU1jwOw3RbLQwz6SDSfD/SR1cDLuv64qpXKmZcC8BYi45wiclHA5sLKSYD0kwGmEwGGOBd93K4PPG86a1hcwn2vY+FtqYS+ur9nFZuJpOBsRadMNykA16FZWPz80joaCjjl+EGYv/mtNDCP5kW8aaFFn6gnsXBNa9UXPJMwVDj9vi6qZ9AokdyYRV2veb9uK8fpItRZh3QVkUeqvLSzV4UEULwLIS389Wrext83ugkkZtHgCdy/PY+Dh+j8rBrlBEmW3cW+sLslFsiqB5RVsPCtheRODfDUqD5uFyCy14pOPclGbtGGWG6rZZQa0otqsaB97HgEODNSkeB0qwAntHwkrvBmGTVGVuHG9IKY/UsDna8ikJWaS1erOhNG7d9ySMFlzyScXehLay6tuE7ziuxCMvuh+C38SYYT1GZc8ItEZmltXi02I7vc9c0sDHvdhD02qlQVqMk5Fdh2f0QHBhn8rcJNzUNbKx+FIolfXsIFBVPx6nPiWivKo+ZQt4clVQ34MyXJFycaUlZVRCcXoo6FgfL+/H3JxKGh4EZmGTdmbLNp7KehT1vY/ButSMAoLuGKs7PtAKLxUZkdjkS8ivhEleIs19TMNRIE4ryMjBsr4zubZVh2U39p3mRfE9VPQupxTUSaZsSVnT7EVrPm98FLXF8bxgMBtqryqOgUnTxBgBMOqkiKuefJd40sDlo5HBxcrI5FGkS9f5OJlt1xnXvVDwOyuJ7I85gMLB3jDEmXvLFFGst2lZEOsaYd4RzVD52vo7GxZmWYn2X2qvxDF8X3gmGSSc1sVLZ1JXlcGu+DSZe8kVXdUW+7bSCICcthcuzrLD6USgW3w3Gjbk2zW60dGurxBNwrvqDEGDXKPEEHEVZaVyfY42tLyMx6bIv7i3ohS7q/P25evVQx4vlvTH/diCyyupwbJIZ7YbQVJsu6KGhjGX3QlBcVY9VA3Qpzw1NWHVtg/er+2D1o1CMu/ANl2dbQVvjP9/z8+7JCEwrhRSTgXNfk3F8svmfHt+xlTzSS2qbrabmEoJDznF4vMSedh2DjNrBpUtfnHRLxJBTXjg6yRQDDNrxHf85tgAvQ7Nxgc+x2qmVAm7Ns8HrsBxsexmFN+G52DfWGJoq4p1zAZ6ouGagLsZZdMK+dzHgEoLtIwzQX08TVY1sVNaxUFHHQmX9f/67tKYRJTUNyCmrQ2pRDRbeCcbGIfqY79BN6NZ6QZGVZmKqTReMMO2Aa95pmH0jAH1022LzUAOI/y600MI/j5a2qRZa+J2m6O9BJz3hGluAewttceqH6O/mqG1k47BzPEad+93EeKMT1g7Sg7amCtQUZJr9wU0tqsaC20G49S0NRyea4cpsa4kJNz5JxRh2ygs55XX4tL4vptgIJ5IAQGZJLZ6HZKORT9UNwGtl+BSTL1CUZ3ltIxbfDeZ5zSy1x4xegidSAbwKorEXvsG4oxpuzbMRWLh5E56DOTcCsXGIPnaMpE+UqqhlYc6NQKQV1+DqHGtK4YYQXvvWde9UPFpiRynceCQUYtn9EByaYEop3Jz/moQnQVnYNsKQ70VvI5uLZfdDoCQrhdPTLPi+poLKesy/FYhFjj0wwfLv88LZ9y4GPbu0xuoB4rcgRWSVwyW6AIcnmgqdsnb6cxJ6dW+DPrr82/oIITjumiD2LnwTRVUN+BxbiOk21DdeHyLzoNdOBXo/VI7JyEjDqntbzLDvgdvze8GqexuYaLWCnqYiEgqqcc07Db+9j0Jmyc/3VYnLq0I7VTmxjdJ5hsXindtYHAJZAcQbflWCgtJeAqbFpp3UxE6tkjRabRSRVVaHkIzy//ZS/oS0FBO/DNPH17gCSvNV445qmGjZGb9KwK+GwWDg1/EmCEwrxdsI4eKkm6O3TlusGqCDZfdDxG5d0dZQxpVZVtj/LlbsZCwFWSmcntYTdY0crHgQyjeyuqu6Eh4vsYdLTD72vYsVu+1EVpqJ45PMMdCgHSZepjcm1tFUxqsVDsgsrcXsGwEoq6E3lLbp1gZvVjrALbYQc24ECvQYgJdcdH9hLwww0MS489/wKToPAC9k4OyXJDSwuWBzCV6H5fwptauBzcGiu8Fgc5t/D7kECE4vQ0iGYIl36spy+HWcCbYON8DaR+HY9jKq2eO/sLIeax+H4VNMPlxiCvjOx2AwMN6yM9w2OEFaionBJ73wLDhLYi1EXdQVcWOeDY5PtsAd3wxsehEJGSkG+ulrYqxFJ8y264qV/XWwfYQhjk82x615tnBd74TkgyNwd0EvvA7LwdBTXvgaz/81SAIVeRlsGKwHj839oKkij5FnvXHIOY7+gS208P+MFvGmhRYAJORXYuHtIOx4FY3VA3TwZqUD5c040CT25GPh7WAEp/N8anaPNuKbCATwLgLOfE7CiLPe6KquhKdL7TGExktFUGoa2DjsHIel94KxvL8O7i20pa0a4cdRF+oe7iZ4Zsu8KhV+RGaXY9OzCAAE71f1gWlnwXcnCSG47JmClQ9CcWCsCTYN1ReopazJr2bnq2hcnm2FWQKUV+dV1GHKFT+oKsjgwSI7yoQdLpfg1w9xCM0ow5Ol9jCmqE5wjy/EigehODLRDGMt+LegXPdOxXWfNNxf1Ivvzj+XS3DUJR6lNQ24MtuK705WTQMbC+8EobdOW4n4uAjKu4hcuMQUYMNgPbE9NFgcLra+jMJEy860HlM/klhQhafBWdg+wpBy3LfkEsTlVWERTYKYoDwNzsIEy060pscvQrIxyYpaUIvPr4JPUgkmWnXB1F49sGOUCfaNNoYcUwq/PIvERfdEuEXnoKRKdANMKiRhVlxVz0J1AxsdWom3/0nnefOftinxEqfaq8ojnybGmA6TTmo/PXGKEILMkmqkFgsWQcxgMDDKrMMfPmP/JAYbtUdFHQs3fNIox20aoo/gjDK4S+A1tFWWw2/jTbD7TQwKxIyxB4DlTtowaK+CDU/DxTZp7dVDHYcnmmLVg1DE5YknAirLSePWfFsUVtVjzaMwvpVpXdQV8XiJHdxiCySS7sVkMrBrlCHmO3TD1Kt+8E+l9qhpqyyHx4vt0EZJFhMu+SKjhD7Fq3MbRTxbZg9VBWmMvfDtL5Hd/JCWYmLbCEMcnWSGTc8isfdtNJbdC/lTyyWTwcBlz//EXR94H4ucsjpKD0MOl+C3D4ILBQwGA5OsOuPj2j5IKarGiLPefxJ/COElTTZyuOAS3qYInd9MW2U5nJveE8cnm+O4awLm3AykvDYTlsFG7fB5gxP66Khjy/NI7HodTStY2mur4/1qRyx07I4NTyOw7H6IxJOofkRTRR4Hxpng07q+qK6XTCJXCy38k2gRb1r4n+Y/0d/f0LNra8ro7+/JKKnB/NtB2P4qCuMtO+HJEnsYdaQ29gxMK8XIsz74FJOPJ0vssXeMMaXQIwz+qSUYdsYL2WV1cF7bF7Ptuopc/pxYUIWPUXl8/SPkpZlQkJECA4CsFBNabRRR0UzcMSEE9/wzMPWKP6y6tsG1OdYCV8wAQF0jB2sfh+OObzqeLLHHOD4eMT/SwObgsHM8ngRl4tlye4EMlZMLqzDxoi96dmmFy7MsKY2i2RwutryIhFtsAY5OMqdssfBIKMTKh6E4Nskco835pwTd80vHmS9JuLegFwzaN38cEUKw710MvsQV4s6CXnyPHTaHi9WPwqCmIIOD403/lhYbAMgqrcX2l1E4OslMIi1a173TwOZwhW5nIoTgmlcqFvftgR4a/D+bpsqpZU7alGbGgsLicHHPLwMDDfmXwANAWnENIrMrMIbieAB4yWX9DTT+1EbQrrUiNo80xpqBekgrroFLdD6W3g/BwQ/ROPQhGne+JcMnIQ/FFeJFGANAVE45enYRzzcgt7wO7VXkoCJAEhwVZ6ZZUHqKMJkMROwZgnZitgp0UVf80467KJh3boWiynqUClgNQAeXy0VZVR1conLxKDADO15GYdWDEOx7H4sPEXkCz9NXTwMfo/Iklsqy5000XobSV13SwWAwsHW4Ia56pVLGZbdWksWmIXrY/z6WbxWJMAwz6YABBprY9jJKImLFickWSCyswkWPZLHXNtaiE5b07YEFt4PEFpfUFGRwb0EvpBXXYOOzCL6fv1YbnoDjk1yM464JYr8nDAYDK/rpYOdIQyy4HURrEq0gK4WLM60wyLAd1j0JR0hGGe1zKMlJ49JMK4zr2QkTL/riS5zglR3DTTvg6VJ7PAvORs0PUeCNHC4eBmSitKYRbrEFeBiQSZuwRABE5VQIbKbchFYbRTxebIdZvbpi1vVAHHOJRyObi4eBmQjOKPujmrC0phGPAujNnQGeyOK2wQlabXgGyXd90yT2vVeQlcKmoQa4ONMK6SU1GHDCA89pDJilpZiYbd8N7hv7waCdCkac8cZvH2JRSWFsLQm6t1XCb+NNf+pztNDCf4MWz5sW/ifhcAmeBGXhmEs8TDqp4cMaR4F29+tZHFzySMEVrxRMsOyM01MtKCs0AJ5AdPhTHN6E52LdIF0scOgusWSPukYOjrrE40lQFjYP1cdc+25Ct5d8D5dLMP0qz8CQyeCJM/VsLhRlpdBNXQlGHVVh2EEVOprK0NFURkc1+WbFgZoGnsnst5QS3JpvAzshvU9yyuuw5G4wFGWl8HaVo8CtG2U1jVh6nxe5+nqlA1+z3+8JySjFwjvBmGPXFesH61GKHY1sLtY9CUNSQTWeLbOnbKlziy3ALy8icXqqBWV11dPgLBz5lIA7C2woq5LOfU2Gc3Q+XizvjbZ8WnwIIdj7LgbZZbV4tqw3pe+KJGH9LhiN69mJMpWruoGNj1F5mGxF7cGUXlyDs1+ScH+RrdCvwSOhCG5xBfDc1J9ynGtsAXIr6jG3t2TSm1xjCiAtxcAAA2pzxpeh2ehvoEFr5PwpOg8r+jdfNWWvqwl7XU2U1zai5wE3rOyrg5zKWuSW1iEiqwK1jdlQlpNCG2UZqMrLQFNVAf30NaGpKrioFpFdQSk4CkJeRT2U+Hh+CQOdwTjAu0kVF00VeURkiVc101pJFu1bKSA4vVSkqko2hwuPhAKEZ1WgvpGDnIo6NDRyoSgvhQ6qCrDs1gp6GkrQbqsCRSFes30PdbC5BMHppRLxotJtp4Lr3mkY37OT2J+vbfc2sOvRBue+JmPvGGO+46bbdsGrsBw8CebvkSMMe0cbY8m9YDwLzuab/CcoaooyuDjDEnve8tpGHcT0PFo1QAcZpbVYdi8E9xbaQlkMgbm1kizuL+qFqVf8sONVFA6Ob74NVauNIm7Pt8X0a/6oqGNh/xgTsa4nAJ5HTWtFWax7Eo7do4woRVgpJgM7Rhri9jeeb8mJyeYYbkptwMtkMrBhsB7026lg9aMwrB6gi2VOPQQ6Jm/5pvHdpGIwgBs+qVCWk4aCjBRqGjlQkGGCAKhnNS/ksDgEv36IxfvVjkJ9J5hMBhb37YE+em2x/kkE/FNKEZlT/qc20AY2F0ddEjDBqjOUBRDDVeV5mzejzTrihk8qXoXn4uhEM4FDHujo3lYJdxfY4lN0Pva/j8WToEzsH2tCmeLZWkkW6wbrYahJe+x7F4MBxz2wZagBJll1Fvs4a6GF/yVaxJsW/ucISi/F3rcxqKpn4+gkcwwy1BToh9Y9oRB738ZAVV4GT5bYUyYLALwbaZeYfOx8HQOTTqpwWdcXWm34m/cJS0hGKTY9i0RrRRm8X+1IWWUgCAWV9djwNBxV9SzY92iDEWYdoaOhDN12ylBXkhX4YiS5sArL74dCXVkWH9Y4Cm2cF5RegmX3QjHUpD32jjYW+OY97fdEKb12yjg91VagmPUvsQVY/TgM20bQJ1fUNXKw/EEISqob8WSpPWVKhEtMPtY9DscpGuHmTXgO9r6NwY25NpRtevf9M3DdOxVPl9lTHkPXvFORWVKLm/NsJHIzKygnXBN5Rs8jqduUfvsQh/TiGkyy7Ax+hxMhBNtfRWGSVWfa1sUfYXG4+PVDLNYP0qOs8uJwCU66JmJVfx2BhAFBuOObjjn21ElxXC7By9Ac7BltRDlXalE1GjkE/fWphSC/lBIMNNBE/x+OsdySKiQV1SKvvA7FNfXwSiiAf0ohFjlow0ir+fe0oKIOHnF5MOikjHbKKlCRk4apGAasAM/v5u8yypYEnVorIKdc/DY0m26tEZD2H/GGyyUC3ZzkldfiimcKiqobYN65FbqrK2GkWQd0VVdEayU5sUQSaSkmhpm0h2tMvkTEm4mWnXHcNQF+qSXorU0vVDSwOZSGpVuGGWD0OR8scOjO1+9LWoqJLcMMsOhOMIYatRNInKdCTVEGy/tpY/XDMPTWUUfn1uL9Ppt2boWpNlpY8ygMH9b0Ecuom8Fg4OB4U2x5Hok1j8NxdbaVWJs+GipyeLC4F6Zc8cOhj3HYziddqqkCZ/o1f+x6E40DY8UXcIYYt8ft+bY4+DEOpTWNWN5Pm/JYnufQHZ1aK2Ld4zBkl9VhUZ/utMd+0/dk8d1gJORX4tAEUyhQnNufBWfhTVgOX1+/BjYXN33SEbhjIJY5aaO4uhGJBVWIz69CTG4FonMqkF5cCxaXCwUZKTT+7pcTk1uJu34ZmNu7m0DvzfcYtFfF82V26H/cs1n/LhaHi4vuydgiROqavbY6LLRa4fTnRIw+74MV/XSwzElbIhs7DAYDw007oK+eBs5+TcK4C98ws1dXrB+sS1lVbthBFY8W28E5Oh+/fYjDg4AM7BljDEsxKz1baOF/BQaRlKNVCy38F8nOzoaWFm/nLCsrC507/9VPIu/36O8vcQVY0V8HCx27CxR1nVNeh3NfkvAxKg+bhxlghm0XWt+VrNJa7HwdjYySGmwcrI9R5h0k1r5Sz+LglFsi7vplYP1gXSx07CF2tPjn2AJsfh6Bfvqa2D9W9HautxG52PYiEnN6d8NGEXxP7vtn4JJHClb208YMIXZWA9NKseReMKZYa2HrMAOBLjafBGXinl8GVvbXxnBT6gqDqnoWFt4JBghwY5415fvjHJWHDU8jcGYatXDjEpOPO77pWOqkTdna9TEqD5ueReDuAltYd+MvZnyIzMOW5xF4stRerNQTYfFOKsLSeyF4u8qBsnrNPaEQax6GwXldH8qbpKfBWTjpmgi3DX2FPg5vf0vD/YBMOK/tQ5lA8josB8dcEvB1k5NEEjBicysx4dI3+G8bSFmJ55tSjFUPw+C/bSDlxfP5r0kIzyrH9bk2lM+79UUkVOSlsWMktRjEZnNx2ycJYVmVaK0sC01lWXRprYiRPbX+eJ9CM0rxNCANRTWNiM2rQjtVRbxe5Ug5Lx0n3RKRV16HYz8kt/xTSSqowpjz3xC7f6hY52ufpGL8+iEG9j3UUVbbCB1NFawaoPvH36vrWSirbUR6cQ1yK+pRUduI/IoG5JTXQbe9MhY7doeaovgG2j8SkFaCFfdDEbB9oESqP4+7JCAurxI35lEfp/f9M+CVWISrc6wpx215HoF6Fhdnp/ekHLfqYShkpZk4OcVC2CU3y7aXkcgoqcX9hb0kUgGw+VkEUotr8HiJnUBJSFRU1LEw6ZIv7LXVsW+MsdjXEVmltVj7OAw23dpg63ADvvPllNdh+lV/OOi0xW/jxBdwACAurxJzbwZihGkH7B5lRDtnVHYFFtwJwjDj9tgz2kigY7awqh6/fYhDRkktrsy2arY6NjqnAuMvfqM1OJeTZmLdIF0s79d8BSSXS5BTXoeE/CokFFQhJKMUXonFAAguz7LGICPqFtrmOPslCRfck/m2aclIMeDzywCBElB/JDK7HFueRwIAjkw0o92AFJakgirsehMNNpdgtl1XjDHvSHu81rM4uOKZisueKRhu0h5bhhmInU74PYLcG7TQwv83WsSbFv4VUJ2g61kcXPdOxYvQHPTs0gpbhgr249DI5uKGTxrOfU3CDNsuWNZPm2+7ShMsDhc3fdJw5ksSxlp0xNZhhkL5vNARkVWOE64JqKhj4fhkc7FLYOsa2TjkHI9XoTnYP86YMgmJigY2Bxe+JuO2bzpOTbWg9f34kUY2F3vfxcAlOh+XZlnBtrvgFRevwrKx/WU0do4yxMxe9IIPIQQX3JNx1SsVV+dY07Z0ldU0Yt6tQKgpyuLKLCvKip4PkTyh5dz0npQXbu4JhVhxPxRnp/fEYIpx35KLsehOMC7M7EkZJxqSUYrZNwJxbnpPod97cSiubsCw097YNESPshy+vLYRQ055YdMQfcr2hKKqBgw66Ynjk80p3xd+z+F0zANnplmgH0XFCovDxeRLfphh1wVTrMVrlWjil+eRYDIZODSBur/+sHMcZJhMbByqTzlu+BlvLO7TnTIljBCC3oe/4tgkczjqCtaikVpQhcisMhRU1eNFWC72jjX5o2oiNL0ELjF5UFeUgaosE+3UlaHdRg6d1NUgJSWawFVc3YAGNldk4/S/m3oWB74pxeinpynWzWoji4NvSYXILKuDtBQDhBDUNXIRn1+FygYOqutYYICgs7oSlGWloK4ih/Yq8jDVavWXBDJJwuES9D78BUcnmQvkBUZHYWU9HI+6w3ltnz/FLjc3ru8xd7xc7kDpDZdbXsfz0FjWm1KAzi2vw6CTnri3sBesuoq/W1/dwMaw015Y3KeHSBUTP1LP4mD8RV/Y91DHbpoqOwBIyK+Cfnv+n3t2WS3GXfDFMqceWNRHfHP1tOIaTLnihxm2XbB+sB7fcbnldZh21R+9tdX5tloJS1ZpLebcDIRpJzUcn2xOWwGSXVaL+beCoNVGEeem94SSAC1DDWwOtr+Mhk9yEa7Otv6TSNF03hQ0VU5VXhqBOwYJtNHXxJvwHOx4FY0p1lr4Zbi+wBsE0TkVGHfhG99WLoAn3owy64hTUy0EXs/3NLK5uOKZggseyZhj3w3rB+kJVKUsKIQQfIzKw753sdDWUMb+scYCXafmlNfhqHM8wrPLMdVGCwsdu0tkY6VFvGnh30iLeNPCv4LmTtC8tqUC/PYxFq0UZLF3jJHAbRi+KcXY/SYG0kwGDowzgQ1FxUMT4Vnl2PYyCiwOFwfHmwolQNDRyObi7JckXPdJxaYh+pjXu5vYO6cJ+VVY/yQcXdooYjtFNDUd2WW1WPkgFFwCXJjZE13aUCft/EhRVQNWPAhBHYuDK7Op47m/h8vl4uzXZNzwTsP5mZYC3YxwuDzTX5eYfNxZYMvXHLiJwsp6rH4Uhi7qivh1nAnlxcS7iFz88iISF2ZYoj+F74lvcjEW3Q3GkYlmlJ4iUdnlmH4tAPvGGGMiRTJRenENxl/8hg2D9TDbvhvl65EkXC7B/NtB0NZQwq5RRpQ7bGsehaGmgY3rc60px219EQl5GSb2jjERej373sUgtagGdxbYUo57GJCJe37peLvKATISuDgsq2mE/eEveL3SgfJ4qqpnwfa3L3ixvDflDWxacQ2GnvJC8K5BlEbKiQVVGHv+G8J2DxbqxgIAWGwORp7zwcWZln9US6UX1sAzMR8l1Q0oqW5AbSMH1Y1sSDOZUJSVgoKsNGSZQC2Li3E9O8JO5+8TCf/plFY34EVoNlKKq8FhE+SW80SbBg6BmoIMWinIQE6aAU0VeZh1VkP3toporawgkHeFpDnwPhbltSycmEJdDeWfWoLkwmrapL4NT8OhICNFawy6920MCqvqcXGmFeW4Q85xSMyvwq351N/jc1+S4BpbgNcrHcSuPAV4LYgL7wThw5o+6E6TFicI6cU1GH3eB4cnmGGkGX/floo6Fvoedcee0UaUYm1EVjlmXPPHiSkWGGYifkJlUkEVpl71x+I+PShN4fMqeAKOXXd1HJogGQGnuLoB828FoZWiDC7PsqIVZCrqWFh+PwR1jRxcnmWJdmr01wiEENzwScNJt0QcmmD6R9IjITy/Q++kYoRllSG3vB5y0kwwANQ3U+0ixWRgzygjzBFS1EsvrsGqR6EAgHPTLWmPqXoWB4NPeiK7vA50d2VSTAY+rulDKfjRkVRQhS0vIsHicLFjhCHsBWh9FIaqehZOuSXhQUAG5jl0w5oBugIJbwGpJdj7Lha1jWzsGmmEgQLaGvCjRbxp4d9Ii3jTwr+CH0/QdTJq2PcuFnF5ldg8VB+TrbUEusArrKzHbx/j8CWuEOsG6WJu7260Zc9V9SyccE3E46BMrOing6VOPSSyY9BETG4FNj6NAJPBwIkp5pSGcILQlAJ16GM8Fjp2x9pBuiKXdrvHF2L903CMNO2AXaOMhL6JjMquwJJ7wbDp1gZHJpoJvAPUwOZg64soVNezsWmovkAXMfUsDjY8DUd8fhXuLrCl9TfILqvFzOsBsOraGkcnmlGKZe8jcrHlRSQuzrSkrPoITi/FvFtB2DvGmDIqOrWoGlOu+GH9YD3KaqLSmkZMuPgNQ4zb08ZiS5prXqm445eOD2v6UPrrfIjMw87XUXBZ35fS/+hrfAHWPQ7H541OQvskJRdWY+RZb7xf7Ui5y1fP4qDfMQ/sHGWIUWbimfE2cdkzGR4JRXi8xJ5y3OPATNzzz8CHNX0ox11wT0ZoRhltK8o1r1T4phTT3uQ2R0xuBaZe8UfEniGU58XSykpkl7BRVluDShZBbQMXYZklqGERnJ5qCSkJGa//f4QQgoT8KgSmlyAwtRStlWRg1rkV2ijIoWNrebRVloWKvAxkpaXEvuFlc7hgMhgSuXGOyCrHrOsBCNpJXU3gm1yMVY/C4LdtAOXvWUxuBSZe8oXf1oGUJtx5FXXod8wDb1c5Up6vy2sbMe7CNxwYZ4I+uvwF+XoWB4NPeWJlPx3Kqj9h2Ps2BlE5FXi61F4igpBrTD42PI3A65UOlKmEnolFWH4/BA8X28GCopXFNSYf656E044TlJjcCsy4FoB1g3Qx36E733H5FfWYfs0Pw4zbY/NQwdqS6ahuYGPpvWBUN3Bwa54NpYccwNvAOuGagHcRubg534Z246UJ94RCrHkUhll2XbF5iP5f1l7dwEZsbiUis8sRklGG8Kxy5FXUQ16aCRaXCw4XkGYyELV3CKWHTnM0sDk4+ikBsbmVmGqjRZmYee5rEk64Jgo0LwOAnbY6Hi22E2o9P8LhEjwNzsKv72MxxqITto0wkEjy4vfE5VVi95toZJfVYfcoIwwzaU8rxnC4BI8CM3HCNQGmnVth9ygjyu8PFS3iTQv/RlrEmxb+FXx/gl5/4zM+pDZiZq+uWDtIVyDjVhabg3v+mTjllggnfQ3sHGkkUGuVS0w+Hgdmoo7FwcHxpmKbBv9pTRwuLnmk4KJHMpb21cbK/jpim8yV1jRiy/MIxORW4tRUC6FToJrgcAlOuSXi1rc0/DbeVOAY7+95E56DbS+jsHagLpb0FSwdAvg9UepeCBrYHFybay3QjX5lPQuL7wSjkcPFzbk2tEk/KUXVmHU9AION2mHvaGPKi9Um/5RDE0zRl6L6JzK7HDOvB2DrcANKQSa/oh4TL/litHlHbB3O35iwnsXBzOsB0FSRw4UZln9rWkNkdjmmXPHDg0V2lG0LhVX1GHrKC7+OM6Xcfa5uYGPISU+sGagr0o3Y+idhUJWXwb6x1BU7171T8TI0B+9XO0rk/WJzuBhy2gvbhxvS+htMvOSLMeYdadsyRpzxxkLH7pTVVgAw63oABhlqYh7FTRc/HgRk4ENkHh6KcPFfUlUPhyPuCNs9RKRyey6Xi/r6eigqSs68XRw4HC44hKC2gY3qBjaKqhvQwOKirK4RVbVsVDWwUdfIQi2LiwY2F3WNHNQ1clFZzwKHEGhrKqGfrgYcdTUk5mv2PYQQOBz+iiuzrSnT6ISZr99xD2wbboBhJvy/k1wuwYATHtg0VJ9W6JxxzR99dNvy9QZpYufrKFTUsXGOxtPmimcK3kbk4t0q6u+pS0w+tr2MgvumfhIxaK9r5GDEWW9Mse5M+1oE5ZBzHDwTivBiWW8oyfO/+b/unYpr3ql4t8qR0oj5pk8aLnok49UKB4kEIIRnlWP29QBsH2mI6RTn3vyKOky/FgDrrq1xZKKZRM6fDWwONjyNQFxeJe7Mt4EWTdUuIQTnvibjmncqLs20ErhdNLmwGovvBkNbQwmnplrQeqlV1bMQk1uJ6JwKfIzKQ1hmOcw7t8LN+fQiU3N8iSvApmcRGGTYDvvGGjdrkp9SVI3PsQVILqxGYkEVMktrUVbLgjSTAVlpJjhc8hcfnAszemKkBDYhskprsf1VFBILqvDrOFOhW5bpIITgRWgODn2Mg3EnNewbYyxQdVt5bSNOf07Co8BMzLLjXc8LKy61iDct/BtpEW9a+Ffw/Ql6/NG3ODKnn8B+MCEZpdjzNhaq8tJY2V9HoIjPvIo67HkTg8D0UuwcaYiJltTRx8KSWFCFjU8j0MDm4OQUC4kY0PokFWPD03BYdmmNwxNNaSPO+VFU1YC1j8NQUFmPy7OshPbd4SX9JOBjdB52jzamTdT5ntSiaiy4HQSD9qo4NdVCoJvHgop6LLobDA0VOZyf0ZM2XSg2txJzbgZgsrUWtgzVp/xcX4ZmY+fraFyZbUW5SxyXV4lpV/2xZqAuFjryv9kur23ElCt+sNBqhSMTzfg+N5dLsPtNNGLzKvFwsZ3QFU/iUN3Axsiz3phirYWVfKKsAd4F2+63MaisbcSZ6ZaUc+59G4O4vEo8XmIn9PfIK7EIax+H4ctGJ7RR4u9JVd3ARt+j7jg+2YzSP0gYPkXn48D7WHhu7kdZmZVSVI3hZ7wRuJ3a0Di9uAZDTnkhaOcgypvRmgY2Jlz0xZXZVugmQovH5mcR0FCREyq15D9rrMa2V9F4uKiXSOc83a0fwAIwqhtwftlIvuNSCqtw9GMs5GUYUFeWhzSTARkmEwoygLycLBRkpdHIbgSbMAAu0FpZDpW1bNQ0ssFgAFwCMBm8z53F4aK2kYPaRg6qGthQlZcBg8ETbqrqOGjkciErLQUpBgPSTAaU5aUhLysFZTkpKMpKQ0FGGkqyTCjJSfP+fzkptFGUhV47FYkY/9Kx6E4QenVXx+K+1H4nhBAUVjXQmpmecE1ASlE1bQvTZc8UeCcV4cEiapHPM6EQv7yMgufmfpRVOjnldeh/3AMf1/Sh3EmvZ3HQ/7gHtg43+KPdpTkIIZhzMxB6msrYNZp/xLgwhGaUYefraJyeZiER/yE2h4tNzyIAAKemWvD9zhBCsPFZBFKLeEbHVOf0A+9jkV1Wi6MTzSXiqReUXop5NwNxYJwxJljy9wHLr6jHjGv+sPxdwJFEdRKHS3DEOR4+ycU4NdVCoCral6HZ2PEqGvvGGAsc8V5Ry8KqR6FQlJHCjpFGQrWJV9WzsOV5JCKyynFxlpVIVU95FXVY+zgcJdUNOD/DUqAK6noWBxkltUgvqUF6cQ2Si6qRmF+F1OIaVNWzIcUEni61FzqVsTkIIXgeko0D72PRV08De8cY03o8CktFHQuXPJJxzz8DCxy6Y0U/HYGu4RLyq7DvXQwAYKxFR0y20hJYPGwRb1r4N9Ii3rTwr+D7E3RmZuYf/01FSXUDjnyKx/vIPKzsr4NFfegN0jhcgnt+6TjumojBRu2wc6Qh1CX4A8fhElz14u069tfXxNpBumK3YDWyOTjhloh7fhnYNcoI02y0RBaagtNLseJBCHr1aIvDE0wF6mH+nopaFlY/DkNOWS2uzrGmNLn8kYDUEiy9H4Kp1lr4RcBEqZSiasy5EYiRZh2weag+bXtYaGYZ5t8KwpK+PSiFCQB4HpKN3W+icW2ONaXgl1xYjd2vo+Cgq0E5Z10jB7NuBKC1oiwuz7KkvCk87ByPr/EFeLTYTqLHnyCsfxKOwqp63FtAnczyNCgLx10T4LKuL2WlU2hmGWZc88fHNX2Erlxjc7gYcdYbU226UIpiAC/FwzOxCM+X2UtMaJ121Q9OepqUnhEAcORTPDJLanFhJrWIdcE9GSEZZbhJ0zLlFluAgx/j4L6pn7BLBgAMPumJzUP1KdPQ+OGRUIj972PxdaNozz3zqi+kUssws780hg4dynfck4AMXPZOgRQ4aCUrg8LaBjSwCGy7q0OKAVQ2cJBXUY8OanLQ76CKspoGMMAAi0NQXsdCO1U5tFWSB4PBAJMJAAwwQaDVRglMKUBeWgptlGShKi8FVTkZKMjLQkGGKREfJElz3TsVfikltK10wemlWHovBIE7BlHeWCcVVGHUOR8E7xxEWYVQXN2A3oe+wnV9X0qRkMslGPR7CxNdxdi2l5Goa+Tg9DTq6punwVk49zUJXzb0o6w4TS6owpxbgbg931ZiZs+HnePxLbkYL1f0FjstCuBVII4864M1A3Uxm8JDqJ7FwbSr/tDWUMbxyfzFew6X/N5yxMbdBb0kEvvsk1SE464JWNxHm7JKsqCyHtOv+sOiSyscm2QuEQGHEIKzX5Jx81sabsy1pkxVbMIvpQRL7wVjbu9u2DBYT6BzOpvDxZFP8XgWko2LMy0Firj/fo3XvFNxyi0JO0cZYoZtF6F/R9gcLs595YUl7BhpiJm9hJ+jiZp6Fm59S8MFj1TMd+iGdYP0JHIcFFbVY8+bGPinlmDPaGOMtaBPjBKW6JwK7HgdjZLqBuwdbSxQKhchBG6xBdj/PhatFQX3sGwRb1r4V0JaaOFfQFZWFgFAAJCsrCzKsRwOl9z3Tydme13IojtBJLOkRqDniM2tIGPO+5C+R78Sr8RCSSz7TyQXVpFxF3xI/+PuJCS9VCJzphZVk7Hnfcii20EkqaBS5Hm4XC654plMDHY6kyeBmYTL5Qo9R2J+JXE6+pUsvB1IKusahXrsi5AsYrDTmTwMyBD4MaEZpcRinws54hwn0Hp9koqI8e5P5Pa3NNqxT4MyidEuZ/ItqYhyXHpxNbH9zY0cd4mnHNfI5pD5twLJ5Eu+pK6RTTn2vn86Md/nQlIKq2jXKWmeB2cRy/2upKCijnJcZkkNMdn9iXyNL6Ac18DikCEnPcn5r0kireeeXzrpd8ydNLA4lOPKahqIye5PxC+lWKTnaY64vAqiv/MjKa1uoBzHYnOIza9uxJ3mvSCEkLk3A8ibsGzacdteRpK9b6MFXuv3VNY1km5b35OCSurPkB+3fFLJgluBIj2WEEIs97uSmJwK+uf5lkp++xAr8vP8m4jKLicmuz8RNof6PMZic4jZXhcSLMDvx9BTnuRlKP2xtuJ+CDn0MY523H3/dDLstBftuTazpIb0O+ZOe/5ic7hk8EkPcssnlfa597+LITOu+Yn0u9Qc9Sw2GXzSg5x2S5TIfIQQ4p9STAx2OpPwzDLKcfkVdcTmVzdyzSuFclxNA4uMOutN1j8Ok9jr/hpXQAx2OpPPsfmU4woq6kj/4+5k/eMw2mNSGO75pRPDXfTP30RSQSVxOPyFrH0USupZ1L+b3/M4MIMY7HQmd/3ShV6jb3Ix6fWbG9n/Lob2t5pqDtvf3Miye8GkvFa4a6Efic+rJMNPe5Hhp71IfJ7o13g/8jEylww47k6W3Qsm2WW1Epu3CQ6HSx4GZBDzfS5kwa1Aga/D6xrZ5OznRGK4y5msfRRK8sqpf8eEuTdooYX/L/zvug228D9JVHYFxl/yxWXPFJyaao5rc6xp+8brGtk49DEO4y9+g4O2OlzW9aVskREWLpfguncqRp31gVWX1vi4pg8sxYw/JYTgWXAWRp31hmWX1jg/s+cfqTLCUlHHwtJ7Ibjjm4FHS+wwRYTKHbfYAky4yPNxuTrbmrbnvAlCeO/NnrcxuDrHirIn/3vc4wsx63oA1g7UxZZhBrTr/RJXgAPvY7F3jBGtJ8nToCzsfRuD63Nt0Jui4ianvA4zrgVgtFlHbKCIY+VyCX55Honc8jpcm2tNWS7vnlCI3z7E4doca4n6KwlCWlENdr+JxvEp5pSeDFwuwebnERhl3pG2Je6qVwoYDGAJTTtIc1TUsXDSLRE7RhjS7jhe9kyFRZdWIns8Nccd33SMNe9E65/knVQMJoNBe85IK66Bb3IJnGjeM0IIPOILhWo3/J7I7Ap0VFMQ2hS6ibTiGpHTeBrZXJTUNEJdif77n1/RgLpGjkjP82/DsIMqwOC1dFIhLcVEf30NfI4roJ1zqo0W3oTn0I6bZquF5yFZaGwmied7JvTsjPyKOvillFCO02qjCJturXHBPYVynBSTgS1DDXD2azKq6lmUY9cO0kVCfhVcYvIpxzVBCAGhKDqXk5bCySkWuOSZjOicCoHmpKNXD3WsG6SLFQ9CUVbTyHdcO1V5XJ1jDdfYAnglFvIdpygrjRvzrBGQVorTn5MEWkNdIwc1DWy+f+9voImTU8yx+lEYvJOK+I7TVJXH48V2iMgux+ZnEeBQRFsLwyy7rjgxmff8z4KzaMfraKrg1QoHpBbXYMerKFTUUh8nTUy16YK7C21x2i0RO1/zEkIFxV5bHa9WOiAsswwTLvois6RW4Md+P8fHNX14IQpPwhGaWSb0HE3ot1fB65UO6KevgeX3Q3DNKxVcCXwew0074MXy3lCWk8bQU16455cukXmbYDIZmG7bBe4b+0FTVQ5DTnnhzOck1LOoz/nyMlJYPVAXnzc4gUuAgSc8cME9mfZxLbTwb6JFvGnhf4KKWhZOuSVi8hVfOOm2hdt6J4F8LzwTizDktBcKqxrweqUDtgwzkKi/SEZJDaZd9cc9/wzcWWCLnSIkNv1IRR0Lax6H48ineJyfaYndo41Ebr2KzqnA6HM+aORw8X61o9C93oQQnPuShHWPw3B4ohk2NpP2wI96FgfrnoTjnn8Gni+zF1gwexachRUPQnFkkplAZq7vInKx6mEY1gzUxSQr6na7p0GZ2PcuBjfm2cBem78QUFDJ8wbob6CBHSMNKX0OjnyKR1ltI+4usKX0OYnJrcDqh7z3UZDoeknSwOZg1aNQLHXqQSsa3PFLR055HXaMpE6/Si6sgndSMQ5NMBWpNeH81yQYdlDBQEPq9RRW1iM6pwIbKQQ0YSmvbcSrsBxaoQ8AvJKKMMuuC217wceoPPTRbUtrvJpUWI2yWhZsu4t2DIRnlYuVVFNS0yhyRG3p7zetbQRo9atrZENRBEPkfyNSTAZ6dW8D/1RqYQQABhm1wxcBxJtBhu3gk1SMkuoGynEO2m2hICtFO6eCrBRm2XXFNe9U2ude2V8H7yJzkVFSQzluoKEmtDWUcM2Lek5VeRlsGWqAA+/jBLqJ2/4qCi9DqYUrk05qWOak/Yf3nCRY0rcHjDuqYv3TcMobYQutVphqrYXVj8KRXsz/PdJUkcet+Ta4+S0Nz0OyaZ//1OdELLsfQvl6hpt2wMHxplh2LwQBFMebpqo8Hi2xQ3hWGY58ipeYgDPctAOuz7XG/nexuOyZQimyAYCGihweL7FDRR0bEy59Q1apYGKKTbc2eLPKASEZ5ZhzI5BSUPuRDmoKeLzEHrbd22DUOW+4x/MX2fihriyHG3Nt0FtHHTOu+eOSR4rI4oisNBNbhhng2GQz3PPPwPRr/sguE15U+pFWirI4NtkcF2da4opXKqZd9UdKUbXY835PayVZHJpghoeLe8E1lpem5pFA/352bKWAs9N74tZ8W3yIzMOQU174EldAe7y00MK/gRbxpoV/NeR3E7YBJzwQmVMO5zV9sGGIPq1AUlTVgDWPwrDqQSiW9NXGicnmAkdTCgKXS3DXLx0jznjDsIMKnNf2Eflm7HtCMkox4ow3KutYcF7bV+TdeUIIHgdmYvJlP0yx7ixQQtOP1DSwseV5JJ4EZ+HZst5/6qMPyyzD3JuBfHcBS2saMet6ADJKavF8WW/oC/DeE0JwySMF+9/F4sZca4GioJ8EZeKXF5G4OMsSI0z59/kDwMOATNz8lo6b82woKzhKqhsw83oAbLq1wf4xJpRVP1e8UvEiNBt7RhtTVrPkVdRhwe0grOivjTHmkom4FoajnxLAZDCwzInaByilqBrHXBJwYrIFlCn8kLhcgu2vomHUURU9uwhfZZZeXIO7fhnYOdKItqrqvHsyFGWlYCHC8/DjSVAWzDq3glFH6uOytKYRD/wzBUoE+RCZR+k10YR7fCF6a6uLLPJGiCnehGWWo1NrBZEeW1LTADUFGYHEuppGDq25+L+B9OIaVNTRVwzY9VAXSLzpq6eBtOIa2ooArTaKsNBqhY9ReZTjmEwGFjr0EKiaZ7Z9V3xLKUFyYRXluK7qShhl1gEXaapvGAwGfhlmgOD0MhRW1VOOnWTVGerKsrjiSS8e9dPXxK8fYmmFq5X9dSAjzRC4soUOBoOBY5PNkVZcg/PuyZRjJ1p1xmSrzlh0N5iy8kivnQouz7LCrtfR8E0uppxzzUBdVNSxsOEpdbXMuJ6dsHu0ERbdCUYYRVWIpoo8niy1x9f4Qmx8Gi4xAae3dls8WmKH696pOOaSQCtqKMpK4/IsKzjpaWL8xW+Ua/6ezq0V8XyZPdQUZDDmgg8S8qkr275HVpqJvWOMcWCcCVY9DMVJt0ShXz+TycBCxx54ssQejwIzMfdWIIqqqI9JKqy6toHz2j7ooaGE4ae98TwkWyJiRl89Dbis6wvjTqoYddYHFz2SwRaiWkkQenZpjberHOGgrY7Vj8Kw7F4IcsrraB9n270N3q12xJoBOtj8PBJzbgYiqYD6/NNCC//faRFvWvjXEp9fiSlX/HDcJQEHxpng5lwbdKdpNeFyeaLFoJOeYHO5+LzRCbPtuko0hjmrtBZzbwXiQ2Qers2xxr6xJmLfpLA5XJz5nIRZ1wOxwLE7bs2zgYaKaEa2tQ1sbHoWgeOuCbg+1xqrBugK/fqzSmsx8ZIvGjlcvF3l+Jeb3DOfk+CVWIRl90P+csGTUlSN8Re/QVOVt6MmyOvgcgnOfknCTZ9UPF5qR9nO1MQNnzT8+j4ON+fZ0IpcDwIycPBjHA6MM0EvCuGmvLYRs24EwqC9Cm2c6tPgLFz4mozb820pzUCr6lmYfysIAww0sdyJ2hj3Z+AeX4gnQVk4O70nZXsSm8PFhqcRmNmrC60Q+SQ4Czllddg0RF+kNR38GIcJlp1pEzuySmvxJCgLG0V8nuZgc7h4FpyN+QJU3bwOy4GFVivaNqPUomokF1YLZNzonlCIfgaii7KRORXo2aWVSI+vZ3GQW1EnlNH495RUN0JdWTARuK6R8z9RebPuSTi+xtMLI3Y91BGYVkp7g6gqL4Ne3dUFElvGWnTEm/Bc2nEjzNrjbUQurSCkqSKPMeYdccMnnXbOVf118Co8h7ZSwrpbG6goSOPsF2oBhclkYO8YY1z2TKGtOhhq3B623dvgtw9xlONkpJg4OcUCt7+li9Xa8j1qCjK4NNPqdxNqarFl63ADdFCTx/on1JU6DjptsX+sMZbdD6G8cVWWk8ateTaIy63ETcIliQABAABJREFU3rcxlDf2U226YOMQPcy9GUjZOqahIo9Hi+0QnVuJDU/DJXZTb9JJDS+W90ZYZjk2PougbW2SYjKwe7QRVvbXwczrAfgULVgLnZKcNC7OtMQ0ay3MvhGIz7H035vvGWvRCS9W9Mbb8BwsuB0kVAVPE+ZarfBhjSNaKcpi+Blv+CRRHxdUKMlJ49AEM5yeZoHDzvFYdj+EVqQUdN49o41xf1EvvAzNwdgL3xCbK5mWwiakmAzMtu8G9039oCQnjcEnPXHRI5m2ZVOKycAkay24b+wHHU1ljDrng33vYgQSxVto4f8jLeJNC/86ahrY+PV9LMZd+AbLLq3xZaMTRph2oN2hTy6swrSr/jj7JQknp5jj4kwr2shVYSCE4FFgJoaf8Ubn1oq4PtdaIJGBjpzyOsy8HoCwrDI8W2aPhY7dRRabUouqMeGSLxgMBt6v7iNQbPqP+CYXY8x5H9j1UMfxyeZo80PFTk55HbyTikEABKaV/hEBCfASJCZc9MUI0w44P91SoOqCBjYHax6H4XV4Ll6scIBxR+pYdUJ4Qs+5r0m4v6gXrQ/KPf8MHP4YjzsLbCjblarqWdj8PBKdWyvg1FQLyjYZt9gC7H0bg6tzrClj4FkcLn55EQnDDqrYP5a6iudnUFBZj43PIrB/rDGtAHHPPwP1jWxaoaSwsh4HP8bh13EmQqeVAYBfSjHqGjmUPkJNnPmShBGmHURu82mOz3GFICAYRNOuRQjB0+AsTLamT7f4GJWHvnoaUKXxgqqsZyE4vQz99ETz3Mouq0NxVQPlMUdFekkNFGWkoCmiMFxS04C2FHHu31PTyIai3L9fvLHQaoWILPqbIMMOqjDXUhPIg2WgoaZA4s0I0w4IzyqnFVA0VeQx0KAdHgdl0s650LE7PBMLaW8Ye2goY4RJe1z0oK6+AYDNQw3wNDgbqTQtG5ZdWmOEaQcc+hhPO+e+MSZwiy2gvVHWa6eCLcP0cdwlQWIeTEYdVbFvjAlWPgxDXgX/6gJpKSbOT7dEcmE1Tn1OpJxzsrUWVg3QwbxbQZRVSurKcri70BZusQW0FUXzHLpjZX9tHHaOpxSFNFTk8GixHWJzK7HxWYTAAg5dO1pXdSWcmW6B+PwqLL4bjNpG/n49Tcx36I7TUy2w8Wk4rnunClR5wmQysHKALvaMNsaax2G46JEsVMWKQXtVvF3tCFlpJsZf/IaobOFFDRV5GZydZoHNQ/Ww5F4wjn6KF8qL50cGGraDy7o+YICBoae9BWqlFASrrq3xYY0jBhlqYv7tIBxziZe430xbZTmcmGKO2/Nt8TY8F8PPeNFWlQGAmqIM9ow2xvvVjkgurEb/4x54HUbv69VCC//faBFvWvjXMe2qH6JyKvB2lSO2jTCkvUGsZ3Fw2TMFo876wLSzGtw2OGGgIf0OuDDkVdRh7q0gnPmchAszLXFogqnApr1UfIjMw/DTXuihoYyLMy1Fvilrmmvs+W/oq6eBQxNM0V5NOOGKEIJb39Kw8E4wtg03xN4xxs22R9z1TYeUFE+EaGBz8SgwE3d80/EiJBsLbgdh+wgDgaPAq+pZWHA7CFmltXi+zB5daMynCSE49iked/0y8HiJHcxp2kfu+qXjqHM8bi+wpYylrG1kY8HtIEgxGDg/oydlW0hgWinWPg7DySnmlL45hBDseh2N1KIa7B/b/Hv5M+FwCdY/CUc/PQ1MsKQWIGJyK3D0UwKOTTanFdz2votBP31N9BeheoTDJdj/Pg4Oum1pK7KSC6vwNiIX6wbpCv08VNzxTcdEq860kdIxuZXIKq2lbccDgPeReRglQMuUf0oJhhq3ozVZ50doZhmMOqqK3HKVWlSD7hpKIouIwlTe1P6PVN6YdVZDZHY57TgpJgMKstLwE8T3xrAdAtNKUV5LXQWgriwHR922eBdJX30zo1cXPA3Opr2hNOygCh0NZTwIoBd6Vg3QwYvQbNr2CB1NZUy07IQTrtQCBgD8MlwfZTWNtFUt7dXksXmYPra/iqIVZebYd0M9i4NjLgm0zy8o4y07YbBhO6x6GEb5nqopyuDaHGvc+paOD5HULW6L+/SAbfc2WHSHWujo3FoRdxfa4o5fOu74plPOudRJB5ZdW2PG9QCkUfjvaKjI4eHvAs6Gp/QCTj2LgyGnvOBKYzLNa82yQz2Lg5nXAwSqbBli3B4PF9vhsmcq9r6NEVhMGmnWAU+X2uOeXwbWPQkXSpRQlZfBlVlWmO/QHVOu+OFpEL3h8o8wGAxMtemCNysd8CWuEL88jxTLu0ZdWQ6XZlli23ADHPkUj+2volBNYVgtKHLSUlg/WB+359vCK7EYI856Iyi9VOx5f8S2exu8X+2I6bZdsOReCDY8CUNBJXX7JADotlPB3QW2ODzBFPf8MiS+rhZa+G/TIt608K9jZX8dPF5iB7129LvtfiklGHHGG+8jc/FsmT12jTISqRqAH02eO0NOeUFTRQ4u6/vCScRd8+/h+clEYPurKByZaIZDE0xFbr1qZHOx710Mtr6MxLHJ5tg+wlBooaCBzcGW55G46JGC+4t6YYpN88a/9SwO7gdk/qkMlsUh2PcuBpc8U3B9rjWm2giWKFVYVY9pV/0hxWTi4WI7qNOYoHK5BDtfRyM6txLPltnTehjd/paGYy4JuLPQFlYU6V/1LA4W3w2GNJOJ09MsKM2h4/IqsehOEHaNMsIwE+qb9YseKfBIKMKt+TYSEfqE5bJnCnLL67B/nAnluAY2BxueRGCpUw+YdW5FOdY1Jh++KSXYM9pIpDU9D8lCTQMb8x260Y495ZaEyVad0VWdumKIxeHimEu8QBe18fmVCM0swzQBjtGnwVkYadaB9nySXFiN1OIaWuNlAPgcV4BOrUUTbgCeX42lGN4/qUXV6NFW9JSzkhphxBv2/4TnjVnnVojJrRRol723tjp8adKcAJ6fjV0PdcrEoCbGWnTEWwFapxx12kJehinQDv58x+6465dOe/Oro6mCIUbtcFmA6pu1A/XwNb4Q4VnllOM0VeTRz0AD+97F0t60z+zVFerKsjj7lboCRYrJwPHJ5ngclCmQ75Cg7BtrjNpGDg47U1cK6bZTwampFtjyPAIxFK0qDAYDhyeaQkFGCmsfU3vQ6LVTwY25Njj6KR5vI6g///WDdDHOoiNm0hjhaqjI4dESO8TnV2I9jYAjLyOF7SMMsfZxOG3qmaq8DG7Pt0U7FXlMvuKHXAG8UMy1WuHVit4oqm7AsvshAlXtALx2rberHJFVWoupV/yQX0EvFjTBZDIwt3c3XJ9rjcOf4rHtZaRIVSm67VTwZpUDVOSlMeKMNz5FU4t2VDAYDEy04vkWphZVY8QZbwRLSGgx7KCKVyt6Y5qNFubcCMTuN9ESEYe+R1qKiUV9euDLRieoK8tj4AlPXPdOpT1fMhgMDDFujweLe0l0PS208E+gRbxp4V/HMBP6FqmymkZsfhaBRXeCMKNXF7xe4QBTmhtPYSmoqMfiu8E48ikep6ZY4Phkc9okGUFoSoDKKKmF89o+GC7Azj4/csvrMPWqHwJSS/F+tSOGmbQXeo6CynpMveKPxMJqvFvlSCl0fIjMA4f71x9dLgEyS2rRWlGwG7u04hpMvOQL/XYquDHXmvYGmc3hYuOzCPimlODQRDPaFqCbPmk44ZaIewt7Ud7sNrK5WPEgFHWNHFynifnOLKnFztdRWOqkTRt5/iY8B5c8UnBzng06qPE3hyWEZ3wt6IWpoIRllOHclyScm25JaTwM8EQSWWkmVvanNjOuqmdh95sY7BhhiLYCpA39SHUDG8dcErFtuAFtelp0TgW+xBdg9QD6qpu34bn4EJkHBQGqUe74pmOcRae/tAL+SD2LgzfhuZhiTZ1eBgDuCQWYbqNFK9ARQuCeUIR++qKLv2FZ5SL73QC8ypseGqLFhAM8M+82ArZN/a9U3vRoqwRZKSYS8ulNNntrt0VweimtBwTAa8dyi6VPbRls1B7pJTWIz6M2a22K9hWkoqafngZaK8oKJAqtHqCDlKJqyvYhgFcpM9+hGw47x9G2tMzr3R2NbC4eBlKvVYrJwKEJprj1LQ1xNK+/h4YyNg/Vx+bnEZRx28IgLyOFSzMt8TQ4C840xtGDjdph4xB9rHkURtmSJicthauzrZFSVI1fP8RSzmnVtTUuzLTEw4AMSqGPwWBg+whDDDDUxMzrAZTVD22VeRU4iflVOOQcTyngDDVuj8uzrbD9ZRRtpYq8jBQuzLSETbc2mHjJl9YUG+CJmIfGm6G6gY2pV/xRKEDVBvAfEUq3nQrGnPehFQx/xEGnLd6vdkRsXhUmX/YTqXpGXkYK+8aa4NAEM2x+Holdr6PFak/q3EYRDxfZYY59V8y+EYgjn+IFOo/QIS3FxJK+2nBe2wcJ+VUYespLoLQoYWmnKo8dIw1xdbYVHgVmYvQ5HwSm0YtQkkyHbaGFfwot4k0L/1MQQvAqLBuDTnqitKYRLuv7YlGfHpCWYEsKIQRvwnMw4qw32qvJw3VdX4GMSOngcgmueqVg8mU/TLTqjIeL7dCxlWipLwDglViEUed8oN9OBS9X9KatUGiOsMwyrH4UBl1NZTxZYkfbanXFKwX1rOYvGFhcLmbdoL4wBIDI7HJMuuSLESYdcHyyOW2VUAObg5UPQxGXV4knS+3QieY9u+6dig9Rebi/sBdlKg+bw8Xax2EoqmrA7QW2lAJSUVUDZt8MgGWX1ljRj9p0OCC1BFtfROH8jJ60aUZXvFJxySNFortdFbUsrHoUhl2jjGDamboNLySjFHd803FyCv3ncM07DT00FDHJit4Dpjkuuiejh4aSQALjSbdEzLbrSns8crkEFz2SsbyfNm2UtzDx4G6xBVBXkqUUMpt4HpwDSwHGxeRWoq6RI3JMfD2Lg9jcCvTUEqPypriGVvikQk5aCp0FTKqSlWIKJKgBgPb2j3/xbTnmEo+jn+i9TwCegfp/K6GEyWTAtLMaIgXwydBrpwwFGSmB2qwGGbWDe0Ih7Q61spw0plhr0VZfAMBkq87wTy2h9chhMBhY6Ngd133oPUf026tCTUFGoJSoZf20EZ9fBc9E6ooiWWkmdo82wgnXxD/i6flh0F4Vy/vp4Lx7Mq0Z9Fz7bujUSgEHP1IbHQtDt7ZKOD7ZHFueR9J6+sx36AaD9qpY8SCUttXq9jyeX8hNnzTKOfvpa2KaTRcsvx+KCAqRgsFgYP8YE1h3bYOZ1wMoBaS2ynJ4sLgXviUXY90TahNjJz0N3JxngwPvY3HrG/VapZgMHBxvgslWnTHreoBAqVJqijK4u6AXdP+Pvb+Oiypt/P/x58zQIS0iYiCoWKCoKNixrrV2d7dud7md7rp2d3eunYhBCAgIEiIojXQzM78/ZvE2YM414uf3vd9783o8/Gf34syZU3Ou1/WK2mYMXeXHfcH73FBPwa8jWjOrqzMfHgjhcJB0FfuzqGtpzL7ZHXF3smDQcl+uSlyzVWFAawdOLepC6OMchq7yq1ZVt1wuY0YXZ44u8OFKVDqDV14XIo1F0NDWlN0zOzK/hwsLd93hh1MRrxTeLAVvF1v+XtyVwR6OTNl8m3f3BVeroasGNfi/iBrypgb/M3iYUcCkTbf58VQk3w5pyYbJ7ahXDQtCZcjIL2HeziC+OR7Bd0Na8t2QVjpXbFeGtNxipmy+zbXoDHbO9GJ+DxfJyWZVUKrU/HHuPuuuxvFJv2b8NLz1K61O7A9IZNz6W/RtUYdfRkhvIzgxm7j0qj3zajXkFpUxfsOtKpUkV++n8+uZKOZ2b8wn/d0kc3EKS8uZsTWAlNwS9szqSG1z7ZP59VfjWH4xhq8GNdeah6NUqXl/fwhx6QVsm9ZBa9BsbnEZkzfdpo2TJZ/0c9OqCotNz2fW9kC+GNic7hINWBfupfLXhWjWT2on+b1EoVar+fhQKE3szRjnpV0dVFhazrv7Qni3TxNcJSyKgQ+fsP5qHN8PbfVKeSmJTwrZdP0BXw6Urgb3j39CXEYBcwSauc5GpFBQomRoG2lCSbQeHDShyuM71pfc1+jUPOIzC4Qyti5FptHF1faVs4/Ck3KwMNbHyfrVCF+1Wo2poYLG1VDe3H2cg6mgFSoltxjjaihvlCrIKxYjNS9EphKTJj0pikzJpduvl4T3QTRro3U9SyFCRiaT0VHQOtXa0QJjfQX+AqvTXVztOBqcJEm01K4lHlw8pI0jmfmlXBNozlnY05U9/gmSyohaRvos6OHCT39HopQ4tt2b1qZdAyt+PyudUzO7qzPhj3PYcVN7PoZcLuPXEe4cDU565cl4Zejbog5jveo/VXFWBU3VeGtyisr49oR2VU19G00pwm9noyRzZYa0ceTdPk2Ysvm21vtALpfxy4jWNK1jzoSNt8kprLrNx9bMkJ0zvIhOzWexBIHj5WzD9hle/Hk+mpUSFeoymYx332jK272bMGHDLS4JqDwM9OT8Psqdke3qMXy1H9cFwm8rPmtGF2c+69+cL4+Fa647HerADfUUfDekFZ8NaM6cHYGsuBgjWXteGZysTdg/uxNdXW15a7kvBwJ1I5JeRBN7c47M96FnMzuGrLzOuquxr6XmXS6XMc6rPmff7UpyTgl9/rjCydDk11JX/iwM9OTM7d6Yc+92o6hUSc/fL7PVL/6115fXoAb/raghb2rwr0eZUsWqyzG8sy+YBjYmnBdsn9IVf99Npu8fVwE4807XatmZnsWFe6m8uewa1qYGrBrftlqZFZn5JUzZfJtjIUl8NsCNkQK2jhdRrtRk5Hx/6h7rJ7VjeudGQsdyw7U41Gj/ES9XqYnPKGDezqCX/t+RO4+ZvT2QEZ71mNHFWfLzKkiT0nIVO2d4YSlhyVp7JZYVl2LYOcNLa3aLSqXmmxMRhD7KYccML63kXHGZkplbA6hdy5BfR7prJZvS84p5b28I47zqSxIn0al5vL0nmJ+Ht65WSPWL2HU7gcCHWfw20l3ynP54KhJ7cyOmdW6kdVxJuZKPD95lUS9XGr1iXspPpyMZ1Lqu5HdVq9X8eiaKwe51JTOQ1Go1qy7HMrOrs9YKdNCQddtuPBSqB3+cXcT+wEcMbF1XcuzJu8n0aFpb0poGmopwqUp7bQh6mI2Hk9Wrhw0XlHI9JvOVz6FmGyWSlrMKaGxTYkSPDA35+ywM9OTCtgALY32yBWplbUwNeZhZKGRf8I9/Qu+lV4Q+38PJghDBhhpN7o305FMul9HLzZ6zAtXH3ZrYkV9STuBDaSXDxE4NCHyYJanoMdJXMLFTA9Zfk1bUNK9bi66udqy9Kj12YqcGGkuWQMjyFwObczDokWRDl5G+gu+HtuLXM1GSeSpO1iZ82t+Njw6GvtYq4g/6NsXaxIBlF+5rneyaGOixflI7jocksVvCFtamvhVLR7mz/cZDraoagGmdGzHOqz6TN93WamFTyGX8OdqDuhaGfH08XKvq08bMkF0zvYgRIHA8nCzZPbMjm3wf8Oc57ccAYEyH+vw0vDXzdgRx+I40mSGTyXi7dxO+GtSCGVsD2B8gHijcrakdR+b7cCY8hVnbAsgr1u28j/Csx/45nQh9lM3MbQGvdN0Y6Mn5pL+bpvDi1D1+OHmvWopbAz05H/Rtxo4ZmuaxKZtvVysc+Vk4WBjz1xgPvhzUgi+OhjFre6BQ0LCucLQ0ZvUET5aPbcOOmw+ZtsWfIAE1Vg1q8H8dNeRNDf7VCErIYtByX47eSeKzAc35bkgryTpeXZFdWMqi3Xf45PBdvnqrBavGt32lTI8XUVym5Otj4SzeE8wXA934c0ybagXXBj58woC/fDE30uPYAh/cHKQVBC8iq6CUSZtu4xeTydH5PnR2FasSz8wv4e+wFLS97xvpy9GTy9D/xy7x7MvbhmtxfH4kjHWTPBns4Sj5eU/yS5iw/iamhnpsndZBcnK8+nIsq6/EsnOGl1aCQK3WEDdhj3LYOdNLa+NRuVLFot13KFWqWDW+rVbFhCb0OJCmDuZ8IFG1nVVQyoxtAUzxacggd2mCQBRRKXl8f/Ief472kCQ+rsdkcCzkMb+NdJdUgK25HPdP6KB2kqcqBD58QuCDJ3zQV/txAbgWncH91Dyhz/KNySDxSSFjO0gTmJej0tDXk9FHwP54KPARXVztsK8lrYY6GZrMAIGWqScFpYQ8yqlW3k1iViFdBO/XyhCXXkCdWkbVCnTPzC/FViCwWKlSU1quErZNyWUyVC9M9gz15JQKrsRamRiQJdHMBGBjaoCBnpxkgRDTBtYmPHxSKFQv3aqeBcVlSqHsKu/GtgQlZAsRSH2aayrDpSbCBnpy+rdy4KhARk0nZxsSnxQJBRdP6NiA2w+eCFkzFvVyZeeth5IWCEM9BSPb1eO3M/clq6Yb2poy1acRS46HSx4DHxdb3mhhz1fHwiX3dWwHJ3xcbFh6Trr9ShT6Cjl/jHbnQOAj9krkvzhZm7BqvCffHI+QbPl5s6UD3ZraMX1rgKTd7f03mtLF1ZbJm25rbSrTV8hZOd6TjPwSpm3x13qNVxA4sWn5LN6jncBpXrcWe2d34mp0Ot+ciJA8Z4Pc67JukidfHAlngwBJCBoiZePkdnx7IoL1V8WqxAEa25lxZJ4PpUoVw1b58TCzahVxZWhR14JfR7ijBgYt9yUiSXvGUlXo3rQ2pxZ1Jio1j0HLfSWJSSl4NrBmy9QO1LMyod+f19gfkPhalDIymYy33Oty/t1umBoo6L30CntuJ7x2FQ5ojsnxhT60a2jN+PW3+OhAqKRdsgY1+L+MGvKmBv9K5BaX8cWRMMavv8Ug97ocX6g9SPdVcTkqjT5/XKWwtJyzb3flLfe6r0XRcz81jyErrxOcmM3JRZ2FbB1VQa1Ws9H3ARM23GZWV2dWjmv7SiRQZEoub630pZaRvs4ZObtuPXxpclVB1hjrK+jiassHfZtxdIEPYUv6snqCJzKZDJVKzfcnI1h9OZbdMzvSxVV68pqaW8zodTfxbGjNuonaQ4QBVl6KYe1VMeLmp9ORnAlP4c8xHpJBwp8fCeNBRgGbp7TXqiBQqdS8vScYfYWMJW+10KrOKVOqmL8riGZ1zHmndxOt30sXFJUqWbg7iGk+jfB20T7Bzyks4719IXza3436NtpthzFpeay+EsPPw1u9kt1HpVKz5HgEE7wbUFuCDKlQ3czt1ljo+l55KYZpPo2E1B0brj1gdDsnyWwslUrN/sBHjGonfb9GpeSRmFVIT4HK9Kv303FzMJc8BtpwNjxVqIGvKsSl51crrLioVElhqVKSGASeEhOi5A0yXtL0GSjElTeWJvpaLSAVkMtl1LUw4nGWdNuNnbkh5oZ6QhkVdS2MyS8pJ1xgQtfQxoSOjay5k5AtOda7sS2Z+aVECeR8DPaoy8m7yZKKGk1wsRO7bksrF2zNDBnb3kmyTQg0LT8+jW2FlDqDPRwxN9ITqgFe0MOFhMxCocaezwc0JyD+CafDtNuMZDIZ773RlMNBjzgnoGwShb2FMX+NacOS4xGSk/JOjW34pH8z5u4IlFQLTe/ciH4t6zBti79W1YdMJuO7IS1paGMqScoY6WuCkVHDrO0BWok0m38sVLHpGgJH2zXmUtuMZWPacP5eKp8cuitp5+niaseumV6suhzLjwJh1qDJTTkwx5ttN+J5b1+IJAlYAQsTfTZPaU8XVzsGr7wupIB78e83TGrHSM96jFjjx8FXtD/ZWxizaUp7hrd1ZOSaG2y+/qBapIipoR4/DmvFsrEe/Hw6ijk7ArVmGukCa1MD/hzThmVjPFh2IZrxG26RkPl6FD7Pwkhfj0W9XDn7TlcyC0ro8dtldt56+Eo2tRrU4L8dNeRNDf51uHQvld6/XyEuI5+/F3dhfg8XSVuErsgpKuP9/SG8szeYT/s10+SOVGNiVQG1Ws32mw8ZsvI6vd3s2T+n0ysFCVcgr7iMeTuD2HAtjh0zvJgmaHF6EWfCUxi77iYjPZ1YNb6tTqvv+cVl/HE+GrUaFDIZxgYvkzXbp3sxvXMjWtS1eKrkKC1X8e6+YM6Ep3JwrrdkeC5oslFGrrmBu5Mln/V3kzzvKy5Gs+FaHLtmdKRFXe3bX3YhmkNBj9k1syNO1tpJi2Xno7kWncG26R0k7Vo/nLrH/dQ8IaLp2+PhPCkoZekoD8m8H13w7ckIzI30ebu3dDvT18fDaeZgLtmkpFKp+eTQXcZ7NZCsEK8Kh+88JjO/lBmdpW1yZ8JTSM0tZlKnhpJjAx8+IexxrtBYXerBbz14Qn5JOT2bSSt0ToYm0bNZbaF7KTwphzdb6N4EV4Gk7CLS8opxd3p1i11cRjWbpgpKkMvAUqBxr+gf8sbIQOy5LYOXyGEDPTklwuSNmPIGNEGkIlXFMpkMV3tzogVacWQyGR5OlpLWloqxtuaG+MZIZ64Y6Svo2sSW8wIEQ4eG1hjqyfEVyAMZ2c6JG7EZkkoOgPEdG7DB9wFpedJqpUW9XNl+46HkxFEhl/FRv2asuBRDroSFxdRQj88GNmfJ8XuSyiZrUwM+H9Ccr46FSW7XwcKYrwa14JNDd19rMKu3iy3zezRm/q4gSXvNxI4N6O1mz5dHwyWzcr4a1BwnaxPm7QzUSmrqKeT8NbYNenIZ35+M0Eq0GBso2DilHbnF5SzYdUfrWJt/Wqhi0/P55rj27TpZm7Bvdiduxz/h3X3ayR7QZEYdmNOJEyHJfHAgVCj7pEkdcw7O8yYmPZ/Jm7Tn9zwLPYUmDPuTfs2YviWA3belCcRnIZfLWNjLldUTPPn2ZASfH7krTB49C4VcxoKermyb3oF1V+OYuS2w2tdhz2b2nH2nK3KZjL5/XhVS1+m6bWc7Uz44EMKGa3GvJWfnRThZm7Bhcnt+H+nO6suxzNjq/9o/owY1+P8aNeRNDf51+PlMFB/3a8aO6V40rEYzSlW4cj+dN/+8SlpeCacWd2Fo23qvRW3zpKCU2dsDOR2WzMbJ7Xm/b9NXDicFuJecywf7Q8kvKefkoi6vpDxSqdQsPRvFe/tC+H2kB4t6uepEGmTmlzBh4y0MFHJmd3Xm2EIfwr+unKx5FvnF5Uzf6k90Wj4H53oLnceYtHxGrrlBz2a1+WV4a0mVxF8Xorn14Ak7Z3SUDKFdcyWWrX7x7JzhJdm2s9H3AafCktk6TXvNN2iqpw/deczmqe0lg6133UogLqOQ9ZOkq9F1wbmIFE6EJLFsjIfkMTsdlszFyDR+Ht5a8prf7Z9AUnYx7/Z5NYVQYWk5v5yJ5KN+zSRJLaVKze9n77Owp4tQyO2m6/HM79EYCxNpIqGiHlwkeHx/QCJD2zhKkoZqtZoTd5MZ0Era9qb8R83TqfGrW57uJGTTrE4t4QyZyhCXno9zdfJu8kuxNjUQen4UlSqRyzTqGRHIZFVk3gjapiyN9ckWnLzVtTTmsQB5A+Ba24zoVLF2GA8nS+4IVhJ7N7YVCi0GGNDKQYgUkss1Noejd6RVMva1jOjZrLakvQfA1d4c78Y27BBQybg7WeLlbM0GX2n1TfcmdjSrY87aK7GSYwe1dsDRyphVl6THDmvriEttM349LR10PKytIx5OlnwpYLXSBfO6u9DI1pQP9odoVVTIZDKWDG5BYWk5Hx8K1TpWTyFn+dg2ZBeW8dnhu1rHGukrWD+5HYEJ2Xx0MFSresHcSJ+tU9uT+KSQ9/aFaJ2QW5sasGuGF6GPslm8RzvZ42BhzL7ZnYhKyWPeziBJgsPZzoxD87y5+yibr45pJ7MqUNvciD2zOmJmqM+w1deFyMgKjG5fn63T2rPjZgKfHb4rSTC9iG5N7Di+oDMhiTmMWntTiBCuDO0bWvP34i7IZND/r2tC9dnaUJGt+Gl/N97eG8zHB0PJe03ZTuZG+nw3pBXv9mnCzlsJDFvt99rarl5E7+b2nHunGx2dbf6fbL8GNfj/EjXkTQ3+ddg9qyPDXhOh8izyS8r55FAo83cGsaiXK1unSk/OReEXk0G/ZVeRyWDluLZ0aly9H5z9AYkMX+2Hm4M5W6Z2EA4JfRZ5xWXM2h7I0ZAkDs3zpqebbmGpMWn5DF3lh6OlCcFfvcEn/d1oUddCcvKWkV/CuA03cbDQvFhpy5WpQERSLqPX3mC4pyNfDWou+RnLzkezxS+ezwa4SRI3W/3iWXUphu3TvSRtJ4fvPOKPc/f5dYQ7LrW1jz0fkcrPpyNZP6mdpLrqZlwm356IYGFPF0nVjy6oeOH+fZS7ZPNael4Jnx4O45vBLSTzXFJyivjp1D2+H9rylYmmNVficLQ0ZpBAJszR4McUlSkZLaCOuZecy/mIVIYLVJbrUg+eW1zGqbBkSUUSwL2UXBwsjIQsU8GJWchAa229FIISsmjb4NX/HjSZN41r//8nrLioTImxvkL4GS6XyXjROKWxTYmtaFuZ6kbeiE60XGqbES3QYgXgXk9MeQOa0OLQRzlCwak+LrZcjEoXCgx9y6MuZyNShbJ3xnaoz76ARKFJ64zOzmy/+VAop+ed3k04fCdJUkUgk8n4uJ8bm3zjJb+bTKaxpG7wjZPMKpHJZHw/pBXXYzIkq6hlMhk/DGvJteh0ToZK27JEIZfL+GOUB+FJuWy4pr0+21BPwbIxbbj94Ilk4LOpoR6bprTHNyaDFRe1tzpZGBuwdWp7/OOf8NPpSK1jLU0M2DHDi/CkHD49dFcr2WNtZsjmqR14kFHIot3aCRxbM0P2zOpIWl4JM7YGSBIy9rWM2DO7E/dT85i48ZaQmsbEQI+1Ez3p4mrH0FUaq7ooOjSyYe1ET4ISspm48ZbOOStO1ibsn9OJ5g7mfHrornAL1ouwNDFg3URPZnd1ZvKm22z2fVAtVYtMJmNY23qcfrsrucVlDF3tJ5mtpAu8nG34e3EXOjnbMHilL3+cuy9scdUFxgYKZgm0TtagBv/XUEPe1OBfBysJm8qrwC8mg75/XCU+o5C/F3dhbAfpGmARlJar+OnvSGZsC2BxryasmeApabPRhuIyJR8dCOXHvyNZM8GTxb2bvFKl+IOMAoau8qOkXMnR+T46Z2XciM1k+Go/BrZ2YPnYNsJV5AmZhYxY7UcDG1O+HdJSKLskKCGLMetuML1LIz7o24zrMZn8cjqyyhfIP87dZ9uNeHbP7EizOtqJmz3+Cfx6Joot0zpINh1dikzj00NhrJ7QVmvNOMDdRzks3nOH30e6SyqiEp8UMneHpj7c6zWuIpUpVSzec4dB7nXp01y7JUetVvPp4bt0crbhLYGQ5K+PRTCinZNk3XlVSMouYv3VOL4c1ELyPistV3HqbjKLe7kK2SNXX45lVDsnoXr1vf6JuAvWg58ISaapvTlN60jfK6dCU7A0MRBSCV2MTKNbE7tXuo8rcCchq1otdWVKFQlPCnGuhpIxI68EG9OXidhdtx7yzt5gvjgSxo9/3+PP8/fZdesh9rWM2BeQyPGQJM5HpHI9JqPKlqO29a148XY3M1QIk+u1jPUpFiR6HC2NSNLSxvMsXO3NhSrIQRNa/CiriAyBrIm6lsbUtzYRWmW3MTOkbX1LzgtYIJo71MLHxUYox6WLqx36CjkX7klXNfu42GBfy4iDQdIZH+5OlrjWNmOjr3bSAjSEZs9mtfnzfLTk2JaOFgxtU4/vTt6THNvQ1pQRnvX4+OBdyUllbXMjvh3cks+P3JUMW9YFVqYGrBzflqXn7ktOnO3MDVk70ZO/LkRzKVL7+bCvZcSmKe1ZdzWOkxKNXbVrGbF9mheHgh5JKpw01eAduRGXyV8Xo7Uqe6xNDdg5w4v4TGkCx9LEgB3TO1BSrmLm9gByi7QTJFYmBmyfrmmXHLnWj5QqwsWfFJQyc1sASdlFKOQyvn6rBfO6uzBu/U3JzKNnUc/KhANzOmFpbMDglb46K0mM9BX8OKw1/VrVYcbWAFZdjnml/BqZTMYUn0bsn9OJPf6JTNhwq9oNT46WxqwY25Yx7Z2YtPE2P5+OfG0ki5G+go/7NWP/bG/ORqQycPk1SbK0BjWogQY15E0NaqAFhaXlLDt/nxnbApjdzZmdM7xem/IhPqOAEWv8uHI/nWMLfBjnVT1CKP4fwiU6LY8TCzvTtcmrNdNcuZ/O4BW+9Ghqx+Yp7XUmkw4GJvLJoVA+6+/Gh282E7ZZhT3OYdhqP3o2s2fZaA8M9aQntrfiMpm08Tbv923KvO4ugMYOtfpyLJ+8IA1Xq9UsPXefnbcesntWR8lJ9pE7j9l5M4H1kzwlJ76BD7NYsCuIX0e2lgxVfpRVyJLj4bzXt4lknXx+STkztwXwlntdyfpwXfHHufsUlCj5YmBzybEHgx5zJyGbb4e0lLxGz4SncPNBJvN7uLzyvv1yOpI3W9YRUpvsC0gkPrOQYW2llTTxGQWcDk9hVlfpDJ1ypYptNx4yRUB1A+Afn8lYgXOkVqs5eTdZSFEEcCkynR4CCp2qUFKuJOxxbrXIm4QnhSjkMhwtX11pmFlQSu1aL5M3YUm5HAl+zPabD1l/NY4Vl2LYeSuBBxkFfH0snI8OhrJozx2mb/Vn+Gq/SnMYQhKzX7JNyWQy7gsE9QJYmxgINUgBOFmZCFW7g8Y29TCzQEhxYmGsj7OdKaGPsoW23amxjbB1qrebvVDujUwmw72eJccEWqcUchlj2jtJ1lVXbHdGF2c2+j4QChBd3MuVLX7xQsqJ9/s25e6jbGIEzvX7bzThVlwmV+5L5wXN/OcZIRKgPMi9Lt4utpJ2JF3h4WTJx/2bsvJSjCSp17qeJT8Oa8WiPXckQ7LdHGqxZqInHxwI5Vac9muooa0pW6Z2YMXFGA5IBOzWsTBi54wO7PNP5JczUZIEzi5BAkdjzeqAQy0jJm7y19qEBRpiYM2Etng4WTJ8td9Lx6OgpJxx629yPiKVXbf+Y+eb1rkRf4z2YJPvAzYKtleBRtG0anxbhrWpx/DVfpwNFyd/KjC6fX32z+nErlsJzN4eKJm5VBVaOlpwcJ43DhZG9F92jUtR0uSqNsjlmnv36AIfrt5PZ/DK66/V6tSqngXHFvgw2MORsetv8s3xcAqqUYFegxr8L6CGvKlBDaqAf/wT+i27hl9sJqcWdWFSp4avJSRWrVZzIPARA5f70q6BNYfneUtabKRwOiyFQSt86eRsw55Znaj7CpMstVrNuqtxzNkeyJLBLfhsQHPJDJRnoVKp+e1MFEuOR/D90JaMai9tH6nA9ZgMxq67yYwujfhioJvQcb5wL5WpW/z5aVirp8GzWQWlBDx8ghoN+fLJIc3LdAVxs+tWArtndpRUEp0OS+aTQ3f5oG9TyayR+6l5TNviz8f93RjYWrsqJaeojKmb/WletxZTvbXXWatUat7dG4yNmYEQwaILfKMz2OIXz4px0qqopOwifjwVwc/DW0naXnKLy/jyaBifD2iOrUCrUGW4k5DFmfBUPnxTuhq8uEzJ8ovRvNdHTGG29mosA1s7CBGw5++loVarherB76fmcepuCv1aShMy4Um5pOYWC6mSUnKKiUrNo9srErEVn2dmpEcDiWYwbXiQXkDbBlbVev49KSitNKx4dldnKraqUkO5Uk2ZUo0aKPynoaqwVElxmYo6tYwqDYOWySoPLBZdJbYyMSC7sFRo4m1vYcSlqHQhEsLBwgjvxrbEC9YKe9SzJFigRQrAp7GtsM2iT3N7rsdmCk2K3nJ35Gp0ulD46cj29cgtLhPKChnk7kBecTmX70tPJts1tKZ1PQs2XZdW3zSyNcWjviW/npXOqLExM+TdPk1Ycjxc8trQV8j5cXgrVlyM4UGG9Pn7dnBLcovKOBYiTXzpgkkdG2JmqMfiPXckrTCDPRwZ51WfmdsCJCf/Pi62fD6gObO2B0qSPS0dLVg70ZMvjoRJhtg6WZuyfYYX+wMSJa1ZVs8QOAslAo+NDRR8N7Ql9uaGjFl3U1LlpKeQ8/Pw1rzlUZeRa248tSSWlquYtsWfuPQC1MDOWwnPHde+Lerw6QA3Vl+J5etj4VqPeZlS9fQ+kctlvNOnCb+MaM07e4NZeUl3BU1LRwuOL+hMSbmKwSuuE5nyanXiZoZ6LB3twaf93ViwM4gfTt2rtmKmib05h+f50KtZbYasvM66q7GvLXBYXyFnfg8XTizsQnZhqea9+xUtZDWowf8CasibGtTgBRSXKfnuRASTNt5mYscG7JrZ8bUFH+cWl7F4TzAHAhNZPrYNXw5qLmwpqgxlShUrL8Xwwf4Qfh7emi8HNX+lZq3iMiXv7A3mRmwGe2Z11LmavLhMyaI9dzga8phD87zxcRGfbB4PSWLG1gC+fqsFc7o1RiaTEZeer3VydDwkiQW7NLajgc/YeM6EpzxV7JSUqzh05zGfHb7LL6fvscc/kT2zOuIqQdxcikzjnb0hLB/bRlK99CirkEkbbzPVpyETOzbQOra0XMXcHYHUtzbhy4HNJRUsf5y/T1RqHivHtdWJRJNCRn4J7+wL5suBzSWPhUql5v39IQz2cKSXmzSJ8cvpSFxrmzO8reMr7ZtarebP8/d57w1XIcvL9hsPqW1uxJstpZuYUnKKORj0mHndxTzw5++lMqlTA6Fjvz8gkX4t62Ah0KR08m4yvd3she77y1FptHGyrJaVMjJZQ/5UR9UXm56PlUC4szZkFpRWWhPewMaU7k3tkOKFDPTkVT7f5HLZS8obQz2FcNuUlYkBZUo1+QLkhqOlMaXlKjIKpC0yMpmMvJJy7guGFndoZC20XYCOztZEpeYJVfo625lRz8qYa9HSipP6Nia0crTg5F3pDJc6tYyxMzMUCi421FMwuVMD1l+VJmRA0zy16foDycalirHXojW2OilM6NgAPbmMbTfiJce2rW/FyHb1hBQ11qYGTOvciC+OhFVp1XkVyGQyfhremuScYpadvy85/sO+zXCyMmHxbmmyZ5xXfcZ2qM/Uzf6S15G3iy2/j3Jn4e47BEkc58Z2ZuyY4cXG6w/YIKFgqSBwHj4p5IsjYVoJHEM9BSvHt6VpHXNGr7tBsoR9USaT8dGbzZjfw4XxG25xOSqNRXvuEJyY/TTMvKBU+VLDmoeTJYfn+XAtOp3Z2wMrzYBSqtRM2+LPWyt8n7s2+rdyYN+cThy585jPjoQJqe6ehZWpAZumtOct97oMX+XH0WDpAPGqMNyzHscWduZadAYj196odkW3gZ6c9/s2ZccML3beSmDs+ps6hTxLwaW2Gb+N9GB650bM3BbAxwdDhe7/GtTgfw015E0NavAM7iRk0f+vawQ8zOLEos7M6OJcrayJZxH48An9l10ju6iM5WPbVssKAZrJ6Nh1NzkRmsTRBT70r8KC88vpSA4EVP1ynZRdxMg1N0jMKuLnEa0l81peRGZ+CePWa9oSDs/z0UlFtPt2Ah8fDGXVhLZPA2TT80rovfTKU9XMi9jrn8BHB0NZPaHtS7aj/YGPntYMg4Yw2eufyLGQFHbN8MJFInD1ekwG8/+xP/WWUFxk5pfwyaG7DGxdh8W9tFdsq9Wa2uzc4jJNDasEIXA2PJkt1x+wYVK7ak3cX4RKpea9fSF4NbJmtIAyatuNeBKeFPKOQGNUQPwTDgY+5vuh0taqqnA8NJnIlDzGeWknwkATqL3qcgzvvdFE6PM2XIujZ9PaQtfnveRcToQmCQUglylVHAp6LBRUrFarORmazEBBy9TFyLRqPyeux2ZIXvdSiEsvqFbTFGjapmzMKr+WF/R0/Sd0uHLIZOBiZ0a/Kki6qqrCRVebzY30kMsQCi020ldga2ZAUrbYBL1JbTMhSw9AM4danAxNEVqxtzEzpGXdWsJBon2a23NWwDoFGgWHiHUKYKyXeHDxeK8GyGQQ9jhbcmxHZxvcHGqx1S9ecmxtcyNmdG7Ez39HSh47PYWcJW+14ERoklB9+Qd9mxKXXsDBIOlJ9Bst6tDbzV6y+UlXmBnqsWaCJxt9H0jaYBRyGX+NbUOZSs3yC9JZQB/2bUqrehbM3BYgSTT0b+XAN4NbMm2Lv6QlsVmdWmyb1oFlF6LZdUu7ta6CwHmQUcCCXUFaryV9hZylozzo0NCakWvECInpnRvx7eAWfHzwLucjUp8jdcvKVWyvhMhzsjbh0Fwf8orLGL325nPXilqt5oujYdx+8ITU3BJuvGBfbFHXgl0zvLifkseotTe0knlqtZqr959X8in+UfGsGNeWL4+G8+f5Vw/0bWxnxuF53rjXs2DA8muvZOl6EZ4NrDi1qAutHS0YsvI6+wMSX9v1LpfLmOzdkDPvdCUpp5g+S69w5jXscw1q8G9CDXlTgxqgyYX4+XQk49bfYqSnEwfmdKKxXfUmKxUoV6pYdj6a8RtuMcW7IVumtBdqUNKG6zEZDPjrGg1sTDk01wfnKvY1OaeItVfi+PjQ3UrDLQPin/DWCl+aO9Ri10wvoRDXZ1HRKFXX0phdMzsKW2XUajU/n47krwvR7JzhRY9nLCTHgh+jJ5dzOPgx352899xLwUbfB3x34h6bp7R/yXaSmV9SaeCdUg1pecVsu/FQ6wtGQPwTZm0L4NvBLSXtT/kl5Uzd4k8tY30+6S+toll2IZqbcZlsmtxesn0p7HEOb+8NYfm4tpLKGF2x63YCDzLy+WFYK8l9jk3P55czUfw20l0yOLqkXMnHh+6yqJerZHNWVSguU/Lz35F82LeZUKX1Rt8HuNY2F7IUZeaXcCAwkXk9xFQ3utSDX4xMw9hAIVRJGvY4lycFpUJ5VCVlSu4l5z53b7wK7jzMok01mqoA4jLycbarnvows6AEmyqOZ9v6VlozqBQyGd8Mrjq8Wi6rTHkjl6wXfvr3chmWJgZkSWRpVMDR0pjHWaKhxWbCyhs3B3OKSpXEC66QezWy4Wq0oHXKzZ5LkWmUC5AsA1o7EJSQJVSJ3lWH4GIrUwOc7UzZ5Bsvssu83cuVjb4PhFq1ZnZ1JiY9n4sSgb0AnRrbUtfSWKgO3NxInyWDW/D9yQghldNXg1pwLzmXfVoWTJ5FbHo+n0g0NIHGtvLtkJa8szdY8rxYGOuz5K0WbLz+QFK5IZfL+H2kOwDv7QuR3I8RnvWY7N2QSRtvS+5H63qWbJrSnu9PRnD4jva8HCtTA9ZM8CTxSZEkgaOQy/hxWCv6NLdn1NobQqHgj7I1YeDlL3w/NXApKr3SpigLE322Te+AS20zhq70e0pYbfR9wIGARErKVZQpVZVW29vVMmLnTC+a2pvz1grfKlusVlyKYdKm25UGivdoVpvjC304G57K2PU3XzmA2EhfwTeDW/LbyNZ8djiMTw7d1VkR9CJMDfX4fGBzfhvpzi9nopi9PVDo/hBFPSsTtk5tz0dvNuOjg5qW19cZCF6DGvxfRg15U4P/eYQ9zuG9fSH4RmdwdIEPc7s3fm02lcfZRYxdf5OjIY85MMebGV2cq5UbofpnNW3G1gA+fLMpv41srbWxZsO1BygUMspVaqZv8X/uZWv37QQmbrzNol6u/DS8lVBA8LO4EZPBsFXXGeTuwF9jxBulypQq3t8fyrHgJHbM8MLjhSDVnbcTKFWqKC1Xsf3GQ5Zd0DRX/HUhmuUXo9kxw6vS1qXT4SkYVmEZK1Oq2RuQyFfHwislcEISs5m62Z9PB7hJVkiXlCuZvT2AWkb6LB3lLqnMOhD4iI2+D9g8tT21JSq20/KKmbktgEW9XF+5qakqhCRm8/3Jeywf25ZaEmRMuVLFu/tCGNehvhApsfpyLPoKOTO6aM/x0YaNvg+wMTNgaBtpy1VWQSkbrj3g/b5NhVQ3W288pEMjG1rXsxTa9pFgsXpw0FimRno6Cd3XJ+4m0ae5mGXKPz6LMqWaZnVenUROySkmJbdYZzXdi4hLL6iSIBbFk/zKbVMVWNjTtdL7V08uo7OrLe0aWlf5tzKZDPULVeEa8kZ8tdrSRJ+s/wd14a725kSniSlvDPUUNK9bS7wy3MVGOBuiTX0r3OtZEiSQqWNrZoiPi+1rDy4GmObTiBN3k4WsRZ0a29CsjjkHJYJyQUOyLOrpws+nI4WyOD7t78aJ0GShaui+LerQvqE1f5yTti1ZmOjz8/DWfHfiHo+ypEm42uaG+MakC7VrDWtbj/6tHJi3M0hSidHYzoy/xrThk0N3ufsoR+tYI30F6ye14+7jHH45I01ovd3blV5utYXqsds3tGbtxHZ8eihMUkFh9U8L1aMsDYGj7TvKZDK+HNicEZ71GLPuBveSq86H2X0rgb8uRL9E3FRAXyHjcBVNaIZ6CpaOcme4pyaM+K/zUfz0dySlSs221MDlqPRKr2dDPQW/jGjNrK7OjF138yUC61xEKsv+aUpbcanyfKD61qYcmudNI1tTBvzly02JgGlt6NvCgcPzvYlKyWXwiutECyoCtaFHs9qcebsrCrmMvn9eFQpGF4VMJmO4Zz3OvdMNZNB76WWOhzx+raq2GtTg/yJqyJsa/M+itFzF0nP3GbHGjyb25hya561zJbY2nAxNpt+fV3GpbcaJhZ0lq6alkFVQyrSt/hwIesSBuZ0Y3V57O1VecRk7bz58+gJUVKZk0sZb5BaV8cWRMH49E8WmKe2Z1KmhzjaXfQGJLDkRwWcD3Pigr3ijVGFpObO2BRCelMOhed4vqZvup+bxMOM/L7yl/2T6TNviz7YbD9kzq2OVE9H9AY8oKqv6Za+0XMUe/0SWHI947sf/XnIuP52OZHFvV8ZL2HWUKjXv7g0hr7icNRM9JQmvm7GZfH8ygjUTPCWvrZJyJXO2B9LR2YbZAm1IuiCvuIyFu++wuLer0ER+9eVYCkvKeb+vdGhwTFoeFyPT+GlYK/RfkfRMyy1m1aUYPh/QXOhaWnMlFs8GVnRoVPWEvgL5JeVsuf6AaZ3FiKU9/ol4OFni5iBdD56WW8yV++kM95QmnNRqNQ/SC4QtU5ei0jRZMPJX/5m+k5BF0zq1JNVe2pBTWEZmQWm1lDdqtZqMgtIqlTegsfVYVWIRVANfSgR2y2W8VBVuqKfQyWpQEVosAkdLYyFVCmgUE/GZhcIqIA8nSyFCATQT48SsIqF9Uchl2Jkbci5CzIIwpE1d4byNUe2d8IvNEMq/cLYzo6urHVsFMmdkMhnze7iw7EK0UNjyOK8GFJUpOSRQSV7PyoTZ3Zz56li4UPj0krdacPJuslBuUPemtRnQ2oGPDoZKbtvcSJ9lY9qw9Nx9SZIFNPeCUqXiuxPhkmN7NKvNol6uzNoeIGkRszEzZMvU9oQ+ypYk4mQyGd8MbkmzOuZM3eJfaSbMs+jsasuqCW358ECoZJX5swTOwt3SBM77fZuysJcrY9bdrPS+OROewhdHwyhTVn0eistUbL0RXyUpIJPJeLdPE6b5NGTp+ZiXSCB9hZydz7RWvfi3M7o4s2aiJ18dDefHv++hVKmJSsljwa6gp9uKSMqt8vwb6Sv4dURr3u3ThKmb/Vl/Ne6VCYx6Vibsnd2JXm61GbzyOnv9E6pNhlibGrBqfFs+7e/GO/uC+fhgqFB+mCjszA1ZOa4tf4z24NsT95iy2V+IGK1BDf6tqCFvavA/iXvJuQxZeZ2z4SkcnOvNol6urzzxfBGFpeV8eCCErTfi+Wl4a34c1lrIBqINoY+yGbjcFwOFnGMLOtOirjQRtOeFF7BylZrEJ0X0W3aV2w8yOTrfh06NpVUVz0KlUvPL6Ui+OxHBlwObC2WCVOBJQSnj1t+iqEzJvjmdsK9EhbI/4BEvzlXLlGouRaUzxbsBzepUPqFOyysWqtgtLVexxS+e46GaMM6YtHwmbLhFZxdbZnTRTpio1Wq+PhbOveRcNk9pL1kXfD81j5nbA/hqUAt8XLQ3VqnVaj49FIZSDT8KWJp0gVqt5tPDYTSwMWGWxHcEjRJt5eUYlo7ykFSIqFRqPj54l/YNraul7vjtbBTdmtoJkTGpucXciMvk/TekiSWAnTcf4mpvjpfAtsuVmvyDKRJNYBU4dOcxHZ1tqGcl3eQU8iiHG3GZdHbVfi1U4NJryLsJSsiiTX3Lam0jNiMfWzNDSbWWNuSXlFNartKqvFHIZczv0Rgj/f88AAz05IxqV09S9VNV21S5Si3ciGJlYiDUsATgaGXMI0HbVF0LI4z05MRniE02dCFvzI30ca9nIay+6dPcnnMRqUKTtT5u9pgZ6hGpRdFQAftaRvRoWlsouBhgRpdG7Lz5UIiQ6eJqSwMbU7bfrHxy/CwM9OS8/0ZTlp67T5EEoQAwp1tjMvJKOChA9jhYGvNOnyZ8djiMolJpIu6zAW7EZxRWOal/Fm3rWzG/R2MW7bkjeUyM9BWsHu9JbEaBULPV7K7OeDWyZu6OIEkC0dnOjLd7N+HbExGSdeoKuYw/Rntgoq9g7g7tNieAHk1r8/3QlszfFYRfrPbr1dJEnMABmNypIW/3dmXihlvPVZ/fS85l3s6gKhU3zyIpu5hQLeRZQmZhlXa/knIV22481HoMujWx4/B8H86FpzJ7WwDjN9x87nupUbP6ctXtXDKZjHFe9dkzqyObrz9g/q6gVyZI9BVyPnyzGWsnevLrmfss2hMsZE3UBplMxrC29Tj9dlceZhbSb9lVAgTzuETRs5k9597thoOFEW/+eY1tN+KFiNca1ODfhhrypgb/UyhXqlhxMZqhq67Ty622MBEiirDHOQz8y5f4zEL+HO1RZYiwKNRqNVv94hm3/hazujZi7URPoUabMqWK1VfiKH7hpadUqSI5p5g3W4rVJT+L4jIlC/fc4XhoEofm+eAtQUg8i0dZhYxY40ddSyO2TO1Q6URQpVJzIDCxyhWyP89Hczyk8pXgM2FVW6YAjPUVyGXQpr4l3w1pSa9mtXmYWcD4DTcZ26E+83u4SH6HZReiORuRwrbpHbROQkGjyJi62Z+pPo0YImAD2uj7AN+YdNZN9KxW+1hl2B/wiBuxmSwd5SGpaikuK+fjg6HM7eZCq3rS98Vu/wSSc4p5VyDQuCqEPc7hWEgSH7/pJjR+xcUYHC2NhfavuEzJ+msPmN+jsRAhdi4iFZlMRm83adJErVYTkpjNGIHgZ4CToUm80byOkD0xPqOAxKxCSdJPCkEJ2bR9wZaoKzSWqerm3ZTS0dmaWkbaCc8Rnk4onjlPMuA9AZLO1szwJULCUE9GfWsTigUm2gBN7M2EJnmgm21KJpPhYm8uGfBaAXcnSyKScoWVOt6NbfGLFbNSdHa1JTmnWLIaGsDMSJ86FkbC1de6BBd7NbKmvo2JEGkik8lY3NuV9VfjJBUeAINa16VdAyu235AmTYz0FXw+wI2fT0dJVmuDJnDZxsyAvy5KBwGbG+nz64jWHA1JIj5D+njP7e6Cnbkh3xyPkBzrZG3CVO9GfHIwlBgJS15FW1WZUsWXRyq3DT+LDo2s+XFYKxbsDNJqRQKNum3dJE/S80r4YL90Xs7A1nX5ZnBLZm0LJPCh9on9swTOR4dCJQmcqT6N+HygG1O3+D8lnsyN9OjXsg5mhnroyWVamzjVaqok2rILSxm7/iaFZVVff8VlSs6Ga7cMNbYzY9/sTgQlZpORX/qc0VOpgjPhqZINWu5OlpxY1IXconIGr/AVtmRWhi6udvy9WFPPPXC5L2ECyi8pOFoas3OGF9M7N2L61gB++jtS+FkmAgtjfX4a3pq1Ez3ZcO2BcOZRDWrwb0INeVOD/xlEp+YxbLUfR4KT2DurE++90fSVarUrg0qlZv3VOEas8WNoG0d2z+xIXUvpqmNtyC8pZ9GeYFZeimHz1PZM9m4krMg4dTe5yhU8lRpWXoqRlC8/i4pGqeTsIo7M89GpveZeci5v77mDT2Nblo9tWyU5cTMuk4KSqn/ky1Vq3tkbwoVKgv32BSS+ZJky1pcjl0G7hlZ8Oag5/p/15vA8HyZ0bEB2URnj1t9iYOu6vPeGNPGwLyCBXbcesn26l6TKoqCknGlb/fFqZM07vbW3UIHGHrP03H3WTWxXqRqpOohJy2PJ8XD+GO0uFJL9x7lo7MwNhYJ9U3OL+envSL4b2vKVbTlqtZptN+KZ6t2Q+jbSZGLik0L2BSQKk0X7Ax9ha2YgHPq72S9euB488GEW12MyhCrUdW2ZuhyVhlcjG0l1lzaUlqu4+zin2sqbzLwS2jWoHgGUmV/Kg4wCyeeXsYGCqT6NkKFR08zv3lgoBD27sOzlwGJ9BQlPCilTiVmnNMpEMXVMPUtj4XBjgGZ1zEnILBAa29DGBGMDBZHJYpMybxcb/GIzhNQ0JgZ6dHG1FW6dGuLhyNHgJKHV7a6udrSoa1Hp8/lFyGQyZnZxZqPvAyFlVPcmdjhaGUu2FoEmgHdUeydWXo4lRyDD6M2WdWhibybUzFQRlLv5+gNJYgM09drNHWrx4QHpQGKFXMafoz04HZ7CyVDpmvbeze2Z5N2QOTuChNQ6ayd6ciEyTagifbCHI7O6OjNti79kSK65kT5bp3Ugv7icH/++J3kdjvCsx0dvNmXKZn/CHmsnCyoInKz8UskMHIDR7evz47BWzNkeyJnwFOpZmbBiXFtCv3qDw/N8WNjThRZ1ayGTaRZ0nn0aKdVqjtxJeklVVVKuZMpmf9LzitHGS5aUq1h3LVbr/gH8ciaqyvOlUMjYJJB9ZG1qwNZpHRjVzomhK/04ESpGsFYGO3NDtk7twKSODRi/8RYbrr26JasCcrmMKd6N2D+nE9ei0xm84jqRKdL3iy7wcbHl9Ntd8HCyZNByX1ZeihEijmtQg38DasibGvzroVSpWXsllq+Ph9PJ2YYTCztXO8DzWaTlFTN582223ohn54yOLOzlWu168fupeQxe4UtmfgknF3WhvZawzhdREe6rLayzXKVm7s5A4gRWYGPS8hiy6vrTRikp1cmzuBmXyai1N+jlVodvBrfQelz2BCRSLjHRKlepmbMj8DmbQHJ2IXcfa14MDPQ0hI1XI2uWvNWSwM/7cGCON2M71H+632m5xYxff5PuTe34fICb5ITyRGgSS45FsGZCO8ncmnKlikW772BuqFkdEml02nz9AT8Mbflar0nQrAQu2HWHiZ0a0sVVut3o9oMnbLvxkM8GNBeyEH59LJweTWtXqw3pXEQqF+6lMae7WAvUn+ejGdDaQaiFq0ypYu2VWOb1cBEiPSOSclCp1EIV6qAhDIe0cRRSSt1JzCa/pFxYSXMxKp3uTaXPmTaEJ+VgYqDA2bZ6qpmgxKxKs2h0QWZ+CTamYs+NKT4NUaNpmJrZVey6kFWSeWPwzzUsGlpsZWLAE8HAYkcrY5JzioVtC43tTAlLEpu8yGQy2jhZEJ4ktgretr4V2YVlxKaLkUO93eyFQ0W7NrGjoLScoEpa/F6EQi6jbX1Ldt8Ws071b+VASZmq0padFyGTyVjU05U1V+KEWnK6uNrRytGCVVeqtqE8u+2vBrXANzpDqNK9WZ1aTPNpxMeH7goRTx+92YyU3GI2XZeelNe1NOanYa345FCoUI7Re32aYGdmyCeH7kpOuB0sjFk30ZONvvFcF7DZLejpgo+LLdO2+EuSQ3bmhnwxqDmH7ySx5srLzUsvYmKnhizs6cLEjbckFWmWJgb8OcaDpJwi5gsQOIM9HFk2xoO39wQ/zWySy2W0qmfBwp6unFzUheAv3+D3Ue4MbeOIpYn+0/eSUqWKP88/H0q94mIMwYnZTwOKtSHsUa7WEOCtfvEcvvOoymdSabmKHTcThOyECrmM2d0a88doDz45dJfvTkS8Mnkhl8uY3sWZTVPas/l6PNO3BryW5qgm9uYcnudDbzd7hq70Y93VWGEbqwhMDDSNV7tmenHkziMW774jSQjWoAb/BtSQNzX4VyMuPZ+Ra/zY469Zrf+kv9trtaVcjEyl35/XsDY14NTiLnhWc4Ua4PCdRwxdeZ3+rRzYPt1L51rxG7GZJAisIJeWq5i48bZWubhfTAbjN9xisLujTo1SAH/fTWbaFn8+H+DG3O7abStFpUpOh6W8NAF7EUb6mhyLw3c0L2VqtZpZ24MAaFm3Fj8MbcWdL95g7+xOjGrv9FLVc2Z+CeM33MKzgTXfDm4pOam/Fp3OB/tDWTG+LW0lzq1arWbJ8QgePilkzQRPSVVXTmEZM7YG0KKuBUPaaG+4ehWsvhKLiYFCSFmUX1LOe/uD+aBvUyFV1dnwFPxiM/lCIkhWG0rLVfxw6h7v9GmChbE0ORCTlseJ0CTe6S2mujkekoSeXMYAQeviFr94XO3NsRQgKgpKyjkRmsyodmJEz4mQZPq2qCOk9CssLedmXGa1826CE7Lp1sSu2vlJr8M29aSgFBszMQLI1swQO3NDfFxstDbpPYvKMm/0FHIUcplwaLGVib5wYLGFsT6mBgrxuvDa4rYpAA8nK/zjpQkT0Kgq2jW0kswRqUAvN3tCHuUI1e4a6Mnp38qBI/8Pgov1FXLm93DhcJDYtnu51ca+lqGQ+gY0pMlWv3ghe1vTOuZ4Oduw5ESEkOpgUS9XsgtL2S6gYjE11OO3ke78fva+kF2tXysHxnaoz5Jj4ZITXT2FnGVjPbgZl8kOgUygtg2sWNDThfm7gkiQqKOXyWT8MLQVFsb6LNp9R3JfGtiYsmVqe1ZdihGqSZ/VtTGTvRsyfsMtyUUkSxMDdkz3IlmQwHmjRR3WTPTk44OhlV5fFsb69G/lwNLRHtz5og8nF3Xmo75NMTFQsMn3wXMEwNgO9fm4XzM6NLTGQCHX/KviOa5GzWa/+Er/n19MBt+eiNAanFyxjf2CNfOgybE6vqAzvjEZjF9/SzKYWhs8G1hxanEXDPXk9P/rGjcE7ZjaYKAn5/2+Tdkxw4udtxIYu/6msMJRFG3qW3FiYRea1qnFiDV+/PR3ZLWr0GtQg/9m1JA3NfhXQqVSs8n3AQOX++LuZMmpRV3wbCCuXpFCcZmSr4+Fs/pyLJ/2d+PP0R7VCvQEKC5V8unhuyw5HsGK8W15742mr6Tg+etijOQLgpGeHH2FnOScIkITK1+p2OefyPStAXza3433+zbVqeJ8+82HvLc/hGVj2giFGp+NSKGqrVfk1Xg4WfD+G0259F53fh3pjkql5oujYWTmF3Pm7S6cWNSFEZ71sDCp/DzkFJax5Hg4TeuY88uI1pLfJyQxm7k7gvhhWEshdclG3wf8HZbC5intq9yHCpQrVSzYHURjO1M+EAze1QVnwlPY5PuAZWPaCKlovj95j3qWJkwRqMfOKy7jy6PhfDbATWdi8VlsuxGPgZ5cODNm6bn7jGxXTyirSaVSczYihdldGwvdQ08KSjkanCT0/QFO3k2mgY0pLepKN1KpVGpO3U1moHtdoW37xWTgYGFUbcVMYELWS21uukKpUvMws7DaNeGZEk1TL6JF3Vr0bSGeFyaXyV4ib6CiLlzsJd7K1EDYCiWTyXC0MuZxttgkxNXeTKfGKXcnS+G6cNCoae4IVICDRiXhXk/M3gQw2L0uJ0OThVb1dQ0ufsujLlej04UCmmUyGYt6ubLmSqzQxKxVPQveaF7nJSVFVXindxPCk3I5J6BKMtJX8MPQVvx29j5JAtdAh0bWjPOqz3v7QigXOI6Le7sSm57PiovSyqHa5kasGNeWH05FCh3HUe2cGNrGkRnb/CWVYwZ6clZP8CThSSG/n42UJLZaOlqwdpKmVUlE3bW4lysTOtZnzo5AyfYgSxMDdk7vKEzgdGtix7ZpXnx5NEyrFUkmk9GsTi3m9nAh4ps3eb9vU8auu/lU3VvX0pg53Rqzb04nwr/py+5ZXizo4YKHkyV6chmGenL0FZrfGJUa9vonvqScUf2jGK7sGfUiistUrL6im0Kloa0ph+f54GhlzMC/fPGvRlCwhbE+q8a3ZWFPV6Zt8WfpuftC16wUPBtYcWpRF1xqm9Fv2TWOBSe91spvQ30Fi3u7cmxBZ27GZdJv2bXnwqtrUIN/E2rImxr86/A4q4ix62+y2e8Bm6a056tBLYRXcEUQnZrHkJXXuZOQxa8j3BnuWa/aq9uJTwoZte4GOYVlnFjY+ZWtKFEpedx68PwPllwGJgYaf7eFsT7dm9rx7htN2DHDi4hv3nyp/eZpo9TJCDZOacdgD+nA3Qqo1Wp+PxvFb2ei2DatA32aS+eBAGy4FvdUSqz454XISE9On+b2/DRco6Y5Mr8zM7o409DWFJVKzedHw7hyP539c31oWkULVQXyisuYtPk2haUqlo5yl5zQx6TlM2Xzbd7p04ShAqqYv+8mc/5eKpumtBMiF378O5LU3GL+GC0dIqwrkrKL+PBAKD8OayW0L5ci0zgRksSvI6UJLYC1V2Jp19CKkZ6vrhbKKijlrwvRfD6guVC+TNjjHC5GprGwp3SGEMDZiFSCE3IYJlDhDbD7dgLtGlrRtI60HQtgf0Aio9uJ3fdBCVkUlyvxFmx2uxyVzsBWDtV+ptx5DWHFj7IKUaPGyap6+V2Z+aU62S2LSpUYG4i/nshlspcyb0Az+SwuE7dNZRWIN644WhoLK28cLY0x0pPzIEPM2uTuZElcRoFQZgtoVp4vRqYJT/gGtHIgXNDG1b6hNcb6CnyjxZQ947zqs1cwuNjCWJ9R7ZzYKJDzAZoGLM8GVk+Vl1J4/42mHA1OElI9WZjo82Hfpnx7MkKIHPJxsWVCxwYsOS6m1vmgb1Nyi8tYf036u5oY6LFsTBtWX4kRauzp0Miad/q4Mm9HIE8KpBVVn/V3o7a5Ee/sDZbM4rEw1mfzlPYcC0lm0/V4yW17N7Zl6Sh3Fu25I7nvFXY4r0Y2TNhwizSJfB0LE312Tu9ISk4x83ZKEzjtG1mzfYYXyy5Es/KSNBEGMLtbY756qwXTtwZw6u7z2UP6CjmeDaxZ1MuVI/N9CFvSly1TOzCna2NNlg4awnvmtoDn/k4ul7FmgiezujrTom4t9OQy9BWy55r1nkVmfqkwuVoBYwMFS0e5s6CnC5M23mbjtThUgnlfL0ImkzGhYwMOzfPmZGgS4zbckgxSFoGpoR4/DG3F8rFt+On0PWZvD3wt9qxn0cTenINzvRnvVZ+pW/z55fS917r9GtTgvwE15E0N/nWYuPEmrvZmnF7clY7OulVha4NarWbHzYcMXnmdHs1qc2CuNw2ruToOcD4ilQF/XcPDyZKlo92Faoer2r/Jm26hVmsIG7lM06AyqVNDfh7eGt+PexL8ZR+2TO3ArK6Nad/Q+iUbVHGZkoW773AiNFnTKNVYvO2mXKnik0N3ORD4iANzOtFOMKcn4MGTp5k1NqYGjOtQn01T2hP6dV/WT9KQR88qWVQqNZ8duYtvdAZ7Z3XCUSIYuqhUyfQtAdQy0mPl+DYYSLT9JOcUMWnjLcZ51Wd6Z+nK6MCHWby3P4TpnZ1pXc9Scvw+/0QOBj1iw6T2mAuotZaejRLKnADNOXh7TzD9WtZhYGtppUdWQSkfHgzli0HNha67wIdZbPSN5703mlaLXFh2IZq2Dazo2kQs12WT7wMmdWooFOisVqtZdTmGmV2dhZqdypQqtt94KFwPHpueT8ijHGFS83pMBoM96gopoNRqNRcj02gvUGuuDWm5xSTlFOHuVL0mvbj0AupbmwgRbNqQWVCCtQ7Km+IyJcY6WDQrs01BhfJGbAJjbaqvUwixo5Uxj3RsnIpOFWtFsTY1oL61CcGPsoXGt6xbC5VKTYQgIdOtqR37AhKF2pvkchmDPOoKW6e6uNphoJBz4Z5YIP40n0acCUsRyniRy2W85V73n0w3aYKlvo0JYzvU55fTkUL7MrKdE5bGBqy/Kp3bAjCrqzO3HzzhTHiK5FgjfQW/jXRn2YX7RKVIk0ktHTVK08V7gskpkibxZnZxpndze97dJ936pKeQs2JcG+6n5gkpk+pZm7ByXFuWno0S+q79Wjnw2QA3pm8NkPyuMpmMJW+1wLOBNeM33KpyMp9VUMrfd5OxMNFnx3QvUnOLeXvvHUkCx8PJ8mm99i+npdVDoAlVXjGuDe/vD9FqYTLSV9CpsQ3v9W3KyUVdCFvSlwU9GhOelMOS48/b3rxdbPm4nxsnF3Uh4ps32Te7E++/0ZQeTe2oZaSnWWT755lXrlLz+ZEwyf18ETKZjEmdGrJjhhfXYzNYvDdEKD+nKrg51OL4ws60crTgreXXhbOypNCjWW1OLOyCQi6j759XX9t2K6CQy5jRxZnTi7uS8KT6pFMNavDfhhrypgb/Ovw03J3vhrR65QacypBVUMrs7YEsvxjNhknt+OjNZkKTMW0oV6r46e9I3t4bzHdDW/HN4JZCk83KUFhazsLdd8gtKmOIR132z/Em4ps3OftON75+qwWD3OviaGmsdcKdkV/C2PU3Sckt5vA8b50apYrLlHx4IJS4jHwOzvUWCpQFzUR4/q5AXOxMObWwMwGf9+bbIS3xcbGt1FdeYZVKySlm72zpRq/iMiWztgcgk8G6ie0kj++TghImbbxF1yZ2vC9gZ3qYWcDMbQF89GYzIZVRQPwTvjoWzqrxbYXalY7ceczWGw+xE1QtLL8Yw5PCUr4a1EJo/DcnInCvZymkoiktV/Hpobss6OlCo2qQljFp+ey+ncBn/cWqwf3jn3A2IpXZXZ2FxvvGZPAoq4ixHcTsWGfCU9DXk9FTMGNmf8Aj+jS3fylPqTIoVWp23kqgt0AjFcD91HyeFJZWm3QOSsiiqb25EDmoDbHp+dW2TIFmJdlWMPMGoKhMqVO+lgwqVd4Y6imEM28sTQwoLFUKZyU4WpoIK28AXGubaQ0zfREeOlin9BRyvJxthHNvGtuZ4WBhJKymGeLuSFJ2kRDZo5DLGNvBiV23xbJp6tuY0MutNlsEAn0B+raog7mRHvsDpGvGQRO8ez81T0jBopDL+PqtFqy+EitEJlmbGvDFwOZ8eTRcqGq8bX0rpng3YvnFaCFl0jSfRrjUNuPTw9KBxDKZjPf7NuVBRgErBFQmliYGrJ/Ujs3X44XardydLFk62oN39wZXeV2qVOqn+TXjvRowzacRXx4Nk7REyeUyfh7eiib25kzadPslsiotr5ghq64zb2cQGfklTwkclRrm7QyUvMfdHGqxZ1YnDgU9ZsnxCKH2tF5u9myb1oFfTkfx5/n7QqSPqaEe7/dtxvEFXbhyP505OwIrvWcM9OS0qW/FjC7ObJ7agZCv3uDKBz34flhLRrd3wtxIj7S8EmGy6UV4NrDilxHuZOSVMGTldaGspapgYqDHFwOb8/lAN97eG8w3xyNeS/W3takBq8a35dP+bryzL5iPDoQKB8CLor6NCcvHtnmt26xBDf4bUEPe1OBfhw7VXLV+EX4xGby57CoApxd3xVuwMUYb0vKKGb/hFhfupXJkvjdvCeZhVIZHWYWMWH2DtLwSrn7Ukz/HtMGzgZVOk58KK1g9KxN2zvDSyeKQXVjK+A23SHhSyLqJ7YQr0iOSchm15gYj2jlx7t1uNHe00EouqVRqPj4UyvWYDH4c1hoHC+2fU1quYv7OIPJLytk4pb2kda6wtJzpWwPo1NiW74ZIhxlnFZQydbM/Q9s4MlkgK+VxdiFzdgTyaf9mQoqmqJQ8Pjt8lz9HewjZn27GZbL+WhwrxrURsgkeC0kiMjmXH4ZKf1eAdVc1NaizBEmUqvDjqXuMauckRPCp1Wp+PR3F9M6NhK/JlZdimObTEBMDMfJ2y/V4JndqKJSNU65UcT81j1HtxCxjAfFPKFep6SRIxlyKSsOnsW21Q9WDErKrXREOEJdR/bBiqMi8EX+m2NcywkQHq2tV2T6utc2E8xosjTVEl2hosSbzRpy8aWJvxn1B5Q1oyBuRDJMK+LjYcF0wYFQmk9Gnub1QvgtAMwdzcorKhMePbOfEDcHgYoAZXRqx53YieQIEiFwuY2FPV1ZfjhUi5mzNDBneth7fn5KusQbNxPfNlnX44ZSY3WJoG0ea2JsLq3ve6e1KdGoeqy5J10rL5TJ+G+nOrbgn7A+UJqtqGemzerwna67Eci06XXJ8E3tzlo724Oe/7xEh0G7Wt0Ud3unThOlbA146t8VlSubsCKTX0itkFWjuoUW9XGjmoCFknhRov6/0FHL+GO1BnVpGTNl8+6liJCm7iMErrvM4qwgjfTkX/1F0WZjo8/Ow1qTllQgROC61zdg/pxMXIlP5RLAprF1Da3bM8GL37QS+PCodIF2B+jYmHJrrTU5RGWPX3ZQMB5fJZDhZmzC0TT1+Ht6au1/35dgCb47cecziPcGvFL5ra2bI9ukd6OlWmyErrnM6TFoxpQ2DPRw5sbAzt+MzGbH6BvGCFlBtkMlkDGtbj9NvdyXhSSH9ll2tVl5PVZ9Rgxr821BD3tSgBlWgTKnil9ORLD1/n4U9XVk70VNotV0KN+MyGfCXLw4WRhxd4INLbTGVSlXbemvFdTwbWLFzhhe2OpAuFbgek8FXx8IZ4lGXZaM9dJo4JmUXMXLNDaxMDNgxw0uoqQc0yoAx624wvUsjPujbTPIHVqlS8+HBUPzjs9gzqxN1LLTbZ8qVKt7ZG0xKbjFbpnbATEKFVVquYu6OIAz15Hza303SJlKh6HG1N+NTAQVJYWk5s7YFMrZDfSZ2aig5Pre4jDk7ApnexVmodSiroJS39wTzSb9mNJPI/wFIzS3miyNhLO7tSu1nrEhhj3MqfUGNS89nxaUYfhreqlqKM9/oDNLySni7t1h2zdXoDO6n5TGji5ilKfDhE8Ie5wodY4C7j3KISM5lpGBr1JX76dxLzqWzi5jd60RoMm+2rCNsO7oYmVbtlimAOwlZtKlm3g3Ag/R8GttWX3lTXKbUyTZ1LzlPp+fQw8zCSq/blNxiCgUnPnoKOVYm+mQJ5sw4WRljrUOFuqu9OffTdFDe1NeQN6Ir796NbfF/8ERYadSneR3hnByZTMZgD0eOCGbN2NcyYmyH+kKtQwCeDaxxsTcTDjru38oBI305B4PE1DczujiT+KSIM+Fi5NPHbzbjSlQ6NwSUTDKZjO+HtuRg4GMCH0pPPA31Ffw+yoPVV2KEao3tzA35fZQ7S46FS7YyATSvW4uv32rB4j3BlTZtFZcpWXUp5ilJ2ae5PWO9GjBzm1j+yPTOjejXsg7Ttvg/Vcg8KShlxBo/rtxPx0Ahf5q7J5PJ+HJgC5rVMWeqQOW4gZ6clePbYmKgYMbWAO6n5vHWCl/S80ooV6kpKlNxPDTp6XgLE322T/N6SuBIKUKcrE3YP9ubgIdP+OnUPSH1U9M6mgyV67EZLNwdJKw6sTQxYPv0DjSrU4vZ2wOI0eHeB2hdz4qjCzrzOLuIUWtvkJKje4uUnkLOJ/3c+HVkaz7YH8KPf9+rVvhwQ1tTDs71pn1DawYu931axV5dOFoas3OGF1O8GzFp421WX455LeqeGtTg34oa8qYGNagEDzMLGLHaj4uRafwwpCUTOjaoNoOvUqlZfTmWX05HsriXK3+M9hBWB7wItVrN9hvxLL8YzftvNOXbIS1faVK91z+BGVsDGNa2Hu/3baZTeG50ah7DV/vRrqEVaya0FZ5s+cVk8Nnhu7zftynzurtIjleq1Hx4IJSgh1nsmdVRkrhRqdT8eiaK6LQ8tk/3wsJYu3VEpVLzwYEQMvJLWD+pneT30IwPpUyp5s/RbSQVG2q1mg/2h2JmqCcUuKsZH4KTtQmLe4mN/+P8fdrUt2RCxwZC4z86GErPZrV5s+V/Gn0y80sYuNyXgcuvPZdToFar+fTwXca0r18tQkCpUvPdyQgGuTsIqWgqwq/ndGssbP9ZdSmWiZ0aSJ7zChwNfsy0zg2Fx+/1T2SEZz0hlY5SpebvsGQGClaV5xSVEfgwq9rkTWm5itBHOdUOKwZ4kFmIc+3qKW/UajWJTwp1Ipb/v8i8AahlrP9UNSCFupbGXIhME55kNLU3w9JYX3h8c4da5BWXkSiY2dDE3gxTQ4WwWqdtfUtUajV3BPO03nKvi29MhnDAaM9mtdnjLxZcDDCjszObfB9QJnC+FHJN89TKSzFC2zc11GNxb1d+ORMpNHmtXcuIj/s1Y8nxCKHxDWxMWdTLlU8O3RUiz1o6WjC7a2Pe2xcidD10a2LHzK7OfHk0XGj8qHZO9HGzf6mV6WFmAf2XXeOXM1Fcuf8fZc6cbs541LdkrkAIsEwm46tBzalnZcy8nYHcT8mj/zLNb0ZJuYoypQrfmP+QXgq5jD9Ge2BqoBDavpG+gvWT2gFqBvx1jScFpZQ/QzDejMukqPQ/x8DCRJ/t0zUEzvyd0uRKHQsj9s7qhF9cJvMExgPUszLhwBxvHmcVMXWzv5BCDDS2zZ+Gt8LHxZZhq/yEbY0VsDM3ZNdML5rVMWfwCl+dlHjP4s2WDhxZ4MOlyDQmbrxNRjVCgg31FHw5qDl/jvbgq2PhfHgghMLXYHeSy2VM79yII/N9OBOewuAV14lMEcvwqkEN/tdQQ97UoAbPQK1WcyjoEQP+8qVtAyuOzPehiYCSQQo5hWXM2h7AzlsP+WpQ82qRQSXlSj45dJdlF6J5p3cTxnlJV3G/CJVKzc+nI/nhVCSbprRnhI7NQQHxTxix5gYj2znxw9BWOigLUpmxLYCZnZ2ZJKCOUKo0RMadRA1xIxVYq1ar+exIGGcjUtk+3UtytV+tVvPNiQiCE7PZMrWDEEmw/locwQlZbJjcTsietPxiDCGPslk9wbPSHJ8Xse5qHGGPc1k22kOIJNh24yHnI1KF7U97/BOJTM7j67eez8VJzilGXyEjKiWPAX9d4+e/IykuU7I/4BEPMwt5v2/1Ks0PBCZSUFouZDEDOBOeSnJOMZMFVTQRSblcj81gmo+YSic9r4RtNx8yRDB4OD2vhEtRaYz0FFPpVKw+ewlapnyjM3CxM5MM4JZCZEouXs7W1a4azysuIyWnGOdqKm9yi8opV6mxEcy8UavVOmfeaKrCX/7vumTewD+NU4LKGzszQwwUcpKzxVbEHSyMuZ+aT1y6mN3ASF9Bv5YOhD7OFhovk8no1NiW6zFiE0Q9hZyezcStU07WJrjXs3ypgacqdH0aXCy2/b4t7GlgY8qZCDF7x8DWdTFQyDkcJLb6P6a9E6hhn2BWzqh2TpQqVey4+VBo/IwujZDLZE/tpVJY0NMFPYWMZeejK/3/iU8Kn1POzO3emKzCUn47EyW0/SWDW1BSpnpq/zobnkLfP6/yMLMAuQxCH/1H9SOTyfh1RGvyi8tZcjxcctuawOO2FJUq6f/XNdLyiilTam5AlRquRD1v2TLUU7B2oidPCkr44IB0oPKDjAJCH+VQplS/dF8r5LLnyCHQNGLpQuDYmhuyc4Zm/IytAc+RQVXB2tSAXTM7ajKd1ktboSogk8l4742mfD6gOdO3BHBIUC1WAUM9BT8Pb83bfVwZt/4mh+/o9vcVaGxnxuF5PtiaG/LhgRACH4qRtlWhd3N7/l7chaJSJUNX+702oqVpHXP2zfamT3N7hq70Y62Otek1qMH/AmrImxrU4B/kFpfx9t5gvj95j+Vj2/DVoBbVzp4AjTVjwPJrqNVwYmFn3J1efUU8La+YcetvEZ6Uy7EFnYUbnZ5FRaPUydBkDs3zppNghXEFzkekMGnTbd7v25R3+zQRJqGOhyQxf+cdfhvpzjABskipUvP+/hBCHmWzZ2bH5+w9laGCiLkWnc7OGV5CzUSrLsdy8m4y26d5YWcurQzYfTuBVZdj2TK1g5CS4HRYMuuuxrFhcjsh28iN2Az+PB/NqvFthSx64Uk5/PR3JH+OaYOVQKZIQmYh352I4JcRrV9Sm6TlFaOvkKNSa9ouNl1/QLdfL7H2aizfDm4paT3ThvyScn47e59P+rkJhXIrVRrVzcKeLkIEGcAe/wRmdnEWOo8Au24l4NXIWti2eOTOY9o1sBYKmgaNZapfSwchAg40lqnuzcTsWNoQ9DALGbJqV9DHpRdgaaKvk92pMmQUlGCoJxfOsClTqlGq1MLnHUAur0J5oy/XSX6vsU2JKW/kchkOlkbCuTcymQyX2mZCtdUVsDTRJ+hhtvD4nk3tJMNhn0Wf5vac06GSeLBHXY4GJ0kPRHN8NMHFYlYoPYWc3s3tWX/tgZBVTCGXMb+HCysuxVAmcI71FXI+6NuUP87fFwpeNtCT89WgFiw9d19IbaSvkPPjsFbciMsUsjfpK+T8PsqdTdcfPKd+UqnUrL8aR4/fLj+Xu2Oop+CvsW3YdSvhOdVMVTDSV7BmgicHAxOZsdWfeTuDKC5ToVRrCJYXA5xNDPRYP7kdp8NShAircxEphD7KoVz1MsHyKKvopWNmbqTP5ikdCE7M5ruTVecPBSVkMWL1DQqrIFRKy1WVEojPEjgLdgVRXKb9HFuaGLBzhhcl5Somb7otpKYxNdRj4+T2ONua8e6+YBIyxe+1Ue2dWDfJk6+OhrPsfLROQcQymYyxHRqweoLm73/8+94rERqmhnr8NcaDrq52TNhwi2034l8pELkCDhbG/DHagzdb1GHYKj923HxYre1VwEBPzntvNH2aNzR23U3h/Kwa1OB/ATXkTQ1qgOaFoUKi+/fbXV5L7oRarWbnrYeMWnuDcV71WT+pnXAmTGUISczmreXXqW9twv45nYSDgZ/Fi41SVQV9VoU9txP480I0v49szUQBi04F9von8NHBUFZNaEt/ARtJuVLTbJSRX8LuWRriJiO/hM4/XaxyZfm3s1H8fTeFXTOkW6hAQ8SsvRLLtmkdhCbkl6PS+OZ4BOsmetJYoIkrIimX9/aF8Psod6EcmpScYj4/EsZ3Q1rg7mQpOb6iYWxOt8ZCId0VZNjQto6VVnSn5JQ819hTUq4iNbeEuPQC/g5LFqqrrQprr8TS0MaEfi3rCI0/FvKYwlIlY9qLqcri0vPZ45/ImA5i40vLVey49VBYpaNWq9kbkMio9mIKtXKlitNhKQxsLWaZUqnUPM4upPdreO4EJWS/FstUXEa+zs+HyvCkoBRbM0Nhkrfon4waXZU3lU0aDPXklJTpoLwxNRC2TYEmq0EXskTTOKVraLH4Cnm7htYcDU4SIicAujaxpahUSaxgHseA1nUJeZT90kTqQUYB22/Ev6RyGqVjcPHo9k7EpecTIKgKGOxRl0a2phwNEVMDvdmyDo6WxmzyFWu26tbEDi9nG347K6Z2aVPfCtfa5nx2OExoEtusTi0W9XLlvf0hFJcpScgsZOiq6/x2NopylfollVZjOzO+GtSC9/aFCFlfjAzk2Jkbcf5e2nPWI4Co1LyX9tHR0pjVEzz5/uQ9bsZVHn6tVqtZdv4+HxwIfWmbTz9XX8HNuJfzf+zMDdk+zYtjIUlsuPZyHfuN2EzGrrtJUZmSqo6eSg3nIlIrJS8qCBwjfQXzd96RJG7NDPXYOrUDRgYKJmy4JRRWbqAn58/RHrg51GL4Gj8iksQVJ11c7dg/txN7/RP44ECoTqpA0FyPR+b7cC48lZnbAoTtW89CJpMxxacR26d3YMXFGN7dFyL8vKgMego57/RpwsbJ7Vl+MZp5O4Oq9a7wLDwbWHFyURdc7c3ot+wa+wISXws5VIMa/F9HDXlTg/9pKFVqVlyM5sdTkUzu1JCtUztQ21xasSGFwtJy3t0Xwh/notk0pT3zurtUayX8UNAjxq6/yfTOjVg6yv2VFEGaRinfShulSstVWgPx1Go1yy9E8/2pe3w+oDn9Wom3Y23yfcB3J+6xeUp7ejSVnpyWK1W8uy+EoIQslo7yeHo+zkekkpJbzJTNt7kY+fxq8YqL0ez1T2TnTC8hIuZ0WDInQ5PZMLk9bg7SxEpEUi4Ldt3hp+GthGwwGfklzNwWwJxujenbQpqwKFOqmL8riDb1rRjWVowg+OpoOHZmhizoKZ0bBJrzkJpXXGXAcmpucaX5EWrgeEgyXX65yKm7yTq/PCVlF7Hh2gM+H9BcaAJfplRx6m4K773RRMhmBrDmSiyD3esKW45O3k3CzFCPbpWQWJXhTmI2qbnF9GspRsb4xz/BwlhfWBkXlpRDeFIuHq+BdLmTmPV6mqbSC6ptvQJNlpIu6p2KZhUjwXMPmglJlVXhOgR06mKbAs1kV5e68Cb25jopbzycLAlLyhWe5DlZm1DHwojbD8QaW0wM9HBzqMX5fxp8pGBtakBnF1uOhSSRllvMxmtx9Fl6hZ6/X+aLo+Gk5j7/G1K7ltE/2TditeFmhnqM61C/0ol9ZdBTyBnQ2oGVl2KEsmlkMhkf92vGmitxwtk9XwxozuE7jwl9lC00/v2+TYnPLOCAQDsUwKwuzpgZKJi3I5DeS68QlpT7NKepMlXXyHb18HK25r192u1Ht+Iy6bP0apXEWWm5qtI8pQ6NrPliYHPm7Qx66W9LyzVFACsvxz61SVWGknJllW1X9W1M2DqtPTtuJjwXaJ2aW8ykTbeEMqpKy1VVZjVZGOvz3ZBWZOSXMHeHtIXK2EDB+kme2NcyYoxAMxRoVGWf9GvGFO+GjF53g1tVEF2VoVmdWhye78O95Fzm7QzUmehwtjPj8HwfylVqhq7ye+XWp3YNrTmxSBOIPKwa26lAp8Y2nFrUheIyJf2XXSNIMEtLCqaGenw/tBXLx7bh1zNRfH0svFqZPTWowb8BNeRNDf5nkZRdxNj1Nzl05zFfDXJjRhfnalsNAGLS8nl7TzCPs4s4taizzrakZ1GuVLHiYgxfHwtn9QRPZnZ1fqWsnOsxGQxf7cekTo0qbZRafjGaHr9drtS3rFSp+fJoODtuPWT/nE50FMzwqCB8/roYzY4ZXkKkR7lSxdt7g4lMyWXXzI7PWWCOBidRrlJTplQza1sgp+5q5PsbrsWxwfcBO2Z4CSkF/GIzeGdvCFO8GwopVpJzipi2xZ+53RszWCAfpbRcxY+n7tGmvqUwsfLDqXsUlir5drBYbs3R4Mecu5fKn2PEcnHup+ax7UY8v490rzIk+1FWYZUrqaVKFblF5Szec4fJm27rpE745XQkb7asI6QmAtgXkEhsej5vuYsRhI+zizgSnMSc7o2FxqvVajZfj2dypwbC9/v+gETecq8rTJoeC0miq6utsGXqUmQ6XV3tqtXkBZpcnkdZRXi8LvLmNShvMgtKhfNuAIpKlRgo5MI5WgByGZVm3hjoqLyxNjUQtk2Bpi78kQ514a72ZkSniStvGtqYYqQn1ylPwqexLTcEK8MBnSrDc4vLcLQ0Zv3VODr+eIFfz0YRnZaPWq0JjXaoJEx+nFcD9gU8Eg4unuzdkEuR6cKTyaFtHClTqjgRKqa+6ehsw9A2jqy9KkYQ1bcxYWYXZ74+Fi6Z1QIaAuqbwS35/tQ9oUlmWl4JauBiVDqlStVzipKcorKXaqJlMhk/DG1FTFo+m66/rCBSq9WsuRzD+A23yCkqo0yLOiasinrwcV71Gd62HkuOhz+nyjgY9IgjwUmSZKJKDVe1WLta1LXgp+Gt+fpYOOf/ufbszAz5fmgrPJwskcs0qrmqt6/mTHjV2UgWxvpsm+5FpiCBY6inYOX4tjStY87HB0NJzpG+p2UyjW3vs/5uTN3iz1kt+/Mi7GsZsW92J2zNDBm5xk8n9R5ovt+mye3o3sSOIauu4yeYc/UiapsbsXOGF51dbBm0wlf4OVAVbMwM2Ti5PVN9GjJ+/S1WX44VumdE0KNZbc4s7sKTglLe/PNqtfe1BjX4v4wa8qYG/5P4+24y/ZZdw9nWlBMLO9PS0fK1bPdYSBJDVl6nWR1zds3wksxp0YbswlKmbvHnRGgSR+f7CKsEXkRFo9SXg1owq+vLBJVSpWbHzYcUlSkZs+7mcy8SxWVKFuwK4npsBgfnegvZf+CfBqRz9zkemsSeWR2FJu5lShWL9wQTnZr/EnFTUFLO7Wc8+uUqNYt2B/PxwRCWXYhm+zQvmtWphVqtfull91mEPc5h9rZAvhncgt7N7SX3Ka+4jKmb/ene1I55AuSAWq3my6NhRKXk8fPwVkJEzLGQJA4GPmLNhLZCOR8PMwv4/HAYv45wx8FCWmlSplTx7r5g+rd20KoESRRQEKjVaDIdMsQmoCGJWcRlFPCBYNhxcZmS5RdieLdPE+HJ+/qrcfRpbi9s8QlKyCYuvYARgvXghaXlPHpSxEjBUO8ypYq/w1IYJEg+AVyMSqN709eQd5OQhWttM2oJtnNpQ2x6Ps52r0N5U4qNQB5TBTRhxbq9mmgCi6tqmxLPvLHUIfMGXk158zCzQOsz6lnI5TLcnSx1apnxdrHhug6tNr2a1eZOYnaVSpTiMiWnw5KZtvk2bb45x4GgR2QXlaFSQ/EzxJiViUGl92wXF1sM9eScFwwirmtpTL9WddhcCTFRGfQVcub3cGH5xWjhHJAJHRuw1S9eOLNkXncXUnKKOSxYld6nuT0dG9nw3YmIKseo1Wr2ByTS8/fL3EuuXI2lkMsqndhbGOuzbIwHv52N4u4LiqBl56P56XRUlUR8BUrKVdx9VDl5A/Dhm03JLynn/f0hT9WWIzzrsXJcW9zrWaCQy9DTQk4n5xSTllu1mrdTYxuWjnJn0Z47+Mc/QS6XMaqdE0fm++D7UU/e7u1KfWtjFHIZ+ornP6dcpZYk654SOAWlQgSOvkLO0lEe1LEwYuSaG8LXxpgO9fljtAdv7w1mr6DCDDSKku+GtKRDI2uGrvITVnZVQE8h5/OBzfm0vxurLse8cn6N/j/b+WlYa97ZG8yay9ULCJbLZczo4syeWR25HpPB1C3+wuHOUrA2M+SvsW34bIAb7+4L5sMDIeS/hqarGtTg/xpqyJsa/E+hsLScTw6F8tHBUH4c1oqfhrd+5bruZ1FSruSro2F8fvguf4724N03muq0cvwi7qfmMXjldYz0FRyY602jV1gBF22Uuhqd/jQcMK+4nNFrb/KkoJScojImb7pNck4xB+Z4U89KLKhVpVLz+ZEwDgQ+Ys0ETyHCR0Pc3CE2PZ9dM71eCgO+ej8dgxeOZ7lKzR7/R0zwqk+rehYAnLqbQrvvzlcq2X2QUcDkTbdZ0NOFkQIT97JyJfN33aF2LSO+HSKmiNnqF8/5e2msm9QOU0PpCXR0ah6fHAxl6SgPGthIT5RLy1X8ce4+I9vVo48A+QSw4mIMZeVq3u3TROu4VC22OQB9hYwurrZcer87ng2kFUtqtZpvT9yjWxM74XymHTcfYmVqQH9Be1J6Xgl7/BOEiLUKbL7+gJHt6gkHMJ8MTSY9v0RYOeQXm4mRnkI4dyYjv4S7j7Lp9hrImzsJ2bSpRiB6BVQqNfGZBTR+DeSNWq2mka3YswM0z9KqjvXINX6k5b18ndapZYi8kvvTztxAJzWTvbmRTrlkjlbGOgVpOlgYYWqgR6xAoG0F2jhZEpyQLTy+U2MbIpJyhfI7QGNtauVowYXIl61TdxKyaPPNOd7eG8zFqHSUKvVzhM2zqGtZ+UKFXC5jRmdn9geKER+gqQ3fF/BI+DsMb1uP4jIVJwWbsJrWMWeQe11+PyeWZWNsoOCzAW4cD0kSzhn5+q0WXLiXVmm4cFpuMRM33uazw2EUl6mqJFoM9eQkVHF9tWtozftvNOXLY8+rY4a2deTNFnUkyRWlSk3Aw6rtdfoKOavGexL6KIflF2Oe/rcBrR04uqAzpxZ1YWS7ehjoySslW4305dyQsBO92dKBzwa4MX2L/3PqsrqWxszt7sLVD3tyYmFnJndqiKWJPgZ6ciq+UXJOseR9ZGGsz7ZpHcgsKGXO9kBJAkchl/HdkJb0aW7PqLU3iBFUyfVtUYfNU9rz3cl7rLwUI0yi6CnkfDu4JbO6ODN23c2nKiRdMKqdE+/0acJfF6L57EiYsMLtRQxo7cDhed4cCX7M5E23eaKDurYyuDtZsmpCW8yN9Oi37Bq+0a+mDnoRMpmMoW3qcebtrjzKKqLfsqv4x4vZRGtQg38LasibGvzPIOxxDgOX+xKbVsDfb3cVCs4VwaOsQkatvUlgQhYnFnYRUnRow5nwFIat8mOwhyNrJ3i+UstPRaPUqbvSjVLb/P4TNKlUqUnLK2b02huMW38TEwMFu2ZKV25XoFyp4r39IVyPyWD/XG8h20WZUsWi3XeISy9g18yOz2XxVOBEaHKVq9Xrrz14GkB5IjSJ/JJyxqy9yeWo/0xGUnOLmbjxFsM96zG7m5iC5ouj4VgY67FyXBuhCaBvdAY/n45i7URPIbIiv6Sc2TsCmeLTUPia+f1sFFGp+Xz4ZjOh8aGPsll7NZbfR7lLtjxlFFS+OmaoJ8fBwoivB7Vg89QOwiTeqbspPHxSyByB4w2a47H6ciwf9G0ibGfadP0BnZxtaFHXQmh8Sk4xSdlFTOokHra9LyCRke2chO2KJ0OT6N/KQfg7XL2fTktHi9eStRWUkEXbBpbV3k5SThEeTpbUt64+eROdlq8TgVJYoqyUEFGp1PjHZ6GqZG6Snl9a6aSlpFyt0yTE1FCPIB0qdOtZGpNXUi6UtwKaiYeXs7VO+RIe9S0J1mFVvra5ES61zaoMnK0MVVmnnG011fUiX6+RFvK5f+s6+EZnCKsZWtWzoHU9C+HcGAM9OXO7N2b5hWhhm8a7fZpwJjyFsMdVq0+eRf9WDhSXK1nxD5EhhToWRnz4ZlM+P3L3pSrqZRei8Y3JkMxjUqnVlebSVGCqTyP05XK+Of4fhU8DG1PWTPTk3DtdGdDaoVLlSgXuJb8cWvwsrE0NWD+pHWuvxL5kU2pax5wfh7Um8PPefNKvGfWsjDFQyKl47BWVqbgaJd2KNd6rAdM7OzN50+1KVUZuDrX4fGBzAj/vw5ap7Rns4fiUlProQIjk9isInCeFZczeFiCpepPJZHw5sDnDPR0ZvfaGcCCxl7MN+2Z34mRoMj+fjhS+DmUyGTO7OvPrSI0KaduNeKG/exaeDaw5uqAzwQnZTNhw65WJF1d7cw7M9aaWsR4D/7qmk+KvMtQy0mf52Da8/0YTZm0P4NczkcLPSinUtTRmx3Qvpng3YtLG2/z49z2dVJY1qMH/ZdSQNzX410OlUrPhWhxLjoczxMOR3bM6CgebSuFSVBoDl/vSom4tDszxFq4Rrmo/l52P5t29wfw6ojXv9hGfxD6L9LwSxqy7SWpuMYfn+Wi1k6TnlXD1fsZzzQ5lSjXRaflkFZaycnxbYWVSSbmS+buCiEjKZd+cTkLHuLRc0yqVU1TG7pkdKyWJypQqLkamVdk+Ua5S8+Pf91h+8f5Tn32pUsWMrQEcufPoqYLIq5ENHwuSHqsux3IpKo1P+7thLmBBeZBRwPxdQXwzuAWeDaSVD2q1mm+Oh+NgYcS7fcQsRVfup7P95kOWj20jlL1SXKbk3X0hzO/uQktH7eRGSbmSgpLnX3z0/nnpX9DThW8Gt+Dn05HCq87FZUp+/PseH7zRFFNB8nGz7wMa2JgIhVqDxla4/cZD4VwhgO0347E2NaSRrZiSLS49n5DEHIa2kc46As31fDoshYHu4sTwxcg0ugt+Z20oK1eSV1yGh6BCSBvi0gtIySkWDozWhsz8Ut0Ci8uVlV7fFeqEynKENJk3Lz8hDBS62aasdWybcrA0pqCknFQdbAE2poaE69BQ417PklqGemRVQa5WBu/GtlyP0Y28uRad/tLE1sJEn4PzvHGpbfqS8vFZ6MllNNISbl3b3IhebrXZrYOtZHY3Z9ZdjRMOax7Zrh75JeWcFsweqWtpzORODfn5dKTQeJlMxtdvtWDrjXhh5dR4rwbUszJ+yQL21aAWfNbfDWN9hdZ7rKRMRXxm1USfQi7jjzEe/B2WwskXbETOdmYsG9OGy+93Z1jbeujJZS+dw4KSclK0WJtAQ578Psqd9/aFEJXysr3L3Eifyd6NuPZhD7ZMa0/3pnZPCZxjoWK18ot6udC3RR0maVF8KOQyvBvb8ucYD8KW9GVch/qEPsrheIj0Z2haqDpgZWrI3B2BQgTOB32bMa1zI8auv1llOPKLcHOoxZoJbTkdlsI7+4J1apPq38qB7dO9+PN8NN+eiNDZuuRoacyBuZ2wMTNg8ErfSs+VCMwM9Vg5ri1TfRoxdt1Ndt6qXv23TCZjTIf6mpasiFRGr7tZaRD3q0AulzG9cyOOLfDhekwG7+8L4V6y+LO1BjX4v4oa8qYG/2qk5RUzZYs/W/zi+fjNZizq5SocIqoNSpWaNVdimb8ziC8HNueHoa1eqQGqAvnFZczdGciBoEQOzvOm3yuqgqJT8/js8F0a2JiwY4a0YuZAYCL6epUfj8z8Uj4+eFfoh7uoVMmMrQGk5BSzd3ZHIRVBabmKBbuCiEjOZeW4tlhVsa/+D55UOjF7FmVKNX+ej35aMwyayd77+0OZtOEmjpbG/DS8lRAZdjT4Masvx7JpSnuhTJnc4jJmbgtgpGc9ITsWwEbfBwQnZrNsTBuh6zE9r4T39gXz9aAWuAjUlINGpWNqqMdcAUtRWm4Jz+6FvkJG1yZ2XP6gBzO7OPPtiXt80LepEJEFsMUvnlpG+gwXzInJKSxj3bU43u/bVFjhsv3mQ95obi9k4QINobTrVgLTOjcUGg+wL+ARfZrbC5MP12MyMDfSp40ggVKuVHH1fjo9XoNlKio1n0dPinCtbV7tbcWl57+WsGLQVIXrFlisqjT7qWIyU5kVRJN58/K2DPXlQu01FbAy0SevpFzYeqCvkGNfy0in3BtXezPu61AXbmNmyJPCMu4+Fp+UeLvYkCQQuvp0n2qbUdvcqFJrg4WxPvvneOPmYF4lgWOgJ6eetfaFi7Ed6rM/IFF4Qtu9SW3MDPWEJuegCZ2d270xe/0ThFUPc7s3JiQx+6VmpNj0fKZv9WfjC61XzerUYnQ7J745HiH0uyiXy/hqYAv+uhhN+DPhwAZ6cmZ2dcbv456MalcPhVxW6e+AGiSr5R0tjfl5eCs+ORRaqXLFydqEn4e35vrHPRnr5YS+QobBP0ocmQzCBK6rN1s6ML1zI2Zs86+S3JTJNOTKpikd8Pu4FwNbO1CmVLPn1kPJ7ctkMr4a1IJ29a348EAIBRI5Jkb6Cn4Y1op1k9rx4YFQofDaWkb6LBncgieFZUIEDsD8Hi683duViRtvCyvZ6tuYcmCuN7Hp+czYFiD5XZ6FZwMrDs/z5kpUGl8dC3tJsSUFEwM9Voxty/C29Ri+2k+nEOVnUaEG2jSlPX+c09TCi+Z0VYUm9uYcnd+ZJvbm9F92TWvgtK5wtTfn0FwfGtmaMmyVH2uvVC+3pwY1+G9HDXlTg38tLkWm0e/Pa1ga63NqcRc8BWt7pZCRX8KkTbc4dTeZw/O8haudq8LDzAJGrr2BqYEex+Z3Fg4FfhG+0RkMW+1Hszrm/FlJo9SLUKvVbPV7WGWGQUm5itPhKfxw6p7W7eQWlz2t+Nwxw0soM6K0XFON/Ti7iJ0zvKokbgBOhSVLhi/qyWWoVLxUF1yuUhP6OJdGtqZa/f8VuP3gCR8fvMuKcW2ErDhKlZrFu+/gaGnMJ1VUcFf2Gb+fvc/Pw1s/l+2z7mosHx8MfemFTaVS8+6+YDo1tmVkO7Fr7VZcJjtvJfD7SHeh7KWUnCLUgAyoa2HExsnt2TSlPY6Wxqy6FIOliT7jvMSsRhn5Jay8GMPnA92EidJ112Jxr2eJd2NbofGFpeVs8n3A0LZiihiAI3ceY1/LiE6CbWnlShUHgx4xqr0YIQcae1//VnWECajgxGzc61nSup6l8GdUhTsJWXjUt3wtjXlxGa+nJhwgs6BE98DiSix+yn9ubkUlFhBZFcobQz2FTqvfFc8uXUKL61kZ8zhbPPemaR1zotN0WxX30DG02KuRDZci00iRyLGqgEwmo7ebPRcryb0BzWr8nlmdaO1kUWkLkFqtOQ7a0NnFFhMDPeGWGLlcxrTOjVh/LU545X+UZz2iUvI5K/gZliYGzO/hwk9/a2wuqbnFvL8/hDf+uMrFe2mEVBLo+06fJoQ+yq7yWL2IZg61mN65EZ8euvvShNLK1IDvhrTi3Dtd8XGxqdTe9FCL8qYCb7Z0YEDrury9J7hKW4p9LSOWvNWSm5/0YqpPI81vpho2+4q1bi3u5Upzh1q8vTdYktysY2HEinFt2T2zI0tO3BPKO1HIZXw7tCWFpUrm7AgUum+7N63NH6M9WLT7TpXV5M+ilpFGgZNVWMYcQQJnqk8jvhjoxpLj4c9ZsbXB1syQ3TM7Uq5UMU5HG1MDG1P2z+nE/ZR8xqy/qXMttlwu4+3eTfh1hCaAeMv1B6+snOnU2IYTC7sQl57PsFV+JAhci9pgbKDgx2Gt+G5IS9ZeieWro2HVJoUqYKAn5903mrJjhhe7bycwdt1NnfLIalCD/0uoIW9q8K9DcZmSJcfDWbj7Dp/2d2PZGI/X0r4C4B//hAF/XcPSxIBdMzvS9BWJlgr4Rmfw1orrdHS24ZcRrbWSGNqw53YCM7cF8PWgFrz7hph64faDJ2RKSPFLy1Vs8Ytno2/lzR9ZBaV8uD8ES2N9tk7tIKTMKClXMm9nICk5xeyUIHvUajWn7qZUuooil2l+sM2N9BjnVR8na5NKrVVqYNvNh3x4IFTrakxsej6ztgfwxcDmwjaW385Goa8n56+xYgqatNxi5u8K4tP+zWjzQqDtseAk9gUk0uePK8+FN66/Fkd8ZgHfDxULTc4vKefbkxF8McBNWKWz/YZmdXRWV2cufdCdrv80m8Wl57PuWhzfD2klTMQsPXefjo1thImY9LwS9von8kFf7YHKz2LXrQScrE3o7CL2GRX14FN9GgoTK5ei0tGXy4Q/o6RMiW9MOgNa69AyFZmGrbnha1EDBiVkv3RNvSpeV024SqXJnNHFNlVUpqxceaPUrryp7ObXtE2JkzcGenLMDPXIKhCzB8KrNU4lPCnUaVVd18YpC2N9WjlacCNOPCT0jRb2XIhMrVK1YmygYMd0L9o1tHqJwCkuV+IkkYUll8sY08GJ3bfFrVPD29YjNbdY2AJmZKDH7G7O/HUhWnjCOtm7ITmFpczZEUjnny9yLDgJpUqNGigqfVk1YWliwPt9m/LNiYjnJp7lShXb/OJp883Zl3J0FvZ0JaeorMo8E2c7M7ZN82LrtA4425o+d3xTcouFvsuXA5uTXVT2NFy4KtiYGfJJfzcCP+9Dm/qWBDzMErKxyOUylo7yQCGX8f1J7Qs6FejU2IbvhrRk7s5AIRuPoZ6CtRM9ySos5YMDIUIKqjdb1uHHYa1YuCuIAIHg2lpG+myb3oFsHQic0e3rM7dbY+buCOJ0mJhixNxIn81T2+NoacQIHevArUwN2Ta9A/WtTRi66rpwcPKz6NfKgQNzvFl3LY7Fe4JfmSSpY2HEnlmd6NHMjmGr/bgkSFpqwyD3uvwx2oPgxGyGrfLTKcBdCp4NrDi5qAuu9mb0X3ZNWLlXgxr8X0INeVODfx1mbPUn6GEWJxZ2ZrhnPeHJmjao1WrWX41j0sbbzOvuwoqxbV4pSPjZ7W24FsfMbQF8PsCNrwa1eKV2KpVKzU9/R/Lj35Fsntpe2KYCGtuJqLT0h5P3yCl8fkKTllvM6HU3kMlkrBgvVnNdUq5k3o4g0vJK2DFdWqUTnpRLzgur4Eb6cgz05PRv5cCGSe2480Uf3u7dROsqS2m5imMhSczc5l/pS0xGfglTN/sztkN9xnnVl/weAIeCHrHz5kM+frMZFsbSpFWZUsWCXXfwaWzDhI7Pq1jUajUPMgpQqeFxVhGDlvuyzS+eOwlZ/HH+Pn+NaSNMQH5/8h7mhvqMbi/2PdLzSrgUlcYfo9z5pL/b02BjTWhzGKPbOT1t85JCVEouBwMf8amgCglg5aUYPJyscBdsSSopV7L+Whzze7i8dG+XlqsqXXn2i80kPb+EwR7iSp19AYmM8KwnTKz4xmRgaqCHu+CxAg1B9DoqwuGfZqD6lq9lW3GvqSa8olJaF9tUcakS40ozbzTntbLzIauiKtxAx6pweIW6cCtjHulA3tQ2N8TcULfGqQrljS4r6N4uuuXeeDaworhMRYiWcGQjfQWbp3TA28XmeQJHrZnkSWGkpxO3HzwRDmw2NlAwsWMD1l8TU4eAxp6Vnl/C+XvSk8ySciXbbzwkPb+UsxGplCnVz4UIF1WhSh3Tvj6mBnpPFzVuxmXSe+kVvj91j/yS8pd+i4z0FfwwtBW/nYkiSQtR4t3YlnPvduO7IS2x/Oc3pUypJlNAuWFsoGD52DasuxrHrQfS593CRJ/D83wY7lmP+TuDhJQupoZ6LHmrBUeDHwvXYg/3rMdUn0ZM2+JfaVPcizA30mfzlA4EJ2bz3cl7Qtf8kDaOfDGoBVM3+xMiQHJWEDg5ReIEzlsejiwb48E7e4M5GizWnGaop2D52LZ4N7ZhxOobROqQx2Kkr2DZaA/ecq/L8NV+OgWQV8Ctbi2Ozu/M4+wiRq65IazEexEGenI+6NuMLwY2Z8GuIJaeu19tW5JGYeRNZ1db3lruy0HBcHIRmBrq8f3QVvw1tg1rrsS+tu3WoAb/Laghb/7LUVhYyK+//kqHDh2wtrbGzMwMNzc33n//fRISxFewqoJMJtP5X2WYMmWK8N/Hx8dXe7+1wbuxLfvneNPwNcn+c4s1P/Cbrz9g10wvJnuLr95XhuIyJe/tD2Hd1Th2zfQSzkmpbDsLdgfxd5imUaqjoB0EIKeojNNhKZXmROjJZRjqydFXyOjobM2n/d04/143LEz+Qx48yipk5NobtHS0YPnYNpJNRqB5UZ67I4iM/BK2T/d6bntVYdWlGJRqjcpGLgOfxjb8MsKdkC/fYMW4tnRtYoeeQs616HRJm1hJuYor9zOYusX/uf9eXKbkuxMRuDtZ8sEbYuHBdxKy+OxwGCvGtRVWKPxyOpKcojJ+GNbqpesnI7+Ugn9W4tVoXti/OxnBjK0BzO3aWFhRcSkqjRMhSfw6srWwfWbJ8XC6NqnN0Bfsf8dDk7mfms97fcWOiVqt5vuT95jXvbHW8NJn8Ti7iN23E3jvDXHVzcHAx1gY69PH7eWGrnf2BuP1wwVWX455rmZ48/UHjOtQXziXKi23mPySMkboQIaeDE2mTwt74WdDSk4x91Pz6Nak+uRNZn4J8ZmFwlk72lBYWk5STvFrIW8y80sw1lcIh57DP7apSs7TfzJvXn5t0QQWv7wtQz05JVVMwKuCrqHF9axMdArglMlkNLE31ylQtEXdWuQVl2ltHnoR3o1tuBGbKUz46Cvk9Ghqx/l72i1HBnpy1k9sR49mtdH7x+ZjYawv1ChmZ25In+b27NFBfTOxU0NuxmVyP1XseBnpK5jdVbv6RqVSc/jOI3x+ushvZ6OqVGdVNalXyGUsGdyCLdfjmbTxFhM23CI+s5CSchX6cjk5RS8rt7xdbOnXyoEvj4ZpPScKuYyR7Zzw+6QnY/+xbO71T5T62oAmMPfrQc354kjYS4stVeGrQS0oV6n4/mSE9GA0GTorx7fl62MRQkoXgHd6u9KtqR2fHw57rta8KtiZG7J9mhfHQpJYLTj5Ht62Hm/3acLkzbeFQmtrGemzdZqGwJm9PbBSldWLeKNFHdZM9OSTQ3eFr2GFXMa3g1sy1suJDw+GEqilnv1FyOWa4ORP+jVj6mZ/jtwRI42ehZ25IbtmeuHmYM6gFb7C4cuVYbCHIwfneXMs+DHTtvg/9xv7KjDQk/NpfzdWjG/L96fu8e7eYJ0ygqTQo1ltdszwem3bq0EN/ltQQ978FyM2Npa2bdvy4Ycf4u/vT1ZWFgUFBURGRvL777/TunVrTp069f/XfWrSRHyS9f8V5vVweS0tKQARSTkMWu5LcZmKk4u6VNuWkJJTzOh1N4lLL+D4ws6vvL30vGLGrLtJel6JZKNUZdjrn/BcjoyxvgIZ0MDGhKk+Ddk0pT1hS/qyZ1Ynpvo0em4yHpuez8g1N+jWxI7fRohlqhSXKZ++uG2f4SWkVIlLz+d0eAqmBgqWDG5JwOd92DmzI2+5131J5XM2PPW5sOIXIZdpmmcsjfXp/sxkWalS8/aeYB5nF/HrcDHCIyWnmNnbA3m/b9On9iIpnLqbzB7/RNZM9Kx0IhudmoeR/vPHsVSpsZxsvfmQ2w+kX/iyC0v56EAoXwxsLlznfTEylav30/nqrebP/ffcojK+PRHB5wPchBU/l6PSCX2cwxTvRkLjAZZfiKZvizq4OYjZD8uVKtZciWVed5dKz5VKrVmlXnY+mnbfneeD/SFcvJfK1fsZTNShHvxg0GPkMhn1tdQfP4viMiXnIlIZ2ErcMnU5Ko02TpZCGVFSCE7MxtnO9LVsKy69AHNDPezMxHNqqkKmjmHFoCEvrSohdsuUalxrm1LZLWpralCpIsdEX49aAs+aZ2FpYkCW4MQXdLdNATSpY859HXJvjPQVuDnU0qkyvF0Da9LzSkjQIfehd3N7zkdIK1b0FHJWjmvLwH+C9XVZy5jYqQHHQ5OFs4jszA0Z4uHIxmuVW3crw3ivBiTnFHGpkoyStLxiei29wscH75KRX6rVVldchWqruEzJ9egMMgtKuBaT8dxvqVKtrpS8AfisvxtBCdlC1hsTAz1+HN6aP0a5s9H3gXD2yaj2TjhZmfDxoVAh4s5IX8Hq8Z4cvvOYY4IWE+/GtnzSvxlzdgRqVRJVQBNIrLF1Ld4TLKTaqG9jwtZp7Vl9OZZ9AWLk1fTOjZjRuRETN94SUrbVMtLUiNuYGjBnR5CQAqdbEzs2T2nP9yfvsakKO/mLkMlkLO7VhJHtnJi48TYXI8UymSowpkN91k705IsjYSy/KG4JrIChnoKfh7dmTrfGjN9wi8N3Xl3l0qxOLY4t7IyBnpyBy31fsgi+Cno0rc3fi7uQnFPMoOW+z4V7VxdWr+E3sQY1+G9DDXnzX4r8/HwGDhxIVFQUADNnzuTChQv4+fnx/fffY2ZmRk5ODiNHjiQ0NPSVP+fu3buS/95///2n4ydPnqx1e3Xr1pXcnqOjuHXh/0vs9U9gymZ/Rrd3YvOU9q+cR1OBwIdZvLM3mCa1zdgzqyP2taRl5pXhfmoew1b50a6BlVCj1IvIKy7j59Oa68pYX0G/lnX4bkhLbn3aiysf9OCzAc3xcbGtVE0TkZTL6LU3GNLGkSVvtRAiO4rLlMzeHkh0Wj5rJ3oKkQGJTwoZv+EWs7o2JmxJXyZ2bFDl91Sp1Fy5X3lYoZG+HIVcRp/m9mya0h7/z3ozu9t/2pd+PHWP+6l5rJvYDiMB21dxmZJZ2wPo1sSOaT4NJccDxKTl8cf5KH4b6V6lIqWqVWU1mraecetvsvRclNaX3i+PhtPK0UI41Di/uIzPD4fxaX+3l9rBfj8bRc9mtXnLXYyMKFOq+O5kBG/3chVSVIGmXv3Qnce800ecED7xTx3uwNaVt7FZ/vPZxeUqylVqDt95zPStAVia6BP2OEcoQ0GtVrM/IFHYdgZwLToDK1MDWjqKZ2BdikqjRzPdKsLVanWlE4yghCzavqa8m4eZBbjam70Wu+mTglKdieWqVnNVajUPMgor3a/sojJKK5lo6ylkOhMrDrWMdFpRdrQyoo6FkXDDEUCT2maSLUIvwsPJkuCEbOHxxgYK2tS31Mk61bWJHXEZ+SRkShM+in8yUOpbGVeqeqoKHRpao6eQ6dQ2M6NLI+4kZpEmUWtdAWMDBTO7OLPsQsxLE11DPUWltrzK8KJqS61WczoshS4/X2L1lVhU6pdD8suUqirJGytTA74Y6MbPpyNfsgNXhSFtHOnobM1nh8WaH2UyGb+OdCfwYRZ7BBU7TtYmLB3lzj7/RKIFFU4TOzagT3N7Zm0PEMpvMtRTsG6iJ7Hp+cKZOS3qWrBuYjt+Ph3JJQEbHGgaoka2c2L8+ltCgbXm/7RQ5RZrFDgiBI6Xsw3bZ3ix7EI0Ky9pzxh6FhM7NuDXEe7M33mHAzrahLo2sWPfnE4EJ2Tz4YFQ4Ua8Cshkmlrt1RM8+epoOD/+fa/KcGsp1DLSZ+0ET8Z51WfkmhvC5Jo22NcyYscML4a2ceTTQ3fZ6hdfrYryGtTg34wa8ua/FL/99huRkZEA/PLLL6xbt46ePXvSqVMnPv30U86ePYuenh6FhYW8/fbbr/w5LVu2lPx39epVQPPwnzBhgtbt6evrS25PX//1hAf/v0JRqZIP9ofwy+kolo7yqHKVXxfs809kwoZb9GtVh19GtH7lWvFr0ekMX+3HsLb1+GyAm5Bd6Vmk55UwZt1NGlibsHVqe8KX9GX1BE+Ge9ajtgSZFJSQxZh1N5jq04iP3mwmNLkrLlMyc1sAecVlbJ/eAQtjaaIpJaeYcRtu0rdFHT56Uzp8OSwp5zkptt4/tauN7Uz5pF8zgj7vw9qJ7ejsavvcedzqF8+hO4/ZPFWMmFOr1Xx4IBR9hZzvBMODC0rKmbsjiN5udejbok6V48KTc6ts/QJNa9baK3EMW3Wd9LyXV2BPhCZxLTqdH4e/bMmqCr+dvY+Pqy2jX2hTuvsoh70Biczu6iy8rV23NBLy8R1fVreMWuPHO3uDXwps/OPcfYZ6OApbrFQqNfsCEpnTrXGVai8LY/3nlBnl/wSPpuWVMHdnEJ1+usAm3wfka5Fm+8dnkVlQyhvNX7ZlVYWToUkMaO0gfLxKy1X4RmfonHdzNiIVty9O0+Xni7y/P4R9/onEpOUR9PD15d1Ep+XTQFBxJIXM/BKdw5iLqwgsLleptWyriqrwV8i8MTZQ6NQO42hpgl9sJhkS4e/PoqmDOblVTPCrgoeTJSGJulkevBvb4hcrHlpcy0ifjs42nJOwTlVALpexe3YnCkrKhZUhcrmMsR3qP31miMDV3py6FsbsuCldO12BCR0bkPikkKsvNB1ZGOtzbIGP5jkil6Ht6nxWHZSaW8zINTdYtPsO6fklVSp2VGq0Xj9DPBxxc6jFr2ejhL6HTKax3QTEZ3E0WEwZY21qwB+jPfj2RIQwGdO7eR3cnSyYuzNIyLoik8lY8lZLjPUVfHhQTOVjaWLA5intORL8mK1+8UL71amxDT8MbcX83UH4C9i0ZDIZH/Ztypst6zBuw02hnBfzfxQ4UgTO6bDkp2obDydL9szqyNHgxyw7f1+YaBjQ2oGNk9ux5Fg4a3XMY3FzqMX3Q1sRnpTL1M3+5Bbr9gwBjXLo8Hwf4tMLmLU9kLxX2AZo7uN53V3YMLkd+/wT+fRQ9evEFXIZC3u58tmA5qy5Esvs7YHVtmbVoAb/RtSQN/+FKCsrY9myZQC4ubnx3nvvvTSmU6dOTJ8+HYBLly4RGBj4/2RfoqKiuH37NgDdu3enfn3x1ej/i3iQUcDQVdd5kFHAyUVd6Owq1jRTFcqUKr4+Fs4Pf99j4+R2TOr06nk5u28nMGtbIEveasE7fZrovJ34jAKGr/bDtbYZp9/uSremtYVJqRuxmfx6Oop3ersyv4eL0N9UEDeFpUq2ThNrokrPK2Hchpv4NLbly4HNhb7j2itxqP7JxTExUDCmvRPHFvhw4b3uTPZuVKkS5HxEKj+fjmT9pHbCE9VN1x8QEP+ENRM8hUgztVrNx4fuYmNmwHsS6hIR6bFKrSYsKfclP39abjGfHwnjuyGtXlLQVIWghCz2+Ccwt1vj546xUqXmsyN3mdXF+aUsn5Sc4kpf9HIKy/jj/H0+H9C80tyLyNQ8joUk0f3Xy3xxJIz0vBLuJedyJjyFRb1dhfYXNMTFg4wChmmpBzc30q80EwU0E7HU3BJ+OfP/Y++9o6K6Fvfvz5kZegcF6SgKilQFVKyxxURj773XxPTee48pauy9xa6ptqhRUZRmxYINBJHe+8y8f4xwQWbgbHJ/3/feXJ61XCth5sw5c9qc/eynXKXjh4cMtlBsO5fEsBBX2QRrlWVqYEBdNVCFWsPoZad5Z98ljl/PqH64jb6TjYWJCj+ZdrEqVKlYknNK2Blzj3f3X+bxb09w5lY2W6KSWHToGseupcvOu9CHWxlFeP8b8m5Al+UkqgwsKTeUeaPR2zQFVZk3eqrCjRRCVeGgG/hmCwwYTI2UNLM0EVL4tHG0IvpujlC+Q7C7LdfTC4W+T9fWDkTdykKjkb9M33ZOHJZZtQ0621gHDzt+faiKk4NRHd2IScrhlkBo86werdh45q7sli4LExXze3mzNy6lzsBapVTwfD8fds6LoIWNqd76c4CyGsqE1NwSLqbk6T3PHkVWPUSWJEm89kRbdsWkyM6McbA04ZPhAbyz7xJpefLOs66tmzG5ixfPbI2TPah+oZ8vjlYmvLZbnsrHWKXgx4kduZiSy4bT8og1TwcLVk7WqWmOyCQJH2/fgjcHtmPGunOysqIkSeKdQX50aeXAhFVnyCz8+wTOz+dTmL85li8PXKu+Bts5W7N0Qge2nk3mg1+uyCZwIlo3Y+vszqw8cYtPfksQUu21sDFl+9wuqJQSI3+MFMrbqoJ3c0u+GBlEhVrDsKWRsgPE9aFr62Z8Py6Ey/cLGL38tFCrliGEt7Tnt4Xd0Wjhye9OyL5OmtCE/xU0kTf/gTh27Bi5ubmAzqakMDAYmTp1avV/7969+//JtmzYsKH6vxuyTP2347eL9xn8w0m6t9H9sMppz6gP2UXlTF59ljO3sti/oBsRMiuHH4VGo+XT3xL4/I+rrJsWxvAO8kNUq3DxXh4jl0XS38+Jb0YHC2UC/Xn1ATPWn2NYB1emdWsla5mScjUz1+vk1HKJm5yichZujSPC24GPhwXIIpaSs4s5cPk+1qYqvh8XQuzb/fhoWADtXQw3/ly4l8uz2+L4elQQHT3lWU0OX3nA4j8TWTUllOZW8rJA1kfe4eztLH4Y16HeXCCtVsudTMMPPFVKoqHBrpx45bFaOTtarZYPfrnCiA5uDDRgJXoU5ZUaXt91kacfa12HoNkSdZfc4grm6yHont4SS5dP/2TTmTu15NbfHblBgKuNQRWJRqMjhSo1Wn6KTqbrZzrVyKhQN1xtzWRts1arZemxRGZ0a1kvqWJpompQ6VGh1mCkVODpUDcXKL+0gt8u3q+jRgIdSTZj3Tk2nblbS2Vw/HoGza1MaO9Sl4hRShLn7+Wy6cxdZm+IJuC9A4xbcYZVJ28T4e1Qh5xMzS1h8OKTBuXs3s0tsDL9V2ZSSYW6utb4cmo+S4/dZO6mGII+OEjEp0f4U+bgqCZuZRb+W2rCQXcPFM28Ka3QGGibMqy8UUj6lTfGSqVQVTjo8nZyBckvN8HGqWaWJthbGHNDoALYy8ECCbiaJr+xJtDVBkmSuJEuf3DWp50j5+5kCxGAg4NdZDfwgI6MeLx9C6Ha8AhvB5ysTdkVK99uMjbcg6PX0g1ax4LdbTnyYk8GB7voJQZrEmUhHnYcfakXYV72GDeQ85bdwL7zdLBgYZ82vL77omwy7vH2LRgV6iabWAF4sb8PJkZKPvv9qqz3KxUS348L4eztLNlkTDNLExaP68AXAmRMR087vhwZxMKtcbIzUyZ08mRGt1ZMXhMliyBQKCQ+HR7IY76OTFx1VpaCwxCB8/P5FJ7/6TwarY4kPlVDzdba0Yodc7twOOEBr+++KLuFyd/Vhp1zI/j90n1e2yNmg7I0UbFqcihhXvYMXXKqUbkzNuZGrJ0aRi+f5gxdeorIRPkKvUfhYmvG9jmdCXSz4akfTvKXARu7COwsjFk5uSOzerRi0uqzLP7zxt9uuGpCE/4paCJv/gNx4sSJ6v/u2bOnwfeFhoZiYaGbIT158uS/fTu0Wi2bN28GwMLCghEjRvzb1/GfgAq1hg9/ucKruy7w5agg3jSgIBDBldR8Bi8+ia25EbvmReChZ6AoByXlauZvjuXA5TR2z4ugk0CjVBVO3MjgiwNXmd2jFW8N8hOygP164T4LNsfx5cggRstsxSopVzNzwznKKzWsmx4uq1I9v7SCyWvOYmtuxHtPtZdltcgsLGPS6igmdvbi/Lv9GRTo0qBaIjm7mOnronm+nw9P6FFK6MP1BwU891M8Hw0NwK8eUqgmYu5m8/kf11g6oUODZE96QZnesOUq0maAfwv+fLEnX44KwuURsmN7dDJnb2fzTG95aiiAFX/ppNqze3jX+nt6QSlfHLjGB0Pa692PWUXlFJZV8uEvCfT5+jgnbmRwK6OQzVF3eWugYZVUzQeu8koN5WoNl1Pz2RF9j+8PX5elPjiZmElydnGDNe6WJqp6w1ONlRKutuZ8OyaY+KTcOq1CP59PxdfJSm+AclG5miNX0/no1yuEf3yYYUtPsTnqLnvi7hm0TCkUEt7NLdFodW1nFWotp29lcfRqOvviU+n86ZFaqpxTiZkoFZJBsk+SpHpb5SrU2mr73YP8MhwEQ4e1Wi23M4r+LU1TAFlFZTiIKm8MtE1VqrUG94tCgd4BrYmRQpy8sTAWsk2BOHkD4ONkyXWBximFQiLoYWW4XBg/DDoWsU652ZnTt50Tx67LyxgBGBjgzMWUPFlZOVUYH+7Bjph7slUhkiQxq3sr1py8LVupYGmiYma3lnx3xLCtxdxYxZcjg1g2sSNWJiqMlP+6jh8dULvYmrFlVic+GxGAubGy1ntrQk6ezczuLVEqpOr7sRws7O1Dwv182e1TRkoF348NZmfMPdnESjNLE5aM78Bnv18lVmYzkb+rDZ+NCOS5bfEkygziHhjozDN92jB3UwwpMtUaC/u0pr9fCyavOSvrGlUqJF59oi3u9uZMWXuuXrtsFR4lcHbFJPP8T+erQ6kr1Br2PNL65G5vzvY5XTh7J5sXtsfLzpLxambBrrkRFJRUPmy8km87UikVfDTUn5ndWjJm+WnZx/fRz3hrkB9vPNmOGeuj2Xj6jvBnVMFEpeSjoQG8OdCPuZtiWPznDSFFkT5IksS0ri3ZMbcLO2PuMWl1lOzcqyY04Z+MJvLmPxAJCf8Kc2vbtq3B96lUKry9vess8+/CsWPHuHtXN/syfPhwLC0bno3Nysqie/fu2NraYmJigrOzM48//jiLFy+muPjvyyn/3bifV8K0tee4lpbPz093Y4C/4VwSuTh4OY1RyyIZHerOkvEdsJBBXuhDekEpr+w8T1ZRGbvnd23UbPi++BRmb4hheAfXOoP1hrA9OpmXd55n6YQOslUdxeWVvLPvEmqNlrXTwmQRN0VllUxbe45mlsZ8NzZEVntVQWkFU9eeJdDNVra9Kq+kgjmbYhgX7s6MbvIakXKKypm5Pprp3VrK3gcZBWXM3xzLKwN86ehp3+D7rz8oqCXbV0i6h87H2jpy4LnuLB7fQa+1Kzm7mA9/SeDzkYGyW4ZuZRSy+Ggin40IqKO++uTXBLq3aUYvX/0hulW5QmWVGu5mFzN93TnGrzzDU4HO+LawMrhOtYFBU1mlhiXHbtLpkyOsOnGr3kHc4j8Tmd61ZYOV05amhl83USno6GXPrwu7kXA/n3f3Xyb048PM3hDNiRsZaDRafjqXzGg9qhvQDdAlSacM0WghLimXD3+5wh+XHvBnQjpbopL02iVCPGzr5GpoH/5Lyytlc1RStSpn7anbdGtAodfTt3mDgatGSolPh/sTJFgd/iC/jOIKNV7/tsybcuwtxAikkgo1ZsZ17wHqepQ3ElKd4FjQNcyJZt7YmRsL5yy42pmRkiv2++bjZCW7/roKIYKhxaBTrETelB9aDNDGyZLDMgNiQUd4jejgxhGBFp3OreyxtzCW1bxUhaeCXCgqr+TIVfnbNjnCi2tpBZy+Vf8+6OvnxJ8v9aJTS4dqUkbfPUmSJIZ3cOP4y4/R06e5XgInv7RhksBIqeDT4QEsPpoo2z5mY27E5yMC+ejXBNn2FE8HCz4fEcB7+y/LHviGetnzYn8fFmyOrdcCVhNPBbkwOcKTmeujZau25vRoxcAAZ2asj5aVvSJJEu8Nbk/bFlZMW3tWFvFvpFSweHwI1qYqpq87J4sgqSJwCksreGnHhVptYhotHLr8oI5iytnGjJ9md+FaWgELtsTKvu84Wpvy+chACssqmbDqjNC9R5Ik5vT05ouRQTyzNY4djQwOHh3qzqaZ4Xx35AZv7rkoHIZcEyM7urFjbhe2R99j9sZog+HdIvB3teGXhd1xtDLh6a1xHNPTIteEJvwvoYm8+Q9EcrLuBmxhYYGtrW2973V31w00MjIyKCuTH5goBzUtU5MnT5a1TGFhISdPniQvL4/y8nLS0tI4ePAgzzzzDD4+PkRGRjZqW+7du1fvv/v35fvtq3DiRgYDvz+Jm50Zq6aE4SUzONUQNBotXx+8xoe/XGHRmGAW9mnT6KDj6w8KGLYkElMjZaMapQBWnbjFG7svsmxSR4aFiFmt1p26zQc/X2H1lDDZjTjF5ZVMX3eOpOxiVk8JlUValVbo7FUmD73zcuxcpRVqZm+Iwd7ChK9GBcnax+WVGuZujMHZ2pRn+7SRRfZUqDXM3xxLO2crnusjL5ulUq3hma2xhHnZMzXCS9YyCffzq9UBKoVEhHcz9j/dlZWTQ2ntqJ8U0Wi0vLTjPE8FufCYAbJF3zKv777I2DCPOhX1kYmZHE5I551B7Q0uX/zIQ2+FWktafhl74lN5e+8lwy1B9cy+lVVqKCyr5PM/rtL762N6ZdHRd7K5nJrP5C5e9Xw7HaxMVHoH8UZKiTFh7mx8aOFrbmWCmZEStUbLoSsPmLEumg4fHiK7qJxQA1Y6I6WiTn12lcolIa2AD3+5QtjHhxnxYyRbopKqB36BbjZ6A3iroNZoKavUEUIpuaV0bYC86dLKod6BgYlKwehQd0YLtGVV4WZGIa62Zo0OVH8UjakKL6tQG7RNGcq8kerJvKlQa4VmgO3MG6O8MW+E8saKa4LkTbCHmPIGdKHFZ25lCTXL9GnnxLFr6UKDuC7eDmyJSpJt6ZEkifHhHkJNNcYqBVMivFh54latvxeWVbLm5C3e3HOxzjLWpkZM79aS74/caPDzm1uZsHFGOO891R4J3T3O0PdpbmXCqilh/DCuAzZmRrWsVHIUHqCzYo0N8+DNPZdk77devo4MCnTmlZ0XZJ/XAwNdCPOy54Xt52UvM6NbS0I8bHnuJ/lKkhf7+dLa0ZKnt8bKWkaSJF5+3BdHa1Pmb46Vdb4pFRKLxgTrMo02x1AmQ7mla7oKBS3M2RQji1g5fj2D8/fy0Le3NFotp/TYjJpbmbBtdmfS8suYvUG+kqaqsryZpQmjlp3mvsxcoyoMDHRm04xwPvktQThDpwodPe3Z93Q34pJyeX3XReF7YE20d7Hh56e7odHC05tjuZIq3+ppCJYmKhaNCWZMqDsLNsfy6e8Jf4tkakIT/pvRRN78B6KgQPdAJ0fpUmWbAh1x8u9CcXExu3btAsDNzY3evXvX+35JkujcuTMff/wxv//+O7GxsURGRrJ8+XLCw8MBSElJoX///sTFxQlvj7u7e73/qtYhBxqNlu8O32DOxhhef6Itn41ofPtTFQpKK5i9MZqfz6eyemoY/etpFmoIVY1So0Ld+GJkoHCjVFVGztJjN9kyqzM9fcQabRb/eYNFh2+wcUY4Xbzl2bSKy3XqGYC108KwMGk446asUlchXqHWsHJyqKxjoH5IQNiaG/HjhA7VZE99D7664OALFJZV8sN4ecoegA9+vkJOcTnfjA6WTcItPXYTpULi8xGBsgOl15y8A0CQmw075nZh08xOtHex4UF+KZNWR+n1s6+NvENqXglvDmwnax2gU1IlZxfz0uO+tf5eVqlmXeQdXn7ct96cJ0PKGPVDxUrEZ3+y5uTtOg9UhpQ3VajatbO7t9KrrFh67CYTO3vKqiC3NFXVWZ9KIfHuoPZ8MMS/+tg3tzKhSg6jBcrVGnJLKkjNLeGJ704walkkv1xIrfOQ72Fv2P5YUqFGo4WYuzm8secisXd1lgM/Z5sGHzJVCl1DSlmlusHWqJbNLAxmSBkpJdq7WPPeYMMkXH24lfHvy7uBh5k3jbBNmegNLBbPvKm6d5YLPOTbWRiRX1opRHa42TbGNiWuvAlys+VWZpFQHo2fizUSukwkuQh0tcHUSCmr3acK/fycSMktIeG+/O80ooMbV9MKZDciAUwI9+RSSh4X7uWSmlvCh79cIfSjQ3zy21V+vah/Emda15ZcTsknSo/6JqOgjLtZ/8oEkiSJCZ092Tq7MyoFHGsgv2OAfwv+evkxBgS0qCYXi8vVQrk0tzOLhEisNwe2425WMRsF2rc+GOpPck4xKx4hvgxBknS/Y5YmKlnEF+isfYvGBJOWV8qnMnN2VEoFS8aHkFFQxjv75JFYJiolyyd1xMJExSu75JFYZsZKVk8NJa+4nGe2xNV7T/7lQirPbYuvpbipiQq1hj0GMp5szY3ZNCMcrVbLq7suyCbyTI2ULJ3QgQ4edoxYGkmiQB4WQAdPe/bM78rBy2ks2BLbqOYnV1szds7rQqVGw5AlJ2WFQxuCjbkRqyaHEtG6GSOXRbJbIKvKECRJYkRHN/Y93Y3j1zIYtey0rDr4JjThn4Ym8uY/EKWlOmmrsXHDD70mJv+aCS4pEU+dN4S9e/dWk0gTJ040GJpchUWLFnH69GneeOMNBgwYQEhICF26dGH27NmcOXOGN954A4CioiJmzpwp+8Hm343sonKmrjvH3vgUds2LYJTMHJf6oGuoiqSsUsO+Bd3wcTJsIWkIVY1SHwxpz3N9xRulKtQaXtpxnt8u3WfXvAgh24RWq+XzP64SczeHbbM711FnGEJRWSVT155DqZBYOzW8QWtL1XYu3BpHTnE5a6aFyVLpaLVa3tp7iYspeXwyLKDWMnM3xTBlzdlaleFV+PbwDaJuZbN6SqisbQPYdOYuv168z8rJ8hREAAcup7Hir1u8P9hf9jLRd7LJLCzjpf4+7Hu6W619Hp+cS2RiFkOXnGLRoevVg8nE9EK+OnCNr0cFy7Klgc6C98uFVD4c6l9nmRXHb5GcU8KEevJkKtW6vBZDKFdrKC5X88lvCTz53Ynq61ur1epVwlTBRKXAxdaMvQu6MrVrXSvb5dQ8Im9myra5WZqoqveThK59bMP0cCZ2qV1h7mhlSqWe76MLpNTVhb+04zwhHxzimxqVvvXZw6pgpJR4dYBvdUB5GydLg4OAqve/PUiXsxXe0qFBslaSJLroyb2RJLA1M2bVlLAGM7sKSitYdvwm++JTuJSSV33d3MwoolUjFIhbou4S8dkRBn5/gqlrz/Largt8deAqFsZKYu/mcPJGJldS83mQX9pgQKuHvTkWepRKGq2Wtgb2f3MrE0yN6n5nY6VER087oSwJWzMjQj3thEKL3ezMuJddLNTq5ONkyYP8MiEixsHSBA97c+Lv5cpeRqnQ5SSJWKcUCok+bR05ImCdMjdW0d/PiX3n5QcX21kY06NNM7YIBBfbmBvxZEALFm6No/vnR9l4+i6lFRoqNVpMDVw7NmZGTOvqxQ9/Jlb/7UF+KW/vvUSXT4/w8s4LdZbp3MqB15/04/PfrzYYlGpjbsT3Y0NYPTWs2gKbVShPuWBlasQnw/1ZdvyW7Lp1K1MjvhwVyOd/XOW2zKYgSxMV348N4dvD12Wrt6xMjXiurw+rT97mqEyripWpESsnh7Iz5h47Y+QN2K1MjVgzNYw/r6az/C955JKVqRHvD/YnPjmXj35NkPVMaWVqxPrp4SRlF/Pi9vOo9RA4DRE3YNg6VXM9yyeFklNczoRVUbKvcZVSwWcjAhjWwZVRyyKJk5k5VAWvZhbsnt+VjIIyxq08I9vyVhPmxjqFy8gO7oz4MZKDl+XbGh+FQiExr5c3P07syAe/XOGtvReFbaz60NrRkr0LuhLgasOT35/gNwOkbROa8E9FE3nzN1BZWYkkSX/737p162p9rqmpbva7vLzhH/+aVikzM3nNLXIgapmqz94lSRIff/wxffv2BahW5YggOTm53n9Vdeb1ITYph4Hfn8DSRMn+p7vqDSUVxbFr6QxZfJLebR1ZOzVMljpAHx5tlBK1OYGORJm5PpqEtAJ2zYugpcAgTKPR8u7+y+yLS+HtQX6y901VXo2RUmL1lLB67SFVUGu0fPjLFXKKKtgwPRxrGU1UAN8cus6xa+lsmB6OXY3Z/Eq1huPXMjiVmMnQJadIL/iXr39nzD3WnLrN2mlhOFrLaw87czOLn84lsWxiR9zrUVrUxO3MIl7afp4vRgbS2lGeciGvuIJnt8XzxpPteLp3XVtWUlYxRkqJSo2WZcdvMvD7k1xLy+fF7fFM6uJJeMuG83Sq8P7+K9iaG9OnnVOddSw9dpOPh/nXq0gqkjH4VSp0BMLEzp7VpGNDpMWgQGcOPt/DYDvY7tgUJnfxlN3wZWmqqlZgtLAx5Zdn9Le8NbcyaVCNUVqhobxSQ2rev84n7+aWmNZj7TNSSrzYz4d5vf4VIG1qpMTNQKuWsUrB3J7eTInwIvJmJt1ay1O66cu9MVIoWD89XJbFMq+kgs9+v8qrOy8wbOkp/N45QMgHB/n5fCrX0vLZcPoOpxIzuZ9XImtQ5GBpQlpeKZdT8zl2LYNt55L58ZiOFPziwDVmbYhmyJKTdPrkCD5v/c6ak4YHaOfv5eklsCrUGoMD1eyicr35F8YqJTF3c6gQIFXMjFVcTs0nt0S+bcDV1gxJksgRIGJszY3p1roZiRmC1qlG597UtXmUVqgNDqb6tHPicMIDoYmWIcGu/ByfKmTbGN/Jk10ygos1Dy2OQxafZE9cKneyilFrtbWu4/p+f6Z3a0lcUg4HL9/njd0X6PrZn/x0LolKjdagympiZw8KSivZGyePkOrp05yo1/vQzNKY9ZG3ZS0D0LutE75OVnz0yxXZy0R4N2N0qDsv75Bvawpyt+W5vj48uy1OtiLEt4UVHw3z5/mf4mXn7Hg1s2DxuBB2xCTLDj12sTVj9ZQwFv+ZKLt2vrmVCRund2L/+VSWHZdH+tiaG7NpZicq1Bre2Ftb6ZOcXczCrXH1/m5VwZB1qgpmxkpWTQnF0cqEsSvPyCbmdFaytizs04ZJq6I4eUOsucneQvf9XG3NGLY0Unae0qPb8GzfNnw5MpDnf4pnydHEvzXh2tOnOT8/3Y3zyXmMWX5G2BamD6ZGSj4c6s+XIwN5bdcF3txzsVFqoyY04b8RTeTNfyCsrHSzi3JsUEVF/3qYlWOzkoP79+9z+PBhAMLCwmjXTr41oz7MmTOn+r+PHz8utKybm1u9/5ydDYfJarVa1p66zUvbzzOzeyuWjO8gq7q6Pmi1WpYfv8n8zbF8MMSfN55sJ9uO8yhKytUs2PL3GqWyCsuYsCoKRytjfprTGUcr+TXnlWoNL+08z/HrGWyf20W2baKwrJKpa89irFLIJm40Gi2v7brAqcRMlk7sIDtod+2p22w6c5eNM8LrNC5dTs1HrdVVUd/KKOLJ705w40EBpxIzeXvvJZZP7ChbDZWUVcy8zTGMC/eQTY4Ul1cyb1MMY8LceVJmg1WVlcu3hRXTunrpfc+tzEJKH87slVVquJFewBPfnaC0Qi07gwd0NecnEzN596naVhqtVss7+y8xNMSVDg2orBp60DdRKWjnbM3B53sypUbWjz51i0ohYWak5LuxIXw9OtigGupWRiEbz9yVlXVTvR1K3TnYwtqE35/tbvBclpPDYqyUmNTFky9GBFb/zauZuUELXRVxM7dX3eavQDfbutuqUjCigysv9POhQq3hzK1sIrzrz7upQudHcm+MlBLfjAnC72FdeXpBKRGfHjE4MHezM6dlM3NKK/+lqMopriCrqJzTt7L59LcEZqw/R5dP/8T37T94bVddZUJN9GnrWIeErbKvFZerKalQV69HqZDoWU9OU2m5gbYpjRaVAQWoJGEw60iSkF3HXAU7cyMhIsbcRIW5sZJkQeuUJCFkMwIdEZMm2LgS0boZ5+5kU1RWSczdHH748wZDl5yi/bsHeGffZb3LdGvdjLS8Um4+Mvgrq1RzKSVP72CuW5tmlFSohexWYV52OFmbGhywV6o1bDx9h4jP/uTpLbGcv5dnUAlT329QYVkl3o6WzNkYy86YFCo1WsofnpOGFK4mKiUvPe7DN4euyx4Y2lro1G+rTt4RsnS8N7g9RxLShWqWXx3QFksTI9ackk8Uze7eCnc7c97Ze0n2MsNC3BgY4Mz8zfKDeLv7NKe/Xwvmbozhgczz1d/Vhu/HBfPyzvPE3JVH+ng4mLN+ehhLjybKtp41szThnaf8iLyZyfs/X6k+l93szPh+XAi9fXVB1PrUfFXQ1zr1KExUOitUG0dLxiw/TVqe/Ot2WteWfDkqiFkbYthnwKJlCKZGSr4fG8LAQGeG/xjJ2dvyr8eaeCLAme1zu7AlKolnt8X/LXLE3d6cHXO70LaFFYO+P/m3qslrYoC/M78u7E7C/Xye2RorZMFsQhP+W9FE3vwNqFQqEhIS/va/YcOG1fpcNzed6qKoqIjc3Nx6t6Eq3Lh58+a1LFR/B5s3b0at1t2k5QYVy4Gfn1/1f6ekiP0YNRYFpRU8vSWO5cdv8eWoIGZ0aylsRXoUpRVqXtt9kZ/Pp7JtdmeGhrg2+rPSC0qZuvYskkSjG6WSs4sZuew0rnZmfDQsQLaSBXQP4k9vieNSSh475nTBzU6e0qSgtIJ3913CRKVg1RR5eTVarZb3fr5M1O1sNs/sTDOZNcb74lP4+uB11k4L1xvgG3kzE0UNpUd2UTmDfjjJO/su8eFQf73KC30oLKvUKQSCXRnfybPhBR5+pzf3XMLa1IhXnzDcDPcotpxNIuZuDl+ONJyNc/1B7UFTlaXnVmYRE1ZFyRoYFJRW8Pa+S7z5ZLs66pU/LqVx8V4erw7wNbD0v1BUVqk3LFYp6QbIL/X3Zd+CbnXUXpWPKB5MVAr8XKw5/GLPBomuZcdvMjjIRfY5CXD0Wjr2FsYcfbFXvcSgkVJRr+VMpZB4vp8P7z7VvhZZ4+lgofcB1kgp8WJ/X73EDejUEjUVOyYqBT19mvPx0AAkSeJiSh6hnnb4yVS8eTmYV1/nKoXEjG4tGRToUv36pZQ8TI2V9Vqwhga7GgwIL6nQVIcxazSG7UpVUCkVTOzsUas1TR9MVApmdW+Jdz33uRIDgcVqdf1tU/rG85IkPWyc+r+qCxfLX/BtRO6NTwsr/rh0X9ZMuEaj5VJKHseupmOiUhL8wUHGrjjDD0cSiU/ORSGBt4FaeDNjJd1aN+NwQjrZReXsirnHtLVnCXjvIIN+OKl3/xgpFQwMdGbf+VTZ30eSJMZ38jBonbr+oJB39l0mLb+0weOoz26XnF3Mi9vj6fnlMRLu51dnXNVEfZFmQ4JcsTZVsVMgkybY3ZZBgc588pv8FtAWNqa8MsCXN/delG3zMzNW8kyf1iw6dEP2oFWhkPhmdBDHrmcIkQLvPKV7fvtQQB00vasXPXyaM3tjjOyBf++2Trw6oC2LDl2rlUVUH9q72LB8ckfe3XeZw1fkNZ4525ixZWZn/riUxlcPrbGSJDEo0IU108KJf6c/X40KMkjkaLS6ZtGGyCwjpYJFY4IJ9bRn1PJIIULviQBnlk3qyBu7L7JWgKAD3XF+dUBbXnm8Ld8evi5MAFWhvYsN+57uSmpuCaOWnSY1r/EZM6ZGSj4bEcgrA3yZuSGatadu/1siFNztzflpThfaO9swZMkptp9L/v8tmqEJTfi/QBN58zfRtm3bv/3Pxqa2ZaAmyXH1quHQt8rKSm7evAnwb1PHAGzcuBEAIyMjxo0b92/73P/rm+nVtHyGLD5FfmkFvy7sRkcDLTIiSMktYeSySG6mF7JmapjeGXW5qGqUcrYxZdGY4EY1Sl1JzWf4j5H09GnOD2NDhMKNS8p1rU2peSX8NLuLbFtRQWkFU9acJaOwnJWTw2QTN5/+fpXDVx6weWaneoNxa+LYtXRe23WRpRM6EGwgv+dIQnqth3qNVqdUuZ1ZVKei2RA0Gi3P/xRPMytj3hIIAd4UlcTJxEwWjw9pMGekCtfSCtgXl8KiMcE41ENgJRl4yKtQa7mYkkffb46z7Wz97S5fHriGl4MFo0Jr2/AKyyp5/+crvP5kO1nqp4LSuuSNiUqBbwtr/niuB7N66A8brqm8USkk5vRoxe55EbgasBFVISW3hL3xqcztKb/evkpht7B3a8xkZAHZGbA4qhQSnwzzr2V9qoK7nXkdhUcVeVXftvq5WFeTC8ZKiUA3GxaP71BNDJ28kYmFiUp2MLYkSbR6OOgOa2nPK4/XJg4v3ssnwFW/Fa0KTwQ4N5jlYaSUCG9pX0tNZQjjOnk2GMxsZari2T4+Bl+vUD/MLtEz412p0aLSU8sMusG3Vm8vjM6aJq68Ea8Ld7NvRONUCyvhUFA/Z2sKyyoN3h/UGi2bo+4yde1Z/N87wNAlp/jm0HXySiqoUGupUGuqyQuFJBHsrv938VZGIWZGSn48dpOOHx3irb2XOHotg/JKDSYqhcHfqyHBrvx28b7QPh8e4sbl1DyuptUNVfZwMGfF5I6YGinqJVmAWlljBaUVPLstjl5fHWN/fCpqjdZgbpdUzy+FQiHxxpPt+OrhPpSLVwa05eSNTCGFwYROnjS3NOE7PQHB+aUVfH/kBhkFte03HT3tmdzFkxd3nJdtn3K0NmXR6CA++jVBNkFiolKyZHwHfj5/nz1x8rJsJEni42H+KCR4Y/dFvb9VD/JLWfqILWdKhBc+TtZMW3dO9nUY4d2Mb0YHsXBbHNEylV/u9uZsmtmJbWeTWXI0sdZrFiaqukROW0eMlFI1SV1aqeGAjKp7pULi0+EB9GnrxKhlp+uo2epDT5/mbJ7Vme+P3ODLA1eFn6PHd/Jgdo9WvLnnUqPtT80sTdg8qxPhXvaMXR4lnMXzKMaEebBtVmd2x6Ywd1MM+TJq4huCkVLBc/18WD6pI18cuMqz2+Jl1c83oQn/jWgib/4D0a1bt+r/rs9eFB0dXW2b6tq1679l3fHx8Vy4oJPIDxw4EAcHcQuPIVy58q8ZGxcXl3re+fexK+Yew5dG8lSQC+umhdc7SJaLc3eyGbL4JAGutmyZ1Vk22aEPNRulFo0JFm6UAp3iZMzy00yN8OLdp/yEasnzSyqYsvYsJeVqNs/sVCtDpt7lSiuYvOYsVqZGrJjUUZZVCnShwXviUtg8q7PsHJm4pBw++PkKn40IoIeBxqzySg3nDYR3arTw6q4LfHPwWoMPLN8cus71BwUsGd9Btv0tLimHT35NYMn4DrLPhZJyNc9sjSW8pUO9ldCVak29YYOVD+ul39l3malrz+nNmIi5m8OO6Ht8Mjygjrrn20PX8XAwZ0QHeaqxorLKahuM4qHa5vl+Pvz8TLd6VRRVD2WmKgXbZnfmhf6+svbvyr9u0bedo+z8IIDYpFxuZRQxUmYIub5jZqSUWDaxo8GabWOVopblykipq7qd0wDJ1M7ZunrA3Kq5JeumhddSvZxKzGywIvxR2JgZoZBg+aSOda79iyl5DZI3bRwtG8wSMlHp7G1y1IqutmZ0buVgcBhspJT4ZFhAvfeMqtl5Uz3vaUzbFOi+gzB5Y2EsZJuCv6e8ERlQmRop8XO2Nhg6W1BawUe/JHDsWgbF5WoqNdpq++WjKFdrqs8TtUbLuTvZfPTLFbp8eoS+3xznUMID8koq0Gp1iqgqeDlYGDwnOnroFGSn9GTsGIKNuREDA1zYEqVT32i1Ws7ezmb+phiC3z9Iam4pvzzTHSdr03pJ8ppquvSCMg5e0WX2VDRAUjZ0endr0ww/Z2uWH78p+zs1tzLh2b5t2ByVJJtUUSgkPh0eyLrI27Xqlf+4lEaPL47yzaHrRN2uGzz9fD8fSsrV/HhM/vb19HVkYIAzC7fFy65cdrc359sxwby55xLX9BBt+mCiUrJ8Ykcib2ax6kRt9UhcUg6PL/qLLw5cq5Nn9ebAdng3t2T2RnnV3qAjpN94si3f/3lDNina2tGSTTM7seKvW6w5qV/dUk3kTA3j/Lv9+WZ0cHU+2Zt7LslSFSkUEu8+5cfwDq68t+8yCfflt78Fu9uyY24Ee+NSeX33RaEmPNDVy2+f04WNp+/y+u6LjarYNlEpeWtQO6ZGeDF+ZZRsAs8QAt1t2TA9nJIKDUMWn/pbzVY10b1Nc357tnu1Ajvhft22ziY04b8dTeTNfyB69epVrcZZv369wQe7mkHHj1qvGouaQcVTpkz5t3xmFZYvX1793z179vy3fnZNfPp7Ah/9eoUfJ3bk+X4+Bh/4RbA56i6TV5/lub4+fDo8wKDdQA62RP29RimAXy/cZ8a6aN5+yo8Fj7UW+oyconImro6idXNL1k8Pl53/k19aweTVZ7E1M2L5pI6y69V/PHaTjWfusmVmJ9khyjceFDBt3TmmdvViSLBhguH8vdx6v3ulRsvyv27x3E/xBgdw+8+nsj7yDqsmh8rO4MkqLOODX67w2hO+QsHBH/16BUsTFc/1rT+zJjW31ICO4F+Q0IUmWpvWVZmUV2p4ffcFnu7dus4+T7ifzx+X7vPRUH/Z501ecTkVai0KSVdx/PuzPZjb07vBa+vQlTQsjZVEvtqbUK/a+6lCrdH7EJlZWMa2c0nMN2BBMoS1p24zKtRddgOXSw31l0ICMyMlW2Z1pq+fUz1LUZ25pFRIvPJ4W2b3aFgdZG9hjIROrbRlVudaCoHi8kpik3LoKjOsuAqOVqbM7NZSr03yUkoe/g2QN5IkMSTIBSMDahYjpcR3Y4Nlh0UDTO/aUu+9UaWQCG/pQL8G9m2VVUufbapSo9Fr3YOHg28Dv5MmKoVQVTg8zLwRtk2JK2/aOFmSW1JBhmArTIiHHXEGQottzY1ZOTnU4L6qCU9782oybeWJW4xadpp1kXe4n1darWDUB39Xw/Y+hUIi0M2W3bFiNo3xnTz4+XwqPx69QbfPjzJh1Rn+uJyGQqGzrLR2tOSPZ3vQwcPWoD3Pqsa90Lu5JQef64F3c8sG7XyKBu6DkqSzoKw9dUcot2RyFy+upuWzSaDS27eFFTO6teT1PRe5l1PM5DVRPLM1ltziCkyNFDzIr3uumBop+WZ0MEuOJXI5Vf5g9bUn2lJeqeGbQ9dlL/NYW0ee69uGuZtiZSsbHK1NWT6pI4sOX+f4w0yfnTHJjF5+mtySCsyNlcQ+cj4rFbr7T2mFmtd26Vft6MPEzl508LBj8poo2WRqO2drNkwPZ9Gh62xroPnM3FjFwEBnNs3szOnXe+Pd3IJZG6JlETiSJPHKgLZ09nZg7IoznJfZ+gU6kmnnvC7EJuUwf7N4FbifizV7FkQQn5zL9HXnGqVKkSSJ6d1asmySzqL26W8JDao364OdhTFrp4bxVJALw5eearS161E4WpmyYXo4Y8Lcmbcp9t/ymU1own8Smsib/0AYGxuzcOFCABISEvjqq6/qvOf06dOsXr0a0BEhYWFhdd5z586d6karXr16NbhetVrN1q1bAXBwcGDgwIGytvfMmTPcv2+4HUCr1fLWW29x5MgRAIKCgv5tSiF9uJleyK8Lu9PTgFpDBOWVGt7cc5FvDl5n3bQwJnaWl4WiDxqNlk9+S+CLA1dZPz28UY1SAD+dTeKVnedZPD6E0YJV5+kFpYxdcQZnG1PeHewnWzmTV1LBpNVnsbcwZpkAcbP1bBJrT91iw/Rw2sgMDU7JLWHymrNM7uzZYFjtqRuZNMRylFVq2B+fyss7z9d57UJyLq/tusB344Jlb59ao+XZbfE425gKhen+fvE+P59P5buxIQ2qT+5mFxmsvQUwVioIcLNh17wIfqhhv6nCpjN3sTEzYnaPVrX+rtFoeXPPRQYHuwpV2u+J12VYLHisNb8u7C5LEVNcXsmy47dYNDYEez0EwJcHrtHxw0P8eCyx1oPk2lO36dTSoUHyoSbu55YQeTOLqTLsPVVwtfuXdcvazIg9CyII82qYiKuaBX71cV9mPbJ/61tG9XAw8qjd5NydHJysTfGQqUirQlxyDh31bG9GQRkPCkpp79Jwfs6TAc56OQ9dmLJbnXayhtDLtznmeu4pkgSf6VGAPYrSCjVKhaRXXVGf8kaqV3mjoKxC3DaVI2qbsjMTJm/MjVV42JtzPU2sESbY3Za4egZ+3do045Nh/gaJOdCRvzWJ53HhHng3t2hQhWKqUuBnoB2uCkNDXDh0JU1vA9ij0Gp1ip81J2+RU1zBN4dvkJJbQoVai0arI/7sLXT3DxtzIzbP7MS4cA+93+1R4tbd3pxfFnZjeAfX+veFDA47yN2W3u0c+e6IfKLDWKXg3afa882h60K1zfN7taakrJJeXx4jMjGr2u5VXqkxGP4b4GbD7O6teHH7edlKFVMjJT+MC2Z95J16m5MexYxurXC1NePVXRdkkypB7rZ8MiyApzfH8OJP8Q8VILplS8rVehVF5sYqVk0J5eztbBYdrmslM4Rn+7Shv18LJq85Kzu7KsjdltVTw9h3PoW9MlUlzjZmbJrVmZJytWwCB3S/owv7tGHiqiiDYcIl5Wpe3nG+lsXK2caM7XO6kFVUzjv7LgnZ+KqW3zG3C5Ik6fJrchvX+tTTpzl7F3Tl0JUHzNoQ/bfsSUqFxAv9fPhhfAhv773Ee/svCysl9UGhkJjfqzXfjwv+25/VhCb8p6GJvPkPxcsvv4yPjy4b4JVXXmHOnDkcPXqUM2fO8Omnn9K/f38qKysxMzPj22+//bes88CBA6Sl6fy748aNw8hIniLjjz/+oGXLlgwdOpQlS5Zw9OhR4uLiOHPmDCtWrKBz5858/PHHAJibm7Ny5cq/HRpcH5ZO6FinkagxyCwsY/7mWOKTc9n/TLdGtUBVoaRczRt7LnLoygP2zO8qpNaoglar5asD11h05AabZnYSHljdyylm9LLTtHexZsn4DrKtWnnFFUxaHUUzC2N+nCh/uZ/OJfHJrwmsmBQqeyCeXVTO5NVRPNbWkef7Gc7GqMKRq+n1zqobK3U5CV28HZj0CPGWnl/KK7su8MrjvvRuK39fLjp0ndS8Er4YGST7PL6XU8yruy7w2YhAWbaxu1n6ZwxNVAqcbUz5YXwI+xZ0JUhPDlBieiFfHLjKG0+2qzMI/ik6mQf5ZTyjp5rcEIrLK7l4L4fXnvDlxf6+spVsa0/dwdXOnL7t9DcLlVVoyC+t5LvDNwj/+AhfHrjK3awiNkTeZcFjYqqbjWfuEu5lj4eDGAEC4GBhzM9Pd6NtC3lhwSZKBUFuNswWyOM5dzsHB0sTHm/fos5rpxIz6erdTOiemF9awY30QkI8bOu8diklj5YOFrIUdYFuNrXUCqAbyDazNKnTTiYHuuBiz1pKBxOVgvm9Wss674vL1QaziDRaLVYmRqTklnDjQQHXHxRwNS2fhPv5FJdXkl1UxvnkXM7dziYyMZOjV9OJvJmJiZGCW5mFXLyXR8zdHE7fzOKv6xn1BgXbmRuRXVROcXklKbklXErJ4+SNTP64lGYwTNbdzpx7OcW1BrNFZZVcTcuvd+Du42SlN+ulPgS725KQml/vIH10mAezurcyqBI1NVLWUsPZmBmxfU4XnKxN61XtSJKEj1P95G3bFtZ42ltw8IrhPJDc4nLWnLxF9y+OMn7lGX5/mB3yaC6NWqOtRXiqlAreG9yej4fWJqcUEnqb60xUSj4dHsg3o4MwUenPzZF77b3U35fdsSkkpssn23r4NKdTKwe+OiiP9Em4n8+IHyO5nVWkqzGvwUpqtNRLED7duw0KSeK7w/IJptaOVrw10I/nf4qXTTBVqWLiknJZc+qO7HU95uuIjbkxu+JSah1nLXDmln4Sw9HKlLXTwlh76ja7YuRn7bw3uD1tW1gxbd05vSTi2dvZhH10mMT0f90HwlvaM69na17ffYkDlxvOsgEdYbhuergwgTOjW0veGNiOaWvPcuKROvCySjXT1p1jR8w91kfeqfWarbkxG6aHkVlQxpjlp0kXbJ6zMjVi9ZRQgt1tGbb0FFcElFo10aq5JXsWdKVSo2XY0kjuZMrLTjKE3m2d+OWZ7kTdzmbcyjOk/RvqxAEC3f5+1mUTmvCfBnn68ib8n8PKyopff/2VJ598khs3brBixQpWrFhR6z3W1tZs3ryZ4ODgf8s6a1qmRFumysrK2LdvH/v27TP4Hg8PD7Zs2aJXJfTvxN+xNFXhUkoeszdE06edEz+MC5GtUNGH9IJSZq2PxsnalN3zImTny9REpVrDG3sucioxi00z9Lcu1YdbGYVMXBVF73aOfDDYX3Y+Tl5xBe/sv4SjlQlLJsgnbvbFp/DBz1dYMzWM4AZqqKtQVFbJtHXn8HGy4sMhDVt6SivUXDHgGzc1UqBSKBjfyYNJnT3rDBxLK9TM3hhDO2drWWGsVTh85QFrT91m74Kusu05lWoNz22LZ2Cgi+wq8TtZRbUyJkxUClQKXTDuxC6eBnMfNBotb+y+yPhwT0Ie2e9ZhWV89vtVvh4VJHQ+Lzt+C3d7C+bIsAdVIa+kguXHb/LjxI4Gj6OxSvf3qjyOVSdus+z4LVo6mAupUEor1Gw9m8SS8R1kLwO6WngjpcTB53vIzsQqLq/kRnoRexZECK3r2LV0evo017svTiVmNpiZ8yjOJ+fiamuGo1Xd3J6LMixTVahqV9lyNqla/q6UJJbXyLO6n1fC2dvZ9doXa2J8J49a4Z925sbM6yXv+9VHRlSotZRUqOn2+Z8o0FWAV+1OtUaLVgtbzupvBHr/5ysoFRIKdMuUq7UEutqwZ0FXdkYnc/ZONukFZWQVlpNbXE5WUTkl5Wr83jkA6EKmJUmirFLDL890q96/pRVqUnJLSM4u5lZGIXZmRkxaHcX9vFLS8kopekj0TOriyYdD/PVum6+TFRfv5RJzN4frDwpIuJ/PhXu5pOSWsnVWJ733ek8HcyxMlFxJza++znOLy4lPziWvpKL6WL38uC9J2cUcuvKgjgWqXK2pEwLvYGnCzrkRDF58kqzCMvTl+5ZUqPGVodobEuLCvvhUgwrTMcvPcCO9wKBiqgoVag0Oen4zR4d54O1oxbS1Z8kvrUSjRa/qqwpPBbni52LDjHXnuJ9Xu7lKrrO6ZTMLRoe68+WBqyyfFCpvIeCtge14/Nu/mNDJw+C1WVqh5uuD11h76g4ardbgfkmpxwpkrFLw9eggXt5xnn5+OXV+AwxhXLg7f13P4NVdF1g5OVQWmeVgacLi8R2YuCqKIDebOrbYR5GYXsik1VFkGiCIkrOLyS+t0GsD9XGy4scJHZm14Rzu9maEt2x4Ik2pkFg0Jphpa88xb3Msq6eEVv9uHricxtNbYtFotBy68qDWNdbDpznfjQ3m2W3xLJvUUZaCu4rAeW5bPC/tOM9Xo4JkqZPHhXtgZqRk9oYYvh8XQj8/JyrVGuZujKkOBd4Tl8I7g/xqqXUtTIxYPjmU13ZdZMSySDZMl29JB12476fDA1h76jbjV0WxaEwwj/nqn2SpDzZmRqyZEsqnv1/lma2xvPZEO+HstprwcDBnz/wIPvjlMpPXnOWDIf50/huTpk1owj8VTcqb/2C0bt2auLg4Pv/8c0JDQ7G1tcXc3BxfX1+ef/55Lly4wKBBg/4t68rPz2f//v2ArkFLhGCZNm0aS5cuZdKkSQQFBeHs7IyxsTHm5uZ4eHgwdOhQVq9ezbVr1/6f2qX+XdgXn8Lo5aeZ1MWLD4a0/1vEzbU0XaNUq+aW/DA+pFHETUm5mjkbYzifnMeueRHCxE3C/XxGLz/DU8EufDhEPnGTW1zOhNVnKClXs1SAuPnj0n1e332RZZM6ylYrlVdqmLspBgtjJd+ODZal7oi5m1MrHFWlkFAqJPycrflseCAxb/fljSfb1SFuquq9tcCnMqwcVUjKKuaF7fF8OiJQtsUK4LsjN8grqeCdQX4Nv/khLiTrZsMkSfe9JnX2JPL1Pkzr1rLewM6t55JIyS3hxf51VUuf/HaVTi3tG8x0qYn7eSWs/OsWbw/yE1KGbIm6S3sX63of5FTK2rPgZZUa1Botd7KK6fr5n7y4PV7WbN6++BQcrUzp4i3/IU+r1XI9vZAvRgYKhZkfvZqBs62prMFrTRy7nkEv37qDgOyichLu5xMhsO0ACan5Bi1eWYVlQsq+gYHO1cfBWKXgxf6+tQaYcUm5rDYQ5KkPzjZmRHjrjrtCgs9HBsq2WZaUqw2+t1KjxUSloL+fE5Kk+39de5JuoFsfB6DWaCmv1FBaqaGkQpedM7WrFwC/X05jR/Q9jl3L4GJKHsk5JRSXq2t9XrlaFxDuYW9GexdrTtzIIPj9g7R9+w/6fXOceZti+fLAde7nl3EyMYubGUXVxI2JSkGftrqBUVmlmsupeeyJu8envyUwdoUuY2bf+fuMX3mGD365wsbTd4lPziOrsMxgEHqFWou/qzVrTt1mweZYOn1ymOAPDjFzfTRv7b1U/T5JkvhmdDDtXazr3DdUCklv2HgLG1N2zYvA6mEg9qMwM1LKykEaHOTCqcRMg2qOz0cGYm6sapA40WjB3lL/72ZHTzsOPN8Dt4cWyIbyaLybW/L7sz14MsC5lmpHRAj8TJ/WnLiRScxd+Y07ng4WzOjWknf3X9ZrM8opKqfXl8dYH3mXSo1h4gZoMB+pnbM1TwQ48+KO87JVIJIk8dmIAK6k5rM5qv7Ml5ro6GnHKwN8WbAl1iApA3D0ajqDfjjBg/xSg41fpkaKejNgurVpxqfDA5m5PrqWWqY+mKiULJ/UkazCMl7ecR6NRsvWqCQWbI6lQq1FrdWFQT+K/u1b8NmIAOZtiuHMrbp2Ln2wNFHx7dhgHuSXMnO9fAXO0BBXFo0JZuHWOPbGp7BwWzyRN7OqycXySg0n9VjajJQKvhoVyJP+zoz8MZJLKWIKGl1+TSs+HOLP/E2xbI6Sn8tUEyqlgrcH+TE1wouZ66PZcPrO32qWNTVS8vHQAKZEeDFt7TlW/nWrqfa7CU14BE3Km/9wWFhY8Morr/DKK68IL+vl5SX7pmdtbU1xsVhTRhU8PT2ZN28e8+bNa9Ty/ylQa7R8ceAqW6J0s/iPtRWfiaiJ49czeHpzLDO7t2JhH7FQ4SrkFJUzY/05VAoF2+d0wcaApcAQLtzLYdLqc8zq3lIo2Di3uJwJq6JwtTVj8fgOstVMR6+m8/xP5/lhXAjd28jLHNJotLyx5yI5xeVsndVZvi3rbBKVGl2IrkqhYEiIC9MiWuLnomsF+eX8fUZ0rDvru+rEbU4mZrD/6W6yB5WlFWrmbopheAc3BgfJb0qLvJlJ5M0svh8XLEQCxj6cdevv58RbA/1kWU4e5Jfy2e9X+X5cSK1AXICoW1n8fuk+h14QCwr/4o9rPN7eSfYMLujshj/8mcjmmZ3qfZ+RQqdmeDR0pcomsD8+lT1xKfT3a8HbT/nprRfX1YPfYWpXL6HrKzYplwf5pTzhL08JVYVfL6YyKMBZaF3J2cXcySyia5u6RFb0nWwivB1oJtiGF3krix4Grq+DVx4wQOB7hXnZP/w+WvxdrJnzSI5PUnax7Ia4Kkzv5sXJxEx8W1gJZY+VVmoMXpNqtQalQuLlx9ty+Eq60PY8CmszIwY+VMG991R7/rqeYXBQWQVTIwUzu7VCknSkR5UyTvNIE9OjUCkV1STmCz/F8/ulNEyNlJRVqqnp+HxUGRPkblutQniQX0rU7Wxi7+Zw+lYWN9ML0Wi1SFBLHVOp0dYh9YxVCtZODWfQDydIzSutVli1c7Y2SJK725uzc24Xhi6JpKisshaR1aq54aapmnCzMyfY3ZbfLt5nkp5ssGB3W355phtjVpwmu6jc4P5XShJW9agcnW3MOPR8T7p8dkRWBbOZsZJFY4KJ8HbQNfdotGQXys83crQy5Znerdlw+g4dPGxl3wvm92rNrpjj7ItPZWhIbRWbhYmK8Jb2/HbRcHZgFeRkuMzp0YqDVx7w1YFrvCVz0sDW3Jjvx4Uwc0M0HT3taOcsz0Y6NcKLmLs5PLstjg3TO9U5p7adTeL13RcbDODXaLTE3Mmp97lhaIgrN9J1ZQZ75neVdd+0MjVi3bRwRvx4iomrozh3J7uWFe1iSh6FZZV1lLRDgl0pq9Awa300G2d2qqNS0wdLExVrp4Uzbe1ZZq6PZtWUUFnPGAP8W2CiCuHVXRfJLiqvtX3llRp+OpdMLz3KGEmSeP3JdjhYGjNuxRmWT+pIhKDy5akgF1rYmDJrQzRJ2cW8+nhboebSKozo6I6ngwVzN8VwNa2A955q32gVvCRJTOjkSXsXG+ZviiEuOYcvRgbJVjs3oQn/dDQpb5rQBHQ2j+nrznHoygP2Luj6t4mbzVF3mbsxhg+H+vNs3zaNIm5ScksYtfw0za1M2DAjXJi4OXMri8lrzvHqgLY83Vv+NuQUlTN+ZRTuduYsmSCfuDmVmMmCLbF8NSpItrpDq9Xy/s+XScktYd00+c1XOUXl/HopDSOlxDuD/Ih+uy9fjgzCz8UarVbL0mM3eXnned7bf7lWrebRa+ksOnydFZNCcZJZ7121jaZGCt54sp2sZUD3kP38T/EMDXGlnbP88N3fHz7AfzM6iOWTQmUPnN/dd5nebR3ryJ/LKzW8tfcSz/Vto5cAMYT4pBwyCsp4ZUBb2csALD16kwhvhwYJH5VSUe8PUMXDGeg/LqcRbSDU8cytbNLySxkq09JThe3nkhkS7CKbvAOdZerPq+kMDJRP3gGcvJHJ4CAXvXaAY9cz8JWZtVMFrVZLXFIuHT3r7t/MwjLu55XSvp42oEehVEg4PVRSLJlQN/w6ObsYdzsx8qZ7a90A7PUn5F8voFPe6GuaAh0xoVJKtHa05PH2TrLalPTB1EjBM4+1rrYhuNubM6+nd4ONRBoNDOugO89cbM14f3DDgxOVQmJwkHO16mVWD28UkkRxeW3iRt82PhX4LwJu9PLTvPBTPBtO3+FaWkG1OuNRvsPMSKn3t8vG3EjXclaDQO7SgCqytaMV22Z3rnONiASJDw52Ze/DsHN98Gpmwa8Lu9OymYXBfWllqmrwt8vMWMmG6eFE380hT2bF+6hQd35Z2A2VQuKWYF7HxM6enLyRyZ9X5ZOIFiYqXn+yLZ/9nkDhIwGvxioF348LYevszng5mNd7LpZWaAzmLlVBpVTw9aggNkclGQzE1YdQL3smd/Hima1xDa6jCpIk8fmIQNLySll94lad1+0tjGlmZdLg9VWu1sqql3+xny/B7nZC6hYHC2NC3O2IvJlVhyQ0USk5fVO/umZ0mDsv9vdhypqztarb60MVgVNWqWbm+mhZ+1Gr1XL0WgY5xbWJG9ApCg8nPKg3/Ht2D2/eG9yeGeujZRGAjyLMy57d8yL441Iaz2yNE26yqkKolz37nu5GfFIuk1ZHyQ6LNoRgd1t+fqabzgq6+KRsxVUTmvBPRxN504T/edx4UMDQJadQKiT2LuiqV0ouFxqNlo9/vcJXB66xfnp4nRk2ubiWVsCzW+MIb2nP0gny252qcPRaOtPXneONJ9oxvpOH7OWyi8oZvyoKTwdzfhgfUq9FpyZi7+YwZ2M0Hw7xZ2Cg/Fn/xX8m8vulNL4YEShbfaDLq4mmt29zrn4wgKlda9cl38spIb+0Ao1W13Y1YVUUeSUVJKYXsnBrHJ8OD9Ab9GsI284lcz45jyUCCiStVssrO88T7G7LRIH9n1FQxht7LvLNmGCGd5DfRnbgchpnbmfxtp5Z1rWnbqOQJKZ1bSn787RaLR/8coUOnnZC4d+puSVsjrrLi/19G3yv6mGOiCEoJN0gdsWkjgwxcB2ti7zN2DAPIVVTUVklv1xIZUyo/OMCcOxqBo/5OjYY1voojlx9YNBmdyoxk26CM6W3MnV5SPpmxi+m5NGymYVeoqg+hHja0su3Oc42dY91UnaxcBNW4cOBhj6CqT6UVaoxNdJ/jenapnSvvfS4b4Mz+YagUigYHVa7pW/+Y62xNjO8z1QKiWEhrrXI5TFh7nTwsEXVQItRzes42N2Wlx/3bXggW6mhb7t/hVt/NFSXl9NQPkxZpdqgBc/d3pxNMztV25T0hV0/Cn9XGzbN7FS9vQoJ/GQqMgAGBjhTUqYmKdswOdLM0oQ987sS6mmnd7/InbQIdLPF38WGrefk237atrDmt2e7UV6pFhoYWpka8Uzv1nz+x1WhquTBQS6EeNix5NhNva+Hedlz+IWe1eeIvoYshaTL0WsIrR0tebG/Dy/tOC+r9asKC3u3xtbMiA9/vSJ7GQsTFcsmdeS7Izf48+qDWq/1b9+CM6/3YdGYYNq1sEKlkAxa5S6m5KFpYH8qFBJfjgxEpZB4/qf4Bt9fXqlh3uYY/jAQQFxWqeZIwgO9rwFM7dqSOT1b8f7Pl2UHVdckcGZtaJjA+fLANbadTTaoPlMpFPWGfwOM6OjGkgkhbDpzh42n78jazppo1dyS3fMiuJ9XwoRVjSdeXG3N2DmvC/YWxgxefFI4jP1ROFiasGF6Jx5v34KhSyL59YI4OdWEJvzT0ETeNOF/GoevPODFHed50r8FKyeHCg96aqKkXM0ruy4QdTu70Y1SoGtBGLUsksfaOvLxUH/Z7T5V+O3ifeZviuWLkYF1Bin1IbuonPErz9CymTnfj5NP3Fy4l8uUNWd5b3B7vTYlQ9h05i4rT9xiw4xw2eoSjUbLyzsvUKHW8v24Dij1bGPM3Zzq2fuySg1xSbkM+PYvntsWy8TOnrKDV0H33T74+QpvDWqHswCJsS7yDldS8/l8RKBsxZNWq+X13ReJaN1MyJqVX1LO1weu8fZAvzoEWHJ2MSv+usUnwwNkH0+Any/cJyW3hLk95VVhV+GHP2/Qv30LWZJ7I4XCYNaEsUqBu705vz/bg/56GppA992OXs1gUhdPva8bwqErafTydcRfQJ0C8POFVHxbWAmp6Eor1JxKzOKxtnWtAMnZxaTklAjfJ+KScglwtdFLJF66Jz+suCZyiysNttfdyynB3V6svS+rqBwTlaLeAFl9aCjzpkpt06q5JU/6t9CrvlEpwNpUv7zeRKVgTs9WddZhaqTkk2EBBuuktVCdkVMFSdIFotanALI2NaLjIwq0Wd1b0cHDrt7qahdbs1rNad3bNOfF/j4NksdWpka0qie4NNDNtrpFzFPmPbejpx1rp4ahkHTkkY9A3pO9hTEtbE35+Xz9Ay4LExUbpoczMMC5znfUF1ZsCDO7t2TdqTtCVcM+TtaMCnVn8Z+JDb+5BsZ38qSkQs3uWHkNSKA7Z57u3Zq1p25z24DaR6VUMLN7K/565TH6tK2rMDNWKniQL68VanrXlrSwMeWz36/K3kaVUsG3Y4P55Xwqf1zSf9zuZhXVyRdq42jFJ8MDeP6n8yRn17bgKxUSTwY48/tzPfhpTmd6+jRHIVHnGqhQa0mUYX0zNVKyYnIoCffz+fwPw9+tsKyS8avOcOxaRh1bYhU0Wp2ypb6Igfm9WtOppT0TVp0hyUAT5KOQS+AsPnqDlSdu1duaWVKhZmuU/jD2mujd1okX+/vy1cHrLDp0XTgrxsHShC2zOtPC2pTntsUZPEcbgrmxiiXjOzCyoxsjfzzN4QR5zV2GoFRIvDKgLd+MDuKLPxL4/PertRTVTWjC/xqayJsm/E9Cq9Wy5Ggiz26LY3aPVrw8oK0wSVIT6QWljFlxmqTsYtZNDcNLIPm/Jg5cTmPq2rO89kQ7oYyaKuyMucdLO86zZEIIgwTsHVmFOsWHt6Ml342VT9wk3M9n8pqzPNfPh5Ed5RNFv128zye/JbBmapjsimaArw5e43xyLqumhBpUW5y9nV1L9luu1nA/r5SE+wV0Ehgo5xSVM29TLAv7tKkOYJWDSyl5fPHHNb4bF4KtufyBx86Ye5y/l8tHBlppDOGLA9fwbGbB8A51San3f75Mn3aOQgqI0go1n/9+lVceb6u3etcQbmcWsSs2hef7yqsh1ylv6v7dWKkLeP392e71Nmjsi0/liYAWQlYwgM1RSYR62QldW4VlDy1TMtvCqnD2dja25kZ6A44jb2YS4mFbJ5+oIcQm5dDBgGriYkoeAYKkFOja6Lz17Gu1Rsu9HHHbVHZROQ4WxsL3r9KKesgbtbbWPfrF/vrVN1okPhzib5AcmawnfwWgbztHwrzs9ZIxvk5WeglJZxszPhzij7Ge+6WRUmJ4B9c6NjSFQmLx+BCD15aRQtJ7ns3t6c1jvs3rJXC6tW64cn5KhBetm1twO0v+wCyidTPeG6wjfQxVuRvCkGAX9salNDiQVCl1TUmzu7eqdez0NaoZQp92TpgaKYStI/N7tea3S2nckkEcVMFYpeCl/r58c+i6kM2kvYsNwzu48dEv9StbnKxNWTapIxtmhONmZ1atSipXa2Qpb0B3rn01Mojdsfc4eaNhS1IV3OzM+XR4IK/uukhq7r8qm7VaLRsi79Dn6+N8caAuaTIk2JUhwS7M2xxjcJ909LRn7bRwjr7Ui1Gh7hgppervptFoib4jz+Zlb2HM2mnh/BSdrDdst7xSw/ClpzifnGuQuKlCdlF5g0TF8/18GBjgwvhVZ7gvs8a6isBRSPD67gt1CJyDl9P46sD1BvO2AKLvZss67h097dkxtws/nUvmrb2XhJRhoCPGfhgXQoCbDcOXnpJ9PB6FQiHxXF8fvhgZwCe/XmXJ0cS/HTzcv30L1k3vxJ9X0xm/Kkr2ddCEJvzT0ETeNOF/DsXllTy9JY4tUUlsn9tFiOTQh6pGKe/mlmycEY69YPhoFbZEJfH8T/EsGhMsZHWqwobTd3hv/2VWTQmld1v5jUKZhWWMXxmFiUrBd2OCZRM3VdWfs7q3YkY3+ZacU4mZvLhdF2rcUL1oTeyMTubA5TTWTgur12J16mamXnuBWosuRPBEw+0Fao2WZ3+Kp72LtZD6pKiskoVb45jb09tgG5A+pOSW8PP5VD4d5i/USHbuTja7Y1N4e2DdNqiDl9OIuZvDa4K5I6tP3sbB0phhgpa/RYeuMzzElVYybYcqpYJHh5kqhcRrT7Rl6YQO9RJHxeWVrPjrJhM7i6lubmYUcv5ennBGzpGEB3g5WAi1jAEcu6ZrmdI3oD6ZmNWoWtW4pFyDeUKXBGrCq1BSrqu79nase9we5OsCbkWscwDZRWUGG4LqQ2mlxmDmjVqjqTWo92pmwaBA51pki5FCYnCQC0NCXAlxt61lzzBWKZjQ2QMbA/YoSZL4ZFhAnb+bGimY1cPw/W1kRzfCvOwweoSk0WgxWJPtYGnCjxM76CWKJEmif/u69+8qpY+rrRn6btFmRkp66mk004dubZoTaSDnwxAmd/EixN2G+HoagfShn58T93JKuJrWsC1JkiReetyXDwb7Vx87azP55KZSITG/lzfbziULDRTd7c0ZGuzC4qNi6punAl2wtzBmg6BN5aX+vpy7k83Raw1n5kR4N+PPF3vxbN82KBUSGi1Cx87DwZx3n2rP90euk18qLw8IdC10A9q34Lmf4lFrtOQUlTNt7Tk++jWBSo2WywYyYN4c2A6VQsH7P9dPTnk6WPDJsADOvdmXZ3q3xsJEiRaEjkHLZhasnBzK7xfvc+yRfanRamnjaIVGi0ErZhWMVQqOX8+o9z2SJPH2oHZ0b9OMCSujyCiQp36yNFHx48SOpOSWMHPDuVoETqCbLTO6taSFtQlKSarXTmmsVPBzPflRNeHjZMWu+RGcvpXFM1tjKasUy7BRPAyGf6G/L5PXnOWXC/LWqw9PBrjww/gQNp+5y7Pb4hudp1OFls0s2LMgAhcbUwZ9f7LR5FITmvDfjCbypgn/U0jOLmb40kgyC8vY/3RX2ruIWwxq4vj1DEb+GMnoUHe+GR0kuympJrRaLd8dvsFnvyewfno4jxuwidSHNSdv8/XB62yYES6kEtERN2fwbWHF16OCqkM8G8LdrCImrDrD2DAPFjzWWvb6Lt7LY87GGD4a6m/QpqEPx66l8/a+y3w8NKDeTKKC0op6Zc2VGi1f/HGN53+Kr/eB5vsjN0jOLuar0UFC6oH39l+iuZUJT/eWv080Gi0v7ziPs40Zff3kH/uySjWv7brAs33a1LJYgI5Eem//ZV5/oh32AmRQen4pS48m8vYgP6HGiYT7+Ry4nMYzfeSpbkBH1FTNOBopJGzMjNg2uzPTu7VscJ/vjk3B3d6cUMFMlR3R9+jn5yREkAH8euG+UJZTFY5dS9fbEqLRaIlMzBQmbwrLKrmWlk8HPeRNVmEZqXmlwuTN7cwizI2UOOqpf07KLsbZxky4NaSoTE1bJ3EFkEohVdc+PwpzExXNHyFtX+xXW32jAZ57qPx656n2tc4jtUbLnB7e9a7fq5kFs7q3qjWIUkpSva1kkiTxzZjgOvfOFtamtHM2TPZFeDdjTo9WdQZsRiqJYHf957W5sc5epO93prSevJu663YQJm8A+rd35nA9+SD6YG6son97J/bGp8heZlwnD1ZM6gjoJkdEMCjIhYT7+Zy5JTaoW/BYa+5ll3AnU776RvGQbF5y9KbsoGTQqUZe7O/Lhz9fkWXxMlYpmN+rNSdeeQwbMxXHrqYLkVOjQt0wMVLyYQOEyqN4d7AfmYVlvLX3Ir2/Pkbkzcxqe8/drCK922CiUrJkQgf+uHSfnTENW8pszY15uncbYt/ux5gwN9LySjmlpxrbEMK87BkV6s7TW+JqhQqbGum2I+atvrw2oC0tm1mgUkh6CdPSCo3eyvBHIUkSHw0NINDNhkmro8gtlpcLY2GiYt20cMorNbUInBY2prw9yI/Tr/fhwPPdea5vG9q2sEKSqENil1ZqhGrcXW3N2Dk3gpTcUqauOUeBAHFXhUmdPVkyvgOv7brIsuM3G62cae9iw76nu5GSW8Lo5afrWO5EYW6sYtGYYJ7u3ZpJq8+y9tTtpjrxJvxPoYm8acL/DCJvZjJ48Uk6tbRn08xOODRSIVOFTWf+fqOUWqPlrb2X2Ho2iR1zI4TUGqAjfr744yobTt9h66zOegd1hpBRUMa4FWdo52zNN6PlEzepuSWMXxnFoEAXXuzvI3t9tzIK+eS3BJ7r20YoG+dKaj5Pb4njsxEBdG5gcHI+OQ+TBmbZytUa9p9PZfLqs3pfP3otnZUnbvHjxA5CGUj74lO4m13Mt2ODhSx4G07f4W5WMW8NElPILD16E1MjpV7V0/dHbuBia8ZIgf0MOltaL19H4fNw4+k7zO7RSsjCpFJIVGq0SBL4uVhz6IUespRYWq2WdZF3mBohVg9eqdawK/YeY0Ll2/tARwgeu57Bk4KWqbtZRSTnFOslaK6mFVBaoZZVP1sTF+7l4mRtSgubulaSK/fz8XWyEs7tuptVRO92jnr3ZXJ2MW3rISAM4X5eCepGPExnFJYZDFfNKSonv7T2ax4OOsVE1ZYPDHDG00Fn//J3taFPjealocEushrmFvZpU11Jq5BgbLhHg4HxTtamfDT0X/YplUJiTKh7g+fn8/188H0Y4gogAX3aOtV7/3C3N2fFpNA6g9Bmlia4ybS3dWrlwK2MQtLzxQZR/fwcOXEjU3YTURWGBrvyc3xqg+GyNdHXrwUzu7UUyq8B3cBuQicPVulpPqoPng4WuNubs9RAmLAhdG/TnEA3G1adFFvfhE4eGCkVrIu8LXsZF1szTr7aG40WdsXKJ8OqGqH+uJxWbzjvozBSKujoYcfWs8nkFFdQXsPeU1qhId2A+sTV1ozvxobwzr5LJNyXF1hrolLy+YggPh8RyIItsdwVsPUNCXZlbs9WTF93rg4xYGtuzNSuLTn6Ui/2LujKqFA3TI0UddQ4MXdzZKlClAqJr0YF4elgzpQ1Z2WTIjUJnBnraytwJEmitaMV83q15o/nenD2jb68+5QfEd4OqBT/UuTcyizifHKOrPWBjiTcMrMTRioFY1ecEb7eAR5r68i22Z1Zc/I2b+691OismeZWJmyZ1Ym2LawYvPiksILvUUiSxOQuXmyaGc6y4zd5dlu8UDB3E5rw34wm8qYJ/3hotVo2R91l/qYYXnuiLe8P8RcKb30Uao2Wz3+/ytcH/16jVGmFmld3XeBaWgG75kfg20JskKTRaHn/5yvsiUth9dQw/Fzkz3SnF5QybuUZ2rtY883ourPGBpfLL2X8yjP08m3OWwPbyR48P8gvZdLqswS52zKzu3wb0v28EqavO8e8Xt6ygoaj72Q3OEAwUSlwsDRhhJ6MmOTsYt7dd5mPh/kLZfHczSrirT2XmNXdW29jjyHcyijkiwPX+GpUkOyadNA1pC3/6yafDQ+sc+yupRWwLvIOHw3zF1LPXE7N4/eL93ntCbFq8NikHPbGpxrMEjGE6Lu6h9CRHdzYOS9CdrbFqcQscorKeUog1Bl0FiYjhSSsdjmc8IBWzSxorcdW1ND6wrzsq4mAmjh9M5NOrRyE70OX7uXRz0+/Yu18ci5tBJuwAK4/KERp4DpOzi7GXiC3qQpZReVCiq8qlDYQWKyP1Hiur0+1+ub5frXJ5Dee/BchKlchaGasrNXuNFlmIPbwDq50bmVfva2Dgxs+P1VKBcsmdqxWNikUEk/4N6y+69amGS8/7ltLEdWjjfzz2sbMiCB3W6IEaqQBvJtb4mxjykkBZQTotrekQs05QYvDs33bcCermEspeULLTYnw4kRiJjcFMmwAFjzmzd741DqBuw3htSfasubU7Vr5MA1BpVTw7mA/vj+SKJTdYWVqxPtD2vPRr1fIKpRn3QEd8fPuU+15bfdFcmQ0CSVnFzNk8Sn2n9dvmTEzUnLjgeH928OnObO6t+TbwzeE7FqjQt0ZHuLGrA3R1a11crDgsdZ0b9OMGevPGRzE+7va8OnwQOLf6c9nwwMJrmGtrNRoOdxAo1MVVEpdtbutuTEv77hAcbm87awicCrV2joETk00tzJhbLgHW2Z15sJ7/fl+XEg1ET1/s1iVt4WJilWTQwnzsmfCqijZgcs14e9qw94FXYm5k8OM9WLHpSZ0BF0gc3p6M37lGfbEyQ/7NoSOnvb88kx30gtKmbr2rFBuVROa8N+KJvKmCf9olFXqCJJFh26wZmo4Y8LEs2Rqori8knmbYkhIy2f332iUyiupYPJq3Q/NysmhwqGrao2WV3Zd4Oi1dLbP6SJUb56eX8q4FWcIdLXh69HyVSJZhWVMWBXFAH9nPhziL5u4ySvWfdeurR14dUDDFdJVKCitYNrac/Tybc78XvXbHapwMjGz1uxgFRSSbja8vYs1340N5szrfRj9yLlQWqFm/uZY+vs5Gcyq0IfySg0Lt8YxoqObwYG1PlSqNbyw/TxjwzzoItPuADrS7rXdF5nU2ZMAN5s6r7219yJTIryEyCetVssHP19hWreWspu/qvD1wWtM6+pFcz22m/pwJ7OIx3yb8+WoICESY13kbcZ3algN8Sh+ik5mZKi7cDD5rxfuM6gRlqmrafk8GaB/IH7iRiY9fOTlk9TE2TvZBmu7dWHF4jbQW5mFBu8fyTklwucD6AJAG0XeVGgwMZh5o9VreXC3N8fJ2gQ7c6M6AddezSxwtjbFykQpO4sJYIB/CyyMlZgZKauVPA1BknQz8hJgZqSQHVrv8lClALrv2F3meTG7Ryv6tHVEQqfYET2fOrW058SN+nM+HoUkSQzwb0H0HTHLlZFSwcBAZ/YZIAIMwcrUiMFBLmw9K98uAjol1KBAZ1aflK9qgX+1mImqb9q72NCnrRPfHr4utFyEdzOGhbiyTHB9j7dvQaeW9nz0a4LQciM6uBLkZsO7+y/X+7798Sn0W3Sc6w8KDIb9atFy/UH9lraFvdtQUqHmlR0XhGwtbzzZFidrU57b1nAVeBUkSeLjYQHYmBnxzNa4ehUipkZKhoa4sndBV46+1IvpXb2QgA9+TqBCprLERKVk2cSOVGo0zNkYIztXxsJExdppYQ0SOFUwN1bxePsWrJ4axoV3++FsY8LUtWeFCBRjlYJ3BvnRrU0zRiyLrGUvkwsXWzN2zOuCpYmSGevPyQ5tfhSSJDGjW0t+nNiRrw9e55uD14VDlR9FcysTNs3oRPc2zRmy+JQsC1wTmvDfjCbypgn/WFSRFFfTCvj5ma50EMzH0Pd5Y1ecIbekgkWjg+ttwqkPaXmljF52GitTFZtndhbO36giCy7cy2XHnC5Cg6v0/FJe2nGeIHdbvhwVJHsgm1dcwaTVZ/FpYcVL/X1kKzpKytXMWH8Od3tzPhkWIJvwqVBrWLAlDkdrUz4cKo8oUmu0XHxkhtZYKaGUJPq0c2LH3C78urA7A/yd9X7v9/ZfRqmQeFmAYAIdeVGu1gorVpb/dYuC0gpeEVzf1rNJPMgvraMyANgVew8bMyOeFcieAV3L2c2MQmYJqKJAFz598V4es7vLI9eqcPFeHhfu5fHVqCCh5e5mFfHX9UwmdBILKk4vKOXYtXRGCdrI8koqKCytFG6ZKilXszs2hc6t6pJy5ZUaom5n00XPa/VBq9USW29YcX7jyJuMIoPERnJ2sUGyqD5UtU2JoqRCbTCwuEKtMXi/GhrsapAoGxfuTl+BfC3QDTCmdvWqVtLIhaO1Kb18muMjqIDq5+dEy2bmmKgUepVahrbxm9HBWJmq0IIQAQw64uBUYpZwVkQvX0d2xqQID7iGBLlwJTVP2AY1vpMH++JThS0RM7u1YnfsPbJlqExq4unerdkVe48UARUN6EKI98WnNkhoPIo5PVux9WwycUny7TAA7w/259CVNCJvyifgJEnik+EB/HUjw2Aj147oZBZui6e0QkNlPce4tEJDQlr9JIBSqeDbMcFcuJfLqhPyiTSVUsEP40JQKSQWHZJPiBmrFPw4sSPJ2cV88MsVWee2p4MF7zzVnvh3+uJgacwrOy/IJozMjJV8OzaEgtJKFmyOk038VBE4WrS8ve+SbBuitZkxG2Z0wkipYOKqKKGcJYVC4p1BfkyN8GLMitOcuSWeeWVtasS3Y0Pwsrdg2JLGkUBV6OnTnPXTwvjlQiqzNkQ3KpOnJlRKBQv7tOGLkYG8vOM8nzXViTfhH4wm8qYJ/0jEJ+fy1OKTeDlYsH1OFyEriz5cTctn6JJT1Y1SooRLFRLTCxnxYyRB7jYsn9TRYN21IZRWqJmzMZqk7GK2ze6Co4wMhyo8eEg+udqZ8eVI+cRNYVklU9aexcXWjG/1BHMago6AiUUh6apx5S6n1Wp5f/9l0vNLWTJefm15zVlCY5UCU5WCCZ09Of5KL1ZODjU46AXYfi6Zg1cesHRCB6HQ6ePXM9h45i4/jAsRUoJcSc3nhz9v8M3oYKHl7ueVsPhoIp+PCKzTxpRTVM4nvyUwKtRdqH66rFLNJ79d5aX+vkLWLa1Wy5cHrjGnpzc2gvXBS48lMjbcXTh3an3kXR73b6E386U+/HExjaHBrsIqkkNXHlBQVklLAdUGwJlbWTham+hVtMQm5WBhohIe4CdlF1NYWom/nirw7KJyUnJLaC9I3mi1Wl1NuKN+Ijopuxh3e/F7Z1ZhY5U3aoPNMIaUN8BDMln/ayZGSioaMbPrYW8uq8L3UQwKcsFEJVb/DvDREH+aWYpdR2bGSr4bGwwgnHUU6mVHekEpydliJEWopx1qrZZ4gewN0NkbMgrK+auBVp9HEehmQ6tm5hy4LDab7udiTUdPOzadqVsjXR9aO1rR389JWA3j4WDOuHAPvvjjmtBybnbmzOnZivf2XxbKBGphY8qbA/14bZf8wasQg+kAAND5SURBVD/oqtc/GurPW3svkanHdvVYW0dGdHBFaSDctyYupzQ8eLe3MGbpxI58c+g6ZwVserbmxrzY34d1kXf49YL86ncbMyPWTA3jt4tpQootG3MT1s8IJ+ZuDp/8liCb1LQ0UbF+WjipuSW8sP28bFKzys6UlF3M9HUNK3CqYG6sYuXkUJpZmjB25RkyZbZegY68W/BYa958sh3T1p5rlELFSKngsxEBTOriyZjlpxts6aoP3o5W7FnQlUqNluFLI4VyjgzhiQBn9izoyuGEB0xec5bsIvn7pwlN+G9BE3nThH8cfrtwn3ErzjCreyu+Hh0kbK94FMeupTPqx9OMCfNodKMU6AZtI5dFMizElc9H1M0qaQiFZZU8ty2ewrJKNs/qJDQ4SsvTETcdPe34aGiAbOKmpFzN9HXnsDJVsViASNFotLy68wKpuSWsnBIqdAyWHrvJ9QeFrJ0WJkQmfHVQ99BsZari1cd9OfdWX959qj1udubczyth9LLTemeKLqXk8e7+y3w/NkSoEjm9oJQXt8fz3lPthfJQyirV/HgskTndvQkSCKzVarW8s+8yXVo56M1t+ez3q3TwsKO/gHULYN2pO1iYqBglGOR7JCGdeznFTOvqJbRcYnoBR66mC6t8Cssquf6ggCkRYqobrVbL+tN36CaQCVKFXy+kNqpl6ui1dB7z1R8CfCoxk26tHYQDzmOTcvBzsdZ7/7mUkoeHvbnBGmxDeJBfRnGFGi891qDSCjXpBWWNtk05NKIqvD7ljS7zRv/9RwIMDZmMVQphtQfoBo85MttkasLd3pzkHPFcCV9na1JyDQc2G0IvX0ccLIy5nCqWC2NurCLE3Y5TN8Xya1RKBb19HTl0peGa65pQKCSGBLsItU6BbsA5JsyDdZF3hJYDmNm9FZvP3BWuJ36mdxu2RycLt+I83bs1p29mCmf7zO3pTWZhOTtjxTJAxoS642BpzHdHbggtNyjQhScDnPnij6t1SIpmliZ8PTqYwy/0pJ+fLjxbaeBWddtA49SjCHa35fUn2/L0llihfJ82TlYsGhPMKzvPC53f7vbmrJkayse/JggRFI5WpmycEc7e+FSW/yU/gNrG3IiNM8JJuJ/P67vlK3csTIxYOzUMtVYrROCYGin5cWIHOre0Z8LqKOHzdGy4B9+ODeaF7fFsE7Qkwr9IoI+G+TN3Y4ywrbEmbMyMWDMllB4+zRmy5BSRgnla+tDa0ZJ9C7piZ2HMlDXn/vbnNaEJ/2loIm+a8I/DosPXWTG5IzO7t2pUA1RNbDpzl3mbYvloWOMbpQCOXH3ApFVRPN/Xh5ce9xX+nNziciasikKllFg/PVxolvV+XgljV5wmzMuOz0cEyiZuSivUzN4YDcCKSfIJGK1Wy9JjicQm5bBherjQgHJffAo/HrvJu4P9hNRSV1LzOXkjgxEdXIl7ux8zureqRfycuZVFTFIOQ5acZGdMcvXf84ormLc5hgWPeQsN7qvqvbt4N2NUqJgV59vDN7idVcTTfeTXiQP8cSmNmLs5vDXIr85r0Xey+flCKu8Nbi90bmUWlrH4z0TeHtROKAtGo9Hy1cFrLHisdR0FUEPYHn2PYcEuQkQZwO7Ye+SXVtBRoFENIDYpl/SCMh5vL7+GHXTnxsnETAYFiAUja7Va/ryqI2/04WQjKsIB4pJyDbbJNTbv5mZGIW52Znqv7Xs5JZgaKerUczcErVb7MPNGvM2vrEJj8D6j1mhRGRhFShIYGkMaKRXV9cYisDM3JlfAllAFd3sz0vJLhQmjZpYmOFgYcyNdLHBTkiSC3W2JS8oVWg4gonXjKsP7+jkJV4aDrhXocMID4cDTwcEuJKYXCgcX92zTHA8Hc4Ohu4bg28KK3m0dWXZcTH3TzNKE2T28+ez3uqRIfTA1UvLWwHZ88cdVoXBfhULi0+EBrIu8LbvVqQov9PPhz6sZBsm0ls0s+HFiR35d2I2ubZqhUkh1tG0l5WoyC+URnJM6e9LF24FnttSfR/Mo+vo5Mf+x1szeEKNXKWQIgW62fD1aR1CcF2g28nSwYN20MA5decCO6OSGF3gIB0td7sqZW9myLVvw0ELVCALHSKngrUF+BLraMHr5aeGQ7cfbt2Dt1DA+/i2BlSduNapqe0iwK+umhfHZ71f5/I+rQsqxmlApFbw9yI83nmjHjPXRbDx9p1GfUxMWJioWjwthXLjYpFQTmvDfgCbypgn/OKyZGkb3NuJhoDWh1mj57vB1vj18nQ0zwmU1HRnC9uhkvj10g89HBDIlwkt4+YyCMsauOEMLaxO+Hh0kNFhOzS1h7IozdG7lwGfDA2Vn1ZRXqnl6SywFpZWsmRomZO9a/tct1kXeYd20MCFb19nb2by26yKLx4fQ3kX+QDSzsIxZG6J5+rE2fG2gOet8ch5arZYKtZbXd1/klZ0XKCmv5Pnt8fg6WTG/lxiRsvLELTRa+HiY/OBmgJi72aw7dYdvRgcLhfTmlVTw5t5LvNCvTR3FVYVaw5t7LvF079bCKolvDl2ns7cDEd5iZMKvF++TX1LB+E5iAeD3copZF3mHOT3FMnI0msbVg4Muw2FosKuwAu/A5TTaOVvj4SC2T29mFJFRUKY37ya/tIIL9/IapQKKTcohxMNW72uXUvLwb1TeTSGtmhnOu3GzMxfe34VllZSrNY2yTZVU6Nqm7uUUczeriHs5xaTllZJRUEZxuZoKtYbi8krKKtWoNdrqAYdUj/bGWKWQnUVRE3bmRo1S3jhZmaJSSELNQ1XwcbLiWgM5IvoQ4mHbqOrdCO9mnL6ZKTxw6+HTnKSsYm5nitkcfFtY4eVgwUFBC1RVcPEWwRl+hUJieAc3Vp+4LfwdF/Zpw7k72cL1yjO7t+RuVhGHroiRWwP8W+DjZMX3h8VUNG1bWDO9a0te231RKIfI3sKYT4cH8O6+y/UqN9q2sGbD9E7smNuFjp52GNUgUFUKiRvp8jJ+JElHNGUXlfPVQbFg5/m9vAnxsGX+plghUnSAfwte6OfDjPXRQuSGv6sNL/b34d39l4Wq1VvYmLJ5ZicOXE7jm4PX/58TOEqFrgL+Md/mjF5+WrhpqVMrB36a05nt55J5/+crjSJfOrVyYPf8CH65kMpruy8Iq9xqYnSYOxtnhPPdkRu8//PlRt23a0KSJMYL5uM1oQn/DWgib5rwj0NjZP41UdUotS8+lV1zIwjzalyjlFarZcnRRD78+QqvP9mWQYLVxgApuSWMXn6ads7WLBkvlseS8pC4ifB24JNhAbKJm6oWJDMjJeunh8sO0ARddsySPxNZNy0cLwODQn24mVHI7I3RvD3Ij14GFAv6UF6pYf6mWEI8bHm6t2EC5tydbKqeSyrUWvbFp9Djy2Pcyynm61HBQpXa8cm5fHv4Bi/29xVSQBWXV/Li9vM8368NPk5itfCf/Z5ApVrDJ79dZevZpFoPWWtP3Uaj1TKzm5gN6WpaPrti7tWqU5aDCrWGRYeu8/LjvsIWwpV/3aK/n5NQ8w/AicRM8ksqhS1MRWWV/Hw+ldGCljCAXy7eFw4qBjh6NZ0u3g56Cc8zN7PwcjAXzuAqKVeTcL/AYOh6Y5U3GYVltHfR30qWWVhGp0a06WUXlePvYo21qXjui0arpai8gm6fH6XXl8fo9vlROn96hLCPD3PgchrfHr6B3zsH8H3rD7zf+I2Wr/9G9y/+RCGBxsBzvolKQWUjsmtszY1oYW0qu0WmCgqFRO+2jqQ2oo3Fx8mSW4KECECwu12jyJtgd1uKytRcr6fyWR8sTVR08XbgsCBBAehafuLFlDAA48I92BeXImwrGxbiSmZhGSduiNkx2jlb42prJmSfAd1A/Pm+PuyNSxFSmEiSxLtPtWfjmbskyiREqrCwTxtyi8uFFQv9/Jzo6+fEq7saboMK8bBj57wI1k8Px8/ZGoWkszKeEMg8MTdW8ePEjlxKyRMi8CRJ4suRQRSVV/Lez/U3ZT2KGd1a8oR/C6avO0deiXxVU4R3M74aFcTCrXHE3JVvg3O3N2fTjHCO38hgydFE2cvpasTFCRyFQuK9we0ZEuzK6OVnuCpI/vo527BmahjHrqXz3E/xjbKYeje3ZM/8ruSVVDBxVZSsKnpDCPWyZ9/T3UjNLWHiqijhwPEmNOF/AU3kTROaUAPp+aWMWX6GvJIKds+PwLORjVIajZb3f77Cusg7bJvTWVjZALoq5dHLThPh7cDXo4KEMnJSckt4enMsXVs34+Oh8okbzcMK8mtpBbw/xF/I8nToygPe3X+ZFZNDhVQAWYVlTFt7jnHhHkJKDq1Wywe/XKa4opIvRwYZVAhoNNo6VoSySg0ZBWUkZ5dw/l6u7HUWlFawcGscz/ZtQ7BAXg3oMmkcrUyZIUiynLmVxb74VMyMlRSXq3lv/2WeWnyShPv5pOaW8N3hG3w01B9jlfzzQ6vVsuTPm8zv5S3cmrYr5h5a4ClBMjKjoIyfopOZJ7P2vSbWnrrNhE4ewmTRbxfv425vrjfktz7kFJUTmZjJk40hb67Vb5nq1gjL1KWUPLp6O+CiJ6g5p6gMO3Nj2gt+R9BZsQzZ164/KGgwsFQfsorKSS8oa5TFNK+kAjdb3fGSQ7cYKSQiWjVDkiS0hpQ3SgUljZgNtjU35lZmUaOsU8XlapKyxHNv2rawlhUC+ygC3HREg6hKxFilIKylPacakTPRz89JWF0CuvtGZGImGQJBq6ALLvZqZiFsgTI1UjKxsyerBGvDQUeKbIlKEt7W0WHuXLmfzy7BDBvfFlaMC/dg2bGbwrarT4YF8NXB68KKr3efas+1tAJ+OifPIhTh3YxfF3ZjxaSOqBQSP0UnCyk2WjtaMjbcnZd2nBcKqDUzVrJicigHL6exPVq+AktHivnhZmfGgs2xQmqOJwOcef3JdkxfFy3UIubtaMUXIwNZdfK2UF29ufFDAkej4b39lygul0dUSpLEqwN8mdLFk7ErznBB4JkGdITTznkR3MosZMb6c8IEKegsg9+OCcHB0pjhP0ZypxEkdBVcbc1YNCYYewtjhiw5ybU0MTKzCU34p6OJvGlCEx4i4b6uUaqNkyUbZ3TC1rxxjVJllWqe2RbH8esZ7J4XIWQBqsK1tAJGLT/NwEBnPhrqL6QMuZdTzNgVp+noacfHAstqtVre2neJuKRcNs8UC0SOupXFs9viWDQmSKiytrRCzcwN0QS52/Jyf7HK7A2n73IlNZ8Vk0LrtXXdzipCbWDmvaRCF8i86ND1Bh9AtVotb+65hKeDObMFw3ZP3shkV8w9vhKoZwfd/nlj90Ve6OdTnRNRVqkh4X4+T/1wkhnrz9G/vROdBGun/7yazsnEDKZ2bSm0XGmFmu+P3OD5fj7CgdtrTt2mSysH4evhVkYhkYlZTBC0aAHsiL7HmDB3YSLhwOU02rvaCKv4CkorKKtU08tHv23zTmYRPQWUZVWIScrB3Fil93tcTi0gt6Qcu0bcr3Q14fU1TTUirLiRTVOgqx82M1byUn9fjGWcX1rg+X4+SBIYunwbG1hspFRgZapqlHXKzc6MezmNUN60sBSumgawMTMmq6ic8/fEMmEA+rVzbJRqp287Jy7cyyVLIIcEdAOzDp52/HpBjISRJIlx4R6NCked1MWTqFtZwoNAf1cbIrwdWHlCTH1jpFTw0uO+LDp0Q6gJCuDZPm04ei2DwwligdBdWzejf3sn3t13SYj4sTEz4vORgXz0a4Jsa5EkSfT1a0HcO/0wN1YK759BgS4M7+DGvE2xQjYbV1szlk3qyHv7rwhVXauUChaP70B2UTlv7rkotH8mdvZkaoQXU9acFSLGdHazcL49dJ0tUfLPWR2BE86drGJmrIsWInCe6dOGpx9rzYSVUUQLhmY3szRh66zOqDVaxjdS8WJmrGTphI70aevI8B8jibkr1khXE+bGKpaM78CIDm6M+DGyUURxE5rwT0UTedOEJqBrlBq97DTjwj34elSQkIqhJgpKK5i29hz3sovZObdLowY/55NzmLn+HJM6e/L6E22FBp7J2cWMXXGGXj6OvDmwnRBx8+EvCRy/lsHmmZ2EsmqupOYzc4PO8jTAX75SQaPR8ulvCZgZKflypPw8HtA19nz2+1XeHOjXYPDtpZQ8TAzUD4NO+r3s+E0mro4it56B2o6Ye0TezOTr0UFC25pXUsHLO8/zxsB2wvkpy47fJMDNhomdPCgq+9dDrkar2+6E+wUcvZrBH5fuy34gLa/U8PGvCbzQz0e4nWhLVBLWZkYMElSk5JVUsPH0XRY8JpYtBDqS7smAFkLnJOhIn/h7uQxtRF5VfHIuIzuIL3cqMYvc4gq9ir3U3BJO3cwi1EsscBkg9m4OHTxt9b52MSUP/0YQxKUValLzSvTWmQMkZ5f8nzZNVW2TqZGSnj7NG7xWTFQKJnb2pIWNKQpJMhhYbKJSNoq8AV1ocWMGMW525txrRONUa0cr0gvKGmU7CHa3Fa7vBp0d5ujVdCGLD+jyPfxdbTh6TbwqeHCQs3DLFcCQRgYXN7M0YViIK6tPipEMoFPfbDx9V5iketLfGUdrE+GWLDsLY1563JcPf7kinB/y1kA/sosrhGvVe/o0Z3CwCy/vPC+korEyNeL7cR1YdPi6sNrjjSfbYWqk4N19YjaoUE973h7kx/zNsUI5NhYmKtZMDSO9oIwfBWvgn+vbht5tHZm0WswSFOhmy5ppYXz86xX2xMlXYZmbqFg7LQyNVitE4ICuYe3tp9qxYEssJwWtglamRqydFoarrSkjl0U26h6mVEi8NciPZ/u0YdLqKH67KL/m/VEoFBLP9fXhi5GBPLctjiVHExsVrNyEJvzT0ETeNOF/HpvO3KlulHqmT+MbpdLzSx82QinYMqszDoItLaBTsExcdZbZPVuxUHBbqoib3m0d+WCIWOvQ1wev8+vFVLbM6iTUApScVczkNVHM7enNuHAxZcSnvydw4kYmi8eFCIXJ3s4sYv7mWD4c6k9HAxkgNXE+ObfBh+CySg2RN7P45pD+IMXE9ELe33+Zb0YH42glRiL8eOwm7ZytGC+4f66m5bPs+E1m92hFfj0y5tySChZujWfiqihZD7ObztxFqZCEj1dRWSVLjiby8uO+QuRV1Tr9XKwJFcyPKiitYEd0srBCCOD3S2mMD/fATlAFklVYxs6Ye/RpJ1a5DjoSuD7LVJCbjVBOEuiI1dikXEIMNE01Nqz4dmYR5kZKHK3q3qe0Wi3J2cW424mTN5lFZTg0omkK/lUVLkmSTn1TD4muBZ55mHOlkDD4UG+sUlDWWPLGonGNU41V3tiYGeFsY9oo9Y2OvMkVXq6dszUKhcRFQUIEdMHFjcm9GRjgwrFrGUK2GXgYXBzs0qgB4YxuLdkbnypsgQpyt6VTK3th25VCIfHagLYsPZZY76SAPowOdcfKVCVkuQFdCPH4cA/e3X9ZqLUKdGSKSqEQVjZ18LDjmd5tWLg1TqhFzFilYMmEDhxKeMB2mZatKowL92BQoDOzNkQLWXxa2JjyyuNt+fHYTSH7nSRJfDDEHx8nK17ZdV6ITAnzsmfZpI68uecSf1ySf96aG/+LwJm+7pzQOkeHevDaE22ZvTFa+Po0USn5YVwHIrwdmLMxplEB6gBTIrz4fmwIL+84z8q/GtdmVYUnA5zZPrcLm8/c5dlt8X8rFLkJTfgnoIm8acL/LNQaLR/9coVDVx787Uap25lFjFgWSaeW9qyeEoqFQMhvFY5dS2faunO8ObAdkzp7CS2blKUjbvr5OfG+YF30kqOJbD2bxOaZnfF0kJ9/klFQxsQ1UUzu7MV8wRyTDafvsCs2hbXTwrAXILnySyuYtSGaUR3dGNlRXkX3uTs5Bi0VoJvBtzM34t2n/Hj9ibrhvaUVulaqiZ096WHADmMIBy6nsSXqLh8PDRA6JmqNltd2XWRqREvau9iQVVheq+XjUZSrNUTdzqb318fYUM9Mb05ROd8evs5bg/yEbU/rIu/g4WBO77Zitp+ScjWrT95ulOpmf3wqfds5CucLVao1rI+8w2OC2wrwx+U0gtxthavMtVqtLu/GwDpPNTLv5l5OCbnF5QYDiRsbVnwrowhvR0u952VeSQUFZZW424vtA2i8bapCrUGt0Var5Pr7OeGkh1gC3TU7s1vLaoJcl3mjH3+LvDE3aqTypnHkDegap64L1oWDjry5kJwn3BijVEh0adW4yvB+fk78dSNDeDBlZ2FMT5/m7GtMcHGYB+sj7wjXjbdxsqKrtwO7BXNoAJ7p3YYNkXeEFVERrZsR4mHHUkGlh1Ih8f7g9iw5msh9weDr4R1cae1oyZd/XBNaztJExdO9W/PxbwnCrUVze3rjbGPGN4fE1ulsY8b3Y0N4d/9lLqeKkYdvD/LDztyYl3aIqYX8XKz5YXwIr+26IGQtUiokFo0JRqOB+YLZOd3bNOf7sSE8/9N5/rwqn0ypInAAYQJnWIgbX48K4pmtcfwiaFFUKiQ+HOLPoEBnRi8/IxTYXBN9/ZzYNrsLG87c4fM/rgqr+2qivYuNLsg4r4QXtsfX25DWhCb809FE3jThfxLF5ZXM3RTDn1fTeX+wf6MbpQAu3Mtl5I+RPOnvzOtPtBOqgK7C7xfvM29TLJ+NCGSsoCLiblYRY1ec1vndn/ITIgnWnLzN8esZbJrZidaO8huA8ksrmLLmLCHuupYnkXUevvKAz36/ysrJoUJkkVqj5dmtcbjamvG6zIYkjUZrcBbbRKWghbUp7w9uT9QbfZnWtaXe7JzPfr+Gi40pLwpm8mQWlvHG7ot8ONQfZ0EiYOPpO+QUl/Nc3zbVn6VS1H9eqTVaNFq4X89DzXdHbtDB046egiRUXnEFy47f5OXHfYWVaXvi7hHmZUcPwXpsjUbLihO36N0IBczx6xkoFVKjyJJfzjeuZerK/XwKSyv13ku0Wi2nEjPp2ojtiU3Kwc/FWq86La+4gqTs4r9RE67/+kvOLsHO3AgrQZUQPLRNNbImHMDs4fdUKCRe7O+LiR71jUKSatXN6zJv9A/gTFQKygUbo6pgZ24srJoAcLU150FBqXBTFegap643IqCzbQsrKjQabgoOvAG6tnYgshE2prYtrLAzN+Z0I4ifIcGu7I1PEZ6Rrwou/lkwuBh06ptlx28Kk00dPe3o4GnHpjN3hdf56gBfNpy+Q4pgkHColz39/Zz49LerQstJksTHQwPYGXNPOHOkcysHxoTpwoRFaseVColvxgSxNy6VffEpQuvs1qYZ83t5M29TLHkl8q81I6VOuXMxJY8f/pTf6gTQy9eRN55sx6wN0ULBuqZGShaNDeZBfhmv7rwgRBr19XPii5GB/HAkUeh6MTfW2b1AnMB5IsCZpRM68MrOC+yIFlM3SZLEvF6teelxXyatPitEOtVEgJsNW2d25s+r6cJKqUfR3MqEzTM6YWGsYvDik41SGjahCf8ENJE3Tfifw4OHjVIFpbpGKa9GNkoB/HU9g/Ero5jXy5vXn5SfMVMTu2Lu8cL28/wwLoTBgg0+dzKLmLk+mgH+zrwzSIy42Rx1l0WHr/PWwHa0c5bfVFNaoWbW+mgcrU34cpRY/svFe3k8uy2Or0cFybI81cQXB65yN7uY78eFyA79vZNVVGeGzFilwNPBnC9HBXHqtd6MDfcwaM84fOVBdZ22aJvTm3su0qmVvfAxTc0t4auD1/lkWED1gD2rsJz6Dq3Jw++0Y24XXn2ird73JKYXsPVsEm8NFKsGB9h6Lomu3g7CrWnllRp++DORIcGuwqTPsevpFJereUIgR6kK26OTGdnRTSgcGiC9oJRzd7Ib1TJ17FoG3do003ueXHtQQHG52qD1qT7EJeXSwcByl1PzcLU1a5TS5VZmkcHK9saGFQNkFpVj34jMm6oBdU2SalCgc51cJhOVggWPedf6e32ZN8YqBeWNnPHVZd6I26YcrUxQKSTu54rPDvs4WTXKNqVSKghwtSGuEQOaLt7NiL6TI0xqSJJEPz8nDjbCOtW3nRMP8kq5nCpmy5AkifGdPIRCYKvQtXUznKxN2R0rRjAAPNu3DSv+ukWeoI2uvYsNA9q34PsjN4TX+doT7TiS8IBzguGzXs0seLp3a97YfVE47+mVx9uSU1whHELsbGPG5yMCeWvPJeGmtQWPtaZHm2a8srPhyvKasLcwZtWUUFaeuMUfl8RyfiZ29mRUqDvT1p0TUlRZmxqxfnoY5+5m8+nvCULrfCrIhXGdPJi1IZrYJPnEWk0C5739l4UInMfaOrJqSijv/3xFuEoeYFJnT74cGcSCzXHsjBFXrQG42ZuzY24EZZUaRi8/zQPBVryaMDFS8sXIQGb3aMW4FWeEsoSa0IR/CprImyb8T6GqUcrHyYoN0xvfKAWwNy6FORtj+HiYPzMF24eqsPH0Hd7df5lVU0Lp6yemMLiTWcTYFWd4IqAFbw9qJzQ43hVzj09+TWDt1DAC3WxlL1ep1rBwaxzlag1LJ3QQUhndyylm+vpzPNfXhycEB8e/nE9lb1wKqyaHCoXsnk/KrbZMGSklfJ2sWDK+A0df7MXgIJd6B/dpeaW8vPM8Hw3zF1IIAeyJSyHmbi4fCdqltFotb++9xAD/FrVUGpmFZXpn+VQKCSOlLtTv0As9DQ7yAVaduM2YUDdaO1oJfZeMgjK+P3KDub3EbU9741IwM1byePsWwsuuPXWHiZ08hcPDMwvLOHo1g1Ed3YXXeeBSGh087Gihp5K7Ifx5tZ68mxuZdGpp36gg9LikHNq7WLM56i6RNzNrZVlcTMkTrkGvwq2MQoNNU8nZRY3KuwEwNVLozdFpCKXlajq1tK91T1EpFTzXtw2mNfabsUrB9G61M5AsTVQ0r8diFeRm26jMBRdbUxrBx6NQSLjYmJLciMBP3xY68qYx29vY3Bvv5hbYmhsJDSir0M/PiSMJD4TtWlX3BVGlBsDgIBduZhRyUbBdS5IkZnZvxaqTt4S3N9TTngA3G9acEq8cf6G/D39eTeeqYH5ICxtTFvRuzbv7LgtbTmb30D2TiJIwZsZKvhoVxHeHbwiTiP38nBjWwZWF2+KEbEUKhcRLj/tyKSWf5X+JbW/bFtZ8NSqI9ZF3hPfvawPa0raFFbM3RgsRl45Wpmyc3ok9cSksPy5miRsd6s7Lj/sydc1ZoeBtc2MVqyaHkpxdwrS1YgqcCO9mbJgRzpcHrrH6hPj5OzDQmdVTQnl//2Xh71sFGzMj1k0Lp52zNcOWnBI+VjVRdR0vm9SRd/dd5rPfrwopxZrQhP92NJE3TfifwdFr6YxadpoJnTz4alRgoxulAFaduMVbey+xYnLHRmflrDt1m28P32D99HBhO8XtzCLGrDjN4GAXnu/rI0QQ/HrhPm/vu8TKyaFCAbJarZa39l7idmYRa6eGYW4sP9cnt7ic6WvPMaB9C2Z2FwufjUvK4eWdF/hiZKBBpYAhfPenbrbTz9mKddPC+eO57vTzc2pQLaTWaHl2Wxx92jkJH9/U3BLe3X+Zz4YHCCsifr14n/jkXN58xBaWWVhWRz1grJTo1MqBoy/1Yl4v73qJtOPXM/jt4n2e6+cjtD2gy0Tq2rqZcO6MWqPlx+M3mdfTW1gBk5heQNTtbMY3oh58T2wKHT3thJu9AH65cJ+BgeKqm5yicuKTc9FotXT59Agv7zzPbxfvV1tuTjbSMlVSXsmtjEJaNrPgzT2XmLrmHIHvHST848PMXH+OwwkPcLAwEVYDaLVa1Fot3s0MNE3llBgkdhrCxXt5jSLFSyo0XNGjwhjR0a3azqhUSDzft02de09JuZo0A7O5xioFUbezqWzEw72pkZLERtiQADybWTYq96Z1c0taO1qSLhisCzryJjlbLAQYdIOhCO9mRCaK25/CW9pTWqHmQiMCj4eEuLL/fKrwwMvK1IghwS5sPSeuvnkqyJmC0kqOXRer4gZd89SaU7eFw4A97C0YFOgsnEMDOquXm50ZPwmG+hopFXw6IoDFfyZyW8AaBDqb2JQIL17YHi9EwoAu+Li0Qs0iA+H/hmBrbsyPEzvw3eEbwja8Af4t6NTKnlkbooUyqhQPc2wq1Fo++S1BiNDzambBumnhLP4zUViRMiXCi3m9WjN5zVluCBBklqZGrJ4aikKShAmcDh52bJnVie3RyXxz6LowORzRuhlbZ3dm5YlbwvuqCsYqBV+O1EUDjFp2mhM3xJvqaqKnT3P2LOjKwctpzN4QTYHgddmEJvy3oom8acL/BHZEJ7NgcyyfDA/g6d6Nb5TSaLQs/jORH48lsnVWZ7q3EcsOAd3A6asD1/j+z0Q2zggXtg/dyihkzPLTDA12Fa4SP3zlAS/tOM+S8R2IEBxMfnXwGiduZLJhRrjQ4Ky8UsP8zbGEetkLZ/Kk5ZUyZ2MMLz3uS08fsfDZU4mZpOSW8PqAtvz2bA+6tm4me91LjiaSUVjG+4PbC61Tq9Xy6q4LDGjfQlhJlVtczq6Ye7z9lF+dhqT7eaXVCqKqgOXvx4WwaUY4bg0oJCrVGj765QrP9vXBXrAF6F5OMVvPJvFif3HS5/dL9ymv1DA0RJzcXB95l0GBzgbVFIag1WrZHp3M6DB5YdY18SC/lJi7OTwRIK4SiryZhZ+LNU7WpmQUlLEr5h4vbj9PyAeH6PP1MW48KMDCRCWcgXI5NR8zYxUdPGxxsjKpJvDSC8o4nJDOuTs57IhJJuiDg4R9dJgZ686x9FhigzPmGQVlXErJN2gZTcoubpT6SKvVklXUuMDi0go1pnoyp0xUyupWKSOlxPhOnnXeI9XTNmWi0n1mY+rC7cyNyWlE2xSAi40pKY0gb8xNVDzILyOxEaHFIR52RN7MFhrUVaGXT3PhXBbQkQSPtXXk0BUx2wpAV28H1BotUbfFSaNx4R7si0sRDi42USmZGuHFqkYoEDq3cqCdszXrT90RXvbpx1oTdTubqFti39VEpWR0qDtfHbwmnL/UwcOO6d28WHRYfLD+fL82lFdqWHJULE/G1EjJD+NCWBd5h8hEsRylQDdb3hrUjme2xpEuaK1Z2LsN/i42LBAMEzY1UrJyciinEg23TRqCv6sNyyd15O29lziSIGYdnNfLm4mdPJiwKkqodc3cWNVoAsff1ZbF40PYdjaJT35LED4n/F1t2Dk3gmPXMvjwlyvCxB7oiOKFfdrwwZD2zN4Qw7ZGELA14d3ckj3zu1Ku1jDyx0ihDKMmNOG/FU3kTRP+0VBrtHz4yxU+/f0qm2aEC+eP1ER5pYYXtsezPTqZnfO6EuAmHhKq0Wh5/+cr7Iy5x/Y5XfBzEfuMmxmFjF1xhuEd3HhNkLg5cSODhdviWDQmSLiFZ83JW1xKyWf99HCcbeSH72q1Wl7bfYH80greHNhOqOGotELN7I3R9PRpzvSuXkLbez+vhIVb4/hwiD9zBJuwou9k8+Oxm/wwLkS4NWxn7D2Ssot55yk/oeUA3cMUMETPOXohWTerrZBgdKgbJ17tzQB/Z1nHf+vZJCo1WiZ1rjvobQjfH7nBAP8WtG0hZs3RarUsOaqrORcN8M4rqWBX7D2mRYjXg8cn55KWV8qA9o3JrEnnCf8WwlXwAIeupNGjTXMC3GyofBgcXVKhRgvczCgiJbeU9/Zfxv/dA4xcFsny4ze5nJrX4MNzbFIOQe62KBQKerdz0mvhqVDrPiOjsIwjV9P58sA1FjcQ4HkzowhXWzO9Ad2ga7hqjG2qqFxNeaWGZo2oCi+pUGNqpP9cGReuO3f7tHXUG9yskCQ0BsYRVYHHjWmcsrMwEm4YqoKucUrcNgW60OJrjQgtdrYxxcHCWNhOBBDW0p7951MbNXv9hH8LztwSb6RRKRUMCnTh4GVx4ifAtfHBxePDPYhLyhVuOAJ4tk8bVp28LbyfHCxNmNOjFZ/9cVV40NynnSOBbrbCahbQNUGdvZXNLsGcHxOVkm9GB3PsajqXBM+nNk5WvDmwHc9vjxduaxsf7kGPNs14eou49eqrUUHkFJfz0S9XhNbZ3MqE5ZM6sOH0HbYLBvtGtG7G16OD+OS3BOFWpuf7+fBUkAvjV0YJEad/h8Bp42TFjrld+O1iGm/tvSSsoPFqZsHG6eGcuZ3NnI0xlJQ3Lgx+WIgba6aGsT8+la8OXPtbVeI25kasnRrGoCAXhi49JUwaNqEJ/21oIm+a8I9FcXklczbGcPRaOnvmR9DBs/GNUkVllcxYf44b6YXsnNeFlo0IOVZrdETGkasP2DG3i1C7E0Biuo64GdnRjVcHiLX+RN3K4pPfEvh0eAADBANg98al8M2hG7zQz0d4m787coOoW9msmRImRIRotVpe2XkBI6WCj4b5C33XKqVPn3aOws1ducXlvLTzPK8M8KW9ILF2J7OId/dd5pNhAcItPZE3M/n1wn0+Glr3u1aqNdzNLsLMSMm+Bd34cGgAljL3ZV5JBd8cus6bgoHLoCMK98an8nxfcdXNsWsZZBSUMiZMPHdmR3Qy7ZytG0WOHrz8gCkRXgZJifqwM+Ye4a0chJdTa7Qcv55B77bNcbQyxc5c/7Evq9RQodYSfSeHrw9eZ+D3J4m6Xf/DfuzdXEI8bAF4zLe53ualR2Fvbsy7DZCHtzIN591oNFpSckoaFVicVViGSiFhbSZGeoKOvDHTQ8yALofDzc6U8Qau5/rapoyVVeSN+CBDp7xpHHnj+jfrwm+ki5M3kiQ1OvfGxdYMD3tzzjZwTupDROtmXLiXKxxUCzAk2IVdsSnCx0eSJMaFe/DXdXHrhZ2FMSM7ujUq/yPC24E2jpZsOC3ePDWje0uSs0s4cFlMpSFJEu885ce2c8nCWSFWpka8P6Q9H/16haxCMSuev6sNvdo68sKOeOHjMz7cgxB3O+GBuSRJfDwsgLySCr48IGYzszBRsXJyKPvPp7LtrJiio7WjVXWGyinBwf+TAc5MjfBi+rpooZwgSZJ4a2A7HvNtzvv7L5NeIF9t9HcIHE8HC7bP7ULkzSxe2nFeOE/JycaUn+Z0prCskomroxrVyAfQxduBD4a0Z298Cs/9JH6O1YRKqeCZ3m1444l2zFgf3ahw5v+PvfMOj6Lc2/C9u+m990pCQkJLCL2jIKggiPQOAiKWY8Ou2Bv2CtJ7UZCq0ovUJJCQBEiF9IT03rPz/bGGD48pzLvqQZ37unIdjrszszs7u8n77PN7HgWFvwuKeKPwj+R6WQ0Tlp2horaeHx7uJztw9mYKKmqZvPwsWkliy/zeQt/M1zVoeXxLFBfSS/juob6yF0bJeeXMWHmOCd09ZNc1R6UX8+DaSGb39ZGd33I0IY8XdsTyzbRudJWZefL9+UxWnrzG6tk9cLKSd86+OZ5CZGoRS6eF3Rh7uFXe/vEydQ1a3hjdSdZ2kiTx/PZYwrxsmdXXR9a2jVqJp7+7yITunrKzTWrqG3lxRyxP3xXY7AjUmtOpeNiYEvnynbIFjS8OJxHsZsWdQfKcVgCfHEzkgW4eQm1sXx9LZk5/32ZdEq3RqJU4lpDPPJm5SKATa9efTWOYzHE10Dm1otJLuLuT/JGp6IwSJCDEUzf+2PkWAsBVKhje0ZmerWROSZLEhfTiGyHUffzs23SPGKhVrJjZHXuL1p0vV/Mr8WshP+p6eQ31Wi3uMuvtAQor67A1NxIaS61tRbzRoWrRuadWqWjpC2S1WoWRRi00NmVnbkR5TYPQeICHrZnQGBLoxBsR5w1AiJeYeAO6a+yUQO6NlYkhvdvZc0BgdCrE0wZbMyOOxssXYUaHuHE8MV/IaTSnvy8p+RXkynyNmsY+VvxyVXbtsZmRAU8Mbc8H++NlL5j9HC2Y2deH13dflu1SGN7RhV6+dry1T147EuiaoIwM1Hx6SF5blkql4t2xnTiakMd6mRXrpkYavpnWjc3n0mW7sjztzPh6ahiv77ksu6Wrr58Db47pxIIN52Vl0QBM7+PDzD7ezFwVTraMa0qlUvHG6E6YGxswfUW4LKffzQLOKzvjZAk47jambH2oN5eyy3h8S5Tsz0crE0PWzemJvbkRE5adIadU7LPO38mSHxb2I7Wgkukrw4WFoCYm9PBk3YM9+fRQEi/9ECv02a2gcLujiDcK/ziSrpcz5qtTdHCxYt2cXli38E34rZBeWMW4b07jZWfGqlk9ZDsqQLc4X7DhPKkFlWyd31t2lkTS9XImfXuOmX29eeYuecJNXFYpM1eFs2h4IBN6yHOhnE8r5tGNF1gyvovsbJ/TyQW8sjOOpdPCCHCW12506PJ1vjySzLczusvOPNkVnUVMZinfTA2TLRxsPJdOVEYxL90rL5cH4NsTVymurOO5Ec3XdLfG54eTsDYzYmYzglFOaTWfHkrivXFdMDeWd+1dK6hk/dk0XhZ4PpeySzl4+TqP3ym/Yerc1UIM1GqmCYxpHY3PIzmvgjuD5AswP8Xm4m5jShcBx86Psbn0ameHQxuiR3McS8hjUIDjjVDmnj62rbqcDDVqgl2t+HxyaKvB2dmlNRRW1t14PpYmhgS5tjy+ZqRR88rI4FuqI2+9aaoaVysToUD3ooo67AXybkDnvDFu5T3bqJUw0DR/vtStZN6ALihTZGzK5tffHSUCuTcetqbkltUIiUYBzpYkXa/4SxunAPr5OXA6RWzkYFiwM4dk5n6AbvE6OsSN3Rflt041BRdvkumyAPB1MMfJyoS1MoUFgAHtHQjztmX7Bfk1xRN7eCJJ8J1A7fJjd/iTlFfBTzJrsQFev68TBy9flx0Sa6hR89H4ENacSpXdRmZrbswnE0N498d42Y6hdo4WfDKpK4u+j5EduNzHz54X7+nAwxvOyx5dHBfmwex+vsxaHSHLCQO6MajBgU5MX3lOlgijVqtYMq4Lvg7mzFgVLisQ28zIgJUzu3O9rJZZMh04TpYmbJnfm4yiap7cGi2rcQt0eUFfT+1GqKct4745I5TTBbqxtS3z+2BjasjYb04LOfhupoePHbsf68+F9BIe3xyl174UFG5HFPFG4R/Hgg3nmdrLiyXj9GuUissqZew3pxnSwYnPJ4XKdoCAbtxq8a5LlFbVsXl+7za/Ef9vEq+XM3n5Wab08mL+QD9Zi/Ck6+XMWBXOwiH+zQoDbR33wbURPH93B0Z2kZcTlHi9nIc2nOfNMZ1ku1ASr5ez/JerLHmgC53c5S3CE3LLeXFHLI/d4S+7aSght5y3913hk4khssNW43PL+PxwEh9N6Cp7XOdydhmrTl3jvbGdm21kemPPZYYFO9PXT35T0bs/XuGBMI9WF/wt8fXRFB69w19WvtGNbY+lEOZti5WA0LnmdCrT+3jLzskB2BaZwfjuHkKuj70x2dzbWSwP678rwrt62rRYL22gVuFmY8KaOT3b/Dy5kFZMkKvlb5qVhge73BgDuhljAzXDgp2Z0efWBLOrBZW0a6FpKr2oCg+BkSmAwspa7C0ExZs6bavOm0athEbd/HWhUqlaHJsC3fkREVGMDTSYG2mERqecLE0wUKuEvpFu52hOZV0DOaXyFo+gC33NLavhuszAV9AtehOvl1Mgc7wGYGiQM5GpxULfnI8OcePQlTzZLU6gCy7eHS0/uBhgbn9fNp5Nk+2gUalUTO3lzWeHkmSHQxtq1Cy6K4CDl6/LzguxNDHk+bs78Pa+K7K3dbE24dkRgbz0Q5zsbQNdLHn8zvY8s+2i7G17t7Nn3gBfHtsUJXvboUEujA/z4OEN8rNVpvX2ZmIPT6HjPjm0PT197Zi3NlLWtiqVirfGdKK9kyWz18gTUgw0aj6fHIq9hRFzZIowZr+Oi2lUKtkCjq25ERvn9QJgzpoI2e8FA42a9x7ozJhQN8YvPS0sHOvcVmEMDnDi/q9PESVTKPxv3G1M2f5wnxsCvILCPwlFvFH4x/Hc3R30apQCXQbJ+z/H82B/X14dGdxmtXRzlFbVM22lLohu3ZyeshezCbnlTP72LFN7efPUMHl14NcKKpmy4hzTe3uzYJC8wN7M4ipmrAxnZh8fpvfxkbVtXnkNS/bHM7uvD+PC5DX+FFfWMXdtJL3a2XOvzGDp8pp6Ht5wnjn9fbmjgzzXRnVdI49uusDcAb6yRZK6Bi1Pbr3Ig/19b8nxcDONWokXdsQwp59vswLL0YQ8TiUX8OJ/1YbfCqdTCiiprucpgWrw82lFHEvIazFfpDXiskoJv1bEbJkB06ATGyNSi5gkkJOTWlBJVHoJ9ws0W2UWVxGbWcoIgZGp62U1xOeWMyjg/51pnd2tqan/vVCgVoGliQGb5/XG2rTtz4IL6cWEev72mhoY6IjEb0UKjUq3MFsyvsstfUbUNjSSUVSFj4MZsZmlZJVU/6aqOaOoSiisGPi1aUq+ewlaz7yBX503LXwOq1TQmkdF57wRy1OwNTeSHboKulpzNxtTocYpE0MNPg7msvIzmrAwNiDAyZKo9BLZ29qZG9HBxUp2VTPoMnM6uFpyNEF+Bbe/kyXtnSz4WcBR0sXDBl9Hc3ZHyw8u7ulrh7e9ueyqZ4DBgY6425qy6Zx818/dnV0prKxj1Sn5mTtjQ93xdzJng4BjaGovb+wtjPj8iLwRKID5A9thbWYoO4cGdBXrVqaGvLVPXpAw6P6eszQx4OWdcbKzc/5zZwAGGhWLvr8oe9v3HuiMl50ZL/0QK6vKXqNW8emkEIwN1CyU2XxlZKBm6bQwDDQq5q87L8sJY2qkYdWsHjcEHDkijJWJIUvGd0GtUjF95TlKq+WJqCqVikXDO/DYHf68++MVoRwq0J27V0cF8+gd/kxdfpZDl+U7+W7GzMiAt8d01msfCgq3I4p4o/CP465g+Yuwm9kbk82DayIZHeLOw4PluV2aKKioZdLyszhYGLNiZnfMZQo38bllTF5+lul9vHlS5gI8s7iKqcvPMjbUnSeGtpe1bWFFLa/vuczQYCfZ21bVNfDgmkgsjQ1lP+b6Rl3IcJCrJU/cKe+4kiSx6LsY3G1NeUIgXPeNvZexNjXkPzKPC7qRJxW6P07l8l1kBhW1Dc1uW1PfyFdHknl5ZJDs0TFdw9oV7uzgJHsMSJIkPvg5gTn9fWW7xECXdTOpp6fQtmtOp3JfVzehbb87n8GdQU5C2/4Um0sfP3uheutjCXl09bD+TbW7jZkRjs08DiMDNZvn98btFrNkotJL6OZt85v/1tnd+ne5L4YGatbM7vkbh05rpBdW0dXTBo1KxagvT9LvvSO0f+lHerx9iPu/PsXPcTkUV9ay52I20RklFFbU3vLCp65BSzsHMeFHq5Vade1YmxmibuGz2FCjblX4cbMxobYZQe1W6OxuTZnMxUwTfdrZk1cu38UCuvGn9CKx8QF9Rqf6+tkLj04NDXLmoOCCa0yIu5AAAzr3zWaB0SmVSsXcAb6sOnVN1gK9advH72jP0uNXZY+bqFQqnh/RgaXHUmS3manVKp4cFsjHBxPJkHl9aNQq3h3bmeOJ+VyW2bSlUav4aHxXtkSkc1Zm3bmBRs2nE0PYfTFbtkBnqFHz5ZRuHE/MY0uEvCYoIwM130wL40JaMV8fS5G1rbGBhjfHdCI6o4R3f5SXFWRiqGH5zO5U1DTw7k9XZDU6mRhqWDGzB5V1DbJrz5sEHAO1itkyXTRmRgasmNkdWzMjpiw/KyRYz+nfjim9vHho/Xl2Rcsfg2xidj9fvpoaxn+2RLHil6t6NVGJfPGqoHC7o4g3Cgo3sfZ0Ks99H8PXU7vJdo40kVNazYRlZwhwtuDrqd1kZ69cySljyvJzzOrrI1uMyC2t5tGNUQwNdpZdJV5R28DsNREYG6h5/T55DU+NWonHN0dhYWzAew/cmgPgZt7ce5niqjo+nhAi+5ft8l+uEpNZwmeTQpsdPWqNfTE57IvJ5tNJIbJqzAGi04vZeC6Njyd2lT2el1lcxZt7L/PW/Z2avT6+PJJMvVbigW5ibU2VtQ3MEnC/nEwuID63nLkD2sneNjmvgkNX8pgnsG1pVT07LmTJHu8D3bX3/flMJnSXf65AJ9aO7CK/WhzgyJU87ujw+zDoEK/fjvwZqFWsmtXjlivXmxaD/+3m0qhV9PX7/0YsA7WKzyaFymq/S8mvoLZei6uNKT6/jhdqJcgvryUqvYSE6xWcSCrgue0xTFh2hrC3DhH4ys/MXRvR5r7TCqswaGG0qS3KaupbHX3KK6vFsIXMG0mSWh2bqahppFYwuLKyrpGCCrEQTa0kcTVfLAfCw8aUGIEgXoDefnakF8nLCWmiv78DOSXyR65Al3tzPCFfyOU0qqsbZ68Wkicw7jU6xJ2U/Aqh4OJ7OrtS16AVEp3uDHLCydJYSDjq42dPmI8tXx1Nlr1tiKcNI7u48o5MUQGgg4sVgwMceeGHONmCVTtHCxYND2Tp8RTZY2qedma8O7Yzz22PkRXoC+BsZcLnk0N5Y89l4rLkvcYOFsYsn9mdr48my3Zy2JgZsXp2D3ZEZcluL7IyMeTrqd04ePk67/0cL2tbC2MD1szqSXZJNe/9GC/rdTI10rByppiAY2KoYen0MHwczJm47Izwe3Hp9DBe3BHLagFnWRNDOjixaV5vlh6/ymu7L8m+VhUU/sko4o2CAro//pfsj+fTQ4lsmNuLIc0syG6FtMJKxi89Qy9fez6eECI7u+NKTilTlp9lTj8f2W6Ogopapq44R4iXDa+N6ihLQKltaGTB+vNYmhjw0YSuskQQSZJ4fc8l0gqrWDo9TLaQsfFcGntjclg+o7usOnGAs1cL+eRgEl9PC5PtnMgoruT1PZd4/4EuzbY8tUZ1XSNPbbvIwsF+t7wgb0KSJF7eGcfILm70aff7Ma3kvApWnLzK22M6yRajymvq+fBAIi/e00F2RpMkSXy4P4GHBrW7pbGe/2bp8RTuD3G/ZWfJzWyLzKCzu7XsnCOAE78GcA5oLz8XKL2oksq6BiG3Xl2DlrjssmY/K3r42N3IvTFQq/h4QldZI3mXsktJL6rCu5nsmWFBzqjQjQrN6uvD8I7yHntKfuWNsOKJPTybrR9v0EpU1TXeyImRJKnFgOObKaysE3I/ge491ZrQ3aDVtvh+aCvzxshALey8sTMzFK4L97A1I1O0ccrFUmhsCiDI1YrjCflCC54evnacTC6Q7eoACHa1oo+fPeeuyq8bd7E2oYePHT/Gyh+dsjA2EA4uNtSomdXXh5Unr8retql5aunxFNnuG4Bnh3dg/dk02aG6AM+O6MDJpALZtdagc4qWVNUJjV7N6O1Nbb1WSDga2cWN4R2d+XB/guxrs6+fA4/e4c+CDecplRkg3tHNmvfHdeHJrdGyW6S87c1ZPiOMd3+K50i8PPHHycqEdXN6sf18Jt+ekOf8sTYzZP3cXhxPyue57TGy3Ds3CzjP74iRJeAYatR8PimUrp42jF92RujaHBTgyMZ5vfn8cBJL9scLO2e6etrww8K+nEop5KH1kbLzpRQU/qko4o3Cv56GRi3Pfh/Dzqhsvn+4r+zskiYSr5czfukZ7u7kwjv3y194X8ouZfLyczxxZwCP3iFPuCmpqmPainN0dLPmFZkZPY1aiae3XaSspp5l07vLXvSvPHmNH2NzWTWrh+xF/9mrhby19wpLp4XJrk/PLavmqa3RvHRvECEya8zrG7X8Z3M093V14+7O8l0X7/8cj625EXP6y3eZ7L6YTVxWWbNZNpIk8crOOCb18BISMr4+loKfo7nsBT3AgcvXySqpkV2TDjon0e6L2SwYLC9fCXTX39ozqUJOIdA1VM3s6yPbOQWwLyYXD1uz34w93SqRqUXUN2oJbiavqIuHDVoJVMAzdwVwX4i8LJ4LaSV087JpVoAdEOCIBDhbGvP83fLbzW6uCR/V1a1NW75KBa7Wpjx9V2Cb+y6sqBUaPwOoaWg786alz1S1SoW2ladhrEfmjY2ZkezRlibcbUzJFMi8gf9vnJKzaGuivZMlEpCUJ1/8MTc2IMTTRmh0SqVS4W5jyn6Z9c5NjAvzYIdAgxPA5B5eJOSWUS4QejyppxeXs8uERs3uCnbG1syI7yLljfQABLtZcW9nVz4+mCh7W0dLY/4ztD2v77kku3bcxFDDO/d3Zsn+BNkuGI1GzQfjurA7OpvjAtkmr47sSHRmCV8LOI4eHuRHoLMl7/0sbxQJdMLRzL4+zFsXKVv8CfO244NxXXh8c7Rs54+vgzlrZvfki8PJbJeZreRgYczGub2ISC3itT2XZIkgTQJOVW0js2Vm4GjUKj54oAsD2zsydcU5rhXIdw+GeNrw3YK+7IzK5oUdsbKv0SY87czYvqAvFbUNTFx2VsgNpKDwT0MRbxT+1VTVNjB//Xlis0rZsbDvjUWNXGIzS3ln3xWm9PLixXuCZI8NxWWVMnXFOeYPbMdMmYvYspp6ZqwKx9veTNg1czm7jNWzemAh0/nyc1wOnxxMZNWs7rLFl4yiKhZuOM+ro4Lp6Wsna9v6Ri2Pboziro4uTO0lP1j300OJVNQ28Mzwthek/83p5AK+i8zgo/HyzjXoQpnf2HOZ1+/r2GyF/a7obFLyK3j6LvnZPRlFVaw+dY1XRsqvBm/USnx0IIHH7vC/5eyUm1lzKpW7gp1lje80cfjKddo5mHNXsPx68MKKWraEZ3BPJ7Gxp32x2dwrIN6BLlB6SKBTs+e6SdDp4WPLQzIDwwGiMopbFJGbBNKvp3YTEqyuFvx/TbiHrRmBbTjHNCoVX03pdkuiblFlHQ56tE217rxpTbyh9bYpQ7GqcNCF+BYJO2/EAosBfOzNadBqyRJw7mjUKjq7WwuFFgP09XfgVLL80GKAYcEuHLpyXUh0GhrsTHxuudCoWRdPG+oatey5mCN7W2tTQ+YO8GVXlPycDrVaxWN3tOfrYylCAuGTwwLYF5PDlRx5VdoAM/r40KiVhBw0/fwduKujM6/ukicKgG5B/dK9QTz3fYzscFsLEwM+nxTK18dSOJ8mz6GlVqv4aEJXTicX8s1xeU4WgKeGBeDvZMlru+ULXiO7uLFwiB8Pro2Q3SDX2cOapdPDeHlnHEfj5QV6O1uZsHFuLw79On4lV8D5cko3DA1UsgUctVrFG6M7Mj7MgwnLzgq5AP2dLPj+4T5cSC9m4cbz1Ag6Z6zNDFk3pxftnSy4/+vTwo5EBYV/Cop4o/CvpbiyjumrwrE1M2TrQ31wtjIR2k9EahFTVpyln789TwyV1woF/y/cLBjkx8LB/rK2raprYM7qCOzMjfh8cqjsMa3PDiex/1Iu6x7sKXvcITqjhKe2XeSzSaF08bCRtW1FbQPz1kUyrY83kwVajd77KZ6K2gaeGyEv1wd04svqU6l8OUV+HlFZTT2Lvo/h+bs74CMgVLy17wqhXjbc0/n3zpjSqnre2neZV0cFYylQs/3eT/GM6uIm5Nj5OS6HugYtk3rKz43JL69lS0QGjwyRd+02sfpUKr397IWEiJ3R2YR42Qi9FqkFlSTmVggHnB+Jz2NIB8dmb0svqsLYQM3aOT2FAs91zpvmxZvL2WU4WRrTzVue4Ak6sfZm5w3AxO4emBg2f+6NDdQ8NMiPzh5tX1OSJFFYUSfuvGmlbUqrlZAkWszTUatUtLamMTbQCIs3tuZ6OG9sTcktqxH61tnIQI2vgzkJuWILlRAvG6IFxZt+fvacTikUGnfo1c6OqrpGYmU6FEAnogzp4MguweDiKT292RQuX8gAeKCbJxvPpQuNidzdyYVuXrZCriFPOzOm9fbmA5m5KKC7RhaP6sjHBxMpFKh3f/neYM6nFQk5pSb18CTQxZI39shvkOrkbs3TdwXw+OZo2eKPjZkRX03txpdHkmWPjKnVKj6Z2JXEvHLe/Un++X54kB9DAp14cmu0bIdXP38HlozvwqObLnBBZg22h60ZG+b2Yvv5LL44Is+xZGqkYcWMHkICjkql4pEh/kzr5c3EZWeEMqVcrU3Z9lAfLE0MmbE6Qvbr3YSRgZqPJnRlXJgHb+29LDQuqKDwT0ERbxT+lWSVVDNu6WmcLI15+/7OQhkfAL8k5TNrVTgv3B3EvIHyv2GPzdQJN48M8ZNd6V1T38jctZEYanT1knLHnTaHp7P6VCrrH+wlO/MlrbCSB9dEsHhUMENlOia0WomntkZjb2HE4zLHw0AXMLstMoOl08IwNZL3nAsranni11GrAGdL2cd+c89l2jmaM623t+xtf0nKZ/+lXN4Y3XwY9JID8QS5Wgk5QSJTi0i8XsYiASdRfaOW939O4JEh/rKvIYBVp67Rw8e22brztojPLeNCejGTesgX8CRJ4rvIDOGg4n2xOQxo79CsA6ot0gurSC+qop9/8zk2p5ILGNDeAVMBF1N2STV55TV0aUEwic0qpbOAQAc6Z0xpdf1vHFL3dnG7kW1zMyp0Yz+32sJWUdtAXaNWPPOmvhGTFt7PDb+6OFrOvGndeWOkUVMrkEkCYGtmSLHMMYsmXH79QiBX0Orf3tmSRIHRJ4BQPRqnQr1sqaxtIClPvgPGUKNmSKATh66It07tis4SEo7uC3HjWn6l0CLTy96MO4OcWHMqVfa2arWKuzo68+WRlGbfS23xyGA/8sprhSraBwY40tPXns8Oya//tjM34uV7g1m8+xJlMsUIlUrF+w904eDlXKGw5zn9fPF3suClH2Jlv9ad3K1ZPCqYxzdHkVsq771l+WuQ8PfnM2VXxKtUKt4c0wlbcyMe3RQl5N557u4OzF8XSbJM90g7Rws2zu3FqlPXWPGLvHwmfQWc/wxtz8OD/Ziy4iyRqfLzrGzMjHhrTGcsjA2Eg5CbHsuTwwK4r6sbc9dGyn79FBT+KSjijcK/jvjcMsZ+fYo+fvZC7osm9l/KZf6687wztjNTBEZ3YjJLmLriLI8O8We+TOGnrkHLE1uiqG3QsmJmd9nPYW9MNp8cTGTlzO6yRYySqjpmr45gTKg7EwUW3Z8cSiThejlfTZE/9pGcV87z22P5aHxX2W4LSZJY9H0MYd62TBFw+xy8fJ2fL+XywTj5bVrVtQ28uiuOZ0cENhvoG51RwpWcct5sQdhpDa1W4vU9l7kvxB0nAffYtsgMDDQq7g+Vl8sCUFpdz4YzacKum7WnUxkT4i7k1ojJLCWzuLpZF9OtsDcmh3sFW6aOJuTRw8euRYfUyeQC+rcg7LTFhfRiOrhYtRjeHZdVKuSuAl1YsYuVyW/27Whp3KzLR6NW8eWUbrccQF5YUYehRoWViXzBClp33jSFmxq0knnT2vLP2FBNnWDmgp2ZkXBgsYFGjYuViXDuTeCvuTcihHjakphXLrsVCHTfcvfwtRP+dntosHhl+JAOThRW1HFRQICxMDbgvhB3YffN3AHt2BKRIZSbM7KLG8aGan6Ikr+gtLMw5p7OrrLHYpp4ZWQQe2NzZOexAIzt5o6/k4VQBo2LtQmv3deRF3bEClWefzi+K2evFvGdwCJ8Yg9PhnRw4tFN8uq0QRdC/NWUbryyM062C8ZQo+b9B7qQW1rD4t3yR85m9PFh3oB2TF8VLjtvKNDFkvVzevHZ4SS+Oy8vY0kfAQdg/kA/nh3RgZmrwoU+F0yNNCybHkawmxUPLD3NtQKxNjyAcd09WTGzO6/vucQnBxP1qhJXUPg7oog3Cv8qzl0tZMLSM0zt5c2bo+WHCjfxQ1QmT26N5rNJIYyWGUYKEJtZwrQV53j8zvbMGygv9LahUcvjm6OQJFg9u4fshqaTSQUs+i6G9x/oQncfeaMXNfWNzF93nvbOFs0G7rbFnovZrDmVyooZ3bExk7dgr6ht4KH155nex5u7BAJ5V51KJSG3nPfGyhdfCitqeWPPJV6/ryOu1vLblD49nER7Z0um9fq9Y6ehUctLP8QysL2j0PjPD1FZFFXWCVV019Q38sXhZJ4eFig0trThbBpBblayryPQjS3+EJUlHFS8LTKDUV1dhTJ6UvIrSMmvYJhAzg7oxJvmKsJBd07DrxXRX6D9CiAqvYRu3jYt3q6P8+ZqfkWzrVETenhietPolLGBmkfv8CfY7dbdVMVVdQS5WAmNiYEunNPSuHnxpr5RS4inDS21kBsbqHG3aVm4dLEyaVH4aQsbMyNsBJ2ZAB62JmQJjOIABDhbCI9NuVib4GxpQkxmidD2ff3shXNvBgc6kpJfIdRYZWKoYUQnF3YK5M8ATOnpxa7obCHRKszblvbOFmyNkB8+rFGreOwOf748mixbTACY3c+HnJJqfo6TP8LkbW/O5J6eQmKCSqXinTGdWX8mjfNp8oQMgPtD3enmZcPnh+U7fxwtjfl4Qlde332JFJk5RyqVijdHd6KitoH3BEag+rd3YNHwQB5af162e8fKxJBVs3tw4PJ1lst0wQDMH9iOwYFOzFwVTolMYbizhzVrZ/fk9d2XZY/p3SzgPLU1WraAM723N6+P7sS8dZGym7dAJ3x9OK4rd3dyZdw3p4XExib6+Tuw/eG+fH8+k6e3XRRyvCko/F1RxBuFfw0/x+Uye00EL9wTxON3thdeZGw4m8bLP8Tx7fTuQiJCVHoxU1ec44V7gpgrc8HdqJV45ruLXCuo5L0HumAlMxvlYkYJCzac5+37O8muQ9dqdc6VukYtn04MlS18xWaW8tz2GD6bHEJ7mW4fSZJ4bnsMzlYmPD1MfpjvpaxSvj6WzOeTQ2SPyTRVe/f0tRNyp8RllbL2TCrP3BXYbAvY+rNpVNc1smCwfPGlqq6BD/bH89zdHYQcZBvOpmFnbsTdneRfx9V1jaw8eU3YdbM1MoMQTxuhcavqukZ2R2czXnBk6seYHAYFOAplC1XXNXImpZDBgc2/f86nFmFrZiQcfl5UWUuPFsSwytp6HCyM6OQu/5wBZBRXNTuONbyjC3WN/7/o87Iz41GZr2tBRR31AiG1TSReL29RQNRKEtEZJS1mejVqJdKKWv4Wu6qukaJKsdEnO3MjLmaWCi3IATztzMksFhsTCHC2RKVCqPIbYFiwM8mCzp1+fg5EpBbSILAosjIxpHc7ew4Ium/GhLqzNyZHKCuos4c1fo4W7IoWE3/m9m/H6lOpQsce1cUNjUollNljZmTAE0MDWLI/QehaWzjYn6ziaqFjezuYs3CIPy/uiJW9CFapVLxzf2d2Xcxmb4z8Yw8McGRKLy8+OZgoO/DZ1EjD0mlhbIvM4MdY+UHVs/v5MDjAkYfWR8quene3MWXVzB58diiJn2QeW6VS8daYTrRzNGfOmgiq6+Qdu5u3Lct+DUCWe+wmAUejVjFrdbhsAWdcmAdLxnXlkY0XOCCQlaRWq3jxniDmD2zH5G/P6pVdE+BsyQ+P9CUpr4KZq8Jlt4gpKPxdUcQbhX8F35/P4Klt0Xw6MUQoILeJb0+k8GNMDmvn9BT6Zv1CejEzVoXz5LAA2Y9DkiRe+iGWmMxSNsztJbveOCW/gtlrInhiaHvGdvOQtS3ARwcTiM4oZsXM7rKzZvLKa5i/PpLH72zPHR3kux22RKQTl1XK55NDZTtEKmobeHRzFHP7+xImEPK6Kzqb8GtFQi1iDY1ant8Rw/wB7ZodT7teVsPHBxJ5c0wnobyZpcev4m5jyiiB8Z+K2ga+PpbCouHNi0ptsSUiHVdrEwYKvA8aGrWsP5PGrL6+srcF+PlSDs7WJoTKrIhv4uzVQkYKjkydvVrAoABH/JpxsACcTClkRCdnIXG4tqGRfTG5LQaAX8kp140+Cbi/ABJyy3Gy/L1DxdrU8MaYl1oFXwk0WRVW1GIvGFYMUNugbXFsqu3MG1WrjgMjvarCdQJfieDCwM3GVCgEF3SOiqS8CtIKxUYMPGxNOSm4OAp2tcTC2JDYbLFvx+/t7EpirvwGJYDe7exRq+C0QAYMwOSeXmwOTxfadnhHZ1Qq+FlgYWqgUfPIEH++PJIkJP5M6K77vbxNoHbc3NiAF+7pwLs/XZG9IAedGwQQcpI4WBrz1phOvLIzjrxy+ULlM3cFklZYyZKfE2Rv6+NgzpJxXVl7OlXIvfPW/ToH9gs75GfvdPaw5tNJoTz93UWiZI5fadQqPpuk+3vmEYHRr37+DnwxOZSntl2U3WBlaqThowkhGBtohASce7u4snR6GE9sjZZdf97EQ4P8WHxfR+aujRQSgZpwsjRh60O9MTfW8MDS02QUiY9jKSj8XVDEG4V/NJIk8cnBRD7cn8i6OT2FnDJN+/n4QAJLj1/lxXuDhMZEzqcVM3NlOM/cFcjsfvIWrbpK78ucSilg47xeOFrKCwXNLa1hxspwJvbwlO32AV248Yaz6aye1RMHmYGktQ2NvP9TPL197XhI5ogY6Nq83thzhY8ndJV9bIBXd8XhbGUsO1cIdOft1V1xvDO2s1AQ66pT16iqa2RhCy6GN/ZeZkgHpxaDb1sju6Sa5Seu8uqojkJCwaqT12jnYM7gwOYbk1qjrkHLtyeu8sgQf6FjH/w1zHRokDz3VxOnkguZ2cdb6NhJ18uJTCvmTpnOsyYOx+fham3S4rFPJhUQ4tl8U1RbXMouw8LEAB/75gPEY7NK6SRjlOm/uZpfiZ9T846gptdibn9foTDvwso67AVrwkHnaDJuM/OmpbapNqrCDcSrwk0MNZgbaYRzbzxsTYXqvkG3wPNztCBROPdGF1oskgmh0ajp7G4tLKAMCHBk+4Us2WMhoHvek3p4Crtn7gtxQ41KaGTMQKNmdj9flv9yTei8jQl1p1GS2CPgQjHQqHl2RCCfHkqiSqBW+b6ubnjamvGVQH6NoUbNuw905ssjyUJ5JPd0dqV/e0de3BEn+7wZG2r4fHI3NoencyxBnhABMKKTC109bVi44YLs82ZsoGHp9DCyS6pZdeqa7GMPC3Zm0fBA5q6NlD0maGKoYfmM7mSXVPP8dvni0Z1BziwZ34VHNl3gtEyR1tRId+wmAUfumOGgACeWz+jOq7viWC9QVQ86F8/Sad14cmu08D5A51pbNr0793Z2Zew3Z7goGNSuoPB3QRFvFP6xNGolXvwhjm2RGax7sKeQ4AI64eTNvVfYGpnB1vm9hcJCz6cVMWtVOItGBDKzr4/s47//cwL7L+WyaW5v2ZkrJVV1zFh1jv7+Djwr0EZ0LCGPXdFZfDs9DP8WFn4tIUkSL+6IIzmvgnfHdpa92M4rr+GRjRd4/u4OQq6ZH6IyORqfJzTmJUkSz26PYWiwM8MFRL/0wio+PZTEe2O7NDvSdCIxnxOJ+bw8Un52EMAHP8czopMLIQLuk+LKOpafuMqi4YFCAshPcTk4WRoLnReAtafTmD/QVyhnJ72wil3RWYzoJOac2RuTwx0dnLAQGJmSJImj8fktjhwWV9ZxKbuUvv72Qo/tQloxoZ42Lb4m+uTd1DdqSS+qol0LuUpBrlZoVPDc3WLXoz414aBrm2orsLilt7BapULbijZjbKChtl48E8HW3IgiwbpwDxtT4cBigEBnC5JkNtM00dnDmsLKOnJkZno00c/fXniswd3GlEAXS44KLMYBhgW78HNcruxxFtAFF3fysBZ230zs4YmFsYbIVPkZMIYaNY8O8WfFL9eExt2Gd3TRjeSclC8kqFQqXruvI6tOXSNVQIDp5mXLhO4eQg1QAG/c15GLmSXsuCBfdPN1MOe1+zryzHcXhdw7zw4PxNrMkJd+kC8eOVma8NK9QXx0IFFIPJrdz5dxYR68tDNW9uiOtakh6+b05Ny1Qt796YrsY4/s4sYbozsxf/15zqfJa4IyNdKwYqZOwJktIOD083dg7ZyefPBzPMtPyHdsAQwKdGLdgz35cH+CXuHDGrWKJ4a2Z8EgP6YsP6uXm0dB4XZHEW8U/pHU1Dfy8IbzRKQWsf3hvkLfJINu0fD89lgOXM7lu4f6ys5qAV2N88xVETx7dwdm9PGRvf0Xh5P4/nwmG+f2wtNOXqV3dV0jT227SFdPG96+X36T0eXsMh7bFMXknl70aid/Qbry5DVOJufz7YzumMgMlm1o1PLYpij6+Nkzo4/8au7Ugkpe2XmJD8d3xcVafgvTxnPpJF0vZ/GojrK3lSSJl3bGMibUnZ6+vxedauobeWVXHIuGBzY7xtIWUenF7L90nWdHyBfjANafTeWezi5Cr2mjVuKzQ0lM7eUlFPh9ObuM6IxioaBv0I1ADgl0ku0+A93rsi9WvGUqKa+Cwspaerdw3k6nFBLgbCn0mkJTWHHLrh19mqbSi6rQqFW4N9N2BrrMmg6uVsIh7kWVtULOuCZq6htbHMds1EoYqFUtfn6p1W04b/RomwKwNTMScpAAeNiakVNaLZxb097ZkgRB8cbMyIAAZ0ui0kuEtu/r70BkWrGQgAI6V4Jo61QndyucrU2EK8ebgotFmqMsjA3o6GbNSgEBBXR151qt7rNGLiqViufv7sCR+HwKBESMTu7WjO3mwVv7LsveFuCZ4YFcza9ku4AAY2tuxHtjO/PankvklMoXLMeFedDXz4Gnt11EK/P9YqBR8+XkUH5JKmDjOfmiXRcPG94d25nHNkfJHr8CeHZEB4w0ahZsOC87N8jJyoT1D/YiIbdCdg046M7bcyMCmbU6gktZJbK2NTHUT8Dp7mPHprm9+fpYMp8eEhNfwrzt2PZQH7ZEpPPKrjjhz0qVSsWD/X35aEJXntgazWoBJ5WCwt8BRbxR+MdRVl3PjJXhFFbW8f2CPs1WM98K9Y1a/rMlisi0Ir5f0BevFkYZWiMytYhZqyN44Z4OTO8tX4D49kQK564VsXFuL9rJDECtb9SycON5KmsbeHN0J9kuh9zSGuasiWDBYD+hhfaxhDw+PpjIt9O74yxQYb1kfwLFVXVCjp26Bi2Pb4lifHcP7gySn7GTVljJuz9eYcm4rlgLNM38EJVFQm45z9/dodnb155JxdrUkKnNtE+1hSRJvPvjFZ6+K0Co+SqvrIZvjl1lqsD1CLrg79oGLfcL5CaBrh78/lAP2W1joFvEf38+kwmCQcWJ1yvIKq5usSmqLY7G59HPz6HFcOiTyflCI3BNXEgvbjHHp6qugeS8Cjo3Ezh8K1zNr8TXwbzFfKPM4io8beV/xjVRWCnuvNFqJWobtJgYNv8Z1aCVWhWVdJk3Le/f2EBNraAAAU3OG7HMGxdrExq0kpCbAPSrC4em0Sn5DhKAdg7m2JkZCbUQAQwNcuZ4Qr5Q3pBKpWJ0V3ehAF7QiRj+Thbsvii2/cy+PhyJzxPKGzI21DCtjzdfHE6SLUKALvPHxsyQr4+JuRmeuSuQukatkIvE0sSQ10d35K19lykor5W9/Z1Bzozo6MKz38cINV+9dX8nrhVUCglnTlYmfDkllLf3XREamRsd4s6UXl7MWxdJmUzRrynDpry2Xig/x9fBnGfu0o3MidTNT+/jw6LhgcxeE0miTLH3ZgFn4YYLsgWczh7WbJnfhw1n03nvJ7G6+0AXS7Y/3JfTKYU8vjlKOKMMYEQnVzbO7cWXR5L5+KD8HCUFhdsdRbxR+Mfx8IbzWJkasnFuL6EFIui+BV6w/jxX8yvZ+lAfIefGuauFPLg2ktdHdxRapK8/k8oXR5J54Z4gAl3kOX60Wolnv48ht6yW5TO7y24iqqhtYPaaCAYFOLJwsPysmJT8Ch7bHMW7YzvTVWCs5+e4HDadS2fptDChKugl++NpaJRaFE9ao1Gra5caF+YhFEpdWFHLypPXeGtMp2bbwK7mV/DJwUTevl+sqn5PTA5pRVVM6SUWvP3l0WQGBTi2GIrbGpIk8dXRZOYPbNdi809rFFXWsTM6i1kyRwebOJlcQL1WEsrpAdgbk80dQU5C1xToKsIHtyL8nEwuEK4Izymt5npZTYvvlys5ZdiZG+EiIISC7j3ZXE14E+lFVXjaiQndoBubEg0srvn1D/WWx6a0rVZ9q1WqNjJvNMKZNwB2ZobCmTdGBmpcrEzIEhydCnC25GpBhXDbVaiXLvdGBJVKRV9/e06niI1OdXSzwsbMiDOCuTmjQ9w4npAv7Hqa3NOLTefShRaT7jamDO/kwupTqULHHhfmQUVtAz8JVH8DPDsikI3n0oTq1u3Mjbgj0Ik39lwWqlAe3tGF0V3deOdH+WM8AK+MCib5ejnbZVZZg66p7PPJoXx0MIHYTPlh2b3b2fOfoe15eMMFigVGHZ8d3gFvOzMe3xwl2wFibmzAqpk9OJNSwBdH5OcOdfawZum0MF7cESc0bjijjw+Te3oxdcU52WNzTQKOvYUhs1bJd+AEuljy3YI+7LmYzaeHxERLD1szvl/Ql8ziKuasiZD9GG4m1MuWHxb24+xVeaNkCgp/BxTxRuEfR0d3a5ZO6yZUnQxQWdvAgg3nMTFUs3l+b6FRgLNXC5mzJoIX7u7AAwIOhW2RGbz/cwJrZveUPSYhSRJv/3iF82nFrJ3TQ3adeH2jlkc2XsDBwoi3BEatSqvqmbc2kmm9vYUcOyn5FSz6LoYl47vIdhsB/JKYz56LOXwxJVSowWnFL1eprG3gOQHhB+DNvZdxtzFtNhxbkiRe3XWJid096exuI3vfNfWNvPfjFZ4b0UFIgMgoqmJrRAZP3yW/bh3gWGI+eeU1TOwh5nzZEpFOmLetbDGyiW2RGYzt5i6UlSNJEvtichjZWWxkqqymnsjUYoa0IBylFVaSW1pDr2bG5G6FqPQSAl2sMDdu/nWNzdSNTIlkFIFONGzn0PL7KaOoSvZY5s0UVtYKBxY3VeW29JndlvPm1gKLxb/JtTEzEloINuGuR+6Nh60pBmq1UIYJQKinDbFZ4lXn/fwcOJUsJr6oVCqGBjkJj075OJgT5GYlLIDc19WN1IJKYrPEGrPmDfBlW2SGUAWxsYGGhwf78cURsYVsBxcrRnZx46MDYs6Bab29MdCoWHNabHTk4cH+HLh8nV+S8mVva2ViyEcTQli86xLphfLFp25etjz6a2uXSHPWQwPbEexmxZPbomWfe41axWeTQ0kvquKD/fGyj+1kZcKq2T1YfuIqO6Pkj571b+/AB+O68OjGC7IbrACeGNqeMSFuTF1xTnbLnYmhhnfHdsHUSCMk4Pg6mPPdgj7sjMpi0fcxQo1rduZGbJrXG7VKxQvbYyiokO/+asLL3ozlM8KEt1dQuF1RxBuFfxwv3N1BaHEHOuFh2spz1DVo+UBwZOZMSiEProlg8aiOTBKoJd8VncVruy+xfEZ3wlrJv2iJpcevsis6m/UP9pSdvaETF+K4XlbDV1O7yXZXNDRqeXTzhRsWYLlU1TXw4f4EpvX2EgqkzSur4Ymt0TxzVwB+AsJPQm45nx5K4uWRwULiyPHEfA5fyeON0Z2avX33xWwSrpfztEBwNOiEJQdLY8YI5sV8djiJezu7CmU3AXx9NJk5/X2FhNH/rwf3ETp2cWUdBy9dFx6ZupxTRm5ZTYthw21xMqmAdo7meLQwWnQyuYBuXrbCrp7ojBK6edm0eHtqYRVdBEemQOcoa000MzXS4NtCmHFbSJKEh60Z9uZimTc19VqCXa0w0jQv0DRqpVbD0jVqVasjhGZGGmEXJqCXIwl0i1FR94harWJggANXBcUbP0cLjA3UwrXdff3tic0qlT1G0sTQYGcOXbkuJGAAjAlxE1oEg84JMTrUnU0CGSigy0Hp5GbN5gix7Sd096S4qo4DguLVU3cF8FNcLnEC4pOBRs1rozry+eFkoZE9F2sTnh0RyEs/xN0QV+XQ19+B+7u588z38vNrAB4e5EdpTT2Ld1+Sva1KpeLD8V3RqFQsPZ4ie3srE0OWz+jOpnPpQo1nHVys+GpqN17YEcu5q/KFz1Fd3X4dgYogOU/eCJRKpeLFe4IYHOjItBXnyCuT99o3NWCJCjjutmZsW9CHmMwS/rMlWsj5ZW5swMqZPdCo1Yz75rSQ+6wJa1Pxz30FhdsVRbxR+Mch+s10QUUtk5efxd7ciFWzerT4DXhrnE4pYO7aCBbf15EJAu6En+NyeX57LN9MC6OPn/ww2a0R6Xx9LJm1c3rgbS9/Ibb6VCpH4vNYNUu+Ywfg3R+vYGViyKeTQoTanV7YEUtRZR1PCwg/Wq3EU9su0r+9Aw+EyXc71TVoeWpbNLP7+dDNS75oVlXXwEs/xPLc3R2aHbMrq6nnrX1XePneIKFze72shm+OpfDqyOAWc0taIzmvnD0Xs3liqJjrJvxaEfG55UwTzMrZf+k6GrVKKIMIdKJmFw9rIVFOd/xchgY5CzvyYjNLGdXFrcXbr+SUMaKTWPsWwPnU4lbF2rNXCwl2FRdvjibk49WCs0aSJA5fyRPKUAIoq2ngfFoxdqLOm/pGrhVUom6hCryhUSK9qHXnSmvfMmvUKiEHQBNGBhqhENMmDA1UwqHDABbGhlzKFhNf1GoVXT1ticoQc5+4WpsyLMiZ8Gti4we9fO1xtjIhLlvs+Pd2ceV8WjFZMl0ETUzp6cXui2LBxQAPDvBlzalUIeeSiaGGBYP8+PxwkvDo1ow+3nywX8x909ffgYEBDnzws9j2U3t5Y29hxOdHkoS2f+HuIHJLa1h9OlX2thqNmk8nhnLoynUhAcXa1JCn7grgiyPJQu4hP0cLvprSjSX7E4TycwYGOPLqqGAe3xJFSr789/6sfr5M6+XNjJXhssOfVSoVb47uRDcvW6atPCe7KU9fAcfZyoQt83uTWljJwxvOCwWeGxmo+XhCVwYHOjH2m9NcyRH7/FNQ+CeiiDcKCujyJiYuO0M7R3O+mRYmtMA7nVzAvLWRvHZfRyF3wLGEPJ7cGs1nk0IYFCA/0+Pg5Vw+P5zM8hnd6egmf5G352I2Xx5NZvWsHkIhz9siMtgelcWzIwKxFBAn1p1J40xKIV9MCRVyTi07cZWM4ireGiN/1AvgyyNJNGol/jO0vextAT4+kIirtQlTWnBbfbQ/gQBnC+7r2rIA0Bof7k9gcAcn4cr7jw8mMr67h1DwNsBXR5OZ2cdHSHgC+O58BjP6eAu3GYWnFjFVMOdHkiR2RWUzSvDca7US353PoEcLI1GNWok9F3MIFRD9AGobGonNKm2x9r2mvpEkPcKKS6rqKKqsazHzJr+8ltoGLR62YuJNUWUdRho1lgKCN7TeNAXQKEm3kHnT8v6NDTV6tk0ZUiwwOtOEh62ZXnXhAXrUhQN0drcSzr0BcLA04mSSWO6NkYEab3tz4dEpJ0sTRoe4szdGfnMT6IKL+/nZs1+wOlgn+KrZGyMWfDy5pxd55bUcuiJWmb5wsD9R6cXCle0v3hPEvpgcoREcjVrFu2M7s/rUNaHFs7mxAUvGdeHD/QlC4qeLtQkfPNCFl3+IE3JfdHSz5vXRHfnPlmiyS+S//wYGODK9tzfz152X7WAB3Ws/tZcXc9ZEUigw/vP0XQEMaO/AW3uvyHbuqdUqPhjXBX8nC2asOkdptbzPL30FHHsLYzbN601xVR0Pro2gqk7++JtarWLxqGBm9fVhwrIzQi4mBYV/Iop4o/CvJ72wivFLz9Dd247PJoUKBbGeTi5g3rpI3hjdifECws3plAKW/3KVD8Z1aTYrpS3OXi3k8c3RLB4V3GKNcWtEpBbx7PcxfDShK8ECwk9kahGLd1/i6yndhBw/59OKee+neL6a2k24Ovvzw0l8PilUSDi6mFHCt79c5ZOJIUI5ORczSthwLo13x3Zu1hUTk1nC1sgM3hwtJizFZZWyJyab50eI5fBcyirl8JXrPHaHmDAVl1VKg1bL7H4+wttHphYLjzzFZZVyLCGfYQLvDd32ZRRW1jFAMEw4LruU2gZti86YuKxSJEmis2CN9+XsMsyNWx5bupxThrWpIW4CwekAKfmVOFoat/jeyCiuwsnSWNiVVFhRi525kbDrsaa+scWwYtCJY61n3rQVWKxf5o2dmZFwYDHocmtEA4tBF1ost0HmZkI8bfUSb/r5OQiHFoN+leEAff3s2SnYOgW6BqRVJ1OF3C8atYqFQ/xZfyZNaHud+6Yde2Oyhba3NTfi4cF+vPdTvHAI7EOD2vHa7kvC2Ttz+vnywo5YoQrnXu3smdLLi6e3XRTKQLmrowtjQt15fEuUkPtpQndPhgU588imC0IjPPMHtqOPnz0LNpwX+gx5dEh7OrlZM3+9fAeKSqXirTGdqW/U8uDaSNnjawa/upeCXKx4dNMF2flBNws4c9dEyHavWZsasv7BXmi1MGNluNDopUql4pEh/rx0TxCz10RwQFCEVVD4J6GINwr/ahKvlzNu6WnuCnbhvQc6C7kCTiYV8J8t0bwztrPQuM75tCLmrzvPmBB3IWfApexS5q2L5LX7goWEn6v5FcxbF8nLI4MYEig/DySrpJoFG87zwj0d6CtQk1xQUcsjGy/wzPBAegi4Sspq6nl8SxRPDmsv1GxVU9/IU9uieeyO9gS5Wsnevr5Ry/M7Ynl4kD/+Tr/PFGls1PLijljmD/QTCmCWJIm1Z1KZP6CdcKDskgMJLBzsL1TZDvDNsRTaO1liLxDeDbDmdCqjQ9yEc0e2RWZwb2dXLASdHXtjsxkWLD4ydSQ+j4HtHVsUdk8mF9DXz0HYVXQhvYRQL9sWxY+4rD8irLhlUTWjqLrFkapbobCyTjisGHRjU8Yt1ISDbmzKoIU8HNAFFrddFa6H88bcSPbowc2425iSWVItnPsS4GJJamGVsAAV4mlDSn6FcG5NHz97kvMqhOvOBwU4kpJfIZxdcVdHZ67mVwgLWKO6upFeVEWMQHsRwMgurqTkV3JOcHRsSi8vTiYVcCxB/vgOwOy+vtiZG7EvVsx99NBAP0qr69kj6B56/M72FFfVseFsmtD2i4YHUlZTz7e/iFWfv3RvEFW1jXx6KFFo+9dHd6S2XivUnqVS6dxHDVqJl3+Iky3AqdUqPprQFUmSePo7+fk/hgZqPp8cikal4tFNF2QLWEYGat4c04mGRol56yJlC0hNAo6XvRmzVstvgDI3NmD17B5Ymhjw0o5Y4eD3ST29+GRiCE9sjWarYAaVgsI/BUW8UfjXEpdVysINF5je25tXRgYJLYx+Scpn/vpIXry3g1CzUmxmKbNWR/Dc3R2EHDtphZXMXBXBw4P9mNhD/khJYUUts9dEMKmHl1CdeVVdA/PWRnJXRxemC2ShNDRqeXxzFGE+tswRcHVIksRLP8Th62DB3P7tZG8P8MnBBKxMDXlooNj2606n4m5jwsMtVKpvDE/HycpEqHIddDlIR+PzmT9IbPuI1CIiU4uZ3sdHaPuU/AoOXrnOfMHzU1BRy+6L2cJBxTX1jeyMyhJuuGpqmbpXsGUKdHkxrQUd/5KUL1wRDnAhvbjVsOLYzFI6u8sXFptIya9sVTjUu2mqok5Y2ANd25Q+zhvVn10Vbm5EeU2DcGOTm40pdQ1aCirFmlPcrE0wNdRwNV8stNjR0hh3G1NiBHNvbMyMCHazEq78tjY1pJevvXBwr6WJIUODnYWyT+DX4OIQNzaHiy36zIwMmNLLixWC4oOZkQHzBrbjM8HsG1MjDXd3cuHDAwlC16CpkYbnRnTgzb1XhAQ8E0MNb4/pxP5LubLzV5q2/2h8Vz47lEi8QHC2iaGGzyeHsupkqpADzMRQw9JpYey4kMmei/IFLBNDDd9O786xxHyh6vgmASQ2s5QlAu1hJoYals/sTlZJNS/siJV9DTXVgNfUN7Jwo3wHkomhhjdGd8LMSMNMgRGqpvOvBSZ9e1ZYBB7e0YVVs3qwLTKDr48mC72XFBT+CSjijcK/ksjUIiYvP8v47h48dmd7IeHmeGI+D60/z7tjO3N/qHzHTXxuGdNXneM/d7YXEj7yymuYvjKcMSFuPCywsK+pb2Tuukg6uVvzrED7kSRJPPPdRSxMDHhtVEehc/jxwUSul9Xw/gNdhLbfFZ3NlexSPhrfVSjE9+zVQvbF5vLR+K5COTupBZV8eCCRhwf7YWTw++3zymtYsj+BmX19hFwfNfWNvPPTFRYNDxBynUiSxJKfE3iwv+6bWxGWHkthTIibUA4SwJbwdHr62Ak3XB24fB0HS2Oh5jWAi5mllFbXMyBATFwpqKglLqu0xRyqqroGLqSV0F/AddZEVFpxqyHZsVmlwiNZoHPe+LWQdwOQXlSFp2DeDUBRZS32gtcX6Jw3rYk3DVptG5k3bVSFG+pbFa4bNysRzL0xMdTgaGksnHujUqnwd7LQc3TKRij3pAldZbi+o1PiIw9jQtzZFS02egS6/BF9gotn9fXhRGIBVwWDq6f39iatsJJfBLODxoV5YKBWsUVQgBrRyYX2ThZ8cVgsfLh/e0dcrE1YvEt++xNAqJct/xkawFNbLwqNLwW6WPLCPR1Y8cs1IRecl70ZH00I4YUdsSTJbHACXf7OsulhLNmfIJT/ZG9hzOrZPdh0Ll1IRLQ2NWTtnJ6cvVrI+wIB1DoHTE+ul9Xw5NZo2SNsTQJUk4Aj931kbKjhs4khdHSzYuKys0IZRAC929nz5ujOrD6dyht7Lwu7GRUU/s4o4o3Cv45fkvKZuSqc50Z04CFBN8OxhDwe3nCe9x7oIuS4ScmvYNqKczzYz5e5A+Q7Gkqr65m5KoLu3ra8eI9815BWK/Hk1mg0KpWw8LHqZCoxmaV8M7Vbs8JFWxy4lMuF9GKWTQ8TEiaS88p56YdYXhkZjKOl/G/9y2vqeea7i8wb0E54nOmlnbGMC/MgzLv5ca+39l5hYICjUAA16MaNLI0NGRcm5jo5kVRAYl45cwf4Cm2fVVLNrovZLBB8n9Q3all/VrweHOC7yAwmdPcUHhnaF5PNXcEuQllGAMcS8unkZtXiNRZ+rQgnK2O8BYOgc0tryC2roUsbYcWd9BFvCipbDCsGXeaNh75jU3qIN7X12tYDi7US6lZe/zYDiw3U1DZohRf+xgYazI00eufe6BtarK94o0/uTV9/B04lFwqfw6HBzkSmFgtXpg8KcKT811YzETq5W9PeyYJdgtk5zlYmjOziyqpT14S2Nzc2YO4AcfeNgUbNsyM68NnhJNnZJaATABffF8y6M2kk54kJUC/fG0xEahE/x4mJcA/290UrSXx5NFlo++m9vTFQq3j2+xihczgs2JlHhvjx5NZooXPYzcuWN8d0YvHuOFIL5Lvg/BwtWDY9jDf2XOZEovwROmcrE9bN6cm2yAwhF1hTBk3i9XKe3R4jW/hoEnDMjQ2YtVp+Bo6BRs2H47vS18+e8UvPkFYo5iQMdrNi+4K+HI3P48ltYnXkCgp/ZxTxRuFfxYFLucxfd5637u8kXHl8NCGPhRsv8P4DXYSag9ILq5i6/BwTunvy6B3+srevqW/kkY0XcLEy5v1xXYSEl48PJlJR28C3M7oLOUJ+jsvhk0OJLJ/RXWhcIrWgkqe/u8i03t7N5sS0RU19I49uimJaH28GCeT0gE5Y8bY3E3I9AXx/PpOUvEqeHdG8a+lkUgFH4vN4dWSw0P7zy2v58kgyr4wMFspSkSSJD/cn8PAgP6EQZ4DlJ64yLMhZSNwC3ciXsYGm1ZGj1sgsruLs1ULGhsoXSEEnUu6LyWFkF31GpvIY3Mo1diq5gAHtHYTFpQvpxQQ4W7YoYF7JKcPKxAB3QedTQ6OW1IKKVivWr5fW4GkrLt7UNWhxshIfm2qUJJxbCSqXJAn3VpxBapUKr1ZuNzZQ4+9oTr0ef+T7O1kICw8AHjam5Ap+2wxNocXideWhXjrxRlR86eFjS155DemCuTXuNqYEulhyNEGsdcnIQM09nV3ZKTg6BTr3zaZz6cLn4MEBvnx/PlM4t2NGH2+S8yo4LTh+dlewM152Zqw8KSYgdXCxYnJPL97Ye1noHNiZG/HyvcEs3h0nNH5lbKDhowld+fZECrEC+UMqlYr3H+hCXFapcP7OvAHtsDA24MUf5I8fgc4BNSzYmXnrIoVcXL3b2fP2/Z345liy0AhZO0cLVs/qwaeHktgrMAJmZ27Exrm9OJ9WzKu75Wf46EbIwoQFHLVaxVtjOnF3JxfGLz0j3KLnZW/Gdwv6kpxXwdx1kUJtVgoKf1cU8UbhX8Ou6Cz+syWaTyaGCI05ARyNv84jGy+wZFxXoXDhnNJq3tp3mbs7u7BoeKDsBV9Do5bHNkdhY2bI11PDhJqx1p9JZeO5NN4c3UlolOZydhlPb7vIh+O7CgX8Vtc1smDDecaHeTKyi1h183s/xWNsqOGZu+SPewEcib/Oj3E5LBkn5jrKL6/lrX1XeHNMp2aFkdqGRl7dFcdTwwKEQ4I/PphIP397+vjJbw8D2H8pl+tlNcwQzLopqKhlS0R6i1k+t8Ka06l61YN/fz6TQQGOOAmew6iMYirrGuknONJU36glu6SaIR1adk7lltYIt1iBzkE2LNi5xdsTcssZFuwiLA5lFldjbWqEu3Xz4kZ9o5aM4mo87cTHptIKq7AxFXfelFbXU9uKjb++UaKgouUFs0oF1wpbFhWMDTUk5VVSp4fFXiuhX2ixrSlpgsIHQAcXS3JLxbIiAIJdrWjnaC7s/jEzMuDeLq7CzheAYUHOetX9jglxY19MjnD2kL7BxR3drOnmZcvGc2LCgaWJIQ/29+UzwdEllUrF83cH8e2Jq0LV0wBPDg0gNrOEw4LV5WO7uePvZMESgdEd0J3DhYP9eWpbtOzwXNCFh38yMYR3fownIVf+wt9AowsAPpNSKCwAPXNXIC7WJjy5NVpobGdsNw96tbNnzuoIoQryrp42fDsjjOe2x3BMQAx1sjJh49xexGaW8vHBRP0EnFXhlFXL+1xUqVS8dG8Qk3p6MfHbs1zKFns/Oloas2V+b+obtExZfk5YVFVQ+LuhiDcK/wq2hKfzwo5Ylk4PY0Qnsbrhw1eus3j3ZT4a35V7Bb7JzyuvYeryc9hbGPHKvfJHnSRJ4sUfYkkrrOStMZ1aHTNoicNXrvPuT/GsmNkdn1baZ1qisKKWeesiWTDIT+g8No0aWZoY8MI9YrXXBy9fZ/v5TL4QrHUvrqzjue2xLB7VUTjH5Y29l+nnb9/ionvZ8auYGmmY0UfM1XMlp4wdFzJ58Z4goe0btRIfHkjksTvbC10nAKtPXaN3O3vhcZ3YrFJySquFgrhB55qJySxlkkAQdxN7Y3IYF+YhNNYHcCGtmIyiKrq42zR7e355Lftic+jTTly8OZ5YgLd9y+/FqPQSvZqcrhZUYGduhEEL5yCnpAaVClxbEHduhYJfq8JF0QUWt9I2pZXayLxpuyocoFZgsdiErnFKLC8FdJXNWXo4b/ydLInLLpVdF9yEqZEBNfVaovQYnfK1t+BIvNiiH3RjK3su5gjnD/XwsaOzu7XQyAnoRpem9fZivx51w3MH+PJ9ZKbwtTSzrw9Xcso4Kyhi9fS1o3c7O744IjZ6ZG1myKLhHXhj72Uh8USlUvH2mM58fz5TWMh7eLAfpkYaPhFsj+rjZ8+D/X15bPMFoefgZGnCl1O68c6P8UI5UAYaNV9MDiUpr4KPD4o9h//c2Z7efvY8uFbMNdLXz4F3H+jCIxsvCD0HD1szPp0UypaIDCExsUnACXSxEnLgqFQqnhoWwPyB7Xh1VxwXBPO4LE0MWT27B67WJoxbepqsYnGBXEHh74Ii3ij841l+4irrzqaxelYP4eyRQ5ev8+imKF64uwN3C7TWFFXWMX1FOCGeNrw9pjNqtfy33gf7EziVXMi6Ob2EKpdjM0t5fHMUS8Z1bTGjpTXqGrQ8vOECoV42QuNeABvPpXMisYAvp3QTEl5ySqtZ9P1F3rq/E16CGSMv74qjq4cND3QTG8U5Gp/H8YQ8XruvY7O3pxZU8vWxZN6+v7NQCLIkSXzwczwz+/q0uqhvjR9js3EwN2KioHBSVlPPwcvXeUzwdQad+HNnB2esTcVGts5cLSQms4RBgWLvWa1W4sfYHAYKvucBjiTkMSjAqUV31umUAjq6WWMrKFzUNWiJzSptvWlK77Di1vNu0ouqcLMxFXZHge7zTR+BqaahsdXxzbbaptRqWv0G3OjX96FejVNmhnpl3rjrmXnjbGWMpbEBKYKBufBr7k16ifD2/fztOZNSKBwSGuxmhY2ZkfDYkFqtIsjNit0C4yJNjOrqxupTqcLBxYMDnLAwNRB+DNamhjx+R3s2Cbp3ABYN78DRhDzSBTNDJvbwxNLEQLg9y8fBnEfv8OfFHbFCeSOGGjUfje/KutNpnE8Tq1//z9D2WBgb8Na+y0Lb9/S146lhATyy8YKQo87GzIgVM7qz9nQqewUq2FUqFe+N7YK5sYbHN0fRKPCeuq+rG88MD2TOmgihHCNfB3M2PNiLtadT+fZEiuztTQw1vDoqGAsTQ6EQY4AFg/wYE+LOjJXhwm12JoYavpzSjSGBTjy4NlJ4FEtB4e+CIt4o/GORJIlPDiby9bFk3h/bhV7txMZPDl6+zmObo/hkYoiQcFNaXc+MVefwczLnA8GMmhW/XGVrRAbrHuyJi7X8EZLM4irmrI3gP0PbC7mGJEli8e44quobWDKuq9AIR3RGCW/vu8KXU0KFRokatRJPbIlmWJCzUEg0wJ7obM6kFPLu2M5Cz6GytoE1p1J58Z4gnJrJ6JAkia+PJTO9tzchLQTQtsWhK3lkFFfzyBCxcaW6Bi0f7E9gfHdPYcfJ+jNp2JgaCYl8oHOk7I3JYWZfMecRwLbIDMZ28xAS+QAi04qpa9DSV3DsDHRC3R2tVoQXCI9kAVzKLsXMSINvCy64mvpGEq+X6yXetFkTXlylV96NJEk68cZcPPOmpo2q8Ftx3rTm/FepVDdCi0WxNTfSy5bvaWtKVnG1cN6KSqUiwNlSaFSkCV1osfjYU1dPG2rqG0kQXBypVCqGBjlxSLAyHHStUwcuXRcKnAXd2E6AswU7BYOL1WoVU3p6s/LkNeHXckJ3T47E5xORKiZcBLpY0svXjo8EXR8atYrX7+vIzuhsoepvgPkD22FlaiA8Qtbe2ZInh7Xn6W0XhV5LQ42azyaFsis6W9hJNXeAL108bHhia7SQeNLe2ZJPJobw7PcxxGXJH/0xMlCzbFp3rhVU8uZeMRFqdj9fpvTyYuaqcKHXMtDFknVzevHFkWTWC4yRNTlw9BFwpvfxYfGoYB5cGyE0Bga6a/qle4MY3tGFcUvP6DXeqaBwu6OINwr/SCRJ4u19V9gUns7Wh/rQ2UNs8bP/Ui6Pb47i00khQmNCFbUNzFodjrOlCZ9ODBVyYvwQlcmnh5JYM7tHq6GjLVFaXc+cNREM7+jMPIFmK4D1Z9M4eDmPb6d3FxrDKayoZeGG8zw5rD29BUW0VSev0qDV8vro5h0vbXG9rIYPDsTz/gOdhdqpAD48kEB1QyMTujefmfRjbC5H4vN49I72Qvuva9Dyzo9XmNXXB2vBDJGtkRkYG2gYIxjyW13XyKqT11goKB4BbA5Pp5evnVAYNUBpVT0/x+UyPkwsmwp0LVMjOrkIiz+ZxVVcza+kfwt5NpIkcTKpQK+8m6j0EkI9bVoUEhNyyzE3NsBDjxrvlPwK2rUyIplRVIWnHk1TZdUNNGglvZw31fVtOW+0rTtv2qgKh6bGKfGxKTszI4r0cN642ZhSXd+oV25OgIsliQI1x02EeNkQl10m3M5iqFHT09dOz8pwFw5duS7s3ungYomnnSkH9RCApvTSL7h4bDd38sprOZUs5hSwNjNkVl8fPhfMvgF4YmgA+y/lCokGAN197OjoZsV7P8ULbW+oUfPCPUF88HMC1wSalwAe7N+OLh7WLNkvlp/jaWfG22M6selcmpBwoVKp+GB8F9ILK4WcJ6BrUXtkiD/z10VSIJBDZG1myOpZPdlzMZvVgk1mz9wVSH9/B2auCqe0Sr540tnDmjWze/Dej1f4/nym7O3/CAFnfHdP3n+gCw9vuMDPcTmytwfd6/nksACeuSuAGSvPcVSPEU8FhdsZRbxR+MfRqNVlw/wUl8t3D/UhwFlsAflzXC5PbInms0khDO8oX7iprmtk7toIzI0M+EqwTvtofB4v/RDH0mlhdPGwkb19XYOW57bH4G5jymujOgq5TU4l5/NTbA7LpocJZcQ0aiWe2BrN0GBx8Sj8WhEfH0zijdGdMDOSXysuSRLPbY8hzMuWYcFimUfRGSVsCc/g3bHNj72V19Tzxt5LvHRvkPCo0LozqRhqVEzqITbuVF3XyBeHk3h6WIDwGMy2yAxcrE2ERwzrGnT14LP7+QhtD7D7YhbBbla0F3zvNmolfozL5d7OYoHYAEcT8gnztm3xtUzJr6S4qo4wb1vhY1xIL6abV8vbN41MiYYVQ9PYVGvOG/3CigsqazE2UGMmmK0EUN1GVXhDG2NTKpWKxrbEG0MNtfXizhsbPZ03ZkYG2Jsb6ZV7E+BkQaIezhtfe3NMDTVCLTdN9PN30Eu86dXOjqq6RmIFRQeVSsXoEHd26dE6NbKLGxlFVVwUDC42MdQwrbc3K06KjR2Brjb7QlqxcNaHm40pM/v48P7PYuILwAt3B3Hw8nVhB1A3L1vGd/fgJcHmJo1axVPDAtkWmcHpFLFr6r4Qd5wsTXhii5h7xsrEkKXTwvj2xFWOC2YpLRzsx8AARxbvuiQkjHrZm7FiZnc+3J8g5DxRqVS8fX8nvOzMeXBthFAuVpi3Hd/O6M6ru+LYFyNfPPkjBJxRXd34YnIoT227yA9R8kWkJqb38eH9cV1YuPECP8WKCUEKCrczinij8I/j9T2XOHe1iO8W9BEK5QX4KTaHJ7dG88XkUO4SEG5qGxp5bfclGrUS384IE6rjPp9WzLITKXzwQJcWv/1vDUmSeGFHLGXV9Xw5pZuQ6yetsJJHNkXxQJin8CL1s0OJZBVXC7VrAZRU1fHEliieGxFIRzcxB9WWiAzic8p5/b5OQtvXN2p5fnsMjwzxa9H99PHBRNo5WDBGcKSrqLKOzw8n8fK9wUKvFcD6s6k4W5kIh3LXNWhZdjyFR4b4CwsGP8XlYGakYXCAWD04wLbITOG8HtCJfVqtRO92YmNfAMfaGJk6mZRPT187ofd2E1HpJXRr5X0Vl1UqHBgNuuyigopa/NrIvNFnbKqosg4HC2O9BKbqukZMWhG3G28psLj1Y+g7NmVnZkSxwLfaN6Nv7o2+deFqtYqunrrKcFH6+jkQfq1IuPHJUKNmSKATh66IO2fu6+rGyeQC4cYlc2MDxoS6sflcuvBjmN7bmzMphcL5GrbmRkzvo5/75uHBflzMKOFkkpjw4WJtwiND/Fm865KQ8AGwaHggV/Mr2X5BTEzzcTDn+bs7sOi7GOEcotfu60h+eS3fHBMLce7gasVL9wbzxJYoIXFVpVKxeFRHUgsreW3PJaHHEOply2eTQnlk4wWhGnUDjZovp4TiaWfKU9uiaRB4f/bzd+DLKaG8seeSkGvlvwWcsmr5r+fQYGe+nd6dl3+IY5Me78+RXdx0gtgBMVeXgsLtjCLeKPzjuFZQybYFfYSbhH6MzeHzI0l8MSWEoa1U+LZEfaOWxzZFkZRXzsqZPYScIonXy5mzJoJ7u7gxUqCSHODzw8mcSSngk4khmBvLfwzlNfU8uDaScd08GCc4vnIk/jorT15j6fSwZiu126LJMRPsZsXMvj5CjyGjqIq3913h/XFdsDYTc8R8e+IqkgTzBzY/ShSXVcrm8HTeHNNJeBH76aFEuvvYCQfsltfU8/WxFJ4RFMkAdkVnYWKoEXKaNbH6VCoz+/gIZTuBroo+Oa9CKJupiX2xupEpURGspr6RUykFDGlNvEkuoL8eeTfXy2rIKa2mayvZSHHZ+ocV25sbtRpwnqnn2FShnk1ToBO7W3PetBlYrKLNb/71HZuyNdcvsBjAw9aUTD3aUAJcLMkqqaZCMO8F9A8t7uBiibGhhot6CEBDg531GnvytDOjq4cNP+rxrfrknl7svpgtLBg4WhozJsSdlSfFRl1Al7ly7mqR8Lm0MTNi4RB/3v85XngM7cH+vlTWNbA1IkNoe0sTQ167ryNv77ssLKZN6+WNt70Z7/x4RWh7c2MDPp8cyldHU4SzTsaFeTCikwsLN14Q+pwwNdLw7YzuHLiUK5QdA7r3xeN3tmfO2gghEcnEUMNrozpxNb+SFwXdUHd0cOb10R15ZNMFTgs47JoEnA6uVsIOnP7tHVgzpydrT18THiWDJjGqm/D2Cgq3K4p4o/CP46sp3XCwEMs02ReTwzPfXWTR8ECGBslfwDZqJZ7adpGM4mpWzeqBlcD4TGZxFTNWhjO7nw/Te4sFvm4/n8mKX66yanYP4XDg/2yJxs3GlOfvFqv0Ti+s4okt0bwztrPw6NqGc+lEZ5TwgWBIcqNW4ultFxkd4iY8BnQ1v4IvjyTz3gOdmx19a9RKvLQzjrn92+HvJD+TCCDpejlbIzKEq8EBVp68RoCTJQMFM1gatRLfHE9hwWA/4ZGrqPRikq6XM66FTKBb4bvzGdzT2VVI7ANoaNTyU2wuI7uIj0ydu1qInZkR7Vt4PesbdKGt+oQVx2aWMjDAEYsWhNWa+gZMDQ3o6C723gHIKq5iSCttXZW19fg7WeiVqVNZ26CXwARgb26EpXHLr7ehRoVrK0HtKmjzMQS6WNLYKLbABbAzN8Jd8AuBJjq6WVNVKy4gOVgYM7C9A8l65N5087KhTFCwAJ17p7+/Axf0CAQdHOhIcl45qYXiLqLRoe7CocOgf3AxwIMDfPkhKkso6wR0r+e03l58cUTcfTOrrw/55bXsExSyTAw1vHJvMEv2xwvlpQCM6ORCDx873t4nJr6o1So+GNeFvRdzOCoYWNvJ3Zqn7wrgP1uihK/vxaM60qjVCj8PdxtTvpkWxjv7rghXwc8f2I5hwc7MEajfBl2GzroHe3IquZAPBLOERnRy5Y3RnZi3LlKoDczEUMOrI4OxMjVkhqCA08PHjiXju/LZ4SS+OJwknE8V5GoltJ2Cwu2MIt4o/OMQEUwA9lzM5pnvLvLVlG7c0UG+40ar1blEruSUsf7BnkJ13oUVtcxYGc6wYGf+c6dY6O3plAJe3hnHN9PC6OAi9otryf4EUgsq+WKyWMhyTX0jD288z/2h7sLNUPG5Zbyz7wqfTgwV/mZ/1clr5JbVCIsiWq1u9GxiD09CW8gm2RyeTnFlnXB9OsBb+64wuaeXsPhTXFnHil+u6eW6OXzlOjV1jcJjXwA/xeUypacXVoLCS21DI8l5FS0GQt8KZ68W0t7Zgp6+4iNTR+LzGNHJpcVzeTGzlKraRoJdxYWV8NSiVt2BSdcrSbxejred2OgnwJWccjTN5DM1kVlcQ1xWKfZ6OGeySmqo0cPRApCUV4GBpuXrtqK2kaLKlhcAarWKqDbcCzmlNVQKZEE0YfdrxbXouBCAhbGBcNZLE7UNWhJzxUWPLh42HLqSR4keLqJe7ew4pEcYqJWJIcM7uXL4iljGCMA9nVxo1EpkFIk7mWb08SH8aqHwwjDA2ZIB7R3YKTgyBDBvYDtOJhcQl1UitL2JoYanhgXw4YEE4SDqO4Oc6OJhwyeHxNqrAF4f3ZEDl68Lj3B52Jrx8sggnt8eIywizennSztHC176IU7oNTUx1PDN1DB2RWcLZyr18LHj1VHBLNx4QejaVKlUvHFfR1ysTVi48YLQ542zlQnrHuzJ1ogMYWfYuDAPnr8niFmrI4RCsU0MNSybHoaVibiA08XDhi3ze7P2TCof7E8Qfp8qKPzTUMQbBQVg98VsntsewzfTurU6KtESuirtS0SkFrFxbi8h509FbQOz10QQ5GbFa/eJhQsnXS9nwfrzvD66o1BODujarTadS2P5zO7Cwbuv7orDyEDNS/cGC21fXdfIo5uimDfAlz6CVc+JuWV8fDCRjyd0FRobA9gZnUVGURXPDA9s9vb88ho2nEnl9dEdhbNPjiXk0aDVCot1AMtOpDC6q5uwYCFJEp8fSWLhEH/hevG8shrWnEplUi8voe0BDl3OI6OoSi/hZV9sDgHOlsLuIUmSOJKQ1+r755ekAvr42TcbXH2rXEhrO6y4k7uVfmHFBRW0ayvvxs5Mr2PoasL1G5tqu23q1qrCW/vj3kij39hUkxhfokfujYetqV6BxaBzECUK5qyAzkHkbW+mV+5Nf38HotKLqaoTH9/q5WvHwctiFc8A9hbG2JkbsfuiuHNmRCcXjibkCwcXA8zo4803x1OoqRe7tpwsTZg/wI/PD4vltYCu/aqTmxVbIsQyQlQqFa+OCiYms4T4HLEwa1drU54dEciS/fFCgbmgq1APdrXitd1xQtur1So+Gt+VMykFQq1JoBvJ+2RiV17cESucZzS5pxcju7gyb12kUA16U35Nfnktr+4SE6L8HC1YNasHHx9IEBaipvf25rE7/Jm+8hwJAkHpf4SA08HFim0P9WFnVBav77ksPB6ooPBPQhFvFP717IrO4vntMXwzLYzBgWLCzTs/XuFIfB4b5/YSGlOqbWhkwfrzWJkY8vGErkILz7zyGmatjmBWXx8mCIa9Xkwv4cUdcXwxpZtQLTnAzqgsDl/J42vBhi2Azw4n4mNvxuOCgkZ9o5aXd13isTv86e4jJgTkldfw2u5LvDO2c4ujLe/+GI+fsyVDBK6bpsf51r4r3NnBGVvBBfD1shrWnE5lsh6iyYmkAnJKanigm7jjZeO5dPr42QtfN6Bruhrf3VNYTKhv1PJznH4jUyn5leSV1dKnXcvizclk/SrC6xq0xGSVEupl0+J9YvUMK4ZbaJoqqsJDj7BigIKKWuwFx1SbqG2rbaqxrcwb3W2trXGMDTV6BRYbGaixMDbQK/emKbBYn2+Q2ztbkqCHeAMQqmdosZedGU6WJkSkio9ODQ1yJjK1WC8H0OgQN3ZGZQmfzz8iuHhAe0ccLY3ZGSXuvpna24vjiflczhYTTgw0asaEevD54SThPCQ/RwvCvG15fc9l4fM5tZe3Ln9GcAxMpVLx3gNdyCiu5uc4MWHP0dKYjyaEsCs6m6v5Yg61Ozo4M6ufD2/tuyx8Pl8ZGYytmREv7BDLnrE0MWTVrB4cic9j6XGxVrMQTxu+mRbG89tjOSHYpDV/oB8z+/owbeU5oUr4P0LAaedowbaH+nAkPo/nd8QIh2srKPxTUMQbhX81O6MyeWFHLEunhQlnonxzPIVd0dlsnNtLaCHUqJX44OcESqvrWDo9DGMD+Q6OqroGXtwRy+BAR54cFiB7e4Dc0hoWbrrAyyODhM9FbGYpL+yI5cspobhai+VD7IvJYXN4Bq+P7iQcOPvlkWRKq+p5cICv0PYAr+++zMAAxxYFvdMpBRy4fJ2X7xXPqdkcno5WkpjeRyzbCOCLI0nc0cFJr4X+V0eTmdPft9UFdGvUNjSy8Vw6s/SoB88uqeZ0SoFeAtKZlEKMDNR016O++2h8Hn387Fs8F+U19URnlNC/vdh7BOByThlmRhratdKGF5elX1hxo1biakFlq86bjOIqvPQIKwad80bfwOLq+kZMW3XeaNsMLAbQtrJIMjZQUyvojmjC1tyQIj3qwt1tTKmobaCsWtyxEuhsSZIejVOgW9RF6RFarFKp6OdvLxRo2oSbjSmBLpbCGScAw4KdySqp5rKgWwT+P7hYNCdFpVLxYH9fVpy8JuwKcLYyYVIPT748Kp59MzTICR97c1b8Il5f/vid7UnKqxAWTjRqFa+MDGb1qWtcEXxNnK1MmN7Hm5d+iBUOQB4U4EgHF0se3xIl7LZ7alggkgTPb48REl8MNWq+mtqN/PIavjgi5qpyszFl5cwenE4pEKrvBhgY4Mh7D3Tm/Z/jiRaspf/Pne25P9SdWavOCQWu/7eAI9JC5WlnxraH+nA+rZgntkbrNb6qoPB3RxFvFP61/BCVyYaz6SybHibc8PP1sWQ2n0tn49xeQrXkkiTx2m5dLePq2T1adHi0RqNW4vHN0VTUNvDqqGAh10JNfSMPrY+kj589U3qKOThKqup4eON5HrvTnz5+Yq6EjKIqnt8Rw/sPdBYOB43JLGHZiRQ+mtBVSAgDOHj5OieTC1g8qmOzt9c1aHllZxxPDG0vLFKVVtXz8cFEXronCENBkSq9sIrvIjN5SlCwA4hILeJKdpleAtKPsTlYmRgwSA9BY/v5TPr7O+DSSjBtW+yNyeaezq7CTVcARxNarwg/e7UIbzszvcJrL6QVE+pp0+J7ta5BS0JuuV7iTXZJNVqt1Ko4k1FUjaedfiG8hRV1OFjoKd7UtT421dBG21TTeWxt7axvVTiArZkRxXqIN5YmhlibGpKhT+OUswW5ZTWUCiyAmgjxsuViZoleDqB+/g6cShEXb0AnvujTOmVmZMBdwc7s1je42MWSXXrs474QN0qq6jmeJJ7hs2CwH4ev5AmNp4DuPfD83R1YfuIq+eViooeliSHPjQjkrX1XhEefglytmNPPlxd2xAo7JO7r6kYPHzte3ik2MgSwaIRu1PlDwdBejVrFxxNDiEgtYu3pVKF92Jkbsfi+jnx74ir7L4kJYp3crZndz4dF318UbtIaHeLOA908mL0mghQBN5JKpeKFuzswsqs701acI6+sRvY+mgScDi6WzF4TISSWulibsPWhPuSV1fDCjljhUUUFhb87inij8K9k+/lMXv4hjieHBTBAcMG5+tQ1lh2/yrLp3Wkv2Kb02eEkDlzOZd2DPXGwkL9olSSJN/de5lpBBcumdRcSKyRJ4vntMWjUKt6+X6zqWquVeHJrNB1crFjQQp12W9Q3avnPliju6+rGiE5iNdE19Y08te0ijwz2F3ailNfU88rOOF66JwhHy+bHQZb/chUjAw2zBOvLAT4/kkRnd+tWhYK2+PRwIiO7uOHvJB6c+/XRZKb38RYOGZYkSVcP3le8HlyrlfjufKbwuB/oBI/9l64zUo+K8fKaeiJSi1odgzuZlK9XyxTAhfTW824Sr5djYqjWyxWTkl+Bl51Zq8JgRlEVnnqOTRVW1mJnLj42JUmSznnTWlW41Fbmje5/W3fe6Dc2BTrxpugPqQsXz72xMTPC0dJYr8apIFdLqmobSS0UF5H6+NlzObtMr7GnYcHOHE/I1yuLaHSoO7svZuuVhTGlpyebzqULCwXGBhpm9vFm5S/itcau1qaM7+7Bl0fFs2+6+9jR19+BL/Vor3qgmwcOlsYsO5EivI/H72xPcVUdGwQrs1UqFW/d34nwa0XCmUbGBho+nxTKpnPpHBccGXKwMOarKd147+d4YeGkg4sVH47vytPbLgoLc3d0cOb5uzswb10kaYXyR5cA5vT3ZVJPL2asDCe3VL74olKpeHpYAN28bZm64pyQA9HEUMPiUR2xNDFg5qpwIQHHwcKYb6d3JzmvgnnrIoVFRgWFvzOKeKPwr+P785m8uiuO5TO6Cy/CNoen8/GBRNbO6Umwm1ij0/ozqaw+lcr6B8XGrQBWnUplb0w2a2b3xNpMbPG99PhVzl0rEh7ZAvjiSDJXCyr5aEJX4QX8p4cSqaxt5JWRYiHHoPuWzdzYgIcHiwlIoGvaaudozvgWGo/SC6v48kgyb40RH+u6ml/BhrNpvHyvmFMKdOHU+2JyeGKoeNDxpexSzlwtZE5/8fGyqIwSruZX8kCYHg1R1wqpqG3gziD5LW9NnEouwMxIQ6in+MjUyaQCvO3N8WxFNDmZXCAcBt5EVHoJ3VoZ7WrKu9ErrLiNvBtJksgormr1ubaFVivpHVjcJKiYtJKP1dgotdqa1eTKaT3zRr/AYtB9k65PYDHoRqf0Di12tiRBj8YpYwMNHd2tiM4Qz6xxsjTB38mCMylilcgAwa5W2Pza4iVKf38Hahu0nLsmv9K4iZFd3MgoqtIruHhqb28i04qEc2sAHh7sz/5LuSTnib+2zw4PZEtEhvAiX61W8fp9HVl2/KrQiAzoFunv3N+ZJfsTyCkVu9YdLIx5+/5OvLrrkpDTA3RZKYvv68jT26KF3Ujdfex45q5AHt10QXiMa0QnF+YO8GXuughh596MPj6MCXFn9poIYcH02eGB9PO3Z+aqcKFGL7VaxQcPdCHA2ZLpK88Juf9MDDUsnRaGtakhM1aKCTjWZoZsmNuL2gYtMwVzdBQU/s4o4s1tSkVFBSdOnODDDz9kwoQJ+Pr6olKpUKlU+Pj4/CnHPHPmDNOnT8fHxwcTExNcXV0ZMWIEW7ZsueV9NDQ0sGzZMgYOHIijoyOmpqb4+/uzYMECLl++/Kc8bjlsi8xg8a44ls/sTl9B4eaHqEze2nuZlbN6EOJpI7SPvTHZvPdTPKtm9SBA0LXzc1wuHx1IYMXMHsILsMNXrvPFkSSWz+iOk6XYuMqxhDyWnUi58QtZhNPJBaw+lcoXU0KFW5vOXi1k47l0PhrfVVhUOZ9WxHeRmbxzf+dmF866VrE4xoS6EaZHrso7P8YzLsyDQBdxx8zHBxOZ2MNTr8X318dSmNTDS6gdrYm1p1MZ391DaOSvie8iM7k/1F044Bpgb0wO9/4BI1NDAlt24uWUVpNaWCXcgAZwvayanNJqurby2RGbVaJ3WHFaYSV+reTdFFXW0dCoxcNWfGyquLoOSxMD7MzF3vegy7txsDDCxLDl116tVmHayu0AjhbGNGpbdtZYGhu0Ku7cCg4WRnovFDxsTbku8M33zbR3ttDLeQO/5t4Iugma6Oun3+iUSqViaJATh/QYnTLUqBnZxZXdF8UDg5uCizedE3OKgE7Ye6Cbh3A1M+iEvQe6ufOVHu6b9s6WjAlx58MD4rXfIZ423NvFlXd/jBfeRz9/B+7q6MziXZeE9zGikytDAh15XjD0F2B8mAe929nzzHcXhd1ZD/b3JdTLhv9siRYeBXv8jvYEu1oJ138DvHRvEH6OFsxff15IiFapVLxzf2c87UyZuy5CaOzIQKPmk4khOFuZMGdNhFCbVpOAY2smLuBYGBuwdnZPTIw0TFtxTi8HoILC3w1FvLlNGTVqFIMGDWLRokV89913pKam/qnHe+ONN+jfvz8bNmwgLS2N2tpacnNz2b9/P5MnT+a+++6jpqb1PzgLCwvp378/CxYs4JdffqGgoICamhpSUlJYtmwZ3bp1Y9WqVX/q82iNrRHpvL77Eitm9qCvYCbLT7E5vLgjjmXTuwvXGf+SlM+i72L4cmo3YQEgKr2Yp7ZF8+nEEGEBKfF6OU9sieaDcV2EF4qZxVU8sTWat8Z0IshVzIFUWFHLE1ujeeneIGEhq6K2gWe+u8ii4YH4O4m1HdXVN/Lc9zE8dqd/i/lF+y/lcjGzlOdGdBA6BsCZlALOXi3QK6cmLrOUC2nFPDrEX3gfV/MrSCuoZN7AdsL7uF5aTV5ZLdN7i+fllNXUk1tawzg9nDu1DY2kFlYyqqt4y5RWKxGfW87QVtw/J5MKGN7RWXjEDOBCWgk9fexaFbsuZ5fT1UM/8SYpr/Wa8IziaixNDTHXQ3QrrqyjrkHC3Fj8fNTUN1JQUYepYcuPo7qukdaWOxq1ivyKWlpbVqlUKsprxIOCAaxMDMkrE/v2vQkPW1NSBV0RTXRwsRQewWiih7cdcXq4RAAGBzgSq4dbBWBERxeu5JTpNfY0NtSdlPxKvZxVU3p6k1VcLRxcDLrRlMziKq4Luk0AFg72Jy67lJR88df3iWHtOZmUT2yW+Gvz7IhAjifmc/aquCvq5XuDiUgt4udYsbBdgNfv60RcVinfCVZ/q1Qq3r6/Myn5Faw6JSasqVQq3n+gC9kl1Xx2SEwUU6tVfDwhhOKqOt7aK/ZFpkat4rNJIdTUN/LCdjFBy0Cj5ovJ3ZAkeHRTFA0CQpKRgZqvp3bD2EDNvHWRQiKQiaGGb/QUcEyNNCyfEaYL/P72rLC7SkHh74Yi3tym3PyhbGtry7Bhw7CwEK/gbY0VK1awePFitFotfn5+rFy5kvDwcHbu3MmQIUMA2LNnD3Pnzm1xH42NjYwdO5Zz584BMHbsWH766SfOnTvH559/jpOTE7W1tcyfP5/9+/f/Kc+jNbaEp/Pm3iusmtVD+FvzI/HXeWrbRb6cEio8NhGbWcLDGy7wzthOwvXSaYWVPLr5AouGB3JXRxehfRRX6v6AmN3PR7hWuaa+kQ/3JzCyiytjBRuCJEnivZ/iGRLoKByUDPDBz/H09bPXK4Pmm+NXCXCxYt6A5sWMitoG3t53hddGBWNjJjYm0qiVeH3PZZ65K1CveuUPDiRwfzd3nARq6ZtYejyFIFcrvYJ3N4ZnYGqkaXU8py32XMymqq5BWPwD+CWxgNzSGrroIXhczinjan5lq+NMJ5ML8NfjuYJuzMy3lX3UNWi5nF1GsNufWxOe/gfk3RRU6N80VVOvxdhA3apjqkHbVubNrQYW69s2pX/mjbutmV6ZNwD+TpYk6Nk41cndmtisUr1CP7v52BKXXSY8GgPQ3deOpLwKvYSGrp425JRWcyxBPDA42M2KirpGdulR+e3naIGFsQHrBLNeQNeqE+ppw9dHxVujXK1NmdrLm/d/EnfOOFma8OyIQBbvihNa4IPOjfTmmE68vz9B2LFmbWbIB+O6sPFsmvC4obWpIZ9NCuVoQj5xgteZpYkh30wL43hivnBDmrmxActndOfA5evsuCAmRpkZGbBiZnfOXStihWDGkqmRhpUze5BeVMkb+8Sq4U0MNSyf0Z3aBi0LN5ynTuCz9b8FnNJq+Z+txgYavprajUAXSyZ+e0avzyIFhb8LinhzmzJlyhQ2btxIUlISRUVFHDhwAHt7cat+S5SUlLBo0SIAvLy8OHv2LHPmzKFHjx6MHj2agwcPMmrUKAA2btzIiRMnmt3P+vXrb9y2cOFCtm/fzogRI+jZsyePPfYYp06dwsrKisbGRh577DEaGvT7BlQOm86lsycmm1WzetCrndg5PJVcwOt7LvPxhK7CuRzJeRXMXB3BS/cGcX+omNhRUlXH7DUR3B/iwex+Yjkl9Y1aHtl0AQsTA54YKu7+eH3PZa4VVOpVlb3qVCqnUwp58R7x7Jej8Xn8cCGLx+9sLzwyk5xXzjfHk1kwqF2LAa+fHkzE1cZUL3fH1ogMqusbmdxLXKg6d7WQqLRiHhIMhgZdE9HO6GwW6JENVNvQyKZzaXoJZgDbIjIYr0dQMcC+2BxGdnHVKyPmSHweA9o7tPj6a7USp5IL9KoIB13TVDcvmxZvT7xejrGBGm89xuEqahvILatptYo8o+iPqQn/s5umQFcVrm7ltW26rbVFiC7zRr/AYjtzI4pvg8yb9s4WFFTU6tV85WlniqWJIZf0cN9YmRjS2d2aU8ni7gxDjZohgU56tU6pVCpGd3XXq3UKdMHFG/UILgaYO6AdG8+lU1Un/jfOI0P82ROTLZxbAzBvQDtis0r5RY8GrEk9vKjXSmw8ly68j3s7u+JmY8ISwdYngMGBTnRwseK578VquwHCvG3p7WvH45ujhEZ9AAJdLJnVz4cntkSTUSSWB+RpZ8ZHE7ry0g9xRKSK5TQ5WZqwenYPvjiSxHZBR5K1mSFrZ/ckOr1E+LUxNzbQtaSaGPLk1otCIp+JoYal08MIcLZg/rrzQg4cQ42ajyeE0KedPc9tjyFdjyB2BYW/A4p4c5syf/58pkyZgr+/+FjErbB8+XJKSkoAeP/993Fw+K2jRKPR8PXXX6PR6P64XrJkSbP7afrvtra2zd7H39+fF154AYCkpCR27dr1Rz2FVtl4Lo13frzCE0MDhMecIlKLmL8ukieGtufuzmJNNjml1cxcFc6kHp5MFnSY1DY0Mn/9efwcLXhSj5Gbt/ZepqiyjiXjxMOFv4vM4Oe4HL6eFoZJK+MOrRGXVcqH+xP4fHKIcNhySVUdz22P4ZVRwcKhz1qtxAs7Ypnay5suHjbN3udydhnrz6bx1hixNi7QjQd9dCCBF+4OEg6GliSJDw8kMG9gO2z1cDws/+UqQ4Oc8NPDRbIvJgdrU0MG6BHeG59bRnxuuV6CWE19IwcvX+dePVqm4Ne8m1aav+Jzy6mqaxQeUwSdqyYmq7RVd09cVikd3a30yu65ll+JjZlhq66YzOIq/WvCK/V33lTXN2LapnhDq86bprdk684bDbX1+ok3NmaGegkmAJ62ZpRW1+uVnWNlYoibtQmJ18VHa1QqFSGeNkRnlAjvA6Cfvz2nk/WrDB+qZ2U4wJhQNw5dua7XeR3V1Y3M4mq9zknvdna425gKL6oBvO3NGdnFla+Pijc+WZsZ8sgQP977KV54JM3IQM2rI4P56ECCULsQ/Dq2NKYz30VmCjc2Abw8MohrBZVs0ENIWjjEH0dLY17fI57Dc3+oByO7uPLIpgvCTr6+fg68cE8HHt5wXljIDXC25OupYby8M044NNzVxpSPJ4SwOTydVYJZTVYmhrx2X0eS8sp5dnuM0LVmbKDhzTGdMDPSMF1whEqjVvHWmE74OVowYdkZvUK/FRRudxTx5l/Ozp07AbCysmLs2LHN3sfDw4OhQ4cCcPDgQSoqfvuhmJSUdCOMeOLEiZiZNb+InjVr1o1/79ixQ89H3jbrz6bx3o/xrJndgx4+YsLNxYwS5qyO4KV7g/Vyy8xYGU5/fwcWDQ8U2odWK7Houxhq6xv5fFLojXYVuehcSDksn9FdOOviUnYpi3df4rNJocIjNxW1DTy2OYpHhvgR5i322gC8susSXTysGa9HXsqm8HSyS2pazKDRaiVe3hnLnP6+wpk8AF8dTaa9swXDO4o3Kh1LzCclv1KvdqjCilq2hGewcLC4MNxUDz6rr49ebpfvIjO5p7OrcNA1wPHEfOzMjeisR8BvYUUtMZmlDG4lrPhUcgG929nrFap8OacMMyNNq46Y2KxSvZ4LwNWCCto5mLf62mQUVetfE15Rq9f4H+jEt9ZqwkHnvNFobmVsqrWq8D+mbUpf8cbK1AALY4M/wH1jqZd4A/wx4s2vocX6uFUGBzpytaBCr2/M/Z0s8Xey4Oe4XOF9mBk1BReLCwQqlYq5A3xZefKaXjk+jwzx54foLGGHB+gaioor69gTI+5IGhzoRE9fez48IO6c8XEw59E7/HlxR6xwWK+liW586r0frwg7kjRqFZ9OCuHA5evsEawgB3h1lK4R84094iUc03t7MyzYmfl61F33b+/A6/d1ZMGG88Jihb+TBatn9+SjAwnsihYbGbQzN2LDg724kFbMq7vjhD4LjA10Dhw7M0NhAUelUvHqyGAeCHNn4rIzXMnRL9NLQeF2RRFv/sXU1dURHh4OQJ8+fTAyavkb1EGDBgFQW1tLRETEb2775Zdffne/5nBxcSEgQLdAPnnypPDjvhXWn0nlg5/iWTOnB90FhZvL2WXMWBXOk8MCmCI45lJV18CcNRH4Opjz9v3iro2PDyZyIb2YFTN7tLnQaYlzVwt5c+9lvp7aTbihqLS6noc3XODhQX4MDBAfH3l1VxwuViY8rIeAsDcmm5NJ+bwztvlmqFsht7SG93+K5+37O7UoZm2NzOB6WS2P3yFeyZ1eWMXa06m8MlJ8PEyrlfhwfwILB/vp1ey0+lQqPX3t9GozupBeQmpBpXDWEehcKD9EZbVYyX6r7IvJ4V49R6ZOJOUT7GrVauPaL8kF9BdsqGviQloxoZ42rT7WuF9rwvUhpY28G9Bl3vwRY1P61ISDTrwxbkMQazvzRve/bYs3eo5NmRlRXtsgvAAF3QLDw9aUzCI968JdLEnUM/dGJ97o1zjVzduWkqp6UvLFR3ysTAzp3c6eA5fFhReA0SFu7NZjUQ664OI9Mdl6BRff29mNmnoth66Iu4n8HC24u5MLXx8Td9+YGGp4clgAHx5IoE6Pa/+VkUHsuJApnBcDMP/XYPxvT4hn+fTzd+CBMA8WfRcj3Prkam3K+w904cUfYoWFMWMDDV9N6cbemBx+iBIPUn79Pp3bZNH3F4XFzwk9PJnW24vZa8IpEKwyD/G04etpYTy/PZYTiWJjdk5WJmyc15uj8fm8+1P8/1TAWTS8A3P6+zLp27NcytYvUF1B4XZEfAWg8LcnKSnpRvZMhw6tt+fcfPuVK1duBBk3/f/m7tfSfhITE8nIyKCyshJz85a/gb6ZzMzWf0FmZGTc+Pfyn8+z9VI5H08MwVlTRWam/F/Q1woqWLjhApN6eXKXj2Gbx2+O+kYtz35/kfp6Lc/eHUJujtgflbujs1h5JIlvZ3SntjQfkXKP7OJqHlwbwcJBfngYVQs9H61W4rntF3E1gNHtTYT2AfBTXA4HwpNY/2BPcrLFvukpKK/h2bXneH5EB+pKC4TOCcBz2y/Sw0mDv3lds8+nuLKWN7ac5dWRwRTmiTdmvLQjhjs8DLHWlpOZKfZt+ZEr18nOymLwKC/hc19eU8+K/REsGddVeB8AX+6JY7ivEcX5uYgu/Y7GX8eguggPQ7HrEXQL/5/OxbF0Wphez2f3qThC7Uxb3EdNfSOnLiYwN9RKr+OciIqnnaNFi/uob9QSk3gNhwGOeh0nJj6F9i4tH6dRK5GenoFBtQeZmeK11WlpGQS7Wer1WDMyc6GysNV9lBbkUmpSQ2Zm8y4frVaioayArMxM6loQ4MqLrlOcn6vXY61r0NJQVsClpKs4WIiHhdtoy4hNvEoHK3GBwE4qZ298DpmZNsL7cFDVcy01g9iEFGzNxR1UwVb17D0Ty7gw8eyqMActu07FMsJXXAzs7iDxzrYEouPthV8fK8DLuIZV+yP1ej73tTfm8z3nCLYOE97HuEBTZqyOYGygCa7WYi7Xnk6gqizkyz1nmdBD7EsoDfBAoCnPrj3KsulhwkL5E33teGzTGULttcLC8fTOFkwPv8xHP2iZ0kus5bCjNQx2VzP/m/18My0MgxZyzlpDBbw0yIln1x7FTuqBn2DL5StDnJm9OoK3DSqZ1VfMUTsxyJzLSXVM++xHvpzSrc0MsebwM4On+9kz75v9fDE5VDgw/8N7PFiw4Tx1pfnMbaH8oS1eHuLMC9tjGPfhXj6bFIKlQLvj6PYmVBdbsPDbwzf+21+Ztamg8KciKfxt8Pb2lgDJ29v7D9nfTz/9JAESIC1ZsqTV+0ZERNy47/PPP/+b2yZOnHjjtvz8/Fb388gjj9y4b3x8/C0/1qZtlB/lR/lRfpQf5Uf5UX6UH+VH+VF+bvUnPDz8ltccCgq3M8rY1L+Y8vL/dwC0VUN+s0PmvzNv/qj9KCgoKCgoKCgoKCgoKCgo/B5lbOpfTE3N/9vlW8u7ATA2/n9LdXX1b2f1/6j9tMbNY1HNce3aNQYOHAjA6dOn8fTUr3pY4dbJycmhZ8+eAISHh+Pqql/rj8Kto5z7/x3Kuf/foZz7/x3Kuf/foZz7/x3Kuf/foc+5b2hoID9fl+PTuXPnP+XxKSj81SjijR40NDRgaCjektLE6tWrf9PE9FdhYvL/M+F1da03aNTW/n8Qmqnpb2ev/3s/N/9/OftpDQ+PWw819fT0lHV/hT8OV1dX5dz/j1DO/f8O5dz/71DO/f8O5dz/71DO/f8O5dz/7xA59z4+Pn/Og1FQ+B+hjE39i7G0/P/a47ZGmCor/79J4r9Ho/6o/SgoKCgoKCgoKCgoKCgoKPwexXmjBwYGBr9pWhLlf2W/vFm9ltPm9N8jSf+9HweHlut0m/ajUqmUby4UFBQUFBQUFBQUFBQUFG4BRbzRk7aqsW9nAgIC0Gg0NDY2Eh8f3+p9b749KCjoN7cFBwf/5n4hISFt7sfT0/OWa8IVFBQUFBQUFBQUFBQUFP7NKGNT/2KMjIxuhICdOXOm1dyb48ePA7rA4e7du//mtv79+//ufs2Rm5tLYmIiAP369RN+3AoKCgoKCgoKCgoKCgoK/yYU8eZfzpgxYwAoKytjx44dzd4nMzOTQ4cOAXDnnXf+JuMGdA6eJjfOtm3bqKqqanY/a9asufHv+++/X89HrqCgoKCgoKCgoKCgoKDw70ARb/7BpKamolKpUKlUDB48uNn7zJ07F2trawCef/55CgsLf3N7Y2MjCxcupLGxEYBnnnmm2f00/feioiKeffbZ392ekpLCu+++C4Cfn58i3igoKCgoKCgoKCgoKCgo3CJK5s1tSnJyMidPnvzNf2tqcqqoqPiNiwVgxIgRuLi4yD6OnZ0d77//PgsWLCAtLY1evXrx0ksv0blzZ7Kzs/n00085evQoAJMnT2bIkCHN7mfmzJmsWrWKU6dO8dVXX5Gbm8u8efOwtbUlPDycN998k7KyMtRqNV988QUGBsqlp6CgoKCgoKCgoKCgoKBwK6gkSZL+1w9C4fesWbOG2bNn3/L9jx49+jt3TWpqKr6+vgAMGjSIY8eOtbj94sWLefPNN2npcrjnnnvYvn07JiYmLe6joKCAe+65h4iIiGZvNzIy4ssvv2TevHmtPxkFBQUFBQUFBQUFBQUFBYUbKGNTCgC8/vrrnDx5kilTpuDp6YmRkRFOTk4MGzaMTZs2sW/fvlaFGwAHBwdOnz7N119/Tf/+/bG3t8fExIR27doxb948Lly4oAg3CgoKCgoKCgoKCgoKCgoyUZw3CgoKCgoKCgoKCgoKCgoKCrcxivNGQUFBQUFBQUFBQUFBQUFB4TZGEW8UFBQUFBQUFBQUFBQUFBQUbmMU8UZBQUFBQUFBQUFBQUFBQUHhNkYRbxQUFBQUFBQUFBQUFBQUFBRuYxTxRkFBQUFBQUFBQUFBQUFBQeE2RhFvFBQUFBQUFBQUFBQUFBQUFG5jFPFGQUFBQUFBQUFBQUFBQUFB4TZGEW8UFBQUFBQUFBQUFBQUFBQUbmMU8UbhtqKiooITJ07w4YcfMmHCBHx9fVGpVKhUKnx8fP6UY545c4bp06fj4+ODiYkJrq6ujBgxgi1bttzyPhoaGli2bBkDBw7E0dERU1NT/P39WbBgAZcvX/5THvefRVVVFUuWLKFnz57Y2dlhYWFBUFAQzzzzDOnp6Xrvv+n1lPPTHLNmzbrl7VNTU/V+3H8Ff/a5P3bs2C2fs9dee63N/SnX/a3T0NDAwYMHWbRoEQMGDMDR0RFDQ0NsbGzo1q0bzzzzDCkpKW3u5+9y3aenp/PMM88QFBSEubk5dnZ29OzZkw8//JCqqqo/7Dhbtmxh+PDhuLq6YmJigo+PD9OnT+fs2bO3vI/CwkIWL15M165dsba2xsrKiq5du7J48WIKCwv/sMf6V/FnnvuysjK2bNnCvHnz6NatGzY2NhgZGeHo6MjgwYP58MMPKSkpaXM/Pj4+t3QN/1m/9/8s/sxz/9prr93ye//YsWNt7k+57m8NOb83m34GDx7c7L7+Sdd9Xl4ee/fu5dVXX+Xuu+/GwcHhxuOfNWvWn3JM5fNeQQGQFBRuIwYPHiwBzf54e3v/4cd7/fXXJbVa3eIxR40aJVVXV7e6j4KCAqlXr14t7sPY2FhauXLlH/7Y/wySk5OlwMDAFp+LtbW1tG/fPr2O0dK+W/oJCAhodj8zZ8685X1cu3ZNr8f8V/BXnPujR4/e8jlbvHhxq/tSrvtbJy8vT7K3t2/znBsZGUmffvppq/v6O1z3e/fulaytrVt8XIGBgVJKSopex6iurpZGjhzZ4jHUarX0xhtvtLmf8PBwydXVtcX9uLm5SREREXo91r+SP/Pc//jjj5KxsXGb152zs7N05MiRVvfl7e19S9fwn/F7/8/iz77uFy9efMvv/aNHj7a6L+W6v3Xk/N5s+pk/f36z+/onXfetPf6ZM2f+ocdSPu8VFP4fRbxRuK0YNGjQjQ9RW1tbadiwYZKFhcWf8sts+fLlN47l5+cnrVy5UgoPD5d27twpDRky5MZtU6dObXEfDQ0N0sCBA2/cd+zYsdJPP/0knTt3Tvr8888lJycnCZA0Go30888//6GP/4+mvLxc6tChw43nMm/ePOnw4cPS6dOnpbfffvvG62BmZiZdvHhR+DixsbFt/jzzzDM3Hsfbb7/d7H6aFrFubm5t7q+urk748f4V/FXn/uY/QletWtXqObt+/XqL+1Gue3lkZGTc2H9ISIi0ePFi6ccff5TOnz8vHTlyRFq0aJFkYmJy4z7Lli1rcV+3+3UfHR0tmZmZSYBkYWEhvf3229Lp06elw4cPS/PmzbvxHDt06CCVl5cLH2fKlCk39jVkyBBp586dUnh4uLRy5UrJz8/vxm3Lly9vcR+ZmZmSs7OzBEgGBgbSs88+K504cUI6ceKE9Oyzz0oGBgY3xIjMzEzhx/pX8Wef+/Xr199YKA0fPlz65JNPpCNHjkgXLlyQdu/eLU2cOPHGMczMzKSoqKgW99W0iB09enSr13BCQoIeZ+Sv46+47m8Wb9p671dUVLS4H+W6l0dFRcUt/d1y89+vp06danZf/6Tr/mbRw9PTU7rrrrv+NPFG+bxXUPh/FPFG4bZi2bJl0saNG6WkpKQb/63pl90fKd4UFxdLNjY2EiB5eXlJ+fn5v7m9oaFBGjVq1I1fCMePH292P6tXr75xn4ULF/7u9qSkJMnKykoCpPbt20v19fV/2HP4o7n5D8MPPvjgd7efPn36xi+3IUOG/KmPpWfPnhIgqVQqKS0trdn7NC1i/w7fULXFX3XubxZv2vpmtjWU614emZmZ0rBhw6QzZ860eJ+zZ89KpqamEuicPmVlZc3e73a/7pvckwYGBtLp06d/d/sHH3xw43y//vrrQsc4duzYjX2MGjVKamho+M3t+fn5kpeX140vAYqLi5vdz80upm3btv3u9m3btt24ffbs2UKP9a/kzz73W7ZskR566KEWP5MlSZI+//zzG8e44447Wrxf0+/1P3qR97/ir7jub/6s0gfluv/jKS4uvuFK8/f3b/F+/6Tr/tVXX5X27Nkj5ebmSpIkSdeuXftTxBvl815B4bco4o3Cbc+fId7c/Mt88+bNzd4nIyND0mg0EiCNHDmy2fsEBwff+IVRWVnZ7H3efffdG8f6/vvv/7Dn8EdSV1d3Q8wKCgqSGhsbm73fQw89dOO5REZG/imPJT4+/jffsLTE7b6IvVX+ynP/R4k3ynX/5/D000/fOM6OHTuavc/tfN2Hh4ffePwPPfRQs/dpbGyUgoKCblw/Iu6ge+65RwKdsysjI6PZ+2zevPnGY/nwww9/d3tubu6Nz/fhw4e3eKzhw4ffOFbTIuV25K8697dC9+7dJdA5dAoKCpq9zz9pEftXnfs/QrxRrvs/57pfunTpLQlE/6Tr/r/5s8Qb5fNeQeG3KIHFCv9Kdu7cCYCVlRVjx45t9j4eHh4MHToUgIMHD1JRUfGb25OSkm6Esk6cOBEzM7Nm93NzcNuOHTv0fOR/DseOHbsRMjlz5kzU6uY/Gv6K57Ju3bob/545c+afcozbidvp3N8KynX/5z2XIUOG3Pj3rYQX3240fa4CzJ49u9n7qNVqZsyYAUBxcfEtBaveTEVFBYcPHwZg2LBheHh4NHu/sWPHYmVlBTT/mu3evZvGxsZWHyv8/2vf2NjI7t27ZT3Wv5K/4tzfKk1hrVqtlmvXrv0px7iduJ3OfVso1/2fc+6b/m5RqVRMnz79D9//vxXl815B4fco4o3Cv466ujrCw8MB6NOnD0ZGRi3ed9CgQQDU1tYSERHxm9t++eWX392vOVxcXAgICADg5MmTwo/7z+RWn0v37t0xNzcH/pznIkkSGzduBMDc3JwHHnjgDz/G7cbtcu5vFeW6//OeS21t7Y1/tyQk3c40nU9zc3PCwsJavN/N51ru+QwPD79xnlp7zYyMjOjdu/eNberr65t9rG3tR5/H+lfyV5z7W+Xvfh3L5XY6922hXPd//PNJSUnh9OnTAAwYMABfX98/dP//ZpTPewWF3/PP/62qoPBfJCUl0dDQAECHDh1ave/Nt1+5cuU3t938/291PxkZGVRWVsp6vH8Ft/pcDAwM8PPz+902fxTHjh0jLS0N0H2TYmFh0eY2hYWFDBgwABsbG4yNjXF1dWX48OF8+eWXf2gl8Z/F/+rcv/jii3h4eGBkZIStrS2hoaE8+eSTJCYm/iGP9+bblev+1jh+/PgtPR64Pa/7pnPj7++PgYFBi/dr7XP1Vo/x3/tp7TgNDQ0kJSU1ux9ra2tcXFxa3Ierq+uNb3T/zNdeX/6Kc3+rNF3HBgYG+Pv7t3rfEydO0KVLF8zNzTEzM8PX15eJEyeyc+dOJEn6Ux7fH83/4twPGzYMe3t7jIyMcHJyYvDgwbz33nsUFxff0mNVrvs/DhG38D/huv8rUD7vFRR+jyLeKPzryMjIuPHvliyYTXh6eja7neh+JEkiMzPzlh/rX0XTczE3N8fGxqbV+zY9l/z8/N98w/pHcPMfQU0257aoqKjg5MmTlJaWUldXR25uLgcOHOCxxx4jICDgxjdityv/q3N/5swZsrKyqK+vp6SkhOjoaD799FOCgoJ47bXXWvwDUrnu//jrHiAnJ4fVq1cD4ODg8JsRqua43a77mpoaCgoKgLavC1tb2xtOpv/+XG2LP/rzu6193LwfuY/1r+KvOve3wr59+4iJiQFg+PDhNxZCLXHt2jViY2Opqqqiurqa1NRUtm3bxv3338+A/2vv3oOjKs84jv82VxKRIAGCqRgFGwekoJkCOoBA1QBhIrRAgVpLKdEwNR1pO9baGiDTMVVr6zAtKnQCYdKgJXUkYkBSLnaiLAk3C50aIJUCIgIBY2owJBve/sHkGJLNXpKTzQl+PzM7s3Leffd5nzye7D45lwkTdOrUKdtjtFN35X7btm26cOGCGhsbde7cOf3jH//QU089pSFDhqi4uLjd11H39q/nL3/5iyQpJiZGs2fPDug1Pb3uQ4X9PdBW+21q4Br1v//9z3ru78iO5l/2ktpc88aueZygeS2BHOnSei3R0dG2xHDx4kW9/vrrkq78gv3Wt77lc7zL5dLdd9+t9PR0paSkKCEhQfX19Tp06JDy8vJUUVGhU6dOKTU1VWVlZbrrrrtsidNuoc79jTfeqO985zsaP368hgwZooiICJ04cUKbNm1SQUGBGhsblZOTo4aGBuXm5rYbbyAxU/eBMcZo8eLFVjzZ2dmKiYnxOtapdR9MXUhX8llXVxd0Xdi9/w7mZ+/EGpZCl3t/Lly4oMcee0ySFB4ert/85jftjo2KitKDDz6o1NRUjRgxQnFxcaqpqZHb7dbLL7+skydP6r333tMDDzwgt9utuLg4W2O1S6hz/41vfEMzZ87UmDFjlJiYqMbGRh0+fFiFhYUqLS1VTU2NZs2apU2bNmnatGntxkvd26OsrEwffvihJOnb3/6232bltVL3ocL+HmiL5g2+curr663nvq53I+mqL2hffPFFl8zjBM1r8bcOqevWsnHjRusX7Pe//32/10p48cUXvR4tcc899+iRRx7R008/rdzcXNXV1SkjI0N79+6Vy+WyLV67hDL3o0eP1vHjxxUZGXnVv6ekpGjmzJnKzMxUamqqPvvsMz377LP67ne/qzvvvNNrvIHETN0HJjc317o44uTJk5WVldXuWKfWfTB1IX2Zz2Bzaff+uytjDZVQ5d6XpqYmPfTQQ9Zpr08//bTPxmFFRYXXOp40aZKysrI0e/ZslZaW6oMPPlBOTo7+8Ic/2BarnUKZ+yVLlmj58uVt/n3s2LH6wQ9+oFWrVmnx4sVqampSRkaGqqqq2jSBqXt711NQUGA9D+Ro4Wul7kOF/T3QFqdNIWgej0cul6vTj/z8/G6Jv1evXtbzhoYGn2Nbnh7R+kOQXfMEo6ty37wWf+uwcy2tBXvKlK/TXFwul5555hnrbmH79+/v9Gkk10Lur7vuujaNm5bGjBmjlStXSrpyNEjz85aoe3vrvrCwUNnZ2ZKkW265RevXr/fZuAx13QcqmLqQvsxnsLm0e//dlbGGSqhy78uPf/xjvf3225Kk6dOnWzXdHl91fP3112vDhg2Kj4+XJK1evTqgdXWHUObe36mdmZmZysjIkCR9/PHHXu+6Q93bt55Lly6pqKhIkpSYmGjtd325Vuo+VNjfA23RvMFXzvXXX28993dYZMuLrLY+3NKueZygeS2BHCbaFWs5ffq0tm3bJunK0SHDhg2zZd7MzEzrecuLwTpJd+e+tblz51qHanvLGXVv31pKSkq0cOFCGWOUkJCgv//97z4vphio7qj7YOpC+jKfwebS7v13V8YaKqHKfXueeuoprV69WpI0fvx4FRUVKTw8vFNzxsXFad68eZKuxLt3795Ox9kVujv3rfn7f5+6t289xcXFqqmpkSQ99NBDna55qefUfaiwvwfa4rQpBC0iIsKWq7DfeOONNkQTvJYXLPN3EdWWFyxreTE0b/P079/f7zwulyugC6a1p6tyf9NNN6m8vFx1dXWqqanx+deh5rUMGDDAtut+FBYWqqmpSVLgFyoOxPDhw63nnb0A4LWa+9YiIiKUnJysPXv2eM0ZdW9P7t955x3Nnj1bjY2NuuGGG1RaWur3zjyBsrPuA9WrVy/1799f1dXVfvern376qfUBufV+1Z/W9ffNb36z3bH+9t9nzpwJ6ELazfMEG2uohCr33jz33HN69tlnJV05/fKtt96y7S/W3VHHwerO3HvjL2fUvX3r6cgNFgLRE+o+VNjfA23RvEGH+Ltln5MlJycrPDxcTU1Nqqys9Dm25fbWR4O0/AVbWVnZ5tog3uYZPHjwVRdV64iuyP3w4cOtiwVXVlbq7rvv9jrO4/HoP//5j6S2+eiM5vPGIyMjNX/+fNvmtfuWm9di7r3xlTfqvvO5r6ioUHp6uurr69W7d29t2bJFI0eO7PS8zbrrVrPDhg1TWVmZqqqq5PF42r11r6/9qj+t68+X5u3eblk9fPhw7du3T5999pk++eSTdo94On36tGprazsUayiFIvetvfTSS/rlL39pzbV161ZbL7DaU26Z3B25b4+/nFH39qzn7Nmz2rp1q6QrTcsRI0Z0es5mPaXuQ4H9PdAWp03hKycqKkpjxoyRdOV2yb7OgW0+7Dg6OrpNx3/8+PFtxnnzySef6MiRI5KkcePGdTjurhToWvbu3Wv99cqutbz//vvWrWWnT59une9th3//+9/W88TERNvmtVN35t4bj8dj1au3nFH3nVvLwYMHNXXqVH3++efq1auXNm3apLFjx3Zqzta6q+6b81lXV6d9+/a1O65lroPN5+jRo62LTvr6mTU0NGj37t1tXtM6Vn/zdCbWUApF7lsqKCiwLqw9ZMgQbdu2zedReB3RE/bfUuhz74u/nFH39qxn/fr18ng8kuw96kbqOXUfCuzvAS8M4HBJSUlGkklKSrJtzueee85IMpLMq6++6nXMyZMnTXh4uJFk0tLSvI4ZNmyYkWT69etn6urqvI757W9/a73Xhg0bbFuDnS5dumTi4uKMJDNs2DBz+fJlr+MyMzOttVRUVNjy3j/96U+tOd944w1b5mx23333WXOXlZXZOrddujP33hQUFFjvs2jRIq9jqPuOOXz4sElISDCSTGRkpCkpKenwXL50V92Xl5db75uZmel1TFNTk1U/ffv2NQ0NDUG/z7Rp04wkExERYU6ePOl1zKuvvmrF8vzzz7fZfvr0aRMWFmYkmSlTprT7XlOmTDGSTFhYmDl9+nTQsYZKqHJvjDGvv/669bvxpptuMseOHetE5N7V1NSY+Ph4I8nExsaa+vp629/DLqHMvT+LFi2yYikoKGiznbq3J/d33XWXtQ86e/Zsp+dr1pPqvrVjx45ZP4sFCxbYNi/7e+BqNG/geME2b1r+Apk4caLXMefPn7e+tCUlJZnq6uqrtns8HpOenm7Ns2PHDq/z5OXlWWMee+yxNturqqpMnz59jCQzdOhQ09jYGNAaukN2drbPX367du0yERERPvMaSO5b8ng8ZtCgQUaSiY+PD/hDldvtNh9//HG72y9fvmx+/etfW7GMGjWq3S/mThCK3F+4cMHs3LnTZxzl5eWmb9++RpJxuVxmz549XsdR91cLpO6PHz9uBg8ebCSZ8PBwU1RUFHSsPaHuJ0yYYH3Q3rVrV5vtzz//vBXfsmXL2mxfu3atz+3GGLN9+3ZrzIMPPmg8Hs9V28+dO2duvvlm68vahQsXvM7z8MMPW/N4+3ls2LChS76MdJVQ5H7r1q0mKirKSDIDBw40lZWVQce5ZcsWc/HixXa319bWmtTUVCuWn/zkJ0G/R6h1de4PHjxojh496jOGV155xZpj0KBB5vPPP/c6jrq/WiB139K//vUva3x6enrAcV6Ldd9SR5o37O+B4NG8gaMcPXrUrF279qpH818h4uPj22zz1hkPtIHQ8oPO0KFDzZo1a8yePXtMcXGxmTx5srVt/vz57c7h8XjMuHHjrLGzZs0yb7/9tikvLzd//OMfzcCBA60u/ubNm+1IUZepra01ycnJ1loeffRRs2PHDuN2u01ubq7p3bu3kWRiYmLMgQMHvM4RbPOmpKTEGp+VlRVwrMuWLTPR0dFmxowZ5k9/+pPZsWOH2b9/v3G73WbVqlVmzJgx1ryxsbFdeqSKHUKR++btI0eONEuXLjXFxcWmoqLC7Nu3z7zxxhvmRz/6kYmMjLTmeOKJJ9qNl7q/mr/cV1dXm69//evWmF/84hfm0KFDPh8fffRRm3l6Qt3v37/fxMTEGEmmd+/eJjc317jdbrNjxw7z6KOPWvElJyeb2traNq8P9IvUvHnzrHGTJ082xcXFZs+ePWbNmjVm6NCh1rZXXnml3TlOnDhhBgwYYH3xe/LJJ01ZWZkpKyszTz75pNW0GzBgQLt/8XWSrs692+02sbGxRrpy5FhhYaHfOv7000/bzDNx4kTTr18/k5GRYfLz801ZWZk5cOCA2blzp8nNzbWanJLM7bffbs6fP98F2bJXV+d+7dq1Jjw83Nx///3m97//vSktLTX79u0z5eXlZt26deaBBx6wXh8eHm6Ki4vbjZW6v1qwzZsnnnjCGv+3v/0t4DivtbovKyu76vP47373Oyv+cePGtfm87g37eyB4NG/gKC135IE8vB1JEEwDYenSpcblcrU7f1pamvniiy98znHu3DkzevTodueIiooyq1ev7kRWQufo0aNXfcls/ejTp4/ZtGlTu68Ptnkzd+5ca3wwXzSXLVsWUH3cfPPN5t133w143u7U1blvud3XIzw83CxfvtzvERvU/Zf85X7nzp1B7dck73/56yl1/+abb1pHXnl7JCcnt3sUQaAf5i9evGjS0tLafY+wsLCAvojt3r3bOvrP22PQoEFm9+7dHcxE6HVl7gOtv5YPb1/aJk6cGNBr7733Xq9NTKfqytwH+tkoPj7ebNy40W+s1P2XgmneNDU1ma997WtGkrnhhhuCOq3pWqv7BQsWBLUv8Ib9PRA87jaFr7ScnBxNmTJFK1euVFlZmc6cOaO+fftq1KhRWrhwYUB3Purfv7927dqlP//5z1q/fr0++OAD1dXVKTExUffdd58ef/xx3XHHHSFYTefddtttOnDggFauXKmioiJVVVWpoaFBgwcPVlpamh5//HElJSXZ8l61tbV68803JV25k9Do0aMDfu3ChQuVkJAgt9utgwcP6uzZszp//rwiIiLUv39/paSkKD09Xd/73vfUq1cvW+Ltal2d+8TERBUVFcntdquiokKnTp1SdXW16uvrFRcXp9tvv12TJk1SRkaGbrnlFr/zUfeh11PqPj09XQcPHtSKFStUUlKijz76SFFRUbrttts0Z84cZWVlKTY2tlPvERMTo5KSEq1fv175+fn65z//qZqaGiUkJGjChAnKysrSPffc43eesWPH6tChQ1qxYoU2btyo//73v5KkW2+9VTNmzNCSJUtsvYh6VwtF7jvrhRde0Pbt2+V2u3X48GFVV1erpqZGsbGxSkxM1NixYzV//nylpqbK5XJ1a6zB6Mrcp6WlKS8vT263WwcOHNCZM2d0/vx5GWPUr18/jRo1SlOnTtUPf/hD9enTx+981H3HbN++3bp999y5cxUdHR3wa6/Vug8F9vfAl1zGcE86AAAAAAAAp+JW4QAAAAAAAA5G8wYAAAAAAMDBaN4AAAAAAAA4GM0bAAAAAAAAB6N5AwAAAAAA4GA0bwAAAAAAAByM5g0AAAAAAICD0bwBAAAAAABwMJo3AAAAAAAADkbzBgAAAAAAwMFo3gAAAAAAADgYzRsAAAAAAAAHo3kDAAAAAADgYDRvAAAAAAAAHIzmDQAAAAAAgIPRvAEAAAAAAHAwmjcAAAAAAAAORvMGAAAAAADAwWjeAAAAAAAAOBjNGwAAAAAAAAejeQMAAAAAAOBgNG8AAAAAAAAcjOYNAADokerq6pSQkCCXy6UhQ4aosbHR67j6+nqNHz9eLpdL0dHReuedd0IbKAAAQCfRvAEAAD3Sddddp1/96leSpGPHjik/P7/NGGOMHn74Yb333ntyuVxat26dJk2aFNpAAQAAOslljDHdHQQAAEBHXLp0ScnJyTpx4oSSkpJ05MgRRUVFWdt/9rOf6cUXX5QkvfDCC/r5z3/eXaECAAB0GEfeAACAHis6OlpLly6VJB0/flxr1qyxtq1YscJq3CxZsoTGDQAA6LE48gYAAPRoTU1NGj58uI4cOaLBgwerqqpKb731lubMmaPLly9rzpw5eu211xQWxt+sAABAz0TzBgAA9Hh//etfNW/ePEnSokWLVFhYqPr6et17770qLS1VdHR0N0cIAADQcTRvAABAj2eMUUpKit5//33r3+644w69++676tu3b7fFBQAAYAeOHwYAAD2ey+XSI488Yv33wIEDtWXLFho3AADgmkDzBgAA9HhHjx7VsmXLrP+uq6vjVCkAAHDNoHkDAAB6tLNnz2rq1Kmqrq5WfHy8pCvNm2eeeaabIwMAALAHzRsAANBj1dXVafr06frwww/Vu3dvlZaWaubMmZKkVatW6cSJE90bIAAAgA1o3gAAgB7J4/Fozpw52rt3ryIiIrRhwwalpKQoJydHLpdLly5dUk5OTneHCQAA0Gk0bwAAQI+0ePFibdmyRZL08ssva9q0aZKkkSNHatasWZKkdevW6ciRI90WIwAAgB1o3gAAgB5n+fLlysvLkyRlZ2crIyOjzfawsDA1NTUpOzu7O0IEAACwjcsYY7o7CAAAgEDl5eVZzZoFCxYoPz/f67j58+frtddek8vl0v79+3XnnXeGLkgAAAAb0bwBAAA9xubNmzVjxgx5PB7df//92rx5syIjI72Orays1IgRI9TU1KS0tDSVlJSEOFoAAAB70LwBAAAAAABwMK55AwAAAAAA4GA0bwAAAAAAAByM5g0AAAAAAICD0bwBAAAAAABwMJo3AAAAAAAADkbzBgAAAAAAwMFo3gAAAAAAADgYzRsAAAAAAAAHo3kDAAAAAADgYDRvAAAAAAAAHIzmDQAAAAAAgIPRvAEAAAAAAHAwmjcAAAAAAAAORvMGAAAAAADAwWjeAAAAAAAAOBjNGwAAAAAAAAejeQMAAAAAAOBgNG8AAAAAAAAcjOYNAAAAAACAg9G8AQAAAAAAcDCaNwAAAAAAAA5G8wYAAAAAAMDBaN4AAAAAAAA4GM0bAAAAAAAAB6N5AwAAAAAA4GD/B0s9sGh4PQDvAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -780,8 +778,6 @@ "accelerations = np.array([i[1][:] for i in gravity_results])\n", "accelerations = np.delete(accelerations, 2, 1)\n", "\n", - "accelerations = -1 * accelerations\n", - "\n", "\n", "fig, ax = plt.subplots()\n", "\n", diff --git a/script/torus_plots.py b/script/torus_plots.py index 18ad970..2fc8bc6 100644 --- a/script/torus_plots.py +++ b/script/torus_plots.py @@ -45,7 +45,6 @@ # We just want a slice of x, y values for z = 0 accelerations = np.array([i[1][:] for i in gravity_results]) acc_xy = np.delete(accelerations, 2, 1) -acc_xy = -1 * acc_xy mesh_plotting.plot_quiver(X, Y, acc_xy, "Acceleration in $x$ and $y$ direction for $z=0$", "../figures/torus/torus_field_xy.png", vertices=vertices, coordinate=2) @@ -72,7 +71,6 @@ # We just want a slice of x, y values for z = 0 accelerations = np.array([i[1][:] for i in gravity_results]) acc_xy = np.delete(accelerations, 1, 1) -acc_xy = -1 * acc_xy mesh_plotting.plot_quiver(X, Z, acc_xy, "Acceleration in $x$ and $z$ direction for $y=0$", "../figures/torus/torus_field_xz.png", labels=('$x$', '$z$'), @@ -101,7 +99,6 @@ # We just want a slice of x, y values for z = 0 accelerations = np.array([i[1][:] for i in gravity_results]) acc_xy = np.delete(accelerations, 0, 1) -acc_xy = -1 * acc_xy mesh_plotting.plot_quiver(Y, Z, acc_xy, "Acceleration in $y$ and $z$ direction for $x=0$", "../figures/torus/torus_field_yz.png", labels=('$y$', '$z$'), From 1a297bd50b3cff5875e641f5c398ca3ff9bf4f99 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Sun, 21 Apr 2024 20:31:37 +0200 Subject: [PATCH 52/54] fix inconsistent indentation --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 1d8432a..a311b8f 100644 --- a/README.md +++ b/README.md @@ -327,7 +327,7 @@ cmake .. -POLYHEDRAL_GRAVITY_PARALLELIZATION="TBB" After the build, the gravity model can be run by executing: ```bash - ./polyhedralGravity +./polyhedralGravity ``` where the YAML-Configuration-File contains the required parameters. From 8f7f1f25d7bf32996d7caf70e259ec04bec530f9 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Sun, 21 Apr 2024 20:33:18 +0200 Subject: [PATCH 53/54] fix legacy reference --- README.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/README.md b/README.md index a311b8f..22805c9 100644 --- a/README.md +++ b/README.md @@ -315,8 +315,7 @@ The following options are available: During testing POLYHEDRAL_GRAVITY_PARALLELIZATION=`TBB` has been the most performant. It is further not recommend to change the LOGGING_LEVEL to something else than `INFO=2`. -The recommended CMake command would look like this (we only need to change `PARALLELIZATION_DEVICE`, since -the defaults of the others are already correctly set): +The recommended CMake settings using the `TBB` backend would look like this: ```bash cmake .. -POLYHEDRAL_GRAVITY_PARALLELIZATION="TBB" From bc7c21fb153f4541b2e9842c383f10decf30fbd3 Mon Sep 17 00:00:00 2001 From: Jonas Schuhmacher Date: Sun, 21 Apr 2024 20:54:57 +0200 Subject: [PATCH 54/54] remove wrong comments --- script/time.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/script/time.py b/script/time.py index cbfa3c7..492225f 100755 --- a/script/time.py +++ b/script/time.py @@ -32,7 +32,6 @@ def run_time_measurements(sample_size: int = 1000) -> Dict[str, float]: end_time = timeit.default_timer() delta = (end_time - start_time) / sample_size * 1e6 - # Print the time in milliseconds print("######## Old Single-Point ########") print(f"--> {sample_size} times 1 point with old interface") print(f"--> Time taken: {delta:.3f} microseconds per point") @@ -43,7 +42,6 @@ def run_time_measurements(sample_size: int = 1000) -> Dict[str, float]: end_time = timeit.default_timer() delta = (end_time - start_time) / sample_size * 1e6 - # Print the time in milliseconds print("######## Old Multi-Point ########") print(f"--> 1 time {sample_size} points with old interface") print(f"--> Time taken: {delta:.3f} microseconds per point") @@ -57,7 +55,6 @@ def run_time_measurements(sample_size: int = 1000) -> Dict[str, float]: end_time = timeit.default_timer() delta = (end_time - start_time) / sample_size * 1e6 - # Print the time in milliseconds print("######## GravityEvaluable (Single-Point) #########") print(f"--> {sample_size} times 1 point with GravityEvaluable") print(f"--> Time taken: {delta:.3f} microseconds per point") @@ -70,7 +67,6 @@ def run_time_measurements(sample_size: int = 1000) -> Dict[str, float]: end_time = timeit.default_timer() delta = (end_time - start_time) / sample_size * 1e6 - # Print the time in milliseconds print("######## GravityEvaluable (Multi-Point) ########") print(f"--> 1 time {sample_size} points with GravityEvaluable") print(f"--> Time taken: {delta:.3f} microseconds per point")