diff options
Diffstat (limited to 'opendc-experiments')
39 files changed, 797 insertions, 3386 deletions
diff --git a/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/Scenario.kt b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/Scenario.kt index f0e5717a..9029691a 100644 --- a/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/Scenario.kt +++ b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/Scenario.kt @@ -22,16 +22,31 @@ package org.opendc.experiments.base.models.scenario +import AllocationPolicySpec +import ExportModelSpec +import WorkloadSpec import org.opendc.compute.simulator.failure.FailureModel import org.opendc.compute.topology.specs.HostSpec +/** + * A data class representing a scenario for a set of experiments. + * + * @property topology The list of HostSpec representing the topology of the scenario. + * @property workload The WorkloadSpec representing the workload of the scenario. + * @property allocationPolicy The AllocationPolicySpec representing the allocation policy of the scenario. + * @property failureModel The FailureModel representing the failure model of the scenario. It can be null. + * @property exportModel The ExportSpec representing the export model of the scenario. It defaults to an instance of ExportSpec. + * @property outputFolder The String representing the output folder of the scenario. It defaults to "output". + * @property name The String representing the name of the scenario. It defaults to an empty string. + * @property runs The Int representing the number of runs of the scenario. It defaults to 1. + * @property initialSeed The Int representing the initial seed of the scenario. It defaults to 0. + */ public data class Scenario( val topology: List<HostSpec>, val workload: WorkloadSpec, val allocationPolicy: AllocationPolicySpec, val failureModel: FailureModel?, - val carbonTracePath: String? = null, - val exportModel: ExportSpec = ExportSpec(), + val exportModel: ExportModelSpec = ExportModelSpec(), val outputFolder: String = "output", val name: String = "", val runs: Int = 1, diff --git a/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/ScenarioFactories.kt b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/ScenarioFactories.kt index 93b2a2b5..56076f52 100644 --- a/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/ScenarioFactories.kt +++ b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/ScenarioFactories.kt @@ -22,37 +22,125 @@ package org.opendc.experiments.base.models.scenario +import AllocationPolicySpec +import TopologySpec +import WorkloadSpec import org.opendc.compute.simulator.failure.getFailureModel +import org.opendc.compute.topology.TopologyReader import org.opendc.compute.topology.clusterTopology +import org.opendc.compute.topology.specs.TopologyJSONSpec +import org.opendc.experiments.base.models.scenario.specs.ScenarioSpec import java.io.File +import java.util.UUID private val scenarioReader = ScenarioReader() -public fun getScenario(filePath: String): Scenario { +/** + * Returns a list of Scenarios from a given file path (input). + * + * @param filePath The path to the file containing the scenario specifications. + * @return A list of Scenarios. + */ +public fun getScenario(filePath: String): List<Scenario> { return getScenario(File(filePath)) } -public fun getScenario(file: File): Scenario { +/** + * Returns a list of Scenarios from a given file. Reads and decodes the contents of the (JSON) file. + * + * @param file The file containing the scenario specifications. + * @return A list of Scenarios. + */ +public fun getScenario(file: File): List<Scenario> { return getScenario(scenarioReader.read(file)) } -public fun getScenario(scenarioSpec: ScenarioSpec): Scenario { - val topology = clusterTopology(File(scenarioSpec.topology.pathToFile)) - val workload = scenarioSpec.workload - val allocationPolicy = scenarioSpec.allocationPolicy - val failureModel = getFailureModel(scenarioSpec.failureModel.failureInterval) - val exportModel = scenarioSpec.exportModel - - return Scenario( - topology, - workload, - allocationPolicy, - failureModel, - scenarioSpec.carbonTracePath, - exportModel, - scenarioSpec.outputFolder, - scenarioSpec.name, - scenarioSpec.runs, - scenarioSpec.initialSeed, - ) +/** + * Returns a list of Scenarios from a given ScenarioSpec. + * + * @param scenarioSpec The ScenarioSpec containing the scenario specifications. + * @return A list of Scenarios. + */ +public fun getScenario(scenarioSpec: ScenarioSpec): List<Scenario> { + return getScenarioCombinations(scenarioSpec) +} + +/** + * Returns a list of Scenarios from a given ScenarioSpec by generating all possible combinations of + * workloads, allocation policies, failure models, and export models within a topology. + * + * @param scenarioSpec The ScenarioSpec containing the scenario specifications. + * @return A list of Scenarios. + */ +public fun getScenarioCombinations(scenarioSpec: ScenarioSpec): List<Scenario> { + val topologies = getTopologies(scenarioSpec.topologies) + val topologiesSpec = scenarioSpec.topologies + val workloads = scenarioSpec.workloads + val allocationPolicies = scenarioSpec.allocationPolicies + val failureModels = scenarioSpec.failureModels + val exportModels = scenarioSpec.exportModels + val scenarios = mutableListOf<Scenario>() + + for (topology in topologiesSpec) { + for (workload in workloads) { + for (allocationPolicy in allocationPolicies) { + for (failureModel in failureModels) { + for (exportModel in exportModels) { + val scenario = + Scenario( + topology = clusterTopology(File(topology.pathToFile)), + workload = workload, + allocationPolicy = allocationPolicy, + failureModel = getFailureModel(failureModel.failureInterval), + exportModel = exportModel, + outputFolder = scenarioSpec.outputFolder, + name = getOutputFolderName(scenarioSpec, topology, workload, allocationPolicy), + runs = scenarioSpec.runs, + initialSeed = scenarioSpec.initialSeed, + ) + scenarios.add(scenario) + } + } + } + } + } + + return scenarios +} + +/** + * Returns a list of TopologyJSONSpec from a given list of TopologySpec. + * + * @param topologies The list of TopologySpec. + * @return A list of TopologyJSONSpec. + */ +public fun getTopologies(topologies: List<TopologySpec>): List<TopologyJSONSpec> { + val readTopologies = mutableListOf<TopologyJSONSpec>() + for (topology in topologies) { + readTopologies.add(TopologyReader().read(File(topology.pathToFile))) + } + + return readTopologies +} + +/** + * Returns a string representing the output folder name for a given ScenarioSpec, CpuPowerModel, AllocationPolicySpec, and topology path. + * + * @param scenarioSpec The ScenarioSpec. + * @param powerModel The CpuPowerModel. + * @param allocationPolicy The AllocationPolicySpec. + * @param topologyPath The path to the topology file. + * @return A string representing the output folder name. + */ +public fun getOutputFolderName( + scenarioSpec: ScenarioSpec, + topology: TopologySpec, + workload: WorkloadSpec, + allocationPolicy: AllocationPolicySpec, +): String { + return "scenario=${scenarioSpec.name}" + + "-topology=${topology.pathToFile}" + + "-workload=${workload.name}}" + + "-scheduler=${allocationPolicy.name}" + + "-${UUID.randomUUID().toString().substring(0, 8)}" } diff --git a/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/ScenarioReader.kt b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/ScenarioReader.kt index e7c7b4ae..ffbb3aa3 100644 --- a/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/ScenarioReader.kt +++ b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/ScenarioReader.kt @@ -25,6 +25,7 @@ package org.opendc.experiments.base.models.scenario import kotlinx.serialization.ExperimentalSerializationApi import kotlinx.serialization.json.Json import kotlinx.serialization.json.decodeFromStream +import org.opendc.experiments.base.models.scenario.specs.ScenarioSpec import java.io.File import java.io.InputStream diff --git a/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/ScenarioSpecs.kt b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/ScenarioSpecs.kt deleted file mode 100644 index f39b16dd..00000000 --- a/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/ScenarioSpecs.kt +++ /dev/null @@ -1,167 +0,0 @@ -/* - * Copyright (c) 2024 AtLarge Research - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in all - * copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. - */ - -package org.opendc.experiments.base.models.scenario - -import kotlinx.serialization.Serializable -import org.opendc.compute.service.scheduler.ComputeSchedulerEnum -import org.opendc.compute.workload.ComputeWorkload -import org.opendc.compute.workload.sampleByLoad -import org.opendc.compute.workload.trace -import java.io.File - -/** - * specification describing a scenario - * - * @property topology - * @property workload - * @property allocationPolicy - * @property failureModel - * @property exportModel - * @property outputFolder - * @property initialSeed - * @property runs - */ -@Serializable -public data class ScenarioSpec( - val topology: TopologySpec, - val workload: WorkloadSpec, - val allocationPolicy: AllocationPolicySpec, - val failureModel: FailureModelSpec = FailureModelSpec(), - val carbonTracePath: String? = null, - val exportModel: ExportSpec = ExportSpec(), - val outputFolder: String = "output", - val initialSeed: Int = 0, - val runs: Int = 1, - var name: String = "", -) { - init { - require(runs > 0) { "The number of runs should always be positive" } - require(carbonTracePath == null || File(carbonTracePath).exists()) { "The provided carbon trace cannot be found: $carbonTracePath" } - - // generate name if not provided - if (name == "") { - name = "workload=${workload.name}_topology=${topology.name}_allocationPolicy=${allocationPolicy.name}" - } - } -} - -/** - * specification describing a topology - * - * @property pathToFile - */ -@Serializable -public data class TopologySpec( - val pathToFile: String, -) { - public val name: String = File(pathToFile).nameWithoutExtension - - init { - require(File(pathToFile).exists()) { "The provided path to the topology: $pathToFile does not exist " } - } -} - -/** - * specification describing a workload - * - * @property pathToFile - * @property type - */ -@Serializable -public data class WorkloadSpec( - val pathToFile: String, - val type: WorkloadTypes, -) { - public val name: String = File(pathToFile).nameWithoutExtension - - init { - require(File(pathToFile).exists()) { "The provided path to the workload: $pathToFile does not exist " } - } -} - -/** - * specification describing a workload type - * - * @constructor Create empty Workload types - */ -public enum class WorkloadTypes { - /** - * Compute workload - * - * @constructor Create empty Compute workload - */ - ComputeWorkload, -} - -/** - * - *TODO: move to separate file - * @param type - */ -public fun getWorkloadType(type: WorkloadTypes): ComputeWorkload { - return when (type) { - WorkloadTypes.ComputeWorkload -> trace("trace").sampleByLoad(1.0) - } -} - -/** - * specification describing how tasks are allocated - * - * @property policyType - * - * TODO: expand with more variables such as allowed over-subscription - */ -@Serializable -public data class AllocationPolicySpec( - val policyType: ComputeSchedulerEnum, -) { - public val name: String = policyType.toString() -} - -/** - * specification describing the failure model - * - * @property failureInterval The interval between failures in s. Should be 0.0 or higher - */ -@Serializable -public data class FailureModelSpec( - val failureInterval: Double = 0.0, -) { - init { - require(failureInterval >= 0.0) { "failure frequency cannot be lower than 0" } - } -} - -/** - * specification describing how the results should be exported - * - * @property exportInterval The interval of exporting results in s. Should be higher than 0.0 - */ -@Serializable -public data class ExportSpec( - val exportInterval: Long = 5 * 60, -) { - init { - require(exportInterval > 0) { "The Export interval has to be higher than 0" } - } -} diff --git a/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/specs/AllocationPolicySpec.kt b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/specs/AllocationPolicySpec.kt new file mode 100644 index 00000000..f7ae7e9f --- /dev/null +++ b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/specs/AllocationPolicySpec.kt @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2024 AtLarge Research + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +import kotlinx.serialization.Serializable +import org.opendc.compute.service.scheduler.ComputeSchedulerEnum + +/** + * specification describing how tasks are allocated + * + * @property policyType + * + * TODO: expand with more variables such as allowed over-subscription + */ +@Serializable +public data class AllocationPolicySpec( + val policyType: ComputeSchedulerEnum, +) { + public val name: String = policyType.toString() +} diff --git a/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/portfolio/PortfolioReader.kt b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/specs/ExportModelSpec.kt index 767b61bb..9a23ad00 100644 --- a/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/portfolio/PortfolioReader.kt +++ b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/specs/ExportModelSpec.kt @@ -20,29 +20,18 @@ * SOFTWARE. */ -package org.opendc.experiments.base.models.portfolio +import kotlinx.serialization.Serializable -import kotlinx.serialization.ExperimentalSerializationApi -import kotlinx.serialization.json.Json -import kotlinx.serialization.json.decodeFromStream -import java.io.File -import java.io.InputStream - -public class PortfolioReader { - @OptIn(ExperimentalSerializationApi::class) - public fun read(file: File): PortfolioSpec { - val input = file.inputStream() - val obj = Json.decodeFromStream<PortfolioSpec>(input) - - return obj - } - - /** - * Read the specified [input]. - */ - @OptIn(ExperimentalSerializationApi::class) - public fun read(input: InputStream): PortfolioSpec { - val obj = Json.decodeFromStream<PortfolioSpec>(input) - return obj +/** + * specification describing how the results should be exported + * + * @property exportInterval The interval of exporting results in s. Should be higher than 0.0 + */ +@Serializable +public data class ExportModelSpec( + val exportInterval: Long = 5 * 60, +) { + init { + require(exportInterval > 0) { "The Export interval has to be higher than 0" } } } diff --git a/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/portfolio/Portfolio.kt b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/specs/FailureModelSpec.kt index 7b0299c5..99620366 100644 --- a/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/portfolio/Portfolio.kt +++ b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/specs/FailureModelSpec.kt @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 AtLarge Research + * Copyright (c) 2024 AtLarge Research * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal @@ -20,13 +20,18 @@ * SOFTWARE. */ -package org.opendc.experiments.base.models.portfolio - -import org.opendc.experiments.base.models.scenario.Scenario +import kotlinx.serialization.Serializable /** - * A portfolio represents a collection of scenarios are tested for the work. + * specification describing the failure model + * + * @property failureInterval The interval between failures in s. Should be 0.0 or higher */ -public class Portfolio( - public val scenarios: Iterable<Scenario>, -) +@Serializable +public data class FailureModelSpec( + val failureInterval: Double = 0.0, +) { + init { + require(failureInterval >= 0.0) { "failure frequency cannot be lower than 0" } + } +} diff --git a/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/portfolio/PortfolioSpec.kt b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/specs/PowerModelSpec.kt index 554442b2..fc568925 100644 --- a/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/portfolio/PortfolioSpec.kt +++ b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/specs/PowerModelSpec.kt @@ -20,12 +20,11 @@ * SOFTWARE. */ -package org.opendc.experiments.base.models.portfolio - import kotlinx.serialization.Serializable -import org.opendc.experiments.base.models.scenario.ScenarioSpec @Serializable -public data class PortfolioSpec( - val scenarios: List<ScenarioSpec>, +public data class PowerModelSpec( + val type: String = "constant", + val idlePower: Double = 200.0, + val maxPower: Double = 350.0, ) diff --git a/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/specs/ScenarioSpec.kt b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/specs/ScenarioSpec.kt new file mode 100644 index 00000000..5f9aec4a --- /dev/null +++ b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/specs/ScenarioSpec.kt @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2024 AtLarge Research + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +package org.opendc.experiments.base.models.scenario.specs + +import AllocationPolicySpec +import ExportModelSpec +import FailureModelSpec +import TopologySpec +import WorkloadSpec +import kotlinx.serialization.Serializable + +/** + * specification describing a scenario + * + * @property topologies + * @property workloads + * @property allocationPolicies + * @property failureModels + * @property exportModels + * @property outputFolder + * @property initialSeed + * @property runs + */ +@Serializable +public data class ScenarioSpec( + val topologies: List<TopologySpec>, + val workloads: List<WorkloadSpec>, + val allocationPolicies: List<AllocationPolicySpec>, + val failureModels: List<FailureModelSpec> = listOf(FailureModelSpec()), + val exportModels: List<ExportModelSpec> = listOf(ExportModelSpec()), + val outputFolder: String = "output", + val initialSeed: Int = 0, + val runs: Int = 1, + var name: String = "", +) { + init { + require(runs > 0) { "The number of runs should always be positive" } + + // generate name if not provided + if (name == "") { + name = + "workload=${workloads[0].name}_topology=${topologies[0].name}_allocationPolicy=${allocationPolicies[0].name}" + } + } +} diff --git a/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/portfolio/PortfolioFactories.kt b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/specs/TopologySpec.kt index aee87814..392b9763 100644 --- a/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/portfolio/PortfolioFactories.kt +++ b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/specs/TopologySpec.kt @@ -20,26 +20,21 @@ * SOFTWARE. */ -package org.opendc.experiments.base.models.portfolio - -import org.opendc.experiments.base.models.scenario.getScenario +import kotlinx.serialization.Serializable import java.io.File -private val porfolioReader = PortfolioReader() - -public fun getPortfolio(filePath: String): Portfolio { - return getPortfolio(File(filePath)) -} - -public fun getPortfolio(file: File): Portfolio { - return getPortfolio(porfolioReader.read(file)) -} +/** + * specification describing a topology + * + * @property pathToFile + */ +@Serializable +public data class TopologySpec( + val pathToFile: String, +) { + public val name: String = File(pathToFile).nameWithoutExtension -public fun getPortfolio(portfolioSpec: PortfolioSpec): Portfolio { - return Portfolio( - portfolioSpec.scenarios.map { - scenario -> - getScenario(scenario) - }, - ) + init { + require(File(pathToFile).exists()) { "The provided path to the topology: $pathToFile does not exist " } + } } diff --git a/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/specs/WorkloadSpec.kt b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/specs/WorkloadSpec.kt new file mode 100644 index 00000000..819f633d --- /dev/null +++ b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/models/scenario/specs/WorkloadSpec.kt @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2024 AtLarge Research + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +import kotlinx.serialization.Serializable +import org.opendc.compute.workload.ComputeWorkload +import org.opendc.compute.workload.sampleByLoad +import org.opendc.compute.workload.trace +import java.io.File + +/** + * specification describing a workload + * + * @property pathToFile + * @property type + */ +@Serializable +public data class WorkloadSpec( + val pathToFile: String, + val type: WorkloadTypes, +) { + public val name: String = File(pathToFile).nameWithoutExtension + + init { + require(File(pathToFile).exists()) { "The provided path to the workload: $pathToFile does not exist " } + } +} + +/** + * specification describing a workload type + * + * @constructor Create empty Workload types + */ +public enum class WorkloadTypes { + /** + * Compute workload + * + * @constructor Create empty Compute workload + */ + ComputeWorkload, +} + +/** + * + *TODO: move to separate file + * @param type + */ +public fun getWorkloadType(type: WorkloadTypes): ComputeWorkload { + return when (type) { + WorkloadTypes.ComputeWorkload -> trace("trace").sampleByLoad(1.0) + } +} diff --git a/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/runner/ScenarioHelpers.kt b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/runner/ScenarioHelpers.kt index a6a05d78..97914556 100644 --- a/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/runner/ScenarioHelpers.kt +++ b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/runner/ScenarioHelpers.kt @@ -108,7 +108,7 @@ public suspend fun ComputeService.replay( } // Make sure the trace entries are ordered by submission time -// assert(start - simulationOffset >= 0) { "Invalid trace order" } + // assert(start - simulationOffset >= 0) { "Invalid trace order" } // Delay the server based on the startTime given by the trace. if (!submitImmediately) { diff --git a/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/runner/ScenarioRunner.kt b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/runner/ScenarioRunner.kt index 59c11f34..63853d33 100644 --- a/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/runner/ScenarioRunner.kt +++ b/opendc-experiments/opendc-experiments-base/src/main/kotlin/org/opendc/experiments/base/runner/ScenarioRunner.kt @@ -22,9 +22,9 @@ package org.opendc.experiments.base.runner +import getWorkloadType import me.tongfei.progressbar.ProgressBarBuilder import me.tongfei.progressbar.ProgressBarStyle -import org.opendc.compute.carbon.getCarbonTrace import org.opendc.compute.service.ComputeService import org.opendc.compute.service.scheduler.ComputeSchedulerEnum import org.opendc.compute.service.scheduler.createComputeScheduler @@ -34,9 +34,7 @@ import org.opendc.compute.simulator.provisioner.setupComputeService import org.opendc.compute.simulator.provisioner.setupHosts import org.opendc.compute.telemetry.export.parquet.ParquetComputeMonitor import org.opendc.compute.workload.ComputeWorkloadLoader -import org.opendc.experiments.base.models.portfolio.Portfolio import org.opendc.experiments.base.models.scenario.Scenario -import org.opendc.experiments.base.models.scenario.getWorkloadType import org.opendc.simulator.kotlin.runSimulation import java.io.File import java.time.Duration @@ -44,17 +42,6 @@ import java.util.Random import java.util.concurrent.ForkJoinPool import java.util.stream.LongStream -public fun runPortfolio( - portfolio: Portfolio, - parallelism: Int, -) { - val pool = ForkJoinPool(parallelism) - - for (scenario in portfolio.scenarios) { - runScenario(scenario, pool) - } -} - /** * Run scenario when no pool is available for parallel execution * @@ -62,11 +49,26 @@ public fun runPortfolio( * @param parallelism The number of scenarios that can be run in parallel */ public fun runScenario( - scenario: Scenario, + scenarios: List<Scenario>, parallelism: Int, ) { - val pool = ForkJoinPool(parallelism) - runScenario(scenario, pool) + val ansiReset = "\u001B[0m" + val ansiGreen = "\u001B[32m" + val ansiBlue = "\u001B[34m" + clearOutputFolder() + + for (scenario in scenarios) { + val pool = ForkJoinPool(parallelism) + println( + "\n\n$ansiGreen================================================================================$ansiReset", + ) + println("$ansiBlue Running scenario: ${scenario.name} $ansiReset") + println("$ansiGreen================================================================================$ansiReset") + runScenario( + scenario, + pool, + ) + } } /** @@ -81,20 +83,14 @@ public fun runScenario( pool: ForkJoinPool, ) { val pb = - ProgressBarBuilder() - .setInitialMax(scenario.runs.toLong()) - .setStyle(ProgressBarStyle.ASCII) - .setTaskName("Simulating...") - .build() + ProgressBarBuilder().setInitialMax(scenario.runs.toLong()).setStyle(ProgressBarStyle.ASCII) + .setTaskName("Simulating...").build() pool.submit { - LongStream.range(0, scenario.runs.toLong()) - .parallel() - .forEach { - runScenario(scenario, scenario.initialSeed + it) - pb.step() - } - + LongStream.range(0, scenario.runs.toLong()).parallel().forEach { + runScenario(scenario, scenario.initialSeed + it) + pb.step() + } pb.close() }.join() } @@ -111,39 +107,93 @@ public fun runScenario( ): Unit = runSimulation { val serviceDomain = "compute.opendc.org" - Provisioner(dispatcher, seed).use { provisioner -> - provisioner.runSteps( - setupComputeService(serviceDomain, { createComputeScheduler(ComputeSchedulerEnum.Mem, Random(it.seeder.nextLong())) }), + setupComputeService( + serviceDomain, + { createComputeScheduler(ComputeSchedulerEnum.Mem, Random(it.seeder.nextLong())) }, + ), setupHosts(serviceDomain, scenario.topology, optimize = true), ) - val carbonTrace = getCarbonTrace(scenario.carbonTracePath) - val partition = scenario.name + "/seed=$seed" - val workloadLoader = ComputeWorkloadLoader(File(scenario.workload.pathToFile)) val vms = getWorkloadType(scenario.workload.type).resolve(workloadLoader, Random(seed)) - val startTime = Duration.ofMillis(vms.minOf { it.startTime }.toEpochMilli()) - provisioner.runStep( - registerComputeMonitor( - serviceDomain, - ParquetComputeMonitor( - File(scenario.outputFolder), - partition, - bufferSize = 4096, - ), - Duration.ofSeconds(scenario.exportModel.exportInterval), - startTime, - carbonTrace, - ), - ) + // saveInSeedFolder(provisioner, serviceDomain, scenario, seed, partition, startTime) + // XOR + saveInOutputFolder(provisioner, serviceDomain, scenario, startTime) val service = provisioner.registry.resolve(serviceDomain, ComputeService::class.java)!! - service.replay(timeSource, vms, seed, failureModel = scenario.failureModel) } } + +/** + * When the simulation is run, saves the simulation results into a seed folder. This is useful for debugging purposes. + * @param provisioner The provisioner used to setup and run the simulation. + * @param serviceDomain The domain of the compute service. + * @param scenario The scenario being run in the simulation. + * @param seed The seed used for randomness in the simulation. + * @param partition The partition name for the output data. + * @param startTime The start time of the simulation. + + */ +public fun saveInSeedFolder( + provisioner: Provisioner, + serviceDomain: String, + scenario: Scenario, + seed: Long, + partition: String, + startTime: Duration, +) { + provisioner.runStep( + registerComputeMonitor( + serviceDomain, + ParquetComputeMonitor( + File(scenario.outputFolder), + partition, + bufferSize = 4096, + ), + Duration.ofSeconds(scenario.exportModel.exportInterval), + startTime, + ), + ) +} + +/** + * Saves the simulation results into a specific output folder received from the input. + * + * @param provisioner The provisioner used to setup and run the simulation. + * @param serviceDomain The domain of the compute service. + * @param scenario The scenario being run. + * @param startTime The start time of the simulation. + */ +public fun saveInOutputFolder( + provisioner: Provisioner, + serviceDomain: String, + scenario: Scenario, + startTime: Duration, +) { + provisioner.runStep( + registerComputeMonitor( + serviceDomain, + ParquetComputeMonitor( + File("output/simulation-results/"), + scenario.name, + bufferSize = 4096, + ), + Duration.ofSeconds(scenario.exportModel.exportInterval), + startTime, + ), + ) +} + +/** + * Utilitary function, in case we want to delete the previous simulation results. + */ +public fun clearOutputFolder() { + val outputFolderPath = "output/simulation-results/" + if (File(outputFolderPath).exists()) File(outputFolderPath).deleteRecursively() +} diff --git a/opendc-experiments/opendc-experiments-base/src/test/kotlin/org/opendc/experiments/base/ScenarioIntegrationTest.kt b/opendc-experiments/opendc-experiments-base/src/test/kotlin/org/opendc/experiments/base/ScenarioIntegrationTest.kt index d67ed727..2966c934 100644 --- a/opendc-experiments/opendc-experiments-base/src/test/kotlin/org/opendc/experiments/base/ScenarioIntegrationTest.kt +++ b/opendc-experiments/opendc-experiments-base/src/test/kotlin/org/opendc/experiments/base/ScenarioIntegrationTest.kt @@ -125,8 +125,8 @@ class ScenarioIntegrationTest { { assertEquals(66977091124, monitor.activeTime) { "Incorrect active time" } }, { assertEquals(3160267873, monitor.stealTime) { "Incorrect steal time" } }, { assertEquals(0, monitor.lostTime) { "Incorrect lost time" } }, - { assertEquals(2.5892214E7, monitor.powerDraw, 1E4) { "Incorrect power draw" } }, - { assertEquals(7.7672373E9, monitor.energyUsage, 1E4) { "Incorrect energy usage" } }, + { assertEquals(1.9469839319124512E7, monitor.powerDraw, 1E4) { "Incorrect power draw" } }, + { assertEquals(5.840705003360067E9, monitor.energyUsage, 1E5) { "Incorrect energy usage" } }, ) } @@ -167,8 +167,8 @@ class ScenarioIntegrationTest { { assertEquals(9741285381, monitor.activeTime) { "Active time incorrect" } }, { assertEquals(152, monitor.stealTime) { "Steal time incorrect" } }, { assertEquals(0, monitor.lostTime) { "Lost time incorrect" } }, - { assertEquals(2644612.0, monitor.powerDraw, 1E4) { "Incorrect power draw" } }, - { assertEquals(7.9336867E8, monitor.energyUsage, 1E4) { "Incorrect energy usage" } }, + { assertEquals(2337040.5458753705, monitor.powerDraw, 1E4) { "Incorrect power draw" } }, + { assertEquals(7.010994945790212E8, monitor.energyUsage, 1E4) { "Incorrect energy usage" } }, ) } diff --git a/opendc-experiments/opendc-experiments-base/src/test/resources/env/multi.json b/opendc-experiments/opendc-experiments-base/src/test/resources/env/multi.json index 721005b0..b87877af 100644 --- a/opendc-experiments/opendc-experiments-base/src/test/resources/env/multi.json +++ b/opendc-experiments/opendc-experiments-base/src/test/resources/env/multi.json @@ -16,6 +16,12 @@ ], "memory": { "memorySize": 256000 + }, + "powerModel": { + "modelType": "linear", + "power": 350.0, + "maxPower": 350.0, + "idlePower": 200.0 } } ] @@ -36,6 +42,12 @@ ], "memory": { "memorySize": 64000 + }, + "powerModel": { + "modelType": "linear", + "power": 350.0, + "maxPower": 350.0, + "idlePower": 200.0 } } ] @@ -56,6 +68,12 @@ ], "memory": { "memorySize": 128000 + }, + "powerModel": { + "modelType": "linear", + "power": 350.0, + "maxPower": 350.0, + "idlePower": 200.0 } } ] @@ -63,4 +81,3 @@ ] } - diff --git a/opendc-experiments/opendc-experiments-base/src/test/resources/env/single.json b/opendc-experiments/opendc-experiments-base/src/test/resources/env/single.json index a1c8d95a..9862f71a 100644 --- a/opendc-experiments/opendc-experiments-base/src/test/resources/env/single.json +++ b/opendc-experiments/opendc-experiments-base/src/test/resources/env/single.json @@ -16,6 +16,12 @@ ], "memory": { "memorySize": 128000 + }, + "powerModel": { + "modelType": "linear", + "power": 350.0, + "maxPower": 350.0, + "idlePower": 200.0 } } ] @@ -23,4 +29,3 @@ ] } - diff --git a/opendc-experiments/opendc-experiments-portfolio/build.gradle.kts b/opendc-experiments/opendc-experiments-portfolio/build.gradle.kts deleted file mode 100644 index f8fdd00b..00000000 --- a/opendc-experiments/opendc-experiments-portfolio/build.gradle.kts +++ /dev/null @@ -1,96 +0,0 @@ -/* - * Copyright (c) 2019 AtLarge Research - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in all - * copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. - */ - -description = "Experiments for the Portfolio work" - -// Build configuration -plugins { - `kotlin-library-conventions` - `kotlin-conventions` - `testing-conventions` - `jacoco-conventions` - `benchmark-conventions` - distribution - kotlin("plugin.serialization") version "1.9.22" -} - -dependencies { - implementation(projects.opendcSimulator.opendcSimulatorCore) - implementation(projects.opendcSimulator.opendcSimulatorCompute) - implementation(projects.opendcCompute.opendcComputeSimulator) - - implementation(libs.clikt) - implementation(libs.progressbar) - implementation(libs.kotlin.logging) - - implementation(libs.jackson.module.kotlin) - implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.0") - - implementation(project(mapOf("path" to ":opendc-compute:opendc-compute-telemetry"))) - implementation(project(mapOf("path" to ":opendc-compute:opendc-compute-topology"))) - implementation(project(mapOf("path" to ":opendc-compute:opendc-compute-workload"))) - implementation(project(mapOf("path" to ":opendc-experiments:opendc-experiments-base"))) - - runtimeOnly(libs.log4j.core) - runtimeOnly(libs.log4j.slf4j) -} - -val createPortfolioApp by tasks.creating(CreateStartScripts::class) { - dependsOn(tasks.jar) - - applicationName = "portfolio" - mainClass.set("org.opendc.experiments.portfolio.portfolioCLI") - classpath = tasks.jar.get().outputs.files + configurations["runtimeClasspath"] - outputDir = project.buildDir.resolve("scripts") -} - -// Create custom Greenifier distribution -distributions { - main { - distributionBaseName.set("portfolio") - - contents { - from("README.md") - from("LICENSE.txt") - from("../../LICENSE.txt") { - rename { "LICENSE-OpenDC.txt" } - } - - into("bin") { - from(createPortfolioApp) - } - - into("lib") { - from(tasks.jar) - from(configurations["runtimeClasspath"]) - } - - into("resources") { - from("src/main/resources") - } - - into("Python_scripts") { - from("src/main/Python_scripts") - } - } - } -} diff --git a/opendc-experiments/opendc-experiments-portfolio/src/jmh/kotlin/org/opendc/experiments/greenifier/GreenifierBenchmarks.kt b/opendc-experiments/opendc-experiments-portfolio/src/jmh/kotlin/org/opendc/experiments/greenifier/GreenifierBenchmarks.kt deleted file mode 100644 index 6cc6df36..00000000 --- a/opendc-experiments/opendc-experiments-portfolio/src/jmh/kotlin/org/opendc/experiments/greenifier/GreenifierBenchmarks.kt +++ /dev/null @@ -1,95 +0,0 @@ -/* - * Copyright (c) 2021 AtLarge Research - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in all - * copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. - */ - -package org.opendc.experiments.greenifier - -import org.opendc.compute.service.ComputeService -import org.opendc.compute.service.scheduler.FilterScheduler -import org.opendc.compute.service.scheduler.filters.ComputeFilter -import org.opendc.compute.service.scheduler.filters.RamFilter -import org.opendc.compute.service.scheduler.filters.VCpuFilter -import org.opendc.compute.service.scheduler.weights.CoreRamWeigher -import org.opendc.compute.simulator.provisioner.Provisioner -import org.opendc.compute.simulator.provisioner.setupComputeService -import org.opendc.compute.simulator.provisioner.setupHosts -import org.opendc.compute.topology.HostSpec -import org.opendc.compute.topology.clusterTopology -import org.opendc.compute.workload.ComputeWorkloadLoader -import org.opendc.compute.workload.VirtualMachine -import org.opendc.compute.workload.trace -import org.opendc.experiments.base.runner.replay -import org.opendc.simulator.kotlin.runSimulation -import org.openjdk.jmh.annotations.Benchmark -import org.openjdk.jmh.annotations.Fork -import org.openjdk.jmh.annotations.Measurement -import org.openjdk.jmh.annotations.Param -import org.openjdk.jmh.annotations.Scope -import org.openjdk.jmh.annotations.Setup -import org.openjdk.jmh.annotations.State -import org.openjdk.jmh.annotations.Warmup -import java.io.File -import java.util.Random -import java.util.concurrent.TimeUnit - -/** - * Benchmark suite for the Greenifier experiments. - */ -@State(Scope.Thread) -@Fork(1) -@Warmup(iterations = 2, time = 5, timeUnit = TimeUnit.SECONDS) -@Measurement(iterations = 5, time = 5, timeUnit = TimeUnit.SECONDS) -class GreenifierBenchmarks { - private lateinit var vms: List<VirtualMachine> - private lateinit var topology: List<HostSpec> - - @Param("true", "false") - private var isOptimized: Boolean = false - - @Setup - fun setUp() { - val loader = ComputeWorkloadLoader(File("src/test/resources/trace")) - vms = trace("bitbrains-small").resolve(loader, Random(1L)) - topology = checkNotNull(object {}.javaClass.getResourceAsStream("/topology.txt")).use { clusterTopology(it) } - } - - @Benchmark - fun benchmarkGreenifier() = - runSimulation { - val serviceDomain = "compute.opendc.org" - - Provisioner(dispatcher, seed = 0).use { provisioner -> - val computeScheduler = - FilterScheduler( - filters = listOf(ComputeFilter(), VCpuFilter(16.0), RamFilter(1.0)), - weighers = listOf(CoreRamWeigher(multiplier = 1.0)), - ) - - provisioner.runSteps( - setupComputeService(serviceDomain, { computeScheduler }), - setupHosts(serviceDomain, topology, optimize = isOptimized), - ) - - val service = provisioner.registry.resolve(serviceDomain, ComputeService::class.java)!! - service.replay(timeSource, vms, 0L, interference = true) - } - } -} diff --git a/opendc-experiments/opendc-experiments-portfolio/src/jmh/resources/log4j2.xml b/opendc-experiments/opendc-experiments-portfolio/src/jmh/resources/log4j2.xml deleted file mode 100644 index c496dd75..00000000 --- a/opendc-experiments/opendc-experiments-portfolio/src/jmh/resources/log4j2.xml +++ /dev/null @@ -1,37 +0,0 @@ -<?xml version="1.0" encoding="UTF-8"?> -<!-- - ~ MIT License - ~ - ~ Copyright (c) 2020 atlarge-research - ~ - ~ Permission is hereby granted, free of charge, to any person obtaining a copy - ~ of this software and associated documentation files (the "Software"), to deal - ~ in the Software without restriction, including without limitation the rights - ~ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - ~ copies of the Software, and to permit persons to whom the Software is - ~ furnished to do so, subject to the following conditions: - ~ - ~ The above copyright notice and this permission notice shall be included in all - ~ copies or substantial portions of the Software. - ~ - ~ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - ~ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - ~ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - ~ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - ~ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - ~ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - ~ SOFTWARE. - --> - -<Configuration status="WARN"> - <Appenders> - <Console name="Console" target="SYSTEM_OUT"> - <PatternLayout pattern="%d{HH:mm:ss.SSS} [%highlight{%-5level}] %logger{36} - %msg%n" disableAnsi="false"/> - </Console> - </Appenders> - <Loggers> - <Root level="warn"> - <AppenderRef ref="Console"/> - </Root> - </Loggers> -</Configuration> diff --git a/opendc-experiments/opendc-experiments-portfolio/src/jmh/resources/topology.txt b/opendc-experiments/opendc-experiments-portfolio/src/jmh/resources/topology.txt deleted file mode 100644 index 6b347bff..00000000 --- a/opendc-experiments/opendc-experiments-portfolio/src/jmh/resources/topology.txt +++ /dev/null @@ -1,5 +0,0 @@ -ClusterID;ClusterName;Cores;Speed;Memory;numberOfHosts;memoryCapacityPerHost;coreCountPerHost -A01;A01;32;3.2;2048;1;256;32 -B01;B01;48;2.93;1256;6;64;8 -C01;C01;32;3.2;2048;2;128;16 - diff --git a/opendc-experiments/opendc-experiments-portfolio/src/main/Python_scripts/.ipynb_checkpoints/OpenDCdemo-checkpoint.ipynb b/opendc-experiments/opendc-experiments-portfolio/src/main/Python_scripts/.ipynb_checkpoints/OpenDCdemo-checkpoint.ipynb deleted file mode 100644 index 792e5995..00000000 --- a/opendc-experiments/opendc-experiments-portfolio/src/main/Python_scripts/.ipynb_checkpoints/OpenDCdemo-checkpoint.ipynb +++ /dev/null @@ -1,1379 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "18170001", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "\n", - "from IPython.display import display, HTML\n", - "\n", - "base_folder = \"../../../../..\"" - ] - }, - { - "cell_type": "markdown", - "id": "422f4d05", - "metadata": {}, - "source": [ - "## Topologies" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "a2d05361", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Topology name: multi\n" - ] - }, - { - "data": { - "text/html": [ - "<table border=\"1\" class=\"dataframe\">\n", - " <thead>\n", - " <tr style=\"text-align: right;\">\n", - " <th></th>\n", - " <th>ClusterID</th>\n", - " <th>ClusterName</th>\n", - " <th>Cores</th>\n", - " <th>Speed</th>\n", - " <th>Memory</th>\n", - " <th>numberOfHosts</th>\n", - " <th>memoryCapacityPerHost</th>\n", - " <th>coreCountPerHost</th>\n", - " </tr>\n", - " </thead>\n", - " <tbody>\n", - " <tr>\n", - " <th>0</th>\n", - " <td>A01</td>\n", - " <td>A01</td>\n", - " <td>32</td>\n", - " <td>3.20</td>\n", - " <td>2048</td>\n", - " <td>1</td>\n", - " <td>256</td>\n", - " <td>32</td>\n", - " </tr>\n", - " <tr>\n", - " <th>1</th>\n", - " <td>B01</td>\n", - " <td>B01</td>\n", - " <td>48</td>\n", - " <td>2.93</td>\n", - " <td>1256</td>\n", - " <td>6</td>\n", - " <td>64</td>\n", - " <td>8</td>\n", - " </tr>\n", - " <tr>\n", - " <th>2</th>\n", - " <td>C01</td>\n", - " <td>C01</td>\n", - " <td>32</td>\n", - " <td>3.20</td>\n", - " <td>2048</td>\n", - " <td>2</td>\n", - " <td>128</td>\n", - " <td>16</td>\n", - " </tr>\n", - " </tbody>\n", - "</table>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Topology name: single\n" - ] - }, - { - "data": { - "text/html": [ - "<table border=\"1\" class=\"dataframe\">\n", - " <thead>\n", - " <tr style=\"text-align: right;\">\n", - " <th></th>\n", - " <th>ClusterID</th>\n", - " <th>ClusterName</th>\n", - " <th>Cores</th>\n", - " <th>Speed</th>\n", - " <th>Memory</th>\n", - " <th>numberOfHosts</th>\n", - " <th>memoryCapacityPerHost</th>\n", - " <th>coreCountPerHost</th>\n", - " </tr>\n", - " </thead>\n", - " <tbody>\n", - " <tr>\n", - " <th>0</th>\n", - " <td>A01</td>\n", - " <td>A01</td>\n", - " <td>8</td>\n", - " <td>3.2</td>\n", - " <td>128</td>\n", - " <td>1</td>\n", - " <td>128</td>\n", - " <td>8</td>\n", - " </tr>\n", - " </tbody>\n", - "</table>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "def read_topology(topology_name):\n", - " print(f\"Topology name: {topology_name}\")\n", - " df = pd.read_csv(f\"{base_folder}/resources/env/{topology_name}.txt\", delimiter=\";\")\n", - " display(HTML(df.to_html()))\n", - " \n", - "read_topology(\"multi\")\n", - "read_topology(\"single\")" - ] - }, - { - "cell_type": "markdown", - "id": "8f4fe54d", - "metadata": {}, - "source": [ - "## Traces" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "fd17d88a", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "<div>\n", - "<style scoped>\n", - " .dataframe tbody tr th:only-of-type {\n", - " vertical-align: middle;\n", - " }\n", - "\n", - " .dataframe tbody tr th {\n", - " vertical-align: top;\n", - " }\n", - "\n", - " .dataframe thead th {\n", - " text-align: right;\n", - " }\n", - "</style>\n", - "<table border=\"1\" class=\"dataframe\">\n", - " <thead>\n", - " <tr style=\"text-align: right;\">\n", - " <th></th>\n", - " <th>id</th>\n", - " <th>timestamp</th>\n", - " <th>duration</th>\n", - " <th>cpu_count</th>\n", - " <th>cpu_usage</th>\n", - " </tr>\n", - " </thead>\n", - " <tbody>\n", - " <tr>\n", - " <th>0</th>\n", - " <td>1019</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>1</td>\n", - " <td>0.000000</td>\n", - " </tr>\n", - " <tr>\n", - " <th>24015</th>\n", - " <td>1129</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>1</td>\n", - " <td>3.901332</td>\n", - " </tr>\n", - " <tr>\n", - " <th>34039</th>\n", - " <td>1138</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>1</td>\n", - " <td>20.799994</td>\n", - " </tr>\n", - " <tr>\n", - " <th>41348</th>\n", - " <td>1147</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>1</td>\n", - " <td>0.000000</td>\n", - " </tr>\n", - " <tr>\n", - " <th>47515</th>\n", - " <td>1152</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>1</td>\n", - " <td>0.000000</td>\n", - " </tr>\n", - " <tr>\n", - " <th>53661</th>\n", - " <td>116</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>4</td>\n", - " <td>158.003968</td>\n", - " </tr>\n", - " <tr>\n", - " <th>61559</th>\n", - " <td>141</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>2</td>\n", - " <td>56.569320</td>\n", - " </tr>\n", - " <tr>\n", - " <th>66380</th>\n", - " <td>190</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>8</td>\n", - " <td>14693.462756</td>\n", - " </tr>\n", - " <tr>\n", - " <th>73300</th>\n", - " <td>205</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>8</td>\n", - " <td>16185.864295</td>\n", - " </tr>\n", - " <tr>\n", - " <th>87698</th>\n", - " <td>244</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>8</td>\n", - " <td>95.333296</td>\n", - " </tr>\n", - " <tr>\n", - " <th>95284</th>\n", - " <td>272</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>8</td>\n", - " <td>164.666623</td>\n", - " </tr>\n", - " <tr>\n", - " <th>112192</th>\n", - " <td>323</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>2</td>\n", - " <td>152.533273</td>\n", - " </tr>\n", - " <tr>\n", - " <th>125958</th>\n", - " <td>378</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>2</td>\n", - " <td>76.266647</td>\n", - " </tr>\n", - " <tr>\n", - " <th>132745</th>\n", - " <td>379</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>2</td>\n", - " <td>109.199970</td>\n", - " </tr>\n", - " <tr>\n", - " <th>139492</th>\n", - " <td>449</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>4</td>\n", - " <td>154.266626</td>\n", - " </tr>\n", - " <tr>\n", - " <th>146840</th>\n", - " <td>463</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>4</td>\n", - " <td>131.733298</td>\n", - " </tr>\n", - " <tr>\n", - " <th>153699</th>\n", - " <td>466</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>4</td>\n", - " <td>131.733300</td>\n", - " </tr>\n", - " <tr>\n", - " <th>160537</th>\n", - " <td>467</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>4</td>\n", - " <td>185.466617</td>\n", - " </tr>\n", - " <tr>\n", - " <th>167694</th>\n", - " <td>501</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>4</td>\n", - " <td>157.733310</td>\n", - " </tr>\n", - " <tr>\n", - " <th>174746</th>\n", - " <td>506</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>4</td>\n", - " <td>183.733284</td>\n", - " </tr>\n", - " <tr>\n", - " <th>182064</th>\n", - " <td>550</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>1</td>\n", - " <td>1.733333</td>\n", - " </tr>\n", - " <tr>\n", - " <th>196282</th>\n", - " <td>607</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>1</td>\n", - " <td>247.866604</td>\n", - " </tr>\n", - " <tr>\n", - " <th>203796</th>\n", - " <td>626</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>4</td>\n", - " <td>10718.931688</td>\n", - " </tr>\n", - " <tr>\n", - " <th>206960</th>\n", - " <td>636</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>4</td>\n", - " <td>10781.331724</td>\n", - " </tr>\n", - " <tr>\n", - " <th>209842</th>\n", - " <td>677</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>2</td>\n", - " <td>181.999951</td>\n", - " </tr>\n", - " <tr>\n", - " <th>225939</th>\n", - " <td>740</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>32</td>\n", - " <td>2048.399624</td>\n", - " </tr>\n", - " <tr>\n", - " <th>234340</th>\n", - " <td>750</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>8</td>\n", - " <td>145.599961</td>\n", - " </tr>\n", - " <tr>\n", - " <th>252091</th>\n", - " <td>851</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>2</td>\n", - " <td>29.259993</td>\n", - " </tr>\n", - " <tr>\n", - " <th>256754</th>\n", - " <td>871</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>4</td>\n", - " <td>158.003974</td>\n", - " </tr>\n", - " <tr>\n", - " <th>265560</th>\n", - " <td>957</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>4</td>\n", - " <td>128.266613</td>\n", - " </tr>\n", - " <tr>\n", - " <th>268345</th>\n", - " <td>997</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>8</td>\n", - " <td>10235.198844</td>\n", - " </tr>\n", - " </tbody>\n", - "</table>\n", - "</div>" - ], - "text/plain": [ - " id timestamp duration cpu_count cpu_usage\n", - "0 1019 2013-08-12 13:40:46+00:00 300000 1 0.000000\n", - "24015 1129 2013-08-12 13:40:46+00:00 300000 1 3.901332\n", - "34039 1138 2013-08-12 13:40:46+00:00 300000 1 20.799994\n", - "41348 1147 2013-08-12 13:40:46+00:00 300000 1 0.000000\n", - "47515 1152 2013-08-12 13:40:46+00:00 300000 1 0.000000\n", - "53661 116 2013-08-12 13:40:46+00:00 300000 4 158.003968\n", - "61559 141 2013-08-12 13:40:46+00:00 300000 2 56.569320\n", - "66380 190 2013-08-12 13:40:46+00:00 300000 8 14693.462756\n", - "73300 205 2013-08-12 13:40:46+00:00 300000 8 16185.864295\n", - "87698 244 2013-08-12 13:40:46+00:00 300000 8 95.333296\n", - "95284 272 2013-08-12 13:40:46+00:00 300000 8 164.666623\n", - "112192 323 2013-08-12 13:40:46+00:00 300000 2 152.533273\n", - "125958 378 2013-08-12 13:40:46+00:00 300000 2 76.266647\n", - "132745 379 2013-08-12 13:40:46+00:00 300000 2 109.199970\n", - "139492 449 2013-08-12 13:40:46+00:00 300000 4 154.266626\n", - "146840 463 2013-08-12 13:40:46+00:00 300000 4 131.733298\n", - "153699 466 2013-08-12 13:40:46+00:00 300000 4 131.733300\n", - "160537 467 2013-08-12 13:40:46+00:00 300000 4 185.466617\n", - "167694 501 2013-08-12 13:40:46+00:00 300000 4 157.733310\n", - "174746 506 2013-08-12 13:40:46+00:00 300000 4 183.733284\n", - "182064 550 2013-08-12 13:40:46+00:00 300000 1 1.733333\n", - "196282 607 2013-08-12 13:40:46+00:00 300000 1 247.866604\n", - "203796 626 2013-08-12 13:40:46+00:00 300000 4 10718.931688\n", - "206960 636 2013-08-12 13:40:46+00:00 300000 4 10781.331724\n", - "209842 677 2013-08-12 13:40:46+00:00 300000 2 181.999951\n", - "225939 740 2013-08-12 13:40:46+00:00 300000 32 2048.399624\n", - "234340 750 2013-08-12 13:40:46+00:00 300000 8 145.599961\n", - "252091 851 2013-08-12 13:40:46+00:00 300000 2 29.259993\n", - "256754 871 2013-08-12 13:40:46+00:00 300000 4 158.003974\n", - "265560 957 2013-08-12 13:40:46+00:00 300000 4 128.266613\n", - "268345 997 2013-08-12 13:40:46+00:00 300000 8 10235.198844" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_trace = pd.read_parquet(f\"{base_folder}/resources/bitbrains-small/trace/trace.parquet\")\n", - "df_trace[df_trace[\"timestamp\"] == df_trace[\"timestamp\"].min()]" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "346f097f", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/html": [ - "<div>\n", - "<style scoped>\n", - " .dataframe tbody tr th:only-of-type {\n", - " vertical-align: middle;\n", - " }\n", - "\n", - " .dataframe tbody tr th {\n", - " vertical-align: top;\n", - " }\n", - "\n", - " .dataframe thead th {\n", - " text-align: right;\n", - " }\n", - "</style>\n", - "<table border=\"1\" class=\"dataframe\">\n", - " <thead>\n", - " <tr style=\"text-align: right;\">\n", - " <th></th>\n", - " <th>id</th>\n", - " <th>start_time</th>\n", - " <th>stop_time</th>\n", - " <th>cpu_count</th>\n", - " <th>cpu_capacity</th>\n", - " <th>mem_capacity</th>\n", - " </tr>\n", - " </thead>\n", - " <tbody>\n", - " <tr>\n", - " <th>0</th>\n", - " <td>1019</td>\n", - " <td>2013-08-12 13:35:46+00:00</td>\n", - " <td>2013-09-11 13:39:58+00:00</td>\n", - " <td>1</td>\n", - " <td>2926.000135</td>\n", - " <td>181352</td>\n", - " </tr>\n", - " <tr>\n", - " <th>1</th>\n", - " <td>1023</td>\n", - " <td>2013-08-12 13:35:46+00:00</td>\n", - " <td>2013-09-11 13:39:58+00:00</td>\n", - " <td>1</td>\n", - " <td>2925.999560</td>\n", - " <td>260096</td>\n", - " </tr>\n", - " <tr>\n", - " <th>2</th>\n", - " <td>1026</td>\n", - " <td>2013-08-12 13:35:46+00:00</td>\n", - " <td>2013-09-11 13:39:58+00:00</td>\n", - " <td>1</td>\n", - " <td>2925.999717</td>\n", - " <td>249972</td>\n", - " </tr>\n", - " <tr>\n", - " <th>3</th>\n", - " <td>1052</td>\n", - " <td>2013-08-29 14:38:12+00:00</td>\n", - " <td>2013-09-05 07:09:07+00:00</td>\n", - " <td>1</td>\n", - " <td>2926.000107</td>\n", - " <td>131245</td>\n", - " </tr>\n", - " <tr>\n", - " <th>4</th>\n", - " <td>1073</td>\n", - " <td>2013-08-21 11:07:12+00:00</td>\n", - " <td>2013-09-11 13:39:58+00:00</td>\n", - " <td>1</td>\n", - " <td>2599.999649</td>\n", - " <td>179306</td>\n", - " </tr>\n", - " </tbody>\n", - "</table>\n", - "</div>" - ], - "text/plain": [ - " id start_time stop_time cpu_count \\\n", - "0 1019 2013-08-12 13:35:46+00:00 2013-09-11 13:39:58+00:00 1 \n", - "1 1023 2013-08-12 13:35:46+00:00 2013-09-11 13:39:58+00:00 1 \n", - "2 1026 2013-08-12 13:35:46+00:00 2013-09-11 13:39:58+00:00 1 \n", - "3 1052 2013-08-29 14:38:12+00:00 2013-09-05 07:09:07+00:00 1 \n", - "4 1073 2013-08-21 11:07:12+00:00 2013-09-11 13:39:58+00:00 1 \n", - "\n", - " cpu_capacity mem_capacity \n", - "0 2926.000135 181352 \n", - "1 2925.999560 260096 \n", - "2 2925.999717 249972 \n", - "3 2926.000107 131245 \n", - "4 2599.999649 179306 " - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_meta = pd.read_parquet(f\"{base_folder}/resources/bitbrains-small/trace/meta.parquet\")\n", - "df_meta.head()" - ] - }, - { - "cell_type": "markdown", - "id": "13bf9fdb", - "metadata": {}, - "source": [ - "# Lets run this in OpenDC!" - ] - }, - { - "cell_type": "markdown", - "id": "c9766446", - "metadata": {}, - "source": [ - "## Resulting Files" - ] - }, - { - "cell_type": "code", - "execution_count": 89, - "id": "0d400ffd", - "metadata": {}, - "outputs": [], - "source": [ - "output_folder = f\"{base_folder}/output\"\n", - "workload = \"workload=bitbrains-small\"\n", - "seed = \"seed=0\"\n", - "\n", - "df_host_single = pd.read_parquet(f\"{output_folder}/host/topology=single/{workload}/{seed}/data.parquet\")\n", - "df_host_multi = pd.read_parquet(f\"{output_folder}/host/topology=multi/{workload}/{seed}/data.parquet\")\n", - "\n", - "df_server_single = pd.read_parquet(f\"{output_folder}/server/topology=single/{workload}/{seed}/data.parquet\")\n", - "df_server_multi = pd.read_parquet(f\"{output_folder}/server/topology=multi/{workload}/{seed}/data.parquet\")\n", - "\n", - "df_service_single = pd.read_parquet(f\"{output_folder}/service/topology=single/{workload}/{seed}/data.parquet\")\n", - "df_service_multi = pd.read_parquet(f\"{output_folder}/service/topology=multi/{workload}/{seed}/data.parquet\")\n", - "\n", - "def add_absolute_timestamp(df, start_dt):\n", - " df[\"absolute_timestamp\"] = start_dt + (df[\"timestamp\"] - df[\"timestamp\"].min())\n", - "\n", - "add_absolute_timestamp(df_host_single, df_meta[\"start_time\"].min())\n", - "add_absolute_timestamp(df_host_single, df_meta[\"start_time\"].min())\n", - "\n", - "add_absolute_timestamp(df_server_single, df_meta[\"start_time\"].min())\n", - "add_absolute_timestamp(df_server_multi, df_meta[\"start_time\"].min())\n", - "\n", - "add_absolute_timestamp(df_service_single, df_meta[\"start_time\"].min())\n", - "add_absolute_timestamp(df_service_multi, df_meta[\"start_time\"].min())" - ] - }, - { - "cell_type": "code", - "execution_count": 90, - "id": "a9a61332", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1080" - ] - }, - "execution_count": 90, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(df_service_single)" - ] - }, - { - "cell_type": "code", - "execution_count": 91, - "id": "e1d01f85", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1970-01-01 02:00:00+00:00 1\n", - "1970-03-02 12:00:00+00:00 1\n", - "1970-03-01 08:00:00+00:00 1\n", - "1970-03-01 10:00:00+00:00 1\n", - "1970-03-01 12:00:00+00:00 1\n", - " ..\n", - "1970-01-31 12:00:00+00:00 1\n", - "1970-01-31 14:00:00+00:00 1\n", - "1970-01-31 16:00:00+00:00 1\n", - "1970-01-31 18:00:00+00:00 1\n", - "1970-04-01 00:00:00+00:00 1\n", - "Name: timestamp, Length: 1080, dtype: int64" - ] - }, - "execution_count": 91, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_host_single.timestamp.value_counts()" - ] - }, - { - "cell_type": "code", - "execution_count": 103, - "id": "5b36f79c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([50, 49, 47, 46, 45, 44, 34, 16, 14, 13, 12, 11, 10])" - ] - }, - "execution_count": 103, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_server_single.timestamp.value_counts().unique()" - ] - }, - { - "cell_type": "code", - "execution_count": 93, - "id": "699268f3", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1970-01-01 02:00:00+00:00 1\n", - "1970-03-02 12:00:00+00:00 1\n", - "1970-03-01 08:00:00+00:00 1\n", - "1970-03-01 10:00:00+00:00 1\n", - "1970-03-01 12:00:00+00:00 1\n", - " ..\n", - "1970-01-31 12:00:00+00:00 1\n", - "1970-01-31 14:00:00+00:00 1\n", - "1970-01-31 16:00:00+00:00 1\n", - "1970-01-31 18:00:00+00:00 1\n", - "1970-04-01 00:00:00+00:00 1\n", - "Name: timestamp, Length: 1080, dtype: int64" - ] - }, - "execution_count": 93, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_service_single.timestamp.value_counts()" - ] - }, - { - "cell_type": "code", - "execution_count": 104, - "id": "a32f9d66", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([44, 45, 46, 47, 49, 50, 34, 16, 14, 13, 12, 11, 10], dtype=int32)" - ] - }, - "execution_count": 104, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(df_service_single.servers_active + df_service_single.servers_pending).unique() " - ] - }, - { - "cell_type": "code", - "execution_count": 102, - "id": "fe5cc9c0", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 102, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "set(d1) == set(d2)" - ] - }, - { - "cell_type": "markdown", - "id": "09d31c91", - "metadata": {}, - "source": [ - "## Power Usage" - ] - }, - { - "cell_type": "code", - "execution_count": 66, - "id": "82f0a24a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "single topology: 2227322672.880138\n", - "multi topology: 5865185988.6738405\n" - ] - } - ], - "source": [ - "print(f\"single topology: {df_host_single.power_total.sum()}\")\n", - "print(f\"multi topology: {df_host_multi.power_total.sum()}\")" - ] - }, - { - "cell_type": "markdown", - "id": "7ab3357d", - "metadata": {}, - "source": [ - "## CPU usage" - ] - }, - { - "cell_type": "code", - "execution_count": 67, - "id": "e94db3a6", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "single topology: 0.575979511557793\n", - "multi topology: 0.34249306908883387\n" - ] - } - ], - "source": [ - "print(f\"single topology: {df_host_single.cpu_utilization.mean()}\")\n", - "print(f\"multi topology: {df_host_multi.cpu_utilization.mean()}\")" - ] - }, - { - "cell_type": "markdown", - "id": "e000a260", - "metadata": {}, - "source": [ - "## CPU utilization" - ] - }, - { - "cell_type": "code", - "execution_count": 68, - "id": "8d7daa45", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "single topology: 0.575979511557793\n", - "multi topology: 0.34249306908883387\n" - ] - } - ], - "source": [ - "print(f\"single topology: {df_host_single.cpu_utilization.mean()}\")\n", - "print(f\"multi topology: {df_host_multi.cpu_utilization.mean()}\")" - ] - }, - { - "cell_type": "markdown", - "id": "ad97741c", - "metadata": {}, - "source": [ - "## Plotting Results" - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "id": "5df8f9aa", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGwCAYAAABVdURTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAwF0lEQVR4nO3de1xVdb7/8fcG3CByUxFQZydeMDMvlKjH2ykLo2xMa87EaImQWR21scgupqOWFV45lDkxOSp21XFST6dMU5JTXiZNRZtS8hJhCYiVoHgEhPX7w597IkDZmw0blq/n47Efj/Z3f9dan/XN2m+/67v2shiGYQgAAMAkPNxdAAAAgCsRbgAAgKkQbgAAgKkQbgAAgKkQbgAAgKkQbgAAgKkQbgAAgKl4ubuAhlZRUaETJ07I399fFovF3eUAAIBaMAxDZ86cUbt27eThcfm5masu3Jw4cUI2m83dZQAAACccP35cv/nNby7b56oLN/7+/pIuDk5AQICbqwEAALVRVFQkm81m/x6/nKsu3Fy6FBUQEEC4AQCgianNkhIWFAMAAFMh3AAAAFMh3AAAAFO56tbcAADgrPLycpWVlbm7DNOyWq1XvM27Ngg3AABcgWEYysvL0+nTp91diql5eHioY8eOslqtddoP4QYAgCu4FGxCQkLk6+vLj8DWg0s/spubm6trrrmmTmNMuAEA4DLKy8vtwaZ169buLsfU2rRpoxMnTujChQtq1qyZ0/thQTEAAJdxaY2Nr6+vmysxv0uXo8rLy+u0H8INAAC1wKWo+ueqMSbcAAAAUyHcAAAAU2FBMQAAThqftrtBj7csvm+DHq86s2fP1vr165WZmVljn+zsbHXs2FH79u1TZGRkg9V2CeEGAAA4LT4+XqdPn9b69evtbTabTbm5uQoODnZLTYQbAADgUp6engoLC3Pb8VlzAwCASd1888169NFH9dhjj6lly5YKDQ3V0qVLVVxcrISEBPn7+6tLly766KOPJElpaWkKCgqqtI/169fXeBfT7NmztXLlSv33f/+3LBaLLBaLMjIylJ2dLYvFctlLV/WJmRsXq8v118ZwLRUAYC4rV67UU089pV27dmn16tX6z//8T61bt0533323nn32Wf3Xf/2Xxo4dq5ycHIf3PXXqVB08eFBFRUVasWKFJKlVq1Y6ceKEq0/DIczcAABgYr1799aMGTMUERGhadOmycfHR8HBwZowYYIiIiI0c+ZM/fjjjzpw4IDD+/bz81Pz5s3l7e2tsLAwhYWF1fm5UK5AuAEAwMR69epl/2dPT0+1bt1aPXv2tLeFhoZKkk6ePNngtdUXwg0AACb262c0WSyWSm2X1tNUVFTIw8NDhmFU6n/p8RNNCeEGAABIuvjgyjNnzqi4uNjedqVFwVartc7PgnI1wg0AAJAk9e/fX76+vnr22Wd19OhRvfPOO0pLS7vsNuHh4Tpw4ICysrJ06tSpRjHTw91SAAA4yWx3ubZq1UpvvfWWnnzySS1dulS33nqrZs+erYceeqjGbSZMmKCMjAxFRUXp7Nmz2rp1q8LDwxuu6GpYjF9fXDO5oqIiBQYGqrCwUAEBAS7fP7eCA4C5nD9/Xt9++606duwoHx8fd5djapcba0e+v7ksBQAATIVwAwAATIVwAwAATIVwAwAATIVwAwAATIVwAwAATIVwAwAATIVwAwAATIVwAwDAVSY+Pl6jRo1y6T6zs7NlsViu+CyqhsDjFwAAcNY7sQ17vDGrXbKbl19+ucrTv82EcAMAwFUmMDDQ3SXUKy5LAQBgUn//+9/Vs2dPNW/eXK1bt1Z0dLSKi4urXJa6+eab9cc//lFPPfWUWrVqpbCwMM2ePbvSvg4dOqTBgwfLx8dH3bt315YtW2SxWLR+/foaj//Pf/5Td9xxh/z8/BQaGqqxY8fq1KlT9XOyv0C4AQDAhHJzczV69Gg98MADOnjwoDIyMnTPPffUeDlq5cqVatGihT7//HPNnz9fzz//vDZv3ixJKi8v16hRo+Tr66vPP/9cr7/+uqZPn37Z458+fVq33HKLbrjhBn3xxRfauHGj8vPzde+997r8XH+Ny1IAAJhQbm6uLly4oHvuuUcdOnSQJPXs2bPG/r169dKsWbMkSREREXr11VeVnp6uYcOGafPmzTp69KgyMjIUFhYmSXrxxRc1bNiwGvf36quv6oYbbtBLL71kb1u+fLlsNpu++eYbde3a1RWnWS1mbgAAMKHevXvr1ltvVc+ePfX73/9eS5cu1c8//1xj/169elV637ZtW508eVKSlJWVJZvNZg82ktSvX7/LHn///v3aunWr/Pz87K9u3bpJko4ePersadUKMzcAAJiQp6enNm/erB07dujjjz/W4sWLNX36dH3++efV9m/WrFml9xaLRRUVFU4f/+zZsxoxYoTmzZtX5bO2bds6vd/aINwAAGBSFotFgwYN0qBBgzRz5kx16NBB69atc3g/1157rY4fP678/HyFhoZKknbv3n3ZbW688Ua99957Cg8Pl5dXw8YNLksBAGBCn3/+uV566SV98cUXysnJ0dq1a1VQUKDrrrvO4X0NGzZMnTt31rhx43TgwAFt375dM2bMkHQxQFVn0qRJ+umnnzR69Gjt3r1bR48e1aZNm5SQkKDy8vI6nduVEG4AADChgIAAffrppxo+fLi6du2qGTNmaNGiRbrjjjsc3penp6fWr1+vs2fPqm/fvnrwwQftd0v5+PhUu027du20fft2lZeX67bbblPPnj312GOPKSgoSB4e9Rs/LIaZf6KwGkVFRQoMDFRhYaECAgJcvv/xaZefprucZfF9XVgJAMAVzp8/r2+//VYdO3as8Yv8arR9+3YNHjxYR44cUefOnV2yz8uNtSPf36y5AQAAV7Ru3Tr5+fkpIiJCR44c0ZQpUzRo0CCXBRtXItwAAIArOnPmjJ5++mnl5OQoODhY0dHRWrRokbvLqhbhBgAAXFFcXJzi4uLcXUatsKAYAACYCuEGAIBauMruv3ELV40x4QYAgMu49Mu9586dc3Ml5ldaWirp4q3nddEo1twsWbJECxYsUF5ennr37q3Fixdf8ZkVkrRq1SqNHj1aI0eOvOwj1wEAcJanp6eCgoLsz1ny9fWt8Yfr4LyKigoVFBTI19e3zr9o7PZws3r1aiUmJio1NVX9+/dXSkqKYmJilJWVpZCQkBq3y87O1tSpUzVkyJAGrBYAcDW69MDISwEH9cPDw0PXXHNNncOj28NNcnKyJkyYoISEBElSamqqPvzwQy1fvlzPPPNMtduUl5frvvvu03PPPafPPvtMp0+fbsCKAQBXG4vForZt2yokJERlZWXuLse0rFarS3692K3hprS0VHv27NG0adPsbR4eHoqOjtbOnTtr3O75559XSEiIxo8fr88+++yyxygpKVFJSYn9fVFRUd0LBwBclTw9Peu8HgT1z60Lik+dOqXy8nL7E0YvCQ0NVV5eXrXbbNu2TcuWLdPSpUtrdYykpCQFBgbaXzabrc51AwCAxqtJ3S115swZjR07VkuXLlVwcHCttpk2bZoKCwvtr+PHj9dzlQAAwJ3celkqODhYnp6eys/Pr9Sen59vX7z1S0ePHlV2drZGjBhhb6uoqJAkeXl5KSsrq8ozLry9veXt7V0P1QMAgMbIrTM3VqtVffr0UXp6ur2toqJC6enpGjBgQJX+3bp105dffqnMzEz766677tLQoUOVmZnJJScAAOD+u6USExM1btw4RUVFqV+/fkpJSVFxcbH97qm4uDi1b99eSUlJ8vHxUY8ePSptHxQUJElV2gEAwNXJ7eEmNjZWBQUFmjlzpvLy8hQZGamNGzfaFxnn5OS45LYwAABwdbAYV9nDMoqKihQYGKjCwkIFBAS4fP/j03Y7ve2y+L4urAQAAPNw5PubKREAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqhBsAAGAqjSLcLFmyROHh4fLx8VH//v21a9euGvuuXbtWUVFRCgoKUosWLRQZGak333yzAasFAACNmdvDzerVq5WYmKhZs2Zp79696t27t2JiYnTy5Mlq+7dq1UrTp0/Xzp07deDAASUkJCghIUGbNm1q4MoBAEBj5PZwk5ycrAkTJighIUHdu3dXamqqfH19tXz58mr733zzzbr77rt13XXXqXPnzpoyZYp69eqlbdu2NXDlAACgMXJruCktLdWePXsUHR1tb/Pw8FB0dLR27tx5xe0Nw1B6erqysrL07//+79X2KSkpUVFRUaUXAAAwL7eGm1OnTqm8vFyhoaGV2kNDQ5WXl1fjdoWFhfLz85PVatWdd96pxYsXa9iwYdX2TUpKUmBgoP1ls9lceg4AAKBxcftlKWf4+/srMzNTu3fv1osvvqjExERlZGRU23fatGkqLCy0v44fP96wxQIAgAbl5c6DBwcHy9PTU/n5+ZXa8/PzFRYWVuN2Hh4e6tKliyQpMjJSBw8eVFJSkm6++eYqfb29veXt7e3SugEAQOPl1pkbq9WqPn36KD093d5WUVGh9PR0DRgwoNb7qaioUElJSX2UCAAAmhi3ztxIUmJiosaNG6eoqCj169dPKSkpKi4uVkJCgiQpLi5O7du3V1JSkqSLa2iioqLUuXNnlZSUaMOGDXrzzTf12muvufM0AABAI+H2cBMbG6uCggLNnDlTeXl5ioyM1MaNG+2LjHNycuTh8a8JpuLiYk2cOFHff/+9mjdvrm7duumtt95SbGysu04BAAA0IhbDMAx3F9GQioqKFBgYqMLCQgUEBLh8/+PTdju97bL4vi6sBAAA83Dk+7tJ3i0FAABQE8INAAAwFbevuQEAAI3QO3VYyzpmtevqcAIzNwAAwFQINwAAwFQINwAAwFQINwAAwFQINwAAwFQINwAAwFQINwAAwFQINwAAwFQINwAAwFScCjfHjh1zdR0AAAAu4VS46dKli4YOHaq33npL58+fd3VNAAAATnMq3Ozdu1e9evVSYmKiwsLC9PDDD2vXrl2urg0AAMBhToWbyMhIvfzyyzpx4oSWL1+u3NxcDR48WD169FBycrIKCgpcXScAAECt1GlBsZeXl+655x6tWbNG8+bN05EjRzR16lTZbDbFxcUpNzfXVXUCAADUSp3CzRdffKGJEyeqbdu2Sk5O1tSpU3X06FFt3rxZJ06c0MiRI11VJwAAQK14ObNRcnKyVqxYoaysLA0fPlxvvPGGhg8fLg+Pi1mpY8eOSktLU3h4uCtrBQAAuCKnws1rr72mBx54QPHx8Wrbtm21fUJCQrRs2bI6FQcAAOAop8LN4cOHr9jHarVq3LhxzuweAADAaU6tuVmxYoXWrFlTpX3NmjVauXJlnYsCAABwllPhJikpScHBwVXaQ0JC9NJLL9W5KAAAAGc5FW5ycnLUsWPHKu0dOnRQTk5OnYsCAABwllPhJiQkRAcOHKjSvn//frVu3brORQEAADjLqXAzevRo/fGPf9TWrVtVXl6u8vJyffLJJ5oyZYr+8Ic/uLpGAACAWnPqbqk5c+YoOztbt956q7y8Lu6ioqJCcXFxrLkBAABu5VS4sVqtWr16tebMmaP9+/erefPm6tmzpzp06ODq+gAAABziVLi5pGvXruratauragEAAKgzp8JNeXm50tLSlJ6erpMnT6qioqLS55988olLigMAAHCUU+FmypQpSktL05133qkePXrIYrG4ui4AAACnOBVuVq1apb/97W8aPny4q+sBAACoE6duBbdarerSpYurawEAAKgzp8LNE088oZdfflmGYbi6HgAAgDpx6rLUtm3btHXrVn300Ue6/vrr1axZs0qfr1271iXFAQAAOMqpcBMUFKS7777b1bUAAADUmVPhZsWKFa6uAwAAwCWcWnMjSRcuXNCWLVv0l7/8RWfOnJEknThxQmfPnnVZcQAAAI5yaubmu+++0+23366cnByVlJRo2LBh8vf317x581RSUqLU1FRX1wkAAFArTs3cTJkyRVFRUfr555/VvHlze/vdd9+t9PR0lxUHAADgKKdmbj777DPt2LFDVqu1Unt4eLh++OEHlxQGAADgDKdmbioqKlReXl6l/fvvv5e/v3+diwIAAHCWU+HmtttuU0pKiv29xWLR2bNnNWvWLB7JAAAA3Mqpy1KLFi1STEyMunfvrvPnz2vMmDE6fPiwgoOD9e6777q6RgAAgFpzKtz85je/0f79+7Vq1SodOHBAZ8+e1fjx43XfffdVWmAMAADQ0JwKN5Lk5eWl+++/35W1AAAA1JlT4eaNN9647OdxcXFOFQMAAFBXToWbKVOmVHpfVlamc+fOyWq1ytfXl3ADAADcxqm7pX7++edKr7NnzyorK0uDBw9mQTEAAHArp58t9WsRERGaO3dulVkdAACAhuSycCNdXGR84sQJV+4SAADAIU6tuXn//fcrvTcMQ7m5uXr11Vc1aNAglxQGAADgDKfCzahRoyq9t1gsatOmjW655RYtWrTIFXUBAAA4xalwU1FR4eo6AAAAXMKla24AAADczamZm8TExFr3TU5OduYQAAAATnEq3Ozbt0/79u1TWVmZrr32WknSN998I09PT9144432fhaLxTVVAgAA1JJT4WbEiBHy9/fXypUr1bJlS0kXf9gvISFBQ4YM0RNPPOHSIgEAAGrLqTU3ixYtUlJSkj3YSFLLli31wgsvcLcUAABwK6fCTVFRkQoKCqq0FxQU6MyZM3UuCgAAwFlOhZu7775bCQkJWrt2rb7//nt9//33eu+99zR+/Hjdc889rq4RAACg1pxac5OamqqpU6dqzJgxKisru7gjLy+NHz9eCxYscGmBAAAAjnAq3Pj6+urPf/6zFixYoKNHj0qSOnfurBYtWri0OAAAAEfV6Uf8cnNzlZubq4iICLVo0UKGYbiqLgAAAKc4FW5+/PFH3XrrreratauGDx+u3NxcSdL48eO5DRwAALiVU+Hm8ccfV7NmzZSTkyNfX197e2xsrDZu3Oiy4gAAABzl1Jqbjz/+WJs2bdJvfvObSu0RERH67rvvXFIYAACAM5yauSkuLq40Y3PJTz/9JG9v7zoXBQAA4Cynws2QIUP0xhtv2N9bLBZVVFRo/vz5Gjp0qMP7W7JkicLDw+Xj46P+/ftr165dNfZdunSphgwZopYtW6ply5aKjo6+bH8AAHB1cSrczJ8/X6+//rruuOMOlZaW6qmnnlKPHj306aefat68eQ7ta/Xq1UpMTNSsWbO0d+9e9e7dWzExMTp58mS1/TMyMjR69Ght3bpVO3fulM1m02233aYffvjBmVMBAAAm41S46dGjh7755hsNHjxYI0eOVHFxse655x7t27dPnTt3dmhfycnJmjBhghISEtS9e3elpqbK19dXy5cvr7b/22+/rYkTJyoyMlLdunXTX//6V1VUVCg9Pd2ZUwEAACbj8ILisrIy3X777UpNTdX06dPrdPDS0lLt2bNH06ZNs7d5eHgoOjpaO3furNU+zp07p7KyMrVq1araz0tKSlRSUmJ/X1RUVKeaAQBA4+bwzE2zZs104MABlxz81KlTKi8vV2hoaKX20NBQ5eXl1WofTz/9tNq1a6fo6OhqP09KSlJgYKD9ZbPZ6lw3AABovJy6LHX//fdr2bJlrq7FYXPnztWqVau0bt06+fj4VNtn2rRpKiwstL+OHz/ewFUCAICG5NTv3Fy4cEHLly/Xli1b1KdPnyrPlEpOTq7VfoKDg+Xp6an8/PxK7fn5+QoLC7vstgsXLtTcuXO1ZcsW9erVq8Z+3t7e3J4OAMBVxKFwc+zYMYWHh+uf//ynbrzxRknSN998U6mPxWKp9f6sVqv69Omj9PR0jRo1SpLsi4MnT55c43bz58/Xiy++qE2bNikqKsqRUwAAACbnULiJiIhQbm6utm7dKuni4xZeeeWVKmtmHJGYmKhx48YpKipK/fr1U0pKioqLi5WQkCBJiouLU/v27ZWUlCRJmjdvnmbOnKl33nlH4eHh9rU5fn5+8vPzc7oOAABgDg6Fm18/9fujjz5ScXFxnQqIjY1VQUGBZs6cqby8PEVGRmrjxo32wJSTkyMPj38tDXrttddUWlqq//iP/6i0n1mzZmn27Nl1qgUAADR9Tq25ueTXYcdZkydPrvEyVEZGRqX32dnZLjkmAAAwJ4fulrJYLFXW1DiyxgYAAKC+OXxZKj4+3n730fnz5/XII49UuVtq7dq1rqsQAADAAQ6Fm3HjxlV6f//997u0GAAAgLpyKNysWLGivuoAAABwCad+oRgAAKCxItwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABT8XJ3AQAAoGbj03Y7ve2y+L4urKTpYOYGAACYCuEGAACYCuEGAACYCuEGAACYCuEGAACYCuEGAACYCuEGAACYCuEGAACYCuEGAACYCuEGAACYCuEGAACYCuEGAACYCuEGAACYCuEGAACYCuEGAACYCuEGAACYCuEGAACYCuEGAACYCuEGAACYCuEGAACYCuEGAACYitvDzZIlSxQeHi4fHx/1799fu3btqrHvV199pd/97ncKDw+XxWJRSkpKwxUKAACaBLeGm9WrVysxMVGzZs3S3r171bt3b8XExOjkyZPV9j937pw6deqkuXPnKiwsrIGrBQAATYFbw01ycrImTJighIQEde/eXampqfL19dXy5cur7d+3b18tWLBAf/jDH+Tt7V2rY5SUlKioqKjSCwAAmJfbwk1paan27Nmj6OjofxXj4aHo6Gjt3LnTZcdJSkpSYGCg/WWz2Vy2bwAA0Pi4LdycOnVK5eXlCg0NrdQeGhqqvLw8lx1n2rRpKiwstL+OHz/usn0DAIDGx8vdBdQ3b2/vWl/CAgAATZ/bZm6Cg4Pl6emp/Pz8Su35+fksFgYAAE5zW7ixWq3q06eP0tPT7W0VFRVKT0/XgAED3FUWAABo4tx6WSoxMVHjxo1TVFSU+vXrp5SUFBUXFyshIUGSFBcXp/bt2yspKUnSxUXIX3/9tf2ff/jhB2VmZsrPz09dunRx23kAAIDGw63hJjY2VgUFBZo5c6by8vIUGRmpjRs32hcZ5+TkyMPjX5NLJ06c0A033GB/v3DhQi1cuFA33XSTMjIyGrp8AADQCLl9QfHkyZM1efLkaj/7dWAJDw+XYRgNUBUAAGiq3P74BQAAAFci3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFPxcncBAACgfoxP2+30tsusLiykgTFzAwAATIVwAwAATIVwAwAATIVwAwAATIVwAwAATIVwAwAATIVwAwAATIVwAwAATIVwAwAATIVfKG5M3ol1ftsxq11XBwAATRgzNwAAwFQINwAAwFS4LAWYXV0ud9YFl0oBuAnhBmgK3BVQAKAJ4rIUAAAwFWZuXOzR/BnOb2wLclkdAABcrZi5AQAApkK4AQAApsJlKdTJ+LTdTm+7LL6vCysBAOAiZm4AAICpEG4AAICpcFkKAIBGrC534S4OfcGFlTQdhBuzaIIP3WS9DgA0XpnHTzu9baTLqnAO4QZA49MEwzqAxoNwAzSUq+0RClfb+QJoNFhQDAAATIVwAwAATIXLUgAA1Dcu0zYoZm4AAICpEG4AAICpEG4AAICpEG4AAICpsKAYTRK/bowa8QOAwFWPmRsAAGAqzNw0InV6joctyGV1AADQlBFuAACoZ3X5yyscx2UpAABgKszcAI7gV0YBoNFj5gYAAJgK4QYAAJgKl6Vw1anTb+RYXVgIAKBeEG4A4BJ+ABAwBcINrjqP5s9wfmN+TwgAGj3CDdymLiFjcegLLqwEAGAmLCgGAACmwswN6rTAtk6XeJogHpEBAI0f4QYAgFrInBfj7hJQS4QbAHAF7rQCGg3CDZqkq+1yWF1wKa0JqEMwqtO/36c3Ob0tYQ6NGeHGJOryP7hHRVBA40IgA1zjav2LIOEGQL2oS0Bx13GvumDURB8EW6dfGY/v68JK0Fg1inCzZMkSLViwQHl5eerdu7cWL16sfv361dh/zZo1+tOf/qTs7GxFRERo3rx5Gj58eANWDFwd3BVQ0PjV6c9GXRfm1uF3rlgUfHVwe7hZvXq1EhMTlZqaqv79+yslJUUxMTHKyspSSEhIlf47duzQ6NGjlZSUpN/+9rd65513NGrUKO3du1c9evRwwxkAtcOMQuPnrn9HTXGWy52u1kstqD2LYRiGOwvo37+/+vbtq1dffVWSVFFRIZvNpkcffVTPPPNMlf6xsbEqLi7WBx98YG/7t3/7N0VGRio1NfWKxysqKlJgYKAKCwsVEBDguhP5//hbAQDgalenxeo1cOT7260zN6WlpdqzZ4+mTZtmb/Pw8FB0dLR27txZ7TY7d+5UYmJipbaYmBitX7++2v4lJSUqKSmxvy8sLJR0cZDqw9nzF+plvwAANBX18R17aZ+1mZNxa7g5deqUysvLFRoaWqk9NDRUhw4dqnabvLy8avvn5eVV2z8pKUnPPfdclXabzeZk1QAA4LJmB9bbrs+cOaPAwMvv3+1rburbtGnTKs30VFRU6KefflLr1q1lsVhceqyioiLZbDYdP368Xi554SLGuWEwzg2DcW44jHXDqK9xNgxDZ86cUbt27a7Y163hJjg4WJ6ensrPz6/Unp+fr7CwsGq3CQsLc6i/t7e3vL29K7UFBQU5X3QtBAQE8B9OA2CcGwbj3DAY54bDWDeM+hjnK83YXOLWp4JbrVb16dNH6enp9raKigqlp6drwIAB1W4zYMCASv0lafPmzTX2BwAAVxe3X5ZKTEzUuHHjFBUVpX79+iklJUXFxcVKSEiQJMXFxal9+/ZKSkqSJE2ZMkU33XSTFi1apDvvvFOrVq3SF198oddff92dpwEAABoJt4eb2NhYFRQUaObMmcrLy1NkZKQ2btxoXzSck5MjD49/TTANHDhQ77zzjmbMmKFnn31WERERWr9+faP4jRtvb2/NmjWrymUwuBbj3DAY54bBODccxrphNIZxdvvv3AAAALiSW9fcAAAAuBrhBgAAmArhBgAAmArhBgAAmArhxkFLlixReHi4fHx81L9/f+3ateuy/desWaNu3brJx8dHPXv21IYNGxqo0qbNkXFeunSphgwZopYtW6ply5aKjo6+4r8XXOTon+dLVq1aJYvFolGjRtVvgSbh6DifPn1akyZNUtu2beXt7a2uXbvy/45acHScU1JSdO2116p58+ay2Wx6/PHHdf78+Qaqtmn69NNPNWLECLVr104Wi6XG5zr+UkZGhm688UZ5e3urS5cuSktLq/c6ZaDWVq1aZVitVmP58uXGV199ZUyYMMEICgoy8vPzq+2/fft2w9PT05g/f77x9ddfGzNmzDCaNWtmfPnllw1cedPi6DiPGTPGWLJkibFv3z7j4MGDRnx8vBEYGGh8//33DVx50+LoOF/y7bffGu3btzeGDBlijBw5smGKbcIcHeeSkhIjKirKGD58uLFt2zbj22+/NTIyMozMzMwGrrxpcXSc3377bcPb29t4++23jW+//dbYtGmT0bZtW+Pxxx9v4Mqblg0bNhjTp0831q5da0gy1q1bd9n+x44dM3x9fY3ExETj66+/NhYvXmx4enoaGzdurNc6CTcO6NevnzFp0iT7+/LycqNdu3ZGUlJStf3vvfde484776zU1r9/f+Phhx+u1zqbOkfH+dcuXLhg+Pv7GytXrqyvEk3BmXG+cOGCMXDgQOOvf/2rMW7cOMJNLTg6zq+99prRqVMno7S0tKFKNAVHx3nSpEnGLbfcUqktMTHRGDRoUL3WaSa1CTdPPfWUcf3111dqi42NNWJiYuqxMsPgslQtlZaWas+ePYqOjra3eXh4KDo6Wjt37qx2m507d1bqL0kxMTE19odz4/xr586dU1lZmVq1alVfZTZ5zo7z888/r5CQEI0fP74hymzynBnn999/XwMGDNCkSZMUGhqqHj166KWXXlJ5eXlDld3kODPOAwcO1J49e+yXro4dO6YNGzZo+PDhDVLz1cJd34Nu/4XipuLUqVMqLy+3/3LyJaGhoTp06FC12+Tl5VXbPy8vr97qbOqcGedfe/rpp9WuXbsq/0HhX5wZ523btmnZsmXKzMxsgArNwZlxPnbsmD755BPdd9992rBhg44cOaKJEyeqrKxMs2bNaoiymxxnxnnMmDE6deqUBg8eLMMwdOHCBT3yyCN69tlnG6Lkq0ZN34NFRUX6v//7PzVv3rxejsvMDUxl7ty5WrVqldatWycfHx93l2MaZ86c0dixY7V06VIFBwe7uxxTq6ioUEhIiF5//XX16dNHsbGxmj59ulJTU91dmqlkZGTopZde0p///Gft3btXa9eu1Ycffqg5c+a4uzS4ADM3tRQcHCxPT0/l5+dXas/Pz1dYWFi124SFhTnUH86N8yULFy7U3LlztWXLFvXq1as+y2zyHB3no0ePKjs7WyNGjLC3VVRUSJK8vLyUlZWlzp0712/RTZAzf57btm2rZs2aydPT09523XXXKS8vT6WlpbJarfVac1PkzDj/6U9/0tixY/Xggw9Kknr27Kni4mI99NBDmj59eqVnGsJ5NX0PBgQE1NusjcTMTa1ZrVb16dNH6enp9raKigqlp6drwIAB1W4zYMCASv0lafPmzTX2h3PjLEnz58/XnDlztHHjRkVFRTVEqU2ao+PcrVs3ffnll8rMzLS/7rrrLg0dOlSZmZmy2WwNWX6T4cyf50GDBunIkSP28ChJ33zzjdq2bUuwqYEz43zu3LkqAeZSoDR45KLLuO17sF6XK5vMqlWrDG9vbyMtLc34+uuvjYceesgICgoy8vLyDMMwjLFjxxrPPPOMvf/27dsNLy8vY+HChcbBgweNWbNmcSt4LTg6znPnzjWsVqvx97//3cjNzbW/zpw5465TaBIcHedf426p2nF0nHNycgx/f39j8uTJRlZWlvHBBx8YISEhxgsvvOCuU2gSHB3nWbNmGf7+/sa7775rHDt2zPj444+Nzp07G/fee6+7TqFJOHPmjLFv3z5j3759hiQjOTnZ2Ldvn/Hdd98ZhmEYzzzzjDF27Fh7/0u3gj/55JPGwYMHjSVLlnAreGO0ePFi45prrjGsVqvRr18/4x//+If9s5tuuskYN25cpf5/+9vfjK5duxpWq9W4/vrrjQ8//LCBK26aHBnnDh06GJKqvGbNmtXwhTcxjv55/iXCTe05Os47duww+vfvb3h7exudOnUyXnzxRePChQsNXHXT48g4l5WVGbNnzzY6d+5s+Pj4GDabzZg4caLx888/N3zhTcjWrVur/f/tpbEdN26ccdNNN1XZJjIy0rBarUanTp2MFStW1HudFsNg/g0AAJgHa24AAICpEG4AAICpEG4AAICpEG4AAICpEG4AAICpEG4AAICpEG4AAICpEG4AAICpEG4AmEJ4eLhSUlLs7y0Wi9avXy9Jys7OlsViUWZmZr3WcPPNN+uxxx6r12MAuDLCDYBK8vLy9Oijj6pTp07y9vaWzWbTiBEjKj38Ljw8XBaLRRaLRS1atNCNN96oNWvW2D+Pj4/XqFGjquw7IyNDFotFp0+fdrq+tLQ0BQUFVWnfvXu3HnrooWq3sdlsys3NVY8ePZw+7i/VdB5r167VnDlzXHIMAM4j3ACwy87OVp8+ffTJJ59owYIF+vLLL7Vx40YNHTpUkyZNqtT3+eefV25urvbt26e+ffsqNjZWO3bscFPlUps2beTr61vtZ56engoLC5OXl1e91tCqVSv5+/vX6zEAXBnhBoDdxIkTZbFYtGvXLv3ud79T165ddf311ysxMVH/+Mc/KvX19/dXWFiYunbtqiVLlqh58+b6n//5nzodv7oZkczMTFksFmVnZysjI0MJCQkqLCy0zxzNnj1bUtXLUr/068tS8fHx9u1/+crIyJAkvfnmm4qKirKf45gxY3Ty5En7voYOHSpJatmypSwWi+Lj4yVVvSz1888/Ky4uTi1btpSvr6/uuOMOHT582P75pVmoTZs26brrrpOfn59uv/125ebm1mkcgasd4QaAJOmnn37Sxo0bNWnSJLVo0aLK59VdCrrEy8tLzZo1U2lpaT1WKA0cOFApKSkKCAhQbm6ucnNzNXXqVIf38/LLL9u3z83N1ZQpUxQSEqJu3bpJksrKyjRnzhzt379f69evV3Z2tj3A2Gw2vffee5KkrKws5ebm6uWXX672OPHx8friiy/0/vvva+fOnTIMQ8OHD1dZWZm9z7lz57Rw4UK9+eab+vTTT5WTk+PUOQH4l/qdowXQZBw5ckSGYdi/4GurtLRUixYtUmFhoW655ZZ6qu4iq9WqwMBAWSwWhYWFOb2fwMBABQYGSrq4TuYvf/mLtmzZYt/nAw88YO/bqVMnvfLKK+rbt6/Onj0rPz8/tWrVSpIUEhJSY+g7fPiw3n//fW3fvl0DBw6UJL399tuy2Wxav369fv/730u6GKRSU1PVuXNnSdLkyZP1/PPPO31uAJi5AfD/GYbhUP+nn35afn5+8vX11bx58zR37lzdeeed9VRd/di3b5/Gjh2rV199VYMGDbK379mzRyNGjNA111wjf39/3XTTTZKknJycWu/74MGD8vLyUv/+/e1trVu31rXXXquDBw/a23x9fe3BRpLatm1rvwQGwDnM3ACQJEVERMhisejQoUO16v/kk08qPj5efn5+Cg0NlcVisX8WEBCg7777rso2p0+flqenZ7WXvSTJw+Pi37d+GbR+eQnHlfLy8nTXXXfpwQcf1Pjx4+3txcXFiomJUUxMjN5++221adNGOTk5iomJqZfLbs2aNav03mKxOBw0AVTGzA0ASRfv9ImJidGSJUtUXFxc5fNf3/YcHBysLl26KCwsrFKwkaRrr71WX331lUpKSiq17927Vx07dqzyhX5JmzZtJKnSgtpf/zaN1WpVeXl5bU+rWufPn9fIkSPVrVs3JScnV/rs0KFD+vHHHzV37lwNGTJE3bp1qzKTYrVaJemydVx33XW6cOGCPv/8c3vbjz/+qKysLHXv3r1O9QO4PMINALslS5aovLxc/fr103vvvafDhw/r4MGDeuWVVzRgwIBa7+e+++6TxWJRXFyc9uzZoyNHjmj58uVKSUnRE088UeN2Xbp0kc1m0+zZs3X48GF9+OGHWrRoUaU+4eHhOnv2rNLT03Xq1CmdO3fO4fN8+OGHdfz4cb3yyisqKChQXl6e8vLyVFpaqmuuuUZWq1WLFy/WsWPH9P7771f57ZoOHTrIYrHogw8+UEFBgc6ePVvlGBERERo5cqQmTJigbdu2af/+/br//vvVvn17jRw50uGaAdQe4QaAXadOnbR3714NHTpUTzzxhHr06KFhw4YpPT1dr732Wq33ExQUpM8++0xlZWW66667FBkZqVdeeUXJycl6+OGHa9yuWbNmevfdd3Xo0CH16tVL8+bN0wsvvFCpz8CBA/XII48oNjZWbdq00fz58x0+z//93/9Vbm6uunfvrrZt29pfO3bsUJs2bZSWlqY1a9aoe/fumjt3rhYuXFhp+/bt2+u5557TM888o9DQUE2ePLna46xYsUJ9+vTRb3/7Ww0YMECGYWjDhg01zlwBcA2LwcVdAABgIszcAAAAUyHcAAAAUyHcAAAAUyHcAAAAUyHcAAAAUyHcAAAAUyHcAAAAUyHcAAAAUyHcAAAAUyHcAAAAUyHcAAAAU/l/hXFfAYgMDuEAAAAASUVORK5CYII=", - "text/plain": [ - "<Figure size 640x480 with 1 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "data = df_host_multi.cpu_utilization\n", - "plt.hist(data, weights=np.ones_like(data) / len(data),\n", - " alpha=0.7, label=\"multi\", bins=30)\n", - "\n", - "\n", - "data = df_host_single.cpu_utilization\n", - "plt.hist(data, weights=np.ones_like(data) / len(data),\n", - " alpha=0.7, label=\"single\", bins=30)\n", - "\n", - "plt.xlabel(\"CPU utilization\")\n", - "plt.ylabel(\"Frequency\")\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 105, - "id": "42c0c638", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "<matplotlib.legend.Legend at 0x7f6fc2d09510>" - ] - }, - "execution_count": 105, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 640x480 with 1 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "plt.plot(df_service_single.servers_pending, label=\"servers pending\")\n", - "plt.plot(df_service_single.servers_active, label=\"servers active\")\n", - "\n", - "plt.legend()" - ] - }, - { - "cell_type": "code", - "execution_count": 106, - "id": "1a688c2d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "<matplotlib.legend.Legend at 0x7f6fc2cc7ca0>" - ] - }, - "execution_count": 106, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 640x480 with 1 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "plt.plot(df_service_multi.servers_pending, label=\"servers pending\")\n", - "plt.plot(df_service_multi.servers_active, label=\"servers active\")\n", - "\n", - "plt.legend()" - ] - }, - { - "cell_type": "code", - "execution_count": 117, - "id": "dc4e17cd", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "<div>\n", - "<style scoped>\n", - " .dataframe tbody tr th:only-of-type {\n", - " vertical-align: middle;\n", - " }\n", - "\n", - " .dataframe tbody tr th {\n", - " vertical-align: top;\n", - " }\n", - "\n", - " .dataframe thead th {\n", - " text-align: right;\n", - " }\n", - "</style>\n", - "<table border=\"1\" class=\"dataframe\">\n", - " <thead>\n", - " <tr style=\"text-align: right;\">\n", - " <th></th>\n", - " <th>timestamp</th>\n", - " <th>host_id</th>\n", - " <th>cpu_count</th>\n", - " <th>mem_capacity</th>\n", - " <th>guests_terminated</th>\n", - " <th>guests_running</th>\n", - " <th>guests_error</th>\n", - " <th>guests_invalid</th>\n", - " <th>cpu_limit</th>\n", - " <th>cpu_usage</th>\n", - " <th>...</th>\n", - " <th>cpu_utilization</th>\n", - " <th>cpu_time_active</th>\n", - " <th>cpu_time_idle</th>\n", - " <th>cpu_time_steal</th>\n", - " <th>cpu_time_lost</th>\n", - " <th>power_total</th>\n", - " <th>uptime</th>\n", - " <th>downtime</th>\n", - " <th>boot_time</th>\n", - " <th>absolute_timestamp</th>\n", - " </tr>\n", - " </thead>\n", - " <tbody>\n", - " <tr>\n", - " <th>0</th>\n", - " <td>1970-01-01 02:00:00+00:00</td>\n", - " <td>b'\\xe2 \\xa89{\\x1d\\xcd\\xaf\\x00\\x00\\x00\\x00\\x00\\...</td>\n", - " <td>8</td>\n", - " <td>128000</td>\n", - " <td>0</td>\n", - " <td>15</td>\n", - " <td>0</td>\n", - " <td>0</td>\n", - " <td>25600.0</td>\n", - " <td>9446.762695</td>\n", - " <td>...</td>\n", - " <td>0.369014</td>\n", - " <td>13838</td>\n", - " <td>43761</td>\n", - " <td>1008</td>\n", - " <td>0</td>\n", - " <td>1.699475e+06</td>\n", - " <td>7200000</td>\n", - " <td>0</td>\n", - " <td>1970-01-01 00:00:00+00:00</td>\n", - " <td>2013-08-12 13:35:46+00:00</td>\n", - " </tr>\n", - " <tr>\n", - " <th>1</th>\n", - " <td>1970-01-01 04:00:00+00:00</td>\n", - " <td>b'\\xe2 \\xa89{\\x1d\\xcd\\xaf\\x00\\x00\\x00\\x00\\x00\\...</td>\n", - " <td>8</td>\n", - " <td>128000</td>\n", - " <td>0</td>\n", - " <td>15</td>\n", - " <td>0</td>\n", - " <td>0</td>\n", - " <td>25600.0</td>\n", - " <td>25600.000000</td>\n", - " <td>...</td>\n", - " <td>1.000000</td>\n", - " <td>57592</td>\n", - " <td>8</td>\n", - " <td>73720</td>\n", - " <td>0</td>\n", - " <td>2.519850e+06</td>\n", - " <td>7200000</td>\n", - " <td>0</td>\n", - " <td>1970-01-01 00:00:00+00:00</td>\n", - " <td>2013-08-12 15:35:46+00:00</td>\n", - " </tr>\n", - " <tr>\n", - " <th>2</th>\n", - " <td>1970-01-01 06:00:00+00:00</td>\n", - " <td>b'\\xe2 \\xa89{\\x1d\\xcd\\xaf\\x00\\x00\\x00\\x00\\x00\\...</td>\n", - " <td>8</td>\n", - " <td>128000</td>\n", - " <td>0</td>\n", - " <td>15</td>\n", - " <td>0</td>\n", - " <td>0</td>\n", - " <td>25600.0</td>\n", - " <td>25600.000000</td>\n", - " <td>...</td>\n", - " <td>1.000000</td>\n", - " <td>57600</td>\n", - " <td>0</td>\n", - " <td>81518</td>\n", - " <td>0</td>\n", - " <td>2.520000e+06</td>\n", - " <td>7200000</td>\n", - " <td>0</td>\n", - " <td>1970-01-01 00:00:00+00:00</td>\n", - " <td>2013-08-12 17:35:46+00:00</td>\n", - " </tr>\n", - " <tr>\n", - " <th>3</th>\n", - " <td>1970-01-01 08:00:00+00:00</td>\n", - " <td>b'\\xe2 \\xa89{\\x1d\\xcd\\xaf\\x00\\x00\\x00\\x00\\x00\\...</td>\n", - " <td>8</td>\n", - " <td>128000</td>\n", - " <td>0</td>\n", - " <td>15</td>\n", - " <td>0</td>\n", - " <td>0</td>\n", - " <td>25600.0</td>\n", - " <td>25600.000000</td>\n", - " <td>...</td>\n", - " <td>1.000000</td>\n", - " <td>57592</td>\n", - " <td>8</td>\n", - " <td>73134</td>\n", - " <td>0</td>\n", - " <td>2.519850e+06</td>\n", - " <td>7200000</td>\n", - " <td>0</td>\n", - " <td>1970-01-01 00:00:00+00:00</td>\n", - " <td>2013-08-12 19:35:46+00:00</td>\n", - " </tr>\n", - " <tr>\n", - " <th>4</th>\n", - " <td>1970-01-01 10:00:00+00:00</td>\n", - " <td>b'\\xe2 \\xa89{\\x1d\\xcd\\xaf\\x00\\x00\\x00\\x00\\x00\\...</td>\n", - " <td>8</td>\n", - " <td>128000</td>\n", - " <td>0</td>\n", - " <td>15</td>\n", - " <td>0</td>\n", - " <td>0</td>\n", - " <td>25600.0</td>\n", - " <td>25600.000000</td>\n", - " <td>...</td>\n", - " <td>1.000000</td>\n", - " <td>57592</td>\n", - " <td>8</td>\n", - " <td>74832</td>\n", - " <td>0</td>\n", - " <td>2.519850e+06</td>\n", - " <td>7200000</td>\n", - " <td>0</td>\n", - " <td>1970-01-01 00:00:00+00:00</td>\n", - " <td>2013-08-12 21:35:46+00:00</td>\n", - " </tr>\n", - " </tbody>\n", - "</table>\n", - "<p>5 rows × 21 columns</p>\n", - "</div>" - ], - "text/plain": [ - " timestamp \\\n", - "0 1970-01-01 02:00:00+00:00 \n", - "1 1970-01-01 04:00:00+00:00 \n", - "2 1970-01-01 06:00:00+00:00 \n", - "3 1970-01-01 08:00:00+00:00 \n", - "4 1970-01-01 10:00:00+00:00 \n", - "\n", - " host_id cpu_count mem_capacity \\\n", - "0 b'\\xe2 \\xa89{\\x1d\\xcd\\xaf\\x00\\x00\\x00\\x00\\x00\\... 8 128000 \n", - "1 b'\\xe2 \\xa89{\\x1d\\xcd\\xaf\\x00\\x00\\x00\\x00\\x00\\... 8 128000 \n", - "2 b'\\xe2 \\xa89{\\x1d\\xcd\\xaf\\x00\\x00\\x00\\x00\\x00\\... 8 128000 \n", - "3 b'\\xe2 \\xa89{\\x1d\\xcd\\xaf\\x00\\x00\\x00\\x00\\x00\\... 8 128000 \n", - "4 b'\\xe2 \\xa89{\\x1d\\xcd\\xaf\\x00\\x00\\x00\\x00\\x00\\... 8 128000 \n", - "\n", - " guests_terminated guests_running guests_error guests_invalid cpu_limit \\\n", - "0 0 15 0 0 25600.0 \n", - "1 0 15 0 0 25600.0 \n", - "2 0 15 0 0 25600.0 \n", - "3 0 15 0 0 25600.0 \n", - "4 0 15 0 0 25600.0 \n", - "\n", - " cpu_usage ... cpu_utilization cpu_time_active cpu_time_idle \\\n", - "0 9446.762695 ... 0.369014 13838 43761 \n", - "1 25600.000000 ... 1.000000 57592 8 \n", - "2 25600.000000 ... 1.000000 57600 0 \n", - "3 25600.000000 ... 1.000000 57592 8 \n", - "4 25600.000000 ... 1.000000 57592 8 \n", - "\n", - " cpu_time_steal cpu_time_lost power_total uptime downtime \\\n", - "0 1008 0 1.699475e+06 7200000 0 \n", - "1 73720 0 2.519850e+06 7200000 0 \n", - "2 81518 0 2.520000e+06 7200000 0 \n", - "3 73134 0 2.519850e+06 7200000 0 \n", - "4 74832 0 2.519850e+06 7200000 0 \n", - "\n", - " boot_time absolute_timestamp \n", - "0 1970-01-01 00:00:00+00:00 2013-08-12 13:35:46+00:00 \n", - "1 1970-01-01 00:00:00+00:00 2013-08-12 15:35:46+00:00 \n", - "2 1970-01-01 00:00:00+00:00 2013-08-12 17:35:46+00:00 \n", - "3 1970-01-01 00:00:00+00:00 2013-08-12 19:35:46+00:00 \n", - "4 1970-01-01 00:00:00+00:00 2013-08-12 21:35:46+00:00 \n", - "\n", - "[5 rows x 21 columns]" - ] - }, - "execution_count": 117, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_host_single.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 120, - "id": "b0e6c7bf", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 120, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "utilization = df_host_single.cpu_utilization.to_numpy()" - ] - }, - { - "cell_type": "code", - "execution_count": 122, - "id": "aea7b79d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[<matplotlib.lines.Line2D at 0x7f6f870ccfa0>]" - ] - }, - "execution_count": 122, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 640x480 with 1 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "window = 100\n", - "avg_utilization = []\n", - "\n", - "for ind in range(len(utilization) - window + 1):\n", - " avg_utilization.append(np.mean(utilization[ind:ind+window]))\n", - " \n", - "plt.plot(avg_utilization)" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "id": "575f824b", - "metadata": {}, - "outputs": [], - "source": [ - "sum_util = []\n", - "\n", - "last_util = 0\n", - "for util in utilization:\n", - " sum_util.append(util + last_util)\n", - " last_util = sum_util[-1]" - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "id": "94d64f88", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[<matplotlib.lines.Line2D at 0x7fd9366b70d0>]" - ] - }, - "execution_count": 49, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 640x480 with 1 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(sum_util)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7962b16f", - "metadata": {}, - "outputs": [], - "source": [ - "output_file = \"../Python_scripts/meta_small.parquet\"\n", - "output_file_path = Path(output_file)\n", - "\n", - "df_meta_new.to_parquet(output_file_path, index=False)\n", - "\n", - "output_file = \"../Python_scripts/trace_small.parquet\"\n", - "output_file_path = Path(output_file)\n", - "df_trace_new.to_parquet(output_file_path, index=False)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/opendc-experiments/opendc-experiments-portfolio/src/main/Python_scripts/OpenDCdemo.ipynb b/opendc-experiments/opendc-experiments-portfolio/src/main/Python_scripts/OpenDCdemo.ipynb deleted file mode 100644 index 09ff26d6..00000000 --- a/opendc-experiments/opendc-experiments-portfolio/src/main/Python_scripts/OpenDCdemo.ipynb +++ /dev/null @@ -1,1121 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "18170001", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "\n", - "from IPython.display import display, HTML\n", - "\n", - "base_folder = \"../\"" - ] - }, - { - "cell_type": "markdown", - "id": "422f4d05", - "metadata": {}, - "source": [ - "## Topologies" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "a2d05361", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Topology name: multi\n" - ] - }, - { - "data": { - "text/html": [ - "<table border=\"1\" class=\"dataframe\">\n", - " <thead>\n", - " <tr style=\"text-align: right;\">\n", - " <th></th>\n", - " <th>ClusterID</th>\n", - " <th>ClusterName</th>\n", - " <th>Cores</th>\n", - " <th>Speed</th>\n", - " <th>Memory</th>\n", - " <th>numberOfHosts</th>\n", - " <th>memoryCapacityPerHost</th>\n", - " <th>coreCountPerHost</th>\n", - " </tr>\n", - " </thead>\n", - " <tbody>\n", - " <tr>\n", - " <th>0</th>\n", - " <td>A01</td>\n", - " <td>A01</td>\n", - " <td>32</td>\n", - " <td>3.20</td>\n", - " <td>2048</td>\n", - " <td>1</td>\n", - " <td>256</td>\n", - " <td>32</td>\n", - " </tr>\n", - " <tr>\n", - " <th>1</th>\n", - " <td>B01</td>\n", - " <td>B01</td>\n", - " <td>48</td>\n", - " <td>2.93</td>\n", - " <td>1256</td>\n", - " <td>6</td>\n", - " <td>64</td>\n", - " <td>8</td>\n", - " </tr>\n", - " <tr>\n", - " <th>2</th>\n", - " <td>C01</td>\n", - " <td>C01</td>\n", - " <td>32</td>\n", - " <td>3.20</td>\n", - " <td>2048</td>\n", - " <td>2</td>\n", - " <td>128</td>\n", - " <td>16</td>\n", - " </tr>\n", - " </tbody>\n", - "</table>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Topology name: single\n" - ] - }, - { - "data": { - "text/html": [ - "<table border=\"1\" class=\"dataframe\">\n", - " <thead>\n", - " <tr style=\"text-align: right;\">\n", - " <th></th>\n", - " <th>ClusterID</th>\n", - " <th>ClusterName</th>\n", - " <th>Cores</th>\n", - " <th>Speed</th>\n", - " <th>Memory</th>\n", - " <th>numberOfHosts</th>\n", - " <th>memoryCapacityPerHost</th>\n", - " <th>coreCountPerHost</th>\n", - " </tr>\n", - " </thead>\n", - " <tbody>\n", - " <tr>\n", - " <th>0</th>\n", - " <td>A01</td>\n", - " <td>A01</td>\n", - " <td>8</td>\n", - " <td>3.2</td>\n", - " <td>128</td>\n", - " <td>1</td>\n", - " <td>128</td>\n", - " <td>8</td>\n", - " </tr>\n", - " </tbody>\n", - "</table>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "def read_topology(topology_name):\n", - " print(f\"Topology name: {topology_name}\")\n", - " df = pd.read_csv(f\"{base_folder}/resources/env/{topology_name}.txt\", delimiter=\";\")\n", - " display(HTML(df.to_html()))\n", - " \n", - "read_topology(\"multi\")\n", - "read_topology(\"single\")" - ] - }, - { - "cell_type": "markdown", - "id": "8f4fe54d", - "metadata": {}, - "source": [ - "## Traces" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "fd17d88a", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "<div>\n", - "<style scoped>\n", - " .dataframe tbody tr th:only-of-type {\n", - " vertical-align: middle;\n", - " }\n", - "\n", - " .dataframe tbody tr th {\n", - " vertical-align: top;\n", - " }\n", - "\n", - " .dataframe thead th {\n", - " text-align: right;\n", - " }\n", - "</style>\n", - "<table border=\"1\" class=\"dataframe\">\n", - " <thead>\n", - " <tr style=\"text-align: right;\">\n", - " <th></th>\n", - " <th>id</th>\n", - " <th>timestamp</th>\n", - " <th>duration</th>\n", - " <th>cpu_count</th>\n", - " <th>cpu_usage</th>\n", - " </tr>\n", - " </thead>\n", - " <tbody>\n", - " <tr>\n", - " <th>0</th>\n", - " <td>1019</td>\n", - " <td>2013-08-12 13:40:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>1</td>\n", - " <td>0.000000</td>\n", - " </tr>\n", - " <tr>\n", - " <th>1</th>\n", - " <td>1019</td>\n", - " <td>2013-08-12 13:45:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>1</td>\n", - " <td>11.703998</td>\n", - " </tr>\n", - " <tr>\n", - " <th>2</th>\n", - " <td>1019</td>\n", - " <td>2013-08-12 13:55:46+00:00</td>\n", - " <td>600000</td>\n", - " <td>1</td>\n", - " <td>0.000000</td>\n", - " </tr>\n", - " <tr>\n", - " <th>3</th>\n", - " <td>1019</td>\n", - " <td>2013-08-12 14:00:46+00:00</td>\n", - " <td>300000</td>\n", - " <td>1</td>\n", - " <td>11.703998</td>\n", - " </tr>\n", - " <tr>\n", - " <th>4</th>\n", - " <td>1019</td>\n", - " <td>2013-08-12 14:15:46+00:00</td>\n", - " <td>900000</td>\n", - " <td>1</td>\n", - " <td>0.000000</td>\n", - " </tr>\n", - " </tbody>\n", - "</table>\n", - "</div>" - ], - "text/plain": [ - " id timestamp duration cpu_count cpu_usage\n", - "0 1019 2013-08-12 13:40:46+00:00 300000 1 0.000000\n", - "1 1019 2013-08-12 13:45:46+00:00 300000 1 11.703998\n", - "2 1019 2013-08-12 13:55:46+00:00 600000 1 0.000000\n", - "3 1019 2013-08-12 14:00:46+00:00 300000 1 11.703998\n", - "4 1019 2013-08-12 14:15:46+00:00 900000 1 0.000000" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_trace = pd.read_parquet(f\"{base_folder}/resources/bitbrains-small/trace/trace.parquet\")\n", - "df_trace.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "346f097f", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/html": [ - "<div>\n", - "<style scoped>\n", - " .dataframe tbody tr th:only-of-type {\n", - " vertical-align: middle;\n", - " }\n", - "\n", - " .dataframe tbody tr th {\n", - " vertical-align: top;\n", - " }\n", - "\n", - " .dataframe thead th {\n", - " text-align: right;\n", - " }\n", - "</style>\n", - "<table border=\"1\" class=\"dataframe\">\n", - " <thead>\n", - " <tr style=\"text-align: right;\">\n", - " <th></th>\n", - " <th>id</th>\n", - " <th>start_time</th>\n", - " <th>stop_time</th>\n", - " <th>cpu_count</th>\n", - " <th>cpu_capacity</th>\n", - " <th>mem_capacity</th>\n", - " </tr>\n", - " </thead>\n", - " <tbody>\n", - " <tr>\n", - " <th>0</th>\n", - " <td>1019</td>\n", - " <td>2013-08-12 13:35:46+00:00</td>\n", - " <td>2013-09-11 13:39:58+00:00</td>\n", - " <td>1</td>\n", - " <td>2926.000135</td>\n", - " <td>181352</td>\n", - " </tr>\n", - " <tr>\n", - " <th>1</th>\n", - " <td>1023</td>\n", - " <td>2013-08-12 13:35:46+00:00</td>\n", - " <td>2013-09-11 13:39:58+00:00</td>\n", - " <td>1</td>\n", - " <td>2925.999560</td>\n", - " <td>260096</td>\n", - " </tr>\n", - " <tr>\n", - " <th>2</th>\n", - " <td>1026</td>\n", - " <td>2013-08-12 13:35:46+00:00</td>\n", - " <td>2013-09-11 13:39:58+00:00</td>\n", - " <td>1</td>\n", - " <td>2925.999717</td>\n", - " <td>249972</td>\n", - " </tr>\n", - " <tr>\n", - " <th>3</th>\n", - " <td>1052</td>\n", - " <td>2013-08-29 14:38:12+00:00</td>\n", - " <td>2013-09-05 07:09:07+00:00</td>\n", - " <td>1</td>\n", - " <td>2926.000107</td>\n", - " <td>131245</td>\n", - " </tr>\n", - " <tr>\n", - " <th>4</th>\n", - " <td>1073</td>\n", - " <td>2013-08-21 11:07:12+00:00</td>\n", - " <td>2013-09-11 13:39:58+00:00</td>\n", - " <td>1</td>\n", - " <td>2599.999649</td>\n", - " <td>179306</td>\n", - " </tr>\n", - " </tbody>\n", - "</table>\n", - "</div>" - ], - "text/plain": [ - " id start_time stop_time cpu_count \\\n", - "0 1019 2013-08-12 13:35:46+00:00 2013-09-11 13:39:58+00:00 1 \n", - "1 1023 2013-08-12 13:35:46+00:00 2013-09-11 13:39:58+00:00 1 \n", - "2 1026 2013-08-12 13:35:46+00:00 2013-09-11 13:39:58+00:00 1 \n", - "3 1052 2013-08-29 14:38:12+00:00 2013-09-05 07:09:07+00:00 1 \n", - "4 1073 2013-08-21 11:07:12+00:00 2013-09-11 13:39:58+00:00 1 \n", - "\n", - " cpu_capacity mem_capacity \n", - "0 2926.000135 181352 \n", - "1 2925.999560 260096 \n", - "2 2925.999717 249972 \n", - "3 2926.000107 131245 \n", - "4 2599.999649 179306 " - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_meta = pd.read_parquet(f\"{base_folder}/resources/bitbrains-small/trace/meta.parquet\")\n", - "df_meta.head()" - ] - }, - { - "cell_type": "markdown", - "id": "13bf9fdb", - "metadata": {}, - "source": [ - "# Lets run this in OpenDC!" - ] - }, - { - "cell_type": "markdown", - "id": "c9766446", - "metadata": {}, - "source": [ - "## Resulting Files" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "0d400ffd", - "metadata": {}, - "outputs": [ - { - "ename": "TypeError", - "evalue": "Addition/subtraction of integers and integer-arrays with Timestamp is no longer supported. Instead of adding/subtracting `n`, use `n * obj.freq`", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[8], line 17\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21madd_absolute_timestamp\u001b[39m(df, start_dt):\n\u001b[1;32m 15\u001b[0m df[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mabsolute_timestamp\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m start_dt \u001b[38;5;241m+\u001b[39m (df[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtimestamp\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m-\u001b[39m df[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtimestamp\u001b[39m\u001b[38;5;124m\"\u001b[39m]\u001b[38;5;241m.\u001b[39mmin())\n\u001b[0;32m---> 17\u001b[0m \u001b[43madd_absolute_timestamp\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdf_host_single\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdf_meta\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstart_time\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmin\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 18\u001b[0m add_absolute_timestamp(df_host_single, df_meta[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstart_time\u001b[39m\u001b[38;5;124m\"\u001b[39m]\u001b[38;5;241m.\u001b[39mmin())\n\u001b[1;32m 20\u001b[0m add_absolute_timestamp(df_server_single, df_meta[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstart_time\u001b[39m\u001b[38;5;124m\"\u001b[39m]\u001b[38;5;241m.\u001b[39mmin())\n", - "Cell \u001b[0;32mIn[8], line 15\u001b[0m, in \u001b[0;36madd_absolute_timestamp\u001b[0;34m(df, start_dt)\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21madd_absolute_timestamp\u001b[39m(df, start_dt):\n\u001b[0;32m---> 15\u001b[0m df[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mabsolute_timestamp\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[43mstart_dt\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43mdf\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtimestamp\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mdf\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtimestamp\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmin\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.local/lib/python3.10/site-packages/pandas/core/ops/common.py:72\u001b[0m, in \u001b[0;36m_unpack_zerodim_and_defer.<locals>.new_method\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m 68\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mNotImplemented\u001b[39m\n\u001b[1;32m 70\u001b[0m other \u001b[38;5;241m=\u001b[39m item_from_zerodim(other)\n\u001b[0;32m---> 72\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mmethod\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mother\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.local/lib/python3.10/site-packages/pandas/core/arraylike.py:107\u001b[0m, in \u001b[0;36mOpsMixin.__radd__\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m 105\u001b[0m \u001b[38;5;129m@unpack_zerodim_and_defer\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m__radd__\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 106\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__radd__\u001b[39m(\u001b[38;5;28mself\u001b[39m, other):\n\u001b[0;32m--> 107\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_arith_method\u001b[49m\u001b[43m(\u001b[49m\u001b[43mother\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mroperator\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mradd\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.local/lib/python3.10/site-packages/pandas/core/series.py:6262\u001b[0m, in \u001b[0;36mSeries._arith_method\u001b[0;34m(self, other, op)\u001b[0m\n\u001b[1;32m 6260\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_arith_method\u001b[39m(\u001b[38;5;28mself\u001b[39m, other, op):\n\u001b[1;32m 6261\u001b[0m \u001b[38;5;28mself\u001b[39m, other \u001b[38;5;241m=\u001b[39m ops\u001b[38;5;241m.\u001b[39malign_method_SERIES(\u001b[38;5;28mself\u001b[39m, other)\n\u001b[0;32m-> 6262\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mbase\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mIndexOpsMixin\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_arith_method\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mother\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mop\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.local/lib/python3.10/site-packages/pandas/core/base.py:1325\u001b[0m, in \u001b[0;36mIndexOpsMixin._arith_method\u001b[0;34m(self, other, op)\u001b[0m\n\u001b[1;32m 1322\u001b[0m rvalues \u001b[38;5;241m=\u001b[39m ensure_wrapped_if_datetimelike(rvalues)\n\u001b[1;32m 1324\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m np\u001b[38;5;241m.\u001b[39merrstate(\u001b[38;5;28mall\u001b[39m\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mignore\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[0;32m-> 1325\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[43mops\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43marithmetic_op\u001b[49m\u001b[43m(\u001b[49m\u001b[43mlvalues\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrvalues\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mop\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1327\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_construct_result(result, name\u001b[38;5;241m=\u001b[39mres_name)\n", - "File \u001b[0;32m~/.local/lib/python3.10/site-packages/pandas/core/ops/array_ops.py:218\u001b[0m, in \u001b[0;36marithmetic_op\u001b[0;34m(left, right, op)\u001b[0m\n\u001b[1;32m 205\u001b[0m \u001b[38;5;66;03m# NB: We assume that extract_array and ensure_wrapped_if_datetimelike\u001b[39;00m\n\u001b[1;32m 206\u001b[0m \u001b[38;5;66;03m# have already been called on `left` and `right`,\u001b[39;00m\n\u001b[1;32m 207\u001b[0m \u001b[38;5;66;03m# and `maybe_prepare_scalar_for_op` has already been called on `right`\u001b[39;00m\n\u001b[1;32m 208\u001b[0m \u001b[38;5;66;03m# We need to special-case datetime64/timedelta64 dtypes (e.g. because numpy\u001b[39;00m\n\u001b[1;32m 209\u001b[0m \u001b[38;5;66;03m# casts integer dtypes to timedelta64 when operating with timedelta64 - GH#22390)\u001b[39;00m\n\u001b[1;32m 211\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (\n\u001b[1;32m 212\u001b[0m should_extension_dispatch(left, right)\n\u001b[1;32m 213\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(right, (Timedelta, BaseOffset, Timestamp))\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 216\u001b[0m \u001b[38;5;66;03m# Timedelta/Timestamp and other custom scalars are included in the check\u001b[39;00m\n\u001b[1;32m 217\u001b[0m \u001b[38;5;66;03m# because numexpr will fail on it, see GH#31457\u001b[39;00m\n\u001b[0;32m--> 218\u001b[0m res_values \u001b[38;5;241m=\u001b[39m \u001b[43mop\u001b[49m\u001b[43m(\u001b[49m\u001b[43mleft\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mright\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 219\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 220\u001b[0m \u001b[38;5;66;03m# TODO we should handle EAs consistently and move this check before the if/else\u001b[39;00m\n\u001b[1;32m 221\u001b[0m \u001b[38;5;66;03m# (https://github.com/pandas-dev/pandas/issues/41165)\u001b[39;00m\n\u001b[1;32m 222\u001b[0m _bool_arith_check(op, left, right)\n", - "File \u001b[0;32m~/.local/lib/python3.10/site-packages/pandas/core/roperator.py:11\u001b[0m, in \u001b[0;36mradd\u001b[0;34m(left, right)\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mradd\u001b[39m(left, right):\n\u001b[0;32m---> 11\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mright\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mleft\u001b[49m\n", - "File \u001b[0;32m~/.local/lib/python3.10/site-packages/pandas/_libs/tslibs/timestamps.pyx:504\u001b[0m, in \u001b[0;36mpandas._libs.tslibs.timestamps._Timestamp.__add__\u001b[0;34m()\u001b[0m\n", - "\u001b[0;31mTypeError\u001b[0m: Addition/subtraction of integers and integer-arrays with Timestamp is no longer supported. Instead of adding/subtracting `n`, use `n * obj.freq`" - ] - } - ], - "source": [ - "output_folder = f\"{base_folder}/output\"\n", - "workload = \"workload=bitbrains-small\"\n", - "seed = \"seed=0\"\n", - "\n", - "df_host_single = pd.read_parquet(f\"{output_folder}/topology=single/{workload}/{seed}/host.parquet\")\n", - "df_host_multi = pd.read_parquet(f\"{output_folder}/topology=multi/{workload}/{seed}/host.parquet\")\n", - "\n", - "df_server_single = pd.read_parquet(f\"{output_folder}/topology=single/{workload}/{seed}/server.parquet\")\n", - "df_server_multi = pd.read_parquet(f\"{output_folder}/topology=multi/{workload}/{seed}/server.parquet\")\n", - "\n", - "df_service_single = pd.read_parquet(f\"{output_folder}/topology=single/{workload}/{seed}/service.parquet\")\n", - "df_service_multi = pd.read_parquet(f\"{output_folder}/topology=multi/{workload}/{seed}/service.parquet\")\n", - "\n", - "def add_absolute_timestamp(df, start_dt):\n", - " df[\"absolute_timestamp\"] = start_dt + (df[\"timestamp\"] - df[\"timestamp\"].min())\n", - "\n", - "add_absolute_timestamp(df_host_single, df_meta[\"start_time\"].min())\n", - "add_absolute_timestamp(df_host_single, df_meta[\"start_time\"].min())\n", - "\n", - "add_absolute_timestamp(df_server_single, df_meta[\"start_time\"].min())\n", - "add_absolute_timestamp(df_server_multi, df_meta[\"start_time\"].min())\n", - "\n", - "add_absolute_timestamp(df_service_single, df_meta[\"start_time\"].min())\n", - "add_absolute_timestamp(df_service_multi, df_meta[\"start_time\"].min())" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "a9a61332", - "metadata": {}, - "outputs": [], - "source": [ - "df_host_single = pd.read_parquet(f\"{output_folder}/topology=single/{workload}/{seed}/host.parquet\")" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "d6fb41d9", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Timedelta('0 days 00:05:00')" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pd.Timedelta(300000, unit=\"ms\")" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "3c271734", - "metadata": {}, - "outputs": [ - { - "ename": "AttributeError", - "evalue": "Can only use .dt accessor with datetimelike values", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[30], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mdf_host_single\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtimestamp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdt\u001b[49m\u001b[38;5;241m.\u001b[39mto_pytimedelta()\n", - "File \u001b[0;32m~/.local/lib/python3.10/site-packages/pandas/core/generic.py:5907\u001b[0m, in \u001b[0;36mNDFrame.__getattr__\u001b[0;34m(self, name)\u001b[0m\n\u001b[1;32m 5900\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (\n\u001b[1;32m 5901\u001b[0m name \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_internal_names_set\n\u001b[1;32m 5902\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m name \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_metadata\n\u001b[1;32m 5903\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m name \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_accessors\n\u001b[1;32m 5904\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_info_axis\u001b[38;5;241m.\u001b[39m_can_hold_identifiers_and_holds_name(name)\n\u001b[1;32m 5905\u001b[0m ):\n\u001b[1;32m 5906\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m[name]\n\u001b[0;32m-> 5907\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mobject\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__getattribute__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.local/lib/python3.10/site-packages/pandas/core/accessor.py:183\u001b[0m, in \u001b[0;36mCachedAccessor.__get__\u001b[0;34m(self, obj, cls)\u001b[0m\n\u001b[1;32m 180\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m obj \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 181\u001b[0m \u001b[38;5;66;03m# we're accessing the attribute of the class, i.e., Dataset.geo\u001b[39;00m\n\u001b[1;32m 182\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_accessor\n\u001b[0;32m--> 183\u001b[0m accessor_obj \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_accessor\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobj\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 184\u001b[0m \u001b[38;5;66;03m# Replace the property with the accessor object. Inspired by:\u001b[39;00m\n\u001b[1;32m 185\u001b[0m \u001b[38;5;66;03m# https://www.pydanny.com/cached-property.html\u001b[39;00m\n\u001b[1;32m 186\u001b[0m \u001b[38;5;66;03m# We need to use object.__setattr__ because we overwrite __setattr__ on\u001b[39;00m\n\u001b[1;32m 187\u001b[0m \u001b[38;5;66;03m# NDFrame\u001b[39;00m\n\u001b[1;32m 188\u001b[0m \u001b[38;5;28mobject\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__setattr__\u001b[39m(obj, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_name, accessor_obj)\n", - "File \u001b[0;32m~/.local/lib/python3.10/site-packages/pandas/core/indexes/accessors.py:513\u001b[0m, in \u001b[0;36mCombinedDatetimelikeProperties.__new__\u001b[0;34m(cls, data)\u001b[0m\n\u001b[1;32m 510\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m is_period_dtype(data\u001b[38;5;241m.\u001b[39mdtype):\n\u001b[1;32m 511\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m PeriodProperties(data, orig)\n\u001b[0;32m--> 513\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mAttributeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCan only use .dt accessor with datetimelike values\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", - "\u001b[0;31mAttributeError\u001b[0m: Can only use .dt accessor with datetimelike values" - ] - } - ], - "source": [ - "df_host_single.timestamp.to_pytimedelta()" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "89977c44", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0 1970-01-01 00:05:00+00:00\n", - "1 1970-01-01 00:10:00+00:00\n", - "2 1970-01-01 00:15:00+00:00\n", - "3 1970-01-01 00:20:00+00:00\n", - "4 1970-01-01 00:25:00+00:00\n", - " ... \n", - "25918 1970-03-31 23:55:00+00:00\n", - "25919 1970-04-01 00:00:00+00:00\n", - "25920 1970-04-01 00:05:00+00:00\n", - "25921 1970-04-01 00:10:00+00:00\n", - "25922 1970-04-01 00:14:12+00:00\n", - "Name: timestamp, Length: 25923, dtype: datetime64[ns, UTC]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_host_single.timestamp" - ] - }, - { - "cell_type": "code", - "execution_count": 148, - "id": "eadd08e4", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1970-01-01 00:05:00+00:00 1\n", - "1970-03-01 23:55:00+00:00 1\n", - "1970-03-02 00:45:00+00:00 1\n", - "1970-03-02 00:40:00+00:00 1\n", - "1970-03-02 00:35:00+00:00 1\n", - " ..\n", - "1970-01-30 23:50:00+00:00 1\n", - "1970-01-30 23:45:00+00:00 1\n", - "1970-01-30 23:40:00+00:00 1\n", - "1970-01-30 23:35:00+00:00 1\n", - "1970-04-01 00:10:00+00:00 1\n", - "Name: timestamp, Length: 25922, dtype: int64" - ] - }, - "execution_count": 148, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_service_single.timestamp.value_counts()" - ] - }, - { - "cell_type": "code", - "execution_count": 104, - "id": "a32f9d66", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([44, 45, 46, 47, 49, 50, 34, 16, 14, 13, 12, 11, 10], dtype=int32)" - ] - }, - "execution_count": 104, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(df_service_single.servers_active + df_service_single.servers_pending).unique() " - ] - }, - { - "cell_type": "code", - "execution_count": 102, - "id": "16f4a6b6", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 102, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "set(d1) == set(d2)" - ] - }, - { - "cell_type": "markdown", - "id": "09d31c91", - "metadata": {}, - "source": [ - "## Power Usage" - ] - }, - { - "cell_type": "code", - "execution_count": 150, - "id": "82f0a24a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "single topology: 2227253755.2781296\n", - "multi topology: 5864872551.731657\n" - ] - } - ], - "source": [ - "print(f\"single topology: {df_host_single.power_total.sum()}\")\n", - "print(f\"multi topology: {df_host_multi.power_total.sum()}\")" - ] - }, - { - "cell_type": "markdown", - "id": "7ab3357d", - "metadata": {}, - "source": [ - "## CPU usage" - ] - }, - { - "cell_type": "code", - "execution_count": 151, - "id": "e94db3a6", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "single topology: 0.5760561514665646\n", - "multi topology: 0.3425398748402685\n" - ] - } - ], - "source": [ - "print(f\"single topology: {df_host_single.cpu_utilization.mean()}\")\n", - "print(f\"multi topology: {df_host_multi.cpu_utilization.mean()}\")" - ] - }, - { - "cell_type": "markdown", - "id": "e000a260", - "metadata": {}, - "source": [ - "## CPU utilization" - ] - }, - { - "cell_type": "code", - "execution_count": 152, - "id": "8d7daa45", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "single topology: 0.5760561514665646\n", - "multi topology: 0.3425398748402685\n" - ] - } - ], - "source": [ - "print(f\"single topology: {df_host_single.cpu_utilization.mean()}\")\n", - "print(f\"multi topology: {df_host_multi.cpu_utilization.mean()}\")" - ] - }, - { - "cell_type": "markdown", - "id": "ad97741c", - "metadata": {}, - "source": [ - "## Plotting Results" - ] - }, - { - "cell_type": "code", - "execution_count": 153, - "id": "5df8f9aa", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGwCAYAAABVdURTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAwGUlEQVR4nO3de1xVdb7/8fcG3CByUxFQZydeMDMvlKjH2ykLo2xMa87EaImQWR21scgupqOWFV45lDkxOSp21XFST6dMU5JTXiZNRZtS8hJhCYiVoHgEhPX7w597IkDZmw0blq/n47Efj/Z3f9dan/XN2m+/67v2shiGYQgAAMAkPNxdAAAAgCsRbgAAgKkQbgAAgKkQbgAAgKkQbgAAgKkQbgAAgKkQbgAAgKl4ubuAhlZRUaETJ07I399fFovF3eUAAIBaMAxDZ86cUbt27eThcfm5masu3Jw4cUI2m83dZQAAACccP35cv/nNby7b56oLN/7+/pIuDk5AQICbqwEAALVRVFQkm81m/x6/nKsu3Fy6FBUQEEC4AQCgianNkhIWFAMAAFMh3AAAAFMh3AAAAFO56tbcAADgrPLycpWVlbm7DNOyWq1XvM27Ngg3AABcgWEYysvL0+nTp91diql5eHioY8eOslqtddoP4QYAgCu4FGxCQkLk6+vLj8DWg0s/spubm6trrrmmTmNMuAEA4DLKy8vtwaZ169buLsfU2rRpoxMnTujChQtq1qyZ0/thQTEAAJdxaY2Nr6+vmysxv0uXo8rLy+u0H8INAAC1wKWo+ueqMSbcAAAAUyHcAAAAU2FBMQAAThqftrtBj7csvm+DHq86s2fP1vr165WZmVljn+zsbHXs2FH79u1TZGRkg9V2CeEGAAA4LT4+XqdPn9b69evtbTabTbm5uQoODnZLTYQbAADgUp6engoLC3Pb8VlzAwCASd1888169NFH9dhjj6lly5YKDQ3V0qVLVVxcrISEBPn7+6tLly766KOPJElpaWkKCgqqtI/169fXeBfT7NmztXLlSv33f/+3LBaLLBaLMjIylJ2dLYvFctlLV/WJmRsXq8v118ZwLRUAYC4rV67UU089pV27dmn16tX6z//8T61bt0533323nn32Wf3Xf/2Xxo4dq5ycHIf3PXXqVB08eFBFRUVasWKFJKlVq1Y6ceKEq0/DIczcAABgYr1799aMGTMUERGhadOmycfHR8HBwZowYYIiIiI0c+ZM/fjjjzpw4IDD+/bz81Pz5s3l7e2tsLAwhYWF1fm5UK5AuAEAwMR69epl/2dPT0+1bt1aPXv2tLeFhoZKkk6ePNngtdUXwg0AACb262c0WSyWSm2X1tNUVFTIw8NDhmFU6n/p8RNNCeEGAABIuvjgyjNnzqi4uNjedqVFwVartc7PgnI1wg0AAJAk9e/fX76+vnr22Wd19OhRvfPOO0pLS7vsNuHh4Tpw4ICysrJ06tSpRjHTw91SAAA4yWx3ubZq1UpvvfWWnnzySS1dulS33nqrZs+erYceeqjGbSZMmKCMjAxFRUXp7Nmz2rp1q8LDwxuu6GpYjF9fXDO5oqIiBQYGqrCwUAEBAS7fP7eCA4C5nD9/Xt9++606duwoHx8fd5djapcba0e+v7ksBQAATIVwAwAATIVwAwAATIVwAwAATIVwAwAATIVwAwAATIVwAwAATIVwAwAATIVwAwDAVSY+Pl6jRo1y6T6zs7NlsViu+CyqhsDjFwAAcNY7sQ17vDGrXbKbl19+ucrTv82EcAMAwFUmMDDQ3SXUKy5LAQBgUn//+9/Vs2dPNW/eXK1bt1Z0dLSKi4urXJa6+eab9cc//lFPPfWUWrVqpbCwMM2ePbvSvg4dOqTBgwfLx8dH3bt315YtW2SxWLR+/foaj//Pf/5Td9xxh/z8/BQaGqqxY8fq1KlT9XOyv0C4AQDAhHJzczV69Gg98MADOnjwoDIyMnTPPffUeDlq5cqVatGihT7//HPNnz9fzz//vDZv3ixJKi8v16hRo+Tr66vPP/9cr7/+uqZPn37Z458+fVq33HKLbrjhBn3xxRfauHGj8vPzde+997r8XH+Ny1IAAJhQbm6uLly4oHvuuUcdOnSQJPXs2bPG/r169dKsWbMkSREREXr11VeVnp6uYcOGafPmzTp69KgyMjIUFhYmSXrxxRc1bNiwGvf36quv6oYbbtBLL71kb1u+fLlsNpu++eYbde3a1RWnWS1mbgAAMKHevXvr1ltvVc+ePfX73/9eS5cu1c8//1xj/169elV637ZtW508eVKSlJWVJZvNZg82ktSvX7/LHn///v3aunWr/Pz87K9u3bpJko4ePersadUKMzcAAJiQp6enNm/erB07dujjjz/W4sWLNX36dH3++efV9m/WrFml9xaLRRUVFU4f/+zZsxoxYoTmzZtX5bO2bds6vd/aINwAAGBSFotFgwYN0qBBgzRz5kx16NBB69atc3g/1157rY4fP678/HyFhoZKknbv3n3ZbW688Ua99957Cg8Pl5dXw8YNLksBAGBCn3/+uV566SV98cUXysnJ0dq1a1VQUKDrrrvO4X0NGzZMnTt31rhx43TgwAFt375dM2bMkHQxQFVn0qRJ+umnnzR69Gjt3r1bR48e1aZNm5SQkKDy8vI6nduVEG4AADChgIAAffrppxo+fLi6du2qGTNmaNGiRbrjjjsc3penp6fWr1+vs2fPqm/fvnrwwQftd0v5+PhUu027du20fft2lZeX67bbblPPnj312GOPKSgoSB4e9Rs/LIaZf6KwGkVFRQoMDFRhYaECAgJcvv/xaZefprucZfF9XVgJAMAVzp8/r2+//VYdO3as8Yv8arR9+3YNHjxYR44cUefOnV2yz8uNtSPf36y5AQAAV7Ru3Tr5+fkpIiJCR44c0ZQpUzRo0CCXBRtXItwAAIArOnPmjJ5++mnl5OQoODhY0dHRWrRokbvLqhbhBgAAXFFcXJzi4uLcXUatsKAYAACYCuEGAIBauMruv3ELV40x4QYAgMu49Mu9586dc3Ml5ldaWirp4q3nddEo1twsWbJECxYsUF5ennr37q3Fixdf8ZkVkrRq1SqNHj1aI0eOvOwj1wEAcJanp6eCgoLsz1ny9fWt8Yfr4LyKigoVFBTI19e3zr9o7PZws3r1aiUmJio1NVX9+/dXSkqKYmJilJWVpZCQkBq3y87O1tSpUzVkyJAGrBYAcDW69MDISwEH9cPDw0PXXHNNncOj28NNcnKyJkyYoISEBElSamqqPvzwQy1fvlzPPPNMtduUl5frvvvu03PPPafPPvtMp0+frnH/JSUlKikpsb8vKipyaf0AAPOzWCxq27atQkJCVFZW5u5yTMtqtbrk14vdGm5KS0u1Z88eTZs2zd7m4eGh6Oho7dy5s8btnn/+eYWEhGj8+PH67LPPLnuMpKQkPffccy6rGQBw9fL09KzzehDUP7cuKD516pTKy8vtTxi9JDQ0VHl5edVus23bNi1btkxLly6t1TGmTZumwsJC++v48eN1rhsAADRebr8s5YgzZ85o7NixWrp0qYKDg2u1jbe3t7y9veu5MgAA0Fi4NdwEBwfL09NT+fn5ldrz8/Pti7d+6ejRo8rOztaIESPsbRUVFZIkLy8vZWVlNcpnXAAAgIbj1stSVqtVffr0UXp6ur2toqJC6enpGjBgQJX+3bp105dffqnMzEz766677tLQoUOVmZkpm83WkOUDAIBGyO2XpRITEzVu3DhFRUWpX79+SklJUXFxsf3uqbi4OLVv315JSUny8fFRjx49Km0fFBQkSVXaAQDA1cnt4SY2NlYFBQWaOXOm8vLyFBkZqY0bN9oXGefk5LjktjAAAHB1sBhX2cMyioqKFBgYqMLCQgUEBLh8/+PTdju97bL4vi6sBAAA83Dk+5spEQAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqEGwAAYCqNItwsWbJE4eHh8vHxUf/+/bVr164a+65du1ZRUVEKCgpSixYtFBkZqTfffLMBqwUAAI2Z28PN6tWrlZiYqFmzZmnv3r3q3bu3YmJidPLkyWr7t2rVStOnT9fOnTt14MABJSQkKCEhQZs2bWrgygEAQGPk9nCTnJysCRMmKCEhQd27d1dqaqp8fX21fPnyavvffPPNuvvuu3Xdddepc+fOmjJlinr16qVt27Y1cOUAAKAxcmu4KS0t1Z49exQdHW1v8/DwUHR0tHbu3HnF7Q3DUHp6urKysvTv//7v1fYpKSlRUVFRpRcAADAvt4abU6dOqby8XKGhoZXaQ0NDlZeXV+N2hYWF8vPzk9Vq1Z133qnFixdr2LBh1fZNSkpSYGCg/WWz2Vx6DgAAoHFx+2UpZ/j7+yszM1O7d+/Wiy++qMTERGVkZFTbd9q0aSosLLS/jh8/3rDFAgCABuXlzoMHBwfL09NT+fn5ldrz8/MVFhZW43YeHh7q0qWLJCkyMlIHDx5UUlKSbr755ip9vb295e3t7dK6AQBA4+XWmRur1ao+ffooPT3d3lZRUaH09HQNGDCg1vupqKhQSUlJfZQIAACaGLfO3EhSYmKixo0bp6ioKPXr108pKSkqLi5WQkKCJCkuLk7t27dXUlKSpItraKKiotS5c2eVlJRow4YNevPNN/Xaa6+58zQAAEAj4fZwExsbq4KCAs2cOVN5eXmKjIzUxo0b7YuMc3Jy5OHxrwmm4uJiTZw4Ud9//72aN2+ubt266a233lJsbKy7TgEAADQiFsMwDHcX0ZCKiooUGBiowsJCBQQEuHz/49N2O73tsvi+LqwEAADzcOT7u0neLQUAAFATt1+WAgAAjdA7dVjuMWa16+pwAjM3AADAVAg3AADAVAg3AADAVAg3AADAVAg3AADAVAg3AADAVAg3AADAVAg3AADAVAg3AADAVAg3AADAVJwKN8eOHXN1HQAAAC7hVLjp0qWLhg4dqrfeekvnz593dU0AAABOcyrc7N27V7169VJiYqLCwsL08MMPa9euXa6uDQAAwGFOhZvIyEi9/PLLOnHihJYvX67c3FwNHjxYPXr0UHJysgoKClxdJwAAQK3UaUGxl5eX7rnnHq1Zs0bz5s3TkSNHNHXqVNlsNsXFxSk3N9dVdQIAANRKncLNF198oYkTJ6pt27ZKTk7W1KlTdfToUW3evFknTpzQyJEjXVUnAABArXg5s1FycrJWrFihrKwsDR8+XG+88YaGDx8uD4+LWaljx45KS0tTeHi4K2sFAAC4IqfCzWuvvaYHHnhA8fHxatu2bbV9QkJCtGzZsjoVBwAA4Cinws3hw4ev2MdqtWrcuHHO7B4AAMBpTq25WbFihdasWVOlfc2aNVq5cmWdiwIAAHCWU+EmKSlJwcHBVdpDQkL00ksv1bkoAAAAZzkVbnJyctSxY8cq7R06dFBOTk6diwIAAHCWU+EmJCREBw4cqNK+f/9+tW7dus5FAQAAOMupcDN69Gj98Y9/1NatW1VeXq7y8nJ98sknmjJliv7whz+4ukYAAIBac+puqTlz5ig7O1u33nqrvLwu7qKiokJxcXGsuQEAAG7lVLixWq1avXq15syZo/3796t58+bq2bOnOnTo4Or6AAAAHOJUuLmka9eu6tq1q6tqAQAAqDOnwk15ebnS0tKUnp6ukydPqqKiotLnn3zyiUuKAwAAcJRT4WbKlClKS0vTnXfeqR49eshisbi6LgAAAKc4FW5WrVqlv/3tbxo+fLir6wEAAKgTp24Ft1qt6tKli6trAQAAqDOnws0TTzyhl19+WYZhuLoeAACAOnHqstS2bdu0detWffTRR7r++uvVrFmzSp+vXbvWJcUBAAA4yqlwExQUpLvvvtvVtQAAANSZU+FmxYoVrq4DAADAJZxacyNJFy5c0JYtW/SXv/xFZ86ckSSdOHFCZ8+edVlxAAAAjnJq5ua7777T7bffrpycHJWUlGjYsGHy9/fXvHnzVFJSotTUVFfXCQAAUCtOzdxMmTJFUVFR+vnnn9W8eXN7+91336309HSXFQcAAOAop2ZuPvvsM+3YsUNWq7VSe3h4uH744QeXFAYAAOAMp2ZuKioqVF5eXqX9+++/l7+/f52LAgAAcJZT4ea2225TSkqK/b3FYtHZs2c1a9YsHskAAADcyqnLUosWLVJMTIy6d++u8+fPa8yYMTp8+LCCg4P17rvvurpGAACAWnMq3PzmN7/R/v37tWrVKh04cEBnz57V+PHjdd9991VaYAwAANDQnAo3kuTl5aX777/flbUAAADUmVPh5o033rjs53FxcU4VAwAAUFdOhZspU6ZUel9WVqZz587JarXK19eXcAMAANzGqbulfv7550qvs2fPKisrS4MHD2ZBMQAAcCunny31axEREZo7d26VWR0AAICG5LJwI11cZHzixAlX7hIAAMAhTq25ef/99yu9NwxDubm5evXVVzVo0CCXFAYAAOAMp8LNqFGjKr23WCxq06aNbrnlFi1atMgVdQEAADjFqXBTUVHh6joAAABcwqVrbgAAANzNqZmbxMTEWvdNTk525hAAAABOcSrc7Nu3T/v27VNZWZmuvfZaSdI333wjT09P3XjjjfZ+FovFNVUCAADUklPhZsSIEfL399fKlSvVsmVLSRd/2C8hIUFDhgzRE0884dIiAQAAasupNTeLFi1SUlKSPdhIUsuWLfXCCy9wtxQAAHArp8JNUVGRCgoKqrQXFBTozJkzdS4KAADAWU6Fm7vvvlsJCQlau3atvv/+e33//fd67733NH78eN1zzz2urhEAAKDWnFpzk5qaqqlTp2rMmDEqKyu7uCMvL40fP14LFixwaYEAAACOcCrc+Pr66s9//rMWLFigo0ePSpI6d+6sFi1auLQ4AAAAR9XpR/xyc3OVm5uriIgItWjRQoZhuKouAAAApzgVbn788Ufdeuut6tq1q4YPH67c3FxJ0vjx47kNHAAAuJVT4ebxxx9Xs2bNlJOTI19fX3t7bGysNm7c6LLiAAAAHOXUmpuPP/5YmzZt0m9+85tK7REREfruu+9cUhgAAIAznJq5KS4urjRjc8lPP/0kb2/vOhcFAADgLKfCzZAhQ/TGG2/Y31ssFlVUVGj+/PkaOnSow/tbsmSJwsPD5ePjo/79+2vXrl019l26dKmGDBmili1bqmXLloqOjr5sfwAAcHVxKtzMnz9fr7/+uu644w6VlpbqqaeeUo8ePfTpp59q3rx5Du1r9erVSkxM1KxZs7R371717t1bMTExOnnyZLX9MzIyNHr0aG3dulU7d+6UzWbTbbfdph9++MGZUwEAACbjVLjp0aOHvvnmGw0ePFgjR45UcXGx7rnnHu3bt0+dO3d2aF/JycmaMGGCEhIS1L17d6WmpsrX11fLly+vtv/bb7+tiRMnKjIyUt26ddNf//pXVVRUKD093ZlTAQAAJuPwguKysjLdfvvtSk1N1fTp0+t08NLSUu3Zs0fTpk2zt3l4eCg6Olo7d+6s1T7OnTunsrIytWrVqtrPS0pKVFJSYn9fVFRUp5oBAEDj5vDMTbNmzXTgwAGXHPzUqVMqLy9XaGhopfbQ0FDl5eXVah9PP/202rVrp+jo6Go/T0pKUmBgoP1ls9nqXDcAAGi8nLosdf/992vZsmWursVhc+fO1apVq7Ru3Tr5+PhU22fatGkqLCy0v44fP97AVQIAgIbk1O/cXLhwQcuXL9eWLVvUp0+fKs+USk5OrtV+goOD5enpqfz8/Ert+fn5CgsLu+y2Cxcu1Ny5c7Vlyxb16tWrxn7e3t7cng4AwFXEoXBz7NgxhYeH65///KduvPFGSdI333xTqY/FYqn1/qxWq/r06aP09HSNGjVKkuyLgydPnlzjdvPnz9eLL76oTZs2KSoqypFTAAAAJudQuImIiFBubq62bt0q6eLjFl555ZUqa2YckZiYqHHjxikqKkr9+vVTSkqKiouLlZCQIEmKi4tT+/btlZSUJEmaN2+eZs6cqXfeeUfh4eH2tTl+fn7y8/Nzug4AAGAODoWbXz/1+6OPPlJxcXGdCoiNjVVBQYFmzpypvLw8RUZGauPGjfbAlJOTIw+Pfy0Neu2111RaWqr/+I//qLSfWbNmafbs2XWqBQAANH1Orbm55Ndhx1mTJ0+u8TJURkZGpffZ2dkuOSYAADAnh+6WslgsVdbUOLLGBgAAoL45fFkqPj7efvfR+fPn9cgjj1S5W2rt2rWuqxAAAMABDoWbcePGVXp///33u7QYAACAunIo3KxYsaK+6gAAAHAJp36hGAAAoLEi3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFMh3AAAAFPxcncBAACgZuPTdju97bL4vi6spOlg5gYAAJgK4QYAAJgK4QYAAJgK4QYAAJgK4QYAAJgK4QYAAJgK4QYAAJgK4QYAAJgK4QYAAJgK4QYAAJgK4QYAAJgK4QYAAJgK4QYAAJgK4QYAAJgK4QYAAJgK4QYAAJgK4QYAAJgK4QYAAJgK4QYAAJgK4QYAAJgK4QYAAJiK28PNkiVLFB4eLh8fH/Xv31+7du2qse9XX32l3/3udwoPD5fFYlFKSkrDFQoAAJoEt4ab1atXKzExUbNmzdLevXvVu3dvxcTE6OTJk9X2P3funDp16qS5c+cqLCysgasFAABNgVvDTXJysiZMmKCEhAR1795dqamp8vX11fLly6vt37dvXy1YsEB/+MMf5O3tXatjlJSUqKioqNILAACYl9vCTWlpqfbs2aPo6Oh/FePhoejoaO3cudNlx0lKSlJgYKD9ZbPZXLZvAADQ+Lgt3Jw6dUrl5eUKDQ2t1B4aGqq8vDyXHWfatGkqLCy0v44fP+6yfQMAgMbHy90F1Ddvb+9aX8ICAABNn9tmboKDg+Xp6an8/PxK7fn5+SwWBgAATnNbuLFarerTp4/S09PtbRUVFUpPT9eAAQPcVRYAAGji3HpZKjExUePGjVNUVJT69eunlJQUFRcXKyEhQZIUFxen9u3bKykpSdLFRchff/21/Z9/+OEHZWZmys/PT126dHHbeQAAgMbDreEmNjZWBQUFmjlzpvLy8hQZGamNGzfaFxnn5OTIw+Nfk0snTpzQDTfcYH+/cOFCLVy4UDfddJMyMjIaunwAANAIuX1B8eTJkzV58uRqP/t1YAkPD5dhGA1QFQAAaKrc/vgFAAAAVyLcAAAAUyHcAAAAUyHcAAAAUyHcAAAAUyHcAAAAUyHcAAAAUyHcAAAAUyHcAAAAUyHcAAAAUyHcAAAAUyHcAAAAUyHcAAAAUyHcAAAAUyHcAAAAU/FydwEAAKB+jE/b7fS2y6wuLKSBMXMDAABMhXADAABMhXADAABMhXADAABMhXADAABMhXADAABMhXADAABMhXADAABMhXADAABMhV8obkzeiXV+2zGrXVcHAABNGDM3AADAVAg3AADAVLgsBZhdXS531gWXSgG4CeEGaArcFVAAoAnishQAADAVZm5c7NH8Gc5vbAtyWR0AAFytmLkBAACmQrgBAACmwmUp1Mn4tN1Ob7ssvq8LKwEA4CJmbgAAgKkQbgAAgKlwWQoAgEasLnfhLg59wYWVNB2EG7Nogg/dZL0OADRemcdPO71tpMuqcA7hBkDj0wTDOoDGg3ADNJSr7REKV9v5Amg0WFAMAABMhXADAABMhctSAADUNy7TNihmbgAAgKkQbgAAgKkQbgAAgKkQbgAAgKmwoBhNEr9ujBrxA4DAVY+ZGwAAYCrM3DQidXqOhy3IZXUAANCUEW4AAKhndfnLKxzHZSkAAGAqzNwAjuBXRgGg0WPmBgAAmArhBgAAmAqXpXDVqdNv5FhdWAgAoF4QbgDgEn4AEDAFwg2uOo/mz3B+Y35PCAAaPcIN3KYuIWNx6AsurAQAYCYsKAYAAKbCzA3qtMC2Tpd4miAekQEAjR/hBgCAWsicF+PuElBLhBsAcAXutAIaDcINmqSr7XJYXXAprQmoQzCq07/fpzc5vS1hDo0Z4cYk6vI/uEdFUEDjQiADXONq/Ysg4QZAvahLQHHXca+6YNREHwRbp18Zj+/rwkrQWDWKcLNkyRItWLBAeXl56t27txYvXqx+/frV2H/NmjX605/+pOzsbEVERGjevHkaPnx4A1YMXB3cFVDQ+NXpz0ZdF+bW4XeuWBR8dXB7uFm9erUSExOVmpqq/v37KyUlRTExMcrKylJISEiV/jt27NDo0aOVlJSk3/72t3rnnXc0atQo7d27Vz169HDDGQC1w4xC4+euf0dNcZbLna7WSy2oPYthGIY7C+jfv7/69u2rV199VZJUUVEhm82mRx99VM8880yV/rGxsSouLtYHH3xgb/u3f/s3RUZGKjU19YrHKyoqUmBgoAoLCxUQEOC6E/n/+FsBAOBqV6fF6jVw5PvbrTM3paWl2rNnj6ZNm2Zv8/DwUHR0tHbu3FntNjt37lRiYmKltpiYGK1fv77a/iUlJSopKbG/LywslHRxkOrD2fMX6mW/AAA0FfXxHXtpn7WZk3FruDl16pTKy8sVGhpaqT00NFSHDh2qdpu8vLxq++fl5VXbPykpSc8991yVdpvN5mTVAADgsmYH1tuuz5w5o8DAy+/f7Wtu6tu0adMqzfRUVFTop59+UuvWrWWxWFx6rKKiItlsNh0/frxeLnnhIsa5YTDODYNxbjiMdcOor3E2DENnzpxRu3btrtjXreEmODhYnp6eys/Pr9Sen5+vsLCwarcJCwtzqL+3t7e8vb0rtQUFBTlfdC0EBATwH04DYJwbBuPcMBjnhsNYN4z6GOcrzdhc4tanglutVvXp00fp6en2toqKCqWnp2vAgAHVbjNgwIBK/SVp8+bNNfYHAABXF7dflkpMTNS4ceMUFRWlfv36KSUlRcXFxUpISJAkxcXFqX379kpKSpIkTZkyRTfddJMWLVqkO++8U6tWrdIXX3yh119/3Z2nAQAAGgm3h5vY2FgVFBRo5syZysvLU2RkpDZu3GhfNJyTkyMPj39NMA0cOFDvvPOOZsyYoWeffVYRERFav359o/iNG29vb82aNavKZTC4FuPcMBjnhsE4NxzGumE0hnF2++/cAAAAuJJb19wAAAC4GuEGAACYCuEGAACYCuEGAACYCuHGQUuWLFF4eLh8fHzUv39/7dq167L916xZo27dusnHx0c9e/bUhg0bGqjSps2RcV66dKmGDBmili1bqmXLloqOjr7ivxdc5Oif50tWrVoli8WiUaNG1W+BJuHoOJ8+fVqTJk1S27Zt5e3tra5du/L/jlpwdJxTUlJ07bXXqnnz5rLZbHr88cd1/vz5Bqq2afr00081YsQItWvXThaLpcbnOv5SRkaGbrzxRnl7e6tLly5KS0ur9zploNZWrVplWK1WY/ny5cZXX31lTJgwwQgKCjLy8/Or7b99+3bD09PTmD9/vvH1118bM2bMMJo1a2Z8+eWXDVx50+LoOI8ZM8ZYsmSJsW/fPuPgwYNGfHy8ERgYaHz//fcNXHnT4ug4X/Ltt98a7du3N4YMGWKMHDmyYYptwhwd55KSEiMqKsoYPny4sW3bNuPbb781MjIyjMzMzAauvGlxdJzffvttw9vb23j77beNb7/91ti0aZPRtm1b4/HHH2/gypuWDRs2GNOnTzfWrl1rSDLWrVt32f7Hjh0zfH19jcTEROPrr782Fi9ebHh6ehobN26s1zoJNw7o16+fMWnSJPv78vJyo127dkZSUlK1/e+9917jzjvvrNTWv39/4+GHH67XOps6R8f51y5cuGD4+/sbK1eurK8STcGZcb5w4YIxcOBA469//asxbtw4wk0tODrOr732mtGpUyejtLS0oUo0BUfHedKkScYtt9xSqS0xMdEYNGhQvdZpJrUJN0899ZRx/fXXV2qLjY01YmJi6rEyw+CyVC2VlpZqz549io6Otrd5eHgoOjpaO3furHabnTt3VuovSTExMTX2h3Pj/Gvnzp1TWVmZWrVqVV9lNnnOjvPzzz+vkJAQjR8/viHKbPKcGef3339fAwYM0KRJkxQaGqoePXropZdeUnl5eUOV3eQ4M84DBw7Unj177Jeujh07pg0bNmj48OENUvPVwl3fg27/heKm4tSpUyovL7f/cvIloaGhOnToULXb5OXlVds/Ly+v3ups6pwZ5197+umn1a5duyr/QeFfnBnnbdu2admyZcrMzGyACs3BmXE+duyYPvnkE913333asGGDjhw5ookTJ6qsrEyzZs1qiLKbHGfGecyYMTp16pQGDx4swzB04cIFPfLII3r22WcbouSrRk3fg0VFRfq///s/NW/evF6Oy8wNTGXu3LlatWqV1q1bJx8fH3eXYxpnzpzR2LFjtXTpUgUHB7u7HFOrqKhQSEiIXn/9dfXp00exsbGaPn26UlNT3V2aqWRkZOill17Sn//8Z+3du1dr167Vhx9+qDlz5ri7NLgAMze1FBwcLE9PT+Xn51dqz8/PV1hYWLXbhIWFOdQfzo3zJQsXLtTcuXO1ZcsW9erVqz7LbPIcHeejR48qOztbI0aMsLdVVFRIkry8vJSVlaXOnTvXb9FNkDN/ntu2batmzZrJ09PT3nbdddcpLy9PpaWlslqt9VpzU+TMOP/pT3/S2LFj9eCDD0qSevbsqeLiYj300EOaPn16pWcawnk1fQ8GBATU26yNxMxNrVmtVvXp00fp6en2toqKCqWnp2vAgAHVbjNgwIBK/SVp8+bNNfaHc+MsSfPnz9ecOXO0ceNGRUVFNUSpTZqj49ytWzd9+eWXyszMtL/uuusuDR06VJmZmbLZbA1ZfpPhzJ/nQYMG6ciRI/bwKEnffPON2rZtS7CpgTPjfO7cuSoB5lKgNHjkosu47XuwXpcrm8yqVasMb29vIy0tzfj666+Nhx56yAgKCjLy8vIMwzCMsWPHGs8884y9//bt2w0vLy9j4cKFxsGDB41Zs2ZxK3gtODrOc+fONaxWq/H3v//dyM3Ntb/OnDnjrlNoEhwd51/jbqnacXScc3JyDH9/f2Py5MlGVlaW8cEHHxghISHGCy+84K5TaBIcHedZs2YZ/v7+xrvvvmscO3bM+Pjjj43OnTsb9957r7tOoUk4c+aMsW/fPmPfvn2GJCM5OdnYt2+f8d133xmGYRjPPPOMMXbsWHv/S7eCP/nkk8bBgweNJUuWcCt4Y7R48WLjmmuuMaxWq9GvXz/jH//4h/2zm266yRg3blyl/n/729+Mrl27Glar1bj++uuNDz/8sIErbpocGecOHToYkqq8Zs2a1fCFNzGO/nn+JcJN7Tk6zjt27DD69+9veHt7G506dTJefPFF48KFCw1cddPjyDiXlZUZs2fPNjp37mz4+PgYNpvNmDhxovHzzz83fOFNyNatW6v9/+2lsR03bpxx0003VdkmMjLSsFqtRqdOnYwVK1bUe50Ww2D+DQAAmAdrbgAAgKkQbgAAgKkQbgAAgKkQbgAAgKkQbgAAgKkQbgAAgKkQbgAAgKkQbgAAgKkQbgCYQnh4uFJSUuzvLRaL1q9fL0nKzs6WxWJRZmZmvdZw880367HHHqvXYwC4MsINgEry8vL06KOPqlOnTvL29pbNZtOIESMqPfwuPDxcFotFFotFLVq00I033qg1a9bYP4+Pj9eoUaOq7DsjI0MWi0WnT592ur60tDQFBQVVad+9e7ceeuiharex2WzKzc1Vjx49nD7uL9V0HmvXrtWcOXNccgwAziPcALDLzs5Wnz599Mknn2jBggX68ssvtXHjRg0dOlSTJk2q1Pf5559Xbm6u9u3bp759+yo2NlY7duxwU+VSmzZt5OvrW+1nnp6eCgsLk5eXV73W0KpVK/n7+9frMQBcGeEGgN3EiRNlsVi0a9cu/e53v1PXrl11/fXXKzExUf/4xz8q9fX391dYWJi6du2qJUuWqHnz5vqf//mfOh2/uhmRzMxMWSwWZWdnKyMjQwkJCSosLLTPHM2ePVtS1ctSv/Try1Lx8fH27X/5ysjIkCS9+eabioqKsp/jmDFjdPLkSfu+hg4dKklq2bKlLBaL4uPjJVW9LPXzzz8rLi5OLVu2lK+vr+644w4dPnzY/vmlWahNmzbpuuuuk5+fn26//Xbl5ubWaRyBqx3hBoAk6aefftLGjRs1adIktWjRosrn1V0KusTLy0vNmjVTaWlpPVYoDRw4UCkpKQoICFBubq5yc3M1depUh/fz8ssv27fPzc3VlClTFBISom7dukmSysrKNGfOHO3fv1/r169Xdna2PcDYbDa99957kqSsrCzl5ubq5ZdfrvY48fHx+uKLL/T+++9r586dMgxDw4cPV1lZmb3PuXPntHDhQr355pv69NNPlZOT49Q5AfiX+p2jBdBkHDlyRIZh2L/ga6u0tFSLFi1SYWGhbrnllnqq7iKr1arAwEBZLBaFhYU5vZ/AwEAFBgZKurhO5i9/+Yu2bNli3+cDDzxg79upUye98sor6tu3r86ePSs/Pz+1atVKkhQSElJj6Dt8+LDef/99bd++XQMHDpQkvf3227LZbFq/fr1+//vfS7oYpFJTU9W5c2dJ0uTJk/X88887fW4AmLkB8P8ZhuFQ/6efflp+fn7y9fXVvHnzNHfuXN155531VF392Ldvn8aOHatXX31VgwYNsrfv2bNHI0aM0DXXXCN/f3/ddNNNkqScnJxa7/vgwYPy8vJS//797W2tW7fWtddeq4MHD9rbfH197cFGktq2bWu/BAbAOczcAJAkRUREyGKx6NChQ7Xq/+STTyo+Pl5+fn4KDQ2VxWKxfxYQEKDvvvuuyjanT5+Wp6dntZe9JMnD4+Lft34ZtH55CceV8vLydNddd+nBBx/U+PHj7e3FxcWKiYlRTEyM3n77bbVp00Y5OTmKiYmpl8tuzZo1q/TeYrE4HDQBVMbMDQBJF+/0iYmJ0ZIlS1RcXFzl81/f9hwcHKwuXbooLCysUrCRpGuvvVZfffWVSkpKKrXv3btXHTt2rPKFfkmbNm0kqdKC2l//No3ValV5eXltT6ta58+f18iRI9WtWzclJydX+uzQoUP68ccfNXfuXA0ZMkTdunWrMpNitVol6bJ1XHfddbpw4YI+//xze9uPP/6orKwsde/evU71A7g8wg0AuyVLlqi8vFz9+vXTe++9p8OHD+vgwYN65ZVXNGDAgFrv57777pPFYlFcXJz27NmjI0eOaPny5UpJSdETTzxR43ZdunSRzWbT7NmzdfjwYX344YdatGhRpT7h4eE6e/as0tPTderUKZ07d87h83z44Yd1/PhxvfLKKyooKFBeXp7y8vJUWlqqa665RlarVYsXL9axY8f0/vvvV/ntmg4dOshiseiDDz5QQUGBzp49W+UYERERGjlypCZMmKBt27Zp//79uv/++9W+fXuNHDnS4ZoB1B7hBoBdp06dtHfvXg0dOlRPPPGEevTooWHDhik9PV2vvfZarfcTFBSkzz77TGVlZbrrrrsUGRmpV155RcnJyXr44Ydr3K5Zs2Z69913dejQIfXq1Uvz5s3TCy+8UKnPwIED9cgjjyg2NlZt2rTR/PnzHT7P//3f/1Vubq66d++utm3b2l87duxQmzZtlJaWpjVr1qh79+6aO3euFi5cWGn79u3b67nnntMzzzyj0NBQTZ48udrjrFixQn369NFvf/tbDRgwQIZhaMOGDTXOXAFwDYvBxV0AAGAizNwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABTIdwAAABT+X8rUl+oucHktAAAAABJRU5ErkJggg==", - "text/plain": [ - "<Figure size 640x480 with 1 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "data = df_host_multi.cpu_utilization\n", - "plt.hist(data, weights=np.ones_like(data) / len(data),\n", - " alpha=0.7, label=\"multi\", bins=30)\n", - "\n", - "\n", - "data = df_host_single.cpu_utilization\n", - "plt.hist(data, weights=np.ones_like(data) / len(data),\n", - " alpha=0.7, label=\"single\", bins=30)\n", - "\n", - "plt.xlabel(\"CPU utilization\")\n", - "plt.ylabel(\"Frequency\")\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 154, - "id": "42c0c638", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "<matplotlib.legend.Legend at 0x7f6fc2cc78b0>" - ] - }, - "execution_count": 154, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 640x480 with 1 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "plt.plot(df_service_single.servers_pending, label=\"servers pending\")\n", - "plt.plot(df_service_single.servers_active, label=\"servers active\")\n", - "\n", - "plt.legend()" - ] - }, - { - "cell_type": "code", - "execution_count": 155, - "id": "1a688c2d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "<matplotlib.legend.Legend at 0x7f6fc02a5db0>" - ] - }, - "execution_count": 155, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 640x480 with 1 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "plt.plot(df_service_multi.servers_pending, label=\"servers pending\")\n", - "plt.plot(df_service_multi.servers_active, label=\"servers active\")\n", - "\n", - "plt.legend()" - ] - }, - { - "cell_type": "code", - "execution_count": 156, - "id": "dc4e17cd", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "<div>\n", - "<style scoped>\n", - " .dataframe tbody tr th:only-of-type {\n", - " vertical-align: middle;\n", - " }\n", - "\n", - " .dataframe tbody tr th {\n", - " vertical-align: top;\n", - " }\n", - "\n", - " .dataframe thead th {\n", - " text-align: right;\n", - " }\n", - "</style>\n", - "<table border=\"1\" class=\"dataframe\">\n", - " <thead>\n", - " <tr style=\"text-align: right;\">\n", - " <th></th>\n", - " <th>timestamp</th>\n", - " <th>server_id</th>\n", - " <th>host_id</th>\n", - " <th>mem_capacity</th>\n", - " <th>cpu_count</th>\n", - " <th>cpu_limit</th>\n", - " <th>cpu_time_active</th>\n", - " <th>cpu_time_idle</th>\n", - " <th>cpu_time_steal</th>\n", - " <th>cpu_time_lost</th>\n", - " <th>uptime</th>\n", - " <th>downtime</th>\n", - " <th>provision_time</th>\n", - " <th>boot_time</th>\n", - " <th>absolute_timestamp</th>\n", - " </tr>\n", - " </thead>\n", - " <tbody>\n", - " <tr>\n", - " <th>0</th>\n", - " <td>1970-01-01 00:05:00+00:00</td>\n", - " <td>b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x06\\xc4]\\x1...</td>\n", - " <td>b'\\xe2 \\xa89{\\x1d\\xcd\\xaf\\x00\\x00\\x00\\x00\\x00\\...</td>\n", - " <td>181</td>\n", - " <td>1</td>\n", - " <td>25600.0</td>\n", - " <td>0</td>\n", - " <td>2624</td>\n", - " <td>0</td>\n", - " <td>0</td>\n", - " <td>300000</td>\n", - " <td>0</td>\n", - " <td>1970-01-01 00:00:00+00:00</td>\n", - " <td>1970-01-01 00:00:00+00:00</td>\n", - " <td>2013-08-12 13:35:46+00:00</td>\n", - " </tr>\n", - " <tr>\n", - " <th>1</th>\n", - " <td>1970-01-01 00:05:00+00:00</td>\n", - " <td>b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x1b9\\x89jQ\\...</td>\n", - " <td>b'\\xe2 \\xa89{\\x1d\\xcd\\xaf\\x00\\x00\\x00\\x00\\x00\\...</td>\n", - " <td>260</td>\n", - " <td>1</td>\n", - " <td>25600.0</td>\n", - " <td>0</td>\n", - " <td>2624</td>\n", - " <td>0</td>\n", - " <td>0</td>\n", - " <td>300000</td>\n", - " <td>0</td>\n", - " <td>1970-01-01 00:00:00+00:00</td>\n", - " <td>1970-01-01 00:00:00+00:00</td>\n", - " <td>2013-08-12 13:35:46+00:00</td>\n", - " </tr>\n", - " <tr>\n", - " <th>2</th>\n", - " <td>1970-01-01 00:05:00+00:00</td>\n", - " <td>b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00,\\x82\\x9a\\xb...</td>\n", - " <td>b'\\xe2 \\xa89{\\x1d\\xcd\\xaf\\x00\\x00\\x00\\x00\\x00\\...</td>\n", - " <td>250</td>\n", - " <td>1</td>\n", - " <td>25600.0</td>\n", - " <td>2</td>\n", - " <td>2622</td>\n", - " <td>0</td>\n", - " <td>0</td>\n", - " <td>300000</td>\n", - " <td>0</td>\n", - " <td>1970-01-01 00:00:00+00:00</td>\n", - " <td>1970-01-01 00:00:00+00:00</td>\n", - " <td>2013-08-12 13:35:46+00:00</td>\n", - " </tr>\n", - " <tr>\n", - " <th>3</th>\n", - " <td>1970-01-01 00:05:00+00:00</td>\n", - " <td>b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00>\\xe5x\\x90A\\...</td>\n", - " <td>b'\\xe2 \\xa89{\\x1d\\xcd\\xaf\\x00\\x00\\x00\\x00\\x00\\...</td>\n", - " <td>125</td>\n", - " <td>1</td>\n", - " <td>25600.0</td>\n", - " <td>0</td>\n", - " <td>2624</td>\n", - " <td>0</td>\n", - " <td>0</td>\n", - " <td>300000</td>\n", - " <td>0</td>\n", - " <td>1970-01-01 00:00:00+00:00</td>\n", - " <td>1970-01-01 00:00:00+00:00</td>\n", - " <td>2013-08-12 13:35:46+00:00</td>\n", - " </tr>\n", - " <tr>\n", - " <th>4</th>\n", - " <td>1970-01-01 00:05:00+00:00</td>\n", - " <td>b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00e~\\xec\\xdd<\\...</td>\n", - " <td>b'\\xe2 \\xa89{\\x1d\\xcd\\xaf\\x00\\x00\\x00\\x00\\x00\\...</td>\n", - " <td>157</td>\n", - " <td>1</td>\n", - " <td>25600.0</td>\n", - " <td>2</td>\n", - " <td>2951</td>\n", - " <td>0</td>\n", - " <td>0</td>\n", - " <td>300000</td>\n", - " <td>0</td>\n", - " <td>1970-01-01 00:00:00+00:00</td>\n", - " <td>1970-01-01 00:00:00+00:00</td>\n", - " <td>2013-08-12 13:35:46+00:00</td>\n", - " </tr>\n", - " </tbody>\n", - "</table>\n", - "</div>" - ], - "text/plain": [ - " timestamp \\\n", - "0 1970-01-01 00:05:00+00:00 \n", - "1 1970-01-01 00:05:00+00:00 \n", - "2 1970-01-01 00:05:00+00:00 \n", - "3 1970-01-01 00:05:00+00:00 \n", - "4 1970-01-01 00:05:00+00:00 \n", - "\n", - " server_id \\\n", - "0 b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x06\\xc4]\\x1... \n", - "1 b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x1b9\\x89jQ\\... \n", - "2 b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00,\\x82\\x9a\\xb... \n", - "3 b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00>\\xe5x\\x90A\\... \n", - "4 b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00e~\\xec\\xdd<\\... \n", - "\n", - " host_id mem_capacity cpu_count \\\n", - "0 b'\\xe2 \\xa89{\\x1d\\xcd\\xaf\\x00\\x00\\x00\\x00\\x00\\... 181 1 \n", - "1 b'\\xe2 \\xa89{\\x1d\\xcd\\xaf\\x00\\x00\\x00\\x00\\x00\\... 260 1 \n", - "2 b'\\xe2 \\xa89{\\x1d\\xcd\\xaf\\x00\\x00\\x00\\x00\\x00\\... 250 1 \n", - "3 b'\\xe2 \\xa89{\\x1d\\xcd\\xaf\\x00\\x00\\x00\\x00\\x00\\... 125 1 \n", - "4 b'\\xe2 \\xa89{\\x1d\\xcd\\xaf\\x00\\x00\\x00\\x00\\x00\\... 157 1 \n", - "\n", - " cpu_limit cpu_time_active cpu_time_idle cpu_time_steal cpu_time_lost \\\n", - "0 25600.0 0 2624 0 0 \n", - "1 25600.0 0 2624 0 0 \n", - "2 25600.0 2 2622 0 0 \n", - "3 25600.0 0 2624 0 0 \n", - "4 25600.0 2 2951 0 0 \n", - "\n", - " uptime downtime provision_time boot_time \\\n", - "0 300000 0 1970-01-01 00:00:00+00:00 1970-01-01 00:00:00+00:00 \n", - "1 300000 0 1970-01-01 00:00:00+00:00 1970-01-01 00:00:00+00:00 \n", - "2 300000 0 1970-01-01 00:00:00+00:00 1970-01-01 00:00:00+00:00 \n", - "3 300000 0 1970-01-01 00:00:00+00:00 1970-01-01 00:00:00+00:00 \n", - "4 300000 0 1970-01-01 00:00:00+00:00 1970-01-01 00:00:00+00:00 \n", - "\n", - " absolute_timestamp \n", - "0 2013-08-12 13:35:46+00:00 \n", - "1 2013-08-12 13:35:46+00:00 \n", - "2 2013-08-12 13:35:46+00:00 \n", - "3 2013-08-12 13:35:46+00:00 \n", - "4 2013-08-12 13:35:46+00:00 " - ] - }, - "execution_count": 156, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_server_single.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 157, - "id": "b0e6c7bf", - "metadata": {}, - "outputs": [], - "source": [ - "utilization = df_host_single.cpu_utilization.to_numpy()" - ] - }, - { - "cell_type": "code", - "execution_count": 161, - "id": "aea7b79d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[<matplotlib.lines.Line2D at 0x7f6f842c6470>]" - ] - }, - "execution_count": 161, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 640x480 with 1 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "window = 2000\n", - "avg_utilization = []\n", - "\n", - "for ind in range(len(utilization) - window + 1):\n", - " avg_utilization.append(np.mean(utilization[ind:ind+window]))\n", - " \n", - "plt.plot(avg_utilization)" - ] - }, - { - "cell_type": "code", - "execution_count": 129, - "id": "575f824b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[<matplotlib.lines.Line2D at 0x7f6f872c7fa0>]" - ] - }, - "execution_count": 129, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 640x480 with 1 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "sum_util = []\n", - "\n", - "last_util = 0\n", - "for util in utilization:\n", - " sum_util.append(util + last_util)\n", - " last_util = sum_util[-1]\n", - " \n", - "plt.plot(sum_util)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d99dfce2", - "metadata": {}, - "outputs": [], - "source": [ - "output_file = \"../Python_scripts/meta_small.parquet\"\n", - "output_file_path = Path(output_file)\n", - "\n", - "df_meta_new.to_parquet(output_file_path, index=False)\n", - "\n", - "output_file = \"../Python_scripts/trace_small.parquet\"\n", - "output_file_path = Path(output_file)\n", - "df_trace_new.to_parquet(output_file_path, index=False)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/opendc-experiments/opendc-experiments-portfolio/src/main/kotlin/org/opendc/experiments/scenario/ExamplePortfolio.kt b/opendc-experiments/opendc-experiments-portfolio/src/main/kotlin/org/opendc/experiments/scenario/ExamplePortfolio.kt deleted file mode 100644 index b5b174b6..00000000 --- a/opendc-experiments/opendc-experiments-portfolio/src/main/kotlin/org/opendc/experiments/scenario/ExamplePortfolio.kt +++ /dev/null @@ -1,69 +0,0 @@ -/* - * Copyright (c) 2022 AtLarge Research - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in all - * copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. - */ - -package org.opendc.experiments.scenario - -import org.opendc.compute.service.scheduler.ComputeSchedulerEnum -import org.opendc.experiments.base.models.portfolio.Portfolio -import org.opendc.experiments.base.models.scenario.AllocationPolicySpec -import org.opendc.experiments.base.models.scenario.FailureModelSpec -import org.opendc.experiments.base.models.scenario.Scenario -import org.opendc.experiments.base.models.scenario.ScenarioSpec -import org.opendc.experiments.base.models.scenario.TopologySpec -import org.opendc.experiments.base.models.scenario.WorkloadSpec -import org.opendc.experiments.base.models.scenario.WorkloadTypes -import org.opendc.experiments.base.models.scenario.getScenario - -/** - * A [Portfolio] that explores the difference between horizontal and vertical scaling. - */ -public fun getExamplePortfolio(): Portfolio { - val topologies = - listOf( - TopologySpec("resources/env/single.json"), - TopologySpec("resources/env/multi.json"), - ) - - val workloads = - listOf( - WorkloadSpec("resources/bitbrains-small", type = WorkloadTypes.ComputeWorkload), - ) - - val failureModel = FailureModelSpec(0.0) - val allocationPolicy = AllocationPolicySpec(ComputeSchedulerEnum.ActiveServers) - - val scenarios: Iterable<Scenario> = - topologies.flatMap { topology -> - workloads.map { workload -> - getScenario( - ScenarioSpec( - topology, - workload, - allocationPolicy, - failureModel, - ), - ) - } - } - - return Portfolio(scenarios) -} diff --git a/opendc-experiments/opendc-experiments-portfolio/src/main/kotlin/org/opendc/experiments/scenario/PortfolioCli.kt b/opendc-experiments/opendc-experiments-portfolio/src/main/kotlin/org/opendc/experiments/scenario/PortfolioCli.kt deleted file mode 100644 index 10ba33d6..00000000 --- a/opendc-experiments/opendc-experiments-portfolio/src/main/kotlin/org/opendc/experiments/scenario/PortfolioCli.kt +++ /dev/null @@ -1,64 +0,0 @@ -/* - * Copyright (c) 2022 AtLarge Research - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in all - * copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. - */ - -@file:JvmName("PortfolioCli") - -package org.opendc.experiments.portfolio - -import com.github.ajalt.clikt.core.CliktCommand -import com.github.ajalt.clikt.parameters.options.default -import com.github.ajalt.clikt.parameters.options.defaultLazy -import com.github.ajalt.clikt.parameters.options.option -import com.github.ajalt.clikt.parameters.types.file -import com.github.ajalt.clikt.parameters.types.int -import org.opendc.experiments.base.models.portfolio.getPortfolio -import org.opendc.experiments.base.runner.runPortfolio -import java.io.File - -/** - * Main entrypoint of the application. - */ -public fun main(args: Array<String>): Unit = PortfolioCommand().main(args) - -/** - * Represents the command for the Portfolio experiments. - */ -internal class PortfolioCommand : CliktCommand(name = "portfolio") { - /** - * The path to the environment directory. - */ - private val portfolioPath by option("--portfolio-path", help = "path to portfolio file") - .file(canBeDir = false, canBeFile = true) - .defaultLazy { File("resources/portfolio.json") } - - /** - * The number of threads to use for parallelism. - */ - private val parallelism by option("-p", "--parallelism", help = "number of worker threads") - .int() - .default(Runtime.getRuntime().availableProcessors() - 1) - - override fun run() { - val portfolio = getPortfolio(portfolioPath) - runPortfolio(portfolio, parallelism) - } -} diff --git a/opendc-experiments/opendc-experiments-portfolio/src/main/resources/bitbrains-small/interference-model.json b/opendc-experiments/opendc-experiments-portfolio/src/main/resources/bitbrains-small/interference-model.json deleted file mode 100644 index 51fc6366..00000000 --- a/opendc-experiments/opendc-experiments-portfolio/src/main/resources/bitbrains-small/interference-model.json +++ /dev/null @@ -1,21 +0,0 @@ -[ - { - "vms": [ - "141", - "379", - "851", - "116" - ], - "minServerLoad": 0.0, - "performanceScore": 0.8830158730158756 - }, - { - "vms": [ - "205", - "116", - "463" - ], - "minServerLoad": 0.0, - "performanceScore": 0.7133055555552751 - } -] diff --git a/opendc-experiments/opendc-experiments-portfolio/src/main/resources/bitbrains-small/trace/meta.parquet b/opendc-experiments/opendc-experiments-portfolio/src/main/resources/bitbrains-small/trace/meta.parquet Binary files differdeleted file mode 100644 index 9cded35f..00000000 --- a/opendc-experiments/opendc-experiments-portfolio/src/main/resources/bitbrains-small/trace/meta.parquet +++ /dev/null diff --git a/opendc-experiments/opendc-experiments-portfolio/src/main/resources/bitbrains-small/trace/trace.parquet b/opendc-experiments/opendc-experiments-portfolio/src/main/resources/bitbrains-small/trace/trace.parquet Binary files differdeleted file mode 100644 index 9d953956..00000000 --- a/opendc-experiments/opendc-experiments-portfolio/src/main/resources/bitbrains-small/trace/trace.parquet +++ /dev/null diff --git a/opendc-experiments/opendc-experiments-portfolio/src/main/resources/env/multi.json b/opendc-experiments/opendc-experiments-portfolio/src/main/resources/env/multi.json deleted file mode 100644 index 721005b0..00000000 --- a/opendc-experiments/opendc-experiments-portfolio/src/main/resources/env/multi.json +++ /dev/null @@ -1,66 +0,0 @@ -{ - "clusters": - [ - { - "name": "C01", - "hosts" : - [ - { - "name": "H01", - "cpus": - [ - { - "coreCount": 32, - "coreSpeed": 3200 - } - ], - "memory": { - "memorySize": 256000 - } - } - ] - }, - { - "name": "C02", - "hosts" : - [ - { - "name": "H02", - "count": 6, - "cpus": - [ - { - "coreCount": 8, - "coreSpeed": 2930 - } - ], - "memory": { - "memorySize": 64000 - } - } - ] - }, - { - "name": "C03", - "hosts" : - [ - { - "name": "H03", - "count": 2, - "cpus": - [ - { - "coreCount": 16, - "coreSpeed": 3200 - } - ], - "memory": { - "memorySize": 128000 - } - } - ] - } - ] -} - - diff --git a/opendc-experiments/opendc-experiments-portfolio/src/main/resources/env/single.json b/opendc-experiments/opendc-experiments-portfolio/src/main/resources/env/single.json deleted file mode 100644 index a1c8d95a..00000000 --- a/opendc-experiments/opendc-experiments-portfolio/src/main/resources/env/single.json +++ /dev/null @@ -1,26 +0,0 @@ -{ - "clusters": - [ - { - "name": "C01", - "hosts" : - [ - { - "name": "H01", - "cpus": - [ - { - "coreCount": 8, - "coreSpeed": 3200 - } - ], - "memory": { - "memorySize": 128000 - } - } - ] - } - ] -} - - diff --git a/opendc-experiments/opendc-experiments-portfolio/src/main/resources/log4j2.xml b/opendc-experiments/opendc-experiments-portfolio/src/main/resources/log4j2.xml deleted file mode 100644 index e479f2ca..00000000 --- a/opendc-experiments/opendc-experiments-portfolio/src/main/resources/log4j2.xml +++ /dev/null @@ -1,43 +0,0 @@ -<?xml version="1.0" encoding="UTF-8"?> -<!-- - ~ MIT License - ~ - ~ Copyright (c) 2020 atlarge-research - ~ - ~ Permission is hereby granted, free of charge, to any person obtaining a copy - ~ of this software and associated documentation files (the "Software"), to deal - ~ in the Software without restriction, including without limitation the rights - ~ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - ~ copies of the Software, and to permit persons to whom the Software is - ~ furnished to do so, subject to the following conditions: - ~ - ~ The above copyright notice and this permission notice shall be included in all - ~ copies or substantial portions of the Software. - ~ - ~ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - ~ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - ~ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - ~ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - ~ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - ~ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - ~ SOFTWARE. - --> - -<Configuration status="WARN"> - <Appenders> - <Console name="Console" target="SYSTEM_OUT"> - <PatternLayout pattern="%d{HH:mm:ss.SSS} [%highlight{%-5level}] %logger{36} - %msg%n" disableAnsi="false"/> - </Console> - </Appenders> - <Loggers> - <Logger name="org.opendc" level="warn" additivity="false"> - <AppenderRef ref="Console"/> - </Logger> - <Logger name="org.apache.hadoop" level="warn" additivity="false"> - <AppenderRef ref="Console"/> - </Logger> - <Root level="error"> - <AppenderRef ref="Console"/> - </Root> - </Loggers> -</Configuration> diff --git a/opendc-experiments/opendc-experiments-portfolio/src/main/resources/portfolio.json b/opendc-experiments/opendc-experiments-portfolio/src/main/resources/portfolio.json deleted file mode 100644 index a1320b39..00000000 --- a/opendc-experiments/opendc-experiments-portfolio/src/main/resources/portfolio.json +++ /dev/null @@ -1,31 +0,0 @@ -{ - "scenarios": [ - { - "runs": 5, - "topology": { - "pathToFile": "resources/env/single.json" - }, - "workload": { - "pathToFile": "resources/bitbrains-small", - "type": "ComputeWorkload" - }, - "allocationPolicy": { - "policyType": "Mem" - } - }, - { - "runs": 5, - "name": "TESTTTT", - "topology": { - "pathToFile": "resources/env/single.json" - }, - "workload": { - "pathToFile": "resources/bitbrains-small", - "type": "ComputeWorkload" - }, - "allocationPolicy": { - "policyType": "Mem" - } - } - ] -} diff --git a/opendc-experiments/opendc-experiments-portfolio/src/test/resources/env/single.txt b/opendc-experiments/opendc-experiments-portfolio/src/test/resources/env/single.txt deleted file mode 100644 index 5642003d..00000000 --- a/opendc-experiments/opendc-experiments-portfolio/src/test/resources/env/single.txt +++ /dev/null @@ -1,3 +0,0 @@ -ClusterID;ClusterName;Cores;Speed;Memory;numberOfHosts;memoryCapacityPerHost;coreCountPerHost -A01;A01;8;3.2;128;1;128;8 - diff --git a/opendc-experiments/opendc-experiments-portfolio/src/test/resources/env/topology.txt b/opendc-experiments/opendc-experiments-portfolio/src/test/resources/env/topology.txt deleted file mode 100644 index 6b347bff..00000000 --- a/opendc-experiments/opendc-experiments-portfolio/src/test/resources/env/topology.txt +++ /dev/null @@ -1,5 +0,0 @@ -ClusterID;ClusterName;Cores;Speed;Memory;numberOfHosts;memoryCapacityPerHost;coreCountPerHost -A01;A01;32;3.2;2048;1;256;32 -B01;B01;48;2.93;1256;6;64;8 -C01;C01;32;3.2;2048;2;128;16 - diff --git a/opendc-experiments/opendc-experiments-portfolio/src/test/resources/trace/bitbrains-small/interference-model.json b/opendc-experiments/opendc-experiments-portfolio/src/test/resources/trace/bitbrains-small/interference-model.json deleted file mode 100644 index 51fc6366..00000000 --- a/opendc-experiments/opendc-experiments-portfolio/src/test/resources/trace/bitbrains-small/interference-model.json +++ /dev/null @@ -1,21 +0,0 @@ -[ - { - "vms": [ - "141", - "379", - "851", - "116" - ], - "minServerLoad": 0.0, - "performanceScore": 0.8830158730158756 - }, - { - "vms": [ - "205", - "116", - "463" - ], - "minServerLoad": 0.0, - "performanceScore": 0.7133055555552751 - } -] diff --git a/opendc-experiments/opendc-experiments-portfolio/src/test/resources/trace/bitbrains-small/meta.parquet b/opendc-experiments/opendc-experiments-portfolio/src/test/resources/trace/bitbrains-small/meta.parquet Binary files differdeleted file mode 100644 index 9cded35f..00000000 --- a/opendc-experiments/opendc-experiments-portfolio/src/test/resources/trace/bitbrains-small/meta.parquet +++ /dev/null diff --git a/opendc-experiments/opendc-experiments-portfolio/src/test/resources/trace/bitbrains-small/trace.parquet b/opendc-experiments/opendc-experiments-portfolio/src/test/resources/trace/bitbrains-small/trace.parquet Binary files differdeleted file mode 100644 index 9d953956..00000000 --- a/opendc-experiments/opendc-experiments-portfolio/src/test/resources/trace/bitbrains-small/trace.parquet +++ /dev/null diff --git a/opendc-experiments/opendc-experiments-scenario/src/main/Python_scripts/multimodel-retry.ipynb b/opendc-experiments/opendc-experiments-scenario/src/main/Python_scripts/multimodel-retry.ipynb new file mode 100644 index 00000000..02d91831 --- /dev/null +++ b/opendc-experiments/opendc-experiments-scenario/src/main/Python_scripts/multimodel-retry.ipynb @@ -0,0 +1,40 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "initial_id", + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import os" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/opendc-experiments/opendc-experiments-scenario/src/main/Python_scripts/multimodel.ipynb b/opendc-experiments/opendc-experiments-scenario/src/main/Python_scripts/multimodel.ipynb new file mode 100644 index 00000000..4d7b86e3 --- /dev/null +++ b/opendc-experiments/opendc-experiments-scenario/src/main/Python_scripts/multimodel.ipynb @@ -0,0 +1,281 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# OpenDC MultiModel Demo" + ], + "metadata": { + "collapsed": false + }, + "id": "fb60c8069ab28634" + }, + { + "cell_type": "markdown", + "source": [ + "> this file assembles multiple simulation models into a single simulation tool -- <b>the multimodel</b>\n", + "> we leverage the outputs of the simulation models, in the same plot\n", + "> and more :>" + ], + "metadata": { + "collapsed": false + }, + "id": "6db427bbc013a04f" + }, + { + "cell_type": "markdown", + "source": [ + "### 0. Imports" + ], + "metadata": { + "collapsed": false + }, + "id": "613ddc7764c074d2" + }, + { + "cell_type": "code", + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import os\n", + "import pyarrow.parquet as pq\n", + "import fastparquet as fp" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-04-19T10:30:32.973554Z", + "start_time": "2024-04-19T10:30:31.719379Z" + } + }, + "id": "bfbf3ccebf48cde4", + "execution_count": 1 + }, + { + "cell_type": "markdown", + "source": [ + "### 1. Load the outputs of the simulation models" + ], + "metadata": { + "collapsed": false + }, + "id": "46656be1992088cc" + }, + { + "cell_type": "code", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "We are now in: /Users/raz/atlarge/opendc/demo/output/simulation-results\n", + "['scenario-simple-model-linearPowerModel-200.0-350.0-scheduler-Mem-topology-topologies-topology-very-single.json-19e6b2a5', 'scenario-simple-model-linearPowerModel-200.0-350.0-scheduler-Mem-topology-topologies-topology-very-single.json-8589863e', 'scenario-simple-model-sqrtPowerModel-200.0-350.0-scheduler-Mem-topology-topologies-topology-single.json-da112dce', 'scenario-simple-model-linearPowerModel-200.0-350.0-scheduler-Mem-topology-topologies-topology-very-single.json-34bf5727', 'scenario-simple-model-linearPowerModel-200.0-350.0-scheduler-Mem-topology-topologies-topology-very-single.json-aae0172e', 'scenario-simple-model-linearPowerModel-200.0-350.0-scheduler-Mem-topology-topologies-topology-very-single.json-a93605da', 'scenario-simple-model-sqrtPowerModel-200.0-350.0-scheduler-Mem-topology-topologies-topology-single.json-b9b34193', 'scenario-simple-model-sqrtPowerModel-200.0-350.0-scheduler-Mem-topology-topologies-topology-single.json-01208bd2', 'scenario-simple-model-linearPowerModel-200.0-350.0-scheduler-Mem-topology-topologies-topology-very-single.json-82898d7d', 'scenario-simple-model-sqrtPowerModel-200.0-350.0-scheduler-Mem-topology-topologies-topology-single.json-f5ae7b9d', 'scenario-simple-model-sqrtPowerModel-200.0-350.0-scheduler-Mem-topology-topologies-topology-single.json-3ccd8e37', 'scenario-simple-model-sqrtPowerModel-200.0-350.0-scheduler-Mem-topology-topologies-topology-single.json-0835f003', 'scenario-simple-model-sqrtPowerModel-200.0-350.0-scheduler-Mem-topology-topologies-topology-single.json-02b41c5b', 'scenario-simple-model-sqrtPowerModel-200.0-350.0-scheduler-Mem-topology-topologies-topology-single.json-abff34a7', 'scenario-simple-model-linearPowerModel-200.0-350.0-scheduler-Mem-topology-topologies-topology-very-single.json-3a3fa887', 'scenario-simple-model-linearPowerModel-200.0-350.0-scheduler-Mem-topology-topologies-topology-very-single.json-f47c3a90']\n" + ] + } + ], + "source": [ + "os.chdir('../../../../../demo/output/simulation-results')\n", + "print(\"We are now in: \", os.getcwd())\n", + "\n", + "# loop through the files, take only the first word of the file name, which is in format modelname-*\n", + "model_names = [file.split('-')[0] for file in os.listdir()]\n", + "directories = [d for d in os.listdir() if os.path.isdir(d)]\n", + "\n", + "# output data is a list of lists -- there are multiple arrays, and each array has data for host, server, service, in this order\n", + "# basically we will have\n", + "host_data = []\n", + "server_data = []\n", + "service_data = []\n", + "\n", + "print(directories)\n", + "\n", + "# loop through each directory and add the data to the list\n", + "for directory in directories:\n", + " host_data.append(pd.read_parquet(os.path.join(directory, 'host.parquet')))\n", + " server_data.append(pd.read_parquet(os.path.join(directory, 'server.parquet')))\n", + " service_data.append(pd.read_parquet(os.path.join(directory, 'service.parquet')))" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-04-19T10:30:34.027701Z", + "start_time": "2024-04-19T10:30:32.974958Z" + } + }, + "id": "df9bb28b2ca1ced1", + "execution_count": 2 + }, + { + "cell_type": "markdown", + "source": [ + "### 2. Define useful functions" + ], + "metadata": { + "collapsed": false + }, + "id": "434a191b3b902e14" + }, + { + "cell_type": "code", + "outputs": [], + "source": [ + "def mean_of_chunks(series, chunk_size):\n", + " return series.groupby(np.arange(len(series)) // chunk_size).mean(numeric_only=True)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-04-19T10:30:34.030345Z", + "start_time": "2024-04-19T10:30:34.028390Z" + } + }, + "id": "5d832e6bbd09c8ac", + "execution_count": 3 + }, + { + "cell_type": "code", + "outputs": [], + "source": [ + "def plot_singular_model(single_model):\n", + " plt.figure(figsize=(20,10))\n", + " plt.plot(single_model)\n", + " plt.show()" + ], + "metadata": { + "collapsed": false + }, + "id": "6b1e2a5c7c656307", + "execution_count": 4 + }, + { + "cell_type": "code", + "outputs": [], + "source": [ + "def plot_multi_model(multi_model):\n", + " plt.figure(figsize=(20,10))\n", + " for model in multi_model:\n", + " plt.ylabel(\"POwer draw [W]\")\n", + " plt.xlabel(\"Seconds [S]\")\n", + " \n", + " # make the y-label between 0-500\n", + " plt.ylim(0, 500)\n", + " \n", + " # add some shadows up and down as a standard deviation\n", + " plt.fill_between(model.index, model - 10, model + 10, color='gray', alpha=0.5)\n", + " \n", + " plt.ylim(0, 500)\n", + " plt.plot(model)\n", + " plt.show()" + ], + "metadata": { + "collapsed": false + }, + "id": "295c7f5fd087324d", + "execution_count": 5 + }, + { + "cell_type": "code", + "outputs": [ + { + "data": { + "text/plain": "<Figure size 2000x1000 with 1 Axes>", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABlkAAANGCAYAAAB+1ug/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9d5Ach33n/X+6e+KG2ZwDciZAgGACKUYxiKKss8T7XUnyybYsn2UVz49tPadzqX4un0Pdyfa5rOfucbrST5alsn22dWVRFiWKImmJEkGABEAu0mIXu4vF5hxmNkzs7t8fw2nsYBdpEJYA3q8qlKnpPLs74+pPf79fw3VdVwAAAAAAAAAAALgi5mqfAAAAAAAAAAAAwM2IkAUAAAAAAAAAAKAAhCwAAAAAAAAAAAAFIGQBAAAAAAAAAAAoACELAAAAAAAAAABAAQhZAAAAAAAAAAAACkDIAgAAAAAAAAAAUABCFgAAAAAAAAAAgAIQsgAAAAAAAAAAABSAkAUAAAAAAAAAAKAAqxqy/O7v/q4Mw8j7t3XrVm95IpHQ888/r6qqKpWUlOi5557T2NhY3j76+/v17LPPqqioSLW1tfriF7+oTCZzoy8FAAAAAAAAAADcZnyrfQI7duzQq6++6v1vn+/cKf3mb/6mvve97+lb3/qWysrK9B//43/Uxz/+ce3fv1+SZNu2nn32WdXX1+vNN9/UyMiIfv7nf15+v1//7b/9txt+LQAAAAAAAAAA4PZhuK7rrtbBf/d3f1cvvPCC2trali2LRqOqqanR3//93+vf/tt/K0nq6OjQtm3bdODAAd1///166aWX9JGPfETDw8Oqq6uTJP3VX/2Vfuu3fksTExMKBAI38nIAAAAAAAAAAMBtZNUrWbq6utTY2KhQKKR9+/bpy1/+slpbW3XkyBGl02k98cQT3rpbt25Va2urF7IcOHBAO3fu9AIWSXr66af1+c9/XidPntSePXtWPGYymVQymfT+t+M4mp6eVlVVlQzDuH4XCwAAAAAAAAAA3vdc19Xc3JwaGxtlmheevLKqIct9992nv/mbv9GWLVs0MjKi3/u939NDDz2kEydOaHR0VIFAQOXl5Xnb1NXVaXR0VJI0OjqaF7DklueWXciXv/xl/d7v/d61vRgAAAAAAAAAAHBLGRgYUHNz8wWXr2rI8swzz3j/vWvXLt13331as2aN/umf/knhcPi6HfdLX/qSvvCFL3j/OxqNqrW1VQMDA4pEItftuAAAAAAAAAAA4P0vFouppaVFpaWlF11v1duFLVVeXq7Nmzeru7tbTz75pFKplGZnZ/OqWcbGxlRfXy9Jqq+v19tvv523j7GxMW/ZhQSDQQWDwWWvRyIRQhYAAAAAAAAAACBJlxwxcuFGYqtgfn5ePT09amho0N69e+X3+/Xaa695yzs7O9Xf3699+/ZJkvbt26fjx49rfHzcW+eVV15RJBLR9u3bb/j5AwAAAAAAAACA28eqVrL8p//0n/QzP/MzWrNmjYaHh/Vf/st/kWVZ+uQnP6mysjJ99rOf1Re+8AVVVlYqEono137t17Rv3z7df//9kqSnnnpK27dv16c//Wn98R//sUZHR/Xbv/3bev7551esVAEAAAAAAAAAALhWVjVkGRwc1Cc/+UlNTU2ppqZGH/jAB3Tw4EHV1NRIkr7yla/INE0999xzSiaTevrpp/UXf/EX3vaWZenFF1/U5z//ee3bt0/FxcX6hV/4Bf3+7//+al0SAAAAAAAAAAC4TRiu67qrfRKrLRaLqaysTNFolJksAAAAAAAAAADc5i43N3hfzWQBAAAAAAAAAAC4WRCyAAAAAAAAAAAAFICQBQAAAAAAAAAAoACELAAAAAAAAAAAAAUgZAEAAAAAAAAAACgAIQsAAAAAAAAAAEABCFkAAAAAAAAAAAAKQMgCAAAAAAAAAABQAEIWAAAAAAAAAACAAhCyAAAAAAAAAAAAFICQBQAAAAAAAAAAoACELAAAAAAAAAAAAAUgZAEAAAAAAAAAACgAIQsAAAAAAAAAAEABCFkAAAAAAAAAAAAKQMgCAAAAAAAAAABQAEIWAAAAAAAAAACAAhCyAAAAAAAAAAAAFICQBQAAAAAAAAAAoACELAAAAAAAAAAAAAUgZAEAAAAAAAAAACgAIQsAAAAAAAAAAEABCFkAAAAAAAAAAAAKQMgCAAAAAAAAAABQAEIWAAAAAAAAAACAAhCyAAAAAAAAAAAAFICQBQAAAAAAAAAAoACELAAAAAAAAAAAAAUgZAEAAAAAAAAAACgAIQsAAAAAAAAAAEABCFkAAAAAAAAAAAAKQMgCAAAAAAAAAABQAEIWAAAAAAAAAACAAhCyAAAAAAAAAAAAFICQBQAAAAAAAAAAoACELAAAAAAAAAAAAAUgZAEAAAAAAAAAACgAIQsAAAAAAAAAAEABCFkAAAAAAAAAAAAKQMgCAAAAAAAAAABQAEIWAAAAAAAAAACAAhCyAAAAAAAAAAAAFICQBQAAAAAAAAAAoACELAAAAAAAAAAAAAUgZAEAAAAAAAAAACgAIQsAAAAAAAAAAEABCFkAAAAAAAAAAAAKQMgCAAAAAAAAAABQAEIWAAAAAAAAAACAAhCyAAAAAAAAAAAAFICQBQAAAAAAAAAAoACELAAAAAAAAAAAAAUgZAEAAAAAAAAAACgAIQsAAAAAAAAAAEABCFkAAAAAAAAAAAAKQMgCAAAAAAAAAABQAEIWAAAAAAAAAACAAhCyAAAAAAAAAAAAFICQBQAAAAAAAAAAoACELAAAAAAAAAAAAAUgZAEAAAAAAAAAACgAIQsAAAAAAAAAAEABCFkAAAAAAAAAAAAKQMgCAAAAAAAAAABQAEIWAAAAAAAAAACAAhCyAAAAAAAAAAAAFICQBQAAAAAAAAAAoACELAAAAAAAAAAAAAUgZAEAAAAAAAAAACgAIQsAAAAAAAAAAEABCFkAAAAAAAAAAAAKQMgCAAAAAAAAAABQAEIWAAAAAAAAAACAAhCyAAAAAAAAAAAAFICQBQAAAAAAAAAAoACELAAAAAAAAAAAAAUgZAEAAAAAAAAAACgAIQsAAAAAAAAAAEABCFkAAAAAAAAAAAAKQMgCAAAAAAAAAABQAEIWAAAAAAAAAACAAhCyAAAAAAAAAAAAFICQBQAAAAAAAAAAoACELAAAAAAAAAAAAAUgZAEAAAAAAAAAACgAIQsAAAAAAAAAAEABCFkAAAAAAAAAAAAKQMgCAAAAAAAAAABQAEIWAAAAAAAAAACAAhCyAAAAAAAAAAAAFICQBQAAAAAAAAAAoACELAAAAAAAAAAAAAUgZAEAAAAAAAAAACgAIQsAAAAAAAAAAEABCFkAAAAAAAAAAAAKQMgCAAAAAAAAAABQAEIWAAAAAAAAAACAAhCyAAAAAAAAAAAAFICQBQAAAAAAAAAAoACELAAAAAAAAAAAAAUgZAEAAAAAAAAAACgAIQsAAAAAAAAAAEABCFkAAAAAAAAAAAAKQMgCAAAAAAAAAABQAEIWAAAAAAAAAACAAhCyAAAAAAAAAAAAFICQBQAAAAAAAAAAoACELAAAAAAAAAAAAAUgZAEAAAAAAAAAACgAIQsAAAAAAAAAAEABCFkAAAAAAAAAAAAKQMgCAAAAAAAAAABQAEIWAAAAAAAAAACAAhCyAAAAAAAAAAAAFICQBQAAAAAAAAAAoACELAAAAAAAAAAAAAUgZAEAAAAAAAAAACgAIQsAAAAAAAAAAEABCFkAAAAAAAAAAAAKQMgCAAAAAAAAAABQAEIWAAAAAAAAAACAAhCyAAAAAAAAAAAAFICQBQAAAAAAAAAAoACELAAAAAAAAAAAAAUgZAEAAAAAAAAAACgAIQsAAAAAAAAAAEABCFkAAAAAAAAAAAAKQMgCAAAAAAAAAABQAEIWAAAAAAAAAACAAhCyAAAAAAAAAAAAFICQBQAAAAAAAAAAoACELAAAAAAAAAAAAAUgZAEAAAAAAAAAACgAIQsAAAAAAAAAAEABCFkAAAAAAAAAAAAKQMgCAAAAAAAAAABQAEIWAAAAAAAAAACAAhCyAAAAAAAAAAAAFICQBQAAAAAAAAAAoACELAAAAAAAAAAAAAUgZAEAAAAAAAAAACgAIQsAAAAAAAAAAEABCFkAAAAAAAAAAAAK8L4JWf7wD/9QhmHoN37jN7zXEomEnn/+eVVVVamkpETPPfecxsbG8rbr7+/Xs88+q6KiItXW1uqLX/yiMpnMDT57AAAAAAAAAABwu3lfhCyHDh3S//pf/0u7du3Ke/03f/M39d3vflff+ta39Prrr2t4eFgf//jHveW2bevZZ59VKpXSm2++qW984xv6m7/5G/3O7/zOjb4EAAAAAAAAAABwm1n1kGV+fl4/93M/p69+9auqqKjwXo9Go/ra176mP/3TP9Xjjz+uvXv36utf/7refPNNHTx4UJL0wx/+UO3t7frbv/1b7d69W88884z+4A/+QH/+53+uVCq1WpcEAAAAAAAAAABuA6sesjz//PN69tln9cQTT+S9fuTIEaXT6bzXt27dqtbWVh04cECSdODAAe3cuVN1dXXeOk8//bRisZhOnjx5wWMmk0nFYrG8fwAAAAAAAAAAAFfCt5oH/4d/+Ae98847OnTo0LJlo6OjCgQCKi8vz3u9rq5Oo6Oj3jpLA5bc8tyyC/nyl7+s3/u937vKswcAAAAAAAAAALezVatkGRgY0K//+q/r7/7u7xQKhW7osb/0pS8pGo16/wYGBm7o8QEAAAAAAAAAwM1v1UKWI0eOaHx8XHfddZd8Pp98Pp9ef/11/c//+T/l8/lUV1enVCql2dnZvO3GxsZUX18vSaqvr9fY2Niy5bllFxIMBhWJRPL+AQAAAAAAAAAAXIlVC1k++MEP6vjx42pra/P+3X333fq5n/s577/9fr9ee+01b5vOzk719/dr3759kqR9+/bp+PHjGh8f99Z55ZVXFIlEtH379ht+TQAAAAAAAAAA4PaxajNZSktLdccdd+S9VlxcrKqqKu/1z372s/rCF76gyspKRSIR/dqv/Zr27dun+++/X5L01FNPafv27fr0pz+tP/7jP9bo6Kh++7d/W88//7yCweANvyYAAAAAAAAAAHD7WNXB95fyla98RaZp6rnnnlMymdTTTz+tv/iLv/CWW5alF198UZ///Oe1b98+FRcX6xd+4Rf0+7//+6t41gAAAAAAAAAA4HZguK7rrvZJrLZYLKaysjJFo1HmswAAAAAAAAAAcJu73Nxg1WayAAAAAAAAAAAA3MwIWQAAAAAAAAAAAApAyAIAAAAAAAAAAFAAQhYAAAAAAAAAAIACELIAAAAAAAAAAAAUgJAFAAAAAAAAAACgAIQsAAAAAAAAAAAABSBkAQAAAAAAAAAAKAAhCwAAAAAAAAAAQAEIWQAAAAAAAAAAAApAyAIAAAAAAAAAAFAAQhYAAAAAAAAAAIACELIAAAAAAAAAAAAUgJAFAAAAAAAAAACgAIQsAAAAAAAAAAAABSBkAQAAAAAAAAAAKAAhCwAAAAAAAAAAQAEIWQAAAAAAAAAAAApAyAIAAAAAAAAAAFAAQhYAAAAAAAAAAIACELIAAAAAAAAAAAAUgJAFAAAAAAAAAACgAIQsAAAAAAAAAAAABSBkAQAAAAAAAAAAKAAhCwAAAAAAAAAAQAEIWQAAAAAAAAAAAApAyAIAAAAAAAAAAFAAQhYAAAAAAAAAAIACELIAAAAAAAAAAAAUgJAFAAAAAAAAAACgAIQsAAAAAAAAAAAABSBkAQAAAAAAAAAAKAAhCwAAAAAAAAAAQAEIWQAAAAAAAAAAAApAyAIAAAAAAAAAAFAAQhYAAAAAAAAAAIACELIAAAAAAAAAAAAUgJAFAAAAAAAAAACgAIQsAAAAAAAAAAAABSBkAQAAAAAAAAAAKAAhCwAAAAAAAAAAQAEIWQAAAAAAAAAAAApAyAIAAAAAAAAAAFAAQhYAAAAAAAAAAIACELIAAAAAAAAAAAAUgJAFAAAAAAAAAACgAIQsAAAAAAAAAAAABSBkAQAAAAAAAAAAKAAhCwAAAAAAAAAAQAEIWQAAAAAAAAAAAApAyAIAAAAAAAAAAFAAQhYAAAAAAAAAAIACELIAAAAAAAAAAAAUgJAFAAAAAAAAAACgAIQsAAAAAAAAAAAABSBkAQAAAAAAAAAAKAAhCwAAAAAAAAAAQAEIWQAAAAAAAAAAAApAyAIAAAAAAAAAAFAAQhYAAAAAAAAAAIACELIAAAAAAAAAAAAUgJAFAAAAAAAAAACgAIQsAAAAAAAAAAAABSBkAQAAAAAAAAAAKAAhCwAAAAAAAAAAQAEIWQAAAAAAAAAAAApAyAIAAAAAAAAAAFAAQhYAAAAAAAAAAIACELIAAAAAAAAAAAAUgJAFwE3Btm2lUqnVPg0AAAAAAAAA8PhW+wQA3Bzm5ubkOI4CgYCCwaBM8/pltLZta3h4WENDQxobG9PU1JRmZ2eVyWS0efNmPf300wqHw9ft+AAAAAAAAABwOQhZAFzS4uKi3njjDcXjcfl8PlmWpVAopKKiIoXDYYVCIQWDQQWDQS+ECQQCCgQCMgzjovtOpVIaGhrS4OCgxsfHNTU1pWg0qkwmI9u2vfVyoc7Jkyc1MDCgRx55RLt27bqu1w0AAAAAAAAAF0PIAuCS+vr6FIvFVFFRIdu2Zdu25ubmNDs76wUhruvKMAyZpinLsrwwJhwOq7i4WOFwWIZhaHp6WrOzs4rFYopGo1pYWFAmk5Hrunn7ME1TgUBAlmXlnUsmk1E0GtX3vvc9tbe365lnnlFZWdlqvC0AAAAAAAAAbnOELAAuKh6Pq7e3V+FwWIFA4KLruq4rx3GUyWQUj8c1PT2tubk5JZNJJZNJ2bYtx3EkSYZhLAtVfD6fDMPw/knKW98wDPl8PhUVFSmVSqm7u1t//dd/rX379umee+5ZFsgAAAAAAAAAwPVEyALgovr6+jQ3N6eampoVlzuOo8XFRcViMS0sLGhxcVHxeDyvOiXn/CBFUt7yTCaz4jFy6+ZCFp/Pp1AoJNu2tbi4qH/9139VR0eHPvzhD6u2tvZaXToAAAAAAAAAXBQhC4ALSiQS6u3tVSgUkmmachxHc3NzisViWlxc1MLCghKJhBzH8SpOpHNVJ6Zpev/3Qi42s2VpAJOrkkmlUkqn017YkqtqGRwc1De/+U3dddddeuSRR6hqAQAAAAAAAHDdEbIAuKCBgQHFYjFVVVWpra1Ni4uLsm07L/xY2sZL0kUDlSu1NIBZWvniuq7S6bQymYw3/8Xn8ymRSOjAgQPq7u7WU089pbVr116zcwEAAAAAAACA8127u6EAbimpVEo9PT0KBoOam5vT3NycbNv2ApVAIKBAICC/3y+fz+fNVbnels5wkbItxhKJhNLptILBoHw+n8bHx/VP//RP+v73v69UKnXdzwkAAAAAAADA7YmQBcCKBgYGFI1GFYlENDMzI9d1vaqRGxGmXEoubLEsS6ZpyrZtJZNJOY4jv9+vdDqtd999V1/96lfV0dGx2qcLAAAAAAAA4BZEuzBgBalUSjMzM5qdndX4+LhCoZDuvvvui84PuZWk02n19PQoEAjINE3Nzc1JuratwK4lwzBkWZbXSiyTyXhtzGZmZvTCCy9o48aN+tCHPqSSkpLVPl0AAAAAAAAAtwhCFkDZUGF2dlazs7OamJjQ9PS04vG4HMeRZVkyDEPNzc1qaGhY7VO9IQYHBzU7O6uqqio5jqOFhYWbImDKBSu5sMVxHEnZlmIdHR0aHBzUww8/rLvuumuVzxQAAAAAAADArYCQBbcl27YVjUY1MzOjyclJTU5OKh6Py7ZtWZalUCikyspKWZYlSZqcnFRnZ6dqa2u9125VmUxG3d3d8vl8sixLMzMz3iyWm8XSsEWSHMeR67qKxWJ66aWXdOLECX3kIx9RZWXlKp8pAAAAAAAAgJsZIQtuC47jKBaLaWZmRlNTU5qYmFA8Hlc6nZZpmgqFQiovL5fPt/KfRHl5ucbHxzUwMKC1a9fe2JO/wYaGhjQzM6OqqipJypvHcrPJBUO5VmJSNmA7e/asvvrVr2rv3r167LHHbsprAwAAAAAAALD6CFlwS3JdV3Nzc5qZmdH09LTGx8e1uLioVCol0zQVDAZVWloqn8930QoNx3E0PT0twzDk8/l0+vRpNTQ0KBgM3sCruXFyVSyWZXnBw/t9Hsvlyv0MXdeVbdtKJpN68803dfLkST3xxBPatm3bTX+NAAAAAAAAAG4sQhbcElzX1cLCgmZnZzU9Pa2xsTEtLCwomUzKMAwFg0EVFxervLz8km2vcsHK5OSkZmdnlU6n5fP5dM8992hqakq9vb3aunXrDbqyG2t4eFjT09OqqKiQpPfFPJbQ/KxqJwdUMzOmaGm5utbdJcMqPAxZGrZkMhnNzs7q29/+tt566y099thjam5ult/vv4ZXAAAAAAAAAOBWRciCm5LruorH45qdndXMzIzGxsY0NzenZDIpSQoEAgqFQiorK7usgGClYCXXXsowDGUyGc3NzSkcDqunp0ctLS0qLi6+rtd4o9m2rZ6eHi+EkKRoNCrbtnWm5IyGioYUckIKO2EV2UXn/q8dVtgJy9TVVYG4tqOSuUnVTw6qdnpU5TOzCs4m5cbP7bdZQ9p6ukM/2feEYhX1V3U8wzDk9/vlOI4ymYwGBwf1j//4j1q/fr12796t5uZmFRUVXdUxAAAAAAAAANzaCFlw00gkEl6oMj4+rmg0qmQyKdd15ff7FQqFFIlELrvq4mLBimVZMgxDpml6N+Gnp6e1fv16jY2Nqbu7W3feeef1vNwbbmRkRFNTUyorK/Nem5mZ0YK5oHcq3pFjOBfe2JUXwITt80KY3GtOkYJOUIYMuZmMKmZHVDc1pJrpcZXPxOSbTctNmeft1pTkyiiVEpGgQqNJWeO2Hn/xBxq8o0mHdz4mXWCOzuUyTVOBQEC2bSuVSqmzs1PDw8Nas2aN1q1bp9bWVlVUVKxqNQ8AXIxt25LEfCkAAAAAAFYBIQve1xKJhPr7+zU+Pq6ZmRklEgm5riufz6dQKKSSkpIrmqNxucHKUrn/HYvFZBiGSktLdfbsWbW0tKiysvLaXewqchxHPT09kpTXKmtubk6dkU45hqPKVKVaE62KW3EtmouKW3HFzbjiVlyO4ShhJZSwEprxz+Tt25dx1TIhrR9ztX7U1YZRV80TrgKZ/NDClSmZrpyIocWKYk1VVGm0qlGT1S3KBLMVJaUzo3r4wKvyjdtqOjqspr6/0/59D2mybv1Vvwe5n79t24rFYuro6NDk5KR6e3tVV1entWvXqq6ujpuYAN53vv/972t4eFif+9znVvtUAAAAAAC47RCy4H1rampKbW1tmpyc9EKVysrKK77JfbFgxTRNWZZ1yaDGMAzF43HZtq2ioiKNj4+rq6tL99577y1R4TA6OqqJiYm8KhbHcTQZn1RvXa8kaffcbjWkGpZt68pV0kwqbsaVTs+oYnpINVNTqp5aVM1UWlXTrizn/PfIUMIvna2VztYZ6q03dLbO0EC1lPEZ8jm2ws6ciuwBhZ1Jrzqm0l+p6NOf1B2dB7W57bTcWVMP/uAnmtpyUm/e9aScQOiq3gfTNGWapmzbVjqd1ujoqBYXF7W4uKjh4WFVVFRo06ZNamlpuSV+7gBufqlUSl1dXUomkxoZGVFDw/LPaQAAAAAAcP0QsuB9x3Vd9fb26sSJE0omk6qurl6VYGWp3I336elp1dTUqLy8XIODg1qzZo3q669uNshqy1Wx5Nqu5USjUZ0qPiXbtFWVqlJ9Kv86cwPp66ZHVDk9o/BsXO78SsGDISPgKFXh10Rlqfqqy9RbX67ByqDigWw4s2gtKm7GZZpxSSllzIzmzDnN+eaW7a0iXaGzJVu1pXWrHnvrVYUHEqrqmNZHB/9Bh++9R4OtO676PclVtTiOo2g0qng8rsbGRknSkSNH5Pf7uZEJ4H2hra1N8XhcknTq1Ck+mwAAAAAAuMEIWfC+kkwmdfLkSZ05c0Z+v1/V1dVXNGNlZmZGExMT1yRYWcowDLmuq5mZGdXU1CgYDCoWi6mzs1M1NTU3dQup8fFxjY2N5VWxSNLwzLC6S7olSXumNmlj97sXHEgvSa6yPycj7CpZEdRMRbnGq+o0Vt2q+eJKGda59YslbUlKSi4/n4yRyQtecu3JFqwFDYeGNeOf0YHyA3q3NKR36rfr6RMJ3fvWSbnzhvb+62FtWXdKP73naaWKSq/qfclVtTiOo1Qqpb6+PpWWlqqmpkZHjx5VSUmJSkuv7hgAcLXa29u977r+/v5VPhsAAAAAAG4/hCx435idnVVbW5t3wz8UunTrp+sZrCyV28fc3LnKivLyco2Pj3sVLTcj13XV09Mjx3EUCATylr2Vfkt2yFZFukK//OKbMifPDb5fOpB+sTys6cpKjVU2aLy6Wcni8mXHuZLGWj7Xp1K7VKX28gAjaSTVXdStzuJOxa24jpUe04n7TW3dskG/8uNxNXbOq6R3QR8e+T86sfcOda3fmxfuFMI0Tfl8PjmOo1gspkQiIdM0dfToUd1///3y+fgYBbA6JicnNTY2Jp/PJ9d1NTExoXg8rnA4vNqnBgAAAADAbYO7g1h1ruuqv79fJ06c0MLCwiXbg92oYOV8pmkqkUgolUopEAjI7/fLsix1dnaqoaFhWUhxM5iYmNDo6OiyKpaFzIJOBE5Iku4e3yBzclySoYW1RZqsrNZYVaMmlgykv1GCblA7FnZo28I29Yf61VHcoanAlNor+/UbH5ce6CnXr748q1DU1I797drU263X739Si5Hqqzpurqolk8konU7L5/NpaGhI7e3t2rlzJ/NZAKyKI0eOKJPJKBwOy3EcJZNJdXZ2avfu3at9agAAAAAA3DYIWbCq0um02tvb1d3dLdM0VVNTs+IN69UIVhw5mvXNato/raZkkwJGQLZta2pqyut5X1ZWpsnJSfX29mrLli3X9PjXW66KxbZtBYPBvGWvTL6itJlWJB3Rfb3zkgwZEVevPvr/WZ2TPY8pU2sTa7UmsUaT/kl1FHdoIDSgNzfM6+1fsfSpNwx9+K20AsMpPfUvL+rMnet0dPtD16SqJZPJKBaLqaGhQV1dXaqoqFBLS8s1ujIAVyIej+tb3/qWHn30UbW2tq726dxQtm2rq6tL0rlqS9d1debMGUIWAAAAAABuIEIWrJpYLKajR49qeHhYpaWlKipaXhWRTqd15swZzczMXPdgxZWrmC+m0cCoxoJjGguMKWWmJElVqSo9OfGkpGxbs1zIYlmWQqGQenp61NzcrOLi4mt2Ptfb1NSURkZGFIlE8l5POkntT+yXDGnH3A61jB6XJM3WlK20m1VlyFBNukY1szVaMBfUWdypnqIeffPRlH60w6fPf9/WxmFD646c1Zq+fv1032OarWou+Hi537dYLKYNGzYokUjo+PHjikQiy6qBAFx/XV1dGhoa0ptvvnnbhSynT59WLBbzWhaapinDMDQ0NLTKZwYAAAAAwO2FkAU3nOu6Gh4e1rFjxxSLxVRVVXXBuRY9PT0aHx+XdH2ClXlr3gtVRgOjSliJvOU+xyfHcDQVmNJA0YAaY415c1kkKRKJaHx8XD09Pdq1a9c1O7frKVfFkslkls2+eWP+DSWMhErSJVqbXKuKiZ9KkobqCw8nboRip1h3zd2lnfM71RvuVUdFh/6/n47p6XdcferHjkKTjh7+3qsa3V6vt+/8oOT3F3QcwzAUj8dl27YqKio0Pj6utrY27du376ZsGQfczHp7e5XJZDQwMKBoNHpbhZ3Hjh2T4zh5n+E+n0/z8/MaHBxUc/P7+zMbAAAAAIBbBSELbqhMJqPOzk51dnbKdV3V1tZecJ7F4uKipqamZBiG/AXeED9f3IznhSoLvoW85ZZrqSZVo7pknepT9apMV+pkyUkdKz2mttI2Ncw3KJVK5Q0WNgxDJSUl6u3tVWtrq8rLy6/JuV5P09PTXgXRUiknpdeir0mStsa2KrS4IM26kgwNNGxahTO9cn7Xr82Lm7VpcZOGg8Nq29mhQ5tG9B9ednRXj9RwYkxPDv692u67XxMNV97izTRN2bat6elp1dTUqKqqSqOjozp58qR2797NfBbgBhoeHpZhGEqlUjp06JCeeOKJ1T6lGyIej6u/v9+bF5Xj9/sVj8fV2dlJyAIAAAAAwA1CyIIbZmFhQUePHtXAwIBKSkou2Vqrr69Ptm1fsMrlciSNpNf6azQwqpg/lrfccA1VpatUn6xXfape1alqWbLy1tm2sE1dRV1a8C2oO9KtTbObNDk5mTeHo6ioSOPj4zp9+rTuueee9/WNdtd11dvbq3Q6vSwQOjB/QHPOnIoyRVq3uE7NoyeUm8eSKClfaXfvW4YMNSWb1JRs0qxvVt/68Cnt7+vRL7xiKzIr3f/yQZ2846hO3/m0fP7Lf/rdMAy5rquZmRnV1NTI5/MpEomop6dH5eXlWrdu3fW7KACeaDSqaDQqn88n27Z16tQpPfbYY7Is69Ib3+SOHDmiVCq1rBLRNE25rqu+vr5VOjMAAAAAAG4/hCy4IUZHR3Xs2DFNT0+rqqrqkpUp8/Pzmp6elmEYV9QeLG2kNR4Y11hgTGPBMU37pqWleYcrVWYqVZesU12qTrWpWvnd5efi2o6qJ/u15exJVU1OK7ynSX+zN6720na1xloVi50X1hiGysrKNDg4qDVr1qiuru6yz/lGm52d1eDgoEpKSvLCoIyb0auxVyVJW6Nb5TN9ah4dyG7zPpzHciXKM+W6f26fEtV79P/7xAnd//YpPXDS0c4TcTX0v6CXHqmWU/egyjPll9xX7vdxadu4cDisZDKpkydPqqysTJWVldfrUgC8p6OjQ7ZtKxQKyTRNzc3Nqb29XTt37lztU7vuTp06Jdd1VwyULMvS1NRUXsUlAAAAAAC4fghZcF05jqPTp0+ro6NDmUxGtbW1lxWanD179rKqWGzZmgxMajQwqtHgqKb8U3INN2+dSDqi+lS96pP1qk3VKugGV9zX0mCldmBC7vy5AOKZQwN6YVe1Zv2zOlV2SqVzpXIcJ+9aQqGQ5ubm1NnZqerq6vft09S9vb1KJpPLZhe8Pf+2Zu1ZFTlFWju/VmbAVMX4rKT3/zyWyxVyQtqguzV6zx59t3W/Htzfq+qY9OnvTuqnO/5FL32gVs3aqcZkowxduBrJNE0lEgmlUilvDktZWZkmJibU1tamBx54YNkT5gCurf7+fi9oyLUMa2tru+VDlsHBQU1NTV3w+9Hv9yuZTOrUqVO66667bvDZAQAAAABw+yFkwXUTj8d17Ngx9fX1KRwOq6ys7LLaaM3NzSkaja5YxeLI0bR/2purMhGYkG3YeeuUZEpUl6rz5qqEnQs/yevajqqmB7T1zIm8YMWVIcNylawLKjCckjHjat/oFr3U8pZ6Snu0aX6T5ufnFYlE8vZXXl6usbExDQ0NqbW19XLfqhsmGo167dqW/ixs19YrsVckSVvntspn+BRYnPPmsQw2bFylM85yHEdSttXZlVY3rcSSJafuYe1/9m7tPPoDtZ6K6aGT0p1nxvSNJyb03c0RbY1v0/r4evnc5R+ThmHItm1NTU2poaHBe62qqkoTExM6ceKE7rrrrqs+TwAXNjIy4n2OmaYpn8+nkZERTUxMqKamZpXP7vp59913lclkVFRUtOLyXMuwM2fOELIAAAAAAHADELLgupicnFRbW5smJydVWVnpPe1/OZZWsbhyNeub1WhwNNsCLDCmjJnJWz9kh1SfqvdClRK75KL7zwUrW3pPqK5/ebCSqA/pTOs6nVm7U5lgkf7NP39Dihm6t3dGbbUNGgmO6FjZMW2d2rosZPH7/TJNU52dnaqvr7+i674Rent7lUgkVFtbm/f6kYUjmsxMqtgo1trYWhmGoebRLkmGjFJX8ZIKL+iQlBfQXOv5M47jyHXdvH9Lj5V7cv1aVAo5wSIdvffjGm49o3sP/lSRWenXvuuobV1UX/3Q2zpae1QbFzdq88JmFTvnZgjlrnl2dtYLWaRsm57y8nL19vaqvLxcGzeubjgF3KpGRka0sLCQV80RCAQUj8d16NAhffjDH17Fs7t+bNvWmTNn8sPmdFLb2n6svvU7tVjVKNM0ZRiGhoaGZNv2+7aqEgAAAACAWwUhC64px3HU29urkydPKplMXnZ7sJzZ2VlFo1GZpqnJ4KQOlB/QvG8+b52AE/BmqtSn6hXJRC7a2kk6L1gZmJA7tyRYMV0lGvKDlaVm6spVEZtVy+iA9sQe00j1iAaLB9U116V1Wj7kvLy8XJOTk+rr69OmTZsu+9qvt7m5OfX39y+rYnFcRz+M/lCStNveLcuxZPpMbx5LtDbihR25J6TPDz+WulAAs1IYszRQOT/EMQxDfr9f4XBYRUVFKikpkeu6GhgYUDKZlOM4sizrmlSLTNSv1/c+0qJ7jv1IjSeGtbtX+tOv2vrfjyT00t0ndar4lFoSLdq6sFU16ZoV57LkBINBBYNBbz7LrfxEPbBaTp8+LcdxFAyea/+Y+7s8ffq0nnjiifddyH0tHD9+XPPz83lzzXYeeUWNbUNqHBzUax/7rCTJ5/NpcXHxfVtVCQAAAADArYSQBddMMpnU8ePH1dvbq0AgoOrq6iuucujr65Pt2Oop71FbpE2u4crn+FSbqs2GKsl6lWfKZerSN9Zd21H19IA2XzBYCepM6/oVg5Wl+hvXqKJrVmVjMVVkKrQhvkE9RT06EDigD9ofXPaUsGVZCoVC6urqUlNT0wVbutxovb29isfjy6pY2hbbNJYZU5FZpA2zGxRXXKa5ZB5LXbMcx5HP5/NuWi4NWc6vOlna2uti60nKa/UTDAZVVFTkBSplZWUrzjWpqalRT0+PpqamlMlkrllVi3x+HbrrKZWtHdbDB15TcMLRL77m6MkT0lc+IvXX9qs/3K+Nixt1b/RemaapVCqlxcXFZT/j0tJSr5rrwQcffN/8DgC3isHBQS/4XSoQCGhhYUFtbW269957V+nsrp+TJ0/KdV2vgse1HTV1D8qVId9EWlZ8QXa4WH6/X4uLi+ro6CBkAQAAAADgOiNkwTUxMzOjtrY2jY2Nqby8vKCh39PT05qan9LbNW9rqGhIkrQmvkb3Re+T3/VfYuusc8HKSdUNjK8YrPS2rlfPJYKVpQYbN+tOo03uvKHi2XHtMnfpbOisJoOT2j+5Xw/XPbxsm0gkovHxcfX09LwvhjDPz8+rr69PxcXFy6pYXo6+LEl6uORhZQYzMgwjbx5L/3vzWHw+n7ftpcKzTCajTCaTV6mSq07JhTWhUEh+v1+hUEjhcHZuztJAZm5uTouLi16I4vP55PP55Pf7tXXrVk1NTenMmTNKJBLXtKolWtmof/nQz2lnx35tbOtR05ih//7XGb25N6y/fDSj7qJuVaYrtWF+gzKZjKamppaFKEvnsxw7dkz33HMPLXuAa8S2bY2Nja34954b+n7ixIlbLmSJRqMaGhrK+6yrGTzltbyUY6ih74QGt97nLR8YGFit0wUAAAAA4LZByIKr4rqu+vr6dOLECS0uLqqmpqbgm8nvDL6jV+te1YJ/QaZram9srzYtbrqsVmAXC1aS9UGdWbNePWt2KhO68oqCTLBITqUlc8rR2qHTWij/gLbNb9OJyAn9MP5DPeA+IJ+R/6dkGIaKi4vV29urlpYWlZeXX/Fxr6W+vj4tLCyorq4u7/WT8ZMaTg8rZIR0l+5Sd6Z72TyWhaKyCwYYuRAlk8nItm2viiU3LyAQCKisrExVVVWqra1VU1OTmpqavIoYx3GUSqWUTCaVTCa9/06lUorH41pcXNTi4qL3+vz8vBzHUUlJiSorK735J2NjY8pkMt7w66tlWKZO7HhIPa079MjBHyo4lNSDhxO6s0v6vecsHa49rMpUpUozpYpGo2ppaVm2D9M0VVFRof7+fpWXl2vr1q1XfV4AsnO7EonEBf/WfT6fxsfHNTAwsOLf5s3q8OHDSqfTeQ8xbOloy/6H4UquodaBHg1uvU9StqpyampK8/PzKim5+KwyAAAAAABQOEIWFCydTuvkyZPq7u6Wz+dTTU1NQUPQXdfVK6Ov6HuR78kxHBVnivXQ7EOqSlddeBvbUdX04HszVi4UrKxTz5pdBQUr55uor1Ld1ISaRod1coe0fXG7uoq7FLWiemPuDT0aeXTZNsXFxRofH1dXV5fuvvvuaz4g/nItLi6qt7d3WRWL67r6QfQHkqSHSh9SfCbuDZVfOo9Fyj4d7rqubNv2KlSWBiqWZSkcDqusrEzV1dWqq6tTU1OTGhoaLhq6maapUCh0ycqnTCajVCqlubk5DQwMaGhoSHNzcwqHw1q/fr1qa2vV3d2thYUFpdPpa1bVEi+t1A+e/IQ2dB/RzsPHVBI19Zvfs/Ubv2TojYo39ETiCS/4Wel4gUBARUVFOnXqlMrKytTQ0HDV5wTc7rq7u/NaZp0vEAhocXFRhw8fvqVCls7OTu8zWpLMxIJKB+bkytDkthpVt08qMhyTazsyLNOr6uno6NDdd9+9ymcPAAAAAMCti5AFBYlGozp69KhGRkYUiUS8dk9XKuWk9I/T/6i3U29LhtSYaNQDsw8o6AaXrXuxYEWmq9Q1DlaW6mtcr7qTEyoaX5BrO/Jbft0xe4eOVB3RS7Mv6d7ie1VkLW8ZVVZWpoGBAa1Zs2bZLJQbJVfFcv7xOxId6k/1y2/49VjkMZ3pPyNJefNYBuqavBt6i4uLXqBSXFysyspKVVVVqb6+Xi0tLaqsrLxuLbFyrcKKiopUV1enzZs3a3BwUGfPntXk5KR8Pp927Nih0dFRDQ0NeVUtuX9Xq2fjXo3WrtET//w9NY65qpsLa6x0Xm9Xv60HJx7U3NycysrKVty2pKREk5OTOnbsmEpLS3miHLhKQ0ND3jwW/0JUViqhRMW5Kr3c3/2ZM2cUj8cL/n56P+np6VE0Gs0beL++4225GUNGiat37v+wnu78hty4obLxPsUa1snn8ymRSKi3t5eQBQAAAACA64iQBVfEdV0NDQ3p2LFjmpubU1VVVcHtmcbSY/raxNc0kh6R4RraGd2pO+J35LUHW81gZamR2g0yrINyk6aqpwc0VbNGG+Ib1JXqUiwQ0w9jP9TPVvzssu1CoZDm5ubU2dmp6urqa3LD/0rE43H19vYqHA5fsIrlAyUfULFR7IUoefNY6jbK5/PJtm2ZpqmHH35YO3fuvGCgcKNEIhFt375dGzZs0NDQkHp7ezUzM6OioiJt27ZNfX19mpubUyaTkc/nuybv+0KkWopIihn65PEa/c99gxoOD6uztFPNU80XfU8qKys1MTGho0eP6r777rsmLc2A21EqldLU1JQsy5JrO3r8X/5BxoKrn3zso1qsavTWCwQCSiQSOnz4sB566KFVPONr4+jRo7JtW8HguQcQ1vV0S5KGNzTJDYSVqg3IP5LWmr6TOt6wTlI2cBoeHpZt28yFAgAAAADgOrmxd3xxU8tkMjpx4oTefvttJRIJ1dbWFnyz+J2Fd/TfR/67RtIjCjkhPTz2sHYs7MgLWHzJRX30pb/TQ9/7kWrbJ7IBi+kq1RhQx/1b9L1/92/10lOfVOeW+69rwOK6rlyfT6ma7ByRNUPZG1uWYWnXzC5J0uux1zWVmVpx+/Lyco2NjWloaOi6neOF5MKG86snupPdOpM8I598+mDkg4rFYspkskPvm0a7lZvHkiqrkmVZsm1bgUBA+/btW/WAZalgMKj169fr0Ucf1QMPPKCmpiZJUkNDg5qamuT3+5XJZJROp732Zldjpq5cknTH4ITujmWfDD9eflydi50X3c40TVVWVmpwcFCnTp2S67pXfS7A7aizs1OpVEo+n0+RqQEpKrkZQ9tPvJm3ns/nk+u6am9vX6UzvXZSqZTOnj2bV5lXPDEoc8KRDFed27IzWIYbs59/dUMj3raWZWlxcVH9/f03/sQBAAAAALhNELLgsszPz+vgwYNqb29XMBhUZWVlQTNGMm5G/2f6/+jrk19X0k2q1WjVk8NPqj5dv6za4K4TP5U56awcrGy9X5nQ9Wm75LquHMeRbdveMHfHcTRan21HUz86Jil747wh2aD6VL0yyui7M99dcX9+v1+GYaizs1PpdPq6nPNKcm1iQqHQsvc2V8Wyr2SfynxlmpmZ8drvNI9mb8ZFayLy+XwyDEO2bau6uvp9+yS0ZVlqbGzUvn379Mgjj2jLli2qqalRS0uLSktLJWVDQtu2r+o4/Y1rJEllYzFtXNyotYtr5RquflT0I82mZy+6rd/vV0lJibq6ulYlcANuBWfPnj03O6qvw3u9+syEjFQib12/36/p6Wl1dXXd6NO8pt59913F43EFAgHvta2n3pYkpesDSpZnW0H2r9spSbImbVnxeUnZ98BxHJ0+ffoGnzUAAAAAALcPQhZc0sjIiPbv36+hoSFVVlaquLi4oP1MZ6b1/4z+P3p97nVJ0hOlT+iR8UcUspeHAIHFOTV2ZJ/GPXX/9usarLiumxes5CoeLMtSIBBQMBiUaZrqbdiQPbeJlPReWGIapu6cuVOGDB1ZPKKzybMrHqO8vFzT09Pq6+u75ud/IQMDA4rFYl7IkNOb7NXpxGmZMvVE2ROSpLm5OUnvVVy8N49lqL5ZlmV578fNMLTdMAxVVlZq9+7devzxx3Xvvfdq+/btamhokN/vl23bV1XVMti4WTJcufOGSmfHdV/sPkXSEcWtuL42+jU57sX3m/vbOXbsmKLRaEHnANzOhoeHZRiGTNNU/ciw97qbNLWu4628dXN/8++8886NPs1rqr29Xa7repWjbiajmt5xSVLPpq3eeovVjTJKXck11Nx7TFL2M911XSpZAAAAAAC4jghZcFGdnZ06ePCg5ubmVFNTkzd090qcjJ/UH438kfpSfSoyi/S5ms/pnsQ9SsaTsixrWchy9/GfyE0bUpnUueHaDuxdKVRxXVeGYcjv9ysYDCoUCikYDMrv93tD1ycqmmQEHbm2oYbxHknZG1iRREQ7jB2SpBdmXlixFVQusOnq6lI8Hr+m17OSVCqlnp4eLyBaKlfFcl/Jfar0VcpxHC0sLJw3j0UabtkqwzC8IfLr16+/7ud9LRUXF2vz5s16/PHH9dRTT+m+++5TeXm5pGxVSyaTueJ9ZoJFcqqy1Txrh07L5/r0gekPyHIsnXXO6vuz37/kPioqKjQ3N6e2trYbWtkE3Oyi0ahmZ2ezFXWZtILjSUlSsik7p2RDZ361hmmasixL/f39N22oOT4+rvHx8bzWnE29R+XGDRkBR32b8r8fpxsrJUnNA73eaz6fTzMzM5qfn78xJw0AAAAAwG2GkAUXlEql1NXVJcMwCh7a7riOXpx5UX81/ldadBbVGmjVf274z9oe2q7BwUGv7ctSoflZ1XZNSJKO79opw7q6X9PLDVVCoZACgYA3KH1pOzSfzyfL79NibXb2y5rhM5LkvSd7FvbIb/jVk+zR8fjxFc8jEokoGo3qzJkzV3U9l2NgYEDRaFSRSCT/9eSA2uPtMmToyciTknTBeSzp8hpJ8uax3GwhS47f71dra6seffRRfeITn9Ddd9+tYDAox3GUTCavuKploq5aktQ4mn2KvsKp0N1T2RudL8de1sn4yYtubxiGqqqqNDo6qpMnTzKfBbhMnZ2dymQy8vv9qhzqlpvJBg0HHnpWMlyZU47KhnvytgkEAkqlUjp06NAqnfXVOXLkiNLpdF6rsE2nT0iSZtZWSv5A3vr9LZskSaUjMbl29rPN7/crnU7r5MmLfzYBAAAAAIDCELLgolzXzbu5cyVidkx/NvZnejn2siTpodKH9Bv1v6EqX5WGhoaUSCRWnPFxz7GfyM0YcisM9azdXdA5nx+qOI4jwzDk8/kuK1TJsW1b8XhcyWRSfr9fg/WNkqSa0fwh927M1WOlj0mSvjPzHdnu8tkfpmmqpKREPT091/Wp6nQ6rZ6eHgUCgWXBWO5nsbd4r2r82RBlxXkstRHv/Xi/z2O5XKZpqra2Vs8884z+w3/4D9q8ebN8Pp/S6bTS6fRlhx19jdmwqWh80buJuSa+RhvnN0qSvjn5TU1npi+6D5/Pp0gkou7u7hvaQg64mfX393vBfOtgds5KvK5IyfIaJZrDkqQdJ9/O2yb3uXXq1Kmrnsl0o9m2re7ubq89miT552cUGspWQ3ZsXV7lObpmhwzLlZswVTGaDfQty5LrunzWAAAAAABwnRCy4LroTnTrj0b+SF3JLgWMgH6x+hf17yr/nfxGdgjvyEh23sr5N+7Dc1Oq6sneoG67c/dlV7FcKlQJh8NeC7CLhSrSuWBlfn5eiURCpml6lR59TVskSea0LV9iMfvfpql0Oq191j6VmCUaz4xr//z+FfddXFyseDyurq6u61bBMDg4qNnZ2WVVLMOpYR1dPCpDhp6KPOW9vtI8lpGGVkm6qeaxXInKykp94hOf0Kc//WnV1GTDpqVhy8V+NiO162X4XLlJU1XTA5Ky792d03eqwWjQorOov574a2Xci7cjC4fD8vl8OnHihGZmZq7dxQG3qJGREe9zu2Z0LPtaQ5Mk6dS2PZKkSF9UZjy/LZbf79fc3Jza29tv4Nlevc7OTs3NzeW16dx46i3JMaRyKdq4YflG/oCSddn2aa39p7yXTdPU0NDQTRc0AQAAAABwMyBkwTXluI5ejb6q/3fs/1XMjqnB36AvNnxRe4v3eusMDAxcsIrlvqM/kWsbcqpN9bXcccHjLA1Vlg6r9/l8CgQCXqXK5YQq0vJgxbIsNTU16eGHH9Yzzzwj0zRl27ZSNU0ySt4bLDyS7f+fGyy8MLOgZ8qfkSS9NPuS4s7y2SuGYSgSiWhgYECTk5OX96ZegUwmo+7u7mx7s/Pe3x9GfyhJurPoTjUEsqHJ0nks/iXzWEZatnr7uxnnsVyu1tZWfe5zn9Pjjz+ucDgs13WVTqfz2sot4/crVZOt7lo71C0p+3M1XVNPxJ9QkVmkvlSfXph54ZLHLysr0+Liotra2pRMJq/lpQG3lLGxMS0sLGRneCUWZE5lw4LB1u3Z5WvukBGR3IyhzSffzNvW5/PJcRy1tbXd6NO+KseOHZPjOHnzWFp7stUofRvWXnC74aZmSVLd0Kj3ms/nUzwe19mzZ6/LuQIAAAAAcDsjZME1s2gv6qsTX9V3Zr8jR47uKb5H/3f9/616f723jm3bF6xiKZ4dV9mZbButI3fuzatiuVCokhsoHwqFFA6HvWH1lmVdNFTJncuFgpXPfe5z+sxnPqOHHnpIO3bsUDAY9AKHaF22QqR1OHuzKxeyRKNRPVjyoGp9tZp35vVK9JUVjxsOh5VOp9XZ2XnF80AuZWhoSDMzMyorK8t7fTw9rncW35EkPV32tPd63jyWkXPzWJJl1d57dDPPY7kclmXpwQcf1C//8i9r48aN3g3Zpf/OD1tG6uskSfWj2ZuYuVY+RszQp6s+LUl6fe51HVk4ctFj5+azjI2N6fjx49f89wG4VZw+fVq2bcvv96t+oENyDBnFrharsy0cDctU36a1kqQ1p3u9Vn5S9u/TsiyNjIxoYmJiNU7/is3Pz2tgYCAbKr33+VI+1C3NSjJd9Wy/P299x3GUyWSr5/rX7ZQkmVO2/AvZ71SfzyfXdXX69Okbdg0AAAAAANwuCFlwTfQn+/VHI3+kE/ET8smnT1R+Qp+u+rSCZjB/vf5+pdPpFatY7j/6E8kxlKm1NNySfTrZdd2LhiqhUOiyQxUpGxokEolLBitLQwrLslRbW+u1IBtqXCNJqhib9dYxDCNbEeIa+tmKn5Uk/XjuxxeczVFeXq7R0VENDw9f8pwvV65/v2VZK1axuHJ1R/gONQeavdeXzmNpGcu2vorVluXt81aYx3I5Kioq9KlPfUrPPPOM9/M/f75PLmzpa8wOlw5MpGWmU5KyN3KTyaQ2GBv0ZORJSdL/nvrfGkuPXfS4lmWpvLxcvb296u3tvV6XB9zUBgYGvHkszYPZ4faxuvyWiKfveFCG5UoxqXYgvzVYMBhUOp3WoUOHbtg5X4133nlHqVQqbyba1o7DkqREU1jp4vwgPR6PK5FIyHEcxSvrpYgk11BT73FJ5x4GGBgYuGHXAAAAAADA7YKQBVfFdV39dO6n+sroVzRtT6vaV60v1H9BD5Y+uCz0SKfTGhvL3nA+/6Z92fSwSs5m++gf3n2fd2M71yql0FBFWh6smKZ5yWDlfM3NzTIMIztPZs0OSdkbeaG5bIhiGIYymYxisZjuCN+hjcGNSrtpvTj74or7y9046+zs9J4+vlpDQ0Oanp5edh1TmSkdWsjeWFxaxSKdm8ciSZUT2bkgw/XZEOZWncdyKXv27NGv/MqvaMeOHfL7/d6NXcuyvLBlsqJJRtCRaxtqGMve8DVNU47jaHJyUs+WP6uNwY1Kukl9beJrSjmpix4zFAopEAjo5MmTN82T9sCNYtu2xsbGvIqOitHsZ9VQ05r89cIliq3JBi/b2t/JW5bb9vTp00qlLv73+H7Q0dHhffZIkpFKqLwve92nN+/MWzdXbZdraylJ041VkqSWwbPeej6fTzMzM4pGozfgCgAAAAAAuH0QsqBgSSepb05+U/80/U/KKKNd4V36YsMX1RJsWXH9XBVL7mbXUve2vSG5hlINfo02bPRu8AeDQQUCgSsKVaQLBysPPfTQZQcrS23atMkbcJ8uKZcqsueyZqhT0rmnhKenp2UY56pZDi0c0kBy5SeHy8vLNTU1pb6+vsu+rotdb09PjwzDyOvfL0mvRl+VI0dbQ1u1NrjWez03j0WS/PF5aeb2msdyMeFwWB/72Mf0sY99TJWVlV41VSAQkGEYcg1poa5YktQ6nK0+yf1ex2IxWYalz9R8RhEropH0iP5x+h9Xnu+yRCQSUTKZ1NGjRxWPL5/nA9yu+vv7vcrDQGxaei8jGF6zfdm67TvulSSFBxez6y4RCAS0sLDwvp/NMjAwoOnp6fxZLF1H5KZMGWFXw+t25a2fSqXk9/vl9/u90L6vNVttVzwyJ/e94CW3vL09v8oHAAAAAABcHUIWFGQkNaI/Gf0THV48LFOmfrbiZ/XLNb+sIrNoxfXT6bTGx8clLa9iqZjsV1H/oiTp7d33y3EcWZblDa2/moqVxsbGvGDl4YcfvuxgZamGhgYVFRV5TwlP1WefEm4eHfSeIJayN9glaU1wje4uuluS9O2Zb694g93n8ykQCKirq0uJROKKz2mpkZERTU1NLbu22cysDs4flLS8imXpPJaWsR5581jKayTdHvNYLmXz5s365V/+Zd11113y+XxKJpPez3qoPjsLomZsMm+bXHVQxIroF6t/UYYMvb3wtg7MH7josXLzWSYnJ3Xs2DHvdw243fX09MhxHPn9fjX2ncy+WC6lSyqWrTvbtFFupSE5hrae3J+3LFeZduLEiRtw1oV79913lclk8lqFbezqkCSNr6+VcV6QnslkVFdXp/r6eu9zY7xlqwyfKzdpqnKkW1L2u9d1XZ09e/bGXAgAAAAAALcJQhZcsUPzh/Qno3+i0fSoyqwy/V91/5c+GPngRcOQvr6+C85iua/tTUmGEs1BjVevkc/nUzAYvKw5IJcKVn7pl36p4GBlKcuy1NDQ4FXYDDVlg4fS8QXZ6eyTw4ZhaHFx0bvJ9ZGKj8gnn7qSXToZP7nifiORiKLRqM6cOVPwuTmOo56ebMsqv9+ft+y12GvKKKONwY3aGNqYtyw3jyUbsuTmsZybcXA7zWO5mEAgoGeeeUaf/OQnVVNTo0wmI8uy1NuQfVLcmHbkS2Rb3eWqnXJBy6bQJn2k/COSpG9Nf0uDqcGLHss0TVVWVqqvr09dXV3X8aqAm8fg4Lkwu2m4X5I0/V7QvZLurZslSY1dQ3LPa8fo8/k0Pj6uwcGL/y2uFtu2debMGRmG4QW6oZkx+UbTkqTObfflrZ8Lyrdv367W1lYZhpH9DvIHlagPSZLW9J3y1jdNUyMjI4S4AAAAAABcQ4QsuGxpN61/nPpHfXPqm0q5KW0ObdZvNfyWNoQ2XHS7VCrlVbGc3yqsZvSMgoNJSa4O3vmAAoGA15LpQm5UsHK+lpYW7/ijrdsk05W7aKg8Np7XD396OtuipspXpUcjj0qSvjP7Hdnu8ptapmmqqKhIPT09XhXMlRodHdXExMSy643ZMe2fzz7JfX4Vi5StuMidd+V4bh5L9hpv13ksF9PS0qLHH39cpmnKMAzFK+pklLqSa6h1+LSkc23jpqamvO2eiDyhO8J3KKOMvjbxNS06ixc9TiAQUDgcVkdHh0ZHR6/rNQHvd6lUShMTE9kqDNtR6Vg2wBxsvnCFXe/W+2UEHLmLhpp73s1bFggElMlkdOjQoet63oU6evSoFhYW8gLzLafekmTIrjG1UN2Ut34qlVI4HNbu3bu1fft2WZaldDobyAw1tUqSaofGvfV9Pp8SicRVBfsAAAAAACAfIQsuy2R6Ul8Z/YremH9Dhgx9qOxDer72eZVapZfc9uzZs8pkMstmhUjSPUezrawW1xRpsXGD/H7/igHLagUrS23ZskU+n0/pdFpuICy7Ons960e65ThOdlaH62p2dtbb5smyJ1VsFms0PXrBdlElJSVaXFxUV1fXJed2nC9XxeK67rIqlh/FfqS0m9bawFptCW1Ztt38fLb6IpROMI/lMq1fv17BYNBrpTZbl/19axnJPl1/fts4STINU/++6t+r0qrUZGZSfzf5d5f8OZeUlCiTyejYsWPezwm4HXV3d3tVkCXTw3IXDcl0s0G3st8Nc3NzSiaT3jZuIKSp9dWSpC0dx/P2Z5qmTNPUmTNn3pezj06ePCnXdb3vS9d21HBmWJLUu3FT3rqO48hxHK1du1aBQEA1NTWKRCJelcrAup2SstV2/rlZSdmQxXEcKuUAAAAAALiGCFlwSe3Jdv3x6B9rIDWgYrNYn6/9vJ4tf1amcelfn0QiocnJybzWJzl1g53yj6Qlw9WRvY+t2JbKtu1lwcoHPvCBGxasLFVZWanS0tJzPe8b6iRJjWMjkuSFQ0tvsBeZRfpQ2YckSd+f/b4SzvLZK4ZhKBKJqL+/P68C4nKMj49rbGxs2XuwYC/op3M/lZStYjk/uMrNY7EsSy0jXWIey+WxLEu1tbVyHEemaWqwYY0kqXxs1lvHMAzNz8971UCSVGwV67M1n5VPPh2LH9OP5n500eMYhqHKykrNzMzo2LFj3jBr4HbT29srx3Hk8/nU3J9te2VX++QGwpKy875y4fdS7Xc8IEnyj6RUNDWctywQCCiRSOjw4cM34Aou38zMjEZGRmRZlvd9Wdt/Uu68IcPn6uyWe/PWz4VPe/bs8V5rbm6W67pyHEeJ8hqpXJIMtfQelSSvEm9gYOAGXRUAAAAAALc+QhZcUMbJ6AeLP9A3Yt9Q3IlrbWCtfqvht7QtvO2y99HX1+fdzM9xXVe2beueY9l2LXPrSrVY27Li9olEQiUlJXnByiOPPHLDgpXzNTY2ejewBpuyM05CY3FZklfNkkgk8m74faD0A6rx1WjOmdNrsddW3G84HFY6nVZnZ2fezfmLcV3XGwi9dECyJP147sdKukk1+5u1I7xj2ba5eSw+n0+N71VhMI/l8jQ3N8swDDmOo5G1OyS5UsxQODYpSV7buKUVTZLUGmzVxyo/Jkn6zsx3dCZx8XY9ufksg4OD6uzsvOIqJ+BWMDQ05IX0DSNDks4F3NK5QNibRfKeheomZep9kgxtP5FfRejz+eS6rtrb22/INVyud955R+l0Ou/zfEtnNhyZay2VHSrKWz+dTqu8vFzr1q3zXtu4caNM0/SC2cnGbEVP82Cft45lWZqdndXMzMx1uxYAAAAAAG4nhCxY0VR8Sr/6r7+qnyR+Ikl6tPRR/Xr9r6vCV3HZ+1hcXFxWxZILKFqHOmSN25Lp6p17nlhx+1xQsXv37lUNVpZas2aNd4N9unGjDL8rN22qYXpAhmF4N/omJye9bXyGTx+t+Kik7CD62czsivsuLy/XyMiIRkZGLutcJiYmNDo6uux9iTtxvR57XdLKVSxSNmQxDEOBQIB5LFdo06ZN3oB7u7hMbmX2d3vN0Gm5ruu1jcvN5lnqoZKHtLdorxw5+vrk1zVnz130WH6/X8XFxers7NTw8PBF1wVuNfPz85qdnc3OY8lkFBrLtvcabDrXNst1XTU3NysUCuW1DJOkzq13SJKqz4xL6VTeMr/fr+npaXV3d1/nq7g8tm17YWou3LbiCyoZyLYL7NiyZ9n6hmFoy5b8VpAbN270WhpKUl9rdnnR6ILc94IXv9+vdDr9vguZAAAAAAC4WRGyYEVhX1gzyRkFFdS/j/x7PVf5nHzG8pkqF9PX1yfbtr0bRrn+8aYM3XX0HUlSdEO5EhV1K26fTCYViUT0wAMPXN3FXEObN2+W3+/PPiXs8ytZG5QktQx2eU9HS1I0Gs3b7s7wnVofXK+0m9b3Zr+34r5zTy93dnZesj1UrorFtm0Fg8G8ZT+Z+4niblz1/nrtKtq1bFvbthWPx2UYhvyJeWk2G6owj+XyNDQ0qKioyLuJOVVfJUlqHh3yqpmk/LZxOYZh6JNVn1S9v16z9qy+MfkNOe7FK5eKi4vluq6OHTu24j6BW1VnZ6fXDqxytEdu2pThdzXVmK0izGQyMgxDGzZs0Lp167zvmJzBjXfJCLtyk6bWdxzM27ff75dt2zpy5MgNvaYL6e3tVTQazZuttb7jLbl2tpXjZPPWvPVTqZT8fr/27t2b93ogEFB9fb33+TTZvEWG35GbMlU1lJ3DkvtOPnv27HW8IgAAAAAAbh+ELFhRkb9If/KBP9HzZc9rZ3DnFW8/Pz+v6enpvOqO3HD2DUPtMqccGZard+9euYollUrJMAzt2bNnWSus1VRSUqLy8nIvBBmpb5Qk1Y6OyefzZZ+4dl3NzeVXKBiGoZ+t+FlJ0lsLb2kwNbji/svLyzU5Oan+/v6LnsfU1JRGRkYUiUTyXk86Sf0olp338VTkqRXn5kxMTMi2bfn9ftUPdEquIaMkfx6L3+8nZLkAy7LU0NDg3czNtY0rGZuXHNerZonH43nti3KCZlC/VP1LChgBdSY69YPoDy55zMrKSsViMbW1tS2bPYHVs9LPF9dOX1+f19awZeC0JClRG5Lx3lD4TCYjv9+vrVu36u6775bP51MqtaRixefX6MbsZ/SGzs68fZumKcuy1N/fvywUXw1tbW3eZ2/O2u4eSdLQhmYZ1rnPcsdxZNu2mpqaVqzwbG1tPdc+zedXvD7bZmztezNtpOz1j46O8jsMAAAAAMA1QMiCC1pXtk7VVnVB2549e9arYskNCQ8Gg/KZlna+k31yeGpTlZJlK+8/lUqpvLxc+/btK/j8r5fm5mZJ2Rtdg2uyTxf7JjLyZbJPFufmssTj8bzt1gXXaU/RHrly9Z2Z76y4b5/PJ7/fr66uLiUSiRXXcV1XZ86cUSaTUSgUylv2xvwbWnAWVOOr0V3Fd624ba6FWyAQUOPwWUnMY7lSLS3Z1mq2bWu8ZYsMy5WbMFUTG/NCFsdx8trGLdUQaNAnKj8hSfpB9Ac6FT+14no5hmGoqqpKIyMjam9vZz7L+8D+/fv1Z3/2ZxocXDkwxdUbHh72KsNqR8YkSSONjd5y27ZVVlamkpIStba2qrq6elkV4Kk7HpAMV+ako8hIT96yQCCgVCqlw4cPX+crubh4PK6+vj6Zpum11iwZ75M55UiGq9Pb7s9bP1fBs2PH8nlbkrRt2zZZluUFsoPNayRJNcMT3jo+n0/JZFJdXV3X45IAAAAAALitELLgmpubm/OeDM71lw8Gg/L5fFrb9bY0Kxk+V217n1xx+1wVy969e9+XN/rXrl3rDRaeq2rJtqNxDNX2d3jVLBe6wf7R8o/KkqWORMcFb6yXlZVpdnZWvb29Ky6fnp7W0NCQSktL815POSn9a+xfJUlPlj0py1j+3i0uLiqZTHpzcnLzWEYazs1jMQxDjUtuZGK5LVu2yOfzKZ1Oyw2ElK7OPn2+Zvhc2zjXdTU7O3vBfdxTco8eLHlQrlx9Y/IbmslcfAi1z+dTJBJRd3e3zpw5Q9CyimzbVltbm2KxmF588cX86glcExMTE5qfn5dlWTJScVmT2fBkqHWbpOxnleu6ampq8rbZuXOnDMPIq/ZKllUr0RyWJO04+XbeMXLfL+3t7ata0dHW1qZEIpFXtbn1VDb4STUElj2MkE6nVVJSop07V64yra6uVllZmXdNA+veaxs5IwWiU5KynyeO47xvZtIAAAAAAHAzI2TBNdfb2+vN9fD7/QoGgzJNU24mo23vHpMkjW+pVbq0fMXtU6mUKioqdM8999zAs758Gzdu9Pr5G5ap+boSSVLTUI8Mw/BmpMzMLL9pXu2v1sOlD0uSvj3z7RXncZimqaKiIvX09CxrO+a6rnp7e5VOp5dVsRxcOKiYHVOFVaF7ipe/d67rKhaLeT8bazG24jwWwzC0bt26K31bbiuVlZWKRCLeTczxhuxcofqREQUCAfnea2d0qRkqz1U+p5ZAixacBX198uvKuBefxRMOh+Xz+fTuu+/q3XffXTboGzfG8ePHFY1G5fP5NDU1pX/5l39Z7VO65Zw+fdprn1XX3yE5howiV3OV2VDFtm2Zppn3WbVnzx4VFxcvC71ObcsOjS87G5UZn89b5vf7NTc3t6pD4E+dOuW1RZMkZdKq7h2XJHVv2p63bi5c2rBhw0UfQmhpaZHrunIcR6lIpVSRrQhq7c1+B5umKcMwNDAwcB2uCAAAAACA2wshC66pqakpRaNRmaapUCjktc+SpPWnDkgxyfA7Orp35VksyWRSpmnqvvvue19WsUjZFjM1NTXeDfbhxmwVSNVo9glhy7Jkmqbm5+fzhjDnPF32tMJmWCPpEb01/9aKxygpKdHCwoK6urryKhZmZ2c1ODiokpIS732VpIyb0avRVyVlq1h8hm/ZPuPxuNfL37KsvHksifPmsaxdu7aAd+b20tDQ4N3EHGzZIkkKjidl2BkFAgGvbdyF2r5Jkt/w65eqf0lhM6zeZO8F28gtVVZWpuLiYp0+fVr79++/YEsyXD9tbW1yHMcLkLu6ula95dStpr+/36uEbB7KtvmaqyvxZpPk5rFs2rTJ2yYQCGjTpk3e32XO2Jo7ZEQkN2NoU/ubecfJVXS0tbVd/4tawdjYmCYmJs4FLJKaetrkJkwZQUcDG/fkrZ9KpeTz+XTXXcvbQS61ceNGr+JSksYbs5/xTUPn5n1ZlqVoNMpnCAAAAAAAV4mQBddMIpHw2hjlnrj3goBMWluOnpQkjWxrkl0UWba94zhKp9OqqqrS7t27b+CZX7nm5mZv7sZQa/ZJY2PGkX8hKsMw5PP5lMlkND09vWzbYqtYHyr7kCTpxeiLSjrLqxEMw1Bpaan6+/vz9tHb26tkMqlwOJy3/tvzb2vGnlHEiuj+kvvP351c19Xc3Jx3zn6//6LzWJa2rcHK1q5d672f0/XrZQQcuRlDlUPdsixLgUBAjuNodHT0ovup9lfr01WfliT9eO7Haltou+Sxw+GwampqNDk5qTfffFNdXV0rBnq49gYGBjQ6Oiqfz+fNmrJtW6+//rrGxsZW+/RuCbZta2xszJtPkguwhxvX5K2z0mfVPffcI7/fn1fNYlim+jZlt117uleufe5vxTRNWZalkZGRVQkbjhw5okwmk3cdm05nvyun11ZJ/mDe+plMRlVVVZds6bhp0yaFQiEvZOl/b35YeDQuZbLt1HIVmadOXXwmFAAAAAAAuDhCFlw113UVjUY1MjKiZDIpv9+f91SuJG068YbceUNG0NGJPR9ccT/pdFqmaWrfvn3v2yqWnA0bNsg0TaXTaSXLa2REJMlQQ1+25UyukmF0dHTF2RkPlT6kKl+VYnbMm6NyvnA4rFQqpdOnT3vv8cDAwLIqFtu19UrsFUnSByMflN/wL9tXrt9/rr0U81iu3tatW+X3+7Mt1ixLidps8NU6mB0knfsdmJ6eXjaM+3w7i3bqiUi2uuvvpv5O4+nxSx7fsizV1GSfTm9ra9Pbb7+txcXFq7kkXIa3334776Z4rr1fPB7XCy+8wHyWa2BoaEjxeFyWZck/PyPNZD9Dh9ZkB73nAsWl81hyamtr1dDQoEwmkxc8nt7xgAzLlaJS7UB+a7BgMKh0Oq233377/N1dV7ZtezNRcoGSf25WweFs9dupbfltH3PtHLdvz28hthLLslRfX++9B5ONm7JBcNpQzWCnt47ruurr67tm1wQAAAAAwO2IkAVXxXEcTUxMyDAMJZNJua7rzSTxpFPacCx7U2dg+xrZ4eIV95NOp1VTU6MdO3bciFO/Kq2trQqFQl7LsJm6cklS03vVIZZlee/JSje+/YZfHy3/qCTp1dirimaiy9YxDENlZWUaGhrSyMiIzp49q0QioaKiorz1jiwc0WRmUiVmiR4seXDF843FYmpoaNDs7Gz2ye34PPNYrlI4HFZFRYUXoAw3NkuSakaz1QyGYciyLKXTaU1NTV1yUP1Hyj+iDcENSrgJfW3ia0o5l75ZbxiGIpGIysrKdPbsWb3xxhsaGRm55LFQmPn5eZ05c0amaXo3xaXsDfJAIKDJyUm99NJLq3iGt4ZcZZbf71dD/ylJhlSm7GwRZT+rLMvKaxW21O7du/NaZUmSXRTR3JpSSdK29nfy1s/9LE+fPn1DQ7L29nbNz8/L7z8XjG8+dUByDbkVhubq8z+LU6mUgsHgJVuF5eTaPtq2LcPn02JD9ru3ta/TW8eyLI2OjhIOAgAAAABwFQhZULBkMqmJiQlVVlaqoaFBMzMz8vv9eTcfJWnLsR/LXTRkhByd2vP4ivtKpVKyLEsPPvjg+76KRcremKqrq/OeEh5syt4MKxs9F5bkbvLFYrEVb3rvKdqjtYG1SrkpfT/6/RWPkwusOjo61NfXp+Li4rwqFsd19MPoDyVJj0UeU9AMLttHroqluLhYiUQi+4Rz/ynmsVwDuSfpHcfRYOs2SZI5ZctMLEjK/p7kZuDMzs5edF+WYekz1Z9RqVmq4fSwvjX9rcs+j0AgoNraWsViMR08eFDt7e2XrJ7BlTt48KB3o/t8gUBApmmqvb1d77777iqc3a1jaGhIruvKNE01D52VJM3UV3jLM5mMgsGgWltbV9x+x44dKi0tVTqdznu9fce9kqTw4KICsfxWjoFAQAsLCzd0NsuJEyfkOI5X+enajpp7sjNT+jbmByyO48hxHK1Zs2ZZu8gL2bZtm/x+v/c+DDavlSRVD59ri2ZZllKplLq6uq72cgAAAAAAuG0RsuCK5eZ7xGIxrVu3Tg8++KCOHz8u27aX9cc3UnGtO54dWty7c4OcQGjZ/hzHUSaTUV1d3WW1QXm/yM1lsW1bo2u2S4Yrd95QaCZbyeDz+WTbtlzXVSwWW7a9YRj62YqflSQdmD+gkdTIiscpLy/X5OSk4vG4iovzq4COLh7VWGZMRWaRHip9aMXtc1Usk5OT5+axjJzNLmMey1VZv369F6YtVDTIKHYlx1D9QIek7MyDXHWX4ziXbOdV5ivTL9b8ogwZOrhwUAfnD172uZim6f38Tpw4oQMHDigaXV4hhcIsnV1xoSA4N5/lRz/6EcPEC5RKpTQ+Pu69x5HR7GfnYNN6bx3HcVRXV3fBn4NlWdqyZYskedWGkjTTtElupSE5hrae3J+3Te5v9cSJE9f0ei5kfn5eg4ODsizLezChcqRbikqG5ap723156+faae7cufOyj1FRUaHy8nLvPRhYt1NStmVaaHZCUvZ7ynEc9fT0XJsLAwAAAADgNkTIgiviOI6mpqZk27Z27dqlu+++W2fOnNHY2Jg3CHqpHe/+SG7ClFHkqnPXoyvuM1fF8oEPfOAGXMG1s2XLFq8dlB0ukVuZvfbm9+ay+Hw+72nsRCKRd7MvZ0Nog+4sulOuXL0w+8KKx/H5fCotLVV5efmyKpYfRH8gSXqk9BGFzeVPNyeTSfl8Pq1fv17Dw8Pe+VSMZeexjDZkW1wxj6Uw69evVyAQyLbjsUzN1WXbETUPZm9Y5mYexGIxbdq0SXNzc8uerj/f5tBmPVv+rCTpn6b/SYOpwSs6p+LiYlVVVWl4eFj79+9XX18f7cOugba2NsVisbzWTuczTVPhcFiLi4t64YUXVvybx8WdOXPG+04omhyWu2BIhqvR9yrFcp9VLS0tF93Pfffdp0AgsKwNVs+WzZKkxq4huedVe/l8Po2Pj2tw8Mr+5gpx5MgRpVKpvFB7a8cRSdJiU5Hsokje+plMRpFI5IIt0i6kpaVFrutmW3KWVMityn5PtfYel5T9nTUM44ZcMwAAAAAAtypCFly2VCqliYkJRSIR7du3T1u2bJHrutq/f3/eIOgcK76g5vbsQN2eXVsk//IKiVwVS2NjozZv3nxDruNaqaurU3FxsXcjdbK+WpLUODIgKXvzynVdzc/Pq7Ky8oJVBR8t/6hMmWqPt6sj3rHiOuFweFmLopPxkxpODytkhPRI6SMrbheLxVRfX6/KykqNj49781iM9+axDDGP5aoEAgHV1NR4vwNDjWskSRWjM946pmlqfHxcW7ZsUVNTk6anpy8ZejwZeVLbQ9uVdtP664m/VtyJX9F5+Xw+1dbWKplM6tChQ3r33XeVTCav8OqwVFtbm1zXvWSll2VZCgQCGhsb08svv3yDzu7WcebMGa+FVvNAtnLIqbbkhLJVfOl0Oq9S5ULKysrU3Nws27a9to6S1Lvt/uwA+EVDzT35bd0CgYAymYwOHTp0ja9quY6ODrmu61XjmKmEyvqy3xGnN+/KWzf3+bJp06Yrbqe5adOmvPk04411kqTGwX5vHcuyFIvFND4+XtjFAAAAAABwmyNkwWWZn5/X7OysWltb9eCDD6quLnuj5vjx45qcnPTmESx1x7uvyU2aMkpcdd2xcpVKKpWSz+fTww8/fN2v4XpoaGjwbpgPNm+UJBWNLsi1szf1LMvSzMyM1q1bJ9u2V6xiqPXXeq2+Xph5QY7rLFvnfK7relUsD5U+pGKreNk6qVRKpmlq/fr1GhkZWXEeS7K8VhLzWK5Grm2c4zgaWnNH9sWovJkPlmUpkUhoZGREd955p8rKyjQ9PX2RPUqmYernq39eFVaFJjIT+vupv7/iahTDMFRRUaHi4mJ1dXVp//79mpqaKugab3e9vb2amJjwZmdcSu7z8Pjx4zp+/Ph1Prtby9DQkKRsONkwnK2umKiv9ZZnMhkVFxd730EXs3fvXq/aMMcJhDS1LhuIb+nI/9mYpinTNHXmzBnF41cWbF6J/v5+TU9P5/0+tXYekps2ZBS5GlmX3xIsnU7L7/dr7969V3ys9evXKxwOeyFL35psRVBoLCGls8Gr3+/Pa4cHAAAAAACuDCELLikajSqdTuuOO+7Qvffe680FsW1bb731ljfnYylrMaaGU8OSpM47d0i+5S12clUsLS0tN20FRWtrqzeXZbx5qwzLlZs0VTaereDx+XxKpVJaWFhQbW3tBYeff6jsQwoZIQ2lh3Ro4dJPUXckOtSf6pff8OuxyGMrrhONRlVXV6e6ujr19PQsm8cyV1vqrcs8lsJt2LBBpmkqnU4rXVoulWdfb+w7KSl7AzM386C0tFS7du2SaZqan5+/6H6LrWL9Us0vyZKltsU2vT73ekHnFw6HVV1drampKe3fv19dXV15T/bj0g4dOrRitd7FBINBpdNpvfbaa5qZmbn0BlA8HtfMzEy21aJtKzyWnWE00HyuRZbrumpoaLis/W3YsEEVFRXLwu32O/ZJkvwjKRVNDectCwQCSiQSOnLkyNVcykW98847y2aYbeg+LUkaW18n47xqlUwmo9raWlVXV1/xsSzLUn19vfc3P92wQUbQkZsxVPve7KhcW8O+vr5CLwkAAAAAgNvaqoYsf/mXf6ldu3YpEol4Laheeuklb3kikdDzzz+vqqoqlZSU6LnnntPY2FjePvr7+/Xss8+qqKhItbW1+uIXv+g9sYmrZ5qmKioqdN9992nbtm15rUreffddTU1Nye/3L6tiufPIq3LThhSRzmzbt+K+k8mk/H6/Hnpo5YHtN4MtW7bI5/Nlb+L5A0rXZMOk5vNuXvX392vLli3efJbzlVglerrsaUnSi7MvKuWklq2Ts7SK5QMlH1CpVbpsnVQqJcMwtGHDBhmGoaGhoWXzWEYasjMNmMdydVpaWhQKhbyWPtP1lZKkppFsO55c27iBgWwbuYaGBm3ZskWLi4vL5kWcb21wrT5W8TFJ0rdnvq3eZG9B52hZlneD9t1339WhQ4e0uLhY0L5uN9FoVH19fXkDyi9Hbj7L/Pw881kuU0dHh9LptHw+nypGe+WmTBk+V1NN2ZDFtm0ZhqHW1tbL2p9lWdq2bZsXhOcs1DQrU++TZGj7iQN52+RmaZ08efKaXddSqVRKvb29XtWMJIWnR+UbywZBnSsMvDcMQ9u3by/4mOvWrfPeA8OyNN+Q/c5Y03/aW8eyLI2NjV3yMwkAAAAAACy3qiFLc3Oz/vAP/1BHjhzR4cOH9fjjj+vf/Jt/493c+M3f/E1997vf1be+9S29/vrrGh4e1sc//nFve9u29eyzzyqVSunNN9/UN77xDf3N3/yNfud3fme1LumW4vf7tX37dj344INqbGzMG7pu27befvttOY6zbFaIf25WtZ3Z3u6n9uySsUKLHcdxZNu2WltbL/uG2ftRWVmZIpGIdwNvrKFeklQ/MiLp3FDh4eFh1dXVqbm5WbFYbMXWT49EHlGFVaFZe1Y/mvvRBY/ZnezWmeQZ+eTTByMfXHGdWCym2tpa1dXVZatsmMdy3eSeFPfaxjVtkCSVjs7ltY2bmJjwwq8tW7aopaVFMzMzl6wqebj0Ye0p2iNHjv564q81b1+8AuZCDMNQJBJReXm5ent79cYbb2hkZOSK25Ddbg4ePLhsQLlrO9r87muq7L94eyXLsuT3+zUyMqJXX331ep/qTe/s2bNeGNw80ClJStYGvUrIXABzqXksS917770KhULLZhKd3pJt7Vd9ZlxK5wcLfr9f09PT6u7uvprLWdGxY8e0uLiYV/255dRbkgzZtZYWq/LD7nQ6raKiIu3evbvgY27btu3cwwCSBpvXSpKqhs+1LcxVXXZ2dhZ8HAAAAAAAblerGrL8zM/8jD784Q9r06ZN2rx5s/7rf/2vKikp0cGDBxWNRvW1r31Nf/qnf6rHH39ce/fu1de//nW9+eabOnjwoCTphz/8odrb2/W3f/u32r17t5555hn9wR/8gf78z/+cpzGvgdyN99LS5ZUShw4d0szMzIrtc3YfeUVuxpDKpb7N9y1bLmWrWAKBgB55ZOWB7TeTxsZGua4rx3E00Jy9+ReYSEmZ7A0ty7IUjUYVi8W0efNmBYPBFasI/IZfH634qCTplegritmxFY+Xq2LZV7JPZb6yZcvT6bRc1/XaWA0PDzOP5TpraclWBdm2rfGWrZLpyl00VDKTDdtycyF6enq8/71r1y5VVFRoenr6okGHYRj6VNWnVOur1aw9q29OfvOy5vZcSCAQUG1trWKxmA4ePKj29naq/y7Atm11dJyrSstZ03lQ697q1r0/fF0lEwMX3UcuhG5ra/P2hZWNjIzIMAyZpqm60VFJ0uiS1mC2bSsSiaisbPnn3oWEw2GtW7dOjuPkBZoDm+6SEc62d1zfcTBvm9yMkuvRMqy9vV2u63ohi2vbqj+T/Zw4s3FT3rq5c167du1VtXIsKytTRUWF93c+sH6XZLhyY9kqGulc1eX1CJYAAAAAALjVvW9msti2rX/4h3/QwsKC9u3bpyNHjiidTuuJJ57w1tm6dataW1t14EC2vceBAwe0c+fOvAG4Tz/9tGKx2EVbfSSTScVisbx/uHy2bevw4cNyXXfZjZ9gdFJVXdnh2sfv2ivDWv4rlqtiWbt27S3RomppK5bZ+nVev/vqoWwrFr/fr3Q6rc7OTlVUVGjt2rWam5tb8cb6XUV3qSXQoqSb1EuzLy1b3pvs1enEaZky9UTZE8uWS9n2RjU1Naqvz1bV5M9jyfbcZx7LtbVlyxYvSLFDRbKrsjfkm/vaJWWfEnccR72959p9FRcXa/fu3fL7/ZeczxIyQ/pszWflN/w6lTilb0x+Q3Gn8MHcpml6P/MTJ07o4MGDfA6u4PDhw5qfn1/2t7GlPfv94mYMPfja92WklrcAXCoUCimdTuvll19WNBq9bud7M5uenlYsFpNlWTJSCfkn3qu6aM1W3DmOI9d11dTUdMX7vvvuu71KDY/Pr9GN2e+fDedVb5imKcuy1N/ff01/XtPT0xodHc0L7OrPnpC7YMjwu+rdem/e+qlUSpZlac+ePVd97JaWFhmGkf3+LYrIee8zqrX3uKRzVZdDQ0NXfSwAAAAAAG43qx6yHD9+XCUlJQoGg/rVX/1Vffvb39b27ds1OjqqQCCg8vLyvPXr6uo0mnvCdXQ0L2DJLc8tu5Avf/nLKisr8/7lnkLH5Tlw4ICi0eiKN+X3HH5Vrm3IrTI1tOGuFbfPVbE8+uij1/lMb4xNmzYpEAhk225ZluK1RZKk5sEuSeeeEM7N5Ni4caNKS0s1Nze3bF+mYXozON6cf1Oj6fzf45ejL0uS7i2+V5W+ymXbZzIZr4oldyNveHj43DyW8Wx7mKXzWCTdEmHXaqqpqVFJSYnXNm6iIfs51DCSvWGZm70wODiYt11tba22bt2qeDy+rJ3R+RoDjfpU1adkytQ7i+/oj0f+WGeTZ6/qvIuLi1VZWamhoSG98cYb6u/vp33YEkePHs2rOpCk8sHTMicdyXBlBBxpVrrvpy9cdD+5+Sxzc3P6zne+w3yWFXR2diqTycjv96tmsFOubcgIOYpVZ9tJ5uaxFNLWsLW1VdXV1csqtk7d8YBkuDInHUVGevKWBQIBpVIpHT58uPCLOs/hw4eVTqfzvjs3nz4mSYq1lskNhPPWz2QyqqysvCZVhps3b5Zpml7LsLGmbAjfOHTuM8myLM3Pz2vkvXaXAAAAAADg8qx6yLJlyxa1tbXprbfe0uc//3n9wi/8gtrb26/rMb/0pS8pGo16/3I3v3FpqVRK77777opVLOHpUZX1zEqS2vbeu2IVi23bsm1bGzduVG1t7Y045esuHA6rsrLSu3E60tgsSaoZmfDWMQzDu3FVXFysDRs2KB6Pr3izdVNok3aGd8qRo3+Z+Rfv9YHkgE7GT8qQoafKnlrxXKLRqKqqqrzQZOk8FjM+L2Nm+TwW0zSZx3INNDQ0nJvL0pxt+xMaj8t978auz+fT7OzssqqVTZs2ae3atZqZmbnkzfe7i+/Wb9T/hiqtSk1mJvWV0a/o1eirV9U+zO/3q7a2VslkUocOHVJbW9slA5/bQXd3t6ampuQ7b6bUzhNvS5LirUU6+lC28qCsK6rWUweW7WOp3HyWgYEB/fjHP74u53wzy30PW5allsFs4LFQX+J9j2QyGQUCAW3cuLGg/e/cuVOGYXghgyQly6qVaM4GGztOvp23fi6kPnXq1DUJxWzbVlfXueBdkqz4vIoHFyRJHVt2L1vfMAxt3rz5qo8tSWvXrlU4HPaupa91myQpOJb0KrECgUBeizwAAAAAAHB5Vj1kyd002bt3r7785S/rzjvv1P/4H/9D9fX1SqVSmp2dzVt/bGzMa4NUX1+vsbGxZctzyy4kGAwqEonk/cPlefPNNxWLxZYNu5ekuw6/JjnZ4b3j6+9ccftkMqlgMHjLVLHkNDU1ea1YBt+7eWVO2TIT2RtouSeEJyaywcv69etVUVFxwVY0H634qEyZOh4/rq5E9sbcy7FsFcve4r2q8dcs2yaTychxnLwqlpGREcXj8ew8loEO5rFcR2vWrJFhGMpkMppq3CjD78pNmaocPSNJ3uDp06dP521nmqZ27dqlmpqaS85nkaR1wXX6rcbf0p6iPXLk6Duz39Ffjv/lBWf4XA7DMFRRUaGioiKdPn1a+/fv19TUVMH7uxUcOnRItm3nhcmB2LSK+rMh2Ykd92pk015NbauSJG1/86iKpoYvus9gMCjDMHTkyBFmXyxh27ZGRka8iq+q0UlJ0lBjS946VVVVCofDK+7jUvbs2aPi4uJl89pObdstSSo7G5UVX8hb5vf7FYvFrsmDHz09PYrFYnmh3YZTB7MVOxFpqmlL3vqpVEqBQED33HPPVR9byn4HNTY2etWLs/XrZYQcubahuv5TkrKfRa7rqr+//5ocEwAAAACA28WqhyzncxxHyWRSe/fuld/v12uvveYt6+zsVH9/v/bt2ydJ2rdvn44fP67x8XFvnVdeeUWRSETbt2+/4ed+q4vH42pra5OkvPY5klQ8OaSS3mz7q3f3PrDi9rZty3Vdbd68WZWVy1td3cw2bNjg3WBfrGqUUexKrpEdNK9zg5Q73+v9HwgEtHnzZmUymbwnq3Pq/fV6sORBSdK3Z76t4dSwji4ezVaxRFauYonFYqqoqMibWbB0HkvT8FlJzGO5XrZu3Sq/359tSeTzK1mbDSJbBrKhSu4GZl9f37JtQ6GQdu/erWAweFmzUYrMIn2m+jP6VOWn5Df86kh06MvDX9bJ+IVnUV2OcDis6upqTU5Oav/+/eru7s4bFn67mJ6e1sDAgCzL8m78S9L24z+RHENulaHp92aFHH7w38itMuSmDX3gtRel9MWrgEKhkFKplF566aVLzuK5XYyMjGhxcVGWZclajHkVd8OtOyRl//8CwzAKmseSs7QKZunv9NianTJKXbkZQxvb38zbJjdL6ejRowUfN+fo0aNeqJ2ztjsbwA5uaMmr/MzNLWtqalJJSclVH9s73tq13vwwwzI115h9wKS1v8tbx7IsjY+PLwujAAAAAADAha1qyPKlL31JP/nJT3T27FkdP35cX/rSl/TjH/9YP/dzP6eysjJ99rOf1Re+8AX96Ec/0pEjR/SZz3xG+/bt0/333y9Jeuqpp7R9+3Z9+tOf1tGjR/Xyyy/rt3/7t/X888+vWGmBq/Pmm29qYWFh5SqWQ/8quYbSDX5NrVk54LpVq1ikbGVKMBj0WrHE6rI3r5qHsjfRzp/LImUHEdfV1V2wmuWZ8mcUMkIaSA3of43/L0nSnUV3qiHQsGxd27aVyWS0YcOGvCelh4aGls9jqc+2M8vdaGxoWL4/XLmSkhKVlZWdaxtXn23ZVvvefKjcYOnh4ZWrHaqqqnTHHXconU4rkbj4IHUpW32yr3Sf/nPDf1ajv1Hzzrz+avyv9M/T/6y0uzy4u1yWZammJlsp9c477+jQoUNaXFwseH83o4MHD3qVBJ50SvVd2ZZ/p7duO/e6z6+ffvCjMvyOjGlX9+z/F12MaZoKhUKKRqPMZ3lPV1eXFwY39rVnK+4iUqI8+3uYyWRkGIY2bNhwVce599575fP58gIEwzLVt3mtJGnt6TNy7XMBjGmasixLw8PDmpycLPi48XhcfX192baN74V2kdGzMqZdyXB1etv9eevn2jju3Lmz4GOuZPv27fL7/V6wP9C8XpJUOTLtrZN7f65321YAAAAAAG4lqxqyjI+P6+d//ue1ZcsWffCDH9ShQ4f08ssv68knn5QkfeUrX9FHPvIRPffcc3r44YdVX1+vf/7nf/a2tyxLL774oizr/8/efQfHkZ4H/v9290RgkHPOkQTzMnN3uVmbd5Wsk2yffQ5ly3f2BV/JV3Xls39VZ0tny2X5TpZ9iqvVraSVNkcuyWVe5kwQgcg5Y5Amdvfvj+Y0MQQwAEhE8v1UsbSaebv7bWAwGLzP+zyPwo4dO/ja177Gb/3Wb/HXf/3Xy3VL9yyPx8Ply0aD3tt7FMR2NxPVYpRZOb9597THh7JYKioqiIuLW9zJLgNFUUhNTTUXTDuy8gBI6B4yx8iyTHd3tzlGURRKS0uRJGnaHhgxSgyPxT0GwKBqLII9GffktNcfGRkhPj6e7Oxs87GZ+rF03taPRZQKWzhZWVnoum6Ujcszvs6WviDyzZ4HiqIwOjrK4ODgtMcXFBRQWFjI8PDwnBff063p/JeM/8JDMQ8B8Onop/xD9z/QG+id5ciZSZJEbGwscXFxNDc3c+zYMbq7u2ctZXYv8Pv91NXVIUmSWXYPoPD6Z+heGcmp03zborgnMZ1rOzcBkFgzSGZd5GbpFosFi8VCS0sLx44dW/ibWGXa29vNYHBWRzMAQ2nx5vPBYBC73X7XvaNSU1PJyMgwSyuG1K3ZiaTo4IaUtvDggt1ux+/3c/r06dtPN2cXLlzA5/OFBe3Krp8BwJ9pxx8bntkZCASIjo5e8Ixcl8tFQkKCkW0HdBRUgaSjj0pE9XcAtzYENDY2Lui1BUEQBEEQBEEQBOFetqxBlh/84Ac0Nzfj8/no7e1l//79ZoAFjLIq/+f//B8GBwcZHx/njTfemNJrJS8vjw8++ICJiQn6+vr4u7/7uylBAOHuHTlyhImJCRwOx5TnNp09BEj4su0MZ0/fpNfr9eJ0OnnooYcWd6LLaHJfllCZG9xGHwcwFq+8Xm9YNkt6ejpZWVkMDw9Pu4C9N2Yv8Uo8AGuda8m2ZU8Zo6oqgUCAoqKisFI0M/Vj8SakmcdZrVYKCwsX6ktw3ysoKECWZVRVZTQpB8mpo2sSKW1GI+lQObGZGktLksTatWtJT09nYGBgzkENq2TlC4lf4A9S/oAoOYo2fxvf7Pomp8ZO3dX92O12UlJSGBkZ4bPPPuP69evmAu296uzZs1My9nRVo/i6UeqvqyQTLNYpx7VVbGO4JB6AdcfOYB+OHORyOBzous7p06dpampauBtYZULB4FBAK75nGID2rFsBFU3TSEtLCwt63al169Yhy3LY61iNimU0zyijWFl9Pmx8KAOtvr7+jrOOrl+/jq7rtz6bBAMkNRuZMXUla8LGapqGruuUlJQsyP3eLjc317yO6nShphhzym26Cty6346OjgW/tiAIgiAIgiAIgiDcq1ZcTxZh5RkbG+PaNaPXw+2LPgkd9djbfYDOuS3TB1BCC1OVlZULWl9+pSkpKUGWZQKBAIGYeIg3Hs9sMb52VqsVTdNoaGgwj5EkidLSUux2Ox6PZ8o5bbKNryV9jQpHBS8lvDTtdUdHR4mLiyMnJyfs8bn0Y0lKShL9WBZQSUmJGUiRFJmxNOP1nt1ufM9DPz+TA223s9lsbNiwgejoaIaHh+d1/aqoKv4i4y8osZfg1/28OvAqr/S/gkeb+tqaK1mWSU5Oxmq1cuXKFU6ePDmnvjGrkaqqXLlyJXxBHEhur0Ea0pFkneqqB2c8/tSDL0EC6H6ZBw+8DcHIZducTic+n48PPvhg2p//+0FjYyM+nw9FUXAM9aCPSiDpdN8sOxnqxzI5S+9uVFVVERMTM6UXVvWarQA42yfMwHiIzWZjbGyMc+fOzft6XV1d9PX1hb2esm+cR/fJSHaNjuKNYeP9fj8Wi4XNmzfP+1pzUVpaiqIo5v13ZxrlIjM7bwVVLBYLY2NjtLe3L8ocBEEQBEEQBEEQBOFeI4IswqyOHDmCx+OZNotl49mjAHjyohhNn76Ui9frJSoq6p7OYgHIzMwkKirKDCoNphslYLI6W4Fbjc9v3yGcmJhIXl4eo6Oj02YulDnL+OO0PybVmjrlOU3T8Pl8FBUVTQmWzKUfS2Zm5t3csnAbm81GcnKy+RrozDQCX0ndA+aY28vGTSc+Pp6qqio0TZt3P5R4Szx/kvYnPBv/LDIyZ8bP8K2ub9Hia7mDO7rF5XKRmJhIR0cHx44dY2hoaPaDVpn6+noGBwfDMsIA1l4zSjuN5rmMAOpMrDaOPfoskkVH7tPY+Nl7Ea8X6s8yNDTEO+9E7uVyr2poaDCDWtktRqkuPVFBdRoBykAggCzLlJZOnyU5X4qiUFZWBhD2MziUVYKeKIEmUX7tRNgxVqsVXde5evXqvK93/vx5VFUNe38uqTPuc6AgeUpWVDAYJCUlhbS0tHlfay5yc3PDfk+15BvBLFuvH8lvBPpCGwJqa2sXZQ6CIAiCIAiCIAiCcK8RQRYhIrfbTXV19ZT+BACJLdexdgVA0jm/Ze+0x4dKsqxbtw6n07no811OiqKQnp5uBjDas4wmzTE9o2YzZUVR6O3tnbLAXlJSQnR0NKOjo/O65ujoKLGxsVOyWEQ/luWTlZUFGIGsjlxjAVMa0rCOuwHjNTAxMUFnZ2fE8+Tk5FBcXMzo6Oi8S3TJksyTcU/yp2l/SoKSQH+wn293f5v97v1oujb7CWZgtVpJTU1lbGxs3q/V1eDcuXNmGb0Q+3AvjjZj8flq1Y5ZzzGenEXN9rUApF7rIa3hUsTxof4sDQ0NHD9+/C5mvzpNDgZndhkZXn3pyebzqqoSFRW1oEGHbdu2YbPZ8Pv9YY83lBmBnMz6dvTbfuYsFgu9vb3zyu5QVZUbN24AmA3vbe4BbF1GD66aigfCxgeDQSRJoqKiYn43NA+KopCZmWn+nhpJyUOK0tFViYzma+ZcdV2ntbV10eYhCIIgCIIgCIIgCPcSEWQRIjp8+DA+ny+sP0HIpvPGguBYfgxjKTlTngfw+Xy4XC727NmzqPNcKULBDlVV6c0pB1lHn5BwDXUBxgKX3++nvr4+7DiXy0VxcTEejyesIXMkmqbh9XopLCyc8v0J68fSXiv6sSyhUC+FYDCILz4FKRZAIuPmLv3QLvHbXwO3kySJyspKMjMz59WfZbJCRyHfyPgGG6I2oKHx9vDb/HPvPzOi3nm5L0mS7vjYlayvr4+Ojg4URTEXxAHWXj4KuoSaIuPOLJrTuZrX7mas0AVIbDx6Ykr5qduF+rOcOHEiYim5e43H42FwcNBotq5qRHWPA9CeXWyO0TSNzMzMBe1PEhcXR3Z2Nqqqhr3fNlVsR7Jp6BMS2Q0Xwo6x2WwEg0HOnDkz5+tUV1czPj4eFrQrrTkJuoSeKDGalh823u/343A42LhxI4upoKAASZLMsoYjGXEA5LbdMMcoikJ/f/99W8ZOEARBEARBEARBEOZDBFmEGXk8Hmpra6fNYkltvITSo4Ksc27LI9MeH6r5vn79+vum70dpaSkWi4VAIIDqiEJNMr5uoTI4FosFXddpbGyccmxBQQEJCQm43e45XWtsbIyYmBjy8vKmPDe5H0tmp9FUW/RjWRq5ubnY7XYz+2QoPR7A7IszU9m46VitVtavX09sbCyDg5EX6mcSpUTxu8m/y28k/gZWyUqNt4a/7fxbrnuu39H57lUnT54kEAiEBSxlv5eUG0YD+7rKtfM634mHX4ZY0L0yew68iT5L0/RQf5Z33313SobFvaq+vh6/34/VaiWut8XoU6Lo9GUbGSWqqiJJ0pRMvYWwefPmsN4kAJrNwWBBEgBlNVfCxsuyjCzLNDU1zTnwcOXKFTRNM/ux6KpGdoORCdNcHB7g1jQNTdPIy8tb9KzP8vJyrFaree8tOUbwML5z2My6tFqt+P1+rl8X7xOCIAiCIAiCIAiCMBsRZBFm5PV6UVV1SoBFVzXWnz8NgLswHm9SxrTH+3w+YmJi2Llz56LPdaVITk7G5XKZ5cD6MozMkYwuY0E90gK73W6npKSEQCAwa3koXdfxeDwUFBRM2ytncgmexJ6p/VgkSRL9WBaJoiikpaWZO+Q7Mo1eRXHd7rAx05WNm05sbCzr1q1DkiTGx8fvaE6SJLErZhd/nv7nZFozGdVG+W7vd3lr6C2C+vxKkd2LPB4P9fX1SJIUlsVSdO0Eul9GitJpKXkgwhmm0m1OTjz6JJKiY+kJsv70BxHHy7KM3W5naGiIt99++47uY7Vpamoy36dy2moA8KfawGoEugKBQFgPlYVUVFREXFxcWJAF4Npa4/eVtctP1EB4ST+bzYbH4+HcuXOznt/tdk/JjErqqEUfAUnRaajYHjY+dK/r16+/m9uaE5fLFdY7qit/jZF1OS7hGjSCQKHfVdNtCBAEQRAEQRAEQRAEIZwIsgjzltl4AblfQ1J0Lmx5dNoxfr8fSZLYtGnTfZctkZmZia7raJpGW1YJAI5ej1njX1EUhoaGpt0NnZOTQ2pqKsPDwxGvMTo6isvlmjaLZS79WCRJEv1YFlF2djaSJKFpGp15lSDp6GMSjoFbZeN8Ph8NDQ1zOl9mZibl5eWMjY1NWRSejwxbBv85/T+zJ8Yo33dg5ADf7v42vYHeOz7nveDMmTN4PJ6w9ypd1SisMUq6tZflIN3MRgjRNG3WYOhoWj43HjACBBmXO0huuRZxvNVqRVEUbty4wenTp+/kVlaVzs5OM7CV1mX8bPSkp5vPq6pKbGwsCQkJC35tRVFYs2YNkiSFBTvHU7IJplkAiYqrn4UdE8pEvHYt8vcRjIb3fr8/7DVVXmuUIBvPjkZ1usLGB4NB4uLilqyE4+T3KM0RTTDFKGmW33SrL4skSXR0dMwpGCwIgiAIgiAIgiAI9zMRZBHmRVc11p03dvEOFCfhi0+Zdpzf7ycuLo4dO2ZvFH2vycvLMxevBrOKkSw6ul8modvYERwq01JbWzvlWIvFQmmpUSrH5/NNe/7JWSxRUVFTnp+2H0u06MeylEpLS81SRJrThZZoZIPltBqldyKVjZuOJEmUlZWRk5PD4ODgnPv2TMcm2/hS4pf4/ZTfJ0qOos3fxre6vsXpsXt/UX86qqpy9epVdF03yzoBpLVcAbeRdXC9ampPKZ/Ph9frnbW0V33VQ3jyokCX2HL4KNax4YjjbTYbmqZx9OhRum4GHu5Fbrcbt9ttZEoGfNj6jK9jW64RlNI0DV3XFzXjbuvWrdjt9invtXXlawBIaeyFQPj312q1Mjg4aDa0n0ldXR26rpuZoJLfQ2yL0Quptmxd2NhQEKO4uHhBe89EUl5ejizLZtC2O8v4Oqd33MresVgsTExMzKm0oSAIgiAIgiAIgiDcz0SQRZiX3LozMKQjWXQubnl82jGhLJYtW7Ys2YLRSlJWVobVajV2uVus+FKN0jc57XXArTIszc3N0x6fkZFBZmYmbrd72mbnY2NjREVFTZvFAqIfy0qQkZFBVFSUmenQn5FsPN4VXopnPouXoVJCCQkJ9Pf33/Xu8nVR6/hGxjcothfj0338dOCnvNL/Cl7Ne1fnXW1qamoYHh4Oa04OsObaeQDcBXGoUbFhz2mahqqquFwu/H5/xO+FpMgcf/hlJJeOPiGx++CbZt+L6ciyjNPpxOPx8M4779yz/VlqamrMgG9KRz16UEKya7hT84FbZQ0XM+PO6XRSUFBg9kMJaSvZjOTU0X0yBTWnwo6xWq2oqhqxZFhTUxODg4NhQbuCmtPGPUbr9OSF9/cJ9aXZsmXLAt3Z7LKyssLeo5oLjMCSpS+A7DXKElqtVjRNo66ubsnmJQiCIAiCIAiCIAirkQiyCHOmqyqVFy8C0FuWSiAmftpxfr+fhIQEHnhgfj0M7hUul4v4+Hhz4bU7w9ghnNrVA9wqw9LZ2Tnt8aGshVD9/8l0XWd8fJz8/Hyio6OnPX7afiwZoh/LUsvIyDCDZO3ZRtm4qJ5xswG6oigMDAzMuYk2QHR0NFu2bCEpKYm+vj683rsLiCRYEvj3af+eZ+KeQULizPgZvtX1LVp9rXd13tXk3LlzZlAyJGqgE1uHkd1wdd3UnlJ+vx+LxcKjjz5KdHQ0Ho8nYnaR6ozms72PIck6tk4/a859HHFOsixjs9no7+/ngw8i93JZrVpbW81Mj+x2oyzbRFo00s3AfCAQwGq1Lko/lskeeOABLBZLeDDLYqW72Og1VlxbEzZelmUURaG1tZWxsbFpz3nx4kVUVQ0LZBfeMO6xuzDDvMcQVVVJT08nMTFxIW5pThRFISsryyxtOZaYjRStgyaR0XyrZJiu67S23j/vB4IgCIIgCIIgCIJwJ0SQRZizguufGeVzrDqXNj827Rifz4csy2zduvW+zGIJmbx41X6z/I21P4DkNxbFFUVhZGSEoaGhaY9PTEwkNzeX0dHRsGyW8fFxoqKiZtzdLfqxrBy5ublmv4e+rBKjbJxPJq63GbhVNq6+vn5e501MTGTXrl2UlJQwNjbG8PDwtBlPcyVLMk/FP8Wfpv0pCUoCfcE+vt39bQ6MHEDT77ws2WrQ1dVFV1cXFoslrOH92svHAIlguoXR1PCMsVAvlrS0NKqqqti7dy8Wi2XG8n4h7qximjYbJfpyLraQ0B45O8BmsyHLMtevX+f8+fN3doMrWFdXF5IkAZDc1W88lpljPq+qKomJiTidzkWdR25uLsnJyVP661xfsxMkHblfI7arKew5m82G3+/n1KnwLBcwAnBNTU3Ge/DN11RUfydKrwro1FZsCxsfCASQJIk1a9Ys7I3NQWFhoVnaUlJkhjPjAchru9UrSlEU+vv7ZwwoCYIgCIIgCIIgCIIggizCXAUDlF+6CkBXReaU8jlgLD4GAgGSkpLYuHHjUs9wRSkoKECWZYLBICPJuUgODV2VSG0z+rCESs5M15cFjGyWkpISoqOjzcWtUBZLXl4eMTEx0x4n+rGsHOXl5VgsFqPngdWOP8XY1Z7TanzPQ7vEm5qaIp1mWg6Hg02bNrFlyxYsFgu9vb2zNmGfTZGjiG9kfIP1UetRUXlr6C2+1/s9RtSRuzrvSnbq1CkCgUBYxoHsHSex0cgAq6lYN+WYYDCILMts2LABgA0bNlBZWYmmabOW9qrZ8Bi+bDtoEts+PYjiibxwbbfbUVWVQ4cO0dfXN8+7W7m6uroYHx83glueMeRBI7urLa8SuJVxl5WVtSTzWbt2LZIkmf1JAHzxKfiyHACsuXYybHxoA8H169enlIq7ePEiHo8nLDOq7GbJsWCaFU9ieth4v99PVFQUVVVVC3dDc1RRUYHNZjPvuzWnGIDYLrdZ0i4UDK6pqZnxPIIgCIIgCIIgCIJwvxNBFmFOiq8eQx+VkGwaVzc+Ou2YQCCALMts27btvs5iAaOBcSiQIiky4+kuALI7jGbJiqKg6zptbW0zniMmJoaioiImJibQNI2JiQkcDkfELJTGxsZJ/ViaAdGPZbnExcURGxtrLsL2pBuLq2nd3cDsZeNmE8pI2rNnDxkZGQwMDDA+Pn5Xc45Sovh3yf+OLyd+Gatk5br3On/b+bdc91y/q/OuRB6Ph4aGhrCMA4CSa8fRAxKSS6e9eNOU4wKBADExMaxbdysA89RTT5GSkjKn/ixHH3kZKVpHH5fYffDXc+rPMjExwZtvvnnXfXhWitra2lvvUy3VRjDYdSsYHMq4KyoqWpL5bNq0iejo6ClBsusVxmaBuGY3iif8Z8tqtTIyMkJ1dXXY49XV1ei6bgZZ9GCQtEajVGRDcWnYWE3T0HWdwsLCZXlPdjqdJCcnm6+rrvw1SIrROyiuzygRZrFY7jgYLAiCIAiCIAiCIAj3CxFkEWYXCFB82dh9374mF9U5tRdIKIslOTl5WXbkrjQ2my1s8aozwyiDk9Q9YI6ZywJ7QUEBcXFxuN1uxsbGyM3NJS4ubsbx4f1YjGuJfizLJzMz0ywb13azbJyt1w8Bo7SUoii43W7cbvcdXyMuLo4dO3ZQWVmJz+djYGAgYn+Q2UiSxO6Y3fx5+p+TYc1gVBvlu73f5a2htwjqQeNe2tpmzMJaLU6ePInX68Vut5uP6apKQU0jAC1lBdP2zgBYs2ZNWCDZZrPxwgsvEBUVNXt/lqhYTj/0EEg6jjYvZZcORpynoijYbDb6+vr48MMP532fK1F7e7v5PpXVaSzeu9Nvva+F+pksVZDFZrNRXGxkcUz+3nXnVyHF6OhBieLqE2HHWCwWNE3j0qVL5mP9/f309PSENbzPaL6CPiEhWTVay8L7lPn9fhRFWdbMz1BZQ03T0G1OAjcz7nJv9mUBI9jX2dl5zwT5BEEQBEEQBEEQBGGhiSCLMKuqmuPGIpFD49rGR6YdE1os2rVr132fxRISKnWjaRrtN8vgSEMayoRRfslisTAxMUFXV9eM53A4HJSWluL3+7Hb7RQUFMw4VlVVenp6jMbMnnHRj2UFKCgoMPuyuFPzkexG2biUm/04QtlOd1uKx2q1snbtWrZv347L5aKvr2/W0lWzybBl8F/S/wt7XHsAODBygH/o/gfONZxjbGyMc+fOzbufzEqhqirXrl0zG6+HZDZeNDL2LDp1a3dPOc7n82G329m6deuU59LS0njwwQdRFGXW/iyDuRV0bMgFoPDcDWK7GiKOD/VnuXbtGleuXJnLLa5Yk/tGASR0DwPQkZUfNiYtLW1Jf5ds3boVi8US9nMjKTKtJca88usaw7KOZFlGURQ6Ozvp7zd6ypw7d45gMBiWlVJaZ3y/hvMS0GyOsGsGg0Gz/9ZyKSsrQ5Zls2RY583fW+mdt34vKYrCxMQEra2tyzJHQRAEQRAEQRAEQVjpRJBFiEj2eym8Zuzsbl5TiG6b2oR4ciPo5Wjeu1KVlJSgKArBYBBffCpSjA66ZJTHwVgY1zSNurrIDbBzc3NJTU0lOzs7YhZLT0+P2Y8ltb1G9GNZAUpKSrDZbEaAS1GYSDOywLLbw8vGLcTiZShLaffu3eTm5jI8PMzo6Ci6rt/xOW2yjS8lfYnfS/k9ouQoWv2t/D/L/6M1upVAIMD7779PT0/PXc99qV25coWRkZEpJZoqqo2shKHCxCkZe5qmoWkaRUVFuFyuac+7ZcsWysvL59Sf5cqWJwlkWNFViZ0HP0H2Ri71ZrfbCQQCHDhwgMHBwdluccVqamrC6/VisViwD/ehjwDodOQZvzuWuh9LSGpqKhkZGQSDwbBsltq1O5EUHdyQ0hZeGsxut+P3+zl9+jSqqppBx1AASZkYIap9wjhPeXjpOVVVkSSJ8vLyxbytWWVnZ+NyucyeTq0FawFQ+oLIN3sGhYLBs/2uEgRBEARBEARBEIT71ZyCLJs2bZrXv82bN9PR0bHYcxeWwPrrx9E9MlKUTs2GvdOOCWWx7N49def3/Sw3Nxe73W4uXg2nxwOQdbNXSqjxeXt7e8TzWCwWtm/fzvr165EkacZxN27cMPscZJn9WG4tBot+LEvP6XSSmJh4q+dBplE2LqW73xwjSVLEbKb5io6OZuvWraxfvx5N0+jv77/rMj/ro9bzn5P/M6n+VIJykNMpp7kRf4OxsTF+/etfMzYWuYH7SnPx4kU0TQsr6xTd14q1KwDoXFm3a8oxfr8fq9XK9u3bI577mWeeISkpCb/fH7FsmKQoHH30JSSnjj4qsfPQmxHPG+rPMjY2xltvvbVqSzc1NDSg6zoWi4WsViNooSfKqFGxwK3eXiUlJUs+t3Xr1iHLsvmeDUZ5t9E8o69V5fXzYeNDfZXq6+upra1lZGQk7DVVfP0kuiZBHAxmFIcd6/f7sdlsbN68eRHvaG6ysrLMsobjyVnmhoDsZiMLJxQ0EpksgiAIgiAIgiAIgjC9OQVZLl68yKOPPsoLL7ww67/nn3+ea9euzVouRVj5Jvp7yKs2FlUaq0rBOnVxPpTFkpGRQWlp6ZTn72eKopCWlmYutHZkGqW+4m+WxwFj8aqnp2fWBVOn02k2Up7JXPqxZGRk3OntCHcoKyvL7HnQFiobN6iau8QtFgvj4+MLGmhRFIWysjJ27txJYmIi/f39eL3euzrnQPMAe7r2sNa9FofqoChQhMPhYHBwkNdff33VLPq3tbXR3d2NxWIJa3hfddnoueHPtDORHJ5FMfl9brafIZvNxvPPP4/D4Zi1P0vAlcC5B3eBpBPdPE7h5UMRz60oClarla6uLj755JNZ7nRlmvw+ldXZBsBAepL5vKqqREVFLUvvqKqqKmJiYszSWSHXKo1eKs62CWwj4VlEVquVsbExDh06ZAa5Q/JuNAPQVpSLpNx6rWmahqqqZhbJcissLDTLGgIMZSQCkNPWaI6xWCwMDQ2tuoCqIAiCIAiCIAiCICwFy+xDDH/+539OamrqnMb+/d///R1PSFg5Or/1F7h8MpJLp65qz7Rj/H4/FouFPXumf/5+l5OTQ3NzM5qm0ZlXQaV0AX1UwjHUgzchDYvFgs/no7m5+a6aPE/fj0WiK1v0Y1luRUVFnD9/nmAwiDchDcmlo48ZZePay7ditVrxeDzU1dUteBAsJSWFXbt2cfXqVZqbm/F6vcTFxUXMiJpOd3c3/f39KJLC+on1lI2VEWWLwmKxYLVa6ezs5I033uDll19e8T2ZTp8+TTAYJCoqynxM8YwR3zSMjkT1mqlNyEPZFXNtUB4q23bw4EH8fj8Oh2PGsX0FVXRXNZF+uYvS0zX0phcwlpo343i73Y6qqly6dInc3FwqKyvnNKeVwOPxMDAwYJTJUzWie8bQkWjPupXloWka6enpy/I6UhSF0tJSzp49i6qq5hyGs0vREw8hDUL5tRNc3vGseYzNZsPv9zM6Ooosy2bgLrarAWlIB0mnvmJH2HWCwSCyLLNu3bqlu7kIKisr+eSTTwgGg1itVlpzi4mvO0NM1yi6qiEpMlarFa/XS3V19bQ9iQRBEARBEARBEAThfjanTJampiaSk5PnfNLq6mry8mZeJBJWvqHWJmJOXgfgelU5WKZmUYR2d2dlZd1VgOBeVlJSYjYVVqNi0ROMH7nsm31ZLBYLqqpy48aNu7rOTP1YPInpwK1+LOL7tPQKCwvNhXEAd7rRVyerswmYe9m4O+VwONi8eTNbtmzBYrHQ29sbVg5pNl6vl+bm5rAm8Vb91vuB3W5HURTq6+s5dOjQQk9/QY2NjdHY2Bi2GA5QfuUoelCCWOjOn7rwHQgEiI+Pn1dAY/v27RQXF6Oq6pTMiNtd3Po0apqCHpTYdeAjZH/krCOHw0EgEOCTTz7B7XbPeU7L7caNG2ZgPnagDd0jISk6vTllAObPSE5OzrLNcfv27WbgZLLGUqN8WeaNdvTbfn4sFgt+vx+73W4+Vn79HAC+LAeBmPiw8YFAAJfLtez9WEJsNhupqanm1787txJJ0dE9EvE9xvtUqH9Uc3PzMs5UEARBEARBEARBEFamOQVZ8vLywhakZpOTk7PidzMLkSlWK+MbC9ETJWqLH5h2TKhHwUMPPbTEs1s9MjIyiI6ONhe1B9KNYGVGl7GgHvq5utseRqIfy8qlKErYAmZHVj4ACXdQNu5OhbKYdu/eTXp6OgMDA0xMTMzp2Lq6OnNhfKbfA6FMjbNnz3L+/Plpx6wEJ0+enLIYrgeD5NS2ANBUXhRW1gluZYGtWbNm3r/XnnvuORISEvD5fJH7s1gsHHnkJSS7Bm7YdmRu/VlGR0d58803V02ptqamJjNYl91SA0Ag2YpuM14/gUAAi8WyrKUn4+LiyM7ORlXVsO9ZY+UOJJuGPi6R1Xgx7BibzUZUVNSt10fAR2KLUbKxvmRN2NjQOYuLi1fU56Tc3FyzrKFuc+BLM35X5N3cEADG666jo2PVvN4EQRAEQRAEQRAEYanMOXKSl5fH7/zO7/DKK6/Q1ta2mHMSVoDYjGwK//FnvP3M15AsU6vKhbJYcnNzyc3NXYYZrh4ZGRnoug5AW7aRSRLdM4auGottiqIwMDAwZef0fIT1Y+kV/VhWmuzsbHMBsyNvDaCjj4B9uA8wdsKHMkYWU3x8PDt37qSiogKv18vAwEDExf+2tjbcbveUzI/phLIrDhw4QFNT00JP/a6pqsr160Z23uTF7Zwb59DHJSSbRv3a6RveO53OOyqR5HQ6efbZZ7Hb7Xg8nohj/XFJXNyzHdCJvTFCbvWJiOND/Vk6OztXTX+Wrq4uJElClmXSuzoB6M1IM59XVZWYmJh5Zc4uho0bN6IoSlgGkmZzMFhg9I4pv345bLwsy2Gvqdwb59F9MpJDo6NoQ9jYUMByy5Yti3cDd6C8vBxFUczfQ51ZRjZRWke3OUZRlCV5nxIEQRAEQRAEQRCE1WbOQZbf+Z3foampiT/8wz8kPz+f4uJifv/3f5/XXnuN7u7u2U8grEq37+oO8fl8IotljkI7hFVVpS+7zCjD4pWJ62sFjAX2QCBAfX39HZ1/cj8W2TuONGgsmot+LCvHTGXjslpvlY3TNO2uy8bNhdVqpaqqim3btuFyuejr65s2wDc+Pm4G1OeSySjLMlFRUXi9Xt555x36+/sXfO534+LFi4yMjIQ1Jgcor74CQH9RCrrNGfacpmlomkZxcTFOZ/hzc5Wbm8uOHTuQJAmvN3IZsO7ijfRXGr3PKj+7TFR/Z8TxoYycS5cuceXKlTua31Jxu90MDw8bwYhgAHuvD4D2m6XCNE1D1/VlaXh/u5KSEuLi4qaUebu2dicA1i4/joGuGY8vrjOCef0FqVNKbQaDQVJSUubc426pZGRk4HK5zCyVlvy1AMgDKsrECGC8d2iaRl1d3bLNUxAEQRAEQRAEQRBWojkHWf7H//gfHDp0iOHhYT755BO++tWvUldXx+/8zu+QlZVFRUUFX//61xdzrsIKoWkaqqqSn5+/IhbEVrrQDuFAIIBucxBIMRbdstqMcjmKoqBp2h3v/p/cjyWtrVb0Y1mBMjIyiIqKMhcwB9KNHfFZneFBjLstGzdXkiSRlZXFrl27yM3NZXh4mNHRUTPjStM0amtrCQaDKIoy53KRoUDL6Ogov/rVr2bN3lhKFy9eRNf1sJJ5sV1NKL0qSDpX1+2ZckwomLx9+/a7uvaOHTsoKCggGAzO2g/n3M7n0JJl9IDE7gPvQcAXcfzk/ix9fX13Nc/FFHo9Wa1Wkjrq0YNG9tBgeiFwK+NuJfRzUxSFNWvWmMHxkPGUbIJpFkBizdXpM43sw31Yu42g5fXK8FKboYD3fHr7LKWsrCx0XUfTNLxJGUixgC6R3WQE8EL9o0Q2syAIgiAIgiAIgiCEm3ujlZvsdjuPPPIIf/VXf8Xhw4fp6uriL/7iL+js7OR73/veYsxRWGF8Ph82m429e/cu91RWhbi4OOLi4szFut50ozxOepexE1qWZSRJuuMF9sn9WDJvNlMfE/1YVhRFUcjIyDBLc7UvUtm4+XK5XGzdupX169ejaRr9/f2oqkpzczNjY2NzKhN2O0VRsNvt9Pf38/rrr6+I/g1NTU309vZiua30YdUVY6Hcl+XAm5AW9lwomJydnX3XWQeKovDiiy8SHx+P1+uNWKINi5Wjjz6PZNOQhnS2Hns74rlD/VkmJiZ48803l/T1Mx+tra1mP5acdiNrz5MWhXSzzFYoALOc/Vgm27p1K3a7HZ8vPMhVV270WElp7IXA1K91ac0p0CW0JJnxlPBSmn6/H4fDwaZNmxZv4nehuLg4LLA0kJEIQE7brQ0AFouFoaEh3G73ssxREARBEARBEARBEFaieQdZ/H4/hw8f5q/+6q/Yu3cvWVlZ/OIXv+ALX/gCP/rRjxZjjsIKElp4LC4uXnHlTlayzMxMc4dwqDyOvdcHQaMcjaIouN1uxsbG5n3uyf1YkkL9WNJFP5aVJjvb+J6oqkpvTrlRNs4jETtg7Aq3WCz4/X5qa2uXdF6KolBWVsbOnTtJSEigtbWVzs5OJEmaEpSYK6vVitVqpa2tjXfffXeBZzx/Z86cQVXVsECjdWyYmJZRAK6undofIxAIIMvygi2IO51OnnnmmTn1Z/EmpHF152YAEmqHyK45HXG8oijYbDb6+vp45513FmS+Cy3UjwUgpbvXeCwjy3w+GAwSHx+Py+Wa9vil5nQ6KSgoMEvGhbSVbEZy6ug+mfyaU2HH6KpGVkM7AM3F4ZmDofPk5eWt2IB3WVkZNpvNzLZqzTUCXq6uUfSbgRer1UowGDT7GwmCIAiCIAiCIAiCMI8gy1//9V/zyCOPkJCQwB/90R/R1dXFH/zBH3Djxg3q6+v5wQ9+wG/91m8t5lyFFcDr9WK323nwwQeXeyqrSl5entn4fDC9EMmmoQclkjqMHd2hviw1NTXzOq+qqvT29k7px9KRbQRyRD+WlaO8vNz8Pus2B4Fko2xcdsutsnG6ri9bU+mUlBS2bt3K0NCQGZwLlQ+7E3a7HVmWqa6u5vDhwws40/lxu920tLRMKXtWceUYuipBPPTlTC3fFAgESExMXNDMioKCArPh+Wz9WdrLtzJUlgDA2hPncAz1RBxvs9lQFIX6+npOnjy5MBNeID09PYyPjxvfA+84cr+xYN+ea3zdQ0GMUCBypdi8eXNYM3gALFa6i42gdUlt+Pt1Svt19FEJSdFpLN8W9lwgEEBRFDZs2LDY075jNpuN9PR0M5OlJ7ccyWIElBK6GoBb71N3Wt5SEARBEARBEARBEO5F8+rJ0tjYyN///d9z9OhRvve97/GVr3xF9OS4j6iqiqZplJaWkpycvNzTWVXKysqwWq0EAgEkRcGbajTRzmk3Gp1bLBZ0XaelpWVe5+3p6WFiYmJKPxZvkrEIKPqxrByJiYnExsbeKhuXcbNsXLfR3DxUNq6zM3Kz88V09OhRPB4PNpsNWZbNZuST6cEgjrHhOZ3Pbrej6zqnTp1atsbsJ0+exO/3h2cPBANk1hkZBzcqypCU8F+FoeBkVVWV0ah9AT344IPk5ubOqT/L6d0voCdI6H6ZPQfeMTPfZmKz2dA0jaNHj9La2rqQ074rtbW15ntReut1831qItn4/BAMBpFlmYKCgmWeabj8/HySk5OnfJ+ur9kJko7crxHbdSvYUFZ7EYCxHBeqMzrsmEAgQFxc3Iq7x9vl5ubeKhlmteNNcwCQ33IroCTLMt3d3SuiFKAgCIIgCIIgCIIgrARzDrJ8+OGH/MZv/AY//vGPyczMpKqqin//7/89v/rVr1Z0s11h4fh8PhwOBw8//PByT2XVcTqdJCYmmotSnZnGju2U7lu70yVJoutmn5a5Ev1YVpeMjAyzbFxbtpEhcXvZuOHh4TsqG3e36urquHr1KpIk4XA4cDgcKIoSXi4pGOS5j3/O02+9S8m1Y7OeM9QvxO/3s2/fviVf+FdV1cwOmxwsyas9je6RkOwaDZU7pxzn8/mIiorigQcemPLc3VIUhZdeeom4uLjZ+7NY7Rx79Fkkq7Ggv/lE5NJroa+3z+fj3XffXZbX0XTa2trMfizZHY0AjKTFms+v5GBwVVUVkiQRCNwKcPniU/BlGcGHNdeMrCHZO05Mq1F+rrZsfdg5VFVFkiTKysoWPGi30CoqKlAUxbzfzuwcAFI7u80xFosFj8dDY2PjssxREARBEARBEARBEFaaOQdZnnzySf72b/+WkydP0t/fzze/+U2ioqL41re+RXZ2NmvWrOFP/uRPFnOuwjJSVRVd16moqCAuLm65p7MqZWVlmSXD2nMrAJAHVBTvBGAsvo6Njc0raCn6sawuk8vGDYXKxgUkkjqNjKZQv4P5lo27Wx6Ph3379hEIBHA4jMVjWZax2+1YrVZ0XUdVVbZeOoDSp4IuUXqqhpTmq7OeW5ZloqKi8Hg8vPXWWwwNDS327ZjOnj3L2NjYlCBj6fVqAHqK08Ea/lwo6FFaWrpowUmXy8VTTz2FzWabtWzYRHIm1TvWAZBc3Uv6jQsRx8uyjMPhYHh4mLfffnvZsw0mlzQESOg2vv8dWXlhY1JTU1dkMHjTpk1ER0eHlwwDrldsBCCu2Y3iGaew5jR6UEJy6fTmrgkb6/f7sVqtK7bh/WSpqalhGXctBVUASAMa1jHje2exWNA0jfr6+mWbpyAIgiAIgiAIgiCsJPNufA8QExPD008/zf/8n/+Tf/zHf+Q//af/RHt7O//8z/+80PMTVgiv14vD4eChhx5a7qmsWkVFRUiSRDAYZDwhAylaB00itc1oIBxaYK+rq5vT+UQ/ltWntLTU/D5LFotZNi673VisDPU7mG/ZuLv13nvvMTw8jMPhCOtbIkkSVqsVu91Oan8LGVdvZlrFAprE5oNHie7vmPX8oQyLkZERfvnLX87a+H2hXLp0CV3XsVqt5mPx7XXI/RrIOtXr9kw5xufzYbVa2bFjx6LOraSkhE2bNqHrOj6fL+LY1sqdjBTHAhIbjp7E5h6ION5isaAoCs3NzRw6dGjhJn0HWltb8Xq9KIpizNttPN6Zd6sfiyRJK64fS4jNZjMzbCZnHXXnVyHF6OhBieLqExQ0GIHSrsLMsPJzmqahqiqZmZkkJCQs7eTvUFZWlplx54tPhTgAiewmI6gaKm3Y1ta2rPMUBEEQBEEQBEEQhJViXkEWTdM4ffo03/zmN/nc5z5HQkICu3fv5v/9v//HSy+9xA9/+MPFmqewjEILS2vWrMHlcs0yWphJUVERNpvNKB2jyIymxQCQ3W6UXAmVkZnrwlVvb++tfiztoh/LauByuYiPjzd7PJhl47rurmzc3bhw4QI3btzAYrFgsVimPC9JEjYtyJ7jR0GX8GbbeftzX0BPvNkr5ON3sY67Z72OoijYbDb6+/t54403Fj3D4saNGwwMDEy5p6qrpwDw5ETjiwvvLRVaEM/JySExMXFR5wewd+9esrKyCAQCs349Tj34EsSB7pN58MCb6LP0c3E4HEiSxLlz55Y8M2qy+vp6s6RhVquRQUQ8BFxGwCEQCCDL8op+n9q6dSsWiyUsm0VSZFpLjGycgmsNyH0aoFNTuT3s2FCwu7KycimnfFeKi4uRZdl8n+rPNH5OctqbzTGh0oZLmZkmCIIgCIIgCIIgCCvVnIMsoaDK9u3b+ad/+ieSk5P5h3/4B+rr62lpaeHHP/4xv/3bv72YcxWWSTAYxOl0iiyWu6QoCqmpqeZiakemsUCX2DNojplPQ2HRj2V1Cu3Y1zSNjptl45Rpysb19vYu+lzcbjeHDx9GVdWIr5MHjr2DPgKSQ+PwrmfQ7E4OPP4CUpSOPirx0MevQyByNgYYWQGhDIuPPvpoIW9lijNnzky5L5t7gKjWcQCuVG2dckwgEEBRFLZs2bKocwsJ9WeJiYnB4/FE7M+i2Rwcf/QpJIuO0quy4fQHs57f4XDg9/v5+OOPl20xfHJJw8xOI0NrMD3JfF5VVRwOBzk5Ocsyv7lIS0sjIyODYDAY9j2qXbsLSdHRJyQAguk2I/NjkkAgQHR0NOvXh/dpWclKSkrMDQEArblG/6iorjEzuGe1WgkEAly/fn3Z5ikIgiAIgiAIgiAIK8Wcgyzx8fH8r//1v6itraW9vZ2f/vSn/Lt/9+8oLCxczPkJK4AkSaxbtw6n07ncU1n1Jvdl6cy9ubN5GGwjRqBFURQ8Hg8dHbOXYGpvb7/Vj+VmoEb0Y1n5CgoKzF3iYwkZSFFTy8apqjrnsnF3SlVV3nnnHcbGxnA6nWFlwiZLa7hIfJ2xQH9511ZISMHhcBCMT+XE40+ai/67Dr6OrkZo4n5TqCTZ5cuXOX78+ILeU8jg4CBtbW0oihJ2X5VXj4ImoSdJDN0sqzdZIBAgKSmJkpKSRZnXdOLi4njiiSewWq2z9mcZS82jbms5AOlXOklpuhJxfKhM2+jo6JJkD93O7/fT399vlMFTNWJ6xgBoz771uUHTNNLT01d8Q/h169aFZXcAqFGxjObGmP//Rkn4a0rTNHRdp7CwcMXf32Q2m4309HTz9dKXU45k1dH9Mkmdt0obAjQ3Ny/XNAVBEARBEARBEARhxZhzkOW1117jD/7gD5Z08UlYGVwuF7t27VruadwTSkpKkGWZQCCAPzbxZq17yLxZRsdqtc6pofDUfiw3s2NEP5YVr6ioyAykSIrMaPrUsnG6ri96v4NTp07R1tZm9u+YjjIxwsZjJwEYKY6ls2QzcKsnw0hGAZcfegAkHVfTOOvnkF0BYLfb0TSN48ePU11dvTA3NMnJkyfx+/3h2TkBP+n1Rhm2uoqppZsCgYAZUF5qFRUVrFu3bk79WRrXPcx4fjToEpuPHDebkc8kVKatu7ubDz6Y2/dnodTX15vZQTGDHUbGh6zTfTODS1VVJEla0VksIVVVVcTExBAIBMIer167FdCR7BqtN38+Qvx+PxaLZVU0vL9dXl4ekiQZgRaLFU+6sckir/VW6TlZlunq6lry4J0gCIIgCIIgCIIgrDRzCrJ85zvfmXWH7WTf+973GB0dveNJCSuD1WrFZrOxfv16kcWyQLKysnA6neai1FC60Zcg62YZHVmW0XWdzs7OiOeZth9LlOjHshrYbLYFLRt3J3p7e/nss8/QdR2HwzHjuF2H30b3SEgundO7X5h2TGfJZlo2G5kJGZc6yKs+Mev1QxkWfr+fjz76aNbX+3z4/X7q6uqQJCkseFR4/TN0r4zk1Gku3zbtcS6Xa9kWxJ944gkyMjLm1J/lxMMvGU3XPRIP7n8TfZbxNpsNWZa5evUq58+fX8hpR9TU1ISmaVgsFrJajUwtNdmCbjN+n4QCMKWlpUs2pzs1eZ6Tvz9DWSWcf3IXx595Gt0W/rMUDAZJTEw0SwSuJhUVFSiKYgaVOrJyAUjp6DPHWCwWfD7frJsClkpvby+HDx8WfWIEQRAEQRAEQRCEJTenIMt//I//cV5Bk//6X/8rfX19sw8UVjSXy8VXvvIVHnzwweWeyj1DURTS0tLMuv7t2UYQJKZnNGxMT09PxIVW0Y9ldcvOzp62bJx1dBgwXgNer3dRsllUVeXdd9/F4/FEDJ7mXTuOs2UCJJ0zDz6E6oiacWzNlicYLo0HoOL4ZRJbZ2+0Hgq0TExM8MYbb+B2u+d9L9M5e/Ys4+Pj2O128zFd1Si5XgtAZ2kWWKxhx4R+1srKypbtZ0ZRFF588UVcLtfs/Vkc0Zx45EkkRcfSHWDjyfdmPb/dbkdVVT799FO6uroWcuoz6ujoQJIkZFkm42YgrTcjzXxeVVVcLhepqakznWJF2b59O1arFb/fH/Z4X0EVo6l5YY+FsnQqKiqWcooLJjk5mbi4uFt9WQqMDC9pSDfLW1osFjRN48aNG8s2z/7+fg4cOMC//uu/8sMf/pCjR4/y1ltviewaQRAEQRAEQRAEYUnNKcii6zqPPvoomzZtmtM/j8ez2PMWlkhGRsaqqiW/GuTmGjuCVVWlO6ccZB19XCKq31iEVBQFv99PQ0PDjOeY3Ew61I+lOz0LwFycTU9PX8zbEO5CUVFReNm4eOPxrJarwK2ycZFeA3fq008/pbu7G6vVOmMfFsdwHxWnLgPQV5nKQO7sC8UnH/w8gQwruiqx9eCnOAe7Zz1GURQcDgfDw8O8/vrrUxav50tVVa5cuYKu61gsFvPx5PYaGNKRZJ3ra/dMOS5UWmzHjh13df27lZiYyKOPPorVap21bNhIRgF124zvS9qVLjLqI2eoyLJMVFQUHo+Ht99+e9F/T4+NjeF2u43yd8Egjl4jG7Y961bJUV3XV1XfqLi4OHJyclBVNWIQDG69pjZu3LhEs1t4OTk56LqOpmn445LASLwku9l4bwiVDVzs0oa3Gxoa4tNPP+X//t//yw9+8ANOnjxJb28vYAR+Ojs7F63fkyAIgiAIgiAIgiBMxzL7EPjLv/zLeZ30hRdeIDEx8Y4mJAj3utLSUo4ePWqUynFEoyUpyH0a2a3V1CVnYrFYCAQCNDQ0TFtGR1VVenp6buvHItGeYzTEDgaDyLIs+rGsYDk5OTgcDnOhezAtkcThQbI6W2heu9ssG9fe3r6g121ububChQtIkhSW6TGZrmrsOvQOul+GBInzO56b07kli4XDT3yZx95+FX1Y5sGP3mb/S19FdboiHmexWLDZbPT09PDGG2/wxS9+8Y4Du/X19QwODmK1hmeqrL16BoDRvBgCMfFhz2mahqqqFBYWEhcXd0fXXUhVVVW0tLRw6dKlqX1lbtO47iHSezqJaRhh/dFTDCVn4U1Im3G8LMvY7XYGBgZ45513+PKXv7wYtwBATU0NgUAAu91OUucN9ICEZNUZyCxG4lbfqLy8vFnPtZJs3LiR5uZm896mE3pNFRQU4HJFfv2vZEVFRVy+fJlgMIjNZqMvM4WUoT5y2ltovNm6SFEU3G43g4ODi/q5z+12c/HiRRoaGujr6yMYDJrBVKfTGRYwHh8f5/Tp05SVlZGWNvPPgyAIgiAIgiAIgiAslEUJsgiCMLOUlBRcLpdZHqkvPZW0vm4yujqo41Zflo6OjmmPD+vH0nZtxn4sxcXFS3VLwjwpikJ6erqZqdKeXUhi7SAx3aPoqoakyCiKQm9v76wL7XPl9/v58MMP8fl8REXNXPqr4sJ+LN1BJEXn+N6nppTWikR1RnP4yRd5+O030EdkHv74Fxx49rdmPYfNZjMzdz755BOeeuqpOV9zsnPnzqGqatjit324F0e7B5C4WrV9yjF+vx9FUdi6desdXXMxfO5zn6Orq4uenh4URYkYdPrsoZd4fPAVGJJ58JO32ffSvwXrzK8Xq9WKqqo0NDRw9OhR9uyZmtmzEFpaWsxF8OwOo2eHN9WBdDPDKBgMYrVaKS8vX5TrL5aSkhLi4uIYHBycMcgSCnSvW7duiWe3sEpLS7Hb7fh8Pmw2G825FaRc68PZNQHBAFisWK1WvF4v1dXV7N69e0GvPzY2xsWLF6mvr6evr49AIGC+phwOx4w/F6EyhO+99x7/9t/+W5GNKwiCIAiCIAiCICy6OZULEwRhYWVkZKDrOgBt2Ub5HGfPhNnAWlEUhoaGpi3pM5d+LImJiaIfywqXk5ODJEmoqkpvToVRNm5CInrI6JcRajq9UCXDPv74YwYHB80m6NOJ7msl/0IjAC0b8qf0mZgLb0IaJx979Ga/kCA7Dv0KXY1cWgnA4XAgSRIXLlzg1KlT875uX18fHR0dKIoSdn9rLx8FXUJNkXFnFk05LhgMkpKSQkFBwbyvuVhC/VlC5b0ilabSbQ6OPPYckk1DGtTZfviNWc/vcDjQdZ2TJ08uSkk6gK6uLiRJAiC1q8d4LDPTfF5VVeLi4lZdpoeiKFRWVpo/u9MJBALExMRQVla2xLNbWKFgcOj1N5BVgmTT0AMyye215hhd12lpaVmQa46NjfHZZ5/xyiuv8N3vfpfDhw/T0dGBpmk4HA5cLlfEAAsYGxWsVivd3d0cOXJkQeYlCIIgCIIgCIIgCJGIIIsgLIO8vDwkSSIYDBoLVxYd3S+T0G0ETULNlWtra6ccO7kfS+IM/VhWU5+D+1VpaakZSFEdUahJxqJhdut14FZT6aampru+1vXr16murkaW5ZmDb8EAuz79CF2VCKZZqN70+B1fbzi7lGu7NwI6sTdGWHNu35yOczgcaJrGkSNHqKurm9c1T548OaWEk+z3knLD6NVQW1k15Ri/348kSWzYsGFe11oKKSkpPPzwwyiKMmt/Fm9SBpf2bAV04m64Kbx8eNbzO51OvF4vH3zwgZlVt1D6+voYGxtDURQkvwelPwhAx83ePpqmoes6WVlZC3rdpbJt2zYzw+N2oXsrKSm5JzIoQmUnVVVFsliYSI8GIK/11s+noih0d3ffcU8lj8fDqVOnePXVV/nnf/5nDh48SGtrK6qqzjmwcrvQ+8DZs2fp7Oy8o3kJgiAIgiAIgiAIwlyJIIsgLIPy8nKsVivBYBAsVnypxsJ3dpsRVAmVDLt9d/DkfiyKdwJ50NhJLfqxrD6pqam4XC5zN3x/utE7ILPT6MMSysa4274sY2Nj7N+/P2IPCYANp95HGtSRrBrH9j6HdJcLxG0V2+jYmANAzvlmsmtOz3qMLMs4nU58Ph/vv/8+PT09c7qWx+Ohvr4eSZLCsliKr51A98tI0TqtJVumHBfKOFipzck3bdpERUWF0Xh8lgXsrpLN9K41XkOlp64T0x05OBf6Wrvdbt56660ZszLuRG1trVm2ML31OmhGScPRRCOooqoqsiyvqOyh+XA6nRQUFKBp2pQsI7/fj9VqZfPmzcs0u4VVWVlp9gkDaM82stuSO/vMMaFA4I0bN+Z8Xr/fz9mzZ/nZz37G//7f/5v9+/fT3NxMMBg0AytOp/OuAlWT30sW8vUtCIIgCIIgCIIgCLcTQRZBWAYul4u4uDhz4acn3Sijk9bdDRgLoJIkTdmBO7kfS0p7rejHsspNLhvXerNsnKPXgx40dv5bLBaGh4cZGxu742t88MEHjIyM4HA4ZiwTlthaQ9pV47VXs3UtvvjUO77eZFe2fI7RohhAYu2x88R3zL4IG1r8Hx8f59e//vWc7v3MmTN4PJ6wLB1d1SioMXqBtJfmmr1AQkI/e+Xl5Ss64+Dpp58mOTkZv98fsWwYwPntzxFMt6CrErsOfIzsify1s1gsWK1W2tvb2b9//4LNua2tDV3XURSF7Haj/NxomgtJMV5/oX4sJSUlC3bNpbZ582YURZkS/AoGg6SlpZGSkrJMM1tYCQkJJCQkmD8vbQXrAR2GwT5sBFpCWXezBVn8fj8XLlzgtdde4zvf+Q4ff/wxTU1NBINB7Hb7ggRWJgtl7vX29vLpp58uyDkFQRAEQRAEQRAEYTrzDrI0NjYuxjwE4b6TlZWFrutomkZ7rpGJYu0LQMBYtFMUBbfbHVbKZ3I/lqyb/VjGRT+WVStUNk5VVQaziieVjTPeZ0M7yOdbOivk3LlzNDQ0oCgKltuCDCGS38PWo4dAl/DmOmiuitwIXdM0xsbGpu0XNOXcisyJvV8kmGZBD0ps378fx3DfrMcpioLD4WBwcJDXX3894i50VVW5evWq2RA7JK3lCrhBUnSuV01tyB1q5r1z585Z57OcbDYbzz//PE6nc9b+LJLFwpHHXkaK0tFHJR48MHs/HLvdjiRJXLx4kStXrtz1fFVVpbu72wzoJXYPANCZmRc2Jjk5eVW/T+Xn55OcnGxkI94UDAaRJImKioplnNnCy8nJMX9XBWLi0RON721u81Xg1qaA6bLuVFXl8uXLvP766/zTP/0TH3zwAQ0NDfj9/rDAykzvT3fLZrOZvZ7a2toW5RqCIAiCIAiCIAiCMO8gS3FxMbm5ufzmb/4mP/jBD+ZVHkIQhFsKCgrMBXZ3Si6SQ0NXJVLbagCjL4uqqtTU1JjHhPdjMRYvu0Q/llUrVDYuEAjcLBtnlPPKaTeCKjOVjZuLoaEhjhw5gqqqEReztx19G31UQnLqnHjoxVnP6/F4sNvtaJqG1+udfSIWK4ee/CJSLOgeiYc+egPZOz77YTezLDo7O3njjTdmDLTU1NQwPDyM1WoNe3zNtfMAuAviUKNiw54LlXkqKChYFY3XMzIy2LNnD7Isz1o2LOBK4PTDD4OsY2/3sfbsR7Oe3+FwEAgE2L9/P319swfBImlra8Pr9aIoCtaxIRg2Hu/IWwPcep9arf1YJquqqjJ7a4GRqeF0Olds+bk7VVxcjCzL5n32ZhmZblntt96XFEVhZGSEvr4+VFXl2rVr/OpXv+I73/kO7777LrW1tWZgMyoqiqioqEULrNzO4XDg8/n44IMPRNkwQRAEQRAEQRAEYVHMO8jS1tbG3/zN3+B0OvnWt75FaWkp2dnZfPWrX+X73//+YsxREO5JJSUl2Gw2Y/ezIjORZiz2Zt8sqaQoCrqu09raCszcj6UzpwwQ/VhWo9vLxnVnGGXjUruMXiQzlY2bjaqqvPvuu4yPj+N0OmcsE5ZRf564eiNT6uKubQSi4yKe1+v1IkkS27dvp7CwEFVV59TsWo2K5ciTzyHZNRiGh/b90iyJFondbkdRFOrr6zl06NC0Y86dO2dmd4VEDXRi6zCakl9dNzVTxe/3Y7FY2LZt26xzWCm2bt1KcXExqqqa/TFmMphbTvPmQgCyL7aScjPjYCaTS7S9+eabd9zAHKChocH8fmS2VBsPxoE/NhEw3qcURVnVpcJCNm3aRFRUFD6fzwzc5efnr+oMnekUFRXhcDjMIEtLnpGp4+j2QtB4LYY2Bbz33nt85zvf4e2336ampgaPx4PVajUDK1ardcb3o8USKhvW39+/oGXxBEEQBEEQBEEQBCFk3n/pZmVl8dWvfpV//dd/pba2ltraWh577DF++ctf8od/+IeLMUdBuCfZbDaSkpLMBfbOjGwAkrv6zTGSJNHV1QXM3I9lPD4dEP1YVqvMzMxbZePybpaN6w8g+Y0sEUVRGB0dZXBwcM7n/Oyzz2hvb8disczY38A6Nsz646cAcJfE0V0cefe9qqoEg0FycnLYuXMnn//850lJScHv94eVTJrJRFImZx55CEnWsXX62Xr0zTndi8PhAODs2bOcO3cu7Lmuri66urqwWCxhC7drLx8DJILpFkZT88KO0TTN7JuRk5MzpzmsFC+88AKJiYnmon4kNRsew5MXBbrE5kNHsbkHIo5XFAWbzUZfXx/vv//+Hc+xvb3dzLbL6jAyHYbSE8znQ/03cnNz7/gaK4XNZjPfb/1+P4qi3HNZLGC8NjIyMszX3GBGMZJdQw9KpLZeN8fouk5HRwcejweLxWIGVmw225IHVm4XKht26dIlmpubl3UugiAIgiAIgiAIwr1n3n/1TkxMsG/fPv7bf/tv7Ny5k3Xr1nHp0iX+5E/+hDfeeGMx5igI96xQyRxjgb0SAGlIQ7nZsNpisTAxMUFXV9eM/VhCzaRFP5bVKT8/H1mWUVWVkaQcJKd+s2xcLWDsEA8Gg9TW1s7pfF1dXZw8eRJd180Axe10VWPn4bfRvTJSjM6pPS9EPKemaXg8HlwuF88++6y5IP/lL3+ZuLg4vF7vrIv+AAN5ldTsXAtAYu0gpefntqs8VM7q4MGDNDQ0mI+fOnWKQCAQ9pqXveMkNhoBqeuV66ecK5TxtWHDhjldeyWx2Ww8++yzOByOWXviSIrM8b2fh1jQvTIP7n/DzDqIdH5ZlqmpqeHUqVPznp/f76evr88M7MX2jADQnlVojtE0jbS0tAVrbr7ctm7davZOio+Pp6CgYLmntCjy8/PN8paSojCeYWRe5rbd6hcVCqqslMDK7RwOB36/n48++uiusrUEQRAEQRAEQRAE4Xbz/gs4Pj6e3/zN38Tr9fKNb3yDzs5OLly4wD/8wz/wwguRF+oEQQg3uda9NyENKUYHXSKj5RpwqwRLfX296MdyjyorKzMDKZIiMz5N2ThgTk2bQ+V6vF4vTqdzxnGF1cdxtHlB0jn10F5028xj4dYu/QcffJCEhFtZCXFxcbz44otERUUxMTExp0BL89rddK8zXqcFZ26QceP8rMfIsmyWZXrvvffo6+vD4/HQ0NCALMthi7mlV4+jBySkGJ2OoqlZBYFAgJiYGNatWzfrdVeiUCaRJEmz9sRRHVEce/xzSBYdpU9jy/G3Zz1/qN/OkSNH5t0oPNTQXFEUovo70cclkHS6c43yUpqmIUnSqssgiiQtLY309HRkWaasrGy5p7NoKisrzWASQFu2EUxK6ryVIXX7z+JKEyobNjAwIMqGCYIgCIIgCIIgCAtq3n8NP/3006iqys9//nN+/vOf8/rrr1NXVzf7gYIgTJGfnx9W6344LR6A7A4jUyXU+LytrU30Y7lH3V42riPTWIBO6g5fvOzq6pq1aXOocXmkXeSOoR7KThtBvJ61GQxlR14YDgaDBINBioqK2LRp05Tnc3JyePLJJ7HZbHg8njkFWi5ue5aJfKOU1frDp4ntbp71mFDfkNHRUX79619z5MgRvF4vdrvdHKOrKvm1jQA0lxYg3ZYtEfr6rVmzZlVnUuzcuZOioiLzexPJeEou13caAaWk6wPkXI+coRL6Ovt8Pt55551ZM2Yma2pqQtM0LBYL2a1GPxYtWUFzRANGgEtRlHsuGPHAAw+QkJDA5s2bl3sqiyYuLo6EhATz9dZRUAWSDm7jPWU52UYGKTv3CY+98X2e+OW/Yh/um3nszbJhV69epampaQlnKQiCIAiCIAiCINzL5h1keeutt+jv7+ejjz5ix44d7Nu3jz179pi9WgRBmDtFUUhLSzMXpjuy8gGI73GbY0IL7Lf6sdSJfiz3mMll4zpyb5aNG9RQJoxyS4qimGXjZtLU1MSlS5cAZiwZp6squw+9ix6Q0BMlLm57OuK8NE3D6/USFxfHc889N+O4NWvWsGPHDmRZxufzRTwnGKWsjj76ZbQUGT0gsXPfR9hGZu85oygKdrud/v5+rly5gq7rYcGSzMaL6KMSklWnfu3uKcf7fD7sdjtbt26d9Vor3fPPP09CQsKcSrW1VO5kqMzIQFpz4gLR/R0Rx8uyjMPhYGhoiDfffHPW4F5Ie3u7eXxGl3GNvvRU8/lgMEh0dDRpaWlzOt9qUVlZyR//8R8TFxe33FNZVDk5OUiShKZpBKLj0BKNn73cpitLPhfruJvSCwd59M0fsPe1X5J/phGlV0Ua1Nl1+F10deafiVDZsA8//FCUDRMEQRAEQRAEQRAWxB3XdaiqqmLXrl3s2LGDBx54gN7eXn7xi18s5NwE4b6QnZ1tLlx15lWCpKOPgOPmblxFUQgEAuYO8cwuY6e+6Mdy75hcNs4Xn4IUCyCRNalsnKZp1NfXT3v85AXDmfqwAKw59wlKj4qk6JzY+zmwWCPOy+fzYbVaefzxxyOWHwPYs2cPa9euRdf1WctYGTdl49CTX0Ry6egTEg9//Ctk/+zHWa1WrFYrHo9nyuu98poRZBosSER1Roc9p2kamqZRVFSEy+WafX4rnNPp5JlnnsFut88pg+j0npfQko2g1u5P3kPyR85QsVgsWCwWmpqaOHz48KzzGRsbY3h4GIvFgq6qOHsmAGjLLjHH6LouShquYqWlpUiSZGaz9GYZwbKsjvmVlbtTimeMokuHeOTtH/LIq69RcKoeS08QdAkSJHrXpoKsY+0KUHJl5tesLMvY7XaGhobYt2/fksxdEARBEARBEARBuLfNO8jy7W9/m+eff56kpCS2bdvGa6+9RmlpKb/+9a/p65u5RIMgCNMrLS1FlmUCgQBqVCx6gvFjmdkavsAe2rWfJPqx3HNuLxs3dLNsXFZHM3CrbFwoU+B2H374IUNDQ9jt9hnLhMX0NJN70Thf06ZCxlIi98Xw+/1omkZlZSXl5eVzuo+nn36anJwcgsHgnHaIB1zxHH3yaSSbhjSgs2f/L9DnkDVht9uJjo4OC7JE97Vi6Q4AOlfXTc1i8fv9WK1Wtm/fPqd7WQ3y8/PZvXs3sizP/vW2WDny2ItIDg3csPvgryPu9gdjx78kSZw9e3bWsqB1dXUEAgEsFguJ3Y3ofhnJojOQZQRZVFVFkiRyc3PndY/CypGfn4/T6TTfp1ryjKw7e48PAouTESJ7xym4cpS97/yIx376KsWf1WLtChiBlTjoWp/JsS88y8df/gMu7H6JznXZABSfq41YxsxqtSLLMteuXZsxeC0IgiAIgiAIgiAIczXvIEsoqPLKK6/Q39/P2bNnzcDL5IbIgiDMTUZGBlFRUebC1UB6EgBZnbdK70iShKIo4f1YbvbSUFVV9GNZ5W4vG9eeZTSVjut2h43p7e2dUrqpurqampoaZFnGap0hMyXgY+ehj9E1iWC6hZoNj0Wcj6Zp+P1+kpKSePLJJ+d1H1/4whdISUnB7/fPqczUeEou5x/eBbKOo9XL5hOzN2cHpgSTqi6fAMCfaWciOTPsOU3TCAaDZGRk3HPByB07dlBSUoKqqrMGWnzxKZx/cBdIOlHN45RdOjjr+SeXVhoaGppxXEtLC7quI8sy2W21xvVS7Wa2VCgAc6/1Y7mfKIpCZmam+T41lF6I5NDQgxLpLdULdh3J7yG3+gQPv/djnvjpTyk9Xo2t0w+ahBQLPVVpHH/5KT7+yh9yecdzjCdnmcde3vIUepKEHpDYdei9iIFEu91OIBBg3759omyYIAiCIAiCIAiCcFfmHWQ5c+YMf/d3f8ezzz57z9cfF4SlkpmZia7rALRnFQEQ3TNmLhBFRUXhdDqNfizazX4sCUY/lmAwKPqx3AMml43rDpWNG5PM3diKouDz+WhsbDSPGRsbY//+/QQCgbAG8LfbdPJ9GALJpnHs4efNMnMzCTWUf/rpp+ddgs7pdPLFL36RmJiYOZWxAugtXEfDVmPxPeVaH4WXD83rmsrECPFNwwBUr9k45flAIIAsy2zcOPW5e8Hzzz9PcnLynAJbvYXr6Fxv7PYvOHuDhPbIGSqyLON0OhkdHY3Yn6WrqwtJkpBlmdQu4zXbPSmgpaoqsbGx4nPDKpefn48kSUZmkiIzmhEDQG5b5NfRrAJ+smtO8eAHr/DkKz+h4sgV7O0+dFVCcun0rUnhsxee4MMv/z4Xd73IWGretKeRLBaOP/wUkqJj6QlSfvHAjJcMlQ0bHh7mww8/vLv5Cya/38+RI0e4cOHCck9FEARBEARBEARhydxxT5aJiQlqamq4fPly2D9BEOYv1FBYVVV6c8qRFB3dIxE7EF7r/lY/lmjRj+UeE1Y2zulCv9lUOvvmDnGLxYKu6zQ0NJjHvPfee4yMjOBwOGYsE5bYcp2U6l4AqrevxxefEnEePp8PXdfZtGnTHZd2SkxM5IUXXsDpdDIxMTGnQMuNDXvprzTmVnKyhtSmuf8+Kb96HD1olA/qzl835flAIEB8fDyVlZVzv4lVxGaz8dJLLxEVFTWnwNblB57Gn2UDTWLbwYNYx90RxyuKgtVqpaura9rF6MHBQUZGRlAUBcnvxdofAKA91ygzFyp3mJWVNeVYYXVZs2YNVquVQODm9zinEIDEzsH5nyzgI7PuLHs+epWnXvkhaw5dxNnqQQ8aGwkGKpI4/dwjfPiVP+D8npcZySiYNUAMRnZc63ojCFNwoYGogc4Zx4bKhtXU1FBTUzP/exBMqqpy4sQJ/uVf/oWjR4+yf/9+enpmLtkmCIIgCIIgCIJwL5l3kKWvr49nnnmGmJgY1qxZw8aNG8P+CYIwf2VlZWaDe93mIJBslNjJbglf9An1Y+lON3aii34s946MjAyio6PNsnF96ckAZHYZgbZQX5aOjg4ATp8+TVNTk9mgfDqyd5ytRw+DLjGRF0Vr5c6Ic1BVlUAgQHp6Og8//PBd3U9+fj6PPvqo2aR+Ls7uegFvjgM0iU2fHsfVN3tDbT0YJKe2BYCm8uIpi7DBYBBJklizZg2Kosz/RlaJ1NRUHnvsMaxWKz6fL+JYSZE58ujnkVw6+oTEnv2/nrUXTqjfz5UrVzh//nzYczU1NWZGXWpbrZF94NAYSTaCdKF+LAUFBXd3k8Kyc7lcJCQkmO9T7QXrjKy7UYmo/pmDGaZggPQbF9i172c89dMfUnXwHFHN4+gBCcmpM1SWwJmnH+TDr/4BZx/6AkNZJXMKrNzu2uYn0FJk9KDEzkPvR3x9h8qG7d+/f87vVcItqqpy9uxZ/uVf/oVPP/0Ut9ttvg99+OGHcyobKQiCIAiCIAiCsNrN+y/XP/uzP8PtdnPq1CmcTicfffQRP/nJTygpKeGdd95ZjDkKwj0vISGB2NhYczGiNyMNgPTuW4tWk/uxdNzWjyUvb/rSKcLqMjlY1p5tlH+L6h43y8YpisLg4CBdXV0cO3YMVVUjZjBtP/oO+pixeHnioRdmvb7X68XpdPLcc88tSEBiw4YNbN26FUmS5rR4KSkKRx//MnqihO6X2f3x+1jHhiMek3PjHPq4hGTTqF8zNYjk9/txOp1s3br1Tm9j1Vi3bh1VVVXouj5roEWNiuWzRx5HUnSsXQE2nHp/1vPb7XZUVeXQoUN0dXWZj7e1GcEwRVHI7rgBwHi6y1wcDwaD2Gw2UdLwHpGbm2uWNlSdLtRk470it/nqtOP1YJDUxsvs2P8aT/30+6zffxpX4xi6X0ZyaLhL4jj31C4+/Nrvc3rvlxjMrbijwMpkkqJw/KGnkRQdpU+j8vwnM46VZRmHw4Hb7eajjz66q+veb65cucL3v/999u3bx+DgIFarFZfLhc1mw2q10tnZyZkzZ5Z7moIgCIIgCIIgCItu3n/FHjx4kG9/+9ts2bLFXNz92te+xre+9S3+5m/+ZjHmKAj3hVBfFk3TaM8uBcDe64OgUZYlUj+WkpKSZZu3sHBC5blUVaUvu9QoG+eTies1MjWsVit+v5833niDiYkJnE7njGXCsmrPENMwAsCF3TtQo2IjXtvr9SJJEjt27CA1NXXB7mnv3r1UVFSgadqsC/8Ams3Boae+gBRl9KR5+OPXITDzceXVVwDoL0pFtznDz6VpaJpGcXExTqdzusPvOU8++SSZmZlG2blZdpC7M4uo32qU9Eq/3En6jcg9FEL9WSYmJnj77bfNHjDd3d3m6zCp28i268jMMY9TVZWkpKT75ntwr5tc2hCgJ8sIDmd2tJtjdFUlueUa2w78gs+9+n/ZuO8zYm+MoPtkJJvGaFEsF57Yzodf+31OPvob9OevRVrgTLOJ5CyaNhnlzPIuNkfMjLNYLMiyTG1tLdeuXVvQedyL6uvr+eEPf8i7775LX18fiqKYwZUQu92Opml89tlnuN2RSxIKgiAIgiAIy8Pv99PV1SWyjwVhAUxfYyaC8fFxcwEuISGBvr4+SktLqaqqmlJCRBCEucvPz+fatWtomsZgeiGS7QC6Xyap8wYDuRUz9mNJSUkR/VjuEeXl5Xz66acEAgEUhwN/qg1rV4CcthquZRSYJcOGh4exWq0zZptYx4ao+uwsOjJDpQn0FK2PeF1VVQkGgxQUFLBt27YFv6/nn38et9tNe3s7sixjtVojjvfHJnL8iSfZ9f7HyH0auw+8ztHH/82U3e2xXU0ovSpIOlfX7Z5yHp/Ph9VqZfv27Qt6PyuZoii89NJL/OQnP2FkZISoqKgZA3EADesfJq2nk5jGUTYcOcmhpEy8CWkRz2+32xkYGOCtt95ix44dTExMoCgKysQI0qAGSHTmrgGMQJckSaIfyz0kNzeXqKgoxsfHAWjJW0PmxQ5svX6Sm69S0HSdpLYB9AkJAB0Zyaoxmh1DY2ElXQVVYDHeA6RFnmvNhkfJaf0RSo/KjkMfse+l30Gaobyi3W5nYmKCgwcPUlhYKIKC02hububIkSN0dHSgqipWqzViTzCn08n4+DgfffQRX/7yl5d4toIgCIIgCAIYf+/39vbS09PDwMAAw8PDjIyMMDIygs/nQ1VVnE4neXl5VFRUUFJSck+X2haExTLvIEtZWRm1tbXk5+ezfv16/uVf/oX8/Hy+973vib4QgnAXysrK2LdvH4FAAIvTiTfVib3dR3Z7PQO5FTP2Y8nMzFy2OQsLKy4ujri4OAYHjSbSPenpZHe1kdbVxTWMTAJFUdB1HbvdPu05dFVj16dvo3tlpFg4u/v5iNfUNA2Px4PL5eLZZ59dlA9TiqLw5S9/mR//+McMDAyY9xHJaHoBlx7cyrqDp4luHmf96fe5vOO5sDFVV04A4M12TgkMaJqGqqrk5uYuaGbOahAXF8fTTz/NG2+8gcfjITo6OuL4zx5+mSeGfoI+JPPgJ2+z76XfBuv0ry8wMqpUVeXGjRuMj4+jaRp2u52sxvOAhBQL3vgU4FZPnKKiooW8RWEZKYpCZmYmtbW1ALhT85CcOrpHYvNHxwHQkZAsOuNZ0TQWltNRuC7ia2qxSIrCsYef4+Ffv4k8oFF17mOubntm2rGTy4a99957fPGLX1zi2a5cXV1dHDp0iNbWVuMzisUyawAXjNeKxWKhsbGRK1euUFVVtUQzFgRBEARBuL+oqsrg4CDd3d1TAikej4dgMGiuIQHouo4sy+a/iYkJrl27xvXr14mOjiY/P5+1a9eSn58vAi6CMEfzDrL86Z/+qVmL/S//8i956qmn+NnPfobNZuPHP/7xQs9PEO4bTqeThIQEenp6AOjKyCK/vZGU7l4kv+dmPxZJ9GO5x2VmZjIwMICmabTllpF9oQ1bn98omWW1z7q7uvjqEewdPpB1Tj70GJrNEXG8z+dDURQefvhh4uLiFvJWwjidTr7whS/ws5/9jLGxsTkt0HWVbCJ2ZID8M41kXOpkJOYYzWuNjBXr2BAxLaPoSFxbs3nKsYFAAFmW2bRp06Lcz0pXXFzMtm3bOH78OF6vF4dj5teBbnNw9LHnePDtt2FQZvuRNzn56G9EPL/D4WB8fJze3l7zA3pWRzMAQ2nx5rhgMIjdbhdN7+8xeXl51NXVEQwGsVgsDOQmkVg7iKToeLKcNBaU0V60AX2W95+l4E1Io2FzKYWn6sm+1EZLfjOjafnTjrVYLFgsFm7cuMHly5dZt27d0k52henv7+fw4cM0NDTg9/vnHFyZzGazMTExwaFDh+6r0o2CIAiCIAgLTVVVRkZG6Onpob+/n6GhIdxuNyMjI4yPj6Oqqln2S9d1ACRJMgMpNpvN/P/T0TSNYDDI2NgYV65cobq6GpfLRUFBgRlwEQRhZvMOsnzta18z/3vz5s20tLRQU1NDbm4uycnJCzo5QbjfZGVl0dPTY/Rlya0g/0wjSn+QzMYrYf1YJEQ/lntVQUEBV69eRdM03Kn5SHYN3SeT0lFPX/7aiMc6BrooOVODjkRXVRbDWZEbjQeDQVRVpaysjA0bNizgXUwvJSWF5557zuwpM5fFutrNjxM38ksSaocoP3GVkZgkBvMqqLhyHF2VIAH6ciqnlB0KBAIkJydTWlq6eDe0wu3evZuuri5u3LhBIBCIWKZtIimTy7sfoOrgOeLq3RSkHqWpak/E84f6s1hull+K63ajI9GedSugomkaaWlpYvfTPaayspJDhw6ZWQ1ndr9AUlEDw6l5qI6o5Z7eFHXrHiantRlrV4Adh/ex7+XfMUuW3S4UFPj0008pLCzE5XIt8WyXn9vt5vDhw9TW1pqB+PkGV0JCGUIjIyN88sknPP985OxKQRAEQRCE+93Y2Bjd3d309fUxNDTEyMgIw8PDjI+PEwgEzN6jIZMDKXa73fzv+QoFYmw2G5qmEQgEGBkZ4eLFi1y5coW4uDgKCgqoqqoiOzt7IW9ZEO4J8wqyBAIBysvLee+996ioqAAgKirqvt0pLAgLrbCwkIsXLxq7BxIzjebfExJrLl8EYDxF9GO515WUlGCz2cyycRNp0ThbPWS3Rw6y6KrK7kPvoQcltCSZyw88FfE6mqbh9XqJj4/n2WefXejbmFFRURF79+7lwIEDeL1eoqJmX5A9tedlHhn9KbZOP1sPHuLoszFk1rWjI1FfUTalV0uoRFVVVdV9vbivKAovvPACP/rRjxgcHERRlIgftjtLt5De00rKtT7KTl5jICWHkfT8GcfLsmwuQDsHu9HHJJB0uvMqgVv9WMQH8HuPy+UiKSnJzGzGamMgt2J5JxWBpMiceOg5Hv71r2BQZv3pD7m0c/rFflmWcTqdjI2N8f77799XvUQ8Hg+HDx/m2rVreDweZFm+4+DKZBaLhUAgwPXr16mqqhKZbYIgCIIgCBhN56urq+np6cHtdpuBFJ/PN2MgRZIksz/r3X5GiyQUsLHb7WbAZWhoiKGhIS5dukR8fDwFBQVs2LCBtLSZe3oKwv1kXkEWq9WK1+tdrLkIwn2vsLDQXGC32WyMprlwNY0jDRqpnt3pRvNo0Y/l3uV0OklMTDQXL7sysilsrSe5uz/icVVnP0bp05AsOsf3Pj3jLu0Qr9eL1WrliSeeWPLyLVu2bGF4eJjTp0/PWsoKQLJYOPzEl3j8rVfRh2X2vPMuekBGsms0VuycMt7n8xEVFcUDDzywWLewajidTl588UVee+21OWUPndvxPI/1/wRLT5CdBz7ik5d/E9UZuacLQHbrdQD0RAXVaQReQiXb7udsontZTk4O3d3daJq2qH/gLRRvfAp1D1RScqKG9KudNBU0MJIxfa8gRVFQFIXGxkbOnz9/z28m8vv9HD16lMuXLzMxMQEY7x0LGaS22+1MTEywb98+fu/3fu++DoALgiAIgnD/CpXiamxspLOzE7/fDxjlvSRJMoMpoTK2K+Fz9u0BF7/fT39/PwMDA1y4cIHExESKiopYv369qHAk3Nfm/dP69a9/nW9+85sEg8HFmI8g3NdsNhupqalmHc3OzPB+Kx05oh/L/SAzMxNJkoyycTezAuQBFdkzNu342K4msi61AtC4uYSJ5KyI5/f7/ei6ztq1a5dtAXzv3r2UlJSgqio+n2/W8ZojmkNPvWQ02A4Yv7p6StLBGp7JFQpAlpaWiiyvmzIzM3nooYdQFGXWr7VksXDksc8bX+dRid0Hf4WuahGPAcjobAOgL/3Wh2pVVYmKihI7m+5R5eXlyLJMIBBY7qmgaRo+n88soTCThjV78GfZQJPYcXi/0etqBjabDVVVOXLkCG63ezGmvexUVeXYsWN873vf4+TJk0xMTOBwOIiOjl7wIEio/ER/fz+ffvrpgp5bEARBEARhJevr6+PTTz/lhz/8Id/97nc5ePAgTU1NBINBbDYbTqcTl8tFdHQ0UVFROBwObDbbigiw3C5UCtblcpmbNXt7ezl58iQ/+MEP+P73v8+hQ4fu2c/PghDJvHuynDlzhgMHDrBv3z6qqqqIjg7f4frGG28s2OQE4X6UlZVFW1sbmqbRkbeG0uPVAEhOnfGEDNGP5T5QVFTEhQsXCAaDeBLTkVw6+phERut1Ospuy84I+NlxeB9oEv5MK7Xr9k7pTzJZaOdJSkoKjz/++KLeRyShUlavvvoqnZ2dKIpi9vaYiS8+lZOPPcb2D/cDUD1NzxCfz4fVamXHjh2LMu/VasuWLXR0dHD16lX8fn/EAFQgJp4zex9iy0eHcbR5WXPuY6q3fm7G8bqqEtUzjo5Me/atPkCappGZmSl2rN+jsrKyiIqKYmxsDLvdvuTXD5UtCG36Cf3B5/F4ZiyfICkyxx96gUd+9Qv0YZmNpz7gwu6Xpj3/5LJhH3zwAV/5ylcW9X6WkqqqnDt3jjNnzjA8PIyu6zgcjlnfg+9WKFP3woULVFVViQCsIAiCIAj3JFVV6ejooLq6mpaWFoaGhlBVFV3XURQFh8NxT/yNFPr8DcY9BwIBuru76enp4fTp06SkpFBcXMzGjRvvyz6Hwv1n3n9NxcfH8/nPf34x5iIIAsYC++nTp41SO7GJEAe4YTxV9GO5XxQVFWG3283UYXd6HLE3RsjuaJoSZNly4l0YBsmucfyhF6b0J7mdx+PBbrfz9NNPL/vrx2az8aUvfYmf/OQnDA0Nzak8zXBWMYdeikbRVHxx4anImqahqir5+fkkJiYu5tRXpWeffZa+vj66u7vNckgzGcitoGVjK3nnmsm50EJv6lX6Z+gJFNfbjO6TkRSdvmwjM0pVVSRJIicnZ1HuRVh+iqKQlZVFTU3NkpUMmxxYCf2RGhcXR2FhIVVVVQSDQV5//fWI/Z78sYnUbK2i7Ng1Uq/1EJ9fx3D29Bl9oeBvU1MTZ8+eZcuWLYt5e4tOVVWuXbvGZ599Rn9/P7qum81Nl4rT6WRiYoIPPviA3/qt37onFhgEQRAEQRBUVaW+vp7a2lpaW1sZGxtD0zR0XcdisdwzgZWZTP77MhRw6ejooLOzk88++4z09HRKSkrYsGHDkpcrF4SlMu8gy49+9KPFmIcgCDfl5OSYu3EB2otyyT7fyo3iNYDox3I/UBSF1NRUWlpaAOjIzCf2xmXiu4fCxqU0XyXpeh8gcW37RvxxSRHPGyoVtXnz5hWz+O1yuXj55Zf5+c9/zvj4+JyaLHuTMqZ9PBAIoCjKql8IXSyKovDyyy/zyiuvMDY2NuvX+vqmx0ntexVnq4cth45y8OVM/LFTg1c5rbUA+FNtYDUyGkLfi7KyssW5GWFFKCgooLa2dlGDLNMFVmJjYykoKGDNmjXk5uaG/cG6bt06zp07FzFjq3ntbvJaGnC0edl25FM+/mL+lNKDITabjYmJCY4ePUpJSQlxcXGLcZuLrqamhmPHjtHb24umaUseXAmRZRmr1UpXVxenT58WWYeCIAiCIKxafr+fq1ev0tDQQHt7Ox6PB03TkCQJi8WC3W5fkSW/FtvtARe/309rayttbW0cO3aMzMxMSkpKqKqqEgGXFSAUILx+/TpdXV3s3buXioqK5Z7WqrS4dQEEQZg3RVFIT0+noaEBgKubn6R6gw/dZvzyEf1Y7g9ZWVm0traiaRpdeZVUcAlGJOzufnxxycieMTYfPYaOxHhBNG0V2yOeL7SbJNSfYyXJyMjgmWee4e2338bj8eB0Ou/ow2ggECA1NVWU0YsgMTGRJ554gnfffTfibn8wSisde+TzPPHGq+gjMg/uf4P9z/82WKxh49K6uwHoSU83H1NVlYSEBBISEhbnRoQVobKykoMHDxIIBBa01JSmaQSDQQKBALquI8syLpeL/Px81q5dS35+/ow7AR9//HFaWlro6+uL2Cz0xEPP8+jrP0cfkdl84l3OPTR9lnaobNj4+DjvvvsuX/va1xbsPpdCU1MTR44cobOzE1VVsVqtOByORfmDP6q/g81nDhLdOU7d1koaqx6cdpzdbmd8fJyTJ09SWVm5agNXgiAIgiDcf8bGxrh8+TKNjY10dXWZ/U5XWrP6lUJRFDOQEgq4NDU10dzczOHDh8nOzqasrIy1a9cue6WN+4mqqjQ0NHDt2jVaW1sZHx83N3T39vaKIMsdmtNfxBs3bkSSIlX5v+X8+fN3NSFBEIxslsbGRlRVRVEUdOVWdF/0Y7k/lJSUcOrUKaNsXHQceoKMNKST1XKNxnUPsePI2+jjElKUzokHX4x4Lk3TzAX15557bkWmKZeWlrJnzx4+/fTTWRf/pxMIBJAkiXXr1i3SDO8dlZWVdHZ2curUKbxer1lHdzqaI5pjjz3F7nc+ROlV2Xz8nfDF6IAPW68fHYm2XCNrJZQWL7Lt7n1Op5OkpCQ6Ozvv+lyhwEowGDQzY1wuF7m5uaxZs4aioqI5vXcpisLnPvc5fvGLX0R8Lwm4Eri2fROVhy+SXNNHUsF1BnKn/2MiVDastbWVU6dOsW3btru616XQ2dnJoUOHaGtrM4Ngc8kUvBP24T42nd1PbIMbdAkdidLT1XTmVOCNT5n2GIfDwfj4OB9++CG/8Ru/seBzEgRBEARBWCh9fX1cuXKF5uZm+vv7zY1AiqJgs9lm7AcohJsccAltqGpoaKCxsZEDBw6Yn7kVRcFqtWKxWLDZbGbwKvT1tlgsWK1WMzPbarVit9ux2WzY7XYcDgc2mw2n0ykCN5PMFFiRJMn8ek9MTCz3NFe1OQVZXnzxRfO/vV4v3/3ud6msrDRT/E+ePMm1a9f44z/+40WZpCDcb0pLSzl27JhZcmcy0Y/l/pCZmUlUVBTj4+MADKQnkTzUT2ZnG37bKVxNY4DOuT270JyRm8j5/X4kSWLnzp2kpEy/4LUSbN++naGhIc6fPz/r4v/t/H4/LpeLTZs2LeIM7x179+6lq6uLlpYWgsFgxCyEsdQ8ru+oovzoVZKv95Oddor2cmOROaW9Dl2VkOwa7tR8JDA/qOXn5y/NzQjLKi8vj66urjsqGTZdYMXpdJKbm0tFRQVlZWV3FBTOzc1l/fr1nD17NmLZsLaKbeQ31xHVMsEDRw+z74sFaLbp33dCQYHjx49TUlKyYvs+tbe3c+LECZqbm/H7/YsaXLGODbP+3H6S6/rRVQmQCKZbsfgC6EMS24++z6Hn/u20x07ud3PlyhWqqqoWfH6CIAiCIEzP7Xab2ciSJCFJErIsT/nv2/9XkiTzs5ksy+a/0Jjbx4UeDwUhJv//0Jjo6GiioqLm1J9zqaiqSltbG9evX6e1tfWebVy/nEKBE8AsDRwMBvF6vei6bo4L/Xdo47+u60iSFDYm9FzotTf5v0Ovu9sDOJODN6F/LpeLnJwc8vPz75n1tlBgpbq6mpaWlmkDKyJAuHDmFGT5y7/8S/O/f+/3fo//8B/+A//f//f/TRnT1ta2sLMThPtUamoqLpcLt9sd9rjox3L/CJWNq6+vB6Ajq4jk6/24ukdZ23UeHZnB8mT6CiIvTKmqSjAYpLCwkO3bI5cUWwmeeOIJhoeHaWxsjLg4OpmqqgCUlZXdMx+GFpuiKLz00kv8+Mc/Znh4eNZF2JY1u0jr6SChboi1xy8wmJzNRHIW2e03AJhIi0a6+YdGIBDAarWKfiz3ibKyMk6fPk0gEMBut8/pmEAgQCAQMD/gO51OcnJyKC8vp7KyckH+aH300Udpbm6mt7d3lrJhL/D4L3+GPiqz5fg7nN77pRnP6XA4mJiY4L333uOrX/3qivnjuq+vjwsXLtDY2GguAiiKsmjBFcUzztoLB8i43okeMDJXtCSZi1u201dQRWxXEzve+Rh7h4+c6ydnLGcZ6ndz6NAhiouLRU1uQRAEQVgCvb29vP766wwNDc1YsWbyAnbIdGOnGzfT2Jmem7wYHloAD2UmhLITJv9/h8OBw+HA6XTidDqJjo7G5XKZGSV3SlVV6urqqK2tpa2tzWxcD7cyMMRi9OIIfc/nK/T90XUdXden/H9d183gmN/vN5+b/L+AGbSRJIlTp05htVqJj48nLS2N7OxsioqKVlV5WxFYWT7zLqD9+uuvc/bs2SmPf+1rX2PLli388Ic/XJCJCcL9Lj09neHh4bDHRD+W+0tOTg719fWoqkpvbjmSfBLde/OXYRyc2fV8xOM1TcPj8RATE8MzzzyzBDO+e4qi8PnPf56f/OQn9PT0mLVtIwkFY0QD5flxuVw8++yzvP7663PqhXP6wZd4fPDHyP0ae/a/xycv/zYp3f0AdGXmmONC2XZiwfT+kJGRgcvlYmRkJGKQJVQSQFVVJEnC4XCYNZgrKysXPECqKApPP/00r732Gh6Ph+jo6GnHqVGxXN75AFUHz5FQO0hKwVX68tfOeE6LxUJ7ezsnT55k165dCzrn+XC73Vy4cIH6+noGBwcJBoPour6omSuS30vFxU/JvdaM7pPRkSAerm7cRHvxZiTFuOZIRgH9FakkV/ex5tQFOvPXok6TcSnLMg6Hg5GREfbt28cLL7yw4HMWBEEQBOGWtrY23njjDUZHR3E4HAvSUy+0sD3ZdMGX27MTJi92hxbIVVXF5/OFPTc5gyHk9myFuwnSDA4O3leN63VVwzE6QNxQF/HDfcS5h9BkmcbCtQxmFJuf51aDhf7eTM6y7+npoaenhytXrqAoCi6Xi7S0NDIyMsjPzycjI2PFbLgC42/wxsZGrl27JgIry2je76hOp9MslTDZ8ePH51XaRRCEyHJzc6mtrTV3pILox3K/KS8v58iRI0bZOIeDYIoFpUcFWeezhx8Ha+RFSZ/Ph6IoPPLII6tq54XNZuNLX/oSP/3pTxkeHo6YOh76MF5YWLiq7nGlyM/PZ9euXRw6dAi/3x/597jFytHHXuThN3+FPiyz55NfIA2qgERbXiVwq1RYVlbW0tyAsOwURSErKwu32z2lZNjtgRW73U5+fv6SNbfMzs5m06ZNnDx5Ep/PN2MQqLN0CwVNtbiaxth87BifpBeiOqbv5RIqG3by5ElKS0uXtARjqNFqXV0dvb29Zj1wi8WyuLsrgwFKrhyl6Eod+oSEjozk0qnZsJamih1IisLt+1XPb3+aJ1t/jD4ms/X4u3z22FemPbXFYiEQCFBTU8PatWspKipanHsQBEEQhPvcjRs3eOedd5iYmFjQ0lxLvXAb6v8YCszMJ0gzOWMh9C90jnutcb113E3sQCdxwz3EuweJGRnFMepFGtPRg1MzjZKrP0VyHaQvN5X6ko24U/NWVcBlIciyHPb3iaZpZuDF7XYzPDxMXV0dR48exeFwkJycTGpqKnl5eRQWFi55VY3JgZXW1lYz+yoUJHQ4HPfEa3k1mXeQ5c/+7M/4oz/6I86fP8/WrVsBOHXqFD/84Q/57//9vy/4BAXhflVWVsann34a1pdFVVWSk5NFSaT7RGJiIjExMWZGU2NRCSW912nZWMBIRuSFqFCPg4qKilVZ6z4uLo4XX3yRX/7yl0xMTMy4M9vv96Moivn7SJi/nTt30tHRQV1d3awl2rzxKVx4cCcb9n+Go80LSEguHW9CGmC87iRJEgul95nCwkKuX79u/pHq9/vNwIrNZiM3N5eSkhKqqqqWPMPp4Ycfpqmpie7ubqxW64x/aJx88AUe73kVfUzigePvcPLRmZuxOxwOPB4P77//Pr/5m7+5qLvY/H4/ly9fpra2ls7OTvx+/5LVA9dVlbzaU1ReuIw+apQFk5w6jetKqKt6ECzWKcEV81ibg/O7drLx48+IvTFCcvFV+mfIELLb7UxMTPDJJ5+Qn5+/onYFCoIgCMK94Nq1a3z44Yd4vd4V1fvkTtzNovF05aVCnw9X42K07B0ndqCL+KFu4kYGiR1x4xz1II+q6P7p70dHAklHioaAy8ZYbDQOjxdnpwd9TCK5uo/k6n1IsdCdl0596UbGU3KX+M5WhtDrYnLGl6ZpBAIBPB4PLS0ttLS0cO7cOaxWK3FxcWaJseLi4kXZBBoKrIRKgYnAysoy7yDLN77xDQoLC/nHf/xHXn31VQAqKir40Y9+xJe+NHMda0EQ5icuLo74+Hj6+41yPKIfy/0pMzOToaEhNE2jcd1DNFbsmDWDRdM0vF4vCQkJfO5zn1uimS687OxsnnzySd5///0Zy1kFg0HS09MpKChYplneG1544QV+9KMf0dfXh6IoEf/w6ilaT1dvGxmXOgBwp9/68KiqKna7XQRZ7jNlZWV88skneDwecwdYdnY2JSUlrF+/fllLxymKwjPPPMPPfvazyGXDnC4u7tzG+v2niat3k5Z/kZ6iDTOe02q10tHRwfHjx3nwwQcXdM6qqlJdXc3169dpa2szG4AuVaNVXdXIbLzAunNnYdj4Y1yyabStyaN64yPotrllrvcWrGOs8AquxjG2HD/GR1ml0/7+Cr1mBgYGOHDgAE888cQC35EgCIIg3L/Onj3Lp59+is/nW7SSoqvFqrz3gJ+YwU7iB3uIc/cTNzKMc3QCy2jwVinx2+gYj0tOnWCMhYmYaNyxcbjjkhlKSmc8Pg2s4RneineCnBvnKWiqx9blQx+RSLvSTdqVDyEeOvOzqC/ZjDcpY7HveEWTZTksO35yibG+vj56e3u5evWqWWIsNTXVXK/IzMy8o8/xqqrS1NQUVgostKFNBFZWljsqwPilL31JBFQEYQlkZmbS19dnpr5KkkRu7v25i+B+lZeXR3V19a0yPLMEWAC8Xi82m40nn3xy1ffFWLNmDUNDQxw9ehSfzxd2P36/H0mS2LBhw/JN8B5hs9l46aWXePXVVyNmDoVc2vo5Egd+ir3dR0PRGvNxVVVJTU1d1bvjhPlzOp0UFxczMjJCSUkJ69atw+Wa2oNjuWRkZLBlyxaOHz8esWxYd/FGCppriL0xwsbjJ9mXWYw2TS8RMLIvgsEgp0+fpqysjLS0tLuaY6hB5dWrV2lpaTFrgof+kFuImulzkdx8lY3nPkPuMzZ2SBad7op0Lm96bMavRSQndz/H450/Qx+V2XjqAy7sfnHacTabjWAwyKVLl6iqqiIj4/7+A14QBEEQFsLRo0c5ceIEwWDwvg+wrGjBAFHDvUZGynAfcSPDRI+MYx0LoI8D0+QOm4EUu4YaY8ET42QkNg53XBJDCWmMJmWi2+a+FqA6omheu5vmtbtRPGPk1Z8lv6kRa7cfhiUyL3aQebEDPVGiPT+HxtIteOOXrmzuSjVdiTFd1wkEAmaJsfr6eo4fP47dbic5OZm0tDRyc3MpKiqasYrEbIGVe7Ff0L1A0qfrSHWfGRkZIS4uDrfbTWxs7HJPRxBMV65c4Z133jEXHywWC3/yJ3+y6hfOhbkbGxvju9/9Lpqmzanvld/vJxAIsGnTplWdxXK79957j0uXLpk7uQHGx8eJiYnh61//uljUXyAXL17k448/RtO0Wd9ndFXDPj6MPzYRMD5QejweduzYwSOPPLIU0xWEOVNVlZ/85Cd0dnZGXGSQveM88fpP0cclRgtjOPHEv5nxnJqmMTExQWZmJr/92799R+9Dzc3NXLlyhaamJjPdfzlqgsd13GDz2SNYuwIASLLOQEkSFx94jIAr4a7OnVt9goojV4x+Ys8/xUh6/rTjFuLrKQiCIAiCYd++fZw7d878XC8WZFeQgJ/M5ivkN9cS2ztiBFK0mYqwgmTV0Vwy3hgHo7GxuOMSGUpIYyQxAzVqcdcwrWPDFNSfI7epCaUvCHponjpaikJrfj5NJZvNvwmFqUIlxlRVNUt7hRrSx8bGkpaWRmZmJsXFxQwODlJdXU1zc/OUwEqk0scLZWxsjD179vDQQw8t6nVWm7nGDZZmW5wgCHekrKzMDLCE+rGIAMv9xeVyER8fT29v76xjNU3D7/eTkpJyz5Vb+dznPofb7aapqcnswwJQXl4uFuIW0IYNG+js7OTChQsRd/wDSIoc9mE6EAggyzIlJSVLMVVBmBdFUXj22Wf56U9/GrFsmOaI5vxuo5dITOMoGfXn6CrZPO1YWZaxWq10dXVx5MgR9u7dO6e59PT0cOHCBRobG3G73cua7u/qa2PzmYM4Wr3GA5LOaGEs5x54DF986oJco6VsO0U3arF1+tl29BP2vfy7SNO8b0/+ep46dYqdO3cuyPUFQRAE4X6iqirvv/8+V69eBRABlhVC8YyRc+MCea2NOLs8ZvN5/WaWiqTo6C4JX4yd0ZgY3HGJDMenMJKYiS86ftma0Adc8dRtfJS6jWBzD1BYd5acllbkfg25TyO/r5H8sw0EU6205hfQWLZl0QM/q02kEmP9/f309fVx7do1Dh48iK7rImNlFRNBFkFYwWw2G0lJSXR2dgKiH8v9Kjs7m97e3lslw2bg8Xiw2+0888wz91zgQVEUXn75ZV555RX6+vrMhtpiEW7hPfnkk/T09NDR0YHFYpnza0lVVaKjo8X7lLBipaamsnXrVo4cORIxiNhbsI7h0hri64ZYf+IMvVklM/6xGCobdvbsWcrLy2csczU4OMiFCxdoaGhgcHCQYDC4rH88OYZ62HxmP66mUXNHoifXybmtjzKenLWg15IUmc/2PM3Dv34TeUCj/OIBajdPvxEg9PU8efIka9asWZSGoYIgCIJwr1JVlV//+tfU19cjy7LYoLnMHMN95DVcJLutFUtvwMxW0ZGQnDrurDhac4oZSM3FE5s87SYUmK5Y2PLwxyVR88CT1DxgfJYsrjtHZnM70hBYeoIU9tRTeKYOf7qNlvwiWkq2oDqn39h0P7u9xBgYP7uhTYsisLJ6iSCLIKxwWVlZdHZ2in4s97GCggIuXrxIMBicsWanz+cD4IEHHiA7O3spp7dknE4nX/ziF3n11Vdxu90UFBSsqL4P94pQQOvHP/4xo6Ojc67frGka6enp91yAT7i37Ny5k4aGBtrb2yMGEU/vfo4nO3+CPiax48g7HHvqazOe0+l0MjExwXvvvcfv/u7vmuccGxvj4sWL1NXV0dfXRzAYRNd1LBbLstVFt44Os/HsPhLrB9E1CZDwZ1o5v+Uh3JlFi3Zdb0IazesLyDvXTMGFRpqLemfMlHE4HExMTPDBBx/wla98ZdHmJAiCIAj3Er/fzy9+8QtaW1vDSiwLS0dXNWIH2ihouEx6WxfS4OTuDBJSLPRlJ9OUv4aBrJKwoMpKCaTMlTchjavbnubqNojq76C4/jwZzZ3glrB1BijprKH01HW8GQ4aC0tpK944rx4x9xtFUcTf0feAeQVZAoEA5eXlvPfee1RUVCzWnARBmKSoqIhz585htVopLi5e7ukIy6CoqAir1UowGJz2+dCuh+zsbPbs2bPEs1taiYmJPP/88xw8eFBksSyiuLg4nn76ad58882IpZVCVFUFICcnZymmJwh3LFQ27JVXXon42tZtTs7seZAtHx0hunmcrJrTdJRvnXZsaDdab28v+/fvJyEhgdraWrq7u/H7/WZgxeFwLNsfT7JnjPXnPiGtpgc9KKEjoaXIXNiyk/68NUsyh+sbHyW3+YcwADuPvs/Bp3972tIXiqJgsVhobm7m8uXLrFu3bknmJwiCIAirlcfj4bXXXqOrq8vMkhWWhq6qJLXXUdh8jeT2fvTRyeESHT1JoSsng8aidYyn3No0u9qCKpFMJGdxOTmLyzsgpqeZ4voLpLX0oI9K2Nt9VLRfofLEZSYyo2goLKejaANYp988KiwPXdVI6G5kXeMVtB3bl3s6q9a8gixWqxWv17tYcxEEYRoFBQU4HA5iYmJEuu99ymazkZqaSltb25TnQs3Go6KiePbZZ++L3Q/5+fn87u/+7nJP455XUlLC1q1bOXHiBF6vN+JuuEAggMVioby8fAlnKAh3Jjk5me3bt3Po0KGIr+2BvEoGy6pJrBmg6uQ5erNLCbjipx1rs9kIBAKcP38eTdPQdd3cRbqc78uy30vlhQNkX2tF98tG3e8Eicubt9BZsGFJ63tLFguf7Xmcne98jK3DT17tKVord0w71mazMTExwaFDhygpKRGffwRBEARhBm63m5///Of09/djtVpnrHwgLKDJjes73Ohe4/OUjgSyTiDNRntOLi1FG/DFJS/zZJfWaFo+F9Ly0XdoxHc3UnLjEsmtfejjEs5WD2tbL1B1/Dxj2S4aCivpKqgCi3W5p31f0lXje1TccImU1j70MSP013bqIDz62DLPbnWad7mwr3/963zzm9/k+9//PhaLqDYmCItNURQ2b95MbKxoHnY/y87Opr29fUpfFr/fjyzL7N69m+Tk++sDnLD49uzZQ1dXFw0NDQQCAazW6T8Aq6pKfHw8iYmJSzxDQbgz27Zto6GhgZaWFlRVnTEQcnbns0bZsBGZHUfe4cjTvzXjOZ1OJ36/H7vdvvyfkYMBSi8fpvDKDXSPhI6MFKNTvXE9LWXbkBR5WXZQjqYX0FeRSsq1PipPX6Qjf820/W5kWcbhcDA6OsrHH3/Miy++uPSTFQRBEIQVrq+vj1/+8pcMDQ1hs9lEgGURzdy4Xkay6kxkRNGSV0Rb4Xo0pyhpLSky7qxizmYVo6saSR21FN+4QmLbILpHIrppnHVNZ1hvO8VITjy9Ken4bXaCFhsBq52A1U7QZidgcxK0OVCtdrCKDK27dSuwcpmU1l4zsKIjISk6nnQHOKKWeZarl6Truj77sFteeuklDhw4gMvloqqqakqZhTfeeGNBJ7gURkZGiIuLw+12i4VsQRBWpKamJn7+85+bjdDAWNj2eDwUFRWJuvXCovF4PPzoRz9icHBw2j4SmqYxMTHBmjVreOmll5ZploIwf0NDQ/zoRz9iYmIiYo+UhPZatr7/KegSNQ9W0VK5cksV6qpKYfUJyi5dM/9okqJ0bqwr48ba3Yu+U1BVVbxeb8Rmu5Lfy5Ov/xh9VGK0KIYTj/+bGc/n8XiQZZnPf/7zomSqIAiCIEzS3t7Or3/9a0ZHR3E4HPPa4KGrGhbfGEgKuqKgSRK6pIAkL2mW60o3U+N6wGxc35xfRlfeGhEAmCNdVUltraa44SpxbcPovnm83mQdSdHBIoEFdIuEZpFRLQqaIhO0WIx/VgtBi5WgxYrfaiNosZqBm4DVTtBqJ2BzELQ6UG0Ogrb/v707j46jvtP9/1Sv2lu2VhtJtrxbeMMyXiB4CV7YMSEsGX43QBIyJxdykpBMZsg9CTf3ZoZM5mYmkzvJkDtskzAEQgjELDaLwXbAxnjBYGy8y7s2y1Zr67Wqfn/I3ZZkyUhlrfb7dU6nu6uqq7/dJiWpnvp8vint5se50NimpezqCo3b91G7YEWSDLet8IgUHRw9TofHXaaGuK2rrrpKCxYsGMARDz7dzQ16fJlddna2br311vMaHACgZ0pKSpSSkqJQKCTpTJuwzMxM3XjjjQM8OlzIUlNTddNNN+m5557r9GS0ZVkyDEOjRo0awFECPTds2DBdeeWVWr16taLRaJdtw04VTVRt2Q7l7ajV5I0fqbJokqJZg6tqy19fq3F7Nqto/2EpePpqNL+lQ1NK9emMz/d532vTNBWJRGTbtlJSUhQOhxWNRju9otb2pWjLlZ/TzFXvKXN/o/LHfaya0s7nXfH7/WppadFbb72l0tLSi6IlJgAAn2X//v1asWKFmpublZqa2qOfj2l1x3XVGy9LwS42MGwZhlonDTEkuewzjw2jzWNJLkN2m3W2IdmGIbla723DaLfcdhnJ5bZhKO71KOr1Ker3K+JLUdSXoog/TRF/qiKp6Yr5MxRNzei3+TvOZ+J6dI/hdqu2dKpqS6dK8ZgKD36iMRW7lNISkjtuyhW3ZMRtKS4pbrdWDNmnQwHLkG0ZUuzM/lyy5JIlSfIrch7jsmUFXKrPy1ZVQbGqLpmgaCDnPD7pwEoEK2P3f6T8Q2dXrIQLU3SwdJyOjL1MZmqb4ommpgEa8YWhxyHLk08+2RfjAACcg9vtVkFBgQ4cOCBJikQi8nq9Wrx4sTIyKEdG3yoqKtJVV12l1atXKxKJtLtCPR6Py+v1asKECQM4QsCZOXPmaN++faqoqDhn27Ctc6/XsqNPyQ66dMW6FXrn2i8P+JWe3uagSvdsVklFhdw1cSWmUDW8tionj9T2mVfLSkk/907Ok2VZCofDyXBl8uTJmj9/vp5++mmdOHFCHo+n0wqh2tFT1Dj2Y2Xub9TM9ev1+iUTZPvODrlcLpd8Pp/q6ur01ltvadmyZX36eQAAGOx27NihVatWKRQK9Thgyayq0JWrViXnEOmUbah9v5vuNhi1T2cvPWqW0y2G25a8tuRzyfK6FPe5Ffd6FPN5FfX5FPW1hjQRf6qi/lSFU9IV9acrmpKhWErqOatMmLh+AHm8qhp3marGXXbu7WIRuWMReaJheaMheaIReWMReeNReWIR+aIReeKx089j8sZj8sTj8sRNueNxueKW3HFLRiLAMW0pbsiOS4l/Sds0ZJy0NezkKQ3bfUqT9bGMdFvNuemqyS9U5chxCuaXDOpgzTYtBWpaK1byD9ck/1u2Zchw2YqM8Kti9DgdGTezfbCCXuOoYXQ8HteaNWu0f/9+/dVf/ZUyMzN1/PhxZWVlcbIPAPpIcXGxKioqFI1GZVmWJk+erEsvvXSgh4WLxOzZs3X8+HHt2LGj3RXq8Xhc+fn5/PzHkHXDDTfoySefVFNTU9dtw7x+vT//as195S35j0Y0Zud7qph6Vb+P1R1uUfHeLSqt2CtfVbRN2wpDVq5LR0aP0v7JcxRLD/TpOCzLUiQSkWma8vv9mjBhghYuXKhAoPV9lyxZoj/+8Y9nhbJtbbzyBi059l+yG126bONr2nrVFzrdzufzKR6P6+OPP9a0adM0YsSIPvtcAAAMZps3b9Y777yjSCRyzlannRl+6FPNXr1GdtQlBaS11yxXJD0gwzJl2LZcZlyGZZ1+bkmWJbdtSbYpt3n63rIk25Lr9HYu25JhWWfuLUuGbbVbLtuS27JlnF7WutyWyzblicfki0Tli0XljcbkjsbljlkyorYUk+zYmRPgMg0pLBmy5JUlr2JKVahbn91w25JPkteQ6XXJ9LkV93lky1B6dRMT1w92Xr9Mr19mWtZ51KqczTYtucyIPJGIfOEGFVQdVEH1MWXVNkhBW3azobTmFo0+dECjdUCG11Ysx6cT+bmqLBylupHjZQ7w/CWtwcohjdv3YZfBSmsrMIKV/tDjkOXQoUO65pprdPjwYUUiES1ZskSZmZn6x3/8R0UiET366KN9MU4AuOhNnDhRmoX9UAAAW3JJREFU7733niKRiHJycnTdddcN9JBwkbnxxhtVW1ur6upqud1uGUbrL3FFRUUDPDLAuUAgoKuuukpvvPHGOduGBS8Zp+opO1WwvVITN32i48WTFMnO6/sBxiIq2v+RxhzYpbRjLa0nGiRJhpQtHR99ifZNmKXQ8MI+H4plWYpGo4rH4/L5fBo3bpwWLVqk3Nz2JyDGjh2riRMnaseOHYrH4532iTfTsrRz9gxNXvex8nbWKHN8hRoLSzt935SUFLW0tGjlypW6++67aRsGALjovPvuu3rvvfcUi8V6HLCM2LtV09d8INt0yc5xafX1d8hMa51XIFF3YvbBmM+XHY/LE22RN9Qsf7hZ/kiL/JGQ/JEW+aJh+aMR+aJReaNReWMxeaJxuaKWjFgnIU1IUuhMeynv6Z5TF/PE9aZpyjRNWZYlr9d70f1+Zbhdst2pivlSFcvM1oG8Eh2Y2rrOFWpSwbE9Kqw6pJzaOnnq4rJjhjxVMRVWVarw40rJ2CBlu1SfF1BVQZGqL5mgcD/8bZAIVsbu26aCw9VdBiuHxl120fy3PFj0OGT51re+pVmzZumjjz5STs6Z/nS33HKL7rvvvl4dHADgjPz8fKWnpysUCunaa6/ttNc90JfcbrduueUWPf3002pqapLP55PL5VJpaecnRoGhory8XHv27NH+/fvP2TZs25xrtezok7JPuXTFupf19vX39EnbMDseV8HhHRq3b4eyjgZbrzrV6T+eMmzVjMrX3gkz1VgwutffuzNtwxWv16uxY8dqwYIFGjlyZJevWbZsmY4cOaJgMNjlyaBDE+do7P5d8h2Lat5f3tTrt3xFRieBjMvlktfrVWVlpd5//31deeWVvfr5AAAYzN566y1t2rRJlmX1OGAZ/cm7mrj+E9mWoXihV2uuuXPAr77vLsPjkenJkpmWpbCD1ydCGn+oSb5wi3yR5tMhTUj+aFieeEw1+UUX9MT1lmUlwxTbtmVZluw2/eBcLpdcLley/avb7ZbP57voApeOrNQMVY6bqcpxM1sXxGMaVn1QhccPKL+2Sqm1IdkhQzplK/tUvbL31GuSPpGRZqslL001eYWqHDFG9QWjO/3dtqds01JW7SGN27dNBYfaByty2YqO8OvQ6LE6OG4mwcoA6vG/9F/+8hetX7/+rJN7o0eP1rFjx3ptYACAs82ZM0emaXJSGwMmNzdXS5cu1csvv6xIJKKUlBSNHTt2oIcFnLcbb7xRjz322Lnbhnm82rBgqeatWCXf8ZjGb1+rfTMW9cr726al4ZV7NX7vRxp+qK5N6wqXjBRLJ0tytG/cNNVdMqHf5oOxLEuxWEyxWExut1slJSW66qqruvUzKDU1VQsWLNCrr77aZYWQ4XZpw1U3aOEfX5DqpMkfrtauyzufd8Xv9ysej2vjxo0qKyvTsGHDzvvzAQAwmJmmqddee03bt2+X1PqztScBy8Qtb2r0pv2SDIVKUrVuyR0XbJjQmURI05KWpZaBHkwfsiwrGaYkHncWpPh8PmVkZCgQCCgQCGjYsGHKy8tTIBDQ7t27tXfvXtXU1CQDF4/Hc1FWuHTK49WpS8br1CXj9enpRSmnqlV4bK8Kq48qUBtsbTHWYij1UEijDlVolCpkeGzFcryqy89RVcFo1V4yvkdtu7KqDmrsvg9VcLhGdkPrsmSwUujXoVKClcGkxyFL4v+4HR09elSZmZm9MigAQOdmz5490EMAVFZWpqNHj2rz5s3Kz8+nqgoXhIyMDC1cuFArV648Z9uwhsLROj6tSCO3HdO4Lbt1dFSZwsMKHL9vZs0hjdu9tfWqtKbEVWkuGV5LjcVZ2jtuiqpLLk1eBddfE61GIhHFYjG5XC6NGDFCV111lSZMmNCjfUybNk07duw4Z4VQODtPFZeN0ehNFRr9UYUOjqvu8vts2zbsr/7qrxx9LgAAhgLTNPWnP/1Je/bskcvl6nKOs87YpqUZG19pbWkkQ8FxAW1YdNugnrQb53auICXRwtntdsvj8SSDlKysrGSQUlBQkJw7rzO5ubm68sorFQwG9dFHH2nfvn2qra1tF7gkuhigVXhYgQ4OK9DBKa3P3aFm5R3bq8Lqg8qpqZO3LiY7bshTHVdBdbUKtldLxvtSwFAwL6Cq/EtUVTThrN97W4OV063AksGKzgQro8fo0PhymQQrg45ht403u+GOO+5QIBDQ//t//0+ZmZn6+OOPlZeXp5tvvlklJSV68skn+2qsfaahoUGBQEDBYFBZWVkDPRwAAAY90zS1atUqlZaWqqysbKCHA/Sa5557Tnv37lVqamqXV+7Z8biWvfiEjDpb8UKP3rrx3h5Vl6Scqtb43Zs08uAxqf7McsNtq+WSNO0fM0nHxs6QvP0fYEajUUWjUblcLuXk5OiKK65QWVmZ46sYg8GgHn/8cYVCIaWnd37lnm2aWvqnJ+SqsxQd6dPb19/d5feZ+GP/mmuu0WWXXeZoTAAADGbRaFTPP/+8Dh48KLfb3eWFH52xTVNz1r6gYXtOSZJqpuRr67yb+60KFs4lgpN4PJ5s7WVZlqQzQYrL5ZLH41Fqamq7ICUnJ0cFBQUaNmxYr1WenDx5Mhm41NXVJVuOEbh0jx2PK7vmkAor96ugpkpptS2yW86+XMpItRXKS1VLWrpyjtclgxVJ/R6sNDU16aqrrtKCBQv69H2Gmu7mBj0OWY4ePaply5bJtm3t3btXs2bN0t69e5Wbm6t169YpPz//vAff3whZAAAAILX+cfH444+rsbHxnH3P02sP66qXXpNtGqqYPVZ7Zi4+5369jfUas+cDlVQckuuEdWaFYSs6wqeDpeN1aPxMWSndbyHQm+LxuMLhsAzDUHZ2ti6//HKVl5f3yh/q69ev15o1a+R2u+X3d96mJLP6oK748yrJMvTp/Kk6XHZFp9tZlqWWlhZlZWXpvvvu69GVvQAADHahUEi///3vVVlZ2eOARfGYrnrrWaUdbG2Odbh8lD69/Jo+GinOR6IqJR6PyzRNGYYh27ZlGIZcLlfy3z4rK0tZWVnKzs5Wbm6uCgoKlJub2+8tvGpra/XRRx9p//79OnXqlOLxuAzDSM7hQuDSPSn1tSo4tifZYsyotyS7Q/DishUt9OnQ6LH9XrFCyNK5PgtZpNY/wp599ll9/PHHampq0syZM3XXXXcN2T9yCFkAAACQsH37dr3yyiuSdM7fby/9YKWKth6W4bG15pabFc4Z0W69K9Sk0Xs3q/TAAXmqo23+iLJl5nt0ePRoVUyYpVhGdh99ks9mmqbC4dbpZDMzM1VeXq65c+f26h/vpmnqt7/9rY4dO3bO4Oqyd19S/ifVMlIsvXn7XTLTOv+9PB6PKxKJqKysTLfcckuvjRMAgIEUDAb17LPPqra2Vl6vt8sLEzrjioa1YNXv5TselQxbe+dN1oFpnCgdTCzLUjweVzwel2VZMgxDfr9fw4YNUyAQUHZ2toYPH55s7zVYWzJXVlbq448/1v79+xUMBpPVNok5XAhcus8dblHO8b0aUXVIGY0NqhxRpEPjZnb5O3BfI2TpXJ+GLBcaQhYAAAC09fzzz2v37t1KSUmRx9P5NIa2aWrpS0/IVWvJzHfrzZvvlcuMqXj/hxqzf7dSKsOyzTNXp9nDDB0bXaT9Ey9XODuvvz5Kp9qGK+np6Zo2bZo+97nP9dkf9NXV1frtb3+raDTaZdswxaK65vknZTdITWMy9N7Su7rcXygUksvl0he+8AWNHz++T8YMAEB/qa2t1R/+8AedOnVKPp+vRz+P3aEmff6138tVa8lw29o+v1zHJl7eh6NFd1mWpVgslmwBlphfp7i4WOPGjVNZWdmgDVO648iRI9q+fbsOHDigxsbGZFUOgcvQRMjSue7mBj2e+L6kpEQLFy7UggULtGjRIo0ZM+a8BgoAAAAMNjfccIOqqqoUDAa7rL4w3G69t+A6zX/xZblrTC3585PynIrLjiUmsDdkZNqqGj1CeyeUqzmvqL8/xllM01QkEpFlWUpNTdWUKVM0f/78Pq9ILygo0GWXXaaNGzcqGo12fkLB69PmK65U+ar3lHGgSfkHPlbNmGmd7s/v96ulpUVvvfWWRo0aNaRPUAAALm5Hjx7Vn/70JzU0NJzz4o7O+BpOatFrz0v1kuG1teXqz6l29JS+Gyw+k2mayWBFap2QPhAIqKSkRJMmTdLYsWP7vd1XXykuLlZxcbFM09Thw4f1ySefqKKiQk1NTYrFYjIMQ16vVx6Ph8AFF7weV7I8/fTTWrdundasWaN9+/bpkksu0YIFC7RgwQItXLhwSF5JRiULAAAAOtq5c6defvnlZCDRlYlb3tDoTRXJ50aarbqSXO0ZP0P1hWMGxWSzlmUpEonINE35/X5NmjRJ8+fPVyAQ6LcxmKapxx57TLW1tedsGzbvrd8ra1+DjAxbb9x+jyxf5/3oo9GoYrGYZs2apWXLlvXl0AEA6BP79+/XihUr1NzcrNTU1B6dfE+pq9TClX+W3WTISLG0YckSBS8Z14ejRVdM01Q0Gk1Wcrjdbg0bNkyjR49WWVmZiouLB3qI/cY0TR04cECffPKJDh8+rObmZlmWJZfLJY/HQ+AyiFHJ0rl+aRdWWVmptWvX6pVXXtFzzz2XnLhpqCFkAQAAQGdefPFF7dy5U36//5xtw2auXyFfNKoDYy9VTfFkGYPkCsW24YrP59O4ceO0cOFCDR8+fEDGU1FRoT/84Q/nDK7coSYt+cPTskOGTpTlacv8L3S5v5aWFnm9Xt11110aOXJkXw0bAIBet3PnTq1cuVKhUKjHAUtW1UFd8foq2SFDRrqtv1x7o5pzL+nD0aKtziau93q9ysvLU2lpqaZMmaLc3NyBHuaAM01Te/bs0c6dO3X48GGFQqFk4OL1euV2uwlcBljbgNDlcmnBggW68sorB3pYg0qftQuTWv+Yeffdd7VmzRq98847+vDDDzVlyhQtXLjQ6XgBAACAQeeaa67RsWPHVF9ff862YR9edWYCduOsLfqfZVmKRqOKx+Pyer0qLS3VokWLVFBQMKDjKi0t1aRJk/TJJ58oHo93GlyZqRnaMXuGytZ+pNxPa5Q1fr8aRoztdH8pKSlqaWnRypUrdc8991ww7TcAABe2LVu26O2331YkEjlndWdncg5/qsvfWiM76pKypHeuu1WRAZ7r7WLQ1cT1JSUlGjt2rKZMmaKMjIyBHuag4na7NXnyZE2ePFmmaWrnzp3atWuXjhw5olAolJynxuPxyO12yzBaf4smeOlbHSuvvF6vRowYobFjx+ryy5nPyakeV7JcccUV+vDDDzV58uTk3Czz58/XsGHD+mqMfY5KFgAAAHRlz549evHFFz+zbdhg0DZccbvdKioq0oIFC1RSUjLQQ0sKhUJ67LHHzjnfjSQtfPkp+Y9FZA839PoXviKji0qiSCSieDyu+fPn66qrrurLoQMAcF5M09T69eu1fv16xWKxHgcsI/Zt1fR3PpBtGrJzDL1z3R2Kpfdf68+LTWcT16elpamoqOiCmLh+oESjUe3YsUO7du3SsWPHFI1GZdu22p6iNgxDtm0ng5fEusTzxOPE887uO96kizfA6SxYycvL07hx4zRt2rR+bSE81PRZu7Dhw4fL5XJp6dKlWrhwoRYuXKgJEyac94AHEiELAAAAzmXFihXavn27fD6fvF7vQA/nLB3DlYKCAs2fP1/jxg3O3uzbt2/XK6+8IsMwlJLS+Zwr/vpaLXrhBdkxQ4fLR+nTy6/pcn+JXvb33HPPgLVCAwDgXI4fP6433nhDx48fl23bSk1N7dEJ31E73tOk97ZLlqF4oUdrrvmSzJS0Ho8jFospEom0O1n9WacG227b3fVdvaazk+SGYcjlcg2KE+GdTVyfmZl5QU5cPxhEo1Ht379f4XA4Od9e4j4ejyd/v020Z0s8T6w3TVOmaSZDmrY3SWfdJ8KbxOPEusRcOonbhRDGtP1vmWDFuT4LWWzb1vbt27VmzRqtXbtW69atk8/n04IFC7Ro0SLdd9995z34/kbIAgAAgHOJRqN67LHHdPLkyR5fddpXOl5d6fF4lJOToyuuuEKXXnrpQA/vMz377LPat2/fOfvQT9zypkZvOiDDY2vNrbcoPKzzdmemaSoUCqm0tFR33XVXXw4bAIAeCYVCevvtt7Vjxw5Fo1F5vV55vd4e/S4xYetbKv1gnyRD4eIUrV16p+T193gs0WhU0WhUOTk5ys/Pb3dC2rKss05SJ05eJ9Z1vO/4eklnPe7spHfHx21vHU98tz0hfq4qhfMJaZi4fuhL/BuGw2GFw2FFIhFFo9HkfeKWCGoSv0MngpqGhgYFg8Hk79WJyiW3293j/78OJIKV3tcvE9/btq0tW7bo3/7t3/Rf//VfTHwPAACAC9a+ffv0wgsvyDRNpaX1/MrR3tAxWHG73QoEAhozZoymT5+uESNGDMi4nAgGg3riiSfU0tKi9PT0TrexTVNLX3xCrhOWYiO8Wn3DPTLcnf+RGw6HZdu2rrnmGl122WV9OXQAAD6TaZratm2b3nvvPTU2NiarN3tystY2LU3/4FWN+Oi4JKlhXJbWL7ytyxaa5xKJRBSLxVRYWKg777xzwOcPiUajCoVCam5uVktLi0KhUPKWqGpIjLntyfLE70GdBT3dCWnaBjWJIImJ6yG1BqIVFRU6fPiwqqurdeLECUWj0WRoKCkZugymaqaugpWxY8dq+vTpBCvnqc9Clq1bt2rNmjVas2aN3n33XTU2Nmrq1KnJ+Vluvvnm8x58fyNkAQAAQHe8+uqr2rZtm7xeb7/14O440arL5VJGRoZKS0s1depUjR49ul/G0Rc2bNigd955R263W35/51fkZtQc0pUvrZQsQ7s/d6kOTvlcp9tZlqWWlhZlZmbqq1/96oCfPAIAXLzatgazLEspKSny9DAYsU1Tc9a9oGG7T0mSai/N05Yrlnd5scG5hMNhmaap4uJi3XnnnRfEPCLRaFTNzc1qbm4+K6DpGNJEIhGFw2HFYjHFYjGZpinLsuR2u5MTfjNxPToyTVPHjh1TRUWFqqqqVFNTo+bm5mSFV6KCyu12y+Px9Gu1S2fBSm5ursaNG0ew0sv6LGTxeDyaMWNGu0nvh/o/HCELAAAAuiMajerxxx9XXV1dn7cNS7QzSAQrqampGjVqlKZMmXLB9AM3TVO/+93vdPTo0XN+nzPe+7MKtlfJ8FtafftfdTnJbzweVzgcVkZGhsaNG6fy8vIhVd0DABjaEq3Bdu7cqUgk4qg1mCQpHtPn3npO6QebJUlHZpZo5+xrHY/JsiyNHTtWt9122wXx+0NviEajyfk3gO46efKkDhw4oKNHj6qmpkbBYFCxWKxfWowRrAyMPgtZGhoaLrgggpAFAAAA3VVRUaHnn39e8Xi819uGdewJnpKSoqKiIpWVlamsrOyCPBFQXV2t3/72t4pGo122DVMsomuef0p2g9RUmq73lv1/Xe4vHo8rEonItu1ku4QpU6ZoxowZF8SVuwCAwWnLli1av369GhoaHLUGS3BFw1qw6vfyHY9Khq298ybpwLSFPd6PZVkKh8OSpMmTJ+umm266IH+PAAZSNBrV/v3727UYi0QiyXZ2iTl+vF5vsvKlJ7oKVsaOHasZM2YQrPSDPgtZQqGQ3nzzTe3Zs0eSNGHCBC1ZskSpqannN+IBRMgCAACAnli5cqW2bt3aK23DOgYrPp9PI0eO1MSJEzVt2rSLIhhYvXq1Nm7cKI/H0+XnzTm0U7NWrpNkaNuSuaoeO/2c+7QsKznBqWEYSktL05gxY1ReXq6ioqI++BQAgItRZWWlXn/99fNqDZbgDjVp0Wu/l7vWkuGytX3+TB2bNLvH+7EsS6FQSC6XS5dddpmWLFlCwAL0A9M0dfz4cR08eFCVlZWqqalRU1NTj1qMEawMLn0SsqxYsUJf+9rXdOLEiXbLc3Nz9fjjj+vGG290PuIBRMgCAACAnjBNU4899phqa2sdtQ3rGAB4vV7l5+drwoQJmjZt2kXXE7y73+fct55VYF9QRoatN26/R5YvpVv7T/RgtyxLHo9Hubm5uvTSS1VeXn5RhFgAgN4XCoX0zjvvaMeOHYpEIskLBZy2CPI1nNSi156X6iXDa2vr569QTem0Hu8nEbB4PB7NnTtXCxYscDQeAL0jGAxq3759Onr0qKqrq5MtxizLkqRk6GLbdvJvA4/Hk5y8ftq0aRo2bNgAf4qLV6+HLOvXr9fChQt100036bvf/a4mT54sSdq5c6d+/vOf65VXXtHatWs1d+7c3vkE/YiQBQAAAD11+PBhPffcc4rFYt1qG9YxWHG73crJydH48eN12WWXXfRXpSXasJmm2WWVvCvUpKV/eFp2yNCJybnasuDWHr1Hx3+D1NRUlZaWqry8XCUlJb3xMQAAF4GtW7fqvffeO+/WYAmpJ6u04LWXZDcZMvyW3l+6RPWXjOvxfizLUktLi3w+nxYuXKjZs3teBQOgb0WjUR04cKBdi7FwOCyXy0WwMgj1eshy3XXXqbi4WL/5zW86Xf/Xf/3XOnLkiF577TVnIx5AhCwAAABw4vXXX9fmzZu7bBtmWVay3F9qvVItOzs7We6fn5/f30Me1FasWKHt27fL7/d32WqlaNdGXbpmm2TYev/GJQqOHOvoveLxuKLRqCzLSgZeZWVlKi8vH9KtkAEAfaeyslJvvPGGjh07dt6twRIyqw/qylWrZIcMGWm23r32ejXlFfd4P4mAxe/3a9myZZo2redVMAD6n2maqq6uVmpqKsHKINTrIcvw4cO1du1aTZ06tdP1H3/8sRYsWKBTp045G/EAImQBAACAE6Zp6vHHH1dNTU2yzZVlWYrH44rFYrJtW263WxkZGRo7dqymTp2q4uKenzi5WIRCIT322GMKBoPnbBu28JWn5D8akT3M0Ou3fkXGeZzg6ljdkpKSolGjRqm8vFylpaWO9wsAuHBEo1G99dZbvdYaLGH44V2a/dY7sqMuGVnSmuu+oHB2Xo/3Y5qmQqGQ0tLSdMMNN2jChAnnNS4AQKteD1lSU1O1a9cujRo1qtP1hw4d0qRJkxQKhZyNeAARsgAAAMCpo0eP6ve//72i0agMw5BlWXK5XEpPT9eoUaM0depUjR49mglnu2n79u165ZVXkoFHZ/zBE1r0xz/Kjhk6OrNEO2Zf2yvv3bG6Zfjw4Zo0aZLKy8svunlyAACters1WELhvm2aseZ92XFD9nBD71x3u2IZ2T3eTzweVzgcVkZGhpYvX67Ro0ef99gAAK26mxt0+5Kv8ePH6+2339a9997b6frVq1dr/PjxPR8pAAAAMIQVFRVp5syZ2rRpk3w+n0pKSlRWVqaJEycSrDgwdepU7dy5U3v37pVpmp1+h5FArg7MHK/SjftU/NEh7R9bqXDOiPN+b4/HI4/Hk2zzVltbqxMnTuiDDz7Q6NGjNWPGDI0ZM4Z/VwC4CFRWVurNN9/U0aNHe601WMKones16d2PZVuG4gUevXPtnbJS0nu8n1gspkgkokAgoNtvv10FBQW9Mj4AQM90+6fDvffeq+9973sqKCjQdddd127dq6++qu9///v6wQ9+0OsDBAAAAAa7hQsXavTo0SouLu50bhb0zDXXXKPjx4+rubm5ywqS3dMWatSBA3LVWrryLyv11o33yHCf/5XFUuvcOX6/X36/X6ZpKhKJaPfu3dq3b58CgYAmT56syy+/nOoWALgAddYarLeqVyRpwoerVbpxryRD4eIUrV36Jcnb898dotGootGocnNzdccddzCXAwAMoG63C7MsS3fccYdeeOEFTZw4UZMnT5Zt2/r000+1d+9eLV++XM8//3yv/dDpT7QLAwAAAAaX999/X2+//bbcbrf8fn+n26TXHtZVL74m2zK058oyVUy9qs/Gk6huicViMgxDPp9PxcXFmjFjhsaPH091CwB8hpMnTyoYDCovL2/QhtQffvih3n333V5vDSZJRjSk8g2vKufTOklS49hMvbfodkfzikUiEcViMRUUFOhLX/rSoP0+AWCo6/U5WRKee+45PfPMM9q7d68kacKECbrzzjt15513nt+IBxAhCwAAADC4mKap3/3udzp69KjS0tK6PMk1ff0KFX5cKcNvafVtX3LUz97J2KLRqEzTlMvlUiAQ0KRJkzRr1iwFAoE+f38AGOyCwaAOHTqk48ePq7a2VidPnlQoFErOW+bz+ZSenq5AIKCsrCxlZ2crNzdXBQUFysjI6Pfgurq6Wq+//nqftAazTUslezbp0k0fym4xJEknynK1+cpbHFVghsNhmaapoqIi3X777UpNTe2VcQIAztZnIcuFiJAFAAAAGHxqamr029/+VpFIROnpXfSqj0W07I9PSUGpeXS63r3m/+u38SWqW+LxuCTJ6/WqqKhIU6dOVU5OjlJSUpSamiqfz0elC4ALVlNTkw4dOqRjx46ptrZWdXV1amlpkWmakiTbtuVyuZI3y7Jk23byPiGx3uPxJAOYzMxMZWdna/jw4crPz9fw4cN79XgajUa1evVqffLJJ8nWYD6fr9eqV9JPHNOc916XtzImSTLSbO24fIaOTJ7raH/hcFiWZam0tFS33347P1sAoI/1eshiWZb+6Z/+SStWrFA0GtXVV1+thx9++IJIzAlZAAAAgMFp9erVev/99+X1eruc7ybn8Kea9dpaSYY+WjxHVeNm9OsYpfbVLYZhyOVyyTBar1hOPHa73fJ4PHK73cnP4/V65fF45PF45PV62y33+Xzy+XzJ+WH8fn8yuElNTeXkGoB+FwqF2gUqJ06cUHNzs+LxeDIwaRuWJB5/FsuyZJqmTNM8K4BJHEvdbrfcbrdSU1OTAUwgEFBOTo7y8vKUn5/fo+Pitm3b9Je//KXPWoPN2LhK+Z9WS5YhuWzVTs7Xh3Oule3r+Xk0y7IUiURkWZbKysp000038TMAAPpBd3ODbtc+/v3f/73+5//8n1q8eLFSU1P1r//6r6qpqdETTzzRKwMGAAAAgI4WLlyoffv2qba2NnnCrqO6kskKjv9Igb1BzdjwvjakZih4ybh+HWfixF/iRKFlWZLU7mRhPB5XOBxOnjjszvVuiZOLhmGc9bjticxEgJMIZjo7+db2/bp6fK7XSEp+rs6267jPxAnRxM3lcrULmto+TgRNHQOnRAjVMXhKvB5A34lGozp8+LCOHj2q2tpa1dbWqqmpKRmo2LadDJAT/790GlIkjmder/esdZZlJY+t8XhcwWBQ9fX1yWNi4vVut1spKSnKzMxMtiAbNmyY8vLyVFBQkAzqq6ur9cYbb+jIkSN90hqseO8mTfkg0RrMULzQo41XLlVTXrGjfVqWpVAoJJfLpfLyci1ZsoTjHwAMMt2uZBk/fry+973v6a//+q8lSW+99Zauv/765IF+KKOSBQAAABi8Kioq9PzzzysejystLa3TbdyhZi35w+9kh1pPutnDDB0cP0b7J8+TmdpFq7FBrG1Ikwhq2j5PPO64rO3ygWQYxlnjSJwQbXt1euIkbccr1ts+7uo+USGUOLmaOEmbCGDahjKJCqCUlBSlpaUpIyND6enpysrKoioIUGs13pEjR3TkyBFVV1errq5ODQ0NisViZwUqbatUBlrbACZxrLQsq93xJXFc8Pv9ysjI0MmTJ/ukNVjaiWOa26E12M7Lp+vQhDmO5l5JfL5QKCSPx6M5c+Zo4cKFvTJWAED39Hq7ML/fr3379qm4+EzynpKSon379qmoqOj8RzyACFkAAACAwe2VV17RRx99JL/f3+UVxxk1h1S+eY1SjoZa27NIMjy2Gksy9emkctVdMsHxiS70nbbVMR2Do84CpY7bftb6joFPohKobUVQ2yqglJQUpaSktGvPlpKSooyMDKWlpSkrK0sZGRldtq+7EJimqVAopGg0qlgspkgkknzc8RaPx5P3iUqDxOPEc8uy2rWO6iwUa1vp1JOqp7aVT20rKgjOumaapiorK3XkyBFVVVWptrZWwWAw+W+V0PHfZKhJVBEmqgsTz3u7NZgrGtb0D1aqYGe17NOtwU5MytO22dfKTOn8woDujr+lpUU+n08LFizQnDlzemW8AIDu6/V2YfF4XCkpKe2Web1exWIx56MEAAAAgG5YunSpDh48qPr6eqWlpXV6cqwpf5TWXne3vI31mrhzvYr2HZbdaCjjQJMuP7BWCqzVofGl2ls2V2YaF1cNFv158rbthNttH0cikWQrt7bVNW3vE2NNhDNtq2U6BjMd585JXGXf9taxOqnjus6Wtw2TOtums/21nesicYtGo+2CkMSt7ffS3YqpziqU2j7vStuqpXNVN3Xctu3zjvdtHyf+u0qEOW2DtcR2XT1PvLbj/Ept2/R1/G+i4z7OteyzdPV5e7qs4/N4PK66ujrV19cn55Bq+7kS1R5DMVDpTOJz9GXgVrTrA03ZtFV2syFbhuIFHr3/uSVqzis5r/0mAha/368lS5ZoxowZvTNgAECf6HYli8vl0rXXXiu/359c9vLLL+vzn/+80tPPlN//6U9/6v1R9jEqWQAAAIDBb8eOHVqxYkXyKuTPYpuW8g/v0KRd25R+pLn1CmNJhttWU3GGdk2+TLVFk6luwTm1DR0+K/zoKpzpSndbu3XVUq07++isdVvb/XQnsOgqUEgs6wtdVTgl7s9V5dTxeU/mHTrf7RK6G6g4cb4tAdu2/KLix5mzWoOlnm4NNtF5a7CERCVZWlqabrjhBk2YMKE3hgwAcKDX24Xde++93XrjJ598snsjHEQIWQAAAICh4bnnntPevXt7PI+GtzmocTs3qGTfISl4ZrmRJR0eV6K9ZfMUy8ju/QHjotS2SuVcPutE/IVSUQBcKFpbg61Swc6qM63BJuZp25zzaw2WEI/HFQ6HlZGRoeXLl2v06NHnP2gAgGO9HrJcyAhZAAAAgKEhGAzqySefVFNTkzIyMnr8etu0lHtstyZ9ukWZh5tkm6dPcrtshYrStGvSdFWPmkp1CwCgnUt2b9LUD7bIbm79udFbrcESEvMfBQIB3X777SooKOiV/QIAnCNk6QFCFgAAAGDo2Lhxo1avXi2Xy9WttmFdcYeaNG7nBo3ee0CqP7PcyLB1bFyRdpddoWjW8PMfMABgyEo7cVxz1r8u3/GopNbWYJ9ePk0HJ87ttUA+Go0qGo0qJydHd9xxh4YP52cPAAwGhCw9QMgCAAAADB2maerpp5/WkSNHlJaW1istlbKP7lHZp1uUdSgoO366usWwFbkkRbsnTdPx0ukymLsAAC4armhY0zatUuGO063BDFt1k/K0dc41slLSP3sH3RSJRBSLxVRQUKAvfelLjqo0AQB9g5ClBwhZAAAAgKGlpqZGv/3tbxWJRJSe3nsnu1zhZo39dKNK9+6TcfLMn0pGuq3KsSO1q2yeItl5vfZ+AIDBp2NrMLPArY1XLlFj/qhefZ9wOCzTNHXJJZfojjvuUGpqaq/uHwBwfghZeoCQBQAAABh63n77bW3YsEFer1c+n6/X959VuV9lOzcp+2C97NiZ6pboCL/2TJyio2Mvk+Hx9Pr7AgAGRlrdcc15r0NrsFlTdXDSvF6fqysRsIwZM0a33nprn/wcAwCcH0KWHiBkAQAAAIYe0zT1+OOPq6amptfahnXGiIZUumujxu7ZK9cJ68zyVFvVYwv06aVXKDyMCYoBoCN3uEXDqw4ov+aIhp2sU9zrUUNmQMFAroLD8tU0bITkHfhwwYiGNX3T6yrcWSnbTLQGy9XWOdf2amswSbIsS5FIRJZlqaysTDfddJPctKMEgEGJkKUHCFkAAACAoengwYP6wx/+oHg8rrS0tD5/v8yaQ5q8Y6OGV9TJjiZCHVuxET7tnVCmI+PLJY+3z8cBAIONEQ1rWNVB5dccVm5djdLrmqVGW7KNc7zKlpEmxTM8aslIU2NWloJZOQpm56txeGGvBxydGblns6Z9sFl20+nWYPlubfxc77cGk1oDllAoJJfLpRkzZmjp0qUELAAwiBGy9AAhCwAAADB0vfrqq9q2bZt8Pp+83n4KOGJRjd79gcbt2SV3jZlcbKRYahqRqZjXp5jXo7jHp6jHq7jXp5jPr6jXr5jXr5g3RXF/6un7FJneFBmcaAMwVMRjClQfUkHNIeWeqFZmXaMU7DxQMVJtRYb7dWr4cLnjcWU2NsrfFJHRZMuOnyuAaT2mmhkehTJS1ZSZpfqsYacrYAoVSw+c10dIqavUvPWr5Dt2pjXYrvIpqph8Ra+3BrMsS7FYTLFYTD6fT7Nnz9bChQt79T0AAL2PkKUHCFkAAACAoSsajeo//uM/dOrUqT5tG9aV9BPHNHnH+8o9UCM74vy9DY8teWzJY8j2GLI8Llkel0yPW3GPR3GvR3GPVzGvVzGP73SQ42sNbXx+Rb0pivlTFPemyDbcMmRLp//cS5zGtGXLaPMnYOKxbdtyyU5slPif5Otk263767AP4/S61n2deQ9JstxemR6vTI9flscr0+trHVcvn7wE0LfseFxZdUeVX3VQeSeqlHWyQa56q7WtVgeG31J0uF+ncoapJq9IJwpLFQnkdr5f05K/uV4Zp6qVHaxRoOGkMhublNIYkqvZ/MzjqeGzZKW7Fc5MUVNmhhoyh6k+O08Nw0YokjGsy2ONEQ1r2uY3NGLH8WRrsJMTW1uDmam9XzkTj8cVDoflcrk0cuRILV26VCNHjuz19wEA9D5Clh4gZAEAAACGtp07d2rFihWSpJSUlIEZRCyi4n3bNPxUtTyxmLzxmDzxuDyxuNxxS664KVfckhG3pbgtxQ3ZcalNlHHhM2wZLkluW3IbkkuS25DtliyXS7bbkOV2JW+my91673afvnlkut2Kuz0y3R7FPR6Zbq/ibq8sj0dxt7f1udcr05uiaGqGoikZVAkB3WSbljJOVSqvqkL5tccVOBmU+5TZacWJ4bUVH+7RqeHDVJs3UjUjxiiUlddrQaq7pUGZJ6sUCNa2BjANQaU1heRuMmWHPqMCxmPLTjcUyfSrOSNDwaxsBQO58kUjunTLh+1bg125WI0Fo3tlzG1ZlqVwOCzbtpWZmakrrrhCl112Ge3BAGAIIWTpAUIWAAAAYOj7wx/+oL1798rv98vj8Qz0cLrFNi25zIi84ZA80bA8sZC80Yh8sbC8sYg8sYi8sah8seiZ4CYWlycelztuyn06uHElg5vT7Xc6+yvP6ORhZ+cpP3OZ3b3tLEO22Xo/oAxbhteW/IZMn1txv0cxv1cRn1+RlBSF/akKp6S33lIzFUlrvcnrH9hxD0G2acmw4nLHwvJEI3LHo/LEY7JchiyXt7Wi6XQwZnl8sl0eKpsGkG1aSm2oVX7VAeXVHld2Xb28J6OyY2f/mxgeW+Ywt4LDA6rJHaHawlI1DR8xYAGmEQ0p42SVsk/VKNBwQpmNDUprbJG3KSa7RZ8xD0xrG7Jds6b2S2uwsrIyXX311UpNTe3V9wEA9D1Clh4gZAEAAACGvqamJj3xxBNqbGyUbdvyeDzy+Xz93j4M7dmmKbcZkxGPyhOLyh2Pym3G5I7F5IrH5DGj8phxueMxueOx1sdmPHnfejPlNi25TVMu05TbMuUyLblMS4ZpyWXaMixbhmlLpiQrUSnkPOAxPLbkk2y/obivNZiJ+n2K+BPBTNrpYCZDkdQMhdOyZPrSBl1oYJumPLGIXPGI3LGo3PGIPNGoPPHELdbm/vQt8W8QP/3dx80z373ZGuoZpnXm+zZtyXRYmeU6Xd3kspOVTXJJtsuQXIYslyHbbch2GbJcrRVOtssl8/Rjy+WW6XbJcrlkuj2t967WiierTeWTDEO2XLINQ7bRui8Zhiwjsaz13jLckiHZLnfrehlnHrsMyXDJMk6/1uWWbbQusw1X65iN1jFJrVVZSrxekp34bozEd3Tmu+qP/258DSeVV7lf+bXHNKzupHwnI5225DJctqxslxpyslSbW6jagtEK5hbJGCLhtWIRZdTXKKu+RoH6E8pqrFd6Y7N8TVEpaqtudK62zr2uz1uDjRgxQkuWLFFRUVGvvw8AoH8QsvQAIQsAAABwYQiFQtq8ebN27typkydPyjRNuVwu+Xy+IVPdgl4Ui8rf0iBfqFGpoUalhJuVEmpWSiQkfzgsfzQibyQmTyQud9SUorbsqPGZV8F3yWXL8NmyfS5Z/tb5dAzblmydniNHp+e3kWS1Xdb+cevz1m2TVUlt1qntuuRzo922dnL7AaokMmwZbrWGJ1JrCGMN4HiGnDanas71lRnneNphXWdzqMiwpYChxuGZOpGbr5qC0arPL6aSq4fatgbLyMjQvHnzVF5eTmswABjiCFl6gJAFAAAAuPBUVFToww8/VEVFRfLkF9Ut+Cy2acoTaVZKS6NSWhqUEmqSP9Ks1HBI/khI/khEvkhU3khM7qgpI2JL0S5OYA8yhss+PR+OJM/pCpHTN8t9uiLE4zoz743HfXrem9b5buKetjdf673XJ9PjV9zjk+n1tT73+mW7vJ1WZ9jxuNxWXIYZlzsWlcuMyWXG5TZjcsVb789UL8Xksky5zbhcVlwe02zdxjpdzWSZp7cz5bJaK5tcltXusWHZcllWa3B1OuTqGGq1XX52qNVFmHX6ZrddPujZMrIMNQ1P14mcPNUUlKi+sFSWb4DmsbpARCKRZGuwyZMna/HixbQGA4ALBCFLDxCyAAAAABeuUCikrVu3aufOnaqrq1M8Hqe6Bb3OiIbkb26Qv6VRKeEmpYSb5Y1Fz7SYknG6xdTpFlKnW1XpdPuq1rZTrS2tWl/TpoWVXJ20sGpdf2afrjP7MFzJNlamxyPrdAgyZNo9DUG2aUmyZdhWa7WSbcqwrNOVTK2Bz+kt27yoNZgxbOus/anNqRoj8Zp2yxJ7a7Osk9M7iWW2bSuaniUrpfdbZF2s2rYGKyws1NKlS2kNBgAXGEKWHiBkAQAAAC4Ohw8f1pYtW1RRUaFQKER1CwCgR2gNBgAXj+7mBgP6V8Qjjzyiyy+/XJmZmcrPz9fy5cu1e/fudtuEw2Hdf//9ysnJUUZGhm699VZVV1e32+bw4cO6/vrrlZaWpvz8fP3N3/yN4vF4f34UAAAAAENASUmJbrnlFj3wwAO6+uqrNWLECElSS0uLmpubFYvFBniEAIDBKhKJqKWlRR6PR9OmTdPXv/51zZ49m4AFAC5yA1orvHbtWt1///26/PLLFY/H9YMf/EBLly7Vzp07lZ7eWsL6ne98R6+++qqef/55BQIBPfDAA/rCF76g9957T5Jkmqauv/56FRYWav369aqsrNSXv/xleb1e/cM//MNAfjwAAAAAg5TP59PcuXM1d+5cHT9+XJs3b9b+/fvV0tKiSCRCdQsAIKlta7CRI0dqyZIlKi4uHuhhAQAGiUHVLqy2tlb5+flau3at5s+fr2AwqLy8PD3zzDP64he/KEnatWuXJk+erA0bNmju3LlauXKlbrjhBh0/flwFBQWSpEcffVR/+7d/q9raWvl8vs98X9qFAQAAAIhGo9q2bZt27NihmpqaZHW81+vt1t8VAIALi2VZikQisiyL1mAAcBHqbm4wqGa9CwaDkqThw4dLkrZs2aJYLKbFixcnt5k0aZJKSkqSIcuGDRs0derUZMAiScuWLdM3vvEN7dixQ5dddtlZ7xOJRBSJRJLPGxoa+uojAQAAABgifD6fZs+erdmzZ6u6ulqbN2/Wvn371NTUpGg0SnULAFxEIpGIYrGYfD6fLr30Ui1ZskSpqakDPSwAwCA0aEIWy7L07W9/W1deeaWmTJkiSaqqqpLP51N2dna7bQsKClRVVZXcpm3AklifWNeZRx55RD/+8Y97+RMAAAAAuFAUFBTo+uuvl2mayeqWyspKtbS0yDAMeb1eeTweAhcAuMDQGgwA0FODJmS5//779cknn+jdd9/t8/d66KGH9OCDDyafNzQ08AMTAAAAwFncbrfKy8tVXl6u2tpabd68WXv37k1Wt7jdbvl8PlrHAMA5mKapeDwu27ZlGIY8Ho8MwxhUQXXb1mCZmZmaO3euZs2axfEdAPCZBkXI8sADD+iVV17RunXrVFRUlFxeWFioaDSq+vr6dtUs1dXVKiwsTG7zwQcftNtfdXV1cl1n/H6//H5/L38KAAAAABeyvLw8XXvttVq6dKm2b9+u7du3q7KyUuFwWJKobgEAnQlULMuSaZqSlAxUXC6XLMtSOBxOBi62bcvlciW3cbvdyW37S9vWYGVlZVq6dCmtwQAA3TagIYtt2/rmN7+pF198UWvWrFFpaWm79eXl5fJ6vVq9erVuvfVWSdLu3bt1+PBhzZs3T5I0b948/f3f/71qamqUn58vSXrzzTeVlZWlsrKy/v1AAAAAAC54brdbM2bM0IwZM3Ty5Elt2rRJe/bsUWNjY7K6xTCM5E1S8gRi2+cAMNRZlqV4PC7TNGVZlmzbltR6nPR6vcrPz1dubq4KCwtVUlKinJwc1dTUqLa2VidPnlQwGFRjY6MaGxsVCoUUj8cVj8clKbmvtgFN2xCmN5imqVAoJJfLpREjRmjJkiUqKSnplX0DAC4ehp34qTUA/vt//+965pln9Oc//1kTJ05MLg8EAskrBr7xjW/otdde01NPPaWsrCx985vflCStX79eUusPxBkzZmjkyJH62c9+pqqqKv23//bf9LWvfU3/8A//0K1xNDQ0KBAIKBgMKisrq5c/JQAAAIALnWma2rlzpz7++GMdP348efW2bdvJW+J5R4kruds+T9y3fdzxPhHctH0OAH2lY6CS4HK55PF4FAgElJeXp4KCAhUXF2vkyJE9arVlmqZOnDihmpoa1dXVKRgMqqGhQQ0NDWppaUm+b9v3bnssTIyjO8fCtq3B0tPTNW/ePFqDAQDO0t3cYEBDlsQfBB09+eSTuueeeyRJ4XBY3/3ud/X73/9ekUhEy5Yt069//et2rcAOHTqkb3zjG1qzZo3S09N1991366c//ak8nu4V6hCyAAAAAOgtiSujw+GwwuGwIpFI8haNRpO3WCyWvCWu3o7FYsl1iZOZba8Q7yq0SbTd6fi47TYDpauxdPx7sKtAqav1iROpXS0H4FwiUEm0/EocVwzDkNfrVUZGRjJQKSoqUklJSZ8GFKZp6tSpU6qtrVVdXZ3q6+vV2Nio+vp6tbS0KBaLdRrAtK2CSVQZJo67Pp9PEydO1NVXX62MjIw+GzsAYOgaEiHLYEHIAgAAAGAwM01T0Wg0GdwkwpvEskQ4E41Gk2GN1D6o6Cq06O7jnr42ccKzbViUCIwSoVLb5W2vUk+ESokTpp2FSm3v2z5uGzYlnrc9QdyxQihxApZqIFysEkFK4tb2/y8ej0fp6enKz89XXl5eMlDx+XwDPex2gsGgampqdOLECZ06dSpZAdPc3KxoNJr8XIn5XwoKCmgNBgD4TN3NDQbFxPcAAAAAgK653W6lpqZedBMxJ8KljpU/HauAYrFYcrLtRHgTj8fbBVGhUKhdEJUIc9qefO2oY+u2tre28+wM1XCmsxCrY6VUZ0HWuUIu6eygq622oVfH9U6CwLbPO27TNlDr6rVtDdV/x55oG362rfxIBCqBQEC5ubnKy8vTJZdcolGjRg2J404gEFAgEND48ePPWtfU1KTa2lrV1tbq1KlTGjZsmMrLy2kNBgDoNYQsAAAAAIBBqa/CpURLt8bGRjU1Nam5uVktLS3JNm+hUEixWCz5PFEplKiwaRvMdBYadHWCX/rs9m09bTbRk+07m/+nY3u5c80JlJhwPNF6KXHzer3yeDzyeDxyu93t7j0ejwzDaFctkXjcNug6V1VTxwqnzoKgc4VB3f2+OquC6u73fK7wpjuv70+GYcjtdis9Pf2sQOVCbJuVkZGhjIwMlZaWDvRQAAAXKEIWAAAAAMBFxe12J0+89kQ0GlUwGFRTU5OampoUCoXU0tKSDGYSc+8k2rl1bNt2rgCj47KOQU3HOWgSlTRtH7dd1vb1XQUiHo8n+dzr9crn88nr9crr9crv9yeXpaamJl8/WCSqnEzT7HRuo0Q1U2J926qNjmFNV88lJUO1xOPObm1f33b/HV+T0J3Axek251rmdruVnZ2dDFQCgcBnvgcAAPhshCwAAAAAAHSDz+dTXl6e8vLyBnooF71ElRMAAMBAu/AbjgIAAAAAAAAAAPQBQhYAAAAAAAAAAAAHCFkAAAAAAAAAAAAcIGQBAAAAAAAAAABwgJAFAAAAAAAAAADAAUIWAAAAAAAAAAAABwhZAAAAAAAAAAAAHCBkAQAAAAAAAAAAcICQBQAAAAAAAAAAwAFCFgAAAAAAAAAAAAcIWQAAAAAAAAAAABwgZAEAAAAAAAAAAHCAkAUAAAAAAAAAAMABQhYAAAAAAAAAAAAHCFkAAAAAAAAAAAAcIGQBAAAAAAAAAABwgJAFAAAAAAAAAADAAUIWAAAAAAAAAAAABwhZAAAAAAAAAAAAHCBkAQAAAAAAAAAAcICQBQAAAAAAAAAAwAFCFgAAAAAAAAAAAAcIWQAAAAAAAAAAABwgZAEAAAAAAAAAAHCAkAUAAAAAAAAAAMABQhYAAAAAAAAAAAAHCFkAAAAAAAAAAAAcIGQBAAAAAAAAAABwgJAFAAAAAAAAAADAAUIWAAAAAAAAAAAABwhZAAAAAAAAAAAAHCBkAQAAAAAAAAAAcICQBQAAAAAAAAAAwAFCFgAAAAAAAAAAAAcIWQAAAAAAAAAAABwgZAEAAAAAAAAAAHCAkAUAAAAAAAAAAMABQhYAAAAAAAAAAAAHCFkAAAAAAAAAAAAcIGQBAAAAAAAAAABwgJAFAAAAAAAAAADAAUIWAAAAAAAAAAAABwhZAAAAAAAAAAAAHCBkAQAAAAAAAAAAcICQBQAAAAAAAAAAwAFCFgAAAAAAAAAAAAcIWQAAAAAAAAAAABwgZAEAAAAAAAAAAHCAkAUAAAAAAAAAAMABQhYAAAAAAAAAAAAHCFkAAAAAAAAAAAAcIGQBAAAAAAAAAABwgJAFAAAAAAAAAADAAUIWAAAAAAAAAAAABwhZAAAAAAAAAAAAHCBkAQAAAAAAAAAAcICQBQAAAAAAAAAAwAFCFgAAAAAAAAAAAAcIWQAAAAAAAAAAABwgZAEAAAAAAAAAAHCAkAUAAAAAAAAAAMABQhYAAAAAAAAAAAAHCFkAAAAAAAAAAAAcIGQBAAAAAAAAAABwgJAFAAAAAAAAAADAAUIWAAAAAAAAAAAABwhZAAAAAAAAAAAAHCBkAQAAAAAAAAAAcICQBQAAAAAAAAAAwAFCFgAAAAAAAAAAAAcIWQAAAAAAAAAAABwgZAEAAAAAAAAAAHCAkAUAAAAAAAAAAMABQhYAAAAAAAAAAAAHCFkAAAAAAAAAAAAcIGQBAAAAAAAAAABwgJAFAAAAAAAAAADAAUIWAAAAAAAAAAAABwhZAAAAAAAAAAAAHCBkAQAAAAAAAAAAcICQBQAAAAAAAAAAwAFCFgAAAAAAAAAAAAcIWQAAAAAAAAAAABwgZAEAAAAAAAAAAHCAkAUAAAAAAAAAAMABQhYAAAAAAAAAAAAHCFkAAAAAAAAAAAAcIGQBAAAAAAAAAABwgJAFAAAAAAAAAADAAUIWAAAAAAAAAAAABwhZAAAAAAAAAAAAHCBkAQAAAAAAAAAAcICQBQAAAAAAAAAAwAFCFgAAAAAAAAAAAAcIWQAAAAAAAAAAABwgZAEAAAAAAAAAAHCAkAUAAAAAAAAAAMABQhYAAAAAAAAAAAAHCFkAAAAAAAAAAAAcIGQBAAAAAAAAAABwgJAFAAAAAAAAAADAAUIWAAAAAAAAAAAABwhZAAAAAAAAAAAAHCBkAQAAAAAAAAAAcICQBQAAAAAAAAAAwAFCFgAAAAAAAAAAAAcIWQAAAAAAAAAAABwgZAEAAAAAAAAAAHCAkAUAAAAAAAAAAMABQhYAAAAAAAAAAAAHCFkAAAAAAAAAAAAcIGQBAAAAAAAAAABwgJAFAAAAAAAAAADAAUIWAAAAAAAAAAAABwhZAAAAAAAAAAAAHCBkAQAAAAAAAAAAcICQBQAAAAAAAAAAwAFCFgAAAAAAAAAAAAcIWQAAAAAAAAAAABwgZAEAAAAAAAAAAHCAkAUAAAAAAAAAAMABQhYAAAAAAAAAAAAHCFkAAAAAAAAAAAAcIGQBAAAAAAAAAABwgJAFAAAAAAAAAADAAUIWAAAAAAAAAAAABwhZAAAAAAAAAAAAHCBkAQAAAAAAAAAAcICQBQAAAAAAAAAAwAFCFgAAAAAAAAAAAAcIWQAAAAAAAAAAABwgZAEAAAAAAAAAAHCAkAUAAAAAAAAAAMABQhYAAAAAAAAAAAAHCFkAAAAAAAAAAAAcIGQBAAAAAAAAAABwgJAFAAAAAAAAAADAAUIWAAAAAAAAAAAABwhZAAAAAAAAAAAAHBjQkGXdunW68cYbNXLkSBmGoZdeeqndetu29aMf/UgjRoxQamqqFi9erL1797bb5uTJk7rrrruUlZWl7OxsffWrX1VTU1M/fgoAAAAAAAAAAHAxGtCQpbm5WdOnT9evfvWrTtf/7Gc/0y9/+Us9+uij2rhxo9LT07Vs2TKFw+HkNnfddZd27NihN998U6+88orWrVunr3/96/31EQAAAAAAAAAAwEXKsG3bHuhBSJJhGHrxxRe1fPlySa1VLCNHjtR3v/tdfe9735MkBYNBFRQU6KmnntKdd96pTz/9VGVlZdq0aZNmzZolSVq1apWuu+46HT16VCNHjuzWezc0NCgQCCgYDCorK6tPPh8AAAAAAAAAABgaupsbDNo5WSoqKlRVVaXFixcnlwUCAc2ZM0cbNmyQJG3YsEHZ2dnJgEWSFi9eLJfLpY0bN3a570gkooaGhnY3AAAAAAAAAACAnhi0IUtVVZUkqaCgoN3ygoKC5Lqqqirl5+e3W+/xeDR8+PDkNp155JFHFAgEkrfi4uJeHj0AAAAAAAAAALjQDdqQpS899NBDCgaDyduRI0cGekgAAAAAAAAAAGCIGbQhS2FhoSSpurq63fLq6urkusLCQtXU1LRbH4/HdfLkyeQ2nfH7/crKymp3AwAAAAAAAAAA6IlBG7KUlpaqsLBQq1evTi5raGjQxo0bNW/ePEnSvHnzVF9fry1btiS3efvtt2VZlubMmdPvYwYAAAAAAAAAABcPz0C+eVNTk/bt25d8XlFRoW3btmn48OEqKSnRt7/9bf3kJz/R+PHjVVpaqh/+8IcaOXKkli9fLkmaPHmyrrnmGt1333169NFHFYvF9MADD+jOO+/UyJEjB+hTAQAAAAAAAACAi8GAhiybN2/WokWLks8ffPBBSdLdd9+tp556St///vfV3Nysr3/966qvr9fnPvc5rVq1SikpKcnX/Nd//ZceeOABXX311XK5XLr11lv1y1/+st8/CwAAAAAAAAAAuLgYtm3bAz2IgdbQ0KBAIKBgMMj8LAAAAAAAAAAAXOS6mxsM2jlZAAAAAAAAAAAABjNCFgAAAAAAAAAAAAcIWQAAAAAAAAAAABwgZAEAAAAAAAAAAHCAkAUAAAAAAAAAAMABQhYAAAAAAAAAAAAHCFkAAAAAAAAAAAAcIGQBAAAAAAAAAABwgJAFAAAAAAAAAADAAUIWAAAAAAAAAAAABwhZAAAAAAAAAAAAHCBkAQAAAAAAAAAAcICQBQAAAAAAAAAAwAFCFgAAAAAAAAAAAAcIWQAAAAAAAAAAABwgZAEAAAAAAAAAAHCAkAUAAAAAAAAAAMABQhYAAAAAAAAAAAAHCFkAAAAAAAAAAAAcIGQBAAAAAAAAAABwgJAFAAAAAAAAAADAAUIWAAAAAAAAAAAABwhZAAAAAAAAAAAAHCBkAQAAAAAAAAAAcICQBQAAAAAAAAAAwAFCFgAAAAAAAAAAAAcIWQAAAAAAAAAAABwgZAEAAAAAAAAAAHCAkAUAAAAAAAAAAMABQhYAAAAAAAAAAAAHCFkAAAAAAAAAAAAcIGQBAAAAAAAAAABwgJAFAAAAAAAAAADAAUIWAAAAAAAAAAAABwhZAAAAAAAAAAAAHCBkAQAAAAAAAAAAcICQBQAAAAAAAAAAwAFCFgAAAAAAAAAAAAcIWQAAAAAAAAAAABwgZAEAAAAAAAAAAHCAkAUAAAAAAAAAAMABQhYAAAAAAAAAAAAHCFkAAAAAAAAAAAAcIGQBAAAAAAAAAABwgJAFAAAAAAAAAADAAUIWAAAAAAAAAAAABwhZAAAAAAAAAAAAHCBkAQAAAAAAAAAAcICQBQAAAAAAAAAAwAFCFgAAAAAAAAAAAAcIWQAAAAAAAAAAABwgZAEAAAAAAAAAAHCAkAUAAAAAAAAAAMABQhYAAAAAAAAAAAAHCFkAAAAAAAAAAAAcIGQBAAAAAAAAAABwgJAFAAAAAAAAAADAAUIWAAAAAAAAAAAABwhZAAAAAAAAAAAAHCBkAQAAAAAAAAAAcICQBQAAAAAAAAAAwAFCFgAAAAAAAAAAAAcIWQAAAAAAAAAAABwgZAEAAAAAAAAAAHCAkAUAAAAAAAAAAMABQhYAAAAAAAAAAAAHCFkAAAAAAAAAAAAcIGQBAAAAAAAAAABwgJAFAAAAAAAAAADAAUIWAAAAAAAAAAAABwhZAAAAAAAAAAAAHCBkAQAAAAAAAAAAcICQBQAAAAAAAAAAwAFCFgAAAAAAAAAAAAcIWQAAAAAAAAAAABwgZAEAAAAAAAAAAHCAkAUAAAAAAAAAAMABQhYAAAAAAAAAAAAHCFkAAAAAAAAAAAAcIGQBAAAAAAAAAABwgJAFAAAAAAAAAADAAUIWAAAAAAAAAAAABwhZAAAAAAAAAAAAHCBkAQAAAAAAAAAAcICQBQAAAAAAAAAAwAFCFgAAAAAAAAAAAAcIWQAAAAAAAAAAABwgZAEAAAAAAAAAAHCAkAUAAAAAAAAAAMABQhYAAAAAAAAAAAAHCFkAAAAAAAAAAAAcIGQBAAAAAAAAAABwgJAFAAAAAAAAAADAAUIWAAAAAAAAAAAABwhZAAAAAAAAAAAAHCBkAQAAAAAAAAAAcICQBQAAAAAAAAAAwAFCFgAAAAAAAAAAAAcIWQAAAAAAAAAAABwgZAEAAAAAAAAAAHCAkAUAAAAAAAAAAMABQhYAAAAAAAAAAAAHCFkAAAAAAAAAAAAcIGQBAAAAAAAAAABwgJAFAAAAAAAAAADAAUIWAAAAAAAAAAAABwhZAAAAAAAAAAAAHCBkAQAAAAAAAAAAcICQBQAAAAAAAAAAwAFCFgAAAAAAAAAAAAcIWQAAAAAAAAAAABwgZAEAAAAAAAAAAHCAkAUAAAAAAAAAAMABQhYAAAAAAAAAAAAHCFkAAAAAAAAAAAAcIGQBAAAAAAAAAABwgJAFAAAAAAAAAADAAUIWAAAAAAAAAAAABwhZAAAAAAAAAAAAHCBkAQAAAAAAAAAAcICQBQAAAAAAAAAAwAFCFgAAAAAAAAAAAAcIWQAAAAAAAAAAABwgZAEAAAAAAAAAAHCAkAUAAAAAAAAAAMABQhYAAAAAAAAAAAAHCFkAAAAAAAAAAAAcIGQBAAAAAAAAAABwgJAFAAAAAAAAAADAAUIWAAAAAAAAAAAABwhZAAAAAAAAAAAAHCBkAQAAAAAAAAAAcICQBQAAAAAAAAAAwAFCFgAAAAAAAAAAAAcIWQAAAAAAAAAAABwgZAEAAAAAAAAAAHCAkAUAAAAAAAAAAMABQhYAAAAAAAAAAAAHCFkAAAAAAAAAAAAcIGQBAAAAAAAAAABwgJAFAAAAAAAAAADAAUIWAAAAAAAAAAAABwhZAAAAAAAAAAAAHLhgQpZf/epXGj16tFJSUjRnzhx98MEHAz0kAAAAAAAAAABwAbsgQpbnnntODz74oB5++GFt3bpV06dP17Jly1RTUzPQQwMAAAAAAAAAABeoCyJk+ed//mfdd999uvfee1VWVqZHH31UaWlpeuKJJwZ6aAAAAAAAAAAA4ALlGegBnK9oNKotW7booYceSi5zuVxavHixNmzY0OlrIpGIIpFI8nkwGJQkNTQ09O1gAQAAAAAAAADAoJfIC2zbPud2Qz5kOXHihEzTVEFBQbvlBQUF2rVrV6eveeSRR/TjH//4rOXFxcV9MkYAAAAAAAAAADD0NDY2KhAIdLl+yIcsTjz00EN68MEHk88ty9LJkyeVk5MjwzAGcGSDS0NDg4qLi3XkyBFlZWUN9HAAYNDg+AgAZ+PYCACd4/gIAJ3j+IjBzrZtNTY2auTIkefcbsiHLLm5uXK73aqurm63vLq6WoWFhZ2+xu/3y+/3t1uWnZ3dV0Mc8rKysjjQAUAnOD4CwNk4NgJA5zg+AkDnOD5iMDtXBUvCkJ/43ufzqby8XKtXr04usyxLq1ev1rx58wZwZAAAAAAAAAAA4EI25CtZJOnBBx/U3XffrVmzZmn27Nn6xS9+oebmZt17770DPTQAAAAAAAAAAHCBuiBCljvuuEO1tbX60Y9+pKqqKs2YMUOrVq1SQUHBQA9tSPP7/Xr44YfPaq0GABc7jo8AcDaOjQDQOY6PANA5jo+4UBi2bdsDPQgAAAAAAAAAAIChZsjPyQIAAAAAAAAAADAQCFkAAAAAAAAAAAAcIGQBAAAAAAAAAABwgJAFAAAAAAAAAADAAUIWdOlXv/qVRo8erZSUFM2ZM0cffPDBQA8JAPrVunXrdOONN2rkyJEyDEMvvfRSu/W2betHP/qRRowYodTUVC1evFh79+4dmMECQD955JFHdPnllyszM1P5+flavny5du/e3W6bcDis+++/Xzk5OcrIyNCtt96q6urqARoxAPSPf//3f9e0adOUlZWlrKwszZs3TytXrkyu59gIANJPf/pTGYahb3/728llHB8x1BGyoFPPPfecHnzwQT388MPaunWrpk+frmXLlqmmpmaghwYA/aa5uVnTp0/Xr371q07X/+xnP9Mvf/lLPfroo9q4caPS09O1bNkyhcPhfh4pAPSftWvX6v7779f777+vN998U7FYTEuXLlVzc3Nym+985zt6+eWX9fzzz2vt2rU6fvy4vvCFLwzgqAGg7xUVFemnP/2ptmzZos2bN+vzn/+8br75Zu3YsUMSx0YA2LRpk37zm99o2rRp7ZZzfMRQZ9i2bQ/0IDD4zJkzR5dffrn+7d/+TZJkWZaKi4v1zW9+U3/3d383wKMDgP5nGIZefPFFLV++XFJrFcvIkSP13e9+V9/73vckScFgUAUFBXrqqad05513DuBoAaD/1NbWKj8/X2vXrtX8+fMVDAaVl5enZ555Rl/84hclSbt27dLkyZO1YcMGzZ07d4BHDAD9Z/jw4fqnf/onffGLX+TYCOCi1tTUpJkzZ+rXv/61fvKTn2jGjBn6xS9+we+OuCBQyYKzRKNRbdmyRYsXL04uc7lcWrx4sTZs2DCAIwOAwaOiokJVVVXtjpWBQEBz5szhWAngohIMBiW1nkiUpC1btigWi7U7Pk6aNEklJSUcHwFcNEzT1LPPPqvm5mbNmzePYyOAi97999+v66+/vt1xUOJ3R1wYPAM9AAw+J06ckGmaKigoaLe8oKBAu3btGqBRAcDgUlVVJUmdHisT6wDgQmdZlr797W/ryiuv1JQpUyS1Hh99Pp+ys7PbbcvxEcDFYPv27Zo3b57C4bAyMjL04osvqqysTNu2bePYCOCi9eyzz2rr1q3atGnTWev43REXAkIWAAAAAI7cf//9+uSTT/Tuu+8O9FAAYFCYOHGitm3bpmAwqD/+8Y+6++67tXbt2oEeFgAMmCNHjuhb3/qW3nzzTaWkpAz0cIA+QbswnCU3N1dut1vV1dXtlldXV6uwsHCARgUAg0vieMixEsDF6oEHHtArr7yid955R0VFRcnlhYWFikajqq+vb7c9x0cAFwOfz6dx48apvLxcjzzyiKZPn65//dd/5dgI4KK1ZcsW1dTUaObMmfJ4PPJ4PFq7dq1++ctfyuPxqKCggOMjhjxCFpzF5/OpvLxcq1evTi6zLEurV6/WvHnzBnBkADB4lJaWqrCwsN2xsqGhQRs3buRYCeCCZtu2HnjgAb344ot6++23VVpa2m59eXm5vF5vu+Pj7t27dfjwYY6PAC46lmUpEolwbARw0br66qu1fft2bdu2LXmbNWuW7rrrruRjjo8Y6mgXhk49+OCDuvvuuzVr1izNnj1bv/jFL9Tc3Kx77713oIcGAP2mqalJ+/btSz6vqKjQtm3bNHz4cJWUlOjb3/62fvKTn2j8+PEqLS3VD3/4Q40cOVLLly8fuEEDQB+7//779cwzz+jPf/6zMjMzk72yA4GAUlNTFQgE9NWvflUPPvighg8frqysLH3zm9/UvHnzNHfu3AEePQD0nYceekjXXnutSkpK1NjYqGeeeUZr1qzR66+/zrERwEUrMzMzOXdfQnp6unJycpLLOT5iqCNkQafuuOMO1dbW6kc/+pGqqqo0Y8YMrVq16qwJngHgQrZ582YtWrQo+fzBBx+UJN1999166qmn9P3vf1/Nzc36+te/rvr6en3uc5/TqlWr6DML4IL27//+75KkhQsXtlv+5JNP6p577pEk/cu//ItcLpduvfVWRSIRLVu2TL/+9a/7eaQA0L9qamr05S9/WZWVlQoEApo2bZpef/11LVmyRBLHRgDoCsdHDHWGbdv2QA8CAAAAAAAAAABgqGFOFgAAAAAAAAAAAAcIWQAAAAAAAAAAABwgZAEAAAAAAAAAAHCAkAUAAAAAAAAAAMABQhYAAAAAAAAAAAAHCFkAAAAAAAAAAAAcIGQBAAAAAAAAAABwgJAFAAAAAAAAAADAAUIWAAAAAOime+65R8uXL3f02jVr1sgwDBmG0eN9jB49Ovna+vp6R+8PAAAAoPcRsgAAAADoV7W1tfrGN76hkpIS+f1+FRYWatmyZXrvvfcGemj9Yvfu3XrqqaeSz7vzfWzatEkvvPDCAIwWAAAAwLl4BnoAAAAAAC4ut956q6LRqP7zP/9TY8aMUXV1tVavXq26urqBHlq/yM/PV3Z2dvJ5d76PvLw8DR8+fABGCwAAAOBcqGQBAAAA0G/q6+v1l7/8Rf/4j/+oRYsWadSoUZo9e7Yeeugh3XTTTe22+9rXvqa8vDxlZWXp85//vD766KN2+3r55Zd1+eWXKyUlRbm5ubrllluS606dOqUvf/nLGjZsmNLS0nTttddq7969yfVPPfWUsrOz9frrr2vy5MnKyMjQNddco8rKyuQ2pmnqwQcfVHZ2tnJycvT9739ftm23G8Mf//hHTZ06VampqcrJydHixYvV3Nzc698HAAAAgMGJkAUAAABAv8nIyFBGRoZeeuklRSKRLre77bbbVFNTo5UrV2rLli2aOXOmrr76ap08eVKS9Oqrr+qWW27Rddddpw8//FCrV6/W7Nmzk6+/5557tHnzZq1YsUIbNmyQbdu67rrrFIvFktu0tLTo//yf/6Pf/e53WrdunQ4fPqzvfe97yfU///nP9dRTT+mJJ57Qu+++q5MnT+rFF19Mrq+srNSXvvQlfeUrX9Gnn36qNWvW6Atf+MJZQUxvfB8AAAAABifD7slfAAAAAABwnl544QXdd999CoVCmjlzphYsWKA777xT06ZNkyS9++67uv7661VTUyO/35983bhx4/T9739fX//613XFFVdozJgxevrpp8/a/969ezVhwgS99957uuKKKyRJdXV1Ki4u1n/+53/qtttu01NPPaV7771X+/bt09ixYyVJv/71r/W//tf/UlVVlSRp5MiR+s53vqO/+Zu/kSTF43GVlpaqvLxcL730krZu3ary8nIdPHhQo0aN+szPvWbNGi1atEinTp1q1y7ss76Pz3o9AAAAgIFDJQsAAACAfnXrrbfq+PHjWrFiha655hqtWbNGM2fOTE4G/9FHH6mpqUk5OTnJSo+MjAxVVFRo//79kqRt27bp6quv7nT/n376qTwej+bMmZNclpOTo4kTJ+rTTz9NLktLS0sGLJI0YsQI1dTUSJKCwaAqKyvb7cPj8WjWrFnJ59OnT9fVV1+tqVOn6rbbbtN//Md/6NSpU73+fQAAAAAYvAhZAAAAAPS7lJQULVmyRD/84Q+1fv163XPPPXr44YclSU1NTRoxYoS2bdvW7rZ79+5kVUlqaup5j8Hr9bZ7bhhGj1p9ud1uvfnmm1q5cqXKysr0f//v/9XEiRNVUVHR47Gc6/sAAAAAMHgRsgAAAAAYcGVlZckJ42fOnKmqqip5PB6NGzeu3S03N1eSNG3aNK1evbrTfU2ePFnxeFwbN25MLqurq9Pu3btVVlbWrfEEAgGNGDGi3T7i8bi2bNnSbjvDMHTllVfqxz/+sT788EP5fL5287Y41fb7AAAAADB4eQZ6AAAAAAAuHnV1dbrtttv0la98RdOmTVNmZqY2b96sn/3sZ7r55pslSYsXL9a8efO0fPly/exnP9OECRN0/Pjx5GT3s2bN0sMPP6yrr75aY8eO1Z133ql4PK7XXntNf/u3f6vx48fr5ptv1n333aff/OY3yszM1N/93d/pkksuSb5Hd3zrW9/ST3/6U40fP16TJk3SP//zP6u+vj65fuPGjVq9erWWLl2q/Px8bdy4UbW1tZo8eXKvfh8AAAAABi9CFgAAAAD9JiMjQ3PmzNG//Mu/aP/+/YrFYiouLtZ9992nH/zgB5Jaq0Nee+01/Y//8T907733qra2VoWFhZo/f74KCgokSQsXLtTzzz+v//2//7d++tOfKisrS/Pnz0++z5NPPqlvfetbuuGGGxSNRjV//ny99tprZ7UIO5fvfve7qqys1N133y2Xy6WvfOUruuWWWxQMBiVJWVlZWrdunX7xi1+ooaFBo0aN0s9//nNde+21vfp9AAAAABi8DLsnTYcBAAAAAI6sWbNGixYt0qlTp5Sdnd3vrwcAAADQ+5iTBQAAAAD6UVFRkb70pS/16DWXXnppjypkAAAAAPQPKlkAAAAAoB+EQiEdO3ZMUmubsMLCwm6/9tChQ4rFYpKkMWPGyOXiejkAAABgMCBkAQAAAAAAAAAAcIDLnwAAAAAAAAAAABwgZAEAAAAAAAAAAHCAkAUAAAAAAAAAAMABQhYAAAAAAAAAAAAHCFkAAAAAAAAAAAAcIGQBAAAAAAAAAABwgJAFAAAAAAAAAADAAUIWAAAAAAAAAAAAB/5/gPg8+3czABoAAAAASUVORK5CYII=" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "### 3. Plot the outputs of the simulation models\n", + "simulation_data = [\n", + " mean_of_chunks(host_data[0]['power_draw'], 1000),\n", + " mean_of_chunks(host_data[1]['power_draw'], 1000),\n", + " mean_of_chunks(host_data[2]['power_draw'], 1000),\n", + " mean_of_chunks(host_data[3]['power_draw'], 1000),\n", + "]\n", + "\n", + "plot_multi_model(simulation_data)\n", + "areEqual = host_data[0].equals(host_data[3])\n", + "print(areEqual)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-04-19T10:30:34.200347Z", + "start_time": "2024-04-19T10:30:34.036843Z" + } + }, + "id": "d46afc205586d40a", + "execution_count": 6 + }, + { + "cell_type": "code", + "outputs": [], + "source": [ + "host_data[0]" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-04-18T18:46:28.085976Z", + "start_time": "2024-04-18T18:46:28.085921Z" + } + }, + "id": "258b4dc49154822a", + "execution_count": null + }, + { + "cell_type": "code", + "outputs": [], + "source": [ + "# print host_data as a table\n", + "service_data[0]\n" + ], + "metadata": { + "collapsed": false + }, + "id": "7f7dcf086ce45547", + "execution_count": null + }, + { + "cell_type": "code", + "outputs": [], + "source": [], + "metadata": { + "collapsed": false + }, + "id": "540df677d458c972", + "execution_count": null + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/opendc-experiments/opendc-experiments-scenario/src/main/kotlin/org/opendc/experiments/scenario/ScenarioCli.kt b/opendc-experiments/opendc-experiments-scenario/src/main/kotlin/org/opendc/experiments/scenario/ScenarioCli.kt index 16d2915c..bd05824b 100644 --- a/opendc-experiments/opendc-experiments-scenario/src/main/kotlin/org/opendc/experiments/scenario/ScenarioCli.kt +++ b/opendc-experiments/opendc-experiments-scenario/src/main/kotlin/org/opendc/experiments/scenario/ScenarioCli.kt @@ -58,7 +58,9 @@ internal class ScenarioCommand : CliktCommand(name = "scenario") { .default(Runtime.getRuntime().availableProcessors() - 1) override fun run() { - val scenario = getScenario(scenarioPath) - runScenario(scenario, parallelism) + // TODO: clean the simulation-results folder? + val scenarios = getScenario(scenarioPath) + runScenario(scenarios, parallelism) + // TODO: implement outputResults(scenario) // this will take the results, from a folder, and output them visually } } |