From c6e14cda9edcee2afa0bb64b4180123804bc4acb Mon Sep 17 00:00:00 2001 From: Peter Munch Date: Sun, 11 Oct 2020 13:51:05 +0200 Subject: [PATCH] Generalize DataOut::write_vtu for simplex mesh --- source/base/data_out_base.cc | 272 ++++++++---- tests/simplex/data_out_write_vtu_01.cc | 121 +++++ ...rite_vtu_01.with_simplex_support=on.output | 417 ++++++++++++++++++ 3 files changed, 714 insertions(+), 96 deletions(-) create mode 100644 tests/simplex/data_out_write_vtu_01.cc create mode 100644 tests/simplex/data_out_write_vtu_01.with_simplex_support=on.output diff --git a/source/base/data_out_base.cc b/source/base/data_out_base.cc index 86fbe61c6c..a3979ee16c 100644 --- a/source/base/data_out_base.cc +++ b/source/base/data_out_base.cc @@ -52,6 +52,7 @@ // we use uint32_t and uint8_t below, which are declared here: #include +#include #ifdef DEAL_II_WITH_ZLIB # include @@ -585,6 +586,67 @@ namespace 72, // VTK_LAGRANGE_HEXAHEDRON static_cast(-1)}; + + /** + * Return the tuple (vtk cell type, number of cells, number of vertices) + * for a patch. + */ + template + std::array + extract_vtk_patch_info(const DataOutBase::Patch &patch, + const bool write_higher_order_cells) + { + std::array vtk_cell_id{}; + + if (write_higher_order_cells && + patch.reference_cell_type == ReferenceCell::get_hypercube(dim)) + { + vtk_cell_id[0] = vtk_lagrange_cell_type[dim]; + vtk_cell_id[1] = 1; + } + else if (patch.reference_cell_type == ReferenceCell::Type::Tri && + patch.data.n_cols() == 3) + { + vtk_cell_id[0] = 5; + vtk_cell_id[1] = 1; + } + else if (patch.reference_cell_type == ReferenceCell::Type::Tri && + patch.data.n_cols() == 6) + { + vtk_cell_id[0] = 22; + vtk_cell_id[1] = 1; + } + else if (patch.reference_cell_type == ReferenceCell::Type::Tet && + patch.data.n_cols() == 4) + { + vtk_cell_id[0] = 10; + vtk_cell_id[1] = 1; + } + else if (patch.reference_cell_type == ReferenceCell::Type::Tet && + patch.data.n_cols() == 10) + { + vtk_cell_id[0] = 24; + vtk_cell_id[1] = 1; + } + else if (patch.reference_cell_type == ReferenceCell::get_hypercube(dim)) + { + vtk_cell_id[0] = vtk_cell_type[dim]; + vtk_cell_id[1] = Utilities::pow(patch.n_subdivisions, dim); + } + else + { + Assert(false, ExcNotImplemented()); + } + + if (patch.reference_cell_type != ReferenceCell::get_hypercube(dim) || + write_higher_order_cells) + vtk_cell_id[2] = patch.data.n_cols(); + else + vtk_cell_id[2] = GeometryInfo::vertices_per_cell; + + return vtk_cell_id; + } + //----------------------------------------------------------------------// // Auxiliary functions //----------------------------------------------------------------------// @@ -828,6 +890,48 @@ namespace } } + template + static void + compute_sizes(const std::vector> &patches, + const bool write_higher_order_cells, + unsigned int &n_nodes, + unsigned int &n_cells, + unsigned int &n_points_and_n_cells) + { + n_nodes = 0; + n_cells = 0; + n_points_and_n_cells = 0; + + for (const auto &patch : patches) + { + // The following formulas don't hold for non-tensor products. + if (patch.reference_cell_type == ReferenceCell::get_hypercube(dim)) + { + n_nodes += Utilities::fixed_power(patch.n_subdivisions + 1); + + if (write_higher_order_cells) + { + n_cells += 1; + n_points_and_n_cells += + 1 + Utilities::fixed_power(patch.n_subdivisions + 1); + } + else + { + n_cells += Utilities::fixed_power(patch.n_subdivisions); + n_points_and_n_cells += + Utilities::fixed_power(patch.n_subdivisions) * + (1 + GeometryInfo::vertices_per_cell); + } + } + else + { + n_nodes += patch.data.n_cols(); + n_cells += 1; + n_points_and_n_cells += patch.data.n_cols() + 1; + } + } + } + /** * Class describing common functionality between different output streams. * @@ -1169,6 +1273,14 @@ namespace const unsigned int y_offset, const unsigned int z_offset); + /** + * Print vertices [start, start+n_points[ + */ + void + write_cell_single(const unsigned int index, + const unsigned int start, + const unsigned int n_points); + /** * Write a high-order cell type, i.e., a Lagrange cell * in the VTK terminology. @@ -1627,6 +1739,23 @@ namespace #endif } + void + VtuStream::write_cell_single(const unsigned int index, + const unsigned int start, + const unsigned int n_points) + { + (void)index; + +#if !defined(DEAL_II_WITH_ZLIB) + for (unsigned int i = 0; i < n_points; ++i) + stream << '\t' << start + i; + stream << '\n'; +#else + for (unsigned int i = 0; i < n_points; ++i) + cells.push_back(start + i); +#endif + } + template void VtuStream::write_high_order_cell(const unsigned int, @@ -4950,40 +5079,12 @@ namespace DataOutBase } // first count the number of cells and cells for later use - unsigned int n_nodes = 0; - unsigned int n_cells = 0; - unsigned int n_points_an_n_cell = 0; - - // compute_sizes(patches, n_nodes, n_cells); - - for (const auto &patch : patches) - { - // The following formulas don't hold for non-tensor products. - if (patch.reference_cell_type == ReferenceCell::get_hypercube(dim)) - { - n_nodes += Utilities::fixed_power(patch.n_subdivisions + 1); - - if (flags.write_higher_order_cells) - { - n_cells += 1; - n_points_an_n_cell += - 1 + Utilities::fixed_power(patch.n_subdivisions + 1); - } - else - { - n_cells += Utilities::fixed_power(patch.n_subdivisions); - n_points_an_n_cell += - Utilities::fixed_power(patch.n_subdivisions) * - (1 + GeometryInfo::vertices_per_cell); - } - } - else - { - n_nodes += patch.data.n_cols(); - n_cells += 1; - n_points_an_n_cell += patch.data.n_cols() + 1; - } - } + unsigned int n_nodes, n_cells, n_points_and_n_cells; + compute_sizes(patches, + flags.write_higher_order_cells, + n_nodes, + n_cells, + n_points_and_n_cells); // in gmv format the vertex coordinates and the data have an order that is a // bit unpleasant (first all x coordinates, then all y coordinate, ...; @@ -5014,7 +5115,7 @@ namespace DataOutBase out << '\n'; ///////////////////////////////// // now for the cells - out << "CELLS " << n_cells << ' ' << n_points_an_n_cell << '\n'; + out << "CELLS " << n_cells << ' ' << n_points_and_n_cells << '\n'; if (flags.write_higher_order_cells) write_high_order_cells(patches, vtk_out); else @@ -5028,33 +5129,11 @@ namespace DataOutBase // quadratic), and high order cells for (const auto &patch : patches) { - std::pair vtk_cell_id = {-1, -1}; - - if (flags.write_higher_order_cells && - patch.reference_cell_type == ReferenceCell::get_hypercube(dim)) - vtk_cell_id = {vtk_lagrange_cell_type[dim], 1}; - else if (patch.reference_cell_type == ReferenceCell::Type::Tri && - patch.data.n_cols() == 3) - vtk_cell_id = {5, 1}; - else if (patch.reference_cell_type == ReferenceCell::Type::Tri && - patch.data.n_cols() == 6) - vtk_cell_id = {22, 1}; - else if (patch.reference_cell_type == ReferenceCell::Type::Tet && - patch.data.n_cols() == 4) - vtk_cell_id = {10, 1}; - else if (patch.reference_cell_type == ReferenceCell::Type::Tet && - patch.data.n_cols() == 10) - vtk_cell_id = {24, 1}; - else if (patch.reference_cell_type == ReferenceCell::get_hypercube(dim)) - vtk_cell_id = {vtk_cell_type[dim], - Utilities::pow(patch.n_subdivisions, dim)}; - else - { - Assert(false, ExcNotImplemented()); - } + const auto vtk_cell_id = + extract_vtk_patch_info(patch, flags.write_higher_order_cells); - for (unsigned int i = 0; i < vtk_cell_id.second; ++i) - out << ' ' << vtk_cell_id.first; + for (unsigned int i = 0; i < vtk_cell_id[1]; ++i) + out << ' ' << vtk_cell_id[0]; } out << '\n'; @@ -5362,25 +5441,17 @@ namespace DataOutBase #ifdef DEAL_II_WITH_ZLIB const char *ascii_or_binary = "binary"; #else - const char *ascii_or_binary = "ascii"; + const char * ascii_or_binary = "ascii"; #endif // first count the number of cells and cells for later use - unsigned int n_nodes; - unsigned int n_cells; - compute_sizes(patches, n_nodes, n_cells); - - // If a user set to output high order cells, we treat n_subdivisions - // as a cell order and adjust variables accordingly, otherwise - // each patch is written as a linear cell. - const unsigned int n_points_per_cell = - (flags.write_higher_order_cells == false ? - ReferenceCell::internal::Info::get_cell(patches[0].reference_cell_type) - .n_vertices() : - n_nodes / patches.size()); - if (flags.write_higher_order_cells) - n_cells = patches.size(); + unsigned int n_nodes, n_cells, n_points_and_n_cells; + compute_sizes(patches, + flags.write_higher_order_cells, + n_nodes, + n_cells, + n_points_and_n_cells); // in gmv format the vertex coordinates and the data have an order that is a // bit unpleasant (first all x coordinates, then all y coordinate, ...; @@ -5431,9 +5502,33 @@ namespace DataOutBase out << " \n"; - std::vector offsets(n_cells); - for (unsigned int i = 0; i < n_cells; ++i) - offsets[i] = (i + 1) * n_points_per_cell; + std::vector offsets; + offsets.reserve(n_cells); + + // uint8_t might be an alias to unsigned char which is then not printed + // as ascii integers +#ifdef DEAL_II_WITH_ZLIB + std::vector cell_types; +#else + std::vector cell_types; +#endif + cell_types.reserve(n_cells); + + unsigned int first_vertex_of_patch = 0; + + for (const auto &patch : patches) + { + const auto vtk_cell_id = + extract_vtk_patch_info(patch, flags.write_higher_order_cells); + + for (unsigned int i = 0; i < vtk_cell_id[1]; ++i) + { + cell_types.push_back(vtk_cell_id[0]); + first_vertex_of_patch += vtk_cell_id[2]; + offsets.push_back(first_vertex_of_patch); + } + } + vtu_out << offsets; out << "\n"; out << " \n"; @@ -5443,23 +5538,8 @@ namespace DataOutBase out << " \n"; - { - // need to distinguish between linear and high order cells - const unsigned int vtk_cell_id = flags.write_higher_order_cells ? - vtk_lagrange_cell_type[dim] : - vtk_cell_type[dim]; - - // uint8_t might be an alias to unsigned char which is then not printed - // as ascii integers -#ifdef DEAL_II_WITH_ZLIB - std::vector cell_types(n_cells, - static_cast(vtk_cell_id)); -#else - std::vector cell_types(n_cells, vtk_cell_id); -#endif - // this should compress well :-) - vtu_out << cell_types; - } + // this should compress well :-) + vtu_out << cell_types; out << "\n"; out << " \n"; out << " \n"; diff --git a/tests/simplex/data_out_write_vtu_01.cc b/tests/simplex/data_out_write_vtu_01.cc new file mode 100644 index 0000000000..aa197b2b20 --- /dev/null +++ b/tests/simplex/data_out_write_vtu_01.cc @@ -0,0 +1,121 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2020 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// Test DataOut::write_vtu() for simplex meshes. + +#include + +#include +#include + +#include +#include +#include + +#include +#include + +#include +#include + +#include "../tests.h" + +using namespace dealii; + +template +class RightHandSideFunction : public Function +{ +public: + RightHandSideFunction(const unsigned int n_components) + : Function(n_components) + {} + + virtual double + value(const Point &p, const unsigned int component = 0) const + { + return p[component % dim] * p[component % dim]; + } +}; + +template +void +test(const FiniteElement &fe, const unsigned int n_components) +{ + Triangulation tria; + GridGenerator::subdivided_hyper_cube_with_simplices(tria, dim == 2 ? 4 : 2); + + DoFHandler dof_handler(tria); + + dof_handler.distribute_dofs(fe); + + Vector solution(dof_handler.n_dofs()); + + MappingFE mapping(Simplex::FE_P(1)); + + VectorTools::interpolate(mapping, + dof_handler, + RightHandSideFunction(n_components), + solution); + + static unsigned int counter = 0; + + for (unsigned int n_subdivisions = 1; n_subdivisions <= 2; ++n_subdivisions) + { + DataOut data_out; + + data_out.attach_dof_handler(dof_handler); + data_out.add_data_vector(solution, "solution"); + + + data_out.build_patches(mapping, n_subdivisions); + + //#if false + std::ofstream output("test." + std::to_string(dim) + "." + + std::to_string(counter++) + ".vtu"); + data_out.write_vtu(output); + //#else + data_out.write_vtu(deallog.get_file_stream()); + //#endif + } +} + +int +main() +{ + initlog(); + + { + const unsigned int dim = 2; + test(Simplex::FE_P(2) /*=degree*/, 1); + test(FESystem(Simplex::FE_P(2 /*=degree*/), dim), dim); + test(FESystem(Simplex::FE_P(2 /*=degree*/), + dim, + Simplex::FE_P(1 /*=degree*/), + 1), + dim + 1); + } + { + const unsigned int dim = 3; + test(Simplex::FE_P(2) /*=degree*/, 1); + test(FESystem(Simplex::FE_P(2 /*=degree*/), dim), dim); + test(FESystem(Simplex::FE_P(2 /*=degree*/), + dim, + Simplex::FE_P(1 /*=degree*/), + 1), + dim + 1); + } +} diff --git a/tests/simplex/data_out_write_vtu_01.with_simplex_support=on.output b/tests/simplex/data_out_write_vtu_01.with_simplex_support=on.output new file mode 100644 index 0000000000..798a90e99e --- /dev/null +++ b/tests/simplex/data_out_write_vtu_01.with_simplex_support=on.output @@ -0,0 +1,417 @@ + + + + + + + + +AQAAAIAEAACABAAAlAAAAA==eNqNklEOgDAMQnsy4Wg9ulGzhRlY5s/iWyGDtEq/vsr+P6feKbdarHzeIXjCa/njY57wngza/vH5huCp87sexltfBs9T3qVDiA6ep7xLh5Ds8DzlXTqE9ADPT3qgcAae8pbTInhu8pbREt6Tm7xltB08dX7XQ+ueBM6DHlr3JHAe9NC6J4HzoIfWPQn8m78BMupZKQ== + + + + + +AQAAAIABAACAAQAAnQAAAA==eNoNw4c2QgEAANCnSJJVRsmmYUV2SLISQigz/v8v3HvODYIg6DFk2F77jNhv1AFjDhp3yGFHHHXMhEnHnXDSKVOmnTbjjLPOOe+Ciy657IpZc+YtuOqa6264adEtty2546577nvgoUeWPfbEUyueWfXcmhdeeuW1N9a9teGd9z7Y9NEnn2354qtvtu347oeffvntj11//fMfAccR0Q== + + +AQAAAIAAAACAAAAASQAAAA==eNoNw4EGg1AAAMBHRMSIiIiIEREREREREWPEiP3/V3THRSGE2MTUl5m5haWVtY1vWzt7B0cnZxdXN3cPTz9+vfx5+/cBGQ8GMQ== + + +AQAAACAAAAAgAAAACwAAAA==eNpjZcUPAApwAKE= + + + + +AQAAAIABAACAAQAAIgAAAA==eNpjYACBBlsGDBqM7bDQQCxgj0mD2VjoUfPxmQ8AfZ4z5Q== + + + + + + + + + + + +AQAAAAAJAAAACQAAPQEAAA==eNp1lNENAyEMQxmFSUhGYRSPdqNVXEuVOE6/OLCfLJwyRvxhDf0d95f4/mmjH0swFzGjRukt8+7ZEzRPwzleqGyWvYkZNULvlrNd7wz70zTHLWfAqszJzKgRelC2691hfzccUAasytzMjJqma9kf9V76uwyrXvDMWOWA1mhm4Hq5d8V5tSayGc2MVc7Ze5quIfjcu+K45Qx37TwzVjlOazQzcL3cu+KAMvzvimfGKgeWZ0Dec5x16r38335eF16Q1wUHtFb3HPncu+Kcc1fZLHtdcM75bLoegs+9K45bzuCCOYkZvbPpegg+9644oAwumJuY0TubruX7SL2X9/G+G8IL8kJwQGtvZgBN74rzvhsqm2UvBOdodtO1Cz73rjhuOQMEcxIzenfTtQs+9644oAwQzE3M6P2uP5vyviE= + + + + + +AQAAAAADAAAAAwAANwEAAA==eNoNwwdXiAEAAMDPCKFCkWjYMrJTRkj2pihE9kwoUkZWVvaWEiIlpCQi6a91994FQRD0sKe97G2IfexrP0Pt7wAHGma4EQ5ysEOMNMqhDjPa4cY4wpHGGme8CY5ytGMc6zjHO8GJJjrJyU5xqklOc7oznOksZzvHZOeaYqrznO8CF5rmIhe7xHSXmuEyl7vCla5ytWtc6zrXu8GNbnKzW8w0y61uM9sct7vDnea6y93muce97nO/BzzoIQ97xKMe87j5nrDAk57ytIUWecazFnvOEks97wUveskyL3vFq17zuuXe8Ka3vO0dK7zrPe/7wIc+8rFPfOozn/vCl76y0tdWWe0ba3zrO99b6wc/Wucn623ws41+8avfbPK7zbb4w1Z/2uYvf9vuH//a4T87/W+X3Qa4R6E= + + +AQAAAIAAAACAAAAAUQAAAA==eNoNwxEXg2AAAMCPoiiKRlEURVEUjaIoiqIoiqIoiqLRKBpF+2ndvXdRCCE2MfVlZm5haWVt49vWzt7B0cnZxdXN3cPTj18vf97+fQAxngxh + + +AQAAACAAAAAgAAAACwAAAA==eNoTE8MPAC2AAsE= + + + + +AQAAAAADAAAAAwAASgAAAA==eNpjYACBBlsGCG0DwShitghxMBuE7SC0gB0EI4s12CGJQ7GAPYQ+AcXIYiAaJg5ig8WhtAsUI4s1IImD2KPuH3U/+e4HADT8bmE= + + + + + + + + + + + +AQAAAIAEAACABAAAlAAAAA==eNqNklEOgDAMQnsy4Wg9ulGzhRlY5s/iWyGDtEq/vsr+P6feKbdarHzeIXjCa/njY57wngza/vH5huCp87sexltfBs9T3qVDiA6ep7xLh5Ds8DzlXTqE9ADPT3qgcAae8pbTInhu8pbREt6Tm7xltB08dX7XQ+ueBM6DHlr3JHAe9NC6J4HzoIfWPQn8m78BMupZKQ== + + + + + +AQAAAIABAACAAQAAnQAAAA==eNoNw4c2QgEAANCnSJJVRsmmYUV2SLISQigz/v8v3HvODYIg6DFk2F77jNhv1AFjDhp3yGFHHHXMhEnHnXDSKVOmnTbjjLPOOe+Ciy657IpZc+YtuOqa6264adEtty2546577nvgoUeWPfbEUyueWfXcmhdeeuW1N9a9teGd9z7Y9NEnn2354qtvtu347oeffvntj11//fMfAccR0Q== + + +AQAAAIAAAACAAAAASQAAAA==eNoNw4EGg1AAAMBHRMSIiIiIEREREREREWPEiP3/V3THRSGE2MTUl5m5haWVtY1vWzt7B0cnZxdXN3cPTz9+vfx5+/cBGQ8GMQ== + + +AQAAACAAAAAgAAAACwAAAA==eNpjZcUPAApwAKE= + + + + +AQAAAIABAACAAQAAIgAAAA==eNpjYACBBlsGDBqM7bDQQCxgj0mD2VjoUfPxmQ8AfZ4z5Q== + +AQAAAIABAACAAQAALAAAAA==eNpjYICBBlsERgaUisP5dkjYloriULaAPQIjq6FUHM5GwihqKBIHAJ0fM+U= + + + + + + + + + + + +AQAAAAAJAAAACQAAPQEAAA==eNp1lNENAyEMQxmFSUhGYRSPdqNVXEuVOE6/OLCfLJwyRvxhDf0d95f4/mmjH0swFzGjRukt8+7ZEzRPwzleqGyWvYkZNULvlrNd7wz70zTHLWfAqszJzKgRelC2691hfzccUAasytzMjJqma9kf9V76uwyrXvDMWOWA1mhm4Hq5d8V5tSayGc2MVc7Ze5quIfjcu+K45Qx37TwzVjlOazQzcL3cu+KAMvzvimfGKgeWZ0Dec5x16r38335eF16Q1wUHtFb3HPncu+Kcc1fZLHtdcM75bLoegs+9K45bzuCCOYkZvbPpegg+9644oAwumJuY0TubruX7SL2X9/G+G8IL8kJwQGtvZgBN74rzvhsqm2UvBOdodtO1Cz73rjhuOQMEcxIzenfTtQs+9644oAwQzE3M6P2uP5vyviE= + + + + + +AQAAAAADAAAAAwAANwEAAA==eNoNwwdXiAEAAMDPCKFCkWjYMrJTRkj2pihE9kwoUkZWVvaWEiIlpCQi6a91994FQRD0sKe97G2IfexrP0Pt7wAHGma4EQ5ysEOMNMqhDjPa4cY4wpHGGme8CY5ytGMc6zjHO8GJJjrJyU5xqklOc7oznOksZzvHZOeaYqrznO8CF5rmIhe7xHSXmuEyl7vCla5ytWtc6zrXu8GNbnKzW8w0y61uM9sct7vDnea6y93muce97nO/BzzoIQ97xKMe87j5nrDAk57ytIUWecazFnvOEks97wUveskyL3vFq17zuuXe8Ka3vO0dK7zrPe/7wIc+8rFPfOozn/vCl76y0tdWWe0ba3zrO99b6wc/Wucn623ws41+8avfbPK7zbb4w1Z/2uYvf9vuH//a4T87/W+X3Qa4R6E= + + +AQAAAIAAAACAAAAAUQAAAA==eNoNwxEXg2AAAMCPoiiKRlEURVEUjaIoiqIoiqIoiqLRKBpF+2ndvXdRCCE2MfVlZm5haWVt49vWzt7B0cnZxdXN3cPTj18vf97+fQAxngxh + + +AQAAACAAAAAgAAAACwAAAA==eNoTE8MPAC2AAsE= + + + + +AQAAAAADAAAAAwAASgAAAA==eNpjYACBBlsGCG0DwShitghxMBuE7SC0gB0EI4s12CGJQ7GAPYQ+AcXIYiAaJg5ig8WhtAsUI4s1IImD2KPuH3U/+e4HADT8bmE= + +AQAAAAADAAAAAwAASgAAAA==eNrNisENACAIxBiBgQQ/DnbjOZYxHMoIkDQNzYnkwehBrDT7vds+OzysHsB/g5febU90hje5f7br7N32r9OLoDSU3mt/AIlvbmE= + + + + + + + + + + + +AQAAAIAEAACABAAAlAAAAA==eNqNklEOgDAMQnsy4Wg9ulGzhRlY5s/iWyGDtEq/vsr+P6feKbdarHzeIXjCa/njY57wngza/vH5huCp87sexltfBs9T3qVDiA6ep7xLh5Ds8DzlXTqE9ADPT3qgcAae8pbTInhu8pbREt6Tm7xltB08dX7XQ+ueBM6DHlr3JHAe9NC6J4HzoIfWPQn8m78BMupZKQ== + + + + + +AQAAAIABAACAAQAAnQAAAA==eNoNw4c2QgEAANCnSJJVRsmmYUV2SLISQigz/v8v3HvODYIg6DFk2F77jNhv1AFjDhp3yGFHHHXMhEnHnXDSKVOmnTbjjLPOOe+Ciy657IpZc+YtuOqa6264adEtty2546577nvgoUeWPfbEUyueWfXcmhdeeuW1N9a9teGd9z7Y9NEnn2354qtvtu347oeffvntj11//fMfAccR0Q== + + +AQAAAIAAAACAAAAASQAAAA==eNoNw4EGg1AAAMBHRMSIiIiIEREREREREWPEiP3/V3THRSGE2MTUl5m5haWVtY1vWzt7B0cnZxdXN3cPTz9+vfx5+/cBGQ8GMQ== + + +AQAAACAAAAAgAAAACwAAAA==eNpjZcUPAApwAKE= + + + + +AQAAAIABAACAAQAAIgAAAA==eNpjYACBBlsGDBqM7bDQQCxgj0mD2VjoUfPxmQ8AfZ4z5Q== + +AQAAAIABAACAAQAALAAAAA==eNpjYICBBlsERgaUisP5dkjYloriULaAPQIjq6FUHM5GwihqKBIHAJ0fM+U= + +AQAAAIABAACAAQAAIgAAAA==eNpjYACBBlsGDBqM7bDQQCxgj0mD2VjoUfPxmQ8AfZ4z5Q== + + + + + + + + + + + +AQAAAAAJAAAACQAAPQEAAA==eNp1lNENAyEMQxmFSUhGYRSPdqNVXEuVOE6/OLCfLJwyRvxhDf0d95f4/mmjH0swFzGjRukt8+7ZEzRPwzleqGyWvYkZNULvlrNd7wz70zTHLWfAqszJzKgRelC2691hfzccUAasytzMjJqma9kf9V76uwyrXvDMWOWA1mhm4Hq5d8V5tSayGc2MVc7Ze5quIfjcu+K45Qx37TwzVjlOazQzcL3cu+KAMvzvimfGKgeWZ0Dec5x16r38335eF16Q1wUHtFb3HPncu+Kcc1fZLHtdcM75bLoegs+9K45bzuCCOYkZvbPpegg+9644oAwumJuY0TubruX7SL2X9/G+G8IL8kJwQGtvZgBN74rzvhsqm2UvBOdodtO1Cz73rjhuOQMEcxIzenfTtQs+9644oAwQzE3M6P2uP5vyviE= + + + + + +AQAAAAADAAAAAwAANwEAAA==eNoNwwdXiAEAAMDPCKFCkWjYMrJTRkj2pihE9kwoUkZWVvaWEiIlpCQi6a91994FQRD0sKe97G2IfexrP0Pt7wAHGma4EQ5ysEOMNMqhDjPa4cY4wpHGGme8CY5ytGMc6zjHO8GJJjrJyU5xqklOc7oznOksZzvHZOeaYqrznO8CF5rmIhe7xHSXmuEyl7vCla5ytWtc6zrXu8GNbnKzW8w0y61uM9sct7vDnea6y93muce97nO/BzzoIQ97xKMe87j5nrDAk57ytIUWecazFnvOEks97wUveskyL3vFq17zuuXe8Ka3vO0dK7zrPe/7wIc+8rFPfOozn/vCl76y0tdWWe0ba3zrO99b6wc/Wucn623ws41+8avfbPK7zbb4w1Z/2uYvf9vuH//a4T87/W+X3Qa4R6E= + + +AQAAAIAAAACAAAAAUQAAAA==eNoNwxEXg2AAAMCPoiiKRlEURVEUjaIoiqIoiqIoiqLRKBpF+2ndvXdRCCE2MfVlZm5haWVt49vWzt7B0cnZxdXN3cPTj18vf97+fQAxngxh + + +AQAAACAAAAAgAAAACwAAAA==eNoTE8MPAC2AAsE= + + + + +AQAAAAADAAAAAwAASgAAAA==eNpjYACBBlsGCG0DwShitghxMBuE7SC0gB0EI4s12CGJQ7GAPYQ+AcXIYiAaJg5ig8WhtAsUI4s1IImD2KPuH3U/+e4HADT8bmE= + +AQAAAAADAAAAAwAASgAAAA==eNrNisENACAIxBiBgQQ/DnbjOZYxHMoIkDQNzYnkwehBrDT7vds+OzysHsB/g5febU90hje5f7br7N32r9OLoDSU3mt/AIlvbmE= + +AQAAAAADAAAAAwAASgAAAA==eNpjYACBBlsGCLCFYiSxBluEeAMM20FoBTsIRhZrsEMSh2IBewh9AYqRxUA0TBzEBotDaQ8oRhZrQBIHsUfdP+p+8t0PAMN4aDE= + + + + + + + + + + + +AQAAAIAHAACABwAArwAAAA==eNqdk1ECwCAIQr0ZV+Po+20OQrevVpRP1KrXh5r9Q5yj7aPt1UILo3f3ErPhYV+j7Ss9Fvke5zRaF5cw7ImnxyrPTOel0lz8kn3Q3qTju3kx4cEg5qQGogfY1wieH+uUr9RgxsyuS/2Ib/2uMyW8rsGscFn7CQ9/1FPFlbGF92r2Yy/A6F1fBGZimV+ZPsa8R2vhDY3e+RSZDY/jdf67mbL5hre5PJvwvO8817uUmQ== + + + + + +AQAAAIACAACAAgAABQEAAA==eNoNwwc3kAEAAMAvSSVpCCklKSlCSEZLISsNyoqsFEIyk5KUZIdUWn/V3XsXBEGwwxB3Guouw9ztHvca7j4j3G+kBzzoIQ8b5RGjjTHWo8Z5zOPGe8KTJnjKRE+b5BnPmuw5UzzvBVNN86LpZpjpJbPMNsfL5nrFPPMtsNCrXvO6N7xpkbe8bbEllnrHMsutsNIq71rtPe/7wIfWWOsjH1tnvQ022uQTm23xqa222W6HnT6zy+e+sNsee31pn/0O+MpBXzvksCOOOua4b5zwrZO+871TfnDaj874yc/O+sU5vzrvgosuueyKq35zzXU3/O6mP/zpL7f87R//+s//bgOvJzGx + + +AQAAAKAAAACgAAAAYgAAAA==eNoNwxEXwmAAAMAPBoNgMBgEQRAEwSAYBIPBYBAEQTAIgkEwCAZBMAgGg2A/tbv3LgohxK5MTM1cu3Hrzr0Hc48WniytrG08e/Hqzda7Dzuf9r4cfPtx9Ovk7M/FP84+DNE= + + +AQAAACgAAAAoAAAADAAAAA==eNrj4iIOAAAgMAGR + + + + +AQAAAIACAACAAgAAQwAAAA==eNpjYACBBjsGFADiI2NkMWQ16HrheuyRsB0SbYemBptaNDl092BzL7p78LkVq3vscbgZh5uQxYaK+wZn/AIAtdZZOQ== + + + + + + + + + + + +AQAAAMASAADAEgAAJAIAAA==eNqNloGOAyEIRPmywqfx6XeXS1sc36xu0uhal5FhQCKWJ+P43q/v699c3+cz/5/jZ18CTsp6fnHnd4vdXOdz/Pyf697NT8BUnOXcgDl/iJkGl/CDbS6j4WLi38TU8ixncP7S+8Rpnaes/44le954JfPPmWS+YAOWi/FmP0Hrw37lzvGmq2nD6GrGuIAH0vB7rKkDw2cnY06uGuyojyW4pKt2OSt+Kc/qY5mYlsujPHOt3xXwTnmzce3iavRN/ryfkvkWD8kBrI+qI9Au+WPzSmL/pN0m3PRaIc2pzjYNOZ6hXpFulFuKqfpruTR1472nknM4TE5hDkNtbJ3nitVjXmN/Tc6nv7Juc3bGTfxFjQBWzW/yrKsGbNXVtDl9DJnrHtXszRkopqTZud5wzpseY4n5a9cO3gOxa1Dz4abH0Pzc+gfosbY8hzs8Lu78hjpI9z/Va60pjzUx+W60NQhqmb0zDzw3xJfq0cZt8D1MudsXuiItR3K8S+oK5b3jNCTn6pCjYXK6JBeb+mNTI7UuFuynfLU1Mg2u8xtsVnq/dU9fxtTxrGdw/s46t/Qotz2GwdSaRLpz8XE9q9Zo1SPlMXHv7qS40HKfenDDq9NyG1zUdbDNxUfTE0xdX/U6jmc5QzzoiHw/9Rj90C9QDOmer7Gf6lUfzlHGLuVuCZ7V1cHXBrvkd5jzzXM8YbRZUz+e/nN7TzxTvSI/lNsw+P9rPw9B6mw= + + + + + +AQAAAEAGAABABgAAZQIAAA==eNol01V3FgQAANCPHjkYzegRo7u7R43u7u7ukRvdKKmgdKeCAUoqjUGjYJIG3dxzeLg/4QYCgUAsYhOHuMQjPgkIIiGJSEwSkpKMYJKTghBSkorUpCEt6UhPBkLJSCYyk4WsZCM7YeQgJ7nITTh5yEs+8lOAghSiMEUoSjGKU4KSlKI0ZShLOcpTgYpUojJVqEo1qlODmtQigtrUoS71qE8kDWhIIxrThKY0ozktaEkrWtOGtrSjPR3oSCc604WudKM7PehJL3rTh770oz8DGMggBjOEoQxjOCMYyShGM4axjGM8E4hiIpOYzBSmMo1oYpjODGYyi9nMYS7zmM8CFrKIxSzhAz5kKctYzgpWsoqP+JjVrOETPmUt61jPBjayic1sYSvb2M4OdrKL3exhL/v4jM/ZzwG+4Eu+4msOcohv+JbDHOEoxzjOCb7je05yitOc4SznOM8FfuBHfuJnLnKJy1zhKte4zg1+4Vducovf+J0/+JO/+Jvb3OEu97jPA/7hX/7jfx7yiMc84SnPeM4LXvKK17zhbeB9/ljEJg5xiUd8EhBEQhKRmCQkJRnBJCcFIaQkFalJQ1rSkZ4MhJKRTGQmC1nJRnbCyEFOcpGbcPKQl3zkpwAFKURhilCUYhSnBCUpRWnKUJZylKcCFalEZapQlWpUpwY1qUUEtalDXepRn0ga0JBGNKYJTWlGc1rQkla0pg1taUd7OtCRTnSmC13pRnd60JNe9KYPfelHfwYwkEEMZghDGcZwRjCSUYxmDGMZx3gmEMVEJjGZKUxlGtHEMJ0ZzGQWs5nDXN4BrwioSQ== + + +AQAAAKAAAACgAAAAYwAAAA==eNoNwxEQwgAUANC/u2gQBdFgFETBKIiCaDAaRIPRIAqiIApGcRzH4ziO43jUe3cvjYiZmQtXrt1aWtvYefTs1Zt3Hz4dfPn249efo5MkYurc3KWFG3dW7m09ePJi7x8kfBEY + + +AQAAACgAAAAoAAAADAAAAA==eNqTkCAOAABNCAPB + + + + +AQAAAEAGAABABgAAgwAAAA==eNrtlEsOwCAIRD0CF0Kv5tGbpi0dRhJx50IT4mcIo7zEUu7Ra7HR9Qnc27pCKMzqNZfLupLfxJtzPz30b38IzALnlvfex3TYu3fOcqPa5C3sS+d412yfV7hl+xzyQ2/1tVAbmKz0OcON+su6NO+X4lY9D2ZxeOzL4/xXO/xXFz1S2q0= + + + + + + + + + + + +AQAAAIAHAACABwAArwAAAA==eNqdk1ECwCAIQr0ZV+Po+20OQrevVpRP1KrXh5r9Q5yj7aPt1UILo3f3ErPhYV+j7Ss9Fvke5zRaF5cw7ImnxyrPTOel0lz8kn3Q3qTju3kx4cEg5qQGogfY1wieH+uUr9RgxsyuS/2Ib/2uMyW8rsGscFn7CQ9/1FPFlbGF92r2Yy/A6F1fBGZimV+ZPsa8R2vhDY3e+RSZDY/jdf67mbL5hre5PJvwvO8817uUmQ== + + + + + +AQAAAIACAACAAgAABQEAAA==eNoNwwc3kAEAAMAvSSVpCCklKSlCSEZLISsNyoqsFEIyk5KUZIdUWn/V3XsXBEGwwxB3Guouw9ztHvca7j4j3G+kBzzoIQ8b5RGjjTHWo8Z5zOPGe8KTJnjKRE+b5BnPmuw5UzzvBVNN86LpZpjpJbPMNsfL5nrFPPMtsNCrXvO6N7xpkbe8bbEllnrHMsutsNIq71rtPe/7wIfWWOsjH1tnvQ022uQTm23xqa222W6HnT6zy+e+sNsee31pn/0O+MpBXzvksCOOOua4b5zwrZO+871TfnDaj874yc/O+sU5vzrvgosuueyKq35zzXU3/O6mP/zpL7f87R//+s//bgOvJzGx + + +AQAAAKAAAACgAAAAYgAAAA==eNoNwxEXwmAAAMAPBoNgMBgEQRAEwSAYBIPBYBAEQTAIgkEwCAZBMAgGg2A/tbv3LgohxK5MTM1cu3Hrzr0Hc48WniytrG08e/Hqzda7Dzuf9r4cfPtx9Ovk7M/FP84+DNE= + + +AQAAACgAAAAoAAAADAAAAA==eNrj4iIOAAAgMAGR + + + + +AQAAAIACAACAAgAAQwAAAA==eNpjYACBBjsGFADiI2NkMWQ16HrheuyRsB0SbYemBptaNDl092BzL7p78LkVq3vscbgZh5uQxYaK+wZn/AIAtdZZOQ== + +AQAAAIACAACAAgAAPQAAAA==eNpjYICBBjtMGsZGVoNNHp3GxibVPHR2gz0a2x5NzA5NDBcb3TxCanCZB6Wp7V9qxwe1/Uvd+AAAjnNZOQ== + +AQAAAIACAACAAgAAKQAAAA==eNpjYEAGDXYMWPkgGoax8ZHFRpp5KNgeB98eCWPj22HhjwjzAKsdWTk= + + + + + + + + + + + +AQAAAMASAADAEgAAJAIAAA==eNqNloGOAyEIRPmywqfx6XeXS1sc36xu0uhal5FhQCKWJ+P43q/v699c3+cz/5/jZ18CTsp6fnHnd4vdXOdz/Pyf697NT8BUnOXcgDl/iJkGl/CDbS6j4WLi38TU8ixncP7S+8Rpnaes/44le954JfPPmWS+YAOWi/FmP0Hrw37lzvGmq2nD6GrGuIAH0vB7rKkDw2cnY06uGuyojyW4pKt2OSt+Kc/qY5mYlsujPHOt3xXwTnmzce3iavRN/ryfkvkWD8kBrI+qI9Au+WPzSmL/pN0m3PRaIc2pzjYNOZ6hXpFulFuKqfpruTR1472nknM4TE5hDkNtbJ3nitVjXmN/Tc6nv7Juc3bGTfxFjQBWzW/yrKsGbNXVtDl9DJnrHtXszRkopqTZud5wzpseY4n5a9cO3gOxa1Dz4abH0Pzc+gfosbY8hzs8Lu78hjpI9z/Va60pjzUx+W60NQhqmb0zDzw3xJfq0cZt8D1MudsXuiItR3K8S+oK5b3jNCTn6pCjYXK6JBeb+mNTI7UuFuynfLU1Mg2u8xtsVnq/dU9fxtTxrGdw/s46t/Qotz2GwdSaRLpz8XE9q9Zo1SPlMXHv7qS40HKfenDDq9NyG1zUdbDNxUfTE0xdX/U6jmc5QzzoiHw/9Rj90C9QDOmer7Gf6lUfzlHGLuVuCZ7V1cHXBrvkd5jzzXM8YbRZUz+e/nN7TzxTvSI/lNsw+P9rPw9B6mw= + + + + + +AQAAAEAGAABABgAAZQIAAA==eNol01V3FgQAANCPHjkYzegRo7u7R43u7u7ukRvdKKmgdKeCAUoqjUGjYJIG3dxzeLg/4QYCgUAsYhOHuMQjPgkIIiGJSEwSkpKMYJKTghBSkorUpCEt6UhPBkLJSCYyk4WsZCM7YeQgJ7nITTh5yEs+8lOAghSiMEUoSjGKU4KSlKI0ZShLOcpTgYpUojJVqEo1qlODmtQigtrUoS71qE8kDWhIIxrThKY0ozktaEkrWtOGtrSjPR3oSCc604WudKM7PehJL3rTh770oz8DGMggBjOEoQxjOCMYyShGM4axjGM8E4hiIpOYzBSmMo1oYpjODGYyi9nMYS7zmM8CFrKIxSzhAz5kKctYzgpWsoqP+JjVrOETPmUt61jPBjayic1sYSvb2M4OdrKL3exhL/v4jM/ZzwG+4Eu+4msOcohv+JbDHOEoxzjOCb7je05yitOc4SznOM8FfuBHfuJnLnKJy1zhKte4zg1+4Vducovf+J0/+JO/+Jvb3OEu97jPA/7hX/7jfx7yiMc84SnPeM4LXvKK17zhbeB9/ljEJg5xiUd8EhBEQhKRmCQkJRnBJCcFIaQkFalJQ1rSkZ4MhJKRTGQmC1nJRnbCyEFOcpGbcPKQl3zkpwAFKURhilCUYhSnBCUpRWnKUJZylKcCFalEZapQlWpUpwY1qUUEtalDXepRn0ga0JBGNKYJTWlGc1rQkla0pg1taUd7OtCRTnSmC13pRnd60JNe9KYPfelHfwYwkEEMZghDGcZwRjCSUYxmDGMZx3gmEMVEJjGZKUxlGtHEMJ0ZzGQWs5nDXN4BrwioSQ== + + +AQAAAKAAAACgAAAAYwAAAA==eNoNwxEQwgAUANC/u2gQBdFgFETBKIiCaDAaRIPRIAqiIApGcRzH4ziO43jUe3cvjYiZmQtXrt1aWtvYefTs1Zt3Hz4dfPn249efo5MkYurc3KWFG3dW7m09ePJi7x8kfBEY + + +AQAAACgAAAAoAAAADAAAAA==eNqTkCAOAABNCAPB + + + + +AQAAAEAGAABABgAAgwAAAA==eNrtlEsOwCAIRD0CF0Kv5tGbpi0dRhJx50IT4mcIo7zEUu7Ra7HR9Qnc27pCKMzqNZfLupLfxJtzPz30b38IzALnlvfex3TYu3fOcqPa5C3sS+d412yfV7hl+xzyQ2/1tVAbmKz0OcON+su6NO+X4lY9D2ZxeOzL4/xXO/xXFz1S2q0= + +AQAAAEAGAABABgAAfgAAAA==eNrdU0EOwCAI4wl8SPzanr5kbtAyk82DF0yIQGpLExF5zmESeRtBtQXuihZ9r4EjcyLvKh9hYTbHN/ntgzSNOVB/lw/P0+yvdz1y7SOwdswdCrdCn7ymWjPemE8n/KRrrDub9dPHiu4OH5ZwyVOVf1Vlz6v8qxp7fgKHjtqt + +AQAAAEAGAABABgAAVAAAAA==eNpjYEAGDXYMqHxbBCZFHUgejm2RaFuEOCnqkNWi2wdTO+qPUX/Qwh8o2B6VL2CPwCSps0dgASRaAEmcJHV2qHxk+wTsMd0z6o9Rf1DHHwCpe9qt + + + + + + + + + + + +AQAAAIAHAACABwAArwAAAA==eNqdk1ECwCAIQr0ZV+Po+20OQrevVpRP1KrXh5r9Q5yj7aPt1UILo3f3ErPhYV+j7Ss9Fvke5zRaF5cw7ImnxyrPTOel0lz8kn3Q3qTju3kx4cEg5qQGogfY1wieH+uUr9RgxsyuS/2Ib/2uMyW8rsGscFn7CQ9/1FPFlbGF92r2Yy/A6F1fBGZimV+ZPsa8R2vhDY3e+RSZDY/jdf67mbL5hre5PJvwvO8817uUmQ== + + + + + +AQAAAIACAACAAgAABQEAAA==eNoNwwc3kAEAAMAvSSVpCCklKSlCSEZLISsNyoqsFEIyk5KUZIdUWn/V3XsXBEGwwxB3Guouw9ztHvca7j4j3G+kBzzoIQ8b5RGjjTHWo8Z5zOPGe8KTJnjKRE+b5BnPmuw5UzzvBVNN86LpZpjpJbPMNsfL5nrFPPMtsNCrXvO6N7xpkbe8bbEllnrHMsutsNIq71rtPe/7wIfWWOsjH1tnvQ022uQTm23xqa222W6HnT6zy+e+sNsee31pn/0O+MpBXzvksCOOOua4b5zwrZO+871TfnDaj874yc/O+sU5vzrvgosuueyKq35zzXU3/O6mP/zpL7f87R//+s//bgOvJzGx + + +AQAAAKAAAACgAAAAYgAAAA==eNoNwxEXwmAAAMAPBoNgMBgEQRAEwSAYBIPBYBAEQTAIgkEwCAZBMAgGg2A/tbv3LgohxK5MTM1cu3Hrzr0Hc48WniytrG08e/Hqzda7Dzuf9r4cfPtx9Ovk7M/FP84+DNE= + + +AQAAACgAAAAoAAAADAAAAA==eNrj4iIOAAAgMAGR + + + + +AQAAAIACAACAAgAAQwAAAA==eNpjYACBBjsGFADiI2NkMWQ16HrheuyRsB0SbYemBptaNDl092BzL7p78LkVq3vscbgZh5uQxYaK+wZn/AIAtdZZOQ== + +AQAAAIACAACAAgAAPQAAAA==eNpjYICBBjtMGsZGVoNNHp3GxibVPHR2gz0a2x5NzA5NDBcb3TxCanCZB6Wp7V9qxwe1/Uvd+AAAjnNZOQ== + +AQAAAIACAACAAgAAKQAAAA==eNpjYEAGDXYMWPkgGoax8ZHFRpp5KNgeB98eCWPj22HhjwjzAKsdWTk= + +AQAAAIACAACAAgAAQwAAAA==eNpjYACBBjsGFADiI2NkMWQ16HrheuyRsB0SbYemBptaNDl092BzL7p78LkVq3vscbgZh5uQxYaK+wZn/AIAtdZZOQ== + + + + + + + + + + + +AQAAAMASAADAEgAAJAIAAA==eNqNloGOAyEIRPmywqfx6XeXS1sc36xu0uhal5FhQCKWJ+P43q/v699c3+cz/5/jZ18CTsp6fnHnd4vdXOdz/Pyf697NT8BUnOXcgDl/iJkGl/CDbS6j4WLi38TU8ixncP7S+8Rpnaes/44le954JfPPmWS+YAOWi/FmP0Hrw37lzvGmq2nD6GrGuIAH0vB7rKkDw2cnY06uGuyojyW4pKt2OSt+Kc/qY5mYlsujPHOt3xXwTnmzce3iavRN/ryfkvkWD8kBrI+qI9Au+WPzSmL/pN0m3PRaIc2pzjYNOZ6hXpFulFuKqfpruTR1472nknM4TE5hDkNtbJ3nitVjXmN/Tc6nv7Juc3bGTfxFjQBWzW/yrKsGbNXVtDl9DJnrHtXszRkopqTZud5wzpseY4n5a9cO3gOxa1Dz4abH0Pzc+gfosbY8hzs8Lu78hjpI9z/Va60pjzUx+W60NQhqmb0zDzw3xJfq0cZt8D1MudsXuiItR3K8S+oK5b3jNCTn6pCjYXK6JBeb+mNTI7UuFuynfLU1Mg2u8xtsVnq/dU9fxtTxrGdw/s46t/Qotz2GwdSaRLpz8XE9q9Zo1SPlMXHv7qS40HKfenDDq9NyG1zUdbDNxUfTE0xdX/U6jmc5QzzoiHw/9Rj90C9QDOmer7Gf6lUfzlHGLuVuCZ7V1cHXBrvkd5jzzXM8YbRZUz+e/nN7TzxTvSI/lNsw+P9rPw9B6mw= + + + + + +AQAAAEAGAABABgAAZQIAAA==eNol01V3FgQAANCPHjkYzegRo7u7R43u7u7ukRvdKKmgdKeCAUoqjUGjYJIG3dxzeLg/4QYCgUAsYhOHuMQjPgkIIiGJSEwSkpKMYJKTghBSkorUpCEt6UhPBkLJSCYyk4WsZCM7YeQgJ7nITTh5yEs+8lOAghSiMEUoSjGKU4KSlKI0ZShLOcpTgYpUojJVqEo1qlODmtQigtrUoS71qE8kDWhIIxrThKY0ozktaEkrWtOGtrSjPR3oSCc604WudKM7PehJL3rTh770oz8DGMggBjOEoQxjOCMYyShGM4axjGM8E4hiIpOYzBSmMo1oYpjODGYyi9nMYS7zmM8CFrKIxSzhAz5kKctYzgpWsoqP+JjVrOETPmUt61jPBjayic1sYSvb2M4OdrKL3exhL/v4jM/ZzwG+4Eu+4msOcohv+JbDHOEoxzjOCb7je05yitOc4SznOM8FfuBHfuJnLnKJy1zhKte4zg1+4Vducovf+J0/+JO/+Jvb3OEu97jPA/7hX/7jfx7yiMc84SnPeM4LXvKK17zhbeB9/ljEJg5xiUd8EhBEQhKRmCQkJRnBJCcFIaQkFalJQ1rSkZ4MhJKRTGQmC1nJRnbCyEFOcpGbcPKQl3zkpwAFKURhilCUYhSnBCUpRWnKUJZylKcCFalEZapQlWpUpwY1qUUEtalDXepRn0ga0JBGNKYJTWlGc1rQkla0pg1taUd7OtCRTnSmC13pRnd60JNe9KYPfelHfwYwkEEMZghDGcZwRjCSUYxmDGMZx3gmEMVEJjGZKUxlGtHEMJ0ZzGQWs5nDXN4BrwioSQ== + + +AQAAAKAAAACgAAAAYwAAAA==eNoNwxEQwgAUANC/u2gQBdFgFETBKIiCaDAaRIPRIAqiIApGcRzH4ziO43jUe3cvjYiZmQtXrt1aWtvYefTs1Zt3Hz4dfPn249efo5MkYurc3KWFG3dW7m09ePJi7x8kfBEY + + +AQAAACgAAAAoAAAADAAAAA==eNqTkCAOAABNCAPB + + + + +AQAAAEAGAABABgAAgwAAAA==eNrtlEsOwCAIRD0CF0Kv5tGbpi0dRhJx50IT4mcIo7zEUu7Ra7HR9Qnc27pCKMzqNZfLupLfxJtzPz30b38IzALnlvfex3TYu3fOcqPa5C3sS+d412yfV7hl+xzyQ2/1tVAbmKz0OcON+su6NO+X4lY9D2ZxeOzL4/xXO/xXFz1S2q0= + +AQAAAEAGAABABgAAfgAAAA==eNrdU0EOwCAI4wl8SPzanr5kbtAyk82DF0yIQGpLExF5zmESeRtBtQXuihZ9r4EjcyLvKh9hYTbHN/ntgzSNOVB/lw/P0+yvdz1y7SOwdswdCrdCn7ymWjPemE8n/KRrrDub9dPHiu4OH5ZwyVOVf1Vlz6v8qxp7fgKHjtqt + +AQAAAEAGAABABgAAVAAAAA==eNpjYEAGDXYMqHxbBCZFHUgejm2RaFuEOCnqkNWi2wdTO+qPUX/Qwh8o2B6VL2CPwCSps0dgASRaAEmcJHV2qHxk+wTsMd0z6o9Rf1DHHwCpe9qt + +AQAAAEAGAABABgAAgwAAAA==eNrtVEEOwCAI61N4CX7Npy8mTGtnNnbzIAkhQqVIE4Fm1THMw/kc1nC3gyJcaphxWN2jnm/cD6xLjfuX4UbRKN9xcafX6cxv+cSuegu3Ka/kedbsnv/olt3zSj/mhvBWyUNmTu85o5vsV+tWZr6Ubj7roVocPfbV4/xXO/xXF9iuvu0= + + + + -- 2.39.5