From b502174f7a25aee1be978620082b92bca7ff5951 Mon Sep 17 00:00:00 2001 From: tcclevenger Date: Thu, 15 Feb 2018 21:55:38 -0500 Subject: [PATCH] changes --- .../changes/minor/20180219ConradClevenger | 5 ++ source/grid/grid_out.cc | 87 +++++++++++-------- tests/grid/grid_out_per_processor_vtu_03.cc | 60 +++++++++++++ .../grid/grid_out_per_processor_vtu_03.output | 81 +++++++++++++++++ 4 files changed, 195 insertions(+), 38 deletions(-) create mode 100644 doc/news/changes/minor/20180219ConradClevenger create mode 100644 tests/grid/grid_out_per_processor_vtu_03.cc create mode 100644 tests/grid/grid_out_per_processor_vtu_03.output diff --git a/doc/news/changes/minor/20180219ConradClevenger b/doc/news/changes/minor/20180219ConradClevenger new file mode 100644 index 0000000000..908482f494 --- /dev/null +++ b/doc/news/changes/minor/20180219ConradClevenger @@ -0,0 +1,5 @@ +Changed: The GridOut::write_mesh_per_processor_as_vtu function now +only includes processor info in the .vtu filename and writes a .pvtu file +when using a parallel::Triangulation. +
+(Conrad Clevenger, 2018/02/19) diff --git a/source/grid/grid_out.cc b/source/grid/grid_out.cc index b73595b9f2..d354c15eb2 100644 --- a/source/grid/grid_out.cc +++ b/source/grid/grid_out.cc @@ -2590,9 +2590,55 @@ void GridOut::write_mesh_per_processor_as_vtu (const Triangulation patches.push_back(patch); } - const std::string new_file = (filename_without_extension + ".proc" + - Utilities::int_to_string (tria.locally_owned_subdomain(), 4) + - ".vtu"); + // only create .pvtu file if running in parallel + // if not, just create a .vtu file with no reference + // to the processor number + std::string new_file = filename_without_extension + ".vtu"; + if (const parallel::Triangulation *tr = + dynamic_cast *>(&tria)) + { + new_file = filename_without_extension + ".proc" + + Utilities::int_to_string (tr->locally_owned_subdomain(), 4) + + ".vtu"; + + // create .pvtu record + if (tr->locally_owned_subdomain() == 0) + { + std::vector filenames; + + // .pvtu needs to reference the files without a relative path because it will be written + // in the same directory. For this, remove any paths from filename. + std::size_t pos = filename_without_extension.find_last_of('/'); + if (pos == std::string::npos) + pos = 0; + else + pos += 1; + const unsigned int n_procs = Utilities::MPI::n_mpi_processes(tr->get_communicator()); + for (unsigned int i=0; i > data_out; + data_out.attach_triangulation (*tr); + + // We need a dummy vector with the names of the data values in the .vtu files + // in order that the .pvtu contains reference these values + Vector dummy_vector (tr->n_active_cells()); + data_out.add_data_vector (dummy_vector, "level"); + data_out.add_data_vector (dummy_vector, "subdomain"); + data_out.add_data_vector (dummy_vector, "level_subdomain"); + data_out.add_data_vector (dummy_vector, "proc_writing"); + + data_out.build_patches (); + + data_out.write_pvtu_record (pvtu_master, filenames); + } + } + std::ofstream out(new_file.c_str()); std::vector > vector_data_ranges; DataOutBase::VtkFlags flags; @@ -2601,41 +2647,6 @@ void GridOut::write_mesh_per_processor_as_vtu (const Triangulation vector_data_ranges, flags, out); - //create .pvtu record - if (tria.locally_owned_subdomain() == 0) - { - std::vector filenames; - - //.pvtu needs to reference the files without a relative path because it will be written - //in the same directory. For this, remove any paths from filename. - std::size_t pos = filename_without_extension.find_last_of('/'); - if (pos == std::string::npos) - pos = 0; - else - pos += 1; - for (unsigned int i=0; i > data_out; - data_out.attach_triangulation (tria); - - //We need a dummy vector with the names of the data values in the .vtu files - //in order that the .pvtu contains reference these values - Vector dummy_vector (tria.n_active_cells()); - data_out.add_data_vector (dummy_vector, "level"); - data_out.add_data_vector (dummy_vector, "subdomain"); - data_out.add_data_vector (dummy_vector, "level_subdomain"); - data_out.add_data_vector (dummy_vector, "proc_writing"); - - data_out.build_patches (); - - data_out.write_pvtu_record (pvtu_master, filenames); - } } diff --git a/tests/grid/grid_out_per_processor_vtu_03.cc b/tests/grid/grid_out_per_processor_vtu_03.cc new file mode 100644 index 0000000000..57c50b952a --- /dev/null +++ b/tests/grid/grid_out_per_processor_vtu_03.cc @@ -0,0 +1,60 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2009 - 2017 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 at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + + +// check GriOut::write_mesh_per_processor_as_vtu() on only one processor + +#include "../tests.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +template +void test() +{ + deallog << dim << "-dimensions" << std::endl; + + Triangulation tr(Triangulation::limit_level_difference_at_vertices); + GridGenerator::hyper_cube(tr); + tr.refine_global(3); + + std::string filename = "file"+Utilities::int_to_string(dim); + GridOut grid_out; + grid_out.write_mesh_per_processor_as_vtu(tr, filename, true); + + cat_file((std::string(filename)+".vtu").c_str()); +} + + +int main(int argc, char *argv[]) +{ + initlog(); + + test<2>(); + test<3>(); +} diff --git a/tests/grid/grid_out_per_processor_vtu_03.output b/tests/grid/grid_out_per_processor_vtu_03.output new file mode 100644 index 0000000000..4fca92e560 --- /dev/null +++ b/tests/grid/grid_out_per_processor_vtu_03.output @@ -0,0 +1,81 @@ + +DEAL::2-dimensions + + + + + + + +AQAAAPAPAADwDwAA9AEAAA==eNqNVsERwzAIyyhMAozCKIzGaL30rneyio37iaLKikxs4ufBX9rT3r9X/u/7s829Ee78QZNGXp0PjrcVtz4250/t798r4m6+qPk+S88+OP7L2dkHNbt6OtXsN9YJd/VHTVqfwYn/PdsJdz5+8X6XOULWl3c71wE1L+eDz7KedcWdD2p2683pvTjwbuc6oCatz+DEJ9Z88PGL9f/o5l4Jd/sFNKnk1fngeF1x66Pzfiz2VuD1X4NrDTVfXs8+mKEIdz510R8e3cxHV9z2E9CkrvNsfXD+uuLWR+d+VZStgK+hDqh5+Rp8MEMR7nzqon8K9yQFXv81zmOx1+nZB+cuhDsfuejnwdkUeP3XJI+Fvt1lCOIT+NSzT1x8X4T4Ar6GOqDGrV8DQvzv3QvhzkcuvndB2Qr4GuqAmtxkCOJ/GYJw5xM35yvd7Addcfu9Bk3quk9aH1y7uuLWR+fzQFE2AV7s3AdQ83Iy+GCGItz51MX55NHNftYVt+cZ0KSu+7z1wf2vK259dD4vFWUL4GOoA2pePgYfzFCEO5+6OL8JfRcEeLFzH0CNW78GhHgH3gcfuThPBmUT4MXOfQA1uckQxDvwPvjExflWiA/gY6gDatz6NSDEJ/A5+MjFeTsoWwAfQx1Qk5sMQXwCn4NPtOf/D1V+TcQ= + + + + + +AQAAAFAFAABQBQAAIwIAAA==eNol0+l7DwQAAODfZpvZbAzbzA4bxtiFbeweM9cOtqlEl0olOiSku9zKfeug6KBbRfeFLhSpHF2EVIpK9937PH14/4Q3EAgEgmhCMCGE0pQwwmlGJBE0J4oWRNOSGFrTijbEEk8cbUkgkXYkkUx7UkgljY50oBPpdKEzGXQlk25kkU0uOXSnB3n0JJ8CetOLQooooZhSyqignD70pR+VVNGfgQxgEIOpoZpa6hjKEOppYBiNnMbpDOcMzmQEZzGSszmH8ziXUZzPhVzAaC7iEi5mDJcyjrFcxuVcyRWM5yquZgITmcQ1TGYK13I913EDN3IzN3ELtzKNqUxnBrOYyWzmcDu3MZd5LGA+C1nEEhazlGWsYDkrWcWd3MFd3M0aVnMP97KOtdzH/TzIA6xnAw/zEI/wKI/zGE+wkad4kqfZxDNs5lme4wWe50Ve4hVe5lVeYytb2MbrvMkbvMXb7GA7O3mHXbzLbt7jffbwAR+yj73s5wAf8xGf8CkH+YxDfM4RDnOUL/iSY3zF13zDcb7lBN9xku/5gR85xU/8zK/8wm/8zp/8wV/8zb/8E/g/fxBNCCaEUJoSRjjNiCSC5kTRgmhaEkNrWtGGWOKJoy0JJNKOJJJpTwqppNGRDnQinS50JoOuZNKNLLLJJYfu9CCPnuRTQG96UUgRJRRTShkVlNOHvvSjkir6M5ABDGIwNVRTSx1DGUI9DQyjkf8AW4iNcw== + + +AQAAAFQBAABUAQAArAAAAA==eNoNwxF0QlEAANC3c4IPQRB8CIIgCIIgCILgQxAEgyAYBEEwCIIgCAaDIAiCIAiCQRAMgsEgGAwGQRAMgkEw6N5zbiqEEJk2Y9bYnHkLFi1ZtmLVmnUbJjZt2fbRjl2f7Nl34LNDR46dOPXFV2fOXbh05dqNW9/cuffdgx9+evTLb388efbir1f/vPlveAghZWTajFljc+YtWLRk2YpVa9ZtmNi0Zds78x0jMw== + + +AQAAAFUAAABVAAAADAAAAA==eNrj5KQBAACA1AL+ + + + + +AQAAAFAFAABQBQAAHAAAAA==eNpjYEAHDfaUYQaHkY0dRvEoHsUjFAMA9hyb8Q== + +AQAAAFAFAABQBQAAGAAAAA==eNpjYGjYzzCKqYhHwSgYBSMVAABEDWit + +AQAAAFAFAABQBQAAFAAAAA==eNpjYBgFo2AUjIJRQA0AAAVQAAE= + +AQAAAFAFAABQBQAAFwAAAA==eNpjYGjwZxjFo3gUj+JRTDEGAAoKEvw= + + + + + +DEAL::3-dimensions + + + + + + + +AQAAAGDbAABg2wAAxBQAAA==eNqdnQGuIyEORDkKJ+lwFI7io/XRVrPamXWcesZmpGgIP3JXqsFdGOOM4f/ZZ8j3f/5Xf/N/933+9fWP3n/gbx/4XHwp/O5vBrYM7NrncP14vQ9c+wM44jUAp+Q/sWHuf4ucVvkcv1h+vme8fofPD4wfgd0+F3wSzvFr2z4XfBLOz3n826Pf//lf/c3/3ffFl5pfX3/7aFv/eIz2Pvn14/W8LcLpccRrIE4x7winf//vHj19Pv1387g8pp/rNfj8svnRvHx9jyafhNNfM16nwyfh9H3kU9ZH87uA6wW8r9BW/t/btHCtf5yGa/37fsDrD86Psynu5YL7ukIbcYrnAuH0Ng3GUIVP/z0WjJsV2h0+FzwvvE2DcVfhk3D61wrtDp+EcxX0Q/STS9ybbF6vwj1T9zvep3Hg94u7BKeJe084/fjOxoQaT1/PcMDpbX7dmyaf5Cf9nMzG3IlP8pPe5td4avJJOL0fycb0iU/C6W2S5ot+crl+5WsW+J0V2uQnl+tf4h5GDpbrVz4u4jR/f4QvW+DXVmgTTqX/Cae3aeBDK3ySn/TvV2h3+CQ/6W0a+OgKn4TTX2+FdodPwrkK66+KnlT6ZcFzlfRIpieVvljw3Fufvp4knOo5vz59PUk41XN4XfD5Fd949HMu87knPr9sfrQf/5pPTT4Jp/dZmU8/8Uk4vU1ak1f0pPLfC/wK+eNMTyr/umDer09fT47sGSV8Z1dPruwZInxbl88hnkXxXkd/2eFzQfxnCV9rF3wSziF8tl3wSThXIX5V0ZPZvF6FZ/ZJT2bzWo3Nrp4knOo+r09fTxJOdR/WBZ/kJ/0YzzTHiU/yk97m17hr8kk4v+LziaY58Uk4vU2KmVb0ZDavF7w6ejKb18v1Z9fP9ORIMBpco6MnV2LD/P34nP3kicsF3zNer8Mn+cklsNsFn4RzCNt2wSfhXIX4/3jg/QN/e+Bz8aX2F9zfDGwZ2LXncP14vQeu/QCOeA3AKfcdEhvm/rfIaZXP8Yvl53vG63f4fGA/QmC354JPwjl+bdtzwSfhfM77Uy/w+wLXL3yfN7bF/pe3+d/+J2Dw69hg89/nnxynuX51L1/g6w1twqn2xQint/nv80+fT/89Xhg3b2w3+Hxhv8zb/Pt5e/p8Ek7/ekO7wyfhfAv7p4PmwwNzg8Zfcs/U/Ta498SvhXFJOP39lnOPxncyJtR4MhhbdP/8vWnzSX5y/M5bey74JB8pxqU9F3wSzvE9jmlMH/kknM95f/8F//KCr3lhPr+hTX7ydf2v4CZy8Lp+5eNe8F8v+LIX/MUb2oRT7esRTm/z3+efPp/kJ/37N7Q7fJKf9Db/ft6ePp+E01/vDe0On4TzLeSflPSk0C8//jfzWSc9KeZitGlPrhfs4CdJo1nBJ5705Eg0lHy2d/kcv1rs5zmX+dwTnw/sB4k5RHoq5ZNwjl/NQnon5ZNwPuf8qIqeVP47YvvxBw09qfxrtOnneldPWvKMUr6zqycJp/JD7wWfJp5F8V7/+MsGny/sV3qb3u92+SScJnw2+fuMT8L5FvL3Snoymddv4Zl91JPJvJZjs6snB89ROXaaenIkc0je2y6f5CfH7xih+foecMr9dDHWaD6lfBLO8TtmabynfBLO55xfWtGT2bx+4dXRk9m8fl1/dv1MT1qC0dv17Y6eJJz+/d/Pvxd8kp80cU3C+x5wKj/pP+u/R5dPwmnCNvGX8Uk430L+8/xofTlBa07QnTO2RX61t7nitf5nc8VrPa5faNyI01y/0rITdO0MbcKp8q4Jp7e5QENX+PTP7Am6ecZ2g88J+dje5gKNXuGTcHr/NEO7wyfhnIX8/B3H6uP6Q27Wn/c7cvu4/id8JuT/e5sWr/V3TRuv9bj+yInAaa7f4hgONj2HO7QJpzoXQDi9TQv3rsOnH5M7jtXH9T/fn6nyueG8gLdpYoxV+SScfkzu0O7wSTh34fxI9JOv61drrQnrrhna5Cdf1/9GDGJev65f6cqI86+vnLCWm7Cum6FNOFXeOOH0NhesISt8kp/0+mKGdodP8pPe5gLdXeGTcHq9NUO7wyfhnIXzTdFPvq7/jWNYzOvX9b/xM8JPvq7/jRjEvH5d/w8nAuffMbnDWFU4PYc7tAmnOtdAOL1NC/euwyf5SX+vd2h3+CQ/6W2aGGNVPgmnH5M7tDt8Es5dOH9X0ZN+zT8h7jBju6Envc0Vr/W4fhHjqOhJwunXcjO0O3qScHqbC2IoFT79c2xC3GTGdoPPCfnw3uaCGE2FT8Lpx+MM7Q6fhHMWzodW9KTncEduH9f/fH+mqie9TYvXelx/4KSqJwmn53CHdkdPEk5v08K96/Dpx+SOY/Vx/c/3Z6p8bjiv4W2aGGNVPgmnH5M7tDt8Es5dOL9c0ZPZvH5d/xs+U9WT2bx+Xb+Kq1X0JOH08bIZ2h09STi9zQUxxAqf5Ce9vRnaHT7JT3qbC+KOFT4Jp3/N0O7wSThn4Xx9RU9m8/p1/W/4TFVPZvP6df2Rk6qeJJyewx3aHT1JOL1NC/euwyf5SX+vd2h3+CQ/6W2aGGNVPgmnH5M7tDt8Es5dqR/1wH7AA3sDFH9PYtYq3m0Q+6b4soW4POFcKvZNOENslGLiKp5uEFun+LWFuG2Lz2RfexZi7kc+k33tKbRCm0/CGWIrFNM/8kk4n3N9khfWwy+sjWn9ma3Z1HovrtPGYX3l10UZziXWfoQzrg1oTajWk34dRTij9lV7SBU+s33tWVhznvjM9rWn0F5dPgln1Ba0pj3xSTjfQv2cQfthD+yN0f5Tsmej9nsM9n5of8XCvhThNLX3QzjH9/4K7Qmp/SSDvSXav/Fr6Taf5CfH776dPRd8Ug0PsS9lzwWfhHN8x2dpT+vIJ+F8zvWdXthffCE2RPGXLGah4h0xTrEO8QUfF8hwmoh9EE4L8QWKiah4io+VEE5v08cmunySnzQRt7Knzyf5ybg22BDzOvFJOC2sTyimc+KTcL6F+mMlPZnk9c3CnuVRTyZ5fVPEetp6knCGvTHaEz3pScQZ1urrc86TJJwyT3L87ltT/u97wCnrgYh9WbXnfeSTcI7vPTPa0z3ySTifc328ip7M8vpmIWZ30pNZXt8UsbOuniScMTZEMcGTniScMfahcggqfFKepIm4LeU/vgecKkfS2/TxxC6fhNNCzIhimic+CedbqN9Y0pPJvN6FPfujnkzm9RaxzraeJJzje3+dcgJOehJxhvipFfwk4ZR+cvzmbaicgyOf4CeHyEtQOR9HPgnn+M5joJyGI5+E8znXF63oyWxe70LM+qQns3m9Rey4qycJp4X4MsXET3qScHqbPjbd5ZP8pIl9CxVzP/FJftLb9PH0Lp+E00Icn2L6Jz4J51uofxvzJKfrV7kmE/JOZmhTnuR0/VNo2KgBp+tXOS4R53L9KpdlQl7LDG3CqeruEk5vc0EOTYXPbF97uv6Z6N+Mz2xfe7p+laNT4ZNwet84Q7vDJ+GchfrMMU9yuv4p1ijxGTtd/8yeb8GmhWvRM3C6/h9OBM7l+lf8XsGm53CHNuFUdaEJp7dp4d51+Mz2tafrn8nzP+Mz29eerj+OsSqfhNOPyR3aHT4J5y7UD49+crt+lWs1Ie9qhjb5ye36d8Qg5vV2/SrHK+I0169yuSbkdc3QJpyqvjrh9DYX5JBV+CQ/6bXZDO0On+Qnvc0FOWoVPgmn15AztDt8Es5ZqG8f/eR2/TuOYTGvt+vf8TPCT27XvyMGMa+36//hROA012/xewWbnsMd2oRT1f8nnN6mhXvX4ZP8pL/XO7Q7fJKf9DZNjLEqn4TTj8kd2h0+Cecu/P5CRU9meX3T9c8kvmUHnUYxsOn6VY5jRU8STr82nKHd0ZOE09tckENZ4ZPyJP37GdodPilP0ttckKNZ4ZNw+uvN0O7wSThn4fdBKnoyy+ubrn8m63s76DSKAUzXHzmp6knC6Tncod3Rk4TT27Rw7zp8Up6kv9c7tDt8Up6kt2lijFX5JJx+TO7Q7vBJOHfh92sqejKb19v17/CZqp7M5vV2/SrHt6InCaePoc3Q7uhJwultLsghrvBJftKP9RnaHT7JT3qbC3KUK3wSTj/fZmh3+CScs/D7ShU9mc3r7fp3+ExVT2bzerv+yElVTxJOz+EO7Y6eJJzepoV71+GT/KS/1zu0O3ySn/Q2TYyxKp+E04/JHdodPgnnrvz+cqWepKjfM6GuDNXjSetJiloUE+q+zM9FPcnBNYqskBN/qic5khpCsrZNl09Rn2ZB3ZR1w6eo1bGgrsm64ZNwinO364ZPwvmcf5+uUk9S1S+ZUFeD6pFk9SRVfZEJdS/mp19P0pIaLVbICTvVkySc6tzkvOBT1edYUDdiXfD5wu/lqboO64JPwqnOHa4LPgnnW/j9xFI9yWRev4UzG8d6ksm8lrUZuvUkB9eokLUTmvUkR1JDQtY26PJJflKcm183fFKNNHEuZd3wSTjFOf51wyfhhNoP3XqS2bx+CzmLp3qS2bxWZ9O79SQtOaOvzo5360kSTnUOe17wSX5SnRteF3ySn1TnetcFn4RTnWNeF3wSzrfw+7MlPSnqF26oq7dv9KSoxbWh7t2+0ZODazRa4UzUSU+OpIairO3X5XP81mL8OeeWnbk68SlqlUWbPv+1zSfhHL81ZuyGT8L5nH8fuaInVf22DXXF9oWeVPXVNtT92hd60pIadVbICT7pScKp6kbsCz5N1KKL9zrNOT7w+cLvX3ubPp+oyyfhNFFjwy74JJxv4fe7S3oymddv4czeUU8m81rWpurqycE1umTtqKaeHEkNLVnbqcsn+cnxe27TbvgEPznEuUS74ZNwjt+aVXbDJ+EUNV3sQk9m8/ot5Kyf9GQ2r1Vtnq6etKRGkaqd09WThFPVodkXfJKfNHFuwS74JD/pbfr95C6fhNNEzR674JNwvvC73t16kip/f0JeOeXjZ/UkVX79hLzv+enXkxzJGQWVO9+tJzmTMwQqt73Lp8pPX5A3vS74VPnjC/Ka1wWfhFPl3awLPgnnhNz/bj1Jlb88Ia+W8pGzepIqv3hC3uv89OtJriRHW+UOd+tJ7iSHWuX2dvlU+bkL8kbXBZ8qf3ZBXue64JNwqryDdcEn4dyQ+9ytJ5nNa5X72a0nmc1rlZvZrSc5khxVlTvZrSc5kxxSldvY5ZP8pMqbWxd8kp9UeW3rgk/CqfL41gWfhHNC7me3nmQ2r1XuW7eeZDavVW5at57kSnL0VO5Yt57kTnLoVG5Xl0/ykypvaF3wSX5S5fWsCz4Jp8pjWhd8Es4NuW9dPanOL244V7cv9KQ6X7jh3Nu+0JMjOaOpzg529eRMzlCqs31dPoc4ixljfT/nBRt8TnFWKdpch/OUGZ+Ec4gcc7vgk3BOkYNpF3pSnd/acK5oX+hJdb5qw7mffaEnV3JGTZ2d6urJnZwhU2ebunwucRYt3uuf81INPrc40xZt2uE8WcYn4Vwix9Yu+CScW+Tq2oWezOa1OvvS1ZPZvFZnU7p6ciRndNTZka6enMkZGnW2o8sn+ckhzojYBZ/kJ6fIobYLPgnnEGdW7IJPwjlFTrdd6MlsXqvc/66ezOa1ys3v6smVnFFQufNdPbmTMwQqt73LJ/nJJXLk7YJP8pNb5NrbBZ+Ec4mcfbvgk3Bukftvn4t6kkle3yzUrDnWk0zy+mRsvltPcvAexSrUxDnVkxzJHoKMbXf5TPa1Z6HmzpHPZF97irOCbT4Jp9Dd64ZPwgmx/249ySyvbxbObJ/qSWZ5fSo22a0naUmMdhXOhJ/qSRJOpZvmBZ/ZvvYsnDk/8Znta09x9rLLJ+FUumNd8Ek4lS5Yn4t6ksm83oWaTcd6ksm8lrGZbj3JwTEqK9SEOtWTHEkMScY2unySnxTr5nXDJ+2RijXEuuGTcIp1/Lrhk3BC7KdbTzKb17tQs+BUTzKb12pt2q0nacka3Qo1EU71JAmnWofNCz7JT6p1w7rgk/yk0vXrgk/CqdYx64JPwqnWGetGTyZ5fbNQs+yoJ5O8Ppmb0NWTg3M0VqEm2klPjiSHQu7td/mkPMnxmyNgN3xCnuQQe2h2wyfhHL8xZrvhk3CKGIxd6Mksr28Wanac9GSW16f2Zrt60pI96lWoCXLSk4RTxY32BZ+UJ2lij9Qu+KQ8SW/T77t2+SScJmJsdsEn4fQ2v+J2XT2ZzOtdqNl31JPJvJZ7U109OXiPzgo1AU96ciR7aHJvp8sn+cnxu0dkN3yCnxwihmo3fBLO8btnZTd8Ek4R07ULPZnN612oWXPSk9m8VrH5rp60ZI/CCjVxTnqScKo49L7gk/ykiRi5XfBJftLb9HH3Lp+E00TM3i74JJze5k8NoEY9ySyvb8KrU08yy+ubrj+7flZPciQYF1yjU09yJjaW+1/V0Kzwme1rT/gOHT6zfe2IfV3wSTiHsL0u+CScvi++OvUks7y+6fpnUt8uqyeZ5fVN1694rdSTJJyerx3anXqShNPbNBhDFT6zfe3p+mdS/28ecNK+9nT9atxV+CSc/rVDu8Mn4fQ2DWrgVupJZvN6F+7ZqZ5kNq+34K5bT5JwjsAvjYlTPUnCOcP9sIKfJJzKTw4xb9cFn+QnpxiX64JPwjnCOKYxfeKTcM4w7k08Ayr1JLN5vV3/Tr5fVk8ym9fb9SsfV6knSTg9hzu0O/UkCae3aeBDK3ySn/Tvd2h3+CQ/6W0a+OgKn4TTX2+HdodPwultGtSArujJLK9vFnzWSU9meX1Km3T15Eg02ir4xJOenImGUs/2Lp+UJznEc8su+KQ8ySnmkF3wSTiH0Cx2wSfhnGJO24WezPL6lO/v6sksr0/55q6eXMkzSvnOrp7cyTNE+bYun5QnuYSPtAs+KU9yC19rF3wSziV8tl3wSTi38P12oSezeb0Lz+yTnszmtRqbXT05kjlqBU1w0pMzmUPq3nb5JD85xBixCz7JT04x1uyCT8I5xJi1Cz4J5xRj3y70ZDavN7w6ejKb19v1Z9fP9ORKMBpco6Mnd2LDfNy84CdPXG74nvF6HT7JT26B3S74JJxL2LYLPgmn7/v/6z+ekJA6 + + + + + +AQAAACBJAAAgSQAAghkAAA==eNot3NMSIMqSBdDbtm3btm3btm3btm3btm3bdvesiDMP6xMqqiozd/7vf//7XwACEZDABCEYQQlOCEIRktCEIRxhCU8EIhGRyEQhGlGJTgxiEZPYxCEecYlPAhKRkMQkIRlJSU4KUpGS1KQhHWlJTwYykZHMZCEbWclODnKRk9zkIR95yU8BClGQwhShGEUpTglKUZLSlKEcZSlPBSpRkcpUoRpVqU4NalGT2tShHnWpTwMa0ZDGNKEZTWlOC1rRkta0oR1taU8HOtGRznShG13pTg960ZPe9KEffenPAAYxkMEMYRhDGc4IRjGS0YxhHGMZzwQmMZHJTGEaU5nODGYxk9nMYR5zmc8CFrGQxSxhGUtZzgpWsZLVrGEda1nPBjaxkc1sYRtb2c4OdrGT3exhH3vZzwEOcZDDHOEYRznOCU5xktOc4RxnOc8FLnGRy1zhGle5zg1ucZPb3OEed7nPAx7xkMc84RlPec4LXvGS17zhHW95zwc+8ZHPfOEbX/nOD37xk9/84R9///ff4Q9AIAISmCAEIyjBCUEoQhKaMIQjLOGJQCQiEpkoRCMq0YlBLGISmzjEIy7xSUAiEpKYJCQjKclJQSpSkpo0pCMt6clAJjKSmSxkIyvZyUEucpKbPOQjL/kpQCEKUpgiFKMoxSlBKUpSmjKUoyzlqUAlKlKZKlSjKtWpQS1qUps61KMu9WlAIxrSmCY0oynNaUErWtKaNrSjLe3pQCc60pkudKMr3elBL3rSmz70oy/9GcAgBjKYIQxjKMMZwShGMpoxjGMs45nAJCYymSlMYyrTmcEsZjKbOcxjLvNZwCIWspglLGMpy1nBKlaymjWsYy3r2cAmNrKZLWxjK9vZwS52sps97GMv+znAIQ5ymCMc4yjHOcEpTnKaM5zjLOe5wCUucpkrXOMq17nBLW5ymzvc4y73ecAjHvKYJzzjKc95wSte8po3vOMt7/nAJz7ymS984yvf+cEvfvKbP/zjb4D/Lv0ABCIggQlCMIISnBCEIiShCUM4whKeCEQiIpGJQjSiEp0YxCImsYlDPOISnwQkIiGJSUIykpKcFKQiJalJQzrSkp4MZCIjmclCNrKSnRzkIie5yUM+8pKfAhSiIIUpQjGKUpwSlKIkpSlDOcpSngpUoiKVqUI1qlKdGtSiJrWpQz3qUp8GNKIhjWlCM5rSnBa0oiWtaUM72tKeDnSiI53pQje60p0e9KInvelDP/rSnwEMYiCDGcIwhjKcEYxiJKMZwzjGMp4JTGIik5nCNKYynRnMYiazmcM85jKfBSxiIYtZwjKWspwVrGIlq1nDOtayng1sYiOb2cI2trKdHexiJ7vZwz72sp8DHOIghznCMY5ynBOc4iSnOcM5znKeC1ziIpe5wjWucp0b3OImt7nDPe5ynwc84iGPecIznvKcF7ziJa95wzve8p4PfOIjn/nCN77ynR/84ie/+cM//gb87+EfgEAEJDBBCEZQghOCUIQkNGEIR1jCE4FIRCQyUYhGVKITg1jEJDZxiEdc4pOARCQkMUlIRlKSk4JUpCQ1aUhHWtKTgUxkJDNZyEZWspODXOQkN3nIR17yU4BCFKQwRShGUYpTglKUpDRlKEdZylOBSlSkMlWoRlWqU4Na1KQ2dahHXerTgEY0pDFNaEZTmtOCVrSkNW1oR1va04FOdKQzXehGV7rTg170pDd96Edf+jOAQQxkMEMYxlCGM4JRjGQ0YxjHWMYzgUlMZDJTmMZUpjODWcxkNnOYx1zms4BFLGQxS1jGUpazglWsZDVrWMda1rOBTWxkM1vYxla2s4Nd7GQ3e9jHXvZzgEMc5DBHOMZRjnOCU5zkNGc4x1nOc4FLXOQyV7jGVa5zg1vc5DZ3uMdd7vOARzzkMU94xlOe84JXvOQ1b3jHW97zgU985DNf+MZXvvODX/zkN3/4x99A/334AxCIgAQmCMEISnBCEIqQhCYM4QhLeCIQiYhEJgrRiEp0YhCLmMQmDvGIS3wSkIiEJCYJyUhKclKQipSkJg3pSEt6MpCJjGQmC9nISnZykIuc5CYP+chLfgpQiIIUpgjFKEpxSlCKkpSmDOUoS3kqUImKVKYK1ahKdWpQi5rUpg71qEt9GtCIhjSmCc1oSnNa0IqWtKYN7WhLezrQiY50pgvd6Ep3etCLnvSmD/3oS38GMIiBDGYIwxjKcEYwipGMZgzjGMt4JjCJiUxmCtOYynRmMIuZzGYO85jLfBawiIUsZgnLWMpyVrCKlaxmDetYy3o2sImNbGYL29jKdnawi53sZg/72Mt+DnCIgxzmCMc4ynFOcIqTnOYM5zjLeS5wiYtc5grXuMp1bnCLm9zmDve4y30e8IiHPOYJz3jKc17wipe85g3veMt7PvCJj3zmC9/4ynd+8Iuf/OYP//j7/8W+AAQiIIEJQjCCEpwQhCIkoQlDOMISnghEIiKRiUI0ohKdGMQiJrGJQzziEp8EJCIhiUlCMpKSnBSkIiWpSUM60pKeDGQiI5nJQjaykp0c5CInuclDPvKSnwIUoiCFKUIxilKcEpSiJKUpQznKUp4KVKIilalCNapSnRrUoia1qUM96lKfBjSiIY1pQjOa0pwWtKIlrWlDO9rSng50oiOd6UI3utKdHvSiJ73pQz/60p8BDGIggxnCMIYynBGMYiSjGcM4xjKeCUxiIpOZwjSmMp0ZzGIms5nDPOYynwUsYiGLWcIylrKcFaxiJatZwzrWsp4NbGIjm9nCNraynR3sYie72cM+9rKfAxziIIc5wjGOcpwTnOIkpznDOc5yngtc4iKXucI1rnKdG9ziJre5wz3ucp8HPOIhj3nCM57ynBe84iWvecM73vKeD3ziI5/5wje+8p0f/OInv/nDP/4G+a/IH4BABCQwQQhGUIITglCEJDRhCEdYwhOBSEQkMlGIRlSiE4NYxCQ2cYhHXOKTgEQkJDFJSEZSkpOCVKQkNWlIR1rSk4FMZCQzWchGVrKTg1zkJDd5yEde8lOAQhSkMEUoRlGKU4JSlKQ0ZShHWcpTgUpUpDJVqEZVqlODWtSkNnWoR13q04BGNKQxTWhGU5rTgla0pDVtaEdb2tOBTnSkM13oRle604Ne9KQ3fehHX/ozgEEMZDBDGMZQhjOCUYxkNGMYx1jGM4FJTGQyU5jGVKYzg1nMZDZzmMdc5rOARSxkMUtYxlKWs4JVrGQ1a1jHWtazgU1sZDNb2MZWtrODXexkN3vYx172c4BDHOQwRzjGUY5zglOc5DRnOMdZznOBS1zkMle4xlWuc4Nb3OQ2d7jHXe7zgEc85DFPeMZTnvOCV7zkNW94x1ve84FPfOQzX/jGV77zg1/85Dd/+MffoP81+gIQiIAEJgjBCEpwQhCKkIQmDOEIS3giEImIRCYK0YhKdGIQi5jEJg7xiEt8EpCIhCQmCclISnJSkIqUpCYN6UhLejKQiYxkJgvZyEp2cpCLnOQmD/nIS34KUIiCFKYIxShKcUpQipKUpgzlKEt5KlCJilSmCtWoSnVqUIua1KYO9ahLfRrQiIY0pgnNaEpzWtCKlrSmDe1oS3s60ImOdKYL3ehKd3rQi570pg/96Et/BjCIgQxmCMMYynBGMIqRjGYM4xjLeCYwiYlMZgrTmMp0ZjCLmcxmDvOYy3wWsIiFLGYJy1jKclawipWsZg3rWMt6NrCJjWxmC9vYynZ2sIud7GYP+9jLfg5wiIMc5gjHOMpxTnCKk5zmDOc4y3kucImLXOYK17jKdW5wi5vc5g73uMt9HvCIhzzmCc94ynNe8IqXvOYN73jLez7wiY985gvf+Mp3fvCLn/zmD//4G+y/Bn8AAhGQwAQhGEEJTghCEZLQhCEcYQlPBCIRkchEIRpRiU4MYhGT2MQhHnGJTwISkZDEJCEZSUlOClKRktSkIR1pSU8GMpGRzGQhG1nJTg5ykZPc5CEfeclPAQpRkMIUoRhFKU4JSlGS0pShHGUpTwUqUZHKVKEaValODWpRk9rUoR51qU8DGtGQxjShGU1pTgta0ZLWtKEdbWlPBzrRkc50oRtd6U4PetGT3vShH33pzwAGMZDBDGEYQxnOCEYxktGMYRxjGc8EJjGRyUxhGlOZzgxmMZPZzGEec5nPAhaxkMUsYRlLWc4KVrGS1axhHWtZzwY2sZHNbGEbW9nODnaxk93sYR972c8BDnGQwxzhGEc5zglOcZLTnOEcZznPBS5xkctc4RpXuc4NbnGT29zhHne5zwMe8ZDHPOEZT3nOC17xkte84R1vec8HPvGRz3zhG1/5zg9+8ZPf/OEff/9/uCcAgQhIYIIQjKAEJwShCElowhCOsIQnApGISGSiEI2oRCcGsYhJbOIQj7jEJwGJSEhikpCMpCQnBalISWrSkI60pCcDmchIZrKQjaxkJwe5yElu8pCPvOSnAIUoSGGKUIyiFKcEpShJacpQjrKUpwKVqEhlqlCNqlSnBrWoSW3qUI+61KcBjWhIY5rQjKY0pwWtaElr2tCOtrSnA53oSGe60I2udKcHvehJb/rQj770ZwCDGMhghjCMoQxnBKMYyWjGMI6xjGcCk5jIZKYwjalMZwazmMls5jCPucxnAYtYyGKWsIylLGcFq1jJatawjrWsZwOb2MhmtrCNrWxnB7vYyW72sI+97OcAhzjIYY5wjKMc5wSnOMlpznCOs5znApe4yGWucI2rXOcGt7jJbe5wj7vc5wGPeMhjnvCMpzznBa94yWve8I63vOcDn/jIZ77wja985we/+Mlv/vCPvyH+G+oLQCACEpggBCMowQlBKEISmjCEIyzhiUAkIhKZKEQjKtGJQSxiEps4xCMu8UlAIhKSmCQkIynJSUEqUpKaNKQjLenJQCYykpksZCMr2clBLnKSmzzkIy/5KUAhClKYIhSjKMUpQSlKUpoylKMs5alAJSpSmSpUoyrVqUEtalKbOtSjLvVpQCMa0pgmNKMpzWlBK1rSmja0oy3t6UAnOtKZLnSjK93pQS960ps+9KMv/RnAIAYymCEMYyjDGcEoRjKaMYxjLOOZwCQmMpkpTGMq05nBLGYymznMYy7zWcAiFrKYJSxjKctZwSpWspo1rGMt69nAJjaymS1sYyvb2cEudrKbPexjL/s5wCEOcpgjHOMoxznBKU5ymjOc4yznucAlLnKZK1zjKte5wS1ucps73OMu93nAIx7ymCc84ynPecErXvKaN7zjLe/5wCc+8pkvfOMr3/nBL37ymz/842/I/wZ7AxCIgAQmCMEISnBCEIqQhCYM4QhLeCIQiYhEJgrRiEp0YhCLmMQmDvGIS3wSkIiEJCYJyUhKclKQipSkJg3pSEt6MpCJjGQmC9nISnZykIuc5CYP+chLfgpQiIIUpgjFKEpxSlCKkpSmDOUoS3kqUImKVKYK1ahKdWpQi5rUpg71qEt9GtCIhjSmCc1oSnNa0IqWtKYN7WhLezrQiY50pgvd6Ep3etCLnvSmD/3oS38GMIiBDGYIwxjKcEYwipGMZgzjGMt4JjCJiUxmCtOYynRmMIuZzGYO85jLfBawiIUsZgnLWMpyVrCKlaxmDetYy3o2sImNbGYL29jKdnawi53sZg/72Mt+DnCIgxzmCMc4ynFOcIqTnOYM5zjLeS5wiYtc5grXuMp1bnCLm9zmDve4y30e8IiHPOYJz3jKc17wipe85g3veMt7PvCJj3zmC9/4ynd+8Iuf/OYP//gb6r+B/gAEIiCBCUIwghKcEIQiJKEJQzjCEp4IRCIikYlCNKISnRjEIiaxiUM84hKfBCQiIYlJQjKSkpwUpCIlqUlDOtKSngxkIiOZyUI2spKdHOQiJ7nJQz7ykp8CFKIghSlCMYpSnBKUoiSlKUM5ylKeClSiIpWpQjWqUp0a1KImtalDPepSnwY0oiGNaUIzmtKcFrSiJa1pQzva0p4OdKIjnelCN7rSnR70oie96UM/+tKfAQxiIIMZwjCGMpwRjGIkoxnDOMYynglMYiKTmcI0pjKdGcxiJrOZwzzmMp8FLGIhi1nCMpaynBWsYiWrWcM61rKeDWxiI5vZwja2sp0d7GInu9nDPvaynwMc4iCHOcIxjnKcE5ziJKc5wznOcp4LXOIil7nCNa5ynRvc4ia3ucM97nKfBzziIY95wjOe8pwXvOIlr3nDO97yng984iOf+cI3vvKdH/ziJ7/5wz/+/n+YJwCBCEhgghCMoAQnBKEISWjCEI6whCcCkYhIZKIQjahEJwaxiEls4hCPuMQnAYlISGKSkIykJCcFqUhJatKQjrSkJwOZyEhmspCNrGQnB7nISW7ykI+85KcAhShIYYpQjKIUpwSlKElpylCOspSnApWoSGWqUI2qVKcGtahJbepQj7rUpwGNaEhjmtCMpjSnBa1oSWva0I62tKcDnehIZ7rQja50pwe96Elv+tCPvvRnAIMYyGCGMIyhDGcEoxjJaMYwjrGMZwKTmMhkpjCNqUxnBrOYyWzmMI+5zGcBi1jIYpawjKUsZwWrWMlq1rCOtaxnA5vYyGa2sI2tbGcHu9jJbvawj73s5wCHOMhhjnCMoxznBKc4yWnOcI6znOcCl7jIZa5wjatc5wa3uMlt7nCPu9znAY94yGOe8IynPOcFr3jJa97wjre85wOf+MhnvvCNr3znB7/4yW/+8I+/Yf4L8QUgEAEJTBCCEZTghCAUIQlNGMIRlvBEIBIRiUwUohGV6MQgFjGJTRziEZf4JCARCUlMEpKRlOSkIBUpSU0a0pGW9GQgExnJTBaykZXs5CAXOclNHvKRl/wUoBAFKUwRilGU4pSgFCUpTRnKUZbyVKASFalMFapRlerUoBY1qU0d6lGX+jSgEQ1pTBOa0ZTmtKAVLWlNG9rRlvZ0oBMd6UwXutGV7vSgFz3pTR/60Zf+DGAQAxnMEIYxlOGMYBQjGc0YxjGW8UxgEhOZzBSmMZXpzGAWM5nNHOYxl/ksYBELWcwSlrGU5axgFStZzRrWsZb1bGATG9nMFraxle3sYBc72c0e9rGX/RzgEAc5zBGOcZTjnOAUJznNGc5xlvNc4BIXucwVrnGV69zgFje5zR3ucZf7POARD3nME57xlOe84BUvec0b3vGW93zgEx/5zBe+8ZXv/OAXP/nNH/7xN+x/Qd4ABCIggQlCMIISnBCEIiShCUM4whKeCEQiIpGJQjSiEp0YxCImsYlDPOISnwQkIiGJSUIykpKcFKQiJalJQzrSkp4MZCIjmclCNrKSnRzkIie5yUM+8pKfAhSiIIUpQjGKUpwSlKIkpSlDOcpSngpUoiKVqUI1qlKdGtSiJrWpQz3qUp8GNKIhjWlCM5rSnBa0oiWtaUM72tKeDnSiI53pQje60p0e9KInvelDP/rSnwEMYiCDGcIwhjKcEYxiJKMZwzjGMp4JTGIik5nCNKYynRnMYiazmcM85jKfBSxiIYtZwjKWspwVrGIlq1nDOtayng1sYiOb2cI2trKdHexiJ7vZwz72sp8DHOIghznCMY5ynBOc4iSnOcM5znKeC1ziIpe5wjWucp0b3OImt7nDPe5ynwc84iGPecIznvKcF7ziJa95wzve8p4PfOIjn/nCN77ynR/84ie/+cM//ob7L8AfgEAEJDBBCEZQghOCUIQkNGEIR1jCE4FIRCQyUYhGVKITg1jEJDZxiEdc4pOARCQkMUlIRlKSk4JUpCQ1aUhHWtKTgUxkJDNZyEZWspODXOQkN3nIR17yU4BCFKQwRShGUYpTglKUpDRlKEdZylOBSlSkMlWoRlWqU4Na1KQ2dahHXerTgEY0pDFNaEZTmtOCVrSkNW1oR1va04FOdKQzXehGV7rTg170pDd96Edf+jOAQQxkMEMYxlCGM4JRjGQ0YxjHWMYzgUlMZDJTmMZUpjODWcxkNnOYx1zms4BFLGQxS1jGUpazglWsZDVrWMda1rOBTWxkM1vYxla2s4Nd7GQ3e9jHXvZzgEMc5DBHOMZRjnOCU5zkNGc4x1nOc4FLXOQyV7jGVa5zg1vc5DZ3uMdd7vOARzzkMU94xlOe84JXvOQ1b3jHW97zgU985DNf+MZXvvODX/zkN3/4x9//X94RgEAEJDBBCEZQghOCUIQkNGEIR1jCE4FIRCQyUYhGVKITg1jEJDZxiEdc4pOARCQkMUlIRlKSk4JUpCQ1aUhHWtKTgUxkJDNZyEZWspODXOQkN3nIR17yU4BCFKQwRShGUYpTglKUpDRlKEdZylOBSlSkMlWoRlWqU4Na1KQ2dahHXerTgEY0pDFNaEZTmtOCVrSkNW1oR1va04FOdKQzXehGV7rTg170pDd96Edf+jOAQQxkMEMYxlCGM4JRjGQ0YxjHWMYzgUlMZDJTmMZUpjODWcxkNnOYx1zms4BFLGQxS1jGUpazglWsZDVrWMda1rOBTWxkM1vYxla2s4Nd7GQ3e9jHXvZzgEMc5DBHOMZRjnOCU5zkNGc4x1nOc4FLXOQyV7jGVa5zg1vc5DZ3uMdd7vOARzzkMU94xlOe84JXvOQ1b3jHW97zgU985DNf+MZXvvODX/zkN3/4x98I/y3tCUAgAhKYIAQjKMEJQShCEpowhCMs4YlAJCISmShEIyrRiUEsYhKbOMQjLvFJQCISkpgkJCMpyUlBKlKSmjSkIy3pyUAmMpKZLGQjK9nJQS5ykps85CMv+SlAIQpSmCIUoyj/B5Z7n5Q= + + +AQAAACQJAAAkCQAAoQIAAA==eNol1h0UsAgahuF2Znf2m9mfrx0KwzAMwzAMwzAMwzAMwzAMwzAMwzAM99qz57wX3/i8P4IgCImISUjJyCkoqahpaOnoGRiZmFlY2dg5OLm4eXj5CP4SBD8IiYhJSMnIKSipqGlo6egZGJmYWVjZ2Dk4ubh5ePkIftEnJCImISUjp6CkoqahpaNnYGRiZmFlY+fg5OLm4eUj+FWfkIiYhJSMnIKSipqGlo6egZGJmYWVjZ2Dk4ubh5eP4K/6hETEJKRk5BSUVNQ0tHT0DIxMzCysbOwcnFzcPLx8BH/TJyQiJiElI6egpKKmoaWjZ2BkYmZhZWPn4OTi5uHlI/hNn5CImISUjJyCkoqahpaOnoGRiZmFlY2dg5OLm4eXj+Dv+oRExCSkZOQUlFTUNLR09AyMTMwsrGzsHJxc3Dy8fAQ/HCERMQkpGTkFJRU1DS0dPQMjEzMLKxs7BycXNw8vH8Hv+oRExCSkZOQUlFTUNLR09AyMTMwsrGzsHJxc3Dy8fAR/6BMSEZOQkpFTUFJR09DS0TMwMjGzsLKxc3BycfPw8hH8Q5+QiJiElIycgpKKmoaWjp6BkYmZhZWNnYOTi5uHl4/gn/qERMQkpGTkFJRU1DS0dPQMjEzMLKxs7BycXNw8vHwE/9InJCImISUjp6CkoqahpaNnYGRiZmFlY+fg5OLm4eUj+Lc+IRExCSkZOQUlFTUNLR09AyMTMwsrGzsHJxc3Dy8fwU99QiJiElIycgpKKmoaWjp6BkYmZhZWNnYOTi5uHl6+n/8f/h+ERMQkpGTkFJRU1DS0dPQMjEzMLKxs7BycXNw8vHz/ezr+o09IRExCSkZOQUlFTUNLR8/AyMTMwsrGzsHJxc3Dy0fwpz4hETEJKRk5Bf8FnvAsTA== + + +AQAAAEkCAABJAgAADwAAAA==eNrj4RkFo4AKAABmthtt + + + + +AQAAACBJAAAgSQAANAAAAA==eNrtwzERADAIBLB3BtKQjoSOHUjukrxM3Z5WVa9tVVVVVVVVVVVVVVVVVVVV9fMFYv2wOQ== + +AQAAACBJAAAgSQAALwAAAA==eNrtwzENAAAIA7BJxxnW9uKAp02azEZV1RMAAAAAAAAAAAAAAAAAAAD4Vjj419c= + +AQAAACBJAAAgSQAAKQAAAA==eNrtwTEBAAAAwqD1T20ND6AAAAAAAAAAAAAAAAAAAAAAAAC+DEkgAAE= + +AQAAACBJAAAgSQAALQAAAA==eNrtw0ENAAAIAKFraCWjW8MHbNROqqqqqqqqqqqqqqqqqqqqqqqqjx7Q9skL + + + + + -- 2.39.5