diff --git a/dpsim-models/include/dpsim-models/MNAStampUtils.h b/dpsim-models/include/dpsim-models/MNAStampUtils.h index ccb065fe5..80d5e723c 100644 --- a/dpsim-models/include/dpsim-models/MNAStampUtils.h +++ b/dpsim-models/include/dpsim-models/MNAStampUtils.h @@ -52,6 +52,52 @@ class MNAStampUtils { UInt node2Index, Bool isTerminal1NotGrounded, Bool isTerminal2NotGrounded, const Logger::Log &mSLog, Int maxFreq = 1, Int freqIdx = 0); + static void stampIdealTransformer(Real ratio, SparseMatrixRow &mat, + + UInt primaryVirtualNode, UInt secondaryNode, + UInt branchEqNode, + + Bool primaryNotGrounded, + Bool secondaryNotGrounded, + + Int maxFreq, Int freqIdx, + + const Logger::Log &mSLog); + + // Complex wrapper + static void stampIdealTransformer(Complex ratio, SparseMatrixRow &mat, + + UInt primaryVirtualNode, UInt secondaryNode, + UInt branchEqNode, + + Bool primaryNotGrounded, + Bool secondaryNotGrounded, + + const Logger::Log &mSLog, Int maxFreq, + Int freqIdx); + + static void stampIdealTransformerAs3x3(Real ratio, SparseMatrixRow &mat, + + UInt primaryBaseNode, + UInt secondaryBaseNode, + UInt branchEqNode, + + Bool primaryNotGrounded, + Bool secondaryNotGrounded, + + const Logger::Log &mSLog); + + static void stampIdealTransformerAs3x3(Complex ratio, SparseMatrixRow &mat, + + UInt primaryBaseNode, + UInt secondaryBaseNode, + UInt branchEqNode, + + Bool primaryNotGrounded, + Bool secondaryNotGrounded, + + const Logger::Log &mSLog); + private: template static void stampValue(T value, SparseMatrixRow &mat, UInt node1Index, @@ -100,5 +146,31 @@ class MNAStampUtils { Matrix::Index column, Complex value, Int maxFreq, Int freqIdx, const Logger::Log &mSLog); + // Template implementation + template + static void stampIdealTransformerTemplate(T ratio, SparseMatrixRow &mat, + + UInt primaryVirtualNode, + UInt secondaryNode, + UInt branchEqNode, + + Bool primaryNotGrounded, + Bool secondaryNotGrounded, + + Int maxFreq, Int freqIdx, + + const Logger::Log &mSLog); + + template + static void stampIdealTransformerAs3x3Template(T ratio, SparseMatrixRow &mat, + + UInt primaryBaseNode, + UInt secondaryBaseNode, + UInt branchEqNode, + + Bool primaryNotGrounded, + Bool secondaryNotGrounded, + + const Logger::Log &mSLog); }; } // namespace CPS diff --git a/dpsim-models/src/DP/DP_Ph1_Transformer.cpp b/dpsim-models/src/DP/DP_Ph1_Transformer.cpp index 60f4d9003..f27c78e6a 100644 --- a/dpsim-models/src/DP/DP_Ph1_Transformer.cpp +++ b/dpsim-models/src/DP/DP_Ph1_Transformer.cpp @@ -7,6 +7,7 @@ *********************************************************************************/ #include +#include using namespace CPS; @@ -216,44 +217,31 @@ void DP::Ph1::Transformer::mnaParentInitialize( void DP::Ph1::Transformer::mnaCompApplySystemMatrixStamp( SparseMatrixRow &systemMatrix) { + // Ideal transformer equations - if (terminalNotGrounded(0)) { - Math::setMatrixElement(systemMatrix, mVirtualNodes[0]->matrixNodeIndex(), - mVirtualNodes[1]->matrixNodeIndex(), - Complex(-1.0, 0)); - Math::setMatrixElement(systemMatrix, mVirtualNodes[1]->matrixNodeIndex(), - mVirtualNodes[0]->matrixNodeIndex(), - Complex(1.0, 0)); - } - if (terminalNotGrounded(1)) { - Math::setMatrixElement(systemMatrix, matrixNodeIndex(1), - mVirtualNodes[1]->matrixNodeIndex(), **mRatio); - Math::setMatrixElement(systemMatrix, mVirtualNodes[1]->matrixNodeIndex(), - matrixNodeIndex(1), -**mRatio); - } + MNAStampUtils::stampIdealTransformer(**mRatio, systemMatrix, - // Add subcomps to system matrix - for (auto subcomp : mSubComponents) - if (auto mnasubcomp = std::dynamic_pointer_cast(subcomp)) - mnasubcomp->mnaApplySystemMatrixStamp(systemMatrix); + // Original: + // (v0,v1) += -1 + mVirtualNodes[0]->matrixNodeIndex(), - if (terminalNotGrounded(0)) { - SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})", - Logger::complexToString(Complex(-1.0, 0)), - mVirtualNodes[0]->matrixNodeIndex(), - mVirtualNodes[1]->matrixNodeIndex()); - SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})", - Logger::complexToString(Complex(1.0, 0)), - mVirtualNodes[1]->matrixNodeIndex(), - mVirtualNodes[0]->matrixNodeIndex()); - } - if (terminalNotGrounded(1)) { - SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})", - Logger::complexToString(**mRatio), matrixNodeIndex(1), - mVirtualNodes[1]->matrixNodeIndex()); - SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})", - Logger::complexToString(-**mRatio), - mVirtualNodes[1]->matrixNodeIndex(), matrixNodeIndex(1)); + // Original: + // (n1,v1) += ratio + matrixNodeIndex(1), + + // Branch equation node (v1) + mVirtualNodes[1]->matrixNodeIndex(), + + terminalNotGrounded(0), + terminalNotGrounded(1), + + mSLog, mFrequencies.size(), 0); + + // Add subcomponents to system matrix + for (auto subcomp : mSubComponents) { + if (auto mnasubcomp = std::dynamic_pointer_cast(subcomp)) { + mnasubcomp->mnaApplySystemMatrixStamp(systemMatrix); + } } } diff --git a/dpsim-models/src/EMT/EMT_Ph3_Transformer.cpp b/dpsim-models/src/EMT/EMT_Ph3_Transformer.cpp index f86f4aa64..1f7652eb0 100644 --- a/dpsim-models/src/EMT/EMT_Ph3_Transformer.cpp +++ b/dpsim-models/src/EMT/EMT_Ph3_Transformer.cpp @@ -7,6 +7,7 @@ *********************************************************************************/ #include +#include using namespace CPS; @@ -232,110 +233,26 @@ void EMT::Ph3::Transformer::mnaParentInitialize( mTerminals[0]->node()->name(), mTerminals[0]->node()->matrixNodeIndex(), mTerminals[1]->node()->name(), mTerminals[1]->node()->matrixNodeIndex()); } - void EMT::Ph3::Transformer::mnaCompApplySystemMatrixStamp( SparseMatrixRow &systemMatrix) { - // Ideal transformer equations - if (terminalNotGrounded(0)) { - Math::setMatrixElement( - systemMatrix, mVirtualNodes[0]->matrixNodeIndex(PhaseType::A), - mVirtualNodes[1]->matrixNodeIndex(PhaseType::A), -1.); - Math::setMatrixElement( - systemMatrix, mVirtualNodes[0]->matrixNodeIndex(PhaseType::B), - mVirtualNodes[1]->matrixNodeIndex(PhaseType::B), -1.); - Math::setMatrixElement( - systemMatrix, mVirtualNodes[0]->matrixNodeIndex(PhaseType::C), - mVirtualNodes[1]->matrixNodeIndex(PhaseType::C), -1.); - - Math::setMatrixElement(systemMatrix, - mVirtualNodes[1]->matrixNodeIndex(PhaseType::A), - mVirtualNodes[0]->matrixNodeIndex(PhaseType::A), 1.); - Math::setMatrixElement(systemMatrix, - mVirtualNodes[1]->matrixNodeIndex(PhaseType::B), - mVirtualNodes[0]->matrixNodeIndex(PhaseType::B), 1.); - Math::setMatrixElement(systemMatrix, - mVirtualNodes[1]->matrixNodeIndex(PhaseType::C), - mVirtualNodes[0]->matrixNodeIndex(PhaseType::C), 1.); - } - if (terminalNotGrounded(1)) { - Math::setMatrixElement(systemMatrix, matrixNodeIndex(1, 0), - mVirtualNodes[1]->matrixNodeIndex(PhaseType::A), - (**mRatio).real()); - Math::setMatrixElement(systemMatrix, matrixNodeIndex(1, 1), - mVirtualNodes[1]->matrixNodeIndex(PhaseType::B), - (**mRatio).real()); - Math::setMatrixElement(systemMatrix, matrixNodeIndex(1, 2), - mVirtualNodes[1]->matrixNodeIndex(PhaseType::C), - (**mRatio).real()); - Math::setMatrixElement(systemMatrix, - mVirtualNodes[1]->matrixNodeIndex(PhaseType::A), - matrixNodeIndex(1, 0), -(**mRatio).real()); - Math::setMatrixElement(systemMatrix, - mVirtualNodes[1]->matrixNodeIndex(PhaseType::B), - matrixNodeIndex(1, 1), -(**mRatio).real()); - Math::setMatrixElement(systemMatrix, - mVirtualNodes[1]->matrixNodeIndex(PhaseType::C), - matrixNodeIndex(1, 2), -(**mRatio).real()); - } - // Add subcomps to system matrix - for (auto subcomp : mSubComponents) - if (auto mnasubcomp = std::dynamic_pointer_cast(subcomp)) - mnasubcomp->mnaApplySystemMatrixStamp(systemMatrix); + MNAStampUtils::stampIdealTransformerAs3x3( + **mRatio, systemMatrix, - if (terminalNotGrounded(0)) { - SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})", - Logger::complexToString(Complex(-1.0, 0)), - mVirtualNodes[0]->matrixNodeIndex(PhaseType::A), - mVirtualNodes[1]->matrixNodeIndex(PhaseType::A)); - SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})", - Logger::complexToString(Complex(-1.0, 0)), - mVirtualNodes[0]->matrixNodeIndex(PhaseType::B), - mVirtualNodes[1]->matrixNodeIndex(PhaseType::B)); - SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})", - Logger::complexToString(Complex(-1.0, 0)), - mVirtualNodes[0]->matrixNodeIndex(PhaseType::C), - mVirtualNodes[1]->matrixNodeIndex(PhaseType::C)); - - SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})", - Logger::complexToString(Complex(1.0, 0)), - mVirtualNodes[1]->matrixNodeIndex(PhaseType::A), - mVirtualNodes[0]->matrixNodeIndex(PhaseType::A)); - SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})", - Logger::complexToString(Complex(1.0, 0)), - mVirtualNodes[1]->matrixNodeIndex(PhaseType::B), - mVirtualNodes[0]->matrixNodeIndex(PhaseType::B)); - SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})", - Logger::complexToString(Complex(1.0, 0)), - mVirtualNodes[1]->matrixNodeIndex(PhaseType::C), - mVirtualNodes[0]->matrixNodeIndex(PhaseType::C)); - } - if (terminalNotGrounded(1)) { - SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})", - Logger::complexToString(**mRatio), matrixNodeIndex(1, 0), - mVirtualNodes[1]->matrixNodeIndex(PhaseType::A)); - SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})", - Logger::complexToString(**mRatio), matrixNodeIndex(1, 1), - mVirtualNodes[1]->matrixNodeIndex(PhaseType::B)); - SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})", - Logger::complexToString(**mRatio), matrixNodeIndex(1, 2), - mVirtualNodes[1]->matrixNodeIndex(PhaseType::C)); - - SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})", - Logger::complexToString(-**mRatio), - mVirtualNodes[1]->matrixNodeIndex(PhaseType::A), - matrixNodeIndex(1, 0)); - SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})", - Logger::complexToString(-**mRatio), - mVirtualNodes[1]->matrixNodeIndex(PhaseType::B), - matrixNodeIndex(1, 1)); - SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})", - Logger::complexToString(-**mRatio), - mVirtualNodes[1]->matrixNodeIndex(PhaseType::C), - matrixNodeIndex(1, 2)); - } -} + // Primary base (A-phase start) + mVirtualNodes[0]->matrixNodeIndex(PhaseType::A), + + // Secondary base (A-phase start) + mVirtualNodes[1]->matrixNodeIndex(PhaseType::A), + // Branch equation node (SINGLE node, not phased) + mVirtualNodes[1]->matrixNodeIndex(PhaseType::A), + + // Grounding flags + terminalNotGrounded(0), terminalNotGrounded(1), + + mSLog); +} void EMT::Ph3::Transformer::mnaParentAddPreStepDependencies( AttributeBase::List &prevStepDependencies, AttributeBase::List &attributeDependencies, diff --git a/dpsim-models/src/MNAStampUtils.cpp b/dpsim-models/src/MNAStampUtils.cpp index 6362607ec..cdbffab29 100644 --- a/dpsim-models/src/MNAStampUtils.cpp +++ b/dpsim-models/src/MNAStampUtils.cpp @@ -237,3 +237,174 @@ void MNAStampUtils::addToMatrixElement(SparseMatrixRow &mat, Matrix::Index row, Math::addToMatrixElement(mat, row, column, value, maxFreq, freqIdx); } + +void MNAStampUtils::stampIdealTransformer(Real ratio, SparseMatrixRow &mat, + + UInt primaryVirtualNode, + UInt secondaryNode, UInt branchEqNode, + + Bool primaryNotGrounded, + Bool secondaryNotGrounded, + + Int maxFreq, Int freqIdx, + + const Logger::Log &mSLog) { + + SPDLOG_LOGGER_DEBUG( + mSLog, "Start stamping single-phase ideal transformer (compat mode)..."); + + stampIdealTransformerTemplate( + ratio, mat, primaryVirtualNode, secondaryNode, branchEqNode, + primaryNotGrounded, secondaryNotGrounded, maxFreq, freqIdx, mSLog); + + SPDLOG_LOGGER_DEBUG(mSLog, "Stamping completed."); +} + +void MNAStampUtils::stampIdealTransformer(Complex ratio, SparseMatrixRow &mat, + + UInt primaryVirtualNode, + UInt secondaryNode, UInt branchEqNode, + + Bool primaryNotGrounded, + Bool secondaryNotGrounded, + + const Logger::Log &mSLog, Int maxFreq, + Int freqIdx) { + + SPDLOG_LOGGER_DEBUG(mSLog, + "Start stamping single-phase ideal transformer (Complex) " + "for frequency index {:d}...", + freqIdx); + + stampIdealTransformerTemplate( + ratio, mat, + + primaryVirtualNode, secondaryNode, branchEqNode, + + primaryNotGrounded, secondaryNotGrounded, + + maxFreq, freqIdx, mSLog); + + SPDLOG_LOGGER_DEBUG(mSLog, "Stamping completed."); +} + +template +void MNAStampUtils::stampIdealTransformerTemplate( + T ratio, SparseMatrixRow &mat, + + UInt primaryVirtualNode, UInt secondaryNode, UInt branchEqNode, + + Bool primaryNotGrounded, Bool secondaryNotGrounded, + + Int maxFreq, Int freqIdx, const Logger::Log &mSLog) { + + if (primaryNotGrounded) { + addToMatrixElement(mat, primaryVirtualNode, branchEqNode, T(-1.0), maxFreq, + freqIdx, mSLog); + + addToMatrixElement(mat, branchEqNode, primaryVirtualNode, T(1.0), maxFreq, + freqIdx, mSLog); + } + + if (secondaryNotGrounded) { + addToMatrixElement(mat, secondaryNode, branchEqNode, ratio, maxFreq, + freqIdx, mSLog); + + addToMatrixElement(mat, branchEqNode, secondaryNode, -ratio, maxFreq, + freqIdx, mSLog); + } +} + +template +void MNAStampUtils::stampIdealTransformerAs3x3Template( + T ratio, SparseMatrixRow &mat, + + UInt primaryBaseNode, UInt secondaryBaseNode, UInt branchEqNode, + + Bool primaryNotGrounded, Bool secondaryNotGrounded, + + const Logger::Log &mSLog) { + + constexpr UInt PHASES = 3; + + SPDLOG_LOGGER_DEBUG( + mSLog, "Start stamping 3-phase ideal transformer (clean EMT model)..."); + + for (UInt i = 0; i < PHASES; i++) { + + UInt p = primaryBaseNode + i; + UInt s = secondaryBaseNode + i; + UInt b = branchEqNode + i; + + // ------------------------------------------------------------ + // Primary coupling: Vp - Vs constraint + // ------------------------------------------------------------ + if (primaryNotGrounded && secondaryNotGrounded) { + addToMatrixElement(mat, p, b, T(-1.0), 1, 0, mSLog); + addToMatrixElement(mat, b, p, T(1.0), 1, 0, mSLog); + + addToMatrixElement(mat, s, b, T(1.0), 1, 0, mSLog); + addToMatrixElement(mat, b, s, T(-1.0), 1, 0, mSLog); + } + + // ------------------------------------------------------------ + // Ideal transformer ratio constraint: + // Vp = ratio * Vs + // implemented as coupling in branch equation + // ------------------------------------------------------------ + if (primaryNotGrounded && secondaryNotGrounded) { + addToMatrixElement(mat, b, p, T(1.0), 1, 0, mSLog); + addToMatrixElement(mat, b, s, T(-ratio), 1, 0, mSLog); + + addToMatrixElement(mat, p, b, T(1.0), 1, 0, mSLog); + addToMatrixElement(mat, s, b, T(-ratio), 1, 0, mSLog); + } + } + + SPDLOG_LOGGER_DEBUG( + mSLog, "Finished stamping 3-phase ideal transformer (clean EMT model)."); +} + +void MNAStampUtils::stampIdealTransformerAs3x3(Real ratio, SparseMatrixRow &mat, + + UInt primaryBaseNode, + UInt secondaryBaseNode, + UInt branchEqNode, + + Bool primaryNotGrounded, + Bool secondaryNotGrounded, + + const Logger::Log &mSLog) { + + SPDLOG_LOGGER_DEBUG( + mSLog, "Start stamping 3-phase ideal transformer (Real EMT wrapper)..."); + + stampIdealTransformerAs3x3Template( + ratio, mat, primaryBaseNode, secondaryBaseNode, branchEqNode, + primaryNotGrounded, secondaryNotGrounded, mSLog); + + SPDLOG_LOGGER_DEBUG( + mSLog, "Finished stamping 3-phase ideal transformer (Real EMT wrapper)."); +} + +void MNAStampUtils::stampIdealTransformerAs3x3( + Complex ratio, SparseMatrixRow &mat, + + UInt primaryBaseNode, UInt secondaryBaseNode, UInt branchEqNode, + + Bool primaryNotGrounded, Bool secondaryNotGrounded, + + const Logger::Log &mSLog) { + + SPDLOG_LOGGER_DEBUG( + mSLog, + "Start stamping 3-phase ideal transformer (Complex EMT wrapper)..."); + + stampIdealTransformerAs3x3Template( + ratio, mat, primaryBaseNode, secondaryBaseNode, branchEqNode, + primaryNotGrounded, secondaryNotGrounded, mSLog); + + SPDLOG_LOGGER_DEBUG( + mSLog, + "Finished stamping 3-phase ideal transformer (Complex EMT wrapper)."); +} diff --git a/dpsim-models/src/SP/SP_Ph1_Transformer.cpp b/dpsim-models/src/SP/SP_Ph1_Transformer.cpp index bee05f78e..f1464c10b 100644 --- a/dpsim-models/src/SP/SP_Ph1_Transformer.cpp +++ b/dpsim-models/src/SP/SP_Ph1_Transformer.cpp @@ -6,6 +6,7 @@ * file, You can obtain one at https://mozilla.org/MPL/2.0/. *********************************************************************************/ +#include #include using namespace CPS; @@ -361,44 +362,31 @@ void SP::Ph1::Transformer::mnaParentInitialize( void SP::Ph1::Transformer::mnaCompApplySystemMatrixStamp( SparseMatrixRow &systemMatrix) { + // Ideal transformer equations - if (terminalNotGrounded(0)) { - Math::setMatrixElement(systemMatrix, mVirtualNodes[0]->matrixNodeIndex(), - mVirtualNodes[1]->matrixNodeIndex(), - Complex(-1.0, 0)); - Math::setMatrixElement(systemMatrix, mVirtualNodes[1]->matrixNodeIndex(), - mVirtualNodes[0]->matrixNodeIndex(), - Complex(1.0, 0)); - } - if (terminalNotGrounded(1)) { - Math::setMatrixElement(systemMatrix, matrixNodeIndex(1), - mVirtualNodes[1]->matrixNodeIndex(), **mRatio); - Math::setMatrixElement(systemMatrix, mVirtualNodes[1]->matrixNodeIndex(), - matrixNodeIndex(1), -**mRatio); - } + MNAStampUtils::stampIdealTransformer(**mRatio, systemMatrix, - // Add subcomps to system matrix - for (auto subcomp : mSubComponents) - if (auto mnasubcomp = std::dynamic_pointer_cast(subcomp)) - mnasubcomp->mnaApplySystemMatrixStamp(systemMatrix); + // Original: + // (v0,v1) += -1 + mVirtualNodes[0]->matrixNodeIndex(), - if (terminalNotGrounded(0)) { - SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})", - Logger::complexToString(Complex(-1.0, 0)), - mVirtualNodes[0]->matrixNodeIndex(), - mVirtualNodes[1]->matrixNodeIndex()); - SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})", - Logger::complexToString(Complex(1.0, 0)), - mVirtualNodes[1]->matrixNodeIndex(), - mVirtualNodes[0]->matrixNodeIndex()); - } - if (terminalNotGrounded(1)) { - SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})", - Logger::complexToString(**mRatio), matrixNodeIndex(1), - mVirtualNodes[1]->matrixNodeIndex()); - SPDLOG_LOGGER_INFO(mSLog, "Add {:s} to system at ({:d},{:d})", - Logger::complexToString(-**mRatio), - mVirtualNodes[1]->matrixNodeIndex(), matrixNodeIndex(1)); + // Original: + // (n1,v1) += ratio + matrixNodeIndex(1), + + // Branch equation node (v1) + mVirtualNodes[1]->matrixNodeIndex(), + + terminalNotGrounded(0), + terminalNotGrounded(1), + + mSLog, mFrequencies.size(), 0); + + // Add subcomponents to system matrix + for (auto subcomp : mSubComponents) { + if (auto mnasubcomp = std::dynamic_pointer_cast(subcomp)) { + mnasubcomp->mnaApplySystemMatrixStamp(systemMatrix); + } } } diff --git a/examples/Notebooks/Components/Trafo.ipynb b/examples/Notebooks/Components/Trafo.ipynb index 5fa3908da..8725a2366 100644 --- a/examples/Notebooks/Components/Trafo.ipynb +++ b/examples/Notebooks/Components/Trafo.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -35,9 +35,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[10:53:01.547893 MnaSolverFactory info] creating KLUAdapter solver implementation\n" + ] + } + ], "source": [ "time_step = 0.00005\n", "final_time = 1\n", @@ -130,9 +138,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[10:53:01.677439 MnaSolverFactory info] creating KLUAdapter solver implementation\n" + ] + } + ], "source": [ "time_step = 0.00005\n", "final_time = 1\n", @@ -199,9 +215,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[10:53:01.787145 MnaSolverFactory info] creating KLUAdapter solver implementation\n" + ] + } + ], "source": [ "time_step = 0.00005\n", "final_time = 1\n", @@ -294,9 +318,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[10:53:01.894058 MnaSolverFactory info] creating KLUAdapter solver implementation\n" + ] + } + ], "source": [ "time_step = 0.00005\n", "final_time = 1\n", @@ -363,9 +395,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[10:53:01.994533 MnaSolverFactory info] creating KLUAdapter solver implementation\n" + ] + } + ], "source": [ "time_step = 0.00005\n", "final_time = 1\n", @@ -477,9 +517,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[10:53:02.112865 MnaSolverFactory info] creating KLUAdapter solver implementation\n" + ] + } + ], "source": [ "time_step = 0.00005\n", "final_time = 1\n", @@ -543,9 +591,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "logs/SP_Trafo_Elements/SP_Trafo_Elements.csv\n", + "column number: 3\n", + "results length: 20001\n", + "real column names: []\n", + "complex column names: ['itrafo', 'v1', 'v2']\n" + ] + } + ], "source": [ "work_dir = \"logs/SP_Trafo_Elements/\"\n", "log_name = \"SP_Trafo_Elements\"\n", @@ -556,9 +616,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure()\n", "plt.plot(\n", @@ -572,9 +643,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure()\n", "plt.plot(\n", @@ -595,9 +677,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "logs/SP_Trafo_Component/SP_Trafo_Component.csv\n", + "column number: 3\n", + "results length: 20001\n", + "real column names: []\n", + "complex column names: ['itrafo', 'v1', 'v2']\n" + ] + } + ], "source": [ "work_dir = \"logs/SP_Trafo_Component/\"\n", "log_name = \"SP_Trafo_Component\"\n", @@ -608,9 +702,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure()\n", "plt.plot(\n", @@ -624,9 +729,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure()\n", "plt.plot(\n", @@ -647,9 +763,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure()\n", "for name in [\"v1_shift\", \"itrafo_shift\"]:\n", @@ -672,9 +799,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "v1_shift: 0.0\n", + "itrafo_shift: 0.0\n" + ] + } + ], "source": [ "errors_sp_shifted = []\n", "for name in [\"v1_shift\", \"itrafo_shift\"]:\n", @@ -697,9 +833,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "logs/DP_Trafo_Elements/DP_Trafo_Elements.csv\n", + "column number: 3\n", + "results length: 20001\n", + "real column names: []\n", + "complex column names: ['itrafo', 'v1', 'v2']\n" + ] + } + ], "source": [ "work_dir = \"logs/DP_Trafo_Elements/\"\n", "log_name = \"DP_Trafo_Elements\"\n", @@ -710,9 +858,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure()\n", "plt.plot(\n", @@ -726,9 +885,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAioAAAGdCAYAAAA8F1jjAAAAP3RFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMS5wb3N0MSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8kixA/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9e7htV1EmjNda+1ySQHJCIFcNhHCRi4CADR2UFu0oAm2rXz+KiAL+Wmy7oW3I543WBkUF2lZb2h9Kc9GI0o3aItoSUaAFFAIEMLRCQMiFBJKTGyQnt3Pba35/rD3XrKrxvjVqzrX2WWfDrOc5zz577bFq1JijRo2qt2qMOWmappGRRhpppJFGGmmk45Cm6xZgpJFGGmmkkUYaidHoqIw00kgjjTTSSMctjY7KSCONNNJII4103NLoqIw00kgjjTTSSMctjY7KSCONNNJII4103NLoqIw00kgjjTTSSMctjY7KSCONNNJII4103NLoqIw00kgjjTTSSMct7Vq3AMvSbDaT66+/Xk4++WSZTCbrFmekkUYaaaSRRkpQ0zRyxx13yDnnnCPTKcdNdryjcv3118u55567bjFGGmmkkUYaaaQBdN1118lXf/VX07/veEfl5JNPFpH5QE855ZQ1SzPSSCONNNJII2XowIEDcu655y72cUY73lFp0z2nnHLK6KiMNNJII4000g6jWtnGWEw70kgjjTTSSCMdtzQ6KiONNNJII4000nFLo6My0kgjjTTSSCMdtzQ6KiONNNJII4000nFLo6My0kgjjTTSSCMdtzQ6KiONNNJII4000nFLo6My0kgjjTTSSCMdtzQ6KiONNNJII4000nFLo6My0kgjjTTSSCMdt7Stjsr73vc++Y7v+A4555xzZDKZyNve9jbz96Zp5KUvfamcffbZcuKJJ8qFF14on/nMZ7ZTpJFGGmmkkUYaaQfRtjoqd911lzzmMY+R17zmNfDvv/zLvyz/7b/9N3nta18rH/rQh+Re97qXPPWpT5WDBw9up1gjjTTSSCONNNIOoW1918/TnvY0edrTngb/1jSN/Pqv/7r87M/+rHznd36niIi86U1vkjPPPFPe9ra3yfd93/dtp2gjjTTSSCONNNIOoLXVqFx99dWyf/9+ufDCCxef7du3T574xCfKpZdeui6xQvrrT90k7/iH/WGb9/7jzfIXf39D2OZvPnOzvP3/xm3e/9lb5H9//PqwzQeuvEX+9PIvhG0+dNWt8ra/i9tcds0X5a0f+7w0TUPbfPRzX5T/9dG4zceu/ZL84WXXhW0uv+42+YPLrg3b/N/P3yb/88Nxm3/4wu3y5g99TmYz3uYT198uv//BuM0VNxyQ37v0GtkM2nx6/x3ypkuvkaObM9rmMzfeIb/7gbjNZ2+6U37n/VfLkaDNVTffKb/9t1fL4aO8zTW33CVv/Nur5dDRTdrm2lvvljf8zVVy8Ahvc90X622+cNs98oa/uUruOczb3HD7PfL6910ldx8+StvceOCgvO59V8qdh3ibm+6Yt7nj4BHa5pY7D8l/f++Vcvs9vM0X7zo8b3M3b3Pb3fM2X7rrMG1z+91H5L+/90r5YtDmwMF5m1vuPETb3HnoqLz2vVfKTXdwpPjuw0flv7/3SrnxAG9zz+FN+e/vvVJuuP0e2ubgkU153fuulC/cxtscOropr3/fVXLdF++mbY5szuT177tKrr2Vtzm6OZM3/M1Vcs0td9E2m7NG3vi3V8uVN98Ztvntv71aPnvTHbTNbNbIxe+/Wj69n7dpmkbedOk1csUNB8I2v/fBz8knrr89bPPmD31O/v7zcZv/+eFr5ePX3UbbiIj84WXXyd9d+6WwzR995Dr56Oe+GLZ568c+L5ddE7d52999QT501a1hmz+9/AvygStvCdv8749fL+//bNzmWNPa3p68f/98wz/zzDPN52eeeebib4gOHTokhw51RuHAAa6Uq6SDRzblhy6+TERE3v/T3yJfdeqJRZsjmzN57m9/WERE/vrHnyIPvN+9ijabs0Z+8I3zNg8585/JQ88sX2/dNI08+w0fEhGRB97vXvK1X7UPtvn+18/bnHvaSfK4+98Hyv3M131QRETO3neCPPH8+8I23/PauWN4+sl75ckPOR22+Ve/NW9z2r12y7c87EzY5ntfe6kcnTVyyom75du/9izY5lmv+6Dcc2RTTtyzS/7lY86BbZ79hg/JHQePyp6Nqfyrx381bPPc3/6w3HrXYZlOJvKsJ9wftvnXF39E9h84KLOmkedccB5s8/w3fUQ+/6V75NDRmfzwk8+HbX709z8qV99yl9x56Kj8u6c8GLZ54f/4O/n0jXfIbXcfkf9w4UNgm//wlr+TT1x/QG6987D8+FO/BrZ58R9+XD5+3W2y/8BB+Y9Pfzhs8xP/6+Ny2TVfkuu+eLf83L98JGzzU3/8f+XSq26Vq2+5S37pux8F2/zM2/5B3vePN8un998h/+V7HgPbvOxP/0HedcVN8g9fuF1+/fseC9v8/J99Ut7xif1y+XW3yWue/TjY5hfffoX8749fL5dd8yV5/XO+HrZ51V98St76sS/IB668VS7+oSfANv/lHZ+WP/jIdfLef7xZ/sfz/yls86t/9Wl584eulXddcaP80Y8+Cbb59Xd9Ri7+wDVyyT/slz99wTfANv//v/6MvP5vrpY/vfx6ueQ/PBm2ee17rpTffM+V8r8++nl550XfBNu87n1XyX9792fkLR++Vt7zE98M27zxb66WX33nP8qbLv2cvP+nvwW2+d1Lr5FX/cWn5PV/c7V85GcvhG1+/4Ofk1dc8in5zfdcKZe/9Ntgmz+47Dr5pUuukP/6rn+UT77822GbP/rI5+WXLrlCfvkvPyWf+aWnwzZv/bsvyC++/Qr5xbdfIde86hmwzf/++PXyC3/+SfmFPxfa5i/+4QZ5+Z9/UkR4m7/65I3yc/87bvPXn75JXvqnnwjb/M1nbpH/9LZ/CNtcetWt8jN/Erf5yOe+JC9569+HbS6/7jb5yT/+v2Gbf/jC7fIT/ytu8+n9d8hFf/hxERG5+pVPh28avvLmO+VFf3C5iIhc9Yqny3RatvncrXfJf3jLvM1nf+lpsmujxCm+cNs98u//59+JiMg//uLTZM+u4+O8zfEhRQ965StfKfv27Vv8O/fcc49JvzpC2U8iGh0Nsajn5js6J2v/7Th6ulVFcDeQNgfu6SLT60n0pKPXz38Jt9HR9OdI9KSj+6tvwW02Z40c3UIlWPQ0mzVyz1Z//0gio6Zp5I6Dc7k/tZ87oe0ziiKj/Vvz8fHreJv2uVweREZXb0WMH/scj4w+feN8PB++hkc0n7h+Pp4PBlFPG6FFEc1l18zleN9nbqZtLt3q4z2f5m3e94/zv/2fT91E27zrivnf/uqTN9I27/jEfvMTUYsOvjPg89aPzZG/SOY/+Mh1IiLygSv5M3zzh64Vke45Ibr4A9eIiIQR8Rv+9moREflkEKG3fD5zE0cMfu/SeZtrAnTif354LnOEhPzh1tgj9OaPt57hbQGa1CKsdwco2dv/fj5fRzY50lhDl0Xi+W7prz/F57ulSNdbev9nYzRBROTDV3eoBENsP6r0hqGxWm8YQvr3X+jsDkMtNfpzF0EbP6OQpgMHcZurbu5QrS/djRHAqxXyxVDCz93atbk50LNjTWtzVM46ax5x33ijVeQbb7xx8TdEL3nJS+T2229f/Lvuuuu2Vc6W9MQy2Pkm5YTcQRRKw78MBr/pQMeHwemaz6EjeKHcpBwnltrQjhNw1EVE5Na7uja7gKfu2+wBnrqIfW4n7tmAbe5Qz+SE3biNTkOcsAu30cbjxD1YHv1MWF/amLE2mk5MtFkVn1xf9SW+snEloq8Noj/HIwWZxwUdDTbyRZsgrdjSkUSbTF+bM54y7CXPqsYVpDk7Pl0b5jzolCpzHnQb1u8R1ddBYjf1XNxF7O9hxf9OYut1gHeApDO1s8jaaLt5gOw9X0rsT7feWW+j94ModXqsaW2OygMf+EA566yz5N3vfvfiswMHDsiHPvQhueCCC+j39u7dK6eccor5dyxIe8QsEjmoPmc5ff0543PPkQQfLQ/x1k0bsuBSfelxkb4OHu4WJaud0N9lNRj6GbKNQvNhzpVpI7iRlpNtn9pgI8hVxBtO3EYbYCazptW1qTc6pn3V2XzZ0bEcM9P17emro6ierKWoDqylw8TB0OM6GNRmtUTRoka3wTZRr2dmE7X9Yvb3YF87vqI9Y5k2RuYjvJ7sWNO21qjceeed8tnPfnbx+9VXXy2XX365nHbaaXL/+99fXvSiF8kv/uIvykMe8hB54AMfKP/pP/0nOeecc+S7vuu7tlOsQaS9bzbJh472a3MPWSh6A12OT30xHVrZuHrKzOTp2dch4vDocbHIT7fZJIZW9zUjbbRxpRGhkoHx0d9N2HRJBM+0L9tvhs9q+sq02UmUceBQvUDRJsNnGxzKpmmgg6n7Oro5g/UMus2hozOIzE0V73uObMq995ZbjmlzeFP2EpS0pbsPb8pJe0o+eg3fc3hT9p24u2ij1+rdhzcFVe2tzP4mHANtg5gzY21ifc9YzrbW26yDttVR+chHPiLf/M1d8dhFF10kIiLPfe5z5eKLL5af/MmflLvuukt+5Ed+RG677Tb5xm/8RnnHO94hJ5xwwnaKNYi0p8nyjX2VZak2RsHrm/XBxKafkifhFHE+9QjDysMMQGZxZ+ar48MQHt1mk8DhWh62ERs+zHE6WudjIPCEw5NzQlbjYOTa1OU5XmgyqT+/TCprI+E9ZNpoh2c2a6ADpOU5sjmT3cDB2Eg4GJrPPUc25WTEZ2odDMRHD+uew9hR0evhniObcmrRwqZyMihHxpZl7ELOwajbjoxNXCrAW5VNTPBZB22ro/KUpzwlhAQnk4m8/OUvl5e//OXbKcZKKJX6OZLZ0DNedn1DN/KQDf1goq+DCcXMjT0jc90ApNrocVHYtWcUkoJC6/Iw6FrPKXVUtMOzhDOjZWB96c9ZG712M7B9BuHZSbQxmcjRiqeykUAn9GebswY6N9rpOHx0Bk9b6L4OHsWogkYn7j68KftOREiIbYMcDD3sew5vysknIHSia3T3kU1B5w5tkDPcvmSch8yaT/WlbWLKttb7WgotydjW1L6SeYZ1e7cO2nGnftZFBxMLLoVOHOnn9acig9SCWwblWBUK1A/loPL0RoqWiXhWFc3M4P9tm+67rJjROiqwScqZsSktzEfLwPbrWc+U1vFITL6pczAgKZ+DOanaL2F6b5CHxAbB9EzLyfoy6MSK1vNSNnFVtrUnipqziXW0elXjWkpmbRNXheYfR4jK6KgkSS9KVlGuJ5ltNNrzPXK0HlnzvnQUX9+McjLX0QC+gfbrK4M8LMVHj4sV7mb66jkXdN4ThcSpuVB9sc0zusBtwUeNi2UvdF+8jeJDGmVOh2yXM7NMkaeueWDzodmzuZ+ZNpiPRqPoiZXNun3R6yGlZymneRnb0Xf9sLWa4aPHPty25vrqF1Rk+lqVHWc2MWXvEn2tg0ZHJUmZSU5tRpmFsqqFa9okNlAqT2bTrxuJ3ELpPmcbXN+5WJljuSIjuty4EhuRLiROjIshIez4pukr4cykHKfgJt6W/K2/yAnxny1zFHeWcFS0k8PWhj5+yx3r1ejZqtbGqtZzJi16MGGncs9nNRvxdsxFJqBit1qbvlZkW5dxnNZBo6OSpNRiMidNMhvWcAdDLyam4H09cbapaZSDjyvTJtHX0YSzl+KjnmGiJiTj7GVkXir6TDhOvZ/zinQsUwDMwAuDujBkxjlFqEbHOzPICSnagLH59XIEPKOmacx42Nzr54v4iCR1aBv0jJ52W5GeHc7wSY2rvlnnZF6V3q/GceprW1OO04ps6zL7yjpodFSS1NtjZdCj2YhXtfENhx77p1qWSVdlIssMn54pm6Xg7X5RETfYOuW3onGtyNlbSsd6zvuswU6Pv3sHGWTvhKD+fBs0Z/4zNB9+vKivzVlj2qFn1DTN6tKiPfVsqbnvOa/LtUmsscx6TqBA6woqVmZbtztVl2izDhodlSTp6GRVkOp2w4oHE7UlBxMG8mBik7VtVpWyqacklsnrZlCylcHtCYPUu69EGi6T8svqGEq12BQSdkJ86gf159NMSO6CD9CzQ6vqyzlOaG0UzhVxeGo1KpuzxvBHbZqm6a1nq0oPLZX6yaQ/MvqaWc/HMmWzMlufWM+pGriEo9vTjo+pnx1ImUK2XFTUM4qnkcGKopltiJyWQ0u2AVFJPedEX8vMRe/8+XbrmNVn5ISkUi3Fpg829EybxKafQUtyqEvdmSllHjh27/AAHfK6h/Ts6Mw6PGjsTdPk0jHHdK2uCA1IbcQ9bcd229bUgYd+Njq15rd5XOug0VFJko4UmbJkUJfNRJvt4MM2Yv1uEGbYViezNlok579Zf8795WH1BcfyOSf4rGjsus3RWQPrPXwOHz0jj46g/jwfJHfJB2/Etb78e2ywPI4P2vRd/zmZ630N5zPgGQI9y/TVNI3ToWXWvNpAyXrO9JVZh5n13HutZtYYLZCur3mtZ8fFfmDsS+IZJgrcjxWNjkqSTC56iU3fLpQlFpyRZ3sdjJXJvA0LLjMXq3J4OJ9+854dO0I57FX8ONVSbNag3iO1gfo6DaBnmQ20dIrq8qBnPcSZWZnzkHIMhjpg/Z2iTF9DHZ6maVboxNcjdH3jcy6g2m471Td4G77pH9e2dURUdh6lFkpiks0bPonyHsnwSWzEmXRVLjLIjD3RVwIx0Jtq5qQFW9ypZ7iZ6CvBp+98sVSLPp3UMCfE8U85GPDky2oi/bLoNLGBwlqOOsKTkTlTBFs4TgnUBffVfy5yzxDxGYImDXX2vMzl82kaX0g8HCU8knH01efsNIpZY8vYVt2GnLI5krGJKcdgBv/P+1qNbc3tK7ivddDoqCSpbyqBbvo9UyRMWY6lB72q9EdK5tSm31PmVDQzHC1JpVrcd1G9R5naGBo1+424vmENRzAGIDOrSrVkEJ6BKZsMgjEMTdo+mf27qIbqT8bh8erL0kzbkl5l6zBly3qin0uh1XU73jeVu9y+shrbug4aHZUkbUf9QEpZGBTac0NfWdpiiRqM3qmxFY19VTntzVmDUY5tSrUMhe6H1XuADXRFqMuQFAlOtQxAFY6l4zR4vtwzHOyA1Z9PxpkZVldT8imcmeNgk11ZPVnGth5DO9W7/m8JB2wdNDoqScotgp4b8cpyksMjjL5GYhmEp7/DswyapKOZ4fUeGaO9mUlbFBvWaiLrzEYzNGpeXX1FYgNdmYOxPZv+9hYJD5n3Oh8876tx9laFJs1m9mI9flBBb8TD7VQOZZ5V21jEdhk7VXd4+hcbL+GAjTUqO5tshftwiM4WjuGrxfsiIRk4cBmZ7dixzH3HfmgpFMg6MzUnpG0X8RHBcg+ByjOFl4c2y+c4BFWAMntkJiFPZiNG19wPGvuK+KTGvqL5wrpRn4shTiPkk5jTVY1r0HwNdpzq8sxm9aPZc16rt4ns1Q7amTkM1rLnk7OtS+wrWuYlnk+mr3XQ6KgkSU8gu05cLwJ2hbNPJcC+TOHY8L70ppaTuR6FcD4z9f96X3TsTuaME4LrPZrwdxFUN1I3tn7DQG0QHy9jBr3JpJlSMmfGDtEAyzsjM5qL3NjrfQ2b9/rzGS5zYt4Tzzk37zP3+6r0Z+C8bw7oa+DYNxPvb/LODJp3z385O9V3P9hm26qeLbJRnj8fe72vddDoqCTJKEJCWdgca0XwC7Bro/kkFJM4vn0XHCoCFbFoBJN5MyGzX5Tw5ItbZEikzKbm+SC5vUFGts0bV8zHyQz59N+IMw4Geta+RgbJ7HkjPsXY4XP2z3DYZjRkvjJzgdaGn4tM8XNmvuAzzMicGHsxX4m5yDhXqfnK6FjGmRnIp9D5hDOD5t3fIUNtq7ZTmTZ0P+iESNnWjI2m8tT3lSObdT4Zx2kdNDoqSTqaQidm8P+ajCJQz7cvOrGa6GEpr3+zX18izAnx0dNQdMIZwET9AEYn+hvSVcmcifQzkTVGS/rz2V5EJcHHb3ypCL0+F4NRhQHPeVXPcFsRlQHPOTfv9ZTW6tCkYfPunZnl0IkV2VbNJyFPxuFZBk1aB42OSpJ6K13mPoAllCXjzGS8de31LwNh6s+bhkWp3uAM29AzR31XlSLxb17GRnI1KZICVcg4M4n7RjLGf/iGnpmvAfM+cHP0qMJ2OmBDEAzIp3Cq6ymk4U7Iiua9kKdew7OdDtigeR+oY/7Y9XLpoXpwm0Lzezsh9b7G1M8OpL7KkkmRZNCJTF8MVuyNzFCZOz7UCRlgcNBaGYIqpOo9EpD7UOOW2qwHbY71TQRBuIPQicRcZNIEmfnCMg9J6wzb1IbNV8LRTejY8Gc4IK0zuL7LzXtCx3CKrb9jkHPABtZlZeZrwLwfW2eG8NFpncx+kKh9ZHzWQaOjkqTtULplnJm+MB5XXtsXLF5N5dDrxi1jcMp6j8SmNtgx6J/WydQPDO4r48gNQJNyzsxqEJXURjwQBUo5BiuaizIlUTTZtpTWYOcz8ZwzNSrDkLSBjtwAB2zwXAzSsXpf6Bn6j5ZDz5UdT9TMZA5y8BqVsZh2R1MKnUjAZqn0UAYOHODMZE7QDI5Sh6ATK4rQM0ZpeP3AsUuRlGjSimpdVlQ7gZ/z9iBgq9och6YbhtRX5E5ObecppO1K62zjOt0upwjyGaKrQ+erPhf+DpmMMzPWqIwUkk3HMOdBoSVEoY70dWaoU9QvrSOSO0GDc+gDnJCE0V6dkSznY8hpgsGbWuZEz4C+UsYWPOdBtS5o3gfJjDb0/joGN1nPZ2gabpvqK4bPe73we0iNUyatk1pfUMe2qy4rMe/b6Hxul45hna8/Q+/MsP3AvCMtEUgv48ysg0ZHJUkZT3NlNSo9vWORbO67XqSXqh9IGYp6JIJh52NYozIk4lsZOpGI0BNjX1VaZ1UptsEyFxtf0WR16bxB87UaHVtZnc9QebZJxzJOda5GpWiysrTOds376tbpMLvqnRmW5jdI/Vij8uVJmdMxOWitX43KrFldHhkXryb4bFP9QAaZgQZ5ZUZpQN3IYIPTfyPOjP1YGsmVGfaUsze05qH/vA/V+e26EC8TLKTma+gFawMc3eE2oX9qbPBcDLEbqfuXVqPzOeezaJKyq/5CvMw9KqzsYB00OipJssVKxAnpCa1tztilZ/UTELm6kXrNQwG5D7x5NQMFr+yI5QCjNBzC3a4ajFWlG5BhX1V6KCHzNkWy25tqWZE8K7rdN5UmSKRIhqRxMzq/urTOap7zquxGKoWdmq/6Wk7ZKDhfq3HkMrf7FnfIjIjKzqO+xUrMCVlVlDok1TI4ulxZ1DzEUGxn8er2RI5DN/TtQye2c977oxMr62tFyMzq0KRVFV5u34Y+6FLBgQ7Ydj3n3NiHIjP1sW9Xemh4wLUiBywh87podFSSpBGDzLXKItmbV1ezeBFKl9rQBxyN3M787+pOD9VRqe2qUVlViu1YpnWGXn0/KMW2rTqWSLGl7jYZ4MitqkZlZWmCFW3oq6pR2c60zsrs6orqsrbpyHluL8jIPKyGcF00OipJ0pPILz1LpFpWBIeWNzEORVT697Wt0H0mal7RaZRVpXW2K8U2VObt0rHhkLsfe31cq0vrDEuxrSrVsiqZB6V1Vnb1fcbhGeaArU7HtifFNvi1GoPGPsyGp07n+b4SzvCIqOxASh3RHQC9bu8NnP0djFUZt5WdRhlcn3MMo9RtQ3iKJsPQpMGb44DIcUVO7GAd26YaldRpFLh2BqzBgS+IHIICrQpNOpa3KA9H/4bMRdFkZcjMIJlXhUYm1g7isy4aHZUkrSrHlzNu/Y3AUMdp22pdVnT76Kpy+qtDgVazoefkScz70BqV7aobWZljMFDHtm3sq6l1WV0dVEbHVlSfM9QB27bC5m18hol5H1bcuyKZUzUqq0mxjYjKDiNfDS2S82wHR5fFa+hLmVblOBUyD0QMtqtGZbjhWhVy1X9zPJbvc8no4eDIetCJnu07Vjyor8zYV3QceOg7cYoL8Y7hUdbBCM+qbMI6j4EPXO+DUCAwF6tKww1B/1J7weio7CzKoBXzdsfwKOuAupGh+fph6MTAI3urQgwGLMzhSMiqjhWvxplZVc3D6qLUen48NV/bFaFvo47lamaOXV+rukNm0Po6ps95+9b76lCg7ar9A/PuxzXWqHz5UcbL9xfqsO9lopXMXQcZBS6LtYomg+6CyEUQwxZC8VwH5usz8PWgqHBw/UA96vFFcUORmUyUmtOx1dQ8DLpGPrOhw7nYHqcRPsNEgeKgjSZzt9JAxyCjY6t61cWQ+oqhtyinirGHzHtCx4banyE6trILJwfasXXR6KgkyCuLyDADBFNIA43bMGdmWDQ36N0oA2tUhjgzGZkzKbah0VNG5iEV/piP15+BKFnqsqnEvK/s5NSAed/GS/yO5cmpYegfOFm2bafzhunYqm73Xdl7sga9c2qYg7FtOgbW+3adnBpvpt1hpCd+Otn6rKkrmff8M8qBnJntveMiEUEk0IAh6aGhTtGQCGLoKaTjv0alaDIMKUohM8P6GqJjg9GkAWM/tjUqCZ1POWBFk4FreUXPcKjO+7GnrtkftpZXVaNSbvp1G7Xu11gMQX1njcBLS9dBo6OSID2Be3bNH1l0jfKeja02gQK1fCIlW/Tl2mhnpu0rUjzGR8vN5MF8uBGI+7JtUn0FhqKfzMP4tP3HfdlnuLKxR/O1mHduJCM+XuZoM1q2r15jJ2tHJDcXGT0s+joWOhau07r++L6i1Fi/vvipltWvr4T+BAjzMVlfA8aeWTurs71DdayU2Tsh/hkyXuug0VFJUOvlTyYiu6Z1B2MvWZhayfa2ShW8g2EvUTzUF0JmWl4tnyjq2Rsa7ZkbF+CzafngfPTM9hUsuravKBJhz8fwSWyy4bg8nyC3u2xfveYrYWwXzzDRV+TMhH35+Yr4JByDZefC9xVt6L36ip5zj3kPn+EG1/ncfLm+oue80LGiSWkTEjoWOUXd8yn7KtfpanQsQpOivop1uio+gQMW2oTNum7kdMyu5Tkvwmdjqr43Oio7htrFvDGZyMZW7idyMDqv1fLRyrp3NzYmxgnZjRX4KGjjFVh/ZdFXZAQIH93/3l0bUB7EJ4Kv2bjmn7ULaiMtc2godkdG0vaV4RNuEIE8RxPPMNNXMV+hkeTP0PcVOjO7udHO9LUwtqGOzWxfK9OxoknZV7QZZXQ1ktmPfbCO2b5CZyaar03fV+DI9dCx1HwFqdVV61h098vy69TySdmoaL6WtQlu7CLlnPlnOOeFA2nDZ0z97BxqJ2s6mciu1lEhirAxnciujXmbqDiJwXTGCSELcxO1CVJRbCHMZo20ephyDDIRaGZzzBi3JfsqjQA/spdDDLb4BIXV8dgT6MRmQubU2OsImB9Xar6WRUIWffF0Q8po99KxCFEJ+GwmZO6zqS2pq4XM0UacWl+rknnV63Qb++qlY20guX3zXtofXrTc8kGvb8FOCN5XNKJS7mG2Lyb3Omh0VBLUTuh0KgtExRuKtvJ6YzqRjQl2ZtpJnzszeMPSC4PlLnXfmTZsczxinBkc9WwaZ4Zvskcym2NmYfo2wTsymMzz79UdgyMJA5jj03/s2CAn+upRpxE7RZlnaPvK8Inec5RxnKK+cvOeGbt7hkjHBukz17G4Dso9w+DEXEaeTI1TRsf6rQt0GiUvczz21epYPPYVzXtqndq+ZsAJ8X2h/lpdjWpLUnxAG7Q21kGjo5KgdqM2qZ8CnVBtFogK9nwjPrYeBiMzGkakhbuqzW6SQ9e/7ib1A1o+tuiapnNmFnwQGrDVaHeU223qC7xdzLsT+fqor5nbRCCfhMztUEN53LiiosGUzImxh0WMxXwFMvcs0mMyMx0zfKKxN6uZdz8uxCelYynd8H0NXBc9dD4ufpa6zJnnnFmnng+a9x5jPyY2wa/TZfmoNr54tZ0L42D4Nu75oP68js3lxnvGnsAJafm0GYE5n9FR2TG0qVI/rEal/X1jOlkU3DKITiMzocOz1cbbG/2d3buwPLpvWjPTlG3KWpe6o4KcmajWJWNwFm0QH7foUA69/SisqE/w8cYkyqHHfOrjWp3M/jkXTYrnPFzm+pxuFx+oYz0c3ZiP9OaTkhnWzLi+Es8nN/ayr0HPeeg6zTzn7dKNhBOC+UhdZsCndEJKx8B3B50H5oREzgzqy829d+QgH1DiMNao7CBa1KhMdY0KvqdjOlHpoQJ5mP/cCGpdTF+k1qVRfS1OIQXvlmCRNXJCvMymDYkgUF8+empAX5lIBEa7bhPBbXpsWEFfjecDosJMFNYOP4p2UzJvU1/Dx277GjwXqTZiZQbyFDIPfIarmotSV8u5GCQzHLvtC857JlhIra+tNhvLrose8vTQsQglW9b+eJm1jIXMJtWC7fieCC0BfJit322QELI/TaO9Z/5zYzqhe9i6aHRUEtQquHFCCGw2DWpUEDLDLjOa90UQDMgHe9kiOoWEZRbplDxCSxisqp2ZHB/myDVq0bUGkBtb1pf+jPU1l9v1FcLyEZ8+8mQg5aCvzNh7pUgyfLg8fWDwHB+8LhCfofPepT9w0CFSPmec/vB8ltUNbFuwzAPHvip9TuhYbp3acaHi1SE6hmV2fYU6Nu8LF69aPoiXHzuSyY9rzgfb+owTsjGddBeSkr6mk/kehfrq9jnlzIw1KjuHkKdJvdHAedBeLeNj6mG2lK7kIwk+nfLWZBbheWTTJoHMcGem7IuNXfcVG9I6qpAybokoLOZj+wplDtCJnMy+r8DYBpFjWVOExu7l4WhAPF+OT4DMLFs7keHTeD4BGrC8PNskc2KTzcx7rt5jmI4VuoqCjpTM/XUsQq7aNrOmvHl1Mfag6NTLjORGbZhN1H0xO75rOpUJcULsqdTY/m4ETojen6YkkF4XjY5KglrFmEwmMm3REpInnJjaEuaxSscngZZEfDaYPCAVFaEcC+WNal0W0YppYmtUyMVEmRSSLRLGOVKNuoRFng5WDfPaG/g5z/t3fUV59uBSpg5Sxs8Z8YllDuoQ3LgyzyfM6S/GXva12dSfYSEzej4Dxh4/57xu4NoJqfLxMqfGnnrOmbEXTXJjzzzngg/oy+tYVMvRR+ZwLvI6hpwQ30Z/1sls+9IyMpkxn7INs+Ot7YV8FvtKYOsVErLlp4TOTJ1Pt2eMNSo7iBbQWnTqZ4FgdNAau4RNoxx+zRmvligUkqeIDLZ+nSrnyveFUJdiMSm+THn1V3YRY6K/s4s4IabNFBu3BvSF3kfR8toVbNbt11hfiE+0OUZ9zVxfaP1n+mp8m0RfmXFFRYxhXzPf11CZ/diRzOLaJOYCtvF8yr68zEvr2IJP2VdOxywf7Ditpi8vcygPOTiQ7avUsUDmHjqmx1HIrNMxIBDSfaH+0OmY0o6DviLnoWLHNxTKwWyivhqD2dZpZn/SzszxAaiMjkqGbA4QGwGtdLU84US1YYtAoy5eMbUHTeHAWSlPkWtVqMuE9dUoj54puEZmSPS9CdqUfES1iREn05dbTPq4dNsGbTSbzrhFkeyuCHnwbUI+9XqGkE+mjesLbhCFzEWTcuypzRrwSY1L6n05eSLEIJr3FB8ncxTp5+aijpaEOjZANwbr2AB9ho5lar6k2hdyYtlR310a5SCbtW7ju/PjQnJ7XRXhaMnGlDsz2v6yl92m7LhCXTJ7BuOj97AJcXjWRaOjkiCjCJU0iobWmFe7oVNIZCPOoBxRjcrmrOQTQYYMDtTHpWsyi4jspumq7v8MUkZ3v7BFafiQcUVtdDvWl0j3rCMYPJVGcX0NT/3UxzUo/REgM8umY0qZiya51E8hM+KzKpnr8+6fc+Q89EuxJWQOdKwPn6Fp00xtiZ/3VKousU7n34tlRjLlUj+gL3bUV6dsIttaCfB0AByWAiT2DLY/6WC7uh9M55kBxGddNDoqCdLw2wbzfFWbTlk8H+CEEMdgnm+sFO5moL6gHsZAhjWnKJH20hXlLJoREXpGH7UpoVkp2pQyl20Q6lK24Zt1dK+AbxOmUYjMkA/YHJsUn602UfpjkbJJIDzh2F1fMP3RQ+Yec5F5ztApSvTV+HkfKLMfe2Yu4vTHqnVsRfOVmYsIjVykPnj6I6rl8DLr/pk8SG4/76hNZ8e7AldmN6ObyttfdcBZOEULPty2LlL4oVO01VcQcCKZR0RlB5FN67BconYM7GctmcKoymZtIDrqrfOUDUJdWHGZTiHRvqYiNO2lFgFTcJuyYahL93tbCc8ipzmfeuEuSwFsJvrS7fqkJCCfNlILLpLyfOJ0VSSzVPkMSwGUfS02kZWlEoIangyfpv4My7GXfa1K5hSfxFykZE7MRaljGZlRm/nPVp8HP2fXBrWbubWjP2MyQz6gTUMOBlg+2JbpwwzU/mZsq6kjxDYxqmNp5yIqKbBppkT5AqmHWReNjkqCTN0IQ0sWG3rg1W79ujHtcoAh6lJFSyYUolv0lfCgo5NBDeLD5FEQJkdmJODT/Z+mkNR3dhPEALYJUJfdZL6aBB/9vd3EAdP97Sb6g/hEp2OiNotjmAm0ZHeiqDI19gTqEvEp+krwCZ9zorA55pN5zhmZfV9FE3VsNkIeBsg8cFzFM1yRjiG5/TNEvFCqhdnWkA9qQ9ESFXAGSHTNltnTm+LabPWlglvKx6SHCB8VTDLEKbyuIoG6rItGRyVBME9IPdaMY9ClkMLCKOoUSceHbBCmcJfA4AZ1qSAhkVOkEZ5eMhM+IuqyOxJhiOTqWFhNiHVmcJ4d8UHOTGcAg5z+wsGoR9Z97lGBRzULPkWTLiJO1HKEMs8GyDxw7EVfoSO3JB8nT3Qkts9dK4Ofs+eTGHuEuvTS1ZTMPNIPr213fOa8sA3qe28JOzygC1yZUxS+LsXYVtKXsom0/q8p++J8kvsKcYoM6tLa8QgpCgKPddDoqCRoUVAapFE08kCPHs/qiqBRl2pRbgLB2JjKwimiR98CqC+TQrJjt99DfHLHpRmf7v/sxAFqw2DOeRuWQgJ9FbUudXk07xjej2W2fAIEo4D3yzbFkeGBfTULmaP0UP++sMxi2oS1HMEzLMden4uczPU2Q/sadsS73mZ5mfkJGnRkmNaNBG28jun+F7/P8n0te62Dta0xGmuPFZO+psGeoVAXahMVmk9TSHrspHzByEwC6XXR6KgkqJ3kSXAcGB4RIx69Pv4VedlTopj6yHAHPTqZEzCeiQzIuLRzxdJVCE2K6mropXlN2SZEXViEoZEQ9hoCg5bEi9vwITLrNjHqEsH7TSiz/qxrUzRJQfeLKDW4m2LW9JAncRlXxKcY+0CZi74yfIbK3Of5rOo5B3fjLBCMpZ+z5YPQEpTWoWiJvpOEpC10G7ZWoxTSAi2ZcHnshk5kRrYsQF24bZ3/NHUjAeoyYbYsY1u1c0XQki5Q1Okh08TJzG3HOmh0VBLUQYbBLa8A5aBHfTVaEigvhfpmXV8UMjQOTwxh6nFFcGn1RsNpHZ40qEsEc7IUUgPGHjgY7OSLubMl5czgTS2TQjLITLTJLow/30Taj5ZNxwxpA9/8m5B5WNqr7Cv3OgMvMxqX1GX2fDLPGY7d9ZV6zoHz0GfsA3XDP+c5L8xnV+RgNCUftg6j48AwZUOcEGsT3bj0hl61rXVbb4tOib3TfCKZaYC3JXNkW1s+Ks2Us63c2WPPcF00OioJMse/ElBfNf0RpYfARpwplI3SQx3U58dV8mGGRL8aIIIM+bjmP/V7JFjhbt+7aCLEiR9hLp0ZNhe2TeDwJIp7eQqpKVIbqUvqEikAFBT5vqLakuiYcy6FlOiruFW1Pq5MGiUlcyKFlErZpNIxw/ryMofHgXvMhebN+IjwwCO6CdbrmP7egi/qi9mX4FSLdkL4pl86DwzhiU5dLuxvKmUTBW9K5prDk9gzIttqZE6lfkZEZceRhsToDa4ANqMox1SCG2XnP+1RaN9XtxHTanGNzLAi2MWGnsjHRmmvRvVFFjc+iofHZXKkhI9JewWFu+yGRZOyocelpWhT3LgL+ERHodnFVrrrPm/IXVXKBtkjf8Iok2qJi3vrm3WftzlDPn1kDtuIk6cuc4wUBc6M7yshM3RiZ/VnCFM2mVQL2UD3BGhJJmXj71FBfSHElqEu4W3dxglJIBjMeTCoN+7LptWJHc/IvBh7YFvhuGxfOl216CuyrSTYXheNjkqCLMox/4ynNiRADJB3XF9MNMIIUj8GwailY0I+qk0FdYlgxQbw4WOPnqEomdv+61EISyFFNTMGCSEbMWrDZBYJ7pBBfJyNaJA8A1GFRUQc1Cr4NuEFYqkL3yI+CXnce4VCNGnRV9Gk7Csjc+YZRs+n13MeKrPta84L65lJ2RCnOX7fzVabDOoSpIe0fWG1HBoNqF56ptGS0LYK5IOKTqntCG1rJ3OfN9xHSFHVJiaQ6PjiTiUzCbbXRaOjkqDUaR3lsbJLgDTqUj0OPOXXGOMcqe+rVEz2SvOwwFV52R0f25dZBLVxBU6INgD8GaKxBzKzhQuPeLu+EOpCnqFuE70agJ36MfUw5BItVAAcoSWZS8/avjIIRlR/krkYbdFXAsGACI+TOYNgRM5DhMx4mTOoy2CEJzGu4h6VhutHhIT4cYnw9RyiLo2d9zkf4qgYeWxfrTOuU8sROlyrwZgk7G90HBgFSxR1MbbV9mX5tGPN2Cknc8a2atSlWlcT2HFgW9H6WQeNjkqCtFc7IQvFIhjtZ0H0QCJ9m48lDob2sglkiPjElwkxmWUhc60yPURmTEqr0pd2QgJDwhCexsjM+uqcotQldZUoRIQ7BrrvxQVZbv3rr7BLtFBf3o40qK9osyZOrG7TvSyvaKLSTHwj9n3FNRiZUzb1NEq/W17rfYWoS5++olNaZKNGfOb919uwtWHeU8OQkKCY1l/4Bvkk7nvSSHT1lu1k3Ugd1VWnCllfU25bYf0Jc66mdTsepdUxek5kDp6PtYmVQDFw9tZFo6OSIHzhG2sTbGogt8m8dXNRG70FlyMG8AgzuS46F2HUL3ybKGMTXm5UiQyi43EZB8NeUkcijFlmvmTBp3bsWkToe09Sl9QB1IUZkpAP6Au978ajLqs7rcP5RG8Hzl34JnWZm4TMs4TMhZM2jE/uZJB9Pk0D0BI3LsTLj33OG8sTOTNeZi2jbzOdBjUPYAPlNRjBScitX6NIP2dblX2hdqHrK5eixuOCe0aQQqpd+BbaVmTHg7FvVOdLqL1bF42OSoIyx4HRUbNo4abeelxJx2yEC07LvCUjjWa4U6Q39MwFdGxRmkLZqszqciNiSIzMbi0Z1KUaySXmy4wLRzy6LzYuEV7LgdI6TGbdJrrXJfVOpaBYNJVGcbUKMI3i+YTOQ4TMeHlAX7OMzK6v0MEIZG6GyFzvC7XzMqM2kA91eLo2vI4l4jP/aeoiSEAVXe2eqp1A9neAbdWoC08J5+1UdKN3o55PlU8QmNkjw1bGoo2pmRHbxtjW+h7GHLB10eioJKhVwrlXO/8sQgxYlXc751GErje+RWRAFnd0WqfRfVXQkkkQhehxsRM0elztYmLpjwjhaRLPR499g8lsor3YaOloL6zhqdSxxDJ3/2eGFhfKur5moE3hOHX/Z6gCKtwt+ajj0olC0AjByBSL+r4yfMJ0VY8C15TMwF4XzyfRF5IbFZ2WKYmSD9OzqI0vEoZ9qZMvE2KDFnZqyqNvs1ZJXYRGMOq2NUrZdHxq8mjbyhynSbavChISITyZcS1sYuRcbf06CcbV7Sv85GrHhzuE66LRUUkQQjloQVMCnoyuvu93mVAd6jOV6QyZCSMMKfqKUJdcHcv8MwZv2wgD97WhCsfoKYEg12qeD43AmgWfWm7cHGcc8KLJDOqif2UFnDD1Q3TM8qn3hWxWLvUT96W/1wstSSAYscwBnwGoC3JmMkgIKl6lRbBBYSrkQzbQ6LSOieJr62fCo2+NutRPMOoiz4QtS9lWK/MsYVvhpWcR6tInRR3wybzrh9rWWSlzZFurSH3gfK6LRkclQRrGYwq1aKM2Ygpz6k2fbBDhcWBkAOgmyyvltcy1zXoSjB05TimZ6eLm8GSTGLuBZglcalI2xCnSTkgVlg4MQJ+i3MlEXVJHDJtIdAtu6fAwWNrwCVAX1he6pC46erzsrartR71eAgj5uL7C1xDk0aQ5L+aE1I8D933p3rA285+R822KTul6Ljc+zofXqORqOaRrs4RttenweG2EdTVo7PTNyPVUVBjcAkcuClxrBycipwgewBhvpt05ZC5GY6gC2PhoZBDBisqDzhRYZW7BrR1hzhyXjrzsGShAKyFeLXN9069FPBaetH0hSJXmfqdBFKKjxiqSFtXVIKPOZK6PXSR3Uy57LwxCXaKi3BTCE72DJuGELNIfKdSlKzplbaJ7XXybTJFw0/DUYHSr6mZTtvHd4Svr8XreFaIl858mZcP0LNj4oF0o1ur8pw5yuH1JoCWZzTphX+bBgP1eMfbAKbJBTrwObUqYjCtbV8MQ24TtMNdeVGxrKHMiKF0XjY5KgrRX26eWgx6bnfBIX0cGteN6UQrJoAGVSF9fUoeudm9lXkQYCacoSv1Ua3iCCCyTRrEpG+YQykLmCemr19HAKa/hsciVwDbIGLNTAhONkgVISOpyOZK20GxZTQjig6D9AnUBtq/9LHWZW3i5nJc50VeAukR3gHg+WsbF77OyDdNp64T07wtFxGEAQ9FYUXzIuFJ8yvUTXSVQ7Wsavcy1k7nmXFlHLrCJBC3RMi8QHiKPvdLC89H7Cpuvjg9Lsc0An9K2ds+Q29ZuXGPqx9HP/dzPLa6mb/897GEPW7dYhrBXG3i+FdRlEixuFKFH0GOt/sQUcw3iIwuZKcKjojTqzCRur8XIA48MmINhIsJKuio8gdWUzzADgbO6msio6+iTOp+ZZ6jkYzUY8NUAAZ89u2Idm/PByIxBXRIoR9tXnELC8iA+Uf1J2wahJZmTOC3vls+cN5ZZt8mcxGFHUPXdQNGaZ6fUdPFqtZZDp36CtcFrObq+WH2FQV1SqGXsFIVrDMkcBIo12xq9LsVeUmf7h3yqSH3S+aS2VRZtMraV2bt10a51CyAi8shHPlLe9a53LX7fteu4EGtBJtKvbLKZVIIpBCWeb3QdsoZ4a+kPC81GfLa+F4yrlq5atpjLICEVODmCVE1kkJmvKpxcP9ETFsRBo277slB6y5s/H85HG5sY4hXhJ1/QCSOG8IjwQtnMSaUZagPs4yJlE5z6WaRaovccuTZtf8pPKPpCY5uBNmwzMqd+yLupNoK+dAp2YzKRo01T3pGiN9mpiGxymVOF+JNgjUG7UF/zLNLP1Mml0rRBKipzCWZm7F3BbZDCBzLTqxYidFjtGan5qgRUvW3rcZL6OS48gl27dslZZ521bjEo4Q3Ltml/nwSRfgMWLtv47AsQmQedQ0sYwoNqORicHKMKncw1GFijLrkjzLiv0Iii5xP0VUvVZeqFNMJDn2GYqqs7chZ1YePqZK5FzCLJ49LkRXh6CMwxwGmmehtcvOrawNRPY9q0n7VzrPvzJ1/aZzH/jhRtUnUj5BlFdSw2VTn/Tv1KggbM2fxnZu61DkVpi9xx4C0+VKf7ISHMiZ/bxERfVWSm37j40ewIjdUyx47TvG7EjsOPy9rWSGa2VoEdD2wrc2bWRWtP/YiIfOYzn5FzzjlHzj//fHn2s58t1157LW176NAhOXDggPm33aTzlpnK69pGE+UJNepCHQyFYGSgvtpmbavFbV/oIqUM6jJMZh2FVGQO4GR422U0Xwl5qieVohSSvqSO6YYxWvg5t1+xz5nwCcZlYGkGOavvsDc+mza7sGHTz53yAW0i1GXRpuGR9Z7o5MtMijYsao74oL745Wl1PvpOEpaum6+fmE+LuiA++vgtPd4P1zO3ZbR+S/Fh6apM4IGOS1Nnbxo5MwJkZmMP0l7G4bH9F/JM6nMRp4RlMS4alEKZTZMkEq0dZh4MrIPW7qg88YlPlIsvvlje8Y53yG/91m/J1VdfLU9+8pPljjvugO1f+cpXyr59+xb/zj333G2XsVfhmEl/eD6yaMPSMX3fjFw7RRJBs2iTpX1lZJ5EF76VMrP33aTyscHYkTGOkRkms9pAqDGe/8wU90YXKTVwvvi4qoa2b7oqQEuYw5N5m7NBXchx4Aa1CVEXfXmauHZlG7ap7UqdsuEXozWoL5q24Cdf9HxUU8IJPYvXatdX5gRavU6Oo7HIMeDpcB68odufi3nv816hwAkxa7WCuoS21QRdsW2169D21aA1n7CJmeshovocdgppXbR2R+VpT3uafM/3fI88+tGPlqc+9alyySWXyG233SZ/+Id/CNu/5CUvkdtvv33x77rrrtt2GXUtB0dC5j811LcMPGlgzij6riyUCHZFqAuLviO0pCsS5hGhPYZoeRdtMpHchB8HRu/o4QWuS76fSLWpFQyaU2PBXNQQnug5mw2EoFKZom64ERF55mOLZRbh70JCbTxaYutqJvDzGeAz/9x0p2pUFB+iQ5YPfo6tbkRjm+g1ltGzzNxTpIxH37iAc4B9McFAPHaTzsyknwO7QNcYCroiG0Rtq3TjWsq2AjsezhcZe8a2GgfV8i76itBzNa7j7e3Jx0WNiqZTTz1VHvrQh8pnP/tZ+Pe9e/fK3r17j6lMGC3h3nr14q9pPdKPimlN9J1ADKrGZsojMJ3TrtXVRFBxv6OTuirfNMFvAY0ijBpaEhpRUTILHJdGXVi0Z5Aislkb3SDRTAZ1gchViLrgvmAxIOlrMokul+t+z1zpv9shGG1kp7/iLzTbvVHj032uj0tHL+9rv5N5CWA795uzhs59p/dNpU6jG5dts8UnRF26Nuw4sEVa7WeFzAk9C+9aUWuep2P0Wq3otEZ46NrQt2N7PuWa93bBvBqgx6nLYaglch7qtjVzCeYy6Hl0rcO6aO2Iiqc777xTrrzySjn77LPXLcqCOm80yiFrRZh/VsKcsmhTqxa3mzX31hlEZ71svOnbI3RxFBI6M7NyEXiDrSODWmFdtODs2PEzRBEhi5gzJwkmKsKIx277L+XhN1maaCaB3tSLe+tphKyO9budFI9LRBfl2metnwUrTNV8dptCWdVXU/blP9fyRUWw+sj9hKwxdNFhVM9A1waIZFMbDUXKNDph++qz5jMXiGXSVTZlU7eJ3LkS6mBkbCI+3m9lzp36Kfnw6/ozxb0KHU7YVrbGItvaC4Wf8iB5XbR2R+XHf/zH5b3vfa9cc8018oEPfEC++7u/WzY2NuRZz3rWukVbEEIn6Hn3AJ60yMzWZxmYkyhmVOticqQZyDAhM097qcigAoWGxxlRio3IbAqbGXoTpZDU2GvQbAZViIp7M2NHqF1ZkDz/GT0fWJsUzRd1vLtx1dII4djV5slSLebuF1J0ap0QjHKgW3m93CjN5Plo1MVeIGaGpo4Mcx2ydwzVN/1eaYvIeUg4u7m1KiGf6M3IGT0zSGviZmeGlpi3OVPEQMtsx4HHnrGtmM+sqcsMA7MhthUirZFukLEndGNdtPbUz+c//3l51rOeJbfeequcfvrp8o3f+I3ywQ9+UE4//fR1i7YgG8nOP6PFosartXxSyIxyilhk0Ki+ag7GRHvrUXqoCu/njgMzp6jRfS2BJjUpQ1vK7AMDA9sn5qJmjCdq7CX8r6IZCieXMkfPmb+QsT4XFkpPzEXFudKRXCvT1D13PV++P1soi1EOffcIu4TNpH521ftqHb5ZY5+jbr+Qe9bQzUiPn8995Fx2ffWq5UigLnEROebT9NCz6PUbDegrrDmj46rzQW9zZhuxtQt1OxXeEJ1ANvkJRtVXBWWePx/Mx+pYDzse9UVkXhet3VF5y1vesm4RqpSqCVHRZabwMoNg0EWg0Jva8dKwlsNEcrb/kk/dKcpE3+GxWfScE6gLRyfqqbrUcw6iWHRKK4osaxFzdPrB6EYl1aIL68LnzCI5pWPaidV3kqATT+13p2KfhY4a/fjbvr3DQ1EXchxYt2F8dL/t3M82rROi2xs9U58z1CWK0DPrufqGXMPHNMFzH0bWDJ1Qm2wGcatG+gnnKmNbg5SERZxiJy06ftv3Oobq61IyKJlBvU0TiLrE9kVwG20TK4F0ZBfWRWtP/ewE6nXaYhq9R2L+09ZF2L50njCTQmqNKIsMok0NFnNFCEbFW7ebWuQ8SNjGVsFjmSOHEMGcDE2KLmRCBaXRjbsL+D+BzPi+cKEsN0h8vqTgQ9GkYEND8ni5TbHktPzc9KWQKy832kBYXyLuJA5BXVihsOapNxrWF9scSz7luHS71Nxno+/E5tjNPXNSo3VY8uE1GPWAIa7lAH0FyNUqbGuUErbIFe4rY1szJ5XQXETXOlSLqCfcwUBvsh6iY+ui0VFJELpwyM8f8sTD42iVKMSkP5gzEygUgjmjW1Uzm2P97cBSjQxsmsnzkUWb6l0R4V0IUo49Eeny+Uqm6ogz0ycqiuBkCxVb3p6P0UPaxqarzHFgMBe+P1MgrduozcgWMOqxlHy0zH78ei7Y0X39f5ba0M9dy21TP5oP1jPLB8+95sn46N+j9IdFuEo5TRu9DgnqEqYAgJ3idkHoGrPFxlbGRRsgc7HpG0duuG3NpOqgMzPAtmbGhWxiWIxdCcy0jjHHKUrVZfaeddHoqCTIRCpEoTJQH4pCouNo1ZxttMkqb51FeyYyqEQ8cSSnFnetHkbDnFEevtfRQMsHXvhGZI42BxPNMJkBLJ0xkJmjgVGhbFXHglQdiry1DIaPczA0L5T28nIjJ20+ftXXTMus+gIIRtsPivTL+pNy/NqRYBuffg5Wz7AzY5zdqE1Cz1j0bVAXEjVnNr6ml551tQq5+i1xbcpNPz6lZj/zMmduVY1sKyqUTdVvUdtaP3YdX86o+krMRdUmTiM+0o2d6oZ+Pq2Mx4enMjoqCbLe6NZnZBFMJtiI6u/YSLZ/ZGAisFoKKUIVVGRQNVqBl62fTxWZiTZrsOmHqEvtSJ9KN/C56IdO0JehJSLmeLMq550/Z6k6RR6dsGhJ2ZfnhebLy42OlhZtCOqCNvR5+gxD01pXRbBzqSNLEa1niya2/oT15dogvS9QFzAfeowM3Zsl+tJ8Iz3Tp8LoMd6Mo4+i72CzrqGWkyDST9kpgCAPsq1mbVjeRV9RqgXZMjr2OjJj7YvrC86X5yMFH46SBciVlpno2LpodFQSZL3aysINkQfZ4pOp8ua5RO358vzn/Gd0Jh7lSFMIRoAG1KryTRRCvH69UBhcmssz1wvroogQ1Q7EF7VhmRvVFx97xyd3gVbXl0k3qLkw6ARIbWjYXn+uZfaoC+Zj+/JFpws+xCnSMosQtGTW2DZgo2GoC7tHhdVUGdSF6BlFXZTMeopZ9G1Ql2CzhugeDSoyesYDBo26ZG7ZZtE3QoczF5pl+srZVtMErnkeMHBEMmdb9bgE8sGX1BHnM3BCLJ+tvlKBUP/5WheNjkqC4FXHARJSq+XQkQp/CWDgrWtPnHnrqQgMefSez/xnfJsu8tbrY2fjimo5YDSTgJPZfIURoUIDMk5R9USC7iu68I2e2JCuL4OWlHx0FOt5IZm93CjynrfBMtPTOkpmEYF6pmUWUfoKZZ7/jp61R12Qo8/4bFLURaU/AOLUjq1WD8PWs0FdSMBQoC4LxEAMIdsRbXz1OrkMwlN3nKJNFq0xhmCEJ6egbeW2IxNw0ss0ASIZpbFraOwkQnhQ0BUhvwnUpY9tPU78lNFRyZD2xDeIYppit8qGpfONLPUTRRgo/ZEp4CyNjXQyg83B88lsxOwETepCph7OQwRd6+gqczSwPl/RCZpuXPSttotnGBQeAqSoaTxaohwejXLoNvoZqjbWmelkVk1w6sejLgANaCPvycKwlzxb/UIRsR57y8/3VfIp596jLkjP9JxqfixdpaH7BvTV8kLOZVHcC2Xu/m/XKubDjgPr49LaIWbOTHT6w8x9JTCza8z1pTbQCekr8xLWPukqPRf8xFMQKGq7UFurE/4MDdpI9wxZ8KmVAtgj3kTmtG3FMtsTjHjvWReNjkqC0H0aFDYznq/lg953E8GKLB+bggz1pkaPPCJ5bF+o0DEaex2erL+jZx5d2f6LvgIIvM99NQZOZhD4VDuo3Kgzh6cxBsDKuJCHnrIpx7UxFXMcGKUkPBLCUjbWCSllLlJIDeircB6wM6PbIHm6lI39XPflHYyYT4TMOMfJbPqCZQZ8Wh4oLWqOS08TqR+CuNkiYebsqb6CjSaDAGq9RzLr/uKUcOmE0PotpWepwl3m8ARr3gaTAmVuUF8MLQnSZzoYYOPqYxMjpN7OV03mRAp/TP3sTMJeLfZYw5SEgqarG99EuOcLoL4yMpBFm8xmnSq+q6Z+eC2HKQStpD/CqvxM9GCcEByFZKryYXFZBt5mczHVkZNLf2iZSRpFOzwULTHzVX6ux6nnXY9F99tGVygi1m1EcIFvkWoBkb5+ziKxE+JTSEieVlZ0d8fMp6IQguHHBeTxqAtCS+hxacCn5QWdIiU/S9MWqSiwORrUZSJBpI90Otj0aZqp1DMW5ESF+KnUj5qPPmkvmn4O0KRM2gut1ehdYhypL2Xm6aHMnoF1TMTbVjuOddPoqCSoi/Trx4FjyHD+M0olwMiARRhTbLQMH5PawOPSdzNEkVP1hJFJ/ZCxJyK5aNNHBZxDDBs2kLgvfUldBCenHEKNYKhm6GigH9smqVFhaRTjzJgIveOjmoRoCTo9pWWety1lZqhLhGBEp2w8EhKhLviiNi9z0NfWeNDcF6hL4Fy1PJCeFZfUwWfY/d/qWSlzKzeyCwZ1idZPwlGxx/sZn3bswaWKqbWqNtklbCtKY3NUV9nxAMGopmMS9z3psS9lxzMoWdK2jqmfHUgLGG/KvX6LYLSf8QijlrYwG2iwcBk0ixGMSObYyzbV6xR1wRualTnxArdg7KkiYR2FMJk1SpZBS5gTot4rZBwMkpJoDYDnhd5PpL9r5RHrYOi+gI75sflcNILBPRKC9KNAMMDce3QCzYeeU8Mn0SZCXdA61JE35eNQl+jCt9BxUs+HHVOldSwh6lKOa+b4oBSAbs+OS3vUhb4E0KRsYnQiutodoZ88vZqxrfXiXo1csbtNopQNPPAQoMwZBCNlxyuIU1RbYvcV+z3flx6Xn/d10eioJMi+4RMrgq4bqd6VMY2QGdnigy+R0nzCmxqVB13N6yaimUlgSKDMzJBMeZRmkQchMnfjqt0HkH01AD8OLB0fFYWglI0ulPVyowjVjx/VC3m5WaGsdTBKmQs+DlVAelZs+iA/rnVM//TpBtQXdIoyqEvBZ9EEyNxDHjIXbFwl6oIcJ7F8grG38sJCWYe6YJlVmylGDDgyE/GRQmbdzt65YZq44/0VZ0bzcevZIK0V22ouqSOB2caUywzRpCFOCLCJEZ9lLmqDfdHnE+1hW3yC57wuGh2VBKFLq4rNESy4cgOVrs2WAeAXvimYM7oGuwJz6r5Y3tJEGGRc2tgUfYHIgBskDO1rPga5CiODjMODZbbV/URmgk7oZuiCPs8rcx293vimpg0eO3N4WH0Futq9ZYFgeVZ/ghEe6xiEdSOgr7L+pD6uDOqCazmsHCi6ZKiLnXf7N1gzk3g+fi7Q8/GoSzT2Vm6c+tF8SF8J1MWfeKrXcigdIwjGVDlFrE5OB4osOLGntALHoLbmg1M2M2DHM7aD7xncTlmkKO5Lz3uBaGu0pCIPq0lbJ42OSoKMV0siDFhgRTxog8zQhVLPIUfV4ppPrQDNwJwECYlqMDLFdzCFRCKe6PI0m7IhMgN0ooRvpWjj0RJW78FqOYyDgS4rmyaOA3snhEToEypPN/Y5v7KN1g3dlqWrWrmozFPbF9r0o1oOHenqvkwKySMYAHGbET4o/eEdHnbEm8pcPOfACXG1LpCPnwvihDCU0DgPE5xKKApuKwgPsy/lcenyu03TmLXBiv7hWmW2NbyYUstTzrvpK/E256igXxf951AXIrOxCwnbmpB5Me8sUJzyAA+Na6xR2UEEr7V3k6yh6dpxYLNw2dtENRxIopDMQomcIiszWwTzn6lr9lXaK64bqS1uoQsFpquKBbfVl0JLeOpHHMqh5DHzrvnjDYs7M+W45vz12GUxLtUk3EDD9MeAlASs03CbNS5M7WT3Mmsd032y2hsjs9v4jMyBcxXVqDCZ2Vzotjj1450ZKdoUMiNHd+HIlTL3SVe1f4dzqnSbbcSGj94ciTMzIe+U0ksyPFmnkcSKncqkY1jaS8sXB5O6Lwn7MvtB9A6wim2dBjJnUjaoSDisvanaVqxj66TRUUkQcjBYpK+hPhoZGIiuvghYGmUO9dnPSj7aqGOZM+/oMcpLIoNpsAhSqEsKcZKFzNwpwk4IfN+NMgCeF3qHhpe7MYa2lKEYO3Nm1DOsFbi2LPocrQ1rOSb2cyuzWD7akSv4cNRl4uUhY9dtEOoSFrg6Jy1Kf0SISiEz2qxn7vmgZ+jRG+TMsPkK5gKlhG3BLY6+ixtuKzfumlSCnndSM4Pmou2LOZ/GCZm08yWGNOpUQzmMzMVGrMdes+OJ6xjCesRy7Dw9FDhFYM9IvRGb7gf46Lr+3R7kkOOCRkclQfakyfwz6mAEaQsdXU6AYcvy0Rs6PQ4M0yiBY0AQHl10ijY0LZ/uyxsbBLuGRwMntv947K4vk2bCTog1JCV/3bfno/tDUZqWwfc1IX2xDRT11RqjBcwLItkijQLRgC25gHHzCAZEJ4p6j3LuPYKBZPYIBpr7AsEAz6eUGSEGTubgOHDLB+lZKTNCHsTJHPQVzpeTGWw0ft6xzNp50PNV9tXywvOFnRA07/Pxs7GrviYc/dQO+jK2ddPYBdxGBznc/iqZWV/Gbsa2NbTjxrba7+GxtzrvZe7WfKuPZX2kHhe20eui0VFJUCaPagu1sEePimA5PCkw4tF8Td4y8XbgEHmooDchWqJlZk4IiFRKhGf+08C3CZk1/3mb+U99IsHLZOBSgpagYmMvk4GKWRtlIBlawqJmtBmF0bdDA9CmxgplbS2H7QuiJQR1QZtaBjEIL3wrEAw09oTMCyTN8YEy83EVzxnMF+PDdMzKvGhSoi5A5rKQ2H6uZZtM+BtyS9SFz9d83MQhJJfU0RNPxLZq1CWVQgpsq3F4GFqiUzYVJCR6y7BGWum735Q8NbSEoVJ27ArZozY6u4dhPuui0VFJkNmMKvnG+KK2cnPMXSbEvWxWy2HqRpjMuuKe1tWosdNoRjlytYvjAgOg60bYcWCUhhNxGzFxQkzEpzasmhNSODPECbGnfvTY7WaEajl8hB7dp1FsWKCvDdeXudrd9RXVn5RplK4vduEb2rBSMjvnIUZCAqeofYaRzCEfsXwCVKqsP0Hj4o5TMe/Bhl7OV9lX5BDqDV//3AR85rzw2JvCCREwru7/tr6i+64tEmapOttXzbb2rWMJUzZV21p3ZuxJJbJnJGxifBWFsomkL73mmVNkUBciz7podFQSZE7QVL3swDFQGzF9eZ9GXarRA1codAFS0ReEJ1mEUUdd2AvcNF+dPgtPKinnQTfTUbN+3w2sG1GG1o8N1czM+ZQ8o/QQc0JQ1FzC+4qni5qjNEGBuqQQjK4viroEfHAthxg+XY0Bes5tW9CXRwyAg1Ec9UXPZ1Z/PgxNQs+nbTNJzAVaq7w+p+srVS/kUBfoyBE0CaMuti80XyXqIkWbVhbkYLBL6pDj1MoU1QuJ8ICKXVLHUjYh6g0CIW5bldNIDkXk3uacq0ekafVeb8TG61R/x86FHBc0OioJ0hFf7WVfJv/J4LcACbFHhmMFn0cqtv+Oz/xn1glBhk1/R5+tL1M/spAHoQVaPj2upmGbmqstQZGsc2bgbajT4Ip4sCj9+C0ffPSvPKZqv6tlTm0iLmpmKSTdF0x/TNtNFmzWHnUBBrlwroJUQlETQo5m65/RBopkpnyI/sx/2s9Nm8JpxDqmf+IUknVmUA1PcYQ5dB6AE0KQK3gM3KM3yAFztUmxzFYG3751aOafd33549JQxzzqgvg4hCd6hi0ffuFb96zpSwC1EwLGrr8TIjzaRjPbqvYVZDfmv3fjqqXe7VUL0dht/wuZm64v5siti0ZHJUEQViy89dI7ZoowJQtXxKU/wMLV30mffKlAoXpcKeVNyYz70jL7dhqaZseB2zFo5MrLTdESArlrtCSsMVgYHDUuttGgVIKLrLEzI6YN2iB68QF6pgukReL0R3HyBfGJNj7HJy5wbccuoI0dF97U7N9Q+qxxfSEHTOvYXB7kzLi+wPqhMvdEZnxfWMeIzHDs9vlgebiO6fXOEAO9/FmkX54wsjL4/7MUku4rd+IJ12Xp70THeBfzoRGeCPVe6IbrSwWBdduaq71h+4Ge+2oKaYLX8jppdFQSpKG1+o2GvMBVIzPV21CnGFKdt5n/tPlPL3Pn0dN0lVJeykct3OrR7Kl1DNCNoFEtB+ejZS6jBz+2hcPjURfAp42uolRCXMsh5m8wbaGQq3mfoC+HTuCaB9tXHzQgQl1gSmIRpdm2ERoQpX78nS0o/eHrc9hxcjYuPl9dX8zZQ5F+iYT0lLnxMtvvap7LylyibfVxRbrq7+GBfAqdx04Iu9ZBtze2jDgzLMBjzkzUBr0duLikrmZbAwTDBIFgvWu+hg85FKFfDRC+GJXIrBFSNO+6TRRIr4tGRyVBflMT4V52Vnk5WqL52P5b0hfzMFhRF1hxqE8peLuYKBISpb1KmX27zNuBjUevURfihBg+ZAOdEHlYtIsu/ipSCaCvDWfY0WVlHsGIHB6Y/lhsNIHMRRqFj73YiAOHJ0JCNqauLzD2YgOFc+HHrsaldGze1o7X8Jm6+UqMizm6lM/M6g+SecjYI7TE6xjSnyIFidZXoGNNwQfJbMeMdKwstEYOs3MwMshM4OS3ciPbak8qYTvesL6obdXrQmwbEJhFxb21FFJq75ni52NkDvgg2zo6KjuI4AsHvbIow8VOvhiPlUB9ZhEQ+E0Xr/JjzlL2lXj/Aytw1Z64Hz9Ke3leqNjYjw3Vsfg2qNiY8Wmh6T5oCUshtXJ5PoUTAp0ZMX3g48B244tOUkTpBo2S6TbQIUxc7V5eetbJnLuorZt3/QzCAlfQJlfc659hH8egGxctggXPp5PZfq55Rim24pI6qKuOz0CZiyPeQd1RmNJSiIL+ideOlR2lBVu5o4v1WllyKaSSj3dC8NohDg9DXYxt5Y4BS4dbm1iOd85H9UWcIq339ZNBdVsfFeWui0ZHJUFoc2QpkhAyNB5rxVFRiumdWoNgkBRS5s2lWubuEiAPh0ohj+dlxq7a6O4Q4lTwMcelNR/szNiXZ6m+nBMS1RiEt4/6SBbB8sSw49tQPZ/S4SlTCaqv4lp7yz/ig55P7MyI+X54hLkYu+pL6fycH5LZtwmeob/6nuiYlovpGB+7m3fwDAuZE/MepT/6PWehbSJdLecies7+GUrZxjmEaN5zMvuxl321/UUp0ZYXTFdph4fYVt1+MsU6pttHR4+1A8r2A4tgxDbapmzqTlGUZqqlkGzqR44LGh2VBOkX2CF4W7cJlUWjLiCK1b9Hnji6A4TlNicTDMnP+ZYyz+UG8kztcWAWyTIkBC0mL7etpi9lsHw62fXnWv4OmuZRWFg34jb0TKFsVDAZnQzyR33RqQSerirH1T7iCeqLyAzREo+6BFFzdFqn6IugbUZmqGNeZr6ho/kqI30rZ8gHysx1LHPknF9SJ12bAgHLjN3KGcoMdV7Mz+iEWq95D9eyHa/+/9yO4TSKv6QuSnt1vOxY5nwW/3V1I6U8RV8GvbGvBmBpFHx6SGybmR5/2ZeWz+w9wTX7tZOr+nUgY+pnB5G9ZbBUXv27uSLeOyHaY6V8ZIuPujwtgOjYaR2TslHRA0Mn6veNiEVUSGHhtObMOLSEGUl6HNgZSVTlXhQNoo3YG3YIKYvtC0W73uEJ0x9OHmCQfaEjMv4+Ig7HHhj2qP6EFnCG8lgZ9P/L5yxFG49O4DqNaL7shh7OV+iESHXsushR84NzkZKZ60YhM0pb+PmCDjzTsUWTXnNRpL1gINBDx5Azwxw5oGPzvzNd7cao0QnOp55mYu/6MQhPEHDCUgDiPBiZyb6ii4Sj49K1FFIk87podFQSlKmG7opOE2/LNKiLuDbKMVgC6tMevaktUc10oSx7oR5KIfk2M4UGmNQPdAy6yKng442kcrC8/N3Gh+Tp+tL8MmmLCOKO0ABvbJHMEcTdNFhmfBlXxMfKGkH3kx7PB/OxffVLf5Q6FqaQisvlLP9lZQ7nPUjVZdJepYPatfHzDhEDL3M0ruD9TTxlg9ey5VP2lUkhlTqm+JAanti5EtpmgbqA5+OdkEhX57IwXe14amcGodC+L6Q/8zZ47JpvphRgMsE2Sv8e7ystH16+sC4aHZUE6YXJYDPrjW59j6Iu/K4VCAcGXnbbl0dLTMqGoSVaHo2WkI1YNYGRSFEES5wQU1sCUhLFnRswihfTBqIlC2gayMxu8gyMJIJ5uw0iaoMdniiyRjDvQg+dPHC+okiWjCu8th3Iw1MAiyagaBnJLEbWzCV14XxFMit01PAJESc0di+z5W/5cJlTl9QVc2r5m7EXa2fRJKljRDegTZAtPqWOsbmIdYzLPPHzDtCSzImn9u9RuqrtB45d/d+c1gHjEhGbngfPsONTfq5/n9tfvGf0uVxO23GWQor4rItGRyVBOgfYpzCKHQe2d61gr9YWWOH3X3i0hBkchoRomTkfKWT2cpvj0owPeecLruVo++TjivjoO1v0Tyaz5gf7KvhI0SaC5WczwgfMaXSSgqZsoPG3zwCdgIhSEhx54PMVXfxVOE6RzGCjYcddrVNUl5nzCcaecIpQ6ofqBnI+M7q6Kh3zMg8cl3/O4XFyMHZfL4Svx7cyo1oOvk7B85n4izJLmVu5o1dUtLL0u6SunItW7ghpbPnUTvRoW1/uPf34sD1sXTQ6KgnC1dDYY51MMMwpYiMRVqyEnCIRcinTxDoGDL5mp3V07QQrptWbCEshsaOR7Hp8EQIpu40Ynnxxm0gMy4vhg2SOLuPqg7pEcHofBMNv6A2YixJORwaZPx8/XxAqd1FzPPZg3r08oK8cHzEyR3U+C5nBhlWm6qwMlk9dV8N5L9ZF2RcvNu762vTznkJmwGZNn7PqyyMYUMfsmFNjB+NqiM5narcihCe8p8jNRd9L6vwNt3hdiGpD+DiHp55C6sbHLqmzxcZiyOwrwLaIWD1DaNI6aXRUEqQNIIXNgDfq0ZJFdDCJ0JJu8Sq/gEaXLGWjI9mJ5kMiPt0XM24shcRSElhmMW1QX/F169aZQXy80caXp4lpg1JImbcD01SL4YP7woXE9Qg0vqjN92Xl1O19IWiIPETPMJVKEMMPRrtTP1/StSlQBft5KLPZIMT8DT3Dkg8al+UTXlLnN+KEgxpdrIccMG1bjMxQx8TJHPSVcFDDeY/SXuRdSIjPwnEC670cezkXmw3RsSDAgfVvSpdY6sfXqES2rpU7Wl+t3AhJawp5Sv769+kUj133p1GXMfWzg6gBE+gdTW1s+YsCu42Y3TfC0RK8EdfQkkwx7XTi0RLMp30Gc5mRsRXTNkRdIsPlDXJgbHExpJUjvMMh2LB8dImLBm1fyFCU6E2pQ31g8Kl/PuSIt5YZowF80y8QjCD6jufC9QWjZiEyJ3RsFsgMItDi+G0QyXrkKkIIIx0rUamyr2jeU6gLlVm1obrBnRCU7iwvqUM6ZsccFcpGOsYuZozQJLhO/XMOkKvISdOOBCs6zRTKWj4Y4SnSTCCYKk48Ecdb2yl62EPpGbuKf100OioJQimSTBFsgZaoRVctOp04tMQUmM1/ptASVcylZdDti4JbI7MsxjX/Wbah8L5BA2QxLt0mLjqNZRbJvWk344RAtIQ4M2GxKBy7HdeyMkdzMayAE0SFLiKGUXNm7P6SukjmIJJlOmbeDkznC43LyQN0bKPQsa6vYfNV2g7qMAc6D2VumMzlWi7QSCizbPGx/LVssfNJdBU+Z6mOq9RV6doUNgHIzBA5IE9YzJ9BdNX/bc1iJ7M/Lo1QDsPH7Cu4DXs1gEGBCMKj+zavBjhOPJXRUUmQOR1Da0vmP7VXK4JrDOZedvn5/P/znx51YTUY9aPH0bt1WpmDiIZCuGhcLgpDMoc3ZzI+uo2TOYwK6zJHRywb11ccFQqV2RdD4uhbtvj4DauU2UeF+DiwM8g9550dv03JHMxFL9QlSLUglKOPjkX1VH7eIx2bFDrG5yKa97AehjxDOPaUzK6v4H6h6J6Q1G26rqjb6hgbe+lc+Xtm8NhtX5HdwCk/O65YVy0/lh6aoy5WTt+eoSW6zWSC17J+nhotQTa8bcOuR9DzgZ7zOml0VBKkN5rppFMEeHlagJboPClDS3SkZtAS4EWXqItuI4s27PK00gmx/HX7cgMtjUkXzQE+BA2IItD4xXwJPgu4uJSHbY5RpAajJydPFBn1KRqM0ZJIZoF9RUe8o5t7M1HzEJkh4uRl1sa2QDmsnFhmKWT2l6chtIShAUjHorkoo28w9oVuiOkr0nmsY1vfj9ASEnQgBDUjc+ekAZnpcwbz3sPRRXaMpmxCVCrSeTuuqBgb6moC3fIpGzh2h7pECKGIRUsYMsPQEo+6oOe8ThodlQSZEz3aCSEbn7mdFW3oE3ccmDgPBi1BfU1zBbdtn1oGL7P+GRXKoqNtGUSlQDAAn0VE42WGkZqNwiLDjm/7lB58xIwv2ojRy8VYNIfftGufQVQkjNJVxdjDaLd9PoiPlSOW2fUVjT2ady9zpGNoLrz+wDl1bSAft6GnZLbfnctvvw+PVLN1ilAXLzMsNo5k9rrRyhk48C0ftV/Rec/IHDh7mSPecE4TL39k9ie0LUDmwkahdeqctPiId3taR2iblkeE8MzljnW1lTeyq+340ZHzddLoqCRIGzd2HBi9rViEpX6CC9YUgmFTP6U80y20JIr4FlEPWJjsqnAjcxE5cpl9SsLInDjqy4pOoxx6CuYNNn1vTKIXtEV9RUXCHsGIxhUdGc6kPyg0jVCXHnzw8W2mY6qvwsHgfMpi7EDHAl3N6Nik4FPOV5n+KMdVplEy66LuGMQ6L3WZ0Vz4W2ej5xy8zZkfhdZ9eXlKmemtvEZmvAaZXZ3LHD1ncWMv+ZTODB9Xn3Sw1VUrR3TkvOWFURflYEzw0WOL3uDyBX8UGq2LddLoqCTIVENP1OcEwWCpH523NXwI6qLY0ELZVi79XdPGw/IowgoiiCIXH0RPYSFfwrhRmDdAXTIOD46MSF8oIi5kRg5Pyycz9pY/f4YxemPlgn05xzJCXaJi0Shd5dE2JA/TsXCzBjL7ee+nY2jttHwE8BE79hAhFDt2ZBP8vCd0LEJdwuP2PqAIxo7SFvRtzhmEMBh7mF4MgiDfV5gOjoIpkhaMjpxH+tM5PIAPS4VH6E2AlixQl0BmkTb1w59POyaMjio+U5xCWieNjkqCaDqGRHwULSGoC1ZOi5ZElymFFxw5WNV42j4iDhZ4CU0rmUn0lImIofEPo0I39sAg+0gWjT1CS/jFX8DhCfmI5RM+QzF88PtTOJ9BaEmIYEQblht7oD8R6sLQAKyrQ3RM9UWj77KvcMMiqEsD5iJapxwp4g5YrKtiZYaoi+0L2aiwQNrbBHR5mkcVeiCEYco4gZLhYlHcV3g5YSBPZFczCE9ZD4OeM5O568sfc47efdb2B8dOnJnxHpUdROh4sv5cxEagDC3R0SW/PK3lM/89zJOG0QE2tvGRvVI5/QIPI1kfNQeXX+EoQ0wfUfRdRPGBcQuj5mAzYpfU9S7gJJsIjLAmXObinhngpHkEI7o8zRcbz0Ida2VWfBKplhJ1KcfVB5ErUUQgc0LHMptRV5sU8PHIVULmqM4H6iq5IoAhuqavwDHohbqEyCeaL7F8EncZRcf2o2CKopFgnWbQ4xAtcfoMC5s9n8Cupmx4MC6NDNsXMpYyt+OPUNa2HxQErZNGRyVBWjkNWgI2Yo+W4Cr3LX5BRBMVhhX534zHDvgw1AUvOhs9xdXywAiQqBkWoSWMf/EMwTtf/BHUvgWTRRQfGIESui/HHhbgOT642BiPHRUo+kgWnhAJZC7qIsCmxgxy5BRFRcILmVFhIXGK8NjdfGV0NXDyI10t1mkGCQHOp5c53PjC+ao/58i2lKiLHYvpq7AbiyZ8vsBzLlAXcALLB1PxfJUysxQ2eldUDr3hz5m9GiC2qz10NcEH6UYrd2Sj2v4Qn3XS6KgkSC8EmvqZdQvKvB1YzXPGwWBQp4H7POoSwOl+c0xBnahWwRkTBHVGJ02YccOwvKT5wBoVIk80dlw0aMccP+e6zGGqjkR8cN4DBCMzdn5ZGehrmpc5dpgn5hnAZ+jWRXwTLJA5MRf0lBZy5ILn41EXKPNSuqr6Yo5uZi2n5qvrq9+R4cT6SsgczQUvOlUykw09Z1frjlysY6XM/tUAKJjiutG1KRFvKWXuw6fYC0p52r93+9foqOwY0qcSlJ9CC2VF8GKh0HQQHSBUodd7WDyfYPFGaYsClk/A4BBSniTG7hdd+FbWclw+ZROmPwKDnHvnS8awS55PCE17Pu3zWU7HoqgwTrGJHXtw3NW/VyhO1WXGXvbFCzgXTYCulmPvk16Mj7fbMaM1yFN10Vqu25Y+OtY3jeLHFemYP9o/AwWc8bz752w/N30VMotqY2WOn4+XGTxnr2ORzMCu5g4yiOGDjjl7eTK2N5rTycS/GmB0VHYM6QVl0ZLA+Ceiy8iz9XB6jk8QHaBNn6AlKOIroE4QqUWRCENL0BtyU9Gc2/jiN7fa7+rnkImeJk5mhLqEqJQfO0JLEpB77ggqmy/VxskDI32CgOUQHjX2jK6SVB3mI0auWFeFtinHDvpyUXNOV7nMcZHwVhugq7ywWUCblg/XjegZ9itstuOK7GGkY9EblnNFwvZvEcIz6TV2KdoUOgbsagbhyRRRc5SM9xUjusHY6f4lxwWNjkqCUpt+ER1sfTcTNQcRcRT1RGhJ7lio5dPr/SBB1BwiPEEEUR6NLMdVFp22fS2alCmbKGrO3AgaPcMijdJDZhTJBjJ756FfJBvpGJLZfh9dSFUWG/NxdWMPZE68WbtcO6La+HGV8zUEKep1Q3Igc67oNJC5h46FqEsKVcjMV90eRsfk/dF+hMhx9Fj35dcXkLlYp8CxdM8nQktiu0p0DNTDDEHOU+sigbZFMiNdXSeNjkqCmLcZFjEmImu4eElEA++4cJtRWAwJoGme9w8WXcAnc+lZVFynU2yGj2ljxxwWnQY1PKmx97jjoouIJ0YGLZvPxYcpJJhKwHOKESduuDIFgUzH+hYWlhe+ceMfjb2Y91DHbNuwQBq9nI7oBr5nRmybAAmBNwD3WBdex6Lj0ql1GqK1fFw01ZLgA4tOw7GL+VuoY2F60fOxYzEyOxQxQqHxjbLzn9H7pFI6T1CyzNrBqItbg5GOtZ2KfdbrotFRqZB9WdP8ZzuZ7QRqBSwi4ihqjhQ44/06Q6HhWR/RTAAfFqmhlM0CNkSRiCseQ30VUfMCTi/78pGs7ovJHEKmaINwhitMM/moOXBCEMLTkL7ieQfPmURqsXNVyuxRF1jgmormxI297KtAXUAqgaMB0dj5uOJn6GUun2FGxxjqYnVVrMyZDSshc586qGgNLmRGdSORrhZ3rUR98XHxomX0fNo+y77YJXVax7zTiBCD4qbc4DlHOkZPL/a14W4tY7sqsK/oXqlQVx0f39+6aHRUKqQnk1Xda2WPNkeWk43uKIBRBo34tDHBbaLoKYpko5MdBeLUA3WJYPDoqJ13nOLoCWyyBArGL6ezckX3zGyAdFVRmR+Mq4ue2rHUnavohXpw7G5Dh0fOt/4bHvEuZC7bFCeeMlFzYsNKoS7hu2zEjgvUGEQ6xtASnKpzfKKoGcnM0BKwOfqIOKzBCMYVzpdzdEMdWxYh9Ggk1DGpysxq2+Lj2y1/tE65XWWvBsigZLnj7YsmwG4EfJxd1eNn9TCe17podFQqpJWLFX2ZW/2cMrRKqxdElI9eeOMFbNjJVL7sTEo+LsoIi+t6OCFhcW/wSnePuqTeaQKiOXac0yI82AmJCswyRhJGT8SY4MJmO64QwQifs9uIoczi+CiZyYYFjzC7zTo3dt2XmL/1kzkYewZ16cFnWR2LA4EldbV4zlLInKkbYfqD05RSlTlON4iVObAtmfVVplHKcUVzURyBz6wLNPYEqpkpRC/Xu/08Oy7mYDRNN6/FcenW6ClezEZ5uddFo6NSIa0UrFBWTySL0A0fj7oAVCE+plpfLD6C8DJrucsCznL8cdGpHXvufRx1p2ghcwNkDlMSbvGm5BHAZ2vMmbkIxr76d77YtvHYBYxdsMzhJtLK2W/eWfFqXBAYyOw3x5BPfe2sSsfCsQ/SMVFt8LzHxb1o7OLG3kNmhOwVti6hP1EQFOlYRuYEn6JIODPvATqR0tUIPU7Y3sKGJ2TWfXiZJ2rXb3mxwl0v97podFQqpJXUQ5Sdx1q28dGcVq6Jgx/bP9nbAQNPOxOhsyK0IFKLItAooikgSmCUaEGgkdnxCaKeYe9P4TJHueYILeFHvIfK3D7DuiOHi4QF8gllTjznVCohPM5p5QqRmUg3EihZicgBPtukY9G4UjKHOhbxESNzhLqsTlc9H65jKdQl0rHoQsWMjiXWcpEK7zVfXV/lOrWfaz6TQn/4etf6vNh7SBv9fbYutNzljejleNZJo6NSIVx/YqMV68xgT9ugLj46AHxYBGqKewnCo3nFRwitEVjIjDz2IKLhmz6IIEKZbZsoki0K1XSbAk4vx7WIsMIItHFjL/sqbnBtnbTEuPA7X7bkQqdRig2rHBe9QGxoJFugJaLaEOchM/ZAx0K0JBh7GX1vtUkgGH2PrpeRrP2u6avQsUUTcEldH5lFtbEyp97JBS9PEyNPrKv9xx7Via1KV/ug0OHzSc17yaeoSQuCjsIeJuZC/61AXTRa4vYexKdtw9ayiNWzddHoqFRIe+W+fmAxyWoiWUSMHB5fLBqhLp1Cgb6AYWdRhi2GTPDxkQhYULwot5OVFoZFkdG0NAKZS+ra5pk3wBYRMdwcbRsrj5g+4suUuMy06DQw/vFld15m6dr4TQSNqxi7/Vy39xFodPwWHgd2MiM+mcJmj7qgAuDiArFQx/BatjIHG19Cx1gNRlhoje4XIjLbglsxbcLN2usqnC+uP6yuBjsh7bhKB6x0zjM6xtdyhLrw4tXE2DPj0n2RGh6Dlvh10TJUf2Pz3vLSsnUyd3Jsur4Q6jIW0+4AQumYImWjkRDnzHjPd/4327ZVTIS6RHzKGhVZ8PNedAQtRsVs3mNHkKmPMvqcDJoZPo3jU465iNQC6L4oQouQGfh8xPwtLIorNggwdt8XigrJnOr20YsU/bjwfPWY92Cz9jJHxYf+0rNID5FTxCLZzEYDx54YV6RjHsFIra9Ax/za0TpG63wiXUUpJD/2xHxlUBeU/shcOJlJdxa2JSFz5FTHNsGOK9Kx6B1PzK5GKLQ5ieNsvUeu9N/YXIiUSL3XMRGRZsth8vvFBPS1ThodlQqhGhUPCW7CNlY5EeriYV6cZrJymFNI5EZQhLogyLREXaw8ut8oBVBWntvv2jZS5RNW1BMoGBXXsbkwfAKY10crMTRt+0KX1BVF1NCZ2WobRoXOAAYomdcx/f8F6hIgBlGxaAaWZzn91HuXokgWPEOPliCZS1jeymD5BBsNifSjupFYx5zMEGkMnk8x9qCvoBiboi4AwYhSqwwlY2+cZzLTOp9Ax3DBrR8Xl9lfFJlJRSGU1c+7lttfUte21bwY4q3l8M9ZOxgl6mL5aTm8js3fsmxlXieNjkqF9GbOCsxms7JNUXALkJD4mPPWT2cAEaLioznj8BCEJ0Jd4rcMB85DED2V9yFIyYfAqhhVCGT2xqQn9Or5xG9KdWMPZM4UcIYbH52vUuZyvsq+4kgfP2coc4ZP8Zwj5wH05SNZhBgUOoZkFtNHrGNifobODEhbFKgL0jE3dnwE1Y45OjIcHr9lm34CdUE6VjghGQQjmq9wXbTPwMoJZU4852jscWpVLJ/gOXtd1X2w+dJt2Hzp/kK0xO0HXmbTl5sL/f/jwE8ZHZUa+c1cBDkPZRsfHdjUD14sjTJyrOhLKw079ghTUQk+4ZuRA7SEvj8liJ5QZORh3hjhESszgnCDqLkslEVjJ4Z9oMxRJMtkjgtleV8R5O51OooK4yJhOxfhvHuZgY5FiNOwtwyXMtP3E8H5ijY1MfJEKFmsY3jsWOb6vPcrbAYyE8QpcxQ6uuG2l8xD593bOjgXti12LPuPfc6rCWXWMpUyl3KwtaxlYjbKthEjs+6PyazlHmtUdgD5SFekhK+95yvSKcVCMV1kIKKgRQcHal4RWjJxiw46Ra1XP4n4WG/cQ4aaD0yjEHgfv4/DevWpgskAdUFFg/2KIdu+7OdzPnbMqEiYH4VG4woMKUNdYPpD6LjYsVAEp0fvZmJFp5kINEoh4YLkhP74eU/MRaxjLR87Fs0zl/oRO/aUzIEzjGQudDWaryV1zD/DcOx8XKxIOEoHwxuS6VoW0GZL5sS7tLCuipFZoyWLiztd0IGKTtnbwEX0ceCEg0HWhf5bmXZXbRo8ds3LF9OqJlCn10Wjo1Ihn7cUKSN0n/sVKSFTH83M/+/4INTFef7ovUJ+8Wq9YkgIQl1KmXkbAzuTiCZCXeBdGX0QjAKaLo1SWXRayhylkBisGm3WaIPwqEsEX/uaEPScMwWBmduGi9QPOoJaOIR1Rw73Zds2aN4LOL0cV1l0CnSsGLvuy8mc0VWo8wNkju428TIjXQ022VLHEroarOV4XYgde6hjVnbdV4ns8WcYpcaKeZ8iHXMyB6eQfKGs5lU+Qym+z1JRIt1+wnRMy5pBXfy86/97ebQT49OrIeoyIirHP7VzNJ2ASSbwm0gJUfoIw/CJUJet/3vPV3/f84naRKiLh2fNcWniPMBL6pzMmqePeuzx0vZvftNfNCkiRwQps8LLjGMQv/MF8EncKMuO8UaRLEZ4iMwBgoFlxvLgKJ47jZnCZooYGD5WDphCcjJPAh3zxzDhEWY/dogGiGmbKzqNZI7my/LL6SoaeyDzALQk0o1iLQfoDZS5qevYrCHzHq73/HNuGoWWRCiHQ0tg3Yi7hdzfKGv4FDqm+Vg7rp+h13s/Lv1/f0jDtqnvYWitrotGR6VCXWEU8ljF/LRt2r/ZRQBrXRYKbvnr9h302MnGjhAa1IWiJYoPgWe1I81qHuLi3u77vaKwBFpSvFwM9FXIAwxgGfHpNm7sAXydipqDSNZHRtNJOfZMoWyRQwdoCYvUcmPXMrtniCLZxNucCz5g7AV0n0AD4kh/OT5lRGw/NzL3QEvwcWDHByIGZN4DHcs8Zx95m7FnkKsACenWjrg2fFwRWhIjM1hm/X2GuujvM/3Rf2PpTpGuDrHUsbIvr2OaZ4HwQLTE2vFlUZd10uioVAhNoI+MUH6PbeghWhKgLv6dQcg79h60blcgPL2RmVhmkfK4dIy6lN567ohlLLP+fwZ56IO64GJRO/e5KLUcVyYq9HOPouayDR97VKvA+oqeYRQ196ljgWhJu4lE0XcGLWHznkIVFk2KiDgzdqirbV8eRQQyR3NBZQ7Gjp+z6wtd0NcD4Yl0tSn4AHnYm5ET6wKhJZ6PlpUhTvPvW/m9jdLfXzg8ATKDEKcCLXE6JqJSsBES4hxiP++aZ4S6IOdyXTQ6KhVC6Rh/u6b3suft7abmj4jp9n5DNx60y6XGx8hKBe8KJi0fbTDKk0G2rf5bKbN6Li6aQykkdqQavRoA1UVsumcNUwmLZ237NJGae9YhHyKz/n+EPHiZo83aR2oo/ZFBeIrLrxCaFG3EBZ/5T4vwiOGD61hamcXwyzxn5OyF805Rl2C+IkfOowFAZj+nUGaHluRkXjShaAnkk9IxMX1FOgbXYOJGa65jgE/wnFmNE17vlo/+m9dViJaQNajlZo63/j67Z0b3BfcD4mCYfcXpkL+jSbf3+8GGkoMhKngPGx2V455QOoajJbqNuDZStPEFkxFa4qvOJ4iPu2UQedmej+7Py2yOSxcwuG2r/1aOvWszcXlbD7uKlMYNQdwTIrNuX8hjDGA8Ls3TR0+weDVEZmwbdDtreUmd/VzzKa9t72Qux843azbvkczaaC1kdu/EQamE8nUGdZn7zjufCwFtbNvUvIc6hmS23x88F6R2C/UVy2ztFEoveh3rbEvJx78LCY0rvBOJIBgIcUKbvk+He13Vf2OXQOr+SiS2lDVCS5gd12hJWRPS9cFSNtiO2760rB6Z8fNu+2rl6mTt2tg+1kmjo1IhBJuxVEuIlgCP1UcrEZ/uyJr97vz/AvlYZMZuahB1IZ64HnN4pJrUeyDUxUegMBXl+gpfDQCiyxB5cAscRt+p6NIagfDIcBDJsgvEUOQY1cP4S+r6oCUo/RGd0mJHI1GhrK/lQHORQV3CE1jFpsb59EED4PFb9wzRKZICSUObdUZmEsVH6E1Gx9D7dzJ1I+xoLUJLivlKoC6zprwoEx319emP8PK0AHVpRWJrWcvNkD39/ei6Cu/MQPQ82lfcs4b7ikM/PXKlZfMyQ9RlfCnh8U9Iofzi9ZunCEcepoCPjwwweuPkCRTTF5xq2YoCK+DMoIvj2u78jbLwkropllnLymTWcpfHt1VfKSSEOxj0XSQBWhIWMQYpCV4QWPYVjYterAcjdOx8avnbv0Xv3ynmIkCl8BFU8pwjmSHiJHbsUYROdEy3iZzYxby7ccF5D2XOjF3s2EMda+Wyn+fHLlgehJZEjrd/PmAuirH3kFmPf0bmXf/N1/nYQllnWwES0gVCYuRAzgyqWUzZ8dYueGQGOCEeLdHOg0fKwgDY1TVGhz3QhW9IX9dFx4Wj8prXvEbOO+88OeGEE+SJT3yifPjDH163SAuKimALb920sYqJ2iwgugIO1Mqy1ZfzfC3U5xTT5ZBFSkPhowcrs+1Toy5eeSHq4sZljzkTmSEfa0j15s+K60yty6Qde2mQ2TFeWFjoNnRcKGtlR7UBRREj5MM3CHakMS42tvzNuFrnMxF9w1tVC0RFgrFHMuO5wGN38w7n1PUVOEVeVy2fYOzuGUY6Fr3rZ5kjw/Y5i2tj+Vs+tq1BS9xzhrpKZI4uJ4RoCZFZy8Fk1nKwInwtB5t33QcrkNZ8wuPAhcyBHU/sGVFw2/EpZfV2CgWuZcFtyQehhOuitTsqf/AHfyAXXXSRvOxlL5OPfexj8pjHPEae+tSnyk033bRu0UQEw2+0RiXwsr23rv+fQV0iz7dItSBY0RkTjLqI6cNHIXqMCC1h0RxCXYagJRiZ6c9H/z+KZIe8aRfBpUWkFqBAPv2B+ipRKcSndR4QH+wU5d6IXfYV18NgmdFcRAXJflwo7UVRF1MsKuZvIVoSvhnZ8ol0LDpauwzqghEM2xae5CrmYqCOBQ5qMXZlQ9pmJepSOiGFzBFaEiEhYeqH201qx5Ft9XY8sNEQwXDzAVEXYn9tygaPC9eoBGMHdmFdtHZH5dd+7dfk+c9/vvzQD/2QPOIRj5DXvva1ctJJJ8lv//Zvr1s0ESEwHvNYjVcrpk2EYERednkU2n5XBKAlAHUp0RLAx40L5Vp9VIhORXm0BKMudqFYtMTLbJ+z7i+HumCZ9d96HbEMUZdyzCxqjlAXFH33O+Zs+9pEm7WPmoE8HWJgZYjGlUJLUjIjPrLV1uqG/n905LyMvks+LPpOIXIJtC08Lh2+AFHMz9xRaOnaJN6svdRlgA1IP7s2mheb97kceFwQLSGIk/4bm3f9twgJyVwhkUJLZn7sZV+p/YCM3ciT2DMK9AagLpvHQY3KrnV2fvjwYfnoRz8qL3nJSxafTadTufDCC+XSSy+F3zl06JAcOnRo8fuBAwe2Rbb/9dHPy9v/7/Vyn3vtmcsVoBzImSmKYCNFiFAXhoQEDgZEXaaYDyy49QsXvBqg48Nlhg6Gixy9zPr75THwTo4u3WAXU996mKhQtoia3Zxq2WLUxRlSwMdHaijaZUWnYUQcyOOfD4b3sWNpZPYROrhnJiq8ZGhJpm4E3WlTzKl5zm6+QMqGvuMJymyfQVSDgcduvx/K7FGXGXg+Ez6n/NUAgczwvTlY5vZvGxPOp+W1e0PpM0BdmE00SEhxt5R1GjUfXwTb/n9z1qWKEYIx59mUhbvAJrLiXs1z5vpC6I0/rROj50xmgLr03VeADq2L1oqo3HLLLbK5uSlnnnmm+fzMM8+U/fv3w++88pWvlH379i3+nXvuudsi21U33yl//emb5R9vvENEnHfsDLKPDERKSBmndezfEOrioT7kZZdtpODDaksyMkcwJ4owCscgJXPpPPiNGJ0MYmkv3V9RLwQcJ59KQJfU4bSFHVu08XWG3X5Xy+TrImzawj7rPk5Rpm5EI7xFzQwwWjyyRuMS10b1lXCK2GkdUyxaoEDR2LlTRC+pSzhglo8dcz+Zu75KmcG8Z8bu1jw+yeVkVuvar40oZePtFCqUbdzzQXebhCdx3HrWaIlH07wjp3l5lAM5IQubGKAuvi9kE8t0TNdXWTdS2lbflx+77itCvb2e4T1Dtsb+Fe6oDKGXvOQlcvvtty/+XXfdddvaXzSBhbeu2rCUTVQ30qURuv49PIu8Ywo9ThMy6zbseBxCb8KxOz5QZjHjsQW31vh3RcLAmfF8gINR8pGiDXs3kx6bh2abpikimm7euz7Y0WO4Ebsj3jD6LsbFN3SYkvAROnJCWBQPZPZzgS98c5tsKLOdLyPzYr7Kcfk0HEx/tM+wmC8ks1THHspc8Alk9g6PeT5W5igdw9YFagOLw91zNikbtzY6R1eKNiEf74RMyzYs/aEDq9CW+U0fBIrMtobpcHTUlwRUGwY9t31lah/90X7d3jshGdsajSt6hsdDMe1aUz/3u9/9ZGNjQ2688Ubz+Y033ihnnXUW/M7evXtl7969x0I8EYnht+g4Gi1oggru+go98a3vBmhJXBTWylXKXPKxclo+3HEq7wwAMrsNy0O8lo/ta87L8XEya14FWgKcEFakNu/Dyt8VxKm+FhFf+X2f9vNGFI0fRTO8UFZoG1wMaWVGm5qfM7Tp594yLEbWCejLjx0iD+4Z4ntU7N8QWsLeKxSiJVGxaEbmwkHVfTk+YFzFsfQI2Sv4dG3Yc277mEwmIGWjnAe3NtC9JR3yIJYPQEIKPpOyL29/W7Rk1sR2arrVqOgrfMM92tBjmfX/mcyaZ1EuENj6mE8gs7OtcH8q9jDuzBwHmZ/1Iip79uyRxz/+8fLud7978dlsNpN3v/vdcsEFF6xRso4Q/MaKRaMCKwi/MW89cEJ85K15lsfaujbsXT+hzJCPED5KHu88JJCZ6NgfSldlUJcMWuKjQvRqgLK+Qgo+xWakUJcC4kYRMdnU4kJZ+3x0vxoG53z45ujrkyI0oJPHjl23D1NIjZcZ9OURjGizJvOOxp5J2URoydTNRXQZIKwtmXmZAR+CYMATPb3GLsXfWAG57iMqXvXpVVQ3wuzLBMkT2lbbFtmOTNFpfFDBOxgZ22o/RzIjxyBjW70z0wf1hn0V8wX6Og48lbUiKiIiF110kTz3uc+Vr//6r5cnPOEJ8uu//uty1113yQ/90A+tWzQR0RB495m/0RF56wVE54yfSBl9Q9TFGckQdfF9AYQnKvjyxVwRWuIvLsqcilq2mGsREYZj186Da9NGPMGrAVABMEtbZFAXg/D4SD/YaLrn3H2fRcQREoJTSHY+VnZJHeCTO+Jt9R5f0Of6AhsxRV1mQGaHlkTFq2HRaeBYFvMVzEV5S7CoNhk+dly26LSR6XRSzKm5VbVpZBeSWbch9gWlh7xNhHwc6hKhJUX6Y9aURacQ5eA20Tv6Hm3TfIqXwg60rYWzB9DqcOzOmfHzpdsXSBHoy8+pLQUodXpdtHZH5ZnPfKbcfPPN8tKXvlT2798vX/d1XyfveMc7igLbdZGPhvX/y2JR4EFvfT/KE5aRiqg2YtogD9q/Myjyskuor+trsujL8pl4IyH94FKIuri+ouPS0bgmvi+IuuA2mhebL91HAQNHqIuL9vTf/E2w+JI6WfytJXoJG0InohRSETXbsWue4Vtri8hazLh0+/YZel2d87FyeB2zYxfzM1M3Yvuqt8kgVwx1iWT2umpltvwwSmbnvWm6lA2TueU1lUmx5vU6artj865lYnMx54NtInr/DrOJs6bJ2cQM6lLYDsXHBR6xbW3bSNHGz32IRAcIRiqt4+Vx68v0RVAyKDPcM6wc66S1OyoiIi984QvlhS984brFgAQ3/SXQEuyxtm0BnwFoSZTb9EgIvJQoQDAYWpKRGY49Qm8IgoFeDVAcZ4wcwgh1aceeeCs0Rl1kSw7QV1EoK1ttVF8ZxKBAJ7rvs3oGdLy0S8dY/nM+Th4Y6Tfm+9GFeFExbRHpZ8YO+JQyz3/HCIZtG8mM5ClQl14yL5qAS+oimS2fVlZ9HBidxGnREr/mzXFgggYYR8WjuhnUxdmFzVlcN7JAS4o1D+yURx4CNCBGXcTKvLRtBTI7RBIj0bavEHUJr8e3zwfaRGLLoue8Ttpxp36ONYVpi4y3HkQGXhFghDH1i4nz6a6mLr1sfsyZKzgaFz9SrcaeiAwKmUFkUCJO9nMts48IURtvAAzq4scOUJdi3iHqgo2W4TPF8zXnYzeICHVBKaTiWChCDJxRQu/68REfMlpF9D0t+0qhLk5f8fHbduz++YBxOT4RKpVBMFBBcoFgoIJbwgcjTlbHWrRE9+XnQvNiTqyWu6zz6cbDajCsU+TtS6c/HVpkxxXZOxTF+7RFXDcijo/qy68xhLqwzRraVjFtsW1tn08pc5FCythfiMwkniHhY45Lu3WYsePrpNFRqVAGeoRoiVNMnEZxfGaIz9b3C4Xq2hRHoSFkWJeZFQnDI3QLmYWPPZC5zzE7Py54DNzDnOi9FgEfH82YlI2LrL2R0Lx89K35dCcXbF9xPYxta/nY56yPS0c3nbJL6sy7foiDESEzqFiUXVIX1sw4XcXylHxomxkY+5SPixUJo8JUj7ogJ6SYdyiz7WvOq/1p52viLk8zfJw8+m8ewUBoSclH9eU24hC1BOvZ671Pn+n+mMy6PRu74eNlBm38Zh1eMxHYjti2+rGXDk9RcAueoa+PRMelCzseOiFOZrA/HQ81KqOjUiEEYbK0BfKgQ3gyAxl6xwAhPFOrmCmoL4GW9II5J+ViKmXu+vKO3AzIzFM/ZWQQpn4KuNR+rtuHYy8isG487DiwbuMja+iokI3Y8HHQffu3BsiTKjpNpVHKjdgbN29ENc8ClQqKRWE9zBCZ4djFygP4sKJTWNxL5lSP0c+XRkui992w4lWMqFh5zE2wCdSlKI5HaEmR/uj68KmvKP1RpC3QGgvtC7GtwHGKUjbs+oOo6NTrmJG5sK0ln+JaBySzGxfcVwLbWrzhPrRlbVv7uW4/pn52AGWKYDFiMP8ZXlnvNhrk+RZQX4CWFFAxQkLavlLjkqCN42MuqXMyJ249RIiTL7yMblj0EC+M0gq4VPGhz0e3ETMulLIp0BKNzExsXx5O1t/3faEUktcxfEmdd2aawgBOXF92/JiPlruVA6WQKOqSQBV0XxR1CRGVdsxA5qgvgrqgFJKfdyRzhJaw4mf9fYYUaT6sQFqkq7fyfCagL1QHxtaGXate5lIOhrqgdVimvcr1HNtEvMb0mOlbhnvaqZztcE4IQpDJO9sQeu7RNvicZ24uEmhShLqsk0ZHpUKhJ+687Og9PrOmXCi0UBZ44p2Ct21UXyRCN2hJgRiUffkoBMssbuw8eiiO9EXjgjKLazNQZmf84OImaEl0DXaDZC6iPeBgRGgJifQtH9sW9TUhyEOD+ooQjEnLx36uecVoidtk4btjrPHHKIftKzpSPVnIXI7L6ytORYmVJ0Kl2r6080A2PoiW+CvrVRumZ/69OXbsVmY9ttJBVVfNB5s1u5IAohyu4BY5+qVN5Laj0zHNJ2On8HrGyEz7DEBfK7atnYMh5dgJWoLsS+hc+XEl7BSy4x71XieNjkqF4NFaqgh8Efictm4f5QnLVEIb8QAFd20Q1Fd40BDqc3zgIrDeOqqmL1COIEqLUloRUlQaGz52n9O2z9nKgV4N4HPIvgZBt/dRkZaD3amg/8bQNv23skh40QQgKqU8PrXR/skU7gZpFD9+WCzqUBeEYLTNoxtlfWTtixx1+6huxKeZvK7qvsq0l+prhseu+2NpJtvG6lkGdbGFsrYvlEIq60a6cWSK7D1yF6V+IjSgXM/2c92+qBuBdkFoG49ORLa1kDljW0ObGNgpb4PA3VuhLdv6r5/32LEMbJlHwALUZZ00OioVwg6G/RuGJ61iYi97i0+AukxcXyHU51AX9DKrKDIooqsAvvVoCZQ59NZdX+D5cGg2kDmIZvxxYON8EqcxhG8XfLjMOCL0MjfF36J6GJZGweiNOJm7NhPnPKT6ChAMr6t2/AlnRkX6ng9LoyAkxCMY2oFjt7xamXFfevx+7rUOsBQjSutE6SGGusA2qbXRjh3oa7DxZVLdfs3H6Of89xB1CWQu60/qMq/atsLC3cRc+JqZGB1u5US2DOvYXDYxf4ufoVCZEbK5LhodlQpFkGFXEGc/1+0zXnYUGdCi3MijX3jQ3TiGoC4ResPepKr/30Vppcz0KHQQ7eUiA/ScxcqMxu7RkgwfiMz4sUfPeauNMqLskroU6mLQG9t2gchB1MX1BVAXPy6NurA2WqaotsTXRUC0pEA5Sj4MdbHpKs+Hy+z5aF5+XvX8Lp41QXh0f17PLB+nr84B03zgWi30TIrxFOkGhLoQ2xHZxAjZzKEutq+wlgOtVYJIhrYVoajLyNyXj7OtEHXJ2HGClmAbjXVMBF/OuC4aHZUKRWhJfMugmL8hj5VH32gDtco7QX1F3rrzjjHqUh9Xn8ip9OijsaPnLI5PJLOYviASkoiconH1QniKSA5FM3ze2YkE3Yd/PvqSOoZOINSFwdIiHerC5l3zwakWO/cohVTUcmTQEudYWj5ifmaOMOvx+77MceACJbR96T580SlCQvzcIz4ZPUPFq+j4uogNBjL6WiAPA5HWEnkI+BTrUIo2EfrpZY5tayuz/S6WuW7HMeriZS7l8Wssqv/zhbKxfQn0J0BdUO3aumh0VAhN3AKOj9bWFQrnSGWLD48MUje4Eg8avjMog7o4BcdHoXlkkLkjhSEq0XG9KF+dO13FnzM/Uo0WrlA+5UV/9rv6/+HYyXPWqAvLsWtebL7mfdjn4494Iz7okjpWxxKiLsZREfM3VHBb1Gm4daF5erSkaXhOHxaderTEODNOHuSE+LkHaIk/qbWxcAgnxYYVobHF8dsALcH1J14/7Hd1X0X0HbzbrBeCAdCSKK1eXJ4GbSsZewLhCZEHOC4x34/QkgUSgpCrIbYVzAVD6sP9IEJdjgNIZXRUKoSdkPnP8F0/Rdpi/hN5rNH7dzKwa3lPCOBD7kiJZEbeOi/uRTLz6KEcV9uXltm2gZFBYUS5zN2JhFYexScRpZV3IfBxRblfVug3AfI0i7GXfTEnVvPyOoZQlzCF5DZ0jMxs9UXmIupL85w4PtphYnUjFr3BMuu/FXUjA29nLfrSKRsy91oHIgTDp75CNMA7M3D9BPrK1hhMwXqnmTshkb56W2bWPLWJ3MEIUd3CbupxiRlPVDdSoi7IJnLb4R0wOO+FbUXjsuMZig5nbKsP1tdJo6NSocUkI2/UQZiZglvt+ZaFbGVkUEB0CbQkrsGwHnR0m2MnD5DZoyXBYsL3AYjlk5IZRQaWT1T8nENvLL+hMpcnngL9gdGMmO9HMvubLKcTcK9LAnWBxb3FHSlStCnqT0AKaYG6OOeqAfKg1I8ff9uXRkvKO0kmxffDuhFSn6Q3Uoa6QETF6T1CSxDi5vXDoy66TRGcKB0q9BWuDebwaD7E3vVc88W4AnniNSZmPBnEIEJa4/unxPBBSLS/CTb3nKVoQ21rGASi5yywDbYdfOwe4VknjY5KhSK4tEMe6pFBmG90HjR6H0VpAFRfJELvH2G4yCCAXSMEgx7fDqK0oZFTGX2CaIYYrSgqQhEhK+6NIqdo3gtUCmwOEeqSQq6IzJpXYdi0g0GdGSnaMB3TfXQOBnBmCj7d37yeWZTD8ozQkqJQFqAlfu7NceAeaEn0zpdo7jnihua1/9wj5K7PGutelqf4JNZGZo2VR3QlkLneVwZ1KV8KG8kMNvSETfTywDuYiIMRXYIJdYwEHhkkGj2f4wBQGR2VLG2YhTL/WeZsgXec8NbDs/VuMaFcNEVLgJcdoS4scsrcaBhGRREaEERyHi1BkUHuOeOFa8du+4rGFeb8C3kE8BHbBhqtti8xP0OZA/TGn+rQqEv4agCHYPjnrPuIUlG+3gMehXbITIuWoBNP5jiwnzPn8GhZvE4jtGSz4XyYnsVXzfO1gU67lUiZGHm03OV6BnzIuOZtxMgRvnOr2PgSaz6jrwlkBj7DwJblUBcydogm2baRY5lBXSLEKUJd+Nucu764jvWzrQjZXBeNjkqScB0CX7gdbCZbbUo+foPA0Xf7fau8fU++cC8bjUu2+HFPPKooLxEeIHPBp/1c8cmgCmSTzSBX6PmUOWQ1drdwI9SljJgBH/8MA9g10rEu+uRzEeariyitM0wd6mLnQqds2v7KmzXLMeuIeX6dP+CjBrA5q7dheub5aNm8zFZuO/foRlk4995JTSBu0XywFJIeW3kakDsP3RpDfASOXbcvnLS+CA8dl+qLrY0IMUA2ka6fri9eWxLJXI4rtZ6dAxbvB+LGXsrsA7wY0S774ikk3ZeYPtZJo6OSJJv7rS9KD3Gjeg8PYYZoQBg5iW0DoxnsrUcyRxHhQuZUZBBEPG7s0Tn+iE/0si+GlqDn7B2MVK1LEKlEqEuzGJdQmaOUH9UN9AwzqAuApT3qEr3NmT0f3Yd+Dk2DURdtdGeNjejYO3Ew6qLbWNmim2DxG8Fbme1zxChhy2eYnhVzH6EuTSuXAHkIn2itBuOK7o3yaFJqjUWoZQJpzchczHuEegNHrn3m5f0w0rVhdhzJk0Cu4to+xwfMRb/9wMkM52t0VHYMpS4rQ1FIAsHI5VEDPgVaMv88eodGlLeMIyf7/V4RhvbWiwVXRgblEUzQF0k3INQlU8OTqpRPoC6s3gGNK1ODgFEXceMCfbHN08y7GHni45W2Ly23R0si1KXtBzkzHi3RdhI5PBR1cWiJfiGjl1mPP0RIAz0rbwS1MmuZIlSBredojYUoR+IEWoESQnTPtjVrLIOW9EI/fRvOJ7Qvi81atmTmayOsb8us1Wi+CpQjmPcUKhXwIQGMtYnixsVlHt/1s4MIFoL6upEpXwTwlA3ZQDeA8vooJHUfAFDw8EbZIgrZ4h9EYKmbaZFjwMYONuLwXT8TOxcI5WBGa6jzGUVpBSQfolK2rzhKK2XO5KKZk4Yj5nZcdrzz/4sZDxy7Q0sQ6qIvT5spx0HL4W+CNXygM4NRl8jhQXPW691UqH4ggXDR98JAXRTTFq2NwvkOalSiNT/kbcVo/RRIURDkwCieOFexbUV8XF+BzGWNYGTLrAwi0XNeNCnTghF6nkBdci9YbWWO5qvelw4C1kW71i3ATiELv81/+oJJ/OrvIMJo+QSRXJFKCKOr+e/oLgQvM0JdiogQbdY0wijHNeT9O7ovdnw7Sn8gBIMdrY1lRnPhx87HFfZV3GnD+USRnHcworsQMlGsP3qLnnPT2NoS1KblhVAXf3maPWFkZdZy+/GYlM0Moy7+/Tv2fhgx/9/camNeyIjmtYd+oNOAXs8ifY3qK7h9iZxLPq4QaSUbKEqHez0bbBOjcRF0ry+q2zYvkQc+79HtvtGpwiKFlLKJ4PlMsY5FjmWsY7YtQsmOB0dlRFSSlClEwm/CDKIZF4VkUJfu1E/XVyYqYihHGBlEiIGLZiLEAI9d6jI7tARHqPZvIaoQoRw+ig0i5lLmRZMyhZRArlKnH1CU5o1WMF+Nmy9030YYMRuUgxjIAi3huuHb6HYeLTHvJ9r6m37mDHXx4zfpIaiv3ZwwPkX9QHBEt+2u7/phNxfHDjHoy+trEH33QUixs9v+jfOZJtZzucasnPP/u76A/c3ofZGCDVDLPghYhLpEp2wKZC9CXTI6FiGtflxAHl/XuE4aHZUkRcdUM0gIijCGRE5ooTC0JIoIcWSANz70FuYoImSRgfbW+dgjxynoK3yGYsaTe3NpOfbyOfPNOkKT6NhhejGKipw8ifc3Rfn8Fi2JNsZW7mjeW1mimohWJo1yoHfizGa+/mSyaKvHPzN8VH9qHWqHh60N1JfmOR87G/+WzIFjwOYeoi4R4kavmi/HGCGtGfSTXgEQ2KkcWmL5hzLDcUVr1bcpx7VyhKeHbcU2UaoycydW87HzFY0r0jFfm7ROGh2VJBlDsoDK578j5WURGIoeMtF3obxhZACimQRkyIq5orP1sPAyk/tlEQaInMoajEUTns8PokYUpdEIAyIYW30l6hSQISmPVwKZezzn6MQTcz5RBNa2Qzrm0ZIon9/2E6Fk7bhRRKifVZSy0YgbQl38+A16Aw2yK+4lFxTWUJfQASWbY2atZuphcK2C49Nbz+Y/c/fDiOUTRPrhu348khjZVvg+LcsHot4OncjJbD/X7TO21SM80CZG65nqGNINcWNPyAyRNKXwa6LRUUkSWgTFxge97Pnv0X0jPm+ZuuUVbHyNa6Odqz4njLr0R94xsFGz7Svy1hcygxsoc9dF18fFUkgo0vcptoxjEN8PwzfrcC7Yc0YFegGapI3T/PI0KWT2x4FrfHTKxiIBtk0VdWl4RKgjPt0Xu7WZISFazyx6o+UuZS74qLXB+tK6yFCX1MkOMvcoWCrryUqZI/vi+4Lv+iFOfDiuyCambFmwxqht7bdW+5x8CWV2+0Fkp4bcwRShbWGQ7Jyr6MQTGlfbfHwp4Q4iXJnuIwzVnsGlio+HJ6ObI6Pc76r4lOmqwDGIoiLHB0PgYv6WqhuBkZzrCzhXtGYmgJwzt/tG72BZRE5A5mLsUQ45QF1ydyF0smlUAUWoc16Z2pJ4Llp5Yf1Sgd6UuqF/12jJRtGm48MLZbt12DDURW2ymg9bYwx1MTIr25660yd0vvl8+DRKpGdx3YiVB9/OGmzoblML0T3v8BAEjI2rWIdgzZc3ygqVJ3NHSmTLSvvCZY5q6Qo7HqCWxT0qQMciND916tLN1zppdFSSFCkmhvrmPzNv2i2iGRBheKXbljeXuigEF0x6Befj8pEBhO0DBIMZgNTbnI3MYsYTRbHhG1CdUY/QkigPT6NY05cdTyRzK1MUEbY8onx12193WgU7Kpukr6IIFuiY7k8jPIWjAtAS30brGUVd1HO0zgxeh6zWRReLUtRFOzwz0peae3TPjJE50lfiEKP13Af9zOgrfNcPidAj+7Jq1CVCLaO3xUe1Ln1ulM3IHL1/p3zDPeiLBCfmORfoTd2WRfVtx4GfMjoqjCbiDCeY5OJ6/MA7jmow+njZyIPOeOu0ViEBT+YQDCBzFMm5hRsiGIXMotoknrN3LBeRnOYjdZkLI1HK7CPm8CbLKEpzG1oVLUkhIYyPdUKaQMdauXFRt3dmSnn070xm3Z9GMKbOWml9paiL0jObsuna6DVmbriFSKIEqIsU4/Jya100J5UCtCQsoC9QXSRzoGdUX7l9SaEliXdTYT5iZQ5tYitX2Re3rdK1Wchs5crdkVK3U2ht+OPAWMcSdjxC2wrbym1HgQ4Hjtw6aXRUkmTht/nPMk+o2rtF0CqNtqMM5gzrK2ZlX7n3WliZI9QlcwNlOHYCT0Y52wyf8LROAnUpEQzuyEWRZaYmJIXwRFGacTBIVORTNkF01cpd7WuG60ZYesj5F7Do1CMhJo1CUBetZ0hXRaze11CXTfd8WK2CtslMzzjqwpwivKnpvvBNpxx10c5ey6/oq9BX+7lIbj0XQQ5A3DJrla0f9AzDWo6E7WABjOUjRtaMTYxkDhGwzPvPUuMS1xe3ZR3Cg+Rh81X2NaZ+dhClcshAEaJ3g5SFdaV3zG+gRMZmq22IBnAvuyy+4162hzn73kCpjTEbO0UwAJ/yOS+aUEOLcr8eSg/zugGfaAPxx4Gj015tf7CA0TsYUObuObD6E+qEuCjWIAYgYtZ9G/SGOA/t+BEfrWdoXPo7FnEyTVR0idFIL4+tP8FrlaEuNoVUylnwIchMBnUp0x/2u3N5ZMFn/gzq6zlTKLtA3FAU79chKMpdrDFYy4HtVOq+kSA4waiLswtNqUPsFF9kp+K7k+o2KLat3gbZsczbiOljBuaCpZCi/WCdNDoqSYqibxRhlNAs5+PREm1Hyxdnochp6/uJCD2+gdLKjE4SFLlNEBkMOccf9ZXhE52yKaHrUmY/p+GdEwGfCWmDor3277h2oPt/CgkhyINHSzCyp/pq6gWujZHZttF6X0Nd5mmdUk79u+bjURcd8VHURc0HWjtzvp2eocjS8AlQFz127WBMwNzre2Z8fxpxY6iLTiWg231NXz3WD0JdaOo0YTsiuxDWpQWoSz/bGo0dOwbQtib6Km+m1TJ7Zy+wiYFtZag3Gld4zX4hMxjXmPrZeRTdeoi89fKsf+mxMgPAojTdZ6oGI4hCwroRr7wBwtNFBtK18Q4YivQLmVFfeMFFJ4Mi1KU8QdPJnHoHi49CgvlaoCWBzG1/tbqRpmHz1cm/SfgwZMaf6tAOFtJn/R2dsvEIhl4bDHWxfWHnQc89Grv+DkOT9O8aCWEym+cTITwV1MW/kJHpPS24VRsNQ102wDP0bXydE17Pbs1HqEsR5GC9b/v0fArbgVAXhioEyEOMcmTWc2ATyZqPbGuElkT3zDAbFNULNUDvMzVO5WGPci782NdJo6OSJHTleIk8qPZks4ZRiINUI48eVXln0JJC5igKcQbA8ukRFaUQDHF89LiczCBKW1nk5AwAej6+sDm6gbLl0UVXZV8tLwjbq0YW5cB9NeQmWK0nEfKgnUukY/r3mUEesPMQ1o1oxwDomP5dowqsL71ZlzLX5UFoySQYF0ddurXBnBCGlmA9C1AXpff2fphSz3SBdCFPH9RlsaG3YwEyJ6J4HzBESHRopwLUZYhtjdDPCNXNITyy9Tf3DHvaRJZCwu9UEjcubsug8+mezzppdFSSBIvCvPICT7y45wDwKTZZxMfnGwM+CHXhBWilYkYnCUq0REqZEzlSWp8TQI/wGRLHCeaiI6SIPWcQFc3Hjze+8p4QILNDVFBUZByMGYmGVSPthGy4DcRuxKWO6TGYkzjMwQjqPayDUTpypq8Z1lXbhsusU0is1gUV97KTQfrUT4jMpGQu+Rs+M4e6wOg7KO5VOq2dkFQ9TLA5RnoW3ZHC6iLQu5D8hp6r2yufQ3SHDLOt0ekqbBNXY1vZgQeMnnM7RU+BItS7sOOi2rh5jxwnrWBrotFRSVJ0UVB07K+owYhgxQiZ8XzAphZ62QqStzJ3ffk8auZyo1hmoTL75xO9gbqDk3k0E0cYVo547F5mPa7u/3M0wMqJ2kR3TrT9RaerRPj7d7wzg8auv6PTFgUaoIwbvdsEIAYewej0LHGZW8PrRvTcM5n13PNal7YNR4r082F1NaYvgJLNxy4LmTmfci58Ox19U2QGjKvkUz5nEZEJqbuakb6KiwUDdK/PHSl97Au7G0f/DGUOkOjodt9V2dYMMlPaxMBxCm2idWaiZxjvYbavddLoqCQJKXgqMgigtRRiUEQY9ru6fXm2PiFzGDnZ7877FccHRVd1mWmEga6ID5Cr8vSQ/a4ZV4C6lGgJGnv3f3YHCD/GWxqAdvxRRNi2wajLxBicLkoTQyj6jk7rcNSlHBevY+Goiz0OXDpymq9OW1CEJ5I5g7oAtCRCb2qoix4XQ3j0vE8m/JhqDXWJj0J3c2FQF2KnGOqyodJV5tUAqfWs16GYv0HUxSE8Q20rux4/PmUD2lDbip5z3bY2rq/UM8yMPTOuAC2JUJcx9bODKFPMZZwZ3wZ4vqyYK0RdEB/n0cP3fjjnIbwLoeBT9uXlwTlSHxmUY49kLi9tkqINg4qnZC50lIpu92151I4DNw1DXayDEUVFcz4NieS0PBh10byi0zraAU2hLgQNMJta4kbZGoJhn6Hn046dIxi6uJmhLua4NENvgMysriZCS/DYscwR4qTXWAYtYW+FRrVAvg2adxGLupjCZrVnobVR2gXV3q9VuJ7FtEHzURbQR/aFOzN+s4bIJrWtug2WOXoHWPRuphgt8X3ZsVg+3CHke5h+PravddLoqCQpqrwe6mVnIEyftmCRte4LogGOD0Iw2uaZ6MGjJWhcEepS1t5sfY76Ck4PMZnDEzQgwtCGWUeyaOyt3Pg5WwcjmveOTymz/k5UF6EhboYGQCSEbLIR8oBTJLivCFWw9TBb46KOE+czUX0x1EXrECoC9TKzsduiXMank5nJo/WV1QLplEQVdfFICLIvHnUh9R4MdUEFyb6N1rGGjL+shwnsS4EYaJllIY8IXmO54l4rB5r7nG3FMuf2DDWuAi2xn4uUCE9U3xbvK7ivqEZwnTQ6Kklib23VPyOvNvKyM2hJEWFAhMdGBlG+MUJdumN2YOwMBQqiEIi6kKOK0dhRvYc/DhxFGG0/UGbnzGCUrPs/RV0UU30iw0ZF+jhwUDeiHQwW6QO0hEf6dQdDP8OyBqMzXPR4skFLWt6eTzcuhrqYy9MYWqIRA4K64HcGYT5NE6BJai4o6pJBeABaUiBOUGbsxGqZfX/GsaygLlE9DBqXiKt1AU4152PXPEZdxLRFfPpc+AZRF+cYRMd4h9lW1Rcde8a2lm2axLi6GhX7XZFgDxuPJ+9sCiMDEKlRDxoZkl6Rgf2u6csjGIlKeZzTDrx+F81ECEaUH/aLMooMMjK3f4eoS3F5Gpe5a8NlFpnPOUZdVF/BRpOJvlHUHKEBVQQjQANQCqlAXZROo/kSsfqaSUVxBEOPC8ts0BI6dgHjIjJHKS0zXxmZ2XzpsUss8yxCXcpxUdSl4UgIknkud9mXltnz0TbR8tGbo+YTv1MqOtFD0RKCJolUbKs/8RQgDxHS2ufyNPRuqnLswP56PoEti5AiascDx3KdNDoqSYLeceuxgigso1C6SE23Ze/90H2iyCnHpx4ZxGfrfRQiRZviOHDK6wcye7QEyayY6kJHhLq0vKLbfVu5oxxy2wZFxMXlaZXoW6MTtG6EvH9Hjz8TfVs0wPJBL+bjiAFHXfS8MtRlCsZOZZ5xBMNsxDUEYxbVjUjHhzmWi3ElanhSfDLITL3OJ3KuzNjVZqOb2SLhkr+RubF82KZWq6uJ7pApbCsYf3G0NmF/M2hJH9tqbZlYmTOoS8a2QtRFzN8ip6idT/gMPcKTeMHqOml0VJIEI4MADSiLsOY/Q6gPRLKsMCpTvR4tyqjKuwkWE1tw+HbWjNdvZeYnaBKndZQBZOkYc/KFOCH28jTsFEV1I/quGdZG6xCKnPR3ItTFbI4sZaN0iCEPJmXTPsNCZrWpVTZrfTsru7dk1mBdtTLji6+KsTOZJ2Vf7CSOLXB1fU3K5xw5hFw3RLUhTshUjz0vM3/OdlwsGGCoCzoRNucP+vKoC7FTHHXROk/kUWNv+XGZZcHP97WUbSUya7ksn63vuyBQT1mZQsqMHdhxhjghZ2arr8i2jojKDqLoaBesTHeeL7rimxWLRrfgtlfNh7ezzkrl7XO2vhuX5a9ly9wHEOZIVfsZ2fi0bDoCnYC+WllQNDPxbQDqYlI/Da4t0b/PAuRBOwa1iFi/f4cWpjYJ1KXROoZltg4G3vgsykFkbrSO2UZaXynqYjb9ci50X5tkTrV8MeqCxm770ikAVAOm5YvQEsiHPsMoVdfJXEWTyLooxk6cqwl4zp6Xti/srhWkq2Wbjk8GdWE1M4VNhLYMOyHIvsT1J7KQWf/ESLSVC43LIxgwHRM5GD3seOHIoXRVArkaHZUdROhoV4c8tG34QoHXITtFwMf1cGRgUBf2hmUSOWl+qboRWLzq+oIRhpe5HFf7d3Q0m6ElyNlr+4tu0xXxTlEpc9tXLZLVUWEJ789/RnUjmbs70OVpHnXRBodda2+O1tINS4+dyAwQg+jIMBu77ouhARAtCZAZht4Y5IE4IXAuBqFS5bgimVlfGYQnhboAtKSsTUIy86J/nQXAdyc5tIQ4DzXUpXF9YSRELOoSoBwQdVk452LaRGhJDkEGfBYOmJi2yNaXtlU9B4e6NGBctOwgsWeg0146JbguGh0VQiwCnv9//jNSBI+WoEitREu4B104PNNSoTzqAj3xhVMEZJ5amTt4ko8doyXMMej6MmgJiZo9WhKlkFqZMOpinZkaghHVM6AIlEXNZoMgjoGOHHkdS0LmRp14IumPCC3J1FdM9PMhjoHZ0AmqYOoiiMODkKuoSJjdM2OLe+33FnxgGo71haNPM3aV/ogQHjbv8P1EBHVJITxGx7jMvJC4k1k7ITnUBfAJUJcJ6YuhExyZ6fjonyHyECAh/mWCeux6LVs+ZV8evYlRbyuDbh9eJOqcGYz4Y0cuOgq9ThodlSRFsFmU24zO33tEBdeNiOEDi8KcYuLiMssnQl186gdHKq4OgSAYpkCRoSUzEhk4JyQ6Uj3nQ1CXqePDIlCV1qJ1I2AzYpFstDnqwjmEkonk7u7QxdY8+paFPLU7UuYbMZFZjQu9kFHLZ2QOnJlWH8saHrBZe4cHICF0Lsxz5g5P96I815eZL9yXKTol48IOIR7XpkIVoltwufMpizZofRmZtf5EMqvNnJ8wKr9r+BROCLBBrg2yQVrHvNxaN2qoS2HHoW21djy29YCPGrv+iQ48+JcSRieeUBq7rEfcGi+ar9DhESPrOml0VJKEJtm/1wK9BbQs1Cp5es/X8iGeb+QdAyOpo3wRhrpYmfEbjbtfmgZHl/o4sIn0A7Qkyuu244anqxyfTARai75TqEsToS7znzZqtn3ZIk+CqID7RmitQgINCO9IUeOiDs/CScMOs+dTvQl2hnXM9NVoY4yfs91AfV+yNXaNEAZ9UWdG9cXGtWjD++rg9A7BYDUq7BZlw6fBKKuWj52Y8+PK1dXYzyI+Xm60vnx/VlexM4PmomijdCxTD6Nv3Q3teIBOdLYV2MTCMZh/jo4nl+/f6fiUQSkYe4HM8P2gRF26vnzaa500OipJQlF8VChb1J8EEF2kvP64HiqUZWgJ9NYLx6lc3E3DjVuJlnCZ5/LGdw90fEpj69EShGDo48DsWLH+TlgXoTcRZpBBpM9O6zDEqeRjPyvkaTjqYtIWZFMzKSQ2dh3tVlCOaMOyJ5UIqqDmix5PTmyOG2AuwrRXDeUIUzbKISQbOkTJKNrGHdScjs1/6kBgEFpikAfCR6NtNdRlFtU4iRpX+V0js0NmMILM74dhCA9CXeb2DsvD0JLordAR6lKi3lhmEewUFchMYFv93qOntXzDMpBZ6eq6aXRUkoQ88VbpYKEs9VgTzkzwTobICVl49LCi3PUFjK1xMBrirTu0BKaQtIPR4LoR3YYeB1btIwRDG5xa3YhJIQUQd/V+jwYbEt1mM0Aw0L0TXmZ7PX5lQ581C4OSOqZKinL1vJd3pMhiXLW6kVmilkNHsam6EfKcNbJHnYem7oSYuaC6gWvJPJ+ac2UCAZZebDq0NpM6TJ2uKhzdjM7LQuY6H74GddEpQ13QjcSeF0NL4EacQF10+sz3pXWM6WuRHkK23rXBKRtv68u+CoQH7T3q+eg20X4A61jUvK+bRkclSdbrn/8srl5GuUTnZUc5QLQZabRg/nNLnsATxykb2fqbO03AUA4SWZt0DInUtMFgqEuBqADnqkBLyIalnRAUGeg2DXHAtNxRJJvZjHS1POcjCz61UzYR6qIdDJ5G2epLO2kBYlArlA1Po5j5suNYtNGRfsXh0XPhHR5UwxMV99Kjx0DHeNqrrmNRyk/rGDulZXUMt0GFspGO0bkAaFuESvE1KKqN/R6SmddKbck8c2gJsEFRPYyeL466bPXlnRlixw3qQvjon9oJ8Q4Gcpq1zLpthPDgQlkvD++r3U8yiP86aXRUkhRVQ0Mv20N0KGXj+ISoywKiKxdBkZOsoBxzQ1rKzNGS7nPDh6ABqePA2pmZ8boRe3kai+b0uEh0qaOnRPRd3dBn2bQF4WPkESizNji0fgCNi200TYe6UARjFhTKqk0tc6Ns5n4Y5oQYdIulbKCDkdiIWV9BygY9Z6Zj0bxr21FP2SRQlyhd1Vfmmo5FSBFEb9gaDJBPgnJYBFkWY+f3unQbMUddtMxSfFePK7wfRslMURfvYCCUgzghWmaPhEQOT599Baa0Rkdl55FFOZjnq9uL+RuCZ8v7RmSLD/CyI4hOKTJbKLpfHX3zO0nwxqcXjclrM9SlYahLh5aEt2saAygFH92mUX15Pjqiyb0dmPXV8cmgJbUNdBbIbG/7jCPQMI0CUBdWO2GdomjsuK9UukqnP4gTolEpuhEjhCcxF1zHOrg8U2zs573TMYEIoZVZ2wQuM73dV/VVT0Ul1sUsQl1kITMvbC6dtOV1lclT9qX56/9rXfW8EPIpgtGSxvdFDkVw1KWb91auuQxYZt02UwQbtUEOukd4ECLpSwrWSaOjkiR2udH8J3BCvFeLFME7PCCi8ZtMrSaEpWyKuhGwUAo+KDJwaAm8n6BAb0gkq55R7dRGBsGIoHtUf8JueU2hLtHdJgAt4bUu9XRDVOsyBWOPCmVZ3Qg8Cp1AS3ixaP2eGQ2nl3Mqaux4czTv36lE8ZFzhaJ4X7ScQcnQ0droDdT0GZr5qsgcOGn9jkLXa8Bsugr3Fd4zA8bO6mFCFFGjJcqOsXebMdSFoSXGeTAylzIUMidRl4UTgvaDxZ7Bg9Ly4EQnG0fzy+dTojfakRMjxzppdFSShFIbHcphPxcpnRmYssncKKs6bkikZm9VJcrr0JIIvfF8+I2yPFKzJ1/K72q5IwQD3a5ZIBgAwmV8NvX7dwIjySNZsPGxjcagN07mNqLRqbHM2MlztkXCri+wWfObYLFh02PPpGwaomOaT4QGWD7xJsuQPTN2kxrzfETxiZ1PjZaESBGZd1vkifkgJCQ8ETar6OqsrquRjqGCW+ZcRfO+AcaVQUsi5xNt+F5mhrroFFIz058j58GhLgT1ZqgLulvJj43d6I32g/JdP9gp0vyQk+YRHjz20VHZMRTdKIuMmy+MwimbTjHnxk1Am04GhhiwlM0GkLmVJbo9sZUbbUb+/TscDehkZpGa3qyr0XeEukA+ts0EGHbW12wmHHVRJ18yd6Rk7j+pRs3hc+4MTu2uDMsn2PiIE4LGVaZsVF81lCMYl35vDt9AZSEz17H2OfNUlN5o+O2+3biYrmqZq4Wyga5inbd9Tc0ztN8rZDa6itdFRsd0IBDdHZR7zrGOaQQjXO+19WXWMr+jiiMhAtsY1AXIXPDZ+m9xPwxweDzqYmy9QtLmcvG+CmQGpL3Ko9BdXx6ZWSeNjkqSEGzWKhKK1Eq0ZOtz4NW2vOB9IyRlQ9MxDYbTGRISvVundu+EyTUHUTNFA0xETCKsBHRv0IBKJJu5c4MhTlrm8O3AxmjbcXiZ2bxrPia6pOmPTKGjMkjEwTBRc+BgIB0zbQI0wIyrkkLSc0FfyKjmtEzZzH/a9yUxHdPOjOMzBfNezGk3Lup8QrTE99XxyaAutSPVkY7B+2oYQhjdw4PGFaIcljeSuT5fQdrLrFP7mW+jndi53KovbaNm5Xe1fCHqAoIO35c5Bt7oz0tnpng1C9gPulqXwAkJ9iddb7Zu2rVuAXYKIeX1l6dFaEntqK9FHsq+RFpDUX7u0RKc29R8MBrg37/DNqPpRGRT4kgNbSIULZkth7qYqLAiT9MI30TAPSFc5gB1AehEJDOLLu3JFyJzYtM3kWxlI47qRpAzEyIGtWcYbcTa0V+kOxmfOlqio12mY/ZYuh+7mvdKvVC27iiTssmgZKxuJKNjWn846iKdzAnUhc97JzOfr64NOwmo12DtJZuhjQL3w3jUxdgohroAG+XlRg6qiEe9O92wJ5WwE9IYeaRo37LYBHqmZW77FMGB63jqZwcRggN9DhDl99q/IzhdRwE6ImZ82EVbBgkhxzB9ColGGSp6qh53NYbdNLG1Ewx1QREWkSe6eyFzi6neIFjdiL2ZNo9g8GLIIALVThEZO0olxGMnhh3cCBo6M5UIPZMmiHQMOjOBjtXeCh3VYJj37zDUBaai8HPO3ufDC2WlkJkX3HJUARWHxzLbz8q+Eusrmi/g6EYy11CX/Hpn6wvoavDm8Zr98SeDYMomRF1EyVzKoNtvzrgzYxy5GW5THj2ef44OPPi7t6L7YdZJo6OSJJ6yIXUjJGXDClObRiAawO420eupKJQFRnIymdjoiaAB+HSD2DYAno0i/fqJDJwj1d+xN51mjDaWOTo9ZG7XrLyYL7ylE0RG/DbdaHOUblwsIlabWjVlY2QmY4/uG5mUfML0B9OxHqmWKLWRieJ10WD9grVg3qdgvugpG7w56DGEqVXwnCMEgznnNpVQX4MZZI/2lVjvaC3z+arXblkdwzLP7SqROWMTEnNhniFFXVRfM9wG6ZjvDwV38/GXTpEObDV/Ee18ykKuoi819nXT6KgkiaZsZnhhGgRDw+lB6idKIYnYiIYWyiZQhVkQqS0g01k2ciR9geiJnXxZtm5Ey7yK+0YMnwBS5qiLJGTuHIzq2IOITzuESMcMnyiS1eMiG6i9I8V+hmXG895Hx7LForzGqeuLF8p2jiVP1ZUyh855de0kbhLWukoRJ6nOV7y+tvoKdKxLSSxXNwLRtgRam0l7ZcbOb1pWgRKzUcFaRjo/51Xa8ZlymDX/uczduBjq0ieFpOfC9+WdEKRnWsfWTaOjQsjZDodyKOehwRdSebQkOvUz54PRAJ9CQn0VaEkFns1EB024GSGZXbQCFlQUrbAbUzEagGW2USEeu61jcXx0NFeJ1DKoyyzqC0TWxYYFkQf+fFKRbAUtiRy5DbPpE+cTomTBnNYcHu3oBrpaO/WTQwgzxb1RjVM37+x2X3OxXhXZi9BI6WTug0oVTlHdidVoia7lgHzIe7u8zLxupC6znXfbfydz+ZyZzNHNxggtiVCy6nqPUjYAIfQy8XcYgbGr9a7lnP9f8UkgPOum0VFJkr2JsPs/g3A5WkL4kNyuQUsyEGV01Tzw2MPr1onR1guT1XvYAlfLG8nM+WiZ6w5PNeoJokKLllT4hKgLcDAGRLLwIrsUWiKuTTcuGskuHDmp6pg++RKhUkzHkEGmaFuwifR6149BeMi8zwLHCSKE9bUToS51ZA/XDvix89SYLMZeRTAiXdWbbA0pavhcYITHNIEI4VJIUYS2gbkI9WfGxi5KHiZz2Zceix6DR13QvhKlkLRN0D4GTkU5ZAY4ReOFbzuIWG2JXixaf316qFYEy06+eLSEbkbtRmMi0PoGkYFVWfS9GdaNqHFVopXIsNv6E4FtjKGooCW23oPIY/iwDb2OumQcS3PCiKQtUidoghQAiuboyZeMjkVzqnSVyZy5b8TKbPvv2shCnhqqoJ8zvXm1SWzEGR2bBU4I0LFwvmo6lnF4Ejqf07HoWLoUfAqZkVMUrMFMkXANjTQpv8TYC9RFz1fFHmZq/4x9Zk5j4YSUbbSO+bGhd59pGczYlcwiIhPzIsVOnnXT6KgkidWWsAhLK1f2/Ts1BY6KGFGEzmFwoc5MO077GnofHSh5KpFI09TRkrh2oowywudDo2/dl4R8mgwSEvKRLT6Jky+B0YZIUSJCLy/jAvNOCkGj9IeV2X6GZGZoALxvhOpYhBAqmamutn2JoNdY6O9oXY3fGcTG3vWVe4Z4c8zpqixkrtb5mDZ8XDXUZdbwwubUu37APSEcjayjLr3XVzCuPqhLqKsMdVE6VkM+7Vr2hbJlX15uVsdiA+muLw2YGGdG2cN10+ioJInWlpC7TQq0pBY5NjxSQ0diw9M6zEj2iA7mEWg5rjnfblyZwrlMNFe7hdIiTk7mBR+hqEvqaK2JwurRU+3OFnY3jh979VZeHcUnou8whURkRmmUUsekGDurUUndMxMiIVKMPU612M/82E3dSPCcq8hehJIBVJMhPKwwXssc38Zc6nOkY9QZBjrP0NGwzkejJZVUb7iWF/MlfOwQ1Yyc4cR6r6A3cb1QXZ/76lgt4NI65vuze0r5OZPH96fbrJtGRyVJLPXDFFi/HVh77FFxHYvUtGdbrxvhHrs9/ma/V/BJ3EJpo4PAASNRDyq4ZZF+pjYgykcjPmHRYCX6jiI15BTFdT4C2+SOgXebWu2FcWGhLIiauRMSPUMw7wld5ToWOE4ZPhrips6eFDIPQfZQMXaMOOG+4LwH+pypJWPrHa5BsslGaxAe3w5tAuMjhcw5u1F/zlEqnL6ZfZqYd6Q/gU1g855BvPVzZq8GQE6s7w/p2FxuKf6v/74uGh2VJCHYTKSS0wfeOD3uGkVqqk0qKqRQp5KZRmqykJmNy96gaPsv+ASoCxo7j76DSA28f8dHavqV7tXTMYGxRQgPT0lEDkbJJ3ozcg11iWF51VdtE5nVC2XnfQnsS9fV1Go59Nph6aq4bgT0RYu6E+mqNHqDdSzzOgO9BtlcwELZwLbwjU968ak6wwr5jN71s0nWe2Yto9tZy+csncyVccXInuJTW18B8olkZnOhTzwN0bENNRe1eff1J7o7NKeel3Ys102jo5Ikf059opW8AuFG9QPas82876a20TQ6Oog2fYZgIKgziObqMtdRlyhnnTGk6PK0ci7mPzMnXzJoSQZ1MSeeaPS9XP2AhYvb7zGZc/VCGRi87pxHtQGyNfbO0eUIWHDfCEIMirGLasMcnlLmYoNA9RU0ihduEyBK5vpC886QveAG6RTykEFdlMzV230bXpvUZy1HCAaq3eIy11FNg3xG+lNNL9Zlts65aWJkZutd18Ow4BelkArUBaBbnpfW53XT6KgkiR9T5ZGajjKqkVo66sF9GbQkYShYlKGjuarHHuSa7bgYH7V4SURs0JJaRBOhLsqZ4TKLknmZCFQWbTJRWNUpClAX7DATmQM+6Lp1hlzNAsOeqRtB17aXz7nrix+/7ea9182iUT0VGVfufVKdzGwzQnwygcmgU1o9dDXSeW3H6m+F7tC2SGaKuujTQ1WEh6OjyPZGyCdfX2CdJuxqxoFnhbt961iY7Z07zFvfS6IuutlYo7IDiUJwZtExpeLRkzU4EvKJjqD2Ka7TkX6Y0yfRdyoSUYu3GmXMEhGWQgxYlBrx6fv+FIq6TEo+0T0htZMvBnWhBlk/Z9MkN3bghHDHu+7wRCkbZEhjZ4Y4IYk0Sl8d42ikLGRmzvkG0B/apuHwvkb2aqkoW+Nkmrh1QZ4zQvaC9V5bF8b5TCAGEfpXQ13CeU/wgY53IY8UbSgqHtiNaWItZ5DPzGEHs18QNBIXdZPn4/qytS5de33CaB20VkflvPPO20qjdP9e9apXrVMkSqURmP+MThNkbqFEx0JztROuLw3PUgUWwIcZLuGbkYkOWt54segUEoc6g7oRLQ+LMjRaUpmLdGTEkAcwLpaSiCI+VBQXjj3hFPETT7JoUztZFs67QXjsZws+PXW17oTk0hbV01VBX/AmWPKcIx3TkWzN4WmivhI6j1I24cmXmsyRA6bGXpvTrI4x1AXyYQihQZywPKFtIZs1kyenY7EzHN4ZpRAenjZF64s5V1rHrMzWrlreflxtf+ukXWvtXURe/vKXy/Of//zF7yeffPIapeGU2dRooWzg1aMIPbr5sA6DZ4ohcwWuHDasLxYtc2ZcdQSDp0jQc2ZOWu5dP/W5iG/73GoTzPsEzBe7nTXKj/e5byQ8pmp0jI1Lb8QZhLAyXwnURY/dbxBWx4Twmf9MFcoGyKfWseq8B+gNvFWVjMtE3xTBULUKwYaeqp2oFbgahCd4zr2QorptoXYjWO9wfRF5Gu0QhrqK+4IyE3lSR5ibQJ8XwYIEzqcs5GEOs/796NbEMxvVyrROZ2HtjsrJJ58sZ5111rrFqFJcqDb/jBfKKiMZRXOJ6IAqHoieeKGsOrVBI9l6GiVCFWDUHEXEbOw6kq30FUagynDV+eSKRTOoC43UMnxSiJwsxlWveZDqPTP2enw89ihlg5C9nI65voxu2O+VfIIIFMxFpGPV22KXnXcQfYe1ZBSRk4XMy9SNmPfv9JA5Qv9SxdgMdemxvoyDESGfFbuaOg0XjR3MF9MxjWBEiHfGJjRVndfFz5iPiMjRzXjeRdZ/6dvaa1Re9apXyX3ve1957GMfK//lv/wXOXr0aNj+0KFDcuDAAfPvWFDpIc9/bqqzXUMiNRgVBlFP7YpvbQSiI4TVinpzmoDLzKJLHDkmIpEAlVr0RQ0yj+IRGpCKCqMIlMpcypNBXXiNAT+t00WFvG4EolsJHWOoi0GKgui7eqdNiBB2MnPnXD3nmoMarB2EyPFNn9eNpAplgY7xY+namRHcJoOyJnQ1tglbMjeJwvgkH/6ct9oE9nDwW6GJDZ9lbEvoXImSB/eVQ6E728t0zF7FEMs8l2lmxtqSviq/RVQiZ2bdBbVrRVR+7Md+TB73uMfJaaedJh/4wAfkJS95idxwww3ya7/2a/Q7r3zlK+Xnf/7nj6GUc2Le5uGjDW0DCwIpMhMYW3ATLPPY9X0R0bE1Chu2MgfGBNdp+HHJgg9FMLTMlQhdRz3Rm5GraEkQPUHEIHiGNbREw/Lh25wXxtbysRtEjQ+vTeoTyUb3jWQKZdEblgsjOUnoGEIVUs6V7cveTCuQTyayRu/oiQtT7VihzCRlg3WMOwZ8vqTkQ1DWTYWApXSVPecAVUjdBGvsT7yWM6fzojujMvUnxiGsoS7RfKF3n5F5j9JwOl1VQ11ERI5skmABtCmDju7/+mTQOmjliMpP//RPFwWy/t+nPvUpERG56KKL5ClPeYo8+tGPlh/90R+VX/3VX5Xf+I3fkEOHDlH+L3nJS+T2229f/LvuuutWPQRITDmPKkSFOSHaG80VTNq+LTRt+y/5ZBCMCDKVgk98NDtevNGdALa41/Iu+QiVJ3XvhNms2/6Z4QoQDLAZxXc4YHlg2iI0gDU+QcoG6UYhs3QyJ1JIqTRKZuy1vgI0Uusq17Gur3phc9DXBMx7MK6qE9IIT9n00rE66hIFQVZXifOZmi8pZGZIWtMEqGbCjqV0DNrV+hpc5iSgtaumCRx7qoYwcEIWSAhBXUR0WgePy7QhYxcRaWayVlo5ovL//r//rzzvec8L25x//vnw8yc+8Yly9OhRueaaa+RrvuZrYJu9e/fK3r17lxWzTgGcNv/z/PfWG0Vt2nk+op2ZwGOvwc5xGmX+M3W3SU+Im0KdDY/U9N0mtar7qNYF31+Bx2Xz0fj5pO6diNCbls+Moy4T1SYlM+Wj5yuBulCZ9VzYz8o2iXkPxw5kDnSVOTxaV6cJXaWIU2LeoY5F6Q8yLj3v9bqRhiMY8DkLbpMITDYbXptkdJXqWOkwcx2L0nCdzDUbFd0gPekx9lnwDHPpaSn4UMQp0A2LpAlpM//ZNCJHZ/FciHAkxLRZpH7wM9RtmI1q5V4nrdxROf300+X0008f9N3LL79cptOpnHHGGSuWanli0NnRzVnxWUutAh/VzkwAO9f4zBqhsKGtwSAyg2glig4yR2szkX4VMWiCega1QbDoEr47ho09SFuYaI7dM7OI5jjqAo9CU8QgiEATqAtKL7LoUhdehjrG0nAGvSEyJyJZVEQd3wg6gX1NwfOJxt7nBukM8hm9l6p+5JzXumAdY2Pnd5vAeY/mizkYqFA/hUpxmes631fHxLXpZK6iLjOOskIdCxDvGuqSOQrdtkMyW7SkdTDwuEREjhzFqAsqpmU1RSLd2NdFa6tRufTSS+VDH/qQfPM3f7OcfPLJcumll8qLX/xi+YEf+AG5z33usy6xKLGI5qhyMFh0oJ0ZFh1EbXQ01zBDqj32pVCX+c+oiBGhJWWU0cmcQl0Sxo0jM53My5wmMHxo1Fw+ZxZdNkEkayLiClxso8LAkJIoTEfNtdNVmULZCAFDOsbGNS8Sxn2ZiHhS0dUsWkLRAEmMS/FJIIQcsRQlT0LHKOqiHV029q6vOoLB7+HRtoW9XNWgJVXEkjtFvWWuIXsZtCSSWaElNT5WZr7p12QWyTkhDHXRXzla0VXdF7qVdzqxtmVdtDZHZe/evfKWt7xFfu7nfk4OHTokD3zgA+XFL36xXHTRResSidJkwuG+IxpRIZ7/4QB1aX/XbRhaciTiAxADdslPdFong7ogxCCOIIjMalOrRbLm5EuAzNRQl3DsCAUikdrmjKMu6Ir4IQWTC6MdRaBgvlheO76ZthtX7TlHt/JmnrPeICifhcwi09q8BxGxLTKP0aT4pJKWGfcFb2wO35YeI42GD2uTQEuiNYickBCNrGx80ckXNK4IZeXoqCiZSV8IjQxuWq7dcGt0LEIjK+tdpLPj7PmIdPsBWxeGD5FZt2Ey6748n/Z72pFbF63NUXnc4x4nH/zgB9fVfS9iEyji0joULcmgLpxPrs38Z3icc1IuqEzUXMgMCi+HIRjKKNGcrHTyEDRAHweuoS5R9IRe+MWeYfQ6exSh87Fz1CVzWqf9SgZ1aTTqQo0tf85t3/HY+817FZlp+AZhdLUyF9GtqmhdLCdzhBjo54PHlZG5m/fgtI6e9166ysdVQ10iHZvovhJzUUOc4tokNF+Bg1F7C3xCZhGRTXqCpvu9teMR6sLuNpkCPjFagu1qy3vW8L7m35s3WjOgsv57VHYCea9WpPN+jwaFsos6luiuFcCHedr2hBGW0fCJNr5a9B1GxF0bhoTAmhAWgTb1yDGT195sAtQFoiW+L6mPHaIKpknqtE4mkp2CZxihJXWZ6whG9JxT9TDgOdOxZ5C9GUcwEMJD30ulHZ4EWhLLnIi+qzIHNxKjdEMG+Qx0rHb8P6WrIeJU17HUWjZXMdj+F22AM1OceEqsZTtfJFBSzkytxklE3fJK7Jhuw+5EivgYZ4bcKDtFfYFg2+8raJ9bOGpr9lRGRyVB0NPc+uzIwjvmNyhGJ4NaZT0SoS4ZPpN6G7R4C+dq2kVGmdsaNzMbH4lAM7ezmlw8iYx00SBFA4zBsbwjPlzmnnUjZN7jSFY/55rM0lNm12axYQUyw/lyMoMNNNQxNu8A4WHjit6TZWSuokCJeqEIdZlmnrMsZKbF6pNuLpa53RcX99o28HqEaF1UdbV+b1K0LlJ8oI4F64LqmNT5GOch5iOiT+I4mdV32Gkdmx7q00YK8nuP56M/i9poPVsnjY5KgsLUT+CxTlyb+fdiPohX+50QmUF9EY894tN2HRehdc4Df4/GFp+GR0b2xY7xuMwtndH7iSifclz8ls4cVF6Xud+Rz1TdSDFfk0WbXjIXYxcgc7ChMxQIzEV062wddeEnXyY9dYyiLugZEpnj+ep0la0LeNld8Jx7zfsyMs846jIFMrPTKLGOZWQGtiW0UW3/9TXI75lRp2wIHxFu62EbIrNuE6ZsKJ+yDXZCXBuIlrg9LGijT6Wug0ZHJUHQ00x4rB4tQaiL92oRL4SWlJGsFG2YN2754DY6lcCcq1zUk0Ndau8ZsdEcfj4xgtEZQBYV2poQK+NC5kykrzbH+jHVusxRJGsKZWu5+BlHAzKoC76hlMkc1PlkUJdJYt6RjgW6Wr+hNKpVQHyczOC9OfQ5R6/VSKBt9jkTmTM6pp9z9RkGqAtAroa8edzORR8dYzJvA1oSFsrGYzd8CplBX+W2MhAtqfMBbIwOrZNGRyVByBtdoCVhsZJtg5EZMW1Qf54P4gXbEG88apPhA9GSTGREo+bEyZcZj9RwpG+amCLGGoIRIwatzBHq0snDUZduXDU+mdM6TdhG88Hj0o4cf86yGBer98Bv2jVN8FHoBFpC5z2IvjP1VBp5qL1TSSN78dgllCdbw8PHLlvyZMdeWV+R/mhUiqAumXm3zxmPC6JkgT7X3itkHLkILVnYaC9z2YY9Q8sn0Rd4hm0zdlus5s346P6YzFruaH/SzuU6aXRUEoQUoV2EMfw2qbYpCpqgV2v7QrxQwW0ZfSM+scxzPrgvDQeyaC66XdPkmmvHS5s6OhHdYwAvYUvxSchM+fCIzyAYlUjWvAtpkMzzn7bOx7bpUhLJiLiChKRuTJ0FdRoavUkgPHXUJfGcAx2ziJzgNpOMzNJD5sAZzsx7QsdMQXIFdQnfqaSeT58XRNKxG+fK9oX0J0IwmG01l6f1KIKNkZk21eJlLvvyMmte0Z6xcDCCPaPcVzJ7D9rD5j/H1M8OIKgIW5N6+CjP77WfRW2mjs8uAM14PpMJjw7aNoiX54Nkajc1ywcbyZDP1q/hKRIAF/u+EMy7sYFl1n1xPvplcNjg6A3CP0Mdxdf56DaOj3F4tvoi49KwPEVCMjJHfNR8tTIX874Ye7eplc9Zyczy/lDmYN6pzPo5Syxz08m8sYHXRViroOerj676NQgQFS5zXceaYO2YYlG6dtS6YOgEcEKKsYO5iHSV6RheO5HzwMbe/c5s6wZoE9WodHy4PB0f21d7eVrER8u9/L7i+vJQkeT2MK2L66TRUUkQ9mrnn7G3U86/J4k2lk+UQjqSSCHZGpVYZsQL1cywxbt8m/nPKLLWkPLCcAUpABYdTEBf0WZ0dNFGbJuWj2mDx2WMLUUV+O2RcOysr1knD7/YKrgu2yAGlVSCGvuw+dqSuWkoxN1r7E0jm6RoUOvY0YT+1PrSfKI0yibTH7VZs7FDmdlcJNaF1rEohVSb91mjb0ONxh5v+ubOHzLvui8mswi3iXpujtDnXLZh8x7xmSA+pYku7XhmzwiQ+pDP1O0rg/ewds7K8RxLGh2VBMXFtPGtfrpNBNH14hN42bovlv6IbtNFN+6WUKeUfAg0bfiQSCSqhzHHeBe1AaaJi5oJHw0799iwokK+6v0wMy6zjmTp/QwgAg3rWMi4TLqqUhdhCh3ZXJg6BPycjcx0XMG7YxKRtb0R1H7P92Wfs2lCjhVjeRqNzERoQKJ+qYaSRX2hgtvoXT+UT0bnkcxBuoqnaEuZoxtca061CLeJ6HbWqP6E8gF9RbUc7NZZzZvdFqt5h3yc/R3KpzvsUd9X1o2orO1m2p1EGWWJ0ZIWfiv9wkmKj22DIMOJ7wtAM1OvmMCZ8TKj/lAbFolEfLzMmE+36bdrhaU2dO6bQcEmlbCBZdabvu8rF+lrx4nxkY5PpSAwlY7RKQAyrhRaooqE2XzFzoOSeTFfmI+u5YjGLsT5nAI+5dhL3SjScGouamMPkQeASpXzpfqqzGmsG6XzSftKOU48HTMBMpdrR49dwnHZvvBciHCbiBwMJrPlU++LzbvhA+CS6URkM5BZ9xfZcW9bMw4PSut425ran+C+Mv+57iv0R0QlQVE65nDosdo2ETLThw/06J08g2Xe+si+ewgb5MOBg+Fl1v13beY/M45K+L4kfRyYRJcZqFwX8rE0SgaZQXyiNyzXnYd6vn42a/iV2tMMn/lPnfbiRZX1eyfmfcXR7kynJCJUij5nLTO5m2LBR8tsmhjEgKU28JwGTlFmvhIoWU3HNmc8fYb0h9VXbAZrR0fVNB2j3r/DUj8G5ajMl0jwThz1HfZOHFM3suAj9TYZGx2g3rFt9TaaOyG9+ECZ6+MqZA7GPt5MuwMoOtFz5GiUAxTTBgAqBR+kmBPfF1Rw19dAmTPyTN249GdMZsQr44R4eUR46ieuvZn/tFA5lnkWpXW2fo2KRSeqr9oJCFN4GaRsqm/Ebng6BqEumZuEGVrSBBuoTSEJGReS2TRJyTwxMre86/PF6mpmwVzA58za6NNeEdpGU4dAZoo4CU3HIB1jtSVRWgcWJJNxzftqx4HbiHCbaIpXyUZs0BJi73BfeN51m+ga+dgmDrCtsI2TB7WZOj4JeTAy4/oC+5NO5a6TRkeFkJ7WTE4SVlX7Nigdk4DofL5xKGRYyhMsgh58NqaTXD0MMSaZGhWbQsInaExf5HSD7qs4BdAD3o9geXSck8mcSyEFqY0MWgI29GXSDeHYFxEYPxmE0yj+RIaUY2fPeVY/GWRRBXLqR6d+2HPOoCWJEz0hH/Cc+Qmseo3TpkrHhDJTHZNCnhAtIfbFXp6G0zHmqO9mjAJZPtiRi9roz9ZiW1N7RuDMLCtzsa/w0oTxePIOoAiiCwusnCJAj9VtxBmnKFNMm8lJRpcJ9Snuzcg8mXB4tndxL4HuM05R1MYWi7I2XYRR27CaRoIU0lZfqZoHfjIIFa/yolOeIjEykyJGg/AknCt2fTeUOUBmaumYJkxJIJlNE5tCYu9YUemq3NgJHyVzqkiYpHVgOiaY9zYdw48D13VMJLjQDDgPbOy6TVnYLKBN3SlCaInf0HM2OmFbIyRkaT79HYzUYY/EHhbJ3F6sty4aHZUEgflTiskhw+L4V6iYER/b1+Aja55PBAcueaQ6J/P8p61jiftCvPy4kNyID0v9ZI5UR6ckUsWiehOppHXMiZ5gc+TQvSzkYZG1jpyqJ4PC1IaSuXX2SGRta4rEttFoCXFCjMzV58NPo9j37ySec7UOKnJmOplTp88qcxHLLJ3Mjf1eMfZZcCrKOAbxvOs27BmaNkHKhtVyTBJ9aV6rtq1x4JpI6ywtc39bH6aiEkeqx2LaHUDR8a+4EElMm8HFU4k2vt4jVbgbKG/Hp2iS4tOncEy/j4KlkKLCXVTcywp3excAM4dHQaFlxDf/uRk6D3qDYHwSG9a045Mphqxdob/ZJJwH7TgxxClw5GAKKeBTOwq9GTgPGyptUT1WrB2w4jl3fOpHdAPnQc9XYz9D46oeqQ5k3jA6Fs+7SKfTUYErs0G4eLW/E2LREuagqsvTAntX2NaMTQw2fVaUq3mv3kaDvlyb3L6ynMxj6mcHUHj8K3Gr35HoJsIBfOICV97XIJmjI9URn2n/seMaHtsXcmY8H9SfHzuS2/eF+KC+6Ga0WX/D8hxyZzn9buNbwPvs6HFwhHmiNuKjFTi9aXgth+6rdvJFp3VYjYGRecPLnOhrAUtHR2vBM0ygJZmjtRGCQe8AmWiZ8bzjsfO5qI+dv0XXICFkrebaTIo2Yd0I4TMBbYbbVscHHitO2MTCliGbuJr9oLSt/KbyZW1rxo7rlPA6aXRUEhShJeErsrc+C9+3MHF8ApQj6mvD9wXb1GUu+ARoSeb14NG4MjU8/hlmZNbfi9rQ4t6e71Rim1HUBtXD0FRCI3UEIzjVYiJ0Untj7ochJ3EyKEffIuGUzBU+5mI9wie8QyZTLAqeczR2lj7LoUCdY1l7sWOGTyuTSHzVPFtjG6ANQ8kMH6Krhg9wrhYORqK+IrR3CRvUfi20L44PRkISfFI22tu7oknxrp/Itvbriz+fEVHZARSnY3gusYPWopqQepsubdGlSAbxcfJEecuOT9mXH3tK5gw8GaaQ+shc54Pa+XGhNv45I7kRn1QKiaSr9HtY6K28ZlML+FRPrETpj7INTaOEtTcdn1pKoglqS0yqJTEu6jyYcdmxljLX3wodHQe279+x30Pjqs2FLthmTpGIWhuJNtGxYrbGbOoH89FvB2byaF65u0SCmpCUnUrYl4JP0SRnp5xNzPBJ2fHMvgL2jD5jX/fNtKOjkiCkLB7qy0CPq0r9ZFIkKZnJDYu1vlaX9pr/DF9XnoI5rcx47LbNdJJLIdHC3e1IIZHbPo9u5m7lZS9o6//eHJb66fj0ec9RdFMu42NkJsdUc3zmP+N3M2nHIE5/6AvWynRM+ZyjFzuySBbJzOZCRB3j9ekzfYLmKI6sUcpmu9I6mlfGToV2wdupoWmdISmkhE3cznTMOmQeHZUdQJFXGx41m9o2qePA0Wa95LHijWn/NkOPVA86Ch0tyiWP/RVtEs95MgFwupMH8UJHoRkasKoj1ZuzzpkJjwNXUjbRhXj2PhYcySLUJURCMqmW6kmczFHx5MmpisxNgMzY1wdU0jrqJA6vFxJaTIuO6EbHivvcbZI7Vlw6lotNdsk1P8i2DrR3w2x00SRlXwYdKx4qcyEPkLnHfK058zM6KhkKPXpi1OdtJqYNVjrHJ8ijHiFGS0R5x8QYY5l5NBPK7Nrg2xwzY884KlbmECkKx143EkVfibHr77G+kEwT1xdqA/siR6qPRg6P3kCrJ3Hqt/KmnIfgpAm88I0gV/rdMVTmpn6k2tSxBGjJjDgPCC3hL8fkt/JqtCR1HJjMl0FLKg6Y4ZNoE6IlPdYGauP1Plzz0amWYs0XTVL2zveFZc7YxHpf3pELbyrPyBw+54xtzc/XWKOyAwjBZoscYADjLXKJCRjvcAC/lXx4JXjYVyEz8sRlNTL34ZPJIYfPJ9HX1PaVe871Z7gxBbfyur40bzYu1J9/hnO58U2epi+SQtL3w9CLv8Ki026zpkeq9TtfyK2quli0+s4g5YR4eL/jk3tfEruVN8Vn2snDbhveMM+HjF2hJfREj/rOYZLaMLUlLB2j2C7aBKgL42NqS6ITIim70GONRWu14MNv/U7ZVpI+S/eVsq3e3g2UOfEMu3e21dPqTMf098bUzw6gSMFDrz8DByZgvPIW3FLGlUGPGWh2iMyBM9MrhTQwrbO6+UrI7PikU0iJ1E+RjpnW+aA2rMgzOhmk0x+svkKjCvRGWZBqiYpgj5K53wBIUVSUWzuxkikStgXJponhQ2/lVb8zHUJtUumYROqHOWBRG80rTp06mTN8Eus5RFSWtImDUkhBEWyM2Cb4DBl7wkanTl0GYx8dlR1AkdIdDRZKqz/s7grMJ9EmgBWZUc/zsW2iFMmyMmfqTzLPcJDMK5oLnPJzfQXQrE7ZMFg+Suv4eRfhzsPybeY/tTNDN/0ZP1Kt4eTqyaAgHZM5Uq1lXqRjIrSkkooyqR/Spm0XySzCdUh/henrJNFmCvqKUi399D6z5osmpZ1KOSGrWc85m7iczMvbF+nfJmMTA8cyw0eZhbXQ6KgkKH7BFIfxNoo20aKsQ48Rnw3PJyVzvS9YTT9AnnDsCZizl8yJsUfpqkVf0UmCBR+e8ltWZt8G8cq0SaV+evA5muAT1bFotGSRjinSOtLxSaRR2MsN0bFizieovTEyx6kfET73qE10oofySbSZQnmkoJSdcmsjRpnzNjF3OiZjF1A6xsmcsq319bwq2xqlkPrYhcH7QcZObX20bkRl11p73yEURSHRFcVdDUbdO46uVZ4UfXGlC69VTvFxbYIoJOJTyByMPVPc2++K68TzyYwr0QZ0NUjmqPhO98WOVJtXA5BIP3rFAGrDHJXoFQOL6HOWuZW3oZdWoSPV/EK8RoSkq/RV8yy6RGhJhE6wAno9N0yHNFtmO6YpPqAN0bNZU7MvExFpll4/uTWfXxuZYv0+9jcn8zA+g2xrRuaMTUTyZF7f0sPetc75umhEVBKUygEmIMzcMbLIOw4WiueD8o0ZSHWakNnzSYwrGjsr9EN8ckehiyZlbcng+arzScmcma8BOobkhnUsFHXhzkyGT65mZv5Tn7JJHakunJCOT+1IdVR7gy+yw3z02GK0pJ6OWeY4MKotydRXxAjgatc83Ii9XQhk7opFER+p88nInGgzpNZwZbY1Ma6h6bM+NTzjSwmPU9Lzmklb4ApuMW1W9v6dKAqJLkCarqavietrOJ/MRjykL15NvzKZe8x75h0jIZS+4nc86e8t+pqWbdh7WFZ3kV2dTwbl0HebRO8nyqAlXb7e8kGXp2XeiRM6KkRfM3x0u2jN+7mPaqr6rPncZW7DbGJZLFpfz3jstq+dYMcLmaN0Va/L5YbZ1vEelR1EmdqSuOqcQ5hFXUToiedzknHV+XJ8ihxpQubwXRM9angyuV/QJMlHHJ/684mjRv58iuccOnIBnx7PWY+d3srbsx6GFcEaPok29BRScM9M+/umOWFkmiz4RieVYL2HRzlAGzZ2wydEXXgKabFh9dL7hL5m7MtAPSvtVNEkpfddkWeP9bMiO5Wp4cFIiDg+2yfzIN0YaFsXdzCNqZ/jn8J7QsKq6olpEy243Hst6qmfkM8QmYNFEPEpxoUcuczYfV+Dx16fi0z+PMOnmK/AACz7nAfpWGLsk0lZD+P5ILm9zHMZ43EhmTJtNOqyqIdJOBhlGqX7f/esscy6TeSEMH3VX1l6zQ/Q1/CekEyato/eZ9ZqyiYWTVJrPvd8pC5zYv3k1qrtK2VfhtrEITIHfNZdTDs6KgmKvNGWImgtasMuCwv5BKmEmE9/mXGh7JCx8/daRH0VMgfvJ+r4cPi2V18BNLvgk5iLCJqN5bG/Z/ikZA6MaMynLiNCs/zcAzZhimTRhrwzKOorilqjNquSGb13yTdLzetAPfN9RZtRzGeIvvKUzYJPypbV1/PwNTbEvgy1iat6zgPs+JJ2aryZdgdQdBytpSgqYt9B34sKmha/Q+Mb942+lzHimXGlZA4gVcYX8gkisI5v2VfGaEUFi6xNVHHP+s7zOXY6Fp0qifiwFJL9LOaDPsvNc+LZB+mHPnyiiHTxnYQzg3hh5GFI/wPtS0aH1rjmM+t5ZWNflU3MzBfkE38HyTjcTuX5rBlQGR2VDGWMLz/211F0RDfuq/+Cy0Q80TuDFm2OoczRkeqIT07mukEqkIcMn5XNxYpkTvEpmgyKmHOOJT9SHfFCMkbHgRd8Eps3O1Idy1OXGaElw/WjrmfD5n7gvCZsRzGuwfoa84V9DeZTlye1NkhtVMhnoJ0q56tosjIb1LIZT/3sAIpOZCx+HxihZ6KHQWjJqiLroWhSAlVgR1KjzwZHKimZBzghK4tiiybDdCyDtg2NwFYkc0oXhkb1A57ZUJ1KIQ9DEbdBelY0SaU2VofqDrAvA52QYbZ1oC4MkrloUjgUK5N56HxldGzrszH1swMoowgZhco5PIm87sC+SpnRzZH296FOWib/6flER6qjvjIyD9kIo1shIz7D5ovfrNmPT0YefpfG4vfEhratMg/cVNgx56hNRkb02cr0bKjeZ+Z1QJAzWF/d11J8VuQ4pezLytZqRmZ+K2/IZ0CKDa9n+/tw2zr/rBkRleOfUpvRimD5ofUVg+DSskkJ0ydgzqHGb5DMCUh1VRDv0FRU0SYF8RZNti2FFL3PZNFmVTJnUocZxGlSzg9M2RSOSl3GTAoJ8RquH/2f0cpSnpn1PBABXN1aHfB8ho49JbP7zuD9IOOE2N9ztrVoMiyFFMyXOny3FhodlQQNjaxzRXN1BV9ZCimTHhpg/IamJAalkAZGIYOgdLTJDYjGhxrIlaVjVqZj8XcQ75SuZmDpxPOZAGdmKFoydAPNpX4S63DQ2iiaDEI2t7UgOuMUDbGtAzf9QWnjwamfAToGxx5/R2R1dmpxi/SIqBz/hCYwAx/vctqK4LfdxcvYyinx30PGZnfxgrRhfFJ9bfi+6s8nN3bExz3DhMyZucBt/NjLZ1g+52Eyp+Y9oWN+LpDMxfMBc3EsdczzGTynCSh9MpmkUJYMr5Te+zYJvYfjH6RnQF/JrcDme4UOZfQsoUNIzzJrI2VbVzVfA+ZiO+34AB3bVtu61ebomiGV0VFJEF6UdYVKGYnCIJX9e8OOjU3do8/J7Poa6KQVfDJjT4wL8RlikKDM/jnDZ1iProp5T+lP2deQceFNuP6cV6Vjg2TO6BiB0nU7JLPntTEtj1QPlTuz5nEdTWKNDdKzoknOQR/gGAxdzznHaYB9GTquATJjO9V/PQ+3rauZiz46dnQspj3+KaNQuSr4knfBZzAMnDGQA2Qe6DxkZB5kSAamNlb1nAfxgc5DXeYclL4imQdEYENlzsy7R0KQzP67iI/vD8nsv4tSSFDuVCoh7ovxGaZnK3JCYF/9HZ7ha6zuNOfSmXXbsW12Yc22dXW2rEVURkfluKfBKZK1pmPqqYRUSmIgfPtlm44ZBJMn0jEDofS1pmOgbtT78k5IxsFAfETss6Z8Em303LO+9DxOJiyA6Z+OScH726lnx3s6JmGDUujWdqZjCr1PzPtQ2zrIlg3Vsfln7Xuy1kWjo5IgmG5YEXxbbNYJWDoHGRZNknwGpGMyi3soxDvkOQ+FSwuZiyYDI1TEJ2Fotykdk+GzsnTMEihHzgmpOzy7E230fNAU0kZGZq9niM82pWMyenYs0zFDEZ4h6ZhMILQy21rva+hcbJstSzif0X5wZERUjn9aHWJQ8s4pS32DSC24lOPU3yBlINWVbcTA8K+qJmTbam8GG5sBczF4c1ihE5JyHvo5Ibz+RPFJtCFd9ZaZj932NTSFtG16lnEMtlPPUs7DkPWc2YiLJqm5KJyQwXUsA+zLqsY+MEhuZR6LaY9TmogyXGBXy8Bm5cmXko9XMq+o6LPMJUneCUBtkDyZ6v6CD0wz1WX2n/nFjvrHz9B+5hdplk8mzVTOV6KvFJ8VzUVCx1Ab74Sg+fK8kI7N5Zyq/9edENaX/i56Pr4N5bPRkw+R2Y69LjN6zl6e6SRXF4H0rDw9NFBfU6mW/uswx6e+gSI9y6QYM2tsyNjRM8yssUEyJ5yQlE1Mycx1bLyZdgdQJnqAiyChmEM2o6ELzn9v6ILzhiNl/DLGJmO0BhrRwinK5H4Hbg4ZB2yQ8zlQx7wTwjbZjcQmq2XYbsfAODyJvtBcFH1RPt13c05R3QnhzoweF3vOKlCa4pNKOWcmUceSCnL6rw3oYCT0PmUXUjaxf71HyrbC+pOMTfRjR7Z1RYFZsR8gmTMO2FbqZ3RUjn/KoSUZxyDjYGQWysC+EpH+ICdk4CIoDclAmVPOTMJIFDIPM7RDNoehjlzhhCQ2ULZZ6+/STdbwSSAqFC1JOAaJAlcjc8IJWcaZSfXV0wlJOTPJ9FkmzZTbQLfPCfHjTaElq5J5ZbY1sR9A27qauRhkfzOBWVAAPKZ+dgBlikXxws1EBvVFUEbfK0JvBiIhgxZBQuahyMMgmVOO08BILmFoM9FwkY5hm2zGCenrGGQcDLqBrkjmVaEcxpGr95WSmbQxTsgSzszKUKmEM5O6gG6IEzI01ZKwrSlkM4UCDQjwEgHM4MAs4RAWY19RYBbxGYtpdwCljgwPrBsZkiIZihgMynsHcGCvvlKOU0bm1TgGOQRjmEOYkbmsCclsWJnoG/PZMJvsEihH3zqWJRyDjZ59ZZAH9pwzMqdSSIm5yM1poq++jhxN+Vn0BjozA/Qet6k7BjkblAk86ms+U6eRWfPD6hEzfBLB7cAgOTMX7fc2x+PJxz+l7h4YWAQ7JIU0vC6ifxQydDGlUKAEMjMk2htakLyqorkSCWEbjdqw2CbbO/oeHsWn7hJJRPopdKKvY0ARjFWlkDLIzKpQqfq4Mumq3Zm+Es9nd8opss8Qppkc/8wppKF1I0NQZmgTMwHMkBR+ZuxQ5gzCvk3OTCDzeDPtDqCMYg49aTKswHX7nJAM8rC6tFdi4a4o7ZVJ2WTGPplMcvB+YuOzTgiJdvvWM2TqIjLoRMoJGY4GbPR2QjLPuS4PRx4S40qhUom+EgXJuflKODM9nRB2kmsjoateZlwzU3dmMhtoas2ngqVMyiZhfzPoRFETMsyOZ0705A5XZGxim/oZEZXjnvbsWpETklqUdSg0l/rJKO8wx2nQwl3RCYBVpZDY6ZjeNQZ0g+i7ySY20MwGkdpkl3AMUumqRBSf2KxTMpuameHPsDdSlHFCEuhNynFi855BpRLPsLfjlDqWnnOYU/fMDEVRU85MwiauKNWyqmL9Y7lntM9wvEJ/B9Cq7jYZCk9mqrNz+c+6R586hZTJxw5AVHInAMo2fhhos87WhGTqIjJpi43EBrFhNtn6BrGczInNOoFy9K7lWCKF1BuZWQIxWF3tTWa++qFSVOYEmrSRcZgzzmdPZ28ZJG2Xc5hrzsxkgp0Zb4OGHu8fUscy9Ih37n6lujxFX0NPHm71P6Z+dgDlUj/DFCrjhOTqT4bwqUcPqZqQFaW9ljkdk6oxSCAPuxNRYe/TMUtsaimZM5F+auPLRNb9ng+vi8hs1nVkJpViS6E3dWQmVcOTmfcUKpVxwHrKnNHVpWp4Es5nRsdSzkxdn/XnzJnJ1cMk7PgAJCR3mmmgzBnnqgd6Pr7rZwdQKt+YcEKGQ4YrcmYGpIeGHtfLpL3mxyVjPoUTstQGkYHuE4jBygod621SMhsnJCHzMvB+b5mXQFQS8566+yVVe9MXlRou88p0rCeSlnNmhjvMqbTXypyZnjqWGDt1ZjI1eUPqCFPpmIHOzJAC4CBwHVM/O4D2DE3ZDHBCUkWeGSckVeU9sK9kAXDNCZnLkDCA69ogEqcklqkNyNRX5FIbCZkTjkGmr1RNSCrtlegrUeuSO8a7eh1bVQ1PbkPHbVLFtCtymDcSz6e3E7JUQXJmva8GSdP8p5Ml7tXK1IQkAs7M9RCZguSy9gbbcZGxmHZH0G5UTJvY9Iedskko1MCakFVdue1FXO4Iak/EYIkNom9tAL13IgWD1xGevk7Iquor+OZYdwz63m2y3feorKogOecw1x0wX19R5ZPR1ZTzmZn3el88jZKY9xQqtSInJMMns5ZXpGOaD3NmBtWxDETPh9zrEqE347t+dgANvpcj4cyU6Zhh3nHm+G32dIxGQnI1IQknJFXPMBydyGwQvSHupeor+kXW/KRJX8QgIfPKUCkmc0/HIDNfiZMmS137n3rOCR3LODN965eWGldPmZdwmFProvdzTiAzSzhFvdPKy9TwqM+pM5NwQlLoeSJI7lN7M95MuwMok5NMFaYmnJlcCinhhCRqQpa6ZCxzmiBTz5Aqzqwbpd4FeKvKfS8D768ocuwvc32DWNk9KjQlkdlo+upY/fnkangSqMKqHOYlCpIzd7/kCnf7oTfbvi5StTfboWOZsW+vw6x1lb6/KePMZBD/HrU3YzHtDiCc+qk7Bl6hYK3LANQF8SmckF2riayXqsHoCYNnIr5VFeBlYOdl7uXQY9lD5mJV9Qz9N4j6RpyaL6ZjmXlf0Wa9qvtq9NjR+vLfXVWR8FL3qGR0rKfjlEl7repET4ZPBrVbzkb1m4tVOcxcx+rBi5aBOzN1RCVXADznMxbT7gDKnHzJFcEOg+imRWFqwpgskfffyBiT3nURdT60LmJFyEPm5tXMDZwZZyY39n6OXCY/nuOzxHwlNrXcc16RzKn0UL2v3nebpNZFXcdyd9EkdHVl64I951XJ3BctGa5jved9KR2rP5/+dzStZt53JZGZ6A6Z8R6V45Q01JU72sW90UWbRDomBV9nakKWqWdIRfGJqKdn7ntVSEhK5mVyzYlx9U3HLJdKqKMluZqQflD5yu6rWSay7qtjKzqiu1Q9Q+/6pSV0te+6WCbt1VfHlkHSes7FymrSVoTeLJPm7l2QnFnLxJlpZT46nvo5PumwmhgE06VO4jgnhMGzfeHrZSBlA5mClJZIbiH0hXAzUOeqoHKekugXEe9JbHwZmTOphKXSXr3TMcvI3M+wL6WrGdRlG3SMzvuqdKxvOialq6tx9lIyb7eO9QzKeNqrr67WbS+T2cwXs6tGV5ewvSl0KzHvPXR1LKY9Tknn5Fg6RtMJuzcgH614J+zCbfaqhcb46M9zbfDUnqD7IvKsrK/diXHt2oa+2Lh69rX3WM7FUmNXbYjR3tt7LhJ9LTPvvcfF+HTfpfOVGVdfPUytneHPZ2/P57N323VMr6/VrHcqc1/92ea5yNiEvbv66eq229Xe44r15/DmTGZrTP+MjgohfcENuq3Q016yeDWcxpRBOz2Mj3aWWBtjtNli2VNXzhO1AtO+dBvcV4bPiXtW1FdiXKsa+4nmOWf4JGRe1XMmRqn/XGT4rErHhhvSlY0rMRdm3lPOwxJz0Vt/1q9jJ2yLjjE+9bnob8dWpGMJeRgKtLLno/siaIke+wZI+3h5Dh7dhG2OBY2OCiHtqKDcnScGnWkfhymVbsO834lMqm003Me8ca20y3j+JykFZn2daNrUF91Sfe3e1bUh4zopEYWtSuaM4Top09ee+pwamYmOZfrKOAaZuTgpMRcnZvikns+ueptElGrni+lhYlwJdCujY5nnnIm+M88wt74yOpaYi5XZja4vtqH3H/uqnk/GJtRtFHUwFJ8p2Zv0XDQNRkL0uBhWosdyz+HRUTnu6PDROsyV8F+Mg8EcHv15xuFhCqy5s0WnFZu10QgS27D29EwhpSLQRHSwKgOYiXqW2WT7IgapTXYJA5jarHumtHgU3w95SI0rpRtL6E9m7L11bIk57SlzTseGR/F9UbJVzUUGwVgmdbgdiBMrXtVt2Nah5ZkRB0PzYW30WFjGRu81jM90Olnwunt0VI4/OnikPinMm7Vt6n0lmhhnBt1oOG/T/Z9Vwk9SCE+9rmaaSGntMiktzCdVO9E3HbNEXjvnzNSjuf7ODDPIqq8lot0TEpvRSdvgGKT6SiEGCadoRQ7PylIAS6QJMjrfN9LPpXUSfWUc1BWlg5dx0jQfmmrR6Q9iMzUfRtbBwG30WFgYrJ8J8R2cg4Hb6D2iob11FNWftHOf2RO3i7bNUfmlX/oledKTniQnnXSSnHrqqbDNtddeK894xjPkpJNOkjPOOEN+4id+Qo4ePbpdIvWiuw7X5cg4GBlnJpNayqA3ui/Gc9rT4WFV5boNM1wTg97UnaJUfU6qmC1htJeJ+BLpmL5R2FIGuWddBJU5lWpZURTfE1XYbkQlNfa+85VCVIZv1n1rt5ZCHvqioytKB2ccDBaUnUj4azLOA9mrNZ+Mg8EaaQeDpWO0zcw4GCknJFEDGzVpx3/PGh2VXfUmw+jw4cPyPd/zPXLBBRfIG9/4xuLvm5ub8oxnPEPOOuss+cAHPiA33HCDPOc5z5Hdu3fLK17xiu0SK03rzMcdT5RxopjDo4mlqzQxw2XbkLSXEoFFQBqSpactlMFhhk4bc9ZGf87k0Z9zPkqeJfik6j129+OjHTbbpjMr9Bkmnk/fGhX6DDN1CImxm+fM5mJFfHJj130l6oVSc5pxrhiffkgjdTBUm0yKhFHGUWEOsKbMYYqMndyp1DrxX5Y1Kj//8z8vL37xi+VRj3oU/Ptf/dVfySc/+Un5/d//ffm6r/s6edrTnia/8Au/IK95zWvk8OHD2yVWmjLeY+a2vkOJi3IOJ6qpDx9N8En1tZ42bCHrsTODoPkwA6jbMAOl25y8F/voh9Wx9JNPwG30vJ9y4m7YRg93H2mjDfUpJ+K+9qjxMj56A1qmzYmr4qMcmH0nsTarkWd1Mndt2Fzovti89x3XKSesaOzkOZ+g5oLKrPjcm6yLE3o6MxkEjNXjaUcodQcIubdkmriTxNQHJpwWdv+JkY3IY9okArdVtckEiVGbds7u/nJM/dTo0ksvlUc96lFy5plnLj576lOfKgcOHJBPfOIT9HuHDh2SAwcOmH/bQRnv8bz7nlRt84DT6m3OTbQ559QTq23OPOWEapszTtlbbXPfe9fb3OekPdU2zMBqOpkYak33IsZTk4nCiFOkNyyGAmkDy4yAKSQmTpF2Qu5FDLu+lpw9B40Cseep5Vlmsz5pb72Ndt7Yxqc3X8ZHf87anJJok+Fz6kn9+DDnQTsDzNE9VfE5icy77ovpjx4700PNh6WY9VhYuuHeak43SfB1rz31NhrtZO+G0WPZDAo4a230Gs9cmsrGbhvVm6zqKpFV4S+pOsnELh+hRq2e3XLHobRcq6a1OSr79+83ToqILH7fv38//d4rX/lK2bdv3+Lfueeeuy3yZRCVf/NNDxIRkZ9+2sNom+f/s/NFROTHv+2htM0PP/mBIiLyH/75Q2ibf/2N8zYv/OYH0zY/9KTztuQ6n7Z5zgXzNj+8xQ/RD17wABERed4WP0TP/qf3n/984v1pm+97wnxuvu+f8Dl65tbf/tXjvpq2+VePn//tO7/uHNrm/3nsvM0zHn02bfMvHzP//lMfeSZt84xHny2Ticg/f9gZtM23f+1ZMpmIfNNDT6dtvvURZ8p0IvIND74vdZye8tDTZWM6kSc88DRqKJ78kPvJ7o2JPP4B96Eb1j994GmyZ2Mqj/nqfTTaffwD7iN7dk3lEWefQqPmr/vqU+WE3VP5mjNPNpu7pkees09O2rMhDzr9XnI6cWi/5qyT5d57d8l59z1JzjgZO88PPfPecsoJu+Tc006Us/fhNg8+495y6km75atOPVG++j7YmT/vfifJaffaI2fvO4E6/Pc/7SS53733ypmn7JUH3u9esM1XnXqinHnKXrnfvffKg8+4N2xz9iknyDn7TpD73muPPPSsk2Gb00/eK+eedqLc56Td8rXn7INtTrvXHnng/e4l+07cLY8591TYZt+Ju+UhZ9xbTt67Sx7/gPvANvfau0sevjWfF5x/X9jmhN0b8qivms/ZPyP6untjKo+9/3zu//nDsd5vTCfyhPNOk727pvK0r8VrbDKZyAXn31f2bEzlOx7D12Gr0//qcV9F23zLw86QXdOJfN8/4fblWx9xpmxMJ/ID/5S3efqjzpLpROSHvoHbu3/5mHNkMunsMKL/57FzWf/tUx5E23zv189t0L//Fm7Hn/WEuawvupDvB8/Zsr8/8dSvoW3+f1vjeUmw9/zI1t7zM09/BG3z77bG89Lv4G3OP32+Zq665S7aZtup6UE/9VM/1cjc76T/rrjiCvOd3/md32n27dtX8Hr+85/ffNu3fZv57K677mpEpLnkkkuoDAcPHmxuv/32xb/rrruuEZHm9ttv7zOUKl3winc1D/ipP28e8FN/TtvMZrPmMzfe0RzdnFXbHDm6Gbb57E25NoeDNk3TNFcm2xw6Ere56uY7q22uvvnO5uCRo9U29xyO21xzS73N5265K9Xm7kNxm2tvzbW569CRaps7D8ZtrvviXc0dlTaf/9Ld1TZf+NLdzYF7Dlfb3F5pc/1tdze33R23ueG2e5rb7orb7L+93ubG2+9pvnTXobjNgXuaL94Zt7npwMHm1kqbm+842Nxyx8GwzS13HGxurrS59c5DzU0H6m1uPHBP2OZLdx1qbrw9bnPbXYeb/bU2dx9ubrgtbnP7PYeb62+7O2xz4J7DzRe+FLe54+CR5vOVNncePNJc98W7wjZ3HTrSXHtr3ObuQ0erbe45fLT53C31Ntfccme1zdU3x20OHqm3OXRks7kq0ebKm+4I2xw+Wm9z5Ohm89lEm8/cuHybo5vz/Wk243vYp/cfaD501a3V9TyEbr/99tT+PWmaDCY2p5tvvlluvfXWsM35558ve/Z0aYGLL75YXvSiF8ltt91m2r30pS+VP/uzP5PLL7988dnVV18t559/vnzsYx+Txz72sSmZDhw4IPv27ZPbb79dTjnllOxQqnTBK98tN9x+UERErnnVM1bGd6SRRhpppJFGyu/fvU79nH766XL66Rzu7kMXXHCB/NIv/ZLcdNNNcsYZc7jxne98p5xyyinyiEdwGOpYUd59G2mkkUYaaaSRtou27XjytddeK1/84hfl2muvlc3NzQVy8uAHP1jufe97y7d927fJIx7xCPnBH/xB+eVf/mXZv3+//OzP/qy84AUvkL1768Wc202Z8+kjjTTSSCMNp83NTTly5Mi6xRhpm2j37t2ysVE/Jl6jbXNUXvrSl8rv/u7vLn5vUzl//dd/LU95ylNkY2ND/vzP/1z+7b/9t3LBBRfIve51L3nuc58rL3/5y7dLpF40IiojjTTSSNtDTdPI/v37i5KAkb786NRTT5Wzzjprqbtmts1Rufjii+Xiiy8O2zzgAQ+QSy65ZLtEWIpGP2WkkUYaaXuodVLOOOMMOemkk76sL0z7SqWmaeTuu++Wm266SUREzj6bnwSr0bY5KjudRkRlpJFGGmn1tLm5uXBS7ntffKx6pC8POvHE+f1fbS3q0DTQ+FJCSqOnMtJII420amprUk46qX7R5Ug7n9p5XqYWaXRUCK3qBsKRRhpppJFKGtM9Xxm0inkeHRVCPa6XGWmkkUYaaaSRtolGR4XQ6KaMNNJII43U0lOe8hR50YtetC289+/fL9/6rd8q97rXveTUU0/dlj5auvjii6t9PO95z5Pv+q7vWvzeNI38yI/8iJx22mkymUzMRa3HgsZiWkIjoDLSSCONNFJLb33rW2X37vk7sM477zx50YtetDLH5b/+1/8qN9xwg1x++eWybx9+R9SxpFe/+tUmq/COd7xDLr74YnnPe94j559/vtzvfveTyWQif/Inf2Icmu2i0VEhNKZ+RhpppJFGaum0007r1X5zc1Mmk4lME68vvvLKK+Xxj3+8POQh/IWGx5K8s3TllVfK2WefLU960pPWIs+Y+iE0+ikjjTTSSCO11KZ+nvKUp8jnPvc5efGLXyyTyWRRLNqmVP7sz/5MHvGIR8jevXvl2muvlcsuu0y+9Vu/Ve53v/vJvn375Ju+6ZvkYx/72ILveeedJ3/8x38sb3rTm2Qymcjznvc8EZnf7v6d3/mdcu9731tOOeUU+d7v/V658cYbU7J+/OMfl2/+5m+Wk08+WU455RR5/OMfLx/5yEdMm7/8y7+Uhz/84XLve99bvv3bv11uuOGGxd906ud5z3ue/Pt//+/l2muvlclkIuedd56cd955IiLy3d/93YvPtpNGRIXQ6KeMNNJII20/NU0j9xzZXEvfJ+7e6H0q5a1vfas85jGPkR/5kR+R5z//+eZvd999t/zn//yf5Q1veIPc9773lTPOOEOuuuoqee5znyu/8Ru/IU3TyK/+6q/K05/+dPnMZz4jJ598slx22WXynOc8R0455RR59atfLSeeeKLMZrOFk/Le975Xjh49Ki94wQvkmc98prznPe+pyvjsZz9bHvvYx8pv/dZvycbGhlx++eWLtFUr56/8yq/I7/3e78l0OpUf+IEfkB//8R+XN7/5zQWvV7/61fKgBz1IXve618lll122uAvljDPOkN/5nd+Rb//2b1/JNfkRjY4KoTH1M9JII420/XTPkU15xEv/ci19f/LlT5WT9vTbBk877TTZ2NiQk08+Wc466yzztyNHjshv/uZvymMe85jFZ9/yLd9i2rzuda+TU089Vd773vfKv/gX/0JOP/102bt3r5x44okLfu985zvl7//+7+Xqq6+Wc889V0RE3vSmN8kjH/lIueyyy+Sf/JN/Esp47bXXyk/8xE/Iwx72MBGRIqV05MgRee1rXysPetCDRETkhS98IX19zb59++Tkk0+WjY2NYrzt9fjbTWPqh9Dopow00kgjjdSH9uzZI49+9KPNZzfeeKM8//nPl4c85CGyb98+OeWUU+TOO++Ua6+9lvK54oor5Nxzz104KSIij3jEI+TUU0+VK664oirHRRddJD/8wz8sF154obzqVa+SK6+80vz9pJNOWjgpIvPr7dur7o9HGhEVQrMRURlppJFG2nY6cfeGfPLlT11b3yvld+KJRSrpuc99rtx6663y6le/Wh7wgAfI3r175YILLpDDhw+vtG9NP/dzPyff//3fL29/+9vlL/7iL+RlL3uZvOUtb5Hv/u7vFhExaSCR+aVsx3MWYXRUCB3HczbSSCON9GVDk8mkd/pl3bRnzx7Z3MzV1bz//e+X3/zN35SnP/3pIiJy3XXXyS233BJ+5+EPf7hcd911ct111y1QlU9+8pNy2223ySMe8YhUvw996EPloQ99qLz4xS+WZz3rWfI7v/M7C0dlFbR79+70M1iWxtQPoW975Dzv9uAz7r1mSUYaaaSRRjqe6LzzzpP3ve998oUvfKHqdDzkIQ+R3/u935MrrrhCPvShD8mzn/3sxcv6GF144YXyqEc9Sp797GfLxz72Mfnwhz8sz3nOc+Sbvumb5Ou//uvD795zzz3ywhe+UN7znvfI5z73OXn/+98vl112mTz84Q/vPc6IzjvvPHn3u98t+/fvly996Usr5e1pdFQIveK7v1Z+4TsfKf/j+U9ctygjjTTSSCMdR/Tyl79crrnmGnnQgx4kp59+etj2jW98o3zpS1+Sxz3ucfKDP/iD8mM/9mNyxhlnhN+ZTCbyp3/6p3Kf+9xH/tk/+2dy4YUXyvnnny9/8Ad/UJVtY2NDbr31VnnOc54jD33oQ+V7v/d75WlPe5r8/M//fK8x1uhXf/VX5Z3vfKece+658tjHPnalvD1NmuM5MZWgAwcOyL59++T222+XU045Zd3ijDTSSCONFNDBgwfl6quvlgc+8IFywgknrFuckbaZovnO7t8jojLSSCONNNJIIx23NDoqI4000kgjjbSD6JGPfKTc+973hv/QpW07nXZWqfVII4000kgjfYXTJZdcIkeOHIF/O/PMM4+xNNtPo6My0kgjjTTSSDuIHvCAB6xbhGNKY+pnpJFGGmmkkUY6bml0VEYaaaSRRjrmNJvN1i3CSMeAVjHPY+pnpJFGGmmkY0Z79uyR6XQq119/vZx++umyZ8+e3m8wHun4p6Zp5PDhw3LzzTfLdDqVPXv2DOY1OiojjTTSSCMdM5pOp/LABz5QbrjhBrn++uvXLc5I20wnnXSS3P/+95fpdHgCZ3RURhpppJFGOqa0Z88euf/97y9Hjx49Zu+LGenY08bGhuzatWtpxGx0VEYaaaSRRjrmNJlMZPfu3cWbfEcaydNYTDvSSCONNNJIIx23NDoqI4000kgjjTTScUujozLSSCONNNJIIx23tONrVNqXPx84cGDNkow00kgjjTTSSFlq9+12H2e04x2VO+64Q0REzj333DVLMtJII4000kgj9aU77rhD9u3bR/8+aWquzHFOs9lMrr/+ejn55JNXfmnQgQMH5Nxzz5XrrrtOTjnllJXyHqmj8TkfGxqf87Gh8TkfGxqf87Gh7XzOTdPIHXfcIeecc054z8qOR1Sm06l89Vd/9bb2ccopp4wL4RjQ+JyPDY3P+djQ+JyPDY3P+djQdj3nCElpaSymHWmkkUYaaaSRjlsaHZWRRhpppJFGGum4pdFRCWjv3r3yspe9TPbu3btuUb6saXzOx4bG53xsaHzOx4bG53xs6Hh4zju+mHakkUYaaaSRRvrypRFRGWmkkUYaaaSRjlsaHZWRRhpppJFGGum4pdFRGWmkkUYaaaSRjlsaHZWRRhpppJFGGum4pa9oR+U1r3mNnHfeeXLCCSfIE5/4RPnwhz8ctv+jP/ojedjDHiYnnHCCPOpRj5JLLrnkGEm686nPs379618vT37yk+U+97mP3Oc+95ELL7ywOjcjzamvTrf0lre8RSaTiXzXd33X9gr4ZUJ9n/Ntt90mL3jBC+Tss8+WvXv3ykMf+tDRfiSo73P+9V//dfmar/kaOfHEE+Xcc8+VF7/4xXLw4MFjJO3OpPe9733yHd/xHXLOOefIZDKRt73tbdXvvOc975HHmwETygAABvpJREFUPe5xsnfvXnnwgx8sF1988fYK2XyF0lve8pZmz549zW//9m83n/jEJ5rnP//5zamnntrceOONsP373//+ZmNjo/nlX/7l5pOf/GTzsz/7s83u3bubv//7vz/Gku886vusv//7v795zWte0/zd3/1dc8UVVzTPe97zmn379jWf//znj7HkO4v6PueWrr766uarvuqrmic/+cnNd37ndx4bYXcw9X3Ohw4dar7+67++efrTn9787d/+bXP11Vc373nPe5rLL7/8GEu+s6jvc37zm9/c7N27t3nzm9/cXH311c1f/uVfNmeffXbz4he/+BhLvrPokksuaX7mZ36meetb39qISPMnf/InYfurrrqqOemkk5qLLrqo+eQnP9n8xm/8RrOxsdG84x3v2DYZv2IdlSc84QnNC17wgsXvm5ubzTnnnNO88pWvhO2/93u/t3nGM55hPnviE5/Y/Jt/82+2Vc4vB+r7rD0dPXq0Ofnkk5vf/d3f3S4RvyxoyHM+evRo86QnPal5wxve0Dz3uc8dHZUE9X3Ov/Vbv9Wcf/75zeHDh4+ViF8W1Pc5v+AFL2i+5Vu+xXx20UUXNd/wDd+wrXJ+OVHGUfnJn/zJ5pGPfKT57JnPfGbz1Kc+ddvk+opM/Rw+fFg++tGPyoUXXrj4bDqdyoUXXiiXXnop/M6ll15q2ouIPPWpT6XtR5rTkGft6e6775YjR47Iaaedtl1i7nga+pxf/vKXyxlnnCH/+l//62Mh5o6nIc/5z/7sz+SCCy6QF7zgBXLmmWfK137t18orXvEK2dzcPFZi7zga8pyf9KQnyUc/+tFFeuiqq66SSy65RJ7+9KcfE5m/Umgde+GOfynhELrllltkc3NTzjzzTPP5mWeeKZ/61Kfgd/bv3w/b79+/f9vk/HKgIc/a00/91E/JOeecUyyOkToa8pz/9m//Vt74xjfK5Zdffgwk/PKgIc/5qquukv/zf/6PPPvZz5ZLLrlEPvvZz8q/+3f/To4cOSIve9nLjoXYO46GPOfv//7vl1tuuUW+8Ru/UZqmkaNHj8qP/uiPyn/8j//xWIj8FUNsLzxw4IDcc889cuKJJ668z69IRGWknUOvetWr5C1veYv8yZ/8iZxwwgnrFufLhu644w75wR/8QXn9618v97vf/dYtzpc1zWYzOeOMM+R1r3udPP7xj5dnPvOZ8jM/8zPy2te+dt2ifVnRe97zHnnFK14hv/mbvykf+9jH5K1vfau8/e1vl1/4hV9Yt2gjLUlfkYjK/e53P9nY2JAbb7zRfH7jjTfKWWedBb9z1lln9Wo/0pyGPOuWfuVXfkVe9apXybve9S559KMfvZ1i7njq+5yvvPJKueaaa+Q7vuM7Fp/NZjMR+f/au2OX1qEwCuDnab11qTgJHarQgCgiCIpSHIr/gKNb6CIdxFUoiERQQURcxFk3RRwVRClOilsKgqUigi52cyg6qHje8DA8nwqm2Jrwzg/ukt7Al4/QnF5yKRCJRFAqlWBZVm2LDqFq7ud4PI6mpiY0NjZ6x7q7u1Eul/H4+AhjTE1rDqNq+jwzMwPbtjE+Pg4A6O3txf39PbLZLKanp9HQoN/l3+GzZ2FLS0tNVlOA/3RFxRiD/v5+5PN579jLywvy+TxSqdSH56RSqTfzAeDw8PDT+fJHNb0GgKWlJczNzWF/fx8DAwP1KDXU/Pa5q6sLZ2dnKBQK3hgdHcXIyAgKhQISiUQ9yw+Nau7n4eFhXF5eekEQAC4uLhCPxxVSPlFNnx8eHt6FkddwSP2l3bf5kWdhzV7TDbitrS1Go1FubGzw/Pyc2WyWra2tLJfLJEnbtpnL5bz5x8fHjEQiXF5eZrFYpOM42p78RX57vbi4SGMMd3Z2eHt7641KpfJTlxAKfvv8L+36+Rq/fb65uWEsFuPk5CRLpRJ3d3fZ1tbG+fn5n7qEUPDbZ8dxGIvFuLm5yaurKx4cHNCyLI6Njf3UJYRCpVKh67p0XZcAuLKyQtd1eX19TZLM5XK0bdub/7o9eWpqisVikWtra9qeXEurq6tsb2+nMYaDg4M8PT31Pkun08xkMm/mb29vs7Ozk8YY9vT0cG9vr84Vh5efXnd0dBDAu+E4Tv0LDxm/9/TfFFS+zm+fT05OODQ0xGg0ymQyyYWFBT4/P9e56vDx0+enpyfOzs7Ssiw2NzczkUhwYmKCd3d39S88RI6Ojj78vn3tbSaTYTqdfndOX18fjTFMJpNcX1+vaY2/SK2JiYiISDD9l++oiIiISDgoqIiIiEhgKaiIiIhIYCmoiIiISGApqIiIiEhgKaiIiIhIYCmoiIiISGApqIiIiEhgKaiIiIhIYCmoiIiISGApqIiIiEhgKaiIiIhIYP0G62Y3hHnmxMUAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure()\n", "plt.plot(\n", @@ -749,9 +919,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "logs/DP_Trafo_Component/DP_Trafo_Component.csv\n", + "column number: 3\n", + "results length: 20001\n", + "real column names: []\n", + "complex column names: ['itrafo', 'v1', 'v2']\n" + ] + } + ], "source": [ "work_dir = \"logs/DP_Trafo_Component/\"\n", "log_name = \"DP_Trafo_Component\"\n", @@ -762,9 +944,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure()\n", "plt.plot(\n", @@ -778,9 +971,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure()\n", "plt.plot(\n", @@ -801,9 +1005,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGdCAYAAADuR1K7AAAAP3RFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMS5wb3N0MSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8kixA/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAtkUlEQVR4nO3de1yUdd7/8feAzADKIVROhZKuJh4SQ0VsW03ppuzEaqspKbamu/eqlbSVlonaunZy01LztnYzS1fXMrc1b1qjLFfZNNQepchdimIpqKVgkByv3x/9nG0SEIgB5+vr+XjMo+Z7fb/X9bm+jc3b6zQ2y7IsAQAAGMKrpQsAAABoSoQbAABgFMINAAAwCuEGAAAYhXADAACMQrgBAABGIdwAAACjEG4AAIBRWrV0AS2hurpaR48eVUBAgGw2W0uXAwAA6sGyLJ05c0aRkZHy8qr9+MwlGW6OHj2qqKioli4DAAA0wpEjR3TFFVfUuvySDDcBAQGSvp+cwMDAFq4GAADUR3FxsaKiopzf47W5JMPNuVNRgYGBhBsAADzMhS4p4YJiAABgFMINAAAwCuEGAAAY5ZK85gYA4MqyLFVWVqqqqqqlS8ElzNvbW61atfrJj2kh3ADAJa68vFzHjh1TaWlpS5cCyN/fXxEREbLb7Y1eB+EGAC5h1dXVysvLk7e3tyIjI2W323m4KVqEZVkqLy/XiRMnlJeXpy5dutT5oL66EG4A4BJWXl6u6upqRUVFyd/fv6XLwSXOz89PPj4+Onz4sMrLy+Xr69uo9XBBMQCg0X9DBppaU3wW+TQDAACjEG4AAIBRCDcAADTA7NmzFRsbW2efwYMH6/7773e+Ly0t1YgRIxQYGCibzabTp0+7tcZLHeEGAGCcY8eOacyYMeratau8vLxcgkZzWL9+vR5//HHn+1deeUVbt27V9u3bdezYMZ06dUo2m0179uxp1rouFYQbAIBxysrK1L59e82cOVO9e/du9u2HhIS4/HL1gQMHFBMTo549eyo8PLzZbrevqKg4r628vLxR62rsuJZAuAEAuLAsS6Xllc3+siyr3jUuX75ckZGRqq6udmm//fbb9etf/1rR0dFatGiRxo0bp6CgoAbPwZYtW9S/f3+1bt1awcHBuvbaa3X48GGXPq+++qqio6MVFBSkO++8U2fOnHEu++FpqcGDB2vBggX68MMPZbPZNHjwYF155ZWSpD59+jjb6uOll15STEyMfH191a1bNy1dutS57NChQ7LZbFq7dq0GDRokX19frVq1SuPHj1dycrLmzZunyMhIXXXVVZKkTz/9VEOGDJGfn5/atm2rSZMm6dtvv3Wur7ZxnoDn3AAAXHxXUaXus95p9u3um5skf3v9vpZ+9atfaerUqXr//fc1dOhQSdI333yjjIwMbdq06SfVUVlZqeTkZE2cOFF//etfVV5erh07drgcbTlw4IA2bNigjRs36tSpUxo5cqSeeOIJzZs377z1rV+/XtOnT9dnn32m9evXy26368CBA+rfv7/effdd9ejRo15P4121apVmzZqlxYsXq0+fPtq9e7cmTpyo1q1bKzU11dlv+vTpWrBggfr06SNfX19t2bJFmZmZCgwM1ObNmyVJJSUlSkpKUkJCgnbu3Knjx4/rnnvu0ZQpU7RixQrnun48zlMQbgAAHueyyy7TTTfdpNWrVzvDzeuvv6527drp+uuv/0nrLi4uVlFRkW655RZ17txZkhQTE+PSp7q6WitWrHCeeho7dqwyMzNrDDchISHy9/eX3W5XeHi4cxuS1LZtW2fbhaSnp2vBggUaPny4JOnKK6/Uvn379D//8z8u4eb+++939jmndevWeumll5wh6sUXX9TZs2e1cuVKtW7dWpK0ePFi3XrrrXryyScVFhZW4zhPQbgBALjw8/HWvrlJLbLdhkhJSdHEiRO1dOlSORwOrVq1SnfeeedPfghcSEiIxo8fr6SkJN1www1KTEzUyJEjFRER4ewTHR3tck1NRESEjh8//pO2W5eSkhIdOHBAEyZM0MSJE53tlZWV551269u373nje/Xq5RJQcnJy1Lt3b2ewkaRrr71W1dXVys3NdYabH4/zFIQbAIALm81W79NDLenWW2+VZVl6++231a9fP23dulXPPvtsk6z75Zdf1r333quMjAytXbtWM2fO1ObNmzVgwABJko+Pj0t/m8123vU/TenctTAvvvii4uPjXZZ5e7uGwh8Glrra6qOx41raxf/pBQCgBr6+vho+fLhWrVqlL774QldddZWuueaaJlt/nz591KdPH82YMUMJCQlavXq1M9z8VOeOhlRVVdWrf1hYmCIjI3Xw4EGlpKT85O3HxMRoxYoVKikpcQaYbdu2ycvLy6MuHK4N4QYA4LFSUlJ0yy23aO/evbrrrrtclp17hsy3336rEydOaM+ePbLb7erevXud68zLy9Py5ct12223KTIyUrm5ufr88881bty4Jqs7NDRUfn5+ysjI0BVXXCFfX98L3tU1Z84c3XvvvQoKCtKNN96osrIyffzxxzp16pTS0tIatP2UlBSlp6crNTVVs2fP1okTJzR16lSNHTvWeUrKkxFuAAAea8iQIQoJCVFubq7GjBnjsqxPnz7Of8/Oztbq1avVsWNHHTp0qM51+vv7a//+/XrllVf09ddfKyIiQpMnT9ZvfvObJqu7VatWeu655zR37lzNmjVL1113nbZs2VLnmHvuuUf+/v56+umn9eCDD6p169bq1atXox5Q6O/vr3feeUf33Xef+vXrJ39/f40YMUJ/+tOfGrdDFxmb1ZAHCxiiuLhYQUFBKioqUmBgYEuXAwAt5uzZs8rLy9OVV14pX1/fli4HqPMzWd/vbx7iBwAAjEK4AQBcctq0aVPra+vWrdTk4bjmBgBwyanrBysvv/zy5ivkBy7GmjwV4QYAcMn52c9+1tIlnOdirMlTcVoKAAAYhXADAACMQrgBAABGIdwAAACjEG4AAIBRCDcAAI80ePDgRv30QH0UFBTohhtuUOvWrRUcHOyWbZyzYsWKC25j/PjxSk5Odr63LEuTJk1SSEiIbDZbnbeRX4q4FRwA4JHWr18vHx8fSVJ0dLTuv//+Jgs7zz77rI4dO6Y9e/Zc8Actm8OiRYv0w19LysjI0IoVK7RlyxZ16tRJ7dq1k81m05tvvukSgi5VhBsAgEcKCQlpUP+qqirZbDZ5eV34pMWBAwcUFxenLl26NLa8JvXjgHXgwAFFRERo4MCBzVpHRUWFM1CeU15eLrvd3uB1NXZcfXBaCgDgyrKk8pLmfzXwd5zPnZYaPHiwDh8+rGnTpslms8lms0n6z+met956S927d5fD4VB+fr527typG264Qe3atVNQUJAGDRqkXbt2OdcbHR2tN954QytXrpTNZtP48eMlSfn5+br99tvVpk0bBQYGauTIkSosLKxXrZ988omuv/56BQQEKDAwUHFxcfr4449d+rzzzjuKiYlRmzZtdOONN+rYsWPOZT88LTV+/HhNnTpV+fn5stlsio6OVnR0tCTpl7/8pbOtPv7+97/rmmuuka+vrzp16qQ5c+aosrLSudxms+mFF17QbbfdptatW2vevHmaPXu2YmNj9dJLL7n8uOWF5qe2ce7AkRsAgKuKUumPkc2/3UeOSvbWDR62fv169e7dW5MmTdLEiRNdlpWWlurJJ5/USy+9pLZt2yo0NFQHDx5Uamqqnn/+eVmWpQULFmjYsGH6/PPPFRAQoJ07d2rcuHEKDAzUokWL5Ofnp+rqaucX9wcffKDKykpNnjxZo0aN0pYtWy5YY0pKivr06aMXXnhB3t7e2rNnj8sRkNLSUj3zzDN69dVX5eXlpbvuuku///3vtWrVqvPWtWjRInXu3FnLly/Xzp075e3tLUkKDQ3Vyy+/rBtvvNHZVpetW7dq3Lhxeu6553TdddfpwIEDmjRpkiQpPT3d2W/27Nl64okntHDhQrVq1Up/+ctf9MUXX+iNN97Q+vXr5e3tXe/5+fE4dyHcAAA8WkhIiLy9vRUQEKDw8HCXZRUVFVq6dKl69+7tbBsyZIhLn+XLlys4OFgffPCBbrnlFrVv314Oh0N+fn7O9W3evFmffvqp8vLyFBUVJUlauXKlevTooZ07d6pfv3511pifn68HH3xQ3bp1k6TzTndVVFRo2bJl6ty5syRpypQpmjt3bo3rCgoKUkBAgLy9vc/b3+Dg4PPaajNnzhxNnz5dqampkqROnTrp8ccf10MPPeQSbsaMGaO7777bZWx5eblWrlyp9u3bS6r//Px4nLsQbgAArnz8vz+K0hLbbWJ2u11XX321S1thYaFmzpypLVu26Pjx46qqqlJpaany8/NrXU9OTo6ioqKcX9yS1L17dwUHBysnJ+eC4SYtLU333HOPXn31VSUmJupXv/qVM8hIkr+/v8v7iIgIHT9+vKG72yCffPKJtm3bpnnz5jnbqqqqdPbsWZWWlsrf//v/Hn379j1vbMeOHV0CSn3n58fj3IVwAwBwZbM16vTQxcjPz895Dc45qamp+vrrr7Vo0SJ17NhRDodDCQkJKi8vd1sds2fP1pgxY/T222/rf//3f5Wenq41a9bol7/8pSSdd5GuzWZzuTvKHb799lvNmTNHw4cPP2/ZD6+Had36/M9CTW310dhxDUW4AQB4PLvdrqqqqnr13bZtm5YuXaphw4ZJko4cOaKTJ0/WOSYmJkZHjhzRkSNHnEcn9u3bp9OnT6t79+712m7Xrl3VtWtXTZs2TaNHj9bLL7/sDDdNwcfHp95zIEnXXHONcnNzm+TXyJtifpoSd0sBADxedHS0PvzwQ3311VcXDCpdunTRq6++qpycHH300UdKSUmRn59fnWMSExPVq1cvpaSkaNeuXdqxY4fGjRunQYMG1Xja5oe+++47TZkyRVu2bNHhw4e1bds27dy5UzExMQ3ez7pER0crMzNTBQUFOnXq1AX7z5o1SytXrtScOXO0d+9e5eTkaM2aNZo5c2aDt/1T5scdCDcAAI83d+5cHTp0SJ07d77gNR1//vOfderUKV1zzTUaO3as7r33XoWGhtY5xmaz6e9//7suu+wy/eIXv1BiYqI6deqktWvXXrA2b29vff311xo3bpy6du2qkSNH6qabbtKcOXMatI8XsmDBAm3evFlRUVHq06fPBfsnJSVp48aN+uc//6l+/fppwIABevbZZ9WxY8cGb/unzI872Cx3n9S7CBUXFysoKEhFRUUKDAxs6XIAoMWcPXtWeXl5bn/uCFBfdX0m6/v93SxHbpYsWaLo6Gj5+voqPj5eO3bsqLP/unXr1K1bN/n6+qpXr17atGlTrX1/+9vfymazaeHChU1cNQAA8ERuDzdr165VWlqa0tPTtWvXLvXu3VtJSUm13uK2fft2jR49WhMmTNDu3buVnJys5ORkffbZZ+f1ffPNN/Xvf/9bkZEt8LApAAD+vx49eqhNmzY1vmp6EN+lWlNzcftpqfj4ePXr10+LFy+WJFVXVysqKkpTp07V9OnTz+s/atQolZSUaOPGjc62AQMGKDY2VsuWLXO2ffXVV4qPj9c777yjm2++uUE/mMZpKQD4Hqelmsbhw4dVUVFR47KwsDAFBAQ0c0UXZ0310RSnpdx6K3h5ebmys7M1Y8YMZ5uXl5cSExOVlZVV45isrCylpaW5tCUlJWnDhg3O99XV1Ro7dqwefPBB9ejR44J1lJWVqayszPm+uLi4gXsCAEDtGnMRrrtdjDU1F7eeljp58qSqqqoUFhbm0h4WFqaCgoIaxxQUFFyw/5NPPqlWrVrp3nvvrVcd8+fPV1BQkPP1wycoAgDk9gfGAfXVFJ9Fj7sVPDs7W4sWLdKKFSvOe+pkbWbMmKGioiLn68iRI26uEgA8w7kn45aWlrZwJcD3zn0Wf/zU5oZw62mpdu3aydvb+7yfhC8sLKz1h73Cw8Pr7L9161YdP35cHTp0cC6vqqrSAw88oIULF+rQoUPnrdPhcMjhcPzEvQEA83h7eys4ONh5k4e/v3+9/+IINCXLslRaWqrjx48rODj4J/1quFvDjd1uV1xcnDIzM5WcnCzp++tlMjMzNWXKlBrHJCQkKDMz0+Xi4M2bNyshIUGSNHbsWCUmJrqMSUpK0tixY8/71VIAwIWd+8uju3+oEaiPhvyyeW3c/ttSaWlpSk1NVd++fdW/f38tXLhQJSUlziAybtw4XX755Zo/f74k6b777tOgQYO0YMEC3XzzzVqzZo0+/vhjLV++XJLUtm1btW3b1mUbPj4+Cg8P11VXXeXu3QEA49hsNkVERCg0NLTWu2uA5uDj4/OTjtic4/ZwM2rUKJ04cUKzZs1SQUGBYmNjlZGR4bxoOD8/X15e/7n0Z+DAgVq9erVmzpypRx55RF26dNGGDRvUs2dPd5cKAJc0b2/vJvliAVoaP7/Ac24AAPAIF9XPLwAAADQXwg0AADAK4QYAABiFcAMAAIxCuAEAAEYh3AAAAKMQbgAAgFEINwAAwCiEGwAAYBTCDQAAMArhBgAAGIVwAwAAjEK4AQAARiHcAAAAoxBuAACAUQg3AADAKIQbAABgFMINAAAwCuEGAAAYhXADAACMQrgBAABGIdwAAACjEG4AAIBRCDcAAMAohBsAAGAUwg0AADAK4QYAABiFcAMAAIxCuAEAAEYh3AAAAKMQbgAAgFEINwAAwCiEGwAAYBTCDQAAMArhBgAAGIVwAwAAjEK4AQAARiHcAAAAoxBuAACAUQg3AADAKIQbAABgFMINAAAwCuEGAAAYhXADAACMQrgBAABGIdwAAACjEG4AAIBRCDcAAMAohBsAAGAUwg0AADAK4QYAABiFcAMAAIxCuAEAAEYh3AAAAKMQbgAAgFEINwAAwCjNEm6WLFmi6Oho+fr6Kj4+Xjt27Kiz/7p169StWzf5+vqqV69e2rRpk3NZRUWFHn74YfXq1UutW7dWZGSkxo0bp6NHj7p7NwAAgAdwe7hZu3at0tLSlJ6erl27dql3795KSkrS8ePHa+y/fft2jR49WhMmTNDu3buVnJys5ORkffbZZ5Kk0tJS7dq1S4899ph27dql9evXKzc3V7fddpu7dwUAAHgAm2VZljs3EB8fr379+mnx4sWSpOrqakVFRWnq1KmaPn36ef1HjRqlkpISbdy40dk2YMAAxcbGatmyZTVuY+fOnerfv78OHz6sDh06XLCm4uJiBQUFqaioSIGBgY3cMwAA0Jzq+/3t1iM35eXlys7OVmJi4n826OWlxMREZWVl1TgmKyvLpb8kJSUl1dpfkoqKimSz2RQcHFzj8rKyMhUXF7u8AACAmdwabk6ePKmqqiqFhYW5tIeFhamgoKDGMQUFBQ3qf/bsWT388MMaPXp0rSlu/vz5CgoKcr6ioqIasTcAAMATePTdUhUVFRo5cqQsy9ILL7xQa78ZM2aoqKjI+Tpy5EgzVgkAAJpTK3euvF27dvL29lZhYaFLe2FhocLDw2scEx4eXq/+54LN4cOH9d5779V57s3hcMjhcDRyLwAAgCdx65Ebu92uuLg4ZWZmOtuqq6uVmZmphISEGsckJCS49JekzZs3u/Q/F2w+//xzvfvuu2rbtq17dgAAAHgctx65kaS0tDSlpqaqb9++6t+/vxYuXKiSkhLdfffdkqRx48bp8ssv1/z58yVJ9913nwYNGqQFCxbo5ptv1po1a/Txxx9r+fLlkr4PNnfccYd27dqljRs3qqqqynk9TkhIiOx2u7t3CQAAXMTcHm5GjRqlEydOaNasWSooKFBsbKwyMjKcFw3n5+fLy+s/B5AGDhyo1atXa+bMmXrkkUfUpUsXbdiwQT179pQkffXVV3rrrbckSbGxsS7bev/99zV48GB37xIAALiIuf05NxcjnnMDAIDnuSiecwMAANDcCDcAAMAohBsAAGAUwg0AADAK4QYAABiFcAMAAIxCuAEAAEYh3AAAAKMQbgAAgFEINwAAwCiEGwAAYBTCDQAAMArhBgAAGIVwAwAAjEK4AQAARiHcAAAAoxBuAACAUQg3AADAKIQbAABgFMINAAAwCuEGAAAYhXADAACMQrgBAABGIdwAAACjEG4AAIBRCDcAAMAohBsAAGAUwg0AADAK4QYAABiFcAMAAIxCuAEAAEYh3AAAAKMQbgAAgFEINwAAwCiEGwAAYBTCDQAAMArhBgAAGIVwAwAAjEK4AQAARiHcAAAAoxBuAACAUQg3AADAKIQbAABgFMINAAAwCuEGAAAYhXADAACMQrgBAABGIdwAAACjEG4AAIBRCDcAAMAohBsAAGAUwg0AADAK4QYAABiFcAMAAIxCuAEAAEYh3AAAAKM0S7hZsmSJoqOj5evrq/j4eO3YsaPO/uvWrVO3bt3k6+urXr16adOmTS7LLcvSrFmzFBERIT8/PyUmJurzzz935y4AAAAP4fZws3btWqWlpSk9PV27du1S7969lZSUpOPHj9fYf/v27Ro9erQmTJig3bt3Kzk5WcnJyfrss8+cfZ566ik999xzWrZsmT766CO1bt1aSUlJOnv2rLt3BwAAXORslmVZ7txAfHy8+vXrp8WLF0uSqqurFRUVpalTp2r69Onn9R81apRKSkq0ceNGZ9uAAQMUGxurZcuWybIsRUZG6oEHHtDvf/97SVJRUZHCwsK0YsUK3XnnnResqbi4WEFBQSoqKlJgYGAT7SkAAHCn+n5/t3JnEeXl5crOztaMGTOcbV5eXkpMTFRWVlaNY7KyspSWlubSlpSUpA0bNkiS8vLyVFBQoMTEROfyoKAgxcfHKysrq8ZwU1ZWprKyMuf74uLin7JbtdqTuUZnczPdsm4AADxJ6563qNcvbm+Rbbs13Jw8eVJVVVUKCwtzaQ8LC9P+/ftrHFNQUFBj/4KCAufyc2219fmx+fPna86cOY3ah4b47sB2JRz/m9u3AwDAxS4rL1QyMdxcLGbMmOFyNKi4uFhRUVFNvp02Vw1Wls3W5OsFAMDTBHa5tsW27dZw065dO3l7e6uwsNClvbCwUOHh4TWOCQ8Pr7P/uX8WFhYqIiLCpU9sbGyN63Q4HHI4HI3djXrrNWi4NGi427cDAABq59a7pex2u+Li4pSZ+Z/rUKqrq5WZmamEhIQaxyQkJLj0l6TNmzc7+1955ZUKDw936VNcXKyPPvqo1nUCAIBLh9tPS6WlpSk1NVV9+/ZV//79tXDhQpWUlOjuu++WJI0bN06XX3655s+fL0m67777NGjQIC1YsEA333yz1qxZo48//ljLly+XJNlsNt1///36wx/+oC5duujKK6/UY489psjISCUnJ7t7dwAAwEXO7eFm1KhROnHihGbNmqWCggLFxsYqIyPDeUFwfn6+vLz+cwBp4MCBWr16tWbOnKlHHnlEXbp00YYNG9SzZ09nn4ceekglJSWaNGmSTp8+rZ///OfKyMiQr6+vu3cHAABc5Nz+nJuLEc+5AQDA89T3+5vflgIAAEYh3AAAAKMQbgAAgFEINwAAwCiEGwAAYBTCDQAAMArhBgAAGIVwAwAAjEK4AQAARiHcAAAAoxBuAACAUQg3AADAKIQbAABgFMINAAAwCuEGAAAYhXADAACMQrgBAABGIdwAAACjEG4AAIBRCDcAAMAohBsAAGAUwg0AADAK4QYAABiFcAMAAIxCuAEAAEYh3AAAAKMQbgAAgFEINwAAwCiEGwAAYBTCDQAAMArhBgAAGIVwAwAAjEK4AQAARiHcAAAAoxBuAACAUQg3AADAKIQbAABgFMINAAAwCuEGAAAYhXADAACMQrgBAABGIdwAAACjEG4AAIBRCDcAAMAohBsAAGAUwg0AADAK4QYAABiFcAMAAIxCuAEAAEYh3AAAAKMQbgAAgFEINwAAwCiEGwAAYBTCDQAAMArhBgAAGIVwAwAAjOK2cPPNN98oJSVFgYGBCg4O1oQJE/Ttt9/WOebs2bOaPHmy2rZtqzZt2mjEiBEqLCx0Lv/kk080evRoRUVFyc/PTzExMVq0aJG7dgEAAHggt4WblJQU7d27V5s3b9bGjRv14YcfatKkSXWOmTZtmv7xj39o3bp1+uCDD3T06FENHz7cuTw7O1uhoaF67bXXtHfvXj366KOaMWOGFi9e7K7dAAAAHsZmWZbV1CvNyclR9+7dtXPnTvXt21eSlJGRoWHDhunLL79UZGTkeWOKiorUvn17rV69WnfccYckaf/+/YqJiVFWVpYGDBhQ47YmT56snJwcvffee/Wur7i4WEFBQSoqKlJgYGAj9hAAADS3+n5/u+XITVZWloKDg53BRpISExPl5eWljz76qMYx2dnZqqioUGJiorOtW7du6tChg7KysmrdVlFRkUJCQpqueAAA4NFauWOlBQUFCg0Ndd1Qq1YKCQlRQUFBrWPsdruCg4Nd2sPCwmods337dq1du1Zvv/12nfWUlZWprKzM+b64uLgeewEAADxRg47cTJ8+XTabrc7X/v373VWri88++0y333670tPT9V//9V919p0/f76CgoKcr6ioqGapEQAANL8GHbl54IEHNH78+Dr7dOrUSeHh4Tp+/LhLe2Vlpb755huFh4fXOC48PFzl5eU6ffq0y9GbwsLC88bs27dPQ4cO1aRJkzRz5swL1j1jxgylpaU53xcXFxNwAAAwVIPCTfv27dW+ffsL9ktISNDp06eVnZ2tuLg4SdJ7772n6upqxcfH1zgmLi5OPj4+yszM1IgRIyRJubm5ys/PV0JCgrPf3r17NWTIEKWmpmrevHn1qtvhcMjhcNSrLwAA8GxuuVtKkm666SYVFhZq2bJlqqio0N13362+fftq9erVkqSvvvpKQ4cO1cqVK9W/f39J0n//939r06ZNWrFihQIDAzV16lRJ319bI31/KmrIkCFKSkrS008/7dyWt7d3vULXOdwtBQCA56nv97dbLiiWpFWrVmnKlCkaOnSovLy8NGLECD333HPO5RUVFcrNzVVpaamz7dlnn3X2LSsrU1JSkpYuXepc/vrrr+vEiRN67bXX9NprrznbO3bsqEOHDrlrVwAAgAdx25GbixlHbgAA8Dwt+pwbAACAlkK4AQAARiHcAAAAoxBuAACAUQg3AADAKIQbAABgFMINAAAwCuEGAAAYhXADAACMQrgBAABGIdwAAACjEG4AAIBRCDcAAMAohBsAAGAUwg0AADAK4QYAABiFcAMAAIxCuAEAAEYh3AAAAKMQbgAAgFEINwAAwCiEGwAAYBTCDQAAMArhBgAAGIVwAwAAjEK4AQAARiHcAAAAoxBuAACAUQg3AADAKIQbAABgFMINAAAwCuEGAAAYhXADAACMQrgBAABGIdwAAACjEG4AAIBRCDcAAMAohBsAAGAUwg0AADAK4QYAABiFcAMAAIxCuAEAAEYh3AAAAKMQbgAAgFEINwAAwCiEGwAAYBTCDQAAMArhBgAAGIVwAwAAjEK4AQAARiHcAAAAoxBuAACAUQg3AADAKIQbAABgFMINAAAwCuEGAAAYhXADAACM4rZw88033yglJUWBgYEKDg7WhAkT9O2339Y55uzZs5o8ebLatm2rNm3aaMSIESosLKyx79dff60rrrhCNptNp0+fdsMeAAAAT+S2cJOSkqK9e/dq8+bN2rhxoz788ENNmjSpzjHTpk3TP/7xD61bt04ffPCBjh49quHDh9fYd8KECbr66qvdUToAAPBgNsuyrKZeaU5Ojrp3766dO3eqb9++kqSMjAwNGzZMX375pSIjI88bU1RUpPbt22v16tW64447JEn79+9XTEyMsrKyNGDAAGffF154QWvXrtWsWbM0dOhQnTp1SsHBwfWur7i4WEFBQSoqKlJgYOBP21kAANAs6vv97ZYjN1lZWQoODnYGG0lKTEyUl5eXPvrooxrHZGdnq6KiQomJic62bt26qUOHDsrKynK27du3T3PnztXKlSvl5VW/8svKylRcXOzyAgAAZnJLuCkoKFBoaKhLW6tWrRQSEqKCgoJax9jt9vOOwISFhTnHlJWVafTo0Xr66afVoUOHetczf/58BQUFOV9RUVEN2yEAAOAxGhRupk+fLpvNVudr//797qpVM2bMUExMjO66664GjysqKnK+jhw54qYKAQBAS2vVkM4PPPCAxo8fX2efTp06KTw8XMePH3dpr6ys1DfffKPw8PAax4WHh6u8vFynT592OXpTWFjoHPPee+/p008/1euvvy5JOne5ULt27fToo49qzpw5Na7b4XDI4XDUZxcBAICHa1C4ad++vdq3b3/BfgkJCTp9+rSys7MVFxcn6ftgUl1drfj4+BrHxMXFycfHR5mZmRoxYoQkKTc3V/n5+UpISJAkvfHGG/ruu++cY3bu3Klf//rX2rp1qzp37tyQXQEAAIZqULipr5iYGN14442aOHGili1bpoqKCk2ZMkV33nmn806pr776SkOHDtXKlSvVv39/BQUFacKECUpLS1NISIgCAwM1depUJSQkOO+U+nGAOXnypHN7DblbCgAAmMst4UaSVq1apSlTpmjo0KHy8vLSiBEj9NxzzzmXV1RUKDc3V6Wlpc62Z5991tm3rKxMSUlJWrp0qbtKBAAABnLLc24udjznBgAAz9Oiz7kBAABoKYQbAABgFMINAAAwCuEGAAAYhXADAACMQrgBAABGIdwAAACjEG4AAIBRCDcAAMAohBsAAGAUwg0AADAK4QYAABiFcAMAAIxCuAEAAEYh3AAAAKMQbgAAgFEINwAAwCiEGwAAYBTCDQAAMArhBgAAGIVwAwAAjEK4AQAARiHcAAAAoxBuAACAUQg3AADAKIQbAABgFMINAAAwCuEGAAAYhXADAACMQrgBAABGIdwAAACjEG4AAIBRCDcAAMAohBsAAGAUwg0AADAK4QYAABiFcAMAAIxCuAEAAEYh3AAAAKMQbgAAgFEINwAAwCiEGwAAYJRWLV1AS7AsS5JUXFzcwpUAAID6Ove9fe57vDaXZLg5c+aMJCkqKqqFKwEAAA115swZBQUF1brcZl0o/hiourpaR48eVUBAgGw2W5Ouu7i4WFFRUTpy5IgCAwObdN34D+a5eTDPzYN5bh7Mc/Nw5zxblqUzZ84oMjJSXl61X1lzSR658fLy0hVXXOHWbQQGBvKHpxkwz82DeW4ezHPzYJ6bh7vmua4jNudwQTEAADAK4QYAABiFcNPEHA6H0tPT5XA4WroUozHPzYN5bh7Mc/NgnpvHxTDPl+QFxQAAwFwcuQEAAEYh3AAAAKMQbgAAgFEINwAAwCiEmwZasmSJoqOj5evrq/j4eO3YsaPO/uvWrVO3bt3k6+urXr16adOmTc1UqedryFy/+OKLuu6663TZZZfpsssuU2Ji4gX/2+B7Df1Mn7NmzRrZbDYlJye7t0BDNHSeT58+rcmTJysiIkIOh0Ndu3bl/x/10NB5Xrhwoa666ir5+fkpKipK06ZN09mzZ5upWs/04Ycf6tZbb1VkZKRsNps2bNhwwTFbtmzRNddcI4fDoZ/97GdasWKFe4u0UG9r1qyx7Ha79Ze//MXau3evNXHiRCs4ONgqLCyssf+2bdssb29v66mnnrL27dtnzZw50/Lx8bE+/fTTZq7c8zR0rseMGWMtWbLE2r17t5WTk2ONHz/eCgoKsr788stmrtyzNHSez8nLy7Muv/xy67rrrrNuv/325inWgzV0nsvKyqy+fftaw4YNs/71r39ZeXl51pYtW6w9e/Y0c+WepaHzvGrVKsvhcFirVq2y8vLyrHfeeceKiIiwpk2b1syVe5ZNmzZZjz76qLV+/XpLkvXmm2/W2f/gwYOWv7+/lZaWZu3bt896/vnnLW9vbysjI8NtNRJuGqB///7W5MmTne+rqqqsyMhIa/78+TX2HzlypHXzzTe7tMXHx1u/+c1v3FqnCRo61z9WWVlpBQQEWK+88oq7SjRCY+a5srLSGjhwoPXSSy9ZqamphJt6aOg8v/DCC1anTp2s8vLy5irRCA2d58mTJ1tDhgxxaUtLS7OuvfZat9ZpkvqEm4ceesjq0aOHS9uoUaOspKQkt9XFaal6Ki8vV3Z2thITE51tXl5eSkxMVFZWVo1jsrKyXPpLUlJSUq398b3GzPWPlZaWqqKiQiEhIe4q0+M1dp7nzp2r0NBQTZgwoTnK9HiNmee33npLCQkJmjx5ssLCwtSzZ0/98Y9/VFVVVXOV7XEaM88DBw5Udna289TVwYMHtWnTJg0bNqxZar5UtMR34SX5w5mNcfLkSVVVVSksLMylPSwsTPv3769xTEFBQY39CwoK3FanCRoz1z/28MMPKzIy8rw/UPiPxszzv/71L/35z3/Wnj17mqFCMzRmng8ePKj33ntPKSkp2rRpk7744gv97ne/U0VFhdLT05ujbI/TmHkeM2aMTp48qZ///OeyLEuVlZX67W9/q0ceeaQ5Sr5k1PZdWFxcrO+++05+fn5Nvk2O3MA4TzzxhNasWaM333xTvr6+LV2OMc6cOaOxY8fqxRdfVLt27Vq6HKNVV1crNDRUy5cvV1xcnEaNGqVHH31Uy5Yta+nSjLJlyxb98Y9/1NKlS7Vr1y6tX79eb7/9th5//PGWLg0/EUdu6qldu3by9vZWYWGhS3thYaHCw8NrHBMeHt6g/vheY+b6nGeeeUZPPPGE3n33XV199dXuLNPjNXSeDxw4oEOHDunWW291tlVXV0uSWrVqpdzcXHXu3Nm9RXugxnyeIyIi5OPjI29vb2dbTEyMCgoKVF5eLrvd7taaPVFj5vmxxx7T2LFjdc8990iSevXqpZKSEk2aNEmPPvqovLz4+39TqO27MDAw0C1HbSSO3NSb3W5XXFycMjMznW3V1dXKzMxUQkJCjWMSEhJc+kvS5s2ba+2P7zVmriXpqaee0uOPP66MjAz17du3OUr1aA2d527duunTTz/Vnj17nK/bbrtN119/vfbs2aOoqKjmLN9jNObzfO211+qLL75whkdJ+r//+z9FREQQbGrRmHkuLS09L8CcC5QWP7vYZFrku9BtlyobaM2aNZbD4bBWrFhh7du3z5o0aZIVHBxsFRQUWJZlWWPHjrWmT5/u7L9t2zarVatW1jPPPGPl5ORY6enp3ApeTw2d6yeeeMKy2+3W66+/bh07dsz5OnPmTEvtgkdo6Dz/GHdL1U9D5zk/P98KCAiwpkyZYuXm5lobN260QkNDrT/84Q8ttQseoaHznJ6ebgUEBFh//etfrYMHD1r//Oc/rc6dO1sjR45sqV3wCGfOnLF2795t7d6925Jk/elPf7J2795tHT582LIsy5o+fbo1duxYZ/9zt4I/+OCDVk5OjrVkyRJuBb/YPP/881aHDh0su91u9e/f3/r3v//tXDZo0CArNTXVpf/f/vY3q2vXrpbdbrd69Ohhvf32281csedqyFx37NjRknTeKz09vfkL9zAN/Uz/EOGm/ho6z9u3b7fi4+Mth8NhderUyZo3b55VWVnZzFV7nobMc0VFhTV79myrc+fOlq+vrxUVFWX97ne/s06dOtX8hXuQ999/v8b/356b29TUVGvQoEHnjYmNjbXsdrvVqVMn6+WXX3ZrjTbL4tgbAAAwB9fcAAAAoxBuAACAUQg3AADAKIQbAABgFMINAAAwCuEGAAAYhXADAACMQrgBAABGIdwAAACjEG4AAIBRCDcAAMAohBsAAGCU/wdUGvCWgD/+rAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure()\n", "for name in [\"v1_shift\", \"itrafo_shift\"]:\n", @@ -826,9 +1041,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "v1_shift: 0.0\n", + "itrafo_shift: 0.0\n" + ] + } + ], "source": [ "errors_dp_shifted = []\n", "for name in [\"v1_shift\", \"itrafo_shift\"]:\n", @@ -851,9 +1075,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "logs/EMT_Trafo_Elements/EMT_Trafo_Elements.csv\n", + "column number: 9\n", + "results length: 20001\n", + "real column names: ['itrafo_0', 'itrafo_1', 'itrafo_2', 'v1_0', 'v1_1', 'v1_2', 'v2_0', 'v2_1', 'v2_2']\n", + "complex column names: []\n" + ] + } + ], "source": [ "work_dir = \"logs/EMT_Trafo_Elements/\"\n", "log_name = \"EMT_Trafo_Elements\"\n", @@ -863,9 +1099,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure()\n", "plt.plot(\n", @@ -879,9 +1126,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure()\n", "plt.plot(\n", @@ -902,9 +1160,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "logs/EMT_Trafo_Component/EMT_Trafo_Component.csv\n", + "column number: 9\n", + "results length: 20001\n", + "real column names: ['itrafo_0', 'itrafo_1', 'itrafo_2', 'v1_0', 'v1_1', 'v1_2', 'v2_0', 'v2_1', 'v2_2']\n", + "complex column names: []\n" + ] + } + ], "source": [ "work_dir = \"logs/EMT_Trafo_Component/\"\n", "log_name = \"EMT_Trafo_Component\"\n", @@ -914,9 +1184,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure()\n", "plt.plot(\n", @@ -940,9 +1221,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure()\n", "plt.plot(\n", @@ -973,9 +1265,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure()\n", "for name in [\"v1_0\", \"v1_1\", \"v1_1\", \"itrafo_0\", \"itrafo_1\", \"itrafo_2\"]:\n", @@ -997,9 +1300,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "v1_0: 0.0\n", + "v1_1: 0.0\n", + "v1_1: 0.0\n", + "itrafo_0: 0.0\n", + "itrafo_1: 0.0\n", + "itrafo_2: 0.0\n" + ] + } + ], "source": [ "errors_emt = []\n", "for name in [\"v1_0\", \"v1_1\", \"v1_1\", \"itrafo_0\", \"itrafo_1\", \"itrafo_2\"]:\n", @@ -1021,9 +1337,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure()\n", "for name in [(\"v1_shift\", \"v1_shift\")]:\n", @@ -1039,9 +1366,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure()\n", "for name in [(\"itrafo_shift\", \"itrafo_shift\")]:\n", @@ -1064,9 +1402,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "v1_shift vs. v1_shift (abs): 0.0\n", + "v1_shift vs. v1_shift (rel): 0.0\n", + "itrafo_shift vs. itrafo_shift (abs): 2.5426026707029044\n", + "itrafo_shift vs. itrafo_shift (rel): 0.25403338984981555\n", + "Max rel error: 2.5e+01%\n" + ] + } + ], "source": [ "compare_errors_abs = []\n", "compare_errors_rel = []\n", @@ -1099,9 +1449,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure()\n", "for name in [(\"v1_0\", \"v1_shift\")]:\n", @@ -1117,9 +1478,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure()\n", "for name in [(\"itrafo_0\", \"itrafo_shift\")]:\n", @@ -1142,9 +1514,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 37, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "v1_0 vs. v1_shift (abs): 3.7519957913900726e-06\n", + "v1_0 vs. v1_shift (rel): 3.7519957913900727e-11\n", + "itrafo_0 vs. itrafo_shift (abs): 0.0007013341531347805\n", + "itrafo_0 vs. itrafo_shift (rel): 7.007083505069428e-05\n", + "Max rel error: 0.007%\n" + ] + } + ], "source": [ "compare_errors_abs = []\n", "compare_errors_rel = []\n", @@ -1170,11 +1554,9 @@ } ], "metadata": { - "interpreter": { - "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6" - }, "kernelspec": { - "display_name": "Python 3.9.6 64-bit", + "display_name": "Python 3", + "language": "python", "name": "python3" }, "language_info": { @@ -1187,7 +1569,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.13" + "version": "3.10.11" } }, "nbformat": 4,