diff --git a/Dockerfile.base b/Dockerfile.base new file mode 100644 index 0000000..8cb97e6 --- /dev/null +++ b/Dockerfile.base @@ -0,0 +1,20 @@ +FROM debian:bookworm-slim + +RUN apt-get update && apt-get install -y --no-install-recommends \ + ca-certificates \ + curl \ + gnupg \ + lsb-release \ + wget +RUN wget -O- https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB | gpg --dearmor | tee /usr/share/keyrings/oneapi-archive-keyring.gpg > /dev/null +RUN wget -O- https://eci.intel.com/repos/gpg-keys/GPG-PUB-KEY-INTEL-ECI.gpg | tee /usr/share/keyrings/eci-archive-keyring.gpg > /dev/null +RUN wget -O- https://raw.githubusercontent.com/ros/rosdistro/master/ros.key | tee /usr/share/keyrings/ros-archive-keyring.gpg > /dev/null +RUN . /etc/os-release \ +&& echo $VERSION_CODENAME && \ +bash -c 'echo "deb [signed-by=/usr/share/keyrings/eci-archive-keyring.gpg] https://eci.intel.com/repos/$(source /etc/os-release && echo $VERSION_CODENAME) isar main" | tee /etc/apt/sources.list.d/eci.list' && \ +bash -c 'echo "deb-src [signed-by=/usr/share/keyrings/eci-archive-keyring.gpg] https://eci.intel.com/repos/$(source /etc/os-release && echo $VERSION_CODENAME) isar main" | tee -a /etc/apt/sources.list.d/eci.list' && \ +bash -c 'echo "deb [signed-by=/usr/share/keyrings/oneapi-archive-keyring.gpg] https://apt.repos.intel.com/oneapi all main" | tee /etc/apt/sources.list.d/oneAPI.list' && \ +bash -c 'echo -e "Package: intel-oneapi-runtime-*\nPin: version 2024.1.*\nPin-Priority: 1001" > /etc/apt/preferences.d/oneapi' && \ +bash -c 'echo "deb [signed-by=/usr/share/keyrings/oneapi-archive-keyring.gpg] https://apt.repos.intel.com/openvino/2024 ubuntu24 main" > /etc/apt/sources.list.d/intel-openvino-2024.list' && \ +bash -c 'echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/ros-archive-keyring.gpg] http://packages.ros.org/ros2/ubuntu $(source /etc/os-release && echo $VERSION_CODENAME) main" | tee /etc/apt/sources.list.d/ros2.list' +RUN apt-get update && apt-get install -y intel-cmt-cat diff --git a/conf/config.yaml b/conf/config.yaml index 997866f..f9b3d35 100644 --- a/conf/config.yaml +++ b/conf/config.yaml @@ -8,6 +8,14 @@ run: stressor: true tests_path: "tests" + resctrl: + - mask: "0x7ff0" + cpus: "3" + - mask: "0x7fff" + cpus: "0,2,4,6,8,10,12,14" + - mask: "0x000f" + cpus: "1,5,7,9,11,13,15" + cpus: t_core: "3" enable_turbo: false @@ -15,9 +23,13 @@ cpus: core_freq_mhz: 3.0 caterpillar: - n_cycles: 12000 + n_cycles: 7200 megabench: + no_cat_cores: "9,11,13,15" + no_cat_mask: "0x00ff" + cat_cores: "9" + cat_mask: "0x0003" caterpillar_cat: "${hydra:run.dir}/caterpillar_cat.csv" caterpillar_no_cat: "${hydra:run.dir}/caterpillar_no_cat.csv" cyclictest_cat: "${hydra:run.dir}/cyclictest_cat.csv" diff --git a/data/10-49-18/.hydra/config.yaml b/data/10-49-18/.hydra/config.yaml new file mode 100644 index 0000000..6d8f785 --- /dev/null +++ b/data/10-49-18/.hydra/config.yaml @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c175f9746449448cc4b6f26a56412fc076f58459761cbdd0f69119fe6bf70505 +size 949 diff --git a/data/10-49-18/.hydra/hydra.yaml b/data/10-49-18/.hydra/hydra.yaml new file mode 100644 index 0000000..698f469 --- /dev/null +++ b/data/10-49-18/.hydra/hydra.yaml @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:405b0e88af01dab1ec2baf3819dafdf0049bfba9d7551b3305c5f11255f42cb0 +size 3241 diff --git a/data/10-49-18/.hydra/overrides.yaml b/data/10-49-18/.hydra/overrides.yaml new file mode 100644 index 0000000..1bd6eaf --- /dev/null +++ b/data/10-49-18/.hydra/overrides.yaml @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:37517e5f3dc66819f61f5a7bb8ace1921282415f10551d2defa5c3eb0985b570 +size 3 diff --git a/data/10-49-18/caterpillar_cat.csv b/data/10-49-18/caterpillar_cat.csv new file mode 100644 index 0000000..94a63c6 --- /dev/null +++ b/data/10-49-18/caterpillar_cat.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:87187657662a5c6969354fffc091502cf699be8b86d6e45afff9bd808e8d7755 +size 544906 diff --git a/data/10-49-18/caterpillar_no_cat.csv b/data/10-49-18/caterpillar_no_cat.csv new file mode 100644 index 0000000..e8e90fa --- /dev/null +++ b/data/10-49-18/caterpillar_no_cat.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:71b71f4c1eff7836b99ce98dce90e24105782ea5f74d6634c2d45beac912f19b +size 544861 diff --git a/data/10-49-18/cpu_monitor.csv b/data/10-49-18/cpu_monitor.csv new file mode 100644 index 0000000..ff17ff6 --- /dev/null +++ b/data/10-49-18/cpu_monitor.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ad1155e27ebe56e47b5ae6606dfe3db5f615a4b666381c0529aac78c2eac7276 +size 17087919 diff --git a/data/10-49-18/cpustat_monitor.csv b/data/10-49-18/cpustat_monitor.csv new file mode 100644 index 0000000..ad09d66 --- /dev/null +++ b/data/10-49-18/cpustat_monitor.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:651a75462d3f4da2b1419c36caccfdb2ff9fd6b80a0330346548028a7168efff +size 136824803 diff --git a/data/10-49-18/cyclictest_cat.csv b/data/10-49-18/cyclictest_cat.csv new file mode 100644 index 0000000..b2da4a8 --- /dev/null +++ b/data/10-49-18/cyclictest_cat.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7699649d16291424984b59cd2028b7e7e6e4796809edd6f447cc204f7acedc29 +size 489677304 diff --git a/data/10-49-18/cyclictest_no_cat.csv b/data/10-49-18/cyclictest_no_cat.csv new file mode 100644 index 0000000..36db32e --- /dev/null +++ b/data/10-49-18/cyclictest_no_cat.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2c4110720b9b72c70b00bb26ba688a7084bd5706280b6c7c91c197282b688b78 +size 473390675 diff --git a/data/10-49-18/irq_monitor.csv b/data/10-49-18/irq_monitor.csv new file mode 100644 index 0000000..7b0822b --- /dev/null +++ b/data/10-49-18/irq_monitor.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b2bf6d0edfb2bcc127b708f31f87097dd939257221579225d9b9bfe89142affa +size 4216347483 diff --git a/data/10-49-18/main.log b/data/10-49-18/main.log new file mode 100644 index 0000000..e69de29 diff --git a/data/10-49-18/meminfo_monitor.csv b/data/10-49-18/meminfo_monitor.csv new file mode 100644 index 0000000..b797259 --- /dev/null +++ b/data/10-49-18/meminfo_monitor.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f81121ec9450a5eb4fceabe70d694a59e850a0f4967424a40a617f517494d885 +size 60241284 diff --git a/data/10-49-18/output.csv b/data/10-49-18/output.csv new file mode 100644 index 0000000..0a1d247 --- /dev/null +++ b/data/10-49-18/output.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0356891c2aae0f43d93a275f34a896ec4b4ee8e210e78818f91c1328ca83a972 +size 2613816697 diff --git a/data/10-49-18/softirq_monitor.csv b/data/10-49-18/softirq_monitor.csv new file mode 100644 index 0000000..eb55da2 --- /dev/null +++ b/data/10-49-18/softirq_monitor.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4d8f411ded07eefbdab3185b3cb7395750fe37bcf6e0305825f794422027a4f4 +size 109890696 diff --git a/data/10-49-18/sysinfo.json b/data/10-49-18/sysinfo.json new file mode 100644 index 0000000..334e554 --- /dev/null +++ b/data/10-49-18/sysinfo.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5b4dfbc8d20a4001aaa1ddba6c784cf1220cd544d602bd4b97d1ea86ed85949d +size 97586 diff --git a/data/15-12-05/.hydra/config.yaml b/data/15-12-05/.hydra/config.yaml new file mode 100644 index 0000000..6d8f785 --- /dev/null +++ b/data/15-12-05/.hydra/config.yaml @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c175f9746449448cc4b6f26a56412fc076f58459761cbdd0f69119fe6bf70505 +size 949 diff --git a/data/15-12-05/.hydra/hydra.yaml b/data/15-12-05/.hydra/hydra.yaml new file mode 100644 index 0000000..f5b0d71 --- /dev/null +++ b/data/15-12-05/.hydra/hydra.yaml @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:badd227ca763b813c76d814d4c97ec106dc8f7ab044fd707e1aa9905d573fec7 +size 3241 diff --git a/data/15-12-05/.hydra/overrides.yaml b/data/15-12-05/.hydra/overrides.yaml new file mode 100644 index 0000000..1bd6eaf --- /dev/null +++ b/data/15-12-05/.hydra/overrides.yaml @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:37517e5f3dc66819f61f5a7bb8ace1921282415f10551d2defa5c3eb0985b570 +size 3 diff --git a/data/15-12-05/caterpillar_cat.csv b/data/15-12-05/caterpillar_cat.csv new file mode 100644 index 0000000..03861a6 --- /dev/null +++ b/data/15-12-05/caterpillar_cat.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3ca05f4df3ce6e3ac8825c326fb1640be6a842f9ce499d3f238f0b100c428717 +size 544859 diff --git a/data/15-12-05/caterpillar_no_cat.csv b/data/15-12-05/caterpillar_no_cat.csv new file mode 100644 index 0000000..7a9872c --- /dev/null +++ b/data/15-12-05/caterpillar_no_cat.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:38961c537978b259b35ee4484f08e9b4c81abe2c7af7b0f6c66bd2e81f6a89b4 +size 544820 diff --git a/data/15-12-05/cpu_monitor.csv b/data/15-12-05/cpu_monitor.csv new file mode 100644 index 0000000..ee8a32f --- /dev/null +++ b/data/15-12-05/cpu_monitor.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:177a7fb085835751710b7d9681a6c9d619a62214e5a86154d21bafb9b76b8db9 +size 17124501 diff --git a/data/15-12-05/cpustat_monitor.csv b/data/15-12-05/cpustat_monitor.csv new file mode 100644 index 0000000..ccab1c8 --- /dev/null +++ b/data/15-12-05/cpustat_monitor.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7f131a7ecca717b7b79ef887c61a5530ce6182c1b7121e351a2f6b44862c3143 +size 136399575 diff --git a/data/15-12-05/cyclictest_cat.csv b/data/15-12-05/cyclictest_cat.csv new file mode 100644 index 0000000..459b4e4 --- /dev/null +++ b/data/15-12-05/cyclictest_cat.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:16458961d06b5770749e67c79064c879db1746adc9917ad362ebef6677af60b7 +size 489296718 diff --git a/data/15-12-05/cyclictest_no_cat.csv b/data/15-12-05/cyclictest_no_cat.csv new file mode 100644 index 0000000..1b7f90b --- /dev/null +++ b/data/15-12-05/cyclictest_no_cat.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:520cd76390c14b1683dd89659c665012c7843fc215940bc5ee2c9c50ac39927b +size 477765892 diff --git a/data/15-12-05/irq_monitor.csv b/data/15-12-05/irq_monitor.csv new file mode 100644 index 0000000..4e1cb6f --- /dev/null +++ b/data/15-12-05/irq_monitor.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c48ad5cc8c4c38505570377ce5c82a0e0a5c4c8a425c354bc984b3f710989ec7 +size 4225234828 diff --git a/data/15-12-05/main.log b/data/15-12-05/main.log new file mode 100644 index 0000000..e69de29 diff --git a/data/15-12-05/meminfo_monitor.csv b/data/15-12-05/meminfo_monitor.csv new file mode 100644 index 0000000..3ac7c80 --- /dev/null +++ b/data/15-12-05/meminfo_monitor.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:52b50e97e223f4b5d5a3c633902a5ae013ec2d1b476b07ac0ce5b8a4134c9aec +size 60396783 diff --git a/data/15-12-05/output.csv b/data/15-12-05/output.csv new file mode 100644 index 0000000..45bce88 --- /dev/null +++ b/data/15-12-05/output.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5c01f014d8069840455205087d62beb2a51f7c5be1961b16479c9ca96f680665 +size 2622488319 diff --git a/data/15-12-05/softirq_monitor.csv b/data/15-12-05/softirq_monitor.csv new file mode 100644 index 0000000..3734c78 --- /dev/null +++ b/data/15-12-05/softirq_monitor.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ed0cb6cad96e2902891db2a91fd081b0608767c6115447f8259f67239f1f5238 +size 110438409 diff --git a/data/15-12-05/sysinfo.json b/data/15-12-05/sysinfo.json new file mode 100644 index 0000000..7be703e --- /dev/null +++ b/data/15-12-05/sysinfo.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bb55193a240ab2723ad947e2ec19be063ee37ab7e6e15d49823b7d5b251da746 +size 98083 diff --git a/data/README.md b/data/README.md new file mode 100644 index 0000000..ea50c87 --- /dev/null +++ b/data/README.md @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d0e8c7267b15c39341f2d6ab489f2b671b5a36af1599f9a5e2dfb74457815e9a +size 313 diff --git a/main.py b/main.py index ff5ef29..7084332 100644 --- a/main.py +++ b/main.py @@ -175,15 +175,21 @@ def run_test( docker_cmd = self._build_base_docker_command(test, t_core) if test == "caterpillar": - return self._run_caterpillar(docker_cmd, l3_cache_mask, t_core) + return self._run_caterpillar( + docker_cmd, l3_cache_mask, t_core, self.config.benchmark_output_path + ) elif test == "cyclictest": - return self._run_cyclictest(docker_cmd, l3_cache_mask, t_core) + return self._run_cyclictest( + docker_cmd, l3_cache_mask, t_core, self.config.benchmark_output_path + ) elif test == "codesys-jitter-benchmark": return self._run_codesys_jitter(docker_cmd, l3_cache_mask, t_core) elif test == "codesys-opcua-pubsub": return self._run_codesys_opcua(docker_cmd, l3_cache_mask, t_core) elif test == "iperf3": return self._run_iperf3(docker_cmd, l3_cache_mask, t_core) + elif test == "mega-benchmark": + return self._run_megabench(docker_cmd, t_core) else: print(f"Error: Test '{test}' is not implemented") return 1 @@ -208,14 +214,14 @@ def _build_base_docker_command(self, test: str, t_core: str) -> List[str]: ] def _run_caterpillar( - self, base_cmd: List[str], l3_cache_mask: str, t_core: str + self, base_cmd: List[str], l3_cache_mask: str, t_core: str, path: str ) -> int: """Run caterpillar test.""" cmd = base_cmd + [ "caterpillar:latest", "/bin/bash", "-c", - f'stdbuf -oL -eL /usr/sbin/rdtset -t "l3={l3_cache_mask};cpu={t_core}" ' + f"stdbuf -oL -eL /usr/sbin/rdtset {self._compose_rdtset()} " f"-c {t_core} -k /opt/benchmarking/caterpillar/caterpillar -c {t_core} -s {self.config.caterpillar.n_cycles}", ] @@ -225,7 +231,7 @@ def _run_caterpillar( pbar = tqdm(total=self.config.caterpillar.n_cycles) parser = build_caterpillar_parser() - with open(self.config.benchmark_output_path, "w") as f: + with open(path, "w") as f: prelude = parser.prelude() if prelude is not None: f.write(prelude) @@ -240,7 +246,7 @@ def _run_caterpillar( return process.wait() def _run_cyclictest( - self, base_cmd: List[str], l3_cache_mask: str, t_core: str + self, base_cmd: List[str], l3_cache_mask: str, t_core: str, path: str ) -> int: """Run cyclictest.""" cmd = base_cmd + [ @@ -248,7 +254,7 @@ def _run_cyclictest( "/bin/bash", "-c", f'stdbuf -oL -eL /usr/sbin/rdtset -t "l3={l3_cache_mask};cpu={t_core}" -c {t_core} ' - f"-k /usr/bin/cyclictest --threads -t 4 -p 99 -l 100000 -d 1 -D 0 -i 100000 -a {t_core}", + f"-k /usr/bin/cyclictest --threads -t 1 -p 99 -l 100000 -d 1 -D 0 -i 100000 -a {t_core}", ] print(" ".join(cmd)) @@ -258,7 +264,7 @@ def _run_cyclictest( pbar = tqdm(total=400000) last_c_value = 0 parser = build_cyclictest_parser() - with open(self.config.benchmark_output_path, "w") as f: + with open(path, "w") as f: prelude = parser.prelude() if prelude is not None: f.write(prelude) @@ -447,35 +453,36 @@ def _run_iperf3(self, base_cmd: List[str], l3_cache_mask: str, t_core: str) -> i return result.returncode - def _run_megabench(self, base_cmd: List[str]) -> int: - cmd = base_cmd + [ - "mega-benchmark:latest", - "/bin/bash", - "-c", - f"stdbuf -oL -eL /opt/benchmarking/mega-benchmark/48_hour_benchmark.sh", - ] - print(" ".join(cmd)) - process = self._run_interactive_command(cmd) - assert process.stdout is not None + def _run_megabench(self, base_cmd: List[str], t_core: str) -> int: + self._run_caterpillar( + base_cmd, + self.config.megabench.no_cat_mask, + self.config.megabench.no_cat_cores, + self.config.megabench.caterpillar_no_cat, + ) - with open(self.config.megabench.caterpillar_cat, "w") as caterpillar_cat, open( - self.config.megabench.caterpillar_no_cat, "w" - ) as caterpillar_no_cat, open( - self.config.megabench.cyclictest_cat, "w" - ) as cyclictest_cat, open( - self.config.megabench.cyclictest_no_cat, "w" - ) as cyclictest_no_cat, open( - self.config.benchmark_output_path, "w" - ) as raw: - parser = MegabenchParser( - caterpillar_cat, caterpillar_no_cat, cyclictest_cat, cyclictest_no_cat - ) - for line in process.stdout: - print(line) - parser.parse(line) - raw.write(line) + self._run_caterpillar( + base_cmd, + self.config.megabench.cat_mask, + self.config.megabench.cat_cores, + self.config.megabench.caterpillar_cat, + ) - return process.wait() + self._run_cyclictest( + base_cmd, + self.config.megabench.no_cat_mask, + self.config.megabench.no_cat_cores, + self.config.megabench.cyclictest_no_cat, + ) + + self._run_cyclictest( + base_cmd, + self.config.megabench.cat_mask, + self.config.megabench.cat_cores, + self.config.megabench.cyclictest_cat, + ) + + return 0 def _start_stressor(self) -> None: """Start the stressor container if not already running.""" @@ -502,6 +509,13 @@ def _start_stressor(self) -> None: except subprocess.CalledProcessError: print("Warning: Could not check stressor status") + def _compose_rdtset(self) -> str: + ans = "" + for group in self.config.run.resctrl: + ans += f' -t "l3={group.mask};cpu={group.cpus}"' + + return ans + @staticmethod def _run_command(cmd: List[str]) -> CompletedProcess | None: """Run a command and return its exit code.""" diff --git a/notebook/01_Cyclictest_analysis.ipynb b/notebook/01_Cyclictest_analysis.ipynb new file mode 100644 index 0000000..fc28fe5 --- /dev/null +++ b/notebook/01_Cyclictest_analysis.ipynb @@ -0,0 +1,750 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9fb0830f-3a71-4ab0-b078-9e8177df6a0d", + "metadata": {}, + "source": [ + "# Megabenchmark Analysis (RT Evaluation)\n", + "\n", + "## Overview\n", + "\n", + "This Jupyter Notebook performs an analytical evaluation of **Cyclictest for Real-Time (RT)** test results. \n", + "\n", + "---\n", + "\n", + "---\n", + "\n", + "\n", + "## Input Data Description\n", + "\n", + "The benchmark generates several monitoring files in the **output directory**, each containing time-synchronized measurements from different subsystems.\n", + "\n", + "| File | Description |\n", + "|------|--------------|\n", + "| `output.csv` | csv file containing test results |\n", + "| `cpu_monitor.csv` | CPU temperature, frequency, and utilization per core. |\n", + "| `cpustat_monitor.csv` | Detailed CPU statistics (user/system/idle times, context switches). |\n", + "| `irq_monitor.csv` | IRQ activity counts per CPU core over time. |\n", + "| `softirq_monitor.csv` | Kernel-level soft interrupt counts per CPU core. |\n", + "| `meminfo_monitor.csv` | Memory pressure and allocation statistics. |\n", + "| `sysinfo.json` | System configuration and metadata (CPU topology, kernel version, etc.). |\n", + "\n", + "---\n", + "\n", + "## Structure of `output.csv`\n", + "\n", + "| Short | Explanation |\n", + "|--------|----------------------------------------------------------------------|\n", + "| `timestamp` | Timestamp of the measurement |\n", + "| `T` | Thread: Thread index and thread ID |\n", + "| `P` | Priority: RT thread priority |\n", + "| `I` | Interval: Intended wake up period for the latency measuring threads |\n", + "| `C` | Count: Number of times the latency was measured (iteration count) |\n", + "| `Min` | Minimum: Minimum latency that was measured |\n", + "| `Act` | Actual: Latency measured during the latest completed iteration |\n", + "| `Avg` | Average: Average latency that was measured |\n", + "| `Max` | Maximum: Maximum latency that was measured |\n", + "\n", + "\n", + "## How can I run analysis? \n", + "\n", + "You need to specify **folder** path in the next cell and run cells below, you will get report automatically then" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "31312697-eb98-46b3-b9a8-0140ccc09b6a", + "metadata": {}, + "outputs": [], + "source": [ + "cyclictest_data_path = \"../data/06-38-03\"" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b8c1f4fe-6a56-4d98-9aee-27d16fddc6c1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m\u001b[36m05-19-35\u001b[m\u001b[m/ \u001b[1m\u001b[36m06-38-03\u001b[m\u001b[m/ \u001b[1m\u001b[36m10-49-18\u001b[m\u001b[m/ \u001b[1m\u001b[36m15-12-05\u001b[m\u001b[m/ README.md\n" + ] + } + ], + "source": [ + "ls ../data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "16dc4aed-49e1-45e0-a171-ffebe46f458d", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns \n", + "import sys\n", + "import os \n", + "import yaml\n", + "import json\n", + "\n", + "sys.path.append(os.path.abspath(os.path.join(os.getcwd(), '..')))\n", + "from src.plots import *\n", + "\n", + "\n", + "output_csv_path = f\"{cyclictest_data_path}/output.csv\"\n", + "cpu_monitor_path = f\"{cyclictest_data_path}/cpu_monitor.csv\"\n", + "irq_monitor_path = f\"{cyclictest_data_path}/irq_monitor.csv\"\n", + "meminfo_path = f\"{cyclictest_data_path}/meminfo_monitor.csv\"\n", + "hydra_conf_path = f\"{cyclictest_data_path}/.hydra/config.yaml\"\n", + "sysinfo_path = f\"{cyclictest_data_path}/sysinfo.json\"" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3b8e2b9f-91cf-4520-a327-f44eb54f2e5a", + "metadata": {}, + "outputs": [], + "source": [ + "with open(hydra_conf_path, 'r') as stream:\n", + " hydra_conf = yaml.safe_load(stream)\n", + "\n", + "with open(sysinfo_path) as f:\n", + " sysinfo = json.load(f)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "0ef74c07-98b3-4677-802e-11bfd0dbc9c8", + "metadata": {}, + "outputs": [], + "source": [ + "assert hydra_conf['run']['command'] == 'cyclictest', \"This notebook is designed to analyze cyclictest!\"" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "5e25b2b1-0fde-4ec7-992f-419d7857574b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Analyzing cyclictest\n", + "With isolated core(s): 3\n", + "Cache mask: 0x7ff0\n", + "System is stessed?: True\n", + "Kernel: Linux zededa-rt 6.12.8-intel-ese-experimental-lts-rt #1 SMP PREEMPT_RT Thu, 28 Aug 2025 10:46:22 +0000 x86_64 GNU/Linux\n", + "Kernel CMD: BOOT_IMAGE=/vmlinuz-6.12.8-intel-ese-experimental-lts-rt root=/dev/mapper/zededa--rt--vg-root ro BOOT_IMAGE=/vmlinuz-6.12.8-intel-ese-experimental-lts-rt root=/dev/mapper/zededa--rt--vg-root ro debug=all nosplash console=ttyS0,115200 console=tty0 clocksource=tsc tsc=reliable art=virtallow no_ipi_broadcast=1 nosoftlockup efi=runtime numa_balancing=disable hugepages=1024 audit=0 nmi_watchdog=0 irqaffinity=0,1 mce=off hpet=disable rcupdate.rcu_cpu_stall_suppress=1 rcu_nocb_poll noht isolcpus=3,5,7,9 rcu_nocbs=3,5,7,9 nohz_full=3,5,7,9 intel_pstate=disable intel.max_cstate=0 intel_idle.max_cstate=0 processor.max_cstate=0 processor_idle.max_cstate=0 i915.force_probe=* i915.enable_rc6=0 i915.enable_dc=0 i915.disable_power_well=0 igb.blacklist=no console=ttyS0,115200 console=tty0 clocksource=tsc tsc=reliable art=virtallow no_ipi_broadcast=1 nosoftlockup efi=runtime numa_balancing=disable hugepages=1024 audit=0 nmi_watchdog=0 irqaffinity=0 mce=off hpet=disable rcupdate.rcu_cpu_stall_suppress=1 rcu_nocb_poll noht isolcpus=1,3 rcu_nocbs=1,3 nohz_full=1,3 intel_pstate=disable intel.max_cstate=0 intel_idle.max_cstate=0 processor.max_cstate=0 processor_idle.max_cstate=0 i915.force_probe=* i915.enable_rc6=0 i915.enable_dc=0 i915.disable_power_well=0 igb.blacklist=no\n", + "\n" + ] + } + ], + "source": [ + "print(f\"\"\"\n", + "Analyzing {hydra_conf['run']['command']}\n", + "With isolated core(s): {hydra_conf['run']['t_core']}\n", + "Cache mask: {hydra_conf['run']['llc_cache_mask']}\n", + "System is stessed?: {hydra_conf['run']['stressor']}\n", + "Kernel: {sysinfo['kernel']['uname']}\n", + "Kernel CMD: {sysinfo['kernel']['cmdline']}\n", + "\"\"\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "2a5791cd-f8c7-4c21-9e98-c497f935c63f", + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Sequence, Tuple\n", + "import re\n", + "\n", + "def parse_kernel_cmdline(cmdline: str, params: Sequence[str]) -> dict[str, str]:\n", + " results = {}\n", + "\n", + " for param in params:\n", + " # Find all matches like param=value\n", + " matches = re.findall(rf'\\b{param}=([^ ]+)', cmdline)\n", + "\n", + " if not matches:\n", + " print(f\"{param}: not found\")\n", + " results[param] = None\n", + " elif len(matches) == 1:\n", + " print(f\"{param}: {matches[0]}\")\n", + " results[param] = matches[0]\n", + " else:\n", + " print(f\"WARNING: multiple occurrences of '{param}' found! Using latest value.\")\n", + "\n", + " \n", + " for value in matches:\n", + " print(f\" -> {param}={value}\")\n", + " latest = matches[-1]\n", + " print(f\"Using latest: {param}={latest}\")\n", + " results[param] = latest\n", + "\n", + " return results" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "778058ea-821f-48e6-afe9-91e17ebf4196", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING: multiple occurrences of 'rcu_nocbs' found! Using latest value.\n", + " -> rcu_nocbs=3,5,7,9\n", + " -> rcu_nocbs=1,3\n", + "Using latest: rcu_nocbs=1,3\n", + "WARNING: multiple occurrences of 'nohz_full' found! Using latest value.\n", + " -> nohz_full=3,5,7,9\n", + " -> nohz_full=1,3\n", + "Using latest: nohz_full=1,3\n", + "WARNING: multiple occurrences of 'isolcpus' found! Using latest value.\n", + " -> isolcpus=3,5,7,9\n", + " -> isolcpus=1,3\n", + "Using latest: isolcpus=1,3\n" + ] + } + ], + "source": [ + "# check 1: selected for tests CPUs are isolated\n", + "\n", + "params = parse_kernel_cmdline(sysinfo['kernel']['cmdline'], [\"rcu_nocbs\", \"nohz_full\", \"isolcpus\"])\n", + "\n", + "for cpu in hydra_conf['run']['t_core'].split(','):\n", + " for k, v in params.items():\n", + " assert cpu in v, f\"{k} parameter of kernel cmdline is missing CPU {cpu} which is used in tests\"" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "3e3d8969-a366-48b8-aa6c-c85c11e68ce2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING: multiple occurrences of 'intel_pstate' found! Using latest value.\n", + " -> intel_pstate=disable\n", + " -> intel_pstate=disable\n", + "Using latest: intel_pstate=disable\n", + "WARNING: multiple occurrences of 'intel.max_cstate' found! Using latest value.\n", + " -> intel.max_cstate=0\n", + " -> intel.max_cstate=0\n", + "Using latest: intel.max_cstate=0\n", + "WARNING: multiple occurrences of 'intel_idle.max_cstate' found! Using latest value.\n", + " -> intel_idle.max_cstate=0\n", + " -> intel_idle.max_cstate=0\n", + "Using latest: intel_idle.max_cstate=0\n", + "WARNING: multiple occurrences of 'processor.max_cstate' found! Using latest value.\n", + " -> processor.max_cstate=0\n", + " -> processor.max_cstate=0\n", + "Using latest: processor.max_cstate=0\n", + "WARNING: multiple occurrences of 'processor_idle.max_cstate' found! Using latest value.\n", + " -> processor_idle.max_cstate=0\n", + " -> processor_idle.max_cstate=0\n", + "Using latest: processor_idle.max_cstate=0\n" + ] + } + ], + "source": [ + "# check 2 p-state and c-state are disabled\n", + "\n", + "params = parse_kernel_cmdline(sysinfo['kernel']['cmdline'], [\"intel_pstate\", \"intel.max_cstate\", \"intel_idle.max_cstate\", \"processor.max_cstate\", \"processor_idle.max_cstate\"])\n", + "\n", + "assert params[\"intel_pstate\"] == \"disable\", \"Intel p-state must be disabled\"\n", + "assert params[\"intel.max_cstate\"] == \"0\", \"Intel c-state must be disabled\"\n", + "assert params[\"intel_idle.max_cstate\"] == \"0\", \"Intel c-state must be disabled\"\n", + "assert params[\"processor.max_cstate\"] == \"0\", \"Intel c-state must be disabled\"\n", + "assert params[\"processor_idle.max_cstate\"] == \"0\", \"Intel c-state must be disabled\"" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "53f0e15d-8b41-4222-b7b5-f53804794b90", + "metadata": {}, + "outputs": [], + "source": [ + "# check 3: hypter-threading is disabled\n", + "\n", + "assert \" noht \" in sysinfo['kernel']['cmdline']" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "fb2e191b-bf49-4493-8fea-640604480324", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "heat_threshold = 90\n", + "cpu_monitor_df = pd.read_csv(cpu_monitor_path)\n", + "\n", + "\n", + "### Check 1: Packages do not exceed threshold\n", + "\n", + "packages = [col for col in cpu_monitor_df.columns if col.startswith(\"Package id\")]\n", + "\n", + "for pkg in packages:\n", + " assert cpu_monitor_df[pkg].max() <= heat_threshold\n", + "\n", + "### Check 2: CPUs do not exceed threshold\n", + "\n", + "cpus = [col for col in cpu_monitor_df.columns if col.startswith(\"CPU\")]\n", + "\n", + "for cpu in cpus:\n", + " assert cpu_monitor_df[cpu].max() <= heat_threshold\n", + "\n", + "### Check 3: plot average temperature\n", + "\n", + "plot_avg_cpu_temp(cpu_monitor_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "ded56946-b4e8-48ec-943a-1a8252869331", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "irq_monitor_df = pd.read_csv(irq_monitor_path)\n", + "mask = irq_monitor_df['description'].str.contains('APIC|MSIX', case=False, regex=True, na=False)\n", + "global_irqs = irq_monitor_df[mask]\n", + "\n", + "for cpu in hydra_conf['run']['t_core'].split(','):\n", + " assert global_irqs[f'CPU{cpu}'].sum() == 0\n", + "\n", + "## Bonus check: plot cumsum of CPU interrupts for each CPU\n", + "\n", + "cpu_cols = [col for col in irq_monitor_df.columns if col.startswith('CPU')]\n", + "cpu_df = global_irqs[cpu_cols]\n", + "cpu_cumsum_df = cpu_df.cumsum()\n", + "\n", + "cpu_long_df = cpu_cumsum_df.reset_index().melt(id_vars='index', var_name='CPU', value_name='Cumulative Value')\n", + "\n", + "# Plot with seaborn\n", + "plt.figure(figsize=(12, 6))\n", + "sns.lineplot(data=cpu_long_df, x='index', y='Cumulative Value', hue='CPU', linewidth=2)\n", + "\n", + "plt.title('Cumulative Sum of system interrruptions per CPU')\n", + "plt.xlabel('Sample Index')\n", + "plt.ylabel('Cumulative Value')\n", + "plt.legend(title='CPU', bbox_to_anchor=(1.05, 1), loc='upper left')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "8955dd5c-f272-4b0d-a493-4dae6dafcf31", + "metadata": { + "scrolled": true + }, + "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" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/pabramov/dev/rt-tools/src/plots.py:290: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `y` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.barplot(x=stds.values, y=stds.index, palette=\"crest\")\n" + ] + }, + { + "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" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9wAAAHqCAYAAAD27EaEAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQWc3ET7x5+s3F3daEuNQnFrseLuUJw/zou7wwtFXqy4u1uLtHiBoi2FGm2hLtTdvb2ey+7m/3mymWQymWTn7nK3cs/387n2bnd2Mplkd+c3j2m6rutAEARBEARBEARBEESghILtjiAIgiAIgiAIgiAIEtwEQRAEQRAEQRAEUU+QhZsgCIIgCIIgCIIg6gES3ARBEARBEARBEARRD5DgJgiCIAiCIAiCIIh6gAQ3QRAEQRAEQRAEQdQDJLgJgiAIgiAIgiAIoh4gwU0QBEEQBEEQBEEQ9QAJboIgCIIgCIIgCIKoB0hwEwRBEDnDgAEDQNM0WLp0qXLbSZMmNcjYcmEujz76aOOHgc9hG2xLZC6JRAL22msvePLJJyHTGDlypHEP4f+pmD17NkQiEfj3338bZGwEQRBBQIKbIAiinoQK/vz111+u53Vdh27duhnPn3baaWmZ/0cffdQao/jzzjvvQC7x1ltv1YsgXLNmDdx3331wzDHHQIsWLVKKhnHjxsHhhx8OTZs2hW233RZuu+02KCkpCfyewx8UJV26dIErrrgCVq1aBbnOL7/8Ypx3586dDXFJOPn8889hxYoVcMstt9TonsHfvT4n+B9sF+RnzaBBg+CVV15xPb7HHntAnz594OGHH6ZLTBBE1hBJ9wAIgiBylYKCAmPhiCKLZ9SoUbBy5UrIz8+HdPP2229D8+bNHY8ddNBBkK385z//gQsvvNAxtyi4t9lmG19RUBvmzZsHzz77LOy8886w9957w/jx4z3bTps2DY477jjYfffd4aWXXjKu/wsvvAALFiyAX3/9NbAxPfbYY7DDDjtARUUF/P3334aowk0ftAji/Rg03bt3h/LycohGo5BOBg4cCNtvv71hcf/zzz/h+OOPT+t4Mo3nn3/eeF+0atWqRvfM9ddf75jLJUuWGGL3uuuugyOOOMJ6fMcdd6z1Zw2+Fu+hvLw863H83MTj33HHHa5+brjhBjj11FNh0aJFSsclCIJINyS4CYIg6glcFH799dfw2muvGdYjfjG5//77w8aNG9M+9//3f/9niFEVSktLoVmzZpDJhMNh46chwGu4adMmaNu2LXzzzTdw3nnnebZ94IEHoE2bNoYFvGXLlsZjKBCvvfZaGDZsGJx44omBjOmUU06BAw44wPj9mmuuMa4tbgoMGTIEzj//fAgatFLWh5CvCXhf/vDDD/D0009D//79DfHd0IIbvVZQsDZp0gQyjalTp8L06dPhxRdfrNU9c8ghh1htMfwCBTc+dumllwb2WVOTewivLb6XPv74Y2OzgCAIItMhl3KCIIh64qKLLjIE2e+//249VlVVZYiziy++WPoadIdFV8o999zTWIR27NjRsDJt2bLF0Q7FGrqjo4DDxTIu9NHKylyaBw8ebPyNfaAwxEV3TWDupmiNv+mmm6BDhw7QtWtX63m0yqKFCwU4ulOjm+esWbNc/cydO9dYaKMoxbHgWHEhn4r99tsPzjnnHMdjeD44phkzZliPffnll8Zjc+bMkcYd4zzhuPA8mBsrH4OMVFZWwl133QXt27c3zufss8+GDRs2pBwjnjeeVyqKioqMewAFChPbyGWXXWZY/L766ivrseLiYsOqh+NGKz3O+wknnABTpkyB2sCskGgN5EErMLt+rVu3hjPPPNOaw5ogi+FGTwI8L3RLPuuss4zfcW7vvvtuiMfjjtfj+wO9EnBecByXX365IQ5rEhf+3XffGRZS3PBAKy7e+yh+GRi7jG7/svcaulDj/Vnb99/QoUOt99+7775rPIei/9hjjzWuHV5DdING667s+OhujW7wGGaAY8QYZexb9MYoLCw07gsMRcE+d9ppJ0MUq7jPf//994b1+Mgjj6zTPdNQMdz4/vz5559h2bJl1nsW54SB3hTYBjdZCIIgsgES3ARBEPUELhLREoTxk7xQ3bp1qyEMZODi/p577oHDDjsMXn31VbjyyisNi91JJ50E1dXVjrYLFy40hPvpp59uWPdQFODv2P7OO+80BF6/fv2MhTNaqmSL882bNxuWdvYjCgsU2ygC0KqF8crIp59+aghsFFK46H/ooYeMNug6zyfYQqF78MEHG0IOX4sWNhR4KMJQJKVa9PPx7zhO7C8UCsGYMWOsx/F3FHPoqi0DxRNuFOy2227GuPHnf//7n6PNrbfeaoi8Rx55BG688Ub48ccfHbGudWXmzJkQi8UsKyIDRdA+++zj2AxBd1kUZ+eee67hCo8iFcVcbcQwwq4HWgQZw4cPN+6n9evXG4IPNxswvhzvOZVkcyqgsMZjtGvXznCdP+qoo4zr/95771lt8H7E+xXfHyi0MaEXxsXj7zUB73cUqxgXj+8r3LTAa8i44IILYPTo0bB27VrH6/D+Wr16teO9WJP3H4YU4KYabohgW7yWCF4/dLVHrwY8ZxTJ+D568803Ha+///77jfcn3hfo8o2hCXgctNjzlJWVGfP32WefGZs06DGD48PX47VLBV5b3HRQdfuX3TNBkOqzhoHvT5xLtIaz96wYz42biOhyjptZBEEQGY9OEARBBEr//v11/HidOHGi/sYbb+gtWrTQy8rKjOfOO+88/ZhjjjF+7969u96nTx/rdWPGjDFeN3DgQEd/v/32m+txfC0+Nm7cOOuxoUOHGo81adJEX7ZsmfX4u+++azw+YsQI67FHHnnEeEz8wX75czj88MP1WCxmva64uFhv3bq1fu211zrGuHbtWr1Vq1aOx4877jh977331isqKqzHEomEfuihh+o777yz7xx+/fXXxvFnz55t/D1kyBA9Pz9fP+OMM/QLLrjAatezZ0/97LPPds39kiVLrMf23HNP/aijjnIdg7U9/vjjjXEx7rzzTj0cDuuFhYW+Y5SNl59j8bnRo0e7nsP7Ydttt7X+xjm8+eablY8rnsvw4cP1DRs26CtWrNC/+eYbvX379sa84d+MffbZR+/QoYO+adMm67Hp06froVBIv+yyy3znEueRn0t8DttgW8bll19uPPbYY485xrjvvvvq+++/v/X3t99+a7R75ZVXrMfi8bh+7LHHuvr0Yt26dXokEtHff/996zG8v84880zr73nz5hn9vf76647X3nTTTXrz5s2t92Zt3n/4nAjrj+ekk07Se/To4Xi/4LjPOussR7tHH33U6BfnkPH444/rzZo10+fPn+9oe9999xn36fLly33nqGvXrvq5555bp3uGgZ9pqtdG9bMG3zPiewc/F9nzMgYNGmS85p9//lEeB0EQRLogCzdBEEQ9gpZldHf96aefDMsb/u/lTo7x3pjUCC1mvCUIrTloTR4xYoSjPbqq8vGVLNkZurNut912rscXL17sOua3335ruDuzH7Tm8WCMMR8TjW3QvRUte/wYsQ0eh40RrVnotoznj+fN2qELMVrxMFmYX/Zs5taKlklmye7du7cxN8zCjeNAKxefvKk2YAIodFvlj40WWnRpDQK8/ogsSR66LbPnEXSr/ueffwzLa23A+Fa0+KNVFV2l0aMAXfhZOABakDGBG7os8+7wPXv2NOYWs30HBVrreXBe+Xvwt99+M6yueI8x0IPh5ptvVj7GF198YbwGPQIYeG+iJwmzoO6yyy6GxRTDDxh4fTG0Ay3sLO66pu8/TDSG97IIH8eN3izYB1qo8dzxb+SPP/4wvB7Q8i16W4jguHDu0OLMjwuvNZ4He494ge85P2t1qnsmKFJ91tQEdj6ZkAeDIAgiFZQ0LQX4RYauXpMnTzYWKugGie6QNQFjvNBVEd0hcXGFcVToZsbHJBEEkZvgQhYXtJgoDV1DcYHMx4zyoAjFBTnGfspAF2AeXlQjLAMxLpxlj8tcOPHzyC9pGooKcYxM1MtgMcro7o6JpNDdHH+8zgdjaGVg7Cy62KK4Rjdf/B/dhnG8KEpQvKCbNbol11Vwi/PIFvNeLq81hQkwjBUXERNtPffcc4ZLNV5DFHqYeA/diHv06KF0LHRbRoGJ99FHH31kfIfxQp9tIuy6666u16JbPn5fBZEcD7/r8N4X55WfUxxLp06djPhlHoxPVgXdrA888EBDVOIPsu+++xq5ElCo4mYKcytHF2/c5MF7DuOF8f7Dx2v7/hPfG4yxY8ca3/mYtR7f8zzYP74f2XUQzxU3QURxjOPCvAXifHqNSwa+F2t7zwRFqs+amsDOh98oIwiCyFRIcKcAFx69evWCq666ypXARwUsoYHJaDDOCndz8QsNYyuxr9omwSEIIrtAizZa8TCGFDMCoxVTBopHXOx7WX7EBbdXNm6vx/0W3V6IWZdZHDjGVWLMrAjLxs7aYQyyzAqoIqwwJhwtgWgBxk1PjCPHWFScPxTgKLjR8ogCqy4EOV8yUFQiuGkrgo9h0iwGegTgBgJu7mL2ctzwxTh5TASG904qUHyyWHHcHMY5xPsP443Fkkz1SUNkikchOnHiRON33JwRwfcRL7gx5hlFOCYfw0R1KHxPPvnkWr//ZBnJMV8Cln/DnAFY/g03TjBWHz0HXn755VrVCMfXoNW9b9++0udRLPuBcfR+m0eZcs/UBHY+QQl4giCI+oQEdwpwgeO3yEGLBSb4wKQv6N6Ii0FcHLEsuLhIRIvWE088Ybi9sQUoinBMwJLu2qUEQdQ/mPUarbRY45Z3axXBmrKY0AoTImVieSGE1b1FYeJXeolZZPEzrrYlmlB4YsZndBvGz9FDDz3U+BxFQcAENz6WStyl2wqG3wu4EYEllfjSXGiFRfdusVwXCnR0NcYftF5ixnZMKKYiuHlwXjCZHnoGvPHGG0biOkzmhaCYkmWURwHTUKXfcCzopo1WYN7Kjd4RKqAwxvsLN3/EewATomFyseXLlxseDGiNRmGJ7z9MiIcbGCgueUtuEO8/TNaG6wJ0yeY9J0R3dHYd8Fx5Szla6UVxjOMqKSmp9fsIxT9u/tf2nkkHqd6zeD74WZBqs4EgCCIToBjuOoJf3Og2hgtCdPnCsiS4Y87cLtElEL8UcNGIC0a0cOPiAL84SWwTROMArUSYuRgzQmPMqBcovPBz4vHHH3c9h/GeuKmXbtBajW7jTz31lCtrM8LKaaEgx41HLJUks+yqlN1iruK4iYkxxsw1Hh9HyzcKWBV3chSQ6Zw7HDd+5qP7M8azM/C7AIUUq9/NviN4cB7RAi5zR1cBrwEKTczyjO7rKOYxnhlrGPNzgrHwaFFHF/aGgmX+fv/99x3WXDGbt5/gxuuP1msM0+B/MNM4wlcIwHa46YVu0xj7y7uTB/X+Y8Kf947Aa4prAB60guMmjFguDEWuCI4L1xno7i+CY8Kx+YF5HvD6qt5D4j2TDvA9K74XeNCYgaXb2GcCQRBEJkMW7jqAO+f4JYr/M5dAtF5jIhh8HBekuHONixj8wkQLF36Z45dfkIlpCILIfFRKHWFiJfycQAsTWj5PPPFEY2MON/DQFRZLD3nFfzcUKLZRJGDtZLS8YkkldLXFz0GsnYvWQSYaUDihNRrrZ6NLPVq9161bZ4iHlStXGqW4/ECXc3RbR2ssn0wKY0Hvvfde43cVwY0bnzhm9DTCPlHEesWg1xTsE2E1yFFEs3JmDz74oNUOLdRojcdrjG7OeP6YywOvMXNrRjGOiarwGmMoE27UoMUV3aaxbW1B8YmiHutaYyIzdFNHazl+F1199dWGy/7rr79uiBfcFGoo0MKMwu6///2vYelFSyxahjHhXiorJyaWw9d4lW/DOG28P1GUs3sFv4fxOxp/MFZatBgH8f7D16ALOW6sYV+4oYIbCnjP8RtPmKPg9ttvN67rGWecYdwD+H7AZG/oZcCfO14/nBes+43J7vB+xnA3LDeHid+wjJefazV61OEmAtaix/HV5p5paPAc0RsBw/EwWSK+F9hmJW7S4LmICecIgiAylrTlR89CcLq+++476++ffvrJeAzLdfA/WOrj/PPPN9qsWbPGKH9zzz336FOmTNFHjRpllFTBcjl8GRqCIHKzLJgfYlkwxnvvvWeUT8LyXlhSDEtr9e3bV1+9enXK1+JxxbJSrHTT888/7yrVg+WAanMOWMIHSx1hGauCggJ9xx131K+44gp90qRJjnaLFi0ySk1h6atoNKp36dJFP+2004zyQypg2Swcx5dffmk9VlVVpTdt2lTPy8vTy8vLpePmS1lhCSacK5xLfI6VtfI6R1mZIi9k5Y7YjwiWncKSVThfWHoJr1NRUZH1fGVlpfFd0atXL2Os+H2Cv7/11lspx+F3vbDUFl4f/GEl3rAU1GGHHWbcYy1bttRPP/10qwRbEGXBcOwi7J7jwfvv4osvNs4X7yW8h8aOHWu0++KLLzzP99ZbbzXa4P3lBSuxhSXPGHjO+Ng111zj+bq6vP9YCTssV4fXefvtt9efffZZ/aOPPnLNJV6Lhx56yHhv4LGwHNqcOXP0du3a6TfccIOjTyzHd//99+s77bSTcd9vs802xr30wgsvGO+HVOB4rr766jrdM3UtC+b1WSN7v5WUlBj3BZYg5EuIIb/++qvx2IIFC5THQBAEkU40/Cfdoj9bwB1nPks57r5ecsklhmVDjB/D3Vi0zGB2XrR4s8QuCFo2MJEKWnkOPvjgBj8PgiAIgshUvv/+eyPvAXoKoMdEYwJdxDFLOXpOYH6YoEDPCyy3hp4oXkkbswVcg7H1GEEQRDZAMdx1ADPjoos4JrVBN0X+h2XvxWQwLFkag4nz2mQrJQiCIIhcga9BjuB3Krq3Y+gCuoQ3pnNHMG4aYYlXgwKNA5jETTU+PlPBRIk//fSTNM6eIAgiU6EY7hRg/BWfMRUzY2JsF8Z/YXZM/BLDGqkYh4UCHBMBYTIfTPDTp08f4wdLgTz22GNw0UUXGTF6WAsUM5TWtZQNQRAEQWQzGJuPwhPjyTGpF2YPHzdunJEDJVMz9QcFeslhjDQmqkOvOLToY5I3jLMO2rKPG/+YOC3bwVrxqZLEEQRBZBrkUp6CkSNHGuUxZAmQ8IsSk3eg69cnn3wCq1atMhKXoJt4v379jERBCGYwf+6552D+/PlG6RNcWGDWXUwQQxAEQRCNlUGDBhkb1rixjRmx0UPsxhtv9EyGlktMmTLFqK2Nm/hFRUVGIrVzzz3XWFNkav1rgiAIouaQ4CYIgiAIgiAIgiCIeoBiuAmCIAiCIAiCIAiiHiDBTRAEQRAEQRAEQRD1ACVNk4DZw1evXg0tWrQwSk8QBEEQBEEQBEEQuYGu60Yy686dO7sqSgUNCW4JKLaxTjZBEARBEARBEASRm6xYsQK6du1ar8cgwS0BLdvsAmAtUIIgCIIgCIIgCCI3KCoqMgysTPfVJyS4JTA3chTbJLgJgiAIgiAIgiByD60BwocpaRpBEARBEARBEARB1AMkuAmCIAiCIAiCIAiiHiDBTRAEQRAEQRAEQRD1AMVwEwRBEARBEATRoMTjcaiurqZZJ+qNvLy8ei/5pQIJboIgCIIgCIIgGqz+8dq1a6GwsJBmnKhXUGzvsMMOhvBOJyS4CYIgCIIgCIJoEJjY7tChAzRt2rRBskQTjY9EIgGrV6+GNWvWwHbbbZfW+4wEN0EQBEEQBEEQDeJGzsR2u3btaMaJeqV9+/aG6I7FYhCNRiFdpN+pnSAIgiAIgiCInIfFbKNlmyDqG+ZKjhs96YQEN0EQBEEQBEEQDQa5kRON6T4jwU0QBEEQBEEQBEEQ9QAJboIgCIIgCIIgCIKoB0hwEwRBEARBEARB+HDFFVcYLso33HCD67mbb77ZeA7bNMQYxJ+FCxfW63GJukGCmyAIgiAIgiAIIgXdunWDL774AsrLy63HKioqYNCgQUbpqYbg5JNPNkpd8T9Ya1qkqqqqQcZDZLjgHj16NJx++unQuXNnY3fm+++/920/ePBgOOGEE4wU7y1btoRDDjkEhg4d6mq3atUquPTSS41yA02aNIG9994bJk2aVI9nQhAEQRAEQRBELrPffvsZohs1CQN/R7G97777OmpAP/3004YQRi3Sq1cv+Oabb6znR44caWgf1DH4Omxz7LHHwvr16+HXX3+F3Xff3dA6F198MZSVlTnGkJ+fD9tuu63jJxwOw9FHHw233HIL3HHHHbDNNtvASSedZLT/999/4ZRTToHmzZtDx44d4T//+Q9s3LhReaxElgvu0tJS46K++eabygIdBfcvv/wCkydPhmOOOcYQ7FOnTrXabNmyBQ477DCj1hresLNnz4YXX3wR2rRpA7nCmq3l8OvMNTB+0aZ0D4UgCIIgCIIgao2u61BWFUvLDx67plx11VXQv39/6++PPvoIrrzySkcbFLCffPIJvPPOOzBr1iy48847DWPgqFGjHO0effRReOONN2DcuHGwYsUKOP/88+GVV14xLOY///wzDBs2DF5//XXlsX388cdGKayxY8cax8aa5yjkUdSj8fG3336DdevWGcep6ViJ2qPptbnT6gHc5fnuu+/grLPOqtHr9txzT7jgggvg4YcfNv6+7777jJtszJgxtR5LUVERtGrVCrZu3WrsLmUaQ6avhts+nwqH9GgHn193cLqHQxAEQRAEQRApQffrJUuWGNbUgoIC4zEUvns87PZYbQhmP3YSNM2LKMdPo4B9//33DSv3vHnzjMd32203Qyxfc8010Lp1a3j33Xehbdu2MHz4cMMbl4HPo7UaxTRauNFwiG2OO+444/lnnnkG7r//fli0aBH06NHDeAzjxZcuXWoIZTaGzz77zJo7BK3XX3/9tWHhRg0zZcoU67knnnjC0ES8R/DKlSut8Xfv3j3lWHPtfkuH3lO7wzIUdIEoLi42bhTGkCFDDBeK8847z9iZ6dKlC9x0001w7bXXevZTWVlp/PAXIJPJjyQdEypj6S3iThAEQRAEQRCNCQxt7dOnDwwYMMCwkOPv6MLNwARmKFbRK1eMqebdzpGePXtav6O7d9OmTS2xzR6bMGGC4zUo1N9++23r72bNmlm/77///o6206dPhxEjRhju5CIo7Kurq5XHSjRSwf3CCy9ASUmJwy1i8eLFxk141113wQMPPAATJ06E2267zXCvuPzyy6X9oCtFv379IFvIMwV3VTyR7qEQBEEQBEEQRK1pEg0bluZ0Hbs2oFs5xksjYmgsahMEXcLR8CfGX/NgCCzv7cv/zR5DAyMPCuyddtpJOi5efLOxYPjts88+62rbqVMnI75bdaxEIxTc6OKAIvmHH36ADh06WI/jTXnAAQfAU089ZfyNuzN4M2FcgpfgRvcNFOi8hRtdLTKV/LApuGMkuAmCIAiCIIjsBUWlqlt3poCZwtEKjGNnyckYe+yxhyFWly9fDkcddRSkO8nbt99+C9tvvz1EIu45zqSx5jLZdXebYDp+jC3AeIXjjz/etVuDNw8PZvrDm80LvNGyaRcnP8pcyklwEwRBEARBEERDglnB58yZY/3O06JFC7j77ruN5GNoCDz88MONOGHMMYWxwl4GwPoA64NjzPlFF10Effv2NcJw0eUdtdQHH3yQUWPNZbJOcH/++eeGGwfeKBgzIYIZylkSA8b8+fONpAC5Qp75xiYLN0EQBEEQBEE0PH6Jth5//HEj1hvDVjHcFZOpobUZw10bEiy9jOL53nvvhRNPPNHIWYWaCC30oVAoo8aay6Q1SznGFeAuC3P9fumll4xEALj7gvXs0NUba2pjqnrmRo47La+++iqcc845Vj9YMw6zzCEYs33ooYca7uYY242JBjBh2nvvvQeXXHJJTmQpn7u2CE5+ZQy0a5YHkx9yJjkgCIIgCIIgiGzLGk0QuZqlPK11uLEeHAptlgUP46jxd1bia82aNUZMAQNFcywWM9wj0HWc/dx+++1Wm969exvlxdASvtdeexm7NljPTlVsZwMhTTP+z4h6bgRBEARBEARBEETmuZRjvTg/Azum2+fBmnUqnHbaacZPrhJK6m3fuSMIgiAIgiAIgiDSS1ot3ERtSSruBOltgiAIgiAIgiCIjIUEdxZbuBNk4SYIgiAIgiAIgshYSHBncQw3BXETBEEQBEEQBEFkLiS4sxCmt8nCTRAEQRAEQRAEkbmQ4M5CKEs5QRAEQRAEQRBE5kOCOwshCzdBEARBEARBEETmQ4I7C9FMxU1ZygmCIAiCIAiCIDIXEtxZnKWckqYRBEEQBEEQBOHF0qVLDWPdtGnTjL9Hjhxp/F1YWGj8PWDAAGjdujVNYD1CgjsL0aw63FSImyAIgiAIgiDqm9GjR8Ppp58OnTt3NgTr999/72qj6zo8/PDD0KlTJ2jSpAkcf/zxsGDBglof89FHHzWOhT/hcBi6desG1113HWzevBmC4oILLoD58+dDQ1FeXg5t27aFbbbZBiorK6ExQII7iy3cJLcJgiAIgiAIov4pLS2FXr16wZtvvunZ5rnnnoPXXnsN3nnnHfjnn3+gWbNmcNJJJ0FFRUWtj7vnnnvCmjVrYPny5dC/f3/47bff4MYbb4SgwI2BDh06QEPx7bffGue02267STctchES3Fkdw02SmyAIgiAIgiDqm1NOOQWeeOIJOPvss6XPo3X7lVdegQcffBDOPPNM6NmzJ3zyySewevVqS1hWVVXBLbfcYljACwoKoHv37vD000/7HjcSicC2224LXbp0MSzm5513Hvz+++/W84lEAh577DHo2rUr5Ofnwz777GOIclVEl3K0qmMfn376KWy//fbQqlUruPDCC6G4uNhqg79fcsklxoYCnsvLL78MRx99NNxxxx0pj/fhhx/CpZdeavzg74z33nvP8B7A8+HBubzqqqusv/Ea4AZBixYt4JprroH77rvPGG8mQ4I7i7OUk94mCIIgCIIgshpc0FaVpucnwMX0kiVLYO3atYYoZqBYPeigg2D8+PHG32j9HjJkCHz11Vcwb948GDhwoCFqaxKPPXToUMjLy7Mee/XVV+HFF1+EF154AWbMmGFY1M8444w6ubIvWrTI2CT46aefjJ9Ro0bBM888Yz1/1113wdixY41zQfE/ZswYmDJlilK/48ePh/PPP9/4wdctW7bMeA43EjZt2gQjRoyw2qPrPG4eoLhHcL6efPJJePbZZ2Hy5Mmw3Xbbwdtvvw2ZTiTdAyBqX4eb7aYxizdBEARBEARBZBXVZQBPdU7PsR9YDZDXLJCuUGwjHTt2dDyOf7Pn0C185513hsMPP9xYv6OFOxUzZ86E5s2bQzwet1zTX3rpJet5FNr33nuvYYVGUIyiaEVru5/7ux9oZUbLN1qRkf/85z/wxx9/GGIXrdsff/wxDBo0CI477jjjeXR1R+t0Kj766CPDU6BNmzbG37g5gK9Fqzo+hs/x/X7zzTdGrPcxxxxj/P3666/D1VdfDVdeeaXxN8bLDxs2DEpKSiCTIQt3FsLLayoNRhAEQRAEQRCZzxVXXGFkC991113htttuM8RiKrAtvmbixImGsEaReuuttxrPFRUVGS7rhx12mOM1+PecOXNqPU60ujOxjaDb+Pr1643fFy9eDNXV1XDggQc6LPk4Tj/i8bgh1NGVnIG/o7BnbuRoycYYb5ZMDS3auJEQCiUlK3oF8MdFxL8zEbJwZ7mFG+O4ww4JThAEQRAEQRBZQrRp0tKcrmMHBMZZI+vWrTMEKgP/ZjHG++23n+F6/uuvv8Lw4cMNt2p0QUdLrhfoPr7TTjsZv6Nbd58+faBfv37w+OOPQ30RjUYdf6M1XoytrilDhw6FVatWGVnRRSGO1vMTTjjByAKP3rs///wz9O7d23A5x/jwbIcs3FmIxl01iuMmCIIgCIIgshY0JKFbdzp+AgzL3GGHHQzRjeKRgRZozFZ+yCGHWI+1bNnSEJ3vv/8+fPnll4ZFtyZlvjApG7qRo2Ub+0JXboyn5sG/99hjD6gPevToYQhytLgztm7dmrK02IcffmhYq9Faz//gYyx5GiaSO+eccwzL9ueff25YzXGTgoF/88dFxL8zEbJwZ71LOWUqJwiCIAiCIIj6BOOEFy5caP2NlmoUjFhTGpN3oRUYs3RjFm2M00YB/tBDDxmC+KyzzrJir9H6ve+++xpu0l9//bUh0vks4alA8Y4Z0J966il444034J577oFHHnkEdtxxR8OSjjHROC4UrfUBuppffvnlxnHx3DFjOB4fz8crr9SGDRvgxx9/NJKs7bXXXo7nLrvsMiPzO246YH/oVn7aaafBrFmzHO7nCLrSX3vttXDAAQfAoYceamxYYKI43ATIZEhwZ7lLOUEQBEEQBEEQ9cukSZOs5F0sUzeC4hPjkJG+ffsa9bqvu+46KCwsNJKjYZZttNwysYq1ujGDeDgcNtymf/nlFytGWZU777zTiAfHmG6MBUcL83//+18jzhot2yhsUfTXF7hxcMMNNxjCGK3seN4rVqywzlPkk08+MUqIsWRoPPgY1gL/7LPPjHM59thjDeGN8doXX3yxoy2KcYwhv/vuu40EcuiSj/MwYcIEyGQ0HR3lCQfo/oHB/3jz4k2UaZRXxWH3h5P19WY/dhI0zfPeN1m+qQzaNItCiwJnLEZ9UloZg+Fz1sExu3WAlg14XIIgCIIgCCJzQZGElmG0/nqJMyL7wE0GrBOO5ckwi3hDcsIJJxheAlg3vCb3W0PqPbJwZyG8gdsvS/nSjaVw9AsjIS8SgvlPnAINxb3fzoCfZqyBI3beBj69+qAGOy5BEARBEARBEPXL1KlTYe7cuUaGcBSsjz32mPH4mWeeWa/HLSsrg3feecfI1I4eAhjnjcnnsBZ4JkOCO8sFt5+DwthFG43/q2L+WQXx+XdHLYIjdmkP+3RTjyHxAsU2MmZB8vgEQRAEQRAEQeQOmLgN3b4xi/r+++9vZBTHmtn1iaZphgs+1gNH6zUmUcOkc5jpPZMhwZ2FaFzaND8Lt2qs9yfjl8KLv883fpY+0wcyjRWby2D84k1wzr5dIBKmxPoEQRAEQRAEkS4w6dvkyZMb/LhNmjQxLNrZBqmXLCTE62gfwa2aWm3BuhJIBz/PWAOHP/snzFhZ6NvuiOdGQN9vZsCAcUsbbGwEQRAEQRAEQRB1hQR3FsKn3PcrC6aazDxdSc9vHjQFVm4ph+s/VdshG79oU72PiSAIgiAIgiAIIihIcGchWi1cz33bpbnKWEV1XKkd1RwnCIIgCILIfhIJ//xCBBEEmVKMi2K4sxzf20hZSAeruMMhDeJ+weUCqk0z4y1DEARBEARB1AZMsIU1p1evXg3t27c3/uY9NwkiSLG9YcMG4/6KRtNbppgEdxai7CoO6YsxV7NZ18xyXQMNTxAEQRAEQWQYKLaxJvKaNWsM0U0Q9QmK7a5duxolxNIJCe4cdpVQ3TF0JGELgKQru7o6VvX2yBS3EIIgCIIgCKJ2oFV7u+22g1gsBvF4TUw0BFEz0LKdbrGNkODOQoIW0qoW81g8AWMWboT9tmsDrZoE55qhauEmvU0QBEEQBJH9MDffdLv6EkRDQEnTshw9ENdztYbvjl4MV/afCBe8Ox6CRFlwp7Ca/zFnHTz1y5waxY8TBEEQBEEQBEHUF2ThzmGCzlL+w7RVxv9z1xanOnCNUNXHqRJaXv3xJOP/nTo0h/MP6FazQRAEQRAEQRAEQQQMWbizHD/jcNDJ1UL1lEUyoai4VS3hyzaVQhBsKK6EFZvLoCFBt/33Ri+Cf1dtbdDjEgRBEARBEAQRPGThzlJQ+wYV06waE57usg2q51tRHUxtx95PDjf+n/bwCdC6aR40BAP/WQ5P/TLX+H3pM30a5JgEQRAEQRAEQdQPZOHOcvzimoMWyEFnM68vgk6utnSTv5X7rwUbYfKyzYEca86aokD6IQiCIAiCIAgi/ZCFO0upWeGtYKgvl/JMx8+VfWNJJVz64T+BWaTT7UVAEARBEARBEERwkIU72/GL4VbsQlXjZYuFOxWfjl8KNw+cAtXxRJ0t5ptKqrh2dd8CIb1NEARBEARBELkDWbizFMMSGpDvtGo281xRgw/9MMv4/+hd28N5StnM/dz27d8x91s4N6aIIAiCIAiCIIgAIAt3lhOE5E63hTtdVbO3llfXPRN8LbKo+0F6nSAIgiAIgiByBxLcWUo6hFlYNZs5ZAeqAtmvldPCna6tA4IgCIIgCIIgMhES3FkOaTzJnCjazBVDuFPUOtcCvRaZnphuxLz1cMugKVBYZseuEwRBEARBEAQhh2K4s5QM12U1IohkY7XBzyLNj8lvfIG7lGf4db2y/0Tj/xYFEXj6nJ7pHg5BEARBEARBZDRk4W4k1twgyHQxWFPimOXMA147+7uU25Pi051BcUU1xFTN6ilYsK4Yjnp+BHw7eSWkg1WFFWk5LkEQBEEQBEFkEyS4sxSVzOK5JpCDRtUg7We55qfYzxK+vrgC9n50GJz2+l++x1K9ZH2/nQHLNpXBf7+eDo3JK4EgCIIgCIIgsgkS3FkO6Z56mlfPP/zLgnkxcu4G4/+5a4t9j8tbzP2oiqlbyjcUV0LQUII4giAIgiAIgkgNCe5sJQ3Wa9V63TW1rGeirVTVgsvPie9rAr5eqnPcf+wS6P3kcHhl+PwGc8cnCIIgCIIgCCIJCe4sJ5A63JBb8eqqVn8/0ao6r3wffiJUNfu4ek10tYb9fpxt/P/K8AUQJNmut7+auAKGzloL2cyqwnL48K8lUFIZS/dQCIIgCIIgCA8oS3mWki0iOZNpSHf8oK9XusuHZXMM9/JNZUYMPLL0mT4NdtwtpVXwxoiF8H/7d4XdO7Wsc39nvvEXbCypgvlri+HZ/6OM8QRBEARBEJkIWbiznGwWPplMbabV7yWhUHrd9oMmmy3cm0qDj2lX4cEf/jUs0qe8OiaQ/lBsI2MWJPMDEARBEARBEJkHCe4sJUjBlW7xli78Xcr1QEV6ulzK64tsTpqWrrmbvbqoXvrN5s0PgiAIgiCIXIcEd5bjn6erkSrpAAhaT6pmH1cllCOXdnNpFcxZUz9C1IuaXAp0A68OqHZ6Y93YIgiCIAiCaMyQ4M5SaiqmA3E91+prbJC18GP3s4qrzohyu7THcKe25r4zalHK8mUHPPG74WJdX9bfuiYl2/fx3+GkV0YH0l99XbHaeGMQBEEQBEEQDQMlTctS9oDFsE1oHUQ2dwVo2yvdw8ltVJVSA7qUZ7qx9NTX7DjlG47aMaU79NiFG2GPznVPJFabUm5emxfDZ68z/l+8odS3v1g8AZ9PXAGH9GgLO3Vo0eCbJORSThAEQRAEkbmQ4M5SLgoNg/8Lj4DCRQUAO/VSskiSS6sTLQCru6p1MV1zj8etDw8C1S7/XbVVqV0sTarR732h6rY/8J/l8MiQWSmznmf6JglBEARBEAQRPORSnqUk2KXTg4kvJepe89vvFUGLrWyxhKvK6HgimPv41s+nwiUf/A0JHwHPz53vNVOc5OkrC9O66aKyoeI3HwRBEARBEET9QYI76wW3ojCs3+HkHNkcV94gGbnVXQCUqI4HM+E/Tl8NYxdugoUbStQEt895qM5dRNEUXl/XIlV+hleGz4de/YbBko3+rvEEQRAEQRBE8JDgzlJ0ZrtMxOosLFRJt7U0E+FnNZC8dAGLsnrT28rtgtkQKqqohmWb1AVjXNGi69cqrPjpGFYtsl5PpDrTV4YvgOLKGDz769wGGhFBEARBEATBIMGd7RbuAGzX6c54HTRBbC7otThWJmaLTndpuIA8xWH/x3+Ho54fCUt9rLT8tfCrE87PiW+7gC3c9fU+U73f47nitkEQBEEQBJFFkODOdsGtqGhoqQ0NX0YtE0i7R7liUjlFl/PxizfVvT69ptZO1QU8rCq4lVoBTF9RCOe9Mw6mLt+i1F71TqU4boIgCIIgiIaHBHeWu5RrerzBjqmcqCsHDObqLtPc7w1X6jztluvaJJUL4p7xs0jzT/lbrtWOpZqlXBXV45737niYuHQLnP3WuEDnmCzcBEEQBEEQDQ8J7iwlYQouXTFLua/FL6hBNUJUs5Q3VoJOjq3an18Mt7MOd8NtHKlazKtiifpxKadM5QRBEARBEA0OCe4sJaElL52mKrhJDrrw0z8ODZPFSrq+NlOCtlyrH9fHws397qctnWXB1IR5LiSwI8FNEARBEATR8JDgzvqyYA3nUt5o8RVKXNK0BvQpzxa3/aBd5FXjkFWvhV+zbNmkUo6nz47TIQiCIAiCyClIcGd7WTDfbMxc+0C0YHpV3oL1JbC6sDxlu0B0RS1ETGMSNOmycKt6Rfu142OzG9Ely5oNBIIgCIIgiFyCBHeWErcs3AHVXcoCCsuq4dBn/mz4A/taQTPbIp1uN+agN2n8k6apj0qlv6BJt1NCY9oQIgiCIAiCyBRIcGcpega7lKdbWGQ6fsJQVaBmi0u5Krl2PtnIN5NXwqUf/ANby6rTPRSCIAiCIIicgQR3truUK9bh9mJjSSW8O3pxMIPKIWpT9qoxWRBVrcnBu5SrJU1TpTFds1Tc/fV0+GvhRnj9zwUNetzhs9fB34r11QmCIAiCILKNSLoHQNQhS7khFuqWHOqmz6bQJUg1d77P1Vyx4bVoKItuuuPuVcmOUWa3GV/1Tt1a3nAW7rVbK+CaTyYZvy99pk+DHZcgCIIgCKKhIAt3lmcp1xIxpfZewnDC0s055/YbhNWyNn0EkZQqW+Y4E8+nVtc9ByzcgWTH5/uDhgM9bAiCIAiCIHIZEtzZ7lLuV0c4x8RbJlIbl3I9ByzXme6K7Rsnr1iHO+fIwPJhYS5lfNAbBwRBEARBEJkACe5sz1KeUEuaRmvZ+kF9XnNLWNQmxt0P1c2hHJi6tBHU5sLjP82Gk18ZDeVVdU/YGOIufFy15htBEARBEEQWQYI767OUZ15ZMC1LTOt+4i1d3slBz1yWXIpAqG08fV1pTHOMfPjXEpi7thiGTF9V5774mujxDNxNWbi+GB4dMgvWF1WkeygEQRAEQWQpJLiz3aVcUXCPX7QJtpRWpWz34PczIRbPPBGfucK8FiIPsp+gXdqD3qTxm2Mtx66F6jmohzyoNayK1332QpzirmPBBQP87Ppk/FJYsK647p0BwGmv/wUDxi2F27+YFkh/BEEQBEE0PkhwZ3nStIlLNkL/sUtStsdMwCe+Mjplu8/+Xg6DJiyXPlcbTfTq8IYtMRQUqm7fzhjuYN2siZpB85pifgK+oRIBuICHeZfyAC4gfnY9/MMsOOHl1J91KlRUJ3cBpq8sTNEuDrNWb82JcBGCIAiCIHJIcI8ePRpOP/106Ny5s2Hh+v77733bDx48GE444QRo3749tGzZEg455BAYOnSoo82jjz5q9MX/7LbbbpBrJEw7XUVVNfT7cbbSazYUq2UEXrapDILi5eHzYeH6EmgMNORSW3Xzo5F5O9eYxiSQlM9VsVkQMdd8DLdfjXVVpq/YCvVBqrFd8O546PPaXzBk+up6OT5BEARBENlLWgV3aWkp9OrVC958801lgY6C+5dffoHJkyfDMcccYwj2qVOnOtrtueeesGbNGuvnr7/+glxDxzrcxgVUdZ6tQd8K697rP50EP81QW1wWVzRcXd/6yDzdkP1lSzxwurJ7N+RRg9biWpaMU7W7IASyI2N8AC7l9fX+SbW3MH1lUuh/NWlF/QyAIAiCIIisJZLOg59yyinGjyqvvPKK4++nnnoKfvjhB/jxxx9h3333tR6PRCKw7bbbQmNwKQ9DIi1xu0NnrTN+TuvZucFFElrqgoj51QOOi1U2IDYeo2rG05guReAu5YHX/w7CYg5p9Q4IIg6dIAiCIIjcIqtjuBOJBBQXF0Pbtm0djy9YsMBwU+/RowdccsklsHy5PCaZUVlZCUVFRY6fbBHcWj1IhsAtukEvzBtYJam7zuqNJmN88EnT0pOBvjFtfqhvCKk1DDq3ot9hMV4cs4X/MG1VIPclxlsf9NRwZYu06mdA0JsQBEEQBEFkP1ktuF944QUoKSmB888/33rsoIMOggEDBsBvv/0Gb7/9NixZsgSOOOIIQ5h78fTTT0OrVq2sn27dukG2ZCn3cymvrYgJ3EU1TS6vdToGd5Ar+k+El36f7zEWPaOFbK65lPuRLq2jes2yJVygIcv6OVzKfdoNm71WKVt4SPEb7c4vp8G6okro+80Mpfaqe26Z967IHWavLoL3Ry+GaqqiQRAEQWQZWSu4Bw0aBP369YOvvvoKOnToYD2OLurnnXce9OzZE0466SQj3ruwsNBo58X9998PW7dutX5WrMj8OLyE1vAu5apotVisBpHxuD6F12t/yLOtk0t5dpOJGwf1hZ7Fc7elTDUPhNZgCd8aexK+hubU18bAk7/MgY/HLU33UAiCIAgi9wX3F198Addcc40hoo8//njftq1bt4ZddtkFFi5c6NkmPz/fyHrO/2RLlvKQguBWaaNCbQ1fKm6Wez86FMYs2JDVi9qgR/XBGG9rjqoVUvWSlVTGYMTc9VAVC3YDR/VSqVqJg6iJ7ugjA2+lejMwK16MdBni/d7XEcXgbOXs/fU0yRn60ZRT/LuqfjLREwRBEER9kXWC+/PPP4crr7zS+L9Pnz4p26PL+aJFi6BTp06QS+iKMdwXhv+Ef/OvhoNDs9X7ruOqUXy1SnelVXH4z4cTatV/bQlEvNXKdVYtDOCJn+fAgLENY8257pNJcOWAifDisHmQDhqTpTnj564BFTcvfP3OIhLWAk2aVm/J1eqnW4LmmCAIgshi0iq4UQxPmzbN+EEw3hp/Z0nO0NX7sssuc7iR498vvviiEau9du1a4wfdwBl33303jBo1CpYuXQrjxo2Ds88+G8LhMFx00UXQ2LKU45rymegH0FSrhHeiLzfIohHLhaG1tAAqoQ0U5UTSND/4c6uPLOXTVxZCQzBu0Sbj/4H/+CcYzORY89rcFw1aOz3gdjUlg942NX7/hBWDs5Xj6etpljM1aRqWZqwvN3qCIAiCIDJYcE+aNMko58VKet11113G7w8//LDxN9bQ5jOMv/feexCLxeDmm282LNbs5/bbb7farFy50hDXu+66q5FMrV27dvD3339D+/btIZewkqZpaouoplCh3ncd1mVYKgz5Jq8f/J1/C3SEzVAVcJKbBrGG1kq81UPG+Lp2WUNdURmLK7XL9GRx/uNrnMIjQ7WgmueHYh/qLuVQLzS0pu334ywje7sfqwvLYe9Hh8H5746HxnAf4/lOWrq5oYZDEARBEJldh/voo4/2tX5itnGekSNHKsV3NwZ0zelSnqo2dZ6mJqRS0RzKoINWCIt1//rbe4WSrtC9Q/Ogoto7zv7o0FSohgiMTezt29+5odGwXO8AE/XdIJPQA36NO+Gc3qBW0Op4hquyoK9F9p4uUSdhXm8Fu6Gh2FhSCf3NkJP/nrgLtCiIStv9NGO18f/kZVsgF0g1w4c+86fx/4+3HA57d23VIGMiCIIgiJyK4SbkLuV1dRfMg2rYQVuT0tL0Z/7dxs+emlpsMZYti3mMDcX7gLznYWDe05APVZ597KktgRfz3oGv8x9Lji/FqRaWV8O4RRtTZj7/Z8kmeOzH2VBeVfvNiNpkKT/7zbHw5cTlgbmoXvPxJNhUUql2cCJwS326y33lzKZBAOehKqTrK4Y73oAXo7gipnTemRj+0RBMWZ4bGwwEQRBE9kOCO8sFN8tAXteFXv/oczAi/79wTGgq/DpzrWc7tG4jJ4YnKfasewqCPLAXjC2h1LOHbbWauQf+PGMNXPz+P/Dd1FUp45Y/GrsE3hm1yPWc+myqxaDyS94F60vg3m9nKvWu4o0/fM46eNGjTnijFch6IxCo9UUDzo9jw6rhDpv2TZIg4Dfj/DzFgj7XsqoYDPpnOawrUg9TChLVnCCZGk9PEARBND5IcGcprHpTFGKGdVhm4a6J2+Rh4WQc4BXhobCp1NvazMiHamULt9eyh38cE7t5UQ751u8RiCkLpl//9d444Fm2qbTeS6opI1wz1cXlFo9rlm5d0ZDZx2uTnK8h1+TKpdxyQQ3Wgga9Fml/Z9SdEHef+DnzBH0/Pf3LXHjgu5lwzlvjIJMhvU0QBEFkCiS4s5QtFUk36L1DS2Fk/l0Qryp3PD97dRG8McK79rgXTXyEL79w83MBFwWrlxBCMc5oCt7HrdDzrN+b+SZ/06Fv5As4JfQP1BUcck9tEUzPvxauDP/q284+evCKoZFqrwYjF2xguXAODb05kwMh3I4tA7/NJlX3eQzB6T92CUxb4V8Z4c+5643/VxU6v3MaCj2L3xeYLf7pX+ZQLXGCIIhGBgnuLK/DjXTSNoO+1ek+feprY2B6ioWTDC/hO2Luehg9f4Oi4LaXOn5rPV5w+1mSmfs8EoW458L86NB0uCkyBN7OezWQRfUL0XeghVYOj0Q/9WzDj2TummJYsK64QaxMJMT9r0W2LcQziUycn6Dv91zYx+LnRDWcxY+fZq6Bfj/OhrPeHOvbTrUmer2hXH4x8+7kZ3+bC++OXgynvf5XIP2NmLceTnx5FMxooPKRBEEQRO0gwZ2lJIRlVLyiJJB+eRHMc+WAiY6/VYW05lO2jBfZEYgrtQuj4Pbosg3IxW5t8atxLoIx6P/9ejqc8PJoqA64DFpdqI3QxyRsjaVmbyYuynPBglwbcuFSpMst3i9eOaRo4vbaLBQJ11fGuUbAnDXBfkdd2X8izF9XYvxPEARBZC4kuLOUuHjpKooC6XeP0DLYRVuRsp2XME8+ZwtOLFvmtRbk+/ATt/xz+LvXkbG8mBo6nBSaAF1gg6coRXGiEr+N53ZBeATMKLgWrg7/bDxWyQLsa4GWARZATMI2an7SbTSbBI2q2MkFYZeL5MJlSdc51KTUYF2JpFlwq24cZWLSNK0BMtYTBEEQmQcJ7ixFF766E5Wpd85vCA9R6vu56Hsp24Q1b1HJC+mrwr+Crsut17yg9RO3/LHCGlq49Totbk4L/Q3v5r0CYwtulz6P1t0ZK7c6XNm9wLE8G33f+P2h6MAajyU18lfW95K3sjoYK3261rzK7uVBlKIKuF26E4U1pNXfWVYv8wRStuArLhV341Snn0/W5geGIB32zJ8wduFGCJKG3ljD85i4tGaVMho8d0BObFcRBEHkLiS4s5SEXnML933RL5T63ifkLpMlovkIZLRqM3YPrYCuK3+Rt+PczSOaWn8Rn+OKmxBeHBKaLfTv5Lnf5sL1n05WEtz1QWsohkND//rOcX0vr1ItDNGN8ZZBU1LWOh82ex08OiSZAT/bSJf+qy9hnumL8lzQ2+naNPA7bNAGadUwlcs+mmAkVrvkg7onsawNQVyJDcWVxnmc9854yGRy4b1DEASRy5DgzlLi4rJcwcJtUB1M7VRmxf5pxmrJc06h2HLrXN8+ZK/xcik3sp4rCHM/sepyxxfApDYq7ZCg1zm4lv0+72EYlPcU/F94tLTNg9/PhJHz7AR29UPqRfVPM9bApGVbUrYbMG5pQGMCeGX4fO8Mv8olunNsdZpjp5OrZbyChr+P/QV3Zs/d+qIKeG/0Is/Shum0cG/mxhTEZkp93ceN4COAIAgiqyHBnaWI1le9ukzthWWb1NqlWFwwsXzLoKmez6XCmQxNTXBjcjWVdY+fJdwl7rXaW8xVxoIuiXd+NQ1U2T60zvj/9JDcqvLZ38utBHKtwD9ZXn2vtStj3snu6oPquB5Yhl8kAE/cnKMh3fFzbvMjA13KM/02RgvyU7/Mhdu+cH+X1OWeCeLeUs0Er94h1AuZGK9OEARB2JDgzlJ4a65BVWmwgjte7fv0meFxcICW2nLthzNpmlqWckNIK3QfCsD1XMXCLe1fWPzggpIltUklkHnytWpf0fdl3uMwveA66K6thaBRFZuZZHkMWrzRGrZhacj5zjV5ks2Ca+7apHfWmAXpifVWrnVe9+4IgiCIRgoJ7iylqeasl62pWrgLl6m1i6d27/sm/zHp4y53bj3hEqS3fzHVsWmwm7bCUyS7Xcr1lELay2KOxxZLqnmh5lLuHotXWPOdkW8MgXxGaJySgM0D/8yzB4TmG/+fFfKvm1ufBGUFxljJdGQzz0QLa03nNBPPoTbkwnk06KaBI+Fc4/HUUHcpD9bCnWpT4+cZa7zDXVh/isdduaUM+n4zHeaZmxGpyOL9FoIgiEYBCe4sZZPe0vmAquAuL7R+HbdoY50ENxKRiEKX2BVWA4s2lMIP01Y7BDcmdOsbkSd144X4EaEZnmPh+8MxeC00RXd8LyutUtI02ULHY/Fze2Sw8f+T0Q9T95vC6u9op3m348+stDKY0jE7aqtgG0guLINay380dgl89NeSOvVRm0Vng9ZNzjHh05CikSCs+6RBp0JTuj8nL9sCNw+akjLcRfUz4MbPpsBXk1bC6QGGzxAEQRDpgwR3ljJb3x6ur7oTRsf3Tj4QU0yGxrW7+H2f7LExNYtjZ22Ty6IgupRrgoU7lkhI290Q+Ul6DL5d3+hXoMeqai1Wa7Ko5y3h+2gLA7PUNQG1ufWLQ69Nuz0fGapsSfZaF3aCTfBH/j0wqeBGCJrHfnJmj88k/KxlJKQDmuOA+kknuWClJ2pu4V64XjFpqSLMsl0VD6Y8Y33k7li7NZgErARBEI0BEtxZzNBEbxiV6OUrkKcldqxRbLbdTiZq3QuO9mBbzBmikA7pVXWK9XZZzCsKa/4aPwu3ltql/Pv8h6VtZGeQolKWfwk0zWnZVzGIYCI5Px6IDIQPo88bmxAj5q6vU+mf3UOKIQlZkuwrE+VRuuPiydKcHXOnp8tTA9JLJp6r6ntWtV046FpuAXPSy6Ph4Kf/gAXrgt1oIAiCyFVIcGc5lRA1/tfiXpbL5Opks948+Wei9oJbJmLbasUpE7pFq0vVEr8pC+6ilK7n+4fmQ0iwrDNUY7hdLuWJuNLiL6havH6J30TBXVYV9xTO10V+huPCU+FIH3d8Vcoh3+lFkNnrwoyqm1xvJYEycdegVqJRzYsgXbWus9Wynu4NnOBpwPcsd+P5ZoJXTTKp2C6S4YJ76aZkCNtv/wafsJMgCCIXIcGdK4Lbw6WcWZGrzHaxajWX4jkrNyhZpFtppa4FsCgUozF5Zu7alA9DtMqilML8vbyX4fTNA1xtdEFw3xP5Agri8g2BuC68Park5xET2gW1HFSdn6siv0HlgpEp27WGEvhtltoCyWu5V6kn7yMV1/i9tMWwLShmxW9AAVIbt1/SeDlWjqyeNBttBeQWmqLnUtC1zsPhzBbcqt5cBEEQRBIS3FlOpZ5n/F9dWe4r2phQmr5UzaW475eTlSyuzaHc+tJli1hRKEari5WymW9hVvgUx9Wq5P2FBVftUwsHpsxmfnNkCJy27i21LOWVxVLxJrary2KeX2btFFrtin/34vO8J5XKjP2p7FIuf7waInZ/UO1pPdtBWwM/5T8Ifxfc6nucNlAEQ/L+B1eEf4O6wm/8KGcyhvQw6J/lUO7hlZBu0jUngZRxyg6dEgi1ud8bE0HMCS+k/TwrQqFg789wltzIlLOAIAhCDRLcOWLhXr5+C0xb4R1PzdptLlKr150H1Uou4OjOLLrahTTn3+XFm2DUfLfFXFxSNIUKJSEdWjBM3k4Q5qLlmS2axDrc25fNVHMpr3RbuPHUxXYqLq9o/VXh5K3yzO21IVWstwr85oefy/semlqs9/WRn6FnaAk8Gv0EggRrn//275rA+hs+Zx0EyQPfzYQnf8ncJHENhfO9oqaQSFvWcE6yQ7tlfGWBhrRwp4stpVUwev4GSCiarmmjhyAIQg0S3FkOE9L5UAX9xy7xtCKzdhu3OkUjxuG+Fn3d+rtIb2L8n6fFlFycoxC3vnSLzbJTouU6UVUBl380QdKfs10+HlOSgVw8botp77naJM8loZScTIzhjujVahbuMnkZNZeFG1KD1l8Vzt6sVkJMxk0DJ8Pm0iqlRHIiXutHvg+/0msxCNd6YycobvhsSmClqK77dLJ008gvwVwq/pyj5m0QFLQ4bog5zt7tALJWppwgT1Q/A5STq6VJv5/y6hhjs/LrySty/n4nCIJoSEhwZzkVkGe592Jta28Ld7JdRWUlrC603c+PC02BM8Ljrb9LISm495ZYYHmB/G38CKsON1q4v5iwHHr1GyYVyHlatXqMsiROWhSKfByx1/j8EC3ScY81g8vCXbbZ1QZfWmuXcklD2UJrusRzQYVfZjrjtXfVVkjrptcE3ssBNzTU1oXeE6LaQ92OUrtX6ZJau0HiaUSqp8U2vu/RgpWpi2i/w2pZssjXMzDhXK6hZ2BZMNUcZ+kS0nPXFsFD3/8L64v9S3mtLUo+P3SWmkdP47nrCIIg6gYJ7iyHiU8U3Cox3HkQg2VmhlGkAJwL8E7aZivJWlxQBLxArtSTsbwRLWnhvm/wTE+BjMeULQqlWcqrSlMK6TGJvaw6pTwqFlw8onjUqkRIzcItSUyH58Rbc9FjwG9h5mDjfKVmdRN69lgujvwJV4d/rZMlhp9jvw0OvRbJ3zKdOosarX4siqq9bCmrhn0f/x0yiZo7lBOp5lEkaI2XI97TAc9x4LMcaG+nvjoGPv17Gdz15XSl9qrfYY1on4cgCKJOkODOUj656kBo1yzPchUv0LxqXSdFUZWZ7CoqWDhFkfpt/HDj/7sjX8HXk1Z4CmSW9RxdyhMphDQT3KKA59uV6AXKghs3F54fOldNcMtKeQm3fUKzE4E5HhcXPdXlKS3h14d/hA/GuF37ZeglwcYFyxDF7v3Rz+vWHxefn3Qp1+oUOy7G0wfBdtq6lN4OHWAL3Bn5Bi556Xt4+tc50jbiyJQ3UhShxWrt5iOj1/hpGlxjupdUN76CmBL+8021bJ1qf/7tIFDYV++MlYWBZh8P+jORIAgiVyHBnaUcuUt7mPTg8VwMt9zCzUQtcz1HYc5/mYsJyZgYba5VwIp1zphlXsQwwY1i6t9VW4V2ouBOji3mIbgXJTpBITT3FNxMSFfrYSu+XPY9L8aOG8Sr3UnOdOdqJr9JMyWX8oQguEsrY8YZ8BbuvtGv4KOxS2BrWerY5ESFvMyY0nkpoupmrwq/SaLaN7bzWqy6vAjqAB7i7NAYGJ1/J7wUlWeeZ7yV9yrcHhkMA/Keg3dHyRPY6TVYhGK29cNCM1Mqnz21pcYYU/XXKLOUqyZNy9B5a3CX8gyeh/okm0873c4B4qZ3fW9qvDliIdz99fSMDHmojifgh2mrYO1Wfzd7giCIICDBncXgbjmLzU7lUs5KbrWCUnhr5CJP0cRELVJQtdlTSFebIhMt5he897fQTuZSrnu6qKOV04rLjrtrO7P+yiHf+L8tFEu/6GWuy3FJEjbRqlqe11ZJDMYrbVf890cvhj0fGQo/TlvtatdVWw+VsdQZwfUquz8/C0g4UfvEYuKcbNRb1mllyAtu1SRs2E5XjZP3JfWi7ebID8b/Z4XH+bY7IJR05989tFz56F7WHJyq3/Lvg4F5TwPM/Nq3j5/zH4CX896Gw1Gce5wPP/VTl29JuVjNxMWsKukaeu4lCPOzvqZb5uUGDRo7Xk/9VgecfTxVu+eHzoNvJq+ESQHnv/ADM6wPGLsEZq50GgJE3h+zGG7/Yhqc8PKoBhsbQRCNFxLcWU6FWYe7iVYFXbUNnmJ1MySFViutxCj74SWaeEHVpGqT0FfyubiuWVbdKyNDU8aNoxsyHifuUT4MBbBV3znuFshsjMw1eefQKqmruExwP/CNu5646PIe1uWJxEQhvWGL7Y735C9JN+TBU1e5XtdN2+A6Vxm6JEGcjFAidaIrL8RzrQ7lK77OYyyC4FYRez1Diz0Xq6oWbtzEmJh/I9we/ta3Xbm5AVUvIs/ndR01896YnRT8qdhDW6o0jrPfGge//utMfuf2ftAbmUt59p7vx+OWwsXv/214xwRJFu+5ZHZZsKD707LEwq3sbaLWriTF/W6U6wzowv4wfRU8+uNsOP2Nv3zbjZyXXAcVVwT7XiQIgpBBgjvLKTaziiPvR180dneXc0nRmKjdorcw/m8D/iKPXw80rdwkFW9oldxBs0UAliSTibIK0+2cuZXHhXTgdn+aFWPuVxasqWZbv/MTEuuwZJHw56zVroWEWCfcS9CKlvAZS+TCp0x3itiWUKa0sElUSuLVJSsyedkySf9xWSm3hFK8Oi/g2kKR5/N8fztqqz2XZfxZfJ73pOdiStXCjcne2mtFcGfUW3DjtbU2blIgq9HuJfQxLr85lKmtvhPeizdNuKdV4x/R7VHeXwJ+yHsIPos+VSMVkqkW8QwdVo1INbePDJkF4xZtggHjlgZxNGiMNKjbPv+7z4FVdbSWJcI8kQj2Wojf/c5j6cbG4vnvjg/ks2neWtVQLYIgiIaDBHeWw1zKmXvsjZ/8A2e8+ZdLhG4yXYm7h9YboonFGIuisn/8ZOv39uULpWILBTJm42bcEP5RGnPM4saZWzmrY8y+zJ2COynOx8x1i4sW+cnbdGj8AOux/FixpzD/Ina0ZV0Xk8Tx47Ne5+myzSz1SRG3ZpM84cwmvZXj771Di5UWLIVb3S5vTaLut2RYIrilmb8l3gFiu6Yh/93816NvwJSCG6DFphnS5/n+3sh7HfIK7fAEv80P3UOIxh3Ct+6LLVXBHRfqhOOiTwYKWkw090jkE+/ONO+cAV7gPKqebcxjsbqdth56hpbAoaFZ0mtfVytXEKWI0CXeH3ssfjPCC5BcEOapLH7BZtBunAR9nzSkZ0XwWc9rhnqWcrV2fh5f64orYNqKQpi4dAsUB/C+CIeyY1ODIIjGBQnuHGPq3IVQyCXsYgJpqb4tFOlNrMRNAycskwqjufp2hmCViVo+5jqPE9xnCPGyrB2KH3Q/ZxbuO76cZvyOO9l8OxxFtSlqv/x7kadLOW4abDZj0ZvE3YKbnUvSRT1slS3jwe999j27NNHR+H9rSSlUxdwKmY2vFAqkJdSsdkLiOax3LVtgTE/0cPy9ZsNG9zlIVgFrNrmFuTRhmWTjwJXATvcXZqeFk/H4Xed+JH1evF9arXXG73uFKugV7uslupRjxnsvVC3hMS4Hgd/C2VU73aNtOy057iPDMxQXwWoLULx+XiJfNe6SvWeQRWv9hS2+/9g9kzLcISBdcfIrYwzLVarav9Zh9ewXKqqnoHrtM9LNOs1CJVM9NFTIlnh61RlWvRR+93uYm5Mg3hd8fwRBEJkCCe4cYMeKT63f25oCQRRIKH6nJXYyft89tAye+22eZ+KrNXo74/9ovFwqLFH8rNNbW4+PSewtPaau27HZ3+U/YrieYzIxZt2RuZSjMBi7UMiOrptCAUKWNbkgXpJCcMvLoDmTsCUt8KFYBbw3epGnWC0zBXcTzqVdxuTEztbrZFZEFvc+P9HF+H/KwlXSdizBHePHKUtrXQJNFObRhGpGVvnCR+yvzcrhioK7MKWQfj36eg1H426kGhMulnxLZdFhpe1Sj8HbtcFRHQDj39V6hLiHuwTbVELOf+NPz2y7+J76J/9m+D3vnhq5iwbFwnVqLp5Bo1IpIGhUBUgQXgaBW3CzV8c2jLgPZEOocW5qiBVKeEIhTnCnOOwHYxbDH3P8y2ny/WXy5hxBEI0LEtw5ALrHLjBFXBvNyyqNidOScdydYLOvcGMW3WhCENycQP48fpynZTIkcRXvqm2E00J/w29cAihZOyz5dckH/wj92YK7CJomj1kls/ra/TFxK7OasnYs6zlarscudMar88dliekKPDPBJ9ttMDchUODIBJxtMU96GjSFCpiwZLNroSNeE1ZWTXZMBxJ3ZlfGeL0SZq5QqMXqk5Gbp+1qeYZXPuTAoFIuuuJcjyeHJ9bZwq1S1xtPTa+h4MaNG6VFsOJC1di88mgqHserS74ZJhREF24ZO2mroI1WAjuG1hjhFCoJ/YLEbxFdm6GovqbXY8NgxeaywI4bJEFfA1V3fKJxo1zuK3B3fDWLtN9G1JTlW+CJn+fA1R9P8j1WRFVw0/uCIIgGhAR3jtBNW2/8/2TkQ89EZ3trS4zf+cRTLPM3DxOimlB3mo/hnqVvD/2q/2P83VIrTenajTTTyh3xqCyWGttVcWXGROzjhmCt3sb4Pb5lmbudxvfnbeFm42PJzrA2uQz2fVzGCXO/dpXcpoFs4cDOt0QvsJLAxSTmRtFtm7eusgWTNIZbwaUcueDtkZASj3WPKwlbSJ4VXKzvvnxN8v4UcVmkqyuULNJeqFq4RcGdaoEpu4/kHdegVFqdy5HZj+dp1dKEe/x9iTSBKt8ERunMAh6IS7kwBb/MXANBcflHE2BzaVUgc5fNLuXppiHPNWADt7LIS7cW1BtQ6POfW34bn+uL/D3MrP5IcBMEkYGQ4M4RCrSk2OoRWushfsEQySktkZwQLS0p8ozhRrbqzaza3rJjokjixWJzqHB8kbOvWYeF27TmorXuq4krjC9qXuivNwW36DrP72wbFm4zltdXcDNXcaiC0qqYtYtut3PW//YW5rrDEo410WWCm81fCWfh3iJxexVF7S6hldbvO9z/i/E/bwVnSd3kFm73OKKJylonsBI3A4rb7CFtJ1rpv/v9DzXL9Zaltbdc10CY19SlPF+LBboINpKm+RzzpvD38HgE4+gxm7l3Hwx8n4U9Fpr8HOP7wc+6arxf0qTe/MWqlvYNAUz6+PzQuRlj4W5EGrt2JasCnqFg3haq1td0S+704GfhVtTR9cKareWBbZJhqMvPM9ZARbV3zhKCIHIPEtw5woh4L+njvIX7q3gyGdqcRDfr+bBkUcIsunwZLr6vaCQp8LZCM6mFmxfmLTTbSt43+iUUlK12CUuU1FVmVvF8UyBjwqW+386An2eusdodunMH2GyVN5MkTTOti3iudgx33PHFhosmNr5QfnL8GFs+Y2XSRf2ct8a5XcCZRRrk1ler7ri5abBPaBHoVaXegttMXtcUKuGNPxdYz2Nt3qWbylxi9QlDeAEs21QqFb5ss0JWksqK4dfDxo+fpR7Hw5i8zOnqLp4DI17l9IJgiOdwedWX0nauNZRk3lQFt6rruUyYy9ZSqu6XjlhAVZdyHws39tc3+hX8JzIcDgv96zkOfmMGPVW81ui6cF1kXhVIKyiBKfnXw/VrHoYGc111vAYyno0l6tngGxLfklWNU7sRDUAQb1l+Y8RfcAd7I6vGcP86cw0c8vSfVtLXunLFgAlw86Ap8Myvc3M6QSBBEE5IcOcID8WuNP5n5bBkcc3lVixylb+F27T8NoMKuP7TSW6xpYV8LdyiJZxn50UDXO3aNMuDLtoGS5Tz/LuqyBIW27ZuBlvMOPS2WglUxxNw4Xvj4ZRXx8CiDSUOMchc2b/MfxweGPQXFFdUw/qipGBm7apCTSzrJR5j9mqnRZ+Nnh2ztUcNcyZqedfdlouTlmhfC7dWAeXcZsBRz4806vOKVuTZevfkOcUTUkFr1TDnLNwssQzvHcDKtHklf2sGtniOQAJ+mrHa8xwYW7bK44bF+2o89JIuJsQSbVAln2NeIH+Z95g0QZzoUt7Sp+Y8f29GIKZUBkdtvacq0tXqcGPuA88YbiEJm1d2Xv6a4XXxWtRihnrcIOtVOhZUwOunsiBsSEtjfWvLVOeruj7O5pJV6SZdGiSIOPmg29UX6RJ6fucdCni1qjrHb4xIlkcdMt39fciDyWAHT1mZMlnj1OXJHCrfTrE912R8+NcSOPjpP2DJRvkmNEEQ2QUJ7hyh0Mxsna9VQwFUwm7acsNyy4s3Jrh2CK0zhFhn2Ah3R7/2dClvApUwdNY6t0Xa/KYqsizczsREmmaL/P9VX+XsnKsXzMYWDoXh8PAsz3Ozjxu2LdxaMfQfuwT+XrwZ5qwpguNeHOWw5rfirO5HLHwW9n50GBz41B+wuazK6q/aFNxsE0IsX8TasRrmrTV/wc3TacqLxv9YX9Rul3AkpUOLMr+u2VhS6RBIMxI7GP+PSvRMvp5bITg3F5KCe+byZHb3VYXlVmIZJsxRYLLr75X8rZlmnz9a828ZNDXlueL9pmLhZps47v4EqstSCumDQnMBip2hEwjOJd/u57z/gRe8gMfs3Xp1MBmtq2MxJYsK/qaypjXKh3nGcCcc7bxiF3lLOF4XL8FtbdxgGEVVanfHF4bNh2s8EhjxQ1b1xFRd4qdTWqY6l3TFF6u/pu4DTHd252w2+mVLlvKGxBEn73Ntg7Zwq6J62Hu/nQF3fTUdrv/MP6mb6n38+E+zYV1RJfT70XttRBBE9kCCO8s5fKdtLKtpTE9ezkvCw+G3/PvgvehLthW5eYEluJD7Ip/DY9H+0j7LBZdyjF9yWq7DDgt3slaxLk2aNjB+PDxefan1nB6PudtpGjxXfb50LFgijLesWxZuKIanfpnrGTveWbNdonfQbHHGW7Grw7YIxM0FMW6O9VdonmdLdI+XWFZZO95zIK80uRt+3Sf2ly/rvdR0Kd8ltApWbin3FEgL9K5W7Dv/ev6YWOecZWRfW5h0s+fLQ9mbHyErxhzPlV+AMy8G9Ghg8KEAzrEJgtszc7uzXZ5nwjldyaXctVQtXZ/Sct0ttMHbMst99OEGFGxd4WpXxXkUICzswDUybmjTVmyBEfPkY3O5lCsIB+xaJYYbhbTXgjSsKLj5ut6XfCCvry7yx9z1KUUcJhsTS/3JF9uZr6RUvBJUCPpM/a3+jUi91SPq3guZfx9nI6qCWws4Tl61P4zLRtAIEGRpQD7RLEEQ2QsJ7izng8sPgOb5uFDWoBCSVu5bI98b/x8VnmEt7V6/aD9LcCHXRX6GbTU7QZgshpsJM4xfcghu5lJuWriRE0KTpcJXbOfMUp4Exc+QxKHG78ztnTFz1VaIxUxRp4UcFm4R3n2aZ43e1vqdT8K2pqjK4WYvGgjZeTBLvkGl24WatVumd3TV0l5fbItbdtwSztp7HDdvdn9JivRkCbT9QgtcCw7ems9is1dsdI/NEVLALNxc8rfFG0stL4av0FXbpDnnXu4cW+qSZdJ2ursdH0/PmL54lbS/uLmZlLrMmNCO2+DhEe8RvdJ9P7UscIZnjFvgX/8VwfO5sr+8vNmC9SVOC7dXYjpNFOZeFm5RcHuPyWqnYQy3vD/+0Smm22NtF47iI9d/6r7PU73Gi80+cdTiGjpoo1hQycXT5hadA2v3hnSfT1+W8vrZJMnEy686puBjuBXb1dN+lWrixKA2+b6etAJeHDaPNoQIIk2Q4M5yCqJh2He71g6LM291ZIvtTq2bWpZr0RWZ56Q9O1pJwtDKeVP4B2kZL4S3mJ8atmtn25bw5O31bfwI67kFqzdIkqZpUGSOvYlWBUsLLoa2YIvHECu1FEKX8pZW0jRR1DEB0jQvAhMTu1iPd+Ks3dd9OtkaH2p/y81aQ/d7zTMZGhPmGza6rZesHVqkB8aS9clX6O1TJk1Dzg7/JbTSIWRapfcILbOSsMmEGBOOWIcdGTZzJWwtdwrbkNSl3BYsfObVZlxsN+9eLjuHdVbN8ZjjCxx/x2zO4hoFwxtULNw/TLCTyPF9YpQ9T6KyVLoQdyVNK5dbG1z5BSrc1uto2Nnm+vCPkApZeIE1FDMTPmvnvY7SBZfy1ELacCn3jOF2Wri9su2qJqYT8RLwjr4VFo2qWYCPfH4EDJ3lDimoCbVdw6aO4Q5mcTxi7nr4dPxS/2PVQj5louDKNcjboH7gNxQDCY1Ic4k2vYEF9z3fzIDX/1zoqMRCEETDQYI7B+jcqonDkoyi1S0ANNhsumPLYjYZ71y6v0OY80nMRAs3/1XEJxSzRR5Ywrtv9bXG7y3BjtG1XcU1K5EY4+7Il27BoIVhi2nFD2s6PBz51PEadq4n7dUZ9tLsxWonbZPc6quHoI0Zl31D+EfXFzDfbhMkhf5tb/8A68zka/Zxk+zYoQV8Fz/MshBPFb7Y2PhYDDfLoo5MN2O9ecE2PbGj9fv8dcUOQWWLLax1btccTyaG44VY8nctFLZDBTiXcq9FB+92LpuTTXory8I9lYtTRyGELsRiabNwolJaBkW0cHsdl7nNMxIesd4uwV3qdiuXlg+T9Ceucy6OJD09/NpJ66Nzx2XgdUYLh2zRxd8DRvkwhRJtWG3A61o6XcrjPgKZ96BQqycuc71HxPNSWTL+3zvj4ZvJ8kRC4rm9MHQeZLeF2L+jKwdMhId+mAUzVqp5GlCW8prNiSr8e68hXcXTHcOtN+QcBzyvgc9dPV0MVZfyoLxqalrPPJspLKuCJ3+ebZSXJYhMgQR3DnDfKbtBr26tHZZTeWZxDf5TdZ/LzVqMazpkN7tsWBI9ZfbxY8LTrczU7Nn2Le3xMAs2n8yMj/VGocSStSHlnCi1En9pYYhBBEpMC/yVkaFGcjjxXJvmR+H8Kru0UUet0GFhFV3ekfMio11nxbebn0jGU3fT1rsW+0yc7NyxBZRA0g28hVYGZ3Mlxpwu5e7rdOabyczQ/Bh+MMU7cuLLo+Hy/hOkY2OWa/RsEL+bWbtIOGzVRD8+PBkmLPGPM8Pa5GJmdKM/0/rO3NNx46OoxBaro+ZvdHoHmHHBOLbDnx3h6ItdfR7M3C6C6zHxntMlFm6Z6/mCFe7MshuKK939Vcst+jwthWz8MguEn4Wbh1m4rxrgdj/nRbuRzdxD+zqEuaZmCceKAioLPcxSr4pKjGGZRxI2cTPh7q+nQ12o7/rFQVmbVOHzMQRSmzoHfMoz/RT0DLaq5gpB3APKLuVQP6gK6VSeP6sLy+GvBfIcGTIqYrlf//vhH2bB+2OWGOVlCSJTIMGdA2BZrbcv2c9RlkpmRUbWmkIbLZNiJmnGvtsnE7GJ8bx2tnD5bTMj/xq4LTzYEqChkG2VtGp2g0xwJ/vjx8N/xTAXa7RwG+PhRFlzzmJuCRBNg5l6D+hZ8Z6RVMzruKKV0ytpms7Fx6NgwVJe28BW+Dj6DJwUmuCIRS82Nz1aSmKgWTuMpWd108XyWbxluJTzNMB2izeUSjPBM3d3mXXY3qwIwb6hZHmTs8Nj4fx3xwujAlf2cRwLX7aMnxOML7fEdPkablzsPJLteJd9loVdNicM3vrOI1qOE5Lkasks5c4eHxvszBj76vAFRjyxbt4XvhZu4W8jaV6KBZHXe0qEzeOIeW4LfAXneu5Xr1tMmqZSr/vb/H4QLpS7KvPvB9FDwQ9xU6YhCFJzfTJ+qXrdcL1hLYN+a+1aZSmv+UuIOsx3plmus5qA5051c84rN4a7P0jLJt+hz/wJl374D4zzSEyZ7g0r/N6XebfVJ7NWyxOcEkQ6IcGdI0RCmlRwW2WbTJEscysWQWH3e3w/6+/WplWad09nvBfr44gBviv6jdStliUA40uI2S7qmlUPmcFcvZ0u5e5vNL4/a9FsnmsRNLcSnvGWdT7GfKVuby64XcrtOGkWH4+lwVZsLoP/Rr4yktK9m/eKNS+aFoJi08KN8y4mFLP7C8Hn8WON37fR5LW/kTLTki/GXTvPQbOT3GmVMFLIkM2HAfBx7bhhgPy1QJ7J2+gPKmGssHPO+kMX7zV6u+S5lsuycjNLeHJsvUPz3S24BHYM2X2pywS3h4UbPSDE/vgv+5eHJ8eh4lKuSkLVpdxhCffG5VLuKaTtxz/LexqgSn4O4iZAu38/UqhN7r1A6gSb4K/82+DG8BBPwa1nmTXkL9XFakBnFnTG62Dcp7NDNDbkvZW20mvpnmRFgng/6Bl+D6gL83pyPVc82fGLnaFztWXgP8vgpWHBhOxghZsDnhgOhz0jD8eqL1SvBa4N/py7TqkMJkHUFRLcOULYQ3DbJD+ASlmNba0KDpCIIOO5aBhurL7D+rs1FLuspYxP4ie6Xn9qeIKrHbNwo4XYHpFTwKN7sigI+eNi0jSRtly2cluYc8fV3cdl7Vo1zYMbq+6wXOw17nxbQBlnudYc40f3WOdxmdB3uouLmb6ZpR7F3kYzBnobbSv8MM3OzM0LUD4pHRPcHWALnBsabSXGS7qUs6zyVa5SaXzStDdiZ1uPHxr61/j/0R9ngxfY340Dp3j2V2jOSV6Vd3Z0vtSYLHGa+LWIydrksd5OUffz1GRCORFRSOOmwWM/uc8xT3NmL68o8ypHlpqqeFzJMswL5Msiv8Mb0deksdK84P5fdBAcX/m7R3/O17Za7tXOuWLTPDYX+Fai5wXPbZHB0FXbCPdGvzD+rq5D2ZraahO/5dT54RHwQ96DxntFlaUbS4OxcAesBAKvYZ5NOyFeBHQOW8uqzZwXQaCpuZSTs3jG3J9Bu5TX1xaJVodcGrXhf9/9C6/9uRDmrKl7/PPYhclNgE2l3pUl0im4Hxg8E64aMAnu/qZuoUwEoQIJ7lwS3LqP4NZCcOPRO0IZFxvt1xdaChcmOht/NzOtjkww8jWMmaDlOSrEPrzsDz0WX45C/0BtDrwSfcPKHt6swFkKDNkxtBpOCE0yrN62K3sYLj+kO7wfO9Vqh9nKXQnCuOMWmRZnR+y4+bQW0qDYFMgojjeUVEJPbRFMK7geZhZcY5RQSp6vbeHGfrC8E5/h3a4nHnKU6boj8q2ni/p6aG1tLNz+xVTwKnFluYubifAG5j0FL+a9A7dHBlt9sTayUmm8m/16M7M4eyYVGIfOQBGMrtN2mbEQbDVLn0Wr3O5brN2wxP7WYx0kZejY+Jh7OgrkD8YslvTnXEys2lykZAnHWvJfTXTX2Gau/4yBf811xTarLP4eHTILPvvbziOwW2iF4f2gYmk+Lfw37K0tSXmud5e/Ju1PvIKhanmpNIzv5tElteTdFm7vxZsYpy5zeazJwnkPbSl8En0a9tIW+xwTYH9tHrwdfRm6wAZPUYPtnou+D71Ci+G+6Oee/em1Fawpn1fr6ctJK6y6vbV1J80J8ZxGej02DA586g9XZYdsEoP1RdDn6tdf+rwIghVv9WXhViUecL3uIsX3RRDu+EGjeikGT00aO1Q+iwmirpDgzikLt1u4WmgadGyRn8IK7vziYNm0WSIrW1jan2bMnZmHuVKjAP37/mSZrFLO8vtV/uNwVniclQE9FArBT7ce7ugDLWjv571kuK3aFu4QXHTQdvBk7FIYFDvGJQp54ctgQrmbZrtOM6uipoWh2HR1xxJo74xYAEPyH3K51Tpcys1s7HyGd9FSH9XilhXTMa9c7Dgrb1agVTtir3mx5aidbbbZObTKEmvJNiHr+txhinB+o5t3n5+jd7ceb66Vw/JN/m7U25obIkUV1bD3o0Ph3HfGOeLfWVx7pMrOpMzuDNYO3eJZCbHmnLU7OSZ7E4e54uO4Zgs760nXc+diIp8LP/ATq02gQvrly3IZWO20Spi2QsEiKtT1HjDOHQ99a+R7gJgsZMMtdGVJ1tQtKkJCu2p5jLkrrlyPK2Uz90IsJ1jXte8nec/AkeGZ8F3eI77tMP78lPBEeC3vDaV+k14qarOpWpIsSF/Wmwc5vUfqkqRN2fU8q5z9G4bFG+QbVbV2d9ZzQHGnCb/7U/W9nK6pS3cUgEp5xpoQRHf1MSeYgTzV53W2hGQQjQsS3DlCJBTyF9OSUl6efZn1h1kM8RXhoXBz+HvLRZq3cGMN6ArBss7HZm/bqsBapDMrpmxsLQoi8E9iN9dTWKfadtkOQ9j8IN1iljhrAeWGCzhavcQEcSxZF9IztFhSKivkzBheVQrLEh1cLtCn7N0FVpl1tbtr61zZsHkrsggfx83and6riyGkE2biLl6IaoLFkW0I8GXXeLBHtOYxcC7Wcm6S4ibJb/Hexv/nhUfB6W/8JRVvm03LdXvTrR/juNFteOryQqfgNjchtHJ36SLefb6chTFwGwuVsbi5ME2226K3sDwWpq+wLebFFdXwzqhFduI8EyyBplJmzDsJW/J8WQw/us9f/fGk1Iu/mFzUuih0W9Vl8d0sc7xsbKlwuYrH5WMT+9M90p7z7fws3GKJNpnYU8+abecxYBtVqcDKBAvXe4skfsPMbxwnhSbCQ5FPfRPTIf0i/WFA9Fmznf95FZZVQ2mlfDOoNvT9ZoaSu7uvGzP3uZQLVnHle0uxP/W9lhyYvAzEWXpN9TVBEKwoqy+Npx4uEmy+h0C8CAKeYyyTuM9jv8N1nzq/qzPFsk4QfpDgzhFCIVCK4Vbqy7JwJ4USJge7J/qVYXFm4q1La1uo8nWlnQty5zHFdrywxGO+EjtXcHtOWnD52OyQ+UnKhChawtEFfGzB7dBeK3R987H++JJjluDWnHHv+1VNhl8TB1l/F5hi+aAe7WA1JC2iHYxj6Ja7Od+f7O3krE+ebHfD0TsbmxbMO6AZl/2aFz04L2sgmZiss1BLnBEOhy0XdmRQ3lNw2+dTpfW6kZPDyTJUmLGcd6XkBVZbM2Hds9H3jP/5GGi+P2bhHv9vMvs5DxPwhss7l6kc2VRSCXs9MtT40mT9sRrxmCyPX7g8/tNseGHYfJdoRME98B/blds4lo5Hc7uUy2KM2XFLzU0l9CBAsZSKRJWi4K7wdrPnweR64sJGmnhN4gYunmuoqkRNcOtegtvuL+wjfnnvDmNotVyXrSosh+eGOnMOqMDyF6QiVcb4d/Nehqsjv8I54TG+53B55Hc4OjwdDgzNTblYrYwlYM9HhkJQYH//+eifwIRKEOTaWtZPWNRGdAQhzLNljvUs3qxQFciZOPaGIBMt3APGJj3Khs+RJWrNHPd+gpBBgjuXLNwpYrjZ5yerY+1F2LwrvOK9USx+dEVvI7ma0U7oD105ZbeXZ/y4phlW9fGJPeGoyqSo5+OYrYUzZ+FmLsgnhCdbbQ8KmYt3zqV8UmJXV9ZzK6u4kYTN/mC+pPILR6Z0ZuHG7OPr9TaWC3hbKHZkcY6aCbiYJal/7CTrOT6u2rIim+2YYGWx7MkZ4xbRoMEqMxM438YxdaEwLNS7WH93EoS56Gb/cewEaT8yqyqLG1/D1QJ2Zm5Pjr85t6lgxcdz52AndUtam3+YttoQwSPnbbDGt9m0cLfXtjpWcX8vTp63THBPWZ50AUdLN1rB568rtvqLmR4ITQU3dus8TIs5uydRmKuwfL1//XLGqrXumLAd2iXvWR68x9yLVslKJ+5OOiMK80il29NAKjw58Y7ZWTebCW34dn5Zyl0Wbsl4VRbil7z/t3EPiB4yqYgIMekOuHUW3jMqFpbttHVKwgo9fNKx9F6xWXGTp5EQ9OaCSl36mhw3k70IMnJsuqqnBtfOpyHVOg8G1XCWhoQZXFK2I71NZCAkuHME/IDxdynXrC+pa6v/m1K889Y/d18h2HXbFjDw2qQ1uEQQ0mxBzNyYj9m1vSNxmqw/JqRZGSnGrqGVthgKhY1YdVnSK0eJME5wF5qikGVaN7qxXMBD7mNxLshWSTXDXd+Oj59ScINDAFpu4+Y59ItdZo2Pz9LNH7dlQcSwzjP3bhv7S07MZu7FO7HTrd/5jQXjUIL1/b3YaZwg1aUC6x2zTfL1TnETMb/IeJdytOKLi1a+BJpdJ1yWpVx3XCekh+60XCf7011ZxjHRyfhFm+DwZ/+EZ36da2QbtSzXTEh7uJSz47KxyVy78f0ielxc/cFo+GqS212cbXYtTyTv9c/HzHK12adrclOBB+dEXNZILdySmHDRwh2plN8jrv4StoX4gCd+h/0e/90Q3XxyNT/rMG6CObqrZXLcpWYOAZW8ErXBV5hzRCEeeKy0ckx4YPjFvtpc9tEEGLdIrQRaY0H1UjWkAEl3DGrmSa30WZ0bU2Z5/vMtnsLz46L3/obrPpnUoPcxWyemhCzcRAZCgjtHwA82PjGZpIH1K1qSN5pJu/zwtnAn+2Kfx36Wa+TtS/eHj6860NOlHL/S7J1L9wfqwaE55lNh26XctHB79cdgMdpYI9x+NrkQ79Y2KRgXJTo5kme5XVc16SLdbhcTkrVpVmwwlrmSCe5ubZta4uy00Hh3G1OssthmliRN5m0wWU9a8cXzS/bHXLuTbIKWlhjhy5bxAmtGoof1exshdrxFQdK62bl1M0eN83lrkxsaqwsrXAni2CYKm1v+u5C14++hm6sHeIrLKtN9/tzwGGMT5aL3/4aNJVUuyzW77vz15GHzwkqvebkpM0HOhxm89scCyfgSDq+FWKkkI7tkAYNJ4lRcyv9esCa1S3m1O0t9sj+n8AzF7Huy1Kw/On2F0zruJ7j5HA4/5j2gHtfuAd7n9YFf4jdxHr1El7jh5LfM7wwboaX5fmkIcYaHwM0+rOYQqlQr4TNhyWa4+H25i3pjxdelnPv92BdHwaSlah4udaXxSDznHAcRN5wul/JsEeZ+Z8NPv5ZisxTrfg+bvQ6qfcqRaWmycAd9XEwci/W6/c6VIFJBgjuHYNZQKYI1lyUqkrF7p5aOGG4RPgs4soWzTjrambdXQTQMB/do62kxR0t4ROWDNGR/pXlayxFufCxOGmOWlxZcDDeFv7cEzVG7JhOkPRe7wBLevEWU1b5m/Z1V+Zj1HO+qjO7NyfPls7cnz/XTvGfg/sjAZDec4EZL/XvxpCX5n8Tu9tC5r0P8ctkntMhyKZe5fbNrcVXV3W7Xev6Lx2yH7t0snl1awxwA/tV3cFjz23E10YvLk3OyY8cWVhw9Cvfy6piRPfTPuesd53Hkzu0twf189D1IlGHiNRtNUj97UZUzgzgvAPna5M+ZMeYygcTuNS8LN+uPxZfzye38xG9rrVgaH8basWz2CUkiOTxLkZZQ6loAyTKX3zloYsqxrdmk5lIejsuz0/P9HW7WaZfBkv0he4eWQrPlI6EuqCxna2MpkXoKeMyPl0Dm5w6vi5cewPJ+4wpugxkF16W0DgUJ1kTH3Bo7/ZE8bmNAdWa/mLAc/l3l7RnEqMm1uuEzO4SJSB9BvL2yRSCrnmwQnzi6Yhw0/4zf5mLQhmYW7tjQXNl/ouFB98rw+ekZAJETkODOIXgL8uyEXQJKtox/NXaOZz8n7dkRnj13b1dsttvCleyRWWHd2J+20VDIx8JtJ0PzRQsbSYRSWrhNl3iEZchm9I1+ZY0qEk5aS9eZJaLQhZzPpI3x2snjJl8xXe8h3bBgYi3MHZffXLg+8rN5lrbgRgGxzowLby6zgqPwffRkGBhPllUT3dPjnOhB/kzsZ/3+QvQdV3/8ZgBLUNYOiqRJ05brHR19XxEZKk2axqzIWJoNY7Lnmlbu5LO6VWOdF8n62FdhynJeGNqW8AlmvP0GaA0L1zuttey4vGv//iH3lx9rx8bGx2aXVcVc7djYjgj/C+eFR1qZ0UfN3wCxRMJVw/qo0AxpfJgluE0LtxXekMLCjeXo+Id/mblGns2c3Yt8f0K7WKVXlnJnO00SD45WHL6/h6Ofghf85ojRH2cxF8GybD/lPQAPmJtO8v5Sfw2pWr74RbRs40LWH4pqr+7FzQqvHncPLQvEzb6moKcH0mLdP3W35HEnd0X/CTBHKM+XKajeC+uLK+G01+1KDF7UxPvf69Cq8cWqpN0jNuANI9U63Jnuyp7r8O8tv3uQhfYlX9NwmxrpSoY2eVnSY+3LiSsb9LjoTYeu+1jVhch+SHDnELzVV4w9FS3cn8WO80yghmLwgt7beQtk4UPPKwaTt4SjoPZyeVe2cGth6N62Key3XWtpDLfdjhPcEis9n/UcKWbCEcrkybPM88WNBnZcKyO6EVeU/Mbp07Ozkb397H27SI/rsF5rnLs7lBs/KJSPCU+z2hTkRWACVyqtI5c4jR2Td+9ljIr34obujlffZIYTtOU2DdicsIzn0zm3cttKzNXD1rCkWvL+6KgVwh0fj4YL37Pd3lm7JvlRLokelqSKwZDpq13tUO79Fj/Q+H1nbSUUVSTFMfuiYeMrMq3qSDvOQi/2x94L/AbK4z/NcV2LSs5lHC3wyBX9J8LlH02AN0csconV6yI/SzeHmCs7i2tvyZ0zo0nUft238SM4C7d9jJsGTpEKRVmMebN857VHt/gVm93HFc8hFPdys3e2Ky7cKF2QiQJ5+KxVknbJ/y8Ij4S9QkuNefOiNotsnLcF6+Qu9DXFKPflsWp0Z3iXt+OrIOAGXENZuMV4ei921FbBnZGvHe9FPzCZ3SUfpHY9v/ebGbChWC3hoAp9v5kOmURtLmNjzWodBA2abT9g7Zb2TZIA0BXFMn+ufkkHg54TVcFdX9eioV3KX/p9vuG6P2SavWYishcS3DkEL5A3QivfT6AN0AaOrnwRjqp82bO/VBZu9uW4STyWxzFLBWuzTUjtg9SM4f72xkOtWFmPhi6Xcj4ml3ftPnGPjpaIQ9fotpzVl9Gqqd0HE+cyl/wWTfLgr3uPgUfP2FO6WeEob6Zp1iIdRf6tke/h/8Kj4YXou8ZjTNSgRZfN2x7act9NjddjZxn/V3NZpK0s5aDBQ6ftAbt0bG55JPAu5SxpGjsuv6GBi/pHIh/D+PxbudJrIcf9cUj1P1Lxlh8NOwQklgTjsZ+zM7Jva24srCuqgHVFZtw386YwrfNesDlm8481ytuY1xStx+Jxeeu7uJuNtZ5FCyduULnvVfv8tppx7S01d+1kTbc3NeYktpNauMV49bWmF4TM5T1PEP4YAoFz5jquGMPNJU2zzkB3W4Qn/jPW1c5oKyzEFq3eAF6cGv4n5WpatmnkbuPk7egrcP67du4DGaprrqRLufdz9hi8e+RzEKCozbQMv9/lPQK3R76Dx6L9lV/Dste74O7/LyetgAe+mwlB8dWklQ0ax9vgaDnm7hwA6jHSwc5dLgjkoEnUwsLtt7mYa1McSyG4h89eBzcPnGLEfAdJhenZSWQ3JLhz1MKNVkJXWTDhg3Gp3slbLAtidWGis2cM94DYiYYL++j43o7HxQVquafFPOSwcFfqzjq/FkYZr9QJ4rCMV4cW+VKXcnSH5etwH7FLe8s9Ha3GPUJrXf3lRSJwxaHbp44dx696TYO8MIpR53ExwZfDpZxze0ah311zHtfhAm5apF/Le0N2stavbGwo4vbT5sOQvP/BgRorlabB1YfvAF9edwhsMTcrHDXCTdfpmPmRwCeZw1FfGRlqxJFfFfkt+ZgWgg3cvVMleDnwmxo/xA+zx1gidxXH68JKr3XUthhn/9XEFa52zDrvhSYRQFMLbkgeg7v/WX/iuN39Jefly9jRxv+jEj0tl3KWiZq3DLNs6zILt8adK7vn0FIrWghtq38Iqsz3giypW1hYzWBIxDeTV6Zc9Mgs3DLB/f2oCa52JZUxl0t5D22N5yKa97YAD9dzvr8D2P0qGR/PYeFZsEVSN51fJGLehtaliyEVfi7lbgu3vB3/fsWcDg2fpdxfgLAQh+NCUwPvPyhPAwYLG8oMan4dffcLFLtrvGJQMV65McVwN2jdeft3v9nhN53NfeQ63cdoJb9/8Az4VvL9VZ/U9H0WS/G5fs0nk+DnmWvg6V9sb7pACGgTEr+XcnpDM8MhwZ1D8FbV6YkdhWdr/uXiEC2JnVwWqb26JAXXFmgJp1Y9DU/FLhEO6by9ZEm/jP40547pmIRTuHv15wW6qI+852gY0/cYl2s3WnB5MRiPJwwrJ3Ollh9Xg55dW6WOHTfHhzXFxczt7+e96DguftCzOG+MzRZdhvkF/CYfqy7fjl3/E0OTYHD+o9AztATujH5rtkuOLYxjkyQUYxZu5qKKYoXRgXOfd56rBsPi+1uZyh1Pc+f6a+JAGBXvafy5ZI3TGmpb4O3YctwIEJNksXbM4ism77LbuV3PkwfQHSKIiVqvZGliO2ZZbwaV1mLjnLfHOc+Vy1Iui+FmKxO8Zmx8eI1mmomd2Bchn1mebQjwWfGRl3+fD1vLKx01x/FcvuA2KexzEJKmJeSWS1FwYw15rHHOGDFvPez96DDXRloHzZ2RXRpuUi2PMef7+yb/MYitmu5KfiVLViVa7mUcvPCllG0ujvwJrUqXKCVN87Jc83OMFQAaYk1Tm2NI78s6EvTeQqpFbdBTSwvQ2s9xVs9d49TbgcyPw6Xc9x5Qm+Rf/10Dn09YAf/9OrNCSkRU7/ZFG9webjxfT1oBF7//N2yVbBrX5biprPMnvzpaKVSIqB9IcOcQaJFeZ8ZufxI/oVZilaeCi29dDckyV3x9bcw+jqKWwbsyG+2ED1u+DJWTZBIxRt/q641a0D+bMb2yc9imeb5VzouVirKaaSFomhcxSm+xLNT8mHhLczIjuwZFKYT0mft0UciOnjwHtNaLruy9Q/MdIhS/o5goj2pxR/kwY5zcuTILtxy7XTFn4fYCx2bVqOaOyYSFLIFVK5B9eWiOrNy9uczoovs89jkqkbR0xiudC37e5Z25uqN1/c7PnO7C7JrhXDxRfYkVNx0RNipYu5V6suSaRXWZY2HAxBqfYV+WF4DNC8t1wJcZm2aW0uIt3EXmfMhiZVnSNJwP9t7AzQy9OtknGx57K2C7aog4kqaVV8Xh8wnL4dU/FljvLiZqmRW8SrAQuizcCYmFWxLDnQ9VRp1zxuM/zjbHJbqyy13UxfruUCVfhIj9rVs8w/H3fYPlLstepdx4Wpa5wzD48TFOnv+QtB2fTNAv6zm/WRGuh7remcY5odHwZOTDZPy7wnLw/dGLleMfU81JEFNWn/Pu2zOJPMm1kP/uP8d1jxtWvRRZ+hatFU4Lt1+Wci3QGO6icneOkmwm1efLPd/MgHGLNsHLilnPg/CYmreuGOavKzGOS6QHEtw5BFoxT6h8HvaveNst0jStxl8cvLjgk2jxMZcouj0T+AiftuLC2m6XfN1xu3WAgmgINkNLeCZ2sSXSrOOaLuWs63uqr4enqy+Ct+NnSPtDYqZg4cfAi8GDerTzTMDF94cW+LtP3EXJwm24vEvi3/M180tF06Bz6yYO67tVa1xg+F1HGvPhBdv8AM5FXd7OtL6HQtZmAFq40fUcs3MzYRkzN00Oq3jVei1mIXefa/K4O4eSLmBnh53xvnw2cz5WOiKIPd7NGjc9rDj/olUOyxnfrn/8ZHtsgrBlx8W55TO5r9mwyZE5mj0zWd8F3o6dbp5nOUBcLuDZ5gjGSYsx3Lx1047hLpN86bI4eefr80tWWu5oybGxzQ8NKpngNsXl1R9PhPtNAWolfjMFN2uD9UJ5WOK8FWbd97AkhpvvzyGkJW9ZcSMNhbkXDlGsYOE2xsG9z/3gE+J5Hr+6yHPxwdOsSr4I4a9tMrma/Di8GMdNhlQftVhWcC9tcZ0XUrrEyyMoeK8jkZfy3oFLIn9An9DfSt8rT/4yBz4d78zk7oVfd/tr82C72FLI6KRpvim57V9x84zwnJ5ASgNCQ/YH9YOegTHcQcfdKyXNzQQUL4bqx/oGIadNbQ+LFSVY7hmVz/NMCnlqTJDgzjGKoJkRl+0WvyHYr7uQuTwFla1skb2Bz3rOCVpHeQjh41VMhvRm7CxDuN9TLdaMTb7ug8sPgGF3HGU9WqUL8bWacyE+Rd8F3o2fbtWDlo1PJiqYsGBfuH32TlrKvUm2u+KwHfyzo0vqcMubheDh0/cwrJderuxs7lAg76StUjpmqZLg5pO1VRiu55id+0DTQs0s3KugPVxadb9VY1h2Dshw06UcOSX0DzwV+QC+yutnWzZZ/W/zWkY9BPfpvbqYidOSnhRdtI2O3V/eEh6HsGVxFl1keWG+S+Un1uOr1q0XYrht9+4XY+fZHVQ6BRprV8IlYTuyarT0mM4Y7lIju6jcwq3BH1wZt/brkv2xGuZ8XDtzKWchB/zutJj4LU+LG2Jd/C5l7ZjLfgjLggmiAEWCaMEt0Kqc72hNLswxdlxEl5Uzq/Z3s2OE494eGo7xKVi4IwmvvpznkBA+W6yxcIJ7e20dQCKWUpj71fVmvBt9CX7KfxASC36H2oKL3vpcNoU9Vtz8o4aHhuIg/l3tXRMb71vrPenRXwfYAt/m94PXttwkzcZfE4K2WtZGLuz+8G9G2R9pfzkWxK24BxFIf40Vde8AteeUPQAC+BTy29zLJFTPVdWDprJa1evH//lTXh0D5749zrdiBP953lBVNAgnJLhzFHdGXQ32794WBl5zkMMN3I899uwFF1Q+BMdXPmdZPo2+uTeun+AWP7LXQDs4s+oJ+Dp+NNxadYurP1xkRCP2a6oE6zRfX5v/vHBnmvb+8EYLJe/azWKuT6p8xvM1rB1+YPFW5E1i/XFuXsSkaWJ/6BJ/SI920vJh/Jzgwp1l7Za3c7uUexzU+BezvLPNAD6G+wkzezFLmsb3h2W/ZOeA/JQ42HromsgvRjzsgaF5cHBotmNO2DUSxRmbMbT4I7zgdrazRSjCQgA6GingyuDLvMfgivBvLmHOQizy406XckvU6iHDC4KV84Ki1XILN+excF/pcxDj6mLyArRV2/aWW/zyDU6BwSzXODbcbNlqbhRFKrd6egewpGmYiEuEtSvlrjuKQq+s5+waGCXM4s7roEst3HLLtUuYK1q4561MbiiIiLH44Vh5jT1wvN75EY94dTH7fKsqd7JEvtwbcm/0Czi96ueUc/J53hOg+xbi1o2678brZnwO9U1ttZvKIlh2Xzr6gHjKNjgf3+T1g1/z7jPaey1Wu2p2/oczXk/WH89EauJSjmV/FJplJbVx22/QsmANd6jcg79OAVwzXIOpkC37UOoGZEUBr9jbmq3e3518OVO/MACi/iDBnaN4uXcfttM2RmyzCviKf/TdYaHe1SF+ect1qya2FXqzjwD1HZ+HgHdlkHZYrnXvOuA+x0W3boyZFoX0PH072LniEzin8lH3i8x2qPdRxDE26q08x5fKwo1cedj2rlhv++yY4AbL0oy4MsFzx+zYXohbdrTjLOFcsjYRPoabbS7Ia5OHrEz3jEmJXazf7TlOHpdtLIjijFm1NC0MO3dobglufnEtc1HvbG5CfJX/OFweHgYHhebCo9FPXMKcnWtewll+S2zHsp9/NmqGVJi1aOX0DhkyYb5UbB2+l52ssP8fM6wvt+KKaqssGJvjwWYtbhBcvPmxsRhu3KhwL2CZ+3yeI0/C7V84M1Gz8VVyHiMbtspcrZ39Ywk43tK22EwEUxPBzScDfOp7d+IzWd4ArzrhIn7HTYUouL0QE7PdWP6+Rzt7TjA8JVQojx0XM9gnWu8AdcGvVFlte2QhAipunqnE9E95/4NJ+TekDDvYP7QAdg2thO21tZ6ii/8OKimXZ7xHsLTjD3kPwmXhoVBXarMsPeyZP2HYLPkGTmOyltarMA/guNki3hoD6XLv1+rrfRHwzpFqf35C2mHhJsGdFkhw5yip4qlV4N+6vIXby2W7BJrCwNhx9ut9XLud4+Nc1DVvC7cW4kQ/N7hKLrmb3/jE5G2aaTFnO38obtBN3YU5pmTsrn1gdzy3O2O4HNui72UJt2ud68aGR8+K92C3iv5wS/Vt3sf0qJsutmNC+siwnYxqjd7W+D/Gubi7XPU9+nuh+jxXNnM+Tp63ropxt1YvmgY3HbMjrDOzkGNdcqSHthp215a5BLKXpVMUgxWm0C8ttUug8eM7ee9kuTu28TF8+mKp4Np/52TdbEbRlg3yY4ajlmdAvCw5Hzs+8IuR3Xt9UbnjHNiGTclmZ1kt/lzZphNmbne7ituiiyUQ/DH/QWiacJ6rGOuNnPT8744M5Ph+Eufu9PDf1u9/LdjoKUJlwpctEHgLN8aYV3KeAQzxmpaXyV3P5ye6pDyubB0hW6z07u5fXo6h+qnpqsBQvtk3fpuBGzG1RTwtvs58bXk08jHMK7gCdtJWOiwiXl8lUS3m+9Wye2g5tNLKYA/NO36b/0zAe9VrychvdvpVF7g58oMR+vFY9OPADXQqbYsrYnDdp/LNJVUaqxis3yAJIuX8qyZ79Pg911E916D1rKp+9wtlUq2dTtQfJLhzFFm26ZrCvyd5gexnVZmS2Jn7y7sd3wcvzPO5JGyikNa5OEv+46JCrAGdYrViL3iT7Zpwx5SWlOIs4byAqBbrhXPH5bNfuzDbjVmwwdul3PwfXc+NMUFzQzz6WfOxdNWcRDd5f9wcM1Hr6MY8Il7nXTomx16cIib8vP27mmNLzte2sMVtQbRiuPOk1nJLvJlJ/ZgwxxhtfO7P/Lvh1/z7obVW4nnv8deBdynnrb/vDHdmuma99N6hrcMjAct+8TARWh12zkWTRLHUuomWejYfWCqNF7X/LNrgEJjrIWk1L9+0CtYXVUjqcKPgTp7b/6KDILHSuYjnz5X3Bnk2+p6jXdumUUuwsIz+KFg2CglbRJdyZPPyZGjAt1Ps+qiubOZCmAAu2pZtKnPFcON75/fZzoRubPw830+0S9L5IYsdj0tcuaevdMcOt2vqfO9aIQUCXqUM3e2ccxIqc3po8PAVCSYscIYwiLSCEgWX7CQ3DZwC89a6kz/WRLtdERlm/H9b5DtFC3fcRxzqvtfK7sM+P2NLU2Ex6Oeh4GdNrymZsC496vkRvrGZmYq6NVCtHX+fBWFBDHpPI2vi7vVgzycT3iOZhmqViqA3ovyEPn85KWlaeiDBnaN4ZgSX8E38SOP/v5oe7/kmj3OWTz/LNXOBTdXOy6W8eX4ETt17Ww8Lt7y/SrH0F3fcqw7bwbL+MXYImYt+s11rU5Awzq7q5zyAFWMOMJlzmxbLoPHnsUJv78iSLZyI8V9pZdzbpdxs06ZZnuf8Gu24eaxMaHBa1VPwVPVFsoNav2HUswizFuJ1+ebGQ43fvTYDkt1p8Oy5PR2lsPh6zE3YolcLQZfWTaxjoqVWOipTcP+d2CPZJzR1tO1o9s3u66HxA+zz5sSmHZttCm5T6Hu5svfs2tbhHcCXSmM1lZHqiHPO8mNFUqG6uqjS2rBpDqVCojbdcc3YxgeeWxVXMom3cPN9h0Y+KZyDLbj5PAZiuSy7nf1eQQHkXFDZSdMWcJbkZqOE94KCS/lrfyyE017/yzUW/F3Flc3LeimKLJmw6tDC7eVRWeluF9X8z8G3FJhE1POx3ohW6hTcKBCYmzFfZm/jFkl+BJMdtVUwKf9GeCYqd2M3+hU+57FWehDg+1clhjuZhNLdDhd07L2D+G0a8HOM11hlaem3EeLwxsrScmz8WxM3r974U55cLdcszRl+WXKedE1/tmx+qH5upMvC7V+iLUs2hHIYEtw5xF0n7OLtUu7D/6qvgiur7oH+be+os4XbKUI1NQu88EHw1iX7SwW3w8LNDY6vF57sz+67T89OcG/1tbA00dG3jBfPIr0LTEns5DoPbPdz4iC4repmOKryJZf45c8XLdIXVz0IZ1U+5nlcXNSUeyZX05Q8F/jYbFyYoRVzq0RQO2O43ZZrJpDxOrcsYALW5wNaC1kup6wUFhPFvBcBztnwu46Cbl2TLtnNNbTT2+LGFpQaVMTihpUeaQvFsC3XH1uws3uvL5fpno8TFtth1n6knVYkF0hs88O0cLdw1Iq37zFRcEertkoX//iFx47ZNFHqECN89nFecONGxXrOgsUL831DtrWXuaiLc6cLmw7umvJ8THjyPbSnttRxdfHtxP6elrDj0BfpSZd7vm3IFFIj470sscp2zPF9yWeX58UzZj1Xuae9xa8ouGXZ0d0LDllMeJgTg8mxVUuFtMzqDxWFKdvFK5wbS7/9u9ZwM8Z7HysDOI7rwYXhEUYuhHPDYyAed7viy5ZWb/yp5h0gg5+7E8KT4UR9XMrXoEAW62vH4gk48ZXRVlb+GgtuhcWln4Wbdz1XIgNFnriJkakuoKrZx/UMjB0nAqqd7nM1+LVVpm9yqaB+Hwdt4VZDNTY71fCwzJjoAUfUHRLcOcTNx+xklLg6aIe2rpJcfqDVa0RiX6jSBEsx9670skj7W7jVBLfXWEVLhbeFW3Qpd7abpO8GR1e97H6h2Q5rf/uNjxfwONYhicNgmb6tW3ALx8WEc9N0XrgL7XRvK7J6MiR3u+/jh8EGMaEbdz6y+HLm8imKn2/jh3scNtnu3P262hZdzjrMrFtoqW+SF4a2bbex3Jl7aYsMwZcclW65Yh+0QzvLFR+FCHMjt2pkO4R0U6mQYy7rTNSuNWPTk/HlOhyozYGdtZVcpnrNUfYOkzYl0R2LevFeHj1joVQwoFcDi+HG+uXOxYjT3Z0JbkyydffnE7j+ElaN+y6aXQZsclFrT5fy3TQ7SddZ4XGelvC25px20zY43saDJizn6n+H4NXYOcbvbaA4+TmguY/LSqXhtZqyLBmz/PaoRY5jixbuqlgipTdOKmszq9UuCu5Hh8yCp36ZC0XChtJdn//j6isiW8LEKtQEd6wy5WZA/5GzHH//bZaI21tbrJz4rYQ7j4cGjZS2EUcn+8itrWHjidiL0sd5d0R8j4jXdP66Eli4vsQxJ+h67oWzpJp3lnKxJroXLs+jOqBcb5isRxlDuq5FfR01B3QqUZ8bWwHfIPPXFRtlxg54Ynig/RIkuHMKdAF885L94IFTd0/Ztle35OK99/bueF4G/zb2s5jvtm0LpeRqtx27k3yR7fEF6XINdAhftbJgvrE05nEvO2R76NjSKXydGwxqGwJe53FM5YvSdqfs3cnhUr5Kb6ckuH+L9+bahaQbKKJbPN+fKw7c55xk1nC+vxfO62lZuGWwzQ9svxlaWpnFf85/ADrCZofw3akDOmEXQKUZk90JNrkS3bHj4nkz4dWMs0ozAaML2ccx6/mi/EuNY/+e39cWyeb4mCX2ssjv0BqKYXz+rfB4pL89L3oI7q++2hFbi+N/I/oq9A7Ns+7prRUxy8KN2aj3e9yusywmfivkPBFaF8523b3hsPNaLCgSNqC4/lprfjWubS+CD2OnGL+14TYzkDELNlrHxf7YvYheBj8Lybhk5chCG5J13J/7LTkXsthdFMivDHe7xoqeLF6WcGaVZptUrG8jseD6EhgwzrmJw6iuKHMla+Pdnf0FtwSsYy4gHlOa2V9CgZAzwNEnN8bps5PzmzLDu4LYwESEdYGPiccNqmrB+s72RZ1WaD8rmJpLOd+fv4U79Waz47stoTtyLdQW3PR6PPIRtAfvMAFVxMsoc9tvdNZSj9c0pDD/bqqdyyLTCCIMQN3DQA80Vj9d+1U1vQdyZfPD7zQmLPFO+EnUDbJw5yAopvfo5J+F94PLDoD7T9kN3r406b4tw+lSbi/2xY+oIbccDv88kMxO7iwf5mx5p6fLu/w2dFuQPbKUiwKSs4Tz7o4fxU4W+gtZceP/PCDGr6feEHDVCfcQ5qzUldgOBSbvUs5b0/y8A96InZmyHZ9tPNm5VuNkdrLyXDJ3/A7dd/Psjx0Lz2yLUDZux9BqbljsF80Sonz9cSa4Lz1ke7jggG6ORGe82GQZj4/cpYPxP3NRx4zbYW5hb2dRd7qeM1feTtpmo6Y4440Ri+Dz+HHQP3aSlRANY2tPC/8D7+S9Yo19xeYyy6q+q7YCKqp5q5zTws1fB6xhbs+E7R1wedW91uNoMUf+G/kKFudfYpV1k23ObC2vlgpzlkTuhsiPrkU8mxNsvc48h47aZpi2vFBwjU+242vSA+di72XBzdeqYFWhu06omMQvlUv5NmZ4wKmhpOX6gzFL4PiXRnHtdFeSMnGhxO6Fat1OJAfVZZ7HrLHg9hDSWPNdvYa57YbdWnMnQ8ONBvHas4SHfgzNs++punJseBpcrP/qeIzdK7woNubHY5XHzx3Ot9ei1tVfQAlDr/lkEuzx8G9QWqmWnM6LX/Luh/9EhsNL0bdStvXLsl5b0uGy6yfy+PHkgjsxcueX041kp4RNblzZ7CXot5ZK7g6idpDgzlFuO07iyszRvkU+XH/UjlYWbNkbl7cOOwSy0DAvEoKOLQtcydVEoYrirGVBxDdLua9oDMldBcUYbr6/WNwe66hEMubUHpDzuHxN8biuYOEWxwc1E+a4CDkkZLue8vHDXm720TDKMc7Sr4Vg8E2HwoArbas3shaSgolvx/j1drP+s4RtWjgt2mMTe8obctdWi+S73HjFzQ90Q8USQTyD8p6CXbQVZjvNVc8dRa9okezWtjk8+389oW2zPCvRGbo9M5qY1tEjd+0grw0vxn1rIbj+yB7wYixZ2szoTyJu2Jwzaz4mvrLdz8G6p5vmha165HuElqV0T15vurLPSWwnrTmO92zf6msd9ZuxZBrGoL+U946VKOzOqhsd/Y6f8Dd8MGax47g7d2zhcD3XhNhmjbv31poiGC3ceKn5t3KYE/DTEj2M34eMny1dVIsu5TLY+Y6K9/SsD8+Pj3FMeLohkl76fb7QX8LySmDXSoxtYzH8eA6sdBxU+1u4N5reEjKXcrFUmlj+jiHOkF8MNy/K+DwFPLyn0H/Cw+C43SW5KgQwLjzIFNL3aQMcf7O3Mj8nhljWVFzK0cItP6YjgaDmdmW3hpxyxLLvOrTcF0rbYfK6N6KvOd47Mtg9tVco6Wnhxb2Rz2F+weWwhxlWI0OcKhVD3KUfukMnahvnqXp7fPb3crjsowmBZT1WFg9pVHmySgDZhK8lPLiPhdp2TUjnLuCYcJ8LSHq7/iDBnaOouBamwsulXFxcei0A/eLInYJWU4rFi0Tsv1s2ifi4SGvSxYU7uZqmGLNu/z7y7qOVXMp7deVjqEX/QOZmzWVMB4D3Yn2kr3nmnL25Q2iCd4AG+23XBo42BabnMbm/cYNkpWh1N2lqJUxL8kn8JHgrdga86xibexPCEi0uTMHt8QHfM7TEMb4H++xuWcJ5C7fdXbLdx1ceyFm4S1wuuh1aNjE2IkSrunWeTNRpIbj/1N2TyebMWHSZuOnSJim0C80Yc5kLN25q4P7OUj2ZZb+7htfWPm/LZVvX4JUL9jF+/y5+mPF/S9N6nWzntISzeujHhadKzwWP+13icKNOO2PmsE/giZ/nwMSlm63kVc0L8uDp2MVWmw1rl0tdmLE1s9Kj6/lXY8SSaizWW7Pcyjdv2QLDJCW/eNf1VIKblaETM8Xb7dyfOz9MW+1ajLD5Y54SLbVSV9IpvpCcFZISK/c8Jm5AsHaFxSWe5+DlUq57uEL7Wbj5RGNegps/zuPRAY5EZdaxZW+9ZWNBiXh1rd00Rcu1ioX707ynQZckiJO5lPOZ/Xlqkr9Ehf7R5+C08N/wbd4jSu393N2RGyM/Gv/3jXzp3UjcrPbpbzttnZEbYOxCOwTHj1NfHQNBMnr+BpixSu7hUl9iQtX1nKh//MRb4NnHFXtsTPeAHvBrKB9F/UGCO0epjeAWv8S8BKhfz6IY9MKZKElTyjabF7XF4DuX7m/FjruSpnm4lLfTxEWB87jd2tqJuJyumvbv22/TDF6+oJfhduPnUj74psPgjYv39Xez1gFOrnzGepS5PxvPcdfvlL3ssmZYC9yZMV7tLcxbuP3vjZDLrf+52IUwJtFTOAW7HSZ3ds0Fa2Yeq6wqDg9WX+l9WLPd5Ydub5UQ68wlDBOP27Z5nhX/3oYrH2aVIzM3IjZxc8qTr9kWbgZzkd7b2gSw2cUM0dhqlkBrCaUud178Gy09K/X2VhK5jrDFiAm/PDwU2pqu0HmRMJy5T2dHf3ypKMv1XIgvF+PV53Plu5LC0d70WG3GYJ/3znhIWNm3NSMDP+PNz752jN+O4Q454vJvjvwAqzlXcDvbegg6axstaz7GUfN009aZyercgvunGatdopaJd7EWunhcFlIxObGzdCOHCW5+buOcp4vRl3nZDTd7thFX7RbcjlrnZm6BiooyJZfy8qp4yk0DP8Ety77Pg0dcnnButPXYoJjoZpK9OeOLJMN7qiUe+3hRLffFzwm+L6Or/pa24zPL9wn97bqmaqOrGXh7bRdKuhA3U4zLx8RvKnhtQDHwfd/C9GrxY3T+nfBj/oOOnBd+zFsXvIVWzFSfKRbNQOp1i/vlXt+fOaby/JYJeuDCPLcS3TV2Yx2RgYJ79OjRcPrpp0Pnzp2ND7Hvv//et/3gwYPhhBNOgPbt20PLli3hkEMOgaFDh3q2f+aZZ4x+77jDWe6qMRBEHIZXWTC/j1vR3bku7UQLcjRii7o9O7eC3+440rA4u5Km8S7lnIXbFdsnHPetS/aDI3beJmXStLP37Qpj7z1WUu9Vc8z//t09EtJZ/ekwV98ODq54HfapeNdykU4+Y/fVqmkUxt9/LEx7+ASjX+fc2e348AA/ULSz2tnuscnvm0rd24sARY9X2R+di1cfHPd2ZWdzEg2HLKv0noJLdvKopvVMAygz499bcVZUw12W68/Lwi0eF2HzL3P91sxwBsulXJML7muP7AFV3AbQwaHZ8Hz0XegX/Rjejr5qPFaQF7EWbXxdbPscbZdy5PfEAdKYejse2B7HL/EDjf+bm1ndjfOqNJOLCeN9Oy85Hvu4toXbUeJObwrjFm2SxqLjPCCHhWa6bp2rw87Y3ksif8BJoYnG77cMmirJem4Kbm7szvGZ7UxhjvccPiKu49j42AYWjnHfx393uIKyEIWkS3lqwY3t2HVNVKfOUt4EKuDeb2e42jF3/FQJ4ozzY5tCPjG/YsLC7htHgwr6tsIGmhex1PHqIpqkXYS9LyW4+quUC0J+jvtGv4LQrG98x5Eci5cVXK83Aedn4XZs4wq128V2P+Q9BDMLroG2UKRkddoptAqCoqY6VbUcUapjBRjpYHDw03/ABq7kIlEP3gaq14wmP2M2lfxeEiYzbL2R1qktLS2FXr16wZtvvqks0FFw//LLLzB58mQ45phjDME+darb1XLixInw7rvvQs+eiguLHKM2m1Tim7BrmyZSS6q0VE4Nsnu7xa+aS3mUs3DzFuf7++xlxWuK7LudXUppZIoY7u7tmsH7lx0gyaLu7hsFX6qyYJ47hebjbL7XQjsoNGwZvOB29tWpVRNo3TTPGJWXF4Fo7RsUO0Y6NrTu/bf6BqM2+e/x/aUCeegdR8Kz5+7t7bYvZIzvyFkynaeabHfrsTsZ53dgxZtQ4RLvzvPY7GGV5o+LmwasvFlLmUDT3JnAPTo0/s2PhKDUFHwdJFmGd922lcOlnLdI83N3Rq+k5XqDGe+LVu4TwlOcWbXN64ceEEzs8dYuy6rKvAOgwAoB4C3G1j3K3WcsgzeftEvMyM5q0s9MbC+ZCfu9+UXsaKlQZ8IHj/+9WTYO63Xz+RIcx+V4N89dno+dLysv5x3DrTvO0bAOS1YOluAWrtX9g20BHOLOtdxHcPObC8yL46Vf//UcG+/qPWT6at/M49Y5eMCLbGsjyWN8jK0lbnd3XcgRgMzYEKu1hVvcXCjhNgqN5837URPKgnmX+xJCAiTZ4mXtQuucoQ4MXec2PiEBI+ath4bEr2RZTZbGLOfF0aFpgbiy1yeyGG5n9vH0rGnWFVXC+2Yui2wl6PjdIMiVJHiNCdVrRhbuHBXcp5xyCjzxxBNw9tlnK7V/5ZVXoG/fvtC7d2/Yeeed4amnnjL+//HHZEwUo6SkBC655BJ4//33oU0b77JXuczfi2ue2l98P15zRA/4z8Hd4ZOrklYzhqb7xXCr3VJqZbecglbLk4sntHY7rNxcfyhUx953LJy697aGy20hb9mVHJd9qTvrcLu/6dHi4Kr36koSJx2u9UQ7wSJtLfx9so+HQuhSHpZ6B1zYO5m9m8FbWnkBjx+oc/TuRm1yFN7C4Ix/d922BVzQeztPwc0fd9UWuUUy2V2yP9wsQNYbKc6ayk7M+rXQ1yptLuY1zbFB4W6W7A/nigkvv3bH797REg7dTBdSnhuP3tlhUeTjxhm8MB1mlm5rL9mIYG+z03p2tuaVF162sHBb39tB0i2dX2C3aGLfR8zqz8f2MjHYzExY+HrsbKn1n7XD5IEHbt/WEranhuXJmDAmfJ7ezcoiLyYvE+tre8HOl9VWx77mrSnybMdCCXCT4p1Ri8VAGCt5FdscYfHx1fyGgB63rhlzxder3JsoTaMswaFt4S4qLU0pBr2SptUkhpvPUi6zcCfLozuPmyh2x9EjbLOAuc+v2ZAMBUiJJEFcqnOQuZRHTG8EFYHqJbjF466I8Xky5O9DfM2QaavrVP4ozgl4FSKKwpffGBDhP/79S8wJcfJpQsyRUBP0WojLmhwtqIRuRN3IxLJg6SaIfYvaxXD7eNc01ovRAGS18wDGJhYXF0Pbts6MzDfffDP06dMHjj/eWerJi8rKSigqKnL8ZDt8zKUq4vusIBqGx8/aC47cJRmTquZSnjr7uNjOa13uErQegtslCIXjdmndBFrkRyXtJELaHEwqwW1YuM2YTq8TSbVTiJm2eZwWc/lr0aXckXCOa4dl1z6+6kDo3q6pb398uAFfDsvvmvHiPdkdJ7gLyy2LrgtJf3IxolYnnAlzPAXeBd+vP69M5clmyXb/67O7ZeGW3auYsG/pM30sV3yWMdzrmBuglae1nL+fWCI/dC3GuHCs631KeIJr04VZ8/k8BJYIk7Tj59h6VgvBXl1aWq7bR4ZnQr5E6J+4V2fYu2sry9KMrv0Yl/pR9DnoG/nCWtifsGcna25ZqS7nbOhKibiYQGZziyW7zn41Wb/8q4krXIKCzRl6DIhlxvhjWi7lpoWb9wCxY7NtS/iKVbZL7l8LNsIP01bBbts2t9qxGG5ZAjM2d6yGvFdZMCYaWXb62iRNGzxlpfEjnq+8coLzfDdB8n06d/latdrTQgk0dM8Vj2m453PXlH3u8YIbLdxeiP1plfLvX1FQzuTqgfPwvd0a+a7OcZru0CHJMbl7i93PdYEfM/8eFeHnWFYesLbU9Az40C0ZD373r1EysSEEiPi121ByO90yJQh3/Nr0kYlCOtc0IzkU5AZZLbhfeOEFw5p9/vnnW4998cUXMGXKFHj66aeV+8G2rVq1sn66dXNaCrORg3o4NyGCdCXxavXp1QemTJp2ycHdJYLWa0GjeVpBHa00p0hjbswpY5F9LNzxFC7luAsoWuDFT/mauuawBb3f4gmFpjNpmt0O45+P2qU9NMuLuAQ3L97EcQ2P88ndQjWO4UZOrnwWpiQkpei4ubvowO0sN2t3O03qoroo0UnaDjcN/C3cdn8sa7i8XXJ8LZtELbEqws8xy6SNi+omYiZq7pgsYRdfy9vuz54T3qX8vsjnRl3vqyK/scFZ7Vjc8naa7R5rx31zLuXMws25ZTPXXraZNE/vaj33WGSANHb8tuN2hp8TB1vPHRiaa9RcvikyxFrkN8+Pwka9lcvynsrSN3Sy0xKuCZZrpFdokREXev93ttswO0tmeceSZcZyWpcLEMv934wzd8SZmisY/Bxic/v5mFmOEku3fzEN1m4ts9qx95PM2mwlfjPvIS+rpJ0gLl8qVnn443TUthibqCWVMbjrq+nGD5ZEY3P3e3w/z5hwPFUrE7x5rrghM3SWs6ydjHmrnJbw3k8Ol7ouV5TJMrfb7R6KfgbtK5ZJk225XMUr8Lq6EY8bSXiVXrPfD7dEfgBVvBI31bSud9D4fYtEuI2MmgjL9cVyL4Ig4a1omFH+6o+T+RtqD7eZXwMFQmKlflH3SiBPg3TieB/4bZI0xGAaKVkruAcNGgT9+vWDr776Cjp0SGZqXbFiBdx+++0wcOBAKCjws345uf/++2Hr1q3WD/aT7Ry0QzJLcU3w04dtmkZTvluP2Lk9nNKzi69QveuEXeCzqw+Cc/bvFujOvKqQZkmqPNspxpij8K1K4VJe07x1XgJZHGFqd3d3f3y7FqZrMYPPbu11XHcMt91un26tYRO0gnOqHoMzKx8T2tljvfzQ5GbLgNiJkjHb7X5KHGKUIruk6n54IXa+tB1ueDDRIoXrz6sEmhgTLsaieglkli+gs1C2jG/HRKH8mPavvEt579A8Z398QjdTyO3A1f624r65a8FEK78ZoHHXFhOWL9U7ST1NLMGtaYZb+b9cjDcvdljZrib59iYFfzxMGIZ3KZ+t+b7qa6zfn/zuH8Nq90zkPTg+NJmLCbfPFxPNDZu11iGS7Rhu+z18ZMiZmIwXbyzb/UnhSXCQNsex4OBLm/klaysur7LasbnF7PnjFjmFKBsby7TOLNexeALuHzzTiudm88hvFsWr5Ja/PC5p2nWRn+H4l0ZBJWeVRgu17WbPPBvk1lDWjnlxyOLkZcLk3i8nefbF88PEBdbv7HYUk4JdvuZxx984fhTwouV662Z3SIdMcLfJ80qIlvqDtyaWPH6Dc2d9mccxg4V36/TLmcIL7poslSur/d3PF6wrVrJI14T569ybMqJ4rg9J5l3XnXDPVXrQ0hQfnguWcNpQyh6yUnCjFfuaa64xxDbvNo6J1NavXw/77bcfRCIR42fUqFHw2muvGb/HPep75ufnG1nP+Z9sJ+gPkkfP2NPu2+cd3jTPPw4ZrbCH77wN5Of5u3bXFK8YbsaenVumdD1PDkXmUq5q4Q7VOBbm8kOSIlR0XfQq94VfRg7ru7LFPOQIFfAW06qC2+7v1QuTNaWR9bqQM4Gbgx22SVp9n4pdAv1jJwlHsNth3DWWIhub2FtSbsy2cO8SSrrVyrH7G5nYx6eZ3Z+XS7lYIq5EoR2LpU7V7sRe21vWzC5miS3ZOTBB1YkT+XaiNc31PnDGhJuLay1kuVV/FDvZVYqOF9wIH2vPW8yZizZufjC3fibg0GF9fP6tMDD6lON+/iJ+jFHLGsH0gJjB/MLISPgg70UuMZkNWsy3lguu5+Z5MCs+spe21LGg5sUbH6PeP+85R1+2hdtOvofngPGevMgP2/74los3uilf/L4zrp2dQwmzcBvzocNNA6fA5xOWQ2FZtUM04oYM1mNH7ho43tEXKycmZv7H0nq8dwoO0/IOMOcENztk2BsC9gaJ6OkiJr1j95hoDeWTobGNziquVBr73BOFYrfKhY6/Z6zcasyLKODnLJGLWrG/Ls3ln4+igA/rzvto6vItsO/jw0AV/rvgK/1uCIogZIXTwu3/vYBlwzpA0nsgL+LhLQYJeDH6Flyu/QRHPDciY4WA3oDjED0fsl2jqU6H6nkGnVmeqD1BZIzPhU2ITCXrBPfnn38OV155pfE/xmnzHHfccTBz5kyYNm2a9XPAAQcYCdTw93A4dSxWrlCbTIN+r+nQokBpx113mHX9xhAO7DbUFGKzmTtzKnGJwz9wh7Ypk7rhIfzKgrG+UtHvzL3gAzMzulNcerg3GoJbLWO8Iwa+Dm72Rhuf0muY3V10ubaacdciPxKGuY+fbMSD/5kQa5RrSrHjrMa6liorLze+cYk9U7ZDwe1l4U5wfe3dpZW34OZjs8X5csDNccS2SItuyLyFm40NXYv9Yrhtwc1nPbd/Y4LbsoT7ZDPHua8yY4Lbc7HjlpjnMsU30aoMoXNIaA601krh0PBsWOJw5cdSdE2tJGbdONd4vtb1tEQP4/e/E7u7ShtacdLc3PaNfilYru0/eBd1nNstZVWGVRVFNRON4VAIyrhNA0z+xNcUxnhy45zzozDNDJmwarhLXcqbWK9DsTps9jppO3wPs2s1edEa6/nf/l0Luz/8m8ulfHFiW8lHmy2xLAu36VK+tawa/vPhP0asN25I2KXX2LlWuj4mZTXN87UqlzWUf9+VmnMcSVTUvHwYs4QL7Zrrcsuq+H4PxT2Sq4mZ4BPOJHdYkq4ihYWXJx06Qfw09Ppq5r1I/JIUokfJ+IJbYULBzcZrvPo7NDQLzg3/BQ9FB9bM2hjQJKkeb+pyeVUMhPRCQNcCGg7+fiRhXjPIVT97SKvgxvhrJoyRJUuWGL8vX77ccvW+7LLLHG7k+PeLL74IBx10EKxdu9b4QTdwpEWLFrDXXns5fpo1awbt2rUzfm9M1OZLx0+j88951TZFdIdbtPftpXPx2H7tVHG6irtPJGIWF0zteq7Bl9cd7LQWSPrDL4Wq2pYFE2BToeJSjlYtPku57NuJvdSZpdzJ42faIpTfhPC6FijemUUueRB5OxRgfDuxP2ZdZ9mSU8XnV/nEjj8Vu1j6GqGZcW+sSLR3jl84D6Out0IM9xNn7eWZhE3VpZzvLx4qkLqni+2YkGMZt3kLKN+OJRRzJk2zhTSz3jKL6GXhYfBi9G2jL7H+N8I2F/hs6wUsdlwLOeYMs4vzVlmWZfvr2JGOBH2YHI4XY+x3FAxvxc40fj8mPN0luNn4HJUGhIRNvHhbmOgixK1Wwm4P/QZ7PPIbLNmQdG/Ni0RsEaqVG6JzyvItEgs3wDQ9KbjnJNw5PliiLN6zQZYckInGhI6CO+pyA7/76+nSRGltZFnxdV7oOzdQXv9zAYxZsNGI9ebnhW0uoAVe/HySCm78VOInQRDS7PqHY94l1bxgvYoW6TwPt3i34PaPk2fsUeL0IKipy2qQLuqq38v8Ofi7lKu1w9oQDMMbxaOpM7mdbsRe1/ein3/l2W+Ng0lLN6dsee0nk3zaCa9qIAVXX9mdG1KAqs5V0CXfHH0H3B8hmWPfGG7asspJwT1p0iTYd999jR/krrvuMn5/+OGHjb/XrFljiW/kvffeg1gsZmQh79Spk/WDcdtE3S3cfq9wGlb8LNz+8cU2fDuoMypWWlCwhCcfFjKBy/rTJRmBhf7UXbeSr+P783Ip79y6SUoLN+vPGcPt7O8/h2wPO7ZvJrdec5yyF7NSakpzh+N2WIA9roXLAuzRn9emBrpErtQ7wE1Vt8kHLhz35Kpn4ODKNzzbGTHhnoI75Ih/Z4nCautS7sgqHhdd5uXnIMvIzqyvfDvLws0lz7KzJqOF27khgH2cGx4DCwous+N6HZZ1U3CDzMIdclyf7bR1DqssWkcR5gnCEsnhpkHEUVfaTmC2iou3b1Fqf/YnR2+384IXeSwjtwhaN+evLbI2hFjcNVp9McYd3cUPDf0LD0QGWtbspvlRK+EYv+nBaN/MdK2GiG+mctvCrVlJ3XgxxL8NdgytcQjupGXS6VLOYOfAjlnocsdnFu4mnEu5c2yOpHKc6Bc/7q1z0DVrg+fbfxa5FuuyMlWrtvCu586xWccUXMC9+gtJyofxCeIYR238ArzA6zwu/xY4JSQvfVeT8nYqqH4n8Of6QPRzaF++KKWF268sGP+dge10Ba8o3OCoinn1qRv5F7pqGwIThSwb+2UfJas0pOL3OfISeCIk4GqHVo8ivb5pTKIx6Hkll/IcFdxHH3208WYVfwYMSGbOxf9Hjhxptcff/drLwNdg/e7GRm3eNH47tHw8pd8HrDNDuM8gHMLc+zYcF9/D+P87zbvEmy6IRt8s5SlivRmpXMpR8DnLbhkNHX9FBcuQJ5oshltOx5b5DsEh8zawLdz+3gbtWyRFlyP5m9Du+fN6wesX7SsRv95zx9e99rqnXBbgGpYjw1wAyK+JA+HL2NHwhyPTutHQ8RdaiLEG+LTEjp7H5TdtWGI0WYb3DWZJJzfJdn16dvItbcYL88EzNym183dR93cpt+4mLQQ3H7OTpwX+nPBfZju3ZX0bD5dyPDYrCYdCdKeQXfOYWW7Ze4nV2UYLt1Mo2DHcs3Q7Udv3I52WSd4S7gUvtvB98mrsHMtFXdpO06wkbEeHp0OiKFkabFDeU0aisov1n5LtQyErP0F7KHS97yLmpgZeMybS74h8623hhhB0ML0GzgiPs8dlzv0Omi22GeeExzhdL42toIRDSEe1OFSUl3lawlm73iHMFJ/sDEurDfpnuRE7ztz+N5leHCiCRCHO5g6vK5s7FPCTl22RbpCwsARk+Xq+jSZ1AfeycIcULdyiJXxwWS/nfHC/3xgeYniXvJ33KoSq3RspOHdqWcprvur1s5yLmwZnLH065bn6hthwx0KruNdXOH+uGB/uVe3r2NBUI//CX/mpjB067Kotl2b25zkpNAHmFVwBV4Z/NXIVqFCh2E5FkNTECp7tgsS3LJhqH4ot1edKU1xfqvZH+Hsl0DZUOsi6GG6iHgW3z3ObSquUXNf4El++ruKO57yzil9XfRdcVXU3PB+2sxzLPkhUrK+IajsxUZZIk7ywu064cL4Ys3zrsZJSWZB6seM1d93aNHVuBvh8ObnrhDthL/U7bvP8CJzeq7N7s8LDBRzZytf2VowJ99qRrkxReg0lx72x6+CzuLAh43HcC6se9GzHL1i/Txxu/c7PDwoiPks2s3oa7cy+XrtwX4drJr8BIZ5Dka+FW4MBV/Y26rXz8cjudvavVo1qSX1tbPd/+3eFn249HHp0bu/qxiozJqnrvXdosd1OiB1vb9bgRpGKZcMYzL3ZEtymmMMyXTJX2KQngQbjzU22cLlzM8LOZu68B3jxzgthbDcjsYPxe4FgbWZ94TH599Pmz693tNtJX261Ww+tDatunhaHbWArLNpQYmRynrwMXVttwc04PzLKSFTlGKspLvGYrDzepZE/oLAseb2YRRFjaUX20xbAAi7T8/3fzrSOxucf+HeJXU8cWVdkW4KZS7kxB+aLT3llNDzw3UwYPHWVdR6bzE0UvCfeG71YmDv7erGNG9yE2VhSJW3Hb+6EuLreXjHcXuJMFOayGG5dIsydpSqdH5n8BtE2S76XHrc2S9MTQxMDcylHopIYeaM/rkM/wc3PMYZ9eC24ec8uI6TB4+QPMDZsUnNGaBwMzb8PPs3zLtOK1+O1aNL76JHop6BKdYra31b/Clew95N/wFeTsrs6Tbpcu4MW6Q0aO96ILOGq0IzUHyS4c5TaxBP5vcbhWubnUq5o4db52ts+xy2BpvBnYj9IhPJ8P8hTZR+vqeu5M4Zb3m6vbkK5Kcl57NddyNotQfNYGMq4+6RdQQuFFZOmqVmkU7rPS+fOea6H7dRObpX2cinXVV3KhaRpdXRRxxJosxLdpfcov6DnXcJ5l3LstgdnfVzPWbvZPYOxxzP1HSyBKYp8/t6q0vxivUNw9K4dYPKDxzsyc7vbuS3c6I78ZORDaAtFjqRkyF5dWkHLFm53axSTSTgXdfOa8+7RzF1ddi1+iR9otzNFP9uwsGO4yxwiOSxkKe8WSiZUezr6gaNvPvnbq7Gzrb9wbBiTfHX4F+jOJWNLZiBPbojsE1oM3+c9KBGNGgxP7G89PmO9mBDNbIdhJhCGDZC83hMLbobp44YZmZzPfXs8bCpJzo9oDWUut/ZxbcG90RS1CMaNj1+0Ccq5sl8i8/WucO7btjW8uDLGWZvD1j0brnYmCXvi5znWcRfqne2x6MnHiipiniL5ochn8Offkzw2K+z3MV5rMQac9YXvYZY/oaqScykX2qUS3GK7sEfSNLEdn7FfhM8HEEq4k+E5R+r9/Sc+9F7ey1AXRMHt9TnPbzDJNmlk/UU1d5gAg9/MQmEui+tHRO8uWTN87JLIH8bvB4Xmgh+OvCQeiMfwOgdxHaNivN5YUgl9v3GWGCTUr0XGQarRd8NDPbN8pl/oHBfcxcXFRvktTHiGTJkyxUhkdt555xn1r4nMoKY1oBE/jd6uOS9ofN6EimLQmYVNYuGuyfnoTjHoJcruP2U337hmpbHyD4e9S2VZD4E6jthsjw86rI/8wnn7pIjhToLLcb8kbLpU6Kt5B4gx5gOuPBBG33OMqxyZcmw21x9mbcdM8a6+hP4uPXg7e2y6/Fo0y3Mv5LwS4v0VTyZWXK23dQh4vj0uQJ+MXWL8joLJKfTtdlgyrmflB7B9xSDYzAkrVzvNFiOucbLySoZVXa3mOD8eXOw+GP3MkTRNTNYmjwlPHrdTqwJYoXcwfsfM4wzLem4mGBwZt112+fh2ZjFnItQRw80JACawWDsU5EgzR9Z23YpFR1Hwcuz/HJb02yLfwUPRz+DH/Acd1423/KLotqaMcynHxT7WfUcKhYR4dilpzXV+h0z5r1SE+glu3qX8iepLrcevGjARBoxb4h4fh8z6x2pd99qujZU4rf+ImZ4ilMWNIy2K3FZKNj52H2F294/ynpceE++nCs6lnLmes0Uav7nAPjvu/2qiSxi5k6Z5WLi52HEvl/JkWTDn3HnVJkcwD4T94ph0keoKYfAU5jXjsPAs+CSa2lXcL1Epf65XRIYBlG5K2V/Swg0p+0u6lKe2hCN6HRLOid9VqviJAbyH0JW9PpxntRx2d66NvlJNwOXbjg+VIY0X2PzXBroW9UeNPuVGjx4NXbp0gd69e0P37t1h2LBhRhz2xIkTYc6cOYbwfv/99+tvtETakqahpa2mLuV+8JZwWYKwflzdbyTko7h1xVrSF/bezvnF7mvhhpTtxi5NutKmOm4qem/fFvLCISE22xuxNJBXA4fVwCPxm9ul3PvIvJgTrQgYU71du6Yuq7TX5ocY46xx1/f4PTrCV9cfAj22aeZr4f7fqUnXY2SNblvYzZbGv+MfOA5eOt8Zw+lYQHP9rYV20LviTTi28kUrg7TRnk8iVhmDefp2sGPFp3BA5dtOYa64ueCICQ/ZosUNn/VcNYbbOV+7aiu4RbTdLm6WI5N3lzzuB5cfIB2b7VIehk6tmsAt1bdaz7XRil3t2Hx7xXCzdmyU/6u+inuuyrDUHx1KVrKw+9Msd/4O2ha4IfKjY4ysjVcJN6cbu23p5JPN8e3YnPDlzJaapbrE455Y+az198t5b8tFI4QcSfoOCc2GxRuclmkV2Ph6dWtjJU5buW4jLFxfIm3Hbzg2qXAnnbIs3JxHxa5CvXu+fBzbCEJR+/bIZGKvovKYkOTOTrjIhzqIFm5WuSBVDDfLjL5561aojLk9AvikbjILNy/BeHEvS8KWbC+8r6udGdk/+msJ3DhwCtSGI8MzXf3JvmO9NmBdmeBXy8cR4rx3konwPPqzd5ggDy3hHuNWWePjPIvC3Kulu8Smwqt8BvFm9FXDlf3M0Fjfds2gHPbTcOPJVzUKo80+grZUOnsL1lWc4ovrn6DDBYh6ENwPPvigYclesWIF3HHHHXDBBRfALbfcYojtf//9F/r16wdvvvlmTbok6gktYJEeVt324tr5j4GzhEsaYhbtkXcfrTQ2XFw6LNce8cWtmkYhFE5d6xpJVRYMqU6RpZzHy4qJNMuPwIxHT4R7Tt5DqfQaPxeyhdj2pvDlLddeWc/Fdl4fCf2v7O0UXz6bFQ6B6VlmzD/hHPLL7UdIspRz566lzmbesiAKO3VoriS4kQ3QxnA7513e+Xth5w4tuM0MzWFZ95pjv3rt6H4uimSrP+4EWbZwKZoG4+47Fj664gCoEFzPMdmZzMKdCMszsvPjw3mTWdatOtRayLgGKGrZPJwe/ttbcJuiNhnDHfe0hE/Tk4ntSvV8OCU0wbDUD+CsrJbF3HRRfy4q2+R1W6R5MWa5lJtzYscii1ZTpzs+v7GDMd1iv9huvu4sG8a/l9m1aJYfdWRk3xY2wwJOJPMlwXjQdd5r44AJ+OZaubEx5DhvzjtgVLynNEaeH6vfBo91TLRwcy7ls9ckNyBPfW2MOSfsmPamkrVZw71/WX/smKmylLNrladXwQdjbK8AEdbu9LAz+R4PP88hSWkz4zzFz6aY8x557KfZUCdWOl32EX5DyhhnQl6b3LX5vX6OtJ2zDJ930jQx1tvLwi3OiZegU83wruRS7vrbex1yQji58XCjsRHnebLwZvQ1GJz/KJwbSt6zjZ3auB1nNVrj2TBR74L3SmgMN0GGCu4ZM2bAPffcY1i57733XigqKjJEN+PCCy+ERYvk5SuIbIjhVn3Opw63xgkfM0ZQCi+KPd7UHVpyyXZ8xoaujI4EZr7J2sKBxXCj27Czb3e7bVslF8GpPrawPnUozLvj+yTA4Ycmcz09fU84drcO0LoZX57L+8vVEXfqca77dG2tJC4RlXh6PKYdMyxvh3PilaVc3HhwCXjHxo948qmv7TZmIjDxXDE7PY+XS7lvvCOfqM3XXdzuz6tkWXJ8mlEu7tjdOros0h21Qrgh8pNLwCfCqcuWRUMhd710RzPNfOtqsAnctclty7VTIKPLuJWgTbB68om90KV8z9BSyfkmWW2K3z1CyyRtNKNKAOaAuLXqFlciN1twJ8/Vco02xsItOtk1EIQ50gpsi7QmtD+38hHruU5g1wu2RKgWhtn69laMfFvufkOKOcs8bzEX2/HeC8yaj+XdvCzcOL51Zrb1X8e5raGsP78kfXxWeSaS+0a/hC6wARJcIiveVZx9dvDWZva+FIU0L8p5WuUnr0F1uInljbBgne1RwcbE+mNJ6ZoIXgv81w0rXedXZswlGj2EuYtEvNZfvKKbfcvqjfKXirbGstQu5fuEvNdo/HH3D833XKSruoqrtNtUUlUrC7dXzjR+OvF+89QMerIyAXIZuuNnKLNWF8GdX9oePnUlCAsyL8SCiAfm7xLSeDW8FrWpkKBayq3GPROBCW4U2G3bJmMr8/LyoGnTptCihb3Qwt/LyuQ7sUQ2lAVTbOdn4HZYl30bpmzHCyU/C/dRu7YXxK9327iy4PYaKyiJPMZu27Y0Yo1VFh46F//uh9PC7RbmmNX6oyt6w77bt/MVyHefuKvbEu5Zm1xwKffZAXHGydetnTvWm78n7EddZbi4ayZ2reK9sIqzZPq52fOWGb7dM+fsbf3uymYvhEq4EshZ/dnncNz+tvfD3dXOTNr8OfiVD+PPIiGJ4Rb7w7H5x45rRrZ+3nrNw8QMCpbDd9rGSiKHMdxM+Dos4bozuRpi1QbnYPeyOzaea6OFoEOL5Dn+mDjEevz+yCDYUVvFudiaglu3BXe/iHeZyUHxY63f+VJpvIUbmazvCksSHY3fu2gbJYImeQ6fxE80/t9Wc5bUYoyJ72VYzFlyvhZQ7mFt1qykaWjhFuHduzdA0urfTiuC9VwG8+SonK72PD9MW+WyqqM3COPxaH/4ZPxS1/2G3j2WSzm30SLW4WbXAEubQTxpeUYB/8RPs2HI9NWWaKzUzFriUAXfT1sNs1fLNyH4hGhen+28hVuL187C7clSNaupXiGGJtmJBFMhupTrEvf0ZDv7e+LJ6EcQXe3Mol5WFYNrPp7k6O+F6LugldghFI7jKIxNpaTagLFL4IL3/lZKGCriZX3nwftt+ebUa1LfMDlX2+CYY3qFpOK7qasc1QZqSn2KWBJluQXFcNcfNfqUQ4sGbzkV/yYyBxRlfm7MMvyupVPwqsVw+32JxbixeWZgTa2LLEucw73bR0iX8MaTOpQFE4WUn+vcfw7eXs0iEIr4Cmmrmepl5b0NJMc/qEc7+LffSbBDB064eAluLg4T8TsfPm7Prya603rt1R+6bUdqbuH2DRfgm8nHt1TfVsmaf0J4srQdq3HOHnfU9XZkRse732Os3PkVhtvCFVX3GJZTPjO62VBJ3PMCPhEpqHESNlk7dp6yWGnepfzTqw+0YrjRMuzMeu6M4cZryZKdtdDci2X2XksmRVJ7/zIxiiW4fsm7n2vntFwfEp4Nl0d+5543/zfn5Nv4kVaGdH7TwBKX3HEti7NpaUUsQWO+iZnF99rIL47xs89E9p5j8erXRn523MG8hZtlZH8++h701pxZoVk7LFW4yXSzxw2DqSuStcCt2TB3U/nP5AWJLsb/t38xzZVwrqdmW0sxe//H45dJyrjJXcrFsfFWfahKWq6Hz1kHH/y1BG77fKr1VHmoqcO9/uZBU4Sa48n+BsePsPszBbyIM4bbLVaxJ134Hq0sl8fazzfnyTEYgUTC/bleVFqe0sJdGhHf8/J2UFWmJMybzxroikPHuRbbaUVepbLsOdlHW+j5TS9+L4qWtUd/TLrji3MsI/lS3dgwMzzAFJQebtKMWyS3+jv2XQOQjdjd9toa2FdboPyaU14dE5hoDkRUq1qrVfvjIxFrMx4i9bWoxTXzT3THv4auWtoEN35YHnfccbDffvsZP2jNPv30062/TzjhhEAHR9QefNPU9K3i95XnEL91dBVH+o9bUTNLro847tgqXzn7uDORmGoMt4qF2yf+PaR2LXhx6rcAcGx6+br3p66JjnW2U9VENw/kFF/c5oCIqnu/Sqx3sp28HBl/+RKCqPVqx9rWpE643+bClMRO8mRowkEdLpOOTQPnovn56vOlx43HdRiZ2NewnPptLvDJDV1wY9L9XMpVvxbM87juyB5QymUDZzBx1X2bFsY9y6zgmPm6k7bJd3FeCMm4+9bgdI1GXr84WcZrh5A76ZfXJgkfJ48x6Nacm3PiFbPMJwgb0/cY494ZHt/fba0VLNx8ci8+7tp+X2tWqS+/47LzYCEF54T/guNCtsDkxS+fkf3r/Mc8zkODDabg7qRthlhcJt6dnz9iSgzePZ33RsDNgSUbS6VWdT5p2ry1xdIYbnzPMRd7qEy22VRa5ZrjdZWmeNdiRpxxMVfWjG/Hh2EsXit3yXbElHsmTXMyfr6zzrl9XOF1XM1xRjVfXtOnnSikw5IM6sl2ztHFKkvVsp5X2t4ZSGFZtfx7p9L9/hP5Pv9haL1+opLg7mcK7FTtvLgp/AP8kX8P3Bv5QsnCrSqkXcnnBI4PTYarw87NLhkj8/8L3+U/Ap8PHQ2ZUHmmLii7HQegyfg1DbmUpxe6FhkiuB955BE499xz4cwzzzR+HnroISOJGvsbn3v44Yfrb7SEMrjgV42z4l/jBf9MyCOpTSprIM8m8wve7xM7wn3D+H34o9XGS9DUtua0A6+kabw7sa/gDildi1Sx2fZzPD7fdryLus+5JhTmznApd5Tekp/Pg312d7j3+22UVCu0u+jAbp7XVnyNl4u6eF+rWLj5cmR8lnKRAbGTuX69RT6/ucC3Q7dtfrHnsPLx9bC5bMwxIVkfv5ly/ym7e46V70/3tXDb49silMkSGhr//t/+XaFEEmNui5lku2LTwu0u+WWOiRfcZvmqtlzWc0b3dkmR90d8X8+R4eYH/5nBb6DIBK2XW78dh65BU9N93i/jdrvm9jwwqzpv4Wbv646tmrqssK3BPlc74ViyZ5aBHNleW8ufqdlxyDMjO39c3IRbpidd3XHTI8ZZXF3WUjYHeiVMXrZFWsP8Ja48G2Yz305bJ92sYKW5Hol+AneY8ahiDDf2Z93/puCW+RkVcxsLTSQhB6wdf037j7STibHboh1she5mzXeZO/bw2evgrDfHutyivbKZi/P30OCpUB13PqZzJcWmJZLJAddudt/jYS6ruJ8bu/g9MW+FfBPKdW2F+HJx84NRVOgsa7e6sBzOe2ec6/us/dpRcu8Abu62hU0wYJw7J0OyrdpapW/0K+N/zEuhtImtKLhTHf2DvBfhoehAo1qCilfn8FEjYe1Wbxfw9lBo3H/+6NAv0h8uDSc9boLyJk2XoFW3xAbjbdBYqM/LSZsfaRbc+LPLLrtYv4s/rD43kWY09S8xvrSTF7xo2dyku3c7zhzid3RHzJZHULhfKTCRTm1bKsUXO8uCKSZq8Wh3wA7JhWuqON9khvfU58KsDMYhfT5GU2Upt8dUmxJtXi7lgtXXQ4ReffgOwrX1vqecYQDy42IiMGdCHe95dMZ7e4tfL++Fvbu0Uqo5/ubF+0kFMt/O18ItZCnnF8POMmN2f8s22a6iaJl0wB3L5y3saJfwLQtmtxuT2Nu7mflex3OQZRm2LMDmeaSK53QK7qSo3lOSEC1iJhe8r/pan76cNivnZpGdBZq9b7dIkr45XI658ClbcHPuyOY13L2TfQ8xCyvvPs9G1aVtM8sKjnXfke7aOmgJJdAKSjh37OQxm3Fx2bxVmU9g5rc5wj5Pzu/dDTZD8rOyi7YJVi7na5Pb8NcKy7id+/Y4V18sI/uxlS9Yz70bfck1NrxP9jKT33XWNkN5lVk2TBNqk+topU++n8qLt7jeR2xO+OSNJ4cnuhbrjuzoZlu92u1q7XLjFwT3NZ+4s4cjH42SZwIXP9cKi0pgwhLnezXOCV12H300xlkP/d9VW2HaMufr0JI/Zbk7zl/8nijculXNghvzL73GGDgimVSM8fAPs2Di0i2ub6eEJq+0wH8X/F1glw/0s3AfHJJbwcVNd+9M687kl/ieCkqY93Bsdgl9cPcqVmEoNe9zEbyWEwtugskFN0LEoxoBcnBojhHe8kS0v9m//9gGT1kJYxY4N0hqKsqU2+m1EMjKydWgwcg1Ye53LVQT3ZFLef1R80wVWGrhxhvh119/dT1+1113wWeffRbEuIg6gpqzpp9beREfC7cG0KfySfgsdhyM6HGPbzsb7xHcz9VQ9kvClrqnJHE+XlkxyZW6hVve7qJDevCNPF8eDqt9nb8/xl78+n0ielQ9c5HgG6pmbvfpnBfczuR4XFeapuze77Rwe/TnclFXFNwesd5+8flfXn+wZcWs8hHcfXp2gtN7dXbE1hrtuONg1nCvc+Xb4WbMdiF7kSSW9bIer7YX6k1c1mGnNZ93LfZqJ1SNcrbi5g7jrh2u+o6GpuDWNDhDUnqJWYD5xfSiRCc1wW26lMuIRJNzuQFaw1YzEZurL+Gai7Ho71vCUIPnzu0Ji3X5uFh8uWPuuIzbF4eTMeFsE4R/X7Bs61gL/cbwELgj8o0dk66F4NUL9zF+3cpZ82cUXAf/5N9slU1jc9cztETuBs1Z6jeZQloGa3dB7+6wkUs213TC6642yIexUywLfUsNHe75zQVbcCN8ebPdQ3aoEEtM5yoh5WFVxXNlXhA3fjSSPSk5V/tBWUk4frOCXb+yrXwIg24JH8fr4nKLpHgvemVRtzYEzM8OnDPe7XnlljIYt3Cj6z4SS8Bd/+lkt0u5psPgSUtTCmkxI7v1eqG/jYVqwjy/2pnUq6jc9vjw/P7lFviiq3h7kCcH5Pv7Iu8JUEHFpRz5PO9JhVZqfYk13b3wq3WOtb8Z7cA7aZpYAtDPAxGpjCXgPx9O8HweNxlPCf0DTSrkory2qArkD/9a7Pgeq43wzTWBHARUuivHBffAgQPhoosugr/++st67NZbb4UvvvgCRowYEeT4iFpilOyp4cfToTtu49vfLH0HeDB2NZRH23i3UzxW+5b8Qjn1Jza6jfvh/ML3HkWH1s1qURbMw+rLWQn94trRNV7lWmB5MzWXcrUYbj5pmt/xEyoWbk2oF+0bJ88/5+dtkFpI48MOF2qPdrtt28LTpdx35rl2TfMiMPKeo13iXRZfmG+WB3O6KtvtsIb1KxfsAwOvOcg33h+9OGYnbI8Rfo55C3eMuzd+jif7tNoJgntSYlePc+WEdIVPWIhjjjWfElGaZeGenNjZ9awlTBSTsB21W9Jj5Kx9Olsu5TKa59lzJNbZts4BNMf7SXQpNzJhm3OMVt9Un1zYji1sLEGlxeGp6IdGWbIrI0Nd58os3BdH/oR7o1/AHZHBcEvkh2QzTYPDdkp+3rINpb21pKhGkdhaK3Fs9vwV31OauZ0JpOqEfC4wqRm6XbN2oVDYkVmcxXOLnzkr9PawZ+WHlrW2LScM+Drc4twuNTOz8+2a5uc5rODxzcuMubzWtCCzsbVt0cSycLNs7M470elmLzJz5VZYsbnMUXOccdCGb62M0EwgiJmxN2wuhPdGu0tmlQubYF6ii50Huz/wHuNLVx3+7AhnqTRz3kThv7W8WhpT/O2ExZJjOj//+UR+fu10Ibkas86K3zutzPvQbmi+XuhfJrhl16qVJo8xr+laBWkSU8vwLfOSqUkMt+weTIXmU7aMnxPMZ+GF6DVUV7F5YXgEvJ33KvQZe66i5dqPmrvqv/bnQnhnVOqywUEYuHMtl3PQVn9fS3iwhyLqKrj79OkDb731FpxxxhkwefJkuOmmm2Dw4MEwcuRI2G233WrTJREwSa9qtU+dv+49Bt65dH84rWenAI6rJnQc8UgKnya3HWsnp5Lh+ML3SeilkjDLhZcY5I7DXFTrEk+v+sWuGuvtcCn321xQaGe4lHMxkX6x+g6LtI/F3LEY84kd97OYY5b1KQ+dAC0Lop7XtltbpxWUlZ+yDiAhlfs8K6nmsFwLc3LWvl1sUcVtGohZyuPc3w5Byh13v+3sLMUdt9nGWYHA4VKuwYOxK2FI/BB4uVpYWHHtfDewhPNFC6dfOzzmlVV9XdmamXWRvy7O+GMntxy7Mwy55TD474m7+lq4WzXLh/8cnNykWGu6Y4vgtUCLj2fZOK4dkjp6hbNw+2VuRzfW5snn/Uqq4XG3aZ4Pe3VpaVmv74p+Yz3P3NDZe+SDeB/rOb7sFxtV5zZNHZZm5LDQTBiS/xB8k9fPlSTujdiZxv8duXJk/GcJXjMc42bT1R5LiIntMDcF49nqCx210XkRgyEAy3U7md/e2mKYt64YVmxOngcbG24GsDj0FuY5fjN5peu4/CfeSn0b2FhSaViPT3/jLzj+pdFSSzj2i6XFeMRPzgKohKd+cWZ3N8YlxFPjfS2zKrHjsvcwWrjFdrywqzQ/O5g3AwM3imTx9KIlPHlMqJXgrqqQC1/x+0RMWsiOJ36fYc17GWI7vnZ9TZOmiTN+5drHISjUk6sllMQcboR7WeD5e8DLW2LxhhJH+Bse12+EO2kroTl4lz/D+/DQ0L/G7wXVfGWChhWDU5enPjZZbGs4/wG3c16LWryICFZwIxdffDE88cQTcNhhh8GPP/4Io0aNMmK7icyAt4KmomubpnDyXtsGkpRD1aVc9VB/338c9L+ytzE+PxIOl3Ifwe1wn1aM4fYikqfWzLBwp8aRfdzPpVx1s4LbEPCLMXcKSm9LcxUnpP3ulbhiibZErSzhIVeWdaw7jju2joR4XH8F0TDM6neS9bfvtTCfdJQik7BtqwKY8L/jnInzfObEUSeea/fYmXvCBq7Ml1PA2+0ePG0PuPP4XeDP/x4FedGIkFXbaTFfqXeA26pvhUn6Lsq1yR3NuP7aNJULVb4/nF+MK96p4hPoWfE+rNOdHjD8eciSpTFQmPXs2hoiYc3Xwo3HvfaIZDjHRrOmtAheC3T9Z3j2Z07ELh1bwGuxs3yPiffZPt1ae4r35HHDMKbvscbnlrdrv+22jxtFMpqbFl4mREYm9oHXzfG14BbWzMNl5w4tYAlXyg4ZmPe0ZeGzroB5XLZRwdf/5oWALrg9HxWaLs2Mzliod3a5NFvJ0LSQ4/6/MTIEqmP2sZhFukle1HIpR/GA8aj/cDHQvPv8FeYGDwvpmLOm2NXu0kO2h/djp7qs2ezIUUHoFphjn7vWaTkVP72fjb4Pw2a7k5Ox8+BdxcXPGqfgNi3hgpBGoSazuPJu/Z4Wbk+Xcr1GVnqrndAfu+SikA5Xu+OkdYkXgdf4amPh3qNMHmMv/XCTlIXjP+d2Ca2CK8PuMMmaZjPn2/EeNl59iNceWbapFI59cRTEuO8g2eYNo5e2EIbn94U/8u/2HRMLcVHlpWHzYcbKwuBiuAOA9F9A80gTmdmCG+OzxZ+FCxdC+/btjZJgaPFmjxPpp15dagJ4tzo2BHwGi8LmmF07pNwMiHNJWzQzqZLXkWvsUu7Vk48lnQdFUM0XFIqC2w8FIZ08koqF25kYyytpGtKyeROlOtzO5GoeQh80paRpuLbxS9bWDMufsbH7zgW4Yri9tks6tChQTujmJaQP3KEtPBm7BGYlusNNVbd5Wt9RmN1+/M7Qo31z49UO66kQE87gk0uJw9N8Eorxc7fDNs3g69iR0nNi70kmylFUofA+Ipy0pIjjy/PN6GaPCq+ln4U7mcDMmVxNBCXLQ332gJcv6AXf3nioJQjd7UxXWk1zZJyXtcM23910qPE+cCT8E2iSFzY+t1hdbGl/3Bz/Fu/tul4sszluSt1qevdY7tYSCzdes126doBDK16Tjk0UyWxTpCOXgE+0cCMsvwDLDi2L4eaturyQs9qZx2Tu6zMSPRzWP3bcJnkRKDJj8h+Ifg4f/jjKEiWYDyBkhu3gJgSLQ8cNA3wuxmUDZ8dtlo+SOjkX1xn1ywHWF1XAZrPUmGhZZpnU3x21GOavK/aMf0Ye+WGWS5gz7BjumOtjnA8BYtdbFP58LfG1ehvr/Yll0ETEzya0cKNLuoqVXklwCyKffW+Ln6E95r4r7U8U3Hxmf18Lt0fd9FojySwvCsVHop+m7ObO6Lew84qvpc+x+zOV4OavmXgPIpiUzhgyN3eyzRbGseFkjfqOmr/1mP8O2spXiRHmBK3lY/Juh+4rBsMZb4yFIPFaujhsCIEeMTfQ07Rsp2uRJsE9depU6c9OO+0ERUVF1t/TpiVLfhDpBT/A0vFmcdaI9mvH/1FrRwuLuLL7tJrQV8EvG3ptYridruIJxXZQpzrc4nNe7YxYat7C7eMdEFesT67k3m+4lKe+trj7r1pj3c99kYlC3ooZ0r3DBfj4cmU3e0cGdQ0W6V2gT9XT8EviYMfYvPpDsVLhaeEGH9dn+Xm7XZ+dLurPxy4wfo/zbuxGs+TBUm2GsetcJZRIcsGymSd0T4s0mx92SC9Ri+83FL5n79sV9uzcUlK73HlMfCtj9u7Hqy/1aGcLc8TTyi2J4fbpzmCiGXPPL7BZYqWWTfIMF3uEuVuj9RvLb+EinHcVx8+Z1bANLNSTLv1yS6jmsHDzGe9VrXe8pZlRboaboFu22I6JtEHxY43/9w8tcNwL1nFDIYfb9P8KHzZCdYbm9YXf8u61xEnLJlErI3sbrcRIWlddzWeCZ3MShjZcqTWjz+/tzaClgkcAc8fG0T7+02zfeVlbVAEnvzImZdI0UdQ5+0rOyxWRoVBiZjEsq4oZc8MnfmObfzLRtVP7po75x3OQlaMSLeH8dbJH4m4nCuSafGXiAt+xgSgR8J6fdZVFHv1ptVMRHmXVXAjl0mQcMlue1I2/trjBwefd8GonC0Vjlmx+zZAHcc93p5hjQIYu9NfrsWGwoVg+J89EP4BuoQ3wfPQ93/7s8XoftzZek0//MtexgeboD4IlF2K9SUhnD8pKB5Ohqfz8+eef9Ttiot7qcAfB0o1cjJZPIjHnyOo+zjUl3BeXr+VZrSxYTV3A/UDRotSfx+/u4/J/+cRwc/Og1dGlHFHNPs677XtlMzfaKZ6xipCOp7Bw8/i9L9o0y4O+J+/qsHBjlXcvvLKPi/CbFX6bHyrnMHft/7d3HvB1FMcfn3vvqbjIstx7t3HBNu7YBmNjGzCm1wCh1+DQA6GFFgIESIAAoaRQkj89QOgEQif0Xk0H2+CCjbul1+7/2Xu3d7N3t/tG0qlZ8/18QLK02t2727t3szPzm3WwCpWAwv0pHu6gUagJKf803y/Qzv/lzqN7wnKoggHV/wdz01cEuqN9fJjOS9S44stPGoM7eO10obH4nIhyh2q6Qbg/GTXyt9zOmnZq+Ti9wW0R9RXkZoW/4YHD7du7Hm4cIbLO9f7umHwTXig7Bf5Zeoni4U65m0VCWT4Irom97dAujudU0AXWeC/9eL7yvJyS/oWhrwgPN/Kcyv4SbsSRVGQekfgODrjxxQgDOQGrUcmz1/LDnZz/QYmlMDCxDDq7CtfiWuAyboMTP0DpuiWhccWG6A25XdHPwRFVCyIF6cTcd0u8DOtqhMJ0ePPz3fwgo6Hk5ay77X+eejr0MoyNrSGJJd6mwa//XihRNuPyguisb3AnvFzvqBxumTothQ2FFzyTUe+JO1//LuSlD903bj/BO1XkGH+xfH3Ret0/dp0KFA+37n4NbYJWryZ6wtN19nBHpt1t8FXkawveJBfXeWNNrriHO1hvHYE3P5wcbs3jxJTiYjp3USXExBi6KITGQqxXrN3Q3EgjbZDNEWoO/YaaLOx67Utw1VNqWUNGT/1di0yzpKk27h794Ac0B2IOdwzbjN+vy5G8r+ok6rf8qbMWBjel9aQBSACKmsNtwEbnwRhGrUQHRLcT3jMlD9JkNCr59PULKRehbxQjVOyIF8sJnzOiG/Tt1KboRtTxM4eofWlq1oY919HX7KTZQ7Uq5UHw3Ewfe6J+s98d8nAbDO6gmvkVmf2cMN8Ls4c44lN+f/6x7zexrzfnlaiclOk4bs/ODYxb6G8bV0BOiztu745ttCHlsi95e6i57Lid6qXX1QDHhq/k0swBEXPzG1yw2yit2jq+L8LnC/cX9g5Hlg7CBnfAmz85sVDxXMvoDBmWHZk7ayXg+oPGe7W4RbkpX8jKX3EiHFvwhu0r3ssX8ShRMrlpEBlS7p57vGZxOSTc7obsbt7PRfuBSGSvyl7tbeAElfOtmjVhg9tKwEqkwp7M1ygbj9JoXo82KP5Uej089fEyeAmV75Lzu8EVmhP0ALVONh5X1hzvaq3xlKpFbW3cl/DUXoc0AyYtKYQz/7g+HWq3wU0lwOWkvGNw88Zxfm4+XWj34DtLYMCZj8JZ938Q8lwLhf0ob24wsqrMysCcPz6Pfu9uUAXaWXaGpLQt+iMZ0oGa6Np2VM91hMEdycovQj8yVSDRe67zcMRtb2ja5Wliq0VCzyV4c9hE8HMPi0qa2kW2qUX4pIjGOSV1L1TBWm3PwY//Jas1Qp2Icx74AM598IPo/urwBvzwe9+TjM0JFz/lGJvNBvK1QBuqxAtoanfPm4vggyVr4Jr/fk6dQKuHDe7NFHKeb8wIw4z2QUX159JQjGyDh1sxFOtpcFPPMfY6mjh2u0GkzQpVCd60qYHPQ6Je50QYLTg31JSbrQjTGUO7ixvc4uVXEWHTrBXxuYDVvqOO4y+HTITnfjWr9pEfef2HKxaDwjl8mG4dytS8WsPwVC99WhF1wyHl/vfpQG42vmbC8Lg+twdMqvkzfGr3U8MSA6rnkjVBIxj1J3KlI49BGBMDC4a2CK89On0qfJLvB3vVXBBxVH7YNg4pfyE32vs+eO3+mt0ZPswPgIszB8FjucmoHfXeDofF35TbBY5Lnxw5N0GbEpHDrXvG+O2E0JkWaeiDKLcXNrilSnmJqybfsW2Jl8Ot629s38qioezi2go9AGEIScGxDm6pJvyCXy1CRhwV8K7ezzq54dn+Mwdv7vghzZKgMvoNWd/bLMueKf1ZCcf4vTq7l3sOqqGvtdxr19leg4yuwDp49hM0rvRwJ5xNCllHvm12jfJX0hNtPF8oh1ts7sjNjAGJsNq+HFesx+AL6y7XvqQatFYC3s0P1hpUfgm0BKxxvf6ipFZI9dw1uMXc0vIZU12IBDj57nfN6QKZjcXrcAdzuDWe8ESUp9lW0yRq4+HesGFdRHd2+L6OGNeqj8GdDou/0UuB+e1EucAtc2HF++A5FqUAg9dU/iuJvN9JS4SUR88j+LyNwgnHjz2u0O/bxL9KL4CTUg/AFSU3kaMCKTXW/++17+Cfr36nzUc/IXk//Kv0fIB0tDK+ZHbiLdg/+SyccOc78N9P/OeNjnXVWXj1q5XQ2tncPf0NARvcm3UOd+Mb3SJ808NgcCvpzzFsDuw4qifRkDYbZZLa5lybwEaQCbVUEy06wKRmrnqhTe0IomlO+So8P5Pnmujh1qiKBz94ixnS0utYzGMujoEa3o9JGULK8QulrmeRk2wqH6a0xR5uw7nThbLL+uDBNnKG3u+8HLnCzzYoImyJyA00wZf56Ptsj616w8+37gfHbTcYnkCGr2Bg10L4r1Agfyo/EealL4O37WGwBJWQCvYnylF9b3dyxLFwiLQ8Vrnsf4IOsEv6Eqds1ld2T+2505Xokv2ph2k5dajVdn5/IpJeqwOAroUwlvAmQKCh8/8z5w2HDlbY8JGlv7bqV4h6eWjBNl4ONwYbtYdNG+h8u0fyf5ox1XMsDbmwIS1SCaTInOWF97dz5+TX4bbCOdxWBvZMvAgvlJ7k1T+W505cK7l+hFf90OSTcEvJ7x3DGve30d38aWPVeGrtgjLXmJ/YP7BuAmransHtjGt5SvZtalbAx24tbuxdDFYkCHpvZX/i+fKJXUi/qAqUy8Ln5ebsLt7PdCrl4ljXQnu40d2ECNanxjnckuHWIrjgoY8i1cfF3FZAodpBYn3YaJDjvpMf4h9v9Rptu2Jlq4LtEnmdIR0UTaPlcP/79S807aBuHu4M0eCO6E8YuxTyeXXd3F8Wtanob5IIziy5C37z74DIZKS4Wl77EY7XiEn7JfhOE/X+Qv1srI0yuYj0EExPfER+I9XVMI8ip3kHOq3kPkcv4sl/XA7fazzmYsPzb6V/cCoPDLaWwHsaVfb6zK+hqYtKfDOafquCDe7NlDhKfNWFspLiBojzOzWmvP4DJ1G+Mvo+iPIiXs+yYHFHEVDF0Ij2uxJSbvwgxuJqxhxuWh6yksMd0U6Ut3LaEQzp2SO6kzzhQ7u114YNB6ntRlRQRRijjqkxuB1PD618GOUY9h7fRzGmcficKNElQ7fTAYMbjxucgSqw5v9W5gVLlD5xf5YFF+8xGo7bbhC8Zo9QO3fbnbj9UOXH/8lNjGznzBUSMKvmj7BtzdWwS/I15eeFr+FzbSoldnduJnyQHwC3ZneIHDN4L4c2KzRK8GHU3y3InAj71/zGq03uNyscx5a9KyONd6k43MYN7e7XuW0opFxQ6ilXW9C1ogzO3nk4fJvvVnR+Nxw03ssJF4bBJam/KEbUhbv7UQXSA9zeNYz9dhbsN7GP8x320l9VeoOjbn5S6n73J2EjX3i4Lyy5DWYl34N9ky8o7WToufDyt0V57dJYq2hbCjOGqRsiUaHsMurpW7u78/Xdd96M9FwH77mesFLrbZZibdJDr+Q3u+3WoutUvn5x5JhyHUtvuDRKgscgnlVjE185359Rcjfc9kphE8Mb01s6Fqx1FfuTmbB3WBrwwjAXlQQcNuEa7DK6pDDuKvdeCoumue1Cdb2jDZrg5kXnwHHq0NUJDz0fqZ7rbHh+62sijP98+GfULdpcwODWETx3978anQObJIae488zGbVRrF1hHlY9Px9tGGD9ALZBVBRjUloPzqU2IevFwqM/+GoJHHFrdHg/poe1ijwuxQO/uYurbQ6Cc40NG9ybMXYT9FuByi8ZlbaVf8SxDLEhnWo0dfQ4UV/6qZsVhquBRdMM0QbUMHtVpdxgNBbJ4Rblrd49by7JkJ42uHOgDrdFUlE31/+upcFt8HAcOm1w0WiDKYM6aVXKw3PD844+htKUpW5+BPr7x5GTYfKATqEcbrz5ceg0P+w1qLZuurbFhPPki5Ni9LnthGo45g/ZfQN/nAhtAmyCcvgcGavyWKNOtSmKQKiZ75q+BC7NHqj8XLYLHnFoswJHMpgEKQPHIP5ObEDgXORgu4dy06L7CrSTBjLGyyWWCu82wB+z+xTtb4dRPZTIgQNTzzphlZL25SXexo0MZX+w7Dz4pvxA2CX5auHYrARctPuWcMthk+DEHX0DPQje6FnjGoXYoyu9+XKDUKY3iDJdOES91Msht2B8v45wRuboSINbfu7I56TUJ/hZyj8+7GkURujsGl8Q8JDUf9R2npHse/ul+vnOf8Lib4X+ZM61oOe3/44cU64fuQHRATbCW9+uCrULGpjYgH3k/e/h86V+mL3cGElEhIr7mwYoXWPTam07GRESzLm2NB7uTZvCY4pNsaBY21Gp6FrXK5EIpKAkX11n0bTI8oMROeEZN21C7S8czaRLFQoiFOYxy+xCxEGov8C56275Gx96gzuv/aTHSvDCMNcZoBQPNxUxxOHJJ+C5stOg52vRqu06vQFa/9FtxZyHWovhyOSjXuSZTfj8FkKjlI11qre4se3tPz71GTy7cHl8hnQM869Lnnxrp3lZHEyL58htB5Hu6rgd3Io316A+rqqUN04Ot8CutYc7XtE0s2IyVeSMZtCqJdqi51rh5JEWDyl3FKYJ7cTLNcWAr5uHWx9SPn4gDm+NPsfDe3QICNvox6cI04nrr/M0F/5pQSoZaBMwfLp3UPNWKedYoBxHPdXWwyHS/rgHTfGV08/MHOV9L69xCQqdl1CiCIKl0mydhzuYox3Ia9cb3P7PB3XxFbdxuHuhXcJQvi26XVSusfcS644rav96HkxDf+IYpPErkbW2pVEza3i3yHEPST0lO3MiKkS7TTnLzyE2HIM0MLsg0TR/rViKEN7WiY/hMGT8Sg+3uGYi1eGe3Cx4Njc2FFJuBVT0t7AKXuatE58om8Dye7GmRGk+yVaJL6M94bblifkJZfFgHqPv4fY3Ml5aEhAXk325z0iZEy7y6Pe+4ZVIj/R1SKxtu8R78NOGNKzemIZf3vGOL64GlheK/8l3vnCp359v6Mtr8PFX32rbVXtl3qLLgoVCz60M1GT1yu21pTQf4TGPyEO2o9THo27NiDzeqH1FO8KAD3rpCw3toseqe0YEP4t7WwFldHlL41zvhMj1Lv6sFV7k5RHlvoQhGcrhjjhRwtClXrEzU3c5X7t++Dey4az9WA783DSHp8rOgN+U/B8clSwo+0edFzyOKSUMI3QUqIYoVXQsTg6/pbiXPm7MJd8acyabB2xwb8Y0RQ638EhKLEOoEb5Z6QJHBoih4tQ63HHmcFP7U176TZsVgZ617bDhS/Rwm+Y5d0sUFmvY1MhjT7jWaKQZZcJbQTH0xalTcsKpefwEgl4aTELZ1DBQ1oEYUl58J+r5z1YEDMKEpixg8OfR50SUuTLVRD99xy1g0oAqo1hb8Ee0zRlViA/fUGP7dtTWS5ZK5gdv3V/5mer111//RXkcjixDaYsp/1rK2qV4uBXl84BnPThgWKQt3B8W6Au3k55/u4i4mj+u3jAvtDl0an/o1K4UNiAFbAxex/989Vuo1uXJo2shvatCuThKNE0gFchxiTFcFks8U5KuMS03K3BusDSQ5LMHi5hVoJxwbIQKvskXQs+nJFSxKzm/Q6cP8p5ZR6SegM4QHQYu1o702C78UTV+gmOuRR5uXbs/uSJygi7WGvi/17716nbjcHcZiv/GZ+GSSr7qeQJWuxstj77+SYQhnVc93EHRNNmfK+gldRjEtbn15YI6O/4Ik/197Z5bpRpCRL+S0nwNqd0J/3wNzn7gg6KfiIuXR5f7+sGtRy/n9ckSvfq8QqTCO83gDhrm/dG9oPvcubLkJkisXVz0M+P98mNg8Ypoj3lwPrTUNP37RXBDl0JkVIHLzMS7cF/pBTDC+tbRPSnG5MB9WpeUMLVdlpybbWrWUST/2OGIj4aCnndf+7/687NfwKoNTVsmbnOCDW4m3l0v3M5glOFwlJqOflhuXVlb3otkbJlyj5V2MXu4KWHMqqlF83Ab88twLrXR4MYGsn6eVhIbIYbQc0UdXe+RVowiXTmypBBrK75JIs4J1Utb25ByE1jF25RCocuRDs+tuIdbeNWKhdlHnSbdpRU+DdPmx4JZQ+De46aRPNxyDKrauvY47OhQcZzL+Ns9tlQ2+PAmhGlTA+cby3McvJdN0QGi7Sv5kUVfavG9JMqvqajjPZGfDIOr/+GouKvNqB/R0sNdTKXc7y+qfBg+BpG/v+OoHpFibYV26tx0pdLwdZXe1YFI5VsKo4lrcdi0AbBJY+D7+cSW12W1ux7F7y5M3QIPl54N7dwa5vLaXpz9uddHJVJH93O4pfHbNjKqRT5jx/fvpBhHb5X/IuAx973Nr+Td2t6QVrxhvmhaQkkTEOdArePsz03cc//NjXP+fUXJzU54tJ9L7RvmUvhQiNDd9r9vNGHx/jVIry8Yl2J+Nzz3perhRnXV5d9WZ3Lwwxq3Przb7+f5Pt75wvnsweP90i58PisbbBHzk9RUh/uSx4b5cfU6uOO170LtZA665KanP3BKR2KEcSXHrXErOqxdH6XcHvFcz9XU2aQJfmZjYUDTuKmVOgNTfZaUrltEEleLFE0LTPry1M2RfYl2+Fn3+tfhjQrdZrGOs1J3wMTEZ/DnkqtJhq8X8VLkbc0UoYavkmhn6qs3rIBB1vfGHG6xPt8tPxYeWLM/NAVxON5xFze98BWcdNc79e+UcWCDezOmKTzc4kVA1LEVO8afjzzB0BBgz5oL4deZo2Ftz+n1HjdbUgEzaq6CrauvLeJ5ju+cxO3hpgrdqSncBg830RhUPNymzQqcG2/y0mIDPqnfdKGGlJu8r/ivKe2o1+L4mbRNoLalOE/eJtUmD57jLu3LNCrl0fM8bPqAQC51uI00IN/MDyt63EI9nHrulFz0yBxueRx1MbhRmDV6Oca56EnbpBhP83Crue0J75wavTeKSrkFf87uBo/nJoU80ziiA3uQQiJsrocWI6ICQsZy4NzNr7nEKYEWwsvhtrWK7O4EvW+DIeVR6054mvQec3WLMKqeuNMfWDB5YMGTuMY1hER4t6RSqrRbllNtYLdJQyL7keHz4v4pd1MK/NDnDByaegpGJ75x6pM7PytJQY8O5U6pMaF4L+iIao5j77DglMzx/py8dqq3+crsfsqc5ibeijS45bkQOegfLlkbmQ8ukEJ4ImdbitLhMeXzAG96TPj2r7D7dS+H5iZz38WGw/kBNXM5t35d2is58sKI3uLcJ0LtZMk4wUCrEKI++w/Pe7mw8vNE3kvCWClFaR7CiP9ixXovF90Xm4sWQ5PHIcPiFy9bBbe8/LXSxo7IA5ZCXMH8aentl2KFQoDv4fcLxpJE3Ct+VEJKG34cuVkdoWYe9FzrBMyC7bAwoEAafaFw/IiSZfIvlHEz4XaFjyb/fn2u9FQorYn2hGP2Sz0P9vJPi466302vwPJ14fD+2th/WyQKHvyBiWVawxe/I3kbF1Gp+MhiNzsvbLU0n2HCL5efBM+U/QoqYb32tUvR6oiIgvCx4ejkIzBi09vQ3A3zFz+Pjg5hag8b3JsxcXryqIgRb8rtCtvU/Ak2telpbPeOPRTuzs2KJRlEPIi/s7vDUgiXjCm6W62ZXzGoauFkD7cVt5o5sUMcgm/yqCVKSGH72Lg0CdhRyn2VJC3VKNN6zINeVVO6QHH6dor2/gXBQmCmD/b1Gf18nj99pqe6TNmEOHKbgYpBGGVIy7UpPTdR5/jpU7eDaw8YB9tv0S1UL1eHakjr22XrYnDjqJdMLtJYDd6/wvse1c5kcKse7sKYwpP79KkzIvuSI2OVcvGc+UXmFHg1ryqy42uB7z/1ONX+MMr1ijh3H9kDnBJoMkQ3KqQclzT7OK+G3eNzjD266jEklAiTldAhup2iUm/ycCfgzqO3ht3G9oKKQOi0iiuaZhk2DNzBpHq+HLOTFSGKZCXgr4cWlPBXuwafCMl+vPTXcG/phSGVcpHHLQ3N9qhUGzakvw2kN+D7EBu/oqSZ4LjUw7Bmkx+W7ZdU80Piq91r3gEZ+cHNgN1Rqbfliz6HH9fXhDzhcrMGC80F+xN/Ic+ZmOND734PabS5JdvhjR/pgV2CSivJY5UGd5mVhSR6Htz31mLY98ZXPMNclPnzNjIM4djSSy/mduHDH0MxZJrBvW+icGvkuRZiidKoXbk+HTI65LgycicZYXBHvjNE5Y6HSqpFh+IG+wt67XWpTInq6JJVQcM8SqU++A7SP7Echn51O1BYuWyRpia6+gGwFq1zHdqNf7v2BqEnLBjRFoukGQ1u9DtxNAalG++7AdZSrYcbf+5d+ODbkboGghmJ9+GckjvgV8vOgPpCzSfHzYT+w/++YEO6sWGDezMm/NLYfFDDousPtQ+qwS1eIOIbldaWGipODilXRje1oyloK8azUQUcK16bcr2LG8hhMTS9kBg1jDnOzRS1mf4cr1MMbvWv2pWlYGDngvFj28U3IUS99i6V7Y3tZKg7NoKCERRDurWHXcf2cmatnLsI76tg/pieRc+xHKPYNdvKzdHWGebC8ybBfQXv3+lDusAf9h1bVDRNlFLz+tZsQgzpVgGfXLRTqK9Cf9GnJ2RIo3EHd2uvv/9QJ8fM8IUmQ8ryqN0Bk/t639+f2zYwbqHdgVP6O7neA6rvgAHV/+fUMY9qZ/JwY06aPRQ+c8OGg+AX7tnDu2kNbmFcivX4uz23DGwoBdsV+rv7XbUsVwgrgULKC2N2dcuoqe38+cm85dHW1zAisQgmJT5zjG9piHxz2XzF49wF1sC/Ss+HM1J3hZTFd6y5LDI/1PNe25ZXyk54dLMbV0ca5SIlojBm4d6vcNXalb7cMe/Ibm8Md3e86q6x2i7CgMP1v71wcUgrxnZwfp/k+0XWCMft8AYR1mz520sF77S8AnLDwzmXkfW/C/PY6KYTSLG2oOf63fzgyLDijOY41tv6TYiCh1v11EdF0EQKv0Ua3Coi6oLk4Y6YW6FdQHBPY3AHny2p9BrSpn9Jxo+8CPao/CtC9V4QNLhLDdFskltLLgcKckPJhLf2ixicJuE+fO6ELoEudxz3oaslL8DPt/tf/yqkayDpExTKa2QWLlsHB/7VL7eJaYEVz1oMbHBvxnyBlFcbi7p4aeNAMUINnW9IRpfqCLLI7kYYM14Pt9ofzeBOl3YkirABsSyYYZ44h9vktcS5+wYPNznsWBHW0rej5nBTNimoJS+omx+K95V4DKbQ96xlVj0/wa15jQ04Y+10wrkb2LldcYPb/VqsXZuSZFgIDJ3LUb2DOc969hrf2wnLN0VCiFJqkR7uQDs/YsEKeJtxqLhFqtd95k7DYYeRBU80VsEOzq+yTYlesRydu6q2pVrDXPbXoxKHpFvG/ii52d06lHsiZiFQX/tM6FM0h1ukX/wtNy+6DepvVbrYi3vCuz/l8UWVVhKbFfJlXKqL74xqukvDFD+bZfj8AalnYULiczg+9VDoOBba/bzIBvzyLXs5Z76a37/xkbPQzH0PtxD9u+7Acb5SeUQYe9uywvFdmD3E+93XyMuOUzikuF2wprcyLiS8kHJh1OIw8KChL9Xig3nouD8l3QPVsJbNZX8iEsALU9+4Sh9SHvDSP/nRUqVPHOpuqu3slWiTHm6oVgwzcTwb0+Ip5Xq4Xf2HaIO7biHlTkk1gpq5jIbw5xY97lufqur5uv7a5tbRRNMiFNmj3lW+/j4s6ibmGGyXi7LUAj/aLvk+UPjkgzfrZXBTK76Ehe6iwdciKQxzXdmyQISC1DwIgj8f//CfQgpMdH95mJd4zckf10G1j+n688T+2DCvNWxwb8acnD4eHs5tDRd1vybWfoMf0jpDxWS7xV3Dj2rAv99mMtyY3QUWpE80trvTnuvkae5bc55hTCveHG587gxPM2GYH5H+FbyTHwJvjr/MMD/ctyFYCnmhTUaZlaAajdiIql8Od6EdPhCr3h5uEnXaONKf42Jh8fIvqaXNlHMc0Z9U+VYNs+j+ylIJ0rl7b/HqWlwzc39Du7c3tps5rCvccNB4OGdnNWRbdx/uN7GPqlIeGPPkOX4uu2oYho/hX7+QAnHRmwEipFxvcCeUtISbDymENAvWYmNBo2YezpdOhKICwsdgiIYIhrWiwXTe5mB0gC5SCj/ThAdb5lOH2yW8NqKu+gu56Jrd8pplkkXSOSzL26SQYwaVxQvtEt5LofRwD08sMhrcUjW8G/gGPA7blkgDbVLiU0eV2BnObdehbRk8lRvvtd0m/aLWcy3Km0kPNy4PlUB9yY2FW7M7KH+L2wmkh3vH5JuwZ8IfE6uKi2OQzyJRdi2YduQb8H5OuPDUBj+O/Bxu/5qn7IyXPys8aMH+pFjbmlVhA05GEcjNnTZumbfguEHjsjQiEq0Q7CxDyl0D3qpR+jr81jfgrW9/UpTlBcmIyiqJiM/ih9/4PPQzi+wJVw3pqIgEZ9xAfyuXL41u515bSao6WsAsOLtcNl1UDE2w7Mfo/oIGdzFPc22MwbtKf1v0b7xNpIhhLaKHG/9OfK87hGB4v66dkwdOqImOz921z3yhnd8eiZfhhtJrnPzx5kbcBnxrgA3uzRiRZ3hC5kT4sixaUbeuVJSbytPQPMDE6lxkqF2Il/PLsgfCo/mtje0yUAqXZ38Gb9jDm2UO9zP58bBn+iKorhxkmB/u0CZ6uA1eUKpoGtTFw20y3mhlwaj90Tzctce0SWKqm11blfJQnrymv7alyUAOd3Q7EZZNOXfZnFnNHP9pThOVcMdRU+C47QbDIVP7R6gWq1Eq80b3hP5uqH0xhOGSxSrlgSso6o5fsc+YkJEQJUw3ob9bAk2TE47vK3HecjjenKhAj8/JXuP8kG0Z0uy38/ubO7I7XL3/VqFjCLbDzEiqJZPwuNiQXmoXjjmKF/Jj4JncVs4GZKAz5ZxoxdoC6+S+3HaadoX+7KTaz+v5LULtdtqyhxPZEPb0q/OTp2W1m0OM8dTM3evSsW0J/GSrdbaD3mGJPP9CqO2ZstPc0fw1dUbmGK+tPC+OMjTKpRaI8may7vdVpTeExsTnTvaDa2PLduWlJYr3t9BXWDhK3Be7ufngQpzqu1VquDCuTe4rldfAIx+otb3lseJNrspMwZC+FSmk+5sVCe/cXv9YoZ5wVG679NJLD7cQzTQa3FKpWhiKtg0ff78Wsnk7FFIuwraxB/a5hQWPISmHGwlrfeRqItz38oekz5Vvlq4s7uHWhJQLTypGJzgXGnddtGEefCZ+vWgJ6V1FbqREjaz0H6PLs6ulC3eH8NqK9HDT3n2UkHLI68XaAvdSnmBwC9E83ciiPB8FLC6pAx9+Y5rA7OGuPWxwM2ROnTsMhveogD3HUUPVTUZPvAjlYAp1UgLXjSnyi5WXbSCG7BYf0xgGhRqKOtX17U/xQps83MSQcuWD3SSuptTNJnpLdbVNnTJjVmw53MK4iTOkXFXQJnrzDe0oxyoMacUg0bQTnsey0uLthJK38qIQGVJuGQXxpg3pAmfOG+69sBTbTBnQpXieseDw6QOL1uGW943iiTVEYKhK8Mi4TJjaEQXiUDscBm7ymIv57zGuN7x29uyi4mqSdLAME2r3v/woeC0/HG7LzlUUxoPnToT9H5E5Ay7P7l9ENC3a+A3291a+kO4QptCuJKXO+cWAR1yMK9bsH/fbSh/G7kwq6dSYxx7uKM/i8J6VnnEnPdxbJnyjURq4FeU49N+/Tp1c4xzncP+EhOY+zfeD6YkP4L2yo2Gv5EvuMUiDW3cm/JxrCVYXD7brVdUOvg/UuN4t8b/I/h7M+VVB1m5UvZyyXSKR8ELKq2A9nHinWhoIG9KS0R//wRFWewwZ576h7yuV/7i88Pvrn/0i1E6GlMtzjg1uYQxJb65cr9g7/JcXv4Kd//QinPPAhxEh5TWQydpaz6V8TiZQWLykPFn4O7GhIXUPsIp98BjEJqLchPvLc+HIC6uoSnl0SHlHax08+M6Sogb8O59HiJxFfDRJDYNQ28DnTjZdXbTddSV/glwgj77QpvaCXiaiPh2jjF/8Omj6vK9GGgFUD3fB4I5uiPUVklZO244qaBwW26w7bCA3PWxwM2ROnD0Unjh5BnREuYRBsN1ktIHjtrhj94TTjHzqg/Oj/IDi/eGwVe2ustpOqvVGoUY7Ez3cpuNBnifTxsW3P6G6okbRtLp4BqPbWTGr8os1rqsZW5eQclVBm3isxqiE4gZ8O+HhJtb/VgxfTTtRYonq4S6Wny9qiQuK1RMf1j3smYyiql0pJEvMnmv5EyWv3XBOeuC8YKXcl/o3Sm1ycph9dDtK+bDO7UojDM3o/moM7YQhvX/6PDg/e7gxr103RtDrj4/v3uwM7bEuga6wc80lcG12D7U/91mx74Q+xnNioXEUAbxIcTULXvr1LC+HG9PW9XDvuGUvL0oitJGBjLrO7cu9dKoozzouWyY4KX28p6R9ZclN0MHaBEemHi+0cc/lq1+tgnfz4Sgl39hKOGJzAi+nGhlofniyH7It6YCU1rGX/p+5Od7Py2zVwy3bdalo4xnwZ5XcGTE/N38WrYnO1lo48tY3FE8nVluXmgHSwMTCWL6BXKa00b1D/OReTynoJgw7WUu80F9e8XCL3OGKdNjzG6zD/b/Pwm3KXPl1HBbfIcLb3K+q3Gsn76eSfPFcb7EZEOUdDrargE1wZUS+b7BdPm0uvWaq/x2lPv7Rd8uL5nDvknwVSpe/B42JF40R+W5jEUPKVUNa56VXDW4gtcPebrMTwbRRX9xEe/HzFQ0SZcDEDxvcrYC4BcqMYxHLUqk53PWfoE5dss4ebsKcRC4ntdb5WZmj4JbsjrA36FU68dRM9YbxS4gom6XvjxZWRS0LZifRy3tUbVKXdTV5kgexbiHlliGknObhjlPln1qiTTHeiSHlphB1xWuo6a5NaapOomm4ljRmRM8OtbhmZoNblkuhRiVQ2GO8v6kVdV8Gla2VHxYhmK+MWel67px2VFG/wLgD3NB5cX6zRaIIxHM1ZPChdt07lOnFHzXzKxZmH1lmLNBOyNbh8mV+f+ExP7YHwPd2oISj227fib4ae9R9iPuTHtEoLPc69alq69X/xnSXedrucXStKIs0pEss98XZsuD983eAWw6bBOmAYY7zcuVtu8Y1CiusjYogGj4GUapKpDhh47DQn2+8HzSlcM6xurjfzu9Piq9F3tMopFzk0W9wveUdsqrYnDROhnavgF4GJWXcn+Rzu7dTjgk/tbCxg1XUH3n/e2eDQ6dSLsOsg8aUbCe95dLT7BiAqKlXTxyVvtvpy4ud94RXv/LDvK1QHe4cfP2jeq1kBp04n2sJHm7xncxFb5dfV9TDLYz3oecUNmJMecPtkYq9qT9x7p76OCJPPtBfuZsnL1m1IR357NRVbAk9Y9PRaubUKMDa4udwm9/96GXB9P74UOi5LqRcPivc66drh8+dyTAvFhn53qLVcOo99I2OYdYi+EvJlTDSilZPZxoWNriZWMFGnuldtjb5zxQyZIMbYgwpp+fMrIIOcGH2UPgkVBcX91f7zYBgjhumxvUiFv7GBBabMjRLoRJTEeIy0SHlpjrcxNxxQjux7lQj1HQgdmzhXEpIuWEToliNaPnBjDcNjEegHF/0OTluu0GeuJPTn8nQJyjVC+8e9ZoVaycVt9WXtvo9FKyUeXPBM7hx+DTVyDecO2z0mc6xLq9d8MiJ23p1wIuFqIvImrBomj+uCLWWnJD5Jek4KOJ6gipU7zpYcxyHU35p94o8BmHUSpYEQqDlfSFE/LT6B4FjCHp11XZ+P1/g+bikZI6s207kx4fGCvRXXpKEWcO7hQzzP5dcE7o3pQEsao+LfM6oZ9r4/h1hmZs/j+8ZrGYu8epnKyHlvoc76MXvCOsjDORCf6vccnFvfKIKNsl2JckUXJXdx/t5m4CwFxaSezk3yvl+sVv/XTV8/eOV+dnCey3qAN+Damf7Hu5Cm1GJb6EdbIJMzlaekbKdzAeXnmY7YHjJdgvz/uZN19Xvw91vLoKf3fxqqJ3ccBIibLOufE451vIID3dUqTQcPv+Du5lUmQvncPfrpG4SdYU1Tt45Pk7c32f53t46kkv/+9WbYKerX4A7XvsuMkT96NtVlW8nHN9tJ0UL8cbNPW8ugvG/fQqueuoztTSlpgxWlGkaVSfcuWYoB15HXRyzXpRFkZBy8/jqmnlJU5s66OHWvW4qauaGHG58r5sM7mIOnQ+/V9MCjEdqA/yj9FKYm3wb7i89H+Lkofe+j7W/zRU2uJmGW1wmD3fMbvdsRP5Q5LjE/ijtxIsv1cMtEQqu2jEtgC/zPZ3vf+qgF2vDp85kcC/+Ce04m7ylyMNtPBrk4bbyeg+8MpIph5uqeK14yQ1GI1G8ispndnT9YYw6Ii2HO8roOWByv1qFmlFKufV3ynjRcsBsQhRBeFy9UatufoTbDeraHk6ZM0w9Qs24VW1NwliIhDlUfHiPgpGh5hrrj/Uf2TmRH5XBew6HlJu8w7qa44L2ZSmnDjg1Jzwq9DlKzTxUjkyb623eEJL0tLBisX+s66ozTumlYuXt7jtuqiLGps6t0C6VFDWg++pDytExrI7wXEfNL1yWDTdLeGtSTQ+IbicIGtzzkgUhMHyPYONMKBZH9TVri27etRRq4OKFfdfE/zzvMr4WcqNIMbilMeHU1y6DX2eO9sTTKhXht8LnY4zRDjwAAKmeSURBVFlp4Vz2TRTCUAdUqznG3jPMspRNk85oo6XQn+/hft8epMxrLRJDw4a5DCmvRBsBwXGlB1nwUfmRkA+U35LjShE84WkWmwHCE44/4mS776GzF5XxY8exoRxoXLZMZ/zI210cgzy3wvgN44fPy3XZNhcW/6p0XeYr3E0PUT4Mb1aFzom7jkRkgLzclz7+qRNNcPYDH3jHIDd4dHW95d3gKbejdXTuAwURuAff/T6UmiWE6dZsFEr16udR8NMpUR3eXIgkrzcwa2OFy2sc+U4VkdZg6kO2+2rFhqIGt1lczUesJcpGQjCSAVPs/VJGiYgImlNT90DbNXrFc0F3q7ApUi5K1hlGrS1C44FSO721wwY3EyvK46ERVcplTmgxqGNRvM2FNvFtHAjP9cHps+Cm7Hx4dfK1+nHR9q14OTX1V2vjzfAJYSXxi6++3Toc2mgIKVfDiWlh1mSxNqNoGu0D5cT0L52yej+3Lql32L5qNISPdWSvDvDOb+aqx2C4FpS62SHDx3TuqEr1Rcb1RdOK97f/pL6kNfD3wyYBCWV9JiJD4m8/YjIpX3nOiG7a0HMRUv7qWbO9f6teUeI6Nnz0qor20e16dQmoiqN27cpS8PFFO8LNB08I/6HmHKubBkACrxlRNx33oVsnYhPoJm9elrqp4faXSiRgQeYk+DbfzTEgM2gzwBkXl/EKhFFjgqkRg6r/CcOqb4toiLxNpRql9cBxmMTa5MafNB47CA93QHHaKwuW9KMVhOF1R+nv4NrS6+CMknv0KuUoFBiHngvuzs2CG7O7Ot93hA0w3PoOdku87KuZl6jn8oKS2wP1v/OoP/94d028EjgT0ruYgI1uePrsxNvQFX5SQrJx6LlMIehtRSl3F8ZdAQUBO8ns/xaOJdif9HBvm/wQPik/An56+mrl6YvDu6/O7lWYa826UDqIzLuXazcVafjKUm4Jb6Ol1Moo4nDqsYoc88KGQLvcupCh6gnEoRQCGUEgQt6FEV04J7ayxsUaku2qMzltdEAwGiF4HDLc3fFwu3PDCu7BTx3h4R570X/g4kc/MX40JTdG14r+3u6k/iATHXoeJJ/NhNKQsKq+XDN/f+nr0N+qXm2awW3K9cbvDLeUXgEVa78gebgpxqvJ4C6mSyPfU89M3QEnph6EKY/Ngz/9N1yyrjH4yU1JYPSwwd0KsBpzLDQYrlcbahfzuJvQB5AJcv1vQrNCDnftKBZm/z10gUuzB0FNu960HO4IUaXosQwzRUax6YjE8d6RneWEpGW7FoR8olgGneDczOFwSvoXkaJPEnp4MjX/mWbAv57XRw9gxLUQZfU+gKH1VoJXQsp1ntx2pco5Ma2VnzZma21wG0PKiQZ8XlG0D7eTO/+U2unix6qHO3oNdGlvMoI0Hm5dmaxhXQOGdFLbzhSVgJXF1dJr4WPYdWwvUpRD1FrRXbOZowLRF4F2bV1PJhXqpsH9uW20An2XZA90FMgPT5+uVCAIbvTgzwWllJjbTuhSfGX3gu3SVzsGpEm5XXr/IgmMK9Z4pAcbrYFkSTnNw22IMJDPobVu/nBUSKs8J+L5jb3lwTJAeHPBE02DGpiZeBdeKzsetkvI/E1/btKzLnLHnyg7E/5Uej3s7pYCE8cgKlv8K7et114Y+XeWXAydYC0qR6augV+X3OWMK5HtZg7v7l3DAYllcFfpxeopQ+JqMoVAbAIEkaPJ3GxJ+42+4raN+hMpWphzUv+A9TWq4rSgbVmJl8e9Ye1P8L8vsbHvX5cad1NnfvL1iLn5hnSFm0e9d/IlOP7/3oYvlq+L9PrLDYHF3y8J59i61qpY17KKgPRKv/zlj5HK7bJdhe0q4kd87uCQ/SA4HF+q3Tvr0o0gwF7i4CakLL32t4BhG3xKJNNrI8eVqQaSmk3hCIeoT84n3lPzjPe4/n/w+IdLQ4bqvW/5qQn+7/Tz1Jf7ypON4t1e3gsWBUrq1dXDHcytr43BLVIBBKMT/rX541OfwUeBUPPGqJudJkaZtmbY4GZihZpfHLeQG9XgNth/dQgphybJf1fOcUrfMOpDuZjitXE3OGHB2dmj4ZDMWUUFrv6ZmwsP5P2XunqFlCuGucljjrvTz++W3Dw4J3MEzKz5A9QXdU+DGFIeg0r58g3+7r9tWIhUryo2pHWiaaH+DGXBioWUF8ah5XCTnxUoh9uEmsMd3fl+E/sGyoxZdTZWr9x3DBy97UBSPfmwwJ5O5CywCRHRDue/FkPxcBvWySL08owNafHsEmHbe6cvhGfz44ybadsM7QL9OrUNGdzyWoRD9oMh5f45Xo/y56WRUyyd5bu8agDg+f2w3vDSiMYNq7/7yPdO0Uanoi7XUzIZIYCnmZtct8IzeWvp5U546C7J1wr9oblJj2g3N3xUMC7heuQsC9qXp+DJ3ETvd6IE2tTkx3BJyd/A8kLUw2tgtPV16POkd1U7ZUNkcEL1+mKvoTS4RTj7OOvzyHbByIFVgWsqjRNT3fgChf7G9avyDFFZdz1qbnjjZt+kmsMtn+ui1vlKNwxcsghX5HAp5Hq79dxhHTwQCmP3NyFEGgA2kjdEbBqIdqWuGFc3WBWKwPNqjnsebl1IuW/Ae2Q3FTUuReRFFMEweCsdNqTx/CR7XP0UZAjG2crVak74Jz+sJYnIOXNBxzDW+lLZLNLNTRy3iGyKbhee77aXP2scV6SR6F4JrMAcdKK/pmex4I1vCqKHwU3J1Rujr5ncWIqD4EdnthafN60VNriZWME3oSncGT9y4rC9Zw/vHhLliR6VNholx5wqckZFMZANfeN2IvxSh9KHKVQc9WE6IlPEQl2ghorTQ8ppBrz4cPq/3Bz4xi7kyxfDpIJKrcONc2TNBjcxpBwrWRuoaBM2aIpuutRDMV4Iq12612hS9IK4FylpAFS9hwSqE28SsKOUShPiWEoos2HdFVOCL0slYUL/TsYcbhz2TsnhfuCDoLhP+DiG96SVVAvncJva0fLf8T0bXHfi3D77q5nO97j+t/RLBT838MZHoT+cH+5/L0Nqi83v2tyegWZ+H+YcblpI+awRhc8iQVQ5sqCHW2zGybrN4XZ4TLcOd0BdukD4PAy2fCGjH9ywXjGueJ5F6VPslHwDOsE6pT9c3g17TrEnPOixbo/ym+UzcY/xfZWc8AfKzocyRW3dz/XGbHBzpoPjSqE5HdizLs9HsAwWNqI+zA/0vr+i5GYvrNvBfZaIjchHc1t7Pxbh58LIuOn5Lx2Rsh9Wy+P2PdwdkbjaG9+sgs+XifPre8LlOhKl4+TfRh2DZI/s455oGpqgEqJe8JbbTp3zDxavCZ07sYHlbeplwkbrj4Gwfn9u6ohKxQLHw60zuAOCgTUbYNladfMjsixaIH8/Sk9ioKVu8Pgd5pVNoNtKfx/ZDH9mn11yJ/Sp8UvLKXMJpITowKs36RZZKzauMPSlpzoI1YQNqpnrtIIoQrDyUuD709SOocMGN9Ng4LIfDe3h3nl0D7jz6K3hPyej+q+RA9P6o8wvmA9WX/BmgHGrAk1OhAfq29HGVUTTDIYKtu3juH7UEHBVQdtkmBc33uqC6XNFqTtvUG7HH3Qmw5e6EUWtYd6tsm3tQ8pN55hwLYQAHMngDoWUazzcQAQZ3KYwPWqpNFGn2p+EKecaGfqaYxAvlJRzfNLsIaQc7u/WBo4vot3griZBMVMOt9rXYdP8El+K159aFi7iNUM+O9WQctfDHdhEDIumRY8b9D7q1hP27oYNbpMHCBm/ykaBSnlJCbxxzhxFDTwIzuEW/eoMeLwRJkPKIz2Y6FilB7MKiaZ5f+PWJhebjV/kw8rth6Secse1nM0zfH2EwXpO6p/w95LLIeWWikokEnBvbjulD1GPO2jkTR3UJSTg2BV54HE49kM5X1hPqJAvuONteOLDpc495BuNJUQFawvWu0Z7oZ56dM5u0IAX6t+hdlYCfoQOnpdQlJW7761FjoCZKMMljahkIuEb3O4GhjCQ973xFZh71QtIXM2v+44Vw6NqmEt+rC5smLwXYUgL+TiZ6y2M5CueXAi7XveSe17VfHq5lqIMbtnuI9eg1hle8h5/NT+i0G86XALN1tQdj7qH38wPU/6djKhhHuTZstMifx58/k9JfBppIQY3yfdbfEmt86x1/SUtvYcbz+/ckn/CM5+Ga50LqKK8wY0qnJPv9WUHn8t6Dks+AQvLD4OZiXdI7Z3+yS1bL2xwMw2GySCN2d52HuBTB3d28mCN7Yj9UbzX4ZDY+lGXCkWmKAJ8DNVlagkeFWJIecy7JNSQcronnGbAN9wmCa0smOlYJ/YvFipZu80FG5dlM4qm1b5OeH2jEkKigwbDnEJCKUGnX8fUOtzkkHLk9dUZocLhUJccbt052RSqw1379X7eLiNhaLf2RcPiL9htFNxy+KRarWOqPoMiYOe2w6KQ4THD4/42c5CjK3Fzdhe1FRp3h5Hd9eHgOFTckJutCpgZPmcsy4u0CoZEB49VbkrrwsqjVMqFmrmuP5yji/G9uwm44aDxzncP5qYbjiHh3EL3o1xvobZ+dOox2D75LmxlfelFR30e8JZXRZQjS7ibuq/kRvr9KWJthXYT+neGEzMnwKTqPzv/roBN8Oj738Nx/3zLOyPy+feSW44scvrIuFyPDFG1hjkOKVfF97CqvOV+L/oS10PWpd4l+Sp8jMKcZX/inMg8+m2SHzlflyCPtOUZQ346gRAmU73WSMAOAP6U3cN7Jn25QvUkezncaHMkalMGK8Z790BmE6wMqEvLuyHsfQd44J3FMPOKZ+GzZes8I1SmMPywXFe33TbW/w4ehySZo6leD7bUkH1BSdQjZ8nboR8FNwM6oc0iUzsduJ2IMNH9FTbgHX0FjXJ7sRxu3eeTLkSd8gZsu2KKgmtLriON7/wdu7yLwgY3EyuKx88YFo0MlUYyjmozFqVVQTStdnM3hbSr54Q2N7NKOcAx6VPg0dxk+GbkL2gh5YaHJt5AicP4VsKiyerjhrDoBvJwG/Xm8JCGc6eExRqO4bQdtiANrITsGssB0DY1KGXGguMaN0lwiKw2pDzmOtxIpdwUqUEN71cNX4PBTTBChcaEaoRGt/t25caAaFqieJ53Hdf7EdsMhBtdxfB1rlGiW0+yNrbJE65Xx9efuywhX129XuFx/5ab7+hK/GirobC4P18ZPaqud3RI+Yag4aoTewuC+guKe3nH4J4f8Xkk5qbNCVfG9NXMQ/2hMaUKta7m+JRBBbVwaYjqxq1sWwLv2kO8us0DrKXhNWIllDx6wYTEQjgr9X9wTcl1fpktd37nZg/32l1ZchP8seTP7tkozK/KFUiU61EIe+EyV9Kg2W5Yd/hLbhetkSzVx8Vx4PPRHil4Y6NHrNcXc74Q6BBriV/5xLOP1XW8X/I5pToKNvLxOOLYsHJ0JpdDhq9rcFtpOPfBQmkuvz85fALWoBD1oC0lz4lIgZHed3zOTr/3Pfh6xQbUn+WncmSrnfJi6rh5ZYNHKLJLTrn7Pfhm5UY44773vWsmz28+Ux1p6AWNVbHpYRE84cl8tNp6kN5uCT3MnBEBnQaNBz7oCe9h/QTvLgrXEzdFTOk2DX5bcqvBw63+oirj31t1MbhD89D8WW37kyKBFAwVbxkXNrhbAY1q0GKPn8kOaLwpqeNS2xEaxu3xVU0Pk2FJVIK3AP6TnwQLMieD1aajsV107yp4rFhCyolGHsULCjEbb2q/QFQpz9FUyg2P3TK0NW/KCVc9yCZDmibUpVwLo0o5bZOE4uEU9w9F6E7cC2qN9eIebmpNdHNIOTZqaSHlOlE/4UnGyt26Y33t61UkD3c4h79u612+EOISRVEGt3wepWP2cKsbUZrNBUMdbkzQ66xsJFoW/PPIKd79J1Wfg+PiPHBZ2imqnSmHW56XUb06wAo7+rmLz3Hb0qTWsy7X5wGT+5LGDIlihfrzv48yuL3zYiXgFrcc37d2d88IlQiPrPRcB59nOyTfgmNTjzqeu0mJhW5/hYGFsJ4MHR6R+A72Sr4EfawVqMxYoZ04VrmpJGte3/Dcl37ouWXB8/mxyri+kWkrRgCe37jE55FGlLgeBwsxUBcRfj7lkqfhzW9WwdMfF4wh2c+t2R283OCVa3EJNLffhAVP5f0NHjH/Fz/3jcKaTNZTUJcG94TE57AqUFYJh8VLj7njDQ2VGSvQuaLc2whqiwTihIr3gX951Tve+aN7+WspokSXFVLFj/ZIiysvkGXhhJr5Z65quzhvR9z6Bnzz44aQcdnPWh7K4S6Mm6+Th3tC4rNQ7nJZxGM4lwn3F/XRucf1L9c5pDx4rOs2rCflhHfLhJXWBeq9Rbdode+PFAdRcJOgqd7VN0fY4GYabnEZy4LhUNzGg/7woLzg137m5rJg2IOsb4cFMUyiad/8uLEO4f0GcTVciziGp3AxBU40cKye8Npi6km5ZgavqurJI14LYx1u2uaCqkBv2sTBKuUmJXiiAU8xuIIpGYbyYZTcs5TrhS10rT93ai4p1Risn4d7bN+OgZDy6HOczdskw1zc9llCu6O28cWgoimcp2Lh7vLxoXibidffdJ/rlNsfPdEvPxYuC+bPb/LATnqvc+A4hDp6/85tIzZJ/HGxgbwqUKIKX1scti1KJarNCv2Jmu8jrW8hCkXh3ZTD7Z673+0x2mxwW5YTKi7WmTSAovHHXRcQJBNINWzRbsvelYphjg1uadDhTQ3JWygXt0T2h67FGrc+OTbeg/XExVmR40o1arEZ5YVFu7f3ielf+nNyvcr43g+KSf2l9I/e93h1FNpZ8GG+oFfQwdoIP23MwD43vuIb5u4xfGz7YmELkv9G/fm53iJiYb27idXFUks0pd2KKuKzo8b1Ip+Uuh+q8gUFcr8/GVJuKeH3qXUFga3dEy/BVtYXUOreQkIxXnqbgyHl62qEZGNhfpXtyvx7JRM2fGU7uXGDveVRRqOMzhDXMe+eKnHeRF7y7x77JGSEXlhyG7z4Wrj8GtXDvTqwfk5KPeB8ffu7n2DU+U/ArS9/rYimSeysunEgQvij0sCifhacm07kMPj+NPiLQmh2sf466zzcaBxqWLsDwcN9eeqmyFD2upcPYxd3MdjgZpokpJyuZh4vVK90zHpotbcrDeMLj0iURzTIox/8QFQzx/+gtYvDu6+GMZvyi5s2h9u0saJ6uA1hzEQPt1IazjAnskAcMYqAullBjUqgzI9cFoz4Ua6kZBhLtNHCnbFKeZRnYFj3QpgnNTcbixPq2s0YKsSliq/383YZRQpRF2HjJqThooSARxyrNL7USA2ot4dbuRbo+1G9Kr1DCoaA43ai/rc2rzpi3CddUU0lZxq1w6XFgjWhdTncDwZrk7vtOrcvg99lD3S+XxEKd1ejhbSlwdx24hkkjltfZiwB80b3hH8vmB4ZUh51DFJkq1g7aZj3S6zwflYQIPOfVwekz/F+h41D1GFIMV0icoT9Elg+UuxM5HH7vRTa9aoqGF0P5afBGjeHWJT96mstgxTqJSrM9WfJZ2CItVh5Xstm69y+pFc9KOgWVDTH3tVgO6lQ/9+y0515SbIopBzTI62qvcvfinZ4zERmPYy2voJrSv8MD5ad5+eOWwlvIyjaSJbtkt7mzYsfh2uiyw0GuWHQJqKud2F+hf6k8V5qZSONNdkOr92ha9268OJezBbExYIG5aaNUesovJm60r1Pf3XPe1CdycMFD38MFhIw9dJvAh7zaZc9E2nERqmyB0PKRcoCxTDfJ/l85DEEPealms0F/NkyLxHepNCdk6hPA3GO8bN9v9TzAAsLqvdxwCncxWGDm4kVqw5Gq6led3MOKY97T486ZkV5iSNi9I8jJzsldurbt2I8mwxfu37e/bq+lFPCjgvtGmaXxHSoSqSGycNNFKajRhtQQ8qVWsRGQxq1o9b1JoeUW/UKKS94wos/I3AUh2nzg1oTXTWkw+PfdsRk2G9iH9Kxhj3r0e1236o36RyP7CVyg2mbGnpvjH9PK2H2EXNrV5aC6w8cb0yN6IwEK9UcbmLYvmbdmepw42seFAuLitSQz0udwb0OiWeFDFdNDrcM941q96E9CIZU3w6Tam5QmuSViBKTaJp6LbS548Rwd3wtpEEb3Z9lDD0vd/N6pYf7lfwoT9iryloXOb8LdxsVWb5t7+QLyFgNX4sKK1xmbOLAQh467m/f5PPwYtkpcF7K9ypOHVLI5b04c5D3s8tK/gpPl50R4eH2xdNw7qqFzl2ndqXwve2PXaKIq/liaE5fyBP7TOmv/PnWuDnRlgXjkcG+dGWhpnKUaNpr9gj/55lNMBDl08tnnbgv5JoVHnqZ1/7L5ANO3XN5joWyvMzPvv/1L0J3uxXYkJGbK0G82um27+GOMrqi1NZLU4V7+sbnv4Qtzn0CXvpihdeffF599p2/SRHV31v5oc7Xhfm+6sRRG9HXK/mRkR5ufAw4pSNKlT0qpDzKMA8avh/a0RueQQO+1I7e1MDP0etL/xTZJrJ/XbWM4L/XLonNcI7a3BIaB8vXVYeE+VorbHC3AqxmmDuOfxV3eS0jxKGo9bprL5pGHdPc76wtusG2Q8PCINq+jUYj9Xj8J2ocl6xO9bWbwOA2rU/8K1NIOTZUTAIsqsdc/8m33Rbdax9Sbsz1JuZwE41LyrUteK4JIeXGM1H7mugVbdALP1n4K9yuZ2UbWDBrCEn4K3hOokJxZZk/7PmyNGtP/JgigBOqdR5AeqTwZoDOQBalF3Wh2IIXzpgFr58zu1Z14pVxNfNU6qEHxsX35qpQzrUhDQB7itGmFDayw6Hs0cZqqPRXYFxZXu5lpKqNIyvENdLlcJdkVS+fVh1dGdL0sC/87qx5w+Eru2fRdsUM8wR6vlS7Gx47JyM8cZYFQ92IkOCGwFGpx72wcbz2pHAarp+NS3RJpP7AL1IPO18PTj3t/W7/Sf2cr8HSZYW+IjzcEOHhdkOnxeeQMLhXQwV8le/hGehbJz6Gf5Rc4tU9l9dWel6DXn35bKpsW+YpnkeFngc3IRbmC2rwllPKy3++tXENxIwNMDrxjfP9X0v/4Hw9IPkM/KrkXqfuuW9w+ykMUTXdpQEvNzIqrY3QASnPB88fVloXJdyCatWyHa7j3rdTYTPissc/db7+89XvkNp6YdxNm3R1vQvtHnFrosv0BsXIdGPbxTNFbtjZEXW9Pe+72DpxDX2pTxA1JqYk0uBW0X0KBd8BSjR58pS62VHoH33qL3LV0ecY0wt+JI0RVfv7/cWrYfLv/gt73+BHNLRm2OBmYkW8APXr1Baq2pY4XynGZbDuakNCN6QbPx8lEXNE9C9mDkZ9F38JK3xrMBjseDdJlHBeqsIe1RMeI+Zzh9oRRdMsTQmQWs0JR4UYd3Go4fiJWA1zumgaweAmlt9TPdz61bDb+L5EpW1sSIM+55roMdflKysE89VNQnJ1Ue/XergTpA1UNTUi7AXvVlFey5By/TmRczPlcOPnuTBMpEpzsF0QnYdb9PhGfpgTTvt0rlA+C/8Oq49fkjkALsgcAis1SuRBprslogr4Y4plq/NKl2bXKe16WWqeb9SmZO+OegNZrvdjtxsMQ/ur5by0mwuG0HO8cVQ0lN1WDXOMrBlu22FDXxrjgihPeNBjjkklk/D0qdtFtonaaJbh81FeddFE/s3V2b2dr+1gE9xVejFsm/wQriu9VukZi9d9YfeGnyefcoTFPMPXsuDbfDevjfBCK/NzldblfS6jG+z0emX2pfnC+cnkws88nHcvFN+dfhPJSEE0EaYu6oZbERst15Vcqz1/si9xbKLKwtvfqSrfUXfh218shtUbVSNTnmd53op51uW6lOHzqrvCP3feJqHB4BaffzWGKgBRm+SU0PMx1le0kHI72uC2ie5nypa0eKcNbtKmI15Fgj09WPobY79dYTU8XHo2VH0bDk/nrG4VNriZWBEvZc+cth28dvYcKEUiRuF2TZPDHbchXdeyDcVF0+rf7wBXIKhYf9h2tqkh5XGUBSMKcDVYuS8iZsE52nlQPdx6g1s1IExGFE34iyyaRs7NpnpzaeHOFCzifSZrGjt/Y4g2sK1gXedoVKG26GPI5mzVWDVsHtI2IQKecI24WmgTwpgnD0Xv6Rzy0htFzpDnWves6FPVRhVNq6PBvdvYXpEGt6k/kwdebacXfzsgfS5Mq7kWlgZyjYPtbs7tCrfmdqrTZ4AimhbYyMCkcii02bjx5/f3qx2H6ZuRQ7wSRsMiql0xg9sm1DDHa1p6uDsgb7M0QjEbkMJ+eFwLhnRr70QZBKMIVK+lGwbueriVMZGRLy+BNODxZoB3DO45+UdurvczUbv84pJb4Ljkw0r5sH3T53ttDkw9C9l01LiuAS83KjIbFe+qNDiTyfCzAtcXl6HSOKS8HGpgfU0W9ki8BA+XnQvvlh/rGY14k2JG8oNQ3175MGm8W+JOzcJPIbX1QrvforD+FStXwkl3vRvZTpTmEpxVcmdoTNxOXnfsOY+6Zr6HWx9SLu5h4eUunJOodvk6ebgHJZbSPNwagzvkWV/5ZWQ76n0eFBFM54qrr3cNRF4EeaP8eCeyYvgLC/TzYalzBza4mdhJJRNGY9tZeOgGbFSDO+Ytt+ADrD6o4cQx9Id6oeYhmwxpvFlhanfR7oXQySv3Vcu2hPujecEouaqF/hpmHVE3K0woRhQSdAlC/lxChphJ+Es1AE0GMrV8GDEnnOKlJXquxYc1pR3WFTDt+NuofBi1lrTuWIWAITnMnhAdINYaycMdCinXheObz7FU7aYKyVHy3289fJJyDLqXvweOn2ZUWr90r9HOM6RD+0CONJ6BRTek9dEG4RDwtdAunFetPS+0m/b49Ine9/iaiGWrUyDG63i/iX5kRhC8joVA5p+zuxVtFwz9jWr34hmzHO+sycM9uGs7recatYS8O56phjlee9LDunPyNad0WKGXcEi5ycONr02wXnhUbrEnmoY83H4psnCefFT4sRzzpfxouDs7U/nNNskP/BlZCVgOVXBP1g93X/n916H5bdWvStnQ+GLJCkXIzCsBZlnwZb6ndmVK5XJxzeQ1ECHlv7zjHbi6VNRDV72vujSH4HlZiVIqBlk/wG8f/Tgwh0K79/OD4Xp3XQrv9fOfrYjsrxh+6Ln0cEeElLsbro6H2z2OPPJwy7WPNzWw2rruWEUqgRTpi9psidQOyRUPUdcZ3KHPsbdvg2KcmbpTq2ESPMPpdDiKIPK5UL2mTu/SLKSmwgZ3K6A5bi5h482koB03UXkm9aG23g1zXnvMF8qqvdJ21C55bUPKD5k6AD66cEfYZ4IhZLEW4ckQQ+hsfTAtT+o1O3f+CJL3NdC79je2MimT55oWYqteC5PHHBtI+rVCDYvGIaT19XArdeJN5xjN2+Txm4Hy5HVe376d2pJF2Cgh5eKlkRIdUHi5JGxEWeY5iTDwt86dE9g4rN9GypBuFXDB7qPRT6KfueP6VcH4AV21/Ym5iWdIRdtAapLiHa69h1vUx6asT/kCrh2sliy0o1MZvv5xA6QMUS+SE2cPMfxWnZsIeT4sfTpMqv5zoJl6rPoSYpa3vj9F845q17uqLc3D7S6DTa53NQrF+HW9s6JG9UtlJymGilQpL4xr8nAntJ7woAcZjykUoZ8o/TVMsXBZK/G0KLSVRpzO+z9nRCFU/IOAaJYYKzjuR3ahFJngh+/9eszBY612z2+uRmwd+AaaH3qdgKMzp6HjyyteWPk3ona6XNviZ8LL+WRuotdOqI0Hz4sUYMPI+Qm/9rv5wV4IuwgrB0149wZ3EyUqXFy2eyrn1zA3hpS717OTSEfIZZTbc6MrTCeOQUbIvP65X7VFlHzDfTkGt3tNowzuHpVl3vqUGwydICwOKKfwWn6497PFK1QxPDyu93dOXr7+WD0qo+9FfKWOSz0MnZY8W1Sl3CEbtWEUgWZ+VJqhCdIksMHNNAlKLelG9HDnYt5y+9YuiKdQITswrcYLUZeeB6edwbrEO5/FPLviZTk20TRirneDiaYV8XB/6qqkflsRzPn06djWf8lM2FliiTb9nHCuvdHox9fTaHAjI9S0Bqx4Q8opd2Nh2hQPN/obU8/Iw22agXqs+u5U4820CZEkeq6LX7OwYa7zcBfP7hPlq4qplEt6dWpPamehjTvTDL5YibxOmnMifo7r0eJzt9e4wqbeFt0r4Mx5w0l1wkf3riQZ3DLEtFg7CuUlfmhr8Nz9tFFsE2gMbvTMFYJ629RcU5hbwPsYjEoQPT6XH6eEFEcdw/Y1V8Lh6dPhH9k5hnbmUHb5WWA2uC0v6i20kYHAazpYJ7yQ/5z3Noa/vnRnuOZnW8EGk2fdPS/3HTc15An3a3+HxxTh0cMTi+CCkluVetiyqScUFpHvK9brnw4Y53wfzM2fkvjUN9Ldc3xHbrZ/jN++ADMT78KfSq5FmzBqSHn6m9eUOtteSLVlwRK7i/fz9lCtlAeTcxWf8XLTQ/aD8/SlwSmuxZFp34AfgJTRnX7c8zdtSFdYZBc2zrZNhEPPsVEr12OUkr28ti/kC5t1y+2OTq3sjeks/Ore90Lt8JyrF6vh6Y9+8D3K4S7cdx8u8sW/xv/2KaUv0U4+E4Lidc7P2pZ4x/CTK87YyVqrPQYcHXDsLS9rz4kkvSlC2T/izlv6kzm8W1Kx4q3In4ee2bloz3qQ6k11M7i9d0a2uB3Y4GaaBFdEMpR72fDjxmtwC0+CCIu8p/PxsfYbh8FNtN3g/177Dv6dmwZr7bZQPWIfWt+x1OGmhorTHlO1vbLUQzBGB4AFh6TPhCsy+8GDQy42tAOS95WqVI9Du01h0YoBaAwVpxrmOF/ZEA1BFE2jEBII04AjZUxlwaxkqtaecJMhTfVwU8PsqSHl9Bxuq5b56vr2226BNhiNOcXonBg2OX9Ylyl6DBMGdFLzuNG4c0Z2hydO3hYeXDDdmbXi4dYcx3HbDSadO0XJ3NCfCVEX++Q5Q2Fi/04BtXWc/mBBeYRadOF3trIxstjuCgOq74DhNbfBYmRc6bz+4XJj6jEshc7wbH4cXJUNPPcD50SWYApPMAGHTy94cWVesK7d5AGdYMdR3Y053GUpf77B3P1dEq8oKuXiM2hc3ypHwM40rjO3TD5Ud7zEUg3aKG/5iMQiJQRc4itzR103C9qWprRh2UelHlXGFce5yq3/Lo7u1tLLYbfkK3Bc6hFl3HZuCPPaXJmyXjxvsVUQ/pKbMZXWeiW/2fdwJ5S866D3WmxsFOZiwX/zE7w61rgeemH2hWfnqN5VMNL61vn+gJTvWS0ovduqwS1rpkd4uGU7GYkg8ssveewTGHnek3DfW4uVGtjB6gA/rFyjvJPg3Gx5rcRGx5pN6gaJhZ7NgxMFD/jNpVd5v19bnYENNWKDRB6DKPfm5vmjtIOo/uS1X7UmyhNeOHdrDH3hdpJ3v44ulRZ8wvb56KbodoGIMptocK9aG70hUAwWTVNhg5tpEqj5wHGDvblx8Hx+LAyruR2eqiyolhajpEhue5wGLe7CdI5XrKuBkzILYHzNjQBt/RqjDZ2PY5GNPNq5qK2H2+S5JrezwMnDuz63B2wq7Uy7FoYcbjJEMTTVaLTqn09PVD3H4lp67yvxmpFVymmLNYENboNhTq1hPn4ANnxoIeW6agAFzzVlsyKeHG6J4uE2XX+c/27qV9mMsetc61zmLptys4f36ABtSpPOqafkcIta3Or61IWU19/DPbZvRzh5zjAnikupYR7oa+vEJ7XuWzVwdXOz9Dnc6OfFSqrtlz4Pdqv5LWxRfavaLpGA7YZ1hf+duX2R0G7L2bi86eCJkCrT5+QfOHUAbNm7A1yw68iA+j/AH0tvRKHUljdNYz1xt92ytdWhkHIZpo7XcU9rZagHrx62JTzcbki5Z3CHo5Vwf1Hq82MShTxtbPvcn9tWKwAm1t0eW/WCN9wwZVEjXJYCc/7GM14LHa6GgvFeCRuUDYFy15BOWCKH2xdNC4bGSw+3PA5ZPg7njRfOi++9/Jc7f8lE61P4oPwoOD91u6K27hv6egEzGYnQwdoEj7xf8FRDxKoV/b2fL2z25DatVVY6TgOQzwSxkZAJiIT50QthqjM5GHPBf2DU+U96nyfi2Szv4/2Sz4XynfGx+lEQhWMVxv6S1ZuU+a1xa7ULkb63vyseev7pkvD6LMxfvV/XlXWPaBM+TivC4I766EzkiaHnGtjBXYANbqZJwDd1Y+aYUx3cZDVX9yFsEqDBlFENbvLohj5okdjeiEIsyNQu7s0KdXjTBBvI4CZGVlBF04zCdLidSaVc6cMcyqn5o8AEid5XxUNWfwE7upe2OGGBMEodbiB6uE0h5UTjkiokR2jnGNya8GllyFBJNVO72tbDhnrn+uN1Z9VTCV7cpxlls0J/7ig53OI+peVwU0XTipMKHkMgsuKFHM55R0MargY25hTVc1OoPzoGdelb6hwCxyrWx/v2YMeDKqKhfArj9urYxhxSjuaUT+kN5I5ty+CRE7aFw6YPhNfzW4R+L4xNxetbloo0kv1hE95nl05cTdxHUjzw0dyU0O87eeHPFpw6t6AAL72X2DPpCQCicxeOMAjPTSDPHa7/7c3PsmBYjwpf0M3Z2vCN33auaFrbssJYcgNCnCslpFx6uJO+aJpUoMYh6n5IeWF+sq3wSgvj/sqSG2HbxPueMSgqKTyZn4RnDL8uucv57vDUk4o4nSfWFhEZII1VHCre11qutgkY3PJYX/n4m4DorC90JyNLxKZC8LPc94Srz4Avlq+DH9b4Xvi8u0kuWo9NFJTCJyU+AzunfparImxqTvjYC/8D0y97BpavrfbGlZsjQqTvta9WFb3/dZoBwc+ntzZGpzqGc7hpHm4rH7ERhDZsdLBomgob3K2AxvQgU7GbaH7UB0Btp0Q15BszX70uZcaMKuWx29tEryrZ4K4d1FQGs+AcMvKMjnB0LWJQKbcV72v9Q8rJ16IuaQBUo1E3JHEzhRpSrni4DddCEaYjK7cn6imaRhWcC4aU19fDjTyfRj0F7EHW9ydq/fp/pL8W2Ag1qROavMMY1cOtOSfEKIJ0DB5uSY/Kcm1pwNF9KuGUzPFwU3a+k1NNRReaHSx9iXOcdR5ugZrvrT9WpQweOsebjLnU/t+sKgl736LQ1SbH/XVqVwq35HYytCvMT+SP68qHiXPyjyOmwMFb93fU6WUIteTc1D8L7SABc0d2hzfPnQP7TxuiXS/yftt/Yl9zmD32hLvnrpu1OrLdkdsM9AxRoY4tQ8GxsdytQznMH9PTM96vKvkzzE6+47Xz8s2FOrpd5eWUC6NJer+dc+W2k+tjK9fAvKjkFtg3+Tzsk3wB/lF6mV/aykrACruj9/d7J15UDEM/pNyPyogy1KRxudb1+gqGW4u0Hl9xnuU5sdJr4aPv14b6KkklvesixOAOu+V1Ja3Qm5ttwfmZQ53vv7c7Od5oK+Ldp01pibI5Yb9yrcbgxmkHqnf4w+/XQMLKhzzcUSVrgx7uQq3zDaF2wWd8pRXRxg7X4YZ8hIc7Yh7JCA+3uLX+WHJDoL/oZz2XBSvABncroESJtWweqAJcjWlwU0tPNEy/1DDmeELKkZFHXALmsmAxo0TEEkXTmsDDbbp91KBek2Huf5+g5nCb3bRAgujhptbrVtaH0bikGuYEg9uyYLWb42hCsY8N9yNW4jeWDyPmZiubH+Qc7voZg+I6UOvT03K4iSkKxJJqFtDOMaX+tzhV2Fg13WdKziw1HF9zL4VrY/t/c/k+Y6A2FOq1pyKfAVv17QgroRIuzR4EX9mF2uMehnWsGLjoWLtVqIblE/nJke2CfUsPaqhdgLwdHQ1jys3G6329VTznmmpwC0Reu6Gh838R9o49p8E2/Tq3hd/usaXzfdATXul6seXnUJf2ZZBIhY13TxHcbff7fcbAjmP7h9pJ8TN8/0gjeWJiYcT0LChLJb0NkV7WSsfDLJFh7aK/BTOHeF7knpbqMcXh+AvzfgWRYdZiJVxcGoid2qvH2Mta5ZRoC88voWzW/L7kZi8PXDVCUSi7IaRc3JuPuJEGfd1ycMG+ZDtZqz2ZXh/ZVzCk/P3Fa+DdxasjDeTP7MI5EV5z8XxVq4wVNsjKSpKeWrwg8/lzkeOKY9WpnovbTo67xvNwbwJwx/Db2aG682KNnRioX15oqz4T8fnHBO8BK6JkWRSJfLRnfefk6+oPMhsjjffm5/JrGpqfJcbETmN6VetCI2qmNVhYdI7Yrclbiiknhp5ToRr6punFLThHlXX70iqUTVmGdtGL90erF19/lXKah1v5m1jqcKPQUNMmCbZCE0TRtETjhJTXhuMzJ8FH+f5wc+9LtG3U8oJ5YmSDKYebdgyq19dwTmJUeA+plOtyuIlh+1OHFMoY1S4326r3cw7ncJvU8Snq42KzguLhptZYDx0fGrdDefEqDJiabF7xDOPICuOGs+FX0tgIGm+TBlSp7XCOs8HDrbyM1+Heppbn+ipQNkrXzlgHGp0zvJGhayecDrqQ9+B61xnmSnRASTgPXYqw4Y2jREn4nPhGI4oOcOfmlLgK/UGhPxk+LQzprkghW3quxfoX73q6Um/Siy2iT4RYnmS7xHsoD9w3ELtXhueOPfbYw42PRdQfj/Jwi+eVKaTcy5UHC753BQG7BzYNVI+vH1K+fKWvQB5UoJcbN3JM7BxRwt3d8yby6J/6eJmysZfP+3PDM7htcSFa4/pnv4A7Xvsu4OEu1SrZl7lLRHq4BZvWhXO4g5uVh6aegh/cPHDtBrd7DdPZ8Gebsqkmynp/vdwJccdEviJrDO4QAYObUWGDezNGvhTMGUEL4WpMlMdmI3q4u1aY8sx8amtbUj3cxbz5J80eCruO7QWTBnSC+oJH6tmxDe1vTC+pMW9WUFXKv04OgPk1v3OEe4z91XJ8cg43sYY5tca6ZSgLFvgrWhkvo2cdh+wmad5co3GZIPZHbUcLKf/M7gvz05fCpx2ma9vh/RPvZTCyXYIUbUAtC6aG99OMPFOefN1UynUh5bSw/b6dOxDXHc5rN3i48dQM55gi1iaOQVUp14fZU3K4Bboogj5VhefkoC7tjAcV0F4qyqzh3ZTzhV+kg8+hXWsuJkVq6DzSweeQakhb2pQaNeXB/93E/lX6fH+8CdGWlsNtRPFwFy/3Vbw/y/vclTWgi/UVLEeGGnrf/XehauDpyCbCx9AmwrtLCcfHGyy6duI4dRsLfki5eryDEj84YepBg/ugKQOhd8c28NvMQf4QWOxWfu+uoz9kCkr3y+wq5fkr03sc0bRAOTKM7G9kr47extl816MuPLvzEq9BJ/A3Go7Zboi3tqWCel9rGRySfNLrX9xzcgOijbupoDz/0dzkeetj/Qh/fu5L1cPt3ocFgxv9Ir3eCfG+4smFcPYDH0CbEstXKdco2X/94wZIuZ5r0UaWaHvg1U+K1+HWvOfIds/mxrpjZuBvL30d+rvgXZO0M/Cbf38Y0WNgzJw5V9sjHQhll7p6zdvn12iwwb0Z88yvZsI/jpwMu4wpqEw2J5pKTOHXOw138rD+cshEY7usJhelvsdTzMY7Ze4wuPaAcWQPETWVoD2hLrbANCyunR4HyothES/oR/bAojXPg2FV9fX6i1BPwc8mFepsR4G7eCdCZdRrh76vSeuFSshHgIw8Y2gvrjlNNKRNxqCqLF9/DzctpNz//sUv9C+6+EXKdENiw9xYFkxR5DblFUSXewqSJ25qUMuHUepwUxXebSVU3OThpr0yqEafSaUcG6G6vmi52SJ6SW2X1M5Ntz7vOGprOGRqf7jtCBSGHdFubN9KqA27jukJh08foPFwq20/sAdpUj1U1DJX+mumqnj7x7Bg1hBDGgg1OsD/vmelP85PwRSQwDr+Ml94J7khu6u23TpoC8enT4Rj06fAm/lhxv5qlJJr4ftIHI5JNA0TLB/m4/f33mJDPWR07r5cnSU9c43h+O78gt7JUH9gOZsom0yRBk53hXFvye7o/R0u+ZVwjUERUn7V/lvB0/kJzr/X2+XRBrf7XFsD7bzyZdhQxGXBcDmyoM6G7PvgaQNhkhtaL4xfwaUlf4UbSq+Bx8vO8tofvd1gWO+ek/bu/J8sPRMuKrkNfpl60OtVetW3SX4E7WCT8rkvvxNzwxEa3WGVcgv8sNr13FoWnJ451vu5EJLbmPbv5TZuZKIph/viRz9RNiFkOL7I4xa89e0qOP/fH8K6mqx3TnAJwCjnTtLNCf/IHuBtrkS9j8jc8Zdzo5yvIhLh20DESeRHZ85fxz9tSOujHUMh5QyGDe7NGJFrtO3Qrs1UsKBpbkVRy1QY28LoNjF5YMHDXNXWENZWB2O0MfPVZ4/o5oQXCsEVKqb5xW9wU8I6ayEkFnMO951Hb+3U9xVlibRzQ2O++PmPNJFAU41oNKVMaWUMZcGwGJahbjbRkFasg1gM7uLgcyxK2OnAHjvbsGGGDXOjhnfMNcxzyrUwnePiHnOy4BzR4FY2cIz56v7zMJhfqIyrfG/I4cabEIbNDxme6Q4c2Sabt9Xa2XUI2xe5vBftviX07RRl3Ph/06eqLVxRizxucb0OmNzP/zc6VtPnsyLIFwB7MoObJB3R55ZOzXz74d3gP6fMqPU9q2uHZxDKvw70t2f6Itip5jL4e3YnY7vH8ls7CtihMOlAu4k1N8LpmWPg3fxgTRSdatTKWsqFdv7MxTXVhbLTtUT8uT2x0PfIhvH7Myq8y5DyIh5u8XkqPtN0IeXBcQdbhZJbeyVf8tXf1Q6dz3xp6Le3qh3hMUmJ+73lPndxuLg0AAujhUPKBeek/k8ZDoeo/z07T/mdEGoTVKGQ+7JUyvP6C5VvXFZteuIjb73j9XpC6gH4csX6yM2AFbb/eds1IF6H89BfzI+B32d+5o2HP3dkne92ZSXaHG7cn5ibPL9S8X7vG16B2175Fq54YqE3v0/y/T0BxB/Xp2HxTxsjz5289iKHO9oTnlfKAJZADj5dqtbYjvo72831/mDxGhj326fgyNveiDbMMxHrqEgUXmuCDW6mSWju5QIu2XM0nDJnGPx7wTax5IYPdEMUGzPaQHi47z1uGvxml5HGdtsO7UIyuKcMqn+YuwLRw003uCFWg1vU9hVebnOoOHFuaH0kjXW4LTgtfRy8mNsSvtjiOEMzqqAXEpsyhXZT+1O8tEThthg93CZwVEgmUK4Fg1+QyCrlxk0NWhSB6uE2nePiho84BEpEh0W9L3AkBDWVwWAgq88RfX/bDCv+PHQ83IoHU2Nw5/KkOtzUKILIiSCGdQ/Uri7CWvdl3Bk/IJCkw7RJJkNRC6jH8MDx0+HobQdG1DpHa1+Um0LHgM+JTTa4o9u8ESzpFTh3Qg38U7sfudZ5KD880E54w+/NzVRyYvHkxHoUxoVkCfIY4nb7TuwbKFUXfQzisyOnuf+wYY6N5CdzE/XefJP32m2nbDpFNywY3MbybH5/n9j9irbr3L7UObcSUdtbIsO25eejlwMNNcomW8o97zuM6qlsxByVehz6WcvCxq+VgPfyhSgPoRif1JXRtBJe9IbwNPcCf8NbGt7i8+X5fCHMWiDGP/nud0Me30LdbH9uwvOrlK51v8ofSW++8KwLj3V408AvC3Zayb2hF96c+/kknvW+h1sNxxYbA/I8yoiRdpaYZQaO++dbsGjVxtC5kxsawsgPvpKKf8t2MvVGbpoUxa3Xfdsr3zhfn12oitnpQsrlHJqlz68JYIObaRKEJ6E507FtKZw0Zyh5nsVeau//xTS4+eAJcOx2/g58c8T07jm8Rwd44uRt4e3fzI1lLKri9aJV0bumQaTQStw53HFELOAPv2Ie7n/lZ8DBmbMhW9qBKOhlCgEm5mbj8EtT2LCatK5vp/ub0LjxfRJjQzoq9837nRJSmK+3h5uaw00NKVeMHU07sZ4otcmpnnA1pNyUokAzuKlL4/AZQ4qHlKOatoUfRBuhQsmZmutN9uYqNdHVGY7uXelESk0d5AtQmagoLyE9A7BxtnDw4do22FsYPAaxwXvO/JFGgztIVimH5fcnamxTtQh2qbkYzsocCQ/npqqda2udBz3h0fPbEDIio9vhHH4ceSLueTxvHPIe9Fwra0jzjBR57Rdnf+58v9QtsRU1NyHodlVmbyd8+/7ctoFmlqYkW7A74meMlXBE04z54E5/heO4JzezSI+FDRlxPuTmTpVXk9xXPe/RsWB8ygiCNpZfZxq3O33H4aF61y+UnQJnpu5wR/O9zcugyhOiE6XBojc3fJVy4R0eklgS2UZcgwfd2vFTEx9HGvByXkKYUyBy2rETxb9fLS+8XiDE5p7/bEVkiHpH1xsvwuLtrwseer+/Qt+VbUu9cnV+GHyBt7/7yTsneNNDhMV//P1aOP2+97x/T0h8HjK4oyKG5LjS++4p62ucA56eQURZsEhYNM0IG9xMkyBKlzxywjbw/OnFHvotg2KiaVXtSmGHUT2aZYm22hiQwugWtU/jgeYFo/JAfhu4OTsfjkyf1mjq+NQucG1Lo5FHHpgajo9zvU0ebqLHjzguvWRVcajGG95A0XpFauHhpuZmU0tlqYaKyTAvfi3EMVAMbvFcIhnc1BQFHDFhqnVO3JhRRP0Mq0ENKY8+JwdO6UcyuEXkCtXgDhoIwYgKkZ50wW6FfMhiDOrajiTWJzgx80vYoeb3sKTnHOXnIgw8yutL9kgr5d9oZeuCEVKm9fmhPQjuzM0Oe661BnLAuNUcR8iI1Brw0eHgYnSxCfBJvi/cnp3reSgFwfsDn69qFF6ODfNT5w6Df+TmwmHpM+D49EmBwdT+rsntDRdmDw2F2eNxTR5uaii7eKaUGtTYcbtwbn9UQzWfXtAdhVqXud7RQV0rlPUoQsqxh7vUVW/XRVgdl3qk8Hvvb4RZ6I/9aNnZ2vnhHG6sjP5afrhy7r6zu3l1x892DfzCSHmvTnvhGArnbv/ks7BqQzpsSLvnRB6rCLPH+CJsCZiMSryt/O6TyHY9q9rCtsmCaNmYhCpyVp0RvdghrYvDUv9xnq8yveru0t96v5Mh5SIPPxlhTMtzLO+TXtaP4ec4epddaPcN5XCb2LhhbdGa3q2Z5v32z2zWbNm7Evp3jlCDbYHEXjGrEYkKnWoU6uItNSA+ni7JHgT/dUVeGsPDTQ8p93eLl1ZNpG1BmPomelUB1Zw2CV6pitwmg5sWRk41uCmnj5r/hcVwZBhjZDtUJtEyhfYSS6qR63CTQ8+LG4Oi2oLJGMT1n0mbGkoON5CO1aSgTX2QJJQNSLteomntysRVL74hVF6SJIXtV5SlSJsa1MeIKa+9p1uC6dz5I7wNBqHMH2RMn8rokHLDHLDnmh4qntBW9lA95igMHbWpUcLd1XaPnuinaYnrkEV1vXG7Ww6fRAopx3no2OC2Q6JpbWBe+vdwXvZwNf89cB/htYaF1nA7sdaE5/S5/Fbwrq2Kz+k2uHBJLW9SLtiDKT4nrs3u4Tdz+xMVTIqVShOGo7E8m9OucByrwBBBFZif9Oia+sMh5VGeU9nfC7nRkd145cOoH8uW5YXsC480rj0ty5zJa7bK9o/1yNTjoTE7tisc36TEZ87X+cnX4cwb7tKWcpPrApdT838bfpL9/qkvA+1kfeqEJyDokN6ozR2XHJd8yNGr+HJFIXx7y0QhzFuAN3VS+aA4q1/UTG5givJy56duDziMfAPcS+VxQ8qLvZ+88IG6acCosMHNMM24vndjoIRONWKyjRRbKfyj8cYd66qPm8TQqCjlvizzhsy89GVwfuZQeHvIL0n9mcC51Epedag/ZCARPdfmdnW4TvWsw42XiVSOL2ZI45cvs4c7H0NeO7EON9WrSog2oIaKF8SzKCHlJbUPKTdsalCfI0orwyMUGxrG0oXkUPHi7S7fZwxRY4DugdRFVgijURiiR23rK5QXQymBZniVU4TpDLsDdfL6a9qFPdf+t6N6qWKQalSC37AfEq4zecJxHjpeJ/jaBa/RMhvpkQR+hzcUZLhvVDtJeFNGY3BHeP3H9+sYupZCwCxqk+TE2UPhqMxp8J/cBHg0N9nz4uL5CQ930TVrJeDpU7fThs7j/opFDsj+RKSiDCnvm1gBnVHoOT5eAVb5lvS3lqIw9MLxHps+OfCX4XHXemXBNioebmH0Yw83Nrixoj0WTZOaB5KtEr6RjMPd8bpoF/BwS29xv87t4eT08aH5BMctKUnBDunLvZ+n16+MbIfXmFQijwIb3N8uV2uYF/rLh66n8Jhf/qTvjceh6LKdFE0rhl2zVpPDzUnchfPPMEyr9nC3KcFGWeONK3Z3m4L/O2oK3HH0FDh8Ol29nYLJyBA7yIvtrnBbbkewSvXhg+TTr3i4ae1Mpa3UkHKr3sazHaPBnUJe0KHd2uvbJYgebnR8QsNWi+K5Ntzg2Ag1rQEl756WT09W2tZAVjMnCsQpHg7DJiPdSYWNIptYX9tkNNIiNSglsLpUlOkFtOrt4c6H8ruDhmgx8Nx0myRtS0VgKf5d/Qxpgc4jjaGKoQl0aQD4fGWCZb8I45rW/Yf5Adp2eCy87vTPTwvShCiCUEi5lYC7j50Kr54126koI1lpV0TmyYt1JhSyj8mcBgsyJ0fmyYuorUdzU3SH7TZLwBDDcxT3RzW4RaQiVaxtGXRyREExz5edCkn3npDn+YX8mFCpskCHvmiaVQNtXKE0gf994dquRikEP0Jl2HNtWTC4a/vQ83WE9S2ck/qnp44uDXjp4RZibeqM/Go4D+a3gf/mxjn/7mmtijR8B3Xt4DyzVrgbApfc979Af9LQBzjKTZXrbunLj4rNIrnptHK1r8YezuFW76cbnvsS7n1zEXyxfB1Y6GU2n3DXrMbg/iLfS/l3aVYdU40LYNjgZphGyOFuzhyByoY1qoc75rEqymm1xkVN8mmDu8QSUo45dobeO4VXh2lcJcreMJZR2ExpRzsnVEGvFSn1A7a+IeVxQl27+PwbS2ChEHBj+LSSw62PNsgRwqJrU2aMElLuzInQJk9cJ8o5JquUA229a86xaKMLFa6LMRg6d5rcUrFMKOe4bsdK1HEInJLeSMAMe2J1z9L7j58W2ISgerhp7fC4+DOwNga3Tlke961688Pzu/e4qeTycUEjP/gMEBujknIrHdlfMKJNhJejhpFjhg1Sy9F06VFZrvT3XH5sYN1Zkdc45PUXweeWBWvANxwfyW0NN2Z3CbWTjK7+a+RcwwZ3adF21QSxth1HFcqxVkcY56J2NDZqhQAYzqGPDin3N6+rwPeqS0NYXtsP8wMjo1twyLb4DnulhWq4qPt9dOoxODpZyDMvc50TnofbGQfrs6gmplTrn5t4M9LwlSk1q+1ClMbCb74tjOOseL8Ot1gPr7t99bZWOr+PQrSrcddFmZWG175a6aiZn/vgB/D1jxu9K68ILrqcft/7MOePLyibgRnX4F7609rId1y5efF1vnBdN61TNwP++J+C57wmS6vKsLnDBjfDtPKQcpGPJonZBjWCa3VSPfDNGVHzXosd7WGta76yybBT2ineV5vkfTUZ8ytLe8Ch6V/DrjUXk9eUOYc7vvtGeLj/5SoB352Yp2+HQs+N3lxl3sTQc7JoWv09jVSFd5qHmyaGpm4IGTzcxZL9ammsYoPLtFGnGD71PMfU6AC6wU1LZTCx1/g+cNx2g+HWwyepHm7NPIXI5exReJOMmPJg0iIgnLtiomnCq1sbD3c6mDYTOOeTBnRyUgCksSEwXbsMTskJHMPNufnwUG4qHJc+2VGYjjqGTC5ocBff1NgQFClD7URJO8kb+eGk6AWT1//XmaMdgbhLMwcYw/Fx7ngYFFJuNHwTxZXWnXYWtC1NacLrfcb27eSlwmBxu6j+xNqRRjkOY/dDyv18dfmZJetdB8t4iVc44ZW+MzvL+VGl5Ze4GpgolC8rTRXmL/QApIo6DmX3wuLdcWUu++DED0qak5fD7baTHviOsN6Z02OlZ8FzZad4hrXwtssxC8enetYlI3p29O49oVT+u8c+gUNveR3++ep38Kt73/Oe7UtxSkUgBctGz/9q15P//EffwQPvhFXg5XHI61S9Xq1f/t7iNc5XmW/e2mGDm2FiIB+D8HRTgXcuG9PDjT+oTIxz89yK0sR7HibPNZauiuMcY4PN2Bs2pIwv+TSPtJi7qGv6gV0s15Rm1MZ9/s/KHAU/S58LV1mHGtr5x5cuNaytJHpRNeV6Y+9wPct9Oe2InkZKSHmhP0ION/aWkq8q0eAm9reh2zhtK7UsmMHDTc3hJtU6pynB1+V2NqnoY4KSd2KNnzlvOMzcoht07dCu9mXrEvXz+s/aoitUuAJTpnFDBlqgnfDqSkStZdQw8rzKkN7ajGs2uPURHZugHE7MnABP5Cdr719sIBf6SxYdVzHKHfx2ubwNc2suh3MzhzvlupT1qblmJq//3blZjkDcEugKac21uGKfQsj2Yl05TaqHG7WRKtm6/kSKg8BUuqy0JAVvnzs3pIquW6uyNFgXq2DcSUM4eC1k+bYOIDy9hesnf1vwcBfuteVQ+EzoGKiLXfgDKxStIMpyRYWoB4XpsJHsGebufSY93KKUWCdY5xjowpPdzT3+zu1EeosfLn5VyQ2RG6Pbj+zhXasB1jJnXX2FjF057moUBRE8hjzaTMLK8795sKCmrtb1Lsxhrd3Oy6Vn9LDBzTCt3MONacwc7k9Ltwyr7dbj3Arlzqagl/vyOKpXB5oSvClFunhqaaE/cn4xNhpNqtL4RdfgkSYuECXnTvPy7vQX4y6JmJt4CX01PxKySkkvFRFhcEL6l04e4aejfGEek+faOE9FzdwUUk4TsKOIptXG4CYZjUjN3rQxQw0px5EapqgN0d+46hthds0VkO4wQB9Srnjz6p/DTfHSiv0zUg53XcKC6ujhxixeg/IqjUKHtA0hNdfbMnj9i5/jYiHgGL2H2/+bY9yQXtO4+bxNzuHOovVkSlHA4P7G96+qtYc7aHDjcl+ZvA2f233gn7m5ztqkRBtkQv1RBewspb668OQ/nNsanshNimx3wOR+RXO4JRNrboBZNX+A+TW/gw9Qnrxsd+yMwZH57MF24p46fcdCCHWxayHzuHdPqvnP+BgEa10vrPhsuih1K5yXut2rKy6uhfx4lMYj9nCjDr3njHxvEfnjItd7WuLDkPDbnbntvb8URmuhB3GFXYPfnd8g63vn68HJp5U0BqeeNgDsPKa3EhkwM/keTLKQ0JkcNZnyojJuKr3KMbiV3yPxt8sz+3k/Fyrvkque8kuYVVvS4K6BDekc3PvWYu93b337k9ef9HCL8mzBzSimmRjcL7zwAuy6667Qq1cvZ+E9+KBa+D3I/fffD3PnzoWuXbtChw4dYOrUqfDkk08qbW644QYYM2aM83vZ5vHH/TIADMOo4EdyY6pJrizpAdvUXAOTav5sbEfdy8g2UZjB82fMgo8v2lENow6AP/diiSLAxqDhBIkPYJpxS/OqlhCNiyQ2KGJcU3F0JbyED+enwcGZsyFd1kk/FjaeY8jhVsuCmaIh6mA0GvBfAg0omwuG+4gYUq4uE7Mn/CfoAF/avY3PHsWQMmxqKEajcfMjPg93XextL5S1HuBjNWoRKOchfKyHTx9AD7MnRmrUJodbV/8bL4drsntHzEQlZwuDu1Rbv/rpU2fAHlv1iggpp4Zj+PMUuddYpBF7kbEB/7NJffUebtSf2Cyg5MkbNzW0tc6jr4U0xkTt9BMyJ8K3bq3qYLtpgztH5ItHH4fwiH5t94SP7IERRrUF/Tq3hYUX72T+LHL7q8noo0DwNTOFxeNrIdaGNJIPTj0NR6SegAtSt4Wekqvt9l54d3jcBPToUB4QTtsE95ReBHeUXgJjEl8p8xNre7VrwLe1quEPJTfA/8pO9Ix5WUVEbjqNTHwL5UjRXBrfMhS/EoXDl7p10DGJQDRE0OCW572iTSn8ObcHLLML3vwK5OHeUO1v5G2y2oS1DFz+8/EyX4TNvdbTkx/B8N88AVc9VSivxjQjg3vDhg0wduxYuP7668kGujC4H3vsMXjrrbdg1qxZjsH+zjvveG369OkDl112mfP7N998E7bffnvYfffd4aOPPmrAI2FaOy3Zw91UUxfvK0KgBgufRCHLd5lKQkXl1TUW4uVLfiBSQkOpHm4TqofUYNAkkvBybpSTz5ftNEzbTirEFv6h9z60NWwqKP25IX3FoOYhe+2Jl1jkrlJyuI2jK942kxGKNjWIhoXdiDncJOMOb8wQ1cfNIeW1FxLTsbEmpxoN1LBoanSANoc7XtE0pW+ih9u03qnefCXKJWKu5+0yEt75zVwY0atK2+5XOwxzRCnP2nkE5DWaBb/ZZWRRI68omg2rJ/KTivYnjAvV0FePYUi3Cjh17hZFRdMMk9P+RmeQHokESY0h5YELrTwrtIa0OqZ89lzzs60C7aKvRfCdRddOtNo68XHkHHC74nXHC+3KUknYLcobHWi378S+cG/Wr7GuM6SlhzuyXWAdB3PChXc62E622S75ftTk4K5jtobuHcq88HkRei5KuQm2sL5zm/n9SYGyckjD3skXHcXyHZJvKe1uye3k1SiXnnCB933EMy9KOC0okprIq+XI5DN7VK+OyrkTnulgm6CHOwr5uaikheQzcM1/P49s39ppUoN73rx5cPHFF8Oee+5Jan/11VfDGWecAZMmTYKhQ4fCJZdc4nx9+OGHvTbCAN95552dnw8bNgx+97vfQfv27eHVV19twCNhWjstuSxYYwqlqePSBt5rfG94+JfbwJ1Hbw0tFXpIOTH3WcnN1i8+4YU5KHM27Jy+VH3xNhnIybL6e7ihaenQxnCs5DpOWOTKJDhHrMONvcgG76sdc0g51Sz321NDys0e7rV2YSNtVe9ZhrkV3/wQXjFsSFmGdAFKaC89pLwQ/FmMOpWmj9vDTQ4ptyKfOVXtSlVjN9DfL7cfCu+dt4NTTgqfE/y8mj6ki1PLePbwbk4IrC43m1pCEE9Vhvnq5icV3NUc7nCbpLvZpuZw6+d2duZIv7/AmG3cfOSw0roV+awx3a/BW4kSgZEOiaYV+t99q0L4ceTcUH/BMUMibO58hcbLm65CdiRuf9LzK1nh5kJHHccDuW2gGH07tYVP7P5F261HYmLhHHL1nEvvdRjLOyHSc61jQJd28Nvdt/REzMaget0ydxyPK73qkUar+9mxxM2j72OtUNp530esgWBJMqe7ZALOyRzht8mti9x8lWtZnjtcTxxv0P6wqbDG8SaA2l/hnD2Zn+j9rEegBBqzmeRw5/N5WLduHXTqFB0WmMvl4K677nI86SK0XEdNTQ2sXbtW+Y9hWouHe0yfjjB5QCcv3K6xqI267+g+lcoLTmsXprOIRmNZScLds04YDYPqRLtosbA6onjMY/Rw08W49A2xSnyJoliu8vB7hby6WuXJG9rpQmfrbnDTPr4pefI4FJEqhlZMzXy7mj/CXjUXwOpe2xnGpZXxU0S4qGJoBiglsOgh5U2zY0m9/qqH2+QJx8ZuQpur/v06FMoaOPZz5o+Evx02CUqTojxRST1DynH+bSAKKqK/7Yd3K5rDLR+b1JByLCgWbHfr4ZOL1use2KWdswERXa+bmPKArsvv9x6tFX7T5aKHRNNkHnLAS6AzzEUE13t5g0im265nx/Iiwnn++RPCm8X6E6zXGL/4WHFI+e25uaF2ZSm/rU71XDxzR/YqlLj6Lt+t6NzEPS8N83NK7ogQRvOPVZZA62WtjOiu0N/3dmfn66DEUsX4laXSojaFCu0COdqJFPxfbrZXHjGVCRrcUh3dUjzcOKQcpyBJcTscUj7UWgxXpG6EPtZyr624h791z1t3KJQGqzakBLRWWrTBfeWVV8L69ethv/385H/BBx984Hi1y8rK4LjjjoMHHngARo70w52CXHrppVBZWen917evn3fDMBRasL3t7MLfc9xUuPpnOpXghoFYSnqzgLo8yMGNysufvncRvkdhVWkv+G3m53BK+hexTJCuwkxD1h+eN7on7Q8M88ReJ6xYHuSzZeuIOdzIUDG0wzncJi9tncKi62lwq8uJ5uE2hp5blpOb/bY9zGiQUsrgieulGDSmms4hL139RNPiLAtWl4VvajZ5cDfSOcE53MZygko7w7oj1DoXxrnO6xuaH/4Hate9ogw6lKfIOeHOxmx/g7GEoHq41TBwtd2E/lVw488nON/rjlXMSWxAVLipOEoaAOKwaarAWFQdbsH+k/rB8B4VkSHg+lzvaE940EkQUm53uxMb3U/kVMV2nRFKGVewBkUsrLA7aK9tqJRaYPPjqv3HwjrU5gu7d6jdQ7/cBvad0AcOmdpfGVdpB5ZzPXU1qoPjike+rMWNaSc90ugzQSqaH516NNQ+mUzA5XuPgRVuLrVgYmJh2MOdSDjPo4PSZynGfSrwOZtw7mELlkHhWErzviEt8Ot6W4qHG4umyask2sj7ToTDS+4vPR/2Tb0A15Vc622si/Uqx+xuFQxukcvNqLTYV9477rgDLrzwQrjnnnugWzf1IbvFFlvAu+++C6+99hr84he/gEMPPRQ+/lifg3LWWWfBmjVrvP8WLVrUCEfAbE60ZA93U9FUnqGmAIvimPKLqSrlxMBzcvi082KY2xkeyBfqWOvHJQYoG2p+18XD/cTJ28IjJ2wDM4cZap0jTL3iHG4sfBQEO4CMIcBExXi6Id34Odz4XjSJrKlr0qRSjvuGeq93JaTcEI5vKveEyRGMRnFP5G2KwQ1NwpZ9C16xYtoBqofbYHArIeUWMTpA3x+llJTbSeRPU8kEvOmWhxJtpNfONL9sojRa7R/04dMmlfIsDouP6G+nLXtAeUki4EWOmFuEZx33d878EeT1KcYsZtBSPNfdAiHguk2NdqUpp7xYcYM7OK5+kwRvZCwL1IRWDG6N8SuffdsP766ElP8UChm3YIseFXDFvmMdT73O4MZjbjKu24T3bIgKPY/ySMuQclkbPDjufpP6Kl76vtYK73ts6P5+7zHwcn40/F92tmfc75x4TelObqjJ/Hk7vTHycznrPtdEGTLBIcn/+FOSYedgecJ3OF9c5quPtL5RDPif3NJmoRJ+TMs2uEWY+FFHHeUY23PmzAn9vrS0FIYMGQITJkxwvNdCmO2aa67R9ic84VLVXP7HMBRK3XClif31asdMPXNpNwOwCSNeAOpr0FL3KhSPpKk/iJeXEwWRo++DL1MBZO5aMSrKS2DL3pW1EOOihZSb1qAScmny5ibwi6W+3bc/1USW4apzSDl+KTdAOWPUUHFqv8q6M1wL6iNAeXk3nJN38kMhZ1te/jhNNC2pnRsth5tmmNcF4z4u9kgT9R7MIeVYqZ4Ytm/oj5oGYJq7/Hw1lQ/DZF2RJ7eR9t7Hx6ALKZ80oEoxDHXzFOHz2KiN6k/eD9jDjdsJY1CIcR273aCi53jBrCFw7QHjamFwR4d2CxHSc5GhH/ZwF8Yd6Za7vCzzM+fr2qDX2e0v+NmlM/QF39jdQ/Wxo9ptivAiu428e7Qb+LW6gxEE+Flqvp8L/QkNApOHWx6rE1KunZs6rgwpF7W1w4SfPbslX/G+93KnrQRUtS0Yv9LQF0rnfypVBaflmurgqpmPtT8NHGXhgVLifv6IcmaC4YlFEaXDElDt3sMjEotg3+RzSl/iXMvNXHFefzKouzMt1OC+88474fDDD3e+zp8/n5zrLfK0GSZu/nPyDDht7jA4fzd9ygITTWvycAfz5eI0pE1GXpL4hI/7UnyT6AvTq6+B7Wv+YGz3x+y+8GBuGhyWPiPW8alef5PB3aV9KckIxaJppvBt9WU7QTS4DR74GD3cFlkMDYeUm3O4/b8xjoy+s2jGm8HD/QN0dgQCRf64iXyMOdy1uXduzO7ifH2oxy+h3hRRH48U9TPl8Vi09UnJfw+HWZsMbhqKwasZN2OhsmAR165rRVlRFXBR/1l4rc/fdVRAhE8fCaEatfrccaVsXaC/rQd1hrPmjTCGlEvjfNexvcK52ai/tljQLSSu5rc7attB8MlFO8E9x06NSMewPA0FwY25XWFS9fXw99y8yP7au+H//rj6smVroT3MqLkKJldf75QSq6232Qvttiwo9bzKhQ1c6VF22qHzKM5v0sob+xMaBJStaXE9zeJqyMNtrDlu6XPecaSYU5tcDVHvbK3R3ptVsC6ynJc0pn8+tZDCcFn2wPCY0uC2fA+34IqSm5W7VYzl5XCLTU43P37LxNf6423lNKnBLfKvRei3+E/w9ddfO99/9913Xqj3IYccooSRi3//4Q9/gClTpsDSpUud/0QYuET8jSgf9s033zi53OLfzz33HBx00EFNcITM5o5QrDxh9lDoUB5+WDJmWpPBHXfGQezlmWKYkzouOGGIcndfh/iQPjnzS3guv1Xs4+soQV4z00bIGTsNJ+Yro49Rw3WmvLw3jEo5QTQNG8hFxNB87Eb0cBO9tACw0O7n5I+boIRFi2OIO4f7suwBML76Rni7UhV3woiKDBSUEkDG3GxqO6yiTzO4TaHsVNE0amoE5RG6qsbcr1iLV+471njvCA/yhxfs6ETUUDzcYW9uuN0vZg52vmaJueOUKIJw+oTf34tnzCKXaBM52sLbXbyUmwUroApqQuW+CuNeuNso5cfF+vvO7g7LoUrrWTeJIEpDWtx7f8vu7Hy/MN8HPrf7aA3cbYZ2UUK0dWOO79cRLsocHD0u8uYbDW4rAb/dfZRGOR0388eVpcE0LWGbIYWwfulZ3yOitJo8L7/LFuydCdbnkZ8FXSvawNu/mQsP5aZ60TldXbEzT8kchPChei4HWEu978U9hEPKZyQKZdTmJd8wHEfrpkkNblEne9y4cc5/glNPPdX5/rzzznP+/cMPP3jGt+Dmm2+GbDYLCxYsgJ49e3r/nXTSSV6b5cuXO0a5yOOePXs2vPHGG/Dkk0869bsZhmk+tKKIcnKOPzU3m/qSr7QzRZ3GWDe5Nu0aCtPwbUr8l+hsXm9cDu7ajigkBnXI4TaElFPrKxP5TeZw5+vtJaq4KEb1LpvqcNNyvYGcw40Nc0MnqfJYzwm1DjfN4KZ7acUZXFVkM2Bodz8P1Tb1jKsJmE4eMriN5cOUyAF9f+MHdCk6rnjcqWkABg88mBH1vwWU8P43Fq0rOuae43pDMoWjUqLzxwU0D3dApTyi3dHbRoSKa6hsU0KKwDCFbHduX0Zqh4cICV1qxtXleosyXr4iO23cYh54nNuMkfelmOIH9iAYWf132DH9e+dnOCQcXwsR+v9OfoixP0H3DuXw99xO8OvM0UYP9zBrCZg4eOoAeOiX04uIsPnzqwA131odNuGlV4QiAhBy3bzhlnEbk/jKua7jrc+cPGzvmW0loFO7UlgPbeFjt/TahETBOLdcr7p4RgY3LwZb3yvnDIeUP5zTV4JiCtS//ks9mDlzplIuJ8itt96q/Ft4qovxt7/9LZa5MQzTsLQmDze5Tjv1lCj2kSGknF5HK1aouegNhcmrKkIyJZmc6cJYkUrPunJJgnxbvbiQKZy0Lh5uKv/ObwPPVW8Fndp3Bz9eTG8Um7z5SrtG9HAfM2s4wAuyw/qXB1TDk/VK29SyYIX+6Ga30ZCmopSjI7YzrCeLKJrWpqy0aDtREqiYsbr/xL5wz1uLim5qvH72HBhx3hOkzQ8lN1vTXqSRnDJnGEDx10myh7tGMRqjPesCpza5Zd78qGpbArma4gZ32DNMNJCj5gcAQxIBA1IzP5NivBAnG//bpzTtar9xsP3UKQBvmw3uoBHqCIZ5Q+FoDAtuz+3g/O1qux38sfRG1KPfblSvDvD4h0vh7tws+NbuDneVXhw6BnH3vp8fCHOTb0Uek2w3unclvGwIKccRImNRPe9wQyQkZ8gdz7vjivrlogSdEDj7Veoe+EXqYSdX3kuNQtfiR7tSqevtb6RasNTuBF/me3r551j4TRjZfr63BY/lp8DpcI+iGs+08BxuhmE2D1pTWTC6h7suIeA0A6kxaeq9FOr4WYPBrfRhMPLEi9zh6dPhjMzRkK2K9qAIsNfKJJpGVSmvDWugvXFzWw2EoLWjqpkbPdzUcOJkOUmlnIquFFXdRNPqOwF9f6bHBj4PxpQHfL5MJdqIImzqhpCmzNX0AarSdkR/v99nDHx28byihrQIee7crpS0+ZGzicdA1F1QDG7NvSg8p9j4NennqaJe0Q0n9O9ECikne5AJ7cSm0a3ZnUj9lUBW2054TZ8+dYZjtFLnR904iArtjip7qXq41d/lrJSTg/6xrZZhwwJ2Ij/e6ysQPi9DtrN52/Gsa3GPVXw2yFrWpnbFwJuWMoc7Cjk/sc7kJoQwtgU9rJ/8FaeIupUq+d7yfhDr/YgZw2Cn9O/hmdxWiqp5KIfbUSkvROYII9/orW/FtKJXXoZhmhPU/GIqop6l4JqfxZsPHAfbDu3ivZyZUMskWTQPoqE/7H018eGSsABLfWjqKnlUQ25It2AZmehznGmjV1MXp/jZ/Di4J+fnTRY38hrPwx05fh3ruish4IZcb6XMmMnIIz4C8kkkhBSDwa3cNdo63PQcbmoecu2FwkwDIw+inaOFnpt6xOfVcI5xPXldO+HZoxiNIgKnTqJpJAOZ9vw0nZNiZcEENx08IWA06u9ZSoi6EGA1iab5s04UPOZeM7WdqBHevUOZUVwN/+lqCJfUkpywvb+RGMqDDvQ3pFsFnLD9UKX0mm5cisF9YPpsR2xQKmYXK+WGw6CD7eSVzhjVzC19aTtUw3xhvq92DkA1kNG4f3Vz0Yu1M+WOtyv3x8KCZyF9DtSfjEQog4L4HPZai/QrcX1+sAslCDtba/05iU9ZL/w8AWtc0TTBUGuxdo6tGTa4GYZpmodPzAa3qGe58OKdYPetekNzY0yfjvD4SdvC6+cUamjSIsXNHsQVbijYut7bEA1z/fn+bBmtlIfVmCGz9aDY0hJemNuPmFykRBvAqenj4F+5bWHl4L0M7Wh5yGoYs8nDHW8ONwXFmW/M4a69h9tYT74OBreVNxiXMYaU03O4a/8cM97baExjSoji4TbViUc1zE0ec2SYG6MICB7ugsI7QQk+IVYbbY2TPNwEQ9XpC3u4DdciQ/Bwj+tXBYlU8Xz1VMIKGNzR7YQA67Sh3UjPAOxFDpZyE/W6Xzt7Dmw9tKf6RxHjOqXtIOGU1Isad1h3/zl5Z2774F9Hru+QaJrmeuB2wYiStdUZ+F9+S0dN+zfZghZFMRSPMtXrr5lbqG63NLjzNqyAwudvJBEe5Oh2/rgP5qcXbffueXNhoyGkfFz/znD49AF61XOUw+3Nz/Xiy40UnJctp7cKCte/J6wKeLhl28J9vNzu6Py7u1UQYIsq79ea4bPAMEzTPHwaIOw4KsSsuTCiZwfo6NbSpFDMw71NzTVOWZVMhX6nvTUJ02GKHbbwwswYps+3luf4/vwMOC3zC4BkSb3PMTbeTAaN4pmL08Ntcm4qccxA9HDTUhlMBqma660fN5fABrdfBijIUEPEghaDh5uWwx13tIH/vSkgRgkpp3qujReX5h3OYyNbkxckzgm1Xjdla27lhnStPdzGVBtl3rRSfuZxUUi55rX6/uOnKToOxpB3wrkTpcvU2uTR/e0wpp/6A8O1VVTUUTthvE8d1NlLT1H7S0RqlpjqhP9+79GRomnB++3+t5eEDMNi4n8zkh/47TTPQJx6EDwG/Jys1mwaiOoWquJ8EP84TCHlim4CWPBtHm20RMxPvD+YPNxC9VyUsyvMPfyu4dX1RvPzPNxWBi5I3Qpnpe7wngHy+fyTXTC49089p6zfpGtwl5UUzsWnrtd/IFIzdxszbHAzDNNUtCbRNCrYoClJmkNxRbibKKti8lxTVaBlyHtjh5Q31BKIo19qH9R1TPGqFsZtIIOb6pE2hooDLMoXNip+7LujYTTauqOeYzvpv7Tm23Wrd717Sng/vQ43PSzaG99k9wbmoCOhhIobSrkhb66x5JuiK2AykGm1qVWD0mRc1uH+0YA9pAmT1x8ZOhbRgDf1R/Fci2gaxYCnKsZr+vv7oZMCSvDR/eWCm4WadqG8a+WzKAF3HrM1vHB6IW1G5wnH4M0A5z5C/Q3s0j46isCw7rAIG33N6FIZ1CgZ3F9NNle09FpRTRaLWoe7ML92bt10nQI5FlcLed2Vhv65jDK4hVEdnJ9sd1Lqfjgs9R+Yk3zHO3eW4RhKIeN5zO88ZprS15Gpx/RzbMWwh5thmCaB7e2Ic4K+T8WgKodDV7E6d5DBXWmeQbKB1EJyuGMZi+zhBpqHWzHMrUb3cJvMx/cWrYbd07+FY9Mnw7JRRxn6i+7bPK7ZKBP1q0VEB5RElwoS5IgLj6RS7oimNcw6oubTC0VtbTtiSLmy1ozRC7gOt957h3Pode1C5y6GdUy5FtiDbBb/o3m4qR5zan1ttT89tkXb1MDGl9YIRdEhpv5EKHuxHHN5GVVPeLjdjGFdAirl6tzwslZLqunPHc6nNhncora0aW6CJXYgugmNO6hre6cWd3Buhfm5omSGvZwCCVIOt4wQefHX22tC3b0Jet8tgypDf2aD2+8unMMdRJxjGQoe0gFwQ9DlPVZWWgK3HTEZdnBV2ztb62D/5LOwsOwQeLz0TNg/8bR+Lq0INrgZhmkSyCWrWhH4lKQMHm6qV1WoqUpMgm1Uz2BLIY6lRRamo14LYhXOFE60xcJY9cRoi2LbyNDw21UbnTrST+YnQyJlKndDFE0DGmJGYlwR0WESAqRWA6DlcNPzi2stmkacp8ngppZyE2Gm3vemJG6sUm7wvioh5YZzRxGmi9vDjT3IpkgNC50802bF/lMGet8nDMJ0OUI4vthQooiwBX+nbg6oYGMOX2e1LyuQz6uZnxXcENCfbzVdINyuorwEZo7opd0swc+H9eCXkQreb3uP7+N9bzLgMV/m/XF1qz2YK47Xu7jn7j9+eqS4mhdSXgsPd2lQ1V1pl/DU3cW4YxNfGdvhOZjaCeHYqBzuYLu9xvdWQvUDjRztGd1GgAhPlyHlor/thnWFD/O++vvvS/4CZVYWRiS+gyMTj+jn0opgg5thGKaZgL18xULKo743GdKm/qiGStw01LCNGVLe1g0HLMZiuws8ktsa7s7OBCul93ooYb+G3PGmTu8wbQgpwcRW/b25+M3Z1Cxf1PMUgSbaoMk83GSDG/3OYDSS2yn1uol5AEbxP9pDiha2T2vXo2M7Ugi4qkWgZ6sBXRrMw20uW0ZrR/GYi79WQ8X1IoGUdhSDO+ilDxrSQkBOshHlOAev8Zg+vjAZNiBNnnBKmL3gkdwU9K9wf389ZGJICV4a5nLD7ND0r52vP0ufq/4xmt/b+WHe9/NqLg2MgjcmtVOl70y657xHh/II1fnw/CrKUloPt6jpPXVwZ8d4DwvgifnanrK5PM9nZaKjnsIbF60TNrgZhmkSNjOnauyYQsBVw9xQhgadZNPLO9XgzhjqVjcvrEYzQkWdYO9vDOf4pNnD4JeZE+HX2WOM/SUbyMNtQp21/hrjZZI0pDyoZcEM41qqCBRlfZrW8cwtCqGiohxSHDncdM+11SB1uE0ikKqHW29c4sdDptL32IY7RN5ho3YArZ48VbOAco7H9ulIajdpYFeahzswA8omhMnDreb60jzIJlFMm2LQghDuonnMKYa0WO/FPPAZN5aasvmBleCDBvKWvSsdY6/YJgS+19V2pmOlRWo8nx9rbDdnZPeIc1f40t6du+hjQPUd8HZ+aOCv/Xn/CJWwTc3VMLX6WliHvPnhe86CP2b2iZ5sYH4nphfA07lx4XZufx3alMBaW596I/v72eR+2tBzeY5F1ZcaTXRWW6tG6U9XmzycC986YYObYZgmoam8qs0aHFJuNGhonsYccvmZXvCoIeWb0rlYQ2YbijjU2alRBPg6mdIkyktoL9tKuS3DGnglX1CjVWrx1vGaKDXHs/oQSFvjpTKfO5qX1mRc2sSNkHPmj4Df7j4KHlxgKLFDzJOniqbFL2BnkcrpqF5a/X0pjuOw9OlwRuZoqOmypb4/ZDwrOcShcaEO6uP1O4/C8KIY3AdM6UfycFM1C5R2hv7yRCMPe4ZN7RRRN107O3Dva9qtWFcT8PoSPeYR7Tq3L4sMyY5iQ9o2GtIPuPeoGq5sac+/cu40a+GcnUcYNz+E51eihlLrz0lUf7O2UIUbgyHXwWu72O4GP0DnUJg3vrbis2ODLt870N9D+elwVOZ0GFH990iDW1REeTo/wfvx2/khkf1171BuzOGWbNG7iKhqkc3pUE32Vgob3AzDNAmbW95wY+Zw43bm3GzauNRLkSXG7NqbRQ430WhMEMOdiV5aLy+uCH/JzYdfZ46G7dN/qPc1wdOxDYYFNtqp69NkIONngMm4xHsFpmvbtjQFB08dAD0rA56kYH/EMOba5mbHjWlTg6qBIdbuc/lxcE+uoDCtI6GIppleDevgua6nh/uYGYPAxsrYGvB9ZRZNU2dAegYY7ks1xFozZi1Ca3FIue7c2QTxMlnLGpfeMuXdq7XTw+0q25TAoK7tFHE6HU8tXGW8xvLc4mPIB8bEz0x1s8Lvb0Dngid3Qv8qOGKbgaoIW2DcW4+Y5H2/CRm3ps0PtfRawotk2n8iLsepjqP7vAiFZgdyx7Wee01/m6AcfpM5LPJ3z+W3gpPSx8P8mkvCpclQ7niNJocbn5NUqojBXKSahl4MrnXBBjfDME0CVVG4NaE4j6D+ua8T+1eRQmzzRIu7de2R0PI8sYfbZJhnieH4iofbgHgRvDs3CxbZ+jJZZLCBbAopJ3u4aSHlabQjZDS40ciNVU6wNiHlcZYFw5gOlVrEQN04MoyFy4wZz7FFVNvHf2LYdLGLH8iOo3qQzrHq9Sd6uInh/ZYhpFw1lAzHSvSEK6/mmnbCGFUNeE3ouU3LaxZ/rRrS0f31rCwnebhVj3RCew2w9zN4v9m6TQ3U7q+HToTDpg2AG38+wfksVPoLHOvwHh3g7J2HO98rodRGdfRosbZg+tCLORw9Et1fyJuMxfEMofq4gsA+E3whOUHKEN3y7/w28JE9ICJs3DLUGg9fi7b5jUo4+zq7Ta0Mbmo9+80dNrgZhmkSqEZea4JaN9siGj5V7UrhvfN3gBfOMHu3yOrOLWSTJA6jjOqlxafftPlB3WASYjQNAbUsWNLwArfHVr0j/ybcH5DKffXsUO7U/xVleGQt2mJzbzyDW9wXDTMW9X4zebFNmzsY6vlSDW5DKLti95gM7uJGY9iQ0kMx8pQNS6NoGv4XLbzfpASPDSWdIS36UnK4iaJp2hxuOxACbnj2mMK2JSIvuZiHW/DyFytJ10LNuQa9wW3IzRYedQkeE7cb0q0CLthtFHStKAsda7Rn3SKHqDvzU0TT8Ea32o7iMTd5uMUz4eV8wWjPhjahLO3nvSKyqSFUR1spC2bO4RasKO2jhLOvtttr+7spO7/ofForbHAzDNMkcEh5MYgexCIJy+KlxZQf61wLoo1H3SNpars8DjMpQd38UAzz+m8wrU0a6qw2kJGnbOAYPHlDurWn1YjGXlCjl9aCh3+5DfzrF9OKiEihv4nh4lI8146IFNEz84nd3/n6aclIiJNiKuXv5gc7368csIuhnf+90W+NBdBMOdzkUHH1r3RQjLdwf5q5KZEaVJXy+udwr6nBvzNEuWDjzWRwK+dfY3CHVMqj2y36aaNq6GlCI34xc3AgNL5+myTFvPny1OKQ7aC42s5b9nBKg/1+79Ewqncn9Mf6cVWRM4PBrRi1tQspx/344/rnWPcsC6513E4InH5u94Gday6BrWuuVzf7DBFtYpukGNXB3HB0HFglHoOvxfLy/nBA+hzYvuZKtz+9AX97dgdnw+CrfA/cGzBscDMM00SwaFoRD43JeMO5tDFYIPSQ8pbxwUn1/hn7QN8ba0kTNz+wYryJj0rGwB8y+8Cx6VOgscDzNnm4qecEn4ZiG0Li90WvF1p3cVxbksGdsOCR/NbO9z/aHYxtT8wsgIdyU+EfFUfFHFJuPsd7py+AcdU3QnXFgDr1ofaXIhmh+NwpXvEAFG9pbTzcpLx7PDeThzvQc31zuFVDyqKFbBujCCgebhFSXjwq4f63l5BUyns4oeK0/ANK5Ac2aCM9ze7JNamPp5IJ+MN+Y2H/Sf1g5vDu2nZ6L3KUwV07Abti/fnt9BsHmE/zKPcbjSs/Hz62BzjK5kq6ANokEfWuMQ/npjpf30Dlx4JsCuZpo/mtBZ2aOd40tRyRzq/sXhqPuT/XJdAVptZcC/PSl9Fqkbci2MPNMEyTcPqOw53a0MfPLHhpmEDOoOGEKCG2cRjc5JDy+qswNwZbD+pc7z6oobhqCSzTSyrtnFgJC67N7QVP5n2Bn0at/WwyuKmGNNHrTyXu1WQKX8fck5sJR6dPhZ1D9XNVFtnd4cTMCfBZ6YhYI0VM506sNeFF/Ak6xBOpoZT40k9wbVmP2nu461mHm2xwK89PoueaKq5mMOCpnmFV5MwU0YGMQVwfXWmjesxNQneKOrahLJgqiBc9v8Fd2xFDyosY3FbYUDWtBXwejCHgiuEbnue2rsFKOYapgzprPfBTBqqfMYownaHvFXZl5LUY17ej0k4XvTB3ZHf4yyETvX9/D11gdPVfYf/0edoxwx5pv791mvJheA0GP9dMHm7BCqhSQtXHJz7Xzq01wdJxDMM0CVv0qICPL9rJWEe6taGG4pq8qhCrh5sa3h+3YR43L5+5PXz6w1rYfni3RisLhjFdCuo5jsODW9trgscsMXgj8Po05RdTNyGaSu+hojwl3DQELHgq77/cFiOuaYp64j+srobRvSv1M1PCYfR9kR+vSf8F2crr10Am1R62qbnGMTBeMXRHVSlvKEElk0d6fU3G/wfxvqCqlOu6E11RDXNAmx9aYbpgDrdmEew5rjekPySolIcM3uj+Jg/sDLl3axdSHu1pLu7hVicYrVIeBBu+UYb54K7tyR7uPx80Hj77PY788PvbeXQPQ+i5365NSRI2ZfxNzA24Fjca97oDx8PWl/43+vxhcTXLcp4PmHVaL3XxHG6dhztvEL5US6oVWctu2HpbY4vWAb/pMgzTZLCxXTcPNzW0l4rYNRd0aR8toIJD/JozvTu2gdkjusdutJJLWxlLtBENbmgozONfmdnX+fr3TqcQPdz6voi2IJm4928oQkMNKoZW5Da65bBJ8PhJ2xrvt9qUBUP/0rdL0Qxu0d1iuysshyrjtaWGJ+eIK4QkmobXp8Ej/dWPG2Kuw40NaUNaCcFALlBczVxEEWUI7fab2JekUl6oO0/bEKBEG6iK5+FzbNWyRrPq4dbPraJdm6LnpG2piOMpfqxCdFQRTTNsiKuh5/r5KbW20UNUhPRjlJDywPxq+5lfrSkLVpiPOi4aRTuezmP+wPHTInvaqKsv3spo3m9PDMMwrRRzjizyNMbg4RbCNLcdMRmePHmGsd2Fu41yjNrf7j4qFgPpiOkDna+7ji3khjUncMg0OZ8+BoO7oVS4zZsQNlyX2xPGV98I/6ucX2+18LiPIe6ICVPYfGPMs9j5EdeKkvsex1iSJPKq2uUGzzqpN3pLo1dTaUcZ0aKJpilzo4kJmgxuivEWVCk3kce7WTqD2/FwI++r5jqP69eRlMMtDlbdJNEdBy0NAHtoo66FnC82LPMGsb5iXlTJvDH6+ti6+ZlyuLNI2yA4hzJUypBSi71Hh/JATWxq5IfaYW0/8kMebqyqr639jb3qRepqu23H9YsW/KSWV9zc4ZByhmGYZojpPRkb2VRPV7GX96AYSxQDu7RzwrbjMjzOnDcc5ozoBuPdeuHNCWoUQfcKnYegbmXBGqrqldEb6U5tFXQwRp3g3Hxzyaq6zVE/brx8kWwY3QjqPOPYkKCWXqPW4RZzOj59InSy1sGJHU0ibLT5UUuqxVoWjDg3vMTJ9bqJomkm40IJnyaKplkGg5saop4m5XAH0wCij8MiXjOlBFrEZoVcl2qpNFPtQtwuT2qnMyZ/vnV/ePbFb9FPaDnhZC0CwzlW1MwNYUImD3dtI7iK5VwXT6ew9OeE2B/DBjfDMEyzgezJU0J7W+7ucWkqAdOGdIHmiPqyradf57Zww0HjoVO70ljykBvK4DYKuuVpXvo6ifXFcDxx13//KDUKDkufDt/YPeC5ODum1lqP4Z6Nuw632MR7zFVlPwnqX/KN6tWiq5QXh661gBoa69MrvROPgdjOKJpW3BMuImso44phKGrmYj3llVJZNO+wvk2C6OFOkaII8DmxTIsBi8xpzvHpO24B/33xRTwbmtAdtbwdGldo1by7aLX7Y0sxuE2bLo7KuxXPh4LqVQ+vgdPSx8G05Icw3FoEoxLfhjY/go8rZQMnor8g7OEuwNsSDMMwzQS84d3GoKTcUGHH8dEyyofRRdPM53ve6J4wpYgyet9ONNmYhrq2JhsPXy2TCB8Onzf218wvv7iez+XHwTd2z1j7pYqmJWO4xNR1QtWFqEvd+Thesul1uAleOeKY1Drc1Px3VYBL365jO/wMIJYFM6B4hzXeUnFOTN5S1cONfxA9B3F4an528XNiOsfY4DameqDjI3u4NddCRPFQNz/UqAS1Hf6nuvnhf3/9QeOVv0nja2YYV9mIMAlmEDCJpgn+lZ8Bp2WOV+5ZcYa87wPzVNZTRH9MNBxSzjAM00woSyWd/OiabB66tNcLjTR3p3bMotJNgvKqHcP5PnKbgbByfRrmjKy/gnpdML3cYUPapAmAL2sc2gFU4jbgG2rm1HJ4sYeUFwkVpxD39aSW+8L1mhvPw03rWbW3ad5N431G8L4Wflfc0yxmTfVwK7nj2lBxYcbSNhgomyR7ju8L8LFewE4+c7BhiY288ARpdeLzCZp4mbpJkqQZvob+enVsB7BeNvTPndA88WaTCIjEGUvImTcObjl8Eny5fD3c99Zi+HTputDvT9h+CFz7zBfO99VB0TLNGsBnVfFwB6ZZ25DyzeB1IBZ4W4JhGKYZcfDUAXDUtoOMbUb2NNfebWqoas3NGfziHIeBVF6ShPN2HQnTBndpkrJgRieJTfNw49DuxoyyaOq67lTyRPHzOK5xXerEG0sNar43tjOGRdNYDmr94fpAPavkOtzC+5fb1vl+4dCjSZsGJk+8KtSlnx82AHWn2MnhxuMayn2p9b9NYmjFc8KFwCZF/G3nLXsaPdLyUYLHTNh6gxsfnyn0HNC5M0Ub4PB5UztdHW7BUdsUPqd3GNk94IW2tOtO9VwntWULi5VVm7VFN+N7wmk7bAFfX7ozvH72bHIZLzGqN1d0joP3+QBrqfqH6Di6dwg7Cpbb8d3jLRk2uBmGYVoYnduXwf/O3B7eO28HaI7EXTe5KaCG4sY+bgP1axI5w5fL7AmnGXxJFDNdUs9wyOC4cdBQewXUacZRXY/uuYZ4seJVH78xuys8kZsEJ6R/WW+POfW6Eh3c8NZ3P8FpmeNgTPXNsLLzhPrnZiueVINWAjJg9OkHIoe7eHiyWCdK6TWDwU2pnS6UqHOoVJYOfNsnIk6yKEG5/fBu9HJ9imiaKfGelnOtCwGvTQ73yXOGwn3HTYU/HTBO3azQPPOCBrepRBslDcD5lVG80oKK8hKoUUqW6ftbYvubwZ2rfVE5vAc7f3TPsO4C6u+xE7eF8pLCv3+ePgtezY+Ak7InaOfYmmCDm2EYpgXSq2MbqGwb+CBtJmwGDu4my5O3m+B4sAeZmpttCkHuUF4Cv5g5GI7bbrBTy7alr6c9x/WOVdwtjvBtpXJUzN70ODzw1Eu2AdrAcZlT4OH8tCL9UeZk1b7kn2Gm66tFPXIL1kJ7ozF/wBSs6m64z7BH01TnGrm/UxqLW2xCKbnU9fRch0LKjXnNtVO51omm/f2wScrPTB7uNOrCdM2o9brVkHKiwR04J0JgcuKATk70krqZorbrWlHw+u44qodq/Bry6dUc+LqbakILpndJIORcc23PzRwR+fPylH9sI3pWwHP5rQL9JRRngPC+C17Kj4afpX8DX+Xj1cpoqbDBzTAMw8TKZhFS3kTjUo22O46eAn07tYHbj5hc7wNSPdymdjTDXPDrnYY7Zd+aY0h5be3J2SO6xbrumyyk3NDOjjl6hSqGRiVWDzfRxd2niiZ0iA1pk/FG9fpnlY0tYlkwbQ530JCmGXnUnPU4NyxNHu6/vvgV+pchDUDZ1NCPNXtkT1K7jKEOt4Khdvp/Tp4Bdxw1BfYY14tUZqxtaYrkCS8ydY/8gBmEVgBLIVr4c6ZrQMt1F67Drc5i/hg2sKNgg5thGIaJlZ3c/L0RzTzX3ERTCcFTjTaRC/7iGdvDDEL99KJlwdCYJqVn6alx2jVmDncT7d+cNncYzNqiq+OZinOew3tUxCyapr8WdXGmWzGsT0qeb9zUJYfbZLzNHdmdOHCi1u3MJaHQxlZ5pXYTSgkpN4odUkLKhd/Yiu3a1mXdmTzc3fCzx5DDjUXTTP1NH9qdVGYsj/PuTdELBqE7EeUjyl86oeK2vsb6WfOGw9aDOsH+k/pCFoft11MFPJ3whdvqwjZDuzgbvK+eNdu5W7DwW9Tmiwg7v426EdyKYJVyhmEYJlYu2n0UTB5YBXNGEF9YmyGNaVDWRXirthhfgIkebqGcf+fRW0NbQ8m6hiDuOtxUTpg9tFbtixmj/14wHV7+8kc4cHK/WNdniaHOGLncl9J3/fPpQ16wehKVB1z32uTobwzXDJ9X432peFVp6uPGudoAp2eOge7wE5zQPTpKRExbNXxpAmHmsmDx1U6P28N9tBAIu5eSw43OieHaWoq4gb7dJmGzu0vZfEgUJXhzTfRjtxvs/PeXF75SQ8obsSLEf3PjYHbyHVhT1gvwVo8U+xTPOEVBPWLNiLU9aUBVo8y3JcEGN8MwDBMr7cpSsP+k+hsVTUlz93DXFtML8KhefiRCscOeOthcb7xllAVrmItbbJpj+3Z0/otbBK80ZRJVgibZ/AiVDmoMg5vaF9UwR4YO9jqHB8YGiCGknNhOcG9upvP1JEMJJzUEXN8fJaRcGEkUQ5rq4a7LujNdY5GL7PVtDCkvIRnwNrHMGBaIM14zwmbK4tWbII1yuC1NObJs3iaFnjvzI+yA1ebxeULmBNg3/zz0nbQvHBXVVyCkXBep0VQaKM0ZDilnGIZhmDp6BuOmoZy5phegbh3Km9yzb6KlKAI0piMeX89SgxS5msNNu7amdtQNIaXecKN5uGvfr8nYMpXIUzsprhZe+CVRzZxw34qNjzgN7sK4tONtqBxu6po0RSUkUsiQNoSUq55wfTNVmM5wTEoef3S76nROjfzQXIt0Nk/KzxdkCCFRYq3kTXXoEBuhHG7L7QgbyqLTaJyQcmxwa+YWhzDk5gYb3AzDMAwToKleFxrKw92SX4DiPicNVhasES1ufAwlRIM7Dqgh5XF7uM/JHAFZOwG/z/xM24a6oYDvBZORSb5nkGCW0WjFXtB6poJUZ3JqeS6qWJtRDI02qw22v0HXWOtOPQ/6RViqGNzE0HNDfxSFd6edVbzdhP5VgTrc0e0GdGlLLgtG8XCLJtVQu2oR2stnq9533eaLqQxla4UNboZhGIbZzEPKTXm+mOb4nhT3KWkou7gxy8/jcOcSQ0g5tsV1JaZCGJpRXvAbIof7HXsoDK+5FW7I7VbvtUs1BlPUGvJEJWscfmtUM8cihpq5VrYpCZTn0h9T307tIE5l+T9k94Uv8r3goszB2jbUvYrf7j6K1A6fB6G7riOVTJLaYTVzU5RDsXxl1CHqL6EVnUyjyA/dGth1TK9AObL6Gdy2IQ0AC2FidEc6rEeFek50IeUteIO3oWCDm2EYhmEaKc+3qYy2qralzfq4TcR9SjK5hlGma8x3TDyUKaQcGypkgzsGL37cBrdAMULqAdlxTWxnUqhW29FEzijMHdkjoFKuXwOpEprIITWkfDlUwZz0lfD33DxtG2pqyr4T+9Ze6M7wRMC3gimk3FIMUENpuM7t0R/RDG5dSLk4J4kSFB2gaSeMVWooO+V2FPesrna6KCs5eUAnuPe4qYHKB9F9CQVyZdOAzUgybHAzDMMwTDPx9MZtXF61/1gY3bsSLtpjS1L75uiYmLlFofRZG6Lh0GQGdyOePOzZMommUT22eL0XEdAm8b3d+OJ69DrcVu3bmTTTiLWfyWrmBES4+4jeWAnalBNOWx/UkHIK1FvBtFmk9XAbyoLh82DycON71WTA47JgJpOJupmyx6TBqJm+vyzWQKhnWTDTZpUo3XnPcVNh0oBOpMgPcR2UHO7mGBLVTGGVcoZhGIZpJsSdB7znuD7Of1Sa4/vT+H5V8OiJ20DvjvWrJ4tVgBuCxsxbxMfQzlCmLY/aUXOSTa2oIeX/zY+HP2d3gw/zA+DP0DjQy4LhHO4YwIJZBqNMmZ8xpJw2rGLkmbygRIONGlIeZ9g+PQ0A/Q2xP5NhrpZit2M9x6Z1mEuW0trhjQNi+oG+jdBUoNROF2PaReemiqYlNmv9kDhhg5thGIZhDC+McXlWmzKHm0pzVCkXjOqFq8K2PCX4uBnQuS3M2qIrVLUrhZTBS4gN8zKiJ9wEfa/CgsuzeoGzhqBuQmT1v2aKQWQSJYsxpDxkSBtVz2ljUdvFa3DXvp0xNxuoBjdt3BUbsqTzYxNFzvKJMqKyPHFNEe5Hp3a2ENgrdsjo909/sgwWzBoS2UwpC0ZYM901eeKtDTa4GYZhGCaACNP93Z5bwqZ0Timb1dAQqrw0KM3T3I4Xu4EKjTXmXoUwGG45fHKtwufrEr7b0BEYwviNK+CAHlIe75rJJ9CrtOH84PNqCsWlng6cw20MO6Z6uImlo5riXqB6pOtkmBvO+MpNOZCls433BVaqN3mukcFt8lxTS75RnmXidFFqp+ONqHe+W61tRxFNU+fICNjgZhiGYZgIDprSv9HPS1N7uFuDxd1QmxrNMTqgQ3lJrDnmca/PdqUpWFfjexHrQ13qjMfh1cWCZQmDkYdDz03GFn1gbHCbDKrGz+GO+1ZQ68kbDG78NwYPt+qB1/eXs6lRBPgcGzzXSf9+hFxG345qcFM93ASDm3r/ZFB+OWXNNPVHWnOBRdMYhmEYppnQ1C8nzVGlnKk7A7q0gwt2HQnXHTiO/DemFRB7+nuMy03YQ7dkd3S+fyI5U9uue2XMESu4LJgBnA8ch6GvhKgrdaUD7YhjxSuaFu9zhLpXpORwmzzcxJxwtSwYreSbyTDPYg93SRnp2pqeyZTb8bWvV5Hy86nnuLY53EwB9nAzDMMwTDOhqT3crG+z+XHY9IHNdn3O27IH3PPmYhjclVYruhi/yx4Ej+cmw8qOY2AnTZsZQ7v4/yAaGX2q2mp/p5TkMiloUwW4iKc4rxh59Q8pj9N4itvgxkYn2ZCmergNJ1wN2yeWfDOGnpfCiekFUG6l4XdtO9OuRQwCe0qIuoaCFoS+lFpUDrcp2qChU3haGmxwMwzDMEwzoXP7Uvh8edONP6x7RdMN3sLZXGIDjGXBYn53Pn/XUTCuXxXMHtGt3n2ls3mn/NHr9ggYnCqNJfT//46aAp8uXQfTBhvKnCneSFN+Mc0LSsXGnnWDh5tauqkpyoLFnp+vGOamWm74W5PBTauxTt1MEb96KD/d+f6SODZTiMYsxeAuQRoP7cv05uGcLXsDfFH4PmGodb7jqO7w5EfL4KhtBpHmuLnDBjfDMAzDNBOu2GcsnH7fe3DsDFSvtRH494Lp8Na3P8FuY3vB5k7cwl+bG6YQ1thzuMtScMDkfrH0lcYCcSlaZYFiod3Th3Rx/jOCjV3T+SGqlFM9gtQw5qbJ4ab3lbMtSFo2PYfbeI7RtwZjkJzDTVQLV8XDDAY3Obw/EW80BGEN4CoGl+41Wttu6tAensFt2qy47sDxsHDpOhjVqwNtkps5HHzPMAzDMM2Evp3awl3HTIVZw+vv8asNY/t2hCO2GRiLsFZzh83tujOmT8datW9MHbm+KOw71ZjrmOjhphplVJQ8X0MeedPU4aa3pXhfcdS+KaQcqGXBlO+pBjc1h7v+1QCUa4sPPtiOYHHvPLoHaTNlv4l9ve+Hdm+vbWchVX7TuRMe8y17VzZLMcmmgA1uhmEYhmGYerK5vFeajuOQqf3h/F1Hwn9OmQHNsZQf1Uv8u8yBzte7e59d73ETikFkCCnHZdliUClX84b1/S1sO8H5utzu2OzqcIfypCmh4qayYMr3TZPDbVKgp54Wag43BVEOkGJwL5g1GCrKUzCxfxUM61ZB3GBq4jqWLQgOKWcYhmEYptXQUBHlyRYcHUA1BITX6vAYRdiaqvTbX3K7wO25HWC3ivrnl6qK18SQ8jh2Z3AfhhzuNaXdYEL1DbAe2sDCRlQpp4SKkz3cxHOs1OE2ebiVQ9X3N2lQV4DF/sj6Dmufn29qlSOnHxDGsYRZTBNN++CCgsq/iUSSGN7PKLCHm2EYhmGYVkPcqrkX77EldGlfBr/fewy0VBrqvbmptiAomx81UBrLSqB6S+NWKcceactgcItWK6HSOd7Gulbi8CiGtIBiDCqGtEmlHH9PNLhNx92uvDRWlXIq2MNtCimnrJUh3dqr9cQbqSY6o8IeboZhGIZhWg1xG5c/37o/HDSlH+cqRtBU+ZvUaIM41gLZw40MpzjCtxOKQphZGZvWX3zhwUILomA0Fi8zRTHM1XJfJg83EA1z2iYJzqU25cKTRdOwsWqqBiDGtSllwYov4KO2HQivPxOfwb10TbX3PYeU02EPN8MwDMMwrYaG8Mm0dGEgxVBp2YdSK9G0+GsEU8uCJRotpJx6OTdBWf3nJKdTCw/3/bltna+fJYYY+qN5uLN5uw4eblNUAvZLUj3chhxu/Uh1MuApq7cslYxVEG/Z2hrvew4pp8MeboZhGIZhWg2cdhgmk/Nf3UsMIaybU0i5Qwz2NrlkFVJ3Nvm7yGXrlE0Sk1AX7VzcmN0FJic+hQdz0+FiqP85oeaEX57dH97KD4UfOk+BB7T90Qzk/33xI8wiGNxUUTdFLTzuHG5DO6o6OnX9Ujc/KJSX0EQCGRU2uBmGYRiGYVoxNVnfOImzNFxTecvJIeWNeIyqhzuOcXF/9fdwr4X2sE/6Auf7i2M4J1SDW+SWP5bfGgZDO31/xL6onnCqhzuPIgdsUw430UCOW6WcUhYsboNbCCdKOKScDoeUMwzDMAzTimCvTJAMMrg3B+g53HbMHm7DeUSGUzwpCNhqNLzON8Gmhzgntc1TN+rNWfTrvjDfx/n+g6o5hvmhcY3h/UShOyUqJAbRtARt3L3GF451Qv8qc38xLgKq4Byjwh5uhmEYhmFaDRxSHiaTaxiDu7ykeI3lps3hrj/qUIYek9iIStZ7TtUJ3yNsJVP19g7HiVMWrJY+PdNxU6MuOrUrhf3S58GExGcwsveeoK8Wb8Hlmf3hgOQz8MWIBdCPZPiaNjVSpM0Ucg430cN9zvwRMHVwZ5g+pIuxv6fyE2CH5Fuwym4PnaCRNpgYBTa4GYZhGIZhWjFxG9x/OWQiXPjwR3DNz8bB5q5SnlK8m3ajebjXlnaDczOHwwa7HK6MIYw5TspSCdhUS4M7ayieTk7JtwHWQHt4Jj8ehhtMHNHfn3O7O//d0Ka7vj/lGEyiabTwfip5xbOeMG5o7Ty6Z9H+7svNgB/tSvggPwjerOfcqPn0jAob3AzDMAzDtBr4FbHhmTuyu/NfU0E1aONYC6kkrS6xhQW4YqjDLbr4Z26u8/2V0LwQhuCGWhrcqzdk6u2lz6GTZ8exPoih3dgoVhTL6ziuusMQT13vZ/PxbH6px8BPUyqcw80wDMMwTKshjrzdzY09x/eBId3aw9HbDoTNAbpH1I5VRMpkLVvU8OQ6YMVwLirKU7FGGFBF0ySZGDzcWETMKBhPLINnI2V51dsdbIc2U3DqQF0F9og11psCpRodG9xk2OBmGIZhGIZpxbQvS8HTp24H58wfCZsD1LJPdszh62YPt//KnYjB4KYaoVTvMHXv4aAphYznY2YMMrarbQ43KqEd6VX9Q2Yf5/urk4dq283b0g+vxvsgdT4nRNE0bE4ZPdykUYNlxhIt8t5iVDiknGEYhmGYVgP7tzd/yEZB3HW4yaJp9R83bjE0aompi3bfEg6Y3A9G9OwQqzJ23mBxi1N8bW5PuDs3C1KVPeFkTbuBXdpFRx5E9EeaE45KMOVw4zx+5W8C7WjDqiXImpmBG2PVwFZF89o2YRiGYRiGaUA4orwVQLa34ygLhjsk5nArQmt1mxNuZ7LJDEMp5Ewu5oBHf8velUWF6fJ27SwznH8dvalhwXKoIiuW0w1uU242Mp6N1wyrlCfrfY7VkPLmZaqxh7tuNK+ryDAMwzAM04BwDvfmy4DObZ2vu43t1WibL+S8XGSwJWKYE25nFuNqPMV2zEv50c7X9dC23uNTc66ppeHIKQcGb7XaIQ4p119dor0dKHadiCVlhGla+AowDMMwDNNqOHPeCDj7gQ/g0Kn9m3oqTMw8cuK28NWK9TC6d2UjGtzEkHIkwCUkxZpbaoTJw1wXLs7+HL6ye8IT+UnwUoz9Uo3lOELKcQ63ZTo/2Cg21EQnb/YpRnb9Y7jjjAKPo6Rda4QNboZhGIZhWg0HTukHM7foCj0ry5t6KkzMCE/emD4dY89bNqGYH3ae5OE2mSwje5lzo2sdnky0j6j9UdkI5fDX3PxY+sJz61BeQvqbElSuzZh3b9RCwx5uk8GNzSmr3utNresdQzByjDYym9t1gw1uhmEYhmFaFb06tmnqKTCbCarHlVgWzNDuZ5P6QXUmD1MGdjKO+8A7SzYrA8mUmo3PcYc2NNMlaci5pp4TGxnSJg83NfScuqeheJFjUbRvKatg84UNboZhGIZhGKbVEYdPV7GNqGXBDP0JMbIjt9k86qHHFapc1a7U+75TuzJSfymDh5saFq2ojxuubQ6ZUynL0I5ocSs1v5uZsdzMptNiYNE0hmEYhmEYptURh4Ae9h6u7j7V0NAPhU7YOWgsYo4UbzCodpxJDA2TNFiG6iaJsRf0vf5EppHBnTAY3NT1FreHO06hSLa36wZ7uBmGYRiGYRimjkyr/hOMT3wO+wzcG7bQtCkr8z2ziVx1I57rprW4u3egeaSLlRmrbXi0qT9yiDUx7z5j++1SuN56gBxVKy9ugxvig0XT6gYb3AzDMAzDMEyrIw7HnzDevocu8H2+C+xjyOVtW4oUr3M10Frqzps8zXUxuKke7kFd22l/ZxENSPU3hlBxG+Cf2dnQxVoL23cbUX+RPsXgjsGnHOMa4JDyusEGN8MwDMMwDNPqiEWlXLGNDF5VZCjG4eE+bNoAuPV/3zTKMTakR1Qoy6+vycKE/lWk/vB5jOL+46fBolUbjWr12MNtqB6mGpe2OTf73OyRzvdfGTokh5THnPEbq4c7xr5aE2xwMwzDMAzDMM0eYZw1N0OEGp6M7cRsF70XlEqH8lSL8HAXOz0PLpgOd73+HRy73WBSfyYDWTC+X5XzH3VOputnIfPSdBjZfJ60IdCeeM1iKQXWQJsuE/qb1fOZaNjgZhiGYRiGYZo9VCOzMaEKcAnjbXbNFTDE+h4u6js13oENUE2t3bfqBf9+93uYP7onxEmxDYkh3drDubuMJPeXMpT7ooKnZAplx4a0MaScmJt98NYD4JUvV8IOo3oY2+WbscFNrRPPqLBKOcMwDMMwDNNsuXzvMdCpXSn8+ecTmiS/2AQxpdhp96XdG57MT4olD5ZcS5poa1221xi4+eAJcMW+YyBOqOenGIO6FHKydx3bM9Ywd9Ma+Mer3xJDymkWd5vSJNxy+GQ4YHI/cv3vOGjqKAeGPdwMwzAMwzBMM2a/SX1h34l9YldILpYPTIE6J9wOhyrXfVxau0yObgwW87zWBbIieBEePXFbWLq2Gga6hnf95kS7fqs3ZgDKZTuov/o4lRi8+Bi2t5se9nAzDMMwDMMwzZqGKEcUh4dbVbym5g3Xe1iy0d7UxlZcl01sCMRhbAfPHVUdPdumKzQWP5bEG9bf5IuAaVqD+4UXXoBdd90VevXq5TxIH3zwQWP7+++/H+bOnQtdu3aFDh06wNSpU+HJJ59U2lx66aUwadIkqKiogG7dusEee+wBCxcubOAjYRiGYRiGYVoSVGMrbg9uHJsH1C5O32EL6FVZDufOr79QW1N6uOMEX/ZiImzHpk+B67K7w7p+c6Gx+LGkFxyePh32qLkolv6aWqmeaWKDe8OGDTB27Fi4/vrryQa6MLgfe+wxeOutt2DWrFmOwf7OO+94bZ5//nlYsGABvPrqq/DUU09BJpOBHXbYwRmLYRiGYRiGYeILKa/938Tj4abRr3Nb+N9Zs+GobQdBYyLrZU8a2AxVrYkq5QKRc39ldn9Imsp9xexCFqfu2fw4eNceEkt/bG43PU0q9zhv3jznPypXX3218u9LLrkE/v3vf8PDDz8M48aNc372xBNPKG1uvfVWx9MtDPQZM2bENHOGYRiGYRimJZOMwfDFBhs1zDsOD/dW/fR1ppsD/zllBjz+4VI4dNoAaG6odbitRouGaKqoAGr9byr3ZLeD/VLPw3/b7wqzY+1586X51VeoBfl8HtatWwedOul3z9asWeN8NbVhGIZhGIZhWhdxeLjrQhz21LZDu8JNB0+Aod3aQ3NkUNf2sGBWPB7auLHqYNw2rsEdb39xe7jPzR4B/8rNgHZ9p7LB3RoM7iuvvBLWr18P++23n9YgP/nkk2H69Omw5ZZbavupqalx/pOsXbu2QebLMAzDMAzDNA9iKQuGrCNqd3F5MHdsAFXx1oASlUC8FCaDOw7VeaW/2D3csXYHaSiB1+wRMMMqibfjzZgWq1J+xx13wIUXXgj33HOPEzIehcjl/vDDD+Guu+4y9iWE1iorK73/+vbt20CzZhiGYRiGYZoD5SXJevdRF9OoiRzrTKRivP5i/HaPLWPdnGmq9TF1UGfna5+qNvF2zGzeBrcwoI866ijH2J4zZ05km1/+8pfwyCOPwLPPPgt9+vQx9nfWWWc5oefyv0WLFjXQzBmGYRiGYZim5Oydh8Pgru3gxNlDm0alPGaPKFP382+6fKN6dfC+T8aR8N9EOdx/OmAcnLj9ELjrmK2bdW745kyLCym/88474YgjjnCM7vnz50de/BNOOAEeeOABeO6552DgwIFF+ywrK3P+YxiGYRiGYTZvjpkx2PkvDrBtRDWTmmGlrFaFlaAZt4q4WqN6uOMdq2tFGZy6wxax9sm0IINb5F9/8cUX3r+//vprePfddx2Bs379+jme5yVLlsDtt9/uhZEfeuihcM0118CUKVNg6dKlzs/btGnjhILLMHLRTqiXi1rcso34vWjHMAzDMAzDMHFAtY1wMza4m5NoGrVet9VoZcFayvpgB3cLCSl/8803nXJesqTXqaee6nx/3nnnOf/+4Ycf4LvvvvPa33zzzZDNZh2jumfPnt5/J510ktfmhhtucMLCZ86cqbS5++67m+AIGYZhGIZhmM2VuoSHx+3BZOpz/pujSnnLWB9xbzRszjSph1sYxab4f1FDGyNCxIvB+QQMwzAMwzBMY1AXO6ylGFSbK0oagOFS5O3NoywY0/S0SNE0hmEYhmEYhmlqsPFM9fexPdWMyoIRnXiNaXC3FDiknA4b3AzDMAzDMAxTB7CHlGqAsIO7+WCKNsCXszFF03Icqb3ZwQY3wzAMwzAMw9QBS/Fw27X+G6ZpMV0Kqoc77jJvuXweWgLs4abDBjfDMAzDMAzDNJKHm2laUsh47ti2VNsOX8/GDCnPthAXd54X/OZbh5thGIZhGIZhmgNKrWbO820RpJIJeOD4aZDN21DZpoQkmma6tHGrdbcUQ5bF/+iwwc0wDMMwDMMw9a7pbJGMN6bpGdevqmgbHFLemGkAmRbi4U4lOTWCCoeUMwzDMAzDMEwDeri5bG3Lo6k2SdLZlpHDzR5uOmxwMwzDMAzDMEwdwI5PU9jx9iO6weSBnWDBrMF8nlsI3TuUNcm4c0Z2d76WphItJheeMcMh5QzDMAzDMAxTX4PbYICUpZJwz7FT+Ry3IAZ1bQ9X7T8WurRvXMP7gMl9nc2bXcb0guaMab0zKmxwMwzDMAzDMEwdwCWhOMR282PPcX0afcy2pSk4fPpAaO40Zm3ylk7zjlVgGIZhGIZhmGYKdvKxAdI6ibsOd0shyaJpZNjgZhiGYRiGYZg6gNWrE/xW3SqJuyxYS4FzuOnwo4FhGIZhGIZh6unh5pBypjXBER102OBmGIZhGIZhmHp6uHt1bMPnkGk1NGZt8pYOi6YxDMMwDMMwTB158YxZUJPNQ2WbEj6HTKshyW5bMmxwMwzDMAzDMEwd6dupLZ87ptXBKRR0eG+CYRiGYRiGYRiGIcMh5XTY4GYYhmEYhmEYhmHIcEg5HTa4GYZhGIZhGIZhGDIproNHhg1uhmEYhmEYhmEYpignzxkKfarawIJZQ/hsEWHRNIZhGIZhGIZhGKYoJ88Z5vzH0GEPN8MwDMMwDMMwDMM0AGxwMwzDMAzDMAzDMEwDwAY3wzAMwzAMwzBMHZg9vLvztaKMM3WZaHhlMAzDMAzDMAzD1IGdR/eAO46aAlv0qODzx0TCBjfDMAzDMAzDMEwdsCwLpg3pwueO0cIh5QzDMAzDMAzDMAzTALDBzTAMwzAMwzAMwzANABvcDMMwDMMwDMMwDNMAsMHNMAzDMAzDMAzDMA0AG9wMwzAMwzAMwzAM0wCwwc0wDMMwDMMwDMMwDQAb3AzDMAzDMAzDMAzTALDBzTAMwzAMwzAMwzANABvcDMMwDMMwDMMwDNMAsMHNMAzDMAzDMAzDMA0AG9wMwzAMwzAMwzAM0wCwwc0wDMMwDMMwDMMwDQAb3AzDMAzDMAzDMAzTALDBzTAMwzAMwzAMwzANABvcDMMwDMMwDMMwDNMApBqi05aObdvO17Vr1zb1VBiGYRiGYRiGYZgYkXaetPsaEja4I1i3bp3ztW/fvg1+ARiGYRiGYRiGYZimsfsqKysbdAzLbgyzvoWRz+dh4cKFMHLkSFi0aBF06NChqafEtODdM7Fxw+uI4XXENDX8PGJ4HTHNBX4eMU29joQJLIztXr16QSLRsFnW7OGOQJz03r17O9+Li8cGN1NfeB0xccDriOF1xDQX+HnE8DpiWvrzqLKBPdsSFk1jGIZhGIZhGIZhmAaADW6GYRiGYRiGYRiGaQDY4NZQVlYG559/vvOVYeoKryMmDngdMbyOmOYCP48YXkdMc6GshdhrLJrGMAzDMAzDMAzDMA0Ae7gZhmEYhmEYhmEYpgFgg5thGIZhGIZhGIZhGgA2uBmGYRiGYRiGYRimtRvc119/PQwYMADKy8thypQp8Prrr2sLmc+bNw8sy4IHH3zQ2Kdoe95550HPnj2hTZs2MGfOHPj8889D7R599FFnTNGmqqoK9thjD2O/999/P0ycOBE6duwI7dq1g6222gr+8Y9/1GlspuWvo+eee87pJ+q/N954o17zra6uhgULFkDnzp2hffv2sPfee8OyZctqdU6YzXsd3XDDDTBmzBivTuXUqVPh8ccfV9rwOmpdn2ufffYZ7L777tClSxdnTWyzzTbw7LPPFp3vvffeC8OHD3fmO3r0aHjsscdqPTbTetcQvxs1X5pqHb399tswd+5c531ZvMccc8wxsH79+qLz5WdR86QlraP7G9NWs1sId911l11aWmr//e9/tz/66CP76KOPtjt27GgvW7Ys1PaPf/yjPW/ePFsc3gMPPGDs97LLLrMrKyvtBx980H7vvffs3XbbzR44cKC9adMmr819991nV1VV2TfccIO9cOFCZ/y7777b2O+zzz5r33///fbHH39sf/HFF/bVV19tJ5NJ+4knnqjV2MzmsY5qamrsH374QfnvqKOOctrk8/l6zfe4446z+/bta//3v/+133zzTXvrrbe2p02bVq/zxGxe6+ihhx6yH330Ufuzzz5znmFnn322XVJSYn/44YdeG15HretzbejQofbOO+/s/F6si+OPP95u27ats6Z0vPzyy87n2OWXX+58tp177rnOOvrggw9qNTbTetcQvxs1T5pqHS1ZssR5vxafP59++qn9+uuvO+8ve++9t7FffhY1T1raOnq2EW21FmNwT5482V6wYIH371wuZ/fq1cu+9NJLlXbvvPOO3bt3b+eBX+wiihfUHj162FdccYX3s9WrV9tlZWX2nXfe6fw7k8k4/f31r3+t9zGMGzfOeUGhjs1sPusoSDqdtrt27WpfdNFF9ZqvGEe88N57771em08++cSZ8yuvvGLsm2k96ygK8eEkn2u8jlrXOlqxYoXTzwsvvOC1Wbt2rfOzp556Stv3fvvtZ8+fP1/52ZQpU+xjjz2WPDbTutdQFPxu1HrX0U033WR369bNGU/y/vvvO31//vnn2r75WdQ8aWnrqDGfRy0ipDydTsNbb73luPEliUTC+fcrr7zi/Wzjxo1w4IEHOuEMPXr0KNrv119/DUuXLlX6raysdEIgZL8iRGHJkiXOeOPGjXNCCkQIxIcffqj0JcInLrjggshxxMbGf//7X1i4cCHMmDGDPDaz+ayjIA899BCsXLkSDj/8cOXnIrTm1ltvJc9X/D6TyShtRLhnv379eB01EC1tHQXJ5XJw1113wYYNG5zQcgGvo9a1jkS43RZbbAG33367sw6y2SzcdNNN0K1bN5gwYYL2c038Pe5XsOOOO3r98uda49IS1xCG342aB025jmpqaqC0tNQZTyLCdgUvvfSS9zN+FjV/WuI6asznUYswuH/88UfnJbF79+7Kz8W/xYmQnHLKKTBt2jQnp4iC/FtTv1999ZXzVVygc889Fx555BEnh3vmzJmwatUq728GDx7s5DFh1qxZ4+TUikUwf/58uPbaa538AurYzOazjoL87W9/c15U+/Tpo/xcvMCIm5k6X/FVrC+Rf0Idm2ld60jywQcfOM+jsrIyOO644+CBBx6AkSNHemPzOmo960hsyDz99NPwzjvvQEVFhZNr98c//hGeeOIJ5/NN97km/r7Y86jY2EzrXkMCfjdqXjTlOtp+++2d76+44grHYPvpp5/gzDPPdH73ww8/eH/Dz6LmT0tcR435PErBZoLw9DzzzDPOwz9O8vm88/Wcc85xxKgEt9xyi/OCKwQbjj32WOdnYlckiPgQevfdd52kffH7U089FQYNGuQY60zrWkeYxYsXw5NPPgn33HNP6Heffvppg43LtO51JIxw8TwSHy733XcfHHroofD88897RjfTetaR2MkXQovCG/niiy86noC//vWvsOuuuzrieyKSS/e5xrQsmuMa4nejlkdDraNRo0bBbbfd5rwfn3XWWZBMJuHEE090DBrsreRn0ebBQ81wHTXW86hFeLjFboQ4eUHlZfFvGY4gLuCXX37pePpSqZTzn0AYybqTJv/W1K/80MAvpcJDJC7Gd999Z5y3uMhDhgxxVO9OO+002GeffeDSSy8lj81sPusIIzZsRDjebrvtVu/5iq9iN2/16tWksZnWt44kYvdWPI9EuKd4Do0dOxauueYab2xeR61nHYl+RbSWSC2YPn06jB8/Hv785z87RpN4adEh/r7Y86jY2EzrXkMCfjdqXjT1Z5oILxbeQpG+KVKkRETpihUrnPdsHfwsan60xHXUmM+jFmFwixdF8ZKIdyaE51n8W+YgitCB999/39mlkP8JrrrqKufFNIqBAwc6Jwz3u3btWnjttde8fsW4wsAWMf0SkTP7zTffQP/+/Wt1HGLOIs+AOjaz+awj7BUQ/RxyyCFQUlJS7/mK34t+cBuxVsVmEK+jhqGlrSPK84jXUetaRyKHToB3/uW/ZVRXFOLvgx6Cp556yuuXP9cal5a4hqLgd6OmpTl8pgmEN1KE9t59991OioIM642Cn0XNj5a4jhr1eWS3IKl5oQp36623OvLtxxxzjCM1v3TpUu3fUKXmRT///ve/HUW73XffPST3ftJJJzlqek8++aQjN3/kkUc6anirVq3y2my//fb2tdde6/37kksusf/zn//YX375pTPfK6+80k6lUvZf/vKXWo3NbD7rSPD00087/Qkl8Si22GILp0RBbeYryiD069fPfuaZZ5yyYFOnTnX+YxqOlraOzjzzTPv555+3v/76a6df8W/LspxnlITXUetZR0JhunPnzvZee+1lv/vuu06puF/96ldOxQPxb93nmijFIz7HxOeZWHvnn39+ZFkw/lxrPFraGuJ3o+ZJU36mifXx1ltvOWvouuuus9u0aWNfc801Sj/8LGoZtLR1dEkj2motxuAWiJMkDAtR401Iz7/66qvG9pSLKCTff/Ob39jdu3d3Fsns2bOdixUsvXPaaac5RnZFRYU9Z84cpX6toH///s7Lh+Scc86xhwwZYpeXlzvld4QBJBZibcdmNp91JDjggAOMNbLFWLfcckut5ituelH/VKwzUQN1zz33NNZBZVrfOjriiCOcZ5SYqygjJvrFxraA11HrWkdvvPGGvcMOO9idOnVyPte23npr+7HHHjN+rgnuuecee9iwYc58R40a5dR3r+3YTOtdQ/xu1HxpqnV08MEHO2tIjDtmzBj79ttvD/XDz6KWQ0taR+c0oq1muQfLMAzDMAzDMAzDMEyMtIgcboZhGIZhGIZhGIZpabDBzTAMwzAMwzAMwzANABvcDMMwDMMwDMMwDNMAsMHNMAzDMAzDMAzDMA0AG9wMwzAMwzAMwzAM0wCwwc0wDMMwDMMwDMMwDQAb3AzDMAzDMAzDMAzTALDBzTAMwzAMwzAMwzANABvcDMMwDNMKOOyww2CPPfZo6mkwDMMwTKsi1dQTYBiGYRimfliWZfz9+eefD9dccw3Yts2nmmEYhmEaETa4GYZhGKaF88MPP3jf33333XDeeefBwoULvZ+1b9/e+Y9hGIZhmMaFQ8oZhmEYpoXTo0cP77/KykrH441/JoztYEj5zJkz4YQTToCTTz4ZqqqqoHv37vCXv/wFNmzYAIcffjhUVFTAkCFD4PHHH1fG+vDDD2HevHlOn+JvDj74YPjxxx+b4KgZhmEYpvnDBjfDMAzDtFJuu+026NKlC7z++uuO8f2LX/wC9t13X5g2bRq8/fbbsMMOOzgG9caNG532q1evhu233x7GjRsHb775JjzxxBOwbNky2G+//Zr6UBiGYRimWcIGN8MwDMO0UsaOHQvnnnsuDB06FM466ywoLy93DPCjjz7a+ZkITV+5ciW8//77TvvrrrvOMbYvueQSGD58uPP93//+d3j22Wfhs88+a+rDYRiGYZhmB+dwMwzDMEwrZcyYMd73yWQSOnfuDKNHj/Z+JkLGBcuXL3e+vvfee45xHZUP/uWXX8KwYcMaZd4MwzAM01Jgg5thGIZhWiklJSXKv0XuN/6ZVD/P5/PO1/Xr18Ouu+4Kv//970N99ezZs8HnyzAMwzAtDTa4GYZhGIYhMX78ePjXv/4FAwYMgFSKXyEYhmEYphicw80wDMMwDIkFCxbAqlWr4IADDoA33njDCSN/8sknHVXzXC7HZ5FhGIZhArDBzTAMwzAMiV69esHLL7/sGNdCwVzke4uyYh07doREgl8pGIZhGCaIZdu2HfopwzAMwzAMwzAMwzD1grejGYZhGIZhGIZhGKYBYIObYRiGYRiGYRiGYRoANrgZhmEYhmEYhmEYpgFgg5thGIZhGIZhGIZhGgA2uBmGYRiGYRiGYRimAWCDm2EYhmEYhmEYhmEaADa4GYZhGIZhGIZhGKYBYIObYRiGYRiGYRiGYRoANrgZhmEYhmEYhmEYpgFgg5thGIZhGIZhGIZhGgA2uBmGYRiGYRiGYRimAWCDm2EYhmEYhmEYhmEgfv4fT96xoupSp/sAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "meminfo_monitor_df = pd.read_csv(meminfo_path)\n", + "plot_meminfo(meminfo_monitor_df)" + ] + }, + { + "cell_type": "markdown", + "id": "e86dc5de-8224-4892-afb2-28977aa34a74", + "metadata": {}, + "source": [ + "## Analysing test results" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "c1007eda-7f0e-4614-8c1c-03a158d7eb5b", + "metadata": {}, + "outputs": [ + { + "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", + "
timestampTT_IDPICMinActAvgMax
39705802025-11-04 09:24:46089910000010000022321
39705812025-11-04 09:24:4619991000019999923320
39705822025-11-04 09:24:46210991000029999822318
39705832025-11-04 09:24:46311991000039999722321
\n", + "
" + ], + "text/plain": [ + " timestamp T T_ID P I C Min Act Avg Max\n", + "3970580 2025-11-04 09:24:46 0 8 99 100000 100000 2 2 3 21\n", + "3970581 2025-11-04 09:24:46 1 9 99 100001 99999 2 3 3 20\n", + "3970582 2025-11-04 09:24:46 2 10 99 100002 99998 2 2 3 18\n", + "3970583 2025-11-04 09:24:46 3 11 99 100003 99997 2 2 3 21" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = pd.read_csv(output_csv_path)\n", + "df.tail(len(df['T'].unique()))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "38d7a463-aeb8-4166-a956-4fdc6731edf8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Analyzing 3970544 data points from column 'Max'.\n", + "------------------------------\n", + "GEV Fit Parameters:\n", + " Shape (c): 0.7327\n", + " Location (loc): 16.9998\n", + " Scale (scale): 3.0377\n", + "------------------------------\n", + "Return Value at 99.9999% quantile: 21.15 CPU cycles\n", + "------------------------------\n" + ] + }, + { + "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" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/pabramov/dev/rt-tools/src/plots.py:215: UserWarning: Creating legend with loc=\"best\" can be slow with large amounts of data.\n", + " plt.tight_layout()\n", + "/Users/pabramov/dev/rt-tools/.venv/lib/python3.14/site-packages/IPython/core/pylabtools.py:170: UserWarning: Creating legend with loc=\"best\" can be slow with large amounts of data.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fit_and_plot_gev(df, \"Max\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "5702be14-8c80-423d-a6ec-80dbce697d5a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Analyzing 3970544 data points from column 'Act'.\n", + "------------------------------\n", + "GEV Fit Parameters:\n", + " Shape (c): 0.0437\n", + " Location (loc): 3.3035\n", + " Scale (scale): 0.7833\n", + "------------------------------\n", + "Return Value at 99.9999% quantile: 11.43 CPU cycles\n", + "------------------------------\n" + ] + }, + { + "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" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fit_and_plot_gev(df, \"Act\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "333bb6ed-5461-4c40-a012-0d5d869f2130", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebook/02_Megabenchmark.ipynb b/notebook/02_Megabenchmark.ipynb new file mode 100644 index 0000000..da604eb --- /dev/null +++ b/notebook/02_Megabenchmark.ipynb @@ -0,0 +1,953 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6d701489-8e38-4a68-ab5a-255575076a04", + "metadata": {}, + "source": [ + "# Megabenchmark Analysis (RT Evaluation)\n", + "\n", + "## Overview\n", + "\n", + "This Jupyter Notebook performs an analytical evaluation of **Megabenchmark for Real-Time (RT)** test results. \n", + "\n", + "Megabenchmark consists of 4 tests in total: \n", + "- Caterpillar with Cache Aligning Technology (CAT)\n", + "- Caterpillar without CAT\n", + "- Cyclictest with CAT\n", + "- Cyclictest witout CAT\n", + "\n", + "\n", + "---\n", + "\n", + "## What is Caterpillar benchmark?\n", + "\n", + "The Caterpillar benchmark measures how deterministically a system responds under load — specifically focusing on **timing jitter**, **CPU thermal conditions**, and **interrupt activity**. \n", + "\n", + "The **Caterpillar RT Benchmark** is a diagnostic tool designed to:\n", + "- Evaluate **real-time responsiveness** of CPU cores under varying system conditions.\n", + "- Measure **timing jitter** (variations in scheduling and latency).\n", + "- Identify hardware or kernel-level contributors to timing instability (e.g., IRQs, temperature fluctuations).\n", + "\n", + "The benchmark runs multiple real-time workloads while collecting detailed monitoring data from the system.\n", + "\n", + "---\n", + "\n", + "\n", + "## What is cyclictest benchmark?\n", + "\n", + "---\n", + "\n", + "\n", + "## Input Data Description\n", + "\n", + "The benchmark generates several monitoring files in the **output directory**, each containing time-synchronized measurements from different subsystems.\n", + "\n", + "| File | Description |\n", + "|------|--------------|\n", + "| `output.csv` | Raw output file from benchmark run |\n", + "| `caterpillar_cat.csv` | Caterpillar results with CAT |\n", + "| `caterpillar_no_cat.csv` | Caterpillar results without CAT |\n", + "| `cyclictest_cat.csv` | Cyclictest results with CAT |\n", + "| `cyclictest_no_cat.csv` | Cyclictest results without CAT |\n", + "| `cpu_monitor.csv` | CPU temperature, frequency, and utilization per core. |\n", + "| `cpustat_monitor.csv` | Detailed CPU statistics (user/system/idle times, context switches). |\n", + "| `irq_monitor.csv` | IRQ activity counts per CPU core over time. |\n", + "| `softirq_monitor.csv` | Kernel-level soft interrupt counts per CPU core. |\n", + "| `meminfo_monitor.csv` | Memory pressure and allocation statistics. |\n", + "| `sysinfo.json` | System configuration and metadata (CPU topology, kernel version, etc.). |\n", + "\n", + "---\n", + "\n", + "## Structure of `caterpillar_cat.csv` and `caterpillar_no_cat.csv`\n", + "\n", + "Caterpillar files contain per-sample jitter measurements recorded during the benchmark. \n", + "Each row represents a single sampling point with both **sample-level** and **session-level** timing information.\n", + "\n", + "| Column | Description | Units |\n", + "|---------|--------------|-------|\n", + "| `timestamp` | Timestamp of the measurement | ISO 8601 datetime |\n", + "| `SampleMin` | Minimum latency within current sampling window | microseconds (µs) |\n", + "| `SampleMax` | Maximum latency within current sampling window | microseconds (µs) |\n", + "| `SmplJitter` | Difference between `SampleMax` and `SampleMin` (per-sample jitter) | microseconds (µs) |\n", + "| `SessionMin` | Minimum latency observed since session start | microseconds (µs) |\n", + "| `SessionMax` | Maximum latency observed since session start | microseconds (µs) |\n", + "| `SessionJitter` | `SessionMax - SessionMin`, cumulative jitter for the session | microseconds (µs) |\n", + "| `Sample` | Sequential sample index | integer |\n", + "\n", + "\n", + "## Structure of `cyclictest_cat.csv` and `cyclictest_no_cat.csv`\n", + "\n", + "| Short | Explanation |\n", + "|--------|----------------------------------------------------------------------|\n", + "| `timestamp` | Timestamp of the measurement |\n", + "| `T` | Thread: Thread index and thread ID |\n", + "| `P` | Priority: RT thread priority |\n", + "| `I` | Interval: Intended wake up period for the latency measuring threads |\n", + "| `C` | Count: Number of times the latency was measured (iteration count) |\n", + "| `Min` | Minimum: Minimum latency that was measured |\n", + "| `Act` | Actual: Latency measured during the latest completed iteration |\n", + "| `Avg` | Average: Average latency that was measured |\n", + "| `Max` | Maximum: Maximum latency that was measured |\n", + "\n", + "\n", + "## How can I run analysis? \n", + "\n", + "You need to specify **folder** path in the next cell and run cells below, you will get report automatically then" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "dd45652b-bca8-4c9f-8caf-7ed6c1a37d82", + "metadata": {}, + "outputs": [], + "source": [ + "megabench_data_path = \"../data/11-04-24\"" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d1db4534-fc4d-4be6-a205-e8c4eb0ca546", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns \n", + "import sys\n", + "import os \n", + "import yaml\n", + "import json\n", + "\n", + "sys.path.append(os.path.abspath(os.path.join(os.getcwd(), '..')))\n", + "from src.plots import *\n", + "\n", + "\n", + "output_csv_path = f\"{megabench_data_path}/output.csv\"\n", + "caterpillar_cat_path = f\"{megabench_data_path}/caterpillar_cat.csv\"\n", + "caterpillar_no_cat_path = f\"{megabench_data_path}/caterpillar_no_cat.csv\"\n", + "cyclictest_cat_path = f\"{megabench_data_path}/cyclictest_cat.csv\"\n", + "cyclictest_no_cat_path = f\"{megabench_data_path}/cyclictest_no_cat.csv\"\n", + "cpu_monitor_path = f\"{megabench_data_path}/cpu_monitor.csv\"\n", + "irq_monitor_path = f\"{megabench_data_path}/irq_monitor.csv\"\n", + "meminfo_path = f\"{megabench_data_path}/meminfo_monitor.csv\"\n", + "hydra_conf_path = f\"{megabench_data_path}/.hydra/config.yaml\"\n", + "sysinfo_path = f\"{megabench_data_path}/sysinfo.json\"" + ] + }, + { + "cell_type": "markdown", + "id": "4ea9a051-2fd0-4741-af45-9a9c0ee088da", + "metadata": {}, + "source": [ + "### Sanity checks: \n", + "\n", + "Those checks are aimed to determine if the system is in a good shape to be analyzed, i.e. if there temperature is higher than a certain threshold, thermal throttling comes into play which would certainly affect Jitter and overal results" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e276e62c-0470-44cf-99e3-68fb607a9db3", + "metadata": {}, + "outputs": [], + "source": [ + "with open(hydra_conf_path, 'r') as stream:\n", + " hydra_conf = yaml.safe_load(stream)\n", + "\n", + "with open(sysinfo_path) as f:\n", + " sysinfo = json.load(f)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "761a62b0-a6d7-4899-bb3b-7ab5af20a679", + "metadata": {}, + "outputs": [], + "source": [ + "assert hydra_conf['run']['command'] == 'mega-benchmark', \"This notebook is designed to analyze mega-benchmark!\"" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "7a604de5-3258-4d19-9d94-ca51711e6b04", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Analyzing mega-benchmark\n", + "With isolated core(s): 9,11,13,15\n", + "Cache mask: 0x7ff0\n", + "System is stessed?: True\n", + "Kernel: Linux zededa-rt 6.12.8-intel-ese-experimental-lts-rt #1 SMP PREEMPT_RT Thu, 28 Aug 2025 10:46:22 +0000 x86_64 GNU/Linux\n", + "Kernel CMD: BOOT_IMAGE=/vmlinuz-6.12.8-intel-ese-experimental-lts-rt root=/dev/mapper/zededa--rt--vg-root ro BOOT_IMAGE=/vmlinuz-6.12.8-intel-ese-experimental-lts-rt root=/dev/mapper/zededa--rt--vg-root ro debug=all nosplash console=ttyS0,115200 console=tty0 clocksource=tsc tsc=reliable art=virtallow no_ipi_broadcast=1 nosoftlockup efi=runtime numa_balancing=disable hugepages=1024 audit=0 nmi_watchdog=0 irqaffinity=0,1 mce=off hpet=disable rcupdate.rcu_cpu_stall_suppress=1 rcu_nocb_poll noht isolcpus=3,5,7,9 rcu_nocbs=3,5,7,9 nohz_full=3,5,7,9 intel_pstate=disable intel.max_cstate=0 intel_idle.max_cstate=0 processor.max_cstate=0 processor_idle.max_cstate=0 i915.force_probe=* i915.enable_rc6=0 i915.enable_dc=0 i915.disable_power_well=0 igb.blacklist=no\n", + "\n" + ] + } + ], + "source": [ + "print(f\"\"\"\n", + "Analyzing {hydra_conf['run']['command']}\n", + "With isolated core(s): {hydra_conf['run']['t_core']}\n", + "Cache mask: {hydra_conf['run']['llc_cache_mask']}\n", + "System is stessed?: {hydra_conf['run']['stressor']}\n", + "Kernel: {sysinfo['kernel']['uname']}\n", + "Kernel CMD: {sysinfo['kernel']['cmdline']}\n", + "\"\"\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e379b5af-967a-4978-b4f4-e980483bc684", + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Sequence, Tuple\n", + "import re\n", + "\n", + "def parse_kernel_cmdline(cmdline: str, params: Sequence[str]) -> dict[str, str]:\n", + " results = {}\n", + "\n", + " for param in params:\n", + " # Find all matches like param=value\n", + " matches = re.findall(rf'\\b{param}=([^ ]+)', cmdline)\n", + "\n", + " if not matches:\n", + " print(f\"{param}: not found\")\n", + " results[param] = None\n", + " elif len(matches) == 1:\n", + " print(f\"{param}: {matches[0]}\")\n", + " results[param] = matches[0]\n", + " else:\n", + " print(f\"WARNING: multiple occurrences of '{param}' found! Using latest value.\")\n", + "\n", + " \n", + " for value in matches:\n", + " print(f\" -> {param}={value}\")\n", + " latest = matches[-1]\n", + " print(f\"Using latest: {param}={latest}\")\n", + " results[param] = latest\n", + "\n", + " return results" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c895c998-fc30-44f7-b6a9-cd922c37ad42", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "rcu_nocbs: 3,5,7,9\n", + "nohz_full: 3,5,7,9\n", + "isolcpus: 3,5,7,9\n" + ] + }, + { + "ename": "AssertionError", + "evalue": "rcu_nocbs parameter of kernel cmdline is missing CPU 11 which is used in tests", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mAssertionError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[7]\u001b[39m\u001b[32m, line 7\u001b[39m\n\u001b[32m 5\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m cpu \u001b[38;5;129;01min\u001b[39;00m hydra_conf[\u001b[33m'\u001b[39m\u001b[33mrun\u001b[39m\u001b[33m'\u001b[39m][\u001b[33m'\u001b[39m\u001b[33mt_core\u001b[39m\u001b[33m'\u001b[39m].split(\u001b[33m'\u001b[39m\u001b[33m,\u001b[39m\u001b[33m'\u001b[39m):\n\u001b[32m 6\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m k, v \u001b[38;5;129;01min\u001b[39;00m params.items():\n\u001b[32m----> \u001b[39m\u001b[32m7\u001b[39m \u001b[38;5;28;01massert\u001b[39;00m cpu \u001b[38;5;129;01min\u001b[39;00m v, \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mk\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m parameter of kernel cmdline is missing CPU \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mcpu\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m which is used in tests\u001b[39m\u001b[33m\"\u001b[39m\n", + "\u001b[31mAssertionError\u001b[39m: rcu_nocbs parameter of kernel cmdline is missing CPU 11 which is used in tests" + ] + } + ], + "source": [ + "# check 1: selected for tests CPUs are isolated\n", + "\n", + "params = parse_kernel_cmdline(sysinfo['kernel']['cmdline'], [\"rcu_nocbs\", \"nohz_full\", \"isolcpus\"])\n", + "\n", + "for cpu in hydra_conf['run']['t_core'].split(','):\n", + " for k, v in params.items():\n", + " assert cpu in v, f\"{k} parameter of kernel cmdline is missing CPU {cpu} which is used in tests\"" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "7b1e1f59-6749-4ef7-a810-9891b3e36509", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "intel_pstate: disable\n", + "intel.max_cstate: 0\n", + "intel_idle.max_cstate: 0\n", + "processor.max_cstate: 0\n", + "processor_idle.max_cstate: 0\n" + ] + } + ], + "source": [ + "# check 2 p-state and c-state are disabled\n", + "\n", + "params = parse_kernel_cmdline(sysinfo['kernel']['cmdline'], [\"intel_pstate\", \"intel.max_cstate\", \"intel_idle.max_cstate\", \"processor.max_cstate\", \"processor_idle.max_cstate\"])\n", + "\n", + "assert params[\"intel_pstate\"] == \"disable\", \"Intel p-state must be disabled\"\n", + "assert params[\"intel.max_cstate\"] == \"0\", \"Intel c-state must be disabled\"\n", + "assert params[\"intel_idle.max_cstate\"] == \"0\", \"Intel c-state must be disabled\"\n", + "assert params[\"processor.max_cstate\"] == \"0\", \"Intel c-state must be disabled\"\n", + "assert params[\"processor_idle.max_cstate\"] == \"0\", \"Intel c-state must be disabled\"" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "c4a365f5-c553-427a-a4ee-5dbef604fc63", + "metadata": {}, + "outputs": [], + "source": [ + "# check 3: hypter-threading is disabled\n", + "\n", + "assert \" noht \" in sysinfo['kernel']['cmdline']" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e9f703b1-4626-45bd-9958-2d98afe97585", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "heat_threshold = 90\n", + "cpu_monitor_df = pd.read_csv(cpu_monitor_path)\n", + "\n", + "\n", + "### Check 1: Packages do not exceed threshold\n", + "\n", + "packages = [col for col in cpu_monitor_df.columns if col.startswith(\"Package id\")]\n", + "\n", + "for pkg in packages:\n", + " assert cpu_monitor_df[pkg].max() <= heat_threshold\n", + "\n", + "### Check 2: CPUs do not exceed threshold\n", + "\n", + "cpus = [col for col in cpu_monitor_df.columns if col.startswith(\"CPU\")]\n", + "\n", + "for cpu in cpus:\n", + " assert cpu_monitor_df[cpu].max() <= heat_threshold\n", + "\n", + "### Check 3: plot average temperature\n", + "\n", + "plot_avg_cpu_temp(cpu_monitor_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b086fc73-1eef-4faa-bdcd-386bc396c9b5", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Python(54964,0x1ff958800) malloc: Failed to allocate segment from range group - out of space\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mKeyboardInterrupt\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[11]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m 1\u001b[39m irq_monitor_df = pd.read_csv(irq_monitor_path)\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m mask = \u001b[43mirq_monitor_df\u001b[49m\u001b[43m[\u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mdescription\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m.\u001b[49m\u001b[43mstr\u001b[49m\u001b[43m.\u001b[49m\u001b[43mcontains\u001b[49m\u001b[43m(\u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mAPIC|MSIX\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcase\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mregex\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mna\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[32m 3\u001b[39m global_irqs = irq_monitor_df[mask]\n\u001b[32m 5\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m cpu \u001b[38;5;129;01min\u001b[39;00m hydra_conf[\u001b[33m'\u001b[39m\u001b[33mrun\u001b[39m\u001b[33m'\u001b[39m][\u001b[33m'\u001b[39m\u001b[33mt_core\u001b[39m\u001b[33m'\u001b[39m].split(\u001b[33m'\u001b[39m\u001b[33m,\u001b[39m\u001b[33m'\u001b[39m):\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/dev/rt-tools/.venv/lib/python3.14/site-packages/pandas/core/strings/accessor.py:140\u001b[39m, in \u001b[36mforbid_nonstring_types.._forbid_nonstring_types..wrapper\u001b[39m\u001b[34m(self, *args, **kwargs)\u001b[39m\n\u001b[32m 135\u001b[39m msg = (\n\u001b[32m 136\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mCannot use .str.\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfunc_name\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m with values of \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 137\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33minferred dtype \u001b[39m\u001b[33m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m._inferred_dtype\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m'\u001b[39m\u001b[33m.\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 138\u001b[39m )\n\u001b[32m 139\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(msg)\n\u001b[32m--> \u001b[39m\u001b[32m140\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/dev/rt-tools/.venv/lib/python3.14/site-packages/pandas/core/strings/accessor.py:1346\u001b[39m, in \u001b[36mStringMethods.contains\u001b[39m\u001b[34m(self, pat, case, flags, na, regex)\u001b[39m\n\u001b[32m 1338\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m regex \u001b[38;5;129;01mand\u001b[39;00m re.compile(pat).groups:\n\u001b[32m 1339\u001b[39m warnings.warn(\n\u001b[32m 1340\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mThis pattern is interpreted as a regular expression, and has \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 1341\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mmatch groups. To actually get the groups, use str.extract.\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 1342\u001b[39m \u001b[38;5;167;01mUserWarning\u001b[39;00m,\n\u001b[32m 1343\u001b[39m stacklevel=find_stack_level(),\n\u001b[32m 1344\u001b[39m )\n\u001b[32m-> \u001b[39m\u001b[32m1346\u001b[39m result = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_data\u001b[49m\u001b[43m.\u001b[49m\u001b[43marray\u001b[49m\u001b[43m.\u001b[49m\u001b[43m_str_contains\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpat\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcase\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mflags\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mna\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mregex\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 1347\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m._wrap_result(result, fill_value=na, returns_string=\u001b[38;5;28;01mFalse\u001b[39;00m)\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/dev/rt-tools/.venv/lib/python3.14/site-packages/pandas/core/strings/object_array.py:162\u001b[39m, in \u001b[36mObjectStringArrayMixin._str_contains\u001b[39m\u001b[34m(self, pat, case, flags, na, regex)\u001b[39m\n\u001b[32m 154\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m na \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m lib.no_default \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m isna(na) \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(na, \u001b[38;5;28mbool\u001b[39m):\n\u001b[32m 155\u001b[39m \u001b[38;5;66;03m# GH#59561\u001b[39;00m\n\u001b[32m 156\u001b[39m warnings.warn(\n\u001b[32m 157\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mAllowing a non-bool \u001b[39m\u001b[33m'\u001b[39m\u001b[33mna\u001b[39m\u001b[33m'\u001b[39m\u001b[33m in obj.str.contains is deprecated \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 158\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mand will raise in a future version.\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 159\u001b[39m \u001b[38;5;167;01mFutureWarning\u001b[39;00m,\n\u001b[32m 160\u001b[39m stacklevel=find_stack_level(),\n\u001b[32m 161\u001b[39m )\n\u001b[32m--> \u001b[39m\u001b[32m162\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_str_map\u001b[49m\u001b[43m(\u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mna\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[43m=\u001b[49m\u001b[43mnp\u001b[49m\u001b[43m.\u001b[49m\u001b[43mdtype\u001b[49m\u001b[43m(\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mbool\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/dev/rt-tools/.venv/lib/python3.14/site-packages/pandas/core/strings/object_array.py:82\u001b[39m, in \u001b[36mObjectStringArrayMixin._str_map\u001b[39m\u001b[34m(self, f, na_value, dtype, convert)\u001b[39m\n\u001b[32m 80\u001b[39m map_convert = convert \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m np.all(mask)\n\u001b[32m 81\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m---> \u001b[39m\u001b[32m82\u001b[39m result = \u001b[43mlib\u001b[49m\u001b[43m.\u001b[49m\u001b[43mmap_infer_mask\u001b[49m\u001b[43m(\u001b[49m\u001b[43marr\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmask\u001b[49m\u001b[43m.\u001b[49m\u001b[43mview\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnp\u001b[49m\u001b[43m.\u001b[49m\u001b[43muint8\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmap_convert\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 83\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m (\u001b[38;5;167;01mTypeError\u001b[39;00m, \u001b[38;5;167;01mAttributeError\u001b[39;00m) \u001b[38;5;28;01mas\u001b[39;00m err:\n\u001b[32m 84\u001b[39m \u001b[38;5;66;03m# Reraise the exception if callable `f` got wrong number of args.\u001b[39;00m\n\u001b[32m 85\u001b[39m \u001b[38;5;66;03m# The user may want to be warned by this, instead of getting NaN\u001b[39;00m\n\u001b[32m 86\u001b[39m p_err = (\n\u001b[32m 87\u001b[39m \u001b[33mr\u001b[39m\u001b[33m\"\u001b[39m\u001b[33m((takes)|(missing)) (?(2)from \u001b[39m\u001b[33m\\\u001b[39m\u001b[33md+ to )?\u001b[39m\u001b[33m\\\u001b[39m\u001b[33md+ \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 88\u001b[39m \u001b[33mr\u001b[39m\u001b[33m\"\u001b[39m\u001b[33m(?(3)required )positional arguments?\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 89\u001b[39m )\n", + "\u001b[36mFile \u001b[39m\u001b[32mpandas/_libs/lib.pyx:2922\u001b[39m, in \u001b[36mpandas._libs.lib.map_infer_mask\u001b[39m\u001b[34m()\u001b[39m\n", + "\u001b[36mFile \u001b[39m\u001b[32mpandas/_libs/lib.pyx:2959\u001b[39m, in \u001b[36mpandas._libs.lib._map_infer_mask\u001b[39m\u001b[34m()\u001b[39m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/dev/rt-tools/.venv/lib/python3.14/site-packages/pandas/core/strings/object_array.py:147\u001b[39m, in \u001b[36mObjectStringArrayMixin._str_contains..\u001b[39m\u001b[34m(x)\u001b[39m\n\u001b[32m 143\u001b[39m flags |= re.IGNORECASE\n\u001b[32m 145\u001b[39m pat = re.compile(pat, flags=flags)\n\u001b[32m--> \u001b[39m\u001b[32m147\u001b[39m f = \u001b[38;5;28;01mlambda\u001b[39;00m x: \u001b[43mpat\u001b[49m\u001b[43m.\u001b[49m\u001b[43msearch\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m \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[32m 148\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 149\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m case:\n", + "\u001b[31mKeyboardInterrupt\u001b[39m: " + ] + } + ], + "source": [ + "irq_monitor_df = pd.read_csv(irq_monitor_path)\n", + "mask = irq_monitor_df['description'].str.contains('APIC|MSIX', case=False, regex=True, na=False)\n", + "global_irqs = irq_monitor_df[mask]\n", + "\n", + "for cpu in hydra_conf['run']['t_core'].split(','):\n", + " assert global_irqs[f'CPU{cpu}'].sum() == 0\n", + "\n", + "## Bonus check: plot cumsum of CPU interrupts for each CPU\n", + "\n", + "cpu_cols = [col for col in irq_monitor_df.columns if col.startswith('CPU')]\n", + "cpu_df = global_irqs[cpu_cols]\n", + "cpu_cumsum_df = cpu_df.cumsum()\n", + "\n", + "cpu_long_df = cpu_cumsum_df.reset_index().melt(id_vars='index', var_name='CPU', value_name='Cumulative Value')\n", + "\n", + "# Plot with seaborn\n", + "plt.figure(figsize=(12, 6))\n", + "sns.lineplot(data=cpu_long_df, x='index', y='Cumulative Value', hue='CPU', linewidth=2)\n", + "\n", + "plt.title('Cumulative Sum of system interrruptions per CPU')\n", + "plt.xlabel('Sample Index')\n", + "plt.ylabel('Cumulative Value')\n", + "plt.legend(title='CPU', bbox_to_anchor=(1.05, 1), loc='upper left')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "c0e700f5-408b-4516-9641-718705bd1729", + "metadata": { + "scrolled": true + }, + "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" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/pabramov/dev/rt-tools/src/plots.py:290: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `y` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.barplot(x=stds.values, y=stds.index, palette=\"crest\")\n" + ] + }, + { + "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" + }, + { + "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": [ + "meminfo_monitor_df = pd.read_csv(meminfo_path)\n", + "plot_meminfo(meminfo_monitor_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "0ed373f4-53da-4ead-8ffe-4b14d02f1886", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Analyzing 7200 data points from column 'SessionJitter'.\n", + "------------------------------\n", + "GEV Fit Parameters:\n", + " Shape (c): 0.6603\n", + " Location (loc): 21315.2217\n", + " Scale (scale): 803.6298\n", + "------------------------------\n", + "Return Value at 99.9999% quantile: 22532.18 CPU cycles\n", + "------------------------------\n" + ] + }, + { + "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" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "caterpillar_cat = pd.read_csv(caterpillar_cat_path)\n", + "fit_and_plot_gev(caterpillar_cat, \"SessionJitter\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "7732ba93-cde8-41df-95a1-372af89aea04", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Analyzing 7200 data points from column 'SessionJitter'.\n", + "------------------------------\n", + "GEV Fit Parameters:\n", + " Shape (c): 7.3093\n", + " Location (loc): 34272.4612\n", + " Scale (scale): 47.7938\n", + "------------------------------\n", + "Return Value at 99.9999% quantile: 34279.00 CPU cycles\n", + "------------------------------\n" + ] + }, + { + "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" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "caterpillar_no_cat = pd.read_csv(caterpillar_no_cat_path)\n", + "fit_and_plot_gev(caterpillar_no_cat, \"SessionJitter\")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "80013025-4fe1-48ba-a749-abb19c854629", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "caterpillar_cat['Source'] = 'CAT'\n", + "caterpillar_no_cat['Source'] = 'NO CAT'\n", + "\n", + "\n", + "combined_df = pd.concat([caterpillar_cat[['SessionJitter', 'Source', 'Sample']], caterpillar_no_cat[['SessionJitter', 'Source', 'Sample']]], ignore_index=True)\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "sns.lineplot(data=combined_df, x='Sample', y='SessionJitter', hue='Source')\n", + "plt.title('SessionJitter Comparison')\n", + "plt.xlabel('Index')\n", + "plt.ylabel('SessionJitter')\n", + "plt.legend(title='CAT')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "db16cea0-a799-4e86-a7d0-cd9998cc09ad", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cyclictest_cat = pd.read_csv(cyclictest_cat_path) \n", + "cyclictest_no_cat = pd.read_csv(cyclictest_no_cat_path) \n", + "\n", + "# Count occurrences of each microsecond value\n", + "count_no_cat = cyclictest_no_cat['Act'].value_counts().sort_index().reset_index()\n", + "count_no_cat.columns = ['Microseconds', 'Count']\n", + "count_no_cat['Mode'] = 'Without CAT'\n", + "\n", + "count_cat = cyclictest_cat['Act'].value_counts().sort_index().reset_index()\n", + "count_cat.columns = ['Microseconds', 'Count']\n", + "count_cat['Mode'] = 'With CAT'\n", + "\n", + "# Combine both datasets\n", + "combined = pd.concat([count_no_cat, count_cat])\n", + "\n", + "# --- Plot ---\n", + "plt.figure(figsize=(12, 6))\n", + "sns.barplot(\n", + " data=combined,\n", + " x='Microseconds',\n", + " y='Count',\n", + " hue='Mode',\n", + " palette=['royalblue', 'darkorange'],\n", + " dodge=True\n", + ")\n", + "\n", + "plt.yscale('log')\n", + "plt.title('Cyclictest Benchmark 24-Hours - Vecow SPC-7100 (TGL)', fontsize=14)\n", + "plt.xlabel('Microseconds')\n", + "plt.ylabel('Number of latency samples (Logarithmic)')\n", + "sns.despine()\n", + "plt.legend(title=None)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "fcd0f700-8ea5-40d8-8968-b4d83247bea8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cyclictest_cat = pd.read_csv(cyclictest_cat_path) \n", + "cyclictest_no_cat = pd.read_csv(cyclictest_no_cat_path) \n", + "\n", + "# Count occurrences of each microsecond value\n", + "count_no_cat = cyclictest_no_cat['Act'].value_counts().sort_index().reset_index()\n", + "count_no_cat.columns = ['Microseconds', 'Count']\n", + "count_no_cat['Mode'] = 'Without CAT'\n", + "\n", + "count_cat = cyclictest_cat['Act'].value_counts().sort_index().reset_index()\n", + "count_cat.columns = ['Microseconds', 'Count']\n", + "count_cat['Mode'] = 'With CAT'\n", + "\n", + "# Combine both datasets\n", + "combined = pd.concat([count_no_cat, count_cat])\n", + "\n", + "# --- Plot ---\n", + "plt.figure(figsize=(12, 6))\n", + "sns.barplot(\n", + " data=combined,\n", + " x='Microseconds',\n", + " y='Count',\n", + " hue='Mode',\n", + " palette=['royalblue', 'darkorange'],\n", + " dodge=True\n", + ")\n", + "\n", + "plt.yscale('log')\n", + "plt.title('Cyclictest Benchmark 24-Hours - Vecow SPC-7100 (TGL)', fontsize=14)\n", + "plt.xlabel('Microseconds')\n", + "plt.ylabel('Number of latency samples (Logarithmic)')\n", + "sns.despine()\n", + "plt.legend(title=None)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "137c2c8f-4f58-45aa-b205-789e0caa7031", + "metadata": {}, + "outputs": [ + { + "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", + "
timestampTT_IDPICMinActAvgMax
85807832025-11-09 19:58:360274806499250345599993111174
\n", + "
" + ], + "text/plain": [ + " timestamp T T_ID P I C Min Act Avg \\\n", + "8580783 2025-11-09 19:58:36 0 2748064 99 250 345599993 1 1 1 \n", + "\n", + " Max \n", + "8580783 174 " + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cyclictest_cat.tail(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "01949c28-6643-42f3-a68c-c6f2ed21cbce", + "metadata": {}, + "outputs": [ + { + "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", + "
timestampTT_IDPICMinActAvgMax
85807522025-11-08 19:58:3602441139925034559998911152
\n", + "
" + ], + "text/plain": [ + " timestamp T T_ID P I C Min Act Avg \\\n", + "8580752 2025-11-08 19:58:36 0 244113 99 250 345599989 1 1 1 \n", + "\n", + " Max \n", + "8580752 52 " + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cyclictest_no_cat.tail(1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7c2a672d-f9d8-4ad3-b8fc-6375dda390ae", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebook/03_Megabench_msr_comparison.ipynb b/notebook/03_Megabench_msr_comparison.ipynb new file mode 100644 index 0000000..f640ea5 --- /dev/null +++ b/notebook/03_Megabench_msr_comparison.ipynb @@ -0,0 +1,544 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "39bdf9f4-8220-4e5c-8911-bdf9a5c732da", + "metadata": {}, + "source": [ + "## Megabench msr comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "02158f0c-379c-4c2f-94bf-03e98b9f45d9", + "metadata": {}, + "outputs": [], + "source": [ + "megabench_error_data_path = \"../data/15-12-05\"\n", + "megabench_no_error_data_path = \"../data/10-49-18\"" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5b9c6872-4107-4902-b9be-009aff6fa6b2", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns \n", + "import sys\n", + "import os \n", + "import yaml\n", + "import json\n", + "\n", + "sys.path.append(os.path.abspath(os.path.join(os.getcwd(), '..')))\n", + "from src.plots import *\n", + "\n", + "\n", + "error_caterpillar_cat_path = f\"{megabench_error_data_path}/caterpillar_cat.csv\"\n", + "error_caterpillar_no_cat_path = f\"{megabench_error_data_path}/caterpillar_no_cat.csv\"\n", + "error_cyclictest_cat_path = f\"{megabench_error_data_path}/cyclictest_cat.csv\"\n", + "error_cyclictest_no_cat_path = f\"{megabench_error_data_path}/cyclictest_no_cat.csv\"\n", + "\n", + "no_error_caterpillar_cat_path = f\"{megabench_no_error_data_path}/caterpillar_cat.csv\"\n", + "no_error_caterpillar_no_cat_path = f\"{megabench_no_error_data_path}/caterpillar_no_cat.csv\"\n", + "no_error_cyclictest_cat_path = f\"{megabench_no_error_data_path}/cyclictest_cat.csv\"\n", + "no_error_cyclictest_no_cat_path = f\"{megabench_no_error_data_path}/cyclictest_no_cat.csv\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9d0d76c0-98a1-4da7-9421-4ffb3f8e18a9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "/bin/sh: 1: echo: echo: I/O error\n", + "stress-ng: error: [93730] taskset: cannot set CPU affinity, errno=22 (Invalid argument)\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "stress-ng: error: [2430030] taskset: cannot set CPU affinity, errno=22 (Invalid argument)\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n", + "/bin/bash: line 1: echo: write error: Operation not permitted\n" + ] + } + ], + "source": [ + "! cat ../data/10-49-18/output.csv | grep -i \"error\"" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "af5c40cb-c93a-49d0-9ac6-5d20ecf10fe1", + "metadata": {}, + "outputs": [], + "source": [ + "error_cater_cat_df = pd.read_csv(error_caterpillar_cat_path)\n", + "error_cater_no_cat_df = pd.read_csv(no_error_caterpillar_no_cat_path)\n", + "no_error_cater_no_cat_df = pd.read_csv(no_error_caterpillar_cat_path)\n", + "no_error_cater_cat_df = pd.read_csv(no_error_caterpillar_cat_path)\n", + "\n", + "error_cater_cat_df['CAT'] = True\n", + "error_cater_cat_df['MSR'] = False\n", + "\n", + "error_cater_no_cat_df['CAT'] = False\n", + "error_cater_no_cat_df['MSR'] = False\n", + "\n", + "no_error_cater_no_cat_df['CAT'] = False\n", + "no_error_cater_no_cat_df['MSR'] = True\n", + "\n", + "no_error_cater_cat_df['CAT'] = True\n", + "no_error_cater_cat_df['MSR'] = True\n", + "\n", + "caterpillar_df = pd.concat([\n", + " error_cater_cat_df,\n", + " error_cater_no_cat_df,\n", + " no_error_cater_no_cat_df,\n", + " no_error_cater_cat_df\n", + "], ignore_index=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "0a988065-ace5-420b-9f02-099b8b27aacc", + "metadata": {}, + "outputs": [ + { + "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", + " \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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
timestampSampleMinSampleMaxSmplJitterSessionMinSessionMaxSessionJitterSampleCATMSR
02025-11-07 17:32:1727833633644780334249278336336447803342490TrueFalse
12025-11-07 17:32:18278296155494100155194027829615549410011225401TrueFalse
22025-11-07 17:32:19278280392700146912782801554941009165652TrueFalse
32025-11-07 17:32:20278334155521570155226227828015552157011101253TrueFalse
42025-11-07 17:32:21278344154356542154041227828015552157012085094TrueFalse
.................................
287952025-11-10 15:29:09289470154632928218004327806415700421616076627195TrueTrue
287962025-11-10 15:29:10278970154425648154126027806415700421616076537196TrueTrue
287972025-11-10 15:29:11280102154442400154142127806415700421616076447197TrueTrue
287982025-11-10 15:29:12278818154153100153848227806415700421616076347198TrueTrue
287992025-11-10 15:29:13278450154735158154442027806415700421616076257199TrueTrue
\n", + "

28800 rows × 10 columns

\n", + "
" + ], + "text/plain": [ + " timestamp SampleMin SampleMax SmplJitter SessionMin \\\n", + "0 2025-11-07 17:32:17 278336 33644780 334249 278336 \n", + "1 2025-11-07 17:32:18 278296 155494100 1551940 278296 \n", + "2 2025-11-07 17:32:19 278280 392700 14691 278280 \n", + "3 2025-11-07 17:32:20 278334 155521570 1552262 278280 \n", + "4 2025-11-07 17:32:21 278344 154356542 1540412 278280 \n", + "... ... ... ... ... ... \n", + "28795 2025-11-10 15:29:09 289470 154632928 2180043 278064 \n", + "28796 2025-11-10 15:29:10 278970 154425648 1541260 278064 \n", + "28797 2025-11-10 15:29:11 280102 154442400 1541421 278064 \n", + "28798 2025-11-10 15:29:12 278818 154153100 1538482 278064 \n", + "28799 2025-11-10 15:29:13 278450 154735158 1544420 278064 \n", + "\n", + " SessionMax SessionJitter Sample CAT MSR \n", + "0 33644780 334249 0 True False \n", + "1 155494100 1122540 1 True False \n", + "2 155494100 916565 2 True False \n", + "3 155521570 1110125 3 True False \n", + "4 155521570 1208509 4 True False \n", + "... ... ... ... ... ... \n", + "28795 157004216 1607662 7195 True True \n", + "28796 157004216 1607653 7196 True True \n", + "28797 157004216 1607644 7197 True True \n", + "28798 157004216 1607634 7198 True True \n", + "28799 157004216 1607625 7199 True True \n", + "\n", + "[28800 rows x 10 columns]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "caterpillar_df" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "82f742cd-a81d-401f-af50-d5df02578c2d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 6))\n", + "sns.lineplot(data=caterpillar_df, x='Sample', y='SessionJitter', hue='CAT', style=\"MSR\")\n", + "plt.title('SessionJitter Comparison')\n", + "plt.xlabel('Index')\n", + "plt.ylabel('SessionJitter')\n", + "plt.legend(title='CAT')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "06114809-0ef6-405a-a41d-7d2d75f22ecc", + "metadata": {}, + "outputs": [], + "source": [ + "error_cyclictest_cat = pd.read_csv(error_cyclictest_cat_path) \n", + "error_cyclictest_no_cat = pd.read_csv(error_cyclictest_no_cat_path) \n", + "no_error_cyclictest_cat = pd.read_csv(no_error_cyclictest_cat_path) \n", + "no_error_cyclictest_no_cat = pd.read_csv(no_error_cyclictest_no_cat_path) \n", + "\n", + "cnt_e_c = error_cyclictest_cat['Act'].value_counts().sort_index().reset_index()\n", + "cnt_e_c.columns = ['Microseconds', 'Count']\n", + "cnt_e_c['Mode'] = 'With Error With CAT'\n", + "\n", + "cnt_e_nc = error_cyclictest_no_cat['Act'].value_counts().sort_index().reset_index()\n", + "cnt_e_nc.columns = ['Microseconds', 'Count']\n", + "cnt_e_nc['Mode'] = 'With Error No CAT'\n", + "\n", + "\n", + "cnt_ne_nc = no_error_cyclictest_no_cat['Act'].value_counts().sort_index().reset_index()\n", + "cnt_ne_nc.columns = ['Microseconds', 'Count']\n", + "cnt_ne_nc['Mode'] = 'No Error No CAT'\n", + "\n", + "cnt_ne_c = no_error_cyclictest_cat['Act'].value_counts().sort_index().reset_index()\n", + "cnt_ne_c.columns = ['Microseconds', 'Count']\n", + "cnt_ne_c['Mode'] = 'No Error With CAT'" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "e6ee8128-bd74-40c7-8e65-739a017f43b5", + "metadata": {}, + "outputs": [], + "source": [ + "combined = pd.concat([cnt_e_c, cnt_e_nc, cnt_ne_nc, cnt_ne_c])" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "211097c8-1a0b-41bd-8ce1-2ba593388e8c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# --- Plot ---\n", + "plt.figure(figsize=(12, 6))\n", + "sns.barplot(\n", + " data=combined,\n", + " x='Microseconds',\n", + " y='Count',\n", + " hue='Mode',\n", + " palette = ['royalblue', 'darkorange', 'mediumseagreen', 'crimson'],\n", + " dodge=True\n", + ")\n", + "\n", + "plt.yscale('log')\n", + "plt.title('Cyclictest Benchmark 24-Hours', fontsize=14)\n", + "plt.xlabel('Microseconds')\n", + "plt.ylabel('Number of latency samples (Logarithmic)')\n", + "sns.despine()\n", + "plt.legend(title=None)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bbb5947f-c584-4562-8be0-3e4b25737c49", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyproject.toml b/pyproject.toml index 11a28da..3d70174 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -17,6 +17,7 @@ dependencies = [ "pyextremes>=2.3.3", "pymc>=5.26.1", "pytest>=8.4.2", + "scikit-learn>=1.7.2", "scipy>=1.16.3", "seaborn>=0.13.2", "statsmodels>=0.14.5", diff --git a/src/plots.py b/src/plots.py index 99ec397..8bcd053 100644 --- a/src/plots.py +++ b/src/plots.py @@ -34,6 +34,7 @@ def fit_and_plot_gev( column_name: str, quantile: float = 0.999999, save_fig: bool = False, + type: str = "CPU cycles", ): """ Fits a GEV distribution to a specified column in a DataFrame and plots the result, @@ -54,7 +55,7 @@ def fit_and_plot_gev( print(f"Error: No data found in column '{column_name}' after dropping NaNs.") return - # Ensure all data is positive, as CPU cycles cannot be negative + # Ensure all data is positive data = data[data > 0] if len(data) < 10: # GEV fit is unreliable with very few data points @@ -86,9 +87,7 @@ def fit_and_plot_gev( # --- 2b. Calculate and Print Return Value --- return_value = genextreme.ppf(quantile, c, loc, scale) - print( - f"Return Value at {quantile*100:.4f}% quantile: {return_value:.2f} CPU cycles" - ) + print(f"Return Value at {quantile*100:}% quantile: {return_value:.2f} {type}") print("-" * 30) # --- 3. Plotting with Seaborn (Histogram + PDF) --- @@ -114,7 +113,7 @@ def fit_and_plot_gev( # Generate x-values for the fitted PDF plot # Go from the 0.1th percentile to the 99.9th percentile xmin = genextreme.ppf(0.001, c, loc, scale) - xmax = genextreme.ppf(0.999, c, loc, scale) + xmax = genextreme.ppf(quantile, c, loc, scale) x_values = np.linspace(xmin, xmax, 200) @@ -210,7 +209,7 @@ def fit_and_plot_gev( ax_rl.set_xscale("log") ax_rl.set_title(f"Return Level Plot for {column_name.title()}", fontsize=16) ax_rl.set_xlabel("Return Period (Log Scale)", fontsize=12) - ax_rl.set_ylabel("Return Level (CPU Cycles)", fontsize=12) + ax_rl.set_ylabel(f"Return Level ({type})", fontsize=12) ax_rl.legend() ax_rl.grid(True, which="both", linestyle="--") plt.tight_layout() diff --git a/uv.lock b/uv.lock index 2219670..cbb1a97 100644 --- a/uv.lock +++ b/uv.lock @@ -744,6 +744,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, ] +[[package]] +name = "joblib" +version = "1.5.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e8/5d/447af5ea094b9e4c4054f82e223ada074c552335b9b4b2d14bd9b35a67c4/joblib-1.5.2.tar.gz", hash = "sha256:3faa5c39054b2f03ca547da9b2f52fde67c06240c31853f306aea97f13647b55", size = 331077, upload-time = "2025-08-27T12:15:46.575Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/e8/685f47e0d754320684db4425a0967f7d3fa70126bffd76110b7009a0090f/joblib-1.5.2-py3-none-any.whl", hash = "sha256:4e1f0bdbb987e6d843c70cf43714cb276623def372df3c22fe5266b2670bc241", size = 308396, upload-time = "2025-08-27T12:15:45.188Z" }, +] + [[package]] name = "json5" version = "0.12.1" @@ -2018,6 +2027,7 @@ dependencies = [ { name = "pyextremes" }, { name = "pymc" }, { name = "pytest" }, + { name = "scikit-learn" }, { name = "scipy" }, { name = "seaborn" }, { name = "statsmodels" }, @@ -2038,12 +2048,42 @@ requires-dist = [ { name = "pyextremes", specifier = ">=2.3.3" }, { name = "pymc", specifier = ">=5.26.1" }, { name = "pytest", specifier = ">=8.4.2" }, + { name = "scikit-learn", specifier = ">=1.7.2" }, { name = "scipy", specifier = ">=1.16.3" }, { name = "seaborn", specifier = ">=0.13.2" }, { name = "statsmodels", specifier = ">=0.14.5" }, { name = "tqdm", specifier = ">=4.67.1" }, ] +[[package]] +name = "scikit-learn" +version = "1.7.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "joblib" }, + { name = "numpy" }, + { name = "scipy" }, + { name = "threadpoolctl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/98/c2/a7855e41c9d285dfe86dc50b250978105dce513d6e459ea66a6aeb0e1e0c/scikit_learn-1.7.2.tar.gz", hash = "sha256:20e9e49ecd130598f1ca38a1d85090e1a600147b9c02fa6f15d69cb53d968fda", size = 7193136, upload-time = "2025-09-09T08:21:29.075Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ae/93/a3038cb0293037fd335f77f31fe053b89c72f17b1c8908c576c29d953e84/scikit_learn-1.7.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0b7dacaa05e5d76759fb071558a8b5130f4845166d88654a0f9bdf3eb57851b7", size = 9212382, upload-time = "2025-09-09T08:20:54.731Z" }, + { url = "https://files.pythonhosted.org/packages/40/dd/9a88879b0c1104259136146e4742026b52df8540c39fec21a6383f8292c7/scikit_learn-1.7.2-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:abebbd61ad9e1deed54cca45caea8ad5f79e1b93173dece40bb8e0c658dbe6fe", size = 8592042, upload-time = "2025-09-09T08:20:57.313Z" }, + { url = "https://files.pythonhosted.org/packages/46/af/c5e286471b7d10871b811b72ae794ac5fe2989c0a2df07f0ec723030f5f5/scikit_learn-1.7.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:502c18e39849c0ea1a5d681af1dbcf15f6cce601aebb657aabbfe84133c1907f", size = 9434180, upload-time = "2025-09-09T08:20:59.671Z" }, + { url = "https://files.pythonhosted.org/packages/f1/fd/df59faa53312d585023b2da27e866524ffb8faf87a68516c23896c718320/scikit_learn-1.7.2-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a4c328a71785382fe3fe676a9ecf2c86189249beff90bf85e22bdb7efaf9ae0", size = 9283660, upload-time = "2025-09-09T08:21:01.71Z" }, + { url = "https://files.pythonhosted.org/packages/a7/c7/03000262759d7b6f38c836ff9d512f438a70d8a8ddae68ee80de72dcfb63/scikit_learn-1.7.2-cp313-cp313-win_amd64.whl", hash = "sha256:63a9afd6f7b229aad94618c01c252ce9e6fa97918c5ca19c9a17a087d819440c", size = 8702057, upload-time = "2025-09-09T08:21:04.234Z" }, + { url = "https://files.pythonhosted.org/packages/55/87/ef5eb1f267084532c8e4aef98a28b6ffe7425acbfd64b5e2f2e066bc29b3/scikit_learn-1.7.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:9acb6c5e867447b4e1390930e3944a005e2cb115922e693c08a323421a6966e8", size = 9558731, upload-time = "2025-09-09T08:21:06.381Z" }, + { url = "https://files.pythonhosted.org/packages/93/f8/6c1e3fc14b10118068d7938878a9f3f4e6d7b74a8ddb1e5bed65159ccda8/scikit_learn-1.7.2-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:2a41e2a0ef45063e654152ec9d8bcfc39f7afce35b08902bfe290c2498a67a6a", size = 9038852, upload-time = "2025-09-09T08:21:08.628Z" }, + { url = "https://files.pythonhosted.org/packages/83/87/066cafc896ee540c34becf95d30375fe5cbe93c3b75a0ee9aa852cd60021/scikit_learn-1.7.2-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:98335fb98509b73385b3ab2bd0639b1f610541d3988ee675c670371d6a87aa7c", size = 9527094, upload-time = "2025-09-09T08:21:11.486Z" }, + { url = "https://files.pythonhosted.org/packages/9c/2b/4903e1ccafa1f6453b1ab78413938c8800633988c838aa0be386cbb33072/scikit_learn-1.7.2-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:191e5550980d45449126e23ed1d5e9e24b2c68329ee1f691a3987476e115e09c", size = 9367436, upload-time = "2025-09-09T08:21:13.602Z" }, + { url = "https://files.pythonhosted.org/packages/b5/aa/8444be3cfb10451617ff9d177b3c190288f4563e6c50ff02728be67ad094/scikit_learn-1.7.2-cp313-cp313t-win_amd64.whl", hash = "sha256:57dc4deb1d3762c75d685507fbd0bc17160144b2f2ba4ccea5dc285ab0d0e973", size = 9275749, upload-time = "2025-09-09T08:21:15.96Z" }, + { url = "https://files.pythonhosted.org/packages/d9/82/dee5acf66837852e8e68df6d8d3a6cb22d3df997b733b032f513d95205b7/scikit_learn-1.7.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fa8f63940e29c82d1e67a45d5297bdebbcb585f5a5a50c4914cc2e852ab77f33", size = 9208906, upload-time = "2025-09-09T08:21:18.557Z" }, + { url = "https://files.pythonhosted.org/packages/3c/30/9029e54e17b87cb7d50d51a5926429c683d5b4c1732f0507a6c3bed9bf65/scikit_learn-1.7.2-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:f95dc55b7902b91331fa4e5845dd5bde0580c9cd9612b1b2791b7e80c3d32615", size = 8627836, upload-time = "2025-09-09T08:21:20.695Z" }, + { url = "https://files.pythonhosted.org/packages/60/18/4a52c635c71b536879f4b971c2cedf32c35ee78f48367885ed8025d1f7ee/scikit_learn-1.7.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9656e4a53e54578ad10a434dc1f993330568cfee176dff07112b8785fb413106", size = 9426236, upload-time = "2025-09-09T08:21:22.645Z" }, + { url = "https://files.pythonhosted.org/packages/99/7e/290362f6ab582128c53445458a5befd471ed1ea37953d5bcf80604619250/scikit_learn-1.7.2-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96dc05a854add0e50d3f47a1ef21a10a595016da5b007c7d9cd9d0bffd1fcc61", size = 9312593, upload-time = "2025-09-09T08:21:24.65Z" }, + { url = "https://files.pythonhosted.org/packages/8e/87/24f541b6d62b1794939ae6422f8023703bbf6900378b2b34e0b4384dfefd/scikit_learn-1.7.2-cp314-cp314-win_amd64.whl", hash = "sha256:bb24510ed3f9f61476181e4db51ce801e2ba37541def12dc9333b946fc7a9cf8", size = 8820007, upload-time = "2025-09-09T08:21:26.713Z" }, +] + [[package]] name = "scipy" version = "1.16.3"