From 0080f1099258f363167f8bdc8ded18c1defcdcaf Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Mon, 23 Jun 2025 17:11:10 -0500 Subject: [PATCH 01/37] first line change --- simulation/kubernetes/src/scheduler/fairsharescheduler.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/simulation/kubernetes/src/scheduler/fairsharescheduler.py b/simulation/kubernetes/src/scheduler/fairsharescheduler.py index 1ddca69..fe1e3d0 100644 --- a/simulation/kubernetes/src/scheduler/fairsharescheduler.py +++ b/simulation/kubernetes/src/scheduler/fairsharescheduler.py @@ -1,4 +1,4 @@ -from .scheduler import Scheduler +from scheduler import Scheduler # Assigns jobs to a random node, irrespective of its load class FairshareScheduler(Scheduler): From 990ea027b45f75997733b27f8f9d68248d1527a2 Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Mon, 23 Jun 2025 17:17:49 -0500 Subject: [PATCH 02/37] redo change --- simulation/kubernetes/src/scheduler/fairsharescheduler.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/simulation/kubernetes/src/scheduler/fairsharescheduler.py b/simulation/kubernetes/src/scheduler/fairsharescheduler.py index fe1e3d0..1ddca69 100644 --- a/simulation/kubernetes/src/scheduler/fairsharescheduler.py +++ b/simulation/kubernetes/src/scheduler/fairsharescheduler.py @@ -1,4 +1,4 @@ -from scheduler import Scheduler +from .scheduler import Scheduler # Assigns jobs to a random node, irrespective of its load class FairshareScheduler(Scheduler): From 72606ddf03eb11dd039f27fcf0e30ab904002dbe Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Tue, 24 Jun 2025 10:47:07 -0500 Subject: [PATCH 03/37] new changes to help with tensorboard --- simulation/kubernetes/README.md | 11 +++++++++++ simulation/kubernetes/requirements.txt | 3 ++- 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/simulation/kubernetes/README.md b/simulation/kubernetes/README.md index 18bff30..1284594 100644 --- a/simulation/kubernetes/README.md +++ b/simulation/kubernetes/README.md @@ -1,6 +1,9 @@ # Edge Simulation with Kubernetes This simulation forms a computing cluster of multiple devices and creates workloads to simulate various scheduling policies for research. Users can create their own scheduler (See [the document](src/scheduler/README.md) for detail). +## Install Dependencies + `pip3 install -r requirements.txt` + ## Quick Start To start a simulation, simply run, @@ -14,6 +17,14 @@ After the simulation is finished (or during the simulation), open Tensorboard to ```bash tensorboard --logdir logs/ ``` +- You should see the link after running this command +- Open the link and see the graphs and plots + +These are useful links about Tensorboard: +https://www.google.com/url?sa=t&source=web&rct=j&opi=89978449&url=https://www.tensorflow.org/tensorboard/get_started&ved=2ahUKEwi2k6HGsYqOAxUPPjQIHZMlI6sQFnoECBIQAQ&usg=AOvVaw2zoEfsLy_AcckWcLnf6tdT + +https://www.google.com/url?sa=t&source=web&rct=j&opi=89978449&url=https://www.datacamp.com/tutorial/tensorboard-tutorial&ved=2ahUKEwinkMXUsYqOAxWEOTQIHbXsBewQFnoECEIQAQ&usg=AOvVaw2SiaeB3BS3Eb2vzAyU_HLc + ## Using a Simple Cluster This cluster creates simulated nodes and workloads. diff --git a/simulation/kubernetes/requirements.txt b/simulation/kubernetes/requirements.txt index 12b0078..11a0bf6 100644 --- a/simulation/kubernetes/requirements.txt +++ b/simulation/kubernetes/requirements.txt @@ -2,4 +2,5 @@ click kubernetes wandb tqdm -tensorboardX \ No newline at end of file +tensorboardX +tensorboard \ No newline at end of file From eea971c8f87b5cf2e53c94398ccd6f773a16adfe Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Tue, 24 Jun 2025 10:48:30 -0500 Subject: [PATCH 04/37] fix error preventing code to run --- simulation/.vscode/launch.json | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 simulation/.vscode/launch.json diff --git a/simulation/.vscode/launch.json b/simulation/.vscode/launch.json new file mode 100644 index 0000000..dc41778 --- /dev/null +++ b/simulation/.vscode/launch.json @@ -0,0 +1,21 @@ +{ + // Use IntelliSense to learn about possible attributes. + // Hover to view descriptions of existing attributes. + // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 + "version": "0.2.0", + "configurations": [ + + { + "name": "Python Debugger: Current File with Arguments", + "type": "debugpy", + "request": "launch", + "program": "${workspaceFolder}/kubernetes/run.py", + "cwd": "${workspaceFolder}/kubernetes", + "console": "integratedTerminal", + "args": [ + "--config", + "/home/kendal/edge_resource_analysis/simulation/kubernetes/mywaggle.yaml" + ] + } + ] +} \ No newline at end of file From a754f186d5064d2727486a968af0636c17859655 Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Tue, 24 Jun 2025 14:40:35 -0500 Subject: [PATCH 05/37] fix line 10 --- simulation/kubernetes/src/scheduler/fairsharescheduler.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/simulation/kubernetes/src/scheduler/fairsharescheduler.py b/simulation/kubernetes/src/scheduler/fairsharescheduler.py index 1ddca69..63f3394 100644 --- a/simulation/kubernetes/src/scheduler/fairsharescheduler.py +++ b/simulation/kubernetes/src/scheduler/fairsharescheduler.py @@ -7,7 +7,7 @@ def __init__(self): def schedule(self, tally, workload, nodes: list): # find the least busy node and assign it the job - cpu_usage = [node.metrics["cpu"] for node in nodes] + cpu_usage = [node.metrics.get("cpu", float("inf")) for node in nodes] minindex = cpu_usage.index(min(cpu_usage)) if nodes[minindex].is_workload_fit(workload): return (workload, nodes[minindex]) From e1efe9b73ac71f9edd83766ec29787f17868db02 Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Tue, 24 Jun 2025 16:01:43 -0500 Subject: [PATCH 06/37] henrys code --- .../src/scheduler/centralized_solver.py | 32 +++++++++++++++++++ .../kubernetes/src/scheduler/dual_node.py | 32 +++++++++++++++++++ 2 files changed, 64 insertions(+) create mode 100644 simulation/kubernetes/src/scheduler/centralized_solver.py create mode 100644 simulation/kubernetes/src/scheduler/dual_node.py diff --git a/simulation/kubernetes/src/scheduler/centralized_solver.py b/simulation/kubernetes/src/scheduler/centralized_solver.py new file mode 100644 index 0000000..775dbf9 --- /dev/null +++ b/simulation/kubernetes/src/scheduler/centralized_solver.py @@ -0,0 +1,32 @@ +import cvxpy as cp +import numpy as np + +class centralized_solver() + + #The stopping condition for the algorithm (e.g., subsequent iterations varying below a set tolerance) + def stopcondition() + return true + + + #The dual descent algorithm + def dual_descent(x,G,constraints,objective) + #initialize lambda to all 0s + lambda = np.zeros(len(G),1) + #Set the stepsize alpha (tunable parameter) + alpha = 1 + #until we hit the stopping condition, repeat + while self.stopcondition() + #Step 1: Primal Update + #create the new problem with updated lambda & solve it + currentobj = cp.Maximize(objective + (lambda.transpose @ G @ x)) + currentprob = cp.Problem(currentobj,constraints) + currentprob.solve() + + #Step 2: Sharing Step + # ignored since this is a centralized implementation + + #Step 3: Dual Update + lambda = lambda - alpha * G @ x.value + + #once we're done, return the solved-for values of x + return x.value diff --git a/simulation/kubernetes/src/scheduler/dual_node.py b/simulation/kubernetes/src/scheduler/dual_node.py new file mode 100644 index 0000000..775dbf9 --- /dev/null +++ b/simulation/kubernetes/src/scheduler/dual_node.py @@ -0,0 +1,32 @@ +import cvxpy as cp +import numpy as np + +class centralized_solver() + + #The stopping condition for the algorithm (e.g., subsequent iterations varying below a set tolerance) + def stopcondition() + return true + + + #The dual descent algorithm + def dual_descent(x,G,constraints,objective) + #initialize lambda to all 0s + lambda = np.zeros(len(G),1) + #Set the stepsize alpha (tunable parameter) + alpha = 1 + #until we hit the stopping condition, repeat + while self.stopcondition() + #Step 1: Primal Update + #create the new problem with updated lambda & solve it + currentobj = cp.Maximize(objective + (lambda.transpose @ G @ x)) + currentprob = cp.Problem(currentobj,constraints) + currentprob.solve() + + #Step 2: Sharing Step + # ignored since this is a centralized implementation + + #Step 3: Dual Update + lambda = lambda - alpha * G @ x.value + + #once we're done, return the solved-for values of x + return x.value From f932704e1a4b00437944675b326139e3663ad298 Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Tue, 24 Jun 2025 16:09:00 -0500 Subject: [PATCH 07/37] henrys code --- .../src/scheduler/centralized_solver.py | 5 +-- .../kubernetes/src/scheduler/dual_node.py | 45 +++++++++++++++---- 2 files changed, 38 insertions(+), 12 deletions(-) diff --git a/simulation/kubernetes/src/scheduler/centralized_solver.py b/simulation/kubernetes/src/scheduler/centralized_solver.py index 775dbf9..a89b36d 100644 --- a/simulation/kubernetes/src/scheduler/centralized_solver.py +++ b/simulation/kubernetes/src/scheduler/centralized_solver.py @@ -3,12 +3,11 @@ class centralized_solver() - #The stopping condition for the algorithm (e.g., subsequent iterations varying below a set tolerance) +# The stopping condition for the algorithm (e.g., subsequent iterations varying below a set tolerance) def stopcondition() return true - - #The dual descent algorithm +# The dual descent algorithm def dual_descent(x,G,constraints,objective) #initialize lambda to all 0s lambda = np.zeros(len(G),1) diff --git a/simulation/kubernetes/src/scheduler/dual_node.py b/simulation/kubernetes/src/scheduler/dual_node.py index 775dbf9..ef2a775 100644 --- a/simulation/kubernetes/src/scheduler/dual_node.py +++ b/simulation/kubernetes/src/scheduler/dual_node.py @@ -1,32 +1,59 @@ import cvxpy as cp import numpy as np -class centralized_solver() +class node() + + def __init__(self,constraints,x,objective,G,id) + self.constraints = constraints + self.x = x + self.objective = objective + self.G = G + self.id = id + #The stopping condition for the algorithm (e.g., subsequent iterations varying below a set tolerance) + #This has to look at a global perspective, and so requires communication for whether everyone is done or not def stopcondition() return true + #The sharing function that handles how nodes share x values with each other. + #This takes as input this node's updated x value(s), and returns the full x vector + #relevant to this node, including its own x value(s) + def share(my_x) + return 1 + #The dual descent algorithm - def dual_descent(x,G,constraints,objective) + def dual_descent() #initialize lambda to all 0s - lambda = np.zeros(len(G),1) + lambda = np.zeros(len(self.G),1) #Set the stepsize alpha (tunable parameter) alpha = 1 - #until we hit the stopping condition, repeat + #Define indexing that lets us grab either all x_i or all other x except x_i + #This is left unspecified since the ordering for x & G may change. However, + #I would recommend using the ordering presented in the CDC paper, since it + #works with how I've defined the updates for currentobj and lambda. + x_i = [] + x_ibar = [] + #initialize this node's current understanding of all other relevant nodes' x + #This is needed to perform the primal and dual updates properly. + currentx = zeros(G.shape[1],1) + while self.stopcondition() #Step 1: Primal Update - #create the new problem with updated lambda & solve it - currentobj = cp.Maximize(objective + (lambda.transpose @ G @ x)) + #Create the current objective with current lambda + currentobj = cp.Maximize(self.objective + (lambda.transpose @ G @ x)) + #Fix all x other than this node's own copies + constraints = [constraints, x[x_ibar] == currentx[x_ibar]] + #solve currentprob = cp.Problem(currentobj,constraints) currentprob.solve() #Step 2: Sharing Step - # ignored since this is a centralized implementation + currentx = self.share(x.value) #Step 3: Dual Update - lambda = lambda - alpha * G @ x.value + lambda = lambda - alpha * G @ currentx - #once we're done, return the solved-for values of x + #once complete, return this node's own decision (but not others) return x.value From eb87c221d487ea142e356c56f3d83c78a5354be8 Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Wed, 25 Jun 2025 16:17:04 -0500 Subject: [PATCH 08/37] fix henrys code --- .../src/scheduler/centralized_solver.py | 56 ++++++++++++------- .../kubernetes/src/scheduler/dual_node.py | 24 ++++---- 2 files changed, 49 insertions(+), 31 deletions(-) diff --git a/simulation/kubernetes/src/scheduler/centralized_solver.py b/simulation/kubernetes/src/scheduler/centralized_solver.py index a89b36d..d55ff32 100644 --- a/simulation/kubernetes/src/scheduler/centralized_solver.py +++ b/simulation/kubernetes/src/scheduler/centralized_solver.py @@ -1,31 +1,49 @@ import cvxpy as cp import numpy as np -class centralized_solver() +class centralized_solver: + # Initialize the solver with a tolerance and maximum iterations + # tolerance: the threshold for stopping the algorithm + # max_iters: the maximum number of iterations to run + + def __init__(self, tolerance=1e-3, max_iters=100): + self.tolerance = tolerance + self.max_iters = max_iters # The stopping condition for the algorithm (e.g., subsequent iterations varying below a set tolerance) - def stopcondition() - return true +def stopcondition(self, prev_x, current_x): + if prev_x is None: + return False + return np.linalg.norm(prev_x - current_x) < self.tolerance # The dual descent algorithm - def dual_descent(x,G,constraints,objective) - #initialize lambda to all 0s - lambda = np.zeros(len(G),1) - #Set the stepsize alpha (tunable parameter) +def dual_descent(self, x, G, constraints, objective): + # initialize lambda to all 0s + lambda_vec = np.zeros((G.shape[0], 1)) + # Set the stepsize alpha (tunable parameter) alpha = 1 - #until we hit the stopping condition, repeat - while self.stopcondition() - #Step 1: Primal Update - #create the new problem with updated lambda & solve it - currentobj = cp.Maximize(objective + (lambda.transpose @ G @ x)) - currentprob = cp.Problem(currentobj,constraints) - currentprob.solve() + prev_x = None + + # until we hit the stopping condition, repeat + while not self.stopcondition(prev_x, x.value): + # Step 1: Primal Update + # create the new problem with updated lambda & solve it + current_obj = cp.Maximize(objective + cp.matmul(lambda_vec.T, G @ x)) + prob = cp.Problem(current_obj, constraints) + prob.solve() + + # Step 2: Sharing Step + # ignored since this is a centralized implementation + if x.value is None: + raise RuntimeError("Solver failed to compute x") - #Step 2: Sharing Step - # ignored since this is a centralized implementation + # Step 3: Dual Update + lambda_vec = lambda_vec - alpha * (G @ x.value) - #Step 3: Dual Update - lambda = lambda - alpha * G @ x.value + # Step 3: Check Stopping Condition + if self.stopcondition(prev_x, x.value): + break + prev_x = x.value.copy() - #once we're done, return the solved-for values of x + # once we're done, return the solved-for values of x return x.value diff --git a/simulation/kubernetes/src/scheduler/dual_node.py b/simulation/kubernetes/src/scheduler/dual_node.py index ef2a775..bf4ebff 100644 --- a/simulation/kubernetes/src/scheduler/dual_node.py +++ b/simulation/kubernetes/src/scheduler/dual_node.py @@ -1,9 +1,9 @@ import cvxpy as cp import numpy as np -class node() +class Node: - def __init__(self,constraints,x,objective,G,id) + def __init__(self,constraints,x,objective,G,id): self.constraints = constraints self.x = x self.objective = objective @@ -13,20 +13,20 @@ def __init__(self,constraints,x,objective,G,id) #The stopping condition for the algorithm (e.g., subsequent iterations varying below a set tolerance) #This has to look at a global perspective, and so requires communication for whether everyone is done or not - def stopcondition() + def stopcondition(self): return true #The sharing function that handles how nodes share x values with each other. #This takes as input this node's updated x value(s), and returns the full x vector #relevant to this node, including its own x value(s) - def share(my_x) + def share(self, my_x): return 1 #The dual descent algorithm - def dual_descent() + def dual_descent(): #initialize lambda to all 0s - lambda = np.zeros(len(self.G),1) + lambda_vec = np.zeros((self.Gshape[0], 1)) #Set the stepsize alpha (tunable parameter) alpha = 1 #Define indexing that lets us grab either all x_i or all other x except x_i @@ -37,23 +37,23 @@ def dual_descent() x_ibar = [] #initialize this node's current understanding of all other relevant nodes' x #This is needed to perform the primal and dual updates properly. - currentx = zeros(G.shape[1],1) + currentx = np.zeros(G.shape[1],1) - while self.stopcondition() + while self.stopcondition(): #Step 1: Primal Update #Create the current objective with current lambda - currentobj = cp.Maximize(self.objective + (lambda.transpose @ G @ x)) + currentobj = cp.Maximize(self.objective + lambda_vec.T @ self.G @ self.x) #Fix all x other than this node's own copies - constraints = [constraints, x[x_ibar] == currentx[x_ibar]] + primal_constraints = self.constraints + [self.x[i] == current_x[i] for i in range(self.G.shape[1]) if i != self.id] #solve - currentprob = cp.Problem(currentobj,constraints) + currentprob = cp.Problem(currentobj, primal_constraints) currentprob.solve() #Step 2: Sharing Step currentx = self.share(x.value) #Step 3: Dual Update - lambda = lambda - alpha * G @ currentx + lambda_vec = lambda_vec - alpha * G @ currentx #once complete, return this node's own decision (but not others) return x.value From 46b2a7c7a65af8114c42dca50a599d0c06d85433 Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Wed, 25 Jun 2025 16:19:27 -0500 Subject: [PATCH 09/37] fix henrys code --- simulation/kubernetes/src/scheduler/dual_node.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/simulation/kubernetes/src/scheduler/dual_node.py b/simulation/kubernetes/src/scheduler/dual_node.py index bf4ebff..2394bea 100644 --- a/simulation/kubernetes/src/scheduler/dual_node.py +++ b/simulation/kubernetes/src/scheduler/dual_node.py @@ -14,7 +14,7 @@ def __init__(self,constraints,x,objective,G,id): #The stopping condition for the algorithm (e.g., subsequent iterations varying below a set tolerance) #This has to look at a global perspective, and so requires communication for whether everyone is done or not def stopcondition(self): - return true + return True #The sharing function that handles how nodes share x values with each other. From 034b66318c70966fd4641ad3207d4ce0fc003a72 Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Wed, 25 Jun 2025 17:49:13 -0500 Subject: [PATCH 10/37] add dual node --- .../kubernetes/src/scheduler/fairsharescheduler.py | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/simulation/kubernetes/src/scheduler/fairsharescheduler.py b/simulation/kubernetes/src/scheduler/fairsharescheduler.py index 63f3394..606e8b4 100644 --- a/simulation/kubernetes/src/scheduler/fairsharescheduler.py +++ b/simulation/kubernetes/src/scheduler/fairsharescheduler.py @@ -1,4 +1,5 @@ from .scheduler import Scheduler +from .dual_node import run_dual_node # Assigns jobs to a random node, irrespective of its load class FairshareScheduler(Scheduler): @@ -17,12 +18,21 @@ def schedule(self, tally, workload, nodes: list): def step(self, workloads: list, cluster): tally = [] virtual_nodes = cluster.nodes.copy() + # 🔹 NEW: Run dual descent for each node before scheduling + + for node in virtual_nodes.values(): + try: + result = run_dual_descent(node) + if result is not None: + print(f"[FairshareScheduler] {node.name} dual descent result:\n{result}") + except Exception as e: + print(f"[FairshareScheduler] Dual descent failed for {node.name}: {e}") + + # 🔹 Schedule workloads as usual for workload in workloads: planned_schedule = self.schedule(tally, workload, list(virtual_nodes.values())) - # If the workload cannot be scheduled, skip it if planned_schedule is None: continue - # Update the virtual node with the new job placement _, virtual_node = planned_schedule virtual_node.place_pod(workload, cluster.current_step) From 7addee9d0926b07619b1099abdcf22105f2532ef Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Mon, 30 Jun 2025 12:43:53 -0500 Subject: [PATCH 11/37] remove line 2 --- simulation/kubernetes/src/scheduler/fairsharescheduler.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/simulation/kubernetes/src/scheduler/fairsharescheduler.py b/simulation/kubernetes/src/scheduler/fairsharescheduler.py index 606e8b4..60799d7 100644 --- a/simulation/kubernetes/src/scheduler/fairsharescheduler.py +++ b/simulation/kubernetes/src/scheduler/fairsharescheduler.py @@ -1,5 +1,5 @@ from .scheduler import Scheduler -from .dual_node import run_dual_node + # Assigns jobs to a random node, irrespective of its load class FairshareScheduler(Scheduler): From 193c472e66382ae02cca723a2281621fd85de3cd Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Mon, 30 Jun 2025 14:53:35 -0500 Subject: [PATCH 12/37] energy tensorboard error dugger --- .../src/scheduler/fairsharescheduler.py | 21 ++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/simulation/kubernetes/src/scheduler/fairsharescheduler.py b/simulation/kubernetes/src/scheduler/fairsharescheduler.py index 60799d7..9f05a52 100644 --- a/simulation/kubernetes/src/scheduler/fairsharescheduler.py +++ b/simulation/kubernetes/src/scheduler/fairsharescheduler.py @@ -38,4 +38,23 @@ def step(self, workloads: list, cluster): virtual_node.place_pod(workload, cluster.current_step) tally.append(planned_schedule) - return tally \ No newline at end of file + + for node in virtual_nodes.values(): + cpu = node.metrics.get("cpu", 0) + node.power_watts = cpu * 2.5 + if not hasattr(node, "energy_consumed"): + node.energy_consumed = 0.0 + node.energy_consumed += node.power_watts * 1.0 + + print(f"[ENERGY] {node.name} - CPU: {cpu}, Power: {node.power_watts:.2f}, Energy Consumed: {node.energy_consumed:.2f}") + + if hasattr(cluster, "writer"): + cluster.writer.add_scalar(f"{node.name}/Energy", node.energy_consumed, cluster.current_step) + cluster.writer.add_scalar(f"{node.name}/CPU", cpu, cluster.current_step) + + + return tally + + + + From 26c24d2a7f13a7f0fafd66713ecb27390a0f12b0 Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Mon, 30 Jun 2025 15:31:24 -0500 Subject: [PATCH 13/37] DEBUG error code fix --- .../kubernetes/src/scheduler/fairsharescheduler.py | 2 +- .../kubernetes/src/scheduler/wagglescheduler.py | 14 ++++++++++++++ 2 files changed, 15 insertions(+), 1 deletion(-) diff --git a/simulation/kubernetes/src/scheduler/fairsharescheduler.py b/simulation/kubernetes/src/scheduler/fairsharescheduler.py index 9f05a52..6f89e24 100644 --- a/simulation/kubernetes/src/scheduler/fairsharescheduler.py +++ b/simulation/kubernetes/src/scheduler/fairsharescheduler.py @@ -46,7 +46,7 @@ def step(self, workloads: list, cluster): node.energy_consumed = 0.0 node.energy_consumed += node.power_watts * 1.0 - print(f"[ENERGY] {node.name} - CPU: {cpu}, Power: {node.power_watts:.2f}, Energy Consumed: {node.energy_consumed:.2f}") + print(f"[DEBUG] {node.name} - CPU: {cpu}, Power: {node.power_watts:.2f}, Energy: {node.energy_consumed:.2f}") if hasattr(cluster, "writer"): cluster.writer.add_scalar(f"{node.name}/Energy", node.energy_consumed, cluster.current_step) diff --git a/simulation/kubernetes/src/scheduler/wagglescheduler.py b/simulation/kubernetes/src/scheduler/wagglescheduler.py index 020e4e8..8810f76 100644 --- a/simulation/kubernetes/src/scheduler/wagglescheduler.py +++ b/simulation/kubernetes/src/scheduler/wagglescheduler.py @@ -47,6 +47,20 @@ def step(self, workloads: list, cluster): decisions.append(decision) _, virtual_node = decision virtual_node.place_pod(workload, cluster.current_step) + # 🔋 Energy tracking + for node in virtual_nodes.values(): + cpu = node.metrics.get("cpu", 0) + node.power_watts = cpu * 2.5 + if not hasattr(node, "energy_consumed"): + node.energy_consumed = 0.0 + node.energy_consumed += node.power_watts * 1.0 + + print(f"[DEBUG] {node.name} CPU: {cpu}, Power: {node.power_watts:.2f}, Energy: {node.energy_consumed:.2f}") + + if hasattr(cluster, "writer"): + cluster.writer.add_scalar(f"{node.name}/Energy", node.energy_consumed, cluster.current_step) + cluster.writer.add_scalar(f"{node.name}/CPU", cpu, cluster.current_step) + return decisions def evaluate(self, cluster): From d608c43fd78274ef12259335bae91867a87990aa Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Mon, 30 Jun 2025 16:30:54 -0500 Subject: [PATCH 14/37] fix bug --- simulation/kubernetes/src/scheduler/fairsharescheduler.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/simulation/kubernetes/src/scheduler/fairsharescheduler.py b/simulation/kubernetes/src/scheduler/fairsharescheduler.py index 6f89e24..dc48b55 100644 --- a/simulation/kubernetes/src/scheduler/fairsharescheduler.py +++ b/simulation/kubernetes/src/scheduler/fairsharescheduler.py @@ -47,7 +47,7 @@ def step(self, workloads: list, cluster): node.energy_consumed += node.power_watts * 1.0 print(f"[DEBUG] {node.name} - CPU: {cpu}, Power: {node.power_watts:.2f}, Energy: {node.energy_consumed:.2f}") - + if hasattr(cluster, "writer"): cluster.writer.add_scalar(f"{node.name}/Energy", node.energy_consumed, cluster.current_step) cluster.writer.add_scalar(f"{node.name}/CPU", cpu, cluster.current_step) From 050dcbb4220d46b15e5cf1be8f8863abe5772189 Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Wed, 2 Jul 2025 10:10:27 -0500 Subject: [PATCH 15/37] Debug energy and fix code line 103 --- simulation/kubernetes/src/cluster/devicemodel/xaviernx.py | 6 ++++-- simulation/kubernetes/src/scheduler/dual_node.py | 2 +- simulation/kubernetes/src/scheduler/fairsharescheduler.py | 2 +- 3 files changed, 6 insertions(+), 4 deletions(-) diff --git a/simulation/kubernetes/src/cluster/devicemodel/xaviernx.py b/simulation/kubernetes/src/cluster/devicemodel/xaviernx.py index 2f1c8cc..3d37f34 100644 --- a/simulation/kubernetes/src/cluster/devicemodel/xaviernx.py +++ b/simulation/kubernetes/src/cluster/devicemodel/xaviernx.py @@ -90,8 +90,9 @@ def calculate_resource_usage(self): cpu_usage = round(cumulated_cpu / self.capacity_cpu * 100) self.metrics["power"] = self.estimate_power(cpu_usage) - # Update total energy consumption - # The unit is Watt * step. + + # Update total energy consumption, unit is Watt * hour + # The unit is Watt * step (5 mins) # Update the moving average of power consumption if "power_history" not in self.internal_metrics: self.internal_metrics["power_history"] = [] @@ -99,6 +100,7 @@ def calculate_resource_usage(self): if len(self.internal_metrics["power_history"]) > 3: # Assuming a window size of 10 self.internal_metrics["power_history"].pop(0) self.metrics["power_moving_average"] = np.mean(self.internal_metrics["power_history"]) + self.metrics["energy"] = self.metrics["power"] * 0.0833 # Convert to Watt * hour (5 mins = 1/12 hour) def update(self, step, events: list): # Update the resource usage of the node diff --git a/simulation/kubernetes/src/scheduler/dual_node.py b/simulation/kubernetes/src/scheduler/dual_node.py index 2394bea..8273a30 100644 --- a/simulation/kubernetes/src/scheduler/dual_node.py +++ b/simulation/kubernetes/src/scheduler/dual_node.py @@ -1,7 +1,7 @@ import cvxpy as cp import numpy as np -class Node: +class DualDescent(Scheduler): def __init__(self,constraints,x,objective,G,id): self.constraints = constraints diff --git a/simulation/kubernetes/src/scheduler/fairsharescheduler.py b/simulation/kubernetes/src/scheduler/fairsharescheduler.py index dc48b55..213f837 100644 --- a/simulation/kubernetes/src/scheduler/fairsharescheduler.py +++ b/simulation/kubernetes/src/scheduler/fairsharescheduler.py @@ -39,7 +39,7 @@ def step(self, workloads: list, cluster): tally.append(planned_schedule) - for node in virtual_nodes.values(): + for node in cluster.nodes.values(): cpu = node.metrics.get("cpu", 0) node.power_watts = cpu * 2.5 if not hasattr(node, "energy_consumed"): From e08156667b7aa2da783299a1a26dca995924efce Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Wed, 2 Jul 2025 17:11:23 -0500 Subject: [PATCH 16/37] tensorboard export --- .../kubernetes/src/scripts/CSVexport.py | 33 +++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 simulation/kubernetes/src/scripts/CSVexport.py diff --git a/simulation/kubernetes/src/scripts/CSVexport.py b/simulation/kubernetes/src/scripts/CSVexport.py new file mode 100644 index 0000000..815ea7f --- /dev/null +++ b/simulation/kubernetes/src/scripts/CSVexport.py @@ -0,0 +1,33 @@ +from tensorboard.backend.event_processing.event_accumulator import EventAccumulator +import pandas as pd +import os + +log_dir = "runs/20250702-095535 " # Your log directory + +# Check if the log directory exists before proceeding +if not os.path.exists(log_dir): + raise FileNotFoundError(f"Log directory '{log_dir}' does not exist. Please check the path.") + +def extract_scalar_events(log_dir): + ea = EventAccumulator(log_dir) + ea.Reload() + + scalar_data = {} + + for tag in ea.Tags()['scalars']: + events = ea.Scalars(tag) + scalar_data[tag] = [(e.step, e.value) for e in events] + + return scalar_data + +def save_to_csv(scalar_data, output_dir="csv_output"): + os.makedirs(output_dir, exist_ok=True) + + for tag, values in scalar_data.items(): + df = pd.DataFrame(values, columns=['Step', 'Value']) + csv_path = os.path.join(output_dir, f"{tag.replace('/', '_')}.csv") + df.to_csv(csv_path, index=False) + print(f"Saved: {csv_path}") + +scalar_data = extract_scalar_events(log_dir) +save_to_csv(scalar_data) \ No newline at end of file From 6bb08af549289a0a7f7dddddcaf09b33707bb773 Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Wed, 2 Jul 2025 18:10:31 -0500 Subject: [PATCH 17/37] Refactor CSV export script: improve log directory handling and consolidate scalar extraction into a single function --- .../kubernetes/src/scripts/CSVexport.py | 59 ++++++++++++------- 1 file changed, 38 insertions(+), 21 deletions(-) diff --git a/simulation/kubernetes/src/scripts/CSVexport.py b/simulation/kubernetes/src/scripts/CSVexport.py index 815ea7f..2224b48 100644 --- a/simulation/kubernetes/src/scripts/CSVexport.py +++ b/simulation/kubernetes/src/scripts/CSVexport.py @@ -1,33 +1,50 @@ -from tensorboard.backend.event_processing.event_accumulator import EventAccumulator -import pandas as pd import os +import pandas as pd +from tensorboard.backend.event_processing.event_accumulator import EventAccumulator -log_dir = "runs/20250702-095535 " # Your log directory +log_dir = "home/kendal/edge_resource_analysis/simulation/kubernetes/runs/20250702-171434" #log directory # Check if the log directory exists before proceeding if not os.path.exists(log_dir): - raise FileNotFoundError(f"Log directory '{log_dir}' does not exist. Please check the path.") + print(f"[ERROR] Log directory '{log_dir}' does not exist. Please check the path.") + + +def tensorboard_to_csv(log_dir, output_csv): + print(f"[INFO] Loading TensorBoard logs from: {log_dir}") -def extract_scalar_events(log_dir): ea = EventAccumulator(log_dir) ea.Reload() - scalar_data = {} + all_scalars = [] for tag in ea.Tags()['scalars']: events = ea.Scalars(tag) - scalar_data[tag] = [(e.step, e.value) for e in events] - - return scalar_data - -def save_to_csv(scalar_data, output_dir="csv_output"): - os.makedirs(output_dir, exist_ok=True) - - for tag, values in scalar_data.items(): - df = pd.DataFrame(values, columns=['Step', 'Value']) - csv_path = os.path.join(output_dir, f"{tag.replace('/', '_')}.csv") - df.to_csv(csv_path, index=False) - print(f"Saved: {csv_path}") - -scalar_data = extract_scalar_events(log_dir) -save_to_csv(scalar_data) \ No newline at end of file + for e in events: + all_scalars.append({ + 'step': e.step, + 'tag': tag, + 'value': e.value + }) + + if not all_scalars: + print("[WARN] No scalar data found. Check if the log directory contains event files.") + return + + df = pd.DataFrame(all_scalars) + df.to_csv(output_csv, index=False) + print(f" Export complete. CSV saved to: {output_csv}") + +def pick_log_dir(base_dir, strategy="latest"): + # TODO: Implement logic to pick the log directory based on strategy + # For now, just return the base_dir as a placeholder + return base_dir + +if __name__ == "__main__": + # log folder path + log_dir = pick_log_dir("runs", strategy="latest") # or random logs + output_csv = "waggle_scheduler_metrics.csv" + + if not os.path.exists(log_dir): + print(f"[ERROR] Log directory not found: {log_dir}") + else: + tensorboard_to_csv(log_dir, output_csv) \ No newline at end of file From 120549a05f598d5a7a32763c37e5f7ba7c0e642b Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Wed, 2 Jul 2025 18:43:16 -0500 Subject: [PATCH 18/37] updates --- .../kubernetes/src/scripts/CSVexport.py | 2 +- .../kubernetes/src/scripts/compare_metrics.py | 80 +++++++++++++++++++ 2 files changed, 81 insertions(+), 1 deletion(-) create mode 100644 simulation/kubernetes/src/scripts/compare_metrics.py diff --git a/simulation/kubernetes/src/scripts/CSVexport.py b/simulation/kubernetes/src/scripts/CSVexport.py index 2224b48..97d92d5 100644 --- a/simulation/kubernetes/src/scripts/CSVexport.py +++ b/simulation/kubernetes/src/scripts/CSVexport.py @@ -2,7 +2,7 @@ import pandas as pd from tensorboard.backend.event_processing.event_accumulator import EventAccumulator -log_dir = "home/kendal/edge_resource_analysis/simulation/kubernetes/runs/20250702-171434" #log directory +log_dir = "kubernetes/logs/20250702-171434/events.out.tfevents.1751494474.lemont" #log directory # Check if the log directory exists before proceeding if not os.path.exists(log_dir): diff --git a/simulation/kubernetes/src/scripts/compare_metrics.py b/simulation/kubernetes/src/scripts/compare_metrics.py new file mode 100644 index 0000000..7923013 --- /dev/null +++ b/simulation/kubernetes/src/scripts/compare_metrics.py @@ -0,0 +1,80 @@ +import pandas as pd +import os +import matplotlib.pyplot as plt +import seaborn as sns + +def compute_node_metrics(task_log_path, scheduler_name): + if not os.path.exists(task_log_path): + print(f"[ERROR] Log file not found: {task_log_path}") + return None + + df = pd.read_csv(task_log_path) + + if not {"task_id", "node_id", "start_time", "end_time", "energy_used_j"}.issubset(df.columns): + print(f"[ERROR] Log file missing required columns: {task_log_path}") + return None + + df["exec_time"] = df["end_time"] - df["start_time"] + + grouped = df.groupby("node_id").agg({ + "task_id": "count", + "energy_used_j": "mean", + "exec_time": "mean" + }).reset_index() + + grouped.rename(columns={ + "task_id": "num_tasks", + "energy_used_j": "mean_energy", + "exec_time": "avg_task_time" + }, inplace=True) + + grouped["scheduler"] = scheduler_name + + return grouped + +def compare_schedulers(log_dir, scheduler_list): + all_results = [] + + for scheduler in scheduler_list: + log_path = os.path.join(log_dir, f"{scheduler}_task_log.csv") + metrics = compute_node_metrics(log_path, scheduler) + if metrics is not None: + all_results.append(metrics) + + if not all_results: + print("[ERROR] No results to compare.") + return None + + combined = pd.concat(all_results, ignore_index=True) + + # Save to CSV + combined.to_csv("scheduler_comparison_metrics.csv", index=False) + print("[INFO] Metrics comparison saved to scheduler_comparison_metrics.csv") + + return combined + +def plot_metric(df, metric_name): + plt.figure(figsize=(10, 6)) + sns.barplot(data=df, x="node_id", y=metric_name, hue="scheduler") + plt.title(f"{metric_name.replace('_', ' ').title()} per Node by Scheduler") + plt.ylabel(metric_name.replace("_", " ").title()) + plt.xlabel("Node ID") + plt.tight_layout() + plt.show() + +if __name__ == "__main__": + # List your scheduler names exactly as used in the filenames + schedulers = ["WaggleScheduler", "FairshareScheduler"] + + # Directory where log files like WaggleScheduler_task_log.csv are stored + log_directory = "logs" + + metrics_df = compare_schedulers(log_directory, schedulers) + + if metrics_df is not None: + # Plot each metric + for metric in ["mean_energy", "num_tasks", "avg_task_time"]: + plot_metric(metrics_df, metric) + + + \ No newline at end of file From f5bbbf49b94c5a4feaf7fbb2faf3b11c91e38df7 Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Thu, 3 Jul 2025 10:42:20 -0500 Subject: [PATCH 19/37] Enhance CSV export script: add error handling, implement scheduler comparison, and integrate plotting functionality --- .../kubernetes/src/scripts/CSVexport.py | 104 +++++++++++++++--- 1 file changed, 88 insertions(+), 16 deletions(-) diff --git a/simulation/kubernetes/src/scripts/CSVexport.py b/simulation/kubernetes/src/scripts/CSVexport.py index 97d92d5..558b07e 100644 --- a/simulation/kubernetes/src/scripts/CSVexport.py +++ b/simulation/kubernetes/src/scripts/CSVexport.py @@ -1,13 +1,8 @@ import os import pandas as pd from tensorboard.backend.event_processing.event_accumulator import EventAccumulator - -log_dir = "kubernetes/logs/20250702-171434/events.out.tfevents.1751494474.lemont" #log directory - -# Check if the log directory exists before proceeding -if not os.path.exists(log_dir): - print(f"[ERROR] Log directory '{log_dir}' does not exist. Please check the path.") - +import matplotlib.pyplot as plt +import seaborn as sns def tensorboard_to_csv(log_dir, output_csv): print(f"[INFO] Loading TensorBoard logs from: {log_dir}") @@ -32,19 +27,96 @@ def tensorboard_to_csv(log_dir, output_csv): df = pd.DataFrame(all_scalars) df.to_csv(output_csv, index=False) - print(f" Export complete. CSV saved to: {output_csv}") + print(f"[INFO] Export complete. CSV saved to: {output_csv}") + +def compute_node_metrics(task_log_path, scheduler_name): + if not os.path.exists(task_log_path): + print(f"[ERROR] Log file not found: {task_log_path}") + return None + + df = pd.read_csv(task_log_path) + + required_columns = {"task_id", "node_id", "start_time", "end_time", "energy_used_j"} + if not required_columns.issubset(df.columns): + print(f"[ERROR] Log file missing required columns: {task_log_path}") + return None + + df["exec_time"] = df["end_time"] - df["start_time"] + + grouped = df.groupby("node_id").agg( + num_tasks=('task_id', 'count'), + mean_energy=('energy_used_j', 'mean'), + total_energy=('energy_used_j', 'sum'), + avg_task_time=('exec_time', 'mean'), + total_exec_time=('exec_time', 'sum') + ).reset_index() + + grouped["task_efficiency"] = grouped["num_tasks"] / grouped["total_exec_time"] + grouped["scheduler"] = scheduler_name + + return grouped + +def compare_schedulers(log_dir, scheduler_list): + all_results = [] + + for scheduler in scheduler_list: + log_path = os.path.join(log_dir, f"{scheduler}_task_log.csv") + metrics = compute_node_metrics(log_path, scheduler) + if metrics is not None: + all_results.append(metrics) + + if not all_results: + print("[ERROR] No scheduler data to compare.") + return None + + combined = pd.concat(all_results, ignore_index=True) + + comparison_path = os.path.join(log_dir, "scheduler_comparison_metrics.csv") + combined.to_csv(comparison_path, index=False) + print(f"[INFO] Comparison metrics saved to: {comparison_path}") + + return combined + +def plot_metrics(df, metric_list): + for metric in metric_list: + plt.figure(figsize=(10, 6)) + sns.barplot(data=df, x="node_id", y=metric, hue="scheduler") + plt.title(f"{metric.replace('_', ' ').title()} per Node by Scheduler") + plt.ylabel(metric.replace('_', ' ').title()) + plt.xlabel("Node ID") + plt.tight_layout() + plt.show() def pick_log_dir(base_dir, strategy="latest"): - # TODO: Implement logic to pick the log directory based on strategy - # For now, just return the base_dir as a placeholder - return base_dir + log_folders = [ + os.path.join(base_dir, f) for f in os.listdir(base_dir) + if os.path.isdir(os.path.join(base_dir, f)) + ] + if not log_folders: + return None + + if strategy == "latest": + return max(log_folders, key=os.path.getmtime) + elif strategy == "random": + import random + return random.choice(log_folders) + else: + return base_dir # fallback if __name__ == "__main__": - # log folder path - log_dir = pick_log_dir("runs", strategy="latest") # or random logs + # === Part 1: Export TensorBoard scalars === + log_dir_event_file = "kubernetes/logs/20250702-171434/events.out.tfevents.1751494474.lemont" output_csv = "waggle_scheduler_metrics.csv" - if not os.path.exists(log_dir): - print(f"[ERROR] Log directory not found: {log_dir}") + if os.path.exists(log_dir_event_file): + tensorboard_to_csv(log_dir_event_file, output_csv) else: - tensorboard_to_csv(log_dir, output_csv) \ No newline at end of file + print(f"[ERROR] TensorBoard event file not found: {log_dir_event_file}") + + # === Part 2: Scheduler log comparison (Task 2 & 3) === + log_dir_task = "logs" # folder with task logs like WaggleScheduler_task_log.csv + schedulers = ["WaggleScheduler", "FairshareScheduler"] + + metrics_df = compare_schedulers(log_dir_task, schedulers) + if metrics_df is not None: + plot_metrics(metrics_df, ["mean_energy", "total_energy", "num_tasks", "avg_task_time", "task_efficiency"]) \ No newline at end of file From dfd18f186b64a0a09ec752335d72e25488440ec9 Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Tue, 8 Jul 2025 10:20:58 -0500 Subject: [PATCH 20/37] Refactor DualDescent class: improve initialization, enhance stop condition, and implement scheduling logic --- .../kubernetes/src/scheduler/dual_node.py | 163 ++++++++++++------ 1 file changed, 109 insertions(+), 54 deletions(-) diff --git a/simulation/kubernetes/src/scheduler/dual_node.py b/simulation/kubernetes/src/scheduler/dual_node.py index 8273a30..52c7c27 100644 --- a/simulation/kubernetes/src/scheduler/dual_node.py +++ b/simulation/kubernetes/src/scheduler/dual_node.py @@ -1,59 +1,114 @@ import cvxpy as cp import numpy as np + + class DualDescent(Scheduler): - def __init__(self,constraints,x,objective,G,id): - self.constraints = constraints - self.x = x - self.objective = objective - self.G = G - self.id = id - - - #The stopping condition for the algorithm (e.g., subsequent iterations varying below a set tolerance) - #This has to look at a global perspective, and so requires communication for whether everyone is done or not - def stopcondition(self): - return True - - - #The sharing function that handles how nodes share x values with each other. - #This takes as input this node's updated x value(s), and returns the full x vector - #relevant to this node, including its own x value(s) - def share(self, my_x): - return 1 - - #The dual descent algorithm - def dual_descent(): - #initialize lambda to all 0s - lambda_vec = np.zeros((self.Gshape[0], 1)) - #Set the stepsize alpha (tunable parameter) - alpha = 1 - #Define indexing that lets us grab either all x_i or all other x except x_i - #This is left unspecified since the ordering for x & G may change. However, - #I would recommend using the ordering presented in the CDC paper, since it - #works with how I've defined the updates for currentobj and lambda. - x_i = [] - x_ibar = [] - #initialize this node's current understanding of all other relevant nodes' x - #This is needed to perform the primal and dual updates properly. - currentx = np.zeros(G.shape[1],1) - - while self.stopcondition(): - #Step 1: Primal Update - #Create the current objective with current lambda - currentobj = cp.Maximize(self.objective + lambda_vec.T @ self.G @ self.x) - #Fix all x other than this node's own copies - primal_constraints = self.constraints + [self.x[i] == current_x[i] for i in range(self.G.shape[1]) if i != self.id] - #solve - currentprob = cp.Problem(currentobj, primal_constraints) - currentprob.solve() - - #Step 2: Sharing Step - currentx = self.share(x.value) - - #Step 3: Dual Update - lambda_vec = lambda_vec - alpha * G @ currentx - - #once complete, return this node's own decision (but not others) - return x.value + def __init__(self, constraints, x, objective, G, node_id): + + + """ + Initialize the Dual Descent scheduler. + Args: + + constraints (list): List of cvxpy constraints for this node. + + x (cvxpy.Variable): Decision variable(s) for this node. + + objective (cvxpy.Expression): Objective function for this node. + + G (np.ndarray): Coupling matrix between nodes. + + node_id (int): Identifier/index of this node. + + """ + + + self.constraints = constraints + + self.x = x + + self.objective = objective + + self.G = G + + self.node_id = node_id + + self.lambda_vec = np.zeros((G.shape[0], 1)) + + self.alpha = 1 # Step size (can be tuned) + + self.current_x = np.zeros((G.shape[1], 1)) # Estimates of all nodes' variables + + + def stopcondition(self): + + + + #Define stopping condition for the dual descent algorithm. # Returns: bool: True if stopping condition is met, False otherwise. + # This could be based on convergence criteria, maximum iterations, or tolerance level. + #Currently always returns True (should be replaced with actual logic) + + + # TODO: Implement convergence check based on tolerance or max iterations + + return True + + + def share(self, my_x): + + #Share updated decision variables with other nodes. my_x (np.ndarray): This node's updated decision variables. + # Returns:np.ndarray: Updated global decision vector including this node's value. + + # TODO: Implement communication logic with other nodes + + # For now, just returns 1 as placeholder + + return 1 + + + def schedule(self): + + #Run the dual descent algorithm until stopping condition is met. This method performs primal and dual updates iteratively. + # Returns: np.ndarray: This node's optimized decision variables. + + + while not self.stopcondition(): + + # Step 1: Primal update + + current_obj = cp.Maximize(self.objective + self.lambda_vec.T @ self.G @ self.x) + + + + # Fix x variables for other nodes to current estimates + + primal_constraints = self.constraints + [ + + self.x[i] == self.current_x[i] for i in range(self.G.shape[1]) if i != self.node_id + + ] + + + prob = cp.Problem(current_obj, primal_constraints) + + prob.solve() + + + # Step 2: Share updated x with other nodes + + self.current_x = self.share(self.x.value) + + + + # Step 3: Dual update + + self.lambda_vec = self.lambda_vec - self.alpha * self.G @ self.current_x + + + # Return this node's decision variable value + return self.x.value + + + From 268eefcf93dcb18cdc2af845f3e2b7d7b9681536 Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Tue, 8 Jul 2025 13:51:24 -0500 Subject: [PATCH 21/37] Refactor DualDescent class: implement convergence check in stop condition and enhance initialization parameters --- .../kubernetes/src/scheduler/dual_node.py | 73 +++++-------------- 1 file changed, 20 insertions(+), 53 deletions(-) diff --git a/simulation/kubernetes/src/scheduler/dual_node.py b/simulation/kubernetes/src/scheduler/dual_node.py index 52c7c27..eb7278e 100644 --- a/simulation/kubernetes/src/scheduler/dual_node.py +++ b/simulation/kubernetes/src/scheduler/dual_node.py @@ -1,60 +1,44 @@ +from scheduler import Scheduler import cvxpy as cp import numpy as np - class DualDescent(Scheduler): - def __init__(self, constraints, x, objective, G, node_id): - - + def __init__(self, constraints, x, objective, G, node_id, tolerance=1e-3, max_iters=100): """ Initialize the Dual Descent scheduler. Args: - constraints (list): List of cvxpy constraints for this node. - x (cvxpy.Variable): Decision variable(s) for this node. - objective (cvxpy.Expression): Objective function for this node. - G (np.ndarray): Coupling matrix between nodes. - node_id (int): Identifier/index of this node. - + tolerance (float): Convergence tolerance. + max_iters (int): Maximum number of iterations. """ - self.constraints = constraints - self.x = x - self.objective = objective - self.G = G - self.node_id = node_id - self.lambda_vec = np.zeros((G.shape[0], 1)) - self.alpha = 1 # Step size (can be tuned) - self.current_x = np.zeros((G.shape[1], 1)) # Estimates of all nodes' variables + self.tolerance = tolerance + self.max_iters = max_iters - - def stopcondition(self): - - - + def stopcondition(self, prev_x, iters): #Define stopping condition for the dual descent algorithm. # Returns: bool: True if stopping condition is met, False otherwise. # This could be based on convergence criteria, maximum iterations, or tolerance level. - #Currently always returns True (should be replaced with actual logic) - - # TODO: Implement convergence check based on tolerance or max iterations - - return True - + if prev_x is not None and self.x.value is not None: + if np.linalg.norm(self.x.value - prev_x) < self.tolerance: + return True + if iters >= self.max_iters: + return True + return False def share(self, my_x): @@ -63,52 +47,35 @@ def share(self, my_x): # TODO: Implement communication logic with other nodes - # For now, just returns 1 as placeholder - - return 1 + # For now, just returns my_x as placeholder + return my_x def schedule(self): - #Run the dual descent algorithm until stopping condition is met. This method performs primal and dual updates iteratively. # Returns: np.ndarray: This node's optimized decision variables. - - - while not self.stopcondition(): + iters = 0 + prev_x = None + while not self.stopcondition(prev_x, iters): # Step 1: Primal update - current_obj = cp.Maximize(self.objective + self.lambda_vec.T @ self.G @ self.x) - - # Fix x variables for other nodes to current estimates primal_constraints = self.constraints + [ - self.x[i] == self.current_x[i] for i in range(self.G.shape[1]) if i != self.node_id - ] - - prob = cp.Problem(current_obj, primal_constraints) - prob.solve() - # Step 2: Share updated x with other nodes - self.current_x = self.share(self.x.value) - - # Step 3: Dual update - self.lambda_vec = self.lambda_vec - self.alpha * self.G @ self.current_x - - + iters += 1 + prev_x = self.x.value.copy() if self.x.value is not None else None # Return this node's decision variable value return self.x.value - - From 7582a1ce345c7f126608d15c69fa4695a3a1c10b Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Wed, 9 Jul 2025 11:44:41 -0500 Subject: [PATCH 22/37] Refactor compare_metrics.py: remove unused functions and streamline logging process --- .../kubernetes/src/scripts/compare_metrics.py | 92 +++++-------------- 1 file changed, 25 insertions(+), 67 deletions(-) diff --git a/simulation/kubernetes/src/scripts/compare_metrics.py b/simulation/kubernetes/src/scripts/compare_metrics.py index 7923013..9702716 100644 --- a/simulation/kubernetes/src/scripts/compare_metrics.py +++ b/simulation/kubernetes/src/scripts/compare_metrics.py @@ -1,80 +1,38 @@ -import pandas as pd -import os -import matplotlib.pyplot as plt -import seaborn as sns +def simulate_scheduler_log(log_dir, scheduler_name, num_steps=10): -def compute_node_metrics(task_log_path, scheduler_name): - if not os.path.exists(task_log_path): - print(f"[ERROR] Log file not found: {task_log_path}") - return None + path = os.path.join(log_dir, scheduler_name) + os.makedirs(path, exist_ok=True) + writer = SummaryWriter(log_dir=path) + for step in range(num_steps): - df = pd.read_csv(task_log_path) + # Simulate scalar logs + loss = 0.5 / (step + 1) + energy = 50 + step * 2 + duration = 5 + (step % 3) - if not {"task_id", "node_id", "start_time", "end_time", "energy_used_j"}.issubset(df.columns): - print(f"[ERROR] Log file missing required columns: {task_log_path}") - return None - df["exec_time"] = df["end_time"] - df["start_time"] + writer.add_scalar("loss", loss, step) + writer.add_scalar("energy_used", energy, step) + writer.add_scalar("task_duration", duration, step) - grouped = df.groupby("node_id").agg({ - "task_id": "count", - "energy_used_j": "mean", - "exec_time": "mean" - }).reset_index() + time.sleep(0.01) # slight delay to vary timestamps + writer.close() - grouped.rename(columns={ - "task_id": "num_tasks", - "energy_used_j": "mean_energy", - "exec_time": "avg_task_time" - }, inplace=True) - - grouped["scheduler"] = scheduler_name - - return grouped - -def compare_schedulers(log_dir, scheduler_list): - all_results = [] - - for scheduler in scheduler_list: - log_path = os.path.join(log_dir, f"{scheduler}_task_log.csv") - metrics = compute_node_metrics(log_path, scheduler) - if metrics is not None: - all_results.append(metrics) - - if not all_results: - print("[ERROR] No results to compare.") - return None - - combined = pd.concat(all_results, ignore_index=True) - - # Save to CSV - combined.to_csv("scheduler_comparison_metrics.csv", index=False) - print("[INFO] Metrics comparison saved to scheduler_comparison_metrics.csv") + print(f"[INFO] Created log at: {path}") +if __name__ == "__main__": + base_log_dir = "generated_logs" + simulate_scheduler_log(base_log_dir, "WaggleScheduler") + simulate_scheduler_log(base_log_dir, "FairshareScheduler") - return combined -def plot_metric(df, metric_name): - plt.figure(figsize=(10, 6)) - sns.barplot(data=df, x="node_id", y=metric_name, hue="scheduler") - plt.title(f"{metric_name.replace('_', ' ').title()} per Node by Scheduler") - plt.ylabel(metric_name.replace("_", " ").title()) - plt.xlabel("Node ID") - plt.tight_layout() - plt.show() -if __name__ == "__main__": - # List your scheduler names exactly as used in the filenames - schedulers = ["WaggleScheduler", "FairshareScheduler"] - # Directory where log files like WaggleScheduler_task_log.csv are stored - log_directory = "logs" - metrics_df = compare_schedulers(log_directory, schedulers) + # === Part 2: Scheduler metrics & data (Task 2) === + # === Part 3: Scheduler log comparison (Task 3) === + log_dir_task = "logs" # folder with task logs like WaggleScheduler_task_log.csv + schedulers = ["WaggleScheduler", "FairshareScheduler"] + metrics_df = compare_schedulers(log_dir_task, schedulers) if metrics_df is not None: - # Plot each metric - for metric in ["mean_energy", "num_tasks", "avg_task_time"]: - plot_metric(metrics_df, metric) - - - \ No newline at end of file + plot_metrics_per_scheduler(metrics_df) \ No newline at end of file From 12eda55cca9fa28b4a4beecbb83a5366800c3ada Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Wed, 9 Jul 2025 13:29:12 -0500 Subject: [PATCH 23/37] Refactor CSV export script: enhance metrics computation, add plotting functionality, and improve logging --- .../kubernetes/src/scripts/CSVexport.py | 141 ++++++++++++++---- 1 file changed, 115 insertions(+), 26 deletions(-) diff --git a/simulation/kubernetes/src/scripts/CSVexport.py b/simulation/kubernetes/src/scripts/CSVexport.py index 558b07e..4cdcf63 100644 --- a/simulation/kubernetes/src/scripts/CSVexport.py +++ b/simulation/kubernetes/src/scripts/CSVexport.py @@ -1,18 +1,21 @@ import os import pandas as pd -from tensorboard.backend.event_processing.event_accumulator import EventAccumulator +import numpy as np import matplotlib.pyplot as plt import seaborn as sns +import random +from tensorboard.backend.event_processing.event_accumulator import EventAccumulator +from torch.utils.tensorboard import SummaryWriter +import time def tensorboard_to_csv(log_dir, output_csv): print(f"[INFO] Loading TensorBoard logs from: {log_dir}") - ea = EventAccumulator(log_dir) ea.Reload() all_scalars = [] - for tag in ea.Tags()['scalars']: + for tag in ea.Tags().get('scalars', []): events = ea.Scalars(tag) for e in events: all_scalars.append({ @@ -29,6 +32,7 @@ def tensorboard_to_csv(log_dir, output_csv): df.to_csv(output_csv, index=False) print(f"[INFO] Export complete. CSV saved to: {output_csv}") + def compute_node_metrics(task_log_path, scheduler_name): if not os.path.exists(task_log_path): print(f"[ERROR] Log file not found: {task_log_path}") @@ -36,29 +40,37 @@ def compute_node_metrics(task_log_path, scheduler_name): df = pd.read_csv(task_log_path) - required_columns = {"task_id", "node_id", "start_time", "end_time", "energy_used_j"} - if not required_columns.issubset(df.columns): - print(f"[ERROR] Log file missing required columns: {task_log_path}") + if not {"task_id", "node_id", "start_time", "end_time", "energy_used_j"}.issubset(df.columns): + print(f"[ERROR] Missing required columns in: {task_log_path}") return None + df["exec_time"] = df["end_time"] - df["start_time"] grouped = df.groupby("node_id").agg( num_tasks=('task_id', 'count'), mean_energy=('energy_used_j', 'mean'), total_energy=('energy_used_j', 'sum'), + max_energy=('energy_used_j', 'max'), + min_energy=('energy_used_j', 'min'), avg_task_time=('exec_time', 'mean'), + std_task_time=('exec_time', 'std'), total_exec_time=('exec_time', 'sum') - ).reset_index() + ).reset_index() + # Optional CPU and Memory metrics + if "cpu_percent" in df.columns: + grouped["avg_cpu_percent"] = df.groupby("node_id")["cpu_percent"].mean().values + grouped["max_cpu_percent"] = df.groupby("node_id")["cpu_percent"].max().values + if "memory_mb" in df.columns: + grouped["max_memory_mb"] = df.groupby("node_id")["memory_mb"].max().values + # Efficiency = tasks per unit time grouped["task_efficiency"] = grouped["num_tasks"] / grouped["total_exec_time"] grouped["scheduler"] = scheduler_name - return grouped def compare_schedulers(log_dir, scheduler_list): all_results = [] - for scheduler in scheduler_list: log_path = os.path.join(log_dir, f"{scheduler}_task_log.csv") metrics = compute_node_metrics(log_path, scheduler) @@ -70,22 +82,79 @@ def compare_schedulers(log_dir, scheduler_list): return None combined = pd.concat(all_results, ignore_index=True) - comparison_path = os.path.join(log_dir, "scheduler_comparison_metrics.csv") combined.to_csv(comparison_path, index=False) print(f"[INFO] Comparison metrics saved to: {comparison_path}") - return combined -def plot_metrics(df, metric_list): - for metric in metric_list: - plt.figure(figsize=(10, 6)) - sns.barplot(data=df, x="node_id", y=metric, hue="scheduler") - plt.title(f"{metric.replace('_', ' ').title()} per Node by Scheduler") - plt.ylabel(metric.replace('_', ' ').title()) - plt.xlabel("Node ID") + +def summarize_overall_scheduler_performance(df): + + summary = df.groupby("scheduler").agg({ + "num_tasks": "sum", + "total_energy": "sum", + "avg_task_time": "mean", + "task_efficiency": "mean" + }).reset_index() + + print("\n=== Scheduler Summary ===") + print(summary) + return summary + + + +# plot_metrics is not defined; use plot_metrics_per_scheduler instead +# plot_metrics(metrics_df, [ +# "mean_energy", "total_energy", "max_energy", "min_energy", +# "num_tasks", "avg_task_time", "std_task_time", "task_efficiency", +# "avg_cpu", "peak_memory_mb"]) +# plot metrics, use the defined function: +# plot_metrics_per_scheduler(metrics_df) + + +def plot_metrics_per_scheduler(df, save_dir="plots"): + os.makedirs(save_dir, exist_ok=True) + + + # Summarize key metrics per scheduler + + summary = df.groupby("scheduler").agg({ + + "num_tasks": "sum", + + "total_energy": "sum", + + "avg_task_time": "mean", + + "task_efficiency": "mean" + + }).reset_index() + + + # Plot each metric + + for column in summary.columns[1:]: + + plt.figure(figsize=(8, 5)) + + sns.barplot(data=summary, x="scheduler", y=column, palette="viridis") + + plt.title(f"{column.replace('_', ' ').title()} per Scheduler") + + plt.ylabel(column.replace('_', ' ').title()) + + plt.xlabel("Scheduler") plt.tight_layout() - plt.show() + + + plot_file = os.path.join(save_dir, f"{column}_per_scheduler.png") + + plt.savefig(plot_file) + + plt.close() + + print(f"[INFO] Saved: {plot_file}") + def pick_log_dir(base_dir, strategy="latest"): log_folders = [ @@ -98,7 +167,6 @@ def pick_log_dir(base_dir, strategy="latest"): if strategy == "latest": return max(log_folders, key=os.path.getmtime) elif strategy == "random": - import random return random.choice(log_folders) else: return base_dir # fallback @@ -106,17 +174,38 @@ def pick_log_dir(base_dir, strategy="latest"): if __name__ == "__main__": # === Part 1: Export TensorBoard scalars === log_dir_event_file = "kubernetes/logs/20250702-171434/events.out.tfevents.1751494474.lemont" - output_csv = "waggle_scheduler_metrics.csv" + output_csv = "scheduler_metrics.csv" if os.path.exists(log_dir_event_file): tensorboard_to_csv(log_dir_event_file, output_csv) else: print(f"[ERROR] TensorBoard event file not found: {log_dir_event_file}") - # === Part 2: Scheduler log comparison (Task 2 & 3) === + + + # === Part 2: Scheduler metrics & data (Task 2) === + # === Part 3: Scheduler log comparison (Task 3) === log_dir_task = "logs" # folder with task logs like WaggleScheduler_task_log.csv - schedulers = ["WaggleScheduler", "FairshareScheduler"] + def simulate_scheduler_log(log_dir, scheduler_name, num_steps=10): + path = os.path.join(log_dir, scheduler_name) + os.makedirs(path, exist_ok=True) + writer = SummaryWriter(log_dir=path) + for step in range(num_steps): + + # Simulate scalar logs + loss = 0.5 / (step + 1) + energy = 50 + step * 2 + duration = 5 + (step % 3) + + writer.add_scalar("loss", loss, step) + writer.add_scalar("energy_used", energy, step) + writer.add_scalar("task_duration", duration, step) - metrics_df = compare_schedulers(log_dir_task, schedulers) - if metrics_df is not None: - plot_metrics(metrics_df, ["mean_energy", "total_energy", "num_tasks", "avg_task_time", "task_efficiency"]) \ No newline at end of file + time.sleep(0.01) # slight delay to vary timestamps + writer.close() + + print(f"[INFO] Created log at: {path}") +if __name__ == "__main__": + base_log_dir = "generated_logs" + simulate_scheduler_log(base_log_dir, "WaggleScheduler") + simulate_scheduler_log(base_log_dir, "FairshareScheduler") \ No newline at end of file From 283e0ca885229c32befe6ec0800352271be972c4 Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Mon, 14 Jul 2025 11:49:34 -0500 Subject: [PATCH 24/37] Refactor TensorBoard class: enhance initialization with scheduler name, improve logging directory structure, and ensure proper writer closure --- .../src/visualization/tensorboard.py | 39 +++++++++++++------ 1 file changed, 28 insertions(+), 11 deletions(-) diff --git a/simulation/kubernetes/src/visualization/tensorboard.py b/simulation/kubernetes/src/visualization/tensorboard.py index a3a2f6e..325ffdc 100644 --- a/simulation/kubernetes/src/visualization/tensorboard.py +++ b/simulation/kubernetes/src/visualization/tensorboard.py @@ -2,28 +2,45 @@ from datetime import datetime class TensorBoard: - def __init__(self, log_dir='logs'): - self.log_dir = log_dir + def __init__(self, log_base_dir='logs', scheduler_name='DefaultScheduler'): + self.log_base_dir = log_base_dir + self.scheduler_name = scheduler_name current_time = datetime.now().strftime('%Y%m%d-%H%M%S') - log_dir_with_timestamp = f"{self.log_dir}/{current_time}" - self.writer = tb.SummaryWriter(log_dir_with_timestamp) + log_dir = os.path.join( + self.log_base_dir, f"{current_time}-{self.scheduler_name}" + ) + os.makedirs(log_dir, exist_ok=True) + self.writer = SummaryWriter(log_dir) + print(f"[TensorBoard] Logging to: {log_dir}") def finish(self): - # No need to close the writer - pass + """Properly close the writer to flush events.""" + self.writer.close() - def log_metrics(self, metrics, step): + def log_metrics(self, metrics: dict, step: int): for key, value in metrics.items(): self.writer.add_scalar(key, value, step) - def log_scalar(self, tag, value, step): + def log_scalar(self, tag: str, value: float, step: int): self.writer.add_scalar(tag, value, step) - def log_histogram(self, tag, values, step): + def log_histogram(self, tag: str, values, step: int): self.writer.add_histogram(tag, values, step) - def log_image(self, tag, image, step): + def log_image(self, tag: str, image, step: int): self.writer.add_image(tag, image, step) - def log_text(self, tag, text, step): + def log_text(self, tag: str, text: str, step: int): self.writer.add_text(tag, text, step) + +if __name__ == "__main__": + tb_fairshare = TensorBoard(scheduler_name="FairshareScheduler") + tb_waggle = TensorBoard(scheduler_name="WaggleScheduler") + + # Example logging + for step in range(10): + tb_fairshare.log_scalar("accuracy", 0.8 + 0.01 * step, step) + tb_waggle.log_scalar("accuracy", 0.85 + 0.01 * step, step) + + tb_fairshare.finish() + tb_waggle.finish() \ No newline at end of file From 7694c6a6ee21b4350a216cf899257cded380f27c Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Mon, 14 Jul 2025 12:18:04 -0500 Subject: [PATCH 25/37] Refactor TensorBoard class: reorganize imports for clarity and consistency --- simulation/kubernetes/src/visualization/tensorboard.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/simulation/kubernetes/src/visualization/tensorboard.py b/simulation/kubernetes/src/visualization/tensorboard.py index 325ffdc..4e863c2 100644 --- a/simulation/kubernetes/src/visualization/tensorboard.py +++ b/simulation/kubernetes/src/visualization/tensorboard.py @@ -1,4 +1,6 @@ +import os import tensorboardX as tb +from tensorboardX import SummaryWriter from datetime import datetime class TensorBoard: From 9534343205c380b5c341b5b3c90d27e586d77296 Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Thu, 17 Jul 2025 12:49:28 -0500 Subject: [PATCH 26/37] Refactor mywaggle.yaml: adjust comments for scheduler and hosts for clarity --- simulation/kubernetes/mywaggle.yaml | 25 ++++++++++++++++++++++++- 1 file changed, 24 insertions(+), 1 deletion(-) diff --git a/simulation/kubernetes/mywaggle.yaml b/simulation/kubernetes/mywaggle.yaml index e6ed703..11b11d4 100644 --- a/simulation/kubernetes/mywaggle.yaml +++ b/simulation/kubernetes/mywaggle.yaml @@ -1,7 +1,7 @@ #env: waggle #workload: bitbrain scheduler: WaggleScheduler -# scheduler: FairshareScheduler +#scheduler: FairshareScheduler dataloader: JobLoader # dataloader: SimpleLoader steps: 50 @@ -18,13 +18,36 @@ hosts: # labels: # waggle.io/type: wsn # waggle.io/group: chicago + - name: T002-nxcore device: xaviernx labels: waggle.io/type: wsn waggle.io/group: chicago + # - name: T003-nxcore # device: xaviernx # labels: # waggle.io/type: wsn # waggle.io/group: chicago + +# - name: T004-rpi +# device: rpi +# labels: +# waggle.io/type: wsn +# waggle.io/group: chicago + + +# - name: T005-jetson +# device: jetson +# labels: +# waggle.io/type: wsn +# waggle.io/group: chicago + + +# - name: T006-jetson +# device: jetson +# labels: +# waggle.io/type: wsn +# waggle.io/group: chicago + From 3cbeaf45eb321bd2e6cdc7b4077096275ee6ec33 Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Thu, 17 Jul 2025 13:33:47 -0500 Subject: [PATCH 27/37] Implement code changes to enhance functionality and improve performance --- .../kubernetes/src/scripts/CSVexport.py | 46 +- simulation/scheduler_metrics.csv | 851 ++++++++++++++++++ 2 files changed, 879 insertions(+), 18 deletions(-) create mode 100644 simulation/scheduler_metrics.csv diff --git a/simulation/kubernetes/src/scripts/CSVexport.py b/simulation/kubernetes/src/scripts/CSVexport.py index 4cdcf63..71a87a2 100644 --- a/simulation/kubernetes/src/scripts/CSVexport.py +++ b/simulation/kubernetes/src/scripts/CSVexport.py @@ -8,6 +8,7 @@ from torch.utils.tensorboard import SummaryWriter import time + def tensorboard_to_csv(log_dir, output_csv): print(f"[INFO] Loading TensorBoard logs from: {log_dir}") ea = EventAccumulator(log_dir) @@ -15,7 +16,7 @@ def tensorboard_to_csv(log_dir, output_csv): all_scalars = [] - for tag in ea.Tags().get('scalars', []): + for tag in ea.Tags()['scalars']: events = ea.Scalars(tag) for e in events: all_scalars.append({ @@ -89,7 +90,6 @@ def compare_schedulers(log_dir, scheduler_list): def summarize_overall_scheduler_performance(df): - summary = df.groupby("scheduler").agg({ "num_tasks": "sum", "total_energy": "sum", @@ -99,9 +99,18 @@ def summarize_overall_scheduler_performance(df): print("\n=== Scheduler Summary ===") print(summary) - return summary + # Plot using pandas + ax = summary.plot(x="scheduler", kind="bar", figsize=(10, 6), title="Scheduler Comparison") + ax.set_ylabel("Metric Value") + ax.set_xlabel("Scheduler") + plt.tight_layout() + plt.savefig("scheduler_summary_pandas_plot.png") + plt.show() + + return summary + # plot_metrics is not defined; use plot_metrics_per_scheduler instead # plot_metrics(metrics_df, [ @@ -115,17 +124,13 @@ def summarize_overall_scheduler_performance(df): def plot_metrics_per_scheduler(df, save_dir="plots"): os.makedirs(save_dir, exist_ok=True) - # Summarize key metrics per scheduler summary = df.groupby("scheduler").agg({ "num_tasks": "sum", - "total_energy": "sum", - "avg_task_time": "mean", - "task_efficiency": "mean" }).reset_index() @@ -136,21 +141,15 @@ def plot_metrics_per_scheduler(df, save_dir="plots"): for column in summary.columns[1:]: plt.figure(figsize=(8, 5)) - sns.barplot(data=summary, x="scheduler", y=column, palette="viridis") - plt.title(f"{column.replace('_', ' ').title()} per Scheduler") - plt.ylabel(column.replace('_', ' ').title()) - plt.xlabel("Scheduler") plt.tight_layout() plot_file = os.path.join(save_dir, f"{column}_per_scheduler.png") - plt.savefig(plot_file) - plt.close() print(f"[INFO] Saved: {plot_file}") @@ -173,7 +172,8 @@ def pick_log_dir(base_dir, strategy="latest"): if __name__ == "__main__": # === Part 1: Export TensorBoard scalars === - log_dir_event_file = "kubernetes/logs/20250702-171434/events.out.tfevents.1751494474.lemont" + log_dir_event_file = "kubernetes/logs/20250702-171434" # Path to the TensorBoard event file + # Note: Adjust the path to your actual TensorBoard event file location output_csv = "scheduler_metrics.csv" if os.path.exists(log_dir_event_file): @@ -181,7 +181,7 @@ def pick_log_dir(base_dir, strategy="latest"): else: print(f"[ERROR] TensorBoard event file not found: {log_dir_event_file}") - + # === Part 2: Scheduler metrics & data (Task 2) === # === Part 3: Scheduler log comparison (Task 3) === @@ -205,7 +205,17 @@ def simulate_scheduler_log(log_dir, scheduler_name, num_steps=10): writer.close() print(f"[INFO] Created log at: {path}") + + + if __name__ == "__main__": - base_log_dir = "generated_logs" - simulate_scheduler_log(base_log_dir, "WaggleScheduler") - simulate_scheduler_log(base_log_dir, "FairshareScheduler") \ No newline at end of file + # Simulate dummy logs for two schedulers + simulate_scheduler_log("logs", "RandomScheduler") + simulate_scheduler_log("logs", "FairScheduler") + + # Compare them + metrics_df = compare_schedulers("logs", ["RandomScheduler", "FairScheduler"]) + + if metrics_df is not None: + summarize_overall_scheduler_performance(metrics_df) + plot_metrics_per_scheduler(metrics_df) \ No newline at end of file diff --git a/simulation/scheduler_metrics.csv b/simulation/scheduler_metrics.csv new file mode 100644 index 0000000..3bfb3f2 --- /dev/null +++ b/simulation/scheduler_metrics.csv @@ -0,0 +1,851 @@ +step,tag,value +0,node_t001-nxcore_energy,0.8496599793434143 +1,node_t001-nxcore_energy,0.6913899779319763 +2,node_t001-nxcore_energy,0.7663599848747253 +3,node_t001-nxcore_energy,0.6913899779319763 +4,node_t001-nxcore_energy,0.7663599848747253 +5,node_t001-nxcore_energy,0.6913899779319763 +6,node_t001-nxcore_energy,0.7663599848747253 +7,node_t001-nxcore_energy,0.6913899779319763 +8,node_t001-nxcore_energy,0.7663599848747253 +9,node_t001-nxcore_energy,0.6913899779319763 +10,node_t001-nxcore_energy,0.8496599793434143 +11,node_t001-nxcore_energy,0.6913899779319763 +12,node_t001-nxcore_energy,0.7663599848747253 +13,node_t001-nxcore_energy,0.6913899779319763 +14,node_t001-nxcore_energy,0.7663599848747253 +15,node_t001-nxcore_energy,0.6913899779319763 +16,node_t001-nxcore_energy,0.7663599848747253 +17,node_t001-nxcore_energy,0.6913899779319763 +18,node_t001-nxcore_energy,0.7663599848747253 +19,node_t001-nxcore_energy,0.6913899779319763 +20,node_t001-nxcore_energy,0.8496599793434143 +21,node_t001-nxcore_energy,0.6913899779319763 +22,node_t001-nxcore_energy,0.7663599848747253 +23,node_t001-nxcore_energy,0.6913899779319763 +24,node_t001-nxcore_energy,0.7663599848747253 +25,node_t001-nxcore_energy,0.6913899779319763 +26,node_t001-nxcore_energy,0.7663599848747253 +27,node_t001-nxcore_energy,0.6913899779319763 +28,node_t001-nxcore_energy,0.7663599848747253 +29,node_t001-nxcore_energy,0.6913899779319763 +30,node_t001-nxcore_energy,0.8496599793434143 +31,node_t001-nxcore_energy,0.6913899779319763 +32,node_t001-nxcore_energy,0.7663599848747253 +33,node_t001-nxcore_energy,0.6913899779319763 +34,node_t001-nxcore_energy,0.7663599848747253 +35,node_t001-nxcore_energy,0.6913899779319763 +36,node_t001-nxcore_energy,0.7663599848747253 +37,node_t001-nxcore_energy,0.6913899779319763 +38,node_t001-nxcore_energy,0.7663599848747253 +39,node_t001-nxcore_energy,0.6913899779319763 +40,node_t001-nxcore_energy,0.8496599793434143 +41,node_t001-nxcore_energy,0.6913899779319763 +42,node_t001-nxcore_energy,0.7663599848747253 +43,node_t001-nxcore_energy,0.6913899779319763 +44,node_t001-nxcore_energy,0.7663599848747253 +45,node_t001-nxcore_energy,0.6913899779319763 +46,node_t001-nxcore_energy,0.7663599848747253 +47,node_t001-nxcore_energy,0.6913899779319763 +48,node_t001-nxcore_energy,0.7663599848747253 +49,node_t001-nxcore_energy,0.6913899779319763 +0,node_t001-nxcore_cpu,3100.0 +1,node_t001-nxcore_cpu,2000.0 +2,node_t001-nxcore_cpu,2500.0 +3,node_t001-nxcore_cpu,2000.0 +4,node_t001-nxcore_cpu,2500.0 +5,node_t001-nxcore_cpu,2000.0 +6,node_t001-nxcore_cpu,2500.0 +7,node_t001-nxcore_cpu,2000.0 +8,node_t001-nxcore_cpu,2500.0 +9,node_t001-nxcore_cpu,2000.0 +10,node_t001-nxcore_cpu,3100.0 +11,node_t001-nxcore_cpu,2000.0 +12,node_t001-nxcore_cpu,2500.0 +13,node_t001-nxcore_cpu,2000.0 +14,node_t001-nxcore_cpu,2500.0 +15,node_t001-nxcore_cpu,2000.0 +16,node_t001-nxcore_cpu,2500.0 +17,node_t001-nxcore_cpu,2000.0 +18,node_t001-nxcore_cpu,2500.0 +19,node_t001-nxcore_cpu,2000.0 +20,node_t001-nxcore_cpu,3100.0 +21,node_t001-nxcore_cpu,2000.0 +22,node_t001-nxcore_cpu,2500.0 +23,node_t001-nxcore_cpu,2000.0 +24,node_t001-nxcore_cpu,2500.0 +25,node_t001-nxcore_cpu,2000.0 +26,node_t001-nxcore_cpu,2500.0 +27,node_t001-nxcore_cpu,2000.0 +28,node_t001-nxcore_cpu,2500.0 +29,node_t001-nxcore_cpu,2000.0 +30,node_t001-nxcore_cpu,3100.0 +31,node_t001-nxcore_cpu,2000.0 +32,node_t001-nxcore_cpu,2500.0 +33,node_t001-nxcore_cpu,2000.0 +34,node_t001-nxcore_cpu,2500.0 +35,node_t001-nxcore_cpu,2000.0 +36,node_t001-nxcore_cpu,2500.0 +37,node_t001-nxcore_cpu,2000.0 +38,node_t001-nxcore_cpu,2500.0 +39,node_t001-nxcore_cpu,2000.0 +40,node_t001-nxcore_cpu,3100.0 +41,node_t001-nxcore_cpu,2000.0 +42,node_t001-nxcore_cpu,2500.0 +43,node_t001-nxcore_cpu,2000.0 +44,node_t001-nxcore_cpu,2500.0 +45,node_t001-nxcore_cpu,2000.0 +46,node_t001-nxcore_cpu,2500.0 +47,node_t001-nxcore_cpu,2000.0 +48,node_t001-nxcore_cpu,2500.0 +49,node_t001-nxcore_cpu,2000.0 +0,node_t001-nxcore_memory,3441426432.0 +1,node_t001-nxcore_memory,3221225472.0 +2,node_t001-nxcore_memory,3695181824.0 +3,node_t001-nxcore_memory,3221225472.0 +4,node_t001-nxcore_memory,3695181824.0 +5,node_t001-nxcore_memory,3221225472.0 +6,node_t001-nxcore_memory,3695181824.0 +7,node_t001-nxcore_memory,3221225472.0 +8,node_t001-nxcore_memory,3695181824.0 +9,node_t001-nxcore_memory,3221225472.0 +10,node_t001-nxcore_memory,3441426432.0 +11,node_t001-nxcore_memory,3221225472.0 +12,node_t001-nxcore_memory,3695181824.0 +13,node_t001-nxcore_memory,3221225472.0 +14,node_t001-nxcore_memory,3695181824.0 +15,node_t001-nxcore_memory,3221225472.0 +16,node_t001-nxcore_memory,3695181824.0 +17,node_t001-nxcore_memory,3221225472.0 +18,node_t001-nxcore_memory,3695181824.0 +19,node_t001-nxcore_memory,3221225472.0 +20,node_t001-nxcore_memory,3441426432.0 +21,node_t001-nxcore_memory,3221225472.0 +22,node_t001-nxcore_memory,3695181824.0 +23,node_t001-nxcore_memory,3221225472.0 +24,node_t001-nxcore_memory,3695181824.0 +25,node_t001-nxcore_memory,3221225472.0 +26,node_t001-nxcore_memory,3695181824.0 +27,node_t001-nxcore_memory,3221225472.0 +28,node_t001-nxcore_memory,3695181824.0 +29,node_t001-nxcore_memory,3221225472.0 +30,node_t001-nxcore_memory,3441426432.0 +31,node_t001-nxcore_memory,3221225472.0 +32,node_t001-nxcore_memory,3695181824.0 +33,node_t001-nxcore_memory,3221225472.0 +34,node_t001-nxcore_memory,3695181824.0 +35,node_t001-nxcore_memory,3221225472.0 +36,node_t001-nxcore_memory,3695181824.0 +37,node_t001-nxcore_memory,3221225472.0 +38,node_t001-nxcore_memory,3695181824.0 +39,node_t001-nxcore_memory,3221225472.0 +40,node_t001-nxcore_memory,3441426432.0 +41,node_t001-nxcore_memory,3221225472.0 +42,node_t001-nxcore_memory,3695181824.0 +43,node_t001-nxcore_memory,3221225472.0 +44,node_t001-nxcore_memory,3695181824.0 +45,node_t001-nxcore_memory,3221225472.0 +46,node_t001-nxcore_memory,3695181824.0 +47,node_t001-nxcore_memory,3221225472.0 +48,node_t001-nxcore_memory,3695181824.0 +49,node_t001-nxcore_memory,3221225472.0 +0,node_t001-nxcore_power,10.199999809265137 +1,node_t001-nxcore_power,8.300000190734863 +2,node_t001-nxcore_power,9.199999809265137 +3,node_t001-nxcore_power,8.300000190734863 +4,node_t001-nxcore_power,9.199999809265137 +5,node_t001-nxcore_power,8.300000190734863 +6,node_t001-nxcore_power,9.199999809265137 +7,node_t001-nxcore_power,8.300000190734863 +8,node_t001-nxcore_power,9.199999809265137 +9,node_t001-nxcore_power,8.300000190734863 +10,node_t001-nxcore_power,10.199999809265137 +11,node_t001-nxcore_power,8.300000190734863 +12,node_t001-nxcore_power,9.199999809265137 +13,node_t001-nxcore_power,8.300000190734863 +14,node_t001-nxcore_power,9.199999809265137 +15,node_t001-nxcore_power,8.300000190734863 +16,node_t001-nxcore_power,9.199999809265137 +17,node_t001-nxcore_power,8.300000190734863 +18,node_t001-nxcore_power,9.199999809265137 +19,node_t001-nxcore_power,8.300000190734863 +20,node_t001-nxcore_power,10.199999809265137 +21,node_t001-nxcore_power,8.300000190734863 +22,node_t001-nxcore_power,9.199999809265137 +23,node_t001-nxcore_power,8.300000190734863 +24,node_t001-nxcore_power,9.199999809265137 +25,node_t001-nxcore_power,8.300000190734863 +26,node_t001-nxcore_power,9.199999809265137 +27,node_t001-nxcore_power,8.300000190734863 +28,node_t001-nxcore_power,9.199999809265137 +29,node_t001-nxcore_power,8.300000190734863 +30,node_t001-nxcore_power,10.199999809265137 +31,node_t001-nxcore_power,8.300000190734863 +32,node_t001-nxcore_power,9.199999809265137 +33,node_t001-nxcore_power,8.300000190734863 +34,node_t001-nxcore_power,9.199999809265137 +35,node_t001-nxcore_power,8.300000190734863 +36,node_t001-nxcore_power,9.199999809265137 +37,node_t001-nxcore_power,8.300000190734863 +38,node_t001-nxcore_power,9.199999809265137 +39,node_t001-nxcore_power,8.300000190734863 +40,node_t001-nxcore_power,10.199999809265137 +41,node_t001-nxcore_power,8.300000190734863 +42,node_t001-nxcore_power,9.199999809265137 +43,node_t001-nxcore_power,8.300000190734863 +44,node_t001-nxcore_power,9.199999809265137 +45,node_t001-nxcore_power,8.300000190734863 +46,node_t001-nxcore_power,9.199999809265137 +47,node_t001-nxcore_power,8.300000190734863 +48,node_t001-nxcore_power,9.199999809265137 +49,node_t001-nxcore_power,8.300000190734863 +0,node_t001-nxcore_power_moving_average,10.199999809265137 +1,node_t001-nxcore_power_moving_average,8.300000190734863 +2,node_t001-nxcore_power_moving_average,9.199999809265137 +3,node_t001-nxcore_power_moving_average,8.300000190734863 +4,node_t001-nxcore_power_moving_average,9.199999809265137 +5,node_t001-nxcore_power_moving_average,8.300000190734863 +6,node_t001-nxcore_power_moving_average,9.199999809265137 +7,node_t001-nxcore_power_moving_average,8.300000190734863 +8,node_t001-nxcore_power_moving_average,9.199999809265137 +9,node_t001-nxcore_power_moving_average,8.300000190734863 +10,node_t001-nxcore_power_moving_average,10.199999809265137 +11,node_t001-nxcore_power_moving_average,8.300000190734863 +12,node_t001-nxcore_power_moving_average,9.199999809265137 +13,node_t001-nxcore_power_moving_average,8.300000190734863 +14,node_t001-nxcore_power_moving_average,9.199999809265137 +15,node_t001-nxcore_power_moving_average,8.300000190734863 +16,node_t001-nxcore_power_moving_average,9.199999809265137 +17,node_t001-nxcore_power_moving_average,8.300000190734863 +18,node_t001-nxcore_power_moving_average,9.199999809265137 +19,node_t001-nxcore_power_moving_average,8.300000190734863 +20,node_t001-nxcore_power_moving_average,10.199999809265137 +21,node_t001-nxcore_power_moving_average,8.300000190734863 +22,node_t001-nxcore_power_moving_average,9.199999809265137 +23,node_t001-nxcore_power_moving_average,8.300000190734863 +24,node_t001-nxcore_power_moving_average,9.199999809265137 +25,node_t001-nxcore_power_moving_average,8.300000190734863 +26,node_t001-nxcore_power_moving_average,9.199999809265137 +27,node_t001-nxcore_power_moving_average,8.300000190734863 +28,node_t001-nxcore_power_moving_average,9.199999809265137 +29,node_t001-nxcore_power_moving_average,8.300000190734863 +30,node_t001-nxcore_power_moving_average,10.199999809265137 +31,node_t001-nxcore_power_moving_average,8.300000190734863 +32,node_t001-nxcore_power_moving_average,9.199999809265137 +33,node_t001-nxcore_power_moving_average,8.300000190734863 +34,node_t001-nxcore_power_moving_average,9.199999809265137 +35,node_t001-nxcore_power_moving_average,8.300000190734863 +36,node_t001-nxcore_power_moving_average,9.199999809265137 +37,node_t001-nxcore_power_moving_average,8.300000190734863 +38,node_t001-nxcore_power_moving_average,9.199999809265137 +39,node_t001-nxcore_power_moving_average,8.300000190734863 +40,node_t001-nxcore_power_moving_average,10.199999809265137 +41,node_t001-nxcore_power_moving_average,8.300000190734863 +42,node_t001-nxcore_power_moving_average,9.199999809265137 +43,node_t001-nxcore_power_moving_average,8.300000190734863 +44,node_t001-nxcore_power_moving_average,9.199999809265137 +45,node_t001-nxcore_power_moving_average,8.300000190734863 +46,node_t001-nxcore_power_moving_average,9.199999809265137 +47,node_t001-nxcore_power_moving_average,8.300000190734863 +48,node_t001-nxcore_power_moving_average,9.199999809265137 +49,node_t001-nxcore_power_moving_average,8.300000190734863 +0,node_t001-nxcore_finished_workloads,3.0 +1,node_t001-nxcore_finished_workloads,4.0 +2,node_t001-nxcore_finished_workloads,6.0 +3,node_t001-nxcore_finished_workloads,7.0 +4,node_t001-nxcore_finished_workloads,9.0 +5,node_t001-nxcore_finished_workloads,10.0 +6,node_t001-nxcore_finished_workloads,12.0 +7,node_t001-nxcore_finished_workloads,13.0 +8,node_t001-nxcore_finished_workloads,15.0 +9,node_t001-nxcore_finished_workloads,16.0 +10,node_t001-nxcore_finished_workloads,19.0 +11,node_t001-nxcore_finished_workloads,20.0 +12,node_t001-nxcore_finished_workloads,22.0 +13,node_t001-nxcore_finished_workloads,23.0 +14,node_t001-nxcore_finished_workloads,25.0 +15,node_t001-nxcore_finished_workloads,26.0 +16,node_t001-nxcore_finished_workloads,28.0 +17,node_t001-nxcore_finished_workloads,29.0 +18,node_t001-nxcore_finished_workloads,31.0 +19,node_t001-nxcore_finished_workloads,32.0 +20,node_t001-nxcore_finished_workloads,35.0 +21,node_t001-nxcore_finished_workloads,36.0 +22,node_t001-nxcore_finished_workloads,38.0 +23,node_t001-nxcore_finished_workloads,39.0 +24,node_t001-nxcore_finished_workloads,41.0 +25,node_t001-nxcore_finished_workloads,42.0 +26,node_t001-nxcore_finished_workloads,44.0 +27,node_t001-nxcore_finished_workloads,45.0 +28,node_t001-nxcore_finished_workloads,47.0 +29,node_t001-nxcore_finished_workloads,48.0 +30,node_t001-nxcore_finished_workloads,51.0 +31,node_t001-nxcore_finished_workloads,52.0 +32,node_t001-nxcore_finished_workloads,54.0 +33,node_t001-nxcore_finished_workloads,55.0 +34,node_t001-nxcore_finished_workloads,57.0 +35,node_t001-nxcore_finished_workloads,58.0 +36,node_t001-nxcore_finished_workloads,60.0 +37,node_t001-nxcore_finished_workloads,61.0 +38,node_t001-nxcore_finished_workloads,63.0 +39,node_t001-nxcore_finished_workloads,64.0 +40,node_t001-nxcore_finished_workloads,67.0 +41,node_t001-nxcore_finished_workloads,68.0 +42,node_t001-nxcore_finished_workloads,70.0 +43,node_t001-nxcore_finished_workloads,71.0 +44,node_t001-nxcore_finished_workloads,73.0 +45,node_t001-nxcore_finished_workloads,74.0 +46,node_t001-nxcore_finished_workloads,76.0 +47,node_t001-nxcore_finished_workloads,77.0 +48,node_t001-nxcore_finished_workloads,79.0 +49,node_t001-nxcore_finished_workloads,80.0 +0,node_t001-nxcore_running_workloads,0.0 +1,node_t001-nxcore_running_workloads,0.0 +2,node_t001-nxcore_running_workloads,0.0 +3,node_t001-nxcore_running_workloads,0.0 +4,node_t001-nxcore_running_workloads,0.0 +5,node_t001-nxcore_running_workloads,0.0 +6,node_t001-nxcore_running_workloads,0.0 +7,node_t001-nxcore_running_workloads,0.0 +8,node_t001-nxcore_running_workloads,0.0 +9,node_t001-nxcore_running_workloads,0.0 +10,node_t001-nxcore_running_workloads,0.0 +11,node_t001-nxcore_running_workloads,0.0 +12,node_t001-nxcore_running_workloads,0.0 +13,node_t001-nxcore_running_workloads,0.0 +14,node_t001-nxcore_running_workloads,0.0 +15,node_t001-nxcore_running_workloads,0.0 +16,node_t001-nxcore_running_workloads,0.0 +17,node_t001-nxcore_running_workloads,0.0 +18,node_t001-nxcore_running_workloads,0.0 +19,node_t001-nxcore_running_workloads,0.0 +20,node_t001-nxcore_running_workloads,0.0 +21,node_t001-nxcore_running_workloads,0.0 +22,node_t001-nxcore_running_workloads,0.0 +23,node_t001-nxcore_running_workloads,0.0 +24,node_t001-nxcore_running_workloads,0.0 +25,node_t001-nxcore_running_workloads,0.0 +26,node_t001-nxcore_running_workloads,0.0 +27,node_t001-nxcore_running_workloads,0.0 +28,node_t001-nxcore_running_workloads,0.0 +29,node_t001-nxcore_running_workloads,0.0 +30,node_t001-nxcore_running_workloads,0.0 +31,node_t001-nxcore_running_workloads,0.0 +32,node_t001-nxcore_running_workloads,0.0 +33,node_t001-nxcore_running_workloads,0.0 +34,node_t001-nxcore_running_workloads,0.0 +35,node_t001-nxcore_running_workloads,0.0 +36,node_t001-nxcore_running_workloads,0.0 +37,node_t001-nxcore_running_workloads,0.0 +38,node_t001-nxcore_running_workloads,0.0 +39,node_t001-nxcore_running_workloads,0.0 +40,node_t001-nxcore_running_workloads,0.0 +41,node_t001-nxcore_running_workloads,0.0 +42,node_t001-nxcore_running_workloads,0.0 +43,node_t001-nxcore_running_workloads,0.0 +44,node_t001-nxcore_running_workloads,0.0 +45,node_t001-nxcore_running_workloads,0.0 +46,node_t001-nxcore_running_workloads,0.0 +47,node_t001-nxcore_running_workloads,0.0 +48,node_t001-nxcore_running_workloads,0.0 +49,node_t001-nxcore_running_workloads,0.0 +0,node_t002-nxcore_energy,0.7663599848747253 +1,node_t002-nxcore_energy,0.5581099987030029 +2,node_t002-nxcore_energy,0.8330000042915344 +3,node_t002-nxcore_energy,0.5581099987030029 +4,node_t002-nxcore_energy,0.8330000042915344 +5,node_t002-nxcore_energy,0.5581099987030029 +6,node_t002-nxcore_energy,0.8330000042915344 +7,node_t002-nxcore_energy,0.5581099987030029 +8,node_t002-nxcore_energy,0.8330000042915344 +9,node_t002-nxcore_energy,0.5581099987030029 +10,node_t002-nxcore_energy,0.7663599848747253 +11,node_t002-nxcore_energy,0.5581099987030029 +12,node_t002-nxcore_energy,0.8330000042915344 +13,node_t002-nxcore_energy,0.5581099987030029 +14,node_t002-nxcore_energy,0.8330000042915344 +15,node_t002-nxcore_energy,0.5581099987030029 +16,node_t002-nxcore_energy,0.8330000042915344 +17,node_t002-nxcore_energy,0.5581099987030029 +18,node_t002-nxcore_energy,0.8330000042915344 +19,node_t002-nxcore_energy,0.5581099987030029 +20,node_t002-nxcore_energy,0.7663599848747253 +21,node_t002-nxcore_energy,0.5581099987030029 +22,node_t002-nxcore_energy,0.8330000042915344 +23,node_t002-nxcore_energy,0.5581099987030029 +24,node_t002-nxcore_energy,0.8330000042915344 +25,node_t002-nxcore_energy,0.5581099987030029 +26,node_t002-nxcore_energy,0.8330000042915344 +27,node_t002-nxcore_energy,0.5581099987030029 +28,node_t002-nxcore_energy,0.8330000042915344 +29,node_t002-nxcore_energy,0.5581099987030029 +30,node_t002-nxcore_energy,0.7663599848747253 +31,node_t002-nxcore_energy,0.5581099987030029 +32,node_t002-nxcore_energy,0.8330000042915344 +33,node_t002-nxcore_energy,0.5581099987030029 +34,node_t002-nxcore_energy,0.8330000042915344 +35,node_t002-nxcore_energy,0.5581099987030029 +36,node_t002-nxcore_energy,0.8330000042915344 +37,node_t002-nxcore_energy,0.5581099987030029 +38,node_t002-nxcore_energy,0.8330000042915344 +39,node_t002-nxcore_energy,0.5581099987030029 +40,node_t002-nxcore_energy,0.7663599848747253 +41,node_t002-nxcore_energy,0.5581099987030029 +42,node_t002-nxcore_energy,0.8330000042915344 +43,node_t002-nxcore_energy,0.5581099987030029 +44,node_t002-nxcore_energy,0.8330000042915344 +45,node_t002-nxcore_energy,0.5581099987030029 +46,node_t002-nxcore_energy,0.8330000042915344 +47,node_t002-nxcore_energy,0.5581099987030029 +48,node_t002-nxcore_energy,0.8330000042915344 +49,node_t002-nxcore_energy,0.5581099987030029 +0,node_t002-nxcore_cpu,2500.0 +1,node_t002-nxcore_cpu,1000.0 +2,node_t002-nxcore_cpu,3000.0 +3,node_t002-nxcore_cpu,1000.0 +4,node_t002-nxcore_cpu,3000.0 +5,node_t002-nxcore_cpu,1000.0 +6,node_t002-nxcore_cpu,3000.0 +7,node_t002-nxcore_cpu,1000.0 +8,node_t002-nxcore_cpu,3000.0 +9,node_t002-nxcore_cpu,1000.0 +10,node_t002-nxcore_cpu,2500.0 +11,node_t002-nxcore_cpu,1000.0 +12,node_t002-nxcore_cpu,3000.0 +13,node_t002-nxcore_cpu,1000.0 +14,node_t002-nxcore_cpu,3000.0 +15,node_t002-nxcore_cpu,1000.0 +16,node_t002-nxcore_cpu,3000.0 +17,node_t002-nxcore_cpu,1000.0 +18,node_t002-nxcore_cpu,3000.0 +19,node_t002-nxcore_cpu,1000.0 +20,node_t002-nxcore_cpu,2500.0 +21,node_t002-nxcore_cpu,1000.0 +22,node_t002-nxcore_cpu,3000.0 +23,node_t002-nxcore_cpu,1000.0 +24,node_t002-nxcore_cpu,3000.0 +25,node_t002-nxcore_cpu,1000.0 +26,node_t002-nxcore_cpu,3000.0 +27,node_t002-nxcore_cpu,1000.0 +28,node_t002-nxcore_cpu,3000.0 +29,node_t002-nxcore_cpu,1000.0 +30,node_t002-nxcore_cpu,2500.0 +31,node_t002-nxcore_cpu,1000.0 +32,node_t002-nxcore_cpu,3000.0 +33,node_t002-nxcore_cpu,1000.0 +34,node_t002-nxcore_cpu,3000.0 +35,node_t002-nxcore_cpu,1000.0 +36,node_t002-nxcore_cpu,3000.0 +37,node_t002-nxcore_cpu,1000.0 +38,node_t002-nxcore_cpu,3000.0 +39,node_t002-nxcore_cpu,1000.0 +40,node_t002-nxcore_cpu,2500.0 +41,node_t002-nxcore_cpu,1000.0 +42,node_t002-nxcore_cpu,3000.0 +43,node_t002-nxcore_cpu,1000.0 +44,node_t002-nxcore_cpu,3000.0 +45,node_t002-nxcore_cpu,1000.0 +46,node_t002-nxcore_cpu,3000.0 +47,node_t002-nxcore_cpu,1000.0 +48,node_t002-nxcore_cpu,3000.0 +49,node_t002-nxcore_cpu,1000.0 +0,node_t002-nxcore_memory,3695181824.0 +1,node_t002-nxcore_memory,1073741824.0 +2,node_t002-nxcore_memory,3430940672.0 +3,node_t002-nxcore_memory,1073741824.0 +4,node_t002-nxcore_memory,3430940672.0 +5,node_t002-nxcore_memory,1073741824.0 +6,node_t002-nxcore_memory,3430940672.0 +7,node_t002-nxcore_memory,1073741824.0 +8,node_t002-nxcore_memory,3430940672.0 +9,node_t002-nxcore_memory,1073741824.0 +10,node_t002-nxcore_memory,3695181824.0 +11,node_t002-nxcore_memory,1073741824.0 +12,node_t002-nxcore_memory,3430940672.0 +13,node_t002-nxcore_memory,1073741824.0 +14,node_t002-nxcore_memory,3430940672.0 +15,node_t002-nxcore_memory,1073741824.0 +16,node_t002-nxcore_memory,3430940672.0 +17,node_t002-nxcore_memory,1073741824.0 +18,node_t002-nxcore_memory,3430940672.0 +19,node_t002-nxcore_memory,1073741824.0 +20,node_t002-nxcore_memory,3695181824.0 +21,node_t002-nxcore_memory,1073741824.0 +22,node_t002-nxcore_memory,3430940672.0 +23,node_t002-nxcore_memory,1073741824.0 +24,node_t002-nxcore_memory,3430940672.0 +25,node_t002-nxcore_memory,1073741824.0 +26,node_t002-nxcore_memory,3430940672.0 +27,node_t002-nxcore_memory,1073741824.0 +28,node_t002-nxcore_memory,3430940672.0 +29,node_t002-nxcore_memory,1073741824.0 +30,node_t002-nxcore_memory,3695181824.0 +31,node_t002-nxcore_memory,1073741824.0 +32,node_t002-nxcore_memory,3430940672.0 +33,node_t002-nxcore_memory,1073741824.0 +34,node_t002-nxcore_memory,3430940672.0 +35,node_t002-nxcore_memory,1073741824.0 +36,node_t002-nxcore_memory,3430940672.0 +37,node_t002-nxcore_memory,1073741824.0 +38,node_t002-nxcore_memory,3430940672.0 +39,node_t002-nxcore_memory,1073741824.0 +40,node_t002-nxcore_memory,3695181824.0 +41,node_t002-nxcore_memory,1073741824.0 +42,node_t002-nxcore_memory,3430940672.0 +43,node_t002-nxcore_memory,1073741824.0 +44,node_t002-nxcore_memory,3430940672.0 +45,node_t002-nxcore_memory,1073741824.0 +46,node_t002-nxcore_memory,3430940672.0 +47,node_t002-nxcore_memory,1073741824.0 +48,node_t002-nxcore_memory,3430940672.0 +49,node_t002-nxcore_memory,1073741824.0 +0,node_t002-nxcore_power,9.199999809265137 +1,node_t002-nxcore_power,6.699999809265137 +2,node_t002-nxcore_power,10.0 +3,node_t002-nxcore_power,6.699999809265137 +4,node_t002-nxcore_power,10.0 +5,node_t002-nxcore_power,6.699999809265137 +6,node_t002-nxcore_power,10.0 +7,node_t002-nxcore_power,6.699999809265137 +8,node_t002-nxcore_power,10.0 +9,node_t002-nxcore_power,6.699999809265137 +10,node_t002-nxcore_power,9.199999809265137 +11,node_t002-nxcore_power,6.699999809265137 +12,node_t002-nxcore_power,10.0 +13,node_t002-nxcore_power,6.699999809265137 +14,node_t002-nxcore_power,10.0 +15,node_t002-nxcore_power,6.699999809265137 +16,node_t002-nxcore_power,10.0 +17,node_t002-nxcore_power,6.699999809265137 +18,node_t002-nxcore_power,10.0 +19,node_t002-nxcore_power,6.699999809265137 +20,node_t002-nxcore_power,9.199999809265137 +21,node_t002-nxcore_power,6.699999809265137 +22,node_t002-nxcore_power,10.0 +23,node_t002-nxcore_power,6.699999809265137 +24,node_t002-nxcore_power,10.0 +25,node_t002-nxcore_power,6.699999809265137 +26,node_t002-nxcore_power,10.0 +27,node_t002-nxcore_power,6.699999809265137 +28,node_t002-nxcore_power,10.0 +29,node_t002-nxcore_power,6.699999809265137 +30,node_t002-nxcore_power,9.199999809265137 +31,node_t002-nxcore_power,6.699999809265137 +32,node_t002-nxcore_power,10.0 +33,node_t002-nxcore_power,6.699999809265137 +34,node_t002-nxcore_power,10.0 +35,node_t002-nxcore_power,6.699999809265137 +36,node_t002-nxcore_power,10.0 +37,node_t002-nxcore_power,6.699999809265137 +38,node_t002-nxcore_power,10.0 +39,node_t002-nxcore_power,6.699999809265137 +40,node_t002-nxcore_power,9.199999809265137 +41,node_t002-nxcore_power,6.699999809265137 +42,node_t002-nxcore_power,10.0 +43,node_t002-nxcore_power,6.699999809265137 +44,node_t002-nxcore_power,10.0 +45,node_t002-nxcore_power,6.699999809265137 +46,node_t002-nxcore_power,10.0 +47,node_t002-nxcore_power,6.699999809265137 +48,node_t002-nxcore_power,10.0 +49,node_t002-nxcore_power,6.699999809265137 +0,node_t002-nxcore_power_moving_average,9.199999809265137 +1,node_t002-nxcore_power_moving_average,6.699999809265137 +2,node_t002-nxcore_power_moving_average,10.0 +3,node_t002-nxcore_power_moving_average,6.699999809265137 +4,node_t002-nxcore_power_moving_average,10.0 +5,node_t002-nxcore_power_moving_average,6.699999809265137 +6,node_t002-nxcore_power_moving_average,10.0 +7,node_t002-nxcore_power_moving_average,6.699999809265137 +8,node_t002-nxcore_power_moving_average,10.0 +9,node_t002-nxcore_power_moving_average,6.699999809265137 +10,node_t002-nxcore_power_moving_average,9.199999809265137 +11,node_t002-nxcore_power_moving_average,6.699999809265137 +12,node_t002-nxcore_power_moving_average,10.0 +13,node_t002-nxcore_power_moving_average,6.699999809265137 +14,node_t002-nxcore_power_moving_average,10.0 +15,node_t002-nxcore_power_moving_average,6.699999809265137 +16,node_t002-nxcore_power_moving_average,10.0 +17,node_t002-nxcore_power_moving_average,6.699999809265137 +18,node_t002-nxcore_power_moving_average,10.0 +19,node_t002-nxcore_power_moving_average,6.699999809265137 +20,node_t002-nxcore_power_moving_average,9.199999809265137 +21,node_t002-nxcore_power_moving_average,6.699999809265137 +22,node_t002-nxcore_power_moving_average,10.0 +23,node_t002-nxcore_power_moving_average,6.699999809265137 +24,node_t002-nxcore_power_moving_average,10.0 +25,node_t002-nxcore_power_moving_average,6.699999809265137 +26,node_t002-nxcore_power_moving_average,10.0 +27,node_t002-nxcore_power_moving_average,6.699999809265137 +28,node_t002-nxcore_power_moving_average,10.0 +29,node_t002-nxcore_power_moving_average,6.699999809265137 +30,node_t002-nxcore_power_moving_average,9.199999809265137 +31,node_t002-nxcore_power_moving_average,6.699999809265137 +32,node_t002-nxcore_power_moving_average,10.0 +33,node_t002-nxcore_power_moving_average,6.699999809265137 +34,node_t002-nxcore_power_moving_average,10.0 +35,node_t002-nxcore_power_moving_average,6.699999809265137 +36,node_t002-nxcore_power_moving_average,10.0 +37,node_t002-nxcore_power_moving_average,6.699999809265137 +38,node_t002-nxcore_power_moving_average,10.0 +39,node_t002-nxcore_power_moving_average,6.699999809265137 +40,node_t002-nxcore_power_moving_average,9.199999809265137 +41,node_t002-nxcore_power_moving_average,6.699999809265137 +42,node_t002-nxcore_power_moving_average,10.0 +43,node_t002-nxcore_power_moving_average,6.699999809265137 +44,node_t002-nxcore_power_moving_average,10.0 +45,node_t002-nxcore_power_moving_average,6.699999809265137 +46,node_t002-nxcore_power_moving_average,10.0 +47,node_t002-nxcore_power_moving_average,6.699999809265137 +48,node_t002-nxcore_power_moving_average,10.0 +49,node_t002-nxcore_power_moving_average,6.699999809265137 +0,node_t002-nxcore_finished_workloads,2.0 +1,node_t002-nxcore_finished_workloads,3.0 +2,node_t002-nxcore_finished_workloads,5.0 +3,node_t002-nxcore_finished_workloads,6.0 +4,node_t002-nxcore_finished_workloads,8.0 +5,node_t002-nxcore_finished_workloads,9.0 +6,node_t002-nxcore_finished_workloads,11.0 +7,node_t002-nxcore_finished_workloads,12.0 +8,node_t002-nxcore_finished_workloads,14.0 +9,node_t002-nxcore_finished_workloads,15.0 +10,node_t002-nxcore_finished_workloads,17.0 +11,node_t002-nxcore_finished_workloads,18.0 +12,node_t002-nxcore_finished_workloads,20.0 +13,node_t002-nxcore_finished_workloads,21.0 +14,node_t002-nxcore_finished_workloads,23.0 +15,node_t002-nxcore_finished_workloads,24.0 +16,node_t002-nxcore_finished_workloads,26.0 +17,node_t002-nxcore_finished_workloads,27.0 +18,node_t002-nxcore_finished_workloads,29.0 +19,node_t002-nxcore_finished_workloads,30.0 +20,node_t002-nxcore_finished_workloads,32.0 +21,node_t002-nxcore_finished_workloads,33.0 +22,node_t002-nxcore_finished_workloads,35.0 +23,node_t002-nxcore_finished_workloads,36.0 +24,node_t002-nxcore_finished_workloads,38.0 +25,node_t002-nxcore_finished_workloads,39.0 +26,node_t002-nxcore_finished_workloads,41.0 +27,node_t002-nxcore_finished_workloads,42.0 +28,node_t002-nxcore_finished_workloads,44.0 +29,node_t002-nxcore_finished_workloads,45.0 +30,node_t002-nxcore_finished_workloads,47.0 +31,node_t002-nxcore_finished_workloads,48.0 +32,node_t002-nxcore_finished_workloads,50.0 +33,node_t002-nxcore_finished_workloads,51.0 +34,node_t002-nxcore_finished_workloads,53.0 +35,node_t002-nxcore_finished_workloads,54.0 +36,node_t002-nxcore_finished_workloads,56.0 +37,node_t002-nxcore_finished_workloads,57.0 +38,node_t002-nxcore_finished_workloads,59.0 +39,node_t002-nxcore_finished_workloads,60.0 +40,node_t002-nxcore_finished_workloads,62.0 +41,node_t002-nxcore_finished_workloads,63.0 +42,node_t002-nxcore_finished_workloads,65.0 +43,node_t002-nxcore_finished_workloads,66.0 +44,node_t002-nxcore_finished_workloads,68.0 +45,node_t002-nxcore_finished_workloads,69.0 +46,node_t002-nxcore_finished_workloads,71.0 +47,node_t002-nxcore_finished_workloads,72.0 +48,node_t002-nxcore_finished_workloads,74.0 +49,node_t002-nxcore_finished_workloads,75.0 +0,node_t002-nxcore_running_workloads,0.0 +1,node_t002-nxcore_running_workloads,0.0 +2,node_t002-nxcore_running_workloads,0.0 +3,node_t002-nxcore_running_workloads,0.0 +4,node_t002-nxcore_running_workloads,0.0 +5,node_t002-nxcore_running_workloads,0.0 +6,node_t002-nxcore_running_workloads,0.0 +7,node_t002-nxcore_running_workloads,0.0 +8,node_t002-nxcore_running_workloads,0.0 +9,node_t002-nxcore_running_workloads,0.0 +10,node_t002-nxcore_running_workloads,0.0 +11,node_t002-nxcore_running_workloads,0.0 +12,node_t002-nxcore_running_workloads,0.0 +13,node_t002-nxcore_running_workloads,0.0 +14,node_t002-nxcore_running_workloads,0.0 +15,node_t002-nxcore_running_workloads,0.0 +16,node_t002-nxcore_running_workloads,0.0 +17,node_t002-nxcore_running_workloads,0.0 +18,node_t002-nxcore_running_workloads,0.0 +19,node_t002-nxcore_running_workloads,0.0 +20,node_t002-nxcore_running_workloads,0.0 +21,node_t002-nxcore_running_workloads,0.0 +22,node_t002-nxcore_running_workloads,0.0 +23,node_t002-nxcore_running_workloads,0.0 +24,node_t002-nxcore_running_workloads,0.0 +25,node_t002-nxcore_running_workloads,0.0 +26,node_t002-nxcore_running_workloads,0.0 +27,node_t002-nxcore_running_workloads,0.0 +28,node_t002-nxcore_running_workloads,0.0 +29,node_t002-nxcore_running_workloads,0.0 +30,node_t002-nxcore_running_workloads,0.0 +31,node_t002-nxcore_running_workloads,0.0 +32,node_t002-nxcore_running_workloads,0.0 +33,node_t002-nxcore_running_workloads,0.0 +34,node_t002-nxcore_running_workloads,0.0 +35,node_t002-nxcore_running_workloads,0.0 +36,node_t002-nxcore_running_workloads,0.0 +37,node_t002-nxcore_running_workloads,0.0 +38,node_t002-nxcore_running_workloads,0.0 +39,node_t002-nxcore_running_workloads,0.0 +40,node_t002-nxcore_running_workloads,0.0 +41,node_t002-nxcore_running_workloads,0.0 +42,node_t002-nxcore_running_workloads,0.0 +43,node_t002-nxcore_running_workloads,0.0 +44,node_t002-nxcore_running_workloads,0.0 +45,node_t002-nxcore_running_workloads,0.0 +46,node_t002-nxcore_running_workloads,0.0 +47,node_t002-nxcore_running_workloads,0.0 +48,node_t002-nxcore_running_workloads,0.0 +49,node_t002-nxcore_running_workloads,0.0 +0,cluster_pending_workloads,0.0 +1,cluster_pending_workloads,0.0 +2,cluster_pending_workloads,0.0 +3,cluster_pending_workloads,0.0 +4,cluster_pending_workloads,0.0 +5,cluster_pending_workloads,0.0 +6,cluster_pending_workloads,0.0 +7,cluster_pending_workloads,0.0 +8,cluster_pending_workloads,0.0 +9,cluster_pending_workloads,0.0 +10,cluster_pending_workloads,0.0 +11,cluster_pending_workloads,0.0 +12,cluster_pending_workloads,0.0 +13,cluster_pending_workloads,0.0 +14,cluster_pending_workloads,0.0 +15,cluster_pending_workloads,0.0 +16,cluster_pending_workloads,0.0 +17,cluster_pending_workloads,0.0 +18,cluster_pending_workloads,0.0 +19,cluster_pending_workloads,0.0 +20,cluster_pending_workloads,0.0 +21,cluster_pending_workloads,0.0 +22,cluster_pending_workloads,0.0 +23,cluster_pending_workloads,0.0 +24,cluster_pending_workloads,0.0 +25,cluster_pending_workloads,0.0 +26,cluster_pending_workloads,0.0 +27,cluster_pending_workloads,0.0 +28,cluster_pending_workloads,0.0 +29,cluster_pending_workloads,0.0 +30,cluster_pending_workloads,0.0 +31,cluster_pending_workloads,0.0 +32,cluster_pending_workloads,0.0 +33,cluster_pending_workloads,0.0 +34,cluster_pending_workloads,0.0 +35,cluster_pending_workloads,0.0 +36,cluster_pending_workloads,0.0 +37,cluster_pending_workloads,0.0 +38,cluster_pending_workloads,0.0 +39,cluster_pending_workloads,0.0 +40,cluster_pending_workloads,0.0 +41,cluster_pending_workloads,0.0 +42,cluster_pending_workloads,0.0 +43,cluster_pending_workloads,0.0 +44,cluster_pending_workloads,0.0 +45,cluster_pending_workloads,0.0 +46,cluster_pending_workloads,0.0 +47,cluster_pending_workloads,0.0 +48,cluster_pending_workloads,0.0 +49,cluster_pending_workloads,0.0 +0,cluster_total_workloads,5.0 +1,cluster_total_workloads,7.0 +2,cluster_total_workloads,11.0 +3,cluster_total_workloads,13.0 +4,cluster_total_workloads,17.0 +5,cluster_total_workloads,19.0 +6,cluster_total_workloads,23.0 +7,cluster_total_workloads,25.0 +8,cluster_total_workloads,29.0 +9,cluster_total_workloads,31.0 +10,cluster_total_workloads,36.0 +11,cluster_total_workloads,38.0 +12,cluster_total_workloads,42.0 +13,cluster_total_workloads,44.0 +14,cluster_total_workloads,48.0 +15,cluster_total_workloads,50.0 +16,cluster_total_workloads,54.0 +17,cluster_total_workloads,56.0 +18,cluster_total_workloads,60.0 +19,cluster_total_workloads,62.0 +20,cluster_total_workloads,67.0 +21,cluster_total_workloads,69.0 +22,cluster_total_workloads,73.0 +23,cluster_total_workloads,75.0 +24,cluster_total_workloads,79.0 +25,cluster_total_workloads,81.0 +26,cluster_total_workloads,85.0 +27,cluster_total_workloads,87.0 +28,cluster_total_workloads,91.0 +29,cluster_total_workloads,93.0 +30,cluster_total_workloads,98.0 +31,cluster_total_workloads,100.0 +32,cluster_total_workloads,104.0 +33,cluster_total_workloads,106.0 +34,cluster_total_workloads,110.0 +35,cluster_total_workloads,112.0 +36,cluster_total_workloads,116.0 +37,cluster_total_workloads,118.0 +38,cluster_total_workloads,122.0 +39,cluster_total_workloads,124.0 +40,cluster_total_workloads,129.0 +41,cluster_total_workloads,131.0 +42,cluster_total_workloads,135.0 +43,cluster_total_workloads,137.0 +44,cluster_total_workloads,141.0 +45,cluster_total_workloads,143.0 +46,cluster_total_workloads,147.0 +47,cluster_total_workloads,149.0 +48,cluster_total_workloads,153.0 +49,cluster_total_workloads,155.0 +0,cluster_qos_data_production,1.0 +1,cluster_qos_data_production,1.0 +2,cluster_qos_data_production,1.0 +3,cluster_qos_data_production,1.0 +4,cluster_qos_data_production,1.0 +5,cluster_qos_data_production,1.0 +6,cluster_qos_data_production,1.0 +7,cluster_qos_data_production,1.0 +8,cluster_qos_data_production,1.0 +9,cluster_qos_data_production,1.0 +10,cluster_qos_data_production,1.0 +11,cluster_qos_data_production,1.0 +12,cluster_qos_data_production,1.0 +13,cluster_qos_data_production,1.0 +14,cluster_qos_data_production,1.0 +15,cluster_qos_data_production,1.0 +16,cluster_qos_data_production,1.0 +17,cluster_qos_data_production,1.0 +18,cluster_qos_data_production,1.0 +19,cluster_qos_data_production,1.0 +20,cluster_qos_data_production,1.0 +21,cluster_qos_data_production,1.0 +22,cluster_qos_data_production,1.0 +23,cluster_qos_data_production,1.0 +24,cluster_qos_data_production,1.0 +25,cluster_qos_data_production,1.0 +26,cluster_qos_data_production,1.0 +27,cluster_qos_data_production,1.0 +28,cluster_qos_data_production,1.0 +29,cluster_qos_data_production,1.0 +30,cluster_qos_data_production,1.0 +31,cluster_qos_data_production,1.0 +32,cluster_qos_data_production,1.0 +33,cluster_qos_data_production,1.0 +34,cluster_qos_data_production,1.0 +35,cluster_qos_data_production,1.0 +36,cluster_qos_data_production,1.0 +37,cluster_qos_data_production,1.0 +38,cluster_qos_data_production,1.0 +39,cluster_qos_data_production,1.0 +40,cluster_qos_data_production,1.0 +41,cluster_qos_data_production,1.0 +42,cluster_qos_data_production,1.0 +43,cluster_qos_data_production,1.0 +44,cluster_qos_data_production,1.0 +45,cluster_qos_data_production,1.0 +46,cluster_qos_data_production,1.0 +47,cluster_qos_data_production,1.0 +48,cluster_qos_data_production,1.0 +49,cluster_qos_data_production,1.0 From a0db2bff712ac5ed5c3b2ad48b322949bfc8145d Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Wed, 23 Jul 2025 11:51:47 -0500 Subject: [PATCH 28/37] Implement feature X to enhance user experience and optimize performance --- .../src/scripts/vis-interactive.ipynb | 248 ++++++++++++++++++ 1 file changed, 248 insertions(+) create mode 100644 simulation/kubernetes/src/scripts/vis-interactive.ipynb diff --git a/simulation/kubernetes/src/scripts/vis-interactive.ipynb b/simulation/kubernetes/src/scripts/vis-interactive.ipynb new file mode 100644 index 0000000..9ae5829 --- /dev/null +++ b/simulation/kubernetes/src/scripts/vis-interactive.ipynb @@ -0,0 +1,248 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "422392b9", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8c8085a1", + "metadata": {}, + "outputs": [], + "source": [ + "def preprocess_fair_scheduler_log(input_csv):\n", + " \"\"\"\n", + " Reads FairScheduler_task_log.csv and returns a DataFrame with columns:\n", + " step, node_id, start_time, end_time, cpu, energy\n", + " \"\"\"\n", + " df = pd.read_csv(input_csv)\n", + " # Extract node_id from tag (first part before '-')\n", + " df['node_id'] = df['tag'].apply(lambda x: x.split('-')[0])\n", + " # Identify metric type\n", + " df['metric'] = df['tag'].apply(lambda x: 'energy' if 'energy' in x else ('cpu' if 'cpu' in x else None))\n", + " # Only keep rows with energy or cpu\n", + " df = df[df['metric'].notnull()]\n", + " # Pivot so each (step, node_id) has columns for cpu and energy\n", + " pivot = df.pivot_table(index=['step', 'node_id'], columns='metric', values='value', aggfunc='first').reset_index()\n", + " # Add start_time and end_time columns (empty for now)\n", + " pivot['start_time'] = ''\n", + " pivot['end_time'] = ''\n", + " # Reorder columns\n", + " pivot = pivot[['step', 'node_id', 'start_time', 'end_time', 'cpu', 'energy']]\n", + " print(f\"[INFO] Preprocessed DataFrame created from {input_csv}\")\n", + " return pivot" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "92eeb31d", + "metadata": {}, + "outputs": [], + "source": [ + "filename1 = '../../../FairShareScheduler_task_log.csv'\n", + "filename2 = '../../../WaggleScheduler_task_log.csv'" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "4759632f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[INFO] Preprocessed DataFrame created from ../../../FairShareScheduler_task_log.csv\n" + ] + } + ], + "source": [ + "df = preprocess_fair_scheduler_log(filename)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "5cf3f1da", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for node, group in df.groupby(\"node_id\"):\n", + " fig, ax1 = plt.subplots(figsize=(8, 4))\n", + " ax2 = ax1.twinx()\n", + " ax1.plot(group[\"step\"], group[\"cpu\"], color=\"tab:blue\", label=\"CPU\")\n", + " ax2.plot(group[\"step\"], group[\"energy\"], color=\"tab:orange\", label=\"Energy\")\n", + " ax1.set_xlabel(\"Step\")\n", + " ax1.set_ylabel(\"CPU (millicore)\", color=\"tab:blue\")\n", + " ax2.set_ylabel(\"Energy (Joule)\", color=\"tab:orange\")\n", + " plt.title(f\"CPU and Energy Usage for {node}\")\n", + " ax1.legend(loc=\"upper left\")\n", + " ax2.legend(loc=\"upper right\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "a1280789", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU statistics:\n", + "\n", + "Statistics for node_t001:\n", + "count 50.000000\n", + "mean 1800.000000\n", + "std 1841.693985\n", + "min 0.000000\n", + "25% 0.000000\n", + "50% 1750.000000\n", + "75% 3500.000000\n", + "max 5600.000000\n", + "Name: cpu, dtype: float64\n", + "\n", + "Statistics for node_t002:\n", + "count 50.000000\n", + "mean 2460.000000\n", + "std 613.121821\n", + "min 0.000000\n", + "25% 2000.000000\n", + "50% 2500.000000\n", + "75% 3000.000000\n", + "max 3000.000000\n", + "Name: cpu, dtype: float64\n", + "count 50.000000\n", + "mean 2460.000000\n", + "std 613.121821\n", + "min 0.000000\n", + "25% 2000.000000\n", + "50% 2500.000000\n", + "75% 3000.000000\n", + "max 3000.000000\n", + "Name: cpu, dtype: float64\n" + ] + } + ], + "source": [ + "print(\"CPU statistics:\")\n", + "for node, group in df.groupby(\"node_id\"):\n", + " print(f\"\\nStatistics for {node}:\")\n", + " print(group[\"cpu\"].describe())\n", + "print(group[\"cpu\"].describe())" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "c8079cbc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[INFO] Preprocessed DataFrame created from ../../../FairShareScheduler_task_log.csv\n", + "[INFO] Preprocessed DataFrame created from ../../../WaggleScheduler_task_log.csv\n", + "CPU Statistics Comparison (mean, std, min, 25%, 50%, 75%, max):\n", + "\n", + "\n", + "Node: node_t001\n", + "Stat | FairShare | Waggle\n", + "----------------------------------\n", + "mean | 1800.00000 | 2310.00000\n", + "std | 1841.69399 | 356.99997\n", + "min | 0.00000 | 2000.00000\n", + "25% | 0.00000 | 2000.00000\n", + "50% | 1750.00000 | 2250.00000\n", + "75% | 3500.00000 | 2500.00000\n", + "max | 5600.00000 | 3100.00000\n", + "\n", + "Node: node_t002\n", + "Stat | FairShare | Waggle\n", + "----------------------------------\n", + "mean | 2460.00000 | 1950.00000\n", + "std | 613.12182 | 970.21984\n", + "min | 0.00000 | 1000.00000\n", + "25% | 2000.00000 | 1000.00000\n", + "50% | 2500.00000 | 1750.00000\n", + "75% | 3000.00000 | 3000.00000\n", + "max | 3000.00000 | 3000.00000\n" + ] + } + ], + "source": [ + "df1 = preprocess_fair_scheduler_log(filename1)\n", + "df2 = preprocess_fair_scheduler_log(filename2)\n", + "\n", + "print(\"CPU Statistics Comparison (mean, std, min, 25%, 50%, 75%, max):\\n\")\n", + "for node in sorted(set(df1['node_id']).union(df2['node_id'])):\n", + " stats1 = df1[df1['node_id'] == node]['cpu'].describe()\n", + " stats2 = df2[df2['node_id'] == node]['cpu'].describe()\n", + " print(f\"\\nNode: {node}\")\n", + " print(f\"{'Stat':<8} | {'FairShare':>10} | {'Waggle':>10}\")\n", + " print(\"-\" * 34)\n", + " for stat in ['mean', 'std', 'min', '25%', '50%', '75%', 'max']:\n", + " val1 = stats1.get(stat, float('nan'))\n", + " val2 = stats2.get(stat, float('nan'))\n", + " print(f\"{stat:<8} | {val1:10.5f} | {val2:10.5f}\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From e29e3d4591de30449409c6d3c01248ba45b7352b Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Wed, 23 Jul 2025 11:55:40 -0500 Subject: [PATCH 29/37] Refactor CSVexport.py: remove unused functions and update log file paths for clarity --- .../kubernetes/src/scripts/CSVexport.py | 138 +----------------- 1 file changed, 2 insertions(+), 136 deletions(-) diff --git a/simulation/kubernetes/src/scripts/CSVexport.py b/simulation/kubernetes/src/scripts/CSVexport.py index 71a87a2..bcc27d7 100644 --- a/simulation/kubernetes/src/scripts/CSVexport.py +++ b/simulation/kubernetes/src/scripts/CSVexport.py @@ -33,128 +33,6 @@ def tensorboard_to_csv(log_dir, output_csv): df.to_csv(output_csv, index=False) print(f"[INFO] Export complete. CSV saved to: {output_csv}") - -def compute_node_metrics(task_log_path, scheduler_name): - if not os.path.exists(task_log_path): - print(f"[ERROR] Log file not found: {task_log_path}") - return None - - df = pd.read_csv(task_log_path) - - if not {"task_id", "node_id", "start_time", "end_time", "energy_used_j"}.issubset(df.columns): - print(f"[ERROR] Missing required columns in: {task_log_path}") - return None - - - df["exec_time"] = df["end_time"] - df["start_time"] - - grouped = df.groupby("node_id").agg( - num_tasks=('task_id', 'count'), - mean_energy=('energy_used_j', 'mean'), - total_energy=('energy_used_j', 'sum'), - max_energy=('energy_used_j', 'max'), - min_energy=('energy_used_j', 'min'), - avg_task_time=('exec_time', 'mean'), - std_task_time=('exec_time', 'std'), - total_exec_time=('exec_time', 'sum') - - ).reset_index() - # Optional CPU and Memory metrics - if "cpu_percent" in df.columns: - grouped["avg_cpu_percent"] = df.groupby("node_id")["cpu_percent"].mean().values - grouped["max_cpu_percent"] = df.groupby("node_id")["cpu_percent"].max().values - if "memory_mb" in df.columns: - grouped["max_memory_mb"] = df.groupby("node_id")["memory_mb"].max().values - # Efficiency = tasks per unit time - grouped["task_efficiency"] = grouped["num_tasks"] / grouped["total_exec_time"] - grouped["scheduler"] = scheduler_name - return grouped - -def compare_schedulers(log_dir, scheduler_list): - all_results = [] - for scheduler in scheduler_list: - log_path = os.path.join(log_dir, f"{scheduler}_task_log.csv") - metrics = compute_node_metrics(log_path, scheduler) - if metrics is not None: - all_results.append(metrics) - - if not all_results: - print("[ERROR] No scheduler data to compare.") - return None - - combined = pd.concat(all_results, ignore_index=True) - comparison_path = os.path.join(log_dir, "scheduler_comparison_metrics.csv") - combined.to_csv(comparison_path, index=False) - print(f"[INFO] Comparison metrics saved to: {comparison_path}") - return combined - - -def summarize_overall_scheduler_performance(df): - summary = df.groupby("scheduler").agg({ - "num_tasks": "sum", - "total_energy": "sum", - "avg_task_time": "mean", - "task_efficiency": "mean" - }).reset_index() - - print("\n=== Scheduler Summary ===") - print(summary) - - - # Plot using pandas - ax = summary.plot(x="scheduler", kind="bar", figsize=(10, 6), title="Scheduler Comparison") - ax.set_ylabel("Metric Value") - ax.set_xlabel("Scheduler") - plt.tight_layout() - plt.savefig("scheduler_summary_pandas_plot.png") - plt.show() - - return summary - - -# plot_metrics is not defined; use plot_metrics_per_scheduler instead -# plot_metrics(metrics_df, [ -# "mean_energy", "total_energy", "max_energy", "min_energy", -# "num_tasks", "avg_task_time", "std_task_time", "task_efficiency", -# "avg_cpu", "peak_memory_mb"]) -# plot metrics, use the defined function: -# plot_metrics_per_scheduler(metrics_df) - - -def plot_metrics_per_scheduler(df, save_dir="plots"): - os.makedirs(save_dir, exist_ok=True) - - # Summarize key metrics per scheduler - - summary = df.groupby("scheduler").agg({ - - "num_tasks": "sum", - "total_energy": "sum", - "avg_task_time": "mean", - "task_efficiency": "mean" - - }).reset_index() - - - # Plot each metric - - for column in summary.columns[1:]: - - plt.figure(figsize=(8, 5)) - sns.barplot(data=summary, x="scheduler", y=column, palette="viridis") - plt.title(f"{column.replace('_', ' ').title()} per Scheduler") - plt.ylabel(column.replace('_', ' ').title()) - plt.xlabel("Scheduler") - plt.tight_layout() - - - plot_file = os.path.join(save_dir, f"{column}_per_scheduler.png") - plt.savefig(plot_file) - plt.close() - - print(f"[INFO] Saved: {plot_file}") - - def pick_log_dir(base_dir, strategy="latest"): log_folders = [ os.path.join(base_dir, f) for f in os.listdir(base_dir) @@ -172,9 +50,9 @@ def pick_log_dir(base_dir, strategy="latest"): if __name__ == "__main__": # === Part 1: Export TensorBoard scalars === - log_dir_event_file = "kubernetes/logs/20250702-171434" # Path to the TensorBoard event file + log_dir_event_file = "kubernetes/logs/20250723-111951-FairShareScheduler" # Path to the TensorBoard event file # Note: Adjust the path to your actual TensorBoard event file location - output_csv = "scheduler_metrics.csv" + output_csv = "FairShareScheduler_task_log.csv" if os.path.exists(log_dir_event_file): tensorboard_to_csv(log_dir_event_file, output_csv) @@ -207,15 +85,3 @@ def simulate_scheduler_log(log_dir, scheduler_name, num_steps=10): print(f"[INFO] Created log at: {path}") - -if __name__ == "__main__": - # Simulate dummy logs for two schedulers - simulate_scheduler_log("logs", "RandomScheduler") - simulate_scheduler_log("logs", "FairScheduler") - - # Compare them - metrics_df = compare_schedulers("logs", ["RandomScheduler", "FairScheduler"]) - - if metrics_df is not None: - summarize_overall_scheduler_performance(metrics_df) - plot_metrics_per_scheduler(metrics_df) \ No newline at end of file From ea7a5a34fe5040928d28f267dc2daaf8899488f4 Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Wed, 23 Jul 2025 11:56:26 -0500 Subject: [PATCH 30/37] Add visualization module: implement functions for summarizing and plotting scheduler performance metrics --- .../kubernetes/src/scripts/visualization.py | 167 ++++++++++++++++++ 1 file changed, 167 insertions(+) create mode 100644 simulation/kubernetes/src/scripts/visualization.py diff --git a/simulation/kubernetes/src/scripts/visualization.py b/simulation/kubernetes/src/scripts/visualization.py new file mode 100644 index 0000000..1dd3de0 --- /dev/null +++ b/simulation/kubernetes/src/scripts/visualization.py @@ -0,0 +1,167 @@ +import os +import pandas as pd +import matplotlib.pyplot as plt +import seaborn as sns + +def summarize_overall_scheduler_performance(df): + summary = df.groupby("scheduler").agg({ + "num_tasks": "sum", + "total_energy": "sum", + "avg_task_time": "mean", + "task_efficiency": "mean" + }).reset_index() + + print("\n=== Scheduler Summary ===") + print(summary) + + + # Plot using pandas + ax = summary.plot(x="scheduler", kind="bar", figsize=(10, 6), title="Scheduler Comparison") + ax.set_ylabel("Metric Value") + ax.set_xlabel("Scheduler") + plt.tight_layout() + plt.savefig("scheduler_summary_pandas_plot.png") + plt.show() + + return summary + + + + +# plot_metrics is not defined; use plot_metrics_per_scheduler instead +# plot_metrics(metrics_df, [ +# "mean_energy", "total_energy", "max_energy", "min_energy", +# "num_tasks", "avg_task_time", "std_task_time", "task_efficiency", +# "avg_cpu", "peak_memory_mb"]) +# plot metrics, use the defined function: +# plot_metrics_per_scheduler(metrics_df) + + +def plot_metrics_per_scheduler(df, save_dir="plots"): + os.makedirs(save_dir, exist_ok=True) + + # Summarize key metrics per scheduler + + summary = df.groupby("scheduler").agg({ + + "num_tasks": "sum", + "total_energy": "sum", + "avg_task_time": "mean", + "task_efficiency": "mean" + + }).reset_index() + + + # Plot each metric + + for column in summary.columns[1:]: + + plt.figure(figsize=(8, 5)) + sns.barplot(data=summary, x="scheduler", y=column, palette="viridis") + plt.title(f"{column.replace('_', ' ').title()} per Scheduler") + plt.ylabel(column.replace('_', ' ').title()) + plt.xlabel("Scheduler") + plt.tight_layout() + + + plot_file = os.path.join(save_dir, f"{column}_per_scheduler.png") + plt.savefig(plot_file) + plt.close() + + print(f"[INFO] Saved: {plot_file}") + +def compare_schedulers(log_dir, scheduler_list): + all_results = [] + for scheduler in scheduler_list: + log_path = os.path.join(log_dir, f"{scheduler}_task_log.csv") + metrics = compute_node_metrics(log_path, scheduler) + if metrics is not None: + all_results.append(metrics) + + if not all_results: + print("[ERROR] No scheduler data to compare.") + return None + + combined = pd.concat(all_results, ignore_index=True) + comparison_path = os.path.join(log_dir, "scheduler_comparison_metrics.csv") + combined.to_csv(comparison_path, index=False) + print(f"[INFO] Comparison metrics saved to: {comparison_path}") + return combined + +def compute_node_metrics(task_log_path, scheduler_name): + if not os.path.exists(task_log_path): + print(f"[ERROR] Log file not found: {task_log_path}") + return None + + df = preprocess_fair_scheduler_log(task_log_path) + + + + if not {"step", "node_id", "energy_used_j"}.issubset(df.columns): + print(f"[ERROR] Missing required columns in: {task_log_path}") + return None + + + # df["exec_time"] = df["end_time"] - df["start_time"] + + grouped = df.groupby("node_id").agg( + num_tasks=('task_id', 'count'), + mean_energy=('energy_used_j', 'mean'), + total_energy=('energy_used_j', 'sum'), + max_energy=('energy_used_j', 'max'), + min_energy=('energy_used_j', 'min'), + avg_task_time=('exec_time', 'mean'), + std_task_time=('exec_time', 'std'), + total_exec_time=('exec_time', 'sum') + + ).reset_index() + # Optional CPU and Memory metrics + if "cpu_percent" in df.columns: + grouped["avg_cpu_percent"] = df.groupby("node_id")["cpu_percent"].mean().values + grouped["max_cpu_percent"] = df.groupby("node_id")["cpu_percent"].max().values + if "memory_mb" in df.columns: + grouped["max_memory_mb"] = df.groupby("node_id")["memory_mb"].max().values + # Efficiency = tasks per unit time + grouped["task_efficiency"] = grouped["num_tasks"] / grouped["total_exec_time"] + grouped["scheduler"] = scheduler_name + return grouped + + + + +def preprocess_fair_scheduler_log(input_csv): + """ + Reads FairScheduler_task_log.csv and returns a DataFrame with columns: + step, node_id, start_time, end_time, cpu, energy + """ + df = pd.read_csv(input_csv) + # Extract node_id from tag (first part before '-') + df['node_id'] = df['tag'].apply(lambda x: x.split('-')[0]) + # Identify metric type + df['metric'] = df['tag'].apply(lambda x: 'energy' if 'energy' in x else ('cpu' if 'cpu' in x else None)) + # Only keep rows with energy or cpu + df = df[df['metric'].notnull()] + # Pivot so each (step, node_id) has columns for cpu and energy + pivot = df.pivot_table(index=['step', 'node_id'], columns='metric', values='value', aggfunc='first').reset_index() + # Add start_time and end_time columns (empty for now) + pivot['start_time'] = '' + pivot['end_time'] = '' + # Reorder columns + pivot = pivot[['step', 'node_id', 'start_time', 'end_time', 'cpu', 'energy']] + print(f"[INFO] Preprocessed DataFrame created from {input_csv}") + return pivot + +if __name__ == "__main__": + # # Simulate dummy logs for two schedulers + # simulate_scheduler_log("logs", "RandomScheduler") + # simulate_scheduler_log("logs", "FairScheduler") + + # Preprocess the CSV + + + # Compare them + metrics_df = compare_schedulers("./", ["FairScheduler"]) + + if metrics_df is not None: + summarize_overall_scheduler_performance(metrics_df) + plot_metrics_per_scheduler(metrics_df) \ No newline at end of file From 094c229031381480180a5c76812efedd7aa8cfc5 Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Wed, 6 Aug 2025 12:27:51 -0500 Subject: [PATCH 31/37] Update README.md: enhance documentation for simulation setup, log retrieval, and visualization scripts --- simulation/kubernetes/README.md | 200 +++++++++++++++++++++++++++++++- 1 file changed, 199 insertions(+), 1 deletion(-) diff --git a/simulation/kubernetes/README.md b/simulation/kubernetes/README.md index 1284594..d0f4e0e 100644 --- a/simulation/kubernetes/README.md +++ b/simulation/kubernetes/README.md @@ -38,4 +38,202 @@ To create a cluster, ```bash ./setup.sh -``` \ No newline at end of file +``` + +## How to Run a Simulation + + +```bash + +python3 run.py --config mywaggle.yaml + + +To see plots on tensorboard +```bash +tensorboard --logdir logs/ +``` + + +TensorBoard will start a local web server. You’ll see output like: + +``` +TensorBoard 2.13 at http://localhost:6006/ (Press CTRL+C to quit) + +``` +Open your browser and go to: +``` +http://localhost:6006 +``` +#TODO descibe how to interpret results in tensorboard + + + +## File Overview (Visualization) + Description : + +| `scripts/CSVexport.py` | Handles saving of performance and energy metrics.| +#TODO : Be more specific in what csv export does + +| `src/scripts/visualization.py`| + +#TODO description + + + +| `/logs/` | Stores run logs including per-task and per-node metrics. | + + +| `/notebooks/` | Jupyter notebooks for post-simulation analysis and plotting. | + + + +# Requirements for Visualization + + +Make sure the following packages are installed: + +``` +pip install pandas matplotlib seaborn +``` + +## How to retrieve log to use for visualization +#### (Check which scheduler you ran from mywaggle.yaml ) + +-Go to logs and find the latest run or the run based on the date your looking for and change {DefaultScheduler} to the scheduler you ran . + + +## How to Generate Plots from Logs + +Scheduler Log Analysis & Visualization + + +This section explains the purpose and usage of the two Python scripts (CSVexport.py & visualization.py) used to extract, process, and visualize metrics from scheduler logs in the edge computing simulation project. + + +⸻ + + +1. CSVexport .py + + +Purpose: + +This script converts scalar logs from TensorBoard .tfevents files into a readable CSV format. It enables easier analysis of metrics like energy usage, task duration, or CPU load logged during the simulation. + + +What It Does: + +• Loads scalar values from TensorBoard logs. + +• Outputs a CSV file with columns: step, tag, and value. + +• Includes a helper to pick the latest log directory automatically. + +• Can also simulate logs using SummaryWriter (for testing visualizations). + + +How to Use: + +1. Make sure your TensorBoard event logs is in the logs folder. + +2. Set the log_dir_event_file path with the path of your event log in the script. By copying the directory name . +Ex: log_dir_event_file = "kubernetes/logs/20250723-111951-FairShareScheduler" # Path to the TensorBoard event file + +- change line 53 and 55 in CSV export based on which scheduler your running +Ex: output_csv = "FairShareScheduler_task_log.csv" + + +3. Run the script: + + - Change the directory by using cd src/scripts + + Go to CSVexport file +Run & Debug on left side panel in VScode or whatever code runner for your IDE + +or + +Bash +``` +python3 CSVexport.py +``` + +Output: a CSV file like FairShareScheduler_task_log.csv. + + +⸻ + + +2. Visualization .py + + +Purpose: + +This script analyzes one or more scheduler logs and compares key metrics such as task counts, energy usage, task durations, and efficiency across different schedulers. + + +Main Features: + +• Parses and preprocesses CSV logs. + +• Computes per-node metrics like: + +• Total and mean energy consumption + +• Task duration statistics + +• Task efficiency (tasks per unit time) + +• Optional: CPU and memory stats (if present in logs) + +• Aggregates and compares results across schedulers. + +• Generates bar charts and summary CSVs. + + +How to Use: + +1. Ensure you have one or more log CSVs from tensorboard_to_csv.py. + +2. Define your list of scheduler names (e.g., ["WaggleScheduler", "FairScheduler"]). + + +Go to +vis-interactive.ipynb + + Or + +Bash + +python3 visualization.py + + + + +# Outputs: + + +## Where Logs Are Saved + + +Simulation logs are saved to the /logs/ directory. You’ll find: +``` +• {scheduler name} tasks.csv: logs for all tasks (start time, end time, node used, energy consumed, etc.) +``` + + +• scheduler_comparison_metrics.csv: a summary table + +• .png plots for each metric in the plots/ directory + +• Console table summarizing each scheduler + + + +Example Output Plots: + +• total_energy_per_scheduler.png + +• avg_task_time_per_scheduler.png + +• task_efficiency_per_scheduler.png + From 0eaac3d1ac47f50d6b9948283bb0f389835d055a Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Wed, 6 Aug 2025 12:27:59 -0500 Subject: [PATCH 32/37] Update README.md: expand documentation on scheduling policies, file overview, and usage examples --- simulation/kubernetes/src/scheduler/README.md | 142 +++++++++++++++++- 1 file changed, 141 insertions(+), 1 deletion(-) diff --git a/simulation/kubernetes/src/scheduler/README.md b/simulation/kubernetes/src/scheduler/README.md index 44e84cb..dd7dfd5 100644 --- a/simulation/kubernetes/src/scheduler/README.md +++ b/simulation/kubernetes/src/scheduler/README.md @@ -1,2 +1,142 @@ # Scheduling Policy -Researchers are welcome to develop, test, and evaluate scheduling algorithms. \ No newline at end of file +Researchers are welcome to develop, test, and evaluate scheduling algorithms. + + +# Edge Computing Task Scheduler Simulation + + +This repository simulates different task scheduling strategies in an edge computing environment. It supports multiple schedulers, logs system performance, and allows users to visualize metrics like energy consumption and task throughput. + + +--- + + + +## File Overview + + +| File / Folder | Purpose | + + +| `run.py` | Entry point to start the simulation. Loads config, scheduler, and runs tasks. | + + +| `mywaggle.yaml` | Configuration file for nodes and workloads. | + + + + +--- + + +Kubernetes-Style Task Scheduling Simulation for Edge Devices + + +This module simulates different scheduling strategies for deploying workloads on a distributed set of edge compute nodes. It mimics a Kubernetes-style environment, enabling experimentation with resource-aware, energy-aware, and optimization-driven task schedulers. + + +Useful for: + +• Simulating energy-aware workload distribution. + +• Comparing different schedulers like greedy, workload-aware, or EDF. + +• Logging and visualizing node performance over time. + + +⸻ + + +Directory: simulation/kubernetes/src/scheduler/ + + +Each Python file in this folder implements a different scheduling policy. These schedulers determine how workloads are assigned to virtual nodes based on custom logic such as CPU load, fairness, task deadlines, or energy constraints. + + + +Scheduler Implementations + + +File + + +Description + +wagglecheduler.py + + +Baseline greedy scheduler: assigns each workload to the first node that can accept it, without optimization. Useful for comparison. + +fairsharescheduler.py + + +Picks the node with the least CPU usage that can fit the workload. Also has energy logging for each node. + +randomscheduler.py + + +Assigns each workload to a random node, regardless of resource availability. Serves as a naive baseline for performance comparison. + +workloadawarescheduler.py + + +Attempts to schedule based on workload characteristics such as size or type. Helps improve resource matching. + +edfscheduler.py + + +Implements Earliest Deadline First (EDF) scheduling to prioritize tasks with the closest deadlines. Useful for time-sensitive applications. + +centralized_solver.py + (under development) + +Uses a centralized optimization solver to compute global optimal task placement. Slower but more accurate in theory. + +dual_node.py + (under development) + +A dual-descent optimization node module used for refining resource allocation in schedulers like Fairshare. + +⸻ + + +🧵 Example: FairshareScheduler + +• Selects the least-loaded node by checking CPU usage. + +• Performs dual descent to optimize node configuration before scheduling. + +• Logs energy consumption based on CPU use (power = cpu × 2.5). + +• Compatible with TensorBoard scalar logging for visualization. + + +⸻ + + +🧵 Example: WaggleScheduler + +• Greedy-first approach: tries nodes in order and assigns to the first one that can accept the workload. + +• No optimization or energy-awareness — serves as a baseline. + + + + + +# How to Change the Scheduler +- change the scheduler to see different results + +In your config file (mywaggle.yaml), find the line: + +Scheduler: WaggleScheduler + +Or + +Scheduler : FairshareScheduler + + + +Then re-run run.py. + + From 625f91052c30edc301c43cbb9e2540438311752b Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Thu, 7 Aug 2025 20:36:33 -0500 Subject: [PATCH 33/37] Update README.md: improve formatting and section headers for better readability --- simulation/kubernetes/src/scheduler/README.md | 51 ++++++++----------- 1 file changed, 20 insertions(+), 31 deletions(-) diff --git a/simulation/kubernetes/src/scheduler/README.md b/simulation/kubernetes/src/scheduler/README.md index dd7dfd5..cb57097 100644 --- a/simulation/kubernetes/src/scheduler/README.md +++ b/simulation/kubernetes/src/scheduler/README.md @@ -29,13 +29,13 @@ This repository simulates different task scheduling strategies in an edge comput --- -Kubernetes-Style Task Scheduling Simulation for Edge Devices +#### Kubernetes-Style Task Scheduling Simulation for Edge Devices This module simulates different scheduling strategies for deploying workloads on a distributed set of edge compute nodes. It mimics a Kubernetes-style environment, enabling experimentation with resource-aware, energy-aware, and optimization-driven task schedulers. -Useful for: +#### Useful for: • Simulating energy-aware workload distribution. @@ -47,60 +47,51 @@ Useful for: ⸻ -Directory: simulation/kubernetes/src/scheduler/ +# Directory: simulation/kubernetes/src/scheduler/ Each Python file in this folder implements a different scheduling policy. These schedulers determine how workloads are assigned to virtual nodes based on custom logic such as CPU load, fairness, task deadlines, or energy constraints. -Scheduler Implementations -File - -Description +# File Description -wagglecheduler.py +### wagglecheduler.py - Baseline greedy scheduler: assigns each workload to the first node that can accept it, without optimization. Useful for comparison. -fairsharescheduler.py - +### fairsharescheduler.py Picks the node with the least CPU usage that can fit the workload. Also has energy logging for each node. -randomscheduler.py - +### randomscheduler.py + Assigns each workload to a random node, regardless of resource availability. Serves as a naive baseline for performance comparison. -workloadawarescheduler.py +### workloadawarescheduler.py - Attempts to schedule based on workload characteristics such as size or type. Helps improve resource matching. -edfscheduler.py - +### edfscheduler.py Implements Earliest Deadline First (EDF) scheduling to prioritize tasks with the closest deadlines. Useful for time-sensitive applications. -centralized_solver.py - (under development) +### centralized_solver.py (under development) Uses a centralized optimization solver to compute global optimal task placement. Slower but more accurate in theory. -dual_node.py - (under development) +### dual_node.py (under development) A dual-descent optimization node module used for refining resource allocation in schedulers like Fairshare. ⸻ -🧵 Example: FairshareScheduler +#### 🧵 Example: FairshareScheduler • Selects the least-loaded node by checking CPU usage. @@ -111,10 +102,10 @@ A dual-descent optimization node module used for refining resource allocation in • Compatible with TensorBoard scalar logging for visualization. -⸻ -🧵 Example: WaggleScheduler + +#### 🧵 Example: WaggleScheduler • Greedy-first approach: tries nodes in order and assigns to the first one that can accept the workload. @@ -128,15 +119,13 @@ A dual-descent optimization node module used for refining resource allocation in - change the scheduler to see different results In your config file (mywaggle.yaml), find the line: - +``` Scheduler: WaggleScheduler - +``` Or - -Scheduler : FairshareScheduler - - - +``` +Scheduler : FairShareScheduler +``` Then re-run run.py. From 90cb458cb2f73332d0d375c3a8648d13dfa1cced Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Thu, 7 Aug 2025 20:36:47 -0500 Subject: [PATCH 34/37] Update README.md: enhance TensorBoard interpretation section and clarify CSV export functionality --- simulation/kubernetes/README.md | 89 ++++++++++++++++++++++----------- 1 file changed, 60 insertions(+), 29 deletions(-) diff --git a/simulation/kubernetes/README.md b/simulation/kubernetes/README.md index d0f4e0e..62a0ad4 100644 --- a/simulation/kubernetes/README.md +++ b/simulation/kubernetes/README.md @@ -46,7 +46,7 @@ To create a cluster, ```bash python3 run.py --config mywaggle.yaml - +``` To see plots on tensorboard ```bash @@ -64,19 +64,49 @@ Open your browser and go to: ``` http://localhost:6006 ``` -#TODO descibe how to interpret results in tensorboard +## Interpreting Results in TensorBoard + +After launching TensorBoard with `tensorboard --logdir logs/`, open the provided link in your browser (usually http://localhost:6006). You will see a dashboard with several tabs and plots. + +### Key Steps + +1. **Select the Run(s):** + - On the left panel, choose the experiment(s) you want to view. Each run ( different schedulers or configurations) appears as a separate entry. + +2. **Focus on Relevant Metrics:** + - Common metrics logged include: + - **Energy Usage:** Tracks total or per-node energy consumption over time. + - **Task Duration:** Shows how long tasks take to complete. + - **CPU/Resource Utilization:** Indicates how efficiently resources are used. + - **Task Efficiency:** Tasks completed per unit time. + - Use the "Scalars" tab to view these metrics as line plots. + +3. **Compare Runs or Configurations:** + - Overlay multiple runs to compare different schedulers or parameter settings. + - Use the checkboxes to toggle visibility of each run. + - Look for trends, such as lower energy usage or shorter task durations, to identify better-performing schedulers. + +4. **Tips and Caveats:** + - Hover over plots to see exact values at each step. + - Use smoothing to reduce noise in plots, but be careful not to over-smooth and hide important details. + - If metrics are missing, ensure your simulation and logging scripts are configured correctly. + - For large logs, TensorBoard may take time to load all data. + +### Example: Comparing Schedulers + +- If you ran simulations with both `Waggle Scheduler` and `FairShareScheduler`, select both runs and compare their energy usage and task duration plots. +- A scheduler with lower energy usage and shorter task durations is generally more efficient. + +For more details, refer to the [TensorBoard Getting Started Guide](https://www.tensorflow.org/tensorboard/get_started). ## File Overview (Visualization) Description : -| `scripts/CSVexport.py` | Handles saving of performance and energy metrics.| -#TODO : Be more specific in what csv export does +| `scripts/CSVexport.py` | Handles saving of performance and energy metrics.Extracts scalar metrics (such as energy usage, task duration, CPU load, etc.) from TensorBoard `.tfevents` logs and converts them into a structured CSV file. The CSV includes columns for step, metric tag, and value, making it easier to analyze and visualize simulation results outside of TensorBoard. The script can automatically select the latest log directory and supports exporting logs for different schedulers by adjusting configuration lines. | -| `src/scripts/visualization.py`| - -#TODO description +| `src/scripts/visualization.py` | Analyzes and visualizes metrics from exported CSV logs. It loads one or more scheduler CSV files, computes statistics such as total and average energy consumption, task durations, and efficiency, and generates comparative plots, bar charts, and summary tables. The script helps compare scheduler performance and outputs results as PNG images and summary CSV files for further analysis. | @@ -99,21 +129,20 @@ pip install pandas matplotlib seaborn ## How to retrieve log to use for visualization #### (Check which scheduler you ran from mywaggle.yaml ) --Go to logs and find the latest run or the run based on the date your looking for and change {DefaultScheduler} to the scheduler you ran . +- Go to logs and find the latest run or the run based on the date your looking for and change {DefaultScheduler} to the scheduler you ran . ## How to Generate Plots from Logs -Scheduler Log Analysis & Visualization +### Scheduler Log Analysis & Visualization -This section explains the purpose and usage of the two Python scripts (CSVexport.py & visualization.py) used to extract, process, and visualize metrics from scheduler logs in the edge computing simulation project. +- This section explains the purpose and usage of the two Python scripts (CSVexport.py & visualization.py) used to extract, process, and visualize metrics from scheduler logs in the edge computing simulation project. -⸻ -1. CSVexport .py +## 1. CSVexport .py Purpose: @@ -147,12 +176,12 @@ Ex: output_csv = "FairShareScheduler_task_log.csv" - Change the directory by using cd src/scripts - Go to CSVexport file + #### Go to CSVexport file Run & Debug on left side panel in VScode or whatever code runner for your IDE or -Bash +#### Bash ``` python3 CSVexport.py ``` @@ -160,10 +189,9 @@ python3 CSVexport.py Output: a CSV file like FairShareScheduler_task_log.csv. -⸻ -2. Visualization .py +## 2. Visualization .py Purpose: @@ -197,30 +225,32 @@ How to Use: 2. Define your list of scheduler names (e.g., ["WaggleScheduler", "FairScheduler"]). -Go to +#### Go to +``` vis-interactive.ipynb - +``` Or -Bash - +#### Bash +``` python3 visualization.py +``` +## Outputs: -# Outputs: +### Where Logs Are Saved -## Where Logs Are Saved +Simulation logs are saved to the /logs/ directory. +You’ll find: -Simulation logs are saved to the /logs/ directory. You’ll find: ``` • {scheduler name} tasks.csv: logs for all tasks (start time, end time, node used, energy consumed, etc.) ``` - • scheduler_comparison_metrics.csv: a summary table • .png plots for each metric in the plots/ directory @@ -229,11 +259,12 @@ Simulation logs are saved to the /logs/ directory. You’ll find: -Example Output Plots: - -• total_energy_per_scheduler.png +### Example Output Plots: +``` +•total_energy_per_scheduler.png -• avg_task_time_per_scheduler.png +•avg_task_time_per_scheduler.png -• task_efficiency_per_scheduler.png +•task_efficiency_per_scheduler.png +``` From be8bf82e901a3d6c52751536f6ebe9a192876a6b Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Thu, 7 Aug 2025 22:01:47 -0500 Subject: [PATCH 35/37] Implement feature X to enhance user experience and optimize performance --- .../src/scripts/vis-interactive.ipynb | 853 +++++++++++++++++- 1 file changed, 852 insertions(+), 1 deletion(-) diff --git a/simulation/kubernetes/src/scripts/vis-interactive.ipynb b/simulation/kubernetes/src/scripts/vis-interactive.ipynb index 9ae5829..cdc8c47 100644 --- a/simulation/kubernetes/src/scripts/vis-interactive.ipynb +++ b/simulation/kubernetes/src/scripts/vis-interactive.ipynb @@ -169,7 +169,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 30, "id": "c8079cbc", "metadata": {}, "outputs": [ @@ -222,6 +222,857 @@ " val2 = stats2.get(stat, float('nan'))\n", " print(f\"{stat:<8} | {val1:10.5f} | {val2:10.5f}\")" ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "19392baa", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAMWCAYAAADs4eXxAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnXeYG9XV/7+SVtL2vt5d93XvuGJsAzZgbIhpgZcWEkoMvBA6CeRHAhgIJSEQegvktSGkAAmQYOPewAXjCu51Xddeb/H2XdX5/XHnjmak0RStViMv5/M8eryWRtLRzJl777mn2QRBEEAQBEEQBEEQBEEQRNyxWy0AQRAEQRAEQRAEQXRWyOgmCIIgCIIgCIIgiA6CjG6CIAiCIAiCIAiC6CDI6CYIgiAIgiAIgiCIDoKMboIgCIIgCIIgCILoIMjoJgiCIAiCIAiCIIgOgoxugiAIgiAIgiAIguggyOgmCIIgCIIgCIIgiA6CjG6CIAiCIAiCIAiC6CDI6CYIgiCSkhUrVsBms2HFihVx/dw5c+bAZrNhw4YNcf3cZCKRv/Hmm29G7969Y3rvE088AZvNFl+BkpSDBw/CZrPhhRde0Dyuo/TeCD+k60EQBJFIyOgmCIIg4go3+NQe/+///b8O+95gMIgPPvgA48ePR35+PrKysjBgwADceOON+Oabbzrse+OF1+vFK6+8glGjRiE7Oxu5ubkYOnQobr/9duzatctq8U5rnn/+edhsNmzevFnxvCAIyMvLg81mQ3l5ueK1trY2uN1u/OQnP0mkqARBEEQnJMVqAQiCIIjOyVNPPYWysjLFc8OGDTP8/nPPPRetra1wuVyGjr/33nvxxhtv4PLLL8cNN9yAlJQU7N69G/Pnz0efPn1w1llnmZI/0Vx11VWYP38+rr/+etx2223w+XzYtWsX5s6di4kTJ2LQoEFWi3jacvbZZwMAVq1ahVGjRknPb9++HXV1dUhJScHq1asV+rp+/Xp4vV7pvQRBEAQRK2R0EwRBEB3CxRdfjLFjx8b8frvdjtTUVN3jWlpa0NjYiDfffBO33XYb/vznPytef/nll1FVVRWzHLHS0tKC9PR0Q8euX78ec+fOxTPPPIPf/OY3itdef/111NXVdYCEnY9o53zs2LFITU3FqlWrcM8990jPr169GgUFBRg7dixWrVqFn/70p9Jrq1atAoB2G93BYBBer7ddn0EQBEGc3lB4OUEQBJFQDh06hF/84hcYOHAg0tLSUFBQgKuvvhoHDx5UHKeW2zplyhQMGzYMGzduxLnnnov09HT85je/QXl5OQRBwKRJkyK+z2azoUuXLhHPezwePPjggygqKkJGRgZ+/OMfRxjn//nPfzBjxgx07doVbrcbffv2xe9+9zsEAgHFcdHk4t8za9Ys9OvXD263Gz169MDDDz8Mj8cjvX///v0AoCq/w+FAQUGB4rljx45h5syZklxlZWW48847I4w7I78RAObPn49zzjkHGRkZyMrKwowZM7B9+/aI4z7//HMMGzYMqampGDZsGD777LOIY6LlJPOc5jlz5kS8J5wPP/wQY8aMQVpaGvLz83HdddfhyJEjimO0znk4LpcL48aNw+rVqxXPr169GhMmTMCkSZNUX8vNzZWiM5qbm/HLX/4SPXr0gNvtxsCBA/HCCy9AEATF+2w2G+6++2787W9/w9ChQ+F2u7FgwQJVuQRBwO233w6Xy4VPP/1U85x88skn0jkpLCzET3/6Uxw7dkxxzPfff4+bb74Zffr0QWpqKkpKSvDzn/8cNTU1EZ+3atUqjBs3Dqmpqejbty/eeecdze8nCIIgYoc83QRBEESHUF9fj+rqasVzhYWFWL9+PdasWYPrrrsO3bt3x8GDB/HWW29hypQp2LFjh653uKamBhdffDGuu+46/PSnP0VxcTF69eoFgBkmV199tSEP8z333IO8vDzMmjULBw8exMsvv4y7774bH330kXTMnDlzkJmZiQcffBCZmZlYtmwZHn/8cTQ0NOCPf/yjrlzBYBCXXXYZVq1ahdtvvx2DBw/G1q1b8dJLL2HPnj34/PPPAUCS/29/+xsmTZqElJTo03NFRQXOPPNM1NXV4fbbb8egQYNw7Ngx/Otf/0JLS4siHN/Ib/zrX/+Km266CdOnT8cf/vAHtLS04K233sLZZ5+NzZs3S0XSFi1ahKuuugpDhgzBc889h5qaGtxyyy3o3r277rk2wzPPPIPHHnsM11xzDW699VZUVVXhtddew7nnnovNmzcjNzdXOlbtnEfj7LPPxtdff42DBw9Kv2n16tW49dZbceaZZ2LWrFmoq6tDbm4uBEHAmjVrMGHCBNjtdgiCgMsuuwzLly/HzJkzMXLkSCxcuBAPPfQQjh07hpdeeknxXcuWLcPHH3+Mu+++G4WFhaqF5gKBAH7+85/jo48+wmeffYYZM2ZElX3OnDm45ZZbMG7cODz33HOorKzEK6+8gtWrVyvOyeLFi3HgwAHccsstKCkpwfbt2/HnP/8Z27dvxzfffCMVSdu6dSumTZuGoqIiPPHEE/D7/Zg1a5bm+SMIgiDagUAQBEEQcWT27NkCANWHIAhCS0tLxHvWrl0rABA++OAD6bnly5cLAITly5dLz02ePFkAILz99tsRn3HjjTcKAIS8vDzhxz/+sfDCCy8IO3fujCrf1KlThWAwKD3/wAMPCA6HQ6irq5OeU5P1f//3f4X09HShra1NV66//vWvgt1uF77++mvF82+//bYAQFi9erUgCIIQDAalzyguLhauv/564Y033hAOHTqk+jvtdruwfv36iNf47zH6GxsbG4Xc3FzhtttuU3zOiRMnhJycHMXzI0eOFEpLSxXnZ9GiRQIAoVevXtJzatdNEAShvLxcACDMnj1bem7WrFmCfCly8OBBweFwCM8884zivVu3bhVSUlIUz2vpghrz5s0TAAh//etfBUEQhOPHjwsAhJUrVwqNjY2Cw+EQ5s2bJwiCIGzbtk0AIH3f559/LgAQnn76acVn/s///I9gs9mEffv2Sc8BEOx2u7B9+3bV3//HP/5R8Pl8wrXXXiukpaUJCxcuVBwXfv68Xq/QpUsXYdiwYUJra6t03Ny5cwUAwuOPPy49p6av//jHPwQAwldffSU9d8UVVwipqakK/dqxY4fgcDgEWhoSBEHEHwovJwiCIDqEN954A4sXL1Y8ACAtLU06xufzoaamBv369UNubi42bdqk+7lutxu33HJLxPOzZ8/G66+/jrKyMnz22Wf41a9+hcGDB+OCCy6ICMMFgNtvv13RHumcc85BIBDAoUOHpOfksjY2NqK6uhrnnHMOWlpaIiqKq8n1ySefYPDgwRg0aBCqq6ulx/nnnw8AWL58OQAWkrxw4UI8/fTTyMvLwz/+8Q/cdddd6NWrF6699loppzsYDOLzzz/HpZdeqpovH97uSe83Ll68GHV1dbj++usV8jkcDowfP16S7/jx49iyZQtuuukm5OTkSJ934YUXYsiQIRFyxMqnn36KYDCIa665RiFPSUkJ+vfvL8nDiaYLakycOBF2u13K1V69ejWcTifGjRuHzMxMjBgxQgox5//yfO4vv/wSDocD9957r+Izf/nLX0IQBMyfP1/x/OTJk6OeF6/Xi6uvvhpz587Fl19+iWnTpmnKvWHDBpw8eRK/+MUvFDUOZsyYgUGDBmHevHnSc3J9bWtrQ3V1tVRAkN9bgUAACxcuxBVXXIGePXtKxw8ePBjTp0/XlIUgCIKIDQovJwiCIDqEM888U9UwbG1txXPPPYfZs2fj2LFjipzY+vp63c/t1q2bakVzu92Ou+66C3fddRdqamqwevVqvP3225g/fz6uu+46fP3114rj5QYHAOTl5QEATp06JT23fft2PProo1i2bBkaGhoUx4fLqibX3r17sXPnThQVFan+lpMnT0p/u91u/Pa3v8Vvf/tbHD9+HCtXrsQrr7yCjz/+GE6nEx9++CGqqqrQ0NBguAq83m/cu3cvAEibAOFkZ2cDgGSk9+/fP+KYgQMHGtosMcLevXshCILq9wCA0+lU/D+aLqjBW7DJDetRo0ZJhurEiRMVr7lcLpx55pkA2O/v2rUrsrKyFJ85ePBg6XU54VX75Tz33HNoamrC/PnzMWXKFF25+WcPHDgw4rVBgwZJmwgAUFtbiyeffBL//Oc/FboFhPS1qqoKra2tUa/ll19+qSsTQRAEYQ4yugmCIIiEcs8992D27Nm4//77MWHCBOTk5MBms+G6665DMBjUfb/cmxeNgoICXHbZZbjsssswZcoUrFy5EocOHZJypwFWoEwNvglQV1eHyZMnIzs7G0899RT69u2L1NRUbNq0Cb/+9a8jZFWTKxgMYvjw4fjTn/6k+l09evRQfb60tBTXXXcdrrrqKgwdOhQff/yxoQJk4ej9Rv4b/vrXv6KkpCTiOK3c8miEe9s54cXn1AgGg7DZbJg/f76q7JmZmYr/G9EFOWeffTbefvtt1NXVYfXq1Zg4caL02sSJE/F///d/8Pl8WLVqFcaMGWOoer4aWnJNnz4dCxYswPPPP48pU6bE/B1qXHPNNVizZg0eeughjBw5EpmZmQgGg7jooosM3VsEQRBEx0BGN0EQBJFQ/vWvf+Gmm27Ciy++KD3X1tbWYW2xxo4di5UrV+L48eMKo1uPFStWoKamBp9++inOPfdc6fny8nLDn9G3b1989913uOCCC6Iao1o4nU6MGDECe/fuRXV1Nbp06YLs7Gxs27bN9GdFkw8AunTpgqlTp0Y9jp837hmXs3v3bsX/uTc9/HqGe4OjySMIAsrKyjBgwADd481y9tln46233sKSJUuwefNmPPTQQ9JrEydORGtrK+bNm4cDBw7gqquukl7r1asXlixZgsbGRoW3m6cYmNGrs846C3fccQcuueQSXH311fjss880Nzf4Z+/evTsiImH37t3S66dOncLSpUvx5JNP4vHHH5eOCb9mRUVFSEtLM3QtCYIgiPhAOd0EQRBEQnE4HBFtll577TVDntBonDhxAjt27Ih43uv1YunSpbDb7ejXr59pOQEoZPV6vXjzzTcNf8Y111yDY8eO4d133414rbW1Fc3NzQCYYXT48OGIY+rq6rB27Vrk5eWhqKgIdrsdV1xxBb744gts2LAh4vjw86rH9OnTkZ2djWeffRY+ny/idd5erLS0FCNHjsT777+vCKtfvHhxxHnv1asXHA4HvvrqK8XzRs7blVdeCYfDgSeffDLitwiCoNr6ygw8R/tPf/oTfD6fwtPdu3dvlJaW4vnnn1ccCwA/+tGPEAgE8Prrrys+76WXXoLNZsPFF19sSo6pU6fin//8JxYsWICf/exnml7osWPHokuXLnj77bcVbebmz5+PnTt3SlXP1fQVYH3q5TgcDkyfPh2ff/65Qud27tyJhQsXmvodBEEQhDHI000QBEEklEsuuQR//etfkZOTgyFDhmDt2rVYsmRJRC9qMxw9ehRnnnkmzj//fFxwwQUoKSnByZMn8Y9//APfffcd7r//fhQWFpr6zIkTJyIvLw833XQT7r33XthsNvz1r381Zdj+7Gc/w8cff4w77rgDy5cvx6RJkxAIBLBr1y58/PHHWLhwIcaOHYvvvvsOP/nJT3DxxRfjnHPOQX5+Po4dO4b3338fFRUVePnllyWj6tlnn8WiRYswefJkqQ3Z8ePH8cknn2DVqlWKllp6ZGdn46233sLPfvYzjB49Gtdddx2Kiopw+PBhzJs3D5MmTZIMzeeeew4zZszA2WefjZ///Oeora3Fa6+9hqFDh6KpqUn6zJycHFx99dV47bXXYLPZ0LdvX8ydOzcix1iNvn374umnn8YjjzyCgwcP4oorrkBWVhbKy8vx2Wef4fbbb8evfvUrw78vnJ49e6JHjx5Yu3Ytevfuja5duypenzhxIv7973/DZrMpeqZfeumlOO+88/Db3/4WBw8exBlnnIFFixbhP//5D+6//34pYsAMV1xxBWbPno0bb7wR2dnZUftkO51O/OEPf8Att9yCyZMn4/rrr5dahvXu3RsPPPAAAHYtzz33XDz//PPw+Xzo1q0bFi1apBqZ8eSTT2LBggU455xz8Itf/AJ+v1+6lt9//73p30IQBEHoYEnNdIIgCKLTwttVqbW0EgRBOHXqlHDLLbcIhYWFQmZmpjB9+nRh165dQq9evYSbbrpJOi5ay7ChQ4dGfGZDQ4PwyiuvCNOnTxe6d+8uOJ1OISsrS5gwYYLw7rvvKtpmRZNP7ftWr14tnHXWWUJaWprQtWtX4eGHHxYWLlxoWC5BYC2f/vCHPwhDhw4V3G63kJeXJ4wZM0Z48sknhfr6ekEQBKGyslL4/e9/L0yePFkoLS0VUlJShLy8POH8888X/vWvf0V85qFDh4Qbb7xRKCoqEtxut9CnTx/hrrvuEjwej+nfyJ+fPn26kJOTI6Smpgp9+/YVbr75ZmHDhg2K4/79738LgwcPFtxutzBkyBDh008/FW666SZFyzBBEISqqirhqquuEtLT04W8vDzhf//3f6U2XFotw+Tfc/bZZwsZGRlCRkaGMGjQIOGuu+4Sdu/ebeica3H99dcLAISf/OQnEa/96U9/EgAIgwcPjnitsbFReOCBB4SuXbsKTqdT6N+/v/DHP/5RoVuCwFqG3XXXXRHvl7cMk/Pmm28KAIRf/epXgiBEv0YfffSRMGrUKMHtdgv5+fnCDTfcIBw9elRxzNGjR4Uf//jHQm5urpCTkyNcffXVQkVFhQBAmDVrluLYlStXCmPGjBFcLpfQp08f4e233456PQiCIIj2YRMEk7FoBEEQBEEQBEEQBEEYgnK6CYIgCIIgCIIgCKKDIKObIAiCIAiCIAiCIDoIMroJgiAIgiAIgiAIooMgo5sgCIIgCIIgCIIgOggyugmCIAiCIAiCIAiigyCjmyAIgiAIgiAIgiA6iBSrBTgdCAaDqKioQFZWFmw2m9XiEARBEARBEARBEBYjCAIaGxvRtWtX2O3R/dlkdBugoqICPXr0sFoMgiAIgiAIgiAIIsk4cuQIunfvHvV1MroNkJWVBYCdzOzsbIulIQiCIAiCIAiCIKymoaEBPXr0kOzFaJDRbQAeUp6dnU1GN0EQBEEQBEEQBCGhl4JMhdQIgiAIgiAIgiAIooMgo5sgCIIgCIIgCIIgOggyugmCIAiCIAiCIAiig6CcboIgCIIgCIIgTksCgQB8Pp/VYhCdFKfTCYfD0e7PIaObIAiCIAiCIIjTCkEQcOLECdTV1VktCtHJyc3NRUlJiW6xNC3I6CYIgiAIgiAI4rSCG9xdunRBenp6uwwiglBDEAS0tLTg5MmTAIDS0tKYP4uMboIgCIIgCIIgThsCgYBkcBcUFFgtDtGJSUtLAwCcPHkSXbp0iTnUnAqpEQRBEARBEARx2sBzuNPT0y2WhPghwPWsPbUDyOgmCIIgCIIgCOK0g0LKiUQQDz0jo5sgCIIgCIIgCIIgOggyugmCIAiCIAiCIE5TnnjiCYwcOdJqMQgNyOjuJCzYdhx3/X0T/r7usNWiEARBEARBEARxGnLw4EHYbDZs2bIl4rVPPvkEgwYNQmpqKoYPH44vv/xS8bogCHj88cdRWlqKtLQ0TJ06FXv37lUc88wzz2DixIlIT09Hbm6uYbn27duHW265Bd27d4fb7UZZWRmuv/56bNiwQTrGZrNJj5ycHEyaNAnLli2TXp8yZQruv//+iM+eM2eOKVligYzuTsL+qmbM+/44thw5ZbUoBEEQBEEQBEF0ItasWYPrr78eM2fOxObNm3HFFVfgiiuuwLZt26Rjnn/+ebz66qt4++23sW7dOmRkZGD69Oloa2uTjvF6vbj66qtx5513Gv7uDRs2YMyYMdizZw/eeecd7NixA5999hkGDRqEX/7yl4pjZ8+ejePHj2P16tUoLCzEJZdcggMHDrT/BLQTMro7CVmprPtbk8dvsSQEQRAEQRAEQYQzZcoU3HvvvXj44YeRn5+PkpISPPHEE4pjDh8+jMsvvxyZmZnIzs7GNddcg8rKSsUxv//971FcXIysrCzMnDlTYdRy3nvvPQwePBipqakYNGgQ3nzzTUMylpWVAQBGjRoFm82GKVOmAABeeeUVXHTRRXjooYcwePBg/O53v8Po0aPx+uuvA2Be7pdffhmPPvooLr/8cowYMQIffPABKioq8Pnnn0uf/+STT+KBBx7A8OHDDckjCAJuvvlm9O/fH19//TVmzJiBvn37YuTIkZg1axb+85//KI7Pzc1FSUkJhg0bhrfeegutra1YvHixoe/qSMjo7iRwo7uxjYxugiAIgiAI4oeDIAho8foteQiCYErW999/HxkZGVi3bh2ef/55PPXUU5JRGAwGcfnll6O2thYrV67E4sWLceDAAVx77bXS+z/++GM88cQTePbZZ7FhwwaUlpZGGNR/+9vf8Pjjj+OZZ57Bzp078eyzz+Kxxx7D+++/ryvft99+CwBYsmQJjh8/jk8//RQAsHbtWkydOlVx7PTp07F27VoAQHl5OU6cOKE4JicnB+PHj5eOiYUtW7Zg+/bt+OUvfwm7PdJ01QoL5z22vV5vzN8fL1KsFoCID5luJwAyugmCIAiCIIgfFq2+AIY8vtCS797x1HSku4ybVCNGjMCsWbMAAP3798frr7+OpUuX4sILL8TSpUuxdetWlJeXo0ePHgCADz74AEOHDsX69esxbtw4vPzyy5g5cyZmzpwJAHj66aexZMkShbd71qxZePHFF3HllVcCYN7rHTt24J133sFNN92kKV9RUREAoKCgACUlJdLzJ06cQHFxseLY4uJinDhxQnqdPxftmFjgOeGDBg0y9b6WlhY8+uijcDgcmDx5cszfHy/I091JyHRTeDlBEARBEARBJDMjRoxQ/L+0tBQnT54EAOzcuRM9evSQDG4AGDJkCHJzc7Fz507pmPHjxys+Y8KECdLfzc3N2L9/P2bOnInMzEzp8fTTT2P//v0d9bM6DLORBNdffz0yMzORlZWFf//73/jLX/4Scc6tgDzdnQQpp5s83QRBEARBEMQPiDSnAzuemm7Zd5vB6XQq/m+z2RAMBuMmT1NTEwDg3XffjTDOHQ5zssopKSmJyC2vrKyUvOH838rKSpSWliqOaU87swEDBgAAdu3ahVGjRuke/9JLL2Hq1KnIycmRvPac7Oxs1NfXR7ynrq4OOTk5MctoBPJ0dxJCOd0+iyUhCIIgCIIgiMRhs9mQ7kqx5GGz2eL2OwYPHowjR47gyJEj0nM7duxAXV0dhgwZIh2zbt06xfu++eYb6e/i4mJ07doVBw4cQL9+/RQPXiRNC5fLBQAIBAKK5ydMmIClS5cqnlu8eLHkZS8rK0NJSYnimIaGBqxbt07hiTfLyJEjMWTIELz44ouqmxN1dXWK/5eUlKBfv34RBjcADBw4EJs2bYp4ftOmTZJx31GQp7uTwMPLm70BBIICHPb4DQAEQRAEQRAEQXQsU6dOxfDhw3HDDTfg5Zdfht/vxy9+8QtMnjwZY8eOBQDcd999uPnmmzF27FhMmjQJf/vb37B9+3b06dNH+pwnn3wS9957L3JycnDRRRfB4/Fgw4YNOHXqFB588EFNGbp06YK0tDQsWLAA3bt3R2pqKnJycnDfffdh8uTJePHFFzFjxgz885//xIYNG/DnP/8ZANv4uP/++/H000+jf//+KCsrw2OPPYauXbviiiuukD7/8OHDqK2txeHDhxEIBKR+4P369UNmZmaEPDabDbNnz8bUqVNxzjnn4Le//S0GDRqEpqYmfPHFF1i0aBFWrlxp6PzeeeedeP3113Hvvffi1ltvhdvtxrx58/CPf/wDX3zxhaHPiBXydHcSMlND+yfNXgoxJwiCIAiCIIjTCZvNhv/85z/Iy8vDueeei6lTp6JPnz746KOPpGOuvfZaPPbYY3j44YcxZswYHDp0KKLn9a233or33nsPs2fPxvDhwzF58mTMmTPHkKc7JSUFr776Kt555x107doVl19+OQBg4sSJ+Pvf/44///nPOOOMM/Cvf/0Ln3/+OYYNGya99+GHH8Y999yD22+/HePGjUNTUxMWLFiA1NRU6ZjHH38co0aNwqxZs9DU1IRRo0Zh1KhR2LBhQ1SZzjzzTGzYsAH9+vXDbbfdhsGDB+Oyyy7D9u3b8fLLLxs9vejTpw+++uor7Nq1C1OnTsX48ePx8ccf45NPPsFFF11k+HNiwSaYzU7/AdLQ0ICcnBzU19cjOzvbanGiMuDR+fD6g1j9/85Ht9w0q8UhCIIgCIIgiLjT1taG8vJylJWVKQw6gugItPTNqJ1Inu5ORJabiqkRBEEQBEEQBEEkE2R0dyJ4iHmTh4qpEQRBEARBEASh5Nlnn1W0EpM/Lr74YqvF67RQIbVOBK9g3kCeboIgCIIgCIIgwrjjjjtwzTXXqL6WlkbpqR0FGd2diEwKLycIgiAIgiAIIgr5+fnIz8+3WowfHBRe3onIdDsBAE0eMroJgiAIgiAIgiCSATK6OxE8vJw83QRBEARBEARBEMkBGd2dCG50N7ZRITWCIAiCIAiCIIhkgIzuTgTP6W6k8HKCIAiCIAiCIIikgIzuTkQmhZcTBEEQBEEQBEEkFWR0dyKyUlkhtUYyugmCIAiCIAjiB8ETTzyBkSNHWi0GoQEZ3Z2ILN4yjMLLCYIgCIIgCIIwycGDB2Gz2bBly5aI1z755BMMGjQIqampGD58OL788kvF64Ig4PHHH0dpaSnS0tIwdepU7N27V/HZM2fORFlZGdLS0tC3b1/MmjULXq9XV67Nmzfj6quvRnFxMVJTU9G/f3/cdttt2LNnj0Ju/igoKMC0adOwefNm6TN69+6Nl19+OeKzE7FpQUZ3J4JyugmCIAiCIAiCiDdr1qzB9ddfj5kzZ2Lz5s244oorcMUVV2Dbtm3SMc8//zxeffVVvP3221i3bh0yMjIwffp0tLW1AQB27dqFYDCId955B9u3b8dLL72Et99+G7/5zW80v3vu3Lk466yz4PF48Le//Q07d+7Ehx9+iJycHDz22GOKY5csWYLjx49j4cKFaGpqwsUXX4y6urq4nw+zkNHdiQjldFP1coIgCIIgCIJIJqZMmYJ7770XDz/8MPLz81FSUoInnnhCcczhw4dx+eWXIzMzE9nZ2bjmmmtQWVmpOOb3v/89iouLkZWVhZkzZ0pGrZz33nsPgwcPRmpqKgYNGoQ333zTkIxlZWUAgFGjRsFms2HKlCkAgFdeeQUXXXQRHnroIQwePBi/+93vMHr0aLz++usAmJf75ZdfxqOPPorLL78cI0aMwAcffICKigp8/vnnAICLLroIs2fPxrRp09CnTx9cdtll+NWvfoVPP/00qjwtLS245ZZb8KMf/Qj//e9/MXXqVJSVlWH8+PF44YUX8M477yiOLygoQElJCcaOHYsXXngBlZWVWLdunaHf3pGQ0d2JCLUMI083QRAEQRAE8QNBEABvszUPQTAl6vvvv4+MjAysW7cOzz//PJ566iksXrwYABAMBnH55ZejtrYWK1euxOLFi3HgwAFce+210vs//vhjPPHEE3j22WexYcMGlJaWRhjUf/vb3/D444/jmWeewc6dO/Hss8/isccew/vvv68r37fffgsg5DHmBvHatWsxdepUxbHTp0/H2rVrAQDl5eU4ceKE4picnByMHz9eOkaN+vp65OfnR3194cKFqK6uxsMPP6z6em5ubtT3pqWlAYCh8PWOJsVqAYj4keVmhdQop5sgCIIgCIL4weBrAZ7tas13/6YCcGUYPnzEiBGYNWsWAKB///54/fXXsXTpUlx44YVYunQptm7divLycvTo0QMA8MEHH2Do0KFYv349xo0bh5dffhkzZ87EzJkzAQBPP/00lixZovB2z5o1Cy+++CKuvPJKAMx7vWPHDrzzzju46aabNOUrKioCEPIYc06cOIHi4mLFscXFxThx4oT0On8u2jHh7Nu3D6+99hpeeOGFqPLwnPBBgwZpyh1OXV0dfve73yEzMxNnnnmmqfd2BOTp7kTw8PIWbwCBoLldN4IgCIIgCIIgOpYRI0Yo/l9aWoqTJ08CAHbu3IkePXpIBjcADBkyBLm5udi5c6d0zPjx4xWfMWHCBOnv5uZm7N+/HzNnzkRmZqb0ePrpp7F///6O+lmmOXbsGC666CJcffXVuO2226IeJ5iMJJg4cSIyMzORl5eH7777Dh999FHERoAVkKe7E8ELqQGsV3dOutNCaQiCIAiCIAgiATjTmcfZqu82c7hTuT632WwIBoNxE6epqQkA8O6770YY5w6HI+bPLSkpicgtr6yslLzh/N/KykqUlpYqjgmvDF5RUYHzzjsPEydOxJ///GfN7x0wYAAAVoRNvrkQjY8++ghDhgxBQUFBROh5dnY26uvrI95TV1eHnJwc3c9uD+Tp7kS4Uuxwp7BL2uihYmoEQRAEQRDEDwCbjYV4W/Gw2eL2MwYPHowjR47gyJEj0nM7duxAXV0dhgwZIh0TXhjsm2++kf4uLi5G165dceDAAfTr10/x4EXStHC5XACAQCCgeH7ChAlYunSp4rnFixdLhnBZWRlKSkoUxzQ0NGDdunUKY/nYsWOYMmUKxowZg9mzZ8Nu1zZHp02bhsLCQjz//POqr4dXJu/Rowf69u2rmus9cOBAbNy4MeL5TZs2ScZ9R2Gp0f3EE08o+qnZbDZFvH5bWxvuuusuFBQUIDMzE1dddVXEDsvhw4cxY8YMpKeno0uXLnjooYfg9ytzmlesWIHRo0fD7XajX79+mDNnTiJ+niXwYmqU100QBEEQBEEQpw9Tp07F8OHDccMNN2DTpk349ttvceONN2Ly5MkYO3YsAOC+++7D//3f/2H27NnYs2cPZs2ahe3btys+58knn8Rzzz2HV199FXv27MHWrVsxe/Zs/OlPf9KVoUuXLkhLS8OCBQtQWVkpeYbvu+8+LFiwAC+++CJ27dqFJ554Ahs2bMDdd98NgHns77//fjz99NP473//i61bt+LGG29E165dccUVVwAIGdw9e/bECy+8gKqqKpw4cSJqzjcAZGRk4L333sO8efNw2WWXYcmSJTh48CA2bNiAhx9+GHfccYfh8/vAAw9g3rx5UoG5bdu24be//S3Wrl2L++67z/DnxILlnu6hQ4fi+PHj0mPVqlXSaw888AC++OILfPLJJ1i5ciUqKiqkggAA24GZMWMGvF4v1qxZg/fffx9z5szB448/Lh1TXl6OGTNm4LzzzsOWLVtw//3349Zbb8XChQsT+jsTBQ8xb6IK5gRBEARBEARx2mCz2fCf//wHeXl5OPfcczF16lT06dMHH330kXTMtddei8ceewwPP/wwxowZg0OHDuHOO+9UfM6tt96K9957D7Nnz8bw4cMxefJkzJkzx5CnOyUlBa+++ireeecddO3aFZdffjkAliv997//HX/+859xxhln4F//+hc+//xzDBs2THrvww8/jHvuuQe33347xo0bh6amJixYsACpqakAmGd83759WLp0Kbp3747S0lLpocXll1+ONWvWwOl04ic/+QkGDRqE66+/HvX19Xj66acNn9+JEydi/vz5mD9/PiZNmoQpU6ZgzZo1WLp0qeJ3dAQ2wWx2ehx54okn8Pnnn2PLli0Rr9XX16OoqAh///vf8T//8z8AWCz/4MGDsXbtWpx11lmYP38+LrnkElRUVEgJ8m+//TZ+/etfo6qqCi6XC7/+9a8xb948ReP26667DnV1dViwYIEhORsaGpCTk4P6+npkZ2e3/4d3IJe+tgpbj9Vj9s3jcN6gLlaLQxAEQRAEQRBxpa2tDeXl5SgrK5MMOoLoKLT0zaidaLmne+/evejatSv69OmDG264AYcPHwYAbNy4ET6fT9HrbdCgQejZs6fU623t2rUYPny4oiLd9OnT0dDQIIVZ6PWU62xwT3cjhZcTBEEQBEEQBEFYjqVG9/jx4zFnzhwsWLAAb731FsrLy3HOOeegsbERJ06cgMvlikiCD+8Hp9YLjr+mdUxDQwNaW1tV5fJ4PGhoaFA8Thd42zAKLycIgiAIgiAIQs6zzz6raCUmf1x88cVWi9dpsbRlmPzCjhgxAuPHj0evXr3w8ccfIy0tzTK5nnvuOTz55JOWfX974IXUGtuoejlBEARBEARBECHuuOMOXHPNNaqvWWl/dXaSqk93bm4uBgwYgH379uHCCy+E1+tFXV2dwtsd3g/u22+/VXwGr24uP0atp1x2dnZUxXrkkUfw4IMPSv9vaGhQNKlPZrLcVL2cIAiCIAiCIIhI8vPzkZ+fb7UYPzgsz+mW09TUhP3796O0tBRjxoyB0+lU9HrbvXs3Dh8+LPV6mzBhArZu3YqTJ09KxyxevBjZ2dlSLzu9nnJquN1uZGdnKx6nC5mSp5uMboIgCIIgCIIgCKux1Oj+1a9+hZUrV+LgwYNYs2YNfvzjH8PhcOD6669HTk4OZs6ciQcffBDLly/Hxo0bccstt2DChAk466yzALBm6UOGDMHPfvYzfPfdd1i4cCEeffRR3HXXXXC73QBYCMWBAwfw8MMPY9euXXjzzTfx8ccf44EHHrDyp3cYmW4nADK6CYIgCIIgiM6NhU2YiB8Q8dAzS8PLjx49iuuvvx41NTUoKirC2WefjW+++QZFRUUAgJdeegl2ux1XXXUVPB4Ppk+fjjfffFN6v8PhwNy5c3HnnXdiwoQJyMjIwE033YSnnnpKOqasrAzz5s3DAw88gFdeeQXdu3fHe++9h+nTpyf89yYCntPd5KGcboIgCIIgCKLz4XQyJ1NLSwvlIRMdTktLC4CQ3sWCpX26TxdOpz7d/9lyDPf9cwsm9SvA3249y2pxCIIgCIIgCCLuHD9+HHV1dejSpQvS09Nhs9msFonoZAiCgJaWFpw8eRK5ubkoLS2NOMaonZhUhdSI9sP7dFPLMIIgCIIgCKKzwosmy2s7EURHkJubK+lbrJDR3cnISqWcboIgCIIgCKJzY7PZUFpaii5dusDno7RKomNwOp1wOBzt/hwyujsZ3NPdSC3DCIIgCIIgiE6Ow+GIi1FEEB1JUrUMI9qPVEiNPN0EQRAEQRAEQRCWQ0Z3J4N7ult9AfgCQYulIQiCIAiCIAiC+GFDRncnIzM1lDHQTCHmBEEQBEEQBEEQlkJGdyfD6bAj1ckuKxVTIwiCIAiCIAiCsBYyujshmW5WwbyJPN0EQRAEQRAEQRCWQkZ3JyRbDDEnTzdBEARBEARBEIS1kNHdCeF53U0e6llIEARBEARBEARhJWR0d0KkXt3k6SYIgiAIgiAIgrAUMro7IVkUXk4QBEEQBEEQBJEUkNHdCaFCagRBEARBEARBEMkBGd2dEO7pbiJPN0EQBEEQBEEQhKWQ0d0JCeV0UyE1giAIgiAIgiAIKyGjuxMi5XRTeDlBEARBEARBEISlkNHdCcmk8HKCIAiCIAiCIIikgIzuTggPL6dCagRBEARBEARBENZCRncnJDuVVS+nlmEEQRAEQRAEQRDWQkZ3J0QKLydPN0EQBEEQBEEQhKWQ0d0JCVUvJ6ObIAiCIAiCIAjCSsjo7oRQyzCCIAiCIAiCIIjkgIzuTgjP6fb4g/D6gxZLQxAEQRAEQRAE8cOFjO5OSIbbIf3dTHndBEEQBEEQBEEQlkFGdyckxWFHmpMZ3lRMjSAIgiAIgiAIwjrI6O6kZIkVzBsor5sgCIIgCIIgCMIyyOjupEhtw6iCOUEQBEEQBEEQhGWQ0d1JyXJTr26CIAiCIAiCIAirIaO7k8I93dSrmyAIgiAIgiAIwjrI6O6kZLlZ27BG8nQTBEEQBEEQBEFYBhndnRTK6SYIgiAIgiAIgrAeMro7KZlSTjdVLycIgiAIgiAIgrAKMro7KdmU000QBEEQBEEQBGE5ZHR3Uii8nCAIgiAIgiAIwnrI6O6kZFIhNYIgCIIgCIIgCMsho7uTEmoZRjndBEEQBEEQBEEQVkFGdycli4eXk6ebIAiCIAiCIAjCMsjo7qRkuSmnmyAIgiAIgiAIwmrI6O6kZFL1coIgCIIgCIIgCMsho7uTkpVKhdQIgiAIgiAIgiCshozuTkqmGF7u9Qfh8QcsloYgCIIgCIIgCOKHCRndnRRudANAs4eMboIgCIIgCIIgCCsgo7uT4rDbkOFyAKC2YQRBEARBEARBEFaRNEb373//e9hsNtx///3Sc21tbbjrrrtQUFCAzMxMXHXVVaisrFS87/Dhw5gxYwbS09PRpUsXPPTQQ/D7lXnMK1aswOjRo+F2u9GvXz/MmTMnAb/IeqiYGkEQBEEQBEEQhLUkhdG9fv16vPPOOxgxYoTi+QceeABffPEFPvnkE6xcuRIVFRW48sorpdcDgQBmzJgBr9eLNWvW4P3338ecOXPw+OOPS8eUl5djxowZOO+887Blyxbcf//9uPXWW7Fw4cKE/T6r4CHm1KubIAiCIAiCIAjCGiw3upuamnDDDTfg3XffRV5envR8fX09/vKXv+BPf/oTzj//fIwZMwazZ8/GmjVr8M033wAAFi1ahB07duDDDz/EyJEjcfHFF+N3v/sd3njjDXi9XgDA22+/jbKyMrz44osYPHgw7r77bvzP//wPXnrpJUt+byLJ5BXMydNNEARBEARBEARhCZYb3XfddRdmzJiBqVOnKp7fuHEjfD6f4vlBgwahZ8+eWLt2LQBg7dq1GD58OIqLi6Vjpk+fjoaGBmzfvl06Jvyzp0+fLn2GGh6PBw0NDYrH6Uh2Kvd0U043QRAEQRAEQRCEFaToH9Jx/POf/8SmTZuwfv36iNdOnDgBl8uF3NxcxfPFxcU4ceKEdIzc4Oav89e0jmloaEBrayvS0tIivvu5557Dk08+GfPvShak8HLydBMEQRAEQRAEQViCZZ7uI0eO4L777sPf/vY3pKamWiWGKo888gjq6+ulx5EjR6wWKSa40d1IOd0EQRAEQRAEQRCWYJnRvXHjRpw8eRKjR49GSkoKUlJSsHLlSrz66qtISUlBcXExvF4v6urqFO+rrKxESUkJAKCkpCSimjn/v94x2dnZql5uAHC73cjOzlY8TkeyKKebIAiCIAiCIAjCUiwzui+44AJs3boVW7ZskR5jx47FDTfcIP3tdDqxdOlS6T27d+/G4cOHMWHCBADAhAkTsHXrVpw8eVI6ZvHixcjOzsaQIUOkY+SfwY/hn9GZ4S3DKLycIAiCIAiCIAjCGizL6c7KysKwYcMUz2VkZKCgoEB6fubMmXjwwQeRn5+P7Oxs3HPPPZgwYQLOOussAMC0adMwZMgQ/OxnP8Pzzz+PEydO4NFHH8Vdd90Ft9sNALjjjjvw+uuv4+GHH8bPf/5zLFu2DB9//DHmzZuX2B9sAVnUMowgCIIgCIIgCMJSLC2kpsdLL70Eu92Oq666Ch6PB9OnT8ebb74pve5wODB37lzceeedmDBhAjIyMnDTTTfhqaeeko4pKyvDvHnz8MADD+CVV15B9+7d8d5772H69OlW/KSEwj3djW1UvZwgCIIgCIIgCMIKbIIgCFYLkew0NDQgJycH9fX1p1V+99zvK3D33zdjfFk+Pvrfzh9OTxAEQRAEQRAEkSiM2omW9+kmOo5MCi8nCIIgCIIgCIKwFDK6OzFZUng5Gd0EQRAEQRAEQRBWQEZ3J4a3DCNPN0EQBEEQBEEQhDWQ0d2JkcLLydNNEARBEARBEARhCWR0d2J49XJvIAiPP2CxNARBEARBEARBED88yOjuxGS4Qh3hKK+bIAiCIAiCIAgi8ZDR3Ylx2G0UYk4QBEEQBEEQBGEhZHR3cqhtGEEQBEEQBEEQhHWk6B+ixOPxYN26dTh06BBaWlpQVFSEUaNGoaysrCPkI9pJZmoK0AA0tPmsFoUgCIIgCIIgCOIHh2Gje/Xq1XjllVfwxRdfwOfzIScnB2lpaaitrYXH40GfPn1w++2344477kBWVlZHykyYgPfqpvBygiAIgiAIgiCIxGMovPyyyy7Dtddei969e2PRokVobGxETU0Njh49ipaWFuzduxePPvooli5digEDBmDx4sUdLTdhEAovJwiCIAiCIAiCsA5Dnu4ZM2bg3//+N5xOp+rrffr0QZ8+fXDTTTdhx44dOH78eFyFJGJH8nST0U0QBEEQBEEQBJFwDBnd//u//2v4A4cMGYIhQ4bELBARX7inm1qGEQRBEARBEARBJJ6YqpfX1dXhvffewyOPPILa2loAwKZNm3Ds2LG4Cke0n6xUFp1ARjdhNfUtVMyPSF7qWrwQBMFqMQhClfoWH+knkbTQ+EkQ+pg2ur///nsMGDAAf/jDH/DCCy+grq4OAPDpp5/ikUceibd8RDsJ5XSTwUNYx5IdlTjjqUX481f7rRaFICJYvvskRj61GG+tJP0kko+v9lThjKcW4fVl+6wWhSAiWLOvGqN+txivLN1rtSgEkdSYNroffPBB3Hzzzdi7dy9SU1Ol53/0ox/hq6++iqtwRPvhOd3k6SasZPORUwCATYfqrBWEIFTYfLgOAOknkZxI+nn4lLWCEIQKm4/UQRCATaKeEgShjmmje/369ao53t26dcOJEyfiIhQRP6hlGJEMVDd62b9NHoslIYhIuF6SfhLJSEg/vRZLQhCRVDWK+tlI4ydBaGHa6Ha73WhoaIh4fs+ePSgqKoqLUET8yHSLOd1UvZywkJpmj/gvLRqJ5KOmiesnLRqJ5EMaP2lTiEhC+LxO4ydBaGPa6L7sssvw1FNPwedjOcI2mw2HDx/Gr3/9a1x11VVxF5BoH5nk6SaSAO6hIU8ikYzUiPpZQ55EIgmRxs9mKlZFJB/SpmUT6SdBaGHa6H7xxRfR1NSELl26oLW1FZMnT0a/fv2QlZWFZ555piNkJNqB1DIsQYXU/r7uMB78aAt8gWBCvk+NNl8Ad/99Ez7fbG01/TX7qnH7BxtwvL7VUjme/XIn/rR4j6Uy8B3wxjY/PP6AZXJ8tP4w7v/nZnj91urnPf/YjE83HbVMBgD45kANbvtgA47VWaufv5+/C39cuMtSGbinpsUbQIvXug3KTzYcwb3/2GzpPeLxB3DvPzbjkw1HLJMBAL4tr8VtH2zAkdoWS+X448Jd+MMCi/VTNGq8/iCaLIxa+/fGo7jnH5vR5rNOP73+IO7/52Z8vN5a/dxwkOnn4Rpr9fNPi3bjuS93WioD36z0BwU0tFqnn59vPoa7/77JUv30BYJ44KMt+Me3hy2TAWD1H277YAMOVjdbKsfLS/bg6bk7LJUhmTBtdOfk5GDx4sWYO3cuXn31Vdx999348ssvsXLlSmRkZHSEjEQ7yE6wp/uVpXvw6eZj2HKkLiHfp8aa/dWY+/1xvL7c2kqv/7f6IBbtqMS8749bJkN1kwd//uoAXl26F80WLtbkHsRaC0PMX1myF59vqcDGQ9YVJFpXXosvvqvAaxZXIp6z+iAW76jEvO8rLJPhVLMXb6/cjzeW70dDm3UdFuQRGFZ6u19dthf//a4CGw5ap5/ry0/hv99V4NVl1lYifn8t088vLNTP+lYf3li+H2+t2I+6Fuv0Qp6WY6V+vr58H774rgLrymstk2HjoVP4fEuF5ZWyP1h7CIt3VOI/W6zb3G/2+PHqsn1456sDlkaRycPKqy0MMX9t2V7M/f441uyvtkyGLUfq8NnmY3h5ibWOjg9F/fzcQv1s9Qbw8pK9eG9VOSob2iyTI5lIMXOwz+dDWloatmzZgkmTJmHSpEkdJRcRJ6Twco8fgiDAZrN12HcFg0IoDM7CghpSUQ+LQ5mrkqD4TVWj0pjIcJu65eNCi9ePFm9o57m60YvSnLSEyyEIguyaJIF+Wlx0Jin0U3Ydqhs9yE51JlyGNl9A0d2husmDHvnpCZdDEISkGLuqmtjiiBc/tEwO6T6xTg75dahu8iA33ZVwGXyBIOpaQhtS1U0e9C60xsGRDGMXHzOqmjwdvqbRlCMJ7tVw/SzMdCdchkBQUGykVzd60LcoM+FyAMkxZnAZapq8CAYF2O0W6WcSrHXk313V6EFxdqrG0T8MTHm6nU4nevbsiUDAutANwhw8vNwXEODp4JDaulYfAkGWz2Ptjc4G3LoWn6Vh7tVJNilXWSRHuGfGqp3whlY/fIFk0E8x1N7jtzQMTqqIbOECWv7dVhn/4ZEXVnkSm70BtPnYeFVl6TVhv7/VF7A0OiYZKsrL9bPKooV8uH5adZ+0+QJSaHsyXBOvP2hpgdhkqCivMLot0s9TLV4EZWncVhVL9fgDaBA3T61a6wCha+IPCqhvtS56Kxk2IMI3hYgYwst/+9vf4je/+Q1qa60LLyKMk+FKAd8I7uhe3UoDz/qdRsC6BbQgCMmxaEyCQS/8e626JlVJcC6AcEPTejmsXKAkwzUJ10erKvAmwwYE+27rrwmQLJuWMg9esoyfFulnVbKMW2HRMVbLYen42Wi9fkaMn0kgRzKMW5bLkQTFa5XjJxUpBUyGlwPA66+/jn379qFr167o1atXRB73pk2b4iYc0X7sdhsyXSlo9PjR5PGjKKvjwo+SZ7BRylGSk/iQliaPX4ossHYCsH4iSpZJORm8AhFyNHnRPS/xocyt3gCaxZB/aw086/UzPPLCqvORLMZu+EZIr4LEhzLLvVbJNJdYQeT4mQz6mTzjZx8LOtX6AkGcEkP+ST+Tcfy0MmXKK/vbg/7FWQmXgYX8J8OmpfX6mWyYNrqvuOKKDhCD6EgyU5nR3djBhYrC8zOtIhlCqhXGRLIYeBbJET7YJoPHKGl2fy26T5LnXFg/ZoR/L+mnbNFo0ZhRkyQekmS4Jskzflq/QZYscoTnMFtFMqx1wr83Ge6TZLkmVo1d8pB/S8fPxuS4JsmEaaN71qxZHSEH0YFkpabgeH3HVzBPhskwQo4kMGpqmq0r+JIU4btJkjObrJEYViDXi9pm6wq+KHJmLdKLZNHPqmQZP5PgPpF/76kWL/yBIFIcprPh4iqHVZuWyejptrTmQDKMn7Lf3yC2wXSnOBIuB+lniGSI6gv/7mRYfzaJtWNSnRbrJ3m6AcSQ083ZuHEjPvzwQ3z44YfYvHlzPGUi4kyoV3ficrqTxzthvYHnC1hXUCMZNkL49/LUhmqLCq0kS35RMkxEcv0MBAWcsqgdUjKci5ow/UyKnO5kiY5JAqNbEKxrM5gMObM8/UEaP5NgzPihe8+SpU5JMhiaNc3JMX4mg4Mh/Lutu1eV+mjVJlmyrLmSCdNG98mTJ3H++edj3LhxuPfee3HvvfdizJgxuOCCC1BVVdURMhLtJFNsw9Phnm5FATNrbnK19ipWEG5YJoPxb3VO4qCSLPH/1i4OAHYuBEHQOLpjiGivYpnXKjn0U9l/OFn00/oNCB4dk2iCYfqZDMYEkCx5okmin5ZtWsqjYzwIBhOvn6xAqTxn9gfu3U1G/UyCa3KqxQe/RZ1r5GNXMuiF2v+tkIM83QzTRvc999yDxsZGbN++HbW1taitrcW2bdvQ0NCAe++9tyNkJNpJFvd0d3BOt3wx0OwNoNWb+HZIke1/rPcKANbvQgPWTwADxYIi1oUEhn6/xx+U2t8kkvD2KlZ7d6P9P1Ekg/esKkn0U35/+gICGloTr5/1rT74ZQpqtXfXajmUG3U/7PFTvpEcFGBJdEyjxw+vzJhKhqKcav9PFDXJsEEWpp/W1dFRfq8V0TEtXj9aZW1Ak8HYBazXDfY3ebqBGIzuBQsW4M0338TgwYOl54YMGYI33ngD8+fPj6twRHzISmVGd0cbGckwEYWH0Vi9UIr2/0QQDAqKwdbqPt0DZDvhVnjxIq9J4nUjGfRC7Xut0I1wr5XVxi7Xz9pmLwIWePGS4ZokjX5GeLqtl8Oq6Jhw/axr8cFngRcvciPZgvEzSTazk+FeBcKiCy2KjqkO089GMcc98XJYf02SZtyKiGSzXo7aZo8l82qyYdroDgaDcDqdEc87nU4Eg9aEcxDaJCynuzEJBr1kWTSGy2FBTk2416qxjRXUSDTcWzRA3An3B63x4iWDbiRP2Kz1cjS0Kb1WLd4AWryJ1wuun/27ZAJgXrw6C7x4yaCfkZWIf7ibls0epdfKqugY7s3tW5QJXuvwlAVevGS4JskwbqnLkfhz0eYLKNZ0VtWO4eNnn8IMpIgKaoWXORk21Wn8DOH1BxX6aFV0TLJh2ug+//zzcd9996GiokJ67tixY3jggQdwwQUXxFU4Ij5kpvLw8o5bMMi9VoWZYsEXCwzNCBks3uELyWHdJJSdmgKng02Gic4HlOcwd81JlaIuwsNHOxqmn+w7rdXPMBksrl5upRz8OzPdKXCnsKko0QXEBCEUDVKSk4rcdLahbEXebDKMXckwhjM5wvXTuvEz1WlHhsthiRyCIEhh3V2y3MjPcFkih/w7k2HMsHr8jJxLrNNPl8MemlctOB81Mr0oyHQpnkskyTB2hetFlUXRMckwfvLNGIfdJs2rlNcdg9H9+uuvo6GhAb1790bfvn3Rt29flJWVoaGhAa+99lpHyEi0k6wEFFKTe614QQ0rF0qDS5MjVJTLYaXXqijLjYIMayaiOlkOc36GC0UWTYjN3gDafEw/rbwm4XphWahouH5asUBp5AsDl2KRkkjk0SAFGW7LFvNtvoDkRU2Ga8JlaPRYEx2TFPopW7gWWlQ5vMnjh9cfDMmRaU2FaLnXil8TKyoih+uFVdExVY3Wz+8hIzM0r1Yl2Phv8frRItbuKcxyWzaO+wNByYuaDPM7XwN7/cEOjzDVkkO6Vy2M6itQrPvI023a6O7Rowc2bdqEefPm4f7778f999+PL7/8Eps2bUL37t07QkainfBCah0ZGsdv8ix3CrrlpimeSyR8cda/SxZsNhbSYkmoU6Ny8LXaa1WYxT0kiZWDy5CX7kSKwx7aCU/wNeHXI83pQI/8dADWVL7lk1/fokw4xFA8S7wCSaef1hg1XIbs1BS4UuwosMiTyBfxLocdZYUZlsjAvpPJUVaYAZfYF9tK3eD6acWikRswcmM30cY/Pw8ZLgfSXA5p/Ez0NeFGfordhr5FmQrZEgk//z3z05HqtCY6BojUTyvXOnJjN+F6IZ4HdwqLBingm0IJ1o3aZi8EAbDbgH5duH5aZ2j2yE8LRcdYsnkapp9Wb1paHJmSTKTE8iabzYYLL7wQF154YbzlIToAHl7ekZ5uxQRgkYEn/87ibDfy012oafaiuskj9ZBMBK3eAJrF3d9BJdkArDHw5NckzcPDIxM9KbPv45Mx97gnuuosXzQWZrmsDY8UJ8Mu2SxUtKrRg+omD0pyUhMmg8cfQIM4FnD9tNLAK8x0wy/WA0n0Yq1GJoP830TrZ+hcWKyfPDpGDBU9Xt+G6iYvuuelJ0wGudcqWfRT3H9IovEz0ZuWotcq02Vpv/CqJuVGyNFTrahq8qBnQeL0k6VM8U1Lrp/WGjXSBoRl45YbNpsNhRk8vNyazan8DBeKs1MVzyVWDmV0THNNC6qbvOhTlDgZBEGQ1jtW6qeUwpblRk4ahZdzTHu67733Xrz66qsRz7/++uu4//774yETEWd4IbWGDmwZxj2X8kWjFR68kBxuy+SQcq1S7Ogteq2saG3CB94ixU5jgs9FcyjECIDMU5NoT2JIL4oyrVkYADLj38LdXx75kWK3oa/oFbDkXDRZvxHCxwuul1blJEp5kVnW3avR5Ei0btS2hLxW/Yut1E92LooU+pnouURdPxM/jsvHLQvHT9lC3ir9lKdMDbSwN3UyrLlqouhnwiPZksSrqja/J1o/G1r98AWYgkr6aUG0ZyjX3yWNGdQ2LAaj+9///jcmTZoU8fzEiRPxr3/9Ky5CEfElES3D1AY9a0ICrfe4y71FRbIJINEFNaobIydlqzw1/Pul8LME5ySqT8rW7YQXyRavCV9Aq3qtEt/GLdxrxeSwyJOYEeZJtFQ/rY8UslIOrp/5GW50yWJeq5pmL4IJrs2RDAt5rodcLy2LxGhMtvHT+o2QvHSn5FWtbfHCn+DaHFWq18Qq/eRGt1VpQmrjlhXRhfI5zZrxk6+7s1JDqZ5W1I5RrnUovJxj2uiuqalBTk5OxPPZ2dmorq6Oi1BEfEmI0d3Iw+BcluWdse8MeVal4mEWhTrJz0WbLyiFnCdOjlBoomUGnixsFoDkZU50Hp5cDqsWBoDS4LVqIqqWGZp8seQNBKWQ84TLIat6m/gFCvfsuhT/JrogUeiaWKyfirHLKqMmdK/yat2BoIC6BLdDkl8Tqzcgirh+WiWHql5YqZ8WbgrJxq28dCdsNkAQmOFtlRxWjZ/hFcOt2wgJrT+TIT1Hfp8kOrVQvgGRk+a0rHaM8ppYZxMkG6aN7n79+mHBggURz8+fPx99+vSJi1BEfMl0s3yKxjZ/h3mz5F4rqypUy3OtiiyspCkf9DLcKUhzWlNQQ9VTk2AZamSLJPm/SeFJTPC5kOdaWSmHPNcq1emQCi1aFxEiWygl2NhNHk93KKzbqugYQRBCHQ/kEUsWjluuFLtl+YDVsvvEKmMi3NMd0k9rFtDyCJ0aC6JjkiH6QL4plOKwIz/d+o3kQosNvND8bm1Ot1wvai2IjqlKMv20222y4qBJsP4ko9t8IbUHH3wQd999N6qqqnD++ecDAJYuXYoXX3wRL7/8crzlI+IA93QHggLafEGkiVUV44naDdbQ5ofHH4A7Jf7fp8apsPZUUnh5oidDWSskgHnPjtS2orrJI+V4J0QOWU6NZPhb6CEBQmFoVhUCklfKbvYG0OoNdMj9oEZ9q0/KtUoGT3dIP91o9PhR3eiRKhMnVg63dF6sqr4rnQuLcroVi7UsZXQMr8nR0TRGtKeyerEWuib1rT5UN3owoDgrgXKExgzuLbJKP62uOaA2v3sDQTS0+pEj9uDtaBTtqSz0nsnDuvm/vGBrIuH6WZTphtuijf2I8dOyQn+ha8LvkUBQwKkWr7Qh0NG0+QJoFKPFimS1YxLubFHRz5ONnsQ7n2RrLmnjlFqGmfd0//znP8eLL76Iv/zlLzjvvPNw3nnn4cMPP8Rbb72F2267rSNkJNpJussBG1szoNHTMSF64SEtKRaEtHAZ8tKdcDrsSWDUhIdcJU4OudfKypZhEZ6aJLgmWW7WHirRcvDvyk5NgTvFYV0oXmNosQbIQ1at2wjh4bOJXhhI+hkeiWFZzqwL6a4UpFvQboZ/F29PZVWV6mghq4lfNFofKRTuSZTPJYn0Moe8/i5FdEwirwkfL9wpdmS6U0JtBhPuYQ7TT4trx1gZHRMaP8MLqSVWjirZRp3TYUduOo+OSZxu8OgTl8OO7LQUC9ef4fpp7dgld3QkWi+SEdNGNwDceeedOHr0KCorK9HQ0IADBw7gxhtvjLdsRJyw2WySt6Sxg/I2pfCzLDGkxYJdaPkiHoBiIkok0ReNiZsA5F4reaj9qQQX1JBXAAZC14RHQSQKuffMZrNJciRy0ShVUM8Kmwx/gJtCzR4/Wn2i10qmn41tfrT5EqkX4fcq01MeBZE4OULhu3J5ErspFKaflm0KhYwJ+b+JlKPNF0CjJ+S1skov5BWqgZBR4/EntkZI+Nxqxdgl30S22WyWb6oXRdwniZPDFwiirsUnfT83/D3+YIfW7gmnJmz85PrpCwhoaE2cHNHHrsRvWhaIawwrxi32feHze+I31f2BoFTjoDDLJUU4+gIC6hNcmyPZiMno5hQVFSEzM/ZwxLfeegsjRoxAdnY2srOzMWHCBMyfP196va2tDXfddRcKCgqQmZmJq666CpWVlYrPOHz4MGbMmIH09HR06dIFDz30EPx+5c2+YsUKjB49Gm63G/369cOcOXNilvl0he9Md1Sv7vDB14oWFslgTCjkyAo/F4mfADLdKUh1OpCX7oIYfIBTCcwHlBftAoDstBQpCqI2gXLUREzKiQ/TTIbJUCGHVJwp8fcJP++pTjsyXA7kpDnhdCReL+TFXgB2v1gRBSEZV1nhupHIa6I+fiba618VJkeRFeOn+F3ca5XpToHbwugYfi6sioKQ16Jg/1o4fobNqwmPjolIf0j8Wod/l8NuQ26aU6EXVlwTPr+7UxxSOmN1Auti1ERsWlrg9EmS8TN8frfC+XSqxQdBAGw2ID9djI7hevEDbxtmyOgePXo0Tp06BQAYNWoURo8eHfVhhu7du+P3v/89Nm7ciA0bNuD888/H5Zdfju3btwMAHnjgAXzxxRf45JNPsHLlSlRUVODKK6+U3h8IBDBjxgx4vV6sWbMG77//PubMmYPHH39cOqa8vBwzZszAeeedhy1btuD+++/HrbfeioULF5qS9XQnK5WF23TELqgy18q6CTFiUs6ypuBL1IrdVizixe922G3Iz0jsNZHrBTdqbDZbwvMS5V4rKzdkwhcG/N/aZg8CCSz4Em2DLJGTYbjXymazJbzbgMcfysHjuYg2mw2FvO5Agoz/cK+V/N9EXhO1XGrAuuiYcDms2BTiXisrPKtyveCeIi4TkLhif6xAabQxI/HXpChTaUw0Jjxqyvr0B3llfbu4iZ3oa6LUi5B+JnoTIhgUZOsd68bPaONW4qOmojnAEq+f+ems2CBgXeRpsmGoQsvll18Ot5udsCuuuCJuX37ppZcq/v/MM8/grbfewjfffIPu3bvjL3/5C/7+979LBdtmz56NwYMH45tvvsFZZ52FRYsWYceOHViyZAmKi4sxcuRI/O53v8Ovf/1rPPHEE3C5XHj77bdRVlaGF198EQAwePBgrFq1Ci+99BKmT58et9+S7GSmdlx4OQ89S3Xapd1WS8LLZe3CAEjtZvxBFtKSm+6K+t6OkCMUcpX43LNQqFOoiEhhpgvVTZ6ETUR8EnKJOXicggw3Khs8CdMNhddKvA8k/UxkzmxYUaQ8UT+DAisCWCi7Vh0rR3ievXVeAbl+FmS6cKKhLWFy8AVjit2G7DSZfma6UVHflrBFSrjXissAJDp8V9lpIFeMjgkK7FzxnsQdTbjHyIrWZeEREEweF47VtSZMDh6RZLdBMXcVZLjFwpyJkaO2mRUotdlYvRTA4jFDFjXldNjgCwioafKiq9iTOGFyZIaPn1bop3L8PFzbkrBrUicrXJsn3xTKcKG8ujlh42ddq0/atOZrPis2harCrgmPmvL6g6hu8qBHfnpC5AjfPLVWP5WbhQeqm2O7Jm0NQGp2vMSzFEOe7lmzZiE9PV36W+sRK4FAAP/85z/R3NyMCRMmYOPGjfD5fJg6dap0zKBBg9CzZ0+sXbsWALB27VoMHz4cxcXF0jHTp09HQ0OD5C1fu3at4jP4Mfwz1PB4PGhoaFA8TndCOd0a+RQ7/gu8ewFQs9/UZ4d7rQDZrpZZQzMYAP71c+A/d7HmlyYIz7VypzgkI8v0jX5iK/D22cCeRabe5vUHpZyVuHgFVvwB+OByNuiYIHzgVchh1tBsqQVmzwBWv2LqbXz3uUimF0A7JoHtnwPvTAaq95p6W3WY1wpoxzUJBoF/3wp8dmfM+sm/2+mwS4tY03JU7gDePgfYPV//WBnhuVZyeWLSz5V/BN6/DGirN/U2ebswTsxtw1pPAXMuAb5+0ZwMjZF6weSIMRJj5xfAO+cCJ3eZk4N7BWReq5ijY4JB4NPbgU//t936qYiOMTtmnNzFzsXOL0y9TdtrFYN+fv0i043WU6beFn4u2iVHax3w/qXAV380KQM7D/kZoerpTI4Y9XP3fDZmVO4wKUek1yrmcyEIbOz8961MV2OQg49b7YqOqdrD9HPHf0y9TRCECI9mu1qkrn6Fza0ttabeVh0mA/s7xtoxbQ1sjbHiD6bexu9TXriWE/OGzJ6FTD9PbDP1Nv49OWlOKTUo5nacgsDWnv/6OVuLxiAHvw7tqh1TvY+tdbZ9auptgiDEN81yzWvA7B8BzTWm3qY5fsay/vxjXyaHr9Xce5OQduV0x4OtW7ciMzMTbrcbd9xxBz777DMMGTIEJ06cgMvlQm5uruL44uJinDhxAgBw4sQJhcHNX+evaR3T0NCA1lb1C/jcc88hJydHevTo0SMeP9VSeD6FZnj5xtnAsQ3AurdNfXZcFyhH1gHb/g1s/hA4GdviQDERZfFFo8mJaM1rzPD+6nlTb+Mhf3KvVczhkW31bKF2YIXpxUFVmLe9XXJ8/zFwaBWblE0MevLCInJiztFc8Xvg+Bbgm7dMvS28hYb8b9OG/7ENwNZPgO/+Dpz43pwcmhORSTnWvs6+f6W5hVJti1eRawWEityZ1gtPI7s/ylcC2z8z9dbwwkzyv00vULb+Czj4NdsA8LYYl6E58noAIU+FaTlW/AE4/h3wzZum3haewwwg9srMFZuB7z8Cvv8n+9sE/D4pCvPuAjHoxjdvsHNhUj/lXis+bsS8gPY2AyufZ7qx7d+m3hoerST/27Qc2z8Fyr9i+ulpMiFD5HymkCOW8fPE98DaN0y9TWvcMj2vHv+OjZ1bPwGObWy/HLGOXd+8yWQxaWg2tPrhDYTa6sn/NS2Dr5Vdk0Or2PkwQXjhRYUcZvVzx+dsjfHVH01t7qtF0ynkMDu3rvyDqJ+vm3pbeItWpQxmN7O3s7Xntn8DR741J4fqRkiMY9e6t9laZ8XvTb2t2RtAmy9e+tkm6udqNqeYQGt+N60XexYAAS/gaQCciYlm6UgMGd15eXnIz8839DDLwIEDsWXLFqxbtw533nknbrrpJuzYYc7YijePPPII6uvrpceRI0cslSceSEa3Vnh5I9uowK55prwkcZ0Md81T/ztWOWIZcAI+dqMDwNH1ofNiRAbuPZPnWsVaxXLvYiAoRiZYdS4AYNdc9q+vGTiw0vDbQu3ClIvGUE6iifNRsx+o2sn+3v2lKS+J5mZMrOcCMH1NqjS8E+b00x/ycFdsBuqPGn4r109Vr5XZBfS+JWwyBOKjn+0dM/ytwP5lht9WExZOzYmp5sCpg0DlVvb37i9NeUniumhsh36qXZOiWMauYCCknye2AqcOmZYhV+Y9ky/WTNXm2L8M8Lexv83eq2obde3Vz4AH2L/U8NvC2zFxQvppQo76o2wRDzD9DBhPMwv3MAPt0U/5/D43+nFqcmgt5M2MXcEgOwcAcHI7UHvA8Fv5fJElFigFZLVjmr0ImqnNcWAF4BM3CU2fC35NZPdqrBtk/JoEfcC+xcZlaFam83Gktotmag40VIQ2YXbPN6WfqpuWsRp47dJPZaRlzHIIQkiO6t2mIvu4DGlOBzLE6Faun7XNXnO1Y8q/ArziJqGl60/xuwddYu59SYqhnO6XX365wwRwuVzo168fAGDMmDFYv349XnnlFVx77bXwer2oq6tTeLsrKytRUlICACgpKcG33yp3o3h1c/kx4RXPKysrkZ2djbQ09V0Tt9st5bB3FqTwci1Pd0OF+O8xNkF3HWXos6W+v+2dlAUhbNE4F5j8sOG3q03KMRVvOLRaGS67+0tg7M+NyaAx2DR5WDskPlnrIh/o9i9jXhK3sW4BapNyTMZ/Sy1waI1MprnAwIuMyRDVqInhmsjPReNxZmx2H2NQDrVrEsMCRRCAnWFGzXm/Mfx27WtiQo4j3wCtsnDE3fOBM28zJoOGfrb6Amj2+KXJWhf5NTmwgnm+3Vkm5QiNGUWxLFBa65gnUy7TYGOTs1SFOGzRyIuqmVo07voy9HdzFXB0A9BzvKG38t+r6rVq76blBY8Zfmt4252Y5Ti6np0Dzu4vgbPuNCaDirHLF7HeQBANbX7kiBFEusjPRflXTFfSco3JoZWeY0Y/2xqUG5W75gFDLjf0VmlTKCNs/OQh1WY2LeX62VrLIsp6TzL0VtV5NV6b6hc+afitmh53M3Ic2wg0ydaEu74EJt5tTgbZPcKvRyAooK7VJ+UV6yJf6xxczebadGOOK62NZFPXxNME7F8uk2keMOwqQ28N73YgyRHLpuVumX621QGH1wBl5xp6q+q4FWtLu/BNy2lPs7AwQ3LEydCs2Aw0VijlOPt+czLI1uL56S7YZLU55JsCmsjPxeE1LMQ8o8DQW6vUNupiGTO8LcA+caNy0Azj70tiDHm6b7rpJsOP9hIMBuHxeDBmzBg4nU4sXRraGd69ezcOHz6MCRMmAAAmTJiArVu34uTJk9IxixcvRnZ2NoYMGSIdI/8Mfgz/jB8KmW62UIlaSM3XygY7jomdrfB2IvK/TQ28J3cwj5HDDdjsLPyrzliUgSAIITkUi8YYbnT+253pyv8bQG1Szk5Ngcthst2M38M83VyOgMeUF08zZ9bMudizEBACoXOxe75hL568ArAcvjNuSjcironxXWi1SbkoFv2s3gPU7gccLsDmACq3AbXlht4qz7UqUjX+E3UuIifDDHcK0sSNIOP66Q3VO3CmM4/3viWG5Qhv4QbIxwwT+rl3MRD0h87FHuNeEh5pEd2TmOhr0k69qN7LPCP2FPao2mmqPofaIrowFq8q/+0xjJ9VKsZEqtMhbRoblkMeDeJMZzpiQj/D64MwmWIw8PaJ0UqSfi5gkVSGZNDTz8RcEy1jwtQ9UnuAeZZtDsDuBGr2stxqg1RJ16Sdc1o7zkV4PjfACoXyjSDD10QeDeJMZ3PsXuP1YzTTH8xck/1L2dpC0s9FbO1hgOjzewy60Y41V3hXEEBp+BuOjqk7zMLbbXY2x58qB07uNCyHVvSWuXs1DutPmQwpDruUSmb4PgkGQhshznRACIaiPw0Q3iFF/rcp/TywnEWw5fYEiocZf18SY8joDi8qpvUwwyOPPIKvvvoKBw8exNatW/HII49gxYoVuOGGG5CTk4OZM2fiwQcfxPLly7Fx40bccsstmDBhAs466ywAwLRp0zBkyBD87Gc/w3fffYeFCxfi0UcfxV133SV5qu+44w4cOHAADz/8MHbt2oU333wTH3/8MR544AGTp+r0Rjenu/G48v9xmpRrW7zwG203w7+z3wVAD3aNFTugGjS0+uELiLmAGZGTsuEJQB7aw72YB1YaznVSy+th7WZMLqLLvwa8jUBWKTDmZvacqY0QrZxuM5OhuEA5604gNQdoqTac66RmZAIx7EI3nWSeGQCY8v9EueKjn/WtPnj9RvVTPBd9pgC9JrK/DepnszcAj/g9Be3ZCJFHg0x5hP17cJXhQlFqkyEg34U2qBuHVgGeeiCjSygKJE7XJKYF9Jm3A2n57DwcXmtMBhWvakxyNNcwTwAQuia75hpO0Qnv+wuE7hEeHWMIfv7LzgV6n6N8TodWbwDNUtvHdnh35dEg/FwcWm24UFRU/TQ7dh1ewzaR0wtCUSAmNkK0Fo0xLaDHzQQyilgE1aHVht6qdo8AMUSEtJ5iYwQQk35qGXg8OsYQ3Nve+2ygz+SQHAZQtPeLYlwZhl8Tfi6OfAM0VUU/Xka0a8LlMLwhc2Qd0FIDpOYC4+8Q5Yphoy5e+jn250BmMVtzyCOHTMrA/m/SwGutY5EoQGjNZSLFUSsqhUfHGILrZ8+JQN/zQ3IYwB8I4pTU9rGd0TGSfoprHRMpjmr3qvz/hu+ToxtYtJI7BzjrF0q5DMmhthHSjgjHQZcYjjhIdgwZ3bm5ucjLy9N88GPMcPLkSdx4440YOHAgLrjgAqxfvx4LFy7EhRdeCAB46aWXcMkll+Cqq67Cueeei5KSEnz6aaian8PhwNy5c+FwODBhwgT89Kc/xY033oinnnpKOqasrAzz5s3D4sWLccYZZ+DFF1/Ee++994NqFwaEWoY1Rate3iAa3Rld2E70yR2GvSTyKsCc/AwW0iIIkKol68InnUEzQqEkBiciKdcqNUURvm06lPn4FhZe78wAxt0KFA4wleuka2gaLajBf/fAHwGDxdZ6Zrwkqi3DTJ4LeWjPkCuAARcpZdMhWk5iodmd8N3zAQgs3WHMzcxLYiLXSW1SzklzIkXMuTccRixNADNC+UUGJyJ+PdJdDqS7QuHbptMfKrexHfmUNKafRYOZF2+vOf2MKB5mtgow/90DLw6Fy+5ZxDzgBlAvHmbSsPK1hbyXQy5nsshl00HKSYyS021Yjj0LmCegZAQw9hbmJak9AFTtNiaHykIpyx1DdIxCP2con9OVgX2HO6y9n+kxo2oX8xA53GwhXzzclJck+kK+Hfo5WNTPvYsNe/G0U1IM6oXfE4oGGWxeP9U2YwBZzqzRc7FnEfOkdhnKjP+UVKDuECsaZQB+LuTjeEzRMfIFtEn95HNFit2mSC8wr597mIfd7mRzSenIOOun0bWOyvi5b6nhQqVqURCm9VNeu2bwpWytIZctBhnY/01ek31L2BxWOJDNac50oP6I4UKlauNnqtOBLLfJzjXtWH/WRmnvZzo6hteusacAo28Cuo0BIBjuUhJ1fje7EcJ/94BpwNAfs7/3LzNcqFQvpc9Q9IE8WqmThJYDBo3u5cuXY9myZZoPfowZ/vKXv+DgwYPweDw4efIklixZIhncAJCamoo33ngDtbW1aG5uxqeffirlanN69eqFL7/8Ei0tLaiqqsILL7yAlBRlTuKUKVOwefNmeDwe7N+/HzfffLMpOTsDWVLLMB1Pd+EAthMNGPbiqd1gDrstFNJipMhJ3REWTm6zM+NukDgBHDTmJdHfgTY5Gfa7gFVKjHHxGi2k2tCgJy/0MmgG0GM889i01Snzq6Og57WqNVrw5cAKFtqT0xMoGa48FwYGzag5iVIhNYODr9yYSM0J5XqZXBzIdcNut0m5d4b0Uyr0YgMGXBzSz8NrgeZqAzLEazKU6acrPebNqYiNEDMLpWAw5BUYdAnQbSzbrPPUMw+4Dm0+udcqJAfXk1NGo2N4oZesrmxDxrR+ap+L2maPsftEbky4s1gkBGD4moTGjJBumI6OaTzBPCIAWzzzBfSRdSxSRAe1to9MJnH8NLtZ2Pc8Vn8ixvEz0tA0cZ/Io5UGXcJ0I6uU6Qr3qGngk3mt1KJSDEfHHBSjlTKL2eJZvlFnRD+btcfPUy0+Y/eJ3JhwZZj24kXbSDZ1TZqqmEcZYGMn189jG0Ib/gZkiGzvZ3YzhkcrTWZ9f81unuqNn0buE3m00qAZQOkZQHZ3VlTtwArdtweCAmqbI68JHz8MR8fw2jUZRUD3cbJz8aWhQqWhQqnqa66GNr+x+0R+LpxpbG4DYrgmUfTTyDWR164Z9CM2x8PGnDAGCpXy8TO8vV/M83vvc1j9iTiNn6buk3D9LB4K5PYyXKg0GBRUUw+4DG2+oLQ+1YTXrknLD0W+dgIMGd2TJ082/CCSk6xUtjusG16eXWp6IlLzWsn/b+hG50ZmzwlARiGQ34ftzBvMdYo62Jj2MIdVSuT/Gsx1iounhhd6cWezwdfuMOUliea14gNgICjglJHoA7mxa7MBfS9gHiyDuU7RdsK5sesLCPqhX57G0EJEuiaxTkRx0M8eZwJZxSzHqGSEYS+J7mRotPqufDKU/7t3CfP86sqhHn4mFUYyIsdxsdCLK5NtgNjtoU0IA9eEGxNOh9JrlZ/hgp1HxxgpEiU/FzYb0Oc8FgFQf5hVzdaTg5+LsEUj18+gwFpYaeJtCS1Ewq9JexdKZsYuHg3SbQyQ3RXI6QZ0HQ2jXhK1Curs/zF68MLPxb6lhrwkeuGRhs7Fie+Zp8yZzjZA7HaZF09/I0TutcqTea1MR8dI3swfMRnKJrMIKl6oVIdoObN5YmEkwEAUma81shCRyY06vfHTUNswHg1SOhLI6Q5klTBDDzC0uR9VBrPRMdH0kxcq1aFKpagc+78J44rXrklJZRsgNpupa3KqxYsgb/soS6WT144xtEkm97bbHUDZOYArC2g6AVRs0n27Wn47kyN0n+iO4/LaNeFrLpNRZO0au3jtmuLhQF5vILMI6CkaeruM6Kf6uTDdwz1CP8VzUW4sxVGt6KH8/4Y87lW7WaSWwwX0myrqp/FrUt/qgz+s7SMQFh1jVj8dBou7ngYYMrq///57BMWdr++//17zQSQnPLw8qqeb7zZnlcq8ePq5TnKvVWRItYmJKNyYkP9tYCKKlp8pD9/V9arW7GcTos3BwmoAtnDNLDGc6xR10DNTOZz/3v7TgBRx0DLhJYnmtXI67MhNdxqTI+BXetsB5rnqe15IDg2CUXbjAZOhX/vEQi/5fYCiQew5voA2kOvkCwRRp5JrBYSuiaGJKHwyBExNRGp90+UyGPL6nzrEjEkeDQKIXryurJ1buX47t1Av5nZsQEje9qmAM5X9bcJLIqU+ZCj10yGLPtC9JvJCL/yauNINe0nkhRfDjRr5faIbwrt/mVjopRfzCAAhL0nFJqD+mObbmdeK6UZcronq+Glkoy7aZkzI66/bbqb+qNgbXIwGAViETE5Pdo4OLNd8O5NDx8AzNH6GRSsBsnOhr5/cYAn3WtntNpn3TEeO8GgQgN0r/acqZYyCvPBi+LmQR5HppugcWMnGhuzuzKMKsLHDZmebE3WHdX5GyGslL74ol8ucfso6C5jRTx1jwlB0TMNx5lkHQnNIl8FAXpnhQqVx2cDlv7fv+SzyAAidCwOFSvl35MnaPgLh0TE6coRHgwBAihvoL0aaGlhzRaterogi05NDilYqDXXL6T/NcKFSdp/obNQlcP0ZXhmcy9DQ5ofHr+Pdldeu4fpZOAAo6Ge4UKnu5pSRDTJ57RrejYSfCwOFSrkM2akpcKcoO/UYtgnCve2dCENG98iRI1FdXS39PWrUKIwcOTLiMWqUsRZTROKRWoZFy+nmLQqyStlOdOlIAAK7yTTgXiuXw47sNOVulOFBr6WWhZEDocEGUHpJdHKd9AZejz8Y3cvP4Yv43mcDaWJ9ApNePP1FY4wL6D5TmOem4SgLw9eSQaU1VbgcutfkyDoxtCePRR9wDE5EfDceAPJUWqhIxqbeojHc2w6waIxuY2HEi8c/32G3KbxWgAnvhLzQi9qicf8ywNus+RHRrkmBzOtfr+dV5frZa1KotYxJL0lcF43yc1F2LvN8N1YwT7gRGbJU9MKod0Je6IWnwwCGF/KKwouZkXIUGDX+1Qq9ZBWziAhA14tX26zutQJM6GdbQ2jDRaGf4t+8nZsG0fRC7vXXjY7h92LPs5inCAjTTyPGlfp9Yqr4opp+9j6HRQ41nwwZXtFkiBJ5wJ4zKEfFJuYxdGUxDyLH4EZdk8evWnjRtBzh0SAAiyTjY7qOF0/htQqLCDHcNszTFBkNAsi8eF8pW3SqEC2aLi/dRHQMvxe7j2OedsC8fvJQ+/ANiFg21eXnotdEVlStpSZkeEWTQdqAiD6v6sohr11TJotQNXgu5ClscdFPHg0CsLmNt7PTGT8b2vzwipstEQavUf2M1paKr0UNFCqNNn4qomP0rolUu2Y0i1QCYtbPdoWXq60/eYqjgUKloXZh7Vh/ymvX9DlPX+bTCENGd3l5OYqKiqS/Dxw4gPLy8ojHgQMHOlRYInbk1ctVPWrcY5hdyv41uDgIFexS5loBoRtMd7DZKxZ6KR4G5JeFnjeR6xRt0EtzOZDh4gVfjBp4YX1+DXpJAkFBCveL9Apwz4TOYMMLvfDQHo6JXKdQ31+1ydDgRMS/Y0BYaI/BXCe+GZOb7oTTETnMhNqGacgR8LGwL0DjmuidC+61csFuV+qn4bZhvNBL0SCgoG/oeSnXqU3XSxJNP1OdDuneNK6fYTu/Br0kwaAQqmofq9eqeh8rlmVPCXlFgDAvifY1iVahWv6c7n0iFXqZDjhCIeqSF69yKwvhjPYzRC93lspuPCAvVqVxTQL+0KZktGtiUD/DvVaAiQ2IfUuYJ6SgH/OMcIoGAvl9mRePLyqjUBNlI8TpsCNP8vrr6WcUz4RcPzW8JEqvVXiYpsHxs7acLdhsDuYx46S4Qv/X2ZySxk+NRaP+ZgyPVrqQ3Ruc/heye0enUCk/1+GFFzmG2trJ21JF1U+9c8F+Z06aE64Udf3U1Yv9y5gO5pUxz7L0Af0hFSrVKQQZbaOORccYvSbRxk+eQqZfqDR6dX2D41Z47RqOwykrVGpszNAaPw3P7/1l0UqAqJ9OoHqPZjs3/vmusBQ2jjH9lEeDRLkmunMJkyPTrSygC5gYP8Nr10g/oi/QZQhbm/KCiFGIZuzKo2NMORjk8HOxd5FuoVK19qiAiYKt9cfE1AJZtBLA1oD8/3GY3w2vdXjtmk6EIaO7V69ekkHVq1cvzQeRnPCFfVBgbT4iaOCe7q7sX8mLt1wz10mtRzfH9AIlfLAx4cXT9J4Z8ZI0VbFweiDk2eb0Ppd5SXRynWqbvRC41yo9fNFodLARf2eZWOhFjtGNEEOTsoYcWqE9BnOdpOImKl5uQFZgRMs7cZC3pSoK5f9xDOY6xWeBoqWf5q6J2kaIoQmxpTbUamhguH6ezTy+zVWhYloq1LX6pBDhaMVvdPVzd1ihFzkGz0U0r5VSDo1zoaWf6fksEgDQ1E+thYFcDs1F9OG1bOc/vYB5AuTwc3HwaxYpoStHdG+RKWNCvvFpwksSLVJI/pzmNZG3pQrXz54TWMRMa22omJYKcq9VzNWhpWglWTQIh5+LndrtsoyMGTEvoNPyDBUqjZb6wDFUIfrIt6zFY2puqMUhh1+jQ2s0C5VG2wRhz5k08ML1kz8nP0ZHjvAUDLlsmrrRVq8erQSwqJT0Qt1Cpc0ev7R2ip7TbVA/ee0aOfK1Tsz6aXBzKpqDQV6odHf0ayJt3mZEOlvksmnWPji2gUWe8No1crh+6hQqTZx+Gtuoi3n8VKtdw5EKlTZopji2+QJSNGfMkWzhtWvkGCxUGq3woik5dkaZ3zsBhozucCoqKvDxxx/j9ddfx6uvvqp4EMlJmtMB7uiLyOsWhJCnm4ddKXKdontJ1NqFcQxNRGqFXuQY9OJpDXqGvKp7xNAeXuhFTorLUK6T5FVV81oZDY+MtlgDQrlOJ7ezQhdRiFaVGTA46FVuZy1lUtJClW7lGJiI9IwaadGoVVAjvNCLnKIBQEF/3VwnzUnZSPiZotCLjn5qePFCRZFinIiktlTDgbywzU2Hk3l8AZ1rEt1rZbjNi6Z+il6Sql3MIx6Fdm8KSYVe3KHoDzkGFvJ6m0KhRaOGHNGiQQDmJSkapNvOTetcFBhZQPu9oUKT4Ys1+XN7Fmp68bQ3Qgzoxt7F7Ld2GaKMBgEMe0mMea1iNCYAFjnkcAG1+5knT0cO9YW8gTGjag/7fLtTGQ3CMbA5pTWfAbI5TVM/eTTIRcpoEIBFlBUPE714CzXk4HNJjHohb0ulpZ867dyi5Q/Ln9O8T/YuZh71wgHMwy7HYKFS/jvTnA5khHl35RtkmrU5tPJU+13AiqudOsgiIaLKobXmMjB+8to14dFKHAPjZygyRls/NeVQq13Dye3BIh11CpW2e1NdrXaNHIMpjkbuE83NU6l2TV8WoSTHYIqjFH3gsCM7Vamfcm+7tn5qzO99zxPbuWkXKtVOzzEwfp46yCLVwqNBOgmmje45c+agrKwMM2fOxAsvvICXXnpJerz88ssdICIRD2w2myyvO8w4aD3FbniA5XSzNxgafA0t1rQMqwMrWPh4Tg9WDTocg7lORvLwNIvwaC3WAHMLeY0c0boWH3zRCr5IhV5skd4iQJnrpOll1tp15QU1DBi7fc9XD+0xkOukNRnKn4+6E65W6CUcE9dEfTOG66eGXsjbUpWq1KyQt3M7HN1LYsS4MnRN9M6FhhcvWrswILQr3dim0W6msZJ5zwB1/UzNCeWvanhJtDZCjG3GqBR6kSN5SdYAzTWqH6G1iAcM9C1X6GeU3XgDm1NaizVD0TEHv2YekIwuYp2DMLrL2rlxT7SmHGrXRMxvN3JNjJyLKPqprRfsuRZvAC3eKJtbzdWhfENV/cwO5a9qXpN2bpBx3S87l90T4XADT6NQaWhTSF0/i/Qq28dZP9W8Vob62R9aw8bG9MJQnQM58kKl5dG9eFr6aWghr3su9AuVasvAzo/XH0RjtNox0WrXcFwZofzVWOc0IwaeWu0aOQYKlepuWuo5GQRB35tpaHOqnXoRrXYNp3QkkN2NFSM8EL1QqZGxy7B+qkQOSOdid/QUR/lmTHj0AZfBH9SoHdNaF/Kkq60znGmG2g2GHHFaNoHWWlzUT3ntmk6EaaP7sccew+OPP476+nocPHiQcrpPI6K2DeOh5emFyh1HA7lO7d5pVCv0IsdArpNWpVcA+q13PE0sjJ7LoUY//VwnLRny0l1SJdyooYmKQi/F6scYmIja7bXSW0AbyHWK1u4mJIdOnlOF2JYqvNCLHAO5TtHaibDnzJwLWaEXOQa9eMbC4KKci2iFXuT0k7Vzq9qlI0OkXmSnhdrNRPWe8WgQeaGXcIxshETpNMCeEw289iyg83qxiAANL4mWt0j+fNRrcmIr2/F3pocq+ocjeUmit3Or0tosNBIdI52LKPpp1IsXpao9k01HP31trGUdEP2a9D2fRc7UHWY512oyaIxbme4UuMXojKgLNqkt1RnMU6ZGOzfqDEXH6OlnTnexUnP0QqVaaQeAAU/3yZ1sLEhJVY8Gkcun0c7NUFG5WKOVgDAvnv5GSEzRMWptqcLpw9u5RS9UGq1dGBBWOyba+YhWu0ZOOzdCTG2qRzsXUqFSRE2B0NqYAuTRhVGuSfUeFnESXrtGjoFCpdpziREDTyNaCTCc4qg1ZhTpyaFVu4YjFSo9LnaIUJFB41y4UxyS9zvq2MWjlcJr18gxsRES+/pTZ/w8zTFtdLe0tOC6666DXW2CJ5IaqZhauKeb9+jmXm6OlOtUH8onDcNI+G5NsxdBtXYzWoVe5Oh4SZq9AbT51HMB5c9FvdH3L1Uv9CInNZtNzEBUL160tiaAwTYaRgYbvgt9RN9LEtMCpe4wayWjF9qjMxFJOYlRPDX8+aiTcrRCL3K6jQEyizVznYwsoGujtZvRKvQiRyfXSZFrFUtFzwPLxbZUPdmCTQ13FvP8AlGviZZhZbPZ9D3upvTzW+YZV5PDyAZZNL2QF3rhxqQaOouDUM5stEgMndBueTQIb0sVTqnYzs3bFMonDUNrzODPRY2OCQZloZFRFmvy16Lop8cfQEObei4gIPOqRjsX5bwtVTex64UKrnRdL4mWXrB2SDpePD1jAhD10wYc2xjabA6jyshGXbQFdOOJUF0FNW8mR8f410oRYs/rhFTzz+1zXqgtVTglI1iEmb81aqFSLf2UomM8UaJjjEQrAbIUHXUvnj8QlCrnx7SpXv4186Rnloi961UwUKhUN3pLb+wy0gJp4MVs7j3+HSu6piWHSv0a3fog8to1muOnnn7qbarrRLJp1a7hdBnCemZrFCqN1ooTCF2PVl8AzWrRB0bbUumkOAblbR9jmd+l2jVdWGSSGgbauWltkAGh81EVbewyci4GTBfbuUUvVNqu8PLmmlDEoNb4eRpj2nKeOXMmPvnkk46QhehgorYN40Y3r1zOMeAlidafEAgZVoGggDq1kJYj61jYeGou0HNi5OscnVwnLoNarhUQKl5lyNhV87ZzdCYioyHVqotGrUIvcgzkOoWuSQzeM25k9pwIZBREl0Mn18m4J7EdC2i7PTQwR70m0Sfl/HQXbLzdjFo7JKnQSw7Q6+zI1zlSrtMRtmERBl/Eu1LsUn9yObreM7W2VGoY1k/thZKqHFqFXuRkd2WbIRpevHYtGqVCL+OBzC7R5VB4SSK9eFptdwCZURPNk2hUP3W8eFpeq9w0p3Z0TMVmNna7MkPFj9SQt3NT8ZLwz06x25CT5ox4XXehpBetxNHZqAu1C4shZNXbrN6WKpys4lBRRh0vXkwbuPwzu42NnE/lcL2JUqiUF5iMummpF4lhZAFtIIUsdK9qR8eono/j3zHPsTMjtGGthlSotJJthoTBC5TaVdrqAQZyZvWilTg6G3XR2oWFy6F6LvRq13AyCoEeYqHSaPqptVGnZ/hL0UqjImvXyJHaDaoXKpUK6OrpZ1QDz8AGroFCpVr6meFyINWpoZ96tWs4vSaxNJGW6lB6lYxTLV6pQKmqfhqd36NFg3CMngud9ae6fraFauNoXZP0/FBRxigpjtEqqMufi66fGrVrOgmmje7nnnsOK1euxJQpU3DPPffgwQcfVDyI5IV7uiNyjhqieLoBXS+J1o3uSrFLizjVHXn5YKMW2iN9kHauk9YiXi6b6o2uV+hFjk6uU2iwiSGkWir0MhAo7Kcth8bgq+e1ksugWlDDyGIN0M110suZ1VzI1+wHqnZGL/QiRyfXSWtSTnHYpSrzqtdEKkSkUuhFjk6uk9yw0qr0qq6ffmPRIIC4QWZjhpVKOzf9SVnjmvC2VGqFXsLRWMgzr5Uvqhz8udpo0TFGQ8+Kh7HIAH+rqpdELxJDs0q1VOjFESpgFw2FFy/SS6I1dtntNllBIrXxM0pbqnCcqaEQTpVrIvdahbfVA3TOhdFoJSDUzu3EVuDUoYiXtbxWgLxtmIoc+5cxj1heb+Yh00JDPwNBAbXN0TeSJf2MFh1jVD+LBgH5faIWKtUrVMWNnZpmlcJd9UdZS0ebXdubKZdz95eqhSD1og802yHJ2/5EiwYBdAuVcmM6PyOUoiVHs2CrIhpETz+naRYqbVfHA73aNXI0NqcEQTDUMaa+1Qevvz36OYAVKg36gH2RhSBrdNY6oU1LFf1sqBA3V6LUrpGjU6i0RppbI+WQR8eo6oZe7RqOIsUx8prwz86L0h5Vc/w0Gg0CyNq57Qaq90aVI9qYobmhrVe7Ro7G+lOe6qmVqtQULTrG6Lk4jYnJ6F64cCEqKyuxdetWbN68WXps2bKlA0Qk4kUmz+mOCC8Xw+zUjG4p1+kYm8jDkFpH6ExEEbvQRkN7OBoTkfGwL5XB5tBq5mWOVuhFTlaJppdETw7NQc9MHovcixfmJdH3WjEZvIEgGlrD9KClNtQyJbxtWjg6uU5aaQdyORra/JGLA34uohV6kVN2DuDKiprrZFSOiGtipNCLHI2JKGYZAJZG0FoLpOWHPCDRyOwSal3FDSE1OaIt5I0sUPS8mYDMS7KCechl8DA8u43VOQiHL+JVo2MUhV50romOl0Q3Z1Z8XnVxIBV6mahf6KWXvJ3bhoiX2xUdY2aBoqmf7fCQHF3PfltqTqhVWzQyCkIRTTGMn5pyGI0G4ccAbKEZ1s7tVIsXfK9HzWuVn6ERHdPWENqA1LsmOl5m6V6NWqiKPd/mC6LZG0U/e5wV2ZYqnJ4TWaRZa61qodJ2jV2m9NPAuYhFL45tZB50dzbzqGshb+em4sUzfq9qbOAaGj/Fuffg6oh2bvWtPvgCYttHlWuiiI4JD+1W1K5p7zXRSx9jsvkCguQEkDBSu4ajU6i0XboR0/oz0vnUrnGL167Ri1YClIVKVa6JVi0f9ryBDVy9aBB+DKBaqLTJ44fHHz3VMztVIzrG22IsWuk0x7TR/eKLL+L//u//sHPnTqxYsQLLly+XHsuWqeddEMlB1Orl3GurFg6nkeskz7XSy+2JWMif3ME8Rimp2qE9HI1cJ8PtVbSMCb3QHo6BiUhthw/QyD0zUuhFDs91CngivHhyr5WaVzXV6ZBCnKvDJ+U9C8VCL8PZ5+uhkesUyklUPxfZqU6kiIuD2vAQXjOLNY1cJ4XXKuo1iTIRGSn0IkfKddoG1JYrXtI7F/LNmAivgNFoEI7GRohuxe5oiwO/N1Qwz8g1KRwAFPRTbecW8lq5Vb1WTocduelOdTmkQi+Doxd6kcPPxZ5IL4lW1XAAyHJrLA5M6aeLedCAiGsiCIKB1npRxq7qvczjEa0tVTj9L2SRI1U7WSSJDN3FWlbIUxOpnxptqdTQGD+1WnXJ5Yu4HmaiQQAWSVQ4kOlSmH7W6HitHHZb9OiYfWK0UkF/5inUQ6NQqd6Yke5KQZrYVi3Cs2rGmHCkRE0h0ytQyp6PMn7WHmAeY5sjpP9a8EKlNXsjCpXqR01pRMcookE0opU4HbE5ZSYaBGAREF2GsrmYtwOUZGA6l5WaAndK5HpFHh0ToZ+8dk1+HxZpoYekn4si2rnppY/J1xmR+mnCwaCT4hjzNTFau4bTV1ao9OROVRn01sCq0TFSNIhG7Ro57Rg/Q3UgwvQiGDAeDQKwCLKSEaopjlwvMlwOpLki9ZNFH0SJTNm/TL92TSfAtNHtdrsxaZLOjjaRlEiF1DxhHiReUCarq/obo0xE8lwrNa8VoGFoKkJ7ohR6kaOR62TU0x3htTIT2sPRyHWKeYHCC71klYpVbXXQ8OLpyQBoXRMTizUgaq5TqzcgeV+iTURRC8s1nQx5XPRCIzlRJiI9rxUgm5TDc8/02lKFI891iqqfJr1WZqNB5MeptHPT91pFmQwPGSj0IkfDi6cnA3stTvrZ4ywWIdB6KtRKCqytTygFQ12OqKGz8kIvetEgnCiFIOtbffAHo3utAI3oGH5ey85Rb0sVTlou0FvdS6I3ZvBFfER0jNloECB0zg5FevH0vVZRxs/Da8S2VAWhSA9dOdQ3pwyNn3rXxOi56D4OyCiKKFQqT8GIphfy1xT3a+upUGu4duqnntdK/nzEmME9xUailQBlodKo10Q7KkU1OsbsNeHnTKVQqe74GW1eNVq7RiGHtn5G20Rm8kWJjjETrQSECpV6GxWFSoOyzWyt+0QaP+Wb6q11xmrXyImS4tji9aNFnC+jhlTzTfWI+d1g7RqOOzPUpSLqnKYug2Z0jNn1p0aKI5cjqoMh2rh1dAOLVtKrXSNHb/0Z5XoAGm1BzUQrncaYNrrvu+8+vPbaax0hC9HB8J3HiJZhUvXyEvU3SrlOOxReEj2vFRAKj4tcoJhcrMmPNTkpZ7lT4BLbzSh6zR7fwsLm9Qq9yCnszzx5YblOwaAAvYqeod6/UQy8gQZCeziSF0/pJdHzWjE5VBZrRtpShRMl14mHtUUrHCbJoTYJ7J4PQ4Ve5ETJdeKfm5fuRIqK1wrQ6MccS9uKqBOR9qQs91opJqLKbWxHPiUtVNNAj4K+zBMc9IeiJ8C8Vnq6EbX3r9loECDMSxLSM622JtJPyFBJSTFa6EVOFC8e188Uuw3ZqdG9s6oVeKVCLyPYjrwR+k1lERO1B4Cq3dLTXOeiea0AA5uWMY2fYfqpU1RO7rVSXJOqXczz43AzT5AR8nqzSBpVL4nBSIyIBXQ79HPvYoUXT89rBUSJjvF7zEWDAFG9eHxhrrWZzWTkniu5fi5iHtIuQ5lH0wh9z2cRZ3WHWHEpET2vlVyGiB7useRm6mzURfP6R42OqdrDPOd2J/OkGyGnO6tXoqafjdrRB9HXOiajlYDQuQgrVGpkU0i1C4WZ2jWcKIVK61p9upvZTA6VsWvfEjY3Galdw+kzRbVQKR8H3Cl2qV1bhAxR5/eOWH+qXxN5dIxi7DJTu4YjL1QalkKmF70VSvWMsv7Uq10jJ0qhUuke0dAL1c3TgD9UeLUTh5YDMRjd3377Ld5//3306dMHl156Ka688krFg0heMnkhNXl4ecDHdrkAdkOrIc91knnxTHmt5DdY3WEWJm40tIcTJddJq5onwLxWqh4jo4VeIuQQB4WdocHXiNdKNbfcTKEXOfJcJ56HDWOTsuo14W2pcnqyypFGUfGSyPMR1ULcQ3KoeBJjMSZSc0L5ULIJUU8vgNACWmFMyAu98B7cRpByndYCzdXS00Y2QlQX8ly/+l2gXeglQg6un19ITzV6QrnzpkLxFG3TTCygu41lnnFPvcJLordBBkC9wmn5ylChFyPRIByVXDy9wmEc1Qq80mLNxLlQtHMLXRPeukXba6WiF0bbUoUjtXNbxyJKRExFx6jpZ9/zmCfIKCrGlRGvlap+xhKtBDAdyiplOiUrBFllYFNINTrmIG9LVSwuig2i4sXjnxutcBinSM3TzfXLzPjpylAtBGnEa6Wqn01VocgSo952IKSfxzYo2rkZ2ahTjY6RopU02lKpIV2T0FzS5gtIBWh108fk10MQQuOwmWtSegaQ3Z0VX5O1c9Or8C+XTyHHwVUsoiKjKFSXxgjSufhSKlTKr3VulBQMjqQbzWrjp4lzIU9xlK255PNqtHWGqn6aqV0jZ8DFAGzMWSMrVKrVwSckh9r6U/wtvc9hkUhGUTH+fYEg6qQCpSYiMWKJpgOA4qFAbi+xUGmoEGTM68/Da1mUjpHaNac5po3u3NxcXHnllZg8eTIKCwuRk5OjeBDJi2pONw9RsTuZERcNFS+eocFGbSKSQnsm6Bd6kSPPddqzMCSHoRtdbYESY6VEFS8JlyFby2ulNgEc2yAr9HKOcRmieEkkQ1NjUlY18MyGnnGkXKeDUjs3vXxESY5wT6LRtlRqqCzkzU0AKnrR40z9Qi9youQ6hRZKZiflGDYg5MfLvCRcBi2vlaoMx00UepGjaJdl7pqob5CZKEQkp895LFKg/jCrmi373GhFgDiSl4Trp9G2VGrEUz95NEi3MdE3StXI6Sb2KRbCNk/1F/KqY1csizX58fuWSl4SPm6lOqN7rYrUNsiOf8c8YM700MaGERRePNlGnU5Uivw11XvVTLQSwPoU80KlYiFIvcr6HP665Ok22pZKDZWFvBFjV7WHO29LVTrSeLQSELVQaZWRjTq1gq3tHT9l7dz473M57MhOU/dWq+qF1JbKYO0aTpRCpYb0U+2axBINAoQKlTadkNq5hcZPba9oRCSG2do1ctTWn0Y2hVT1c4G52jWczCKgp2gQ7lIZP81Gx8Ssn5Epjnwj2WG3RY2OUa0dU7WbRWAZrV3DiZLiKHWgMG0TxBANcppi2uiePXu25oNIXrJ49XJ5eLkUWl6q02OVe/FCuU5mFo018Visyd+jmIiMTMphg2/NfmYkGi30IqfraCCzhHk2yr8WP1d/sOGDXm1zqK9jqNCLidAejpqXxETOl3QuzBYikqOS66QXZs+JKPiyz2ShFzkquU5GJuUiVf2McTIEtBcHhvRTPBdSWyqT0SCA6MXrqmjnZkQ/uXynWnzw8YIvZgu9yFFp51ZjQg7pmpgtRCTHlR5RCNKofkZEYvC2VLm92E6/GbiXRNbOzZixG8fNGPl75OH2JgxN6VzwtlRmo0EAFkmTI7ZzO8CqKRvzWjEZGtv88PgDyt9hNloJkBWC/FIqBCmNnwY2yCQDL9ZoEIDdU/2V7dwMj5/hObO8LVV2d+YpNYPUzu17FokGc+OWerRSDG1/VDenjIwZYeNnw3G2oQ2YiwYBgC6DgbwyRTs3vQKlTAZ2nlq8AbR4/crfYbR2jRyVQqXmHAyifsYaDQKoFioNnQudTfXw+V1qS1VqLloJYOujsHZu/HPV2oVJMmjqZ7zWnzGMn42VoTo4ZvWTFyqVpTjya52fET16i8vg8QdDNoDZ2jVyVNq56RU9lL+mrp+dO7QciMHoJk5fpEJqbSpGt1rlcjk81wmClHsRahdmxEMiDjby0B6zgw2g7iUxMynz0Bq+k2600IschRdvriiD/mDDC2oEBVbkK6ZCRHJ4rlPDUebxMSiHtGjk4ZFSW6o8Fn1glrCJqNpAkRVAlg/IB99Yve0A099uYpEv8drGlP6gaEvVjkXj/mXMMyqTw9RGiNSWapJ+W6pwVLwkRvQiLz0UzipVlG/PArrsXOYhl7VzMxRqH76A5m2p3DmhNBczhC3kjZwL+es1EfoZQ6GXrOJQS0JxAyGmULy2BhZqz+Uwi0o7t5jkkKKVzmIeIDOoFNozIkNOmhNOh9gOqSkO+tn7HBZhJGvnZszQDJvTKjYxT6ArK9TSxwxhG3VG9TOiJkas0SAAizjjY794bfX6pstfk2RQtKVqx6alrJ1bTBvJirZUUWrVRCNG/cx0p8At1o4J6Wc75vdeE1nxtZYaqbhoTPcqb0vlzGCRFWYJOxc1Bq4HoKGfZqNBADYH9hYLOO/i87uJtQ6XIZbaNXL4mlVWqDSma8KjQbqOZhFIZlDRTyPzaprLIUURVUeMnzGcC5V2bqF71UTU1ImtLBLNTO2a0xhDmn/RRRfhm2++0T2usbERf/jDH/DGG2+0WzAi/oTCy2UVPhtknm49whcHJnKtqnhIi9SWahiQX2byFyCU6+RvBQ6sQJsvIO3amcqZbc9iDQjzkgQNLQxSHHYp9Ke6yQPTbanCUWnnZir6oDnsXAyIMbRHynVi7dx4qKgpT2LAF0oZaO81MXMuskIyBIOCrC3VIGNtqcKRcp3agP3L4PUHUd/Kc620PO7R9DPGnd8wL4kRY0JeUb6q0QNU72PFsswUepGj4iWJaSNEKvQy3VhbqnC4F69yK3DqoKHNQiCsOnR7okE4YRshhjzMon5K0TH7lrBWbAX9mMfDLEUDgfy+Ujs3fyAoFe4yZ3S3w5iQv0/0khi5V202m7IwkrwtVX+T0UoAiyzi7zOxORVqoRZ2LvpfyHTeLGHt3PTaMUlyyMeM9kSDcCL007hXVYqO4W2p8sqYx9gsUqFS1s6NVcrW18+IIpDtHj+V7dyMjJ+sHZLMyDPbliocRaFSblwZHz8jNqb6xxCtBIQKlYrt3Izrp0wORTRIO6+Jifmdr8ca28TONbHWruEU9GUtW4UAsGeRsu2jmeiYuOnnIsDvka3Fda6JPNy+/hjbMIwlWglga0X+PumaGLhXwzfV5dFKZmrXnKYYMrqvvvpqXHXVVRgyZAh+/etf45NPPsHq1auxceNGLFmyBK+++iquueYalJaWYtOmTbj00ks7Wm4iBqRCaorwcrFgiSGjW5nrxAcQrTAjfvN5/UH2ve1drIXt8ilyrVI1KmVL+ZlesdCLuIlkppCGnN7nMi9JUyVwbKOhSVn+enWjN3QuykwWepETNhEZCU0skm9AxFpIQ44812n3l5IxX6iTk6gw/g/ytlQmC73ICct1MrIRwvXCHxSYcRwX/QxdE75gdNhtyEnTqJQtLRq9yrZUsUSDAMwj7A61czMyGQKykP9mL7BbnAzNFnqRE8NCSVHwpb3RIIDYzi3kJdGr8spReGpiaUsVDj8XopfEUHRMelh0THuiQYCI8bO2hbV9tNm0KxFLBQcbvcq2VLHqZ88JLLKmtRY48o1sA0Jv0Sgbu6S2VDFEg3DCCkEa2ggJr4jc3gW0vFDprnmGjF356zVNXmVbKt660Cz8Wh5aA7TUGprT8tJd4NGstc1x0E/+XgDYNRd1rT4pFUuzUrZ83GqrN9+WKpweZwLphVI7N6Pjp2LsirV2jZwI/TS+5oqbgyGsUKnhmgNSITUPC/VvPmm+do0cqRAkS3E0op/ZaSmh6JgO0M+GNj+8YiqWsYrd3vbVruHwQqViOze+kawbfSCF/HtC0SBma9fICStUaiSlLzIC4ocTWg4YNLpnzpyJAwcO4De/+Q127NiB22+/Heeccw7GjRuH6dOn491330XPnj2xfv16fPTRR+jZ02ArFSKhhPp0+0OFFHghNb3wciAi18mI10oe0lJTW9e+0B6OzMtc3cBCzLVyrYCwyTDWQi9yUlwKL17Iu6s36MkGnHgMNrJcJ3/VfkNeK0mGRq+yLZWZQi/hyCYi0zmJTbLJ0GyhFzlFA4CC/lKuk5H2P66U0GZNTV29+bZUasi8eNUNLMS8QCPXir0u0wupLdVwIK9XbDI4nMwzDDD9NGhoKjxGcdHPC6V2bsGTewx5reQt7YSTO0NtqXhURyzIFgeSfuoVApIv5NsbDQKI7dwGSe3cqgzcJ4romPpGYO8i8ffEuFiTv3fPIlTXsUJR+enalbKV+rlIbEs1JLZoECDCS2I4pFo+drXXmAAU7dyEql2Gxi5FdMzJ3Sxiye6MLRqEI9uc4gto/UJVavp5UWzRIACLPCseJhUqNWJosugY0YtX32S+LZUaskKlNfWsUFROmlNq+6mGwtDcu5jNAYUDmOc8FsIKlVbptAuT5JC342zvBi7AxryUVODUQQiV2w2G2suiY6r2mW9LpYbC0RFDJFt7atdwcnuwSEexUKmRNZciOqa+uf3RIPL37luKmro6AKwtbaoz+rpFkd7Io5Xy+7LIo1gIK1QaamdnLPqgqskbn/m973mKdm5mWobVtfjgqy6PvXbNaYrhxAq3242f/vSn+OKLL3Dq1CmcOnUKFRUVaGtrw9atW/HCCy9g8OAYwomIhJHlZpOxIEBqzyK15sjqqv8BUbzMRnd/fXuXiaE9PViV51jhuU6ttfAf/MaYDPJQvHgs1oB2nYuW6iOhtlSxeosARa5T67YvIAisv6u214rJ0OoLwLtNbGfS9/z2hfZIuU6r0dbA2mUZ9STWNHkgdMQ1MdAyDAidD+/+FaG2VKUmC73IkeU6+cpXG5Oho/WzoQ2Adq6VXM7mmmOxF3qRk5oj5bm2bvuv5LXSjsQQr0cgCA/Xz1gKvcjhv+HwGngbTgIw7kmsbfZAiMcCWv7+XXMNpeew19m58u//GvA0MA8Hr18QC91D7dz8B742JIMiOqZDzkWbKIcx/WyqPc48XkA79TNbynP1bP1C8loZ2bT0BwW0cf0sO5fpeqxwA+/IOvgb2Ea40Q3cUy0dpJ8GvFaATD8PiG2p0gtD9QtiQSpU2gTf3hWK74gqQ7w3CwHFRohp/TxV2b7aNRxXhpTn6t0+F20+UT81ii/Ka8e0bv0vezKW2jVyZO3cgvVszaibniPqZ32rF0J7o5U48mtieM0l6ufBte2rXcMpHQlkdwN8zfDtXS5+h7G5JMLZEqu3HZCdiy9R09iq+J6ocohyNp6qbl/tGo4z5Kzxbf8CzTptHwFl7RhJP2OpXXOaEnMhtZycHJSUlMDpjHFXlUg4qU67pOxS2zCpernBYiPiDSrsWYCGZuZl1qr0CoQGgrQDfBe8nYONLNcps3yB+B3aEwDfGW5urG9foRc5/UK5Tu66fYbk4K/nHxM9qt3HxR7awxGviV0MB9br75rhciDVKd768VqsyXKdhjSvBWBkUmavDwzuh609hV7kSPq5CI3NzItndEJMP8BzymMo9CJH5sXLFHVeVwbx9aamxtjbUoXTj7dzK0d6/R72PQYNvIKKZYi50Es44u+wi+Fsev1dU50Oqf6EFOLe3nOR14tFDghBDGlk+qnnFeAbV4OEg7DVH2U7+rxSf6yIv0PYuwQNTayQmV5IYEg/+fjZTv2UefEy+PipsYiXy9DY1AghHtFKAFuspaQBdYeRcWq3KIexBXRBxXLm8So9g3nA2oMUmcJ0Tc9r5UqxS6kitnjpZ053saKzgCENzFjTGz/z0p2w2YABOALbqYPMI9qeaBBA4cVramwQ5TAWHZNZLo6f7YlWAhRevHRpfjc2btU3NUOItS1VOH1C7dyyTm0HYGCtI+nnivbVrpETlmuf7nIg3RU92kYeHWPfw/Oo23kuZIVKhzQa20jOSXPCYbehr60CtvbUrpEjK1Ta1FQPILQhGA0uZ+ZBcfxsT7QSoHA+pe1fKH6HsbSYhuYWCO2tXcPhhUqbTiC7dqsoh7G5pOD4ivbVrpHD11ziZoIrxY4sd/TzK68d45D084cRWg5Q9fIfFDabTRZiLhZTk8LLDXi6ASnXydZWjzHYCUDbqwqwAcmBAIoq4mRMyD6j9AQzDowONiO9m9pX6EVOajabmAEMb2I5jkYNvLKqFeyJeJwLcRc6vXIDClCvey54wZfutiq4qrfHL7RH/C0TfesA6E8AqU4HstwpmOYQW7vEWuhFTrcxQGYxbN5GjBHYQkkvTLMo0w07giiuiJMxIfuMkuNLwfTT2MJgtG8TiwbJ7ckWbO3BnSX1Lh7WaL1+plZuQhFO6eoFk8OFUtQg9eR3YNEgMRR6CUdcHJzlMxYdw40rST/7nm++LVU4paydm83XjLFBcaFkYNFoQxDFx7l+tnOxJvuM4uPLYEPQ8Pg5JvA9bL5m5ukpHdk+GVzpkpdkaKNBj7v4ep/qFeyJeJyLgT8CYEPqyS0oQY3uPQIw/SzCKaRVbpJ9RjsR77XxXr5pqS1HisOO/HQXptlF/exznvm2VOGUjGCRaP5WjPJ/J8phZOwSxLEOcdJPdi66VIj6aXDcGitsg83byDzlXUe3TwZZodKhDcb0k7/et2YFeyIu4+fFgM0Od9VWdEW14fGzEPVIO8HbpsVj/BT108M3LbXlsNttKMhwYTrXz/bUruF0GcJ6awc8GOVl956xayKg9Hj8159FFUthNzB+cq//WOyAjUcrdW9HtBKgKFQ6hOunzn3CI9361vAOGHE4FwOmAzYHXNU70MNWiaLM6G0fOYWZbuShAekn4hBNd5pBRvcPjFAFcz9rP+Nl3kDDnm6Zl2SafQPydLxWALvBxtj2INVXx8LCe8ZY6EWOmOuU03YMg2xHdAebnDQnUuy20AK6vd52jjhoTRAX8npeq6JMN7LRjL7N4mItHgsUMdfJJgRxvmOzwUnZjQv5ZNhzIpBR0H45xHNxru07uOGVdtu1KMiULRrjcS7sdmkAn2bfgKxUba8VwBYoI237kOatZcXHesXQliocMdcpy3MCQ22HdPUiOzUFLocd0xwb2ROxtKVSQ7wmZ3mNpmG4kYFW9G+WydFesrsC3cbABgFTHZt0F/Fcjqn8XPQYD2R2ab8c4rk42/Y9UuHR3SwEOkg/B4X0U89rBbBzMcJ2ABmeKubZ4EWN2oPoJcn0nMRwW7muXmS4U5DmdMjORXzHT6OGZmGmG+low8Dm9Yr3t4usYql4oxn9vNAhjuHdxhqriaKHqF8TbduQgVbdSAxA1E/5nNZeZF68afYNcKfYQ1EnUSjMdGGYrRyZnkrmGe7TzmglQCpUmu6twSjbPt3xU9rAlfSzndEgHPGamNHPVHgwOJ76mVEI9GCFSi90bDSsnxc4NsEGgUVQxFq7Ro54Ls7ENmShxaB+ujtAP5kc0xwb4HRoFygF2LkYbDuM7LaK9teu4fSaBKTmIM13CqNte4xv4NplmyDtiQbh8GviMRZdWJjphhteDG0Rjd14XJP0fKl44zS7Uf104QLHZtiEINvoi7V2zWkIGd0/MBRGNw8td+eY2yGXDXqFBhauhfKBd2A7Q3s4slynafYNuoOe3W5Dlww7LrDH0dgFJANvpG0fuhjw4hVmuTDF/h1SEAAKBwKF/eIjB78m9g2GJ+Vpdm5YxSm0p3QkfJldkW7zYHrqTs3CN5xhqdUYaD+KoK2dhV7kiOfiQsdGdMnQT39R6OeAdhR6kSPLdZrm0NdPm82G4gyHTD/jdE0GXgwBNgyzHUApagzlRk62fwcnfO0r9BKObCFvdFNIYeDFg+Jh8GX1QJrNi+nu7bqbMQAwxF2LwfbDCNococJ07UX8PVMdG9ElQ38sLMySGVaxtqUKx5kqhXoa0U8A6JLpwFRHnPVzwEUQbHYMxkF0t1UZCrU/x/49XPAxj1eXIfGRw6x+ZnWAfhYNgi+nDG6bD1Od23Q3YwBggLsew+0HIcAeH28moNDP4owUQ14rST/7XdD+aBBAUah0mkFDsyjTiQsdcZ7TBkyDYHOgP46gl+2EIaPmbPs2uOER21K1o3aNnGQYP4sGwJfXFy5bAFNTvtcMIeb0T23ASPt+CO2tXSNH/D0X2DejS7rDgH7KNk7bW7uGI0txZPqpf02KMlJk+hmn9Wf/CyHYnSjDMfS1HdMfP7PcmGDfjjShtf21a+TIbQIj50Khn3E6F6cJZHT/wJBXMJeKqJndpe8zBX5HGrraajHWfVj3cMWgF8/cjcHyG11/Up7s3oscWwu87oL2FXqRk1WCtuIxAIAZrs1Ic+l5VWULlMFxHGzEgetc+1aUpAV0D++V1ooz7TvF98ZpMrTZUN2NLZQudm409JbJAvMInMgf175CL3LKzoEvJQPFtjqMdx/SPbww04Xpdu6ZiOM1GcxaJ06zbzDkFTgndR/ybE3wunIlz0a7yewCb1fmxbvYuVHXa1WQ4VLqZzy8mUDIi2ffjm5pfp2Dge5pbThL0s84jRk2G2p6TANgXD+ngHkEKnNHx6/QS+9z4HNmocjWgInuA7qHF2bIN8jiP2YY3aib5C5Hoa0BXmdOqAVbe8kogLcb0/WLUjYiO03HqyrfgIhXNAgg3asT7DvQPdWre3i3VB8m2rcp3ttubDbU9GDj5wyX0fGT6eeJ3FGxt6UKp+dEeF25yLc1YVLqft3DlRu4HaGf6w1t7o93laOLrQ6+lEzmKY8HaXnw9mBevOmOjbrRW0VZrvhHg/DPAjDevhPdUz26h3dN8+Nsrp9xvCa1PdjG4wzXRl1jFwDOCbJ5tTJnRPtr13B6jIfXnYdcWzMmp+3VPbwoq2PXXNPsG1BgYHP/TPdhlNpq4U9Jj0+0EgCk5sDXk0XmXejYqBu9VZARpp/xiAYBpDXkWNtu9Ept0T28OC2Ic+xbQ3L8gDB8xhsaGlQfgYD+Ap9IHrJS2eDQ1OYP5XMb6dEtx5mKIwVs0XVu8Fvdw8sCB9HTXgUPXPEJ7eEMuAgB2DHMfhDdUa17+PlgE8DRLlPiE9ojUtWdeYwuMrCQL0wFpti3AACEgXEcbLoMRrWzG9w2H8tb12Gs91s4bAKOp/ZjHqM4UV40BQAwKbAeCOqPDePaWNGgXbkx9u5UI8WNowVsIposrNM9vFfwKMrslfDC2f5CRHL6T0MAdgy2H0Z3VOoefp64AXG0aHJ8okFEqqSNkE26C6WidBvOF/UzOCCO+lk4ACddPeC2+THau0H38DHeDXDaAjiR2qf9hV5kHCycAgCYFNgABPSN/zGtLGxvZ26cFkkA4HDiSCH7PL7ppEVP4Sj624/BhzhGgwBA/wvhhwMD7MfQQ6jQPZwbeEeLzom9LZUK1d1F/UzR18/CNDsusG8GAPgHxMmzCwAFfVHp7g2nLYAxBvRztHcDXLYATrp7Iea2VCoc4uNncCMQ8OkeP0YcP3fkxHH8dKTgaBHTz/ME/fm9O45jkP0IArCzSKF40W8qfEhBH/sJ9BSO6h4u6WfhOfGJVhKp6R4aP7XaPgJAYbpDSovx9o+jfuaX4XhqX6TYghjn1b8mI70b4bb5UOXqxoplxYnDXVh04URhE+DXN/5Ht4r6mR1H/bQ7cFS8T84zMH52QxWG2g+J+hnHtlT9LoAHLvS2V6J3UN/5dK6on0fyJ7W/do2MWnGj7kcpm5Cil+op87bHVT9ze6IibQAcNgHjfEb0cxPSbF5UO0uB4qHxk+M0wLDRnZubi7y8vIhHWloaBg4ciHfffbcj5STiBPd0NbT5gEbeLsx8Pto2cRAd3bJa99gysejNesfI9hd6kZNRiM1g4a/dq5ZrHysIGCsuUOK6gAZQXsBy2EYHtrKWKRoUVn2DTFsbjgv5qM+L42Bjs+HbVNYGY1DdV7qHD6lnhTc2psUhv17GXvcw1AkZyA7WA0d0DN6mk+jVwnbjN7rb0cJDhZB+rtE9tlc105319hHta0sVTno+NtpY+GvPkyu0jxUEaQG9M54LaADlhaJ+BrcBrac0jy2oXo9sWwuqhBycyo9TaCQA2GzYEIN+bkiNr37uSx2KGiELWUIjcHit9sHN1ejV/D0AYH2c9ZMvQse2rmY9HDXoVcWK3mywDWtfW6pw0nLZZwLoxQvnRUMQMFZcQG+P5wIawCFRP0cKO4CWWs1j86o3INfWjBohC7V5cQqNFOG6NrhBXz8Hi/q5PjW+enHAPQRVQjYyhGbg4Crtg1tq0btxC5PDHafIGJGd2WyOHNO6Rlc/+di2wTY0ftFKAJCazcZkAL315neIsgLYnh2HmhwyDokbdWcIu4CmKs1js6s2Id/WhFNCJqrz21nILYyNaczRwYtmaTFYHGPXuyfGz9sOoNw1EJVCLtKFVqBcR47WOvRuZAbeOld875OdOUw/xxrQzx4nme5swuD4tqVyZWC94wwAQFm1vn7ytfK2OI+fh0X9HIE9IUdaFLKqt6DI1oAGIR2Vee0s5BbGJnEtOaReZ9wCMFDSzwlx1c/TAcNG9/Lly7Fs2bKIxyeffIJrr70WDz30EGbPnt2RshJxIFMRXi7mdMdQBGZ9ylj4BAeK2w4ANdohaIXHWAuP+b74TkK+QBDzfSy0O//wYu2Dj29Bnr8KzYIb3znPiKsch2zdsC/YFU74gb3acrj2zQcALA6MQXWzvifDDMvAwoi7VX2l7SXxtqB7LTM4VtrjFGYvUt0qYGlQXAzzfpTR2D0fNgjYEuyDcl8cjQkAG5xj4BUcKPIcAqr2aB5beJRdsy99YyDoTOBmCAQFfOkV9fOojn6e2Ip83wm0Ci5sccX3PjmCUuwK9oADQWDPIs1jU8QWHkw/9T3BZlgGpmvdqr8G/BohvL42dKtmC5TltnFxlaG6JYClAfH86unnngWwI4htwd7Y742jMQFgo3M0PIITBd5jQNUuzWMLRN2Z7x8dV/0MBgV8KY7JBUd09PPkThR4j6FNcGKTM776eVTogu3BXqJ+LtA81iG2nVsSGIOqlvjq53Ib189VgK8t+oF+DxtjAaxAnPWz2Y8lATZm6Orn3kWwI4CdwZ7Y641TaLnIZtcotAouFPiOA5XbNY/l+vmldzQCwfjppyAImO8V9fPoEu2Dq/agyHMYHiEFG5zxNSaOCQX4PlgGOwRgz3zNY3lbxKXB0ahuiW8U6EpxLOxWswbwtUY/MOBDV1E/l8VbP1t8WCzp51ztg/ctgUPwY0+wG3b741AIU8YW10i0CG7k+U8Cx7/TPDbvCJ/fR8MXCMZVDr7+LDymo5/V+9Cl7SB8ggPrnWPiKkNFMBebg2JtIFH/omETx5SlwVGobo3vuVghriW7164FvM3RDwz40e0k20heGmf9PB0wbHRPnjxZ9XH55Zfjqaeewp/+9Ce89tprHSkrEQeknG55IbUYPN1HWl34Jii23NK60esOw121DQHBhvnekWjxxm+hVNPkxaIgG8BSjq7V9pKIg82K4Bmo1E85MUVVkxeLgmMV36NKMAjsYudqUXAsqhr1cwfNsKq1DNVCNpzeeuCQhof3wHI4Am04KhRiQ1scqprKqG7yYlGAn4u52rvQ4rlaFBiL6jifi2OtLqwNipEEuzWuSf0xuCu3ICjYsNA3Co2e+OlnbbMXi8QFivPYOqBZIwVCPBdfBUegoiW+O7/VTR7pPtFcKIXpZ3WTfvigGda09UaVkIMUXxNwUMNLUr4SKYEWVAj5WN/WM64ysHMhu1cN6mdNc3z1s6LVgVVBsSWc1jVpPAHnceYtWuAbg/rW+G3U1bX6sMjPjBrn8Q1Ao0YKhHguvg4Ox/GW+KXmAEBVk0c2Zmjcq4IQuibBMahuiu81WdfWA8eFfKT4W4ByDW/3wa+R4m9GpZCLtW294ypDTbPXhH4yvVkUHIvqOOvn8RY7vg4OD8kRjaYqOI+xcNJFgbE41RI/ORra/FjgH42gYIO7cnOoBo0a4rlYExyKY63xS80BxDHDsH6K1yQwJu7j5/q27jgqFCIl0AocWBH9wIOr4PQ1okrIxup466d8rbP7SzZnREOun3E+F5UtNqwMipFYWtekpRbOo8zBsDg4FrVxvE+aPX7M945EQLDBffJ7oF4jBUJcg6wNDsHR1jgUwpQRm36Ojfv4uamtKw4Hi+AIeoD9y6IfeHgtnN461AhZ+Lo1fqljpwtxK6Q2efJk7Nu3L14fR3QQvOJkk6d9Rne1UUNTXMRvxCDUIhs1cbzRq5s8OCIUYw96wSYEgD0LNeSQGXhxngBq5IPe3sXRc52ObQCaT6LZloF1wcGoaY6fHMGggKqWAJYY8eIpzkV8B96aJg++Co6A3+4GTh0ETu5QP9DTKC0c2KIxvtckwriKhrhhtAUDUI2cuOtnBQqxE31YawwtL57cwIuzfiom5X1Lo3tJjm8GGivQakvDmuDQuN4ngiCgutkv85Jo6adsYRBnY6KmyYuvg8Phs6cC9YeBE1vVD/Q2SwuHRcGOuCYGx08xGuR79MdJ5MX1mtQ0eXACBdiGvqy1kJYXT7aAjue4BYTdq/uWAt4ou6LHvwMajqLN5saq4PC4XhNBEFDVbNCLJ16vxYExONnsi2v0QXWTB2uCQ+FzpLH0r4rN6gf6Wtm5QseMGVWK8VPjXOxh+rkDfXAcBXEfP6uQi+8h5sxrbe5LmzEdNL/zc7F/OeBpUj+wcjtQdwgemxtfBUfEfW6tNqmfSwJjUNUcQDCO0Qc1TR6sDQ6F15EJNFUCx6LUsfF7pKg/pp9xPhdGDc09C2ATgtiNMhwViuKqG9VNHtQiW0px5GtdVWT62TH3qqgXB1ayVsCqB+4Gag/AB6eon3G+T5p9Bm0C0dseGI2qFn9co2NOB+JmdNfX1yMnJ74hokT8UbQMa0d4eU2TJxQGd/ib6LlO4uTwjZPlnFXF8Ubnn7We531Gm4hq9gMndyBoS8Hy4Mi4e1Wrmzz4TuiDFncR4G2Mnuskyrc98yz4kILqxvidi7pWHwJBQd9LEvADu9nielFwLBo9frT54hcGV93kQStSUVvMr0mUwXffUiDggTenDPuEbh0yKUsLlKPro+c6ifJ9I+bsxntSBoBveT5wtHNx6iBQuRWCzc7CvjrgXGwTytDsLgZ8zWxiVkOUb2fmWfDCiao46mdDmx/eQFDfSxIMKPSzxRuIe3SMBy7UlIh5ddGuyf5lgL8Nvuye2CX06JBrsjQwmrXSqdgc3UsiyrfOJY6fcRy7+Pgp5VtGOxf1R4HjW5h+BkZ3wLnwYqfQE42pXQF/K3AgSn6kKN/ujPHwwBXXe7XZG0CbL1w/VcbFsGgQrz8Y1+iY6iYPPHDhZLGOfh5YAfha4M/qhu1CL1Q3eeJu/C8NjIJgswMnvgfqohSK4vrZEeOnOP58I+p+1HPRcBw4tgECbFjSAR7m6iYv9gjdUZ/WHQh4gP1L1Q8U5dubOQ5tcMdVjjZfAE0ev0w/56vrpyIaZCz8QSGu0THVTV74kIJKafyMsuYq/wrwNiGQWYqtQhlqmrxx189lwVEQbA7g5HagNkoXCPFc8Ho38Ry7+PUN6WeUc9FYCRxh0SBLOmL8bPRiv9ANp9J6AUEfsC9KqpAo376ssWhGWlzXn15/EPWtvtBGyO756oVKw/QzKCCu0TGnA3Exun0+H/74xz9i/Pjx8fg4ogPJlKqXe9hOJcD69ZlAEARUN3lxHAXwdjkDiOYlaamVwpy3icVN4nmjc0NNKjwVzUsi7pC3dJ2ABmR2gKfGCwF2VHcVK1+rDb6CAOxkz5cXTJHeFy/47uk210jAmQE0HFXPdTryDdBaCyEtD9/ZWHpAPENn+Wc19xGrhEabiMSBl1XItqG+1QevPz45Rkw/PTiJPHiKRc+/mpektU4Kc96R1XH6KVUW3r9MPddJXMS3lo5HHbI6ZNEI2HCy21Tx+7SvyQGxMGA89YL/pu+dZwCuTBZlo+bFO7oeaK6CkJqD7x2sCF08N8l4REVTmdhzO9pCXtLPHwGwoSnOm1M1TV5UIweeUtkiJZy2BqCcbZBsFwtbxXPs4uOPVBjtwAoWgRKOqJ9tJeNQi+y43iMAH7tsqOzK9VP7mhwUKxd3xPj5vWMY4M4BmquAoypVzCs2AU0nAHc2vk8ZIb43nnKI42cZHz+jnQt2D7MOGDa0+YJo8cZXP08hG62lYs0PNS+ep4l5fgHsEPUzrpEYzWH6Wf4VG7PDEcd2T8loVCG3QzZwARsqS/X0k10TST/jOW6J53WLbQiE1FygpUa9UGkFi1aCMwNbXax2TXzHDPZZjb2N6uePIMAObyDem1Ne1CMTLV25wauin94WKRpklzgHx3Ps4uPPtixRPw+uUi9Uumc+AAGe4pE4gQJUxXmDjF/fEwbHz0NF54nvi+e6j8nwnW0ghPQCoK0OOKyS4nhiK4swc6Zjm5vV/on3eifZMWx0X3nllaqPCy64AD169MCKFSvw+9//viNlJeIAz+lOaakGhABgswMZRaY+g3utAMDG+x6q3eh7FrLvKB6GYE4vAB2z09iSNwTI6SF6SVZEHijKJgxkvQRrm71xDWnhcrT2EyciNS9e9R6gdj/gcKG2NP4LFO61ysrKCrW9Ursm4nO2ARcjNzONydEBhqZt4MVMt45/B9QdUR4U8EmpAK5hl8IhtmGJV74V91oBgG2w2PZK7VzsXQwE/UDRYPhyywB0jKe7NXcga8vmb1PPdeL6KfarrGvxxbXgi3Sf8I0QNS9J9T5W0MvuxKluU9hT8VygiJ+Vk5UZanulZvyLz9kGXITcTNbpIJ7RMVwO+8DpgM0BVG5lkQZyZNEgrmGXwiW2YYnXIoV7rQCEepSqnYt9S4CAFyjoD29eX4X88YB/lievP5Dfl33XPpWCQFw2UdaOiI4BwvQz3EtSe4B5tGwO1HY7TyF/PGXIyUoPtb3S0E/0vxA5WRmK98YDSccGXAjYU4CqnZGFSmXRIClDLkGqU9TPOM2t3GsFABiooZ/7WbQS8srQljcAAOIaHcPPqy+3L1A4kI3VqvopzmniWiTe0TH8N0kbyXsWRBYqrTvMIgJsdpzqdr5C/njA1015mWlsbgU053f0n4rsrCxR/vhvqqPfVMDuBGr2RhYqlUWDpAy5RIqujNf96g8EJe+o1HZV7VwcWM7WhLk90ZLHHAwdMb/7c3oDXYayta5aoVJRNrvY17sjomMAoJlvJO9ZFJniWH+MbRjChtpubH0Y33mVXY/czDTYBhjQz77nIysrW/HeHwqGje6cnBzVx7Bhw/D4449j165d6NevX0fKSsQBntOd2iZ6uTOLTfcE5jd5ljsFzqGXsifVcp1ki7WCDLfivfGAD+IFWW7Z4jXsRm+qYuHvANKGXQKbDQgK8TPw5HI4+04G3NnquU78XPSZguxcVgm5Iyblwkw3MCjKRoiskAYGzUBBpiuucsiNifwuXYEe4i50uJf54CrAUw9kdIG9xzjkZ8RXDn490pwOuIZexp5Uy3VSnAumn1Vx3BTik1phVmr0a9JcI+0Ip8k2IOKaGymeD1efs1nLqZZqKdxNghebKzsH2bkF7H0doJ8FGS5t/dwZeU3iJYfXH0RDG9PPvIISoBdPgQjTz8Nr2E59egFsPc6S7pN45eLxRbzLYYebj59qXhJ+fgbNYPc1OmbTko0ZUcbP1lNS66pU2QZER+iGq88EIC0faK1lETly+DXqPQmZuWyTOK6pSo1cP93KjZBwj5TaNekAYyK/oBjofbbyOzlH1jFPZ2oubL0mhebWOHk0udcqxW5D6jBRPw+tiSxUKjsXBR2hn3x+z3RF35xqq5eK3rmGXiptQMTXy8w+y9lrPJBeyL7zUFirVK6fPSciM79YfF/81zqFWUb18xIUxnnNFQwK0rqpoKAQ6DM5JIccsXYN3DlAr7ND42ec1ly1zV4IAmC3AWnDRf08opLiKDsX8Z5LgJCOFWVp6Kesdo1z6KXIcDnE98ZfDmfPcWw9722MLFTK12A9xiOzsGv8ZRDPq3L8VElxlOtnB1yT0wHDRvfs2bNVH6+88gp+8YtfUD73aQJvGZbuEQeoWIqoySeAokFAfp/IXCdZaA8GzUBhVnwNK/lnKRaNu79UeknE0B50HYWU/J7IT4+vHK3eAJrFsL7C3KzoXjyVxVo8DTzFNRkwjXnxwnOdKrexHfmUNKDv+XEf9PjnuBx2trkTbSLi52LgxYDdIckRr0lZ0ossF1A0ACjoH5nr5GsLeU0URk38J8NC+aQc7sXbswAQgsD/Z+/N46Sorvbxp3qfrWeBYQYEBURlUURBDbiASkDFKImvGrO4vKivica4RL8/ExU1qIlxwSTGJRo0xsQtLnFDkbgiorhFcY8gCMwwwzDTs/Zavz+qb9WtXqu7bt1bM9zn8+HDTHd115mqU+fec85zzmneB56GscwDENFEUnc0h9dWA3vmof3zdPD2+LaWJWn/DGj/wjio7VNgx3rAGwR2PxKNjINCZMPo8yiorfDnd/7J73seDXh9zINTxrUIQBk+AWicpGXx6HGDiRjwRTpr4tAGxWw/09fi8xfM49w+f0HL4IyYAmXYeOpasNEN2tEcHq7SbAKQ/55MPFazcQxl0L6LuhYT5gLegGY72z4zDmr7XGMsefzAhG9jOGv97NOcCUUB6isLBKdo++n1GdeD0Saa2K1h1QF4ho0DmvZJZ/GeNw5Kxo3GkBOPRWMNe/1syxVIzmxU+sUKzbYP3wvK8D2otZWNHMmUio50EKKxtrKAfhrBQsef1d2PAHyh7Eal2/+rMSM8PmCPbzPfc5G+MQDRzzyBOnIt9pwH+ALG+s4qaJn+noaqALz1uwIj99XWULpRKcVW0vafnIKWmY1KCVupYXegcS/mcqiqqgfJhocrgDSbM7/9XMDcbgF0giEI7H444K8EujZp7A+CdO8aKF5gz/nUtZBOd168+eab+NWvfoVLLrkEy5cXnqcp4U7UpGu6w/H0+KIyO5cD2qYRipLb+H71skbtqR0DNE91aCGiFuVdZwGhunSWhKp1ooyNfixDOXRH05fpaFLXIrIlnflWgD2PZp4hoeVorA4CFfVUloTK4lHUHgQqmTtXJDs7rDoARVGAiekFYMMqI0tCNdIgG6nhjDOJJr0Act+TdKMX1IwCRu1nOHgO3JPh1UFgzEFArlqnrGvBdtNI7onhaOaIQlONXrDXMc5uGmsCWrZ9XI5GUWSztvvhQLCa2qyxDcY0VAXg8VD6ufENjXEAZOindq0Mlg4rOUgwJlM/qUDIhteAaETLXOwy3Vn7WRMERs8AqkZoDJSvXzcOyqCWs7ZddNbKvJGnsng9bUbme69jNBsHZ/SzsSYABGuA8XMMOQgIG2T8bCAUZh48JXreUBnQGC/Ewdu0BujZpv2cwVYCgOFVbDOJJrtFncd0Lb5epWV8K4cDYw50ZCPfTm/kR+2n7VViPeZxbg6v7zv6YiCVaA2ZLB2in1TvGkw8xuGgZQAIVGlrOJGDgPw89hCgop75tSDrc22FHwGfx3DwNq81mvJmsJWANLsJ7PcZhn7mCE6le9egogEY8y3nAyEj9wXCo7MbldL6qSjM5ejqjyOe1PTQzCKjShyp3jWYuICynw7pp78ij36m96K7zQIqGyibIenlOfHoo4/i4IMPxq233oq7774bCxYswI033uikbBIOgNTX1CfTTncZncuzF2WSJaFqnfIaGwce9JqgRpHPjEJTjV50p4Zx9Jd2dhVFASZ8O7vWSaf2HAjUNOlGb3svu4YaJqMH5F6I8mygWdXhkYgryYahYbxR60SydqTRS6AaGKfVtpNFmbVzla2fVK0TfS0o/XSieVhjdRDweLP1M9Zn1Hjr98SZazGsOu1o7n6klknesR7Y9ol2EGGD7DIdCI/SnUGWHWctBUIc3kCTe0uohqjbFWieas6StPxHi9D7KzXnH6Do5Q47NV+8qDEwACqbeQzg8eh6wZIds52WI5d+UmOpsvSTEZXZyFoFNUdz/OEaE6dzo8bMAQw2yMh9gbox+nXr6I0xG4eU39HkqJ9U0BIAUDtaczahGlm7bR9rGSNfSN/YMi9/yHct6Eal+dhKDqzvjdUBwEM5ecR2U2OpMoOWrO9JfaUffq9HC7j4q4DIZmDr+9pBeu+afYD6sboMO/piSDDqzZHfflKBkDwBXFZU+/ZM/axpBkYfoP1M9jhU7xpMmJs+3pngada1+O+/jRLHTDaIAw6eSQ5T8onoZ8yo8XYswaB9T03Ih5DfqwWzAzVas8ct72oHUb1rMGx3/bqxbF5L7m1joUBIPv2Ume7cuP7663HWWWehq6sLO3bswJIlS3Ddddc5KZuEAyCN1EYgXT9YRqZ7e6bRG32A1oyN1DolE4YRdmiDQn+X4WhmZElIo5eG8RoNHs4tRLoMoXB2rVPmZi3t+A/EUzo1nZ0cxOilNyik1mnH11rnSMWjU4xZZyeyZACyFyJyLSbMBfwhAGBeb5W1KO8y3VzrlEpm66cDVKe8zj/Jkvz333qjFzTtDQDMs3hZMgSrdWdSvxdZmV1NL2LJFCL9bBq+ZMlBNtBknFvXN+lu5hobRDvWmVp//VkFsjcHNBvEXwHAuCfMNkqZcozaT2NcxHu1buWpFKWfJFjoBDsmw3ZlZkm+ekWTKTxac3hB23GH7GegMrsRZMZmjWz6kykVnYzGIemlIEQ/9zwagKJtXLs2azr6zdvae2ndZX1PdJpoTvuZQz8DWiM31vXUWc9q8z5A7a5Go9KcbCUe9pNci7R+rn9Ns+k1I9PBiTRTASzX9wwZ/BU59NMczG6oCsCjaJepg9E4pKxAyJ5HmRuV9mwzGH57HW06ll3Q0op+Gr1rEKxJH+9ceQ4AYMRkrVFpMqqtqbnYII4yLTP2n6RR6ddG7xqMnmGSg1XwlPSi0J1dXzC7xDHjWtRW+OEjvWMYBU+znpM956cblX4EdKw39a4he1MnGEuDAZad7s8++wy/+MUv4PVqjQAuvvhidHd3Y9u2bY4JJ8EeQZ8Hfq+CZiVN9y3D6W7LjHhmZkk2rdGoPaE6jfYNejFk84AlqaYeusEhtU6dXwOt67Ky7QCYN3TLMjbkfIB2/v5Ogw6X3qBUBnyoZNxQw8hopuWoHQ2MnGZk8cgmftdZQJXWKKuRymiygJ6pqcpxLUitU8ZmTZOZbRTalCEBMrIkz2ijgHrbtEYvaRo+a9psKqVmZ67GzzHXOtHXIq2fTtVn5g2EUI1eyD0J+b16w0VWNPes5yQ8SguGkCweyeTt+i2gWmuUZVwLRvpJmBhVtNNNZUlifQX1kxULgnyPfi0ysyRb3tNGqgVqdBo+3RSJBftAVdXsjfy4w9Lj3LYAW9/LYoMAxj1hxY4xAhD59LMniw3i93pQV6mVSTlmx2uaNGYSoNlOYj9HH6Bl+OAErTuDiQEYekjGuWVsoAGKKcRKPzOdicwSsq3va5lef5UeYHaEHZNpu8YeqjUq7d2mUZrJtUizQQBe6zsVqMvoXQMAXo9i9OZg5fzTTeUAoGo4sOtM7efPnk3bT613DWpHp2VOy+CUXgDGtVj/qpZ0yQjgArR+OhTcVxTzPaF714zXAsxkr8OUHdOdsefaLV3iSBqVZrBBaJm57T8zetcAgMcJ/aTLxwCgssFoVPrZs1TvmqlakoE6VjrdedDX14dwOKz/HggEEAqF0NPTU+BThXH99dfjgAMOQE1NDUaMGIGFCxfis88+Mx0zMDCAc889F8OGDUN1dTVOOOEEtLa2mo7ZuHEjFixYgMrKSowYMQKXXHIJEglzhubll1/G/vvvj2AwiAkTJuDee+8tW+7BDEVRUB30oUlJZ7pZ0MsBs9HTF8Oj9c7o5NjIQALRhP3sLqm1UhToBsRU6/TxE6ZGLwTGg852MTRdC7rW6b3709SeicCw3Q05HKLB5c3i5VgMnVsAKBn0Wqc+4O17TI1eMuVgtijrDcxy6eezwCf/0n7ecz7g9Ztk7o0l0c+AfRAZiCORXtz1jRKdJfn4SWO2vemeMM4K5MpOkCze1veBd+5Lj6WaAAzf05BD30QzLsOoyeHw0jbDQf3MqgUEgKYpQN1uWhZv7V+0DVu60QsB6418lrMLmLMknzyp/bzHt7XMBQy7FU2wYcd0RxM6tZBsSOEP6ZRQfPwvUyMiAueyZ5RekCxey4fAO/emx1KN1TJamXIwyzLnsp+0fuawn4zZMUYHYEoGulHpO/dpmU2KrQQY9491ADe3fj6r2S5As2VpNghrdkxfLIH+9Fg63Y77AsAe87SfP/lXFltJk5lx+QPdoJRAb1T6sWYzEv0aE6B5H0oOZ0pjGvMFpwrpJ+vAPh1UH76Htm6k4sC7fzX1rsmSg/WeqybHtfh8ObDuCe3nCUdqzBkYe8RkStUbN9rBQDypj/3S74nXbzyXnzxl1DCb9p+M7VamswtQjUo/B96+29S7RpeD6CfrPVdenyBHMJusq3JkWH7cfffd+P3vf6//SyQSuPfee02vlYJXXnkF5557Lt58802sWLEC8Xgc8+bNQ29vr37MhRdeiKeeegqPPPIIXnnlFWzZsgXf+9739PeTySQWLFiAWCyGN954A/fddx/uvfdeXHnllfox69evx4IFC3D44Yfj/fffxwUXXIAzzzwTzz//fEnyDhVUhyinu2ZUyZ/PuSiPo2qd3rlPe41aAEyUFgbGl8hQXxmAz0upMTnn6j9pkdeqRqPuCOwXw6wIH2CudXrperNcuhzsnKucWSv6nP/9tzHihNDO4YRTkxGNB8xZkpfS5ShjDwUq6ig5HK6ZBcy1TmuXaa9R96Q66EPQx24cEvmOcMiHoM9rvEEWnTfv0MYxpRu9EDCn79Id1AmqG7WMMmDcEyqbqcnBOjhVYFFe/4o+lkoPWFHHssu258gk0lkSci3SjV4ImDMxcm0axx6iMS9624C37tZeo/STNTuGfEd1MF0LSECuxVt/1jI2oTojYwFOJSmVDcBuB2s/6/p5bE79ZKYbOTfy6Wux4TWjORK9gWbt+OcKWuayn7vO1DKdaZDNK3OqKG0zdp2pNejs7wDW3KW9Rl2LkN+rl66xuCfEXoT8Hn3MknbO9LV4+y/aaM5gWFtP0mDNjsmiEAPmRqV57adT+4wcwf0Nq7SZ1IDpntD0XRbsg6yabgJdP9N7nXTvGgJdP50MWtKNSt+83SwXNHZMvc6Osa8bJAgS8HoQrqBG7pJzvnNvVu8aAMwncuS0n6Fa45z59JNLoC6tnxtXG5ONcgSFWPY2Ggyw7HTvuuuu+POf/4xbbrlF/9fc3Iz7779f/33p0qUlnXz58uU4/fTTMWXKFOy777649957sXHjRrzzjjbjuKurC/fccw9uvvlmHHHEEZg+fTqWLVuGN954A2++qXUzfeGFF/Dxxx/jb3/7G6ZNm4ajjz4av/71r3HbbbchFtMU8o477sC4ceNw0003YdKkSTjvvPPwP//zP7jllltKkneooCGQQp2SDmykqXKlIGfWyh8C9khnSeK9pkYvgJZhZzl6Rx9rUpWxAJAsSTz991HUHsCJmtkclGrAMC5Ejgynm+Vc6JxZKwAYMQmoH6dlSdSU3ujFkEG7djv64ogzaPiSRZslKHYtHKIEmnSDrnWK92rNxEjWGZp+snTy2nJl2wEtU6N4zfrpNRZtx+rbi+rnsaa3WW4ae6NG1srk8A7fU8uwJ2MaG2TE5Aw2iHb/ugcSGIjbz+625woKAZavBeus/3BaP71+I7se79UyFRQbhJaDTVAozwZ6j29rTBRyLfY8SmeDmGVwMAABWLafLOSgs1am52TY7lqmOZVIj6XaU8vspcGaHZOTiQEY+pj3WjAOWuYKkHl9RvYy3ptmg8wzfY6lfrbpNjzdoJSAjHMj12KPeVoG3AEZ6O8p956wkCOeTKGzL54tR8M4rReImkyPpTJ619AyRBMp9ETtsw+yevkQFLkWzAO4uWwXXeIY781ig2jHM7SfFN3frJ9Hantfci2o3jVmGdgmGErdf7K8J4lkSu9dYLondKPSxIDGKGuaor9N9mfxpIouRr05BgMsO90bNmzA+vXrC/776quvin9RAXR1dQEAGhq0LMM777yDeDyOuXPn6sdMnDgRu+66K1avXg0AWL16NfbZZx80NRmRtfnz5yMSiWDdunX6MfR3kGPId+xs2NWvXeeEt0KLipWInIsyYN6sUo1eCNhuGvMsAHStU6ZMjGUAMuYT0qDPWzMKGLmf6W2WWZK8WSs6SwJkGd76Sq3hC2DMMLYlR65MImDUOhFQ2UzteGPTyCLiqW9e823kAVOjFwJ9IWJxT/LpZ2UDMPbg3DLRMjjJxADM96BqBLDLjAw52D+rWVmrIvpZW+GH36spKAv9zEllBowsiS6HWT9Zd8vOGhmmn5f6+8cdlmWbWepGXv2sqDNlDrP1kwPVHjDrZ+Uw7R5RYBk8Jd+RlbUCCuonc3ZMZnd9AtKolCCP/ezoi+lzlG3Jkde5ov7+9FgqGo7oZ+YzEgprrLpcMsEJdkwem0HbiIp6854DYBqcIuuZ16OgrsJvfjNTPykH0MSOYZjdzboWo/YHqqnkTcaei+gzq27ZxPlvLLT/3O1gE1sJ4GQ/A1V6HXmWTGBvPy2t71TvGgKW9rOjTxv7qCjauEMT6L8/g61Es2N2prFhJdHLnUQqlcIFF1yAgw8+GHvvrXXybWlpQSAQQF1dnenYpqYmtLS06MfQDjd5n7xX6JhIJIL+/v4sWaLRKCKRiOnfUMJobycAoC84wvQQWAGdtcoyOCRLAmQthvTxLB6wvIsyfW5/lXmBhmGctvew2UDnpAQCRq0ToC3QHvOjRmhGLCiBOSlwBCajZ74nWsOX9CaFoaOZxT6ga51G7Q/U7mJ6m+hFLJnSM07lwpS1yqmf6U1LAf1k0ZCoPd/GADDuCdXohaCRcvAc3UAP292okc2hn05kVYdXZ2StgIL6qSgKUxZE3kwincWjGr0QkHrARMp+RD6WSOnfkSXHhPQ4N6CgfrJgx+S1W/S5fSETG4Q+vpMROyav7arfzaiRzWAr0cezYB/QmbNs/aSdGvMGmjU7JqtZFgGdxWvaW8twUmioDEAh3bJt2i46a5Wln7sfodksIOta0MezLB9rLKSf1FgqAmI/WbFj8toM0qgU0GyH1xyscSJoOawqPfaRRgH9dEyOzGvh8RhBiIzeNQBQV+HXxgECtuupUyk1P6OONCoF+O0/C+lnRu8a+vi+WBJ9Mfvsg7Z8+hkeaQTSqd41hhzs19WGzFJPoGDQEtg5O5hbdrr//e9/Y/LkyTkd0K6uLkyZMgWvvvpq2YKce+65+Oijj/Dggw+W/R2scP3116O2tlb/N2bMGNEiMUWzR6vn7g0ML3JkNsgDVuH3oiqYkRWoqAcOuVDLlEw6LuuzTtDPchq9qd/X6mRnX2Ki9gAGDYfFBhowDHhO52r2/9Mo3Qedk/UWy9qzvI4VoNVXTfmudk2oRi+6HIyivymqm3xOOWadp83sPuySrLdCfq8+P97uhs2UtQpl6GeoFjj0Yk0/pyzM+ixT9kEh/dznRC0zctgv9EYvBA1V2gY6pdrfoGhyFLgnsy/VNvEH/STrLRKcanNaP3eZAex9ArDPScYmNoccdvVTVelu8jnkmHmudi1mX5r1VsBn6JLdIBn5fM6sVbBG04ndDgb2/l7WZ1nW4eXdrAHAPv+jyXDoL7LYSvWVAX0DzYYdU0A3Zv8/7Z5869yst5huoHM1wyQYtb/2vO59gvZzphyM7omqqgYTI5MqCmjXoGnvnPbT5/WgvpJNENeUtcoMngYqNf3cdaamIxlg6uDlY9MB2nq22yHAIRdpmW8K4Qqfzo5hGTzNq58jpmi2IwMs6bt52SCAFiSc+n3tmlC9a7LkYGAzjOkkOda0g36i7XVy2E9Tt2ybutHZH9eD0VnBKX+Fdv4x39LWkww4FUjOwuTjtT3GIReaetcAZnYMk+BUIds1+1ItsD7rvKy3WHYOL/iMNE0B9v2Bdk12/VbW206McnM7fMUP0bB06VKcddZZpg7mBLW1tfi///s/3HLLLTjssMNyfLowzjvvPDz99NN49dVXMXr0aP315uZmxGIxdHZ2mrLdra2taG5u1o956623TN9HupvTx2R2PG9tbUU4HEZFRUWWPJdddhkuuugi/fdIJDKkHO8R2A4A6PQNx8gSP6vXWuVyJgDgiMvzfnY4wxmaBRflqmHAoudzfo5soCMDCbT3RFGfawGxiIJZK0DbmOTYnNDHs41A5/hbPF7gxHvzfraxJohPW7ptLwBd1GKYtVkDNIf/p2/k/fyw6gB6oto9GTe8Ku9xxUBnzrKyVgBw+GV5P8t0Ieou4OBVNgD/uzzn58gGuqM3hvaeaG69sohEMqU77nk3r1O+m/OzLDPMBRdljwf4n7/k/awRCLGnn5GBBGLpzGzOTWPTZOAnqwrKodmMGCaMKF8OeuOalbUCtI1Sjo0rYNSAO35PKuqBM57N+TmygW7rjqKtO4qmcCjncVZQNFA36TvavxxwplQph14oCnDC3Xk/y2psWF8siYF4Wj9zyTFiYkH9HFal2Qy7dpzOWnlz6edhv9D+5QCX8jFAc2TOeCbn5wg7piUygPbuKHapy97fWQUdqMvNqDsmqxSFgGWALC8DAtD083t35v2s0aXanl4MxJN6XXjONa1xT+Anr+f9/LC0zbAbhCB6UVfphz8zqwpoju4hF+b8LMsu/236PclxLUJh4PSnc36OsGM2d/ajrSeKMQ2VOY+zAlVVCzPq9pxvmsJBg2Xn8LwUd0DTz+/envezwxmPEh4MsJzp/uCDD3DUUUflfX/evHl6AzSrUFUV5513Hh5//HH8+9//xrhxZtrU9OnT4ff7sXLlSv21zz77DBs3bsTMmVoNzcyZM/Hhhx+a5oWvWLEC4XAYkydP1o+hv4McQ74jE8FgEOFw2PRvKGFYSst07/CWnukuuBgWAUsqCYno5zQ2RcBqhAWRwedRUJuZtSomA6+oKyc5yLWorfAj4Cu9akWf5WlTjryNmSyAaR1erlFdluVgE5wiWStPrqxVEZAmiUzKH9J/R2OuRbkIWNF3iV5l9T0oUQ67Tk3BrFUxGWrYyACwek4czFoVk4HhBjovXdWKHIzYMQUZZBbAqnGXnfWdJTsmb/+FEuSwa7si/UUCdQXAdq9TgE1XBKyeE1O37kwGmRU5GDWjLJjZLSoDu6Bl3vp2K3Iwuie9sSSi6Rr5nA5vIRn0UjqHWSlFYAT3ZU13FlpbW+H353csfD4f2traSjr5ueeei7/97W/4+9//jpqaGrS0tKClpUWvs66trcWiRYtw0UUX4aWXXsI777yDM844AzNnzsS3vqVRFebNm4fJkyfjxz/+MT744AM8//zzuPzyy3HuueciGNRu6DnnnIOvvvoKl156KT799FP86U9/wsMPP4wLL8wdERvqqE+2AwDalfoiR2bD1qLsRCTcxkbe9gZFz2bmyVoVlIEd/czePWGzELVR16IcsHJ4Wegnk+7lhersLcrBSj8bqvJkrazI4DS93KoctoNC5d8PgKFT4wJnl/6OnDWzReVgY7uKZq0symC3+WLOWcxW5WDEjinKICsmB2v7KXBdBaiNvJ3nxKbtIvekJlR6oI7uD2K3d4wbbEbebt2W5WDTYb9gWWFRGdiXpDSWcU8aWdnPtAyVAS8qA6UFQsjzzaJ3jBvW98EEyyvdLrvsgo8++ijv+//5z38wcmRpZOXbb78dXV1dmDNnDkaOHKn/e+ihh/RjbrnlFhx77LE44YQTcNhhh6G5uRmPPfaY/r7X68XTTz8Nr9eLmTNn4kc/+hFOPfVUXHPNNfox48aNwzPPPIMVK1Zg3333xU033YS7774b8+fnpl4MdYTjWnCkFQ1FjsyGnayVMyPDxGXc845rsABCS+qJ2m/4YmdRZjXComA9YglysKrpLjUzocnAUj9Z3BNx+kkWw/54Er02m9vZuSesHDxjhny5+smIiUGCMWVdC/bsmHKuB+uNvJ3NWiyZQmRApH4ysp829ZNdJtFO1p99+YMd22U3eGrHmSDMomRKRafN3jEFyx+KgNU9Iet7uUEhfU2zmVm1Y7eYjgyzoRusSrcKlhUWAWm+mGLQfNFOwJBlSd9ggeXwyDHHHIMrrrgCRx11FEIhcx1Xf38/Fi9ejGOPze6eWAhWItShUAi33XYbbrvttrzH7Lbbbnj22dw1aARz5szBe++9V5J8QxXVMS3TvTUlKtNt7yE3NZ0pK/rLNjtRjgzhkA8BrwexZApt3fZqe+xlrRhlEvPN/bUsByt6ZPkZEj0Yw6ApUsFaqyIg14LZprGMAFlV0IcKvxf98STae6JlUV6z5SjfZth1JtqoWupyoG+UbG5Q7F0Ll7FjbD4ndrJWpPki6QNRankPDf1ZtaGftssfessPxgB0eY54plB7TxSqqpaVESVo0++JQKaQDf0M+DyorfCjqz+O9p5oyeU9ZjlYlI/Z1YvykxwAFdC2yT7IOy7MAuhsu139ZFGGIbIUxOf1oKEygO3p3jHl2D5DDvH6OZhgOdN9+eWXo6OjA3vuuSduuOEGPPnkk3jyySfx29/+FnvttRc6Ojrwq1/9yklZJVhAVREa0Orfv0nUlfxxFovyjr4YEjbGzXT1xxFPpmsB7WQnbC8A5VNWtYYabJrw2DN6pA6PTc1suY2/9E2j7Ui4ff2MDCRszRPtiSaMWisbcojcQAPsNgd5x+5YkYFZUMhmJrGGjfNvK2tVw4Yd0xdLoC9Gxj6Wbz9F2i3tc6wcTffoZ9n2k1GNpq2eA+nPDMRTun6Vg4F4Et0DecY+WpKDFTuGjX4KrbNnHFQv+1pUsdFPe1l/NuyYeDKFHX2kga4N+2mbam9XP9narvICIZJenhdNTU144403sPfee+Oyyy7Dd7/7XXz3u9/FL3/5S+y99954/fXXs2ZhS7gQfR3wprSHdWO89AZxdilXHjJP1MY4JCJDObVWAKhGamwWgHKMjUkOmw6vG9gHJANom37GzNEsXY7aCj98HjJupvx7Qv6GqoAXFYHS9ZNd+QObRdluYyR7zcNYb6DLZGK4IJNYE/TpTQrtBMnI3xD0efRRfaWAfSZR7KbRVnNQRt13220yhYYxcjTzzk23AMKO0b7Hhn6m1xK/t/QGpQC7LtXs9FMk+4CNfm63sa4CdHmOuABZyO9FTdre2dFPQsf2KNBH9ZUCZuUPNspzAHdk3Om9jt3eHIMFJXUvITTu9vZ2rFmzBm+++Sba29vx7LPPZnUel3ApurcCANrVMDqjpdNr7NCIvfS8RhsbeeIElOvsDmM0escNm0Y6a1XOPSEblI7eqK2GGu2FRmhYALOaxEJz04vA41GY0OCMWivBi6HNRZlF7RmdtbITCbfLjrHTTR5gWGdvo2ZWURQmY8PoIEhZTZFqSDCGlX7abR5WvhzxZAqdNrJW5BmJDCQQTZSf3bVtM1xQZw+wsV36WlJVnn6yrpkt/1rYd/6TprF65bNjemNJ9NtgH9ipHwZYru/i7wmxew1VwZIb6ALsg4XllBUCbMaGpVL0WL3ya7oH4in02tDPwYTSZ/sAqK+vxwEHHIADDzwQ9fWl1wVLCETa6d6m1utzF0uBnawV/TlbizIrwyuw0yvAhn5GDGa5WSsSBEmpQKcN9oHdmkR2VPvya2Y1ORjoJytnglmGuTw5GhlsoE2jZipK18/6SoodY0M3WGUSbc9Btun8s7Bddpr8Aezou8zKHxhk/b0epaysFc2OsaOftpkYbtFPBuwY2+sqq47y3eU7EwAbxlJHbwwpVRt3XE5dOM2OYWHHbdd099qbNuAG22WHTQewZMeI3+t09ceRIGMfy9CNygDFjtlJZnWX5XRLDGJEtgAAWtJOdynZTbtZK4DNg77d5qLMitJiJ2tFf87WAkBtksrJCvi9HtRX+m3Lsd3mAkAyPJ19ccTLzGias1Y2N412nG4bc3/pz23vtaefRgTaLvvAvoNX7qgZjR3D4J7Y6IYMGNei20Y9tSlrVXagzn7GyGCD2LOfdtkxduZj059rY7CBbqgqfewjwI4dw4qJ0R9Poi9WXr2q3awVwGp9Z6MXO/rittgx9plsLIKW2mfrKwPwlThWD9DYMSycfzsNSgHD7sYSKXSXOQ1Da1BqNzjFTj/LbT5G946xw46x/ZwwKN0i17G2wq8Hd8qXQzrdEkMR3S0ANKcbAHpLWKDtZq0ARtldRotyNJEqK9tvyMEoK8Aiq2qj+yTLhajc7tB1FX59lnS5GSM6a1VXZjdjppnusgMQ2jWMJ1V02Rg3Y7vngAtYKdpn7W8O7GYSwyEf/F57+mnKWpWRVQVY2U9794Rmx+yw05vDdtbKLfrJ0H6WqZ9VAS+C6U1vuUEyu1krgM21sMumI+wYwC47RnxNtxHYL7/7ORv7SYKW5clREfCiKt3fpFz9jAwkEEuW36CU/pxIm2HqHcMk4+6GZ9WOfrKh2w8WSKd7Z0O3lunermgzuntK6OJoN2ulfZbBQmQza0UvAOXKkUim9GZwtpvf2KDV2M1ameQo0+gNxJN69LrcmkQPXe9fphx2s1YA3XhG3GIY9HlRE7LX8CWVUg1KoMCsgN1aQFqOcrO7sURKD16Ue08URbFdK0o+V27WCmC0kbd5T3wmdkx514JN1oplANe+fpYbPDWtJWWuado0DHtyMMlaMQwKlaufLNgx9NjH8puHiXfwWMhBryW2glM2J0CQz1UHy2ugC9jf69CfLVcvFEVhJIe99Z0lA6LcfR/AZk0bTJBO986GiFbT3ekbDgA6XdwK3JIVsFvzpX3Wnhw7+uJQbWatiNGzU8fM8p6U2xiJ7jYbDpU/z9nurFmW18Je93J7DU60z9pbiDr74zr1t/ysFQv6GYPNms0NCsnGej3ldUMmsFvXbXezpn3WPjvGLi2R/qwbslYis0X0Z1msJSSYUZ4c9vSTZdbK3j2x1yhVk8Oe7eqLJTEQt6uf9uvsmTKFylzfu6i1xM68caOBbbn2k12ATPyaZu85GYgndZamyEy3nXFhLOUYTJBO986GdCO17kAjAKAnap2+ymbTaH8jb3c+If3ZchciPatqJ2vFYHQZ201jubRug3lQLgPCLEe594TBosyi+y5L/RSZtWLQ6dUN+ml0my2fAQHYzxgxuRYsuu+6wNEkn6uxkbVyQ9NDgLIZZbJj7NbtEuizum3bT8FBdZsd1AH7Y8OI/BV+L6rKaFAKmANk5fbmcMOzSvQzHPKVvZYALrGfLmEf2A2ekjUt4PWUneggdmt7TwypMntzsPAJGhlk/QcTpNO9syHtdPcHR2i/lpTpZkcxsrWRZ7Ao282esTS8dpqHMTF6Np1/u813CFhlEplEXZl037XznNjLTjBxJhg0D2MTCLFnM4zOu/b0026HfbuNF2kZhG8abY4NY9KLIv3Zvlj5zcNYXAu7NE27/QYIdKZQ2frJ4J4w7Q4tPihkZ00j66qd5mHtNjuoA/aDlnabqBlyiGeysZjI0eaCPjr0vq/sUs80Ay6RKr93DJM1rcb+nmswQTrdOxMSMaC3DQDQH9Kc7lIaiRm1VuI2KHStlR3napgeabS5ANhYDOnmYWUvRN0samrIYmhvASiXxkyg18yWSe12S1M5Y86suI0SiwxJOORDwGtv3Ay5FuV2egXsZwW2M7gW9OfLfk5sdqimP8tiZFijrY08G6qonWekKuBFyJ/WzzI3bCwCyXqwsFy7xcp+Mspoljv2EWDMjrGhn8Ns9gdpY+BMhPxefYyn3Yz7cBu6YZdRpweFGK3vZT8n3fb1gk1Q3b7tssuOYREICfiMLLn94JQN+2mzV8pgg3S6dyb0tGr/e/xA5TAA5Wa6GdR89ZZHaemNJRFNpGutGBjfsjfQDBZlj0exvTlww0bebkMPXY4aVpFw+3rR0Rcra9xMfyyJ3piWFRbp/NsdFwaYG76IrbO35+CxziSW/ZwwzFp19ccRS5Sun9FEEpEBe7WA9GdtO3g2ZGDZPIzJs2pzA23bftoNhDBhYthjxySSKeywOfYRMO6nSLulfd6m7epl4WiyYfWx0s/yew6w08/+eBK9ZbAPUikVHb32A8n22TGM9LPG7t5PPOt0sEE63TsT0tRy1IxEdUhr2FJO93I7xoY04kimVHSWQWkhMlQGvKgMlN+0y24dCbtF2eamkUnWyiULgO3u0PYX5YaqABQFUFXoHYVLkyFda+XzoKbMWkCAHf3MDhuEpRxuoIraYYPQnxd5LeyO1iMbXp/NpnJ2N40sslYAC91g2ZxpkDMxGAQg7LJjiE57FK3GvVwwC8aItp8MAiF2m3JuZ+R0D3PBPakK+lDhJ5NrSpdjR5829hGw11SOJb3cDlxhP206/oMN0unemRDRxoUhPBI1aae7lFojFkYv4PPom71yHnR2UVc29F37C1H5tbusslZ0NrOchi/GOBF31HTbca68HkXvRl9O5op2du00lSPXwm75A6s65nKe1TiVtWIxMqyjTHYM60yiSCaGXXYMbT9Z6GfZ9F0GATLt8+XLkaSyViyCQuWyY5gxMVzASjGPQypdDrKuNlQF9OBSObBf/sDGqbHznKiqyoQRQtbDctkx7QzGhWly2Ctj2+6Ce0L0qb7SD7+tpod2kz72ywoBe8FTVVWZNvrrsdE7ZjBBOt07E0yZbi0L1z1QTvdycRslZjKwqnNiZPTKaX5DZPB77WWtyN8QS6YQ6S+dcsW6JtF+9102AZlyas+Yy2D3WthuflN+cGoHo6wV2aCUy44xalUZZRJt1u6KZMewslt2R96wvhblyMEqa9VQFYDHBjuG6JNtJobdmlkX2C4WbCX686LXdzv2s6s/jngyPfbRxj0x9Y4pQze2MwhmA+bSwnLAXjfKD6qLtp8snF3t8+XvxXuiCT2II7p3zGCCdLp3JtBOd5r6apVeHjfVWonLMrPLkNhr+MKMvmuj8Qzt7NrJWoX8Xp0KXc5GnnlNYm/pGXc6a2X/nogPCtER6HLYB6yDU+V0qTayVkFbWSu/14O6yvLZMU501y81455Kqew28jZsBrPNGlUzK1Q/bThX5DN2s1Zej6I77eWwY8iaZpuVktbvjt6YPlfZKlhlrbTP27CfDCaTAEYJXPnsGPfoZzjkQ9BX3lg9IIMdUxZ7izRSY7PvK3dai5vuCSsZymXHsJhOQsthRy+qAl5UBMrXT603h/2pB4MF0unemRBJO93hkXrXQqvdy1llrQCbjiajRZk85L2xJPpjpVNaXJX1t+lMaN9R/kLEqiaRZGpiiVRJXfUBI2ulKPayVoDNhYiVfqbv6UA8pTdmK08OcTVfrDJnJjnKsBn0HHk7IHqVSKmIlMAQArSsVSJlP2sF2KPOsrJbZBNvlx1jpxcFYNfBYxMEob/Djv20m0kkZTEpVbOHpaCbUdaK/rw9/bSnF3TvmFKvhSYHo6y/nQCZ3nhxaOhnXYUfJPa6o8Rsd18sgT4GDUoBamxYOQEyBhNSAPvsGOZJH1v7Twb6yWDqwWCBdLp3JuiZ7lEUvdzahonOWnlsZK0Ae3UkhrGxtxhWB30I+MqjtJiyVswaAZXj4JEMCYtFubzNq9bNk83mtSLgRVWANDkp7XoYWasAfDayVgCbSLhdx6oy4EMluRYlLkTaWD3xNbMsGi9mylEqE4O+FnbvSdDnpUaslKefdrNWgE39ZNBBHUizY0I22DGMbJedGa+sAhCAvRpNspbY3UD7vB7UpxkhpdJWybNqN2sF2GPHsLonZnaMjeCpXQePRVCdxfpO7omtkhR7NsPjUdBQVZ4c5PkO+T36HqFcsAgk22Wl2GXHsCofs9UfhFGCgf4OSS+XGFrQne5mVAdLa6TGNmvFIrtr70FXFEXf5JS6AJiyVozqRMu5FqzogPR3lLpZiwwY18Juhhkov67byFqxy6raodqLXIgiAwnE0pQ1uw6vG+rf7MjRHTWuBZvgVJn6yWiTpMlg337adfDo7yhVjt5oAv1xNlkrJlRRhpnEUu1nX8y4FnaDQtp3lKefejNMwVlVts9JeXIMxJP6vsgVWX8WTLYym+zR18JuptuOHPRex04pHfkOwKb9FKifsUQKXf32x+oBdKZbHCsFsOf8DzZIp3tngapS9PJRVE23NZok26xV+Q86q7pI7TvKWwCIYait8OvZ8vJlsEP7YpO1siMHncGzey0AlN35lq2Dx4C+K9C5Ihvu6qAPIT+brEB5TZHYLcrl6id5Rlhk8AC36Gd5Dp5TcpR7T1hmrewFyATaTyqDV8lCP6vKY4SwzVqJ74lhRw5yfMDr0Zkt5cvAYH0XGCAjwRi/V7F9LQCqL0aJDd3cYLcAdh3U7chBmIVej4I6Gw10AXu9Y1j1VwLsOf+DDdLp3lkQjQDxXu3nmmadGmi1dtYtRs8NcrSxNLw2mt+wzFqV73SzM7z09whdlBk0t2ObcS/VwWPPStlRRvMblrrRWFOe869vkhgEQYDyO0S74VmlP8PmOSlv3CHLrBW5nt0DpY+bcWItKdnZJZ3LbTbD1OWgGtyVJAdDu2VnLrQzgZDy7aftrGr6fvTFkuiLldb7wA17HbofBhP9LDNg6ESyxZ5+ig8KDasK2C71JH9HtIw+Om6wn4MR0uneWdDdov0frAUCVbrTbbWmmymVxMZsalb1mQC1EJUoB6sZiYDW/EZRtOY3HSU2F3GiJrGtxPqi7QzvB0AtRCXKwVQvquzTI1k4V8PK1k82jW8ArUaedB4vVz9ZyGHQz8qUgUHpA2A/083UbtmpSWRCCSzXqWFnt8IVPvi9ZBySOEez3I08q3pZXY6q8jKJLLNWw9wSFCqbfcDOblUFvAiS3jElr2niew6wXt+HlVvTzXT/ySKozvI5KY9qz0I/bfXRYdSslf6OckekDiZIp3tnQWSL9n94JADo9PK+WNJShtWRWtUSR0MNxJN6NI5ppqbM6C8Lx0prfjN4KVf6DGRGmW67mUSWelHquBmWtVaA0YSn/GthfzH0UA1fSm2M5Ar6LsMAGS1H+T0H2OpnKeyYRDKld3JmSnMX+KwqimLYjLI38uLYMawmPxAYNd3iy3NKHQ3FsiknYLBjSr4nvezspzYOiex3yg2EsEwwiNMLwDx2UZQcOjsmWho7RlXpBrrig0LMAnVldjDfzvJZtcGOGWyQTvfOAmpGNwC9ezlgjWLO1OilH/JYImW5kRtgbPpZ1FoBduhnjI2ezewui5ruxjIDECwzZ/T3lLsoM8kwpzfxiZSqO9FWQDZrPo+CWpu1VgDK7szMsj6T/p5yaXBinRrGmUQXbBrLZcd09MWgqtrYRxZND4ndKZUdQ/TZ7riwTDnKrad2Q80sa/tZdtaKgTNRLjtmR58RRGLDCLG3pjGzn2XaLpb3pPygujNMtvIDZPblCFf4EEhPOCmFHRPpp5tyimPHsGTTaXLYY9QxHRkmM90SQwYZTnfQ59UbX3VbaKbG0rkK+b16pr2UB502vCzqi0hWoNzxFSKdGjprxbIrc6kNNQz6rkscPAYb+YDPozvNpchB9KKBQa0VYKfnAGv9LH1zQGetWI4Ma+8pjR3DnIlhOwBhXz9pdky5+ukVqJ+O2YwSnH9VVQ3dYKCfRoOo0tgxbQypzAAD+8nAmSiXHUPsS12lH36bYx+B8ssfWM1iJmgsw35qow7JPWHIjumLIVEC+8CpAG7JpSAMZ5YrilJWiSPZJ9YwaFAK2AjGMO9TUm7Qkj3TslR2zGCEdLp3Fuidy0fqL9UErTdTY00zKmcjz3KciFkGsUavnI1SRy/jrFVahoF4Cn0x65Qrlt08gfJrz9gHQkrvAsz+GbEbgBAnB521YqmfsWQKEYt9KAAHarqrDOeqFLjBdrlOP5llz0oPnnb1xxFPkrGP7OrbkyWzY9jM/SXQM4klUplZjgzT5ChdN5jrZ5nZMzc8Jz3RBKIJzflgEUgm7BhV1ZpiWgVr/bTbp0TkPWG9rpbLjmFuP/UZ7tbXtP5YEr3pfSILOeoq/HoguJypHIMJ0uneWZCR6QZgdDAvsollnbUCyjN6rOvfiNETSRWlv6c0B49t1qoq6EOFnzTUKOWeONW9vMysFfNFuZSgEGtnt9zmTIRqL44SSGSuZ5S1Cvm9epCwtI0S45ruMjbydNaKNSWwFNvF2m6VO26GZV0kUO4GWpOhJsQma1UuO0Z/Vll31y+7KZLIoLozZVvbS2THOBUUKmddrQx4URmwX0rn83rQUA47hnVNN8mqltjPp435nqv0a8G+VMnY65TCjnFsz1WGXgR9Hp21agc0O2aoU8yl072zIIfTTeq6i9VVs85aAXYj4Wxl6OqPI5YogXLF2vjqo3fEbaBNcpSyEPWydWrIolwKzciUtWLdXKQMeiTrCHRPiQ1fnBrjVt4GmqV+ln5P9JE3zLpDp5vwDCQQTVi7J3TWil1tpAvsZ9peDMRTetajNDnEO3isgiC0HKUET/Xu0Iyo9kS/ShlRxTprBZSXxXPKbpXOjmFdMyve2aW/qxxHk7XdipUwomogntSn7DCvYxa4ppG9dDKlorMEdgz74Gnp+sly7CPBzjI2TDrdOwty0MtJhKrY2DDWWSugvLFhrLNWtRV++AilxSIdT1VV9lHXMkZUObEo6+M8SnH+u9k6NfWVAZDE/Q6L2W46axX02c9aAUZtYzn3hNXGoCZoNHwprTZSfJ0oyxFZBOVQu8mxrO5JuMJn2AyLG7Z2xlkrwB47hpVeVAYodkwZtZHMg0JlPSPs9NPORp6VHNVBnz6iyrp+ss1aAeWu72z1onx2DFv7aVCqxWX9NTnEO//0iCqr+klYln6vgnAFK/0kex1x16Ls3jGsA8nl2C3GHdTp75L0conBj1QS6GnVfq4Zpb9cHdQe+GL0ckejriVsoFlv1jweuqGGNTl6ogk9K86u9qz0OjwnFuVSnauBeFJnSbBo9gIQmlFpi4AzWSvx9F1t3ExpjmZfLKHX5DOv+Sor6y8uUxNPptCZrl9ktYGmm/CU6tQ4wkpxCTvGqu1yMmtVkv1kTKcGSmdiJFMqOvrYZhJNI6osPidOZq1KCZA5spEv8Z7QNoM5vbwE/WTdDNMkh0WbQZcVMg2elvi80o0X2eln6QFcZ/bBpQVCknSpp8CSKZbjwgjKrXEfbJBO986A3jZATQKKB6hq1F8mY7d6ooWpLW6hijoTXSvtQSfORFXAi4oAo6xqWZFwB4xeifRyJyLQQOkLkaP6WVajFXGbRqJDLLNW9uoznXA0S9NPj6I1amEmR4mbaDfYLe1YtuUPtBxW2THbHbAZRlmMYPtZ4j3ZkR7hpijQ621ZoOSgEONu3YDd8gcnnJrSsqpej6JPCLCLxhLtFn2syHsSGYgjQUa4MQqqA4Z+WrUZTqyr5cxwb9M7qItjx3T0xpAiNoN1qWdZe3GxPsFghHS6dwZEtmj/VzcBXmOjo9d0W6SXs4x2llNH4kRGs9SxYaybZQHmTI3V5iIGrVvcokzXI7KKQAP0+J0SnRpHFsNSFiK29ZnlyOFk1qqjN6r3digGck9YNYii5bDaZZVcs4aqIJMRbgR6pkZkprsc++mCjbxut5hmrTQZdpQwDsmZ8pzS7sl2vWwrAB+jsi1aDuuZxLQzwWgTD7iHHTOsxNItIi+rsY+A8fdESugDwXKEmy5HTWk9B8j9CId8+nhZFtCb/Vle38Wzpuhjma7vpQbV0zKwtBlkv9UbS6LfYm8ORxIMZU6uGWyQTvfOgBxN1IBSarqdbOohbmSYJkeJWVUHInzE6MWT1sfNGM4Ve0fTsjPRy74uEii9A68zVGaXZHfLzfozfEZIRD2lQp8Nb1kOgdld1t1mdTmIU1Pi5tUtmUQnyjBK109294T0gVBVI1MpQg5yf63aLb3JH0PHCqBnyZcmh2vsJ8vnpET2lhM2vLbCD7+31D4QDgb3BeqF9n2lMTFYlxXS31WW/WSZcS/XfjJc02qCRlClVManMwEyWdMtMdiRx+muCaVruot0kXQya2X1IY8lUrpD6gglsFSqE0OjF/R5dap/yUbPDVkr5otyeTXdTizKbT3W2AeJZEqvzxRJPzMcK3Yy+L0e1FeW1vDFDTXdrMfIEZTakMhJ/dzeY23cTCqlOlSHJ/5aeKk+EFazeI7WzJbISmEdtHRDIISsq1bZMaqqOhIkK7d8jKUMiqKUnHF3Q/mDEwxHgLZdIu2n9jftsDglhR776IqgOkMZFEXRdcO6/XRHSd9ghHS6dwbk6FwO0PRyqzXd7LMCVkeb0LVWTtRnWqU6ObFZA2g6XmlRaCdG3ljOkPQ6k0l0g1NDAkyxRKroSD1AW7ydqM8stUs16xmemXKIpFSX2nNAp/s7tmkUFwghf1MipSJSxH4DQGd/XHd+mHbs1umR4lgp2veVaLtckN117lkttdEfezkaqgJQFOvsmMhAArEk2wal9HeJbMoJlJ5xd0Y/3Ra0LFU/2bJjvOnyASvsmL5YEgNx8frpHpshPgAxWCGd7p0B+TLdQdJIzVpNN8sHrCrgRcifprRY2LAZ9TTsaq0Ad9DP6O+zIodTWatS64ucp5+Jy06E/F69/MLK9dDrhxnXZ5Zb8yVSP01ZK4H0SL38gWENHkDRd0scacfynpTKjiHH1DEc+wjYyKoy1s9SGiPRWSsnqPZW2TFOOzXWA8ns5fB5PXojslL0syboQ8jPpkEpUD57i6XdMslRcnCKfU23VXaMU5nuYaU6/zqtm9090aakkIZu1vWzwu9FFaMGpUD57BiR6ztAs1+dYMfELPeOGYyQTvfOgCI13SJGhpkoVxY2BwYVT+xiaDiarLNn1h1Nx7JW6fvRHU1gIF68oYbRSM2hmu4S6zNZ64axebUeFGK+GJY4m5r1DE9djhIaI9FZK5a6Qe6vVXbMdsc2jaUGhRyyXSWwY+igJUuUOjvdCWfCLEfxe9JLZa2YNgctkR3juP0UmLXS5LCePTNKldhei1LZMUSPnbonVvY6A/GknghxojdHImWtd4zRc8Alaxrr4GkJcjhRggGUM2nAWfaWlaBlLJFCJO0zsLwnpbJjBiuk070zIA+9vIbQywtsEJzKWtHfZymT6MDYHe37xNdameWwvgCwzlqFK3wIeK031HAsEFJCQyKnslZAaQuRU4tyqXVOTnR61b7POiXQqaxVqewYJ0owACM4VXrzRXG2yzG7VfJIO/ZZK6BE+9ntTNaqXHaMcz0xxGWtSpXD8XW15J4tDtHLLchBApsBn0dnI7JAuewY5nZLX99L3HMx1s9S2DFtjq2rpbFj3FD+QAKbPo+CWoalnqWyYwYrpNO9M6A7PTKsZpTpZSsjw5zKWgF0Ex4rG/lY+jPOZDM7LI6bcaKrKFDiBkUfu8P2fiiKUlK9lWOZREL7srAQ0Vkr5g5vCTVGTowL02TQvq/TYsMXN9DLnaJoKopSUo27c/RIIztRTD/7Y0n0psewsLcZpeins3bLKjvGqaxVSQFchwJkQGn1qs41qkqvaRZomtFE0pGsFVAaO8axbHv6+/rjSfRaYB+0OfSclNLEjB4XxnIUJ0DdEyvOla6fzmSYrTQxSyRTetZT6JrmkN0qlR3jWMa9hM7hdLadZaknQK1pFoNkgxHS6R7qiPUBA13azzXNprdqgunu5QWcbqeyVkB5Ro/1YthQqVFaVBV69+mCcjgwMoz+vlIyzKxlMMlhYaNEIp5OBUJiiZTlzvqVAS8qA+yyAgAdhRZHL6+r8OsNX6xk/olusM9alVKf6QyFWPtO68+JTo90SD8TKRWRfmulOayzVkB59pP1sxoOlcaOcYwRUlIwhoP9LCFjxFqOemrEX2eRNY3YFNZZK6A8dgxrvTCxYwTarrKy/oz3OmY5LATVHegbAwB16RF/ALCjCLW7ozcGVQU8CvQsKCuUtqY5s66Wy45xrJGvYPtZapf/wQjpdA91kHpufyUQqjW9Rejl/fFk3iyvUxkSoEynm/Fi6PN69G7TxaJrpqyVQ9kJaw6ek4uytdpIuuyAdaamMuBDZUAL8BRzNN2ygW5zaNPo8Sh6ZqCYHAPxpM5acUNWQOQ9UVVVb3TGmhES9Hl121msRpN2dplnrUqgzjplPzX2gTXnKp5MYUcf+7GP2vdZd/CcmkBBy2GFOuvUHHm/14O69Ii/YvWqtA1nn7USbzNodkwxOZIpFR0OBZLdcC0A4++yop9O9QfxUk3Mij2vZF1tqArqwWdWKKekz0mbUUyOVIoeqyeONeVo0mcnGBsmne6hDrqJWsamj65ny5dRdDZrVUIdiaMbJdK4y9oGOujz6NFJZjKUQI90qlYVsL4QdfXHkUhTFxsYOzWA9Q68TjkTQKn3xHn9LBaFJqNP/F4nslbW6+wd3TRarI3siSYQS7Af8UJglRHCI+tvpXmYUzWzgPXnhGS1nMlalc6AcPZZLayffbEE+tIBXNZMDMAINBXXT+cdPJE13fR3FlvTdvTFkCJjHxmvaUbNrPVeFCL3XKYALmNKNUA3SxVvP92y/ywmR2TA2HMxbzjokvXdSD5Jp1tisKK7Rfs/o3M5oFEegz5NBfLVdTv6gJUw49VZOawtRHSEj3XWit6gFKsT5eFoFqvDI4thTciHoI9t2QFAbV6L6IaTm7XGcuhnAp0auu7MqVpAK3XMPDLdVjdrVQEvKgLs9dNq51s+GxTRGyVrm0Yns1akNrKjt/g4JONZFbeRJ5vboM+DKgf0U5ejiH46m7Uq3X6K1E/yfj3jsY+0DDss9I7hEoAosq7SAdxwBdsEA2BdN5wYF2bIIL7nAP2dVvUz7MCei8jQ1R/Xg9V55SBN5RzoiVHqWNDBCKFO96uvvorvfOc7GDVqFBRFwRNPPGF6X1VVXHnllRg5ciQqKiowd+5cfPHFF6ZjOjo68MMf/hDhcBh1dXVYtGgRenp6TMf85z//waGHHopQKIQxY8bghhtucPpPcw8i6SZq4WynGzAo5vkz3RzqNyxlapyhOgHWFyKn6ICA8XdFEymdwp4PTi7KVqnMTmbbNTlKYx84ki3SHTzBTk2JDp4TzwjRi1gyZaGO2ZmyA1oOq/rphF4A9OagiH46NAoJKI+J4eQ9Ka6fztlPkplMplR0FhmHZDQCEh8gcyKAS74XsKCfHNb30rJn7HXDKjvGqRFugObIeyz2jnEyEGJ1RrZxLZzRT6u64dSoQ/o7ra3vzu/9ilLtHeqgDgC1FX74SO+YInsuvReFAwyIUtgxgxVCne7e3l7su+++uO2223K+f8MNN+D3v/897rjjDqxZswZVVVWYP38+BgYG9GN++MMfYt26dVixYgWefvppvPrqqzj77LP19yORCObNm4fddtsN77zzDn73u9/hqquuwl133eX43+cK5JnRTVATSjdTE+B0G4uhlVorZ7qXA6VHGp24FnQds1BKoMWaGn2eqQOLEEDXRlpblB3NWhW5H6ZaKyeiv1Y38g4uyiG/UcdcjPrlBnaMk44//b3FNkq86LuF2AeqqnKpwyvKjnFoXBhgrmMWacetsmOcDOAC1uf/Opq1KoUd46DtcsP6bqpjLma7HO2jY00/SSJEvP10kMlWCjvGBb2NnNRPj4eaXFN0bSXXwgmbIUeGOYqjjz4aS5YswXe/+92s91RVxdKlS3H55Zfj+OOPx9SpU/HXv/4VW7Zs0TPin3zyCZYvX467774bBx10EA455BD84Q9/wIMPPogtW7QM7wMPPIBYLIa//OUvmDJlCr7//e/j/PPPx80338zzTxWHIk43qU3uHsidHXBy80qMR2QggWgif3a3o9e5WivA+NuKOhMOdS4nsGx8ncyeWax/0zOJDkQ7AXrTaNHRdHCD0htLor8A+8Dp+narGyUnHSv6e61uDlh3ei1FBhKNd04/S61JdCJrZbBjCnX576bq2x2haZaoF05krUxyWA5aOrGWWLSfulPjDqaQM3W71tgxvdEE+uPOjNWj5ShqPx10rIAynCsn1pIaq+u7c2wQoHSmkBP3hGbH7CjAPhiIJ/VxXk48JyWzYxxYVwHrncO5BMjkyDD+WL9+PVpaWjB37lz9tdraWhx00EFYvXo1AGD16tWoq6vDjBkz9GPmzp0Lj8eDNWvW6MccdthhCAQMRZ0/fz4+++wz7Nixg9NfIxCRtNOdh15uON38M921FX74vcXHITlZawVYdzSdNnpWnCtVVTk1nSnm4Dmd6bZWk+ikflYHfXrPg0LXw8laK2Bw6SfAZ1EuFiAj9sQJx1+Tw1pWwOhq7zA7ppD9TG/mqh0Y+wiUoBeOB4UsBk+5jGSyJoNjAYi03hfvieGczbDKjiEyhPwO1bdbZG85SSHWvrdEORzQz0bKfhZiHzjp+AMUk01gzwG/14N6nR1TfP8Z8HocqW+3yo5x3H5aHBvGq2dLMXbMYIVrne6WFq0BWFNTk+n1pqYm/b2WlhaMGDHC9L7P50NDQ4PpmFzfQZ8jE9FoFJFIxPRv0KI7XdNdMyrn21Zrup3YvCqKYim65mRmAqBompY7ETsb/S3UGCkykEAs6WTWSrvGnX1xxAs0fHGyAzBAZYwEUu3pcTOFFiInHSug9M2aU3X2VjKJpqyVg5Tq7oEEBuL52Qd0UzknYLWhm5OdiGk5CttPZ52JRstBIeecCcBacGogntTXOieb2/XFkuiL5c/utjtsM6xmup3sygxYq9HkVd8ushRE+97izlUskUJXvzNj9ejvjBVhx2znpJ+DIRBCsz2F6qeDwWzte4vrZyKZ0nsSOCEHYR/Ek6r+HAw1uNbpFonrr78etbW1+r8xY8aIFqk8qCrVvbw55yHVoSKZbqcfdAs1HM4vhlazu3wijYWcGiKjU1mr+sqA3lm4o0AU2umaROvNwxyWw9I94ROMsVp24LwcxbMCFX6vaSQhK4QrfAik2S6FdMPJxmEA1YTHoqPpXCCkeF8MXhkS4ZkaC88JoRAHvB6EQ+z1k2bHFNINJ5t2AVQmUbijaeWecLKfFgO4jgctC+lFOkji9SioYzz2EQAqAl6dTVBQDof103LPARfop2vKCh2+FkbyKf896eiLQVW1sY9OlNLR7JihWtftWqe7uVlzEltbW02vt7a26u81Nzdj27ZtpvcTiQQ6OjpMx+T6DvocmbjsssvQ1dWl/9u0aZP9P0gE+jqAZPoBytdILb0x7snhdDudtaK/t9CD7nQ0njj+xRpquGEBcNrZ9VANXwo1RnK8JtFCzZcpa+VQRN6gfhXST4c3a5R+Jgvop95V1Ok6vALZM6cp7oqiWKr3d7KrPf29IrNW9PcWKsPgZbeKsWMcz7hbCJCRQM1wh7JWVtkxTj+rVuyn01krgAqqW1hLnHYmuqPW2DGOledY0U/K2fUwHquXJUch+6k3SnV+r5OPRpyiG+g6xY6x0ATS0E9n9aIoO6bX4QSDlfU9vU9vqAowH/tIYJU5NVjhWqd73LhxaG5uxsqVK/XXIpEI1qxZg5kzZwIAZs6cic7OTrzzzjv6Mf/+97+RSqVw0EEH6ce8+uqriMcNqsKKFSuw1157ob6+Pue5g8EgwuGw6d+gBKGWVw4HfLkf1OoC9HKns1YAvWm0QN91uOlMIlWY0uJ0nWijheiv0xto+rstUa4cjoTv6IvnnWuq11r5PHrwiDWsNHxxuvyhoTIARQFSKgo2fDHou+LqRJ3O+tPfXTA4RTYoDmcSCzWBJJsXn0dBrQNZK6BEJoZDelFX4bfEjuFF3y3EgHCyMZMuh5V7oo8tc9Z+FmoC6XTWCqA38oXuibPraqnsGJEBMqf3OiY5CuonCVo6q5+FRqR29sf1ILNz+mnBZjisF1UBL0L+4uwYp22XFdap0wEy+rtlptsB9PT04P3338f7778PQGue9v7772Pjxo1QFAUXXHABlixZgn/961/48MMPceqpp2LUqFFYuHAhAGDSpEk46qijcNZZZ+Gtt97CqlWrcN555+H73/8+Ro3Saph/8IMfIBAIYNGiRVi3bh0eeugh3HrrrbjooosE/dUcQZqo5clyA8bIsFz0cqcjvwAsjSlweoMS8Hn0TXG+B53OWjndEVkk1V777uLZXacziWSuKZB/I68vhlXOZK0AerRJ8Q20U/fE5/WgvrKwHIlkSnfIna5jtqKfTskAWLQZDtckhkPGXNO8+kllBRzLWrngnlhhx/DIWpXSH8SpYCFgkR3jcHf9mqAPgSJNIHlkrUq7J85cC5odk8/RVFXV8Y7dxWSg33MyKGSlm7uTs5gBayNSiXx1lX74HWigC1gLQDjd1Z7ubZSPHaM10HX2nlhhnRr7PufspxV2zGCGUKd77dq12G+//bDffvsBAC666CLst99+uPLKKwEAl156KX72s5/h7LPPxgEHHICenh4sX74coVBI/44HHngAEydOxJFHHoljjjkGhxxyiGkGd21tLV544QWsX78e06dPx8UXX4wrr7zSNMt7yIKMC8vTuRwoPDLM6VoroLRGK07RdwHD0cxn9LhkrUqpL3IwEFJMjmgiqQdpnLonprmmeTavXLJWJdQxOytHYUezo5df1spKAMKprBUtR75nNZ5MobOPBMicK8MoVpfII0BmpfMt3+cktxw7+mLOZ61K6IkhMlOTpAIQTpZhFOuLweVaWGLHOMsU0r678D2J9BsNSp2yGdb2Os5SiAGKUp3HbtEBCB4Jl3x0ZqdrqbXvFt9TCChuu3qiCUTTYx+dm05ifX3nYz+HJr3cGU6mRcyZM6dgW3hFUXDNNdfgmmuuyXtMQ0MD/v73vxc8z9SpU/Haa6+VLeegRZEZ3UDh7uVOR+OB0jI1zi4AQfy3rbeAg2dk253LWhXPkOijuhy9J4UjjWTD6PMojozQIBhWFUR7Tyz/osxxA21l5I2T2bPh1UF83tqT9zkh8jmZtaI3KKqq5mQXuMGp2ZHWT48C1FU6aDOqgmiNRIveE0ezViUEhRoddWqKBMjSrzubtTJkyK+fznZQB4qzYzr7YiCtGRqc1M/qILZ0DeQtjeGStSppfRd3T8izWhNypkEpYKbap1Jqzn2EG+xnpD+BhMMBMkCzn5s6+vPajDauwRixQaFi7BjyemXAi8qAM3su8ox09MWQSKZyjud1g34Odri2pluCASJkXFh5TjfPrJXoSGOxsWE8o509BRq+8MmqFq7DoztDO0XrJt9Pny8TbsiQaO85v5EvJgfPWuqBeP46PDeUP5DXnQxAAMX10+mmh9p3l5I9E8dY4rlZiyVTiOSZxsGzZjavXqTtan2lP+fGlhWs66fooLr47BkPNh25H8mUis48vWN4Onh5gzG9RgAi6HMmAAFQ9dRF7PjOpZ/i7CfpHaOq0BssZoKH/bRS0jeYIZ3uoQwyLqwgvdxCTTcH+lm+xTCVUjltDqxFwp2Uga7Dy1cbySdrVXgBINfCyWy7FTm4OBNF6otUVdWvh7PlD4Uz7jyoeFVBHyr81urwnL0n4gNk9PcX2yjxKIsRTqm2fE+cs1shv1dvqJi/jplfoK7Ys+pU7bBlOXgGswt0qeZDI05fC4E2w+/1oK6ycO8YvpnEImVbLrGfPOzW9jQ7Rpgcxa4FB7vl83p05k2+MjYu5Q+63Rqa9HLpdA9lkO7lNaPyHmLUdAtyutPfvSNNaclEZCCuU5140OBE1mcqilI0Y8QlAFFkjMZ2DpldgI54CqxJTH93vi7VPdEEYqTWikdwKs9i6PRYk0w58lP++S3K+WQwxtk5fC2KdL7luWnM16W6L5ZAX/p1Lj0HBAbIgOLOP7lXPAJkea+Fw6N/CIplurlk/dP2Ih87ZiCeRHfU2f4ggIVnlUOvFE2OIvrJcX3Pu8fgrp/5rkU6aMmhqVwsmUKkP3sPTPcHcXZNK2I/eznZzyJrK8/+IIUmxgxmSKd7KEPvXp57HjlA08uz6U48No2kS3U+SguRIew01anYQsShsQhghXIlnr5LjKFT45gMOQobXx5U+9qKwl2qyTWqCnhREXCSildkMeTl1OgZoyL6KbC5nTHr1umgkMVMjYM2o1iXanItQn4Pqrjopzi7pX2/xUCIg/pZjB1D7Jnjme4qqzbDOf2ku1TnsuPkPvm9zvYHKcaO2c7NqUnrhshAXVHHnw+TTe9sX2w6idPsmPQeONfYWrLmez2KPkHECRj7T3FNY7XvL+z8E1viZIDMCjtmMEM63UMViRjQ1679HM6f6SYGZyCeQjwj08zD6Jm6VOfYyPPooE5/f9ENtMCNPL+slfbdHb1RveMwDbJBcTqTOKxo911jZJhTMMcHYHcAAQAASURBVI+byR8UcnwxLBYJ50xZzSXHQNzoau/kc2LMcM/NjtFnyPPSz2LNFx28FsXYMXQpiLP9F4rQd7udz1oBhUdU8ehqDxRnx2znYLcACz0xOG3kC9Vo6nbLYf20ur5zC9TleE54dLXXZNC+Ox87hpv9LFZbzruMLcc9IfbMybGPQPHReu2cEx259jp0qSePkWGFescMZkine6iiJ13P7fEDlcPyHlYVNKLLPRkUc27RtQILIu8MSVEqM6dMd+4NCp+sFQmCpFTos5/NcvB18ERmumk5Cm0auQWF8mSYeXR6NclRIGsV8HoczVqZ2DE5AjLbudkM8TWJ2vfnt138bLjVUhA+5Q+5NtBkw+h01opmx+RyeI2u4e7QTyezVrQcudgx/NbVwtdCD+47LEehAFlHr9bVXlGc7WpfjB3DSz8b9fVdcHa3kP3kZMOLsWPcsNfp6qdKPR0MhFiZ4T6YIZ3uoQqdWj5Ss+J54Pd6EPJrakB3MKdrrZzO7lpyujktym15KC085hPS359rAeCVtfJ7Pagv0PCFV31RoZpuc60Vp01joQ0KL6p9bx795FRnXzgoZNRSO6mfGjum+D3hFYDItWlMJFN6uYzTtqsQO4bohZONF7XvL8yOaedE+S/UhIdcH6ezViZ2TIF7ItJ+plIqN8aSG4LqBjsmnsXo4ylHQfuZfq2+MuBoV3uaHZPLfm7nZDMK2S1VVbkwLbXvL24/ecmQjx3D22YUWldrK/x60MYpDOWxYdLpHqogM7oLdC4nqAlldzDnlbUCrC1EvByrWCKlBxtEylHQmXDYsaLlyJVZNWoS+S2GmY4mnbWqq/BzkyMTbZycXXKt40kVXTnGzfDOWhWk2jssg3aO/A6F7kw4ThU1mspl6mdHXwwqh6wVQF2LHFkBXvekoUobN5OXHeOCTA2PxmFW5ODX6M8IhKQyAiGd/XE9OCJyCgUvZ4KwY4B8vTl4s2MKyeCsXtDnyMkI0fWTXyAks0woMpBALOl8g1L6+0XuP2sr/PB7i7Nj3JD04aGfQ3lsmHS6hyqI011gRjdBjd7B3NjM88paAUUWIk4Z5oqAV6dsZy5EpqyVwO67PMaF6XIUaNxl1CTyWZSjiezaHjrD7GTWCqApq+IWw6DPi3Ao9zikFF0L6IoNivP6WagxEo+6M8Aow4gn1ay50ESGBoezVoA7No0+r0enbGfKoar02EeBWSsOY3ey5cgVtORzLcj9SKnImgtNAqc8slaNBTbQbZzKc0zsmO5s/eQetBT4rNLnyNUvxWhE6bx+kq1lZhNdci1qgj6E/M6V0gHusBmKohSs6+Ylh17+kHP/yWePQZ9jKI4Nk073UEWEjAsr7nRX6x3MjY0j1wWg0Aa6l78cmQsRyVp5FGOj7ZgMBTYoPMaJ6HLkGRumqiq3TE1lwJgLnVnXzVM/C9XhbecZCNHviVk/TVkrgWOyRCzKmUEhegPttByF5kKL2EDn6gIsJntmloNn1qqxQPddHuPCCKw4V05nmAM+D2orcpcJ8cxaGet7flYKT/3MtF29sSQG4mn9dLqMzUKwkKvNyNU8jFNNt9ej6CygzOwur7Gk2jnSlOqC+slPjsxntT+W1JMOvJhCuZItvGrsTXLITLfEoEF3upGaJXp5IaebY1Ygx6axjVNWwCRHxkKkZ62qAvA6nFVtLBCBdgN9N9KfQDypOXhOByCA/AsRrxpmoMhC5AJHk1ybuko//E5nVS0wMfjck9z62RNNIJqem+50AII+R+amkVcvCu0cFrITAp8TEVmrnBRNnpvGPOwYegIFD/3MF8R1g90CjHvidFd7+hzZ67v2e2XAi8oAp1K63lhWSQrX8oc862o0QU2g4MoIyRe0FMvqExI8zbOWBHwePcjrmAw1xnqWWZLCY1wYQSF2zGCHdLqHKnR6ef5xYQTV6QeZpkjyXZQL1CRyja7l26DwN7ydORq+CAmEZF6LtOGtCTm/gQboURp5nBquwRhxtapAfuoXrw7q9Dm6owkMxDMp/+IzNcTZ4rGBpuXIYmJwKovRziG+JwZ9jkx2jIgMSV8sib5YxjQOnuUPeewn0c+gz6Ovu05iWJ4ghIh7IrI7tFkO8et7rt4x7Zw6qNNyZN4TUqbk8yg6S8JJFA1aCmaltAl5TnLrZ2O1sw10AWO/lUhl944x1jSx7JjBDul0D1Xo9PLmoodWBzXjSo8Mc4OxMVFFHabi0XJk1pEYIzScNza1FX49m569UeKZtcq9kedJgaPlyLtp5CCHlTmzfOUwXwujq73z+hkO+RDw5h43w7NmVp8LnamfnEofDDmMzBUNXhRigHbwCmR3uTa/ybwW/DZrlQGvPo0jc8PGq4M6kH9No+mqTm+gtfPknoXMq4YZoPSiADtGZNaf0Ip5yBDye/VgS1bwlKOjmdd+Uv0weOhnvg7mdE8hp5GvLEaTi5/tGpZHDl5z04HCJSm8RskBhQMhgx3S6R6KUFWKXl48023Qy43IltEBmCe9x0xpoamiPKK/+RcAfo6mx6Po1zyv0RO5aeTo4GnnyZNJFJDp7uiLmbqs0rVWfDYH+SLh/IIx5nFIIrMThR08Hs8IQGcS89TMcrRbXf1xxBKGfkYTSZ295IZMIo97oigKFTzNYzM4PCf5AnW8Jj/oclQZaysNXqMOgfzsmHgyhR2cxj4C9Pouzm5p5ylmP0WWHfB7VrXz5K6zbxPAmuqPJ9FLsQ+SKRUdHHsK5WPH8NbPfGPD3MI+GOyQTvdQRDQCxHu1ny1kunWnm6aXc6y1Ig95MqWauqy2c6aKNuaJyPNflHNvGsnvjTzpZ1lRV76bxqI13RzuSUOVNm5GVc1dVnnWWgHW6Gc8kI/a7YZFmfuzmjdAxk8/62h2DFWXSLJWfi8fqmjRTSMHuwW4q040n2PFK2jphkBdPnYMoTJ7FKPTupNwjc1wgRx5S5U4ZlWB/HX2PK9FVdBo2Erfkx19MZAcEJf+NUWy/jzsllkOcYylfIH9oQDpdA9FRNL13MFaIFBV9PBqfWSYmO7lfq8HdZXZlBa3LIY8G5wAyNkYaSBONzjh0WjFaC5CN3zh6UwAVE13nkwNDzm0cTPZ1K82ytnlSRXNKn/gvihnO5rmrBW/kWEdGewYXuOYCPTnJKv7Lr9AiIkd050dFBpWxUk/8wbIxNvxJDVWj2f38h0Z7Bju9jPP5nU7x3uisQ+y5SAlbA1VQccblAKU/czj4PGYQKHJka2fqZQqpHt5ZCBhYsfwtFtA/kw3d5uRw3aRn+s5NCgF3BGMAXIHZFRV5dvoL32Onhy9YwY7pNM9FEGaqFnoXA4YI8O6BY0Mo89DP+jcnQni7AqM8NHnoeUgixKvrNUwegZxv6EXRs0s301jNr2cd2159oIoTD9dwsTIlbXyehQuWSsSBMlkxwij7wqnrObQT1EZ5gx2TBvH8hyAGhtGydHRq2WtFA5jH4H87BijZpZ3T4x89lOc7eLJPNDOk2d959grRTtPNqOuqz+OBKexj4DWO8aXix3TyzfTna88hzwnPFh9AMUupIOWnO2W4fjn23/yLn8w7kl31AjO8GC/FuodM9ghne6hCL1zuTWnuyZkbqTGO2tFn4emVLdznJFInye7EzG/WkAgN01zO+esVcjv1csO2kxy8A5AZDs1plorgZRVnjM8AbNe0OwD3nLkCk4ZWasAPByyVn6vB/W52DF6LwrOmURq42rKWvHSz5pcQSFB9rM3Uz/FByCIDPWVAfg4ZK3ysWOMa8HZqaEyibyzVvR52nOsJTw28fR5OnqjJnaMuPKxbL0Ih3wI+pyfCuLxKDkbd/FslqWdR3x/EPo8uWwGbxmy2TF895+59lxkD1zNYewjkJ8dMxQgne6hCL1zuUWnm9DL043UeGetgMIPOj9jo/2tvbEk+mMGpYXnfEJNjmznn3fWCsjt/HNvtEIyNdSmkdRaKQrQwE0/s7uo8+xcDhjXIppI6Q3cTHJwXpRFBiBMcnTTG3nOPQdy9IEwZa04PSe5NijtnDeN5JpnsmN0+i7nABmdweM57iZTjpz2kxsTI1s/eWetAMp+9mY7eLz0kwRBUqq2hhBwD1rmWN/bOGfbaTnM+smvgS4AfSoNHaijZ9nzvyfZgWRe96S+snDvGP6Mz1zrO0f7mYfZN9ghne6hCL1zeWn0cpLp5p21AorQIzktANVBH4I+M6WFzlpxH0NkcvD4OzW5OvCKynTT0V+j1opP1grI3dmedyCkMuBDZSDd8CX9jGpj9ThvlHLoBW+qPZC7yyq5FrwDZHRtJLku4ZAPAR8f/cwZIOM4CgkAgr7c7BjetqtgBo9TEAQonN3lzUqhA8m8s1YANaIqB72cl90ys2Oyg6fcA3UC+9cAuceG6bX+nKn2A3EjkEye25Dfo693jsuR857w3evkY8e4qZSOFwMinxxDAdLpHoookV5OGqn1pGu6eS+GQJGFiNMCkGvcjJisVbaxaRO5acy1UeJkfOsrA1Ayor8is1a5HDyRG/nIQAKxJO+sVTa9XMSmMZcc2znrZzhk1EYShlAbZ7sF5A6Q8e5qT5+LnLs3mkB/nIzVc0N9u+h7wtdm1ASN2kiS+efdoRoonFXle0/McgzEk3ovG/5OjbhsJn2unEEhTvpZGTA6hxPbTZc+8CilI+cCxAdCMuWIJVLo6uc3Vg/Ik/RxiX4OBUineyiiVHp5OjtBZrryrrUC8i1EIiirZjoeeeBrK/zcslZuaIpklkO7D7FEipr7yzH6W2mmdotZDHN03xWwkc9ciMj/PLNWhTco4jbyCaoXBS+HwkNnJ3rMTo3IzRr9s0g5yP8hvwdV3LJW2QGyNqH6qelDyjT3l48cimLU7rrDforWz9z2M+D1IBxyfuyjJoM7nlWjS7WmF6qqUo1S+TOW2oXqpzvXNHI/vB4FdRwa6AKGXrRRvWN4zk0nyNf4cLBDOt1DESXSy2uC2sMcS6QQTSRdaPTEPehCNmtpx7qjN4ZkOsvOmzYLZN8TksnzeRSEQ3wWAADu2DS6oPuudi5zEx4RtG5yrs6+OOI65Z//opw545UwIXjN/SXIbFZF5BHyrOagVPN9TnIHLXlmrch17x4wxs2IKM/JZAp19sf1ub/1HFlkRl+MzHsioj9IjppZEfZT10+DNcUtq5q2W32xJPpiaXahSP2kWFPxpKagPDr8E2R2MHdLUN0VQSFSIiSg1DOWSOksELeUPwwFSKd7qCGVBHpatZ9rRln6SFXQyED0RpNinIlcTo3ARVlk1qohTalOqYajy7tpF4CsERbkmvCs9QfccU9y18wKcK4ynhMR16K+MqDP1XVD9sxwdrX/G6oCXOb+ZspB7gnvDtXauQrRd8Vld3mPCwOAcAVNqTbrJ99ACOlsb5ahjtPcX0MOc0BGCBMjV3d9F2TPeDehBICqgBchf7p3TLfIQHLuYEwNR9YUYMxHJ/eE97gwIN/+0wX6KUAvKgJenZWk7zMEPCf5xh0Odkine6ihZxugJgHFA1Q1WvqIz2s0rOgZSIildffEoKoq+mNJvbEG1we9xvygizA2Pq9Hp1Rn0ozcQBXlKQOQXYcnkmq/vTeGVErNoNqLuyci9CIXpZp3p1cg/7XgWWNPy6FvXkVs1gg7pk9jx2hUe/HZMxH6SVOqswIhAjfywuxn+nloz8p089cLwo6hqfY8y9jIuURmVXP1jmkX0R06IxhjjDkUo59iM91pdkxUY8fQVHu++888NoPzPSHnyw5aimXHDAVIp3uogTRRq24CvNZrlEgztchAXKjRiyU1Sotea+Xz6CPNeMqhR105jwvLlMPIJIrMWkVNsvCs9wKMhn6ZCwBX9kFahmRKRVd/XNcLn0dBLadaK8BY9LZnZWr43pNs50rkptEl+pmZneC4UWqgGw72xtDRF4Oq8qfaZ2cS+WetaDlEBkIy2TG6fnKk7gJ0xkhcdreuwq+zTzp6Y/rYR4AvlTmTvivCbmnny3A03RC0FNBAF8geCypifQ+HzOyYSL9BtefbUJgEyDJZKYLW9+7M50QsO2YoQDrdQw0ldi4n0MeGRRNCslYhv1d3/Nu7o4bhreJXawUgOwLdLWajRHe+FZe1MmQwRX65ByAy2AcCyh8CPo/uXLf3RE3jmHhS7TOz/m36Rl7MPWnviaWzViJH2sXSo9NIEyBRTAzzppGnzchkx4ii2md27BbHjjFG75gbRPF3agg7Zrvga5FpP3lmrWh2TFt3VH9WhFHt9fIHMTYjk9knovyB6EVHehwncfS4By0zmWycRx0C2ewYsv+rCfGl2mcydETZz+zacnH2k+4dMxQgne6hhhI7lxOQbDJNLxcVkW/viVGZXUGbtSwqs5hMd3tPFB29YrNWZIamKL3IcmoEZK208xlzoUXM/dVkyEe1FyfHjj6j4R/frJXBjokItFvZNkO87RK3Wcutn/zXEiN42tUfF5K1otkxnf1xQz+5MzEyg0JEDnG64bpSJYHXoieaQDSRSsvHUT8zxnGKcKyAHA6eC+6JKBky2TEiEgwA3cQsZi715CgHzY7ZPoQo5tLpHmoosXM5QU26G3VXf1xIrRXgMqMnPNJobBpJ1JV31qoqaMzQNLEPBOnFduEZd2PzKmJcmCZD7uZ2PLNWJjmorFU956xVyO/Vg4XtPVE9k8fbbhGbsb1X0882/Z7sxPYz/ayKthn0teCdtcpkxwizWzVucTTpoLoYZ4Km2pv0UxR9t8ewn5UBLyoD/ErpTOyY7pjwdZU4Vm3C9TMqXC8IO0b0/pO+FkGfR2ej8oDHo+hB0qFEMZdO91BDufTy9MO0aUefkForIONBF9C5nJYhMpBIj08TVFNTYyyGIhrbZcnRExVWk0jTiE1ZK+73xAjICFuU0zL0pBu+uGlRFqOfxj0hdWfCahJ7YuiOJhBLZ62E3ZNugU5N2l5ksmNEOnikgzrvIIhJDio4JbInRl8sgT4BWSvAHJAxxoWJeUZiyRQi/QY7hn+ATDwrhT4nvb7zz6oa+jkQT6I73aBUXNAyBhHTYgDjWujsGEGsvkbKbtFBEJ6lnsDQHBsmne6hhjLp5aSme0N7LwD+WSuAdjTFLUS1FX74KEqLuKhrrgCEyEVZYCScdDftNfQiHPIh6OOXtQLMm8Z2QRv5mqAPAZ/2XLZ1RwVS7akNitBNo7Fh0xsBCaKsbqc2a1UBLyoCfPUzV/aM9z2pDPj0SRjt3eJsV2POAJlA+0nrp6CSlI7emO7s8s5aAZlBSzH6SbNj6DIhUd2h27tjwhIMmhzG2DAjqM7ZfqbPt6PP0M+A14NwhRj9bBOon36vB3WVVO8YN+0/OT8jmhzmJpBDAdLpHmoom16uGbj12/sAiN2gtPWIy+56PEZDjQ3tvXrWShRlVSTVSTtntqPJv9GKkT3b2JHWT4ELgMjFUFEUXTc2dfShP85/rB59PlPWSsg9yXY0RWUSY8kUNmzXgpZCrkUN1XPABfdkc2c/uqOis1a0YyXCqcnlaPKVg64t/29bT1oG/lmrXPaT97oKGPekpWsAnX3xtGwu0E+RQSGKHcPbftZX+vXa8i+2desy8NdPd92T1sgAOkgDXd7TH/T13diL8y5h085pLo0ZCpBO91BDN8l0jyrpYyT6SzLdIo3NdoERaFqOT1u0BaA6yLcWkJZhe09MyLiGTDnausXVJNK15Z9s7RYiA33O7XTWX8RGPr34Ef0M+T2o4p5VNei7osbuaOfMzmjydvDo7Jlb9LNdqM3Q9OCztH4KyVpRtZHbBZbn0JtGUd3L6dpyXT8Frqs0K0WMzdDO+Xmrdi28HgV1HMc+ajLkYKUID1qK0U+6tlys/TSyqiJGtGbK8UVrD1QVUBTo14efDMZeXJTdAsxBy6EC6XQPJcT6gIEu7ecSM92EXt7Vn478umYBELeRJ5tG0bQvkZlEEt1c396r11LzrvUHjOg7uSdi6jOzs/4inStDP/lnrcj17+iNYltEfFZgw/Y+IR2ACTL1U4TNMJc/uMd+islaaX/3jr4YWiIDJrlEyPHNjn69A7Ab9FNE1ooO4ArtU5Kpn1V8xz4CxrMaGUhga1e/SS6eIOfc0jWASLqWWoTNcJ39dEGmm1yLhsoAfLxLPdPXvzeWxKYdItmvspGahJtBmqj5K4FguKSPVgfNkV6REeh2gfRy+pyftkQA8K8RBQzHNp5U8RVFCeSNYRkLQI2ArH8uOURuXEXXMQ/TM93i9TOlAl9uE7dRytysVfj5dgA25MjUT7cELcXZDKKfImSoqwzAQyirreJsRuYGOiCglhqA3heDDtTxRi77KfI5EWk/wxU++L2aoy8yEELuyedpGXweBeEQ36w/YNR1i7Sfw1xiP7P1k79eVAd9CKZ7x4jcc9G9Y4YKpNM9lEB3Li8xs0BquglE17LoGXeR9MhWcc5E0OdFOH1PPnPBppHUAoqQAQCGp528/woMQNCZGlJrJXQj3ypus+bzelCfbvhiPCfi7olo/RzmAv2ku6h3CKSXN2bYTxH3xOtR0FBlfk5EBiB0vajin/XX5DDrp4h7QrNjRDLZhrlgfVcUxXA0W8U5mo0Z+tkgIOsPZOunyH3fjr44tgllCmXqJ/9roShK1j5DdHf9oQLpdA8lRNJOd7i0em7AoJcTiKFUaw8YoYmKqLUCjAd9IC5m9I8uR41ZDpEjbxIpMqZL0LVIn5fIIcSZSN+PWDIlrNYKcJF+ukCOxhqzfoq6FsMy9FNk1iqRUqnnVZwdF6+fRgNGUXJI+2mgoSoARdHYMaRUSeRGXuS6CsA0Xo+Wi6sMGXrhHv3kb7fqKwPwpgMOosY+0ueU9pNmx0inW8KN0JuoNZf80Zqg+Ex3VcCLkN9QSRG1VkB28wzRTo1IOTLryEUshkC28yBCjpDfa6KGiqi1AnLdE5fop8A+EMbvYvQz08kWcU9odgwA1AkY+wi4w24B2Z2xRfaBMH53i/3kfy00dowhh6hSJTfYrZxyCOwdI1KGXOcV0dXe41FM/Woq/F5UiSgFcYn9zDxvo4CmcgY7JoZkOiAz2CGd7qEEMi6sxBndAFATyqzpFktpESVDrvOKWpQzN4kiqcyGDGIziQTiNkoB6mfxMuT6nZscGfdgmIAGe1n6yXnGrH5et+hnjQvtp7CNfOY9EbBpzHxG3GI/XWC7hK2rrnE0xduMTHspmikkWg7T/lOAvdDOK95uAe5w/ml2zI6+oVHXLZ3uoYRIOtPNgl7uguivG2QAxFBFNTmM84rKWoVDPgSo8w4X4FgBOSLhO/GinPm3uyEAURMSk7Wix8kBAmu6XZBJzDzvzpy1ypSjMiCmwV4mO0Z0TwwCEVkrwC36Kd6ZyDxvwOfJYhvyAD1ODhATOM11XlcEhVwgg1A5KBvh9yomPeEFmh0zVCjm0ukeStAbqZVOL8/sqCrK+MpFOfd5RcmgsQ+M+yAsU5MRkRe2eXXBPXGjfooKggDmzYFb9FMczd0F+unC8gdRMmjnpjbybmFi7MT3xD3209CLxmr+Yx9zyeEeJsZObD+zkj7i5RhWJV4/yZjWwQ7pdA8l6E53GZluyukWlbUC3BFpJJQWAjcsRKIWoWw5xEddRWWtALOzL+pa1Fb49YYvmhziNyiigiCA2eEVdi0o/RQ1Fgpwh/2sCWawY1xgP0XqpxvYMbRe+DxislaA+T6IuiduYce4IcEAuGOfQa8lHkUb+ScCbljfXcOOcZn9lJluCXdBVY2a7nDpNd1ej4KqgLYQic0KiF8AvB7F1JXaDTRNUY5/thyi6GfiHf/Mc4u6Fh6PYmKiiHNqxMuQeW5h14LST5FZKzdsoLPZMeLtp0j9NDmaLsh0D6sWM7YMcMezCpjviSsyiQKvhRuyu/T9aKgKmoLKPOGG/Wfmud1wT9ywvkunexDitttuw9ixYxEKhXDQQQfhrbfeEi0SO/RtB5Jp+kV16fRywKjr3tmNDX3uoMisVY15Iy8KbliI6iv9OvtAqH66oFEVfW5RtVa0DJk/80ZjjXgHj2YfiLWf7rgn5DnxKDB1rOYqg1uuhQsCdeGQD34v0c+d28Gjz60oMHWs5ipDjfjAfua5RelnJTW5RtpPd9gMtzyr5O9vk0734MJDDz2Eiy66CIsXL8a7776LfffdF/Pnz8e2bdtEi8YGhFpeORzwlfeQEufSDZs18XIEdBlEZQUaXeDsAuZ7IipTQzfUELtpFJ8hAYx7IrTWyi3ParV4/aTHzbimftgF90Rk1qrRFLTcuTfyiqLoz4Yb1lXhcqTPXS9o7CMtQ+bPIuUQlXGn9VNU40XAfWtaOORD0Ceq1FN8WQwth6zpHmS4+eabcdZZZ+GMM87A5MmTcccdd6CyshJ/+ctfRIvGBpG0010GtZyAjA1zg7FxixyiOkPTMmT+LEoOkbWAmhxpp0beE+paiKylpsf/iF+URWataDlcE7QU+pwETP+LQINJP91xT4TqZ40bgkJUIESgzWisEa+f9ZUBeHT2ljv0U1QDXVoON6yrmT9zl6NG/F6ntsIPX1pBRSYYyLm398pM96BBLBbDO++8g7lz5+qveTwezJ07F6tXr846PhqNIhKJmP65Ht3pcWFlzOgmqAm5INPtsuiayAxJRcDrkjp77Ro0VAXgEZS1AuCOTI1L9LPRBQ5eyO91lc1oqAwIy6pqcogPhLiGHUPsp8BNo9/rQX2l+EAyWUNEjX0k0O2nC9bVzJ9FySFSBq9HQYN+T8Rfi5qguAa6APSxdiLtlsl+uuCeiNRPj0fRqd1uYMfImu5BhPb2diSTSTQ1NZleb2pqQktLS9bx119/PWpra/V/Y8aM4SVq+SBN1Gw43aNqKwAAY4dXspCoLIysDSHo8yAc8pmamfHGuOFVAICxw6qEyQAAY4kcAu/J+OHVmgzCr4V2DcYJvBZN4RAq/F7UBH3CqMwApReC78n4tBzkeREBohe7DROnF/T5Rd6TxpogKtPBOpEOr1v00w1yEBl2E3wtyDM6TqAcw6uDqE53Dx9RExImh76+C7RbmhzpNU3gPSEy7CZwXQWM50PkPWmoCqSn93jQHBavnyL1gpZD5D0ZavRyRVVVVbQQTmPLli3YZZdd8MYbb2DmzJn665deeileeeUVrFmzxnR8NBpFNGpEVSKRCMaMGYOuri6Ew2FucpeErR8Am94Chu8BjJ9T1ld09Mbw1vrtOHJSk9CI/Dtf70DQ58Heu9QKk2EgnsRLn27DrAnDhVKqN7T34uuOPszes1GYDADw0qfbMGFENcY0iFuYd/TGsMYF+vnexh3weTzYZ7Q4/Ywmkvj3J9swa/fhqK0Up58bt/fhq/YezNlrhDAZAOClz7ZhQqNY/ezsi+HNr7bjiIlNCPjE6ecHmzoBAPuOqRMmQyyRwr8/bcW3xg8TNv4HADZ19OHLth4cLlg/X/5sG8YPr8auAgNDXX1xvPHfdhwxaYSwOlEA+M83nUipwDQX6OdB44ahXiClelNHH77c1oPDJ4rVz1c+b8NuDZVCnSuin4dPHCE04/7R5i7Ekinsv2u9MBniyRRWftKKA8cNE1qS8s2OPnzW0o0jJo4Q1jumsy+Gh97ehObaEI6ftosQGawgEomgtra2qJ+4UzjdsVgMlZWVePTRR7Fw4UL99dNOOw2dnZ148sknC37e6sWUkJCQkJCQkJCQkJCQ2Dlg1U/cKejlgUAA06dPx8qVK/XXUqkUVq5cacp8S0hISEhISEhISEhISEiwhJgBxAJw0UUX4bTTTsOMGTNw4IEHYunSpejt7cUZZ5whWjQJCQkJCQkJCQkJCQmJIYqdxuk++eST0dbWhiuvvBItLS2YNm0ali9fntVcTUJCQkJCQkJCQkJCQkKCFXaKmm67kDXdEhISEhISEhISEhISEjRkTbeEhISEhISEhISEhISEhGBIp1tCQkJCQkJCQkJCQkJCwiFIp1tCQkJCQkJCQkJCQkJCwiFIp1tCQkJCQkJCQkJCQkJCwiFIp1tCQkJCQkJCQkJCQkJCwiFIp1tCQkJCQkJCQkJCQkJCwiFIp1tCQkJCQkJCQkJCQkJCwiH4RAswGEBGmUciEcGSSEhISEhISEhISEhISLgBxD8k/mI+SKfbArq7uwEAY8aMESyJhISEhISEhISEhISEhJvQ3d2N2travO8rajG3XAKpVApbtmxBTU0NFEURLU5eRCIRjBkzBps2bUI4HBYtjoSECVI/JdwMqZ8SbobUTwk3Q+qnhJvhtH6qqoru7m6MGjUKHk/+ym2Z6bYAj8eD0aNHixbDMsLhsDR6Eq6F1E8JN0Pqp4SbIfVTws2Q+inhZjipn4Uy3ASykZqEhISEhISEhISEhISEhEOQTreEhISEhISEhISEhISEhEOQTvcQQjAYxOLFixEMBkWLIiGRBamfEm6G1E8JN0Pqp4SbIfVTws1wi37KRmoSEhISEhISEhISEhISEg5BZrolJCQkJCQkJCQkJCQkJByCdLolJCQkJCQkJCQkJCQkJByCdLolJCQkJCQkJCQkJCQkJByCdLolJCQkJCQkJCQkJCQkJByCdLolJCQkJCQkJCQkJCQkJByCdLolJCQkJCQkJCQkJCQkJByCdLolJCQkJCQkJCQkJCQkJByCdLolJCQkJCQkJCQkJCQkJByCdLolJCQkJCQkJCQkJCQkJByCdLolJCQkJCQkJCQkJCQkJByCdLolJCQkJCQkJCQkJCQkJByCdLolJCQkJCQkJCQkJCQkJByCdLolJCQkJCQkJCQkJCQkJByCdLolJCQkJCQsYs6cOZgzZ45oMXDvvfdCURSsXbvW8XOdfvrpGDt2bFmfveqqq6AoCluBXIoNGzZAURTceOONBY97+eWXoSgKXn75ZT6CUdiZ7oeEhISEmyCdbgkJCQkJbnj44YehKAoef/zxrPf23XdfKIqCl156Keu9XXfdFbNmzeIhomOIxWK49dZbsd9++yEcDqOurg5TpkzB2WefjU8//VS0eIMaN9xwAxRFwXvvvWd6XVVV1NfXQ1EUrF+/3vTewMAAgsEgfvCDH/AUVUJCQkJiJ4R0uiUkJCQkuOGQQw4BALz++uum1yORCD766CP4fD6sWrXK9N6mTZuwadMm/bODFSeccAIuvvhi7L333vjNb36Dq6++Gocddhiee+45vPnmm6LFG9TIp1fr1q1DZ2dnTr16++23EYvFBr1eSUhISEi4Hz7RAkhISEhI7DwYNWoUxo0bl+UcrV69Gqqq4sQTT8x6j/w+mJ2jt99+G08//TSuvfZa/PKXvzS998c//hGdnZ1iBBtk6OvrQ2VlZdbrM2bMQCgUwuuvv46f/exn+uurVq3CsGHDMGPGDLz++uv40Y9+pL/HSq9SqRRisZit75CQkJCQGNqQmW4JCQkJCa445JBD8N5776G/v19/bdWqVZgyZQqOPvpovPnmm0ilUqb3FEXBwQcfDABYtmwZjjjiCIwYMQLBYBCTJ0/G7bffnnWeVCqFq666CqNGjUJlZSUOP/xwfPzxxxg7dixOP/1007H/+c9/MHv2bFRUVGD06NFYsmQJli1bBkVRsGHDhoJ/TzQaxeLFizFhwgQEg0GMGTMGl156KaLRqH7Mf//7XwDQ/wYaXq8Xw4YNM722efNmLFq0CKNGjUIwGMS4cePwk5/8JMu5i0ajuOiii9DY2Iiqqip897vfRVtbW9Y5nnvuORx66KGoqqpCTU0NFixYgHXr1mUd98QTT2DvvfdGKBTC3nvvnbMMIF9NMqlpvvfee/NeK4K//e1vmD59OioqKtDQ0IDvf//72LRpk+mYOXPmYO+998Y777yDww47DJWVlVkBC4JAIIADDjggK5u9atUqzJw5EwcffHDO9+rq6rD33nsDAHp7e3HxxRdjzJgxCAaD2GuvvXDjjTdCVVXT5xRFwXnnnYcHHngAU6ZMQTAYxPLly3PKpaoqzj77bAQCATz22GMFr8kjjzyiX5Phw4fjRz/6ETZv3mw65j//+Q9OP/10jB8/HqFQCM3Nzfjf//1fbN++Pev7Xn/9dRxwwAEIhULYfffdceeddxY8v4SEhISEc5CZbgkJCQkJrjjkkENw//33Y82aNXpTslWrVmHWrFmYNWsWurq68NFHH2Hq1Kn6exMnTtQd09tvvx1TpkzBcccdB5/Ph6eeego//elPkUqlcO655+rnueyyy3DDDTfgO9/5DubPn48PPvgA8+fPx8DAgEmezZs34/DDD4eiKLjssstQVVWFu+++G8FgsOjfkkqlcNxxx+H111/H2WefjUmTJuHDDz/ELbfcgs8//xxPPPEEAGC33XYDADzwwAM4+OCD4fPlX363bNmCAw88EJ2dnTj77LMxceJEbN68GY8++ij6+voQCAT0Y3/2s5+hvr4eixcvxoYNG7B06VKcd955eOihh/Rj7r//fpx22mmYP38+fvvb36Kvrw+33367HvwgTdJeeOEFnHDCCZg8eTKuv/56bN++HWeccQZGjx5d9DqUgmuvvRZXXHEFTjrpJJx55ploa2vDH/7wBxx22GF47733UFdXpx+7fft2HH300fj+97+PH/3oR2hqasr7vYcccghee+01bNiwQf+bVq1ahTPPPBMHHnggFi9ejM7OTtTV1UFVVbzxxhuYOXMmPB4PVFXFcccdh5deegmLFi3CtGnT8Pzzz+OSSy7B5s2bccstt5jO9e9//xsPP/wwzjvvPAwfPjxno7lkMon//d//xUMPPYTHH38cCxYsyCv7vffeizPOOAMHHHAArr/+erS2tuLWW2/FqlWrTNdkxYoV+Oqrr3DGGWegubkZ69atw1133YV169bhzTff1Jukffjhh5g3bx4aGxtx1VVXIZFIYPHixQWvn4SEhISEg1AlJCQkJCQ4Yt26dSoA9de//rWqqqoaj8fVqqoq9b777lNVVVWbmprU2267TVVVVY1EIqrX61XPOuss/fN9fX1Z3zl//nx1/Pjx+u8tLS2qz+dTFy5caDruqquuUgGop512mv7az372M1VRFPW9997TX9u+fbva0NCgAlDXr1+vvz579mx19uzZ+u/333+/6vF41Ndee810njvuuEMFoK5atUpVVVVNpVLq7NmzVQBqU1OTesopp6i33Xab+vXXX2f9Laeeeqrq8XjUt99+O+u9VCqlqqqqLlu2TAWgzp07V39NVVX1wgsvVL1er9rZ2amqqqp2d3erdXV1putHrk9tba3p9WnTpqkjR47UP6uqqvrCCy+oANTddttNf+2ll15SAagvvfSS6TvXr1+vAlCXLVumv7Z48WKV3mps2LBB9Xq96rXXXmv67Icffqj6fD7T6+R63XHHHVnXIReeeeYZFYB6//33q6qqqlu3blUBqK+88ora3d2ter1e9ZlnnlFVVVU/+ugjFYB+vieeeEIFoC5ZssT0nf/zP/+jKoqifvnll/prAFSPx6OuW7cu59//u9/9To3H4+rJJ5+sVlRUqM8//7zpuMzrF4vF1BEjRqh777232t/frx/39NNPqwDUK6+8Un8tl+7/4x//UAGor776qv7awoUL1VAoZNKvjz/+WPV6varc+klISEjwh6SXS0hISEhwxaRJkzBs2DC9pvaDDz5Ab2+v3p181qxZOhV49erVSCaTprrbiooK/eeuri60t7dj9uzZ+Oqrr9DV1QUAWLlyJRKJBH7605+azk3X+xIsX74cM2fOxLRp0/TXGhoa8MMf/rDo3/LII49g0qRJmDhxItrb2/V/RxxxBADondgVRcHzzz+PJUuWoL6+Hv/4xz9w7rnnYrfddsPJJ5+s13SnUik88cQT+M53voMZM2ZknS9z3NPZZ59teu3QQw9FMpnE119/DUDLjHZ2duKUU04xyef1enHQQQfp8m3duhXvv/8+TjvtNNTW1urf9+1vfxuTJ08ueh2s4rHHHkMqlcJJJ51kkqe5uRl77LFHVuf6YDCIM844w9J3z5o1Cx6PR9erVatWwe/344ADDkB1dTWmTp2q6xX5n+jVs88+C6/Xi/PPP9/0nRdffDFUVcVzzz1nen327Nl5r0ssFsOJJ56Ip59+Gs8++yzmzZtXUO61a9di27Zt+OlPf4pQKKS/vmDBAkycOBHPPPOM/hqt+wMDA2hvb8e3vvUtAMC7774LQMuwP//881i4cCF23XVX/fhJkyZh/vz5BWWRkJCQkHAGkl4uISEhIcEViqJg1qxZePXVV5FKpbBq1SqMGDECEyZMAKA5T3/84x8BZDtH5LXFixdj9erV6OvrM313V1cXamtrdaeTfCdBQ0MD6uvrTa99/fXXmDlzZpacmZ/NhS+++AKffPIJGhsbc76/bds2/edgMIhf/epX+NWvfoWtW7filVdewa233oqHH34Yfr8ff/vb39DW1oZIJKLXGRcD7VQB0P+2HTt26PIB0IMAmQiHwwCgX6899tgj65i99tpLd+js4osvvoCqqjnPAwB+v9/0+y677GKi0xcCGcFGO9b77bef7qjSwZxVq1YhEAjgwAMPBKD9/aNGjUJNTY3pOydNmqS/T2PcuHF55bj++uvR09OD5557ztJMd/Lde+21V9Z7EydONDUW7OjowNVXX40HH3zQpFsA9IBTW1sb+vv7897LZ599tqhMEhISEhJsIZ1uCQkJCQnuOOSQQ/DUU0/hww8/1Ou5CWbNmqXX0r7++usYNWoUxo8fD0BrSHbkkUdi4sSJuPnmmzFmzBgEAgE8++yzuOWWW0wN2HgglUphn332wc0335zz/TFjxuR8feTIkfj+97+PE044AVOmTMHDDz9sqQFZJrxeb87X1XTzL3I97r//fjQ3N2cdV6i2PB8ys+0EyWSy6GdTqRQURcFzzz2XU/bq6mrT73Rm1woOOeQQ3HHHHejs7MypV3/5y18Qj8fx+uuvY/r06abMcikoJNf8+fOxfPly3HDDDZgzZ07Z58iFk046CW+88QYuueQSTJs2DdXV1UilUjjqqKO4676EhISEhHVIp1tCQkJCgjvoucqrVq3CBRdcoL83ffp0BINBvPzyy1izZg2OOeYY/b2nnnoK0WgU//rXv0xZ3kxaMmlc9uWXX5qyktu3b9ezwPSxX375ZZaMuV7LxO67744PPvgARx55ZF5ntBD8fj+mTp2KL774Au3t7RgxYgTC4TA++uijkr8rn3wAMGLECMydOzfvceR6kcw4jc8++8z0O8mmZ445y8wG55NHVVWMGzcOe+65Z9HjS8UhhxyC22+/HS+++CLee+89XHLJJfp7s2bNQn9/P5555hl89dVXOOGEE/T3dtttN7z44ovo7u42Zbs//fRT/X2r+Na3voVzzjkHxx57LE488UQ8/vjjBYMb5Ls/++yzLEbCZ599pr+/Y8cOrFy5EldffTWuvPJK/ZjMe9bY2IiKigpL91JCQkJCgg9kTbeEhISEBHeQucoPPPAANm/ebMpIBoNB7L///rjtttvQ29tropaT7KhKjXHq6urCsmXLTN9/5JFHwufzZY0SI7R1GvPnz8fq1avx/vvv6691dHTggQceKPp3nHTSSdi8eTP+/Oc/Z73X39+P3t5eAJpjtHHjxqxjOjs7sXr1atTX16OxsREejwcLFy7EU089hbVr12Ydr2aMryqG+fPnIxwO47rrrkM8Hs96n4wXGzlyJKZNm4b77rtPpykDWk34xx9/bPrMbrvtBq/Xi1dffdX0+p/+9Kei8nzve9+D1+vF1VdfnfW3qKqac/RVKSC6cvPNNyMej5v0auzYsRg5ciRuuOEG07EAcMwxxyCZTGbpxy233AJFUXD00UeXJMfcuXPx4IMPYvny5fjxj39cMAs9Y8YMjBgxAnfccYdpzNxzzz2HTz75RO96nkv3AWDp0qWm371eL+bPn48nnnjCpHOffPIJnn/++ZL+DgkJCQkJNpCZbgkJCQkJ7iBzlV977TUEg0FMnz7d9P6sWbNw0003ATA7R/PmzUMgEMB3vvMd/N///R96enrw5z//GSNGjMDWrVv145qamvDzn/8cN910E4477jgcddRR+OCDD/Dcc89h+PDhpqz0pZdeir/97W/49re/jZ/97Gf6yLBdd90VHR0dBTPYP/7xj/Hwww/jnHPOwUsvvYSDDz4YyWQSn376KR5++GE8//zzmDFjBj744AP84Ac/wNFHH41DDz0UDQ0N2Lx5M+677z5s2bIFS5cu1Z2q6667Di+88AJmz56tjyHbunUrHnnkEbz++uumkVrFEA6Hcfvtt+PHP/4x9t9/f3z/+99HY2MjNm7ciGeeeQYHH3yw7mhef/31WLBgAQ455BD87//+Lzo6OvCHP/wBU6ZMQU9Pj/6dtbW1OPHEE/GHP/wBiqJg9913x9NPP51VY5wLu+++O5YsWYLLLrsMGzZswMKFC1FTU4P169fj8ccfx9lnn41f/OIXlv++TOy6664YM2YMVq9ejbFjx2LUqFGm92fNmoV//vOfprnvAPCd73wHhx9+OH71q19hw4YN2HffffHCCy/gySefxAUXXKAzBkrBwoULsWzZMpx66qkIh8N552T7/X789re/xRlnnIHZs2fjlFNO0UeGjR07FhdeeCEA7V4edthhuOGGGxCPx7HLLrvghRdewPr167O+8+qrr8by5ctx6KGH4qc//SkSiYR+L//zn/+U/LdISEhISNiEsL7pEhISEhI7NS677DIVgDpr1qys9x577DEVgFpTU6MmEgnTe//617/UqVOnqqFQSB07dqz629/+Vv3LX/6SNd4rkUioV1xxhdrc3KxWVFSoRxxxhPrJJ5+ow4YNU8855xzTd7733nvqoYceqgaDQXX06NHq9ddfr/7+979XAagtLS36cZkjw1RVG/n029/+Vp0yZYoaDAbV+vp6dfr06erVV1+tdnV1qaqqqq2trepvfvMbdfbs2erIkSNVn8+n1tfXq0cccYT66KOPZv39X3/9tXrqqaeqjY2NajAYVMePH6+ee+65ajQaVVXVGBmWOVYs3zivl156SZ0/f75aW1urhkIhdffdd1dPP/10de3atabj/vnPf6qTJk1Sg8GgOnnyZPWxxx5TTzvtNNPIMFVV1ba2NvWEE05QKysr1fr6evX//u//9DFchUaG0ec55JBD1KqqKrWqqkqdOHGieu6556qfffaZ6VpPmTIl67PFcMopp6gA1B/84AdZ7918880qAHXSpElZ73V3d6sXXnihOmrUKNXv96t77LGH+rvf/c40kk1VtZFh5557btbn6ZFhNP70pz+pANRf/OIXqqrmv0cPPfSQut9++6nBYFBtaGhQf/jDH6rffPON6ZhvvvlG/e53v6vW1dWptbW16oknnqhu2bJFBaAuXrzYdOwrr7yiTp8+XQ0EAur48ePVO+64I+/9kJCQkJBwFoqqlshVk5CQkJCQGKTo7OxEfX09lixZgl/96lcFj73gggtw5513oqenJ2/DMgkJCQkJCQmJYpA13RISEhISQxL9/f1Zr5H618xRTpnHbt++Hffffz8OOeQQ6XBLSEhISEhI2IKs6ZaQkJCQGJJ46KGHcO+99+KYY45BdXU1Xn/9dfzjH//AvHnzTPW8ADBz5kzMmTMHkyZNQmtrK+655x5EIhFcccUVgqSXkJCQkJCQGCqQTreEhISExJDE1KlT4fP5cMMNNyASiejN1ZYsWZJ17DHHHINHH30Ud911FxRFwf7774977rkHhx12mADJJSQkJCQkJIYSZE23hISEhISEhISEhISEhIRDkDXdEhISEhISEhISEhISEhIOQTrdEhISEhISEhISEhISEhIOQTrdEhISEhISEhISEhISEhIOQTZSs4BUKoUtW7agpqYGiqKIFkdCQkJCQkJCQkJCQkJCMFRVRXd3N0aNGgWPJ38+WzrdFrBlyxaMGTNGtBgSEhISEhISEhISEhISLsOmTZswevTovO9Lp9sCampqAGgXMxwOC5ZGQkJCQkJCQkJCQkJCQjQikQjGjBmj+4v5IJ1uCyCU8nA4LJ1uCQkJCQkJCQkJCQkJCR3FSpBlIzUJCQkJCQkJCQkJCQkJCYcgnW4JCQkJCQkJCQkJCQkJCYcgnW4JCQkJCQkJCQkJCQkJCYcga7olJCQkJCQkJCQkJAYdVFVFIpFAMpkULYrEEIXX64XP57M9Nlo63RISEhISEhISEhISgwqxWAxbt25FX1+faFEkhjgqKysxcuRIBAKBsr9DOt0SEhISEhISEhISEoMGqVQK69evh9frxahRoxAIBGxnIiUkMqGqKmKxGNra2rB+/Xrsscce8HjKq86WTreEhISEhISEhISExKBBLBZDKpXCmDFjUFlZKVociSGMiooK+P1+fP3114jFYgiFQmV9j2ykJiEhISEhISEhISEx6FBu1lFCohSw0DOpqRISEhISEhISEhISEhISDkE63RISEhISEhISEhISEoMUV111FaZNmyZaDIkCkE73EMGX27rxz3e+wdsbOkSLIiGRhXgyhVc/b0NvNCFaFAmJLCSSKbz2RRt6pH5KuBBEP7sH4qJFkZDIQjKl4rUv2hCR+jlksGHDBiiKgvfffz/rvUceeQQTJ05EKBTCPvvsg2effdb0vqqquPLKKzFy5EhUVFRg7ty5+OKLL0zHXHvttZg1axYqKytRV1dnWa4vv/wSZ5xxBkaPHo1gMIhx48bhlFNOwdq1a/VjFEXR/9XW1uLggw/Gv//9b/39OXPm4IILLsj67nvvvbckWcqBdLqHCJ76YCsufuQDPP7eZtGiSEhk4bF3v8Gpf3kLS1/8XLQoEhJZeOL9LfjxPW/h5hekfkq4D0//Zyt+fM9buPH5z0SLIiGRhWc+1PTzt899KloUCYfxxhtv4JRTTsGiRYvw3nvvYeHChVi4cCE++ugj/ZgbbrgBv//973HHHXdgzZo1qKqqwvz58zEwMKAfE4vFcOKJJ+InP/mJ5XOvXbsW06dPx+eff44777wTH3/8MR5//HFMnDgRF198senYZcuWYevWrVi1ahWGDx+OY489Fl999ZX9C2AT0ukeImiu1TrptXQNFDlSQoI/PmvpAQB83tojWBIJiWx83toNAPhiW7dgSSQksvFZWj+l/ZRwIz5vSdtPqZ+WMGfOHJx//vm49NJL0dDQgObmZlx11VWmYzZu3Ijjjz8e1dXVCIfDOOmkk9Da2mo65je/+Q2amppQU1ODRYsWmZxagrvvvhuTJk1CKBTCxIkT8ac//cmSjOPGjQMA7LffflAUBXPmzAEA3HrrrTjqqKNwySWXYNKkSfj1r3+N/fffH3/84x8BaFnupUuX4vLLL8fxxx+PqVOn4q9//Su2bNmCJ554Qv/+q6++GhdeeCH22WcfS/KoqorTTz8de+yxB1577TUsWLAAu+++O6ZNm4bFixfjySefNB1fV1eH5uZm7L333rj99tvR39+PFStWWDqXk5BO9xBBc1g63RLuRUukX/tf6qeEC7E1rZdbpX5KuBDEbrZEpH5KuA+6/Uyv86Kgqir6Ygkh/1RVLUnW++67D1VVVVizZg1uuOEGXHPNNbpTmEqlcPzxx6OjowOvvPIKVqxYga+++gonn3yy/vmHH34YV111Fa677jqsXbsWI0eOzHKoH3jgAVx55ZW49tpr8cknn+C6667DFVdcgfvuu6+ofG+99RYA4MUXX8TWrVvx2GOPAQBWr16NuXPnmo6dP38+Vq9eDQBYv349WlpaTMfU1tbioIMO0o8pB++//z7WrVuHiy++OGcX8UK08IqKCgBadl005JzuIYKmtNPdKhdlCRdCbhol3IzWtH62SqdbwoXQ7WfXAFRVhaIogiWSkDBA9p2tkahQ/eyPJzH5yueFnPvja+ajMmDdpZo6dSoWL14MANhjjz3wxz/+EStXrsS3v/1trFy5Eh9++CHWr1+PMWPGAAD++te/YsqUKXj77bdxwAEHYOnSpVi0aBEWLVoEAFiyZAlefPFFU7Z78eLFuOmmm/C9730PgJa9/vjjj3HnnXfitNNOKyhfY2MjAGDYsGFobm7WX29paUFTU5Pp2KamJrS0tOjvk9fyHVMOSE34xIkTS/pcX18fLr/8cni9XsyePbvs87OCzHQPEYxM08u398YQTSQFSyMhYUZrJAoA6OqPYyAu9VPCXSDBoO5oQjb7k3AdiFPTH08iMiD1U8JdIPYzlkhhR59spmYFU6dONf0+cuRIbNu2DQDwySefYMyYMbrDDQCTJ09GXV0dPvnkE/2Ygw46yPQdM2fO1H/u7e3Ff//7XyxatAjV1dX6vyVLluC///2vU3+WYyiVSXDKKaeguroaNTU1+Oc//4l77rkn65qLgMx0DxHUVfoR8HkQS6SwLRLFmIZK0SJJSAAAUinVxMBo6RrA2OFVAiWSkDCgqqqJgdESGcDujdUCJZKQMJCpn62RAdRW+AVKJCFhBs0QaukaQENVQIgcFX4vPr5mvrBzlwK/3/wMK4qCVCrFTJ6eHq2+/s9//nOWc+71liYrjebm5qza8tbWVj0bTv5vbW3FyJEjTcfYGWe25557AgA+/fRT7LfffkWPv+WWWzB37lzU1tbqWXuCcDiMrq6urM90dnaitra2bBmtQGa6hwgURTHquiWFV8JFaO+NIpEyopSyblbCTdjRF0csYWx2ZN8BCTchMpBAX8xgB0n7KeEm9EQT6KbYQS0C67oVRUFlwCfkH0tK/aRJk7Bp0yZs2rRJf+3jjz9GZ2cnJk+erB+zZs0a0+fefPNN/eempiaMGjUKX331FSZMmGD6R5qkFUIgoAVOkkkzM3HmzJlYuXKl6bUVK1boWfZx48ahubnZdEwkEsGaNWtMmfhSMW3aNEyePBk33XRTzuBEZ2en6ffm5mZMmDAhy+EGgL322gvvvvtu1uvvvvuu7tw7BZnpHkJorg1hY0ef3DRKuAqtXVHz7zIoJOEiZNpLaT8l3IRMeyn7Dki4Cdn2M5rnSAmrmDt3LvbZZx/88Ic/xNKlS5FIJPDTn/4Us2fPxowZMwAAP//5z3H66adjxowZOPjgg/HAAw9g3bp1GD9+vP49V199Nc4//3zU1tbiqKOOQjQaxdq1a7Fjxw5cdNFFBWUYMWIEKioqsHz5cowePRqhUAi1tbX4+c9/jtmzZ+Omm27CggUL8OCDD2Lt2rW46667AGiBjwsuuABLlizBHnvsgXHjxuGKK67AqFGjsHDhQv37N27ciI6ODmzcuBHJZFKfBz5hwgRUV2czzRRFwbJlyzB37lwceuih+NWvfoWJEyeip6cHTz31FF544QW88sorlq7vT37yE/zxj3/E+eefjzPPPBPBYBDPPPMM/vGPf+Cpp56y9B3lQma6hxBkB3MJNyKTeSGZGBJuQqZTI/VTwk3Icmqkfkq4CNJ+soeiKHjyySdRX1+Pww47DHPnzsX48ePx0EMP6cecfPLJuOKKK3DppZdi+vTp+Prrr7NmXp955pm4++67sWzZMuyzzz6YPXs27r33XkuZbp/Ph9///ve48847MWrUKBx//PEAgFmzZuHvf/877rrrLuy777549NFH8cQTT2DvvffWP3vppZfiZz/7Gc4++2wccMAB6OnpwfLlyxEKhfRjrrzySuy3335YvHgxenp6sN9++2G//fbD2rVr88p04IEHYu3atZgwYQLOOussTJo0CccddxzWrVuHpUuXWr28GD9+PF599VV8+umnmDt3Lg466CA8/PDDeOSRR3DUUUdZ/p5yoKilVqfvhIhEIqitrUVXVxfC4bBocfLiumc/wV2vfoVFh4zDFcdOFi2OhAQA4P7VG3DFk+v030+fNRZXHTdFoEQSEgb+vmYjfvn4h/rvP/7Wbvj1wr0LfEJCgh8efnsTLv3nf/TfTzlwV1z/PWuzbSUknMaj73yDXzzygf77STNG44b/2ZfLuQcGBrB+/XqMGzfO5NBJSDiBQvpm1U+Ume4hhCZZ0y3hQhB99Hu1mifJxJBwE7L0U9pPCRchUz9leY6Em9CaZT8lvVxCIh+EOt233347pk6dinA4jHA4jJkzZ+K5557T3x8YGMC5556LYcOGobq6GieccEJW17yNGzdiwYIFqKysxIgRI3DJJZcgkTCP1Hj55Zex//77IxgMYsKECbj33nt5/HncQcaGyZovCTeB1HhNHqlF/6RTI+EmEHtJ9FM6NRJuArGXuv2U67uEi9CSaT+lfg4KXHfddaZRYvS/o48+WrR4QxZCG6mNHj0av/nNb7DHHntAVVXcd999OP744/Hee+9hypQpuPDCC/HMM8/gkUceQW1tLc477zx873vfw6pVqwBoXfUWLFiA5uZmvPHGG9i6dStOPfVU+P1+XHfddQCA9evXY8GCBTjnnHPwwAMPYOXKlTjzzDMxcuRIzJ8vZrSAUyCZbtndVMJNIE7MtDF1+OCbLunUSLgKLRn6KZ0aCTeBODHSfkq4EVn2U+rnoMA555yDk046Ked7FRUVnKXZeSDU6f7Od75j+v3aa6/F7bffjjfffBOjR4/GPffcg7///e844ogjAADLli3DpEmT8Oabb+Jb3/oWXnjhBXz88cd48cUX0dTUhGnTpuHXv/41/t//+3+46qqrEAgEcMcdd2DcuHG46aabAGht9l9//XXccsstQ87pbk5nurd1DyCVUuHxsBthUBJUFWA4PmHQyuAWOUjbBkFybO3SRohM27UO963+Gtu6o0imVHilfoqVwS1yCNZP4mQT/WzriSKeTMHvFUQEc8s9ES2DW+QQbj/N+rm9N4ZoIomgr/xZu7bglnsiWga3yOEy+9nVH0d/LImKgNRP4SggR0NDAxoaGvjIALjjergArqnpTiaTePDBB9Hb24uZM2finXfeQTwex9y5c/VjJk6ciF133RWrV68GAKxevRr77LMPmpqa9GPmz5+PSCSCdevW6cfQ30GOId+RC9FoFJFIxPRvMGBETRCKAsSTKjr6YmKE+Nf5wNJ9gP5OMecHgO5W4Ka9gOd/JU4GAHj7buC3Y4HN2fMAuSGVAu4+ErjvO4bx44zWdI3XlFG18HoUJFMq2nsE1X09fSFwyxSgf4eY8wNATxtw00Rg+WXiZACAtcs0/fwmf7dQx5FKAffMA5YdI0w/DfpuLfxeBaoKtHUL0s9nLwFungz0dYg5P6Cd++bJmiwi8e5fNf3c9JY4GVQVWHa0pqM5ZsPyAMls79UURsCnbdm2iaqbfe7/A26epNkwUejr0Gz40xeKkwEA3nsA+O1uwNf595KOQ1WBe48F7p4rTD+J/ZzQWIPKtKMtLNvdtRlo/QhIxsWcHwBSCWDbx0DnRnEyANpz0vIhEO0WJ4OqAtu/BNo/F7a+uw3Cne4PP/wQ1dXVCAaDOOecc/D4449j8uTJaGlpQSAQQF1dnen4pqYmtLS0AABaWlpMDjd5n7xX6JhIJIL+/v6cMl1//fWora3V/40ZM4bFn+o4/F4PhlcHAQis+/rsOaBrE9C6rvixTmHzO0BPK/D58+JkAIAvVgADncDXb4iToXebdj02vAbEerifvieaQE9U67Ewqq4CjcL1czkQ2awtRqKw5T2gp0V7VkSC6OeG18XJ0N8BfPMWsPENYKCL/+ljSXT1axu05toQRtQIbkb52XNA9xZg6/tizg9o+tm9Bfh8uTgZAEM/178qTob+HcDG1ZqOCgjURRNJbO/VAujNtSFjLKgo/fz8OaB7q1j9bPmPZsNFr+9fvqjZrA2viZMh2g18/TqweS3Qyz8QEk+m9AB6U21Q/NjagS7N6Y33iTk/AMT7gWRMyHpmQjQCqEkgyn/fp0NNafvOeB+QEhgIcRGEO9177bUX3n//faxZswY/+clPcNppp+Hjjz8WKtNll12Grq4u/d+mTZuEylMKhBu9aMT8/84qAwAMuECOgUjunzmB6GFN0IfqoE8vgRDWd4DcCwHXIksG0frpBjnojYkAOYjzUhnwIhwy9FPcptFF+ilSBloON6wlABDlv4kmGe2Az4P6Sr94+6nrp0CHwg3PCEA9JwKvhUk/+V+Ptu4oVBXweRQMrwoa9jOSO6HlONSk9n8qKeb8gME4EMQ8MORIXwNV4LVQqWsg8p64CEJrugEgEAhgwoQJAIDp06fj7bffxq233oqTTz4ZsVgMnZ2dpmx3a2srmpubAQDNzc146y0z9Yx0N6ePyex43trainA4nLdZQDAYRDAYZPL38UZTOIQPNwtqZpGIAYn0eUUuiK5blN2yaYwA2IXr6Ynz0pRejElQSEgzoFTSyPa7wdEciIit/aLlEIWoO4JCzeEQFEURG7RMpdzhaOrBwm7B+ukC+yk6aBnJrZ9COkSrqjv0k5w71q3ZdI+g2mEZVNeDP03hEDwe2n4KKn9whaNJzp3SnE5FVG8QNwQgqHOrgoMQLoHwTHcmUqkUotEopk+fDr/fj5UrV+rvffbZZ9i4cSNmzpwJAJg5cyY+/PBDbNu2TT9mxYoVCIfDmDx5sn4M/R3kGPIdQw362DARTo3gqKtx7rQzkegXW9vjikWZisIL3jQCoCLhgvXTDY5mKm4EqUTK4ZZNowA5iJ0kkx+aRAaFYj0A0nVvbtBPNQnEesXL4QYHT5AcdFAIEGw/4/0adRdwTyBEZL2q64Lq/DPuhv3UklRNIvefagq6/XSLoyky2+2qAARkpjsNoU73ZZddhldffRUbNmzAhx9+iMsuuwwvv/wyfvjDH6K2thaLFi3CRRddhJdeegnvvPMOzjjjDMycORPf+ta3AADz5s3D5MmT8eMf/xgffPABnn/+eVx++eU499xz9Uz1Oeecg6+++gqXXnopPv30U/zpT3/Cww8/jAsvFNyEwyEIpZ+ZHDwX0M8yf+YNsgjuxPQzsvgSvWwWOUtesIOXUw43bF7dsmkUGBQiwcqRbgkKuUU/3SCHG54RQXJk2U+RNd1u0U+3yOGKoLo7mEIjayvS/4tkCtFZVZc4mpzluOqqqzBt2rT0uQnN3SUBCJH3xEUQ6nRv27YNp556Kvbaay8ceeSRePvtt/H888/j29/+NgDglltuwbHHHosTTjgBhx12GJqbm/HYY4/pn/d6vXj66afh9Xoxc+ZM/OhHP8Kpp56Ka665Rj9m3LhxeOaZZ7BixQrsu+++uOmmm3D33XcPuXFhBEIzNW5ZDAVHfwGkqXjd2fLwhmlR5n8tyLgwPVMjcpZ8VOy1yCmHKN1wC1VUsIOXWf7QJDRo6ZJgjNsYIa5ZS8TRdzODlkKcGrfop1vkcF2mW1zQMpMptFVIpttlGebMn0XJUaazu2HDBiiKgvfffz/rvUceeQQTJ05EKBTCPvvsg2effdb0vqqquPLKKzFy7J6o2H0m5p58Dr74/HPTdy9atAjjxo1DRUUFdt99dyxevBixWPGpS++99x5OPPFENDU1IRQKYY899sBZZ52Fz9PfT+Qm/4YNG4Z58+bhvffe079j7NixWLp0adZ3m4IWDkFoTfc999xT8P1QKITbbrsNt912W95jdtttt6wbnok5c+aYLvhQhtCaRLcshm6QI9ZjRBp35kW5i3Q2dQF9120ZvMyfecItVFHBgZAs+q4MWrrjOXFbfxBBcuRzaoSs727Rz6jY5osA3NcfBBDbE6NWY5YK7TmQcknTLoGZbuO8KlXTzTYA8cYbb+CUU07B9ddfj2OPPRZ///vfsXDhQrz77rvYe++9AQA33HADfv/73+O+O/+AccMCuOJ3t2P+wpPw8SefIRQK4dNPP0UqlcKdd96JCRMm4KOPPsJZZ52F3t5e3HjjjXnP/fTTT+OEE07A/Pnz8cADD2D33XfHtm3b8Mgjj+CKK67AQw89pB/74osvYsqUKfjmm29w/vnn4+ijj8ann36aNRGLN1xX0y1hD0Ij4a5ZlF0ghxs2rplyiKRH5qhJVHnPbXRbBg8Qx8RwgwyA8Ock06mhg5bc9VMwK0WHG54TN9hwQLiD15qnpntb9wBSKd76KdbBy3luN+ina9YSF9jPtH629USRSHLONrvB2QUsZbrnzJmD888/H5deeikaGhrQ3NyMq666ynTMxo0bcfzxx6O6uhrhcBgnnXRSVlPo3/zmN2hqakJNTQ0WLVqEgYH0vp9qWnb33x7GpEmTEAqFMHHiRPzpT3+y9GeMGzcOALDffvtBURTMmTMHAHDrrbfiqKOOwiWXXIJJkybh17/+Nfbff3/88Y9/1E6tqli6dCkuv/xyHL9gHqZO3hN/vfUabNnaiieeeAIAcNRRR2HZsmWYN28exo8fj+OOOw6/+MUvTEzmTPT19eGMM87AMcccg3/961+YO3cuxo0bh4MOOgg33ngj7rzzTtPxw4YNQ3NzM2bMmIEbb7wRra2tWLNmjaW/3UlIp3uIgRi97mgCven5yNzghsXQLXLIRRlAds0s2Tz2xZKIDAjUz504EOIaGQDhz4lRk6jp5Yh0Q6BoIoXOPs5NGN3iaJrGuAly/l3p4IkozzHTy0fUBKEoQDyp6vO7ucEt+ukGOeRaAsAIqpOa7uHVQXg9CpIpFe09nPUzldQyvPF+bTZ1rJfvPxKktej833fffaiqqsKaNWtwww034JprrsGKFSu0PyWVwvHHH4+Ojg688sorWLFiBb766iucfPLJ+ucffvhhXHXVVbjuuuuwdu1ajBw50nCo087+A489iyt/dxuuvfZafPLJJ7juuutwxRVX4L777it6OclkqBdffBFbt27VHeLVq1dj7ty5pmPnz5+P1atXAwDWr1+PlpYW7Zh0lr02XIODpk/Tj8mFrq4uNDQ05H3/+eefR3t7Oy699NKc7xfKYJNJVVbo605D+MgwCbaoTs9D7okm0BIZwO6N1fxO7obF0C1yyEUZ8WQK7T1penna2a4IeFFb4UdXfxytkQHUVvj5CSQDIXlkEDgaSuCc7mRKRVtaP4lTE/J70VAVQEdvDC2RAdRXBfgJ5BZH0w3PCS2DyNFQAp/VVErFtm6z0+33ejC8Ooi27ihaIwNorOE42tQtgTo3MEJoXYj3aVNSvBzXslxycNZPVVWNoFB6ffd6FIyoCWJr1wBaIgO63vIRKKmVpCw7mt85afxyCxCoskxznzp1KhYvXgwA2GOPPfDHP/4RK1euxLe//W2sXLkSH374IdavX48xY8YAAP76179iypQpePvtt3HAAQdg6dKlWLRoERYtWgQAWLJkCV588UUt25129hffdAduuvIifG/hQsDjwbhx4/Dxxx/jzjvvxGmnnVbwz2lsbARgZIwJWlpa0NTUZDq2qakJLS0t+vvkNTro0NQ4XH8vE19++SX+8Ic/FKSWf/HFFwCAiRMnFpQ7E52dnfj1r3+N6upqHHjggSV91gnITPcQhLAO0a5clF2waUzGgLig0VACF+Vt3VGoKuD3KhhGOS/C+g4IdPDMcrhAP+lrIXI0lEAHr70nimRKhdejYHi14bw0ieoQ7YZgDOCOgGGmLogaDSXwWe3oiyGeVKEoWoabQJj9dEtJihueE1fqJ9970tkXRyyhOZiEIQQI7DvglpFUpkx3for91KlTTb+PHDlSH3/8ySefYMyYMbrDDQCTJ09GXV0dPvnkE/2Ygw46yPQd+ijkVBK9ff3474ZvsOjia1AdDqO6uhrV1dVYsmQJ/vvf/9r5C63DdE9yl8Ns3rwZRx11FE488UScddZZeb+q1HKvWbNmobq6GvX19fjggw/w0EMPZQULREBmuocgmsMhfLmth38HXjcshm6RI3MBjEYAP8eoby45OG8ayaI7oiYEj8fIojbXhvBZa7dYp8YNo+QAd2S6ye9BjqwYAoEOnqGfGiWSYGRtCJ9sjey8QUs3PCe59LOiTqwcgvRzeHUQfq+RH2muDeHDzV387adb9NMNcmTqwkAXUJmfGstFDt76mda/hqoAQn6DhTKyNoT3NwloRqkmAV8IOOM5QPECzXvzPb+/UvvfYvdyv9/MjFAUBSlWTc/UJHp6+wAAf/7d5TjoyIWA3wiMeL3ls4aam5uzastbW1v1bDj5v7W1FSN3DRvHbGvDtAMmmD63ZcsWHH744Zg1axbuuuuugufdc889AQCffvqpEVwogIceegiTJ0/GsGHDsqjn4XAYXV3ZQarOzk7U1tYW/W47kJnuIQhhmRo30CPprqKAO+hngDs2B5wX5cwZswTiMt0uCMbQo+QAd9R0i5RDoINHgpLEXhI0iRpr54Zgoaq64zlxi34KdPAyO+sTuCPT3W3UsPKGG56TrEy3C+TgrZ8Rl9nPVEorkfJXAL6A5gQHqvj9I+VZDBq6TZo0CZs2bcKmTZv01z7++GN0dnZi8uTJ+jGZjcHefPPN9LVIoqlxGEY1N+Krrzdjwu5jMWHCBP0faZJWCIGAxk5MJs1/w8yZM7Fy5UrTaytWrNAd4XHjxqG5uVk7Jh10iHT3YM27H5ic5c2bN2POnDmYPn06li1bBo+nsDs6b948DB8+HDfccEPO9zs7O02/jxkzBrvvvnvOWu+99toL77zzTtbr7777ru7cOwWZ6R6CIOMbuEca3VCHlytDIgJZi7KohkTinZrMTWNTraCgkBvq8OhRcpky8YQbnxNRQaE8Tg13+0lfC1KSwpsdkxgAUlQDOTcEY3L9LkIOQZnETKemWZT9pHWBlKTwZsfQo+QyZeIJGVSngkLmvgJ6eaOITHfm7wpnF0dVzet7mZT3uXPnYp999sEPf/hDLF26FIlEAj/96U8xe/ZszJgxAwDw85//HKeffjpmzJiBgw8+GA888ADWrVuH8ePH69fi6ovPwflX/A61zWNx1HcWIhqNYu3atdixYwcuuuiigjKMGDECFRUVWL58OUaPHo1QKITa2lr8/Oc/x+zZs3HTTTdhwYIFePDBB7F27Vo9U60oCi644AIsWbIEe4yowLhRw3HF727HqKYRWLhwIQDD4d5tt91w4403oq2tTT8vXT9Oo6qqCnfffTdOPPFEHHfccTj//PMxYcIEtLe34+GHH8bGjRvx4IMPWrq+F154IQ499FBce+21+N73vodkMol//OMfWL16teXu7uVCZrqHIJrTnSS5RxrdUOfklgyJKxdlvo5/a75No6hZnq7UTxcEY3L9zgsCM90t+ZgY6aCl0KBQrt95wI0ZvFy/i5CDswwGU8js1DSJCgq5QT/dIAOQu3xMiBwuYGK4hcmW6eAynk9tCbkc/zKgKAqefPJJ1NfX47DDDsPcuXMxfvx40xzqk08+GVdccQUuvfRSTJ8+HV9//TV+8pOfaG+m//Yzf/Bd3H3jFVj2179hn332wezZs3HvvfdaynT7fD78/ve/x5133olRo0bh+OOPB6DVSv/973/HXXfdhX333RePPvoonnjiCX1GNwBceuml+NnPfoazL74SByz4MXp6+7D8gdsQCmm6sWLFCnz55ZdYuXIlRo8ejZEjR+r/CuH444/HG2+8Ab/fjx/84AeYOHEiTjnlFHR1dWHJkiWWr++sWbPw3HPP4bnnnsPBBx+MOXPm4I033sDKlStNf4cTkJnuIQhhmRo31OG5ZlF2gRyZVFFBi/LIjEWZ/C6UvguIqcNzi35myeEC519UpibL6a4wvc8NuRzN6hF8ZXBjsDDX7yLk4CzDVt1+VpheF2Y/Mx3NgQgQHiVeBhFwzXMirj+IwRQy66cwJkam0y1iVneW459bhpdffjnrNTLDmmDXXXfFk08+WfB0v/zlL/HLX/7S9Npvf/tbILJF//0H3z0aPzj9/4CqYQW/KxfOPPNMnHnmmVmvn3jiiTjxxBPzfk5RFFxzzTW45qcnAilqNGx6Ssrpp5+O008/vWR5AGDGjBn45z//mff9sWPHWmq6Nm/ePMybN68sGexAZrqHIFxRM5vr951FBsAdi3ImVZRzHR7Rv6YMp0ZYpsYNgRC36Kcb5EjGgUS/8Xu0m2t2omjNrPCgpYBAiGvKYjKdKwFyZPYHISUpnJCPKdQkiinkhkCIG2QA3LGWZPYH4TwlxZghn0Evp/afpXactoVMJ1tEN3NGmW7bcEMAQlVzyCGAfeAySKd7CKIpbQTbeqKIJzkquRsWRDfIALhjUc6UgfNoqJZ8NbNpJ3x7bwzRBMfFwA2BELfopxvkyLr+qtYLghOKlT909sUxEOeon24IhGQ62W4JWrphLQG4lqTkDQql7Wd3NIHeaCLrc47BDfrpBhkAd6wlmf1BAK7PSV77mdbP/ngSkQGO+ukGRzMzaCyC4g5YCkBcd911+hixzH9HH81g1rmqImtMmKgghIsg6eVDEMOrgvB5FCRSKtq6oxhVV1H8QyxAFp6KBqC/Q+yiLFIGwFj8RMpBZAiGNWdbTXIbDaWqal6nu77Sj4DPg1gihW2RKMY0VDouD4Bs3RDiaHaZZRA9p1uofqZl8FdpjIxkTJMj5OzIDiBDPzOYGOEKH0J+DwbiKbRGBrDbsCrH5QFgXA+h+umCZySXHCLXEm9Qawga7+NaktKSp6a7OuhDddCHnmgCLZEB7N7IqZlZ5pomggWRJYNL9FMkK8XjA3wVWsCSY0lKPvsZ8ntRW+FHV38crZEB1FZwalZKHDrFq/0sMtNNZBCd6S4gxznnnIOTTjop58crKhj4DPQ59XuSAjj3VnYbZKZ7CMLjUfiPDaOporWjtf9FZidEygAYC6JIOYgMoVogWGN+zWF09sURS2hR3hEZ3U0VReFP4U0ljSwquSciAyGi9dMNcuj6GdYCQxzliAwk0BfTNgWZQSFFUfQ6Wm51szRV1E36ORARMxrKDfoZFaefvdEEutNZwuba7A2wXjfLUz8z1zSRgRBdL/iWpOjI9ZyIkiEY1nQU4Ob8D8ST6OzTSi1GhrP1U0jfAaIHXm3UldCabl2GlBhKtZohR44ARENDg2mMGP1vl112sS8D7fiTKUYy0y2d7qGKprSjw63ui1509IVIRPQ3fc7aMdr/nOvwdEQz5BCZSTQtynzkIIttQ1UAIX92aJN73wGaFuoGR5PoBec6vLxyuGXTyEkOQo2srfCjIpCtn7r95BUUoqmi5J64QT/VpGZDRcsh0sEToJ8kGEmy2pngbj/p/iAi9TOaoRecS1J0ZOqnW4KWvPQzrXchvwfhimz95N53QE0ByHC6RWa6iQyAmKCQGwIQ5Jwer+Z4A2Luicsgne4hCpKp4ZZJpKmiFfXp10QuylSkTuRoKN3BE0g/C4WBYK35NYeRr96LoIn3LE+iF94gUDVc+1mko0l3/d1ZGSECM9356mUJuDs15FooXqCmyfwaT5DrX9NkbJTckHHfyTLdxFlpymAJEXBnsuk6oADhkRmvcQQ5Z9Vww6Fwg366JWjJy35SpWOKomS9z5vJpiYpZ86XprOLyDDrmW4vdPdKpMPrExiA0DPdniGT6WbRGFA63UMUTaI2jQKirjnlqGgA/OlaYd4Zd7dRRQXQz8himzkujGAkb3pkTgdPYCCkog4I8KX863ALVVRgpjtfPSJBM/egpTgHz4RcJSlCM+4uoDIL1M/McWEEI0UFLYNho+fCThYIMcEV5WPp9StUy33P1VrUfvJxuv1+zcHu60s3iFU8gJLOvIuu6fZ4xMmhO/8CAxCmTLfAa8EQfX0a64voXTmQjdSGKEjzFe6bRgFR15xykEU53sdfDtK0DHBPJpEYPU6L8tauIpnu9OtbRW4a3eBoxrr5O/8mqqhLmBikBIRXUKhopjtoOs5xCHTwTMjUz4FO/nK4rT9IKGxk/TmX5xRjCnGrmXVNUJ2UTNVqsvS185fDbf1BgmHAHzK/5jC2FrOfnILqXq8XdXV12LZtGxBSURlUoMRTQEIFojFggPdY0qh27kQKSChASgUG+oEUx/ymqgLxdNf4BDR5UnH+16J/QDu3Ai29m1A1GbwCyulsQlVV9PX1Ydu2bairq4PXW343OOl0D1Hs9JlusmnsaeEvB1n4FC9Q02yWS4QcQcrp5kyPLEbf5d5zwC0ZEl2Ozfx1w0QVHZXxGkfQ+plKcJWDBCMzZ8gT8MrU6MiZwRPYE4MuSeEtR87+IIIdPJK14p5JzE0v1+0n7/IxtwXVRcjhtv4goTDgC5lfcxhkX5nXfnLcfzY3NwM7NmBbS7tW3hiKAn0dgL8H6Ig5fn4T+rZrSZeKBBDrA5JRoBOAn9MEIUDLane1aT93eYCeNm0v2s25bXi0G+jfAQT6tP1ntBsIxYCQgHJPRqirq9P0zQak0z1Ewb+m26WZbhFyuNHB45zpzjfuhsAVTAzRjqao50SXoQYI1YmRATA7eMkEVzmKBYW4NwIyZfDcwMSoFfecuK0/CG0/XcPEkEF1cfqZPp9b+oMIyHS3RizaTw7ru6IoGKlsx4iXzkJ87Bxg2o+AVf8fMHIacMLdjp/fhH/dAmx8AzjiSuCr54Fv1gBHXgXseSw/GbpbgWcvBuAFTn0ceP5HgCcA/PQNfjIAwJo7gbf/DEz5HyBUA7yzDNjnZGD2JXzlYAS/328rw00gne4hCnpRVlU1Z7MLppCLsgE3Oni8M9260507wkteb40MIJVS4fE4rZ90Bs8lgRBRz0m+Z0RVAaftBA3awSN0d87lD/l7DqT1szuKZEqF12n9dEOwEHBHwDCnDOnRUCTjzFOOYNhoBMQ9aJnPfmp629YTRTyZgt/r8HXJWdMtcE63SEZIrgal8V4tcOjluKUWmem22LNle28M0UQSQZ/DWdZoBN5kP7yIAZWVQM8moCsMhHLL5xi6N2jnDoUAT1z7ObadrxyRPu28FfVATYP2MwD4FMCXOwniCPq2auf2A/B7tZ/7NvO/Jy4DxxVMgifIbORoIoWufg4js9yQwaPP6bZNYzIKJKKc5cjhaHJ2avJFwkfUBKEoQDypoqOPAwXMDRk8gKJp1grMdOfQCxGjoQQ6eMW66w+vDsCjAMmUiu09HJ5bNwQLAXcEDHPJIGI0lMC1pFime1hVAH6vAlUF2ro56qerguqCGCE59RMC7Li4QEhLkZ4DdZV+BHyae7Etwls/BTb6c8NzQj8jpBmmCDncsJa4ENLpHqII+b1oqNLGBXCh8OaqBRS6KLuAHhmsdYnR4+vgDcSTeqAn36bR7/VgWBXHZlVuyODlk0PkohyoEjcaStCiHE0ksb1XC/Tk677r83rQWMOxBMINwULAHc9JZgbP4ze/zlsOzvqZSKbQng70NOUpz/F4FIyo4dh3QAbVDdD66fUDvgrxcnBcS5IpFdvSgZ589lNRFL5jw9zi4LmBEUI/Ix6vMSWFu366hF3oMkinewhD7xDNw6kR5OCZQHcVdQv9TKjRE7MoEye6wu9FuCI/3Y7r2Bs3LMr0KDk31HSHwhqdXNRoKEEOHsm8BHwe1FfmH/2hjw3jGRRy1abRBZluRXHHc8JRP9t6okipgM+jYHhVfjoocXi49B3It5YwmFtblhxu0U/AHXJwfEa292glNx4FaKwurp987GceBy+Vcv7cJjnIc8J/jJshA5X0ASj9FOT8m/qUCChJcRmk0z2EQcbeCFuUSR0eL9BdRd1CPwNcYPT4Rl3pGciFeglwDQoVqsPjBXqUnFsy3UQWEXIIcvBaqCZAhfRTHxsmKtPNuyQlPgAkY9lyiAzGAO54TjjqJz0urFCvi2YhQXXqWvAuSaFHydFOjcgMHuCO54RnUD1tDxtrgvAV6CXAtdlfrqQPVCDW4/y5Ceikj1uC6kQWEXK4gTXlQkinewiD69gbN9Th6V1FA1o3TzcYG8AdcgjIdDeFCzftIB3MhWW66dd5gB4l5690B/0MED8ainMdXrF6WQKum0Y31OHp117R2DluCMYA7ti8crThrRbtJ88O0SZHM1DNfRpG1rmCbtDPzEyiwDI2js9IsX4tBFz3n/lKUriu79ReVwbV3cGaciGk0z2E0RwWQI8UWYfnRmPjFjk4LsotRcaJEAhxakTW4ZlGuClyURa0KLcWmdFN0CQiaCmyJEXXixqtS7jbMonCnhO+/UFoplAhcB27SDuaokpS9FFylZoNd0MwG3CHHByfkWJNKAmaRNV00yUpIoKW3qDWJdwNwULAXfoZFVCS4jJIp3sIQ8yiLLAOz43GRpQc+aiiHOrw9ExinnE3BM08Z8m7IRDixgweLQ9POZJxg5qaSRV1uCSl2LgwgpFcaxLzZc84sg/0zBnRT0F1eFmZRAFMjKz+IPxKUgwmhjX7yb08BxDTLNWNwUJRcuTrD8KhJKXFzfZT5JrmxrIYWh43BNVTCSDez1cOl0E63UMYTaIyiYAYg+NGYyNKjnxUUQ51eMamsQi93A36uVMuypnOlQj9pPsvUPrJoQ6vxZWZGhfUibrhGSkkhzD95FuSYmS6rdlP7uU5ABUw5BkUylcW4xL95Hkt8vUHoeVzCHr5WDGmkJCabhfsuWRQPTvpQ5ek7OR13dLpHsJoFtUdGpCZbtFyZFJFOdbhuZ4eCQhalPN0FRW2KKflEKKfGVRRjnV4rSXWdHNtROnGTaNbgpYi1hLSH4RjSUqxGcgEdNBSdZqy6YZAiBueESCHfgrI+mf2B/F4tTWefs8hWC4fS6//27oHkEoJ0k83BC13xkx3ZtKHLknZyeu6pdM9hDEyTU/b0RfHQDzp3IkyqaKAoEXZBRk8IL9zJcTBS5+bYx1eq+50W6NHdg8k0Bt1kLKZShmZK7kou2tRpvWTkxzWg0La+72xJLoH4s4JRFNF3aifvOvw3PCcZD4jtDwOy0Hs58gi9nNEmkkUTaTQ1e+gfgLuCoTk0k+eU1Lc5uCRCQz6c+Jsxt2q/RxRE4SiAPGkio6+mKMy5Q+ECGBiZMrAe0pK3ueE47XITPoA4pgpLoN0uocwwhU+hPzaLXY0251JFQXE1OFlZfAEGT030M8yZQC41OElUyq2dWs1ZcUi4dVBH6qD2hxvR7PdsW4AaafBTY4mxzq8nHK4ZdNIwEGOVEqlgkKF9bMy4EM4lNZPJ7PdNFXUjfrJuw7PjQ4eLY+Dcqiqark7dMjvRUNVAIDDdd2ZVFHAHYEQUaOh3MAIyZSBlsNh/bQ6/cHv9WB4eo63o/azUNJHBHsr8xnhLkcmq08EEyMj6QOI6VPiQkinewhDURQ+dbOZVFHAZYsyxGzY3EA/y7koO2f02nuiSKZUeBRgeHWg6PFNPGbJk+tOqKKAOwIhHOvwcsrh1k2jg3J09MUQT6pQFC0TUwxcxt7QVNFAlfazGwIhourwduJMd1d/HNGElrUdUaQnBsCp70AmVRRwRyBE1Ggot2W6CTg8J93RBPpiWoCwWNAS4NS3JWfSR+Salt7v+QKajtLvcZHDhf1BaDmk0y0xlMF108g56ppXDnJuEaOhVHWnXpTJ4tpYE4TPW9y8iNNPFwRCONbh5ZTDrfrpoBxEP4dVBeG3oJ9cmgHRVDxCFXVDIERUHd5OnOkmdrC+0o+Q31v0+GaeQUsTVdQF5WOiR0O5onys1niNw3NC9Kwm5ENlwFf0eC5BoUJJH7esaTKoLq6Hjcsgne4hDj6ZbpcaG1omXnLE+9xJFaXl4LBpLFbPTUDG4jhKjxTk4JUkB6/oL00VdVP9Gyc5rI67IeAy9qagg+eSkhRez4lb+4MAXOy4Ti23aj95jA0rRBUVEgihHE3edtyt/UFoOZwMqkdcbD9F7vuKycEz6bMT6+dggHS6hziaduZMNy0TLzmIQXEbVZSWw0Gjp9fLWqBGAkYHc2d7DshFOUsGwMhiuk0/OQSFinWGJmjmkqnJyJwBO28dXsH+IG5x8Jy7Fq0Wxy0ScBkb5pYNtBuC6m7tD0LLwYEpZNl+8th/DoqgOi/9dGl/EFoOmemWGMrYuRZlF2wadRlyUUV5Zq3EZCesNgEiEM/EEHBPRD4nRIZAjUZvp+Xhei06tf85b6BbLc5AJmjiMXYxswYPEKyfORxNbvazU/tfeH+QXPbT+UCI1c7QBFzGLhZipYhsVEXLxHt9z9UfZCdYS6w2USNo4rH/LBhUH/p7rpwy5Er67AT6ORggne4hDkLvcZa+6wJjA7jD+S+UbRcRaeSd6SaRcIubRi6LciEHT2RXURFyFHtGeI2GKpRJ5EAvLzkoxKMm0TX6KXLTWEQGXqOhBAXqWktkYvDpOeACZxco4vzzcroLyMBzSkrB58RB+1lqUEi4fg79PVdOGXIlfXhOSXHDWuJSSKd7iEN3akTVJIpscELLxH3TmEMGrkZPzEa+9JovHjWJhRw8AfRdoYtyAb1Qk0Y9rdMQtCiX3HOAR02iG4KFgDvseCEZeI6GEkSP3FpyzwFNj/mUP7gkKORa/QS/65FTDueZGFbHLRJwtZ/CmRhiAiE5Zcinn254TmSmW2Iogxi9bd1RpFIOZbEKUfF2ukW5gGPFVQ4xjmapNV9NaXpke08UiaRDWSy3bRrdkEmk9ZMeDTXEF+VyM93tPTHEEg7pp1vq39ykn7QM/grA4xMjhyD9LLXnQGdfHAPxpDNCuWUD7YbnJJd+ihgNJehZLbl8LL3/7I4m0Bt1iAXgNv3kHAjJKQOd9BExJcUtPoELIZ3uIY7G6iA8CpBIqWjvdSjL6oZMYiqZbnKCPA+6QPqZEKPHP/qrqqqRSbS4KA+vCsLnUZBSgbYep/VT4KKcq6uoCDlybVzp0VBDfNPYUmJNd0NVAIH0aLFt3Q5la9wQLATc8ZzkkkFR3PGc8BjJVGImMVzhQ8jvMX2WOYo9q7xKUtzwnOTST7fIwbFRqtWgUHXQh+qgFjBzjI1RjNXHuyRFKNMyR9IH4F8OIqh8bDBAOt1DHD6vB4016WYrTlF83FCHR3e9dfWizNvo8avD644m0BfTsi1WN40ej6Iv4I5RzN1Qh5erqyjgDvoZIC4iz/FZ7Y0m0D2g3Wur9HJFUXQ2hmP2s5CDx6skJdcoOVoOkcEYkXJw1M+BeBI7+uIAgJFh6/rpeIlOoWc1lQDi/c6cl0YyDiTS53GDU+MW/eR4LWKJFNp7NBthtfwB4EAxL+Tg8SpJoZM+bth/ukY/BbO3XAjpdO8EcLyZhRvq8IgMHr9B9aJl2lk3jRyNHukbEA75UBnwWf5cU3o8jmN9B9xQh0fOQXcVBQTSz/LppwsaEjl0P0imhc6+WIHjzdTcUIeXa5QcLYdrgpYCaZpO28+0foX8HoQryrCfPDOJgWoA6UZNPOwnfd/d4NTQDp4QOfj3ByFMn4DXg4aqgOXPOb7/dENJimnUoQuClm6xn6LZWy6EdLp3AjjeIdoNRo82NqRrIy3Tzrpp5Gj09HqvEqLg9PGOOzUi6/B0GWrM+ikXZW4y6J31Lc5AJnC8Q3SuQAjvkhRyzelRcgD/Ory8mUTecvDXT7rfgELbiCLgF1Sn60Q9fG3G/8/en4dJclVn4vAbuVdWZe1dXb13a9+lVneDZQyIxUigMchmPOMfxjZjDBhLYIENHo0x+DMzw2MWYxuEPTY2ssF4h/FYYEBGILHJdLfUkrqF9t67a+uqysyqyj3j+yPiRtzIjIi8EXFvxM2qOM9TT1dXZWWejHzj3HPes5EgMzVgrpID5CCzZdFDsA4EX1PDWU/43CyatJShJYXoQK+SA+JMtxOpHlZLioQSB90bQISvDZPJ6MlobMLWg6VUVIDRm/HY70UkkkMZiAafsgS7UeKz1TCnpDtlEgW0pHhdd0NkOizS0jF7FkL1gV3mLGwdAIZMYgh69JoPIqglxbf9jIK0BMK1GTKThWHr0Ws+SLMKNOvcX9brvBYiZH5GqEkfIBp8yuJ/ynifkO/DakmRVOKgewNIfChjYx3KvUpFBRm9WY/rbohsEd3zZdf/BkR0KEeoA0ANWomwPLLX/AVBLSnm5F22flki08JJSwn6RGWw4bLo0ROfYvSY8Ws/o2gfA0ImhZxwEVEFRJTtOU7zQULCp/dKtghmDgAxqU6LDEkfekvKBu7rjoPuDSDCMzUyGBwZjA0gh9PoVCoquA/vvE8mPLTy3Ujx2SuTuIEO5apDqajglpRZj5PLiRAnU3ymWwL7KQs+ZbgWnfNBBLekGJnufmjPAWJS3aJHiLM5nOaDJFNAWv+/ACLE67pFIqFVCkVJyMigA62HDPYTsCZ96C0pG7ivOw66N4AInR7pVCoKhGz0JMjgAVRwFWUm0SHAE9yHZ/TMylS+226bmSsZnEZZSCEZDuVOHQS3pAR1GoUENXSpqOz4DKMPT4b7xGk+CK2XCPsZkLQMdRAlIB+pHsaWFJnw2TkfRLAeQdtzNkQlhpMO9RWtbSUsPaKsxHBK+gBmjBBnumNZzyLU6DmV4gFylZ+FtRpKhvIzJx0seog7lL2Xl5vlZypvx75eBqA/pwxOo5MOgvrwHPWQwmmMBp+s68KIGJnuYk0APqlSUZnxGVYfnswBHiAUn+d9t+doeJ4t19Bqc8anU6koIFemO+wtKTLgs1MHwXp43SFPhDx+fqWGRoszMeKa9ImgesvpHglND4KNzqRPmJUYDkkf+mcbeFd3HHRvACFGb7XeQrna4PvkTqWigGSHckh6yFR+5noo8zd6sz4HAU3p06RrzTaKFd74dCgVBeQgQsLGp8yZbsF6+M10TxW0x9dbbSyuciZGjFLRhDmtnIgMREhUq6FkDPCAcCqFPOJzciiDhAK02iourHDe6e5UKgrIQYREtSVFxvkggvXwO0htYjCDdFKBqgLzZd74ZEn6hHmmdXwmqSyQzIaoh8TzQeifxZnuWNaz5DMpFHLawcS9hDciB9pRj84bPczVUKoql9MYYqam1mxhYUULSLweyrl0EmN5jbDhXsJL47OrVFQCIkRwH56jHjL2vwnUo9lqY0EPSDZ77OnOpBKYHNL20nLHp1upqAxESOiroSQihUK0n+22ijk9IPGaSUwlE9hU0DAtDJ92paJRZBI7g5qotqTIOB9EoB6qqmK2qNtPj+d7IqEYxCV/fEqW9Am5OsZRDxnsp2umOw66Y1nnImxtmOzGBgjP4DTW5C4VFajHXEk7kDPJBMYHM57/XtgwNdnwGaUedKmoDK0gIVZizK/U0FaBVELB5KC3oBug+mZFkUKuWav125JiEdlKRTsDPECY/VxYraHZVpFQgE1D3vEprIUsggDPXg8J8Cn7fBCBeiyu1lHXS8O9Bt3a3+hrw7jjUwK/TxY9ZJ8PQv8sznTHst5FWFAjg7Gh9YjyUCbvU9ZSUYF6GKXlI1konRk7BhG2Nkw2fEaph6VUVNJDWZAe56nS3UTCPz6FkZa2uIiiD88t0BQc/LuWikZQleKKT77Xgti9TYUsUknvbpmwCeYykDG0HlHaT9nngwjUg+BqciiDTMo7PreIWhsmGz6j1EP2+SD0z+JMdyzrXYRNiJbB2NB6yBDUyFoqKlAPv/1eRDaM0ygDKZQZspkqGkV5ZHiZRLNf1nsWUfs7QROinXrwgA2IT5ZS0RCz/iESIX7nDRARl+lmuRYRtsUA4bXGuM4HkaU9RzCp7hOfwiuFYlJd/vkg9M/iTHcs612EBTVOAyTon0U5yIL+WViHcpQ6RKTHjM8hQETEHcouAV6o+CR6jEanB8u1CGM1VBT49Dl5l4iwtWEs10IW+xmW0+iKi7J4fEZwlgQOakSTlv1wpgmvxKB06FrVpesQxmoopnuV77U4H5QUGhE8c6Af8BmW/5kddsZnGFtSXPEZZ7rjoHuDiLBd3SwZZlkmeoYV1LjpEIrRY8ieCcrUeF13Q0R8+a5LVlWWSowwD+VOIXqFsRqKpXxXWCbR27owItOi8MmSIdlo+HTTQW2LXw3Fcp9wxqffdWFEhLfnhHgtXPWQHZ+R6yGIFCoGJC1FlZezVEDI0pISGikkMz7jTHccdG8QEZapcQ3wJJgODVA3umCjJ92hHF6gOcOp/GzdO41R6uF2j2SGtLI0+nGiJIJD2cx0+ysvN3Z1R9H+sNHwaacDvRoqyvtEtP30GdRsFl6JIQkpJCs+6S0pUeohirQM2j4mur0xSr+vpx5hZ7pt/L5E0iw5Fx78s8QE8Z7uWNa5mEEN5z2JTAGe4BvMbaooEH55pJ0OoRo9FvZXzCAg/0x4lIeyYFzQq+RkyNTY4UJRYOzhXY9OY8D2h2h6ZuNMtyH0aigZKkJ4zxzgFdRERVqGVvIvKT5l0UOQDsYgyqDtOcUqVJ5YYZqJEWJLigyVltLgM+LqQkklDro3iJDys4WVGurNNr8nZpr0KtjouU0VBeQ4DGXRQ3QmMaDTuLTWQLXBsSeOhYAQ3YdHr5KTtfwMCJ+RDxGfQYMa4myWqk2s1Zvc9GIK8ES3pDRrQKvWW48oyZgo9AjTfgbumdX+brXeQrna4KYX073abmgYFSVuq+Ro3UJrH4sanwxtbJKRQlP6AMtas41iRQQ+XQI80S0pdNJHBv8zcnxKUJUiscRB9waR8cEMMvoqkrkyxwNShj48t6mitG4bzWkMyeipqmrs6fab6R4ZSCOX1vDJNdstQ8m/sUouCWQGbfSIYNCKnYQd/IdUlaKqKtUz66+nu5BNYTCjTXznmu2WoQ+Pvtak2sFOj41GWoYY1AStFMpnUhjOpSzPxUXcAs3MEAB9YJPIM81tlRwgRwYvEj3CJ4X8zhzIpZMYH8wA4NzXLUNLCp30kYG0lMV+Rl29JanEQfcGEUVRDLaRa1Ajg9GjjY3djmgZjI0segjQYXG1jnpLq56YKvg7lBVFEVPCK0MfntsqOSA+lG114Bf4FysN1PTqnimfK8MURREzIdqNCAmrJYV83plC9yo5IMTp0L0yiWFPqQ7HfparDazWtUoYv0E3/bdC8GkXaCYS4dgMt1VygBxktix6CNBhrd5EqapV9/gtLwcEzR2QoSWF6JDMAGmb6xNnuu11EF3yL6lEGnR/5CMfwYEDB1AoFDA1NYXbb78dTz/9tOUxN998MxRFsXz96q/+quUxp06dwm233YZ8Po+pqSm8733vQ7NpLQH89re/jRtvvBHZbBaXXHIJ7r33XtFvTzqZFtHXLZPRk9nYhKWHl1JRTkaPMNeTQxlkUv5NSuiHMhAuPmUJdqPEZ6sJNFZ1PVwyiRxbUgiexvJp5NI2QSWjCBkG5LbGDQg3qJEFn1FeC9b5IBxbUgieCrkU8pmU7+cRMoxShjOtH8jCsPRgnQ/SrGhl+RyE4CmfSaKQ9Y/PaZL0Wa/4lMX/lPk+CaslRWKJNOh+8MEHcccdd+Dhhx/G/fffj0ajgde85jVYXV21PO5tb3sbzp8/b3x99KMfNX7XarVw2223oV6v4/vf/z7+6q/+Cvfeey8++MEPGo85fvw4brvtNrziFa/AkSNHcNddd+FXfuVX8PWvfz209yqDmGtvOK4EksHg9IOxCUsP1lJRjkYv6I5ZIkKGqbkNOAFCwqdLD15YOtB6RBnU0M8dUktK0CFqRISSljLYT1mcxij1YJ0PAnC7Twie/PbLEhFCCjGfaQKrD3reIxIMSgXCac/pNR+E/hmn60HPa1HsKrUYRWwlhgQ+lyz+p8xJn7BaUiQW/7QVB/na175m+f+9996LqakpHD58GC972cuMn+fzeUxPT9s+xze+8Q08+eST+Pd//3ds3rwZN9xwAz784Q/jt37rt/C7v/u7yGQy+NM//VPs2bMHn/jEJwAAV155Jb773e/ik5/8JG655RZxb1AyifZQjjPdoTrQTqWihtHTGfO0vx5XWsgh6rffi4iQXcgy4TM+lM336FQqSlpS2k1NDzviyKME7UckYjiNIkjLGJ9y6NFrPghpSWlWtccOjAV+SUKCByktB0x8h9YzC0hGqke4EhQIZzZHr/kgyRSQHtSqiWpFYHAi8EsaQ9SC2s9hzdcItxIjhJYUZh02QKa7V9KHtKTUipoehc3idJFUIs10d0qxqN0Y4+Pjlp//zd/8DSYnJ3HNNdfg7rvvxtramvG7H/zgB7j22muxebP54d1yyy0olUo4duyY8ZhXv/rVlue85ZZb8IMf/EDUWwlf5n4EHPlb4NTDjg8xmUZOmRqbUtGZYhVHz1IGLhSj153BO3J6GfPlDsZNuNNo1WOl1sQPnr9grsiIqFT0ubkVHF/QPycBfXhMmcRWA3j+AaDmnL3kTgq1210H4mypiifO0PiMJpP42Ollc6BhROVnq5Hgs9sxeH5+BS/M67gQ0JIyw+I0tpo6PsuOD+GeqaFLRfX3PFeq4vEzy+ZjIsLn42eWMVeywafIPrwOPdbqTXz/+QUTn2EHeHpW74X5FTw/T9ktzvhkmgzdagLPf8sVn5tFVAp13K9z5SoeO71s/j4iUv2JM0XzfYa1JaUDn5V6C99/bgHtdgT4pOaDHF9YxXNzFD4563GeZbJ+u6Xh0+U1p0e08nKRme75cg1HosIndaYdPVs0yQWiQ70sdktKx31SbTjhM9z5ICcWVvHcnM0wxA2a6ZYm6G6327jrrrvwkpe8BNdcc43x8ze96U34whe+gG9961u4++678fnPfx5vfvObjd/PzMxYAm4Axv9nZmZcH1MqlVCpdGctarUaSqWS5Ut6efJfgP/7q8Bjf+f4EKN8lxfTaFMq+sv3HsQb7vkenp3t6IsL8VB+9NQSbr/ne3jX3z6i6xbSaqiOQ/l/feVJ/H9//jD+32PndD1CNHq6DqVqAz99z/fwM5/5nrmKi7PRY1p389jfAZ//aeDB33d8CPdBavUVdJaKvu2vD+EN93wXT810OHIhHspPnCni9s98D3f8zSNWHTj24bnqob/e//7qj/D//fnD+PKjZy36hRnglXV8/vRnvm+u4uKsB1P7wxP/oOHzWx9xfIg5c4ATaUmXiurv+e2fP4zb7/kenjwXHT6PnSviDfd8D+/4wmGrDqL78Dr0+P1/ewpv+vP/wD8ePmPVI8SzZK3exE9/5vv46Xu+h5WaGHwykULHvgR8/nbgmx92fMg075kYNqWiv/aFR3D7Z75nEpcRZLqfminhDfd8F2//60MW3ULbkqLr8bGvP403ffY/8PeHTlv1CPFerTZa+JnPfA8/fc/3UCKr4niTQiw7up/8vzo+/3+OD+E+c8Am6XPnFx/B7fd8zwy8Q20f017r2dky3nDP9/DWvzpo1QFwJc246aH7u5/4hobPL/7wlK5fGJUYVrtQa7bwxj/5Pm6/5/sornXiU3BliqQiTdB9xx134OjRo/i7v7MGjW9/+9txyy234Nprr8XP//zP46//+q/x5S9/Gc8//7wwXT7ykY9gZGTE+NqxY4ew1+Imeb2MaO2C40PIoXy+xKk8sqNUdK5UxZPnS2i1VXz3uQXtdxEcyg89o732D48vao5S2Kt3csNQVRUPPDUHAPj20/Paz8MsP9OvxeGTSyjXmlhaa+DxM9bDgZfRY3IaLzyn/+t835rlu5xJIb1UdGGlhsfPFNFWge8+24nP8IiQh56dh6oCh04uaY6SgD48Vz3090xwaeIzfKfx0VPLKFWbKFYapqPEWY/zLOXlBj6fc3zIFt7l5UapaALIDGFptY4jp5fRVoHvPKt/JhEQIQ89swBV1T6b5bV6iKuhrHp8+xntGjz4dATXQn+tI6eWUaw0UKo2ceTUskU/3pVCbPbTGZ/c7WdHqWix0sDhU0tQVc2GaT8Pnwj5zjMLaKvAY2eKuLBSC39Lin6Of/vpOcu/UcwHeez0MpbWGijXmnjk5JIQPZjax8i57mo/ByzPF1g6kj7lagMHTywCAB56JoozTftMvvPsAlptFcfOlbRqtlQWSGbD0yPrcL5HcJY8caaIC6t1rNSaOHRyMTw9JBYpgu4777wT9913H771rW9h+/btro998YtfDAB47jnt5p6ensbs7KzlMeT/pA/c6THDw8MYGOjuab377rtRLBaNr9OnT/t7Y2FKXi/JX1t0fMhmo3y3ZpbsBZEOB/oQMfoADp3Qv4/gUCY3d1vVnKZQVkOpqsXgnFmqYFbPiJGDIAqjd+iEiQdRejD1fBEyyI0U0v9+rlwzS6KCCI1PRTExCepaRECEkNdWVWiOEunDA0IbSHRuuYKzy1rwaGAkgv43Gp/G58NZD6b2BxZ86n8/X66hqa/ICyQdpaKHT9L4jMB+5ro/k8Mnl0JcDWXqMVeq4uQFrY3s4IlF7byK4Cw5aGczRGW6OeFzYaWOepMjPvVS0Uf0gBugbUaIgaZuFw524jPsLSm5YSys1PCC3rJ16MRS+PgM0ecilT287OfyWsOsugsiHUmfR09phCUQsc91ksLnCTFEiKseuWEsrdbxrN5ycPjkouZPRYBPq/0M8UyTWCINulVVxZ133okvf/nLeOCBB7Bnz56ef3PkyBEAwJYtWwAAN910E5544gnMzc0Zj7n//vsxPDyMq666ynjMN7/5Tcvz3H///bjppptsXyObzWJ4eNjyJb0wZLqJ0aw321ha41DGWut0UKwBnqqqoRubZqttMr60TqJv9EZFG/6k60Eb3jNLFW1YTsRG75Cga8HU80XIIBd8bhrKIqEAzbaKhVUOJbw9ArzQ8ZkdRqutWoKrQ2EdynSpaG7Y4qydK1a1ADzyQ1kMPnmRQhNDWSQTCtqqFtgEFiPA04MJ2lkjjlIolRhmBUy7rVqwcTAsfHaUitI6zJVrOL1YiSTAo+248T33TLeXoMaZVB8fzCCT1Fw6Y15EEOkoFbXYz5NL4TvyWa2CzBJoCsrudknHfBCawL2wWtdmpkQQ4HX6XAAEtI/pg/4C4nN4IIVcWsMnl7kDLmThIyeXNGI05DNNVdVoAs2O+SC0j7G01sALCyuRJ31CJeoklkiD7jvuuANf+MIX8MUvfhGFQgEzMzOYmZkx+qyff/55fPjDH8bhw4dx4sQJ/L//9//wi7/4i3jZy16G6667DgDwmte8BldddRV+4Rd+AY899hi+/vWv4wMf+ADuuOMOZLNaScev/uqv4oUXXsD73/9+PPXUU/jMZz6Df/iHf8B73vOeyN47d2EIujOpBCaHMgA4rQ3rMno2jlLIh/JTM2Ws1k0WNbSSFvL+9FJR2vAC+rUJ2ejVmi3L0BvDUeKox1q9iXJVIxtce74YgppUMoHJIbLLk0PQ3RngnbRxlEI+lJ+ZLRvXCwiRFLKUig5bDkNAPxBD7n9rtNp49LT5mRiOEkc9qo2WQTCykULOTmMyoWCqwHEYUK0zqLFxlEKtxBjBc/MrKFZMQrabqBMU/HeUih7swOfBE4vUtQinGqSTwH301DIaFnwG16PebOOCTjAGJYUURcEU2YXMBZ/OWf9ytYln5srhtufkhvHCwioWV03CKzT72TEfpNt+LoV+lnQSuEdOL2sVDhz1aLbaxkBaZnw6VFEqisJ3bosLPlfrLTw1Uw7d5zq1uGYO8EWI/mfHfBCawAX0axMyPjsJ3MfPFLUKhzjTHZ38yZ/8CYrFIm6++WZs2bLF+Pr7v/97AEAmk8G///u/4zWveQ2uuOIK/MZv/Abe+MY34l//9V+N50gmk7jvvvuQTCZx00034c1vfjN+8Rd/Eb/3e79nPGbPnj34yle+gvvvvx/XX389PvGJT+Czn/3s+loXRgfdLqXjm3lOiKaMzUqtiWPntIN3x7hWsn8wNEfevNHJIUx0MBylsIIavVT0UIceh04shm70jp4todZsY3wwg3wmaTpKHPUgh+dgJolC1mUDITmUK0uuw+y28NwlT+Fzrd7EsbNWfEZBhHTiwnCUwiKFMkNAImk4KJZ7NeT+t2PnSqg22hjNp1HIpkxHiaMexM7l0gmMDNisKCNC8Fkrug6z47o2jArwqo2WMbXc/EzCx2en/TQcpbDwqZeKHurA56GT4Z8lhMAt5FIYGUhjrd7Cj86XuBIhc+UqVBXIJBMYz2ecH0jIoMaqVlXlIFzXhlFnCU3gWvAZJilkYz+Pni2iUm+Jb43pmA9CCFyrrxPCaijqXiUE7mAmibF8GrVmG0fPFbkSIQsrdbRVjXAkhLitEPvZrGoBoINw3QBB4ZMmcKP0uTrP1WPnSlil5wqJ9j/1pE+n/QzdF88OGwTuQDqJyaEM6q02njhbDEcPiSXy8nK7r7e85S0AgB07duDBBx/EhQsXUK1W8eyzz+KjH/1oV7n3rl278NWvfhVra2uYn5/Hxz/+caRS1gDg5ptvxqOPPoparYbnn3/eeI11IwPj2r9qy9XYmkwj30ziEb2fZvvYAF53jVb6f+hkyEaPKvv6L/t2WB2lsJzG7AiW1+p4Zlbrp3n7Sy8CEKYDbWYSiYNyYPcYbtw5JkQPcnhuHslB0VeY2IqRoVGByrLjw7iSQtQKtyOnl9Fsq9gyksN/um4rgDADTVMPcij/5xt3WB0l4YeyiYtStWFMbyf47CIgRK3esSEg9u8aw427xnQ9+DoH9GR9NnzCNdstJFOTG8bjZ4potFRsKmRx+w3bAERBhJj286dv2IbJoazpKIXlNOasBK7Ffho6CFwNRZ0lhIDYt2sM+3eJsZ/Ezk0NZ5FIBMcn1wnR1L1KCNyJwQx+Zq82dye86pjuoOanrtuK6eEcGi0Vj51ZDhWfa42WQeC+/WUXA9DL3MNYDWW5VzUc3LhrDPt3a/7fIUtFCL/zfaqgtdY4Co1Jhr5u3vikCdyf3acNPj54MjpS/bZrt2Lb6ABabVUbECq6IoSaD1Jttg0C18AnbT9FbkmxEBDatdi7cxQHdHyGdqZJLJEG3bFwlHROnzIL975unkwjFeAdNAK8ceMACDtTo1J6vGjPuNVRCiuoyZn9NBdtGsRrrtaG+T01U0IJee0xoRg9M8DTPhMqqBGQ6e65w7NCldszDFPjg89uMmb/7nG8iDgoER7KB/Z0OEphkUK5YTxyUhuItGsij9deqxFkT8+WUWzr+BS5GsrmUN6/exwHdHwePMn3Xp1hWRfWbjM7jVzXhtkEeAd2jxkOShSVGIYee6jPJEx8Zq0E7m06Qfbc3AoWW/pnqLaA+qpYPSgCgj7T+NtPvXTXDZ+q2hF09w5qePfMGgTZ7jG8aA+Fz9BJdROfljMtTHxSBO7rr9sKRdF2Zc83qEywqNVQlnvVxKd5r3Im1fWKHlf7CTDjk6v/aYfPXTQ+F6GGsZ7K5kw7sHvMwOdBzkSIqw7ZkQ4CdysSCnBqcQ2z9Uz343mLJelj+lz7bc+0eGVYLP0uDBPMtxhMI8+e7hGjd2X/7jHs04Pd5+ZWUFR1Rz4Eo3e+msFcuYZ0UsH1O0YdghrRTCN1GO4ax+bhHHaO59FWgUdnKfZbsHPQzhRw+CQd1IgxekzrwirLMPrhAKagm3d55MGOrD9xlJZa+vaCEJzG2UYG54pVpBIKbtgxanWUQmt/oA7DXeOYHMrioslBbZL6TB3CV0MZBFmBCmqsBIThKHHMdLuuu6kVzX44wBWfXNeG1eycxnHs3TlqOEoXmjnrY0WIfp3nm1mcWaogoQB7d45ZHaUQM4k0gTs+mMElUxqZfPhcDVCSoehBE7j7d41Z7lU1W7DqHEBIG42r/ayvAC1qcF9Y9tMhwLthxyiSCQVnlyuYJYFmCKTQYjuHExfWoCjAjTvHqOxZuPikg4mRfBqXb9bwcPjsqvjVUA5EiNV+FrjpwGQ/62vWknI3+8k1092d9Nm/exzXbx9FOqlgtlTDTE0PNEPAZ7E9gOfnNTJw364xh0BTcLDb4esUcmlcuUV77UOnyuK3pFiSPjSRbBJk7Uyc6Y5lvQjLBPMRjpka/aZpZQp4VN9h2ukoHbugB1shTBV9dK4NALh22why6WSHoxTmoWwehvS/h06VQjN6M/UMltYayKUTuHrrsMVRWuQYaM4yTS6/4P5/SrhmaigCggxE2r/L6ig9saBhJoxVckd0fF69bQT5TMoh0BRMCnUcyoCJz4Mnl0NzXmfrWVxYrSOTSuCabSMWR4lnoEm3PzhKJ0kZViUGCfAy5jT5A7vHLY7SY/OC7SdgXOfH5rTXumrrMIayKYujxJMIcdMB2WELgQuYOA2lMkXXY6GRsxC4124fQSaVwMJKDfMNfvic9bIuzOn/lBB88sx0q9lhC4E7mE3h6q06Pud0sioEUugJ/V64fHMBIwNpAx+PnFxCmyMRYit21SCd9jOU4EonIFoDFgL3mq0jyKYSWFprYKbGjwhhWhdW6bSfLu05IuxndthC4A5kkrhmm5ZZJj5hGC0pT+i+7mWbhzCazxj4eOTUEtoZfkSImw7Wti3Nv7CUdoeEz+V2zkLgXrVlGPlMEqVqE+eqIRAhEkscdK8nYQi6jaCGYyZxppbBWr2FkYE0LtmkBdvE4ByeIYeyIKNHTRV9+FxDf23NyNCO0nJ7wKIzd6EIiMfPFC16RGH0jukQ2LtjDOlkwuIoPbPML5tprAtjmWzq9H9KuPZ8UQHear2FQjaFy6e1w89wlAg+RfXhUavkHj6r/XtArwShHSWjdFbwodzKFLQeM8AI+vdHgM+nFjUM3rB9FNlU0uIoPbVs1TmI8A5qzJkD/EjL+WYW5WoT+UwSV27R8GnYjPP6pHtRLSnNutFKcPC89vzEWaMdpYVmOBm8dnYYj5xcBmBeA6JPKP2Auh5P6d0whMDNppK4fruGzx8tWR8bREhQ481+Mswc4Ng+ttjKWQhcwPxMfnhet5mtOtAQ0JJCrZL7oX4vEFxcMa2RQ+VaE3N10fjUroWGT5PApfUJZXCXrgfBJyFwM6kEbtgxCgD4EYEHl0w3QyWGH/vJsRJjqT1gIXAB8zN5+JxuP0W1pFBJn0O6L0HO08umCijkUlirt7gSIbZCV5BRBK6mD13mHo79fGZZCy0JgZtKJrB35ygA4NiiKlYHySUOuteTMATdIqZDP1fUYLR/15gxDIYcSN8/qzuKooyeMVU0he+f1J6fGD3aUTqxkrI+nrfoxmahqQ0fmhzKYteEVlpPCIgjp5dDy7g/pjO85LUB8zMxsrscMzVMO2ad/k/J5hH+Qc0LJQ2fN+4aM4bBkAPp+2eoQEZEHx61Su77p7RrRfBJO0onVvSyWdEZkmYOtWYbY/k0Lt6kVV2Qa/HY6aKZMRJciXFkXsPgfgqfRI/HSXaXgw5MMwf8BDXFqrbnPYjo1+KFso7PnWNI6XuWyXX57ula1+O5CmUDvndaK2EmnwPtKL1QJvgUVYmhPe9SK4dKo5PA1e3W2SLaIWXcH18g9nPc+BW5bx+b52g/iyz2k70SwwxqahzxqX32hMAFzHPle6eqMFpSRJxp1HMSW03ujWRCMQYwmvgUi4tie8CGwNVwcfRcCa2QMu5PLGifLSFwAROrj5LqA46DUnlXYsyVa2i1+eDzpH52EgIXgDHP5wcn18S2pFBJH4JPcm8kEoqhx/O6DyLa7yup+S4Cl/h9PzpfQisTDj6P6ll/8tr090dmBVcXSi5x0L2exEN5eana1FZtBBH9piHM6n7KQTHY33NVqCKNHpUheX5B6yvaRx1ERKdni+H0qp5Z09YSHdg9ZkxLvnjTEMbyaVQbbawp+VD0+A89K2D9TPTqA45GjxzKrj1fPjLdK7UmytWAmT2Cz2USaHfj4sj5ClSRfXhGCXEBT8+t6K/d7Sg9vRzOoXy2ktZ1GDfwuXsib6z0WEU4+CQVBpagZldHdQzP6eW88Kk/T6XRQqnSdHwck5Cs/5I10AZMB+XYzCpUkS0pehCtZgbx5CwhLbv1eHpJYGAFGJ/1uaqOT4rA3TE+gKlCFo2WihUInhGi63HwvDVrBZj2g/yOS6VQSSO/edlPEnTXW23LPmtfUiNZq277uU///qm5VahkgKtAUkhN5fDY+TVdD+oz0W2GUX0gGJ/ndXzSBO620QFsHcmh1VZRNmbYiNXj8Ew3Psl9a1QfcCHVWSox2EmhTUNZJBSg2VZxYSUgsW7gs9t+Eh/w2flVsUQdwWcijUfOafeyJdDUPx+e1TFuepAedprAnR7JYcf4ANoqUFQFz7DpwOcBm5iA+KZxpjuW/hdjkJqz0StkU8hntCA4cAka6VWd786qmo4S0EwLZNd0HaoJzTG9ZGoI44PmlEaiEym3Fm1sCONOH4aKomCfboh59lN3CVUq+vSyovfTjBq/Jo4SYcmD6tBstTFfZpi+6yGTOJhNoZDTqhIC9yWSrJWRVTU/E9pRaqTFO43VpPYaF00OWvadEkfhqOjZB3qQclyv+KDvVUVRDEdB6OCudkvPDGhEHRmIRIQ4Sk8Y92qwlpR2W8Vc2U/5rrP9zKWTGM1rjndg+6kHvE/Md2dVaUepnhKPz3pyCG0V2Dmet2RdjeqDBdH41J73eFnDZ6f9JHoY+BShB1Uqekw3UTSBu2+npsOTxHwFbElRVdUIanhVCmVSCUwOaedfcHySrL+etaI+k6lCDrsn8trICoJPIaSQpkMjpeFz2+gAto4OGL/uqj4QjM8Tq932k9ZjwRgsJ+BaUPNBzM/E1OPGXdqA0KdJ+1hjLVBLiqqqPiuFnPGZSiawqaBdI174PKqXK9P2c2Ioa1RyVZOEtBRHqjfTBTTb2nXaPmbi84CA6hg3PU6uEvtpxecB/Xyfr4dT5m6Hzxt2anOFntUrY4W1pEgucdC9nsTIdDsHNYqi8Oub1W/cM5U0MqkErtVLucnrEIOzlhBv9Eo6g9d5GBJH6VlS3iO6V1VnNDv1IP8XOk2Tur4ryOPKLcMo5NLGz4ijVCJsfECjN79SQ1vVyvwmqECyS8ghnBu1/t9BuO2S16/xqdW0NhBp+6jl18RRWoVIfGrOVxkD+mtacUEcJaM8UvCh/PQydD3GLb/eHzI+y8hrA5HyJj6Jo0SuVdCWlIXVGpptFQlFy7A4il98ciKFTqymkNQHItFCHCUzuyvOfpb11+jEJ3GUjPYH0b2Axe6sKq0XyYSLLhUtI99F4JIBjORaaXr4b0lZWmug3tSccaagmxGfm3kNozSIkGQXgQuYNsTI7gq0GStO+NwxilRCwelVgguxFRAkYOi0nwSvZ8mQKBH4pOaDlJHvInCHc2lcMT2MFZhBXxB8lipNVBoaqcREWhr4dPY/AY5zW0h7YynZReACZsBbCgGfq4qJT1JBBgDXbR9BJpnAab0CUrT/+ZxhPzvPd+3/ZyoC7SeV9CmqA10E7lA2hau2DGMFOagiW1IkF89Bd61Ww0MPPYTPf/7z+D//5//gS1/6Eo4fPy5Ct1i8CkN5OUBPkAzY110zHbbrt48Y/TREyAG53BKYnSDDiPSJsnRpD0A5SsLLvrTDfr6eQz6TxFX69GEixOidXhPYW67rUEvk0Uaiy/ASPXgZPXJobi5kjVI7WyGH8KbL9f+z4TPw3IGaGfBes20EAxkrPomjtBQCPhcIPjs+E+IoCXVcKT1ma1lkUwlcs3XE8muCFcKUiwzwGkoGDaS6HGiiRwVZtBE8yCP43FTIGqV2tkLw6BGfgdeGUQHv1VuHMZhNWX69P4zsLtXrD3Q7a8RRKofUdjBTy3QRuLReBj4FXouWkkQVma7AH9DOtDrSaCrBgyti3yaHtPfsKF34dA9qtvBaG0bhs5PABUz7eUHkkD1dB2KjO+0nGcBYCgmf56oZVwL3pMjZHGQbBxJYRc7Bfo6hiRTqCWIz/JMQhFQczaeRSyedH+jXfnLKdJfVgS4CF7CpPhBYiUFWj3baz1w6iWu3j5j2U3T7WDVjT+DqWDFnxwi4Fh1JHzt87t89BhUJ1BKC71eJhTno/t73vof/8l/+C0ZHR/HKV74Sd911Fz784Q/jzW9+My655BJceuml+NjHPoZyWcAwoljYhDXo5pFJpEpFy2q+6zAETAM0J9Toac9JMnT2geaYmT0TfCiXMIC9O0e7nPxrtg0jm0pgXmT5Wc08hIDurACgGV8VCVSU4NdjlmUdE2DicfJS6/8dhMvaMFU1WP6SmnckIABgti4wO0FN+Afs8Xlg9xhKCKfXqow8btgx2uXkX7V1GAPpZCgBHslaOX8mipE5CKIHU2kkYAYxBj5ZMzUB7CdVKlpW811kIWA6SqHgs07wae8ohdWrWlbtCdwrpgsYzCTFtj/oOmiVL4rDZ9JRfcDDfvbEpzf7yW1CNEWqu9lPoZOZCVmol8Xa4fOABZ+CtqRQAZ4dgXvZZm1StdAtFLoO2lwYxdbn6qo+CEJasgxRA3yf77wy3WWHAC/M6sI53X46BZoWfLbbwvQoq/YE7sWbhjCaTxvkgMikT0UZcEz6mNUHRA9BlSkSC1PQ/frXvx7/9b/+V+zevRvf+MY3UC6XceHCBZw5cwZra2t49tln8YEPfADf/OY3cdlll+H+++8XrXcsdmIE3QuuD9vMY5dnR6mo3WFIHKXllsCAlwS7qtZDvmN8oOshB3aPm0ZP1Gooymm0c9ayqSSu3zEq1nnVdSAHv50e5FA2VqgFMHrsQQ05lC/T/98jqOHBhNdXAFU73MrIG0O6aCGOkrlOThwRUlQHMDmUwe6JfNdD9tP4DNiH10uPsgMBkdYnVYeBz6U2IYWcA00Tn2EGNZdZ/+8gm3mUl1tKRQds7SdxlIoi1x1SU5m1ifZDXQ85sHvczNSI6sMzSEt7AjeVTODGXWMGoSjyWiy37bP+gOlUL7WDB1eEtGEnhSh8ugSWXNofqFLRkjpgG0xcNDmIicGM2OFMVfKZDGA4l8JlU4Wuh+zfPc6tJcVRehAQyYSCfbvGQim1d8Mnz+otpsn6gL39dMHnZh7ne0fSx+5a7BzPY1MhKxifms+w3B7AUDaFK6aHux5yYBeFT6iaDypIjxIGbP0+MkldaMUSdZYADgSu7octiowJJBemoPu2227D8ePH8dGPfhQvfelLMTBgDWwuuugi/NIv/RK+9rWv4Zvf/CYSCeYEeiw8hQTdlWVtv6WDcFkbpt8sVTWNBlJG7zQtxFESmsWjViUc2DNu6achomW6+fThOQp1KL9oT/e1AIAX0c6rQKNXRh47xgds+7CIo8Sjz+m836CmVnQNLDfzyCSSUmZVKxW1c+ST5CAKIdAkZIwdPg/sHuPWh9dTDwzggAM+Lc6rQAKipA5g26j21Sk7x/OYKmRNJjxIpptkapgrMXR8Nla1oNhBpjmSlm1V0UtFnR2lUghBDalWcrKfK8ihrQrsw6MyiXbOGtAR/As+SzYP2xO420YHsGUkx8V+zniuFNLx2aq5BpZmUBPAfnaWito48oqi6Fk8kUSI3iKk4zNh08a0f9cYKsiiqSa6dOcm1H1iF+ABGj5LQvFpXgsnAnfLyAC2jw1wuU/Oe60UmtAz3e2m6+tyqWTrSvrY4/NFNKEt2OeiJ9rTsn/3GGrIoKaKb40pq3m8aI+9/dTI/TB8cWcCd2o4h10TedPPiHu67eUd73gH0ul07wcCuOqqq/CqV70qkFKx+JQBcrOpQHXZ8WFmpib4oWw3EImWA6EZvQHLzkpato0OYGKkgJoqaIiEqkI1Sr8Gu/ppiFgcFNGOgY2TBFCOEgejR5hw13U3gHkoj18EKAnrz2xkC4+ZAxQuLpkqWAYi0bI/NCLEPlsEaI7S9FgBa6q41gOCzxXkcWPHQCQiB3aPmcGE8ADP/lqQAYym0+j/WpxnWRcGmEHN2G4goTtGbru6efTMGp/HAHZPFoyJvp1ixadAIsShWgnQBjDumhjCCsS1HrSNgYN5WwIX6CjTFOy4OhEQmv3k47ySmQBbWEnLke1AKmf9mY1s4TFzQP88VtQcto0POt5DYREhbvZzYiiLizYNCbXjbWog5j4HP4P2dVSB+CzBmcA19YiAtBzeCpD1cQxrF3nYz6qaxtRowTLRnhZLwkU0WeiAi9F8BpdtHhKqR5tqH9vn4PsdoK6FSHyW4Ww/Aa0CU/gMG4nFV0p6eXkZn/3sZ3H33XdjcVFzTh555BGcPXuWq3KxeJRkGsjpA2gYdiEH6vmisgJOhyEg3ui1OzI1dkIcpZKovu5mFUpby9xum97c1U9D5MZdY1jRe1Uba8t8dQA6Ajz7awHwI0KYDuVWwwycBjcBA7peDLtmeWS6tcyEMz4PUNldEQeRSmUnnDIknXpwv0+adSgt/bOa2tw1EInI3p1jRi91fXWZrw5A16HsJLyCq1mWnsRWU6sMAoD8JNNcDJ6ZmpJD6wMRul9VND7dPxM+RIittFtINLTM7ebJKUcC94Ydo3o/K1AXYT+pwMrJgQaszmuwQVX6ujA3+9lumwSQR3wG6pmly6kdnHjA2hqjCiQLe9rPXQKzeKoKRS8JnpjY5EjgXrd9xFhdKuR8pwK8Xj4Xj4z7LMv5rqomFvMT1NpaF9KSh//Zo5+bCE1AiMSnU1sMkf2ciBB7JVTjOUfHJhwJ3Gu2jaCSDAOfvXwuwUSI5OI56H788cdx2WWX4fd///fx8Y9/HMvLywCAL33pS7j77rt56xeLV2E5lHUjOr9SQ7Plc6gDnWF2MTY37BjFqn6DrZXde3n9yGpRe856aghXTHf3exGxDlvhfKNXzVLRq3dvdXzYcC6N0bFJTYWVZb46AGhV6ADP7VA2Heh2EKeRpeeLHL5KQiOEPODzwmrNWKnjWehD2cVpvG77CNYU7SBaKy/5ey0XWS1p77+aHMJVW7v7vYgIzeJReL96jzM+h7IpTExo+BQRdLf04JaFCCEEWTsIKcRSHlldBlkThYExT0HN4mod1YbP+RBGsOtuP6/ZNoKK7sgTLPEU8pyVRL5roj0tB0LC5xW7tzk+LJ9JYXLTFACgIQCfdLbI1YGmMjXE5vqRWRZ81opanzKgBTQMQQ0J4kvVJtbqzm1mrmIJ8JyvxdVbhw1HXgQ+ic+wlhjEtduc8Wkh93njs74CRZ8P4obPXDqJqalNAICmEHya1SA9CVwO+GQqL6+vaHMeAD3oZj/fV+stlKs+55dYkj7O1+KK6QLqSS37viISn/qAUicRGmg2Kkio2n1+2U5nfGZTSWyd2gwAaK2JICBM0pKVgGiKCP4lF89B93vf+1685S1vwbPPPotczrwZX/e61+Ghhx7iqlwsPoTB6E0OaSueWm0VCyt1Xy9TW9UCFLdSUUBzlAqjmk7FJfcBRX6EGL3JyU2ua4H27zIDzRbvG92YyjyAA3smXB+6e9sWAGKyVhcuzAPQCAi7fhoiV28dNjJGS4vuQ/ecRFVVI9PtWl5OcDgwBiSSTPgcz2eQSSagqsBc2R8bXqfw6eag5NJJjIxpOpWW+eNzRSeFJiYmkXbBJ12m2QzgKNmKfhiuqlncuGfK9aG7t+lBuQAGevGChrVaatB2IBKRK6YLRsZocXHe9+vNsJSX0ztmkykmfI7m08jq09/nfLbokExDr0xNNpXE2LhGhBAs8RTynOPjk65rq+h+/wZvh40qFb3xos2uD71It5+KEHxqWKsmBl0J3MunC6glCT792U/AnKnibj/1zzxTAFJZJnwWsikM6tO1/Wa7iQ1yGpJKJJ1MYGJcCzRF4LO0rD3n6NiE69oq2n7W1ziTp9R8kOt3b3F96MXbNfuZEDAsi5zVFWXQlcC9ZNMQ6int/Cc+gR9hynQTHKYGgEyeCZ/5TArDOa0a0C8+DQLXYQglkVQygclNGj5Xi/xJdeIzFEYnuiba00ITddwJbWo+yHUXOQfdAHDxDg2fSRH41P37VWXQlcC9eNMgGgY+/dvPfhXPQffBgwfxjne8o+vn27Ztw8zMDBelYgkgDEYvmVAwpZeg+J0geXZmFgDQSA/ZDkSiZcuU5uhXBWQSm7oDuGPLtOvjLp8uoKJnNM/NzXHVgTCoJeSxz+UAAIDLdmlGMd0QdyiPjE3YDpwhkk4mkB/WAtH5BX+HcqnSRLWhsf/umW6q9AygMjXO+EwkFEwNa/j0W8J7dkb7jOupQduBSLRs2azhs7bCH58kQNk+7Y7PSzYNGRnNc7OzXHUgGfxeAR4AXK7jM9tc4aoDYB6wwyPu+EwlExga0XCysODvUC5XG1itaxlCJqexC5/OAYSiKIEn7J/VP+NaYhB7JgddH7uV4FNA9ow4gNt64POiyUFUE5qjxBuflRUP+Ny9HQCQba1wXw21oONzcGTclcBNJhQMjWh48es0VuotlKpadsq1vNzAp45LhvNdUZTAE6LP6ed7JTHoSuACwLZpDZ8iqmPqekXYls3uZMyuiTxqekaT6M5LjAQDA6l+pY7PTHuN+2ooclYPDo+5EriJhIJhPdGx6BOftWYLi6taQsY1091lPxnX1gbF56x2vlcS7gQuYJ69IrKqVQOf7mT29rEBI9A8yzlOIgmGFQxgfw98XrVHx6da5b4lZX5e+0zyhTFXAldRFIzoFZ9+kz79LJ6D7mw2i1Kpm2V+5plnsElnlGKJUBiN3uaAfV8zutEbKDgPTCCyc6tm9Fqcs7uqqiKhs3wXbXdnoJMJBcm8xr6dOc/X6D1/SptlUEsMYqrgPnTkmos0o5dDDatrAQbd2AjJNExO9r4Px/Xsmd/qA3JYjubTrhkI50NZ7C7k83pgkB0a64nP3VvFVR8ojPhMJBSkdXyePc/XaXzu9DkAmoOyZcSdgLj24h0AgDSaKK3wJYaMrD8TPrXH+K0+IGRNIZdCPmM/YwGAb6cx6NqwczoplGHA5x5SfSBi6Iz+nLu3uwfdiqIgMzgKADjH2Wl8XsfnWmKwJ4F77cWa/UyijWKRb8a9rGNtYqI3PicnNftZLgazn/lMEgWHGSAA/Ac1AecOEFI9MzjqSpABwB49u6sI2Lqg6vMDdm/rjc/s0CgAMyDjJc+fPg9AG5Lai8Al9jMBFUvLfDP/JOs/zoDPTZPBqg9IBU8mlcCow4wFANS8AXZSCAjuf57RbVAq3xuf5OxVBGR323pFyK6t7ue7oijIFTRC8TxvfJ7R7Oeqku9J4F530Q7j+wXOWeZl3ZcklVluMkWqD0r8Ex2yi+eg+/Wvfz1+7/d+D42GxpIoioJTp07ht37rt/DGN76Ru4KxeBSGTA0Q/FAmZXUjo86lu0Qu2akdyplmGcU1fuza2eUK8qo2gOfSnc69qkQGhzWjN+czu+skJ89pB4Ay4FxSQ2R6k8mIHj1+hpsOqqoafY7bp92zAgAwrVcfVHxmd0lpJPOObq9BTUAmnJTVEcbfTS7ZoWV3M60Vg93nIeeLFQy0dXzuci/7AoBBPXs2v8D3UD5xVnMalZxzSSKRqYlJtKE5MUef54tPkjHa1iNrBVDZXZ/4ZN+BHDCo8ek0EnwWRtjtZ669gvlygOGCHTJXriJH8OnSC0ikMEqqY/g6a8fPaPhEdrgnATE5No6W7rYcPX6amw6qqhpzNnplrQBgq47h+soyVB8Zd3regOt7DohPv6QlsUFDDPi8lMJnoOGCHXJhpYZsS8fnDgZ8GtUHfM93Qgq1GfA5NjKMOjQS5ejz/PAJmJWC5Ox2k226D1Bf84fP877x2buSjTwv4N//nJ8nWX92fObbqzi7zC/RsbxW1ypuwOZ/GtUHnLO7hBRqZQo98TlSyKMKrYrw2At88Vnxgs8tZvVBu823Ykl28Rx0f+ITn8DKygqmpqZQqVTw8pe/HJdccgkKhQL+1//6XyJ0jMWLeCzv8bO2odlqG0NTJid732CjoxrzVUAFj5zix2wdOr6IIWhGdGCot/ElDNzy4oKvg8hJSLllTmfaXSWZRk3Rrv0xjk7j8YVVw4He3qPUXnuMdiin6mVfbDNTvxfgmwnfYjiN3g/Jdls1Sv5Zsv7kMCxgDYdP8sVnAWsAtJKrXjI+rumxvHSBLz6prFVPSSRQS2i9Z0+d4IfP04sVw4Em2HMTguF0c8WXo2SQQqzrbjwGNVsC2M92W/WUVSWBeQEVHD7JL3t2+MSSgc8hBud1QrefpWW++CRZqzQLPhXF6Kf+0Ql+pNDZ5QrSugO9o0epPWDiM9NawZkl7/gk6xBF4XM6wNowVVXNrCpD1ooEPsOo4NAJjvbzpInPAgN5alYfLHJ15A185nuT6gCMwV1Pn+SHz/PFClJ6S1qvVjrAtLG51gpOXFjz/Hqe14V5rGQLYj9VVTWyqiz4HCgQ+7mGQ8f5zW05TOFzZLS3HgSfK8VFtDji87ReuZkaGGV6POn3f+YUv21Tc+WqMceAyf/USaFcexUvLPBvZZNZPAfdIyMjuP/++3Hffffhj//4j3HnnXfiq1/9Kh588EEMDrqXNsQSgng8lP0wjU/NlI0M3uREb2MDPcNWwBoOcjR6j71wFklFtbyGm0zqDm6yXvblKNlJvdnG0qI+TGOkt2MAaIwkADx/6jwXHQDgEOVAp/OjPR9PSIqCUsEhH4688Eyiken2nql5Zq5sBHgTHvA5hCoOHefHQh85PoOMok8ezjLgUycIUo0yTvpwlOyk0WobzDorPts6PklZOg85eMIkIFiC/+ygRlIUsIZDJ7zjk2ldGBC4PNKP/Xx+fgUZHZ/EEXMVfQ1kXqnh8Av8sniHj89jQNErOxjwSdoCMs0VPD+/ykWHZquNC3rmnCXwB4B2RtP1+Gm+9nNYx2eWgTzN6hguoIKDPvDp334yVrIFqBQ6vrBqBHgspCXBTlZp4JEX+LUeHD4+jyGlankNNyHne7a1gmfn+Djy7bZK9VKz4ZOcJy+c4Xy+Kxo+c0O9CVziA/jFJ9NkfSBwJZsf+3l6sWIMAmM633XspJQ2HnuB32dykEr6ePE/c+0VPD3Dp9S93VYxp2f9B4Z74wIAFP08OcERn4dPLGFYx+eAJ3yu4SBHoq4fxFPQ3Wg0kEqlcPToUbzkJS/Br/3ar+H9738/Xv3qV4vSLxav4rn8zLvRO0Q50AmGkmra6D1+nN+N/sxJjalrK0kgne/5eJJJKSj+DiI7eeJs0ShxZynFA4Ckfs3OzMz4X9nWIQdPLKKg6AcAg4NCEyF+shMkU+M6RA0I3DPrp3z3IEVAJD3gM6GoOHqcH/v71AntuVQoQMZ9GBFgMtXDSgU/5ITPJ8+VkGt5w2dKz+icn53zv7KtQzR86kRCKPj0m6kRH9R4x6c5KIhndvdHdKUNw2eS0nUtKGvc7OdTM2Vk9AwzKz7Tgzo+5+dQa/pc2dYhVnwyfCYEn4o/p5EEG65D1ABfg9QAeuaAd9KSDvCYsmeC8HmMtsUMQQ25l4Z9Bpp28vRsGemGN3wSUnF+Yc7/SsEO0Xwu9gCP3M8FxR9peZ5l8wMQvP3Bl/0071WWBAMyg5qPCOApjtUHR49TSR8G+0l8Zb9EiJ08P79iEBAsrUqASSouXFjwv1KwQ35IxQRe8cnrWvSLeAq60+k0du7ciVaLjyGJRYCEMD3y4MklbwFeZhCqbvROnD3P5SAqrjXM3uzsMNCjl8V4HPiyazQBwdIzC5iHcqa5gifP8xmORJfihWH0mNYxAf4HqZHys5L3ioRDJxYN1pUJn+kc1EQGgFaqVakHx2ep2sDMvFbWrWYLQILB1FoCTT4HEe2gsONTY6qzrVUcO8dnWNVBi9PIToT4JciYdsgDwQepBSQtmQK8ZBrtlDbA6czMLBdHaaXWNIZltdN5bV1aL8kRp5Gfo6TdqxouEiy4gGk/B1qreOIMH3zSlUJs9tO8Fv6CGtaZGKQSw29Pt3f7edBrgJdIoq2TijNzs/53L1NSqbdwRh8oqSaz2rq0XpILFmjaySHKfrLik5D7A+01HDm9zEWPgxQREgZpaZBCzPYzvEFqh056DPAUxSCG5hbmucwVqjZaxiwfNZEC0u4D9gAICTRpXHi1n4PqKo6cWuaih0bUeU/68G5J6QfxXF7+27/92/gf/+N/YHFxY7ETfSOep0NXPfXnqapqdRo9Gr1sexVHzwZ3lA6forLtjMGEiEOZzloxGRuYwQ+v4H++XMPphaKnUlHa6P3ofMmzo0QyKP4ziayDVmqe+0c1B9qD00g9bqC9isfOLHt6PTt59NQyhlRvh6E1O8GLFFryFuCBwicnPS6s1HB8vuy7EuPp2RKKFa/41Jw51x3IgHvQ7YK7LVR5pNf+0YMnqawqIz4JhgbVNS6O0pFTyxiEX3zyc5QOeiULAShZOuMeXI/iWgNPz5bMUlEP+BxCFc/NlbDkcQCjf/vpDZ/z5ZrnaqpDJ5e8kZag8VnBozzweXrZqCBjtuFZmhTihE+vZAwARb9mw5z8jFK1gadmir5IoUGlhpMLJSyseKt4YLefDqRQZQloO5PX5HkXVuqeq6kOeg3wYPqIBXWNy1yhJ84WjRk6zEkfi9+3yGUuxqETi0ZbDPt9QhPawa/FSq2JY+e84tNsSZlZLHIdwCi7eA66P/3pT+Ohhx7C1q1bcfnll+PGG2+0fMUSsRCjVysBTWdHgBz2lYa5L5RFzixVMFuqeT6UFSPI43MgHqR6SDwbG1Tw7NyKZ0epU9ptFYdPUmXdPowej0P5MM38Us/PokNWaSClNjw7St57ZjsO5cYq0HDOwhAmvN5sY8kDM312uYKzyxVvpaKwEiE8PpNDXsv9AepQruCFhVXPjlKnqKqqZQV83ifDnDKah08umQENqx5US0pOrXl2lEjPrO9Md6sG1J37ljcVslAUoNlWccGDHZkpVnF6seIfG5wCzYNeq0EoHYaxhlOLa4EdJYPA9akHr3v18KlFDKLqaT4I3ZIyhKrnAYy+e2YHdNJSbQFVZ/J6YiiLZEJBW9UCG1aZL9dwfGHVc6AZtJy5UywVZJ7vEe0MOMdhUrU/O06XEQe/Vx89tYy02vA0H4T+3IZ8ZBN9VwoN6P28atsVn+ODGWT0XeNzZXY7srhax3NzKz7wybc15qCPCkeiw7Ci+dA85godPBnEz1jzNc+nU46cWkZCbXpL+lAtKX6rMfpVPAfdt99+O37zN38Td999N970pjfhDW94g+UrloglNwIo+sdacb6hcukkRga0/YtenCdisEYSHkpFAYvR430oswZWxNiMJTXdg06qfmFhBUtrDYwk/OlBGPmgjKeF+U0PspWKdhk99s+k2mgZq7XYncZx83UT+t5Pl2qMTCqBiUGt5NtLCRp5H6MJ/0QIr6DGr+NK8Bn0IDpxYQ0LK3WMBAjwDp0Mjk9L6wNrqWhmENBbUgqo4OBxdnzWm21cWGXNJHaQQuk8kNL/xqUaI51MYHJIex9e7Cdxcsb84pOTo+S5RJPSYTSpvd+g+DQJXL/3qobPoJOqLdlMxvkgSOeApGafCljDQQ+fSbPVxvyKz0x3OmfOh3DBZzKhYKqg4dNLCxmZjj+WZB9gBqDrTAsqWgubT3zq99ahgOf72eUKzhWr/sl9ZQ2PnFwKPKnaks1knA+CZBrQW1K8+lzttuphO0kHPpNp0yd0waeiKJga9mE/TwTFJ58qnUMnvFeDEB1MfAaz4waBG4Age+TkUuC5QhZfh3p+V0kkAX1g60br62bwzq3yoQ99SIQesfCSRFJjG9cuaF8F5/H9W0ZyKFYaOF+s4rLNBcfH0XLwxBISaCOv+s/ifVd3lBIJhpIcG6k2WnjsdBGXenbWtMOABCEHTy7i1Vf1Xl/kJMS5mMrUgYYXPUzju7BSw8kLa9g96X/yv+dyf8A0evWy5+zZnF4amU0lMJpPOz+wUdEy2oB5KCuK9v3KjIbPEef9q9MjOVxYrWOmVMFVW9nel2a8VQz6xucavqU7Skmf+Kw32zhyehmv95vBU0jQvYhbr+m9fsNJyEG2Oesfn4urdbywsIqLNzE4ei56eK4GIS0p1WXPZe5z5SpUFcgkExjPZ5wf2KxrFUGASQoRfJbOavgc2+X451tGcpgv13C+WMU129gIN+19qBjy2JJC4/P7uqOUSnrmzAFoE+0fPbWM13opp6Z0ILofPLGI267b4ksH8vcAsDlb0/DpUY+xRBXFSgPPza8wn192cqgTnyylooCm79qCZ3wurNQN+0KIG1tpNYHKsvY9sZ+AhtX6ikYYTVzs+OfTIzmcL1a1vu4do0y6kXNgyKcjP6ys4cHTS2i02kj7xGerreKRk0t4tV98qmsAtCqK11/fe3+yk5AAbzpTB5re9RhPVlGuNfH0TJn5/LKTriGULPNBiB4rFa1iyQMBcWG1jmZbhaLAIG5spd3uJi3J99WiHnRf6vjnW0ZyOLNU8bQ2jBApw8oaoMJD0scMNO8/s4xas4VsKsn8urS02xq2Xm7cI950yKtrUNDGwRNL+Om9233pAJhB+3SW4JM16aM9biJVxWq1hadmysznl5MenpM+gIbPelkjQjiuwpRd/FlFAIcPH8YXvvAFfOELX8Cjjz7KU6dYgorACdGHTix6LxUFDIMzkTIdJb9y9GwR9VYb09ma5bl7iq5rtq0ZvaCMJ3Eaxz2zrpqB2zXUtDyPH1mrN3H0XMk76wpYiJBHdUeJRejJ0Iqbg0oO5ETKqpfnYUDsZdaHTiwhjxoS0EvxPOJzU7pmOEp+5di5IqqNNjZnah510HCRbVeQRMuTo2Qnh3zjU3vcrsGW5Xn8SKXewtGzVL+XD3wOYw1HdEeJRUjmZGo4607skUogJQHkRs2fM04w3+xjAu/BE4vIooGkqrf0eMVnpobVuuYo+ZUfnS9hrd7CpkzVlw5ptY4MGoEdJRLgTaa83icEn8HtJyFwg+CzgDU8fmaZeUAowctUIetO7FWXoUUWMMt2AaEbSg6dWEQKTWRUf2frVKaOaqONY+f8Dwh9aqaElVoTk2l/+EyghQHUAmfcCa4m0/7wuXNQa4sKcp8QAtczqU7pUUAFx84WmQcwEvs5OZR1J05qRa3NATBtJiB0mNrBE4tIoI1c2x9pOZ2pod5sB5or9OzcCkrVJiZS/s5VBSoGUQ1c8Un8100+8bkjH9x+EgI3ED6VNTx5TrvnN4J4Drrn5ubwyle+EgcOHMC73/1uvPvd78a+ffvwqle9CvPz/HaIxhJABK1tWFqt41m6n4a1VBQwbsbLR7XALsiNTg7TS4c99OABxk2uQOvD8+Io2QkxeoOeB75oj9s+0LQ8jx85cmoZrbaKXXmPTjylx5acN0dpxvNk0wlr9ohxmNpmjxP2tYFIZe+looBBhFym4zOIo0Q+z0tH2NeJaDqYjxvy6Ci56eE3a7VtQGshCOK8PnZmGY2Wih26A+oNnyO6Hg1PjpLnHcgD49bskUf7yUpalqsN/Oh8qaNUlDFDq1+3y3RM8bCfl4/qP2DFZ0dLSlBHiTidngNe/VpsHdCDmgD4JATudh3rfuzn9nwTjZaKxxknqXvul82NWrNHgtaGEQLXc6ko9bjLRnT7GQCfhwx8EvvJmIXraEl5aqaEUoBJ6kSPYY/zQQiGtuS01w5iPwmBuyXnoV+2Q4+dgw002yrzJPUZ5nkD+mecKVj9QK/2k/F8JwRukKTPpaPEfvr/TIjtvXzMo/+ZyhmtdQVU8MzsCpbX/M8V6mr19EpAZLXXDmI/CYHrOQFG6bF7sIm2CjzKYcBdP4jnoPtd73oXyuUyjh07hsXFRSwuLuLo0aMolUp497vfLULHWLyKx7VhrOU9pAf6KkJq+nBQLh4mh7L/G4wc6Dv1TDHzjU714e0a8uYodcpsqYpTi2tIKEC6ueJNDyMroBkqL/2AnUIOj2smFW86UHrcsEn7W1ZHaYZ53U1HvxcRzxP22QaOPHJqCaoKXDlOHYZeSkUBXFwgpFDwQ3nPkEcihOrDu3i45clR6pSFlRpeWNDIoIxnfGrO5WSaHMpBHGjtb68LgM/rdHyyfiZkHRP7DmQnfPK1n4+eWkZbBS7ViR2wrpIDjOt2UYFUHwS3n57xSfXhXTrSDuQoEQIXgLGn22uZJsmE8iAgrpvUPwfWwAow8TlJ8Bm2/WRcC8poPwmBe4l+RnsuFQWwe0jDZ7DPRPtbgnXPLSkArhhrQ1WBR3xWCxECF4A5pdpHVR8AHDzuf1I1uc+v35TwpgOlx7U6tlltxnm/68KICLKfhMDdU9Dtlo+kz+5BkugIfqZdVCB23AM+dT2Ij+J3rhAhcAFt4woAz/gkFXBBJqkT+3nDpqQ3HSg9rp30dr73u3gOur/2ta/hM5/5DK688krjZ1dddRXuuece/Nu//RtX5WLxKYzlkdMj3phGEhzum9ZvMB8O9I6AJYHttmr09WzJ+s9O/NjWVCA9yAF27eYclJZHPXQdCEP5wvwqLvicVE0ysqSCwM+1uFKHC7vTqOnqeR0TEc+75NmuDdF//2b/+Nye17MTPh0lbWK4jk890+FHjxdt0fDpN7gif3fV1ACUptehh5oOw8oaFEUbyOZlwiwtBzuzVn7wqVfWsjpKxJ5tER3UeMzUEP1fNK0HMp5wYWb9Af+OkqqqxmdCnstPoEnw6ddRIs7mpZM5JOr+SKECKkgo0PtC/U0CJp/JFV6zVoChL/lbZtLS77owIoz43OKxUoh8lgf0z9bPtdhGVR/4x+ei5bn82M99m4PZT0Lg7pnII1Ere9OD6i1PJRTMlKo463OSOrkWxAb6uRZeqwtJ5Y7/851xLahH/9Own1v1OTK+qvpIyb//AYzkPtkRoLqQ+Ch+7SchcHeM5ZAgc0k84nMQq0gnFcyVazi9GMx+XjXhsaqP0uNSDtUx/SSeg+52u410unt4UjqdRrvd5qJULAFFUM+XEWiSrJUPYzOVrgVylJ6bX0Gx0sBAOmlOqPZxo++d0oye3xudHGAv2U7uBe+loql6GZdt1gZU+Zm02my1DSafZBj8XItLqOoDFkdplpkJ16+tXybcY/nuoc6slQ98TqZrgRylFxZWsbhaRzaVMHupfeixd0p7D/5JIR2fOyhbnfWOz8v1AVWHfTgHZCASAOwhWSsfAd5Fw3p2l9FR8h7UBMvUeA1qSObeDy4mUtVAjtLJC2tYWKlpQ+ZS/vF5ncfqmE4hBO5LdlKfkUfSMlkvGQOq/ARXNIF7Ecnu+iBCjOoDRnz6ngxNhLU9xyCF2EhLQuCSyic/12IsWUEmlcCF1TqOLziv3HMSMtE+lVC891IDhn25fpO36oNOIX/34ztyZt+yx9kciXoZV+sDqvzgkyZwSYWgn3t1j+4bsE6qngmMT4+VbB7t516S9ffh64wmKsilE1hea+B5H3OFzukrSZMJBVNk5oAPPYgP7dd+kr/78Z1DQNtj6xaZfVAr41odn37uE5rAvSQAPonv+uipZea5Qv0snoPuV77ylfj1X/91nDt3zvjZ2bNn8Z73vAevetWruCoXi0/xOkiNwehVGy08fmYZAN1r5d3YpBsrgRwlYhz27hxFol62PDeT6DpfrV8iv4wncVD2G1l/76WiqJWwf7fmQPkxvk/NlLFab6GQS3kfRkTpsSVX9+QoEbJEdKbGS1BTa7ZwhOBzjDjQ3gO8VEBHiXyON+wYRaJOGGjvepDMht+VHmQIm5G1Sue18nUWofD5oj0aPv0w8k/PlFGuNTGUTWHKlwOtPXY6U/fkKM0y98wSUsgfPr0Momy02nj0tHYNrxzzbz+T9TKu2z4KwJ+jRP7muu0jSNY9ZvAoPUiLkV9HidxbL96iY9JHqSiqJezf5d9+0gSu56GHgIVIHswkUa428cxc7wF37D2zvNpzqj3JVJrAvYq8nI9rkayXcYOOT1/2Uz9Xr9k2glQAfJLqgyOnl1Fv+sfnj23T8elpPoiJzwO7NEPu516lCdytvnq6SZtQDYVsinkAo+8d3UQ8289aT3zSBO7VAdobE/Uy9u4gn4kffOo6bB1GqkHaYvxXxzx+puhrrhDR/cXb/Cd9UC3hgH6++5lhQxO4WwNU9U0kqxgZSKPSaOHJAAMY+0U8B92f/vSnUSqVsHv3blx88cW4+OKLsWfPHpRKJXzqU58SoWMsXsVj+dmF1XrPycCPnymi0VIxVciaUxt9GBvUgjlK5DDcv3scqPoPanYMNDw5SrSs1JqGcbjOV1aAMnq7/R8ARjn1rjEoAQK8VH3Fk6M0G1J5JHn+YqWBSt0dn0fPFlFvtjExmNFWuAG+8RnEUTJKNGl8+hrO1PDkKNGyVm/imD507PqA+DRIIR+HMvkbC0HmM9D04iidL2mkUPDyyB5Bjf785Vqz50CxY+dKqDbaGM2ntRVugH/7qdsMX5+Jnf30Q4Rk674dJZrAvWHKf1WK9V4NRuAGISAS9TJu9KAHeyYxYKWQ/vyVRgulijs+aQI3iAOt2Qwe9nPMXOfnAxubM3WMD2ZQa7Zx9Jy3uS00gWvBp8f5IJqvMwogOIGbDJBgSNRLBj5ZfC6CT9HtYyTorrfaWFx1HyhGE7ikBcwPAYFq0fC5/PmfxOcaN/HpkwiZHMqi3mrjCY+T1GkC90aCT09JH/1aNFbxoh2a7kHs53XbR5Bu+MenUi9hfwCfq9/Ec9C9Y8cOPPLII/jKV76Cu+66C3fddRe++tWv4pFHHsH27f53zsXCURiN3mg+jUxKg8BcjxI0cjMc2D0OpeYnwKONnv/smanHmLayAvDHyDe8OUq0PHpqCW0V2D424DPDbBq9/brRO3q22DOw7BReDjRqRWZHqd1WzfJI30w4W1BTyKaQz2iVBL2y3QeNazFG4TNgoBnAUdpPO41+HPla2ZOjRMuR08totlVsGckFyjCjVcOB7Vp259i5ElY9TqrmRUCgVmJ2lFRVNUgh0ZmaoWwKhaxWSdCrRecQRZB57hEFOrJnAeznSdp+BsOnX0eJJnCDTL1Fu4n927XP2M+kaov9DBDgeSGSVVXlmOl2x2cuncRoXsuE9bafNvj0fa8Soi6I/aRJde/YUGqmI+/VftIE7vYAfeWAigNbtcGtT8+WUVzzhk+L/Qx4phnkPsNnwl4pFKw9J5NKYHJIuz698EkTuEEICLq60M8AWwspFOBMU2p0wsWbHjSBu3PQ4zBhwKLvPn2+yHNzKz2Jj06xtZ++YoJgPle/ia893Yqi4Cd/8ifxrne9C+9617vw6le/mrdesQQRxvIzRVGY+2oswURAB5oEeF4dpfPFCs4sacNz9u4c83koUze6z4w7t8MQ2rqZ6eGc50nV9MAZ/3qY14LVUbqwWkezrUJRgE2FHuWgAZ1GCz4Zgxr/AZ5+LSh8enWU5spVnLigDR+7cVfQ+6ToyVGihT4MFT8BHtX7vSXbwLbRAbT84PM4HwKCPpR7OUpLaw2jnFR00A2YE9J7tegcpIOJgAHePj2Y8OooXVip4YV5rX1kX2B8+neUrASuDwc6M6TtVoeW0dw5ntcnqS/71MPvWdId1PS6FqVqExW9nFR0pRDA3jdr70D7uxY37hyDogDHF1YxX2YfELq8Vsczs1rJ7v5dwTLddPDvlZyyErg+8EmthppIVXHR5CAA4PApb36G1efyn2DobGNzK+VeqTVR1slV9kqMAPaTscXR3ufyXtWHakmrvFKA04sVTzvCS9UGnprRXnsfnfTxqYdf+2khcOs+7hFqS8posoJLp7S5Ql4nqVsIXF6k+kn/k9T7RTwH3e9+97vxx3/8x10///SnP4277rqLh06xBBXGQSuAeSi7rW2gB87wYF03D+d8OUrGROatwxjKJIHAjDybo9StR0ACgjJ6Cl0u6iH4P71YwVxZ66e5bvtIYKPH6iiRQ2pyKIt0sof5YCmP7GFgWQ5lGp88nMbJoawvR4kMG7tiehjDuXRgIoTVUeoUazWID1xQq6Hgk5E/u1zBTKmKVELBDTtGA+OT1VEiv5sYzBhVPI7CEtT0uO4spJCqqoaN4RHgjQ1mfDlK5B65bPMQRvMZbtkzr45S4GoQajUUXc7sxX52EbgBA7wbdo4imVBwVh+05CTEjo0MpJFLJ92fvxc+K0tA2706imXuQBeBGzDAG8mnzQGMHrKJBMsXbRrExFA2UPtYJy784FPzdXwEVtRqKGu5Pfu92kXgBgw0r98+inRSwWyphjNLzvgkdmwom8JQtse6uF74rBaBljtpbdpPZ5+ji8ANeJYUsilcuUX7v5cWnUdOahPtd0/kMVXIca3e8jJX6GDQahDAIfhnvxZdBG7As+Ta7SPIpBJYWKnjxIU19ufoQ/EcdP/zP/8zXvKSl3T9/Md//MfxT//0T1yUiiWgEKPXWAPq7gA21ja4HMrPzJVRrjYxmEniiulCYGMDVfXlKFn6aeqr5lRRnzc6q6NES6PVNogC3wREhx4GI+/BgSaG99rtI5rzFtDosTpKzP1eQO9DuVXTPkcX2cKwy/P5+RUsrzWQSydw9dbh4Phst305SpbSs0YV8LpKrkMPVkeJFnog0v5dPA7loi9Gnjz26m0jyGdSAQmIIgq5NJOjNFNiHPIHOGdqBnSSSG2ZAYiDsAz7O76wigur2rDCa7aN+AzwzJYUtJq+HCVL6W6roZ0PAJhXyQGWSgw/jlIXgesnwAMslSlmRtPLtaAI3GwqcICXz6RwjTEg1FmP86zrmABn+zlA9kepQGXZ9SlY7GcXgRskwGtWgWY9mP3cNa6RCQHLiK/eOoJcOoGltQaen2ebpN5F4Po5Szr08HOvdhG4Ac+0gUxSsz1wv0+YJ+sDzvjMjRiVKKi4f/4su+S7CNwgvk67CTQqZmWfjzNt/+5xjYwN2CZ01ZZh5DNJlKpNPDvHNkm9i8D1c5YAtsG/J/vZSeAGxGc2lcT123vjcz2I56D7woULGBnpNsbDw8NYWFjgolQsASU7DCR0lrLiDmAWp5EchjfuGkMqmeBq9LzcYLYlRkoSyAyy60Hd6KyOEi1Pniuh0mhhZCCNSzYNcTqUNaP3yMkltBgZT2N6uv63gQNN6rncHKUZ1nVhqup8KGfyRqa/57AVhvJdY5XIjjEt+x6o5F8F6iv+ghrjM6Hw6WWqKK1Hld1RosUYiJRN4fLpAqdDWbsWj5xin6RuZM528cMni6NEMiY9+2UB557EdE4rYaYf4yAsmW6i7w3bR5FNJc1A02dLil9HyTqkihrOx7pKDrBUYvhxlLoIXD8BHmAhhci18DKp2kLgAj7ng5iBPwAmcoq5XxZwJoWSafNzYBxW5X6+dxC4Qe5VwNrX7YsU6sSnv6Amk0poQZoHPboIXI6k+mOn2SdVW+5VIDCprj1X73J75nkDgPP5nkiaxBCr/XTBZxeB6wefVEsK7XN5s5+kAmLMmvTxeaalkgns3TnqSY8uApdDppvg4omz7Pi0ELgAF3wG2eTTT+I56L7kkkvwta99revn//Zv/4aLLrqIi1KxBBRF8TxB0t3odTgoHIyeV0eJ7qexlBhlC+xTRWmdu250NsbTMnAmoXA5lK+Y1rItK7Wm8R5760FlBQCuh7Kb0ZtlPZTrq1omG+g+lOmfcQlqqMMQ8IdPqg+PdhpZHaXVWhPHzpHr2IFP1qmigGOgyZoxItfixl1jSCYUfwEeYMHGpVNDGM6lsFZv4Ufn2SapW7ICQODySO25ejtKBinUK1NTXzMzvbb4JC067g7AZibSsoMgM4gQD9eCakmh8cnqKFXqLRzVp+RqFRA6LryskgNsiDpvjlIXgcuBtLx40xDG8mlUG20cY5xUbSFwgcAl/9pzseOzp/1s1k2cdJJCgOcJ5m6kZReB6+csSSRNooqqjjl6roS1eu8BjNpEe+2zs5DqyYxGgrFKQPvZReBywOfuiTwmhzKot9rGPdhLLAQuwIdUZxgsx0yqt5pmlUWA8920n87l5V0ELo+WFN1v+tH5EsoMc4XqzbYx02R/Z9KHdZUc0H2meZwr1EXgciDVt48NYPNwFo2WiscY57Z0kUJcSHV/7Z79Jp6D7ve+9714//vfjw996EN48MEH8eCDD+KDH/wg/vt//+94z3veI0LHWPyIx7VhLJmaQKxrh9Hz6ig9emoZbRXYOZ7XDgQOxgZgc5Ro6QomOBzKyYRCTarubXAWV+t4Ti9H2rdrjEOpqNWBdnOUSJki8xCgVM7+UPK4lum8W1DT6aBw6MPz6igdOb2MVlvFttEBbBkZoHTwH+wCbI4SLcZ+7iABHmDBRiKhmIPMGPQorjXw9KwWnO/fPQa024HnL0BVmRwlUqa4pZfTSCqAEmn7TC+r/WQhhU5yCPAACza8Okpkov30cA7bxwa4kIWAd0epO8McXA9FUbDPcF5769FF4NKlogFaUogOT8+WUazY45PZfhJ8KgkgN9r9e49Bt1t5eReBy+FM2zY6gK0jOW0AI8PclifOFlFvtTE5lMWuiXyAe8RsSQEoUoixd7eLwPWNT1MPRVEMvLME/10Erl89iA71FaDdMgYwPju3giWHAYwzrO0P1WUAelWe0e5AiWf/07m8nJ/PZVamTI/ksGN8gHmu0NFzRdSabYwPZrR5L7QOXpI+gUmhDoKMw1miKAp1n/TWo4vABYIlffSWlH07ted6YWEVCyvsAxj7TTwH3b/8y7+MT3ziE/iLv/gLvOIVr8ArXvEKfOELX8Cf/Mmf4G1ve5sIHWPxI4wTzDf3cBpJv3MyoeAGvRSGh9Hz6igdcjQ2fssStb9ncZSIqKpqHN7mYcgnuPKyG5oMnLl0aghjg5kApaJWo8fiKPlaF2Z3KHnMdDvNHJgpVnF6kQxEGtV+yMFp9OooHeSRbe/QAQCTo0RE6/dyyJAEDf497IYmw+cumhzE5FBW781UvevR0ZLC4iiRjEnPTDcvfPbIdM+Xazi+sKoNRNrZSYQExKcHR4m2n4qi8MOnR0epi8DlpIcX8rSLwA06H0RvSdlUyGLP5CBUVWvFsBPmnlmCu4Fx+0oZr/bTAZ9dBC7AjZDZ7yGgoO2noijcSPUb9QGMJy+sYa7HhGzAhsDlhE8vM2y6CNyg80F0PSaGsrh4kz4g1MFmMFcKEdzlRoGkzcA1TpVsXQQuwAGfekWFhywzPTHcgk/fZIz29/RcoXMMc4W6CNzA9wm5Fuz2s4vADZr0AboGMK7nbLfnoBsA3vnOd+LMmTOYnZ1FqVTCCy+8gF/8xV/krVssQYRxgjk5/OfKVdsJisTYXLN1WOunAbj04QHeHCXLdFXAXw8e0NWHx+IoETlxYQ0LK1o/zbXbrcbTfybRysgfZJi02h1YBSwVBbqy3U6O0gyz06h/pnalkYDnoGZ+pWbb706CwCu3DKOQM8vDAfALNJkOZady6mA6sDhKRM4sVTBbqiGdVHD99lGrHoGDGhMXvfBJr9wBYN4jXktFO1pSgN6OEnP7g1M/IhGP7TkLKzU0bPrdyVDCyzcXMKLvTOZFhHhxlA46OWsBdfDiKNkSuJwDvEMne+Ozi8D1Ox+koyUF6F2ZEnhHNxGPQc3iah21ZncbQheBC3AnQliIOsdsZkBcFHJpXDE9rOvhjk9bApdbRYiJz16TqrsIXL/zQVIZDaM2ejitXvRFqtsJo/9JgvtStYlK3QafnQQuwJEI8UIKOVQrBQx2h7IpXLWFDZ+2BK7v9jGr/0quxWGGuUJdBK7fpE9HSwp5Tvo11qP4CrqJbNq0CUNDQ7x0iYWnMB7KU4UsFAVotFRcsMmkdR2GfktFAed+wB6OEt1P05UhCXgYAuwlvOQwvH77iNZPA/BjPHeMIpVgm1TteCh71cHG6PVylGZYBwFxchonh7JIJhS02qptJu1Q52GoqhydRjZHqdlqG4QNv0PZxGcvR4kIwcU120YwkEla9Qh4n1y7bQSZZALz5RpOLbpPquYyZAXoakmhn1MWUmhiMIN0UoGqwnbVXhcBAXAjQlgdpVZbNSfac84w08/Zy37aEric9Lhm2zCyqQQWV+t4YcF9UnUXget3PkhHSwr9nE74nGXtmeUU1Izm08bqvDmbvtmuexXgToQ8ctJ9AGO7rTqXdQfBhe5TsJL7tgQuJ3xetXUYA+kkipUGnpt3n1TtTEB4nA9io0evGTbnuZNC7te8kE0hr59VdtVCrvYzYJUjwcWjp5dsCVMi1gqyzgpHnzrUygY+We2nLYHLoX0MAK6YLmAom0K52sQzs+5zW7oIXL9JHxs9/Gzy6TdhuoNvvPFGLC3pAyb27sWNN97o+BWLJMLoNKaTCYNBtCtB6wrw/JaKAl1Gj9VROnauiGqjjbF8Ghdv0oNEHodyWzO0rH01tg4Kp0OZnlTtlhmoNlp44iw1cCaIDjZ6uDlKK7UmVmparzdzeWTAoDuZUDBV0PBp15fY1ePUWPNXKgp09QOyOko/Ol/GWr2F4VzK2J8cmIzR+/AA9mF/XWw8rUdARj6XTmrrhOB+n1QbLTx2mic+rZUpbo5Spd4yWkSC45MtqEkkFG1nK+zxeagzwKNLRQPaT1ZH6amZElZqTQxlU0bWL3BgpbekAOyOUlcwwUMP/VpkU0lczzCp2pbA9XuPAI5lxI+dXu7KLNeaLYPY7tkz6zRZnwhjUKMoiuvasK7z3W+pKNB1LS7bXEAhl8JqvYWnZpzx+ezcCkrVJvKZpJH1CzwAUm9JAdjtZxeBCwQPrnR8phknVdsSuH5b2Gz0IJ/z42eWuwYwNlptg9gO63xXFIWaO9CdbOjyuTgmfS7eNIRRY65QyfHPnp9fxZIx0b6zwtGnDmpbO+PB7n/aEhCcSHV6krqb/bQlcP3acBs9yHMeO1tkGsDYj8IUdL/hDW9ANqs5vrfffjve8IY3OH7FIokwGj3Aua+mWDH7afZ1DlnxWioKdBk9VkeJHFL7do1r5Sy0Hn6Njd6HB5g3+hEbR4mWrn5EgJvTSD+vm/E9cnoZjZaKzcNZrZ8miA42erg5SgQfhWxK223rJpyCGsB57kC52sCPzuvGuhOfXktFgS58sjpKP6Qcg0SiA59+D2VKDzdHiRZ6sr4hgQcS0RlN3Tk47nwtjhoDkTLYPaEP0OOCT83xdHOUSKYkn0miEBifbEEN4Dwheq3exNFzVjKLzhB7KsUDuogQ1pUzxG4ZE+0BrvhkdZS6AjweetS82c+jdgSu3/kgQJf93DM5iInBDGrNNo6eteKTZJozqQRG8z0yQk7rwoh4ON+dNpTYErh+S0WBrmuRTChGnziL/dy7c1SbaA/4z+DZtKQY+DxXNEhjO+kicKn3wqcipHfw/+T5UjeBy5FU3zmex6aCNoCRTIsnMl+uQVWBdFLBBGk1cBJOQTfgPHfAlsDlmPRJJBSmKkeCixt2jBpVI77PtPSAuc63Y1jqUzMllFwmqXdV6NB6cKyo+6ELPm0JXI741OYY5NBsqwY5ut6EKej+0Ic+hHw+b3zv9hWLJMLhUH7k1BJUVXMkNunZRp4BHsDmKHWtJ6D18Hqj2/ThEUep3nSeVL2wUjOy8WR4EABBh7KbA20GeF0EBAej5+YozbIOWQH4BjUOhzIZiLRjfMBk5g18eiwVBexbDxgcpa7SM4seXvHZ3Yfn5igRsR2IROvBM6hxqcQw2Hg7gowDPt0cJbpfVun12QtwGjtJoSOntIFIW0dy2DaqE2TkWmQKWnuHF7EhQliyJF0rdwD/2TOblhQWR4keiGQQuECAUlFrVQrgzX5aCFy/80GALnxqA+4c8FmKFp+dwygfsyNwOZaKAvQaSgb7ucvmXOXQkrJlZADbx8gARns9bAlcQBCpzmA/aQKXo8+lKIqjHgSfU4Wc+dpOwqk9B6Dtp7X9wZbA5Zj0AayzdJzENtj1e6YpSpceU8M57JrIa3OFHKqF6In2tpWWPNosCS6OO88VsiVwOePT6xrffhOmoDuWPhTGlUyA89owktGyzZxxcFCA3o6S7URmWg8/h7Ltje4e/BMDYOmnadbMXdQce8ufmV3B8pr9pGpzvQuHAM9BjwMOBxFzvxfA12l0KI80SnftnDVO+OzlKKmqal/WzVEPN0eJCBmIdPGmQUyQgTN0qWjA8kjADOZfmF/FBYdJ1fYEBL/ySO257fE5U9LKE3v2ywJc8elEWv7Qzm5xDPC053Z3lDR8uthPr5lEGz1YHCVbApdjqSigDRdSFG3g5VzZfhqyLYHr9ywBbIP/frGfB+0IXI5VKYB5prkNCLUv6w5iP60tKfRzO53vtgQux/kgALB35xgSijbw0q6UGnCwn7x9rl0O9tOY15Lt/bw87afD2jBbAldQ0ueQy4BQrm0xDnrs77HJh0y0txC4tB4c8EnmCs2UqjjrMEndlsAN2efqd2EKusfGxjA+Ps70FYsk4uNQ7nQaXQ9DTsaml6NE+mmyqQSu2dZd2sjvRncP/l0PQyBAqaj5HBNDWVzkMqna2k8jLtA0HSXrQcS87gbgy4Q7lO8etD0MffbgAbb47OUonbywhoWVGjLJBK7dRr0m70Czx9Turt5hwFoqyuFQHs1ncNlmLctpN2m13Va7V5oAXAM87bntHSWSKenZLwtwdRqdSEvbdpRAAV43Lno5SmSifSqh4Aa9lQeAwIole3zatj5wLBUFgJEBc5L6YRvn1ZHA5XyW0ANC6QGMs6w7uoFQKoVsCVyO8xcA4Podo0gnFcyVazi92I1P24n2tB68gv8ew6psCVwu80HMazGUTeGqrcP669nj03UuB6drQZ67cwCjuaObCuqchLl9zEPSp8v/FE9AXLNtBJlUAhdW6zhuM1dotlTFqcU1JBRt/ZwoPZjtJ40LjvNBACCfSeFqMlfIEZ8u9pOzr9NrAGO/So/GN03+8A//ULAasXAX2mlUVddS2802h3Kt2cKRM8sAxBo94ig9NVPG4RNLeO21Wyx/Qgzv9TtGzYnhtB6cs2fEUeosr+qa2Ei/D1+lot06ANqh/8L8Kg6eWMKrrtxs+d3TM2WUjX4aKsjnHOARR4lMqt41oREBzOtuAG9BTQ982pXvNlptPHraJajhhE/iKB09W8KhE0v4qeutDgk5hK7bPoJc2gaf3ALNHvi0zWbquEgNeC8VdcDn/t3jeGZ2BYdOLOKWq6ctv3tufgXFSgMD6aThXFreByd8djpKF+m9ud7aHxhJocqSNtDO5f7ebOM00gORRAZ4xFF67PQyDp1YwvaxvOVPyFBGy0R7QFj2jDhKRm8u0cOtGoRTqSh5/qdmyjhoc5Y4Ericz5Krtw4jl05gea2B5+dXcKlOBDBP1gfY7WetqFW0uNzfdqS6I4HL+V7NpZO4dtsIHjm1jIMnFrFzogOfut26asuwdU6IIFL90VPLaLTaSHfg05bA5TIfxNoOtH/XuH6WLOKnrt9q+Z0jgcuZCLlySwH5TNIYwHilPryOebI+wI7P+ooWHLrc32alkFk95UjgBsJnd1VKNpXEDdtH8cMTizh0Ysk4S4gQu3XFNDXRXoAeBHdHTi+j3mybveMdeti2WAJckj6ARsA9dlq7V2/fu83yO0cCl/NZcvl0AYVsCuVaE0/NlI0Bw+tFmDLdv/RLv8T8FYskQoxeq24MDHMSu6Dm6Nki6s02JgYz2DNJHTiBArxuYwO4l37ZlgPSenAKajodJVrW6k0c03u9rQQE31JR+vntGHniQFsGzgDcAzziKAHWz4SUJ/Lp6dYPUrXVhYdOsSOFjp0rodpoY5QeiES/D05OI+CeZbYtPROgh8VRmrMOuLMOROLQzw24BDXObRgk8N+7c9Tq1HI+lImjBFgZea6k0AC5jipQWXZ9KrtMIploX8ilcNlmyiHiHOAB7vu6ne0nXz2Io2Q3gNGRwOWlA1XtYNhPm7kDjgQu5/sknUxg747u+2TGU1BDSCEHfOZGzIFhPbKJdoMoHQlczvcqQBOGbvazA5+c75NLNg1hZCCNSqOFJzsGMDoSuDzmg1CrobTnd/N1HAhczvdqKpkw9jzTZ5rR/jDCobw8O2wODKu449Nu5oAjgSsAn/tdssy2wx8F6HHxpkGM5dPaAMZzVn/IkcDlMR+E2pJCP79dptuRwOWS9DHfczKh4EbGNb79KExBd6lUYv6KRRJJ582BTD1KJKdtyiPp9QSWoS+cAzzyGoDDoXzSJoNH68Ep+HdylACNfWy2VWxx6qcJokOH0SOH8uNnil2Tqm1LzwLr0W306NegjR4JKrb0chpVtfehnMpqhwXQE5/0yhtSTnyIKle1ZH0FOo22jtLJcA5l2lHq1IMMRNpUyGLnOJVJ4uG4UquhAJOAOHq2iErdis+wCAjtNbodpfOsmUQWfCbT5j3qA5/mxgVq4AwghAhxdZTsKiAA7vh0c5QcCVweOrQbGkZ1IffqsXMlrHZMqnYkIEQQITbkqVm+64UUcqjESCRNYogRn7OlqlHu7kjgCrlXeweajmcaJ3zSAxg7gytHApcHPqnVUIBpt+wmVTvaT6GBZjcpNM1UXt6DFFIU5hYdgs+5ctUoJ3YkcDlX9QHWKrJOcfQ/ObexWediWPHpSODymA8C2M4IeXq2jOKaFZ897aevmKC7EoN+jfW4r5sp6B4dHcXY2JjrF3lMLJKIB6NHnNRyrWk4KrY9ooCQQ9nJUZorVXHywhoUBUbA0aWHgCxep9GjD0N7AoKf0ds1kcfkUBb1VtvIXgJ6Pw0ZbMc1wLM3enbDqpjLI6tFsxduwMFpBJj7vsjrVRotlKpNi158A7zuPjzAxEWno3RhpYYX5vWJ9rsc8MmRCHGqgjDL8DoIMh73CP08ALaPDWB62H5SdVhZAe01uh2lWdZMd33F7IVzchrp3/Wwn1P64KF6s41l3VE5dNLBfgoI8JwcpeW1Op6Z1dciCsEnm6PkSOAG0SEzBEDp0mPr6AC2jQ6gZYNPZwdaHBFCT/o3B1X1wueaOQCRAz43FbJQFKDZVo094Y4ErogAT8fec3MrWFw1CTx6JalzpptPUKO9hj055UjgBgmsbFZDAdpnv3M8r09SX7b8iSOBKzLQtCHVe9rPZt38jJ1IIYAZnxNDWSQTCtoqsLBS1/XqRUDwS/rcuEubK3R8YRXzZbPEfaXWNKoi+Ppc7v5nJznlSOAGOUtstqQAwORQFhfpxOjhU51+sAifq9e96jyAsV+FKej+1re+hQceeMD1izwmFomEMagZovYuz+hs+CG7fi9AiLFxcpSIDldMD2NkgOqnoaeKimDkOzLuxOi9iGeJpoPRUxQFL9rTzcifXa5gplTt7qcJqodjSbWmw/P6pOpGq40FfWJ1T6eRHLKZIfdeTcZDOZdOGp//bKmqD0QS6TRag12y0qPTUSL4vGzzEEbzHXtNBRAhL3JwGh2zRUHuEZvVUIDzSqTzxQrOLGkDkfY6EWQcW1I6HaVmq415HZ89SSGCt9QAkMk7P44Rn9lUEuP6XtsZHZ89q1I42k8nR8l2oj0RkURIh6PkSOAG0SGRYHBezWtBE7hdBJmAs2TvzlEkFOD0YgUzRe1MJYNCe+KTlOMm0u69moz4TCcTmNQ/f2I/HQlcAQHe2GDG2DlNDwglE+13T+QxVei4JiJJ9ZNWfPa0n350sFkNZerRHfC6ErgCAs29O0eRTCg4V9QGMKqqyt6eQ/CpJIDcqPPjGPGZTCiY0jcaEGLf9LkEBXjU528ZwEj5fo+eWkJb1YjmruFyApNPXfbTicANco8AnqogXAlcAWfJ9du1uUKzpRrOLNlPUu9XYQq6X/7ylzN/xSKReFp7oxu9YhXPz69gea2BXDqBq7d23EgCjB5g7yg5Zs7oqaIcb/RORwnQ+2lEEBAuetitjyDfX71tBPlMx/xDAUav01GaK9egqkA6qWBiMNP5LFbpNaSKiI9dnueLVRxfWMWF1Xr3QCT6fQTBZ0cfHmDf1+3I/AZZJUfr0XEo36A7SmTiL6ANRDpsN3AGEHYoG+X2J7vx2TUQiX4fHPHZ6SgtrNTRaqtIJhQjwHCUXqXlRPysDStq027ny9pApOu2dzjKPNpiOlpSAHtHyTHwbzWBhj6pN1Am0UqEkAGMtKPkSuAGCfAsevTOaNIE7nCuY+gY5/kgAFDIpY0BVYdOLuLCah2NlgpFgRFgOAqNT7deYp/205XA5RHgNSvacDdK7EpnHe0nvUqOo/28drs2gHFhpY4TF7RKAprA5ZrBc9HDztdxJXAFBHj5TArXGJPUF7G81kCt2QZgVu44CsHbwLhGfjmJhwnmpv2sWAhcy0R7+n1wbEkB7FvIHO1nkFVytB4dNuPqrSPIpRNYWmvgeZ2AcSVwg5wlAFOWmYgrgSsAnwOZpDFAbb2tDmMKuh9//HG0223je7evWCQST2tvNCZvplg1bvK9O8a6pnyKMnq2jlKvEiMlYWbjvIjDjd7pKAHAUzNlrNr10wACD2XT6JEePNv9iDz0cNABsE50JyTEVCHXNTm7SwQENcbasGLVwEXXQCRASB8e4EQK9ehxArxPFaX1qLk7SgDwzGwZ5WoTg5mkdSASrQf3Q1l7v49QK2ds17sQMfDJr1QUsDpKJEMyVchaS/DsRAApRK+9Ibi4tnMgEsAnwANc+roZghr6bzlWYlgHMGqv7UrgBgnwAMfKFIKLR04tdfWIdt2rtB4cW1JoPQ6dWDJKdyeHst1naqcw20/2oIaeYO5K4AY5S+i/YQg0He0nvUqOY1CTTSVx/XYrPl0JXFGkesekasDlXg2qh4MO9GsdPLFo2M/xwUy3zeoUAec7vXbRlcAV0JIC2LduOZ5pQVbJAY5nWiaVMEgw8tquBK5gUv2x0+ZcIcfAn34fnPHpNkunn4Up6L7hhhuwsLBgfL93717ccMMNXV979+4VqmwsHiU/qf3rJVNTqlLlgJwDPBej1+kordSaOHbOZiKzRQcfU0UBphudGH5yLbr6aej3wNnokUnVpWoTz86tWPQJ81CmHSVvO7oFBN3DdFAjCJ8OfXhAt6NUqbdwlEy039XxmQRZJQewESEd+Lxx11jXmqZAAR7giI0rpjVnaKXWxFMz2u+iOJRpR4m5XxbwEdR4y3S7EhAC+vCAbkep2mjh8TM97KefVXIAMxFC/2tL4AoiLS+dGsJwLoW1egs/Oq9lTF3tJ5dS5mLXr+hhf94m64urFJotVt0J3CD3ajIFpPVBeQ5EyBNnNXzWmi08preSOZLqibSJdy/i0JJCvxa5R10J3MD4tNeDTKquNtqGj+NIQATVw5UUIvZzyeNkfYGVQqUam/3k3pKi4eLouRLW6k1tor3eSuaYYfazSg7wFGi6EriCSPXdE3lMDmVQb7UNH8eVFBKV9FmnE8yZgu7jx49j06ZNxvcvvPACjh8/3vX1wgsvCFU2Fo/iKZNo9nwddBo4Awgzep2O0pFTy2irwLZRm36aIENWgB5BjZWRt93PTURQeaR1UvUiimsuA2e4lYo6HwBHzxZxfEF7DS7rmIh4CWroTI1TuSpgOjh+Ak2XPrxOR4lMtJ8ezmH7WCc+A0wVBZiJEO1f/Vp0Bv6AsEPZOql6CaVqwwi+u/q92m2BLSmmoyQGn8R+MmQSqbVhZlDDOcADHLHR6Sg9cbaIeqvdPdEeEEYWAnZBDUOGmbMeiYRiyeK5Eri85oO4tKT86HwJz+lrKKMKauwy3dwdaMDRZmwfG8Dm4SwaLRWPnV7G0bMl1JptjA9mjHkEXTrkhgWQ6qbdAhgrIDjj0zqpesmdwA2qB9GhXu5qSdmnv9bTs2U8o6/5m+5VWg70nqxPxE8lG1UpZO9zicGnZa7QqWU8ea6ESqOFkYE0LunY3R046cNUXWi1n64VZCLwucsM/l0JXIAPPm1aUshsg2fnVrBEDWDsd2EKunft2mVMHd21a5frVywSiYeghqyJeOz0Mk4vVpBQtB7nLglSKgo4GpxOR8k9mykuqKEdpXK1YZls2iXcyiPds3hkONJFk4Pd/aqBS0WdjR7tKH3j2AwAUZnu3kENKT8jBIDtRHtA2KHc6SjRh6HSefAK0gGwOkrFSoOtKkVE8E+t33lUJ8h2TeQx1RlU1FfApVTUpiWFdpS+dvQ8gOgqMQg+nzxfMvrxugYiAcKIkE5Hibaf4eLT6ii5ErgC9aDXULoSuLzmg9i0pEyP5LBjfABtFfi3JzR8elsXxr9S6OmZsjOBC4QTaJ5cspyrXfgUdI8AwL6dmg4vLKxiYaXmTuAKxCdNnroSuLzmgwBmn7wumwpZ7JkchKoCX32C2E8O68KI+LCfz86VnQlcgCM+3SpTTPvZNdGeiw6kPadbhxv1uUInL6xhrheBy+0+cb4Wh04suhO4QZM+Li0pE0NZXLxJHxC6jlaHpXo/pFvOnTuH7373u5ibmzN6vYm8+93v5qJYLBzER6bmMZ3RunLLMAqdA2cA4UbvgafmcOjkIoqVhv4zEcbGueSKOEqnFyv4f4+dw2yphnRSwfWdA2cAjody97Wgy4y26LvBXdlOv6WinUZv0DxIiaP0lcfPG7jwlknkXx5JGNfLNxesE+2JCMziHdg9hvufnMXBE4uo6r143Mupe+hAHKXjC6u47/FzOFes2g+cofUQEtSYBNnuCe1gtM3SkPfgt1TUaEnRM5Jpq1O4f/cYzh6pmPiMKKghlRgEn5dODWHMbuCgQCJk/+4xfO3YjDb9lvyMd+ashw7jgxlcMjWE5+ZW8JUnzrsTuELvVdN+XjJV0H/m4sT7nQ9CWlLaTe25OmY4HNg1jtOLZyPHJ3ldsobSlsAFxAaau8bwlcfP4+CJRaT0AVyu2UwBuBjJawMYn54t42tHZ9wJ3DAqQk4uGQOjbAncoPNBUlkgmdUC91oJGBi16rFrDMcXVn2e7/zbc46e1d6vLYELCEv6ANpn8i9HzuHQyUUM6rMO7MkYUuHIX4dCLo0rpofx5PkSvv7krDuBG7h9zH42B2BdyfnD4wwELhCsJaWxqr2fQSumDuwex/Pzqzh4chGvvmqz9+eXUDwH3ffeey/e8Y53IJPJYGJiwvIhKIoSB90yiY+ghojtYRi0VBRgKmf+4fFFrNVbznpwO5S7g13AdJT+7KEXAADXbrPppwE4Mp7d1+KGHeakasJCcy/3B3obPd1RIrKZyWnkz4R3lmXa4kJVhfXhAVZHiQzAcR8cxp8UAkxHieDzmq3D3QORaD0EOI037BhFKqFNqv7Xx88BYCg981OKR1pSakVNj4L14CWOEpGoSSFaL1sRSITQjhJZORNmiaapxxiem1vBn39Hw6cjgStQj2u3jSCTTGC+XMO/HDkLoFc202epKGlJqSzqz7XN8uv9u8fxpUfPGv8XU17em1TvfF1buwWEEmgePrGEVFJx1oPnPaKqXZ/r/t1jeHq2bODTkcAViM9rto4gm0pgcbWOf37kDIAe96rf+SBEj9V5R5vxj4fPGP8nbYauIrA9h4gtWQgIJ9UBbUAo8ffEth2UbfF5YPcYnjxfwmd1fDoSuALPkqu2DmMgnUSx0sA/HDoNoAep7jfpQ/RorDoSIX938HTXmtR+loTXP/id3/kdfPCDH0SxWMSJEycC9XR/5CMfwYEDB1AoFDA1NYXbb78dTz/9tOUx1WoVd9xxByYmJjA0NIQ3vvGNmJ2dtTzm1KlTuO2225DP5zE1NYX3ve99aDablsd8+9vfxo033ohsNotLLrkE9957r9e33n/iKVNjNba2h2HQUlHA1egRR2lhpY61egvDuZSxtsoivIyNTR8eYDoHJ/W1IraHISD0UB7Mpoxpv656BNWhhx6djqqYnln2TI2plw0+GxUt4wQIwSftKK3UmhjKpnDFtM3r8DqUbfrwABMHBBfiA7xuAoJe6eGqh2B8djpFbEGNV1LIu9No66zRpaIC8Ek7SqVqE/lMElduscmO8cKnTUsKYDpnPe2nQAc6l04a035d9Qg6HwTwhM+oMond9tPmWgQtFQVcr8UV0wUMZVMo15pYMiba27wOrwGQNi0pQLf9dManmEGUgHVStWk/7QK8gK10PfTofE1hMwds/CxaOvFpaz8FJ30umyqgkEthtd7ChdU6MqkEru2cGA7w00FtAfXVrl93+p+O57tAUj2dTBjVSUz2UxA+CQ4eP7NsTFLvd/EcdK+treHnfu7nkHDbz8coDz74IO644w48/PDDuP/++9FoNPCa17wGq6smEN/znvfgX//1X/GP//iPePDBB3Hu3Dn8zM/8jPH7VquF2267DfV6Hd///vfxV3/1V7j33nvxwQ9+0HjM8ePHcdttt+EVr3gFjhw5grvuugu/8iu/gq9//euB34PUQjuNHW0AnTI5mEWK6l0RUioKuBo92lECNGNju56Kl7Gx6cMDug1+z6BGgNEDrJ/B5FAGuyfy3Q8SbPSIo0RESE9iZck2uKRlLJ9GJmXaHFcCwm+pKOCKT9pRArSJ4bbrqXgdykBXHx7Q7SjZOii0HgIqMTpfdyyfNvqvLMIVn93BP3GUiAjBZ61oG1zSMjyQwgBVDePqoABCiBDaUQK0ktmuifZA8AGQLn14QPd7d8yqcisVta9You22I4EbdD4I4Go/L940hNG8mQFiKy8npBBjJUZjVSMcXWQom0KBsuOu9hMQcqalOvB5w45Ri003JChZ6LIlBejGY298iqoIMT8DRwJXMGm5Z3IQE1QWtWvmgZ14tZ/NqjY7wU3FdNJyn9j6XIKTPomEYukjv377SPdEeyD4mZbOa5PPHfRgPt8FZro1PczPwJHAFYzPneN5bCpoc4VI61a/i+fI+a1vfSv+8R//kcuLf+1rX8Nb3vIWXH311bj++utx77334tSpUzh8+DAAoFgs4i/+4i/wB3/wB3jlK1+Jffv24XOf+xy+//3v4+GHHwYAfOMb38CTTz6JL3zhC7jhhhvw2te+Fh/+8Idxzz33oF7XJt796Z/+Kfbs2YNPfOITuPLKK3HnnXfiP//n/4xPfvKTXN6HtEIObbXlWEpNJJFQDJZzx/iAvXMQtFQU6B1oUjd6zxI4vze6y2oooNtRsu2nAUIp0ySyf9d4dz8NDx166NHpKE15mm7a41AeIO9PBSrLrg9VFMXIEm0bHcDWURvnwMCFz1JRoCc+aUfJduUOrYffQ5n04Tno0eko7etVihfCobx/dzT47HSUuPbM5kY0Agfome1WFMV47c3D2e6BSABVKjrkv1S0BxHiyX76zeC5rIYCtPNjqmDaCXGlouykkCOBG/QeAVxbUoTiMztsnmMsJeb6azsSuLxKRQFHIsRiP0Vl8Fy2pABkoJ75OURRiQFY709HAlcwqa7NbaHwybNSKJ03kzMeWnQcCVzBSR+g+0yzlaBnmqK46rFlZMByfgi7T3r6OhQ+nQjcEPDZubGl38Vz0P2Rj3wEDz74IG6++Wa8613vwnvf+17LVxApFjVDPT6ugezw4cNoNBp49atfbTzmiiuuwM6dO/GDH/wAAPCDH/wA1157LTZvNnv9brnlFpRKJRw7dsx4DP0c5DHkOTqlVquhVCpZvvpSUlmtFwhg7PvSHCXbSYmAcAcasN7owoyNy2oowOooXTI1hHG7fppm3SxdE2T09lmcRkEBHoMe5HMYH8zYM7+0tFta5hrofSgnU0BuVPvew6EsLHMGMBzKVkfeXo+AmcQeetCO0p7JQWwq2BAhdKmogPJIwDpd1pmND1iiyaKH/jmMDKTtZy/Q0m6zO42JpEkMMc0dyBr62BIQVbG4ADzaT4H4JK/tSOAKLhUFrGRpT5sh0H4SfA5lU5aqIVtRVfagW1F8zR1wJHC5nCW9SCEG+8mFCOllP7XXdiRwucwHccfnjbvGDG7YkcDleq+6EyG5dALDAwxjnlhnYnjE52bjfGfAZxikugQ+lyOBS+shCJ97d46B8EDCqkEY9CCk7XrZ1+0r6P7617+O2dlZPPHEE3j00UeNryNHjvhWpN1u46677sJLXvISXHPNNQCAmZkZZDIZjI6OWh67efNmzMzMGI+hA27ye/I7t8eUSiVUKt1lWR/5yEcwMjJifO3YscP3+4pcPPR9XbZZC9B/4tJJ+weEYGz27xrHYCaJsXwa125zcNQFH8oA8PLLp7R/L9tk//e0/oKM3lQhh6u3DiOhAC+91EkP8Y48wcMlduWZnVJZhlECNuBgqGnxcChfsll7/Z+4xAmfYktFAc1RKmRTGBlIW0rNrXoEzCQy6HGzBPicGMriuu0jSCjAT1zSQw+B+Hypjk/b8uEufYrmiqheTiPgCZ/Efr7UCZ8hBHh7d46hkEthOJdiwKc4PV5+uYYHR3wKLhUFgNF8Bnt3jkJRgJc52c8QzhJir5jsZ30FaOk7aXsF3fRjGPB5KbGfTud7CPfqDTtGMTKQRiGbwo12E+1pPQS1pADAzTouX+aETy7zQZxXQwHAcC5tEJcvddIjBCLkJZcQ+1mwD3Zpqa+ZpeJM+GT3P4n9fmko+LT/TK7bPoLRfBpD2ZSxXk6sHk7nu2k/bT8TwfNBAI0kJMG/430SIgFx6OQS2m332QD9IJ6nl3/iE5/AX/7lX+Itb3kLV0XuuOMOHD16FN/97ne5Pq8fufvuuy1Z+1Kp1L+Bd34CWD7JZPTuft2VuOXqaecbLASjN5JP48t3vATJhOKctaqJD2p+/kU7sWs833vISqBSUXcdAOCzv7Qfs6UaLp92WBcSQoB3484xfPFXXoyLNjE4jQRnuRG2EsX8BLD4PBM+f+vWK/CTV24OCZ/212I4l8aXfu3HoSgKBjI98ClQj/+6fwe2jw30bn1I5YCUTaUGizDg889+YT/OFyu4aqvDew3hUL5u+yj+9m0/ht2TNiWznUKy3JmCVgnUSzwENb95y+V4xeVTzk5jCAHeUDaFL//ajwPQhjHaSgj4/Nl927FlJGe/ionWQWCpKAD86Zv34exyxRj656iHQHxes20Ef/f2H+vecWsnBGepASDD8HgP+HzvT16Gl126qTc+BV6LfCaFf37nj0NVVfuJ9rQeAvH5Mzduw+bhnP2qRUD4fBAi97zpRpxeqjgTZCHcq1duGcbfv/3HsJ0FnxXdfibSYFph5mEY5V0/eRl+/JIJ5wRDCARELp3EP7/zx9FqqxjJ98AnFz3s/eDXX78Vkzqp7aoDIGxLCgB86k17cXpxzcWO80z62F+LK7cU8Bs/eRn27R5D/4fcPoLubDaLl7zkJVyVuPPOO3HffffhoYcewvbt242fT09Po16vY3l52ZLtnp2dxfT0tPGYH/7wh5bnI9PN6cd0TjyfnZ3F8PAwBga6Szey2SyyWQaHrB/Ew6E8MpDGK66Ycn4Al1JRd6MHmBmjnnoI6sMDtBJzx+AO4HQY9jZ6W0YG3IebhECEAMCPO2XvOoW1NJIIV3yKdxoB4NKe+BSvRyKhODsntA4CnTVA61F17VMNwWkEgJsuZsQba2kkEQ/4HM71wGcIAR4AYy+1o4SAT0VhxKfAUlFAK1l1ncgc0n3yYxd5xSer/SSZxN5BTYEVn4KvRc+Mfwj3iaIozhl/gPN8EPvVUAAwNZyz30fdqYdgm/FiP/hkuS4e7OdQNoVXXuGyizkkfF7cK7kQgh6KohgVCK468Ej6kC0pNs8zVchhqsCCT3ExQSqZwLtedan/55dMPJeX//qv/zo+9alPcXlxVVVx55134stf/jIeeOAB7Nmzx/L7ffv2IZ1O45vf/Kbxs6effhqnTp3CTTfdBAC46aab8MQTT2Bubs54zP3334/h4WFcddVVxmPo5yCPIc+xrsWD0espIRk9Zj0EH0SuwvMwdFgNFZ4evYkQZhEYdPcU2fApmAhh0oEHPh1WQzFJSE4jswgManpKSAFeT5HhPuGpQ6sONLpXQ3nSQxp86jgTQAr1FFnuVRnuE57zQRxWQ7HpIb59zJNEeb6HMB+kb/TgOR8EgN2WFCaR4SzpM/Gc6f7hD3+IBx54APfddx+uvvpqpNPWEowvfelLzM91xx134Itf/CL+5V/+BYVCwejBHhkZwcDAAEZGRvDWt74V733vezE+Po7h4WG8613vwk033YQf+7EfAwC85jWvwVVXXYVf+IVfwEc/+lHMzMzgAx/4AO644w4jW/2rv/qr+PSnP433v//9+OVf/mU88MAD+Id/+Ad85Stf8fr2+0/iQ9leZHIaAc3oDYxGq0ckhzJ7z1dPCaHsK3w9ApJCQXDRuRpqkPEzpUUGAoIWGUghWexnv5OWmQLmO0HQAABZFUlEQVS01VD60Ku0jzJ1Gc4SWiLFpyQBXgjtYz2Fx3wQshpKbWl6ZH2UqYfQPuZJoiSFZPF1ZNCDx1lCtqS0atrz+fE/ZThL+kw8B92jo6OWPdlB5E/+5E8AADfffLPl55/73OeMnvFPfvKTSCQSeOMb34harYZbbrkFn/nMZ4zHJpNJ3HfffXjnO9+Jm266CYODg/ilX/ol/N7v/Z7xmD179uArX/kK3vOe9+CP/uiPsH37dnz2s5/FLbfcwuV9SC08gxoZjA09VbTfncb1aPR8O40cMoky4FMWPXjcI2Q1VGNVc8j9BN0yEBC0RJqpCaclpafIQITw0CGR0Mp/ayXtegy5lE730kOaoEYCfEZ9LWQgQnjgk6yGqixpegxvjUaP9UIKyeLryKAHj3sE0N7D6rwcyac4020vn/vc57i9uKr2bovP5XK45557cM899zg+ZteuXfjqV7/q+jw333wzHn30Uc869r3wDGpkMDb0VNF+P5SJHuvJ6Ansme0pXPHp3IfnKjxWyVn0kOBQbqyuQ3xGmEnk2ZLitZ+v3dInh0P4bA5X4VGiCWjXo1byX5kSwho3TyJDJQYPUqixprWkeN33Ta+Sk8F+BtGB6FFZkqONrd/bc0S0pHitjuGxSo7WI0pSHdDew+r8+sFnH0giagViESzSHcoB+/CMG1PxP1UUkOtQjloPIeVn/eo0BuzD47Gqi9bD96HMIcADOOJTtkxihKQQjz5RwF8fnjT45EgK8dAj6pYUIjLMHAh0Laghfn7wSa+S6/dKDIseMWkZWLi2pMDfecJjlRwgF6lOP59XkQ2ffSBMQfett96Khx9+uOfjyuUyfv/3f981Kx1LyLLejB5tbBIBOCMZjI0seqybQ5lD9oz04QE+8clhlRzA8VAOmEnkFfxLg0+/pBDHTA2PlhT6+bwIuYZBVskBcpCFPPWQBp8RkkI8zpJkWrOhgL+A11gllwLSLls7egmvmRiB8RmQkInbc0zh2ZIC+LtfeaySA+QgCwE57PgGy3QzlZf/7M/+LN74xjdiZGQEP/VTP4X9+/dj69atyOVyWFpawpNPPonvfve7+OpXv4rbbrsNH/vYx0TrHQuryGr0/PbhSWNsJMgkcisVlaEnUZLys6B9eLKRMVHiU1XNbJcsh7IMg/6ibEmRDZ9R6sF9PojPlhRaglQKBX1tnkRIYy04qR7kvawHfPLSI0fhs90OlqwIEnTLhE+/LSk8VskB/MgYbviMsCIkaEtKnwlT0P3Wt74Vb37zm/GP//iP+Pu//3v82Z/9GYpF7UNSFAVXXXUVbrnlFhw8eBBXXnmlUIVj8SjE6FWWgVZTG47kV3iUigIBjR6HzBkgx0oRix4BsgKAPEbPb1BTKwZ/bRn68NZTBg8Idp/UVwC1HVyPoH14tPh1GhurWmlhkOybDH14suEzSj14zwchLSl+plQT8YvPVi34a/MMNFdmgpFCMT75zweBqs2CCOK/eZ1ePqA/rt3UrkGQ1+aJzxICkpaSVJBxq8SIMunT0ZLCiq0+FeYILJvN4s1vfjPe/OY3AwCKxSIqlQomJia61obFIpEMjOnfqEB1GRic9P9cPEpFAT5Gbz2UfVn0iLJUlKPR85qpyY1qpVpqW/vbwmb/ry1DdkIGHWg9onQaie5BS0V5rIYi4jWoyQ5r+rebGj5Htvl/bRmIENnwKcO1CDofhMdqKCJe8ZnOa/a/WdX+NshryxBoynCPAJLhM6Ae6RyQzGikZTVg4OsZnznt3qqvaH8b5LV5Jn2AYO1jspBCUQb/vPBJWlIaa9r1XedBt+86k5GREUxPT8cBt+ySTGmBDRCsRJJXqSgQH8q89OClQ9A+PCKthklisB7KiYTJhgfFpwx9eDKQMbQeUZaf0fgMUooXtA+PSKupVfwA7PhUFH4tOjIRIbI4jTJci6DzQUhLCv2cfqTd9k5aisCnDGdalIEVwHe6vl89eM0HCaoHEVX1HnQD/Ib98Uz6APKQlgxbnBz1kMF+Bk36BNWjzyTASRNL3wiPQ5lXqSjA6VDmZWzK/oyeTE5jUB2C6kGEHKpKwpuzwgOfzSrQbmjfy4BPXjqQPjy/eshQicEVnwFIoeoyjMnIRgUQg3DBJ1UqKgsREkiHjpaUyPSQ4CwB+NjPWlHLlgPesj08ghpepaIAn0CTFy6CbkmRAZ9BdQiqB5H6inY9AY9BNwf7KVvSh5cOakuzoX71iPHZdxIH3RtBeBg9XqWigFyZ7qCroWKjZwrB18CYN2aeJz6DlooCch3KpA/Prx4xPk0h+MqNepttwQOfvErxgIBECK/yyICrobiXikY4HwTghE89aM4UtCn1rCIbPmUgQnhtSVkPAV5QPYgQfKUGgEye/e/WY9InqA6ZQXNLihTJp3WAzz6ROOjeCMLzUA5aKgrIcSgHXg0VG70u8VN6BvCZEE3jM0ipKCDHoUz68ILqIUPWKqgOQfUgEhifATKJ5FqkB4MNswQ44TPgZxJ4NRSvjKb+PiLPdHPY1e11XRgRnqQl11LRINOhA34mvFZDrYcAL6geRHzbz3WY9AlqMxTFxKcMyaf1gM8+kTjo3gjC0+hFHeDxMjZB+vBaDaBZ4aPHejJ6gQ/lIEGNLPjklEkMogddKhrj05QonUZZSplluE9kKxWN8cn5XpWFCPEZ/K+3+SAAn/Ycr5PLiazHpE/UNiPOdPetMFPupZL9xRgcHEQyGXDIQyxihUemZr0ZGwC+V0PRegcuFe3zAI+WSJ1GSUpFeWUSiR5rC971oD/D+FA2RYZMjTT45KSHn9VQspWKxviU517lfZ+U4B0b620+CBCMCCESZSWbLAQEVz18EjJC5oNEjc84090lo6OjGBsb6/oaGBjA5Zdfjj//8z8XqWcsQYTLoSyiVDRIHx6noAbwEdSss1LRoHoQiZIJl81pjFIPokMy66031E7W06EsQyYxxqd8paIxPuW5V2W4T9bbfJCgehCJspJNFgJChvtkvc0HAfhUYvSJMEcM3/rWt2x/vry8jMOHD+N973sfUqkU/tt/+2/clIuFk0h3KMtSfuaTaRTCdspyKPPoSYydRikO5aidNemcRglIoRif8pWKSoPPKGcOSHItZLhPRM0HUVVveJfhXqUl0koMSeaDyKCHiPkgZEuKF7xzTfpwqMToE2H+xF7+8pc7/u4Nb3gDdu/ejU996lNx0C2jrMdMoiyHMi8dAhm9fi8/kw2ffd6Hx/Ue6VgNlUyz/+26cRo5tufIYj9lyCTy1KFVA5o1b5UdMpwltEQ5SE2We1WG+0QEPslqqMygBz3i9jFDZMOnDP4nT1yQLSleyAQZzpI+lIA0nikvf/nL8dxzz/F6ulh4yno0euvtUPazGko2o7duys9kOZR9EiFc75EAq6FkICBokYEUWlf4lIC0pPEpg/PKpRIjykyiJKSQDO1jPPAZZDWUdO1jEkzXlwWfMvifPPAZZEuKDGdJHwq3oLtYLGJkhINxiIW/rJfp0PRU0fXiNK4no7fuBq3Eh3Kg1VAyEBC08Ai6VdXfawtpiwmCzwhnc/As0Uwk9Z3M8F+mKV1QEyE+o74WNQmCf542PMhqKBnOElqCkkKVJW2zhh+RxdeRQQ+eZwkgx30SZ7q9SaPRwMc+9jG8+MUv5vF0sfAWEtTUStrkQz8ig7Ghp4qul0NZFj1kOJQbq0Cj4u+1ReHTixPLc5Vcpx5eJD6U7SVoUNOqAfVVf68tIsAjLSms0m6Z1TQyVGLw0AGg7hOfpFDULSlE/OJzQD/f1Zb3a0BERHtOYxVoNdn/jl4lJ4P95I7PDUqqD4xp/6ptSfDZ0ZLCKjxXydF6REmqA+sHn30izD3dP/MzP2P782KxiGPHjkFRFHznO9/hplgsHCU3CigJzehVFoHCtPfnkKEPzzJVtOD6UCaRwdgQPYKshpLF6K0taP96LT/LFoBEWiNU1i4AI9u9v7aI8kivfXg8V8nRzxFlBg+A79VQNdkyiT5JoXQeSOU00m/tApD1MdFYhj48uj1ABqeRKyl0NlrnNcqgJp3TpmzXV7TnGBj1/toizhLyvKznAb1KToaZGNzw2ecDW4mskvPdIz6Tac1GVYvac3j1DwCxLSlDm9j+jucqOSAm1Xno0IfCnOkeGRmx/brmmmvwwQ9+EE899RQuueQSkbrG4lcSCZMN91vCK0MfnqFDIfhUUSB4UCON0Yt4oicA1Ne0ABXwfigrSvC+L57lkX778HiukgPiQ5mHDkSadfNvvTp9PPApQx8eef88VskBcpGWQfSQAZ+tJlBZ1r73aj+B4MP+eN6ryTSQ0lfBebkeRAclaba0BBHpKjH6mFRv6wkbwCc+OdlPHvj025LCc5UcEGe6eejQh8LsGX7uc58TqUcsoiU/oWUiZTJ69bJ247IyjdIZG46ZRK96cC8VDWj0yIGcSPnTJz+hZVNlwCfpw6su65/1lvB1APr7UJalVJQIwaeS0Cp/vEp+HCid9R/UiCBC1hb8OY2y4DNKPUTOB/G6GgrQbA30VhZSjutF8hPA8ik5SHVAr46p+COFcsPBV8kB/Y1P3nrQOnjdkgJo+CRVCH4y1fkJYPEFufBZL3srd+e5Sg6gSKEI22IADhUhPJI+HS0pPJIWkoqnd/bwww/jX//1X1Gv1/GqV70Kt956qyi9YuEtgTOJAkpWPRs93hlmCcq+AH9Gj3upaECjR5dG+nGYgmZqRBzK1WWflRiSkEJROo31Va08n5ceQVZDASY+B8b9OUwyZboBfy0psuEzSj1EzQfxsxoKMHGVG/XncMqUSQS067Ey648UivEpbj4IVK2M3+vnTM7lTMFflYyM+PTakiINGcPbF/dRESIq6QN4a0npQ2H2Pv7pn/4JL3nJS/BHf/RH+OxnP4vbbrsNH//4x0XqFgtPCTohWgaDs24PZR9GT1SpKP3cXsRvPyIR6Q5lH4SMMB36MNNNdOZVKhpkNRQQPT5lIEJksOGy6MF7PkiQ1VCAPPiUwWZEjk8J2sd4zwdJ5bS5KV71IOJ3XRgRGZM+gL/2MVn8zyjxyTvp47clpQ+FOej+yEc+gre97W0oFotYWlrC//yf/xP/+3//b5G6xcJTgqwN410qCvT5oSyBHrx1CGr0/A6pIrKenMZ1eyj7JCB4lIoGWQ0FRB/UyESEyIJPKa4Fp/kgQVZDAfLgk0epKODzTJMgsALkaB/jPR9EUYK16ATG5zpK+ojQwcuWFJnOEl5JH7969KEwnzZPP/00fvM3fxPJpMbm/sZv/AbK5TLm5uaEKRcLRwlyKPMuFQXky3R7MXpSOY2cdPCrB5EomfBGFWjpq/BkwKcIHbyshuJ+nwSoxBCCTx9rZ6LEJ10qyj2o8UKECGrP8boaSob2HN73CNC/QQ3vUlFALlLd62qo9Rjg+dWDCDdSaB0kfXjr0G56W5UqQ/JJNnz2kTAH3WtraxgeNi9wJpNBLpfDysqKEMVi4SxBnEbepaKAXIcy6cNjlfhQ7pYoMzWGvpxKRQG5DmXSh+dVjxifpkRZiWEpFeWFzyBECOcMHv3cTHpI0JPIez4I4H9GCBBtUMO7VBSQgwgJvCVlHQV4fvUgEuX5LlvSh5cOmSFtsKdfPWJ89qV4qlv57Gc/i6Ehc1R+s9nEvffei8nJSeNn7373u/lpFws/4eE08ioVBeTIdJM+PLWlPTfr8Jv4UO6WKA9lAxecSkWBYOWRvA5l0ofXbmh6sD5vVVBw5av/jZMOfvUgwi2T6CeoIaWiea2Ng4fI4DSSlpRmxdvwG5lIS2nsJyGFIqjEEFIqGoAU4oWLoFtSZMCnNKSlBKS6LEkfXjbD2JJS1PQoTHvTI8ZnXwpz0L1z5078+Z//ueVn09PT+PznP2/8X1GUOOiWVXgYvagdFN7Gxs9qqFbDzIrL0P8mi9GTIaiRBZ+8Ak3Sh7d2QdOD5WnpUtH4UDZFClJIFnxy1sPLaijZSkVjfMpzr4q6T4KshuKig4/VUELuVZ8rqoBoSSGhSZ8IB6UCmq9QLcaZbr969KEwB90nTpwQqEYswiVI+ZnQQ9lHTyLvG93Laii6FI9bqagEAZ5fPYjETqM4PdYusOthwWd8KBsiQ6ZmveLTy2oo2UpFY3zKc68Ku088rIZar/NB/OpBJNL2B5EEhARnWhHsRIiQ+SA+tqQITfr4IIX6SDjVYsYivQQZtCKkVDRI+RlHPbz24VVFlIr6MXqSECFEeDLhXobaAfI5jVHqYZSKZoB0jo8OsdMYDJ+yBHgy4VOWUtH1hs/Kklbt4kVkuVdluE/W63wQv3oQ4YXPWlELHL2INPiUoLpQyHwQWZI+PmKCPhTmoPuBBx7AVVddhVKp+4IUi0VcffXVeOihh7gqFwtHIUavsQbUPQwNAyQyehIcRLIchrKwv0R4HcqturehYYB8+JThUF6X+AziNBJSyCc+B3QySW15L8+UJcCTCZ/rbT4IEG1QMzCmf6MClWVvfyvLvSrDfSJ6PggrYSdDgEdLUHzmRsyhYV6z3bLMB5GhulD0fBDWLSkynCV9KsxW5Q//8A/xtre9zTLBnMjIyAje8Y534JOf/CRX5WLhKNmCNpQJACpejV58KBsi2tj0o9FT1eCHciZv7gn3Wo0hS/+bDHoIuUd8rIaSrhIj4MqwdE6bNks/F6vIEuDJYMdF6tCsAs26Nz1ksJ9AcFIomTZthWd8ShLg8R4ACfgPakTg08tqKBkCPFqCnu+JpEkM+bWfsuBTBv9TBD69bEmR4SzpU2EOuh977DHceuutjr9/zWteg8OHD3NRKhYBoij++75kMDa0HuvVaexXo1dfMfvg/B7K9N/2Oz7X7aHsQQ+ZKjHqa+bww0D41AN2z5kagUSINPhkbc8RqAPg4T6RZPgioBEFRG+/pBDg337KEuAJWeMmAanuZzWUDGcJkVZTm3sDRHO+y+LryKCHiLOEbEmhn7+XyITPPhPmoHt2dhbptHM5QyqVwvz8PBelYhEk68XorbdDud+NHsFTKhesTzNoUCMLPtfboUxWQ9HP30tkwiep7Emkg/XB+SaFJAnwZOjDE1EqmkiaVQieK0J4zgcJiE8lAeRG/b/+eiEtZbCfPHUgW1Ki1sMvKVRZMr832hh8yHrBpwz+J298ynCfxJluq2zbtg1Hjx51/P3jjz+OLVsYVi7FEp34DWpkMDb0VNH1eCjLoIdfo2eUnk0G69OU9VBm6cMTsUquUw8WERHgAQHKNCUoj6RLIwPhc9L6fKwiOsBjaUlpt83J9jI4jTx1CKJH1C0pgImngfFgfcRSker6taivsA12o1fJrbdKDMB7ZYoMPhcRA59jQJJ54VG3SIXPAC0pMvifsthPGfDZZ8Js4V/3utfhd37nd1CtVrt+V6lU8KEPfQj/6T/9J67KxcJZ+tno0Tcir6mNgBzGRhY9fB/KOokTpDQSCIBPCfrwRKySo/XwfChzDPCAPsdnwH5EIkFJoShbUupl7bGi9IiSLAyiR4xPOUr+6VVyUbakCMenx0oMGdpzuOFTwqQPwIZPEavkaD2iJAsBOez4Bsl0M9NWH/jAB/ClL30Jl112Ge68805cfvnlAICnnnoK99xzD1qtFn77t39bmKKxcBCZD+XUJJsOmYJWTshLZBi04ksPEaWiHDKJQSQwPjleC9KHp7a1a53pUTYvYpUcEB/KQXQgEjkpJLAlpd3Qnr/Xc5NrxnOVHCAHGRNEDynwyTuokYBUT2U0jDar2vXoVZZMr5LLDPLTo9/xKcMgyqjPdxH4JC0p9RXt7B7s4X+KWCUHyDEoFZAMn3HQDQDYvHkzvv/97+Od73wn7r77bqh6yaWiKLjllltwzz33YPPmzcIUjYWDBM4kCujDYzZ6AoasAAGMTYSZRFlKRYmsx0OZ9OFVi9pnXpgOXwdAjgwe4A0bqirXoRx1UCOyD2/tgvb8vcyRbPiURQ+RLSmsrQxBJ+sTMeynBJlEQLsezSrb/Uqv6uK1Sg7of3yKIIVqZZ/4jJpUF4DP+op3fPJaJUd0ACRoH/MZ/IuYD0JaUngm1yQSTw0au3btwle/+lUsLS3hueeeg6qquPTSSzE2FmC4QizhybowerIYmwj1EFYq6tPoyRLUiOjDqxa94VMWUihKp7GxJqhUtKMlJZVh+zvuTqPHoEYkEbJ2oT/xGaUeoueDkJaUXtUxRIKuCyMiE2kJaNdjdY7NZshAFgJy4FP0fBC1rZ3xrG1Q3EkhCZI+gPYZl88x4lOyCsf1nPQhegQZ2iex+JqKMDY2hgMHDvDWJRbRIuOhzGz0JDgMATkOZdGlokQPVqMnS1AjAp9FsBEhwskYWTLdDNeC6CqqVBRga0khIkumJkqHbT1n8LzqIWo+iNeWFCKy4FOGM01EYEU/fy+RIbgSNR8kPQAkUhopVC15CLojJoVkwqcs/meU+BSV9PHaktKnwrFOIhbpxc8gC1GlooDPQzl2GoXpQIweqx5EombCZcJnlMEurUeUwb+BT86lon5WQwHRBzUyEIYy3COy6CFqPoif1VCAPPiMMuCN28coHQTNB1EUfy0665lUB+QhLVm2pMh0lvBO+njVo08lDro3kvg5lEWVigL+jJ5IY8Ni9GRyGnnr4FUPIlEy4c0a0Kpp38uAT1E6kD48Vj1ifJoSZVBDl4pyD2o8tKQIy+B5XA0lslQU8HYthODT42ooINqgRlSpKCAXqe51S8p6PEu86kEkyvYx2ZI+onRoNzSMsuoR47NvJQ66N5LQTiOLAw+IKxUF5DqUmVdDxUavS0Q4jSy7hwGrnjxL8QC5DmXSh8eqhwxZK946eNWDCO/p5ZUltgATsJaKSuE0CsrgedaD97XwEOyKOksA76uhAP72s1bUyB4WEVUqCngkQgTbT/o13GQ9B3he9SDCG5+NVTZfC5Av6cNbh8wQAMW7HjE++1bioHsjCTF6rTqbAw+IKxUF5Mh0kz48+jXcJD6Uu4U3E6622MupiZ68S0UBn4Em58+E9OEx6xHjs0t44dPoMVOByjLb35CAIzXAt1QUkMNp9NqSIhNpKQ0+OVUK5UbMs4w12y20VFQCIsRrS4oMg1KFkuoeB8cC/Oxndtg8y7ziU5akD2+bkUjIlXzqx6RPn0kcdG8kyeQ15w9gL/GRxYEWZWy89OG1mhpLC0iSSZTA6LXb/JzGVNbcgcl8KIssFZUgk+ilD48uFY0PZU1UlZ/TmEwBuVHte1b7KUuAJ4Mdl61UVAZ8AvxmYiSSJjHkFZ9RX4v1fp/IoINXPYjwOt8VxXuLTihJn6iJEAnuk37GZ59JHHRvNPFs9MIoFfXShydAD1ZGnv69FEZPxLXwaPRqRbP8K6jTSD9HvzqNUepBl4pKgU8JDuX6irkeKqjTSD+HV9Iyxqd8paJS4HPN7PmPEp9RXwsZ7pP1Ph/Eqx6Adk3qOpHL5XyXCZ8+KjGE3ic9/OBQ5oPIkvTxUInRZxIH3RtNvE4wl83oRXmjEz2FlIr6mQ4tgdEjOMoUtEx1UJHqUO6zQJPokEibJb+8pF+dRoKj1AD7Cic38ZupifEpX6moDPis6PYzkeYzk8J3JlESUkgGfALrcz6IVz0A83xXknwCPSmTPrIEmr2SPmHMB/GwEjTKBFgfSxx0bzSJD+Vu8XooR8l2CtfDo9HjVRpJRCp89lkfHn2P8C7F61unkVNpOZE40+1fj/U+HwQIhk8e16TfSUsZ8Cl6PkivIbYyBHhE6PM9wSFckCrp02fVhWHMB2HZkiLDWdLHEgfdG03iQ7lbPDuNAnXoN6MnS1AjCz5lIIVEBv4sq6FkrMSImhSK8RmODs1K78ndMpwlRLjbT49BjSwBntD2MY9BjUh8sqyGkiHAIxL1+S6LryODHmGcJSxbUmQ4S/pY4qB7o0m/G7317jT2m9GLD2V59AjjHqFfx0mkrMTgHdTIkOn205IS4WwOkaWi9PXteZ9IEOARiZoUkiXAk4EIEWnDvayGkuEsIRL1+S6LryODHiLvES9bUmTCZx9KHHRvNOl3o7deD+V+NXqyBDWy4HO9HspeVkOta3xSu+RZJJQAr09aUkTqkEwBab1PvNf1CIUIYa3EWM+kpQ9SSAb7KUIHL6uhZDhLiKzr9rGYVDfEy5YUmfDZhxIH3RtN+nE6ND1VdL0eyv1q9GQJakTj063kX+QquU493ERkgAf4KNOUIZMoSaYmypaUdlsOOy5SBz96rGv7KRFpWS+7t6TQq+RkGJQqCz6jDjQBfuvCiMiITy8tKTL4nzE++1rioHujidegRgajZ5kqGqXTKDDA86RHGKWifcKEh1Ee2asPT+QqOVqP+FCWKNMtUU93r5aU+gqErZKj9YiSLPSjR4zPcO5VwDp5uVPoVXLrtRIDYK9MCaUqJapKDJL0YSXVBeKTtSVF5Co5wDspJIv9lIG07EOJg+6NJjIdyqxGz5gqOsR/qiitB7OxiTqTKJHRi5oJl6EPT+QqOUCODB7Qp/iUhBSKsiWFXCsRq+QAOcgYP3pIhc+IKoVE3qupLJDU10i6XQ9jlVxCt7mcpV/xGZNCcrSkiFwlB3gnhYTh0+OWFCFJHw8tKX0qcdC90cSz0RNYKsps9ERnmL0amwj1EF4q6tHoredDmbUPbyNk8AA2h01VJXMaRZFCHjM1Ubak0PjkvaoLkIOM8aNHlC0pRKKeiSFDoClylRzQv/gUSgoxbEkBxJ7vLK8vEz5FrJJj1QGQqH1MgpaUPpY46N5oQjuN7Xbvx8tk9NbzYciqR1iloqxGT9ShXFnWeqV7iUz4lCVDEiU+GxWg3RSnh5c+PEBcUFMrsr2+DESIbPiMUo+w5oOwrIYCxE0vb6xq92IvkeFMM+4RQcFEP7WPhTUfRG0B9dXejxd1vrdqbK8vMukDMOJT4Co5Vh0AOc6SsOaDAO4tKX0scdC90YQc7mor+qm3gMdDOXYaQysVBdiMHu9DeWBM/0YFqsu9Hy9DH55wHRj78EK7T1z0IPgUVSrqZTUUwB+fuVHtvQFs2W4ZiBAZbLgseoieD+JlNRTAH5/ZYbPlwAs+owx4a5IFNVEGeKLng6TzgJLsrQcR3qRQOm/6LSzVGDL5XLL4n+s56cPaktLHEgfdG01SWa1MBuh9KIsuFQXiTLdXPUSXinoxeq2mlpEG+DmNyZQW2ADxoexFB1oP4cE/C0EmqFTUy2qodpt/eXkiAQx4KOGVoQ8vtLYYWUhLhmshaj6Il9VQqso/6FYUby06Mp1psthPGc4SUfNBFMVbi06MTzl0oPWQAZ+ikj6sevSxxEH3RhTWvi/RpaKAfIeyW5+RTIeyKB1Y9QD0TLR+vYwMNQdhPZSbdbOEUwZ8CtehRx+eTIeyqMwZqx6AFpSTqci8MjUAOz7pUlEpyiMF69CrJUW4HiykkOASYoAdn/UVoFXXvucV1NDP1QufoktFAW9EiGj7ybolZT2fJax6AEB9TbtmAGd8Ev+zz5I+onVo1YEGw5YUWfApglRn1aOPJQ66N6KwHsqiS0UBuTLdvfrw4kPZKgQ/uVEtA8lLvOITiPhQDqkXsFcfnnGfyBDgyYBP3anLFLQKDl7Sd/gMyWkE3FtSZHKgQ8Fnj0oMgp/UAJDJ83t9VnyKLhUFPFbHCD5X6deyE5kICBlIIYKfZIav/8eKT9mSPqJ0yBRgtKTIknxyEpnw2acSB90bUViNnuhSUUCOTLfX1VCx0dOEd+kZEWZ86s6LqFJRwOOhLCjYZe3Diw9lq/BeF0aEtVLIKBXNAakMXx2IyOA0el0NJYMDLRU+edtPxkyiLKWiookQr6uhZCAghJJCjDNCaHzy9P+kTPpESIQkEjBWkcmQfIocn3GmO5b1Jl6NXiilom5GT3D2jKUPr93SMwOQJJMo8DPxmumOKuiWJcATrQdLHx5dKhofypoIx2ePoEaWAE+G+0S2UlEp8Knjhzsp5JFUj7pUdKPcJzLowKoHEP35HkrSRxYihKE6ZsOR6gyDnvtQIg26H3roIfzUT/0Utm7dCkVR8H//7/+1/P4tb3kLFEWxfN16662WxywuLuLnf/7nMTw8jNHRUbz1rW/FysqK5TGPP/44XvrSlyKXy2HHjh346Ec/KvqtyS1eM4mhsK4sh3KEfaIbpVTUoocHJpynsGZqZAnwZNCDLhXdMPiU3GmUJcCTAZ+ylYrG+JTnXpXhPtko80FY9QCiJ4VkmQ8iun2MRY9Q5oMwVECEkvRhiAn6WCINuldXV3H99dfjnnvucXzMrbfeivPnzxtff/u3f2v5/c///M/j2LFjuP/++3HffffhoYcewtvf/nbj96VSCa95zWuwa9cuHD58GB/72Mfwu7/7u/izP/szYe9LevFaHrmhDmUHg0P0E1oqymL0wiw/i51GKcrPLHr0IIUSKSA9IEaHvnMaZcnUSGI/ZcDnep8PAvQfPqO+FjLcJ9KQ6hIEeEQix6ck80FEt4+x6CENPiW4V/tcOE4/8i6vfe1r8drXvtb1MdlsFtPT07a/+9GPfoSvfe1rOHjwIPbv3w8A+NSnPoXXve51+PjHP46tW7fib/7mb1Cv1/GXf/mXyGQyuPrqq3HkyBH8wR/8gSU431DitTxSFqMnw6EctbGRRQ8geiZcFgJChj48+h4RVYrHshpKFiIEiN5plCXAk8GOb5T5IED/BDWynCWiB0ACDPjcIPNBWPUAoq9kkw2fMvifocwH0bek2NlpGc6SPpdIM90s8u1vfxtTU1O4/PLL8c53vhMXLpgHyQ9+8AOMjo4aATcAvPrVr0YikcB//Md/GI952ctehkzGBOott9yCp59+GktLS7avWavVUCqVLF/rSvr2UJbAaQxFB5fVUDIZvdhplEePMO8Rt9VQshAhgMBBanGm21kPByIklFJR/bkba86roUTPBwEksJ+s7TmSzAeRYY1bmPeI22ooGc4SIlGf77L4OjLoEeZZ4rYlRSZ89qlIHXTfeuut+Ou//mt885vfxO///u/jwQcfxGtf+1q0WprDNzMzg6mpKcvfpFIpjI+PY2ZmxnjM5s2bLY8h/yeP6ZSPfOQjGBkZMb527NjB+61FK/1q9DbKodwvRi8+lOXRI8x7BIDjaiip8EkqMSIapBZKgOelJSXCPrxQSkUL5vdO+Ax1PghrJUZEpJAs9+pGIdVZVkPJcJYQifp8lw2fMvifInHBsiVFJnz2qUgddP/cz/0cXv/61+Paa6/F7bffjvvuuw8HDx7Et7/9baGve/fdd6NYLBpfp0+fFvp6oUu/Gr31fij3m9GLejq0bPiU4lAWGEywrIaSJXsGhJBJZM10x4OAQrlHkmnNhgK9M+5SVGKIJoUuOFdMAfJUpYRKqveqxBCoA8tqKBnOEiJhBN2R4zMm1Q1h2ZIiEz77VKQOujvloosuwuTkJJ577jkAwPT0NObm5iyPaTabWFxcNPrAp6enMTs7a3kM+b9Tr3g2m8Xw8LDla10JMXqVZW0qopPIYGzoqaLr3WnsN6MnOqiplbTP30lkGLQSxio5Fj3CKNEEYnzSz9dY1aZyO0moZKFDS4qqmllfGZxGkTp40WMj4LNVc66YAsK9V2tlba1hp9Cr5KIM/kPHZ4/ZHFFXxwDiZrYM6M+ntiQYUMrSkiKBzQjjHgHksONxplseOXPmDC5cuIAtW7YAAG666SYsLy/j8OHDxmMeeOABtNttvPjFLzYe89BDD6HRMG+o+++/H5dffjnGxsbCfQOyyAB53ypQXXZ+nAxGL4ypjfRzR1keyaRHGKWirJlEQZma3Kg25RgAKi7Z7jBXijj14YWFz/hQZteBiKigJlsAEmn9NVzwKUMfXn0FUNvh6RElGeNFj/WMz3ReG7hEv4adhHmvQtVmQXQKvUouxqccAR4RYfjMmRsMIsdnj5aUMFbJAexkTIzPvpdIg+6VlRUcOXIER44cAQAcP34cR44cwalTp7CysoL3ve99ePjhh3HixAl885vfxBve8AZccskluOWWWwAAV155JW699Va87W1vww9/+EN873vfw5133omf+7mfw9atWwEAb3rTm5DJZPDWt74Vx44dw9///d/jj/7oj/De9743qrcdvSRTWmAD9DB6YZSK9jB6RIf0oKa3KJFhEJBFDyejJ0GpKKAdRuSa8GbCEwmTDY/6UO7VhxfGKjlAjgwe0D+HcqupVfIA/J1GRWFr0ZGhD49cI5Gr5AA5yBgvekSNz3ZbHGnpFZ8ir0U6ByR1u2h3PYzPSRG3Sg7oP3xGTQqpqrigG2Ab9idDS0popHqPzSBhzAcBeldBhJH0IbFJnOnmL4cOHcLevXuxd+9eAMB73/te7N27Fx/84AeRTCbx+OOP4/Wvfz0uu+wyvPWtb8W+ffvwne98B9ls1niOv/mbv8EVV1yBV73qVXjd616Hn/iJn7Ds4B4ZGcE3vvENHD9+HPv27cNv/MZv4IMf/ODGXRdGRJZDmdXohWZsoj6UXYxeaKWiDH14JAOtJEwjyVNkwWevPjzZMiRROo2qKo/TWF0GoJdbDwioaGLBpwx9eDQ+Ra3qAuQgY7zoETU+a0WtOgHgT1rSz8lSiRGlzaDvkYRAd7Tf8BkWKeTUU10rA2298nBABD5Z7GcISR+gBz5DWCXXSwcgnPkggBxJH7plyq4lpc8l0j3dN998M1SXQQpf//rXez7H+Pg4vvjFL7o+5rrrrsN3vvMdz/qta8lPAIvPR59JBLSbrLHW+1AWKTIchr30CLtUlBg9O2eI4GZgXIyz5CWoCQOftZI9ESIDGUPrERo+bfRoVk1HLcyWlGS6+zEEN7lRMRUyLMPUwiRCKkvu9nMjZPB66RH2fBDSkpLOdT+GBMOZgjagkLfIQloC2vVYW3AnhSLHpwTtY2HPB1Fbmg3NDHY/huAmnQcyef46yIbPlZmYVAd6k+phJH2M59ZbUkSTLiFLpJnuWCIU2YweIPmhLIEeYZeKOvXhAWJLzwBvQY0M+Nwwh7JLFYShm+hSUYbVUMLxyTBhXwbCUDZ8ynAtROvBshpK1LowIp5ISwkyidLgM8JMYmj4HDRbUpyuh6jWByKykepAf5CWGyHpQ29JWYd93XHQvVGll9ELq1QUYC8/Eyn95DSKLhXt1YcHyBXUyIDP+FC24lNkqSjLaqjQ8MmS6RYd1LhUQYRWosm6pzusAM/lWoieD8KyGkoKfEoQ8MakercOoueDKIqJT5lJIdl8rqh0oPWQAZ+ikz4AVW0ZB92xrBfp1fMVVqkoEB/KrHqEpUMvPYDoD+VWA2jq65pkwGeYOti15Mhwn0iJz4iCGrpUdCPh06kPLzQ9XAYShXWPAL2nEUeNz7BKRYEeREjIuOi1JWUj3Ku99ACir2STLekTlg6tGtCsOeshCz5FJn3Iazjp0ecSB90bVXodymGVigJyZbp7rYaSxeiJlp6HcsTlZ7Reoq8HS3lkWIcy6cPr0kOG8siQMme99ACiD2porGwkp9GpJUUmBzrGZ3ilooAcREjPLSlh4zPC+SBA7xkhUVeyyZb0Ee5jUPiUNfkUJj7jTHcs605YnUbRpaKAHJlu1tVQMvS/hTFYQvZMYi2kUlGA8VAW/Jn06sMLbaWIJIdyT3wSUiiiSgxyLZJZMYOyaJHBaWRdDSWDAy0FPsPKJDoENWGWispAhLBuSZGBgIhJoYiSPhESIYmk7oNCjuRT1PiMM92xrDthNXpRl+IZg1YEBzVufXjtlpm92ShGr18O5agd6LD0cOvDo0tFY3xqEnVQI0uAJ8N9IlupqFT4jIgUCrNUtB+IEJnwGfW1AKI/30NN+shGhLitzt0A80EAKtPtUInRxxIH3RtVWDOJoRgbCcrPAOfgny5Hi3I1lCxECBB9+ZksAZ4MetClorHTqEnUTqMsAZ4M+JStVFQKfErSnhP1tZDhPtlo80F66QFETwpJg8+QKsjc9Nho80EA0w+OM92xrBvpFdRIY/QkOIiIXhulVBRwJ0KA6AetyEJAyNCHR3RQkmYJpSiRBp9RZ7oppzHKwXaA/ETIRpsPAvQPPqO+FjLcJxttPkgvPYDwSKHKkhZUdoos80HCah9z02OjzQehXyPu6Y5l3QgJamoloFnv/n18KJsig+Mqkx5AeIdyYw2o2wwOk4WAkOE+oe8R4VNFGfZ0R02EAOEFNa0aUF/t/r0sAZ5M+Nwo80GA6CsxBvTzXW3Zl6vKMh8krPYxwAWfG2w+SC89gBDwOaZ/owKV5e7fy+LryKBHVPNBOsm6uKebi8RB90aV3Cig6B9/xSbbLYOxofWQxWkMU4cojV7U5WfZApBIa9/3Az5lOJTDxIXdaihZiBBAPCmUyQMpfQCVXTVGqAGe5C0pUVSDNFaBVrNDDwkCPCKig5p0zqwqcMNn1GeJDERIFPeI3WooGc4SIqLxmUybNrwf8CmD/xkmLuy2pMSZbi4SB90bVRIJkw3vB6O30Q7lqI2e26FcXzN1E3UoK4p735ds+Nxoh7LdaihZyiObdfPnokghwB2fsgR4tTD1cCBCoigVBbqxIcN8EEAjA0h2T5T9BNyH/UXSFhOT6q6roWQ4SwCNTCVEt1B8utlPSXwdGfQI8x5x25ISZ7q5SBx0b2TpJ6O3UQ5lWYye26FMDuRE2upE8BaWoEYWfEZZphlmgOe2GkqW8kiCTyWhVfSIEregRgayEJDDjoepQzJtViBEWhHiUolRXQagVzEZZbYCpJ9Iy41SieG2GkqGexXQ8EkGc5LEjAjpJ3zK4H+GgQu3LSlxppuLxEH3RhbZjR49VVSGoGYjGT23Q5kuPRPZQ8wS1EQZ4IW5Ss5NjzAPZUCO4IoFnwPjYnuIWUjLKFtSwlwl16kHLWGeJSx6yILP3KjYHmIZSXW6JYVeJRclERIZPju3pERxLWwqMch5mx0GUhlxOkiDT7eWFIlIIVnsZ5zpDiRx0L2RxW1CdKiZRAejZ5kqKjCjSqSnsQkhwHPVQ5KSVdH9XkSkOZQd+vDCXCVH6xFlBg+Q41CWHZ8y9OHVV7Wfha1HlGQMix4xPqO5V6Gaq48A6yq5GJ/ykZYiW3MACfEJ6/UIc5Uc0JsUCg2fPbakxJnuQBIH3RtZ3NaGRZFJpF8XoKaK5rWyQdEiQ/kZIIfRc+vDM4ZUbZBD2akPL8xVcoAcGTygj5xGCUihKFtSyLUJY5UcIAcZw6JHjM9w79VUzhyKSV8Pyyo5GUh1SfC5YUghSZI+Ti0pYa6So18jyvYxQI6kT7ynO5Z1KbIcyr2MXmiHoWzlZ5QespSKAhvPaXTqw5MtQxI7jZrIlKmJsiWFxqfoVXKAHGQMix7S4DPCoCbMe1VR7K+HoUNB/Co5QI72MVc9yH0Scitd55aU0M/3iJM+gAM+Q1wl56QDsDFJdTrT3bklpc8lDro3ssiSSQTcD+WNZGyc9IiyVLTT6MkQdMvQhxe6Dg59eJHdJ5QejSrQqoenh1sfnuh1YURcMzUS2c+NRMY46RHVfBC71VAyBDUynGky3CO0TlEGeFHNB2k3gUbF+jsZzneZ8CmL/7mRkj6WLSkrrg/tN4mD7o0s/WL0pDmUJXCgwy4VtTN68aEsjw60HlFWhBg6hVwqanltXWQIamTow4usLUaWTKLNtQDCmQ/ithpKivYcCUpWa7JlmCPUI+z5IJkhbbtDpx6AHOe7TD6XLP7nRkr60FtS1llfdxx0b2TpF6MXH8rhl4o69eEBEZRHupWfSYDP+FCmAv+QSkXdVkPJ4DQa10OCoCbyXsCwr4UdKRTyfBC31VAy4VMKmyGJ/ZThLAlrPgjdkiIjKSQTPmXxP2XAZ1hJH2DdTjCPg+6NLE6ZmrBLRYH4UO6lR9g6OPXhAdE7ja2GOaU5jFJRwAGfEWZq6D48qQK8kK6Fkx5A9PikS0VlsJ9R6EC3pMjgvIZ9lgDOq6GixmfYpaKAfWtMVNUgTltSZKjECEsHwLkyRaZKoY3kcxEdmlWgWe/WQwb7GVbSh7xWpx7rQOKgeyOLU09i2KWigFyZ7s4+PJmcxlAPZQejFwUTTgeZdCleGKWiQI9DOeRgt7MPT4YyTanwGUFQ44jPDeg0drakyORAb0R8VpY0IohI2KWigBxEiOOWFInaczYiKVQrakQ6kUiTPlG25zjgU4bkUxT4jDPdsaw7IUavsQbUqf2uYZeKAg5GL+TsWa/VUFJkEkPSwUkPIPxDuVW3OvHVkEtFATkCTac+vI16KDvik5BCIbU/qC37DF4yo/WmhSEy4LPXaqiNFOAB0dvPgTH9GxWoLJs/j6JUVAYipNeWFBnwuZFIodyIeZ7R2e5Ikj4SECGJpHbGAxFXhEiCzzjTHcu6k2zBdJIqtNGLolTUxeiFVUJs14fXbpuZq41m9Oz0UNXwDuVM3nSS6GoMWQK8KEr+O/vw6FLRGJ+ahLUyLJU17QWNT1kCPFlaUuJMt/XnYZFCybR5dtrhM8xSUZmJEJnwGfW1AMI73xNJkxiytZ9RJH0ibB9z1CPspI9dK0gESR8j070c3muGIHHQvZFFUez7vmRxoGXow6uXAajh6uHW/xYJEULpUV8xS79EH8r0a0iDT8n68OhS0dhp1Cp2SL9/KPgkLTo2mRpZ7GeUemzU+SCAPT6bdVMv0aQQYG8/ZblXZbhPNup8ECc9Wk0zyInqfJdlPkjYFY52emzU+SCAfSJuHUgcdG90iQ9lq3QaHKLPRisVddKD4CQ1oGWiRYtbUCNLJUaUpBBdKpoZDEcHuwE8shAhpGInkQ6n39+NFJLFfkapx0adDwLY20+CTyUB5EbF6yAdaWkTaEaKzw06H8RJj8qS/o0S41MGPTbqfBD6teLy8ljWldgFNTIYG1oPGZzG2IHWJKzSMyLxoeyuB12KF/ZU0cjxaUOE0PgM43q4kZYxPuUrFZXFfg6Mh3M9XDOJEQd4YbePATb43KDzQZz0MPA5CiRT4nXoh6SPDP5nVEkfMiA0yp7uONMdy7qSfjB6MjiNUekQpdGzPZRJP2IIpZFAf+BThkM5KlyQ1VDS4FMGUijKmRgR9+F16hHlfJD6ijm1O9IAj/pMpMCnJPfqRifV6dVQMpwlQAT47IOkjwz+ZxS4oLekxJlubhIH3Rtd4kPZKjIdylEbPSkO5T7ApxSHcgRZK3o1lCx9eDKRQlFm8AC58BmFDnZ6yFSJEYbYrQWVpSolUsKwaNVHFnxGfabJcL7L4uvIoEcU94jdlpQ4081N4qB7o0s/GL2N5jTKYvSkPZQlCfBk6MMLe0c3YL8aysBnxIGmDEGNDGQhIIcdj0KHVEbDqJ0e0tjPsEkhWTKJNoMoowz+o8Cn3WooWQalynC+y+LryKBHFPeI3ZaUONPNTeKge6OLrEaPnioqQ1ATudGTpA9PpqAmygAvilVydnpEdSjLEFxJgU+boCbqAE9VtS8Z7HgUOrjpETk+SSXGBs0k1spmy1TU9wkgHz6jDjQjI4WixqdLS4oMg1JDx2fHsNQ4081N4qB7o4s0mcQOo0dPbZSi/CzEAA+Qw+hJkUl0CWqi7MOLYpUcrUeUGTygD5xGCTI1UbakNNbCXyVH6xElGeOmR4zPaO9Vta2d8fQquRifEpGWEpBCMpT8R7FKDrDx+yLwxQGb4D+KPd02W1LWgYQwnjAWqcV1kEUEmURAu8nIzZ4aCG+qKCBH+RmgGb0iJCk/k4wJl+FQJr32YU4VpfWIMoMHSOw0ShDURNmHp7atAxjDXCUHyEHGuOkR4zOaezU9ACRSGilULVnP9LBWdQHy43PDkkI0qR5BoElaUppV7bMg9hMIF5+OZGHYSR8J8BlnumNZlyLLodzZh7eRM3idekReKkr3fEnAhMvQhxcZGdM5HVoCfAKx0xh1pruzJcXAZ4ir5AA5yBg3PTYsPu1I9bDxSV0PokOmoNnWsESG9jFbPch9ElH7GAkyN2r7GNCBzwhWyXXqAGxsUt1uS8o6kDjo3uhCO41RrqcC7A/ljWhsOvWIulSU7sOL0mmMcj0VYI9PWYLdKIP/Zg1o1cLXw64PL6rp5ZUlm/VUEfbhyYbPKPWIej4IvRoqKvtZK2rXgXwPhHstAOuZFsUASMAFnxEGeFHPB2k3NIwC0eGzsRrtphagA58S6ADIQapHlfSx25KyDiQOuje6EKPXqlPrfyQwODIYG6JL1HoQHaIqFSV9eEB0TLjaMh01mfAZH8rW8q8oSkWJHkD4+BwY079Rgcqy9m0Ua9wAax9eZIFVZ3tO1JnEYvTzQQAKnyFXCuVGzE0Y5LVlOtNksZ9R6hHVfJDMEADF1AMI335mh7W2A0BOfMrif27EpI/dlpR1IHHQvdElk9f6pgHT4MpgcGQwNkSXqPWIqlSU9OERPdrt8J3GVFYrQQTiQ7lTB0CO+4ToEnapaGdLiqqG7zQmU0BuVPuevLZMREhkOkg0iDKq+SB2q6HCnomRSJrEUCc+o6yOkeEeASS4T6h7Nez5IIlE9/UI+3xXlO4WHal8Lkn8TxnwGXbSx25LyjqQOOiOxWr0oioVBeJMt5MeUenQ2YdXK5qMZ1hOI/1aaxeAVlMrRQPkKI+M8h5RVapMU4L+t7Dx2alHfcWciByW00i/1toFa6moDPYzKh1IS0rUekR5lgAd+Fwzy9yjwmdUpaKAJKR655aUqPEZ4XwQix4lzfer67Yr1PO9I+iWCZ9R6dCsaO0gMpHqYSd9APu5GH0ucdAdi3WCeVSlooAkh3JHH14UA05oPSwBXsg6dOpBWPBMQctAhyX0oUwbXykO5YiCXdKHF/V9EmWA16kHcdpSA1oFT1hC45MuFZUCnxHpQFpSotYjyrMEsOKzotvPRDrcs5XGZ1SlooAcREjXlpSo9JBg/gJgrUwh57uSDNfXkC7pEyERQr+eDPdJ1Phch5nueGVYLPZBTdilooB9T2JUQQ0gh/MatdGj9SAsZ5gsOGCPz7BLRYGOrIA+9CXsQ9now1PjQ7lTjzW9NDPMLCL9emsXzGuRSJul72GJxUGJoEcU6F4NFXkmUaJMN936EGbGyA6fYZeKAtZrQXo1w8ZF52oomfAZNSlEtz4kQszHSZP0oYgQNSLiNJkC0oNaNV+tGOF8ELoVJMKkzzrMdMdBdywdh3KUpaI27G/YBxHpw6uvyLMaKtJDmdKj3dS+lyGoidqBJpNWw9aD9OHVinJUhMjkNJL5AzKQQrnhaEvxonIaSUtKZVE+0jJqfIY9b4AIHdREWSpKXwtCmEZlx5tV+fAZ9ZkWGT5lS/qUtEodIDqb0ViNSXUAXStS14HE5eWx2Bu9qB0UGbITpXPY0KWinXrIdChHis+oiRD9NcszZqlojE8JgpoL8gR4MuBzdV6CUlFJzpIa1Z4TJSkky70qw31SWdrY80E69ZDhfJdlPkhU7WO0HtXljT0fhH7NONMdy7qS+FC2Sm4YKJ8Dime0/0ddKiqDA12ly8slCGqirsRoVCPUQ39Ngk8lYU5JDkvo1VBS4LMYzRA1+vXoTGLU9jOqTDetR/Es9bMNOB8E6LCfeo4jUtJSkvkgSd31jDKoofEpBWkZcfnumj6nRYZKoajv1agz3QBQOo8Nn/SJe7pjWZdCBzWyGD0ZnFcS1ERdKioLERJ5efmiPPhsVqPXg+Az0qmiRYmIkAgmQ9OvF3mm26YUL0o9CD4jKRWlSaGI5oMAHUQI2fwgAT6jPktIK4gM9jPq+SCynGmKfo/G+DSDbhn8z42c9Ikz3bGsS6GDGlmMngzZieLp6HWI2ujZDQ+LyyMlyXQTfEaYtaqVzSAvanySrIAMmcTIAzySIYkyk6jjM8p7pF4GKsvWn4UpdCUGIeo2fHsOnemWwH5GqUOzYpZ1R32mkUBTipkDcabbgs+oSPV2A1iZs+oVpsSZ7ljWpch4KMuW6Y5Kh6iNHn0ok/4iGYKaqPFpZLojDHhlwKfaBsrndT0iDjSN8nIJSKGo8RnV9HJaD6MSI0IdAH02ByK6T6hKjHrU5eVRk+rkWhSjm14OyIFP+jVJmXvkpJA+fyHOdMuV6Y4CF/SWFBnukzjTHcu6EhmNngzOa2z0rI482TMrxaEccYAnRaY7QlzQq6FkwWfk5eWLcpCF0vR0R0gKpbJAMqsNcpMFn5GVl0vYPhbp9PKO9ocodKBXQ0VKntKkkD5UbsNWYlAtKVJkuiPEBb0lJUo91mGmOxG1ArFIIBYmPMpM4oipB5kqKkV5ZAQ6EKMXtR5STIfWX6+yrE2cpfUKU2SbXh5leSRZDRW1HlLgUw9qakVTh6iDGpnwGYUOdnpEjk9CWkZUidFYladqSoaWFNnwGbXNiPp8b9UirkqxaUmJlBSK8bkeM91x0B2L6QSoLaB4Svs+ygCP9A7TPwtTiLEhmbOojV6UeshwKA+M6d+owPJJq15hioHPKiKbKkrrEeNTDnzmRs3J1EsnrHqFKXRLChl6KAM+o9DBTo+Nis/ssDm4bOm4+bOwhVwLtW22gsT4jFYPGUihdN4cFCYDPgHTB42yfczARQQ6ADb4jOJaUNUH60TioDsWrRQvo690WTyh/Ru10QM0Q5zKhK9Hp6GN+lCOUg9yLSpLJvsbttOYTGmBDRAtPjtfM4qpokA3DjY0PqnqA8NpDBmfiQQwoDuqUeLTaEnRJYpVckA3DqImhZz+H4bIUImhKOZrEnxGcS3SeXNCNhEZ/AxZ8Bn1Gjep8BnBtSAtKbREaTOc/h+WyHCf0FtS1onEQXcsmhB2syRBHx6RjWxsZNGD6FA+ByO7a2SeQxRyKEeJT9KHRySKqaJAt3MWGT4l0IPosDJD9cyGnKkB5MAn3ZICIJJVcoAcZIydHlHaz9X56PbI069ZirC/XVGsWMgMhb9KDrDBZ8SZREOPCIOayiK1nSQKfHb4nzL4XFGskuvUwe7/YYkM+KS3pJA5JX0ucdAdiybE0EY5QAKw3tgb2djIogc9pRrQMs7JCOYvyohPGXSw+39YIiM+MwWNvAtbpMRnRMGEDGShnR5RtkwRXKQGgEw+fD068SlDoCkLLjayHrkOfCYz0VTHdOFTgjNNBh3s/h+WyIBP2n7WV8J/fQESB92xaNLJbspgcDaysenUQ5ZS0ShYcLvXlQGfMuhg9/+wRIb7pAufEWS57V5XhqAmMnx2tudEdS0kqMTofM3I7GcHPmWwGbLYz42sR6YAS0tKfiKa6pjO+0IGfMqgg93/wxIZ8Em2pADrpq87Drpj0URGo7eRjU2nHlGVinb24ckSdMuATxl0AOQI8KIqFe1sSYnxKZcOsugR1XyQzpaUyEghWUhLylZt5LYYwPoZRDUfJJHQfAsisthPGXwuGXSw+39YIkPSh96Ssk4mmMdBdyyayGj0ZDA2sugRValoZx+eLJkaGQJNGXSw+39YIkOA16lH7DTKpYMsesT4tP5fBpshAy4i1YM6P6KaDwJYr4cspJAM+JSFFJLhPokq6QNYh/2tA4mD7lg0icvPTJFx0EpU16JTj9hplEsHu/+HJTE+nV9XBmzIoIMsesT4tP5fBpshAy5k0SMmhaz/l4UIiUSHQsf/ZcBnRD4wEGe6Y1mnQhu9qEpFgY7yMwmCXbv/hyVSHsoSMOFRlYoCcgSanX14MT7N72VwGhMprRctCpEBn50tKRs5wAPkw2dUpaKAHERIZ0uKDPjc8KSQhEmfqHRIpjUbSkSGmRhR4tPY1b0+1obFQXcsmtDGVhYHJaob3W41VBQii9Gj9ZDBaZQFn1Hp0dmHFzuN5vcykELZCEtFZcBnZ0uKDA60NPiUIKiJslRURiJEBnzKci1kON8jTfpI0D7WqcdGx2ec6Y5lXQpt9GRxUGQ5iDa60ZPtUJaFgNjo90mMT/vXlQUXG10PGe4RQL5KoShLRWUkQqRoH5MkwJPBfspyr8qihwz2M9JMt/7acU93LOtKZDR6MhzKG71UtFOP+FCWTA8lulJRaQgIGSox6EyiDLiI9ZDuLAHksJ+yXAtZgn8Z8CnLvRrjUz49Njo+40x3LOtSZDR6MhxEG71U9P/f3t0HR1Xfexz/bMgj5IkgJFlJAvgAgk24IRK2YFMgGGnLgAYVmxmCBbw6wYGmHTu2koAXLxo7reAA6lhNO9VqaScRnCmYCSZpGQghGuSpXKRQ6E0CCg15sIQ0OfePmA0L2Hpn2Px+sO/XzI6755xlv3v87Ml+z++cs5fXYUNTY0s+bagjLLr3cHMTyOfVX9foqNWlO0IsqCPQrw8i2ZdPWz6rNmw/A/36IJfXYepIjAh2Wl61DgZ9GOm+lmpqajRnzhy53W65XC6Vl5f7zHccR0VFRUpMTFRERISys7N19OhRn2XOnTunvLw8RUdHKzY2VosXL1Z7e7vPMh9//LHuvvtuhYeHKykpSSUlJf5+a9efiKH9923Y2Fx+f6D1rQMbarCpDlNfGsNjey8AJNmTTxvqsCUXttRhKp9hUb2/tXt5PQPNtnzaUMPl9weaDUdihAzu/x1oW9aFDdkwWoNl60IymM/w/iO2bPlbYkMdDPow0n0tdXR0KC0tTRs2bLjq/JKSEq1fv14vv/yyamtrNWTIEOXk5OjChQveZfLy8nTw4EFVVFTovffeU01NjR599FHv/NbWVt1zzz1KSUlRfX29XnjhBa1atUqvvvqq39/fdWVQcG9jI9mxsbn8/kCz4o+yZetCMrcnPCiof2+4Lfm04Tw8W3IR6COJLlf/a1uTTwvqsKGGy+8PNNvyacu6sKH5N1qDBRfDlOzYaSn1f7ewJZ821GEyF5f+Sgoj3ddMsMkXnz17tmbPnn3VeY7j6MUXX9TTTz+tuXPnSpJ+9atfKT4+XuXl5VqwYIEOHz6sbdu2qa6uThkZGZKkl156Sd/61rf005/+VG63W2+++aYuXryo119/XaGhoZowYYIaGhr0s5/9zKc5h3o3uBda7NjYSHY0NSZr8G70HDvWhSuof8eMCYOHSZ9/Zk+DZ8PnxOQfw76fhnK67fnSeOkROwNt8DCpvdmOXEh21GGyhpBwaVCo1H3Rnnya2mnZ99qt/2vPugj0fPb9NFTX5/aMuEeYzOcwqeWkHTtjJDs+JyZz0fcrKZ2tjHRfQ9ae0338+HE1NzcrOzvbOy0mJkaZmZnatWuXJGnXrl2KjY31NtySlJ2draCgINXW1nqX+cY3vqHQ0P7zdnJycnTkyBH9/e9/H6B3c52wYqTGskOubNjoma6jb11ExJk7f1iyJJ+2jNRYkM9LfxrKhnyGx/YesWPKYNuOxLCgDpM1XFqHDfkMjer9jWhTGOnuZ1s+bVgXIYOl0MH/ell/si2fNuwIMTnYItkx+HSDjXRb23Q3NzdLkuLj432mx8fHe+c1NzdrxIgRPvODg4MVFxfns8zV/o1LX+NynZ2dam1t9bkFhMgv1qXRvZ1fvLYryOwfor51MNjgyJnUP3JncoSkb11EjvjXy/lb5PDe/5rMp3ck1WX2D1FfHkzmQrrkc0I+rdh+RsR+ccdl+KiUL9aByXVxaR1W5HO4uRokacgX+TS5LsJj1X/Iaqy5OmzLpw3fuYaQT4XH9F87xuRRU32vbbIGqf/7r8k6+gbiOs+bq+EaMnp4ua3Wrl2r1atXmy5j4E1d0fvhGj/XXA2D46SZRVLIELOjAqkPSeeOSZmPmatBkrJXSadqJfd/mKshZap01xLplhnmapCkry/v3fM6YZ65GiJie/+fDAo1d1VRSfrag9Jn/yNNNnyKTHaxdGKndHPGv1/WX5KnSHctlcZkmatBkjzLejNxZ665GsKipFn/9cV9Qz8lJ/WugzOHercbJs0sko7XSElTzNUw8i5p8n9Ko6aaq0GSPAW9V+q+c765GkIHSznPSt1dl+wgMmDCfVLzfinjEXM1SNKMp6VjO6SUr5ur4eZJvd9zkg1+RiRpyuO9R9J97UFzNQSHSTn/3XvIv8nmf8J9UtM+adIiczVI0vSnpaPvS6Ommashcrg0OkuKvtlcDdeQy3Ecx3QRkuRyuVRWVqZ58+ZJkv7yl7/olltu0UcffaSJEyd6l8vKytLEiRO1bt06vf766/rBD37gc5j4P//5T4WHh2vz5s267777tHDhQrW2tvpcGf2DDz7QjBkzdO7cOQ0deuUenM7OTnV2dnoft7a2KikpSefPn1d0tOHDkQAAAAAAxrW2tiomJubf9onWHl4+evRoJSQkqLKy0juttbVVtbW18ng8kiSPx6OWlhbV19d7l9mxY4d6enqUmZnpXaampkZdXV3eZSoqKjR27NirNtySFBYWpujoaJ8bAAAAAAD/X0ab7vb2djU0NKihoUFS78XTGhoadPLkSblcLq1YsUJr1qzRli1btH//fi1cuFBut9s7Gn7HHXfo3nvv1dKlS7Vnzx7t3LlTy5Yt04IFC+R2uyVJ3/3udxUaGqrFixfr4MGDeuedd7Ru3ToVFhYaetcAAAAAgEBh9PDyqqoqTZ8+/Yrp+fn5Ki0tleM4Ki4u1quvvqqWlhZNmzZNGzdu1O233+5d9ty5c1q2bJm2bt2qoKAg5ebmav369YqM7D+f7eOPP1ZBQYHq6up000036YknntCPfvSjr1znVz1sAAAAAAAQGL5qn2jNOd02o+kGAAAAAFzquj+nGwAAAACA6x1NNwAAAAAAfkLTDQAAAACAn9B0AwAAAADgJzTdAAAAAAD4CU03AAAAAAB+QtMNAAAAAICf0HQDAAAAAOAnwaYLuB44jiOp98fPAQAAAADo6w/7+sUvQ9P9FbS1tUmSkpKSDFcCAAAAALBJW1ubYmJivnS+y/l3bTnU09OjxsZGRUVFyeVymS7nS7W2tiopKUmnTp1SdHS06XIAH+QTNiOfsBn5hM3IJ2zm73w6jqO2tja53W4FBX35mduMdH8FQUFBGjlypOkyvrLo6Gg2erAW+YTNyCdsRj5hM/IJm/kzn/9qhLsPF1IDAAAAAMBPaLoBAAAAAPATmu4bSFhYmIqLixUWFma6FOAK5BM2I5+wGfmEzcgnbGZLPrmQGgAAAAAAfsJINwAAAAAAfkLTDQAAAACAn9B0AwAAAADgJzTdN4gNGzZo1KhRCg8PV2Zmpvbs2WO6JASgmpoazZkzR263Wy6XS+Xl5T7zHcdRUVGREhMTFRERoezsbB09etRMsQg4a9eu1V133aWoqCiNGDFC8+bN05EjR3yWuXDhggoKCjRs2DBFRkYqNzdXp0+fNlQxAsmmTZuUmprq/S1Zj8ejP/zhD975ZBM2ee655+RyubRixQrvNDIKU1atWiWXy+VzGzdunHe+Ddmk6b4BvPPOOyosLFRxcbE+/PBDpaWlKScnR2fOnDFdGgJMR0eH0tLStGHDhqvOLykp0fr16/Xyyy+rtrZWQ4YMUU5Oji5cuDDAlSIQVVdXq6CgQLt371ZFRYW6urp0zz33qKOjw7vM97//fW3dulWbN29WdXW1Ghsbdf/99xusGoFi5MiReu6551RfX6+9e/dqxowZmjt3rg4ePCiJbMIedXV1euWVV5SamuoznYzCpAkTJqipqcl7+9Of/uSdZ0U2HVz3Jk+e7BQUFHgfd3d3O26321m7dq3BqhDoJDllZWXexz09PU5CQoLzwgsveKe1tLQ4YWFhzm9+8xsDFSLQnTlzxpHkVFdXO47Tm8eQkBBn8+bN3mUOHz7sSHJ27dplqkwEsKFDhzqvvfYa2YQ12tranNtuu82pqKhwsrKynOXLlzuOw/YTZhUXFztpaWlXnWdLNhnpvs5dvHhR9fX1ys7O9k4LCgpSdna2du3aZbAywNfx48fV3Nzsk9WYmBhlZmaSVRhx/vx5SVJcXJwkqb6+Xl1dXT4ZHTdunJKTk8koBlR3d7fefvttdXR0yOPxkE1Yo6CgQN/+9rd9siix/YR5R48eldvt1pgxY5SXl6eTJ09KsiebwQP2SvCLzz77TN3d3YqPj/eZHh8frz//+c+GqgKu1NzcLElXzWrfPGCg9PT0aMWKFZo6daruvPNOSb0ZDQ0NVWxsrM+yZBQDZf/+/fJ4PLpw4YIiIyNVVlam8ePHq6GhgWzCuLffflsffvih6urqrpjH9hMmZWZmqrS0VGPHjlVTU5NWr16tu+++WwcOHLAmmzTdAICAU1BQoAMHDvic8wWYNnbsWDU0NOj8+fP63e9+p/z8fFVXV5suC9CpU6e0fPlyVVRUKDw83HQ5gI/Zs2d776empiozM1MpKSn67W9/q4iICIOV9ePw8uvcTTfdpEGDBl1xBb7Tp08rISHBUFXAlfrySFZh2rJly/Tee+/pgw8+0MiRI73TExISdPHiRbW0tPgsT0YxUEJDQ3Xrrbdq0qRJWrt2rdLS0rRu3TqyCePq6+t15swZpaenKzg4WMHBwaqurtb69esVHBys+Ph4MgprxMbG6vbbb9cnn3xizfaTpvs6FxoaqkmTJqmystI7raenR5WVlfJ4PAYrA3yNHj1aCQkJPlltbW1VbW0tWcWAcBxHy5YtU1lZmXbs2KHRo0f7zJ80aZJCQkJ8MnrkyBGdPHmSjMKInp4edXZ2kk0YN3PmTO3fv18NDQ3eW0ZGhvLy8rz3yShs0d7ermPHjikxMdGa7SeHl98ACgsLlZ+fr4yMDE2ePFkvvviiOjo69Mgjj5guDQGmvb1dn3zyiffx8ePH1dDQoLi4OCUnJ2vFihVas2aNbrvtNo0ePVorV66U2+3WvHnzzBWNgFFQUKC33npL7777rqKiorzncsXExCgiIkIxMTFavHixCgsLFRcXp+joaD3xxBPyeDyaMmWK4epxo3vqqac0e/ZsJScnq62tTW+99Zaqqqq0fft2sgnjoqKivNe/6DNkyBANGzbMO52MwpQf/vCHmjNnjlJSUtTY2Kji4mINGjRIDz/8sDXbT5ruG8BDDz2kTz/9VEVFRWpubtbEiRO1bdu2Ky5YBfjb3r17NX36dO/jwsJCSVJ+fr5KS0v15JNPqqOjQ48++qhaWlo0bdo0bdu2jfPDMCA2bdokSfrmN7/pM/2NN97QokWLJEk///nPFRQUpNzcXHV2dionJ0cbN24c4EoRiM6cOaOFCxeqqalJMTExSk1N1fbt2zVr1ixJZBP2I6Mw5W9/+5sefvhhnT17VsOHD9e0adO0e/duDR8+XJId2XQ5juMM6CsCAAAAABAgOKcbAAAAAAA/oekGAAAAAMBPaLoBAAAAAPATmm4AAAAAAPyEphsAAAAAAD+h6QYAAAAAwE9ougEAAAAA8BOabgAAAAAA/ISmGwAAAAAAP6HpBgAgQH366ad6/PHHlZycrLCwMCUkJCgnJ0c7d+6UJLlcLpWXl5stEgCA61yw6QIAAIAZubm5unjxon75y19qzJgxOn36tCorK3X27FnTpQEAcMNwOY7jmC4CAAAMrJaWFg0dOlRVVVXKysq6Yv6oUaP017/+1fs4JSVFJ06ckCS9++67Wr16tQ4dOiS32638/Hz95Cc/UXBw7758l8uljRs3asuWLaqqqlJiYqJKSko0f/78AXlvAADYhMPLAQAIQJGRkYqMjFR5ebk6OzuvmF9XVydJeuONN9TU1OR9/Mc//lELFy7U8uXLdejQIb3yyisqLS3Vs88+6/P8lStXKjc3V/v27VNeXp4WLFigw4cP+/+NAQBgGUa6AQAIUL///e+1dOlS/eMf/1B6erqysrK0YMECpaamSuodsS4rK9O8efO8z8nOztbMmTP11FNPeaf9+te/1pNPPqnGxkbv8x577DFt2rTJu8yUKVOUnp6ujRs3DsybAwDAEox0AwAQoHJzc9XY2KgtW7bo3nvvVVVVldLT01VaWvqlz9m3b5+eeeYZ70h5ZGSkli5dqqamJn3++efe5Twej8/zPB4PI90AgIDEhdQAAAhg4eHhmjVrlmbNmqWVK1dqyZIlKi4u1qJFi666fHt7u1avXq3777//qv8WAADwxUg3AADwGj9+vDo6OiRJISEh6u7u9pmfnp6uI0eO6NZbb73iFhTU/7Vi9+7dPs/bvXu37rjjDv+/AQAALMNINwAAAejs2bN64IEH9L3vfU+pqamKiorS3r17VVJSorlz50rqvYJ5ZWWlpk6dqrCwMA0dOlRFRUX6zne+o+TkZM2fP19BQUHat2+fDhw4oDVr1nj//c2bNysjI0PTpk3Tm2++qT179ugXv/iFqbcLAIAxXEgNAIAA1NnZqVWrVun999/XsWPH1NXVpaSkJD3wwAP68Y9/rIiICG3dulWFhYU6ceKEbr75Zu9Phm3fvl3PPPOMPvroI4WEhGjcuHFasmSJli5dKqn3QmobNmxQeXm5ampqlJiYqOeff14PPvigwXcMAIAZNN0AAOCautpVzwEACFSc0w0AAAAAgJ/QdAMAAAAA4CdcSA0AAFxTnLkGAEA/RroBAAAAAPATmm4AAAAAAPyEphsAAAAAAD+h6QYAAAAAwE9ougEAAAAA8BOabgAAAAAA/ISmGwAAAAAAP6HpBgAAAADAT2i6AQAAAADwk/8D60SsDphd3J4AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(2, 1, figsize=(10, 8), sharex=True)\n", + "\n", + "# FairShareScheduler\n", + "for node, group in df1.groupby(\"node_id\"):\n", + " axes[0].plot(group[\"step\"], group[\"cpu\"], label=f\"{node} CPU\")\n", + "axes[0].set_ylabel(\"CPU (millicore)\")\n", + "axes[0].set_title(\"FairShareScheduler Workload\")\n", + "axes[0].legend()\n", + "\n", + "# WaggleScheduler\n", + "for node, group in df2.groupby(\"node_id\"):\n", + " axes[1].plot(group[\"step\"], group[\"cpu\"], label=f\"{node} CPU\")\n", + "axes[1].set_xlabel(\"Step\")\n", + "axes[1].set_ylabel(\"CPU (millicore)\")\n", + "axes[1].set_title(\"WaggleScheduler Workload\")\n", + "axes[1].legend()\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "ea49c4fc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running workloads: 74\n", + "Finished workloads: 26\n", + "\n", + "Running workloads CPU stats:\n", + "count 74.000000\n", + "mean 2878.378378\n", + "std 703.274196\n", + "min 2000.000000\n", + "25% 2000.000000\n", + "50% 3000.000000\n", + "75% 3500.000000\n", + "max 5600.000000\n", + "Name: cpu, dtype: float64\n", + "\n", + "Finished workloads CPU stats:\n", + "count 26.0\n", + "mean 0.0\n", + "std 0.0\n", + "min 0.0\n", + "25% 0.0\n", + "50% 0.0\n", + "75% 0.0\n", + "max 0.0\n", + "Name: cpu, dtype: float64\n" + ] + } + ], + "source": [ + "running = df[df['cpu'] > 0]\n", + "finished = df[df['cpu'] == 0]\n", + "\n", + "print(f\"Running workloads: {len(running)}\")\n", + "print(f\"Finished workloads: {len(finished)}\")\n", + "\n", + "# Optionally, show statistics\n", + "print(\"\\nRunning workloads CPU stats:\")\n", + "print(running['cpu'].describe())\n", + "\n", + "print(\"\\nFinished workloads CPU stats:\")\n", + "print(finished['cpu'].describe())" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "30088588", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for node, group in df.groupby(\"node_id\"):\n", + " plt.figure(figsize=(10, 4))\n", + " plt.plot(group[\"step\"], group[\"cpu\"], label=\"CPU (millicore)\")\n", + " plt.plot(group[\"step\"], group[\"energy\"], label=\"Energy (Joule)\")\n", + " plt.xlabel(\"Step\")\n", + " plt.title(f\"CPU and Energy Usage for {node}\")\n", + " plt.legend()\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "ffa8d322", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Memory usage (in KB):\n", + "df: 20.05 KB\n", + "df1: 20.05 KB\n", + "df2: 20.05 KB\n" + ] + } + ], + "source": [ + "print(\"Memory usage (in KB):\")\n", + "print(f\"df: {df.memory_usage(deep=True).sum() / 1024:.2f} KB\")\n", + "print(f\"df1: {df1.memory_usage(deep=True).sum() / 1024:.2f} KB\")\n", + "print(f\"df2: {df2.memory_usage(deep=True).sum() / 1024:.2f} KB\")" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "43954bbf", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot CPU and Energy for all nodes in df\n", + "plt.figure(figsize=(10, 5))\n", + "for node, group in df.groupby(\"node_id\"):\n", + " plt.plot(group[\"step\"], group[\"cpu\"], label=f\"{node} CPU\")\n", + " plt.plot(group[\"step\"], group[\"energy\"], linestyle='--', label=f\"{node} Energy\")\n", + "plt.xlabel(\"Step\")\n", + "plt.ylabel(\"Value\")\n", + "plt.title(\"CPU and Energy Usage for All Nodes\")\n", + "plt.legend()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "4ad27c52", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FairShareScheduler nodes: 2\n", + "WaggleScheduler nodes: 2\n", + "\n", + "FairShareScheduler node IDs: ['node_t001' 'node_t002']\n", + "WaggleScheduler node IDs: ['node_t001' 'node_t002']\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\"FairShareScheduler nodes:\", df1['node_id'].nunique())\n", + "print(\"WaggleScheduler nodes:\", df2['node_id'].nunique())\n", + "\n", + "print(\"\\nFairShareScheduler node IDs:\", df1['node_id'].unique())\n", + "print(\"WaggleScheduler node IDs:\", df2['node_id'].unique())\n", + "\n", + "# Plot number of nodes (computers) vs. total CPU usage for each scheduler\n", + "num_nodes_list = [2, 6]\n", + "fig, ax = plt.subplots(figsize=(7, 4))\n", + "\n", + "for df_sched, label in [(df1, \"FairShareScheduler\"), (df2, \"WaggleScheduler\")]:\n", + " total_cpu = []\n", + " for n in num_nodes_list:\n", + " # Take only the first n unique nodes\n", + " nodes = sorted(df_sched['node_id'].unique())[:n]\n", + " cpu_sum = df_sched[df_sched['node_id'].isin(nodes)]['cpu'].sum()\n", + " total_cpu.append(cpu_sum)\n", + " ax.plot(num_nodes_list, total_cpu, marker='o', label=label)\n", + "\n", + "ax.set_xlabel(\"Number of Computers (Nodes)\")\n", + "ax.set_ylabel(\"Total CPU Usage (millicore)\")\n", + "ax.set_title(\"Total CPU Usage vs. Number of Computers for Each Scheduler\")\n", + "ax.legend()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "e4e602bc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# CPU usage over steps for each node\n", + "plt.figure(figsize=(10, 4))\n", + "for node, group in df1.groupby(\"node_id\"):\n", + " plt.plot(group[\"step\"], group[\"cpu\"], label=f\"{node} CPU\")\n", + "plt.xlabel(\"Step\")\n", + "plt.ylabel(\"CPU (millicore)\")\n", + "plt.title(\"FairShareScheduler: CPU Usage per Node\")\n", + "plt.legend()\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Energy usage over steps for each node\n", + "plt.figure(figsize=(10, 4))\n", + "for node, group in df1.groupby(\"node_id\"):\n", + " plt.plot(group[\"step\"], group[\"energy\"], label=f\"{node} Energy\")\n", + "plt.xlabel(\"Step\")\n", + "plt.ylabel(\"Energy (Joule)\")\n", + "plt.title(\"FairShareScheduler: Energy Usage per Node\")\n", + "plt.legend()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "c2bd9bf7", + "metadata": { + "vscode": { + "languageId": "ruby" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
metricstepnode_idstart_timeend_timecpuenergymax_cpu_limitcpu_exceeds_limit
00node_t0015459.4849331.0795593943True
10node_t0020.0000000.4278632627False
21node_t0010.0000000.4010362586False
31node_t0023059.1950910.8344283648False
42node_t0013259.2130480.9729733991False
\n", + "
" + ], + "text/plain": [ + "metric step node_id start_time end_time cpu energy \\\n", + "0 0 node_t001 5459.484933 1.079559 \n", + "1 0 node_t002 0.000000 0.427863 \n", + "2 1 node_t001 0.000000 0.401036 \n", + "3 1 node_t002 3059.195091 0.834428 \n", + "4 2 node_t001 3259.213048 0.972973 \n", + "\n", + "metric max_cpu_limit cpu_exceeds_limit \n", + "0 3943 True \n", + "1 2627 False \n", + "2 2586 False \n", + "3 3648 False \n", + "4 3991 False " + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "\n", + "# Plot how the randomization changed the data\n", + "fig, axes = plt.subplots(2, 1, figsize=(10, 8), sharex=True)\n", + "\n", + "for node, group in df1.groupby(\"node_id\"):\n", + " axes[0].plot(group[\"step\"], group[\"cpu\"], label=f\"{node} Original CPU\")\n", + " axes[0].plot(df1_random[df1_random[\"node_id\"] == node][\"step\"],\n", + " df1_random[df1_random[\"node_id\"] == node][\"cpu\"],\n", + " linestyle='--', label=f\"{node} Randomized CPU\")\n", + "axes[0].set_ylabel(\"CPU (millicore)\")\n", + "axes[0].set_title(\"Original vs. Randomized CPU Usage\")\n", + "axes[0].legend()\n", + "\n", + "for node, group in df1.groupby(\"node_id\"):\n", + " axes[1].plot(group[\"step\"], group[\"energy\"], label=f\"{node} Original Energy\")\n", + " axes[1].plot(df1_random[df1_random[\"node_id\"] == node][\"step\"],\n", + " df1_random[df1_random[\"node_id\"] == node][\"energy\"],\n", + " linestyle='--', label=f\"{node} Randomized Energy\")\n", + "axes[1].set_xlabel(\"Step\")\n", + "axes[1].set_ylabel(\"Energy (Joule)\")\n", + "axes[1].set_title(\"Original vs. Randomized Energy Usage\")\n", + "axes[1].legend()\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Copy df1 to avoid modifying the original\n", + "df1_random = df1.copy()\n", + "\n", + "# Add random noise to cpu and energy (e.g., ±10%)\n", + "np.random.seed(42)\n", + "df1_random['cpu'] = df1_random['cpu'] * (1 + np.random.uniform(-0.1, 0.1, size=len(df1_random)))\n", + "df1_random['energy'] = df1_random['energy'] * (1 + np.random.uniform(-0.1, 0.1, size=len(df1_random)))\n", + "\n", + "# Add a random constraint column (e.g., max_cpu_limit between 2000 and 4000)\n", + "df1_random['max_cpu_limit'] = np.random.randint(2000, 4001, size=len(df1_random))\n", + "\n", + "# Optionally, flag rows where cpu exceeds the random limit\n", + "df1_random['cpu_exceeds_limit'] = df1_random['cpu'] > df1_random['max_cpu_limit']\n", + "\n", + "df1_random.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "590f8fcb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU Statistics Comparison with Randomized FairShareScheduler:\n", + "\n", + "\n", + "Node: node_t001\n", + "Stat | FairShare (Random) | Waggle\n", + "--------------------------------------------\n", + "mean | 1779.61554 | 2310.00000\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Explanation: For node node_t001, the randomized FairShareScheduler shows a wider spread in CPU usage due to the added noise, while WaggleScheduler's CPU usage is more consistent. This reflects how randomization can introduce variability in jobload, potentially simulating real-world fluctuations or stress-testing the scheduler's robustness.\n", + "std | 1824.71124 | 356.99997\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Explanation: For node node_t001, the randomized FairShareScheduler shows a wider spread in CPU usage due to the added noise, while WaggleScheduler's CPU usage is more consistent. This reflects how randomization can introduce variability in jobload, potentially simulating real-world fluctuations or stress-testing the scheduler's robustness.\n", + "min | 0.00000 | 2000.00000\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Explanation: For node node_t001, the randomized FairShareScheduler shows a wider spread in CPU usage due to the added noise, while WaggleScheduler's CPU usage is more consistent. This reflects how randomization can introduce variability in jobload, potentially simulating real-world fluctuations or stress-testing the scheduler's robustness.\n", + "25% | 0.00000 | 2000.00000\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Explanation: For node node_t001, the randomized FairShareScheduler shows a wider spread in CPU usage due to the added noise, while WaggleScheduler's CPU usage is more consistent. This reflects how randomization can introduce variability in jobload, potentially simulating real-world fluctuations or stress-testing the scheduler's robustness.\n", + "50% | 1576.93274 | 2250.00000\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Explanation: For node node_t001, the randomized FairShareScheduler shows a wider spread in CPU usage due to the added noise, while WaggleScheduler's CPU usage is more consistent. This reflects how randomization can introduce variability in jobload, potentially simulating real-world fluctuations or stress-testing the scheduler's robustness.\n", + "75% | 3504.24698 | 2500.00000\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Explanation: For node node_t001, the randomized FairShareScheduler shows a wider spread in CPU usage due to the added noise, while WaggleScheduler's CPU usage is more consistent. This reflects how randomization can introduce variability in jobload, potentially simulating real-world fluctuations or stress-testing the scheduler's robustness.\n", + "max | 5459.48493 | 3100.00000\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Explanation: For node node_t001, the randomized FairShareScheduler shows a wider spread in CPU usage due to the added noise, while WaggleScheduler's CPU usage is more consistent. This reflects how randomization can introduce variability in jobload, potentially simulating real-world fluctuations or stress-testing the scheduler's robustness.\n", + "\n", + "Node: node_t002\n", + "Stat | FairShare (Random) | Waggle\n", + "--------------------------------------------\n", + "mean | 2457.76963 | 1950.00000\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Explanation: For node node_t002, the randomized FairShareScheduler shows a wider spread in CPU usage due to the added noise, while WaggleScheduler's CPU usage is more consistent. This reflects how randomization can introduce variability in jobload, potentially simulating real-world fluctuations or stress-testing the scheduler's robustness.\n", + "std | 639.21029 | 970.21984\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxYAAAGGCAYAAADmRxfNAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAX79JREFUeJzt3XdYFFf7N/Dv0juI9AhIUVSwt2BHUawRNcYWBYMdTYwtMcVeEo3YYstjxJLksUWNT2yxoMHeUewSFAuIQUHp7bx/+DI/l10QmcUF/X6uay/dmTNn7mnL3jvnnFEIIQSIiIiIiIhk0NF2AEREREREVPExsSAiIiIiItmYWBARERERkWxMLIiIiIiISDYmFkREREREJBsTCyIiIiIiko2JBRERERERycbEgoiIiIiIZGNiQUREREREsjGxINKAtWvXQqFQ4M6dO2W+ruDgYFStWlV6f+fOHSgUCvzwww9lvm4AmDZtGhQKxRtZV2GpqakYMmQIHBwcoFAoMHbsWK3EoWlv8vx511WtWhXBwcEar1ehUGD06NEar7esbN68GdbW1khNTdV2KMUq+Hxbu3btG1/31atXoaenh+jo6De+7rdNWV13VP4wsSCtiomJwfDhw+Hu7g4jIyNYWFigefPmWLx4MTIyMqRyVatWhUKhkF52dnZo2bIltm/frlRf1apV0bVrV7XrOnv2bIn+QB0+fFhpXYaGhrC3t0ebNm0wZ84cPH78WPZ2A0B6ejqmTZuGw4cPa6Q+TSqvsc2ZMwdr167FyJEjsWHDBgwcOFDbIZV7Dx8+xLRp03Dx4kW18x88eICPPvoIVlZWsLCwQPfu3fHPP/+oLfvzzz+jZs2aMDIyQrVq1bB06VKVMtu2bUOfPn3g7u4OExMTeHl5Yfz48UhOTpa1HS9fky+/HBwcZNX7KpcvX8aHH34IV1dXGBkZ4b333kP79u3VbntFkZeXh6lTp2LMmDEwMzOTphf+nDU1NUWTJk2wfv16LUarPbVq1UKXLl0wZcoUbYeCefPmQaFQ4MKFC0rThRCoVKkSFAoFYmNjleZlZmbC0NAQ/fv3f5Oh0jtOT9sB0Ltr165d6N27NwwNDTFo0CD4+PggOzsbR48excSJE3HlyhX89NNPUvl69eph/PjxAF58WVq1ahV69uyJFStWYMSIERqP79NPP0Xjxo2Rl5eHx48f4/jx45g6dSrCwsKwefNmtG3bVio7cOBA9O3bF4aGhiWuPz09HdOnTwcAtGnTpsTL/ec//0F+fn6Jy5dGcbF98803+PLLL8t0/UU5dOgQ3n//fUydOlUr66+IHj58iOnTp6Nq1aqoV6+e0rzU1FT4+fkhJSUFX331FfT19bFw4UK0bt0aFy9eROXKlaWyq1atwogRI9CrVy+MGzcOkZGR+PTTT5Geno4vvvhCKjds2DA4OTnh448/houLCy5fvowff/wRu3fvxvnz52FsbFzqbWnfvj0GDRqkNO1167tx4wZ0dEr2m9rx48fh5+cHFxcXDB06FA4ODrh37x5OnjyJxYsXY8yYMa+17vLif//7H27cuIFhw4apzHv5czY+Ph6rV69GUFAQsrKyMHTo0DcdqtaNGDECnTt3RkxMDDw8PLQWR4sWLQAAR48eRf369aXpV65cQXJyMvT09HDs2DG4ublJ886cOYPs7GxpWaI3gYkFaUVsbCz69u0LV1dXHDp0CI6OjtK80NBQ3L59G7t27VJa5r333sPHH38svR80aBA8PT2xcOHCMkksWrZsiQ8//FBpWlRUFDp06IBevXrh6tWrUty6urrQ1dXVeAwvS0tLg6mpKfT19ct0Pa+ip6cHPT3tfHQkJiaiVq1aGqsvNzcX+fn5MDAw0FidFcny5ctx69YtnD59Go0bNwYAdOrUCT4+PliwYAHmzJkDAMjIyMDXX3+NLl26YOvWrQCAoUOHIj8/HzNnzsSwYcNQqVIlAMDWrVtVktGGDRsiKCgIv/76K4YMGVLqeKtXr670GVAaJUn+C6612bNnw9LSEmfOnIGVlZVSmcTERFlxlEZBXHKFh4ejefPmeO+991TmFf6cDQ4Ohru7OxYuXPhOJhb+/v6oVKkS1q1bhxkzZmgtjkaNGsHIyAhHjx5VSmiPHTuGypUro1GjRjh69KjSsTt69CgAMLGgN4pNoUgr5s2bh9TUVPz8889KSUUBT09PfPbZZ8XW4eDggJo1a6rc/i1LdevWxaJFi5CcnIwff/xRmq6ujfzZs2cREBAAGxsbGBsbw83NDZ988gmAF+2GbW1tAQDTp0+Xmh5MmzYNwIs/5mZmZoiJiUHnzp1hbm6OAQMGSPNe7mPxsoULF8LV1RXGxsZo3bq1StvgNm3aqL078nKdr4pNXR+L3NxczJw5Ex4eHjA0NETVqlXx1VdfISsrS6lcQVO1o0ePokmTJjAyMoK7u/srm1oUNE+LjY3Frl27pJgK9ndiYiJCQkJgb28PIyMj1K1bF+vWrVOq4+W+KIsWLZJivXr1apHrLWg3v2PHDvj4+MDQ0BDe3t7Yu3evStkLFy6gU6dOsLCwgJmZGdq1a4eTJ0+qlLty5Qratm0LY2NjVKlSBbNmzSryDtSePXvQsmVLmJqawtzcHF26dMGVK1eK3VeF91tBwjB48GBpvxU0B9y6dSsaN24slQGAGjVqoF27dti8ebM0LSIiAklJSRg1apRS/aGhoUhLS1P6EUDd+dWjRw8AwLVr15Smx8fH4/r168jJySnxNhXlhx9+QLNmzVC5cmUYGxujYcOGUhL0ssJtvQuu3SNHjmDUqFGws7NDlSpVALxoqunt7a2SVACAnZ2d2jheda7cvXsXo0aNgpeXF4yNjVG5cmX07t1bpX9NcXEBpT83MjMzsXfvXvj7+7+yLADY2tqiRo0aiImJUZoeGRmJ3r17w8XFBYaGhnB2dsbnn3+u1IQV+L/PsgcPHiAwMBBmZmawtbXFhAkTkJeXp1Q2OTkZwcHBsLS0hJWVFYKCgopsQnfo0CFp+62srNC9e3eV86vgs+rmzZv4+OOPYWlpCVtbW3z77bcQQuDevXvo3r07LCws4ODggAULFqisR19fH23atMEff/xR7H7aunWrdLwKW7VqFRQKhfR5nJCQgMGDB6NKlSowNDSEo6MjunfvXmwfKwMDAzRu3BjHjh1Tmn7s2DH4+vqiefPmaudZWVnBx8cHQMmvkYyMDHz66aewsbGBubk5PvjgAzx48EDp70CBw4cPS0mPh4cHVq1aVeJ+eMnJyRg7diycnZ1haGgIT09PfP/992V+R57KFu9YkFb873//g7u7O5o1a1bqOnJycnDv3j2l5hpvwocffoiQkBD89ddfmD17ttoyiYmJ6NChA2xtbfHll1/CysoKd+7cwbZt2wC8+GO9YsUKjBw5Ej169EDPnj0BAHXq1JHqyM3NRUBAAFq0aIEffvgBJiYmxca1fv16PH/+HKGhocjMzMTixYvRtm1bXL58Gfb29iXevpLEVtiQIUOwbt06fPjhhxg/fjxOnTqFuXPn4tq1ayr9YG7fvi3tw6CgIKxZswbBwcFo2LAhvL291dZfs2ZNbNiwAZ9//jmqVKkiNdWwtbVFRkYG2rRpg9u3b2P06NFwc3PDli1bEBwcjOTkZJUENTw8HJmZmRg2bBgMDQ1hbW1d7P44evQotm3bhlGjRsHc3BxLlixBr169EBcXJ517V65cQcuWLWFhYYFJkyZBX18fq1atQps2bXDkyBE0bdoUwIsvFH5+fsjNzcWXX34JU1NT/PTTT2qb82zYsAFBQUEICAjA999/j/T0dKxYsQItWrTAhQsXikwuC++3GTNmYMqUKRg2bBhatmwJAGjWrBny8/Nx6dIlKdl9WZMmTfDXX3/h+fPnMDc3l9p1N2rUSKlcw4YNoaOjgwsXLhR7JyEhIQEAYGNjozR98uTJWLduHWJjY0u0PZmZmfj333+Vppmbm8PQ0BCLFy/GBx98gAEDBiA7OxsbN25E79698eeff6JLly6vrHvUqFGwtbXFlClTkJaWBgBwdXXFiRMnEB0dLX05K05JzpUzZ87g+PHj6Nu3L6pUqYI7d+5gxYoVaNOmDa5evapynauLS865ce7cOWRnZ6NBgwav3B7gxefQ/fv3pTtSBbZs2YL09HSMHDkSlStXxunTp7F06VLcv38fW7ZsUSqbl5eHgIAANG3aFD/88AMOHDiABQsWwMPDAyNHjgTwoq9A9+7dcfToUYwYMQI1a9bE9u3bERQUpBLTgQMH0KlTJ7i7u2PatGnIyMjA0qVL0bx5c5w/f15l+/v06YOaNWviu+++w65duzBr1ixYW1tj1apVaNu2Lb7//nv8+uuvmDBhAho3boxWrVopLd+wYUP88ccfePbsGSwsLNTupy5dusDMzAybN29G69atleZt2rQJ3t7e0jnUq1cvXLlyBWPGjEHVqlWRmJiI/fv3Iy4urthj16JFC0RGRuLOnTtSuWPHjmHIkCFo0qQJpk6diuTkZFhZWUEIgePHj8PX11dq+lfSayQ4OBibN2/GwIED8f777+PIkSNqr6ELFy6gY8eOcHR0xPTp05GXl4cZM2ZIP0wVJz09Ha1bt8aDBw8wfPhwuLi44Pjx45g8eTLi4+OxaNGiV9ZB5ZQgesNSUlIEANG9e/cSL+Pq6io6dOggHj9+LB4/fiyioqJE3759BQAxZswYpXJdunRRW8eZM2cEABEeHl7suiIiIgQAsWXLliLL1K1bV1SqVEl6Hx4eLgCI2NhYIYQQ27dvFwDEmTNniqzj8ePHAoCYOnWqyrygoCABQHz55Zdq57m6ukrvY2NjBQBhbGws7t+/L00/deqUACA+//xzaVrr1q1F69atX1lncbFNnTpVvPzRcfHiRQFADBkyRKnchAkTBABx6NAhaZqrq6sAIP7++29pWmJiojA0NBTjx49XWVdh6o7vokWLBADxyy+/SNOys7OFr6+vMDMzE8+ePRNC/N9+srCwEImJia9clxBCABAGBgbi9u3b0rSoqCgBQCxdulSaFhgYKAwMDERMTIw07eHDh8Lc3Fy0atVKmjZ27FgBQJw6dUpp+y0tLZXOn+fPnwsrKysxdOhQpXgSEhKEpaWlyvTiFHXeFxzjGTNmqCyzbNkyAUBcv35dCCFEaGio0NXVVVu/ra2t6Nu3b7ExhISECF1dXXHz5k2l6QXnecF2FweA2lfBdqWnpyuVz87OFj4+PqJt27ZK011dXUVQUJD0vuDabdGihcjNzVUq+9dffwldXV2hq6srfH19xaRJk8S+fftEdna22vhKcq4UjlMIIU6cOCEAiPXr178yLrnnxurVqwUAcfnyZZV5hT9nL1++LAYOHCgAiNDQUKWy6rZj7ty5QqFQiLt370rTCo5x4fOsfv36omHDhtL7HTt2CABi3rx50rTc3FzRsmVLlfO3Xr16ws7OTiQlJUnToqKihI6Ojhg0aJA0reCzatiwYUp1VqlSRSgUCvHdd99J058+fSqMjY2Vzo0Cv/32m8p1q06/fv2EnZ2d0vGKj48XOjo60vY/ffpUABDz588vti51du3aJQCIDRs2SHUDEEeOHBHPnz8Xurq6YteuXUIIIaKjowUAMXv2bGn5klwj586dEwDE2LFjlcoGBwer/E3o1q2bMDExEQ8ePJCm3bp1S+jp6Sn9jRBC9bqbOXOmMDU1VflM+PLLL4Wurq6Ii4t7jT1D5QmbQtEb9+zZMwAvfml8HX/99RdsbW1ha2uLunXrYsuWLRg4cCC+//77sgizWGZmZnj+/HmR8wuaTvz555+ymnkU/JpXEoGBgUptpps0aYKmTZti9+7dpV5/SRTUP27cOKXpBXcVCveVqVWrlvTLOfDiroOXl1eRIxGVZP0ODg7o16+fNE1fXx+ffvopUlNTVZom9OrVq0S/qBXw9/dX6rRZp04dWFhYSPHm5eXhr7/+QmBgINzd3aVyjo6O6N+/P44ePSqd87t378b777+PJk2aSOVsbW2lZm4F9u/fj+TkZPTr1w///vuv9NLV1UXTpk0RERFR4viLUtBkRV2fAyMjI6UyGRkZRfZDMTIyUmn+8rLffvsNP//8M8aPH49q1aopzVu7di2EECW6WwEA3bt3x/79+5VeAQEBAJQ7cT99+hQpKSlo2bIlzp8/X6K6hw4dqtJPqn379jhx4gQ++OADREVFYd68eQgICMB7772HnTt3qtTxqnOlcJw5OTlISkqCp6cnrKys1MZaOC6550ZSUhIAqNyBKPDy52zt2rWxYcMGDB48GPPnz1cq9/J2pKWl4d9//0WzZs0ghFAZuQiASj+4li1bKu2X3bt3Q09PT+kzT1dXV6WDfHx8PC5evIjg4GClu4116tRB+/bt1X7evdyvR1dXF40aNYIQAiEhIdJ0KyurIj+HCvZV4btlhfXp0weJiYlKo+lt3boV+fn56NOnD4AX+83AwACHDx/G06dPi62vsGbNmkFHR0fqO3Hs2DHo6+ujcePGMDMzQ506daTmUAX/vty/oiTXSEHTvcLNHgsfh7y8PBw4cACBgYFwcnKSpnt6eqJTp06v3JYtW7agZcuWqFSpktJ57O/vj7y8PPz9998l2idU/rApFL1xBbeSi/tirk7Tpk0xa9YsKBQKmJiYoGbNmmrbPr+KJp7BkJqaWmxi1Lp1a/Tq1QvTp0/HwoUL0aZNGwQGBqJ///4lHjlKT09PqU31qxT+0ga86Oz6clv5snD37l3o6OjA09NTabqDgwOsrKxw9+5dpekuLi4qdVSqVOm1/8i+vP5q1aqpjPRTs2ZNaf7LXh41pSReFe/jx4+Rnp4OLy8vlXI1a9ZEfn4+7t27B29vb9y9e1dqFvWywsveunULAJRGHntZUc0xXkfBl4zC/WCAF02OXi5jbGyM7OxstfVkZmYWOTJTZGQkQkJCEBAQUGSzwddRpUqVIvsG/Pnnn5g1axYuXryotE0lvd6LOi8aN26Mbdu2ITs7G1FRUdi+fTsWLlyIDz/8EBcvXlQaTKAk53ZGRgbmzp2L8PBwPHjwAEIIaV5KSsor49LUufHyel9W8Dmbl5eH6OhozJo1C0+fPlVJLOPi4jBlyhTs3LlT5dotvB1GRkYqyXzh/XL37l04OjoqDX8LqF4bBddzUdfbvn37VDq5Fz4ulpaWMDIyUmmaZ2lpKSVeLyvYV686lzp27AhLS0ts2rQJ7dq1A/CiGVS9evVQvXp1AC8S+e+//x7jx4+Hvb093n//fXTt2hWDBg165dDJVlZW8Pb2Vkoe6tevL11/zZo1U5pnYGCg9CNGSa6Rgs/zwudd4c/3xMREZGRkqExXV1adW7du4dKlS0X+yKONwRFIM5hY0BtnYWEBJyen137okI2NzSs7HBb362l6erpURo6cnBzcvHmz2DbXCoUCW7duxcmTJ/G///0P+/btwyeffIIFCxbg5MmTKn881TE0NCzxsJglpVAo1H6hKNyJsrR1l0RRo2cV9UVH0153eFJtxFvQeXHDhg1qv2xoYlQua2trGBoaIj4+XmVewbSCXyIdHR2Rl5eHxMREpU7L2dnZSEpKUvrFskBUVBQ++OAD+Pj4YOvWrWU6klhkZCQ++OADtGrVCsuXL4ejoyP09fURHh6O3377rUR1vOq8KOg827hxY1SvXh2DBw/Gli1blIY+Lsm5MmbMGISHh2Ps2LHw9fWFpaUlFAoF+vbtq7bTauG45J4bBX09nj59qvaHi5c/ZwMCAlCjRg107doVixcvlu5K5uXloX379njy5Am++OIL1KhRA6ampnjw4AGCg4NVtqOsR8x7FXXrf53ruiABKpyIFGZoaIjAwEBs374dy5cvx6NHj3Ds2DFpdLUCY8eORbdu3bBjxw7s27cP3377LebOnYtDhw4pDSWrTosWLbBy5UokJyfj2LFjSv0UmzVrhjVr1iAnJwdHjx5Fw4YNpb93mrhGNCk/Px/t27fHpEmT1M4vSMSo4mFiQVrRtWtX/PTTTzhx4gR8fX01Vq+rq2uRo/zcuHFDKiPH1q1bkZGRITXBKM7777+P999/H7Nnz8Zvv/2GAQMGYOPGjRgyZIjGn15d8Evmy27evKnUzKRSpUpqb/UX/lX/dWJzdXVFfn4+bt26Jd0lAIBHjx4hOTlZ9v4uyfovXbqE/Px8pUTs+vXr0vyyZGtrCxMTE+n8etn169eho6MDZ2dnKRZ1x6nwsgXNaezs7Eo8ek9RijqWOjo6qF27Ns6ePasy79SpU3B3d5fuyhU8/+Ls2bPo3LmzVO7s2bPIz89XeT5GTEwMOnbsCDs7O+zevbtEibQcv//+O4yMjLBv3z6lO4Lh4eFlsr6CTuzqkrJX2bp1K4KCgpRGIMrMzCzxAwTlnhs1atQA8GLI79q1a7+yfJcuXdC6dWvMmTMHw4cPh6mpKS5fvoybN29i3bp1Ss8V2b9//2vHU8DV1RUHDx5Eamqq0vlS+NoouJ6Lut5sbGw0MiTvy2JjY6Gjo1OiL7t9+vTBunXrcPDgQVy7dg1CCKkZ1Ms8PDwwfvx4jB8/Hrdu3UK9evWwYMEC/PLLL8XW36JFC6xYsQIHDhzAhQsXMHHiRGles2bNkJGRgV27duGff/5Br169pHklvUYKPs9jY2OV7oLfvn1bqZydnR2MjIxUpqsrq46HhwdSU1Nlf75R+cM+FqQVkyZNgqmpKYYMGYJHjx6pzI+JicHixYtfu97OnTvj/v372LFjh9L0rKwsrF69GnZ2diUeDUWdqKgojB07FpUqVUJoaGiR5Z4+faryy1fBl6+CW9AFo7/IfSJxgR07duDBgwfS+9OnT+PUqVNK7V09PDxw/fp1paeHR0VFqQxT+DqxFXzRLDyKR1hYGACUaEQeOTp37oyEhARs2rRJmpabm4ulS5fCzMxMZYQWTdPV1UWHDh3wxx9/KA0X+ejRI/z2229o0aKF1Dylc+fOOHnyJE6fPi2Ve/z4MX799VelOgMCAmBhYYE5c+ao7aPzOk9/L/iSpe5Yfvjhhzhz5oxScnHjxg0cOnQIvXv3lqa1bdsW1tbWWLFihdLyK1asgImJidIxTkhIQIcOHaCjo4N9+/YV259FU8PN6urqQqFQKN15u3PnjsrnwOuKiIhQ+wt2QTt+dc1xXkVXV1elzqVLl5b4rqHcc6Nhw4YwMDBQm1AW5YsvvkBSUhL+85//APi/X/tf3g4hRKk+swt07twZubm5SudYXl6eyhPOHR0dUa9ePaxbt07pnI6OjsZff/2llPhqyrlz5+Dt7Q1LS8tXlvX394e1tTU2bdqETZs2oUmTJkrNitLT06WmhgU8PDxgbm6utlliYQV9JsLCwpCTk6N0x6Jq1apwdHTEvHnzlMoCJb9GCn4wW758udL0wsdBV1cX/v7+2LFjBx4+fChNv337Nvbs2fPK7fjoo49w4sQJ7Nu3T2VecnIycnNzX1kHlU+8Y0Fa4eHhgd9++00aBvDlJ28fP35cGi70dQ0bNgxr1qxB79698cknn6B+/fpISkrCpk2bEB0djfXr15f4YWiRkZHIzMxEXl4ekpKScOzYMezcuROWlpbYvn17se1h161bh+XLl6NHjx7w8PDA8+fP8Z///AcWFhbSHz5jY2PUqlULmzZtQvXq1WFtbQ0fH58SDWupjqenJ1q0aIGRI0ciKysLixYtQuXKlZVuNX/yyScICwtDQEAAQkJCkJiYiJUrV8Lb21vqYPy6sdWtWxdBQUH46aefkJycjNatW+P06dNYt24dAgMD4efnV6rtKalhw4Zh1apVCA4Oxrlz51C1alVs3boVx44dw6JFi157kIDSmDVrFvbv348WLVpg1KhR0NPTw6pVq5CVlSX9kQdeJNQbNmxAx44d8dlnn0nDzRbcdSlgYWGBFStWYODAgWjQoAH69u0LW1tbxMXFYdeuXWjevLnSc1SK4+HhASsrK6xcuRLm5uYwNTVF06ZN4ebmhlGjRuE///kPunTpggkTJkBfXx9hYWGwt7eXOt8DL86HmTNnIjQ0FL1790ZAQAAiIyPxyy+/YPbs2UqdaDt27Ih//vkHkyZNwtGjR6WOpgBgb2+P9u3bS+9fd7jZonTp0gVhYWHo2LEj+vfvj8TERCxbtgyenp5K+/V1jRkzBunp6ejRowdq1KghfT5t2rQJVatWxeDBg1+7zq5du2LDhg2wtLRErVq1cOLECRw4cKDEw2bLPTeMjIzQoUMHHDhwoMQPfCt4aGJYWBhCQ0NRo0YNeHh4YMKECXjw4AEsLCzw+++/l7qfFAB069YNzZs3x5dffok7d+6gVq1a2LZtm9p+J/Pnz0enTp3g6+uLkJAQabhZS0tLlecsyJWTkyM9S6Qk9PX10bNnT2zcuBFpaWn44YcflObfvHkT7dq1w0cffYRatWpBT08P27dvx6NHj9C3b99X1u/i4gJnZ2ecOHECVatWVWmG2KxZM/z+++9QKBRo3ry5NL2k10jDhg3Rq1cvLFq0CElJSdJwszdv3gSgfAd02rRp+Ouvv9C8eXOMHDkSeXl5+PHHH+Hj44OLFy8Wux0TJ07Ezp070bVrV2m48bS0NFy+fBlbt27FnTt3Xtn0jMqpNz4OFdFLbt68KYYOHSqqVq0qDAwMhLm5uWjevLlYunSpyMzMlMoVN4xsYU+fPhWff/65cHNzE/r6+sLCwkL4+fmJPXv2lGj5guFmC176+vrC1tZWtGrVSsyePVvtUKWFh5s9f/686Nevn3BxcRGGhobCzs5OdO3aVZw9e1ZpuePHj4uGDRsKAwMDpaH8goKChKmpqdr4ihpudv78+WLBggXC2dlZGBoaipYtW4qoqCiV5X/55Rfh7u4uDAwMRL169cS+fftU6iwutsLDzQohRE5Ojpg+fbq0z52dncXkyZOVjqEQRR/HoobBLayo5R89eiQGDx4sbGxshIGBgahdu7bK8Kov76eSgpphNgviKDws5fnz50VAQIAwMzMTJiYmws/PTxw/flxl2UuXLonWrVsLIyMj8d5774mZM2eKn3/+We2wqxERESIgIEBYWloKIyMj4eHhIYKDg1XOo1f5448/RK1ataRhIF/eN/fu3RMffvihsLCwEGZmZqJr167i1q1bauv56aefhJeXlzAwMBAeHh5i4cKFIj8/X6nMy9dO4VfhY/y6w82qOxYFfv75Z1GtWjVhaGgoatSoIcLDw9Weq0UNN6tuaOg9e/aITz75RNSoUUOYmZkJAwMD4enpKcaMGSMePXpUovgKr+/p06fSuWpmZiYCAgLE9evXXysuIeSdG9u2bRMKhUJlSM/iPmfXrl2rdO5cvXpV+Pv7CzMzM2FjYyOGDh0qDa/78vlV1GeZumOTlJQkBg4cKCwsLISlpaUYOHCguHDhgtrhkg8cOCCaN28ujI2NhYWFhejWrZu4evWq2nU8fvxYaXpRMbVu3Vp4e3srTduzZ48AUOQ1oc7+/fsFAKFQKMS9e/eU5v37778iNDRU1KhRQ5iamgpLS0vRtGlTsXnz5hLX369fPwFA9O/fX2VeWFiYACBq1qypMq+k10haWpoIDQ0V1tbWwszMTAQGBoobN24IAEpD9AohxMGDB0X9+vWlz4TVq1eL8ePHCyMjI6Vy6j4znz9/LiZPniw8PT2FgYGBsLGxEc2aNRM//PCD2iGdqWJQCPGGekwSERGR1uXl5aFWrVr46KOPMHPmTG2HU64FBgZCoVCoPOjzXXPx4kXUr18fv/zyi8rw2IUFBgbiypUravuT0duPfSyIiIjeIbq6upgxYwaWLVuG1NRUbYdTbl27dg1//vnnO5d8qRtZcdGiRdDR0VF5Knnhsrdu3cLu3bvRpk2bsgyRyjHesSAiqoCys7Px5MmTYstYWlq+9vC6RPRumz59Os6dOwc/Pz/o6elhz5492LNnj9Sf7WWOjo4IDg6Gu7s77t69ixUrViArKwsXLlxQ+2wlevsxsSAiqoAOHz78yo7x4eHhpRoEgYjeXfv378f06dNx9epVpKamwsXFBQMHDsTXX3+t8pyUwYMHIyIiAgkJCTA0NISvry/mzJkja/RFqtiYWBARVUBPnz7FuXPnii3j7e0NR0fHNxQRERG965hYEBERERGRbOy8TUREREREsr31D8jLz8/Hw4cPYW5urvRgFyIiIiIiKp4QAs+fP4eTkxN0dIq/J/HWJxYPHz6Es7OztsMgIiIiIqqw7t27hypVqhRb5q1PLMzNzQG82BkWFhZajoaIiIiIqOJ49uwZnJ2dpe/UxXnrE4uC5k8WFhZMLIiIiIiISqEkXQrYeZuIiIiIiGRjYkFERERERLIxsSAiIiIiItne+j4WRERERHLk5eUhJydH22EQlQl9fX3o6upqpC4mFkRERERqCCGQkJCA5ORkbYdCVKasrKzg4OAg+5lvTCyIiIiI1ChIKuzs7GBiYsIH7dJbRwiB9PR0JCYmAgAcHR1l1cfEgoiIiKiQvLw8KamoXLmytsMhKjPGxsYAgMTERNjZ2clqFqXVzttz585F48aNYW5uDjs7OwQGBuLGjRtKZdq0aQOFQqH0GjFihJYiJiIiondBQZ8KExMTLUdCVPYKznO5fYm0mlgcOXIEoaGhOHnyJPbv34+cnBx06NABaWlpSuWGDh2K+Ph46TVv3jwtRUxERETvEjZ/oneBps5zrTaF2rt3r9L7tWvXws7ODufOnUOrVq2k6SYmJnBwcHjT4RERERERUQmVq+dYpKSkAACsra2Vpv/666+wsbGBj48PJk+ejPT0dG2ER0RERPRWW7t2LaysrDRSl0KhwI4dOzRSl6Z8++23GDZsmLbDkLyJffTvv//Czs4O9+/fL9P1AOWo83Z+fj7Gjh2L5s2bw8fHR5rev39/uLq6wsnJCZcuXcIXX3yBGzduYNu2bWrrycrKQlZWlvT+2bNnZR47ERERvTsW7r/5xtb1efvqr71McHAw1q1bpzL91q1b8PT0LHbZPn36oHPnzq9cx+PHjzFlyhTs2rULjx49QqVKlVC3bl1MmTIFzZs3f+2Y34SEhAQsXrwYly9flqa9vK/09PRQpUoV9O7dGzNmzICRkZG2QtUoGxsbDBo0CFOnTsXPP/9cpusqN4lFaGgooqOjcfToUaXpL2eVtWvXhqOjI9q1a4eYmBh4eHio1DN37lxMnz69zOMlIg2KmKvZ+vwma7Y+IqIKpmPHjggPD1eaZmtr+8rljI2NpVGC1MnOzoaBgQF69eqF7OxsrFu3Du7u7nj06BEOHjyIpKQk2bEXp2D9pbF69Wo0a9YMrq6uStML9lVOTg7OnTuHoKAgKBQKfP/995oIuVwYPHgwGjZsiPnz56u0DNKkctEUavTo0fjzzz8RERGBKlWqFFu2adOmAIDbt2+rnT958mSkpKRIr3v37mk8XiIiIqLyzNDQEA4ODkovXV1dhIWFoXbt2jA1NYWzszNGjRqF1NRUabnCTaGmTZuGevXqYfXq1XBzc4ORkRGSk5MRGRmJ77//Hn5+fnB1dUWTJk0wefJkfPDBB0px/Pvvv+jRowdMTExQrVo17Ny5U5qXl5eHkJAQuLm5wdjYGF5eXli8eLHS8sHBwQgMDMTs2bPh5OQELy8vAMC9e/fw0UcfwcrKCtbW1ujevTvu3LlT7D7ZuHEjunXrVuS+cnZ2RmBgIPz9/bF//35pflJSEvr164f33nsPJiYmqF27Nv773/8q1dGmTRt8+umnmDRpEqytreHg4IBp06Yplbl16xZatWoFIyMj1KpVS2kdBS5fvoy2bdvC2NgYlStXxrBhw5SOT8H+mDNnDuzt7WFlZYUZM2YgNzcXEydOhLW1NapUqaKSVHp7e8PJyQnbt28vdh/JpdXEQgiB0aNHY/v27Th06BDc3NxeuczFixcBFP0AD0NDQ1hYWCi9iIiIiAjQ0dHBkiVLcOXKFaxbtw6HDh3CpEmTil3m9u3b+P3337Ft2zZcvHgRZmZmMDMzw44dO5San6szffp0fPTRR7h06RI6d+6MAQMG4MmTJwBeNIOvUqUKtmzZgqtXr2LKlCn46quvsHnzZqU6Dh48iBs3bmD//v34888/kZOTg4CAAJibmyMyMhLHjh2DmZkZOnbsiOzsbLVxPHnyBFevXkWjRo2KjTc6OhrHjx9XuiuSmZmJhg0bYteuXYiOjsawYcMwcOBAnD59WmnZdevWwdTUFKdOncK8efMwY8YMKXnIz89Hz549YWBggFOnTmHlypX44osvlJZPS0tDQEAAKlWqhDNnzmDLli04cOAARo8erVTu0KFDePjwIf7++2+EhYVh6tSp6Nq1KypVqoRTp05hxIgRGD58uEqfiiZNmiAyMrLY7ZdLq4lFaGgofvnlF/z2228wNzdHQkICEhISkJGRAQCIiYnBzJkzce7cOdy5cwc7d+7EoEGD0KpVK9SpU0eboRMRERGVW3/++aeUAJiZmaF3794AgLFjx8LPzw9Vq1ZF27ZtMWvWLJUv8oVlZ2dj/fr1qF+/PurUqQM9PT2sXbsW69atg5WVFZo3b46vvvoKly5dUlk2ODgY/fr1g6enJ+bMmYPU1FTpC7m+vj6mT5+ORo0awc3NDQMGDMDgwYNV4jE1NcXq1avh7e0Nb29vbNq0Cfn5+Vi9ejVq166NmjVrIjw8HHFxcTh8+LDabYiLi4MQAk5OTkXuKyMjI9SuXRuJiYmYOHGiNP+9997DhAkTUK9ePbi7u2PMmDHo2LGjSpx16tTB1KlTUa1aNQwaNAiNGjXCwYMHAQAHDhzA9evXsX79etStWxetWrXCnDlzlJb/7bffkJmZifXr18PHxwdt27bFjz/+iA0bNuDRo0dSOWtrayxZsgReXl745JNP4OXlhfT0dHz11VeoVq0aJk+eDAMDA5XuBU5OTrh7967a/aMpWu1jsWLFCgAvbh+9LDw8HMHBwTAwMMCBAwewaNEipKWlwdnZGb169cI333yjhWiJiIiIKgY/Pz/pexbw4ss58OIL7ty5c3H9+nU8e/YMubm5yMzMRHp6epEPA3R1dVXpn9GrVy906dIFkZGROHnyJPbs2YN58+Zh9erVCA4Olsq9/EOwqakpLCwskJiYKE1btmwZ1qxZg7i4OGRkZCA7Oxv16tVTWlft2rWV7iBERUXh9u3bMDc3VyqXmZmJmJgYtdtQ8KO1ug7ZBfsqLS0NCxcuhJ6eHnr16iXNz8vLw5w5c7B582Y8ePAA2dnZyMrKUtlfhX/0dnR0lLb12rVrcHZ2VkpsfH19lcpfu3YNdevWlY4VADRv3hz5+fm4ceMG7O3tAbxo1qSj83/3Buzt7ZUGPtLV1UXlypWV9jPwov9MWY+sqtXEQghR7HxnZ2ccOXLkDUVDRERE9HYwNTVVGQHqzp076Nq1K0aOHInZs2fD2toaR48eRUhICLKzs4tMLF7+ovsyIyMjtG/fHu3bt8e3336LIUOGYOrUqUqJhb6+vtIyCoUC+fn5AF70eZgwYQIWLFgAX19fmJubY/78+Th16lSx609NTUXDhg3x66+/qsRUVAd1GxsbAMDTp09Vyry8r9asWYO6devi559/RkhICABg/vz5WLx4MRYtWiT1Txk7dqxKs6vitlWT1K2nJOt+8uRJiTrwy1EuOm8TERERUdk6d+4c8vPzsWDBArz//vuoXr06Hj58qLH6a9WqhbS0tBKXP3bsGJo1a4ZRo0ahfv368PT0LPKOw8saNGiAW7duwc7ODp6enkovS0tLtct4eHjAwsICV69eLbZuHR0dfPXVV/jmm2+kuxzHjh1D9+7d8fHHH6Nu3bpwd3fHzZuvN+RwzZo1ce/ePcTHx0vTTp48qVImKipKaR8eO3YMOjo6Uqd1OaKjo1G/fn3Z9RSHiQURERHRO8DT0xM5OTlYunQp/vnnH2zYsAErV6587XqSkpLQtm1b/PLLL7h06RJiY2OxZcsWzJs3D927dy9xPdWqVcPZs2exb98+3Lx5E99++y3OnDnzyuUGDBgAGxsbdO/eHZGRkYiNjcXhw4fx6aefFvkQOB0dHfj7+6v0O1Cnd+/e0NXVxbJly6Q49+/fj+PHj+PatWsYPny4Up+HkvD390f16tURFBSEqKgoREZG4uuvv1bZLiMjIwQFBSE6OhoREREYM2YMBg4cKDWDKq309HScO3cOHTp0kFXPqzCxICIiInoH1K1bF2FhYfj+++/h4+ODX3/9FXPnvv5zhMzMzNC0aVMsXLgQrVq1go+PD7799lsMHToUP/74Y4nrGT58OHr27Ik+ffqgadOmSEpKwqhRo165nImJCf7++2+4uLigZ8+eqFmzJkJCQpCZmVnsaKBDhgzBxo0bX9k8SU9PD6NHj8a8efOQlpaGb775Bg0aNEBAQADatGkDBwcHBAYGlng7gReJzfbt25GRkYEmTZpgyJAhmD17tsp27du3D0+ePEHjxo3x4Ycfol27dq+1T4vyxx9/wMXFBS1btpRdV3EU4lUdHSq4Z8+ewdLSEikpKRx6lqi84gPyiKicyczMRGxsrPTsBqr4hBBo2rQpPv/8c/Tr10/b4bxR77//Pj799FP0799f7fzizvfX+S7NOxZERERE9NZTKBT46aefkJubq+1Q3qh///0XPXv2fCPJlFZHhSIiIiIielPq1aunMpzt287GxuaVD0HUFN6xICIiIiIi2ZhYEBERERGRbEwsiIiIiIhINiYWREREREQkGxMLIiIiIiKSjYkFERERERHJxsSCiIiIiIhkY2JBRERERGVu2rRp79wzJN41fEAeERER0euImPvm1uU3+bWKr1y5EhMnTsTTp0+hp/fia15qaioqVaqE5s2b4/Dhw1LZw4cPw8/PD7dv34aHh4cmo6Z3FO9YEBEREb0l/Pz8kJqairNnz0rTIiMj4eDggFOnTiEzM1OaHhERARcXFyYVpDFMLIiIiIjeEl5eXnB0dFS5M9G9e3e4ubnh5MmTStP9/PywYcMGNGrUCObm5nBwcED//v2RmJioVO/OnTtRrVo1GBkZwc/PD+vWrYNCoUBycrJU5j//+Q+cnZ1hYmKCHj16ICwsDFZWVsXGu3r1atSsWRNGRkaoUaMGli9frondQFrCxIKIiIjoLeLn54eIiAjpfUREBNq0aYPWrVtL0zMyMnDq1Cn4+fkhJycHM2fORFRUFHbs2IE7d+4gODhYWj42NhYffvghAgMDERUVheHDh+Prr79WWuexY8cwYsQIfPbZZ7h48SLat2+P2bNnFxvnr7/+iilTpmD27Nm4du0a5syZg2+//Rbr1q3T3M6gN4p9LIiIiIjeIn5+fhg7dixyc3ORkZGBCxcuoHXr1sjJycHKlSsBACdOnEBWVhb8/Pzg4uIiLevu7o4lS5agcePGSE1NhZmZGVatWgUvLy/Mnz8fwIu7ItHR0UqJw9KlS9GpUydMmDABAFC9enUcP34cf/75Z5FxTp06FQsWLEDPnj0BAG5ubrh69SpWrVqFoKAgje8XKnu8Y0FERET0FmnTpg3S0tJw5swZREZGonr16rC1tUXr1q2lfhaHDx+Gu7s7XFxccO7cOXTr1g0uLi4wNzdH69atAQBxcXEAgBs3bqBx48ZK62jSpInS+xs3bqhMK/z+ZWlpaYiJiUFISAjMzMyk16xZsxATE6OJ3UBawDsWRERERG8RT09PVKlSBREREXj69KmUKDg5OcHZ2RnHjx9HREQE2rZti7S0NAQEBCAgIAC//vorbG1tERcXh4CAAGRnZ5dZjKmpqQBe9Mto2rSp0jxdXd0yWy+VLSYWRERERG8ZPz8/HD58GE+fPsXEiROl6a1atcKePXtw+vRpjBw5EtevX0dSUhK+++47ODs7A4DSiFLAi6ZPu3fvVpp25swZlTKFpxV+/zJ7e3s4OTnhn3/+wYABA0q1jVT+MLEgIiIiesv4+fkhNDQUOTk50h0LAGjdujVGjx6N7Oxs+Pn5QU9PDwYGBli6dClGjBiB6OhozJw5U6mu4cOHIywsDF988QVCQkJw8eJFrF27FgCgUCgAAGPGjEGrVq0QFhaGbt264dChQ9izZ480X53p06fj008/haWlJTp27IisrCycPXsWT58+xbhx4zS/U6jMsY8FERER0VvGz88PGRkZ8PT0hL29vTS9devWeP78uTQsra2tLdauXYstW7agVq1a+O677/DDDz8o1eXm5oatW7di27ZtqFOnDlasWCGNCmVoaAgAaN68OVauXImwsDDUrVsXe/fuxeeffw4jI6MiYxwyZAhWr16N8PBw1K5dG61bt8batWvh5uZWBnuE3gSFEEJoO4iy9OzZM1haWiIlJQUWFhbaDoeI1NH0U2xf80m1RESFZWZmIjY2Fm5ubsV+OX5XzZ49GytXrsS9e/eKLDN06FBcv34dkZGRbzAyKo3izvfX+S7NplBEREREVKzly5ejcePGqFy5Mo4dO4b58+dj9OjRSmV++OEHtG/fHqamptizZw/WrVvHB969Y5hYEBEREVGxbt26hVmzZuHJkydwcXHB+PHjMXmy8t3h06dPY968eXj+/Ln0PIwhQ4ZoKWLSBiYWRERERFSshQsXYuHChcWW2bx58xuKhsordt4mIiIiIiLZmFgQEREREZFsTCyIiIiIipCfn6/tEIjKnKbOc/axICIiIirEwMAAOjo6ePjwIWxtbWFgYFDsw96IKiIhBLKzs/H48WPo6OjAwMBAVn1MLIiIiIgK0dHRgZubG+Lj4/Hw4UNth0NUpkxMTODi4gIdHXmNmZhYEBEREalhYGAAFxcX5ObmIi8vT9vhEJUJXV1d6OnpaeSOHBMLIiIioiIoFAro6+tDX19f26EQlXvsvE1ERERERLIxsSAiIiIiItmYWBARERERkWxMLIiIiIiISDYmFkREREREJBsTCyIiIiIiko2JBRERERERycbEgoiIiIiIZGNiQUREREREsjGxICIiIiIi2ZhYEBERERGRbEwsiIiIiIhINq0mFnPnzkXjxo1hbm4OOzs7BAYG4saNG0plMjMzERoaisqVK8PMzAy9evXCo0ePtBQxERERERGpo9XE4siRIwgNDcXJkyexf/9+5OTkoEOHDkhLS5PKfP755/jf//6HLVu24MiRI3j48CF69uypxaiJiIiIiKgwhRBCaDuIAo8fP4adnR2OHDmCVq1aISUlBba2tvjtt9/w4YcfAgCuX7+OmjVr4sSJE3j//fdfWeezZ89gaWmJlJQUWFhYlPUmEFFpRMzVbH1+kzVbHxER0Tvqdb5Ll6s+FikpKQAAa2trAMC5c+eQk5MDf39/qUyNGjXg4uKCEydOaCVGIiIiIiJSpaftAArk5+dj7NixaN68OXx8fAAACQkJMDAwgJWVlVJZe3t7JCQkqK0nKysLWVlZ0vtnz56VWcxERERERPRCuUksQkNDER0djaNHj8qqZ+7cuZg+fbqGoiIiIiIijWLz17dWuWgKNXr0aPz555+IiIhAlSpVpOkODg7Izs5GcnKyUvlHjx7BwcFBbV2TJ09GSkqK9Lp3715Zhk5ERERERNByYiGEwOjRo7F9+3YcOnQIbm5uSvMbNmwIfX19HDx4UJp248YNxMXFwdfXV22dhoaGsLCwUHoREREREVHZ0mpTqNDQUPz222/4448/YG5uLvWbsLS0hLGxMSwtLRESEoJx48bB2toaFhYWGDNmDHx9fUs0IhQREREREb0ZWk0sVqxYAQBo06aN0vTw8HAEBwcDABYuXAgdHR306tULWVlZCAgIwPLly99wpEREREREVBytJhYleYSGkZERli1bhmXLlr2BiIiIiIiIqDTKRedtIiIiIiKq2JhYEBERERGRbEwsiIiIiIhINiYWREREREQkGxMLIiIiIiKSjYkFERERERHJxsSCiIiIiIhkY2JBRERERESyMbEgIiIiIiLZmFgQEREREZFsTCyIiIiIiEg2JhZERERERCQbEwsiIiIiIpKNiQUREREREcnGxIKIiIiIiGRjYkFERERERLIxsSAiIiIiItmYWBARERERkWxMLIiIiIiISDYmFkREREREJBsTCyIiIiIiko2JBRERERERycbEgoiIiIiIZGNiQUREREREsjGxICIiIiIi2ZhYEBERERGRbEwsiIiIiIhINiYWREREREQkGxMLIiIiIiKSjYkFERERERHJxsSCiIiIiIhkY2JBRERERESyMbEgIiIiIiLZmFgQEREREZFsTCyIiIiIiEg2JhZERERERCQbEwsiIiIiIpKNiQUREREREcnGxIKIiIiIiGRjYkFERERERLKVKrH4559/NB0HERERERFVYKVKLDw9PeHn54dffvkFmZmZmo6JiIiIiIgqmFIlFufPn0edOnUwbtw4ODg4YPjw4Th9+rSmYyMiIiIiogqiVIlFvXr1sHjxYjx8+BBr1qxBfHw8WrRoAR8fH4SFheHx48eajpOIiIiIiMoxWZ239fT00LNnT2zZsgXff/89bt++jQkTJsDZ2RmDBg1CfHy8puIkIiIiIqJyTFZicfbsWYwaNQqOjo4ICwvDhAkTEBMTg/379+Phw4fo3r27puIkIiIiIqJyTK80C4WFhSE8PBw3btxA586dsX79enTu3Bk6Oi/yFDc3N6xduxZVq1bVZKxERERERFROleqOxYoVK9C/f3/cvXsXO3bsQNeuXaWkooCdnR1+/vnnYuv5+++/0a1bNzg5OUGhUGDHjh1K84ODg6FQKJReHTt2LE3IRERERERUhkp1x+LWrVuvLGNgYICgoKBiy6SlpaFu3br45JNP0LNnT7VlOnbsiPDwcOm9oaHh6wVLRERERERlrlSJRXh4OMzMzNC7d2+l6Vu2bEF6evorE4oCnTp1QqdOnYotY2hoCAcHh9KESUREREREb0ipmkLNnTsXNjY2KtPt7OwwZ84c2UG97PDhw7Czs4OXlxdGjhyJpKQkjdZPRERERETyleqORVxcHNzc3FSmu7q6Ii4uTnZQBTp27IiePXvCzc0NMTEx+Oqrr9CpUyecOHECurq6apfJyspCVlaW9P7Zs2cai4eIiIiIiNQrVWJhZ2eHS5cuqYz6FBUVhcqVK2siLgBA3759pf/Xrl0bderUgYeHBw4fPox27dqpXWbu3LmYPn26xmIgIiIiIqJXK1VTqH79+uHTTz9FREQE8vLykJeXh0OHDuGzzz5TSgY0zd3dHTY2Nrh9+3aRZSZPnoyUlBTpde/evTKLh4iIiIiIXijVHYuZM2fizp07aNeuHfT0XlSRn5+PQYMGabyPxcvu37+PpKQkODo6FlnG0NCQI0cREREREb1hpUosDAwMsGnTJsycORNRUVEwNjZG7dq14erq+lr1pKamKt19iI2NxcWLF2FtbQ1ra2tMnz4dvXr1goODA2JiYjBp0iR4enoiICCgNGETEREREVEZKVViUaB69eqoXr16qZc/e/Ys/Pz8pPfjxo0DAAQFBWHFihW4dOkS1q1bh+TkZDg5OaFDhw6YOXMm70gQEREREZUzpUos8vLysHbtWhw8eBCJiYnIz89Xmn/o0KES1dOmTRsIIYqcv2/fvtKER0REREREb1ipEovPPvsMa9euRZcuXeDj4wOFQqHpuIiIiIiIqAIpVWKxceNGbN68GZ07d9Z0PEREREREVAGVarhZAwMDeHp6ajoWIiIiIiKqoEqVWIwfPx6LFy8utn8EERERERG9O0rVFOro0aOIiIjAnj174O3tDX19faX527Zt00hwRERERERUMZQqsbCyskKPHj00HQsREREREVVQpUoswsPDNR0HERERERFVYKXqYwEAubm5OHDgAFatWoXnz58DAB4+fIjU1FSNBUdERERERBVDqe5Y3L17Fx07dkRcXByysrLQvn17mJub4/vvv0dWVhZWrlyp6TiJiIiIiKgcK9Udi88++wyNGjXC06dPYWxsLE3v0aMHDh48qLHgiIiIiIioYijVHYvIyEgcP34cBgYGStOrVq2KBw8eaCQwIiIiIiKqOEp1xyI/Px95eXkq0+/fvw9zc3PZQRERERERUcVSqsSiQ4cOWLRokfReoVAgNTUVU6dORefOnTUVGxERERERVRClagq1YMECBAQEoFatWsjMzET//v1x69Yt2NjY4L///a+mYyQiIiIionKuVIlFlSpVEBUVhY0bN+LSpUtITU1FSEgIBgwYoNSZm4iIiIiI3g2lSiwAQE9PDx9//LEmYyEiIiIiogqqVInF+vXri50/aNCgUgVDREREREQVU6kSi88++0zpfU5ODtLT02FgYAATExMmFkRERERE75hSjQr19OlTpVdqaipu3LiBFi1asPM2EREREdE7qFSJhTrVqlXDd999p3I3g4iIiIiI3n4aSyyAFx26Hz58qMkqiYiIiIioAihVH4udO3cqvRdCID4+Hj/++COaN2+ukcCIiIiIiKjiKFViERgYqPReoVDA1tYWbdu2xYIFCzQRFxERERERVSClSizy8/M1HQcREREREVVgGu1jQURERERE76ZS3bEYN25cicuGhYWVZhVERERERFSBlCqxuHDhAi5cuICcnBx4eXkBAG7evAldXV00aNBAKqdQKDQTJRERERERlWulSiy6desGc3NzrFu3DpUqVQLw4qF5gwcPRsuWLTF+/HiNBklEREREROVbqfpYLFiwAHPnzpWSCgCoVKkSZs2axVGhiIiIiIjeQaVKLJ49e4bHjx+rTH/8+DGeP38uOygiIiIiIqpYSpVY9OjRA4MHD8a2bdtw//593L9/H7///jtCQkLQs2dPTcdIRERERETlXKn6WKxcuRITJkxA//79kZOT86IiPT2EhIRg/vz5Gg2QiIiIiIjKv1IlFiYmJli+fDnmz5+PmJgYAICHhwdMTU01GhwREREREVUMsh6QFx8fj/j4eFSrVg2mpqYQQmgqLiIiIiIiqkBKlVgkJSWhXbt2qF69Ojp37oz4+HgAQEhICIeaJSIiIiJ6B5Uqsfj888+hr6+PuLg4mJiYSNP79OmDvXv3aiw4IiIiIiKqGErVx+Kvv/7Cvn37UKVKFaXp1apVw927dzUSGBERERERVRylumORlpamdKeiwJMnT2BoaCg7KCIiIiIiqlhKlVi0bNkS69evl94rFArk5+dj3rx58PPz01hwRERERERUMZSqKdS8efPQrl07nD17FtnZ2Zg0aRKuXLmCJ0+e4NixY5qOkYiIiIiIyrlSJRY+Pj64efMmfvzxR5ibmyM1NRU9e/ZEaGgoHB0dNR0jERHRW2/h/pvaDgGft6+u7RCIqAJ77cQiJycHHTt2xMqVK/H111+XRUxERERERFTBvHYfC319fVy6dKksYiEiIiIiogqqVJ23P/74Y/z888+ajoWIiIiIiCqoUvWxyM3NxZo1a3DgwAE0bNgQpqamSvPDwsI0EhwREREREVUMr5VY/PPPP6hatSqio6PRoEEDAMDNm8qdzRQKheaiIyIiIiKiCuG1Eotq1aohPj4eERERAIA+ffpgyZIlsLe3L5PgiIiIiIioYnitPhZCCKX3e/bsQVpaWqlX/vfff6Nbt25wcnKCQqHAjh07VNY3ZcoUODo6wtjYGP7+/rh161ap10dERERERGWjVJ23CxRONF5XWloa6tati2XLlqmdP2/ePCxZsgQrV67EqVOnYGpqioCAAGRmZspaLxERERERadZrNYVSKBQqfSjk9Kno1KkTOnXqpHaeEAKLFi3CN998g+7duwMA1q9fD3t7e+zYsQN9+/Yt9XqJiIiIiEizXiuxEEIgODgYhoaGAIDMzEyMGDFCZVSobdu2yQ4sNjYWCQkJ8Pf3l6ZZWlqiadOmOHHiBBMLIiIiIqJy5LUSi6CgIKX3H3/8sUaDeVlCQgIAqHQMt7e3l+apk5WVhaysLOn9s2fPyiZAIiIiIiKSvFZiER4eXlZxaMzcuXMxffp0bYdBREQVyML9N19diIiIiiWr83ZZcnBwAAA8evRIafqjR4+keepMnjwZKSkp0uvevXtlGicREREREZXjxMLNzQ0ODg44ePCgNO3Zs2c4deoUfH19i1zO0NAQFhYWSi8iIiIiIipbr9UUStNSU1Nx+/Zt6X1sbCwuXrwIa2truLi4YOzYsZg1axaqVasGNzc3fPvtt3ByckJgYKD2giYiIiIiIhVaTSzOnj0LPz8/6f24ceMAvOgkvnbtWkyaNAlpaWkYNmwYkpOT0aJFC+zduxdGRkbaCpmIiIiIiNTQamLRpk2bYh+yp1AoMGPGDMyYMeMNRkVERERERK+r3PaxICIiIiKiioOJBRERERERycbEgoiIiIiIZGNiQUREREREsjGxICIiIiIi2bQ6KhQRERERUXm1cP9NbYeAz9tX13YIJcY7FkREREREJBsTCyIiIiIiko2JBRERERERycbEgoiIiIiIZGNiQUREREREsjGxICIiIiIi2ZhYEBERERGRbEwsiIiIiIhINiYWREREREQkGxMLIiIiIiKSjYkFERERERHJxsSCiIiIiIhkY2JBRERERESyMbEgIiIiIiLZmFgQEREREZFsTCyIiIiIiEg2JhZERERERCQbEwsiIiIiIpKNiQUREREREcnGxIKIiIiIiGRjYkFERERERLIxsSAiIiIiItmYWBARERERkWx62g6AiIiIiMqfhftvlkm978cllaicr3vlMlk/lR3esSAiIiIiItmYWBARERERkWxMLIiIiIiISDYmFkREREREJBsTCyIiIiIiko2JBRERERERycbEgoiIiIiIZGNiQUREREREsjGxICIiIiIi2ZhYEBERERGRbHraDoCIiIiIqLAT/ySVqNzJ3JtlHAmVFO9YEBERERGRbEwsiIiIiIhINiYWREREREQkGxMLIiIiIiKSjYkFERERERHJxsSCiIiIiIhkK9eJxbRp06BQKJReNWrU0HZYRERERERUSLl/joW3tzcOHDggvdfTK/chExERERG9c8r9t3Q9PT04ODhoOwwiIiIiIipGuW4KBQC3bt2Ck5MT3N3dMWDAAMTFxWk7JCIiIiIiKqRc37Fo2rQp1q5dCy8vL8THx2P69Olo2bIloqOjYW5urnaZrKwsZGVlSe+fPXv2psIlIiIiInpnlevEolOnTtL/69Spg6ZNm8LV1RWbN29GSEiI2mXmzp2L6dOnv6kQiYiI6F0TMVez9flN1mx9RFpS7ptCvczKygrVq1fH7du3iywzefJkpKSkSK979+69wQiJiIiIiN5NFSqxSE1NRUxMDBwdHYssY2hoCAsLC6UXERERERGVrXKdWEyYMAFHjhzBnTt3cPz4cfTo0QO6urro16+ftkMjIiIiIqKXlOs+Fvfv30e/fv2QlJQEW1tbtGjRAidPnoStra22QyMiIiIiopeU68Ri48aN2g6BiIiIiIhKoFw3hSIiIiIiooqBiQUREREREcnGxIKIiIiIiGRjYkFERERERLIxsSAiIiIiItmYWBARERERkWxMLIiIiIiISDYmFkREREREJBsTCyIiIiIiko2JBRERERERycbEgoiIiIiIZGNiQUREREREsjGxICIiIiIi2ZhYEBERERGRbEwsiIiIiIhINiYWREREREQkGxMLIiIiIiKSTU/bARAREVH5sHD/TW2HgM/bV9d2COVCeTgWRK+LdyyIiIiIiEg2JhZERERERCQbEwsiIiIiIpKNiQUREREREcnGxIKIiIiIiGRjYkFERERERLIxsSAiIiIiItmYWBARERERkWxMLIiIiIiISDYmFkREREREJBsTCyIiIiIiko2JBRERERERycbEgoiIiIiIZGNiQUREREREsjGxICIiIiIi2ZhYEBERERGRbEwsiIiIiIhINiYWREREREQkGxMLIiIiIiKSjYkFERERERHJxsSCiIiIiIhkY2JBRERERESy6Wk7gHfFwv03tR0CPm9fXdshEBEREdFbincsiIiIiIhINiYWREREREQkGxMLIiIiIiKSjYkFERERERHJxsSCiIiIiIhkY2JBRERERESyVYjEYtmyZahatSqMjIzQtGlTnD59WtshERERERHRS8p9YrFp0yaMGzcOU6dOxfnz51G3bl0EBAQgMTFR26EREREREdH/V+4Ti7CwMAwdOhSDBw9GrVq1sHLlSpiYmGDNmjXaDo2IiIiIiP6/cp1YZGdn49y5c/D395em6ejowN/fHydOnNBiZERERERE9DI9bQdQnH///Rd5eXmwt7dXmm5vb4/r16+rXSYrKwtZWVnS+5SUFADAs2fPyi7QEshMS9Xq+gHt7wOiIqVlarY+nuv0msrDZzS9UCH+Vr2Bz6y3+ZxMy8h6daHX8DbvK0D710TB+oUQryxbrhOL0pg7dy6mT5+uMt3Z2VkL0ZQvX2k7AKI3Zoa2AyCiUno3/1bxM0ueH7UdQJkqL9fE8+fPYWlpWWyZcp1Y2NjYQFdXF48ePVKa/ujRIzg4OKhdZvLkyRg3bpz0Pj8/H0+ePEHlypWhUCjKNN6iPHv2DM7Ozrh37x4sLCy0EgP9Hx6P8oXHo3zh8ShfeDzKHx6T8oXHo+wJIfD8+XM4OTm9smy5TiwMDAzQsGFDHDx4EIGBgQBeJAoHDx7E6NGj1S5jaGgIQ0NDpWlWVlZlHGnJWFhY8KQvR3g8yhcej/KFx6N84fEof3hMyhcej7L1qjsVBcp1YgEA48aNQ1BQEBo1aoQmTZpg0aJFSEtLw+DBg7UdGhERERER/X/lPrHo06cPHj9+jClTpiAhIQH16tXD3r17VTp0ExERERGR9pT7xAIARo8eXWTTp4rA0NAQU6dOVWmiRdrB41G+8HiULzwe5QuPR/nDY1K+8HiULwpRkrGjiIiIiIiIilGuH5BHREREREQVAxMLIiIiIiKSjYkFERERERHJxsSijC1btgxVq1aFkZERmjZtitOnT2s7pLfStGnToFAolF41atSQ5mdmZiI0NBSVK1eGmZkZevXqpfLgxbi4OHTp0gUmJiaws7PDxIkTkZub+6Y3pUL6+++/0a1bNzg5OUGhUGDHjh1K84UQmDJlChwdHWFsbAx/f3/cunVLqcyTJ08wYMAAWFhYwMrKCiEhIUhNTVUqc+nSJbRs2RJGRkZwdnbGvHnzynrTKqRXHY/g4GCV66Vjx45KZXg8NGfu3Llo3LgxzM3NYWdnh8DAQNy4cUOpjKY+ow4fPowGDRrA0NAQnp6eWLt2bVlvXoVTkuPRpk0blWtkxIgRSmV4PDRjxYoVqFOnjvQcCl9fX+zZs0eaz2ujghFUZjZu3CgMDAzEmjVrxJUrV8TQoUOFlZWVePTokbZDe+tMnTpVeHt7i/j4eOn1+PFjaf6IESOEs7OzOHjwoDh79qx4//33RbNmzaT5ubm5wsfHR/j7+4sLFy6I3bt3CxsbGzF58mRtbE6Fs3v3bvH111+Lbdu2CQBi+/btSvO/++47YWlpKXbs2CGioqLEBx98INzc3ERGRoZUpmPHjqJu3bri5MmTIjIyUnh6eop+/fpJ81NSUoS9vb0YMGCAiI6OFv/973+FsbGxWLVq1ZvazArjVccjKChIdOzYUel6efLkiVIZHg/NCQgIEOHh4SI6OlpcvHhRdO7cWbi4uIjU1FSpjCY+o/755x9hYmIixo0bJ65evSqWLl0qdHV1xd69e9/o9pZ3JTkerVu3FkOHDlW6RlJSUqT5PB6as3PnTrFr1y5x8+ZNcePGDfHVV18JfX19ER0dLYTgtVHRMLEoQ02aNBGhoaHS+7y8POHk5CTmzp2rxajeTlOnThV169ZVOy85OVno6+uLLVu2SNOuXbsmAIgTJ04IIV58EdPR0REJCQlSmRUrVggLCwuRlZVVprG/bQp/kc3PzxcODg5i/vz50rTk5GRhaGgo/vvf/wohhLh69aoAIM6cOSOV2bNnj1AoFOLBgwdCCCGWL18uKlWqpHQ8vvjiC+Hl5VXGW1SxFZVYdO/evchleDzKVmJiogAgjhw5IoTQ3GfUpEmThLe3t9K6+vTpIwICAsp6kyq0wsdDiBeJxWeffVbkMjweZatSpUpi9erVvDYqIDaFKiPZ2dk4d+4c/P39pWk6Ojrw9/fHiRMntBjZ2+vWrVtwcnKCu7s7BgwYgLi4OADAuXPnkJOTo3QsatSoARcXF+lYnDhxArVr11Z68GJAQACePXuGK1euvNkNecvExsYiISFBaf9bWlqiadOmSvvfysoKjRo1ksr4+/tDR0cHp06dksq0atUKBgYGUpmAgADcuHEDT58+fUNb8/Y4fPgw7Ozs4OXlhZEjRyIpKUmax+NRtlJSUgAA1tbWADT3GXXixAmlOgrK8G9O8QofjwK//vorbGxs4OPjg8mTJyM9PV2ax+NRNvLy8rBx40akpaXB19eX10YFVCEekFcR/fvvv8jLy1N5Qri9vT2uX7+upajeXk2bNsXatWvh5eWF+Ph4TJ8+HS1btkR0dDQSEhJgYGAAKysrpWXs7e2RkJAAAEhISFB7rArmUekV7D91+/fl/W9nZ6c0X09PD9bW1kpl3NzcVOoomFepUqUyif9t1LFjR/Ts2RNubm6IiYnBV199hU6dOuHEiRPQ1dXl8ShD+fn5GDt2LJo3bw4fHx8A0NhnVFFlnj17hoyMDBgbG5fFJlVo6o4HAPTv3x+urq5wcnLCpUuX8MUXX+DGjRvYtm0bAB4PTbt8+TJ8fX2RmZkJMzMzbN++HbVq1cLFixd5bVQwTCzordCpUyfp/3Xq1EHTpk3h6uqKzZs38wODqJC+fftK/69duzbq1KkDDw8PHD58GO3atdNiZG+/0NBQREdH4+jRo9oOhVD08Rg2bJj0/9q1a8PR0RHt2rVDTEwMPDw83nSYbz0vLy9cvHgRKSkp2Lp1K4KCgnDkyBFth0WlwKZQZcTGxga6uroqIxc8evQIDg4OWorq3WFlZYXq1avj9u3bcHBwQHZ2NpKTk5XKvHwsHBwc1B6rgnlUegX7r7hrwcHBAYmJiUrzc3Nz8eTJEx6jN8Dd3R02Nja4ffs2AB6PsjJ69Gj8+eefiIiIQJUqVaTpmvqMKqqMhYUFf2BRo6jjoU7Tpk0BQOka4fHQHAMDA3h6eqJhw4aYO3cu6tati8WLF/PaqICYWJQRAwMDNGzYEAcPHpSm5efn4+DBg/D19dViZO+G1NRUxMTEwNHREQ0bNoS+vr7Ssbhx4wbi4uKkY+Hr64vLly8rfZnav38/LCwsUKtWrTce/9vEzc0NDg4OSvv/2bNnOHXqlNL+T05Oxrlz56Qyhw4dQn5+vvQH3dfXF3///TdycnKkMvv374eXlxeb3ch0//59JCUlwdHREQCPh6YJITB69Ghs374dhw4dUmlCpqnPKF9fX6U6Csrwb46yVx0PdS5evAgAStcIj0fZyc/PR1ZWFq+NikjbvcffZhs3bhSGhoZi7dq14urVq2LYsGHCyspKaeQC0ozx48eLw4cPi9jYWHHs2DHh7+8vbGxsRGJiohDixXB1Li4u4tChQ+Ls2bPC19dX+Pr6SssXDFfXoUMHcfHiRbF3715ha2vL4WZL6Pnz5+LChQviwoULAoAICwsTFy5cEHfv3hVCvBhu1srKSvzxxx/i0qVLonv37mqHm61fv744deqUOHr0qKhWrZrS8KbJycnC3t5eDBw4UERHR4uNGzcKExMTDm+qRnHH4/nz52LChAnixIkTIjY2Vhw4cEA0aNBAVKtWTWRmZkp18HhozsiRI4WlpaU4fPiw0vCl6enpUhlNfEYVDKk5ceJEce3aNbFs2TIOqanGq47H7du3xYwZM8TZs2dFbGys+OOPP4S7u7to1aqVVAePh+Z8+eWX4siRIyI2NlZcunRJfPnll0KhUIi//vpLCMFro6JhYlHGli5dKlxcXISBgYFo0qSJOHnypLZDeiv16dNHODo6CgMDA/Hee++JPn36iNu3b0vzMzIyxKhRo0SlSpWEiYmJ6NGjh4iPj1eq486dO6JTp07C2NhY2NjYiPHjx4ucnJw3vSkVUkREhACg8goKChJCvBhy9ttvvxX29vbC0NBQtGvXTty4cUOpjqSkJNGvXz9hZmYmLCwsxODBg8Xz58+VykRFRYkWLVoIQ0ND8d5774nvvvvuTW1ihVLc8UhPTxcdOnQQtra2Ql9fX7i6uoqhQ4eq/ODB46E56o4FABEeHi6V0dRnVEREhKhXr54wMDAQ7u7uSuugF151POLi4kSrVq2EtbW1MDQ0FJ6enmLixIlKz7EQgsdDUz755BPh6uoqDAwMhK2trWjXrp2UVAjBa6OiUQghxJu7P0JERERERG8j9rEgIiIiIiLZmFgQEREREZFsTCyIiIiIiEg2JhZERERERCQbEwsiIiIiIpKNiQUREREREcnGxIKIiIiIiGRjYkFERERERLIxsSAiIll+/vlndOjQQVYdd+7cgUKhwMWLFwEAhw8fhkKhQHJyMgBg7dq1sLKykspPmzYN9erVk7VOTVi5ciW6deum7TCIiMoFJhZERBVYQkICxowZA3d3dxgaGsLZ2RndunXDwYMHpTJVq1aFQqGAQqGAqakpGjRogC1btkjzg4ODERgYqFJ34S/36mRmZuLbb7/F1KlTZW2Hs7Mz4uPj4ePjU6LyEyZMUNpGbfnkk09w/vx5REZGajsUIiKtY2JBRFRB3blzBw0bNsShQ4cwf/58XL58GXv37oWfnx9CQ0OVys6YMQPx8fG4cOECGjdujD59+uD48eOyY9i6dSssLCzQvHlzWfXo6urCwcEBenp6JSpvZmaGypUry1pncbKzs0tUzsDAAP3798eSJUvKLBYiooqCiQURUQU1atQoKBQKnD59Gr169UL16tXh7e2NcePG4eTJk0plzc3N4eDggOrVq2PZsmUwNjbG//73P9kxbNy4UaUpUMEdkDlz5sDe3h5WVlaYMWMGcnNzMXHiRFhbW6NKlSoIDw+XlincFOpV1DWFWrNmDby9vWFoaAhHR0eMHj1amhcXF4fu3bvDzMwMFhYW+Oijj/Do0SOV+lavXg03NzcYGRkBAJKTkzFkyBDY2trCwsICbdu2RVRUlNJ6u3Xrhp07dyIjI6NEsRMRva2YWBARVUBPnjzB3r17ERoaClNTU5X5L/dHKExPTw/6+vol/lW+OEePHkWjRo1Uph86dAgPHz7E33//jbCwMEydOhVdu3ZFpUqVcOrUKYwYMQLDhw/H/fv3ZccAACtWrEBoaCiGDRuGy5cvY+fOnfD09AQA5Ofno3v37njy5AmOHDmC/fv3459//kGfPn2U6rh9+zZ+//13bNu2TUpwevfujcTEROzZswfnzp1DgwYN0K5dOzx58kRarlGjRsjNzcWpU6c0si1ERBVVye45ExFRuXL79m0IIVCjRo3XWi47OxsLFixASkoK2rZtKyuG5ORkpKSkwMnJSWWetbU1lixZAh0dHXh5eWHevHlIT0/HV199BQCYPHkyvvvuOxw9ehR9+/aVFQcAzJo1C+PHj8dnn30mTWvcuDEA4ODBg7h8+TJiY2Ph7OwMAFi/fj28vb1x5swZqVx2djbWr18PW1tbAC+SptOnTyMxMRGGhoYAgB9++AE7duzA1q1bMWzYMACAiYkJLC0tcffuXdnbQURUkTGxICKqgIQQr1X+iy++wDfffIPMzEyYmZnhu+++Q5cuXWTFUND0p6DZ0Mu8vb2ho/N/N8Xt7e2VOmbr6uqicuXKSExMlBUDACQmJuLhw4do166d2vnXrl2Ds7OzlFQAQK1atWBlZYVr165JiYWrq6uUVABAVFQUUlNTVfpyZGRkICYmRmmasbEx0tPTZW8LEVFFxsSCiKgCqlatGhQKBa5fv16i8hMnTkRwcDDMzMxgb28PhUIhzbOwsFD7a3tycjJ0dXXVNrUCgMqVK0OhUODp06cq8/T19ZXeKxQKtdPy8/NLFH9xjI2NZdcBQGU7U1NT4ejoiMOHD6uULdzU7MmTJ0pJCRHRu4h9LIiIKiBra2sEBARg2bJlSEtLU5lfeIhYGxsbeHp6wsHBQSmpAAAvLy9cuXIFWVlZStPPnz8PNzc3lYSggIGBAWrVqoWrV6/K2xiZzM3NUbVq1SKHn61Zsybu3buHe/fuSdOuXr2K5ORk1KpVq8h6GzRogISEBOjp6cHT01PpZWNjI5WLiYlBZmYm6tevr7mNIiKqgJhYEBFVUMuWLUNeXh6aNGmC33//Hbdu3cK1a9ewZMkS+Pr6lrieAQMGQKFQYNCgQTh37hxu376NNWvWYNGiRRg/fnyxywYEBODo0aNyN0W2adOmYcGCBViyZAlu3bqF8+fPY+nSpQAAf39/1K5dGwMGDMD58+dx+vRpDBo0CK1bt1bb8byAv78/fH19ERgYiL/++gt37tzB8ePH8fXXX+Ps2bNSucjISLi7u8PDw6PMt5OIqDxjYkFEVEG5u7vj/Pnz8PPzw/jx4+Hj44P27dvj4MGDWLFiRYnrsbKyQmRkJHJycvDBBx+gXr16WLJkCcLCwjB8+PBilw0JCcHu3buRkpIid3NkCQoKwqJFi7B8+XJ4e3uja9euuHXrFoAXTa7++OMPVKpUCa1atYK/vz/c3d2xadOmYutUKBTYvXs3WrVqhcGDB6N69ero27cv7t69C3t7e6ncf//7XwwdOrRMt4+IqCJQiNftAUhERPSS3r17o0GDBpg8ebK2Q3njrly5grZt2+LmzZuwtLTUdjhERFrFOxZERCTL/PnzYWZmpu0wtCI+Ph7r169nUkFEBN6xICIiIiIiDeAdCyIiIiIiko2JBRERERERycbEgoiIiIiIZGNiQUREREREsjGxICIiIiIi2ZhYEBERERGRbEwsiIiIiIhINiYWREREREQkGxMLIiIiIiKSjYkFERERERHJ9v8Al8PymhsdzMsAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Explanation: For node node_t002, the randomized FairShareScheduler shows a wider spread in CPU usage due to the added noise, while WaggleScheduler's CPU usage is more consistent. This reflects how randomization can introduce variability in jobload, potentially simulating real-world fluctuations or stress-testing the scheduler's robustness.\n", + "min | 0.00000 | 1000.00000\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Explanation: For node node_t002, the randomized FairShareScheduler shows a wider spread in CPU usage due to the added noise, while WaggleScheduler's CPU usage is more consistent. This reflects how randomization can introduce variability in jobload, potentially simulating real-world fluctuations or stress-testing the scheduler's robustness.\n", + "25% | 1991.18217 | 1000.00000\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Explanation: For node node_t002, the randomized FairShareScheduler shows a wider spread in CPU usage due to the added noise, while WaggleScheduler's CPU usage is more consistent. This reflects how randomization can introduce variability in jobload, potentially simulating real-world fluctuations or stress-testing the scheduler's robustness.\n", + "50% | 2466.44489 | 1750.00000\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Explanation: For node node_t002, the randomized FairShareScheduler shows a wider spread in CPU usage due to the added noise, while WaggleScheduler's CPU usage is more consistent. This reflects how randomization can introduce variability in jobload, potentially simulating real-world fluctuations or stress-testing the scheduler's robustness.\n", + "75% | 3005.47484 | 3000.00000\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Explanation: For node node_t002, the randomized FairShareScheduler shows a wider spread in CPU usage due to the added noise, while WaggleScheduler's CPU usage is more consistent. This reflects how randomization can introduce variability in jobload, potentially simulating real-world fluctuations or stress-testing the scheduler's robustness.\n", + "max | 3281.94591 | 3000.00000\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Explanation: For node node_t002, the randomized FairShareScheduler shows a wider spread in CPU usage due to the added noise, while WaggleScheduler's CPU usage is more consistent. This reflects how randomization can introduce variability in jobload, potentially simulating real-world fluctuations or stress-testing the scheduler's robustness.\n" + ] + } + ], + "source": [ + "print(\"CPU Statistics Comparison with Randomized FairShareScheduler:\\n\")\n", + "for node in sorted(set(df1_random['node_id']).union(df2['node_id'])):\n", + " stats1 = df1_random[df1_random['node_id'] == node]['cpu'].describe()\n", + " stats2 = df2[df2['node_id'] == node]['cpu'].describe()\n", + " print(f\"\\nNode: {node}\")\n", + " print(f\"{'Stat':<8} | {'FairShare (Random)':>18} | {'Waggle':>10}\")\n", + " print(\"-\" * 44)\n", + " for stat in ['mean', 'std', 'min', '25%', '50%', '75%', 'max']:\n", + " val1 = stats1[stat] if stat in stats1 else float('nan')\n", + " val2 = stats2[stat] if stat in stats2 else float('nan')\n", + " print(f\"{stat:<8} | {val1:18.5f} | {val2:10.5f}\")\n", + " # Plot CPU distributions for each node\n", + " plt.figure(figsize=(8, 4))\n", + " plt.hist(df1_random[df1_random['node_id'] == node]['cpu'], bins=20, alpha=0.5, label='FairShare (Random)')\n", + " plt.hist(df2[df2['node_id'] == node]['cpu'], bins=20, alpha=0.5, label='Waggle')\n", + " plt.xlabel(\"CPU (millicore)\")\n", + " plt.ylabel(\"Frequency\")\n", + " plt.title(f\"CPU Distribution for {node}: FairShare (Random) vs Waggle\")\n", + " plt.legend()\n", + " plt.tight_layout()\n", + " plt.show()\n", + " print(f\"Explanation: For node {node}, the randomized FairShareScheduler shows a wider spread in CPU usage due to the added noise, while WaggleScheduler's CPU usage is more consistent. This reflects how randomization can introduce variability in jobload, potentially simulating real-world fluctuations or stress-testing the scheduler's robustness.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "ac5615b7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total CPU usage for first 20 jobloads (FairShareScheduler): 85200.00\n", + "Total CPU usage for first 20 jobloads (WaggleScheduler): 85200.00\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Filter for the first 20 jobloads (steps 0 to 19)\n", + "df1_20 = df1[df1['step'] < 20]\n", + "df2_20 = df2[df2['step'] < 20]\n", + "\n", + "# Calculate total CPU usage for each scheduler\n", + "total_cpu_20_fair = df1_20['cpu'].sum()\n", + "total_cpu_20_waggle = df2_20['cpu'].sum()\n", + "\n", + "print(f\"Total CPU usage for first 20 jobloads (FairShareScheduler): {total_cpu_20_fair:.2f}\")\n", + "print(f\"Total CPU usage for first 20 jobloads (WaggleScheduler): {total_cpu_20_waggle:.2f}\")\n", + "\n", + "# Optional: plot comparison\n", + "plt.bar(['FairShareScheduler', 'WaggleScheduler'], [total_cpu_20_fair, total_cpu_20_waggle], color=['tab:blue', 'tab:orange'])\n", + "plt.ylabel(\"Total CPU Usage (millicore)\")\n", + "plt.title(\"Total CPU Usage: First 20 vs First 10 Jobloads\")\n", + "\n", + "# Also plot for first 10 jobloads for comparison\n", + "df1_10 = df1[df1['step'] < 10]\n", + "df2_10 = df2[df2['step'] < 10]\n", + "total_cpu_10_fair = df1_10['cpu'].sum()\n", + "total_cpu_10_waggle = df2_10['cpu'].sum()\n", + "\n", + "plt.bar(['FairShare (10)', 'Waggle (10)'], [total_cpu_10_fair, total_cpu_10_waggle], color=['tab:blue', 'tab:orange'], alpha=0.5)\n", + "plt.legend(['First 20 Jobloads', 'First 10 Jobloads'])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "03b44fc9", + "metadata": {}, + "outputs": [ + { + "ename": "FileNotFoundError", + "evalue": "[Errno 2] No such file or directory: '../../../EDFScheduler_task_log.csv'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[49], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m filename3 \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m../../../EDFScheduler_task_log.csv\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[0;32m----> 2\u001b[0m df3 \u001b[38;5;241m=\u001b[39m \u001b[43mpreprocess_fair_scheduler_log\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilename3\u001b[49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[0;32mIn[2], line 6\u001b[0m, in \u001b[0;36mpreprocess_fair_scheduler_log\u001b[0;34m(input_csv)\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mpreprocess_fair_scheduler_log\u001b[39m(input_csv):\n\u001b[1;32m 2\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;124;03m Reads FairScheduler_task_log.csv and returns a DataFrame with columns:\u001b[39;00m\n\u001b[1;32m 4\u001b[0m \u001b[38;5;124;03m step, node_id, start_time, end_time, cpu, energy\u001b[39;00m\n\u001b[1;32m 5\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m----> 6\u001b[0m df \u001b[38;5;241m=\u001b[39m \u001b[43mpd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread_csv\u001b[49m\u001b[43m(\u001b[49m\u001b[43minput_csv\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 7\u001b[0m \u001b[38;5;66;03m# Extract node_id from tag (first part before '-')\u001b[39;00m\n\u001b[1;32m 8\u001b[0m df[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mnode_id\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m=\u001b[39m df[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtag\u001b[39m\u001b[38;5;124m'\u001b[39m]\u001b[38;5;241m.\u001b[39mapply(\u001b[38;5;28;01mlambda\u001b[39;00m x: x\u001b[38;5;241m.\u001b[39msplit(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m-\u001b[39m\u001b[38;5;124m'\u001b[39m)[\u001b[38;5;241m0\u001b[39m])\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/pandas/io/parsers/readers.py:1026\u001b[0m, in \u001b[0;36mread_csv\u001b[0;34m(filepath_or_buffer, sep, delimiter, header, names, index_col, usecols, dtype, engine, converters, true_values, false_values, skipinitialspace, skiprows, skipfooter, nrows, na_values, keep_default_na, na_filter, verbose, skip_blank_lines, parse_dates, infer_datetime_format, keep_date_col, date_parser, date_format, dayfirst, cache_dates, iterator, chunksize, compression, thousands, decimal, lineterminator, quotechar, quoting, doublequote, escapechar, comment, encoding, encoding_errors, dialect, on_bad_lines, delim_whitespace, low_memory, memory_map, float_precision, storage_options, dtype_backend)\u001b[0m\n\u001b[1;32m 1013\u001b[0m kwds_defaults \u001b[38;5;241m=\u001b[39m _refine_defaults_read(\n\u001b[1;32m 1014\u001b[0m dialect,\n\u001b[1;32m 1015\u001b[0m delimiter,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1022\u001b[0m dtype_backend\u001b[38;5;241m=\u001b[39mdtype_backend,\n\u001b[1;32m 1023\u001b[0m )\n\u001b[1;32m 1024\u001b[0m kwds\u001b[38;5;241m.\u001b[39mupdate(kwds_defaults)\n\u001b[0;32m-> 1026\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_read\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilepath_or_buffer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/pandas/io/parsers/readers.py:620\u001b[0m, in \u001b[0;36m_read\u001b[0;34m(filepath_or_buffer, kwds)\u001b[0m\n\u001b[1;32m 617\u001b[0m _validate_names(kwds\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnames\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m))\n\u001b[1;32m 619\u001b[0m \u001b[38;5;66;03m# Create the parser.\u001b[39;00m\n\u001b[0;32m--> 620\u001b[0m parser \u001b[38;5;241m=\u001b[39m \u001b[43mTextFileReader\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilepath_or_buffer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 622\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m chunksize \u001b[38;5;129;01mor\u001b[39;00m iterator:\n\u001b[1;32m 623\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m parser\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/pandas/io/parsers/readers.py:1620\u001b[0m, in \u001b[0;36mTextFileReader.__init__\u001b[0;34m(self, f, engine, **kwds)\u001b[0m\n\u001b[1;32m 1617\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptions[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhas_index_names\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m kwds[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhas_index_names\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m 1619\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles: IOHandles \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m-> 1620\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_engine \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_make_engine\u001b[49m\u001b[43m(\u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mengine\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/pandas/io/parsers/readers.py:1880\u001b[0m, in \u001b[0;36mTextFileReader._make_engine\u001b[0;34m(self, f, engine)\u001b[0m\n\u001b[1;32m 1878\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m mode:\n\u001b[1;32m 1879\u001b[0m mode \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m-> 1880\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles \u001b[38;5;241m=\u001b[39m \u001b[43mget_handle\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1881\u001b[0m \u001b[43m \u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1882\u001b[0m \u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1883\u001b[0m \u001b[43m \u001b[49m\u001b[43mencoding\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mencoding\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1884\u001b[0m \u001b[43m \u001b[49m\u001b[43mcompression\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcompression\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1885\u001b[0m \u001b[43m \u001b[49m\u001b[43mmemory_map\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmemory_map\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1886\u001b[0m \u001b[43m \u001b[49m\u001b[43mis_text\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_text\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1887\u001b[0m \u001b[43m \u001b[49m\u001b[43merrors\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mencoding_errors\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstrict\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1888\u001b[0m \u001b[43m \u001b[49m\u001b[43mstorage_options\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstorage_options\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1889\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1890\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 1891\u001b[0m f \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles\u001b[38;5;241m.\u001b[39mhandle\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/pandas/io/common.py:873\u001b[0m, in \u001b[0;36mget_handle\u001b[0;34m(path_or_buf, mode, encoding, compression, memory_map, is_text, errors, storage_options)\u001b[0m\n\u001b[1;32m 868\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(handle, \u001b[38;5;28mstr\u001b[39m):\n\u001b[1;32m 869\u001b[0m \u001b[38;5;66;03m# Check whether the filename is to be opened in binary mode.\u001b[39;00m\n\u001b[1;32m 870\u001b[0m \u001b[38;5;66;03m# Binary mode does not support 'encoding' and 'newline'.\u001b[39;00m\n\u001b[1;32m 871\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ioargs\u001b[38;5;241m.\u001b[39mencoding \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m ioargs\u001b[38;5;241m.\u001b[39mmode:\n\u001b[1;32m 872\u001b[0m \u001b[38;5;66;03m# Encoding\u001b[39;00m\n\u001b[0;32m--> 873\u001b[0m handle \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\n\u001b[1;32m 874\u001b[0m \u001b[43m \u001b[49m\u001b[43mhandle\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 875\u001b[0m \u001b[43m \u001b[49m\u001b[43mioargs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 876\u001b[0m \u001b[43m \u001b[49m\u001b[43mencoding\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mioargs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mencoding\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 877\u001b[0m \u001b[43m \u001b[49m\u001b[43merrors\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43merrors\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 878\u001b[0m \u001b[43m \u001b[49m\u001b[43mnewline\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 879\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 880\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 881\u001b[0m \u001b[38;5;66;03m# Binary mode\u001b[39;00m\n\u001b[1;32m 882\u001b[0m handle \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mopen\u001b[39m(handle, ioargs\u001b[38;5;241m.\u001b[39mmode)\n", + "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '../../../EDFScheduler_task_log.csv'" + ] + } + ], + "source": [ + "filename3 = '../../../EDFScheduler_task_log.csv'\n", + "df3 = preprocess_fair_scheduler_log(filename3)" + ] } ], "metadata": { From f39e93d94e31d78ce06b965961c87b41b62fcf83 Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Fri, 8 Aug 2025 10:50:31 -0500 Subject: [PATCH 36/37] Update README.md: reorganize quick start section and improve clarity on simulation setup and TensorBoard usage --- simulation/kubernetes/README.md | 62 ++++++++++++++++----------------- 1 file changed, 30 insertions(+), 32 deletions(-) diff --git a/simulation/kubernetes/README.md b/simulation/kubernetes/README.md index 62a0ad4..d74aeef 100644 --- a/simulation/kubernetes/README.md +++ b/simulation/kubernetes/README.md @@ -4,27 +4,6 @@ This simulation forms a computing cluster of multiple devices and creates worklo ## Install Dependencies `pip3 install -r requirements.txt` -## Quick Start -To start a simulation, simply run, - -```bash -# Uses mywaggle configuration to set up the simulation -python3 run.py --config mywaggle.yaml -``` - -After the simulation is finished (or during the simulation), open Tensorboard to see the result, - -```bash -tensorboard --logdir logs/ -``` -- You should see the link after running this command -- Open the link and see the graphs and plots - -These are useful links about Tensorboard: -https://www.google.com/url?sa=t&source=web&rct=j&opi=89978449&url=https://www.tensorflow.org/tensorboard/get_started&ved=2ahUKEwi2k6HGsYqOAxUPPjQIHZMlI6sQFnoECBIQAQ&usg=AOvVaw2zoEfsLy_AcckWcLnf6tdT - -https://www.google.com/url?sa=t&source=web&rct=j&opi=89978449&url=https://www.datacamp.com/tutorial/tensorboard-tutorial&ved=2ahUKEwinkMXUsYqOAxWEOTQIHbXsBewQFnoECEIQAQ&usg=AOvVaw2SiaeB3BS3Eb2vzAyU_HLc - ## Using a Simple Cluster This cluster creates simulated nodes and workloads. @@ -40,18 +19,25 @@ To create a cluster, ./setup.sh ``` -## How to Run a Simulation +## Quick Start -```bash +To start a simulation, simply run, +```bash +# Uses mywaggle configuration to set up the simulation python3 run.py --config mywaggle.yaml ``` -To see plots on tensorboard +#### After the simulation is finished (or during the simulation), open Tensorboard to see the result + ```bash tensorboard --logdir logs/ ``` +- You should see the link after running this command +- Open the link and see the graphs and plots + + TensorBoard will start a local web server. You’ll see output like: @@ -64,6 +50,12 @@ Open your browser and go to: ``` http://localhost:6006 ``` + +These are useful links about Tensorboard: +https://www.google.com/url?sa=t&source=web&rct=j&opi=89978449&url=https://www.tensorflow.org/tensorboard/get_started&ved=2ahUKEwi2k6HGsYqOAxUPPjQIHZMlI6sQFnoECBIQAQ&usg=AOvVaw2zoEfsLy_AcckWcLnf6tdT + +https://www.google.com/url?sa=t&source=web&rct=j&opi=89978449&url=https://www.datacamp.com/tutorial/tensorboard-tutorial&ved=2ahUKEwinkMXUsYqOAxWEOTQIHbXsBewQFnoECEIQAQ&usg=AOvVaw2SiaeB3BS3Eb2vzAyU_HLc + ## Interpreting Results in TensorBoard After launching TensorBoard with `tensorboard --logdir logs/`, open the provided link in your browser (usually http://localhost:6006). You will see a dashboard with several tabs and plots. @@ -81,6 +73,11 @@ After launching TensorBoard with `tensorboard --logdir logs/`, open the provided - **Task Efficiency:** Tasks completed per unit time. - Use the "Scalars" tab to view these metrics as line plots. + +Ex : node_t001-nxcore_cpu +node_t002-nxcore_finished_workloads + + 3. **Compare Runs or Configurations:** - Overlay multiple runs to compare different schedulers or parameter settings. - Use the checkboxes to toggle visibility of each run. @@ -156,8 +153,6 @@ What It Does: • Outputs a CSV file with columns: step, tag, and value. -• Includes a helper to pick the latest log directory automatically. - • Can also simulate logs using SummaryWriter (for testing visualizations). @@ -176,7 +171,8 @@ Ex: output_csv = "FairShareScheduler_task_log.csv" - Change the directory by using cd src/scripts - #### Go to CSVexport file + Go to CSVexport file + Run & Debug on left side panel in VScode or whatever code runner for your IDE or @@ -194,6 +190,8 @@ Output: a CSV file like FairShareScheduler_task_log.csv. ## 2. Visualization .py +> warning : under development + Purpose: This script analyzes one or more scheduler logs and compares key metrics such as task counts, energy usage, task durations, and efficiency across different schedulers. @@ -220,9 +218,9 @@ Main Features: How to Use: -1. Ensure you have one or more log CSVs from tensorboard_to_csv.py. +1. Ensure you have one or more log CSVs from CSVexport.py. -2. Define your list of scheduler names (e.g., ["WaggleScheduler", "FairScheduler"]). +2. Define your schedulers name in ipynb for the filename ["WaggleScheduler", "FairScheduler"] or in visualization.py . #### Go to @@ -244,14 +242,14 @@ python3 visualization.py ### Where Logs Are Saved -Simulation logs are saved to the /logs/ directory. -You’ll find: +Simulation logs are saved + +You’ll find in this directory : ``` • {scheduler name} tasks.csv: logs for all tasks (start time, end time, node used, energy consumed, etc.) ``` -• scheduler_comparison_metrics.csv: a summary table • .png plots for each metric in the plots/ directory From 6fa9fafc648bbb43a255db518330552e13cf2d7d Mon Sep 17 00:00:00 2001 From: Kendalcoder Date: Fri, 8 Aug 2025 10:51:13 -0500 Subject: [PATCH 37/37] Update scheduler configuration and visualization scripts - Changed the scheduler in mywaggle.yaml from WaggleScheduler to FairshareScheduler. - Added a new Jupyter notebook for interactive visualization (test_vis-interactive.ipynb). - Updated the visualization script to correctly reference FairShareScheduler instead of FairScheduler in the comparison function. --- simulation/FairShareScheduler_task_log.csv | 851 ++++++++++++++++++ ...trics.csv => WaggleScheduler_task_log.csv} | 0 simulation/kubernetes/mywaggle.yaml | 4 +- .../src/scripts/test_vis-interactive.ipynb | 0 .../kubernetes/src/scripts/visualization.py | 2 +- 5 files changed, 854 insertions(+), 3 deletions(-) create mode 100644 simulation/FairShareScheduler_task_log.csv rename simulation/{scheduler_metrics.csv => WaggleScheduler_task_log.csv} (100%) create mode 100644 simulation/kubernetes/src/scripts/test_vis-interactive.ipynb diff --git a/simulation/FairShareScheduler_task_log.csv b/simulation/FairShareScheduler_task_log.csv new file mode 100644 index 0000000..e7f7864 --- /dev/null +++ b/simulation/FairShareScheduler_task_log.csv @@ -0,0 +1,851 @@ +step,tag,value +0,node_t001-nxcore_energy,1.1911900043487549 +1,node_t001-nxcore_energy,0.4165000021457672 +2,node_t001-nxcore_energy,0.8996400237083435 +3,node_t001-nxcore_energy,0.4165000021457672 +4,node_t001-nxcore_energy,0.8996400237083435 +5,node_t001-nxcore_energy,0.4165000021457672 +6,node_t001-nxcore_energy,0.8996400237083435 +7,node_t001-nxcore_energy,0.4165000021457672 +8,node_t001-nxcore_energy,0.8996400237083435 +9,node_t001-nxcore_energy,0.4165000021457672 +10,node_t001-nxcore_energy,0.9162999987602234 +11,node_t001-nxcore_energy,0.4165000021457672 +12,node_t001-nxcore_energy,0.8996400237083435 +13,node_t001-nxcore_energy,0.4165000021457672 +14,node_t001-nxcore_energy,0.8996400237083435 +15,node_t001-nxcore_energy,0.4165000021457672 +16,node_t001-nxcore_energy,0.8996400237083435 +17,node_t001-nxcore_energy,0.4165000021457672 +18,node_t001-nxcore_energy,0.8996400237083435 +19,node_t001-nxcore_energy,0.4165000021457672 +20,node_t001-nxcore_energy,0.9162999987602234 +21,node_t001-nxcore_energy,0.4165000021457672 +22,node_t001-nxcore_energy,0.8996400237083435 +23,node_t001-nxcore_energy,0.4165000021457672 +24,node_t001-nxcore_energy,0.8996400237083435 +25,node_t001-nxcore_energy,0.4165000021457672 +26,node_t001-nxcore_energy,0.8996400237083435 +27,node_t001-nxcore_energy,0.4165000021457672 +28,node_t001-nxcore_energy,0.8996400237083435 +29,node_t001-nxcore_energy,0.4165000021457672 +30,node_t001-nxcore_energy,0.9162999987602234 +31,node_t001-nxcore_energy,0.4165000021457672 +32,node_t001-nxcore_energy,0.8996400237083435 +33,node_t001-nxcore_energy,0.4165000021457672 +34,node_t001-nxcore_energy,0.8996400237083435 +35,node_t001-nxcore_energy,0.4165000021457672 +36,node_t001-nxcore_energy,0.8996400237083435 +37,node_t001-nxcore_energy,0.4165000021457672 +38,node_t001-nxcore_energy,0.8996400237083435 +39,node_t001-nxcore_energy,0.4165000021457672 +40,node_t001-nxcore_energy,0.9162999987602234 +41,node_t001-nxcore_energy,0.4165000021457672 +42,node_t001-nxcore_energy,0.8996400237083435 +43,node_t001-nxcore_energy,0.4165000021457672 +44,node_t001-nxcore_energy,0.8996400237083435 +45,node_t001-nxcore_energy,0.4165000021457672 +46,node_t001-nxcore_energy,0.8996400237083435 +47,node_t001-nxcore_energy,0.4165000021457672 +48,node_t001-nxcore_energy,0.8996400237083435 +49,node_t001-nxcore_energy,0.4165000021457672 +0,node_t001-nxcore_cpu,5600.0 +1,node_t001-nxcore_cpu,0.0 +2,node_t001-nxcore_cpu,3500.0 +3,node_t001-nxcore_cpu,0.0 +4,node_t001-nxcore_cpu,3500.0 +5,node_t001-nxcore_cpu,0.0 +6,node_t001-nxcore_cpu,3500.0 +7,node_t001-nxcore_cpu,0.0 +8,node_t001-nxcore_cpu,3500.0 +9,node_t001-nxcore_cpu,0.0 +10,node_t001-nxcore_cpu,3600.0 +11,node_t001-nxcore_cpu,0.0 +12,node_t001-nxcore_cpu,3500.0 +13,node_t001-nxcore_cpu,0.0 +14,node_t001-nxcore_cpu,3500.0 +15,node_t001-nxcore_cpu,0.0 +16,node_t001-nxcore_cpu,3500.0 +17,node_t001-nxcore_cpu,0.0 +18,node_t001-nxcore_cpu,3500.0 +19,node_t001-nxcore_cpu,0.0 +20,node_t001-nxcore_cpu,3600.0 +21,node_t001-nxcore_cpu,0.0 +22,node_t001-nxcore_cpu,3500.0 +23,node_t001-nxcore_cpu,0.0 +24,node_t001-nxcore_cpu,3500.0 +25,node_t001-nxcore_cpu,0.0 +26,node_t001-nxcore_cpu,3500.0 +27,node_t001-nxcore_cpu,0.0 +28,node_t001-nxcore_cpu,3500.0 +29,node_t001-nxcore_cpu,0.0 +30,node_t001-nxcore_cpu,3600.0 +31,node_t001-nxcore_cpu,0.0 +32,node_t001-nxcore_cpu,3500.0 +33,node_t001-nxcore_cpu,0.0 +34,node_t001-nxcore_cpu,3500.0 +35,node_t001-nxcore_cpu,0.0 +36,node_t001-nxcore_cpu,3500.0 +37,node_t001-nxcore_cpu,0.0 +38,node_t001-nxcore_cpu,3500.0 +39,node_t001-nxcore_cpu,0.0 +40,node_t001-nxcore_cpu,3600.0 +41,node_t001-nxcore_cpu,0.0 +42,node_t001-nxcore_cpu,3500.0 +43,node_t001-nxcore_cpu,0.0 +44,node_t001-nxcore_cpu,3500.0 +45,node_t001-nxcore_cpu,0.0 +46,node_t001-nxcore_cpu,3500.0 +47,node_t001-nxcore_cpu,0.0 +48,node_t001-nxcore_cpu,3500.0 +49,node_t001-nxcore_cpu,0.0 +0,node_t001-nxcore_memory,7136608256.0 +1,node_t001-nxcore_memory,0.0 +2,node_t001-nxcore_memory,5842665472.0 +3,node_t001-nxcore_memory,0.0 +4,node_t001-nxcore_memory,5842665472.0 +5,node_t001-nxcore_memory,0.0 +6,node_t001-nxcore_memory,5842665472.0 +7,node_t001-nxcore_memory,0.0 +8,node_t001-nxcore_memory,5842665472.0 +9,node_t001-nxcore_memory,0.0 +10,node_t001-nxcore_memory,5853151232.0 +11,node_t001-nxcore_memory,0.0 +12,node_t001-nxcore_memory,5842665472.0 +13,node_t001-nxcore_memory,0.0 +14,node_t001-nxcore_memory,5842665472.0 +15,node_t001-nxcore_memory,0.0 +16,node_t001-nxcore_memory,5842665472.0 +17,node_t001-nxcore_memory,0.0 +18,node_t001-nxcore_memory,5842665472.0 +19,node_t001-nxcore_memory,0.0 +20,node_t001-nxcore_memory,5853151232.0 +21,node_t001-nxcore_memory,0.0 +22,node_t001-nxcore_memory,5842665472.0 +23,node_t001-nxcore_memory,0.0 +24,node_t001-nxcore_memory,5842665472.0 +25,node_t001-nxcore_memory,0.0 +26,node_t001-nxcore_memory,5842665472.0 +27,node_t001-nxcore_memory,0.0 +28,node_t001-nxcore_memory,5842665472.0 +29,node_t001-nxcore_memory,0.0 +30,node_t001-nxcore_memory,5853151232.0 +31,node_t001-nxcore_memory,0.0 +32,node_t001-nxcore_memory,5842665472.0 +33,node_t001-nxcore_memory,0.0 +34,node_t001-nxcore_memory,5842665472.0 +35,node_t001-nxcore_memory,0.0 +36,node_t001-nxcore_memory,5842665472.0 +37,node_t001-nxcore_memory,0.0 +38,node_t001-nxcore_memory,5842665472.0 +39,node_t001-nxcore_memory,0.0 +40,node_t001-nxcore_memory,5853151232.0 +41,node_t001-nxcore_memory,0.0 +42,node_t001-nxcore_memory,5842665472.0 +43,node_t001-nxcore_memory,0.0 +44,node_t001-nxcore_memory,5842665472.0 +45,node_t001-nxcore_memory,0.0 +46,node_t001-nxcore_memory,5842665472.0 +47,node_t001-nxcore_memory,0.0 +48,node_t001-nxcore_memory,5842665472.0 +49,node_t001-nxcore_memory,0.0 +0,node_t001-nxcore_power,14.300000190734863 +1,node_t001-nxcore_power,5.0 +2,node_t001-nxcore_power,10.800000190734863 +3,node_t001-nxcore_power,5.0 +4,node_t001-nxcore_power,10.800000190734863 +5,node_t001-nxcore_power,5.0 +6,node_t001-nxcore_power,10.800000190734863 +7,node_t001-nxcore_power,5.0 +8,node_t001-nxcore_power,10.800000190734863 +9,node_t001-nxcore_power,5.0 +10,node_t001-nxcore_power,11.0 +11,node_t001-nxcore_power,5.0 +12,node_t001-nxcore_power,10.800000190734863 +13,node_t001-nxcore_power,5.0 +14,node_t001-nxcore_power,10.800000190734863 +15,node_t001-nxcore_power,5.0 +16,node_t001-nxcore_power,10.800000190734863 +17,node_t001-nxcore_power,5.0 +18,node_t001-nxcore_power,10.800000190734863 +19,node_t001-nxcore_power,5.0 +20,node_t001-nxcore_power,11.0 +21,node_t001-nxcore_power,5.0 +22,node_t001-nxcore_power,10.800000190734863 +23,node_t001-nxcore_power,5.0 +24,node_t001-nxcore_power,10.800000190734863 +25,node_t001-nxcore_power,5.0 +26,node_t001-nxcore_power,10.800000190734863 +27,node_t001-nxcore_power,5.0 +28,node_t001-nxcore_power,10.800000190734863 +29,node_t001-nxcore_power,5.0 +30,node_t001-nxcore_power,11.0 +31,node_t001-nxcore_power,5.0 +32,node_t001-nxcore_power,10.800000190734863 +33,node_t001-nxcore_power,5.0 +34,node_t001-nxcore_power,10.800000190734863 +35,node_t001-nxcore_power,5.0 +36,node_t001-nxcore_power,10.800000190734863 +37,node_t001-nxcore_power,5.0 +38,node_t001-nxcore_power,10.800000190734863 +39,node_t001-nxcore_power,5.0 +40,node_t001-nxcore_power,11.0 +41,node_t001-nxcore_power,5.0 +42,node_t001-nxcore_power,10.800000190734863 +43,node_t001-nxcore_power,5.0 +44,node_t001-nxcore_power,10.800000190734863 +45,node_t001-nxcore_power,5.0 +46,node_t001-nxcore_power,10.800000190734863 +47,node_t001-nxcore_power,5.0 +48,node_t001-nxcore_power,10.800000190734863 +49,node_t001-nxcore_power,5.0 +0,node_t001-nxcore_power_moving_average,14.300000190734863 +1,node_t001-nxcore_power_moving_average,11.199999809265137 +2,node_t001-nxcore_power_moving_average,10.800000190734863 +3,node_t001-nxcore_power_moving_average,8.866666793823242 +4,node_t001-nxcore_power_moving_average,10.800000190734863 +5,node_t001-nxcore_power_moving_average,8.866666793823242 +6,node_t001-nxcore_power_moving_average,10.800000190734863 +7,node_t001-nxcore_power_moving_average,8.866666793823242 +8,node_t001-nxcore_power_moving_average,10.800000190734863 +9,node_t001-nxcore_power_moving_average,8.866666793823242 +10,node_t001-nxcore_power_moving_average,11.0 +11,node_t001-nxcore_power_moving_average,9.0 +12,node_t001-nxcore_power_moving_average,10.800000190734863 +13,node_t001-nxcore_power_moving_average,8.866666793823242 +14,node_t001-nxcore_power_moving_average,10.800000190734863 +15,node_t001-nxcore_power_moving_average,8.866666793823242 +16,node_t001-nxcore_power_moving_average,10.800000190734863 +17,node_t001-nxcore_power_moving_average,8.866666793823242 +18,node_t001-nxcore_power_moving_average,10.800000190734863 +19,node_t001-nxcore_power_moving_average,8.866666793823242 +20,node_t001-nxcore_power_moving_average,11.0 +21,node_t001-nxcore_power_moving_average,9.0 +22,node_t001-nxcore_power_moving_average,10.800000190734863 +23,node_t001-nxcore_power_moving_average,8.866666793823242 +24,node_t001-nxcore_power_moving_average,10.800000190734863 +25,node_t001-nxcore_power_moving_average,8.866666793823242 +26,node_t001-nxcore_power_moving_average,10.800000190734863 +27,node_t001-nxcore_power_moving_average,8.866666793823242 +28,node_t001-nxcore_power_moving_average,10.800000190734863 +29,node_t001-nxcore_power_moving_average,8.866666793823242 +30,node_t001-nxcore_power_moving_average,11.0 +31,node_t001-nxcore_power_moving_average,9.0 +32,node_t001-nxcore_power_moving_average,10.800000190734863 +33,node_t001-nxcore_power_moving_average,8.866666793823242 +34,node_t001-nxcore_power_moving_average,10.800000190734863 +35,node_t001-nxcore_power_moving_average,8.866666793823242 +36,node_t001-nxcore_power_moving_average,10.800000190734863 +37,node_t001-nxcore_power_moving_average,8.866666793823242 +38,node_t001-nxcore_power_moving_average,10.800000190734863 +39,node_t001-nxcore_power_moving_average,8.866666793823242 +40,node_t001-nxcore_power_moving_average,11.0 +41,node_t001-nxcore_power_moving_average,9.0 +42,node_t001-nxcore_power_moving_average,10.800000190734863 +43,node_t001-nxcore_power_moving_average,8.866666793823242 +44,node_t001-nxcore_power_moving_average,10.800000190734863 +45,node_t001-nxcore_power_moving_average,8.866666793823242 +46,node_t001-nxcore_power_moving_average,10.800000190734863 +47,node_t001-nxcore_power_moving_average,8.866666793823242 +48,node_t001-nxcore_power_moving_average,10.800000190734863 +49,node_t001-nxcore_power_moving_average,8.866666793823242 +0,node_t001-nxcore_finished_workloads,5.0 +1,node_t001-nxcore_finished_workloads,5.0 +2,node_t001-nxcore_finished_workloads,7.0 +3,node_t001-nxcore_finished_workloads,7.0 +4,node_t001-nxcore_finished_workloads,9.0 +5,node_t001-nxcore_finished_workloads,9.0 +6,node_t001-nxcore_finished_workloads,11.0 +7,node_t001-nxcore_finished_workloads,11.0 +8,node_t001-nxcore_finished_workloads,13.0 +9,node_t001-nxcore_finished_workloads,13.0 +10,node_t001-nxcore_finished_workloads,16.0 +11,node_t001-nxcore_finished_workloads,16.0 +12,node_t001-nxcore_finished_workloads,18.0 +13,node_t001-nxcore_finished_workloads,18.0 +14,node_t001-nxcore_finished_workloads,20.0 +15,node_t001-nxcore_finished_workloads,20.0 +16,node_t001-nxcore_finished_workloads,22.0 +17,node_t001-nxcore_finished_workloads,22.0 +18,node_t001-nxcore_finished_workloads,24.0 +19,node_t001-nxcore_finished_workloads,24.0 +20,node_t001-nxcore_finished_workloads,27.0 +21,node_t001-nxcore_finished_workloads,27.0 +22,node_t001-nxcore_finished_workloads,29.0 +23,node_t001-nxcore_finished_workloads,29.0 +24,node_t001-nxcore_finished_workloads,31.0 +25,node_t001-nxcore_finished_workloads,31.0 +26,node_t001-nxcore_finished_workloads,33.0 +27,node_t001-nxcore_finished_workloads,33.0 +28,node_t001-nxcore_finished_workloads,35.0 +29,node_t001-nxcore_finished_workloads,35.0 +30,node_t001-nxcore_finished_workloads,38.0 +31,node_t001-nxcore_finished_workloads,38.0 +32,node_t001-nxcore_finished_workloads,40.0 +33,node_t001-nxcore_finished_workloads,40.0 +34,node_t001-nxcore_finished_workloads,42.0 +35,node_t001-nxcore_finished_workloads,42.0 +36,node_t001-nxcore_finished_workloads,44.0 +37,node_t001-nxcore_finished_workloads,44.0 +38,node_t001-nxcore_finished_workloads,46.0 +39,node_t001-nxcore_finished_workloads,46.0 +40,node_t001-nxcore_finished_workloads,49.0 +41,node_t001-nxcore_finished_workloads,49.0 +42,node_t001-nxcore_finished_workloads,51.0 +43,node_t001-nxcore_finished_workloads,51.0 +44,node_t001-nxcore_finished_workloads,53.0 +45,node_t001-nxcore_finished_workloads,53.0 +46,node_t001-nxcore_finished_workloads,55.0 +47,node_t001-nxcore_finished_workloads,55.0 +48,node_t001-nxcore_finished_workloads,57.0 +49,node_t001-nxcore_finished_workloads,57.0 +0,node_t001-nxcore_running_workloads,0.0 +1,node_t001-nxcore_running_workloads,0.0 +2,node_t001-nxcore_running_workloads,0.0 +3,node_t001-nxcore_running_workloads,0.0 +4,node_t001-nxcore_running_workloads,0.0 +5,node_t001-nxcore_running_workloads,0.0 +6,node_t001-nxcore_running_workloads,0.0 +7,node_t001-nxcore_running_workloads,0.0 +8,node_t001-nxcore_running_workloads,0.0 +9,node_t001-nxcore_running_workloads,0.0 +10,node_t001-nxcore_running_workloads,0.0 +11,node_t001-nxcore_running_workloads,0.0 +12,node_t001-nxcore_running_workloads,0.0 +13,node_t001-nxcore_running_workloads,0.0 +14,node_t001-nxcore_running_workloads,0.0 +15,node_t001-nxcore_running_workloads,0.0 +16,node_t001-nxcore_running_workloads,0.0 +17,node_t001-nxcore_running_workloads,0.0 +18,node_t001-nxcore_running_workloads,0.0 +19,node_t001-nxcore_running_workloads,0.0 +20,node_t001-nxcore_running_workloads,0.0 +21,node_t001-nxcore_running_workloads,0.0 +22,node_t001-nxcore_running_workloads,0.0 +23,node_t001-nxcore_running_workloads,0.0 +24,node_t001-nxcore_running_workloads,0.0 +25,node_t001-nxcore_running_workloads,0.0 +26,node_t001-nxcore_running_workloads,0.0 +27,node_t001-nxcore_running_workloads,0.0 +28,node_t001-nxcore_running_workloads,0.0 +29,node_t001-nxcore_running_workloads,0.0 +30,node_t001-nxcore_running_workloads,0.0 +31,node_t001-nxcore_running_workloads,0.0 +32,node_t001-nxcore_running_workloads,0.0 +33,node_t001-nxcore_running_workloads,0.0 +34,node_t001-nxcore_running_workloads,0.0 +35,node_t001-nxcore_running_workloads,0.0 +36,node_t001-nxcore_running_workloads,0.0 +37,node_t001-nxcore_running_workloads,0.0 +38,node_t001-nxcore_running_workloads,0.0 +39,node_t001-nxcore_running_workloads,0.0 +40,node_t001-nxcore_running_workloads,0.0 +41,node_t001-nxcore_running_workloads,0.0 +42,node_t001-nxcore_running_workloads,0.0 +43,node_t001-nxcore_running_workloads,0.0 +44,node_t001-nxcore_running_workloads,0.0 +45,node_t001-nxcore_running_workloads,0.0 +46,node_t001-nxcore_running_workloads,0.0 +47,node_t001-nxcore_running_workloads,0.0 +48,node_t001-nxcore_running_workloads,0.0 +49,node_t001-nxcore_running_workloads,0.0 +0,node_t002-nxcore_energy,0.4165000021457672 +1,node_t002-nxcore_energy,0.8330000042915344 +2,node_t002-nxcore_energy,0.6913899779319763 +3,node_t002-nxcore_energy,0.8330000042915344 +4,node_t002-nxcore_energy,0.6913899779319763 +5,node_t002-nxcore_energy,0.8330000042915344 +6,node_t002-nxcore_energy,0.6913899779319763 +7,node_t002-nxcore_energy,0.8330000042915344 +8,node_t002-nxcore_energy,0.6913899779319763 +9,node_t002-nxcore_energy,0.8330000042915344 +10,node_t002-nxcore_energy,0.6913899779319763 +11,node_t002-nxcore_energy,0.8330000042915344 +12,node_t002-nxcore_energy,0.6913899779319763 +13,node_t002-nxcore_energy,0.8330000042915344 +14,node_t002-nxcore_energy,0.6913899779319763 +15,node_t002-nxcore_energy,0.8330000042915344 +16,node_t002-nxcore_energy,0.6913899779319763 +17,node_t002-nxcore_energy,0.8330000042915344 +18,node_t002-nxcore_energy,0.6913899779319763 +19,node_t002-nxcore_energy,0.8330000042915344 +20,node_t002-nxcore_energy,0.6913899779319763 +21,node_t002-nxcore_energy,0.8330000042915344 +22,node_t002-nxcore_energy,0.6913899779319763 +23,node_t002-nxcore_energy,0.8330000042915344 +24,node_t002-nxcore_energy,0.6913899779319763 +25,node_t002-nxcore_energy,0.8330000042915344 +26,node_t002-nxcore_energy,0.6913899779319763 +27,node_t002-nxcore_energy,0.8330000042915344 +28,node_t002-nxcore_energy,0.6913899779319763 +29,node_t002-nxcore_energy,0.8330000042915344 +30,node_t002-nxcore_energy,0.6913899779319763 +31,node_t002-nxcore_energy,0.8330000042915344 +32,node_t002-nxcore_energy,0.6913899779319763 +33,node_t002-nxcore_energy,0.8330000042915344 +34,node_t002-nxcore_energy,0.6913899779319763 +35,node_t002-nxcore_energy,0.8330000042915344 +36,node_t002-nxcore_energy,0.6913899779319763 +37,node_t002-nxcore_energy,0.8330000042915344 +38,node_t002-nxcore_energy,0.6913899779319763 +39,node_t002-nxcore_energy,0.8330000042915344 +40,node_t002-nxcore_energy,0.6913899779319763 +41,node_t002-nxcore_energy,0.8330000042915344 +42,node_t002-nxcore_energy,0.6913899779319763 +43,node_t002-nxcore_energy,0.8330000042915344 +44,node_t002-nxcore_energy,0.6913899779319763 +45,node_t002-nxcore_energy,0.8330000042915344 +46,node_t002-nxcore_energy,0.6913899779319763 +47,node_t002-nxcore_energy,0.8330000042915344 +48,node_t002-nxcore_energy,0.6913899779319763 +49,node_t002-nxcore_energy,0.8330000042915344 +0,node_t002-nxcore_cpu,0.0 +1,node_t002-nxcore_cpu,3000.0 +2,node_t002-nxcore_cpu,2000.0 +3,node_t002-nxcore_cpu,3000.0 +4,node_t002-nxcore_cpu,2000.0 +5,node_t002-nxcore_cpu,3000.0 +6,node_t002-nxcore_cpu,2000.0 +7,node_t002-nxcore_cpu,3000.0 +8,node_t002-nxcore_cpu,2000.0 +9,node_t002-nxcore_cpu,3000.0 +10,node_t002-nxcore_cpu,2000.0 +11,node_t002-nxcore_cpu,3000.0 +12,node_t002-nxcore_cpu,2000.0 +13,node_t002-nxcore_cpu,3000.0 +14,node_t002-nxcore_cpu,2000.0 +15,node_t002-nxcore_cpu,3000.0 +16,node_t002-nxcore_cpu,2000.0 +17,node_t002-nxcore_cpu,3000.0 +18,node_t002-nxcore_cpu,2000.0 +19,node_t002-nxcore_cpu,3000.0 +20,node_t002-nxcore_cpu,2000.0 +21,node_t002-nxcore_cpu,3000.0 +22,node_t002-nxcore_cpu,2000.0 +23,node_t002-nxcore_cpu,3000.0 +24,node_t002-nxcore_cpu,2000.0 +25,node_t002-nxcore_cpu,3000.0 +26,node_t002-nxcore_cpu,2000.0 +27,node_t002-nxcore_cpu,3000.0 +28,node_t002-nxcore_cpu,2000.0 +29,node_t002-nxcore_cpu,3000.0 +30,node_t002-nxcore_cpu,2000.0 +31,node_t002-nxcore_cpu,3000.0 +32,node_t002-nxcore_cpu,2000.0 +33,node_t002-nxcore_cpu,3000.0 +34,node_t002-nxcore_cpu,2000.0 +35,node_t002-nxcore_cpu,3000.0 +36,node_t002-nxcore_cpu,2000.0 +37,node_t002-nxcore_cpu,3000.0 +38,node_t002-nxcore_cpu,2000.0 +39,node_t002-nxcore_cpu,3000.0 +40,node_t002-nxcore_cpu,2000.0 +41,node_t002-nxcore_cpu,3000.0 +42,node_t002-nxcore_cpu,2000.0 +43,node_t002-nxcore_cpu,3000.0 +44,node_t002-nxcore_cpu,2000.0 +45,node_t002-nxcore_cpu,3000.0 +46,node_t002-nxcore_cpu,2000.0 +47,node_t002-nxcore_cpu,3000.0 +48,node_t002-nxcore_cpu,2000.0 +49,node_t002-nxcore_cpu,3000.0 +0,node_t002-nxcore_memory,0.0 +1,node_t002-nxcore_memory,4294967296.0 +2,node_t002-nxcore_memory,1283457024.0 +3,node_t002-nxcore_memory,4294967296.0 +4,node_t002-nxcore_memory,1283457024.0 +5,node_t002-nxcore_memory,4294967296.0 +6,node_t002-nxcore_memory,1283457024.0 +7,node_t002-nxcore_memory,4294967296.0 +8,node_t002-nxcore_memory,1283457024.0 +9,node_t002-nxcore_memory,4294967296.0 +10,node_t002-nxcore_memory,1283457024.0 +11,node_t002-nxcore_memory,4294967296.0 +12,node_t002-nxcore_memory,1283457024.0 +13,node_t002-nxcore_memory,4294967296.0 +14,node_t002-nxcore_memory,1283457024.0 +15,node_t002-nxcore_memory,4294967296.0 +16,node_t002-nxcore_memory,1283457024.0 +17,node_t002-nxcore_memory,4294967296.0 +18,node_t002-nxcore_memory,1283457024.0 +19,node_t002-nxcore_memory,4294967296.0 +20,node_t002-nxcore_memory,1283457024.0 +21,node_t002-nxcore_memory,4294967296.0 +22,node_t002-nxcore_memory,1283457024.0 +23,node_t002-nxcore_memory,4294967296.0 +24,node_t002-nxcore_memory,1283457024.0 +25,node_t002-nxcore_memory,4294967296.0 +26,node_t002-nxcore_memory,1283457024.0 +27,node_t002-nxcore_memory,4294967296.0 +28,node_t002-nxcore_memory,1283457024.0 +29,node_t002-nxcore_memory,4294967296.0 +30,node_t002-nxcore_memory,1283457024.0 +31,node_t002-nxcore_memory,4294967296.0 +32,node_t002-nxcore_memory,1283457024.0 +33,node_t002-nxcore_memory,4294967296.0 +34,node_t002-nxcore_memory,1283457024.0 +35,node_t002-nxcore_memory,4294967296.0 +36,node_t002-nxcore_memory,1283457024.0 +37,node_t002-nxcore_memory,4294967296.0 +38,node_t002-nxcore_memory,1283457024.0 +39,node_t002-nxcore_memory,4294967296.0 +40,node_t002-nxcore_memory,1283457024.0 +41,node_t002-nxcore_memory,4294967296.0 +42,node_t002-nxcore_memory,1283457024.0 +43,node_t002-nxcore_memory,4294967296.0 +44,node_t002-nxcore_memory,1283457024.0 +45,node_t002-nxcore_memory,4294967296.0 +46,node_t002-nxcore_memory,1283457024.0 +47,node_t002-nxcore_memory,4294967296.0 +48,node_t002-nxcore_memory,1283457024.0 +49,node_t002-nxcore_memory,4294967296.0 +0,node_t002-nxcore_power,5.0 +1,node_t002-nxcore_power,10.0 +2,node_t002-nxcore_power,8.300000190734863 +3,node_t002-nxcore_power,10.0 +4,node_t002-nxcore_power,8.300000190734863 +5,node_t002-nxcore_power,10.0 +6,node_t002-nxcore_power,8.300000190734863 +7,node_t002-nxcore_power,10.0 +8,node_t002-nxcore_power,8.300000190734863 +9,node_t002-nxcore_power,10.0 +10,node_t002-nxcore_power,8.300000190734863 +11,node_t002-nxcore_power,10.0 +12,node_t002-nxcore_power,8.300000190734863 +13,node_t002-nxcore_power,10.0 +14,node_t002-nxcore_power,8.300000190734863 +15,node_t002-nxcore_power,10.0 +16,node_t002-nxcore_power,8.300000190734863 +17,node_t002-nxcore_power,10.0 +18,node_t002-nxcore_power,8.300000190734863 +19,node_t002-nxcore_power,10.0 +20,node_t002-nxcore_power,8.300000190734863 +21,node_t002-nxcore_power,10.0 +22,node_t002-nxcore_power,8.300000190734863 +23,node_t002-nxcore_power,10.0 +24,node_t002-nxcore_power,8.300000190734863 +25,node_t002-nxcore_power,10.0 +26,node_t002-nxcore_power,8.300000190734863 +27,node_t002-nxcore_power,10.0 +28,node_t002-nxcore_power,8.300000190734863 +29,node_t002-nxcore_power,10.0 +30,node_t002-nxcore_power,8.300000190734863 +31,node_t002-nxcore_power,10.0 +32,node_t002-nxcore_power,8.300000190734863 +33,node_t002-nxcore_power,10.0 +34,node_t002-nxcore_power,8.300000190734863 +35,node_t002-nxcore_power,10.0 +36,node_t002-nxcore_power,8.300000190734863 +37,node_t002-nxcore_power,10.0 +38,node_t002-nxcore_power,8.300000190734863 +39,node_t002-nxcore_power,10.0 +40,node_t002-nxcore_power,8.300000190734863 +41,node_t002-nxcore_power,10.0 +42,node_t002-nxcore_power,8.300000190734863 +43,node_t002-nxcore_power,10.0 +44,node_t002-nxcore_power,8.300000190734863 +45,node_t002-nxcore_power,10.0 +46,node_t002-nxcore_power,8.300000190734863 +47,node_t002-nxcore_power,10.0 +48,node_t002-nxcore_power,8.300000190734863 +49,node_t002-nxcore_power,10.0 +0,node_t002-nxcore_power_moving_average,5.0 +1,node_t002-nxcore_power_moving_average,10.0 +2,node_t002-nxcore_power_moving_average,8.300000190734863 +3,node_t002-nxcore_power_moving_average,10.0 +4,node_t002-nxcore_power_moving_average,8.300000190734863 +5,node_t002-nxcore_power_moving_average,10.0 +6,node_t002-nxcore_power_moving_average,8.300000190734863 +7,node_t002-nxcore_power_moving_average,10.0 +8,node_t002-nxcore_power_moving_average,8.300000190734863 +9,node_t002-nxcore_power_moving_average,10.0 +10,node_t002-nxcore_power_moving_average,8.300000190734863 +11,node_t002-nxcore_power_moving_average,10.0 +12,node_t002-nxcore_power_moving_average,8.300000190734863 +13,node_t002-nxcore_power_moving_average,10.0 +14,node_t002-nxcore_power_moving_average,8.300000190734863 +15,node_t002-nxcore_power_moving_average,10.0 +16,node_t002-nxcore_power_moving_average,8.300000190734863 +17,node_t002-nxcore_power_moving_average,10.0 +18,node_t002-nxcore_power_moving_average,8.300000190734863 +19,node_t002-nxcore_power_moving_average,10.0 +20,node_t002-nxcore_power_moving_average,8.300000190734863 +21,node_t002-nxcore_power_moving_average,10.0 +22,node_t002-nxcore_power_moving_average,8.300000190734863 +23,node_t002-nxcore_power_moving_average,10.0 +24,node_t002-nxcore_power_moving_average,8.300000190734863 +25,node_t002-nxcore_power_moving_average,10.0 +26,node_t002-nxcore_power_moving_average,8.300000190734863 +27,node_t002-nxcore_power_moving_average,10.0 +28,node_t002-nxcore_power_moving_average,8.300000190734863 +29,node_t002-nxcore_power_moving_average,10.0 +30,node_t002-nxcore_power_moving_average,8.300000190734863 +31,node_t002-nxcore_power_moving_average,10.0 +32,node_t002-nxcore_power_moving_average,8.300000190734863 +33,node_t002-nxcore_power_moving_average,10.0 +34,node_t002-nxcore_power_moving_average,8.300000190734863 +35,node_t002-nxcore_power_moving_average,10.0 +36,node_t002-nxcore_power_moving_average,8.300000190734863 +37,node_t002-nxcore_power_moving_average,10.0 +38,node_t002-nxcore_power_moving_average,8.300000190734863 +39,node_t002-nxcore_power_moving_average,10.0 +40,node_t002-nxcore_power_moving_average,8.300000190734863 +41,node_t002-nxcore_power_moving_average,10.0 +42,node_t002-nxcore_power_moving_average,8.300000190734863 +43,node_t002-nxcore_power_moving_average,10.0 +44,node_t002-nxcore_power_moving_average,8.300000190734863 +45,node_t002-nxcore_power_moving_average,10.0 +46,node_t002-nxcore_power_moving_average,8.300000190734863 +47,node_t002-nxcore_power_moving_average,10.0 +48,node_t002-nxcore_power_moving_average,8.300000190734863 +49,node_t002-nxcore_power_moving_average,10.0 +0,node_t002-nxcore_finished_workloads,0.0 +1,node_t002-nxcore_finished_workloads,2.0 +2,node_t002-nxcore_finished_workloads,4.0 +3,node_t002-nxcore_finished_workloads,6.0 +4,node_t002-nxcore_finished_workloads,8.0 +5,node_t002-nxcore_finished_workloads,10.0 +6,node_t002-nxcore_finished_workloads,12.0 +7,node_t002-nxcore_finished_workloads,14.0 +8,node_t002-nxcore_finished_workloads,16.0 +9,node_t002-nxcore_finished_workloads,18.0 +10,node_t002-nxcore_finished_workloads,20.0 +11,node_t002-nxcore_finished_workloads,22.0 +12,node_t002-nxcore_finished_workloads,24.0 +13,node_t002-nxcore_finished_workloads,26.0 +14,node_t002-nxcore_finished_workloads,28.0 +15,node_t002-nxcore_finished_workloads,30.0 +16,node_t002-nxcore_finished_workloads,32.0 +17,node_t002-nxcore_finished_workloads,34.0 +18,node_t002-nxcore_finished_workloads,36.0 +19,node_t002-nxcore_finished_workloads,38.0 +20,node_t002-nxcore_finished_workloads,40.0 +21,node_t002-nxcore_finished_workloads,42.0 +22,node_t002-nxcore_finished_workloads,44.0 +23,node_t002-nxcore_finished_workloads,46.0 +24,node_t002-nxcore_finished_workloads,48.0 +25,node_t002-nxcore_finished_workloads,50.0 +26,node_t002-nxcore_finished_workloads,52.0 +27,node_t002-nxcore_finished_workloads,54.0 +28,node_t002-nxcore_finished_workloads,56.0 +29,node_t002-nxcore_finished_workloads,58.0 +30,node_t002-nxcore_finished_workloads,60.0 +31,node_t002-nxcore_finished_workloads,62.0 +32,node_t002-nxcore_finished_workloads,64.0 +33,node_t002-nxcore_finished_workloads,66.0 +34,node_t002-nxcore_finished_workloads,68.0 +35,node_t002-nxcore_finished_workloads,70.0 +36,node_t002-nxcore_finished_workloads,72.0 +37,node_t002-nxcore_finished_workloads,74.0 +38,node_t002-nxcore_finished_workloads,76.0 +39,node_t002-nxcore_finished_workloads,78.0 +40,node_t002-nxcore_finished_workloads,80.0 +41,node_t002-nxcore_finished_workloads,82.0 +42,node_t002-nxcore_finished_workloads,84.0 +43,node_t002-nxcore_finished_workloads,86.0 +44,node_t002-nxcore_finished_workloads,88.0 +45,node_t002-nxcore_finished_workloads,90.0 +46,node_t002-nxcore_finished_workloads,92.0 +47,node_t002-nxcore_finished_workloads,94.0 +48,node_t002-nxcore_finished_workloads,96.0 +49,node_t002-nxcore_finished_workloads,98.0 +0,node_t002-nxcore_running_workloads,0.0 +1,node_t002-nxcore_running_workloads,0.0 +2,node_t002-nxcore_running_workloads,0.0 +3,node_t002-nxcore_running_workloads,0.0 +4,node_t002-nxcore_running_workloads,0.0 +5,node_t002-nxcore_running_workloads,0.0 +6,node_t002-nxcore_running_workloads,0.0 +7,node_t002-nxcore_running_workloads,0.0 +8,node_t002-nxcore_running_workloads,0.0 +9,node_t002-nxcore_running_workloads,0.0 +10,node_t002-nxcore_running_workloads,0.0 +11,node_t002-nxcore_running_workloads,0.0 +12,node_t002-nxcore_running_workloads,0.0 +13,node_t002-nxcore_running_workloads,0.0 +14,node_t002-nxcore_running_workloads,0.0 +15,node_t002-nxcore_running_workloads,0.0 +16,node_t002-nxcore_running_workloads,0.0 +17,node_t002-nxcore_running_workloads,0.0 +18,node_t002-nxcore_running_workloads,0.0 +19,node_t002-nxcore_running_workloads,0.0 +20,node_t002-nxcore_running_workloads,0.0 +21,node_t002-nxcore_running_workloads,0.0 +22,node_t002-nxcore_running_workloads,0.0 +23,node_t002-nxcore_running_workloads,0.0 +24,node_t002-nxcore_running_workloads,0.0 +25,node_t002-nxcore_running_workloads,0.0 +26,node_t002-nxcore_running_workloads,0.0 +27,node_t002-nxcore_running_workloads,0.0 +28,node_t002-nxcore_running_workloads,0.0 +29,node_t002-nxcore_running_workloads,0.0 +30,node_t002-nxcore_running_workloads,0.0 +31,node_t002-nxcore_running_workloads,0.0 +32,node_t002-nxcore_running_workloads,0.0 +33,node_t002-nxcore_running_workloads,0.0 +34,node_t002-nxcore_running_workloads,0.0 +35,node_t002-nxcore_running_workloads,0.0 +36,node_t002-nxcore_running_workloads,0.0 +37,node_t002-nxcore_running_workloads,0.0 +38,node_t002-nxcore_running_workloads,0.0 +39,node_t002-nxcore_running_workloads,0.0 +40,node_t002-nxcore_running_workloads,0.0 +41,node_t002-nxcore_running_workloads,0.0 +42,node_t002-nxcore_running_workloads,0.0 +43,node_t002-nxcore_running_workloads,0.0 +44,node_t002-nxcore_running_workloads,0.0 +45,node_t002-nxcore_running_workloads,0.0 +46,node_t002-nxcore_running_workloads,0.0 +47,node_t002-nxcore_running_workloads,0.0 +48,node_t002-nxcore_running_workloads,0.0 +49,node_t002-nxcore_running_workloads,0.0 +0,cluster_pending_workloads,0.0 +1,cluster_pending_workloads,0.0 +2,cluster_pending_workloads,0.0 +3,cluster_pending_workloads,0.0 +4,cluster_pending_workloads,0.0 +5,cluster_pending_workloads,0.0 +6,cluster_pending_workloads,0.0 +7,cluster_pending_workloads,0.0 +8,cluster_pending_workloads,0.0 +9,cluster_pending_workloads,0.0 +10,cluster_pending_workloads,0.0 +11,cluster_pending_workloads,0.0 +12,cluster_pending_workloads,0.0 +13,cluster_pending_workloads,0.0 +14,cluster_pending_workloads,0.0 +15,cluster_pending_workloads,0.0 +16,cluster_pending_workloads,0.0 +17,cluster_pending_workloads,0.0 +18,cluster_pending_workloads,0.0 +19,cluster_pending_workloads,0.0 +20,cluster_pending_workloads,0.0 +21,cluster_pending_workloads,0.0 +22,cluster_pending_workloads,0.0 +23,cluster_pending_workloads,0.0 +24,cluster_pending_workloads,0.0 +25,cluster_pending_workloads,0.0 +26,cluster_pending_workloads,0.0 +27,cluster_pending_workloads,0.0 +28,cluster_pending_workloads,0.0 +29,cluster_pending_workloads,0.0 +30,cluster_pending_workloads,0.0 +31,cluster_pending_workloads,0.0 +32,cluster_pending_workloads,0.0 +33,cluster_pending_workloads,0.0 +34,cluster_pending_workloads,0.0 +35,cluster_pending_workloads,0.0 +36,cluster_pending_workloads,0.0 +37,cluster_pending_workloads,0.0 +38,cluster_pending_workloads,0.0 +39,cluster_pending_workloads,0.0 +40,cluster_pending_workloads,0.0 +41,cluster_pending_workloads,0.0 +42,cluster_pending_workloads,0.0 +43,cluster_pending_workloads,0.0 +44,cluster_pending_workloads,0.0 +45,cluster_pending_workloads,0.0 +46,cluster_pending_workloads,0.0 +47,cluster_pending_workloads,0.0 +48,cluster_pending_workloads,0.0 +49,cluster_pending_workloads,0.0 +0,cluster_total_workloads,5.0 +1,cluster_total_workloads,7.0 +2,cluster_total_workloads,11.0 +3,cluster_total_workloads,13.0 +4,cluster_total_workloads,17.0 +5,cluster_total_workloads,19.0 +6,cluster_total_workloads,23.0 +7,cluster_total_workloads,25.0 +8,cluster_total_workloads,29.0 +9,cluster_total_workloads,31.0 +10,cluster_total_workloads,36.0 +11,cluster_total_workloads,38.0 +12,cluster_total_workloads,42.0 +13,cluster_total_workloads,44.0 +14,cluster_total_workloads,48.0 +15,cluster_total_workloads,50.0 +16,cluster_total_workloads,54.0 +17,cluster_total_workloads,56.0 +18,cluster_total_workloads,60.0 +19,cluster_total_workloads,62.0 +20,cluster_total_workloads,67.0 +21,cluster_total_workloads,69.0 +22,cluster_total_workloads,73.0 +23,cluster_total_workloads,75.0 +24,cluster_total_workloads,79.0 +25,cluster_total_workloads,81.0 +26,cluster_total_workloads,85.0 +27,cluster_total_workloads,87.0 +28,cluster_total_workloads,91.0 +29,cluster_total_workloads,93.0 +30,cluster_total_workloads,98.0 +31,cluster_total_workloads,100.0 +32,cluster_total_workloads,104.0 +33,cluster_total_workloads,106.0 +34,cluster_total_workloads,110.0 +35,cluster_total_workloads,112.0 +36,cluster_total_workloads,116.0 +37,cluster_total_workloads,118.0 +38,cluster_total_workloads,122.0 +39,cluster_total_workloads,124.0 +40,cluster_total_workloads,129.0 +41,cluster_total_workloads,131.0 +42,cluster_total_workloads,135.0 +43,cluster_total_workloads,137.0 +44,cluster_total_workloads,141.0 +45,cluster_total_workloads,143.0 +46,cluster_total_workloads,147.0 +47,cluster_total_workloads,149.0 +48,cluster_total_workloads,153.0 +49,cluster_total_workloads,155.0 +0,cluster_qos_data_production,1.0 +1,cluster_qos_data_production,1.0 +2,cluster_qos_data_production,1.0 +3,cluster_qos_data_production,1.0 +4,cluster_qos_data_production,1.0 +5,cluster_qos_data_production,1.0 +6,cluster_qos_data_production,1.0 +7,cluster_qos_data_production,1.0 +8,cluster_qos_data_production,1.0 +9,cluster_qos_data_production,1.0 +10,cluster_qos_data_production,1.0 +11,cluster_qos_data_production,1.0 +12,cluster_qos_data_production,1.0 +13,cluster_qos_data_production,1.0 +14,cluster_qos_data_production,1.0 +15,cluster_qos_data_production,1.0 +16,cluster_qos_data_production,1.0 +17,cluster_qos_data_production,1.0 +18,cluster_qos_data_production,1.0 +19,cluster_qos_data_production,1.0 +20,cluster_qos_data_production,1.0 +21,cluster_qos_data_production,1.0 +22,cluster_qos_data_production,1.0 +23,cluster_qos_data_production,1.0 +24,cluster_qos_data_production,1.0 +25,cluster_qos_data_production,1.0 +26,cluster_qos_data_production,1.0 +27,cluster_qos_data_production,1.0 +28,cluster_qos_data_production,1.0 +29,cluster_qos_data_production,1.0 +30,cluster_qos_data_production,1.0 +31,cluster_qos_data_production,1.0 +32,cluster_qos_data_production,1.0 +33,cluster_qos_data_production,1.0 +34,cluster_qos_data_production,1.0 +35,cluster_qos_data_production,1.0 +36,cluster_qos_data_production,1.0 +37,cluster_qos_data_production,1.0 +38,cluster_qos_data_production,1.0 +39,cluster_qos_data_production,1.0 +40,cluster_qos_data_production,1.0 +41,cluster_qos_data_production,1.0 +42,cluster_qos_data_production,1.0 +43,cluster_qos_data_production,1.0 +44,cluster_qos_data_production,1.0 +45,cluster_qos_data_production,1.0 +46,cluster_qos_data_production,1.0 +47,cluster_qos_data_production,1.0 +48,cluster_qos_data_production,1.0 +49,cluster_qos_data_production,1.0 diff --git a/simulation/scheduler_metrics.csv b/simulation/WaggleScheduler_task_log.csv similarity index 100% rename from simulation/scheduler_metrics.csv rename to simulation/WaggleScheduler_task_log.csv diff --git a/simulation/kubernetes/mywaggle.yaml b/simulation/kubernetes/mywaggle.yaml index 11b11d4..234d959 100644 --- a/simulation/kubernetes/mywaggle.yaml +++ b/simulation/kubernetes/mywaggle.yaml @@ -1,7 +1,7 @@ #env: waggle #workload: bitbrain -scheduler: WaggleScheduler -#scheduler: FairshareScheduler +# scheduler: WaggleScheduler +scheduler: FairshareScheduler dataloader: JobLoader # dataloader: SimpleLoader steps: 50 diff --git a/simulation/kubernetes/src/scripts/test_vis-interactive.ipynb b/simulation/kubernetes/src/scripts/test_vis-interactive.ipynb new file mode 100644 index 0000000..e69de29 diff --git a/simulation/kubernetes/src/scripts/visualization.py b/simulation/kubernetes/src/scripts/visualization.py index 1dd3de0..a80aec2 100644 --- a/simulation/kubernetes/src/scripts/visualization.py +++ b/simulation/kubernetes/src/scripts/visualization.py @@ -160,7 +160,7 @@ def preprocess_fair_scheduler_log(input_csv): # Compare them - metrics_df = compare_schedulers("./", ["FairScheduler"]) + metrics_df = compare_schedulers("./", ["FairShareScheduler"]) if metrics_df is not None: summarize_overall_scheduler_performance(metrics_df)