diff --git a/dpsim/examples/cxx/CMakeLists.txt b/dpsim/examples/cxx/CMakeLists.txt index b9075bc7e1..210f2bf529 100644 --- a/dpsim/examples/cxx/CMakeLists.txt +++ b/dpsim/examples/cxx/CMakeLists.txt @@ -90,6 +90,10 @@ set(CIRCUIT_SOURCES Circuits/DP_SynGenTrStab_3Bus_SteadyState.cpp Circuits/DP_SynGenTrStab_3Bus_Fault.cpp Circuits/SP_SynGenTrStab_3Bus_Fault.cpp + + # KRK Two Area System + Circuits/SP_SynGenTrStab_KRK_TwoArea_SteadyState.cpp + Circuits/SP_SynGenTrStab_KRK_TwoAreaTrafo_SteadyState.cpp ) if(WITH_JSON) diff --git a/dpsim/examples/cxx/Circuits/SP_SynGenTrStab_KRK_TwoAreaTrafo_SteadyState.cpp b/dpsim/examples/cxx/Circuits/SP_SynGenTrStab_KRK_TwoAreaTrafo_SteadyState.cpp new file mode 100644 index 0000000000..3f22e3061c --- /dev/null +++ b/dpsim/examples/cxx/Circuits/SP_SynGenTrStab_KRK_TwoAreaTrafo_SteadyState.cpp @@ -0,0 +1,601 @@ +/* Copyright 2017-2021 Institute for Automation of Complex Power Systems, + * EONERC, RWTH Aachen University; Universidad + * Nacional de Colombia + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. + *********************************************************************************/ + +#include "../Examples.h" +#include + +using namespace DPsim; +using namespace CPS; +using namespace CIM::Examples::Grids::KRK_TwoArea; +using namespace CIM::Examples; + +ScenarioConfig KRK_TwoArea; + +void SP_SynGenTrStab_KRK_TwoAreaTrafo_SteadyState( + String simName, Real timeStep, Real finalTime, Real cmdInertia_G1, + Real cmdInertia_G2, Real cmdInertia_G3, Real cmdInertia_G4, + Real cmdDamping_G1, Real cmdDamping_G2, Real cmdDamping_G3, + Real cmdDamping_G4) { + // ----- POWERFLOW FOR INITIALIZATION ----- + Real timeStepPF = finalTime; + Real finalTimePF = finalTime + timeStepPF; + String simNamePF = simName + "_PF"; + Logger::setLogDir("logs/" + simNamePF); + + // Components + auto n1PF = SimNode::make("n1", PhaseType::Single); + auto n2PF = SimNode::make("n2", PhaseType::Single); + auto n3PF = SimNode::make("n3", PhaseType::Single); + auto n4PF = SimNode::make("n4", PhaseType::Single); + auto n5PF = SimNode::make("n5", PhaseType::Single); + auto n6PF = SimNode::make("n6", PhaseType::Single); + auto n7PF = SimNode::make("n7", PhaseType::Single); + auto n8PF = SimNode::make("n8", PhaseType::Single); + auto n9PF = SimNode::make("n9", PhaseType::Single); + auto n10PF = SimNode::make("n10", PhaseType::Single); + auto n11PF = SimNode::make("n11", PhaseType::Single); + + //Synchronous generator 1 + auto gen1PF = + SP::Ph1::SynchronGenerator::make("SynGen1", Logger::Level::debug); + + // setPointVoltage is defined as the voltage at the transfomer primary side and should be transformed to network side + gen1PF->setParameters(KRK_TwoArea.nomPower_G1, KRK_TwoArea.nomPhPhVoltRMS_G1, + KRK_TwoArea.initActivePower_G1, + KRK_TwoArea.setPointVoltage_G1, PowerflowBusType::PV); + gen1PF->setBaseVoltage(KRK_TwoArea.nomPhPhVoltRMS_G1); + + //Synchronous generator 2 + auto gen2PF = + SP::Ph1::SynchronGenerator::make("SynGen2", Logger::Level::debug); + + // setPointVoltage is defined as the voltage at the transfomer primary side and should be transformed to network side + gen2PF->setParameters(KRK_TwoArea.nomPower_G2, KRK_TwoArea.nomPhPhVoltRMS_G2, + KRK_TwoArea.initActivePower_G2, + KRK_TwoArea.setPointVoltage_G2, PowerflowBusType::PV); + gen2PF->setBaseVoltage(KRK_TwoArea.nomPhPhVoltRMS_G2); + + //Synchronous generator 3 + auto gen3PF = + SP::Ph1::SynchronGenerator::make("SynGen3", Logger::Level::debug); + + // setPointVoltage is defined as the voltage at the transfomer primary side and should be transformed to network side + gen3PF->setParameters(KRK_TwoArea.nomPower_G3, KRK_TwoArea.nomPhPhVoltRMS_G3, + KRK_TwoArea.initActivePower_G3, + KRK_TwoArea.setPointVoltage_G3, PowerflowBusType::VD); + gen3PF->setBaseVoltage(KRK_TwoArea.nomPhPhVoltRMS_G3); + + //Synchronous generator 4 + auto gen4PF = + SP::Ph1::SynchronGenerator::make("SynGen4", Logger::Level::debug); + + // setPointVoltage is defined as the voltage at the transfomer primary side and should be transformed to network side + gen4PF->setParameters(KRK_TwoArea.nomPower_G4, KRK_TwoArea.nomPhPhVoltRMS_G4, + KRK_TwoArea.initActivePower_G4, + KRK_TwoArea.setPointVoltage_G4, PowerflowBusType::PV); + gen4PF->setBaseVoltage(KRK_TwoArea.nomPhPhVoltRMS_G4); + + auto trafo15PF = + SP::Ph1::Transformer::make("Transformer15", Logger::Level::debug); + auto trafo26PF = + SP::Ph1::Transformer::make("Transformer26", Logger::Level::debug); + auto trafo311PF = + SP::Ph1::Transformer::make("Transformer311", Logger::Level::debug); + auto trafo410PF = + SP::Ph1::Transformer::make("Transformer410", Logger::Level::debug); + + Real voltageMVSide = KRK_TwoArea.nomPhPhVoltRMS_G1; + Real voltageHVSide = KRK_TwoArea.Vnom; + Real ratio = voltageMVSide / voltageHVSide; + Real trafoResistance = 0; + Real trafoInductance = 23.4e-3; //set base to V_end2 + Real trafoPower = 900e6; + + // Note: to be consistent impedance values must be referred to high voltage side (and base voltage set to higher voltage) + trafo15PF->setParameters(voltageMVSide, voltageHVSide, trafoPower, + std::abs(ratio), std::arg(ratio), trafoResistance, + trafoInductance); + trafo15PF->setBaseVoltage(KRK_TwoArea.Vnom); + + trafo26PF->setParameters(voltageMVSide, voltageHVSide, trafoPower, + std::abs(ratio), std::arg(ratio), trafoResistance, + trafoInductance); + trafo26PF->setBaseVoltage(KRK_TwoArea.Vnom); + + trafo311PF->setParameters(voltageMVSide, voltageHVSide, trafoPower, + std::abs(ratio), std::arg(ratio), trafoResistance, + trafoInductance); + trafo311PF->setBaseVoltage(KRK_TwoArea.Vnom); + + trafo410PF->setParameters(voltageMVSide, voltageHVSide, trafoPower, + std::abs(ratio), std::arg(ratio), trafoResistance, + trafoInductance); + trafo410PF->setBaseVoltage(KRK_TwoArea.Vnom); + + //use Shunt as Load for powerflow + auto load7PF = SP::Ph1::Load::make("Load7", Logger::Level::debug); + load7PF->setParameters(KRK_TwoArea.activePower_L7, + KRK_TwoArea.reactivePower_L7_inductive - + KRK_TwoArea.reactivePower_L7_capacitive, + KRK_TwoArea.Vnom); + auto load9PF = SP::Ph1::Load::make("Load9", Logger::Level::debug); + load9PF->setParameters(KRK_TwoArea.activePower_L9, + KRK_TwoArea.reactivePower_L9_inductive - + KRK_TwoArea.reactivePower_L9_capacitive, + KRK_TwoArea.Vnom); + + //Line56 + auto line56PF = SP::Ph1::PiLine::make("PiLine56", Logger::Level::debug); + line56PF->setParameters( + KRK_TwoArea.lineResistance56, KRK_TwoArea.lineInductance56, + KRK_TwoArea.lineCapacitance56, KRK_TwoArea.lineConductance56); + line56PF->setBaseVoltage(KRK_TwoArea.Vnom); + + //Line67 + auto line67PF = SP::Ph1::PiLine::make("PiLine67", Logger::Level::debug); + line67PF->setParameters( + KRK_TwoArea.lineResistance67, KRK_TwoArea.lineInductance67, + KRK_TwoArea.lineCapacitance67, KRK_TwoArea.lineConductance67); + line67PF->setBaseVoltage(KRK_TwoArea.Vnom); + + //Line78_1 + auto line78_1PF = SP::Ph1::PiLine::make("Piline78_1", Logger::Level::debug); + line78_1PF->setParameters( + KRK_TwoArea.lineResistance78, KRK_TwoArea.lineInductance78, + KRK_TwoArea.lineCapacitance78, KRK_TwoArea.lineConductance78); + line78_1PF->setBaseVoltage(KRK_TwoArea.Vnom); + + //Line78_2 + auto line78_2PF = SP::Ph1::PiLine::make("Piline78_2", Logger::Level::debug); + line78_2PF->setParameters( + KRK_TwoArea.lineResistance78, KRK_TwoArea.lineInductance78, + KRK_TwoArea.lineCapacitance78, KRK_TwoArea.lineConductance78); + line78_2PF->setBaseVoltage(KRK_TwoArea.Vnom); + + //Line89_1 + auto line89_1PF = SP::Ph1::PiLine::make("Piline89_1", Logger::Level::debug); + line89_1PF->setParameters( + KRK_TwoArea.lineResistance89, KRK_TwoArea.lineInductance89, + KRK_TwoArea.lineCapacitance89, KRK_TwoArea.lineConductance89); + line89_1PF->setBaseVoltage(KRK_TwoArea.Vnom); + + //Line89_2 + auto line89_2PF = SP::Ph1::PiLine::make("Piline89_2", Logger::Level::debug); + line89_2PF->setParameters( + KRK_TwoArea.lineResistance89, KRK_TwoArea.lineInductance89, + KRK_TwoArea.lineCapacitance89, KRK_TwoArea.lineConductance89); + line89_2PF->setBaseVoltage(KRK_TwoArea.Vnom); + + //Line910 + auto line910PF = SP::Ph1::PiLine::make("PiLine910", Logger::Level::debug); + line910PF->setParameters( + KRK_TwoArea.lineResistance910, KRK_TwoArea.lineInductance910, + KRK_TwoArea.lineCapacitance910, KRK_TwoArea.lineConductance910); + line910PF->setBaseVoltage(KRK_TwoArea.Vnom); + + //Line1011 + auto line1011PF = SP::Ph1::PiLine::make("PiLine1011", Logger::Level::debug); + line1011PF->setParameters( + KRK_TwoArea.lineResistance1011, KRK_TwoArea.lineInductance1011, + KRK_TwoArea.lineCapacitance1011, KRK_TwoArea.lineConductance1011); + line1011PF->setBaseVoltage(KRK_TwoArea.Vnom); + + // Topology + gen1PF->connect({n1PF}); + gen2PF->connect({n2PF}); + gen3PF->connect({n3PF}); + gen4PF->connect({n4PF}); + + trafo15PF->connect({n1PF, n5PF}); + trafo26PF->connect({n2PF, n6PF}); + trafo311PF->connect({n3PF, n11PF}); + trafo410PF->connect({n4PF, n10PF}); + + load7PF->connect({n7PF}); + load9PF->connect({n9PF}); + + line56PF->connect({n5PF, n6PF}); + line67PF->connect({n6PF, n7PF}); + line78_1PF->connect({n7PF, n8PF}); + line78_2PF->connect({n7PF, n8PF}); + line89_1PF->connect({n8PF, n9PF}); + line89_2PF->connect({n8PF, n9PF}); + line910PF->connect({n9PF, n10PF}); + line1011PF->connect({n10PF, n11PF}); + auto systemPF = SystemTopology( + 60, + SystemNodeList{n1PF, n2PF, n3PF, n4PF, n5PF, n6PF, n7PF, n8PF, n9PF, + n10PF, n11PF}, + SystemComponentList{gen1PF, gen2PF, gen3PF, gen4PF, trafo15PF, trafo26PF, + trafo311PF, trafo410PF, load7PF, load9PF, line56PF, + line67PF, line78_1PF, line78_2PF, line89_1PF, + line89_2PF, line910PF, line1011PF}); + + // Logging + auto loggerPF = DataLogger::make(simNamePF); + loggerPF->logAttribute("v_bus1", n1PF->attribute("v")); + loggerPF->logAttribute("s_bus1", n1PF->attribute("s")); + loggerPF->logAttribute("v_bus2", n2PF->attribute("v")); + loggerPF->logAttribute("s_bus2", n2PF->attribute("s")); + loggerPF->logAttribute("v_bus3", n3PF->attribute("v")); + loggerPF->logAttribute("s_bus3", n3PF->attribute("s")); + loggerPF->logAttribute("v_bus4", n4PF->attribute("v")); + loggerPF->logAttribute("s_bus4", n4PF->attribute("s")); + loggerPF->logAttribute("v_bus5", n5PF->attribute("v")); + loggerPF->logAttribute("s_bus5", n5PF->attribute("s")); + loggerPF->logAttribute("v_bus6", n6PF->attribute("v")); + loggerPF->logAttribute("s_bus6", n6PF->attribute("s")); + loggerPF->logAttribute("v_bus7", n7PF->attribute("v")); + loggerPF->logAttribute("s_bus7", n7PF->attribute("s")); + loggerPF->logAttribute("v_bus8", n8PF->attribute("v")); + loggerPF->logAttribute("s_bus8", n8PF->attribute("s")); + loggerPF->logAttribute("v_bus9", n9PF->attribute("v")); + loggerPF->logAttribute("s_bus9", n9PF->attribute("s")); + loggerPF->logAttribute("v_bus10", n10PF->attribute("v")); + loggerPF->logAttribute("s_bus10", n10PF->attribute("s")); + loggerPF->logAttribute("v_bus11", n11PF->attribute("v")); + loggerPF->logAttribute("s_bus11", n11PF->attribute("s")); + + // Simulation + Simulation simPF(simNamePF, Logger::Level::debug); + simPF.setSystem(systemPF); + simPF.setTimeStep(timeStepPF); + simPF.setFinalTime(finalTimePF); + simPF.setDomain(Domain::SP); + simPF.setSolverType(Solver::Type::NRP); + simPF.doInitFromNodesAndTerminals(false); + simPF.addLogger(loggerPF); + simPF.run(); + + // ----- Dynamic simulation ------ + String simNameSP = simName + "_SP"; + Logger::setLogDir("logs/" + simNameSP); + + // Nodes + auto n1SP = SimNode::make("n1", PhaseType::Single); + auto n2SP = SimNode::make("n2", PhaseType::Single); + auto n3SP = SimNode::make("n3", PhaseType::Single); + auto n4SP = SimNode::make("n4", PhaseType::Single); + auto n5SP = SimNode::make("n5", PhaseType::Single); + auto n6SP = SimNode::make("n6", PhaseType::Single); + auto n7SP = SimNode::make("n7", PhaseType::Single); + auto n8SP = SimNode::make("n8", PhaseType::Single); + auto n9SP = SimNode::make("n9", PhaseType::Single); + auto n10SP = SimNode::make("n10", PhaseType::Single); + auto n11SP = SimNode::make("n11", PhaseType::Single); + + // Components + //Synchronous generator 1 + auto gen1SP = + SP::Ph1::SynchronGeneratorTrStab::make("SynGen1", Logger::Level::debug); + + // Xpd is given in p.u of generator base at transfomer primary side and should be transformed to network side + gen1SP->setStandardParametersPU(KRK_TwoArea.nomPower_G1, + KRK_TwoArea.nomPhPhVoltRMS_G1, + KRK_TwoArea.nomFreq_G1, KRK_TwoArea.Xpd, + KRK_TwoArea.H_G1, KRK_TwoArea.Rs, 10.0); + + // Get actual active and reactive power of generator's Terminal from Powerflow solution + Complex initApparentPower_G1 = gen1PF->getApparentPower(); + Real initMechPower_G1 = initApparentPower_G1.real(); + gen1SP->setInitialValues(initApparentPower_G1, initMechPower_G1); + + //Synchronous generator 2 + auto gen2SP = + SP::Ph1::SynchronGeneratorTrStab::make("SynGen2", Logger::Level::debug); + + // Xpd is given in p.u of generator base at transfomer primary side and should be transformed to network side + gen2SP->setStandardParametersPU(KRK_TwoArea.nomPower_G2, + KRK_TwoArea.nomPhPhVoltRMS_G2, + KRK_TwoArea.nomFreq_G2, KRK_TwoArea.Xpd, + KRK_TwoArea.H_G2, KRK_TwoArea.Rs, 10.0); + + // Get actual active and reactive power of generator's Terminal from Powerflow solution + Complex initApparentPower_G2 = gen2PF->getApparentPower(); + Real initMechPower_G2 = initApparentPower_G2.real(); + gen2SP->setInitialValues(initApparentPower_G2, initMechPower_G2); + + //Synchronous generator 3 + auto gen3SP = + SP::Ph1::SynchronGeneratorTrStab::make("SynGen3", Logger::Level::debug); + + // Xpd is given in p.u of generator base at transfomer primary side and should be transformed to network side + gen3SP->setStandardParametersPU(KRK_TwoArea.nomPower_G3, + KRK_TwoArea.nomPhPhVoltRMS_G3, + KRK_TwoArea.nomFreq_G3, KRK_TwoArea.Xpd, + KRK_TwoArea.H_G3, KRK_TwoArea.Rs, 10.0); + + // Get actual active and reactive power of generator's Terminal from Powerflow solution + Complex initApparentPower_G3 = gen3PF->getApparentPower(); + Real initMechPower_G3 = initApparentPower_G3.real(); + gen3SP->setInitialValues(initApparentPower_G3, initMechPower_G3); + + //Synchronous generator 4 + auto gen4SP = + SP::Ph1::SynchronGeneratorTrStab::make("SynGen4", Logger::Level::debug); + + // Xpd is given in p.u of generator base at transfomer primary side and should be transformed to network side + gen4SP->setStandardParametersPU(KRK_TwoArea.nomPower_G4, + KRK_TwoArea.nomPhPhVoltRMS_G4, + KRK_TwoArea.nomFreq_G4, KRK_TwoArea.Xpd, + KRK_TwoArea.H_G4, KRK_TwoArea.Rs, 10.0); + + // Get actual active and reactive power of generator's Terminal from Powerflow solution + Complex initApparentPower_G4 = gen4PF->getApparentPower(); + Real initMechPower_G4 = initApparentPower_G4.real(); + gen4SP->setInitialValues(initApparentPower_G4, initMechPower_G4); + + gen1SP->setModelFlags(true); + gen1SP->setReferenceOmega(gen3SP->attributeTyped("w_r"), + gen3SP->attributeTyped("delta_r")); + + gen2SP->setModelFlags(true); + gen2SP->setReferenceOmega(gen3SP->attributeTyped("w_r"), + gen3SP->attributeTyped("delta_r")); + + gen4SP->setModelFlags(true); + gen4SP->setReferenceOmega(gen3SP->attributeTyped("w_r"), + gen3SP->attributeTyped("delta_r")); + + auto trafo15SP = SP::Ph1::Transformer::make("trafo15", Logger::Level::debug); + trafo15SP->setParameters(voltageMVSide, voltageHVSide, trafoPower, + std::abs(ratio), std::arg(ratio), trafoResistance, + trafoInductance); + + auto trafo26SP = SP::Ph1::Transformer::make("trafo26", Logger::Level::debug); + trafo26SP->setParameters(voltageMVSide, voltageHVSide, trafoPower, + std::abs(ratio), std::arg(ratio), trafoResistance, + trafoInductance); + + auto trafo311SP = + SP::Ph1::Transformer::make("trafo311", Logger::Level::debug); + trafo311SP->setParameters(voltageMVSide, voltageHVSide, trafoPower, + std::abs(ratio), std::arg(ratio), trafoResistance, + trafoInductance); + + auto trafo410SP = + SP::Ph1::Transformer::make("trafo410", Logger::Level::debug); + trafo410SP->setParameters(voltageMVSide, voltageHVSide, trafoPower, + std::abs(ratio), std::arg(ratio), trafoResistance, + trafoInductance); + + ///Loads + auto load7SP = SP::Ph1::Load::make("Load7", Logger::Level::debug); + load7SP->setParameters(KRK_TwoArea.activePower_L7, + KRK_TwoArea.reactivePower_L7_inductive - + KRK_TwoArea.reactivePower_L7_capacitive, + KRK_TwoArea.Vnom); + + auto load9SP = SP::Ph1::Load::make("Load9", Logger::Level::debug); + load9SP->setParameters(KRK_TwoArea.activePower_L9, + KRK_TwoArea.reactivePower_L9_inductive - + KRK_TwoArea.reactivePower_L9_capacitive, + KRK_TwoArea.Vnom); + + //Line45 + auto line45SP = SP::Ph1::PiLine::make("PiLine45", Logger::Level::debug); + line45SP->setParameters( + KRK_TwoArea.lineResistance56, KRK_TwoArea.lineInductance56, + KRK_TwoArea.lineCapacitance56, KRK_TwoArea.lineConductance56); + + //Line56 + auto line56SP = SP::Ph1::PiLine::make("PiLine56", Logger::Level::debug); + line56SP->setParameters( + KRK_TwoArea.lineResistance56, KRK_TwoArea.lineInductance56, + KRK_TwoArea.lineCapacitance56, KRK_TwoArea.lineConductance56); + + //Line67 + auto line67SP = SP::Ph1::PiLine::make("PiLine67", Logger::Level::debug); + line67SP->setParameters( + KRK_TwoArea.lineResistance67, KRK_TwoArea.lineInductance67, + KRK_TwoArea.lineCapacitance67, KRK_TwoArea.lineConductance67); + + //Line78_1 + auto line78_1SP = SP::Ph1::PiLine::make("PiLine78_1", Logger::Level::debug); + line78_1SP->setParameters( + KRK_TwoArea.lineResistance78, KRK_TwoArea.lineInductance78, + KRK_TwoArea.lineCapacitance78, KRK_TwoArea.lineConductance78); + + //Line78_2 + auto line78_2SP = SP::Ph1::PiLine::make("PiLine78_2", Logger::Level::debug); + line78_2SP->setParameters( + KRK_TwoArea.lineResistance78, KRK_TwoArea.lineInductance78, + KRK_TwoArea.lineCapacitance78, KRK_TwoArea.lineConductance78); + + //Line89_1 + auto line89_1SP = SP::Ph1::PiLine::make("PiLine89_1", Logger::Level::debug); + line89_1SP->setParameters( + KRK_TwoArea.lineResistance89, KRK_TwoArea.lineInductance89, + KRK_TwoArea.lineCapacitance89, KRK_TwoArea.lineConductance89); + + //Line89_2 + auto line89_2SP = SP::Ph1::PiLine::make("PiLine89_2", Logger::Level::debug); + line89_2SP->setParameters( + KRK_TwoArea.lineResistance89, KRK_TwoArea.lineInductance89, + KRK_TwoArea.lineCapacitance89, KRK_TwoArea.lineConductance89); + + //Line910 + auto line910SP = SP::Ph1::PiLine::make("PiLine910", Logger::Level::debug); + line910SP->setParameters( + KRK_TwoArea.lineResistance910, KRK_TwoArea.lineInductance910, + KRK_TwoArea.lineCapacitance910, KRK_TwoArea.lineConductance910); + + //Line1011 + auto line1011SP = SP::Ph1::PiLine::make("PiLine1011", Logger::Level::debug); + line1011SP->setParameters( + KRK_TwoArea.lineResistance1011, KRK_TwoArea.lineInductance1011, + KRK_TwoArea.lineCapacitance1011, KRK_TwoArea.lineConductance1011); + + // Topology + gen1SP->connect({n1SP}); + gen2SP->connect({n2SP}); + gen3SP->connect({n3SP}); + gen4SP->connect({n4SP}); + + trafo15SP->connect({n1SP, n5SP}); + trafo26SP->connect({n2SP, n6SP}); + trafo311SP->connect({n3SP, n11SP}); + trafo410SP->connect({n4SP, n10SP}); + + load7SP->connect({n7SP}); + load9SP->connect({n9SP}); + + line56SP->connect({n5SP, n6SP}); + line67SP->connect({n6SP, n7SP}); + line78_1SP->connect({n7SP, n8SP}); + line78_2SP->connect({n7SP, n8SP}); + line89_1SP->connect({n8SP, n9SP}); + line89_2SP->connect({n8SP, n9SP}); + line910SP->connect({n9SP, n10SP}); + line1011SP->connect({n10SP, n11SP}); + + auto systemSP = SystemTopology( + 60, + SystemNodeList{n1SP, n2SP, n3SP, n4SP, n5SP, n6SP, n7SP, n8SP, n9SP, + n10SP, n11SP}, + SystemComponentList{gen1SP, gen2SP, gen3SP, gen4SP, trafo15SP, trafo26SP, + trafo311SP, trafo410SP, load7SP, load9SP, line56SP, + line67SP, line78_1SP, line78_2SP, line89_1SP, + line89_2SP, line910SP, line1011SP}); + + // Initialization of dynamic topology + systemSP.initWithPowerflow(systemPF, CPS::Domain::SP); + + // Logging + auto loggerSP = DataLogger::make(simNameSP); + loggerSP->logAttribute("v1", n1SP->attribute("v")); + loggerSP->logAttribute("v2", n2SP->attribute("v")); + loggerSP->logAttribute("v3", n3SP->attribute("v")); + loggerSP->logAttribute("v4", n4SP->attribute("v")); + loggerSP->logAttribute("v5", n5SP->attribute("v")); + loggerSP->logAttribute("v6", n6SP->attribute("v")); + loggerSP->logAttribute("v7", n7SP->attribute("v")); + loggerSP->logAttribute("v8", n8SP->attribute("v")); + loggerSP->logAttribute("v9", n9SP->attribute("v")); + loggerSP->logAttribute("v10", n10SP->attribute("v")); + loggerSP->logAttribute("v11", n11SP->attribute("v")); + loggerSP->logAttribute("v_line56", line56SP->attribute("v_intf")); + loggerSP->logAttribute("i_line56", line56SP->attribute("i_intf")); + loggerSP->logAttribute("v_line67", line67SP->attribute("v_intf")); + loggerSP->logAttribute("i_line67", line67SP->attribute("i_intf")); + loggerSP->logAttribute("v_line78_1", line78_1SP->attribute("v_intf")); + loggerSP->logAttribute("i_line78_1", line78_1SP->attribute("i_intf")); + loggerSP->logAttribute("v_line78_2", line78_2SP->attribute("v_intf")); + loggerSP->logAttribute("i_line78_2", line78_2SP->attribute("i_intf")); + loggerSP->logAttribute("v_line89_1", line89_1SP->attribute("v_intf")); + loggerSP->logAttribute("i_line89_1", line89_1SP->attribute("i_intf")); + loggerSP->logAttribute("v_line89_2", line89_2SP->attribute("v_intf")); + loggerSP->logAttribute("i_line89_2", line89_2SP->attribute("i_intf")); + loggerSP->logAttribute("v_line910", line910SP->attribute("v_intf")); + loggerSP->logAttribute("i_line910", line910SP->attribute("i_intf")); + loggerSP->logAttribute("v_line1011", line1011SP->attribute("v_intf")); + loggerSP->logAttribute("i_line1011", line1011SP->attribute("i_intf")); + loggerSP->logAttribute("Ep_gen1", gen1SP->attribute("Ep_mag")); + loggerSP->logAttribute("v_gen1", gen1SP->attribute("v_intf")); + loggerSP->logAttribute("i_gen1", gen1SP->attribute("i_intf")); + loggerSP->logAttribute("wr_gen1", gen1SP->attribute("w_r")); + loggerSP->logAttribute("wref_gen1", gen1SP->attribute("w_ref")); + loggerSP->logAttribute("delta_gen1", gen1SP->attribute("delta_r")); + loggerSP->logAttribute("deltaref_gen1", gen1SP->attribute("delta_ref")); + loggerSP->logAttribute("Ep_gen2", gen2SP->attribute("Ep_mag")); + loggerSP->logAttribute("v_gen2", gen2SP->attribute("v_intf")); + loggerSP->logAttribute("i_gen2", gen2SP->attribute("i_intf")); + loggerSP->logAttribute("wr_gen2", gen2SP->attribute("w_r")); + loggerSP->logAttribute("wref_gen2", gen2SP->attribute("w_ref")); + loggerSP->logAttribute("delta_gen2", gen2SP->attribute("delta_r")); + loggerSP->logAttribute("deltaref_gen2", gen2SP->attribute("delta_ref")); + loggerSP->logAttribute("Ep_gen3", gen3SP->attribute("Ep_mag")); + loggerSP->logAttribute("v_gen3", gen3SP->attribute("v_intf")); + loggerSP->logAttribute("i_gen3", gen3SP->attribute("i_intf")); + loggerSP->logAttribute("wr_gen3", gen3SP->attribute("w_r")); + loggerSP->logAttribute("delta_gen3", gen3SP->attribute("delta_r")); + loggerSP->logAttribute("Ep_gen4", gen4SP->attribute("Ep_mag")); + loggerSP->logAttribute("v_gen4", gen4SP->attribute("v_intf")); + loggerSP->logAttribute("i_gen4", gen4SP->attribute("i_intf")); + loggerSP->logAttribute("wr_gen4", gen4SP->attribute("w_r")); + loggerSP->logAttribute("wref_gen4", gen4SP->attribute("w_ref")); + loggerSP->logAttribute("delta_gen4", gen4SP->attribute("delta_r")); + loggerSP->logAttribute("deltaref_gen4", gen4SP->attribute("delta_ref")); + loggerSP->logAttribute("v_load7", load7SP->attribute("v_intf")); + loggerSP->logAttribute("i_load7", load7SP->attribute("i_intf")); + loggerSP->logAttribute("v_load9", load9SP->attribute("v_intf")); + loggerSP->logAttribute("i_load9", load9SP->attribute("i_intf")); + loggerSP->logAttribute("P_mech1", gen1SP->attribute("P_mech")); + loggerSP->logAttribute("P_mech2", gen2SP->attribute("P_mech")); + loggerSP->logAttribute("P_elec1", gen1SP->attribute("P_elec")); + loggerSP->logAttribute("P_elec2", gen2SP->attribute("P_elec")); + loggerSP->logAttribute("P_mech3", gen3SP->attribute("P_mech")); + loggerSP->logAttribute("P_mech4", gen4SP->attribute("P_mech")); + loggerSP->logAttribute("P_elec3", gen3SP->attribute("P_elec")); + loggerSP->logAttribute("P_elec4", gen4SP->attribute("P_elec")); + + // trafo + loggerSP->logAttribute("i_trafo15", trafo15SP->attribute("i_intf")); + loggerSP->logAttribute("v_trafo15", trafo15SP->attribute("v_intf")); + loggerSP->logAttribute("i_trafo26", trafo26SP->attribute("i_intf")); + loggerSP->logAttribute("v_trafo26", trafo26SP->attribute("v_intf")); + loggerSP->logAttribute("i_trafo311", trafo311SP->attribute("i_intf")); + loggerSP->logAttribute("v_trafo311", trafo311SP->attribute("v_intf")); + loggerSP->logAttribute("i_trafo410", trafo410SP->attribute("i_intf")); + loggerSP->logAttribute("v_trafo410", trafo410SP->attribute("v_intf")); + + Simulation simSP(simNameSP, Logger::Level::debug); + simSP.setSystem(systemSP); + simSP.setTimeStep(timeStep); + simSP.setFinalTime(finalTime); + simSP.setDomain(Domain::SP); + simSP.addLogger(loggerSP); + + simSP.run(); +} + +int main(int argc, char *argv[]) { + + //Simulation parameters + String simName = "SP_SynGenTrStab_KRK_TwoAreaTrafo_SteadyState"; + Real finalTime = 1.0; + Real timeStep = 0.001; + Real cmdInertia_G1 = KRK_TwoArea.H_G1; + Real cmdInertia_G2 = KRK_TwoArea.H_G2; + Real cmdInertia_G3 = KRK_TwoArea.H_G3; + Real cmdInertia_G4 = KRK_TwoArea.H_G4; + Real cmdDamping_G1 = 1.0; + Real cmdDamping_G2 = 1.0; + Real cmdDamping_G3 = 1.0; + Real cmdDamping_G4 = 1.0; + + CommandLineArgs args(argc, argv); + if (argc > 1) { + timeStep = args.timeStep; + finalTime = args.duration; + if (args.name != "dpsim") + simName = args.name; + if (args.options.find("SCALEINERTIA_G1") != args.options.end()) + cmdInertia_G1 = args.getOptionReal("SCALEINERTIA_G1"); + if (args.options.find("SCALEINERTIA_G2") != args.options.end()) + cmdInertia_G2 = args.getOptionReal("SCALEINERTIA_G2"); + if (args.options.find("SCALEINERTIA_G3") != args.options.end()) + cmdInertia_G3 = args.getOptionReal("SCALEINERTIA_G3"); + if (args.options.find("SCALEINERTIA_G4") != args.options.end()) + cmdInertia_G4 = args.getOptionReal("SCALEINERTIA_G4"); + if (args.options.find("SCALEDAMPING_G1") != args.options.end()) + cmdDamping_G1 = args.getOptionReal("SCALEDAMPING_G1"); + if (args.options.find("SCALEDAMPING_G2") != args.options.end()) + cmdDamping_G2 = args.getOptionReal("SCALEDAMPING_G2"); + if (args.options.find("SCALEDAMPING_G3") != args.options.end()) + cmdDamping_G3 = args.getOptionReal("SCALEDAMPING_G3"); + if (args.options.find("SCALEDAMPING_G4") != args.options.end()) + cmdDamping_G4 = args.getOptionReal("SCALEDAMPING_G4"); + } + + SP_SynGenTrStab_KRK_TwoAreaTrafo_SteadyState( + simName, timeStep, finalTime, cmdInertia_G1, cmdInertia_G2, cmdInertia_G3, + cmdInertia_G4, cmdDamping_G1, cmdDamping_G2, cmdDamping_G3, + cmdDamping_G4); +} diff --git a/dpsim/examples/cxx/Circuits/SP_SynGenTrStab_KRK_TwoArea_SteadyState.cpp b/dpsim/examples/cxx/Circuits/SP_SynGenTrStab_KRK_TwoArea_SteadyState.cpp new file mode 100644 index 0000000000..49565c6500 --- /dev/null +++ b/dpsim/examples/cxx/Circuits/SP_SynGenTrStab_KRK_TwoArea_SteadyState.cpp @@ -0,0 +1,499 @@ +/* Copyright 2017-2021 Institute for Automation of Complex Power Systems, + * EONERC, RWTH Aachen University; Universidad + * Nacional de Colombia + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. + *********************************************************************************/ + +#include "../Examples.h" +#include + +using namespace DPsim; +using namespace CPS; +using namespace CIM::Examples::Grids::KRK_TwoArea; +using namespace CIM::Examples; + +ScenarioConfig KRK_TwoArea; + +void SP_SynGenTrStab_KRK_TwoArea_SteadyState( + String simName, Real timeStep, Real finalTime, Real cmdInertia_G1, + Real cmdInertia_G2, Real cmdInertia_G3, Real cmdInertia_G4, + Real cmdDamping_G1, Real cmdDamping_G2, Real cmdDamping_G3, + Real cmdDamping_G4) { + // ----- POWERFLOW FOR INITIALIZATION ----- + Real timeStepPF = finalTime; + Real finalTimePF = finalTime + timeStepPF; + String simNamePF = simName + "_PF"; + Logger::setLogDir("logs/" + simNamePF); + + // Components + auto n5PF = SimNode::make("n5", PhaseType::Single); + auto n6PF = SimNode::make("n6", PhaseType::Single); + auto n7PF = SimNode::make("n7", PhaseType::Single); + auto n8PF = SimNode::make("n8", PhaseType::Single); + auto n9PF = SimNode::make("n9", PhaseType::Single); + auto n10PF = SimNode::make("n10", PhaseType::Single); + auto n11PF = SimNode::make("n11", PhaseType::Single); + + //Synchronous generator 1 + auto gen1PF = + SP::Ph1::SynchronGenerator::make("SynGen1", Logger::Level::debug); + + // setPointVoltage is defined as the voltage at the transfomer primary side and should be transformed to network side + gen1PF->setParameters(KRK_TwoArea.nomPower_G1, KRK_TwoArea.nomPhPhVoltRMS_G1, + KRK_TwoArea.initActivePower_G1, + KRK_TwoArea.setPointVoltage_G1 * KRK_TwoArea.t1_ratio, + PowerflowBusType::PV, KRK_TwoArea.initReactivePower_G1); + gen1PF->setBaseVoltage(KRK_TwoArea.Vnom); + + //Synchronous generator 2 + auto gen2PF = + SP::Ph1::SynchronGenerator::make("SynGen2", Logger::Level::debug); + + // setPointVoltage is defined as the voltage at the transfomer primary side and should be transformed to network side + gen2PF->setParameters(KRK_TwoArea.nomPower_G2, KRK_TwoArea.nomPhPhVoltRMS_G2, + KRK_TwoArea.initActivePower_G2, + KRK_TwoArea.setPointVoltage_G2 * KRK_TwoArea.t2_ratio, + PowerflowBusType::PV, KRK_TwoArea.initReactivePower_G2); + gen2PF->setBaseVoltage(KRK_TwoArea.Vnom); + + //Synchronous generator 3 + auto gen3PF = + SP::Ph1::SynchronGenerator::make("SynGen3", Logger::Level::debug); + + // setPointVoltage is defined as the voltage at the transfomer primary side and should be transformed to network side + gen3PF->setParameters(KRK_TwoArea.nomPower_G3, KRK_TwoArea.nomPhPhVoltRMS_G3, + KRK_TwoArea.initActivePower_G3, + KRK_TwoArea.setPointVoltage_G3 * KRK_TwoArea.t3_ratio, + PowerflowBusType::VD, KRK_TwoArea.initReactivePower_G3); + gen3PF->setBaseVoltage(KRK_TwoArea.Vnom); + + //Synchronous generator 4 + auto gen4PF = + SP::Ph1::SynchronGenerator::make("SynGen4", Logger::Level::debug); + + // setPointVoltage is defined as the voltage at the transfomer primary side and should be transformed to network side + gen4PF->setParameters(KRK_TwoArea.nomPower_G4, KRK_TwoArea.nomPhPhVoltRMS_G4, + KRK_TwoArea.initActivePower_G4, + KRK_TwoArea.setPointVoltage_G4 * KRK_TwoArea.t4_ratio, + PowerflowBusType::PV, KRK_TwoArea.initReactivePower_G4); + gen4PF->setBaseVoltage(KRK_TwoArea.Vnom); + + //use Shunt as Load for powerflow + auto load7PF = SP::Ph1::Load::make("Load7", Logger::Level::debug); + load7PF->setParameters(KRK_TwoArea.activePower_L7, + KRK_TwoArea.reactivePower_L7_inductive - + KRK_TwoArea.reactivePower_L7_capacitive, + KRK_TwoArea.Vnom); + + auto load9PF = SP::Ph1::Load::make("Load9", Logger::Level::debug); + load9PF->setParameters(KRK_TwoArea.activePower_L9, + KRK_TwoArea.reactivePower_L9_inductive - + KRK_TwoArea.reactivePower_L9_capacitive, + KRK_TwoArea.Vnom); + + //Line56 + auto line56PF = SP::Ph1::PiLine::make("PiLine56", Logger::Level::debug); + line56PF->setParameters( + KRK_TwoArea.lineResistance56, KRK_TwoArea.lineInductance56, + KRK_TwoArea.lineCapacitance56, KRK_TwoArea.lineConductance56); + line56PF->setBaseVoltage(KRK_TwoArea.Vnom); + + //Line67 + auto line67PF = SP::Ph1::PiLine::make("PiLine67", Logger::Level::debug); + line67PF->setParameters( + KRK_TwoArea.lineResistance67, KRK_TwoArea.lineInductance67, + KRK_TwoArea.lineCapacitance67, KRK_TwoArea.lineConductance67); + line67PF->setBaseVoltage(KRK_TwoArea.Vnom); + + //Line78_1 + auto line78_1PF = SP::Ph1::PiLine::make("Piline78_1", Logger::Level::debug); + line78_1PF->setParameters( + KRK_TwoArea.lineResistance78, KRK_TwoArea.lineInductance78, + KRK_TwoArea.lineCapacitance78, KRK_TwoArea.lineConductance78); + line78_1PF->setBaseVoltage(KRK_TwoArea.Vnom); + + //Line78_2 + auto line78_2PF = SP::Ph1::PiLine::make("Piline78_2", Logger::Level::debug); + line78_2PF->setParameters( + KRK_TwoArea.lineResistance78, KRK_TwoArea.lineInductance78, + KRK_TwoArea.lineCapacitance78, KRK_TwoArea.lineConductance78); + line78_2PF->setBaseVoltage(KRK_TwoArea.Vnom); + + //Line89_1 + auto line89_1PF = SP::Ph1::PiLine::make("Piline89_1", Logger::Level::debug); + line89_1PF->setParameters( + KRK_TwoArea.lineResistance89, KRK_TwoArea.lineInductance89, + KRK_TwoArea.lineCapacitance89, KRK_TwoArea.lineConductance89); + line89_1PF->setBaseVoltage(KRK_TwoArea.Vnom); + + //Line89_2 + auto line89_2PF = SP::Ph1::PiLine::make("Piline89_2", Logger::Level::debug); + line89_2PF->setParameters( + KRK_TwoArea.lineResistance89, KRK_TwoArea.lineInductance89, + KRK_TwoArea.lineCapacitance89, KRK_TwoArea.lineConductance89); + line89_2PF->setBaseVoltage(KRK_TwoArea.Vnom); + + //Line910 + auto line910PF = SP::Ph1::PiLine::make("PiLine910", Logger::Level::debug); + line910PF->setParameters( + KRK_TwoArea.lineResistance910, KRK_TwoArea.lineInductance910, + KRK_TwoArea.lineCapacitance910, KRK_TwoArea.lineConductance910); + line910PF->setBaseVoltage(KRK_TwoArea.Vnom); + + //Line1011 + auto line1011PF = SP::Ph1::PiLine::make("PiLine1011", Logger::Level::debug); + line1011PF->setParameters( + KRK_TwoArea.lineResistance1011, KRK_TwoArea.lineInductance1011, + KRK_TwoArea.lineCapacitance1011, KRK_TwoArea.lineConductance1011); + line1011PF->setBaseVoltage(KRK_TwoArea.Vnom); + + // Topology + gen1PF->connect({n5PF}); + gen2PF->connect({n6PF}); + gen3PF->connect({n11PF}); + gen4PF->connect({n10PF}); + + load7PF->connect({n7PF}); + load9PF->connect({n9PF}); + + line56PF->connect({n5PF, n6PF}); + line67PF->connect({n6PF, n7PF}); + line78_1PF->connect({n7PF, n8PF}); + line78_2PF->connect({n7PF, n8PF}); + line89_1PF->connect({n8PF, n9PF}); + line89_2PF->connect({n8PF, n9PF}); + line910PF->connect({n9PF, n10PF}); + line1011PF->connect({n10PF, n11PF}); + auto systemPF = SystemTopology( + 60, SystemNodeList{n5PF, n6PF, n7PF, n8PF, n9PF, n10PF, n11PF}, + SystemComponentList{gen1PF, gen2PF, gen3PF, gen4PF, load7PF, load9PF, + line56PF, line67PF, line78_1PF, line78_2PF, + line89_1PF, line89_2PF, line910PF, line1011PF}); + + // Logging + auto loggerPF = DataLogger::make(simNamePF); + loggerPF->logAttribute("v_bus5", n5PF->attribute("v")); + loggerPF->logAttribute("s_bus5", n5PF->attribute("s")); + loggerPF->logAttribute("v_bus6", n6PF->attribute("v")); + loggerPF->logAttribute("s_bus6", n6PF->attribute("s")); + loggerPF->logAttribute("v_bus7", n7PF->attribute("v")); + loggerPF->logAttribute("s_bus7", n7PF->attribute("s")); + loggerPF->logAttribute("v_bus8", n8PF->attribute("v")); + loggerPF->logAttribute("s_bus8", n8PF->attribute("s")); + loggerPF->logAttribute("v_bus9", n9PF->attribute("v")); + loggerPF->logAttribute("s_bus9", n9PF->attribute("s")); + loggerPF->logAttribute("v_bus10", n10PF->attribute("v")); + loggerPF->logAttribute("s_bus10", n10PF->attribute("s")); + loggerPF->logAttribute("v_bus11", n11PF->attribute("v")); + loggerPF->logAttribute("s_bus11", n11PF->attribute("s")); + + // Simulation + Simulation simPF(simNamePF, Logger::Level::debug); + simPF.setSystem(systemPF); + simPF.setTimeStep(timeStepPF); + simPF.setFinalTime(finalTimePF); + simPF.setDomain(Domain::SP); + simPF.setSolverType(Solver::Type::NRP); + simPF.doInitFromNodesAndTerminals(false); + simPF.addLogger(loggerPF); + simPF.run(); + + // ----- Dynamic simulation ------ + String simNameSP = simName + "_SP"; + Logger::setLogDir("logs/" + simNameSP); + + // Nodes + auto n5SP = SimNode::make("n5", PhaseType::Single); + auto n6SP = SimNode::make("n6", PhaseType::Single); + auto n7SP = SimNode::make("n7", PhaseType::Single); + auto n8SP = SimNode::make("n8", PhaseType::Single); + auto n9SP = SimNode::make("n9", PhaseType::Single); + auto n10SP = SimNode::make("n10", PhaseType::Single); + auto n11SP = SimNode::make("n11", PhaseType::Single); + + // Components + //Synchronous generator 1 + auto gen1SP = + SP::Ph1::SynchronGeneratorTrStab::make("SynGen1", Logger::Level::debug); + + // Xpd is given in p.u of generator base at transfomer primary side and should be transformed to network side + gen1SP->setStandardParametersPU( + KRK_TwoArea.nomPower_G1, KRK_TwoArea.nomPhPhVoltRMS_G1, + KRK_TwoArea.nomFreq_G1, + KRK_TwoArea.Xpd * std::pow(KRK_TwoArea.t1_ratio, 2), KRK_TwoArea.H_G1, + KRK_TwoArea.Rs * std::pow(KRK_TwoArea.t1_ratio, 2), 10.0); + + // Get actual active and reactive power of generator's Terminal from Powerflow solution + Complex initApparentPower_G1 = gen1PF->getApparentPower(); + Real initMechPower_G1 = initApparentPower_G1.real(); + gen1SP->setInitialValues(initApparentPower_G1, initMechPower_G1); + + //Synchronous generator 2 + auto gen2SP = + SP::Ph1::SynchronGeneratorTrStab::make("SynGen2", Logger::Level::debug); + + // Xpd is given in p.u of generator base at transfomer primary side and should be transformed to network side + gen2SP->setStandardParametersPU( + KRK_TwoArea.nomPower_G2, KRK_TwoArea.nomPhPhVoltRMS_G2, + KRK_TwoArea.nomFreq_G2, + KRK_TwoArea.Xpd * std::pow(KRK_TwoArea.t2_ratio, 2), KRK_TwoArea.H_G2, + KRK_TwoArea.Rs * std::pow(KRK_TwoArea.t2_ratio, 2), 10.0); + + // Get actual active and reactive power of generator's Terminal from Powerflow solution + Complex initApparentPower_G2 = gen2PF->getApparentPower(); + Real initMechPower_G2 = initApparentPower_G2.real(); + gen2SP->setInitialValues(initApparentPower_G2, initMechPower_G2); + + //Synchronous generator 3 + auto gen3SP = + SP::Ph1::SynchronGeneratorTrStab::make("SynGen3", Logger::Level::debug); + + // Xpd is given in p.u of generator base at transfomer primary side and should be transformed to network side + gen3SP->setStandardParametersPU( + KRK_TwoArea.nomPower_G3, KRK_TwoArea.nomPhPhVoltRMS_G3, + KRK_TwoArea.nomFreq_G3, + KRK_TwoArea.Xpd * std::pow(KRK_TwoArea.t3_ratio, 2), KRK_TwoArea.H_G3, + KRK_TwoArea.Rs * std::pow(KRK_TwoArea.t3_ratio, 2), 10.0); + + // Get actual active and reactive power of generator's Terminal from Powerflow solution + Complex initApparentPower_G3 = gen3PF->getApparentPower(); + Real initMechPower_G3 = initApparentPower_G3.real(); + gen3SP->setInitialValues(initApparentPower_G3, initMechPower_G3); + + //Synchronous generator 4 + auto gen4SP = + SP::Ph1::SynchronGeneratorTrStab::make("SynGen4", Logger::Level::debug); + + // Xpd is given in p.u of generator base at transfomer primary side and should be transformed to network side + gen4SP->setStandardParametersPU( + KRK_TwoArea.nomPower_G4, KRK_TwoArea.nomPhPhVoltRMS_G4, + KRK_TwoArea.nomFreq_G4, + KRK_TwoArea.Xpd * std::pow(KRK_TwoArea.t4_ratio, 2), KRK_TwoArea.H_G4, + KRK_TwoArea.Rs * std::pow(KRK_TwoArea.t4_ratio, 2), 10.0); + + // Get actual active and reactive power of generator's Terminal from Powerflow solution + Complex initApparentPower_G4 = gen4PF->getApparentPower(); + Real initMechPower_G4 = initApparentPower_G4.real(); + gen4SP->setInitialValues(initApparentPower_G4, initMechPower_G4); + + gen1SP->setModelFlags(true); + gen1SP->setReferenceOmega(gen3SP->attributeTyped("w_r"), + gen3SP->attributeTyped("delta_r")); + + gen2SP->setModelFlags(true); + gen2SP->setReferenceOmega(gen3SP->attributeTyped("w_r"), + gen3SP->attributeTyped("delta_r")); + + gen4SP->setModelFlags(true); + gen4SP->setReferenceOmega(gen3SP->attributeTyped("w_r"), + gen3SP->attributeTyped("delta_r")); + + ///Loads + auto load7SP = SP::Ph1::Load::make("Load7", Logger::Level::debug); + load7SP->setParameters(KRK_TwoArea.activePower_L7, + KRK_TwoArea.reactivePower_L7_inductive - + KRK_TwoArea.reactivePower_L7_capacitive, + KRK_TwoArea.Vnom); + + auto load9SP = SP::Ph1::Load::make("Load9", Logger::Level::debug); + load9SP->setParameters(KRK_TwoArea.activePower_L9, + KRK_TwoArea.reactivePower_L9_inductive - + KRK_TwoArea.reactivePower_L9_capacitive, + KRK_TwoArea.Vnom); + + //Line56 + auto line56SP = SP::Ph1::PiLine::make("PiLine56", Logger::Level::debug); + line56SP->setParameters( + KRK_TwoArea.lineResistance56, KRK_TwoArea.lineInductance56, + KRK_TwoArea.lineCapacitance56, KRK_TwoArea.lineConductance56); + + //Line67 + auto line67SP = SP::Ph1::PiLine::make("PiLine67", Logger::Level::debug); + line67SP->setParameters( + KRK_TwoArea.lineResistance67, KRK_TwoArea.lineInductance67, + KRK_TwoArea.lineCapacitance67, KRK_TwoArea.lineConductance67); + + //Line78_1 + auto line78_1SP = SP::Ph1::PiLine::make("PiLine78_1", Logger::Level::debug); + line78_1SP->setParameters( + KRK_TwoArea.lineResistance78, KRK_TwoArea.lineInductance78, + KRK_TwoArea.lineCapacitance78, KRK_TwoArea.lineConductance78); + + //Line78_2 + auto line78_2SP = SP::Ph1::PiLine::make("PiLine78_2", Logger::Level::debug); + line78_2SP->setParameters( + KRK_TwoArea.lineResistance78, KRK_TwoArea.lineInductance78, + KRK_TwoArea.lineCapacitance78, KRK_TwoArea.lineConductance78); + + //Line89_1 + auto line89_1SP = SP::Ph1::PiLine::make("PiLine89_1", Logger::Level::debug); + line89_1SP->setParameters( + KRK_TwoArea.lineResistance89, KRK_TwoArea.lineInductance89, + KRK_TwoArea.lineCapacitance89, KRK_TwoArea.lineConductance89); + + //Line89_2 + auto line89_2SP = SP::Ph1::PiLine::make("PiLine89_2", Logger::Level::debug); + line89_2SP->setParameters( + KRK_TwoArea.lineResistance89, KRK_TwoArea.lineInductance89, + KRK_TwoArea.lineCapacitance89, KRK_TwoArea.lineConductance89); + + //Line910 + auto line910SP = SP::Ph1::PiLine::make("PiLine910", Logger::Level::debug); + line910SP->setParameters( + KRK_TwoArea.lineResistance910, KRK_TwoArea.lineInductance910, + KRK_TwoArea.lineCapacitance910, KRK_TwoArea.lineConductance910); + + //Line1011 + auto line1011SP = SP::Ph1::PiLine::make("PiLine1011", Logger::Level::debug); + line1011SP->setParameters( + KRK_TwoArea.lineResistance1011, KRK_TwoArea.lineInductance1011, + KRK_TwoArea.lineCapacitance1011, KRK_TwoArea.lineConductance1011); + + // Topology + gen1SP->connect({n5SP}); + gen2SP->connect({n6SP}); + gen3SP->connect({n11SP}); + gen4SP->connect({n10SP}); + + load7SP->connect({n7SP}); + load9SP->connect({n9SP}); + + line56SP->connect({n5SP, n6SP}); + line67SP->connect({n6SP, n7SP}); + line78_1SP->connect({n7SP, n8SP}); + line78_2SP->connect({n7SP, n8SP}); + line89_1SP->connect({n8SP, n9SP}); + line89_2SP->connect({n8SP, n9SP}); + line910SP->connect({n9SP, n10SP}); + line1011SP->connect({n10SP, n11SP}); + + auto systemSP = SystemTopology( + 60, SystemNodeList{n5SP, n6SP, n7SP, n8SP, n9SP, n10SP, n11SP}, + SystemComponentList{gen1SP, gen2SP, gen3SP, gen4SP, load7SP, load9SP, + line56SP, line67SP, line78_1SP, line78_2SP, + line89_1SP, line89_2SP, line910SP, line1011SP}); + + // Initialization of dynamic topology + systemSP.initWithPowerflow(systemPF, CPS::Domain::SP); + + // Logging + auto loggerSP = DataLogger::make(simNameSP); + loggerSP->logAttribute("v5", n5SP->attribute("v")); + loggerSP->logAttribute("v6", n6SP->attribute("v")); + loggerSP->logAttribute("v7", n7SP->attribute("v")); + loggerSP->logAttribute("v8", n8SP->attribute("v")); + loggerSP->logAttribute("v9", n9SP->attribute("v")); + loggerSP->logAttribute("v10", n10SP->attribute("v")); + loggerSP->logAttribute("v11", n11SP->attribute("v")); + loggerSP->logAttribute("v_line56", line56SP->attribute("v_intf")); + loggerSP->logAttribute("i_line56", line56SP->attribute("i_intf")); + loggerSP->logAttribute("v_line67", line67SP->attribute("v_intf")); + loggerSP->logAttribute("i_line67", line67SP->attribute("i_intf")); + loggerSP->logAttribute("v_line78_1", line78_1SP->attribute("v_intf")); + loggerSP->logAttribute("i_line78_1", line78_1SP->attribute("i_intf")); + loggerSP->logAttribute("v_line78_2", line78_2SP->attribute("v_intf")); + loggerSP->logAttribute("i_line78_2", line78_2SP->attribute("i_intf")); + loggerSP->logAttribute("v_line89_1", line89_1SP->attribute("v_intf")); + loggerSP->logAttribute("i_line89_1", line89_1SP->attribute("i_intf")); + loggerSP->logAttribute("v_line89_2", line89_2SP->attribute("v_intf")); + loggerSP->logAttribute("i_line89_2", line89_2SP->attribute("i_intf")); + loggerSP->logAttribute("v_line910", line910SP->attribute("v_intf")); + loggerSP->logAttribute("i_line910", line910SP->attribute("i_intf")); + loggerSP->logAttribute("v_line1011", line1011SP->attribute("v_intf")); + loggerSP->logAttribute("i_line1011", line1011SP->attribute("i_intf")); + loggerSP->logAttribute("Ep_gen1", gen1SP->attribute("Ep_mag")); + loggerSP->logAttribute("v_gen1", gen1SP->attribute("v_intf")); + loggerSP->logAttribute("i_gen1", gen1SP->attribute("i_intf")); + loggerSP->logAttribute("wr_gen1", gen1SP->attribute("w_r")); + loggerSP->logAttribute("wref_gen1", gen1SP->attribute("w_ref")); + loggerSP->logAttribute("delta_gen1", gen1SP->attribute("delta_r")); + loggerSP->logAttribute("deltaref_gen1", gen1SP->attribute("delta_ref")); + loggerSP->logAttribute("Ep_gen2", gen2SP->attribute("Ep_mag")); + loggerSP->logAttribute("v_gen2", gen2SP->attribute("v_intf")); + loggerSP->logAttribute("i_gen2", gen2SP->attribute("i_intf")); + loggerSP->logAttribute("wr_gen2", gen2SP->attribute("w_r")); + loggerSP->logAttribute("wref_gen2", gen2SP->attribute("w_ref")); + loggerSP->logAttribute("delta_gen2", gen2SP->attribute("delta_r")); + loggerSP->logAttribute("deltaref_gen2", gen2SP->attribute("delta_ref")); + loggerSP->logAttribute("Ep_gen3", gen3SP->attribute("Ep_mag")); + loggerSP->logAttribute("v_gen3", gen3SP->attribute("v_intf")); + loggerSP->logAttribute("i_gen3", gen3SP->attribute("i_intf")); + loggerSP->logAttribute("wr_gen3", gen3SP->attribute("w_r")); + loggerSP->logAttribute("delta_gen3", gen3SP->attribute("delta_r")); + loggerSP->logAttribute("Ep_gen4", gen4SP->attribute("Ep_mag")); + loggerSP->logAttribute("v_gen4", gen4SP->attribute("v_intf")); + loggerSP->logAttribute("i_gen4", gen4SP->attribute("i_intf")); + loggerSP->logAttribute("wr_gen4", gen4SP->attribute("w_r")); + loggerSP->logAttribute("wref_gen2", gen2SP->attribute("w_ref")); + loggerSP->logAttribute("delta_gen4", gen4SP->attribute("delta_r")); + loggerSP->logAttribute("deltaref_gen4", gen4SP->attribute("delta_ref")); + loggerSP->logAttribute("v_load7", load7SP->attribute("v_intf")); + loggerSP->logAttribute("i_load7", load7SP->attribute("i_intf")); + loggerSP->logAttribute("v_load9", load9SP->attribute("v_intf")); + loggerSP->logAttribute("i_load9", load9SP->attribute("i_intf")); + loggerSP->logAttribute("P_mech1", gen1SP->attribute("P_mech")); + loggerSP->logAttribute("P_mech2", gen2SP->attribute("P_mech")); + loggerSP->logAttribute("P_elec1", gen1SP->attribute("P_elec")); + loggerSP->logAttribute("P_elec2", gen2SP->attribute("P_elec")); + loggerSP->logAttribute("P_mech3", gen3SP->attribute("P_mech")); + loggerSP->logAttribute("P_mech4", gen4SP->attribute("P_mech")); + loggerSP->logAttribute("P_elec3", gen3SP->attribute("P_elec")); + loggerSP->logAttribute("P_elec4", gen4SP->attribute("P_elec")); + + Simulation simSP(simNameSP, Logger::Level::debug); + simSP.setSystem(systemSP); + simSP.setTimeStep(timeStep); + simSP.setFinalTime(finalTime); + simSP.setDomain(Domain::SP); + simSP.addLogger(loggerSP); + + simSP.run(); +} + +int main(int argc, char *argv[]) { + + //Simulation parameters + String simName = "SP_SynGenTrStab_KRK_TwoArea_SteadyState"; + Real finalTime = 1.0; + Real timeStep = 0.001; + Real cmdInertia_G1 = KRK_TwoArea.H_G1; + Real cmdInertia_G2 = KRK_TwoArea.H_G2; + Real cmdInertia_G3 = KRK_TwoArea.H_G3; + Real cmdInertia_G4 = KRK_TwoArea.H_G4; + Real cmdDamping_G1 = 1.0; + Real cmdDamping_G2 = 1.0; + Real cmdDamping_G3 = 1.0; + Real cmdDamping_G4 = 1.0; + + CommandLineArgs args(argc, argv); + if (argc > 1) { + timeStep = args.timeStep; + finalTime = args.duration; + if (args.name != "dpsim") + simName = args.name; + if (args.options.find("SCALEINERTIA_G1") != args.options.end()) + cmdInertia_G1 = args.getOptionReal("SCALEINERTIA_G1"); + if (args.options.find("SCALEINERTIA_G2") != args.options.end()) + cmdInertia_G2 = args.getOptionReal("SCALEINERTIA_G2"); + if (args.options.find("SCALEINERTIA_G3") != args.options.end()) + cmdInertia_G3 = args.getOptionReal("SCALEINERTIA_G3"); + if (args.options.find("SCALEINERTIA_G4") != args.options.end()) + cmdInertia_G4 = args.getOptionReal("SCALEINERTIA_G4"); + if (args.options.find("SCALEDAMPING_G1") != args.options.end()) + cmdDamping_G1 = args.getOptionReal("SCALEDAMPING_G1"); + if (args.options.find("SCALEDAMPING_G2") != args.options.end()) + cmdDamping_G2 = args.getOptionReal("SCALEDAMPING_G2"); + if (args.options.find("SCALEDAMPING_G3") != args.options.end()) + cmdDamping_G3 = args.getOptionReal("SCALEDAMPING_G3"); + if (args.options.find("SCALEDAMPING_G4") != args.options.end()) + cmdDamping_G4 = args.getOptionReal("SCALEDAMPING_G4"); + } + + SP_SynGenTrStab_KRK_TwoArea_SteadyState( + simName, timeStep, finalTime, cmdInertia_G1, cmdInertia_G2, cmdInertia_G3, + cmdInertia_G4, cmdDamping_G1, cmdDamping_G2, cmdDamping_G3, + cmdDamping_G4); +} diff --git a/dpsim/examples/cxx/Examples.h b/dpsim/examples/cxx/Examples.h index 95857de15b..737a2a3b5f 100644 --- a/dpsim/examples/cxx/Examples.h +++ b/dpsim/examples/cxx/Examples.h @@ -482,6 +482,144 @@ struct ScenarioConfig { }; } // namespace ThreeBus +namespace KRK_TwoArea { +struct ScenarioConfig { + + //-----------Network-----------// + Real Vnom = 230e3; + Real nomFreq = 60; + Real nomOmega = nomFreq * 2 * PI; + Real nomFieldCurr = 1300; + Int poleNum = 2; + + // Dynamic simulation, operational parameters for all the generators + Real Rs = 0.0025; + Real Ld = 1.8; + Real Lq = 1.7; + Real Ld_t = 0.3; + Real Lq_t = 0.5500; + Real Ld_s = 0.2500; + Real Lq_s = 0.2500; + Real Ll = 0.2; + Real Td0_t = 8.0; + Real Tq0_t = 0.45; + Real Td0_s = 0.0300; + Real Tq0_s = 0.05; + + // Dynamic simulation, fundamental parameters for all the generators + Real L_ad = 1.6; + Real L_aq = 1.5; + Real L_fd = 0.10655; + Real R_fd = 0.00056; + Real L_1d = 0.10010; + Real R_1d = 0.01768; + Real L_1q = 0.45652; + Real R_1q = 0.01153; + Real L_2q = 0.05833; + Real R_2q = 0.02166; + + // Additional parameters for the classical model + Real Xpd = 0.3; + + //-----------Generator 1 (bus1)-----------// + Real nomPower_G1 = 900e6; + Real nomPhPhVoltRMS_G1 = 20e3; + Real nomFreq_G1 = 60; + Real H_G1 = 6.5; + // Initialization parameters + Real initActivePower_G1 = 700e6; + Real initMechPower_G1 = 7006; + Real initReactivePower_G1 = 185e6; + Real setPointVoltage_G1 = nomPhPhVoltRMS_G1 + 0.03 * nomPhPhVoltRMS_G1; + + //-----------Generator 2 (bus2)-----------// + Real nomPower_G2 = 900e6; + Real nomPhPhVoltRMS_G2 = 20e3; + Real nomFreq_G2 = 60; + Real H_G2 = 6.5; + // Initialization parameters + Real initActivePower_G2 = 700e6; + Real initMechPower_G2 = 700e6; + Real initReactivePower_G2 = 235e6; + Real setPointVoltage_G2 = nomPhPhVoltRMS_G2 + 0.01 * nomPhPhVoltRMS_G2; + + //-----------Generator 3 (bus3)-----------// + Real nomPower_G3 = 900e6; + Real nomPhPhVoltRMS_G3 = 20e3; + Real nomFreq_G3 = 60; + Real H_G3 = 6.175; + // Initialization parameters + Real initActivePower_G3 = 719e6; + Real initMechPower_G3 = 719e6; + Real initReactivePower_G3 = 176e6; + Real setPointVoltage_G3 = nomPhPhVoltRMS_G3 + 0.03 * nomPhPhVoltRMS_G3; + + //-----------Generator 4 (bus4)-----------// + Real nomPower_G4 = 900e6; + Real nomPhPhVoltRMS_G4 = 20e3; + Real nomFreq_G4 = 60; + Real H_G4 = 6.175; + // Initialization parameters + Real initActivePower_G4 = 700e6; + Real initMechPower_G4 = 700e6; + Real initReactivePower_G4 = 202e6; + Real setPointVoltage_G4 = nomPhPhVoltRMS_G4 + 0.01 * nomPhPhVoltRMS_G4; + + //-----------Transformers-----------// + Real t1_ratio = Vnom / nomPhPhVoltRMS_G1; + Real t2_ratio = Vnom / nomPhPhVoltRMS_G2; + Real t3_ratio = Vnom / nomPhPhVoltRMS_G3; + Real t4_ratio = Vnom / nomPhPhVoltRMS_G4; + Real transformerInductance = 0.15 * std::pow(t1_ratio, 2); + + //-----------Load (bus7 and bus9)----------- + Real activePower_L7 = 967e6; + Real reactivePower_L7_inductive = 100e6; + Real reactivePower_L7_capacitive = 200e6; + + Real activePower_L9 = 1767e6; + Real reactivePower_L9_inductive = 100e6; + Real reactivePower_L9_capacitive = 350e6; + + // -----------Transmission Lines-----------// + Real r = 0.0529; + Real x = 0.529; + Real b = 3.308e-6; + Real g = 0; + + //line 5-6 (25km) + Real lineResistance56 = r * 25; + Real lineInductance56 = (x / nomOmega) * 25; + Real lineCapacitance56 = (b / nomOmega) * 25; + Real lineConductance56 = 0; + //line 6-7 (10km) + Real lineResistance67 = r * 10; + Real lineInductance67 = (x / nomOmega) * 10; + Real lineCapacitance67 = (b / nomOmega) * 10; + Real lineConductance67 = 0; + //line 7-8 (110km) + Real lineResistance78 = r * 110; + Real lineInductance78 = (x / nomOmega) * 110; + Real lineCapacitance78 = (b / nomOmega) * 110; + Real lineConductance78 = 0; + //line 8-9 (110km) + Real lineResistance89 = r * 110; + Real lineInductance89 = (x / nomOmega) * 110; + Real lineCapacitance89 = (b / nomOmega) * 110; + Real lineConductance89 = 0; + //line 9-10 (10km) + Real lineResistance910 = r * 10; + Real lineInductance910 = (x / nomOmega) * 10; + Real lineCapacitance910 = (b / nomOmega) * 10; + Real lineConductance910 = 0; + //line 10-11 (25km) + Real lineResistance1011 = r * 25; + Real lineInductance1011 = (x / nomOmega) * 25; + Real lineCapacitance1011 = (b / nomOmega) * 25; + Real lineConductance1011 = 0; +}; +} // namespace KRK_TwoArea + namespace SGIB { struct ScenarioConfig { diff --git a/examples/Notebooks/Circuits/SP_SynGenTrStab_KRK_TwoAreaTrafo_SteadyState.ipynb b/examples/Notebooks/Circuits/SP_SynGenTrStab_KRK_TwoAreaTrafo_SteadyState.ipynb new file mode 100644 index 0000000000..aa6e4418c5 --- /dev/null +++ b/examples/Notebooks/Circuits/SP_SynGenTrStab_KRK_TwoAreaTrafo_SteadyState.ipynb @@ -0,0 +1,843 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# KRK Fault SP vs DP" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run C++ examples" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "TOP=${TOP:-$(git rev-parse --show-toplevel)}\n", + "PATH=${TOP}/build/dpsim/examples/cxx\n", + "\n", + "#1ms simulation\n", + "DURATION=20\n", + "TIMESTEP=1e-3\n", + "\n", + "SP_SynGenTrStab_KRK_TwoAreaTrafo_SteadyState -t ${TIMESTEP} -d ${DURATION}" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Read results\n", + "import villas.dataprocessing.readtools as rt\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "from collections import defaultdict\n", + "\n", + "# %matplotlib widget" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "V_nom = 230e3\n", + "V_nom_gen = 20e3\n", + "\n", + "work_dir = \"logs/SP_SynGenTrStab_KRK_TwoAreaTrafo_SteadyState_PF/\"\n", + "log_name = \"SP_SynGenTrStab_KRK_TwoAreaTrafo_SteadyState_PF\"\n", + "\n", + "print(work_dir + log_name + \".csv\")\n", + "\n", + "ts_pfsimpy = rt.read_timeseries_dpsim(work_dir + log_name + \".csv\")\n", + "\n", + "results = pd.DataFrame(\n", + " columns=[\"Bus\", \"V Mag. [V]\", \"V rel Ang. [deg]\", \"V Ang. [deg]\", \"P\", \"Q\"]\n", + ")\n", + "\n", + "s_prefix = \"s_\"\n", + "v_prefix = \"v_\"\n", + "mv_nodes = [\"v_bus1\", \"v_bus2\", \"v_bus3\", \"v_bus4\"]\n", + "\n", + "vble_result_columns_abs = defaultdict(lambda: [0, 0, 0, 0, 0])\n", + "for column in ts_pfsimpy.keys():\n", + " if column.startswith(v_prefix):\n", + " column_base = column.replace(v_prefix, \"\")\n", + " if column in mv_nodes:\n", + " vble_result_columns_abs[column_base][0] = \"{0:.2f}\".format(\n", + " np.absolute(ts_pfsimpy[column].values[-1]) / V_nom_gen\n", + " )\n", + " else:\n", + " vble_result_columns_abs[column_base][0] = \"{0:.2f}\".format(\n", + " np.absolute(ts_pfsimpy[column].values[-1]) / V_nom\n", + " )\n", + " vble_result_columns_abs[column_base][1] = \"{0:.2f}\".format(\n", + " np.degrees(np.angle(ts_pfsimpy[column].values[-1]))\n", + " )\n", + " vble_result_columns_abs[column_base][2] = \"{0:.2f}\".format(\n", + " np.degrees(np.angle(ts_pfsimpy[column].values[-1])) - 6.8\n", + " )\n", + " else:\n", + " column_base = column.replace(s_prefix, \"\")\n", + " vble_result_columns_abs[column_base][3] = \"{0:.2e}\".format(\n", + " np.real(ts_pfsimpy[column].values[-1])\n", + " )\n", + " vble_result_columns_abs[column_base][4] = \"{0:.2e}\".format(\n", + " np.imag(ts_pfsimpy[column].values[-1])\n", + " )\n", + "\n", + "i = 0\n", + "for node, node_data in vble_result_columns_abs.items():\n", + " results.loc[i] = [node] + node_data\n", + " i += 1\n", + "\n", + "print(results)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Results 1ph SP" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "work_dir = \"logs/SP_SynGenTrStab_KRK_TwoAreaTrafo_SteadyState_SP/\"\n", + "log_name = \"SP_SynGenTrStab_KRK_TwoAreaTrafo_SteadyState_SP\"\n", + "print(work_dir + log_name + \".csv\")\n", + "ts_sp1ph_TrStab_dl = rt.read_timeseries_dpsim(work_dir + log_name + \".csv\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "timestep = 50e-6\n", + "t_begin = 0\n", + "t_end = 20\n", + "\n", + "begin_idx = int(t_begin / timestep)\n", + "end_idx = int(t_end / timestep)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generator terminal voltage" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.subplot(2, 2, 1)\n", + "for name in [\"v_trafo15\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"N5\",\n", + " )\n", + "for name in [\"v_gen1\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"N1\",\n", + " )\n", + "plt.legend(loc=\"lower right\")\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"voltage (kV)\")\n", + "plt.title(\"Gen. 1\")\n", + "\n", + "plt.subplot(2, 2, 2)\n", + "for name in [\"v_trafo26\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"N6\",\n", + " )\n", + "for name in [\"v_gen2\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"N2\",\n", + " )\n", + "plt.legend(loc=\"lower right\")\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"voltage (kV)\")\n", + "plt.title(\"Gen. 2\")\n", + "\n", + "plt.subplot(2, 2, 3)\n", + "for name in [\"v_trafo311\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"N11\",\n", + " )\n", + "for name in [\"v_gen3\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"N3\",\n", + " )\n", + "plt.legend(loc=\"lower right\")\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"voltage (kV)\")\n", + "plt.title(\"Gen. 3\")\n", + "\n", + "plt.subplot(2, 2, 4)\n", + "for name in [\"v_trafo410\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"N10\",\n", + " )\n", + "for name in [\"v_gen4\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"N4\",\n", + " )\n", + "plt.legend(loc=\"lower right\")\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"voltage (kV)\")\n", + "plt.title(\"Gen. 4\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generator terminal Current" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure()\n", + "\n", + "plt.subplot(2, 2, 1)\n", + "for name in [\"i_gen1\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"N1\",\n", + " )\n", + "for name in [\"i_trafo15\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"N5\",\n", + " )\n", + "plt.legend(loc=\"lower right\")\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"current (kA)\")\n", + "plt.title(\"Gen. 1\")\n", + "\n", + "plt.subplot(2, 2, 2)\n", + "for name in [\"i_gen2\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"N2\",\n", + " )\n", + "for name in [\"i_trafo26\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"N6\",\n", + " )\n", + "plt.legend(loc=\"lower right\")\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"current (kA)\")\n", + "plt.title(\"Gen. 2\")\n", + "\n", + "plt.subplot(2, 2, 3)\n", + "for name in [\"i_gen3\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"N3\",\n", + " )\n", + "for name in [\"i_trafo311\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"N11\",\n", + " )\n", + "plt.legend(loc=\"lower right\")\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"current (kA)\")\n", + "plt.title(\"Gen. 3\")\n", + "\n", + "plt.subplot(2, 2, 4)\n", + "for name in [\"i_gen4\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"N4\",\n", + " )\n", + "for name in [\"i_trafo410\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"N10\",\n", + " )\n", + "plt.legend(loc=\"lower right\")\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"current (kA)\")\n", + "plt.title(\"Gen. 4\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure()\n", + "\n", + "plt.subplot(2, 2, 1)\n", + "for name in [\"i_line56\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"i line 56\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"current (kA)\")\n", + "plt.title(\"i line 56\")\n", + "\n", + "plt.subplot(2, 2, 2)\n", + "for name in [\"i_line67\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"i line 67\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"current (kA)\")\n", + "plt.title(\"i line 67\")\n", + "\n", + "plt.subplot(2, 2, 3)\n", + "for name in [\"i_line1011\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"i line 1011\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"current (kA)\")\n", + "plt.title(\"i line 1011\")\n", + "\n", + "plt.subplot(2, 2, 4)\n", + "for name in [\"i_line910\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"i line 910\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"current (kA)\")\n", + "plt.title(\"i line 910\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure()\n", + "plt.subplot(1, 2, 1)\n", + "for name in [\"i_line78_1\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"i line 78_1\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"current (kA)\")\n", + "plt.title(\"i line 78_1\")\n", + "\n", + "plt.subplot(1, 2, 2)\n", + "for name in [\"i_line89_1\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"i line 89_1\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"current (kA)\")\n", + "plt.title(\"i line 89_1\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generator electrical & mechanical energy" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure()\n", + "\n", + "plt.subplot(2, 2, 1)\n", + "for name in [\"P_elec1\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-6 * ts_sp1ph_TrStab_dl[name].interpolate(timestep).values[begin_idx:end_idx],\n", + " label=\"P_elec G1\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"power (MW)\")\n", + "plt.title(\"P_elec G1\")\n", + "\n", + "plt.subplot(2, 2, 2)\n", + "for name in [\"P_elec2\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-6 * ts_sp1ph_TrStab_dl[name].interpolate(timestep).values[begin_idx:end_idx],\n", + " label=\"P_elec G2\",\n", + " )\n", + "\n", + "# plt.legend(loc='lower right')\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"power (MW)\")\n", + "plt.title(\"P_elec G2\")\n", + "\n", + "plt.subplot(2, 2, 3)\n", + "for name in [\"P_elec3\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-6 * ts_sp1ph_TrStab_dl[name].interpolate(timestep).values[begin_idx:end_idx],\n", + " label=\"P_elec G3\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"power (MW)\")\n", + "plt.title(\"P_elec G3\")\n", + "\n", + "plt.subplot(2, 2, 4)\n", + "for name in [\"P_elec4\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-6 * ts_sp1ph_TrStab_dl[name].interpolate(timestep).values[begin_idx:end_idx],\n", + " label=\"P_elec G4\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"power (MW)\")\n", + "plt.title(\"P_elec G4\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Rotor angular speed $\\omega_r$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure()\n", + "\n", + "plt.subplot(2, 2, 1)\n", + "for name in [\"wr_gen1\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).values[begin_idx:end_idx]\n", + " * 60\n", + " / 377,\n", + " label=\"G1\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"Frequency (Hz)\")\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.title(\"$\\omega_{r,1}$\")\n", + "\n", + "plt.subplot(2, 2, 2)\n", + "for name in [\"wr_gen2\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).values[begin_idx:end_idx]\n", + " * 60\n", + " / 377,\n", + " label=\"G2\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"Frequency (Hz)\")\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.title(\"$\\omega_{r,2}$\")\n", + "\n", + "plt.subplot(2, 2, 3)\n", + "for name in [\"wr_gen3\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).values[begin_idx:end_idx]\n", + " * 60\n", + " / 377,\n", + " label=\"G3\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"Frequency (Hz)\")\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.title(\"$\\omega_{r,3}$\")\n", + "\n", + "plt.subplot(2, 2, 4)\n", + "for name in [\"wr_gen4\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).values[begin_idx:end_idx]\n", + " * 60\n", + " / 377,\n", + " label=\"G4\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"Frequency (Hz)\")\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.title(\"$\\omega_{r,4}$\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Rotor angle $\\delta _r$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure()\n", + "\n", + "plt.subplot(2, 2, 1)\n", + "for name in [\"delta_gen1\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).values[begin_idx:end_idx]\n", + " * 180\n", + " / 3.14\n", + " - ts_sp1ph_TrStab_dl[\"deltaref_gen1\"]\n", + " .interpolate(timestep)\n", + " .values[begin_idx:end_idx]\n", + " * 180\n", + " / 3.14,\n", + " label=\"SP\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"angle (°)\")\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.title(\"$\\delta_1$\")\n", + "\n", + "plt.subplot(2, 2, 2)\n", + "for name in [\"delta_gen2\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).values[begin_idx:end_idx]\n", + " * 180\n", + " / 3.14\n", + " - ts_sp1ph_TrStab_dl[\"deltaref_gen2\"]\n", + " .interpolate(timestep)\n", + " .values[begin_idx:end_idx]\n", + " * 180\n", + " / 3.14,\n", + " label=\"SP\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"angle (°)\")\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.title(\"$\\delta_2$\")\n", + "\n", + "plt.subplot(2, 2, 3)\n", + "for name in [\"delta_gen3\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).values[begin_idx:end_idx]\n", + " * 180\n", + " / 3.14\n", + " - ts_sp1ph_TrStab_dl[\"delta_gen3\"]\n", + " .interpolate(timestep)\n", + " .values[begin_idx:end_idx]\n", + " * 180\n", + " / 3.14,\n", + " label=\"SP\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"angle (°)\")\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.title(\"$\\delta_3$\")\n", + "\n", + "plt.subplot(2, 2, 4)\n", + "for name in [\"delta_gen4\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).values[begin_idx:end_idx]\n", + " * 180\n", + " / 3.14\n", + " - ts_sp1ph_TrStab_dl[\"deltaref_gen4\"]\n", + " .interpolate(timestep)\n", + " .values[begin_idx:end_idx]\n", + " * 180\n", + " / 3.14,\n", + " label=\"SP\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"angle (°)\")\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.title(\"$\\delta_4$\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "power_line3 = (\n", + " np.conjugate(ts_sp1ph_TrStab_dl[\"i_line78_1\"].interpolate(timestep).values)\n", + " * ts_sp1ph_TrStab_dl[\"v7\"].interpolate(timestep).values\n", + ")\n", + "power_line4 = (\n", + " np.conjugate(ts_sp1ph_TrStab_dl[\"i_line78_2\"].interpolate(timestep).values)\n", + " * ts_sp1ph_TrStab_dl[\"v7\"].interpolate(timestep).values\n", + ")\n", + "power_line5 = (\n", + " np.conjugate(ts_sp1ph_TrStab_dl[\"i_line89_1\"].interpolate(timestep).values)\n", + " * ts_sp1ph_TrStab_dl[\"v8\"].interpolate(timestep).values\n", + ")\n", + "power_line6 = (\n", + " np.conjugate(ts_sp1ph_TrStab_dl[\"i_line89_2\"].interpolate(timestep).values)\n", + " * ts_sp1ph_TrStab_dl[\"v8\"].interpolate(timestep).values\n", + ")\n", + "\n", + "plt.figure()\n", + "plt.plot(\n", + " ts_sp1ph_TrStab_dl[\"i_line78_1\"].interpolate(timestep).time,\n", + " (power_line3 + power_line4) * 1e-6,\n", + ")\n", + "plt.plot(\n", + " ts_sp1ph_TrStab_dl[\"i_line89_1\"].interpolate(timestep).time,\n", + " (power_line5 + power_line6) * 1e-6,\n", + ")\n", + "plt.xlabel(\"time [s]\")\n", + "plt.ylabel(\"Power [MW]\")\n", + "plt.grid()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.9" + }, + "tests": { + "skip": true + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/Notebooks/Circuits/SP_SynGenTrStab_KRK_TwoArea_SteadyState.ipynb b/examples/Notebooks/Circuits/SP_SynGenTrStab_KRK_TwoArea_SteadyState.ipynb new file mode 100644 index 0000000000..62016b9b7b --- /dev/null +++ b/examples/Notebooks/Circuits/SP_SynGenTrStab_KRK_TwoArea_SteadyState.ipynb @@ -0,0 +1,1064 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# KRK Fault SP vs DP" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run C++ examples" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[15:08:30.871899 PiLine56 warning] Zero value for Conductance, setting default value of G=1e-06 [S]\n", + "[15:08:30.872079 PiLine67 warning] Zero value for Conductance, setting default value of G=1e-06 [S]\n", + "[15:08:30.872193 Piline78_1 warning] Zero value for Conductance, setting default value of G=1e-06 [S]\n", + "[15:08:30.872310 Piline78_2 warning] Zero value for Conductance, setting default value of G=1e-06 [S]\n", + "[15:08:30.872417 Piline89_1 warning] Zero value for Conductance, setting default value of G=1e-06 [S]\n", + "[15:08:30.872526 Piline89_2 warning] Zero value for Conductance, setting default value of G=1e-06 [S]\n", + "[15:08:30.872638 PiLine910 warning] Zero value for Conductance, setting default value of G=1e-06 [S]\n", + "[15:08:30.872752 PiLine1011 warning] Zero value for Conductance, setting default value of G=1e-06 [S]\n", + "[15:08:30.873285 SP_SynGenTrStab_KRK_TwoArea_SteadyState_PF info] Initialize simulation: SP_SynGenTrStab_KRK_TwoArea_SteadyState_PF\n", + "[15:08:30.873916 SP_SynGenTrStab_KRK_TwoArea_SteadyState_PF info] Scheduling tasks.\n", + "[15:08:30.874286 SP_SynGenTrStab_KRK_TwoArea_SteadyState_PF info] Scheduling done.\n", + "[15:08:30.874341 SP_SynGenTrStab_KRK_TwoArea_SteadyState_PF info] Opening interfaces.\n", + "[15:08:30.874344 SP_SynGenTrStab_KRK_TwoArea_SteadyState_PF info] Start synchronization with remotes on interfaces\n", + "[15:08:30.874346 SP_SynGenTrStab_KRK_TwoArea_SteadyState_PF info] Synchronized simulation start with remotes\n", + "[15:08:30.874349 SP_SynGenTrStab_KRK_TwoArea_SteadyState_PF info] Start simulation: SP_SynGenTrStab_KRK_TwoArea_SteadyState_PF\n", + "[15:08:30.874353 SP_SynGenTrStab_KRK_TwoArea_SteadyState_PF info] Time step: 2.000000e+01\n", + "[15:08:30.874355 SP_SynGenTrStab_KRK_TwoArea_SteadyState_PF info] Final time: 4.000000e+01\n", + "[15:08:30.881143 SP_SynGenTrStab_KRK_TwoArea_SteadyState_PF info] Simulation calculation time: 0.006782\n", + "[15:08:30.881235 SP_SynGenTrStab_KRK_TwoArea_SteadyState_PF info] Simulation finished.\n", + "[15:08:30.882305 PiLine56 warning] Zero value for Conductance, setting default value of G=1e-06 [S]\n", + "[15:08:30.882424 PiLine67 warning] Zero value for Conductance, setting default value of G=1e-06 [S]\n", + "[15:08:30.882541 PiLine78_1 warning] Zero value for Conductance, setting default value of G=1e-06 [S]\n", + "[15:08:30.882659 PiLine78_2 warning] Zero value for Conductance, setting default value of G=1e-06 [S]\n", + "[15:08:30.882767 PiLine89_1 warning] Zero value for Conductance, setting default value of G=1e-06 [S]\n", + "[15:08:30.882878 PiLine89_2 warning] Zero value for Conductance, setting default value of G=1e-06 [S]\n", + "[15:08:30.882996 PiLine910 warning] Zero value for Conductance, setting default value of G=1e-06 [S]\n", + "[15:08:30.883110 PiLine1011 warning] Zero value for Conductance, setting default value of G=1e-06 [S]\n", + "[15:08:30.884037 SP_SynGenTrStab_KRK_TwoArea_SteadyState_SP info] Initialize simulation: SP_SynGenTrStab_KRK_TwoArea_SteadyState_SP\n", + "[15:08:30.884184 MnaSolverFactory info] creating KLUAdapter solver implementation\n", + "[15:08:30.892813 SP_SynGenTrStab_KRK_TwoArea_SteadyState_SP info] Scheduling tasks.\n", + "[15:08:30.894468 SP_SynGenTrStab_KRK_TwoArea_SteadyState_SP info] Scheduling done.\n", + "[15:08:30.894797 SP_SynGenTrStab_KRK_TwoArea_SteadyState_SP info] Opening interfaces.\n", + "[15:08:30.894800 SP_SynGenTrStab_KRK_TwoArea_SteadyState_SP info] Start synchronization with remotes on interfaces\n", + "[15:08:30.894802 SP_SynGenTrStab_KRK_TwoArea_SteadyState_SP info] Synchronized simulation start with remotes\n", + "[15:08:30.894805 SP_SynGenTrStab_KRK_TwoArea_SteadyState_SP info] Start simulation: SP_SynGenTrStab_KRK_TwoArea_SteadyState_SP\n", + "[15:08:30.894808 SP_SynGenTrStab_KRK_TwoArea_SteadyState_SP info] Time step: 1.000000e-03\n", + "[15:08:30.894810 SP_SynGenTrStab_KRK_TwoArea_SteadyState_SP info] Final time: 2.000000e+01\n", + "[15:08:36.611856 SP_SynGenTrStab_KRK_TwoArea_SteadyState_SP info] Simulation calculation time: 5.716835\n", + "[15:08:36.611917 SP_SynGenTrStab_KRK_TwoArea_SteadyState_SP info] Simulation finished.\n" + ] + } + ], + "source": [ + "%%bash\n", + "TOP=${TOP:-$(git rev-parse --show-toplevel)}\n", + "PATH=${TOP}/build/dpsim/examples/cxx\n", + "\n", + "#1ms simulation\n", + "DURATION=20\n", + "TIMESTEP=1e-3\n", + "\n", + "SP_SynGenTrStab_KRK_TwoArea_SteadyState -t ${TIMESTEP} -d ${DURATION}" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Read results\n", + "import villas.dataprocessing.readtools as rt\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "from collections import defaultdict\n", + "\n", + "# %matplotlib widget" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "logs/SP_SynGenTrStab_KRK_TwoArea_SteadyState_PF/SP_SynGenTrStab_KRK_TwoArea_SteadyState_PF.csv\n", + "column number: 14\n", + "results length: 3\n", + "real column names: []\n", + "complex column names: ['s_bus10', 's_bus11', 's_bus5', 's_bus6', 's_bus7', 's_bus8', 's_bus9', 'v_bus10', 'v_bus11', 'v_bus5', 'v_bus6', 'v_bus7', 'v_bus8', 'v_bus9']\n", + " Bus V Mag. [V] V rel Ang. [deg] V Ang. [deg] P Q\n", + "0 bus10 1.01 -9.78 -16.58 7.00e+08 8.40e+07\n", + "1 bus11 1.03 0.00 -6.80 7.14e+08 6.92e+07\n", + "2 bus5 1.03 25.43 18.63 7.00e+08 6.82e+07\n", + "3 bus6 1.01 15.85 9.05 7.00e+08 1.39e+08\n", + "4 bus7 1.00 7.97 1.17 -9.67e+08 1.00e+08\n", + "5 bus8 0.98 -4.98 -11.78 5.68e-03 4.35e-02\n", + "6 bus9 1.00 -17.73 -24.53 -1.77e+09 2.50e+08\n" + ] + } + ], + "source": [ + "V_nom = 230e3\n", + "\n", + "work_dir = \"logs/SP_SynGenTrStab_KRK_TwoArea_SteadyState_PF/\"\n", + "log_name = \"SP_SynGenTrStab_KRK_TwoArea_SteadyState_PF\"\n", + "\n", + "print(work_dir + log_name + \".csv\")\n", + "\n", + "ts_pfsimpy = rt.read_timeseries_dpsim(work_dir + log_name + \".csv\")\n", + "results = pd.DataFrame(\n", + " columns=[\"Bus\", \"V Mag. [V]\", \"V rel Ang. [deg]\", \"V Ang. [deg]\", \"P\", \"Q\"]\n", + ")\n", + "\n", + "s_prefix = \"s_\"\n", + "v_prefix = \"v_\"\n", + "\n", + "vble_result_columns_abs = defaultdict(lambda: [0, 0, 0, 0, 0])\n", + "for column in ts_pfsimpy.keys():\n", + " if column.startswith(v_prefix):\n", + " column_base = column.replace(v_prefix, \"\")\n", + " vble_result_columns_abs[column_base][0] = \"{0:.2f}\".format(\n", + " np.absolute(ts_pfsimpy[column].values[-1]) / V_nom\n", + " )\n", + " vble_result_columns_abs[column_base][1] = \"{0:.2f}\".format(\n", + " np.degrees(np.angle(ts_pfsimpy[column].values[-1]))\n", + " )\n", + " vble_result_columns_abs[column_base][2] = \"{0:.2f}\".format(\n", + " np.degrees(np.angle(ts_pfsimpy[column].values[-1])) - 6.8\n", + " )\n", + " else:\n", + " column_base = column.replace(s_prefix, \"\")\n", + " vble_result_columns_abs[column_base][3] = \"{0:.2e}\".format(\n", + " np.real(ts_pfsimpy[column].values[-1])\n", + " )\n", + " vble_result_columns_abs[column_base][4] = \"{0:.2e}\".format(\n", + " np.imag(ts_pfsimpy[column].values[-1])\n", + " )\n", + "\n", + "i = 0\n", + "for node, node_data in vble_result_columns_abs.items():\n", + " results.loc[i] = [node] + node_data\n", + " i += 1\n", + "\n", + "print(results)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Results 1ph SP" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "logs/SP_SynGenTrStab_KRK_TwoArea_SteadyState_SP/SP_SynGenTrStab_KRK_TwoArea_SteadyState_SP.csv\n", + "column number: 60\n", + "results length: 20000\n", + "real column names: ['Ep_gen1', 'Ep_gen2', 'Ep_gen3', 'Ep_gen4', 'P_elec1', 'P_elec2', 'P_elec3', 'P_elec4', 'P_mech1', 'P_mech2', 'P_mech3', 'P_mech4', 'delta_gen1', 'delta_gen2', 'delta_gen3', 'delta_gen4', 'deltaref_gen1', 'deltaref_gen2', 'deltaref_gen4', 'wr_gen1', 'wr_gen2', 'wr_gen3', 'wr_gen4', 'wref_gen1', 'wref_gen2']\n", + "complex column names: ['i_gen1', 'i_gen2', 'i_gen3', 'i_gen4', 'i_line1011', 'i_line56', 'i_line67', 'i_line78_1', 'i_line78_2', 'i_line89_1', 'i_line89_2', 'i_line910', 'i_load7', 'i_load9', 'v10', 'v11', 'v5', 'v6', 'v7', 'v8', 'v9', 'v_gen1', 'v_gen2', 'v_gen3', 'v_gen4', 'v_line1011', 'v_line56', 'v_line67', 'v_line78_1', 'v_line78_2', 'v_line89_1', 'v_line89_2', 'v_line910', 'v_load7', 'v_load9']\n" + ] + } + ], + "source": [ + "work_dir = \"logs/SP_SynGenTrStab_KRK_TwoArea_SteadyState_SP/\"\n", + "log_name = \"SP_SynGenTrStab_KRK_TwoArea_SteadyState_SP\"\n", + "print(work_dir + log_name + \".csv\")\n", + "ts_sp1ph_TrStab_dl = rt.read_timeseries_dpsim(work_dir + log_name + \".csv\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "timestep = 50e-6\n", + "t_begin = 0\n", + "t_end = 20\n", + "\n", + "begin_idx = int(t_begin / timestep)\n", + "end_idx = int(t_end / timestep)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generator terminal voltage" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Gen. 4')" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "\n", + "plt.subplot(2, 2, 1)\n", + "for name in [\"v_gen1\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"G1\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"voltage (kV)\")\n", + "plt.title(\"Gen. 1\")\n", + "\n", + "plt.subplot(2, 2, 2)\n", + "for name in [\"v_gen2\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"G2\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"voltage (kV)\")\n", + "plt.title(\"Gen. 2\")\n", + "\n", + "plt.subplot(2, 2, 3)\n", + "for name in [\"v_gen3\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"G3\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"voltage (kV)\")\n", + "plt.title(\"Gen. 3\")\n", + "\n", + "plt.subplot(2, 2, 4)\n", + "for name in [\"v_gen4\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"G4\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"voltage (kV)\")\n", + "plt.title(\"Gen. 4\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generator terminal Current" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Gen. 4')" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnUAAAHWCAYAAAARl3+JAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAXNtJREFUeJzt3Xl8U3X+Pf6TpOmSrkB32gKFUgShIJuIOoAFinwcAUUG8AvMjDgCxUEWhWHY3HBlUAcQRcBREWZ+I8wMKBYLrawCFUEsVIotBbrRQpvSNU3u7w8hErsl5ebe5N7zfDz6GHNzk/u6yeTwuutbIwiCACIiIiJya1q5CyAiIiKi28emjoiIiEgB2NQRERERKQCbOiIiIiIFYFNHREREpABs6oiIiIgUgE0dERERkQKwqSMiIiJSADZ1RERERArApo6IiIhIAdjUkWxycnKQnJyMrl27wmAwwGAwoHv37pg1axZOnTold3k2XnrpJfz2t79FWFgYNBoNli9fLndJROTi3CXjzp49i2effRa9e/eGv78/IiIiMHr0aBw/flzu0shBGo79SnLYuXMnJkyYAA8PD0yePBkJCQnQarU4e/YsPvvsM1y4cAE5OTno0KGD3KUCADQaDcLDw5GQkIAvv/wSy5YtY2NHRE1yp4ybP38+PvjgAzzyyCMYMGAAysvLsX79euTm5mL37t1ITEyUu0SyE5s6ktz58+eRkJCAmJgYpKamIiIiwub5+vp6rF27FmPHjkV0dLRsdd4qNzcXHTt2RElJCUJCQtjUEVGT3C3jMjIyEB8fDz8/P+u00tJS3HHHHejatSsOHDgga31kPx5+Jcm99tprqKysxKZNmxqEHQB4eHjg6aefbhB2Z8+exaOPPoq2bdvC29sb/fr1w3//+1+beTZv3gyNRoODBw9i7ty5CAkJga+vL8aOHYsrV660uuaOHTu2+rVEpC7ulnF9+/a1aegAoF27drjvvvtw5syZVr0nyYNNHUlu586d6NKlCwYOHGj3a3744QfcfffdOHPmDBYuXIg333wTvr6+GDNmDLZv395g/tmzZ+PkyZNYtmwZZsyYgf/9739ITk4WeU2IiBpSSsYVFhYiODhY1Pck5/KQuwBSF6PRiPz8fIwZM6bBc2VlZaivr7c+9vX1hY+PDwDgz3/+M2JiYnDs2DF4eXkBAGbOnIl7770Xzz33HMaOHWvzXu3atUNKSgo0Gg0AwGKx4O2330Z5eTkCAwOdvJZEpFZKybj9+/fj8OHD+Otf/3rb70XS4Z46kpTRaASABrv6AWDIkCEICQmx/q1ZswYAcPXqVezduxePPfYYKioqUFJSgpKSEpSWlmLkyJE4d+4cLl++bPNeTz75pDXsAOC+++6D2WzGhQsXnL6ORKReSsi44uJiTJo0CZ06dcKzzz572+9H0uGeOpKUv78/AOD69esNnlu/fj0qKipQVFSExx9/3Do9OzsbgiBgyZIlWLJkSaPvW1xcjPbt21sfx8TE2Dzfpk0bAMC1a9dEWxciol9z94yrrKzE//3f/6GiogIHDhxotDkl18WmjiQVGBiIiIgInD59usFzN88/yc3NtZlusViAG5fdjxw5stH37dKli81jnU7X6Hy82JuInMmdM66urg7jxo3DqVOn8OWXX+LOO+9s9XuRPNjUkeRGjx6NDRs24OjRoxgwYECL88fGxgIA9Ho975dERC7PHTPOYrFgypQpSE1NxT//+U/85je/kaUOuj08p44k9+yzz8JgMOAPf/gDioqKGjz/6y3N0NBQDBkyBOvXr0dBQUGD+Vt7GX9BQQHOnj0Lk8nUqtcTETXGHTNu9uzZ2LZtG9auXYtx48a1ankkP+6pI8nFxcVhy5YtmDhxIuLj4613WxcEATk5OdiyZQu0Wi2ioqKsr1mzZg3uvfde9OzZE9OnT0dsbCyKiopw+PBhXLp0CSdPnnS4jkWLFuHDDz9ETk5Oi/eh++ijj3DhwgVUVVUBAL7++mu8+OKLAID/9//+n0vcFZ6IXIO7Zdzq1auxdu1aDBo0CAaDAR9//LHN82PHjoWvr6/DyyfpsakjWTz88MP4/vvv8eabbyIlJQUbN26ERqNBhw4dMHr0aDz11FNISEiwzt+9e3ccP34cK1aswObNm1FaWorQ0FD06dMHS5cudXq9H3zwAdLT062P9+3bh3379gEA7r33XjZ1RGTDnTLuu+++AwAcPnwYhw8fbvB8Tk4Omzo3wWHCiIiIiBSA59QRERERKQCbOiIiIiIFYFNHREREpABs6oiIiIgUgE0dERERkQKwqSMiIiJSAFXdp85isSA/Px/+/v7QaDRyl0NEIhEEARUVFYiMjIRWq85tVeYbkXLZm3Gqaury8/MRHR0tdxlE5CQXL160uUu/mjDfiJSvpYxTVVPn7+8P3PhQAgICmp3XZDIhJSUFI0aMgF6vl6hC6Sh9/aCCdeT6/cJoNCI6Otr6G1cj5pstpa8j18/9OSPjVNXU3TwkERAQYFfoGQwGBAQEKPL/UEpfP6hgHbl+Dan5sCPzzZbS15Hr5/6ckXHqPPmEiIiISGHY1BEREREpAJs6IiIiIgXQCIIgyF2EVIxGIwIDA1FeXt7iOSffX7yK360/BGg9UFlnhr+3Bypq6iWrlYiARQn1+MOjD9p1ErG9v22lcuQzqKurw5tbduOr0gCcv1LZ5HxrJt2FDw78hG/zylpV09G/PIABL6e26rWTBsZgyzd5rXptY+5sH4DTl412zRtk0KOsyiTasl1FW19PXK2sk7sMumHb9AEoPH0IDz4oXsaxqWtEjcmMbkt2S1obETXu4LO/Qfu2fs3Ow6bOsc/g4b8fwMlL5ZLVRkSNW3FXPSaNFa+p4+HXRpgtqulziVxeTknTe5KoddjQEbmGZd+KexMSNnWN0Kr4tghErqaqzix3CUREboFNHRG5NCWe20RE5Axs6hpRZ7bIXQIR3XA6376T24mI1I5NXSNMdjR1Z19IwvmXH5SkHiI149kQ4hsU21buEojICdjUtdKWb/LwY1GF3GUQETnMU8foJ1IiVY39ai97dgw8vzNTgkqISD03XZLO9/m8+pVIibi51ghvvU7uEojohs4hvnKXoDhXK3nxCZESsakjIpcW4ucldwlERG6BTR0RuTSDF/ecExHZg01dI2rreUsTIldh8GRTR0TK9HI/cceUZ1PXCC8PfixEroLD9hGRUv3lOIcJczqdljfGInIV1SYOE0ZEZA82dUTk0jhMGBGRfdjUNYLDhBG5jpOXeE81IiJ7sKlrRJ0dF0qceT4J2S+NkqQeIiIx9e/YRu4SiMgJ2NS10rd511BaWSd3GUREDjPwButEisRhwhphz2USkzd8I0ElRMRhwsR3ppDjVhMpkdvsqVu5ciX69+8Pf39/hIaGYsyYMcjKynLKsjx5SxMil9GxnUHuEhSnuKJW7hKIyAncpntJT0/HrFmzcOTIEezZswcmkwkjRoxAZWWl3KURkRMF+3nKXYIkpNxwJSJlcpvDr7t377Z5vHnzZoSGhiIjIwP333+/bHURkXP5erlNTN2Wmxuu/fv3R319Pf7yl79gxIgRyMzMhK+vr9zlEZEbcNu0LC//+TYHbdu2bXKe2tpa1Nb+cpjBaDQCAEwmE0ympu99VVXDCyCIXIXBA83+XoGWn3cH3HAlUp9X+os7TJhbNnUWiwVz5szB4MGDceeddzY538qVK7FixYoG01NSUmAwNH2eTq0Z7vrRECnON0ePovhM8/NUVVVJVY5k7NlwJSL3tvCYBx75rXjv55ady6xZs3D69GkcOHCg2fkWLVqEuXPnWh8bjUZER0djxIgRCAgIaPJ1tfUWPHv0K1FrJqLW6dWnH+7rGtrsPDf3wiuFPRuurT0SQUSuxZ7fq72/abdr6pKTk7Fz5058/fXXiIqKanZeLy8veHl5NZiu1+uh1+ubfJ1Fw7EmiVxFpUlo9veKG79pJbFnw7W1RyJ+5nbRT6RYe/bsaXEee49GuM0vWxAEzJ49G9u3b0daWho6derktGWZzLwxFpGrOH7hGh7q3fwGnJLYu+Ha2iMRAPDnwymi1kxErTd8+PAWN0ztPRrhNk3drFmzsGXLFvznP/+Bv78/CgsLAQCBgYHw8fERdVk1ppb31GU+PxKeOi26LP5C1GUTkTo5uuHa2iMRANAnOhAnLnJMXSJXYM9v1t6jEW7T1K1btw4AMGTIEJvpmzZtwrRp0ySvp/R6HYIMyjrkQ0TykXLD1d/bbaKfiBzgNr9swcXGCrrvtX1yl0BECiLlhmt2MW/aTqREDjV1ZWVl2L59O/bv348LFy6gqqoKISEh6NOnD0aOHIl77rnHeZVKSK9zm4E2iBQvqo24e6maI2fGSbnhml9eI9myiEg6dnUv+fn5eOKJJxAREYEXX3wR1dXV6N27Nx544AFERUVh3759GD58OLp3745t27Y5v2oiUo0Qv4bnjYmNGUdESmDXnro+ffpg6tSpyMjIQPfu3Rudp7q6Gjt27MDq1atx8eJFzJ8/X+xaiUiFDJ46py+DGUdESmBXU5eZmYl27do1O4+Pjw8mTpyIiRMnorS0VKz6ZGG2uNb5e0RqFujj/AuS1JZxROQaVoo8TJhdh19bCjvcuAP6zp077Z7flXnreU4dkavQaTVOX4baMo6IXMOiY+Jer3rb75adnY2NGzdi8+bNuHLliiKGp+GFEkSuo67eIuvylZhxRKRMrepeqqur8Y9//AP3338/4uPjcejQISxduhSXLl0Sv0IiUrXyaumbKGYcEbkjh/bUHTt2DBs2bMDWrVvRuXNnTJ48GYcOHcLatWubPLnYHZnM8u4ZIKJfHMm5ilG92kuyLLVkHBEpk9176nr16oXx48ejXbt2OHToEL799lvMmzcPGo3zz3eRWlVdy8OE/bBiJM69NEqSeojI+dSUcb3aNz82LBG5J7ubuqysLNx///0YOnQot1gB1FsEWFxslAsiJZKqpVJTxnGIQyJlsrup++mnnxAfH48ZM2YgKioK8+fPx4kTJxS5FWuPhBUpiP/rbrnLICKRqCnjfiqpkrsEInICu5u69u3bY/HixcjOzsZHH32EwsJCDB48GPX19di8eTN+/PFH51YqIb2WV78SuYrIIGmGCVNTxl26Vi13CUTkBK3qXoYNG4aPP/4YBQUF+Pvf/469e/eiW7du6NWrl/gVEpGqBft5Sr5MZhwRuaPb2iUVGBiImTNn4vjx4/j2228xZMgQ8SojIgLgo3f+MGFNYcYRkTNNiG35wkxHONzUffrpp41O7927N7y8nD/wthTMvACCyGW0kfikfjVkHBG5hnvCxO03HG7qZsyYgS+++KLB9GeeeQYff/yxWHXJSs49A0Rky9ND2nNc1ZBxROQa5h0Rt99wOC0/+eQTTJw4EQcOHLBOmz17NrZt24Z9+/aJWpxcpP5HhIiaVm+Wds+5GjKOiFxDvSDu1fUOdy+jR4/G2rVr8dvf/hYZGRmYOXMmPvvsM6SlpaFbt26iFkdEVF4j7TBhzDgiclcODRN206RJk1BWVobBgwcjJCQE6enp6NKli/jVyYTDhBG5jgPZpRjeI1LSZSo944hImexq6ubOndvo9JCQENx1111Yu3atddqqVavEq04m12vrW5zn9IqR8PLQIm5xw3NviMi9qC3j4sP8kFV0Xe4yiEhkdjV1J06caHR6ly5dYDQarc8r8c7rTREEAbxIlkgZ1JZxwX5ebOqIFMiupo4nBzfUc3mK3CUQqUJ7CUaUUFvGXbjKYcKIlIiXeTZCq5CtcSIlGBTbVu4SFIfDhBEpk11N3VNPPYVLly7Z9Ybbtm3DJ598crt1yYotHZHrCJFgmDC1ZRwRKZNdh19DQkLQo0cPDB48GA899BD69euHyMhIeHt749q1a8jMzMSBAwewdetWREZG4r333nN+5USkCl4S3AycGUdEchjTQdxhwuxq6l544QUkJydjw4YNWLt2LTIzM22e9/f3R2JiIt577z0kJSWJWqAcLLwCgshl6CQ4HUJtGUdErmFopLj9hkYQHO9grl27hry8PFRXVyM4OBidO3d2i6vCjEYjAgMDUV5ejoCAgCbnq64z446luyWtjYgat2PG3ejdoV2z89j727aXO2acI59Bx4W7JKuLiJoWoBeQsXQk9Prmx7i29/fdqpsPt2nTBm3atGnNS92CF4cJI3IZcuw5V3rGEZFrMJpkHiaMiEhK16qkHSaMiMhdsalrhMnCYcKIiIjIvbCpa0RFjX3DhJ17aZQk9RARiSk22CB3CUTkBGzqWsm1T5kmUg7+1sQXHugtdwlE5AQON3XDhg1DWVlZg+lGoxHDhg0Tqy6X12PZl4hb/IXcZRCRyNSQcRxRgkiZHG7q0tLSUFdX12B6TU0N9u/fL1ZdREQAgHYSjChxKzVkXN5VNnVESmT3LU1OnTpl/e/MzEwUFhZaH5vNZuzevRvt27cXv0IZ8HAPkesI8/eSZDlqyjgiUia7m7revXtDo9FAo9E0egjCx8cH77zzjtj1NbBmzRq8/vrrKCwsREJCAt555x0MGDDA6cslInl4SnTfSGYcEUntwWgZhgkDgJycHAiCgNjYWBw9ehQhISHW5zw9PREaGgqdzrljNG7btg1z587Fu+++i4EDB2L16tUYOXIksrKyEBoa6tRlE5E8PHXSNHXMOCKS2sgoFxgmTC4DBw5E//798fe//x0AYLFYEB0djdmzZ2PhwoUtvp7DhBG5n//OHIReMW2bnUfsYcLkcjsZx2HCiNxPmI+AA3+ReZiwc+fOYd++fSguLoblVzfqXbp0aWveskV1dXXIyMjAokWLrNO0Wi0SExNx+PDhRl9TW1uL2tpa62Oj0QgAMJlMMJmavku9B0+qI3IZpvrmf6+48ZsWkztkXGvzjYhcR1G1xq7fq72/aYebuvfffx8zZsxAcHAwwsPDbQa51mg0Tgu8kpISmM1mhIWF2UwPCwvD2bNnG33NypUrsWLFigbTU1JSYDC0dPPNVvW7RCSyPfu/waWg5g8oVFVVibY8d8k45huRMuzZs6fFeezNOId/2S+++CJeeuklPPfcc46+VHKLFi3C3LlzrY+NRiOio6MxYsSIZndfmswW4PBXElVJRM25q08fDL0jvNl5bu6lEoO7ZFxr8w0A/nw4RYIKicgew4cPt+vwqz0cbuquXbuG8ePHO/qy2xYcHAydToeioiKb6UVFRQgPbzzwvby84OXV8HYIer2+2Q+w/JZDGk05vWIkvDy0vAExkZN5eHi0GHgtPe8Id8m41uYbAEQFeeNSWY0IVRPR7bLnN2tvxjl8Wdn48eORkiL9Vp6npyf69u2L1NRU6zSLxYLU1FQMGjRI8no0vJ8dkSKpIeNi2nHsVyIlcnhPXZcuXbBkyRIcOXIEPXv2bNA9Pv3002LWZ2Pu3LmYOnUq+vXrhwEDBmD16tWorKzE73//e6ctsyk9ln0p+TKJyPnUkHEF3EtHpEgON3Xvvfce/Pz8kJ6ejvT0dJvnNBqNUwNvwoQJuHLlCpYuXYrCwkL07t0bu3fvbnBi8e1yn5u8EClfW19phwlTQ8bllIp3YQkRuQ6Hm7qcnBznVGKn5ORkJCcny1oDEUknVKJhwm5ixhGRu2r1rdrr6uqQlZWF+vp6cSsiIrqFVMOE/RozjoicbVikxY657OdwWlZVVeGPf/wjDAYDevTogby8PADA7Nmz8corr4haHBGRj965Q3P9GjOOiKTycAeZm7pFixbh5MmTSEtLg7e3t3V6YmIitm3bJmpxcjF4SvuPCBE1LaekUtLlqSHjiMg1rD4tbr/h8Dl1O3bswLZt23D33Xfb3Gm9R48eOH/+vKjFycXXi3dbJ1IrNWQcEbmGnApxb47m8J66K1euIDQ0tMH0yspKmwAkIhJD8fWWbwYuJmYcEbkrh5u6fv36YdeuXdbHN0Nuw4YNstwE2BlMZnGPcROR+1BDxhGRMjl8nPHll1/GqFGjkJmZifr6erz11lvIzMzEoUOHGtzTyV1dq6prcZ5Ty0fA20OHrn/lMGFESqKGjAv190JxhbR7QInI+RzeU3fvvffi5MmTqK+vR8+ePZGSkoLQ0FAcPnwYffv2dU6VLkin0cBDy0MxRE4n8c3A1ZBxXUJ85S6BiJzAoT11JpMJf/rTn7BkyRK8//77zqvKDXCYMCLlUUvGFRo5TBiREjm0p06v1+Pf//6386ohIvqVQB+9HXOJQy0Z91MJhwkjUiKHD7+OGTMGO3bscE41RES/EhYg7TBhzDgiclcOXygRFxeH559/HgcPHkTfvn3h62t7boYzB7smIvWRepgwZhwRSWVwmLh323C4qfvggw8QFBSEjIwMZGRk2Dyn0WgYeEQkKn+JbwbOjCMiqTwWK2NTJwgC0tLSEBoaCh8fH1ELcSUGT44oQeQqfiqpRI8oaQ7BqiXjiMg1vHtGiwcfFO/9HDquIQgC4uLicOnSJfEqcEF+HCaMSJXUknFE5BrOlIl7eolD76bVahEXF4fS0lJRiyAiakqRhDfJZcYRkTtzuEV85ZVXsGDBApw+fdo5FbmAeg4TRuQ6JL75sBoyjoiUyeHjjFOmTEFVVRUSEhLg6enZ4LyTq1evilmfLEorWx4m7PCiYQjw1vMmxETOJvHALWrIuCAfPcqqTXKXQUQic7ipW716tXMqcTOBPnr46HVyl0GkfBLvqVNDxnWP8Mehn9y/OSUiWw43dVOnTnVOJW6m+1LuoSNSIjVkXLGE5ykSkXQcbury8vKafT4mJuZ26iEisuHnLe3V6GrIuOwrlXKXQERO4HBaduzYERpN0ye5mM3m262JiMgqPMBb0uUx44jIXTnc1J04ccLmsclkwokTJ7Bq1Sq89NJLYtZGRARPnbRXSjDjiEgqfYNlHiYsISGhwbR+/fohMjISr7/+OsaNGydWbUREaGPwlHR5zDgiksqUOHGbOtFuZRwfH49jx46J9Xay8vHkVa1EruJ8iWuc/6WkjCMi1/Dhj+KOKOHwnjqj0WjzWBAEFBQUYPny5YiLixOzNtkEeOvlLoGIZKKGjCMi1/BtqcxNXVBQUIOTiAVBQHR0NLZu3SpmbUREKDLWont76ZbHjCMid+VwU7d3716bwNNqtQgJCUGXLl3g4SHtrQecxWyR+G6nRNQkQZD296iGjCMiZXI4oYYMGeKcSlxIcUVNi/P8e8Y9iG7jgwEvp0pSE5FqSTxMmBoyztdLh8pa3pqFSGkcPpi7cuVKbNy4scH0jRs34tVXXxWrLpd3R4Q/QiW+fxaRKkm841wNGdcnOkjuEojICRxu6tavX49u3bo1mN6jRw+8++67YtXl8rov/RIdF+6SuwwiEpkaMq7YyGHCiJTI4aausLAQERERDaaHhISgoKBArLqIiAAAvl7Snsemhoz7sfi63CUQkRM43NRFR0fj4MGDDaYfPHgQkZGRYtVFRAQACA/wknR5zDgiclcObwJPnz4dc+bMgclkwrBhwwAAqampePbZZzFv3jxn1EhEKuahE/c+Ti2RI+Nyc3PxwgsvYO/evSgsLERkZCQef/xxLF68GJ6e0o6oQUTS6R4k8zBhCxYsQGlpKWbOnIm6ujoAgLe3N5577jksWrRI1OKIiEL9pd1TJ0fGnT17FhaLBevXr0eXLl1w+vRpTJ8+HZWVlXjjjTecskwikt+f7hC3qdMIrbwJ1PXr13HmzBn4+PggLi4OXl7OC16xtmKNRiMCAwNRXl6OgICAJucrq6pD7+f3iFQ9Ed2OL2bfgzvat2l2Hnt/246QMuMa8/rrr2PdunX46aef7Jrfkc+AF3kRuYZ7Qi34cHYS9PrmR7Ky9/fd6jOQ/fz80L9//9a+3CFSb8UGSTyAOBE17dejO0hFyoxrTHl5Odq2bSvb8onI+Q4VyzxMmBySkpKQlJRkfRwbG4usrCysW7eOhyaIFK7QWINuKrs+ITs7G++8806z+VZbW4va2l9uTXJzzFqTyQSTySRJnUR0++z5vdr7m3aLpq4x9mzFtjb0LBwmjMhl1Na13KS4ahOzcOHCFm9YfObMGZv74l2+fBlJSUkYP348pk+f3uTrVq5ciRUrVjSYnpKSAoPB0EJlbhv9RIqzZ0/Lp3tVVVXZ9V6tPqdOTtnZ2ejbty/eeOONZkNv+fLljYbeli1bmg29q7XAim+bD72Jnc3o6Cdg5UmGI5EzPdXNjDvaNB9TVVVVmDRpkqjn1InhypUrKC0tbXae2NhY67nB+fn5GDJkCO6++25s3rwZWm3Th2Ya22iNjo5GSUlJi59B9+V7YDK7XfQTKVLm0qF2nVMXHBzcYsbJ2tS1div2N7/5DYYMGYINGzY0+9rWhl5+WTV+8+b+Zt/71JIH4OOpQ9ySlGbnI6Lbs35SLwy7I7zZeewNPFd2+fJlDB06FH379sXHH38MnU7n0OsduVDi8Q1HcCC7+WaTiKRx7oUR8l8oIYZ58+Zh2rRpzc4TGxtr/e/8/HwMHToU99xzD957770W39/Ly6vRK9b0en2zH6CHvr7F9+71QmqL8xDR7fPw8Ggx8Fp63tVdvnwZQ4YMQYcOHfDGG2/gypUr1ufCw5tvaFvjSgWHCSNSIlmbupCQEISEhNg1761bsZs2bWr2sAQRKYeP3rE9Vu5oz549yM7ORnZ2NqKiomyec8bBlKwiDhNGpERu0Rnd3IqNiYmxbsUWFhaisLBQ7tKIyMkiAr3lLsHppk2bBkEQGv0jIrKXW5zlL/VWLBG5Dp1WnvvUERE5Wyd/cXsYt9hTx61YIvVSw546IlKnOXeaRX0/t2jqpKaGc3iI3EVuaaXcJRAROcWOXHHbMDZ1jWjry2HCiFwFd8gTkVLtK2BTR0QqUlBeI3cJRERugU1dI3iuHpHrqOewfUREdmFT14jLZdUtzvP43THY8sRASeohIiIiagmbulb66+juuKdLsNxlEBE57P64dnKXQERO4Bb3qXNF3ZbslrsEIqJWuVJRJ3cJROQE3FPXCJ5SR+Q6vDwYU2I7U1ghdwlE5ARMSyJyabz5MBGRfdjUEZFL4zBhRKRUYT4qHCaMiNSrfZCP3CUQETnFX3pzmDCn8+YwYUQuI+9qldwlEBE5xRcXxT0SwaauESH+XnKXQEQ3WHjlEhEp1O5L4u5EYlNHRC6Nw4QREdmHTR0RubS6eovcJRARuQU2da3UIzIAf5uQIHcZREQOa2PQy10CETkBm7pW2vX0fRjbJ0ruMogU7+5YDmkltv0LfuOU9104qptT3peI7MNhwppw7oUR+Pzzz/Hggw9Cr/95q1YQBFypqLW5kCL3ldH4sagCMW0Ndl01W2+2IPvKdXx5ughl1XWYO7wrckoq0aGdLwK8PaDRaKzLuunWaRYBMFabUG8RkFVYgTa+eoQHeEOr0SDQRw/NLRfSWARAY32PX6aZLQLKKquR+tVX6D94CMLb+KLebIGvlwc0ALQ3ZrYIAjQaDQRBgFajgWB9XwFmy89/9Zafp3rqtNBqf36tVqOB5cZrzBYBOu3PjzU31uXmf9fWW6DXaVFTb4a3hw5miwC9TgOzIMBDq7U5QV4QAK3m5/p1Wg1MZgt0Wg3qzb+8v/aWlddqgJo6E1K+3I0RI0bC28vT5n0F4efP5GZ99WYBHjrNjRq0MJkt8ND+XIvW+vn//L433+fmPPUWwfq/Oq3GOiKJRmP7Gp3ml3lvPr75/jfX9dZ5mvpf4cZ3YKmvx64vdmP0qCRodB4289x831trMTfzvr98RxpoNLD5/hp7za/fX6tBs3XfvNec5VefQ3PvazL9/P1xRAnxeXlo8dagemu+ffLNBSzefrrF1w3s1BYLR3VD7+ggay7VmMw4lnsVcaH+CA/0RniAN/664zTa+Oqh02hwrcqE8moTHuwZjrd/1wff5pXB4KlDl1A/mMw/Z8Cx3Kv4/nI5Hr0rCsYaE17cdQYeWi28PLS4Ny4Y4/tG4bUvs3ChtBKdQ/wwulcEArz1KK82IbqtAUdzrqKwvBq/TWiPPWeKcCi7BDotUHslDy9NG4G1X+eiqLwGOq0Gf7i3Ezy0Gnx/uRwdg30R6u+FjAvXAABDu4Viffp5XK+ph5+3B2YO6YLdpwtxpsCIeouA8f2iUGSswenLRgQZ9Bh3VxS++akUxRW16Nk+EBZBQMoPRai3CBjZIwx19RZ8fe4KAODBnhHQajT478l8eOp+Xq8Abz0Ony+BTqfF6J4R+OzbS6ioqUdogBf+r2ck/nE4FyaLgKg2PnigWyg+OnIBFouAzqF+6B8TiFe27kW3O7rh3rhQaDUapP94BRaLgEf6RuHbvGv4seg6/Lx0mDKoIz7/vgC5pVUI9NFjQv9obD2ah+o6M0L8vfB/CZHYejQPtfUWdAv3R1yoPz47cQkAMKJ7OMqrTTiacxUAMLpXBC6XVeO7vDJ4emgxaWAMvvyhEMXGGgT7eeHBXhH45Ege6uotaH+j7i1H81BvFtC/YxvEhflj27E8mC3A4C7t4OWhQ1pWMTQaYNxdUTh1qQw/Fl2HYLGgbdlZ+Mb2wcVrtfD39sBjN+quqjMjNsQXD3QLw0dHclFjsuCOiAB0C/fHjhOXYRGAxO6huF5Tj29u1P1gz3AUlNfgRF4ZdFoNHh/YAV/+UIiC8hp4639ej/98l4+rlXWICPTG8O5h2HI0D6Z6AX07tEG3CH9sPfpz3YM6t4PBU4fUMzfrbo8f8o04W1ABnRYY3y8ax3Kv4nxxJfy8PfC7/tHYduwirtfWo2OwL0Z0D8M/DucixFcPzcUTov62NYKgnkvLjEYjAgMDUV5ejoCAgGbnNZlMDZo6JVH6+kEF68j1+4Ujv22lYr7ZUvo6cv3cnzMyjpvARERERArApo6IiIhIAdjUERERESmAqi6UuHn6oNFobHFek8mEqqoqGI1GRR7PV/r6QQXryPX7xc3ftIpOEW6A+WZL6evI9XN/zsg4VTV1FRUVAIDo6Gi5SyEiJ6ioqEBgYKDcZciC+UakfC1lnKqufrVYLMjPz4e/v7/1cvymGI1GREdH4+LFi4q8mk7p6wcVrCPX7xeCIKCiogKRkZHQatV5VgnzzZbS15Hr5/6ckXGq2lOn1WoRFeXYDYMDAgIU+38oqGD9oIJ15Pr9TK176G5ivjVO6evI9XN/YmacOjdpiYiIiBSGTR0RERGRArCpa4KXlxeWLVsGLy8vO+Z2P0pfP6hgHbl+1Fpq+GyVvo5cP/fnjHVU1YUSRERERErFPXVERERECsCmjoiIiEgB2NQRERERKQCbOiIiIiIFYFPXiDVr1qBjx47w9vbGwIEDcfToUblLEs3y5cuh0Whs/rp16yZ3Wa329ddf46GHHkJkZCQ0Gg127Nhh87wgCFi6dCkiIiLg4+ODxMREnDt3TrZ6W6OldZw2bVqD7zQpKUm2eh2xcuVK9O/fH/7+/ggNDcWYMWOQlZVlM09NTQ1mzZqFdu3awc/PD4888giKiopkq1kJlJpxSss3qCDjlJxvkCHj2NT9yrZt2zB37lwsW7YM3377LRISEjBy5EgUFxfLXZpoevTogYKCAuvfgQMH5C6p1SorK5GQkIA1a9Y0+vxrr72Gt99+G++++y6++eYb+Pr6YuTIkaipqZG81tZqaR0BICkpyeY7/fTTTyWtsbXS09Mxa9YsHDlyBHv27IHJZMKIESNQWVlpneeZZ57B//73P/zrX/9Ceno68vPzMW7cOFnrdmdKzzgl5RtUkHFKzjfIkXEC2RgwYIAwa9Ys62Oz2SxERkYKK1eulLUusSxbtkxISEiQuwynACBs377d+thisQjh4eHC66+/bp1WVlYmeHl5CZ9++qlMVd6eX6+jIAjC1KlThYcffli2msRUXFwsABDS09MF4cb3pdfrhX/961/Wec6cOSMAEA4fPixjpe5LyRmn5HwTVJBxSs83QYKM4566W9TV1SEjIwOJiYnWaVqtFomJiTh8+LCstYnp3LlziIyMRGxsLCZPnoy8vDy5S3KKnJwcFBYW2nyfgYGBGDhwoKK+TwBIS0tDaGgo4uPjMWPGDJSWlspdUquUl5cDANq2bQsAyMjIgMlksvkOu3XrhpiYGMV9h1JQQ8apJd+gooxTSr5BgoxjU3eLkpISmM1mhIWF2UwPCwtDYWGhbHWJaeDAgdi8eTN2796NdevWIScnB/fddx8qKirkLk10N78zJX+fuHFo4h//+AdSU1Px6quvIj09HaNGjYLZbJa7NIdYLBbMmTMHgwcPxp133gnc+A49PT0RFBRkM6/SvkOpKD3j1JRvUEnGKSXfIFHGeYhWLbmFUaNGWf+7V69eGDhwIDp06IB//vOf+OMf/yhrbdQ6v/vd76z/3bNnT/Tq1QudO3dGWloaHnjgAVlrc8SsWbNw+vRptz8HiuTDfFMepeQbJMo47qm7RXBwMHQ6XYOrToqKihAeHi5bXc4UFBSErl27Ijs7W+5SRHfzO1PT9wkAsbGxCA4OdqvvNDk5GTt37sS+ffsQFRVlnR4eHo66ujqUlZXZzK/079BZ1JZxSs43qDTj3DHfIGHGsam7haenJ/r27YvU1FTrNIvFgtTUVAwaNEjW2pzl+vXrOH/+PCIiIuQuRXSdOnVCeHi4zfdpNBrxzTffKPb7BIBLly6htLTULb5TQRCQnJyM7du3Y+/evejUqZPN83379oVer7f5DrOyspCXl6fo79BZ1JZxSs43qDTj3CnfIEfGiXpZhwJs3bpV8PLyEjZv3ixkZmYKTz75pBAUFCQUFhbKXZoo5s2bJ6SlpQk5OTnCwYMHhcTERCE4OFgoLi6Wu7RWqaioEE6cOCGcOHFCACCsWrVKOHHihHDhwgVBEAThlVdeEYKCgoT//Oc/wqlTp4SHH35Y6NSpk1BdXS136XZrbh0rKiqE+fPnC4cPHxZycnKEr776SrjrrruEuLg4oaamRu7SWzRjxgwhMDBQSEtLEwoKCqx/VVVV1nmeeuopISYmRti7d69w/PhxYdCgQcKgQYNkrdudKTnjlJZvggoyTsn5JsiQcWzqGvHOO+8IMTExgqenpzBgwADhyJEjcpckmgkTJggRERGCp6en0L59e2HChAlCdna23GW12r59+wQADf6mTp0qCDcu+V+yZIkQFhYmeHl5CQ888ICQlZUld9kOaW4dq6qqhBEjRgghISGCXq8XOnToIEyfPt1t/oFubL0ACJs2bbLOU11dLcycOVNo06aNYDAYhLFjxwoFBQWy1u3ulJpxSss3QQUZp+R8E2TIOM2NhRIRERGRG+M5dUREREQKwKaOiIiISAHY1BEREREpAJs6IiIiIgVgU0dERESkAGzqiIiIiBSATR0RERGRArCpIyIiIlIANnXkMtLS0qDRaBoMbCyV1NRU3HHHHTCbzS3Ou3v3bvTu3RsWi0WS2ojIvTHfSAps6kgWQ4YMwZw5c2ym3XPPPSgoKEBgYKAsNT377LP461//Cp1O1+K8SUlJ0Ov1+OSTTySpjYjcB/ON5MKmjlyGp6cnwsPDodFoJF/2gQMHcP78eTzyyCN2v2batGl4++23nVoXESkD842kwKaOJDdt2jSkp6fjrbfegkajgUajQW5uboPDE5s3b0ZQUBB27tyJ+Ph4GAwGPProo6iqqsKHH36Ijh07ok2bNnj66adtDinU1tZi/vz5aN++PXx9fTFw4ECkpaU1W9PWrVsxfPhweHt7W6edPHkSQ4cOhb+/PwICAtC3b18cP37c+vxDDz2E48eP4/z58075nIjI/TDfSE4echdA6vPWW2/hxx9/xJ133onnn38eABASEoLc3NwG81ZVVeHtt9/G1q1bUVFRgXHjxmHs2LEICgrC559/jp9++gmPPPIIBg8ejAkTJgAAkpOTkZmZia1btyIyMhLbt29HUlISvv/+e8TFxTVa0/79+zFp0iSbaZMnT0afPn2wbt066HQ6fPfdd9Dr9dbnY2JiEBYWhv3796Nz584if0pE5I6YbyQnNnUkucDAQHh6esJgMCA8PLzZeU0mE9atW2cNlUcffRQfffQRioqK4Ofnh+7du2Po0KHYt28fJkyYgLy8PGzatAl5eXmIjIwEAMyfPx+7d+/Gpk2b8PLLLze6nAsXLljnvykvLw8LFixAt27dAKDRwIyMjMSFCxda/VkQkbIw30hObOrIpRkMBputxLCwMHTs2BF+fn4204qLiwEA33//PcxmM7p27WrzPrW1tWjXrl2Ty6murrY5NAEAc+fOxRNPPIGPPvoIiYmJGD9+fIMtVh8fH1RVVd32ehKR+jDfSGxs6sil3Xo4AAA0Gk2j025een/9+nXodDpkZGQ0uMrr1qD8teDgYFy7ds1m2vLlyzFp0iTs2rULX3zxBZYtW4atW7di7Nix1nmuXr2KkJCQ21pHIlIn5huJjU0dycLT09Ou+yU5qk+fPjCbzSguLsZ9993n0OsyMzMbTO/atSu6du2KZ555BhMnTsSmTZusoVdTU4Pz58+jT58+oq4DEbk35hvJhVe/kiw6duyIb775Brm5uSgpKRHtJpddu3bF5MmTMWXKFHz22WfIycnB0aNHsXLlSuzatavJ140cORIHDhywPq6urkZycjLS0tJw4cIFHDx4EMeOHcMdd9xhnefIkSPw8vLCoEGDRKmdiJSB+UZyYVNHspg/fz50Oh26d++OkJAQ5OXlifbemzZtwpQpUzBv3jzEx8djzJgxOHbsGGJiYpp8zeTJk/HDDz8gKysLAKDT6VBaWoopU6aga9eueOyxxzBq1CisWLHC+ppPP/0UkydPhsFgEK12InJ/zDeSi0YQBEHuIohcwYIFC2A0GrF+/foW5y0pKUF8fDyOHz+OTp06SVIfEVFrMd/UgXvqiG5YvHgxOnToYNehktzcXKxdu5aBR0RugfmmDtxTR0RERKQA3FNHREREpABs6oiIiIgUgE0dERERkQKwqSMiIiJSADZ1RERERArApo6IiIhIAdjUERERESkAmzoiIiIiBWBTR0RERKQAbOqIiIiIFIBNHREREZECsKkjIiIiUgA2dUREREQKwKaOiIiISAHY1BEREREpAJs6kk1OTg6Sk5PRtWtXGAwGGAwGdO/eHbNmzcKpU6fkLs8qPz8fjz/+OOLj4+Hv74+goCAMGDAAH374IQRBkLs8InJR7pJxv/bJJ59Ao9HAz89P7lLIQRqB/yqRDHbu3IkJEybAw8MDkydPRkJCArRaLc6ePYvPPvsMFy5cQE5ODjp06CB3qTh16hSefvppDB48GDExMTCZTNizZw/++9//YtGiRXj55ZflLpGIXIw7Zdytrl+/jvj4eJSXl1sfk/tgU0eSO3/+PBISEhATE4PU1FRERETYPF9fX4+1a9di7NixiI6Olq3Oljz00EPYt28fysvLodPp5C6HiFyEO2fcwoULsWPHDvTr1w87duxgU+dmePiVJPfaa6+hsrISmzZtahB2AODh4YGnn366QdidPXsWjz76KNq2bQtvb2/069cP//3vf23m2bx5MzQaDQ4ePIi5c+ciJCQEvr6+GDt2LK5cuSLqenTs2BFVVVWoq6sT9X2JyL25a8adO3cOf/vb37Bq1Sp4eHjc1nuRPNjUkeR27tyJLl26YODAgXa/5ocffsDdd9+NM2fOYOHChXjzzTfh6+uLMWPGYPv27Q3mnz17Nk6ePIlly5ZhxowZ+N///ofk5OTbqru6uholJSXIzc3Fhx9+iE2bNmHQoEHw8fG5rfclImVx14ybM2cOhg4digcffPC23ofkw1acJGU0GpGfn48xY8Y0eK6srAz19fXWx76+vtaG6c9//jNiYmJw7NgxeHl5AQBmzpyJe++9F8899xzGjh1r817t2rVDSkoKNBoNAMBiseDtt99GeXk5AgMDW1X7W2+9hUWLFlkfP/DAA9i0aVOr3ouIlMldM27Xrl1ISUnByZMnHX4tuQ7uqSNJGY1GAGj0qqohQ4YgJCTE+rdmzRoAwNWrV7F371489thjqKioQElJCUpKSlBaWoqRI0fi3LlzuHz5ss17Pfnkk9awA4D77rsPZrMZFy5caHXtEydOxJ49e7BlyxZMmjQJuLH3jojoJnfMuLq6OjzzzDN46qmn0L1791asNbkK7qkjSfn7+wNNXFG1fv16VFRUoKioCI8//rh1enZ2NgRBwJIlS7BkyZJG37e4uBjt27e3Po6JibF5vk2bNgCAa9eutbr2Dh06WK9UmzhxIp588kkkJiYiKyuLh2CJCHDTjPvb3/6GkpISrFixwuHXkmthU0eSCgwMREREBE6fPt3guZvnn+Tm5tpMt1gsAID58+dj5MiRjb5vly5dbB43dTWqmBd7P/roo3j//ffx9ddfN1kXEamLu2VceXk5XnzxRcycORNGo9G6p/H69esQBAG5ubkwGAwIDQ116H1JHmzqSHKjR4/Ghg0bcPToUQwYMKDF+WNjYwEAer0eiYmJElRon5uHXm/ez4mICG6WcdeuXcP169fx2muv4bXXXmvwfKdOnfDwww9jx44dktZFrcNz6khyzz77LAwGA/7whz+gqKiowfO/3tIMDQ3FkCFDsH79ehQUFDSYv7WX8RcUFODs2bMwmUzNztfU+3/wwQfQaDS46667WrV8IlImd8q40NBQbN++vcHf0KFD4e3tje3bt9tcIEaujXvqSHJxcXHYsmULJk6ciPj4eOvd1gVBQE5ODrZs2QKtVouoqCjra9asWYN7770XPXv2xPTp0xEbG4uioiIcPnwYly5datUVW4sWLcKHH36InJwcdOzYscn5XnrpJRw8eBBJSUmIiYnB1atX8e9//xvHjh3D7NmzGxwWISJ1c6eMMxgMjV6pu2PHDhw9erTR58h1sakjWTz88MP4/vvv8eabbyIlJQUbN26ERqNBhw4dMHr0aDz11FNISEiwzt+9e3ccP34cK1aswObNm1FaWorQ0FD06dMHS5cudWqto0ePxvnz57Fx40ZcuXIF3t7e6NWrFzZt2oSpU6c6ddlE5J7cKeNIOThMGBEREZEC8Jw6IiIiIgVgU0dERESkAGzqiIiIiBSATR0RERGRArCpIyIiIlIANnVERERECsCmjoiIiEgBVHXzYYvFgvz8fPj7+0Oj0chdDhGJRBAEVFRUIDIyElqtOrdVmW9EymVvxqmqqcvPz0d0dLTcZRCRk1y8eNFm6CU1Yb4RKV9LGaeqps7f3x+48aEEBAQ0O6/JZEJKSgpGjBgBvV4vUYXSUfr6QQXryPX7hdFoRHR0tPU3rkbMN1tKX0eun/tzRsapqqm7eUgiICDArtAzGAwICAhQ5P+hlL5+UME6cv0aUvNhR+abLaWvI9fP/Tkj49R58gkRERGRwrCpIyIiIlIANnVNOFNQgTdP6XC2sMKh15nMFlgsgs00QRAgCEKTr2lKa19HRNSSmnrgDx9moOPCXRj2Zhp+unLdrtfVmy3457GL6PfiHvzm9X3YfbqwQeY1RRAE1NabrTl5M+Nu/rcjbr7W3IrXEimVRlDRr8FoNCIwMBDl5eXNnnNiMlsQt/gLSWsjosadXDIMgb4+zc5j729byRz5DOrq6tB16R7JaiOixkX7Cti7cKRdF0rY8/vmnrpGVJvMcpdARDf852SB3CUozsrdP8pdAhEBuFgp7sVdbOoaoVXxFXREribU30vuEhRn06ELcpdARE7Apq4RHlo2dUSuotZkkbsEIiK3wKaOiFxabT2bOiIie7CpIyKXduJimdwlEBG5BTZ1jVDP9cBErq/OzD11ruiZxK5yl0BEv8KmrhE6nlNH5DK4keWa/vYVr6AlcjVs6ojIpXULb34AayIi+hmbukZYuGuAyGUE+njIXQIRkVtgU9cInsND5DoMnmzqxMYzTIiUiU0dEbm067X1cpegOOsf7yN3CUTkBGzqiMilXauqk7sExTmey9vEECkRm7pG8MgEkevoGuondwmKs35/jtwlEJETsKlrhF7Hj4XIVdRwmDAiIruweyEil1ZjMstdAhGRW2BTR0Qu7cTFcrlLICJyilh/cW+hxqaOiFxaFffUuaR5wzlMGNHt8taxqXM6D97Eichl8Nfomt7cw2HCiG5XZpm4bRibOiJyaXG8+pWIyC5u09StXLkS/fv3h7+/P0JDQzFmzBhkZWU5ZVkWjhJG5DICffRylyAJKTOOiJTJbZq69PR0zJo1C0eOHMGePXtgMpkwYsQIVFZWir6smnqew0PkKgyeOrlLkISUGafX8aA2kRK5zaCKu3fvtnm8efNmhIaGIiMjA/fff79sdRGRc1Wr5EIJKTNu1fhemL31pKjvSUTyc5um7tfKy3++zUHbtm2bnKe2tha1tbXWx0ajEQBgMplgMpmafF19M88RkbSKyqub/b3ixm9aaezJuNbKKqwQ/T2JSH5u2dRZLBbMmTMHgwcPxp133tnkfCtXrsSKFSsaTE9JSYHBYGjydTX1cNePhkhx6grO4fPPm7/SsqqqSrJ6pGBPxrV2oxUA/p72k8gVE1Fr2bNRau+Gq1t2LrNmzcLp06dx4MCBZudbtGgR5s6da31sNBoRHR2NESNGICAgoMnXVdXV47lje0WtmYhap0ev3hhxZ0Sz89xsaJTCnoxr7Ubrz9wy+okUac+ePS3OY++Gq9v9spOTk7Fz5058/fXXiIqKanZeLy8veHl5NZiu1+uh1zd9RZ1e4EnERK6i1oJmf69Ay8+7E3szrrUbrQDw58MpotZMRK03fPjwFjPM3g1Xt2nqBEHA7NmzsX37dqSlpaFTp05yl0REElDLJpajGdfajVYich0d/QS7frP2/qbd5pYms2bNwscff4wtW7bA398fhYWFKCwsRHV1tejL0mrU8s8IEbkKKTNODAtGxstdApHb89erdJiwdevWoby8HEOGDEFERIT1b9u2baIvy1PnNh8LESmElBknhte/5I2RiW7X99fE7TccOvxaVlaG7du3Y//+/bhw4QKqqqoQEhKCPn36YOTIkbjnnntELe5WgsBhHojUqFOwr2TLYsYRkTuzq0XMz8/HE088gYiICLz44ouorq5G79698cADDyAqKgr79u3D8OHD0b17d5fdqnSEheFK5DLaGJx/fpjaMo6IlMmuPXV9+vTB1KlTkZGRge7duzc6T3V1NXbs2IHVq1fj4sWLmD9/vti1SkYtd7AncgfeeucPE6a2jPP11KGyjjlHpDR2NXWZmZlo165ds/P4+Phg4sSJmDhxIkpLS8Wqj4hUrs5scfoy1JZxK37bHfP/v+/lLoOIRGbX4deWwg437oC+c+dOu+cnIrJHQVmN05ehtozLL3PNK2qJ6Pbc9n3qsrOzsXHjRmzevBlXrlxR5BiMRCQfKfbUNUeJGbfqq2y5SyAiJ2jVtbTV1dX4xz/+gfvvvx/x8fE4dOgQli5dikuXLolfoQw0vE8dkcuokeEcV6VnHBEpk0N76o4dO4YNGzZg69at6Ny5MyZPnoxDhw5h7dq1TZ5cTER0O67XStfUMeOIyJ3Z3dT16tULRqMRkyZNwqFDh9CjRw8AwMKFC51ZHxGpnFT7zZlxRCS1jn4yjSiRlZWF+++/H0OHDlX8FquHlodfidRGTRknBg4TRnT7gjxlaup++uknxMfHY8aMGYiKisL8+fNx4sQJRZ5/5uXBYcKI1EZNGScGDhNGdPu+uypuv2H3u7Vv3x6LFy9GdnY2PvroIxQWFmLw4MGor6/H5s2b8eOPP4paGBERAMS0NUiyHGYcEbm7VrWIw4YNw8cff4yCggL8/e9/x969e9GtWzf06tVL/AplYOEoYUQuo62v84cJ+zWlZxwRKdNt7fcLDAzEzJkzcfz4cXz77bcYMmSIeJXJqLKuXu4SiOgGOU+HUGrGBflI3ygTkfM5nJaffvppo9N79+4NLy8vMWqSHc+gIXIdZon3nKsh455L6ip3CUTkBA43dTNmzMAXX3zRYPozzzyDjz/+WKy6iIgAAAXlzh8m7FZqyLiKGh6NIFIih5u6Tz75BBMnTsSBAwes02bPno1t27Zh3759YtdHRCpXL/EwYWrIuJe/4JWrRErkcFM3evRorF27Fr/97W+RkZGBmTNn4rPPPkNaWhq6devmnCqJSLVq6qVt6phxROSuHBom7KZJkyahrKwMgwcPRkhICNLT09GlSxfxqyMi1TNWmyRfJjOOiNyRXU3d3LlzG50eEhKCu+66C2vXrrVOW7VqlXjVERFJgBlHRHKI8RX3SjC7mroTJ040Or1Lly4wGo3W55Vy53W9jiNKEKmJ2jJODPNHdMUbKbwhM9HtaOctQ1OnlJOD7eWt18ldAhFJSG0ZJwY2dES370SpTMOEERHJoX2Qj9wlEBG5BbuauqeeegqXLl2y6w23bduGTz755HbrkpUgcJwwIlcR7Ofp9GWoLeOISJnsOvwaEhKCHj16YPDgwXjooYfQr18/REZGwtvbG9euXUNmZiYOHDiArVu3IjIyEu+9957zK3ciI2/MSeQyPCQ4x1VtGRfi54kr1+vkLoOIRGZXU/fCCy8gOTkZGzZswNq1a5GZmWnzvL+/PxITE/Hee+8hKSnJWbUSkQpJcWmC2jIueWhnLPvfGbnLICKR2X2furCwMCxevBiLFy/GtWvXkJeXh+rqagQHB6Nz5868KoyInKLQWIPItn5OX46aMo4nmBApU6tuPtymTRu0adNG/GqIiH7FbJG+BVF6xi3nXjoiReLVr0Tk0molHiaMiMhdsakjIpdWLsMwYURE7ohNHREREZEMokQeJoxNXSP0OuWcEE1E5AwLRsbLXQKR2wsVeZgwh5u6YcOGoaysrMF0o9GIYcOGiVWXrAyerbp+hIicQOp7gash48Tw+pdZcpdA5Pa+lXuYsLS0NNTVNbxpZU1NDfbv3y9WXUREAIDwQG9Jl8eMIyJ3ZfcuqVOnTln/OzMzE4WFhdbHZrMZu3fvRvv27cWvkIhULUSCYcLAjCMiBbC7qevduzc0Gg00Gk2jhyB8fHzwzjvviF1fA2vWrMHrr7+OwsJCJCQk4J133sGAAQNEXUZZFYfPIXIVWq0057iqKePCA7xQaKwV9T2JSH52N3U5OTkQBAGxsbE4evQoQkJCrM95enoiNDQUOp3OWXUCNwbSnjt3Lt59910MHDgQq1evxsiRI5GVlYXQ0FCnLpuI5OEhUVOnpox74t6OePFznhNHpDR2N3UdOnQAAFgs8t0IdNWqVZg+fTp+//vfAwDeffdd7Nq1Cxs3bsTChQtlq4uInKewvBYRbZw/TJiaMs7XixeDESlRq37Z586dw759+1BcXNwgAJcuXSpWbTbq6uqQkZGBRYsWWadptVokJibi8OHDTlkmEcnPIvXlryrIuEXbfxD1/YjINTjc1L3//vuYMWMGgoODER4ebjPItUajcVrglZSUwGw2IywszGZ6WFgYzp492+hramtrUVv7y3kjRqMRAGAymWAyNX2XepOpXrS6iej2VNfWNft7xY3ftFjcJeNam29E5Frs+b3a+5t2uKl78cUX8dJLL+G5555z9KWSW7lyJVasWNFgekpKCgwGQ5OvqzShtTsxiUhk+w4fR2lW83vrqqqqRFueu2Rca/PtZ8w3IlexZ8+eFuexN+Mc/mVfu3YN48ePd/Rlty04OBg6nQ5FRUU204uKihAeHt7oaxYtWoS5c+daHxuNRkRHR2PEiBEICAhoclllVSb85fg+Easnotbq3TsBSXdGNjvPzb1UYnCXjGttvgHAnw+niFg5EbVWe4OA4cOHQ6/XNzufvRnn8M2Hx48fj5QU6QPB09MTffv2RWpqqnWaxWJBamoqBg0a1OhrvLy8EBAQYPMHAHq9vtk/H29p7otFRC3z0Hm0+JttKRAd4S4Z19p8E+uzWjAyXrIrk4mUKtIg2PWbtfd36/Ceui5dumDJkiU4cuQIevbs2WBBTz/9tKNvabe5c+di6tSp6NevHwYMGIDVq1ejsrLSeqWYWPx4ZRiRaqkh48TAYcKIbt+xEnGHCXO4e3nvvffg5+eH9PR0pKen2zyn0WicGngTJkzAlStXsHTpUhQWFqJ3797YvXt3gxOLiUg5Qvy9JF0eM46I3JXDTV1OTo5zKrFTcnIykpOTZa2BiKQTKnFTx4wjInfV6v1+dXV1yMrKQn298m7/wWHCiEjJGRfVxkfuEojICRxu6qqqqvDHP/4RBoMBPXr0QF5eHgBg9uzZeOWVV5xRo+RkuNcpETVBr5P2ZHw1ZNykAVFyl0BETuBwU7do0SKcPHkSaWlp8Pb2tk5PTEzEtm3bxK6PiFSuSOKB59WQcREB3nbMRUTuxuFz6nbs2IFt27bh7rvvtrnTeo8ePXD+/Hmx6yMikpQaMu6Zf30vdwlE5AQO76m7cuUKQkNDG0yvrKy0CUAiIjGYzBY75hIPM46I3JXDTV2/fv2wa9cu6+ObIbdhw4YmbwJMRNRaJdelvXCJGUdE7srhw68vv/wyRo0ahczMTNTX1+Ott95CZmYmDh061OCeTkRE7oYZR0RSCfMR98pMh/fU3XvvvTh58iTq6+vRs2dPpKSkIDQ0FIcPH0bfvn1FLU4uOomvtiMi16GGjBPD3OFd4a0X9274RGrTwU/cps6hPXUmkwl/+tOfsGTJErz//vuiFuJKArzFG0eSiG6PlJtYask4Maza86PcJRC5vaNXxN0wcujd9Ho9/v3vf4taABFRc9r6eUq2LGYcEbkzh1vEMWPGYMeOHc6phojoV8IlvqcaM46I3JXDF0rExcXh+eefx8GDB9G3b1/4+vraPO/Mwa6lcq2Sw4QRqZUaMi422ICfSqrkLoOIROZwU/fBBx8gKCgIGRkZyMjIsHlOo9EoIvAsHCeMyGVIPUyYGjJuXJ/2eGPPObnLICKROdTUCYKAtLQ0hIaGwseHA0ITkfNdqahDRBtplqWWjOsc4mvHXETkbhw6p04QBMTFxeHSpUvOq4iISCZqybgZW76TuwQicgKHmjqtVou4uDiUlpY6ryIioluYLdKdDsGMIyJ35vDVr6+88goWLFiA06dPO6ciIqJbFBlrJF0eM46I3JXDF0pMmTIFVVVVSEhIgKenZ4PzTq5evSpmfUREkmLGEZFUgjxlHFECAFavXi1qAa7IQ8uhb4jUSg0ZJ4ZnErvigwM/wVhTL3cpRG7rjiCZm7qpU6eKWoArCjRwmDAitVJDxonhb19xmDCi23W4WNydSA43dXl5ec0+HxMTczv1EBHZCJJ4I4sZR0TuyuGmrmPHjtBomr4ZqNlsvt2aiIiswgOlHSaMGUdE7srhpu7EiRM2j00mE06cOIFVq1bhpZdeErM22VzlMGFEqqWGjIsP80NW0XW5yyAikTnc1CUkJDSY1q9fP0RGRuL111/HuHHjxKpNNlLeF4uImuflIe2FS2rIuKQeYWzqiBRItLSMj4/HsWPHxHo7IiIAQOl119hzrqSM6x4ZIHcJROQEDu+pMxqNNo8FQUBBQQGWL1+OuLg4MWsjIpKcGjLuTx+fsGMuInI3Djd1QUFBDU4iFgQB0dHR2Lp1q5i1ERHBLEh7OgQzjojclcNN3d69e20CT6vVIiQkBF26dIGHh8NvR0TUrIKyGiRIeBcRZhwRuSuHE2rIkCHOqYSIyAUw44hIKgaduEciHL5QYuXKldi4cWOD6Rs3bsSrr74qVl2y0mmbvkcVESmbGjJODHMS4+DnxT2XRLejdzuZm7r169ejW7duDab36NED7777rlh1yaqtr6fcJRDRDVLfYEgNGSeG1V+dw/VajvtKdDsOiTxMmMPvVlhYiIiIiAbTQ0JCUFBQIFZdREQAgAAfafcGMeOIyF053NRFR0fj4MGDDaYfPHgQkZGRYtVFRAQACA+QdpgwZhwRuSuHN4GnT5+OOXPmwGQyYdiwYQCA1NRUPPvss5g3b54zapQchwkjUi81ZFzP9gH4/rLRjjmJyJ043NQtWLAApaWlmDlzJurqfm5+vL298dxzz2HRokXOqFFy9RaL3CUQ0Q0+ep2ky5Mj43Jzc/HCCy9g7969KCwsRGRkJB5//HEsXrwYnp7in+M7tGsImzoiBXK4qdNoNHj11VexZMkSnDlzBj4+PoiLi4OXl5dzKpQh8IjIdZRVmRDZVrrlyZFxZ8+ehcViwfr169GlSxecPn0a06dPR2VlJd544w3Rl9crisOEESlRq89A9vPzQ//+/cWtpglSBx4RkZQZl5SUhKSkJOvj2NhYZGVlYd26dU7JuCc+4jBhRErkFjcZkjrwiMh1WCQeJsxVlJeXo21bCXdREpHbc4umrjH2BF5tbS1qa2utj28O1G0ymWAymZp8Xb2J914ichW5JdcRH+7f7DzN/Z7dUXZ2Nt55551mN1pbm29E5Frs+b3a+5t2y6bOnsDDjTvDr1ixosH0lJQUGAyGJl9nrIO7fjREivPdd9/BnNf84cKqqirJ6nHEwoULWxyF4syZMzY3O758+TKSkpIwfvx4TJ8+vcnXtTbffsZ8I3IFWo2APXv2tDifvRmnEQT5jm20NvB+85vfYMiQIdiwYUOzr21sSzY6OholJSUICGj6ROHS67W4+9V0h9aFiJzj7xN6YuSdDW8GfCuj0Yjg4GCUl5c3+9uW2pUrV1BaWtrsPLGxsdYLvvLz8zFkyBDcfffd2Lx5M7Tapm8l2tp8A4C4JSkOr8uvzR4ai/X7c1FXz7sFELXW3aEWbHzqAej1+mbnszfjZN1cmzdvHqZNm9bsPLGxsdb/zs/Px9ChQ3HPPffgvffea/H9vby8Gr1iTa/XN/sBhrdp/sMlIunodLoWA6+l5+USEhKCkJAQu+a9fPkyhg4dir59+2LTpk3NNnS4jXwTyzv7fnL6MoiU7kix1q7frL2/aVmbOmcGHhEpgxoGjb98+TKGDBmCDh064I033sCVK1esz4WHh8taGxG5D7dISwYekXpFBEo7TJgc9uzZg+zsbGRnZyMqKsrmORnPkCEiN+MWu7tuBl5qaiqioqIQERFh/XOG0uu1dsxFRCSOadOmQRCERv+coW9MkFPel4jk5RZNndSBV2/hljGRq/DxlHaYMDUYFMv73xEpkVs0dVLj0Q4i11FezXuuia1vhzZyl0BETsCmjohIZX7/YYbcJRCRE7CpIyLXxj3nRER2YVPXCIH/ihC5jAtXXXO0CCIiV8OmjohcmkbuAoiI3ASbukZoNfxnhIioOclDu4BRSXR7BoaIO8yeW9x8WGphAcq/2SmRu+DJEK7p7/uy5S6ByO19c0XcfWvcU0dELs3A+9QREdmFTR0RuTQ1DBNGRCQGNnWNKOEwYUSkYBxRgkiZ2NQ1oq5e3BMXiaj1vPU8/Cq2PtEc+5VIidjUNYInZhO5juo6s9wlKM49nbmnjkiJ2NQRkUvjRpb4Ht94XO4SiMgJ2NQRERERKQCbukYIAvcNELmKnJJKuUsgInILbOqIyKVxG4uIyD5s6hphtvBfESJX0TnEV+4SqBGrHktAt3B/ucsgcmsTO4t7IRibukZ0aGffPyKP3x2DrU/ejRW/7eHQ+w/rFoopgzqgR2RAKyskUoe7Qy2IZVMnug+n9W3yuZ2z78VPLz+IgwuH4Xf9o5ucb9xdUdj65N3NLmfaPR3xbFI87u0S7HCNnjr+80TK5qHVYGCIuDuRNIKKTiAzGo0IDAxEeXk5AgKab6hMJhM+//xzPPjgg9Dr9ZLVKBWlrx9UsI5cv1848ttWKuabLaWvI9fP/Tkj47gpRERERKQAbOqIiIiIFIBNHREREZECsKkjIiIiUgAPuQuQ0s1rQoxGY4vzmkwmVFVVwWg0KvIkTaWvH1Swjly/X9z8Tavouq8GmG+2lL6OXD/354yMU1VTV1FRAQCIjm76Mn0icl8VFRUIDAyUuwxZMN+IlK+ljFPVLU0sFgvy8/Ph7+8PjUbT7LxGoxHR0dG4ePGiIm+RoPT1gwrWkev3C0EQUFFRgcjISGi16jyrhPlmS+nryPVzf87IOFXtqdNqtYiKinLoNQEBAYr9PxRUsH5QwTpy/X6m1j10NzHfGqf0deT6uT8xM06dm7RERERECsOmjoiIiEgB2NQ1wcvLC8uWLYOXl5fcpTiF0tcPKlhHrh+1lho+W6WvI9fP/TljHVV1oQQRERGRUnFPHREREZECsKkjIiIiUgA2dUREREQKwKauEWvWrEHHjh3h7e2NgQMH4ujRo3KXJJrly5dDo9HY/HXr1k3uslrt66+/xkMPPYTIyEhoNBrs2LHD5nlBELB06VJERETAx8cHiYmJOHfunGz1tkZL6zht2rQG32lSUpJs9Tpi5cqV6N+/P/z9/REaGooxY8YgKyvLZp6amhrMmjUL7dq1g5+fHx555BEUFRXJVrMSKDXjlJZvUEHGKTnfIEPGsan7lW3btmHu3LlYtmwZvv32WyQkJGDkyJEoLi6WuzTR9OjRAwUFBda/AwcOyF1Sq1VWViIhIQFr1qxp9PnXXnsNb7/9Nt59911888038PX1xciRI1FTUyN5ra3V0joCQFJSks13+umnn0paY2ulp6dj1qxZOHLkCPbs2QOTyYQRI0agsrLSOs8zzzyD//3vf/jXv/6F9PR05OfnY9y4cbLW7c6UnnFKyjeoIOOUnG+QI+MEsjFgwABh1qxZ1sdms1mIjIwUVq5cKWtdYlm2bJmQkJAgdxlOAUDYvn279bHFYhHCw8OF119/3TqtrKxM8PLyEj799FOZqrw9v15HQRCEqVOnCg8//LBsNYmpuLhYACCkp6cLwo3vS6/XC//617+s85w5c0YAIBw+fFjGSt2XkjNOyfkmqCDjlJ5vggQZxz11t6irq0NGRgYSExOt07RaLRITE3H48GFZaxPTuXPnEBkZidjYWEyePBl5eXlyl+QUOTk5KCwstPk+AwMDMXDgQEV9nwCQlpaG0NBQxMfHY8aMGSgtLZW7pFYpLy8HALRt2xYAkJGRAZPJZPMdduvWDTExMYr7DqWghoxTS75BRRmnlHyDBBnHpu4WJSUlMJvNCAsLs5keFhaGwsJC2eoS08CBA7F582bs3r0b69atQ05ODu677z5UVFTIXZrobn5nSv4+cePQxD/+8Q+kpqbi1VdfRXp6OkaNGgWz2Sx3aQ6xWCyYM2cOBg8ejDvvvBO48R16enoiKCjIZl6lfYdSUXrGqSnfoJKMU0q+QaKM8xCtWnILo0aNsv53r169MHDgQHTo0AH//Oc/8cc//lHW2qh1fve731n/u2fPnujVqxc6d+6MtLQ0PPDAA7LW5ohZs2bh9OnTbn8OFMmH+aY8Ssk3SJRx3FN3i+DgYOh0ugZXnRQVFSE8PFy2upwpKCgIXbt2RXZ2ttyliO7md6am7xMAYmNjERwc7FbfaXJyMnbu3Il9+/YhKirKOj08PBx1dXUoKyuzmV/p36GzqC3jlJxvUGnGuWO+QcKMY1N3C09PT/Tt2xepqanWaRaLBampqRg0aJCstTnL9evXcf78eURERMhdiug6deqE8PBwm+/TaDTim2++Uez3CQCXLl1CaWmpW3yngiAgOTkZ27dvx969e9GpUyeb5/v27Qu9Xm/zHWZlZSEvL0/R36GzqC3jlJxvUGnGuVO+QY6ME/WyDgXYunWr4OXlJWzevFnIzMwUnnzySSEoKEgoLCyUuzRRzJs3T0hLSxNycnKEgwcPComJiUJwcLBQXFwsd2mtUlFRIZw4cUI4ceKEAEBYtWqVcOLECeHChQuCIAjCK6+8IgQFBQn/+c9/hFOnTgkPP/yw0KlTJ6G6ulru0u3W3DpWVFQI8+fPFw4fPizk5OQIX331lXDXXXcJcXFxQk1Njdylt2jGjBlCYGCgkJaWJhQUFFj/qqqqrPM89dRTQkxMjLB3717h+PHjwqBBg4RBgwbJWrc7U3LGKS3fBBVknJLzTZAh49jUNeKdd94RYmJiBE9PT2HAgAHCkSNH5C5JNBMmTBAiIiIET09PoX379sKECROE7OxsuctqtX379gkAGvxNnTpVEG5c8r9kyRIhLCxM8PLyEh544AEhKytL7rId0tw6VlVVCSNGjBBCQkIEvV4vdOjQQZg+fbrb/APd2HoBEDZt2mSdp7q6Wpg5c6bQpk0bwWAwCGPHjhUKCgpkrdvdKTXjlJZvggoyTsn5JsiQcZobCyUiIiIiN8Zz6oiIiIgUgE0dERERkQKwqSMiIiJSADZ1RERERArApo6IiIhIAdjUERERESkAmzoiIiIiBWBTR0RERKQAbOrIZaSlpUGj0TQY2FgqqampuOOOO2A2m1ucd/fu3ejduzcsFosktRGRe2O+kRTY1JEshgwZgjlz5thMu+eee1BQUIDAwEBZanr22Wfx17/+FTqdrsV5k5KSoNfr8cknn0hSGxG5D+YbyYVNHbkMT09PhIeHQ6PRSL7sAwcO4Pz583jkkUfsfs20adPw9ttvO7UuIlIG5htJgU0dSW7atGlIT0/HW2+9BY1GA41Gg9zc3AaHJzZv3oygoCDs3LkT8fHxMBgMePTRR1FVVYUPP/wQHTt2RJs2bfD000/bHFKora3F/Pnz0b59e/j6+mLgwIFIS0trtqatW7di+PDh8Pb2tk47efIkhg4dCn9/fwQEBKBv3744fvy49fmHHnoIx48fx/nz553yORGR+2G+kZw85C6A1Oett97Cjz/+iDvvvBPPP/88ACAkJAS5ubkN5q2qqsLbb7+NrVu3oqKiAuPGjcPYsWMRFBSEzz//HD/99BMeeeQRDB48GBMmTAAAJCcnIzMzE1u3bkVkZCS2b9+OpKQkfP/994iLi2u0pv3792PSpEk20yZPnow+ffpg3bp10Ol0+O6776DX663Px8TEICwsDPv370fnzp1F/pSIyB0x30hObOpIcoGBgfD09ITBYEB4eHiz85pMJqxbt84aKo8++ig++ugjFBUVwc/PD927d8fQoUOxb98+TJgwAXl5edi0aRPy8vIQGRkJAJg/fz52796NTZs24eWXX250ORcuXLDOf1NeXh4WLFiAbt26AUCjgRkZGYkLFy60+rMgImVhvpGc2NSRSzMYDDZbiWFhYejYsSP8/PxsphUXFwMAvv/+e5jNZnTt2tXmfWpra9GuXbsml1NdXW1zaAIA5s6diyeeeAIfffQREhMTMX78+AZbrD4+Pqiqqrrt9SQi9WG+kdjY1JFLu/VwAABoNJpGp9289P769evQ6XTIyMhocJXXrUH5a8HBwbh27ZrNtOXLl2PSpEnYtWsXvvjiCyxbtgxbt27F2LFjrfNcvXoVISEht7WORKROzDcSG5s6koWnp6dd90tyVJ8+fWA2m1FcXIz77rvPoddlZmY2mN61a1d07doVzzzzDCZOnIhNmzZZQ6+mpgbnz59Hnz59RF0HInJvzDeSC69+JVl07NgR33zzDXJzc1FSUiLaTS67du2KyZMnY8qUKfjss8+Qk5ODo0ePYuXKldi1a1eTrxs5ciQOHDhgfVxdXY3k5GSkpaXhwoULOHjwII4dO4Y77rjDOs+RI0fg5eWFQYMGiVI7ESkD843kwqaOZDF//nzodDp0794dISEhyMvLE+29N23ahClTpmDevHmIj4/HmDFjcOzYMcTExDT5msmTJ+OHH35AVlYWAECn06G0tBRTpkxB165d8dhjj2HUqFFYsWKF9TWffvopJk+eDIPBIFrtROT+mG8kF40gCILcRRC5ggULFsBoNGL9+vUtzltSUoL4+HgcP34cnTp1kqQ+IqLWYr6pA/fUEd2wePFidOjQwa5DJbm5uVi7di0Dj4jcAvNNHbinjoiIiEgBuKeOiIiISAHY1BEREREpAJs6IiIiIgVgU0dERESkAGzqiIiIiBSATR0RERGRArCpIyIiIlIANnVERERECsCmjoiIiEgB2NQRERERKcD/D6T3fcMIZp+PAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "\n", + "plt.subplot(2, 2, 1)\n", + "for name in [\"i_gen1\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"DP\",\n", + " linestyle=\"--\",\n", + " )\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"current (kA)\")\n", + "plt.title(\"Gen. 1\")\n", + "\n", + "plt.subplot(2, 2, 2)\n", + "for name in [\"i_gen2\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"DP\",\n", + " linestyle=\"--\",\n", + " )\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"current (kA)\")\n", + "plt.title(\"Gen. 2\")\n", + "\n", + "plt.subplot(2, 2, 3)\n", + "for name in [\"i_gen3\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"DP\",\n", + " linestyle=\"--\",\n", + " )\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"current (kA)\")\n", + "plt.title(\"Gen. 3\")\n", + "\n", + "plt.subplot(2, 2, 4)\n", + "for name in [\"i_gen4\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"DP\",\n", + " linestyle=\"--\",\n", + " )\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"current (kA)\")\n", + "plt.title(\"Gen. 4\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'i line 910')" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "\n", + "plt.subplot(2, 2, 1)\n", + "for name in [\"i_line56\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"i line 56\",\n", + " )\n", + "\n", + "# plt.legend(loc='lower right')\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"current (kA)\")\n", + "plt.title(\"i line 56\")\n", + "\n", + "plt.subplot(2, 2, 2)\n", + "for name in [\"i_line67\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"i line 67\",\n", + " )\n", + "\n", + "# plt.legend(loc='lower right')\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"current (kA)\")\n", + "plt.title(\"i line 67\")\n", + "\n", + "plt.subplot(2, 2, 3)\n", + "for name in [\"i_line1011\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"i line 1011\",\n", + " )\n", + "\n", + "# plt.legend(loc='lower right')\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"current (kA)\")\n", + "plt.title(\"i line 1011\")\n", + "\n", + "plt.subplot(2, 2, 4)\n", + "for name in [\"i_line910\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"i line 910\",\n", + " )\n", + "\n", + "# plt.legend(loc='lower right')\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"current (kA)\")\n", + "plt.title(\"i line 910\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'i line 89_1')" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.subplot(1, 2, 1)\n", + "for name in [\"i_line78_1\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"i line 78_1\",\n", + " )\n", + "\n", + "# plt.legend(loc='lower right')\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"current (kA)\")\n", + "plt.title(\"i line 78_1\")\n", + "\n", + "plt.subplot(1, 2, 2)\n", + "for name in [\"i_line89_1\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-3\n", + " * ts_sp1ph_TrStab_dl[name]\n", + " .interpolate(timestep)\n", + " .frequency_shift(60)\n", + " .values[begin_idx:end_idx],\n", + " label=\"i line 89_1\",\n", + " )\n", + "\n", + "# plt.legend(loc='lower right')\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"current (kA)\")\n", + "plt.title(\"i line 89_1\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generator electrical & mechanical energy" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'P_elec G4')" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAybVJREFUeJzs3Xd803X+B/DXNztpm+5BoQPKaJFpWQVkU6aK1I0K4j7Qk56eop7iOvjpiedA9M5eURHxOBFPQI6WDZZVZZRRVhd0jzRt0+zv748k3zZt0iYlbZr0/Xw8+qBNvt9vPp+UvPv+fibDsiwLQgghhBDi8XjuLgAhhBBCCHENSuwIIYQQQrwEJXaEEEIIIV6CEjtCCCGEEC9BiR0hhBBCiJegxI4QQgghxEtQYkcIIYQQ4iUosSOEEEII8RKU2BFCCCGEeAlK7IhHW7JkCWJjY91dDEIIcTmKb6QjKLEjLrNhwwYwDMN9SSQSDBw4EMuXL0dZWZm7i+dyeXl5WL58OQYOHAiZTAaZTIbBgwdj2bJlOHPmjNWxJSUlePnllzF16lT4+fmBYRjs37/fbWUnhDiH4pv9+LZnzx4sXbqUO7Zfv354/PHHUVJS4rby92QCdxeAeJ+33noLffv2hVqtxuHDh7F+/Xrs3LkTOTk5kMlk7i6eS2zfvh333XcfBAIBFi1ahOHDh4PH4+HixYvYunUr1q9fj7y8PMTExAAAcnNz8X//938YMGAAhg4diqysLHdXgRDSARTfWse3l156CdXV1bjnnnswYMAAXLt2DZ9++im2b9+OU6dOISIiwt1V6llYQlwkPT2dBcCeOHHC6vHU1FQWALtp0yaXv+bixYvZmJgYl1+3LVeuXGF9fHzYhIQEtri4uNXzOp2O/eijj9jCwkLuMaVSyVZVVbEsy7JbtmxhAbD79u3r0nITQjqO4puJrfh24MAB1mAwWB134MABFgD76quvdkm5SRPqiiWdbtq0aYC5ad8ZGzduRGJiIqRSKYKCgnD//fejqKio3fOMRiP+/ve/45ZbboFEIkF4eDieeuop1NTUtDr2l19+weTJk+Hn5we5XI7Ro0dj06ZNbV7/vffeQ0NDA9LT09GrV69WzwsEAjz33HOIioriHvPz80NQUJDDdSeEeAaKb8CkSZPA41mnE5MmTUJQUBAuXLjQbp2Ia1FiRzrd1atXAQDBwcEOn/Puu+/ikUcewYABA7B27Vo8//zz2LNnDyZNmgSFQtHmuU899RRefPFFTJgwAR999BEeffRRfPvtt5g1axZ0Oh133IYNGzBv3jxUV1dj5cqVWLNmDUaMGIFdu3a1ef3t27ejf//+GDt2rMP1IYR4J4pvttXX16O+vh4hISE3dR3SAe5uMiTew9JVkZmZyVZUVLBFRUXs5s2b2eDgYFYqlbLXr1936Dr5+fksn89n3333XavHz549ywoEAqvHW3ZVHDp0iAXAfvvtt1bn7tq1y+pxhULB+vn5sWPHjmUbGxutjjUajXbLVltbywJgFyxY0Oq5mpoatqKigvtSqVQ2r0FdsYR4HopvjsU3i7fffpsFwO7Zs6fN44jrUYsdcbkZM2YgNDQUUVFRuP/+++Hr64sff/wRvXv3duj8rVu3wmg04t5770VlZSX3FRERgQEDBmDfvn12z92yZQv8/f0xc+ZMq3MTExPh6+vLnZuRkYG6ujq8/PLLkEgkVtdgGMbu9ZVKJQDA19e31XNTpkxBaGgo97Vu3TqH6ksI8RwU39qPbwcPHsSbb76Je++9l+uqJl2HZsUSl1u3bh0GDhwIgUCA8PBwDBo0qNX4i7ZcvnwZLMtiwIABNp8XCoVtnltbW4uwsDCbz5eXlwPNuk+GDBnicLlgHisHczdDS1988QXq6upQVlaGhx56yKnrEkI8A8W3tuPbxYsXcdddd2HIkCH48ssvnXp94hqU2BGXGzNmDEaNGtXh841GIxiGwS+//AI+n9/qeVt3k83PDQsLw7fffmvz+dDQ0A6XCwD8/f3Rq1cv5OTktHrOMiYlPz//pl6DENJ9UXyzH9+KioqQnJwMf39/7Ny5k0sUSdeixI50O3FxcWBZFn379sXAgQOdPjczMxMTJkyAVCpt8zgAyMnJQf/+/Z16jXnz5uHLL7/E8ePHMWbMGKfOJYT0bN4a36qqqpCcnAyNRoM9e/bYnFFLugaNsSPdzsKFC8Hn8/Hmm2+CZVmr51iWRVVVld1z7733XhgMBrz99tutntPr9dyMs+TkZPj5+WH16tVQq9WtXqMtf/7znyGTybB06VKbK863dz4hpOfyxvjW0NCAuXPn4saNG9i5c6fdbmbSNajFjnQ7cXFxeOedd7By5Urk5+djwYIF8PPzQ15eHn788Uc8+eSTeOGFF2yeO3nyZDz11FNYvXo1Tp06heTkZAiFQly+fBlbtmzBRx99hLvvvhtyuRwffvghHn/8cYwePRoPPvggAgMDcfr0aahUKnz11Vd2yzdgwABs2rQJDzzwAAYNGsStzM6yLPLy8rBp0ybweDz06dPH6rx33nkHAHDu3DkAwDfffIPDhw8DAF577TUXvoOEkO7KG+PbokWLcPz4cSxduhQXLlywWrvO19cXCxYscPG7SNrk7mm5xHvYW5m9o3744Qd24sSJrI+PD+vj48PGx8ezy5YtY3Nzc7lj7K3M/o9//INNTExkpVIp6+fnxw4dOpT985//3Gol9f/+97/s+PHjWalUysrlcnbMmDHsd99951D5rly5wj7zzDNs//79WYlEwkqlUjY+Pp59+umn2VOnTrU6HoDdL0JI90bxzX58i4mJsRvbunrnDMKyDEv9RoQQQgghXoHG2BFCCCGEeAkaY0e6VGlpaZvPS6VS+Pv7d1l5CCHEVSi+ke6AumJJl2pr1XMAWLx4MTZs2NBl5SGEEFeh+Ea6A2qxI10qIyOjzecjIyO7rCyEEOJKFN9Id0AtdoQQQgghXoImTxBCCCGEeAnqijXvv1dcXAw/P792x0gQQronlmVRV1eHyMhIpzZl93YU3wjxfM7EN0rsABQXFyMqKsrdxSCEuEBRUVGrXT96MopvhHgPR+IbJXYA/Pz8APMbJpfL2zxWp9Nh9+7d3FYu3oTq5pmobiZKpRJRUVHc55mYUHwzobp5JqqbiTPxjRK7ZlPU5XK5Q4FPJpNBLpd75X8yqpvnobpZo+5GaxTfTKhunonqZs2R+EYDUQghhBBCvAQldoQQ0gliY2PBMEyrr2XLlgEA1Go1li1bhuDgYPj6+iIlJQVlZWWtrrNhwwYMGzYMEokEYWFh3PmEEGILdcUSQkgnOHHiBAwGA/dzTk4OZs6ciXvuuQcAsGLFCuzYsQNbtmyBv78/li9fjoULF+LIkSPcOWvXrsUHH3yA999/H2PHjkVDQwPy8/PdUh9CiGegxM6FlGod3vjpHBJjAvHQuBh3F4cQ4kahoaFWP69ZswZxcXGYPHkyamtrkZaWhk2bNmHatGkAgPT0dCQkJODo0aMYN24campq8Nprr+Hnn3/G9OnTuesMGzasy+pQr9Fj5dazGBkVgKUT+3bZ6xJCOo4SOxf6/ngRfvz9Bn78/QbuGtkbPmJ6ewkhgFarxcaNG5GamgqGYZCdnQ2dTocZM2Zwx8THxyM6OhpZWVkYN24cMjIyYDQacePGDSQkJKCurg7jx4/HBx980ObyJRqNBhqNhvtZqVQC5oHaOp2uzXJanrf8+8PJIvx8uhg/ny7GXSMi4OvBMa1l3bwJ1c0zOVM3Z+rvuZ/SbuhSWR33/dWKegzrE+DW8hBCuodt27ZBoVBgyZIlAIDS0lKIRCIEBFjHiPDwcJSWlgIArl27BqPRiL/+9a/46KOP4O/vj9deew0zZ87EmTNnIBKJbL7W6tWr8eabb7Z6fPfu3ZDJZA6V17Ln6e5rPG4o9tfbdiPWC1aSaW8/V09GdfNMjtRNpVI5fD1K7FyooLrpjc+vUlFiRwgBAKSlpWHOnDlObQJvNBqh0+nw8ccfIzk5GQDw3XffISIiAvv27cOsWbNsnrdy5UqkpqZyP1vWv0pOTnZouZOMjAzMnDkTQqEQ//32d6CsAgDQJ34k5g7v5XD5u5uWdfMmVDfP5EzdLC3vjqDEzoVu1DRy31fUado8lhDSMxQUFCAzMxNbt27lHouIiIBWq4VCobBqtSsrK0NERAQAoFcvUxI1ePBg7vnQ0FCEhISgsLDQ7uuJxWKIxeJWjwuFQof/MFqOrajXco9Vq/RW55fWqvHtsQIsvLUP+ob4OHTd7sCZ98HTUN08kyN1c6butNyJCylUTUGwqp4SO0KIaVJEWFgY5s2bxz2WmJgIoVCIPXv2cI/l5uaisLAQSUlJAIAJEyZwj1tUV1ejsrISMTFdMzmrXNkUx8rr1FbPvbvzAj7ZewWv/5TTJWUhhDiGWuxcRGcwokHbtLRBJSV2hPR4RqMR6enpWLx4MQSCpnDr7++Pxx57DKmpqQgKCoJcLsezzz6LpKQkjBs3DgAwcOBA3HnnnfjjH/+If/zjH5DL5Vi5ciXi4+MxderULim/orHpZrW8WS8Ey7L4+XQxAODQ5UqwLEs7fhDSTVCLnYvUNlrPWKlq1oVBCOmZMjMzUVhYiKVLl7Z67sMPP8T8+fORkpKCSZMmISIiwqq7FgC+/vprjB07FvPmzcPkyZMhFAqxa9euLumS0huMUOuM3M/VDU0xTdmotzq2kuIdId0Gtdi5SMvETqn2vqnZhBDnJCcng2VZm89JJBKsW7cO69ats3u+XC5HWloa0tLSOrGUtjVoDFY/N49xVQ3WPRJFNSqE+rUe10cI6XrUYuciCpV1Ilen1ts9lhBCurt6rXUMax7jqhqsW+ioh4KQ7oMSOxepbbQObJTYEUI8Wb26ZWJnf3JYdQONKSaku6DEzkUs3RS9A6QAdcUSQjxcvcaU2MlEfABAnUYPg9HUrdxyTF3LFjxCiPtQYucilha6yAAJYA6KRqPtsTWEENLdNZgTO8vNKssCdeYb1pZdr9XUFUtIt0GJnYuozEudhMtNiR3Lth6jQgghnsLSYhcgE8LH3GpnGWdn6XoV8ExLnFSrKLEjpLugxM5FGs2JXYBMCBHf9LbSODtCiKeyJHY+YgECZKZ9aS1DTirNXa+x5h0nWo7HI4S4DyV2LtKoMyV2UiEfcqlpFZk6GmdHCPFQlq5YX7EAcqlp3TxFo6Ur1tRiFxtsTuw09hO7g5cqcOa6ogtKTAgBJXauY2mxk4oE8BVbEju6iyWEeCbL8BKpkI8AS2Jn7nK1jLGLDZYBbSR2R69V4ZF/Hcfdn2ehtFZt8xhCiGtRYucizYOgTCSweowQQjyNRm/adUIi5CNAZkrsLF2xllmwMeauWHs3sbvPlQEAtHoj9uWWWz1X3aDF+/+7iFNF1JpHiCtRYucianNXrEzEh4/YNNC4kSZPEEI8lMYc0yRCHjfGrqZBB4ORRY3KusXOXmJ3ubyO+z7nRq3Vc+/uuIB1+67iia9PQm8w2jibENIRlNi5iMqcxEmFfEjNLXYtt+QhhBBPYWmxEwuaWuwUjVrUqLRgWYBhgOggS2Jnezzx1fJ67vvLZU3fG40sMs6XAgAq6jS4WFpn83xCiPPcmtjFxsaCYZhWX8uWLQMAqNVqLFu2DMHBwfD19UVKSgrKyspaXWfDhg0YNmwYJBIJwsLCuPO7Ejd5QsTnlgZQUYsdIcRDWXohxAIeN8auVqXjxtcFykQIkJpa8jR6I7R661Y3o5FFqbJpXN21ygbu+8JqFZTNWvnOFVu35hFCOk7gzhc/ceIEDIamVq2cnBzMnDkT99xzDwBgxYoV2LFjB7Zs2QJ/f38sX74cCxcuxJEjR7hz1q5diw8++ADvv/8+xo4di4aGBuTn53d5XRppjB0hxIs0H2Pnb07salRabkZskI+IG3YC8yxakUDE/Vyj0qL5Gu2V9RqodQZIhHzkNUvyAKCgStXZ1SGkx3BrYhcaGmr185o1axAXF4fJkyejtrYWaWlp2LRpE6ZNmwYASE9PR0JCAo4ePYpx48ahpqYGr732Gn7++WdMnz6du86wYcO6vC7NW+wsW/A0OJnYqXUG/D3zMob18cfcob06pZyEEOIIjd7cYifkwV/WtNyJZQ27YB8RBHweZCI+VFoD6tR6BPo0JXaWCRYBMiH0Bhb1Gj1uKBoRF+rbKrHLr7L+mRDScW5N7JrTarXYuHEjUlNTwTAMsrOzodPpMGPGDO6Y+Ph4REdHIysrC+PGjUNGRgaMRiNu3LiBhIQE1NXVYfz48fjggw8QFRVl97U0Gg00mqZNq5VKJQBAp9NBp2t77TnL8y2PU5mn+wt5LCQC02rs9Y3adq/X3D8PXMPnB66CxwDHXp7KjWvpKvbq5g2obp7Jmbp5Y/3dSa2zjLHjNVvuRIdqc4tdiK8YACATCaDSGtDQYuhJZV3TcXyGQW5ZHa7XmBI7SyLXL8QH1yobUGJnKRSVVo/P91/FLb39MeuWiE6sLSHeo9skdtu2bYNCocCSJUsAAKWlpRCJRAgICLA6Ljw8HKWlpkG3165dg9FoxF//+ld89NFH8Pf3x2uvvYaZM2fizJkzEIlENl9r9erVePPNN1s9vnv3bshkMofKm5GRYfWzooEPgMHJo7/iRg0DgI+LV/Owc+dVh9+Dn86ZrmFkgS+2ZmJokHv2mm1ZN29CdfNMjtRNpaLuPFeytNhJhHyuJU6h0nItccG+psd8xHxU1rceU9y8Zc9XLEBuWR1u1DQCANdiNzo2CNcqG1BRp4Etn+27ik/3XQGPATJTJ6NfqC/3nFKtw0+nijE9PgyR5v1sCSHdKLFLS0vDnDlzEBkZ6fA5RqMROp0OH3/8MZKTkwEA3333HSIiIrBv3z7MmjXL5nkrV65Eamoq97NSqURUVBSSk5Mhl8vbfE2dToeMjAzMnDkTQmFTi9or2XsAGJA8fQr4F8qxs+gSQsJ7Y+7coQ7X5+2z+wGYgqFfn0GYO6Wfw+e6gr26eQOqm2dypm6WlnfiGhobLXa1jTouCQsyJ3tSoWWymPXQE67Fzk+MYPOxRTWm5NvSYjembxC+P1mE8joNWJYFwzBW1/glpwQAYGSB7WdK8Nz0AQAAlmXx+IaTOJ5fjQ2hPti9YjL4POtzCempukViV1BQgMzMTGzdupV7LCIiAlqtFgqFwqrVrqysDBERpib5Xr1M49AGDx7MPR8aGoqQkBAUFhbafT2xWAyxWNzqcaFQ6PAfxubHsiwLlXmMnVwqhp/UdO1GvdHh6ynVOlTWN22knV/d6LY/0s68D56G6uaZHKmbt9bdXdSWMXYCPjfGzsg2tbY1dcXaTuwsa90FyUSICjT1hFyvaYRWb+Ra7sb0DQLMCxgr1XpukgbMu1lcrWgae3csrwqAKbG7VtmA4/nVAICrFQ04kV+Ncf2CO+mdIMSzdIt17NLT0xEWFoZ58+ZxjyUmJkIoFGLPnj3cY7m5uSgsLERSUhIAYMKECdzjFtXV1aisrERMTEyXlV+jN4I195o2nzzhzHInhS1mhZXUNrq2kIQQ4gSuxU7Ig1jQFNeumNemaz7GDs1WBrCwLFoslwoQZV7vrrBahcJqFYysKSHsEyiFn8R0fkWd9Ti7vArrCRWni2phME+zPXqtyuq5X69UuqzehHg6tyd2RqMR6enpWLx4MQSCpgZEf39/PPbYY0hNTcW+ffuQnZ2NRx99FElJSRg3bhwAYODAgbjzzjvxxz/+Eb/++itycnKwePFixMfHY+rUqV1Wh+YBzbTcie072LZY7m4t7A0mJoSQrtC8xQ4A1x1rGWMX6mfuiuVWAbC+kbUkdr5iIbeQcVG1CgXmbtjYYB8wDIMwP1OCWN5inN2VCtOixYkxgZCJ+KjX6Lmk8ug1U2tdiHmc37li293w1Q1avPFTDtZmXOKSQguWZZFX2dAqISXE07k9scvMzERhYSGWLl3a6rkPP/wQ8+fPR0pKCiZNmoSIiAir7loA+PrrrzF27FjMmzcPkydPhlAoxK5du7q0W8ay1ImIz4OAz4OP2LyOnRM7T9SoTDP6Iv0lgDmxY1n3TJ4ghJDmY+wAcNuKWVha7CwLsrdusTPFND+JAFFBpskN1Q1a5NwwJWGxIaZkzzJWr6bBelZzfqWpF2NAmC+G9fEHAJwqqgHLslyL3aMT+gIAzpfYTuze/PkcvsoqwMd7LmNDVoHVc2/89xym/m0/5nx0ELUqmlFNvIdTY+wUCgV+/PFHHDp0CAUFBVCpVAgNDcXIkSMxa9YsjB8/3ukCJCcn201gJBIJ1q1bh3Xr1tk9Xy6XIy0tDWlpaU6/tqtYWuYkQlMAtHcH25Zac4tdfC85imvV0OqNqG7QIti39VhAQkjn6IwY56maL1CMZgmYhSWxk9pZkL3evASUn0QAP4kQQT4iVDdocfByBWBusUOzhLFlr0WFeVmVMLkEATIRjl6rxqkiBUbFBqGiTgORgIf7Rkfh/f/loqRWDaVaB7mk6Ya+Tq3DjjMl3M9ph/Oxcojp+/zKBmw8akr08qtUSP81D8/PGNjqPWBZFtkFNQiXS7juZEK6O4da7IqLi/H444+jV69eeOedd9DY2IgRI0Zg+vTp6NOnD/bt24eZM2di8ODB+P777zu/1N2MZesdy1gTHztjTtpiabEL8xNz69dZujwIIZ2LYlxrzbcUA4DIAAn3nK9YwPVM2Bt6YumKtYyhs3THZhfUAM0Su0DL4sctEjvLrNpQXxFGRpsm0P1eqOBa626NDkCIr5hLMFuOUz56rRp6I4veAVIE+4hQUa/FRYVp5uw/Dl2z2hXjv6eKbTYwvPTDGdz9eRamf3AABy5VcI8bjCxW/fcchr+5G8u+/Y17rwjpDhxqsRs5ciQWL16M7OxsqxmozTU2NmLbtm34+9//jqKiIrzwwguuLmu3ZQlolpY6WQda7Cx3qwEyEYJ8RFBY9mQM75QiE0KaoRhnjWVZrsVObO6JsMxsBWDVeiXjumKt411Ti50pcYsOkuFUkYJ7Pi7MkthZWuysu0MrzS12oX5ijIwyJXaXyuqQed60X/jYvqZZsLHBMlTWa5Bf1YAhvf2584+ZE8Apg0IhFvDxryN5OFbOoKJOg/9kXwcApC8Zjac2ZuNaZQPyKhus1sk7e70W/z5pOk5rMOKFLaex50+TIZcITV27v5q2rtxxtgShfmKsuuOWVu9jdkEN/nUkDwFSIf4wtT96N1tv79i1KmReKENcqC/uTuwDAd/tI6OIl3AosTt//jyCg9ueSi6VSvHAAw/ggQceQFVVVZvHehtuOzGhdWKn1hlhMLIOra+kMAe1AJkQIT5iXKtoQFWD7UU7CSGuRTHOmtbQ1Hpl6YptnszFNPteamcLRcsYO19zy15CLzn+e7oYAMBjTD/Dga7YEF8xwuQSRPpLUFyrxr5cU8vZhP4hprIE++BkQU2r/WYvlpomXwzr449hfQLwryN5OFvN4N1fcqHVG3FrdACmDArFiKgAHM+rxvG8aqvE7vuTpiWz5gyJQG5pHa5VNmD1zgu4a2QffLz3MgBg3rBe2HGmBN8eK8ATk/pZJW5nrivw4D+PcgnyLzml+PTBkRgVE4S3t5/HN0ebxvz971wp/vHIKAibJXcGI4u/7ryAH367jiCZCPeNjsKDY6PhJxHieF41vj1WgLM3ahEdJMPjE2yvAnHmugK/FyogFfIxINwX8RFySEV8qHUGXCytw6XSOsilAiT1C+GWtGmOZVluyZle/hKuldby+y1TquEjFiDMT2L375xaZ4CQz6N1BruQQ4ldcHAwNBqNzbXf7B3fk1juVC0Brvl//kadgQtsbbF0QwTKhNxYluoOdMVW1mvgKxZwwZgQ0j6KcdY0zboWLV2xQ3o3Ld4+tE9Ty5hMaG/yhHVX7OjYQO65+Ag5N3SlqSu2qcWOZVlU1llm35p+J6Nig7jE0E8swAhzK15MsCnJzG+x/6wlsRsY7oeEXnIk9QtC1rVq7Dhr2rlo2dT+YBgGY/sGcYnd/WOiudffd9GUQN4zqg98RALc94+j+O54EbacvA6WBe5O7IO/3TMcVfVZOHqtGpuOFeDFWfHc+X/ZlgON3ogxsUFo0OpxrliJh748hhBfMcrrNGAYYGZCOA5drsS+3Aq8s/083rzTNAjQaGTxytaz+P5kEfferP7lIj7ZewXhcrHV+n7XKhqwP7cCk3vxMF1ngFAoxLWKevzlpxwcuWJ9A8JjgF7+UpQp1dA364sW8XmYMTgMdyf2Qb8QX5y5UYuDlypw8FKF1WzlIB8R/KVCVNRpuBZZy/+RAeG+GBjmh5hgH1TUq3GlvB5Xyhu4lleRgGfuwueDAQO9wQidkYXeYASfxyDEV4xQPzECZSIo1aaFsGsatKhRaWE08vHO2f0QCfiwrGFtMLLQG1mu8UQq5EMq5EMi4kPEZ6DVG6HRG7l/9UZTgs2AAcMAljTTsii2gM+Az2Mg5PHA4zFgWdO1DSwLI/ev6Rwjy4JlAYaB6Rxz4spnGBibnWcwsmhrDiTLsmhs5GPydD0CXDjh0+HJE/7+/khKSsLUqVMxdepUjBs3jhYENWvkxtiZApxYwAOPMS3m2aDRO5TY1XAtdiIEmafwV9U7l9jtuVCGJ7/JRt8QH/y8fCKXaBJC2kcxromllYlhTH/0ASAu1Bezb4lATnEtFozszR0rs6wC0Kwr1vLHFAD8xKb3cERUABJ6yXGhRImHk5pamGy12DVoDVxctYyhu290FJfYLby1N0TmhJNL7Kqakp2qeg2XUAwM9wMArJjRH8f/eQwGlsFtA0IwLT4MMG9rBgDH8qq5869W1OOGohEiPg/j+gVDJhLgqUn98MXBa9AbWQwK98Mbt5u67JeMj8XRa9X4/kQR/jh9IEQCHnaeLcXp67WQifhYt+hW+IoFeG1bDn747TrK6zQIlAmx9t4RmBofht3nSvHkN9n4KqsAQ3r74+7EPnjjv+fw/cki8BjgnQVDIeAx+OLgVVytaEB9hR4iPg8piX2QPDgc/ztXis0ninCghIcF649ieFQgfj5TDK3eCCGfwaQBodAajLhQokRlvRY3FKY1UoN8RIiP8ENlvQaXyuqx82wpdpqT3uYkQh6EPB7qNHpUN2itGhz8JAI0ag3Q6I3IuaHkZjzbotUbUa3XorrB9vOV9VouGW+NQYWTfw89BwNXr3/hcGL3+eefY//+/fjXv/6FVatWQSqVYvz48Zg2bRqmTp2K0aNHg8/vmYlE06xYU/0ZhoGPSIA6jd7hteyaWuxECOlgi93nB67CYGRxpbweu8+X4s4RvR04ixACinFWmtaw43EtGgzD4POHE1sda2vyRPPWHF9zi52Az8P3T41DuVKN/mF+3PO2WuwsEydkIj7XAzKhfwjevWsIiqob8ey0/tyxlkkYzbtic8tMCUJ0kIw7f2RUAF4cZkBk/K1IHhLJ1SsxJhB8HoMbikZcr1GhT6AM+83dvWP7BXEtiy/PiUdiTCAq6jW4fXgkN3ZwRkI4wuVilCk1+CWnBPOHReLDzEsAgCdu68e1OH5w73A8fltflCrVGB0bxN3wJ98SgednDMDfMy/j1W05+OlUMQ5fqQTDmM65a2QfAKYWwhP51ahT6zEyOoBbMWFqfBimDQpB6ve/4UpFA66YW/NuGxCCv9411KoLvVypRkG1Cn0CpYiQS7j34HyxEluyi7DjTAkUjTr0D/XFxAEhmDwwFKNiAyEW8KFU63CjphEKlQ6hfmKua9ZgZFFUrUJuWR0ul9WhoEqFUD8x4kJ9MSDcFzFBPjCwLFRaPRo0Bm7suZDHg4DPQMhnoDOwqKzXoKJOg+oGLfwkAoT6iRHsI4aviMHeffsxOmkiwONzk1y4VjIeA72BRaPOALXOgEatAVqDESI+j1tcWyTgQdCsK9jSisaaUyojCxiMRugNplZAvZEFz9wax2dMr8HjMeAxDHhMU6sfywJ6o9Gq9ZBnPp7Pg/l4+13Qer0eR349wg3jchWHE7slS5ZgyZIlAIBr165h//79OHDgAD7//HO89tpr8PHxwW233YYdO3a4tICewNIFIWvWQiYT81Gn0aNB49gECkWjKag174p1ZoydzmDEb4VNA5MP5FZQYkeIEyjGNWlaw679Pzi2EjvL+DofEd9qbJVcIrRakgQAAn1at9g1H1/X3KKxrceSWRK78joNGjR6+IgFyDW3/AyK8LM6tpfMNGZO2OwPqY9YgCG9/XG6SIFj16rRJ1HGzYCdPDCUO45hGCTfEtHq9QV8Hh4cE4MPMy9h3b4r0BlMN9dyiQCP3dbX6tiEXnJubGFzz00bgHPFSmScL8PhK5XgMcCalGFcUgcAPB6DsXa2TZs6KBQvDzegLngwlBoDJvYPwfi44FZ774bJJQiTS1qdPzhSjjcib8Ebt7eeAGIhlwgh79W6BZvPYxAb4oPYEB/MsvH+WLRcLsdROp0OYVLglki517Wg63Q6XPeFy8cfdmiv2H79+qFfv35YunQp8vLykJaWhk8++QS7du1yaeE8hbrF5Alw4+w0DiV2BiOLWnNi5y8TIsgczJzpii1WNFqtrH72Rq1TdSCENOnpMa5pDbv2Z2pKha27YrldJyTt/4mxLO9U26jjxktxS534tT/m0V8mRKBMiBqVDgVVKgyOlONSmWmHikHhfu2eDwDj+gaZEru8KswZGoFj5p0tmid2bVkyIRZph6/hUlk9XthyGgDw1OS4VkmsPTweg08eGIkNv+ajqFqFBSN7c13EjvITAvdNjPW65Ic4z+nErrCwEPv27cP+/fuxf/9+VFZWYty4cXjhhRcwefLkzillN9eyKxbN1rJzpCtW2ajjmoYDpB3rii2sNnVDBMiEUKh0uFJRD5VWz3UjEEIcQzGuKbFzpsWu0arFznqpk7YESE3xjmVNsTDQR8SNj7NsGdae2BAf1BQqUFDVgMGRclwpN7XYDQj3bfdcmLtcvzh4DcfzqnHsWjW0BiN6B0jRP8yx8/2lQrxx+y34kzmpGxUTiCdu6+fQuRYSIR9PT45z6hxCbHH4r/7SpUuxf/9+VFdXY8KECbjtttvw5JNPYvTo0VZ7vPZELSdPNP++3oEWO0sXhK9YAJGAx02ecCaxs4wvSYwOxO9FClQ3aJFX2YBbIv3bPZcQQjGuOY15jJ1lgkJbfMTmrlhd665YRyaOWWZL1mv0qFFpEegjQoUTLXYwd8f+XqhAnnkChWVP2bhQxxKzUbFBYBjTLhSWZUgmDwpt1ZXZlpTEPhgQ7osbNY2YGh/m0HtHSGdwOFpt2LAB0dHRePXVVzF9+nSMHDnSqf/03sxyp9q8K9bXxkwxeyzj6yxdEsE+pmBWrdI6vA5ekbnFLipIBkWjrsOJXb3ONF6PWvNJT0MxrklTi50DXbGW3glN68kTfg50xQJAoI/QnNiZYqFlBmTLMXb2cBMoKlWoqtegRqUDwzie2MklQoyOCcLx/GrsvVgOAJjdxngxe4b1CcCwPgFOn0eIKzl8S3HhwgW8/PLLyM7Oxty5cxEUFITbb78df/vb33Dy5EkYLQu89EDcAsVWkydMAa1B035XrILbdcKUTVlmibFs60U77bG02MUEy9A3xBTk8irszCu3Y/OJ6/jLST5m/v0w1xVCSE9BMa6J1pzYOdLqZFnHTmswQm8wnddyDbv2BFmWPDH3UjjdYhdimvmZV9WAy+bWut4BUqeWfHqo2RIs/UJ9MNG8ADIhnsbhxG7QoEF4+umnsXnzZpSWluLIkSOYO3cujh8/jvnz5yMoKAjz58/v3NJ2Uy23FIN5NhgAhyZP1DRYZsSagpuAz+OSO0e7Yy1j7KKDmiV2lY4ndmqdAR9kXIYRDG4o1PjiwFWHzyXEG7g6xsXGxoJhmFZfy5YtAwCo1WosW7YMwcHB8PX1RUpKCsrKymxeq6qqCn369AHDMFAoFDaPcSUusXNgm6vmcc/SHWtpsXOkKxbNZkxa4l2lnVmx9jQtedLAdcMOcHB8nMXtw3rhheSBmDk4HJ8tuhU82imBeKgODxwZPHgwgoODERgYiMDAQGzevBm//PKLa0vnIdQ2xthZ1k5quc2OLc33ibUI8hGhRqVDZb2GW2DTHpZlucQuJljGBeWrTiR2By9VcF3CAPDj78V4eU4CbQNDeqybjXEnTpyAwdD0+c/JycHMmTNxzz33AABWrFiBHTt2YMuWLfD398fy5cuxcOFCHDlypNW1HnvsMQwbNgw3btxwUe3apjU43mInFpjWEzMYWag0BsglwmaJnWNjOoLMw0+qOtpiZ07sypQaHDcvNDwoovWyIm1hGAbLpw1w6hxCuiOnErvy8nLs37+fmzF26dIliEQijBkzBitWrMDUqVM7r6TdmMrGGDsfbm2n9lvsaputYWcR7GvaNsaRFrsalY4LpH0CZdxWMXkV9WBZ1qFxQtkFNQCAsaFGnFOaZqWdK651erzIDUUj/KVCh+/UCelOXBnjQkOtl8pYs2YN4uLiMHnyZNTW1iItLQ2bNm3CtGnTAADp6elISEjA0aNHMW7cOO689evXQ6FQ4PXXX++ym2et3hRDHBljxzAMZCI+6tR6Lt41cImdY12hwdyEMY1pOzFzi12ogy12/jIht5esZXeKEVE0cYz0TA7/9U1ISMClS5cgEAgwevRo3H333ZgyZQomTJgAiaT1goc9CTd5otnSIpYWO2dmxQZImyV2Po5vK2ZprYuQSyAR8hETZLp7VapNg5EdWRjyt0JTYhcnZ+EbHIg9Fytw5EqVU4nd6l8u4IsD1+AnEeDrpWMwMjrQgbMI6R46M8ZptVps3LgRqampYBgG2dnZ0Ol0mDFjBndMfHw8oqOjkZWVxSV258+fx1tvvYVjx47h2rVrN11Hh8trcHy5E5iXdzIlduauWPMYOx8nu2KrGrSo0+i5yRuOdsUCQGJsEIrNSR0ADI+iSQykZ3I4sVuwYAGmTp2KiRMnQiaTOXBGz9FoY4Fibv9EByZPNN8n1sJyB1vlQItdgXmKf7R56xipiM/dveZV1iPIp+2FLrV6I85cNy1oHOvHIq53sDmxq8QzUxxbV6mgqgH/OGj6w1On1iP136exe8UkCB0Yo0NId9CZMW7btm1QKBTczhalpaUQiUQICLBOPsLDw1FaatqvU6PR4IEHHsD777+P6OhohxM7jUYDjaZp8pNSadq/U6fTQafTtXEmuOcbNaZ/BTy0ew4AyESmz7miQQ2dTsYtdyIVMg6dLze37FXVaVBi3kzUVyyAgDFCp3Ns0srY2AD8bE7s4iP8ECITWL225XtHyuNpqG6eyZm6OVN/hxO71atXO3zRnsbWcifc5AlHljux7BPr07zFzrL7RPuzUy1LnUQHN/0x6hvqg+JaNa5VNCAxpu3E7kKJEhq9EQFSIcIkegzsZzr+RH411DqD1cLL9mw8WgCWNe27WFDVgLzKBmw5eR0Pjo1u91yYxwl+uvcKvsrKR5ifBO/cNQS3Uosf6UKdGePS0tIwZ84cREZGOnzOypUrkZCQgIceesip11q9ejXefPPNVo/v3r3b4YT1Qu4lAHyUldzAzp1F7R6va+QDYHDw12OousCioJgHgIfL53Ows+Jsu+fnVTMA+LhWXIHte0oBCCBjdNi5c6dD5QUAkQEIkfBRqWYwzk9h99yMjAyHr+lpqG6eyZG6qVSqdo+xcDixe+uttxw67vXXX3f4xb2FZVyJ1NbkCQe6YhVttNg5MsbOstRJdLPNnvuG+ODIlSrkV7U/gcLSDTs8yh8M04j+oT4I8xOjvE6D3wprMD6u7Wn/jVoD/n3yOgDgmclxKKxW4a3t57Fu3xXcndjHoQHYW7Kv44MM08bZlfVaLPrnMWz9w3ib+yrawrIsfjpVjMwLZQiQCfHgmBgMjnRu8DTp2TorxhUUFCAzMxNbt27lHouIiIBWq4VCobBqtSsrK0NEhGn9tL179+Ls2bP4z3/+A5j/jwNASEgIXn31VZvJG8wJYWpqKvezUqlEVFQUkpOTIZe3/ZnQ6XTIyMhAdGw/oKgAcbExmDs3od06bio9gaK8GgweNhJzh0YgregoUKvEhLGJmB4f1u75vYoU+GfucbBCKfrfMhA4dwYxEUGYO3d0u+c2N3uWATUqLSIDpHbrNnPmTK/bdovq5pmcqZul5d0RDid2q1atQmRkJMLCwrgA0xLDMD0ysVObuwqsZsU6saUYl9hJbbXYOT7GLqZ5i12Iaaq/I0ue/FZoWj5hZFQAoCoFwzAYHxeMbaeKkXW1qt3E7uczxaht1KF3gBRT48OgMxix/sBV3FA04offruOBMW232uVVNmDVf88BAB6b2Bfni5XIulaFp77Jxk/LJnCbhNvTqDXgpR/OcIOmAeC740VYNiUOy6cNaDex1BmM2HGmBN8eK0DODSV8xHxM7B+Cu27tg4n9Q9qdGcyyLMrrTJNNzt1QokFrQL8QHwyK8MOgCL9WLZ4tJ7SwLAulWo+KOjXKlRoo1TqE+okRGSBFkI+IG+dkMLLQGYwQ8XlWSzEYjSw0BlO3vc6og1pngJE1tSBLRDxIhXxIhXzwWkyiMbIs9Ebzl8FoXofM9BoMGPB4gIDHA48H8BkGAh4PDA+w9260NUmHZVmw3PcAWMDySMtwwjAAAwZgAINeBwc+Qi7RWTEuPT0dYWFhmDdvHvdYYmIihEIh9uzZg5SUFABAbm4uCgsLkZSUBAD44Ycf0NjYyJ1z4sQJLF26FIcOHUJcnP0hEmKxGGJx67FpQqHQ4T+Metb0u5SIBA6dY5n9qjGwEAqF3Pqd/jKJQ+eH+5tiV7VKh+pG081wmNyxc5sTCoWQ+7Q9HtKZ98HTUN08kyN1c6buDid2c+bMwd69ezFq1CgsXboU8+fPB49H46csfxDRaoyd412xlskTgS2WOwGAqob2u2ILm+06YdHPvJbdNQcWKf7NPCN2ZJQ/FLmmx8b3D8G2U8U4cqUSf0oeZPdclmXxTZZpC56HxsWAz2PA55n2PHzb3GqXcqup1e5SWR32XChHqJ8Y84f1gkTIh85gxPObf4dKa8C4fkF4ZW4ClI063LHuMAqrVXjm22ykLR6NohoVfj5djNNFtfCXCjFxQAimx4dBqdZh+abfcbG0DgIeg8cm9kVBlQq7zpXi471XsPt8GRaM7I3y2kYcOsfD/50/CImIj0h/KaKCZPAR8bHrXCmu1zT9AW3UGbDtVDG2nSpGqJ8Yg8L9UK/Ro6pBg6p6LYR8HkJ8RdzvKK+yAZV2EnAeY5rUojWw0OgMUOsN0BlYMAwg4DHg8xgY2aZ1w2yRCHnQG1hutrPlupZEymBkTR/l4/vb/V17orGhPCzogtfpjBhnNBqRnp6OxYsXW21L5u/vj8ceewypqakICgqCXC7Hs88+i6SkJG7iRMvkrbKyEjBP8mg5Ns/VnFnuBM3GFNebEzpLYufsOnYqrQFF1abPoqMzYgkh1hxO7Hbs2IHi4mJ89dVXePHFF/HUU0/hkUcewdKlSzFokP0//N6usdn+iM27Yn0d3HlCozdwrXrNE7sQBydPqHUGlCrVAICYFl2xAJBf1QCjkeVaeBQqLaQiPtcKVKZU44aiETwGGNbHHwctiV1cMADg9PVa1Kl18BEJ8N7/cvFNVj6igmT42z3DMaS3P34vUuDsjVqIBDzcNzqKe/1FY6Px+YGruF7TiLTDeVCqdfjHwWvmJAT4MOMS/pQ8ECfya3D6ei3kEgHW3jsCfB6DQB8RvnxkNBZ+dgRHr1Vj2Ju7ufMsdpwtsfo5xFeEdQ/eirH9TOXecaYEf/kpBxdL67Dml4vmo3gATO9Vy4Q3xFeER5JiMXdoL9SotPjvqWL8fKYYFXUabk2tJgbUNupwtdk1eObti26JlEMuFeJqRT0ultShqkGL4lp1q98bywI6AwudoalecokAoX5iyKVClCs1KFWqYTCyXItwc0bWRlOXeXkKmYgPhmGg1hnQqDPYOswukYAHofn/it7Icq16zlzD1bpqV6/OiHGZmZkoLCzE0qVLWz334YcfgsfjISUlBRqNBrNmzcJnn33mgprcPGcWKEazZU1UmhbLnTi484SvWAARnwetwYjcMlOXk6Nr2BFCrDm12FhkZCRWrlyJlStX4uDBg0hPT8fo0aMxdOhQZGZmQiptPa7B21kmTjCM9ZpPMgd3nqg1d8PyGOvtdyx3sAqVDnqDEQI7AfZ6TSNY1jRZo/myJn0CpRDwGKh1RpQq1YgMkGLDkTys+vk8IuQSbHpiLPqF+uJkvqm1Lj5CbnV33SfQtINFXmUDdp8rw/kSJdIO5wEALpbWYdGXx/DdE+Pw5SHTTL07hkdavb5EyMdTk/rhnR0X8H+7LnKPj48LRl5lA24oGpH679Pc43+7Z7jVuJhBEX7YsHQMVnx/CtdrGiHkM5gyKAzT4sNQUafB3ovlOFVk6kKekRCGd+8ainB5UxfMvGG9MK5fEDafKEJuaR38JXzoK/Nx17Qk6MHgRk0jimoaUd2gwYioQK4F0WJ0bBD+Mn8wTuZXo6RWDR+xAKF+IgT5iKE3GFFRp4GiUQeDkUVUkAyDwv1abV/Esiwq6jQorlVDxOdBIuRBKuJDyOfByLIwGFnoza13Ib7iVl22RiOLOrUeSrUOIgGPWwhWb2ChNRjBsqb/d6xBj4P79uDOeXMgFotalUGjN0JtI8FjGNMuJ5aWQwGPsdudajSyMLCmRM/6+jYPt3q++SUt3zNgzF2ulscZrrzNc1atVov//e9/bb+IC7k6xiUnJ9vt1pVIJFi3bh3WrVvn0LWmTJli91qu5nSLnahpQXaWZbmeCh8H17FjGAahfmLcUDTidJFphn4YJXaEdEiHV5EdPXo08vPzcf78efz+++/Q6XQ9M7Gz7Doh5Fv9UfQxBzqN3thmYmZZ6sRfKrQaNxUgE4HHmFpmqlVahPlJoDMYsfNsCQaE+XETA4qadcM2f30Bn4foYBmuVTTgUlkdBHwG/7fL1BxXqlTj5R/O4vunxuFkgWmV9lGxrWeg3p3YB+//Lxd/2tKUgL02LwE7zpbg90IF5n9yCJaGtMdv69vq/IeTYnD6ei1+Pl2MPoFSvD5/MJJviUCj1oAvDl7FV7/mQyLk46XZ8Ui2seH26NggHHhxKq7XqBDsK7ZKPJ+bPgAKlRYMw8BfanvsQbCvGMum9gfMg1R37szDyOgAh8cqiAQ8jLezX+SAdnYDgfmPVZhcgjB5x9ZA4/EY+MuE8Je1XV6dTgcxHza3QGIYBhIh36GZze2VhWd3dJ0rWb8Gw/LhYG7hcj05xlla7BxZoBgtFmRvNI/xhBNdsTDfjN5QNHJrfzYfWkIIcZzTiV1WVhb+9a9/4d///jcGDhyIRx99FA8++GC7s628lcrG4sRosTBng9YAf6ntAGmZ9dpyggCfxyBQJkJVgxZV9abE7i/bcrD5RBFEfB52PDcRA8L9uMkRlq7X5kZEBeBaRQNO5tcg43wZGnUGhMvFUKh0OJ5fjf+dK8WRK6ZxO6NiWy+J8uCYaGz4NZ/rinx+xgA8fls/3DMqCou+PIqcG6Yukydu64t4G9v3iAV8fPLASPztnmEQ8Xlc4ikV8fH8jIF4fsbAdt5d0/sQE9y6bmgxi5gQV6EY16wr1skxdg0aA7c4MY+xHnfcnqggGY6ZtwNDi1n+hBDHOZzYvffee9iwYQMqKyuxaNEiHDp0CMOGDevc0nkAbnFikXUAFAl4EPIZ6AwsVFq93VYlyxp2QTaSlHC5BFUNWpTUNiIqSIatv5n2idQajEg7nIc1KcO4xC7WRmI3OjYIW3+7ge+OF3L7wH58/0gcuVKJj/dewdMbfwNgGsQ/eWBoq/MDfUT4/slx+P5EEQZHynHHcNMaXP5SIb5/Mgk7zpRALhVglo3WtuYcXb2eEHeiGNeE64p1cIxd8+WdLC1uPmKBQ9sZWjRP5IR8xmpoBSHEcQ4ndi+//DKio6Nx7733gmEYbNiwweZxa9eudWX5uj3LGDuZsPVb6SMWQKHScRMo6jV6fLr3CkZEBWD2EFMyVK2y3WIHAFFBUpwvUaKouhFafQUXbGGeHLDqjlu4der62mjVum1ACBimaQLGtPgwjO0XjFt6+2PT8SJuP8Zp8WHwlwptrmzdL9QXK22sY+UjFuDeZpMlCPF0FOOaWPaKdbTFrvmC7M7OiLWIC/Xlvh8U4dfuMkOEENsc/uRNmjQJDMPg3Llzdo9x5u4MAGJjY1FQUNDq8T/84Q9Yt24d1Go1/vSnP2Hz5s1Ws8bCw8NbnVNVVYXhw4fjxo0bqKmp6fTlACwsiZ1E1LpVykdkSuwsd7B/z7iELw/ngc9jsP+FKYgKkqGmwX6LneUOtrBahbM3TAOKH50Qi1/OlqJUqcbBSxXc7E5bLXZ9AmW4c3gktp0qhkzEx2vzTAmar1iAt++8BX/cfAr+MiFemhPvujeEEA/VGTHOU3V08oRKa7BqsXPG2H5Nw0FG2xgaQghxjMOfvP37Xb9G1okTJ2AwNC0HkpOTg5kzZ+Kee+4BAKxYsQI7duzAli1b4O/vj+XLl2PhwoU4cuRIq2s99thjGDZsGG7cuOHycrZF1WzyREuWWa7KRh1YluWW6DAYWfzvXCkev60fqhtMrWS2W+xMiV1BVQN+Ny8iPDMhHAwY/OtIHr49VogbCtOaTwPDfVudDwD/d/cwzB3aC/ERcqstx+YM7YWp5hXhb3ZgPSHeoDNinKdydrkTy+zXll2xzgjxFePNO27BocsVeGqSY3tUE0Ja6/CsWFcIDbUe17VmzRrExcVh8uTJqK2tRVpaGjZt2oRp06YB5hXcExIScPToUW4RTwBYv349FAoFXn/9dfzyyy9dWgc1N3midXJkWZeuRqVFmVKDkmbrmVm28WpanLj1GDxLi13mhXLAnCiO7hsEqYiPfx3Jw4FLFYB5xwl7EwnEAr7NGaeghI4QYgc3K9bBGGFJ4lRaQ9Madg4uddLc4vGxWDw+1unzCCFNHLodW7NmjcMb0B47dgw7duxwuiBarRYbN27E0qVLwTAMsrOzodPpMGPGDO6Y+Ph4REdHIysri3vs/PnzeOutt/D111+7ZScMW/vEWgT6mJI1hUqH3LI6q+fOXDd1rdqbFQsAw/pYdydPGRQGIZ+HEVEB6BPYtOzCqBjqtiDkZnRFjPMkGmdb7EQ2Jk+I3NpuQEiP5dAn7/z584iJicE999yD22+/HaNGjeJa2/R6Pc6fP4/Dhw9j48aNKC4uxtdff+10QbZt2waFQoElS5YAAEpLSyESiVqNlQsPD0dpaSkAQKPR4IEHHsD777+P6OhoXLt2zaHX0mg00GiadhOwbK6r0+lsTiBorkzRAL0R3HH1atO/Yj7T6lw/811sVZ0ajVrTc+PjgvDr1Wpcr2lERa0K1eYtw+RiXuvzRQz6h/rginkc3cz4EO6Y24dGYP1B04LBtw8Lb7fcjrBcwxXX6m6obp7JmbrdTP27IsZ5EufH2DVNnlCaY6LczkoAhJDO5VBi9/XXX+P06dP49NNP8eCDD0KpVILP50MsFnN3uSNHjsTjjz+OJUuWQCJxfpp6Wloa5syZg8jISIfPWblyJRISEvDQQw859VqrV6/Gm2++2erx3bt3Qyazv3ZStQZ453c+wqV88JgM8BjgbCEPAA8Vxdexc2eh1fFVJabnTl24DLUBAHjw11QgWMxDlYbBVz9lorCCB4BB7umT0NjISycGMLhWwUMfH0Bf8BssL9HXAEyL5CFUwqI29xh25jr1FrQpIyPDdRfrZqhunsmRujna4mZLV8Q4T6JzdoFi802sWmfkJoTZW+KJENK5HG4rHz58OP75z3/iiy++wJkzZ1BQUIDGxkaEhIRgxIgRCAmxvUK/IwoKCpCZmYmtW7dyj0VERECr1UKhUFi12pWVlSEiwjRmbO/evTh79iz+85//AObtiAAgJCQEr776qs3kDeaEMDU1lftZqVQiKioKycnJbS5CmnWtCobfslGsAqKGjsPw6CCc2ZUL3ChA/IB+mDvLesHdkiP5yLxxCf5hkaipUgFQYt7EW6E/XYKMC+WQRcWj/uIVACxS5kyzuW7TXABP12sglwohbNEtcle776xzdDodMjIyMHPmTId3Z/AUVDfP5EzdLC3vHdWZMc7TdLTFDgC3NzIldoS4h9ODIHg8HkaMGIERI0a4rBDp6ekICwvDvHnzuMcSExMhFAqxZ88epKSkAAByc3NRWFiIpKQkAMAPP/yAxsZG7pwTJ05g6dKlOHToEOLi7M+qEovFEItb70MoFArb/OMhEDS9XefLGjAqLhxq83pPPpLW5wb7mhK1WrWBW5YkPtIf16oakXGhHEeuVsNgZMHnMegV6Gt33aaIwK4NkO29D56M6uaZHKmbq+reGTHO0zg7K1bcbEH26zWmmEyJHSHu4fbRrUajEenp6Vi8eLFV4uTv74/HHnsMqampCAoKglwux7PPPoukpCRuRmzL5K2y0rQ9VkJCQqevY1dQZeqe4faKtTF5wjJT9VJpHRq0BvB5DKKDfDC4l6lV8MiVKsC82TUtxkkI6S6cbbFjGAYBMhEq6jQoMC+aTokdIe7h9sQuMzMThYWFWLp0aavnPvzwQ/B4PKSkpFgtUNwdFFab7kotU/tb7hULc8IGAKVKU9dEdJAMIgEPt/S27u6NDOgZG4sTQro/IwvoDM7tPAHzkk0VdRooVKbJE5TYEeIebk/skpOTubFxLUkkEqxbtw7r1q1z6FpTpkyxey1XK6o2tdhZpvbLJa3fyqgWm1j3M+8OESGXIFAmRI05APYPtb24MCGEdDVDsxDqXGJnvWQTzYolxD26fuE3L1FWZ1qmpF5tWYyzdWIXKBNyeygCQH/z7hAMw2BwZFOr3QA7u0YQQkhX0zdtSe3wGDvYSOyoxY4Q93AqsdPpdBAIBMjJyem8EnmIGpUOGr0BdRr7iR3DMIgJbtrDdWRU07i/cX2Due8nDwxtdS4hpOtRjAP0zVvsnEnsfKwTuVC/1hPUCCGdz6muWKFQiOjoaKv9XXuyijpNU4udja5YAJjQPxjnS0zLMIxplsw9dltfVNRrMKxPAAaE+3VRiQkhbaEY19RiJ+Qz4Dkxqat5i51YwLM5PIUQ0vmc7op99dVX8corr6C6urpzSuRBypQa1JkTOz+x7W6HpyfH4c4RkfjbPcMR1GzbMJlIgLfuHIK7E/t0WXkJIe3r6THOktg501oHwCq+hcnFYBia6U+IOzh9S/Xpp5/iypUriIyMRExMDHx8fKye/+2331xZvm6tWNHILXdir8Uu2FeMj+4f2cUlI4R0VE+PcZauWGcmTgBAbLNhJ73kNNOfEHdxOrFbsGBB55TEA1kWHQYAH3HrdewIIZ6np8c4S4udWOBcTOsb2pTYxYbY35qRENK5nE7s3njjjc4piQe6WlEPmO9snQ2ChJDuqafHuI622MUEyRDpL0FxrRqTaEIYIW7ToeVOFAoFvvzyS6xcuZIbh/Lbb7/hxo0bri5ft3aprA6ws4YdIcRz9eQYpzeaxsY5m9gJ+Dx8/1QS/rVkFOYN7dVJpSOEtMfpjOTMmTOYMWMG/P39kZ+fjyeeeAJBQUHYunUrCgsL8fXXX3dOSbuhi6WmxK75oGFCiGfr6TGOa7FzcvIEzIuyt1yYnRDStZz+5KampmLJkiW4fPkyJBIJ9/jcuXNx8OBBV5fPI1BiR4j36OkxjpsV62SLHSGke3D6k3vixAk89dRTrR7v3bs3SktLXVWubk3Mt962LNiHFuIkxFv09BjX0TF2hJDuwelPrlgshlKpbPX4pUuXEBraMwbM+gsBfrOFO6nFjhDv0dNjXNOsWErsCPFETn9y77jjDrz11lvQ6Uwb2DMMg8LCQrz00ktISUnpjDJ2OzwGiJA3tdJF+EvaPJ4Q4jl6eozr6ALFhJDuwelP7gcffID6+nqEhYWhsbERkydPRv/+/eHn54d33323c0rZDfUJbFqAM5oGCxPiNXp6jNNZWuyElNgR4omcnhXr7++PjIwMHD58GGfOnEF9fT1uvfVWzJgxo3NK2E0N7+OPY3k1AIAB4b7uLg4hxEV6eoyzJHYSWpuTEI/kdGKnVqshkUgwceJETJw4sXNK5QHuGNYL3xwtQv8wXwwM83N3cQghLtLTY1xTix0ldoR4IqcTu4CAAIwZMwaTJ0/G1KlTkZSUBKm05+0LOCjCD8dfnQ6xgA8ejza7JsRb9PQYp2NN8UxCXbGEeCSnP7mZmZmYPXs2jh07hjvuuAOBgYGYOHEiXn31VWRkZHROKbspP4mQlgQgxMv09BjHdcVSix0hHsnprGTixIl45ZVXsHv3bigUCuzbtw/9+/fHe++9h9mzZ3dOKQkhpIv09BhHY+wI8Wwd2uT00qVL2L9/P/el0Wgwf/58TJkyxfUlJISQLtaTY1xTix31RhDiiZz+5Pbu3Rvjxo3Drl27MG7cOPzyyy+orKzEjz/+iD/+8Y+dU8rugnXgGEKIR3NVjIuNjQXDMK2+li1bBpgnaSxbtgzBwcHw9fVFSkoKysrKuPNPnz6NBx54AFFRUZBKpUhISMBHH33UKXVuTkcLFBPi0Zz+5IaGhkKlUqG0tBSlpaUoKytDY2Nj55Sum6KpEoR4L1fFuBMnTqCkpIT7sozPu+eeewAAK1aswM8//4wtW7bgwIEDKC4uxsKFC7nzs7OzERYWho0bN+LcuXN49dVXsXLlSnz66acurG1rNMaOEM/mdFfsqVOnoFAocPDgQRw4cACvvPIKzp8/jxEjRmDq1Kk9YgFPQoj3clWMa7n92Jo1axAXF4fJkyejtrYWaWlp2LRpE6ZNmwYASE9PR0JCAo4ePYpx48Zh6dKlVuf369cPWVlZ2Lp1K5YvX+7CGlujxI4Qz9ahMXYBAQG44447MGHCBIwfPx4//fQTvvvuOxw7dowSO0KIx3N1jNNqtdi4cSNSU1PBMAyys7Oh0+msFj2Oj49HdHQ0srKyMG7cOJvXqa2tRVBQ0E3VrT06Iy13Qognczqx27p1Kzeg+Pz58wgKCsLEiRPxwQcfYPLkyZ1TSkII6SKdEeO2bdsGhUKBJUuWAABKS0shEokQEBBgdVx4eDhKS0ttXuPXX3/F999/jx07drT5WhqNBhqNhvtZqVQCAHQ6Hbf/rT06nY5rsRMwbLvHexJLXbypThZUN8/kTN2cqb/Tid3TTz+NSZMm4cknn8TkyZMxdOhQZy9BCCHdVmfEuLS0NMyZMweRkZEdOj8nJwd33nkn3njjDSQnJ7d57OrVq/Hmm2+2enz37t2Qydrf11pnNHXBnso+iYYr3jdjzJvXIqS6eSZH6qZSqRy+ntOJXXl5ubOnEEKIx3B1jCsoKEBmZia2bt3KPRYREQGtVguFQmHValdWVoaIiAir88+fP4/p06fjySefxGuvvdbu661cuRKpqancz0qlElFRUUhOToZcLm/zXJ1Ohzd/2wsAmDQxCSOjAto83pPodDpkZGRg5syZEAqF7i6OS1HdPJMzdbO0vDuiQ2PsDAYDtm3bhgsXLgAABg8ejDvvvBN8Pg22JYR4PlfGuPT0dISFhWHevHncY4mJiRAKhdizZw9SUlIAALm5uSgsLERSUhJ33Llz5zBt2jQsXrzY4bF9YrEYYrG41eNCodChP4yWrlhfidjr/pDCiffBE1HdPJMjdXOm7k6Pjr1y5QoSEhLwyCOPYOvWrdi6dSsefvhh3HLLLbh69apT1/LUdZ4IId7LlTHOaDQiPT0dixcvhkDQdB/t7++Pxx57DKmpqdi3bx+ys7Px6KOPIikpiZs4kZOTg6lTpyI5ORmpqanc8isVFRUur3NzGoPpX5mIbtQJ8UROJ3bPPfcc4uLiUFRUhN9++w2//fYbCgsL0bdvXzz33HNOXctT13kihHgvV8a4zMxMFBYWtlq6BAA+/PBDzJ8/HykpKZg0aRIiIiKsumv/85//oKKiAhs3bkSvXr24r9GjR7uknrYYjSy05lmxPuIOdegQQtzM6U/ugQMHcPToUasp98HBwVizZg0mTJjg1LU8dZ0nQoj3cmWMS05OBsvanoAgkUiwbt06rFu3zubzq1atwqpVq5ws/c1R6Qzc976U2BHikZz+5IrFYtTV1bV6vL6+HiKRqMMF6cp1njq6HIDeoOe+7+lTrz0N1c0zddZyAG3prBjnCRo0phjHY2gdO0I8ldOJ3fz58/Hkk08iLS0NY8aMAQAcO3YMTz/9NO64444OF6Qr13nq6HIAl2oZAKZxJz196rWnorp5JlcvB9CWzopxnqDBPMDORywAw9DmiYR4IqcTu48//hiLFy9GUlISN0tDr9fjjjvuuKmJC125zlNHlwMIvFaFdeezAaDHT732NFQ3z9RZywG0pbNinCdo0Jpa7Hxo4gQhHsvpxC4gIAA//fQTLl++jAsXLoBhGCQkJKB///4dLkRXr/PU0eUABHyBw8d6MqqbZ+rpdXNV3TsjxnmK5i12hBDP1OFP74ABA7hAd7NN9l29zhMhhLTHlTHOU9Q2msYpyiWU2BHiqTo0OjYtLQ1DhgyBRCKBRCLBkCFD8OWXX3aoAJ64zhMhxLu5MsZ5kqoGLQAgxLd1jwYhxDM4fVv2+uuvY+3atXj22We5lrOsrCysWLEChYWFeOutt5y6XnvrPPF4PKSkpECj0WDWrFn47LPPuOebr/O0ceNG7vGYmBjk5+c7WzVCCHF5jPMk1ebELsjHO7v0CekJnE7s1q9fj3/+85944IEHuMfuuOMODBs2DM8++6zTQc/T1nkihHg3V8c4T1JY0wgAiJBL3F0UQkgHOd0Vq9PpMGrUqFaPJyYmQq/X2zyHEEI8RU+OcZYWuwh/SuwI8VROJ3YPP/ww1q9f3+rxf/zjH1i0aJGrykUIIW7Ro2OcufOkZ0wVIcQ7dWjqU1paGnbv3s1NYjh27BgKCwvxyCOPWK0Pt3btWteVlBBCukhPjXGsObPrIZOACfFKTid2OTk5uPXWWwEAV69eBQCEhIQgJCQEOTk53HE9ZXkAQoh36ckxjuVa7LyvboT0FE4ndvv27euckhBCSDfQk2OcZRqbF+ashPQYtMszIYQQwKrFjhDiqSixc4LtRVkIIcQ7sNzsCUrtCPFUlNh1BMU8Qog3ohY7QjweJXaEEEIAGmNHiFegxI4QQggAcLsAUV5HiOeixI4QQghg1WJHqR0hnooSO0IIIQDNiiXEK1BiRwghBKAxdoR4BUrsCCGEAM3G2BFCPBcldoQQQqzQGDtCPBcldoQQQgAaY0eIV6DEjhBCCEBj7AjxCpTYEUIIAazWsaPMjhBPRYkdIYQQgFrsCPEKlNgRQggBaIwdIV6BEjtCCCEAABaU2RHi6SixI4QQYmLJ66gvlhCPRYkdIYQQoPkYOzeXgxDScZTYEUIIAZqPsaPMjhCPRYkdIYQQoNkYO8rrCPFclNgRQggBrFrsKLUjxFNRYkcIIQSg5U4I8QpuTexiY2PBMEyrr2XLlgEA1Go1li1bhuDgYPj6+iIlJQVlZWVW1ygsLMS8efMgk8kQFhaGF198EXq93k01IoQQE0+Mb5bJE5TZEeK53JrYnThxAiUlJdxXRkYGAOCee+4BAKxYsQI///wztmzZggMHDqC4uBgLFy7kzjcYDJg3bx60Wi1+/fVXfPXVV9iwYQNef/11t9WJEELgqfGNthQjxOO5NbELDQ1FREQE97V9+3bExcVh8uTJqK2tRVpaGtauXYtp06YhMTER6enp+PXXX3H06FEAwO7du3H+/Hls3LgRI0aMwJw5c/D2229j3bp10Gq17qwaIaSH88T4RluKEeL5BO4ugIVWq8XGjRuRmpoKhmGQnZ0NnU6HGTNmcMfEx8cjOjoaWVlZGDduHLKysjB06FCEh4dzx8yaNQvPPPMMzp07h5EjR9p8LY1GA41Gw/2sVCoBADqdDjqdzm4ZTxVWc9+3dZynstSJ6uZZqG5w+Bh38YT4BgC5ZfUAAINe363fz46gz4lnorrB4WMsuk1it23bNigUCixZsgQAUFpaCpFIhICAAKvjwsPDUVpayh3TPOhZnrc8Z8/q1avx5ptvtnp89+7dkMlkds+rrGIA8CEXsly3ijeiunmmnl43lUrVJWXpCE+IbwAQIOJDoWVw5Ww26q86UUEP0tM/J56qp9fNmfjWbRK7tLQ0zJkzB5GRkZ3+WitXrkRqair3s1KpRFRUFJKTkyGXy+2el6hUI+FKJbRFZzBz5kwIhcJOL2tX0ul0yMjIoLp5GKqbiaVlqjvyhPgGAILoEuTm/I6H7+zZ/5c8DdXNM3VWfOsWiV1BQQEyMzOxdetW7rGIiAhotVooFAqru9qysjJERERwxxw/ftzqWpZZZZZjbBGLxRCLxa0eFwqFbb65fYKFuEsuwc7SM+0e68mobp6pp9etu9bdU+IbACQP6QV94e89/v+Sp6K6eSZXx7dusY5deno6wsLCMG/ePO6xxMRECIVC7Nmzh3ssNzcXhYWFSEpKAgAkJSXh7NmzKC8v547JyMiAXC7H4MGDu7gWhBDSGsU3QkhXcnuLndFoRHp6OhYvXgyBoKk4/v7+eOyxx5CamoqgoCDI5XI8++yzSEpKwrhx4wAAycnJGDx4MB5++GG89957KC0txWuvvYZly5bZvGMlhJCuRPGNENLV3J7YZWZmorCwEEuXLm313Icffggej4eUlBRoNBrMmjULn332Gfc8n8/H9u3b8cwzzyApKQk+Pj5YvHgx3nrrrS6uBSGEtEbxjRDS1dye2CUnJ4NlWZvPSSQSrFu3DuvWrbN7fkxMDHbu3HlTZbC8viODE3U6HVQqFZRKpdf191PdPBPVzcTy+bUXT9yB4lv3QXXzTFQ3E2fim9sTu+6grq4OABAVFeXuohBCblJdXR38/f3dXYxug+IbId7DkfjGsN3p9tZNjEYjiouL4efnB6adJdctSwcUFRW1u3SAp6G6eSaqmwnLsqirq0NkZCR4vG4xL6xboPhmQnXzTFQ3E2fiG7XYAeDxeOjTp49T58jlcq/7T2ZBdfNMVDdQS50NFN+sUd08E9XN8fhGt7WEEEIIIV6CEjtCCCGEEC9BiZ2TxGIx3njjDa9cR4rq5pmobsRVvPn9prp5Jqqb82jyBCGEEEKIl6AWO0IIIYQQL0GJHSGEEEKIl6DEjhBCCCHES1BiRwghhBDiJSixc8K6desQGxsLiUSCsWPH4vjx4+4u0k1btWoVGIax+oqPj3d3sTrk4MGDuP322xEZGQmGYbBt2zar51mWxeuvv45evXpBKpVixowZuHz5stvK64z26rZkyZJWv8fZs2e7rbzOWL16NUaPHg0/Pz+EhYVhwYIFyM3NtTpGrVZj2bJlCA4Ohq+vL1JSUlBWVua2MnsrinHdG8U4z4tx7ohvlNg56Pvvv0dqaireeOMN/Pbbbxg+fDhmzZqF8vJydxftpt1yyy0oKSnhvg4fPuzuInVIQ0MDhg8fbndT9ffeew8ff/wxPv/8cxw7dgw+Pj6YNWsW1Gp1l5fVWe3VDQBmz55t9Xv87rvvurSMHXXgwAEsW7YMR48eRUZGBnQ6HZKTk9HQ0MAds2LFCvz888/YsmULDhw4gOLiYixcuNCt5fY2FOO6P4pxnhfj3BLfWOKQMWPGsMuWLeN+NhgMbGRkJLt69Wq3lutmvfHGG+zw4cPdXQyXA8D++OOP3M9Go5GNiIhg33//fe4xhULBisVi9rvvvnNTKTumZd1YlmUXL17M3nnnnW4rkyuVl5ezANgDBw6wrPn3JBQK2S1btnDHXLhwgQXAZmVlubGk3oVinGehGOeZuiK+UYudA7RaLbKzszFjxgzuMR6PhxkzZiArK8utZXOFy5cvIzIyEv369cOiRYtQWFjo7iK5XF5eHkpLS61+h/7+/hg7dqxX/A4BYP/+/QgLC8OgQYPwzDPPoKqqyt1F6pDa2loAQFBQEAAgOzsbOp3O6ncXHx+P6Ohor/nduRvFOM9HMc4zdEV8o8TOAZWVlTAYDAgPD7d6PDw8HKWlpW4rlyuMHTsWGzZswK5du7B+/Xrk5eXhtttuQ11dnbuL5lKW35M3/g5h7qL4+uuvsWfPHvzf//0fDhw4gDlz5sBgMLi7aE4xGo14/vnnMWHCBAwZMgQw/+5EIhECAgKsjvWW3113QDHO81GM6/66Kr4JXFJa4rHmzJnDfT9s2DCMHTsWMTEx+Pe//43HHnvMrWUjjrv//vu574cOHYphw4YhLi4O+/fvx/Tp091aNmcsW7YMOTk5HjsGinQ/FOO8gzfEuK6Kb9Ri54CQkBDw+fxWs1TKysoQERHhtnJ1hoCAAAwcOBBXrlxxd1FcyvJ76gm/QwDo168fQkJCPOr3uHz5cmzfvh379u1Dnz59uMcjIiKg1WqhUCisjvfW3507UIzzfBTjureujG+U2DlAJBIhMTERe/bs4R4zGo3Ys2cPkpKS3Fo2V6uvr8fVq1fRq1cvdxfFpfr27YuIiAir36FSqcSxY8e87ncIANevX0dVVZVH/B5ZlsXy5cvx448/Yu/evejbt6/V84mJiRAKhVa/u9zcXBQWFnrl784dKMZ5Popx3ZNb4pvLpnp4uc2bN7NisZjdsGEDe/78efbJJ59kAwIC2NLSUncX7ab86U9/Yvfv38/m5eWxR44cYWfMmMGGhISw5eXl7i6a0+rq6tjff/+d/f3331kA7Nq1a9nff/+dLSgoYFmWZdesWcMGBASwP/30E3vmzBn2zjvvZPv27cs2Nja6u+jtaqtudXV17AsvvMBmZWWxeXl5bGZmJnvrrbeyAwYMYNVqtbuL3q5nnnmG9ff3Z/fv38+WlJRwXyqVijvm6aefZqOjo9m9e/eyJ0+eZJOSktikpCS3ltvbUIzr/ijGeV6Mc0d8o8TOCZ988gkbHR3NikQidsyYMezRo0fdXaSbdt9997G9evViRSIR27t3b/a+++5jr1y54u5idci+fftYAK2+Fi9ezLLm5QD+8pe/sOHh4axYLGanT5/O5ubmurvYDmmrbiqVik1OTmZDQ0NZoVDIxsTEsE888YTH/EG2VS8AbHp6OndMY2Mj+4c//IENDAxkZTIZe9ddd7ElJSVuLbc3ohjXvVGM87wY5474xphfmBBCCCGEeDgaY0cIIYQQ4iUosSOEEEII8RKU2BFCCCGEeAlK7AghhBBCvAQldoQQQgghXoISO0IIIYQQL0GJHSGEEEKIl6DEjhBCCCHES1BiR7ql/fv3g2GYVhsjd5U9e/YgISEBBoOh3WN37dqFESNGwGg0dknZCCGejeIb6UyU2BG3mzJlCp5//nmrx8aPH4+SkhL4+/u7pUx//vOf8dprr4HP57d77OzZsyEUCvHtt992SdkIIZ6D4hvpapTYkW5JJBIhIiICDMN0+WsfPnwYV69eRUpKisPnLFmyBB9//HGnlosQ4h0ovpHORIkdcaslS5bgwIED+Oijj8AwDBiGQX5+fquuig0bNiAgIADbt2/HoEGDIJPJcPfdd0OlUuGrr75CbGwsAgMD8dxzz1l1L2g0Grzwwgvo3bs3fHx8MHbsWOzfv7/NMm3evBkzZ86ERCLhHjt9+jSmTp0KPz8/yOVyJCYm4uTJk9zzt99+O06ePImrV692yvtECPE8FN+IOwjcXQDSs3300Ue4dOkShgwZgrfeegsAEBoaivz8/FbHqlQqfPzxx9i8eTPq6uqwcOFC3HXXXQgICMDOnTtx7do1pKSkYMKECbjvvvsAAMuXL8f58+exefNmREZG4scff8Ts2bNx9uxZDBgwwGaZDh06hAcffNDqsUWLFmHkyJFYv349+Hw+Tp06BaFQyD0fHR2N8PBwHDp0CHFxcS5+lwghnojiG3EHSuyIW/n7+0MkEkEmkyEiIqLNY3U6HdavX88FlrvvvhvffPMNysrK4Ovri8GDB2Pq1KnYt28f7rvvPhQWFiI9PR2FhYWIjIwEALzwwgvYtWsX0tPT8de//tXm6xQUFHDHWxQWFuLFF19EfHw8ANgMmpGRkSgoKOjwe0EI8S4U34g7UGJHPIZMJrO6WwwPD0dsbCx8fX2tHisvLwcAnD17FgaDAQMHDrS6jkajQXBwsN3XaWxstOqmAIDU1FQ8/vjj+OabbzBjxgzcc889re5cpVIpVCrVTdeTENLzUHwjrkKJHfEYzbsGAIBhGJuPWabl19fXg8/nIzs7u9Xsr+bBsqWQkBDU1NRYPbZq1So8+OCD2LFjB3755Re88cYb2Lx5M+666y7umOrqaoSGht5UHQkhPRPFN+IqlNgRtxOJRA6tp+SskSNHwmAwoLy8HLfddptT550/f77V4wMHDsTAgQOxYsUKPPDAA0hPT+cCn1qtxtWrVzFy5EiX1oEQ4tkovpGuRrNiidvFxsbi2LFjyM/PR2VlpcsWwhw4cCAWLVqERx55BFu3bkVeXh6OHz+O1atXY8eOHXbPmzVrFg4fPsz93NjYiOXLl2P//v0oKCjAkSNHcOLECSQkJHDHHD16FGKxGElJSS4pOyHEO1B8I12NEjvidi+88AL4fD4GDx6M0NBQFBYWuuza6enpeOSRR/CnP/0JgwYNwoIFC3DixAlER0fbPWfRokU4d+4ccnNzAQB8Ph9VVVV45JFHMHDgQNx7772YM2cO3nzzTe6c7777DosWLYJMJnNZ2Qkhno/iG+lqDMuyrLsLQUh38+KLL0KpVOKLL75o99jKykoMGjQIJ0+eRN++fbukfIQQ0lEU37wbtdgRYsOrr76KmJgYh7pN8vPz8dlnn1HQI4R4BIpv3o1a7AghhBBCvAS12BFCCCGEeAlK7AghhBBCvAQldoQQQgghXoISO0IIIYQQL0GJHSGEEEKIl6DEjhBCCCHES1BiRwghhBDiJSixI4QQQgjxEpTYEUIIIYR4CUrsCCGEEEK8BCV2hBBCCCFeghI7QgghhBAvQYkdIYQQQoiXoMSOEEIIIcRLUGJHCCGEEOIlKLEjHm3JkiWIjY11dzEIIcTlKL6RjqDEjrjMhg0bwDAM9yWRSDBw4EAsX74cZWVl7i6ey+Xl5WH58uUYOHAgZDIZZDIZBg8ejGXLluHMmTNWxx48eBB33HEHoqKiIJFIEBERgdmzZ+PIkSNuKz8hxHEU3+zHt5aeeOIJMAyD+fPnd1l5SROBuwtAvM9bb72Fvn37Qq1W4/Dhw1i/fj127tyJnJwcyGQydxfPJbZv34777rsPAoEAixYtwvDhw8Hj8XDx4kVs3boV69evR15eHmJiYgAAly5dAo/Hw9NPP42IiAjU1NRg48aNmDRpEnbs2IHZs2e7u0qEEAdQfGsd35o7efIkNmzYAIlE4payEwAsIS6Snp7OAmBPnDhh9XhqaioLgN20aZPLX3Px4sVsTEyMy6/blitXrrA+Pj5sQkICW1xc3Op5nU7HfvTRR2xhYWGb12loaGDDw8PZWbNmdWJpCSGuQPHNpK34ZjQa2aSkJHbp0qVsTEwMO2/evC4qNWmOumJJp5s2bRpgbtp3xsaNG5GYmAipVIqgoCDcf//9KCoqavc8o9GIv//977jlllsgkUgQHh6Op556CjU1Na2O/eWXXzB58mT4+flBLpdj9OjR2LRpU5vXf++999DQ0ID09HT06tWr1fMCgQDPPfccoqKi2ryOTCZDaGgoFApFu3UihHRPFN+afPPNN8jJycG7777bbj1I56HEjnS6q1evAgCCg4MdPufdd9/FI488ggEDBmDt2rV4/vnnsWfPHkyaNKndROipp57Ciy++iAkTJuCjjz7Co48+im+//RazZs2CTqfjjtuwYQPmzZuH6upqrFy5EmvWrMGIESOwa9euNq+/fft29O/fH2PHjnW4PhZKpRKVlZW4ePEiXnnlFeTk5GD69OlOX4cQ0j1QfDOpq6vDSy+9hFdeeQURERFOnUtczN1NhsR7WLoqMjMz2YqKCraoqIjdvHkzGxwczEqlUvb69esOXSc/P5/l8/nsu+++a/X42bNnWYFAYPV4y66KQ4cOsQDYb7/91urcXbt2WT2uUChYPz8/duzYsWxjY6PVsUaj0W7ZamtrWQDsggULWj1XU1PDVlRUcF8qlarVMbNmzWIBsABYkUjEPvXUU61enxDS/VB8azu+vfDCC2zfvn1ZtVrNsixLXbFuRC12xOVmzJiB0NBQREVF4f7774evry9+/PFH9O7d26Hzt27dCqPRiHvvvReVlZXcV0REBAYMGIB9+/bZPXfLli3w9/fHzJkzrc5NTEyEr68vd25GRgbq6urw8ssvtxrkyzCM3esrlUoAgK+vb6vnpkyZgtDQUO5r3bp1rY5Zs2YNdu/ejbS0NIwbNw5arRZ6vd6h94UQ4n4U31rHt0uXLuGjjz7C+++/D7FY7ND7QDoPzYolLrdu3ToMHDgQAoEA4eHhGDRoEHg8x+8hLl++DJZlMWDAAJvPC4XCNs+tra1FWFiYzefLy8uBZt0nQ4YMcbhcAODn5wcAqK+vb/XcF198gbq6OpSVleGhhx6yef6IESO47x966CHceuutWLJkCf7zn/84VQ5CiHtQfGsd3/74xz9i/PjxSElJcer1SOegxI643JgxYzBq1KgOn280GsEwDH755Rfw+fxWz9u6m2x+blhYGL799lubz4eGhna4XADg7++PXr16IScnp9VzljEp+fn5Dl1LJBLhjjvuwJo1a9DY2AipVHpTZSOEdD6Kb9bxbe/evdi1axe2bt1q9Zxer0djYyPy8/MRFBQEuVx+U2UjjqPEjnQ7cXFxYFkWffv2xcCBA50+NzMzExMmTGgzUYqLiwMA5OTkoH///k69xrx58/Dll1/i+PHjGDNmjFPnttTY2AiWZVFXV0eJHSE9gLfFt8LCQgDAwoULWz1348YN9O3bFx9++CGef/55p8pBOo7G2JFuZ+HCheDz+XjzzTfBsqzVcyzLoqqqyu659957LwwGA95+++1Wz+n1em7GWXJyMvz8/LB69Wqo1epWr9GWP//5z5DJZFi6dKnNFedtnW/pImlOoVDghx9+QFRUlN2uFUKId/G2+DZt2jT8+OOPrb5CQ0MxatQo/Pjjj7j99tvbfE3iWtRiR7qduLg4vPPOO1i5ciXy8/OxYMEC+Pn5IS8vDz/++COefPJJvPDCCzbPnTx5Mp566imsXr0ap06dQnJyMoRCIS5fvowtW7bgo48+wt133w25XI4PP/wQjz/+OEaPHo0HH3wQgYGBOH36NFQqFb766iu75RswYAA2bdqEBx54AIMGDeJWZmdZFnl5edi0aRN4PB769OnDnTNnzhz06dMHY8eORVhYGAoLC5Geno7i4mJ8//33nfI+EkK6H2+Lb9HR0YiOjm51neeffx7h4eFYsGCBC9894hB3T8sl3sPeyuwd9cMPP7ATJ05kfXx8WB8fHzY+Pp5dtmwZm5ubyx1jb2X2f/zjH2xiYiIrlUpZPz8/dujQoeyf//znViup//e//2XHjx/PSqVSVi6Xs2PGjGG/++47h8p35coV9plnnmH79+/PSiQSViqVsvHx8ezTTz/Nnjp1yurYTz/9lJ04cSIbEhLCCgQCNjQ0lL399tvZgwcPdvj9IYR0HYpv9uObLbTcifswbHvtsoQQQgghxCPQGDtCCCGEEC9BY+xIlyotLW3zealUCn9//y4rDyGEuArFN9IdUFcs6VJtrXoOAIsXL8aGDRu6rDyEEOIqFN9Id0AtdqRLZWRktPl8ZGRkl5WFEEJcieIb6Q6oxY4QQgghxEvQ5AlCCCGEEC9BXbHm/feKi4vh5+fX7hgJQkj3ZNmaLTIy0qlN2b0dxTdCPJ8z8Y0SOwDFxcWIiopydzEIIS5QVFRktetHT0fxjRDv4Uh8o8QOgJ+fH2B+w+RyeZvH6nQ67N69m9vKxZtQ3TwT1c1EqVQiKiqK+zwTE4pvJlQ3z0R1M3EmvlFi12yKulwudyjwyWQyyOVyr/xPRnXzPFQ3a9TdaI3imwnVzTNR3aw5Et9oIAohhBBCiJegxI4QQgghxEtQYuekvMoGNOrdXQpCCOk8Wr0RZ64rQMucEuJ5KLFzQmGVCskfHcE7v/PdXRRCCOk0nx+8hjs+PYL3/pfr7qIQQpxEiZ0TztxQAADq9Qx0BqO7i0MIIZ3ii0P5AID1+6+6uyiEECdRYueEQJmI+76yXuvWshBCSGfR6jt243qhRIm/Z15CvYbGqxDiLrTciROazzJWNurcWRRCCOkUhhbD6oxGFjyeY0vIrPj+FC6W1kHAY7B82oDOKSAhpE3UYtdBdXRHSgjxQvUt7lkdjXV6gxEXS+sAAPtyKzqjaIQQB1Bi10F1akrsCCHep65FYlercqx3orxOw31Ps2kJcR9K7DqIEjtCiDeq11l3u9Y6OOykpLaR+755kkcI6VqU2HVQo87g7iIQQojLtWyxq1M7ltgpmrXsOdrKRwhxPUrsOkhNiR0hxAu1TOwcvYltflydRg+DkbpjCXEHSuw6SK2jdewIId6nrkVXrErrYGLX4jhHW/oIIa5FiV0HafTUYkcI8T4dbbFr2YuhpL0XCXELSuw6iFrsCCHeqOVyJy1b4uxpmQAqqcWOELegxK6D1B1cmZ0QQrozS1dskI9ppx2Hx9hprWMiLeJOiHtQYtdBGpo8QQjxQnXm3RKjgmTATbTYNTh4HiHEtSix6yDqiiWEeBuWZVFnHhoXFSgFbmKMnUpLY+wIcQdK7DpITZMnCCFeprZRDyNr6ortE+hki12L4xw9jxDiWm5N7GJjY8EwTKuvZcuWobq6Gs8++ywGDRoEqVSK6OhoPPfcc6itrbW6RmFhIebNmweZTIawsDC8+OKL0Os7/05RQy12hPQYbcUqAFCr1Vi2bBmCg4Ph6+uLlJQUlJWVcedv2LDB5vkMw6C8vNyp112zZk2n1bOy3rRjhJ9EAH+pEHBmuRPqiiWkWxC488VPnDgBg6Hpw5+Tk4OZM2finnvuQXFxMYqLi/G3v/0NgwcPRkFBAZ5++mkUFxfjP//5DwDAYDBg3rx5iIiIwK+//oqSkhI88sgjEAqF+Otf/9qpZacWO0J6jrZiFQCsWLECO3bswJYtW+Dv74/ly5dj4cKFOHLkCADgvvvuw+zZs62uuWTJEqjVaoSFhbX52m+99RaeeOIJ7mc/Pz8X165JhTmxC/ERQSQw3fdrDY7dxLZM7BqpK5YQt3BrYhcaGmr185o1axAXF4fJkyeDYRj88MMP3HNxcXF499138dBDD0Gv10MgEGD37t04f/48MjMzER4ejhEjRuDtt9/GSy+9hFWrVkEkEnVa2bU0K5aQHqOtWFVbW4u0tDRs2rQJ06ZNAwCkp6cjISEBR48exbhx4yCVSiGVSrnzKyoqsHfvXqSlpbX72n5+foiIiOiEWrVWVG3a7zUqSAqxJbFz8CbWMsYuUCZEjUrncEsfIcS13JrYNafVarFx40akpqaCYRibx9TW1kIul0MgMBU7KysLQ4cORXh4OHfMrFmz8Mwzz+DcuXMYOXJkp5VXZ6DtcgjpiVrGquzsbOh0OsyYMYM7Jj4+HtHR0cjKysK4ceNaXePrr7+GTCbD3Xff3e7rrVmzBm+//Taio6Px4IMPYsWKFVwMtEWj0UCj0XA/K5VKAIBOp4NO1/YSJBdLTcf2CZCAz5hinFpnaPc8AFBpTC10gTIRalQ61Kvbf72uZClLdyqTq1DdPJMzdXOm/t0msdu2bRsUCgWWLFli8/nKykq8/fbbePLJJ7nHSktLrZI6ANzPpaWldl+ro4HP0OzOVat3LNh5EvoAeSaqGxw+xhVaxqrS0lKIRCIEBARYHRceHm43DqWlpeHBBx+0asWz5bnnnsOtt96KoKAg/Prrr1i5ciVKSkqwdu1au+esXr0ab775ZqvHd+/eDZlM1ubrZefyAPBgqCrE+ZpCAHyUlJVj586dbZ4HAGVVfAAMGE09AAa5V/Oxc+e1ds/rahkZGe4uQqehunkmR+qmUqkcvl63SezS0tIwZ84cREZGtnpOqVRi3rx5GDx4MFatWnXTr9XRwHe5lgHABwAolPUOBTtP1NM/QJ6qp9fNmcB3M9qKVY7IysrChQsX8M0337R7bGpqKvf9sGHDIBKJ8NRTT2H16tUQi8U2z1m5cqXVeUqlElFRUUhOToZcLm/z9X6oOAkoqjFsyC2Qy8T45sppyAOCMHfumHbL+tHlw0CDCnFR4bh6vhwh4ZGYO3dYu+d1FZ1Oh4yMDMycORNCodDdxXEpqptncqZulgYoR3SLxK6goACZmZnYunVrq+fq6uowe/Zs+Pn54ccff7SqfEREBI4fP251vGUmWltjUjoa+I5eq8an508CAIQSKebOneRkTbs3+gB5JqqbiTOBr6NsxaqIiAhotVooFAqrVruysjKbcejLL7/EiBEjkJiY6PTrjx07Fnq9Hvn5+Rg0aJDNY8Risc2kTygUtvseMjzTuDo+nw+Z2HSszsA69P/KsrZniJ/E9LPe2C3/PzryPngqqptncqRuztS9WyR26enpCAsLw7x586weVyqVmDVrFsRiMf773/9CIpFYPZ+UlIR3330X5eXl3MyyjIwMyOVyDB482O7rdTTw8QV87ntHg50n6ukfIE/V0+vWFXW3FasSExMhFAqxZ88epKSkAAByc3NRWFiIpKQkq/Pr6+vx73//G6tXr+7Q6586dQo8Hq/dmbQd1mzosGVWrMbBiWKWWbEh5q3IaPIEIe7h9sTOaDQiPT0dixcvthoQrFQqkZycDJVKhY0bN0KpVHJ35KGhoeDz+UhOTsbgwYPx8MMP47333kNpaSlee+01LFu2zG43havoHFwCgBDiHezFKn9/fzz22GNITU1FUFAQ5HI5nn32WSQlJbWaOPH9999Dr9fjoYceanX948eP45FHHsGePXvQu3dvZGVl4dixY5g6dSr8/PyQlZWFFStW4KGHHkJgYGCn1pVhABHfMivWucQuiEvsaLkTQtzB7YldZmYmCgsLsXTpUqvHf/vtNxw7dgwA0L9/f6vn8vLyEBsbCz6fj+3bt+OZZ55BUlISfHx8sHjxYrz11ludXm5H13YihHgHe7EKAD788EPweDykpKRAo9Fg1qxZ+Oyzz1odl5aWhoULF7aaaAHzGMHc3FxuEohYLMbmzZuxatUqaDQa9O3bFytWrLAaRtKZnGmxMxpZris2yNd0U00tdoS4h9sTu+TkZLBs66VDpkyZYvPxlmJiYtwyiYHWsSOkZ7EXqwBAIpFg3bp1WLduXZvX+PXXX+0+1zLm3XrrrTh69OhNlPjmOLNAcfPkL9jcYufoHrOEENeivWI7SGdgHUo8CSHEU7DNBtk1LVDcfmLXPIkLlJkTO2qxI8QtKLG7CXojJXaEEO/DgIGIb5os5kxiJxLw4Cs2dQRRVywh7kGJ3U2g7lhCiLdypivW0jonFfIhFZkSwkadgXo1CHEDp8bYKRQK/Pjjjzh06BAKCgqgUqkQGhqKkSNHYtasWRg/fnznlbQbopmxhHRfFK+cx9pY7sRgZGEwsuDzbG/1iGb7xDZP7GBe2675z4SQzudQi11xcTEef/xx9OrVC++88w4aGxsxYsQITJ8+HX369MG+ffswc+ZMDB48GN9//33nl7qboJmxhHQ/JSUlFK9cwJLYwYHeCUtXrFTEh1TYlMjRkieEdD2HWuxGjhyJxYsXIzs72+7Cv42Njdi2bRv+/ve/o6ioCC+88IKry9rtUFcsId3PbbfdhiVLllC8ugnN17GDOda11fLWvCuWz2MgFvCg0RtpZiwhbuBQYnf+/HkEBwe3eYxUKsUDDzyABx54AFVVVa4qX7emM9D4EUK6m+PHjyM2NrbNY3pivHKWkN/U9aoxGADY39mjeYud5V+N3kgzYwlxA4e6YoODg6HRaBy+aHtJoLegMXaEdD9BQUEUrzqo+a0qwzBNEyja6Z1oPsYOAGTmf2lmLCFdz+HJE/7+/khKSsLUqVMxdepUjBs3zmv3pXQUdcUS0j1RvLo5lrY6MZ8Hrd7Y/hg7cwInETa12IEWKSbELRxe7uTzzz9HTEwM/vWvf2Hy5MkICAjAzJkzsXr1ahw9ehQGQ8/7ANPkCUK6J4pXriEwd8e2t2anra5Y0CLFhLiFw4ndkiVLsGHDBuTn5+PKlSv45JNPEBkZic8//xwTJkxAYGAg5s2b17ml7WZ01GJHSLdE8co1hHzHumK5xE5oOl4mFFg9TgjpOh3aK7Zfv37o168fli5diry8PKSlpeGTTz7Brl27XF/Cboxa7Ajp/iheOa7lesKWxK69Fju11nqMnaXFjsbYEdL1nE7sCgsLsW/fPuzfvx/79+9HZWUlxo0bhxdeeAGTJ0/unFJ2UzR5gpDujeJVBzGmLljLzFh9O7HO0jInsXTFCi1dsbSOHSFdzeHEbunSpdi/fz+qq6sxYcIE3HbbbXjyyScxevRoCAQdavjzeFo9LXdCSHdE8co1BHzHthVrbDkr1onJEyzL4pmNv+F8iRJfLR2DviE+Lig5IT2XwxFuw4YNiI6Oxquvvorp06dj5MiRYBj7W8z0BNQVS0j3RPGqY1hY36wKeJYWu7ZvYlU30RV79kYtdp0rBQBsOJKHN+8c0sHSE0LgTGJ34cIFrkvjgw8+gEajwcSJEzF58mRMmTIFt956K3g8h+dieKYWsY2WOyGke6J4dXMsKbBlHbv2hp2oW86KFTo+KzbnhpL7/shVWiyakJvlcGQbNGgQnn76aWzevBmlpaU4cuQI5s6di+PHj2P+/PkICgrC/PnzO7e03Ux7404IIe5B8co1LC127e2y03IdO2e6Yq9V1HPfXymvR22jrsPl1RuMuFJeD7blLBBCepAODzYZPHgwgoODERgYiMDAQGzevBm//PKLa0vXzVFXLCGegeJVxzTNinVujJ1UZPrT4khXbEG1yurn00UK9A3xwYcZlzBrSARm3RLhcHnf3n4eX2UV4OFxMXh7AXXpkp7JqcSuvLwc+/fv57o4Ll26BJFIhDFjxmDFihWYOnVq55W0G6KuWEK6L4pXHWBnuZP2umIbdabnucTOvJ6dI12xlfUa7txGnQG/FdYg7XAeDlyqwM6cEpx4dQb8JO3vGqLRG/BVVgEA4JujBXh5Tjx8xDRRhvQ8Dv+vT0hIwKVLlyAQCDB69GjcfffdmDJlCiZMmACJRNK5peym2uueIIS4B8Wrm2OZZ2JZ7qS9WMetYyeydMU6vkBxdYMWADBjcDh+Pl2Mn08X41plg+m6OiNO5tdganxYu9fJuVHb6uex/WgfYNLzOJzYLViwAFOnTsXEiRMhk8k6t1QeglrsCOmeKF65hsDhFjvbe8WqHFjHrrrenNglhOHn08W4WtFg9fyFUqVDid25YmWrnymxIz2Rw4nd6tWrO7ckHogWKCake6J41TEt2+WaFih2cK9YoXOzYrV6I+o0puRvfFwIfER8NJjP6R0gxQ1FI/IrG9q8hkVRi7F61yrr7R5LiDdzOLF76623HDru9ddfv5nyeBRK7Ajpnihe3RzLcieOjrFr3RXr2KzYGpWptY7PYxDsI8JDSTH44sA19PKXYPm0/li59Szyq1RtXsPiek0jACChlxwXSpQocPA8QryNw4ndqlWrEBkZibCwMLtTyRmG6VGBUuNgV+y/DufhRH411qQMg7+0/UHAhJCbQ/HKNQQ8S2LnZIudgwsUV5m7YQNlQvB4DP48Kx6jYoIwtLc/impMiVmZUu1QWS2J3fi4YFwoUbZqwSOkp3A4sZszZw727t2LUaNGYenSpZg/f36PX+DTkRY7lVaPt7afB8wB5+Gk2C4oGSE9G8Ur1xAJ2t8rVmcwQm80JX4tE7v2umIVKktiJwLMLXczB4cDzRY9rqjTOFTW6+ZEcEL/YKQdzsP1mkboDUZunCAhPYXD/+N37NiBq1evYuzYsXjxxRfRu3dvvPTSS8jNze3cEnZjjiR2lrtImBffJIR0PopXHdOydZNrsTPab7Fr3t0qEZmOlwkdmxVrGV/nK2ndxhDqJwbMrX4NmrYnYdRr9KhRmRY2TowJgojPg97IoqTWsdY+QryJU7cykZGRWLlyJXJzc/H999+jvLwco0ePxoQJE9DY2OjAFazFxsaCYZhWX8uWLQMA/OMf/8CUKVMgl8vBMAwUCkWra1y6dAl33nknQkJCIJfLMXHiROzbt8/psnSEI7NibzRL7G4onH+PCCEd48p41V6sUqvVWLZsGYKDg+Hr64uUlBSUlZVZXcPW+Zs3b27zdaurq7Fo0SLI5XIEBATgscceQ319598gWvbVFXDLndiPdZbxdTwGEJlbx6TNxti1tQuEJWHztbHenI9YAB/zdcrbabWztNYFyITwlwrRO1AKAFx3LiE9SYfbqEePHo2pU6ciISEBv//+O3Q657eBOXHiBEpKSrivjIwMAMA999wDAFCpVJg9ezZeeeUVu9eYP38+9Ho99u7di+zsbAwfPhzz589HaWlpR6vmMEfWsWt+x1issL57pG1vCOkaNxuv2otVK1aswM8//4wtW7bgwIEDKC4uxsKFC1tdJz093eo6CxYsaPN1Fy1ahHPnziEjIwPbt2/HwYMH8eSTTzpV9pthSdTa6optPr7OkhBaEjuWbXsssiWx8xHZHhVkabVrrzv2erUpUe9jTugs/1oed4ShjVZJQjyJ04ldVlYWnnjiCUREROCTTz7B4sWLUVxcDLlc7vSLh4aGIiIigvvavn074uLiMHnyZADA888/j5dffhnjxo2zeX5lZSUuX76Ml19+GcOGDcOAAQOwZs0aqFQq5OTkOF0eZzmypZhS3fQHxLIQJwAcvFSB+L/swv/tuthp5SOkp3NVvGorVtXW1iItLQ1r167FtGnTkJiYiPT0dPz66684evSo1XUCAgKsrtPWYskXLlzArl278OWXX2Ls2LGYOHEiPvnkE2zevBnFxcUdfk/a0jK1ETiwQDGX2JmTOTQba4d2JlDUa0zP2dshIsTXlNhV1TvWYtcnwLRmYVSQ6V9HWuyMRhbPb/4dCa/vwrp9V9o9npDuzuHJE++99x42bNiAyspKLFq0CIcOHcKwYcNcVhCtVouNGzciNTWVu+trT3BwMAYNGoSvv/4at956K8RiMb744guEhYUhMTHRZWWzW2YHumLr1U1jQ6pVWrAsC4ZhsOHXfGj0RqzffxV/njXI4TrvOFMCAZ9xav9EQnqazoxXLWNVdnY2dDodZsyYwR0THx+P6OhoZGVlWd2YLlu2DI8//jj69euHp59+Go8++qjdz35WVhYCAgIwatQo7rEZM2aAx+Ph2LFjuOuuu2yep9FooNE0JUJKpWnhXp1O125LJWtutTIYDNDpdLCkZxqd3u65dSrTa0kEPKtjxAIeNHojlCo1/ES266hsNJ0rEzI2ry83j72rqle3WfbCKtNad70DxNDpdIiUmxLCgsoG7ryW/1rsy63AtlOmRPn9/+VieG8/jO0bZPe12lNUo0KYnwRiQddN2rBXN29AdYPDx1g4nNi9/PLLiI6Oxr333mtKTDZssHnc2rVrHX7x5rZt2waFQoElS5Y4fA7DMMjMzMSCBQvg5+cHHo+HsLAw7Nq1C4GBgXbP62jg0xusB/Bq9YZ23+zaRm2z442obVDDRyzA1WYTKUoVDdydaVsul9dj2abfAADbnhmHWyKdbyVtC32APBPVDa2O6cx41TJWlZaWQiQSISAgwOq48PBwqyEhb731FqZNmwaZTIbdu3fjD3/4A+rr6/Hcc8/ZfJ3S0lKEhVnvuCAQCBAUFNTmUJPVq1fjzTffbPX47t27292Fo7qGB4CHs2fOQFB8GlevMwD4yCsoxM6d+TbPuVxrOkavacTOnTu5x/ngA2Dwv8x9iLDzsufyTK9Xer0AO3fmtXq+vtr0/LHfz8Kv/Izdcp/MNR2nuHENO3deRWWlqUxn84qxc2eR1bGWbnSLjVd4Vp1Xz286gafjDThVzSBQBCSGsHDwvhv/vsbDkTIeAkUsnh9iQED7Yd2lWtbNm/T0uqlUjo8XdTixmzRpEhiGwblz5+we42irky1paWmYM2cOIiMjHT6HZVksW7YMYWFhOHToEKRSKb788kvcfvvtOHHiBHr16mXzvI4GvkvmAGZRVlFlFchsuXjVOmhs3bEbwRKgUsnnlgH9YeceRPm2X9+DJU2vn77zCKZFds6YkJ7+AfJUPb1uzQNfZ8arjsQqAPjLX/7CfT9y5Eg0NDTg/ffft5vYddTKlSuRmprK/axUKhEVFYXk5OR2u6C/LT4OKBUYOmwY5o7ojRuH87Cj6DIievXG3LlDbZ6zN7cCOP87QoP8MXduU+vkmvMHoapVY3TSBAzt7W/z3ANbc4DSYgwfPAhzJ/Vt9fzpX3JxvKIAEdFxmDtroN1yf5GfBaAOyRNHYdqgUPS5XosNl49BBQnmzjUN7dHpdMjIyMDMmTMhFDatJ7r+018B1OODu4fivf9dQlmdBu+cavrT2HdQPB4eF93m+wYAl8rqcCQrCwBQo2XwmyEKf7Pznrmavbp5A6qbiaUByhEOJ3b79+93+KLOKigoQGZmJrZu3erUeXv37sX27dtRU1PDBazPPvsMGRkZ+Oqrr/Dyyy/bPK+jgS/wWhXWnc/mfvaVWwcyW7ZvOgVUlHM/Dx8zAQm9/PDHrEzusYHDR2PqoNB265u94yKQXwgAkITGYO7cwe2e4wz6AHkmqptJ88DXWfHKVqyKiIiAVquFQqGwarUrKytDRIT9IRNjx47F22+/DY1GA7G4ddNOREQEysvLrR7T6/Worq5u87pisdjm9YRCYfv/P7jZsHwIhUJIzMcbwNg91zKETiYSWB1j2X1Ca7R/bqPONJxFLhPZPCbI3JNRpzG0WfYb5olpsSF+EAqF6BtmiuNldRoYwOP2sG35PugNRlyrNN0QjOkXgv+7W4Invj4JnYGFv1SI2kYd1h/Mw+IJ/cDntX0jkJ5lahm0bIW242wpVs4djAh/++MoXc2h37GH6ul1c6buDid2nSk9PR1hYWGYN2+eU+dZ7tBbLjzK4/FgNNof/9bRwCfgW79dOmP7b3ZDi4HDSo0RSo11S1u1Su/QL+16s1m1xbXqTvtP3tM/QJ6qp9etK+puK1YlJiZCKBRiz549SElJAQDk5uaisLAQSUlJdq916tQpBAYG2oxFAJCUlASFQoHs7GxuzPDevXthNBoxduxYl9etOUtjpmWvWF0b44ktkydkzSZPoMWSJ/bUtzMr1t+8cLFl6zFblGodahtN3fCW2bCBMiG37+wNRSPiQm13iRRUq6A1GCEV8tE7QIqoIBmOvDQNVQ1axIX6YuxfM1FRp8HRa1WY0D/EbhnKlWr8dOoGAOCTB0dizc6LOJ5fje+OF2LFTPstjTAvJfPujgv437lSDO4lxx+mxiExpuNj/CrqNBALeZBLvDMWkPY5NLrTMtPUEceOHcOOHTscLoDRaER6ejoWL14MgcD6w11aWopTp07hyhXTTKWzZ8/i1KlTqK6uBsyBLzAwEIsXL8bp06dx6dIlvPjii8jLy3M6SewIRxYorlNbj8urUWlR2WKGl6LRsbFRzbfIab4+HiGkydq1azslXtmLVf7+/njssceQmpqKffv2ITs7G48++iiSkpK4iRM///wzvvzyS+Tk5ODKlStYv349/vrXv+LZZ5/lrnP8+HHEx8fjxg1TgpCQkIDZs2fjiSeewPHjx3HkyBEsX74c999/v9PdwB1l2StW38aNsmV3CVmL5IxbpLiNWbHccid2ZsUGmLdgVKjsx0jLkiZBPiLuOgzDNM2MbWNrsctldQCA/mG+4Jlb5MLkEiT0kkMk4GF6gmkXjEOXK+1eAwC+ysqHzsBiVEwgbo0OxENJMQCA744Xtvt34q87L2DDr/koqVVjz8VypKzPwp3rjmDxv47j8a9OYOfZkjbPtyhrBB7+1wmMfjcTI9/KwKs/nuV272iPVm/EpbI65Fc2OHwO6b4carE7f/48YmJicM899+D222/HqFGjEBpq6jrU6/U4f/48Dh8+jI0bN6K4uBhff/21wwXIzMxEYWEhli5d2uq5zz//3Gos3KRJkwDzXfOSJUsQEhKCXbt24dVXX8W0adOg0+lwyy234KeffsLw4cMdLkNHOTQr1hy4IuQSlCrVqG7QtlqTqU7tWGJX1Wy5lIp2pv8T0lPl5uZ2SrxqK1Z9+OGH4PF4SElJgUajwaxZs/DZZ59xzwuFQqxbtw4rVqwAy7Lo378/1q5diyeeeII7RqVSITc312oSyLfffovly5dj+vTp3PU//vjjm3yH7Gu93En7e8ValjNp3t0JB/eLbTAvd2JrgWKYFxwGwLXI2cItdWJurbPoEyjDxdI6FLVxE3ypzDSJbUC47Ra9pH7B+E/2dWRdq7J7DaVah6+zCgAAj9/WDwAw+5YIhPiKUF6nQcb5Mswdanu897WKeu7cv8wfjMtlddiSfR2ni5oW48+8UI6XZsfjmSlxVueyLIurFQ04V1yL7PxqbDrNh56tAcxr8n17rBA5N2rx6YO3ckluS2qdAelH8vHZ/itWjRBhfmL0DpQiSCZChL8Etw0IxeSBoc3WJ2RxvaYRl8vr0KAxQKHSoqRWjcJqFQqqVKht1CEmWIZbIv0xtLc/BkX4gmEYGI0sJEI+fMQCsCyL6gYtLpSaEsqS2kYADCRCHqRCPmQiPiRCPqQCBpcrGfhfrUKInxQ+YgHq1DrUqHRo1OqhNbBci7KlpZlhAAYMGMa0TZ1YwOdan7n/ySzAggXLmtZbtDzOsixY8xqMMD9vwTCmmwYew8DIsjAaWeiNLIwsC72BhYFlufUQ+TwGAh5j/pcHHtP8NUz/6vV6/F7JYKbBCFd2ODiU2H399dc4ffo0Pv30Uzz44INQKpXg8/kQi8XcnfHIkSPx+OOPY8mSJW2uzdRScnKy3YV6V61ahVWrVrV5/qhRo/C///3P4ddzJUda7Cx3pH0CpShVqqFQ6VolZcrGtrfLgXmtJUWz7og6tR4avQFiAb/N8wjpab744gvk5eW5PF61FaskEgnWrVuHdevW2Xx+9uzZmD17dpvXnzJlSqvrBwUFYdOmTQ6VrzMIHdh5olFril+tumKFTnTFim3HsQCpqSu2rRa7KxWm5Cw22Mfq8aggyyLF9lvsLplb7AaG+9l8PikuGACQc6MW9Rq9VQJa06DF/kvl+CH7BurUevQP80WyeZ9bkYCH+0dH49N9V/B1Vr7dxG5txiUYjCymx4fhsYmmySN/mNIfJwuqYWRNr7vh13y897+LiI/ww9R40yzpY9eq8OcfzqCgqnndGEwaEIx37xqGgioVln/3G05fr0XyhwcxrI8/hHweWLDwFQvQN8QX/lIhvjteiELz++MrFsBgZNGoM6C8TmO128e3xwohEfIwIS4EDMPgVJGiVc9TS4XVqnZbOh3Hx4bL2Q4c54n4+KPeiLbnqzvH4TF2w4cPxz//+U988cUXOHPmDAoKCtDY2IiQkBCMGDECISH2xx94K0cSO0uztmUAbbVKa7WQJ1osYmyPUq1Dy4XRqxu06OUvtXcKIT0WxSvX4LpiHWixa5nYWX62JH621LexpRiatdgpGu2PsbtUakrOBkVYJ2dRgaY/lYVtdsWaksKBdlrsIgOkiA6SobBahZP51ZgyyJRYXSmvx71fZHGLzvN5DN6+cwjXnQsAD4yNxmf7r+DotWos3XACap0BPmIB/jh9AIb09selsjrsMHezvjBrEHdedLAM0cGmst+d2Ad6oxEbjxbi2e9+x6YnxmJ/bgX+nnkJRta0VuCQ3v5IiPCFqCYfLz90K0QiEaKCZPh5+USs+P4UThbU4FhedYuaNW13Fy4X48+z4nHXyN5gGKBGpcP1GhVu1DSitlGHi6V1yLxQhus1jdhzsWkyj5DPoH+YH/ylAsglQoTLJYgOkiEmWAa5VIhrFQ3IKa5Fzo1a5FU0cK1nKq2B243EVyzAwHBf9A/zRe8AGRjGdCOg1hnQqDWgQWtAvVqLwuIK8KV+qFXrUK/Ww08iRIBMCD+JAEI+j2tZttwYsc1a4/RGFhq9EVq9EQzX6maqg6VVj4HpCctvz/IYY36MYZpa9ViWhZE1baEn4PHA41n+NbXQ8cwXN7Km1jyD0Qi9wdSqx72C5YVYFtXV1WhnXo7TnJ48wePxMGLECIwYMcK1JfEgfIaFgWXa3CrHwnJMZIApAVOotNw2PSG+YlTWa6B0YIydZYNrX7EAPmI+ypQaVNZRYkdIWyhe3RyB+S+Orq0xdjZ2noADXbEsyzbtFStpO7FT64xQ6wytunsB4EKJ7VY3y89nrtfavLbOYMS1SnNXbJjtFjsAGNs3CIXVKhzLa0rsXvrhDKobtOgTKMXkgaFYeGsfJMZYr53aO0CKZVP745O9V7C3WUJ06HIF/n7fSPwnuwgsC8wZEoGEXvZXY3h9/i24VFaP43nVuOPTI9zjKbf2wao7BsNPIoROp8POnXlWS/hEBcmw5ekknL5ei4KqBrCsKUGpadAir7IBJbVq3BoTiIfHxViNcQzyESHIR4RhfZpmeL9x+2CcK1bi6LUqCHgMhvT2x5De/jZ/Hxbj+gXbfU5vMILHMFaJsD2muu3E3LnjvW5ymKVuLcen3qxuMSvW0wgYwMC232LHsiyX2EXIzS12DVouo+8X6mNK7NTtd8Va7gwtm1yXKTWobKBxdoQQ12nZFSwUWMbYOTJ5wvqPvKUVrt5OfNPojdCbuyHsTZ7wFQvA5zEwGFkoVDpE+Fu/RkWdBrnm7tSR0dYLRI+IDgCfx+CGohGXy+qg0mitej0KqhqgM7CQiUwzYu0Z2y8YW7Kv45h5nN2pIgWyC2og4vPwn6fHt7mcSerMgUiMCcTlsnr4y4T4+XQxDl2uxNMbTd2KQj7T7qxZkYCHLx5KxHObf8ehy5UI8hHhtXkJWHhrnzbPg7nFaURUAEZEBbR7bHvXsSRzrmBpYSOdgxK7DhDwAI2x/ckTzVv0epk//AqVjhs4GRfqg+N51Q612FnG1wX5iOBvnilWVW+/e4IQQjrK0vIj5DneFStt0eoQ6GMaH1dtZ6kSS2sd2ljuhGEYBEiFqGrQokal5ZIolmXxzo4L+PdJ09pxw/r4t9q9x1cswIioAGQX1GDmhwcBAEMDeZg311QXbuJEsxmxtli2FztzvRYqrR5fZ5l24Jg/vFe7a9QxDIMpg8K4lr6FI3vjnR2mWbBCPoN3FgyxO76vuUAfEb55bCwUKi18xQJKjEibKLHrAPN4YhhZ0+wjewtXanRNiR03xq5By939xpgH+7Y1a8yiqcVOhCBz90Q1tdgRQjqRZfKEto0WO5VlHbsW3XJBljXoGuwlduaEUMhvc/HfAFlTYmex/UwJ0g6btiDj8xismGG71evpyXF44uuT3M9na3g4fKUK0wb34iZODGgnsYoKknGLDu+5UI7tZ0zj4h5Jim3zPFsEfB5W3XELnpkSBxGfxyW/jgqQOXc86Zko7e+A5ns7t9VFodabAhePAUL9THeTCpWOm20UY56CrmpjcLGFZVZYkEyIIB/TtarsBExCCHEFgQOTJyyTI1qOseNa7OzEqfp21rDjriNrPTN2hzm5mj+sFw68OIWbLdrSzMHh2LZsAv75yCgsGhMFAPjptOnc9iZONGdptXv2u9+h1RsxtLf/TXVvhsslTid1hDjKqcROp9NBIBAgJyen80rkAQTNbi7bmkBhabGTCPkIMn+ItQYjt16QZeZTy90pbLF0ZwT6iBDsaw6Y1BVLiF0Ur26epcVO39YYOzuTJ4La64rVWmbEtr1kU0CL3SdYluXWlXv8tn7oE9j2QhEjogIwc3A47hhuWnJkz8UKaPQGXCg1bUEXH9H2/rkAMHuI9RZuD4+LafccQtzFqcROKBQiOvr/27vzsKbutG/g35OQlS3siAgIivuKLVKtKypqF6vtdHFcprbWVtsqbWcebZ9qnbdjZ9raVzvWTp/60k7t1I7zWDt1G1e0VkRFcS+ugAoBAVkDIct5/0jOIQkhJDGQhftzXVwXhHOS3yFwc5/fcv/ioNN17crUpqMG9vTYSfwMBRclJl19Yj8BYowrWpu1er6oYVu44YwQubglYNrZY1fTqMHei0qqKE66FIpXzuNCHFfupNlGjx03pOpvMU+Oi1P3GqzPIba/x85894lqVcsWYn3smJ/GGRobjCARi3q1Fgcvl6OwogEA0Ldb+8+R3i+K77V7ICEEM4d3t/t1CelsDg/Fvv3221ixYgW/rVdXxNhZuNO0x45hGD7QAUBEgARykzvV9oZjubvVELmo3TthS698m4eF3+Rh+bbzdh1PiK+geHV/+B47G+VOuMVfQTLzBI0bWahXa63GN1UbCaGlEH/zuXqFlYaELDpI2qqX0BaBgMHgUEOCuu7AVehZQ/IZEWB9r17Lc//x4kjsfv1hfPfiSFq8QDyaw4sn/vrXv+LatWuIiYlBfHw8/P3Nq32fPn3ale3zWGKhABqdzubKWK7Hjqv1o5CLUVrTBMAw504sFPBL+VXNOgTa2LSZu0MNdrDH7laVCr9cMwxb/HDmDlY/PsDm6xDiSyheOcZyYw2ux07TRpxjWZafWmK56XyQVIQQuQj3VBr88+QtRAfLzIY0uaHYtnad4HC17LhanlxiFx/meK3+wWEsjpYBvxqLGg+PCzGr/WaLUMDYrDdHiKdwOLGbMWNGx7TEyxgCns6uHjtuCDbUvyXwRQZKwDAM5GIh6pq07a6M5YYhgmUmPXZ2zLG7WGJenDPneiUmD4iGXs/i32dLkBDu79Ak4EO/luNiSQ3mpCXwZVcI8VQUr5zD5Tr8XrFtTBVRa/X8itkgK/EgKSIAp4ruYdVPlwAA376QilG9DLt+qIxDsXK7F08Ye+wqDDtJWG4hZo9egSwUMhGqjTfKD/emHUiI73E4sVu5cmXHtMTL8GUAtG3PPeHmtEmMPXbcalaY1LXjEjvTmk7WcMMdCpkIYcbErk7d/n6x3J0p5/iNKkweEI2sY4X4445LEDDA7tfHtNqOx5oLd2rw/NcnwbLA1fJ6rHtmWLvnEOJOFK/uj0hge/EEF5cEDOBvZVh0cKwCp4ru8V/vvajkEztu0Zi180yF8D12hsSuyNhjlxDueGInFABzRvbAp4duIDxAjBlDaa4c8T1OTRSorq7Gl19+ieXLl/NzV06fPo07d+64un0eS+zHTSq2b/EEACSaBKKexs/9jfNLbG2UDYC/wwyWiRAkFfF1n9qamMy5Vm5Y0j841lAxPOdGJViWxbfHiwBjLb5tZ27bvlijPReU/FDNznOlqLGxMTchnoLilfO4oViuZqclbp/rQKnI6pDmi2N6YpDJbgXc9l8wKVDc3nZKCotyJ4WVXI+dc9umvzo+CdsXj8L+zLEIltOoA/E9Did2586dQ3JyMv785z/jo48+QnV1NQBg27ZtWL58eUe00SPxc0/sXDwBwGx+Bvc5N/nXVo+dRqfnh2oVchEEAoYfnqhsp0hxWa1hTt/MYYY701+Vtci5XokbxhVhAHCi1QbR1h27XsF/rtWzyL5SbvN4QtyN4pVjLFM3kclKfmuxrqbROL9OZj056xYsw0+vjsau1x4GAFwtb0nsuJgWYOdQrGWPXbwTQ7Ew2WaLiv0SX+VwYpeZmYn58+fj6tWrkEpbtlOZNm0ajhw54ur2eSx+Vawdiye4HrtxfSKQ3i8Kjw6J4TeM5vZXbLQxx67GZMsxbuFDmJ0LKMpqDYnfwO7BSIrwB8sC/2fnZQBAX+Pw68WS2nbLrdSrtThr3Ew7Y4BhAvTJQvtXGtY2adp9DUJcjeKVcxhjwRMuzqGNxK7KpAyTLd1DDKWd7qk0fKzje+zaWTzBDcXWNGpwr6GZX0ThzOIJQroChxO7kydP4qWXXmr1ePfu3aFUKl3VLo/HDcWqHeixk4qE+HLeCHz67DB+UjI3DGGrSDE3BBEk9eOHYEP8uW3F2k7sWJble+yigqRISwoDAFwqNRTmnPdQAiR+AjRr9bh9T2Xzek/erIJOzyI+TI4Zw2IAAKcK79k8h7Nm92UMXrUXGf/3CJTGVcGEdAaKV/eH2ysWADRWatmV1xn+niMDbZcMCZL68XPpSmoaAZMeO387h2L1LHDuTg3/eu3VvyOkq3I4sZNIJKitrW31+JUrVxAREeGqdnm89soAwLTciV/bP+aWHru2h2JbSp20zAcJMy7EsJXY1TZq+Z0xIgIlGJkYxn9PwAAT+0UiMcKwnQ63vU5buGHYh5LCMCLBUKizoKyu3Xl2525X42+Hbxheo7wey77Ph07PQlnThGXf5+OFr0/hcmnr3ydr6tVazP1/J5C0Yhde+TaPL3BKSFsoXjmGtah3IhAw/M2ktR67cuOIQESgtNX3TDEMg24KQ69dabUhGeTKncjbWTwh9hPwSWF+sWEo3ZkVsYR0FQ4ndo899hhWr14NjcbwD51hGBQXF+MPf/gDZs2a1RFt9Egtc+xYqLU6vPJtHlYbl/Rz+HInIluJneGu01a5k5pGQ/JmWl7Enlp2Zca76WCZCFKREA8lhUNm7D2cOqgbIgOl6BVpTOzKbSd2XC28tKRwhAdIkGgc1s29WWnzvB/zSwAAA2KCIBMJkXOjEsu+z8ejfz2KH87cwf7LZZizKbfdBFGj0+PlzXk4cuUudHoWu84rsXRLPvR2DO/m36rG0n+ew+arAhy5WsH/86pWNeNmRYPN7ZIsqZq1OHa9Ahfu1Nj12sS9KF45x3QdREsFgJa/E5Zl8WP+HX7hVXSQ7cQOJpUAuFEEvkCxHT1vocZix3nFhlECGoYlpG0O92V//PHHePLJJxEZGYnGxkaMHTsWSqUSaWlpeP/99zumlR5IzG+1o8PPVyqw67xhWGfBwz3R3Xhn2tJj1/YdKXe3ajkUe/DXMjAMg/F9IvkeO4WsZR4Ll9hVGhO72iYNKuub+dW2MAmgUUES/pzNL6TiVGEVnkuNAwAkRRiOv3G3JbFjWRZr913Bz1fv4o1JfdA/JojfVzHN2OuXlhiGG3cbkHPDUBdPq9OjqEqFuFB5y0o6PYvd5w0bbr82sTfqmrR4c+tZ/PtsCf/aqmYdSmua8OnBq3jnkf58G/6Vdxs7zpWgV0QAnnkwDhsOXcPPVysgEwmxbFJvfLT3CvZfLsO6A1exbFIymjQ65NyohFgowMjEML6X4cf8O3jrX+eM/5QEOPn304gNkUHsJ8CNu4ZJ2CFyEV6d0Btz0uIhEgrQpNFh1/lSfg5hdJAMOpbFqcIqnCq8x6+EjguV44lh3fFAQihqmzS4W6dGs1aPGIWMf40rZXU4f7sG5+7UoKiyAZGBUkQHSxEiF0EkFMBPwEAoEEAuFiIuTI6YYBnq1YbnUtY2oaqhGc1aFlq9HlrjTUS9WguWBSKDpIgIkEAhE+J6CYNbR24CDAOtnoVez0KrZ6FjWTRr9ag31krUsywEAgYChoGQAQQMY/zaUICVYRgIGcPXAuPP0LJorSWhwOR41jABn2VZsKxh+IwFyz8Hl1RzKygZxjCfS8AYP2cYfjsrnZ6FRqcDKhhMs92ENlG8un+Gvwm9WY/dfy6W4fUt+fzXvaMC2n0ey3nB9m4pBuMijFtVjfjlmmHkwJlSJ4R0FQ4ndsHBwdi3bx+OHj2Kc+fOob6+HsOHD0d6enrHtNCDmP5/a1k8waKgumWl19WyOj6xs6vHTtJ6KPbCnRo8/9UpAMC/l4wyK07M4bbrqapvRpNGh+nrf8atqkZ8/tvhyBho2OyaWzgRZXI3nRIfwi/cgLGAKACzVbK/XK/C+gNXAeN2ZJmTksGyhsUWEca5NGlJYfg2txg51yuh1uow58sTOFFYhSGxwfhu4UjIxX7Iv12Nkpom+IuFGJscAalIiKoGNb4/eQuDYxVY9egAnLl1D/OzTuLvx4vw/OieiFHI8GP+Hby59SwAILvgLr48ehMwJhCfzR6O8X0jEeovwZtbz2Ldgas4XXwP+cXVqDP+o+gTFYhlk3rjYkktPj14DQDwcK8wMPV3capKhNv3GvlrFfsJcE+lweodl7A5twgPJoRiz0Ul/zO3JipIgvomLYqrVFhn/DnZq6xWjfN3auw40lFCoMixtniL1Aj7dgawpivHK1fhbmK1Jj3Uh35tWREvYAw7OLSHq+NZYVzJz20z1l4dOwCIDZHhxM2WkiuJlNgR0iaHE7umpiZIpVKMHj0ao0eP7phWeTrGdHNsPW5VtSw8KK9rKT+itqfHTtR68YRpWZGDv5bzvR2mc+y4VWhVDc3Yf7kMt6oMycq3ucUmiR03sbntYZJEKz123PApANQ2afmq8WOSW+YkcfP1flXWYfG3p3HC2Lt19nYN/nb4BpZNSsbOc4beuvT+UfwCkoVjkrBwTBL/PGOTI5DaMxS5Nw3J5MIxiVhh3NN2+uBuaFBrkV1wFwq5CGueGITxfSMBAE+mxOLX0lp8efQmfr5q+HlFBErQ1KxDQVkdFm1u2Spq4ZhEvDExCXv27Ma6F8biXEk9WJbF4FgFgmUifH/yFj7aW4Abdxv4XrzuChkeGxoDsVCA8jo19HoWA7oHYXSvcPQM90ejRoc9F5TYdb4URZUqBEj90C1YCj+BALfvqVBS3QS1VoeEcH8M7h6MQbEKJEX4426dGuV1atQ0aqDVsdDp9dDqWdQ0alBcpYKypgkBUj9EBkoQFSRFmL8EYj8BREIGIqHAMN9I4geWZVFeq0ZlQzMq6ppQVHwLcXGxEAmFEAoY+AkMPXF+AgZ+QgECJIbJ6wIBA72ehY419J7p9Cz0LKBnWePjxq+Nn3MpFTc019KfZsDC5Hg9a9brxjCMsUeupWeO+5qF4TVZvofP2Mtn0qsnEDBgWBbNymtt/v62h+KVY6x1zvKxzmQo9roxXiSG+2PZpGREB7c/FGt6MwqTmNdeHTsAiDXeLHO4ucGEkNYcTuwUCgUefPBBjB07FuPHj0daWhpkMpkdZ/oWvkCxVs/XVwKASpNtvprs6LHj9klUmSwEMC3iefZWNWKMQS3cv2UoNsy/pY6daR26M8XV0OsNw23lFkOx1nBDt/dUGn6IJM84Qfn1ib3NeqSeGNZSpT08QILRvcJx9FoF9l823L0/lRKLrXm38eXPNzAnLR67jMOw0wZ1a/P1GYbB7zP6YNbGHGw5eQs7z5eioVmHkYmhWP/MMAgFDOqaNJCKhPw/GM7b0/thbJ8I/Fpah6FxCqTEhaCuSYsN2dew9dQtBEj98MakPpgxrDs/xypA4oexyeaT5p9LjcP0wd2w7fRtlNepMTwuBBP6RvLDudbIxX6YOTwWM4fHtnlMZ9FoNNi1qwjTpg2ESORbBVcN1+Z8TyTFK+eY/uaL/Fovnrhp7OFf/+wwDDQpQGyL5VCsSm3fXrEAEBvSMqdOwNAcO0JscTix279/P44cOYLs7Gx88skn0Gq1GDFiBMaOHYtx48Zh0qRJHdNSDyMWtgQ702G7ynorPXaitgMXV6DYdPHEHZOhwmt36/kkMsKkpAA3mfieSmOW2NWrtSisbEBiRIDVoVhLcrEfYoKlKKlpws2KBtQ2A7fuNYJhDPMFJSIBNucU4akRPVptgL00vTdO3KxCs06P1yf2xtL03risrMWFO7VY8PUplNY0IdBKImUpJT4UE/tG4sCv5ahr0iIiUIJ1xqQOJrX7LDEMg4d7R+Dh3i3PHywXYcW0flgxrZ/N17QULBPhd6N6OnQO8XwUr+6f6UIxGLcXqzLezNrTU8fh5gVXNDRDr2eh0ti/eMI0eezXLchmTCWkq3N4Vezo0aOxYsUK7N27F9XV1Th06BB69eqFv/zlL8jIyOiYVnog050nTBO7eyaf83PsbJQ78beyKta0B/D2vUZ+Tlh4gEliZ3L3y+0Hy9WS4oYTuVWxtnrsACApkptnp8LNOkMy1ScqEEFSEV4Z1wvHlk/EsknJrc4bkRCK7LfGYddrD2PZpGQwDINM43Fnbxl6/aYP7mZXEP7TzEGYNigaY5Mj8M2CB20mo4TYi+KVY6wtlBFb7LJT06jhj1PI7O8h5odiG9Ro1Oj45/C3Yyi2b3QgYo1Fjm2NABBCnOixg7EGVHZ2Nv+hVqvxyCOPYNy4ca5voYcyHYqtbmxJxEy3BuNqyEnsWBWrMlk8YZrYsaxhZwgACDftsZOLwTAtgTg2RIYhsQrsPF+KQuOWO/bWmEoM98fPVytws6IBN4yJnekCC1tiFDJ+qBgAxveJxIM9Q3HiZhX8xUK8Mq6XXc8TFSTFZ7NT7DqWEEdQvHKCyVisH1fuxJjYcfEpWCbiC63bg6+9Wd/M17BjGEBqY6oKRyBg8M+X0pBXdA8ZA6MduxZCuhiHe+y6d++OkSNHYs+ePRg5ciR2796NiooK/PDDD3j99dc7ppUeqGXxBGvWY1dvltiZbylmjWUdO5Zteb64UPN5JKY9dn5CAeJNvj+0h4Kfd1JcpTJMrjf22LU3XJJosjK20MHEzhLDMNg0bwT+79ND8dOroxFHc2GIG7kqXiUkJBgXg5h/LF68GDAu0li8eDHCwsIQEBCAWbNmoaysjD//7NmzePbZZ9GjRw/IZDL069cP69atc+p1P/jgAyd/Gs6xLMbOjUqE+ju21yo3faShWcffdAZK/PjSN+2JUcjw6JCYVnNtCSHmHP4LiYiIgEqlglKphFKpRFlZGRobG+04s7X2guUXX3yBcePGISgoCAzD8Bt4W9q5cydSU1Mhk8kQEhKCGTNmONUeR3DlTmqbNHzPHCwSO24VmdhWYifh6tgZzqtTa/myAmkmO0UwDBCjME/QBsS0zDt5ICGUr8ZeWKnCPZWGnxMTEWB7KJZbGXu5tA63jFVPRsSH2v4B2BAoFWHGsO60co24navi1cmTJ1FaWsp/7Nu3DwDw1FNPAQCWLVuGn376CVu3bsXhw4dRUlKCmTNn8ufn5eUhMjISmzdvxsWLF/H2229j+fLl+Otf/9rua69evdrstV999VWH238/LOfYtewP69hCnUCJHz+sy40qBDkwlEsIsY/DQ7H5+fmorq7GkSNHcPjwYaxYsQKXLl3C0KFDMX78eIeKfp48eRI6XcvcsgsXLmDSpEl8sFSpVMjIyEBGRgaWL19u9Tn+93//Fy+++CL+9Kc/YcKECdBqtbhw4YKjl+UwLkBxd56ceieHYrmNsasbDHfDMpEQQ+MU+P7ULQBATLCs1fNM7BeJnedLIRYKMGVANIqMwbKwooHvrQv1F9tMLGFSy66kpgkAg8hACXqE0spB4v1cFa8stx/74IMPkJSUhLFjx6KmpgabNm3CP/7xD0yYMAEAkJWVhX79+uH48eMYOXIknn/+ebPzExMTkZOTg23btmHJkiU2XzswMBDR0Z0z/MhaKXjSUsfO2GNnTOwc7bFjGAbhAWKU1DTx84CD2lgYRQhxnlNz7BQKBR577DGMGjUKDz30EH788Ud89913yM3NdSixsxUsAWDp0qUAgOzsbKvna7VavP766/jwww+xYMEC/vH+/ftbPd6VuAUBpTXmd//1TY712Pkbh2IbjNvrcPNXQuQi9DdZhcotcDDFlR/p1y0I0cFSvtbY7Xsq3DbWtWtvc24YtwMKkPjxSWlKnMLu4RFCPJ2r4hWnubkZmzdvRmZmJhiGQV5eHjQajVnR4759+yIuLg45OTkYOXKk1eepqalBaGj7PeMffPAB/vjHPyIuLg7PPfccli1bBj8/p0K33Uz//i23FON2wnEmKQsPlBgTO0MdvCBZx14HIV2Rw39V27Zt4ychX7p0CaGhoRg9ejQ+/vhjPiFzhmWwtMfp06dx584dCAQCDBs2DEqlEkOHDsWHH36IgQMHtnmeWq2GWt3S08ZtEq7RaPh6Z9ZotS1JG1d6qaTakECJhAw0Ohb1ai3/HE3G5fxC6Nt8XhFjCJaNGh3U6mbcrTUUOw6WidAnUo7EcH/cqGhARv8Iq8/x6KAovu0hUgFkIgEaNXqcKjTs4RoZKLZ5TZyxyeHYadwWbUKfMLvO8Sbc9fjadYGurdWxpjoiXm3fvh3V1dWYP38+AECpVEIsFkOhUJgdFxUVBaVSafU5jh07hu+//x47d+60+VqvvfYahg8fjtDQUBw7dgzLly9HaWkp1q5d2+Y5zsY3AGCN00B02pY45mcsO9TUbHisvslw8ykVMQ7/znHDt1yB40CJX6f93tLfiXeia4Pdx3AcTuwWLVqEMWPGYOHChRg7diwGDRrk6FNYZRks7XHjxg0AwKpVq7B27VokJCTg448/xrhx43DlypU274bXrFmD9957r9Xje/fuhVze9mT/ghrGsHUTgBtXfwUg5CcSK0R63NUxaFBrsGPnLggYoE4lBMAgN+cX3G5jBxzDCKzhbfhx526cqzK8hq6xBv/Zsxvz44GySAZy5Tns2nWu3Z9JiEiIRg2D/5y5AYCBuvoudu3a1e55gwTAcYkQ3eQshHfOYVdp+6/ljbi5Ub6oq1+bSqVq9VhHxKtNmzZh6tSpiImJcer8Cxcu4PHHH8fKlSsxefJkm8dmZmbynw8ePBhisRgvvfQS1qxZA4nEem+8s/ENAGprDTHrTH4+NEVnAAAV5QIAAuSfO4+gu+dwodDwtfJ2MXbtKrTzqg2a7hnOvaqsAcCgpkJpV3xypa7+d+Ktuvq1WYtvbXE4sSsvL7fjKMc5Eyz1xjkfb7/9NmbNmgUY57bExsZi69ateOmll6yet3z5crOAWVtbix49emDy5MkICgqyeg4AKK5X4rNLeQCAB4YNxnfXL/Lf6x0Thrs3qsCCwcRJUyATC/HOmYOARov08WP5HR4ssSyL35/cB5YFRo+biJoLSuBaAXr3iMG0aYPt/llwdtbko+RSOV+P7oEBvTBton0lR+ZqNNi3bx8mTZrkkzsY0LV5H0eujeuZMuXqeFVUVIT9+/dj27Zt/GPR0dFobm5GdXW1Wa9dWVlZq7lxly5dwsSJE7Fw4UK88847Dr9+amoqtFotCgsL0adPH6vHOBvfAODLohygvg7Dhg7FpAGGenEHVedxprIUyX37YdqoBBz/9yWg9DYG9umNaROSbD6fpUt7ryL37k006QzxqX+vBEyb1teh53AW/Z14J7o2A2vxrS1OTXDQ6XTYvn07Ll++DBjntD3++OMQCp2rBm4tWNqjW7du/OtzJBIJEhMTUVxc3OZ5EonE6t2uSCSy+cM1ndcSKDOfOBxtUstNCwFEIhE/J0UuFdt8XrlIiIZmHTQsg7omw/BtaIDEqV/ixIhAAC3/zJKiAh1+nvZ+Dt6Mrs072XNtbX3flfEqKysLkZGRmD59Ov9YSkoKRCIRDhw4wN9gFhQUoLi4GGlpafxxFy9exIQJEzBv3jyn5vbBuBhEIBAgMjKyzWOcjW8wmVvn5+fHHys2LtrSgYFIJEKT1jBcGyizHdesiQw2X5Sl8Hcuzt2Prv534q26+rU5cu0OJ3bXrl3DtGnTcOfOHf6Occ2aNejRowd27tyJpCTH7uDQRrC0R0pKCiQSCQoKCvgNvjUaDQoLCxEfH+9wOxwhs9hNIVQuhsRPALVWb6yqztq1KhYA5BI/NDTr0KDW8UO7jpYS4CRY1I2LC21jDJiQLsCV8Uqv1yMrKwvz5s0zu8kLDg7GggULkJmZidDQUAQFBeHVV19FWloav3DiwoULmDBhAqZMmYLMzEx+7p1QKOQXkZ04cQJz587FgQMH0L17d+Tk5CA3Nxfjx49HYGAgcnJysGzZMvz2t79FSIhzdSadIfLj6tgZEjqumDq3HaIjwgPEFl+3v7iLEOIYhxO71157DUlJSTh+/Dg/h62yshK//e1v8dprr7U7GdhSW8ESxknJSqUS165dAwCcP38egYGBiIuL4wPookWLsHLlSvTo0QPx8fH48MMPAZP6Uh1FbhHUFHIRZGKhIbFr1vE1n9DOqljT52rUaPk9GBVyx0oJcHpZrJ61/JqQrsSV8Wr//v0oLi5uVboEAD755BMIBALMmjULarUaU6ZMwWeffcZ//1//+hfu3r2LzZs3Y/Pmzfzj8fHxKCw0zFNTqVQoKCjgJ0lLJBJs2bIFq1atglqtRs+ePbFs2TKzYVZXs7KjWKstxbhi6v4SZxI780Quwo5V+4QQxzic2B0+fNgsSAJAWFgYPvjgA4waNcrhBtgKlp9//rnZJOAxY8YAxh4+bpHFhx9+CD8/P8yZMweNjY1ITU3FwYMHO/yOVm6xv2GwXAyZSIhqaNCk0fG7TqCdnSdMn6tBrUM1V+7E37keuyE9FPxWY/FhcgRTAVDShbkyXk2ePBmstc1UAUilUmzYsAEbNmyw+v1Vq1Zh1apVNp9/3LhxZs8/fPhwHD9+3KE2uoppYQKu3AmX2HHbJspEjs/kocSOkI7n8M4TEokEdXV1rR6vr6+HWOx4LxMXLJOTW28yv2rVKrAs2+rDdOWsSCTCRx99hLKyMtTW1mLfvn0YMGCAw+1wlGWPXbBMxA/PNmp0/Pw6mNzxtvdcqmYt7jVwQ7HO9diJhAK8Pa0fwvzF+ENG50xKJsRTuTpedUWWO0/cT4+dZeFze+psEkIc43Bi98gjj2DhwoXIzc3lE63jx49j0aJFeOyxxzqmlR7Ico6dQibiixY3Nuv4+XVioQACge26fC2JnUmPnZOJHQC88HAi8v57EqYN6ub0cxDiCyhe3T9RG0OxlqMW9pCL/WAaDmOCaYcbQlzN4cRu/fr1SEpKQlpaGqRSKaRSKUaNGoVevXrZtam1r2hrjh0seuzam19n+lwNzTp+jt39JHaEEAOKV46xNtLMxbDWiZ1zVRAeHWIoafVgz9B2b3oJIY5z+JZLoVDgxx9/xNWrV3H58mUwDIN+/fqhVy/7aqX5CrGfAIESP9QZ55uEGOfYwbjjRMuK2PYTO3/jne+9hmY0aQznKZycY0cIaUHxyjmm6Ra/pRif2Blinr8TPXYA8O4j/dEz3B+PDXGuwDMhxDanN+rr3bs3Hxy76r6iIj8BYNy5JypIajYU60iPHdfTd+eeYXsyPwGDQAntoUiIq1C8cp6foGWOnV7PotG4VaIz5U4AICxAgqXpredUE0Jcw+GhWBh3iRg4cCA/tDFw4EB8+eWXrm+dh9PpzUuamA7Fcqti7eqxMyZxJTWGxE4hF9E/H0JchOKV/VgrBU9a6tjp0aTV8cO1ziyeIIR0PIe7hd59912sXbuWL8AJgC+cWVxcjNWrV3dEOz3S1IHR2HLyFvp3M2zTIxMZAqCzc+y4HjuaX0eIa1C8co7pjaXYpNwJN78OAKTtFF4nhLiHw4ndxo0b8T//8z949tln+ccee+wxDB48GK+++mqXCpRL05Oh1bOYM9KwywU/x65ZZ/euEzBJ7G5TYkeIS1G8un/cqthmnR4qdcvCCVr4QIhncjix02g0GDFiRKvHU1JSoNVqXdUurxAdLMVHTw3hv5aaDcU60mNneBu4ycmh/pTYEeIKFK/uH5fYaXUsGowLJ5xdEUsI6XgOz7GbM2cONm7c2OrxL774ArNnz3ZVu7ySaYFiR+bYWe4OEUKJHSEuQfHKMdbKnZjWsbufGnaEkM7h1F/npk2bsHfvXn6D69zcXBQXF2Pu3Llm+xiuXbvWdS31Anxi16x3aI5dmEUiZ/k1IcR5FK8cZzrIKvYznWNHPXaEeDqHE7sLFy5g+PDhAIDr168DAMLDwxEeHo4LFy7wx3XFVZ3cqlhH69hZ9tDRUCwhrkHx6v61zLFj77s4MSGk4zmc2B06dKhjWuIDuDp2qmatSY9d+wHQMpGjxI4Q16B45RhrQ7EtdexMe+xoKJYQT+VUHTtinUzUsuerQz12FqtgI2hjbEKIO5l0YJoPxVKPHSGejhI7FzLdUsyROXbc9mSc7graGJsQ4hn4xRNa83InhBDPRImdC3HBztBjZ/+qWAAIkLYkdt0U0g5qISGEOMbqHDva8pAQj0WJnQvJTBI7R3rsAGBscgQAoE9UoF1FjQkhxNWsTLFrqWOnN5ljJ6IYRYinotsuF+ImFDdqHNt5AgAWj+8FjY7FkymxHdpGQghpDwPTLcVMhmKpx44Qj0d/nS7UMhSrdXgotkeoHB//ZogdRxJCSOcRGRdPNOv0tPMEIV6AhmJdqKWOnR4NxjtbGQ1ZEEK8GN9jp2PRoKbEjhBPR4mdC5kGu2pVM2CS7BFCiMezUsjONIZVNRjiGtWxI8RzUWLnQlI/0wCoMTwmoh8xIcS7mG7EYR7XuMSOblgJ8VSUdbiQQMDwQ69VDWqAhmIJIV5OIGD41f2U2BHi+SixczEu4HEBUEqJHSHES1grdwIAUmNid09lGImgoVhCPBcldg64cbe+3WO4+SganSFEUo8dIcTbMBZfW84Vph47QjwXJXYO4O5SpTZimmXAo8UThBBvZznyQIkdIZ6LEjsHDItTYNGYnniqp67NYyx76KjHjhDvl5CQAIZhWn0sXrwYANDU1ITFixcjLCwMAQEBmDVrFsrKysyeo7i4GNOnT4dcLkdkZCTeeustaLVam69bVVWF2bNnIygoCAqFAgsWLEB9ffsjB65mGcdoKJYQz+XWxK69YPnFF19g3LhxCAoKAsMwqK6ubvO51Go1hg4dCoZhkJ+f3yHtTYwIwBuTeqO7f9vHWPbQ0Rw7QrzfyZMnUVpayn/s27cPAPDUU08BAJYtW4affvoJW7duxeHDh1FSUoKZM2fy5+t0OkyfPh3Nzc04duwYvv76a3z11Vd49913bb7u7NmzcfHiRezbtw87duzAkSNHsHDhwg67TivVTgAAEssbVuqxI8RjuTWxay9YqlQqZGRkYMWKFe0+1+9//3vExMR0eJvbY3knS4kdId4vIiIC0dHR/MeOHTuQlJSEsWPHoqamBps2bcLatWsxYcIEpKSkICsrC8eOHcPx48cBAHv37sWlS5ewefNmDB06FFOnTsUf//hHbNiwAc3NzVZf8/Lly9izZw++/PJLpKamYvTo0fj000+xZcsWlJSUdOj1MhaT7GQWZZtoKJYQz+XWxM5WsASApUuX4r/+678wcuRIm8+ze/du7N27Fx999FEntbxtlneydGdLiG9pbm7G5s2b8fzzz4NhGOTl5UGj0SA9PZ0/pm/fvoiLi0NOTg4AICcnB4MGDUJUVBR/zJQpU1BbW4uLFy9afZ2cnBwoFAqMGDGCfyw9PR0CgQC5ubkdcm1Xyq0P85reoIqFAoiENIuHEE/lMRMluGCZmZkJxvJ20YaysjK8+OKL2L59O+RyuV3nqNVqqNVq/uva2loAgEajgUajsXku9/22jpP6mbddyOqg0bRVRMCztHdt3oyuzTs5cm2ddf3bt29HdXU15s+fDwBQKpUQi8VQKBRmx0VFRUGpVPLHmCZ13Pe571mjVCoRGRlp9pifnx9CQ0PbPAf3Gd94er3ZsRJhS1yTi4Ve+btGfyfeia4Ndh/D8ZjEzjJY2oNlWcyfPx+LFi3CiBEjUFhYaNd5a9aswXvvvdfq8b1799qdHHLDxpbKSwR8R6hYwGLvf/bY9XyepK1r8wV0bd7JnmtTqVSd0pZNmzZh6tSpHjH1w5r7iW8PRAjAALj760nsutLyeGV5S1wT6puxa9cu1ze8k3T1vxNv1dWvzZH45jGJnTPB8tNPP0VdXR2WL1/u0GstX74cmZmZ/Ne1tbXo0aMHJk+ejKCgIJvnajQa7Nu3D5MmTYJIJGr1/Yt7r+BnpSHBVPhLMW3aWIfa5k7tXZs3o2vzTo5cG9cz1ZGKioqwf/9+bNu2jX8sOjoazc3NqK6uNuu1KysrQ3R0NH/MiRMnzJ6LWzXLHWMpOjoa5eXlZo9ptVpUVVW1eQ7uM75NauPnfezHSzhVcdvQrrAgTJuWZvN5PBH9nXgnujYDR+KbRyR21oKlPQ4ePIicnBxIJBKzx0eMGIHZs2fj66+/tnqeRCJpdQ4AiEQiu39x2jo2NEDKfx4o9fPKX0RHfg7ehq7NO9lzbZ1x7VlZWYiMjMT06dP5x1JSUiASiXDgwAHMmjULAFBQUIDi4mKkpRkSoLS0NLz//vsoLy/nh1f37duHoKAg9O/f3+prpaWlobq6Gnl5eUhJSQGMMU+v1yM1NbXNNnZEfAuStXyukIu9+vesq/+deKuufm2OXLtHzIC1FiztsX79epw9exb5+fnIz8/nhwe+//57vP/++x3UWttC5WL+80Cpb/4SEtIV6fV6ZGVlYd68efDza7knDg4OxoIFC5CZmYlDhw4hLy8Pv/vd75CWlsYv/Jo8eTL69++POXPm4OzZs/jPf/6Dd955B4sXL+aTsBMnTqBv3764c+cOAKBfv37IyMjAiy++iBMnTuCXX37BkiVL8Mwzz3T6MLDCJK4FUVwjxKO5vceurWAJ4+RhpVKJa9euAQDOnz+PwMBAxMXFITQ0FHFxcWbHBwQEAACSkpIQGxvbiVfRItTfJADKKAAS4iv279+P4uJiPP/8862+98knn0AgEGDWrFlQq9WYMmUKPvvsM/77QqEQO3bswMsvv4y0tDT4+/tj3rx5WL16NX+MSqVCQUGB2STpb7/9FkuWLMHEiRP551+/fn0nXK0507gWTHGNEI/m9sTOVrD8/PPPzSYBjxkzBjD28DmyyKIzhZgEwFA5BUBCfMXkyZPBtlHBVyqVYsOGDdiwYUOb58fHx9tcdDBu3LhWzx8aGop//OMf99Fq1wgxiWWmMY4Q4nncntjZCparVq3CqlWr7H6uhISENp+rs5je2UYFSW0eSwgh3sB0KDYmmOIaIZ7MI+bY+ZLYEBn/eSjd2RJCfEBiRMs+irEh9pWEIoS4h9t77HyNSCjAykf745drlXhqRA93N4cQQu5bZKAUL4zuiZKaRozuHe7u5hBCbKDErgP8blRP/G5UT3c3gxBCXOadR6yXZSGEeBYaiiWEEEII8RGU2BFCCCGE+AhK7AghhBBCfAQldoQQQgghPoIWTwB87Tt7NtnVaDRQqVSora31uX3r6Nq8E12bAff36+5alp6G4psBXZt3omszcCS+UWIHoK6uDgDQoweVJyHE29XV1SE4ONjdzfAYFN8I8R32xDeGpdtb6PV6lJSUIDAwEAzD2Dy2trYWPXr0wK1btxAUFNRpbewMdG3eia7NgGVZ1NXVISYmBgIBzTLhUHwzoGvzTnRtBo7EN+qxAyAQCBAbG+vQOUFBQT73S8aha/NOdG2gnjorKL6Zo2vzTnRt9sc3uq0lhBBCCPERlNgRQgghhPgISuwcJJFIsHLlSkgkEnc3xeXo2rwTXRtxFV/+edO1eSe6NsfR4glCCCGEEB9BPXaEEEIIIT6CEjtCCCGEEB9BiR0hhBBCiI+gxM4BGzZsQEJCAqRSKVJTU3HixAl3N+m+rVq1CgzDmH307dvX3c1yypEjR/Doo48iJiYGDMNg+/btZt9nWRbvvvsuunXrBplMhvT0dFy9etVt7XVEe9c2f/78Vu9jRkaG29rriDVr1uCBBx5AYGAgIiMjMWPGDBQUFJgd09TUhMWLFyMsLAwBAQGYNWsWysrK3NZmX0UxzrNRjPO+GOeO+EaJnZ2+//57ZGZmYuXKlTh9+jSGDBmCKVOmoLy83N1Nu28DBgxAaWkp/3H06FF3N8kpDQ0NGDJkCDZs2GD1+3/5y1+wfv16fP7558jNzYW/vz+mTJmCpqamTm+ro9q7NgDIyMgwex+/++67Tm2jsw4fPozFixfj+PHj2LdvHzQaDSZPnoyGhgb+mGXLluGnn37C1q1bcfjwYZSUlGDmzJlubbevoRjn+SjGeV+Mc0t8Y4ldHnzwQXbx4sX81zqdjo2JiWHXrFnj1nbdr5UrV7JDhgxxdzNcDgD7ww8/8F/r9Xo2Ojqa/fDDD/nHqqurWYlEwn733XduaqVzLK+NZVl23rx57OOPP+62NrlSeXk5C4A9fPgwyxrfJ5FIxG7dupU/5vLlyywANicnx40t9S0U47wLxTjv1BnxjXrs7NDc3Iy8vDykp6fzjwkEAqSnpyMnJ8etbXOFq1evIiYmBomJiZg9ezaKi4vd3SSXu3nzJpRKpdl7GBwcjNTUVJ94DwEgOzsbkZGR6NOnD15++WVUVla6u0lOqampAQCEhoYCAPLy8qDRaMzeu759+yIuLs5n3jt3oxjn/SjGeYfOiG+U2NmhoqICOp0OUVFRZo9HRUVBqVS6rV2ukJqaiq+++gp79uzBxo0bcfPmTTz88MOoq6tzd9NcinuffPE9hHGI4u9//zsOHDiAP//5zzh8+DCmTp0KnU7n7qY5RK/XY+nSpRg1ahQGDhwIGN87sVgMhUJhdqyvvHeegGKc96MY5/k6K775uaS1xGtNnTqV/3zw4MFITU1FfHw8/vnPf2LBggVubRux3zPPPMN/PmjQIAwePBhJSUnIzs7GxIkT3do2RyxevBgXLlzw2jlQxPNQjPMNvhDjOiu+UY+dHcLDwyEUClutUikrK0N0dLTb2tURFAoFkpOTce3aNXc3xaW496krvIcAkJiYiPDwcK96H5csWYIdO3bg0KFDiI2N5R+Pjo5Gc3MzqqurzY731ffOHSjGeT+KcZ6tM+MbJXZ2EIvFSElJwYEDB/jH9Ho9Dhw4gLS0NLe2zdXq6+tx/fp1dOvWzd1NcamePXsiOjra7D2sra1Fbm6uz72HAHD79m1UVlZ6xfvIsiyWLFmCH374AQcPHkTPnj3Nvp+SkgKRSGT23hUUFKC4uNgn3zt3oBjn/SjGeSa3xDeXLfXwcVu2bGElEgn71VdfsZcuXWIXLlzIKhQKVqlUurtp9+WNN95gs7Oz2Zs3b7K//PILm56ezoaHh7Pl5eXubprD6urq2DNnzrBnzpxhAbBr165lz5w5wxYVFbEsy7IffPABq1Ao2B9//JE9d+4c+/jjj7M9e/ZkGxsb3d30dtm6trq6OvbNN99kc3Jy2Js3b7L79+9nhw8fzvbu3Zttampyd9Pb9fLLL7PBwcFsdnY2W1payn+oVCr+mEWLFrFxcXHswYMH2VOnTrFpaWlsWlqaW9vtayjGeT6Kcd4X49wR3yixc8Cnn37KxsXFsWKxmH3wwQfZ48ePu7tJ9+3pp59mu3XrxorFYrZ79+7s008/zV67ds3dzXLKoUOHWACtPubNm8eyxnIA//3f/81GRUWxEomEnThxIltQUODuZtvF1rWpVCp28uTJbEREBCsSidj4+Hj2xRdf9Jp/yNauCwCblZXFH9PY2Mi+8sorbEhICCuXy9knnniCLS0tdWu7fRHFOM9GMc77Ypw74htjfGFCCCGEEOLlaI4dIYQQQoiPoMSOEEIIIcRHUGJHCCGEEOIjKLEjhBBCCPERlNgRQgghhPgISuwIIYQQQnwEJXaEEEIIIT6CEjtCCCGEEB9BiR3xSNnZ2WAYptXGyJ3lwIED6NevH3Q6XbvH7tmzB0OHDoVer++UthFCvBvFN9KRKLEjbjdu3DgsXbrU7LGHHnoIpaWlCA4Odkubfv/73+Odd96BUChs99iMjAyIRCJ8++23ndI2Qoj3oPhGOhsldsQjicViREdHg2GYTn/to0eP4vr165g1a5bd58yfPx/r16/v0HYRQnwDxTfSkSixI241f/58HD58GOvWrQPDMGAYBoWFha2GKr766isoFArs2LEDffr0gVwux5NPPgmVSoWvv/4aCQkJCAkJwWuvvWY2vKBWq/Hmm2+ie/fu8Pf3R2pqKrKzs222acuWLZg0aRKkUin/2NmzZzF+/HgEBgYiKCgIKSkpOHXqFP/9Rx99FKdOncL169c75OdECPE+FN+IO/i5uwGka1u3bh2uXLmCgQMHYvXq1QCAiIgIFBYWtjpWpVJh/fr12LJlC+rq6jBz5kw88cQTUCgU2LVrF27cuIFZs2Zh1KhRePrppwEAS5YswaVLl7BlyxbExMTghx9+QEZGBs6fP4/evXtbbdPPP/+M5557zuyx2bNnY9iwYdi4cSOEQiHy8/MhEon478fFxSEqKgo///wzkpKSXPxTIoR4I4pvxB0osSNuFRwcDLFYDLlcjujoaJvHajQabNy4kQ8sTz75JL755huUlZUhICAA/fv3x/jx43Ho0CE8/fTTKC4uRlZWFoqLixETEwMAePPNN7Fnzx5kZWXhT3/6k9XXKSoq4o/nFBcX46233kLfvn0BwGrQjImJQVFRkdM/C0KIb6H4RtyBEjviNeRyudndYlRUFBISEhAQEGD2WHl5OQDg/Pnz0Ol0SE5ONnsetVqNsLCwNl+nsbHRbJgCADIzM/HCCy/gm2++QXp6Op566qlWd64ymQwqleq+r5MQ0vVQfCOuQokd8RqmQwMAwDCM1ce4Zfn19fUQCoXIy8trtfrLNFhaCg8Px71798weW7VqFZ577jns3LkTu3fvxsqVK7FlyxY88cQT/DFVVVWIiIi4r2skhHRNFN+Iq1BiR9xOLBbbVU/JUcOGDYNOp0N5eTkefvhhh867dOlSq8eTk5ORnJyMZcuW4dlnn0VWVhYf+JqamnD9+nUMGzbMpddACPFuFN9IZ6NVscTtEhISkJubi8LCQlRUVLisEGZycjJmz56NuXPnYtu2bbh58yZOnDiBNWvWYOfOnW2eN2XKFBw9epT/urGxEUuWLEF2djaKiorwyy+/4OTJk+jXrx9/zPHjxyGRSJCWluaSthNCfAPFN9LZKLEjbvfmm29CKBSif//+iIiIQHFxscueOysrC3PnzsUbb7yBPn36YMaMGTh58iTi4uLaPGf27Nm4ePEiCgoKAABCoRCVlZWYO3cukpOT8Zvf/AZTp07Fe++9x5/z3XffYfbs2ZDL5S5rOyHE+1F8I52NYVmWdXcjCPE0b731Fmpra/G3v/2t3WMrKirQp08fnDp1Cj179uyU9hFCiLMovvk26rEjxIq3334b8fHxdg2bFBYW4rPPPqOgRwjxChTffBv12BFCCCGE+AjqsSOEEEII8RGU2BFCCCGE+AhK7AghhBBCfAQldoQQQgghPoISO0IIIYQQH0GJHSGEEEKIj6DEjhBCCCHER1BiRwghhBDiIyixI4QQQgjxEZTYEUIIIYT4iP8PMb7GaQiYeN8AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "\n", + "plt.subplot(2, 2, 1)\n", + "for name in [\"P_elec1\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-6 * ts_sp1ph_TrStab_dl[name].interpolate(timestep).values[begin_idx:end_idx],\n", + " label=\"P_elec G1\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"power (MW)\")\n", + "plt.title(\"P_elec G1\")\n", + "\n", + "plt.subplot(2, 2, 2)\n", + "for name in [\"P_elec2\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-6 * ts_sp1ph_TrStab_dl[name].interpolate(timestep).values[begin_idx:end_idx],\n", + " label=\"P_elec G2\",\n", + " )\n", + "\n", + "# plt.legend(loc='lower right')\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"power (MW)\")\n", + "plt.title(\"P_elec G2\")\n", + "\n", + "plt.subplot(2, 2, 3)\n", + "for name in [\"P_elec3\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-6 * ts_sp1ph_TrStab_dl[name].interpolate(timestep).values[begin_idx:end_idx],\n", + " label=\"P_elec G3\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"power (MW)\")\n", + "plt.title(\"P_elec G3\")\n", + "\n", + "plt.subplot(2, 2, 4)\n", + "for name in [\"P_elec4\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " 1e-6 * ts_sp1ph_TrStab_dl[name].interpolate(timestep).values[begin_idx:end_idx],\n", + " label=\"P_elec G4\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"power (MW)\")\n", + "plt.title(\"P_elec G4\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Rotor angular speed $\\omega_r$" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "<>:11: SyntaxWarning: invalid escape sequence '\\o'\n", + "<>:22: SyntaxWarning: invalid escape sequence '\\o'\n", + "<>:33: SyntaxWarning: invalid escape sequence '\\o'\n", + "<>:44: SyntaxWarning: invalid escape sequence '\\o'\n", + "<>:11: SyntaxWarning: invalid escape sequence '\\o'\n", + "<>:22: SyntaxWarning: invalid escape sequence '\\o'\n", + "<>:33: SyntaxWarning: invalid escape sequence '\\o'\n", + "<>:44: SyntaxWarning: invalid escape sequence '\\o'\n", + "/tmp/ipykernel_807343/1978007569.py:11: SyntaxWarning: invalid escape sequence '\\o'\n", + " plt.title('$\\omega_{r,1}$')\n", + "/tmp/ipykernel_807343/1978007569.py:22: SyntaxWarning: invalid escape sequence '\\o'\n", + " plt.title('$\\omega_{r,2}$')\n", + "/tmp/ipykernel_807343/1978007569.py:33: SyntaxWarning: invalid escape sequence '\\o'\n", + " plt.title('$\\omega_{r,3}$')\n", + "/tmp/ipykernel_807343/1978007569.py:44: SyntaxWarning: invalid escape sequence '\\o'\n", + " plt.title('$\\omega_{r,4}$')\n" + ] + }, + { + "data": { + "text/plain": [ + "(59.8, 60.2)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnUAAAHWCAYAAAARl3+JAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAbtZJREFUeJzt3Xl8jPf6P/7XPZOZyZ6QPbbEEnvtUtv5UWmiSkkVtRy0TrWWo4QuutiqUvrhi2rjOKeNbmgd9DhtKQ1SUkFULVXBSKTIIovsmUxm7t8fkjlGEmZiJjNz9/V8PObB/b636zLJ5Zp77kUQRVEEERERETk0ma0DICIiIqKHx6aOiIiISALY1BERERFJAJs6IiIiIglgU0dEREQkAWzqiIiIiCSATR0RERGRBLCpIyIiIpIANnVEREREEsCmjoiIiEgC2NQRERERSQCbOnI42dnZ8Pb2xksvvVTn/Ly8PAiCgIULFzZ6bERElsaaR6ZiU0cO5+2330ZlZSWWL19e53wfHx8EBQXh5MmTjR4bEZGlseaRqdjUkUP5448/sGXLFjz33HPw9/evd7lmzZohLS2tUWMjIrI01jwyB5s6ciiffPIJtFotnn/+ecNYZWUlysvLjZZTKBS1xoiIHA1rHpmDTR05lO+++w5+fn7o1auXYWzixIkYPXq00XJ5eXnw8fExe/txcXHo2bMnFAoFli5dapGYiYgaypo1T6PR4Pnnn0fLli3h6emJRx99FMeOHbNY7NT42NSRwxBFEefOnUOnTp2MxpOTk9G2bVvDdGFhIdRqNbp161bndnQ6Xb37CAoKwtKlSzFmzBgLRk5EZD5r17yqqiqEhITg6NGjuH37NubNm4eRI0eipKTEwplQY2FTRw6juLgYFRUVCAwMNIydPn0aN27cgLe3t2EsISEBOp0OkZGRAID169cjOjoaY8eOhbu7O/bv31/vPkaPHo2nnnrKaHtERLZg7Zrn5uaGxYsXo2XLlpDJZHj22WehVCqRmpraCNmRNTjZOgAiU6lUKgDAzZs3DWPr1q2Dv78/cnNzgepPpP/3f/8HT09PPPPMMwCAs2fPIikpCf/+97/x1Vdf3fdIHRGRvWjsmnf58mXk5+cbHQUkx8KmjhyGSqVCnz59cOTIEbzxxhuoqKjA999/j5iYGKxevRpdunTBvn37cOzYMWzatAleXl5AdYFbsmQJ/vKXvwAAZDIeoCYi+9eYNa+8vByTJ0/GokWLDNshxyOIoijaOggiU507dw7Tpk3Db7/9hs6dO+Ojjz5Chw4dMGbMGCQlJaFly5Z47bXXDFeK6fV6eHh44PLlywgODjZ5Py+99BICAwN5sQQR2VRj1DytVovo6Gh4eXnhiy++gCAIVs6KrIVH6sihdO3aFadOnao1/uOPP9a5/JUrV+Dh4WFWQ0dEZC+sXfP0ej3++te/QhAEfPrpp2zoHBybOpK0s2fP1nlF2LRp0wAAW7ZsMRqvqqpCVVUVdDodqqqqUFFRAYVCAblc3mgxExE1lLk178UXX0RmZiZ++OEHODmxJXB0PLmIJO3cuXN45JFHao1fv34dAwYMqDW+YsUKuLi44F//+hfeffdduLi44PPPP2+kaImIHo45Ne/atWv417/+hRMnTsDX1xfu7u5wd3fHkSNHGjFisiSeU0d/OlVVVXjkkUdw5swZKBQKW4dDRGRVrHl/HjY/Unfjxg1MnjwZPj4+cHFxQdeuXZGSkmKYL4oiFi9ejKCgILi4uCAiIgKXL1++7zZjY2PRp08feHh4wN/fH6NHj+Z9d8jAyckJFy5cYHEjm2DNo8bGmvfnYdOmrqCgAAMGDIBCocDevXtx4cIFrFmzBk2aNDEss3r1amzYsAGbNm3C8ePH4ebmhqioKFRUVNS73cTERMyePRvJyck4cOAAtFotIiMjUVpa2kiZERHVxppHRNZk069fX3/9dSQlJdX7/b0oiggODsaCBQuwcOFCoPpxKAEBAdiyZQueffZZk/Zz69Yt+Pv7IzEx0XDfHiKixsaaR0TWZNNLXfbs2YOoqCiMHTsWiYmJaNasGWbNmoUXXngBAJCWloasrCxEREQY1vHy8kJ4eDiOHTtmcoErLCwEADRt2rTO+RqNBhqNxjCt1+uRn58PHx8fXt5NZIdEUURxcTGCg4Md6mbSrHlE1BAm1zzRhlQqlahSqcRFixaJv/zyi/iPf/xDdHZ2Frds2SKKoigmJSWJAMSbN28arTd27Fhx3LhxJu1Dp9OJTz75pDhgwIB6l1myZIkIgC+++HKw1x9//PGQVahxsebxxRdfD/N6UM2z6ZE6vV6P3r17Y+XKlQCAHj164Pz589i0aROmTp1qkX3Mnj0b58+fx9GjR+tdZtGiRYiJiTFMFxYWomXLlkhLS4OHh8d9t6/VanHo0CEMGTJEMiehMifHILWczMmnuLgYoaGhD/z9tDesefaJOdk/qeUDK9U8mzZ1QUFB6NSpk9FYx44dsXPnTgBAYGAgACA7OxtBQUGGZbKzs9G9e/cHbn/OnDn49ttv8dNPP6F58+b1LqdSqQwPTr5b06ZN4enped99aLVauLq6wsfHR1I/aMzJ/kktJ3PyqZnvaF8VsubZJ+Zk/6SWD6xU82x6MsqAAQNqXXZ/6dIltGrVCgAQGhqKwMBAJCQkGOYXFRXh+PHj6NevX73bFUURc+bMwe7du3Hw4EGEhoZaMQsiItOw5hGRNdm0qZs/fz6Sk5OxcuVKXLlyBVu3bsXmzZsxe/ZsoLojnTdvHlasWIE9e/bg3LlzmDJlCoKDgzF69GjDdoYOHYqNGzcapmfPno0vvvgCW7duhYeHB7KyspCVlYXy8nKb5ElEBNY8IrIym3792qdPH+zevRuLFi3C8uXLERoainXr1mHSpEmGZV599VWUlpZixowZuH37NgYOHIh9+/bB2dnZsIxarUZubq5hOi4uDgAwePBgo/3Fx8cbnn9HRNTYWPOIyJps/vTeESNGYMSIEfXOFwQBy5cvx/Lly+tdJj093WiaTz4jInvFmkdE1uI4N3giIiIionqxqSMiIiKSADZ1RERERBLApo6IiIhIAtjUEREREUkAmzoiIiIiCWBTR0RERCQBbOqIiIiIJIBNHREREZEEsKkjIiIikgA2dUREREQSwKaOiIiISALY1BERERFJAJs6IiIiIglgU0dEREQkAWzqiIiIiCSATR0RERGRBLCpIyIiIpIANnVEREREEsCmjoiIiEgCnMxdIS0tDUeOHMG1a9dQVlYGPz8/9OjRA/369YOzs7N1oiQishHWPCJyFCY3dV9++SXWr1+PlJQUBAQEIDg4GC4uLsjPz4darYazszMmTZqE1157Da1atbJu1EREVsaaR0SOxqSmrkePHlAqlZg2bRp27tyJFi1aGM3XaDQ4duwYtm/fjt69e+Ojjz7C2LFjrRUzEZFVseYRkSMyqal77733EBUVVe98lUqFwYMHY/DgwXj33XeRnp5uyRiJiBoVax4ROSKTmrr7Fbd7+fj4wMfH52FiIiKyKdY8InJEZl/9+thjj2HZsmW1xgsKCvDYY49ZKi4iIrvAmkdEjsLsq18PHz6Mc+fO4fTp0/jyyy/h5uYGAKisrERiYqI1YiQishnWPCJyFA26T92PP/6IrKwsPProow99LsmNGzcwefJk+Pj4wMXFBV27dkVKSophviiKWLx4MYKCguDi4oKIiAhcvnz5vtv86aefMHLkSAQHB0MQBHzzzTcPFSMR/blZquax3hGRNTWoqQsKCkJiYiK6du2KPn364PDhww3aeUFBAQYMGACFQoG9e/fiwoULWLNmDZo0aWJYZvXq1diwYQM2bdqE48ePw83NDVFRUaioqKh3u6WlpejWrRs+/PDDBsVFRHQ3S9Q81jsisjazv34VBAGovvpr69atWLFiBYYNG4bXXnvN7J2vWrUKLVq0QHx8vGEsNDTU8HdRFLFu3Tq89dZbGDVqFADgs88+Q0BAAL755hs8++yzdW73iSeewBNPPGF2PERE97JUzWO9IyJrM/tInSiKRtNvvfUWvvzyS6xZs8bsne/Zswe9e/fG2LFj4e/vjx49euCf//ynYX5aWhqysrIQERFhGPPy8kJ4eDiOHTtm9v6IiMxlqZrHekdE1tagx4T5+voajY0ZMwbt27fHqVOnzNrW1atXERcXh5iYGLzxxhs4efIk5s6dC6VSialTpyIrKwsAEBAQYLReQECAYZ4laDQaaDQaw3RRUREAQKvVQqvV3nfdmvkPWs6RMCfHILWczMmnMXO2VM2zl3oH1rxamJP9k1o+sFLNM7upq+9xOF26dEGXLl3M2pZer0fv3r2xcuVKoPou7ufPn8emTZswdepUc0NrsNjY2DpvWbB//364urqatI0DBw5YITLbYk6OQWo5mZJPWVlZo8QCC9Y8e6l3YM2rF3Oyf1LLBxaueSY3dU8//bRJy+3atcvUTSIoKAidOnUyGuvYsSN27twJAAgMDAQAZGdnIygoyLBMdnY2unfvbvJ+HmTRokWIiYkxTBcVFaFFixaIjIyEp6fnfdfVarU4cOAAHn/8cSgUCovFZEvMyTFILSdz8qk5smRNlq559lLvwJpXC3Oyf1LLB1aqeSY3dV5eXkbTW7duxciRI+Hh4WHqJmoZMGAAUlNTjcYuXbpk+GQcGhqKwMBAJCQkGIpaUVERjh8/jpkzZzZ4v/dSqVRQqVS1xhUKhck/POYs6yiYk2OQWk6m5NMY+Vq65tlLvQNrXr2Yk/2TWj6wcM0zuam7+4otAPj3v/+N1atXo3Xr1qZuopb58+ejf//+WLlyJcaNG4cTJ05g8+bN2Lx5M1B91dm8efOwYsUKtGvXDqGhoXj77bcRHByM0aNHG7YzdOhQREdHY86cOQCAkpISXLlyxTA/LS0Nv/76K5o2bYqWLVs2OF4i+vOwdM1jvSMiazP7nDpL6tOnD3bv3o1FixZh+fLlCA0Nxbp16zBp0iTDMq+++ipKS0sxY8YM3L59GwMHDsS+ffvg7OxsWEatViM3N9cwnZKSgiFDhhima75mmDp1KrZs2dJo+RER1WC9IyJrs2lTBwAjRozAiBEj6p0vCAKWL1+O5cuX17vMvXd4Hzx4cK3bEBAR2RrrHRFZU4OeKEFERERE9sXkI3V79uwxmtbr9UhISMD58+eNxp966inLRUdEZCOseUTkaExu6u4+UbfGiy++aDQtCAJ0Op1lIiMisiHWPCJyNCY3dXq93rqREBHZEdY8InI0PKeOiIiISAJMauqSk5NN3mBZWRl+++23h4mJiMimWPOIyBGZ1NT99a9/RVRUFHbs2IHS0tI6l7lw4QLeeOMNtGnTxqyHXBMR2RvWPCJyRCadU3fhwgXExcXhrbfewsSJExEWFobg4GA4OzujoKAAFy9eRElJCaKjo7F//3507drV+pETEVkJax4ROSKTmjqFQoG5c+di7ty5SElJwdGjR3Ht2jWUl5ejW7dumD9/PoYMGYKmTZtaP2IiIitjzSMiR2T2EyV69+6N3r17WycaIiI7w5pHRI6CV78SERERSQCbOiIiIiIJYFNHREREJAFs6oiIiIgkwOym7urVq9aJhIjIDrHmEZGjMLupa9u2LYYMGYIvvvgCFRUV1omKiMhOsOYRkaMwu6n75Zdf8MgjjyAmJgaBgYF48cUXceLECetER0RkY6x5ROQozG7qunfvjvXr1+PmzZv45JNPkJmZiYEDB6JLly5Yu3Ytbt26ZZ1IiYhsgDWPiBxFgy+UcHJywtNPP40dO3Zg1apVuHLlChYuXIgWLVpgypQpyMzMtGykREQ2xJpHRPauwU1dSkoKZs2ahaCgIKxduxYLFy6EWq3GgQMHcPPmTYwaNcqykRIR2RBrHhHZO7MfE7Z27VrEx8cjNTUVw4cPx2effYbhw4dDJrvTH4aGhmLLli0ICQmxRrxERI2KNY+IHIXZTV1cXByef/55TJs2DUFBQXUu4+/vj48//tgS8RER2RRrHhE5CrObusuXLz9wGaVSialTpzY0JiIiu8GaR0SOwuxz6uLj47Fjx45a4zt27MCnn35qqbiIiOwCax4ROQqzm7rY2Fj4+vrWGvf398fKlSstFRcRkV1gzSMiR2F2U5eRkYHQ0NBa461atUJGRoal4iIisguseUTkKMxu6vz9/XH27Nla42fOnIGPj4+l4iIisguseUTkKMxu6iZMmIC5c+fi0KFD0Ol00Ol0OHjwIF5++WU8++yz1omSiMhGWPOIyFGY3dS98847CA8Px9ChQ+Hi4gIXFxdERkbisccea9D5JTdu3MDkyZPh4+MDFxcXdO3aFSkpKYb5oihi8eLFCAoKgouLCyIiIky6Gu3DDz9ESEgInJ2dER4ezmc1ElGDsOYRkaMwu6lTKpX46quvcPHiRXz55ZfYtWsX1Go1PvnkEyiVSrO2VVBQgAEDBkChUGDv3r24cOEC1qxZgyZNmhiWWb16NTZs2IBNmzbh+PHjcHNzQ1RUFCoqKurd7ldffYWYmBgsWbIEv/zyC7p164aoqCjk5OSYmy4R/cmx5hGRwxBt6LXXXhMHDhxY73y9Xi8GBgaK77//vmHs9u3bokqlErdt21bven379hVnz55tmNbpdGJwcLAYGxtrUlyFhYUiALGwsPCBy1ZWVorffPONWFlZadK2HQFzcgxSy8mcfMz5HbUnrHn2iTnZP6nlI1qp5pl982GdToctW7YgISEBOTk50Ov1RvMPHjxo8rb27NmDqKgojB07FomJiWjWrBlmzZqFF154AQCQlpaGrKwsREREGNbx8vJCeHg4jh07Vuf5LJWVlTh16hQWLVpkGJPJZIiIiMCxY8fqjEOj0UCj0Rimi4qKAABarRZarfa+OXx9MgNOOjxwOUdSkwtzsm9Sy8mcfBozZ9a8/ykq1+L41VyUV0nn5w4S/F2CBHOSWj6wUs0zu6l7+eWXsWXLFjz55JPo0qULBEEwdxMGV69eRVxcHGJiYvDGG2/g5MmTmDt3ruHu7FlZWQCAgIAAo/UCAgIM8+6Vm5sLnU5X5zoXL16sc53Y2FgsW7as1vj+/fvh6upab/zn8gX8K1WOJko51EU/onMT0aS8HcWBAwdsHYLFMSf7Z0o+ZWVljRILWPOMnMkT8MklOeSCHNuvJuDJFnr4u5iUukOQ2u8SJJiT1PKBhWue2U3d9u3b8fXXX2P48OHmrlqLXq9H7969DScb9+jRA+fPn8emTZsa9ZE7ixYtQkxMjGG6qKgILVq0QGRkJDw9Petdz/9aAfZln8P12xXYfFGOviFNMH1gCIaE+T5U4bc1rVaLAwcO4PHHH4dCobB1OBbBnOyfOfnUHFlqDKx5/yOey0LL3MvIyC/Hr3kCfi90Qmx0Z4x8pO5n4joKqf0uQYI5SS0fWKnmmd3UKZVKtG3b1tzV6hQUFIROnToZjXXs2BE7d+4EAAQGBgIAsrOzjR6knZ2dje7du9e5TV9fX8jlcmRnZxuNZ2dnG7Z3L5VKBZVKVWtcoVDc9x+6X1t/fPf3/pj3rx9xJFuOE+kFOJFegM7Bnlg8ohPCWzv2PawelL8jYk72z5R8GjNf1rz/Gd2zBZ7sGojNO75HUqk/flbnI2bHOWQWVWLW4DYO/WEWEvxdggRzklo+sHDNM/vq1wULFmD9+vUQxYf/qnHAgAFITU01Grt06RJatWoFAAgNDUVgYCASEhIM84uKinD8+HH069evzm0qlUr06tXLaB29Xo+EhIR613kYrkonjA7R42DMIMz4S2u4KuX47WYRJvwzGZsS1RbfHxE1Lta82pq7AZ9M6YXpA+88aeP9H1Lx2s6z0Or0D1yXiKzH7CN1R48exaFDh7B371507ty5Vve4a9cuk7c1f/589O/fHytXrsS4ceNw4sQJbN68GZs3bwYACIKAefPmYcWKFWjXrh1CQ0Px9ttvIzg4GKNHjzZsZ+jQoYiOjsacOXMAADExMZg6dSp69+6Nvn37Yt26dSgtLcVzzz1nbromC/JyxhvDO+Kl/68NVn7/O/596jre23sRheVavBrV3uE/wRL9WbHm1U0uE/D2iE5o5eOKpXt+w9cp13H2eiEWj+yE/m1qPyuXiKzP7KbO29sb0dHRFtl5nz59sHv3bixatAjLly9HaGgo1q1bh0mTJhmWefXVV1FaWooZM2bg9u3bGDhwIPbt2wdnZ2fDMmq1Grm5uYbp8ePH49atW1i8eDGysrLQvXt37Nu3r9aJxNbQ1E2J/xvbDe0DPPDu978j7rAaBaWVWDG6C5zkZh8YJSIbY827vyn9QtDM2wULdpzBxaxiTPzncTzauinmRYThUQc/BYXI0Zjd1MXHx1s0gBEjRmDEiBH1zhcEAcuXL8fy5cvrXSY9Pb3W2Jw5cwyfYm3hhb+0hpvKCW99cw7bT/6B9LxSvDm8E7o08+RROyIHwpr3YEM7BuDQgsH4fz9ewvYTfyD5aj6e3ZzM5o6okZnd1AFAVVUVDh8+DLVajYkTJ8LDwwM3b96Ep6cn3N3dLR+lg5oY3hK+7krM3X4ayVfzMXLjUTR1U6Ktnzva+Lujnb872gW4IyzAA/4eKjZ7RHaKNe/BmrgpsXxUF7z0/7XBR4ev4KuTxs3dxPBW8PdQwVUpr345IcDTGXIZ6x6RpZjd1F27dg3Dhg1DRkYGNBoNHn/8cXh4eGDVqlXQaDTYtGmTdSJ1UJGdA7F/3v+H1T9cxP4L2cgvrcSJ0nycSM83Ws7D2QktmriieRMXNG/iioHtfDConR8U/MqWyKZY88wT7O2CFaO7YtbgtkbNXfLV/FrL+rqrMKxLAKI6B+LR1j6sd0QPqUE3H+7duzfOnDkDH5//HVKPjo423BWdjLX0ccXGiT1RXqmD+lYJruTceV3KLsaVnBKk55WiuKIKFzKLcCHzzr1oPklKg6+7Ek/3bI6xvZqjXYCHrdMg+lNizWuYu5u7zT9dxdnrt3G7XIvySh3KtTqUaqqQW6LBF8kZ+CI5Ax4qJ3QK9kSHQA90aeaF7i280cbPHTIeySMymdlN3ZEjR/Dzzz/XepB1SEgIbty4YcnYJMdFKUeXZl7o0szLaLxCq0NGfhmuF5ThekE5LmUXY++5LOSWVGLzT1ex+aer8HVXwdddCblMgJNcBqVcgNJJBrlMBieZAJkgQOkkQCmXwcddhfYBHmgX4I62/u7wcJbWPX2IGhNr3sMJ9nbB0qc61xqvrNLjZ3UufvgtCwcuZCO3pBLH0/JxPO1/R/RclXJ0DPJE8yYuEABoqvTVLx2qdCJ83VXw91QhwNMZAZ4qBHg4w89DBQ9nBdxUcrgpndgU0p+K2U2dXq+HTqerNX79+nV4ePBoUkM4K+QIC/BA2F1H45aM7IxDF3Ow49R1HLqYg9wSDXJLNPfdTn183VVwUcogEwRU6UToRRFVehE6vYgqnR56EajS6yFAgItSDmcnGaCV48vMk/ByVcLTWQEXpQyiCOhFQBTF6r+Lhumav+tFETJBgMpJBqWTDConOZROMsgEQMSd+aII6PWi8XT1nyJEyAUBgiBALrvzkgkC7q7L994tzJTbh+n1OqivyfDb/kuQyeT3XVastQf7pNfpcfWaDOd/uASZCV9bCbDv/9xq3iOPK7l4rKP9PKGANc86lE4yDG7vj8Ht/bFitIjfM4uQmlWM3zOLcPZ6Ic7dKERZpQ6nrhXg1LWCBu/HVSmHm8oJSrkMFdo7RwkrtDo4yWRQOcmgUsiglMtQpZEj7urPUCmd7oxX1y+VQgaVXAa9KEKrE1Gp00Onv1PnnGQCnOQCFHIZ5DIBCrkAJ9ldf5fLINxVs2pqlaHGGP9hqK01YzU18e4aJwh3fpdlQvXfBaH2GATo9DqoM2S4+ONlyKtrXn21rb4aamoltMAtHB/InBruKGpy8k3Px4B2lrlS3eymLjIyEuvWrTO6r1JJSQmWLFlikcfo0B0KuQyRnQMR2TkQJZoqXL1VgsJybXUjJkKr06NSp0eVrro5098Z01TpkFlYYfhqN7vIvGawXFvzn5eAm+kNL6T2SYaEm7WvGnRsUstJhrD0Artq6ljzrE8uE2p9i1Gl0yM9rxS/3SzCreI7NezuRksQBOSVaJBdpEFOUQWyiyuQXaTBrWINSjRV0OnvdBpllTqUVdZuyiura2ixoTwKyKkoaZyEG40MuJFm6yAsSGr1DgBk6H29yHZN3Zo1axAVFYVOnTqhoqICEydOxOXLl+Hr64tt27ZZJCgy5q5ywiPNvRu0bmG5Fn/kl6FSp4coioava+UywfBnzUsU7zR1haUVOHjkGNp37YFSrR5F5VUo1+ogE2A4albz6bBmWlZ9dE2oPvpWqdNDo71TNCur9IYjeDXL4t51q/+zRPWnVZ0oQqevPhqovzN995Gmey8UftAxKL1ej6tpaWgdGgqZzISjWnZ6UOvuT8Tm5tTgfVpty8b0ej3S0tLQs2XDftathTXPNpzkMrT190Bbf/OPhoqiCE2VHiWaKpRqqlCiqYJWJ8JFIYezQgZnhRw6vWj4Kre0vBKJR5PQo3c4dKJgGNdU6aHR3vnzztE3GZzkd2qnXrzTeGqrP1hr9Xc+ZFdVfwNS80G7Rk39qqktNSXGMF39F+GumQJqjsLdWe7Okbv/HcGD0bccMHzrgerfp/T0dISEhNRbH0ypc6Ye4bd2zaypD6FWrneNqSanLsH1P2/ZXGY3dc2bN8eZM2ewfft2nD17FiUlJZg+fTomTZoEFxcXiwVGluHlooDXPefwPYhW64yb3iKGdw2UzDP2tFotvv9ejeFPtGdOdqomn8FhfrYOxQhrnuMRBAHOCjmcFXL4utd+xu29tFotrnsCA9v6SOJ3CYbfp6sYPryDJHKSWr3DXTk92rqpxbbZoPvUOTk5YfLkyRYLgojInrHmEZEjMLup++yzz+47f8qUKQ8TDxGRXWHNIyJH0aD71N1Nq9WirKwMSqUSrq6uLHBEJCmseUTkKMw+27CgoMDoVVJSgtTUVAwcOJAnDROR5LDmEZGjsMglJO3atcN7771X6xMtEZEUseYRkT2y2HXBTk5OuHnzpqU2R0Rk11jziMjemH1O3Z49e4ymRVFEZmYmNm7ciAEDBlgyNiIim2PNIyJHYXZTN3r0aKNpQRDg5+eHxx57DGvWrLFkbERENseaR0SOokHPfiUi+rNgzSMiRyGNZ20QERER/cmZfaQuJibG5GXXrl1r7uaJiOwKax4ROQqzm7rTp0/j9OnT0Gq1aN++PQDg0qVLkMvl6Nmzp2E5wV6fiE5EZAbWPCJyFGY3dSNHjoSHhwc+/fRTNGnSBKi+Oedzzz2HQYMGYcGCBdaIk4jIJljziMhRmH1O3Zo1axAbG2sobgDQpEkTrFixgleCEZHksOYRkaMwu6krKirCrVu3ao3funULxcXFloqLiMgusOYRkaMwu6mLjo7Gc889h127duH69eu4fv06du7cienTp+Ppp5+2TpRERDbCmkdEjsLsc+o2bdqEhQsXYuLEidBqtXc24uSE6dOn4/3337dGjERENsOaR0SOwuymztXVFR999BHef/99qNVqAECbNm3g5uZmjfiIiGyKNY+IHEWDbz6cmZmJzMxMtGvXDm5ubhBF0bKRERHZEdY8IrJ3Zjd1eXl5GDp0KMLCwjB8+HBkZmYCAKZPn272pf1Lly6FIAhGrw4dOhjmq9VqREdHw8/PD56enhg3bhyys7Pvu83i4mLMmzcPrVq1gouLC/r374+TJ0+amyYREcCaR0QOxOymbv78+VAoFMjIyICrq6thfPz48di3b5/ZAXTu3NnwCTgzMxNHjx4FAJSWliIyMhKCIODgwYNISkpCZWUlRo4ced9nMf7tb3/DgQMH8Pnnn+PcuXOIjIxEREQEbty4YXZsRESseUTkKMw+p27//v344Ycf0Lx5c6Pxdu3a4dq1a+YH4OSEwMDAWuNJSUlIT0/H6dOn4enpCQCGm38ePHgQERERtdYpLy/Hzp078Z///Ad/+ctfgOpPxv/9738RFxeHFStWmB0fEf25seYRkaMw+0hdaWmp0afVGvn5+VCpVGYHcPnyZQQHB6N169aYNGkSMjIyAAAajQaCIBht09nZGTKZzPDJ9l5VVVXQ6XRwdnY2Gndxcal3HSKi+2HNIyJHYfaRukGDBuGzzz7DO++8A1Q/71Cv12P16tUYMmSIWdsKDw/Hli1b0L59e2RmZmLZsmUYNGgQzp8/j0cffRRubm547bXXsHLlSoiiiNdffx06nc5wTsu9PDw80K9fP7zzzjvo2LEjAgICsG3bNhw7dgxt27atNw6NRgONRmOYLioqAgBotVrDLQzqUzP/Qcs5EubkGKSWkzn5NGbOrHnGpPZzB+bkEKSWD6xU8wTRzEu4zp8/j6FDh6Jnz544ePAgnnrqKfz222/Iz89HUlIS2rRpY87mjNy+fRutWrXC2rVrMX36dOzfvx8zZ85EWloaZDIZJkyYgAsXLqBv376Ii4urcxtqtRrPP/88fvrpJ8MDt8PCwnDq1Cn8/vvvda6zdOlSLFu2rNb41q1b6/yETkS2VVZWhokTJ6KwsNDwVaW1sOYRka2ZWvPMbuoAoLCwEBs3bsSZM2dQUlKCnj17Yvbs2QgKCnrYuNGnTx9EREQgNjbWMJabmwsnJyd4e3sjMDAQCxYswCuvvHLf7ZSWlqKoqAhBQUEYP348SkpK8N1339W5bF2fWlu0aIHc3NwH/oeh1Wpx4MABPP7441AoFGbna4+Yk2OQWk7m5FNUVARfX99GaerAmmdEaj93YE4OQWr5wEo1z6yvX7VaLYYNG4ZNmzbhzTffNGdVk5SUlECtVuOvf/2r0bivry8A4ODBg8jJycFTTz31wG25ubnBzc0NBQUF+OGHH7B69ep6l1WpVHWeG6NQKEz+4TFnWUfBnByD1HIyJZ/Gypc1r35S+7kDc3IIUssHFq55Zl0ooVAocPbsWXNWua+FCxciMTER6enp+PnnnxEdHQ25XI4JEyYAAOLj45GcnAy1Wo0vvvgCY8eOxfz589G+fXvDNoYOHYqNGzcapn/44Qfs27cPaWlpOHDgAIYMGYIOHTrgueees1jcRPTnwJpHRI7E7AslJk+ejI8//hjvvffeQ+/8+vXrmDBhAvLy8uDn54eBAwciOTkZfn5+AIDU1FQsWrQI+fn5CAkJwZtvvon58+cbbUOtViM3N9cwXVhYiEWLFuH69eto2rQpxowZg3fffVdynT0RNQ7WPCJyFGY3dVVVVfjkk0/w448/olevXrWef7h27VqTt7V9+/b7zn/vvfceWEjT09ONpseNG4dx48aZHAMR0f2w5hGRozC7qTt//jx69uwJALh06ZLRPEEQLBcZEZEdYM0jIkdhclN39epVhIaG4tChQ9aNiIjIDrDmEZGjMflCiXbt2uHWrVuG6fHjxz/wQdNERI6KNY+IHI3JTd29t7P7/vvvUVpaao2YiIhsjjWPiByN2c9+JSIiIiL7Y3JTJwhCrZOCeZIwEUkVax4RORqTL5QQRRHTpk0z3IW8oqICL730Uq3L+3ft2mX5KImIGhlrHhE5GpObuqlTpxpNT5482RrxEBHZBdY8InI0Jjd18fHx1o2EiMiOsOYRkaPhhRJEREREEsCmjoiIiEgC2NQRERERSQCbOiIiIiIJYFNHREREJAFs6oiIiIgkgE0dERERkQSwqSMiIiKSADZ1RERERBLApo6IiIhIAtjUEREREUkAmzoiIiIiCWBTR0RERCQBbOqIiIiIJIBNHREREZEEsKkjIiIikgA2dUREREQSwKaOiIiISALY1BERERFJgE2buqVLl0IQBKNXhw4dDPPVajWio6Ph5+cHT09PjBs3DtnZ2ffdpk6nw9tvv43Q0FC4uLigTZs2eOeddyCKYiNkRERUP9Y8IrImmx+p69y5MzIzMw2vo0ePAgBKS0sRGRkJQRBw8OBBJCUlobKyEiNHjoRer693e6tWrUJcXBw2btyI33//HatWrcLq1avxwQcfNGJWRER1Y80jImtxsnkATk4IDAysNZ6UlIT09HScPn0anp6eAIBPP/0UTZo0wcGDBxEREVHn9n7++WeMGjUKTz75JAAgJCQE27Ztw4kTJ6ycCRHRg7HmEZG12Lypu3z5MoKDg+Hs7Ix+/fohNjYWLVu2hEajgSAIUKlUhmWdnZ0hk8lw9OjRegtc//79sXnzZly6dAlhYWE4c+YMjh49irVr19Ybg0ajgUajMUwXFhYCAPLz86HVau8bv1arRVlZGfLy8qBQKBrwL2B/mJNjkFpO5uRTXFwMAA75FSNrnv1hTvZPavnAWjVPtKHvv/9e/Prrr8UzZ86I+/btE/v16ye2bNlSLCoqEnNyckRPT0/x5ZdfFktLS8WSkhJxzpw5IgBxxowZ9W5Tp9OJr732migIgujk5CQKgiCuXLnyvnEsWbJEBMAXX3w52OuPP/6wQmWyHtY8vvji62FeD6p5gmhHH3Vv376NVq1aYe3atZg+fTr279+PmTNnIi0tDTKZDBMmTMCFCxfQt29fxMXF1bmN7du345VXXsH777+Pzp0749dff8W8efOwdu1aTJ06tc517v3UqtfrkZ+fDx8fHwiCcN+Yi4qK0KJFC/zxxx+Gr0wcHXNyDFLLyZx8RFFEcXExgoODIZPZ/NTgBmPNsw/Myf5JLR9YqebZ/OvXu3l7eyMsLAxXrlwBAERGRkKtViM3NxdOTk7w9vZGYGAgWrduXe82XnnlFbz++ut49tlnAQBdu3bFtWvXEBsbW2+BU6lURl951MRiDk9PT8n8oNVgTo5BajmZmo+Xl1ejxGNNrHn2hTnZP6nlAwvXPLv6iFtSUgK1Wo2goCCjcV9fX3h7e+PgwYPIycnBU089Ve82ysrKanWxcrn8vlePERHZAmseEVmSTZu6hQsXIjExEenp6fj5558RHR0NuVyOCRMmAADi4+ORnJwMtVqNL774AmPHjsX8+fPRvn17wzaGDh2KjRs3GqZHjhyJd999F9999x3S09Oxe/durF27FtHR0TbJkYioBmseEVmTTb9+vX79OiZMmIC8vDz4+flh4MCBSE5Ohp+fHwAgNTUVixYtQn5+PkJCQvDmm29i/vz5Rtuo+aqixgcffIC3334bs2bNQk5ODoKDg/Hiiy9i8eLFVslBpVJhyZIltb7KcGTMyTFILSep5VMX1jz7xJzsn9TygZVysqsLJYiIiIioYezqnDoiIiIiahg2dUREREQSwKaOiIiISALY1BERERFJAJu6h/Dhhx8iJCQEzs7OCA8Pd+gHaC9duhSCIBi9OnToYOuwzPLTTz9h5MiRCA4OhiAI+Oabb4zmi6KIxYsXIygoCC4uLoiIiMDly5dtFq8pHpTTtGnTar1vw4YNs1m8poiNjUWfPn3g4eEBf39/jB49GqmpqUbLVFRUYPbs2fDx8YG7uzvGjBmD7Oxsm8VMd7Dm2RfWPNa8e7Gpa6CvvvoKMTExWLJkCX755Rd069YNUVFRyMnJsXVoDda5c2dkZmYaXkePHrV1SGYpLS1Ft27d8OGHH9Y5f/Xq1diwYQM2bdqE48ePw83NDVFRUaioqGj0WE31oJwAYNiwYUbv27Zt2xo1RnMlJiZi9uzZSE5OxoEDB6DVahEZGYnS0lLDMvPnz8d///tf7NixA4mJibh58yaefvppm8b9Z8eaZ39Y81jzamngc6n/9Pr27SvOnj3bMK3T6cTg4GAxNjbWpnE11JIlS8Ru3brZOgyLASDu3r3bMK3X68XAwEDx/fffN4zdvn1bVKlU4rZt22wUpXnuzUkURXHq1KniqFGjbBaTJeTk5IgAxMTERFGsfl8UCoW4Y8cOwzK///67CEA8duyYDSP9c2PNs2+seY7DmjWPR+oaoLKyEqdOnUJERIRhTCaTISIiAseOHbNpbA/j8uXLCA4ORuvWrTFp0iRkZGTYOiSLSUtLQ1ZWltF75uXlhfDwcId+zwDg8OHD8Pf3R/v27TFz5kzk5eXZOiSzFBYWAgCaNm0KADh16hS0Wq3Re9WhQwe0bNnS4d8rR8Wa53hY8+yXNWsem7oGyM3NhU6nQ0BAgNF4QEAAsrKybBbXwwgPD8eWLVuwb98+xMXFIS0tDYMGDUJxcbGtQ7OImvdFSu8Zqr+G+Oyzz5CQkIBVq1YhMTERTzzxBHQ6na1DM4ler8e8efMwYMAAdOnSBah+r5RKZa0HzDv6e+XIWPMcD2uefbJ2zbPpY8LIfjzxxBOGvz/yyCMIDw9Hq1at8PXXX2P69Ok2jY3q9+yzzxr+3rVrVzzyyCNo06YNDh8+jKFDh9o0NlPMnj0b58+fd7hzmcjxseY5Jta8++ORugbw9fWFXC6vdWVKdnY2AgMDbRaXJXl7eyMsLAxXrlyxdSgWUfO+SPk9A4DWrVvD19fXId63OXPm4Ntvv8WhQ4fQvHlzw3hgYCAqKytx+/Zto+Wl9l45EtY8x8OaZ38ao+axqWsApVKJXr16ISEhwTCm1+uRkJCAfv362TQ2SykpKYFarUZQUJCtQ7GI0NBQBAYGGr1nRUVFOH78uGTeM1Q/MD4vL8+u3zdRFDFnzhzs3r0bBw8eRGhoqNH8Xr16QaFQGL1XqampyMjIkNR75UhY8xwPa579aNSaZ/HLOv4ktm/fLqpUKnHLli3ihQsXxBkzZoje3t5iVlaWrUNrkAULFoiHDx8W09LSxKSkJDEiIkL09fUVc3JybB2ayYqLi8XTp0+Lp0+fFgGIa9euFU+fPi1eu3ZNFEVRfO+990Rvb2/xP//5j3j27Flx1KhRYmhoqFheXm7r0Ot1v5yKi4vFhQsXiseOHRPT0tLEH3/8UezZs6fYrl07saKiwtah12vmzJmil5eXePjwYTEzM9PwKisrMyzz0ksviS1bthQPHjwopqSkiP369RP79etn07j/7Fjz7A9rHmvevdjUPYQPPvhAbNmypahUKsW+ffuKycnJtg6pwcaPHy8GBQWJSqVSbNasmTh+/HjxypUrtg7LLIcOHRIB1HpNnTpVFKsv8X/77bfFgIAAUaVSiUOHDhVTU1NtHfZ93S+nsrIyMTIyUvTz8xMVCoXYqlUr8YUXXrD7/2TrygeAGB8fb1imvLxcnDVrltikSRPR1dVVjI6OFjMzM20aN7Hm2RvWPNa8ewnVOyQiIiIiB8Zz6oiIiIgkgE0dERERkQSwqSMiIiKSADZ1RERERBLApo6IiIhIAtjUEREREUkAmzoiIiIiCWBTR0RERCQBbOrILh0+fBiCINR6wHFjSUhIQMeOHaHT6R647L59+9C9e3fo9fpGiY2IpIc1jyyBTR3Z3ODBgzFv3jyjsf79+yMzMxNeXl42ienVV1/FW2+9Bblc/sBlhw0bBoVCgS+//LJRYiMix8aaR9bCpo7sklKpRGBgIARBaPR9Hz16FGq1GmPGjDF5nWnTpmHDhg1WjYuIpIs1jyyBTR3Z1LRp05CYmIj169dDEAQIgoD09PRaX0Vs2bIF3t7e+Pbbb9G+fXu4urrimWeeQVlZGT799FOEhISgSZMmmDt3rtHXBxqNBgsXLkSzZs3g5uaG8PBwHD58+L4xbd++HY8//jicnZ0NY2fOnMGQIUPg4eEBT09P9OrVCykpKYb5I0eOREpKCtRqtVX+nYhIGljzyJqcbB0A/bmtX78ely5dQpcuXbB8+XIAgJ+fH9LT02stW1ZWhg0bNmD79u0oLi7G008/jejoaHh7e+P777/H1atXMWbMGAwYMADjx48HAMyZMwcXLlzA9u3bERwcjN27d2PYsGE4d+4c2rVrV2dMR44cwcSJE43GJk2ahB49eiAuLg5yuRy//vorFAqFYX7Lli0REBCAI0eOoE2bNhb+VyIiqWDNI2tiU0c25eXlBaVSCVdXVwQGBt53Wa1Wi7i4OEMBeeaZZ/D5558jOzsb7u7u6NSpE4YMGYJDhw5h/PjxyMjIQHx8PDIyMhAcHAwAWLhwIfbt24f4+HisXLmyzv1cu3bNsHyNjIwMvPLKK+jQoQMA1Fkcg4ODce3atQb/WxCR9LHmkTWxqSOH4erqavSJMCAgACEhIXB3dzcay8nJAQCcO3cOOp0OYWFhRtvRaDTw8fGpdz/l5eVGX0MAQExMDP72t7/h888/R0REBMaOHVvr06mLiwvKysoeOk8iIrDmUQOwqSOHcfehfwAQBKHOsZrL7EtKSiCXy3Hq1KlaV3TdXRTv5evri4KCAqOxpUuXYuLEifjuu++wd+9eLFmyBNu3b0d0dLRhmfz8fPj5+T1UjkRENVjzyFxs6sjmlEqlSfdGMlePHj2g0+mQk5ODQYMGmbXehQsXao2HhYUhLCwM8+fPx4QJExAfH28ocBUVFVCr1ejRo4dFcyAi6WHNI2vh1a9kcyEhITh+/DjS09ORm5trsRtahoWFYdKkSZgyZQp27dqFtLQ0nDhxArGxsfjuu+/qXS8qKgpHjx41TJeXl2POnDk4fPgwrl27hqSkJJw8eRIdO3Y0LJOcnAyVSoV+/fpZJHYiki7WPLIWNnVkcwsXLoRcLkenTp3g5+eHjIwMi207Pj4eU6ZMwYIFC9C+fXuMHj0aJ0+eRMuWLetdZ9KkSfjtt9+QmpoKAJDL5cjLy8OUKVMQFhaGcePG4YknnsCyZcsM62zbtg2TJk2Cq6urxWInImlizSNrEURRFG0dBJG9eeWVV1BUVIR//OMfD1w2NzcX7du3R0pKCkJDQxslPiIiS2LNkwYeqSOqw5tvvolWrVqZ9LVIeno6PvroIxY3InJYrHnSwCN1RERERBLAI3VEREREEsCmjoiIiEgC2NQRERERSQCbOiIiIiIJYFNHREREJAFs6oiIiIgkgE0dERERkQSwqSMiIiKSADZ1RERERBLApo6IiIhIAtjUEREREUkAmzoiIiIiCWBTR0RERCQBbOqIiIiIJIBNHREREZEEsKkjIiIikgA2deRwsrOz4e3tjZdeeqnO+Xl5eRAEAQsXLmz02IiILI01j0zFpo4czttvv43KykosX768zvk+Pj4ICgrCyZMnGz02IiJLY80jU7GpI4fyxx9/YMuWLXjuuefg7+9f73LNmjVDWlpao8ZGRGRprHlkDjZ15FA++eQTaLVaPP/884axyspKlJeXGy2nUChqjRERORrWPDIHmzpyKN999x38/PzQq1cvw9jEiRMxevRoo+Xy8vLg4+Nj9vZnzJiBoKAgeHp6omvXrvjvf/9rkbiJiBrC2jWvxrFjxyCTybBixYqHipdsi00dOQxRFHHu3Dl06tTJaDw5ORlt27Y1TBcWFkKtVqNbt251bken09W7j5iYGKSnp6OoqAiffPIJJk+ejLy8PAtmQURkmsaoeQCg1+sxf/589OnTx0KRk62wqSOHUVxcjIqKCgQGBhrGTp8+jRs3bsDb29swlpCQAJ1Oh8jISADA+vXrER0djbFjx8Ld3R379++vdx8dOnSASqUCAAiCgMrKSty4ccOqeRER1aUxah4AbN68GeHh4ejYsaMVs6HGwKaOHEZNs3Xz5k3D2Lp16+Dv74/c3Fyg+hPp//3f/8HT0xPPPPMMAODs2bNISkrC3//+dxQVFSEiIuK++5k1axZcXFzQp08fPPbYY+jatatV8yIiqktj1Ly8vDysW7cOy5Yts3o+ZH1Otg6AyFQqlQp9+vTBkSNH8MYbb6CiogLff/89YmJisHr1anTp0gX79u3DsWPHsGnTJnh5eQHVBW7JkiX4y1/+AgCQye7/Weajjz7CBx98gMOHD+P8+fMQBKFR8iMiultj1Lw333wT8+bNMzryRw5MJHIgZ8+eFXv27CmqVCqxZ8+eYnJysnj79m1x6NChorOzsxgWFiZ+/PHHhuV1Op3o6uoq3rhxo0H7GzFihPjdd99ZMAMiItNZs+b98ssvYs+ePcWqqipRFEVx6tSp4jvvvGPVfMi6eKSOHErXrl1x6tSpWuM//vhjnctfuXIFHh4eCA4ObtD+qqqqcOXKlQatS0T0sKxZ8xITE5GamopmzZoB1RdcODk5Qa1WIz4+3gLRU2PjOXUkaWfPnq3zirBp06Zh2rRpRmOFhYXYunUrSkpKUFVVhR07duDQoUOGrzCIiOydOTVvxowZuHLlCn799Vf8+uuveOqppzB79mz8v//3/xoxYrIkHqkjSTt37hweeeSRWuPXr1/H+PHjjcYEQcA///lPzJo1C6Ioom3btti6dSu6d+/eiBETETWcOTXP1dUVrq6uhmkXFxe4u7vz/DoHJoiiKNo6CKLGVFVVhUceeQRnzpyBQqGwdThERFbFmvfnYfOvX2/cuIHJkyfDx8cHLi4u6Nq1K1JSUgzzRVHE4sWLERQUBBcXF0RERODy5cv33WZsbCz69OkDDw8P+Pv7Y/To0UhNTW2EbMgRODk54cKFCyxuZBOsedTYWPP+PGza1BUUFGDAgAFQKBTYu3cvLly4gDVr1qBJkyaGZVavXo0NGzZg06ZNOH78ONzc3BAVFYWKiop6t5uYmIjZs2cjOTkZBw4cgFarRWRkJEpLSxspMyKi2ljziMiabPr16+uvv46kpCQcOXKkzvmiKCI4OBgLFizAwoULgeqT2QMCArBlyxY8++yzJu3n1q1b8Pf3R2JiIk96JyKbYc0jImuy6ZG6PXv2oHfv3hg7diz8/f3Ro0cP/POf/zTMT0tLQ1ZWltHdsL28vBAeHo5jx46ZvJ/CwkIAQNOmTS2cARGR6VjziMiabHr169WrVxEXF4eYmBi88cYbOHnyJObOnQulUompU6ciKysLABAQEGC0XkBAgGHeg+j1esybNw8DBgxAly5d6lxGo9FAo9EYrZOfnw8fHx8+TYDIDomiiOLiYgQHBz/wCSH2hDWPiBrC5JpnyzsfKxQKsV+/fkZjf//738VHH31UFEVRTEpKEgGIN2/eNFpm7Nix4rhx40zax0svvSS2atVK/OOPP+pdZsmSJSIAvvjiy8Fe9/u9tkeseXzxxdfDvB5U82x6pC4oKAidOnUyGuvYsSN27twJAAgMDAQAZGdnIygoyLBMdna2SfcOmzNnDr799lv89NNPaN68eb3LLVq0CDExMYbpwsJCtGzZEmlpafDw8LjvPrRaLQ4dOoQhQ4ZI5soi5uQYpJaTOfkUFxcjNDT0gb+f9oY1zz4xJ/sntXxgpZpn06ZuwIABtS67v3TpElq1agUACA0NRWBgIBISEgwFraioCMePH8fMmTPr3a4oivj73/+O3bt34/DhwwgNDb1vHCqVCiqVqtZ406ZN4enped91tVotXF1d4ePjI6kfNOZk/6SWkzn51Mx3tK8KWfPsE3Oyf1LLB1aqeTY9GWX+/PlITk7GypUrceXKFWzduhWbN2/G7Nmzgerg582bhxUrVmDPnj04d+4cpkyZguDgYIwePdqwnaFDh2Ljxo2G6dmzZ+OLL77A1q1b4eHhgaysLGRlZaG8vNwmeRIRgTWPiKzMpkfq+vTpg927d2PRokVYvnw5QkNDsW7dOkyaNMmwzKuvvorS0lLMmDEDt2/fxsCBA7Fv3z44OzsbllGr1cjNzTVMx8XFAQAGDx5stL/4+Phaz74jImosrHlEZE02f/briBEjMGLEiHrnC4KA5cuXY/ny5fUuk56ebjTNJ58Rkb1izSMia3GcewEQERERUb3Y1BERERFJAJs6IiIiIglgU0dEREQkAWzqiIiIiCSATR0RERGRBLCpIyIiIpIANnVEREREEsCmjoiIiEgC2NQRERERSQCbOiIiIiIJYFNHREREJAFs6oiIiIgkgE0dERERkQSwqSMiIiKSADZ1RERERBLApo6IiIhIAtjUEREREUkAmzoiIiIiCWBTR0RERCQBTuaukJaWhiNHjuDatWsoKyuDn58fevTogX79+sHZ2dk6URIR2QhrHhE5CpObui+//BLr169HSkoKAgICEBwcDBcXF+Tn50OtVsPZ2RmTJk3Ca6+9hlatWlk3aiIiK2PNIyJHY1JT16NHDyiVSkybNg07d+5EixYtjOZrNBocO3YM27dvR+/evfHRRx9h7Nix1oqZiMiqWPOIyBGZ1NS99957iIqKqne+SqXC4MGDMXjwYLz77rtIT0+3ZIxERI2KNY+IHJFJTd39itu9fHx84OPj8zAxERHZFGseETkis69+feyxx7Bs2bJa4wUFBXjssccsFRcRkV1gzSMiR2H21a+HDx/GuXPncPr0aXz55Zdwc3MDAFRWViIxMdEaMRIR2QxrHhE5igbdp+7HH39EVlYWHn30UZ5LQkSSx5pHRI6gQU1dUFAQEhMT0bVrV/Tp0weHDx9ucAA3btzA5MmT4ePjAxcXF3Tt2hUpKSmG+aIoYvHixQgKCoKLiwsiIiJw+fLl+27zp59+wsiRIxEcHAxBEPDNN980OD4iIkvVPNY7IrIms5s6QRCA6qu/tm7dipdffhnDhg3DRx99ZPbOCwoKMGDAACgUCuzduxcXLlzAmjVr0KRJE8Myq1evxoYNG7Bp0yYcP34cbm5uiIqKQkVFRb3bLS0tRbdu3fDhhx+aHRMR0d0sVfNY74jI2sw+p04URaPpt956Cx07dsTUqVPN3vmqVavQokULxMfHG8ZCQ0ON9rVu3Tq89dZbGDVqFADgs88+Q0BAAL755hs8++yzdW73iSeewBNPPGF2PERE97JUzWO9IyJra9Bjwnx9fY3GxowZg/bt2+PUqVNmbWvPnj2IiorC2LFjkZiYiGbNmmHWrFl44YUXDPvKyspCRESEYR0vLy+Eh4fj2LFj9RY5c2k0Gmg0GsN0UVERAECr1UKr1d533Zr5D1rOkTAnxyC1nMzJpzFztlTNs5d6B9a8WpiT/ZNaPrBSzTO7qavvcThdunRBly5dzNrW1atXERcXh5iYGLzxxhs4efIk5s6dC6VSialTpyIrKwsAEBAQYLReQECAYZ4lxMbG1nnLgv3798PV1dWkbRw4cMBi8dgL5uQYpJaTKfmUlZU1SiywYM2zl3oH1rx6MSf7J7V8YOGaZ3JT9/TTT5u03K5du0zdJPR6PXr37o2VK1cC1Y/mOX/+PDZt2tSgr3MbatGiRYiJiTFMFxUVoUWLFoiMjISnp+d919VqtThw4AAef/xxKBSKRojW+piTY5BaTubkU3NkyZosXfPspd6BNa8W5mT/pJYPrFTzTG7qvLy8jKa3bt2KkSNHwsPDw9RN1BIUFIROnToZjXXs2BE7d+4EAAQGBgIAsrOzERQUZFgmOzsb3bt3b/B+76VSqaBSqWqNKxQKk394zFnWUTAnxyC1nEzJpzHytXTNs5d6B9a8ejEn+ye1fGDhmmdyU3f3yb0A8O9//xurV69G69atTd1ELQMGDEBqaqrR2KVLlwxfd4SGhiIwMBAJCQmGolZUVITjx49j5syZDd4vEdGDWLrmsd4RkbU16D51ljJ//nwkJydj5cqVuHLlCrZu3YrNmzdj9uzZQPWtBObNm4cVK1Zgz549OHfuHKZMmYLg4GCMHj3asJ2hQ4di48aNhumSkhL8+uuv+PXXX4HqE5B//fVXZGRk2CBLIiLWOyKyPrMvlLCkPn36YPfu3Vi0aBGWL1+O0NBQrFu3DpMmTTIs8+qrr6K0tBQzZszA7du3MXDgQOzbtw/Ozs6GZdRqNXJzcw3TKSkpGDJkiGG65tyRqVOnYsuWLY2WHxFRDdY7IrI2mzZ1ADBixAiMGDGi3vmCIGD58uVYvnx5vcvc+9iewYMH17q3FBGRrbHeEZE1mdzU7dmzx2har9cjISEB58+fNxp/6qmnLBcdEZGNsOYRkaMxuam7+5yOGi+++KLRtCAI0Ol0lomMiMiGWPOIyNGY3NTp9XrrRkJEZEdY84jI0dj06lciIiIisgyTmrrk5GSTN1hWVobffvvtYWIiIrIp1jwickQmNXV//etfERUVhR07dqC0tLTOZS5cuIA33ngDbdq0Mesh10RE9oY1j4gckUnn1F24cAFxcXF46623MHHiRISFhSE4OBjOzs4oKCjAxYsXUVJSgujoaOzfvx9du3a1fuRERFbCmkdEjsikpk6hUGDu3LmYO3cuUlJScPToUVy7dg3l5eXo1q0b5s+fjyFDhqBp06bWj5iIyMpY84jIEZl98+HevXujd+/e1omGiMjOsOYRkaPg1a9EREREEsCmjoiIiEgC2NQRERERSQCbOiIiIiIJMLupu3r1qnUiISKyQ6x5ROQozG7q2rZtiyFDhuCLL75ARUWFdaIiIrITrHlE5CjMbup++eUXPPLII4iJiUFgYCBefPFFnDhxwjrRERHZGGseETkKs5u67t27Y/369bh58yY++eQTZGZmYuDAgejSpQvWrl2LW7duWSdSIiIbYM0jIkfR4AslnJyc8PTTT2PHjh1YtWoVrly5goULF6JFixaYMmUKMjMzLRspEZENseYRkb1rcFOXkpKCWbNmISgoCGvXrsXChQuhVqtx4MAB3Lx5E6NGjbJspERENsSaR0T2zuzHhK1duxbx8fFITU3F8OHD8dlnn2H48OGQye70h6GhodiyZQtCQkKsES8RUaNizSMiR2F2UxcXF4fnn38e06ZNQ1BQUJ3L+Pv74+OPP7ZEfERENsWaR0SOwuym7vLlyw9cRqlUYurUqQ2NiYjIbrDmEZGjMPucuvj4eOzYsaPW+I4dO/Dpp59aKi4iIrvAmkdEjsLspi42Nha+vr61xv39/bFy5UpLxUVEZBdY84jIUZjd1GVkZCA0NLTWeKtWrZCRkWGpuIiI7AJrHhE5CrObOn9/f5w9e7bW+JkzZ+Dj42OpuIiI7AJrHhE5CrObugkTJmDu3Lk4dOgQdDoddDodDh48iJdffhnPPvusdaIkIrIR1jwichRmN3XvvPMOwsPDMXToULi4uMDFxQWRkZF47LHHGnR+yY0bNzB58mT4+PjAxcUFXbt2RUpKimG+KIpYvHgxgoKC4OLigoiICJOuRvvwww8REhICZ2dnhIeH81mNRNQgrHlE5CjMbuqUSiW++uorXLx4EV9++SV27doFtVqNTz75BEql0qxtFRQUYMCAAVAoFNi7dy8uXLiANWvWoEmTJoZlVq9ejQ0bNmDTpk04fvw43NzcEBUVhYqKinq3+9VXXyEmJgZLlizBL7/8gm7duiEqKgo5OTnmpktEf3KseUTkMEQbeu2118SBAwfWO1+v14uBgYHi+++/bxi7ffu2qFKpxG3bttW7Xt++fcXZs2cbpnU6nRgcHCzGxsaaFFdhYaEIQCwsLHzgspWVleI333wjVlZWmrRtR8CcHIPUcjInH3N+R+0Ja559Yk72T2r5iFaqeWYfqdPpdPj4448xceJERERE4LHHHjN6mWPPnj3o3bs3xo4dC39/f/To0QP//Oc/DfPT0tKQlZWFiIgIw5iXlxfCw8Nx7NixOrdZWVmJU6dOGa0jk8kQERFR7zoPo7JKb/FtEpH9YM27Z3+seUR2y+wnSrz88svYsmULnnzySXTp0gWCIDR451evXkVcXBxiYmLwxhtv4OTJk5g7d67h7uxZWVkAgICAAKP1AgICDPPulZubC51OV+c6Fy9erHMdjUYDjUZjmC4qKgIAaLVaaLXaeuPPKqrAjM9/QWcXAY/fZzlHU5Pz/XJ3NMzJ/pmTT2PmzJr3P2m5pZi97Vc86smaZ++klpPU8oGVap7ZTd327dvx9ddfY/jw4eauWoter0fv3r0NJxv36NED58+fx6ZNmxr1kTuxsbFYtmxZrfH9+/fD1dW13vUOZwr4PUuOi5Ch6dc/onMT0cqRNq4DBw7YOgSLY072z5R8ysrKGiUWsOYZ+eG6gMs5cmTkytBqzwH4uVg50EYmtd8lSDAnqeUDC9c8s5s6pVKJtm3bmrtanYKCgtCpUyejsY4dO2Lnzp0AgMDAQABAdna20YO0s7Oz0b179zq36evrC7lcjuzsbKPx7Oxsw/butWjRIsTExBimi4qK0KJFC0RGRsLT07Pe+J8QRYg7z+GbM1n45JITonsEo1VTVwR4qtCiiQva+bvDXeWEyzklSLlWgKwiDToFeWBoB38oncz+5rvRaLVaHDhwAI8//jgUCoWtw7EI5mT/zMmn5shSY2DN+58ovYhbn5zEyWu3sedWU2x/oS8UcvutZaaS2u8SJJiT1PKBlWqe2U3dggULsH79emzcuPGhvoYAgAEDBiA1NdVo7NKlS2jVqhUAIDQ0FIGBgUhISDAUtKKiIhw/fhwzZ86sc5tKpRK9evVCQkICRo8eDVR/Ok5ISMCcOXPqXEelUkGlUtUaVygUD/yHfnd0F6Rfv4lf82TYcepG7W3IBWh1xkfwAjxVmD4wFBP6toSHs/3+cJqSv6NhTvbPlHwaM1/WvLvmA1gz9hFE/b9EnL1RhE0/pSMmsr0Z/wL2TWq/S5BgTlLLBxaueWY3dUePHsWhQ4ewd+9edO7cudaOdu3aZfK25s+fj/79+2PlypUYN24cTpw4gc2bN2Pz5s0AAEEQMG/ePKxYsQLt2rVDaGgo3n77bQQHBxuKFwAMHToU0dHRhgIWExODqVOnonfv3ujbty/WrVuH0tJSPPfcc+am+0BKJxmmtdPDc0RvHE+7jVvFGmQVVSAttxSZhRXQ6kS4KOTo1aoJWjR1QcLvOcgu0mDl9xfxQcIVDArzRb/WPni0tQ/a+rsb/aeh04u4XlAGuUyAu8oJzgo5VE6yh/6PhYhMx5pnLMjLGeNb67HlshwbD13BoDA/9AlpapivqdJBU6WHpx1/YCWSKrObOm9vb0RHR1tk53369MHu3buxaNEiLF++HKGhoVi3bh0mTZpkWObVV19FaWkpZsyYgdu3b2PgwIHYt28fnJ2dDcuo1Wrk5uYapsePH49bt25h8eLFyMrKQvfu3bFv375aJxJbiiAAg9r64rGOQUbjRRVa5JdUonkTFzhVf0WhqdLhP6dv4h8/qaG+VYrvz2Xh+3N3ToD2dVciPNQHXq4KpGYV48LNIpRrdbX25aKQo3kTF/QNbYr+bXzRN7QpvF0UKNfqUKKpQnFFFYortNV/VqFEU4VSTRVUTjIEerkgwFOFAE9neLkooJDLIJfVbhJFESirrIKuUoRCLkAhl0Epl0FWx7JEUsaaV1sPXxGF7sHYffom5m3/FdteeBTX8kvxZXIGDvyeDZ1eRICnCgPa+mJIe3/8pZ0fvFzZ5BFZmyCKorTO7reAoqIieHl5obCw8L7nl6D6O/Hvv/8ew4cPN+uQsF4v4peMAhxT5yE5LQ8p6QXQ1HGrAKWTDBCBSp31biMgE2Bo2pzkd5q2ovJK6MTaDZxcJhiaPFelHG4qJ7go5BBFQKy+Gz6qm0IRotG4CAD3TIsioBfvLIe7xvWiCL1YPd2An9B7D2aKIqCp1EClVNWad9daD7WPBy5v3uIP3ocIVFRU3PnPXqjZh/l7aZw8HryWKIooLy/HC0PCMGtI2H2XNed3lB6sITXvL0MjMeqjZGTkP/gEbrlMQHSPZnh7RCd4udhfc9fQOm7PpJaT1PKBmTmZ+jtq9pE6AKiqqsLhw4ehVqsxceJEeHh44ObNm/D09IS7u3tDNvmnI5MJ6B3SFL1DmuLvaAdNlQ5n/ijE8at5KNPq0M7fHV2beaG1nzvkMgFanR4VWh3KtTqUaXS4mFWM5Kt5+Fmdi0vZJYbtOskEeDg7wd3ZCR4qxZ2/q5zgpnJCuVaH7KIKZBdVILekEjr9nW5JLwKaKv09TWXd/wnr9CJ0ehEVWj2KK6oAaOpczj4JKNFW2joICxNQqHWk9+BBhOqfK/vCmlebu8oJX0wPR8zXvyLlWgE8nJ0Q3aMZJoa3RDNvF5y7XojDl27h0MUcXM4pwb9PXcdvN4vwxfS+8HGvfT4fET08s5u6a9euYdiwYcjIyIBGo8Hjjz8ODw8PrFq1ChqNBps2bbJOpBKncpKjb2hT9A1tWud8hVwGhVx258IKDyDE1w3Duty5sq28UocKrQ4uStPPudPpRZRrddBW6aHV6VGp06NKJ0Kr00NTqUXKsSMYNTwSnq7O0Or01a878yur7ixfXqlDqaYK5VodBOHOMSJBuHO06M6fd3rDu6cF4e6/31lAJqDW+jKZ8Z/mqD4maKRKW4UjR45g0KBBcFLU/rE392ig2cvXEdPD7qOqqgpJSUcxYMBAODk16POZXeRRo6qqCkk/J2F0nxZm78OaWPPq19LHFf+e2R/FFVq4KOSG00wAoH9bX/Rv64s3hndESno+XvriF/yeWYQJ/0zG1hcehS8bOyKLa9DNh3v37o0zZ87Ax8fHMB4dHY0XXnjB0vGRCVyUcrgo5WatU3PxBeqoq1qtFmrVnU/icpkAuUwOZ4V527c3Wq0WajegfaCHpA7dX3MDOgd7SiInrVaL6+53TsS3J6x5D/agq/h7hzTFVy8+ion/TMal7BJM2JyMLc/3RTNv4xvdaXV6nEjLx0+Xb+HCzSKonGToE9IUw7sGoUXT+u+fR0R3mN3UHTlyBD///HOtB1mHhITgxo3at/QgInJkrHmW0cbPHdtn9MOEzcm4nFOCwe8fQhs/dyjkMpRoqlBUrkVhuRZVeuNDuz/+noPYvRfRu1UTjOoejOFdg/j1LVE9zG7q9Ho9dDpdrfHr16/Dw8PDUnEREdkF1jzLCfV1w9cv9sPCf5/BibR8XMwqrrWMj5sSQzr4o3erJiir1OHH37Nx7GoeUq4VIOVaAZb+9wL6t/FB/za+6NnSG05yGVKzivHrHwU4nXEbfxSUobJKD6eai7mUTmjqpkT3Ft7o1aoJerVqguZNXCAIAqp0d84Nzispxx8lQJI6DyWVehSUaVFYVglnhRxBXi4I9HKGj5sS3q4KeDgrjO4YoNeLuF2uRX5pJSqrT2cRASjlMiidBCjlciidZHBRyuGmNP6KWhRFaKpPZ9Fo/7duDSeZcOcll0EhF+Aku/NnQ25rVXPRmdGFazZwv9Mx7heVVquDVg9otDro4Pg3vAaAquqcqnR6WOrLFrObusjISKxbt87ovkolJSVYsmSJRR6jQ0RkT1jzLKuljyu+mvEo0vPKcC2vFKIIuDs7wdP5zoVdAZ7ORk3T8wNDkV1Ugf+euYk9Z27i7PVCHLmciyOXc++7n8qqO+f/3i7T4sbtcpy7UYjPk68B1TeFl8sEVGjvvjjMCTh36oHxCwLg7CSHQi5AJhNQVK6F3owOSel0504DNecmN4RcJkAuCIYmqKZZwz0Nmyg64eVj+xu0D/vkhIXHE2wdhIU54ZZ3BmYOaWehrZlpzZo1iIqKQqdOnVBRUYGJEyfi8uXL8PX1xbZt2ywSFBGRvWDNszxBEBDq64ZQXzeTlg/wdMbfBrXG3wa1hvpWCQ5dzMGJtHz8drMIoiiitZ87urXwQo8WTdA+0AMqJxm0ehHllVUo1ehwvaAcp64V4JeMAvx2s7D6oq//dWKuSjkUYhUCmnigSfUROS8XBcoqdcgqrEBmYQUKy7Uo0VRBFIFyrQ7l9zxf3cP5zg3ildVH4iqrLyrT6u7cWaDmbgM1zWZdlHKZ4RZD4l13G7iXTi9CZ7NjbWTPzG7qmjdvjjNnzmD79u04e/YsSkpKMH36dEyaNAkuLhJ7ujMR/emx5tmXNn7uaOPnjr8Nam3yOt1aeOPJR+7cHL5Cq0NBWSWqdCLcVU7wcHaCqNdV3y+s/30vOtLq7hz5q9DqUKm706h5uyjQxE1532fgiqL4vzsGVOpQWaWHykkGpZPM8Oedhq6uG8HfaUCr9HfuQFCl06OqutmruVsA7rrfZM0WqqqqkJCQgIiIoYacBAAywx0IBNNvOmnp/rGO/db3jXLNsFZbhQP79+PxyEgolY5/YRiqLw7bv38/nny0pcW22aD7IDg5OWHy5MkWC4KIyJ6x5klHzXlyd9Pqa58zWReFXAY/D/Mv0hAEASonOVROcnibeRGvIAh3zs0z8zwyrVYLTyXg666SxtXxcsDZ6c4RUUUdt6VyRFqZCGc5oHKy3DmCZv/LfPbZZ/edP2XKlIeJh4jIrrDmEZGjaNB96u6m1WpRVlYGpVIJV1dXFjgikhTWPCJyFGYf8ysoKDB6lZSUIDU1FQMHDuRJw0QkOax5ROQoLPJFbrt27fDee+/V+kRLRCRFrHlEZI8sdnaek5MTbt68aanNERHZNdY8IrI3Zp9Tt2fPHqNpURSRmZmJjRs3YsCAAZaMjYjI5ljziMhRmN3UjR492mhaEAT4+fnhsccew5o1aywZGxGRzbHmEZGjaNCzX4mI/ixY84jIUUjjqbhEREREf3JmH6mLiYkxedm1a9eau3kiIrvCmkdEjsLspu706dM4ffo0tFot2rdvDwC4dOkS5HI5evbsaViurmfYERE5GtY8InIUZjd1I0eOhIeHBz799FM0adIEqL4553PPPYdBgwZhwYIF1oiTiMgmWPOIyFGYfU7dmjVrEBsbayhuANCkSROsWLGCV4IRkeSw5hGRozC7qSsqKsKtW7dqjd+6dQvFxcWWiouIyC6w5hGRozC7qYuOjsZzzz2HXbt24fr167h+/Tp27tyJ6dOn4+mnn7ZOlERENsKaR0SOwuxz6jZt2oSFCxdi4sSJ0Gq1dzbi5ITp06fj/ffft0aMREQ2w5pHRI7C7KbO1dUVH330Ed5//32o1WoAQJs2beDm5maN+IiIbIo1j4gcRYNvPpyZmYnMzEy0a9cObm5uEEXRspEREdkR1jwisndmN3V5eXkYOnQowsLCMHz4cGRmZgIApk+fzkv7iUhyWPOIyFGY3dTNnz8fCoUCGRkZcHV1NYyPHz8e+/btM2tbS5cuhSAIRq8OHToY5qvVakRHR8PPzw+enp4YN24csrOz77vN4uJizJs3D61atYKLiwv69++PkydPmpsmERHAmkdEDsTspm7//v1YtWoVmjdvbjTerl07XLt2zewAOnfubPhaIzMzE0ePHgUAlJaWIjIyEoIg4ODBg0hKSkJlZSVGjhx53wds/+1vf8OBAwfw+eef49y5c4iMjERERARu3LhhdmxERKx5ROQozL5QorS01OjTao38/HyoVCrzA3ByQmBgYK3xpKQkpKen4/Tp0/D09AQAwx3dDx48iIiIiFrrlJeXY+fOnfjPf/6Dv/zlL0D1J+P//ve/iIuLw4oVK8yOj4j+3FjziMhRmN3UDRo0CJ999hneeecdoPp5h3q9HqtXr8aQIUPMDuDy5csIDg6Gs7Mz+vXrh9jYWLRs2RIajQaCIBgVTWdnZ8hkMhw9erTOAldVVQWdTgdnZ2ejcRcXF8On4bpoNBpoNBrDdFFREQBAq9UabmFQn5r5D1rOkTAnxyC1nMzJpzFzZs0zJrWfOzAnhyC1fGClmieIZl7Cdf78eQwdOhQ9e/bEwYMH8dRTT+G3335Dfn4+kpKS0KZNG5O3tXfvXpSUlKB9+/bIzMzEsmXLcOPGDZw/fx4VFRVo27YtnnvuOaxcuRKiKOL111/Hxo0bMWPGDPzjH/+oc5v9+/eHUqnE1q1bERAQgG3btmHq1Klo27YtUlNT61xn6dKlWLZsWa3xrVu31vkJnYhsq6ysDBMnTkRhYaHhqJa1sOYRka2ZWvPMbuoAoLCwEBs3bsSZM2dQUlKCnj17Yvbs2QgKCnqooG/fvo1WrVph7dq1mD59Ovbv34+ZM2ciLS0NMpkMEyZMwIULF9C3b1/ExcXVuQ21Wo3nn38eP/30E+RyOXr27ImwsDCcOnUKv//+e53r1PWptUWLFsjNzX3gfxharRYHDhzA448/DoVC8VD52wvm5BiklpM5+RQVFcHX17dRmjqw5hmR2s8dmJNDkFo+sFLNM+vrV61Wi2HDhmHTpk148803zVnVJN7e3ggLC8OVK1cAAJGRkVCr1cjNzYWTkxO8vb0RGBiI1q1b17uNNm3aIDExEaWlpSgqKkJQUBDGjx9/33VUKlWd58YoFAqTf3jMWdZRMCfHILWcTMmnsfJlzauf1H7uwJwcgtTygYVrnllXvyoUCpw9e9acVcxSUlICtVpd69Ovr68vvL29cfDgQeTk5OCpp5564Lbc3NwQFBSEgoIC/PDDDxg1apTV4iYiaWLNIyJHYvYtTSZPnoyPP/7YIjtfuHAhEhMTkZ6ejp9//hnR0dGQy+WYMGECACA+Ph7JyclQq9X44osvMHbsWMyfPx/t27c3bGPo0KHYuHGjYfqHH37Avn37kJaWhgMHDmDIkCHo0KEDnnvuOYvETER/Lqx5ROQozL76taqqCp988gl+/PFH9OrVq9bzD9euXWvytq5fv44JEyYgLy8Pfn5+GDhwIJKTk+Hn5wcASE1NxaJFi5Cfn4+QkBC8+eabmD9/vtE2ar6qqFFYWIhFixbh+vXraNq0KcaMGYN3331XcodriahxsOYRkaMwu6k7f/48evbsCQC4dOmS0TxBEMza1vbt2+87/7333sN7771332XS09ONpseNG4dx48aZFQcRUX1Y84jIUZjc1F29ehWhoaE4dOiQdSMiIrIDrHlE5GhMPqeuXbt2uHXrlmF6/PjxD3wmIRGRo2LNIyJHY3JTd+/t7L7//nuUlpZaIyYiIptjzSMiR2P21a9EREREZH9MbuoEQah1UrC5JwkTETkK1jwicjQmXyghiiKmTZtmuAt5RUUFXnrppVqX9+/atcvyURIRNTLWPCJyNCY3dVOnTjWanjx5sjXiISKyC6x5RORoTG7q4uPjrRsJEZEdYc0jIkfDCyWIiIiIJIBNHREREZEEsKkjIiIikgA2dUREREQSwKaOiIiISALY1BERERFJAJs6IiIiIglgU0dEREQkAWzqiIiIiCSATR0RERGRBLCpIyIiIpIANnVEREREEsCmjoiIiEgC2NQRERERSQCbOiIiIiIJYFNHREREJAFs6oiIiIgkgE0dERERkQSwqSMiIiKSAJs2dUuXLoUgCEavDh06GOar1WpER0fDz88Pnp6eGDduHLKzs++7TZ1Oh7fffhuhoaFwcXFBmzZt8M4770AUxUbIiIiofqx5RGRNNj9S17lzZ2RmZhpeR48eBQCUlpYiMjISgiDg4MGDSEpKQmVlJUaOHAm9Xl/v9latWoW4uDhs3LgRv//+O1atWoXVq1fjgw8+aMSsiIjqxppHRNbiZPMAnJwQGBhYazwpKQnp6ek4ffo0PD09AQCffvopmjRpgoMHDyIiIqLO7f38888YNWoUnnzySQBASEgItm3bhhMnTlg5EyKiB2PNIyJrsfmRusuXLyM4OBitW7fGpEmTkJGRAQDQaDQQBAEqlcqwrLOzM2QymeGTbV369++PhIQEXLp0CQBw5swZHD16FE888UQjZENEdH+seURkLTY9UhceHo4tW7agffv2yMzMxLJlyzBo0CCcP38ejz76KNzc3PDaa69h5cqVEEURr7/+OnQ6HTIzM+vd5uuvv46ioiJ06NABcrkcOp0O7777LiZNmlTvOhqNBhqNxjBdWFgIAMjPz4dWq71vDlqtFmVlZcjLy4NCoWjQv4O9YU6OQWo5mZNPcXExADjceWOsefaJOdk/qeUDa9U80Y4UFBSInp6e4r/+9S9RFEXxhx9+EFu3bi0KgiDK5XJx8uTJYs+ePcWXXnqp3m1s27ZNbN68ubht2zbx7Nmz4meffSY2bdpU3LJlS73rLFmyRATAF198Odjrjz/+sEotaiyseXzxxZc5rwfVPEG0s4+6ffr0QUREBGJjYw1jubm5cHJygre3NwIDA7FgwQK88sorda7fokULvP7665g9e7ZhbMWKFfjiiy9w8eLFOte591OrXq9Hfn4+fHx8IAjCfeMtKipCixYt8McffxjOg3F0zMkxSC0nc/IRRRHFxcUIDg6GTGbzs0geCmue7TEn+ye1fGClmmfzCyXuVlJSArVajb/+9a9G476+vgCAgwcPIicnB0899VS92ygrK6uVsFwuv+/VYyqVyug8FgDw9vY2K3ZPT0/J/KDVYE6OQWo5mZqPl5dXo8RjTax59oU52T+p5QML1zybfsRduHAhEhMTkZ6ejp9//hnR0dGQy+WYMGECACA+Ph7JyclQq9X44osvMHbsWMyfPx/t27c3bGPo0KHYuHGjYXrkyJF499138d133yE9PR27d+/G2rVrER0dbZMciYhqsOYRkTXZ9Ejd9evXMWHCBOTl5cHPzw8DBw5EcnIy/Pz8AACpqalYtGgR8vPzERISgjfffBPz58832oZarUZubq5h+oMPPsDbb7+NWbNmIScnB8HBwXjxxRexePHiRs+PiOhurHlEZFUNP8WXRFEUKyoqxCVLlogVFRW2DsVimJNjkFpOUstHqqT4PjEn+ye1fEQr5WR3F0oQERERkfkc+7IxIiIiIgLY1BERERFJA5s6IiIiIglgU/cQPvzwQ4SEhMDZ2Rnh4eEO/QDtpUuXQhAEo1eHDh1sHZZZfvrpJ4wcORLBwcEQBAHffPON0XxRFLF48WIEBQXBxcUFERERuHz5ss3iNcWDcpo2bVqt923YsGE2i9cUsbGx6NOnDzw8PODv74/Ro0cjNTXVaJmKigrMnj0bPj4+cHd3x5gxY5CdnW2zmOkO1jz7wprHmncvNnUN9NVXXyEmJgZLlizBL7/8gm7duiEqKgo5OTm2Dq3BOnfujMzMTMPrfg8Rt0elpaXo1q0bPvzwwzrnr169Ghs2bMCmTZtw/PhxuLm5ISoqChUVFY0eq6kelBMADBs2zOh927ZtW6PGaK7ExETMnj0bycnJOHDgALRaLSIjI1FaWmpYZv78+fjvf/+LHTt2IDExETdv3sTTTz9t07j/7Fjz7A9rHmteLRa7jvZPpm/fvuLs2bMN0zqdTgwODhZjY2NtGldDLVmyROzWrZutw7AYAOLu3bsN03q9XgwMDBTff/99w9jt27dFlUolbtu2zUZRmufenERRFKdOnSqOGjXKZjFZQk5OjghATExMFMXq90WhUIg7duwwLPP777+LAMRjx47ZMNI/N9Y8+8aa5zisWfN4pK4BKisrcerUKURERBjGZDIZIiIicOzYMZvG9jAuX76M4OBgtG7dGpMmTUJGRoatQ7KYtLQ0ZGVlGb1nXl5eCA8Pd+j3DAAOHz4Mf39/tG/fHjNnzkReXp6tQzJLYWEhAKBp06YAgFOnTkGr1Rq9Vx06dEDLli0d/r1yVKx5joc1z35Zs+axqWuA3Nxc6HQ6BAQEGI0HBAQgKyvLZnE9jPDwcGzZsgX79u1DXFwc0tLSMGjQIBQXF9s6NIuoeV+k9J6h+muIzz77DAkJCVi1ahUSExPxxBNPQKfT2To0k+j1esybNw8DBgxAly5dgOr3SqlU1noWqaO/V46MNc/xsObZJ2vXPJs+JozsxxNPPGH4+yOPPILw8HC0atUKX3/9NaZPn27T2Kh+zz77rOHvXbt2xSOPPII2bdrg8OHDGDp0qE1jM8Xs2bNx/vx5hzuXiRwfa55jYs27Px6pawBfX1/I5fJaV6ZkZ2cjMDDQZnFZkre3N8LCwnDlyhVbh2IRNe+LlN8zAGjdujV8fX0d4n2bM2cOvv32Wxw6dAjNmzc3jAcGBqKyshK3b982Wl5q75UjYc1zPKx59qcxah6bugZQKpXo1asXEhISDGN6vR4JCQno16+fTWOzlJKSEqjVagQFBdk6FIsIDQ1FYGCg0XtWVFSE48ePS+Y9Q/UD4/Py8uz6fRNFEXPmzMHu3btx8OBBhIaGGs3v1asXFAqF0XuVmpqKjIwMSb1XjoQ1z/Gw5tmPRq15Fr+s409i+/btokqlErds2SJeuHBBnDFjhujt7S1mZWXZOrQGWbBggXj48GExLS1NTEpKEiMiIkRfX18xJyfH1qGZrLi4WDx9+rR4+vRpEYC4du1a8fTp0+K1a9dEURTF9957T/T29hb/85//iGfPnhVHjRolhoaGiuXl5bYOvV73y6m4uFhcuHCheOzYMTEtLU388ccfxZ49e4rt2rWz64dez5w5U/Ty8hIPHz4sZmZmGl5lZWWGZV566SWxZcuW4sGDB8WUlBSxX79+Yr9+/Wwa958da579Yc1jzbsXm7qH8MEHH4gtW7YUlUql2LdvXzE5OdnWITXY+PHjxaCgIFGpVIrNmjUTx48fL165csXWYZnl0KFDIoBar6lTp4pi9SX+b7/9thgQECCqVCpx6NChYmpqqq3Dvq/75VRWViZGRkaKfn5+okKhEFu1aiW+8MILdv+fbF35ABDj4+MNy5SXl4uzZs0SmzRpIrq6uorR0dFiZmamTeMm1jx7w5rHmncvoXqHREREROTAeE4dERERkQSwqSMiIiKSADZ1RERERBLApo6IiIhIAtjUEREREUkAmzoiIiIiCWBTR0RERCQBbOqIiIiIJIBNHdmlw4cPQxCEWg84biwJCQno2LEjdDrdA5fdt28funfvDr1e3yixEZH0sOaRJbCpI5sbPHgw5s2bZzTWv39/ZGZmwsvLyyYxvfrqq3jrrbcgl8sfuOywYcOgUCjw5ZdfNkpsROTYWPPIWtjUkV1SKpUIDAyEIAiNvu+jR49CrVZjzJgxJq8zbdo0bNiwwapxEZF0seaRJbCpI5uaNm0aEhMTsX79egiCAEEQkJ6eXuuriC1btsDb2xvffvst2rdvD1dXVzzzzDMoKyvDp59+ipCQEDRp0gRz5841+vpAo9Fg4cKFaNasGdzc3BAeHo7Dhw/fN6bt27fj8ccfh7Ozs2HszJkzGDJkCDw8PODp6YlevXohJSXFMH/kyJFISUmBWq22yr8TEUkDax5Zk5OtA6A/t/Xr1+PSpUvo0qULli9fDgDw8/NDenp6rWXLysqwYcMGbN++HcXFxXj66acRHR0Nb29vfP/997h69SrGjBmDAQMGYPz48QCAOXPm4MKFC9i+fTuCg4Oxe/duDBs2DOfOnUO7du3qjOnIkSOYOHGi0dikSZPQo0cPxMXFQS6X49dff4VCoTDMb9myJQICAnDkyBG0adPGwv9KRCQVrHlkTWzqyKa8vLygVCrh6uqKwMDA+y6r1WoRFxdnKCDPPPMMPv/8c2RnZ8Pd3R2dOnXCkCFDcOjQIYwfPx4ZGRmIj49HRkYGgoODAQALFy7Evn37EB8fj5UrV9a5n2vXrhmWr5GRkYFXXnkFHTp0AIA6i2NwcDCuXbvW4H8LIpI+1jyyJjZ15DBcXV2NPhEGBAQgJCQE7u7uRmM5OTkAgHPnzkGn0yEsLMxoOxqNBj4+PvXup7y83OhrCACIiYnB3/72N3z++eeIiIjA2LFja306dXFxQVlZ2UPnSUQE1jxqADZ15DDuPvQPAIIg1DlWc5l9SUkJ5HI5Tp06VeuKrruL4r18fX1RUFBgNLZ06VJMnDgR3333Hfbu3YslS5Zg+/btiI6ONiyTn58PPz+/h8qRiKgGax6Zi00d2ZxSqTTp3kjm6tGjB3Q6HXJycjBo0CCz1rtw4UKt8bCwMISFhWH+/PmYMGEC4uPjDQWuoqICarUaPXr0sGgORCQ9rHlkLbz6lWwuJCQEx48fR3p6OnJzcy12Q8uwsDBMmjQJU6ZMwa5du5CWloYTJ04gNjYW3333Xb3rRUVF4ejRo4bp8vJyzJkzB4cPH8a1a9eQlJSEkydPomPHjoZlkpOToVKp0K9fP4vETkTSxZpH1sKmjmxu4cKFkMvl6NSpE/z8/JCRkWGxbcfHx2PKlClYsGAB2rdvj9GjR+PkyZNo2bJlvetMmjQJv/32G1JTUwEAcrkceXl5mDJlCsLCwjBu3Dg88cQTWLZsmWGdbdu2YdKkSXB1dbVY7EQkTax5ZC2CKIqirYMgsjevvPIKioqK8I9//OOBy+bm5qJ9+/ZISUlBaGhoo8RHRGRJrHnSwCN1RHV488030apVK5O+FklPT8dHH33E4kZEDos1Txp4pI6IiIhIAnikjoiIiEgC2NQRERERSQCbOiIiIiIJYFNHREREJAFs6oiIiIgkgE0dERERkQSwqSMiIiKSADZ1RERERBLApo6IiIhIAtjUEREREUnA/w/EACbayDmy+gAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "\n", + "plt.subplot(2, 2, 1)\n", + "for name in [\"wr_gen1\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).values[begin_idx:end_idx]\n", + " * 60\n", + " / 377,\n", + " label=\"G1\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"Frequency (Hz)\")\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.title(\"$\\omega_{r,1}$\")\n", + "plt.ylim(59.8, 60.2)\n", + "\n", + "plt.subplot(2, 2, 2)\n", + "for name in [\"wr_gen2\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).values[begin_idx:end_idx]\n", + " * 60\n", + " / 377,\n", + " label=\"G2\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"Frequency (Hz)\")\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.title(\"$\\omega_{r,2}$\")\n", + "plt.ylim(59.8, 60.2)\n", + "\n", + "plt.subplot(2, 2, 3)\n", + "for name in [\"wr_gen3\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).values[begin_idx:end_idx]\n", + " * 60\n", + " / 377,\n", + " label=\"G3\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"Frequency (Hz)\")\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.title(\"$\\omega_{r,3}$\")\n", + "plt.ylim(59.8, 60.2)\n", + "\n", + "plt.subplot(2, 2, 4)\n", + "for name in [\"wr_gen4\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).values[begin_idx:end_idx]\n", + " * 60\n", + " / 377,\n", + " label=\"G4\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"Frequency (Hz)\")\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.title(\"$\\omega_{r,4}$\")\n", + "plt.ylim(59.8, 60.2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Rotor angle $\\delta _r$" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "<>:12: SyntaxWarning: invalid escape sequence '\\d'\n", + "<>:23: SyntaxWarning: invalid escape sequence '\\d'\n", + "<>:34: SyntaxWarning: invalid escape sequence '\\d'\n", + "<>:45: SyntaxWarning: invalid escape sequence '\\d'\n", + "<>:12: SyntaxWarning: invalid escape sequence '\\d'\n", + "<>:23: SyntaxWarning: invalid escape sequence '\\d'\n", + "<>:34: SyntaxWarning: invalid escape sequence '\\d'\n", + "<>:45: SyntaxWarning: invalid escape sequence '\\d'\n", + "/tmp/ipykernel_807343/407923322.py:12: SyntaxWarning: invalid escape sequence '\\d'\n", + " plt.title('$\\delta_1$')\n", + "/tmp/ipykernel_807343/407923322.py:23: SyntaxWarning: invalid escape sequence '\\d'\n", + " plt.title('$\\delta_2$')\n", + "/tmp/ipykernel_807343/407923322.py:34: SyntaxWarning: invalid escape sequence '\\d'\n", + " plt.title('$\\delta_3$')\n", + "/tmp/ipykernel_807343/407923322.py:45: SyntaxWarning: invalid escape sequence '\\d'\n", + " plt.title('$\\delta_4$')\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, '$\\\\delta_4$')" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "\n", + "plt.subplot(2, 2, 1)\n", + "for name in [\"delta_gen1\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).values[begin_idx:end_idx]\n", + " * 180\n", + " / 3.14\n", + " - ts_sp1ph_TrStab_dl[\"deltaref_gen1\"]\n", + " .interpolate(timestep)\n", + " .values[begin_idx:end_idx]\n", + " * 180\n", + " / 3.14,\n", + " label=\"SP\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"angle (°)\")\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.title(\"$\\delta_1$\")\n", + "\n", + "plt.subplot(2, 2, 2)\n", + "for name in [\"delta_gen2\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).values[begin_idx:end_idx]\n", + " * 180\n", + " / 3.14\n", + " - ts_sp1ph_TrStab_dl[\"deltaref_gen2\"]\n", + " .interpolate(timestep)\n", + " .values[begin_idx:end_idx]\n", + " * 180\n", + " / 3.14,\n", + " label=\"SP\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"angle (°)\")\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.title(\"$\\delta_2$\")\n", + "\n", + "plt.subplot(2, 2, 3)\n", + "for name in [\"delta_gen3\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).values[begin_idx:end_idx]\n", + " * 180\n", + " / 3.14\n", + " - ts_sp1ph_TrStab_dl[\"delta_gen3\"]\n", + " .interpolate(timestep)\n", + " .values[begin_idx:end_idx]\n", + " * 180\n", + " / 3.14,\n", + " label=\"SP\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"angle (°)\")\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.title(\"$\\delta_3$\")\n", + "\n", + "plt.subplot(2, 2, 4)\n", + "for name in [\"delta_gen4\"]:\n", + " plt.plot(\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).time[begin_idx:end_idx],\n", + " ts_sp1ph_TrStab_dl[name].interpolate(timestep).values[begin_idx:end_idx]\n", + " * 180\n", + " / 3.14\n", + " - ts_sp1ph_TrStab_dl[\"deltaref_gen4\"]\n", + " .interpolate(timestep)\n", + " .values[begin_idx:end_idx]\n", + " * 180\n", + " / 3.14,\n", + " label=\"SP\",\n", + " )\n", + "# plt.legend(loc='lower right')\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"angle (°)\")\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "plt.title(\"$\\delta_4$\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib64/python3.13/site-packages/matplotlib/cbook.py:1719: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " return math.isfinite(val)\n", + "/usr/local/lib64/python3.13/site-packages/matplotlib/cbook.py:1355: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " return np.asarray(x, float)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "power_line3 = (\n", + " np.conjugate(ts_sp1ph_TrStab_dl[\"i_line78_1\"].interpolate(timestep).values)\n", + " * ts_sp1ph_TrStab_dl[\"v7\"].interpolate(timestep).values\n", + ")\n", + "power_line4 = (\n", + " np.conjugate(ts_sp1ph_TrStab_dl[\"i_line78_2\"].interpolate(timestep).values)\n", + " * ts_sp1ph_TrStab_dl[\"v7\"].interpolate(timestep).values\n", + ")\n", + "power_line5 = (\n", + " np.conjugate(ts_sp1ph_TrStab_dl[\"i_line89_1\"].interpolate(timestep).values)\n", + " * ts_sp1ph_TrStab_dl[\"v8\"].interpolate(timestep).values\n", + ")\n", + "power_line6 = (\n", + " np.conjugate(ts_sp1ph_TrStab_dl[\"i_line89_2\"].interpolate(timestep).values)\n", + " * ts_sp1ph_TrStab_dl[\"v8\"].interpolate(timestep).values\n", + ")\n", + "\n", + "plt.figure()\n", + "plt.plot(\n", + " ts_sp1ph_TrStab_dl[\"i_line78_1\"].interpolate(timestep).time,\n", + " (power_line3 + power_line4) * 1e-6,\n", + ")\n", + "plt.plot(\n", + " ts_sp1ph_TrStab_dl[\"i_line89_1\"].interpolate(timestep).time,\n", + " (power_line5 + power_line6) * 1e-6,\n", + ")\n", + "plt.xlabel(\"time [s]\")\n", + "plt.ylabel(\"Power [MW]\")\n", + "plt.grid()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.9" + }, + "tests": { + "skip": true + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}