From b1313374fc982b355d5ff884717eee46dc15b8b7 Mon Sep 17 00:00:00 2001 From: JcDai Date: Wed, 4 Dec 2024 16:38:55 -0500 Subject: [PATCH 01/11] add msh obj writers --- src/exec/view_quadratic_spline.cpp | 50 ++++---- src/quadratic_spline_surface/CMakeLists.txt | 1 + .../quadratic_spline_surface.h | 77 ++++++------ .../quadratic_spline_surface_msh_writer.cpp | 117 ++++++++++++++++++ 4 files changed, 183 insertions(+), 62 deletions(-) create mode 100644 src/quadratic_spline_surface/quadratic_spline_surface_msh_writer.cpp diff --git a/src/exec/view_quadratic_spline.cpp b/src/exec/view_quadratic_spline.cpp index 3ad8c41..f4b346d 100755 --- a/src/exec/view_quadratic_spline.cpp +++ b/src/exec/view_quadratic_spline.cpp @@ -1,28 +1,23 @@ // Copyright 2023 Adobe Research. All rights reserved. // To view a copy of the license, visit LICENSE.md. -#include "common.h" -#include "globals.cpp" #include "apply_transformation.h" -#include "generate_transformation.h" +#include "common.h" #include "compute_boundaries.h" #include "contour_network.h" +#include "generate_transformation.h" +#include "globals.cpp" #include "twelve_split_spline.h" +#include #include #include -#include - -int main(int argc, char *argv[]) -{ +int main(int argc, char *argv[]) { // Build maps from strings to enums - std::map log_level_map { - {"trace", spdlog::level::trace}, - {"debug", spdlog::level::debug}, - {"info", spdlog::level::info}, - {"warn", spdlog::level::warn}, - {"critical", spdlog::level::critical}, - {"off", spdlog::level::off}, + std::map log_level_map{ + {"trace", spdlog::level::trace}, {"debug", spdlog::level::debug}, + {"info", spdlog::level::info}, {"warn", spdlog::level::warn}, + {"critical", spdlog::level::critical}, {"off", spdlog::level::off}, }; // Get command line arguments @@ -35,14 +30,16 @@ int main(int argc, char *argv[]) OptimizationParameters optimization_params; double weight = optimization_params.position_difference_factor; app.add_option("-i,--input", input_filename, "Mesh filepath") - ->check(CLI::ExistingFile) - ->required(); + ->check(CLI::ExistingFile) + ->required(); app.add_option("--log_level", log_level, "Level of logging") - ->transform(CLI::CheckedTransformer(log_level_map, CLI::ignore_case)); - app.add_option("--num_subdivisions", num_subdivisions, "Number of subdivisions") - ->check(CLI::PositiveNumber); - app.add_option("-w,--weight", weight, "Fitting weight for the quadratic surface approximation") - ->check(CLI::PositiveNumber); + ->transform(CLI::CheckedTransformer(log_level_map, CLI::ignore_case)); + app.add_option("--num_subdivisions", num_subdivisions, + "Number of subdivisions") + ->check(CLI::PositiveNumber); + app.add_option("-w,--weight", weight, + "Fitting weight for the quadratic surface approximation") + ->check(CLI::PositiveNumber); CLI11_PARSE(app, argc, argv); // Set logger level @@ -66,9 +63,14 @@ int main(int argc, char *argv[]) energy_hessian_inverse; AffineManifold affine_manifold(F, uv, FT); TwelveSplitSplineSurface spline_surface( - V, affine_manifold, - optimization_params, face_to_patch_indices, patch_to_face_indices, - fit_matrix, energy_hessian, energy_hessian_inverse); + V, affine_manifold, optimization_params, face_to_patch_indices, + patch_to_face_indices, fit_matrix, energy_hessian, + energy_hessian_inverse); + + // output to obj + spline_surface.write_corner_patch_points_to_obj("sphere_powell_sabon.obj"); + spline_surface.write_cubic_nodes_to_msh("sphere_ps_cubic.msh"); + spline_surface.write_cubic_nodes_to_obj("sphere_ps_cubic_nodes.obj"); // View the mesh spline_surface.view(color, num_subdivisions); diff --git a/src/quadratic_spline_surface/CMakeLists.txt b/src/quadratic_spline_surface/CMakeLists.txt index 789157b..9a57855 100755 --- a/src/quadratic_spline_surface/CMakeLists.txt +++ b/src/quadratic_spline_surface/CMakeLists.txt @@ -6,6 +6,7 @@ add_library(QuadraticSplineSurfaceLib quadratic_spline_surface.cpp quadratic_spline_surface_patch.cpp twelve_split_spline.cpp + quadratic_spline_surface_msh_writer.cpp ) target_include_directories(QuadraticSplineSurfaceLib PUBLIC .) target_link_libraries(QuadraticSplineSurfaceLib PUBLIC diff --git a/src/quadratic_spline_surface/quadratic_spline_surface.h b/src/quadratic_spline_surface/quadratic_spline_surface.h index 2b27c53..002110b 100644 --- a/src/quadratic_spline_surface/quadratic_spline_surface.h +++ b/src/quadratic_spline_surface/quadratic_spline_surface.h @@ -12,8 +12,7 @@ #include /// Parameters for the discretization of a quadratic spline -struct SurfaceDiscretizationParameters -{ +struct SurfaceDiscretizationParameters { /// Number of subdivisions per triangle of the domain int num_subdivisions = 2; @@ -31,8 +30,7 @@ struct SurfaceDiscretizationParameters /// - visualization /// - (basic) rendering /// - (de)serialization -class QuadraticSplineSurface -{ +class QuadraticSplineSurface { public: // Index type typedef size_t PatchIndex; @@ -43,7 +41,7 @@ class QuadraticSplineSurface /// Constructor from patches /// /// @param[in] patches: quadratic surface patches - QuadraticSplineSurface(std::vector& patches); + QuadraticSplineSurface(std::vector &patches); /// Get the number of patches in the surface /// @@ -53,8 +51,7 @@ class QuadraticSplineSurface /// Get a reference to a spline patch /// /// @return spline patch - QuadraticSplineSurfacePatch const& get_patch(PatchIndex patch_index) const - { + QuadraticSplineSurfacePatch const &get_patch(PatchIndex patch_index) const { return m_patches[patch_index]; } @@ -63,10 +60,9 @@ class QuadraticSplineSurface /// @param[in] patch_index: index of the patch to evaluate /// @param[in] domain_point: point in the patch domain to evaluate /// @param[out] surface_point: output point on the surface - void evaluate_patch(const PatchIndex& patch_index, - const PlanarPoint& domain_point, - SpatialVector& surface_point) const - { + void evaluate_patch(const PatchIndex &patch_index, + const PlanarPoint &domain_point, + SpatialVector &surface_point) const { get_patch(patch_index).evaluate(domain_point, surface_point); } @@ -75,10 +71,9 @@ class QuadraticSplineSurface /// @param[in] patch_index: index of the patch to evaluate /// @param[in] domain_point: point in the patch domain to evaluate /// @param[out] surface_point: output point on the surface - void evaluate_patch_normal(const PatchIndex& patch_index, - const PlanarPoint& domain_point, - SpatialVector& surface_normal) const - { + void evaluate_patch_normal(const PatchIndex &patch_index, + const PlanarPoint &domain_point, + SpatialVector &surface_normal) const { get_patch(patch_index).evaluate_normal(domain_point, surface_normal); } @@ -94,8 +89,8 @@ class QuadraticSplineSurface /// /// @param[in] patch_indices: indices of the patches to keep /// @return subsurface with the given patches - QuadraticSplineSurface subsurface( - const std::vector& patch_indices) const; + QuadraticSplineSurface + subsurface(const std::vector &patch_indices) const; /// Triangulate a given patch /// @@ -104,11 +99,9 @@ class QuadraticSplineSurface /// @param[out] V: vertices of the triangulation /// @param[out] F: faces of the triangulation /// @param[out] N: vertex normals - void triangulate_patch(const PatchIndex& patch_index, - int num_refinements, - Eigen::MatrixXd& V, - Eigen::MatrixXi& F, - Eigen::MatrixXd& N) const; + void triangulate_patch(const PatchIndex &patch_index, int num_refinements, + Eigen::MatrixXd &V, Eigen::MatrixXi &F, + Eigen::MatrixXd &N) const; /// Triangulate the surface. /// @@ -116,10 +109,9 @@ class QuadraticSplineSurface /// @param[out] V: vertices of the triangulation /// @param[out] F: faces of the triangulation /// @param[out] N: vertex normals - void discretize(const SurfaceDiscretizationParameters& surface_disc_params, - Eigen::MatrixXd& V, - Eigen::MatrixXi& F, - Eigen::MatrixXd& N) const; + void discretize(const SurfaceDiscretizationParameters &surface_disc_params, + Eigen::MatrixXd &V, Eigen::MatrixXi &F, + Eigen::MatrixXd &N) const; /// Triangulate the surface. /// @@ -131,20 +123,20 @@ class QuadraticSplineSurface Eigen::MatrixXi, // F Eigen::MatrixXd // N > - discretize(const SurfaceDiscretizationParameters& surface_disc_params) const; + discretize(const SurfaceDiscretizationParameters &surface_disc_params) const; /// Discretize all patch boundaries as polylines /// /// @param[out] points: list of polyline points /// @param[out] polylines: list of lists of polyline edges - void discretize_patch_boundaries( - std::vector& points, - std::vector>& polylines) const; + void + discretize_patch_boundaries(std::vector &points, + std::vector> &polylines) const; /// Save the triangulated surface as an obj /// /// @param[in] filename: filepath to save the obj - void save_obj(const std::string& filename) const; + void save_obj(const std::string &filename) const; /// Add the surface to the viewer /// @@ -166,7 +158,7 @@ class QuadraticSplineSurface /// @param[in] camera_position: camera position for the screenshot /// @param[in] camera_target: camera target for the screenshot /// @param[in] use_orthographic: use orthographic perspective if true - void screenshot(const std::string& filename, + void screenshot(const std::string &filename, SpatialVector camera_position = SpatialVector(0, 0, 2), SpatialVector camera_target = SpatialVector(0, 0, 0), bool use_orthographic = false) const; @@ -174,22 +166,22 @@ class QuadraticSplineSurface /// Serialize the surface /// /// @param[in] out: output stream for the surface - void serialize(std::ostream& out) const; + void serialize(std::ostream &out) const; /// Deserialize a surface /// /// @param[in] in: input stream for the surface - void deserialize(std::istream& in); + void deserialize(std::istream &in); /// Write the surface serialization to file /// /// @param[in] filename: file path for the serialized surface - void write_spline(const std::string& filename) const; + void write_spline(const std::string &filename) const; /// Read a surface serialization from file /// /// @param[in] filename: file path for the serialized surface - void read_spline(const std::string& filename); + void read_spline(const std::string &filename); /// Compute hash tables for the surface void compute_patch_hash_tables(); @@ -198,7 +190,7 @@ class QuadraticSplineSurface /// /// @param[in] point: point in the plane /// @return pair - std::pair compute_hash_indices(const PlanarPoint& point) const; + std::pair compute_hash_indices(const PlanarPoint &point) const; /// Hash table data std::vector hash_table[HASH_TABLE_SIZE][HASH_TABLE_SIZE]; @@ -206,7 +198,7 @@ class QuadraticSplineSurface /// Hash table parameters double patches_bbox_x_min, patches_bbox_x_max, patches_bbox_y_min, - patches_bbox_y_max; + patches_bbox_y_max; double hash_x_interval; double hash_y_interval; @@ -216,4 +208,13 @@ class QuadraticSplineSurface void compute_patches_bbox(); std::vector m_patches; + + //-------------------- code for c1 meshing --------------------// +public: + void write_cubic_nodes_to_msh(std::string filename); + void write_cubic_nodes_to_obj(std::string filename); + + void write_corner_patch_points_to_obj(std::string filename); + + //-------------------------------------------------------------// }; diff --git a/src/quadratic_spline_surface/quadratic_spline_surface_msh_writer.cpp b/src/quadratic_spline_surface/quadratic_spline_surface_msh_writer.cpp new file mode 100644 index 0000000..e917ac3 --- /dev/null +++ b/src/quadratic_spline_surface/quadratic_spline_surface_msh_writer.cpp @@ -0,0 +1,117 @@ +#include "quadratic_spline_surface.h" + +void QuadraticSplineSurface::write_cubic_nodes_to_msh(std::string filename) { + std::ofstream file(filename); + + /* + $MeshFormat + 4.1 0 8 MSH4.1, ASCII + $EndMeshFormat + */ + + file << "$MeshFormat\n" + << "4.1 0 8\n" + << "$EndMeshFormat\n"; + + // msh 10 node 3rd-order triangle nodes + const std::array normalized_vs = { + {PlanarPoint(0, 0), PlanarPoint(1., 0), PlanarPoint(0, 1.), + PlanarPoint(1. / 3., 0), PlanarPoint(2. / 3., 0), + PlanarPoint(2. / 3., 1. / 3.), PlanarPoint(1. / 3., 2. / 3.), + PlanarPoint(0, 2. / 3.), PlanarPoint(0, 1. / 3.), + PlanarPoint(1. / 3., 1. / 3.)}}; + + file << "$Nodes\n"; + + const size_t node_size = m_patches.size() * 10; + file << "1 " << node_size << " 1 " << node_size << "\n"; + file << "2 1 0 " << node_size << "\n"; + + for (size_t i = 1; i <= node_size; ++i) { + file << i << "\n"; + } + + for (const auto &patch : m_patches) { + for (const auto &normalized_v : normalized_vs) { + PlanarPoint nv = normalized_v; + auto domain_v = patch.denormalize_domain_point(nv); + SpatialVector surface_point; + patch.evaluate(domain_v, surface_point); + file << surface_point(0, 0) << " " << surface_point(0, 1) << " " + << surface_point(0, 2) << "\n"; + } + } + + file << "$EndNodes\n"; + + // write elements + const size_t element_size = m_patches.size(); + + file << "$Elements\n"; + file << "1 " << element_size << " 1 " << element_size << "\n"; + file << "2 1 21 " << element_size << "\n"; + for (size_t i = 0; i < element_size; ++i) { + file << i + 1 << " " << i * 10 + 1 << " " << i * 10 + 2 << " " << i * 10 + 3 + << " " << i * 10 + 4 << " " << i * 10 + 5 << " " << i * 10 + 6 << " " + << i * 10 + 7 << " " << i * 10 + 8 << " " << i * 10 + 9 << " " + << i * 10 + 10 << "\n"; + } + + file << "$EndElements\n"; +} + +void QuadraticSplineSurface::write_cubic_nodes_to_obj(std::string filename) { + std::ofstream file(filename); + + // msh 10 node 3rd-order triangle nodes + const std::array normalized_vs = { + {PlanarPoint(0, 0), PlanarPoint(1., 0), PlanarPoint(0, 1.), + PlanarPoint(1. / 3., 0), PlanarPoint(2. / 3., 0), + PlanarPoint(2. / 3., 1. / 3.), PlanarPoint(1. / 3., 2. / 3.), + PlanarPoint(0, 2. / 3.), PlanarPoint(0, 1. / 3.), + PlanarPoint(1. / 3., 1. / 3.)}}; + + for (const auto &patch : m_patches) { + for (const auto &normalized_v : normalized_vs) { + PlanarPoint nv = normalized_v; + auto domain_v = patch.denormalize_domain_point(nv); + SpatialVector surface_point; + patch.evaluate(domain_v, surface_point); + file << "v " << surface_point(0, 0) << " " << surface_point(0, 1) << " " + << surface_point(0, 2) << "\n"; + } + } + + // write elements + const size_t element_size = m_patches.size(); + + for (size_t i = 0; i < element_size; ++i) { + file << "f " << " " << i * 10 + 1 << " " << i * 10 + 2 << " " << i * 10 + 3 + << "\n"; + } +} + +void QuadraticSplineSurface::write_corner_patch_points_to_obj( + std::string filename) { + std::ofstream file(filename); + + const std::array normalized_vs = { + {PlanarPoint(0, 0), PlanarPoint(1, 0), PlanarPoint(0, 1)}}; + + for (const auto &patch : m_patches) { + for (const auto &normalized_v : normalized_vs) { + PlanarPoint nv = normalized_v; + auto domain_v = patch.denormalize_domain_point(nv); + SpatialVector surface_point; + patch.evaluate(domain_v, surface_point); + file << "v " << surface_point(0, 0) << " " << surface_point(0, 1) << " " + << surface_point(0, 2) << std::endl; + } + } + for (size_t i = 0; i < m_patches.size(); ++i) { + file << "f " << i * 3 + 1 << " " << i * 3 + 2 << " " << i * 3 + 3 + << std::endl; + } + + file.close(); +} \ No newline at end of file From b29839979936a7739bffea375f42ddee836715d0 Mon Sep 17 00:00:00 2001 From: JcDai Date: Mon, 9 Dec 2024 01:47:27 -0500 Subject: [PATCH 02/11] add draft ct --- CMakeLists.txt | 2 + src/clough_tocher_patches/CMakeLists.txt | 18 + .../Clough_Toucher_derivation.py | 441 +++ .../TestCloughTocher.ipynb | 3285 +++++++++++++++++ .../clough_tocher_autogen_matrix_coeffs.hpp | 396 ++ .../clough_tocher_matrices.cpp | 36 + .../clough_tocher_matrices.hpp | 5 + .../clough_tocher_patch.cpp | 148 + .../clough_tocher_patch.hpp | 55 + .../clough_tocher_surface.cpp | 0 .../clough_tocher_surface.hpp | 0 11 files changed, 4386 insertions(+) create mode 100644 src/clough_tocher_patches/CMakeLists.txt create mode 100644 src/clough_tocher_patches/Clough_Toucher_derivation.py create mode 100644 src/clough_tocher_patches/TestCloughTocher.ipynb create mode 100644 src/clough_tocher_patches/clough_tocher_autogen_matrix_coeffs.hpp create mode 100644 src/clough_tocher_patches/clough_tocher_matrices.cpp create mode 100644 src/clough_tocher_patches/clough_tocher_matrices.hpp create mode 100644 src/clough_tocher_patches/clough_tocher_patch.cpp create mode 100644 src/clough_tocher_patches/clough_tocher_patch.hpp create mode 100644 src/clough_tocher_patches/clough_tocher_surface.cpp create mode 100644 src/clough_tocher_patches/clough_tocher_surface.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 553b8d3..1c0f10a 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -41,12 +41,14 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin) add_subdirectory(src/core) add_subdirectory(src/quadratic_spline_surface) add_subdirectory(src/contour_network) +add_subdirectory(src/clough_tocher_patches) target_include_directories(QuadraticContoursCoreLib PUBLIC ${PROJECT_SOURCE_DIR}/ext ) add_library(QuadraticContoursLib INTERFACE) target_link_libraries(QuadraticContoursLib INTERFACE QuadraticContoursCoreLib QuadraticSplineSurfaceLib ContourNetworkLib + CloughTocherPatchLib ) # Build utility library diff --git a/src/clough_tocher_patches/CMakeLists.txt b/src/clough_tocher_patches/CMakeLists.txt new file mode 100644 index 0000000..025c9db --- /dev/null +++ b/src/clough_tocher_patches/CMakeLists.txt @@ -0,0 +1,18 @@ +add_library(CloughTocherPatchLib +# clough_tocher_patch.hpp + clough_tocher_patch.cpp + clough_tocher_autogen_matrix_coeffs.hpp + clough_tocher_matrices.cpp +) +target_include_directories(CloughTocherPatchLib PUBLIC .) +target_link_libraries(CloughTocherPatchLib PUBLIC + QuadraticContoursCoreLib +) +target_compile_definitions(CloughTocherPatchLib PUBLIC + SPDLOG_ACTIVE_LEVEL=SPDLOG_LEVEL_DEBUG + # SPDLOG_ACTIVE_LEVEL=SPDLOG_LEVEL_OFF +) + +target_compile_options(CloughTocherPatchLib PRIVATE + -Wall -Wpedantic -Wextra -Werror +) \ No newline at end of file diff --git a/src/clough_tocher_patches/Clough_Toucher_derivation.py b/src/clough_tocher_patches/Clough_Toucher_derivation.py new file mode 100644 index 0000000..2510dcb --- /dev/null +++ b/src/clough_tocher_patches/Clough_Toucher_derivation.py @@ -0,0 +1,441 @@ +from sympy import Rational, Matrix, symbols, det, collect, simplify, solve, diff, Eq, expand, Poly +import sympy as sp +import numpy as np + +# ********* helper functions ********* +def nxt(i): + return (i+1) % 3 +def prev(i): + return (i+2) % 3 + +# Equation of a line in homogeneous coordinates +def ep2line(a, b): + """Returns the implicit form of a line passing through points a and b.""" + return collect(det(Matrix([a.T, b.T, Matrix([[u, v, w]])])), [u, v, w]) + +def ep2param_line(a, b): + """Returns the param equation of a line passing through points a and b.""" + return a + (b - a) * t + +# Derivatives in homogeneous coordinates +# these are linearly dependent, using 3 for symmetry for variables u,v,w +def gradb(f): + return [ + (1 / Rational(2)) * (2 * diff(f, u) - diff(f, v) - diff(f, w)), + (1 / Rational(2)) * (2 * diff(f, v) - diff(f, u) - diff(f, w)), + (1 / Rational(2)) * (2 * diff(f, w) - diff(f, v) - diff(f, u)) + ] + + + +# ********* global definitions, barycentric coord symbols ********* + +u, v, w = symbols('u v w') +uvwvars = (u,v,w) + +# parametric line parameter +t = symbols('t') + +# ********* global definitions, triangle geometry ********* + +# reference triangle geometry +# triangle corners, homogeneous coords +pt = [ + Matrix([Rational(1), Rational(0), Rational(0)]), + Matrix([Rational(0), Rational(1), Rational(0)]), + Matrix([Rational(0), Rational(0), Rational(1)]) + ] + # edge midpoints +midpt = [ + (pt[0] + pt[1]) / 2, + (pt[1] + pt[2]) / 2, + (pt[2] + pt[0]) / 2 + ] + +center = (pt[0] + pt[1] + pt[2]) / 3 + +# three subtriangles +CTtri = [ + [pt[0], pt[1], center], # adjacent to the edge w = 0, 01 + [pt[1], pt[2], center], # adjacent to the edge u = 0, 12 + [pt[2], pt[0], center] # adjacent to the edge v = 0, 20 + ] + +# Lines passing through the center and triangle vertices +lineseq_center = [simplify(ep2line(pt[i], center)) for i in range(3)] + +# equations of lines bounding subtriangles +CTtri_bounds = [ Matrix([ [q.coeff(bc) for bc in uvwvars] for q in p]) for p in list( map( lambda x: [ep2line(x[0],x[1]), + ep2line(x[1],x[2]), ep2line(x[2],x[0])], CTtri))] + + + +# ********* global definitions, boundary dofs of the element ********* + +# boundary data: corners, derivatives along edges, midedge derivatives in the opposite vertex direction +p0,p1,p2 = symbols(['p0','p1','p2']) +vtx_unknowns = (p0,p1,p2) +G01,G10,G12,G21,G20,G02 = symbols('G01 G10 G12 G21 G20 G02') +side_deriv_unknowns =(G01,G10,G12,G21,G20,G02) +N01, N12, N20 = symbols('N01 N12 N20') +mid_deriv_unknowns = (N01, N12, N20) +all_unknowns = vtx_unknowns + side_deriv_unknowns + mid_deriv_unknowns + +# ********* main function: derives subtriangle polynomials ********* + +def derive_C1_polynomials(vtx_unknowns,side_deriv_unknowns,mid_deriv_unknowns): + """ This function derives expressions for Clough-Tocher polynomials on subtriangles + with coefficients determined by the boundary data and joined with C1 continuity + in the interior. The boundary data includes: + -- vtx-unknowns: function vertex values + -- side_deriv_unknowns: values of scaled derivatives Gij along triangle sides at each vertex + i.e. grad F(p_i) dot e_ij where p_i is the vertex and e_ij is the edge vector + -- mid_deriv_unknowns at the midpoints of scaled derivatives along vectors to vertices + i.e., grad F(m_ij) dot (p_k - m_ij), where k is the vertex opposite ij, m_ij = (p_i + p_j)/2 + The ordering of the unknowns is p0,p1,p2, G01,G10, G12,G21, G20, G21, N01, N12, N20 + + The function returns a list of 3 polynomials, one per triangle, in variables u,v,w + and with coefficienets dependent only on the unknowns passed in + """ + global pt, midpt, center, CTtri, lineseq_center + + # coefficients of an inknown polynomial for the first triangle, to be sovled for + q300, q030, q210, q120, q201, q021, q003, q111, q102, q012 = \ + symbols('q300 q030 q210 q120 q201 q021 q003 q111 q102 q012') + first_poly_coeffs = (q300, q030, q210, q120, q201, q021, q003, q111, q102, q012) + + # additional coefficients to define other polynomials relative to the first one + lambda_ = symbols('lambda_0:4') + mu = symbols('mu_0:4') + nu = symbols('nu_0:4') + + + # Polynomial for subtriangle 0 + startpoly = q300 * u**3 + q030 * v**3 + q210 * u**2 * v + q120 * u * v**2 \ + + q201 * u**2 * w + q021 * v**2 * w + q003 * w**3 + q111 * u * v * w \ + + q102 * u * w**2 + q012 * v * w**2 + + # Define 3 polynomials joined with C1 continuity walking around the center vertex and adding a term of the form + # d = (lambda[i]*u + mu[i]*v + nu[i]*w)*(L)^2 each time we cross a line with equation L(u,v,w)=0 + # this ensures C1: d(u,v) has zero values and derivatives on L, so the two polys on two sides + # differ by d(u,v) only. Crossing the last line takes us back to the original triangle, + # so the polynomial should be the same, which allows to eliminate all unknowns. + + polys = [ + startpoly + sum( (lambda_[i]*u + mu[i] * v + nu[i] * w) * lineseq_center[nxt(i)]**2 for i in range(j)) + for j in range(4) ] + + # solve for all mu's and nu's and one of lambdas + # based on equating the last polynimal and first + depvars = solve( Poly(polys[3]-polys[0], [u,v,w]).coeffs(), + [lambda_[0],mu[0],mu[1],mu[2], nu[0], nu[1], nu[2]]) + + indepvars = first_poly_coeffs + (lambda_[1], lambda_[2]) + + # Substitute into the C1 polynomials + polys_C1 = [poly.subs(depvars) for poly in polys] + + # Values at triangle corners + vp = [polys_C1[0].subs({u: 1, v: 0, w: 0}), + polys_C1[1].subs({u: 0, v: 1, w: 0}), + polys_C1[2].subs({u: 0, v: 0, w: 1}) + ] + + # Variables for side derivatives at vertices + + # variable permutations for 6 scaled derivatives along triangle sides, + # eg at corner point #0, with barycentric coords [1,0,0], i.e. u=1, and with exterior edge corresponding to w = 0, i.e., + # the increasing variable along the edge is v, so we set side_vars[0][0] (in this case w) to 0, differentiate with respect to side_vars[0][1] (in this case v) + # and then set side_vars[[0][1] = 0 and side_vars[0][2] (in this case u) to 1. + # side_vars[i][0]: side line equation is side_vars[i][0] == 0 + # side_vars[i][1]: variable changing along the edge line, with value 0 at the vertex i + # side_vars[i][2]: variable changing along the edge line, with value 1 at the vertex i + + #side_vars := [ [w,v,u],[w,u,v],[u,w,v],[u,v,w],[v,u,w],[v,w,u]]: + #pside_deriv := [seq( subs( + # {side_vars[i][2]=0,side_vars[i][3]=1}, + # diff( subs(side_vars[i][1] = 0, polys_C1[i+6]),side_vars[i][2]) - + # diff( subs(side_vars[i][1] = 0, polys_C1[i+6]),side_vars[i][3])), i=1..6)]; + + + side_vars = [ + [w, v, u], # edge w = 0, corner u = 1 G01 + [w, u, v], # edge w = 0, corner v = 1 G10 + [u, w, v], # edge u = 0, corner v = 1 G12 + [u, v, w], # edge u = 0, corner w = 1 G21 + [v, u, w], # edge v = 0, corner w = 1 G20 + [v, w, u]] # edge v = 0, corner u = 1 G02 + side_poly_ind = [0, 0, 1, 1, 2, 2] + + pside_deriv = [ + (diff( + polys_C1[side_poly_ind[i]].subs(side_vars[i][0], 0), side_vars[i][1]) + - diff( + polys_C1[side_poly_ind[i]].subs(side_vars[i][0], 0), side_vars[i][2])).subs( + {side_vars[i][1]: 0, side_vars[i][2]: 1}) + for i in range(6)] + + + # Midpoint derivatives in the direction of the opposite vertex + # e.g., diff( poly[0], w)- 1/2( diff(poly[1],u) - diff(poly[2],v)) evaluated at (1/2, 1/2, 0) + # reusing side_vars here, for edges 0,1,2 - does not matter which of two vertices to pick + + mid_deriv = [ + (diff(polys_C1[i], side_vars[2 * i][0]) + - (1 / Rational(2)) * diff(polys_C1[i], side_vars[2 * i][1]) + - (1 / Rational(2)) * diff(polys_C1[i], side_vars[2 * i][2])).subs( + {side_vars[2 * i][0]: 0, side_vars[2 * i][1]: Rational(1, 2), side_vars[2 * i][2]: Rational(1, 2)}, + ) + for i in range(3) + ] + polys_C1_f = [p.subs(solve( + [side_deriv_unknowns[i]- pside_deriv[i] for i in range(6)]+ # equations for derivatives along sides + [mid_deriv_unknowns[i] - mid_deriv[i] for i in range(3)] + # equations for midpoint derivatives + [vp[i].subs(depvars)-vtx_unknowns[i] for i in range(3)] # corner positions + , indepvars)) for p in polys_C1] + return polys_C1_f + + +# ********* For testing: compute all element boundary data from a function f ********* + +def build_data(f): + """ Compute vertex values, edge derivatives and midpoint derivatives from a function f(u,v) + """ + u, v = sp.symbols('u v') + + ff = sp.Lambda((u, v), f) + df = sp.Lambda((u, v), Matrix([[sp.diff(f, u), sp.diff(f, v)]])) + + vtx = sp.sympify('[[1, 0], [0, 1], [0, 0]]') + midpt = sp.sympify('[[1/2, 1/2], [0, 1/2], [1/2, 0]]') + edges = sp.sympify('[[-1, 1], [1, -1], [0, -1], [0, 1], [1, 0], [-1, 0]]') + middir = sp.sympify('[[-1/2, -1/2], [1, -1/2], [-1/2, 1]]') + p_values = [ff(*vtx[i]) for i in range(3)] + grad = [df(*v) for v in vtx] + # gradients per endpoint of edges + grad_e = [grad[0],grad[1],grad[1],grad[2],grad[2],grad[0]] + G_values = [grad_e[i].dot(Matrix(edges[i])) for i in range(6)] + N_values = [Matrix(df(*midpt[i])).dot(Matrix( middir[i])) for i in range(3)] + return p_values + G_values + N_values + +def subs_data(p, bdata): + """ Substitute boundary data values into a polynomial expression""" + global vtx_unknowns, side_deriv_unknowns, mid_deriv_unknowns + subs_eqs = \ + [[vtx_unknowns[i],bdata[i]] for i in range(3)] +\ + [[side_deriv_unknowns[i], bdata[i+3]] for i in range(6)] +\ + [[mid_deriv_unknowns[i], bdata[i+9]] for i in range(3)] + return p.subs(subs_eqs) + +# ********* Bezier form ********* + +# currently not used, all polynomials stay in complete triangle barycentric coords, not in subtriangle +# order 003, 012,021,030, 102,111,120, 201, 210, 300 +bezier_deg = 3 +unity_poly = ((u+v+w)**bezier_deg).expand() +bernstein_basis = [unity_poly.coeff(u**i *v**j * w**(bezier_deg-i-j))*u**i *v**j * w**(bezier_deg-i-j) + for i in range(bezier_deg+1) for j in range(bezier_deg+1-i)] +monomial_basis = [ u**i *v**j * w**(bezier_deg-i-j) for i in range(bezier_deg+1) for j in range(bezier_deg+1-i)] +bernstein_scales = [ [1/unity_poly.coeff(u**i *v**j * w**(bezier_deg-i-j)) for j in range(bezier_deg+1-i)] for i in range(bezier_deg+1)] +def coeff2bezier_cubic(p): + return [p.coeff(u**i *v**j * w**(bezier_deg-i-j))*bernstein_scales[i][j] + for i in range(bezier_deg+1) for j in range(bezier_deg+1-i)] + + +# ******** Evaluation ********* + +def poly2matrix(p): + return Matrix( [[p.expand().coeff(u**i *v**j * w**(bezier_deg-i-j)*all_unknowns[k]) + for i in range(bezier_deg+1) for j in range(bezier_deg+1-i)] for k in range(12)]).T + +def compute_CT_matrices(polys): + return [poly2matrix(p) for p in polys] + +def triangle_ind(CTtri_bounds,u,v,w): + """Check which triangle defined in CTtri_bounds if any contains the point (u,v,w). + CTtri_bounds is a list of 3 x 3 matrices of the coefficients of lines bounding subtriangles""" + for i in range(3): + if all( [CTtri_bounds[i][j,0]*u +CTtri_bounds[i][j,1]*v +CTtri_bounds[i][j,2]*w >= -1e-7 for j in range(len(CTtri_bounds))]): + return i + return -1 + +monomial_basis_eval = sp.lambdify( (u,v,w), Matrix(monomial_basis).evalf(),'numpy') + +# This function can be easily converted to C: just need to write out the numerical matrices +# CT_matrices, CTtri_bounds, and write a function evaluating the monomial basis vector from u,v,w +# (monomial_basis_eval) +def CT_eval(CT_matrices, CTtri_bounds, boundary_data, u,v,w): + """ + This function evaluates the Clough-Tocher interpolant at barycentric point (u,v,w) + It takes as input + -- CT_matrices: array of three 10 x 12 matrices computed from the coefficients + of the C-T polynomials on subtriangles using compute_CT_matrices. These are constant matrices, do not depend on data. + -- CTtri_bounds: 3 3 x 3 matrices, one per subtriangle, each row is the coefficients of the line along an edge of the subtriangle + -- boundary_data: vector of 12 values for the boundary data in the order p0, p1, p2, G01, ... G02, N01, N12, N20 + """ + ind = triangle_ind(CTtri_bounds, u,v,w) + if ind >= 0: + bb_vector = monomial_basis_eval(u,v,w) + return (CT_matrices[ind]*boundary_data).dot(bb_vector) + else: + return np.nan + + + +# ******** Testing ********* + +def runTests(polys_C1_f): + global pt, center; + q300, q030, q210, q120, q201, q021, q003, q111, q102, q012 = \ + symbols('q300 q030 q210 q120 q201 q021 q003 q111 q102 q012') + testpoly = q300 * u**3 + q030 * v**3 + q210 * u**2 * v + q120 * u * v**2 \ + + q201 * u**2 * w + q021 * v**2 * w + q003 * w**3 + q111 * u * v * w \ + + q102 * u * w**2 + q012 * v * w**2 + + # Test: infer the input dofs from a polynomial (using generic deg 3) and verify that the result is the same, should be [0,0,0,0] + bd = build_data(testpoly.subs(w,1-u-v)) + passed = not any([subs_data(p-testpoly,bd) for p in polys_C1_f ]) + print('Cubic polynomial reproduction '+ ('passed' if passed else 'not passed')) + + # Test that polynomials on boundaries between subtriangles match + passed = not any ([ (polys_C1_f[j].subs( dict( [[uvwvars[i], ep2param_line(pt[j],center)[i]] for i in range(3)]))-\ + polys_C1_f[prev(j)].subs( dict( [[uvwvars[i], ep2param_line(pt[j],center)[i]] for i in range(3)]))).expand() for j in range(3)]) + print('Polynomial on internal subtriangle boundaries match '+ ('passed' if passed else 'not passed')) + + # Test that derivatives of polynomials on boundaries between subtriangles match + hom_grads = [gradb(polys_C1_f[i]) for i in range(3)] + passed = not any([ (hom_grads[j][k].subs( dict( [[uvwvars[i], ep2param_line(pt[j],center)[i]] for i in range(3)]))-\ + hom_grads[prev(j)][k].subs( dict( [[uvwvars[i], ep2param_line(pt[j],center)[i]] for i in range(3)]))).expand() + for j in range(3) for k in range(3)]) + print('Gradient on internal subtriangle boundaries match '+ ('passed' if passed else 'not passed')) + + + +# ******** Plotting ********* +# !!!! ChatGPT generated - probably there is a better way to plot a function on a triangle but not sure +import plotly.graph_objects as go + +def plot_function_on_triangle(func, fun_name, vertices, resolution=20): + """ + Plots a function on a single triangular domain using a regular grid. + + Args: + func (callable): A function of two arguments (u, v) to be plotted. + vertices (list): A list of 3 corner points defining the triangle in the (u, v)-plane, e.g., [[0, 0], [1, 0], [0, 1]]. + resolution (int): Number of divisions along each edge of the triangle. + + Returns: + None. Displays an interactive plot. + """ + # Convert vertices to a numpy array + vertices = np.array(vertices) + + # Create a regular grid of barycentric coordinates + bary_coords, triangles = create_regular_grid_and_triangles(resolution) + + # Convert barycentric coordinates to Cartesian coordinates + grid_points = barycentric_to_cartesian(bary_coords, vertices) + + # Evaluate the function at grid points + z_vals = np.array([float(func(u, v)) for u, v in grid_points]) + + # Add the function surface as a triangulated mesh + fig = go.Figure(go.Mesh3d( + x=grid_points[:, 0], + y=grid_points[:, 1], + z=z_vals, + i=triangles[:, 0], + j=triangles[:, 1], + k=triangles[:, 2], + intensity=z_vals, + colorscale="Viridis", + colorbar=dict(title="Function Value"), + opacity=0.9 + )) + + # Add the triangle base in the (u, v)-plane for context + fig.add_trace(go.Mesh3d( + x=vertices[:, 0], + y=vertices[:, 1], + z=[0, 0, 0], + i=[0], + j=[1], + k=[2], + color="lightblue", + opacity=0.5, + name="Triangle Base" + )) + + # Update the layout for better visualization + fig.update_layout( + title="Clough-Tocher interpolant of "+fun_name, + scene=dict( + xaxis_title="u", + yaxis_title="v", + zaxis_title="Function Value", + aspectratio=dict(x=1, y=1, z=0.5), + ), + width=1000, + height=1000 + ) + # Show the interactive plot + fig.show() + + +def create_regular_grid_and_triangles(resolution): + """ + Creates a regular grid of points and corresponding triangles inside a triangular domain. + + Args: + resolution: Number of divisions along each edge. + + Returns: + tuple: + - np.ndarray: Array of barycentric coordinates for grid points. + - np.ndarray: Array of triangles, where each row contains 3 vertex indices. + """ + bary_coords = [] + triangles = [] + + # Generate barycentric coordinates for grid points + for i in range(resolution + 1): + for j in range(resolution + 1 - i): + k = resolution - i - j + bary_coords.append([i / resolution, j / resolution, k / resolution]) + s = bary_coords[-1][0]+ bary_coords[-1][1]+ bary_coords[-1][2] + if s > 1: + print(s) + + # Generate triangle indices + for i in range(resolution): + for j in range(resolution - i): + # Index of the top-left vertex + idx = i * (resolution + 1) - (i * (i - 1)) // 2 + j + # Triangle 1 + triangles.append([idx, idx + 1, idx + resolution + 1 - i]) + # Triangle 2 + if j < resolution - i - 1: + triangles.append([idx + 1, idx + resolution + 2 - i, idx + resolution + 1 - i]) + + return np.array(bary_coords), np.array(triangles) + + +def barycentric_to_cartesian(bary_coords, vertices): + """ + Converts barycentric coordinates to Cartesian coordinates. + + Args: + bary_coords: Barycentric coordinates as a numpy array. + vertices: Triangle vertices as a numpy array. + + Returns: + np.ndarray: Cartesian coordinates of the points. + """ + return np.dot(bary_coords, vertices) + +# end ChatGpt code + +if __name__ == '__main__': + # run validation + polys_C1_f = derive_C1_polynomials(vtx_unknowns,side_deriv_unknowns,mid_deriv_unknowns) + runTests(polys_C1_f) diff --git a/src/clough_tocher_patches/TestCloughTocher.ipynb b/src/clough_tocher_patches/TestCloughTocher.ipynb new file mode 100644 index 0000000..726547a --- /dev/null +++ b/src/clough_tocher_patches/TestCloughTocher.ipynb @@ -0,0 +1,3285 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "e8e9d29b-e0c3-4ae1-9365-006a052cb2a5", + "metadata": {}, + "outputs": [], + "source": [ + "from Clough_Toucher_derivation import *" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2a7ff18f-135e-4688-8fd9-0d06d6dd33cf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cubic polynomial reproduction passed\n", + "Polynomial on internal subtriangle boundaries match passed\n", + "Gradient on internal subtriangle boundaries match passed\n" + ] + } + ], + "source": [ + "polys_C1_f = derive_C1_polynomials(vtx_unknowns,side_deriv_unknowns,mid_deriv_unknowns)\n", + "runTests(polys_C1_f)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "15a935dd-9f07-4357-a658-5bd5b24e9172", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + " \n", + " " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, + "data": [ + { + "colorbar": { + "title": { + "text": "Function Value" + } + }, + "colorscale": [ + [ + 0, + "#440154" + ], + [ + 0.1111111111111111, + "#482878" + ], + [ + 0.2222222222222222, + "#3e4989" + ], + [ + 0.3333333333333333, + "#31688e" + ], + [ + 0.4444444444444444, + "#26828e" + ], + [ + 0.5555555555555556, + "#1f9e89" + ], + [ + 0.6666666666666666, + "#35b779" + ], + [ + 0.7777777777777778, + "#6ece58" + ], + [ + 0.8888888888888888, + "#b5de2b" + ], + [ + 1, + "#fde725" + ] + ], + "i": [ + 0, + 1, + 1, + 2, + 2, + 3, + 3, + 4, + 4, + 5, + 5, + 6, + 6, + 7, + 7, + 8, + 8, + 9, + 9, + 10, + 10, + 11, + 11, + 12, + 12, + 13, + 13, + 14, + 14, + 15, + 15, + 16, + 16, + 17, + 17, + 18, + 18, + 19, + 19, + 21, + 22, + 22, + 23, + 23, + 24, + 24, + 25, + 25, + 26, + 26, + 27, + 27, + 28, + 28, + 29, + 29, + 30, + 30, + 31, + 31, + 32, + 32, + 33, + 33, + 34, + 34, + 35, + 35, + 36, + 36, + 37, + 37, + 38, + 38, + 39, + 39, + 41, + 42, + 42, + 43, + 43, + 44, + 44, + 45, + 45, + 46, + 46, + 47, + 47, + 48, + 48, + 49, + 49, + 50, + 50, + 51, + 51, + 52, + 52, + 53, + 53, + 54, + 54, + 55, + 55, + 56, + 56, + 57, + 57, + 58, + 58, + 60, + 61, + 61, + 62, + 62, + 63, + 63, + 64, + 64, + 65, + 65, + 66, + 66, + 67, + 67, + 68, + 68, + 69, + 69, + 70, + 70, + 71, + 71, + 72, + 72, + 73, + 73, + 74, + 74, + 75, + 75, + 76, + 76, + 78, + 79, + 79, + 80, + 80, + 81, + 81, + 82, + 82, + 83, + 83, + 84, + 84, + 85, + 85, + 86, + 86, + 87, + 87, + 88, + 88, + 89, + 89, + 90, + 90, + 91, + 91, + 92, + 92, + 93, + 93, + 95, + 96, + 96, + 97, + 97, + 98, + 98, + 99, + 99, + 100, + 100, + 101, + 101, + 102, + 102, + 103, + 103, + 104, + 104, + 105, + 105, + 106, + 106, + 107, + 107, + 108, + 108, + 109, + 109, + 111, + 112, + 112, + 113, + 113, + 114, + 114, + 115, + 115, + 116, + 116, + 117, + 117, + 118, + 118, + 119, + 119, + 120, + 120, + 121, + 121, + 122, + 122, + 123, + 123, + 124, + 124, + 126, + 127, + 127, + 128, + 128, + 129, + 129, + 130, + 130, + 131, + 131, + 132, + 132, + 133, + 133, + 134, + 134, + 135, + 135, + 136, + 136, + 137, + 137, + 138, + 138, + 140, + 141, + 141, + 142, + 142, + 143, + 143, + 144, + 144, + 145, + 145, + 146, + 146, + 147, + 147, + 148, + 148, + 149, + 149, + 150, + 150, + 151, + 151, + 153, + 154, + 154, + 155, + 155, + 156, + 156, + 157, + 157, + 158, + 158, + 159, + 159, + 160, + 160, + 161, + 161, + 162, + 162, + 163, + 163, + 165, + 166, + 166, + 167, + 167, + 168, + 168, + 169, + 169, + 170, + 170, + 171, + 171, + 172, + 172, + 173, + 173, + 174, + 174, + 176, + 177, + 177, + 178, + 178, + 179, + 179, + 180, + 180, + 181, + 181, + 182, + 182, + 183, + 183, + 184, + 184, + 186, + 187, + 187, + 188, + 188, + 189, + 189, + 190, + 190, + 191, + 191, + 192, + 192, + 193, + 193, + 195, + 196, + 196, + 197, + 197, + 198, + 198, + 199, + 199, + 200, + 200, + 201, + 201, + 203, + 204, + 204, + 205, + 205, + 206, + 206, + 207, + 207, + 208, + 208, + 210, + 211, + 211, + 212, + 212, + 213, + 213, + 214, + 214, + 216, + 217, + 217, + 218, + 218, + 219, + 219, + 221, + 222, + 222, + 223, + 223, + 225, + 226, + 226, + 228 + ], + "intensity": [ + 0, + -0.03591174457718357, + -0.13580028412885914, + -0.2878955773852138, + -0.4804275830764352, + -0.7016262599327101, + -0.9397215666842261, + -1.1829434620611703, + -1.4195219047937306, + -1.6376868536120934, + -1.8256682672464462, + -1.9716961044269765, + -2.0640003238838713, + -2.0908108843473183, + -2.040357744547504, + -1.9008708632146167, + -1.6605801990788427, + -1.30771571087037, + -0.8305073573193853, + -0.2171850971560771, + 0.5440211108893698, + 0.03591174457718357, + -3.0357660829594124e-18, + -0.1468754333565604, + -0.34026223935054123, + -0.56839037671213, + -0.8194898041715135, + -1.081790480458879, + -1.3435223643044139, + -1.592915414438307, + -1.8181995895907428, + -2.0076048484919102, + -2.149361149871997, + -2.231698452461189, + -2.2428467149896743, + -2.1710358961876395, + -2.0044959547852725, + -1.7314568495127607, + -1.3401485391002914, + -0.818800982278051, + -0.18127335257889296, + 0.13580028412885914, + 0.1468754333565604, + 3.122502256758253e-17, + -0.23183062819797748, + -0.4927072066963041, + -0.7708596942251666, + -1.054518049514753, + -1.33191223129525, + -1.5912721982968456, + -1.8208279092497257, + -2.008809322884078, + -2.1434463979300915, + -2.212969093117951, + -2.2056073671778456, + -2.109591178839961, + -1.9131504868344862, + -1.6045152498916069, + -1.1932731057437318, + -0.6947070731905266, + 0.2878955773852138, + 0.3402622393505412, + 0.23183062819797745, + 6.938893903907228e-17, + -0.2907773291014351, + -0.5931351861661475, + -0.8953035299243248, + -1.1855123191061538, + -1.4519915124418223, + -1.6829710686615176, + -1.8666809464954262, + -1.9913511046737362, + -2.0452115019266346, + -2.016492096984308, + -1.8934228485769442, + -1.6813198586365077, + -1.3911946101622197, + -1.019820133485156, + 0.4804275830764352, + 0.5683903767121299, + 0.4927072066963041, + 0.2907773291014351, + 1.3877787807814457e-16, + -0.323715536066933, + -0.6415461777600717, + -0.9417218838096038, + -1.2124726129457166, + -1.442028323898597, + -1.6186189753984324, + -1.73047452617541, + -1.765824934959717, + -1.7257147678828733, + -1.6168839721436572, + -1.4361055780731435, + -1.1801526160024078, + 0.7016262599327101, + 0.8194898041715133, + 0.7708596942251668, + 0.5931351861661475, + 0.32371553606693265, + 5.551115123125783e-17, + -0.3306452490944711, + -0.6379401814780762, + -0.9101147558810042, + -1.1353989310334405, + -1.3020226656655725, + -1.4067589901084772, + -1.4520763157604872, + -1.4347476729526785, + -1.3515460920161266, + -1.1992446032819066, + 0.9397215666842261, + 1.081790480458879, + 1.0545180495147528, + 0.8953035299243246, + 0.6415461777600712, + 0.330645249094471, + 1.1102230246251565e-16, + -0.3115664681840489, + -0.5823171973201625, + -0.8047536819389689, + -0.9770727976383602, + -1.0960475747494112, + -1.1584510436031974, + -1.1610562345307947, + -1.1006361778632772, + 1.1829434620611703, + 1.343522364304414, + 1.3319122312952496, + 1.1855123191061536, + 0.9417218838096034, + 0.6379401814780763, + 0.31156646818404926, + -4.5102810375396984e-17, + -0.27217457440292775, + -0.500306440088993, + -0.6811686273892726, + -0.8115341666348411, + -0.8881760881567747, + -0.9078674222861479, + 1.4195219047937306, + 1.592915414438307, + 1.5912721982968454, + 1.4519915124418228, + 1.2124726129457164, + 0.9101147558810041, + 0.5823171973201624, + 0.27217457440292764, + -1.5265566588595902e-16, + -0.23097955621969507, + -0.41753712458723263, + -0.5564457354336898, + -0.6444784190901407, + 1.6376868536120934, + 1.8181995895907432, + 1.820827909249726, + 1.6829710686615178, + 1.4420283238985967, + 1.1353989310334403, + 0.8047536819389692, + 0.5003064400889928, + 0.23097955621969504, + 2.7755575615628914e-17, + -0.18940525890116763, + -0.33400925081488353, + 1.8256682672464462, + 2.0076048484919107, + 2.008809322884078, + 1.8666809464954264, + 1.618618975398432, + 1.3020226656655727, + 0.9770727976383602, + 0.6811686273892725, + 0.417537124587233, + 0.1894052589011674, + -2.7755575615628914e-17, + 1.9716961044269765, + 2.149361149871997, + 2.1434463979300915, + 1.9913511046737362, + 1.7304745261754095, + 1.406758990108477, + 1.0960475747494116, + 0.8115341666348413, + 0.5564457354336897, + 0.3340092508148834, + 2.0640003238838713, + 2.2316984524611887, + 2.2129690931179513, + 2.0452115019266346, + 1.7658249349597166, + 1.452076315760487, + 1.1584510436031978, + 0.888176088156775, + 0.6444784190901406, + 2.0908108843473183, + 2.2428467149896743, + 2.205607367177845, + 2.0164920969843085, + 1.7257147678828733, + 1.4347476729526782, + 1.161056234530795, + 0.9078674222861479, + 2.040357744547504, + 2.1710358961876395, + 2.1095911788399606, + 1.8934228485769444, + 1.6168839721436565, + 1.3515460920161264, + 1.1006361778632776, + 1.9008708632146167, + 2.004495954785273, + 1.9131504868344857, + 1.6813198586365081, + 1.436105578073143, + 1.1992446032819066, + 1.6605801990788427, + 1.7314568495127611, + 1.6045152498916062, + 1.39119461016222, + 1.1801526160024074, + 1.30771571087037, + 1.3401485391002919, + 1.1932731057437316, + 1.0198201334851562, + 0.8305073573193853, + 0.8188009822780515, + 0.6947070731905263, + 0.2171850971560771, + 0.1812733525788935, + -0.5440211108893698 + ], + "j": [ + 1, + 22, + 2, + 23, + 3, + 24, + 4, + 25, + 5, + 26, + 6, + 27, + 7, + 28, + 8, + 29, + 9, + 30, + 10, + 31, + 11, + 32, + 12, + 33, + 13, + 34, + 14, + 35, + 15, + 36, + 16, + 37, + 17, + 38, + 18, + 39, + 19, + 40, + 20, + 22, + 42, + 23, + 43, + 24, + 44, + 25, + 45, + 26, + 46, + 27, + 47, + 28, + 48, + 29, + 49, + 30, + 50, + 31, + 51, + 32, + 52, + 33, + 53, + 34, + 54, + 35, + 55, + 36, + 56, + 37, + 57, + 38, + 58, + 39, + 59, + 40, + 42, + 61, + 43, + 62, + 44, + 63, + 45, + 64, + 46, + 65, + 47, + 66, + 48, + 67, + 49, + 68, + 50, + 69, + 51, + 70, + 52, + 71, + 53, + 72, + 54, + 73, + 55, + 74, + 56, + 75, + 57, + 76, + 58, + 77, + 59, + 61, + 79, + 62, + 80, + 63, + 81, + 64, + 82, + 65, + 83, + 66, + 84, + 67, + 85, + 68, + 86, + 69, + 87, + 70, + 88, + 71, + 89, + 72, + 90, + 73, + 91, + 74, + 92, + 75, + 93, + 76, + 94, + 77, + 79, + 96, + 80, + 97, + 81, + 98, + 82, + 99, + 83, + 100, + 84, + 101, + 85, + 102, + 86, + 103, + 87, + 104, + 88, + 105, + 89, + 106, + 90, + 107, + 91, + 108, + 92, + 109, + 93, + 110, + 94, + 96, + 112, + 97, + 113, + 98, + 114, + 99, + 115, + 100, + 116, + 101, + 117, + 102, + 118, + 103, + 119, + 104, + 120, + 105, + 121, + 106, + 122, + 107, + 123, + 108, + 124, + 109, + 125, + 110, + 112, + 127, + 113, + 128, + 114, + 129, + 115, + 130, + 116, + 131, + 117, + 132, + 118, + 133, + 119, + 134, + 120, + 135, + 121, + 136, + 122, + 137, + 123, + 138, + 124, + 139, + 125, + 127, + 141, + 128, + 142, + 129, + 143, + 130, + 144, + 131, + 145, + 132, + 146, + 133, + 147, + 134, + 148, + 135, + 149, + 136, + 150, + 137, + 151, + 138, + 152, + 139, + 141, + 154, + 142, + 155, + 143, + 156, + 144, + 157, + 145, + 158, + 146, + 159, + 147, + 160, + 148, + 161, + 149, + 162, + 150, + 163, + 151, + 164, + 152, + 154, + 166, + 155, + 167, + 156, + 168, + 157, + 169, + 158, + 170, + 159, + 171, + 160, + 172, + 161, + 173, + 162, + 174, + 163, + 175, + 164, + 166, + 177, + 167, + 178, + 168, + 179, + 169, + 180, + 170, + 181, + 171, + 182, + 172, + 183, + 173, + 184, + 174, + 185, + 175, + 177, + 187, + 178, + 188, + 179, + 189, + 180, + 190, + 181, + 191, + 182, + 192, + 183, + 193, + 184, + 194, + 185, + 187, + 196, + 188, + 197, + 189, + 198, + 190, + 199, + 191, + 200, + 192, + 201, + 193, + 202, + 194, + 196, + 204, + 197, + 205, + 198, + 206, + 199, + 207, + 200, + 208, + 201, + 209, + 202, + 204, + 211, + 205, + 212, + 206, + 213, + 207, + 214, + 208, + 215, + 209, + 211, + 217, + 212, + 218, + 213, + 219, + 214, + 220, + 215, + 217, + 222, + 218, + 223, + 219, + 224, + 220, + 222, + 226, + 223, + 227, + 224, + 226, + 229, + 227, + 229 + ], + "k": [ + 21, + 21, + 22, + 22, + 23, + 23, + 24, + 24, + 25, + 25, + 26, + 26, + 27, + 27, + 28, + 28, + 29, + 29, + 30, + 30, + 31, + 31, + 32, + 32, + 33, + 33, + 34, + 34, + 35, + 35, + 36, + 36, + 37, + 37, + 38, + 38, + 39, + 39, + 40, + 41, + 41, + 42, + 42, + 43, + 43, + 44, + 44, + 45, + 45, + 46, + 46, + 47, + 47, + 48, + 48, + 49, + 49, + 50, + 50, + 51, + 51, + 52, + 52, + 53, + 53, + 54, + 54, + 55, + 55, + 56, + 56, + 57, + 57, + 58, + 58, + 59, + 60, + 60, + 61, + 61, + 62, + 62, + 63, + 63, + 64, + 64, + 65, + 65, + 66, + 66, + 67, + 67, + 68, + 68, + 69, + 69, + 70, + 70, + 71, + 71, + 72, + 72, + 73, + 73, + 74, + 74, + 75, + 75, + 76, + 76, + 77, + 78, + 78, + 79, + 79, + 80, + 80, + 81, + 81, + 82, + 82, + 83, + 83, + 84, + 84, + 85, + 85, + 86, + 86, + 87, + 87, + 88, + 88, + 89, + 89, + 90, + 90, + 91, + 91, + 92, + 92, + 93, + 93, + 94, + 95, + 95, + 96, + 96, + 97, + 97, + 98, + 98, + 99, + 99, + 100, + 100, + 101, + 101, + 102, + 102, + 103, + 103, + 104, + 104, + 105, + 105, + 106, + 106, + 107, + 107, + 108, + 108, + 109, + 109, + 110, + 111, + 111, + 112, + 112, + 113, + 113, + 114, + 114, + 115, + 115, + 116, + 116, + 117, + 117, + 118, + 118, + 119, + 119, + 120, + 120, + 121, + 121, + 122, + 122, + 123, + 123, + 124, + 124, + 125, + 126, + 126, + 127, + 127, + 128, + 128, + 129, + 129, + 130, + 130, + 131, + 131, + 132, + 132, + 133, + 133, + 134, + 134, + 135, + 135, + 136, + 136, + 137, + 137, + 138, + 138, + 139, + 140, + 140, + 141, + 141, + 142, + 142, + 143, + 143, + 144, + 144, + 145, + 145, + 146, + 146, + 147, + 147, + 148, + 148, + 149, + 149, + 150, + 150, + 151, + 151, + 152, + 153, + 153, + 154, + 154, + 155, + 155, + 156, + 156, + 157, + 157, + 158, + 158, + 159, + 159, + 160, + 160, + 161, + 161, + 162, + 162, + 163, + 163, + 164, + 165, + 165, + 166, + 166, + 167, + 167, + 168, + 168, + 169, + 169, + 170, + 170, + 171, + 171, + 172, + 172, + 173, + 173, + 174, + 174, + 175, + 176, + 176, + 177, + 177, + 178, + 178, + 179, + 179, + 180, + 180, + 181, + 181, + 182, + 182, + 183, + 183, + 184, + 184, + 185, + 186, + 186, + 187, + 187, + 188, + 188, + 189, + 189, + 190, + 190, + 191, + 191, + 192, + 192, + 193, + 193, + 194, + 195, + 195, + 196, + 196, + 197, + 197, + 198, + 198, + 199, + 199, + 200, + 200, + 201, + 201, + 202, + 203, + 203, + 204, + 204, + 205, + 205, + 206, + 206, + 207, + 207, + 208, + 208, + 209, + 210, + 210, + 211, + 211, + 212, + 212, + 213, + 213, + 214, + 214, + 215, + 216, + 216, + 217, + 217, + 218, + 218, + 219, + 219, + 220, + 221, + 221, + 222, + 222, + 223, + 223, + 224, + 225, + 225, + 226, + 226, + 227, + 228, + 228, + 229, + 230 + ], + "opacity": 0.9, + "type": "mesh3d", + "x": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 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.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.2, + 0.2, + 0.2, + 0.2, + 0.2, + 0.2, + 0.2, + 0.2, + 0.2, + 0.2, + 0.2, + 0.2, + 0.2, + 0.2, + 0.2, + 0.2, + 0.2, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.3, + 0.3, + 0.3, + 0.3, + 0.3, + 0.3, + 0.3, + 0.3, + 0.3, + 0.3, + 0.3, + 0.3, + 0.3, + 0.3, + 0.3, + 0.35, + 0.35, + 0.35, + 0.35, + 0.35, + 0.35, + 0.35, + 0.35, + 0.35, + 0.35, + 0.35, + 0.35, + 0.35, + 0.35, + 0.4, + 0.4, + 0.4, + 0.4, + 0.4, + 0.4, + 0.4, + 0.4, + 0.4, + 0.4, + 0.4, + 0.4, + 0.4, + 0.45, + 0.45, + 0.45, + 0.45, + 0.45, + 0.45, + 0.45, + 0.45, + 0.45, + 0.45, + 0.45, + 0.45, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.55, + 0.55, + 0.55, + 0.55, + 0.55, + 0.55, + 0.55, + 0.55, + 0.55, + 0.55, + 0.6, + 0.6, + 0.6, + 0.6, + 0.6, + 0.6, + 0.6, + 0.6, + 0.6, + 0.65, + 0.65, + 0.65, + 0.65, + 0.65, + 0.65, + 0.65, + 0.65, + 0.7, + 0.7, + 0.7, + 0.7, + 0.7, + 0.7, + 0.7, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.8, + 0.8, + 0.8, + 0.8, + 0.8, + 0.85, + 0.85, + 0.85, + 0.85, + 0.9, + 0.9, + 0.9, + 0.95, + 0.95, + 1 + ], + "y": [ + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0.5, + 0.55, + 0.6, + 0.65, + 0.7, + 0.75, + 0.8, + 0.85, + 0.9, + 0.95, + 1, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0.5, + 0.55, + 0.6, + 0.65, + 0.7, + 0.75, + 0.8, + 0.85, + 0.9, + 0.95, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0.5, + 0.55, + 0.6, + 0.65, + 0.7, + 0.75, + 0.8, + 0.85, + 0.9, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0.5, + 0.55, + 0.6, + 0.65, + 0.7, + 0.75, + 0.8, + 0.85, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0.5, + 0.55, + 0.6, + 0.65, + 0.7, + 0.75, + 0.8, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0.5, + 0.55, + 0.6, + 0.65, + 0.7, + 0.75, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0.5, + 0.55, + 0.6, + 0.65, + 0.7, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0.5, + 0.55, + 0.6, + 0.65, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0.5, + 0.55, + 0.6, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0.5, + 0.55, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0.5, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0, + 0.05, + 0.1, + 0.15, + 0, + 0.05, + 0.1, + 0, + 0.05, + 0 + ], + "z": [ + 0, + -0.03591174457718357, + -0.13580028412885914, + -0.2878955773852138, + -0.4804275830764352, + -0.7016262599327101, + -0.9397215666842261, + -1.1829434620611703, + -1.4195219047937306, + -1.6376868536120934, + -1.8256682672464462, + -1.9716961044269765, + -2.0640003238838713, + -2.0908108843473183, + -2.040357744547504, + -1.9008708632146167, + -1.6605801990788427, + -1.30771571087037, + -0.8305073573193853, + -0.2171850971560771, + 0.5440211108893698, + 0.03591174457718357, + -3.0357660829594124e-18, + -0.1468754333565604, + -0.34026223935054123, + -0.56839037671213, + -0.8194898041715135, + -1.081790480458879, + -1.3435223643044139, + -1.592915414438307, + -1.8181995895907428, + -2.0076048484919102, + -2.149361149871997, + -2.231698452461189, + -2.2428467149896743, + -2.1710358961876395, + -2.0044959547852725, + -1.7314568495127607, + -1.3401485391002914, + -0.818800982278051, + -0.18127335257889296, + 0.13580028412885914, + 0.1468754333565604, + 3.122502256758253e-17, + -0.23183062819797748, + -0.4927072066963041, + -0.7708596942251666, + -1.054518049514753, + -1.33191223129525, + -1.5912721982968456, + -1.8208279092497257, + -2.008809322884078, + -2.1434463979300915, + -2.212969093117951, + -2.2056073671778456, + -2.109591178839961, + -1.9131504868344862, + -1.6045152498916069, + -1.1932731057437318, + -0.6947070731905266, + 0.2878955773852138, + 0.3402622393505412, + 0.23183062819797745, + 6.938893903907228e-17, + -0.2907773291014351, + -0.5931351861661475, + -0.8953035299243248, + -1.1855123191061538, + -1.4519915124418223, + -1.6829710686615176, + -1.8666809464954262, + -1.9913511046737362, + -2.0452115019266346, + -2.016492096984308, + -1.8934228485769442, + -1.6813198586365077, + -1.3911946101622197, + -1.019820133485156, + 0.4804275830764352, + 0.5683903767121299, + 0.4927072066963041, + 0.2907773291014351, + 1.3877787807814457e-16, + -0.323715536066933, + -0.6415461777600717, + -0.9417218838096038, + -1.2124726129457166, + -1.442028323898597, + -1.6186189753984324, + -1.73047452617541, + -1.765824934959717, + -1.7257147678828733, + -1.6168839721436572, + -1.4361055780731435, + -1.1801526160024078, + 0.7016262599327101, + 0.8194898041715133, + 0.7708596942251668, + 0.5931351861661475, + 0.32371553606693265, + 5.551115123125783e-17, + -0.3306452490944711, + -0.6379401814780762, + -0.9101147558810042, + -1.1353989310334405, + -1.3020226656655725, + -1.4067589901084772, + -1.4520763157604872, + -1.4347476729526785, + -1.3515460920161266, + -1.1992446032819066, + 0.9397215666842261, + 1.081790480458879, + 1.0545180495147528, + 0.8953035299243246, + 0.6415461777600712, + 0.330645249094471, + 1.1102230246251565e-16, + -0.3115664681840489, + -0.5823171973201625, + -0.8047536819389689, + -0.9770727976383602, + -1.0960475747494112, + -1.1584510436031974, + -1.1610562345307947, + -1.1006361778632772, + 1.1829434620611703, + 1.343522364304414, + 1.3319122312952496, + 1.1855123191061536, + 0.9417218838096034, + 0.6379401814780763, + 0.31156646818404926, + -4.5102810375396984e-17, + -0.27217457440292775, + -0.500306440088993, + -0.6811686273892726, + -0.8115341666348411, + -0.8881760881567747, + -0.9078674222861479, + 1.4195219047937306, + 1.592915414438307, + 1.5912721982968454, + 1.4519915124418228, + 1.2124726129457164, + 0.9101147558810041, + 0.5823171973201624, + 0.27217457440292764, + -1.5265566588595902e-16, + -0.23097955621969507, + -0.41753712458723263, + -0.5564457354336898, + -0.6444784190901407, + 1.6376868536120934, + 1.8181995895907432, + 1.820827909249726, + 1.6829710686615178, + 1.4420283238985967, + 1.1353989310334403, + 0.8047536819389692, + 0.5003064400889928, + 0.23097955621969504, + 2.7755575615628914e-17, + -0.18940525890116763, + -0.33400925081488353, + 1.8256682672464462, + 2.0076048484919107, + 2.008809322884078, + 1.8666809464954264, + 1.618618975398432, + 1.3020226656655727, + 0.9770727976383602, + 0.6811686273892725, + 0.417537124587233, + 0.1894052589011674, + -2.7755575615628914e-17, + 1.9716961044269765, + 2.149361149871997, + 2.1434463979300915, + 1.9913511046737362, + 1.7304745261754095, + 1.406758990108477, + 1.0960475747494116, + 0.8115341666348413, + 0.5564457354336897, + 0.3340092508148834, + 2.0640003238838713, + 2.2316984524611887, + 2.2129690931179513, + 2.0452115019266346, + 1.7658249349597166, + 1.452076315760487, + 1.1584510436031978, + 0.888176088156775, + 0.6444784190901406, + 2.0908108843473183, + 2.2428467149896743, + 2.205607367177845, + 2.0164920969843085, + 1.7257147678828733, + 1.4347476729526782, + 1.161056234530795, + 0.9078674222861479, + 2.040357744547504, + 2.1710358961876395, + 2.1095911788399606, + 1.8934228485769444, + 1.6168839721436565, + 1.3515460920161264, + 1.1006361778632776, + 1.9008708632146167, + 2.004495954785273, + 1.9131504868344857, + 1.6813198586365081, + 1.436105578073143, + 1.1992446032819066, + 1.6605801990788427, + 1.7314568495127611, + 1.6045152498916062, + 1.39119461016222, + 1.1801526160024074, + 1.30771571087037, + 1.3401485391002919, + 1.1932731057437316, + 1.0198201334851562, + 0.8305073573193853, + 0.8188009822780515, + 0.6947070731905263, + 0.2171850971560771, + 0.1812733525788935, + -0.5440211108893698 + ] + }, + { + "color": "lightblue", + "i": [ + 0 + ], + "j": [ + 1 + ], + "k": [ + 2 + ], + "name": "Triangle Base", + "opacity": 0.5, + "type": "mesh3d", + "x": [ + 1, + 0, + 0 + ], + "y": [ + 0, + 1, + 0 + ], + "z": [ + 0, + 0, + 0 + ] + } + ], + "layout": { + "height": 1000, + "scene": { + "aspectratio": { + "x": 1, + "y": 1, + "z": 0.5 + }, + "xaxis": { + "title": { + "text": "u" + }, + "type": "linear" + }, + "yaxis": { + "title": { + "text": "v" + }, + "type": "linear" + }, + "zaxis": { + "title": { + "text": "Function Value" + }, + "type": "linear" + } + }, + "template": { + "data": { + "bar": [ + { + "error_x": { + "color": "#2a3f5f" + }, + "error_y": { + "color": "#2a3f5f" + }, + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "bar" + } + ], + "barpolar": [ + { + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "barpolar" + } + ], + "carpet": [ + { + "aaxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "baxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "type": "carpet" + } + ], + "choropleth": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "choropleth" + } + ], + "contour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "contour" + } + ], + "contourcarpet": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "contourcarpet" + } + ], + "heatmap": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmap" + } + ], + "heatmapgl": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmapgl" + } + ], + "histogram": [ + { + "marker": { + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "histogram" + } + ], + "histogram2d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2d" + } + ], + "histogram2dcontour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2dcontour" + } + ], + "mesh3d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "mesh3d" + } + ], + "parcoords": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "parcoords" + } + ], + "pie": [ + { + "automargin": true, + "type": "pie" + } + ], + "scatter": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter" + } + ], + "scatter3d": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter3d" + } + ], + "scattercarpet": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattercarpet" + } + ], + "scattergeo": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergeo" + } + ], + "scattergl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergl" + } + ], + "scattermapbox": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermapbox" + } + ], + "scatterpolar": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolar" + } + ], + "scatterpolargl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolargl" + } + ], + "scatterternary": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterternary" + } + ], + "surface": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "surface" + } + ], + "table": [ + { + "cells": { + "fill": { + "color": "#EBF0F8" + }, + "line": { + "color": "white" + } + }, + "header": { + "fill": { + "color": "#C8D4E3" + }, + "line": { + "color": "white" + } + }, + "type": "table" + } + ] + }, + "layout": { + "annotationdefaults": { + "arrowcolor": "#2a3f5f", + "arrowhead": 0, + "arrowwidth": 1 + }, + "autotypenumbers": "strict", + "coloraxis": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "colorscale": { + "diverging": [ + [ + 0, + "#8e0152" + ], + [ + 0.1, + "#c51b7d" + ], + [ + 0.2, + "#de77ae" + ], + [ + 0.3, + "#f1b6da" + ], + [ + 0.4, + "#fde0ef" + ], + [ + 0.5, + "#f7f7f7" + ], + [ + 0.6, + "#e6f5d0" + ], + [ + 0.7, + "#b8e186" + ], + [ + 0.8, + "#7fbc41" + ], + [ + 0.9, + "#4d9221" + ], + [ + 1, + "#276419" + ] + ], + "sequential": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "sequentialminus": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ] + }, + "colorway": [ + "#636efa", + "#EF553B", + "#00cc96", + "#ab63fa", + "#FFA15A", + "#19d3f3", + "#FF6692", + "#B6E880", + "#FF97FF", + "#FECB52" + ], + "font": { + "color": "#2a3f5f" + }, + "geo": { + "bgcolor": "white", + "lakecolor": "white", + "landcolor": "#E5ECF6", + "showlakes": true, + "showland": true, + "subunitcolor": "white" + }, + "hoverlabel": { + "align": "left" + }, + "hovermode": "closest", + "mapbox": { + "style": "light" + }, + "paper_bgcolor": "white", + "plot_bgcolor": "#E5ECF6", + "polar": { + "angularaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "radialaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "scene": { + "xaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "yaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "zaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + } + }, + "shapedefaults": { + "line": { + "color": "#2a3f5f" + } + }, + "ternary": { + "aaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "baxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "caxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "title": { + "x": 0.05 + }, + "xaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + }, + "yaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + } + } + }, + "title": { + "text": "Clough-Tocher interpolant of sin(10*u**2 - 10*v**2)" + }, + "width": 1000 + } + }, + "image/png": "iVBORw0KGgoAAAANSUhEUgAABF8AAAPoCAYAAAAIslEnAAAAAXNSR0IArs4c6QAAAERlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAA6ABAAMAAAABAAEAAKACAAQAAAABAAAEX6ADAAQAAAABAAAD6AAAAABa6ZnnAABAAElEQVR4AezdB4AkRdnG8dq9fGQk5xyVnHNUEMnykSQJShZEECUKCJIkJxFEggRBck5KRkkqGSTnnC/f7Pc+b3XNzu7t7c5s6N67/vfdzvR0V1fP/GYvzLNvVTe12BJYEEAAAQQQQAABBBBAAAEEEEAAAQT6RKC5T3qlUwQQQAABBBBAAAEEEEAAAQQQQAABFyB84RsBAQQQQAABBBBAAAEEEEAAAQQQ6EMBwpc+xKVrBBBAAAEEEEAAAQQQQAABBBBAgPCF7wEEEEAAAQQQQAABBBBAAAEEEECgDwUIX/oQl64RQAABBBBAAAEEEEAAAQQQQAABwhe+BxBAAAEEEEAAAQQQQAABBBBAAIE+FCB86UNcukYAAQQQQAABBBBAAAEEEEAAAQQIX/geQAABBBBAAAEEEEAAAQQQQAABBPpQgPClD3HpGgEEEEAAAQQQQAABBBBAAAEEECB84XsAAQQQQAABBBBAAAEEEEAAAQQQ6EMBwpc+xKVrBBBAAAEEEEAAAQQQQAABBBBAgPCF7wEEEEAAAQQQQAABBBBAAAEEEECgDwUIX/oQl64RQAABBBBAAAEEEEAAAQQQQAABwhe+BxBAAAEEEEAAAQQQQAABBBBAAIE+FCB86UNcukYAAQQQQAABBBBAAAEEEEAAAQQIX/geQAABBBBAAAEEEEAAAQQQQAABBPpQgPClD3HpGgEEEEAAAQQQQAABBBBAAAEEECB84XsAAQQQQAABBBBAAAEEEEAAAQQQ6EMBwpc+xKVrBBBAAAEEEEAAAQQQQAABBBBAgPCF7wEEEEAAAQQQQAABBBBAAAEEEECgDwUIX/oQl64RQAABBBBAAAEEEEAAAQQQQAABwhe+BxBAAAEEEEAAAQQQQAABBBBAAIE+FCB86UNcukYAAQQQQAABBBBAAAEEEEAAAQQIX/geQAABBBBAAAEEEEAAAQQQQAABBPpQgPClD3HpGgEEEEAAAQQQQAABBBBAAAEEECB84XsAAQQQQAABBBBAAAEEEEAAAQQQ6EMBwpc+xKVrBBBAAAEEEEAAAQQQQAABBBBAgPCF7wEEEEAAAQQQQAABBBBAAAEEEECgDwUIX/oQl64RQAABBBBAAAEEEEAAAQQQQAABwhe+BxBAAAEEEEAAAQQQQAABBBBAAIE+FCB86UNcukYAAQQQQAABBBBAAAEEEEAAAQQIX/geQAABBBBAAAEEEEAAAQQQQAABBPpQgPClD3HpGgEEEEAAAQQQQAABBBBAAAEEECB84XsAAQQQQAABBBBAAAEEEEAAAQQQ6EMBwpc+xKVrBBBAAAEEEEAAAQQQQAABBBBAoJThyzcjRoX/vf5O+PjTL0Kl0tLmu2DcuPHh3ItvCLfe+88224t88PBjz/hz+uSzL4t8Gg2du78851Gjx4Svvh4Rxo8f39Dzn1Qb98fv3+5Y6nXcdNfD4dTzrw4nn3tVeOCf/+1ON9Vjeuv74Isvv/E/i+ddemMYO3Zctf/aFW0fX6nUbupw/atvRoaXXnkr6Ll1tejvo0effK6rZg3t/+iTz8N5l9xY15+NetuOGDkqvPrGu+FFe116fXkvch8zkfel9rk0Yl/va6/tv6v1Rvqs573Xv2MffPxZePal18M773/c4fffa2+979+7f7n27q6eHvsRQAABBBBAAAEE+kBgYB/02S+71H/Iz7vkhnD97Q+FDz76tPochw4dHL67xnLh/zZZOyz97QXD2HHjwlkXXRdWX3GJ8P11Vqy2K3Llfvvgeek1d4a1VlkqfGu6qRt6Kgps1tpiv7qO2X7L9cOv9tmurrZdNerJc+6q70b2H3HSn8Itdz8azjz2Z2GdVZdp5FD/AHP8mZeH+eaeNWy72boNHVtU47y+f//x8L/DQxYK7rz1BmH2WWbo1Zfb0tISdvn5CeHJp1/yfgcOHBA+++Ir/zPZ3RP15Pug9pyn/vHqcPVN/whHHrBTGDRowr8+FeiuveX+YdvN1w2H/OxHtYdW199+96Pw89+cFZ5/+c2g1zpgQHNYdflvhxMP3zNMNcWwarvnXnojLLbQ3P745jsfDgvMN0dYaZnFPCx59c33woLzzlFtW+9KCpxnmmHa8KF9WD/zT9eGXbbZ0J7DgKAP57PN/K0wZPAg766RtgqGfnfGXzzUrn0ua660ZDj85zuGWa3fPJbfnXFZuOL6e8PDN54dppl6iglOWa99I699gpNMZEMjfTby3h987B/C3x96KuiHCmmZftqpwj4/3iJsbf+upWWu2WcKL736drjzvsfCzDNOF9Zbfdm0i3sEEEAAAQQQQACBHAQm/PSQw0nzPsXnX34dfrTPseE1+8CiD4o7bvW9MOtM0/uHjcf+/UK40T7YvPzaO+GaPx6V91Pr8/MNtg9S31t7hTbneeK/L9oHr8/Dait8J0w15fDqvkUXmKu6PrmsLDTfnOGTZb4M00/bWGil1z9+fCVcft3dYZXlFp9kwpe83rennnnZbTZad6VeD18eeeI5D17WX2NZCwO3DzNaUKDqpZ4sPfk+SOd95oXXwt9uvi/8cKM1PaxN23WvSq8XrNrj2lvuCxULVCa2jBo1Jmy39zFBoehWG68VFl1w7vCghav32ofnPQ8+JVx21qF+qD6ob7vX0WG5JRYOR1jQo4BmoH39+5n/haNOvTh88cXX4e6/nhKam5smdqoOt//h0pvCjXc8FH6225ZhqW8v4G1UqXPOn68Pf/7r7eGw/Xbw56UdjbR9/uU3witW8aKwZYnF5w9ffz0y3HX/4+G+R/8TPv3N2eGKcw4PTU2NPdcOX0AHG2Wlyih9T1576wMdtIib6rVX60Ze+0RP2G5HvX02+t7f88CT9vf4sLD5hquHWezftceeeiE8/Piz4ehTLvbHek+0DGhuDicctruFfm+E48+6PKy2/HeCfvjAggACCCCAAAIIIJCPQCnCFw0jUvCy4jKLhtOO2idMPVXrT0Q1HEX/KValRpGLfgLeyIeTetvrJ+knH7Fnm5e23+FnhrsfeMKrXOada9Y2+/ryQb3PuTefw27bbRT01dnSG8+rN/ro7DkWta+I1/X6W+/5y938+2v4h0c9mHbqKXtE0NPvAw3rOPrUS/zDqoKL9svpF/4tKJzparn3oSc9eFGA85tf7OzNf/iDNcOO+x7n4YGGQy4wz+xhhumnCX856zA/52a7HBoUov772f+F8y+7OaxhH6bPPOZnDQcvOtmBe24dpp1myvD7864KU2ZVNlvserhXTSh42dKeV1oaabvEovOHq/5wZFh8oXnS4eGnP/pBWMuqgJ5+/tXwznsfhzlmm7G6rzdXVCVy2AkXdtllvfbqqJHX3uWJswb19tnoe3/QXtuETb+3ahg6JAYpu2y9YTjlD38NF15xa7jdhqul8EVPY7BVax24x9ZhvyPODH+47KawXwffy/W+HtohgAACCCCAAAIINCYw2Ycv737wSbjyhnvDEPuP6e8O+Wmb4EVUKrffa+fNfJhAZ3Rvv/dROOmcK/0DkMq7F15gzrDbthuFtVddunqYfpr9y2POC6taRcmPrZS/dvnZYWeE6W3IUPrAlfZdYz9Jv+L6e8LLVg6uUGid1ZYOOpeGF/z0RxunZn7/2edfhaPsp5n6SbnO9e1F5vWS/u4MP2jTcc2Del6nmqsS4YwLrw2PWxXNuzbHwGxWUbTS0ouGH/3wu20qIep9ziqFv+TqO22uiDftA8Igf22/3GvbMP88s1Wfnd7Hu+57PPzmwJ2Dhl3caz/xffeDj33oy6r2U9yOFvneZh9ANPRhnjlnCfrp996HnBaW/s6CYZH55woXX32Hz5OgD/dbbrRG2HPHTf1D7dc2X8U+h57uXT5tH6p3PeBEXx82bEg469g4jEsVVfoQ+9i/XwzvffhJmGv2mcMm310l/Hjb7/tPmXVA7fm232K9cNUNfw9Pv/CqDS8Z7t8Lei6qQJhj1hmDnutzNmeDqrO23nSdsINZ1i71vje1x2j9if++5JUNOv7jz74IgwYO9A/46v97ay1fbV77XDuz0ZwRt9zzqB937BmXhqmnjGHmNputE9a3IXydLV29hr/dcn+4+K93eBdn2ZCYS7L1c084wD84dtT36DFj7Zjbwx3/eCy89e6HXs0139yzhY3XX8XfDx3T3e+DdL57HnwiPPvia2FHM+to6J8CzpEjR3v1y6+POz8dNsH9nVYNomUT+7CcFlUk/GD9lf3vFn1/K3zRoj/fV557RPjFUef4UBFt22eXzcOeO22q1erSyN87GlK0t/19t9bKS4bt9z7W+5DftX86Jsw8w3TVPrXSSNtll1iozbF6oL/PlvnOQuGRJ571P6d9Fb4st+RC4boLj/Hz6+9HhVQdLY3Y1/vab7j9Qa+c1LDE9axSq3bRsLmzL7ret2t/vX2qj3rfe7WtHVqkx1o0RFXhi/79a7/oeerPx0VX3hZ2/r8NOhye1f4YHiOAAAIIIIAAAgj0XGCyD1/+89z/gibv3GyD1Sb4cFHLN900U9U+bLOuuRC23fNoDxyWX2oR+7A5PPzzyef9w7nmftB8MVpGjhrtk2LObKXf7Zd/2fAmDXWqXTSR6EVX3RamGD7Uq3I0L82Ndzzs8858q4NhMrv/8vdBAxpUraL5DPShep9DTg+3XHp80LwYPV3qfZ2aLHLrPY72uXP0XJZcbAEPTS6xeWmmsRBjjx03qT6Vep6zJv3U3BN6DQpRFOY8+K+nPdi5+eLfVeeLeN3eB80t8YvfnOOBSTqJ5nJZtTVDSJv9Ph2Thq1oThT18c+nnvf5NvTT/3nmmMWGTLzjAYXmQlBVgio+FBxp0ffPp59/6evDRw/1ezfY/Sif5FLByVorLxUefOzpcNofr/EhXYfuF+f7SOeT7VU3/j18aqGZFn2/pX1pIlUFQHPbc9GEpRoWII8010y974133u7m5dfe9tesIGvFpRYNI+z7VMNXDrDhIKcdvU81MEnPpysbTaqqoEbLl1+NcB+tj8y2ab2jpZ7XoL71/LR8bkNrZN/VcuRJF/nkvBpyoSFi7334qQ+9eMWGEioM09Ld74N07vse+Y+vbrTeymlTm/s5Z5vJH48aE13a7Kx58F72YXjxheep2Wofthee1x8rTEyLqmAU+D5iQ0gUHg+wIUZn2/AgBUz7/eSH1b/PGvl7R54Ke8+1+a8GDRrg34MVm6T2R3v/Nvz8p1uFDW2eq1SB10jb9Jxr71Ut9ML/3vRNM7ULdmrb9XR9+LChYaH55/RuUjVPR302Yl/va1/Yhmo+evwFPslv+/BFf971Z3uPneLfh/X2qede73vf0evUNs0npGVi7hutt1I408JzBWMbtBuW6gdygwACCCCAAAIIINDrApN9+PL6m+87muZ86O5yuk2yqQ/vx/xy17DF91f3bt5854OwjQUyp9qHbX1gqZ07pZ7zaOLDS6zqQj8N/vOpv6oGDPqA+oMdftVhF6qoOWz/HbxKQv+RT5OS6ie9yy25cIfHNLKx3tf5+/P+6sHLHjtsEvbddQs/hT5oXX3zP3xuitpzdvWc33j7A7/iykI2meiFv/+lVwfpeFW5HGPDPC64/BavWqnt8w2zP9gmBl7dPPShdKj9NL/RRYGXyvW32HANr3TRnBF72JwbmpxX4Yvez6ttDqCl19/NJmJeIPzx5IPanOL0C/7mwYvCN83doQ+sqpbZ6qe/sZDl3rDb9htVPxzrQE3yrEmcNd+QXquumpMWBTF6X9OHIAV7u/7iRP/JtYI9VUbU+96kPmvvNUzlHpsfROFEWvQ9s7194Nb8H+2rVbqy+cn2P/DXqvfmhEN3r84dkvqe2H09r0HVOAoT5KsKp4lVNKVzyPyWux+xCUSnD7dedkJ1slh90L72tonP/5GO7+q1pnb/srBOlSGqSOjJovBNlUdpiEjqK/398clnMfDTvB9b7naEzwmj4TwKXfR9o0qS3552qYXBx4S7r/p9w0OPTjznCq8CUlXdyhZUbbfXMeGGPx9nFRrXhYN/+wcffqTvZy2NtPUD2t088K//+kTJqsxT1VnRS732ep71vvZFLHzRUCtVuejfBFW/adH3pYZ26nUvv+Qivq3ePnv63uvv4pvvesTPqXmTOlo02a7CF31fp793OmrHNgQQQAABBBBAAIHeE5jswxdddlOLKhq6s2hOmHsffMr/E52CF/Wj/2TrQ7pKu/Vhuf1PPbs61/02EaUui7r7jzapBi86Zgr7Ke7EFo3PV5WFFlVFrLvaMv6ffg150fLK6++Gm+2DaO2iOS732mmzLitj6n2da6+6VLjt7//057zXzq3DHzTxZ0fl710959v//i//6fsOP/xemMbmokiX6NUHguPsyiWaHLL9cs7vfh46GubQvl1nj1XBpPcvLZp8WB/E00/H0/aO7vXhRh/49V5sYfOS+ASrVimjIUkaNvbnq24P/7Nqk9phHJpv6DwbOpMWzeuQqnE07Kj2A5DarrD0Iv59peejiqmefA/qCjZadMUgXQL4g48+86oehQBvvvNhekrV+57YVDtpt1Lv91ejf450Gg0dHGNDZzTEYt7sQ76urqPhNV0t9b5WTVC91OILdNVdl/u/+OobCwwnDAtTGJO+J/T98adTDvYrsOnPVsUmfx5nX/o+veHPx/r3V6OT7erJ7WpD4na0P2sKfTWMSou+7zUsT3PP1IYkjbT1jmpu9H17uM3DolDylxZydrX05O+urvpO++u1V/tGXvuW5vbsKa/blfQeDD/bdUs/nYbAqTqsdg6devvs6Xt/+gXXhP8+/4r/Hbne6h0PA0yVWro8NQsCCCCAAAIIIIBAPgKTffiiS6pq+cg+PHVnUXijQKCjypmFbc4QLW/aMIBGFw0t0dJ++EEj/aRLqY4ZM84P09CZ820SxfaLJhvtalhSva9T7VR1o5/26kNvo0v75/zG27Ey6fATLwz6ar+8b0FB+2W4hRy9vehDouao0NCvrhYNDVE7zV+y5Hq7dtj8/Q/bPm8NjWhk0ZwMCvXetyE0GhbSk+9BzU2jCUnvs8tDt78ST/vHHT3HRmw6Ol7b6v3+mtjxE9uuYSZrWSCouVI23vHXYTG7etB3Fp0vbLrBqkGTwDa6dPRav7IqBg3Jqq0carTf1H5Km+tH70f7RfOuaFEQkpbagHEFm09ppixA1twhi2fDlFLbeu9VIZQWDRHUXDOqrNKiKy/VLo20rT1OFSa7HXiSz0uloUyr2GW0u1p68ndXV32n/Y3YN/LadcUvVbXcYFVk++yyhVcj3XDHg/537mY1c/s00md333sN/VRFmoLh3x+510Qro/Q9pMtRp6GVyYh7BBBAAAEEEEAAgb4TmOzDl3nmjFfzeeXNGHY0Spnmthg8eEKqFGjop+5tlk4uNZvapQ9bmuOiu0tz9qEpHb/i0ouFS888JD2s3g8b2nVYUe/rTPN6dPTT++oJO1lp/5w1ebEWDYPQT3zbL7UfRtvv6+3H+hBaqYzvstsR2XPWkANVvnS0aKhST5YWq67RMtACrnrfm4md76cH/d6rHPQhWNU+8809q1tvvOOE3ysT66Nem4kd39PXMLF+tf33NtntZX+7K1x324PhOauUeval133Y2rabr+uXTu7s2I72TfBasz/PzXap554u35puKh+CpjAthR7qM/056GgyX+3feesNdNf5UsffO7Ud6AO6ho3Vs9TbVpUUu/3iJJ9jR3M/dXWlsXTunvzdlfro6r679l29dgWAG6y1gle+aI6XOa2qSPNxrb/mctVhlO2fW1d91rav6723AzTp9Ik2R5Aq3TSEc8ZvxR881PZVu66gkQUBBBBAAAEEEEAgP4EJE4X8zp3LmfQBWctNdz7sw2/0076OFlVzpDCldn+6QoeqHNovaYiKrvSjJQULKaBo3772cRoK8pRNfLr0txes3dXtdVWVaE6I7iz1vs65Zo8Ti77+1gfdOc0Ex8w9R5wjQQZrrLTEBPv7wwYN96hdNORMH1z0/aIrGPXFovkjtMh76NDBvl7P96A3rLnRlXA0vER/Dv540oE1e0JosuEsPV3G2bC8epZ6v7/q6at9G1Vg7WRXbdGX5tq458Enw8nnXhmuvukffnWgnl6mWh+u9V5/YFVIPV1U/aBLI2si2trLMqfhdd0ZHtnI3zs9ff6dHa/v2Z8ceLJXhB1gFS+7dnGJ99q+evJ3V20/na33hX06n4ZsadjR9bc/UJ33ZSvbltei+VvOu/RGHzam4KWrKq2xVrn3qU0oniZ6zut5ch4EEEAAAQQQQKDMAj3/UW4/19Mkld+3snB9KDv0+D/a1VlaJzrVU9f8Hbp0riY47WjRcBFNGPmfZ18JL9l8GWlRWHPtbfeHZvsQvoQNc9Ciyg19KH/u5de939RWkzGOHt32KijL21VntNx276NBwxq06Lmdf9mNvp73Tb2vU1U0uhSuPtBrssbaRVcA0k98G1lSWHT2n68L+kBQu+g9u8/mxilqGTxoYNDrTSFbeh4KQxZdcK7wjF2CWpNqtl8esytbyaK7i/p95Inn/PtOlyev973p6HyavFPLIHsttYvm2OhJ1ZWGrGjp6FK2tedJ6z15DamPju71+u596MnqLgUlm9pQDw3L0Z/RFGJVG3RjRX+m9We7o/Cr0e400akWhcFp0ZW1brnnEX84sTk6UtuO7hv5e6ej43tjm+YY2W6v3/ol1486aJeGgpfeOH89ffSFfTqvwmNd+e3u+5/wq5opXF952a6HW6Xju3uvuZQ0pFDBiyaDvvSMQ7oMXnQuDQPU992M2bDc7p6f4xBAAAEEEEAAAQTqF2j7iaz+4yaplgftuY2HAvc/+t+w6S6HhnXtA9BsM89gpfHvBVWeaP6V9vMd1L7A/e2yrnsfcpoHNCqjn8I+4N1w+0M+we3mG65enaRSH9aXXGz+oCvJ7PmrU3z96RdeDQ/882n/j25tn6ry0BWKHv/Pi2HNLfazEvFpwrvvfTzBnBy1x/T1er2v8+C9tw0/OejksMevTg3b29AOXR75hVfe9Cvn/Hib7zc0Ge5aqyzlk4jq0tKb/fgwvyS4hhqpMuDvDz3lH6LXtKv1FLUsttDc/r1z8LF/CIsuMLd/aNFlpA/db4ewwz7HhgOOPDtsYh/29cFH8wo9YUGbwpcrzz2iy7L/9JoetksJ/+rY8y1smd2voHTtrQ/498tBe22dmoR635vqAdmKPhCq2uvp518N+x1+ZlhsoXl8sta77EOi5jHp7pKqNk47/2q7tPZnQcPovr3wPGFNu+T2xJbuvoaJ9aftquzZ99AzvHpMf6ZU3fCCDT3S95PmfPn2wjEY7ayPevatYBM032iBiQLYdFnj2uN0dZkPLXBLl4p+9sXXw5+uvM2bbLfZutXqpe/aUJTfn3eVD5NS2LighcO6lLTm99FcNfp+a3Rp5O+dRvuut/3J517lEzpromNdxlxftcvsVh24506b1m7qtXWFYnfanD9adBluLZdde5cHpwpJV152cd/WF/becXajIX0nWcWV/izs++M490vt/r5Yf/w/L9lwuwe8aw1lOsX+PLZfdrQriLX/nlV1mJYVsh8CtD+GxwgggAACCCCAAAK9L1CK8EWT7t508XHhrD9dG26486FwxXX3VCU1eauuNLPDlt+tbtOKKlrSooDgxMP2CL89/VIfU6/tmq9Bc0oo2KldjrBLD+976On+4U8fABUkHLjH1uGci6+3qpi2hUbn2zCQcy++wT+sa/jGSjZnywbrrOBzJujKP2lJY/PTffvtjV71pPrSqiuxx3pfp+YOOfu4/cPvzvpL9QOmelCAlSaKTM813Xf2nE8/el//ye1f7APTaXbp7rRoSJKu6JSW1Fe6T9s7u08vsWqUbWh9d2uOto3VdtlmhSxnXPi3oKsy6QO2JuVV+KIr31x65qHhuDP/4sMN0gcgfRDWT9irZf+dnS87x3CrrtH3yk13xWoIBQgnHr57m8ss1/vepFeTvn/1fE4+Yq9w4DHnepWOKnVUzbPjVt/1n9AnHz+us+fazkZXZNIHzGtvvT+cmn3g+/W+26fTd3hf72tI72/7Py8ddTqjVaSoX10q/KlnXq420ffh0Qf9uPp+ptdZfX8beK3qdI2Vl/TwRe/RL+ZvDcXSCfVhXwFXWhTA6kuLKnHS0DFVAOn75meHn+Hz0mi/Xu9KyywWTvnN3nrYraWRv3e6dYIuDkrvmarE0p+F2kMU1vVV+PLam+95oFV7vnPs0txadAW2FL70lX06r0LYU/94ddB8TZtvuFra3Kf36ftaJ9HfUR0tutx0+/DlZvs+1lC6VZaPwVRHx7ENAQQQQAABBBBAoHcFmqz0OM7s2bv99uveNNb9Pbtija5+McesM9R91R4NUXrD5jUYOXK0T1qaLg/b/sVquMOr9oFA/zGezyoPGrkqkIZQ6Cf5CnXqnWix/fl7+rje16nz6MotGmIz07emC+lKRt09v74VVUXx2Rdf+6SRCjr6y/LFl9/4a9VP9hVo1C6aTFZXvFKIMuvM09f9fuuywiv9YK+w9qpLh9OP2dcvAT3A5mFR+DKxpZH3praPUTbs7dU33vNN8841iwcwtfu7u6737I23PwhTTTk8TGyy2PZ9d/c1tO+n9rH+zKnq5OtvRvl7MN00Hc/tVHtMI+uaIHfbPY4Or9vVuW665HdtLiPeSD+1bVW1864N/5jH/o6Yyqrperr05O+dnp57Uju+t+0npdevy2Af8JuzfWiY5uZhQQABBBBAAAEEEMhHoJThSz60XZ9FwxKmnmp4WHi+Ob2i4qVX3wonnH1F+MTmsbj50uODSvVZJl+B2vDlrGP3m3xf6GTyyjTP0TYWwKxj1VgKy1gQmNQE9HfOJjsfEgYNHBhu/PNx1YqsSe118HwRQAABBBBAAIFJUaDtj/AnxVcwCT/nhx97xiZWfbbNK9CQkMP235HgpY0KDxAoXkCT+GqooSbo1tVl9t11i+KfFM8AgToFNBeN5i770OamOvf4Awhe6nSjGQIIIIAAAggg0FsCVL70lmQ3+tHkkJrw9yMbalOx4RtzzjaTXypac9SwTP4CGiaiyyHrMsyrr9g/L7M9+b8Ljb1CXYErXaloS7uUcPshaI31RmsE8hPQ8EAF/hoi+IP1V87vxJwJAQQQQAABBBBAwAUIX/hGQAABBBBAAAEEEEAAAQQQQAABBPpQoO3ld/rwRHSNAAIIIIAAAggggAACCCCAAAIIlFGA8KWM7zqvGQEEEEAAAQQQQAABBBBAAAEEchMgfMmNmhMhgAACCCCAAAIIIIAAAggggEAZBQhfyviu85oRQAABBBBAAAEEEEAAAQQQQCA3AcKX3Kg5EQIIIIAAAggggAACCCCAAAIIlFGA8KWM7zqvGQEEEEAAAQQQQAABBBBAAAEEchMgfMmNmhMhgAACCCCAAAIIIIAAAggggEAZBQhfyviu85oRQAABBBBAAAEEEEAAAQQQQCA3AcKX3Kg5EQIIIIAAAggggAACCCCAAAIIlFGA8KWM7zqvGQEEEEAAAQQQQAABBBBAAAEEchMgfMmNmhMhgAACCCCAAAIIIIAAAggggEAZBQhfyviu85oRQAABBBBAAAEEEEAAAQQQQCA3AcKX3Kg5EQIIIIAAAggggAACCCCAAAIIlFGA8KWM7zqvGQEEEEAAAQQQQAABBBBAAAEEchMgfMmNmhMhgAACCCCAAAIIIIAAAggggEAZBQhfyviu85oRQAABBBBAAAEEEEAAAQQQQCA3AcKX3Kg5EQIIIIAAAggggAACCCCAAAIIlFGA8KWM7zqvGQEEEEAAAQQQQAABBBBAAAEEchMgfMmNmhMhgAACCCCAAAIIIIAAAggggEAZBQhfyviu85oRQAABBBBAAAEEEEAAAQQQQCA3AcKX3Kg5EQIIIIAAAggggAACCCCAAAIIlFGA8KWM7zqvGQEEEEAAAQQQQAABBBBAAAEEchMgfMmNmhMhgAACCCCAAAIIIIAAAggggEAZBQhfyviu85oRQAABBBBAAAEEEEAAAQQQQCA3AcKX3Kg5EQIIIIAAAggggAACCCCAAAIIlFGA8KWM7zqvGQEEEEAAAQQQQAABBBBAAAEEchMgfMmNmhMhgAACCCCAAAIIIIAAAggggEAZBQhfyviu85oRQAABBBBAAAEEEEAAAQQQQCA3AcKX3Kg5EQIIIIAAAggggAACCCCAAAIIlFGA8KWM7zqvGQEEEEAAAQQQQAABBBBAAAEEchMgfMmNmhMhgAACCCCAAAIIIIAAAggggEAZBQhfyviu85oRQAABBBBAAAEEEEAAAQQQQCA3AcKX3Kg5EQIIIIAAAggggAACCCCAAAIIlFGA8KWM7zqvGQEEEEAAAQQQQAABBBBAAAEEchMgfMmNmhMhgAACCCCAAAIIIIAAAggggEAZBQhfyviu85oRQAABBBBAAAEEEEAAAQQQQCA3AcKX3Kg5EQIIIIAAAggggAACCCCAAAIIlFGA8KWM7zqvGQEEEEAAAQQQQAABBBBAAAEEchMgfMmNmhMhgAACCCCAAAIIIIAAAggggEAZBQhfyviu85oRQAABBBBAAAEEEEAAAQQQQCA3AcKX3Kg5EQIIIIAAAggggAACCCCAAAIIlFGA8KWM7zqvGQEEEEAAAQQQQAABBBBAAAEEchMgfMmNmhMhgAACCCCAAAIIIIAAAggggEAZBQhfyviu85oRQAABBBBAAAEEEEAAAQQQQCA3AcKX3Kg5EQIIIIAAAggggAACCCCAAAIIlFGA8KWM7zqvGQEEEEAAAQQQQAABBBBAAAEEchMgfMmNmhMhgAACCCCAAAIIIIAAAggggEAZBQhfyviu85oRQAABBBBAAAEEEEAAAQQQQCA3AcKX3Kg5EQIIIIAAAggggAACCCCAAAIIlFGA8KWM7zqvGQEEEEAAAQQQQAABBBBAAAEEchMgfMmNmhMhgAACCCCAAAIIIIAAAggggEAZBQhfyviu85oRQAABBBBAAAEEEEAAAQQQQCA3AcKX3Kg5EQIIIIAAAggggAACCCCAAAIIlFGA8KWM7zqvGQEEEEAAAQQQQAABBBBAAAEEchMgfMmNmhMhgAACCCCAAAIIIIAAAggggEAZBQhfyviu85oRQAABBBBAAAEEEEAAAQQQQCA3AcKX3Kg5EQIIIIAAAggggAACCCCAAAIIlFGA8KWM7zqvGQEEEEAAAQQQQAABBBBAAAEEchMYmNuZOBECCCCAAAIIIIAAAggggAACCITx48eHO+9/vEOJOWedKXx7kXk73JfHxpvuejhMPdUUYc2Vluyz0730ylvhlTffDWuvsnQYOmTwBOd5+PFnQ3NzU1hpmcUm2Fe74cOPPw/7HHJa+OXe24bllly4dle/Wyd86XdvCU8IAQQQQAABBBBAAAEEEEBgchYYPWZsOPCoczt8iVt8f3ULX3btcF9vbnz/w0/Delv/Ipx21D5hvTWWrXZ92h+vCfPNNWufhi9vvvOhv/6Tj9wzbLj2itVza+Wrr0eEvX99athm03W6DF/GmOOzL70evvz6mzZ99McHhC/98V3hOSGAAAIIIIAAAggggAACCEz2Aj/bdcvw4202bPM6mwfkMztIpaUltOjLftUu115wTOjr57DGykt6dc3Ndz0yQfhyx32PhTFjx4WNv7tq7dOa5NcJXyb5t5AXgAACCCCAAAIIIIAAAgggMCkKDLSgZdCgCT+Wv/bW++HXx50fjjxgp7DognP7S/v8y6/DHgefEvbbbcuw8rKLh+tueyBcf/uDYfMNVw+XXH1neOe9j8L6ay4XdttuozDPnLNUOR7/z4vh7D9fH15+9e0wbOjgsNS3Fwz7/+SHYb/Dz/Q2p/zh6nDhFbeGQQMHhkvPPCSccPblYbZZZgj77LK571cQomqYuywU+eyLr8MiC8wVDtxz67DU4gv4/nqfR/UJ2cpge80brL1CuPbW+4Ne17RTT1ndrUBmgXlmD4stNHc479Ibw413PBQ+/vSL0GS/Fl5gzrDvrluE5ZdcpNq+duXy6+4O9z/633DeCQdUN9967z/N545wxTmHh6amJt/+r6eeD6df8Lfwog1/mnrK4WHd1ZcNB+y+lfkMqR7X2ysTvsu9fQb6QwABBBBAAAEEEEAAAQQQQACBCQQ0/OafTz5f3T5kyCAPNUaMGBmefv7V8M2IUdV9Y8aM820KK7RovhMFK6++8W7YbIPVwlQWIvzpytvC2HHjwgmH7u5tHvvPC2GX/U8Is886Q9hl6w3CuPGVcM3N/wjP2VAdzeny/MtvhCUXm98DFc2xouXl1962duN9XTdHnvSnoABDw4MWXXCucNWNfw877fe7cMNFx3rIU8/zqHZWs7LJd1cJf7W+bv/7v3yIkXZpKJRe088tHNKiIUhrrrxUWHj+Of05XXn9vTYk6bRwz19P8dfrjWpudLxeW+2i4EaWVuRj4Uvw/n98wIlh9RW/E478xU4eSl1+3T1eAXTYfjvUHtqr64QvvcpJZwgggAACCCCAAAIIIIAAAgjUJ3DNLfcFfaVl5hmmC/dec2p62OW9qlVuufR4H8KjxqNHjw2XX39PGF+phAHNzeGMC64NUwwbGm655PgwcOAA72+n//teGDV6TFh84Xm9smTd1ZcJ66+xXIfneu+DT8JNVomy7WbrhkP3+5G32Xj9VcIaW+wXLrKg56iDdvFtXT2Pjjpf2ipw5phtxqBKF83vouWWex61+pYQfrD+yv74oD238XtNUPzxZ1+GQQMGhEOOvyC8ZFU8yy6xkO9r9OasP13nlTXnHt9aHfPZF1/58yB8aVST9ggggAACCCCAAAIIIIAAAgj0cwENEdp+i/Wrz3JAg/O9aG4WXZkoLbPO/K3w5VffhBFWMaNKmBdfeTOsuvx3qsGL2unqQvoaMXJ0Omyi969YVY3mhVlp2darDk0/3dRhwfnm8AqZdGBXzyO1a3+/ic3rcu7FN4R33v84zG5DnW6++5Gw/NKLhJlnnN6bPvPCa+Gkc68M/372f2HcuNZqnFGju37u7c+VHr9gJlo22+WwtCl88vmXXmXz9Tcjw5RTDKtu780VKl96U5O+EEAAAQQQQAABBBBAAAEEEKhTQPONzDTDtBNt3X4y3Ik2zHY0W7VLWiqVljDW5mvRObq7jBk71g+dYvjQNl0Mt7lR1PfEltrnMbE22r6xVbicY/PR3GKhy9qrLh10Cepjf7WbH6JqlB32PTYsOO8c4Yxj9rXAZ87whQ25+uFPjuysSw+LJtZAQdJoq/pZbYXvhE1tqFb7paPLXrdv093HhC/dleM4BBBAAAEEEEAAAQQQQAABBPpAYJqp4gS0X3zRegnllpZKQ2fSHC5zzzFLeOCf/53gOA1LGjp4kG/XUKWJLXPPHifuffSJ56qXfR4xclR45sXXwno2SW1Pl7lmn9nnuNHQpq+tWmeoTQichkA99czLftWjg/baJiy/VJxgd9SoziteprEqIFWvaJjSABuipKXFXmtaNOHuPHYZ7U8t2Fl3tWWqE/B6Owtm0oS8qX1v3hO+9KYmfSGAAAIIIIAAAggggAACCCDQQwHNhTLf3LOFi/56W5h2min9SkYX2BWJGl223nTt8NvTLg37H3Gmzduynl1Cuilcfu094fvrrughx0I2fEhXTNK5NDHtGist0eYU888zW1huyYVtkt77goYbacLdi/96hw8BSvO0tDmgGw82tol3jzn1En+NuupQqrJZYtH5fbjUlTfcG1RJo8l0L7j85k7PoEtYn3L+1eH0C68Na6y4RNBVjS666rY2x+y81fd83phDbe6Y7TZfz/cp6JHD3y44uk3b3nxA+NKbmvSFAAIIIIAAAggggAACCCCAQBcCzU3Z8KDs0scdNd9zp03DaRYk6MpCQ6xKRcNkdGUjXXJZS0eHpisWpZ1bb7JO+NwuD33BFbeEu+5/wo+b1yo/5pxtY1/fdduN7JLL14Stfnqkn+PJO//o/ddWgOjKSQcdc1444azL/RhVpxy2/w7VapR6nocfOJEbXUXp+DMvD6PHjA26AlJaZph+miADTeyrKyINsXlq1tHQJJtsNxmktumxhij93yZrh79ce1e48PJbfB6ZFZZeNPzj4X+npu74jVXvnH3R9eEGu4y1Fl36+ntrrVBt0xcrTTbmyS64xIIAAggggAACCCCAAAIIIIAAAv1JQPO2vP7We3ZVoJk8IOjuc1M/7334SRhmc7VMP+1UbbpRJPCeVZVoe2dznnxqVxvSZa41VChdOalNR330QFdmeuvdD8Mcs87oz7+e02jo0Rc28bAm8e1s+eiTz72KR/PupGFKnbXvyT7Cl57ocSwCCCCAAAIIIIAAAggggAACCCDQhUDrVMhdNGQ3AggggAACCCCAAAIIIIAAAggggEDjAoQvjZtxBAIIIIAAAggggAACCCCAAAIIIFC3AOFL3VQ0RAABBBBAAAEEEEAAAQQQQAABBBoXIHxp3IwjEEAAAQQQQAABBBBAAAEEEEAAgboFCF/qpqIhAggggAACCCCAAAIIIIAAAggg0LgA4UvjZhyBAAIIIIAAAggggAACCCCAAAII1C0wsO6WNEQAAQQQQAABBBBAAAEEEEAAgR4LVN5fyPposq9KaLG7Jq1rpaUlhGb7qjTbQ7vXov22qkdN1VsdUYk71cYWa2Z7sz7UrkkH+sa41/punvUlW2cpQoDwpQh1zokAAggggAACCCCAAAIIIFBagRaFI/rd1ByaKnqkoESBiW2zEEa5SVo8eLFtLQplWqy97dAROsbX1d4eWV5jXaiP1oP10BdbqdmcbeQuTwHClzy1ORcCCCCAAAIIIIAAAggggEDpBawGJYYtClE8K6mmJEpkPFpRsqKAxWpg4mMrdLE6mdYQRe08sIlBTIuSFu9GfcYj/XGTHdhs56smMaXnLwSAOV8KYeekCCCAAAIIIIAAAggggAACZRWoWBCSshDlJYpKYujSHCppuJBwrJEGF6VoJgYy2hEDGj/WbmL8km33MCcLcLTHqmUUzKgfluIEqHwpzp4zI4AAAggggAACCCCAAAIIlFSgxUIWr1axIKXJKlUqFpo0eRmMghIlKNXIRS1sv0U0WbWLBzdZyOJNPX6xI7I2fqzt91DHtsWu/ICSahf/sql8Kf494BkggAACCCCAAAIIIIAAAgiUSEAZi6pV0pIqYbw6xTOSuNfDEwUvWVsdoeDF9+reH2hFHWZzwPjxCnassYIXHZP16Q+4KUSAypdC2DkpAggggAACCCCAAAIIIIBAeQUsDbGJdjVJrkUj9tsm0lV+YomJhyYqZ/EqlmybqmSsvVe5aJf9iuGKjk7HZJUxMZqxfmNljbe1Y1iKFSB8KdafsyOAAAIIIIAAAggggAACCJRMQJUuTc2WiKjUJQtGPHixB8pjVK+iqx55hYuaKGmxHSpkUQbjix2XghoNW9ISH2tNnWbbdF/Tl/ay5C9A+JK/OWdEAAEEEEAAAQQQQAABBBAouYAHJR6atAYlItHcLtVQRuOFsjTGAxs1yOaK8UtSp4AljivSXlvUn5YY3jTXVs3EHdwWIED4UgA6p0QAAQQQQAABBBBAAAEEECivQJzLxV5/NXdJgYltU5WKPVR04qUuKlzJAhVbtQfa4A2yDuJDDUtqsqBFx7VO3mvzxVh1jSb3td8sBQoQvhSIz6kRQAABBBBAAAEEEEAAAQTKJ+DDiTxbiSGKHsfYJAtdPELRFgtOxKO22TYPZLIdurqRsphmD2M8rrG2VirjZTW2T+2yQEaVMizFCRC+FGfPmRFAAAEEEEAAAQQQQAABBEopYEGJMhK/vFEMXtL0L+ky07qstF/lSCUr1dzEkhYPWoSWRTa2TwGNZytW/ZIyFu/Vm+vGGlT70LEseQsQvuQtzvkQQAABBBBAAAEEEEAAAQRKLaAsxGfOtWCltiIlVrKoxsW2e6gSkxXlL+liR569ZGGK7ryvbKWpSRPEpBgnBjItlvKoX8IXoRe3EL4UZ8+ZEUAAAQQQQAABBBBAAAEESijggYkCFnvtClaq07h4sqLtsUW6UwWM5nPxAMZ2eTBjN3ZoDFW0ou0qpfFARzvSUCbt0NAkbWMpSkCxGAsCCCCAAAIIIIAAAggggAACCOQkoBBFk+D6ErORuGoVKr7P0pIUyMQIxapXbIMHNQptFKQotPH1GNX4uh57T7ZTYY3156dRv+l8vp+bvAWofMlbnPMhgAACCCCAAAIIIIAAAgiUW0DBSZageHSiYUEqZ7HwxOMTW/cQxUOWFMTYvuyx0heFLTrCUxiNNFJpi/1u0j5vZ33YZY905SNf/OBsnbvcBah8yZ2cEyKAAAIIIIAAAggggAACCJRZoDZ4UQVMqlqRyXgLS+Kku/bA1hWkeJaS3WuOGL90tO1WBKN9QZP3+kpTGK+D/LH12qxhSDGoiQ3VmKUIASpfilDnnAgggAACCCCAAAIIIIAAAqUVaLF0JEYiKkuxtThVi0+VGytg4l4FKl4U41UtCmksULGNylkUwmgkkWcu2TZPYJo1N4ziHE3Sq3oLb2332sJSlADhS1HynBcBBBBAAAEEEEAAAQQQQKCcAp6oqMLFghGFKHavkUNxieGKQhOPZlS54teltntlKZ6h+B5roV9xo4Ia68pudFw234s69fbqzWOaeApucxfQu8SCAAIIIIAAAggggAACCCCAAAI5CSgo0QS4HofYA4UmHpwoKckykjghr7WJO2IbzeFi+zVsSblKHJ6UBTc+vCi+gBjq6Bzqzo7xMCanF8dpOhQgfOmQhY0IIIAAAggggAACCCCAAAII9I2A17R4qYuFKymEsVRFuYuyFgUseqDhQzFAyepWVDFjQUoMZGJQ430pwFFwEw/zTtRSS3akkhqWAgUYdlQgPqdGAAEEEEAAAQQQQAABBBAon4BPuGtZiY8+8sxENzEm8XlcsuQkximxQia18Jgl7ohDiqxtnPvFVnScwhzruEkpTvytkUixbfmo+80rJnzpN28FTwQBBBBAAAEEEEAAAQQQQKAMAmmIkd8rGfExKVm8YhUqTV4Nk6pZFKoogLF7hSnxIGPScKJ4qFfKKIHxJSYt6baiYy2Mac4qY7JG3OUsQPiSMzinQwABBBBAAAEEEEAAAQQQKLmAByieqVgkYqGJpyd67I9ipYoRKTTxzMVzmRiuxNFKtm6hTZxY1xvGxwptsnBGWYyCFx2lwEbDl1iKEyB8Kc6eMyOAAAIIIIAAAggggAACCJRQoJJCFQtFlJWkSXUVtPiQIYtM4lwuEUdVLJ6i6E7H6oGCFm33Gx0X0xX1p7AlDjXSZLwKYKxR1k6HsOQvQPiSvzlnRAABBBBAAAEEEEAAAQQQKLWAgpKYhmhSXY9Hsk0enNTYKFPRHDGxle2wxyqUSdu1QeFKCnB8eJJviSGMutKVldQ9S3ECXO2oOHvOjAACCCCAAAIIIIAAAgggUFIBhSnjvVolVrCooEURiYYVqfolXuUoBi3xktK2bvvS5aW9siWz0/YsgvG1OD9MjGE84vHwJmvMXSECVL4Uws5JEUAAAQQQQAABBBBAAAEEyiqgahfFJSph8XldbF3DhWK8ou32ZcFMGjQUq1wyLTvUhyT5Q9VTxOglDmXScbapxbZngYtaqCom9u8HcVOAAOFLAeicEgEEEEAAAQQQQAABBBBAoLwCKTzxwhe7DpGGFXlm4rfRJYYlFpoop/EwxmtYvPKluanigYriGR9u1GxH+1gkJTOxp6SrUIZBR0mjuHuGHRVnz5kRQAABBBBAAAEEEEAAAQRKKKABQZ6p2GtX5Yv/0gavdkn5iYIU/21trLpFmYoWVbSoksVWVfPilTPeTlvidluJx6q/ioU7aYPfc1OEAJUvRahzTgQQQAABBBBAAAEEEEAAgRILaFhQDE5arKqlyUMXC1Uq2bWJLGjxihZVrXg7JS8WpKhCxlbjQKPUxnapPMZ2aHttu3SONqGMt+EmbwEqX/IW53wIIIAAAggggAACCCCAAAKlFlAlSrrctCBU+RKrWJrjRLtqkA0X0igib69hRd42Zi2x+iXGMGlyXh+ipNYe0KgKRlUysX/f6D1wU4QAlS9FqHNOBBBAAAEEEEAAAQQQQACB0gqogsWrUVTW4tGKKJSyxOBEs7QoONFjVbq0ttW6LV4pE4MXb6dtcZIYO0R9arE9fqzWsr7jDm4LECB8KQCdUyKAAAIIIIAAAggggAACCJRXwEMRC0kUijR5WGLhSBaUSEWrPtxID5TB6N7zkzh1rlfN2ES9imhiwqKgJWsY05rqgX6snUOtWYoTIHwpzp4zI4AAAggggAACCCCAAAIIlFLAYxN75aluJQtObIsyFLuWkau0WJDS7CGN9is8ydrbQ3+U5SmKZFJPfrzdNFt770UbtN9DHu+WmwIEmPOlAHROiQACCCCAAAIIIIAAAgggUF6BSgpClKkoGPFqlXivKXf127+snR57iKJ4xYcbyU2T66a4pTWQSdt1gB+j4EYhjPqpVsSU173IV07lS5H6nBsBBBBAAAEEEEAAAQQQQKB0Ap696IJHXs1ikYmHLLqPQYlCFA9QrGolRi/xSkYqYvH5WySmJmqvoMY71EYfyOT3GpqUKmLUJKYxWmEpQoDKlyLUOScCCCCAAAIIIIAAAggggEB5BWK2Yq8/q2mJd/FRVqHic7goYbGv6jAkF1M1jCpaMr54mSTryiOWrMd4Am/iqynUyY6pufv086/CBx9/VrOF1b4QoPKlL1TpEwEEEEAAAQQQQAABBBBAAIGJCHj1ioUmcbiRNbLApdlCkjgcKYYoOlTVErrCtA83srSlyYOZuD9lL03N2dAii100qa6Cmdgiq5nRdajVebvlldffDbsdeGL48OPPfc9C880Rdt9hk7DB2iu0a8nD3hCg8qU3FOkDAQQQQAABBBBAAAEEEEAAgToFVLUShwtlB+ixl7LEqxnFrdm8Lp6bWAMFKBpm5L9iCwUw4y1ciUUvcWiS7c7iFwthtG436lu/apfxlUrYbvP1wr3XnBoeuP7MsMRi84eTzr0yjB8/vrYZ670kQOVLL0HSDQIIIIAAAggggAACCCCAAAL1CKTgpUnBiOpUlJLYolvfogbKWuw+jkLSsKG4L9thoYo3sGa6V1svoIn9eT8xqPELUmf7dI60qNJFX2nZbIPVwjU33xdUEbPQ/HOmzdz3kgDhSy9B0g0CCCCAAAIIIIAAAggggAAC9QjEgUFZ8BLLVjx4UY7i1S26t0XxiV/9yHfYOCULXDQ5rwcw3iCFMnoQ+4uRi1oouLFqGG+urZ0vjzz+bBg+bEiYc/aZOm/I3m4JMOyoW2wchAACCCCAAAIIIIAAAggggED3BOIQIzvWK1IsNMkqX/yxusySkjQnjNrrSkgKZnTJaK1WtG4NNd+ut9d2X7WP+bbPK2W8HCZr0En68ti/XwjnX3Zz2GPHTcOwoUN0AEsvC1D50sugdIcAAggggAACCCCAAAIIIIBApwLKUVTXolAlJiceqmhdoUposnoX3Wf7tOohix7rt3b5FrWNrbTF53aJm+KR1lCZi7Idy2Y6XF7435th38POCJttuFrYddvvd9iGjT0XIHzpuSE9IIAAAggggAACCCCAAAIIIFC3QAxEFKcogEmpiLbqS2GJbc8qWTw4sW0aPqSW2u5Dj5SmeEfaaF++qOpFw49sUeN4gB2TbfM2rTdP/PelsNevTw2bb7h6OHjvbVt3sNbrAoQvvU5KhwgggAACCCCAAAIIIIAAAghMXMCHBHkyYm08IFGoYqt2U52nxSKUNBopztviuYoHL57XpIRFnfkSO9JcLx61+Pa0rr6zZtndo08+F3564MkevGy3+brhrXc/9D1TTTk8TDfNVG0bfXUMSwAAQABJREFU86jHAoQvPSakAwQQQAABBBBAAAEEEEAAAQTqF9Bgo7jEgMUfWzii0CRmKVYV49UvFprYpaTV3Ico2b0PS7JG6kF5it+nB+pUVS6ezmT7bV8cjtR2ytfnXnrDLlNdCdfccp9/6VAt2262Tjhs/x3jA257TcCqlaoxWa91SkcIIIAAAggggAACCCCAAAIIINCxwPNvLxqTkRSwqCyltZylelAsVqnWsljQ0pqyqLkPT7IIJh4e93mti+1sarY1y3DiXC8WyNjuxeZ4vto3K/kKUPmSrzdnQwABBBBAAAEEEEAAAQQQKLlALIHw9MQksstB+1rMZLRNIUrMWuIVjWLAotqYGMFotx55QOMJi9Z0BSTbb40rdhLLX3y/H0PdRaHfdYQvhfJzcgQQQAABBBBAAAEEEEAAgbIJKCBRLOJXNPJUxWKTmqCkWaGKlap4nKKQpTkGKx6lWIiiKhbt1/wwWrIIxnera7XWzfhqKJOO1w6WIgQIX4pQ55wIIIAAAggggAACCCCAAAIlFkhDhWIoophF1z5Ki6/HXMWClhjEeEajUpa0+Gq8NHWzhSxe2KJtacXXa0Mdj2TS0dznLNB2xp2cT87pEEAAAQQQQAABBBBAAAEEECijQEWBiV64hSWaUzdGI/FS0Ro+lKISz1LUTG0slYnTtiqQscoWlbloiJH6UUjj9zYpb7Ye+1Uwo/6UxrAUJUDlS1HynBcBBBBAAAEEEEAAAQQQQKCUAj7sSElJNYARQ4xbFLL4anbvj7XJ0haNIvIgxZr6kCNLY1p8ow5pDVeagg1calIko9BFv3SgPWQpTIDwpTB6TowAAggggAACCCCAAAIIIFBKAQtSFKpoKJEWBSia/yVeVbq16sX3ZcGJwhZVu2gYkm+vhjEKYrQjy1e8ncU71l8MbmJ/3saP5KYIAcKXItQ5JwIIIIAAAggggAACCCCAQGkFNORIdSoejiiIySQ8XLEHtru6La7pikiqfNEOHRmXitraqh+nPhXAqDNb93vrxStlfAezjmRshdwRvhTCzkkRQAABBBBAAAEEEEAAAQRKK6CqFP2y5MRjGIUm9ivYcCElKFrTjfb7VY0cKlawZLu8gY5VtYwaZsUvfpzfpGO9M7XzFe+Jm/wFiL7yN+eMCCCAAAIIIIAAAggggAACJRbQfCzVgMUcNDuL5mVR7NJmslyfSdezFW/vFS6Zm4KX1Ic2aV1fHsZoX4s+7seAx/dkfdlGlgIECF8KQOeUCCCAAAIIIIAAAggggAACJRbwypf4+hW4ePGKPYxhikpW9MACFO3QqqUuvsk3xHUPbLLtOsD317RVvBMDHQUyrX15h9zkLkD4kjs5J0QAAQQQQAABBBBAAAEEECizQAxS7FLRmsPFopdqUYoCF/tS9UoMT+zeGqcQRcdVdCUju9eXz+2ibR7K6Fjban2qP3tkj9VI4U3WPj7ktgABwpcC0DklAggggAACCCCAAAIIIIBAeQVSsKJkJf5SqGJfGo6UTd7iVytSxBLzmQxLaYpCFUUrWoulMcpe4pwu8bFXzSh+sYfezm50z1KcABPuFmfPmRFAAAEEEEAAAQQQQAABBEopYHUQ2QS4LapksdIUFcH4PC1pu+coMT1R2OKLBzM220uzRTVWHqOgJha72LpKZGxRIKPLSqewRWt+lSTfy01RAoQvRclzXgQQQAABBBBAAAEEEEAAgVIKVLKBQTFSUTxiAYkClpi1xGoXxSf6rflarL0m2NUOj1WyyXSF5yFLdtPSpMEt8Ti19ktaW79eTaPGLIUJEL4URs+JEUAAAQQQQAABBBBAAAEEyijQZOGJ8pIsdvFgxa9yZGUszQpYFMJYA1Ww+IpfglqrOspCFTvSq1n0sFr9EitoFND4fjXU4d4HAYw4ilwIX4rU59wIIIAAAggggAACCCCAAAKlE/DLQVuQomoWVajEahYxaLJdJSYZiQ83ihFNS5xFV02q++Nx1R78IA9srFHMZaxFXFEKk3XKXREChC9FqHNOBBBAAAEEEEAAAQQQQACB8gpYIqLoxWOXlIlYOJIVqdh22+gVLZaceDO78Wli7LH/jvs9UPF2ah4DF58/xhopc7HymNjeH/iNtrIUIED4UgA6p0QAAQQQQAABBBBAAAEEECivgIpQVJHiAYxVtCgj0ZKuWOQPfb9ClbgvximxodZ9Et6U1ijMaU4HWAjjx6hNPDaeKTtJ2sR9rgKEL7lyczIEEEAAAQQQQAABBBBAAIGyC8SqF1PwZCXO0SKTGLrY9LpKZ5TIaEPKVGyb5nKJS6yS0bq2aP4XBTI+iMnCHAUxPoGvGqgyRh21JjHaypKzgKZCZkEAAQQQQAABBBBAAAEEEEAAgZwEKqpUUaiSBSsxZbEAxa5WpOsaKTDxapjqfgUoHrP4M4yZTNyizdqT5nSJ88nEIUjaUdEGnc+TnJxeIKeZQIDKlwlI2IAAAggggAACCCCAAAIIIIBAHwooMPEERYFLjF4Uj2jkkAclqmRRBYvv00Y1tsWPy6pefFPr8drpc/L6lZSsRkZzxGTH+RCl2AO3BQkQvhQEz2kRQAABBBBAAAEEEEAAAQTKKdDiZS0WjqTgRSUwtig80UblKukS0XocLx1t2z1wsZgmNlBrX2I8o/3apxoXa+BJjCIZ26sDs3OkY7jPV4DwJV9vzoYAAggggAACCCCAAAIIIICAUhGbYDeDsOFGGigUI5gsJ7F9PpeLQhMLT3QVIx86ZOs6LFXMqCNtj1c50n3cEqxP79EbpuAG+KIECF+Kkue8CCCAAAIIIIAAAggggAACpRSoxDxFKYkFK3aXVaXEmhXt1K4YqAioKQtglLgoUEkP1Y83VhqjgEYPdesBTRq3FNvHk3kDbgoQIHwpAJ1TIoAAAggggAACCCCAAAIIlFdAIUkMUBSlqJLF7j2EsR02bMgfOI9t1FAiD2Kil3IWBSl+RaTsaLuLi/rw/uK9Nsfes/3cFSZA+FIYPSdGAAEEEEAAAQQQQAABBBAopYBVpih9iaFKjFNi4GLbVN2i/dqrhMaDFT22ShY/LEYqsbrFu8kOjbGLghxdMcl7tX50ZSW19YNLid0/XjThS/94H3gWCCCAAAIIIIAAAggggAACJRFIw4wUrHjVS0xY/NV7aOL5StzjKYoFKF7B4sGMHWP7U6biTXUTbI4X22jXTIo7bYseaVGIE9f8ITcFCBC+FIDOKRFAAAEEEEAAAQQQQAABBMoroChFvz1AUSxik+N6OqIhRhp/pNoVXTLaExO1zaITbdBvq2TxQMXWY42LHeeJjExjW1W/NFt7TeqrHvXFUpwA4Utx9pwZAQQQQAABBBBAAAEEEECghAKqQ1FWokDEa1ps5lxlLqlCxatctM8TE7WNw4c0esiDG820mxW4qC9fvL/Yox77ZaezyEXBTNYqtuU2dwHCl9zJOSECCCCAAAIIIIAAAggggEDZBfxKRapg8UAlC1UcxYIWu9egI1/srmLhiS47rflbFKooU/HjLZTxx9lxMWLJjlRb68PDGh2SdRc75TZvAcvKWBBAAAEEEEAAAQQQQAABBBBAIC8BDQlKk+pqbJEea1E+ouBFawpXvJ3vUyBjG3x0kh2bgpQU3CiM8aN0ZKpyiSGOd2c3FaU8LIUJUPlSGD0nRgABBBBAAAEEEEAAAQQQKKdATE/8ykYC8GFBCkf0lVWr2KrHKB6aZIGKj0OyY31frGbRpqZYKuMBjHpQOqNwJ84fow22UPoSHQq6JXwpCJ7TIoAAAggggAACCCCAAAIIlFPAK1cUqnggosFBaTUGLzEnSSFLDGq0LWYvOs5/2+MslFFfam73ymGabbuGKDXHzbYrzSJTTu/+8KoJX/rDu8BzQAABBBBAAAEEEEAAAQQQKI2ADzmKCYwFJvayY76S7mISY0mLb9aN2ihIsWNSc1W16JdvV0vfER9ruJIepiFM2h2PtI0shQgQvhTCzkkRQAABBBBAAAEEEEAAAQTKKxATFdWtWH2KBSXxktCxtMWCEiUn1UXJSdzgQ4lsux75JgtjPISxBEdZTtqm6MUvMa3TqK19tU7M65u4yVmACXdzBud0CCCAAAIIIIAAAggggAAC5RZQUKJwJF6JKAYvMSfRRluzFCUGKdFJ6/6lXQpcbHPsw3ZoiJE3i9uVzOjqSGqk7TqH2qdJfb0pN7kLEL7kTs4JEUAAAQQQQAABBBBAAAEEyiwQhx2ZgEIVu/OJcT1UsQDFJmrxMCXmJ36VIs9j1NCXWOXi45X8GKUtWbiiYzylabZ+7YH6T/PCVI9P/XCfpwDDjvLU5lwIIIAAAggggAACCCCAAAKlF2jRdaSzSXKFEXORWKFieUl8bCtewNIuNFGYomFFLS1Wy5I19vua43xuGAthdKi3tft0Fl/lJncBKl9yJ+eECCCAAAIIIIAAAggggAACZRZQdYuCER8SFBOSGLhom1WxpADGK2AcSu3tlwcy9jHejmmyuWIqWcCidl7wovvUnzqxL6+aUYpj7VmKE6DypTh7zowAAggggAACCCCAAAIIIFBGAYUmlod4mJIlLV7lohKWLDDxBtpni0c1HrTE49KQI11aWpUw3pFV0/hj5SwxnYnb/WE2lEnrLIUIEL4Uws5JEUAAAQQQQAABBBBAAAEEyirgFS1Z6KIgRXmJghhf0rAiT2HiJt9X3Z81s+PUT5Nm7rWlpUmVLVl1jI617R7M2Kq38FDGm3JTgADhSwHonBIBBBBAAAEEEEAAAQQQQKDcAqp88UtC24pXrCiCsZTFC1liXOKBjIITzeGiRe3VwCfVtdV45aM4q4sPS/KURh3HQMf7s+P8stPeAzdFCTDoqyh5zosAAggggAACCCCAAAIIIFBKAZ/rxYKUioUkilQ0/64nLVq3uVmUoWQFLT76yK+O5JUuClXix/iYx+j4dKWj7OO92qm/uCt2a4+51LRTFXZD5Uth9JwYAQQQQAABBBBAAAEEEECgjALV4MTGDXmxiiHEe6Umtp6VqqiaRXUtilziMek+S1Y8YfFBTFnIkrZbH3aAH+3BjvqPffsJuMldgPAld3JOiAACCCCAAAIIIIAAAgggUGaBWL2i4UZS0FWLFJO0LlpXVYzuFbq0VJqztjFQaW6q2Hbfq1TFurAvv3x1bK89qfQlXZo6PfZd3OQuQPiSOzknRAABBBBAAAEEEEAAAQQQKLOAIhSFIV6LEid5yUKUGJ6k1CXWqlg7a6N5YTxosTRGQ5PiYi1sc+qiTcCiyhcPZdTADo1nKzN7oa+d8KVQfk6OAAIIIIAAAggggAACCCBQOoGWbN4WBSJat3DE4xFdLtp++Xwvvt0eK4Gx4EWVLhpKFAchxUNasjaeq6iNd6P71rBGwY2OYilWgPClWH/OjgACCCCAAAIIIIAAAgggUDIBjRRKQUosS7FqFs9H4mS7TRprpEWBi+5UxWL3rcGMdnpcU23jkYu1b8rCFo9pWmx4krXzohmdlKUwgVSrVNgT4MQIIIAAAggggAACCCCAAAIIlEkgZisWtNiL9soU5SKqYtEGrWoeGNumqXRjZhJDGY9gvI1FLbEkJpbA+EH6eG/bdYB3bK2VuqRtasNSmACVL4XRc2IEEEAAAQQQQAABBBBAAIEyCnigYgGJQpYmvy60KXhOEitdvEqitVHKZGJ7a+j1LBbWeGubjFcxTaXZal10jJe5ZKp+Dq17HUy2kbsiBPw9LeLEnBMBBBBAAAEEEEAAAQQQQACBcgrEqheFIl6okopVFJJYuYvyGBWvVJrULgYymt9FFTNxIJFlLHag7/PQxj7a+2Md5L9txfarcy3WD0uxAlS+FOvP2RFAAAEEEEAAAQQQQAABBEomULGARPO36LdCFi0aRdTSbMONbEuMZmynghQfOhQjmDiMyA/TrrioA89YYmdx7pjWfn1SXu/VG6WjuM9ZgPAlZ3BOhwACCCCAAAIIIIAAAgggUG4BD1yUlWQrmiRXoYmqXhSbxEtJ+06HarKql4q18WoXu/eKFqU1uuS0Hnsru1G+4tUusaLGN6idbyN8SUxF3BO+FKHOORFAAAEEEEAAAQQQQAABBMorYNUsyllSHBJDmDhcqMmGCHle4jqxhaph0iWmlbQobvH5XWraxFXbmQIYJTLpBD4PjDawFCVA+FKUPOdFAAEEEEAAAQQQQAABBBAopUC8IlG6vLQImkOzKlgUrFQzkiZNxxtabAKYFs39Yvc+AskTFc33kqUrWVKjR82qkPHtyl0054tCGjtWBTJ+XCm5+8WLJnzpF28DTwIBBBBAAAEEEEAAAQQQQKAsAh6wNFtZSip/Ueji4Uisb0n5i4IUzfOiqMXSGU0AY4/TbC+xrEVBTgxlbHc60I9Qp2qf3WehTFmM+9vrJHzpb+8IzwcBBBBAAAEEEEAAAQQQQGCyFvApWCxI0VwvHrr4fXzJnp/YTRwpZLUvCk80Ba8lNr5PIY1WYgOPbFTXov1xm+33XEaRjSbvjcf6vslatX+/OMKX/v3+8OwQQAABBBBAAAEEEEAAAQQmMwFFIkpQPHjxJCZ7gQpN9Nh+e75itxVPUnyHb/csJm1TO2uotmmJkYuaqh8bhuShTDxfasN9/gKEL/mbc0YEEEAAAQQQQAABBBBAAIESC3iVir1+D1JU9aKiFXl4EKPHcShRurS0z91iLRTWxCZKXdSBDkr9ZBUuCnY8kFEDday2WdDjrbkpQoDwpQh1zokAAggggAACCCCAAAIIIFBiAQtE7LfmaGny5MWufuSBSwxeYnoSQxOFJymEcTClL/Y7lrxoxVtX7xW5eN5ijTQ9TIxdYjtvxE0hAoQvhbBzUgQQQAABBBBAAAEEEEAAgbIKeECiG1t8CJKnMDFPiRtj4JJyFl1W2puoSsZDFTvYJuD1ChnvxB57p9lwJl+3HZ7CWLtmbWApUoDwpUh9zo0AAggggAACCCCAAAIIIFA6AR8+pLxERSxelGIBiSlonhb90nalKVrXjorGJ1lDVcfookdeCaMD7Mvbxk50kB0R53mJFTVxf4tN7qtYhqU4AcKX4uw5MwIIIIAAAggggAACCCCAQAkFVLGiXMXTEx8aFB+rriVVuMRgxRt5COPzvthDn4DXhip5UYv2aD4Xb6Yb9RCDGg94bN0DHAtv4sS9JcTuJy+Z8KWfvBE8DQQQQAABBBBAAAEEEEAAgXIIpOxFIYwKWDTzroYWKZHxHCVt107foAoWW0mVLrY5xipWDWObVRjjh9uNevTDrL2HPN62tR9bYylAgPClAHROiQACCCCAAAIIIIAAAgggUGIBhSVZTNKkkMQoYpiSVbFkIYoHL7bTimOyVQUqtq4gxo+x9jo4C2a0TRUuTap0qVbHWN/qzxuqBUsRAoQvRahzTgQQQAABBBBAAAEEEEAAgdIKaJLdOBAoBi8qX4n5SaxWsVlbbL8uHR2rWoJNmFvNTmyb8ha/8RBGx2iLdlgo4xPxRtpYWaNYR3tjYBP3cJu3AOFL3uKcDwEEEEAAAQQQQAABBBBAoNQCGhikYUbKSnSjCCbOyeKxSrYeiVqsikUhii5Y1FI7a64d68fZ9mYLYXyIkfqLk8ZkB7cpionbuC1EoPatK+QJcFIEEEAAAQQQQAABBBBAAAEEyiZQaVL1i6UlFp5UFJ44gH1E9xU9VpJiD9NjNbUKmdgubh+vNvZbw5I08UtsavPA6Dj70nww6qfFUpvUn5qy5C9A5Uv+5pwRAQQQQAABBBBAAAEEEECgxAIVXfjZ0pHqfC+emvhNtRrGs5dUHWNWPgRJYYq22WMd29Riw5M09Mg2tIYrWrP+m3z2F9uehTJ2HEtxAlS+FGfPmRFAAAEEEEAAAQQQQAABBMooYEmKAhQFKn6vAMUiE69gUaVKZhLbxLlfbHBRbB+b+oS6Cl58uFFte6uo0Ywx2u4VMFlYo8oYluIEqHwpzp4zI4AAAggggAACCCCAAAIIlFCgxQISJSweh3hJi9ZjZYoVs/jkuwpOsi2+pkDFM5pU+WJbfXoXu/d+UgVMViKjO+3xSpkJJozRPpY8BQhf8tTmXAgggAACCCCAAAIIIIAAAggoQLF0xO58+JDSExWm+BCiNHeLpS/arwjG77LQRRs1Ca8fY4FLJR6oUUbqzLdnOz148aOtueZ/YSlOgPClOHvOjAACCCCAAAIIIIAAAgggUEIBVbF4ouJBSsxLvKpFFgpJlLr4fcTRw5jA6N6OtQfVnEWXqbYt1UNsh36pgkZt0/ZsTJNtZClCgDlfilDnnAgggAACCCCAAAIIIIAAAiUWaJ2rxeKRGJaYhg8Vipco8jQlhS7arsjFk5SsnbIV325hi9ppv6bY1VAk9ejb7EZtdDUlzRnDUpwAlS/F2XNmBBBAAAEEEEAAAQQQQACBEgp4OGKvW8OMmiwd8SIVC0y0xNFDimQUp8TwRLu0V/tiiKKExetbYgBjW/0KR2phfVasT+UtHuv4gfEcfjg3hQgQvhTCzkkRQAABBBBAAAEEEEAAAQTKKqDqFC0KXuKvWKminERLvIJRiltUsWKtsmOUybR4FYs2xH0euNijJpW7+KIrI6lne+zttT11kDXhLlcBwpdcuTkZAggggAACCCCAAAIIIIAAAjEkiXFIDEq0JVa2ZKFMsypbLFxRiFJptnxFrWOg4usaUuTJih1pv+McL2qu47TE2zg5r9bjY9/V7mb8+PGhuVnnmHibdofwsEEBwpcGwWiOAAIIIIAAAggggAACCCCAQE8EfMJdC1YUn/ikuH5nwYdnLXpg6165orNYOGOXMlIw0tKShTFqqGMVqCgv8YoXRTFpe9zdYgGOX+ZIbby97tsun3/5ddhsl8PCb36xc1hrlaXa7mz3aJVN9g5ffPlNm60H7blN2HnrDdps48GEAoQvE5qwBQEEEEAAAQQQQAABBBBAAIE+E2iyEEXRiX+pUsXCEa1XbDySRzIeqNgGu48XN1J1jLWxrzjTS3avg6ptPMqxRs1WQaM5X3SA9meNPKWxxzXLQcecF+554IkwesxY61vtOl/URGHL6isuUW34remnrq6zMnEBxWIsCCCAAAIIIIAAAggggAACCCCQk4CuPhSjDkUpqmhJQ44sOFEQY499vw8tio/jVYxiIYvvr+6zCXbteetL2z1s8f5VJaNtSnJa7/1BdnPw3tuGGy8+LgwZMrh2c6frs8w0fZh/ntmqX9NOPWWn7dkZBah84TsBAQQQQAABBBBAAAEEEEAAgTwFPFxRKGJDhawyxeORbEhRfGCBjG2PYYqaWQv99tQlC268siVu93lesj5VwaIW3mtWUqP9HV3vaIbpp/FXrWb1Lpf+7c5wt1XLzDHrjGGrjdcKs88yQ72HlrodlS+lfvt58QgggAACCCCAAAIIIIAAAnkLKEtRkUpFc7RYqYsm1NVjbbfZXWJw4oFJttG36Rh9hNd+a5cNXaroeNugihnvNVW9eJtUFaMjev7xf6N1VwwrLr1omNWqX+6877Gw9e5HhQ8++lQnZulCgMqXLoDYjQACCCCAAAIIIIAAAggggEBvCrROjKvKF6UmCkeyxVIUDSHyCXa9ciXbZ2GMhh7Fqx7F9MaP9dAlBjDegx0cq2liG8tqdJBtrDlHdqpG7w7bf8fqIbvvsElYd6sDwj8e+U/YepO1q9tZ6ViA8KVjF7YigAACCCCAAAIIIIAAAggg0CcCmlhXc714MBLTkZi/WHGKIpJY22Ir1k7VMNXFq1q0Xy1SKGN7U4CjgMaHMWl/bKUKmdi655Uv1edhK1NOMSxMMXxoGDlydO1m1ici0Lv6EzkJmxFAAAEEEEAAAQQQQAABBBBAIAlYHOLFKHafMhSFLNmsuZqjpWJfcfYWNdSwJN3rd7bPgxj1o3Zx+3ifBya7MpJ3Z8foMPWVnSc9A92PGzc+jBk7zjeNHTeuuq4Nz7zwml+C+qlnXvb9Tz//arjk6jt8mJGujnThFbeGjz75PKy4zKK+n5vOBah86dyHvQgggAACCCCAAAIIIIAAAgj0qoCCFy3xTmFKTEa8WkVVLB6yaJvXx1gm49GL38ZLQttjb+PdZK1iAYz69ktZW59ZV34itW+/7Lz/8SGFKz8/8mzf/cD1Z4bpp50qjBw9Orz82tvhmxGjfLue4/mX3RxOOPsKfzx82JBw2M93DIsuOHf7bnncgYBNltxR/tVBSzYhgAACCCCAAAIIIIAAAggggECPBU59bv0YsGQhjIcslo60/XSuwEXjkLKhRzGL8XNXD9MjPy5u0W1rxhIfNanqxbrRlZJ+vthdfnx3bzRc6qNPPw+jR4/xqxwNGDCgu12V7jgqX0r3lvOCEUAAAQQQQAABBBBAAAEEihTwiXObLRzxmXXtmVhiotBEcUuMUeK6z+tiG3ybAhRNxuslLLGVBy0WrmgS3rQee9L+2Kkm39UYJ9/fwxfdbM955hmm62Ev5Tyc8KWc7zuvGgEEEEAAAQQQQAABBBBAoCABv0qRBy8KTWxCXA9UYmwSQ5MscYklKx6cqComRTMawOJ92L22+dWTfJsd7WGMXpjmicmuq6TkJeY1Bb1iTkv4wvcAAggggAACCCCAAAIIIIAAArkK1FSiqDDFk5EYuPjkuL6qxERfWpScKHDxO7uJ187R5ajVJLVUEKOeU0GNJn1RlY2OS8GNHcxSgADhSwHonBIBBBBAAAEEEEAAAQQQQKC8Aqpi0aL5WJSrxKlYY5BitzFQafKJWvTIH8dYJbaPaYvFLNlwo2b1Z+1jP3ZcdgI/jQ5RAOMdcVOUAOFLUfKcFwEEEEAAAQQQQAABBBBAoKQCCk6yjERDhzw4sZDEUhJdYlpRiQcmHqpk6YlSGkUoWWCjgMWHGMWttifGK35rFS9+qJXApO2e8pRUuz+8bMKX/vAu8BwQQAABBBBAAAEEEEAAAQRKI+ABiVenKCSxShWfgdeCEtvhoYkFLJrTxXMYU1GFjDfxUMVqYPTAJr9N7f0ga+PDkPTAO7E7tVdfXhpTGt5++UIJX/rl28KTQgABBBBAAAEEEEAAAQQQmFwFfI4XhSIqarEvZSXapl9atD1ujTt1hSMFKzGA0f4YvOhAHZ8dZg9j6uK5jt34VZDUwK6SFGeJUb8sRQgQvhShzjkRQAABBBBAAAEEEEAAAQRKK6ChRR6aKCzxoUGa30VxS8UqVXT1I220DQpW7Ea/NJ+LjlFI4yUv2T6f5yVbr4LGztWbhy6aG6ZC/FLlKWKF8KUIdc6JAAIIIIAAAggggAACCCBQXgELQ1SjooDF732CFyUoFrxoiwUwcb/dKmvRLwtU1EyPtVRX9TgFNQp1vLVts/YacqQrH/mSHZcecp+vAJVH+XpzNgQQQAABBCYpgXHjNfGf//dvknrePFkEEEAAAQT6s4BCkRSw+BAij0xiOjLeQpNKSlg8QLGmClXsn2P9i+xzuNgEvTFmiY9j0KJX3BTGq8JF3VtjDTvydW3TwSyFCVD5Uhg9J0YAAQQQQKD/CowYPT6MGD0ujBkbf142ZFBzmGLowDDY7pvtP4IsCCCAAAIIINB9AQ0G0kAgBShaWuyfW/3z6v/qKpjx6hVVrth2+7JCGA9PVAHTZBuVo3ggY03jMCQNMIptlLP4sCZ7GK+cpB1a4rniOrd5CxC+5C3O+RBAAAEEEOinAmPHVcI3o8aF0Ra4jNeMfjWLto0eO8aDl2FDBoRhgwd4EFPThFUEEEAAAQQQqFtAiYpVuHjOEiOYarWL9eGBit3H3Ra2KH1R6GJXOIqL3Vsq47/0T3Z2qWrPbezfcJ+cV71og9IbW9r+y+6buMlRgPAlR2xOhQACCCCAQH8UUHXLF9+MCWNtiFFXi4YgKaDRl6phphw2yO+7Oo79CCCAAAIIINAqoH9xNdxIi64CHYceacYXq4jJymDURi1U/eIrWWmMX/nItytYseDGwhVVzDT7vV3VyDbrsSIdhTse7VgIo0l3WYoTIHwpzp4zI4AAAgggUJiAKllG2rCiAfofmv3HrZ7gpf2TVR+DB1VsaNJ4P37KbFhS+3Y8RgABBBBAAIG2An4NIqUq9m+wDxjKchFft21xl+2zFZ9o1w6vhjAKUpTG2G9tbLGqF92nqxn50CXbmcKWauRSXWn7XHiUjwDhSz7OnAUBBBBAAIHCBTSUSPO4jBg1vjqsSEOIBg7Q/966v4yzfkeNGe9fmg9mimEDfH4Y5obpvilHIoAAAghM3gJ+eWjVpCg8qQYpbV+zspJYtWLZiq/HAEahiv/LrTTGA5jYLmYr2mYbdefVLrqPx8eD2p6DR/kJEL7kZ82ZEEAAAQQQKESg/eS5ffkk9BO6r0aM8y8m6e1LafpGAAEEEJiUBXzIUapgyUIUBS2KYjRmKMtPPHSJrzPbZ7lKU5p914coxSDGq108iIlVMOogdms96jw2tikeNymrTdrPnfBl0n7/ePYIIIAAAgh0KNDZ5LkdHtAHG5mktw9Q6RIBBBBAYPIQSBPoKkzJkhavhtEQIitVsQgmTdzi68pVbByRbm0okt34MRao2H2ctNc2xYlePGxRVKNKl3TVIx3r7bwHbooQIHwpQp1zIoAAAggg0AcCGlakwEOT4Sp86S9L+0l6h9qVkjTciWFJ/eUd4nkggAACCOQtoLldlJ8oI0mT7fpj26CMJQ4ZUrWKnplFKWrroYzVx8SN9liXq7bF/8nXcbFDP15VMR7G2Fwwtt3DmP7zXwM969IthC+le8t5wQgggAACk5tAmjxXw4v6+xKrYSo+LGmwXy1pYBg80H7Kx4IAAggggECpBCwOicUpilssHFE8YuGJ0hRPVIRhAYoFLR6peGPtty+FMDFhsXt1Ylc4qh6mfhW4pKY62vIZm2A/ZTa+gZvcBQhfcifnhAgggAACCPRcQFUumuT2a6tyGV/HJaJ7fsbe7UHVMEzS27um9IYAAgggMCkJeC2KhyRe5WJPPcYkWf6igMXjmBim6IpG2q9cphq1eDmMNuqKSdquPhXG6HLVFtoogNF2rdj/G2KMYxtYChEgfCmEnZMigAACCCDQPYE8J8/t3jNs/Kj2k/RONXyQX4GJYUmNW3IEAggggMCkIaB/+xSXKB3xwETBidKVGJdYlYoeKEyp2K1+xV3pvjVIUShjPVjAoh7VibexWph4jnhca3s1YilCgPClCHXOiQACCCCAQAMCqnL5asTYMNrmcZkUq1waeKk+Z83oL0b7fDDDhw4Imh+GYUmNCNIWAQQQQGBSEGixcCSGJHq2FpxYcqLH1ZDENvhFjTSgSOsaR+QHxNBG875o6JHHMwpqtM/+vxCLXLyh96sefbfd2JptYylKgPClKHnOiwACCCCAQCcC/XXy3E6ecq/u0k/rvh45zr90yWqFMMNtkl4vne7VM9EZAggggAAC+QsoCFHQ4jGJ3fgwIaUkMWuxMEUb4/NSO5/7xbfFoCZLYrwP35ddfroa3uhQO77F5nrJxiTl/yI5YxsBwpc2HDxAAAEEEECgWIH+NnnuAPtPW7N9FXn1pNpJeocMbg5TDGWS3mK/Szk7AggggECPBWJZi+Uj9stCF79ktNZt8hYfSOSBjDIYJSgKX6yNVrNAJs7xYs9Cj22ftjfZXC+6ipKXuti9shpf9/ljrE2PnzQd9ESA8KUnehyLAAIIIIBALwikyXN1iehx/WTyXFWZDB8yMAwYYJP4WRmz/fZLWCsI8Ssr9MLrbrQLVcOMtCs66UuB0JQ2LElBDNUwjUrSHgEEEECgaAEVucQkRdUvCk+UnuhZ2b+7Nfvi2CMFKrGAxZ+3749tNSeMhzN+pNopyFFzhS0KbBTv+E7fp1WWYgQIX4px56wIIIAAAgh4iPDN6HFhjAUa/WFRlYsmu9UwH4UsX44cW31uflloCzqmmWJQGGlXWdKViop83gqEvhwxzr/0fPW8B1lQRBDTH76TeA4IIIAAAl0KeJ4SLxCtYUO+WDVMLHTRY9tnD/TDj9YKFm1SpYxaW8LijWM7T1jseO1q/SGJtbWD/WpKfozf6GCWAgQIXwpA55QIIIAAAuUViJPnWuAybny/qXIZMrA5DJl6iFe5aGJffel51i4KWj4dO8bDDVXFTDVsUAjD/L9+9jqKDY98WJIm6bXwSM+NSXpr3znWEUAAAQT6o4AqXxSi+MS7/m+ufoBgYYuqWlSxonAl/VOsYUd6bLdpol6tabiSL5UsxIl3dnjtsa3deJ/xCG4LECB8KQCdUyKAAAIIlEtAQYbCi69tWFGRc6fUqlerXCx40fOrrXKpbdd+XT9N0/AofakaRpUw00wxOAwaOK5fVMMwSW/7d4zHCCCAAAL9UUAhihaficXCEg9T/LHd2M80/McaClFi5mL7bVUhjCpfPHOxKCVu9McKVrTPAxY72Cfh1cHVNlpPaY51xpK7AOFL7uScEAEEEECgLAKqyNAQnREWVPSHRf+HG2ZXDdI8KaoS8QoXq1oZMKC5W0OIFCiNHdcSRowb6y8vVcNoSNIIG05V5P/xvBrGnt9XdsUkDUtikt7+8B3Ic0AAAQQQSAIVC0hihuK3ttnCGAUr9u+z5yV+a5s9SIkZih+rf8yzJUYp9thWUiCj9XhV6tiPmrZoOJPtiNUz6Wju8xYgfMlbnPMhgAACCEzWAqoiUfjQnybP1VwoUwwbaCHEAJ/L5QsbVpTmaxlmw3QGDOjZW5Imwk3VMAp4Zpp2aL+ZG6btJL0DLYjhktU9e8c5GgEEEECgNwQ0H0v6QYUyFQUozV7y0hqUVIMYVb0od8mCllT14rUztj2GK7Zf62qrX77db+w8ds9SqADhS6H8nBwBBBBAYHIR0Af8/jR5rv4Tp7lPprQqFy0KRr78ZpxN3Kf/xvXdolBHX1/ZZLgKdqa2uWFabG6Y/lANEyfpHWuT9I71ahgm6e277wN6RgABBBDoXEDBS1rikCGlLnalI220fT6XrjeI7eJe3xADGK3WBCrVuWDswHRZagU1CmP8X35107f/BdAzYulEgPClExx2IYAAAggg0JmAqlw0rGXM2P4zea7mYYmTzg4Mo60C5/NvxhYyz4xCHgU+/bEaRu8pk/R29p3NPgQQQACBvhZQJYoHLCkcsWFHXv2iH5LYvpiTxIFClTiOKLTY/zu8kT25lKXoXh35YXZUterFX4Bd/SjusJKadITv4KYAAcKXAtA5JQIIIIDApCug/8SMGlPpV1UumjxXoYvmXFF1h+Zb+fKbUX1e5VLvuzhBNYxdFlr/F+wv1TBM0lvvO0k7BBBAAIHeEtC/gz7Ni5W0xNAl9pwqWFSmoujFQxjLTTxkUYBiQYwm09V2bavoVhUwSnLUvloN4/U0sdolC2fUnqU4AcKX4uw5MwIIIIDAJCQwZlwlDLT/9Lz/2ah+86xTlYvmclHA8emXo8M4/VSsny611TCaBFfDoqpzw9iwLRkXudRO0juzzVkzzmZDHGSTEbMggAACCCDQ2wKekXhFi11e2kITXWZa/4LHf8Xt1gOVbIPyFa1aYhMDFG3QZan1KFa7eBSjRr5L/fkeD2r+n713i7Gt2e67Zl929+59+/b+vu9855zvHJ/v2A7k4oTEJCASHMBGQuRGAhEPICEFKW88AIoQDyCBBELwgISASAglD4lPEvmSEMEDDygxigNBQJTYOTKOE8d2Yvtcv8u+79594/8bo8actWbP1b169VprrtU9au81q2rUqFE1x5w9q+Z/jhq1LZTHwB4DaMSTYRQNJPgyitqz0dRAaiA1kBrYBA1gRcIL+fPXR83xyVnzhSd3R+/2kJXLZy98t6HRO3eFDrRAR/iG0ZbVTCHZHYqlSjZJvIK8RbJy3ZngfuezwwZ9s1NSOuldpIZTVmogNZAaSA1g9hL2K7W1ii8hwrqlACutqsgLUDFUJTzAFJpGUJdl2IuNp8FBOycMqibP+VuRmVipBhJ8Wam6s7HUQGogNZAa2AQN2O44AgFYFlOHLZu41JTVpc3KRZYi+/qZlctzWbkIENr0MM0a5khWMCwHGssaJq41fn1w0Fs76d3bTWuYTb/vsv+pgdRAamBsDZgvFjohCxfDUyxd8ti5mBULIAwFCuAnBrI4MGNp4/FCfL2AuoCzmH2MfcUAkqGi1+xAHpOYhxVrIMGXFSs8m0sNpAZSA6mB9dQA1g44zz28wHnuqrGXQSsXOdC9qaG2hgFsejSiNczQtbb+PT1stmUNwy5S9DGBmJt6N+Z5pQZSA6mB5WoA3y4BlmyZZUoB9s0/C2ktRjorDnMZlMqSIQNTBLTYjkZAK4A3CHKYpeu0SKdqY1vzG7eCca6OIVOr1kCCL6vWeLaXGkgNpAZSA2ujAeY6WLfMukU0AM0qwk21cplVd1jDcF343ZGVSfiGwdLnuaxQVmENc5FVEfcBljCE/T31Tz537u3vukX3rCeZfKmB1EBqIDVwqzXAjALQxW1SdBRCYsYrKrAyASe4hCm4ivHJFZnGGuAXQ1bcYS9AjGlSNCUcYglhyESIy3Y+y+ZhBA0k+DKC0rPJ1EBqIDWQGhhXA1gwGOgi3yJXCcvEXsaycgGAWufA8iN+L2WVFNYwuztbtiRpWb5hsGyZNRxq5yt+WE2xxfeBloUBGGVIDaQGUgOpgdTAZRrAasUAFwEkQCotiCIIxdI2SDuoYtYr4mMuYniKyKdU1g9AxoPLMX8y1OVnso0ZW5sMI2ogwZcRlZ9NpwZSA6mB1MDqNIC1wqFe4rGcuMiq4bIe8eJ/nfp9+WNbuSzCmudkBb5namuYbU0k7x/sygHygVnBLNoa5grYS3s50WNsWd056U1rmFZBmUgNpAZSA6mBCQ0AnBiIAsyiMcSsWQxnUdowE8ATVXEmbF1EF5fx2EFlMDjGYgyWM0qL0BTJBvLYttQtTyZWrYEEX1at8WwvNZAaSA2kBlaqAXbPwYEuli7XDYsAKugDL+cHspJgqQoyX6l/n71cny2sr6unZdcHiAFw4cc22/iGWbQ1zHWude2k966WJT08uJPWMMu+KVJ+aiA1kBrYNA0YmgK+UqxcBKSY01zlKQItMWjFAJgCsMDreAsM+sFp3Dh4KUnqFwBH840z287auYNVnBlG0ECCLyMoPZtMDaQGUgOpgeVqgBfny5znztMDXvqvE/BdAuiCk9abtGPRdXRy3bo4SD58etIs2hrmutc6zuuNliS9eds56d2Xk95clhTayTg1kBpIDdxiDWhK4cALRwdVSspBF6c6oGK8Sha8xfkEuti0BNsWlZmFjDNg4cJSJMYyt5Txtsyx7y1W+dinnuDL2Fcg208NpAZSA6mBhWgAXOSNXsTxAwKwsaywu7OtZUezW9HUVi7HJ6dm5fLp87fL6t6tlbtIaxiu8aIDgGA46cUaBouddNK7aC2nvNRAaiA1sDkaYLcj9iHC2kX/DUipgRJKzSeMilrQxYxcNOHRpMfriGCgC7YuZe7j+IvyDs7AZySqQcswmgYSfBlN9dlwaiA1kBpIDSxCA/M6z11E2xfJwPHqfW1HzHKYl1pW9Mnzw4X6irmo7dte1lrDyNyaaxC+YQA/cN47S7jOsqPL5Ls1TDrpvUxPWZ4aSA2kBm62BgSFALzYSfpSI/PJ4gTtdNQBJWbbIl4otnuREp4GmOksX/gQ5QXALIJvbCkTJHiwhrnZGl33s0vwZd2vUPYvNZAaSA2kBs5pACsHQJfrOs89J/gSwtEljmXZJeeRHMHuyaoBK5cXssJZhK+ZS7qVxVM0YMvPKt8w71zBN8wll3pKi1cj078JJ726d+7nltVXU2JypwZSA6mBDdUAQIkBKYoNQBEw4tiJrC/P3IELVivb8HGOQk6IvUgp8pQppsSWGikOkOWUlAS4pFJ3Q3V1U7qd4MtNuZJ5HqmB1EBq4BZoACAD57k40R0r4FukH2orFwCXF2nl0lfR6PnaGuZBsYY5PD4RgHd8zhpmGcuOLlOAOel9edQ80w/fQA8FxKRvmMu0luWpgdRAamBzNcCyI983GnClIC9CUwBcAmhhuZFwesuLyYNNQwSmyJEuU5IzoTEmy+oC3DgAg6CzrQLiWGUxz2b8WRrKaNEaSPBl0RpNeamB1EBqIDWwUA24L49js3TBmmTsgHULgZgXZByoHh3Ln8fro6X6mhn7vG9K++F7hSVI+F0xaxhdy7BSWuQ24vPqDJCRn21ZrXvsru6xMQChefuf9VIDqYHUQGrgcg0AmoCetP5cWBakaoG1AJSEVYuBMyrzGQjgCpkSF+DGgBhK9B/nu77kiKVHXg//MTjhzTCeBhJ8GU/32XJqIDWQGkgNTNEAZrSrcJ47pfmpZMAfnKTevbNvvlzYUenlm7fpy2Wqxta7oG8N87l37jZYwzBxHdO6KrTWWsOIgDUMQF866Q3tZJwaSA2kBjZbA2db2w62GOJSLF5EYQ5UcBkHWZwLJEZ4jGAYR1nakwdOKSIKWCNWhIiPT1aSqLyDMc3Z4h3Ktx3JxKUaSPDlUhUlQ2ogNZAaSA2sSgPhPJev/rx4rkuorVzo1VMtDVnmjkrrct63pR/nrGEe3Gne0XbgWJ5wL66TNQw+YtiunKVuuSzpttyheZ6pgdTATdSAOdtliZBZpujABMNAEwEkYdUiGuUciIh9dmSQigErlASPoy3KG5MOqnRKXWNQOi1f0OJoIcGX0VSfDacGUgOpgdQAGuic5x6bk9p10krtywUrF0yEeSFP4GWdrtJi+4I1zNHRTvNWVk47+mr45OG+gMDT5vAt24RzDyy2vatKA5QMJ72AL/cExKQ1zFW1mPypgdRAamB8DUwCIQ6qFIzEQBPfCUmDjpmveHm7RskgGOCYYt1SxiavD6ADJAPyAksAPEqSzzCaBhJ8GU312XBqIDWQGrjdGmBZ0es34zrPHboCtZVL35cLSz8AZDLcfA2caLujl2+Pm6b4hrl/d6d5cHC3dfg865bVy9QUfXjKL530LlPNKTs1kBpIDSxHA0JKAPRZCAQQYxYsACaiOfBCs8r7f/EWUEX18N3ijnjFHnRVdN8wyEWIYuo6ItOc6uNRGr4s51LOKjXBl1k1lXypgdRAaiA1cG0NrJvz3PqE+lYuQ75cmMtkuB0aqK+1+YYRWAgwx05JTx7sNcdrZA3DFamd9D4ojqDTSe/tuFfzLFMDqYFN1YCQEcElJ1ipaH7BFAMKRzd2AUxxGmOSW7MUYxaDbFRegBVQFurgRcZqAbyUykQmWAzhuBdShtVrIMGX1es8W0wNpAZSA7dKAwz+6+g8l4uwu7PV3NfLtO1YJEuHWXYs4gU8w83WwLRr3PcNc3dvu/ng8XpZw7AsCUsYAv27qx2dDuQkWvPwDKmB1EBqIDWwRhrgg5ShIoAi5RntscElmMPYs9vtWZQGitH/iDsgBcgF6MWqmLD2ka82zKaGqohN0xfT01iHBF/G0ny2mxpIDaQGbrgG1tV5Li+hvJBiHYD/lqvsWGRmvDf8uuXpzaaBsIbh/sHvCltWm/+iNfENw1m8UV/40cd00jvbdU2u1EBqIDWwOg0UiMQibQktdIRkYDL0A2sXABdLn7JAydAXxQAzgdqwBIm8YBkB8IAzp5QbtwkvoAvpklcqw+o1kODL6nWeLaYGUgOpgRurAV4+cUb7TH4y1mGHmFrRYeXC8qJD/GSoj1d1nHtTwZfda1jzXKNqfXnWLn2qZUWzBKxhwgHuvu6tu9oOeh2tYaKP6aR3lquaPKmB1EBqYPkasG2jy/KhDmEROGL4iCxWiEFi+A+wIqsVh19UILrlKDd+eL3PbGHtlbzI6sqKJuQ6Vx7H0ECCL2NoPdtMDaQGUgM3TAM4/uTl7rW25V2nsK3JCkuKsHLhi9DLN8fNt58eNrwwzxtuKtgwvz5i1jevhPWrp1tlrnCo+5/fhDWM7jWswNZhpyROKp30znVps1JqIDWQGli4BrbOAEkCMykDjyKzXjGwpRQKdPHVQgAwKje8RWli+JjSUN3ikhcBeMaCRToYmlPa8ZI8rlgDCb6sWOHZXGogNZAauCkaCOe5d3a3zMplnYCXPQEuWLiwBS/+Zj6TD4x12J3mplz7m34eTE1ns3sZ1sQmWMPQc5z0Ak6+ETgEqEg6nfQOX9OkpgZSA6mBRWugBlICPTE/MLJcwcplq6AqgDQBpGCUaTiLDlYsIWdafgSPWdKAsejnxi8AMO4rBse8/mGB2hnG0kCCL2NpPttNDaQGUgMbqAEGdHxdvJAFSSzZ2dsV0CGfF2MHrFwAXR7dY2hzK5dvffbmWlYu/XOST94Mt0QDNqldwLn2rWEeyzcMTnHXzRoGIIbAduosnUonvQu4+CkiNZAaSA1cpAGbU4SFCoiJmAWiYOVC0RmgS8kEcAJgEzUcTQFe6cAZEwIw01r4snwp/L+Y0It6lGVL1kCCL0tWcIpPDaQGUgM3QQO8KAK6vD48sRfH/jnhR2KsEFYuAEAAQp++WK6VCya+GW62BnDEvOgwzRqGvy2Ww41lmcXfLn/XEWLL6tZJr/6u7uyM9/cd/co4NZAaSA3cNA04wKKzwkxFiL8tLdLw45aXDphsYdnCidtBhWLy7aVFJ+2Ijcp5Tsv2xcAa+KpxTHVdhtvBIC7DOBpI8GUcvWerqYHUQGpg7TWAc1leDHkJu+jFkI8r1RC/kvMKK5eHsnI50yyFJU/f/OTNitpeSTPZyA3WwJA1DBNj7uNXAmIWZXUziwr5220/kFYVsM4JJ71h3cYyvno+X7FnMjWQGkgNpAauqIFwn1ugkQpkkSANCoAwPKO7HY9EbOmeVmGZhClfLGBsTkYxRRwIhuw4yOOEPI6hgQRfxtB6tpkaSA2kBtZYA/hI4Ut4/TX84u5qhC9j+8V81y/tW7l89vxtc7TCtUDXcdR7/bNfvQQsQB7euyMw4EygwIl07d/jVt+T1be4imtdW8Ow3AefK+yU9LY4sL4I9FyYRmb426U//J7KdxL9BPRMa5iFXYEUlBpIDdxSDeDfBXDElxH5w5ij7U6kMhYTGeINkOIwTJluRQ2PTX0BwhSwRVUMqCE2YxgrD0sZq5GHETSQ4MsISs8mUwOpgdTAummAL+3PXx+ZpctVX/ioiyXKskJr5aIdi2hrlVYuQ+d0G5Yd8YL94O5us7Oz1TzXltyc8+MHd8xCgvsk/P0M6ecm0Ma4xvVyn3ta6oNvGCbNgKDL3CnJpv38Yc0Yop8Ac+wilk56Z1RcsqUGUgOpgb4GCmByWmJmUmbtwjNZv1PmVvHNQ0lzqiskxVcWCXgp9UxsNQ3jie7LlVRZz+p4wrdWMP1+ZH5lGkjwZWWqzoZSA6mB1MB6aYDBmOUPtfPceXoYg/o8dS+qc87K5cVqrVym9W2JONO0JldC52WaF+mHB3fMwuVZD2TBLwnXhPLd+1sCBPzeWUnnVtzImNe4tobBHwu+jL7w5MB8Ll22BHAeNemyC1S7+l8xy5KwhCGYk9694qR3nk5kndRAaiA1cBs1oOdv+/QVkCK4RVogBmkBQIlyZRRsNyPFVq7nttmxtALgcD4qgsuYH5hqbbjT4MswlgYSfBlL89luaiA1kBoYSQOXOc+9ardYkrIoS4F1s3IZ0sUqlqMMtbtM2q5e8t9/Z98sn7777HDQqTLtY/Hy8dFhA1BzT5YxHzzet2uPhUxzvMwerlb2ulxjrND44XtlX9cIaxh0DwizMGuYBSBNYQ3z/NWxgUUARrksabX3bLaWGkgNbJ4GzHIF8KRgJvhs4ZHMvAr0xHEVoBalDUSJmHN1h7xtdQAXqyB+1Q2gBplWQBloe5GKhAyr10CCL6vXebaYGkgNpAZWrgEGZHYrWsaXc2S384Y5zwyLC76ex45Fn62JlcvQ6TD/uQmBpS04UAV4OZEvl4+fvZ3ZAgKrB5YjvRQI8N6jPVuihKybsiRp3a4xYHN1vJ8AAEAASURBVBDL7fjh/PbuAq1hbCq+oHt60EmvQLrrPh9uwt9bnkNqIDWQGuhrwOZPgYcodvAEeEQgjDGbbYtZuEAwOMbMFZUCbBEPfKccT/XbFsVAGwEzEnamXZSsjjE6OAN/hvE0kODLeLrPllMDqYHUwNI1AODC8pDZnefO16V5li1g5QLYAgjAhGNsXy5XOfNdWXocr9DR71X6dhFvvbToUBYVLC060Xk8ebA3M/BSy+e6c+0+FViG9QtLku483BYoc2TL2SjbtMC1XecQzm+fFee3WMNsazKOdcw81jDz/O3Oop/oZzrpnUVbyZMaSA3cRg3YEMlaIANSBJgUQMWHTh3bMRQesm754qMUhOIXRrHRAGAIik4LgGN1VHO7WMDQXIbxNJDgy3i6z5ZTA6mB1MBSNMAL77zOc+ft0KmWKeOfYhZnvVi5sGSFmGUsn7042qhddNZlScpVrhWgCzvU7N/ZObe0iLJFhFiSBKh2X45Y2bUHQI0lKTfdQe8i9DePjFjuA/iC89ur+obhb5a/3WWH6Cf3WjrpXba2U35qIDWwMRqQZYotMTJkxWxU2q4bnBJYiiZ2tkTJIBYsWsRmgIsvPfK1SiKJbkvBxYc09yAjotoxoF2xONo2MrF6DST4snqdZ4upgdRAamDhGmAoXYTz3Hk7dnR84kuJpwjghTxeugCHeCn/VNtEb2JYlqXAMnSBZdF9LQeKXYsAupYd0E8sSaL9R7KGOTtwQHBTQJjjDdtSG0AQS5h5rGFOVoG+lJsunfQu+68v5acGUgObpAEHXoSNGEoiUEWdL3iLnUa3mxFQCqVAMkqbtQxAi7hLXYqpuyULF/cZA9BCoKZLtqVITszjSBpI8GUkxWezqYHUQGpgERpYtPPc6/RpyIIitize3fXdcTbNymWaPnZ3trXs6GRa8ah0rgO7EgF6sPSjv2vRqjoHCMMOSbFLEv3Z1ZKkF1qSBA0Qbh0DQOEmh7AymcUa5o6WWB2NBDRFP8NJL8sP+bvKkBpIDaQGbo8GNN4EflIAEsNSRPMxUmCLABYDUzQ2BYgCoOLmL2jKgRXk2LCqpUskWIGk/+YPxkgcFIqtjKXzsHoNJPiyep1ni6mB1EBq4FoaYEBelvPceTt2JL8hvOwReHlliQuOQeMFHEuXDMvVAKBLLC2yJUDateh4TTzH0p/vapekTViSxH28iUvL+nfXLNYwLDsa23dROuntX7nMpwZSA7dFA8AhW4zTACsCWXwWJaIhL+RFpwwgxdg0PhEXOpYs7DaJHAskYFa5+ZEhX7JsOx1Oeo03D6NoIMGXUdSejaYGUgOpgatrYFXOc6/es8a2JmZZ0V35FLkjK5eXcvJ7U6xc+voAaFqnMMbSonnP/9ySpHtakiR1rtsuSWt2iedVd1svrEz61jBM2g+P1meP8NpJ74F2PwNMTGuY9jJmIjWQGrhpGtD4ZzsVAbwIJMHCBbDFjVkCaHHrF06dMdTAFuICrPg3FoNjinZAW1QombA4kOMioQHYZBhPAwm+jKf7bDk1kBpIDVyqAcbIVTvPvbRTFQNzhId6gd7XF3Re7Nj1ZlP8elSnceXk2EtTYmkRuwvh5HispUVXVlypEBZRLD/C8fIj3UO8ZK/DkqSxr+28Op2l3pA1zDvaLYn7CXB3bCuY+hywluNnFl0CdvcE7K77TlR1/zOdGkgNpAYu0wDAC1CJBU34LA9uIoJbwpw2Z1o/hDGLgy0AMrI01uRrwt+LpNiSJPF5PQdYBNGYfElhryPjYfvpDONpIMGX8XSfLacGUgOpgaka4Ev1C72YriuQEb5csHLBZ8OL4+PmvnYwWtf+TlX0nAXbI81dePl8wE5RsgpA158819KiDTfTML9FTyeXJJmV1xvtkiRgadVhrGu76vPkGXMiUOPZq6OGv+dH9+42b9ianueO9L4uH0dZlvSZnAk3zVGDNcz+nnZLkxPpDKmB1EBq4CZowGCSsFIBYbHlQawWosSBF87TLGIMPgGAAbJReZi/GKto5jCGkmIJg7gC1LSjqdVBYoYxNJCj1xhazzZTA6mB1MCABtbJee5A98wkFksLLBV4IaqtLQAFsIK5DYGdcPgav8pwbmmRvYyusgfLb+vckiRZZAAAYB0DULDKsGm7Hc2tG93G+Nt9qvuJn4Ew0jtfVV9r6eAr/dZJF2ENA+CLg17+LnJZ0txXPyumBlIDY2uggCaGpZiNikEqhqmcMqlSuYEwTDk0IBp76bMBLO3Eq5SVOkzIzIpGQAtLmYLN6qwLsj627kdqP8GXkRSfzaYGUgOpATTAGLhuznP7V6azctm2LYT5Cs1SlzpwHjd5uUZ9rqRXca4APOgei6JNXFrU19ms+f6SJM7/8YM7WpLkOyflvHFWTV7OZ99GK4XWvmEeyirm3Yd7thsSwPDrw/XZoQrw97nuB35mDSNA+J7ukwypgdRAamCTNHDKEqCzsvjIABbAFsNcDGiRi1z9E/wCCIN1zDbwCwyK7X8pM9AFmEZzMwSw1ZHmEPF4d78wVlMHGDKMpYEcqcbSfLabGkgN3GoNALjwQsML5ToGxvFpVi5D/S3TgaGiG0mLnZ2WcXL10iJehm/C0qJ59eTWYG8N7LovMOCDx3ebQ+kEi4xlLUnCkuLkdLWWNvPq57r1+DsH7OoHfMNgCcNSHwcA5fz24O5aW8MACqeT3v6VzHxqIDWwzhpw57eAJgoCV1gRZBYvJV9/5jrbUk5Lkgx0YelzmLN4bTtuybOLsJwCwGDxgmwJRTZWMMi9IJycnMh/37bVu4Ati66hgQRfrqG8rJoaSA2kBq6iAd5x1tp5rk4GXyL4FGEL2ufyBTFk5TJ0zm7Weju+pgy8qw6p5Mq0WFrEh7CXAuXcz8WVxdzICvWSpLvy+fGoLEl6JWsMAKpFX5NFy1vXi8LE/LJwoTWMloRdNpm/TP4iy2NZUjrpXaRWU1ZqIDWwLA3w/MSyhVADL4AohqIYeFJsVcRsy5PEjhNeKrj1ogAWspLULjWiRDQc7RqP0sYRMsj2wmfPXjR/5N/+j5v/9E/8seZf+D2/o1ea2UVpIMGXRWky5aQGUgOpgSkawIklFi7r6owWSwscWPLyP+/yFl5WbWyfooObRF7kizkviSyrwbpgXt3fJN1edi6AMFi98NvX7jf37+407Naz6CVJi7zGl53TmOX8zc56rn1rGO7Zh0/W0xpmwkmvnmv4qUonvWPeadl2aiA1MKQB24OIh7Aexjq2B0sDvJS5FXkc5wLQWJnxAreoYnmQ2y5Gslr03Yx8uZIBLrYUCV5qRkMI6MJ/8J/9D81f+em/KcvSI7XZttAxZGphGkjwZWGqTEGpgdRAaqDTwNo7z1VXeXl9cE9WLlpmgUXOJ8/fnvPl0p3R5Sm+styWIJVdK+zxMqiXVyyNbvvSonkV6Uv3ZCKtG48lSV94cmC79WA1dJ0lSde9tvOezxj1hpYczdKP2hoGx7dP5BsGx7yHb4tvmFmErIgHx8H80knvihSezaQGUgMza+AMZyzgJwXvcDsVABazVzE5DrqIQeYtsBnW0kIp0FuiWbu0i4uYlAlI2WL3pJbFa5vg6vAf/jv/RvPv/vE/2vwrf+w/qqiZXIYGEnxZhlZTZmogNXArNcDgZs5ztRNH3yHtuiiEl/67Al1aKxctLVqURc7Rsb7hyJKDL+Q3OVznqxB6Z1kXH5ZeabnMZ5++ucmqWsm5TSxJkn6XvSRpJSe1gkZYWnhaOxSYo03+1rE64oclDNtAP9SW1b5T0vFabYM+4aQ3rWHmuNpZJTWQGli0Bs40ZzJkxCxSBJvwYaeALCwtMvwEkmj4bJEXXfnp0oNbBZYFS1EICxmWHUVwQEdzMpGgIuNMRFvSFEwlfv/ddyxFexmWq4EEX5ar35SeGkgN3BINsB2uO6hcvxNmMN3Xi9bDe3c0Xm9pycbxta1chs7y6PjEtmBO8GVSOywtYicWnIECys3qR2dSynJz15lw7WjZ2joEW5Kkv8NX+mHVhUXGI93z/G3yu4ol9el1UYl1UMgMfThZ4HmGNczzbd8G+snD/dYahmfOOoWwhvnsxVHzQFZT3CcZUgOpgdTAqjWwJWQES5VTA0XUuvAVG6sYlPXfPvaAuZDWobN98bxZuaicuR0yqG+gi/JWl+FZPzewMSHOt+oTzfZaDST40qoiE6mB1EBqYHYNMBbikJblRQf62ovVx7qFsHJhSQY7xAAOXWc5xiznd0cv4kfr9Z41S7evzDPLVtOxtAiLgBd6+V/nXYuWuXvTlZW7gArtkqTiU4clSdz7z/Q3e5lV2ixOaBfQxdFF8Le6DKB0yBrm82tqDcNFODk5M0sd7o2HWoa5t7vT4AcrQ2ogNZAaWLYGAjDB2qUDSdQqU0pQlPgyUqaYsMFnwVEWY7FiLGVU4KIEy6iu4TFFVmnCwZkiIqPVayDBl9XrPFtMDaQGNlgDtqyo5zx3T1YlvGiz08bYgXG6b+XyLS1tWcZLVv9cj/QSk6Ep293eMZ3n0qJx7wjue0BSfoBgOOflqyJWGlhjDFnDMHm95mqccU96xtYB3Jb9N7sJ1jDx7DYnvbKEYXttlgemk94Zb6RkSw2kBubXgBARw0YkAevNsG1B4BZoiRW6dYwBK2WaZWVCVkrWxzIDarS/kcmE24PxiGZjG4BMFGQ8igYSfBlF7dloaiA1sEkawLrlrXYsYocVJuj9wBf1e/vjmq2PYeXS1wO64YWlkZ5uchjCmHiRfSgLI5a7YFnx6YvrOS++yfob69wCCIglSQ8O7k5dkjQEyozV72W1y3I4nm2rCH1rGLYLxzcM/qZw9n089Ee1io6pDcBznu11iGVJ6aS31kqmUwOpgcVrQFCIppWnmjoBqDDDNHAEGmkDWAooo4HJrFlEtzK2o1YNSsOc5VQysMz1JUcO2ojJ2qAuKI3xG7E7HGvZeDhgPzpmd85jfVRMmKDT0OJSqdXF6TIlpQZSAzdMA+E897KlOpitj+H3gnGUFwf8FfCyyJbW3/j49WhXgRcsnHjepgDohS8Xfuu+tOg2XZeLzrVekoTzY5YkHWriyYs2wNltWXY0lnPsAMG2i2+Yd+UbhmcHVmL461l14NnNM3wopJPeIa0kLTWQGliUBmSnIlGazAlNcTsWASbKOpgCWELGy7BZiZynVKOUN1vbKpMQTQwBZpBpvLbTkT/fbAlSkWAs1eGP/Xv/ZfO3vv73jPLv/yd/0uKf/sv/XfPu44cVVyYXoYEEXxahxZSRGkgN3BgNhJXLcy0tmjX4dwQfEmetcx2+1spFL45Y5KyLA9fh15frnOn61t3VfsQfPOalsbHlZt/MXYvW92JN6Rkv/Pj54Ic1DEuS+PKHRQjA5k0PnKdUMFoYtIZ5Mo41jL/0XKyK2hqGZzCWbjwHMqQGUgOpgbk14NsbGf7CVkc2nxSg4tYp/oA2ixVAE6xWHJlxcEb8W1ugNnoOqYydjvh4gNULQxhWMJXti3Ac0ak/ML597b/PLabnvoZXrJjgyxUVluypgdTAzdRAOM+9zMplrLMPKxd2LOJDiVm5fDKelcuQHjTe3+iX1m5pkb9wffL87ajLJYauQdLm04BZwzw9MRBm/+FO8/6j/alLkuZrYf1qrRPAFNYwO7KGwd8K1jD0DxB82dYw5fvwzBcIa5gAYgCwcNJ7bz+n0zMrMBlTA6mBVgNh+QJIgrVL2UXaARKRDEZhcqVAGnBGj50CwgDGMB/xcuMpSYdfyOgJp/q2pTU7KwG8FHnwZ1i9BnK0WL3Os8XUQGpgTTQw5Dx3nq7ZODbwJWEeWf06fSuXZyvYsajfh1nz/rVlSYqYtRNL4KuXFvEy+PLN2+Y9vZyP6adiCaeZIqUBnglYv3zn6WEztCTppinJ/AKs0UkBbLzQ3xg/lvLxt/fhewdmXQZAvpS/OXuRmU8J9Jftqvm5k17f4nw+aVkrNZAauG0akIcWA0MMMylWKURneraY3QpTKgAWs1pRGssWSDqYlQskQBmIsLHmSOiM5UUArFGxKhijDgQIGcbSQIIvY2k+200NpAZG0cDxyal9tbTlRfLvsKiwyKFsE6xcpultnb6mT+vjrHRe/viqPbS0iC/eNyVojnftsAgZ1+7EggTYchyd0NCSpMO3p1N3SVpQ8ysTY04ZV9ba1Rti9zh+ADGAMMuyhmH50yJCWMM8f7UlSxj5gdIvlyUtQrMpIzVwczXA08cwFzNJ0bxCqInNTOXDBeAEPy0GvACw8E95fsxAjI/yUsaSIixpqGM8XhmKaAbDFOvkmzN/4ew3LST4smlXLPubGkgNzKUBs3KRQ81lLSti4n1HLwhH19g9hJ2CDmS+zks/vlzW2cpl6CL4NolDJZtDq5cWHR2fNdOWFi3qhW0dNLMI64dFyFgHXdCH/rWtlySxS88Hj6fvkrQu5zBLP8I3wCy8Y/LUy3xwMA6osShrGJ7Z05ztznvO9BcLOX5uDbOdy5LmVWbWSw3cdA1U4IkjLTphfLkAlmAUU4AVJRw4EcDiYA0IC8oRkGJWMYAzJe8JA2AKk+oAwChnZYXB+POwag0k+LJqjWd7qYHUwMo0MI/z3Hk7dyLziH05X7wq+IKlCIALX0oZOd2Xy9t5uzFqPRvUN9T0hS/r9+XAeF8vd7G06KIlDgv6WD7q9crGhzUw7doaCCNQlPvjNixJGtbOuFTAc36LsobhmY11zbJCZw3j1jvppHdZmk65qYHN1ABOcHGiK08uWjIEKCKQRDS5Z9GckAVFBTTh9OBz5EUWLuxuxLSR+kJpmEB6JQNtyBpaQ0xQHElb6uTUPI6ggQRfRlB6NpkaSA0sVwNjOM99KysJvnI2b2Y7t023cpl2lpu0Ggec6K52uamXFn0qJ7qzhl1tUXsRQDOrnORbHw1wTS8LWMb0lyRR65Ws314dHpcvi5dJGb/cnTaO3495elBbw7BM7IF2HprHGgbLFwCSZYd+f9NJ77I1nvJTA5uhAQdOgFwEjWggMTBFXbeRSCRfghTjEvAJRLiDX7yQqasfYI353yMjetBIw+gWMGQyjKWBBF/G0ny2mxpIDSxUA7asSF+k315j2c91OsTX2MfaqvaiwPDJbkVYWTAQbrKVy7TzZKkOS3f6Szem8Y9Bx9cFLz8AYEcn05cWXdS3dT6/i/qdZYvVwLQlSa/euOPexba2OGn8jfK3ehMCwMZTOSLnBwB+Fd8wWLpRb5WB/qaT3lVqPNtKDayvBjB2YW7oy0BJGEZiIAlWMXh+gYhlsW85zblQyWl8RILDKhpPSSsCuMEPDOW0YUCPBJ1SKcNoGkjwZTTVZ8OpgdTAdTWwLOe5c/UrRreByrzkPzy4Yz5hNtGXy8ApTSWx/Coclk5lGqngqkuLLuom/m0y3EwN8Fy5augvSfr8k7u2cxJLlI4W6Nj7qv2axs/fKH+rNy3EMp+ZrWHsjWQ8LUR/3Umv/H3tb6eT3vEuR7acGhhFA2akYlMKs1spoAldwfluWVJUemYcem5h7eL1SqZFbcQokgEvgDZAL8rHciVDYqiYYTQNJPgymuqz4dRAamBeDZiVyxKd587TLwY4BsUIpMLKBRPQl1qO8PrZ8s3bm7NPm+2Tn7ThOvoSMMH29j0jHZ++0kD8cXN2/JcsT/n5n38tCToDOV9oiKFtbX3Q7O3+Yf8aU9U/fL7TPNn/43rhFHENAlYuBn5VuxZdZWnRRafATibHJyu4phd1IssWqgHul+uEiSVJcpz9jqzhkIhfkZdv1mdJkrCXtbZOu841oO5F1jCHuhaUE/xVx9NGGOlAf56/PtIPH2A7emblltUjXYpsNjWwcg347NGfQ2eOmhTwJPy60CU9tMXiuxn5/IwJmM094xEWoIry+I3xQL2StqjKF46MVquBBF9Wq+9sLTWQGphTA7E1NP5c1jHE2FZbueD/YRE7Fh0ff83AFF6YDt/+KTn2vdvgmsJ+UgYx30YUYYlqGR9qY4Au4IqI0O+Ix76Y7L1vecZ6AmWnGvmPTw8tzSHAFve4f9IcqcxAmLPvNK+P/pSN6adqGRr1n709a7794n9sgZqo/2Tvj7t88dzZ+mLzZO/3K7W8EEuL7rJzlCwPpu1atLwe3AzJWBAAIhK4n8da1rcqbS5yyRwv+fzuaGkLDrXZJQlLB/Q4tq8g+sSSu9sQwrrErGEEwj6+310He59ZMzVEf7GGceD4jlkT3oZrleeYGrhtGmBuxUSLpUBM3xptMQ1wEnNK5lDQDSiGKD4rc2Zq+HwNHuqJk3Jgm6jrM0QRcczrwqxeHsbRQIIv4+g9W00NpAZm1ABm+1i6rPtL3yO9oAJ84PhxXiuXU0AWyQBIOT35WguuHIgmV74OwOzddaCFAbSEeHewQTyIdVx4ieDtfj5Qm/lqoW9p4N/eOeh4GK/bOlvNnZ0Hbf5EQE0Lxojn7Qnehh3wQRfIpU0mAJ8e/ekC1OirtOi/+uY/Vyx52x82T+78fivb2/lS87m9f0nc84cAv3Ccyr3z8bPDpbzo3vQXV5ZosaMPL+kBeLJ0rjlo7Av9uv89zn8H+f15nfr9uiw7eqpf7JL0/qN9AwTHXJIEyLToLZb7571uebOGeSHfMPphXfLO/T17Pt3TbnOHx7KGWTMwiv66E+cTLUUSCKq/P3Pqvm6Kzf6kBlIDc2ug4CmaaDFpUhQTLns6iQRNaSyoCcyrrEj8+IRhQmY85CkoEy8+iiHMHOzCZPU6UMeE5WEUDST4Moras9HUQGrgIg1g5YIJ9rq/4MWLPi+q7H7CZBlHisQXBgErYanSnApkEXNYr0Anv7VzZjQNnzawKrJgkhmkFaa1YmMsDIzD8PUYjVbqA78wOMMCn8VtmfJi7srgJu/8ADU7AmoAVzjlPaUJyDuSP4mjE1nJUKbfoYAZ2wVRadrnPPmdnP16863DP21ADGub//7L/0L82wbKfCAg5lQdOBAo88X9HxH3cMDKhWvwqCwtYnnHMrePHe7FzaBiocFLHvfwC+nxTbX7Ey+C6DlAGPT8RpYdNylcd9nRRbroL0nCQTeT5pdYw0iX/b/Ti2RdtwwrkDcr2OXnuv1cVn2sSxhfnjzYky+urebxg84ahvFn3QKWUp++eKtfY1ZUBwKMGH8ypAZSA5utAQNMmFhpZsV8h9mVz7NEMnCFGRNBsf7bPE0MTuXo9YjNdqbMD6lhFPH6nM02s1aauhwzjKWBBF/G0ny2mxpIDUxoIL7ybYKVC8sw2CWDIfIZINEzn6xjtbInev/Ff0tgy1bzqtk5/UsOOmhADfBhWwlLq27EPqh26vFhsgAekMXgA6jS9RjKQE1hCVHECx5UywdR+aBxHjY4i0DxhSCMlRf+IhM5nDtaMPEQ1OjOroAZEaDttyCNtmcWZ1jMAMr4eZ8JgBHsonp8gD4++zVZx/wZA2VOxPH1F/9Vs7/95eaLez+i2lvNb7z/bxovuxaxtAjrglUvLZplW2Kd+kYEdlr4vJbFHEqP35W10DQAkRfWj48ODYTBMuaxXl4JvlODXf2NON9pneTvcRWB5UjfGViSxLNjFQ56AV82/2pd70rxrOY+xxJmwhpGz6/YNnzdrGE449oaBhAGwJTrmSE1kBrYRA0UuIWJmoATfy7z96x5luUdkLEzs8JSBsEma8qrLlRmdVjD4DcGcdD46GVTQ82j+ABgOyZRmGE0DST4Mprqs+HUQGoADWyilQvLMLB0wZdIHdgkJcAXB1xeC3D5iwZM7GggZX4cAEvEDIHQifmdfyGKQbVrCR54CXzkiHShKDpPocyoUVQ1BAk4BVINwgCceJn3y8u9TeMXobWaKfLhKXMInStbGmIVs2XnjbZONQvYUf6OwBhsJu4WgOZYs4XDk7cFeDlTWhZEqsvZm64UH539avNLb35UwMx28wuv/rzFv/O9f0u+Z86a/ebD5qt3f0gSVxNOdLFZurHJgRe2+wJQDgReES4CXfrnCQjzydFbe+n7nECbDx7vy3rjxKxlwjy6X2dT8lzbVYWJJUlasvjeoz2zyFj2kiT7G+WP9RaHeFaHCsLXCn8XgLqAkQAd3Ov46Vm3gDUMYxE/ABic9OaypHW7Stmf1MDFGrCZl57FbAnNhMvmUIAqBpD4Q9osWCTGcipr4RimIPYw93kZYAxyCskreCUDZSgwqCfMkC/uWpYuSQMJvixJsSk2NZAamK6BdXeeGz3f0Vog/AEMWbkETx0fHf6ZZnv3bbN39GMCVIp1iwZHHJ/xnk6MQ7QaeGHsjODDbOTqEqdBgSdiqENp/47CINvxwxt1SVshcdWo8zMVKF9fRLDiwhPyyNrPyjv+oHOuzCMCvAkncHx94dztS4wkbCtvznrFu60lTLtbd816BsuXe3fuGRDz+liAjPpzLNrhybHpkCVax5pkbOv3tz/5s0rvGBDzNz77b5r7O19uPhII82j3S833HvxuzjBDTwPxcsnL2gv5xQF0ef+d/anWLr3qE1ksBwBbvvPZYXNf4AEgDNYbrwXEHK0QxJjo1AZmbEnSS4G6+mHJxZIkrhMgDC/+UvESwlKELqGfyxHJErpXulf7gXua5aP8ADNsKd49B2K4FutsDfP8tZZgyqIH60zunwypgdTAumtAf6f67/MlnslylOskPfdJOKBiIA1zMwNlyjkVwMZnZF4pnuqMy/CKavMs5l/uI6YIX3e13OD+Jfhygy9unlpqYN00wJdFnNHyJXGdQ+3LZZqVS/R/25YUvZGFy0+YjxbMNfYZLDW+hcUGUAbzYGLo+m8hYjIxYJ4vcUr/SN2oM5QOWsTUH0rTH+TYwFx4QjJgEWWM7xZHg6IRrF5JAdj0g52rmLyEc/cUoAsBuUixLzVKhW5cb+7zZufOnk0g8ANzrArHmpUYIKO0DF6aNwAymmRsyxrmRCDM69N/1Hz95Y8pvd3875/+t0b7wYf/miYf280/9eiP0ODCAltNb1LgZTO+kHNf83K5qHCqa4DMlwILeGF9/OCOTSY3wXdTrQOu6dvT8y/kNc+y0/jR4XdHKOOBLJNil6RFLklieR+T/dscANcvA1L61jDvPXRnyetsDXN8wo5a6aT3Nt/bee6bowEew8y/CGfsRmQzK8vpIPBEc52wMIaPaZNc6tl8iXnXFg9y++JFnTpIFgAMJCoxwTJZpbGaNdMr1UCCLytVdzaWGrh9GtiUZUVh5cLL6bG+2Ne+XPpXLQCXXQEujHkGFihmbGMbZ75aQCPP0htFlq7lQLtq6A+ZyAja+bQNy1Z+vsxbDnrEUEOec3RH6FF2Po2ELgRfUEJ+xEEn7tMsr4PpVOX44DjRBELbP9lyJQCcnd1dWcMAtmw393fvWhpABguYQ01K3ujlA8uYsI75mRc/aWX/z7P/SfF2808/+le1w9KHzW+897vqrlwpvUkvroAh+GdBjXy5vyro8qsvnptuvvzg4aU6AoTBES+/2jnvJoEw63Jt2VHrSJYwWCfxXMI5LM+mRSxJsr8zbohbHmbVQFjDNM3mWMOkk95bfnPn6W+GBpje8CBiwsh/pcus0frPp8otPavNhgVeZmLi5fFNFSah9iiPvMrr2Z/IEsjR6QAwAfZQlGH1GkjwZfU6zxZTAzdeA0xU+fK2Cc5z+1Yun2p3l74vFy6YAy5vm93TH9dY50OjAS8+XrZgAQ/VFnyhIoNjL/RJNji2PP1SL5jkaZknwAtqBp+n6yG4K4vaPhx7pTZdZFAzaCbTDudlhKyhuFSxorpvECbyJUNEwY5mFCzDYPmR+w+xaYfp3TpljPTQHfRi+bKzqx16RLkncOX4bF9Ofbebl0fHBra8NUBGlFM5ptS1+3+f/yUDY/6X7243T7Q86R8XCPO+wJjffP+fpAczBZvLzMQ5HhOgyyPtXMT9/FRWKVexOPu5j7/V/KPnz5r/65u/3rxz976dxA9+8IXmn/nCh3J8DDR2eaC9cM5LP3bub5lPmOUto7m8T7NwrNu15W8BAIbfwpYk2ax9Fm3cXB5/qtRPqdnOtbaGARRbd2sYziqd9M52bZMrNbBqDdgOR/Y81pxGc5VTpX1KBFiC/fGpwBlR7D8lgC1asC0+ZkGG3ECGLl6PjQDReMgB2jgVX3yzjeEmIA8L10CCLwtXaQpMDdxeDWyKlQtf5PF38VA+KgCILrNy2dF20G7hEsuH7GODAS4MZmaloQRp/JG0XxUg9EKfNMvUfxaeaAb5we9pcg6kwBNlxPGSaWkKFTzd8Tv18mMtI+S0jV1SnX6iX0xrsZwAvNP/iQAPPw6uXyYSULgmHnsxkxKc+p41u7rGgDBYuxydyUJG8QsBMsQAMq+PT5qnx7/a/I2n31CbW81fFP29O19qftP9H2w+2Puw+YEHvwORUwN9XreAnwdAl/vyVQTochUnupzLj//8zzS/9vJF80x6eufuPfvFOf6tb3+z4TcPCPNd7ZBE3x6YX5i7rXVM3IPRxtjxuq8kW9SSJPt76/2Nja37lbevv9/r3H88p7BC4sffnI0pa+4bJp30rvwuywZTAxdrwJ5DPIxj3iXQBbClzG8AYJjn2LMKshLm98UAGX+Ie23KEKZYVeCH3fj1wD/jq6ARRGsnqTBkWLUGEnxZtcazvdTADdPApjjPRe19K5fvPj0ctHKBl92KDHRRmhcVlg8xBDJ2kbeYNLQqr+yFwYfKC1mscBF8yACiCFl1zMBc52mUfJ/faIXXy4NvMqY+AZ5WcElGPYrQm/GQLnpjvoBvVr7w892GEHzEli4EP5sCu2gCYeuhTSIMzmt1AGCMjktfv34nOPXdA4jZUXtySlnAGQCZI+VZsvTJ8a81P/2ZgzGANJ/b+1LzWx789uYLAmN+28PfZm1wwCLHMJ+WMm4CYIMdWngB5Mv8x3Kie9xHsKZ08cf/7s80v/T84+ZbLw6brzx+v9na2Wve0W9aAID5tefPm9/y/gfN9z96p/n8NMYenZfVp1pG8/zVcXHOe9ec8+InhrIMs2ugvyQJB70BBly2VTW7dB3hwfqWB543iwqT1jDatWrNfcNw3mENk056F3UXpJzUwBwasMdQN0/zCRJzHNmqMMnQBIlSs3Rh4qYcFjLMmxrNUXRosRQrVR0HXuTTSqVYalvenO1RJmsak6PCDKNoIMGXUdSejaYGNl8DTDY3wXnuVaxcuCqALiwxMsBFg1sfdGkBGHj56WCx0gx8845pNv6qvktB4vnQ8Zwvg1KXW19syHbeKDO6DnU+6moI93PwKu35BG8h96LhvobMHrNlTWc6YOXC+w+xf+lxXVp7iK0aDh0b2UCX0LsDMTY5oYrkqtiuiaQqZqvq+FJEgYMxJzunso7htyMLGQEy4jo+3W2ODJyRZYwcJ7+RZcyL0+80P/XJ/6oy9zEDCPNbH/4TzUf3P2x+772LLWOGzn3RtHmd6P5/n3y7+Tvf+Ubz43/3Z5uvvPN+85FAl688vtynS/T/269fNt/+h7/U/Ny9+83vOvyw+eL+fYFZs00puN61c152Woov8kNL/qLNVcWLfClfdp+HliQBrrBEadryrtwFR7659Dd/mbPdea6dA2ACGF+7b5hNsYZJJ73zXO2skxq4vgbYDIBFQVsAKUxeQFX03+ZjBXgBMGE6ZB+bAkSBg7kTvPABspgsOKGJX/Mhy+ng7ZDjx0wqw1ga0HXj8mRIDaQGUgOXa4CJ5acv5BNlzXcr4kzCyoUXkddyMspXvou/ruv1++0fFOjCy7pbtLS+Xcj7eGhDFsOWgTBl/KqHMfjsoVqNb3W5qno5iQuCP5j7Nc9XaB/gJcFATAggxdNGssEYtqhzPl0GanhUeL68o5kMHYAyjK9tV5WVdlClxy/dglbxwmj+XMSKpQv1WdNsceSNFvX5BqS0tedtwk/bbawr0qbbMtHg0Q8rFi8HRIHWi1XOEiUsYrCM8R95LV2SuS71D9Xp17r35fpX4IzSAme+dPfD5rc//IHmywdfbH7w0W9WL1cTYmkRrfGSzf09Lfz8p99pflZAC+HnP/5287PfVVq6BHThR+DSTJ8NlItrnNWBC6ZA3c8d3G/++e/53uaRAJhZQRiv7Uf7e9X2uPQBYGYsEAYg6Kl2gdrkbbJ55rG860BbVptFhnZOqq1h0DVln8kK6bYGc0Ctk8cx9LIDYNc9LQPkb5Znn1ucLL/d654X/mxyy+rrajHrpwYu1sAP/5U/4ZgLbBpMHVApAzKDK4O15izMq3yQ5pOSkxS1weqppB3LK36vgAgHa6j0U//if93WzcRqNTDbZ6rV9ilbSw2kBtZIAwAWTBbxjfL+I22zucbAy6SVi3Ysmukl7ljWLj8qa5cfM+CF8QrQJQAYz/u4R9ryxCRKKO+gVgboYNu4GpQQHJfHIWOSM6hVY2IIaiQib7EGaYtVZZLueWgT9JIPsMbKdOjz1fnoo/FWGeOpumrlyqNLFMZKB14+pr/khzCPEeVtcFSuJdBbn4BwHdzSBZqzeInSKohtrMP6hQkKX4M8pi556rmfGLPnVd58xgDIyFLmaEsAjPi2tWxpb1s7LUHX7x2BMK9PXjT/2yd/zWlCiD7Y/VzzO975zc1HB19oftfj3+QnssAjL3AP5byWl2nzVdT7e/yxv/czpbWt5sd/4WctjV7ioj/aO2h+6wdfaR7Ln0vQSoUpkdWeUtaRv/3qZfMTf/frzW9574PmB7QcaV/OUwBi9mZ0zsvyxUMtAwQYeKQlNPwN8WI8zXqja3mxKc7WdpNYrNiVSuNv7Fm1S1IsSUKf6BkwgGVLtzlg+QIwtYowzRomfKQtwwJnEefFuA/48vGzt7ZzGWBMWk0tQrMpIzVQaYB5EZMQxcxlLK1i+wxY9pQ27KU8skkTfB7l8xnSZvUrIXxsMpCF2MVWY71KamEuKo8r1kCCLytWeDaXGtgUDTAxfCHTaeIIPPvtYV4GgaCPHYeVC/0AJPrWp28usXKBU18ebYnRX7AXPc7LABde2FVqli3EypCPXzH+bN9boUdo1SKiDYwiUB6DZfBdNcaY1EIlKNrqYu9J5Nsqqhg04jqNTKc5YGPpwlDzOQ/cwe8JNFWXWbkITCC4UXjvxrgSQIof5LYDpKtgeqry05LwuU5DIHk/d64h8h10IemTEI6UBdDC7kj0xehKsZ8AFI52H1Cuk9B3aphMHsuTdgTEHG/jL0Zl+vGXsaWlS9v7d2QdI7quz6uzF81PP/2bzV/55LT5k7/yl3X++wIQOP8t7ZT1wCY+//r3/KBaoq/eb7tXyKqx3/nel5u/+d1fRbLxmC6V25Un5/3dHekUSy5tpY2THBPSNL/w2Xebv/2dXxdXCYVuJ6M02Xf2D8zK5TE7F7XlKojGo+4145+TZQ2/H/7K9zWHB/fmBmE43/vaHvuDx6t3zrtglVxTo/NXB4Spd0l6pBdp7p+wvphf8ubX3N/dNv9Dqz4Ts0TS329Yw+AbJq4HQOO6BfrJmMoPizQAGJZSAQJnSA2kBq6vAfvUxwRJkw/mIYw/jPvMQZxGXmUqcB8wdZuihyNdypm5Gh+x/UeQC1Q1kTx00/qgZLxCDST4skJlZ1OpgXXXAFYtmPszyWof0nWnB4k1w+rS81m50L+T5swsXQS6KIcVBLGDLLz+TgdeKIPDXpmLLiwyggpLqNVk6ZogHmPv1aHqEG8RaVGIOR9PCjtf3g2658v8JZ8Bvy7rp+s8jJGP/pHnZyCHTSIEOGhCEXT4hupAHwqckckrcZ+H8vgxSbHJitH8fKwfZbIC6EJwkIV64ue6V+VmDQOPWH2u4lfaeFUDayh2wtk604uT0if6uYXEtsmBhtNeHOGxiyOWG3fktFZ/Ts1dvawAvrw9eam/r+Pmf/72/+3LWk61zEYTp1NZ0XCyfJH6iV/5WxZbh5WPf+4XR1ROxeglDSM0bmIrUxzKU/KRQJePHr0vSxffLlqkiXK7YNSz0CaCMHf8U//wHzSfv/eg+ee+56vNd07eXhmEwQfMGM55uQ9uYohdkgBfnjzYs2VJAFxYN9RLkm7iuQ+eU/U3Mli+ZOKkNQyOsrebxw8O7HrgL2YdrGH4UyiPzlYbvmRKQMzrrWZPAFYuS2pVk4nUwFwaMO8f+ltjnqKhXUGzDostqYmUDfk2F6gb8OGeuUw1bitpf7c2GXBZPjmiAfvvf9MhvxaY6ZVpIMGXlak6G0oNrK8G+Bo3i/NcXqV5GfRX6nHOB9DlkZZdELDK+fWPX8/YEQddmpO/IIsGBigHUXhnZbDyl2wfnBiXnNblaYQhjrJqqINshHYsK4k+T1vu7ANCTNK5g8uhdx76cVC5MhH6PEN5aNSJybXnQ1oXn6OL0NY1GTqoaXv3l9IACXixQIFRN2IIkSa+SuDshur4dfNrCY/niYMWdy31XUtc27B+seVIbT2/v5Hh56OYPmtywwSplan8tgqsrsAYZAG+GAAjOs55sYRhTkQdZLBMaU81drf3JfCkuSPa6Zl8bmiW9Ua7Le2o9FT1DIwRIGOQoPGgTzTl52NnYP2BJJp4JkJR1Ef4c3no/lza8poXPgK0SLeJYGwLjPXcobR1jl4I39KW1X/tH/2y7Yr0vqxgAGEIV/ELUzvnvS8/Jst2zsu9cZMDgCjnCLAF+NJfknSTz70+N7914z6vS1afxifZa1nHPX8l3zCy9mJ5L+GZdgWjbKzAE2faWA84mk56x7oy2e5N0oBZs3BCPJg1lwB4af/2+JijIp5U7VAthlMQGRv/46uL/63Cy4eeqEQevqgr8TafsfkFZRlG0UCCL6OoPRtNDYyvgbBwwdqFB/MsAZDmYH9bvhhWs1Y++sQXtn05iHyoly/6O5svl6itweb4a3qplV8XkfgxxjEoWdpie6XtaKVcRRZCP9SJdCmyaILO4FZ+0E2oomn1TEB1qPm8V13duowqdT4mybFr0GSZmNWZoBEj2/qJIIXJso7W0kvC6zq/6ZGBXYJwIWFmsUWWgQJRuZLvkhdx5Ax8UuFn4zkD1dQuJejff85b+4CxchVOLEVSp41OfZ2XlYkCzYAWQA9kanIDDeQDHVBmn6eE6m3r5ZYtrgFiAGGOlFNSFjEO2OAvBqe+ohSZWMbsmu7MKsusYACx5CBaOy414gW8ORUgAzBjPWRyJVrcZ8zWaEMiDXD5CNCFfB1gVnk5dOXQSt2ujjHWtYfT/TYGuABg+P3wR9/XAMAQngls4jcPCINVXviF4ZSW4ZwXgOImB64ulhVYw7As6a6ereFn56Jdkm6UTvjDXbPLbNYwur+5pw/koJf7/ElYw4hmoPYKLwJ+cd4eXa4kgBgc8X/6ohF4pCVJe973FXY1m0oNbKwGbEmRHkanzCc4C/3JlZmGnZP9BZbxm6HJ5h7G6SmvxVHzBiYC8FgllVsMAVAGOi3AZ6LzMJIGEnwZSfHZbGpgDA0weQNAeaP12/M4zqUOE/WXWrqzisAE9H5ZW36o9RuzW7lE77QzzeHva8EWG3Z0YJDyIUgvy2XAI18DM+QJNnYpJh9p6BGG6MFncWSoUIT2ZYcsYmf3QbXLdxy1uEj7ABt1nVqGcatoFB2IvTQG7chPxs5T8Ze60R8DJgroEkuLoizaCL143s+4Lzd46X+krcPVIepUpCpJaa1Nrmt35n6VxcE1ViN+3SP2641Vy7YmJEx2DGCxOPKKrVz9sxig0rnQAYHIZSNPUpTfEVpivmCU5v4ySxg57bUlSeoydU40+7HlRvqbVJEpAODsVA727MuVeot1zZYqQSdNbD/MkDlTyyut+Cv3Ptd85QGWLtAtUsrlEnmGfNGoFeoQKiTPH0ApbmORBkPwDRaK2Cv/qV/RMqT7vgwpqswDwlAXizd3zuugAV335RDH7elFGxkPaMAue3eB6iVJANxfePegeaNx4rmAGfMtNCBi00ncM50G1u9sWmsYLe/B1xMWX/T3+QqtYe5prL+q5c0rfZjhh1UV43c66V2/eyt7tF4acMDEHsrWMQxdeT5Z0PzBJhVMGkpB+9xqE/Br3KeC5gLxbLNYBysTHQFEpJiLZBhPAwm+jKf7bDk1sDINDDnPnafx1/pS+uThnn3hmqf+LHWwcsH0mkkbYA/r32unv7PIcB7tUnP4++19krwNOFZAquQZ2CJdxUbsHapxri1B0iTdZfPyPDGABldhJirv7kVWGThLblLmZBtWpkPwREzVoTS0oHvctXW+zHlb/pKwSKdm4IU6fqIX+DOBBkP17RRUgAEHDMFDTEAvNQ0swICEQTo1PFh9440859Gdi1/R4PYcgInNXazncPvExGpxPmWiYpIsLx7NSuDC2oQz5Ip6vVJfAg1kkaNdA6Eol06MTydjaWKji1d6kF2L2tLyJNU9Ub3jE1mz4LhXPGdiYEMD06ny1hqdtoAU0n6e5CyPgyK18ejOveZ7BLo83pMjXyujWCn1hzxJOtKKK/lgdV5yLtnoVbIT2tbwBHLmCLYM6R/+cvMDn/ugea9YwSAmQJi7cqrDNtWz75AkR6BPT8wBKM+LBwfXd857G3ZzwR+R3Ru9awiQan52BLqgT571gC8A9jhcHarTE7ERWa7xWFuZX1VBWCi9OvFdv7CEAdBYlTUMS3yxMp0nYA2DBQ8/7iUsV9nePENqIDXQ04DmIWXYBh7RaOwfeOAySxUbb8WjgZzhOYZfKysfZyjw8d454DHuItjqMN9RMVYvPmOhhQxjaCDBlzG0nm2mBlagASaXAV4sctLMQ9wf74s9ifhKhuz5rFy6/hwf/9nm9OTPG/CCPH4WSqLNi1infYASTURLl2r9KOqc53HtMIAiuNN71OgkdWW9Tijblxu8QY8YaefT5cWbwhKCx2MHTehgTZ9IlwwRugBQoA+aTyuO+t52YTVZpPX+1gYHWrp2KKNYcwCPLe/l50AZ+Nqf83R5LyBv58HkxUkWG9kO6L3WvbjIMgkh0r/giB2PPAaAUUqTHbOKsZhq4kdEyZOxF1nkFNFh/UILWMSYPBXSjmAWO27vsgOUQBhljwCx5KEXOZRy0zKpiqUvyLH13Srw/m41D3YPBLp8YKAL58K18fNBAEEEo1gGFutfj8kLr3pE9CxhskNeQ3VjGdKPfPX7JgAYGN7oRf+N/MLMBcIIHECH+IWJHZIADa66VCP0PsspbioPl6b+O+2fBzqod0m6r6Uk72j775uyJAmAfx0c2vb1flneLL6O3pqz29YaRn9TfKDgXl90AKS66t/PUB9aJ72yhgHQeSifbbcB5BzSRdJSA30N+OzAP0zZ2C8G5g0E5gTMN2Lst/mXxjl7hlPmEwbNAURhEqL/ZZahpFLMKzRBUGTcKraHv8WkM4yigQRfRlF7NpoaWJ4GmITN4jx37h7w1OZBvoCnt++WwPrw61q5xNloicfxjxrwQhfLeGOFMfgYjbJIRFXFcUq8zBJaljYxy6nHUIq8qqKLHD5GwyqtkoPpuhxhkY+2urw31eZLIvLUtLS6SN2gt+cuuoMu7kC3lt/ylvbJU6+mc+Z9ucZX8UY5k4UoU3JCluXLoZNPfzvApeVB34ARVmYnRpEFrztJizKqGVCimMaZx6Ad3w2JmDwTngKmkOMGEi+RlStB9Xp5kxn/FOCFSdUOPGICdDnDckb80BCwJQBmS/5dsIKhr+yYREJsNhFjInVv937z5YPPN4/vPDQeZxQfwU9QFUlzULC0J9vjEK0t7CWuwturei4b/SsFf/WXyzKkr3z1HOu8IEzfOS8gTOvbCqXPEC4CJWaovhks3HPtDXNxl2/ikiTGHaw4NzXU1jA7AjQAM9jBiq2qWZa0CMCEWyTGgkXpqXXSW5YlsVNSWsMsSrspZ1M1AKBig7Uin5UJMOERHQO8jefMPtwqN4oiZm5iQebGNivSH699AFQ9L9GHm/LH7PiMcXmdPI6igQRfRlF7NpoaWKwG6heMRU+Y+j1lcPDX0N7bVJ/xgjx+BQBcCFi5fPxs1h2LLhCqfr2WfxfeWctQpJT3MfL9uJYWZ0McfG06CovEKG8ZK0GU8QIXFhFVkZJtzQlyJb6l17SL0jHwnuMRIWgRh/DIW6wD15Q0gALLZMyXiChM4p23G6zJT/ycoaXRhr/mUscLuSehTdQbyFtdMU3jo5wyDhZLn5y//ybrBa/zkfNzCH1BaYPJ8/KghVSsVQxy0azFQRZJEL/5kaGEuuhNadrqymhRdJ38lr4g8zLDywfgCj1F194G2ItSKt+SMFtRxA0ETbws3/pw//PNl+5+3roW1wYwh/ZMVjk37q4+zVg4dIUtaZDWlc6f8k504ku+L3DaMqTgCxCG/LzOecOZLPcgSygu2laZbZhvQ7BbYco1mXb+05YkYY3x+o187UyruIZ0HMm+2mDwpVYpQMxncnb7Gc5utSTJfMPoYlzXGua6Y3zdx6G0Oel9Lie9KkwnvUMaStpt0YDNL+xkeYoClMRwXQZt5W0ZN7NbFeJ43wZXe+oytygTBeXt4wGTDSU8KjKKMm2eQTMZRtVAgi+jqj8bTw3MrwFejLFymdd57rwt0+Y8Ox4t3sqlO4O3snY5PvlzBrwElSEnftBIR2Ds4SUZIlFJRvFEPFTW0kj0gpEkl/bOF3cUMxOt6rYldUdLeVtWZGpYtZKgW6xD5Cm8LF2XGxAgkQz6bGsMjEB5/JwSL/uFrsIoJyZ0+cJbeMAboqzjcx7KIhjmoEzwekzHBmiFL8r8YiLT5VI3AudVB5dbUy5Oo22X7K8k/n3JWwLsYzkSMlsgxmZPAl5UEX0eM2ECSdEdauCK8shEqslW/XDaa13VrAm5X5SVy4f7XzBORLpYOOgNMhRbtksjjwkWHarTJuSiQ6lzEculZaXNS/kqhm+90G5I+v3I955fhlSxtX5hrgLCUD8sNwB7WTqDvl4JLOC5abqrGrkl2IuBgNVpXyk5tCTpoXzt2JKkDQFhcAa7COuQKyluBcxYvvBbhDXMrDsdLeK00knvIrSYMjZVA4zlPoL7IOxDutL6D90HclH5r7mB+36Bl/EfbkAZsmVeYGYzLhOd8KEGhlOVG05D1ioQZxhDAwm+jKH1bDM1cA0NLMp57rxduOqOR8uxcul6D/ByVAEvPiSVchtkOt5+ioHNxiwVMFQRfJjyuM5b4awHiWK867/ceQshJHLeh6C2Y2LpO1zBaQNxYQzZXVkrwRJBJxPpOka8LZ0p/eSlKvQBX83radeQW16cL+/4/XwCSOkDL5aXcuAnjcJJcz4Wk25/4uvRUWyUUzl0EjRiFzrJZ+T6YHKdx/itLPI142Ta9aZWaUgZs4ARsCJYxSZGbDHNZAcw5UhmLvFVywCbFqSRLpkIld4jy9JGk6XL3heaL+pHsPOhvDSIPqyXMdGiE8aHJlRi5aoHP/2gTAejW0aEiKm4gGBdU3NTw1B7Pf6f+iUtQ3rwoPm9X/nqVDEUhHPeq4IwOIytnfO+88B9mLwEMKj6clN39wml3tGSm0WFALawGLJdkt7TLkmyKMHJKpYN6xzqa77O/ZynbxdZwzB+zwI82U5Hb4/naX7uOtwz6aR3bvVlxQ3VwJbMWnha+gzLn8+M3yyj9XkDhaKLZmMtAzjjv8p9FmFZ5aEz1otu5SjElyDZTEDlMS+gJMN4GkjwZTzdZ8upgZk1sCznuTN3oGKcZcej2soFZ3vz71hUNTyQfPbmXwbzN2sCinnHi1CnoTG41TRe/H0gizKV6n/w+asDg1sXIk3s5V1ZP0V5/PplXd5eo8/JMtltA95qZCNGxmXpoXKNydKXv6QzuPsyGPrhfTG54om6xPbTwdMcK94ot9grwgG380e9kON1nUc0JUjXIE1br5SRJzhv1FdclzOxcLaqXXTHL9q2ZO8Q8lx+V+j1uvz0FJws1+J+4p0TZ7pnmiy5nv0e8mVK9o3KJkDmY0b1KOWa3N++13x+78Pm0c5f2eLDAABAAElEQVQ7RuPc2hOKppl8oXuVWa+pKCYmXSTRuFGYhFlASKRdXJcrLAN8dcll6WF5VS26UIcq36+LBcxP/8ovN7/3o6/WNQbTAcLM7ZxXgMED7aoWznkBYW5LODperL+T80uS9gW+aDvwt+yUtH5LkuxF5Nwf1828+tOsYbA2YV4xLVxnp6NpMq9Cr530ssvTg3TSexX1Je8GaYDhOoAU73ZZPqTZra0wislAmeMwzmNIy5hvf8E2pjIjUMLGfh9kbZ6AOW41Z7B6ovUtrzdIXTeiqwm+3IjLmCdxUzXAEh8mT/Nttbw8rfjj3F/m6lZqKxcmTx8/e1sXLyz95vhrmjh+rXqtrF8xpzRjnWZ46l75fIjyuqXYKsf5Mbq1aZVE7agHcyfNqtoBGjwxtXX+Sc5aBpX6+SFazVOna96gR0wZwaxcPGk7fVCOLoJvIlbGysuJWNr4o5+uiZpOBahopKWrPhOANl8mD7VeKCNPHMH424lGVz9kwxdyLd22Wc6n1J3gKw34OcM3eT3gjVD3JWjTYgAW7hOWFwFm2YRHstlWmgmVLTNSZXPeW/ppZTprvmsBunxu98Pmwc5j65O1jZDSP3p6rq/lurR9Knm64jV1RAdBF2OkTWyIr2OE9eW2DcyRQLbChEjRyE8NKgeA+esCYH7oo69OZasLwi/MVUEYAAN8wLwQ6AII84UnB+YPhmt4k8Mdltws6Rz7S5LYYvjhPV+StFbglm7CJalgbW+dvjUM24ijAz6MDFnDLGqno+sqBGuY4xNtIpBOeq+ryqy/rhqwIcdHeuuiDeTxkGIeUY3lfG0seR9L/cgsoRtdqUtW9TBBJkOa0ZciJgO37QEoLaxTSPBlna5G9iU1IA2s0nnu3AqP57ziVVm5RF/fHP85OentgBfGqaEQXazLbLwxc5fhStQhUGr1C8HSVoUBzMvhg2syH1RizD27UER1BKX6NMv3ibzEW63JPtdskY4Y9khjtuoDrn9NgR4v88FT8wfN+HSwuJLnee9LzRMy6C10cwgrtra+EqRroKXNkyi8Vs7kQqSJn9GCTvs+mYAHRostGTzQnG+CF/4STH5UrGhRflHMUguqhvWQi6G9LlgPdYPafEk3nznlLed5b+tB897ulwS6PLHJkN0rZUJEv7mvTSYHxHoDnXAjS9fGGEylWPzWO5ukqUz/zWIGmaRDXsQTUq+ZoSu9QDMXhl6db14RgEF2DcKwJOkOpkgzhABhAGLwCcPuK+8+2rNdYy5yzjuD6LVk2V3RNsv9JUlfXKMlSVzz2xymWcOY82R9NGkfKWumpNpJL9ufH+zt2tbVa9bN7E5q4Eoa8LFfYzM7HjJAa9y2v0EbOEnb6O1TADE7iMJ8Tvzi8TmXLVCyukaxsV2yYOhPINRG/THuSp1N5oVoIMGXhagxhaQGrq8BHBau2nnuvL3mYc/2lgAvBL6eLcvKpe7jJ29+n71UDr1WMZ22saquUIhEbVCmc1jWUgcTUS/GMZgsXbhjAAu+CSG0I0J5n7aiQT54JipOZtr6BhpR5i/9pOp6LZ+zdEuLxMXSIgcienXgVQg5dUy6n3debz/aC76IQ55DMDKbLYxMMHySAIfLMJoqWjs6OE+Rb/xehgh42l/JI4nz6n7OBJ9dqcIX9aNdLzcmO5Bv63CFC/hjMjo2y5qli8qPTKjOSOnJENKDXiTbBOq0eX/nK827u99j94X1W8WIsElX0Qs1XX8ugzOE1+jcB702nW6VJruiXF0WabpOug2WoZ8V1ZhbjuUkaHJKAID5ya9/vfmR7//+5t2Dgylc58kBwlByVb8wgC28l2MJABDDvftaX9w3eVvi8xrCCfQFih+qcA0aQMfTl0f2O5AlzJOH3ZIkQIBVBxzJrvL8V31+V2mvbw3zSFs/M64DnPnz5yrSVsuLJQw/LLkOtMsT9xbWOhlSA5unAfs8o9HXx2D+9roxOj7i6d4uY7JxaQ4QfBTYna+DSwhJ0oQINt+NOQMf8wyxgTPDWBpI8GUszWe7qQFpIJznMtnfhEdhWLnwAkr6WTFZXsXF/Pi1gJcy/tTt+WBTU7p06LSMWWVgUrkKagDmIhmdNE/VvN0A2ZV1/AyNDih0tMkU5UNhiE5bHpRgkI3BNMiKDQyyMu2wo5cer+IDMWytiCodtDq2tA7E0YwDHLSLpE6W8ZR8KVI9NK7+iDBUzt1udJtAGGtrEdPnpz1vu5yHdYh05Ou+dPSQg7JIEyyOTOStxPvb8hit6zuns6Obj/XSvLgBEqEYRJVpT6lRR14alHd3vtw82RHoYv2JMtdD0Zbp2kAYEbi+E3MkmErfLVnlow3iiTp1QeltkFCj4Xkhx2I1YAKCayAO/oGiqaTS77a8n28LSqIq/6u/+ItXBmBCXPiFmRWEia2mzznnFRDD8qS+c95oZ5PivZ1te7keo88so+XH9t9jLUna1/nThwyTGqitYZ7c3zPw/rGcUoc1zCT3+uSOtCzpSFZrOOoFgOHe4pchNbApGgDkZyxmLuFDn4MxtrORyuxjo8Zdnwv5WRlfGavbIdnmRmWaUMZQ5ipmhWwxMiQtAJhNUdAN7GeCLzfwouYprbcG1sl57iya4msSE2W+LvEVEysX/Lnc1datgEbLDi+1zOj10Y+2L7mMKQw2bThHaEs8ofIyJk0WQNc/k6VBrBZTpycrtSLbPsA7FHC8ChgSEEjNM1RnVprJEXMnl5f0eFEPKxfKXUu13EgPxQzshHNlIvgk4Hw5vPGLuoAGIYO5QdwhwWexDp73KzBRphLPS47xIc9luuySpm1rq8tTkbp2h0SZEVwGdC+HL/TjcYAp1DYe1af/7GJ0qrSBWUUWPJeFkP5Eli6Pt79iMkPHdd3Sege8lD7SNj5jOjCExpme0T9PI4cz6r5khTQKEADHHMEbQfiFMqrWhhu5avtT+K8DwNCxq4AwJzjvKcFAGO2SBCjTd847dC2j3lrH3BbdKY7S1TGXJGH5kuDL9MuONQwA86cv3trTJqxhcJzMuL+uVkM8OsJJL9YwOAxOJ73Tr3OWrJEGuHn1XNafnY3bNqaTJK+BhuVIFJZi0cShwnbbaOUNUBF7HYyfMs3CzswqzCW7XOgZxtJAgi9jaT7bvXUaYMK3js5zp12IsHLZF8jCkqjPXr6dAFuePNjTBG1a7cXQAV5eCngx5P8CkTbIqJx4MjDYKOjgQ02bmGQrb1JR30ETZ6FeS69qQRsavmpef4Hu6lfVW5k1LdIhI/IWF6K1i2D9xwKJAZthud64IoAF6oWsc7HV8xb6ZVEvQA+E1Dyk+3nqAFIQoqxORx1U3aZ1El1a9Iky+CgvPEw4iuw4vzrfB2IoIwSPpZUJmVZYDjUPJPQKoAGAZj5dYEDh9iPj5wl1KOzJn8s7Ox81B1vvWns2qeozIsLkegFnZ+clui9Bgk5GbOIzdjsUsmhV9clyE0klKltm/kO0GRKuKy/k1PFlMlX+V/9+sYC5N/sSpLoJ0gHC4Jx3Hr8wtXNetxQ4MSe9/XbWOe+3xGUKX80Z1EuSsFZ4V0uSoPlL9HKWJO3LYpNlUBmmayB2OgJo4T7fEZjBcqT339mVJYy2bNdHl3UGsMwapjjpBYh5qOVUaQ0z/XpnycgaKMM0Qy3jdYFZbOg2a2YoNg4bh5V7yoieL4/0ji5ZZuHC3MHBG/JWQ4dujjHyud/S5hN8uaUXPk97NRrYCOe5lSqwcsF0915l5TLNlwvPen/0VwIWmHxx9OebF8dYvPj7I3EZjUoCwvRA/6KPcHlar7gkFHgJIZRXXs+Uo2/755nC3g5awej9KkKCGPUVR0n9kTlkWWd6dci25VVZAA2QkGmDsRKcx7EOUWcyJudgBfXaMiXaNAUKkY+05wfqFt7gJ7a0Dg5oeL6lq9xe9KxcZcY8yRO8FgefyaV978NkWUW32UjXT1Ur5yKaATUehx6cBpcHlxtXSTQl0S1u6zB+8OVFk/K9ZlWHamQRpnBn637zaPuj5u7We8rRvpFbnpJ14sCxElUqKkKIKRISEirrl5ZOWRWKoHPyKpaVJ4dOfohWd6xXjgXMFx4+bH7oqx/VXFdOh18YB2HuyDkvmmqaXYEyb0+nL0kBGIgdknDMG35hnr863hgQhrsn7ssrK26JFcIaBr3u723bLknPBfrbVtW9++Ba3VirP4prncnSKvd3OgrfMDTI3OC+foAx624NQ38BYj55jhWP+i4nvffv3tHfuf+9U54hNTC+BnQ/as5xxrbQ9qwrjnT1oGbeYiGAEyvXM5wvOhSp3CIljRPAxXg0g7K6MUcsz33KNN4F1WTnYeUaSPBl5SrPBm+DBjbJeS7Xgy9dsU30kJXL4DXjIR5P/UGG+YnPBbw8x+KlvNnSlI0nRWSdhmSDTikjiq5FOoom6EWIvYzAICGdnH4LRWZF9mQQupptW8hTMQNhcEVZxOfpDIrDIUAXLDFYNlDzxfhMzaDb4KpMgBiTZV0b8Hd1/DwiT0GURxtRFucV8lu+TrSljK5DlEP0tJ9rv9zlRZliq0s+aKqvznR5eOp86YDVG2iL9o2/8OmUAVy4+li6ALoguw2VnJbWSwC6PNj6XgNdrF+qMxRC6kQxxIrAmUy0XwkyVruplOJ/6ZvVMSAGQd1kzE5DpK4JL69EzpxEBgEJhMgboc14mR2DkUydrlimJi/g/+bz581f/6VfaX7oez+aWn3WAgdhDpu7OztmCUM95rSXBUAY/L/wwzIwQJhNcM4LzjTLOV6mg2WV49yY3862tgA/2G0ev3tgeXx6sNvNIoI9Gxch6AbKaB8jU84tfMMAYLCsZ1OsYbhz0knvlIua5HE1wBc6xtBTHYjtMefzAKy+yfqchVSZsepBviX+U9YeldHY+ERjlRKgTBGj4iJUtHbScOVBWTIzLEwDCb4sTJUp6LZrYBOd5xroIpNcdvlgcvvJs7czP5J9aPBXxUVe+2cCXp6VpUY+1Lj0Nq0ES0LK0GKF9oLO+HJBiGIbkCq+CbmFPim9G9paXvgk0GWF5EooxSpkLGVojOD8kfN6k7Qo85gxE9DFAQjW4k+WR47ytj9Kkw25/qJRa6tfjpRSXip1dSs5VRnJDvwYkuc0PuTEi57XCXnentF06Mqg62e04Cm0aLMCWkwdVLYy5FA3+KO+FzobOne6orJsS/5c1KC3iaRSTtKC1wm6ySltPpSVC6CLAWKCcOw6RLWpMZWRWYdJGqWliZppIu084uImKcxGm6hcyZ2gT4i6NEMThAB7PDdwvKzTVqUIa3nbRHseA5I7ktgXCcAg+I2WKPB7dnrc3BcQc9dmr12TF6Vq57wP7+0aELPWznnjYl50UmtQBgja7pK0wCVJBmJXt9wanOqadaH8fV7SK4Cwz+QXhoA1DD7gNskaJp30XnKBs3hlGuBxxNjKgTnMlsXevM3fNKfxv0odLaE5Spn8WAnzF5sHWO1u0ineQkG4TRP40MScbEOGAVfCDTwm+HIDL2qe0uo0sGnOc9FM38rl42eHE75cZtUea74P9rfta9KsdWbh+8yc65b3MA0SNqiUt0sbn4oQ0nWwl+cYm1RgY1QV13WjXvCck1UYJst9AGx5lbB0MIXQXtzhJZOMrZweP1leEMpYaj4QhnhrmqV1CFo/psSAidKWlxeQoTDXdep0dA9a9/O6NV+bViL47BxKPeREH4y34nN+ZOpn9JBfaFHXgBWX73MPLz8tEwtr2BsqfYj6IY9C6ZbP/5IFmIWcfptU9j7BXwKEEu5vf7W5v/VV8Uxe0yhfRIxkm3hd1IYzWXOcYUzAurufe8nPL/pkfBfJLIzUY0IY+mnr0ybhnIKqzjjH+aN0fi5Uej1XFoQBHgCY/0MWMP/sAixgohnO+enbo+ZjvVjOukNS1A0QBosAXkY/eHy3tY7h/lqXYFdpnTo0g2LCGqZekhR+YVgSc5Uww116FXE3jpf5AR+SrhLcGoZle77t8/vv7G+EbxjunEknvTtmbZVbVl/l6ifvtTWggcec6zMulzmOj+E+b3OkRLMN3bD+6OYpJie6que+W5ibilYebjbMitGpLoMi5pV8KELeMucu19bHLRCQ4MstuMh5iovXgDnPlWn0oX6bEHCeex0rl6FzBHjCmd0iw6+8+gM2fiCTiVEZS1pa0IkpZQiJwHTRBicrsTGsrQ9PyIo0cdTun0XkoxxeQj8/QYxKRvRDvOMM1it8dVmALrG0qBJ1ru263lDaaZ2Ggif6xNnEAExZWz7Qr5iKw9/nbesp0S+zF/ciO+oinj609axccsukI/gsLjTAFa6gy9cEwmSQjx/yStrqeNrqFBlbsmbgjuFd7VQCkMEXIO8H/C5DkcnyOybozgfgcm/re0tbcFbBBRmB3lbZismTl5U7F2fk7Z/nRzrU8yF4Nb8qEzXnCbrlJjLnZUDp7pOu3M5JB6rz4+B8JAph6plbDZgmA2SrO0kepPVYvvFs0QBM18dwzntVEAaLgPALEzsk4c+ElzwsDMcONvkeuxNzth8gTCxJ+rwALmizLknipZpxK8N0DdyTldHrt/M5O+be51rwM2sYycIaBmCS5cxYM61rcCe9vpTwjuZLLMNOJ73rerVuWL/KhIj5K5NY/yvxow2PRve5gA2W4meuyJzJVioptgmNIkT5UiUsccXH1tIEpdkhiUEbwMalW0keRtBAgi8jKD2b3EwNMHF+pgkE2ys7Sr3+5xFWLjiSBDCa18pl6EyR9+jJXb1ozDdR68v8By//gAYNTYzL+48NOmIyQMVo2kZZhQwlQeP1tH5z86GlUJQpopyrZOoaUR4DUZ2PdL+fU/N9IWI80RDHuOgjnTN4nyspKmcghUd3VrsNrHGHzMJeZ+u0FbsIS0YbwcOATIh8pH0IjkF9qFw0q+Q8UZ9zatNKkG7zCFcwmpU5WAKh5rFy42QSETIKr65YgDE18BIWLueWFqlDnHP8eL0K+aiWLz3M+1tLF8qtza4O/FRCdkkaj76FamnR98mZ7gdFJnVgLUpwdqtz6QFeawhOEjNWjhuearOEup26bk2XHE6V4rYbUd720YuqrLXe5pWwe7ffp5ahX9DLG180WsqqupQQKlJLiLJvLhiA6b8fBghzoOVID+/sts55vSPTj7Vz3ntyYs7ucMe6AXEiOxYIw0slwOOmh8ElSfqDNisG+eGZFvgIcVVLmWmybiqdOQPg4XXDkDUM9/+rN+7T57ryl1mfv09z0quHjDkYvrubTnqXqfBbL1s3mia2PJt9dtEdff5z1mwLZbH5GqCLDdooTbMQnueq7qUCVpT2YVVHlfl0RnNnFfhUQHT9Hxy3b/11WJ0CEnxZna6zpQ3VAOv3+XIJ6LIJobVy0RcnJhHPXx9d2Yx41vPcxumXmO1hP2ulAb5fFPDCazdykEcImU6LVhh+ysCkAgYW8l7HXofPyYiaFLRpybe0V7T2zpUZdbJOIV0cRcfFFeIdwIhqOgcGQn4iUcaLWlXNGPv5rnakPHY+b6mto0SkI4abdOS7OFKuV+MppNB11G1jlRsfBIWhdNAs5lDxlWwBOrzdFliRVgJ48fYpr/sW+ULTTdDyWVoNSbe2tln1wtLFwRZ6If62Dn2flAMHtG2BLve3vl+gy+ftGkWfKY8wRIuyy+L6fmt5B4gtqU203JaYQp5gkjrsHILIGXOOhIkyOyEOXmYMJTftXNEr3MghTN7rEKBOyoPidEvZoZ1PdqQ2ZbWndUBcBsD8Ay1B+r6P2jqLTryWTxh+84AwfPXnty9LgMf375gFAM56r7q8YxHndHIT0JdKEWEN0y5J0geBaUuS7goE46NBhuka6O90NJ1ztpJz1jC6Bmz9vAnWMDzLwrE2wCX3GLtB5rKk2a59cs2ugS1Qfw2izE0Yn2NWGyOnyD5kio2NKIxdFF96pLJSDr+NwSaH9lWBNAX6sQNS8FKaYRwNJPgyjt6z1TXXAJNinxzLdkHPrk0IZuXCFxpNEphgfvvpm+V/5UM39rSfX0N/7+UflIgO2KrVHaLtGtjoQWn34uijkY0tNljV3WEA64coh26lOtAGIbijTQoiHWXOeYWjKtpA2Ur3PKdiS4sGBA+QrMGaHi/O0RMrqxiqpLUc+X5Mff+yovMvhTVPna7bqun9tOeZRHgNovhBsTSjv6X9KnE+QW/TRkOOfmLvAzJ2x1AGX4m5YIBa5E/0Y4JioA7pkGex94MrTLttmfhkcN4cALo0Al2sj13/ybfBMn4e1sG2oOOvSCVJpVKnTVX38/kKS6NwD3KNfBLXa4YuTpxsr3wgG9fbJo1CUiLP+cYZ90UGfUCck/oVhhgLDwDM/ykA5vdcA4BpHzFD7RTavCAM1Vmm+h39AGEe6QWUl7jnAmFe6dfp64LGr1nEMlGsD25iCBDmoiVJiwYWbpoe45mwrPMasobhvmeZEtdvnQMfsuJjFgAMDoZzWdI6X7EN6pv+BmwexlhmY6/mJYptq2ibzzjZt45mzHZG5j720UK8zHkimAjLiE90uBlgGIk9jezgzngMDST4MobWs8211AAD6yGWIlpGszHLigS0+NKi5Vu5DF00XhvLaDFUfCntF17+IfH4y0AMHYwr9hKkkhgfLI6mrIbMMMtAYvWCsdSxSaTKCSG3DDtGqw+VWCOHKAanSEdc17swHY2KyftCLKIE2VKkifcfZx5qo6MN83Tl3ps6H+mh2GgxKKsq+SG+oDJsE1o+JWKsD1pbv5JLBfhanlLJAJNWHrJ1deAlNjoxtJKPWDQHSsRrNK+LktGvgS0yzyVGjvEWPpdLvWinyEeEaPvN92uXm99Q2hdtMJT+qB9tMHmRE52GSqiShVLVCybFpQtKUUO5jlBxedlg0TlikVPVjqTdhiqG41w4J6fjuKCoY+rJNdglKtYNKg3ZQk2H0M871/njAB8+YK4LwPgz7XxzfUqAMNCv6hcmQBgclN4XYI5zXiwslw3CYKl4Q7GX9vJMLEnSS/K7D/ftGcxyL/Sdy45aVQ0k2r/KgbLFkYasYZ483LMPXuvuG4bxg6VT/LCGwdKYLdHTGmZx98dtk8Q9ZQ8pDX4sI9KUxcZBxiLmOcw6zsy5C3Sf61DmY7mY2y8oXtHr+1zFdel/11bHpUlM8QXjDHlcsQYSfFmxwrO59dNAWLmwtGhTQli5sGsLy6G++elre6lcdf+xsLk3545HP//iD2kYOPExpwwI9L+MOxOnAlbhQ0VXCojBsOTDSvcyZxwazILOQGS0QnE6dbtgY1+XtRS0uUMRaFYYEkJrnbV/9GBYurfb9c7yvc7U2TatKm26iI48sQ3w6scEbYAvejXJp5z9r/ruJFMuvAGUUJ88weicu88ulA/wgrIiSxeoTVsd5QuN6+51oh5lHc2uv2YgsbTo1OpFOT2IeoVW5EZ/kb/f/IZmH9DF5FKHEPW8PadNHpFB8Nj5ncJx8voFb1d+PkWNjo9UJ+M8d02ZjbcFXbpGaiGD6WCdtSedENWQQq1nSlrbKqwBzY73Cqno0AVVFgHAXCB+sCj8wlwVhOEllO2UAQZ4gQOE4ZmKhQBliw6AL3xkuC0BXfLjBfne3R2zQkTPy9Lvput1787WypfChTXMcwFjB9oljJ2SeBZvkjUMVtLppHfT7/4R+28DrG76Mn+xmYDSBJ9ZMIj6/MDHUh9bW5RGAyvzJMZXw2h4xBf+7TIOMwgzr2oDzBlG00CCL6OpPhseUwNMQF9qgvvm8LS8GI7Zm9naZgKJuSsO4ML8dQyfAXVv593x6OcK8FLLimHBhgQOQShMHb0u8EEHFqj8omrEENo05WLipR0aIaSV4azNe6kfg7fjrkt7aQnEKof/rQUGs8mhIPJwCdSuj1St+QbTXsVaIVk3OQluGEsrL2QNxiJO0sl5v1q68bgWWxrtezOaEMDf1Wn7Uuiwwes8kqNMa91i9aKuYhOqq1d2LkK/vEtaXZMXcoIWeeS6HOYl8O9padGegBc7nyJXGZo/F6DVP2dyeZx51InYBFjG9UJ+oqzkJ2n0yvn7dLuZTGg51I3WdGulaxNxxiqB9f0wUWUwQw86OZEzWYP8Q8RyNtE2fZkqYGrBecUNNdWjfePpfBYwLBG8TpgXhDHnvAJh+OqPc15eQAHVF+2cd0+O1zfpI8N1rkVdl3Hq7YtT+ezYbbaF4n9OINcbgTL4Q1sGyFW3vUnpe9LPvDsdXfc8N9kahnNnTlY76U1rmOveEbeoPgOsxlubzQKSlFO3UbEc2KHIx0+fqcZIZbMGFXiewRZRyimGylxqC3Am6qvYrGmuNiEoPcpoURpI8GVRmkw5G6EBvlDwFR4TUcxGNyE44OJf7QBbxrJyGdIVXxWvuuPR15//YQ0GrnsbMGywYKwgR6aEQg9qlDBmWD2x2ZCjTPAEHQmkIz9RrvpFNGzeohiq4cvoVz5Ihr28SfgJnaQRBWhD41wpdqbqWNOnpYOd8gmeKuP6dM4gXxoXhj4fUpDXpw/lofn5wi8fKjp/28XJhDitltfKHQJPaFMC7Vy4RgJdjF80DAOsLePxvlFm3/ULsNOCOGL0j0Hy5yLAZaf5Il3w+ghBRsl3aTVoZZQTlLfgvCUjlo4ObaJKx2SpaMN5vF7HX/ehqlgmUkHpYmpG2x01UlEydO8FTx13/aipc6YlLNpvFSJatNGekl2s0oauWcsRjFdtvqoHAPM35APmd1/VB0wl46rNB3+AMDjnxRpmV+PNLAEQJpzz4k8inPMuDIRRN85qnc/SqZvEo/P/7MWR/RhX2yVJWmqMBcZtD4va6ei6etxkaxiet2EJg38ldprc1w5SuSzpunfFza3vcwiOPKB1nvq1Y6TGRZ8Z6AidcszAFRtYYzF58VGJIEbY3GcMWZ/d+lyAEuoWXsvlYdUaSPBl1RrP9lauAb56MaHFuz4PH0yvP6cvi/pWsfK+zNogJqx8AV0nK5dpfb/Kjkd/5/kflRgBL7xogcaHUBspyDAgtFRLGmuhRkkMGxaL2OaViDTSBvlFh4eylleZ4BX5SoEBzwZKCTjGFKMOpYHL3nfqWl2alAsIWsQ0EemI4e3SXXnNW6eD1wfkjj/owRuDdNAnYjLqIlcSPpfl/Yh6nHssI3KZXbnJ0gUmtvolNr6gm36R7cuLaKPmddlhLQNflHdyt7Rz0d3mHyugS9BpZVK/oUPvF3K6H9wWrNDpxmDnP1BWSNFGV9fbbIuViHZqmqc7XlJlStWyOa3N+tmI6Dro6N5CJ2uiTzXbZWl1tN8mVYpK2tp1Sy2xYgx++7up6C3vUCNtYS9RhA21aQDMLwqA+f6PepWmZ6Nv0zlmLwm/MFcFYWgBCxV+AcJAi118/O8MytUC+r6tgZdfwK0I/SVJD+9N3yUp6tz0GB3hM2ddQm0NA4BxT/6RwjcMgGR9Pdelz9EP+suW3aenxzY/SCe9oZmMhzRgFsL2fHawJeZP8NZ/kbbNNJNiiPp7bcusrnKUlYGVpE0GmJtZui3qSVU2w0o1kODLStWdja1KA5iAArrgPNf9TXQtM2DzHAI0WLfBG1NVBm2sBdbNyqXTYC/F07882HslE9lvHf64rA8OjRV2QjtweLYcJ4XZi4ZI0UzUC66JWEzkCRbrMFHuRRWP9yDqlOKqX/2S4GDcc+HcX1O/Jkv8+RfhTkad8p7UOvG2g06nIu1xr1zCbICthUKr8pbWIWjT40nZLV8kKrl+fsEfk4EAOHzLZ6r5r6PT2ZpONw1UKSdBZJYuYjrRQuZoB54AdLi6llYcdet2AF32zhx08b/66AetuUy/Q2p6KSNqQ/TVz7Or41+UYKNdD+JRpssHfVocMqeVO/0ieSaBZmm3ZSQxKZtcW1w1d56zKhxITkodYAjSUGNVmRVLmPWrO7S9HqpubQ8VhNw6Ft88AEwtYhHpRYAw7FTEy6c559WLJ9YB3bWerZfcrf3xcLaam8/FeM9Srn6IJUm2S9K93ebzxe/OMy1Juk3Oee19bda/q74SV5BnPnR49LbBN8y+dhriAxo4Eb5h1m0pnX2QkkJjfsnfae2kN7esXsENs0FNsKToFAe4irHtZftoPrRsM0dickleA9+27iP7E2UQ5GePM1Eop0yx/hsZOVj+uuWxWKKuza9c3gap6MZ1NcGXG3dJb/cJMUBj8nnZYMzXnf6XsLE0F47amFAAGr3QpO/NwCRxrP5d1m73Nd6GhUH2bx7+RPONw69pYKhQfdjNhrJUsXxXnbEFEuMLbAwqNUuk65ja1CNYTD3PeqwMefrscSmcGiHdQ7xmG+giEkuLGPAuC+bwTI1dxms9KvJqsefTGjh7jbZ5EpyYQt1eWw7dSqfFneyWLxK9uk72xjpgw+uHNQqdOdWF4xoGP/2Cv81bmfJGkDwudLnY7MxiS4dswlDS8DMpMRmlPdJGc9m7snK5I9CFgNh+/4xe2vNyKN25hO66MsoVRLBqJU0dz6tuXWbM0TfL6ODyI9cJainDibbB4WJTlTrM+U8NFF0iJ4ovkDIpPipMUqfnpvGLbvpWw3bp6WrhnejLtPr9Fgf41gGAoZsBwpC+qnPeoynOebHqnBVQQb9rZNiAGlYWeOEFaJkWbJckLUl6qh9WCu/FLkm3ZknSxF/bNDWNTsca5vjk2OZ5tTUMO4WtizUMywxPOg/7EzpjjscPf0MsSXqoD265ZfWEim5dxvbu5MGsP0GGLxv/GNP5k9RDG5qBJ0oAsEyO5crr4xTkGEgDzHHARbMfBGkbpZjDmrzpj0IJyrBsDST4smwNp/yla4CB7KrOc5mE4cCWumMFrFzuCnDhoQlo9OmLcXYsuu75Y7590Y5H3zj8yebXAV7Ko58Hv48eOvEYVURh7PA8EQOOvzI7v2glYXzwR/WuGhJChMXk4edn1XXw+jEMwaHgRE/3jlafxvSfPhwzKPZ4LsryUoyMy156apkXpylFoodzvIVwjh4VFEdZF7u8Nh+JHq+TgzdiBBegQQx+1Tzv/eyXOQ+y7DqbUMmSjlEzvlxi3tqBLFUd6dPvjyKXto3WNIAu/Ji1mNjSBj30fpFSWuUWk7ZUyGoJbf323IyPQ8h2GVCirX6aPKEuP5efKOxkWsVzBy+3ow7cjxPVCz/lQ/Rz4lZF6Hemzke6xFwn03A5v5lOJGRccD7f+Ew+YC5ZgoRTwlWF8AtzVRCGr+nPinNexpAPnszunLf1CbCqk1yjdnZkMfF6xh0Nb+OSpDF2Orru7RHWMMhhy/Z1sYa5I+tl+nZR4FHD/DOd9F6kpVtSJusWs1ph+CmDu89vmROJqFvJym0wNIaimDIXhSeCktRlBuDiNJqqfOtMtjCi29jqBVEj4xE0kODLCErPJhergU9evL2yeTCWMf8/e28CbFt21vftN8/d6taIEN0SUiMgICEHECZgScgGHAIFSVFkMoVdGcukgkm5inIgDqRIYmfA5QyuiuMUcahQzHHMPGkAgwxShBgkgWSEhm61uqWeXr95yvf7f+tb69v77HPuOeeee8+97+313tl7rW9e3953rbW/vdba562zvnR1s7bsJO2wz3IZqx+BLKbEj6XHrv1U96gCL47Vs416hugsjE8dQQpoWDk6nniEzH1F5JGFVpVDTDEiaCjmPOWwNM7ARKRMO4DXw4plYmkRsmZTT9IMmrpo6ucOD3ZZds6HwAwbzRuwxBSCRedRWsN4AKOQwpu4Is/Z815Hr0ILPqAvqhXBjSbX6Zg6G4Enl+dwBaXMOfFAyFDVY6GGN57QG/LEKzg4n01DhclH0EU8ldfrSLWg8TOFyPuZO8J1Oa7mKc7DGVHIjDvK+XCI/heZXq66JZNSpvFyBaaiZ8POosmK8mc2tMcDwohg08Vp/D2yTRWKuqXFzbE7W+nBMfNwAcY9VnXMkVHxkRnQLQrAhK5g3a/zboMwBGJiXxhmb+y0Oe9+Bpj2y4fL6OFly6r7meQlSezBxmwYYFdsyddOD9fL2HSQaLb5paNN+IEZz/yO21jkwtkT2huG2TAE0rhm+5nw5dOXri+tkvYN29mXkGWFU7q3PHCHJUeWNDThZrB+z8cXNi62W9dfRzBGpkM0vMY4TqdZLRpt+JhIe/EaqgyiDQNdjHGsBC/BGMlC65S24YEp+LINr086N+oBbRLH6/IVEgOnBy/4rJOZgf0KcpYlvVtmuYzVl8HNvC8efeLqjxmLdRh6iCprUNW5lE7EsXpGLM/ErkKdR3RAzu6g/nUuZP6MWWS5APU3yjZNTU6liUw6Q0+wBNkKuvRVJsrlsqo6spYjl95MmtXHvaoOddB5io5DUdjjKwK9866Fnq6g5xx5hLnO6Lz9mgTeH5KRN4sPHG9ssBfdkm0XmoCL9lwyAIEE943hNaho8jIPUMrxBaMjd85b0OXzbI30y0EJhwJ0kKKu7Qw07HQnQZvpW77B4QoZnufoKehDSC2bHlIre6GV465wmizfGRueskp20LVoQkQ6e+jzBt6vguFA7ygjuHY6j+uayzXUW8o9KYkm9lIKfNz/c+WDSPxjdJ982mbAfPhj3Z9/zUM99LYHoxGEOWtfSLpgD2/H7W9k2cTLBH4RhIHvkrXLBAmyz+7VwAv+kDt3uDegG0sR1CKwxZKk+8+dlDz2lLtbvpJ0UL50NOb/VWAsS3r64nU1c7FBL30My7kZ98U+LKvIXIWW+4wA0M01Aj70iVO69zygzXat42IMrH5I7RQH/6yRF4W0/s17qhgzgPM8RxsfcQtBIybPq1M0OOMr4JXO0FPajgem4Mt2/D5p3aAHeCM1tpHeTip4sOYhW58F3ol4DXye5cLAmDW+d9vbsnCLNpizQrT3wN/17LdZ+aZ1H7T6BqBTsIw6ikFZ/YWIoCkphInPYdHhBMgfKItoI8ks8dBRaS1T1Y6oICAQA3SWFi2fhlL7nIEdkzgGgzurH9K0MrkIJrhO4RzsvqA3L6nxBaT5C1zDm0wVmmzHuyyni3yc4be8IeMacRZtgQXcgy7+VQ0CKarDkM/sxnTnR47L4nykO9cdv/N59uWiz3Y8tpd6il51CbuKDQZDoONDFsCgA0/ZTzN0BggYmaiL6B1hWTe4Fouwyke56FN2UO7xBQHmGQJcvicCHedR3kCOnt2T4is6RslWAc4zIsHd2y406pNhfXXNsEpbiKMs+iQ/+BtngQxoPvnMc6MBmGX3Tgk9e3G+fOtWd/mKLeXcZRCGfvHCmdP60h8BAtq3WM63F3YfBpn0PrtNd+uSpIP2paPdXieu9HA2zAvOn7SNb/d2Noz2Euw1UMvXhGXoU7r3PHBby4JsdFCaJz+VXkw4G7NY0bZt0RCivsgzQqj41WOSIQnwQWECeHXly5cMVoWIeTrsswem4Ms+O3xSt3kPsFHtOp+N5ksGrANfdSryTjXIs1z4NOjTtixqzb54J1UHB0+Dr5beTfr41Z+2oNYtH/DbgDcHYKz575V9QEzngIzSc1g2RCrjYv2InpLiIThAfq4SRRVy4hoELUiCLXXZCwTWIZXn+KJh9yeqpNkdGJLSoJgwnh3DByzqDWXAQoBwQ2BBBnh4RkjIbOcMQ4A5K9N50WAEM9yrLrcFN4AHTA9/Rsvfm/f7hpOzg55y0im5rtdlnNcmukct6IItDjN6yZBpVRdcTXejCb6wibPyRVfI7NHN2IH00B8+ARYp4QqoyZ0HcHi1x91ZjAu5s2e3fRa+nxBMjb8t6Z2pbLFmBB7VrPZmmpyXkqan8mWaKmS+vkxCAOZdNgPmKwYzYDLNNvM1CHPcgign1psJQ6BT+8LYUgYC//M2Ad1mPfdLt9r5RffLiobcTUuS6Ad7f8Mr+uKgk8+bDcPMMMZom5wNw0u3dfcSZFbVlO49DzBG5O9Pf4caucQYwmCMb8Ax5iAQk9wTG+lqRkv8DZsQgix1jEKbJxEosQx5PyVJU3a/PTAFX/bb45O+jXuANw3rvLXhbeBZvoCww8Zoyxh8L81yGfPH8I3iR67+qCZMRis/DLjkMh2BehfvIZSPzqH0G/6AbJggDTicDlSu0ImqgunGMn3kGYyTZ+AVMEmhsHLqSWjcborKq7xoyCZ43gXNwpuqnJtHV+GW8XzIjXODB94H5SN4EcQgIc59foYB/LtlxvHWHRYFRXTRnUfDCUNEsCRouLDkj9nSIma6kPcUfFbym0e4PCwJWdBHcCbkuZxmLzKabOzwH7wZJxo79PWIyklbdrYsPieQnKDtFcxCczP+1i9oljr79VmKdA+I0B5VqZYEYEyf4Spd4Efpi+SCS7FZceEvku7RAX/hFL6nK9F98unnuo9++unu4Rc9YMvgRHrgDpdv2kwY+5F2sznv/bYPBsuSHrxwcsd9YQ6cEzZgUL4fNiCuirgXliTVyh7yDH/6bTaMfWmIT4vb3wVjwWvXb+/4lcxlqs/LwGU3ds7ymIXNOHZK96IHvHXS94g0HolRRgmjWMfHP1HZTRyb73qIpSxN0lgIJP993KWRrTHRP2psYa6VDI3FyE1pWx6Ygi/b8vykd6Me4A3fqjNY+JwzG7N1tmHhuolNexnQ0rCxxv6emOUy4iymYvPW5vLVW907n/l31fjTMdj+6vQUavFzwIUeIMp6cFI/YLSG0BG2okcQ4b3jAEzRqT1T8yAtRUdDProxuijgwhkDs1GalpwD7qmojeLaZ3ShTiqXkBI2B+kMXwEM4ep/TYv4R2m8Ro5q+SiHvPGABfbD04IVYWflJ2Mk6vrN0fKx3QisQx5dYqSBhsutMor8HHRpOPeIyoUXyIwdTmaDjqhjnEEU+00Iclx2zmdaFxT+dNqov9EFM5W2PMUKKmU5RGKCL9G4eCehPpU59AbB4DygG2DXLFLvPRHct2dMxRDWK7tdHIep7gkD0n5D/1Wenry+lP/vI492Lzh7xjZTPbPRN+B9LZspxb4w6wRhbth3269folXuuhecO6H+cqfNeTdj9fal8HJkPzZdjSVJPETzYH/hrM84YskxM20PamK/l7t1SfQ8n9+0v4e8N8z99jfBeHC3s2H4/PVzl1cfUx4/XlureSZP8LvUA7EXly8rUsikDBvKyMaabZ+hTRvC6MrO9j/OJSdM9OEa+pTxD25DR4xjxD58k3GX+vagVmsKvhzUKzPZtZIH6PBWnerJjAe6O+1B4U/iS+nkqwlM5eYNB29RnrOB1SZmzyyl/IASMbDli0fvfPqv2UO27S+AZ+2/DzfpKLzsARerRCpD6LF770JK1wK7ElfpSHmqQh4dTvQpQcPZcYXHCoEjoxdKCgYYrz9/OGGjKuX+qcrog5cvFaM4YbNXYwmpMAxSBs3Nh2PEq645SemXQ0bp3s22sMvpZvD4CqD5kVPFG5+D7TqZo6kjzxnxJ6XrCY3Bsi54KHP2q2plo1PQxWa7kBzX+AQTMPgaLstxOq9P1QkQfUUop4zL/MqXeqU7yTgUTkRQsq3lgzbkZjox6RB2WSFc7sY4iRtSkbXo2LWPq8vJHGHoUH2mMZz5bNcpiZS0VK6yB7C4pqK3g8oDmso7zBjdr//hh7uvff0j3YPnzwyxB7K8ThCGfo4+kgAB/VZszoubWHox3Jz3QFZ8TaMIhuxnH82LoGeev2EzGWx27anjB/4rSYf9S0dr3hZi4/4fnQ2jrw+tNhuGB2R+6yxjYlw5pXvVA6XfrB2Y+0H9mMEY7ahrtYPyt8uIWQEU7jkbcTiBxlAaVxCwgc+OiI0xSfvSUdF5r7p8y/Wegi9bvgCT+s14gDc33ZXVZTFIOkZnaU3TosTAlSVK7J5PBJk3hvfqLJcxPzGg/3j3892NO1fU1Ju7/Im0tu/mXzoOKxP7GM6IEU6CrbsoEXln9S4jOg4Xa3LK0xZXTbAejwQpoIM+8PaSy1K7xsCWScGBnNVSYgghWFLyFbSE0Ew7m296wkchMsozPOqknSpoKEUeeueh6842U3Yk8KCBxD+l7X7u8+N//ye46R7ikXXkjm2i2z1i1+wVpiBko6zl/ZJ7fV133+ZKa8hWl0xvsoRDbqbxcvBLdrHT6URcZTrM/eJ2ZB1FVtJDhaGLHxnuJ9kinPMXTjulMkz7mtA9phRYsmvEph52REQPn/kX0VbcPLuSIKMVuR2kq7BUEUE6A3DEr/z+h7q/9LpHunOnTgXlgT9HEObsEvvC0M9djYio1Sx/IWm4OW9pXg98/Zc1kFmZ9FH7nXxJ0g1ttn+Qv5J0t3zpaLfXt86GsbaDoNmqs2GO28Bn3X2Vztj4ckr3pgd85ovddOq4SgdVxstqixkwWNsNmiVHmkesM2MaD7Co8xPM6O4wwranGpVhctEa+t0yfkSUMbPlprQFD0zBly04fVK5eQ+wS7w/AM4ZWc9RyYwNBh5MyR5LdZaLdYy8HXnm0vV9fYM2ZtNBhf3hMz9hbby6B8164Hp4hxAWWycRHYpAdq3oDew/wS8e0UlE8Hnk5kr6vix+TcF6LtEWWI36GxHvBNi/gU5r3tdLXJMRjqQx3OoPI6Y8Oj50WFH3Z6lBVut1ypB+vuHdMpV1SGVYTF+j9fq7pAxvtXPahuuV1Utjdh/v11fKdG24ZPiGr2r6X5DRS1DYVvRhm8FBhUy/ime1n8vCoAvqikydoljul5ApskLnLM12c07VrzwElrK8yHNPRl71tYLXO+BUuvG6JI4JX4DO57g44lr5qPgYeOgjP5ac3jE70Y7xbw22k7FDvJXLHTPrlCFtVGoELlCRpT9Dy/t9GUzj519+34e6r/mi13T323KRw5RiX5hFQRhmf/Rn/XkNIwjDC4YLNqPzJbY57/P2coF9MJbx2WHwE3VfdWbspuvVX5J0onuBzbJixtFBWJKEf1Zdtr1p/xwkedz3vdkw9nfx4vuPK2DJ8iz+ZsYSY8mbN9X6jKHnwmijWBo3pXvTA8z91oiXfsp6QPpAjRMs4MK4kTuKz1QQMCFmEuMK7lOoianbn7C31xprGYXO+NNfLqtfRRB0drhb2nZqeBjTFHw5jFdtsnnUAzxw3x7vE0fpAdKJnrPZLJeuNpITx44qIAN8muXS/LIo9ytP/VVr7G/UTgFaRfMZVZQGH5iWHfFwa2A6A35HhaeD8S7Fz2AMbzjPFTGlECI5e1dC53NUHRABF/taK90LEkSRD0DENyfyP8vRuBfhGlWR78Y5uDCmF8+Z3O0RZJ4Gh2eRtQMOSV6pJAtEny94wDRZ0RFnWvceNMHDWRR2Tbms1MU30Z3Dn+yJwJPLQkoOujQdbleyI8lwHMeEt1K1rxfMcPudx+hNjkQZr5+jHOe+zIV8ISB0U3Z22PqDGsOJvODv2OY3lAUTdTuMw5PgRrpjbkz+jkyVAJ27k1BFRWYZcUYzt7biH7FrkVzDCW0HOLlnAQgWdo2cf/0PPtx9zRcfvgAMVclBGPaFYbZLJGseFyaWSjxr+58xq5MgzMsePKP+8eLlmx0zAg5zYkbCQXnY8CVJ17uLl202bVqSxLIoAl77nbhFDopv9rvuy+jTbBj7YiV+4nqx5Jz9fAimDb+UBP65y9eXEdujIfg1pXvXAxq6lI6JL4NGIMbWcdtY2TstoLxkFM5cFYH04OXFppYUBQ1s9jvKAFv/Gb8Zt+W1TGl+b3vvXoh9rPkUfNlHZ0+q9tYDzFK5yVP3Com3GA9e8A1zefMQG+hOs1yWd+K/uPKz3c07N7vjNjrxgAu8RNsJrKilV+Mfbb1mudBjaLzB5EjLGF15tLf4vnciLqXBIUccjOpELMeYhQg/6ZYhfU9DUVZ5QtrBqdwUwdRrBVyCHRwMg7NLLfUZ4BYXjdPYmAI6/ggTlvWlNIsaPAINQByfefFKSxlf4ZZpMpy34iTTYTGLBWlBLz8bOoIuRNBCRz0XYcETcLxM/lj32u7YyJeLpKfeE6ZTjH37mqxWd4dBn2nDrmK7EQVvpVe90EpyeuFSnWByei2SE+VMvUJgkdG/m8wmzEJmkVXJK73EhqKio1csBGucmrI1mDfAkvT71TGZCZY1zMRB59CJJ3BxDkGlLJcHrJyFsgM4NRcjvLKxwN9WAjD3HbIZMFHtCMJQzpvzzpsJGHycIwhDIIb+8AH7OhIPoIc6CFNvwFzT7eb7S5Lsgb481OPnbQRhtuuNg6+dNrzOhrGx4gX728izYa7duNUdt33v1tm4eNrv5eBf/z210AZVjC0IivgscLRZOfopxhBWyONrOrM60imdmo+hC5Px0OzdYcCmZGejq02hD7IKbjrttwem4Mt+e3zSt2ceYMonbyJWScxyoUF72QNnfIA57eWyivtE+8HLP24NOlMfrfuwxl1tunqN8QAMXQGdxlHrHOgMSrdTnssoGbj0F8ilQyJ5p4EOL2k6pikj4BL0wpTepYgAJN5cFlCHeJwuTA1Rc4GpViRBfVxhCaCKueBdZWKvOlqm0Y/TGb4gwnIql2kFrzRIDpmuP3Q5ieNaUMjLGRfXFD/ztiX01jPX0VItFwVRpnjEAi4n7UcK2X52QNDq3hFVszXoG2/ThbDKW+8QCbD7MOyi3JcXuhuvkRh9g7uMPp/Jkz7Hha0hA6j4jQzNjHmCRhzZnqIIXs+6rdWAAi9kYnepoaSAVjihIcvL+VkxQ+pZij2DDA3LZfkwA9yK/PcPpHhz3ERjr3jLz0pztg88+kT3xkceGpdxiKCxL8zx0y2IuKz5z9tSW35szhtBGN74X7MZo/P8tqzs/aSjH9GDy34qXUEXmx3zYwYEX9ypS5Lsqzl7vRyIcdM6AYMVqnfXkd60dbbs+cdYJGbD3GfXjb+JVT/ggHP4YMSU7mEPlO72tu3VwoiA+6iAlCMfs17o69T2WkbL+IvbfH8XkEZtA487mvFieR8wi6mORyxDmzil7XlgCr5sz/eT5g17gE6QLwwskxhwxCwXggZ8GpC3GlNazQM/95l/3zoCGnGfwVKHEOo9dNBsDzbI9WBJ6wt44PeNc0s3QD8hSZw9x5HOhA6JPoRp9EFzUxH9RBdcprZILNLU7yDJk7HAFQWsHFA4yo6hqwJKJvjhdf5EMQMAZxxWj/oSIpGTdR8OgL1iaOzrkyqT21fptFlmww9n32RebCxKLUvQBXtZWuSfiQZX6JNO9ASbnxvNwi8XGXHYGPxVvmkahyU/iKBf1+DJgZfQgfXgnWZg86A+EDlf6LOzYEgJXMhyGLZD7dfY6aM+rjPohny5HPqkpDHkHCQSmGgzfj/yUaE4L9I5j2YMPoQNy9JTHSB/uy8WGVBwSVZkkaSxaQBCjJU/+Znnun9+52PdGz/v8AdgqNZn7Kt8l+x3wZYj8Vslxb4wBGHYnJeNSLUvjPWZQ9etInffaO1CHwY7e0uSbGbFi+4/pcAIwRGCM3uR7uUvHe3WnzzMxmwYlqkze+nFds34e+GazdsbJuul/TljY9cp3bse0H4u1kId4VvTNhahtartFWMTCrRhtgwpPjYBXaMypAbU8NKntfENIm9bIMbDOiBDWNUgnumwvx6Y/uL319+Ttj32wKKN42IvF9br3rLX+KxtJ1hz+qTt8TJtdrbylfm5T/91W250Qw8vLP/hofOobbxzpy5GNZHR0FsWfH3Q8T6C7sYw5fEYPCyCQOudi5ZDi9E2dqUXUk8EXQmxGINBK5+XvBxHQ7dU9DQAObTGkRwS46is2+7Zgi2FuSeXGWgCAvSPs2lAN0vQgxRvVZiXmwy33NGuL+NKXkStg6YIBp+To1Nnm4fQpbMRtTLynd/1FVkq2H4u9qnoo93nQGQ8pKaLkl/CAUwWgG08LZ90S6DXI2T36DQoAZJ4vDhjy9COVk8Ymn3llpOUIY2bbbRmjNtj58gUvT5QKnizjxS+9MFW4w2WOM/ICsQuz1gxNLMvcmeKPv14yWu7QNk8IxJcMqycQOluGdfbI15EYkJDvmqclHzyqee63/mTj3VffpcEYKhazIRh4T0j7gAAQABJREFUc97hvjBz3FTBEYSpm/M+UDbnPcBBGMYE63z6t1Z6CxktSbIXQhftx0ulcxbwYtzCkqRNB2F4EcXLpyntzgMsW2eWGMEYgikEKZkNc9WWIxGonHcPTvu97M7vdwM3S4O8n/SjjaSts7PW2touZuwxLBPG6MrwQdWOl4zgardlGdHYmeG3bTNnZx/LqMzsGsuExrvBf4exDlPw5TBetcnmuR44Zmtuh9N08ywXOsanLva/WHTV3lAw1bezNe5TWs4Df3zpF+yzpZfpIhRR98CKNeg0/FWEtfoUSgCG5t6XGhlMnUFp/kuQJToQztHZRAQ/D1y8w2ldh8TDU37KFdXZGkOXDm4IBeNWI8NTy1VIq1iAJK8HnmFrACweD76EuEYLpCc3SGoNALTgAKUm2+WIP/XU4bEsl7z8CYs5nevIr8ou/I236XQ5pSy6M7any+fZrx90cWlWH2eQbGC1mOoRMjM+dMPQx6d6wmCJAFfIDb5WhiLhhUhlwzUdbYlGX06jiXtTYkIJNiCnnAEnVIHrNJMP3Y3e5WRC4RpBE1RyC1AztAcFkGrZTEoVET6VIYqvmzWGlBvQJkzLDmgo0uaQ4qz71RCP2QyY3/ljC8C89iEnOKTHqFeYH/vCrBOEiX1h6ua8L7TNefXlnoO3OS+BIjazPayJ/V/4Mba5cOZE90B8JckCJsOxzjp1XPTCah159yoPS4cIYtFuXLZx5mX7iAMBGT4hzWwY9k26dPXWzGwY7s8pTR7Q8EP9ko3ICI7YbcGsFUYQzFvhSPL+0MYtRsPYFzrN9M0DYVE6zgMvJkgdAEJhqpIK5XTabw9MwZf99vikb089wNsGBlonbKBy0j4/zduimzbLhTcPrNFtD4DNDAaSNGjrrNVtUu6t3B89/0/U4BNVpyXnAZ5ADA/udAS083kJkjoS8NCCtzw/wUtHoC4GxoJkOVhcG4A8JvvRSkYHvWSko4n0JJlkg6PA06mocYg6ptInCVIFSDqgBnGW0eMMEVo8VUsSjdcgKIbnxhuYmUcII5GMKrMFE+DJ8iuJ1Yi8uxqr/Lqxp4suiPjsUGrufM4TMkIn5yPd/KALioIficFPHvlRjvMsTBUckdF4kdTsoVTKOqtY+dEjXdx4kdc56xkEXowh7FP7YaRwkwcePnaaLMeQSsnWqhcJlqzsMigUWPGLywNOCpyXOPbxDT4vtyq9y0HvHnCOiRzAao0TXLBUlo3ZxCEunDEPHvhy1vUttGoSTDawx5gBc4gDMNQlB7BztTcVhKHvjX1hmLFBv3sQEg+/122PjsOemK37jI1hLl7xryS1JUm39OWdderHfaF7fh3miad6gPEIv+HfGJ8358fnxOfNhjlt49Qp3eMe4O/QXGAnJd+fyscGPkLrhV6MNkYd8QdsZRMQLa7zIMoojeSIzXZxmU4hXdMfvjt7S8cp+LIlx09q98YDp6wje/DCEb1xYIr0p5+9ttQgkC/lsJ8IwYEpLfbATz/+n3Y37thmc0amgEs9+8wJTZMsD5C81IEu9naJ3iW8TIchOdCZ/+lU6BN8GqaAgkEDD2dSyFMZMvvnMv3oVE4f3VTA/Ox0Ia8wV5Lo8CqgZKAPnUNcv1wl1xkpqqut2fV7rOHh61udJfXpMkZ85WFeeSGdPsvr19/x2n/H6NtMF5j7vNlD5FVOwYPhfi5VjxE6r8uMfJzRE/k4ZxhcIcvHB9munB/aBGfi9WLR5TqlrwQ8Ctp1GcJtaYEX+aPCoba7wtTnmUGyE0Y3Kz3IZH2uyeV7nuPC8hDZ2EouFIYPCnhHvhlBewooVs5WdpHWXIech6dXRnoCpKzED8sCzh74u4yU8zE25ZqTCMB84tPPdq940f0OOERH2jO/b+cbHUEYKPIXkuZzNAwPnbzg4Oeb8/qb/is2A4CZpdtMzBi5YmOBuyVpybQFt9qSJPYaOaEHfDZDntL+e4BPmd9ic7Q5ibZkbDYMfzfTzJc5TruXwIyr7B65bR2QdzcsDWKs4Z0TUEYU4LSqn7EyDboTG9THG7iMHFyMw+OjFMArRuuQDF95HTsd99cDU/Blf/09adtjDzCF9qINtObNcpmnntkyLE+6wUYXU5rrgfdf/MXu6q1LCpToK0TWgnsAxjsG3EeDry8fSYrhayNvXQIPvlamgyDYQlInQ8Y6C82aEcy7EH8YKnk6HPggtaOXVFDecpaKTC8YXUkOLlhgDnC8HwuJGGYhgF13IlBWh8w8DpAt9lHzEoyZYWiyRvhrPQZU7kkHNppUt9zDmv+4FviYzYprbYwx89Y8tIguMoJ+GHSRLwtT5bV6tjw6kdXqnHGzdXDFTuM8kc98mmqLeV59OzadAct8yltdAgdbX0Y/8FLGPbo/ofM6wJVkmDDkYWXUj3PTkfJFd9BBVOmqj5GfUiVIsJls8+sMSpbNQleDeO1W41mOOgc7ModqNKz7sCwGo4wLlQUk2hnvJFxmGa2l0YZ42qn3fOjjttnsaXvYPZVZD3zeYr5WjzkVH7E+9oVZNQiDqNgXhiDMhXMnu/vNbwRltrWhPfu5bWJ5zoibtg6aXZJ0UkuU2BtmmToz5pm+dLT7y4gfl53plWfDsJ8Pm1dP6d72AE0z/YuW05aOyEMoNs6l2TaYjyucUKMKY4BeAZugsTN0kmUHgXUIoVLiAtvo4952/pZqPwVftuT4Se3eeeCGTc9dYZwpQxgwslv9JVunO6X5HnjPMz+VgikEErzVp2nnp56iPEgCIAhDZ0CARh2C6AxiTwNwcqFuWKZ0E5IhibqABFg8wQsISIQN4tN60KCDI6nlVPSDo4Rr0AI06AwPAEvl5AUrBUcBFLxBK6LPUcFF1m06xPBPCLFzpkvgkp3V2zcMmcHl+r3oeYJhJGgIjnl4cZauioh6VoDrZxNdfoAdZTIsU8kEd7noI1W6mhdYB79mXq50VV7fvp6O5L+AD2UFPO4slY0v4KIvBT+1wEvI0j2H3Uagn0xNMrId5KHz6uiofAFkOEgv5zoGY8gfwwXNumeXuQ43vmAQqCoPKxMCAx7ngA/PY/gxWOabhx+Bz9RyhCaL7uUT7Tw5b/u9D3Vf96WvtQ01Ty71gNuTv6UCge5lHsaH5m0iCMO+FyxJemnZnHe/gzBq/tJ1HdbxbiivuyRp+tLRZq4+QZTnLl9fSRh9CoGYKU0ewAPcD9rrxTpZjQJKm8XeLnS83h/REUPs4wQfCwtg/H4WZeGFlvGMv+SARyXXNbl9qx6Ygi9bdf+kfC88wJuuVTs13v48eMHmJdBYRcO1F8YdYpk/8vHvlG/47DDNfPxK824BFmvabUqjLS/1xt0cyaAfODysbOYNLIdbzJ00P7skHG7S8L1y0UV4maPeCDiVZIpC1yk6FJBYFDwt51ChJN9zHMHQGWUe4JYk2ykcMDgak2sGnjWMlV2cU0XAKstr/EVtQjZcAlb73IqMMatMCFz4HpcwOxVYG+ZheUvugdkyNEe6090JfbnoIRGIT518MsEw82TAFLqwRTNIJMkPgYvBhEOzfS0/pjvrDVlxDt8EX8DFUwp+aoEXePAdcPxGGg+WQdXq1vJur1jLAEmEJtXFOV+jR0jiKYii2lllUdHVRxT8/NOK5H1BZqrGfQatbaIJ1HWEclfC+6oWlubpqXC/YtWzFb6EjZl2oREgjZj/9vvF3/lg9w1f8QW2p9hp9TVspnmQ03G7aCytXTdFEOacfSGJz1SzRHfZRF/8rPa9uKlP8X6Wbc57yWbCMGtj2dkCy+oao+Mvmv7iXkirLklixsb0paPd3Rn8KRy3pW3rzCDC/1OaPMC4g87FxzN5rGCwMt7CS6JSU0aOPsfOtOtGEzPJoROLBjDe+vHSz742bcnGOsCt7C8vgfXTrVu3useffLp72Use7I7Z10untDcemIIve+PXSeoWPXDKPh29zgwWZmkwS2A3g9QtVntPVf/Bs7/U3bht+7yYf9hvxb9a5I24uoASnad9B09/EIEXOghjU1fBMwrdBjNf8pAYGONjLWUShYpAVZJcJ5F8oOIBT0cCM/ww1OQleD2VR/UeUXR0A5rKEfB2FjvqenIavuX6BNhBECnsyYGDxhO5Pm9lKuhxXuPhv/WXeIf7mWXomdZ1N9lcJzHZsdolMR50OdY9VBDOEzRwzcgCWK5AphPY4OhyfUlk8keft/kJ/hiAZLlRr4DFWfTZjqRDNIXQTynwwk1qwAi6zOoNm5yuiJFtsGI/MMEX6Ay85HOoKcmvsLFMoQsDxkiGsFVorS5Up8RHS4VUQUnVNTR5xV0FP1S4c9nfxg3okDsA5aLsAjCoT5U1gGde5XfC9xiMeAH9z73rA92/8Rdep43d+dIJD18HNQjDtbq9gQ1wL9281fFbJwjD/hbP2hcF+UISM2FefP9pfYZ3zzfnXXRD9a733VVYZknS9KWj3V/zWGa9jiQ2g57S5AF1NPQ19tPsF1xCR2ttl/d53ohpnFtwjPEYA2kLF0OrX3ZiBVru6E2nyeDT0jHwoqM0Gji1dwyyUvqpn3tn94N//0e6G9dvdCdPnej+9nd/R/dNX/uViaKf/cpv+uvds89d6gH/5n/8b3bf8W1f34NNhVkPTMGXWZ9MkD32wI/+zK91v/SO3+kee/zT3Wte9YruB7/n3+seuP/CxrSye/w6HSLTssc+Vb0xww6poPc9+8vd7z710wpy0Igrwm6NOIEEf3T1jkFfMrI6xuwGh5YgQOkZeAigc1Ef4E+s1hGoK6BP8AdZ9UDe6RjEoC7Jc3Q/Ibk4FJsC5qiC8FMDxUMrkkKq07RjoRGgaGoCCrRQW/1z6pcyxmsBhKATQZH5aVZKn3ocjyu55/HObbPLAwi5LkZggqLmITPOzRsWdLnziC0veli0Dd8sDv8HJGRSHtKLNoBuglF5HZobSjkEGj5YnKaPz/or3QLeHk25Zg4rdy92GbwGGyTLyoXRT0ObXGHYEjrCjCjrjOxAlHMtW6bmwaVy6B+w9oriLQL85L7qEQ0LPfqGFCcHw/d0F1ij9JxojFZ/xvBkgijEOeOG+TGaEVjUjLYj0IKpUIzMtgZR6BuWAx5nKrQTDbSJ5rf/6KPdl33+Q9o0kwDM6ZMn7Gt7tw7c13XUZkc9N3DebRAmb8774IVT2mttrzbn1S2RrtkGqn+oRMSSpGee7yzodbzjK0kECa9csx77HvbLpi4iy+qGXzlaRjbtJrxTmjygMZHdD/73yB+ljRmszMiB8RwD5pj97bj4wwUOuY+i5ckyDqSjUpcmObz8NBqj9WVMsBgipSc/80z3/f/DD3ff9ze+vfuWv/zV3Y/9v2/rvu/v/qPuq9/4xXOfz5BPsOWr3/i6KumFD95X81Nmvgem4Mt830yYPfDA3/pv/mH3R3/8Z903f/1XdQ+84Hz33/+DH+9+7J+8rfuPvv2bNqqN2XK3V9z4n93oz/JZyi1/nWGjjtiAsPc89bOl4bYZL9aAk2xChToGjjTotOP8bPatHvzJMyBRQAYc/3QueesYrKgUs10o8wOj2TO17BnHOY1BjI58OwLzjohcS7OPvqG5yWrUGVY4UaHUbA5IPleyDKx518myLEzOtDnv5M2+YKf/HSaBzKn4lU6Q5ePVwt4Df/NAX5cLBXaie60FXB6pKoIuztkrEGV4yzu7ysngwHMPRN4ph+VkPzqKjOCpdUv6A4e8wAumQ5PvsFZffafLikA0uDEC0YScUvBTlpNliFh8UTfRp7ozgurJNZaYMhWyBZIl5Fw+OU9WDgEB6p0TfaHrkfcKPcZegXsIPdxH+hvqYRcXxGMkcR8upt4lttSn1rpXP3xVAD246RyWMWMAkw+G4AENbKTQ/0n7+tG7P/Cx7ku/4CF97vfo0dsdQZjzxy0IYzNEDsonjnVt3PSNHiMIg9Ddbs57X9mcl5kx9MWbSDzcHpRrsIn67FZGzIYhCMPsI+6LM3aevpK0vmdPHF/va1rMOprS5AF5QP2Mj2AY92imSnRI1lHFuNbJoLNxhY33fJaMlXjbZs88MWaKHkp3WOkTY5ytMYkJ5F9Ov/7P3tvdf9+57lu/8c0C/1vf/Nbuf/o/frp7+2/9noIxmTbnWZ706le+PIOm/BIemIIvSzhpItmcB65cvdb98N/7Hgu8+EyX973/T7t//t73bzz4wr4vN23t4iqJT2JeOGs7z9vU6Cm5B977zK90127f8KCLteSxs7qCMJStYWcMwawLzbyw8q3oLNRFeDeg2S4mMh7s4Kdj4Fe6EnUF3kEABxNn73zoKpzezo52HlH6wTsn6FrHgvyccik/JwdNwzcZjnNMwwfH7DnT9KVYl2fGxzNicPZpAprOImhSffYRnS1Brv5zpMty2r7c7BXHs4HuiRJ06dOie0zGfLj8XIT0ZWW9zp/xw+vjvunrzjTBW8/lIuokYF+fQEFDrWz2ETD0hM2iAUadS8FPTVbgKm29eZxGcINVPFUtKewPXINHztUGfuX7o4nxXAgawmvZ/cvfkfywI31lHM2IvciQTKiWkZlpLO9WJRUhM4FqNvMCHJaDcACPNijQ9Qyd/WZsqAQlM5D3WArAEHDmQfbIkVvdSdsf5fzpgxOEWeVrR8MqL1OOfWF2E4QhWHLutO0rY5vzbiIIwwPu9DJl9uoRhGHftfPW+p+ymcIPnF/tK0mzEu9dCIGsJ5+9trIDGKNOafJAeECBEzof+mQ7eDfjI2HlraNWyQoKnGgcaRDxGD1E9qv9r4rO4zjLRxTHXgIO+7lPPflU9zkvf0mYo9mcn/PyF3ePP/FUhY1l/q+f+uXuV3/jPd0rPuvFCtx89steNEY2wQYemIIvA4dMxb31wA99/3fOKHjq6YszsN0C2Mjssg2CV0kMnGmQjtqAbZ1ppKvoOiy0/+zTP+MNvjXaTHuUfyzvgXYrE3mhbAEABV3kP/chvQEc8IgXGZBb+ZazeVkdBnTWpRQdEZWPzgIeksuDzssOKYUiGwyQ4AnKOFdWAFbo04VmkG47uZzE32fKaOXnofEblfavRAXbPGrH+13pdsp/dqD+PrMImvn8wQtVeytiM12O8OUin+mi+kBQ5LSygOUQg4EMcz/HTA4wmTfrdlxfxgxezF6XkOPnMZjbEXUSXeEP3tBZjcJ5VkddA8tJvxEHfZSdj2OzN3A9WsmArqWGN1gKxEAhXIFFvsKVmX8dQUcKHVFe+YyaIqT9Ha0sZS5DyJS7UZUMTqrn8odtMwRJzgxNxQ00VHi5u1N5RoYMzgTFghHQ0LYcgAFHna9p+dEBCcIsd2sNq7VWeTdBGDbnfeb527bR483u/Jnj+kISwax1N+edZnXMv4R86Qi/4t/hkiTGTtNsmPm+CwxNBi9C1hkvTpvthhenM2OS6C+PlJdpXmasba8qBbTxSGnHteDfgqfcez4GQgB+pKwpMdYJAbDxbIGDZ3QrqI3Fmcee03MXL3Wn7At+OZ20ZbQXL13JoF7+G976xu6+C+e6Gzdudr/8jt/tfvJn39H91P/+/d1LX/xgj24qzHpgCr7M+mSC7KMH3v2+D3b/wb/zjRvXyNuIZ55ffQYLm+3yJYf+w/HGzTsUAv/hn36PNfy+r4vWi1qD7RvtWlDC8qQIAFCmUWdGC20/BXUoEFkS3mRBo1/pbJQvvBHqAAaVSVLHorODBHOciCTLNRvUrp1bVbnJ9NKgKBw8Dm+5YAp5Ua7nhJgns9KmDLWiy/MH0saZxCVqy0JiP/mG+5I64l9LUW8vcWzycETGI/9Id6oEXR5qLAYd0515E3GjFZPrG/L3eZt8qJ222el+QMOsrCwndNSzjyiaPYN6iA4axGqAgvJmi2QbUZWHCaXgp0Q70NXnbXQxMhL/UJfkJ9qmznJ9eNgh401YMQsJlorvZuAJJ7otH4p9xf0yRte6VKY0H81Ig5ea9WCtkHJFRoXMKY/pEM+QvgoqmZ3wc+gfe/LZ7uLDV/UFpCChzgchCKP2Y9V6RSXWPEcQhs15mQ3DzMhlE/uvsTkve8PsZnNeZr6s+uXDZW087HTDLx3lJUnMhrlw5oQFYPgq1a21PlN+2P2zjP18DeYWb55WTPwpMEad0uQBPKCmUe0zYwHL0Hlp3OHj4Dq2AGX3DrMYYxziIwQv08ICJ1aDDOWhFZ/J1u68aLQ06CAJoly/0X9munbtRnff+bNOP3L83u/69gr9D//KN3Vv/dbv7t7+2+/rvu2b3lLhU2bcA9Nf/7hfJug+eODDH/lE96cf/WT3Vbah016kdXbyZ4oyg5IbB/zToXvhr6HM528+7w9E1toTMKBhp+EnqBJT2B1meINBwLIkIvGUGZNADw1HNvqivXeeclZZjwaFzuDqFNRtFM7ogErHYl0K6kjI984Hea5JcA5ARBjUQSlkofC8JLqwhrRck9gD9wohfWla00NnmJMXBxKMjolF4KD3W3JAIyF9WBbtXjxpQZdHbIL5w+qMMz5scFhfDjjBK0PDV1ARgJ6cZstgC40xN36HtXLg+vAefhAMQW7gdTY8lzIv78r2KG+EQx4sdFiSN9AVvNCGXniY2RXywEQ+9Ea54gZyYQiaOEO7OFFJpxjncR9mGaIbJ85km8mbntDH9dAPyYv0j+Bma5HMG9Jb2dsBZZquoItzEtGzR9dljCgxLEC/7d0f6t7ypY/0AjBw8ve77SDMArNT5TafjX1h1g3CsPyIH1+Gic152RNmmU/7HrcGdNjWbr6Gh1PivPGRB2Fs/zbbwI0AzEsfOKEZMhcv21IlOv8pVQ/wiel1PpfO7OopTR6oHtCfFWMIMnZvlHJAvFez0QS3jeFEVUnp8eyfeHTwztaogOtoSMbsPrYusEHD+JIXPdB97NEnqkm8WP34Y090wJdJ58+d6c6dPd1dubL6Erxl5N9tNP15R3db7ab6HGgP/MAP/ePuO//at9SdtP/gA3/aXb12fWM20zGumq5ev6UNE1flu9vo/8GH/5Y11viv/SizF/FNa5RvWQRdX9Whcbf2XvnBmUbf4X6+c5sv/fRhtjuCrT0HxrIlk8PPyndsqiXTLdHJrJv+z3AWDmryoUuyE73L7PPDF78m12Ugx3/YgF3zf+DzT7RJd5NNvZoNsjuVwTEFNGwiz74k+P4mfjFf46OG93yTWfw2I9O+XHTki7ozR/6SLTF6pfjt4J23nbluYb9f54C1c7x9cd0Gd3Y7Rt5tEUCwUu7p8XvI9Tkf+oYyo36OC7p2xhbZW3SjM2R4Hk77ZyMU7icfW8zaRyUwL3i8jgGDvuBMX6WxDLoCmfWGvZW28AHPsJCregjDIfQ5bQUnXRVW5VZIyxThVUfBaLBGfohonAU31J8J1swnkXHtkSSbEm4p6WP2D2AMPl1sQQR+eA6FwAMXsCEgaPK50ro+dNaf0b39dz/UXbw8PgDFDwRhLtkbRe5T9hg7ZUGFep2S7E1m91r+MrYShPmkDcyfsc+YLv7i27i0K9Y3P/HMVRsj3Orut815X2r7wpw9vcP7w1Xvs3HVdx2U+8Hbx/lVi68kPfaZK/ZG/I6+kvTC+05qg975XPcWhllZ62wOzezqKU0eCA/4eMI6B+vjNSKwLHeInSwFzDCMAWIcYPcQeJ/xTXDFaaEniKOiCyh0yGOcacmIJYt8SV/zr/y57tlnn+9+4p++vbtl+2X+6P/za3oee/NXfoko/vCDH+m++a9+b/feP/yQyjyv/eOf+KWOvWKuWZv+j3705zu+mPTGP/cFIXI6L/DADj3XAs4JNXlgFx748Ece7d7z+39iwZd/vfu/7dPT/+sP/0z3wgfv7/6e7Qnzqoc+axeSGyvrvZd5O9Y4GBjftrdrPhjeaXCS+e62/GWb9eLTxHmQZd2pHj31wEBYIG+8S8AklhV5006wgPbdOgr+W56OxH8c6QSKPAoGIrggvBE7HYjCgyxBvaxP5QnisoLOsXakYxE3EO+IVCzkjasQ6RQaAjZOBTYwoSM4dC7AoHFcv+TBpcYVmhmP+RreOwq6QBG4Rt2X1bfBcSdtLxd+SoVgjK4HqwWXUYtFcb88ZkOBGWGjTbIMSN1IDR/5Jm8W5wbEQKHhfeDhWI5caYPp2kMFfiC3DFpChs49WJM51CdZhZF8X4bXI+T1cJhmOmZggMGRLBN5M7+XBkWnGwJ7HC4PVxOACsE7sQxF7EWZqxH105UplwdYyTa1xeAZeKPo5WhjPJVMLffBQRV+cfmJx7LL6pSsoZ6i4O2/+yfdm7/s8yy4cqqqzBnqHDNhfJPZE5ptedP2PNmL2QXr7EmR7d1kPmbCIHOdzXkJwvBjw9KzO2zO22v/N1mJe0xWXpJ0elqSpKtPG8vyrKcurv7CkPt2SpMHmgdsVGF9AiNXAiS8TlPXMhg7VBqDq5+ym7AMYVyUdSyMT7T83yDCqdMtdCYUPo1nWqcp3pe86AXd937XX+n+67//I90P/I//Z3fClor+l//Zd3QPlo+jXLl2rfuQrVa4dPmq6Hkm+N9+5Ge7v/O//KjKZ8+c6r7XPlP9BY88rPJ0WOwBe07RlVlMNWEnD2zYA9/1X/zP3a+8892S+nVv/vLu69/yZd3XvunLNqqFQeynnvaGYhXBvFH7tO1evxeD4FXs2G9aBrMXzh7v/va7/0Z3/RZ+o/m3Ztpaa/2U966BYIvmZtiZxvwo55KHNiYd0fiDF448BZVDZjmLqMHoiRykLkh58ckmo5OUdtDjrYDOF5ig87PLChznwDdYoplFjtA3zmFuhF0kww2dCUrgF1piPTAPBans0pJ1icpxJ21p0cnuNQmesy0AkKHk+x5zbF9PvyYNV+AFMITnMvmoY4a7ftc5zHOps23Bl2HOaXUTbcgpb3dKMQIpWb5klVGLy23+CfqevlII3RQFMhmNDqCXM12DNbzbUq5pliFhza8h25UUXQZ0uNEVAu/FrQyrRUMBRz0oRF7kOjRZLqPptD89T/lseVFkGFQBJ08UFipoAl7yBeM4CsAtFa1eFr/DR/GgCp+oQkaFlUwtJ/oMM3CtIwIHOMkeOyxLF7xG/41vXn5JLUEYHubYQ4Llr5vqfwii8yLi0oY+3xzV2+R5nSBM6Gf5DJvznrYZROxPQqCAWRukl7/wTMfMjSn1PXDqpH1V6tQJCxyMz9DqU8+WmFXMkiTdV+bv5+/BJUncdy+6/9TaY0z4pzR5AA984Y//gA0TvO/UXeFZ7bEYG+gyXGE5v14tQmvJ91dktNHGIeSQ5S8hGVuKw8pOA6fGJwb/wLd+n+Tkw02bofjYpz7dvfylL+qO235dixJB/Sefeqa7ZisW+MrRsWOL6RfJutdw08yXe+2KH5D6/tvf8lZNT/t6C7zEZ6c3bRqdG79VB7E0KOvwbdr+/ZLHHjcXbPBKEOCdn/zV7vKNa3ooon2nUW9PJ97g+6wXz3OkcecBk5PzALTm3ZA89AnGGTBPOpYRrXhT3sokIy0dhXcq0g/McNkeyiTOJrWQ5U4IWWCELbwQeqp8AdDZNSjrbAnrnVgC1GzYUgGWEfsIonaC5hjQBFzmhcCbCbOCAncqBV3UqWYjRvJjNCGrkTd9PRwXp6QeXLDmeyfpl1tgyWVk/pzHcdnGhkvyEGG2hN+cBvzAvmJvk1FkF0Djc4t7QQoHwaAUsikKhP6g4Twoj9IU+uCLs8C5kPNCDnRRz0TjM6YMVGHND0XlHpx0EXYlN+xFkrcXlil1qDWodUqqhjTBlGkTTYAlMwrBk8T2spWuB51fGKF/z/s/1v3LX/jQfJ6EYWNYfsePWRDGAgm8F9tEEIYVjKv2gcmsfcnG5rzrBGGoW2zOSxDmJfef7q7a0i6Wgxz0eu+Lc0eU8KWjK9dvjmCWA7HPydPPX7efbxxLEIK/5YtXbtwzX0kavkRZznP2YqqMS5eln+jufg/oVaa1Y/SBJPWLdtDwxYAqF3gEaaBzevA2loRXPNbgm6w71vBr1AAOQbYLr484S0eVX3YgrCQCLg999kujuPDM38BLl9wTZqGgexA5BV/uwYt+EKr85W/4go7fXicah1UHYExpZi3vdRsI382JgSp7DjDgv3j5hpZc/dxHflbBABpp2nIab+WtUadxJ8+MF56QtHG6NeqUmSSpGRyWV7zDkPieqD1NvfOCc7kGcnjCAXCdcTZ+gjhADRehjypBOKf1I7QtKS+ZDsUOkkp2CHkO5egUTt2gLTeLCUjIbrQlJ/0Jagx0gTiEaZu1UxVJkRZCq4gBwOBHbPtcD7o8nIR7dtaWWf5FND0cnXZJPXgAzZJZeB/W8C4rynGWKCt4uU8TauqVFdrklz/NJgOdyVYhZmVFcAW5oS9kBH+URVPqHzDOyhs8YC6rlUMO8EizPIU+ycny4BuWJWsA5O+Keyjuo9C31HkgaymevSAqdlCHcnnH61Po4irPmJ8BA9rgaU4tBJmHug3L8+q7JN1jTzxrMi0A8y8tF4BB3U3bWZsfQRhmc9BOsBx23aVDtMvr8s6r/l7BIwhz3h4ALqz5hSQCMczIYF8Y0rqbou5VHQ+C3OGXjnZj0726JOm0zR5irLhqIvgypckDPQ8woFFnXqCW5y6hm5m9WwxifYK/cCHIAmsZSxYmHxeUES4Fk3SE/QzTeFovTYu66bT/HpiCL/vv80njPnqALySs+qlJpi6/2N7kdDaIu9tSLC06adPbL9kXJD7z3DW9XaWev/3k27prt66rD/B606pbrvegYUEXAwLWzxpzWv9aBm6FeJAaPuyWfkA04jH2ypv46BiAh2yyUALz2SxWqg+u8bhrWP13g8UvPtfhEoyfDAYWeRQ9OYdzB6x/rjJLZj5tw4jUDtpDx8DaDwcr6DWV4hy2hc4GbxCCLq/pTh55WKCmhaLT92HBOXZuAQNhK+NiOeHtocQhvIob2NXgJsEKXh7XGTLrQCPFQ5uc4TIjLOvXTbTF342v0UiPIRrO8j16pw05PTrUVUCqR70/wQ90FZ7KRlnJ+aOkc7GjwfzvgDK3sWQYm27pRrR6btaY1WUswxF64px4BLIDXoh2JKF7WXkqGAJTZPa8WGDtGhVAwAe8UeydB7Q9+ZnQ6Jy0MTz2xDOiWCUAA0MOwtCPrRuEOW6OhPcwpedt6ju/dYIw1POK9eEnLHjFF3v4QhL115KkA7z0aj+vz17M7I2vJGlJkr3Uean9WOrG58JXfQG2n75YVxefin7Slqevmgh8TWnyQM8D6uxsjEDHoraawIkVLE9R4x+DqBUX3miFYCkSYwuovZ1XCULJchl0pmKTeMszvrZgzJS254Ep+LI930+a98EDp9bo6HhLSLu17rTSfajWyiry0iKmsj/13BVvyJOktz/+SzZIpc22WSsKqoBUC07rXzqFUhbcmYezXmj8Ifcv9LgExMGZk/oHAwYOPD/vN8wKEAWmjDoYy1lnE3SOR6Mlo4fFrx6yXBIoGGSXCu2AnJ1SpnGLjKNm+tyNtuTsFK7TRCrKxkINEDFHTBXqeKhtTwOWF40GXSr5wkz4RUQ9xW5rD5QkhQ0JlEQ4b+D6Msp1CSRnyHuzVmZ1Zzsj6NLe3GeZ/Svqg4sReTJqCG9yhO4bbgOVTO+0TuLwqJLzDmSB1IDIqbLoyA9lxcBIHIYMOpfQynEv9eghGjIE4064TGf5fu0GyNEiHIuUjzIJGLrmcVNHNQFG2KvvGEOBhcyqdYwW5AAefICVH+CrvMj08L1CULSzoR/71DPdy19yf/dZL76/wZfMbSIIc1gffncThCHwwoM/L1+YCcNs1gtnTuuz1et8oWbJy3XgyaIN2StDtSTJNqF92hTwNaq7cUkSPqRvav3S8t4kkDqlyQM9DzDesH6CnkSjWzo8dYDcaKW7YtxU8hpxQGwAxuwMMgnGaLxkNAg64oN5jWVEDy9jZ3DwQTelrXlgCr5szfWT4v3wAJsYrjPYoN1ipkLZc3w/TN0THVpaZBvjaWmRrcee9/Wn3/rU27trN9usF5/d4o/BNNQ03jTsbOKlpUMEOsxix3HmB42daeCtTERe/YU6Ba+e80LjPIrYi8fLMMIbHQR5IxXQraDgusl5KuWiF5jzuTB1PCYkuFQORUVC0SK+CqpyMmQsLwuFQC9JvrIC/Sef5o5EvSgNA3tO4fYGLefTNsuFX07IHE+hfRzbh7oX+jAvVVsGyKa26WmwIHZchue8ByUC0rchro8klT/aNrjt03KFM737pK9bWuyeIIVG5xOowA1fkEEzP/DigiodEkx+lL2hqeKK/AFN3GGZT5Qc3NZaTBncgSLqWfUlfM0WZKbJfnLm+XqQU1xfRS5SGHaN0WDDYk1Nxbyc6mEHySk+mEfbsyE7YMige6IRqK0x2UCkp6Gcc1iu8kYQBpKMStMy7/mDj3Zv/orXdufnfAGpUY7nhkEYtF+3vU142F2UaGu61VdHLBK577gIwqB42X1hmOUZQSdmwvBjxsd521SeTfWZCfO8Lbdd7L19r+pdpZAgFz9eghGIYZPeK7ZBL76Pa3MYK3zsKPdWmoa5ZCVoLxmTTmnyQPZAmdOisTMdSO2zaZysg9LYVx2zc6kLKx2NlhxBoc7YyOPllpVFwgEGfobUZrxoWP32zSZP+V16YAq+7NKBE/vB9wADrp0GqMNa3LA19wwYGPAetqSlRbafi5YW2cDnM/ZFA2a7LEq/+Og/9YZaxxiOqtX2p4n6wEIDbvhaRqo/gNLU65G4kNw0sgKxM2zWxYAjH2fJobMpcDsrD74AoQcYj7kuE6DLaZjaZTkOJvFJQoEZSJ2U0SK/JqfpgYy5cVbClqlIz+hoB87EW9qH5LDYU5PvgakZYYXAgy6vFroFW0JK4xrmmnwwO9ND1Xj69A3eZPVhwElxZbwUx0prmcjj+qFXHVd0i8DukxqwGsrWHRYqXK4E9OkESveWMwxoZvBcM7cjbPJzUWe4KIf8KIevZ+HV1FrvxuO4dn2tPEDGvS4awy30XVUlJ9dSZAaiA9w7i6YQlkvRw0fBr6PZY82K392z0ssVDZa552XoqD90orVD+GPGYfO0hHlxDlmpLNYox3mePOC6V5YhbELe/q4/3lUABkk5CMPXkU6e6BRcn7u8Fn81Ew59LvaF2SkIwz06TDzwP/v8je75ozcVhPks+xoSQRk2il11jDCUfVjKzIKd9xJmr+qAvms3rmv/nfMWgHnpA4d7SdK6+wixj9OUJg8MPRD9PHDNYGFMRftFw13GJN772QhA/R8IuKyg8XghU8dYpJXxil5wIg9hRZaPgU3ElLbmgSn4sjXXT4r3ywO8abh5a7VXf7ytOWdvai6t/qXq/arWjB4tLTKbj1iwiQHlU/Y1ArXFM5R9wH/7+9/vy42sVdfMFjXp/phHM64dNdQRRG9Ag28yyojeG3eXCRcofuD9Ic1lsfd6wL3rcDrR20GwIlOwIof+gnJBIdnlcBbQMUhXrtLDBW3jFMScUmlF0eSVYgFkzsB4XVQqYqkjL5dJ+Lu9iA79yfZCh93aeNfZ6vHMkVd3Z9JMl2Z5JRlkisABdFgcl9PnnaUZqz+SDT4kNlEVVDMJZlzuOXQ6gR/DBocvG3TBCrfB+ZPKUXi6aq49BiEIKmle4EWyy0AG0tly1AFkyw/pxniLKwzV+KDjngJHHSUHYKQhoFfuy5lldiE9lpA7OKNb0uxQr3cRHxseD1j2ppiMDTvkH9OmcsHXmif6qD84gS3jbYZlQtjQ6syfcfPgmWaYH+F5+29bAObPrz8DJlREEIaZLbwoOHXihGbCDDeKl19G7Ag5h/W8UxBGbfycaxxBGAIxzA5lX5iYHXq3B2HO7PJLR7u5X/DtMzYueYavJOUlSTYDaZ3Na3djy254WcK2zqfbCdpMafLAjAc0buAjFtZqWVtNcx39lF6bWsGDMt5t+QjWV3D7Jy9ginvLX+z5t46cUs0/aGXiHPQz1kyAffDAFHzZBydPKrbrAQamBCNWSbypefDCsRJlXoVzf2mZ1cN6dqbzxuBx1bdaz127aPWMlrmcaci99VeQQEEZQKVz4LG85oPFqk6WpDbeeg3sIzjDGNh3WkeGi4Y25+GLMnmZoIzBOceRjkjlgHghdIP0vFMxCC//C98w9BL0yCmSQ0HRE6fMia0sTYOUpUUxzq92wGSFnigrgGe9baM/3p05+mpbXvQwHH16QXoSBRmnq6iRzKyMnl3i8LqMMJutO/AnYSkrUcPAh+NDHmd8F1xDGygHrVtWSQ0eXGCUL3Y2+IBGCJfXaLgWGdZ4QmbQzpaTbYUoaN3aYnPUYYDsFVOh1bFISbgsN/I7oINs5bPk2kF/l8Y9P+iCHzZsRRInL6dy2IFdSglXIDIn0MB6Mob0lONXBRRYLs/kkVqEDWXO0DYAAZh/7a2va4Bd5FiaR/929OjtjlmP509bEMY2q81BmNZi7kLRAWWNIMz547asRV9IKobmi7/AdvaF4Uc/qs15zZ/anNeWx9yNifEQXzfcdppZkmQb9B6GJUm0Ocw4e8r2tVk1cY9NafLA0APa3sD6D8bZ9CfMTCHHUc1Yb4apjULL2NzpjUODZWi9P/KjRHnHp/ENvUChkHAOU9qWB6bgy7Y8P+ndNw+wKz2fn5x5oNnBAr6QwMP1rVUZd5C7CfQ6S4vG9P7g7/1XyS/WZNOol4a6tNqFzTuD/iwYUKVBh9WLpdOIqLzx1TYeGd6ZMIBBFTzkYVKecvrBCr6KgL88KBc2UTuNUzlcnJIlqB2AI8nxdvT/BaqTHZyKkudcZmB1NoSCLlYxNtF1iiFf4RiyVzJ8YevgLehypgRd0Dgk7+ldWFiPd2i7VBhwDD5m2xgMGe7lZnDQedcPHEfY3VBujiG9+6I6S4LyfQQgZCqvgtM3ePOJYOW+afgiowdvOoMn6GfLA9p0/Ya0zd5kUwg2vpCkt1wQk4pdXsDWoHKIsydYlRccGzqbivB9/Vv0CpqCpL+XN9Qy9ixDM7ca3D+uR5P5k50zLKN6sN0Q4HI1gnmUx5Fl7BuUOi8g79FJlRG/9w8/1r3hix7q4XZTIAhz1T59e+TILQvCHKtBGAXWlzVuNwZsmff5mxZEsV8EYXR1V6g3ASx+dXPes7Y572X2J7m7gjC8EDlI+63kJUm8RIolSVyLHEDc8u1V1WsvwGgQK3TnDG3naQvaTGnywIwHrK9Xv6COxXoza7fUfomwjFmdQAGaeFkU4/Uj7OXC14uMX7emOurCxziidliMwJHdxiEztkyAffHAFHzZFzdPSrbtgXWCKAxmD9pAJX+1iLd1yy4tmuf/Z689p4aYppi2vW6ma4337BIkXyojuqAXt0tXox7tfOkEjhrQ3KjkfBzb846XTK/4sMH+kTea6C+U56BExgUWsQ71HqdSIEH9T6F1LjjQUJIVa16YLDG0GIX/N3lB7UGXPncIDb5WDi5BpPNYd+aOzXQ5+rBE9LU2vgqvmZ6kRjiSE8so+QjQiKuK5JEGawrGYGAd3pfdp3VcjFlb0AXuxlfuQoCeTEiTU2QELkhE0B9MuJwiouApNVmWT8ENhzcZKhs+6If4olqnoI1qRLnxlvoZIGDBH3dj+CXgc89DAb3ymH+ab+fKnIPQ309PPj5zYv/bsvwAP0fUzuCQE+dFHJmm5Ktd8FmVKdeaZ/osN5iAQZPpUl5yarlmsiTlq74hZg7LY4/7J6g3GYBBNdW6ZhvxMvuFIAzXiqW3B/FBduiqTZQJwFy5bUGo5+zv13xhsYaVUgRh6Psv2Oa8FywIw0yYgzBbZKWKjBDjinzbj5BsDcSSpKdtSdLTZUnSAxdOylb8fpCWJA03y1/WYYxBpzR5YNwDBEW4P/QXWkjKGDbGKeUPFzqodT9pjELAxfcSiq6GsTP5GAf5C0uj4x7kDU9WU7RNp/31wBR82V9/T9q25AHW2q76tocOn7W92x60Mgjc7dKiMbf/57/zfWkgVlpjnSJvZ2/By5NMNO3eqNPc0y/Q0MNRuEreOw7a+ZgSSd8RdOoc4C18dlJHEWXOILPsAmodCsiRFFCfkilJ0oNAf2h0CjBB27T3BUIvCZZhJhQM0aH1KVvJNWbJhjPgOZvlcu7I53rBjqJoZE3AnNzypG5BqlzODqQX2rBngJ2ns8Hn8Te4i+RByDxn4OJGAzca92kqNwViH/pc6ErTgiQQZ1p0hZ4gd17XFTBoIu/4cn1gjxQEVg4dTuu8SMxl2ILFz61+IMIX0JGC1gtD+wQdPfT4oJgBZLZkQwU3GLmwy31XiXoZqbADtIv19dhmC2vzt0rmZiBszvXoKa1sNeP2GwM8SgnVykNgoR2eliQLNgVgjOcNX7y5GTAhG18QhCFgT+B4bDlS0N5tZ+7LJy9d01Jc6rbT5rxj9We88IztCXPMNuclCPNy25xXQRjbnPdW29hrjPXgwupNfnBNxLKxJUnMQCIwtuo4btM1PX3SlrHb2HDVxDhuSpMHxjzASxjvuwiklHGq3S7sgae9W8gXuI8d/F4SjzV2dDuCsJ7dBubaCN/ut+gPWdYkvAgJ3cDjMsbsmWB774Ep+LL3Pp40HAAPELxYdS8UBlovvv9U19mSpW0k3lbeZ5sBnjp5TGvSn3j26sYGfW9/7De6K7euq2H3pw9qSGNM60zyhlnNtDXulFogxJttAiskxhQ08qJxkKRIQiFS5F0AaI3f8vHQVPoDf+gzKYWMPsTlBC1nyXcb+8uPCl8RCl3UBJbIh05gLouc5UsHBiVwyrLR8tTNB3yZA66QSr7Jc2ijPX/0cxV4gabPAWS9tF7H6TbtZMMYvg+bJ8fgRhi0+A+v+CwXh3LMthdvVyfEYCEAmRZYH++DjqCVrlKQNh36NM6f7W95txAlAx5kJljY5Doa7bDsprj84C8lvXxS5FKynbIdm02ClXo0PD4khTTLOkDQuYdlaBC1JB16oMUKrrXYMi+IXIZhh7QSy1B2Llueot+DbmezpSCxJfPMLQ+JILQ0B+zIOccRHgIwL3/ZC7qXvvi+OUy7AzODM8+EIQhzwz6Ty2eqV7nWu7Nif7lPHDvW3Uib7Me+MLsJwhCIuWD98Qttc15eyPCFpMMWhNnGl452c+XzkiSWj7/IxmPcy5evbm9JEnY8+ey1lat19vS05Ghlp90jDHQL2hORAAs9qjXM/KMDYwitWeiW558whoq+Vy5SvwLOPuNgs2DEi4wSsHE+O0qu94v0tVPangem4Mv2fD9p3kcPsEGafZBzJY0MWmmg1p1mupKyREyg6Jx18Dw4XNzA0qIkumZ/8WO/osabL+6gx5cY2Vn/2iMxZU/eEdAfRCILtgZhLB+w4DIXSn6vozCFOQADbebzvHc6hupsOavbaNqsL+EI2I5+dl3lkRgCS3HUeYeAjOhdlOlxf1Dk+mO3Ek4qaSwHykmDoesIuvBrOGXrAZFVfoXmTNOUofPyTfPOfI12nrSoT+DD61EuZ/P3UJa7yuDq6DPW767+lXNbh36IAEdo6+NndWb6Rtunc3jRJ8ENX60c1EfwBAs9s3C758q9V20udyG00moHbGj2GUKC6slZC0yFMbxTDY65XgWFrgHVTkXoXdJOlH181En3NKiiex1Zq/DkYGrfIi/ljXmRG7PXgjZ0cY46BM6dN/DgoFhpxzLL0Baad7/3z7o3f9Vru3NnLdi/wZSXOlC/XhDG9tcgiHDDNpeXXzaod9uijljk/tZId7+bIAx1oj/mRx9NEIY+4jBtzrvNLx3t5p5gSdJztvyIH1+hjCVJlNnnaL8S7RtjBK77qsnHoKtyTfT3hAd0O/G60eaocI9RaQuiaPY2YHsVyXhXL7LUWUEEk/007qCs0bzDYImlSNbwSx60YrODxjRSCuWUtuCBKfiyBadPKvffA0z5XCeIQh/LzI4IMOyV5cxy4SsE8dWi5+2t2lUbFO9F+vVHf6O7fPNaCWjQrNMimya1xRwokHLj7A+q7LLOQyYUwRL5sDbKOhsQ3zO4r3CpoKQ+oMA9lEJ/AiasQFPLB8553QpkIDsepKGOGpROR51TwBzrAYJGC4keHA3El4s8uZ5S0Clsy7CWZ4roCQu4vMpmujwscEhqNP3cGD5rHcM3CZnSoYvpG+cwN8ZXvNcnLYSjOJnj17pdwcYOqz/gQmg/Awz1DuU6fciIaxxl+Ps+aPL7sgPe9DVZgukwgKFGgxTXF7oafbNDpJAXUNBSjHtzWJdCOjh5fUKOI0sd+0ApG4KqAWJ0H5PNdDnv8tux780GXzYXdYy/pR35Fhkzl9mY7H/P1iRHY9IBr+wKHhgTvUhHywNgKvZ0Iy7hBqq9WPBDvkz7jt/84+5NexCAGS7TwNYIwpw4Zpt+28PsLZsJwyyDdR4qcx0OSt6DTvMvSgRhztvXkZgNs+i6jNUp9oUhCMNMCJYlHYbNeQ/Kl47GfLosjE8886Mu3LsPnD+pTZEJiu31/Xvs6FHTESOdZS32F3jTsqPl/XWvUWqIas3VbUbjNv7U+MEapYDTPtGv0aLprAz9jkbvBicwQx4iqK3MhouiMyhn0TiOfIyfwUxp/z0wBV/23+eTxi15QEGA+mC9nBE3bt3ujtsA9Waawrwc53JUBF2YyszSoks2eHjSlhbxlmcv0y989FetMY5G2ANLNMQ8MNFee/IOACoadD9bAT77X04efKdRF51QjjdA8ERnkWnA5VS7AmQbp/DGEHroPEJe8CkQRMGIkE0Sp2SQd7tcIsdIXh9RW6WpN71TG1MJIGJySoW5yegjjnT2uW+b5XLu6ENOngmrkOApZ6PJZANsLYa1FbBiZhkdiHS6gbGFeRQXdoglOniALqPpDZnlbIiGcyHDOvpgoSlYnr6vW3zcRJaaDL9fatkyWX+Dt/sqLGnnhhN93KjSY/pKVfmmeB6q9+pVFFV9CM+FMXwlCQUwrZZ6gZHQF+fVRI1Tmyz9vRY3SPQ8+VRjDBeweWc0By5Z0fNKwntAxgD2v9J40eVUYJabjCuyKlkph+oKBzDABc3seUBoxXf8xgctAPP53blzm5kBc9QmfPqyvxHtpo+ZL/z4et4Z64MIkt9NQZjZWvchz9+wLyTZb7dBGMYWsTnvQQ7CYOcwGNf3yOEpDZcksUR8r5cksXfgjTXGZ8d5gzelyQPzPFDGKBpV+IC0UVo7zRgilsbXkYeNLTTCtVtLdxfdCRkVDGdtuWbjGjxeUKpvEo0deoORpm7K7Y8HpuDL/vh50nIAPMDg8oYNNFdJbPzGNNdNT209bwEXPjtIO8tu/uzyvx9t4a994je7yzd81ktppc0dLXgCDJt4WKmNvLfmohv6Ts+cdoj+orb/pW23kwI6t6EpEjjnX5YZ/DqbUAVuoIfBEj7q5R1cjz4zx4s8UDub1aTw+wnpZpcViMX52zIr6L/j3MI4urw4ugwvHensradmupSgSxDlc4hMMGTIphFcBWVF8FaECxoUx4110iGrQZPwGUFZfqIbyPLrQCdfEHZKWSvBaz8D9uFD+qJjhC4HReDKZcmsgtvdGtLdLpcdZMEf5Ry4c/lSYocmz2mTHLtwwa9zKYvCDpzRTYAz6CS7FlwWsH5yeCUTstD2gX023Uh9EIqHLFwvt8toh8hgnwcP/CpnbLCfasBhk7Ln2bFIR8HpZAdMirakiis02VwP3BSKglcp56uAeZlEnLJj1O/4zQ92/+rXvX4MtTLsmK2/mRd8ycIiCMOLhrsiCGMX0P/+cy3n53cbhCGgkTfnfcH5g7c5b76n53vi8GHGliTRrzOu2vS4jQ8wMOtm1cReO1OaPDDPA62fpOEyKnXWfvbAiYA+Hjacl2w0U+mSZEda/8ZffBGXxgiaIWPrcfXlo8Q2ZffXA1PwZX/9PWnbogeYprpq4u3Kgxc8SLLKYG5Mz34uLRrTD+wnP/xzpVFuARca6WimFWE3Ohp1zYLRiC1onQ6Q0yPRkhXUeTx2FHUAAEAASURBVNgZeHQkTmMzSngINWDpE8QSeWjiN5Ba6SXTqERnh+CF3qU2ztAtJciGyaj0AGV56sU/7FEcTngdSqAH6SR/TFfJ0Q62I8ULR1+poEsAgyvKY+csJuqwkG8h0jX0SHqFsCBrDdgIbw81y5NFxxsYfJ3hLsJ4S0c/iytKIBGy6BmRE0GSMCuXxVqF+0Ak6Dg3vMt30kaX8VVM5Wt0LqvYOIJ3OYWeOkETdc+CXRBHS63OlHpkuaB83xboa8q0BdgHFYMqQ7MtgfYlK7vswN8itY/yssqLx+aTl4rPo/PgSSFCSsmGHbVtGGiQPF3PzFCIkrgBW7+4LF2fq/u93/9Y9yWv84DuALVycZWZDjdtpie/XhDm+uHbE2bevbCT8yIIA91uNudl9gsP6gdqc16csub9uJPfDgo+liQxQ+XC2RPaG4YXaJtYkkT7xb4tT128vnJ1CWhOafLAXA/wd2mPJz4usn7SyoC054sBFSgRwIB21hhW+PInTT8lJs5OY8eSYb8YG9lzAyPDDhpPKU95StvwwBR82YbXJ51b8QDBD7U/KzY6TMVmDfmtaBlXtD6WFp22Dvh5W1r0+NNXaiO7oqhdkX/Pb/0dBULyvi2lNS5yabVr06zGmvYcn+kBxVvuQmMwy9VOQHwFBsL41B9AQR4uZNkpfgVUywGHFrlFjHgjn+EIVOTfRYseztK1IF5+lv0cLDHLhbdiVEr60jWVjQYVpeG9bKSRMbYLxx7u7rPACymBVc4H15YhY/Rua59qnVJf2yK7+tL7fIEb5zfaQi7/BTHnCDgEQcaB7pXNvwGwc2SDJAdZgOVyulQizzinFYNwfh+UrNkVenTWYQCTgAZTMdXH+Rq+yilukW3lHhMu6XRZYcu8szvXeQc0CRiyR2UmuixhDriQlIuaGVbJwz6mYAQuHxmtNIbaMd5V9GfaLKvkQ82ojfAaHaS6Jy3DJaz3WZEhiyvQeWCdSZV+BrMYMML32GNPy7Avef3uAjAsM7m5xn6kvSCMBRG0HOmQBGG4hpv4ClHsC7NuEGa4OS+zi67Y55J5obONdNi+dLQbHzEb5mkLkhCEYU8eliRdta8kXbN7eN3ZMIwB+TtYNXE/Mgac0uSBuR4o/Y6dLNk4QzvFM96w8ZIDyzCL8SmhFPYXzMnuy2hWdIvGOLb0b0atZUjGUu/gmslypvx+eWAKvuyXpyc9B8IDPhhdrdXhgZ3Neld5g0hl+0uLbu7b0qJ5jv7MlWdLQ26tOQ26BhLeskfAglJpttXAR1lLls1tEWAXO7QG48sSpIDhXedrDT0DF+CopDPJX1eCN8uFlyQ5EhqQBFfWZQYWerhiZgZ63G6uHRh1ZaJCeK/sUBkuedgJkSWO9x17ZXd/CboUsGhFMHJwzhFEAvk4LqxPiD3JRm12ED5jeHWi3y6wiybkjdvfF1NoCpBrPRzDOqrJyuVZ2kZXzakKw66oZyuLxA45aBOwdrWdL2iqWDO65oto7rMIRMWd5fL6tM3+gR/CRM5D4eOgzLFafkT+agJWoKaaC/SFPyDjbzTKK2iYIS2enYEvsiNw2Y6wBRj3qWhUl1IY1mtY7lkwQA6KPdKRwmOftACMqd3VDBjjX1Ftz5KZIIzd8OyDttf7kvWMWLGgviYu5Iq8Y+S7CcIgL2/Oe/+5k7rnt7EvzGH90tHYNVkWFkuSWILE5rz3nzuhGTHrLEla54MN2Dnt97Ls1bqX6WioLahCN0OLbYNqn6/CKNVB9AUMtdW0aexRRinisYPeIFCAw18yagveaAvhMTj7wNC30fdOaXsemIIv2/P9pHkLHuANxKqb516xTxmePnl0qf1ikN//atFNvXHZQlV7Kv/mb/5dml1vl9U4g6YFpjGPR0dgeajurXNp/hXUiPad9lxY8XveqQu8SAJGQJ6Ajhp+AMbLNEqyCt64ZToKJnqXgzXAPLWc4BSRJWR0RMi1JVOGo14edDEZhdVpQ2Y8JBde5CR5R20T3ftspsv9xx4qGnRqhxDWILvOhZ2rCJo1g8ovL6GRFicVVp9VZFc/IgwGd0/16SBvMgqzgE43xAV3gwck5BS+RiCh6Sp5uYePaxn6W7mSWSbLEFyHIW2ye4CvN2PaSDdkurwmSy4QkFypYylXsMxN+sQ0S1/ByMnMihBIiA7cP/xtZpKGHc+hHXq3otCsImBc7HxoKCx2xj2P3RtJRU6rTxKcsuiqNAEv5yjK1GRvtk9toQGCNucSMLMsl28Cu8ceZQbMne5LXv/wcrxjVEneGHoZWA7CsPTi5AnbrNdmEhzEIAxLpggQbTpFEOaCfR2JX713llQUQRg2NyYQcOHs6X39QtLd8KWjJV09Q8afQFuSZB85sK9T8bnqVZYkMQZkLLhqOj7NelnVZfccvcbg1hHa16Jrp+TNto+TcQj9I2NokpYjlc4pZrQwyPU+1Hh8YK2yt1N2NKTn7VzfLEjcdNiCB6bgyxacPqncngcYgDAIWiVdNnqmrfK2al46KEuL5tnXZr3wiOANOo+JNMZ6yPZWm5Ka94oThMBJ7RPEo+AGMOsLokGnW/C8ZVIC7sEQdDtNdCmKwBuXHmSM+ajZkWmQ18ot3zSBJZkMUxJBF/Zz8Xo6XtWjc3NiyRRXATQpkmQBl2HQJSiKgBVOoXOUhSfP6vtedpS8D1woudZxFR7RYpNx+xTr0BHnJm3GIwL4/dOo+rng8Tuv4RxedFgh6KCYoc1Iu6K9YipXeMlkOQLZYQZW7pDAczcUdt1yulR20wYsn+NhvNYqkBUwJzNCNwLqMWe8Xy1Hh309YhVmr1+mmYtFUVaWmTaUj9uf2051Sfrm2rWK7iQvs1XZ4GuhUBQenQzHFY/xqkiTTMq0WjPXPysbyycZgfbWL0p+ZgnSI6952VpfQArb+hLXL+UgDH0eD6QEYVhSc1ASM19ujvh2U/ZdtK8j8Vs3CKPNjW2Dff9C0oluvzbnvZu+dLSba8k97EuSLAhmS+qWXZLE8qUnn722suppv5eVXXZPMrDSiKAJY5I2wsAV1phZ5+NDRT8LSsdJO1cG1/EFU41y6azA6UQvQFa9mJ8Np2GeMNNhGx6Ygi/b8Pqkc2seoAN99tKN/Ly7oy0sO6L5Gpt2et7eYLGXCw0Za7z366tFOxqdCL77nf+dPUh700s9vCkmYzkaaA4l700/sKASQbTjggLhF7KQTACHaHwfjhxPvuluKaDWCINfPOK3yD52WOJBhq4iaIB5p1R0hwz47JeDLtBGih3dJdVkoovkWsxeV170HC1Bl1eIIGgzh/M5ZNljX06f61VnH7EHl9WCgVnCo9f+NBdTfr6l8+zxmS5+bexuT7I8O8NXAf2hQmasJAKG19t1iCsBWtciMwMrV2oMn3HC16tahBTls3QS3Jctlmaf3yilXoBNlpZhm46xOglo92HGtXy5FgXQ4CgtOOl3PTOwwEHbZxY3oAG4cgwzy9IN+Vo57N29pCbTc3H9SxMwej8MeeaVZeUiE8dwAStnr6m1EQrk2lUxAL+ws+m2Oyx4G7Cfm4vvI9A5K7/r3vmOD3RvevMXdGfPrvgJagnsm7KJkgdh6BNva6bn+RMnDkwQ5pjtbXr7xiZquVjGboMw/oWk6/ZSx/cleekLTne86Ll45cZG9qzJ1u/RbZBVHLo89/Bzl2/rq0g7LUnyv317CZVmgS5TYfgYH05p8sBiD9h4qwRe6P/VB/BHa0njl5JnhOHjmfIXzUn3pI+DC4NeFMRonHG5L2eCuHz9zm7Mfs8jzumwjx6Ygi/76OxJ1cHwAG/GVt08l/aNB3ze72lpkb31Yzd9Pl39vO2mv+4mbvvhkU9fea484tH4kvrNLo05GJpjnwXTaBoOmHNmKc7nOPwqnIkn8O4BFORa2WC9z00LOF+eL0sKu4ptyDVp0mEyj5b4ALLjxavjCkXRUU5uZKk79iGV0wtsWdEDNtMlkolzwwJgZ+gsxNO9/LTTveLkqxN2vSwDs3OnT9gmzOs/KXz2wI5PXO8HY3YOzpgRVM7SjuNKOcZpuQ7zUiIzEqMrAPc5kMJr8D5tk9iTP6Dr4YwllyWvCPVTs7OApbTPM6AxQuEBk4dRzP0BS8gQyurkZ6+DeJRtdaWYaYQugBn4gHiIl2kGrPCakdR6GAUnYKt5ZVkysz5nKMCMGSkGDDh/H+CbL4NzhK+h+jnVVVKqs2Z09jmSTW5MpadYjMM2iQagTBIyLCeUshVfMz2Kqq8H7bp3vN0CMG+yAMy55QMw9W9tIGtTRR5GmUl65Mit7uTxY915a88IJm93JgweHPftpuqd5UQQBtj6m/PeUNDljL0ceuF9pyyQteHNeffXJdk9Bz7PnbLTkqRjNti4fZvR32qJMdGUJg/s6IHUyTH7JfZmga/+6dq9FGMolhppPxfDCmY3cfRN4rHyETZjNKAo7exyQNh/wXe0aiLYQw9MwZc9dO4k+mB6gB3wV908l7ckDIxOGO+2v1q0ild/8c9+29pfWltvnPOXjnhcpEHm56nkiJoYT8TYwRmk0rY8NA0eQxOCVIiQTk7khSTTksySniYjy4Oyle0xArkGixka+Rq65aUjgiaYiwwkCRaDIRP8wPGHLejyEJTSE0cB7PA5pz5XWbY+e/mpVwb4QJ9fcdJtDiOH5U9c/4j8oI2nuxvdo1c+XmZ0BMfsuX/V3NOZqo83jAB+bzQ64zM4KCRooNCQyrmcJL/QN7K+zHJFG68LKNeyySngYhenjPO8aIKQe4S8/Rq86XayPh+wkNrqViDO0KpRc8FRAZIyl1zY8qckljH+JAs0whYJTOSbzqJWf27z9Id9I4rFYgdIdDkABFDnEaYMWoYG+qArZ7VVkmOAwIXcKCeUqpDrETRZ9oygELjDOcsqMt7x9vd3b3rLFy49AyZu5R007RrNPX9Ny48sCGN7wmw7CNP+BnddtZUExL4w6wRhUMTXkPgx1njB+ZPS/Zwtdwa2m3QvfeloN34aXZJk+7zwYmKd/Y3oZ6c0eWBnD9h9Yv/VbtmBwAl5BWIYKNsAWvu00CfQqFtHRRYiH2vb+Njy4lGvCbbQwGI/k+A0lp/S9j0wBV+2fw0mC/bZA2dsne8qn3tkaRGb+Nkee1qydBCXFs1z4U9+6G0aOPAGtD0Iqdk2FppkUilbMRrv0r47SZAXyswVMiEBzi+CMFEWDTjLuHzXKDkcjFn8lo+HHx6Qgx+cxbzcfstrL0XKxP4LAzQkOiBSLatkB3RzssMDx22miwVeSJXuztHuFWVWy+ecepVwe32QL6jkPiVUvfrca7oTtu8Rg0zerr7i+CNV+/U717tPXX+0lm+o/FgtRyZ8FuXqRLsiM7gRWNDEmSuZU7mEGWRyG43zeVn5IijDYS7gmlkow+i5T6EJ/U12q1fWkfHSVxVSmk19tJSJqMJrxsA5b0UFHO0PawDu86u04UO4fUxxVgXdTjSZfsl8XAuZwYu8aFzm8Wcbenk3UHIyvMgBJJzKVhrSzCkLbIwuPQmbEVBwY6eh7LBhjNZg73jb+7u//A1vmIPtg8N/fejeldB3zR5WrzMTZktBmOhv9q6WO0veVBCGoAlLpe+zzXl3E4S5F790tPNVmk9RlyTZrFT8z5cr2QON/VtW2XT37OlpydF8L0+Y8IBedFrfFmOQI5qGXHoVa1M1Grai4jB2H1KmrWVkoqX1Ru/tXhmr0KeAF5CC0xYFxiNmwafDdjwwBV+24/dJ6xY9wNcaOnvrvyidsGALQZpz1nnesN37nr10XdOBebtHo3cY0i985Le7yzfYIC4/Gli+tun+OEpDDohmm3NLXtIMFVpy6l15PQttgF2CHQ2gz08nFuiOWUeg6ZSWLzET4/WOpIitsqIMD8uL0FGXFrlZxWYr+H9USBrn0gWJT2WrxIMWdHnB8c9R//OK068CrKmbrzgks1pk8JoH7vkIuvCFh7G16yePnLTZPu6XUPO5p18b2e767Wvdp254MEb565+s/q5ElhneRX2cl7ieunBenPs3NZQVZfG7EEnI8iq4ZDIO4lwmb7ePYCyLiyQaO4Q+4EM+B8Sd5pytbSiynKnwhvQqrMHn0DF2QmbILWQGaLY2Icjt2+MaE20yoScjw/cyjym1EssrEosdVJMsI2TFeYFIb+XGCaM9GmUfsqicgBEUM7tkGsISusocg1VkziwgLKj3vfej3evf8HBmmsn7vbNA1gzH5gDcr8MgDF8gov/c6xR/K3utZxn5EYRhc15mw6yaCJBfv2Gb89rbhwtnTnQPnD9Tv5CUZ37uJPde/tLRTr5ZhOdeumyzju6zT1R/5tnr3X0WhGFGEjD2+BvrR7M8H2tmyJSfPDDuAW+p1cOp+1AXby8F1Y6LxUYjpd/XnBZDMGY5aowEYGq7h4jCFF9RIpbDyMBHB9A637glE3Q/PLB6b7AfVk06Jg/soQeYCjq2eS4q+QwkbznY14V9XB5/+mpt1BjsrLNfzB5WZaHon//Iu9x2fyIQLRFvGnDaZj1wCOfNvj86QFbKhqNBF4kd+zyuGkrwpF6+RPGdt+CMwDsBlwVPtUV5K6OTvJ3xNW+bbtl4HTnAyPgpuhGDObjaQVkPzdTV/r3QZrm8/vxXAe4eKkEXFQ7A4aZFlPbyKxQRdOGLJM9fXhxw3MkdJ4+e6gVnXn3m87trCsh8UoGZx68/PiOCa9lPdPx2fWYRlcxRXOWWAqZz4g14UGb8KC7fJagwItmT4CFD91ARnGUFnjvR4aF9cC7IGZoygBpQW7HVOXJD22Z59ghSfLOMdOoX9iozU+FlpCxHI9F2sHislEZ5IXe1xzI1bxyR752jkPBZuNDjNHwm1AfFZpo5RPd4Is1iPL8AuQAF72OPPiUdr/uSh2fFFght3yoP6HMF7QKBD3IQhn3SCCjsVRCGtnSnB+JdVGdt1tgXZt0gzK1bd7pn7AtJF6+UzXkfKJvzWpu+zDXeyz5mbaccEkaNQ2zgQl/91MXrNgvarwFfSWLPPzZJHtvzjzEmfp/S5IGdPEAwRONbay8ZVfgSIbgsTwBG88ntaLeTxu1GT1/DvaltBWpnU6aH0v8YF3cfXYnfhUiBB6C4LTOlbXlgCr5sy/OT3q16IGZhhBHnbGkRU0ppAHmjcc0GOmrPgsDODOroUJcZ7CS2rWWfvPSMWt1ogN0Qb4bVJOsJwaCFgOaYLE22nytKZfijIa+sBYCvqmTLqINI9PDGF49CBjCmRUIrfXZgeRGJII32twNvsOABXfPA6bQSDGFveuBrBHnD+b/QXdzFl4RMyJ4ndYZ7cE9tMuiyyAmnLCDzUJk59Jozry3BmMe7q7ev2hKmCMb4BeS6jaUG50r2k+Mcnv8ehzwqN2C5k11WAxf5mAPQHpZJEWTJMgLmeI7FhgroB16ybUEL6WwqNhii2qWMyxPWyoGLcwUgsAJ72VlVA0hiE6ZZMiDciyLKhgaspccFhb9Vh6jIAvlBsrNKlz9KJ/lFSdIl2QUnbstjH+2WN06JeCg4oVJ2SDVafvQTT0nR697wylH8UZvgyZvPg5AwQ0EYCwLTNsVm9QRi/JP2m7ESnzPD5qCmTQRhLlrAhR/LYV5kAQCWUDObcd4mx7onD6pDDoFdwxd17P3yHNegLEm6YC/r+D1v48a8JOn4FHg5BFf3YJjI36j6R4IqVtByejLWgaSRgWho0UUPRs07Bx+9A1fQpbz8VN6INE7mfrTojXgsC8eUtueBKfiyPd9PmrfogTOnLEJsK3JYWsS63Ju2tIjOdNFeMHSsp08e1duOLZq+lOr/5Fd/SA01xNFY5zPNt5pra4R99ok102rsW4Mc9DTopCg7b+kAaMQNoQcNGnmjgz7OmfeoySeoQgp4vMH2tam+tAhcPLiIrgjTyQ7BS5n+5E0PvsVgRyzo8ubuog3un7vpmxMe9MALfuCNJl9S2FTar6DLPHs9GPOw0J+nYMzV7vHrnyrBmE9VNq6dp7iaXhrCa7lkarncBSo3oO67dof4fVjLpkoDj0HQBc1ZztzAS9GT8eJN+quuSuv1qschXGX3AUfZV4n7maYm+awBjdmHaX2uQSnTB2oMFrjhWUYWYOTjvIi24FAl6zPPvDw8GVdk5JPankIGbZQzjedNc65n5O2Mil4KnAErzmB1sFrwDZcY4Imizl6AdtG1Rb9oyIylkFlxfhc+RgDG0lgARl/DmOGrAraSwQfMEuCn/UzsofWWzR6g391EEOaEfWf6BlMlD3iKIAxmrrs5L0tf+BGEeeDCSd1fjGH4+lQvLbyxepRTYcQDjPlyUCVIuJfjK0nMlCYAw5KkS3ZNCMRwf09p8sBSHqCdtkGv9mJRR2Zl688JwqgJJ285xsWURW4HA/vBED6iF7U6E/WFBme4wzj5jg2+fY9ESRK9oaa0JQ9MwZctOX5Su10P8DWBUyfu6G3RE09fW2rgd+367e7B+05qzfV2rd9Z+/O210s00FB7I1346mCMDEmUPvovxQJpjbjBRU0jbsgBJ1ymgw6AjP3I2DmyFH3GkCN4dIhZLhDHbCI6F37qeIoYwYpO6oHMt77wLd3XvPDNlvNE0OXRK+xvc7gSL2lPHqfC6yemNhN0OWoO3cTyovUtmeU8dfR093DZyPi1Z1+rIMwTN56wHZeudZ+44jNjuJ4tMTCw1AcOioUm0Tl582NjNxhgA+TNWv3RFQFFVWGYgYvZaEbw4m2KrFju/yKzhxJxs48iSabZIeQ7NB9B5vLy+TXZFiiYtX8usSo2F7txRPjP247lxVf6nrMGxgvnd0Zu+6QlFIfKnpwCNJjAJlaS59BADX5xCmGN6rGPP9V99ite2L3wxRca0HIEtKNd7SEOSMH3M7mth1RegjCzdLdBGK7nAZ74Mur52Bdmt0EY9nVhXMPeMDkIM33paNTtSwMJbj357OKxBcuPhkuSpiVHS7v4nifUprnqS2wMQcDFmvnaV1ijFjNhCKQouA8NjZ14vE/Q8qPSgdQNdY3hiI0PtfeL8d6xJUwSYHx5rHPPX4AtOGAKvmzB6ZPK7XuAjpEOdZX14UxnZo1lbfO2X41RC37+X7yru3T9iuGsJS4tuLfJPLSWhwjH+kOBEfE8wJHHR+qXvxrkvP4AQR4akvMo28+L3+CVMbQaiLbf/vl+LllI0RtsRQYioA9Rf/HFb+7+4ovebFBPeaZLwA7XmaVs61k8DLpcv0bXfLDTaQvGvOrsw92p48e6V596RMGYx68/0V2xZUqPX3uiZzz3Vz/5fSpYQTYav0N6ZUAGmBd0QY7oC1MejDio6BvBi7fAycfNrrEQpXLDRlkk5QBb3M/orDQ9ecW2xKOsoqgOrHwqhsTCwEnyDA5qILtZkOj3KjvUn8s5X8wENC+JfMCTafEJ6EX+xxdVx9AvKjvw/2fvTQBlK6pz/7rzufO9zDMyCQgoCqIikyiKY4xDSBzyoiYaTfQ55Pnii4lD/Md/8jQOeb74kmc076kxiKg4z+AsqCAggihGgXuBC3eex/f9VtXaXXt39zndfbpP9zl31zm9d9WqtVbVrt69qva3V1UZj+enc1nOM1MNKkmj5jT9PEmOW7ekyjhz2YLeOnLd924PFzzhtNIW1Lzt3F2+SVoLD5nqIAw7Ck4WhIm2tIuGG/K158VPFoQBuNpRWpw3vihisd5tOye3VXVez/0pzm/V13zp5Lp9StJmeSAddsDCTkRqnroF1AJus1jjReNd2W1b34WclMXJgBfx2jQiEfbJyBd9EvnKi+vFiEo+maZAOcQBYyDp40eL1ocpb4EafJnyJq8LHJUWYHDa7eMqbxLpjPe4RRyVi8nqcfnPro5WV9dHNXkDGs/RGmN4MdLRAFsi2WHMMkF5kiEVUfakx/Iiq+UZJ/oTn6dNMjFzSrpiuXHRL1tEFzkUwRJPKrnRmfD9WL2V98RDLwqXCHjxwEB1Okwr8vqOf/arH5/LcxlM4+nCF8gbt13TAHTxutu5uPFCAIx50NgxRj510YMjCAMYs4fpSoAxsW0KkRQp0tV87p9035RBF4potLPJF0r4NTRCjCdaysiBGTjLP/+kN1NSTK8jS3R7K5WK8PoZPdFKFYgiOjbq62xtz5TRLrNVxkS0Vvnt9Ds9XasnOzlTTHGVPci3K8PshpSbfalcS0Fzup9bKWtVJ+OvCFWSpiq/SbJ8J8frZiDdquDuad/86k/DhQJgFi5aYMI+lbN7TcORYHtfPpMDYYq7aTgX0YdSHYTpx+K8eMEskleRcC1b6HiUPaH60HR9V8GU4F7arPZ66ftXMbMVqg+InizqszxuV6zJowxkrNNKTUB/gZnjoyzbREMJ+pE4bmdszzgoncVmMaEvBsAYr4QjkqPcOgyjBWrwZRitXpc5Ei3APN3dXc4PZ3CI3B7NWR/VsGXndjPMPgzFVpuhxvImm2tG2jLKBpp8Q9XTxZmI+OIDY3wELcCcpBZWVFEenzxuNIT1oSR0a5mTpC+TgQV6Jg+Cf6lAlyceeqGoMUx/Txe/kni2By8uuoOQgy4sXtnLoLCDYgbOMt41L8QzJoExD1ksMEYgzOqdawTKbJNnzBqrG/dXDLHhPG33pTIM+EjEeGo0sKVdQLxNoIopHgd4kWwmLu6kOyNm0fRgnQAhyiPTPy5rZVYPzXpzjryMnO5xK8cTQzxTz6L1iUxU8XZ1rcpW0y3krCgdYPWxa7n9WwilCpbGpXmd87iLt6RlxCxqDZDSTi7VzXW2OrtAq7xEu+YrAmAuSQAMFz4Nw6RAGF3zqNz7k216Xxem1+lIvkPSogULtQ7M3rQ47x4tzrun7eK8k63zTJNnZyPux27DXI0R61C3QKctYOMQbjPsF0KNQwHKWEcmuoE0sChO38GYOoItxLWFgxEVtz0BUcQLTYCXVEBUDkMdhtgCNfgyxMavix5uCzAXumlxugmqxEKBY5JrtbXgBKJTkv2KL747GmWV5rbVx+AOpBRn8WCU4UywSqmO0WxHksXtKQEAJRp9CnCeooykEbXGrgNeQrNAXAjmsKFMFxTJ9HHWBz1PPuwCyc4Olx52oVIxzDTQxa+Ls7ddTsvjDrowb3c6gy75NU10zc67cM5YOH7h0ZY8TWDMVvOIWRPu2Han3S9ktAJdoMc7LpYU4wVReeUaFPmiWzwRSnyiNfgoIenIiFkUBgs8yDvdxkU2lk/lwOGZkb2RTPQimx+uh4IIIaN7vp0b9BL7OBIl8cRXla3yNKUpthOhnK9VXDS3DXkZsI4bsrLhtTaHpo/ZpCy/VM9EL+mHln+B1YJzXZ5HpT1kUatAKR2Z/Bq93Fzc1STOcrJN6pqv3CwA5nQtJD/X2q8N28iTHYSZl6Yj0XRsUQ2o0C54G7bLn45094TpBYShPWitjhfnnY4NNMA64zXEorrdBnbOrEPdAh23gBl9jcb1Y43WLVqylpbOxgGMTDSGkJyN5yUVVUhOBEYX/BEiGINiAEFobiVbakekDlPQAjX4MgWNXBfRewt8/0e3hDtX3Ree+/SLelfSRnKxFlLbuGVXVwPUrdpJgBXt10tuFMO9mzdE25rsqj94FOaWSLK/FlU8AjDxaixLGfkDgBn3pM9MftJRootGx8FUIbJ5II7r6VCASjCi8iXknUIsMQqg/imHX6DPhSZLHtOKGHjO9EBb+/eUX+tMBF24Pvv+uR96CIsSGHPS4mPCrtk7w51b7wu3bf5NvKeTPu6leBdGgqUj0W79pryMv8ybVVIZSUVU6gOYjJhFGxrtfs9kBbzYdw0HAhWhmGyUW8k2vU0HMeV8ebyJt1uClDVq062w+BHuZ4Wq+pS230+Lqnm9S7YsXU+r31sLFWVScR0pUqQTm6UjEVtIaLAolhJeL09HzphNXtyRIgo35J2rcm7BgI5vfvnmcOkzzpTBnf4Pgay1xgcQZkzTLffNS9MtNeUyD3yn4wEzOe90jDsIQ907BmK4GbJ7JAdhGP9UF+edju0yqDpzPy0QiMJCut0E5MZq8KWbJqt5rUNKL2TosGbrwwCbH28aMzSsHT9opu/LN1xyvksp43h2jCtG2P7btw6QRAzmKaMOSisvOqk+D6EFavBlCI1eF9l5C3zkk18NX//2j8MlF54dVixb0rlgh5y9rN/CdA/m9I7atI+Xf/69ehAxeMTGW26EMcrRXGPQ1TCyw5w4W7BEU1LZLhf5k2ghYuJJF0N8XzgWL13sPfL0KfC5rHnwiuhpzk854vzw1CMusrV0UL6/gC5cK4GtUbmfWKyPMFNBF7s4DrpM7o1egi8ybLK75odj5x8Zjj3gyLBlj6Yl7Xwg/GLrXYVaa83YpEbjl+GhQc5oDaKq2KBT3yxLKlJeIpbzlEs2MjZ4qspGOjJeQlXe6lglJl3kVbOMPz8YQ7mOlt1KsBUt6fL65aq7iqd2mFAm51M82o5MKsunuiTHC9b+YrAxp86t+C1PGaYapdYO6Vv3NvFzq8Kqea3kU9kGNiq/VI+SfEwU+SmPdFG/VnWYgPalz9wQzr/kDK0BM38CzumR7SAMNgCv1QXz5pknDOteEejL6f/2h+BAzEQgDG3FQrzV4CAMfQ0ADJ9ttnX19J3OWr3Gyaa7WWg3Lwu5OtQt0FUL0L/LdHGysRF2jA/3EllE7WBsIqmvsjEBNk8lJdvnXsCUPYv510bnBBOyceSFrIkbtT4MowVq8GUYrV6X2VELvPkdHwp33n2fgS4f/8zV4Y+e/7SO5LphYvDRLYgCujx7BMEX2+EIo6oGwGb7w5+5pCRDTbzprWy079GII0sDJoNP1AI8Uoxu1w8dU26DFMULTxejxwN1QB8f5IhAocN4xlEXhqcceZ7kIwK/v4EuNAdhr8bG3E8Y4/m82VXjzJTpRXaBlYPdBxXaREnu54Xz51o7MfXAH7hcbvGcheGEhUfZByBm9Y4GEBPL4w6MoVF+pNngxTO5N4u4IkqU0tzAhETM86ij8UNMI5s8vyrj5bpcfESSkqrukpJG2YoppPrERMtjVbwTmZKiZgWl7PaJ1CAwZFHjz9Kob7qKLN/4S4f2md6W3rYlsWpCBRuf1JnGltcJUy7YbD/dnpqWpoIb/IWWkr6CGiNZnkftmpTbpLoi2qRAhG9++cbwpGee3ZJzuhLpr5kuPGd23KZ6wVyBMPKSpB8CoNmfwkQgDFtPj7fTka8L4yDMoSvn2RSlTVt3dz0ummntTp/MWK/bAOBVh7oFummBwhuccYP+i7E7tx9jdtk2HYu+yIfzVoZ1QBpVG4+xG9nWdSTG7ZjGI+iK9Bb9kknVh6lqgRp8maqWrsvpugVe+ZJnhQNXLgvv/qePh8999fsDAV+Ym8tWl92E7Rr4jc2f3fQA2I2OfvN+9uc/CJt2bDc7i24fMpjdFTWescMJnHEO7LkZ+Fgj45Oh5uzBdUUrHo/m7igGZM1jQwImIyAlf1ggbup1IB+g4QWnPCFcdOBjXH2Yyeu5FBc5QYTdi1jjYCaDLhM0Qcts7h8AKaYc7BTo0sl22gAxJy46yj4AMat2rDWPmOp9XB1X2+Amr4UEGjJk2B1eJTq18XCcBjol2SKRdGTleD1s8FTwZQxFCU1FG6GlSC4+1DjX22ENW7G2onE9VTr4rWyLtyUsHQdVzzwGpZNx7Hi1pVgPFi+YWwi2qkzB71payHlWOruaWHYxTB+/oq5D6m/+0a/C6Wcd55QZc3YQZtasPbb7Gwvh79Rs4G4X0Z8JDdIOhGHNkvs3TDx110GY9ZtDWLpoXrE47/4MwjDGY6zXbVg0Nv2n+nV7zTX/5FrAPFGkAhufe6+bVsYT9Bs2sI6jlOjhBx3QJfYJNuwQMO3gCnmIxdw07jcmdZXSRVl1GF4L1ODL8Nq+LnmCFgB4Ibz6pc8NH//sNeEnt/wyPOwhJ0wg1V02c3M3dLl+y3aBNSsWzwubwsSDmu5q0zv3ZwS+EMxGcyBgmxXHyBo9ncmKVI6R2Y7GqEMmYKC6EaRD9Dl0APq3N0JgVpaOhtzLQLvFxeeeL8j81jEX2OeIAxeGVQ9s2+9BFwAXdlOgrWjPbhd/pp2na/CHXX+wrF4Ht1UOumzmqaqHABBz0qIj7XP71rvDZvOKWWu/C1c3MejinDrbD6WRVjXLpDS4KbEVCf+1VYWSDvHZ701K8Ri24OeULBfmxMa5yt7IGWaMViJwgfFkSQ7VdJHRiHBNpqHKq7S310Tt0tA2TkwFWVmpHOLjBmdodRNbXqXCzl8oFaGJljKNXs70FL8NgqdjKh2rRKXv/vUDljkTARgujOZnAXy8N2ibJWPRE6bqHZdaaEafqiAMXhjdevZu2ror8Fkkr5mDli+wlwKsdbc/9U/cJFz/mg07ur5f6NfrULdA1y0gO7ZXv1f6NP3HPk/jCe1fZAlAFOtRyJehi70LnP7mQZTUOWAT48ucuC4MdZkteRuPu5JYAll1GEIL1ODLEBq9LrL7Fjj26EPDm9/xwfDJf3lb98LjSDA4MffS4mlnHOaUxaBurt7EY+dajbsn1tB/jns2rTNja2Y7WuXCtGKek6W2gr3e0QbHAavXyJ4dEUg6OBPV1RpLnFqU8hNPOhUydBFO+61jHxvmatHHZx57gclzuH/bznD3tu4HNYWCaR5hcMaaBXi68NAA8LJYDwz7U+CBgLskvpVpXDn3Zj9Al4bGRgwQhvDwpSH8HCBmN14x6xoMirX/Pati9kNK7CTzNOTJAC/2i0lFSK+NoXRuAoZS8eOf+PUp5PXL4ik38kzBkaJjmRyzikxU9jjspk8H+w6k0tLoG0dmouIsX7qshujUKDj/jg06s8wJNBU8RaT5snPFqMtYx9UuPhe1ewTRDmQjADNLHjAPGlf9dM7EnuzQAu07QvSEWVCDMGH+wt6BAF8XBhBif1ucl99WL2u+MJaspx1NZysynLrHcZAsmD2HYNDV29CXaXto7Jq9ZNBZ8ExMKxa5jFN9AACMKLpxbVSls+tUhrKs94oy1l/EtOXVh6G0QA2+DKXZ60K7bYE3v+5F4bdf/Mbw67vu0dSMXeGYIw8NYwv6s5Ag3hyGLndRKUAIOme2UR52eNlV/2B2F2PrUxf8wUFVjFY6nbJkrHZGIOqBq2IgwTUSAAi4VEuJVuWN6WjQiT9doMuzjrvAgBfkWc9lkwbG6F06a/8CGrh+goMurFmyVdtX+hvJvC0j5/5xZCOWvcl5jNtsUKBLq9Z8cAJiHqHMn29dpftTQMz2tS1Y07dT3Pv8FsTGJw89Ai+5CtdpqlMZ/vu1ZJsyyzo6uJuqekoKBpCgSkWZbiMKQiww51G8sDVenRb5hc4KP5ph7zTkqk0mVc1Mu+J8B0ZyxSk/8uYJUYpkETFaqQxTnNVOrLG+cbjc0JHxtIi6mlL9Mj7Pd9Ldv77fojMZgKHtaHlAbZ+ONKZpNEwtxu7ub4EXHXixcH8tnafdjfTpNjgIg2fRsrQ4L7TN20bH87fba5qIf452D/D+eSLePL8GXvLWqOMdt0AaP8T+3nxUkgdM7BlMj0V1wMYlfhJ7FZ8tkMa8WmT0ze5r7B4jMCOIVYz9zD4hOXGxXiPVhyG1QPeWeEgVrYvdv1vgwccfFU4+4ejwwlf+ja0D85b/8uLw0FOP70ujjC3Q+i1bmUPTebCtLzXHfI8GecMOq/F6KYbvycCSNpvbMLqkMcyQCeQYS3GOWugAAF3gNdAFZtEM2HHeqNYeTKwzSFp/67hzw7OOvzDMS1uc5qALaggOXKF7fwg56MJAuBrse/AvpZo5Q9PuQcW9NpWgS6vmfPCiI4x81rITwm1bAGK2asFePGJUuew+53ZtecumgVDpbi4S479himztvvz4G7RcDoXOxlW0IDUyW4q0K6skVk60KbvE5Dx+LmWmRClPCUtPdAUNRdwrcPMdINrP0KyvUS8vz8uPlWhReiGSIpV6cifk94+Vmcsk/oLUoohWpH2p64r1k/Q4Cu7+jzXWgKeffVwrVdOaVnw/6Spoa0AYQBdsMGuZAMLgubo/9D32cijtoMctwZQkXoD0CsKwLsy6zTttqiy7IzF9eAsgzAxcnJfpwHimdhsWaExYh7oFum8BfqGxvzfUxd7waDwuECWu76JsGTT6DDgFucQXo4w9RNerYKOSh7ytIYMBxChC4qDkPkCZvfpEVxqodRhSC9Tgy5Aavi628xZ4YN3G8Lq3vM+M0F++5vfD+Y96aN+8XqjFmAZm3a7fwqBuTFNHOA8zfObWa6NRzeypA90Y3GJuaDLc1DUa6Gh/LQ5RzJhvA110ZqBlhlvGGz2EgpdEKs9pv3X8ueHZJ1wg0CWalFagC2IEgKu5c2dpIOzSkT7TjhOBLvn10k/uT4GxBe0zax73wZ7Q65ou/W6zkxdHIAa9d2y/J2wUEHPnlrXR26VVYeMCL5XfzHjfccorWIpI1FF6wCYvlVuukv9Sy9SBpihS9aFKpdITvWXZ1TylbZwIczUPEoZJz0Hl30gLRuT7GbLvIA5wpVzFFg/5eX5Rbhwgl40lmbGRqLWFkmzM86yCxwl+rso43c8pP423i/aq6lslDxh4Tpthi/CW7w9vlHjfOAjDoryLF841AAYgZiaDMLYAsTxO88AtMlkQhgX2AWFYnHdJWpx3OzZ8BoEwLFQMsNRtWCi5OtQt0G0LzLJpQ/QS9AUyzmbEldIOFYzA45ieM8CKtFsnFIEZ7DtydjZZCEqLx7oE0UxvZJRswd1tNWv+PrZADb70sTFrVYNpARbefcUf/HY458xTBlIAg5Q4XcdMVUdlsADdiiXzw/ouF+vtSHkXTB/9yTXFINvFsLEEs9HpHI21Em68s3ymFynD9BQ7FyVDbacsjoUvBrnQRQB4+d2TLibR0SK6vHlkjZNud5myAkb8gNsx6wGxpgtvXFt5urS6hD0CpJDtxdW5lb5RpTFmwNNlPl5jQmC2bGv2BBp23e37U/1OnX+k7T515pLjzSNm4y62sM7WiLERUaW2mQlJj+GRIaO7RCTZj8hJ2bk1nd8eOchWVVbTmbKRi1LXeIV+Na2raGPMdGFNLVIVzdPOLNlGWa3LmIjqqowPfUV9NIj1Mo2WvvGU39CLUCNVipPI85ytFc3zWgqkTNTpQ7t51Vqx3/0rTUES32kzxAMG2+nedEUzVSK0C30OH+zzTAdhDHzZXgZfvEnUFAbCAMQs63E6Ejro3/jMpMV5+e0s0EYMazft9Obq6IwcbV6HugW6bYHYj2QjBhkrfl+8Ei0AFyje4RA1Q98gFRZfPA6vIOK7IZE/K+mNyxLQQ9RhWC1Qgy/DavlpVO61N9w6MOCj02YYFPDi5et5WW6mnurszMPjMB+Y8XrZrO2lfZSNXQYV178Nvs1Wp0vBzMZ8GWb4lAnmMkuvlTHi+3BFgMnyyC2HxkNQ2RPm/z7pz8N8ebt0s1209RmUNYMC9wGeHMyL7wZ08SZgzSFAsJkKvnD/5NOLWPOG9hqlAOiygIWQ9VvgTW7+MJd7xDA16bZNq4qqF7+VIsJvMLvBM7oLlUgpUdCKSOTm95IHn+/d+E2m3ApfIZPRs1oV2YOLqGCrpEqg4KweRZk53eM6m1jV69/zEfa4nwuFA4jk9fa4zva9eF2VpirNAcaMmschY4xLDM3JpnyT49AcStpSnZrukyR293/ENWBmAgDDNXYzTcRBGLawx1sBuwttJnnCtPveq3dNdYekan4naV8XZtGYFufVh2lJmwSsT8cdkvD+zW1/J9cPz1ytE1OHugV6aYEIikTrbWCLlNi6LPQXRmbcTiIZ9TTYJwtSHG9ELxlScMa+RWfZtqgiykY1EYiBrQ7DaYEafBlOu490qb/6zepwnQCXq793g523ameaL3zk77TI7SEjXe/JVI43Frv3dIe+MFCzedXR1E2m+J5kr7rlOis5Lp5l5rapJmacdTDAg1IUp85EbKCZQBcjmYoEvGCnNZYoPfhJzMAdnZ95wrnhOSddEHbsmRXW7Nh/dy4CbFkwtwG6bN1RfWLs7KtlmheL/M20wH2Vgy4+vcjuQW7DEQgOurB49jZNI5xo4A0Qw2ejFum9dfOqsHr7+tJVdA68qAHiz7Ykbz/SCqWaNLEkSxs7IFPwtdSr3JyexwvBAUf4zinXz15cSsdr4Xo8I50r/FFFhVgRKZLG1iFvIRQjSJUbrZJM9aTeVkJe7/wicrrpdD2VjFIyJUo0F25/ph5YcRPTwarh9UMs03f3r7QGjMJ0B2DmzZmj6azd9d9cN1Ngbf22GQzCcJ2dhL6AMALVAdZZM4U1dgBhptvivAa+5L/dThpPPEylrkPdAj23ALaajoQxOb0Jt5MG3NyKef9i4ImyIm6f+Mzesycp/AjqLEbjlXDU2MhDKd7+dRheC9Tgy/DafmRKXrdhs0CWn4WvXPPDcPuv7tLnbqvbccccHp5+ybnhM1/5bvj5L38zo8EXpkF0+5Zmu6Ye9bJYb7+++FWb1pp9xrBinaOhVSr+F3lmw3VgUAGve1eY6XX7S4bibtiJ+/gDFh4o4zmExx97TrhIuxmtGfJ6N6rW0IKBLnhuqN3wdNmzgwbsPWhqr1yd8ZrpXccoSdKv81YZ4IU30gzAq6AG99MwAw8IeN8AQnYCulTrumzuwnDOihOMfOvm1eYN0yvwUtw9RSSWVknqfmtuNX6n8NHm/ptFuknWfsFRb9OxmbmJZTIEq19bBbItyfD42jbGyqW6oM4eLQwRTHbRnNIg1WhJjng/AxUoQpawqMpPefF78JSIWbQsXskoJVOiRCukY6RlXkbMotTBk9X7ZCYAMFwTNrTXUIMwjZZzEIafX6+L89q6MJq24yCMLc4rUIYdknz80ShxtGKM6XpZj26hpirVoW6B3logjq/dSltvIoPNbzB2g8l6F8YbYCVC7D5mtzPMJhPzLIEomeK3bB1sLch8sGCM9WEqW6AGX6aytUewrP/y1n8Mn//6D6xmK5YvCY/UuiqAMRc8+mHhr1//YqPftXpNuOrL3w1PuODsEbyC/lQJV9mNmrvcjT3aLjflFYvlXhu6X5htsrX+wyvfJxURTMFgJ9tqBrkw4DKyYOFML8L+xkV0U8lYYT7JIPNM5zpgJsuEJOxtctSyI8KrH3mZHqrnWhYsvQYexHt9w9Rrmf2QK4EuAp/6NZCks7U270clh6iDsQGeJAAvgBqtQBeqZ4OLIV0w992YBsrUoRfQpVXznrLk8MBng9aFAYhZva3sDROv2SV14fwgU8iiolQapZzpIs1n8cFajM2aOaaOwiVYZdK5Xcni86s1GyMZ6l9tG+dpMCeFzmtnT8Q8L75d0d3Ry7pzWXJiSDwquChbpBKY5Kww5BfZlDSGMksiuYrmcwuGFiQrCrrqlmps5dx9B7sgyQPmkcc1q54GFJwGzaZMsq5VEIamMnCdBeinUcDGWX8/iTpzxQAx7JDEujBLetim2kGYTQK6fV0YFj8eZRCGevay3gt9Sh3qFuilBZj6Hz3YkXYgxqI2/makH9eljPmxc2DMGK148nkh08bxkBnPk8+UdtcNja2p4zowyNZhWC1Qgy/DavkRKffgA1doMdtnGuji66q87PXvDEw98gAg8+5/viIw/WjRwgVOnnFnG7A40tDB1bFwLA+aw3jgWbWxsfBnXNUcAxtNMul8AgsDIDOzGOTiuiJwQ5pBloWUKK4Hfr1NPGrFEeHYlUeF55x8ft+mxjDInU47HjnoQie5o4+gizd94wsoU6ZLintmDp4uCXSprpnSdB1pYNBEHyCBOuKJM0eRCevXYz2Wz1sYHrXy+BBWhnDrptX2KaviR9YIxW8PUinRlBRDlK2wFeCoqSCTD6xVRhg6Cb3KdaI751EdW4IT8LSpv18a+Zhq2DzYQNSNIETPFJ/JtdHp8h2dUdQuZHnu+s09Ryi6FfE0IPOYV/6eohIug2CnFE+pmJEfi/ycOEFcMi5GHalf4QEzLQEY/7InuO4Os3MQht0Q982bXiCMLbbb7SJ2bdqG+2SDABiAmMmAMLzc4sO6MActXxB2a/zExgUA4KMS+C0wDmRs101Apg51C/TaAmbvzQ7rYP8RSp7NW1HrPOJLUKh2q9nbUpWGHYfAj1Qn610yeeOHVwx2Eq/1P5aAvw7DaoEafBlWy49Iua//k99rqsllz3hceOUb3xvuX7shHHTA8vD4888y8OU2TT16+OknNfHPFAIP2N16MhTrvhSj68G3Bmu9REuqsmS1KToCMAwciINuY5VTXZSO9jcaYajECMkuWzqypxydjl1xlIEupxx4VHjoIcdFgT4dp8uOR1MDuuh7oPH9S+lTG0+Vmrmasse0PYCpTkENvzWnoo78HnzdmW2a/rTD5lQPvuRTlsobRp8Nu7aGnwmIWb19Qyw0XXypDSxRuQFKDBKtpse5BLuflI9GF6toH0d6sFk2VlSlqGOjTorlwIlXwS/Az9DzeEpzjUZ2nVUe+FJwXk93f0ZDqnuMtlahPM/mmmPCKUkkSzooUwhRRqEjMtogvXVpPVOLe0V1nLYAjOru19FzQ7QQrIIws2xq6J6uH85bqB4oabydjnotmDsQEIZPrzskUTZrwvABhFkmz2HWhmHHpKkCYdZt2xxWLlzSshl63UAh7hjZUmVNrFtg4hagf5Dhjyc7Nro5dR6xHyDfXjFEbxbTSl7qROyUdCQ+E5Q683yxDjfxNjqWietWcwykBWrwZSDNOr2VPvyMB9sF3PqL34TzzjkjHK+1X04+4ehw4y13zGjwhTm77HjQTQBEYKCzZwrf3nz4+m/FBxdstNATFsYFdCGAdPvcdyO54S1yxS+a2+skptwU0+kYebng6QLfaQcdG047+BiT7ufB+oFG4f1U3RddUwW65JUd4ebIq1nEmc8PqGGgi+7/6pouBWObiD2QtsnrBxn9DrowdcAX++2H7m50LJ+3KDz6gLg2zM823RNu3bg6f77mR6tQ/vbTEKmpmCq9mi4rzn7nqG9iblLfNaFc6zbiXrbslI35JqqH8yd1sBflVPOUbgIkEk+zXMrgRJioHpGr5bEoM6ksKTO9FeXWrcS3lp5d6LASRK2IeNqr6+mWFaoQrVpVfRWeatL6BAmu0iK8AEEPeaQ8uKZJKNpoQPV1EIaHc7apXjBvnk1H6tZDYkDVa1Kb9/FNmX0g+Low/QBh2GEOIMZAmCnYIakd8EKz4Mncza5Z3pSLx+opR94W9bmHFuAtKF2ATtGWxXE6L1EBTug+oPPBW5SXrXrDmpijhJfq65/xLIDnDNOOYhAfUT72wOD0lF2fprQFavBlSpt7ehS2Umu//OHznmpeL17jd/zVy8OypYs9OSPPzNndsKW7FU+ZvzymwQPnqQobt283YITy7I2LbChGmj9CfKhl+IzhjrbW6Mmsu8k1Qx4zjOlBBwh00cfDs04+V9sn7l+DimGALt7ezNEf9KDZy5rMebKgi5fdLVjjchOdacNRAF1a1fPUpYcFPuvxhtl4j9aGwRumPHiy36f/SF0Jo7JWwfjKeVVRxJgGI+zDirKH7Jwpj8OjUNLYIj9ydXKUcDRIZmOs7FyMgtCfzh41Fs/L+TN2l/Fsk63+gPxCyCS00RkzB3P0KlA4QCXBqlHURTSvH5l5nDShFa2JXmYq1JuCDg9SgRbWgOFB9PRzjg87u5yC0WFJfWPjK5/s+iadVgbPWBbmnzM7vnRZMCYQRtN7RhWE6fS6euXrBwizQy+8duxqLM67csn8sGUAi/N+8fYfhktPGn/dQoAg1vLrNrBwex3qFui5BegXZMgMkC8Mt8aD/GGQoelgo3z4sNLGrxhrAzA+SHJxTZcimeRjJkCObVmNzradCnl1GHQL1ODLoFt4mup/zUufW9SctV6OP/aIIj1TI7zVAszo5qGQOcsrNFhY3yVo02sb/uEV77c5yb7OSzHoNNvLQebZDCu22UwwceiXAABAAElEQVS0ikogTMyORSsO39ErjwgP0rSiOQJZRLJwykFHhYcdelxK7R8nvJf4DHZNl/Hbco9eaXAPskbPKIZ+gS5+bTzIMFfepsg5cRJnqSoW++VN9bA8XTq5hBXyhnnMgdGzABCGD2G8MVH1rqimm8qtMDTswvjlNOnplIABqZTJd2Llik4WLO2DcnO02Bldr5+hV+POm5eT8yg/L7+IFzxFxDV1d0bhhCFVTnzGriLtLWX+rNdKj39xuf5WNM93HTp3e1Xwe/j1z+9lfB8efu5J8gjdM7IgDDbEQS2v+6DP2C68XWfN2iMvmDmhBmHimjDcP5NZF2addkjyxXkPXTnWNxDmoz+5JjzvYReOe1twr/MCbtOGHePyVTMZM9Jv16Fugd5bQPcP9trG79xLjXF8BEsAXKDGDTQAWzDzgDGFlQeAUZrFdyHDa0IpTQIvGFucF7E6DLUFavBlqM0/moWz2O51N9warv7eDXZ+zFmnhfe+7VWjWdk+14rFOBtuep0pZyBG58t5UAFgYNnCuWE1C+2qmD3F4DsaWOZ9GvhtBli1aAJhEgBjFZylqUWHR9BlTuONDbU/42BNMzrkmEFdRknvKOx4xMAZN3JcjQe3kG7pstsmCndSvuARCv0GXfJLw7Fqbx82C7M6zo3bRrPD0nQKpy6TN4w+63ZuDbdsuCfcs31jufr+my5TzQ6USOPcNgzLPJjpEC8PG4UZ8cx+nSlQZfSsP8l7dbi04hryPMUpo8gzAaUSiNMsl4RdgDqiO5G9vKiRnC6DRDLVMd5ODS8sk/q230WrBsxpeTyrak7O65OxNEWdL8/4j9vusX7t4eeeGBbNnWsgzKiBw3joALYOI9DOeL2OEggDGFW8lJniRuF+HsTivEwb3bq9ewBw/fYtYcXY4gmBF5rJF83t5uUbcjXwQivUYXItEDsgA0yKHiRpTP0/QItxWZoYNk9nGSFb0wVSkjUWex6JXjJ7lWeL9yrfFrmH1zo9ZOowjBaowZdhtPqIlnn5Vd8I7/vQp2yhXap42oMfFC57xsXhgsc8bERr3P9qjS3QQG5rdwM53tzbgKcYSvevXgADSzUfmrcrH7nue2EvXhEynNhOG7inCCueGwBD0eT7A1sCYdwL5uiVh4XjDjpaO9Mk0AUlScdzTpvaaUYMmIe141EOurD43yCBM76STgJ1oF6j4sI+SNCF9uh2kNuqDakjbUbbdbrYbys9o0BbOX9ReOzB0RvmFrxhBMQYoqrK2W89q2QjzY+3EQp6ESFPPKV05PcH9LYP/g215ViyF2ViTJkuom5Cnbd6TsJUi6y2weUqDCZXzVPa9XFtptcOSZhMQlUuUhvHifIbnKldXXGW4eVnpFK0ImIDYjGUvgv/gnLBnJbHE4+rLS7BCbmONvF2rL+RBwz9zumPPkG/NS2uPW/WSIEw9L2721W+zbX2m8xXUQVh6N8ADaY68KJmZ592Ouq17nwdBQgzX9tUC7jrJeSL865cOt+AVnZM6mSa9/ptW8J3f/Oz8JSTx59q5PXiPurFC3OB2rsOdQtMqgWSLeedAS8ODGjRGJ5hfHqPEDsHL0T8EVaBQd2QGXzi6niViHqid0zYJ1+Xoq9QAbrPjd37aNdZn6e0BXqziFNaxbqwqWiBr3/n+vCWv//XcNzRh4X/+qfPC2w7zU5H+1tgW8lNobs359s19agX0Ga8tl0iL5dFC+ZqsLHPtmdkXvTl11+bBvtRshiomyUlC+Orf8mYDTe6EczL5UGaTgTJgjFEdaeKfubhx3nOlJ0BGRZrzny3ixxPpoIOusQ3aaMBuvj18KKCxZOHHQYNuvj1cb22wGHo/gHFQRcGy+yS0Q8gx+s1CueHyBOGD94wP8UbZtumcrX4/eahms7zJogjii0hFGO0mOz8iLwUdSyf+K2APC4L5W/4WhZe4m1w+CC1QVHM65Si5Nm1ElEo4oVORYqRboXHlUVy8zHp4BQ1N7M0U6iBQjpZNMVjK1huPBi9BSPiGRnmol+IkulYYSrlTZy465f3ikmL8J5zgr0IYHH6+dp+melIw/aEMe+57pZqm/iCe+Tgu8hBGBaRpX+bShDGwBd5iYxC4K7bsFM7JOnTz8V5l6ldxwNh3vf9L4QHrTwkPLVD4IW2mmegYve/k4ULGt7Do9DmdR2mXwtY96GD2XId4svSCK/YHal+ydZrgQEDHzua2FsmEm88IiQTr9/kxG/AjEikCx2STCqmX2PNkBrX4MsM+SInexnfEPiyQgvtXv5Pbw6LFo5NVt20lWfgYobPrGBnl8ECbSu0ZWK3oE0r7YAuSxfOM++H9Vt2loCJu9evjUbXrKik3ejqDMmsqcVlWGWsuYTjDj5Kni5aRNcsbQRlnBWhUw45cijAC3XwfoT4oEMOurCt5WiGvOuc+hpOFejiV8ZUr9mzZwfu+e0793a0y8RMB128bfyMN8x57g2z4V6bluR56UfdSLaJTTjIMpsRheGNb9HaKKuSJWAy0lEKRixRLAEbWS2Dy1TPMDvNBfN0JW6mu4pAOI+dU4ITIV2/AVDZdRRpl4XX436GNpmQysuqYobRq2GXAUqZh6xvakQjT/Wyc7FSvKKylNcmcdcv7lPOLAEwx9taHACn0a4KcNALiF68BtoU1RU5vcftSmbQzHwvgDCALrQRIAwvGwBiBt1OHd8Dg26Eiv5BLc7LNNNN23YXAPxHrv9m+JNHP7lS+sRJXnZ1u+ECS70wZqxD3QKTbYHonQLsrpsKrxR7EYChloVj3hA/bP0TPAuSEekjuBl1QsIOiszibZ7PM0qyeMLsm21ccNZhSC1Qgy9DavhRKxaPl/UbNoetW7e3BF/uvuf+cORhB41atQdSH40p9SDYuWoGVQxEex300Hkv0dQiFntjlf971m1repv5mZt/aHY3PliobhXbaUZYNCPLyD5IU4uOO/hIt9WNDDPAEYR57unnhnk+/ajzy51WnNMDdElNWvlOp6qhpxp0ya+Lh5FdmjMwNn+2fkNz7GGl8UDZ4GRePd8ld+5M9HRpXGn72EOWHxr4rN3h3jCbS8ytbx8fcZVY2yZcR0e2TKpbfVdtlXsGVaKgdPaoZzedq3x52nUh5HGdGZwWIaNHA5nxFkwdRFxPUVBZD9ntgyrkdbJzTFRl3GvR9ezToDoOsFNb5w3u+pJi+84m5UpeKPTim853/YKFoaMHDOApH/o+3v7jfYaH5qDBhaZKQZi46i3FBk3k6wKE4cMU4sUCmqcKhBn0tfWqvx8gDN5WLM5L3wVowuK8d6/bEF7w4feFjz7vNV1Xjd/OPN3HfDfdBNttshuBmrdugTYtwI6EdC3lPgFoWYCM0Q2WMVvHIrzxJTH8MjLKt66BKAr4mE3kEDeSgAEZ6xx1m8NSh+G1QA2+DK/tR6rkF//eU8K/fvxL4T0f+ER4wyufH+5dsy5cq0V3r9Giuz+97T9sHZhrrnzPfjEViU54954u0Bd9kww4bd0Xs4CdfbWALks1GOPM9pWtQBfX9Jmbf2TG1A2m2VU3sOl89IGHhQcJcJk7J/2sxZTsuasxHafIG+aMw46ZscCLP6izbTRvHkfX06XxtRDjO7WOs0weWGqYoEt+UUyt4/7nIW7xAr0h1m+PhzgC7cG20SyEPd3XdMmveTLxAxYsCucfcnx4QCDMPds3hVvWMyUkC2YcukhnrBbFbiQa7V81aWZuks2pijYGfXmO3dk5oTnu+pJyG1x6JRK3/TZymsuQrzj1hFQEFxAdMc8zm5j0FPRClyKO3CSeQl+nkVwuj08knxraqmJyUdjbvzrIRp3RdIYToKbn0KmoKnfXL+L9dsIZR4cFC+cbADNMEMbu0Z4vfOoEAZr5AMIAVrFO1VR4wkzdFXZXkoMwjJuWzmNdmO6n7wDCMP3ozrUbwud+9qPwtT95g/X5WzTtqhsgpdcNExgr1qFugcm2QAN4EUAiW7xXlp3zvugCo1ScUkQnZnCMOjFeRMUuTkR1EvQb1suljhCKedNYf6Y4bMgYJ7H63p3s9zYZ+Rp8mUzrzTDZN732P4VXvvG9gSlI6+QFQ3jkmSeHl73w6TrvP2vAMDDi7Xo3gY4eEIXtJycKDL7wdKHDBxjYIVkfYLeTvWudphxhNLGwGFoMKQNmnY864LBwfA66JCU2njYD3hA9RXyPOPK4xDH8E29Le13orlr7KuiydUd3b7Gq+oaRnug+6EedHHRR7zv0HZ7y6+EBbrM+C+QBtli/j926NxjcbpNb+Y7JPFjmhcyg+IECYficJm+YnwqA4dPvwP1oAzwpNnvCmYgnOinQbJYY/dyJjPO4jM5WlwqdasQBaMqAX8Gqp0NKZhHPTIqdQbxVXXGYappMZ34w3oKQdFm6NX/BmkUc44limVzVCFgWg+UYrMp2EM2JRUQ8Tkv8fT0l3Xfdfm/gc+GzzjYAhjKG5QmTX3pfr3VAyhyEwbb1G4SxF0Asyj+NAi+uNuzcFTbt2t0TCPO+734xHLvi4PC8h58f7l233fqOA7Q4L10G4yu8jiYKAP/cv90Gvr861C0w2RZgmQCz24Aqis/yhXOLTjNBJsVPO0V4kxAFJQfYkvox3cq29IByDYCBnY7Spi+l2pY6oESrT1PWAjX4MmVNPfoFMe2I6UePfPip4cJHPyyc8/BTWk5BGv0rmVwNmf6DnepmUEcHPyZQZbyOnrUtWNAX3TYoSG/3J6rtZ26KXi8NOxwrh6fLcVqzxTxdRCqCGdr4vJFMtFnk5z70MSPn7dKPHY8MdNF3Rh+0e+/eMB1BF//u9mgA2OtbONfR7uzgFPnD3la7XR35bRBwj+WlIqDmUKYxxGpMm+NpKw4NfPCG+em6e4sFenOz0OvFJHNSmJ9e9bic67M0FRShRHPGVufEX2TlacWx2ZC8sjYgTQXkZVg8ly0UViKd8JREuhYoSXunU2ihotY6iU3pWHfLiERddJk/8eZyTurz+ZorrxMA88gCgEH9VIIw2LTputg2fR+ffoIwvAAa9k5Hvd5i3YIwG7ZvDR/+0bcMeHnaQ84qimXqNh/GYwsF4rPezkQgDLt4sXZfN4G+irFiHeoWmHQLcOtxQxkgIgBG5j1uHx1B97h7aXzp6v1BZAWAx6slAi+eZ7roF0Snd5gt5viiE32RFteYmXTNawU9toDan6+5DnULjN8Cd/x6VbjuhtvCZb/1uPEZZ0gub1C63X74iAMXhlUPbGtqgXwR3U3b5OnSZSf/0o/8r3DXBjxfYjju0KPCgwS62Ig7H2AzAq8G0U4+5Ijw0MOOHTngharS37Dj0Wa1S7chB12YXtTt99VteVPBv0Brnwg/6spleqJ6lUCXEW0n7gOmF/Egwg4qO9Pc+/l6mOCBgt9ML28mJ2qbmZpvU5K2bQ63CIjJTYRdb7XHb5EumZLimSRS+a58a2T0GTXX0Spub+jEnPJKMm1pGia6Lufh7DQKT+lCn9J5nPxikGnxTMZkdXC6sqw86BCNHs/Enebxct2cHzZjRsBE0iGeUhbD36gnsplMJmdsjUNkUtraPuNDLtJiWSZi3Io1EqmQwZ0ufHYZgMlLwquAh9tBrAmDFx/eHm4v8nKnWxzbhw3cow4A0LmX/myJFuvfsn1X6Racbu2Q17fdDkkbBby89PJ/Ci94xPnhaac3gJdc1uPcIwAwtpOlxhlbWRw686TEXhyiNWPWbNhRort8uzP9KmvN1KFugcm2wPHvf4d+s8AiuhvpWPRPHKiEFwhatUX5Sqfs2FEpUeoLyEw18c6Jvlv3aYMPHd6vzgp3vPzPJlv1Wr7HFqg9X3psuJkuxrSj6274WfjyNT/U+VZb84VrPveRp4Wjjzhkpl9+T94HDJbokDnzwJgvortmw3Y9PPY2GrYpR7KfBrocKtDFA+oYeWOpCa7eDbBIpxx8hKYZHW/Zo3ig77BL6KJyJTBBHke9DFK7KG5KWXdr8VkeVvoRvJ1ma/BpgEaXoF8/6jCRDr57rpcHD8CVzXI/zwMPVbwd5g3j/LlzNR1wd2MckTPW8VILFFOSVhwiT5j7IggDh9sI566mRcd88L3YuK5FvtGVD18+9nOVgzxTndzkWVlWkVRqqjckH4jakDZV1OQTa6ErpWmbgkZEIQ6HlbAyUkHpFGmRr+Ux6bA8V+GJlgKR2GjTTAHyGjQXeZYV841m+ZL364xZEMYpqX9Z13zi2nDUSdoe/VEnNikdpCcMC8ZjH2ZCKHnCzJ9rHn/dvlQofrczoUF0Db4uTA7C4O3yWXkDf+wPXt3RVTYW59Uae4u0OK+AmK3yjPEdkmbxcKqQAzKdKGaMV4e6BfrTAnEFFsAWQ1hkx/19BTYdK84xYiqKacei2dCLWzB2SsA12kNSeYohZOQUQVimEhEofrRofZjyFqjBlylv8tEu8Pqbbteiu1eYlws1Pe6Yw8Pjz3tE2LhpS/j+j28Z7cr3sXbM5e32bRpus7zh40GRz2ZtfzjeIrqdVPezN/6oDLq4QXVhs6KysDZ+iCbVLKvSp8jj5RFHHe+c0/7sYAIX0u2gdLpcPB3m3LksFDy5GrMz0Dzdiwa6jOjaN7b2jBZZ5HfDdqHtAm0SF+Sd1bQgbzuZmt5ogdNWHhL43L99i0CY+8K9W8u7JDU4U0y2gzYfNygfFh72MD0lfiNUpY07MVfzYtr1pZFhJLbUlcmn/CbZilwx/UiiqSap0MjYeKOYGLIiWoMsWQFZNNrhZh2wEPwcU+lYajzPoZYK6USkYDNakVHwuBOzl8FgvQhZtKD1OXLXz9kJKbQEYKAPAoTh/uv2oZm6jHJoBcLgCTNTQKZe2t5BmBvv+mX43E8EvLy4M+AlL4v7jx2SuGfYIeng5QtsEfddeinRy9RWduirQ90C/WgBcBGAfmy2gSrJiOP9Yp6b3LQKHOkHLEnC1nCJkjhzeT9nLw0A65GHjZjlKwFF8YTkQKjDEFqgBl+G0OijXOSK5UvCyuVLw3//q5eHcyqL7L7+be8Pr/jzd4XP/J+3j/Il9KVugCcbtnT+BMwiuhg03FuRW7d5Z2Ow3EONtmiv6436rNq+U+DLkWYrCzUYTgJW1YMZUwgx82Q8XmYI8ALogjs2VzdTQZfG10h32XvIQZfNWmxwFIMv+MtDUzc7GPEGc/OeXbZbyCLN5d8prycW5a1DZy1w0NjicMHhxxkIc+82ATFrywv0MqBjOpGZks5UFjbOZJHp5etomK1GqUaLg1H7PThP9ewSTietuA1QU9xY8nrBm0K81kxABKPZ6DYK2Zx6v7C8HFfi52peNe18XsEi3TrSEI/1MC6LVtPkJJpOMSY7IgUG2GTsrUtyapWRGnQXJgJg0NZPEIatfksgU3fVHWnuHITBy4I+EDB9fwRhduzeHW5a9ZuwbGxReMfv/nFYvW1HwBtmcQ87JPGbYE0YvF/oRxiz8VthzDfemn3Vm4W+tg51C/SjBWzUp/syrtEijYXhln0zOw5HsnWYZeVHa60jXi4i4cBlADw3s8ZFADEEy0uykQQFZsuuD0NqgRp8GVLDj2qxeLq86y1/2rJ6lz3j4vD7r/qbcNsv7wwnn3B0S56ZQuSBn4HdRG/VfGoRRm2L5hIvlsdMNx14tb0cdPE3MRu3xTVkkh0t28tkQwsdZkxVEf2fdfT08XihjVvteFR4uuh6RnWB2KLt+xrRBXcZphPowgCB38hEv612TcBuIXsExPAwMle6AORsrNJOoKaXWgAQhg/eMD/fuCb85L7osTCZNnRZ7JTHS4X2MVE1e9g7DKPRU9yKy+OwqHI2THXeVCeXs3OiRUObKSBKYCRctsJGNqOb01uxUUCHwdrRZtNkQhatplGYaEVWjPj3EL+TKk8nFSkUtmb2Nqnk3vXz1faVnNpiClLO6iAMLy4WaTH6PfLuYG0n7/ty3v057iCM94e0FzawCsJMx52OOvleAV4+ccMPwtnHHB8efMjhJsI9sl5TVPGI6RmEkSZAGLycue+W6h7sZHFeKsDYkO+jDnUL9KUFeImk2wnvFEIGtZgtNWLKt22pReDuA4Lhz+LIRmIE3kW3oA7A1pNJIE1iaeiNXPVxilugBl+muMGnc3H/ftXXp3P1u647nWu7B0RAFzpq3IE3qwN3wGV5eoviA99OC62CLsjdfu/qhnjDjrpJjXmJnlvS55z5qIbcNIgxiGSqzc5d8WJ8kMk17V+gizpT/z47/N72J9AlbxLW+WELahbkxYW8XpA3b52J4/FN+uxwxvzDwinLDwn3aSrST9feZ2cGZ70Gv3/jA7+05CO97N4mCk/ZmFVK9fzqucJWJJ0PguLUxcpwBi8fvmpIoIrVS3lF/RJf4f2SyZr+qh5L5xVpydCW6O3m7WiMXu+8saq0StqSieZZvdeqTXVdcYvsO29bHfhc9DuPCvPH5rfgaJB86+UchNkmcLaT4O3VCe9058HmMT0TkIW2mi/PjxyE4Tc9XXc6avfd/Og3d4Tb7rknnH1sA3jJeScLwnD/0G73a7HdTVLM+mOsC7NyyXytCdO8OK+XXQMv3hL1uS8twAy2BI5Yx5XS9ER4o5pHjDoFA17S/CFAF/o51neJqI1AFnijKh2JKVhnEr1j4suHBn9kqI/DaIEafBlGq0+TMll09/Zf3RUuv+ob4drrfxYeWLcx/P5znzjjvV7862FOL+CKB98ScrGAF96YPLBphw1+PJ8zgwF7A1UaPecc5fgmvbXfqDc7rcLP79UbaQa4yYYaD/bWbWoulPie83ANdudMr581bcyORwTABAaZNr2oxwWK82aZjnH/fserO+3EAJx2GtXpRQaiyZV7sp4u47VDaUFePYxMxqNmvHJmSh73Fu71mKdt2+V9lOzUQQsXhwuPPC6s0XQkPrc80GKXpC4aAbV2H+uMaeo0wOtyLmM0T3DG/jnRlSdaK/lc1Lxf0jXbmJVMCcW4K44Sdg0UZoNd0YpsjzTntS7f+aPe8Y6pai1Y/EKVZdFqGpFIq2bHwXfMZdFe48zEjTCpA9fXOlx9+Q86AmCQzkEYXmyQxr7VodwC/Gaxc1UQxsAX/aZnSgB4+Y/77w/PO+fcCS/JQRi8YfLFeScSrL5g83VhHISpLs7r+gD961C3QL9aYJbWbsEk0w/NpqPBE4agztB6DyXNbzMBL7GPTDKRUcLJX8YE7CBx8aBU2pGJLxHo0kSHXIehtcD0ekobWjPtfwX/wavfXlp09wnnnxUuvfhRtg7M/tIatjVh2G07sfA2xBbRFegy3iK6AAkMgvZM8OZuPNDF23fHrrRmB3Y4N5QNu5yG21ECj5fpBrxQc9qLjmHu7Nk2D3sm7V4Uv5nujkypiR1ls1wOumwa0TVdqDv15DwVYAgPrCzIy0Ca3ygDaB7c6tBoAf9O5mjnq+1qq3a/sYMFwvB5yAGHCIDRLkmAMD0GBxLsXkZHsltxNNmpUgyfCzZkoJDTFHJ2xamD8TmzqVIiASqmhzxFPG7nXHEiTOz90tBr4nmZeTzXrbi1D2V0EowvYy6iMVLNtgYo9PLmNCaK6hTyBVMPkfGVXH359wXAPEYeMBFgn6gAB2GwIeOBMLQbtnJ/DVUQhvagD61OR5pu7bNTL6Ou+PG1YcHsueHZZ5/TdfV9cd5OQBhAlvwFmxfmIAxtulTbd9vivBrTbRW4Rfsu0lSlOtQt0K8WYPtnOiDzYpHSOJHIIgJJlHKwxBbYjX2VlS0ZIJjYN0WrjiqC6Uhxg3Asjr9MnH47qx4ixYYa0rEGX4bU8KNe7InHHRVY4+WRlUV3R73e/awfoMABS+fbQx1TizpZRJeHzTF5JHBuFToBXVxux+5swdRkREtPHKIxOCA8/aFn2Va8MTU9jnhuMMD2AfR4O95MjyvqTy33yHcUICHfmny6gC62Dovqzv3f7gG/P63UrIXyWESR+2qx5u/v2LnXgJhmzv2LQnv4Q1k7u9SqRR5y4CGBz5qt0RNmzdatrdgmpBUP/LPjIFGjv+aAHRuHzls6G1Q6n5+bNUVKnp/HKUZpH6CW7CmS9jqQASqD2lgl3h6WKmf1TEpcWVPdyzKuT4qKgFraxtunyCgiFaWWzGhFNEaq2WXFBbNdiqeoJaGogxMiuT9HFXb1v38vHH3yEeHUR5/YsU68XphG0w6EwfPDFpjsWOPMZHQQhvEK4OrYgnnmMTQdAWgHXh56xNHh9KOOntQX1gkIw+6U28cB6vldbNRLDqYgMb31gGXz7bfCovF1qFugXy1g4Ao3G32C/iI8ErWTR4fEHWfdDWcz2OISvdFRJbrsIoAMGRzthsVWWlx5qDMeCHUYVgvU4MuwWn7Ey33jf35hUcMvX31d+PI114X7123QTkjLwhMvPDs8WV4w+0PgYWWr3hR3GuBdofnC69vslLSUt3n6TBRe/q//HO5c+0Bkw+oSog2OxjalOT3jYWeHk1csJzotQrGwnbbiNu8NefAeccDCsGpfXFx4WlzEACu5RMABfStgFG/dmObG4I+ty/UUrc8AC+9BNZ05b6hZbHrT1t22BlIY8ptBHkSWLp1r3rsMntut3dTD5U4bERaSXKb7Z9vO3ZomKTBM4EfozPmgdI1HLlwQzjzwAPOCufzWm8It92dTkqSyADLSINGEoRPRufgoOlt/hH0CymysmfJNB3FCJlvQoVV5q7Qka/LwMv/dZVSexRPN3vqpAgWNt4CJZ1ZxljymHz7kRI9xnS1OfoNmW4JyUYk/1oO0647x2SJQrt2T8O+lcMSIR+AHHcXWUxYnnT4ojP9I2T8njycNShqxcTaWQtDoPtDnN0zgQb59SEztGco5FfablLvhmeeEJ73oorBkxeIy7wQpwOglK6L36SbZQUDWZUxNkhfC9rmd988TFDOts484UH3oA9sMgFm6ZKF5Z2CP6UemGgjvpSH/6ZtfDV+/+ebw/EefF5704JN6UdG1DJ6Sm7Tey0SBn4XtkKS2XCIPLjyh61C3QH9bAIAkAipY4Wg+oYmqDiPSRLUIAEuKEqNDUf9rdpyoycNBxyUduoGjjYcmkvUzMW6E+jDlLVBbkClv8ulV4F/93b+ET3z+mwJdloQTjzsy3PHrVeHP3vqPtv7LC559yfS6mB5qO+5YtI0+BjoMFicz4Nm4VUBEtKClc25cKf4ZZ54dXnbBE9rUZLTIOejCIDEPeHnwNin39sjz96c4U2gOXLbAHi4YOK9eW26rUWkL7sUcdFm9dvuoVM1cyddu2mk7WeAyDsjXDYg6MhfSQ0WwPSwYif15YOOOvm3H/ZADDw1vfuyhVqOP33pj+LiAmHKQweKmwG5VA+M80f3hHq8FIyUD62/02spG8WzAWS7ATGVWrqUpwIPKi4NYEZRZKg8+X8IBHCTxWmGiMx+fwa3L2AA5Vj7ss3xk4mXbW0olYyrRSKLC1KgeDHyzupKdB1QT2rJQf2NIHDHhxNhGXoCfnd95SUsLZdEu1In6RW8S0XI54438FrUKei2LzOZIqp5dfMr9zievDXzeetXruwJguJc36IUGADTg9KErx6wNt2+pgRealr6TRccJeJKu37xTgP0sA+9pK/oRgJjJjElM+QAOm3dsDx/93rfDkgVj4WOvePUASmit0myQbuNugHl+FkxJqkPdAv1sgcKTRXYuvhFQP6F7U1t+6MNNCrCCzbUOyuw2nQAUzsQ4zaJDcpkEyMRc0XXzRh6ippysOgypBWrwZUgNPx2K/d8f/ZwBL3/+p88LL3zOE4sqv/ufrwhv/4ePmPfLgSuXFfSZGOHtcac7L/j184DR5KrumR2eN8rFH1trY2AsrBnYhjB5T5fHy6gDL7Ybzdgcc9nljWUVdPErYueahbyFwrtjPw18p3i68HDBgJAHZxaUHbVAPXljuGKxdoQQqDFKoEu1rQCymH60bPG8sEgeRDyUzFSAD9CFN7JM02CK5CCnHTz3lIcGPh//2Y3h5jX3hlvvv6/c9C1sVs5gNlKEWaozto2H/zzYIDFmxbGoZ6I3C8aXRF0my46DTRHiWFMDVLx/FPBkMehBA1Srqsi2OCEDVhEMREmAizFA041vZTB9SvLRxqMs6bdMDlk6KjNQg3GzgU+xCOMb72D1Go+BPCtOBz8bLV1TJDbyKjymWjS7KlTw0R9fCYs+7iVlMsbZOBgtZVDJCQO8Ysx4/+oZfxse+9uPCs9+zVMnlM4ZchDm4BUL0q400RMm59vf4gs1JQaAJQ8OwqzfHEHyUQRhtgh4eckH3m/eLs94xNl59QceZ7voXsAoxoR1qFugny0QX0VIo9nICJQQdZDE4ulgJ14IyD5HjxiAGdlYOjnR/C1B3PkIi472aK/hoEMtyiNdh6G0QA2+DKXZp0eh13zvhvD48x5RAl6o+av/6Dnhw5/4Svj5HXeGx5x12vS4mB5ryUMmD5stB6FtdLKg5ULtlLRpW28Pzq/44P+OmmUvzVgqZaYz2VYjivCyC0fX4wXQxR8ExwNdvAnxSjgID4X9EHzh/uKBme3LeTgDdFmptYZGEXhh4LlYA33qNqoeOX5P+Zk2BXRhKhIeIbwhZirSTAoAdoCXuMav3zx11/bcUwXCnBoMgLnilhvDz+5fUzQrNsvsl9stcopBYrRpvPHjXR0PQoATDBUtpFNM6GiKoh12dYnkY82GnPMmMWy32XBLaxhKHcRjbAaoaDDKeBdARfWwt5BJB3LGCJ9AF5uuBFH/thCisg3YIR+9ykgnRSOQYUNfeSPEXFhiGakIEdoHeJBrGSxDBz8TsTjcqitJz/OzZSUmp6WkC0ccLH0vqiu/n4KlWpG2GZWrs8qUhb9z5fetnpe+6OKweMWicuYEKR6auTa821j8FGCBvoPpSPtjoL8d79oByfngqUg/y3o6w/aEwdvl49/7fvjka/9sKF/Z/HmzBFC3vYFb1omfPmPCOtQt0M8WKDxfzGxyT2K/lUh9Bf2NTXulUOPZG70Uvb+BiJjlKSIPGOBz5CFZn6Qza72EPfpAcKLodZj6FqjBl6lv82lV4orlS1vWd5HWAdi2beK5si2FB0C87Zd3anemW/WANSc888nnhwXze1jcoE29cE/dE0exbTjKZBZwW6E37b0CCcWUI9RiObGTOlsVUvrfXj517rnlqxs/VQVdHtjY2ZQZBtO8ud+fAle7QAM593QBEADU4LsetcCAk3ryNnWD6tlqh4hRq3O1PtT5fgFbrKFzmB7W1mkaw442C2NXZUc1DRiGtxRrUz2wcWcxrWeq63v6wYeG0y+M01CvuOWm8HF9Og087AuOsMGkTXtJD9YiR7vHmYSHcX4fJpPxug4XtTRojwJgC8hP9ILJygKIgSFNN/IpSQ68GOiCDg2OC/141PibR9WPIe9sPaPt0++FJV2KKhMxIQpI1MK4Q/NgNbCEi3hO6WxsHPRxEe+rlKaGMZkys7xcxnJd3gpQvamf+DHLrTxhYE9XUKpSTCRlzlDS7cQQvnPlD+zzJAEwT3rx41roaU/iXmEKyIYte0vTkfZHEIaFYzvx4nAQhsVjhwnC/NM3vhpWLFoyNOCFu4o2YCpbN4F7rg51C/S7BVgLzSBu2cloV2W5davtU+dhfaIKFByjvwiqF5Y32VXMunVJJixB9aHxRQI1jV6MdufCaBFpSrL9vpZaX2ctUIMvnbXTfsl14WPODB/69y+EV73kWeGgAxoLuq7bsCkcf+zh4cHHHzUS7fKZr3wvvP29Hw4PPuGocOMtd4R/v+ob4UPv/vOwbGl3i/q1u5hu12/hIY8tDFuOqdsVktE32K4ispAYSTeWbjNF+ugr/nNYOjaWSQw/6qAL3QNeLDwI1qF1C/C1OujCG4+NGgDmXi7xK7cesrWCKaQCurBWDwN7BqrTEXTJm4u2Zd0IpiMtXzLPvEWm44K82CR2YmMK1dpNWtdF51EJz3nIGYHPFT+9Kdx03z3htjXJG8bsWaplizgeFpAZbEZPlMo1pZ9E/H34IDXqgzNlx8GrJ1Jxeb6BJkJz3NsFQ82g1kavBsggHMu2GkV0SAWIjpzOpg/ABX6R4SObATRePIBFAJVoiocYsbqTiQIPJpgTPKNxRs+4HJ5JAQQ76aB/ahuTdizlNVhTngtHAUtx+QgBwti1qwxIE9YJDjHCVw4Z0XSH8KV/+VrYsmFLeNZrnlZmnSDll+v2KV8TZn8EYSZoriKbKUp8phqE2bJjR7j8O98LL714uF673JN4QnbbnyFTh7oF+t0CyQyaWoDuCMTQ1zRAGaj0VMmAx5cHSIhElxItbXyjYF6Y0PSxKUlkm7Q0Q6cfM12WUR+G0AK1JRlCo0+XIv/weU/Vyvlzwmve9L5SlVfKG+ZD735D+NDlX7KFd6+Vx8ldqxru5iXmKUj8/f+6PLzpdX9gdfryv78jrL5vbbhSiwT3K/Qyx5cHiV7ekrziAx+ItjUZzgh/60pIK3z05QAvC2NiBI6ALgdq+0V2nmDgi2dBde75CFRzZKrAG8oD5fa9WOvgALoAUuXAi1eU+2eYAdCFhWpx6WfnLtz7ux2oDrP+E5XNw9pa2l7u91zndNm9AtAFrzreWvO9sLbLKAEvebs/57Qzwlsed0n4iwsvDicfdHCe1YhXnsy5622ai+5/HvRtXRXxmFNJQyrGkG33gSPlmSw6olTUBYCSyeKO7el4TmlGSGpz1jGMnxhXxcQvBcVZfFr0dPbs2eYwY56SrlNZXrbXKcopI+ngTHXGC17dtjzYDAqywlI8lcxOTKbf8pzH6+VENLscUeiND9/LXr2JRQ/NwoDf9KIbXvvkIlGWB4mmv8SeqQ/fvuL74bXnvVEgTGdbmreykQ7C3K8dbObp+2A6Ems91aF1C9BX37tuu02/wabQl9OnDyJs2b4jfO76H4cXXXzRINR3pROAtJuFdl35mKaT16FugX63QLSfsqyyofzFIBgGm0qwTin1jUYQL/8FkE8Cr2n6Eewxtlk0UqiwT9QMFXrMsETpsGfPnnD3PffrhRtATh0G1QJ1rzSolp0hej/1wbeF+9duKF3Nzbf+Kvz0tl+Ff/vU1+xD5hte+fwwrN2P7rt/XTj1pGOtjgetXC4Q5r+GZ73kr8L5j3poOOFBR5bq3kuCB9Fu3VPN+0WDmD1dTmtgoV0zlFhIDKadddD/0858hLwQRgN4yT1d2AbZd1ropX1dhofIORow88Z4pgVAF+bbt/J0aXWtADK9vJlrpasb2nzVc7nqyUMMD/czCXBp1Q54abGgNuChARojDGYw7cu2Hde0r3Zb2be6xmHTzjj0sMCHcMXNN9nHB5NeNzN1bvNEJM1QEZK7XReDRRGNXwc7JyXt4ik72tISrxRplAqoEqcexTRlGk2l20LAkAFgrDQUGIeO0GJqNgNd/Wb2iAIdTMVqZ+BKqigkkxFPVGGUSBbBeJXyAXcjtxyD1VVW9RinZ1I7BdeXkp6OSeeNrMUlukx0e0mZOqk8Bz3MQympRxdV4ZpNb0xYExg55cZ45IMU69CgQnjjU/4mXPpiTUN6ycVZRjmKbcRGtQsOwpgnjBahnslrwtBnTrb/zT1hWG+M6VysCdPqxUC7Nh+P/sGvXR1e9PiLwu88+jHjsU1Z3lzdP730bazNVoe6BfrdAu6pole2cW0X9QXVHseNZW7796mjwtTGxdEVt0wMK/2a7CMmkn7F7XkikaaEavjE574Z/j/NIti1c1eYv2BeeNNr/yA844nnVtnqdB9aoAZf+tCIM1kFXi588G65/NNft/MD6zbaJS8cWxAOP/SA8Jev+U/hnDNPGVozHHLQyvCz238djjnyEKvDySccE04U6PLJL347/NkfXzbpevG2uds3JazBsFAPst2uKbFxi8AXbKIZzXTW6WmPeER42eOHv7X3IEAX/4LY8WiRgK5e18pxPaN07hZ08brvFQBFW/cyQHQd3Zzpnw9cukC33f4BuuRtw7gEcJUHOqbybNfuSJu1cGcvb0Zzvf2K5+u68JZ6OofnnK4pSfpccdNN4cZ77gk/X3N/vBy3eUr5eJEI3w0DSxtiyg7boDJ/IYdcFkzW01nCo36GhTi21opOZwaq/AYKmoMuKtN2ZrLcJKi4T5Has1va0EEdFUw3MkraQr0CZ1yvMcLhZRmziZXGyZHS/hhLSmUZGxQpM31JaXXQHTMTt2qUlR0TLo+qPNNE8sIMhKFErtEeFcSPhNcLidiSMcaxklkhGIcO+8IXbRrS1vCs17aehkSfTB87UTAQRgtQb5u7x7zbli6ceQvzLpDd6pe3aRWE4Rbg5QrTNHsJH/32t8NcLX4E8DJKYUxjM9bm6yYwBuS+q0PdAv1uAT1hSCXWUjbUbrFoSyknvhjQD1F0vC2jN4zSMGJzdUKkAGWI07coDzovBVi+jD6U3zMAjXltksjCmgfWh7e880N6nvv98NtaN5PlG/7y7z6gl9hn2DNgxlpH+9ACtQ9dHxpxpqt4z//+RHjRq///wKK2Tzj/rPCOv3p5+OYn3xP+6PlPtUsfJvBCBajT+//PVaWv4ZmXPjZ88GNfEPjR3YJqJSVZottOlzfq3bo7/+k/a8qRAkaUj+ywfUYBeMEjojq9aLJv27jWPPTSZrn8KMUBXfCkwFthvOlF7eq8TdNhur3n2ukaj86DE14fAC8bNchmGtRUAT7j1WsYeVz3Gk1X4M3+QcsW2A5Uw6iHl8n3f8iKsTCmt62s6zKTdmh6zhlnhLdeckn4b497XHjwwQf5JcezjRgbJMwgAAzfCw/5tqaKeOIgNZrJghvZ9PF8z0MPwc+WYJBalXHdGh3FvMhD3AatjJr0Any2HnrxkGEizj4eytCFDHF9ijjz9pHhx5ZCtQ6WR37+ceamc9KTnxqq4/Uj44XoHKNFJGpUMopBhyPLLw3MUz40vE34ENeHAT4g5T6tXkzVrRm8bLHwoBBd6hsyUTbVL+mxsq2W4kv1+NYV3wuvOfcvwtYWi7azs9d4ni9UIQ94cGDb1mn6JDsR4gmDjZ4JgW2m+72tvE9H2rBlp+1uhx3qZvr1Vq3t8sy3/1143nnnhd85dzS8XfLvGm/mTsC7XGYq+uO8vDq+/7SAeVhi+gh2BmTBOtP3KK6opbC1icfsKkQR6BeTYLS3IkKhA4MfJxjsLinbvtr1wJPC179zfVi+bHF47tMvCnO1ccnvPfPxgRfsV3/3Bmepz31sgdrzpY+NOVNVffHrP7Atp9/7tleVLvGSC84O7/3AleGu1WvCUYe3mdNfkhhM4rlPuzB89JNfDUyHOv2U46yQcx95Rgjvvzys0ZSko46IHjGTKZ25vt0+lDIo7cZjhilHBXoty0n8qWfJ4+UJw/N4AXRZpt1UCP2aXtTue2AwPd0HOObpovaii6wupNvuulvRmXq1cInWhdEUk0EEOnN2ybFpLAJdWKunDjY+sbWLAAJXaEFewDMeQKZyXRV+AyxyzKLMbDs+lWVP9T3w0MMPC3wIV9x4U/jEjTf7GDKONslg4JhCBGCUxYBUtDQU9WzjhZ08gsU9EUmlY+QFKFHMPVUkbUNWV5Se0eNW1Nhl5SvPpkdSD8nGuii+B6CFN+rwKM5rS8nzZlMwhZU9i9eQBCvThsOmz0bYDJCVbQPkGIm8ExxVmsqiwgrpVDSGEwt6zqTyRLd2LPKLCBUx6ZLOQrzRsIahiIkq+3fj05Ngd87YUoUCIpXQ4LQMJf/i0r8O5z/33HDpHz4+LFoap93yG+kFcHAQxj04ly6cNfB+rXKBfU/S53QDRHVTAV6w7Ni1w4Aq+gs+43nCbNu5MzDF6MBlS8On3vD6boqaMl7zVtN91a1nI/dMHeoWGFgLyHi6uY29guymgSdYZ+xiwy67vbd8ZZkcLNYPwCpeSyOTtJkKHaLBN91IeLh3zdpwdPasxLPL0UccHO7RGpp16H8L1OBL/9t0xmlcqG2ljz/2iKbrgvblj70jHHlYfHMJ+HHEoQeGA1Yua+IdJOHBJxwdLnzMw+Qi9y/hQ+/587Bcuxzd9svfWJEHa0pSPwJvnzeF3V2pYvBJR89b207CBqYcKRRjbtnJ39Obo2EEHjq5ZsKgQZdhXF+/yyyBLmnL6MmU4Z3wZHS0kuXeykGX1Ws72wq8la6ZTGNgzoK8vGE/UF4wWzUNadDT4fhuFust9mL99tgSdjqt69KPe+E5D9WUJH0+IRDmJ3evDr9Y80BZrdrHLKkO7lKNfYXmaRMQXynAkGge9TN8xTgV/fpEVunVIJW48WogSpxxqz20SYjvi497w8QhrvgAYABdtBaHgS4sXGgATQJgkNWf6U0DYVNEZbRgrwpIlVAcIEf/VosooCgRAjXipLT+YyrWImXolOApF7GMyF/oFA8qCCUQxsspZDO5xO2lWtLkpcPaRlM0VCH9jErVjS7zVrKLpHO6Fi6kFCL9Wx//buBzgUCY39aOSKxzUuUsiU2QyEGYFUvm23da93PtG81BmLlq93YgzEe/+e1w+Te/Gz71xtEEXfzqunkh5jKcWXy+DnULDKIFsHKNPgzDGS0rNg4wuxEUx6bqz202NtX4JGN0Y458BRO9g9lzE47q3L4n5Rs3bQkLFsxvFKXY/PkCW7fUY8RSo/QpUUO5fWrImazmyRc/KvzoxtuaLpEtpwFcvviNa8Pa9ZvCZX/8lnD7r+5u4psKwltf/5KwfuPm8PTff0N42evfGd7wN/8c/vr1L9bb4+i1Mdk6sB5E2QhOrJF50rg4dxJe+U/lXY4wrB9+1SvldTK1C+wCuhx+4EIDXhiM4hHR7+lFnbTHdOEBdGGKik0v0gNzu92LermeUp/bi4JMBl0ACYetXGjTNwBdWIyyDuO3AIvx3rde66yoAZlGNqgFF3Hp5z7iwYB1XfC82V/DswXAvPXJTwz/9QkXhRMPPtBGoQwuSyGNLdlVSNFiKpLjETl/Hi/p8AQK9P0CvOClwtniTlOa74X1XFhQN+aLH17MOx/jhVE0ntEEohgfCITFXb/o0tPQT34jjR4+tnZMisdrinRpLpLEY1BeFgB2TE9Ga0TVGtYg1TMcjQF95DFSEs34EyWeUJZ9GNDzL9TFttpWmiawGqY88unf/OHB9FgegtmHjDytrG9e/l1NRfpv4ZP/88v2sGKykzgAwvD73qL1xpYvnp+mG/KF1qFVC+CFxw5rTIPk5QzTkT72re+EJ73pbfqeZ4888MI1zZ/HAsW6mboI/BQZA9ahboHBtICstjoF7kr7FLY/AituOq1su3XFq7PT3ebbM4ruVet7TBN80sFHVth6SysHo2xWubicZXppvXNX2dN6x45dYdmSRQVPHelfC9SeL/1ryxmr6Y+e/zSt7xIXvmPhXXY6uuZ7N4TrboiAzOknPyhc+rhzwgff/efhxBYeMlPRMAfJ2+bj//yW8OkvfEtzeXeF//6XfxwwJv0MvJTULmwdBxZ0Y1vYTt6Ys9AuptDsqg7/9zUCXhZNndEDPGA3nl2qM1MdenHp7rhhxmGcLjse9dvTpdoksassd45Vnk7TgC5ML9qudWRqT5dOW63BxwAHT5TtGnwv1+95oTwbNmonkG7d1hsaGzHeJB+g9XaY0jjK20Y3ajx1sYcdcXjgQ/jEDZqSdMPNNl7ERhYP7vqJGAAjIl4wPB7x24EnD3yHPtY0eWX6Gb4YZ3Cq4akbYp1tioIyfVoHoAjAQtSlOBVJz2QMgH1qkv9+bS6/wJhi2hGy6KDQpMfKlkKX8YrawoiMovVQa6suWkVNUjHoKV6QRONCY24EeEh4PhGLV88wKSS+qFa1Sekiwxmcucg3QjyoCnnQJUo8eoCy4GPclaPB4ez2UODkgugVQgfERoFX/o8vhXvv3aipSE/Q9Mwxl+z5zIsSe1kiEBQQht8ja2CN+s57/djpqJdGo59evXZLuPzb3wmf/s614fr3vM0W/Z0OgP4ieRd2u3vldJ8O3ct3XMtMXQu4t6BNSXX7Z/bOYBWrCFNR6SMIZqPFx9lsrBHN1JKrLkQZyWRGdTo2DLrkUiZyKbBxyW/uvs+TNr65c9V9AXod+t8C8ljKvpH+6681zpAWePs/fCR8QWu/sNPRyuVLwiPPPDU86aKz7XzgFE8zGlaTslgfb8K7CYcfsDDcs25bbvdaij/zbX8b6bKJ/2cKgRcHXbbIC4KH82GBLt4orHVB6ASwcpmpPDvoQpmsx8Kb00GFI+SBhBeEP/h1Ww47OizRHH3k2b2n2zWLui1vf+HnN8Mil5v1cNbrLiC+rss8fUfYlZm8rks/74uf3LXKQJhfakqSDUAZi6Zxpp0Vt52RRAYcy3lyPufNz424wAL0MNhlZIsefuaUo4+NdnELz9IWV9dg02rIQ05Dq1l6SI3ySYemFJHnnyKPYZiVEfOswxCvDc9MlzI5MyUJXn0sT1FLI+zxlB95Yn4c5kU54xM5yhFRQMbOxcH0+WC/yG8wxfIs3cHBngAEQenM40S8VMq0jFxrIiV6IzsWYum464zZRYFWF1722PAkrQfTDxDGr8R3GBt1EIapMLRir3bIr7fb8we/+o3wsau/E158ycXhsgvPDT4daUz1AageVRCG2+cw9aurH+huKgUvMNiCuw51CwyiBU549zvUd+juVEeiHkB/0R4XcctTyZnJNM6CrlR6axD1NHgx7fFlAeLq29BuevaFX7z6z4rLue/+9eEJv/Na2+3oWU85P3zs098If/c//y1844p3hwNWLC346kh/WqD2fOlPO854LScdd1SY98S54QKtrTLs3Y2G1dgMyLoFX3zdF97Otguvev8HCqP6FC2wOxUeLznoco8GIu1r167Wg6Ez3YLpHaMGvpRAFz10TwVItVYeSKw3wmC2m/sO0AUvJh5ONki2Bl36e6/yYOEL8uJRtF5u+J2CJ4Au5okkAId7fP2WeqHjbr6dhx11ROBDuPL6m/TRAr0KNsDkrPErthZnFKYK4YkSjStnBRt0lqMZyTLwdoHPps3wtEaaNVtEM33Sy+A46la2laNMCtViuvbWUTTDQ3BaEZkyODaG1UZo5FFPFWBlqDxkmK40CwDGEjpwNr1UBH4Rin6FzFhKXqJTIyspAnzOSzTFM1LMpr4EhuyVkBMUL3F4/XMR42fHKojREybWqSFZ1M4uOC8g5ehE++CBuhcQKqoK13zs2+Gaf/92uPQlTzAQJmZM7ph7wrATHCA703BHzRMGEBj7M1Xh3675dvjQl68Oc3Sff+ntbyyKxf7huTd3W1wThhcHTOXaLA9BA8kKzuFGel3vpZudnoZ7hXXp07EFksWPVTfTF20eNpIOIPYBbo9THtyWj0DUkPcvWFbSaaUxi5M2Gyy5KIGSGA45aEV446tfGP7mvR8Ob/37fw3z5s0Nb37dH9TAizdQn8+150ufG3R/UHfHr1dp2tFPwjXfj1uQnX7K8eFFlz057A8eMEzb8LFqJ981UwoYhOwYx2PmP73zH/SQvDU8+WztbPTkwe1sZA9+ApB4MMfThYf6fIjbyfVMBQ8Dt1VdvpkaVL3y3Z5wQ58K0CW/FjpfFoSkj8VVeryBbA668GBfgy55Sw4mDijHVt2sizTRzlSALoCenfAOprYzU+sNd64KV/74pnCHdmvg4Ryjxu+FM2/5iOPBYnabPHgInD2tM9iJzbtndGp5Gryai4boOkfdopFH2vIiT6SlOHTpwHsmeqtAV0KfJo+XdvRUvnu67NsjpVwAiI/JJK8Yo0FPHxVp+VwANPEavKGo80SPGQjQ0iEljeA0Z8hZKzQrJipJusRgjW+M5YM9SZSzDegSv30/cJtsVKDWasgr6rxcflNIuqG//WtvCmOLJz8VKS/DPWFGDYSZqr7yU9+4Przn85+29Z9f+rRLwmWPe2zePE1xPGGY3oO92yKvSwDr8fquJgUDIrCDHIuas2ZNp4FbCw/mOtQtMKgWOPFd74iqhbJwv5nNlg8xZAAAQABJREFUTvbPgH7i+jdTS75su3mwiMji7tZvYRfpdPRfBlaiYNRDMeRSwqzwi9e8DkIp7N69J6y6935tnnKQbTldyqwTfWuB2vOlb025fyj6149/KfyPf7kybN22I7DWyxGHHRw+9qmvGxjzIa35MtMBGAaA43mxVO+CHTt3h4V6QBsPfGG9l0ECL2yRyCCIxUIZCI2Sp0u1vUYl7aALZxYdnmrQxduB5yempSyShwWLG/KWs+oF4wAA0yzYIacGXbz1Bn8GSOH+YHoX3w8A2Q5N38sD99CKtI5Eva5L3jL9iZ959BGBDwEQ5pM/utlwBgaxtt2xfkPYbcCVBEVEAIUxqdG0MZF5r8RBrcakFmyIiscLuAfCOhfDVqWlNg56iZGHDlAYycOHc4Yt1yK+yJv0IJdoOjXHYZYEOpKbR/KuSdwIqyyrV2TlKEUStIIUNx3QiOelVUlJRmwNIRc2YnGIWnL+IqshCqm1eJGRZ7OAMQ8OfD+mXwYvPnioniI47xwl+C7N2whGC4p4HEOZwhse/5Zw4e+dZ+vBjC1e4ORJnaeLJ8ykLrIivFN27AvfujH8qzxdNuzcEBbOmRc+/86/qHC1TuIJAxjNCx5e9hy6cmwkQBheUDC9uptgoF83AjVv3QJdt0C0ZdGKcUyGTae9yX7bNFizc9jKyE9H59OM8HBhXRgkTY9FGnZREE3sIuxNQVFCU03nzp0Tjjny0CZ6TehvC9SeL/1tzxmtjd2Nnvi7fxZOPenY8K63/ImAluV2vex09MwX/UV46QufHl7wrMF5boxC496/QQ/iXa7zwcCDtTtahVf/47+EU489KrzsKU9slT0pWhV0GVVPl+pFTtXbvGq5pHPQhfYapelPvE3ECwZwhYd8rytvQTbWni6tvs4ppbEbxtJFc8NeHjz0fRCWCfScO2e2QLHOpyZNaaVnaGHX/+bucOUPbw6/ljeMBY1BGXPytpCRKQ/ylk5P+Pn6MDY2ZcyaZGyAKyDF0gAqlhflnSaFkW75isNP3D5WoOKNczVeTctNwPQZnQE304/srHjm/VKiUxl47EN9Pc6gXHGC0VQpy/J8y7Bsy48xmO2/SEJxPRBNZYJKLO6cKeE0HgIsFBEnlMjs1MGsKh4LKAdxphiRZumcRsj0FFFFinjiVPqi3zvfvGBYE6afYVQ8YQbRV+4SOHHV124IH/36t8L6Xevte37p0+Xt8vjxvV0mal9eILCm23Z5AQ/LE4ax2BqN4bpZLH1M3jIH1Ou9TPT11vmTaIET3/VO2XvZvNQfYcowee6hYmkdsIqALbDRnVi+EvRJtkC7G8HCXorROiM0wC8dUbGlW3m+WEZ9GHgL1J4vA2/imVPAFZ+52jxe3v+3rwuLFjbeKLEY06Mf8ZDwQ+2ENNPBFwZd3YIvGErenthb2MrtsGHzlvC7F55XoU4uCejCIAcXWwY56zZ3N1VqcqVPXpq3ZuziMNXz69nqF0AD0AVvhlELtAvgH+uMuBv0A3KfHpZXzqi1z7DrAyi2duNO++0dKi8YAmvu1Ou6TP038/Bjjgx8CJ/8kbxhrpM3jOywgS6i2dbRGoTaQ34ajPqY1M/IxriGuLkHjIjsSmEDYXgEEAAc7NPvE0+XfcqzNWJ0speWdAD6Z8RsA2QbKYtXZ/4MpSEbXanwWQLsbKoRMqKDQjTWf6FAUB30xnwrx4RRJDpxE0SYkGgeV7meHeugDJc3nuZDM/ASeRp6Mhmuw0MRLyIxxwSpV0xSD0AWWpbvx/tMyoXV2LwwE2nI2tOHMziP0lf/27fEOSt88QNftTVhLnreeWHBosbYJZbc/XEUPGH6vdPRZ758fbjqqz8Ja/etD+t3C3TRLTYmb5fPvaszb5eJWnGrvG75AMKwrttUgzDmXaV7oxvghWsam28I4ESXV+fXLdBzC9AlmJXDhmHWSGPHdLC+JdlmvF8IZhPNzstOJl68XppDmpJkGUk5cUUpsw7Da4EafBle20+7klcub7/iNbsgLd0P9oPnLUi32xTifm4LvTGyrIR3v+Il2tqyP1tKO+iC+zugy1pNUZlgPF2pzWgkt2mNnEVq56nyOsEtGrBqVEEX/1boa5dqegvgC4s/jmkaGeuI1OCLt9Dwz3wfTO/jHmbQxG4kuO8DnNVhOC3w22edEfhc/x93h0/+8KZwp3Z1YPDJN8J3xOjVF881muiMY30oG2kZAMNlGP4RARiShFkCjG13JBIoAB9BN3n6s7ExevWBVgQBKwbcCFAxKAVgBVmhOlqiVvEIsBgAo3SceiMl5iaiilgHI217eUjUlIriIooS7FqsTIlZMJ6Y4FgCVpwhr2S7OLwpL2rT9Ra8iuRxq4UpzxohE04PDwZgiWxAmZRaeylt+nWOLSo9scCoMMkWIAxCBNTbk00EYL74ga+FxyUA5kkvmbw3TA7CALiyEPdULcy7QC9ZtsrOTDZ89ksCXb5yg90+6/asDxt2bbAHuj98hrxdLpmct0urulVBGKZpbt2unRa79ChupXs8WlxsdzyO1nnY8zrULTDIFsBMeYhATDRbGDCmHdHT0A+YmVN0lozkPnUEEZiRrcPzUicAHL3mFR8JbKBrJk4qcnDeh6Gtw9BaoJ52NLSmn34FM+3ovN96ZXjDK58XXvDsOE2GxXff96FPhS9+49rwgb9/vXnATL8r667G92gKUTdvTwa9fXIVdGEw0xgAd3dto8DN+gu8GWs3VatfdcxBl6kCenqpO/1oDroArHkAiOHDWiL1Wi/eKlN/BghbtniuvoN99vDlYAtTkVYsnqd1Bvbamgfd2I2pv4qZXSILIwOeA7L+23duMG8YxqbForwymgZsMLhlzJqdaZlI0+BVeIjnxbgYE6/x2PSiyO/50Gex1ARn8lVWeRtq0RhA4z3DGR5NPZptZ9JxGpIBLUxBgo6RB3hJZwbj5jrCGZr+4znykrQ0GS7vNOPX9XO2gEyKcrJkIhT0FumCpEiVL1MXo/GBwJ4aICiJ7c+rBg37h9eCXxKshWqTS3qIm4BFomCKQm7koTSmLxUAAxgzf2F/thGmr6dfmQoQhp3wWAOsl4Vsdwvo+NwXrw+f/9qNYd+cfeGBvRvCht0bdJ+FsGDO3PDZ97zRW27gZ5+ORJ3ohwcFwiwamxPmzeHlWee7QwHYHKapSnWoW2CQLXDi32vakQqI3iuybuowbC2XrFDHlzNSFsUiSgNMdDYpCYNNZ1JeBGqMS9mUEcIvXtu84G6mtI4OsAVq8GWAjTsTVb/9vR8JH77yKwEvmO07tPjn9jg947+96vnh+TN8vRf/Ppkz3M2DLm6rrPy/Vgun9jPkoAsPFCz+OVPCIOaye9vMBNDFr4WzrQXDgq56WOvWKyvXU8e7bwEG5zxw8dDIApMOuuSaeHh0kGz95uYFeXPeOt7/FgBwWS4AjB3eNmvaQx5+/Ku7wievvTnctWadDU7JY80eG5sygGWMms4xTkI0TG3Kc4ClSMMCgiAeA11S2vRAM3rKN74McFF6FjsbcTZegS4AMolmYEwCXPZxRh6wJcUjKJPSCVApUAulbdBNffI8Kl6hFXxitWAsic9pJqQEshayfPQrFMeCx8jxoN+FR/TzMU8er5Y9iVhmwWRTuuIOH6m6Sbo4GSuHJGPRFIfJop7n55jxuOedHxYIgHnSSy6GMOmQgzCD2gq6lz7y85/7cdile+YLXwV0CTbFaF0CXeYLdPn9p14ULnvSeZO+/l4UOAjDPcB4prqwfC86cxle6NA/djN2Azw/WHJ1qFtgkC1w0jvZ7cj8W3TCNsmGy/Mx92KxXGUl02rmLJpVEdW5mEUTARoq4ANwwYMQ+xrTlqt49Ka5/XU1+DLI73U83TX4Ml7r1HktW+BbP7hR20z/JIwtmG87Hj3yzFNn/C5HeUPgVrxpa3kQn+e3ih+u7ZP7tcvQTAZdvO16GVi6bLvzdAJdcHVeIo8WdmbIPV3aXRt0drQC5Ku9YMZrpf7kOejCNCPe1rKL2EQBkGy5QDK8X3gIaLUG1EQ66vzOW4D2xmOMM8D3RB4Cn7r2pvBpATG21ojGvhHY0JlBLGPW9OFNYk4zgAX+Kh1gRHSXRc6AGmiJvwHEALCgFx6dzQNGwIvxknYvGGjohc89YMTkQAw06kHaQBnFrV5+Jqk4IadzQalOyrC8Bl9iN3qMO8XOSZ3pc4LTlG4CcqJwceS3ROCyLNjDR4pzsuzIQxJ+UlZd6hQZyMp4Ez+nXJ+RPc/PhSARrQ0jb5jnnx/mj82z9GQODsJgIwAU+hk66SP36L750uevtzb4nM779FvYqw9rGP1y12/s/lowa054wdMuCr976fn9rF7PugYBwvBNH6Yx2OoHtnVVL0BzgNs61C0wyBY48Z1/L/Wy7cxnxWLKrNmUWLOecSoRPppm7XSwNcgEoGBb6V/MK8ZkkI7ASsFr9g9qzONIgOv2173W4vVh6lugBl+mvs1nZIk33/qrcJ0W3L3x1jvCu978JzPyGv2ieHOC90s3gVX2WSx1ogeA8XT67jZY0Znm6VK97k4GllWZdunpArpQf7aN5oGRB3NAl25dsHlTx84MvDXcqAf8OvS/BQBcGJQzva+X6Wq4v/MdA9h0Cqz1/ypmtkYe4Fg3aovWxGBdjm7Cj355V7hKC/TeuYZFR9NAmPFq+kQwRQn9W1woQA6wFHTyDSgp50fghTzpBERBL2fjjedq3NIGyCgfLxh9DARChjSj9RxwAYQhz71icqAFMmlCiU5GogFtOJ+RySAvnuLRMhKhXZzsKORFJgHDROIDgThgIWEhRexUEJvyiwVUJWMAjysoySnhKkogTCI6rSQjhYl+qXnCzAoXC4yZJ2C7l4BXHLugAYz3E4Rp1Ud+4dM/tOv93FU/5lnNrmMf4JY+nFkWaO2+DVpQd0OYL4YXPu1x4bKnjAboUm1b6ws1hYvvebKeMHwHvUxlxuuFPrUOdQsMsgVOeuc7zUyapdT9jm1n3ZZ4TiUr08wSeTJqmCybZZRXzPOUWdhURQB19qmjsb4Ge2yKgsCX2vMlb76pjPfWm0xlDeuyRrIFWOvl9l/dHb58zXUGurDgLoHpSGsVP2DlspGsdz8qRWcc50+aqexIJWtBzJXcHj0UdxscdMFeMrVhJk0vatcWTN+Y7I5HOeiyqss3Xu3qNSi6DzR5YOI77hZ08XoBDLJWzkoBMAdrAUhc3rtxs3Y99bm5BQBdeIjitzyZraNZXBJAYLkeLHggACTr9fturuX+TcHLhbUwdsjO4gHWC9h91glHBT54WHxWIMyPBcbcsWqtQQg24LUmZvCbHvn1bAbGEQfDous3TM9gaekwPs+HKq8DBsGx91Ba/CySbjJKMlQ2ZAaDL0YW3VVMn0hnoUR7KyqAxaTgA4AhmFLXjBdMenAEiDFfkchktWJ0ngbhUZBS4NPZRvXUJF4l6w/Eq0J+ghCLz5iiXitKeWTrci1YtZyzkPt/7L0JnGVXVe+/q7qmnqd0EhJ5RECGJ0NUEpA5CRDmBEUIKBpngf/zMb0nKggqICKE4SM+ff+nRkABEYk84AUQhAACCcr0lDBPJumkh+q5q7q6u97vu/bZt07dvlV1zp3Oufeu1V33nLOns8/a5+y912+vtbZOUlVSHJlTfJQgYJuF0U6mrcRlFmYRjRsqr5VHuZxkCa3MLIx8Vm4Wr5vx7Nf/xUctz/V/+U+xDOV57NWX2Pll8hUzMbX2FJp3EHNDtGXpPwBNOgVhGBvZLej699wkPsiM6L3/YvU0kIXn4jF0bAAvSr9PoMvs/IEwvrAYfvEnHhWe/oSHw4naEvOceS1YMTaaNoz6y3ZBGOZe9NtlCDY68FKGY562bQ7o1YxOctXvWL9MSdYpRVBe72IDjKFn4uUkPuuXubS+TycxptFzW5dH3x3HHMLVL1jR/DhVxQG1szVDVff3+w4gB/7xhs+F//o7f2w1v889LwgX/ci9w8MfdP9w2+37wu+//i3h93/jF8LjLnngAD5Z8Soj4JaZ2G/UridMAMr45MCMhBXyk5pYjwrokloAdW2oHc2CPOjSTv5Uh34c86ALde2mEJ58XaBdUcQsph/PO4j3QLhby69Lu8+FCeG2TVNRi0bCmZsitcdJhG/6S955AMdufke00RaZHvztJ74YPv7lb4fv3xF3S2Lua/K6plB2BGBhPpv92SQ6SxM1WWJcNDXiXPnATFI+CenkaWjEgC7YtY45MyQDawBeFGbnaMGQFs2XxpFz/Sl/9A0Tz1OYzb6teP1ASmcIEpd2bpFcxP+NMLskhyjGLR3zYZag6UfPJskA4SB7tKb4FpckNspOKCBPdqkf/ecd4GhVTWka6WOcBTfCdJXOzzhSlIQUZYtpsvxnpLMEAmQeQcLwqJ9+SFg3sfruOFETZtJ2QgOUKbpj0fV/91mry/V/f2NEr1QXdjWnfia4qZ+y+upoYRwz0OXACe1gJDDjp6+8VH+XKNPgkZkRCoCZ1DbszIcAn4oSpkML+l7Yaakocb+ztYDh5BzoNQd+6LUyO6Ljsv4lwtw2lvB9ixRj/RFp7Bu3a2IyItDSxpRLZRGvMIvXGBATxaPK+vp/c80XOFQFOfhSBdcH/J5ovXz/1jvCfe511zN8vVzzZ38b/v4Dnwgffudrw/qZ4XVUhg+BMoM/AhwqrEV28EmgCxoL+JcZBU2X5k+iHTXhBLpgDrLvUHedGzfXr9PrBuiiAZAV0W4Ki/m6MZYj3E/o/dund9Z328lzZ/XzBLqU8euyeomtY2kjzJjWC6A9dPSkATGtU3poKw5gzoFGQSuHuq3StxuGH6btmzAXOxX++p8+H2762vfCLXsO2tw2D7Q0wBTmwfq+mRMboKJrS8ccWH9MrtN1A7yxOACY+Gf507kBK7k4CZPJAa+lNzBGBbQAYWyNzcKJZzKuo+pm83KOkF0Tns6Jz/4sKF2ThHMyQU3nWZBF5X7AAqAGwJjPFqNW/s3yimMxjQkpWXIL0k8WxXfLBc9sVWykzdJYuixxOm9xBHzhvwEb3MrKiWHx/MywVAwZL//ZR1j+5WmtIAsal3C/Ue+uOC7zuAgkWH0tiZVk+a9/12djHQjSs6HMND6+TsALglgGvHDkudHCsvMQZhcPBUCXMWm6/MxTLg3P/IlLKHngKQ/CMD8qYlaI2Tem4mXGP4BcTHidnAO95sAP/ZHMjvi+6QB0ZNRgbOBbHuM7VyeBtgthp3WE4m/s43JZ6QBiHhJZeeobKFHhEaPRVZbm6y9y8AU2VUFr60xWUSu/Z605cNe7nBf4a0UPe+D9wp+//QPhltv2hLv/4A+0SjIUYRskKJUBXxj06TNNPZoJbQvKgy77Ds+HE0O0e1GLx101CK0iAJgilAdd8KvTKyCjSF3WSpNMyBgM+2Fuwqs2K9CFieRZMscou2K41vMMazzfN0I9vnPYWr6XRBuhnYQQAVAGkID2Rqudk3pZj0Er24QwaQYyC+3Un1aRZwfU3T17yrSgfvlxDwjPvORCa7d/+PSXw+e++v1wy16AmNjP22SZbp4JL0eZGtlEOM5+GxPqbDYcARG6O/vTD9ZCqDUAlJiQTbnxb9FUZ0grzQe0XmSGZGmYYCuLqaRnaex2Chw7dUrCOYWSQDN5JH7AGPLon4EzZI43jun02yB7ruxZqAfPFR8oPlcjIWVQ53gg2OrEPfgHLxJRlew6H5yilx0bCXSSyubIBXEUlPE2jbUmrCiKexJlRFoof53LGyP1u1RcvGjcp5EinlBeKqsp6oNvvUFxiuQvA4TStbE6xekIYDSm9lErZe+L+EW5jTTx3KzICFNTIkAZMKRrA14UvG/scJjVttHjcwLmpOTxrJ8Q6PKTlzTVbLAv6RcZ0xIIs01OzAFhVvKfxZwLlpUBXuAQY4CTc6AvHND7aR0JR+trY8eSwHneYes/LVXsnLjmvY5bUut7V0ckQ1P9Zn1IKjPru+MdUscW+3DCnKrhgIMv1fB9KO+K091XvvFt9mzDrPXCAyLMWj9ZoiWZ6zLJsq1Mc/kS6IJpyKiDLjm2rHmK9oj5dxBIVXfQhXcFkAgThkOaKPYbWAMoRHhEuGdSeYDddhDsnJZxoFt+XZYVWvACwHHfoXnTgOG9doe8KzOOPpO2YuvoIivfK5dUPgbzQDQVtuh7PnvbdHjqw+4frvjx+1pB//DPADHfC7dmGjGm4aKYxpeWGzSYOAPSNCJJRDwYiYAXwxLsPF4DxOATaiyBMgwoAl5iGBNxXeNRtQHIIHRSDjehDNJnaSxANzMABt8xSgdKQaVWA2A0flmdAWAoQ1kaz2Zl8kMMZVGSfvR/eV+TxS9P2qIcEkD5Oygvlw3AxC6awnSpZzHhRDc3EIZsFsa9RY1n5Vx/WTBRyyjd+oz41TJliU0y0nnKa7xV6Vw34ojXnIDiaFs137hAmKTVQlwCYdgaOp/PwmkPFbE/HAqzJw+ZP5dJ+TZ55lMvDc/Q3zBTMwhzpx340sGM69Sy983mXNknUJQfNBFzPCfnQD84YGC2+gDr8+kg1D8lzRe7pBK8w7yYSqevPvZbWaSBsMpjIE2WxvoTK6qRScWqP7T86nMIdqqMAw6+VMb6wb/x7MHD4cbP37zM6e7dpBHzit/4xXD+nXYN/gOu8QTmJNFmTWskzKIREtZPjWuCEGcCedBl9+xxmw8WK2m0Uy1pj8QV7zprujC+AbpslLCIs8C9Eq6rIuQN14JpzX0m6GlLUUwKq9Q6oZ8ALMPfEw55h31ns9Yt0jqU1e7kULfI9tGtS+k8FDAB7STqA6CJKc1B+e+44sH3tT/u8N5PfTncdPP3wm0N0ySbU8f5M6CKvkcuwEPS5Nkm2IRDdB4GwgAgKJA8DB2EIagze0ajRgCKXesdNvMjjgAw0hCIMj5TdW6kP5txx/HHCkPatzL5UTydhA5LN7MLAiIpPo57urQo3UulG3CT0lgU2hwqWukNrMnFxVMyZw+aneZCmlLnY8ijazvoJ0orufS5sOyUupnAoQpRkg3ZVqQSwJMG5fJamK7jQzZSZDduHHIRy0+Xlcs9svsoPH/HRiaF8yjWTvzqel2mCUOGhsaLpVNa8XZ/OGx/4yeUXqZFk9J0ecbTBLr81KWNYkfhpBmEOUfjLb5dAEn5Tqcmx0ovdjAeODkH+sUBgGK+c9NiSf0AnRbEMfVzHEV2yMXTqxjQTqS6clLZmGLlWqz1wzaOWB+kMtMwQB6nvnPAwZe+s3w4bgjw8tAr/os9DE53n3z5Q8zp7sUX3ms4HrDAU2AWs3xFb/VMC1L9RqCakMM4VlVY2XbQZWWeManK73iUQBdydLIj0Mp37F4Mg18edLmtRrstIdijebNN/itGXQuGlSLMfHrt16Xsm4UMzDuenL3O4P9phB3yAnLgFwe/K/0wMSraXvRR1Id64dMLfzBH5hYMw3jyQ+4b+IPe+0kBMV/5bgRiLEQ9hE2q7UIz5TjxNm2NbK5NWJyQZ5NtgBO9r5ZPwvcyEAZEYVwgDICLeDV2CuQDAGZc5ieaZSNMnsr+rIysLNN8oQ7KA4jDqd2XH7uJxRFslbFI3YMoSQB5ocEAGL24JrfqHtEhfVZfslvhnCRSnJEistMkT5yRNIoTS+m5JlHiIc9k18uTpECicDwcQQ3VW3XPnrY5Q3a9xiFVvTlZPjydc1x2nl3k2iGTqSwd5+KwMsFntQvzDMKUfu+6IwRLy+WwmRVNCHQZV5s/42mXhauefmlzbUbqOoEwsJV5Fn5eAGHYsajMRgcwbXIC/js5B/rDAfva9V3HYzQhsj7BOq4sPOtErKtjgpBRvKZ/UICF24n1E/QjNqbYUeVkHU0EZlIJfqyCA9JsyrViFTXwew4sB278ws0BTZedQ7yt9GqNA3hSdFBnArApc6qJbTLqsf7lrcZdJlARG8bhMCr+EHyrswNihr086LKSHbo9TA1+EGjhLdvylvFhVIOqd1wFc3IrEBS/LnzLdSa05KgvgEy/zWyq5gsAIc9OO9X9ewLIw1cQ7xN/rfr4937iS+Gmf/9u2L33kE2WwQ8MdEhHViSV0ayF0uQ7XbOqSRiaLxano4RvBPK445FODHQhnjJ0DSBjmjCAMSqAP0CXdOQ8+1skDFUV8kH2ADrnSFD+SICuYxKLNDOj08ofgRgrIfdDGlF2iBf531yETnNX+URnniN90PFmwknj3MJScLrgWoBG9sc97D4pf74shSllFGoIp+AUn09v4UTl44VONa7z4fHezXEmEwlksaPymXDEPQgTmDY7fjTslaYL7wRbRY/JtAifLldddan+LlNCp2YOwH5AGPpOvsWkCdOcrtV1XJjwtelWvPGw7nPgHq+5xvohvvtx+lTdgs8fiv1T7Gfpj2JIirUkubCUU32EemO551VczMP3YGZHljqm+/p/f0EqwI995oCDL31muN9ueDjAyt5auxcBugAiTKPpItAFQQKv+3FVcHh40YsnYfeX7VLpR0uj7qALzz8jHzRb5PyPrUPrLiTm2wtNLHZx4Z3ElGPYKfl1OSEB5ojAPFZMB4HQtMPEhUnUKDjkNYeaEp4Q5BGcBqXPxGQBoH1GJqazMkVi17qV6H/f8KVw4799J9y+DyBG02SScuSVBABJ53bUj+IbaSytJtnEkdbS65pwu85Mj3QOEENYwxzJQBjtsMO7f5qjMiUAJgfGWDlUPiIssVwqpf/xD0GBlVoCKAIhIcVniWKUxcefLOCM8JRkKWLpLMWtdNRHgYwRf5bOLSwFpwuuSS/xRH+mWaIb2b0sPCuHJPqXABErNMVztGQc9ac2txCL19kKR+7VHNcoX3hNBF3iPfdNHAv70XQx8Ey30HH85Fj45asfY37jnvSUR8Q6+O+KHKDPRCON/gMQhgWGIiAMWjNFHf6veHOPcA4U5MAPvUa7HVlHQAb1RNaZLGVuaKwoznoaGyBiUtICqmQdkA5Jp4+I2N1Y5xYvLZl15yrj6//ddzta4nJ/zxza7S+//W5DxAEGZyZvja0zc8+WQBfSoKkxuz/6dJkQGINQMSiCRO6R+naKqQXaIxorjKr0k1LkoW3baAmJvAcIxXX2QdPqeU5K8MJ0YoMExnN3zOgZFoZSC4Zvla1DT6mdqvbr0qod1gqjz8AhL0AuoOQcoKQ0YYaR0MbCNBPQddA0fQAg0FA6Np/5g9E1Al8rEOZJD79f4A8yIObLOSAGAV6YCGAGgArTbrMEYuKt/9ZBmj2KAA+lJTl+YBYNjdG5fIbgG8TMbRDgCdd4tIifGAGu4zjnFTA0ljnpTQAMOyMBxJAvAjJKz7ndnxvrT3WKIIt8k+jGBrroOUmi/0YmS8SfLE8WkVJQHyg7xAt+UwlLIa3PcjdrTkCZxqcsTbrOl60wE1P0aPQN5phV2c6oTnPZzdepuo1jdk+urVG4ju1jWXNhdi9Lp/sqHMCFsP3jRwSUqV7y5zKu41UyK3pGZlZ03s71tiBBfQfx+2hmXy+vmWud0LuP5gsmSIxxgDGrgTC8Cw689LJVvOwzOKB+km7AftRpW5+vy6W+iD5e/TVkfS/nis36OPr2qNVCj0Z/k0XryoAZy8cP/QwpNA5Yohjmv/3ngIMv/ef5SN5x/4HDYce2zUP37PgkOa0V9ER50AXthzntMKO+skHz0opAqKiz6Uyjsn0+yYMuSdOFiWZdKYEuGt5q74NmLR7yijJB5b1ECwb/OmyFPQzEZDr5dcFMEPOVQaZ51X+v+pXk1wDAb1j6E/pPADIAlz0H55b1nYPWZg1/MOrveaZjOX8wrZ4lD8TcmIEwN3752+GOfYezybS+UjAQAA0+WCbeNsnWj8IjAKMptcUpPsNL2IoawMWc8mYgDJoypwFuJMADvphGDOCJacRolxcBMOYDBiAGMyT8xRDPue5Pn4dDXRrIgBfqobJig1GvWA+qEokEXFFGFpQm/1S4EZaLU5aUK4UWOpKpQZSdK2hZXCNRXEDRowFo2G5DCDiKPqNaS1mys1hg4xdgxUhHzrNrO6TrLMzKhoe63jtxXFouR6OWi/i8TnV5xk8tAS5ZoY0DCxJp/KEfcBCmwZplJ8y1kjkt/G4GYQBEm4FR5nROzoH+coD+JgEw+vj1PwG2UX5QHH2vKIIm0X9V6outj2vE0feii2iFpF7WOjPAeHMgRdeUF0wo2KmvHHDwpa/sHs2bvfna68IHP3ZjeO+1rxo6BmBqwgCeB10YzNnWt1XfdlzC7S6t6hb1FTN0DGvxQK1AlxbJahOUJr0Ml3V3/FuWaXktmF3b0II50XLFvmy5VaXfiL8QCSdMunfPzlVVja7fl76Fdw/BAi2xmanBdsg7IaGX56AfrZND3W40HGDZ7dZOE9qaesbeRd7HVuNDut/F973ATp/0yKgV81mBMHsEwnz2i9+yo4EtrJZqMk05ZnaEdAkwkmnDRFOkbJItgZ5rQBiOjTiBKst2SpJGDABM0oYZO7VO8ahgIBAs/U0wtecSgSCBLumBsvubmJABKykqPV+UBNIVkkA6bzpmQEVTaPHLlcptLiFLJ9bwUPZIafcQglpTVu98HTlPf+mh0nU6UpjO900e4yTsQ8tFbHzmT1yqq7FwlXYrIulaBOA6v7AEwuBrCE24QdO8XOs5O4k37TlpdeaJ9syDMACjzOHYopr+lPmIk3Ognxww2EUvpkG+9OvZ9299M/2I/i+CnCRQO0tgfb/OeafJYv0scTpJ/VeWWdcKY3wgIWktRzz33/5zwMGX/vN8ZO74ze/cEn7/DW8NN8kx7zOuHE6ncJgAIDCgpgroklZZVmpkVgnpG1mNb2WutFK+YQyPoMuEhoCoPt1q9Z7V4/yOR1XyYZhBlzxf0+SU9sDxID53EPQHiZh0b5HzU55h/+H5gfHrUpbHCFqYIuGQdtc2dtsZLH9DPC9+sBAc0UjC8fOwErtVsRsS/mDYLtuAW72fReiB9/1BS/bEBMYAwuw/HD7zBcAYCe8af8w0SR/vGGZFzLANBGEermvGHT5sjvpbOpKPMLRfOKo+AmTYJWkMwGUdaaMmDKDMOGCL0pw+qcUFIUDSE7GJvk3o448JCCYNcM29EQTsyKnCLJLHoUIQYQWoYLJY3EqJFc4ADHFI5+maowgWQWj3mBDDY1j6GG6/uWKsHMpKZdo51+Jlli6l2Sctl70TR8M6Oc59mraGXqeCizrNZSxs9lGVQBi+oe0CEgDQeddGHYRhjgXvmXO1IkLzIMzWjZMGAIMlOjkH+s0B031JnYz6SzMfVYdCEP0nr6WBJ/SbxCuCMHu77Ycr9ckK59J+SUPHryhByrEfJpZvw/IooVMlHHDwpRK2D/9N33HdRwIaL9ArX/xL4crHPnQoHxoAAYGhjF8C5rdmvjnY1g9tt2cR0CUVflxmWhskSANsVUVpi2sGx2HTdFmNp0zilwT7wdCCYcK9Y8uUTbgH0a/Lau2xWhxCBMDvFgkQZ8mnwQE5Tj65gtCxWjn9jEPbBWFxQe8Zfego+MFCEKQPwRcFfnt45mazhyJt8MD739WSPfGS+9sREGavwJhP/+u3wr79cTviCMJorMnMi0wLHfMjJvIag+JR16qDATIKD4AwXBsQw1EJ9TcuDZhxhXN+ekF9MQOYqb4QLxMl8tofk3zN9JnZZ9cmPWTxUdUdSYB6UHXSZUcTJexxlv0gUqwQtSxd84UVa3XJFYA0nruMgEgWkEXl43lkggFg0kqyOcW1chVDefm/dD8Li1EgOPu1U9HsuhNh8eTJ8PQrH22mTVc9s/yC1LTmGzh0b0WE8+cgTOQOwBmv6FrEe2IgTMY7QBgn50BfOWD9jF5YddLJJwumQ9ZJGkqCGVH8Z10MAAsdkzrRCLZwARhOf6T/lGcJdEEnprx0SSlvllkBTlVxwMGXqjg/pPfFt8s1f/rO8J7rP2nbUF/7xhfL18uWIX3a+FhoBpQhgBqbRGFPP0JUBnRJbEEVGGGyKvDlLK1QQ4fk+LNsO6dnGOQjAhK+i1hdTb446qgF0/DrIi0KQJdRbCsE+Vk9O2DhDr23toW22q6OGnZoJc1MyUxiAB3qduN7RnuBXe/QnNwmYQ8tBb6rCEiUv8ODLryrZXripRGM+fTnAWGWwBhAD5RWbELOcMU8nwk8k3ddJyCGiXr+HI0YEwkUflp1tN2RTskZegbKSM1CYQID7CgQJgNiGhouaXnV5v/8cF8duW/uHAAG0YL/2Q8nLchymRDRIrIRlJWudM3pdc0DZUJKzNCUJuWxZHEVmWqRCifG0TGvrgxgoTwVyDkqEzrun5yP4JUyzS4eC2PScHn6zzw6TN3peHjKpU+Kt2zzd720WzAFXY1agTA4UR8FcDPPF/rBMto/vJaYi4fg4Euej37eDw7o5eO/QG0DwiNKov5EYeqndbA/amL9tV0pA9os+o2wTEyH2Sm9lrruWBYJsty840b0vxaeXfuh7xxw8KXvLB/eG37zO7eGq5/36rD/wKHw2//1Z8Izn/Ko4X3Y3JNhdnRKq85FaUETVFanABZGgdoBXRJfmDBWsfMA/ifYIhwb+qqAn8SDOhyxib/jwJxtdVw3XzCYraDxgar97v3D49el3XYHeMJZbTJFQqukLmAUbcW3xUoz79OoE/5g9ugPh9D4gzkivrArS2OS3CaDfvxH7mo5n3hZBsb86zdNI+bTn/tG2D97VOVH0MVWQAEjAGAwXeLG/Fe/yzl/aA8sArZIW8cEA5khmXYMaQhXAjRl0ICxdNLuCPwpjmuDL5j0UzZigh2za4Lshs3XikhxJDmDVpYcTDOlEa0TzpOk0RxOuYoj2G5n6Zrz6FoAS1xIjkDL+DqZYil4r4AWiG2g90/Ma3ciPe/xWPenPevR4anSblmHH50uEaavRUGUPAjDAgbAAn1k0fxdqnJlxTDHKutbb6KLbVXZg/uNB5AD9BHqT2MvZOep/4tQCnFKYX0VPRV9M7/ZOf0WpzqYmRGdVaOf1akSYyJq/bupxWTnyuJUDQccfKmG70N311e+8W3hb97zj6bt8g9/+YqwY/tgaLv87uuuDXe74PzwMz/56LbbBIFiLV8v+cLnNEHbvlmTtyGnTkCXqliTB11u3Xe8qmrU8r6M5WhWrNdqPVowaMQgRFdF+HVBaF0Q2LBPWgQLCIBOxgHaivZBy26bzFsWZ9gGfaEyLRgAVLaPxtxm2BzqduOVa/iDEeCLPxjbKa8EoL9WHX78R+9mSZ74qAjGcPG+D3/RJvvv+5COaG0IRzGEQS/POECLjraTEeEZMJNAGY6kRzU+AjKa3OMbhrAGIAMoo4BMO8aAGIAaXk4+VR1NeMhdW0QWpxSWJi9ExIyqaytC3jDpQ5GWRD+NpLnzDGyxSAUj0HDLJYCGtEt/mBtxvX8av1enw4FJaZ4IjDYZZj47ih8TAl2edvVjwk8IcJmYqM/4PqogDItiLBqUIeZyTs6BfnPAwHB1QuppYl+UzqQJQ/eI0VEMinBLqh9dE312ND1SGv2PFMEZgBvbfNqQ4xiWHPdaUErux75zwMGXvrN8+G6IqRHAy/atm82x7je+e2s4fz6qxp5/7lm1feCbv/G98NFPfT586SvfCldc/pCwedOGtuqKELjUaRYrgsmrqS8ziR0yctBlyBq06XEwZ2ELdYT69dPTZuazklPDpqxducTEaOdW+csQ2IJvEwddVmYrq9xLfnuqcci7SYDCzOQ680cxe2Q0tP1WbpGVY8wfjLZCnxTwsXXjlDkibscfzMp3WB7zxEdHIOYJj76wEXGjNGSOH5sL81ogWNA3/snPfi0cnNWuPJIAABvMfwDnyLRIBfoGE5hiR71vyV+MacSczOLRgEGFRsdFzG3tT9fYQlEuZTX+ctdE5uMb10pjETqoP4iCBKMw1/xl53aaznUkXP9Vq5jO0mfhufNZAS0874EpmYKpitHfTXy28eOnw08+49IwOYmzeJHq/dznXWGAGUBHXWmUQBjA3rJjEm3JXM7JOdBvDljfqheQLjD2XZzoNOv7TJtPfetSNH2WrvDnpWPMZzn0E/NylQdeMLe0fo94kjj6AosqIwdfKmP98Nx4x7bN4b73+sHw5Zu/HV7xxree8WDEr5+ZCtvl++XhD7p/eO7VV56RpoqAX3/Jm8LjLn1guE7+aT76yX8NV3TgFJiVQ1sNLPggp9RbrtNEkM5xWMhAFwla+DFAaDh8bHXb9KLP3csdj1DjZqUZ8yLXdCnaIhq39domLRj84uCvooz2V/E7LaXM+3XZd2iwt8Beeqr+nCWHkpu17XbaaafsqnDZmiIAJXOHUXGoW5ZHrdIDJu7VDlYIgskfDJoxvfbdwy5MT7z0h60vBGCFnnD5EjDD9Sc/87Vw4KD8mNiwtRg+8c9fC4d0TYcQwRclsok915zrB0BGf5bGzuVb4+hcmNb4N048GmtCOAhjBXhG2RCELS/xdp5dp/EyC1YiS7aUKCrpx2tKUUIDXJJ2i4K4jnfQQQ7zp+UIV8kOTi6EdRqzAI+eLE3Y6elJG9PXiRdXPOtRYUrXKxEAJ1p4mzfMmGlPL0CYVjsdrVSf1cJHAYRBw64sKM9imJNzoBIOZK+eHdQXZTBL7O0USO8FVoKGC2mQG5IxY+wKLZNi4hU5SIcJkuWjBPpernlAIlPfyrVT3zmg8dJboO9cH+IbogVzfG4+3LJ7b5iV75d4vk9+YA6HOYXjD+aal/9/BsbUhQ1/8Ka/Dp/70lfDtW94cdvaLzhPLCPMbJR664TUYsvaJNeFZ/l6nAm6dHdbYnyvQN30vZLfNnoUnRHm26/Tc2QZdm4xAUYgTNkVx7XuT/mYOiW/LlWaOq1V10GIxxHldmlWoL3UC6E+gWRou8werY+/mUFom1Z1xHcP2kOYIiE4d3vGNik/FwAHgGWAPp2U/4lPfzWCMTyIZvk3fPLmcPiQzDdVaARjsghpk1iYXSphA6DJwhWUABvKSWCN4Si6tkrqePRkNtaojyC4QQawIGiMhaOYkij+qU99cBQ6dDF/GsAohCnqpro86WqBLeujc/VGGW2cwEN4Oa13n2+rmyAMJjHj8j1zRE6qu0n4RqHOw+QThh2LAF/wn1SU0kJM0fSezjnQLQ7c41WvN/B6SRlF4AlAybJOje6Ljg5AJR65hAiPvZ0CcvlSeEplnR43iS5mwtd+6/kxyn/7zgEHX/rOcr9hHTnwoCc+J/zmf3mmzI8e2lb1EAjLACmssuySE7zbZwfX6WSvQZfUEHFCO7nmLg8p/WrHPOjC5LjMbgirletxESDBZ043tWDMr4sET4DNQxI+uw3sjGq74cdi08w60644KMCsWw55k0NdhJ5ugqWj2k7puRkvAGAAIRlnuqVlxve1fZP6VpWJf6Be08cFxhw5nPnSMsEiA2W4sa5PBQnLEgye9PiLe12VnpbfCxAGjTV2OuqVw9xhAmHO2T5ju4mVGS/QMtsgoNPJOdBvDtzjldcIbBGAoj6wgauYlorBLVadiMPEX8Nc+JHZEc50IS4Bm+lHpVIYj3atcxUKPGNxWRLyfO23XsDBqQIOeE9TAdNH4ZZoviR/Lzd94eZw/cduCi993rNq++hXPOYh4S3v+lB43CUPDFNTK6sXr/QATGLLgC9MCuhkWSXutTr5SnXuJBxtFARtBKx9PXZMy2QToe7AkfZrnAddAAccdGmflyvlTL5gtssZrwmJHWjBoDaONg1tj8BRVoV8pTp6eOQACq98u+y4hu+esF7+LToQ7BJAKozAHer24CVjvDgEQCJQa6vai/6Q9iujbZmvFmDO1swB8m4tADSvsObTdvP8EQ+9VzeLq21Zsd+SGdP4SX1fEurlG4tt1eflHLxdYgzrFfBCnfLmSIAXXLNA0ct7tsuL1fIxp2JuVQZ4oTzMpZ2cA1VxIAIvSX8FBEXEAXBF//VK68C7bYHL3BzEJCmFEgLKkFpBBsgoiBJS6XT4pHaqjgPJbKy6Gvidh4oDr3zDW8MDHvur4TFXvSg8+8XX2LNtl8+Xd1z3kXDTF2+uxbO+9e8+FA4fkdpxjn7z13863HLbnvB//umzAmE+GL77H7fnYtc+Rfhg0C9DsbMtk6P6tIAu5+2UpKZnxUcKvlL6QUwCmRBi916GmLDik4RVY0AXfIU48FKGg+XS8k7vz3h8zrbp0g4M+YZQGcdXCGDAfneoW64BSqZGsMJfxXEJWvAcE5eyRJ/A7lcnZMZEew2asFb2eatMb/5gZOJqoJm+E1bry447mBnxbWJmgrks36xTbzgQv68TNvYwBgF0lh3DSM8YxhjYDwJ0YWxnoyrGXMAj5jeDQrLMEvBSrrZ8Q4P0jOWezlPXnwPx+7Ku2H4ElGQ2SByBSgg2+EQn+T47Kr5EwNF2ZiMVxZFBfzEnmTjXlX0bpBmcb7r+7Ve+hg6+lOeZ51iBA9/ULkd/I5DlMY94QHjRrz093PSFr4a/ePsHwt21lfNFF94rvP09H1khZ3+CAV0wL/rIJ//ljBvu3X8wbNJuR7/1B/8r3HbH/ra2yi47eDP5BRwYBKoKdEm8YdUQB6/nbJvRDjtrC4j4tYigSzSDcdAlcbI/R8zwbj8gJ5QSONBgWYuY/LKaf/b2ae1Muxh2759zbZe1mNbFeIT5O9Re9GG7JJjz/axFpI2A6LiBLpTh1B8OYHZkfsb0rSTQrMhcGkGav9tnI4DTn9r6XQD8GYMY83duni4MwvAdMuaxcMAY2E9KTugHDYRhi+myCyxl5279bAe/1yhwAHBEEIs0ViJuEuEWziN4Ag/ilaUgLQhLxFQiziJQBY1W/tiNzsyYyKZ0lBsRG8Xp1MpUXqfqOLC2FFNd3fzOA8aBb37nFqvxCwW87Ny+Raup8+F1f/a34crHPTRc/oiLWu6E1I9HBHT5k2uvC/e8+53Dm17x6+FiAUHN9Ixn/1549MN/LDzn565s2+nuzNR4WNA2lEVpTtt5InDWWWhhtW6L1NNx9lj1bkBMqPCRgzAPaIVmRCsCdIHcvKgVd/oXhto3DjzRpjhXK6izR1C7P1NAb/h10Swf0MWpGg4waeObmVoYN5MUvrdDWm0nPE8IKpgcTkvI2SvNCdd0yXOnv+eAnJj70U+fjZCOaVK2U1G+Jmi7sD078TgYd6qGA/jV4W+9xn1AGL4xQJVTAtGaCS2ZCX1rVY+7gDD8MQ8AbKWPYD5QV2K8KWMCznMUAZvr+rxer8HngAEqGT4CMMI1PQK/pgEj9RYDW7JQRRhFEMXQFF1nRkVZHNf2X2gLQVYqQVYW4Ewsw3+r4YCDL9XwfSjvere7nG/PhfkO4AtABtou3/j2reEb343ADLsfrZ/pfFeBIgx87wc/Ff7gj/863PNudw5vXAF0SeW8762vls1veV8vKT/HtMVyPmy1c1Yv8Y9RR6oT6JLnD4IeAj0T07M1EdyXE/4QCNG0QMjHjMKpeg4gtzNRx9cBJhLzEuyZvENMePE7QZsiEC6wxOpUOQdwvotWBULM2dKCQfBKADFgMeH0XbevAH5W/gAjVoElfzCnbNcaBPu8Pxg0XQBffHv2+rwYq4EwgJssMMwLmFlpgaGKJ6HfxiSJ7eoxPa4rCIPmS1lfSHwzTs6BKjmg3W90e8EpaKpEqMSqYxhJjAJLEXrCNtPyFWnaLYavmKZL2sHIkmQ5Y96Y2cAWBQDioDQTc1pC/6mAAw6+VMD0Yb3l3S44LzzzysvCS/7wz8O1b3yxbTe9Y9uW8MLffbNtNX35Iy/qG/ACjwFdPvg3fxS2bN64Jss7BV64Abv/0ME1LRSveu9FCZ44PyzrHG7VQjuIBHQBxDgqgfk22X1bZ99Beb3KyqQU7RdW4hA0AF2wia96lbBXzzvo5TIZTlow7PLFii8T3n0HcabroEsd2xetCkAWgE5M/dCAUXflfl3q2FiqE98RPnfQJAPoBNQE4AT8PHjUfbvUsdmWQJgJMy9KYxl+mDpxzturZ8UkdFZj7+Hj0n4TCHMngTCAs3XRhAG4KjuXYs7G3M3JOVAZBzSumm8XwBGAEQASHaLOCrWKgoVdK+I04IwSGlBDeotWbMzEZUYxwGQS/TRMkTTlAsBxqo4DDr5Ux/uhvPOzr74yvOf6T4aHXfnrjee76MJ7hpcIlHn4g+7fCOvHyT3v/p/6cZtl98B3xakS6AtpyUNnWiXlQZfdNQZd8jyamoyrVZg/sDLfb5v4fF38fG0OpIkEDiSnNPQfmzvlwMvabKs0BQI8jnTjFqxj9p0BwDjVlwMAZpjAou0ClRiO6vtQQ14zNDVZTGAsg9bhNVazgrpSAmEmagbCsEsedStD7u+lDLc8bS84QB8N6AIcMqYB9rTOuFbvrf6bRV31BairWBgHnWSyg5klGRjDe69+A4+6pIvqLXZu2VQghkmALpgeceZUHQccfKmO90N757vd5bxwn3v9YLj8kotb+lfhwW/U9tNsQf0LVz1e2jD1NL1pp4FQeT2lyW9ROqZVyY0zbFNdzUQrgS4LMjVgtQ2Tg7oTq/DbpUrPKmHSdGF1fqd8vaARg8DoVC8OsBrPu3Yy8+vCxALzFbRg3OSoXm2VaoPWBOYPCPM444W2bIimSKx+D0JfkZ5lVI4ALpgZoVmGmRGTcL671fzBjApv6vqcCP+MX4xbaAdybSa0G/CvIp8+NTahbQZheM9YBEGjpwpinGnl82i1ukxkIOVqaTzOOdBLDtj20TZtBSABeNGFgSfALOnc8JYIyhBE5255+AFMiZiL/TKNj4iLtGEAcHTBpIstqC1cqU1NppdP5WWvxgEHX1bjjseV5sAObSv9zj972Rn5viFnvIAtN3zmi3Y8PnfCdkF6nACauwqsGRbCJwLCSlE6LrBjl8x8yjqIK1r+SukGEXRBNRinf1ACXdLz5c2QcAKK8OFUPQdYzaXNECwO5vy6sNKDqjoC/I4tU1FzKfMFU32tR7sGSfij7Zod6tJPoWVmbTqtNtV1s0Pe0eZedU9vTpDVZoDSjTFI3xlOdvnWMEVaL6Af88yyPjGqe6rhvjNjGrtV5c2M6CsZz9J3uGWQQBhpnmCOxF8VIAzgy2GN/2WIOZuTc6BSDqifztASq4ZpwhhgYgZG5qcFsCThJiQaVx4DUixddm0gTDQvIg3p0aIZV17WJDlSium/cBOnyjjg4EtlrB/uG+8/cFggy1fCBz92k4EtXEOYILEbEltPswX1sBGDPx1e0W4N+2QAaTM96kNnOKigC4IFfD2kVbWVVtyxkb/9wJxtMc2uOr6rR3VfF+/zZmlJTMs0jC3CV/LrAkh2h9oMx7tRC4a0Rb+e6p5vWO+MILJBmmWsHiMAtiIEd4TF5JAXwR7/ME7VcGASgTcDOPdL2+V0i3GEcabZHwz9Y6u01TzF6N0VP2X0j4xZrXY7aoAwCdAQCANwNhCaMNk72U8QhnmULe4jZRYk5hTM2ZycA9VyIDMX0iyXdxgBAoiEN5nLZHbEjtG26xFaK5YuQin2mwWFsZzJooAZyiM+gjVkogxKdqqSAw6+VMn9Ib03Gi5XP+/V9nT3uecPhsfI0e7lj7w43FemSP3a6ahK1o5JbRhHukWJfjB1uEXzlE2HCcEWrUbRYe+vqTO/5mdiVTCBLqyiFXFAyCSW7aijGdKUATBMYp36wwHeY7QiEOJRmT94dO2to3n/D2h1Hge8O2Q6dkyCPKv3Tv3jAKvsbNHODiuYFBX5ZmybY2nBYOYyMzVtGhYrgWz9e5LRuhMA2HoJj0cy58hrPT0aMfyR75ztajN9o+xg43PxtTjX3fid0vbDzzhmRmsRY5ppwgjQ2L5xyvpWnNzWWbvTzJEEuuODhTG8HyCMLWCVVHhlswMn50DVHABoYXLOL0CJmQpF1MSqlmawYC7mCwptF86RNXTgLY5p9Kv/mbFSDFPnbtdKFPNH7ZeYU3Xw370AAEAASURBVBmdKuGAgy+VsH24b4pWy+te9pxw8Y/cK7Db0agRgkwZj/toaaDin7Zz7Sa/8qALE7YiAEY3799OWe2ALs33YbLKCj67IbkZUjN3enPNCuImCXUntQfibfvXBl2aa4GfgPkT2pJawjyq+KzUl/mOmsvz62IcYAUeh7r5LaWL5dQ0UBM72ol+xszH5EQZIMBNkYpysL10SduF3PadlERPDDgTCOP+YNrjf7u5WpkZFS0LEAawJplyImwxzhUBSoveo9vpWoIwmoeU9ctSpF70QWUBKcAhJ+dA5RxQ/72YgS043LVzISWm5WIOdAWVJPAEfIXXlj/z7UJPEN9jYBbQlwxuyY4ZMEM+SxkzWxm6dqqGAw6+VMP3ob/rY+XLJU/NPl/+6o2/GX5YWjHDSKz6Hyzhc2ROAid5ugm+jCrokn+fWNGdP3nKzZDyTOnBOaALAjxCAD5AOtF+SMI8WjCYIVFew39FD+o+ykXS57AizXeCtlgnhCngHjnl3YhzV7Xb7FF3yNsJP1fLi9YKf5361ADYTP5gMPsDiJnV93ayxNi1Wj09bjkH1jIzWp565SsWUOYX5m1xAZCaa4DTgQJh9L5R526CMHwTjBdlCK0xJ+dA1Rww0ERAimnARxyFlY2IqSgQbN2CAVAskY6EEZghMfE8FkLcosyPTLtF8fzTNkpKbBni43LpVBkHHHypjPWjceO3X/eR8CfXXhfyPl9+XjscnXfOWUPLAITRMpMAhMvtm7uz45NpjWgSjenTYGm6qM76V9S8qOjL02yGZDuAFM3s6VblAIM9KuVT2i2i2zsW5bVgmCAf1ETdtWBWbY7CkdGR54RtRcxKereENoAz056R5gtmf4szEYzrVvmFH3BIEyZtF9oPbb5u+Wvhu8LUjHGLXeTQVkCjggm8U3c4gJkR41sRM6OidwQ05Q8Nz0EEYegjGD+6BcKw02RZR9LTDr4Ufd08XQ85EH2waEKV+lywEv1rACz5e2dpgFFIz7bRnKNtGgGYCLGQmaSEWZxAGHAa06ax8HQzXTj1nQMOvvSd5aNzw+e8+PXh49rd6HLz+XKRnOzeW2ZIm4eeAUyOyzrQxUcM9sftCpiDCLrwIrAayAQsv9tDL16QZIZ03s71bobUIYMT6LJRk34mznuPru23oJ1b5rVg8EdySPdyLZh2OLmUh9VhwCyEtl45pAZs4XvGBA2h0B3yLvG/3TOAEczx0FTppoZkvj58W/xxr3O3rzcgHPMkB2HyXCp33omZUdE7nQnCnFK/fLJroGrRepRJB8AHgIgJlfmE6RCEaWfuxByNuZqTc6ByDhhCQi0MRrHfdIVpEa9p0lsxbZYwLmBF+xgpXwJT0HNJyjL2PAa06EwYC8Xb0SL0g/OXRRzzOlXFAQdfquL8CNz3Rjnefc7PXRGe+/NPGYGnXf6INhnQBKMo0WkaYGNYddFcIQw66IJj1eZto4s/fbmUTFKTGZI7dS3Hu5QawR0BHgH7tv3HU3BPj0kLBu0w14Jpj9UIGWUd6rZ3p6Vc+H4BKGDXq50Cz9BqW2mnsqVcfpbnAOMIJkH4prhjtnvaLvl7NJ8DwLADD8D42dtmHDxrZlDB62Rm1OuFhVSdPAiDrzOA8bo7LjcTqi6AMHwfADpliG/LyTlQBw4AoKCdkrRYDCixawEkAkoAwMFLIipjOjECT7L3V+GcRs2XqN1i+YXWGKZjnwUFkAawhlMgHIuow+OPZB0cfBnJZu/PQ6+l5XJ87oR2P+qOuU1/nqj4XdZPjWviU9yo8ujcgoRazJWK5XHQpXhb5FO6GVKeG8XPWQ1HmAB0wQSorHp38Tu1TokWTH57Y7Q2XAumNa/yoYAupu0i/y6YlvQb/KDdMMHEB9V2mRkApAHCMJl0Wp0DmBntlOYQ2i6zR06tnrjLsWhg0m4I71s3snuZ/PjomzvJFj1Oa3KgF2ZGa940S5BAGDRK0PQcJBCGcYb3jbqjrVrUgS6gfFn/MdOTDr4Ufac8XW85kICQBLDE8dHQEiEloCXZu5qNm4a7pNdXR07RgiEa1y5cJ2yGiwjuCHKxSKAXEvDjVBUHXO+oKs6PwH2vfNxDw5/81T+EW3bvtaf9xrdvCfiAefZvXBMe8NhfCdf82d8OLRfK2hIfl9NdJh5rEaDLTmkAbNEEhZVlVHcHYQcjBHcmggwiaLowIaySmNgdnz9tK7vw1Kk1BxjzEZoBBtkOmp1V+g285GuGGQSOXdGmoF6+epnnzvJznBaj7cIsC4e6/QZe8rXh3tSB+R51KtLX5fOP2vk29e/b1M+j7dIrM6MiPDV/MPrmDwmEQfOMPzQ0nVpzgLGEcY6xpZv+XVrfbfVQxlg0mNbJJxcaTPQHdSfTulI/wdyGd425TpHxmf6kLBi/XmazTs6BOnAg9agRFJELAiqVAtFWAfPO0BTrfkFnGExPKy47NyylsaoR4y1qWZgKzbJyC6fqOKB2a7RMdbXwOw8tB664+rflbPdQ2L51c/jmd2+157zownvKD8zF4bH62z7EPmAwyyjzdZ27Y2ZF1XKcyW0RgIGwie+LQQBcaOzGrks6r3oyai9f0w/qyphEwFNW5Z0iBxjg2QkHrQkm8UyG60TUj7rZDi0SDgfle+gHD9F2AZxCSEZr4iQ2jTWiCdXPHPKqToCg7pB3qXHy2i5Vgi5LNVp+hpAL6EmfYP5glkeP9BULDAj0B7XTV936o3Ua5+jPATI63SWrn428QX08fGUHLgDAVsA/YwE+isqYwZLnTju0GOTkHKgBB+798tcblsJORuMSGhix9Yrar13pAlnCwpYiLUUMBZ2JGi022ivxmHY7wi/MspIAcigru8PNL39+VoYf+s0Bh377zfERvB8Ay8VytvuiZz9dTnfvJVMjVmOHnxB+TpVAX6xzpXe13jPyZ2BBF03yEAAZDg7V2NcDduKsyCMMsvWu74YUzK8KwMYJmRiUmdD284vmW8GRK0IOjkg5AjSMOgFGJcCsjsI77QMYBBCLII9DXoR42nLUCW2XSZln0Qe1EjLrwB+0C+gTMA05W35FaDf8Z+WGrDpUs+91SGZGd0jTpI6EuS1AZwJhAGIGAYTh3eIPEGaHtGBagTDmK6/EPIv2cUe7dXxLR7dOBoYAjNh7TG+a+W7JwJNoSoRZkZzs6l+DLKlyZ1oxICtyuyslmejTxZzxmkzRlIcyckGN8vykbxxw8KVvrB7NG/3lG168bIcjTI+++Z1bwvr107b70bD6fKG1AU5OabJalOYXTpn3f4Qm8rLiwyQBu3viSs4vit62q+lYWUugC5O7uq0ArvSwTEzZshP1bM6L2pqvVN4ghs9Myq+LALOq/Lq0wzOEVEzv2FkHJ5P4hSnreLGd+9YtDxoT2zdPm9C+T/yom7ZLK34hyGOOxDtn3500Bqo0jWpVx36EoX1nIJT6+YNqu0Ho55M/GACjUfYHw3hH2+GDCl8rdac8CLNFAAwgzCCMd80gDH0H8yLM4tCuLTvPmJAplpNzoC4cSDsWRUBE76YGAVy9xE2kYy0jviLEhHC70IklEuCSHclneQBWAGb000gbixEwQ9nRP0wW5IcKOODgSwVMH6VbJqe73xDg8ro/fWe44TNfajw+ca/6zV8OD3vg/Rphw3SCJkUZO+Q5+X0BcGFFGNCFVcU5B1369koweT51Gk0KqdULOBoVMyTUUHdKcMc5Kn5d6rrqvtKLgLDKRHzOtGCmDKhkq9VRoGRiNC3gbFBAl3y7JIe805OnAoI8fSDfHm06CsQzIzwOogNpBF98QLFQgH8OnPHy3Y2KU158qABe9Gs3o25+D4AwOOBmq+ctcm6LyEbb1X3RIYEwaPftEujF/Ir3DzCwDDE3c3IO1IUDfH+oooChmIMXHXGgCxiTxsKxRUyIIJCVuM00fmBsqIzIjMUCuIzZNtJLpkgWoYQxOJYbtWyyLH7oOwcc/u07y0fvhvsPHA4//7xXh1t37wvPufpKY8AnrnuTgS6/Jue7swcPDyVTAFHoJosQEwgmBBwR+lHLx3t/6niLlFFFGlb+ULlmAgdYRL3LrkJVUe+V7kndUR3fKC0YnP0NMzG2027YywPyVe1Mt1NeAxohCDEbYWKORsEwE8IfqvjCC810bhC0XVZqj/jdxa2U0YJBuBpm4t3kHWXivPfgiVIgfd34wne3R30m4xbPRNsN95cHWC0n5BojGCsGfbyzuYYcBAOgYcI5CCY5mCpiLoyWI3MQ5k5Fna/zbjI3c3IO1IUDGAsZ8KIRYREnumY2pKmMAO5xQ1d0bsiJ3l67JodI5xyzJPGaiZ0EB1IQzpnJEabxAqhDxhgez/y3Cg44+FIF10fsnh/82I1yuns4XPPy54bnCnzB+e7swSOm9fKf73FB+PAN/zK0HBmTBstqZKuG0rRAdZmJBCvBTOYGAnTRZG1YQJfmNrIJqdoBQZDJ3bARW3MmbRd8OAyLzw2+G7Rg2A4bR8qYtAwbIRzxbJiJsXqNs+hhId5DADSAJZ5xEATBsrznnYzadXpPtWJPnz8MhBYCfQl+RfAHM4wgDGMBYwK7EzJGDAuh9Rl3RFu0uciggDAsUKGBxdwJ4A9fRGuBMGvNyYalTf05Bo0DGgekwTIOnGKoSQagIEJojABKSeZJaK00FGEUDXATTYl0osUYy27pg8pTPhNDVLIi0h47EewZNB4NT32HT6oYnrYZmif55nduNb8vd7vgPHumu93lvPC5L37VzvH5sn/20NA8a/ODrCQ8NEAXCRj42NitSStCFKvYa00emu/R72tMowCLbKvrAdd0WY13qDizcwWC0iBs07nas6S4GamZM0nleQAohgV0Sc+XjvgOYVV63Xj0yTAsWjA41OXbOy5hCeBlGP3b8Ez48Tki8yM0e3jmtFqX2ncQj7yDaavm/XKqW8YkdZCeF8fXe9R+mLTwrjLWDQPRZ/I8jAmD4N+lHZ4PGgjDN7Wg/iKvCbMWCIN/LCfnQJ04EIEQQ1mEv0gIyIElEUqJ76yWZSPSQgL7D5qSnuR0BG5iVAbUCLJRcUL4QV3AdjJwRydLGVMBfuwjB4ZjVOwjw/xW5TkA6ILmS6LLH3lRuP6jnw3f+PZ/hH/76nfC+eeelaKG7thsW3wG6DIbQZe0+Hl0bkErhvVUiQV0OW+ntmeUJHTrvuMDrW5d9EVDCwmVelTMt0ole1AJ4fUsAX3sGoFfl0E3MSrSDnxTOJMERBt0LRjU5FlxZ2ePPQfmJfwVd+RdhFd1TMO3x84/ANi7tg62BhpaINs2ToU5tdswabus9N4kfzD0NYDXgE6DDIAmM6NRGffyIAyOzNEoqSOhwYn2S6IiIIybHCVu+bEuHDCfL4ajSCSX2RHaK2i6mCsX/cR/hreY9kqMAD5BTwYghSzk4ETXlGWIjk6Q8tPqhd1D10JkUj6yOPWfAw6+9J/nI3fHyx95sT3zBz92kx0fe+nF4cYv3Byu+PmXhB+4067wqIc/YGh5kh/ot2gCgwBsmi5NoEtiAOrM+TwpvMojK8+ALtihMvk8PERmDkX4yoCGivnCyUUTgFfSZipSVr/TMOYmvy5HpS0xCqBLM48BKgAsJrXDBSBM3TXL8vXnXcMpK8LP/sPzUTsuIbX5hEN6nhzyouVD/4kQn+aRg/DISdsFLRC+vbygOAj177SOeX8waI3QFw0SJTOjE2hjDZGZUdE2AIRhzKfLYQ7AXKBOxFyplQYZIAyaj9Q7gUep36/b/KpO/PS6VMOBzNhIOAlqKpCAF15e/SVTIS4NfomIjAE0xC9m9kf4hjEYRhnsCGhDmIoE3IlhpCFQV7FACnWqgAP16kkrYIDfsvccYFejq664NLzg5W8OH37Ha8N50nR54a89Ldz9gvPDwx90/95XoMI7IDxh479pZtJUY3cLdFmtz2PFkH7RHG6tlrAPz8REK/l0YQI26oQGxSnt6MFkDmGw7rshsSq4WcIOE2h8MYwyIcQj/KKJhlo6AGLdtUcwc0DjivZDg2CUCSHethRXn4QGEOZyCFh1JrRd+MN8qu7vWq/5iIC8e/8pA9DoPweh/eg/AfsGcTejbrcnJtHsQob2Ft9fHXYDZJ6EJiBzplbE9CnVm12peO8Yswdp8aTVc3nY8HEAoCWCI/Zr4IiBLnq/LY4LYBOlS287IMoiH0EGssAVS5UlsCxZ2LgBNipBcWjLWEryOlXGAfntoYtycg70ngM3fOaL4aIL7xXWz0z3/mY1uoP5DtHkpeiXxiQBQQMNmSqIrU+ZZDGpGcXVvrV4zpCFBsWCgJiyW1yuVXY34vHrAujC+4PzWQRXpyUOMGHftnnS/CtFP0vVfGdLNVp+hnBg75faDSFnGP26LH/icle0H0IxhP+NuvEHbRe+P3xLsJPRsDjULddKK6dGAwETVrRKAEHZIr5uhJkRCyA+/p3ZMvZ+C8zAhLpKEIZ+Em0qHAUXIWTNrfouMb11cg7UiQP3fsnrl5RR9J4yx2RWYkcEB17eLIAwYkybRWERV0k5UiZLpB9AHbncRTtG30sEX2K5lPfvr3h+SujHPnPAe6E+M3yUbzfsWi4rtS1CcFHghTLmte0vaur9Xi1lMoyWDragByTU4LTU6UwOMAYyKUcriFVAVkarAsrytWN8TmZtaEo46JLnztK5acHIlwhaMPALx8PzOb8BSyn7e0b7oemyUYLpIGjm9Jc7S3ej/fjm6CMBqVjNRggs08culdbdM94p+gVAz9nD9dbM6e6TFy8NUB/QGuHdnJkLxOZ9rwOIlsZATEwPHTtR/KFGKCXthOZnAmHQKqkChOH+Zbb5pn9gwcTJOVA3DuSwlVg1vawRTtFsXJF2HgMMOdG+qDZPJ8KCs/SWmQmqEZFcoE2vc159S0+Y5bJU/lMNBxx8qYbvftcR4sC01JeZjBelOfl9YRLfL/AlTTjpoJkEl5nQFH2mYUyH1gRAmZkhVejPgXGVCTAmDoBmdTeHqsu7wPfFt4YWBSYGVWrBYGJEG2KeUXQlty58rKoe0Rn2vIFVOOTFufKJirS80OYAdJmaGJOviXnXdinwUiR/MPjg2LF52t79KkE0xkE0KfYL2KujNk4BlvY1SSsQpp/fIONdmXkVzFkvcNvJOVBHDphvloYX1nEpqsRFW0BDw1N0rVAtMuhKk75FgdgGqgCo5LEUU29BM0a7H0ktJsGNQDjkNU0Y8tSRCSNUJ++JRqix/VHLc+ArX/tuePO114Vvf/+28Gg5Bn7O1VeGqclynw2TOjpH+swihACW1OqLpG83jYMu7XJuKR8CII79MNPCXKvfZkgILtu1mwhCy6j7dVlqleJnSYsC/0ZnS/CaPRIBteIldJbSfELp3pN6d3CoW4fV/86eqL+5aT8AY7beRouCPhYBsJ+aaHz3O+wblG+eI8VB9v5yqr53Y7zjD6fS0Z/ISduhrJ81ZktzzNnoQ4uO0/2sX53vlUAYNNFwio2Ad/jYyZ4DoSxq4cerKDEHY87j5ByoHQdASPRqAsBEVEQDmckLBpXY6aIBKVGIkL+QzIxI4IrO80AK6XjXI9jCkTykSDsc6Wi2SrEsRThVwAHviSpgut9yMDjwm6/6n+Gpv/KycOfzzw6Pv+xB4a/+9vrw9+//eFuVZ2JXhkC1y+YpWj4TkJ1bpmyihOND/Mu4tktR7p2ZjsknZki01y6ZIfXDoR8TXRzHoiHFvWlHp/Y5AP/26DvYulFbAkuQTjtjtF/i2jk3aeV2h77DEzJxYDcmB17W5tlKKewbtH7slGkvbJhZt1LSroYDGLAb1R26d90dAHf1wXtQGMA1YxG+ctAmpI/rNUX/SlP27dGPOvDSPseZQ9B+9KUsHm3dNNmzsZCxtqy7yn6My+1zz3OONAciNiLQJAEieHQBVIlH8BOSEE2vmICVqMmigNRxAcSQlmKSyosBLbrOSiMv5TlVy4FyS/jV1tXv7hzoKwc++qnPh7e86bfCj93vHnbfr33z++Hv3n9DuOrKy0rXA/v2U1rdK0rCXiQAqv8snmXNogFdWOFHsGSCxGqjU/c4gB08AsPZEhwO9MgMaZ0EEzRdAOcQVqoys+ge1+pTEtoSADDsTIYWzH7MWHrg9ygKfHLYLBOZWb0nDrp07x2gXzs2d8p8V521dSIc6tE3gr8J/AVh9nDw6Hz3HmDES+IbpF/DdBIQFB8dvfIHY4sQaLu5mVFX3zpAGEwncWyLGRfzDL7LbmqjjWluhF+eMjSxrvdgXpn6eFrnwBIHgFYi3JJ50F2KAiwhWmRgjIEpQChCV1jUNc0XEmTp9FnwZcTSDKYxHIaz6HxXsSUXg7m3U3c54OBLd/nppQ0RB659w4vDvX/oLo0n2rVja/jiv32jcV3mBJ8OZcCOo3ML5sOjW2YsqFVPT64zR3k4F6Vzduo+B5h47umBGRJjZfLrsk/mKb0ABbrPjcErkQUkTLjm5Mtnu1Zu8QmDL5huEKALu7wkdXl3iNwNrp5ZBmrY9Jv0d6zA49uH7Z5p224Q2i6ArPsEnHkbdoOjZ5YBqIw5J76YzB+MvkdAmG62IQsiu93M6EzmdymEXR756wUIw3txvOTiEXMwJ+dALTmQdWzR7Chqu0TYxCCV2O+BrwCwGKEVg/ZXBFwsu5ksKa/CIsyoOBvz5PZACciJHxjK4LpLw2Gsjv+W5oBDwaVZ5hlGhQN54IVn/sK/fzP85BMe0dbjM1lI3WaRAo5L6MOfR6cANZoud9qx3lbXmWgCAHmnW6QF2k+DJgO7sXTDDIn25z04d/t6s+3FJ4EDL+23TdGc5gxUWjBMajCBQNOhE+L7Z2ceNNpYFXahvRNuFsuLM+zkvBhfIp2asfAOnKt34bTmr2hIeRsWa4dOUiFgA8KwQxJt2Ok2wcnMiL55X/Z9d1I/z7s2BwBgrM/TuIgmDOBlJ8SYiLPdMotZ9N70wU7OgTpywGYX+okWQhmwAkhCmFVYYRp3mk3t0IQxMyOlia51BbxYYRagnwjkUATl5H29pGTEOfWfA6750n+e+x0HlAO379kfHvXwH2u79mPqFTEXKUJMNpl4otq+V9viNne6a5UB6IKmBH4Ids+6E8G1+NXteFoZM6SZzAyJiX5ZEyGExc3aQYV3AQGkm2rb3X7eYSwP4GVJC2bKJvtld9fAxM+EDZXlDnWreUvyDnk3qR34LvmmylDSdjGTmJIr7mXu42lbcwCzFUyRGNcAQ2mHMsI3pbqZUWve9isUEAbH2MxLWBCib6VdyxDCKHMi2r7MN8zcy8k5UGcOjGtMWtQLbg5zVVGAFVv9AYTRP/7bj4INlOGoEFN+YTjLXnFODWmxeOlXGGqT5bcM2jHJnMKQ0KkqDrjmS1Wc9/sOFAfeLUe76+SE5W4XnG/1xvnuhz52U6lnWEePWYLwV4Cwh2NVVKSLUNJ0YWUP0AWTCYRIp2o4wJalmCGxDW3RFT92T2GFEIesvAPs6ODASzXtx13RcMAZJzMe2qWoFgyrs/iOwRQNgd99u1TXhskh7zEJf/Sn9JNFKGm7kBYQvKypQ5F7eJpiHEj+YPCTBCiNSVnRb5G+lz6Yvti3kS7G716kYi7CnIS5CXMaQJiiGimkZ0v56GepnCkoTpydnAO15YC+C/RdmKonMSFqwaD9svTuJi0Xc7SrYEtvPzpXBovXNTliLtRlYrm2gEtacun/OBZITpVxoJhEV1n1/MbOgf5z4C3v+mC4+nl/EE6cWBrg337dR8NLnv+z4e3v+Ui4+PHPDu/78Ke1PWyxCXx6gnZ24GCFB8GN1R7MT1YiBHYmMjPyc+Cgy0pcqia8YYak1Td876y06wJjLALCzs3TBrrgU6Kstkw1Tzj8dzUtGAkNaFFgPoTvlpUIIQETCSb8gDas+DrVgwNoT2AyNKFv0dpoFVCbNsa5NVoW/JVZaa/H0w5nLegTDURRW+IPBhAmJ58se2j6WttGWkdMQR0AXcaeyi7oTwHR9hycCzPyxcK3uBoIw9yHORBzobIaTzzkanOnypjgN3YOZBxIC6QJPAEjicop+HAhkX7AUbLT5DhX3ZpIP4qLYAu/SqUDYE6iqDsDCKNdVC1H1LJJ8X7sPwfkdyc1e/9v7nd0DtSJA4Auf3LtdeEpj394eM7VV4bNG9c3qvcjj/4l+do4aQ54n6u4Sx7yI424oies3CUfBEXzpHTRVn3azIjyW5qiSo3ATj/LipL7A0kcq+cRbYgtWoXNmyEhOJhzUAl67ahi1/NJh7dWtNfWjXHV/UBOowUTIwR2hAhAFxf06v0O8M2hEYE2S94hL9oUttOOhHxW2R10qXc7osVEv0pb5YHOhpmRhPx2BPZ6P/Vw1Y5vDm2mSe1IZGaCOdM+2pY/gJd2/SxhqrbSosdwcdKfZhA58MO/dU2sdlR30XxeAEo6Tw+keQfgiw5G+XNi7HpR0IrlXUoYnesqlyYuSPsxP2jNWPi3Vz0/K80P/ebAyst3/a6J3885UBEH3vJ3H4qgy+MeGj78zteFzZs2nFGTyx95Ubj8kRe3Bbqkwhj8MQdiN46yBHCD3w9W8aYmp8JRTTQR9LBlZrKCaYNT/TkAcIYjULQnEAj4c78u9W+3fA35fAFdNmjFlnakTU/JmSRCIIL8bjnUdao/B/gO7zgQ/Yiw8k4/ioo34Bn9q5sY1b8NqeEZ/mD0bU5oUQItUDRkHAStfzvSRmjCJBCGMZGFCDRWEBaZ+7RLzLkceGmXe56vLxwwkSCDVXTg0vy8SKUFPzDmKFcTD53GSB3QYImShAL1P14rxNItAS2nFTkuQAY3ZxzNvEkgzXgbcohu6dQlDjj40iVGejGDyYFnPPv3woU/fPfw4Xe8tiXokp7q1b/9q+m0o+P01Lg5Dmy3ECaaCHwICPgC8RW9djlZXT4mmgclIOxQO7Ki5+1YXVt0cme2MF44uRh2bZu2Yva24VS5k/t73u5wgD6VbxJgG9pzQDsZnXIwuzvc7U8pyR8MZmX4ZYLuUDs68NIf/nfrLgmEAXThe0Q+xFysE2LO5eQcqDcHeEcZcyLkYmZEBpQoRN9A2smI7wEgZnFcJ/rPT9JssTgDbuRQdzEbv5R2TEWn7ac5QtEAyU79pyIOOPhSEeP9tvXgwNv/x+/0tSL4EBgfW7DV8jI3xo/EFq2sY9rArinTmpygMo/Gi1sOluFktWkZ+ljV26i2RFinXXknmGC6f5dq26bs3QHO0D7DHwjfIL4nMP1DAHQaHA7QjvjjQpsJzGXnlqlwRNpMaDQxoXUaDA6YmZEAbcBsVogR3gHRDujam3Ew2pBaon1mzubVlwLG0K9ibkQ/C8hWhgBxGF+dnAN15gBgiDnGBTwBMNF13meLvfX8EM/uRaeZSXKtlDrlynCVbMDiG+LUwvTNWImkszJi2XZPK8R/quCAgy9VcN3vOdIcADRBvZadbKxTXYUbCOcIeKjNYtOeNF0AXfDvcq5smfEv0a4t9Cq39qgucoDBcYOEPPy9YN5w277jVjqASzJDwsyBd8Kp3hxA62zzhgkDPu8QgJZ8grCLyrZNk2Fa3+whfaspvN5PM7q1MxMHbXtLH0sfmtrrjoOnDehmV6TZIwvetw7AK4LJH2ZGLEwkE9y0NfW5O9eb4J73BzMAjzSSVUxgSX4xgjkPYycaTZyjqbYWCMN4y1gLsOrkHKg9B4SUYF6EQGDAC+fAL6AnaLEkkCUTGAxU4aHsmkwxr5koKdDglszEKIsy4IXkViZ34RZOlXHAe6bKWO83HmUOMCkAUMGJXKvVVTRcAGlwQMdqOgJ6czomIkxSOtkFYJTboF/PPq2dqJJflwS65O/N6h427Tj5ZLWWlVun+nFgLYe6CO/7tR1x9AUjLZij0b9P/Z7Ea5S0lgC06YPzRDseEAiKJgV9MN8nfXACZ/Jp/bx6DtBn8m0yFjaPkQ1/MAJLcbqKdlMCZ6qvudcgz4FWwEuKBzjjLw/CrOQMG2ET02y+XyfnwCBwwMASYSymwkKFE6jCOcALB370t6i+Lsan5LqWJgzvvQE1FEI62RtlOSPgIo0Z27Y66yRRoHGqjgMOvlTHe7/ziHOAyQaThOZJI6t4m7Uii9r7gSNzZ0wo82xDc8Ic8aocwBzyONWDAwl0wSQFjZbVzIoYD3E4iFDIluH5lb96PM1o1wJAZcN0MYe6+IJBCwahcP1J14Kp05uDkI755pS0JPJaS63qyPeKaSCah2jBoLFG2zrVgwPJzGit7YfNH4w0mI5P4NxcY+uGMQNhANWc6sEBxj2AFeYyq2m1JBCG9HyTLEDlQRgHXurRnl6LchzAb0vSXkkATDQ+isGZO5hYaFO3ZXouhrcA4YiyojghqWEyQm7MV4xdR3AmojlkcKqCAw4NV8F1v6dzIOMAE0h22piUGRKgC4I33vl3zx631dYMpF6VX0xW2NUBYR/7aEPAV83hkb3kAIMd23+zHTGgyz5pQ6wGvOTrAniGCQTtyPvgVC0HENbPlkNdtiU+cPREYXATLQkE95M6ni0hgfxO1XKANqAtkqZZUU0WhLs9asv1At92yB8MZkpO1XKAvhFNQcyMEMCLEH0wfTF97I7N0+YLxISVIpk9TU84wFyFsY65C3OY1YCXfAVoQ4Aa5kfnaP7E+8AcirmUa7zkOeXnA8GBNGnnCHiSVdqO0lDJjzhosxiQkgkH0TRJaWRHlBzqGuqiMpK2zLLyDJEBqMmXWp5Lp06dCrfs3qtv1lVoynMvBJ/dt8M1z+Mc6CIH0FjZpUkDk0NAlyKAS6vbY66CmnwrbZpW6T2suxxggEvOdFklZ3LYDuG/h7xuhtQO97qThznQphl8BgC6LBQW8JrvjtkDwiHC3okF14Jp5k+/rgFD0TRcS9tlpfoA1KCNBoCzU8Li0Tn5npjD0fJKOTy8VxxIZkZ7Dq6uFbrS/fEF4/5gVuJO/8LpY5mrJGe6Ze/Mt4c5IFtSA7rwjTs5BwaRA1ErBU2VnPaKXnBMh5IGiwEqTDIFsiRzogSyxGFoUXCKYiyNZTMQJ45RSqFwc+Zrp9o/yZCZ9rj17vffEF75preFhRMyz52eDC97wdXhyY958IqFPfjJzw0HDx1dFv/fnn1VuPrpj10WNkoXDr6MUmv7s9aaA6zYMLkvupLX6mHYEQCHoExGEBZctboVl7ofZiZGMhU7rZGulV+XsndkwExmSLQlvgqKas+UvZenX86BvEPd3bPtAWj5EvkGERQ36f1AVf6ATCDw4eTUew7gVBcB76hAsHbB0HwtaTcc8rIbi7Ul5oQyMXPqPQeSmRECdzfMa5v9wRw+Jr8i82622/uW1Kpv9l2iGYqj+U6IORMLWE7OgUHlwCJASMRHDDCxEcW0YQgkLnu/iQBEaXpQYhMkk8pppFGkxRloowJUrpXW5rC1Z9+B8Luvuza89Pk/G57yuIeFd773n8JLX/Pn4WEPvG/YvnVzU83iJfNZwJaHPfB+jfidO7Y0zkfxpDO9o1HkmD+zc6CHHGBVr1NzEyYzCO67ts5oBwj/xHvYXKYujcNj2gyhoNvOchEy8GmAajaggFPvOICJEZpjbANOOwJkdouYfKANxXfJPdCQcuotB1gJR+MInrN1dLcILZj0rds9ZIrEu+PUOw4kMyP6wm4AL6mmyR8MJoLrp8fNef06AQNOveMAGmjMTfguOwVe8P3CnMnJOTDIHGiYB2megPZLY9YOgoIzXY5AJvG/ElmAmR+ZFozlU5IsPMEzpMLnYCQSqYDs0G4v99FPfT5s3bIx/NSTHhkmJtaFZ1x5WVg/Mx0+9s9fyO7T+nDu2TvC3S44r/G3bcum1glHJNQ1X0akof0xB4cDTOhZ5WNykrrNsrWP9u3zturbrZXCsnUY9vSYBU1I6IK/vdRKSWZIrOCvl+PXbgM8w95ORZ6PSTyOVfHvcfDofJEsbaXhPUlaMK7R1BYL18yUVtVxjtuuacqaN1ECNJryDnkBBdCmcOouBzo1MypSG0AY/MHQv+4UYEefi4+nhtxSpBBPsyYHVtvRaM3MuQQoBWzX+Et5Ts6BYeGAbRUNOKIHiuAI0Iqu7CJGEJe0VyzOoBqpsZhmi9LHZMpC3rjDEWFjQnAwajKFGvV3mYFTadbdvmd/uPN5ZzfysfBw5/N2hd137G+EtTp567s/FP7xE/8SfuBOuwy4Of/cs1olG5kwB19Gpqn9QQeJA0wqdspEoXknpDLPgKCHqj2rv6jlAhI4dc4BtBZMUBc/Dxzpj7DF4ImgB0jgQnvnbZhKwLn1WVunwgKCdJ/M9GhLtGDmpaGGFgyrvy60pxbp7AhwTd9JX4dfj34QgN1R3Yt7A5Byb4R3p8440G0zoyK1Sf5gAGFwfo+/J3bYceqcA3wfAKO37T/eUWEIj3xnvB9OzoFh4EDUThEwIlAkqrkIODHAhXFEJzrYNtH5bY9IysNrQrEEpAC5xDyYMpkzXmOQUiq9kY7mmNcyZ2E6HD02F/7ynf9nKaDp7MrLHxp+QCDLocNHw/T0cm2zqanJcPjoyt/1Ey57YNiyeWNYWDgZPvTxm8Lfve/j4d3/63fDObt2NN1ldC4dfBmdtvYn7TIHPvCRz4Rvf393eOZTLlvR1rGTW6bJJytyS6qD5Uq0nZDkb4LVw7MAcyTApz64XEmeOvl1oS1u3bfyQNNLTrG6TpuidYMA36nadi/rWueyAV3YdhZTrn3SMKtCWAYcBfBhW3m+Tfz6uI+m9t6apO0CoAVgzTfST8IUifZzh7zd4Xr0uzRpJped+EBrtzaAMCcW5qyP2Lx9Rn2t+4Npl5fIeCwk8Y10qrWJALpTZn69Al4QQL/wf78eDkrAfPxlD2r3kT2fc6AUB4BMjOwgUFFzTE7zIEkc0WLKRZkiGZqCPRIaL+M6EoZ2C6gN0Yb/Z9oumvWnEdFAmXQ/u2n8YfeifbOHciHLTxdORhAaEOXEwvKF3Pn5hbBl04blGXJXL3nezzaufvVZTw6X/dQLwsc+/cXw9Cdf0ggftRMHX0atxf15O+bAv3/tO+Hq5/1huMv5Z2tVbD68639/LLztj3/b1Ok6LrypACYZbHXLpKUTAZH8jZ2QtD0nq+9OxTjQAF00fPXaxKhIjRBG5uXk8yxNQt0MqQjHlqfptkPd5aWXu+I75J3iHTPHsG66Uo6BSo0/ENq0n9ouK1USh7y7Z6MWDBpq3XAoutK9hjWchQI0NXtpMlaEdwB4OMdeN35SYPdk2DAt/0EyRTolLTmnYhxIWirMXTr1ocUW7+ndKHb3cqkAXq5+3h+E7/7H7WHD+unw8tf9Vbj2Db8R/vM9LihXkKd2DpTkQEPzBdAkoiZRa0XXNlfXcWzR0BSdkCiaE4GyWG8U1WSyu6LxglaY0istqcFoLBc/p/STArMcHABVXvaCn8uFtD49+6zt4Xu33NGIBFT9/q13BMKL0KaN68PGDTPh+PHemXcXqUfVaVxvr+oW8PsPHAde+pq/CI+95KLwrv//d8P73/rqcPGF9wrPf9kfm9peLx7GtqLWylGn9s1MfnA8ibO7CVfZLdRUONNFMwHBDg2kXvp2KVShLBGD9R5pMQHCIOQxMXVanQNouzB5n8n85nQqDKx+t3KxtCMmgpPr5PRT3zqaHE6rcwAeGa8kqAMu98vMaPVaxdjYX8hMUMAQ7xzvntPqHKAPoy+Lu4PVZ4EAEIa+/6h2QsIfDFqH7pR39bYkljkGcw1MKjvta5n7sLtYr3Y1whwC4GV6cjLc+IE/DR979xvDC371p8LzX/7mtR/UUzgHOuQAEImNEJrX2XbQugJPWVTfk2Z28YxAbpbSRxzFABqCAVkYaxTAkXDKA7YxHRiLJ2EMj2flfi99yI+GgweP2KIz2jJvv+4jYW7+RHjkgy+0gv7vzd8OV/78S8LnpUEGffkr3wpvedcHA75i5rU19Z+//QOBHZMe+KP3tvhR/XHNl1FteX/utjlw5Njx8Igfjx0Nhbzmpb8WLn78r4X3/+Onw9N6qEbHJJ5JTCe7PaA1AVLNRAaHvlWodLfN+D5mzPt1wadDXSmZIeF8EIHP27N1S22cWWcgmvnnqKkPByZK7OayQXV1LZjW7ZhCNwhA2zA9YX1hnUCXVD+OySEvdQUkYhtjvtfGRDmfeMTPEa7pw3j/69qH5f3BnCOQCK0Y35q69Ytr7an5CmbOnS5YUBZzn17SjV+4OXz927eED7/jtY3boPFy9Ohc49pPnAO95YAmAAJVxgWWxK2nMwCFmwKmWCy/pBOUYqZHFphptgCySCNG/wBuLI9OoqNdXQvGUUw4TVkCZkjSDp191rbwkuc9K7zqTW8Lv3fNX4XJyYnw8hdeHXZsi9tMH5+f17f0H43FaO73P9/2vvCHb3673Q6tspdom+p7/9Bd2rn90OQZ0woqLenkHHAOFOTAT/7S79hKJpovif7k2uvCm/XHqgkqdb2ktJV0J/dgBSkJeJ2AOZ3UoY55k4nRydPa7UKT60EhBlPMkOal3o2pg1PkAD44tm6ckACwqBXYhYHxqcL3yQo7i1juC2bpbUbbBU00dliAL/327bJUk3Jn1DfuYjcmgMEd8ua5t12CNbvG4f9okGajmCLRv7g/mHxrBnMKj2P4bvhe2iKH5JtUVi8JrZdHX/WicM+73jn82R+9sHGr3/mjvwif/fxXwgf/5o8aYX7iHOgFB+73otcbpGIoit0AaEQAiTrECMToWv/pHwFT7MJ+o6YMWfLhlk5hEbIhfZaHYnTKrkpCb8KXX/sCsrZFJ0+eCrfevjecd85ZtuX0aoWw4Ltn/4EwLw0Zdjlat853KUsaTavxzeOcA86BHAd+/7//Qvj3r383fOt7tzVCn3P1lQa63PTFmxthvTrBvwErQfSf7RJCC2YOM/I1wYrjqBOgCyZG+I9Ag2SQgBfaLpkh8Urs0qoswt4oE2Ye+DjaLgEJk5RBAzCiqcO8mdIAkuLbZ9QJDRL6KlbSuyHY9ZOfTD55Bw/Kces2vZe8m5303/2se6/uhZkRGpj4UBk04AWeMEawA9366Th2jLopEiMOQBpzCuYWnQCjfBtoi/UaeKEdb9m9Nxw4dCS84sW/yKXRUWk3v/v9N4RffuYTU5AfnQO944ABKszjJJKj0SKAxIAXuyNaKgAxEXKxpKbaEtMTB2FeBMRiDncNYLGrmClLQwJCAV5SPi7boYmJdeE/nX/OmsALZTMfPUc+YUjvwEvktoMv7bx1nmekOYA66l3vcl74jd//02V82LVzW7hj74FlYb26QBUXoazTCTw7vaSJTuzCe1Xj+pYbQZf6+XVph2OYpbELEmrxvCOjSKamLi0g1F13z84NjLZLq7ZCKw0BDxObHfreR9F3CNougC6bpPECkDbImnrsxoSvJt5N/JuMKqjGN0q/iz8QwG5WageRIkjq/mCYO7CjEUfmFJ0Q8xHmNr3a0ai5bseOz8k300xg/pboL99xfdguM4qnPvERKciPzoEecgCTIAyDcKTLbfDQQqco3RUdWFyzLtIiSRDD6ThlSESGCM5YIsyKSBLhlTGLjjowBBtEExOQzakiDjj4UhHj/baDzYE//O1fCd/4zi3hfR/+dONBjslbPip1/aK4E5Kc53bonBOBBjv7s7WlZqdl9evZu3Ef/Lqct3O9nNbG7Wk7tU3vRp26UQZtebtAh83S4kFte1QIYIKdwdCQQMsAc4BhoKQFg+DONqtoaY0K0ZYIYgunokPiTlbT68Qz3k20d1jZR4uxV45E6/TMqS4AafRNu2ePB0xoh4HwB4O2B2MJwDdjy6gQchzfKOMOc4lOCIfjgJL9Al6o6wYBL2yjixNQCEeh/+Mt/xCe90tPtWv/cQ70mgM41s3QFTsAm4yZdst4vBYCY8CJ0mX4iqqUgSykzVXQNGN0bWEUq5NGCq6lXRPT5HPlCvDTvnCgt8aUfXkEv4lzoP8cQPvlV37mSeGlr/lzefv+R3PWdpcfOMd2PupnbZi0M1lhIs+OKe0SK5Cof2Oysr/DstqtQ7/yIbxu3Tglk46T4dZ9x/t1277eh5V1VthRA0e1n9VITB+GkZj8Y4oH0IRQO8iaEau1D8+FgGOq/TK94Vlp52EkgLTNGybMpwaaP8MCuuTbKu3qgxbILoGGR9UHsxvdkDap7cgG6EJb7tXuQcP4nNEp73HbmvocLWbwjQ6zU17GUjTyuuFYl7IAcfpNF9z53PDgB9zH/L48+uEPCB/4yGfCEx71INd66XdDjPr9NI9p9Imcix/R9AjAJcInFmZ8iiZGBqJYPsXrwmYDuo6ZrQCVAYAj2UBjKlGGvAzntIGnGxhyh7sD01Re0TpygNWST930ZVNZfchF9620ikmDpZNKsOLEBGj28HyY6wDM6aQOvcrL5A5nnQxRTIqHRdNlLX4h3LHaXOedRNZ6hpXieTaE9AW9q4ckvA4rwNT8/PgmwqklGj6dgK7N5dbhmu8UZ8OATYDCo0DYxG+VtsTEBI6Eh88hL/5dMDPifR0WbZe13svoNFu+ffTvsJx9D9t3av7iugS80I/3ekejtdrra9/6j/DhGz4XHnLRfcKFP3z3tZJ7vHOgaxy43wvlcFfISNJaMRQmIiV2j4SnpBsuwTExJAI1Ol+WkAJZkLWCUlYdMwhHSM+Xrmnf4W6uQD9tgwMOvrTBNM/iHKgrBzrdiprnYtLIatYxCT/DokXAxH/UQJf8O5r8ZgzLbkhJMwKfGay6Lkhra9RoQir6CCyYOgyLFgw7AiGIDZpD3W69ewBP8ADtEECYYdBsAvil/9knbZdheJ6ybc2CBmAiYD8gDBqmg04Av93a0YhycEDt5BwYVQ4AvoCJmKWRMUFbTguJaSgrG16yKJ8w0mIRaGLpdDRdlmZsJQNXSMc8yeAXy4+2jPIoswE9Ov/S654/qiyv/LlHx3i8clZ7BZwDvecAk5hOV5CY+O+R/TqCACYOg0zL/bqcGBltl+Y2SyYOAGvsIjHIuyEBuPAMPNPu/XMjCbzQviflB2XPwTlbJMNshe91UImthjHTQDjvdKeUQeUB9UY7AnNBwETadJAd8tLHMBbRpuxmNIrAC20K6DJM/mBYyKCv6fQ7xVyU98OBF94Sp5HmgIEjUfMFLAVzI7MUEkoyrlO+FYCW5HiX+DEzI8qQF/JDOtpuRzolnmAry5LJma8FcLSE5HCqiAODO1uriGF+W+dA3TnAyjHCKR12J4QZE2YcTLYGjZgc4kwXyRS/LodHxHxhrXaaVZviW2IQd0NiFQf/Nfh3wSxuWLSy1mqz1eKZQ7FbDCZl+DEaREEGTQ807XiGUTEzWq1NiWPHMkAY3nXMQDHbGSSivvQx+EBBG5P3dNQJXjAWSWHNgEZ2MBs0Yi6A8+tOHesyN+G9Zq7i5BxwDogD6iMNLrG+Eh0VTtBy0ZE4C9eOSPp2TOPFgrNAEtgp2jFZWq4tTBnsnNIzbRkLV7xTZRwYrBG9Mjb5jZ0Dg8WBtBNSpwCMmTHJMS2r0oOwExKgCxNEfGLgqNNBlzPfW3wuoDEBjwZhNyRAF+p69va4NS0T/1E0MzqzJZdCTpjGRNSCYcenQRDWk7YLT8H7yDM4LXEA4Jt3HZCRXa74Bjrtz5dK790Zfco2/dGmo+LfpQw3MSdjbJrSWMW4Oggaa4z9OPY/qrkAc4JOKAEv/dzRqJP6el7nQO85EFdKF62D5zz96dRsjCJ+gsYKQDYQSgxRSo0TmBKlf9TVsJUM8TbIRchNLFFmS2aHlCufDE5958DgQe99Z5Hf0DkwmBxIOyGZsCrV53aJFTvs1Luxq1K7dVgr3zpNDrdr5Z9BB02AUXGmuxZfVorHZAe/GvgiQEuKd6SOzmpZGWWHlAW9v5gYOa3MAeZavPtzCzIXVLuyy0pdNUm2yEnyzNSE1Zf+xWllDrDD1R0HTkcAUgIw2mt17N8wMwJ0oQ/GzCib+6/8YCMcE336nLAtlevuDwZwCC0VAKNO37tU1gg3vT+6c+BMDiSghM5TQIlpqGSgC4kJjugJoIlI6c0MSb+NZFleAiyVgJxYLFtLWwnKKDlA4QbIpCAr0H/6zQHXfOk3x/1+zoE+cgAABlON6Q7Ve5l0MfnCPGCDHOTVifDrgor7UQlxAAqdThDr9Gy9rAvjcd4MqU7aEmi7YEID8MIOKQc6XG3tJR/rVnbSgoGHaIHRB9SFqAur/QjqfKsOvBRrGYDRQ/oG9otnya8X7VsXypsZ0ac05vp1qWBN68FYFf3BnLYxjLGsTgRYwpjfFeAlM6Gr0/N5XZwDdeBABEuWNFYSsAKKEjEStFt0rnHAAsigP0AUwuOlgJUEvDQeKgI5XFIOGjLWOWd5Gsn8pO8ccPCl7yz3GzoH+s+BnXJst3GmM/tqJoq3yWZ9k8AXVuuqJiaG0a9LMFv641rpdyrPgWiGJGBN70gdzJA2yKEuJkbJSbCbGJVvU4RftGCOyGQFzSZMVqom6gAYRL0wvWD136kcB/gW8AWDY14c8rJTTNVEnwEghLaLmxm11xqMXdEfTAQn6+APBl9MfLOM+Z0uaDD3YA7i5BxwDrTmwLgGbUAU+0VBBbgkCzPQhGwZ4I4TXjMf4kh4k2I74z/xctdr5URwhvz6vyjTIzAYAp0q44CDL5Wx3m/sHOgvB3DI2Y3di1ipk5VPZY54sZWPfl004ZcgwvadTp1xgJ1zrF2lkQAIU8VuSPgVQEvLthpWu7pD3c7alNzRZGXOfMBUpQWDtgv3pn1NQHczo44blm8DEAa/GXwzVWitpd2M8N2DFhOmgU6dcQAtP8a05A+GYxXE9zqp75XtwTslQBzmHk7OAefAyhxglyKAlISJGKhiVwrJAjmg6XIaiEYXlj7LBGhDHERczEKfrHIVzk5JkDnwVfC4d9fGj6p+ql82qerJ/b7OgRHkALtnrNNkfZ8meFk/3RYX9km1nNVOJmlMvDspq2gFEDRQy2ZQcb8uRblWPB1jMyYDrKZjxoWg3A+BCvOJzfIBwra6+zXZ73SVtfgTj0bKfLuiBYPg3i9fMGgx8T5xz2MOunT1hcMUiR2iACsBTOExf9kcu6v3ai4MsIe+H7DAtV2audPZdd4fDIslaDmx+1U/NMUYW/HvsnD6dDgo7bROyMpSf+OOdTvhoucdBQ7QZyfAxMyL9NARSDHvL8AnhNh/+IFGC6otzJ1sa2kVwPdmCUzlhSv9WcGcxbyUFnVh4pll8Z9KOODgSyVs95s6B6rjAJOhnQAwgCYdoCbseoDAvEuC+n5t/YuZSK9o83r5/5CATp2ZjDr1jgMIcAAgCHQIzEz8e0UNh7rSvHGHur3iciyXdkUTBpPB6cl1Jjj3SqBD28WAUs35cObcq/v0lmODUTptyh/mPzhFxzdMLwERzE5n1O/3C5wdjFbofi3pg2+fnQuYIAGaMu4BdvWKkjNcAL1OfTEh+jHHcOClV63l5Q4TB8YS4oL2Cx+PXduJYBPTaYkLnGmKrYm7wS12zY+ulTyaJ+nEFF4IRxtGcXZKeFY+pUV0Z5jYOFDPUo1O40CxyCvrHBg+DjApYqLe6fbRTNKYEFIWk7duE2rX5tdF4wY28Q68dJvDrctD4wUzJFTPWX3tthmSOYPV5BzNCPx/8OfUew4AggBgIqwj0AF+dZtoU4A73iE0qRx46TaHW5cXHfKeMD8dZjrIUmqXib4AwJ13qB9acV2u/kAWx65lgDDQ2XJWvV5gTLcpAS+YPHUKvNi21KqnAy/dbiUvb2g5ILAkaafYMxqeQgggCwosgCikWSL8vhhFtCaM29FSR9cwWfrTlGxgjrRexkBlSMMOSDG7/1bDge734tU8h9/VOeAcKMkBVqe7sX10WqFDXRkHn8f01ykxcUsmRqywsoOLU385wGoJWgusdJ8t557Y/3dD4EI4Z5X+8LFoJtHfp/K7wYG8FkwARxulAABAAElEQVQCwE7b8lj7/EnaLgB2ru3SPh87ybkgDTJ8wbAjHU6r+cYQ3jts2obPIDcz6qR1OssL79fp2zIt0PUztujRDRNNNGtwrAvA0ylQmkCczp7UczsHRowDY3KCax50AUqStVDUWDFzJEATgSvgJWi3mN8WkBh17AbQEKZIyytgZZH0xEvTRUUrTkeS85vlc+xFDKmQHHypkPl+a+dAHTgAaNKpOQ+TNjQldm6RScPElPkiaOfZIugyofFhzBzpuqZLO1zsbh4AtfkumCElEyPM0/YdFJAjQdGpOg4kLRh8svDdHpR5WbsgJwAOYCnA64EjnYOv1XFlOO5MO6DdtFVtsmFavllkitQucJrMjDBHoUyn6jhwSn0nIAwgRzf8wWyXCeK4hDPG7k7JgZdOOej5R5UDGayS03LBjAiURCSUJAElpsCCTZHAFAvUAipxWcqYmOsMjCFZBGiUTuem+KIcOUMmJXCqggPdtxOo4in8ns4B50BHHACA6XQraiqAdgRdO84Yy9JmtqKVKQTOQNF2ceClLAd7lx7BzcyQJqIZUpk7YWKEc+ZtmybNvAghzoGXMhzsbVq0YNBUQVCnnWivooS2Cz5kWI2PO4858FKUd71OlxzyHlZ/uk3tStuWaFqrHsJ5MjNy4KXXLVa8fMZGNFUASxkz6VvLEmM0wEs3djSyraTbGPPL1tnTOweGkgNSWzGgRA9nPlqso44QCdemt5INyw1zIa5Zv0Llhf92ICUzcJWTJSSZXRNvZfBDKrvQuVMVHHDwpQqu+z2dAzXkQNqKutMuGf8d8wunwjmy+0ZNei1ich/9uoy5X5e1mFVhPIM7PjwAYs7dMSN/MGsPH+yutUNaFeTFoa6DLhU24Cq3RgsGcxVtciIH2nKUWcB/E2kQ/E5Jg+l2rZx3arKwSvU8qgMOAJrQtnyDmJnyTa5FfNt32rHevteUd608Ht9/DiR/MCgRMoYylq5FjMkAL4zRnQIvjO5o4PhW0mtx3eOdA6txQKCJvuHGbFl9NaCLddoCYjg1LIWghKATpgzmZFeoypguLI9KMQ2ZxcyvC3GGuiS4JZbbAHFWq5bH9YwDbnbUM9Z6wc6BweOAbUWtiRlmSOqi2yZWW09KoGPL4pVMmvImRia89XC3pLYfxDMu4wCTADSTbDckgSqcoznRTGhPYMqCQM6WpQ66NHOonteHjy+YaQkOW+cknB2Sz5BFGj1HTPK2aOexGe2YhLaLgy455tT49JDMynCmulVaEgjpmCKhHdNMmBnhM8bNjJo5U99rdqQDiIn+YNAwPGF9dHONk2kQ322n/mIQFNGYLQLUNtfDr50DzoEcB+iHQVJSd8zHJcCES04TWXBKQ6DO8f8Sw3W0k5QnS6gwxvCxbKcjQTGxOEdfElsrOa69dFlJtfymzgHnQFUcYDLFrgrWkXdQCSb6TPKYoDHpSwTogmC+RWYOycQIW3anweEA6u6YIeHrA9OERLwzOG88R84+2aYacxYHXhJ3BuNIe93R0JRYLlxFJ93TJrS7tstgtGe+lrQtfTLf5jnScOJbzffzycxoz8E59++SZ9wAnCd/MAePnjBtFMZYvtdEXQVeVKwDL4mzfnQOdMiBxneqD0tT4fTV2lEaMWn2bBowSgCAYosiShA1X2z/IoXFnDabToWk8khLNS1SZUgzxqk6DrjmS3W89zs7B2rLASZtqJ3vkYC90AEwsmwnJGlJYKmCY86VtGFqyxCv2BkcYCKAbx4ctmKqcnTuVNgoMAYB7zaZGDkNLgeY2KEpgfYLAjmmK2hJoBGxn12vsHNwGlgO0J63Hzht4AsmKLQ17Yxz7QNHO98daWAZMwQVT/5g2MUIs0DMi/hc0Wr1HY2GoIH9EYaOA6aVIlQkabEYAKMxeJGtiqShwlzLQBNDTwx6UYAusvBoVcRW0gJlSEM4Zkwk4dwK5DzqvQDYnHbNFxhTGTn0VRnr/cbOgfpzYJfMhvJaK+3UGLOE41KJxikgwMut+467M912GFnDPAzsZnakI049506cNqe6NayqV6kNDqDhBNgCwLZRTnXdWXIbTKxpFsC0QzI9on9Gi4E5Ot9ynKzXtNJercIcSP5gAGFwZo9JYacmgkl7pnAlPKFzwDmwJgds62ilAg9JgAn6LUuoC5H6Y81DaeirjbKTmC/6hjHQpZFAqZTPIBd8wFjCWNR4Pk1WnB/6xwEHX/rHa7+Tc2AgOcDEfMPM2o78Wj1cNDHC7GidgS5MCNvZCalV2R5WPQfwHbFr64z5krht//EwM6UtUHNmSNXX0GvQCQcQ2nCYjPnY/sPz1rYAMU7DwQEAcbQc+XYxEy3qkHc4nn74n4Kx1kAYabAyBlv7qs9uh5gDMBdwcg44B7rLgaSEAr6C1mleMEdLxTATVFri/wyU0aVpskQUxUDzBnK+FGbmSVZdhVFGdujuE3hpZTmQb+OyeT29c8A5MCIc2LZxqpRQvdyvy4KZp8AqdkI6KgCm6E5II8LegXtMVmd2SaUdVXZ2QMJcgXEfM6STMlMjrshuSAP34CNSYQTy+I2Om48QzFSin5/5MKHdUhDC8v4kRoQtQ/OYfJt8o3yrfLN8u5gesbMRgCqA20SB3cyGhiFD9iDsaATQwljLmJv3B7NRmjDN/mDWenwAdeYATs4B50CPOGCgCDoqmaNdXQOuGJ5imIkCRBFfMV0W4Sj8Q4yPcTjDT2msJCVulKc0meKLjpkpk6X2nyo44EtYVXDd7+kcGEAOMClfNz7dAFJWegRWU1F1XsmvCyusTAZX2wlppbI9vFoOMLazowbaD+yocVxCeZ6YGKDefvKUHPFqxxzzG9KUJp/ez+vHAbRd8O0Sd1Bpbl/tXiVTlRmBbviTWGm3q/o9ldcocYC2264+GqG8+fvFFAktJ9IAzvAtuylS4txgHJNpUKsdjfAHM78wb+Nz8gfDe7AaoT3jOxqtxiGPcw50xgEgFNRaxtT/RiAl891idkaGvBiIEu2OIsBClgxqESCThWmCJm8uigDAicCLxWTxdhf9mElTZ1X23B1ywDVfOmSgZ3cOjBIHmIQxGcu6+mWPjtB23s715txvLb8ueUe8ADVO9eeACdyZxoOZKawCqiDUsaLOOwEY51R/DqDJYhot0nhIO+KsVGs0YfYcmDd/UK4FsxKX6hdufrf0Td4+O38G8JKvbXTIO2faTWhQ8O071Z8DjKV8j62Al3ztkz8YHPEyZrOw0oooy4GXVpzxMOdA9zgQzYdUnk2so1hupkiZmRBAi50mzRa2jVZyABYWvPDlEkEWXSvOCP8wWXxMGYOTU99Wc/iYwn/7wQGXevrBZb+Hc2CIOJC2okazBbV1TIzYNhoCdClKOP8jPSrQU5NTpklRNK+n6x8HGO9ROR/XnOCAtB4WTtqovmYFWEUHgNk0M2mr6Kyw+i45a7KtkgRoMrFtOFoObENchE5r1oeWBHldC6YIx6pLg5kRwAugdzIzWqs2fL9oOfE+bJPZCQI62m5M9p3qxwHaCEuxMmNw1G47adqMaDSi6YRmqpsW1q99vUbDywFAFJAXA1zGNL/Sf3RYsCiy/lanY4tp3sXFaQEuOiZwJkIvkUEUgnPdTGtGqSyW4NMqj52VYnLvyKt8oxx8qZL7fm/nwIBygFVyVkTZxpJBgkkbKs3t0D7tpgIAg0YNgoFTfTiATxcm9UzS8etSlpg4JDOknVsB2LR98SoaM2XL9/SdcYDvmB3IdDAgpZ3dUABsaFPeEzQkENDbKaezJ/HcK3EAR6vbN0/azkZFgbV8WYCte+SwdZNANvp8TM2O4eMpn8jPK+UAYycCHGNpWUr+YABcANnxCePaLmW56OmdA+1zYFwgSuxP0WTRjBpcRcUtCgAHRjGMJe1WpAjm3IAqCQgnLddkiqCMNGFUCOFkPq0zrhrAiyIWuYlTZRwQDubkHHAOOAfa4wAT+06Al3RXJo0nT5/2nZASQyo+4mzTHOpqtRtArB3gJf8ImCHdITMVzJCSllQ+3s/7zwE0XXbILw/CNRosnQAm5EUTDhAGLZiVzBj6/5SjfUe0XbZsmAh3yMyoHeAlzz36ABzymump2tgd8ua5U905wAtjZzvAS77WaLEyljvwkueKnzsHes8BwBVDTgSRALYYaiJkBYjF4uxc17qIkAnmRVm9FIBWC3GW0RAXzkBYAGOUj6gxK1lhBJI+y++HSjjg4EslbPebOgeGhwPYhbe7FXWeC2hFsDsDNujs1uDUfw4wSAOOALxgYoRQXtTMaK3aJjMk7kH546hbOPWdA2i7IJRvFBBG+6K50i2iLPxN4HsCYMcX17rF2XLlYGYECMY8G6EcE7FuEN8wu5sdlvbLWdJko6/wr7gbnC1fBo51GSvTjkblS1iew7eSXs4Pv3IO9IsDEQihJxVkgtmRdaoCS6zb1k9EZwxQwWdLRE/4JS7VUqZI9i9eRzBGKQBp1G8nNRmDbyivS2NCursfy3HAwZdy/PLUzgHnQAsOlN2KukURFoS9OcIbOyExuXTqHwdmpMXEKirC+f9j7zwAJLmqc31ndmdnc97VSiJHAzYCA8bGYESwwGCDsE18BJENIggJIYKMSEIiRwEmCUwGywhMkkgGEQwiiPRAJD0wQdLmPHne+c6t29Mzmp7p6b7d1eE/u9NVdWPVX1W36v51Ag51c5Eu1UfA8x4/EpgubN84bOd4fkeP1XW0ng8BtF04x2iq4DC3GW2XWnuVtGAITY2Zir6k10KqNencU5j4YRrEvZaLeKneWzScrt4z4uTa9k1yyFuNTTvWqyMa8cxsVhRKulkEVV8ININAJFE8bDQ+WZx/gYixNu0HEyLnY6wY3EyFjHHfLp5jHIxTMcap2LY3xw8VrHzxFcS2IldjjIybJ9m2pBwE5POlHNzVqxDoCASu+PEvwwXv+Xj4ze+uDre7zc3Duc99QhgaamxYwNRg0EJRY37QjFRHQnL/AqYNI2kdAjyX04R8KQ51m9kjzJAmDkybj4Eh8xU06CGpm2lPdRdGIPp2We5kF+RmK0iXuXuAmQrnebP5cxodm3KTBn1sm4tS3m00mtB6wcQPLZVWy1yHvPtNe7EVZE+rj6Ob2kerbK1HrBrJch+judrMh45JM3l687v+M3z6i98MN7zejnDqKQ8Kt/vTm3UTpNpXIVAyAu7ZxXgSmBVIFPtXDN/QLmy78LLmq5ggsUo5EqwUC/teSRp8C78sbcW4Gsr7lhW1Et4OFSRlIaBPy2Uhr36FQMkIvPvDnwmPfsbLw21ueePw1FNODpd+5Tvh9e/4j6b2ipe4Y+xLaLPC5PBac/IIoYMjT0lrEMCh7o5Nq3ySnNPEqJ69RbMGfzI4esREQmZI9aC29DLuo6PQdrlmb54JW717wX2Mhg2veds3SAumXtyWWg7CBTMvgHYzozYQL2kfuY9xyIumE2M/0a+K1/xURMtMCPAsXDUMuZbnPm6WeJky4uU5L31buPAjnwv/eL+7h3vd9Q7hlGedH674yS8zHbGaEQK9j4ATKDwkjSBhAW3i1In5aYnbRp7YoDpgRAvbUSLJUpRMSZGEsS0nY2zp9RPxYhvTFvIo5mmUjqCV89vYJ+5y9lW9CgEhkBGBC95zcXjjy54eTrzL7b3Vn/78N+E9H/1cOONfHmIT4cZ5Wb6yY4vOCyJO/JoRtGh44UQzQ5GQmkFydt2VRpIR5YbJMbi2wsRodo/zb/HRBtIHkg0zpL0HiZrVvBr9/L31Vyova4SPBdt2abvUQphoWZiqQBBgJoFjz/Rlr1YdpdeHwJCRl5gZHSjCQtdXK38p/P2g6YQ22+phu5ct6lWz43/+vezeFnkG8jRtVrMUBJLZUrNoXPmr//WPNu974/NM2+Xm3txvf39NeMWbPxg+9NYXNtu86guB/kCAG9ue14USix+zJ0G2kMjD3JRiPA3OBJLGlpAocRk3yKedGUHjhXd5i3dk7+Uxi0ozJbRWDgKNz7DK2V/1KgSEQCYE3vWa51SIF5q8773+MlPLsRn8PTSjzpx2htC1h23CxldVOeJNqDS25BmOk8xN6/I71G1sj2ItJuR8sScyC6SQpDkEIEDRNOEtq93aLrX2PGpIjPp7pLRgaqG0tHSIDshpzIyajWa0tJ7nL42pE2QqDnkZYzbY/jHmSBpHgGcez75R0yzqJOJlfGIiPO35bwh3/6sTKsQLR3n1zj2NH6xqCoE+RCCNkQyVrpVihAtaLpAkFX8vlun5VmbayJQ0rLJ0fRjKzvoryBZL9DawaDJx3RqvbIUlpSEg8qU06NWxECgXgdvdZrZd9nvMDOl2t7lpU1ovc4/IIyHZl/dm5aj5fSHKBo545cCzMTRXmonRNibk9uBtlUPdxvYs1mJyDgHjX/LtK6/MkBpDE38QmHHtMdLywJHO8peEPxD8hOw7PBZw8unRctJbZGOH25e1uDfQImLZbjOjegBHywlTJF7vIeEZeyRLR4BnHc+8GGFqfOkNzKmBw22eyTkErZcDhw6HN5/7zEpzR46OhEv++/Jwn3v8RSVNK0JACCyCAANlodlCSRzvQpiQDAeDFSkEC3RKDDHNklwKRFImbti6szckG0GDhgx1vWhcD2Z2FGvowZswK2Mp8qUM1NWnEGgTApOTBd1dR3+X/+DK8LynP7JS8o/X5vmCxZdZJlrNCo54MZ9A/XqVOR2U1IcAX1UI7cyLN6YAmCd0qjA558s5ZJuiIS3tLLm2i03UWOJnpSxTsnr2mq/47CPXJvfzcvNZIqkPAchJ7g0IDu6VTnZwy1jDPq4zQnCTkUX4d5LUh8CK5RYu3O4Nnnk8+5oVj2iU4Tmc9uOZZ78p3PgGx6ZNX15w4cVhzeqV4ZSH3HdWetoYGxsPn/ni/0g7JgGipRAAAcgRGxoL3mRG68USBwtyxYkUK+hmRrYcsOd8xYluQtHKThEtyZszsoVlZF5sbcrb8nBJnkaupCwE9MZTFvLqVwi0EIF3fvDT4fYnPTHc9l6PC89+yVvNGeLiE+6Dh46Gm9wwvky9/f2fCs97+b/ZQN78Sx+Hid+JHF/cUiQkN08xfxaS2ggwscX5ZVkOdWvv2eI5mFDwRX+dzJAWB8tKJG0XfKu0KrxwXTuyhEJJC+aA7fMWi4jEMUgWRgCTPMhs7o1OMDNaeG9jrpubGYGAaSGad4xJkoURwFcTZBUmgzmIF569PINzCuZFf1el4fKLq37nPuNecubjanbz3//zg/Dqt30knPSwZ4dz3/C+muWUIQT6DgFIlsS+QJtAkNhfjFRUEDOWxKTdSRfXlLEExMv6SpFPmpUjqfiFtTHPL7ZlqVQrqnoR/bQdAT0F2w65OhQCrUXgVW/9cPjsl74V3vSyZ4TVK4fDk57zmnDKM88PH3zLv9bs+MKPfDZs37IxvP+iL4S3mCPe29zyRuE9b3heVhOk5OSvWbt1nMTyUspXwWXLVgR8wkhmI5Ac6uLwEhOjbhQmbXtskkn4XCYPaO20I3xuN2GFlgvYuMmWTXAnkipyFx1E0oKBaMNcChML7nHJDAKYF20w4qViZuRfLmfyu2ENTZ1rzBQJLRg08doV1r4bsKneR+5nJk0843II7eXwvTZ3X97w0qd7pKPtWzeFTRvWhX995bvd/8t9qwiZuXVO+ps7Bv5+cdXvw8mPfUHYu/9QePULnzK3mLaFQJ8hwB0fDYtctcW3CggwHfJViBMrheqLr/FhFO0Xci2NZH5s04vYM7QwVPL6kC78c7Mlb8IrUElSAgLSfCkBdHUpBFqJwKc+/83w7Kc8LNz1L/4s/PltbxHe9Zozw09/8Zvw+a9+p2a37/3oJa4K/JVvXhHect5p4QMXnB2Gluf9UkbnvATiPDCH+nmKfsTLpSQigLYLfjTWrzFSylT+ISy6WZIZEhGQMLXA5EISEUjaLocscpBHluliwiJpwRw2R60QMNKOmLnKk5kR9wDEdSebGc3s9fxrkKdoZuGQ181RTbuDMUsSEeBZliLQNYsJz1ieta0gXti3e/717c1M+f+E1/7bx8KTz3ptuOXNrm/vDs+qa7dvfuPj7R3loeFr3/5RXeVVSAj0NAIwIkaiDNgiUi22biQKQ2MyG4I4IcWHSyvv2i8FMQP9EpswwiW1kwZWi3Y0gCmSkzTWrq16H3A3ktIQkOZLadCrYyHQGgSWmf+EH/7kl+F+97yzd3CCOda9h70onfbCN4fvf/6d5rA23vbfvuJn4faWN2Tbr3/xqWH/wcP25ep2rdmpqlaTbwrIkzHz/dCMoPWy2vy/4NSRiUk/fzFfZU4tmdAQxpcw370kh2yyhobEZpucYG6BeU2/CvcP55mJLNd8L4XzJVQx55njw0kr93c/39OYGTF5xm9Ks2NlJ90vaMHwt96iITF2c38TqrpfJWmwgcMR83fVrOCoF83QVsrg4GB48D+c6H/V/YyPT/iHnvstED0RX3SXfuU7YfWq1u5j9X5pXQh0KgJOqRT8CGRLcrYLSWJbttuFOgsESmRP/FAwJHI1F4qkMp6Ttj3Vq9AO5I6bMVm2V6mU1Uq7EZDmS7sRV39CoMUI4OzufRd9PuDcLslrX3Sqky5f/vr3UlJ48pmvDqecdp5v3+5Pb94W4qXSua3wcpgjchEvq/stegpf+XBS2G/CF87kUBdCixf4XhT3HWFOWjnHOI/EBKPfBI0Qotx49C8jJnqJeEnnMmo7jRoJM9m3WjBc21zjXOuY3vUS8ZLOM0sc8u40czkIJsawHBqR1e13wzrnmGcXz7BuIV4WwvV17/hYeO65b5/Xqe5vf3+ta7s86unnhit/+dvwuhc/baGmlCcE+gYBJ10gUKBF7MNK4lMgYCBNEDcnsu1BNF5Ig0who9B69XW2bWXatF3iPzasDSd1rHUaofGKfxkqSNqNgDRf2o24+hMCLUbg0Q++T3j7+/8rnPWyfwuve8nMy83mTevDJV+2MJAnxjCQpz3xn8MjHnTvFu/Nws1DwPB1u1nnkXwtx58A7eHAE+eOvS58AMExIxNyzE74ktzrwsQcbQ9MbjBD2m0Tt3Hza9PrwpdxfGUMmlabmxj1wTFDInJN95sWjIdaNyICYqLZcbEb7gs0uNDsQdMJh7yM3/2iBYMTXEg2xjSeYc0KmlKME2XKQ/7hHmFiYjLs2LY5oOFy8ecuC5dfcaX9/dQImb3hBsdtD//093cPZz3tEeGEW9+0zF1V30KgQxDAXMg4Enupc9LF9oq3mhmihN2EQIn5rr1iZanjHIpVgq6J6yQWdWOqczOQON4q9YyY6b/PlGDYOVLuKN05OGhPhEBPIXCB2V4/4qkvDT+58v+581wObse2TbOO8TE1wkHOKtSGDSZXw0OTTfsnmbQJaXLEy5fUfYdmNH/acBht7YLjw7cLJhnd6lC3GcCYmBMFBDMkJmq9qu0DRkzQ1hrBhknOocOjzcDWdXXR7CHU7ox/m942T4FI5XwzdvUDmVp9QXK8mEtyrqMmSG9jgCPx5Wa684fdeRyiQ+LkjmhUfX7qXb/R9XeE5z/jkV4cX3MvfNWF4WY3Oi6c94Inhxscv91JmXrbUjkh0BcIFNooUfulikgxwgQHu5E4MSQgWZxwIcU0YIpteJVYJhIwNOdi6dHMCDYm1olZyZypKKdF2xEQ+dV2yNWhEGg9AnxRwiHeQ578ovDRT345POW5rw0/+tlV4QmP/PvWd95AD7w05nKci+kNL7WEr+01seenhyBlgoLjSr4Y96tgirHTzJCGh+LX414zQ3LfLuYTA+0mtF16mWBa7Brm2NEOYJxgksl90GvCca1euczNjPqNeEnnEjKZcY2IV5DLhFvuxXPNs4lnVHIan46/0SXPzk4gXubu/5/+yY3DOac/xkjjo+GdH/jU3GxtCwEh4AhEsyDsimI0I/RYIFTQUHGdlogTzIsJ1IkvnWWJ657gefZTpUTn2jBWzx+ZON4lz6vMrpfqa9keBIxoK85me/pTL0JACLQRAUJIf+1bPwrbLIz0U0852b88tbH7JXfFy3cuJ6Jo1GBP3yvOZ1HLZ4KGQ91+nojPd1Ghar/atAZyXTvz9dHONCZSkC5MwjHDkMwgAPGIhgjmijlMNWZaLmcNPydEeCLSE1GAJDMIcK4hYYjcdqRHHPJCvJg1jl+/M0fa+BrEC5qQnSyYH/ER6Lw3fyD80/3v7oRMJ++v9k0ItBOBOz7xtRXNFCgXZ0cKjZfIrxTaLynLSjiZ4iUtr7JhtIytUzqqyCR9GEs3rmWgsFFyOscSvvOO09t5mOqrCgGRL1VgaFUICIHOQADCJIczUSIhod6N6QJmKt0ovFhjyz9txBSTs249jlZjD04QbkRC6lZfGcm3y7ARbb1CJLXivENYbF437OQUZGS3fkKCREpabP2q7bLY9cE9scE0wNBsg3DL8VxYrM9W5PMhAJKN+zoHadiOiEa5cbjqt38MH/j4F8LZz3xU7qbVnhDoWgTu8KTXOVnipIkRJE6UFCRM1HtBS6UgUmx1erBItYLwKRWCBs6lKOlLLxuJGPu1vPgLUPT1nXfUFxqe8pK8CIh8yYunWhMCQiATAjlCUbMrTMr5OthtBAxfM5JDXV7YRbosfmENGmiYKqBBxUStm4TrdMOaFdJ2WcJJg5QkxDrnutvuj41GKDCB3rV/zBwi8qosWQgBzjPkKj6euk0bTMTLQmdWeUKgvxFwzReIErgRaBF7HkTnu7b0lESqkE/aYCxjCm+uzFKQKtAzU9OWZ+34I8WWtEUCtdxhL+QOzZhI8yXiUMZvZ+sqloGI+hQCQqAjECBy0Wozv2hWUiQkJuWdaBc/3/E5YWRf9vnCj0PdbptYzndM7UhLYYpRc8dpZzeEruVFCdMKJpZ7Do523cSyHee1Vh9oOUG8cG+DIVh2unBN7rBrE4LwWvNZJOKlvjOGw2nGQs4x9/ZKI666QXjmcG8TjS+HxgvPRJ6NEiEgBHoDgai9Eh9eg06WcFxRuyWSK2y7XowlxyXj4AA+XJxJMULFllOU8Qo4443OXSgXiZdY1EmZyPLQqKQkBLrj6VUSOOpWCAiBchHgpRU/J81KioS0pjBDara9VtXnQYlqOtFt+Lrbzw51G8WYlwvMs8APjaccBF6j+7JYPSbihNdFiNTVrSYVix1nK/MhJnG8zL0DlmgZdKpgZoS51H67NuXfpbGzVHHIa1pine6QF5NXnjmY0fIMalZ4FvJMlAgBIdA7CDjNYmS8kzAclg0VA7adXLI6H2M/08lynnUfTooxxUNHozFDXXsQWrlpNGBs2+tC0jiZU5Snj9QW65K2I9C5bylth0IdCgEh0IkI8OWQSXQOidElBjoyEhIOdXdsWuVmJ7st2oe0XZo740dHJ31Sjk+NTpywQLBxXaO50W1mFM2dmfy10R5hUs5fp2rB4LdkjUUzwvyRa1PSOAKMjRAaI4YjYyakVqdJv0Q06jTctT9CoOsQgFUxfgSyBJqE36jfYmtFekyt/o0lnU6ximZwRCYci9fxlcS1WD4mR4j/2vMyash4kn5KQEDkSwmgq0shIASWhkDy27K0WvOXZrJ7dHQqbN+4MuDMsWzh2NB2QUODCYUiGeU7I0zKd9pkFzMkMO4EMySuOb/2TOsFjQ2RbPnO9+h4JNySFkwnnG/2ATOZKXs35lqUmVG+840pEmNmGkM74Xyn+3tsYjprKGmOUSIEhEAPIsADywQ/L2iqOHECTWLrBS9DIpv+C5EyXajBDNq6kzam6eLEi/3ENrxwquR1I/Fi6VQwvzGS8hDovM8F5WGhnoWAEOhgBHj5ZBLDl2P8JTQjR0YnrI3oF6QsR7w8CHEYyldbOdRt5mwuXJcXEUw8uGZc08S0I0Zt0laGoO2yxjRx0HSR9kNrzkDSghkemvLzjYPWsghNCFV80XC+uzUCV2vOUr5Wua8xz8QhLyZd40a07rPt5p4Qje1fbse6EDmQxp3wkaAxRFRLCAiBxRBwrRR7UZlGQ4XCDF7OupjpUDGSwZe48ooPbDOaLOi8uFj5AcgbGiAJZRpbT2ROXC+IGlp1AiZW1W/7ERD11X7M1aMQEAINIsBLKARMDr8OOD+E9ODltt2OeDEx2maaNzwQ5VC3wYthidWY/EK0bVjdfjOk9DV8yPyRcM2JeFniyWugeNKCWV7SBBYzI0zecKor4qWBE7jEKkkLZsrImO0lOOTNTbzQHs86ES9LvBBUXAh0GQKJQEl8SKRTInOS8kjDh66TMLYOyeJppPPHyyTLokxkcUhAx8V+piKR4+RMUY7yknIQEPlSDu7qVQgIgSYQyEWYpEhIfJ3eYM4RWy08Htl3fD9g/oSPCkn7EOAruZt+2JLz0A4zBbRdtllfh0wDY6+dcznVbd/5Rgtmn91jaL9wvtvhfJlrir4QmRm171ynnuY65G3HPb7OSDaeIX/YfTRLRKNE5KRj0lIICIHeRSDSJknrBa0WO1ZLJN21YhKhwjbp9lyjTCRajJ6hvAkOemNV+2XF/2K+5xjzksgbr6Cf0hAQ+VIa9OpYCAiBZhAg8kMOjZUUCWlocLBljnh5iPJyvmNL4VD3gBzqNnPum6nLi4qbgdiEHDOFYdNCaoUMFhoXaLvg6PmI9ScpBwF3vmxaT6ss8gymZ5ybVsjwUAwDzLmGBEgvxa3oS23WRqDikNfMC9EwbKVDXhzrct6jM/fa+1RvDkROIu/qraNyQkAIdC8CTrYY1TLl2ivx2eTkiqXBn4RBqBNfc2ukgqYptF9wzWt59p+a/Nm3pajtYonkkpnK2IaTNywl5SEg8qU87NWzEBACTSIQQ2/m0Vjh5RmnmLxM5xR81WwptCz+aF9Gy/I/kfOYeqEtTEEwAcIMCRORnIKGBdcRfUjbJSeyjbeFOQrnG3MkNJFya8FwDW1YIzOjxs9Q/pqQbtdaCPfly6O5am4tGO5xnhm5iBfaww+YRAgIgf5BIGqloMkCiRL/It1iflwgTixUdPILA5UyCNNCupWNpIqlkuSUi6X5Ju1Q2sRtlLyka76wncJYxwL6bTcCIl/ajbj6EwJCICsCq/1rdh7ChIny0bE8kZB47BHieMOaFeGAfQXHKaSksxBIZkjYS+cwQ0KjYrNNoNCw2GvnW9ounXW+2RvIT0iY1WYOxrlqVgum2sxol2m0KZpRZ51z7vH9h8b9fkTTDcK+mJI0vKOYBRGxjKh5PDNyCMQLGjQSISAE+gyBgiRxkyIfnRLZAovCaGVECgvXjDFaxiMbxVFsyvJT2OgBc7o77eWpRxUImBksvSVTqfGm/HcmT2vtRUDkS3vxVm9CQAi0AAFeWrdvzBMVIpoMjDXl2HelabtgYjRhkTcIhapwwi046Zma5EMT/nc471vNJKXRCRDRVrasWxHGCkfO8u2S6QS1oBnOjUc5s3PVjBbMCrvPuWbQsMDMCO0aSWcikEyRIMdwyAtp34gkfyz7D9uYYVHzcgjPrkbHnRz9qw0hIATKRCA+N1wbxZ2y2Lb9d67F2RPImKjpEqkTIhuxxj/IGKdVCp6FcnYsvNg4wRJrUN83TYsGiXowvqqfEhBo7OlTwo6qSyEgBITAQggsXzYTirpZsgNHvJAmfCk9eLT+sMB8Bd9omi6ojO42HxPN7sdCx6u8vAhgIsR55wv00dEBD09dTw9oTuCngcnTnoOjcqhbD2gdUgYtmBHzC4KGGudvn02o/Z21jv3DzAiTwmvtPhfpUgdgHVIEkozzvtHO3+rhYT/n9RKl+BhDcyaar5m9UZOSiJwmm1F1ISAEuhgBNymy/Y+cCZosHIy9ReJoF8bE/jvBAuFihSKdQlrMh3txGoYGqEu6NcJ7qJsYUYMyvhkL8SspDwFpvpSHvXoWAkKgBQhgPsJLbbPCC/lOI2DW2BfSenyC4FAX546H7WvobjnUbRb+UuonM6QhNBrsOlrMJAVtl61G1iCQdfVO4ko5OHU6LwJJC2bctNQwJYFQWUggWHHay8utmxlJ22UhuDoyj/t8t5kFMlYzZmOCtpgQDY9nAX67IGmbFREvzSKo+kKgRxCAXIEg8X92TMaqxI8ARqA4mULetPndZQN+BWImpjnTQmFnUyzNV9mIaa4hAxFDXcr50EW52JY3qJ+2I7DwW0bbd0cdCgEhIASaR4CJc45ISDzCcKY4ZFo1mJTMJ0zWMD1gUsaLOSYIku5FgPeTPUaeYYa0HSJvnsk4pEx0sDrkvnz4mi7pbgSSLxh8NOH0lC+FcyWZGaEtg6maNF7mItRd28kh71DhkLcW8cbYTzQ8ngU8E5oVnk08oyRCQAgIgeg4lwcOo4v92aoTMaw6sQLdQhQjT7A1CrhOjK3HstSLj6y4hFzxEpAtFaLGUniwJSLGa+unDAREvpSBuvoUAkKg5QjkjoRkijD+ZXxZVZhaSJe1ZnJC6GI51G35KW1rBx4Nyb6OY56AWVGSam2Xqy2SirRdEjLdv+RcosHESyy+YAgTngSyjWthp5kZHVbY8ARL1y+rHfJCvPHcqBbMEMfxEWTESw7ZaBo0c/vI0a7aEAJCoDsRgFiBXXHahA38sqRE2+R5ZNGmfTkAmeLraMcYmWJ/aM0k6iUSKxSxQk7WWG0nXGI9/Mrw58SMJUnKQWDmjbKc/tWrEBACQqBlCOBUEbIEM6BmhS/dqKfjrBFNByZiB410OWj+AyS9icD4xJRPtjfZl+8tQ8Puw2eNfbVmIibSpTfPOUcFmToyFrXdDpsm23IbQwaMh5GZUe+e8+SQF6L1OHOWvs8iJGFqtMfu9RxmRiCniEa9e/3oyIRAowhAhFTRJ9aMMy/enJsROYliqWi7sO7ECpSMUyyWZvwKXAtJJrPaM62XKXt2DXofkYehhBMzsbh+S0Bg5rNOCZ2rSyEgBIRAqxHAkSYvvTlk0vxCYGoA8UL4aBEvOVDt7DZ41zl4ZMJMzwbCWiPf0HAS8dLZ5yzH3jEZ51xHZ8qDfg3IzCgHsp3dBmM6YeLRUOF8T9hfDhHxkgNFtSEEeg8B999SECjx6KBPosaKxTVyxRV4lQEbi9JoFA2RZkpXcgpyBjIGNgZCxtetphM3rlVTKR0b0G/bEZDmS9shV4dCQAi0GwEIGMJ5ogGDmnkjgh8IJmKEqMX2Fqebk7aUj5dG0OyeOmuMcOG87zHNJ95rNtmkjHMu4q17zmEje5qiGWFmNGhfHPH7cXhkMhwaGddHw0YA7ZI6mJFyz2N+htkZTpgPGyGDNlQjguYlxAvR+CRCQAgIgXkRqCijQLYYOWLvGtEp7pTRJowdM++tbmpkZSBVIFcoC1fjwnaxSoFolmRtYHrkhE6sN1MhFdaynQjoadBOtNWXEBACpSGQQlEvNRJScqi7wjQf/mAOdfkijubDNebvo95ISKUdtDpuGAGc6kLY4YyTcMJjFuEEMyRMT4iGtNkm44tFQ2q4c1UsDQHOKT45ltn9zrnmnI+OT/o1sGzZdX3BlLaj6jg7AtzTK42oZ2xnjIdkxYk6JmfHmLlpLYe8tXaEZw31RLzUQkjpQkAIQIsk/sQ5FPtAOJOGDkzcZs0JF7YLhiUubdt8wbDuS9NuGeAvlcHoiLyqevqCUO51J/KlXPzVuxAQAm1GYCmRkKod6hKadK7g+4PJWq1ISHPLa7s7EODLN5GO0G7B90O1uQnrREPCD4RHQ6pyytodR6e9rIUAEcs4p25yZOd47nnnWth/eMLvdzQkJL2DgJOp9nV4Pse6++28Y4qEQ96NBTG32JErlPRiCClfCAiBhACkCVwJBkHTxva6oopvWZplkO7ETEGouLZLse7p/mMNGMsyzV9R3tcK1RgvjikSLaXyaQe0bCsCIl/aCrc6EwJCoBMQ4Ms2piS1BEe9OF3kizemSkzGagkv5SNMxE09vToSUq3ySu9cBJK2CxMnJmELmZQR8QZCDme8moh37jmtd884h0zA95p52ULRjJIWDNoMmB7qnq8X4c4sx/lj7IZMnY94SXvNMwBTJM7/MVaeZ0Qt4dmiUNK10FG6EBACsxCAFYEPsSWcSPTNYitGlAzaX+RJBtzc3YsamQI5Q04kVIrWbGN6Gte6lmc/lbJkU8cLmxcZyBhfL+pp0XYEaj892r4r6lAICAEh0D4E8OGCaQFfs5OgVr5u1ZA9l6JZUb3+YZis4YyXl/jdNmlfiKxJfWnZWQgk3y5ouyw0+a7e6xQNCeecm5evCPvMCXO1tkR1Wa13JgIQbuttsrzcCbfZ2i619phz7NHPLPIVk2yinhGaXNJdCECybrHzt9fGbAj0egRCdmx8xB3yrh62uofNj5iZKCXZbP5dMF2SCAEhIATqRgCzITRWcOLib6CQK8VaImBsmIkaMRAxZEYSxpmUop4TL5YHv+INxB/biG151CPP40dSFgLSfCkLefUrBIRA6Qjw9ZKXZQQyhi/ZOFZsxDEvL+97Do76y/yqFXr5Lv3k1rkDOFPFt8sKI9748l0v8ZKaT2ZI4zYBw2QF0xVJdyCQzIw4d+5I299o6993CBcc8q4qxhGIHEl3IJCIF0JJ10u8pCODlOcZcXgUE7RhN0UiT8RLQkhLISAE6kcgPjfcHAgSJf3RAOvFYwU9l6i0Uui8kG5jEU51K/8gXrzj+IuWC/8Q06MpSBkqFo16jn7ajYA0X9qNuPoTAkKgoxDgK2U0MZpyh7rN7Byq6ztNNR0Sh8n8ftOEkHQuAqtNc2GtaTpBuCyVdJl7VGg/jJlJAueetg6ZBo2kcxHAzAiSlHv06FjjWiuQb2i7rVu9PGyTFkznnvCqPSOS1ZCZjV2952icjFTlLWUVLRj+uOd5hkiEgBAQAktGYBqtO6NPnCOJZAlkSuRMIFxs3fmSgjBB48X+OVnj2jJWnSYGE+FCecv3TZztUrIgYSx9wPrzukveUVXIhYA0X3IhqXaEgBDoagQwOeJraLNClIxrLVoGYUrxISHpPATQduErNRoLaCs1S7ykI3TyzTQhVtqkfqNN8KQJkZDpnCXnhHOD1hs+e5ohXqqP6uAR8wFkJMxqc9bMtcU1Juk8BBiTGZs5V3Fy0tw+8sxYahSk5npUbSEgBHoJASda7HERqZNErNgRehrPEUuzzGk0M2MhP3ynX9B6sSJmiGR5tET5JAXhYpveKiROMehVl0qltWwfAs3PNNq3r+pJCAgBIdBSBPDfkIOA4fmIGQPPOUVCaukpW3LjaDtssckx/lqYgEGW5RQ0ITj3NCszpJzINt9WtZkRzlM5VzmFa4lzz7W1zUzZ0KySdA4CjMWc8d2MzRl2i2eFHOtmAFJNCIE+R2DQnkUQIq7lgqYKAxRptvR18IkFzHio4FCsnI9jUXGGEi68d6JME82RijbIsfqk0VNRM1bQb9sREPnSdsjVoRAQAp2MAC/TqzJNmoicctRMkRQJqfwzjiYC5gbr7Y/zgqZCKwUzJPrBJAFnvpJyEUAjhXOBmVEuTadaRzRLC8Ym/FKCqYVUe9IhSY7dvMrHYqLT+YSlya55Roh4aRJEVRcCQsCZFMYkSJP0rEBJJbIlxRLKpNBsmYKcobz9OjFjG5A2vk4bsWYs4WQL+ZbBH2KLwSnvIG43+Ds5ORnbbbB+P1cT+dLPZ1/HLgR6CIHf/XFnuPyKn2U5IkJRY5qQQ46Y/48DFhFj+6aVWbRqcuxTv7WBtsvWDdEE7BozCcut7VILz2SGxERNZki1UGp9OtivNfIF57i5zIwW2+uKFkwRBQ0fUJL2IwDx4hGNzLyQsTiHEN2MZ0QO+bY9s35/9a4cTakNISAEuhCBGOEIgyGjU1wbsyBSbDvyJcaWJLIE4qSgXgaTSgxaLjAqRXpkYSIQKZXWkUjMWLtNci/7DhwK93rIGeEr3/xB7Ei/S0JAn+OWBJcKCwEh0KkI3OfhZ9pXg4Hw4y9fmGUX+VKOf4g99qW0WSGaBhM/1N6JpoSTRknrEUDbBUeokC9EMmoX6VJ9ZMkhK459t5rmBT5mytiP6n3ql3XMjNB2ISoRZkZlCFowySkrZNx+I2LTB8gy9qef+sT30nqLYsfYO2GmYDkEnzG026z8wQiXF5z/zgD5cvyOLeHYY7aG977hec02q/pCQAh0GQKEmHbupKBQ2EjmQRafyI4mUiv+4LB3GrRYplGRqZgbRSMiHOu6xCreJjU9lXoQOIl0ScRNA1id+dK3hS9e9t0wOjbu+9JAE31fRZ9i+v4SEABCoPsRSM+cY7dvDo8//RXZDoiX7BSKutlGeflnAogJCuYvktYiUK3tcnUbtV3mOyquT8yQIN4gA3KZtc3Xl9IiApCnmyA7zcwI7MsUyDY0riDiiIiEw1dJaxFgjCWi1c79pumWi3gxX1E5iBeO/L6PeI65dJj2jwWXfvg1TvSf8szzWguKWhcCQqDzELD3g6iZ4jSJkyasQZxMQZoU6/AtibnHR4yLLyyItKuyxDRvy1ZZThUtU2/QoiE50UNaUT02srTfs059ePjke18ehofzaP8trffeKK03gN44jzoKIdDXCMDto+Xw7tedFb71vZ+G72QyPwJUQlFvN+eZy0wLpllhEo6zR0VCahbJ2vV5QVlnky4mX2gtdVK47xELaYxD1nWmBSMCrvY5bDYHbQfMjPYcyBfNqNl9oj7kG9cjGnBco/4ynaNhtTELgUpEI7vXGHObFcZ+ngE8C3LIC1/17jA5NRUutOcV2prInU74k3D5D67M0bzaEAJCoKsQiPopyUEubIvzLHYMkCROv+C7xf4o4+LjBhoyDHD2BuzlyEs1LcHTfOHtUD8WJ69oJ7a2pN+tmzeE6x27Tc+vJaE2u7DMjmbjoS0hIAS6EQF/8gyE6x+3PdzhhFuGx53+yvD2Vz07LLcvzHe0l9pmZfmywXCM+Wxh4jzW5FdUe+x5O3yV37ZhpZuhTKavGM3uaJ/Xh9TaZP4Yxsy8A22XThTONV/jIWBwxCwzpHxnKZkZYeYDxv6ima/5LC1henStjSMQRGjB7D007tGRsjTe541AkmxeNxxGxyfDgQzmosCZO6LRH67ZFf7zM5eFd73mOfYleub75ycu+Xo47pgtfX4GdfhCoP8QiOSKUyh28OirJDOiSJzwzshaJF6qiBPnWigf8yFbIvlSpLCwh6C3aCzOLG2XWRshHD4yEi78yGdpYF45+T53Ddc7btu8eUpcOgIzI//S66qGEBACQqAjEPj2FVfal8Nb+L485TEP9K+KTzzzVdn3LWskJJscHBmd8Ak4L/iS5hAgrC8hpNF22WfaBZ0skAJoQRwakRlSrvOEKReE5sGj0byrE4mXdKyYH+2zSFj7zR8M16y0YBIyjS8ZQyEz0/lvvKWZmrmJF1p+4SveHTCPvfMdbl3pCIe7OIy/8PXPraRpRQgIgT5BwPmUSJi4JouvRtKEbd80TZdE0sSSlm4+XFIUI3gX/irEDVv2n7JQOXAt5McS3pJvpR8iF+3ee6Dm3/hEHmflqb9+X0rzpd+vAB2/EOgBBD75ucvCA4yZv+DCj4e3/vsnAwTM22yZQ+tlLjxEuVg2aBPno80/jAh5O2nRUPADstscwjarVTN3X/thG3OzLRbJaGJi2nzqjLpfjW457iMjk+a0Lp5/JnqdZCLVLRiyn2iR4IuDe6ibtMhGzQzt2n1TYYPtP8TuPmnBNHTZce8whhLaHdO+HIK/GK6r3HL5D68MT3j4/eOEqmj8cc96hWu9oMovEQJCoN8QMGIF7WdMifhqwKpB4PovRZJvk2UriYSBUYkKLFY/FYCkoQ1fRhyhbayDypjjGjRWpFrWr1sTzjn9MdVJWm8hAvrc2kJw1bQQEALNIfCW914cbnPiKf73fIsMsZAQOeK7P/x5uPRDrwqnPvZB4Q5/dgtzvvvKhao0nMdLea5Q1DES0oh/tcdJrKR+BNB22b5p2ByqTvjEC42CbpNkhsR+MwHHdEZSHwJghbYD7pgwM+om4iUdIdcspAHXMFowTPol9SMAXmg8cf5zES/4jGkF8cJR3cnMYr9jvl3SSHX2K97lWi+XfPjV9R+0SgoBIdA7CJj/JyT6b2Fl9jtA3IoaMIk4cULFBhF33eJqLbZBwWIRbW7ZKHRhpmy6z6b9Va2wsWSZmJg00+748RGNmLS+5Ib6uIKd605Wzu3jM6NDFwJ9jgDEy8fNNv7c5z7Bnh8D4ZTTzvcX1/fME46TUew7P/hZuNPtZvy7MLT98drd9kVxa8uQ5GU/RyhqdpDnLV9vx82njDQgFj5lSdtl0qLIEMlm3Ja9IKtXLnNfMJik4BtEUhsBzIyYIGNmggZRLwih7dGCYck10I1kUjvPAyQJWKHxlOtNNlco6Vo44PPlsfYsg3Q7/tit4XIzmX33a88Kd/7zW9Wq4unfvuJnVtb+vv9T872wPbzsrMcvWF6ZQkAIdAcCf/VwI179FcZeAhnIUItwVsXW7T/vhr5ZCS1Ngm3Y2IfpUWRUiGxkgSeoymFbclyZ2fAkmjQGZtD+fePDZ5C5ZHnk084N3//xL2bVu+ziN4XNG9fNStNGbQREvtTGRjlCQAiUiMCf3fOx4R2vfk74y+KllBdPCBjs4v+iimQpcRe963EzGyKqSo6JEg/ZjWbWxEMyF6lTNj65+0fbZb1FMkJTALOtXhO0OXAaCrGHXxjJdRGAdOlGM6PrHsn8KauHY7SufYctWpM5D5ZcFwFIEiYZkFQ5iBd31muaR0PmXL0d8onPfS38zny9nHzfu4bjd8z/gSARLhd/9jL/APFAM63lo8Spjz05PPUxJ7djN9WHEBACLUbgLg99jY1l9s9e/CwadEGcsD1o74K2tDQnTvgpshn8Ij9jiYXmCx8pqe5CHcuKY+NMA2jM0BcNfvPDz06ltWwzAu15yrT5oNSdEBACvYDAgIWM/mnlQNBqgXThq2G1QMjgsLAs4WUd0wci7TQrPCj3msNYtB5oM0d462b3qVPqo+1CdBifdFu0mF4kXsB6wrR4MKHgxUlmSLOvPogpMLEPfl1rZjT7iObfwhH3NftGwhoLl+3aHVwMEkeAMXGbjY2MkYyVOYgXxm4fw9tEvHAgDzTS5dRTTq4QL3xcqDatveA9F4ezz3+HT7pe/rwnhkvNLInnHJo+Il50MwiB3kEATRTEiRdbMqa5kZGt8I/Rv6L54nnkkwiHEhM8ZD3bxZ+zK7ZOZQiXgen4fpraK7qkFUkJCDQ/Wyhhp9WlEBACvY/AS5/zOHeeW20ZmaJB8KKahHW+IpYpaaKcg4DhOCAW0HpgQoAzyX4XTEzw7XLEtADQCOoVM6Na55WXL0zP0HrAFG14SNcAGIAFGkFEs8ox6a6FfyekY5ZCaHuu9W0bhwP3QL8LYyFjIqaGuchXxmwIvbL5rbe+9xNuUpTOMdowv796txMufHggGtInLvla+NwH80fxS31qKQSEQPsRSESIkywF2ZL2ouLjxdgXxijeBCrlSYs0jBMxFdLG02BeTArr5QrpYklO5HimfspCQGZHZSGvfoWAEFgUAUyPcJxb7eflBee9I1xuDgv5EojwNbCW2vaiHbSgAM4zc5kKoOVBdKWcUTxacMgtaxJtl41rY8SRXvLtshTAltvXeLQf+tkMqdfNjBa7HoZM4wdzREwbiYg01evM0zyAtGIsxMH5Rru3mPR0gsx9lrGNBsx37AMDHyGIhpQ+QHTC/mofhIAQaB6Buzw0+nyZtvcdnO5Cm8TPLdGPC6RLocQSSRbbZsziMRA1XirOYHxnaAGfLtMwL1Y5lrPCsC6poq1846MyO2r+7DXWgj6nNYabagkBIdAGBHBECNHybXMyWEs6iXhhHyFLNphPkhzChPvqvSPeHn5O+kmYbPHFny///aDtUuvcTphPIcyQllVMbnh76g+pNjPqtjDSOc8Q98DOPtaCYTxdayZYjIWMiTmENomS1El309xnGdsvegkPQwAAQABJREFUN4fzxx2zJfzhmt05DlttCAEh0GkIwI6YeLhpo0ycH7GfacJDswGHAnFi5dj0iTvEC5W8rq/ZBksrA+Hi6jExHf0YiBfvhZ+0bquSchBQTMNycFevQkAI1IEA6tYP+ru7hcc+6xXhqWYfz6Pk4ku+XtF6qaOJUorgqwHfBDmc5vLF81rz/4DJBRoQOdosBZQ6O0XbZd3q5W5utceimPS6iVE9sPB+hX8LrisIqX6IhoQ5CNc75iWHjvaeY+V6zvvcMmh/jZg/GLRg0NroBy0Y93ljY2k3RTSae96a3eYDBFH//lCib7Nmj0H1hYAQqIVAQZL4YtA1G3210FSBNjEaxv+h1TJtYaOdSjGCZdrKDJqzmGmPemQsDXWQCtPCtm/4+zM2S07GeCH9lIWAyJeykFe/QkAI1IUAITXveMItw8Xu12Xa1a7nfiGsq6E2F0JzIxdZwuQb/w98qc3VZpvhqKs7MFu3armH2+ZLv2Q2AhARhCJn8o1T1l4lJWbMjMbMATEq1ZKEQNKCWWcRnyDiIOXG7JroRWGsY9rQz8TLxy3SEc87oiJJhIAQ6EEECu2VyJtAsxSaLrbiWdAlhJZGClWYaG4UiRUImChxG+e6yeTIq0TuJfIyk1aGYslxTFFTi/YiIJ8v7cVbvQkBIdBnCDB53J0pFDXQof3A5BRtmBzhrTvhdCRtF5yK7i7MKzphvzp1H3j/Ihw1S8Kc94oPEMyM1q9mwj0dDphT3V65vlt1HeELZrNpxI2aKc5+04qJL+qt6q197eJYF00/nI7ncqyLJiLOen3u0r5DUU9CQAgIgQUR+OsHR/+FPPciMxI5lmnz8eUmRJXatm1EC1wL4xjjvS0qtZxjIQ+exmyTZp4HBfsyq3QI3/iYfL5UoG3ziny+tBlwdScEhEB/IYDDVA9jahOKHMJkBAe8OdvMsV+NtoG2y5b15nvBXhqu3jMiM6M6gOSlCm0AHDuj/ZArylYdXbesyHKbHDPhHpuYdG0OES+LQ40WzDXmB4V37a2GXS9cBxwD1wFjXC7ihTZFvCx+PamEEBAC5SAA8QKx4n+2Cx7l016KoE1wwstaxVzItlGEQXnFaRV+/C8muCIMLwn2v2jBChSmSp5mm5JSEZDZUanwq3MhIAT6AQGIBSZHuaIW4XRyl02+UctHQ+BoJieU7TwXYIIGT9R2IXx0oVbbzp3o8r6SGRJOnrvZDCmZGfWyCU0rLzXGgOGhSGJiisZ1wbt3twlELNcCYxvmdTkE4oWxl/FGIgSEgBDoOAScXGGAMlLFfbJArNg2Y7j5c4kUii19dUb7hYRIwFhZ6kXWxZKhaYoBz+pEAoaVIrWS1nFI9M0O5fkU2zdw6UCFgBAQAo0hwMs/ZEmuSEhMTq7dNxrWmo+UXG02dmRLr1U9IYraLnkmWkvfk+6vgb8PtGCYfHN9YcLVLYK2C8QR1wPH0Ku+S9pxPkbHJ308GDJNu27UgmEMw98Tkb1yES+Mjds2iHhpx/WnPoSAEGgQgQpPYuQIjnP5Q4xQSf5cokaMhZCGgOGPnwrJkspZGnWNzJmClaGMvw/E9gplGEslr+iDpiRtR0DkS9shV4dCQAj0MwL4bMlFlqCayldi/BngjLfThfcAJkSYGRGphT9J8whgopPIi24xQ3IzI5sYo/HEvsvMqPnrYMquA7TrDpr2C/cY91o3cHGMXfh5YSxjgpBDICLRopEIASEgBDoagULLpaKh4sSKDYRwJ86YsA5lArHCkdiakSy8//EHjeJcC1nOqRTlKGvftWJNI3Zoz1th3RuihqQEBES+lAC6uhQCQqC/EYCAYXKQQ3iGEn6aiddWm8wOGhHTiYJGhn+Rty/zaOzIzCj/WcLkhMk3PjOYeHeqsG84imVfezViU5nYY5bIPdbpWjCMVWimMHYR3SzXfICxFRMmiRAQAkKg0xFw/y6QIokPsXcl/sGcQ61AoPufDZCVIuSQaFIxN2KjGEQj0UJ+bNdJGvIKzZjpoi5VJO1HQORL+zFXj0JACAgBnxww8UBrJYfsx/eLOWDd3oEOWFdbFKPtm4b9izwTbiZbktYgMDY+FXZaJCzMkDDp6SQzJPaFfVplE2PX1LF9lbQGgfm0YFrTU2OtYmp2jEUfgnxj7MohjKVofol4yYGm2hACQqAdCCTSJfImUSvFtVXsNQkNFUyPUqRp9gdihjcoj2pky8rbFBo0LjFlKpaKBSzLCZfUmR69BVblLES+lIO7ehUCQkAIuK+LnFGLcLSJKQ8aJp0wAWGyDcHEvuzePxb4Ii9pPQLJDIllp5ghpYkxGk9oOcjMqPXXAT1Ua8FsNlOkTtCMSz6f9hkRm8tZOG36WGqadRIhIASEQNcgUHAmLOBGXBPGl7ZtiU61kFn4eEmmRpXjM4LGOZVi6f5hrGwaCV1DxsiWqEcTa0X6ptKCVtqMQDo3be5W3QkBISAEhAAI8HDN6SCTyRZOK/Erg3lTWZK0XY6YNg5mUTIzav+ZOHBk3E17MMMo0wyJvrnG0XCQmVH7r4OkBTM6NuXaJmgelSXJ5BL/LjmJF64vxlKJEBACQqCbEIA4QYsFfZVoWGRhoX0sQ+sFMoajwQDJxLWGjTrx8mRCqkTxpf3QhrdDPasczZqsDtvuzJeSqVasq9/2IiDypb14qzchIASEwHUQ4EGLhkiuSdHE5LT5fBgJECCYebRT0rEkbRe0cSTlIYAZ0i7TNOHagpBrpxkSfTkJOLzcnalK86m864CeuRevsXFhDT53jJCLL/jt2yfGIsYkxqZcEY0YZxg7230s7UNNPQkBIdDLCDgpYu+ATsLYgUYnuxyxaa+4tout2tIpFcqZF90Bm72TVy3RPKnwEeMZmDBRPhoquXaMsTzR2S5MjKQsBES+lIW8+hUCQkAIzEGAqB/5IiEFn/AyKcnl3HfO7l5nc5VNrHZsWhmk7XIdaEpNwMQnOTTFDCmXn6GFDiqZGaF1wYRfZkYLodW+PM4HZBwELWY6uQjfxY4A4oWxKGdEI8bKdo1tix2f8oWAEBACjSDgFApcSGRHYhNso7VSqMQ4iVIQMU6lFJoysS7aLVQzYsUomuhUl21PjEsnbyIR48kpi2KStiMg8qXtkKtDISAEhEBtBFDLzxU2mgcyJj9jE1Pm+2Nly/w9JIKHidwu8+0ibZfa57fMHMyQMP0hKtbaFpqk0TaT4oPWH2GPJZ2HANfCngNjbo7WSi0Yj2hkYw9jEGNRnCQ0jwdjZJlmlc0fgVoQAkJACICAUyhxWSFFoFhMCtKEVSdTLB8NFydZYFF8QLVtewlD09TrGFPDP/5HfZlY12s5aWOleGmTlIaAyJfSoFfHQkAICIH5EYDEQJU+l+Bn45BNtogugmPKnMK+8gWdL+ny7ZIT2da0hemPmyGZllJuM6SKmZGRL1wLaEBJOheB5Py4VVowlYhGNvbkJGQhi9qlsdO5Z097JgSEQG8gUBAlRozMJlUiLRNpkiqyxAgXDy9tJEwsYQtIFWsGlzAoy1Tc7U6b/xi2Lb1gY8wRb1GQJEkpCOR9Cy/lENSpEBACQqD3EIjRO/KZiODcEpX/XJGQ+HCy3tT+1662ibZ9QedLuqQ7EMAEaJedM17WtmxYkcUMKZkZ0abMjLrjOkh7WdGCsXsZjZIcH0XxxcJYQ2j5nI51j928qiMiuSXstBQCQkAININAsjaCH4mRjGZIFZ6nkCbupwVmhe0ie4CK9j9uGsNiMjOpJw+zpVgAnsb7ocGijlfQTykIzJynUrpXp0JACAgBIVALgeUWNjVnKGqcXF6zd8RNDdavHqrV7aLpaWK1zGZpO/eNKpLRooh1XgFe8ph0oxWFGRKOUBsV6tIGZkYi4RpFsdx6rgVj9/Jk4QtmxVDjr4eQsuvMqS9jTS4ny5DRimhU7jWi3oWAEGgNApArkChOpTiPUhAupBChyBmWSgmPduREDFUoT1bkVWKyEyym9UK7s8gW03uxsq40Q11JKQg0/nQtZXfVqRAQAkKgvxDgK3QubRWQm7KH8W7TgBm2ydVSIyG5touRNtTbdyiGMe6vs9F7R3vUTIMwQ8J/RiNmSNRZt2rI25CZUfdfH0kLBtMezu1StWAYG4aNKEHLjrEmhySyd6n7kqNvtSEEhIAQaDkCxoYwWkZ6JfWWfLjYdkHOuLIL6xAokCpFJfzA0AD1/Y/0gpWh3DRaMy62NLJmMCrKFGlatBsBkS/tRlz9CQEhIASWiAAP2jQZWmLVeYvzMGbCzVMajQWcYi4maQKEeckf9xyVtstigHVRfiNmSFwHx1hkK64lmRl10cmuY1fRgrl6z4iXRPMODbx6hDGKMSVnRKO1JYXFrud4VUYICAEh0CwCPEMZN3kLQ1PFN/lh3UkV2yjIGfrC3wuaq/G1zWpZdtScYd0rehvxhxqWby+RtMxIHtfoTVIWAvU9UcvaO/UrBISAEBACFQSyRkKyVveaU1Q0H7Zb+OFajnghfjBRcm0Xi5SDDwdJ7yGQzJCOjEw6IQfZVkswM2KijcmSzIxqodT96UTG2md/OP8mghVjwXzC2LFj88owOj7lY4q//89XcIlp+J9pxjxyid2puBAQAkKg7Qi4zguDpmmjeCQjV2dhN9B8STZFtlkZWCFYIGAoU0W2JLbFzJTiUG1LK1RpztKnaa5Sj/qSMhAQ+VIG6upTCAgBIdAgAkT58C/MDdafW40oJPvNhAjTprkEDF+8Sa9ou5jPGElvI8D1gFYUJif8zRV8eawzMo5oRjkj2MztR9udgcCoOepGs2nIzBQZC+ZqwSRfLIwhOa8HiBdFNOqMa0B7IQSEQAsRcDLE6BIYE/tzUqUgSIw6KfgVXysyzWwoETFFXfPuYpV9I5LktkrKlP3imBfSZRAWhnVj0SuETAsPS03XRkDkS21slCMEhIAQ6EgE0ErgazSkSA4hGgl+YCB1aJtW+dJNH3z5lrZLDpS7pw3MkK4156u8ym0zrSius2RmNGDr5FFG0h8ITNm5RkvuoGk6VbRg7NAZKxgzMDPKFdGI64w+RLz0x7WloxQCfY8AKoWQKXAjBoZzJICStm3FdVnM3MhDTFOqqINmC3UhV1L4abRYvRHSaMbqMdmv+IWhCu1LSkNgeWk9q2MhIASEgBBoGAG+OGMuRMhgohg1K2PWBpGLtqxf4ZFKJmzCxRdvJl6S/kPAzZCMeMPUDb9ACGZGObUb+g/V7j5iIhcxJqARtX3VSj+Ya22bd/0ckrRoapk35ehDbQgBISAEOgmBSKAYIYJWihMsrBd7OIco8dDRZDLmGlHNwov6D4XRdInmRd6Gvb9Ffy+Rj6Gw9RLrdBIIfbYv0nzpsxOuwxUCQqB3EOChOp+5UKNHSAQkzApcq8Ge4yJeGkWyd+rZ+11Fli2r2qikaqWfEPAxoRgbBm38WT1svmAyACDiJQOIakIICIHuQ8A5kziKQsQk4gVtF/fZUoywlKiYC7HCNzdnviFtoFQsHwKnWNoiKshAthT5luIEDWUk5SEg8qU87NWzEBACQqBpBPhKjGZCM2r6tOGq/uZIFRMCTAwIE0taPZGQmj4INdBxCLj5ByZHRsZhZsQfk+0thQ+gjtth7VDLEWAsYExgbMAvEFowHrLeTI+4NhoVzJcYw5pootGuVU8ICAEhUDICRrIksyEnRyBZjB4pGBKIFSddTIvFiZkiD70XCJrgDnYhajgM2oKMKbYtbcDyPYcFdU3oT1IeAiJfysNePQsBISAEsiDAMxUHlfM5SF2sA0ibHZtWuc8GnKhiwsTjmUgnmJksFAlpsbaV350IpMkwkY/2WXQr/6pmL22sY3rCRHmFaUlJ+gcBNFOOsbDTjAmMDYwRaMEwZhDl6BiLdoSJ2lKFMQu/MXF6sNTaKi8EhIAQ6HIEIERgTpwYYWSNoyFrvuorRSqkiiemMpbprEtRCBLHsqJBEmm25m3bMrUTk2ldUhICS39SlrSj6lYICAEhIAQWRoDJD1+g63GQywMakyVMjNB2mc9vDE40pw/Fcnts4k3kE0lvI0A0o9V2HaHZMJ9TXXy+4B+ICfMRW8cJq6S3EUgmQZBv8znW5ZogfYtdE2jCMP6kF/2FkCF8/SrTtpMIASEgBPoWAedRnDFxAgbTIUgTJ1CMTOEzB8ZEBZViG1SILMugrZNDaT6b+VYiV1iSVqgUenuUt/ZjdCTyJWUgoE9XZaCuPoWAEBACLUKAyUxykFqri/m0XWqVRdNhp03EN9oXakIMS3oTAcyM3KTIzIxqES/pyCHqcM7MpFxmSAmV3lxC6EK0MQbMR7yko0YLhjI46t5uGjJoTy0kHkpaxMtCEClPCAiBPkDAoxTZuImGqYstMB2KJItTJnAo8DG+TCQKaSTHv4JQcSLHEuFmqOCZ9mOES1KscUUYKyIpDwGRL+Vhr56FgBAQAi1BYIVNineYGQAT6mrhA0ia9KDtgglBPTIxOWU+P0bCSvuqzddqSW8hgAkRWlBj49HMaD6Nl7lHjN8PTE7cDMnqygxpLkLdv829vtoIEu59xoB65ICZJHFdQNQy1hQfXStVIewYm5rxUVVpTCtCQAgIgS5HwHVa7N0MUiS9sblyC8yJOWdJadHBLtQLhdNB+5ZvugYMpAuEiw+8sUGK4vfFq1hm3KaQpCwERL6Uhbz6FQJCQAi0EAHMj/gCzWQH4Us020ysk2+XpXTPVxMImwFrjkmVpDcQwMyISTbnthETIkxOMEmjDdqS9AYCTpzYvc51kT7I1ntkUTNqxMeaai2YZL7UjHPeevdB5YSAEBAC3YCAkyKRJ3HtF99mx0nDWS7LyMYYp2IbDMhFWtSCKY7Sk6kdy+B0l1U0aJzg8ToxyVosKmlRBgJ6UyoDdfUpBISAEGgDAnz8QKOBCfKwkS+NkC7Vu8kzn0hIa1YOhW0WCWf3AYuKhHqspOsQQCtqoxEmqDovZma02MElMyQm7FuG4nVWUaFerLLyOwqBITM727J+RThkY0a9mnG1DgAtmKOjk36dYQ650q6NuZowteoqXQgIASHQFwgUr1DTNjgmbiVSI06tOOFSeZ4WZclndWCaj2u2Zv9jmuu/2DpbaCtG4iWSNkWrXpzakrIQiJ9Ey+pd/QoBISAEhEBLEWCys9Y0EnCWO59T3aV2DgFz6GiMhET0EyZrku5CYLmds2RmBCFXj5nRYkeIGdJu05LADGm7oiEtBldH5nMv4y9q/5F4f+fYScYcxh4070S85EBUbQgBIdBLCFS0UtzPizMjxeFhcmTbbkoEMRPzIoUC8WLblo9WjK8WlEvMp2wiW2xpGjRF8aJsLyHYfccizZfuO2faYyEgBITAkhGAgEHboZ5ISPU0zhftyanRsNm+ku87NG7hZhUJqR7cyi6Tohk1qwVV6zjQsho3/yCYIaE5wbak8xEYNq2UzeuGPJz4Qo51l3okXAeKaLRU1FReCAiBfkEgmRS5skqVJkv0zhKjHWF95NoscCpGqjgpY8QL64PmF8aJlsjAJBUYgy/mx7Ix2ZiaECMk9Qu6nXmc+mTZmedFeyUEhIAQyI4Ak6Cc/lrGxi3qjUU4Wb96uSIhZT9beRuEeOPcr7BJNmZGObSgau0h1wV9oO1ANCRpPNRCqjPS15tzXO7hayyClYiXzjgn2gshIAT6AwHXfOFQUWTBwa6RKOis8NxkiQxMQ7BQALEyBRkDseK+XWKG/UZNmKKx2I6lYs7kG7A4SKWtuKnf9iIg8qW9eKs3ISAEhECpCBBlZJuZFsyNhNToTuHzBaecioTUKIKtr8e5xsyIiDWYBuUwM1psr+mDvsYmMENaGTB1knQeAhvXDoVhi3bFPZzLfxPXG2OMNF4673xrj4SAEOgsBNBEceLFCJFpV3GJBMm0PUPdBwy7WzEhgkiJ5eFPktaM13BuBvMiyJvYBu1iEuwEj7uAgayhwSKfVUnbEdDbUNshV4dCQAgIgaUj8L0f/XzplWrUIOoIDnNTJKQaxepO5mHO5I2vMWg6DNrkS9IZCGBmhB+PvYfHwsEj7TcBok/6xonrmpWydO6MqyLuBSZBRB5qJKJRreNgTKmOslarnNKFgBAQAkIg8SqRMPFJOWSJ/blxEa9SzpZAxKT3KsvHP4xTKrYkn01+imUkW6yOsTcDvJjF1qL/mAqjQx1JGQiIfCkDdfUpBITAggi89b0Xh5MedoY/gKoLPva088MpzzyvOqkv1j/wn58Pjz3tFeH9F12a7XiZdKENkZOAwY8Ivl9wuCpHvNlOVUMNoX0QtRqimRGmQGVJMkNC68pDGKd3yLJ2qM/75d7csWml++bhnvV3+wyYMJYwpvi7fob2aOJdH/pMeMH57wwf+cSXTHOr//xK3ebEU2YhyaSMtMt/cOWsdG0IASHQnQhEx7nOsjidEpVSjHoxIsVNkArShXvfSRUKxP+xqP/inJdkZ18iUWMDMdZKAxA1xSBPmVn+YboTsq7fa5EvXX8KdQBCoPcQeMpjTg5/uGZ3+Pb3fzrr4L59xc/Cuc974qy0Xt/4/o9/Gd7wzovC+970/PDIfzop6+EySUIrAt8cuQQnqwcsWsrWDStEwOQCdYntJDOjZBLWDjOjxXaRfUimLTJDWgyt1uXHiEYr/B5tNpR09V4yhjCW5CRenvmvbwqv/bePhi2b1hvx/PnwqKeda5GTxqu71boQEAJCoMsRiOSI+26BcDHTI0iXRLVwcBAxaZnWI4kCnULJSLt4G7iHsX8QLozHcDdeiiRKk+6t6acsBES+lIW8+hUCQmBBBI7fsS087vRXVspc8J6Lff34HVsrab2+wpfeM150QXjG4/8x3PbWN/XD/f3Vu8I1u/ZmO3QewpvNEev6NUPZ2jxikZB2HRjzSEg5iZ1sO9jDDWHak8IFHyjBzGgxaPcfHg/7zAyJfZQZ0mJo5c0Hb6KTcW9yj+YSxg7GkJwv9M9+8VvCFy77bvjY218cTn/yQ8J//ft54eqde8KPfvbrXLutdoSAEBACHYDAoI+dAzjbtb2ZNoe6iU5xCyEnYiyjwmwbeeLcCtqszrTgp7cgaCLhwkH5eEwRq5+2naKxjKQh4xn6aTsCIl/aDrk6FAJCoB4EXnbW470YLD3yViNfnvqYB/p6v/xMmoNUiJY/M+Ll57/+XXj4U15i5ljPDic99NnhtW//WFYY1trEbKP5gMglRNMhEhI+R4imImktAryXYWa0ZuWysNtwHxnLN7nOveejREPaN+IOWTessUm7vyXm7kXtVSPAtbHaop3ttIhGOSNdMWYwduSUH/701+HzX/1uePULnxJufYsbzmr6mp35iOdZDWtDCAgBIVACAtNTkUBxtRTrH18v0b/LoCfht4XJupsPsX/+TgzJEh+cMxP5SMpQBHLGCRonWooHrKWhGRO1avTQBaeyZOaclbUH6lcICAEhMA8Cd7rdn7gzyBec986AtgcUzFNPOXmekr2bNLwikhZf+58fhgc/8Zxw77+5Y7j0w68OZz71YeG9H/lc+JFNUnIKkzM0EnIJZi+77Sv78uUW5jgjsZNr/3qlnRhdZqVFqwnhWptcT7gzvs4+OvaRcNR859umaEgtPVkQL5gbcS8S+SKX4L+HMSO3nPmSt4Zb3fyG4W/vfsdK05Aue/YeDH9hz4V+E55/EiEgBHoTAadB7AdiJA7P0eAo+nuBMSE9pvG8hJ7xUZws1j2pSKexoiz6MxAwaRv0IHK8MumS0hAQ+VIa9OpYCAiBxRB44H3+Onzi0q+bs9nzw3HHbKkw/YvV66X8V5795PCW937CCZfHP/x+AbOrR/7T37ofhC989TvZD3WFOc3csXllvlDU9iKw15x6TkxOO7GjSEh5T1kyMzp0dNz9eORtvfWtYYZ00HwEKRpSfqy51yBTeTl3fzv+lt58PzjWZYzAgXIr5Opr94RXn/MUC08+0/4z//WNrgWzbcvGVnTZ0W1ebr7OkoiISUhoKQR6CAEbm6FUfFJuHyacIykIkoJqQR/G0tkqSBU7fAgaZ1MwL6IeH17QbsFvTAFPrMcGeUVipmdB0ZoWS0Qgr67oEjtXcSEgBITAQgi87LlPCB//3Ndc8+WSD71qoaJdm4dp0TL7Kl1L7n23O3gWL+CQLu0QIiFtt1DU+IbIYaLAc/6gkQOTU8u83d37rV07bknjCKBxvG7VkJvuYGbUDdoutY72qJlIcZ1ttkg5aPFwrejdsBZa9aWj6bLFnF4fMHIrp3+XGNEIU7H0al/f/tRbCjNLfF1tXL+2UuUVb/mQ+Xq5Knzjvy6opPXTCtGeEunylsL3WT8dv45VCPQ8ApAiNqRCrIQBfMDYGg/B+B+WZYZ4YeilvJf1ar4Zh2RvIWZZGbRfXMj0h6otqe8qMTFLv+1HoPYbf/v3RT0KASEgBK6DwMl/d7dwpxNuGa537Lbr5HVzwtj4eHjU088Nt73X48LtT3piuPAjn533cIaHV4QPv+2F7nzy1Oe/PhDxiQgg+w8eDs8yR5StEiZXW8055/CKfI8JJoH7D5mWg00Kh4dmvmq36hh6td1kZsTxXbN3pKuJl3SOII+uNT8wvCNihsQxShpDgHuLe4x7LSfxwljAmNAq4oWjPWbrprB184bwxndd5IQDoaY/eNEXwhte8vSwYd2amoD816XfCDhlv+jTXwkQ2r0imJkev2NL+MTnLgsQ8Be+7qxw8n3v6pqgvXKMOg4h0NcI2HDlxAlLuJKCdIElcZ4EcAqNF1Zd28UyPNfKU5xyXs3KudiCpipaMxZzOuZYJ7FgLKffUhCwc8hZkAgBISAEhEC7EGByAPGyeeP68Lxn/J/wlW9eEc59w/vDWU97RHj0P88fTvrXv/mDTy5+9NNfhZvc8Djzf/OgcNtb3aTlu8wT4vBIDB+dqzO+nhMd5cjohJmcTORqti/awcxorTkxxlQn58S6k8BbbceIo2ZCIXPtSepHYN3q5U5sYs6VQ2st9YzTbK67dgjaL//ynNeak/H/dTLm+TZG4u9qPvnB//1VeMIZrww3v/H1wvWPPyb8xKIhHR0ZDeeccUr4m788Yb4qShMCQkAIdAwCJ550nhEiRqUY82L6LbZfc34hVCBTIFkig2IlbKNIr2RYASdkqsr6DD9Wd39faDXHdqbDly99Xsdg0G87IvKl3864jlcICIHSETh0+Gi4ywNODT/84rsr+/Klr30vnHbOm8P73vSCcEIRVrqS2QErTPT3HRrLtie8BODnA/OjffaFXrI4AkyAV5mD090HzMzIfOj0sixfNmAE3bBHbZIZUn1nulWOdYlo1ArHuosdFU52j9m2qVJs7jahp//h0c834uX48M7XPCesXhWdhX/mi/8TVq0cDvf469tX6mpFCAgBIdCJCJx40vkFs2J755orPNsLlgWShXU3O7JsPwDybM3eoaLPl4JdKQiZadRnyPY2jKZJ2badyBia+e9Ln+ut6af9COTTJ2//vqtHISAEhEDXIoD2yw9+8svK/t/zrn8ebnPLG4dnnP3GShp+Dv78Pk8MP7Svu2ULk6+cEYuIukL0FcxLcrZbNk6t6B+Mtm9c6V+93Myox4kXMIRcIhoSX/q2FL5gWoFtr7TJPcR1kjuiUVnEC+dlLvHyd498jvt+SefsWedcENatXRUOmAnm3z/6uaZB+APPut+9/lLESwJJSyEgBDobARgRyBLMjlgxYRn/4q7H0NOkm1j5uPRqXsOsipxYwZgF7gXiJWnHeF3LT/WcsKFPSWkIiHwpDXp1LASEQL8isHbNKtduedoLZogWsHj7K88Iu/bsD6jSI7e4yfVc7d43OuAHrYtt5og3lz+ORMDg72ObRWVRJKTrnmQwJ2IN0YwwJekn4frgmNG6AgOwkMxGYMg0hI7ZtNI1yHISL9zjYF6GxsvsI4xb15iWC3KTGxzry6tNK+YnV14V3viyZ4RPve/88LoXneqag1/6+vc8Xz9CQAgIgW5AACIFP1qRDommQwW9YnwJuRVmxQgU23bmhUUiWihdkDZFntMy9vx0LRhoGNKtSCRkKk10Azw9uY8iX3rytOqghIAQ6HQE3vzyZ4Y9+w6EM170lsqurlu7Opxkvg1e89aPeNrwiqHw2Q+8Mty2g8yQiKICUcIyl+C/BN8eRFhiMimJCGBmxB9mRr3q36Wec33Erg0wSHigDSMJfq9ssXuR+wf/OLnE73G7Fwk73ynCGPi9S94R1qxe6bv0+a982x3r3upmN/TtE25zs3Drm98w4HhXIgSEgBDoGgSMFBkoHOI62eLaKzAlkVRxzRV75k37gy+Go0bTJZIptmS9MDUizdNp0wJXRy2XgmyxNlJbVkpSIgKd82QtEQR1LQSEgBBoNwI42339S54WvvSN71fMj9wUyRzqVqvbt3u/6ukPDRWiqeQkYCAX9hwc83DDK1f0t4ZDtZnRzn2979+lnmsOMySwkBlSRCtGNBquaAbVg2E9ZbinubfxydTJcsy2zb57hKVO8v/+9+qwY/uWtKmlEBACQqALEDB9FLgW29M46rp+SmXLD8AJGVuzQmiEMjxTx8v7Ov5fvKT/xHUiHJlOjKVPm3axr1gDEDeYOEnKQ0AOd8vDXj0LASHQ5whAtpx17r+FS79yuYcP/cVVvw+/tL/LP/u2rkCGh/pec8I7MjYzAWp2xyEeiIQ0Mj7lX/Sbba/b6mNas9ai/Rw1THNqM3QbDgvtL1F3iPqEA+hRu076TdaZNtTKoUEnKyd5qc4kYIp2UYfzLpWjfciTX2RhmLeGu//VCeEzX/xW+PrlPw7f+vRbA2adEiEgBIRANyBw4r3OK8bcaEaEvksUSJjovcW3nXEx4sTJlkTAzJSNVIw9D0hKdkZp3YsVrfHiZoW+/EVFO4o4t/9X5Ev7MVePQkAICIFZCFz06a+E7/3oF+HG5s/gCY+4/6y8btiAJDhgpg+5pBIJacIiIfWRnxNIlzVGLPRDNKNmrxWiIeGI96hpTOW89prdr1bX37hmKBCqPad/F/YZ0qVdoaRzYvTi1743XPXbP3iTZ5/26HCzGx2fs3m1JQSEgBBoKQL3uNfLY/vJn4ubEDlrUkXDpF2I6ZE+ievkzNr2jVQfrRpbt49arvFCspcORr48nw1JCQiIfCkBdHUpBISAEOg1BI6MTmQNGc3XHSK44IgO7ZqpjF/4Ow17tH0gEsaNbMLBLGrFksURgKTbsHbIHUDvNZO1nFogi/fe3hKY+nE/TJr51f4jY1GDPNMuEKJ69fDyTK2pGSEgBISAEKgXgXvc81x/z4lPfdgR0+acNn8tZhvkhkNGnrhDXcsqlFaiixeKOmETdWXSW4Mn2wbvTlNGtOBfhHoDRurEkpgoTYcvfUnkS73nKHc5+XzJjajaEwJCQAj0IQJM3rasj+Fucxw+Lwv4gBkdnywc/PJK0XsybOYjEC+QV04y+dtV7x1nK44IkgrSBbM3IvN0koPYnMeLE2qcUR+F4Dycl3jhnhXxkvNsqS0hIASEwBIQGBg0csRoEQgStFKKJa8CvPVAoSC+DdmCFAwLjnq9ii3cz4vl05Zv2AerolixtC3LoiEWkvIQEPlSHvbqWQgIASHQUwjgBJRISJiE5JJk0kRUl16LhISZ0UbTZthzcFT+XZq4YLhGIGE2ma8gzGd6SbjmufYPFCG3cx0b9+gOC1HNPSsRAkJACAiBchDwSEfGhkCJYCLkVke+K5Escb7Etp1IwVMuCfAxptlCBCTSbWFCIxAutjFFniUlAoYylu3kDuveiK1ISkFA5EspsKtTISAEhEBvIoB5BFoIOQkY/HqkSEi98JUeMyMwwneHohnluQ/GzGQLLMEUTSIw7nbhWt9sx8K1nzPUOPcm1x/3qkQICAEhIARKRADOJLInRpCYoVAxLEOiYB4U6ZW4f5FAsXUnVmyJlouTNvxaSStACkuEZklhs0jxFcpKykNA5Et52KtnISAEhEBPIoAvjm0b+Kqe7xEzZlFtdu0ftSg3ywLRXrpVkpkRxyMzo7xnETMknBW7qZqZ6XSzGRKOdbnWIZS4VnIJ158TL8XLfq521Y4QEAJCQAg0goCRJmioJNYFlgRSBZMiX43kCVosFHGzIidlCgrFtFygUiBqKEBbSYMGxmXA8lGVcUKGMpS1MpLyEMj3ZlzeMahnISAEhIAQ6DAEmNttXjdsREk+R544VCXKC5NqnI92m1SbGfVThJ52nyfMkPbYdYIZEph3m3hEIyNJWhHRCK0gyFGJEBACQkAIdAACHobI9qMgRowamdFUYah2nqQgSxJBU2iueKpruxQEPQlWx82KivamXe3FUoomfKXQjOmAo+/LXRD50penXQctBISAEGg9Aszx1q0aMr8m+TRV0G7AR8qEETH4l+kG04kUzSiGCLZ9t4g1ktYikMyQhlcs6xozJDfZM3IEXXG0vHJGveIe7MZQ0q29StS6EBACQqBkBBIZztJeDZI/FudHjFOpnqjjfBcNmelCK8bLWJ1BT+M4bKP69cLbi8cHj+N5VmlgVqsxX7/tQ6D6nLavV/UkBISAEBACfYMAvityaqrwBefgkfFweGTCo8B0siPe5IOEMNKYGYl4ad9lX22GhMYH56JTJUU0iiHb80Y04t7rBV9JnXrutF9CQAgIgUYRSCSLmxPRiL3guAlR0aBzKfxQELMiY1DcRMkzIp9CXX+6OcNiZe3jVIVs4YXJ6rKAfKEuIagl5SHQffq45WGlnoWAEBACQqBBBFYNLzMnvNF5KOZDOQQnpLRENBii3Yxm9I2RY/8weUHbAIepaGJIykEAM6TxiemwxcyQWD9kpF0nCX5YMJHabxGNcC6dS9C4ot1u9n2TCwu1IwSEgBDoRARwiItAiqD8YrottmVpJDszU2y77xZLZrMqHTpmwCp6K/aa4aVdm8ZSbMk/t2yijm8bMaPXEQOxPBH5Uh726lkICAEh0FcIoHmwzRyh7t4/FsYn8zz9mayiTbLZJplowjC5LlswH9lgToFZ7jIHsNJ2KfuMBHfCe+3+Kb9OMEXCdM2/BJa8a/hEWmn7g2PdXKQkhzS0zKI+bVgh/y4ln191LwSEgBBYCAE4EYgT6JOowTIYiRT7dY7FNVc8NxIrFKa8V4rUjRMynj5D3KD7Qi7ki4vnW4ptVtJijn7bjEDn6uC2GQh1JwSEgBAQAq1HAGefTApzRkLCpIfJ62rTrsFZaZniYXzNxGXKnQOLeCnzXMztm3OCL5UJu16IxlW2GRLX6iojXiAjcxIvy0W8zD312hYCQkAIdCgCxoYYMUK4addSccIEcsXIk8iUOInCzqcPBgXFYunFNN7KFRSLl/GWrHAsF2kY+mA7kT0dCkZf7JbIl744zTpIISAEhEDnIAABQyQkvvjnEvx77LSJ9TImnjgtLUHWmJnRVusb85H95pNG0pkIcG44R5ghQdiVIRvNDwvX6i4jXnI61l1t16A7orZ7TCIEhIAQEAKdjcC0GRq5YI4NuxL/GxmDDVHciD5eIpniI7slo9fCH/8jKwPlQkhpkkhMZIsn+LYXr5SPSfptPwIiX9qPuXoUAkJACPQ9ArwgYCq03sxzcgnvLbvNzGdsfDIcs2ml+Zjx15RczddsB/MinJri1wYzo1HrX9LZCHCOOFeQFZvXr/AX1nbsMdck1+akmd1xreYkXohohDaNeJd2nEn1IQSEgBBoHgH39WLNxLeV4tcJElsviBIPF+0Du9Eq5vvFk+2Xd54BI2i8ljl2SXmRz4n5EDGUR2gn9hC39VsOAiJfysFdvQoBISAEhIAhgEPa3KZCB3GqatoNaKG0moCJ4YFXuJmRm7QojHTXXNf44uGcTZozXrRFlrWYrEsmaVybXKM5hXtIEY1yIqq2hIAQEAKtR2CGHIFJsT9jVFhEkoQV02ghzQMVWKppxEStF1uHfcE0iaVLqss2mjCRbKlETyqc9kb6pqiiRdsRkMPdtkOuDoWAEBACQqAaAbQPmPjuOzSezffFYRzx2ssKJkj7zMRkdCy/NgpmRuuMPMKMJWeUmmpstN56BDh/w+PLwnbzA7P/8FggilZuwckvTphzXytENELjZXioHPOp3DipPSEgBIRAPyHgJkXFAePjBdIFDRX4FDQkIrdi6QUx46SK8y2RWIG8IdoR6i2xDEszQHJCxlvzNqkeyR1RLwXcpS2k+VIa9OpYCAgBISAEEgJMHrea9gHOQnMJoafRbNhgEWWIKpNLPJqRaRpAvmC6IuIlF7LltYMZ0s79I26GhAmZa3hn2h2uPa5BzIxyXivcK9wzIl4ynSg1IwSEgBBoNwLwI4VhUHz7MZbEiJOot0IW6/ZXEDOsT7t/mLij7hrG3MO47xgr45o01HHyhrpIbI2Q05SMFA/rkjIQyPeWW8beq08hIASEgBDoGQT4ir/VIiHlJGCIIoNTU6LKbDDCpFlJZka0c+2+EYWRbhbQDqqfzJAI95nLDIlrjmuPazB3RCPuFe4ZiRAQAkJACHQnAm5OhFaK0yaF813TeYmmQhAx/t81WSBWXGzYdy0XNngEGANjNWwlki6u5WLb9iizJBqINeOk38pFFsYyJWUgIPKlDNTVpxAQAkJACMyLAJGQmPjmDEVdiYRkE1WiLEGgNCJExtlu+4a/DqLlSHoTAczU9h+ecJ9BjUZD4hrD5A31b6Jw5XSsy70B8cK9IhECQkAICIHuRcCd6druT0/blByfLMaVQLxEmiXqqAySVhArbofk5S3PbZKsGhovTrJQ3+o6++KVrGTxnLBNb9OIF2m+lHu9iHwpF3/1LgSEgBAQAnMQYE7JxBV/KrmE95I9B8fC+MSUkztLccTL/qDBQGQmmRnlOiOd3Q5mSJgJrbVzznlfCs/BtQVJNzI2YX6MxngXzibsC/eGiJdskKohISAEhEBpCECEQI8QJtpXjCKJ1ItpsZjmrnMqlp8MiGYSKIWmzHSAnIlipXhY2Tb8CyZJlKJ90mIGW5UKJErajIDIlzYDru6EgBAQAkKgPgTW2UQzh6lQdW8Hj1qkmSIS0grTIFhM0GBAEwe5eq/MjBbDq5fyMUO61s75oF0mboZUh8ZUimiEdtThkbyOe7kXiA4mEQJCQAgIgd5AIPpvSQQJpEih0WJLUmMoaVtDo6UgUNwkqeBQosPeSKZ4uhWKZkeReHFixtOsDJoy+IuRlIqAnuKlwq/OhYAQEAJCYCEEcGrLlxw0CHIJ0WzGbWK9ed0KmyBbWOoaYX8xOUHTIE6k84YGznUsaqf1CBCFa5VdCzi3hbirFQ2J6wXCcI9dq2Pm7DmnbDQnwI2aQOXcD7UlBISAEBACGRGACzFOxN2w2LtOMjmCVJm2RNNrsUwrBNniRSFljGBBq4V6MdlX2K5OQKeGNkxV0muS6c14wVSxseXk5KR9mDBPM0tRC22sq56rJfKl506pDkgICAEh0FsIMOkcWjbsZkO5nJZifrRz36j7zsBpabUPF94l1q4kmpE5SjXTEzQgJP2NAFGKuGYw+VlmL5yHRsaLr5ARF7RS8MXCNZXTvwvXJiTh0PLFtbT6+wzp6IWAEBAC3YcA7xsF/2I7b2toqcQ1JzacaqkkUKLw2WJpnlyU9yOvvKqQGT8AODnCavIDQy1nerxGQz/7DhwKJz/27PCiM04JJ97ldgu2cZcHnBr2Hzg8q8yZT3lYOOWh952V1k8bIl/66WzrWIWAEBACXYoAk89tG4c9aszEZHypaPZQmCQThWaTTW7RLEC7JkUzGpuYdjOjZvtQ/d5BABIO57loQ2GGtOvAWJgyFW6uHUgS3+YLZSaJoaTlWDcTnGpGCAgBIdCRCLgWS4VfH3BFFR4l/sceG3EyaP/cqa6xNZgqJY0TCJiKWLlp12qx6Ee2jG9KkDmxrmvT2LNqVp1K5fpWznzp28IXL/tuGB3jA8TizzuKQLbc7c63rXSwZfP6yno/rlROdT8evI5ZCAgBISAEugcBnIwS5SV3JKQ9B01bwV5mtm9c6ZNqfHXkNHPqHoS1p4shwHXCtYHpEQQM1wxp6RparH69+e47RhGN6oVL5YSAEBAC3YmAPT9gQyBgUE6JCiqR1GCS7kSJEymYIBmRYmzGgGVQju1qmbZoSWjSUIccL+tbpi0TEzwt5lbXrH/9rFMfHj753peH4eEVdVfasX1zuOmNjqv8bVy/tu66vVhQmi+9eFZ1TEJACAiBHkUAAoZw0fsPxwlwjsP0r0v2YoL2Al9yiHQjEQILITAyNmmmafgjil8nFyq71DzM7DasWeFtL7WuygsBISAEhECXIWDvHzjWRUclUSpOrkSGJRIw/No2eisQ/gil7aWlWIu1PVw16Z7pP75B6+ahpS5tFarXkq2bN3gWz7565X0XXRq+YNoy1zt2W3jwP5wYjt+xtd6qPVlO5EtPnlYdlBAQAkKgdxHgoe+mHsuIXNScI9ykTYOZ0R/3HHWnplvNr0crnKb27hnpryMjStZmMzU6YM53R8yxLmZIEIJ7TSMmvRQ3igi+Y3AyLRECQkAICIF+QAAWo9BhiZyKbcY0V19xFgVixcpYfqJafM0S3IgoESFWbxoSxwpFrRcLbmStw+FQziMr8QKVyhfwHj4yEi78yGdrgn3yfe4arnfctpr5C2Xc/153DuvXrQnj4xPh0q9cHv7jU18JF73zxeGYbZsXqtbTeXrC9/Tp1cEJASEgBHoXgXWrhsw2eraz3KUc7aoVFs3IJrtHRicqJE51JKRDFgnpcI1ISEvpR2V7B4F1FuqZyEf4fknOnzFDWrd6uZsh7Ts8brbwjWlOiXjpnetERyIEhIAQqA+ByKhAkMCS8I91+Je49AxP9/accIF6iSQKuZFhsTTL89DSrpYSG0kkDKRMrGI9zHGbR+Si3XsPePPz/YxPNP6R6+zTHl1p8smPekC414NPD//9zR+Ehz7gHpX0flsR+dJvZ1zHKwSEgBDoIQTQEsA/xl4LB7wUrQOIm1rRjDwSkk2ut65fEZabKVJ1JKQegk6HskQEUkSj5Gi3ujoaWEREQmvq8LLrRkOqLjt3HSfPm9YSLWnZ3CxtCwEhIASEQA8jkIgWtFVQWcGRLqsop7B0msVWkrPdpLWSNGGcZzH2BTJmxpGrV4gKNEU73k/RMm1XC5op55z+mOqklqyvXbMqrFm9Mhw9OtqS9rul0Znz1C17rP0UAkJACAgBIVCFAJNWnJ9CwiwmaMpst6hJy6zstUaw1AojDZGDdgPlCPXLBFnSvwhsNHKEiFvzES8JFa4lrql4zQy7VlbKq7XkmuXaFfFSCyGlCwEhIAR6G4GkneKUS+HPxW2H7LCLiNGRjWEbXgXNFWdrbJm0WEhPyZaGmZG3a4nUcXGzJCvXxOvMxMRkGDMTIgSNmLTO9o9/dpWHoP7+j3/BZvjRT38d/v1jl4Rrdu7x6Ejv+tBnws7d+8Kd//xWnt+vP9J86dczr+MWAkJACPQQAjjLRetg14HahApmRpiHHDWzkHp8xfBus8fCCa8znx5bbYK8Z4G2ewhKHUoVApAjm+26Qqtl36HFv9ZB2lXMkIzkww/MmPmFmU9om2tWxN586ChNCAgBIdAPCEQfLWi0zOJEIE0sYdp+0HIhTDSC+ZBrx5BPgm0nHganvZ5IWRKtbsxDL8YLO1kT1z1hyT+nnHZ+SOTKs865wOtfdvGbwuaN6+w5ORp+cdXvAj5kkCnr/O3v/1R4xQUf8u3Vq4bD2c96dLjVzW/o2/36Y6RYOmX9CoGOWwgIASEgBHoFAZ5ohP0dnTPhxcQIU6OFyJmFMMC8CX8fjdZfqG3ldSYCiRw5aH5/Dpv/n6VKcsxL6PKDR8dnVSdc+iZz2iviZRYs2hACQkAI9BUC977zi51kgSWBFLGg0AVR4t5fbJ2liWVWCBjIGAo7IeO5sQAlLX3a0qk3s25pXsczWQtf+NY5tNpycS3iPfvC6OiYRzlatkzmtdJ8afllpw6EgBAQAkKgXQjwQrLFtAmIRHPIJs0pmtF4YRKyFL8w1fvM5BsHq7S9z/zLKBx1NTq9t44ZEKZGONAlrHQjgsYLZkgbLWw0183egxYNyV6w0b6CCJQIASEgBIRAfyPgJAn8iREmkSBBUxJmhV8y4lZUlYjbnlghXgqSxrJIwkwphq0O5nyXRBqAdOHPa3p+XGv9Lx8Yjtm6qfUddVEPIl+66GRpV4WAEBACQqA+BAj/i4+OITPtqNfMaLGWmYSPT06FLeYD5ujogGkzLF0bYrE+lF8+AsmxLj5/GiXr0lFQH00sCBd8DY2MT1o4c716JXy0FAJCQAj0NQIQJJAjhWMW50qcWDEnupYetV2SpktECoetUR+GekaypO3UVtEkWjSD1i5uZFii8cIfvmAk5SEgh7vlYa+ehYAQEAJCoIUI4ONlwt466vHvUu9uTJoGDU5XCTe80cJUS3oLgUS8LORYt5Ej5hpEc0rESyPoqY4QEAJCoFcRsKl4oaFiPErUXClUVKILFyiUWMSTbSNSJ/aL512rm0JHe7wjJ1aMYkEDxuvFKEiYIlFRxEv515HIl/LPgfZACAgBISAEWoTAyiISUk7fGm7DbFoROL3DnCRn2y2CQc0uggDn0M+lndMcGi/V3dE2EY3QxJIIASEgBISAEEgIDODlxdkUI1EgRyzDN4sCrKd0Lwip4gWsJBoz1OA/hezPPcYY0RKVZ2ybZNqyn2jGRBlPIVVSAgJ6EygBdHUpBISAEBAC7UOASe/2OkNR17tXvOd4JJuJKY9Yg3NWSXciwLnj+sCsjHPKuc0lqW0RL7kQVTtCQAgIgR5CwJ43mBc5OWIPHydN7PAwNxowbUknWgpyJa17opEwkWyhgaKeFeDxlcgVmp1y9qV4qNG4/RVbPQRidx2KyJfuOl/aWyEgBISAEGgAAbQPCOtLBJqcctAd+47HtqXZkBPatrTVbESjhXYytS3NqIVQUp4QEAJCoH8RQA8Fpyz2GwVmZMqZFSdinCjhi0D8H4kWW/ew0lZ0egpdF4gaNmJb3lpRZ9DzSaGl2K4vbEtSDgLy+lYO7upVCAgBISAE2oyAm5asG/awv0RCyiVHRnHEOx02myNe2m0kLHGufVE79SOA3x4cM6PtMjc0ef2tzF9ytbW9waIcuVb4/EWUKgSEgBAQAn2OwIA5bEmaLw6F8SeQKVAlEDJwKLOeI75tOZ7Bhq3aPy9TKWsptl7JQ9ulaJeGE3Hj/emn7QiIfGk75OpQCAgBISAEykKAFxQm3CxzOuIdN/MjfIWgXbPctGz2m0aMpHMR2GDXwLA5ZM7t34UjxmnvmpV6vercs689EwJCQAh0BgIxopHtCy8laLw4i2LbRpIk4qXgUczaKK5NG2GDz7kYCYnjmCFrvJ4TLbENmvN2yDAtGIs/bQl5NYDZA0n9CAj9+rFSSSEgBISAEGgjAvsPHg4Xf+6y8OWvfz97r+tWDfkkOWfDOOLddWA0DJlpkyIh5UQ2b1ucG84R56rZUNJz96yVxMvvr94VRkfH5napbSEgBISAEOhSBNyPC3xIQazMOM4teBjLw/eLlYA+8eVMHVJjXaNVKmZKsTzpnmlEDZowlKAtiJrYkifop+0I6NNM2yFXh0JACAgBIbAYAhd9+qvh3De8L9zyptcPP/zpr8PjH36/cPqTH7JYtSXlo52wzLRU9h0ezzYJZzK/2yb160yzYqs5cd1zcCxb20s6OBW+DgL4YNlsZmdHzbHuPtNSyimYtG1auyIMZ/YpxD7+/Ff/G0457fwAGbll0/rwnFMfHv7+3n+Vc/fVlhAQAkJACJSCQCRCnFAxNRVIEtdjMeZk2hLRcKGEh45GjcU5FGdVKquu3WKl3O8Lx0ACtSiOyRGrdGDpkdyhkKQsBKT5Uhby6lcICAEhIATmReDHP7sqvPptHwkfeusL/e8MI10+/9XvznXQBgIAAD37SURBVFu22cSVZnpCGGAm5rmEF50DRuiMmC+Y3FGWcu1jv7WTnN8eGZkwc7O8JmG0zTXUSuLlb+9+x/CNT14QXvzsx4aXv+H9gXtEIgSEgBAQAt2NgJMudgiRU5kKg1VaKTHiUSRQnEghz9VZrELhSJej9yR86VqhRNx4MxQv/sXtabc8oqSkPAREvpSHvXoWAkJACAiBeRD47Je/Ff70ljd2rRey73rn24aVw0MBs4tWCNov7qslIwHDfh6yiT5aNds2rAwrFAmpFaeurjbBnvN7gMhUdk5ySiJ1uIZyy+69B8K/PPe14da3uJGTLhvWrwn3+Ovbh+sfvz1c/oOf5e5O7QkBISAEhEAZCBhJYl5cjCkptFxsO2msYC2UzIQgWey/SyRVmMYXiZG9iVou3hYRjqI4oUObtukmSamRIl+L9iIgs6P24q3ehIAQEAJCYBEEtm7aEP7zysvCuz706bD/wOFw2bd+GH7+69+Fkx727HDrm98wvO2VZ7j5xSLNLCkbsxG0F/YQ+WbMPyEtqX6twiNm4rJz/4ibIBEJKWeUpVp9Kn0GgbWrlofVw8vdv8uERaTKKYQt32ymRq0KJX3eG98fJiYmw2vOecqs3eaeOO6YrbPStCEEhIAQEALdh8AsXy9OpBgB46wJdIz943WkIFZ8uyBbWLc407blmbZOCpGToGN41nkJJ2NmyoBPUZ5VSSkIiHwpBXZ1KgSEgBAQArUQeMSD7h1+fOVV4SOf+FLYZV//T3/SQ8Jtb3WTsHz5svCC898Z/v1jl4RnPenBtao3nI5t9RbzCeIaEhlDUTPp37lvNGwx7YtB64P2Ja1HgKhWmJXhg2fSHRbm63OdkTr49WmVoPXy5W9cEd72itPDhvVrK93gB+nI0ZHwl3e4dSVNK0JACAgBIdCtCEQyJP2i3cK6O8j1RBJsxRkZo1WIWIRgrwThYtGLop8YI168jOV5G1AwRVmvYNu26Ro1Ts54on5KQEDkSwmgq0shIASEgBCojcCwmRi95pynhl+YtsuZL3tbeOQ//W2l8P3N0eg3Lv9xZbsVK0za0WbAb0suYfKPBgwOXzetWxH2HzInv8l2O1cnascRgOBav3q5kXWDLSFe1lu0pLUtDiX981//r/kMGgt/ZqRjEhzv4oj6vOc/KWxYtyYlaykEhIAQEALdioBpr1j8ZyNGqqgSSBX4luIdoRK9iEQoFedUMFGKBIwVjNwMeVbX062QGzFZEYSQ1mHSVmwR63uyfkpAQD5fSgBdXQoBISAE+h2B0bHxsGvP/kVhuHbnXo/2QsH9Bw651ss/3v9vFq3XbAEm15uNJMkpvEehhYEmDJGQcjr5zbmf3dyW+2AxbLEw2mURjXJrvGxc23riBfyJaoRgYoSkiEcnmePd+5x4J0+b74d7intLIgSEgBAQAp2PwIARL86lwKNAujg7YvTJlHuBcbIEWgYOxSMV+SHZtr1QUC8to1qLJ1SIG9qjHuKOfQvvvgWnEzP023YEpPnSdsjVoRAQAkKgfxFgYvg+Mxt63Tv+w0G43z3vHF71wtk+LRI6NzDHosds2xQe9tSXhHvc5fbh17/5gy/bFWYXk5VWhIsm2s60acJghpTImHTMWjaOAMQLmB7Gt04LHOvSdisc6853xLe4yfXDkx/1D+HBTzon3OSGx4bLr7gy/NUdb+OOd+crT9rZr3hn+Phnv+bZD3nAPcJzn/aIMLyidaZRtfZD6UJACAgBIVAvAuipRI0Vr2EEiWu8mHqKEy72roCmiuuxOOFCvnMy8cfZFWiY6CPG+JZI0kDkJLIl1oap8TqUlpSHgJFo4r/Kg189CwEhIAT6C4ELLvx4+Oh//Xd448ueEVYMDZkPl3eEjebT4t2vO2teIDC9+MTnvua+X/72bncIt7jp9ect18rEKXv52VVorOTsB3Jng5mw7DMTpNFx9IEljSKwaniZmRqBpTlMHs/nMJn9SRGNWuVYd6Fj/vLXvx/+7y9+4z6P7mZRv2rJ180U70lnvjp84IKzw/WO3RbOf/MHw1W/+WO46F0vqVVF6UJACAgBIVAyAve93b8W2imJUbEdmjbDFKbn5s8FjRZMklg6meLbcCgxzXffSZaCUrFk1mxRSLEGg+Or5E6FS654WSqgZZsRkNlRmwFXd0JACAiBfkYA4uVR/3xSOOHWNw23uvkNwnte/9zwq//3e/tq/65ZsHzhsu+GK83HxcrhFeGhD7xnOPWUk0shXtgpJt2EKs4dLppISGi+QMAQlUfSGAKQLutWDbmZUW7iJYWpLoN4AQ1CS3PtJ+IFB9Rf+Op3awJ1/I6tYevmDeHVpk32s1/9tmXh2WvugDKEgBAQAkKgbgTQekHciAhnuu5Q19LgSoxoQfDjAtniHItn2Y+nUQ9NGC8Mp0Ila4I2YxuRirHaVPFUCsV2bUVSAgIiX0oAXV0KASEgBPoVgVv+//buPNaS9KwP8Omeme7ZZ+yZsRPMIgFhCwZFQk6QzB8kEbaJHNkJITFKCMYGEwiKAyaAbIxwiMISs0uIJGCjICVGKBBEwChKHDYBBgIymBgEEZiAgj2exeMZT3dP3877e7+q2z1jz9I9596qPuep7ntOnaqvvqp6qqV7+3e/pVqu/Npvvevw9m+tgUO/v2Z0+fGf+YUKW97d28+cObd5w3f88Ob13/5Dh+WWXsl/vu+49dTWQ5KM/5IAZm4Fs/R9Xm3nP8oZjW6s1jR55ksFLx/uWbz+235w889e/72b+x8YY8Fk8OkXf+HXb77pjW/qLkY//d9/pQ97y0++rd91O/pwirYRIEBgLQIJThKHjGikP3RSkrCltk1fHc6kSMpVQJOOK/lKjNJZS3bVh8Q0h9lL5SwJZ+YyHeD0/q4oR1gWENDtaAF0pyRAgMC+Cvzv6kLx8n/+rd3i5ZM+/qMPGd78lrd2APNf3vyvettv/s4fbG684fQmYc3alownss2ZkHJ/aRF8+02nNtfUuCX3vP+smZCe5KFnRqPMGpUuYfc9eLZ/Pn2SQy5r93HMaHRZFzQVTmuwe+57YPOZ01TTn/nir9h8Xg1A/dVf9vc37/qDd2/+7itfv3nOX7ijWry8b/PNX/uKzUtf9FlXchrHECBAgMAxCHzOp7+uw5KLvYJGeDI3Zjk5JSvJYOYlYUr2J4cZbWJ6pT9fLJOo5eJBqaZjmKzUsbodzVLH/67ly/GbOyMBAgT2VuCT/9LHbJ7z7Ds3L3/1tzzK4LP+6nM3f/Jn7znc9lc+9eNXGbzkAjMT0u3VVWibS36wurfGK3n4zPnNXbebCemJbDMGS4zOVLetmF36Q+kTHfdU9601eMn1J4ycg5cEMe+vFjAveeHz+9YSZn7KJ3zM5jM+/ZM27/yfbxa8PNUHrhwBAgQWEuhspcKQ+ftYWrt0a5V6P1HTUGd7z0Y9Xd8IWyo/Se+hWubjLslZensdWTunivNWX53y1ObuntSlvCwhIHxZQt05CRAgsMcCb/rur9v8xWffsfmaN3z/4XTTb6+uSM+68/arRuXGaSrqbXdJSauaB2q2nsysc921vkU/9h9ETI5qRqPDrmX1bK+GJUFMuu396f+7+/ByP6KCzV96++8cfrZCgAABAisW6PSlG6OMbKTTlopfKiQ5Uc1hkpnMoUnWL1QS09uyvZOX+pxAJeUv+To5begaKqgZx6RA/uYAy1ICV8dPGEvpOC8BAgQIbF3g1ptv3PzAt3315vNe+Y09XsUnfvxH9eC6b3z9l2/9XEdZYU9Ffc3JzT0PnNlk7JZtLQ9VAPPIIwebZ1a3mgQx+WypFkc1KPFNFYzc+8DZzdny2eYyT1N9XFNJb+va31gD6/7T13735tVf8nmbs+ce2fzCr75j8y++4mXbql49BAgQIHCEAhlMN1lIz2jUEUnFJdlUwco84G5O3+FJvu3VzgvV3bYL1dZsz08fvb/Sl3FMWs2MPeMnkzomh9S2CzV+nWVZAWO+LOvv7AQIENhbgTNnz21+ogba/cCDH9w8/3nP3XziJWPAXE0o5+sHoQyau80AJvefICCtPDIr0vsfOnc1kWz9Wo9yYN2rNXiZkX+vxnrJALv/591/tvn8F3/25nP/xl+bd3knQIAAgRULvOC5rx05SsKSkZckJalApYKVKVUZAcoco0w3kyClChyW6bClDu1jU1VVNprP1AF17FTXTPHWd4zx9ebP3o9PQPhyfNbORIAAAQI7KpDfUt1TLTK2PdVxApgMLHuuWnrc/+B+BjCZijvdjdLiJUHXNpdMJZ0ZjdK820KAAAECBI5ToMOXnDChyYWTFZmM73GdlSRZmUKVxCmdtGRTij/mc7aOdjBzgjNvGaUT56TRSzeaqePf+tvCl7AvsehQvoS6cxIgQIDATgnkP+9ppXJLdY3Z5jK3qkmdz7r9+vrhaX9CgrRIyT3nl3d3339m68FLntWdt50WvGzzH6y6CBAgQOApC4zAJMUv/d4+bU3rltqTr/5G2CvZN21NklJ/syWxTS8d4nTB2lbD7vbmEcwcdG/dbLj0XOMwr8cnIHw5PmtnIkCAAIEdF7jlxus26SKzzSXhQ1q9PHTmkb2ZCWnuCpR7PoouV3lGeVYWAgQIECCwmECmMkpWUm89SG4+5Jt+/c3MR2n80lHJlJekle0YJybdjuq4+krxzG6UfamnW3LWarekyedaz5RJ+d1NApk+YLEbdmLhi38DBAgQIEBgiwIZGDaD5W57+UANvpsg4q7brt+cvm53v33PMxrlfvO17SXdmPKMLAQIECBAYFmBSkQSoNRFdHgyt0qpxGTMazQCmO4vVIUypssoMs1yVMclUEkgk9YvVVVqetRXxS29P/UnnxllUs6yhICfPpZQd04CBAgQ2GmBzISULjN310C8B1scp+SDZ87X+C9nOtxJq5CjCCeWfDAJRW48fW0NYHy2BjDOj4zbW9Ka5pm3nN7k3UKAAAECBJYXqHCl05G6kgpQ0tqlttSfSkmmoCQtXPLVLWGyJ9lKljRlmQdxqY85Mn/7q7soj4JdV33uFjMV3oyZlVKBZQmB3f3V2RKazkmAAAECBCaB/Cf/rhpTZNv/2U8okdmVElJsu4vTkg8v9zKCl8wctf3gJWPybPtZLOnl3AQIECBwdQukIcuISOo+EozkdnpjhSUVmMxBzMnakV8bdOuYrNTSYUytdxiT/fnqfWPj6J5UBVNgLpQy5/twLwsJCF8WgndaAgQIENh9gXm66Myqs80lA/G+9/6HexagZ9x86qoeiDeDCKebVrob5Z6OZkaj0z119zafgboIECBAgMDTEagspJaEJSM86U/JSvKnd9ZoLvW7iF5Ny5guO8ZvSTCTfclbOnPpo1LDvOSocUzqG+VqbSQ0cyHvxyyw3Z8Gj/ninY4AAQIECKxdYAQwpzY3Xb/dnr75wSwtYBJW3Hnbqc21mUfyKltyzXfdfrpaulzoexk/bG7vJmKeqaTzDCwECBAgQGBNAqNtyxi/ZXz/q2/s9TetVsaAu/Web1/ZnKYtGTA3MUrKJFDp1jLZmb9VthuNjs8XW7yk/Djm8BxrQtizaxG+7NkDd7sECBAgcPwCaT6cgV6PoptQBuF9qMaCuaO6OKX1yNWyJHjJNT/48NHNaBTznvnhakFxnQQIECCwPwKVkyQYyVsylixZz+uUl9TqCFl6PJjamfcUGkHKaNnSoUw2VCXd/ahryL60oElLmT6wtta2WrUsJ7DdX8Mtdx/OTIAAAQIEVi+QAWXzW6xMHb3NJQPvpgVMuu+k7ofPrrtTdwYkTjByX13rmSO41oRcZjTa5r8wdREgQIDAtgVGZ6B6TdJSqUharuRnhM5H6iXTT1+Yw5lszOAv/TnHjKvJ/vySoQ6bE5muYP7FQ8rN5+kdOZdlMQHhy2L0TkyAAAEC+yiQrjAZ+PXeD5w7gpmQRgCT+tc6E9KtN167uf7UtZu77x9dprb5b+BktaZ5xs3X1VTc12yzWnURIECAAIGtC3Sblw5RKmRJq5SELTnL4basjuikNx6kdWvtTH4yZShp1ZLWMNW+paeb7hqyLwPC1JYOdWp/b6oth6lN1i3HLnD1tE8+dhonJECAAAECRyOQcODOI5h9Z54J6YapZcnRXP2V15rg5YYKXuaxaq68pg89MoFTZpcSvHyojS0ECBAgsD6B7kpUrVaStZycug3NMUx3L6rtaQkzt3LpoCXbkqskUKkDc1iClxGuJGTJxiqTtdHspeuvTTmyX70sJyB8Wc7emQkQIEBgjwUSFhzF9MfpfnR3DcSbH7IS8GQ2oaWXXEOu5ZprTm7ecwQzGs2WBtZd+kk7PwECBAg8VYFEJSfqe3YHJ0lH0u2oPs9TSidY6SxlJCfTen3oAypcqdWTqaMLzmVrZ21PHScOumAXP6wowY1lMQHhy2L0TkyAAAEC+y6QsGC01tjut+P8HHb/g2c3Z86d79mElgwl+h5rRqNcy70PnO0fFrf53E9fd7INl7zHbd6PuggQIEBgTwQOugnLFJ50h6G+8UvXEpqkNUvGdkmo0m1c6pt8t2qpli0ZULfTld5XLynUBXNU7asApsOcbO590pdILLVs96e9pe7CeQkQIECAwFUqkEHx0gLmKAaIfaAG4s3YL3cuNBNSZl/KuXMNuZZtLzGL3Tyw4LbrVx8BAgQIEDgygfoFTJZu+5KWKlP/ot5aGUn/R71Ck/xC5USClFo56LFc6nMylN5eb71+MbIZlXatU+2pJH+zzX//22ehFwPuLgTvtAQIECBA4FKBzNCT7jmZOnqbS6ZyPnf+oGdCeuCDNS31w8czE1KCkZtOX1sDC5/dnD2Xnwy3u5jRaLueaiNAgACB4xVIgJJAJK1YRuBSCUkvUyjTH+ulPo4AZg5URqns7u5FVWAe32UcmdeprvnYrqYinCngGTV4PW4B0ddxizsfAQIECBB4HIEEFs+o6aK3vST8yOxCt1x/3eaWGvT2qJecI8FLxp45iuAl01QfRUuho3ZRPwECBAgQmAUOpoBkzkOmuKR2J5AZTVt6W63OZXJsdyOqMhnrZYQtWe+MZqo6kc70uboddbelrqDK1ZgyluUEhC/L2TszAQIECBD4EIHMVPSs26/f+kC580C819dMS7ffvP2AZ76RBCM5R4KXnHObyzU1SHFsMl23hQABAgQIXM0CCUXSpGXkItN7gpfafNitaPo22mPnZ8dUvgOV3pfy0zH9njKlMm3rGKbGi8k5uvjVDLYD1y582YGH6BYIECBAYLcEetrkGqQ2YcM2l4Qh760WMFnuSv1Tf/NtnGMeWLd+3utzHEXwchTTc2/j3tVBgAABAgQuWyCD6NbSkxLV+whKRiuXHmC3EpPeltfMgtSl52xltGipJjLd+iU15fcd/am+EedzjpgDnnw6nBVpqsfb8QsIX47f3BkJECBAgMCTCiTMSNiQQWu3vdxX47A8fOZ8D4a7jQCmr7UG1k2d2x6zJvfeA/dmquothkXbNlUfAQIECBC4HIHMRpRfWHRXoKzUVwKWdDk6kaYvc3ej7KtlDlJO9Ai749jRBamjlx6w92JEM0KcVNhH572/0p3JspTA9n+iW+pOnJcAAQIECOyYwAhgTh1JN5vMPpSgJLMRnarpmq90ybF3VVego5rRKF2M7rz1lODlSh+Q4wgQIEBglQInutVKopF8VYBSb6MLUsUsvbmilGwefY6q9Uvil45gan+1cUlIkzurMCZ5TLd36e6+dVwdnyAmf3qty2bdsqSATtNL6js3AQIECBB4EoFMo5xxVE5Wq48HtjwT0gerpcojj1zomZA+ULMiZWaky1kSjNxcX++rrkyZUWnbyy01A9QtNQixhQABAgQI7JrAhSQm9T2+A5Q0c8lS+Uiylo5J6v3EwbS9A5iELaN0H5v1pCy9qaKXDmdyZErVe1dSb9k/9W2ap7POqSzHL3Dlv+o6/mt1RgIECBAgsLcCCSESwmx7SWiSwXETolxO0JGyOSbHCl62/VTUR4AAAQK7LpCIpAfCrQClW7IkRck4L9V6pbcXwNzS5TCNybbOW6bWMdPnHJod+YXNPADv3OqlW9NMSUyOtSwnIHxZzt6ZCRAgQIDAZQmkpckzayrqk/0bsMs69AkLZ3Dc91TrlVPTTEj54e3xluzLNaRsjtn2wLq5t9R/OUHQ412r7QQIECBAYK0CCUcy7kvCkTkg6TFc6ltw9qTVS1qwdGuXpCb1lWCm32t73vM29Tmq1XyuljL11i1fsiupzHRs71grxp5cl/BlTx602yRAgACB3RC4vqaivvO2GgNlyzMh5Qe+91UrloP6wa7r/zCD22YMmmfVLEnnHjnosmOgv+255p4yC1Pu0UKAAAECBHZZoGcf6j5BFZvUmCwjPKmoJb2RkqDkNYFLvkY6k0297+LMRaMr0hy2jD5GFbOkjg5durI6phOdEcTsMurK7034svIH5PIIECBAgMBjBa695mTPhLTtACbnySC8Dz08ZkK6dKaleUajh2pcmAzWu+0l95LZncxotG1Z9REgQIDAagUSrCQYSUZS47IkREnQktwkS+2pJa1gEqZkdYQyY884Nq8ZjDf7RkhTZaaspY/uc9S+eu8QJhstiwgYxW4RdiclQIAAAQJPTyAhxV01U9G9D5zdnDlXP5VtccnAu+lOlO4/CWPys17Gm7n/wXObh8+e3+KZRlU3VEuX226uQYWfoLvT1k+qQgIECBAgsKjACFuSvCQWSRekeullimHmD/2ekGX8nb/nV6l8gz7Zezqoyce5C9NBrZysljWpMgPt9qxJaRJjWUxA+LIYvRMTIECAAIGnJ5Cw4o5qLZKAJFM9b3NJyHL+/IXNHRXwZHnvfQ9vfXyX1HtzDdx7a81qZCFAgAABAvskkBmLRlCSu+6IZAQoaQiTTCXbRoOW3ptS9fEx61Umh3bqMgcv3X7mMITJOTKgbzZ0K5tUZFlEQLejRdidlAABAgQIbE8g4cUtN27/9yk3XH9NN1M+X4P+3XQEUz7nmgUv2/t3oCYCBAgQuIoEEopM4UoClI5MKkQ5UcnLiQpmkqd0Q5V6z3JibsUyfc7+TmN6Z5Wt93wddAuaUfG8rZOY/pAXy1IC2/9Jbak7cV4CBAgQILDHArfccN3m2uqKdP+Dj9RvzJ7eD1fp0nT7zac6eHnPfWdaNd2O0srmnurmtI2BdlNfZm+yECBAgACB/RSo79X1N61ZOnpJc5da0j0of3q945R0LxqhSvUwquWSxOZRvYjGUenBO9q4VJyTMKeOOPyxYJwilVgWENDyZQF0pyRAgAABAkchcMPpa3umoqczdso8sO7Zc+cPg5b88HbfB85usi2zHT2dQXFzbOoQvBzFvwB1EiBAgMBVJVBhSPKQHrUlocuUlOTz+EXHHJ7M7wlSRoKSoklWckzGdElC0/WkziozyiWAyQlSOgVzkGUpAeHLUvLOS4AAAQIEjkAgMyFluuYrCUium2ZRyvgxH25Go2zLvsxKlLKXu8zBTq7RQoAAAQIE9logrVYShuQ9AUlavszBSj5nSVejdEHq9XpNfjL1VRqhyjjkoMOVKlT7UzZdmHrJuDK9UifJAVP9Y6fX4xbw089xizsfAQIECBA4YoE55Lh0qugnO2Vaojzz1lObe6qFS2Y7erwl++598GwPxHvD6Wser9iHbM+13FmD915JKPQhldlAgAABAgSueoEKQyoT6VYruZduuZKVtF+5JCypYCVhSr9WQNOtW7rYJQFLQpWEOFPXpdHSJYVOdFfk7pAkeAnIoovwZVF+JydAgAABAkcjkJDjjgpTbqpBc59suaUG082sQ3fff2Zz7pH89PbEy9ma2jqzH/VAv09hIN4b6xoyLbbg5Yld7SVAgACBfRJIm5QpSkmO8qivw7YrtSNBTP2tr7F1+tBUFcqku1LWD7sdJahJa5kR4ByGNt2nqQ/yspCA8GUheKclQIAAAQJHLZCxX2676dQTzoSUAOX6asGS4OX8/Buzp3BhKfveGow3x2Zw3vzw9+GWzGh0e12DhQABAgQIELhEIFMZdYuVhCVT8jK1TjlR7xnGZSzj++vh1NTJXqY9qSKD7PdA+/V9eYphqtpaO6ivrq8KVRUnu/Bcp/clBIQvS6g7JwECBAgQOEaBzISU2YUuXdIKJa1RkpkkRLmc4GWuJz/s5dgsd1Yrm8e2bMk5c24LAQIECBAg8GEE6ptwxy4JRjqCSdCSNivZnnCmPuYXI3mvXT20S6UyI5gZoU3Wc9RYUjZ1ZWPVkB2ppr5fJ4cZZ5uKejt2AeHLsZM7IQECBAgQOH6BjOmSgXLTGiYhSdYfPnu+pqY+97QvJjMhpa7Umbpzjmfeki5PppJ+2rgqIECAAIGdFThxMA2Im1Ql60lI6utiy5cKTZKuVKCSaaY7V6kwplY7VKktYz2f5/0dxeRD5y+dzIywpjbNKylvOXYBPxUdO7kTEiBAgACBZQROXTdmQsrZM2vREw2se7lXmJmQ0nomg+pmeWwrmMutT3kCBAgQILDTAmmNUjeY17RCzYeEI52P9Oexcc5L0to0XXyTz3RIU7t7vZGyMdvHxnQ/GnMk1TEdxoyyJ9MoxrKYgJYvi9E7MQECBAgQOH6BORQ5+xQG1r3cqztTA/Fmmc9xuccrT4AAAQIE9kUgwUmWhCsnptYsI2ipOKb3VXySLkMplDJ5qw0d1ORT7bvYjSil5lYwec/nxC4pkQBmlL0wDq5PliUEhC9LqDsnAQIECBBYUCDhSGZCOl0tYba1XH+qZjS63YxG2/JUDwECBAjstkBPMZ2Upf+OmKQzkwyW26nLvK0KjORlgPTvOfIyhS1VR4c1UxjT611vF6yQZrSWGeeZtu027Wrvbns/da32Fl0YAQIECBAg8FiBjMtyR43Rso1xWTJVdcZ4SZ0WAgQIECBA4CkIdEoyRygJUKYw5bDD0Kijv7VO+050dpKy4/vt3FKmE5wUr3Kd09Rqt3nJ5z4odSfUGXV6XUZA+LKMu7MSIECAAIFVCIwZia58CLgEL7fUdNUWAgQIECBA4KkLJAxJ4HIYiKSBS32el4za0q1VsmneXMnKOKa6JFXZLt77RuTS8U197k/dgiaHjq5HXXiuZz6J92MVuPKfto71Mp2MAAECBAgQOCqBhCfXXHNi8/4HH6kZLZ/6T2a333zd5sbTfpQ4queiXgIECBDYXYFEIllGYDJapaRBy9yaZd47f+55prNxaj6RgOUwfZlawqTKMTtSIpeTYwDftJY5THhykGUpAS1flpJ3XgIECBAgsCKBhCh33HbqKQ2WmzFjMr6L4GVFD9ClECBAgMDVJZCWK9MVp8XLmAY6WxLEJDy5ZDksWNvSIKYG6O2gpd/G2DB95BSydMuXKpiPI5dJK5s+5JJKrR63gPDluMWdjwABAgQIrFTgumtO9lTRTzRbUfZlOumUtRAgQIAAAQJXJtDjtlSIcrFlS9XTCUkP7FKr077MhNRpSr13KDMFM1Usm7urUgqkXL13fRW0nKiBdlNft7BJvVkS2lgWE/CT02L0TkyAAAECBNYnMLdqua66IT12ybYEL08Uzjz2GJ8JECBAgACBDxXoGY3yrXYORmq1W6qkaG/PyhSWTG/zd+aKWbqlzIU0g8l6Qpba2aO7TPWN7keXVN9lhC9RXWoRviwl77wECBAgQGClAj0TUoUsN56+5vAKMyvSXbdfL3g5FLFCgAABAgSuXGC0ZqlwpEKThCcJUXqp9QvnR+uWDlmyPcFJv40tJ7qFS7aN7kRz6JK9WUZ9o8bR8qU2dgVzfNPFvByzgFHyjhnc6QgQIECAwNUgkADm9ptr+uiT5/pybzWj0dXw2FwjAQIECFwlAiM4GXFJt4hIbnIhfYlOViuW2j4HLod5yRTApFjKZnuVP1Hfr+cgJw1hxrG1rz+k7NQVKcXngCe7LccuIHw5dnInJECAAAECV4+A0OXqeVaulAABAgSuHoHRZSgNUipFqb8dqEwr6TLUoUpuJz2Lsj9hy+FSGxOqJHipbSdSppZRprbU9q63VlNXn2KcYBT0uoiAbkeLsDspAQIECBAgQIAAAQIECOyrQHoBZRldhqoFS8co2ThauGRw3C6TICb7Ojyp9bRumcp296IMtNs1JZBJi5naOw2s23u6yhHA5EjLcgLCl+XsnZkAAQIECDyhwNt/611PuH8fdv7yr79z84GHPrgPt+oeCRAgQGDfBCoYSeySpinJVhK25CvrabFy0M1exueZJoFK4phRKFvHAeP4bE9XpOyeAp3UmWIJaVLIspiA8GUxeicmQIAAAQKPL/Dnd9+7efmrv2XzA//hJx+/0B7s+eXfeOfmc/7BazbP+9wv2/xKrVsIECBAgMAuCIwgJC1ZEoiMr9FFKGnJ1MLlcLroBCi1rcOT6X30Mapjq4tRH1+1JLmZlynQ6Y9dfUpdsn8udxnv99z3wCY/n1iuTMCYL1fm5igCBAgQIHCkAu957/jh5nt+8D9vPvMz/vLm0z754470fGut/Kte9fmbt/3Sb25uvumGzXP31GCtz8Z1ESBAgMDTFEjO0oFJWr4kVBkxzGiqUnV3k5W0YsmOfMgB3Yhlc7L6H/VguvW5M5nsPgxyLh6bY7qtTJrDXOHyh3/0Z5tXvubbNu+5+76u4RM+9iM3r/pHf3vzws9+3hXWuJ+Hafmyn8/dXRMgQIDAygXe/KNv3XzTa16+edU/fPHm1d/wfZs//r9/vvIrPprL+8Zvf9PmkfMHm+96w1dubrrx+qM5iVoJECBAgMBxC3RiMkcjY7yWXEJnJNO+nv3osFy6E42AptuwTGHMYQuaymU6nEk6U8eklcxoVVObqwVNVzPVlZKXs5w/ONh8wUv/5uZ//Nh3bn7hJ75382mf8nGbb//+/7Q5f/785VSz92W1fNn7fwIACBAgQGCNAm/8xi8/vKx3/v4fdRekH/+hb97cdutNh9t3feU7fuBHN//t53998yPf99rNs+96xq7frvsjQIAAgT0S6Kmmc7/d2iUzF01BTLVeqcmmuwvRaNmSAhWkTA1XOmyZyvamhC75PJUZXYtOVCOY6ZgELl0wkc2VLWnpkq95eckLn7/5sZ/6uU1axHzCx33UvNn7kwho+fIkQHYTIECAAIGlBd7wNV+8OX361ObLvvaNfSk//6vv2Lz7T3ezJczv/eGf9D2+5SfftvnB//jTm2/4qn+8+diP+YilH4HzEyBAgACBrQqM8VnGHNH9n/KEJAlMOnipU/V6tXaZs5P6fGFuaJJt01eHLTk0h3SSkzrGoLvpqpQWMI9uHfP0byOD4d94w+nNRz3nWU+/sj2qQcuXPXrYbpUAAQIErk6BtPp483d93eaLXv2vNy/94tdt7n/gwf58dd7N41917uuffN13dB/y/Ebtq770721epD/544PZQ4AAAQJXrUCHIt0kJZFJkpS6lXQlSorSIcrc+mVu9TI+J6jpIglpeq6kPrAPn1vTjKmmpzimdieo6aWCmEuXBx96ePOmt/zMpZsetf6SFzx/85Efcdejtv1azcT4b3/kpzZf+Yq/s7nh+tOP2ufDEwto+fLEPvYSIECAAIFVCCSAef7zPu0wePno5zx7Fde1zYu47ZabOlT6xbf/9uaOZ9y6ecUX/K1tVq8uAgQIECCwGoG5lUq6FnWakkYwHY70nnw4bPXSsxxNuUmKdMjSLVpG8NKhTXVX6qmpu8DF28zHHJqppx+7ZMyW9937/sf9OvfII4865F1/8O7NV77uezYvedHzN6942ec+ap8PTy5QzzGPw0KAAAECBAisWeAn3vqLm7e+7e2bb33tq3Z+3Jf73//g5l9+5w9vPvWTP3bzRZ//wjU/FtdGgAABAgSuSOAFd33pSEU6GnlMFVNg0uPA1EuHL12kWrvUf9/n8V86dOlmLQlhUl26HGVltJJJF6auvvsojXreeve/S4nLXn7jHb+/+fKv/87NS1/0WZuv/YqX1TWMc152RXt8gPBljx++WydAgACBq0fgAw99cHPzjTdcPRe8hSvdx3veApsqCBAgQOAqEPicO75kBCXJMNIcopOWWqn3OWDpXY9tKjGVnw/rSi4pk+1p45L3LMldDqrOdFLKxp+9gvDlV/7X726+9DX/poOXV3zBxRYvt9x84+YZt90yTuT1SQWM+fKkRAoQIECAAIHlBfYteIn4Pt7z8v/SXAEBAgQIHItAdw+qSGRKStK6pVuuJEjpzikJYdKIZWrNMuKTmj462+YrrCPyIZ/7mHqr1dHipfb1ICPZOZ0kb1ew/O7v//Em003/2H/9uf6aq3jZS/765nWv/sL5o/cnEdDy5UmA7CZAgAABAgQIECBAgAABAtsUeMEdrxxBSdKSTk9GQNLhyZynZFeHKwlZqlSHLKN4f87+wyU7aznshlQHdGVjc7/W55+9599fssHqcQoYcPc4tZ2LAAECBAgQIECAAAECBAgkTKm8JflIWrx0+5bOT0bQUuPnVuCSvbVMLVYyi1GXr5cpahn7K3AZf0aFGVw3x6bOrqI3P+qIcZzXYxXQ7ehYuZ2MAAECBAgQIECAAAECBPZd4HBcl6QplYt096GOVjIw7rQt4UmSl9rf0Uleal+6InXLl/m4ah1zogOYoTqOT+ERxqTCzJBkWVZA+LKsv7MTIECAAAECBAgQIECAwB4KdIBSaUqClxNzUBKHpCe9bUKZQ5f+OI8BM45LwDLGeJkCmtTXVeQ1WU3Kj7FlEtBYlhMQvixn78wECBAgQIAAAQIECBAgsK8CI2Ppux8tX2p1bs0yto4cptenBCYF0icpkUo2Zel68lJbM7NRuhzVvuyeg5d8mGObPsbLsQsIX46d3AkJECBAgAABAgQIECBAYK8FejCWCkeSo1QsMrdQSYAyttRr0pW5tUqVT5iS3d2DKMcf1JYexbX2ZUeV7+5MnbSMilJvPmb/2FLlLIsIGHB3EXYnJUCAAAECBAgQIECAAIF9FUiQMlqjjOilW6j0to5Laq0ClQyw2yPvZseITrp70hgGpg4fY7p0XV2iPle5izWM0KUHiEl9qcaymICWL4vROzEBAgQIECBAgAABAgQI7KNAApLMdpRlxCJTu5S5RUy2z2lJWr3U+mjVUjvm9eyvfaMlTFdUu3pjfZiO7wOrRUw3jdH2pWEWehG+LATvtAQIECBAgAABAgQIECCwnwLdDShZSLKS+pDMZUQjiU8yy1E2TK1Vel/2pltRvzZa1lPsYtySj2MA3rFv2pnSU2uZPtDLIgK6HS3C7qQECBAgQIAAAQIECBAgsK8CHY4kNam4JN2L5hCl45M5Van3KV/pQKbDmDmoqX0ZWLeXw/JdXR0zbc8YMPWnT5PjemUc4vX4BYQvx2/ujAQIECBAgAABAgQIECCw1wJTeDKGbanmK9ViJSFK/T2ZwGTKT7qpSyKUKWgZb9l5GLHkkG7Z0gfX6qhnqiCD8o7i9T5tS3nLsQsIX46d3AkJECBAgAABAgQIECBAYK8F5iBkbo1SuUg2JTjpYXOn9bRd6R21fQ5nRtoyRnepEXmLsfalnhxTb93xKOnNQa1VqDNqTN17Lb74zQtfFn8ELoAAAQIECBAgQIAAAQIE9ksg47eMZi8dsNTqlJ90SNLbastB+grlK29ziaQ09dW5S9Bq/2gZk8BlKlWrXV8fnzIXW8rsl/N67lb4sp5n4UoIECBAgAABAgQIECBAYC8E0pIliUq6FHVMUuHKaJqS9/w5qH0jhKnWKwln6nMvKZ6lmrJk2+EsSLW7q6oWL6mqSx/WkQNqu2UxAeHLYvROTIAAAQIECBAgQIAAAQL7KNDdi5K91J8TnayMsCRdgw4H4K39c1eh7laUD8lPpkAloUs+nqjtCVo6qMnxqTdlE8x08T5RrVmWFDDV9JL6zk2AAAECBAgQIECAAAECeyeQNi0dssy5SEKTCmEuJDnJtnxONJP0pD53kNLr9ZK/1cTlZJdL/FJtKhK0TAO/jCwn9WT0lyxTJRq+tMZSL1q+LCXvvAQIECBAgAABAgQIECCwnwLpGjRSlBGcTAodtnRYksDkkgCmPnaQ0iFLPlRQM7WYSfAyWr1UnakgoUzaxFRA0/WlqnzNzWhSseXYBYQvx07uhAQIECBAgAABAgQIECCw1wKH/xPvpGSEJ/XaIUrlJtmdTkMjS0lykrF0E9gkd5mPmcKVLtm7xkuHMYlq5lAmayOMuaSU1WMWOHzkx3xepyNAgAABAgQIECBAgAABAnspUA1XujVKApZe+nNeEprUrtrcZTKeSxfpjkq9LwdmU8KYHtplKt8Fs6O/xgnGsWn0klinK5rq8HbcAsZ8OW5x5yNAgAABAgQIECBAgACBvRY4qNQkwUm+ErjkrWOXClQyWG6HJbUhAcw0lEuVGEFMyo3jaqW2XVzPnhGxdMuZClzmyKWPSR5jWUxAy5fF6J2YAAECBAgQIECAAAECBPZRoAOTOXxJC5YpNBktXioqyb6pIUxHM+ly1OWnQCVpTS2Z8ahbt+Q9BbK918e+cczY3Ad4WUxA+LIYvRMTIECAAAECBAgQIECAwF4KTOFJhm+pmKUDlAQyo+1KNl0MUzpg6T0JUerP1KKlg5U+eoQrowXM6J6UYzIF9Ry7ZGpry7ICuh0t6+/sBAgQIECAAAECBAgQILBnAvMAuHNg0gFMBzEjPMn4uGnjUiO71FetjYKji1FtHllKApYR14zX+pyMpV7SbWluATO3qpmDmD2jXs3tavmymkfhQggQIECAAAECBAgQIEBgHwQSjiQwueRlBCe1vYOVesnYLxemcKV7HVWwMlq+1GEJWHJ8xogZPZJGTtMtY6Zy2Z/Pc9k0lbEsJqDly2L0TkyAAAECBAgQIECAAAEC+yjQLV/SomXOQzpxSQuXqZ1KJSvdVSiBSwKYGgBmxDUJZ3LQ9D4SmG7pMuo8mT2DdD62G89MYc0+Yq/knoUvK3kQLoMAAQIECBAgQIAAAQIE9kOguwXVraYlS4KUDlYqSLlwUCFLApiEKr1rdCXq6CT7K3jpXXnvz314dozjOpipbXVwyiXc6XOkRU02WxYTEL4sRu/EBAgQIECAAAECBAgQILCPAiMIGQHJHLJ0bjK1fLnYIqajliZK96Ish8HM4UqClaorldZXhzIVveRjv/bK+JTjLcsICF+WcXdWAgQIECBAgAABAgQIENhTgXQpShzS7VI6NUkzlmr/kgTmZH2lpUrnLrU+5y/1PsKUEaxc7IpUdY3Kqr7aVx9O1EC9He30MTnNXEnOaVlCwIC7S6g7JwECBAgQIECAAAECBAjssUACloyRW6FI5puuVi2JVHqQ3Q5K6nMHKmnRMsrmgEwzPZaxnqClW8TkvQ/oikbw0uX7NHVcn2mPvZe/dS1fln8GroAAAQIECBAgQIAAAQIE9kogo7ykbUqFJglgaknGkqgkn3o1Hw8Hdqkt3e0o5Wu9tncoU4XnGnL86HpUQ+/WyskKanpfrfegveMEqdWygICWLwugOyUBAgQIECBAgAABAgQI7K9AWqIkQxndgYZDRzAnTnbG0sFMpzAdtaRgBzVzyYQsyVJ65qPUU0sHL/Wej/OAvl0uLWuq8FQsRS0LCGj5sgC6UxIgQIAAAQIECBAgQIDAHgskOOlkJAbViqXWR2hSHyuYqXYrHZi0UGUnCVNSvseK6SylN/axSV3mYGXUUftqy+ihNJWbC3SFXpYQEL4soe6cBAgQIECAAAECBAgQILD3AolJOig5qHSkPoyMZHRJmuKYZCvVGuaguxGN4imVjY8OVlLXYYiTElVkdDxK+VTe/ZZq3bKEgPBlCXXnJECAAAECBAgQIECAAIH9FqjA5XD83IzhUhpzG5YeniXZSrbVhxO1v7sYZUv/TUuYsX9u+TLClrlcHZhjDkOa8bleLQsJCF8WgndaAgQIECBAgAABAgQIENhTgZGUjEF0k7AkJOnlkhCmNiU86XYrabXSg+wmjBnbE8KM9d7VSUwHNeOI3pmqa/jdeumTTOfwtoSAAXeXUHdOAgQIECBAgAABAgQIENhjgUpQOk9JtJJljlnynrAk2ztl6dYv3RGpto3WL9k19uX9cCrqOqyXS4KWg+yfU5rUZ1lMQMuXxeidmAABAgQIECBAgAABAgT2U2C0SemIpV5Gu5SxLR4jMum9UwbT8csomOBlPmI6ZEQ3CWJGuYMRuXR3pQQw3WpmP6FXc9cVkvWTW80FuRACBAgQIECAAAECBAgQIECAwC4J6Ha0S0/TvRAgQIAAAQIECBAgQIAAAQKrExC+rO6RuCACBAgQIECAAAECBAgQIEBglwSEL7v0NN0LAQIECBAgQIAAAQIECBAgsDoB4cvqHokLIkCAAAECBAgQIECAAAECBHZJQPiyS0/TvRAgQIAAAQIECBAgQIAAAQKrExC+rO6RuCACBAgQIECAAAECBAgQIEBglwSEL7v0NN0LAQIECBAgQIAAAQIECBAgsDoB4cvqHokLIkCAAAECBAgQIECAAAECBHZJQPiyS0/TvRAgQIAAAQIECBAgQIAAAQKrExC+rO6RuCACBAgQIECAAAECBAgQIEBglwSEL7v0NN0LAQIECBAgQIAAAQIECBAgsDoB4cvqHokLIkCAAAECBAgQIECAAAECBHZJQPiyS0/TvRAgQIAAAQIECBAgQIAAAQKrExC+rO6RuCACBAgQIECAAAECBAgQIEBglwSEL7v0NN0LAQIECBAgQIAAAQIECBAgsDoB4cvqHokLIkCAAAECBAgQIECAAAECBHZJQPiyS0/TvRAgQIAAAQIECBAgQIAAAQKrExC+rO6RuCACBAgQIECAAAECBAgQIEBglwSEL7v0NN0LAQIECBAgQIAAAQIECBAgsDoB4cvqHokLIkCAAAECBAgQIECAAAECBHZJQPiyS0/TvRAgQIAAAQIECBAgQIAAAQKrExC+rO6RuCACBAgQIECAAAECBAgQIEBglwSEL7v0NN0LAQIECBAgQIAAAQIECBAgsDoB4cvqHokLIkCAAAECBAgQIECAAAECBHZJQPiyS0/TvRAgQIAAAQIECBAgQIAAAQKrExC+rO6RuCACBAgQIECAAAECBAgQIEBglwSEL7v0NN0LAQIECBAgQIAAAQIECBAgsDoB4cvqHokLIkCAAAECBAgQIECAAAECBHZJQPiyS0/TvRAgQIAAAQIECBAgQIAAAQKrExC+rO6RuCACBAgQIECAAAECBAgQIEBglwSEL7v0NN0LAQIECBAgQIAAAQIECBAgsDoB4cvqHokLIkCAAAECBAgQIECAAAECBHZJQPiyS0/TvRAgQIAAAQIECBAgQIAAAQKrExC+rO6RuCACBAgQIECAAAECBAgQIEBglwSEL7v0NN0LAQIECBAgQIAAAQIECBAgsDoB4cvqHokLIkCAAAECBAgQIECAAAECBHZJQPiyS0/TvRAgQIAAAQIECBAgQIAAAQKrExC+rO6RuCACBAgQIECAAAECBAgQIEBglwSEL7v0NN0LAQIECBAgQIAAAQIECBAgsDoB4cvqHokLIkCAAAECBAgQIECAAAECBHZJQPiyS0/TvRAgQIAAAQIECBAgQIAAAQKrExC+rO6RuCACBAgQIECAAAECBAgQIEBglwSEL7v0NN0LAQIECBAgQIAAAQIECBAgsDoB4cvqHokLIkCAAAECBAgQIECAAAECBHZJQPiyS0/TvRAgQIAAAQIECBAgQIAAAQKrExC+rO6RuCACBAgQIECAAAECBAgQIEBglwSEL7v0NN0LAQIECBAgQIAAAQIECBAgsDoB4cvqHokLIkCAAAECBAgQIECAAAECBHZJQPiyS0/TvRAgQIAAAQIECBAgQIAAAQKrExC+rO6RuCACBAgQIECAAAECBAgQIEBglwSEL7v0NN0LAQIECBAgQIAAAQIECBAgsDoB4cvqHokLIkCAAAECBAgQIECAAAECBHZJQPiyS0/TvRAgQIAAAQIECBAgQIAAAQKrExC+rO6RuCACBAgQIECAAAECBAgQIEBglwSEL7v0NN0LAQIECBAgQIAAAQIECBAgsDoB4cvqHokLIkCAAAECBAgQIECAAAECBHZJQPiyS0/TvRAgQIAAAQIECBAgQIAAAQKrExC+rO6RuCACBAgQIECAAAECBAgQIEBglwSEL7v0NN0LAQIECBAgQIAAAQIECBAgsDoB4cvqHokLIkCAAAECBAgQIECAAAECBHZJQPiyS0/TvRAgQIAAAQIECBAgQIAAAQKrExC+rO6RuCACBAgQIECAAAECBAgQIEBglwSEL7v0NN0LAQIECBAgQIAAAQIECBAgsDoB4cvqHokLIkCAAAECBAgQIECAAAECBHZJQPiyS0/TvRAgQIAAAQIECBAgQIAAAQKrExC+rO6RuCACBAgQIECAAAECBAgQIEBglwSEL7v0NN0LAQIECBAgQIAAAQIECBAgsDoB4cvqHokLIkCAAAECBAgQIECAAAECBHZJQPiyS0/TvRAgQIAAAQIECBAgQIAAAQKrExC+rO6RuCACBAgQIECAAAECBAgQIEBglwSEL7v0NN0LAQIECBAgQIAAAQIECBAgsDoB4cvqHokLIkCAAAECBAgQIECAAAECBHZJQPiyS0/TvRAgQIAAAQIECBAgQIAAAQKrExC+rO6RuCACBAgQIECAAAECBAgQIEBglwSEL7v0NN0LAQIECBAgQIAAAQIECBAgsDoB4cvqHokLIkCAAAECBAgQIECAAAECBHZJQPiyS0/TvRAgQIAAAQIECBAgQIAAAQKrExC+rO6RuCACBAgQIECAAAECBAgQIEBglwSEL7v0NN0LAQIECBAgQIAAAQIECBAgsDoB4cvqHokLIkCAAAECBAgQIECAAAECBHZJQPiyS0/TvRAgQIAAAQIECBAgQIAAAQKrExC+rO6RuCACBAgQIECAAAECBAgQIEBglwSEL7v0NN0LAQIECBAgQIAAAQIECBAgsDoB4cvqHokLIkCAAAECBAgQIECAAAECBHZJQPiyS0/TvRAgQIAAAQIECBAgQIAAAQKrExC+rO6RuCACBAgQIECAAAECBAgQIEBglwSEL7v0NN0LAQIECBAgQIAAAQIECBAgsDoB4cvqHokLIkCAAAECBAgQIECAAAECBHZJQPiyS0/TvRAgQIAAAQIECBAgQIAAAQKrE/j/Bokb+hCo0SMAAAAASUVORK5CYII=", + "text/html": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "CT_matrices = compute_CT_matrices(polys_C1_f)\n", + "f = sp.sin(10*(u**2-v**2))\n", + "bd = Matrix(build_data(f)).evalf()\n", + "plot_function_on_triangle(\n", + " lambda uc,vc: CT_eval([m.evalf() for m in CT_matrices],\n", + " [t.evalf() for t in CTtri_bounds],\n", + " bd,uc,vc,1-uc-vc), str(f), [[1,0],[0,1],[0,0]])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d45b715a-ca53-4b8f-b420-ec4268a386d4", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "da4db961-44ae-4566-9a09-edb1ce0730b1", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "67a5967e-6302-44c8-b2a4-689fe2152cd7", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.20" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/clough_tocher_patches/clough_tocher_autogen_matrix_coeffs.hpp b/src/clough_tocher_patches/clough_tocher_autogen_matrix_coeffs.hpp new file mode 100644 index 0000000..4c287e6 --- /dev/null +++ b/src/clough_tocher_patches/clough_tocher_autogen_matrix_coeffs.hpp @@ -0,0 +1,396 @@ +#pragma once + +namespace CT_interpolant { +inline void CT_tri_bounds_coeffs(double bound_coeffs[3][3][3]) { + bound_coeffs[0][0][0] = 0; + bound_coeffs[0][0][1] = 0; + bound_coeffs[0][0][2] = 1; + bound_coeffs[0][1][0] = 1.0 / 3.0; + bound_coeffs[0][1][1] = 0; + bound_coeffs[0][1][2] = -1.0 / 3.0; + bound_coeffs[0][2][0] = 0; + bound_coeffs[0][2][1] = 1.0 / 3.0; + bound_coeffs[0][2][2] = -1.0 / 3.0; + bound_coeffs[1][0][0] = 1; + bound_coeffs[1][0][1] = 0; + bound_coeffs[1][0][2] = 0; + bound_coeffs[1][1][0] = -1.0 / 3.0; + bound_coeffs[1][1][1] = 1.0 / 3.0; + bound_coeffs[1][1][2] = 0; + bound_coeffs[1][2][0] = -1.0 / 3.0; + bound_coeffs[1][2][1] = 0; + bound_coeffs[1][2][2] = 1.0 / 3.0; + bound_coeffs[2][0][0] = 0; + bound_coeffs[2][0][1] = 1; + bound_coeffs[2][0][2] = 0; + bound_coeffs[2][1][0] = 0; + bound_coeffs[2][1][1] = -1.0 / 3.0; + bound_coeffs[2][1][2] = 1.0 / 3.0; + bound_coeffs[2][2][0] = 1.0 / 3.0; + bound_coeffs[2][2][1] = -1.0 / 3.0; + bound_coeffs[2][2][2] = 0; +} + +inline void CT_sub_tri_matrices(double subtri_matrix[3][10][12]) { + subtri_matrix[0][0][0] = 1.0 / 2.0; + subtri_matrix[0][0][1] = 1.0 / 2.0; + subtri_matrix[0][0][2] = 0; + subtri_matrix[0][0][3] = 2.0 / 3.0; + subtri_matrix[0][0][4] = 2.0 / 3.0; + subtri_matrix[0][0][5] = -7.0 / 12.0; + subtri_matrix[0][0][6] = -1.0 / 12.0; + subtri_matrix[0][0][7] = -1.0 / 12.0; + subtri_matrix[0][0][8] = -7.0 / 12.0; + subtri_matrix[0][0][9] = 4.0 / 3.0; + subtri_matrix[0][0][10] = -2.0 / 3.0; + subtri_matrix[0][0][11] = -2.0 / 3.0; + subtri_matrix[0][1][0] = -3.0 / 2.0; + subtri_matrix[0][1][1] = 0; + subtri_matrix[0][1][2] = 9.0 / 2.0; + subtri_matrix[0][1][3] = -3.0 / 4.0; + subtri_matrix[0][1][4] = -5.0 / 4.0; + subtri_matrix[0][1][5] = 5.0 / 4.0; + subtri_matrix[0][1][6] = 7.0 / 4.0; + subtri_matrix[0][1][7] = -1.0 / 2.0; + subtri_matrix[0][1][8] = 1.0 / 2.0; + subtri_matrix[0][1][9] = -2; + subtri_matrix[0][1][10] = 2; + subtri_matrix[0][1][11] = 0; + subtri_matrix[0][2][0] = 0; + subtri_matrix[0][2][1] = 3; + subtri_matrix[0][2][2] = 0; + subtri_matrix[0][2][3] = 0; + subtri_matrix[0][2][4] = 0; + subtri_matrix[0][2][5] = 1; + subtri_matrix[0][2][6] = 0; + subtri_matrix[0][2][7] = 0; + subtri_matrix[0][2][8] = 0; + subtri_matrix[0][2][9] = 0; + subtri_matrix[0][2][10] = 0; + subtri_matrix[0][2][11] = 0; + subtri_matrix[0][3][0] = 0; + subtri_matrix[0][3][1] = 1; + subtri_matrix[0][3][2] = 0; + subtri_matrix[0][3][3] = 0; + subtri_matrix[0][3][4] = 0; + subtri_matrix[0][3][5] = 0; + subtri_matrix[0][3][6] = 0; + subtri_matrix[0][3][7] = 0; + subtri_matrix[0][3][8] = 0; + subtri_matrix[0][3][9] = 0; + subtri_matrix[0][3][10] = 0; + subtri_matrix[0][3][11] = 0; + subtri_matrix[0][4][0] = 0; + subtri_matrix[0][4][1] = -3.0 / 2.0; + subtri_matrix[0][4][2] = 9.0 / 2.0; + subtri_matrix[0][4][3] = -5.0 / 4.0; + subtri_matrix[0][4][4] = -3.0 / 4.0; + subtri_matrix[0][4][5] = 1.0 / 2.0; + subtri_matrix[0][4][6] = -1.0 / 2.0; + subtri_matrix[0][4][7] = 7.0 / 4.0; + subtri_matrix[0][4][8] = 5.0 / 4.0; + subtri_matrix[0][4][9] = -2; + subtri_matrix[0][4][10] = 0; + subtri_matrix[0][4][11] = 2; + subtri_matrix[0][5][0] = 3; + subtri_matrix[0][5][1] = 3; + subtri_matrix[0][5][2] = 0; + subtri_matrix[0][5][3] = 3.0 / 2.0; + subtri_matrix[0][5][4] = 3.0 / 2.0; + subtri_matrix[0][5][5] = -1; + subtri_matrix[0][5][6] = 0; + subtri_matrix[0][5][7] = 0; + subtri_matrix[0][5][8] = -1; + subtri_matrix[0][5][9] = 4; + subtri_matrix[0][5][10] = 0; + subtri_matrix[0][5][11] = 0; + subtri_matrix[0][6][0] = 0; + subtri_matrix[0][6][1] = 3; + subtri_matrix[0][6][2] = 0; + subtri_matrix[0][6][3] = 0; + subtri_matrix[0][6][4] = 1; + subtri_matrix[0][6][5] = 0; + subtri_matrix[0][6][6] = 0; + subtri_matrix[0][6][7] = 0; + subtri_matrix[0][6][8] = 0; + subtri_matrix[0][6][9] = 0; + subtri_matrix[0][6][10] = 0; + subtri_matrix[0][6][11] = 0; + subtri_matrix[0][7][0] = 3; + subtri_matrix[0][7][1] = 0; + subtri_matrix[0][7][2] = 0; + subtri_matrix[0][7][3] = 0; + subtri_matrix[0][7][4] = 0; + subtri_matrix[0][7][5] = 0; + subtri_matrix[0][7][6] = 0; + subtri_matrix[0][7][7] = 0; + subtri_matrix[0][7][8] = 1; + subtri_matrix[0][7][9] = 0; + subtri_matrix[0][7][10] = 0; + subtri_matrix[0][7][11] = 0; + subtri_matrix[0][8][0] = 3; + subtri_matrix[0][8][1] = 0; + subtri_matrix[0][8][2] = 0; + subtri_matrix[0][8][3] = 1; + subtri_matrix[0][8][4] = 0; + subtri_matrix[0][8][5] = 0; + subtri_matrix[0][8][6] = 0; + subtri_matrix[0][8][7] = 0; + subtri_matrix[0][8][8] = 0; + subtri_matrix[0][8][9] = 0; + subtri_matrix[0][8][10] = 0; + subtri_matrix[0][8][11] = 0; + subtri_matrix[0][9][0] = 1; + subtri_matrix[0][9][1] = 0; + subtri_matrix[0][9][2] = 0; + subtri_matrix[0][9][3] = 0; + subtri_matrix[0][9][4] = 0; + subtri_matrix[0][9][5] = 0; + subtri_matrix[0][9][6] = 0; + subtri_matrix[0][9][7] = 0; + subtri_matrix[0][9][8] = 0; + subtri_matrix[0][9][9] = 0; + subtri_matrix[0][9][10] = 0; + subtri_matrix[0][9][11] = 0; + subtri_matrix[1][0][0] = 0; + subtri_matrix[1][0][1] = 0; + subtri_matrix[1][0][2] = 1; + subtri_matrix[1][0][3] = 0; + subtri_matrix[1][0][4] = 0; + subtri_matrix[1][0][5] = 0; + subtri_matrix[1][0][6] = 0; + subtri_matrix[1][0][7] = 0; + subtri_matrix[1][0][8] = 0; + subtri_matrix[1][0][9] = 0; + subtri_matrix[1][0][10] = 0; + subtri_matrix[1][0][11] = 0; + subtri_matrix[1][1][0] = 0; + subtri_matrix[1][1][1] = 0; + subtri_matrix[1][1][2] = 3; + subtri_matrix[1][1][3] = 0; + subtri_matrix[1][1][4] = 0; + subtri_matrix[1][1][5] = 0; + subtri_matrix[1][1][6] = 1; + subtri_matrix[1][1][7] = 0; + subtri_matrix[1][1][8] = 0; + subtri_matrix[1][1][9] = 0; + subtri_matrix[1][1][10] = 0; + subtri_matrix[1][1][11] = 0; + subtri_matrix[1][2][0] = 0; + subtri_matrix[1][2][1] = 3; + subtri_matrix[1][2][2] = 0; + subtri_matrix[1][2][3] = 0; + subtri_matrix[1][2][4] = 0; + subtri_matrix[1][2][5] = 1; + subtri_matrix[1][2][6] = 0; + subtri_matrix[1][2][7] = 0; + subtri_matrix[1][2][8] = 0; + subtri_matrix[1][2][9] = 0; + subtri_matrix[1][2][10] = 0; + subtri_matrix[1][2][11] = 0; + subtri_matrix[1][3][0] = 0; + subtri_matrix[1][3][1] = 1; + subtri_matrix[1][3][2] = 0; + subtri_matrix[1][3][3] = 0; + subtri_matrix[1][3][4] = 0; + subtri_matrix[1][3][5] = 0; + subtri_matrix[1][3][6] = 0; + subtri_matrix[1][3][7] = 0; + subtri_matrix[1][3][8] = 0; + subtri_matrix[1][3][9] = 0; + subtri_matrix[1][3][10] = 0; + subtri_matrix[1][3][11] = 0; + subtri_matrix[1][4][0] = 0; + subtri_matrix[1][4][1] = 0; + subtri_matrix[1][4][2] = 3; + subtri_matrix[1][4][3] = 0; + subtri_matrix[1][4][4] = 0; + subtri_matrix[1][4][5] = 0; + subtri_matrix[1][4][6] = 0; + subtri_matrix[1][4][7] = 1; + subtri_matrix[1][4][8] = 0; + subtri_matrix[1][4][9] = 0; + subtri_matrix[1][4][10] = 0; + subtri_matrix[1][4][11] = 0; + subtri_matrix[1][5][0] = 0; + subtri_matrix[1][5][1] = 3; + subtri_matrix[1][5][2] = 3; + subtri_matrix[1][5][3] = 0; + subtri_matrix[1][5][4] = -1; + subtri_matrix[1][5][5] = 3.0 / 2.0; + subtri_matrix[1][5][6] = 3.0 / 2.0; + subtri_matrix[1][5][7] = -1; + subtri_matrix[1][5][8] = 0; + subtri_matrix[1][5][9] = 0; + subtri_matrix[1][5][10] = 4; + subtri_matrix[1][5][11] = 0; + subtri_matrix[1][6][0] = 0; + subtri_matrix[1][6][1] = 3; + subtri_matrix[1][6][2] = 0; + subtri_matrix[1][6][3] = 0; + subtri_matrix[1][6][4] = 1; + subtri_matrix[1][6][5] = 0; + subtri_matrix[1][6][6] = 0; + subtri_matrix[1][6][7] = 0; + subtri_matrix[1][6][8] = 0; + subtri_matrix[1][6][9] = 0; + subtri_matrix[1][6][10] = 0; + subtri_matrix[1][6][11] = 0; + subtri_matrix[1][7][0] = 9.0 / 2.0; + subtri_matrix[1][7][1] = -3.0 / 2.0; + subtri_matrix[1][7][2] = 0; + subtri_matrix[1][7][3] = -1.0 / 2.0; + subtri_matrix[1][7][4] = 1.0 / 2.0; + subtri_matrix[1][7][5] = -3.0 / 4.0; + subtri_matrix[1][7][6] = -5.0 / 4.0; + subtri_matrix[1][7][7] = 5.0 / 4.0; + subtri_matrix[1][7][8] = 7.0 / 4.0; + subtri_matrix[1][7][9] = 0; + subtri_matrix[1][7][10] = -2; + subtri_matrix[1][7][11] = 2; + subtri_matrix[1][8][0] = 9.0 / 2.0; + subtri_matrix[1][8][1] = 0; + subtri_matrix[1][8][2] = -3.0 / 2.0; + subtri_matrix[1][8][3] = 7.0 / 4.0; + subtri_matrix[1][8][4] = 5.0 / 4.0; + subtri_matrix[1][8][5] = -5.0 / 4.0; + subtri_matrix[1][8][6] = -3.0 / 4.0; + subtri_matrix[1][8][7] = 1.0 / 2.0; + subtri_matrix[1][8][8] = -1.0 / 2.0; + subtri_matrix[1][8][9] = 2; + subtri_matrix[1][8][10] = -2; + subtri_matrix[1][8][11] = 0; + subtri_matrix[1][9][0] = 0; + subtri_matrix[1][9][1] = 1.0 / 2.0; + subtri_matrix[1][9][2] = 1.0 / 2.0; + subtri_matrix[1][9][3] = -1.0 / 12.0; + subtri_matrix[1][9][4] = -7.0 / 12.0; + subtri_matrix[1][9][5] = 2.0 / 3.0; + subtri_matrix[1][9][6] = 2.0 / 3.0; + subtri_matrix[1][9][7] = -7.0 / 12.0; + subtri_matrix[1][9][8] = -1.0 / 12.0; + subtri_matrix[1][9][9] = -2.0 / 3.0; + subtri_matrix[1][9][10] = 4.0 / 3.0; + subtri_matrix[1][9][11] = -2.0 / 3.0; + subtri_matrix[2][0][0] = 0; + subtri_matrix[2][0][1] = 0; + subtri_matrix[2][0][2] = 1; + subtri_matrix[2][0][3] = 0; + subtri_matrix[2][0][4] = 0; + subtri_matrix[2][0][5] = 0; + subtri_matrix[2][0][6] = 0; + subtri_matrix[2][0][7] = 0; + subtri_matrix[2][0][8] = 0; + subtri_matrix[2][0][9] = 0; + subtri_matrix[2][0][10] = 0; + subtri_matrix[2][0][11] = 0; + subtri_matrix[2][1][0] = 0; + subtri_matrix[2][1][1] = 0; + subtri_matrix[2][1][2] = 3; + subtri_matrix[2][1][3] = 0; + subtri_matrix[2][1][4] = 0; + subtri_matrix[2][1][5] = 0; + subtri_matrix[2][1][6] = 1; + subtri_matrix[2][1][7] = 0; + subtri_matrix[2][1][8] = 0; + subtri_matrix[2][1][9] = 0; + subtri_matrix[2][1][10] = 0; + subtri_matrix[2][1][11] = 0; + subtri_matrix[2][2][0] = -3.0 / 2.0; + subtri_matrix[2][2][1] = 9.0 / 2.0; + subtri_matrix[2][2][2] = 0; + subtri_matrix[2][2][3] = 1.0 / 2.0; + subtri_matrix[2][2][4] = -1.0 / 2.0; + subtri_matrix[2][2][5] = 7.0 / 4.0; + subtri_matrix[2][2][6] = 5.0 / 4.0; + subtri_matrix[2][2][7] = -5.0 / 4.0; + subtri_matrix[2][2][8] = -3.0 / 4.0; + subtri_matrix[2][2][9] = 0; + subtri_matrix[2][2][10] = 2; + subtri_matrix[2][2][11] = -2; + subtri_matrix[2][3][0] = 1.0 / 2.0; + subtri_matrix[2][3][1] = 0; + subtri_matrix[2][3][2] = 1.0 / 2.0; + subtri_matrix[2][3][3] = -7.0 / 12.0; + subtri_matrix[2][3][4] = -1.0 / 12.0; + subtri_matrix[2][3][5] = -1.0 / 12.0; + subtri_matrix[2][3][6] = -7.0 / 12.0; + subtri_matrix[2][3][7] = 2.0 / 3.0; + subtri_matrix[2][3][8] = 2.0 / 3.0; + subtri_matrix[2][3][9] = -2.0 / 3.0; + subtri_matrix[2][3][10] = -2.0 / 3.0; + subtri_matrix[2][3][11] = 4.0 / 3.0; + subtri_matrix[2][4][0] = 0; + subtri_matrix[2][4][1] = 0; + subtri_matrix[2][4][2] = 3; + subtri_matrix[2][4][3] = 0; + subtri_matrix[2][4][4] = 0; + subtri_matrix[2][4][5] = 0; + subtri_matrix[2][4][6] = 0; + subtri_matrix[2][4][7] = 1; + subtri_matrix[2][4][8] = 0; + subtri_matrix[2][4][9] = 0; + subtri_matrix[2][4][10] = 0; + subtri_matrix[2][4][11] = 0; + subtri_matrix[2][5][0] = 3; + subtri_matrix[2][5][1] = 0; + subtri_matrix[2][5][2] = 3; + subtri_matrix[2][5][3] = -1; + subtri_matrix[2][5][4] = 0; + subtri_matrix[2][5][5] = 0; + subtri_matrix[2][5][6] = -1; + subtri_matrix[2][5][7] = 3.0 / 2.0; + subtri_matrix[2][5][8] = 3.0 / 2.0; + subtri_matrix[2][5][9] = 0; + subtri_matrix[2][5][10] = 0; + subtri_matrix[2][5][11] = 4; + subtri_matrix[2][6][0] = 0; + subtri_matrix[2][6][1] = 9.0 / 2.0; + subtri_matrix[2][6][2] = -3.0 / 2.0; + subtri_matrix[2][6][3] = 5.0 / 4.0; + subtri_matrix[2][6][4] = 7.0 / 4.0; + subtri_matrix[2][6][5] = -1.0 / 2.0; + subtri_matrix[2][6][6] = 1.0 / 2.0; + subtri_matrix[2][6][7] = -3.0 / 4.0; + subtri_matrix[2][6][8] = -5.0 / 4.0; + subtri_matrix[2][6][9] = 2; + subtri_matrix[2][6][10] = 0; + subtri_matrix[2][6][11] = -2; + subtri_matrix[2][7][0] = 3; + subtri_matrix[2][7][1] = 0; + subtri_matrix[2][7][2] = 0; + subtri_matrix[2][7][3] = 0; + subtri_matrix[2][7][4] = 0; + subtri_matrix[2][7][5] = 0; + subtri_matrix[2][7][6] = 0; + subtri_matrix[2][7][7] = 0; + subtri_matrix[2][7][8] = 1; + subtri_matrix[2][7][9] = 0; + subtri_matrix[2][7][10] = 0; + subtri_matrix[2][7][11] = 0; + subtri_matrix[2][8][0] = 3; + subtri_matrix[2][8][1] = 0; + subtri_matrix[2][8][2] = 0; + subtri_matrix[2][8][3] = 1; + subtri_matrix[2][8][4] = 0; + subtri_matrix[2][8][5] = 0; + subtri_matrix[2][8][6] = 0; + subtri_matrix[2][8][7] = 0; + subtri_matrix[2][8][8] = 0; + subtri_matrix[2][8][9] = 0; + subtri_matrix[2][8][10] = 0; + subtri_matrix[2][8][11] = 0; + subtri_matrix[2][9][0] = 1; + subtri_matrix[2][9][1] = 0; + subtri_matrix[2][9][2] = 0; + subtri_matrix[2][9][3] = 0; + subtri_matrix[2][9][4] = 0; + subtri_matrix[2][9][5] = 0; + subtri_matrix[2][9][6] = 0; + subtri_matrix[2][9][7] = 0; + subtri_matrix[2][9][8] = 0; + subtri_matrix[2][9][9] = 0; + subtri_matrix[2][9][10] = 0; + subtri_matrix[2][9][11] = 0; +} +} // namespace CT_interpolant diff --git a/src/clough_tocher_patches/clough_tocher_matrices.cpp b/src/clough_tocher_patches/clough_tocher_matrices.cpp new file mode 100644 index 0000000..7b96a83 --- /dev/null +++ b/src/clough_tocher_patches/clough_tocher_matrices.cpp @@ -0,0 +1,36 @@ +#include "clough_tocher_matrices.hpp" +#include "clough_tocher_autogen_matrix_coeffs.hpp" + +std::array, 3> CT_subtri_bound_matrices() { + double bound_coeffs[3][3][3]; + CT_interpolant::CT_tri_bounds_coeffs(bound_coeffs); + + std::array, 3> CT_bound_coeffs; + + for (int i = 0; i < 3; ++i) { + for (int j = 0; j < 3; ++j) { + for (int k = 0; k < 3; ++k) { + CT_bound_coeffs[i](j, k) = bound_coeffs[i][j][k]; + } + } + } + + return CT_bound_coeffs; +} + +std::array, 3> CT_subtri_matrices() { + double CT_coeffs[3][10][12]; + CT_interpolant::CT_sub_tri_matrices(CT_coeffs); + + std::array, 3> CT_matrices; + + for (int i = 0; i < 3; ++i) { + for (int j = 0; j < 10; ++j) { + for (int k = 0; k < 12; ++k) { + CT_matrices[i](j, k) = CT_coeffs[i][j][k]; + } + } + } + + return CT_matrices; +} diff --git a/src/clough_tocher_patches/clough_tocher_matrices.hpp b/src/clough_tocher_patches/clough_tocher_matrices.hpp new file mode 100644 index 0000000..d5e20be --- /dev/null +++ b/src/clough_tocher_patches/clough_tocher_matrices.hpp @@ -0,0 +1,5 @@ +#pragma once +#include "common.h" + +std::array, 3> CT_subtri_bound_matrices(); +std::array, 3> CT_subtri_matrices(); diff --git a/src/clough_tocher_patches/clough_tocher_patch.cpp b/src/clough_tocher_patches/clough_tocher_patch.cpp new file mode 100644 index 0000000..98dfc2f --- /dev/null +++ b/src/clough_tocher_patches/clough_tocher_patch.cpp @@ -0,0 +1,148 @@ +#include "clough_tocher_patch.hpp" +#include "clough_tocher_matrices.hpp" + +#include +#include +#include + +const std::array, 3> + CloughTocherPatch::CTtri_bounds = CT_subtri_bound_matrices(); + +const std::array, 3> + CloughTocherPatch::CT_matrices = CT_subtri_matrices(); + +CloughTocherPatch::CloughTocherPatch( + const Eigen::MatrixXd &V, const AffineManifold &affine_manifold, + const OptimizationParameters &optimization_params, + std::vector> &face_to_patch_indices, + std::vector &patch_to_face_indices, + Eigen::SparseMatrix &fit_matrix, + Eigen::SparseMatrix &energy_hessian, + Eigen::CholmodSupernodalLLT> + &energy_hessian_inverse) + : m_affine_manifold(affine_manifold) { + // Generate normals + MatrixXr N; + generate_face_normals(V, affine_manifold, N); + + // Generate fit matrix by setting the parametrized quadratic surface mapping + // factor to zero + double fit_energy; + VectorXr fit_derivatives; + OptimizationParameters optimization_params_fit = optimization_params; + optimization_params_fit.parametrized_quadratic_surface_mapping_factor = 0.0; + Eigen::CholmodSupernodalLLT> fit_matrix_inverse; + build_twelve_split_spline_energy_system( + V, N, affine_manifold, optimization_params_fit, fit_energy, + fit_derivatives, fit_matrix, fit_matrix_inverse); + + // Build full energy hessian system + double energy; + VectorXr derivatives; + build_twelve_split_spline_energy_system( + V, N, affine_manifold, optimization_params, energy, derivatives, + energy_hessian, energy_hessian_inverse); + + // Build optimized corner and midpoint data + generate_optimized_twelve_split_position_data(V, affine_manifold, fit_matrix, + energy_hessian_inverse, + m_corner_data, m_midpoint_data); + + // compute boundary data + for (int i = 0; i < 3; ++i) { + // p0,p1,p2 + m_boundary_data.row(i) = m_corner_data[i].function_value; + // G01, G10, G12, G21, G20, G02 + m_boundary_data.row(3 + i * 2 + 0) = m_corner_data[i].first_edge_derivative; + m_boundary_data.row(3 + i * 2 + 1) = + m_corner_data[i].second_edge_derivative; + // N01, N12, N20 + m_boundary_data.row(9 + i) = m_midpoint_data[i].normal_derivative; + } + + // compute coeff matrices + for (int i = 0; i < 3; ++i) { + m_CT_coeffs[i] = m_CT_matrices[i] * m_boundary_data; + } +} + +void CloughTocherPatch::generate_face_normals( + const Eigen::MatrixXd &V, const AffineManifold &affine_manifold, + Eigen::MatrixXd &N) { + Eigen::MatrixXi const &F = affine_manifold.get_faces(); + + // Compute the cones of the affine manifold + std::vector cones; + affine_manifold.compute_cones(cones); + + // Get vertex normals + Eigen::MatrixXd N_vertices; + igl::per_vertex_normals(V, F, N_vertices); + + // Set the face one ring normals of the cone vertices to the cone vertex + // normal + N.setZero(F.rows(), 3); + for (size_t i = 0; i < cones.size(); ++i) { + int ci = cones[i]; + VertexManifoldChart const &chart = affine_manifold.get_vertex_chart(ci); + for (size_t j = 0; j < chart.face_one_ring.size(); ++j) { + int fj = chart.face_one_ring[j]; + N.row(fj) = N_vertices.row(ci); + } + } +} + +int CloughTocherPatch::triangle_ind(const double &u, const double &v, + const double &w) { + int idx = -1; + for (int i = 0; i < 3; ++i) { + if (m_CTtri_bounds[i](0, 0) * u + m_CTtri_bounds[i](0, 1) * v + + m_CTtri_bounds[i](0, 2) * w >= + -1e-7 && + m_CTtri_bounds[i](1, 0) * u + m_CTtri_bounds[i](1, 1) * v + + m_CTtri_bounds[i](1, 2) * w >= + -1e-7 && + m_CTtri_bounds[i](2, 0) * u + m_CTtri_bounds[i](2, 1) * v + + m_CTtri_bounds[i](2, 2) * w >= + -1e-7) { + idx = i; + break; + } + } + + assert(idx > -1); + return idx; +} + +Eigen::Matrix +CloughTocherPatch::monomial_basis_eval(const double &u, const double &v, + const double &w) { + Eigen::Matrix monomial_basis_values; + monomial_basis_values(0, 0) = w * w * w; // w3 + monomial_basis_values(1, 0) = v * w * w; // vw2 + monomial_basis_values(2, 0) = v * v * w; // v2w + monomial_basis_values(3, 0) = v * v * v; // v3 + monomial_basis_values(4, 0) = u * w * w; // uw2 + monomial_basis_values(5, 0) = u * v * w; // uvw + monomial_basis_values(6, 0) = u * v * v; // uv2 + monomial_basis_values(7, 0) = u * u * w; // u2w + monomial_basis_values(8, 0) = u * u * v; // u2v + monomial_basis_values(9, 0) = u * u * u; // u3 + + return monomial_basis_values; +} + +Eigen::Matrix +CloughTocherPatch::CT_eval(const double &u, const double &v, const double &w) { + int idx = CloughTocherPatch::triangle_ind(u, v, w); + Eigen::Matrix bb_vector = + CloughTocherPatch::monomial_basis_eval(u, v, w); + + Eigen::Matrix val; + val = bb_vector * m_CT_coeffs[idx]; + return val; +} + +std::array, 3> CloughTocherPatch::get_coeffs() { + return m_CT_coeffs; +} \ No newline at end of file diff --git a/src/clough_tocher_patches/clough_tocher_patch.hpp b/src/clough_tocher_patches/clough_tocher_patch.hpp new file mode 100644 index 0000000..d96200b --- /dev/null +++ b/src/clough_tocher_patches/clough_tocher_patch.hpp @@ -0,0 +1,55 @@ +#pragma once + +#include "common.h" +#include "convex_polygon.h" + +#include "evaluate_surface_normal.h" +#include "optimize_spline_surface.h" + +class CloughTocherPatch { +public: + CloughTocherPatch(const Eigen::MatrixXd &V, + const AffineManifold &affine_manifold, + const OptimizationParameters &optimization_params, + std::vector> &face_to_patch_indices, + std::vector &patch_to_face_indices, + Eigen::SparseMatrix &fit_matrix, + Eigen::SparseMatrix &energy_hessian, + Eigen::CholmodSupernodalLLT> + &energy_hessian_inverse); + + // CloughTocherPatch(const Eigen::MatrixXd surface_mapping_coeffs, + // const ConvexPolygon &domain); + + int triangle_ind(const double &u, const double &v, const double &w); + + Eigen::Matrix + monomial_basis_eval(const double &u, const double &v, const double &w); + + Eigen::Matrix CT_eval(const double &u, const double &v, + const double &w); + + std::array, 3> get_coeffs(); + +private: + void generate_face_normals(const Eigen::MatrixXd &V, + const AffineManifold &affine_manifold, + Eigen::MatrixXd &N); + +private: + const static std::array, 3> + m_CTtri_bounds; // constant ct sub tri boundaries + const static std::array, 3> + m_CT_matrices; // constant ct matrices for 3 sub tris + + std::array, 3> + m_boundary_data; // p0, p1, p2, G01, G10, G12, G21, G20, G02, N01, N12, + // N20, for x, y z + + AffineManifold m_affine_manifold; + std::vector> m_corner_data; + std::vector> m_midpoint_data; + Eigen::Matrix m_boundary_data; + std::array, 3> + m_CT_coeffs; // constant ct matrices for 3 sub tris +} \ No newline at end of file diff --git a/src/clough_tocher_patches/clough_tocher_surface.cpp b/src/clough_tocher_patches/clough_tocher_surface.cpp new file mode 100644 index 0000000..e69de29 diff --git a/src/clough_tocher_patches/clough_tocher_surface.hpp b/src/clough_tocher_patches/clough_tocher_surface.hpp new file mode 100644 index 0000000..e69de29 From 70b3057a0a6e3ac646a47ef70caf32ceed7c42c7 Mon Sep 17 00:00:00 2001 From: JcDai Date: Thu, 12 Dec 2024 10:10:14 -0500 Subject: [PATCH 03/11] add msh correct conn --- .vscode/settings.json | 5 + src/clough_tocher_patches/CMakeLists.txt | 4 +- .../clough_tocher_patch.cpp | 122 ++--- .../clough_tocher_patch.hpp | 54 +- .../clough_tocher_surface.cpp | 403 ++++++++++++++ .../clough_tocher_surface.hpp | 42 ++ src/core/affine_manifold.h | 160 +++--- src/exec/CMakeLists.txt | 11 + src/exec/generate_cubic_surface.cpp | 78 +++ .../optimize_spline_surface.cpp | 516 ++++++++---------- .../optimize_spline_surface.h | 100 ++-- 11 files changed, 939 insertions(+), 556 deletions(-) create mode 100644 .vscode/settings.json create mode 100644 src/exec/generate_cubic_surface.cpp diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..889b02b --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,5 @@ +{ + "files.associations": { + "array": "cpp" + } +} \ No newline at end of file diff --git a/src/clough_tocher_patches/CMakeLists.txt b/src/clough_tocher_patches/CMakeLists.txt index 025c9db..6fae739 100644 --- a/src/clough_tocher_patches/CMakeLists.txt +++ b/src/clough_tocher_patches/CMakeLists.txt @@ -1,12 +1,14 @@ add_library(CloughTocherPatchLib -# clough_tocher_patch.hpp + clough_tocher_patch.hpp clough_tocher_patch.cpp clough_tocher_autogen_matrix_coeffs.hpp clough_tocher_matrices.cpp + clough_tocher_surface.cpp ) target_include_directories(CloughTocherPatchLib PUBLIC .) target_link_libraries(CloughTocherPatchLib PUBLIC QuadraticContoursCoreLib + QuadraticSplineSurfaceLib ) target_compile_definitions(CloughTocherPatchLib PUBLIC SPDLOG_ACTIVE_LEVEL=SPDLOG_LEVEL_DEBUG diff --git a/src/clough_tocher_patches/clough_tocher_patch.cpp b/src/clough_tocher_patches/clough_tocher_patch.cpp index 98dfc2f..f8650cc 100644 --- a/src/clough_tocher_patches/clough_tocher_patch.cpp +++ b/src/clough_tocher_patches/clough_tocher_patch.cpp @@ -6,94 +6,50 @@ #include const std::array, 3> - CloughTocherPatch::CTtri_bounds = CT_subtri_bound_matrices(); + CloughTocherPatch::m_CTtri_bounds = CT_subtri_bound_matrices(); const std::array, 3> - CloughTocherPatch::CT_matrices = CT_subtri_matrices(); + CloughTocherPatch::m_CT_matrices = CT_subtri_matrices(); CloughTocherPatch::CloughTocherPatch( - const Eigen::MatrixXd &V, const AffineManifold &affine_manifold, - const OptimizationParameters &optimization_params, - std::vector> &face_to_patch_indices, - std::vector &patch_to_face_indices, - Eigen::SparseMatrix &fit_matrix, - Eigen::SparseMatrix &energy_hessian, - Eigen::CholmodSupernodalLLT> - &energy_hessian_inverse) - : m_affine_manifold(affine_manifold) { - // Generate normals - MatrixXr N; - generate_face_normals(V, affine_manifold, N); - - // Generate fit matrix by setting the parametrized quadratic surface mapping - // factor to zero - double fit_energy; - VectorXr fit_derivatives; - OptimizationParameters optimization_params_fit = optimization_params; - optimization_params_fit.parametrized_quadratic_surface_mapping_factor = 0.0; - Eigen::CholmodSupernodalLLT> fit_matrix_inverse; - build_twelve_split_spline_energy_system( - V, N, affine_manifold, optimization_params_fit, fit_energy, - fit_derivatives, fit_matrix, fit_matrix_inverse); - - // Build full energy hessian system - double energy; - VectorXr derivatives; - build_twelve_split_spline_energy_system( - V, N, affine_manifold, optimization_params, energy, derivatives, - energy_hessian, energy_hessian_inverse); - - // Build optimized corner and midpoint data - generate_optimized_twelve_split_position_data(V, affine_manifold, fit_matrix, - energy_hessian_inverse, - m_corner_data, m_midpoint_data); + const std::array &corner_data, + const std::array &midpoint_data) + : m_corner_data(corner_data), m_midpoint_data(midpoint_data) { // compute boundary data for (int i = 0; i < 3; ++i) { // p0,p1,p2 m_boundary_data.row(i) = m_corner_data[i].function_value; - // G01, G10, G12, G21, G20, G02 + // G01, G02, G12, G10, G20, G21 m_boundary_data.row(3 + i * 2 + 0) = m_corner_data[i].first_edge_derivative; m_boundary_data.row(3 + i * 2 + 1) = m_corner_data[i].second_edge_derivative; - // N01, N12, N20 - m_boundary_data.row(9 + i) = m_midpoint_data[i].normal_derivative; } + // p0, p1, p2, G10, G01, G02, G20, G21, G12, N01, N20, N12 + m_boundary_data.row(0) = m_corner_data[0].function_value; // p0 + m_boundary_data.row(1) = m_corner_data[1].function_value; // p1 + m_boundary_data.row(2) = m_corner_data[2].function_value; // p2 + + m_boundary_data.row(3) = m_corner_data[0].first_edge_derivative; // G01 + m_boundary_data.row(4) = m_corner_data[1].second_edge_derivative; // G10 + m_boundary_data.row(5) = m_corner_data[1].first_edge_derivative; // G12 + m_boundary_data.row(6) = m_corner_data[2].second_edge_derivative; // G21 + m_boundary_data.row(7) = m_corner_data[2].first_edge_derivative; // G20 + m_boundary_data.row(8) = m_corner_data[0].second_edge_derivative; // G02 + + m_boundary_data.row(9) = m_midpoint_data[2].normal_derivative; // N01 + m_boundary_data.row(10) = m_midpoint_data[0].normal_derivative; // N12 + m_boundary_data.row(11) = m_midpoint_data[1].normal_derivative; // N20 + // compute coeff matrices for (int i = 0; i < 3; ++i) { m_CT_coeffs[i] = m_CT_matrices[i] * m_boundary_data; } } -void CloughTocherPatch::generate_face_normals( - const Eigen::MatrixXd &V, const AffineManifold &affine_manifold, - Eigen::MatrixXd &N) { - Eigen::MatrixXi const &F = affine_manifold.get_faces(); - - // Compute the cones of the affine manifold - std::vector cones; - affine_manifold.compute_cones(cones); - - // Get vertex normals - Eigen::MatrixXd N_vertices; - igl::per_vertex_normals(V, F, N_vertices); - - // Set the face one ring normals of the cone vertices to the cone vertex - // normal - N.setZero(F.rows(), 3); - for (size_t i = 0; i < cones.size(); ++i) { - int ci = cones[i]; - VertexManifoldChart const &chart = affine_manifold.get_vertex_chart(ci); - for (size_t j = 0; j < chart.face_one_ring.size(); ++j) { - int fj = chart.face_one_ring[j]; - N.row(fj) = N_vertices.row(ci); - } - } -} - int CloughTocherPatch::triangle_ind(const double &u, const double &v, - const double &w) { + const double &w) const { int idx = -1; for (int i = 0; i < 3; ++i) { if (m_CTtri_bounds[i](0, 0) * u + m_CTtri_bounds[i](0, 1) * v + @@ -116,33 +72,39 @@ int CloughTocherPatch::triangle_ind(const double &u, const double &v, Eigen::Matrix CloughTocherPatch::monomial_basis_eval(const double &u, const double &v, - const double &w) { + const double &w) const { Eigen::Matrix monomial_basis_values; monomial_basis_values(0, 0) = w * w * w; // w3 - monomial_basis_values(1, 0) = v * w * w; // vw2 - monomial_basis_values(2, 0) = v * v * w; // v2w - monomial_basis_values(3, 0) = v * v * v; // v3 - monomial_basis_values(4, 0) = u * w * w; // uw2 - monomial_basis_values(5, 0) = u * v * w; // uvw - monomial_basis_values(6, 0) = u * v * v; // uv2 - monomial_basis_values(7, 0) = u * u * w; // u2w - monomial_basis_values(8, 0) = u * u * v; // u2v - monomial_basis_values(9, 0) = u * u * u; // u3 + monomial_basis_values(0, 1) = v * w * w; // vw2 + monomial_basis_values(0, 2) = v * v * w; // v2w + monomial_basis_values(0, 3) = v * v * v; // v3 + monomial_basis_values(0, 4) = u * w * w; // uw2 + monomial_basis_values(0, 5) = u * v * w; // uvw + monomial_basis_values(0, 6) = u * v * v; // uv2 + monomial_basis_values(0, 7) = u * u * w; // u2w + monomial_basis_values(0, 8) = u * u * v; // u2v + monomial_basis_values(0, 9) = u * u * u; // u3 return monomial_basis_values; } -Eigen::Matrix -CloughTocherPatch::CT_eval(const double &u, const double &v, const double &w) { +Eigen::Matrix CloughTocherPatch::CT_eval(const double &u, + const double &v, + const double &w) const { int idx = CloughTocherPatch::triangle_ind(u, v, w); + + // std::cout << "subtri_idx: " << idx << std::endl; Eigen::Matrix bb_vector = CloughTocherPatch::monomial_basis_eval(u, v, w); + // std::cout << "monomial: " << bb_vector << std::endl; + Eigen::Matrix val; val = bb_vector * m_CT_coeffs[idx]; return val; } -std::array, 3> CloughTocherPatch::get_coeffs() { +std::array, 3> +CloughTocherPatch::get_coeffs() const { return m_CT_coeffs; } \ No newline at end of file diff --git a/src/clough_tocher_patches/clough_tocher_patch.hpp b/src/clough_tocher_patches/clough_tocher_patch.hpp index d96200b..697e6cd 100644 --- a/src/clough_tocher_patches/clough_tocher_patch.hpp +++ b/src/clough_tocher_patches/clough_tocher_patch.hpp @@ -7,49 +7,37 @@ #include "optimize_spline_surface.h" class CloughTocherPatch { + public: - CloughTocherPatch(const Eigen::MatrixXd &V, - const AffineManifold &affine_manifold, - const OptimizationParameters &optimization_params, - std::vector> &face_to_patch_indices, - std::vector &patch_to_face_indices, - Eigen::SparseMatrix &fit_matrix, - Eigen::SparseMatrix &energy_hessian, - Eigen::CholmodSupernodalLLT> - &energy_hessian_inverse); + static const std::array, 3> + m_CTtri_bounds; // constant ct sub tri boundaries + static const std::array, 3> + m_CT_matrices; // constant ct matrices for 3 sub tris - // CloughTocherPatch(const Eigen::MatrixXd surface_mapping_coeffs, - // const ConvexPolygon &domain); +public: + CloughTocherPatch(); + CloughTocherPatch( + const std::array &corner_data, + const std::array &midpoint_data); - int triangle_ind(const double &u, const double &v, const double &w); + int triangle_ind(const double &u, const double &v, const double &w) const; Eigen::Matrix - monomial_basis_eval(const double &u, const double &v, const double &w); + monomial_basis_eval(const double &u, const double &v, const double &w) const; Eigen::Matrix CT_eval(const double &u, const double &v, - const double &w); + const double &w) const; - std::array, 3> get_coeffs(); + std::array, 3> get_coeffs() const; private: - void generate_face_normals(const Eigen::MatrixXd &V, - const AffineManifold &affine_manifold, - Eigen::MatrixXd &N); - -private: - const static std::array, 3> - m_CTtri_bounds; // constant ct sub tri boundaries - const static std::array, 3> - m_CT_matrices; // constant ct matrices for 3 sub tris - - std::array, 3> - m_boundary_data; // p0, p1, p2, G01, G10, G12, G21, G20, G02, N01, N12, - // N20, for x, y z + // std::array, 3> m_boundary_data; - AffineManifold m_affine_manifold; - std::vector> m_corner_data; - std::vector> m_midpoint_data; - Eigen::Matrix m_boundary_data; + std::array m_corner_data; + std::array m_midpoint_data; + Eigen::Matrix + m_boundary_data; // p0, p1, p2, G01, G10, G12, G21, G20, G02, N01, + // N12,N20, for x, y, z std::array, 3> m_CT_coeffs; // constant ct matrices for 3 sub tris -} \ No newline at end of file +}; \ No newline at end of file diff --git a/src/clough_tocher_patches/clough_tocher_surface.cpp b/src/clough_tocher_patches/clough_tocher_surface.cpp index e69de29..9fe8b9a 100644 --- a/src/clough_tocher_patches/clough_tocher_surface.cpp +++ b/src/clough_tocher_patches/clough_tocher_surface.cpp @@ -0,0 +1,403 @@ +#include "clough_tocher_surface.hpp" + +#include +#include +#include + +CloughTocherSurface::CloughTocherSurface() {} + +CloughTocherSurface::CloughTocherSurface( + const Eigen::MatrixXd &V, const AffineManifold &affine_manifold, + const OptimizationParameters &optimization_params, + Eigen::SparseMatrix &fit_matrix, + Eigen::SparseMatrix &energy_hessian, + Eigen::CholmodSupernodalLLT> + &energy_hessian_inverse) + : m_affine_manifold(affine_manifold) { + + // Generate normals + MatrixXr N; + generate_face_normals(V, affine_manifold, N); + + // Generate fit matrix by setting the parametrized quadratic surface mapping + // factor to zero + double fit_energy; + VectorXr fit_derivatives; + OptimizationParameters optimization_params_fit = optimization_params; + optimization_params_fit.parametrized_quadratic_surface_mapping_factor = 0.0; + Eigen::CholmodSupernodalLLT> fit_matrix_inverse; + build_twelve_split_spline_energy_system( + V, N, affine_manifold, optimization_params_fit, fit_energy, + fit_derivatives, fit_matrix, fit_matrix_inverse); + + // Build full energy hessian system + double energy; + VectorXr derivatives; + build_twelve_split_spline_energy_system( + V, N, affine_manifold, optimization_params, energy, derivatives, + energy_hessian, energy_hessian_inverse); + + // Build optimized corner and midpoint data + generate_optimized_twelve_split_position_data(V, affine_manifold, fit_matrix, + energy_hessian_inverse, + m_corner_data, m_midpoint_data); + + // compute patches + assert(m_corner_data.size() == m_midpoint_data.size()); + for (size_t i = 0; i < m_corner_data.size(); ++i) { + m_patches.push_back( + CloughTocherPatch(m_corner_data[i], m_midpoint_data[i])); + } +} + +Eigen::Matrix +CloughTocherSurface::evaluate_patch(const PatchIndex &patch_index, + const double &u, const double &v, + const double &w) { + return m_patches[patch_index].CT_eval(u, v, w); +} + +void CloughTocherSurface::generate_face_normals( + const Eigen::MatrixXd &V, const AffineManifold &affine_manifold, + Eigen::MatrixXd &N) { + Eigen::MatrixXi const &F = affine_manifold.get_faces(); + + // Compute the cones of the affine manifold + std::vector cones; + affine_manifold.compute_cones(cones); + + std::cout << "#Cone: " << cones.size() << std::endl; + + // Get vertex normals + Eigen::MatrixXd N_vertices; + igl::per_vertex_normals(V, F, N_vertices); + + // Set the face one ring normals of the cone vertices to the cone vertex + // normal + N.setZero(F.rows(), 3); + for (size_t i = 0; i < cones.size(); ++i) { + int ci = cones[i]; + VertexManifoldChart const &chart = affine_manifold.get_vertex_chart(ci); + for (size_t j = 0; j < chart.face_one_ring.size(); ++j) { + int fj = chart.face_one_ring[j]; + N.row(fj) = N_vertices.row(ci); + } + } +} + +void CloughTocherSurface::write_cubic_surface_to_msh_no_conn( + std::string filename) { + std::ofstream file(filename); + + /* + $MeshFormat + 4.1 0 8 MSH4.1, ASCII + $EndMeshFormat + */ + + file << "$MeshFormat\n" + << "4.1 0 8\n" + << "$EndMeshFormat\n"; + + // msh 10 node 3rd-order triangle nodes + const std::array tri_0_bcs = { + {PlanarPoint(0, 0), PlanarPoint(1., 0), PlanarPoint(1. / 3., 1. / 3.), + PlanarPoint(1. / 3., 0), PlanarPoint(2. / 3., 0), + PlanarPoint(7. / 9., 1. / 9.), PlanarPoint(5. / 9., 2. / 9.), + PlanarPoint(2. / 9., 2. / 9.), PlanarPoint(1. / 9., 1. / 9.), + PlanarPoint(4. / 9., 1. / 9.)}}; + + const std::array tri_1_bcs = { + {PlanarPoint(1, 0), PlanarPoint(0, 1), PlanarPoint(1. / 3., 1. / 3.), + PlanarPoint(2. / 3., 1. / 3.), PlanarPoint(1. / 3., 2. / 3.), + PlanarPoint(1. / 9., 7. / 9.), PlanarPoint(2. / 9., 5. / 9.), + PlanarPoint(5. / 9., 2. / 9.), PlanarPoint(7. / 9., 1. / 9.), + PlanarPoint(4. / 9., 4. / 9.)}}; + + const std::array tri_2_bcs = { + {PlanarPoint(0, 1), PlanarPoint(0, 0), PlanarPoint(1. / 3., 1. / 3.), + PlanarPoint(0, 2. / 3.), PlanarPoint(0, 1. / 3.), + PlanarPoint(1. / 9., 1. / 9.), PlanarPoint(2. / 9., 2. / 9.), + PlanarPoint(2. / 9., 5. / 9.), PlanarPoint(1. / 9., 7. / 9.), + PlanarPoint(1. / 9., 4. / 9.)}}; + + file << "$Nodes\n"; + + const size_t node_size = m_patches.size() * 30; + file << "1 " << node_size << " 1 " << node_size << "\n"; + file << "2 1 0 " << node_size << "\n"; + + for (size_t i = 1; i <= node_size; ++i) { + file << i << "\n"; + } + + for (const auto &patch : m_patches) { + for (const auto &bc : tri_0_bcs) { + auto z = patch.CT_eval(bc[0], bc[1], 1 - bc[0] - bc[1]); + file << z(0, 0) << " " << z(0, 1) << " " << z(0, 2) << "\n"; + } + for (const auto &bc : tri_1_bcs) { + auto z = patch.CT_eval(bc[0], bc[1], 1 - bc[0] - bc[1]); + file << z(0, 0) << " " << z(0, 1) << " " << z(0, 2) << "\n"; + } + for (const auto &bc : tri_2_bcs) { + auto z = patch.CT_eval(bc[0], bc[1], 1 - bc[0] - bc[1]); + file << z(0, 0) << " " << z(0, 1) << " " << z(0, 2) << "\n"; + } + } + + file << "$EndNodes\n"; + + // write elements + const size_t element_size = m_patches.size() * 3; + + file << "$Elements\n"; + file << "1 " << element_size << " 1 " << element_size << "\n"; + file << "2 1 21 " << element_size << "\n"; + for (size_t i = 0; i < element_size; ++i) { + file << i + 1 << " " << i * 10 + 1 << " " << i * 10 + 2 << " " << i * 10 + 3 + << " " << i * 10 + 4 << " " << i * 10 + 5 << " " << i * 10 + 6 << " " + << i * 10 + 7 << " " << i * 10 + 8 << " " << i * 10 + 9 << " " + << i * 10 + 10 << "\n"; + } + + file << "$EndElements\n"; +} + +void CloughTocherSurface::write_coeffs_to_obj(std::string filename) { + std::ofstream file(filename); + + for (const auto &patch : m_patches) { + std::array, 3> coeffs = patch.get_coeffs(); + for (int i = 0; i < 1; ++i) { + for (int j = 0; j < 10; ++j) { + file << "v " << coeffs[i](j, 0) << " " << coeffs[i](j, 1) << " " + << coeffs[i](j, 2) << "\n"; + } + } + } + + file << "f 1 1 1\n"; +} + +void CloughTocherSurface::sample_to_obj(std::string filename, int sample_size) { + std::ofstream file(filename); + + for (const auto &patch : m_patches) { + for (int i = 0; i <= sample_size; ++i) { + for (int j = 0; j <= sample_size - i; ++j) { + double u = 1. / sample_size * i; + double v = 1. / sample_size * j; + double w = 1 - u - v; + + // std::cout << "u: " << u << " v: " << v << " w: " << w << std::endl; + // std::cout << "w^3: " << w * w * w << std::endl; + auto z = patch.CT_eval(u, v, w); + + // std::cout << z << std::endl; + + file << "v " << z[0] << " " << z[1] << " " << z[2] << '\n'; + } + } + } + + file << "f 1 1 1\n"; +} + +void CloughTocherSurface::write_cubic_surface_to_msh_with_conn( + std::string filename) { + std::ofstream file(filename); + + /* + $MeshFormat + 4.1 0 8 MSH4.1, ASCII + $EndMeshFormat + */ + + file << "$MeshFormat\n" + << "4.1 0 8\n" + << "$EndMeshFormat\n"; + + /* + subtri0: 0 4 5 1 12 13 3 11 10 16 + subtri1: 1 6 7 2 14 15 3 13 12 17 + subtri2: 2 8 9 0 10 11 3 15 14 18 + */ + + const std::array CT_nodes = {{ + PlanarPoint(0., 0.), PlanarPoint(1., 0.), + PlanarPoint(0., 1.), PlanarPoint(1. / 3., 1. / 3.), + PlanarPoint(1. / 3., 0.), PlanarPoint(2. / 3., 0.), + PlanarPoint(2. / 3., 1. / 3.), PlanarPoint(1. / 3., 2. / 3.), + PlanarPoint(0., 2. / 3.), PlanarPoint(0., 1. / 3.), + PlanarPoint(1. / 9., 1. / 9.), PlanarPoint(2. / 9., 2. / 9.), + PlanarPoint(7. / 9., 1. / 9.), PlanarPoint(5. / 9., 2. / 9.), + PlanarPoint(1. / 9., 7. / 9.), PlanarPoint(2. / 9., 5. / 9.), + PlanarPoint(4. / 9., 1. / 9.), PlanarPoint(4. / 9., 4. / 9.), + PlanarPoint(1. / 9., 4. / 9.), + }}; + + // std::vector vertices; + std::map, std::array> + boundary_edge_to_v_map; + std::vector> faces; + std::map v_to_v_map; + std::vector vertices; + const auto &F = m_affine_manifold.get_faces(); + + Eigen::MatrixXd edges; + igl::edges(F, edges); + std::cout << edges.rows() << std::endl; + + // compute corner vertices first + for (size_t p_idx = 0; p_idx < m_patches.size(); p_idx++) { + const auto &patch = m_patches[p_idx]; + // idk why but this is 2 0 1 not 0 1 2, maybe because of the half edge data + // structure + std::array Fv = {{F(p_idx, 2), F(p_idx, 0), F(p_idx, 1)}}; + for (int i = 0; i < 3; ++i) { + if (v_to_v_map.find(Fv[i]) != v_to_v_map.end()) { + // vertex already computed + continue; + } else { + auto z = patch.CT_eval(CT_nodes[i][0], CT_nodes[i][1], + 1 - CT_nodes[i][0] - CT_nodes[i][1]); + v_to_v_map[Fv[i]] = vertices.size(); + vertices.push_back(z); + } + } + } + + assert(size_t(F.rows()) == m_patches.size()); + + for (size_t p_idx = 0; p_idx < m_patches.size(); p_idx++) { + std::array l_vids = {-1}; + // idk why but this is 2 0 1 not 0 1 2, maybe because of the half edge data + // structure + std::array Fv = {{F(p_idx, 2), F(p_idx, 0), F(p_idx, 1)}}; + const auto &patch = m_patches[p_idx]; + + // node 0 - 2 + for (int i = 0; i < 3; ++i) { + l_vids[i] = v_to_v_map[Fv[i]]; + } + + // node 3 + auto zz = patch.CT_eval(CT_nodes[3][0], CT_nodes[3][1], + 1 - CT_nodes[3][0] - CT_nodes[3][1]); + l_vids[3] = vertices.size(); + vertices.push_back(zz); + + // node 4 5 6 7 8 9 + for (int i = 0; i < 3; ++i) { + if (boundary_edge_to_v_map.find(std::make_pair(Fv[(i + 1) % 3], Fv[i])) != + boundary_edge_to_v_map.end()) { + // this edge is processed in some other patch + const auto &vs = + boundary_edge_to_v_map[std::make_pair(Fv[(i + 1) % 3], Fv[i])]; + l_vids[4 + i * 2 + 0] = vs[1]; + l_vids[4 + i * 2 + 1] = vs[0]; + } else { + // eval new vertices + auto z0 = patch.CT_eval( + CT_nodes[4 + i * 2 + 0][0], CT_nodes[4 + i * 2 + 0][1], + 1 - CT_nodes[4 + i * 2 + 0][0] - CT_nodes[4 + i * 2 + 0][1]); + auto z1 = patch.CT_eval( + CT_nodes[4 + i * 2 + 1][0], CT_nodes[4 + i * 2 + 1][1], + 1 - CT_nodes[4 + i * 2 + 1][0] - CT_nodes[4 + i * 2 + 1][1]); + l_vids[4 + i * 2 + 0] = vertices.size(); + vertices.push_back(z0); + l_vids[4 + i * 2 + 1] = vertices.size(); + vertices.push_back(z1); + + boundary_edge_to_v_map[std::make_pair(Fv[i], Fv[(i + 1) % 3])] = { + {l_vids[4 + i * 2 + 0], l_vids[4 + i * 2 + 0 + 1]}}; + } + } + + // node 10 - 18 + for (int i = 10; i < 19; ++i) { + auto z = patch.CT_eval(CT_nodes[i][0], CT_nodes[i][1], + 1 - CT_nodes[i][0] - CT_nodes[i][1]); + l_vids[i] = vertices.size(); + vertices.push_back(z); + } + + /* + subtri0: 0 1 3 4 5 12 13 11 10 16 + subtri1: 1 2 3 6 7 14 15 13 12 17 + subtri2: 2 0 3 8 9 10 11 15 14 18 + */ + faces.push_back( + {{l_vids[0] + 1, l_vids[1] + 1, l_vids[3] + 1, l_vids[4] + 1, + l_vids[5] + 1, l_vids[12] + 1, l_vids[13] + 1, l_vids[11] + 1, + l_vids[10] + 1, l_vids[16] + 1}}); + faces.push_back( + {{l_vids[1] + 1, l_vids[2] + 1, l_vids[3] + 1, l_vids[6] + 1, + l_vids[7] + 1, l_vids[14] + 1, l_vids[15] + 1, l_vids[13] + 1, + l_vids[12] + 1, l_vids[17] + 1}}); + faces.push_back( + {{l_vids[2] + 1, l_vids[0] + 1, l_vids[3] + 1, l_vids[8] + 1, + l_vids[9] + 1, l_vids[10] + 1, l_vids[11] + 1, l_vids[15] + 1, + l_vids[14] + 1, l_vids[18] + 1}}); + + // // debug code + // for (size_t i = 0; i < l_vids.size(); ++i) { + // std::cout << l_vids[i] << ": " << CT_nodes[i] << std::endl; + // } + // std::cout << std::endl; + // if (p_idx == 2) + // break; + } + + file << "$Nodes\n"; + + const size_t node_size = vertices.size(); + file << "1 " << node_size << " 1 " << node_size << "\n"; + file << "2 1 0 " << node_size << "\n"; + + for (size_t i = 1; i <= node_size; ++i) { + file << i << "\n"; + } + + for (size_t i = 0; i < node_size; ++i) { + file << vertices[i][0] << " " << vertices[i][1] << " " << vertices[i][2] + << "\n"; + } + + file << "$EndNodes\n"; + + // write elements + // assert(m_patches.size() * 3 == faces.size()); + const size_t element_size = faces.size(); + + file << "$Elements\n"; + file << "1 " << element_size << " 1 " << element_size << "\n"; + file << "2 1 21 " << element_size << "\n"; + for (size_t i = 0; i < element_size; ++i) { + file << i + 1 << " "; + for (int j = 0; j < 10; ++j) { + file << faces[i][j] << " "; + } + file << "\n"; + } + + file << "$EndElements\n"; + + // mark cones + const auto &cone_indices = m_affine_manifold.generate_cones(); + + file << "$NodeData\n"; + file << "1\n"; // num string tags + file << "\"Cone\"\n"; // string tag + file << "1\n"; // num real tags + file << "0.0\n"; // time step starts + file << "3\n"; // three integer tags + file << "0\n"; // time step + file << "1\n"; // num field + file << cone_indices.size() << "\n"; // num associated nodal values + for (const auto &idx : cone_indices) { + file << v_to_v_map[idx] + 1 << " 1.0\n"; + } + file << "EndNodeData\n"; +} diff --git a/src/clough_tocher_patches/clough_tocher_surface.hpp b/src/clough_tocher_patches/clough_tocher_surface.hpp index e69de29..229b7a0 100644 --- a/src/clough_tocher_patches/clough_tocher_surface.hpp +++ b/src/clough_tocher_patches/clough_tocher_surface.hpp @@ -0,0 +1,42 @@ +#pragma once + +#include "clough_tocher_patch.hpp" +#include "common.h" +#include "optimize_spline_surface.h" +#include "position_data.h" + +class CloughTocherSurface { +public: + typedef size_t PatchIndex; + + CloughTocherSurface(); + CloughTocherSurface(const Eigen::MatrixXd &V, + const AffineManifold &affine_manifold, + const OptimizationParameters &optimization_params, + Eigen::SparseMatrix &fit_matrix, + Eigen::SparseMatrix &energy_hessian, + Eigen::CholmodSupernodalLLT> + &energy_hessian_inverse); + + Eigen::Matrix evaluate_patch(const PatchIndex &patch_index, + const double &u, const double &v, + const double &w); + + void write_cubic_surface_to_msh_no_conn(std::string filename); + void write_coeffs_to_obj(std::string filename); + void sample_to_obj(std::string filename, int sample_size = 10); + + void write_cubic_surface_to_msh_with_conn(std::string filename); + +private: + void generate_face_normals(const Eigen::MatrixXd &V, + const AffineManifold &affine_manifold, + Eigen::MatrixXd &N); + +private: + std::vector m_patches; + + AffineManifold m_affine_manifold; + std::vector> m_corner_data; + std::vector> m_midpoint_data; +}; \ No newline at end of file diff --git a/src/core/affine_manifold.h b/src/core/affine_manifold.h index 202feb6..04fd49e 100644 --- a/src/core/affine_manifold.h +++ b/src/core/affine_manifold.h @@ -21,17 +21,16 @@ /// nth vertex is the same as the first. For a boundary vertex, the one ring /// begins as the boundary face to the right of the vertex and ends at the left /// boundary face, and the nth vertex is generally different from the 0th. -struct VertexManifoldChart -{ +struct VertexManifoldChart { Halfedge::Index vertex_index; // Index of the vertex in the affine manifold std::vector - vertex_one_ring; // List of manifold vertex indices in the one ring + vertex_one_ring; // List of manifold vertex indices in the one ring std::vector - face_one_ring; // List of manifold face indices in the one ring + face_one_ring; // List of manifold face indices in the one ring MatrixXr - one_ring_uv_positions; // Local uv coordinates of the one ring vertices - bool is_boundary = false; // Mark boundary vertices - bool is_cone = false; // Mark cone vertices + one_ring_uv_positions; // Local uv coordinates of the one ring vertices + bool is_boundary = false; // Mark boundary vertices + bool is_cone = false; // Mark cone vertices bool is_cone_adjacent = false; // Mark vertices adjacent to a cone }; @@ -43,8 +42,7 @@ struct VertexManifoldChart /// edge, there is only one adjacent face. The bottom vertex and face indices /// are set to an out of range value (e.g., -1), and the bottom vertex is set to /// the empty vector. -struct EdgeManifoldChart -{ +struct EdgeManifoldChart { // Face indices Halfedge::Index top_face_index; Halfedge::Index bottom_face_index; @@ -68,8 +66,7 @@ struct EdgeManifoldChart /// Local layout manifold chart in R2 of a triangle. /// /// This is the same as global uv positions when these are provided. -struct FaceManifoldChart -{ +struct FaceManifoldChart { // Face indices Halfedge::Index face_index; @@ -79,13 +76,13 @@ struct FaceManifoldChart // Global information bool is_boundary = false; // True iff the edge is on the boundary bool is_cone_adjacent = false; // Mark faces adjacent to a cone - std::array is_cone_corner = { false, false, false }; // Mark individual corners adjacent to a cone + std::array is_cone_corner = { + false, false, false}; // Mark individual corners adjacent to a cone }; /// Representation for an affine manifold, which is a topological manifold F /// equipped with a discrete metric l that satisfies the triangle inequality. -class AffineManifold -{ +class AffineManifold { public: typedef int Index; @@ -97,9 +94,8 @@ class AffineManifold /// @param[in] F: faces of the cone manifold /// @param[in] global_uv: global layout of the manifold /// @param[in] F_uv: faces of the global layout - AffineManifold(const Eigen::MatrixXi& F, - const MatrixXr& global_uv, - const Eigen::MatrixXi& F_uv); + AffineManifold(const Eigen::MatrixXi &F, const MatrixXr &global_uv, + const Eigen::MatrixXi &F_uv); /// Get the number of faces in the manifold /// @@ -114,26 +110,25 @@ class AffineManifold /// Get faces for the manifold /// /// @return faces of the manifold - Eigen::MatrixXi const& get_faces() const; + Eigen::MatrixXi const &get_faces() const; /// Get halfedge for the manifold /// /// @return halfedge of the manifold - Halfedge const& get_halfedge() const { return m_halfedge; } + Halfedge const &get_halfedge() const { return m_halfedge; } /// Get halfedge to corner map for the manifold /// /// @return halfedge to corner map of the manifold - std::vector> const& get_he_to_corner() - const - { + std::vector> const & + get_he_to_corner() const { return m_he_to_corner; } /// Get faces for the manifold parametrization /// /// @return faces of the manifold layout - Eigen::MatrixXi const& get_F_uv() const; + Eigen::MatrixXi const &get_F_uv() const; /// Get an isometric chart for the vertex with the given index. /// @@ -145,7 +140,7 @@ class AffineManifold /// /// @param[in] vertex_index: index of the vertex for the chart /// @return chart for the given vertex - VertexManifoldChart const& get_vertex_chart(Index vertex_index) const; + VertexManifoldChart const &get_vertex_chart(Index vertex_index) const; /// Get an isometric chart for the edge opposite the corner with the given /// face index and vertex index within the face. @@ -154,14 +149,14 @@ class AffineManifold /// @param[in] face_vertex_index: index of the corner opposite the edge in the /// face /// @return chart for the given edge - EdgeManifoldChart const& get_edge_chart(Index face_index, + EdgeManifoldChart const &get_edge_chart(Index face_index, Index face_vertex_index) const; /// Get an isometric chart for the given face. /// /// @param[in] face_index: index of a face /// @return chart for the given face - FaceManifoldChart const& get_face_chart(Index face_index) const; + FaceManifoldChart const &get_face_chart(Index face_index) const; /// Get the portions of the isometric vertex charts corresponding to the /// corners of a given face. @@ -173,9 +168,9 @@ class AffineManifold /// /// @param[in] face_index: index of the face for the chart segments /// @param[out] corner_uv_positions: chart uv positions as enumerated above - void get_face_corner_charts( - Index face_index, - std::array& corner_uv_positions) const; + void + get_face_corner_charts(Index face_index, + std::array &corner_uv_positions) const; /// Get the portion of the edge charts contained in the interior of the given /// face. @@ -188,16 +183,16 @@ class AffineManifold /// @param[in] face_index: index of the face for the charts /// @param[out] face_edge_uv_positions: uv positions contained in the given /// face - void get_face_edge_charts( - Index face_index, - std::array& face_edge_uv_positions) const; + void + get_face_edge_charts(Index face_index, + std::array &face_edge_uv_positions) const; /// @brief Get the uv coordinates of the face. /// /// @param[in] face_index: index of the face for the chart /// @param[out] face_edge_uv_positions: global uv positions of the face void get_face_global_uv(Index face_index, - std::array& face_uv_positions) const; + std::array &face_uv_positions) const; /// Compute the curvature curvature at the given vertex. /// @@ -224,24 +219,24 @@ class AffineManifold /// Get list of all flat vertices in the manifold /// /// @param[out] flat_vertices: list of flat vertices - void compute_flat_vertices(std::vector& flat_vertices); + void compute_flat_vertices(std::vector &flat_vertices); /// Get list of all cones in the manifold /// /// @param[out] cones: list of cone vertices - void compute_cones(std::vector& cones) const; + void compute_cones(std::vector &cones) const; /// Get boolean mask of all cones corners in the manifold /// /// @param[out] is_cone_corner: true iff corner i, j is a cone - void compute_cones_corners( - std::vector>& is_cone_corner) const; + void + compute_cones_corners(std::vector> &is_cone_corner) const; /// Compute a matrix of cone point positions from mesh vertex positions. /// /// @param[in] V: mesh vertex positions /// @param[out] cone_points: cone positions w.r.t. V - void compute_cone_points(const MatrixXr& V, MatrixXr& cone_points) const; + void compute_cone_points(const MatrixXr &V, MatrixXr &cone_points) const; /// Return list of all cones in the manifold /// @@ -251,7 +246,7 @@ class AffineManifold /// Get list of all boundary vertices in the manifold /// /// @param[out] boundary_vertices: list of boundary vertices - void compute_boundary_vertices(std::vector& boundary_vertices) const; + void compute_boundary_vertices(std::vector &boundary_vertices) const; /// Return list of all boundary vertices in the manifold /// @@ -271,7 +266,7 @@ class AffineManifold /// Get global uv coordinates /// /// @return global uv coordinates, or the empty matrix if they do not exist - MatrixXr const& get_global_uv() const; + MatrixXr const &get_global_uv() const; /// Cut edges adjacent to cones so that a planar layout is possible around /// them. @@ -282,12 +277,13 @@ class AffineManifold /// /// @param[in] V: mesh vertex positions /// @param[in] color: color for the affine manifold in the viewer - void add_to_viewer(const MatrixXr& V, Eigen::Matrix color = GOLD_YELLOW) const; + void add_to_viewer(const MatrixXr &V, + Eigen::Matrix color = GOLD_YELLOW) const; /// View the cone manifold and its data /// /// @param[in] V: mesh vertex positions - void view(const MatrixXr& V) const; + void view(const MatrixXr &V) const; /// Save an image of the cone manifold and its data to file. /// @@ -296,53 +292,47 @@ class AffineManifold /// @param[in] camera_position: camera position for the screenshot /// @param[in] camera_target: camera target for the screenshot /// @param[in] use_orthographic: use orthographic perspective if true - void - screenshot(const std::string& filename, - const MatrixXr& V, - SpatialVector camera_position, - SpatialVector camera_target, - bool use_orthographic) const; + void screenshot(const std::string &filename, const MatrixXr &V, + SpatialVector camera_position, SpatialVector camera_target, + bool use_orthographic) const; // Clear all internal data for a trivial cone manifold void clear(); protected: void build_vertex_charts_from_lengths( - const Eigen::MatrixXi& F, - const std::vector>& l, - std::vector& vertex_charts) const; + const Eigen::MatrixXi &F, const std::vector> &l, + std::vector &vertex_charts) const; void build_edge_charts_from_lengths( - const Eigen::MatrixXi& F, - const Halfedge& halfedge, - const std::vector>& l, - std::vector& edge_charts) const; + const Eigen::MatrixXi &F, const Halfedge &halfedge, + const std::vector> &l, + std::vector &edge_charts) const; - void build_face_charts(const Eigen::MatrixXi& F, - const MatrixXr& global_uv, - const Eigen::MatrixXi& F_uv, - std::vector& face_charts) const; + void build_face_charts(const Eigen::MatrixXi &F, const MatrixXr &global_uv, + const Eigen::MatrixXi &F_uv, + std::vector &face_charts) const; void build_corner_to_edge_map( - const std::vector>& corner_to_he, - const std::vector& he_to_edge, - std::vector>& corner_to_edge) const; + const std::vector> &corner_to_he, + const std::vector &he_to_edge, + std::vector> &corner_to_edge) const; - PlanarPoint layout_next_vertex(const PlanarPoint& current_point, + PlanarPoint layout_next_vertex(const PlanarPoint ¤t_point, double next_edge_length, double prev_edge_length) const; - void layout_one_ring(const Eigen::MatrixXi& F, - const std::vector>& l, + void layout_one_ring(const Eigen::MatrixXi &F, + const std::vector> &l, Index vertex_index, - const std::vector& vertex_one_ring, - const std::vector& face_one_ring, - MatrixXr& one_ring_uv_positions) const; + const std::vector &vertex_one_ring, + const std::vector &face_one_ring, + MatrixXr &one_ring_uv_positions) const; - void build_lengths_from_global_uv(const Eigen::MatrixXi& F, - const MatrixXr& global_uv, - std::vector>& l) const; + void build_lengths_from_global_uv(const Eigen::MatrixXi &F, + const MatrixXr &global_uv, + std::vector> &l) const; - void align_local_charts(const MatrixXr& uv, const Eigen::MatrixXi& F_uv); + void align_local_charts(const MatrixXr &uv, const Eigen::MatrixXi &F_uv); void mark_cones(); @@ -351,9 +341,11 @@ class AffineManifold bool is_valid_affine_manifold() const; +protected: // Topology information - // TODO: The faces are duplicated in the halfedge. Our halfedge alway retains - // the original VF topology, so there is no need to maintain both separately + // TODO: The faces are duplicated in the halfedge. Our halfedge alway + // retains the original VF topology, so there is no need to maintain both + // separately Eigen::MatrixXi m_F; std::vector> m_corner_to_he; std::vector> m_corner_to_edge; @@ -373,8 +365,7 @@ class AffineManifold /// Representation for an affine manifold with a global parametrization, which /// yields a flat metric and thus an affine manifold structure. -class ParametricAffineManifold : public AffineManifold -{ +class ParametricAffineManifold : public AffineManifold { public: ParametricAffineManifold(); @@ -383,13 +374,13 @@ class ParametricAffineManifold : public AffineManifold /// /// @param[in] F: faces of the affine manifold /// @param[in] global_uv: affine global layout of the manifold - ParametricAffineManifold(const Eigen::MatrixXi& F, const MatrixXr& global_uv); + ParametricAffineManifold(const Eigen::MatrixXi &F, const MatrixXr &global_uv); /// Get global uv coordinates for a given vertex. /// /// @param[in] vertex_index: index of the vertex for the uv position /// @param[out] uv_coords: global uv position for the given vertex - void get_vertex_global_uv(Index vertex_index, PlanarPoint& uv_coords) const; + void get_vertex_global_uv(Index vertex_index, PlanarPoint &uv_coords) const; private: bool is_valid_parametric_affine_manifold() const; @@ -397,10 +388,9 @@ class ParametricAffineManifold : public AffineManifold /// Generate an affine manifold with the cone faces removed but cone adjaceny /// information retained -void -remove_cones(const Eigen::MatrixXd& V, - const AffineManifold& affine_manifold, - Eigen::MatrixXd& pruned_V, - AffineManifold& pruned_affine_manifold, - std::vector& cones, - std::vector& removed_faces); \ No newline at end of file +void remove_cones(const Eigen::MatrixXd &V, + const AffineManifold &affine_manifold, + Eigen::MatrixXd &pruned_V, + AffineManifold &pruned_affine_manifold, + std::vector &cones, + std::vector &removed_faces); \ No newline at end of file diff --git a/src/exec/CMakeLists.txt b/src/exec/CMakeLists.txt index 9967452..15956d3 100755 --- a/src/exec/CMakeLists.txt +++ b/src/exec/CMakeLists.txt @@ -15,3 +15,14 @@ target_link_libraries(view_quadratic_spline PRIVATE target_compile_options(view_quadratic_spline PRIVATE -Wall -Wpedantic -Wextra -Werror ) + + +add_executable(generate_cubic_surface generate_cubic_surface.cpp) +target_link_libraries(generate_cubic_surface PRIVATE + QuadraticContoursLib + CloughTocherPatchLib + CLI11::CLI11 +) +target_compile_options(generate_cubic_surface PRIVATE + -Wall -Wpedantic -Wextra -Werror +) diff --git a/src/exec/generate_cubic_surface.cpp b/src/exec/generate_cubic_surface.cpp new file mode 100644 index 0000000..b9674c4 --- /dev/null +++ b/src/exec/generate_cubic_surface.cpp @@ -0,0 +1,78 @@ +#include "apply_transformation.h" +#include "common.h" +#include "compute_boundaries.h" +#include "contour_network.h" +#include "generate_transformation.h" +#include "globals.cpp" +#include "twelve_split_spline.h" +#include +#include +#include + +#include "clough_tocher_surface.hpp" + +int main(int argc, char *argv[]) { + // Build maps from strings to enums + std::map log_level_map{ + {"trace", spdlog::level::trace}, {"debug", spdlog::level::debug}, + {"info", spdlog::level::info}, {"warn", spdlog::level::warn}, + {"critical", spdlog::level::critical}, {"off", spdlog::level::off}, + }; + + // Get command line arguments + CLI::App app{"Generate Clough-Tocher cubic surface mesh."}; + std::string input_filename = ""; + std::string output_dir = "./"; + spdlog::level::level_enum log_level = spdlog::level::off; + Eigen::Matrix color = SKY_BLUE; + int num_subdivisions = DISCRETIZATION_LEVEL; + OptimizationParameters optimization_params; + double weight = optimization_params.position_difference_factor; + app.add_option("-i,--input", input_filename, "Mesh filepath") + ->check(CLI::ExistingFile) + ->required(); + app.add_option("--log_level", log_level, "Level of logging") + ->transform(CLI::CheckedTransformer(log_level_map, CLI::ignore_case)); + app.add_option("--num_subdivisions", num_subdivisions, + "Number of subdivisions") + ->check(CLI::PositiveNumber); + app.add_option("-w,--weight", weight, + "Fitting weight for the quadratic surface approximation") + ->check(CLI::PositiveNumber); + CLI11_PARSE(app, argc, argv); + + // Set logger level + spdlog::set_level(log_level); + + // Set optimization parameters + optimization_params.position_difference_factor = weight; + + // Get input mesh + Eigen::MatrixXd V, uv, N; + Eigen::MatrixXi F, FT, FN; + igl::readOBJ(input_filename, V, uv, N, F, FT, FN); + + // Generate quadratic spline + spdlog::info("Computing spline surface"); + // std::vector> face_to_patch_indices; + // std::vector patch_to_face_indices; + Eigen::SparseMatrix fit_matrix; + Eigen::SparseMatrix energy_hessian; + Eigen::CholmodSupernodalLLT> + energy_hessian_inverse; + AffineManifold affine_manifold(F, uv, FT); + + CloughTocherSurface ct_surface(V, affine_manifold, optimization_params, + fit_matrix, energy_hessian, + energy_hessian_inverse); + + ct_surface.write_coeffs_to_obj("test_cubic_points.obj"); + + ct_surface.sample_to_obj("test_sample_cubic_points.obj", 25); + + ct_surface.write_cubic_surface_to_msh_no_conn("test_cubic_sphere.msh"); + ct_surface.write_cubic_surface_to_msh_with_conn( + "test_cubic_sphere_with_conn.msh"); + + return 0; +} diff --git a/src/quadratic_spline_surface/optimize_spline_surface.cpp b/src/quadratic_spline_surface/optimize_spline_surface.cpp index 1188fce..d650e28 100644 --- a/src/quadratic_spline_surface/optimize_spline_surface.cpp +++ b/src/quadratic_spline_surface/optimize_spline_surface.cpp @@ -3,25 +3,25 @@ #include "optimize_spline_surface.h" -#include "powell_sabin_local_to_global_indexing.h" #include "compute_local_twelve_split_hessian.h" #include "planarH.h" +#include "powell_sabin_local_to_global_indexing.h" // Build the hessian for the local fitting energy // // This is a diagonal matrix with special weights for cones and cone adjacent // vertices Eigen::Matrix -build_local_fit_hessian(const std::array& is_cone, - const std::array& is_cone_adjacent, - const OptimizationParameters& optimization_params) -{ +build_local_fit_hessian(const std::array &is_cone, + const std::array &is_cone_adjacent, + const OptimizationParameters &optimization_params) { Eigen::Matrix H_f; H_f.fill(0); // Check for cone collapsing vertices for (size_t i = 0; i < 3; ++i) { - size_t vi = generate_local_vertex_position_variable_index(i, 0, 1); // local vertex index + size_t vi = generate_local_vertex_position_variable_index( + i, 0, 1); // local vertex index // Weights for cone vertices if (is_cone[i]) { @@ -32,33 +32,37 @@ build_local_fit_hessian(const std::array& is_cone, // Add cone gradient fitting term spdlog::info("Weighting cone gradients by {}", - optimization_params.cone_vertex_gradient_difference_factor); - size_t g1i = generate_local_vertex_gradient_variable_index(i, 0, 0, 1); // local first gradient index - size_t g2i = generate_local_vertex_gradient_variable_index(i, 1, 0, 1); // local second gradient index + optimization_params.cone_vertex_gradient_difference_factor); + size_t g1i = generate_local_vertex_gradient_variable_index( + i, 0, 0, 1); // local first gradient index + size_t g2i = generate_local_vertex_gradient_variable_index( + i, 1, 0, 1); // local second gradient index H_f(g1i, g1i) = - optimization_params.cone_vertex_gradient_difference_factor; + optimization_params.cone_vertex_gradient_difference_factor; H_f(g2i, g2i) = - optimization_params.cone_vertex_gradient_difference_factor; + optimization_params.cone_vertex_gradient_difference_factor; } // Weights for cone adjacent vertices (which can be collapsed to the cone) else if (is_cone_adjacent[i]) { // Add increased weight to the cone adjacent position fit spdlog::trace( - "Weighting cone adjacent vertices by {}", - optimization_params.cone_adjacent_position_difference_factor); + "Weighting cone adjacent vertices by {}", + optimization_params.cone_adjacent_position_difference_factor); H_f(vi, vi) = - optimization_params.cone_adjacent_position_difference_factor; + optimization_params.cone_adjacent_position_difference_factor; // Add cone adjacent vertex gradient fitting term spdlog::trace( - "Weighting cone adjacent gradients by {}", - optimization_params.cone_adjacent_vertex_gradient_difference_factor); - size_t g1i = generate_local_vertex_gradient_variable_index(i, 0, 0, 1); // local first gradient index - size_t g2i = generate_local_vertex_gradient_variable_index(i, 1, 0, 1); // local second gradient index + "Weighting cone adjacent gradients by {}", + optimization_params.cone_adjacent_vertex_gradient_difference_factor); + size_t g1i = generate_local_vertex_gradient_variable_index( + i, 0, 0, 1); // local first gradient index + size_t g2i = generate_local_vertex_gradient_variable_index( + i, 1, 0, 1); // local second gradient index H_f(g1i, g1i) = - optimization_params.cone_adjacent_vertex_gradient_difference_factor; + optimization_params.cone_adjacent_vertex_gradient_difference_factor; H_f(g2i, g2i) = - optimization_params.cone_adjacent_vertex_gradient_difference_factor; + optimization_params.cone_adjacent_vertex_gradient_difference_factor; } // Default fitting weight is 1.0 else { @@ -68,16 +72,17 @@ build_local_fit_hessian(const std::array& is_cone, // Check for edges collapsing to a cone and add weight for (size_t i = 0; i < 3; ++i) { - size_t vj = (i + 1) % 3; // next local vertex index - size_t vk = (i + 2) % 3; // prev local vertex index + size_t vj = (i + 1) % 3; // next local vertex index + size_t vk = (i + 2) % 3; // prev local vertex index if ((is_cone_adjacent[vj]) && (is_cone_adjacent[vk])) { // Add cone adjacent adjacent edge gradient fit spdlog::trace( - "Weighting cone edge gradients by {}", - optimization_params.cone_adjacent_edge_gradient_difference_factor); - size_t gjk = generate_local_edge_gradient_variable_index(i, 0, 1); // local first gradient index + "Weighting cone edge gradients by {}", + optimization_params.cone_adjacent_edge_gradient_difference_factor); + size_t gjk = generate_local_edge_gradient_variable_index( + i, 0, 1); // local first gradient index H_f(gjk, gjk) = - optimization_params.cone_adjacent_edge_gradient_difference_factor; + optimization_params.cone_adjacent_edge_gradient_difference_factor; } } @@ -90,13 +95,11 @@ build_local_fit_hessian(const std::array& is_cone, // WARNING: Unlike the other hessians, which are 12x12 matrices assembled per // x,y,z coordinate and combined into a 36x3 block matrix, this Hessian has // mixed coordinate terms and is thus directly 36x36 -Eigen::Matrix -build_planar_constraint_hessian( - const Eigen::Matrix& uv, - const std::array& corner_to_corner_uv_positions, - const std::array& reverse_edge_orientations, - const SpatialVector& normal) -{ +Eigen::Matrix build_planar_constraint_hessian( + const Eigen::Matrix &uv, + const std::array &corner_to_corner_uv_positions, + const std::array &reverse_edge_orientations, + const SpatialVector &normal) { // Build planar hessian array for derived derivative quantities double planarH_array[36][36]; planarHfun(normal[0], normal[1], normal[2], planarH_array); @@ -111,7 +114,7 @@ build_planar_constraint_hessian( // Build C_gl matrix Eigen::Matrix C_gl = - get_C_gl(uv, corner_to_corner_uv_positions, reverse_edge_orientations); + get_C_gl(uv, corner_to_corner_uv_positions, reverse_edge_orientations); // Make block diagonal C_gl matrix Eigen::Matrix C_gl_diag; @@ -123,7 +126,7 @@ build_planar_constraint_hessian( // Build the planar constraint Hessian with indexing so that DoF per // coordinate are contiguous Eigen::Matrix H_p_permuted = - 0.5 * C_gl_diag.transpose() * planarH * C_gl_diag; + 0.5 * C_gl_diag.transpose() * planarH * C_gl_diag; // Reindex so that coordinates per DoF are contiguous Eigen::Matrix H_p; @@ -133,7 +136,7 @@ build_planar_constraint_hessian( for (size_t ci = 0; ci < 12; ++ci) { for (size_t cj = 0; cj < 3; ++cj) { H_p(3 * ri + rj, 3 * ci + cj) = - H_p_permuted(12 * rj + ri, 12 * cj + ci); + H_p_permuted(12 * rj + ri, 12 * cj + ci); } } } @@ -147,30 +150,28 @@ struct LocalHessianData { Eigen::Matrix H_f; // fitting term hessian Eigen::Matrix H_s; // smoothness term hessian Eigen::Matrix H_p; // planarity term hessian - double w_f; // fitting term weight - double w_s; // smoothness term weight - double w_p; // planarity term weight + double w_f; // fitting term weight + double w_s; // smoothness term weight + double w_p; // planarity term weight }; // Structure for the energy quadratic local degree of freedom data struct LocalDOFData { - Eigen::Matrix r_alpha_0; // initial local DOF - Eigen::Matrix r_alpha; // local DOF + Eigen::Matrix r_alpha_0; // initial local DOF + Eigen::Matrix r_alpha; // local DOF Eigen::Matrix r_alpha_flat; // flattened local DOF }; // Assemble the energy quadratic Hessian data -void -generate_local_hessian_data( - const std::array& face_vertex_uv_positions, - const std::array& corner_to_corner_uv_positions, - const std::array& reverse_edge_orientations, - const std::array& is_cone, - const std::array& is_cone_adjacent, - const SpatialVector& face_normal, - const OptimizationParameters& optimization_params, - LocalHessianData& local_hessian_data -) { +void generate_local_hessian_data( + const std::array &face_vertex_uv_positions, + const std::array &corner_to_corner_uv_positions, + const std::array &reverse_edge_orientations, + const std::array &is_cone, + const std::array &is_cone_adjacent, + const SpatialVector &face_normal, + const OptimizationParameters &optimization_params, + LocalHessianData &local_hessian_data) { // Build uv from global positions Eigen::Matrix uv; uv.row(0) = face_vertex_uv_positions[0]; @@ -179,28 +180,25 @@ generate_local_hessian_data( // H_s: local smoothness hessian local_hessian_data.H_s = build_local_smoothness_hessian( - uv, - corner_to_corner_uv_positions, - reverse_edge_orientations); + uv, corner_to_corner_uv_positions, reverse_edge_orientations); // H_f: position fit hessian local_hessian_data.H_f = - build_local_fit_hessian(is_cone, is_cone_adjacent, optimization_params); + build_local_fit_hessian(is_cone, is_cone_adjacent, optimization_params); // H_p: planar fitting term // DEPRECATED if (optimization_params.cone_normal_orthogonality_factor != 0.0) { - local_hessian_data.H_p = build_planar_constraint_hessian(uv, - corner_to_corner_uv_positions, - reverse_edge_orientations, - face_normal); + local_hessian_data.H_p = + build_planar_constraint_hessian(uv, corner_to_corner_uv_positions, + reverse_edge_orientations, face_normal); } else { local_hessian_data.H_p.setZero(); } // w_s: smoothing weight local_hessian_data.w_s = - optimization_params.parametrized_quadratic_surface_mapping_factor; + optimization_params.parametrized_quadratic_surface_mapping_factor; // w_f: fitting weight local_hessian_data.w_f = optimization_params.position_difference_factor; @@ -210,14 +208,12 @@ generate_local_hessian_data( } // Assemble the local degree of freedom data -void -generate_local_dof_data( - const std::array& initial_vertex_positions_T, - const std::array& vertex_positions_T, - const std::array& vertex_gradients_T, - const std::array& edge_gradients_T, - LocalDOFData& local_dof_data -) { +void generate_local_dof_data( + const std::array &initial_vertex_positions_T, + const std::array &vertex_positions_T, + const std::array &vertex_gradients_T, + const std::array &edge_gradients_T, + LocalDOFData &local_dof_data) { // r_alpha_0: fitting values // WARNING: Only fitting to zero implemented for gradients // TODO: Implement fitting for creases @@ -252,32 +248,30 @@ generate_local_dof_data( // Compute the local twelve split energy quadratic from Hessian and local // degree of freedom data -void -compute_local_twelve_split_energy_quadratic( - const LocalHessianData& local_hessian_data, - const LocalDOFData& local_dof_data, - double& local_energy, - TwelveSplitGradient& local_derivatives, - TwelveSplitHessian& local_hessian) -{ +void compute_local_twelve_split_energy_quadratic( + const LocalHessianData &local_hessian_data, + const LocalDOFData &local_dof_data, double &local_energy, + TwelveSplitGradient &local_derivatives, TwelveSplitHessian &local_hessian) { // Extract local hessian data - const Eigen::Matrix& H_f = local_hessian_data.H_f; - const Eigen::Matrix& H_s = local_hessian_data.H_s; - const Eigen::Matrix& H_p = local_hessian_data.H_p; + const Eigen::Matrix &H_f = local_hessian_data.H_f; + const Eigen::Matrix &H_s = local_hessian_data.H_s; + const Eigen::Matrix &H_p = local_hessian_data.H_p; double w_f = local_hessian_data.w_f; double w_s = local_hessian_data.w_s; double w_p = local_hessian_data.w_p; // Extract local degrees of freedom data - const Eigen::Matrix& r_alpha_0 = local_dof_data.r_alpha_0; - const Eigen::Matrix& r_alpha = local_dof_data.r_alpha; - const Eigen::Matrix& r_alpha_flat = local_dof_data.r_alpha_flat; + const Eigen::Matrix &r_alpha_0 = local_dof_data.r_alpha_0; + const Eigen::Matrix &r_alpha = local_dof_data.r_alpha; + const Eigen::Matrix &r_alpha_flat = + local_dof_data.r_alpha_flat; // full local 12x12 hessian (only smoothness and fitting terms) Eigen::Matrix local_hessian_12x12 = - 2 * (w_s * H_s + w_f * H_f); + 2 * (w_s * H_s + w_f * H_f); - // Add smoothness and fitting term blocks to the full local hessian per coordinate + // Add smoothness and fitting term blocks to the full local hessian per + // coordinate local_hessian.fill(0); for (int i = 0; i < 12; i++) { for (int j = 0; j < 12; j++) { @@ -311,7 +305,7 @@ compute_local_twelve_split_energy_quadratic( double smoothness_term = 0.0; for (int i = 0; i < 3; i++) { smoothness_term += - (r_alpha.col(i).transpose() * (w_s * H_s) * r_alpha.col(i))(0, 0); + (r_alpha.col(i).transpose() * (w_s * H_s) * r_alpha.col(i))(0, 0); } spdlog::trace("Smoothness term is {}", smoothness_term); @@ -319,7 +313,7 @@ compute_local_twelve_split_energy_quadratic( double fit_term = 0.0; for (int i = 0; i < 3; i++) { Eigen::Matrix r_alpha_diff = - r_alpha.col(i) - r_alpha_0.col(i); + r_alpha.col(i) - r_alpha_0.col(i); fit_term += (r_alpha_diff.transpose() * (w_f * H_f) * r_alpha_diff)(0, 0); } spdlog::trace("Fit term is {}", fit_term); @@ -335,10 +329,7 @@ compute_local_twelve_split_energy_quadratic( } // Helper function to cyclically shift an array of three elements -template -void -shift_array(std::array& arr, int shift) -{ +template void shift_array(std::array &arr, int shift) { std::array arr_copy = arr; for (int i = 0; i < 3; ++i) { arr[i] = arr_copy[(i + shift) % 3]; @@ -347,21 +338,17 @@ shift_array(std::array& arr, int shift) // Method to cyclically shift the indexing of all energy quadratic data arrays // for triangle vertex values -void -shift_local_energy_quadratic_vertices( - std::array& vertex_positions_T, - std::array& vertex_gradients_T, - std::array& edge_gradients_T, - std::array& initial_vertex_positions_T, - std::array& face_vertex_uv_positions, - std::array& corner_to_corner_uv_positions, - std::array& reverse_edge_orientations, - std::array& is_cone, - std::array& is_cone_adjacent, - std::array& face_global_vertex_indices, - std::array& face_global_edge_indices, - int shift) -{ +void shift_local_energy_quadratic_vertices( + std::array &vertex_positions_T, + std::array &vertex_gradients_T, + std::array &edge_gradients_T, + std::array &initial_vertex_positions_T, + std::array &face_vertex_uv_positions, + std::array &corner_to_corner_uv_positions, + std::array &reverse_edge_orientations, + std::array &is_cone, std::array &is_cone_adjacent, + std::array &face_global_vertex_indices, + std::array &face_global_edge_indices, int shift) { shift_array(vertex_positions_T, shift); shift_array(vertex_gradients_T, shift); shift_array(edge_gradients_T, shift); @@ -376,25 +363,19 @@ shift_local_energy_quadratic_vertices( } // Compute the energy system for a twelve-split spline -void -compute_twelve_split_energy_quadratic( - const std::vector& vertex_positions, - const std::vector& vertex_gradients, - const std::vector>& edge_gradients, - const std::vector& global_vertex_indices, - const std::vector>& global_edge_indices, - const std::vector& initial_vertex_positions, - const Eigen::MatrixXd& initial_face_normals, - const AffineManifold& manifold, - const OptimizationParameters& optimization_params, - double& energy, - VectorXr& derivatives, - Eigen::SparseMatrix& hessian, - int num_variable_vertices, - int num_variable_edges) -{ +void compute_twelve_split_energy_quadratic( + const std::vector &vertex_positions, + const std::vector &vertex_gradients, + const std::vector> &edge_gradients, + const std::vector &global_vertex_indices, + const std::vector> &global_edge_indices, + const std::vector &initial_vertex_positions, + const Eigen::MatrixXd &initial_face_normals, const AffineManifold &manifold, + const OptimizationParameters &optimization_params, double &energy, + VectorXr &derivatives, Eigen::SparseMatrix &hessian, + int num_variable_vertices, int num_variable_edges) { int num_independent_variables = - 9 * num_variable_vertices + 3 * num_variable_edges; + 9 * num_variable_vertices + 3 * num_variable_edges; energy = 0; derivatives.setZero(num_independent_variables); std::vector> hessian_entries; @@ -403,42 +384,42 @@ compute_twelve_split_energy_quadratic( for (AffineManifold::Index face_index = 0; face_index < manifold.num_faces(); ++face_index) { // Get face vertices - Eigen::MatrixXi const& F = manifold.get_faces(); + Eigen::MatrixXi const &F = manifold.get_faces(); int i = F(face_index, 0); int j = F(face_index, 1); int k = F(face_index, 2); // Bundle relevant global variables into per face local vectors std::array initial_vertex_positions_T, vertex_positions_T, - edge_gradients_T; + edge_gradients_T; std::array vertex_gradients_T; build_face_variable_vector(vertex_positions, i, j, k, vertex_positions_T); build_face_variable_vector(vertex_gradients, i, j, k, vertex_gradients_T); edge_gradients_T = edge_gradients[face_index]; - build_face_variable_vector( - initial_vertex_positions, i, j, k, initial_vertex_positions_T); + build_face_variable_vector(initial_vertex_positions, i, j, k, + initial_vertex_positions_T); // Get the global uv values for the face vertices std::array face_vertex_uv_positions; manifold.get_face_global_uv(face_index, face_vertex_uv_positions); // Get corner uv positions for the given face corners. - // NOTE: These may differ from the edge difference vectors computed from the global - // uv by a rotation per vertex due to the local layouts performed at each vertex. - // Since vertex gradients are defined in terms of these local vertex charts, we must - // use these directions when computing edge direction gradients from the vertex uv - // gradients. + // NOTE: These may differ from the edge difference vectors computed from the + // global uv by a rotation per vertex due to the local layouts performed at + // each vertex. Since vertex gradients are defined in terms of these local + // vertex charts, we must use these directions when computing edge direction + // gradients from the vertex uv gradients. std::array corner_to_corner_uv_positions; manifold.get_face_corner_charts(face_index, corner_to_corner_uv_positions); // Get edge orientations - // NOTE: The edge frame is oriented so that one basis vector points along the edge - // counterclockwise and the other points perpendicular into the interior of the - // triangle. If the given face is the bottom face in the edge chart, the sign of - // the midpoint gradient needs to be reversed. + // NOTE: The edge frame is oriented so that one basis vector points along + // the edge counterclockwise and the other points perpendicular into the + // interior of the triangle. If the given face is the bottom face in the + // edge chart, the sign of the midpoint gradient needs to be reversed. std::array reverse_edge_orientations; for (int i = 0; i < 3; ++i) { - EdgeManifoldChart const& chart = manifold.get_edge_chart(face_index, i); + EdgeManifoldChart const &chart = manifold.get_edge_chart(face_index, i); reverse_edge_orientations[i] = (chart.top_face_index != face_index); } @@ -458,31 +439,25 @@ compute_twelve_split_energy_quadratic( // Get global indices of the local vertex and edge DOFs std::array face_global_vertex_indices, face_global_edge_indices; - build_face_variable_vector( - global_vertex_indices, i, j, k, face_global_vertex_indices); + build_face_variable_vector(global_vertex_indices, i, j, k, + face_global_vertex_indices); face_global_edge_indices = global_edge_indices[face_index]; // Check if an edge is collapsing and make sure any collapsing edges have // local vertex indices 0 and 1 // WARNING: This is a somewhat fragile operation that must occur after all // of these arrays are build and before the local to global map is built - // and is not necessary in the current framework used in the paper but is for - // some deprecated experimental methods + // and is not necessary in the current framework used in the paper but is + // for some deprecated experimental methods bool is_cone_adjacent_face = false; for (int i = 0; i < 3; ++i) { if (is_cone[(i + 2) % 3]) { - shift_local_energy_quadratic_vertices(vertex_positions_T, - vertex_gradients_T, - edge_gradients_T, - initial_vertex_positions_T, - face_vertex_uv_positions, - corner_to_corner_uv_positions, - reverse_edge_orientations, - is_cone, - is_cone_adjacent, - face_global_vertex_indices, - face_global_edge_indices, - i); + shift_local_energy_quadratic_vertices( + vertex_positions_T, vertex_gradients_T, edge_gradients_T, + initial_vertex_positions_T, face_vertex_uv_positions, + corner_to_corner_uv_positions, reverse_edge_orientations, is_cone, + is_cone_adjacent, face_global_vertex_indices, + face_global_edge_indices, i); is_cone_adjacent_face = true; break; } @@ -491,6 +466,7 @@ compute_twelve_split_energy_quadratic( // Get normal for the face SpatialVector normal; normal.setZero(); + if (is_cone_adjacent_face) { normal = initial_face_normals.row(face_index); spdlog::trace("Weighting by normal {}", normal.transpose()); @@ -498,54 +474,35 @@ compute_twelve_split_energy_quadratic( // Get local to global map std::vector local_to_global_map; - generate_twelve_split_local_to_global_map(face_global_vertex_indices, - face_global_edge_indices, - num_variable_vertices, - local_to_global_map); + generate_twelve_split_local_to_global_map( + face_global_vertex_indices, face_global_edge_indices, + num_variable_vertices, local_to_global_map); // Compute local hessian data LocalHessianData local_hessian_data; generate_local_hessian_data( - face_vertex_uv_positions, - corner_to_corner_uv_positions, - reverse_edge_orientations, - is_cone, - is_cone_adjacent, - normal, - optimization_params, - local_hessian_data - ); + face_vertex_uv_positions, corner_to_corner_uv_positions, + reverse_edge_orientations, is_cone, is_cone_adjacent, normal, + optimization_params, local_hessian_data); // Compute local degree of freedom data LocalDOFData local_dof_data; - generate_local_dof_data( - initial_vertex_positions_T, - vertex_positions_T, - vertex_gradients_T, - edge_gradients_T, - local_dof_data - ); + generate_local_dof_data(initial_vertex_positions_T, vertex_positions_T, + vertex_gradients_T, edge_gradients_T, + local_dof_data); // Compute the local energy quadratic system for the face double local_energy; TwelveSplitGradient local_derivatives; TwelveSplitHessian local_hessian; compute_local_twelve_split_energy_quadratic( - local_hessian_data, - local_dof_data, - local_energy, - local_derivatives, - local_hessian); + local_hessian_data, local_dof_data, local_energy, local_derivatives, + local_hessian); // Update energy quadratic with the new face energy update_energy_quadratic( - local_energy, - local_derivatives, - local_hessian, - local_to_global_map, - energy, - derivatives, - hessian_entries); + local_energy, local_derivatives, local_hessian, local_to_global_map, + energy, derivatives, hessian_entries); } // Set hessian from the triplets @@ -553,11 +510,9 @@ compute_twelve_split_energy_quadratic( hessian.setFromTriplets(hessian_entries.begin(), hessian_entries.end()); } -void -convert_full_edge_gradients_to_reduced( - const std::vector>& edge_gradients, - std::vector>& reduced_edge_gradients) -{ +void convert_full_edge_gradients_to_reduced( + const std::vector> &edge_gradients, + std::vector> &reduced_edge_gradients) { int num_faces = edge_gradients.size(); reduced_edge_gradients.resize(num_faces); for (int i = 0; i < num_faces; ++i) { @@ -567,21 +522,19 @@ convert_full_edge_gradients_to_reduced( } } -void -convert_reduced_edge_gradients_to_full( - const std::vector>& reduced_edge_gradients, - const std::vector>& corner_data, - const AffineManifold& affine_manifold, - std::vector>& edge_gradients) -{ - Eigen::MatrixXi const& F = affine_manifold.get_faces(); +void convert_reduced_edge_gradients_to_full( + const std::vector> &reduced_edge_gradients, + const std::vector> &corner_data, + const AffineManifold &affine_manifold, + std::vector> &edge_gradients) { + Eigen::MatrixXi const &F = affine_manifold.get_faces(); int num_faces = reduced_edge_gradients.size(); // Compute the first gradient and copy the second for each edge edge_gradients.resize(num_faces); for (int i = 0; i < num_faces; ++i) { for (int j = 0; j < 3; ++j) { - EdgeManifoldChart const& chart = affine_manifold.get_edge_chart(i, j); + EdgeManifoldChart const &chart = affine_manifold.get_edge_chart(i, j); int f_top = chart.top_face_index; if (f_top != i) continue; // Only process top faces of edge charts to prevent redundancy @@ -590,8 +543,7 @@ convert_reduced_edge_gradients_to_full( SpatialVector midpoint; SpatialVector midpoint_edge_gradient; compute_edge_midpoint_with_gradient(corner_data[i][(j + 1) % 3], - corner_data[i][(j + 2) % 3], - midpoint, + corner_data[i][(j + 2) % 3], midpoint, midpoint_edge_gradient); // Copy the gradients @@ -611,24 +563,19 @@ convert_reduced_edge_gradients_to_full( } } -void -build_twelve_split_spline_energy_system( - const MatrixXr& initial_V, - const MatrixXr& initial_face_normals, - const AffineManifold& affine_manifold, - const OptimizationParameters& optimization_params, - double& energy, - VectorXr& derivatives, - Eigen::SparseMatrix& hessian, - Eigen::CholmodSupernodalLLT>& hessian_inverse) -{ +void build_twelve_split_spline_energy_system( + const MatrixXr &initial_V, const MatrixXr &initial_face_normals, + const AffineManifold &affine_manifold, + const OptimizationParameters &optimization_params, double &energy, + VectorXr &derivatives, Eigen::SparseMatrix &hessian, + Eigen::CholmodSupernodalLLT> &hessian_inverse) { int num_vertices = initial_V.rows(); int num_faces = affine_manifold.num_faces(); // Build halfedge std::vector> he_to_corner = - affine_manifold.get_he_to_corner(); - Halfedge const& halfedge = affine_manifold.get_halfedge(); + affine_manifold.get_he_to_corner(); + Halfedge const &halfedge = affine_manifold.get_halfedge(); int num_edges = halfedge.num_edges(); // Assume all vertices and edges are variable @@ -656,49 +603,36 @@ build_twelve_split_spline_energy_system( // Build vertex variable indices std::vector global_vertex_indices; - build_variable_vertex_indices_map( - num_vertices, variable_vertices, global_vertex_indices); + build_variable_vertex_indices_map(num_vertices, variable_vertices, + global_vertex_indices); // Build edge variable indices std::vector> global_edge_indices; - build_variable_edge_indices_map( - num_faces, variable_edges, halfedge, he_to_corner, global_edge_indices); + build_variable_edge_indices_map(num_faces, variable_edges, halfedge, + he_to_corner, global_edge_indices); // Build energy for the affine manifold - compute_twelve_split_energy_quadratic(vertex_positions, - vertex_gradients, - edge_gradients, - global_vertex_indices, - global_edge_indices, - initial_vertex_positions, - initial_face_normals, - affine_manifold, - optimization_params, - energy, - derivatives, - hessian, - num_variable_vertices, - num_variable_edges); + compute_twelve_split_energy_quadratic( + vertex_positions, vertex_gradients, edge_gradients, global_vertex_indices, + global_edge_indices, initial_vertex_positions, initial_face_normals, + affine_manifold, optimization_params, energy, derivatives, hessian, + num_variable_vertices, num_variable_edges); // Build the inverse hessian_inverse.compute(hessian); } -void -optimize_twelve_split_spline_surface( - const MatrixXr& initial_V, - const AffineManifold& affine_manifold, - const Halfedge& halfedge, - const std::vector>& he_to_corner, - const std::vector& variable_vertices, - const std::vector& variable_edges, - const Eigen::SparseMatrix& fit_matrix, - const Eigen::CholmodSupernodalLLT>& - hessian_inverse, - MatrixXr& optimized_V, - std::vector& optimized_vertex_gradients, - std::vector>& optimized_edge_gradients) -{ +void optimize_twelve_split_spline_surface( + const MatrixXr &initial_V, const AffineManifold &affine_manifold, + const Halfedge &halfedge, + const std::vector> &he_to_corner, + const std::vector &variable_vertices, + const std::vector &variable_edges, + const Eigen::SparseMatrix &fit_matrix, + const Eigen::CholmodSupernodalLLT> + &hessian_inverse, + MatrixXr &optimized_V, std::vector &optimized_vertex_gradients, + std::vector> &optimized_edge_gradients) { // Get variable counts int num_vertices = initial_V.rows(); int num_faces = affine_manifold.num_faces(); @@ -717,14 +651,9 @@ optimize_twelve_split_spline_surface( // Build variable values gradient as H VectorXr initial_variable_values; - generate_twelve_split_variable_value_vector(vertex_positions, - vertex_gradients, - edge_gradients, - variable_vertices, - variable_edges, - halfedge, - he_to_corner, - initial_variable_values); + generate_twelve_split_variable_value_vector( + vertex_positions, vertex_gradients, edge_gradients, variable_vertices, + variable_edges, halfedge, he_to_corner, initial_variable_values); spdlog::trace("Initial variable value vector:\n{}", initial_variable_values); // Solve hessian system to get optimized values @@ -735,15 +664,12 @@ optimize_twelve_split_spline_surface( std::vector optimized_vertex_positions = vertex_positions; optimized_vertex_gradients = vertex_gradients; optimized_edge_gradients = edge_gradients; - update_position_variables( - optimized_variable_values, variable_vertices, optimized_vertex_positions); - update_vertex_gradient_variables( - optimized_variable_values, variable_vertices, optimized_vertex_gradients); - update_edge_gradient_variables(optimized_variable_values, - variable_vertices, - variable_edges, - halfedge, - he_to_corner, + update_position_variables(optimized_variable_values, variable_vertices, + optimized_vertex_positions); + update_vertex_gradient_variables(optimized_variable_values, variable_vertices, + optimized_vertex_gradients); + update_edge_gradient_variables(optimized_variable_values, variable_vertices, + variable_edges, halfedge, he_to_corner, optimized_edge_gradients); // Copy variable values to constants @@ -753,22 +679,19 @@ optimize_twelve_split_spline_surface( } } -void -generate_optimized_twelve_split_position_data( - const Eigen::MatrixXd& V, - const AffineManifold& affine_manifold, - const Eigen::SparseMatrix& fit_matrix, - const Eigen::CholmodSupernodalLLT>& - hessian_inverse, - std::vector>& corner_data, - std::vector>& midpoint_data) -{ +void generate_optimized_twelve_split_position_data( + const Eigen::MatrixXd &V, const AffineManifold &affine_manifold, + const Eigen::SparseMatrix &fit_matrix, + const Eigen::CholmodSupernodalLLT> + &hessian_inverse, + std::vector> &corner_data, + std::vector> &midpoint_data) { int num_vertices = V.rows(); // Build halfedge - std::vector> const& he_to_corner = - affine_manifold.get_he_to_corner(); - Halfedge const& halfedge = affine_manifold.get_halfedge(); + std::vector> const &he_to_corner = + affine_manifold.get_he_to_corner(); + Halfedge const &halfedge = affine_manifold.get_halfedge(); int num_edges = halfedge.num_edges(); // Assume all vertices and edges are variable @@ -782,39 +705,29 @@ generate_optimized_twelve_split_position_data( MatrixXr optimized_V; std::vector optimized_vertex_gradients; std::vector> optimized_reduced_edge_gradients; - optimize_twelve_split_spline_surface(V, - affine_manifold, - halfedge, - he_to_corner, - variable_vertices, - variable_edges, - fit_matrix, - hessian_inverse, - optimized_V, - optimized_vertex_gradients, - optimized_reduced_edge_gradients); + optimize_twelve_split_spline_surface( + V, affine_manifold, halfedge, he_to_corner, variable_vertices, + variable_edges, fit_matrix, hessian_inverse, optimized_V, + optimized_vertex_gradients, optimized_reduced_edge_gradients); // Build corner position data from the optimized gradients - generate_affine_manifold_corner_data( - optimized_V, affine_manifold, optimized_vertex_gradients, corner_data); + generate_affine_manifold_corner_data(optimized_V, affine_manifold, + optimized_vertex_gradients, corner_data); // Build the full edge gradients with first gradient determined by the corner // position data std::vector> optimized_edge_gradients; convert_reduced_edge_gradients_to_full(optimized_reduced_edge_gradients, - corner_data, - affine_manifold, + corner_data, affine_manifold, optimized_edge_gradients); // Build midpoint position data from the optimized gradients generate_affine_manifold_midpoint_data( - affine_manifold, optimized_edge_gradients, midpoint_data); + affine_manifold, optimized_edge_gradients, midpoint_data); } -void -generate_zero_vertex_gradients(int num_vertices, - std::vector& gradients) -{ +void generate_zero_vertex_gradients(int num_vertices, + std::vector &gradients) { // Set the zero gradient for each vertex gradients.resize(num_vertices); for (int i = 0; i < num_vertices; ++i) { @@ -822,11 +735,8 @@ generate_zero_vertex_gradients(int num_vertices, } } -void -generate_zero_edge_gradients( - int num_faces, - std::vector>& edge_gradients) -{ +void generate_zero_edge_gradients( + int num_faces, std::vector> &edge_gradients) { // Set the zero gradient for each vertex edge_gradients.resize(num_faces); for (int i = 0; i < num_faces; ++i) { diff --git a/src/quadratic_spline_surface/optimize_spline_surface.h b/src/quadratic_spline_surface/optimize_spline_surface.h index 1d0e6d7..487f0f4 100644 --- a/src/quadratic_spline_surface/optimize_spline_surface.h +++ b/src/quadratic_spline_surface/optimize_spline_surface.h @@ -16,31 +16,30 @@ /// /// Methods to optimize a spline surface -struct OptimizationParameters -{ +struct OptimizationParameters { // Main optimization weight options double position_difference_factor = 1.0; double parametrized_quadratic_surface_mapping_factor = 1.0; // Weights for cone positions, normals, and gradients double cone_position_difference_factor = - 1.0; // fitting weight for cone vertices + 1.0; // fitting weight for cone vertices double cone_vertex_gradient_difference_factor = - 1e6; // fitting weight for cone vertex gradients + 1e6; // fitting weight for cone vertex gradients double cone_adjacent_position_difference_factor = - 1.0; // fitting weight for vertices collapsed to a cone + 1.0; // fitting weight for vertices collapsed to a cone double cone_adjacent_vertex_gradient_difference_factor = - 0.0; // fitting weight for vertex gradients collapsing to a cone + 0.0; // fitting weight for vertex gradients collapsing to a cone double cone_adjacent_edge_gradient_difference_factor = - 0.0; // fitting weight for vertex edge gradients collapsing to a cone + 0.0; // fitting weight for vertex edge gradients collapsing to a cone double cone_normal_orthogonality_factor = - 0.0; // wight for encouraging orthogonality with a normal at a cone + 1.0; // wight for encouraging orthogonality with a normal at a cone // TODO bool compute_final_energy = - false; // Perform one more energy computation for the final value + false; // Perform one more energy computation for the final value bool flatten_cones = false; // Perform final optimization with fixed vertices // and flatten cone constraints int hessian_builder = 1; // 1 for assemble, 0 for autodiff, otherwise assemble @@ -57,16 +56,12 @@ struct OptimizationParameters /// @param[out] derivatives: energy gradient (i.e., linear term) /// @param[out] hessian: energy Hessian (i.e., quadratic term) /// @param[out] hessian_inverse: solver for inverting the Hessian -void -build_twelve_split_spline_energy_system( - const MatrixXr& initial_V, - const MatrixXr& initial_face_normals, - const AffineManifold& affine_manifold, - const OptimizationParameters& optimization_params, - double& energy, - VectorXr& derivatives, - Eigen::SparseMatrix& hessian, - Eigen::CholmodSupernodalLLT>& hessian_inverse); +void build_twelve_split_spline_energy_system( + const MatrixXr &initial_V, const MatrixXr &initial_face_normals, + const AffineManifold &affine_manifold, + const OptimizationParameters &optimization_params, double &energy, + VectorXr &derivatives, Eigen::SparseMatrix &hessian, + Eigen::CholmodSupernodalLLT> &hessian_inverse); /// Compute the optimal per triangle position data for given vertex positions. /// @@ -76,54 +71,51 @@ build_twelve_split_spline_energy_system( /// @param[in] hessian_inverse: solver for inverting the energy Hessian /// @param[out] corner_data: quadratic vertex position and derivative data /// @param[out] midpoint_data: quadratic edge midpoint derivative data -void -generate_optimized_twelve_split_position_data( - const Eigen::MatrixXd& V, - const AffineManifold& affine_manifold, - const Eigen::SparseMatrix& fit_matrix, - const Eigen::CholmodSupernodalLLT>& - hessian_inverse, - std::vector>& corner_data, - std::vector>& midpoint_data); +void generate_optimized_twelve_split_position_data( + const Eigen::MatrixXd &V, const AffineManifold &affine_manifold, + const Eigen::SparseMatrix &fit_matrix, + const Eigen::CholmodSupernodalLLT> + &hessian_inverse, + std::vector> &corner_data, + std::vector> &midpoint_data); /// Generate zero value gradients for a given number of vertices. /// /// @param[in] num_vertices: number of vertices |V| /// @param[out] gradients: |V| trivial vertex gradient matrices -void -generate_zero_vertex_gradients(int num_vertices, - std::vector& gradients); +void generate_zero_vertex_gradients(int num_vertices, + std::vector &gradients); /// Generate zero value gradients for a given number of halfedges. /// /// @param[in] num_faces: number of faces |F| /// @param[out] gradients: 3|F| trivial edge gradient matrices -void -generate_zero_edge_gradients( - int num_faces, - std::vector>& edge_gradients); +void generate_zero_edge_gradients( + int num_faces, std::vector> &edge_gradients); -/// Given edge and opposite corner direction gradients at triangle edge midpoints, -/// extract just the opposite corner direction gradient +/// Given edge and opposite corner direction gradients at triangle edge +/// midpoints, extract just the opposite corner direction gradient /// -/// @param[in] edge_gradients: edge and corner directed gradients per edge midpoints -/// @param[out] reduced_edge_gradients: opposite corner directed gradients per edge midpoints -void -convert_full_edge_gradients_to_reduced( - const std::vector>& edge_gradients, - std::vector>& reduced_edge_gradients); +/// @param[in] edge_gradients: edge and corner directed gradients per edge +/// midpoints +/// @param[out] reduced_edge_gradients: opposite corner directed gradients per +/// edge midpoints +void convert_full_edge_gradients_to_reduced( + const std::vector> &edge_gradients, + std::vector> &reduced_edge_gradients); -/// Given edge direction gradients at triangle edge midpoints, append the gradients in the -/// direction of the opposite triangle corners, which are determined by gradients and -/// position data at the corners. +/// Given edge direction gradients at triangle edge midpoints, append the +/// gradients in the direction of the opposite triangle corners, which are +/// determined by gradients and position data at the corners. /// -/// @param[in] reduced_edge_gradients: opposite corner directed gradients per edge midpoints +/// @param[in] reduced_edge_gradients: opposite corner directed gradients per +/// edge midpoints /// @param[in] corner_data: quadratic vertex position and derivative data /// @param[in] affine_manifold: mesh topology and affine manifold structure -/// @param[out] edge_gradients: edge and corner directed gradients per edge midpoints -void -convert_reduced_edge_gradients_to_full( - const std::vector>& reduced_edge_gradients, - const std::vector>& corner_data, - const AffineManifold& affine_manifold, - std::vector>& edge_gradients); +/// @param[out] edge_gradients: edge and corner directed gradients per edge +/// midpoints +void convert_reduced_edge_gradients_to_full( + const std::vector> &reduced_edge_gradients, + const std::vector> &corner_data, + const AffineManifold &affine_manifold, + std::vector> &edge_gradients); From 5ed1c43a67add795235a363e524d4f928d39e83c Mon Sep 17 00:00:00 2001 From: JcDai Date: Sun, 22 Dec 2024 18:47:44 -0800 Subject: [PATCH 04/11] add suffix --- .../clough_tocher_surface.cpp | 35 +++++++++++-------- 1 file changed, 20 insertions(+), 15 deletions(-) diff --git a/src/clough_tocher_patches/clough_tocher_surface.cpp b/src/clough_tocher_patches/clough_tocher_surface.cpp index 9fe8b9a..7428dd8 100644 --- a/src/clough_tocher_patches/clough_tocher_surface.cpp +++ b/src/clough_tocher_patches/clough_tocher_surface.cpp @@ -206,7 +206,7 @@ void CloughTocherSurface::sample_to_obj(std::string filename, int sample_size) { void CloughTocherSurface::write_cubic_surface_to_msh_with_conn( std::string filename) { - std::ofstream file(filename); + std::ofstream file(filename + ".msh"); /* $MeshFormat @@ -385,19 +385,24 @@ void CloughTocherSurface::write_cubic_surface_to_msh_with_conn( file << "$EndElements\n"; // mark cones - const auto &cone_indices = m_affine_manifold.generate_cones(); - - file << "$NodeData\n"; - file << "1\n"; // num string tags - file << "\"Cone\"\n"; // string tag - file << "1\n"; // num real tags - file << "0.0\n"; // time step starts - file << "3\n"; // three integer tags - file << "0\n"; // time step - file << "1\n"; // num field - file << cone_indices.size() << "\n"; // num associated nodal values - for (const auto &idx : cone_indices) { - file << v_to_v_map[idx] + 1 << " 1.0\n"; + // const auto &cone_indices = m_affine_manifold.generate_cones(); + + // file << "$NodeData\n"; + // file << "1\n"; // num string tags + // file << "\"Cone\"\n"; // string tag + // file << "1\n"; // num real tags + // file << "0.0\n"; // time step starts + // file << "3\n"; // three integer tags + // file << "0\n"; // time step + // file << "1\n"; // num field + // file << cone_indices.size() << "\n"; // num associated nodal values + // for (const auto &idx : cone_indices) { + // file << v_to_v_map[idx] + 1 << " 1.0\n"; + // } + // file << "$EndNodeData\n"; + + std::ofstream v_map_file(filename + "_input_v_to_output_v_map.txt"); + for (const auto &pair : v_to_v_map) { + v_map_file << pair.first << " " << pair.second << std::endl; } - file << "EndNodeData\n"; } From a6d923d77a94ef305fef40fa9f89e1fc5b41ca5e Mon Sep 17 00:00:00 2001 From: JcDai Date: Sat, 28 Dec 2024 08:04:50 -0800 Subject: [PATCH 05/11] add pretty print --- src/clough_tocher_patches/pretty_print.py | 50 +++++++++++++++++++++++ 1 file changed, 50 insertions(+) create mode 100644 src/clough_tocher_patches/pretty_print.py diff --git a/src/clough_tocher_patches/pretty_print.py b/src/clough_tocher_patches/pretty_print.py new file mode 100644 index 0000000..f7b3398 --- /dev/null +++ b/src/clough_tocher_patches/pretty_print.py @@ -0,0 +1,50 @@ +from sympy import * +from sympy.matrices import * +from sympy.printing import ccode +import numpy as np + + +# pretty print +def C99_print(expr): + CSE_results = cse(expr, numbered_symbols("helper_"), optimizations='basic') + lines = [] + for helper in CSE_results[0]: + if isinstance(helper[1], MatrixSymbol): + lines.append( + 'const auto ' + str(helper[0]) + '[' + str(helper[1].rows * helper[1].cols) + '];') + lines.append(ccode(helper[1], helper[0])) + else: + lines.append('const auto ' + ccode(helper[1], helper[0])) + + for i, result in enumerate(CSE_results[1]): + lines.append(ccode(result, "result_%d" % i)) + return '\n'.join(lines) + +# Pretty print a matrix or tensor expression. +def C99_print_tensor(expr, result_name="result"): + # If a tensor expression, the result is reshaped into a 2d matrix for printing. + lines = [] + subs, result = cse(expr, numbered_symbols( + "helper_"), optimizations='basic') + if len(result) == 1: + result = result[0] + + for k, v in subs: + lines.append(f"const double {ccode(v, k)}") + + result_shape = np.array(result).shape + if len(result_shape) == 2: + for i in range(result_shape[0]): + for j in range(result_shape[1]): + s = ccode(result[i, j], f"{result_name}[{i}, {j}]") + lines.append(f"{s}") + elif len(result_shape) == 4: + for i in range(result_shape[0]): + for j in range(result_shape[1]): + for k in range(result_shape[2]): + for l in range(result_shape[3]): + s = ccode(result[i, j, k, l], + f"{result_name}[{i * result_shape[1] + j}, {k * result_shape[3] + l}]") + lines.append(f"{s}") + + return "\n".join(lines) \ No newline at end of file From cdfc8ab10e1a91c1cdd9c65f17bd6b92e4027348 Mon Sep 17 00:00:00 2001 From: Denis Zorin Date: Sat, 28 Dec 2024 13:41:32 -0500 Subject: [PATCH 06/11] Added Lagrange basis C1 constraint local matrices --- .../Clough_Toucher_derivation.py | 95 + .../TestCloughTocher.ipynb | 3226 ++++++++++++++++- 2 files changed, 3246 insertions(+), 75 deletions(-) diff --git a/src/clough_tocher_patches/Clough_Toucher_derivation.py b/src/clough_tocher_patches/Clough_Toucher_derivation.py index 2510dcb..1ba4ea4 100644 --- a/src/clough_tocher_patches/Clough_Toucher_derivation.py +++ b/src/clough_tocher_patches/Clough_Toucher_derivation.py @@ -69,6 +69,52 @@ def gradb(f): ep2line(x[1],x[2]), ep2line(x[2],x[0])], CTtri))] +# ********* global definitions, Lagrange nodes ********* + +#subtriangle corner barycentric coordinates +bp0 = np.array([Rational(1),Rational(0),Rational(0)]) +bp1 = np.array([Rational(0),Rational(1),Rational(0)]) +bp2 = np.array([Rational(0),Rational(0),Rational(1)]) +bc = np.array([Rational(1,3),Rational(1,3),Rational(1,3)]) + +# barycentric coords of all Lagrange nodes, multiplied by 9, so that these are all integers +# computed as linear combinations of corners of subtriangles +# coefficients should sum up to 9 +node_bary = [ + 9*bp0, 9*bp1, 9*bp2, # corners + 6*bp0+3*bp1, 3*bp0+6*bp1, 6*bp1+3*bp2, 3*bp1+6*bp2, 6*bp2+3*bp0, 3*bp2+6*bp0, # 2 nodes per exterior edge,split the edges 2:1 and 1:2 + 3*bp0+3*bp1+3*bc, 3*bp1+3*bp2+3*bc, 3*bp2+3*bp0+3*bc, # subtriangle center nodes + 6*bp0+3*bc, 3*bp0+6*bc, 6*bp1+3*bc, 3*bp1+6*bc, 6*bp2+3*bc, 3*bp2+6*bc, # 2 nodes per interior edge split the edges 2:1 and 1:2 + 9*bc # center node +] +subtri_nodes = [ + [0,1, 3+0, 3+1, 9 , 12+0, 12+1, 12+2, 12+3, 18], + [1,2, 3+2, 3+3, 10, 12+2, 12+3, 12+4, 12+5, 18], + [2,0, 3+4, 3+5, 11, 12+4, 12+5, 12+0, 12+1, 18], +] + +# a helpde function to create symbolic names for nodes based on their barycentric coords +def bary2name(bc): + return 'c'+''.join([ str(c) for c in bc]) + +# dictionary barycentric coordinate tuples -> symbolic name for an node +node_vars_dict = {tuple(map(lambda x: int(x), b)): symbols(bary2name(b)) for b in node_bary} + +# array of barycentric coord tuples in the same order as in node_bary +ind2bary = [tuple(map(lambda x: int(x), b)) for b in node_bary] + +# array of variables in the order matching node_bary +node_vars = [ node_vars_dict[ind2bary[i]] for i in range(19)] + +# polynomials that can be used to evaluate each of the Lagrange nodes +node_subtri = \ +[0, 1, 2, # corners, one index of two possible + 0, 0, 1, 1, 2,2, # exterior edges + 0, 1, 2, # subtriangle centers + 0, 0, 1, 1, 2, 2, # interior edges, one index of two possible + 0 # any polynomial can be used +] + # ********* global definitions, boundary dofs of the element ********* @@ -280,7 +326,27 @@ def CT_eval(CT_matrices, CTtri_bounds, boundary_data, u,v,w): else: return np.nan +# ******* Converting to Lagrange basis ****** +def generate_L2L(polys_C1, node_bary, node_subtri, all_inknowns): + """ + Generates a matrix L_d2L that maps a vector of 12 dofs (pi, Gij, Nij) to the vector of Lagrange node values + enumerated as described by node_bary and node_vars. node_subtri is the 3 polynomials on subtriangles with + coefficients given in terms of (pi, Gij, Nij) + """ + subtri_polys = [Poly(p,[u,v,w]) for p in polys_C1] + Lagr_node_vals = [ subtri_polys[node_subtri[i]](*(node_bary[i]/9)) for i in range(19) ] + local_dof_vars = all_unknowns + L_d2L = Matrix( [ [ Lnode.coeff(v) for v in local_dof_vars] for Lnode in Lagr_node_vals]) + return L_d2L +# a vector of coefficients c_e + +def generate_ce(subtri_polys): + "Creates a vector of coefficients which, when applied to the vector [p0,p1,G01,G10,N01] yields the derivative along the edge at the midpoint." + midpt_dfde = subtri_polys[0].as_expr().subs({w:0,v:1-u}).expand().collect(u).diff(u).subs({u:Rational(1,2)}) + edge_endpt_vars = [p0,p1,G01,G10, N01] + c_e = [midpt_dfde.coeff(v) for v in edge_endpt_vars] + return c_e # ******** Testing ********* @@ -311,6 +377,34 @@ def runTests(polys_C1_f): +def test_Lagrange_consistency(polys_C1_f, L_L2d_ind, L_ind2dep): + """ + polys_C1_f: 3 subtriangle polynomials with coefficients in terms of (pi, Gij, Nij) variables, + L_L2d_ind: 12 x12 matrix expressing (pi, Gij, Nij) in terms of 12 indep. Lagrange node values + L_ind2dep: matrix expressing 7 dependence Lagrange nodes in terms of independent; this ensures internal edge C1 constraints + The test verifies that + (1) when we use L_L2d_ind to express polynomial coefficient in terms of indep Lagrange nodes + we get these nodes back when evaluating at their barycentric coordinates. + (2) when we evaluate at the dependent node coordinates we get the same as we get by applying L_ind2dep to indep node values. + As for any choice of (pi, Gij, Nij) dofs the polynomials are already verified to be C1 at the interior edges, + this also verifies that if the dependent node values are computed from independent using L_ind2dep, the resulting polynomials + are C1 at the interior edges. + """ + global all_unknowns, node_vars, node_bary, subtri_nodes + dof_vars = all_unknowns + + # express the triangle dof values (pi, Gij, Nij) in terms of independ lagrange node values using provided matrix + dof_lagr_subs = dict( [[ dof_vars[i], (L_L2d_ind * Matrix( [node_vars[0:12]]).T)[i] ] for i in range(12)]) + # express dependent node values in terms of indepedent + dep_nodes_expr = L_ind2dep*Matrix([node_vars[0:12]]).T + + # evaluate the polynomials on subtriangles at node barycentric coordinates, verify we get the Lagrange nodes back + passed = True + for i in range(3): + passed = passed and not any([ Poly( polys_C1_f[i].subs( dof_lagr_subs), [u,v,w])(*node_bary[j]/9)- node_vars[j] for j in subtri_nodes[i] if j < 12]+\ + [ Poly( polys_C1_f[i].subs( dof_lagr_subs), [u,v,w])(*node_bary[j]/9)- dep_nodes_expr[j-12] for j in subtri_nodes[i] if j >= 12]) + print('Lagrange consistency test '+ ('passed' if passed else 'not passed')) + # ******** Plotting ********* # !!!! ChatGPT generated - probably there is a better way to plot a function on a triangle but not sure import plotly.graph_objects as go @@ -380,6 +474,7 @@ def plot_function_on_triangle(func, fun_name, vertices, resolution=20): ) # Show the interactive plot fig.show() + return fig def create_regular_grid_and_triangles(resolution): diff --git a/src/clough_tocher_patches/TestCloughTocher.ipynb b/src/clough_tocher_patches/TestCloughTocher.ipynb index 726547a..67c75c3 100644 --- a/src/clough_tocher_patches/TestCloughTocher.ipynb +++ b/src/clough_tocher_patches/TestCloughTocher.ipynb @@ -42,68 +42,18 @@ "text/html": [ " " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, + "data": [ + { + "colorbar": { + "title": { + "text": "Function Value" + } + }, + "colorscale": [ + [ + 0, + "#440154" + ], + [ + 0.1111111111111111, + "#482878" + ], + [ + 0.2222222222222222, + "#3e4989" + ], + [ + 0.3333333333333333, + "#31688e" + ], + [ + 0.4444444444444444, + "#26828e" + ], + [ + 0.5555555555555556, + "#1f9e89" + ], + [ + 0.6666666666666666, + "#35b779" + ], + [ + 0.7777777777777778, + "#6ece58" + ], + [ + 0.8888888888888888, + "#b5de2b" + ], + [ + 1, + "#fde725" + ] + ], + "i": [ + 0, + 1, + 1, + 2, + 2, + 3, + 3, + 4, + 4, + 5, + 5, + 6, + 6, + 7, + 7, + 8, + 8, + 9, + 9, + 10, + 10, + 11, + 11, + 12, + 12, + 13, + 13, + 14, + 14, + 15, + 15, + 16, + 16, + 17, + 17, + 18, + 18, + 19, + 19, + 21, + 22, + 22, + 23, + 23, + 24, + 24, + 25, + 25, + 26, + 26, + 27, + 27, + 28, + 28, + 29, + 29, + 30, + 30, + 31, + 31, + 32, + 32, + 33, + 33, + 34, + 34, + 35, + 35, + 36, + 36, + 37, + 37, + 38, + 38, + 39, + 39, + 41, + 42, + 42, + 43, + 43, + 44, + 44, + 45, + 45, + 46, + 46, + 47, + 47, + 48, + 48, + 49, + 49, + 50, + 50, + 51, + 51, + 52, + 52, + 53, + 53, + 54, + 54, + 55, + 55, + 56, + 56, + 57, + 57, + 58, + 58, + 60, + 61, + 61, + 62, + 62, + 63, + 63, + 64, + 64, + 65, + 65, + 66, + 66, + 67, + 67, + 68, + 68, + 69, + 69, + 70, + 70, + 71, + 71, + 72, + 72, + 73, + 73, + 74, + 74, + 75, + 75, + 76, + 76, + 78, + 79, + 79, + 80, + 80, + 81, + 81, + 82, + 82, + 83, + 83, + 84, + 84, + 85, + 85, + 86, + 86, + 87, + 87, + 88, + 88, + 89, + 89, + 90, + 90, + 91, + 91, + 92, + 92, + 93, + 93, + 95, + 96, + 96, + 97, + 97, + 98, + 98, + 99, + 99, + 100, + 100, + 101, + 101, + 102, + 102, + 103, + 103, + 104, + 104, + 105, + 105, + 106, + 106, + 107, + 107, + 108, + 108, + 109, + 109, + 111, + 112, + 112, + 113, + 113, + 114, + 114, + 115, + 115, + 116, + 116, + 117, + 117, + 118, + 118, + 119, + 119, + 120, + 120, + 121, + 121, + 122, + 122, + 123, + 123, + 124, + 124, + 126, + 127, + 127, + 128, + 128, + 129, + 129, + 130, + 130, + 131, + 131, + 132, + 132, + 133, + 133, + 134, + 134, + 135, + 135, + 136, + 136, + 137, + 137, + 138, + 138, + 140, + 141, + 141, + 142, + 142, + 143, + 143, + 144, + 144, + 145, + 145, + 146, + 146, + 147, + 147, + 148, + 148, + 149, + 149, + 150, + 150, + 151, + 151, + 153, + 154, + 154, + 155, + 155, + 156, + 156, + 157, + 157, + 158, + 158, + 159, + 159, + 160, + 160, + 161, + 161, + 162, + 162, + 163, + 163, + 165, + 166, + 166, + 167, + 167, + 168, + 168, + 169, + 169, + 170, + 170, + 171, + 171, + 172, + 172, + 173, + 173, + 174, + 174, + 176, + 177, + 177, + 178, + 178, + 179, + 179, + 180, + 180, + 181, + 181, + 182, + 182, + 183, + 183, + 184, + 184, + 186, + 187, + 187, + 188, + 188, + 189, + 189, + 190, + 190, + 191, + 191, + 192, + 192, + 193, + 193, + 195, + 196, + 196, + 197, + 197, + 198, + 198, + 199, + 199, + 200, + 200, + 201, + 201, + 203, + 204, + 204, + 205, + 205, + 206, + 206, + 207, + 207, + 208, + 208, + 210, + 211, + 211, + 212, + 212, + 213, + 213, + 214, + 214, + 216, + 217, + 217, + 218, + 218, + 219, + 219, + 221, + 222, + 222, + 223, + 223, + 225, + 226, + 226, + 228 + ], + "intensity": [ + 0, + -0.03591174457718357, + -0.13580028412885914, + -0.2878955773852138, + -0.4804275830764352, + -0.7016262599327101, + -0.9397215666842261, + -1.1829434620611703, + -1.4195219047937306, + -1.6376868536120934, + -1.8256682672464462, + -1.9716961044269765, + -2.0640003238838713, + -2.0908108843473183, + -2.040357744547504, + -1.9008708632146167, + -1.6605801990788427, + -1.30771571087037, + -0.8305073573193853, + -0.2171850971560771, + 0.5440211108893698, + 0.03591174457718357, + -3.0357660829594124e-18, + -0.1468754333565604, + -0.34026223935054123, + -0.56839037671213, + -0.8194898041715135, + -1.081790480458879, + -1.3435223643044139, + -1.592915414438307, + -1.8181995895907428, + -2.0076048484919102, + -2.149361149871997, + -2.231698452461189, + -2.2428467149896743, + -2.1710358961876395, + -2.0044959547852725, + -1.7314568495127607, + -1.3401485391002914, + -0.818800982278051, + -0.18127335257889296, + 0.13580028412885914, + 0.1468754333565604, + 3.122502256758253e-17, + -0.23183062819797748, + -0.4927072066963041, + -0.7708596942251666, + -1.054518049514753, + -1.33191223129525, + -1.5912721982968456, + -1.8208279092497257, + -2.008809322884078, + -2.1434463979300915, + -2.212969093117951, + -2.2056073671778456, + -2.109591178839961, + -1.9131504868344862, + -1.6045152498916069, + -1.1932731057437318, + -0.6947070731905266, + 0.2878955773852138, + 0.3402622393505412, + 0.23183062819797745, + 6.938893903907228e-17, + -0.2907773291014351, + -0.5931351861661475, + -0.8953035299243248, + -1.1855123191061538, + -1.4519915124418223, + -1.6829710686615176, + -1.8666809464954262, + -1.9913511046737362, + -2.0452115019266346, + -2.016492096984308, + -1.8934228485769442, + -1.6813198586365077, + -1.3911946101622197, + -1.019820133485156, + 0.4804275830764352, + 0.5683903767121299, + 0.4927072066963041, + 0.2907773291014351, + 1.3877787807814457e-16, + -0.323715536066933, + -0.6415461777600717, + -0.9417218838096038, + -1.2124726129457166, + -1.442028323898597, + -1.6186189753984324, + -1.73047452617541, + -1.765824934959717, + -1.7257147678828733, + -1.6168839721436572, + -1.4361055780731435, + -1.1801526160024078, + 0.7016262599327101, + 0.8194898041715133, + 0.7708596942251668, + 0.5931351861661475, + 0.32371553606693265, + 5.551115123125783e-17, + -0.3306452490944711, + -0.6379401814780762, + -0.9101147558810042, + -1.1353989310334405, + -1.3020226656655725, + -1.4067589901084772, + -1.4520763157604872, + -1.4347476729526785, + -1.3515460920161266, + -1.1992446032819066, + 0.9397215666842261, + 1.081790480458879, + 1.0545180495147528, + 0.8953035299243246, + 0.6415461777600712, + 0.330645249094471, + 1.1102230246251565e-16, + -0.3115664681840489, + -0.5823171973201625, + -0.8047536819389689, + -0.9770727976383602, + -1.0960475747494112, + -1.1584510436031974, + -1.1610562345307947, + -1.1006361778632772, + 1.1829434620611703, + 1.343522364304414, + 1.3319122312952496, + 1.1855123191061536, + 0.9417218838096034, + 0.6379401814780763, + 0.31156646818404926, + -4.5102810375396984e-17, + -0.27217457440292775, + -0.500306440088993, + -0.6811686273892726, + -0.8115341666348411, + -0.8881760881567747, + -0.9078674222861479, + 1.4195219047937306, + 1.592915414438307, + 1.5912721982968454, + 1.4519915124418228, + 1.2124726129457164, + 0.9101147558810041, + 0.5823171973201624, + 0.27217457440292764, + -1.5265566588595902e-16, + -0.23097955621969507, + -0.41753712458723263, + -0.5564457354336898, + -0.6444784190901407, + 1.6376868536120934, + 1.8181995895907432, + 1.820827909249726, + 1.6829710686615178, + 1.4420283238985967, + 1.1353989310334403, + 0.8047536819389692, + 0.5003064400889928, + 0.23097955621969504, + 2.7755575615628914e-17, + -0.18940525890116763, + -0.33400925081488353, + 1.8256682672464462, + 2.0076048484919107, + 2.008809322884078, + 1.8666809464954264, + 1.618618975398432, + 1.3020226656655727, + 0.9770727976383602, + 0.6811686273892725, + 0.417537124587233, + 0.1894052589011674, + -2.7755575615628914e-17, + 1.9716961044269765, + 2.149361149871997, + 2.1434463979300915, + 1.9913511046737362, + 1.7304745261754095, + 1.406758990108477, + 1.0960475747494116, + 0.8115341666348413, + 0.5564457354336897, + 0.3340092508148834, + 2.0640003238838713, + 2.2316984524611887, + 2.2129690931179513, + 2.0452115019266346, + 1.7658249349597166, + 1.452076315760487, + 1.1584510436031978, + 0.888176088156775, + 0.6444784190901406, + 2.0908108843473183, + 2.2428467149896743, + 2.205607367177845, + 2.0164920969843085, + 1.7257147678828733, + 1.4347476729526782, + 1.161056234530795, + 0.9078674222861479, + 2.040357744547504, + 2.1710358961876395, + 2.1095911788399606, + 1.8934228485769444, + 1.6168839721436565, + 1.3515460920161264, + 1.1006361778632776, + 1.9008708632146167, + 2.004495954785273, + 1.9131504868344857, + 1.6813198586365081, + 1.436105578073143, + 1.1992446032819066, + 1.6605801990788427, + 1.7314568495127611, + 1.6045152498916062, + 1.39119461016222, + 1.1801526160024074, + 1.30771571087037, + 1.3401485391002919, + 1.1932731057437316, + 1.0198201334851562, + 0.8305073573193853, + 0.8188009822780515, + 0.6947070731905263, + 0.2171850971560771, + 0.1812733525788935, + -0.5440211108893698 + ], + "j": [ + 1, + 22, + 2, + 23, + 3, + 24, + 4, + 25, + 5, + 26, + 6, + 27, + 7, + 28, + 8, + 29, + 9, + 30, + 10, + 31, + 11, + 32, + 12, + 33, + 13, + 34, + 14, + 35, + 15, + 36, + 16, + 37, + 17, + 38, + 18, + 39, + 19, + 40, + 20, + 22, + 42, + 23, + 43, + 24, + 44, + 25, + 45, + 26, + 46, + 27, + 47, + 28, + 48, + 29, + 49, + 30, + 50, + 31, + 51, + 32, + 52, + 33, + 53, + 34, + 54, + 35, + 55, + 36, + 56, + 37, + 57, + 38, + 58, + 39, + 59, + 40, + 42, + 61, + 43, + 62, + 44, + 63, + 45, + 64, + 46, + 65, + 47, + 66, + 48, + 67, + 49, + 68, + 50, + 69, + 51, + 70, + 52, + 71, + 53, + 72, + 54, + 73, + 55, + 74, + 56, + 75, + 57, + 76, + 58, + 77, + 59, + 61, + 79, + 62, + 80, + 63, + 81, + 64, + 82, + 65, + 83, + 66, + 84, + 67, + 85, + 68, + 86, + 69, + 87, + 70, + 88, + 71, + 89, + 72, + 90, + 73, + 91, + 74, + 92, + 75, + 93, + 76, + 94, + 77, + 79, + 96, + 80, + 97, + 81, + 98, + 82, + 99, + 83, + 100, + 84, + 101, + 85, + 102, + 86, + 103, + 87, + 104, + 88, + 105, + 89, + 106, + 90, + 107, + 91, + 108, + 92, + 109, + 93, + 110, + 94, + 96, + 112, + 97, + 113, + 98, + 114, + 99, + 115, + 100, + 116, + 101, + 117, + 102, + 118, + 103, + 119, + 104, + 120, + 105, + 121, + 106, + 122, + 107, + 123, + 108, + 124, + 109, + 125, + 110, + 112, + 127, + 113, + 128, + 114, + 129, + 115, + 130, + 116, + 131, + 117, + 132, + 118, + 133, + 119, + 134, + 120, + 135, + 121, + 136, + 122, + 137, + 123, + 138, + 124, + 139, + 125, + 127, + 141, + 128, + 142, + 129, + 143, + 130, + 144, + 131, + 145, + 132, + 146, + 133, + 147, + 134, + 148, + 135, + 149, + 136, + 150, + 137, + 151, + 138, + 152, + 139, + 141, + 154, + 142, + 155, + 143, + 156, + 144, + 157, + 145, + 158, + 146, + 159, + 147, + 160, + 148, + 161, + 149, + 162, + 150, + 163, + 151, + 164, + 152, + 154, + 166, + 155, + 167, + 156, + 168, + 157, + 169, + 158, + 170, + 159, + 171, + 160, + 172, + 161, + 173, + 162, + 174, + 163, + 175, + 164, + 166, + 177, + 167, + 178, + 168, + 179, + 169, + 180, + 170, + 181, + 171, + 182, + 172, + 183, + 173, + 184, + 174, + 185, + 175, + 177, + 187, + 178, + 188, + 179, + 189, + 180, + 190, + 181, + 191, + 182, + 192, + 183, + 193, + 184, + 194, + 185, + 187, + 196, + 188, + 197, + 189, + 198, + 190, + 199, + 191, + 200, + 192, + 201, + 193, + 202, + 194, + 196, + 204, + 197, + 205, + 198, + 206, + 199, + 207, + 200, + 208, + 201, + 209, + 202, + 204, + 211, + 205, + 212, + 206, + 213, + 207, + 214, + 208, + 215, + 209, + 211, + 217, + 212, + 218, + 213, + 219, + 214, + 220, + 215, + 217, + 222, + 218, + 223, + 219, + 224, + 220, + 222, + 226, + 223, + 227, + 224, + 226, + 229, + 227, + 229 + ], + "k": [ + 21, + 21, + 22, + 22, + 23, + 23, + 24, + 24, + 25, + 25, + 26, + 26, + 27, + 27, + 28, + 28, + 29, + 29, + 30, + 30, + 31, + 31, + 32, + 32, + 33, + 33, + 34, + 34, + 35, + 35, + 36, + 36, + 37, + 37, + 38, + 38, + 39, + 39, + 40, + 41, + 41, + 42, + 42, + 43, + 43, + 44, + 44, + 45, + 45, + 46, + 46, + 47, + 47, + 48, + 48, + 49, + 49, + 50, + 50, + 51, + 51, + 52, + 52, + 53, + 53, + 54, + 54, + 55, + 55, + 56, + 56, + 57, + 57, + 58, + 58, + 59, + 60, + 60, + 61, + 61, + 62, + 62, + 63, + 63, + 64, + 64, + 65, + 65, + 66, + 66, + 67, + 67, + 68, + 68, + 69, + 69, + 70, + 70, + 71, + 71, + 72, + 72, + 73, + 73, + 74, + 74, + 75, + 75, + 76, + 76, + 77, + 78, + 78, + 79, + 79, + 80, + 80, + 81, + 81, + 82, + 82, + 83, + 83, + 84, + 84, + 85, + 85, + 86, + 86, + 87, + 87, + 88, + 88, + 89, + 89, + 90, + 90, + 91, + 91, + 92, + 92, + 93, + 93, + 94, + 95, + 95, + 96, + 96, + 97, + 97, + 98, + 98, + 99, + 99, + 100, + 100, + 101, + 101, + 102, + 102, + 103, + 103, + 104, + 104, + 105, + 105, + 106, + 106, + 107, + 107, + 108, + 108, + 109, + 109, + 110, + 111, + 111, + 112, + 112, + 113, + 113, + 114, + 114, + 115, + 115, + 116, + 116, + 117, + 117, + 118, + 118, + 119, + 119, + 120, + 120, + 121, + 121, + 122, + 122, + 123, + 123, + 124, + 124, + 125, + 126, + 126, + 127, + 127, + 128, + 128, + 129, + 129, + 130, + 130, + 131, + 131, + 132, + 132, + 133, + 133, + 134, + 134, + 135, + 135, + 136, + 136, + 137, + 137, + 138, + 138, + 139, + 140, + 140, + 141, + 141, + 142, + 142, + 143, + 143, + 144, + 144, + 145, + 145, + 146, + 146, + 147, + 147, + 148, + 148, + 149, + 149, + 150, + 150, + 151, + 151, + 152, + 153, + 153, + 154, + 154, + 155, + 155, + 156, + 156, + 157, + 157, + 158, + 158, + 159, + 159, + 160, + 160, + 161, + 161, + 162, + 162, + 163, + 163, + 164, + 165, + 165, + 166, + 166, + 167, + 167, + 168, + 168, + 169, + 169, + 170, + 170, + 171, + 171, + 172, + 172, + 173, + 173, + 174, + 174, + 175, + 176, + 176, + 177, + 177, + 178, + 178, + 179, + 179, + 180, + 180, + 181, + 181, + 182, + 182, + 183, + 183, + 184, + 184, + 185, + 186, + 186, + 187, + 187, + 188, + 188, + 189, + 189, + 190, + 190, + 191, + 191, + 192, + 192, + 193, + 193, + 194, + 195, + 195, + 196, + 196, + 197, + 197, + 198, + 198, + 199, + 199, + 200, + 200, + 201, + 201, + 202, + 203, + 203, + 204, + 204, + 205, + 205, + 206, + 206, + 207, + 207, + 208, + 208, + 209, + 210, + 210, + 211, + 211, + 212, + 212, + 213, + 213, + 214, + 214, + 215, + 216, + 216, + 217, + 217, + 218, + 218, + 219, + 219, + 220, + 221, + 221, + 222, + 222, + 223, + 223, + 224, + 225, + 225, + 226, + 226, + 227, + 228, + 228, + 229, + 230 + ], + "opacity": 0.9, + "type": "mesh3d", + "x": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 0.05, + 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.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.15, + 0.2, + 0.2, + 0.2, + 0.2, + 0.2, + 0.2, + 0.2, + 0.2, + 0.2, + 0.2, + 0.2, + 0.2, + 0.2, + 0.2, + 0.2, + 0.2, + 0.2, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.25, + 0.3, + 0.3, + 0.3, + 0.3, + 0.3, + 0.3, + 0.3, + 0.3, + 0.3, + 0.3, + 0.3, + 0.3, + 0.3, + 0.3, + 0.3, + 0.35, + 0.35, + 0.35, + 0.35, + 0.35, + 0.35, + 0.35, + 0.35, + 0.35, + 0.35, + 0.35, + 0.35, + 0.35, + 0.35, + 0.4, + 0.4, + 0.4, + 0.4, + 0.4, + 0.4, + 0.4, + 0.4, + 0.4, + 0.4, + 0.4, + 0.4, + 0.4, + 0.45, + 0.45, + 0.45, + 0.45, + 0.45, + 0.45, + 0.45, + 0.45, + 0.45, + 0.45, + 0.45, + 0.45, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.55, + 0.55, + 0.55, + 0.55, + 0.55, + 0.55, + 0.55, + 0.55, + 0.55, + 0.55, + 0.6, + 0.6, + 0.6, + 0.6, + 0.6, + 0.6, + 0.6, + 0.6, + 0.6, + 0.65, + 0.65, + 0.65, + 0.65, + 0.65, + 0.65, + 0.65, + 0.65, + 0.7, + 0.7, + 0.7, + 0.7, + 0.7, + 0.7, + 0.7, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.8, + 0.8, + 0.8, + 0.8, + 0.8, + 0.85, + 0.85, + 0.85, + 0.85, + 0.9, + 0.9, + 0.9, + 0.95, + 0.95, + 1 + ], + "y": [ + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0.5, + 0.55, + 0.6, + 0.65, + 0.7, + 0.75, + 0.8, + 0.85, + 0.9, + 0.95, + 1, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0.5, + 0.55, + 0.6, + 0.65, + 0.7, + 0.75, + 0.8, + 0.85, + 0.9, + 0.95, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0.5, + 0.55, + 0.6, + 0.65, + 0.7, + 0.75, + 0.8, + 0.85, + 0.9, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0.5, + 0.55, + 0.6, + 0.65, + 0.7, + 0.75, + 0.8, + 0.85, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0.5, + 0.55, + 0.6, + 0.65, + 0.7, + 0.75, + 0.8, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0.5, + 0.55, + 0.6, + 0.65, + 0.7, + 0.75, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0.5, + 0.55, + 0.6, + 0.65, + 0.7, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0.5, + 0.55, + 0.6, + 0.65, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0.5, + 0.55, + 0.6, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0.5, + 0.55, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0.5, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0, + 0.05, + 0.1, + 0.15, + 0, + 0.05, + 0.1, + 0, + 0.05, + 0 + ], + "z": [ + 0, + -0.03591174457718357, + -0.13580028412885914, + -0.2878955773852138, + -0.4804275830764352, + -0.7016262599327101, + -0.9397215666842261, + -1.1829434620611703, + -1.4195219047937306, + -1.6376868536120934, + -1.8256682672464462, + -1.9716961044269765, + -2.0640003238838713, + -2.0908108843473183, + -2.040357744547504, + -1.9008708632146167, + -1.6605801990788427, + -1.30771571087037, + -0.8305073573193853, + -0.2171850971560771, + 0.5440211108893698, + 0.03591174457718357, + -3.0357660829594124e-18, + -0.1468754333565604, + -0.34026223935054123, + -0.56839037671213, + -0.8194898041715135, + -1.081790480458879, + -1.3435223643044139, + -1.592915414438307, + -1.8181995895907428, + -2.0076048484919102, + -2.149361149871997, + -2.231698452461189, + -2.2428467149896743, + -2.1710358961876395, + -2.0044959547852725, + -1.7314568495127607, + -1.3401485391002914, + -0.818800982278051, + -0.18127335257889296, + 0.13580028412885914, + 0.1468754333565604, + 3.122502256758253e-17, + -0.23183062819797748, + -0.4927072066963041, + -0.7708596942251666, + -1.054518049514753, + -1.33191223129525, + -1.5912721982968456, + -1.8208279092497257, + -2.008809322884078, + -2.1434463979300915, + -2.212969093117951, + -2.2056073671778456, + -2.109591178839961, + -1.9131504868344862, + -1.6045152498916069, + -1.1932731057437318, + -0.6947070731905266, + 0.2878955773852138, + 0.3402622393505412, + 0.23183062819797745, + 6.938893903907228e-17, + -0.2907773291014351, + -0.5931351861661475, + -0.8953035299243248, + -1.1855123191061538, + -1.4519915124418223, + -1.6829710686615176, + -1.8666809464954262, + -1.9913511046737362, + -2.0452115019266346, + -2.016492096984308, + -1.8934228485769442, + -1.6813198586365077, + -1.3911946101622197, + -1.019820133485156, + 0.4804275830764352, + 0.5683903767121299, + 0.4927072066963041, + 0.2907773291014351, + 1.3877787807814457e-16, + -0.323715536066933, + -0.6415461777600717, + -0.9417218838096038, + -1.2124726129457166, + -1.442028323898597, + -1.6186189753984324, + -1.73047452617541, + -1.765824934959717, + -1.7257147678828733, + -1.6168839721436572, + -1.4361055780731435, + -1.1801526160024078, + 0.7016262599327101, + 0.8194898041715133, + 0.7708596942251668, + 0.5931351861661475, + 0.32371553606693265, + 5.551115123125783e-17, + -0.3306452490944711, + -0.6379401814780762, + -0.9101147558810042, + -1.1353989310334405, + -1.3020226656655725, + -1.4067589901084772, + -1.4520763157604872, + -1.4347476729526785, + -1.3515460920161266, + -1.1992446032819066, + 0.9397215666842261, + 1.081790480458879, + 1.0545180495147528, + 0.8953035299243246, + 0.6415461777600712, + 0.330645249094471, + 1.1102230246251565e-16, + -0.3115664681840489, + -0.5823171973201625, + -0.8047536819389689, + -0.9770727976383602, + -1.0960475747494112, + -1.1584510436031974, + -1.1610562345307947, + -1.1006361778632772, + 1.1829434620611703, + 1.343522364304414, + 1.3319122312952496, + 1.1855123191061536, + 0.9417218838096034, + 0.6379401814780763, + 0.31156646818404926, + -4.5102810375396984e-17, + -0.27217457440292775, + -0.500306440088993, + -0.6811686273892726, + -0.8115341666348411, + -0.8881760881567747, + -0.9078674222861479, + 1.4195219047937306, + 1.592915414438307, + 1.5912721982968454, + 1.4519915124418228, + 1.2124726129457164, + 0.9101147558810041, + 0.5823171973201624, + 0.27217457440292764, + -1.5265566588595902e-16, + -0.23097955621969507, + -0.41753712458723263, + -0.5564457354336898, + -0.6444784190901407, + 1.6376868536120934, + 1.8181995895907432, + 1.820827909249726, + 1.6829710686615178, + 1.4420283238985967, + 1.1353989310334403, + 0.8047536819389692, + 0.5003064400889928, + 0.23097955621969504, + 2.7755575615628914e-17, + -0.18940525890116763, + -0.33400925081488353, + 1.8256682672464462, + 2.0076048484919107, + 2.008809322884078, + 1.8666809464954264, + 1.618618975398432, + 1.3020226656655727, + 0.9770727976383602, + 0.6811686273892725, + 0.417537124587233, + 0.1894052589011674, + -2.7755575615628914e-17, + 1.9716961044269765, + 2.149361149871997, + 2.1434463979300915, + 1.9913511046737362, + 1.7304745261754095, + 1.406758990108477, + 1.0960475747494116, + 0.8115341666348413, + 0.5564457354336897, + 0.3340092508148834, + 2.0640003238838713, + 2.2316984524611887, + 2.2129690931179513, + 2.0452115019266346, + 1.7658249349597166, + 1.452076315760487, + 1.1584510436031978, + 0.888176088156775, + 0.6444784190901406, + 2.0908108843473183, + 2.2428467149896743, + 2.205607367177845, + 2.0164920969843085, + 1.7257147678828733, + 1.4347476729526782, + 1.161056234530795, + 0.9078674222861479, + 2.040357744547504, + 2.1710358961876395, + 2.1095911788399606, + 1.8934228485769444, + 1.6168839721436565, + 1.3515460920161264, + 1.1006361778632776, + 1.9008708632146167, + 2.004495954785273, + 1.9131504868344857, + 1.6813198586365081, + 1.436105578073143, + 1.1992446032819066, + 1.6605801990788427, + 1.7314568495127611, + 1.6045152498916062, + 1.39119461016222, + 1.1801526160024074, + 1.30771571087037, + 1.3401485391002919, + 1.1932731057437316, + 1.0198201334851562, + 0.8305073573193853, + 0.8188009822780515, + 0.6947070731905263, + 0.2171850971560771, + 0.1812733525788935, + -0.5440211108893698 + ] + }, + { + "color": "lightblue", + "i": [ + 0 + ], + "j": [ + 1 + ], + "k": [ + 2 + ], + "name": "Triangle Base", + "opacity": 0.5, + "type": "mesh3d", + "x": [ + 1, + 0, + 0 + ], + "y": [ + 0, + 1, + 0 + ], + "z": [ + 0, + 0, + 0 + ] + } + ], + "layout": { + "height": 1000, + "scene": { + "aspectratio": { + "x": 1, + "y": 1, + "z": 0.5 + }, + "xaxis": { + "title": { + "text": "u" + } }, "yaxis": { "title": { "text": "v" - }, - "type": "linear" + } }, "zaxis": { "title": { "text": "Function Value" - }, - "type": "linear" + } } }, "template": { @@ -2742,11 +5794,10 @@ ], "scatter": [ { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } + "fillpattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 }, "type": "scatter" } @@ -3193,11 +6244,11 @@ "width": 1000 } }, - "image/png": "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", + "image/png": "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", "text/html": [ - "
\n", - " " - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "data": { "application/vnd.plotly.v1+json": { @@ -3138,35 +3109,7 @@ }, "width": 1000 } - }, - "image/png": "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", - "text/html": [ - "
" - ] + } }, "metadata": {}, "output_type": "display_data" @@ -6243,35 +6186,7 @@ }, "width": 1000 } - }, - "image/png": "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", - "text/html": [ - "
" - ] + } }, "metadata": {}, "output_type": "display_data" @@ -6312,7 +6227,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "995c3f30-b4dc-4fe3-92be-b4f6c2458ab0", "metadata": {}, "outputs": [ @@ -6330,11 +6245,75 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "50d3fb36-4475-4036-8fcd-4853d2cdf2f4", "metadata": {}, "outputs": [], "source": [] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "765d3a6b", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "67745ecc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'L[0][0] = 1;\\nL[0][1] = 0;\\nL[0][2] = 0;\\nL[0][3] = 0;\\nL[0][4] = 0;\\nL[0][5] = 0;\\nL[0][6] = 0;\\nL[0][7] = 0;\\nL[0][8] = 0;\\nL[0][9] = 0;\\nL[0][10] = 0;\\nL[0][11] = 0;\\nL[1][0] = 0;\\nL[1][1] = 1;\\nL[1][2] = 0;\\nL[1][3] = 0;\\nL[1][4] = 0;\\nL[1][5] = 0;\\nL[1][6] = 0;\\nL[1][7] = 0;\\nL[1][8] = 0;\\nL[1][9] = 0;\\nL[1][10] = 0;\\nL[1][11] = 0;\\nL[2][0] = 0;\\nL[2][1] = 0;\\nL[2][2] = 1;\\nL[2][3] = 0;\\nL[2][4] = 0;\\nL[2][5] = 0;\\nL[2][6] = 0;\\nL[2][7] = 0;\\nL[2][8] = 0;\\nL[2][9] = 0;\\nL[2][10] = 0;\\nL[2][11] = 0;\\nL[3][0] = -11.0/2.0;\\nL[3][1] = 1;\\nL[3][2] = 0;\\nL[3][3] = 9;\\nL[3][4] = -9.0/2.0;\\nL[3][5] = 0;\\nL[3][6] = 0;\\nL[3][7] = 0;\\nL[3][8] = 0;\\nL[3][9] = 0;\\nL[3][10] = 0;\\nL[3][11] = 0;\\nL[4][0] = 1;\\nL[4][1] = -11.0/2.0;\\nL[4][2] = 0;\\nL[4][3] = -9.0/2.0;\\nL[4][4] = 9;\\nL[4][5] = 0;\\nL[4][6] = 0;\\nL[4][7] = 0;\\nL[4][8] = 0;\\nL[4][9] = 0;\\nL[4][10] = 0;\\nL[4][11] = 0;\\nL[5][0] = 0;\\nL[5][1] = -11.0/2.0;\\nL[5][2] = 1;\\nL[5][3] = 0;\\nL[5][4] = 0;\\nL[5][5] = 9;\\nL[5][6] = -9.0/2.0;\\nL[5][7] = 0;\\nL[5][8] = 0;\\nL[5][9] = 0;\\nL[5][10] = 0;\\nL[5][11] = 0;\\nL[6][0] = 0;\\nL[6][1] = 1;\\nL[6][2] = -11.0/2.0;\\nL[6][3] = 0;\\nL[6][4] = 0;\\nL[6][5] = -9.0/2.0;\\nL[6][6] = 9;\\nL[6][7] = 0;\\nL[6][8] = 0;\\nL[6][9] = 0;\\nL[6][10] = 0;\\nL[6][11] = 0;\\nL[7][0] = 1;\\nL[7][1] = 0;\\nL[7][2] = -11.0/2.0;\\nL[7][3] = 0;\\nL[7][4] = 0;\\nL[7][5] = 0;\\nL[7][6] = 0;\\nL[7][7] = 9;\\nL[7][8] = -9.0/2.0;\\nL[7][9] = 0;\\nL[7][10] = 0;\\nL[7][11] = 0;\\nL[8][0] = -11.0/2.0;\\nL[8][1] = 0;\\nL[8][2] = 1;\\nL[8][3] = 0;\\nL[8][4] = 0;\\nL[8][5] = 0;\\nL[8][6] = 0;\\nL[8][7] = -9.0/2.0;\\nL[8][8] = 9;\\nL[8][9] = 0;\\nL[8][10] = 0;\\nL[8][11] = 0;\\nL[9][0] = 379.0/448.0;\\nL[9][1] = 379.0/448.0;\\nL[9][2] = -65.0/448.0;\\nL[9][3] = -1683.0/224.0;\\nL[9][4] = -1683.0/224.0;\\nL[9][5] = 9.0/32.0;\\nL[9][6] = 171.0/224.0;\\nL[9][7] = 171.0/224.0;\\nL[9][8] = 9.0/32.0;\\nL[9][9] = 6885.0/448.0;\\nL[9][10] = -891.0/448.0;\\nL[9][11] = -891.0/448.0;\\nL[10][0] = -65.0/448.0;\\nL[10][1] = 379.0/448.0;\\nL[10][2] = 379.0/448.0;\\nL[10][3] = 171.0/224.0;\\nL[10][4] = 9.0/32.0;\\nL[10][5] = -1683.0/224.0;\\nL[10][6] = -1683.0/224.0;\\nL[10][7] = 9.0/32.0;\\nL[10][8] = 171.0/224.0;\\nL[10][9] = -891.0/448.0;\\nL[10][10] = 6885.0/448.0;\\nL[10][11] = -891.0/448.0;\\nL[11][0] = 379.0/448.0;\\nL[11][1] = -65.0/448.0;\\nL[11][2] = 379.0/448.0;\\nL[11][3] = 9.0/32.0;\\nL[11][4] = 171.0/224.0;\\nL[11][5] = 171.0/224.0;\\nL[11][6] = 9.0/32.0;\\nL[11][7] = -1683.0/224.0;\\nL[11][8] = -1683.0/224.0;\\nL[11][9] = -891.0/448.0;\\nL[11][10] = -891.0/448.0;\\nL[11][11] = 6885.0/448.0;'" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "73c54793", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "2d719cbc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'L[0][0] = 1;\\nL[0][1] = 0;\\nL[0][2] = 0;\\nL[0][3] = 0;\\nL[0][4] = 0;\\nL[0][5] = 0;\\nL[0][6] = 0;\\nL[0][7] = 0;\\nL[0][8] = 0;\\nL[0][9] = 0;\\nL[0][10] = 0;\\nL[0][11] = 0;\\nL[1][0] = 0;\\nL[1][1] = 1;\\nL[1][2] = 0;\\nL[1][3] = 0;\\nL[1][4] = 0;\\nL[1][5] = 0;\\nL[1][6] = 0;\\nL[1][7] = 0;\\nL[1][8] = 0;\\nL[1][9] = 0;\\nL[1][10] = 0;\\nL[1][11] = 0;\\nL[2][0] = 0;\\nL[2][1] = 0;\\nL[2][2] = 1;\\nL[2][3] = 0;\\nL[2][4] = 0;\\nL[2][5] = 0;\\nL[2][6] = 0;\\nL[2][7] = 0;\\nL[2][8] = 0;\\nL[2][9] = 0;\\nL[2][10] = 0;\\nL[2][11] = 0;\\nL[3][0] = -11.0/2.0;\\nL[3][1] = 1;\\nL[3][2] = 0;\\nL[3][3] = 9;\\nL[3][4] = -9.0/2.0;\\nL[3][5] = 0;\\nL[3][6] = 0;\\nL[3][7] = 0;\\nL[3][8] = 0;\\nL[3][9] = 0;\\nL[3][10] = 0;\\nL[3][11] = 0;\\nL[4][0] = 1;\\nL[4][1] = -11.0/2.0;\\nL[4][2] = 0;\\nL[4][3] = -9.0/2.0;\\nL[4][4] = 9;\\nL[4][5] = 0;\\nL[4][6] = 0;\\nL[4][7] = 0;\\nL[4][8] = 0;\\nL[4][9] = 0;\\nL[4][10] = 0;\\nL[4][11] = 0;\\nL[5][0] = 0;\\nL[5][1] = -11.0/2.0;\\nL[5][2] = 1;\\nL[5][3] = 0;\\nL[5][4] = 0;\\nL[5][5] = 9;\\nL[5][6] = -9.0/2.0;\\nL[5][7] = 0;\\nL[5][8] = 0;\\nL[5][9] = 0;\\nL[5][10] = 0;\\nL[5][11] = 0;\\nL[6][0] = 0;\\nL[6][1] = 1;\\nL[6][2] = -11.0/2.0;\\nL[6][3] = 0;\\nL[6][4] = 0;\\nL[6][5] = -9.0/2.0;\\nL[6][6] = 9;\\nL[6][7] = 0;\\nL[6][8] = 0;\\nL[6][9] = 0;\\nL[6][10] = 0;\\nL[6][11] = 0;\\nL[7][0] = 1;\\nL[7][1] = 0;\\nL[7][2] = -11.0/2.0;\\nL[7][3] = 0;\\nL[7][4] = 0;\\nL[7][5] = 0;\\nL[7][6] = 0;\\nL[7][7] = 9;\\nL[7][8] = -9.0/2.0;\\nL[7][9] = 0;\\nL[7][10] = 0;\\nL[7][11] = 0;\\nL[8][0] = -11.0/2.0;\\nL[8][1] = 0;\\nL[8][2] = 1;\\nL[8][3] = 0;\\nL[8][4] = 0;\\nL[8][5] = 0;\\nL[8][6] = 0;\\nL[8][7] = -9.0/2.0;\\nL[8][8] = 9;\\nL[8][9] = 0;\\nL[8][10] = 0;\\nL[8][11] = 0;\\nL[9][0] = 379.0/448.0;\\nL[9][1] = 379.0/448.0;\\nL[9][2] = -65.0/448.0;\\nL[9][3] = -1683.0/224.0;\\nL[9][4] = -1683.0/224.0;\\nL[9][5] = 9.0/32.0;\\nL[9][6] = 171.0/224.0;\\nL[9][7] = 171.0/224.0;\\nL[9][8] = 9.0/32.0;\\nL[9][9] = 6885.0/448.0;\\nL[9][10] = -891.0/448.0;\\nL[9][11] = -891.0/448.0;\\nL[10][0] = -65.0/448.0;\\nL[10][1] = 379.0/448.0;\\nL[10][2] = 379.0/448.0;\\nL[10][3] = 171.0/224.0;\\nL[10][4] = 9.0/32.0;\\nL[10][5] = -1683.0/224.0;\\nL[10][6] = -1683.0/224.0;\\nL[10][7] = 9.0/32.0;\\nL[10][8] = 171.0/224.0;\\nL[10][9] = -891.0/448.0;\\nL[10][10] = 6885.0/448.0;\\nL[10][11] = -891.0/448.0;\\nL[11][0] = 379.0/448.0;\\nL[11][1] = -65.0/448.0;\\nL[11][2] = 379.0/448.0;\\nL[11][3] = 9.0/32.0;\\nL[11][4] = 171.0/224.0;\\nL[11][5] = 171.0/224.0;\\nL[11][6] = 9.0/32.0;\\nL[11][7] = -1683.0/224.0;\\nL[11][8] = -1683.0/224.0;\\nL[11][9] = -891.0/448.0;\\nL[11][10] = -891.0/448.0;\\nL[11][11] = 6885.0/448.0;'" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ddb29d77", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -6353,7 +6332,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.1" + "version": "3.11.5" } }, "nbformat": 4, diff --git a/src/clough_tocher_patches/clough_tocher_autogen_constraint_matrices.hpp b/src/clough_tocher_patches/clough_tocher_autogen_constraint_matrices.hpp index 5576ddb..3caaefb 100644 --- a/src/clough_tocher_patches/clough_tocher_autogen_constraint_matrices.hpp +++ b/src/clough_tocher_patches/clough_tocher_autogen_constraint_matrices.hpp @@ -234,7 +234,7 @@ inline void L_d2L_dep_matrix(double L[7][12]) { L[6][11] = 4.0 / 81.0; } -inline void c_e(double c[5]) { +inline void c_e_matrix(double c[5]) { c[0] = 3 / 2; c[1] = -3 / 2; c[2] = 1 / 4; diff --git a/src/clough_tocher_patches/clough_tocher_constraint_matrices.cpp b/src/clough_tocher_patches/clough_tocher_constraint_matrices.cpp new file mode 100644 index 0000000..6fae5b9 --- /dev/null +++ b/src/clough_tocher_patches/clough_tocher_constraint_matrices.cpp @@ -0,0 +1,42 @@ +#include "clough_tocher_constraint_matrices.hpp" +#include "clough_tocher_autogen_constraint_matrices.hpp" + +Eigen::Matrix L_L2d_ind_m() { + double L[12][12]; + L_L2d_ind_matrix(L); + Eigen::Matrix L_L2d_ind_mat; + + for (int i = 0; i < 12; ++i) { + for (int j = 0; j < 12; ++j) { + L_L2d_ind_mat(i, j) = L[i][j]; + } + } + + return L_L2d_ind_mat; +} + +Eigen::Matrix L_d2L_dep_m() { + double L[7][12]; + L_d2L_dep_matrix(L); + Eigen::Matrix L_d2L_dep_mat; + + for (int i = 0; i < 7; ++i) { + for (int j = 0; j < 12; ++j) { + L_d2L_dep_mat(i, j) = L[i][j]; + } + } + + return L_d2L_dep_mat; +} + +Eigen::Matrix c_e_m() { + double c[5]; + c_e_matrix(c); + Eigen::Matrix c_e_mat; + + for (int i = 0; i < 5; ++i) { + c_e_mat[i] = c[i]; + } + + return c_e_mat; +} \ No newline at end of file diff --git a/src/clough_tocher_patches/clough_tocher_constraint_matrices.hpp b/src/clough_tocher_patches/clough_tocher_constraint_matrices.hpp new file mode 100644 index 0000000..2c8a2d5 --- /dev/null +++ b/src/clough_tocher_patches/clough_tocher_constraint_matrices.hpp @@ -0,0 +1,6 @@ +#pragma once +#include "common.h" + +Eigen::Matrix L_L2d_ind_m(); +Eigen::Matrix L_d2L_dep_m(); +Eigen::Matrix c_e_m(); \ No newline at end of file diff --git a/src/clough_tocher_patches/clough_tocher_patch.hpp b/src/clough_tocher_patches/clough_tocher_patch.hpp index 697e6cd..81d6e50 100644 --- a/src/clough_tocher_patches/clough_tocher_patch.hpp +++ b/src/clough_tocher_patches/clough_tocher_patch.hpp @@ -30,7 +30,7 @@ class CloughTocherPatch { std::array, 3> get_coeffs() const; -private: +public: // std::array, 3> m_boundary_data; std::array m_corner_data; diff --git a/src/clough_tocher_patches/clough_tocher_surface.cpp b/src/clough_tocher_patches/clough_tocher_surface.cpp index 258d057..50c3a67 100644 --- a/src/clough_tocher_patches/clough_tocher_surface.cpp +++ b/src/clough_tocher_patches/clough_tocher_surface.cpp @@ -4,6 +4,8 @@ #include #include +#include "clough_tocher_constraint_matrices.hpp" + CloughTocherSurface::CloughTocherSurface() {} CloughTocherSurface::CloughTocherSurface( @@ -533,3 +535,55 @@ void CloughTocherSurface:: // v_map_file << pair.first << " " << pair.second << std::endl; // } } + +void CloughTocherSurface::P_G2F(Eigen::SparseMatrix &m) { + const auto N_L = m_affine_manifold.m_lagrange_nodes.size(); + const auto F_cnt = m_affine_manifold.m_face_charts.size(); + + m.resize(19 * F_cnt, N_L); + + std::vector> triplets; + + const auto &face_charts = m_affine_manifold.m_face_charts; + for (size_t i = 0; i < face_charts.size(); ++i) { + for (int j = 0; j < 19; ++j) { + triplets.emplace_back(i * 19 + j, face_charts[i].lagrange_nodes[j], 1); + } + } + + m.setFromTriplets(triplets.begin(), triplets.end()); +} + +void CloughTocherSurface::C_L_int(Eigen::Matrix &m) { + Eigen::Matrix L_L2d_ind = L_L2d_ind_m(); + Eigen::Matrix L_d2L_dep = L_d2L_dep_m(); + + Eigen::Matrix neg_L_dot_L = -L_d2L_dep * L_L2d_ind; + m.block<7, 12>(0, 0) = neg_L_dot_L; + m.block<7, 7>(0, 12) = Eigen::MatrixXd::Identity(7, 7); +} + +void CloughTocherSurface::C_F_int(Eigen::SparseMatrix &m) { + const auto N_L = m_affine_manifold.m_lagrange_nodes.size(); + const auto F_cnt = m_affine_manifold.m_face_charts.size(); + + Eigen::SparseMatrix p_g2f; + P_G2F(p_g2f); + Eigen::Matrix c_l_int; + C_L_int(c_l_int); + + Eigen::SparseMatrix C_diag; + C_diag.resize(7 * F_cnt, 19 * F_cnt); + + for (size_t i = 0; i < F_cnt; ++i) { + for (int j = 0; j < 7; ++j) { + for (int k = 0; k < 19; ++k) { + C_diag.insert(i * 7 + j, i * 19 + k) = c_l_int(j, k); + } + } + } + + m.resize(7 * F_cnt, N_L); + + m = C_diag * p_g2f; +} diff --git a/src/clough_tocher_patches/clough_tocher_surface.hpp b/src/clough_tocher_patches/clough_tocher_surface.hpp index 901d7bc..734fba6 100644 --- a/src/clough_tocher_patches/clough_tocher_surface.hpp +++ b/src/clough_tocher_patches/clough_tocher_surface.hpp @@ -30,15 +30,23 @@ class CloughTocherSurface { void write_cubic_surface_to_msh_with_conn_from_lagrange_nodes( std::string filename); -private: +public: void generate_face_normals(const Eigen::MatrixXd &V, const AffineManifold &affine_manifold, Eigen::MatrixXd &N); -private: +public: std::vector m_patches; AffineManifold m_affine_manifold; std::vector> m_corner_data; std::vector> m_midpoint_data; + +public: + // constraint matrices + + // interior constraints + void P_G2F(Eigen::SparseMatrix &m); + void C_L_int(Eigen::Matrix &m); + void C_F_int(Eigen::SparseMatrix &m); }; \ No newline at end of file diff --git a/src/clough_tocher_patches/generate_ct_constraint_matrices.py b/src/clough_tocher_patches/generate_ct_constraint_matrices.py index a577df9..b04f716 100644 --- a/src/clough_tocher_patches/generate_ct_constraint_matrices.py +++ b/src/clough_tocher_patches/generate_ct_constraint_matrices.py @@ -33,7 +33,7 @@ file.write("}\n\n") # c_e -file.write("inline void c_e(double c[5]){\n") +file.write("inline void c_e_matrix(double c[5]){\n") for i in range(len(c_e)): file.write("c[{}] = {};\n".format(i, c_e[i])) file.write("}\n\n") From f1a90c9c38ccf0ad9aa1cd4473785ea77ff47d8f Mon Sep 17 00:00:00 2001 From: JcDai Date: Fri, 3 Jan 2025 03:11:25 -0500 Subject: [PATCH 10/11] add assertion --- .../clough_tocher_surface.cpp | 16 +++++++++------- src/core/affine_manifold.cpp | 8 ++++++-- src/exec/generate_cubic_surface.cpp | 9 +++++++++ 3 files changed, 24 insertions(+), 9 deletions(-) diff --git a/src/clough_tocher_patches/clough_tocher_surface.cpp b/src/clough_tocher_patches/clough_tocher_surface.cpp index 50c3a67..8492aae 100644 --- a/src/clough_tocher_patches/clough_tocher_surface.cpp +++ b/src/clough_tocher_patches/clough_tocher_surface.cpp @@ -452,7 +452,7 @@ void CloughTocherSurface:: b2 b0 bc b20 b02 b0c bc0 bc2 b2c b20^c */ - m_affine_manifold.generate_lagrange_nodes(); + // m_affine_manifold.generate_lagrange_nodes(); const auto &lagrange_nodes = m_affine_manifold.m_lagrange_nodes; // evaluate vertices @@ -485,7 +485,7 @@ void CloughTocherSurface:: file << "1 " << node_size << " 1 " << node_size << "\n"; file << "2 1 0 " << node_size << "\n"; - for (size_t i = 0; i < node_size; ++i) { + for (size_t i = 1; i <= node_size; ++i) { file << i << "\n"; } @@ -506,7 +506,7 @@ void CloughTocherSurface:: for (size_t i = 0; i < element_size; ++i) { file << i + 1 << " "; for (int j = 0; j < 10; ++j) { - file << faces[i][j] << " "; + file << faces[i][j] + 1 << " "; } file << "\n"; } @@ -530,10 +530,10 @@ void CloughTocherSurface:: // } // file << "$EndNodeData\n"; - // std::ofstream v_map_file(filename + "_input_v_to_output_v_map.txt"); - // for (const auto &pair : v_to_v_map) { - // v_map_file << pair.first << " " << pair.second << std::endl; - // } + std::ofstream v_map_file(filename + "_input_v_to_output_v_map.txt"); + for (const auto &pair : m_affine_manifold.v_to_lagrange_node_map) { + v_map_file << pair.first << " " << pair.second << std::endl; + } } void CloughTocherSurface::P_G2F(Eigen::SparseMatrix &m) { @@ -584,6 +584,8 @@ void CloughTocherSurface::C_F_int(Eigen::SparseMatrix &m) { } m.resize(7 * F_cnt, N_L); + std::cout << 7 * F_cnt << " " << N_L << std::endl; m = C_diag * p_g2f; + std::cout << m.rows() << " " << m.cols() << std::endl; } diff --git a/src/core/affine_manifold.cpp b/src/core/affine_manifold.cpp index 03595a5..479250c 100644 --- a/src/core/affine_manifold.cpp +++ b/src/core/affine_manifold.cpp @@ -1148,6 +1148,10 @@ void AffineManifold::generate_lagrange_nodes() { // TODO: // maybe outside this loop } + + assert(m_lagrange_nodes.size() == 10 * m_face_charts.size() + + 2 * m_edge_charts.size() + + m_vertex_charts.size()); } /* @@ -1157,8 +1161,8 @@ get constraint matrices void AffineManifold::get_u_ij(Eigen::SparseMatrix &u_ij_u, Eigen::SparseMatrix &u_ij_v) const { const int64_t N_L = m_lagrange_nodes.size(); - assert(N_L == 10 * m_face_charts.size() + 2 * m_edge_charts.size() + - m_vertex_charts.size()); + assert(size_t(N_L) == 10 * m_face_charts.size() + 2 * m_edge_charts.size() + + m_vertex_charts.size()); u_ij_u.resize(N_L, N_L); u_ij_v.resize(N_L, N_L); diff --git a/src/exec/generate_cubic_surface.cpp b/src/exec/generate_cubic_surface.cpp index 5de09da..b8505f6 100644 --- a/src/exec/generate_cubic_surface.cpp +++ b/src/exec/generate_cubic_surface.cpp @@ -6,6 +6,7 @@ #include "globals.cpp" #include "twelve_split_spline.h" #include +#include #include #include @@ -66,6 +67,8 @@ int main(int argc, char *argv[]) { fit_matrix, energy_hessian, energy_hessian_inverse); + ct_surface.m_affine_manifold.generate_lagrange_nodes(); + ct_surface.write_coeffs_to_obj("test_cubic_points.obj"); ct_surface.sample_to_obj("test_sample_cubic_points.obj", 25); @@ -76,5 +79,11 @@ int main(int argc, char *argv[]) { ct_surface.write_cubic_surface_to_msh_with_conn_from_lagrange_nodes( "icosphere_from_lagrange_nodes"); + Eigen::SparseMatrix c_f_int; + ct_surface.C_F_int(c_f_int); + + std::ofstream file("interior_constraint_matrix.txt"); + file << c_f_int; + return 0; } From a7883dede00b745c3bc533ddb5f22c73f202cc3d Mon Sep 17 00:00:00 2001 From: JcDai Date: Fri, 3 Jan 2025 21:02:30 -0500 Subject: [PATCH 11/11] all constraints --- .vscode/settings.json | 63 ++- .../clough_tocher_surface.cpp | 377 +++++++++++++++++- .../clough_tocher_surface.hpp | 7 + src/exec/generate_cubic_surface.cpp | 23 +- 4 files changed, 466 insertions(+), 4 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index c9e7e2e..f9fe157 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -7,6 +7,67 @@ "string": "cpp", "string_view": "cpp", "unordered_map": "cpp", - "unordered_set": "cpp" + "unordered_set": "cpp", + "__bit_reference": "cpp", + "__config": "cpp", + "__debug": "cpp", + "__errc": "cpp", + "__hash_table": "cpp", + "__locale": "cpp", + "__mutex_base": "cpp", + "__node_handle": "cpp", + "__split_buffer": "cpp", + "__threading_support": "cpp", + "__tree": "cpp", + "__verbose_abort": "cpp", + "atomic": "cpp", + "bitset": "cpp", + "cctype": "cpp", + "cfenv": "cpp", + "charconv": "cpp", + "clocale": "cpp", + "cmath": "cpp", + "complex": "cpp", + "condition_variable": "cpp", + "cstdarg": "cpp", + "cstddef": "cpp", + "cstdint": "cpp", + "cstdio": "cpp", + "cstdlib": "cpp", + "cstring": "cpp", + "ctime": "cpp", + "cwchar": "cpp", + "cwctype": "cpp", + "deque": "cpp", + "exception": "cpp", + "forward_list": "cpp", + "fstream": "cpp", + "future": "cpp", + "initializer_list": "cpp", + "iomanip": "cpp", + "ios": "cpp", + "iosfwd": "cpp", + "iostream": "cpp", + "istream": "cpp", + "limits": "cpp", + "list": "cpp", + "locale": "cpp", + "mutex": "cpp", + "new": "cpp", + "optional": "cpp", + "ostream": "cpp", + "queue": "cpp", + "ratio": "cpp", + "regex": "cpp", + "sstream": "cpp", + "stack": "cpp", + "stdexcept": "cpp", + "streambuf": "cpp", + "system_error": "cpp", + "thread": "cpp", + "tuple": "cpp", + "typeinfo": "cpp", + "variant": "cpp", + "algorithm": "cpp" } } \ No newline at end of file diff --git a/src/clough_tocher_patches/clough_tocher_surface.cpp b/src/clough_tocher_patches/clough_tocher_surface.cpp index 8492aae..900691f 100644 --- a/src/clough_tocher_patches/clough_tocher_surface.cpp +++ b/src/clough_tocher_patches/clough_tocher_surface.cpp @@ -490,8 +490,8 @@ void CloughTocherSurface:: } for (size_t i = 0; i < node_size; ++i) { - file << vertices[i][0] << " " << vertices[i][1] << " " << vertices[i][2] - << "\n"; + file << std::setprecision(16) << vertices[i][0] << " " << vertices[i][1] + << " " << vertices[i][2] << "\n"; } file << "$EndNodes\n"; @@ -589,3 +589,376 @@ void CloughTocherSurface::C_F_int(Eigen::SparseMatrix &m) { m = C_diag * p_g2f; std::cout << m.rows() << " " << m.cols() << std::endl; } + +void CloughTocherSurface::P_G2E(Eigen::SparseMatrix &m) { + const auto N_L = m_affine_manifold.m_lagrange_nodes.size(); + const auto E_cnt = m_affine_manifold.m_edge_charts.size(); + + m.resize(24 * E_cnt, N_L); + + const auto &e_charts = m_affine_manifold.m_edge_charts; + const auto &f_charts = m_affine_manifold.m_face_charts; + + std::vector> triplets; + for (size_t i = 0; i < e_charts.size(); ++i) { + const auto &top_face_idx = e_charts[i].top_face_index; + const auto &bottom_face_idx = e_charts[i].bottom_face_index; + for (int j = 0; j < 12; ++j) { + triplets.emplace_back(i * 24 + j, + f_charts[top_face_idx].lagrange_nodes[j], 1); + triplets.emplace_back(i * 24 + 12 + j, + f_charts[bottom_face_idx].lagrange_nodes[j], 1); + } + } + + m.setFromTriplets(triplets.begin(), triplets.end()); +} + +std::array P_dE_helper(int a, int b) { + int hash = a * 10 + b; + + // p0 p1 p2 d01 d10 d12 d21 d20 d02 h01 h12 h20 + + switch (hash) { + case 1: + // 01 + return {{3, 8, 4, 5}}; + case 12: + // 12 + return {{5, 4, 6, 7}}; + case 20: + // 20 + return {{7, 6, 8, 3}}; + case 10: + // 10 + return {{4, 5, 3, 8}}; + case 21: + // 21 + return {{6, 7, 5, 4}}; + case 2: + // 02 + return {{8, 3, 7, 6}}; + default: + break; + } + + return {{-1, -1, -1, -1}}; +} + +void CloughTocherSurface::C_E_end(Eigen::SparseMatrix &m) { + const auto N_L = m_affine_manifold.m_lagrange_nodes.size(); + const auto E_cnt = m_affine_manifold.m_edge_charts.size(); + + m.resize(2 * E_cnt, N_L); + + const auto &e_charts = m_affine_manifold.m_edge_charts; + // const auto &f_charts = m_affine_manifold.m_face_charts; + const auto &v_charts = m_affine_manifold.m_vertex_charts; + const auto &Fv = m_affine_manifold.get_faces(); + // const auto &Fv_uv = m_affine_manifold.get_F_uv(); + const auto &uvs = m_affine_manifold.get_global_uv(); + + const Eigen::Matrix L_L2d_ind = L_L2d_ind_m(); + Eigen::Matrix diag_L_L2d_ind; + diag_L_L2d_ind.setZero(); + diag_L_L2d_ind.block<12, 12>(0, 0) = L_L2d_ind; + diag_L_L2d_ind.block<12, 12>(12, 12) = L_L2d_ind; + + Eigen::SparseMatrix C_E_L; + C_E_L.resize(2 * E_cnt, 24 * E_cnt); + + for (size_t eid = 0; eid < e_charts.size(); ++eid) { + const auto &e = e_charts[eid]; + // T vertices + const int64_t v0 = e.left_global_uv_idx; + const int64_t v1 = e.right_global_uv_idx; + const int64_t v2 = e.top_global_uv_idx; + // T' vertices + const int64_t v0_prime = e.reverse_right_global_uv_idx; + const int64_t v1_prime = e.reverse_left_global_uv_idx; + const int64_t v2_prime = e.bottom_global_uv_idx; + + // T and T' + const auto &T = Fv.row(e.top_face_index); + const auto &T_prime = Fv.row(e.bottom_face_index); + + // u_ij + const auto u_01 = uvs.row(v1) - uvs.row(v0); + const auto u_02 = uvs.row(v2) - uvs.row(v0); + const auto u_12 = uvs.row(v2) - uvs.row(v1); + const auto u_10 = uvs.row(v0) - uvs.row(v1); + + // u_ij_prime + const auto u_01_prime = uvs.row(v1_prime) - uvs.row(v0_prime); + const auto u_02_prime = uvs.row(v2_prime) - uvs.row(v0_prime); + const auto u_12_prime = uvs.row(v2_prime) - uvs.row(v1_prime); + const auto u_10_prime = uvs.row(v0_prime) - uvs.row(v1_prime); + + // D0 D1 + Eigen::Matrix D0; + D0 << u_01[0], u_01[1], u_02[0], u_02[1]; + Eigen::Matrix D1; + D1 << u_12[0], u_12[1], u_10[0], u_10[1]; + + // D0_prime D1_prime + Eigen::Matrix D0_prime; + D0_prime << u_01_prime[0], u_01_prime[1], u_02_prime[0], u_02_prime[1]; + Eigen::Matrix D1_prime; + D1_prime << u_12_prime[0], u_12_prime[1], u_10_prime[0], u_10_prime[1]; + + // u_01_prep u_01_prep_prime + Eigen::Vector2d u_01_prep(-u_01[1], u_01[0]); + Eigen::Vector2d u_01_prep_prime(-u_01_prime[1], u_01_prime[0]); + + // g0 g1 + Eigen::Matrix g0 = u_01_prep.transpose() * D0.inverse(); + Eigen::Matrix g1 = u_01_prep.transpose() * D1.inverse(); + + // g0_prime g1_prime + Eigen::Matrix g0_prime = + u_01_prep_prime.transpose() * D0_prime.inverse(); + Eigen::Matrix g1_prime = + u_01_prep_prime.transpose() * D1_prime.inverse(); + + // C_dE(e) + Eigen::Matrix C_dE; + C_dE << g0(0, 0), g0(0, 1), -g0_prime(0, 0), -g0_prime(0, 1), 0, 0, 0, + 0, // v0 + 0, 0, 0, 0, g1(0, 0), g1(0, 1), -g1_prime(0, 0), -g1_prime(0, 1); // v1 + + // check cones and modify C_dE(e) + if (v_charts[e.left_vertex_index].is_cone) { + // v0 is cone + C_dE.row(0) << 1, 0, 0, 0, 0, 0, 0, 0; + } + if (v_charts[e.right_vertex_index].is_cone) { + // v1 is cone + C_dE.row(1) << 0, 0, 0, 0, 0, 0, 1, 0; + } + + // P_dE reindexing global dof to local index + Eigen::Matrix P_dE; + P_dE.setZero(); + + // v0 v1 local id in T + int64_t lid_0, lid_1 = -1; + for (int i = 0; i < 3; ++i) { + if (T[i] == e.left_vertex_index) { + lid_0 = i; + } + if (T[i] == e.right_vertex_index) { + lid_1 = i; + } + } + assert(lid_0 > -1 && lid_1 > -1); + + // v0_prime v1_prime local id in T' + int64_t lid_0_prime, lid_1_prime = -1; + for (int i = 0; i < 3; ++i) { + if (T_prime[i] == e.right_vertex_index) { + lid_0_prime = i; + } + if (T_prime[i] == e.left_vertex_index) { + lid_1_prime = i; + } + } + assert(lid_0_prime > -1 && lid_1_prime > -1); + + // T and T' reindex + auto T_P_dE_indices = P_dE_helper(lid_0, lid_1); + auto T_prime_P_dE_indices = P_dE_helper(lid_0_prime, lid_1_prime); + + // assemble P_dE respect to [qL_int^T qL_int'^T] + P_dE(0, T_P_dE_indices[0]) = 1; // d01 + P_dE(1, T_P_dE_indices[1]) = 1; // d02 + P_dE(2, T_prime_P_dE_indices[2] + 12) = 1; // d10' + P_dE(3, T_prime_P_dE_indices[3] + 12) = 1; // d12' + P_dE(4, T_P_dE_indices[2]) = 1; // d10 + P_dE(5, T_P_dE_indices[3]) = 1; // d12 + P_dE(6, T_prime_P_dE_indices[0] + 12) = 1; // d01' + P_dE(7, T_prime_P_dE_indices[1] + 12) = 1; // d02' + + // C_E_L(e) + Eigen::Matrix C_E_L_e = C_dE * P_dE * diag_L_L2d_ind; + + // set C_E_L + for (int i = 0; i < 2; ++i) { + for (int j = 0; j < 24; ++j) { + C_E_L.insert(eid * 2 + i, eid * 24 + j) = C_E_L_e(i, j); + } + } + } + + Eigen::SparseMatrix p_g2e; + P_G2E(p_g2e); + + m = C_E_L * p_g2e; +} + +std::array P_dM_helper(int a, int b) { + int hash = a * 10 + b; + + // p0 p1 p2 d01 d10 d12 d21 d20 d02 h01 h12 h20 + + switch (hash) { + case 1: + // 01 + return {{0, 1, 3, 4, 9}}; + case 12: + // 12 + return {{1, 2, 5, 6, 10}}; + case 20: + // 20 + return {{2, 0, 7, 8, 11}}; + case 10: + // 10 + return {{1, 0, 4, 3, 9}}; + case 21: + // 21 + return {{2, 1, 6, 5, 10}}; + case 2: + // 02 + return {{0, 2, 8, 7, 11}}; + default: + break; + } + + assert(false); + + return {{-1, -1, -1, -1, -1}}; +} + +void CloughTocherSurface::C_E_mid(Eigen::SparseMatrix &m) { + const auto N_L = m_affine_manifold.m_lagrange_nodes.size(); + const auto E_cnt = m_affine_manifold.m_edge_charts.size(); + + m.resize(E_cnt, N_L); + + const auto &e_charts = m_affine_manifold.m_edge_charts; + // const auto &f_charts = m_affine_manifold.m_face_charts; + // const auto &v_charts = m_affine_manifold.m_vertex_charts; + const auto &Fv = m_affine_manifold.get_faces(); + // const auto &Fv_uv = m_affine_manifold.get_F_uv(); + const auto &uvs = m_affine_manifold.get_global_uv(); + + const Eigen::Matrix L_L2d_ind = L_L2d_ind_m(); + Eigen::Matrix diag_L_L2d_ind; + diag_L_L2d_ind.setZero(); + diag_L_L2d_ind.block<12, 12>(0, 0) = L_L2d_ind; + diag_L_L2d_ind.block<12, 12>(12, 12) = L_L2d_ind; + + Eigen::Matrix c_h; + c_h << 0, 0, 0, 0, 1; + + Eigen::Matrix c_e = c_e_m(); + + Eigen::SparseMatrix C_M_L; + C_M_L.resize(E_cnt, 24 * E_cnt); + + for (size_t eid = 0; eid < e_charts.size(); ++eid) { + const auto &e = e_charts[eid]; + // T vertices + const int64_t v0 = e.left_global_uv_idx; + const int64_t v1 = e.right_global_uv_idx; + const int64_t v2 = e.top_global_uv_idx; + // T' vertices + const int64_t v0_prime = e.reverse_right_global_uv_idx; + const int64_t v1_prime = e.reverse_left_global_uv_idx; + const int64_t v2_prime = e.bottom_global_uv_idx; + + // T and T' + const auto &T = Fv.row(e.top_face_index); + const auto &T_prime = Fv.row(e.bottom_face_index); + + // u_ij + const auto u_01 = uvs.row(v1) - uvs.row(v0); + const auto u_02 = uvs.row(v2) - uvs.row(v0); + const auto u_12 = uvs.row(v2) - uvs.row(v1); + // const auto u_10 = uvs.row(v0) - uvs.row(v1); + + // u_ij_prime + const auto u_01_prime = uvs.row(v1_prime) - uvs.row(v0_prime); + const auto u_02_prime = uvs.row(v2_prime) - uvs.row(v0_prime); + const auto u_12_prime = uvs.row(v2_prime) - uvs.row(v1_prime); + // const auto u_10_prime = uvs.row(v0_prime) - uvs.row(v1_prime); + + // m01 and m01_prime + const auto m_01 = (u_02 + u_12) / 2.0; + const auto m_01_prime = (u_02_prime + u_12_prime) / 2.0; + + // u_01_prep u_01_prep_prime + Eigen::Vector2d u_01_prep(-u_01[1], u_01[0]); + Eigen::Vector2d u_01_prep_prime(-u_01_prime[1], u_01_prime[0]); + + // g_M and g_M_prime + Eigen::Matrix g_M; + g_M = (c_h - (m_01.dot(u_01.normalized())) * c_e).transpose() / + (m_01.dot(u_01_prep.normalized())); + Eigen::Matrix g_M_prime; + g_M_prime = + (c_h - (m_01_prime.dot(u_01_prime.normalized())) * c_e).transpose() / + (m_01_prime.dot(u_01_prep_prime.normalized())); + + // C_dM + Eigen::Matrix C_dM; + C_dM.block<1, 5>(0, 0) = g_M; + C_dM.block<1, 5>(0, 5) = g_M_prime; + + // P_dM + Eigen::Matrix P_dM; + P_dM.setZero(); + + // v0 v1 local id in T + int64_t lid_0, lid_1 = -1; + for (int i = 0; i < 3; ++i) { + if (T[i] == e.left_vertex_index) { + lid_0 = i; + } + if (T[i] == e.right_vertex_index) { + lid_1 = i; + } + } + assert(lid_0 > -1 && lid_1 > -1); + + // v0_prime v1_prime local id in T' + int64_t lid_0_prime, lid_1_prime = -1; + for (int i = 0; i < 3; ++i) { + if (T_prime[i] == e.right_vertex_index) { + lid_0_prime = i; + } + if (T_prime[i] == e.left_vertex_index) { + lid_1_prime = i; + } + } + assert(lid_0_prime > -1 && lid_1_prime > -1); + + // T and T' reindex + auto T_P_dM_indices = P_dM_helper(lid_0, lid_1); + auto T_prime_P_dM_indices = P_dM_helper(lid_0_prime, lid_1_prime); + + // assemble P_dM respect to [qL_int qL_int'] + P_dM(0, T_P_dM_indices[0]) = 1; // p0 + P_dM(1, T_P_dM_indices[1]) = 1; // p1 + P_dM(2, T_P_dM_indices[2]) = 1; // d01 + P_dM(3, T_P_dM_indices[3]) = 1; // d10 + P_dM(4, T_P_dM_indices[4]) = 1; // h01 + P_dM(5, T_prime_P_dM_indices[0]) = 1; // p0' + P_dM(6, T_prime_P_dM_indices[1]) = 1; // p1' + P_dM(7, T_prime_P_dM_indices[2]) = 1; // d01' + P_dM(8, T_prime_P_dM_indices[3]) = 1; // d10' + P_dM(9, T_prime_P_dM_indices[4]) = 1; // h01' + + // C_M_L_e + Eigen::Matrix C_M_L_e = C_dM * P_dM * diag_L_L2d_ind; + + // set C_M_L + for (int i = 0; i < 24; ++i) { + C_M_L.insert(eid, eid * 24 + i) = C_M_L_e(0, i); + } + } + + Eigen::SparseMatrix p_g2e; + P_G2E(p_g2e); + + m = C_M_L * p_g2e; +} diff --git a/src/clough_tocher_patches/clough_tocher_surface.hpp b/src/clough_tocher_patches/clough_tocher_surface.hpp index 734fba6..0829443 100644 --- a/src/clough_tocher_patches/clough_tocher_surface.hpp +++ b/src/clough_tocher_patches/clough_tocher_surface.hpp @@ -49,4 +49,11 @@ class CloughTocherSurface { void P_G2F(Eigen::SparseMatrix &m); void C_L_int(Eigen::Matrix &m); void C_F_int(Eigen::SparseMatrix &m); + + // edge endpoint constraints + void P_G2E(Eigen::SparseMatrix &m); + void C_E_end(Eigen::SparseMatrix &m); + + // edge midpoint constraints + void C_E_mid(Eigen::SparseMatrix &m); }; \ No newline at end of file diff --git a/src/exec/generate_cubic_surface.cpp b/src/exec/generate_cubic_surface.cpp index b8505f6..c112bfa 100644 --- a/src/exec/generate_cubic_surface.cpp +++ b/src/exec/generate_cubic_surface.cpp @@ -81,9 +81,30 @@ int main(int argc, char *argv[]) { Eigen::SparseMatrix c_f_int; ct_surface.C_F_int(c_f_int); + Eigen::SparseMatrix C_E_end; + ct_surface.C_E_end(C_E_end); + Eigen::SparseMatrix C_E_mid; + ct_surface.C_E_mid(C_E_mid); std::ofstream file("interior_constraint_matrix.txt"); - file << c_f_int; + file << std::setprecision(16) << c_f_int; + std::ofstream file_2("edge_endpoint_constraint_matrix.txt"); + file_2 << std::setprecision(16) << c_f_int; + std::ofstream file_3("edge_midpoint_constraint_matrix.txt"); + file_3 << std::setprecision(16) << c_f_int; + + file.close(); + file_2.close(); + file_3.close(); + + // std::ofstream file_4("interior_constraint_matrix_triplets.txt"); + // const auto trip1 = c_f_int.to_triplets(); + // std::ofstream file_5("edge_endpoint_constraint_matrix_triplets.txt"); + // std::ofstream file_6("edge_midpoint_constraint_matrix_triplets.txt"); + + // file_4.close(); + // file_5.close(); + // file_6.close(); return 0; }